- better - more sphisticated

Committed on the Free edition of March Hare Software CVSNT Server.
Upgrade to CVS Suite for more features and support:
http://march-hare.com/cvsnt/


git-svn-id: http://moon:8086/svn/vhdl/trunk@628 cc03376c-175c-47c8-b038-4cd826a8556b

lib/CPUs/MIPS/bsp/examples/test_irq.c

@@ -11,6 +11,19 @@ char buffer[16384];
 char * volatile pPtr_r;
 char * volatile pPtr_w;
 
+// -------------------------------------------------------------
+typedef struct _sps2_if_t
+{
+	volatile UINT32 *pCTRL;
+	volatile UINT32 *pDATA;
+} ps2_if_t;
+
+static ps2_if_t ps2_if[2] =
+{
+	{(UINT32*)sys_ps2_0_stat, (UINT32*)sys_ps2_0_data},
+	{(UINT32*)sys_ps2_1_stat, (UINT32*)sys_ps2_1_data}
+};
+
 void handler0(void)
 {
 	printf("Interrupt 0\n");
@@ -63,9 +76,71 @@ void handler5(void)
 	printf("Interrupt 5\n");
 }
 
+static INT32 mouse_x, mouse_y;
+
 void handler6(void)
 {
-	printf("Interrupt 6\n");
+	int p, i;
+	ps2_if_t *pIF;
+	UINT8 mouse_rsp[3];
+	UINT32 timeout_count, key;
+
+	INT32 dx, dy;
+
+	for (p=0; p < sizeof(ps2_if)/sizeof(ps2_if_t); p++)
+	{
+		pIF = &ps2_if[p];
+		if (p==0)
+		{
+			while(sys_ps2_bit_rx_irq & *pIF->pCTRL)
+			{
+				key = *pIF->pDATA;
+				printf("Keyboard scan code = 0x%02X\n", key);
+			}
+		}
+		if (p==1)
+		{
+			if(!(sys_ps2_bit_rx_irq & *pIF->pCTRL))
+				continue;
+
+			for (i=0; i < 3; i++)
+			{
+				timeout_count = 100;
+				while(!(sys_ps2_bit_rx_irq & *pIF->pCTRL))
+				{
+					timeout_count--;
+					if (!timeout_count)
+					{
+						break;
+					}
+					sleep(1);
+				}
+				if (!timeout_count)
+				{
+					break;
+				}
+				mouse_rsp[i] = (UINT8)*pIF->pDATA;
+			}
+			if (!timeout_count)
+			{
+				continue;
+			}
+			dx = mouse_rsp[1];
+			if (mouse_rsp[0] &  0x10)
+				dx |= 0xFFFFFF00;
+			dy = mouse_rsp[2];
+			if (mouse_rsp[0] &  0x20)
+				dy |= 0xFFFFFF00;
+
+//			printf("dx = %5d, dy = %5d\n", dx, dy);
+
+			mouse_x += dx;
+			mouse_y += dy;
+
+			printf("x = %5d, y = %5d\n", mouse_x, mouse_y);
+
+		}
+	}
 }
 
 void handler7(void)
@@ -73,6 +148,125 @@ void handler7(void)
 	printf("Interrupt 7\n");
 }
 
