/*  * Generate a VGA signal using a PIC32 microcontroller.  *  * Copyright (C) 2017, 2018 Paul Boddie <paul@boddie.org.uk>  *  * This program is free software: you can redistribute it and/or modify  * it under the terms of the GNU General Public License as published by  * the Free Software Foundation, either version 3 of the License, or  * (at your option) any later version.  *  * This program is distributed in the hope that it will be useful,  * but WITHOUT ANY WARRANTY; without even the implied warranty of  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the  * GNU General Public License for more details.  *  * You should have received a copy of the GNU General Public License  * along with this program.  If not, see <http://www.gnu.org/licenses/>.  */  #include "pic32_c.h" #include "init.h" #include "vga_display.h"    /* Display state. */  vga_display_t vga_display;  /* Pixel data. */  static const int ZERO_LENGTH = 1; static const uint8_t zerodata[1] = {0};    /* Initialise the state machine. */  void init_vga(display_config_t *display_config, int line_channels,               int line_timer, int transfer_int_num) {     /* Display parameters. */      vga_display.display_config = display_config;     vga_display.line_channels = line_channels;      /* Initial state. */      vga_display.state_handler = vbp_active;     vga_display.line = 0;      /* Configure a general display timer to start line data transfer and for the        horizontal sync. */      vga_display.line_timer = line_timer;      /* Configure a separate transfer interrupt condition, if indicated.        Otherwise, transfers are initiated by the line timer. */      vga_display.transfer_int_num = transfer_int_num;      /* Update the addresses used for the display. */      vga_set_frame(display_config); }  /* Initialise a separate transfer timer if different from the general display    timer. */  void init_vga_with_timers(display_config_t *display_config, int line_channels,                           int line_timer, int transfer_timer) {     /* Initialise the basic properties of the display. */      init_vga(display_config, line_channels, line_timer,              transfer_timer ? timer_interrupt_number(transfer_timer) : -1);      /* Configure a line timer for horizontal sync and line data transfers. */      /* The timers have no prescaling (0). */      timer_init(line_timer, 0, display_config->hfreq_limit);      /* Enable interrupt requests when the CPU needs to perform the transfer, as        opposed to the DMA channels doing so. */      if (!line_channels)         timer_init_interrupt(line_timer, 7, 3);      timer_on(line_timer);      /* Configure a separate transfer timer, if indicated. */      if (!line_channels || !transfer_timer || (transfer_timer == line_timer))         return;      /* The timer wraps around immediately. */      timer_init(transfer_timer, 0, 1);     timer_on(transfer_timer); }    /* Configure the transfer of pixel data. */  void vga_configure_transfer(uint32_t output) {     vga_display.output = output;      if (vga_display.line_channels)         vga_configure_dma_transfer(output); }  /* Configure DMA channels for the transfer of pixel data. */  void vga_configure_dma_transfer(uint32_t output) {     int dual_channel = vga_display.line_channels == 2;     int channel = 0;      /* Determine whether an initiating channel is used. */      int initiating_channel = vga_display.transfer_int_num >= 0;      /* Determine the different interrupt conditions, with pixel data employing        any specified transfer condition or the line condition otherwise. */      int line_int_num = timer_interrupt_number(vga_display.line_timer);     int transfer_int_num = initiating_channel ?                                vga_display.transfer_int_num : line_int_num;      /* Where dual line channels are involved, put the first before any        initiating channel, chaining it to such a channel. */      if (dual_channel)     {         vga_configure_line_channel(channel++, transfer_int_num,             initiating_channel ? dma_chain_next : dma_chain_none,             output);     }      /* Introduce a special initiating channel if a separate transfer interrupt        has been indicated. */      if (initiating_channel)     {         vga_configure_zero_channel(channel++, line_int_num, 1, output);     }      /* A line channel is always configured, chaining it to any initiating        channel. */      vga_configure_line_channel(channel++, transfer_int_num,         initiating_channel ? dma_chain_previous : dma_chain_none,         output);      /* A zero channel is always configured, chaining it to the preceding line        channel, with the same transfer interrupt initiating the transfer. */      vga_configure_zero_channel(channel, transfer_int_num, 0, output); }  void vga_configure_line_channel(int channel, int int_num, enum dma_chain chain,                                 uint32_t output) {     dma_init(channel, 2);      /* If initiating, configure to always be enabled. */      if (chain == dma_chain_none)         dma_set_auto_enable(channel, 1);      /* Chain to either the previous or next channel where a special initiating        channel is used. */      else         dma_set_chaining(channel, chain);      /* Initiate DMA on the transfer interrupt, transferring line data to the        first byte of the output word. */      dma_set_interrupt(channel, int_num, 1);      dma_set_destination(channel, HW_PHYSICAL(output), 1);     dma_set_cell(channel, vga_display.display_config->transfer_cell_size); }  void vga_configure_zero_channel(int channel, int int_num, int initiating,                                 uint32_t output) {     dma_init(channel, 3);      /* If initiating, configure to always be enabled. */      if (initiating)         dma_set_auto_enable(channel, 1);      /* Otherwise, chain to the preceding channel and register prior transfer        events before the channel is activated. */      else     {         dma_set_chaining(channel, dma_chain_previous);         dma_set_receive_events(channel, 1);     }      /* Transfer upon the indicated interrupt condition. */      dma_set_interrupt(channel, int_num, 1);     dma_set_transfer(channel, PHYSICAL((uint32_t) zerodata),                               ZERO_LENGTH,                               HW_PHYSICAL(output), 1,                               ZERO_LENGTH); }  /* Configure output compare units for horizontal and vertical sync. */  void vga_configure_sync(int hsync_unit, int vsync_unit) {     /* Record the peripherals in use. */      vga_display.hsync_unit = hsync_unit;     vga_display.vsync_unit = vsync_unit;      /* Horizontal sync. */      /* Configure output compare in dual compare (continuous output) mode using        the timer as time base. The interrupt condition drives the first DMA        channel and is handled to drive the display state machine. */      oc_init(hsync_unit, 0b101, vga_display.line_timer);     oc_set_pulse(hsync_unit, vga_display.display_config->hsync_end);     oc_set_pulse_end(hsync_unit, vga_display.display_config->hsync_start);     oc_init_interrupt(hsync_unit, 7, 3);     oc_on(hsync_unit);      /* Vertical sync. */      /* Configure output compare in single compare (output driven low) mode using        the timer as time base. The unit is enabled later. It is only really used        to achieve precisely-timed level transitions in hardware. */      oc_init(vsync_unit, 0b010, vga_display.line_timer);     oc_set_pulse(vsync_unit, 0); }    /* Update the display addresses from the general display configuration. */  void vga_set_frame(display_config_t *display_config) {     vga_wait_visible();      vga_display.screen_start = display_config->screen_start;     vga_display.screen_limit = display_config->screen_limit;     vga_display.screen_size = display_config->screen_size; }  /* Wait for the visible region to be completed. */  void vga_wait_visible(void) {     while (((volatile void (*)()) vga_display.state_handler) == visible_active)         __asm__ __volatile__("wait"); }    /* Display state machine interrupt handler. */  void vga_interrupt_handler(void) {     uint32_t ifs;      if (!vga_display.line_channels)     {         /* Check for a timer interrupt condition. */              ifs = REG(TIMERIFS) & TIMER_INT_FLAGS(vga_display.line_timer, TxIF);              if (ifs)         {                vga_transfer_interrupt_handler();             CLR_REG(TIMERIFS, ifs);         }     }          /* Check for a OC1 interrupt condition. */          ifs = REG(OCIFS) & OC_INT_FLAGS(1, OCxIF);          if (ifs)     {            vga_hsync_interrupt_handler();         CLR_REG(OCIFS, ifs);     }  }  /* Display state machine interrupt handler. */  void vga_hsync_interrupt_handler(void) {     vga_display.line += 1;     vga_display.state_handler(); }  /* Visible region pixel output handler, used when the CPU is responsible for    producing pixel output rather than the DMA channels. */  void vga_transfer_interrupt_handler(void) {     display_config_t *cfg = vga_display.display_config;     uint8_t *current, *end, *output;      if (vga_display.state_handler != visible_active)         return;      /* Generate the pixel signal. */      output = (uint8_t *) vga_display.output;     end = vga_display.linedata + cfg->line_length;      /* This is potentially not as efficient as loading words and shifting bytes        but it appears difficult to implement that approach without experiencing        data load exceptions. */      for (current = vga_display.linedata; current < end; current++)         REG(output) = *current;      /* Reset the signal level. */      REG(output) = 0; }    /* Vertical back porch region. */  void vbp_active(void) {     if (vga_display.line < vga_display.display_config->visible_start)         return;      /* Enter the visible region. */      vga_display.state_handler = visible_active;      /* Set the line address. */      vga_display.linedata = vga_display.screen_start;      if (vga_display.line_channels)         start_visible(); }  /* Visible region. */  void visible_active(void) {     display_config_t *cfg = vga_display.display_config;      if (vga_display.line < cfg->vfp_start)     {         /* Update the line address and handle wraparound. */          if (!(vga_display.line % cfg->line_multiplier))         {             vga_display.linedata += cfg->line_length;              if (vga_display.linedata >= vga_display.screen_limit)                 vga_display.linedata -= vga_display.screen_size;         }          if (vga_display.line_channels)             update_visible();         return;     }      /* End the visible region. */      vga_display.state_handler = vfp_active;      /* Disable the channel for the next line. */      if (vga_display.line_channels)         stop_visible(); }  /* Vertical front porch region. */  void vfp_active(void) {     if (vga_display.line < vga_display.display_config->vsync_start)         return;      /* Enter the vertical sync region. */      vga_display.state_handler = vsync_active;      /* Bring vsync low when the next line starts. */      vsync_low(); }  /* Vertical sync region. */  void vsync_active(void) {     if (vga_display.line < vga_display.display_config->vsync_end)         return;      /* Start again at the top of the display. */      vga_display.line = 0;     vga_display.state_handler = vbp_active;      /* Bring vsync high when the next line starts. */      vsync_high(); }    /* Enable the channels for the next line. */  void start_visible(void) {     update_visible();     update_transfers(1); }  /* Update the channels for the next line. */  void update_visible(void) {     uint32_t transfer_start = (uint32_t) vga_display.linedata;     uint32_t transfer_length = vga_display.display_config->line_length /                                vga_display.line_channels;      /* Determine whether an initiating channel is used. */      int initiating_channel = vga_display.transfer_int_num >= 0;     int channel = 0;      /* Update the source of a secondary line channel. */      if (vga_display.line_channels == 2)     {         dma_set_source(channel, PHYSICAL(transfer_start), transfer_length);         transfer_start += transfer_length;         channel++;     }      /* Skip any initiating channel. */      if (initiating_channel)         channel++;      /* Update the source of a line channel, with potentially updated start        address. */      dma_set_source(channel, PHYSICAL(transfer_start), transfer_length); }  /* Disable the channels for the next line. */  void stop_visible(void) {     update_transfers(0); }  /* Enable or disable transfers. */  void update_transfers(int enable) {     void (*fn)() = enable ? dma_on : dma_off;      /* Determine whether an initiating channel is used. */      int initiating_channel = vga_display.transfer_int_num >= 0;     int channel = 0;      /* Update line channels if no initiating channel is used. */      if (vga_display.line_channels == 2)     {         if (!initiating_channel)             fn(channel);         channel++;     }      /* Update any initiating channel. */      if (initiating_channel)     {         fn(channel);         channel++;     }      /* Update line channels if no initiating channel is used. */      if (!initiating_channel)         fn(channel); }    /* Bring vsync low (single compare, output driven low) when the next line    starts. */  void vsync_low(void) {     oc_init(vga_display.vsync_unit, 0b010, vga_display.line_timer);     oc_on(vga_display.vsync_unit); }  /* Bring vsync high (single compare, output driven high) when the next line    starts. */  void vsync_high(void) {     oc_init(vga_display.vsync_unit, 0b001, vga_display.line_timer);     oc_on(vga_display.vsync_unit); }