MEGA65: implement DMA fractional initial addresses

First try to implement the enhanced mode DMA list options $91 and $92 as
described here: MEGA65/mega65-core#903

[DEPLOYMENT]

Author: lgblgblgb

targets/mega65/dma65.c

@@ -80,6 +80,7 @@ struct ldm_st {
 // source and target DMA "channels":
 static struct dma_channel_st {
 	int   addr;		// address of the current operation, it's a fixed-point math value
+	Uint8 addr_fract;	// address fractional part, used during transition from DMA info fetch and starting the actual DMA, but not during the DMA (will be low byte of "addr", fixed point math!)
 	int   base;		// base address for "addr", always a "pure" number! It also contains the "megabyte selection", pre-shifted by << 20
 	int   step;		// step value, zero(HOLD)/negative/positive, this is a fixed point arithmetic value!!
 	Uint8 step_fract;	// step value during option read, fractional part only
@@ -345,6 +346,8 @@ void dma_write_reg ( int addr, Uint8 data )
 	source.mbyte = 0;			// source MB
 	target.mbyte = 0;			// target MB
 	length_byte3 = 0;			// length byte for >=64K DMA sessions
+	source.addr_fract = 0;
+	target.addr_fract = 0;
 	// zero out LDM-specific options by default
 	memset(&source.ldm, 0, sizeof source.ldm);
 	memset(&target.ldm, 0, sizeof target.ldm);
@@ -466,6 +469,12 @@ int dma_update ( void )
 					case 0x90:	// extra high byte of DMA length (bits 23-16) to allow to have >64K DMA
 						length_byte3 = optval;
 						break;
+					case 0x91:	// set initial fractional part of the source
+						source.addr_fract = optval;
+						break;
+					case 0x92:	// set initial fractional part of the target
+						target.addr_fract = optval;
+						break;
 					case 0x97:	// DMA line drawing mode SOURCE - X col (LSB)
 						source.ldm.x_col = (source.ldm.x_col & 0xFF0000U) + (optval <<  8);	// Xemu integer + 8 bit fractional part arithmetic!
 						break;
@@ -609,13 +618,13 @@ int dma_update ( void )
 		    source.base = ((source.mbyte << 20) + (source.addr & 0x700000)) & 0xFF00000;
 		else
 		    source.base = source.mbyte << 20;
-		source.addr	= (source.addr & 0x0FFFFF) << 8;// offset from base, for M65 this *IS* fixed point arithmetic!
+		source.addr	= ((source.addr & 0x0FFFFF) << 8) + source.addr_fract;	// offset from base, for M65 this *IS* fixed point arithmetic!
 		/* -- target selection -- see similar lines with comments above, for source ... */
 		if (session_revision)
 		    target.base = ((target.mbyte << 20) + (target.addr & 0x700000)) & 0xFF00000;
 		else
 		    target.base = target.mbyte << 20;
-		target.addr	= (target.addr & 0x0FFFFF) << 8;
+		target.addr	= ((target.addr & 0x0FFFFF) << 8) + target.addr_fract;
 		/* other stuff */
 		chained = (command & 4);
 		// FIXME: this is a debug mesg, yeah, but with fractional step on M65, the step values needs to be interpreted with keep in mind the fixed point math ...
@@ -678,6 +687,17 @@ int dma_update ( void )
 		if (chained) {			// chained?
 			DEBUGDMA("DMA: end of operation, but chained!" NL);
 			in_dma = 0x81;	// still busy then, with also bit0 set (chained)
+#if 0
+			// In case of chained DMA, fractonal part is carried over from the last state
+			// TODO: do we need this? As far as I can tell from the VHDL, we don't. So let's delete this part, if I am sure.
+			source.addr_fract = source.addr & 0xFF;
+			target.addr_fract = target.addr & 0xFF;
+#else
+			source.addr_fract = 0;
+			target.addr_fract = 0;
+#endif
+			// TODO/FIXME: I should really overview if any param should be reset here, like fractional stepping, byte3 of length, etc ...
+			// To put it into another way: enhanced mode options are "sticky" and always remaining for the chained sessions?
 		} else {
 			DEBUGDMA("DMA: end of operation, no chained next one." NL);
 			in_dma = 0;		// end of DMA command