+void PS2_byte_write(UINT32 port, UINT8 byte)
+{
+	ps2_if_t *pIF;
+
+	pIF = &ps2_if[port];
+
+	while(!(*pIF->pCTRL & sys_ps2_bit_tx_empty));
+
+	*pIF->pDATA = (UINT32)byte;
+}
+
+UINT32 PS2_byte_read(UINT32 port, UINT32 timeout_ms)
+{
+	ps2_if_t *pIF;
+
+	pIF = &ps2_if[port];
+
+	while(!(*pIF->pCTRL & sys_ps2_bit_rx_avail))
+	{
+		timeout_ms--;
+		if (!timeout_ms)
+			return ERROR;
+
+		sleep(1);
+	}
+	return (UINT32)*pIF->pDATA;
+}
+
+UINT32 PS2_cmd(UINT32 port, UINT8 cmd, UINT32 ack_timeout_ms)
+{
+	UINT32 result;
+
+	PS2_byte_write(port, cmd);
+	result = PS2_byte_read(port, ack_timeout_ms);
+	if (0xFA != result)
+	{
+		printf ("PS2_cmd(%d): no ACK received. Result = %08X\n", port, result);
+		return ERROR;
+	}
+	return 0;
+}
+
+void PS2_flush(UINT32 port)
+{
+	while (ERROR != PS2_byte_read(port, 10));
+}
+
+void PS2_init(UINT32 port)
+{
+	ps2_if_t *pIF;
+
+	pIF = &ps2_if[port];
+
+	UINT32 result;
+
+	// Disable RX-interrupt
+	*pIF->pCTRL &= ~sys_ps2_bit_rx_inten;
+
+	printf ("PS2_init(%d) - Initialize... ", port);
+
+	// Flush buffer
+	PS2_flush(port);
+
+	// send RESET
+	result = PS2_cmd(port, 0xFF, 1000);
+	if (IS_ERROR(result))
+	{
+		printf ("Reset error %08X\n", result);
+		return;
+	}
+
+	// Read BAT
+	result = PS2_byte_read(port, 1000);
+	if (0xAA != result)
+	{
+		printf ("BAT error %08X\n", result);
+		return;
+	}
+
+	printf ("Success\n");
+
+	// Read ID
+	result = PS2_byte_read(port, 10);
+	if (IS_ERROR(result))
+	{
+		// No ID => keyboard
+		printf ("PS2_init(%d) - Keyboard detected\n", port);
+	}
+
+	if (result == 0)
+	{
+		printf ("PS2_init(%d) - Mouse device detected\n", port);
+		printf ("PS2_init(%d) - Enable stream mode...", port);
+		result = PS2_cmd(port, 0xF4, 1000);
+		if (IS_ERROR(result))
+		{
+			printf ("error %08X\n", result);
+			return;
+		}
+		printf ("Success\n");
+	}
+
+	// send Get Device-ID
+	result = PS2_cmd(port, 0xF2, 1000);
+	if (IS_ERROR(result))
+	{
+		printf ("Get Device-ID error %08X\n", result);
+		return;
+	}
+	printf ("PS2_init(%d) - Device-ID: %08X\n", port, result);
+
+	// Flush buffer
+	while (ERROR != PS2_byte_read(port, 10));
+
+	// Enable RX-interrupt
+	*pIF->pCTRL |= sys_ps2_bit_rx_inten;
+
+}
+
 int main(void)
 {
 
@@ -81,18 +275,20 @@ int main(void)
 	volatile UINT32 *pUART0_baud = (UINT32*)sys_uart0_baud;
 	volatile UINT32 *pUART1_baud = (UINT32*)sys_uart1_baud;
 
+	char string[65];
+
 	UART1_setbaud(460800);
 	printf("Hello\n");
 	memset(buffer, 0, sizeof(buffer));
 	pPtr_r = buffer;
 	pPtr_w = buffer;
-	interrupt_register(0, handler0);
+	interrupt_register(0, (void*)handler0);
 	interrupt_enable(0);
 
-	interrupt_register(1, handler1);
+	interrupt_register(1, (void*)handler1);
 	interrupt_enable(1);
 
-	interrupt_register(2, handler2);
+	interrupt_register(2, (void*)handler2);
 	interrupt_enable(2);
 
 	printf("UART0 Status = 0x%8.8X\n", *pUART0_stat);
@@ -100,25 +296,28 @@ int main(void)
 	printf("UART1 Status = 0x%8.8X\n", *pUART1_stat);
 	printf("UART1 Baud   = 0x%8.8X\n", *pUART1_baud);
 
-	// enable RX interrupt
+	// UART: enable RX interrupt
 	*pUART0_stat |= (1 << 6);
 	*pUART1_stat |= (1 << 6);
 	printf("UART0 Status = 0x%8.8X\n", *pUART0_stat);
 	printf("UART1 Status = 0x%8.8X\n", *pUART1_stat);
 
-	interrupt_register(3, handler3);
+	PS2_init(0);
+	PS2_init(1);
+
+	interrupt_register(3, (void*)handler3);
 	interrupt_enable(3);
 
-	interrupt_register(4, handler4);
+	interrupt_register(4, (void*)handler4);
 //	interrupt_enable(4);
 
-	interrupt_register(5, handler5);
+	interrupt_register(5, (void*)handler5);
 	interrupt_enable(5);
 
-	interrupt_register(6, handler6);
+	interrupt_register(6, (void*)handler6);
 	interrupt_enable(6);
 
-	interrupt_register(7, handler7);
+	interrupt_register(7, (void*)handler7);
 	interrupt_enable(7);
 
 	printf("Start:\n");
@@ -139,6 +338,18 @@ int main(void)
 	sputs("Status  : ");
 	print_word(CP0_SR_read());
 	sputs("\n");
+	sputs("\n");
+
+	interrupt_disable(6);
+	printf("Bitte gebe ein: ");
+	scanf("%s", string);
+	printf("Du schriebst: %s\n", string);
+
+	// Flush buffer
+	PS2_flush(0);
+	PS2_flush(1);
+
+	interrupt_enable(6);
 
 	while(1)
 	{
@@ -147,7 +358,7 @@ int main(void)
 //			sputs("r: "); print_word((int)pPtr_r); sputs("\n");
 			if (pPtr_r == &buffer[16383])
 				pPtr_r = buffer;
-			writechar(*(pPtr_r++));
+			writechar(0, *(pPtr_r++));
 		}
 	}
 	return 0;

