Checking in the latest broken DMA code.

examples/cube/sin.c

@@ -0,0 +1,22 @@
+#include <stdio.h>
+#include <math.h>
+#include <stdint.h>
+
+#define FIX_PREC 9
+#define TO_FIX(x) ((int32_t)((x)*(1<<FIX_PREC)))
+
+#define SIN_SIZE 512
+#define COS_OFF 128
+
+
+int main(void) {
+	int i;
+	double v;
+	for(i = 0; i < SIN_SIZE + COS_OFF; ++i) {
+		v = sin(2.0 * M_PI * i / (double)SIN_SIZE);
+		printf("%d, ", TO_FIX( v ));
+	}
+	printf("\n");
+	return 0;
+}
+

examples/pgztest/build.sh

@@ -32,7 +32,7 @@ START=0x2000
 
 echo "__f256_start = ${START};" > ${SETTINGS}
 
-CLANG="mos-f256k-clang -I${F256}/include -I${F256}/f256lib -Os -fno-inline"
+CLANG="mos-f256k-clang -I${F256}/include -I${F256}/f256lib -Os"
 
 ${CLANG} -c ${F256}/f256lib/f256.c
 ${CLANG} -c pgztest.c

examples/pgztest/pgztest.c

@@ -41,20 +41,13 @@ void bitmap(void) {
 	bitmapReset();
 
 	bitmapGetResolution(&mx, &my);
-	mx--;
-	my--;
 
 	for (l=0; l<TEXTCOLORS_COUNT; l++)
-		bitmapDefineColor(l,
+		bitmapDefineColor(l, textColors[l].r, textColors[l].g, textColors[l].b);
-							textColors[l].r,
-							textColors[l].g,
-							textColors[l].b);
 
 	l = 0;
 	while (1) {
-		bitmapSetColor(c++);
+		// Abuse all three graphics pages.
-		if (c == TEXTCOLORS_COUNT) c = 0;
-
 		switch (l) {
 			case 0:
 				bitmapSetPage(1);
@@ -73,10 +66,16 @@ void bitmap(void) {
 				break;
 		}
 
-		x  = rndRead() % mx;
+		bitmapSetColor(0);
-		y  = rndRead() % my;
+		bitmapClear();
-		x2 = rndRead() % mx;
+
-		y2 = rndRead() % my;
+		bitmapSetColor(c++);
+		if (c == TEXTCOLORS_COUNT) c = 0;
+
+		x  = randomRead() % mx;
+		y  = randomRead() % my;
+		x2 = randomRead() % mx;
+		y2 = randomRead() % my;
 
 		bitmapLine(x, y, x2, y2);
 	}
@@ -99,8 +98,8 @@ void text(void) {
 
 int main(void) {
 	f256Init();
-	//text();
+	text();
-	//bitmap();
+	bitmap();
-	bitmapReset();  // BOOM!
+	//bitmapReset();  // BOOM!
 	return 0;
 }

f256lib/bitmap.c

@@ -37,7 +37,19 @@ char error;
 
 
 void bitmapClear(void) {
+#ifndef BOOM
 	dmaFill(_BITMAP_BASE[_page], _PAGE_SIZE, _color);
+	//dma2dFill(_BITMAP_BASE[_page], _MAX_X, _MAX_Y, _MAX_X, _color);
+#else
+	uint16_t x;
+	uint16_t y;
+
+	for (y=0; y<_MAX_Y; y++) {
+		for (x=0; x<_MAX_X; x++) {
+			bitmapPutPixel(x, y);
+		}
+	}
+#endif
 }
 
 
@@ -162,11 +174,9 @@ void bitmapReset(void) {
 	_BITMAP_BASE[1] = _BITMAP_BASE[0] + realSize;  // Page 2 = 0x24000
 	_BITMAP_BASE[2] = _BITMAP_BASE[1] + realSize;  // Page 3 = 0x38000
 
-	/*
 	print("\nbase0 = ");  printInt(_BITMAP_BASE[0]);
 	print("\nbase1 = ");  printInt(_BITMAP_BASE[1]);
 	print("\nbase2 = ");  printInt(_BITMAP_BASE[2]);
-	*/
 
 	// Set palette to a gradient so there's at least *something*.
 	for (x=0; x<256; x++) bitmapDefineColor(x, x, x, x);
@@ -174,7 +184,7 @@ void bitmapReset(void) {
 	POKE(MMU_IO_CTRL, MMU_IO_PAGE_0);  // Swap I/O page 0 into bank 6.
 
 	POKE(VKY_LAYER_CTRL_0, 16);  // Bitmaps on all layers.
-	POKE(VKY_LAYER_CTRL_1, 1);   // Bitmaps on all layers.
+	POKE(VKY_LAYER_CTRL_1, 2);   // Bitmaps on all layers.
 
 	// Turn everthing on for setup.
 	POKE(VKY_BM0_CTRL, 1);

f256lib/dma.c

@@ -39,7 +39,27 @@ void dmaFill(uint32_t start, uint32_t length, byte value) {
 	POKE(DMA_FILL_VAL, value);
 	POKEA(DMA_DST_ADDR, start);
 	POKEA(DMA_COUNT, length);
-	POKE(DMA_CTRL, DMA_CTRL_FILL | DMA_CTRL_ENABLE | DMA_CTRL_START);
+	POKE(DMA_CTRL, PEEK(DMA_CTRL) | DMA_CTRL_START);
+
+	dmaWait();
+
+	POKE(MMU_IO_CTRL, mmu);  // Restore MMU state.
+}
+
+
+
+void dma2dFill(uint32_t start, uint16_t width, uint16_t height, uint16_t stride, byte value) {
+	byte  mmu = PEEK(MMU_IO_CTRL);  // Get current MMU state.
+
+	POKE(MMU_IO_CTRL, MMU_IO_PAGE_0);  // Swap I/O page 0 into bank 6.
+
+	POKE(DMA_CTRL, DMA_CTRL_2D | DMA_CTRL_ENABLE);
+	POKE(DMA_FILL_VAL, value);
+	POKEA(DMA_DST_ADDR, start);
+	POKEW(DMA_WIDTH, width);
+	POKEW(DMA_HEIGHT, height);
+	POKEW(DMA_STRIDE_DST, stride);
+	POKE(DMA_CTRL, PEEK(DMA_CTRL) | DMA_CTRL_START);
 
 	dmaWait();
 
@@ -48,9 +68,13 @@ void dmaFill(uint32_t start, uint32_t length, byte value) {
 
 
 static void dmaWait(void) {
+	// First, wait for DMA to be complete.
 	while (PEEK(DMA_STATUS) & DMA_STAT_BUSY)
 		// Spin our wheels.
 		;
 
 	POKE(DMA_CTRL, 0);
+
+	// Then wait for a VBL because two DMAs per frame will crash.
+	waitVerticalBlank();
 }

f256lib/dma.h

@@ -35,6 +35,7 @@ extern "C"
 
 
 void dmaFill(uint32_t start, uint32_t length, byte value);
+void dma2dFill(uint32_t start, uint16_t width, uint16_t height, uint16_t stride, byte value);
 
 
 #ifdef __cplusplus

f256lib/f256.c

@@ -31,6 +31,8 @@
 void f256Init(void) {
 	byte mmu = PEEK(MMU_IO_CTRL);  // Get current MMU state.
 
+	asm("sei");
+
 	POKE(MMU_IO_CTRL, MMU_IO_PAGE_0);  // Swap I/O page 0 into bank 6.
 
 	//POKE(VKY_MSTR_CTRL_0, 1); // Enable text.
@@ -53,11 +55,11 @@ void f256Init(void) {
 	// MMU_MEM_BANK_6 is always mapped to I/O.
 	// MMU_MEM_BANK_7 belongs to the MicroKernel.
 
-	rndSeed(0);  //***TODO*** Use clock or something.
+	randomSeed(0);  //***TODO*** Use clock or something.
 }
 
 
-uint16_t rndRead(void) {
+uint16_t randomRead(void) {
 	byte    mmu = PEEK(MMU_IO_CTRL);  // Get current MMU state.
 	uint16_t result;
 
@@ -72,7 +74,7 @@ uint16_t rndRead(void) {
 }
 
 
-void rndSeed(uint16_t seed) {
+void randomSeed(uint16_t seed) {
 	byte mmu = PEEK(MMU_IO_CTRL);  // Get current MMU state.
 
 	POKE(MMU_IO_CTRL, MMU_IO_PAGE_0);  // Swap I/O page 0 into bank 6.
@@ -82,3 +84,20 @@ void rndSeed(uint16_t seed) {
 
 	POKE(MMU_IO_CTRL, mmu);  // Restore MMU state.
 }
+
+
+void waitVerticalBlank(void) {
+	byte mmu = PEEK(MMU_IO_CTRL);  // Get current MMU state.
+
+	POKE(MMU_IO_CTRL, MMU_IO_PAGE_0);  // Swap I/O page 0 into bank 6.
+
+	//***TODO*** This assumes we're 60hz with graphics enabled.
+	while (PEEKW(RAST_ROW_L) == 482)
+		// Spin our wheels.
+		;
+	while (PEEKW(RAST_ROW_L) != 482)
+		// Spin our wheels.
+		;
+
+	POKE(MMU_IO_CTRL, mmu);  // Restore MMU state.
+}

f256lib/f256.h

@@ -51,6 +51,12 @@ extern "C"
 typedef unsigned char byte;
 
 
+// Things not in the Merlin defs.
+#define TEXT_MATRIX  0xc000  // I/O Page 2
+#define RAST_ROW_L   0xd01a
+#define RAST_ROW_H   0xd01b
+
+
 // Single-byte
 #define PEEK(addy)         ((byte)*(volatile byte *)(addy))
 #define POKE(addy, value)  (*(volatile byte *)(addy) = (value))
@@ -70,7 +76,7 @@ typedef unsigned char byte;
 #define VECTOR(member)     (size_t)(&((struct call *)0xff00)->member)
 #define EVENT(member)      (size_t)(&((struct events *)0)->member)
 #define CALL(fn) \
-asm("jsr %[addy] \n" \
+	asm("jsr %[addy] \n" \
 		"stz %[err] \n" \
 		"ror %[err]" \
 		: [err] "+m"(error) \
@@ -83,8 +89,9 @@ extern char           error;
 
 
 void     f256Init(void);
-uint16_t rndRead(void);
+uint16_t randomRead(void);
-void     rndSeed(uint16_t seed);
+void     randomSeed(uint16_t seed);
+void     waitVerticalBlank(void);
 
 
 #include "text.h"

f256lib/text.h

@@ -34,9 +34,6 @@ extern "C"
 #include "f256.h"
 
 
-#define TEXT_MATRIX          0xc000  // I/O Page 2
-
-
 // Apple IIgs Colors, because that's how we roll.
 typedef enum textColorsE {
 	BLACK = 0,