blog:commodore_c65_dtv_programming

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revision Previous revision
Next revision		 Previous revision
blog:commodore_c65_dtv_programming [2023/01/23 22:14] – [Basic DTV Functions] johnblog:commodore_c65_dtv_programming [2023/01/25 17:21] (current) – [Extended DTV Functions] john
Line 1: Line 1:
 ====== DTV (and C64) Programming - Using the CC65 toolchain ====== ====== DTV (and C64) Programming - Using the CC65 toolchain ======
  
 +~~TOC_HERE 2-5~~ 
 +
 +From [[https://en.wikipedia.org/wiki/C64_Direct-to-TV|Wikipedia]]:
 +
 +> The C64 Direct-to-TV, called C64DTV for short, is a single-chip implementation of the Commodore 64 computer, contained in a joystick (modeled after the mid-1980s Competition Pro
 +> joystick), with 30 built-in games. The design is similar to the Atari Classics 10-in-1 TV Game. The circuitry of the C64DTV was designed by Jeri Ellsworth, a computer chip designer who
 +> had previously designed the C-One.
 +
 +These are my notes on programming for the C64 DTV and making use of some of the extended functionality of the hardware from within C, rather than 6502 assembly. I hope you find these useful - whilst I came to the DTV more than a decade after its popularity peaked, I've found it a very capable little system!
 +
 +{{:blog:c64:commodore64_dtv_mugshot-x600.jpg?200|}}
 ===== Basic use of CC65 ===== ===== Basic use of CC65 =====
  
Line 205: Line 216:
  
 ---- ----
 +
 +==== Extended DTV Functions ====
 +
 +These functions raise the DTV above a simple C64 clone and add substantially improved functionality to the system: increased colours, digital sound and a dedicated image blitter.
  
 === Enabling 320x200 Linear Framebuffer === === Enabling 320x200 Linear Framebuffer ===
Line 298: Line 313:
 <code C> <code C>
 // DTV registers which can toggle extended features on/off // DTV registers which can toggle extended features on/off
-#define DTV_VIC_REG_CONTROL_1 0xD011 +#define DTV_VIC_REG_CONTROL_1 0xD011 
-#define DTV_VIC_REG_CONTROL_2 0xD016 +#define DTV_VIC_REG_CONTROL_2 0xD016 
-#define DTV_VIC_REG_BORDER 0xD020 // Border pen colour +#define DTV_VIC_REG_BORDER 0xD020 // Border pen colour 
-#define DTV_VIC_REG_BG_0 0xD021 // BG pen colour +#define DTV_VIC_REG_BG_0 0xD021 // BG pen colour 
-#define DTV_VIC_REG_CFG 0xD03C // Controls linear framebuffer mode amongst other settings +#define DTV_VIC_REG_CFG 0xD03C // Controls linear framebuffer mode amongst other settings 
-#define DTV_VIC_REG_EXTENDED 0xD03F // Enables/disabled DTV extended feature set +#define DTV_VIC_REG_EXTENDED 0xD03F // Enables/disabled DTV extended feature set 
-#define DTV_VIC_REG_LFB_START_LOW 0xD049 // Linear framebuffer address low byte +#define DTV_VIC_REG_LFB_START_LOW 0xD049 // Linear framebuffer address low byte 
-#define DTV_VIC_REG_LFB_START_MED 0xD04A // Linear framebuffer address middle byte +#define DTV_VIC_REG_LFB_START_MED 0xD04A // Linear framebuffer address middle byte 
-#define DTV_VIC_REG_LFB_START_HI 0xD04B // Linear framebuffer address high byte +#define DTV_VIC_REG_LFB_START_HI 0xD04B // Linear framebuffer address high byte 
-#define DTV_VIC_REG_LFB_STEPSIZE 0xD04C // Linear framebuffer chunk size, 8 == 8bpp +#define DTV_VIC_REG_LFB_STEPSIZE 0xD04C // Linear framebuffer chunk size, 8 == 8bpp 
-#define DTV_VIC_PALETTE 0xD200 // Start address of palette entries +#define DTV_VIC_PALETTE 0xD200 // Start address of palette entries 
-#define DMA_PORT_SOURCE_LOW 0xD300 // DMA transfer source address low byte +// DMA registers 
-#define DMA_PORT_SOURCE_MED 0xD301 // DMA transfer source address middle byte +#define DMA_PORT_SOURCE_LOW 0xD300 // DMA transfer source address low byte 
-#define DMA_PORT_SOURCE_HI 0xD302 // DMA transfer source address high byte +#define DMA_PORT_SOURCE_MED 0xD301 // DMA transfer source address middle byte 
-#define DMA_PORT_DEST_LOW 0xD303 // DMA transfer destination address low byte +#define DMA_PORT_SOURCE_HI 0xD302 // DMA transfer source address high byte 
-#define DMA_PORT_DEST_MED 0xD304 // DMA transfer destination address middle byte +#define DMA_PORT_DEST_LOW 0xD303 // DMA transfer destination address low byte 
-#define DMA_PORT_DEST_HI 0xD305 // DMA transfer destination address high byte +#define DMA_PORT_DEST_MED 0xD304 // DMA transfer destination address middle byte 
-#define DMA_PORT_SOURCE_STEP_LOW 0xD306 // DMA transfer step size low byte +#define DMA_PORT_DEST_HI 0xD305 // DMA transfer destination address high byte 
-#define DMA_PORT_SOURCE_STEP_HI 0xD307 // DMA transfer step size high byte +#define DMA_PORT_SOURCE_STEP_LOW 0xD306 // DMA transfer step size low byte 
-#define DMA_PORT_DEST_STEP_LOW 0xD308 // DMA transfer step size low byte +#define DMA_PORT_SOURCE_STEP_HI 0xD307 // DMA transfer step size high byte 
-#define DMA_PORT_DEST_STEP_HI 0xD309 // DMA transfer step size high byte +#define DMA_PORT_DEST_STEP_LOW 0xD308 // DMA transfer step size low byte 
-#define DMA_PORT_SIZE_LOW 0xD30A // DMA transfer length low byte +#define DMA_PORT_DEST_STEP_HI 0xD309 // DMA transfer step size high byte 
-#define DMA_PORT_SIZE_HI 0xD30B // DMA transfer length high byte +#define DMA_PORT_SIZE_LOW 0xD30A // DMA transfer size (bytes) low byte 
-#define DMA_PORT_STATUS 0xD31F // DMA status & control register+#define DMA_PORT_SIZE_HI 0xD30B // DMA transfer size (bytes) high byte 
 +#define DMA_PORT_SOURCE_MODULO_LOW 0xD30C 
 +#define DMA_PORT_SOURCE_MODULO_HI 0xD30D 
 +#define DMA_PORT_DEST_MODULO_LOW 0xD30E 
 +#define DMA_PORT_DEST_MODULO_HI 0xD30F 
 +#define DMA_PORT_SOURCE_LENGTH_LOW 0xD310 
 +#define DMA_PORT_SOURCE_LENGTH_HI 0xD311 
 +#define DMA_PORT_DEST_LENGTH_LOW 0xD312 
 +#define DMA_PORT_DEST_LENGTH_HI 0xD313 
 +#define DMA_PORT_CLEAR_IRQ 0xD31D 
 +#define DMA_PORT_MODULO_ENABLE 0xD31E 
 +#define DMA_PORT_STATUS 0xD31F // DMA status & control register 
 +// Blitter registers 
 +#define BLITTER_SOURCE_A_LOW 0xD320 // Blitter source A address, low byte 
 +#define BLITTER_SOURCE_A_MED 0xD321 // Blitter source A address, middle byte 
 +#define BLITTER_SOURCE_A_HI 0xD322 // Blitter source A address, high byte 
 +#define BLITTER_SOURCE_A_MODULO_LOW 0xD323 // Blitter source A line modulo, high byte 
 +#define BLITTER_SOURCE_A_MODULO_HI 0xD324 // Blitter source A line modulo, high byte 
 +#define BLITTER_SOURCE_A_LENGTH_LOW 0xD325 // Lenth of one line of pixels of source A, low byte 
 +#define BLITTER_SOURCE_A_LENGTH_HI 0xD326 // Lenth of one line of pixels of source A, high byte 
 +#define BLITTER_SOURCE_A_STEP 0xD327 
 +#define BLITTER_SOURCE_B_LOW 0xD328 // Blitter source B address, low byte 
 +#define BLITTER_SOURCE_B_MED 0xD329 // Blitter source B address, middle byte 
 +#define BLITTER_SOURCE_B_HI 0xD32A // Blitter source B address, high byte 
 +#define BLITTER_SOURCE_B_MODULO_LOW 0xD32B // Blitter source B line modulo, low byte 
 +#define BLITTER_SOURCE_B_MODULO_HI 0xD32C // Blitter source B line modulo, high byte 
 +#define BLITTER_SOURCE_B_LENGTH_LOW 0xD32D // Lenth of one line of pixels of source B, low byte 
 +#define BLITTER_SOURCE_B_LENGTH_HI 0xD32E // Lenth of one line of pixels of source B, high byte 
 +#define BLITTER_SOURCE_B_STEP 0xD32F 
 +#define BLITTER_DEST_LOW 0xD330 // Blitter desintation address, low byte 
 +#define BLITTER_DEST_MED 0xD331 // Blitter desintation address, middle byte 
 +#define BLITTER_DEST_HI 0xD332 // Blitter desintation address, high byte 
 +#define BLITTER_DEST_MODULO_LOW 0xD333 // Blitter destination line modulo, low byte 
 +#define BLITTER_DEST_MODULO_HI 0xD334 // Blitter destination line modulo, high byte 
 +#define BLITTER_DEST_LENGTH_LOW 0xD335 // Lenth of one line of pixels of destination, low byte 
 +#define BLITTER_DEST_LENGTH_HI 0xD336 // Lenth of one line of pixels of destination, high byte 
 +#define BLITTER_DEST_STEP 0xD337 
 +#define BLITTER_SIZE_LOW 0xD338 // Blitter copy size (bytes), low byte 
 +#define BLITTER_SIZE_HI 0xD339 // Blitter copy size (bytes), high byte 
 +#define BLITTER_START 0xD33A 
 +#define BLITTER_CFG 0xD33B // 
 +#define BLITTER_MINTERM_CFG 0xD33E // Sets operation mode of blitter 
 +#define BLITTER_STATUS 0xD33F
 </code> </code>
  
Line 391: Line 448:
 </code> </code>
  
-Here are a couple of functions which fill an off-screen scratchpad with a solid colour, and then copies the entire 320x200 scratchpad to the linear framebuffer using the** dtv_dma()** function above:+Here are a couple of functions (**draw_Clear()** & **draw_Flip()**) which can fill an off-screen scratchpad with a solid colour, and then copies the entire 320x200 scratchpad to the linear framebuffer using the** dtv_dma()** function above:
  
 <code C> <code C>
Line 399: Line 456:
  
 void draw_Clear(void){ void draw_Clear(void){
- // Clear the contents of the screen buffer with a solid colour+ // Clear the contents of the screen buffer with a solid colour, line by line
   
  unsigned char i;  unsigned char i;
Line 418: Line 475:
 } }
 </code> </code>
 +
 +== Bugs ==
 +
 +I've seemingly found a bug which manifests when making sequential DMA calls in a tight loop and the transfer length is 182 bytes or greater. 
 +
 +You can successfully DMA copy quite a large region in a single operation and there are no side-effects, however in my testing I have found that if you have a tight loop where you are DMA transferring line by line, I get corrupted transfers with any size over 181 bytes. See the example below:
 +
 +{{:blog:c64:vice_dtv_256_speed2x.png?400|}}
 +
 +The colour bars in the image should be continuous for the entire screen width, but they glitch at two points.
 +The above example was generated by the following pseudocode:
 +
 +<code>
 +screen = FRAMEBUFFER_LOCATION;
 +for (line = 0; line < SCREEN_HEIGHT; line++){
 +    memset(line_buffer, colour, SCREEN_WIDTH);
 +    dtv_DMA(&line_buffer, screen, SCREEN_WIDTH);
 +    colour++;
 +    screen += SCREEN_WIDTH;
 +}
 +</code>
 +
 +If you reduce the transfer size to 181 bytes you do not get the glitching, and if you have a //reasonable-number-of-cycles// between DMA operations you also don't get the glitching... but I don't know what that //reasonable-number-of-cycles// value is. It's clearly a timing issue between DMA operations - due to the time it takes for transfers over a centre number of bytes, but all I know is that the documentation says that checking bit 0 of 0xD31F should indicate whether the transfer has finished or not. It's possible (though unlikely) that this is an emulation bug - until I have a working, physical DTV, I won't be able to confirm.
 +
 +----
 +
 +=== Blitter Operation ===
 +
 +One of the big features of the DTV2 & 3 is the addition of [[https://en.wikipedia.org/wiki/Blitter|blitter hardware]]. This dramatically speeds up transfer of memory and can be used to achieve very high speed image/screen manipulation.
 +
 +The Blitter documentation is extensive, with dozens of different registers to set and configure. However, in most circumstances you will want to copy one solid block of pixels to another area (either on-screen or off - the blitter works over the entire 0-2048kb memory region, but //not// ROM).
 +
 +Here I show a variation of the blitter command to transfer w x h pixels from src to dest.
 +
 +   * **src**: address of the upper-left pixel of a rectangular block of source pixels
 +   * **dst**: address of the upper-left pixel of the destination area.
 +   * **w**: width of the source area to copy in pixels
 +   * **h**: number of lines of the source area to copy
 +
 +The source area is OR-ed with the destination and transparency in the source area is honoured (source pixels with value //0// will //not// overwrite pixels in the destination).
 +
 +**dtv_Blit()**
 +
 +<code C>
 +#include <stdint.h>
 +#include <accelerator.h>
 +#include "dtv.h"
 +#include "dtv_reg.h"
 +
 +void dtv_Blit(uint32_t src, uint32_t dst, uint16_t w, unsigned char h){
 + // Blit 'width * height' bytes of data from 'src' to 'dst' in high memory
 + // using the blitter engine.
 + //
 + // 'src' is the address to copy from - it is NOT pointers
 + // 'dst' is the destination address - it is not a pointer
 + // 'w' is the width of the source rectangle, in pixels/bytes
 + // 'h' is the height of the source rectangle, in pixels/bytes
 +
 + uint16_t total_bytes = w * h;
 + uint16_t modulus = SCREEN_WIDTH - w;
 +
 + // ==================================
 + // Source address
 + // ==================================
 + POKE(BLITTER_SOURCE_A_LOW, src);
 + POKE(BLITTER_SOURCE_A_MED, src >> 8);
 + POKE(BLITTER_SOURCE_A_HI, src >> 16);
 +
 + // ==================================
 + // Destination address
 + // ==================================
 + POKE(BLITTER_DEST_LOW, dst);
 + POKE(BLITTER_DEST_MED, dst >> 8);
 + POKE(BLITTER_DEST_HI, dst >> 16);
 +
 + // ==================================
 + // Set line length
 + // ==================================
 + POKE(BLITTER_SOURCE_A_LENGTH_LOW, w);
 + POKE(BLITTER_SOURCE_A_LENGTH_HI, w >> 8);
 + POKE(BLITTER_DEST_LENGTH_LOW, w);
 + POKE(BLITTER_DEST_LENGTH_HI, w >> 8);
 +
 + // ==================================
 + // Set modulus/wraparound
 + // ==================================
 + POKE(BLITTER_SOURCE_A_MODULO_LOW, modulus); 
 + POKE(BLITTER_SOURCE_A_MODULO_HI, modulus >> 8);
 + POKE(BLITTER_DEST_MODULO_LOW, modulus); 
 + POKE(BLITTER_DEST_MODULO_HI, modulus >> 8);
 +
 + // ==================================
 + // Step sizes
 + // ==================================
 + POKE(BLITTER_SOURCE_A_STEP, 0x10);
 + POKE(BLITTER_DEST_STEP, 0x10);
 +
 + // ==================================
 + // Set total transfer size
 + // ==================================
 + POKE(BLITTER_SIZE_LOW, total_bytes);
 + POKE(BLITTER_SIZE_HI, total_bytes >> 8);
 +
 + // ==================================
 + // Configure blitter mode and start blit
 + // ==================================
 + POKE(BLITTER_CFG, 0x04); // Enable transparency, if supported by blitter
 + POKE(BLITTER_MINTERM_CFG, 0x18); // OR the source with destination
 + POKE(BLITTER_START, 0x0B);
 +}
 +</code>
 +
 +Here's an example of the blitter function in operation, copying a **100x100** rectangle of pixels from the source position of **1,1** to the destination at **219,100**:
 +
 +This is the source image - a basic set of colour bars:
 +
 +{{:blog:c64:c64_dtv_blitter_example_source.png?400|}}
 +
 +Using dtv_Blit() we copy from 1,1 to 219,100 a 100x100 rectangle in OR mode:
 +
 +{{:blog:c64:c64_dtv_blitter_example_dtv3.png?400|}}
 +
 +Notice that the transparent (aka //black//) pixels in the source region are preserved when copying to the destination, and that the original content of the destination is preserved for those areas. Where the source is not transparent, those pixels then overwrite the destination. The mode of operation can be customised - see the [[https://www.c64-wiki.com/wiki/C64DTV_Programming_Guide#BLITTER_DATAPATH|DTV Programming Guide]] for more details; specifically the ALU mode set for register **0xD33E**.
 +
 +== Bugs ==
 +
 +However, there is a problem. On the **DTV2** systems (the initial PAL models), the blitter is partially bugged and transparent copies result int a vertical banding effect:
 +
 +{{:blog:c64:c64_dtv_blitter_example_dtv2.png?400|}}
 +
 +Therefore, //without mitigation//, only **DTV3/Hummer** systems fully support transparent blits. If you are //not// bothered about transparency, then the blitter functions fine on DTV2, but to support transparency you need to do some type of workaround.
  • blog/commodore_c65_dtv_programming.1674512093.txt.gz
  • Last modified: 2023/01/23 22:14
  • by john