lib/CPUs/MIPS/bsp/examples/testbench.c

@@ -49,7 +49,7 @@ void handler3(void)
 	while((0x10 & *pUART_stat))
 	{
 		buffer[g_i] = (char)*pUART_data;
-		_cg_putchar(buffer[g_i]);
+		_putchar(0, buffer[g_i]);
 		g_i = (g_i+1)%sizeof(buffer);
 	}
 
@@ -517,6 +517,7 @@ int Test16_MemTest(void)
 	UINT32 *ram32 = NULL;
 	UINT32 volatile *pFlashIO = (UINT32*)sys_flash_io;
 	UINT32 volatile *pFlashMem = (UINT32*)sys_flash_mem;
+	UINT32 volatile *pROM = (UINT32*)0xBFC00000;
 
 	UINT32 *pSrc32, *pDst32;
 	UINT32 start, end;
@@ -551,6 +552,9 @@ int Test16_MemTest(void)
 		printf("passed (%.2f MByte/s)\n", (double)TEST_SIZE/(1000*(end-start)));
 */
 	// ----------------------------------------------------------
+	pSrc32 = (UINT32*)calloc(TEST_SIZE/4,sizeof(UINT32));
+	pDst32 = (UINT32*)calloc(TEST_SIZE/4,sizeof(UINT32));
+
 	// Memtest BEGIN
 	printf("Dump first 16 bytes of flash blocks\n");
 	for (i=0; i < FLASH_SIZE; i += 0x40000)
@@ -561,56 +565,47 @@ int Test16_MemTest(void)
 	printf("SDRAM Memory Test\n");
 	printf("Test size %d kByte\n\n", TEST_SIZE/1024);
 
-	ram8 = (UINT8*)calloc(TEST_SIZE,sizeof(UINT8));
+	ram8 = (UINT8*)pDst32;
 	printf("Zeroize SDRAM (memset)...");
 	start = clock();
 	memset(ram8, 0, TEST_SIZE);
 	end = clock();
-	printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1000*(end-start)));
+	printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*(end-start)));
 
-	free(ram8);
-
-	ram8 = (UINT8*)calloc(TEST_SIZE,sizeof(UINT8));
 	printf("Zeroize SDRAM (8-Bit access)...");
 	start = clock();
 	for (i=0; i < TEST_SIZE; i++)
 		ram8[i] = (UINT8)0;
 
 	end = clock();
-	printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1000*(end-start)));
+	printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*(end-start)));
 
-	free(ram8);
+	ram16 = (UINT16*)pDst32;
-
-	ram16 = (UINT16*)calloc(TEST_SIZE/2,sizeof(UINT16));
 	printf("Zeroize SDRAM (16-Bit access)...");
 	start = clock();
 	for (i=0; i < TEST_SIZE/2; i++)
 		ram16[i] = (UINT16)0;
 
 	end = clock();
-	printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1000*(end-start)));
+	printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*(end-start)));
 
-	free(ram16);
+	ram32 = (UINT32*)pDst32;
-
-	ram32 = (UINT32*)calloc(TEST_SIZE/4,sizeof(UINT32));
 	printf("Zeroize SDRAM (32-Bit access)...");
 	start = clock();
 	for (i=0; i < TEST_SIZE/4; i++)
 		ram32[i] = (UINT32)0;
 
 	end = clock();
-	printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1000*(end-start)));
+	printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*(end-start)));
 
-	free(ram32);
+	ram8 = (UINT8*)pDst32;
-
-	ram8 = (UINT8*)calloc(TEST_SIZE,sizeof(UINT8));
 	printf("Write SDRAM (8-Bit access)...");
 	start = clock();
 	for (i=0; i < TEST_SIZE; i++)
 		ram8[i] = (UINT8)i;
 
 	end = clock();
-	printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1000*(end-start)));
+	printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*(end-start)));
 
 	printf("Verify SDRAM (8-Bit access)...");
 	start = clock();
@@ -626,18 +621,16 @@ int Test16_MemTest(void)
 		return TEST16_ERROR;
 	}
 	else
-		printf("passed (%.2f MByte/s)\n", (double)TEST_SIZE/(1000*(end-start)));
+		printf("passed (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*(end-start)));
 
-	free(ram8);
+	ram16 = (UINT16*)pDst32;
-
-	ram16 = (UINT16*)calloc(TEST_SIZE/2,sizeof(UINT16));
 	printf("Write SDRAM (16-Bit access)...");
 	start = clock();
 	for (i=0; i < TEST_SIZE/2; i++)
 		ram16[i] = (UINT16)i;
 
 	end = clock();
-	printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1000*(end-start)));
+	printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*(end-start)));
 
 	printf("Verify SDRAM (16-Bit access)...");
 	start = clock();
@@ -653,12 +646,10 @@ int Test16_MemTest(void)
 		return TEST16_ERROR;
 	}
 	else
-		printf("passed (%.2f MByte/s)\n", (double)TEST_SIZE/(1000*(end-start)));
+		printf("passed (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*(end-start)));
 
 
-	free(ram16);
+	ram32 = (UINT32*)pDst32;
-
-	ram32 = (UINT32*)calloc(TEST_SIZE/4,sizeof(UINT32));
 	printf("Write SDRAM (32-Bit access)...");
 	start = clock();
 	for (i=0; i < TEST_SIZE/4; i++)
@@ -667,7 +658,7 @@ int Test16_MemTest(void)
 	}
 
 	end = clock();
-	printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1000*(end-start)));
+	printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*(end-start)));
 
 	printf("Verify SDRAM (32-Bit access)...");
 	start = clock();
@@ -685,21 +676,19 @@ int Test16_MemTest(void)
 		return TEST16_ERROR;
 	}
 	else
-		printf("passed (%.2f MByte/s)\n", (double)TEST_SIZE/(1000*(end-start)));
+		printf("passed (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*(end-start)));
-
-	free(ram32);
 
 	printf("\n");
 	printf("Small data test (size = %d kByte)\n", SMALL_TEST_SIZE/1024);
 	printf("Write SDRAM (32-Bit access)...");
-	ram32 = (UINT32*)calloc(SMALL_TEST_SIZE/4,sizeof(UINT32));
+	ram32 = (UINT32*)pDst32;
 	start = clock();
 	for (j=0; j < TEST_SIZE/SMALL_TEST_SIZE; j++)
 		for (i=0; i < SMALL_TEST_SIZE/4; i++)
 			ram32[i] = (UINT32)i;
 
 	end = clock();
-	printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1000*(end-start)));
+	printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*(end-start)));
 
 	// -------------------------------------------------------------------
 	// Verify
@@ -718,21 +707,19 @@ int Test16_MemTest(void)
 		return TEST16_ERROR;
 	}
 	else
-		printf("passed (%.2f MByte/s)\n", (double)TEST_SIZE/(1000*(end-start)));
+		printf("passed (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*(end-start)));
 
-	// -------------------------------------------------------------------
+	for (i=1024; i < 4*65536; i *= 2)
-	free(ram32);
+	{
-	printf("\n");
+		printf("Memcpy() (%d kByte)...", i/1024);
-
-	pSrc32 = (UINT32*)calloc(TEST_SIZE/4,sizeof(UINT32));
-	pDst32 = (UINT32*)calloc(TEST_SIZE/4,sizeof(UINT32));
-
-	printf("Memcpy() SDRAM => SDRAM\n");
-	printf("Copying %d kBytes...", TEST_SIZE/(2*1024));
 		start = clock();
-	memcpy(pDst32, pSrc32, TEST_SIZE/2);
+		for (j=0; j < TEST_SIZE/i; j++)
+			memcpy(pDst32, pSrc32, i);
+
 		end = clock();
-	printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(2*1000*(end-start)));
+		printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*(end-start)));
+	}
+	// -------------------------------------------------------------------
 	printf("\n");
 
 	printf("Memcpy() Flash(IO) => SDRAM \n");
@@ -740,7 +727,7 @@ int Test16_MemTest(void)
 	start = clock();
 	memcpy(pDst32, pFlashIO, FLASH_SIZE);
 	end = clock();
-	printf("done (%.2f MByte/s)\n", (double)FLASH_SIZE/(1000*(end-start)));
+	printf("done (%.2f MByte/s)\n", (double)FLASH_SIZE/(1024*(end-start)));
 	printf("\n");
 
 	printf("Memcpy() Flash(MEM) => SDRAM \n");
@@ -748,19 +735,14 @@ int Test16_MemTest(void)
 	start = clock();
 	memcpy(pDst32, pFlashMem, FLASH_SIZE);
 	end = clock();
-	printf("done (%.2f MByte/s)\n", (double)FLASH_SIZE/(1000*(end-start)));
+	printf("done (%.2f MByte/s)\n", (double)FLASH_SIZE/(1024*(end-start)));
 	printf("\n");
 
-	free(pSrc32);
-	free(pDst32);
-
 	size = 0x2000;
-	pSrc32 = (UINT32*)0xBFC00000;
+	memcpy(pDst32, pROM, size);
-	pDst32 = (UINT32*)calloc(size,sizeof(UINT32));
-	memcpy(pDst32, pSrc32, size);
 	printf("Verify boot ROM...");
 	for (i=size/4-1; i >= 0; i--)
-		if (pDst32[i] != pSrc32[i])
+		if (pDst32[i] != pROM[i])
 			break;
 	i++;
 	if (i)
@@ -771,8 +753,6 @@ int Test16_MemTest(void)
 	else
 		printf("passed\r\n");
 
-	free(pDst32);
-
 	printf("Verify FLASH(IO) <=> FLASH(MEM)...");
 	if (!memcmp(pFlashIO, pFlashMem, FLASH_SIZE))
 		printf("passed\r\n");
@@ -787,6 +767,9 @@ int Test16_MemTest(void)
 
 	// Memtest END
 	// ----------------------------------------------------------
+	free(pSrc32);
+	free(pDst32);
+
 	sputs("\r\n");
 	return 0;
 }
@@ -854,9 +837,9 @@ int main (void)
 	screen_res_x = *pVGA_resx;
 	screen_res_y = *pVGA_resy;
 
-	*pVGA_cgcol = 0x00C0C0C0;
+	*pVGA_cgcol = 0x0000C000;
 	*pVGA_ctrl &= ~sys_vga_bit_msten;
-	cg_clr_screen();
+	clr_screen();
 
 	pBuf64 = (UINT64*)malloc(screen_res_x*screen_res_y*sizeof(UINT32));
 
@@ -939,6 +922,8 @@ int main (void)
 		}
 	}
 
+	Test16_MemTest();
+
 	interrupt_enable(7);
 	interrupt_enable(3);
 	*pTim_ctrl |= 3;