Beispiel #1
0
unsigned char ataWriteSectorsLBA(	unsigned char Drive, 
												unsigned long lba,
												unsigned int numsectors,
                            			unsigned char *Buffer)
{
	unsigned int cyl, head, sect;
	unsigned char temp;

#ifdef DEBUG_ATA
	rprintfProgStrM("ATA LBA write ");
	rprintfu32(lba); rprintfProgStrM(" ");
	rprintfu16(numsectors); rprintfProgStrM(" ");
	rprintfu16((unsigned int)Buffer); 
	rprintfCRLF();
#endif

	sect = (int) ( lba & 0x000000ffL );
	lba = lba >> 8;
	cyl = (int) ( lba & 0x0000ffff );
	lba = lba >> 16;
	head = ( (int) ( lba & 0x0fL ) ) | ATA_HEAD_USE_LBA;

	temp = ataWriteSectorsCHS( Drive, head, cyl, sect, numsectors, Buffer );

	if(temp)
		ataDiskErr();
	return temp;
}                            		
Beispiel #2
0
void dhcpPrintHeader(struct netDhcpHeader* packet)
{
	rprintfProgStrM("DHCP Packet:\r\n");
	// print op
	rprintfProgStrM("Op      : ");
	switch (packet->bootp.op)
	{
	case BOOTP_OP_BOOTREQUEST:	rprintfProgStrM("BOOTREQUEST"); break;
	case BOOTP_OP_BOOTREPLY:	rprintfProgStrM("BOOTREPLY");	break;
	default:					rprintfProgStrM("UNKNOWN");		break;
	}
	rprintfCRLF();
	// print transaction ID
	rprintfProgStrM("XID     : 0x");	rprintfu32(packet->bootp.xid);
	rprintfCRLF();
	// print client IP address
	rprintfProgStrM("ClIpAddr: ");	netPrintIPAddr(htonl(packet->bootp.ciaddr));
	rprintfCRLF();
	// print 'your' IP address
	rprintfProgStrM("YrIpAddr: ");	netPrintIPAddr(htonl(packet->bootp.yiaddr));
	rprintfCRLF();
	// print server IP address
	rprintfProgStrM("SvIpAddr: ");	netPrintIPAddr(htonl(packet->bootp.siaddr));
	rprintfCRLF();
	// print gateway IP address
	rprintfProgStrM("GwIpAddr: ");	netPrintIPAddr(htonl(packet->bootp.giaddr));
	rprintfCRLF();
	// print client hardware address
	rprintfProgStrM("ClHwAddr: ");	netPrintEthAddr((struct netEthAddr*)packet->bootp.chaddr);	rprintfCRLF();
}
Beispiel #3
0
unsigned char ataWriteSectors(unsigned char Drive, 
										unsigned long lba,
										unsigned int numsectors,
                            	unsigned char *Buffer)
{
  	unsigned int cyl, head, sect;
  	unsigned char temp;

	// check if drive supports native LBA mode
	if(ataDriveInfo.LBAsupport)
	{
		// drive supports using native LBA
		temp = ataWriteSectorsLBA(Drive, lba, numsectors, Buffer);
	}
	else
	{
		// drive required CHS access
		#ifdef DEBUG_ATA
			// do this defore destroying lba
			rprintfProgStrM("ATA LBA for CHS write: ");
			rprintfProgStrM("LBA="); rprintfu32(lba); rprintfProgStrM(" ");
		#endif

		// convert LBA to pseudo CHS
		// remember to offset the sector count by one
		sect = (u08) (lba % ataDriveInfo.sectors)+1;
		lba = lba / ataDriveInfo.sectors;
		head = (u08) (lba % ataDriveInfo.heads);
		lba = lba / ataDriveInfo.heads;
		cyl = (u16) lba;

		#ifdef DEBUG_ATA
			rprintfProgStrM("C:H:S=");
			rprintfu16(cyl); rprintfProgStrM(":");
			rprintfu08(head); rprintfProgStrM(":");
			rprintfu08(sect); rprintfCRLF();
		#endif

		temp = ataWriteSectorsCHS( Drive, head, cyl, sect, numsectors, Buffer );
	}

	if(temp)
		ataDiskErr();
	return temp;
}                            		
void rprintfTest(void)
{
	u16 val;
	u08 mydata;
	u08 mystring[10];
	float b;
	u08 small;
	u16 medium;
	u32 big;

	// print a little intro message so we know things are working
	rprintf("\r\nThis is my cool program!\r\n");

	
	rprintf("\r\nWelcome to rprintf Test!\r\n");

	// print single characters
	rprintfChar('H');
	rprintfChar('e');
	rprintfChar('l');
	rprintfChar('l');
	rprintfChar('o');
	// print a constant string stored in FLASH
	rprintfProgStrM(" World!");
	// print a carriage return, line feed combination
	rprintfCRLF();
	// note that using rprintfCRLF() is more memory-efficient than
	// using rprintf("\r\n"), especially if you do it repeatedly

	mystring[0] = 'A';
	mystring[1] = ' ';
	mystring[2] = 'S';
	mystring[3] = 't';
	mystring[4] = 'r';
	mystring[5] = 'i';
	mystring[6] = 'n';
	mystring[7] = 'g';
	mystring[8] = '!';
	mystring[9] = 0;	// null termination

	// print a null-terminated string from RAM
	rprintfStr(mystring);
	rprintfCRLF();

	// print a section of a string from RAM
	// - start at index 2
	// - print 6 characters
	rprintfStrLen(mystring, 2, 6);
	rprintfCRLF();


	val = 24060;
	mydata = 'L';

	// print a decimal number
	rprintf("This is a decimal number: %d\r\n", val);

	// print a hex number
	rprintf("This is a hex number: %x\r\n", mydata);
	
	// print a character
	rprintf("This is a character: %c\r\n", mydata);

	// print hex numbers
	small = 0x12;		// a char
	medium = 0x1234;	// a short
	big = 0x12345678;	// a long

	rprintf("This is a 2-digit hex number (char) : ");
	rprintfu08(small);
	rprintfCRLF();

	rprintf("This is a 4-digit hex number (short): ");
	rprintfu16(medium);
	rprintfCRLF();

	rprintf("This is a 8-digit hex number (long) : ");
	rprintfu32(big);
	rprintfCRLF();

	// print a formatted decimal number
	// - use base 10
	// - use 8 characters
	// - the number is signed [TRUE]
	// - pad with '.' periods
	rprintf("This is a formatted decimal number: ");
	rprintfNum(10, 8, TRUE, '.', val);
	rprintfCRLF();

	b = 1.23456;

	// print a floating point number
	// use 10-digit precision
	
	// NOTE: TO USE rprintfFloat() YOU MUST ENABLE SUPPORT IN global.h
	// use the following in your global.h: #define RPRINTF_FLOAT

	//rprintf("This is a floating point number: ");
	//rprintfFloat(8, b);
	//rprintfCRLF();
}
u08 mmcWrite(u32 sector, u08* buffer)
{
	u08 r1;
	u16 i;
	u16 retries;

	spiSetClockPhase(SD_CLOCK_PHASE);
	spiSetBitrate(SD_TRANSFER_SPI_DIV);

	// assert chip select
	_mmcEnableCS();

	retries = 0;

	// wait for card not busy, at most 250ms
	if (cardBusy) {
		spiTransferByte(0xFF);
		do {
			r1 = spiTransferByte(0xFF);
			retries++;
			if (!r1) {
				delay_us(250);
			}
			else
				break;
		}
		while (!r1 && retries < 0xFFE);
	}

	if (retries == 0xFFE) {
		_mmcDisableCS();
		rprintf("mmcWrite - card still busy, sector ");
		rprintfu32(sector);
		rprintfCRLF();
		return -1;
	}

	// issue command
	r1 = mmcCommand(MMC_WRITE_BLOCK, sector<<9);
	#ifdef MMC_DEBUG
	//rprintf("MMC Write Block R1=0x%x\r\n", r1);
	#endif
	// check for valid response
	if(r1 != 0x00) {
		_mmcDisableCS(); // Andreas - was reversed
		rprintf("mmcWrite - invalid response %x\r\n",r1);
		return r1;
	}
	// send dummy
	spiTransferByte(0xFF);
	// send data start token
	spiTransferByte(MMC_STARTBLOCK_WRITE);
	// write data
	for(i=0; i<0x200; i++)
	{
		spiTransferByte(*buffer++);
	}
	// write 16-bit CRC (dummy values)
	spiTransferByte(0xFF);
	spiTransferByte(0xFF);

	// read data response token
	r1 = spiTransferByte(0xFF);
	if( (r1&MMC_DR_MASK) != MMC_DR_ACCEPT) {
		_mmcDisableCS();
		return r1;
	}
	#ifdef MMC_DEBUG
	//rprintf("Data Response Token=0x%x\r\n", r1);
	#endif
	/* old busy code
	// wait until card not busy
	while(!spiTransferByte(0xFF));
	*/

	// Provide card with 8 clock cycles to complete the operation
	spiTransferByte(0xFF);

	cardBusy = 1;

	// release chip select
	_mmcDisableCS();

	// return success
	return 0;
}
u08 mmcRead(u32 sector, u08* buffer)
{
	u08 r1;
	u16 i;
	u16 retries;
	
	//#ifdef MMC_DEBUG
	//rprintf("mmcRead(");
	//rprintfu32(sector);
	//rprintf(")\r\n");
	//#endif
	
	spiSetClockPhase(SD_CLOCK_PHASE);
	spiSetBitrate(SD_TRANSFER_SPI_DIV);

	_mmcEnableCS();

	retries = 0;
	
	// wait for card not busy, at most 250ms
	if (cardBusy) {
		spiTransferByte(0xFF);
		do {
			r1 = spiTransferByte(0xFF);
			retries++;
			if (!r1) {
				delay_us(250);
			}
			else
				break;
		}
		while (!r1 && retries < 0xFFE);
	}

	if (retries == 0xFFE) {
		_mmcDisableCS();
		rprintf("mmcRead - card still busy, sector ");
		rprintfu32(sector);
		rprintfCRLF();
		return -1;
	}

	do {
		r1 = spiTransferByte(0xFF);
	} while (r1 != 0xFF);

	//rprintf("1: r1 = %u\r\n",r1);

	mmcCommandNoWait(MMC_READ_SINGLE_BLOCK, sector<<9);

	// wait for card response
	do {
		r1 = spiTransferByte(0xFF);
	} while (r1 == 0xFF);

	//rprintf("2: r1 = %u\r\n",r1);
	spiTransferByte(0xFF);

	// NOTE TO SELF - Check error tokens
	// wait for block start
	retries = 0;
	do {
		retries++;
		//rprintf("mmcRead() - Timed out waiting for startblock: R1=0x%x\r\n", r1);
		if (retries > 0xFFE) {
			#ifdef MMC_DEBUG
			rprintf("mmcRead() - Timed out waiting for startblock: R1=0x%x, 0x%x retries\r\n", r1, retries);
			#endif
			_mmcDisableCS();
			return -1;
		}	
	} while((r1 = spiTransferByte(0xFF)) != MMC_STARTBLOCK_READ);

	//rprintf("Read startblock after 0x%x retries\r\n", retries);
	// read in data
	for(i=0; i<0x200; i++)
	{
		*buffer++ = spiTransferByte(0xFF);
		//rprintf("%d\r\n",buffer[i]);
	}
	// read 16-bit CRC
	spiTransferByte(0xFF);
	spiTransferByte(0xFF);

	// Provide card with 8 clock cycles to complete the operation
	spiTransferByte(0xFF);

	_mmcDisableCS();

	cardBusy = 1;

	// return success
	return 0;
}
Beispiel #7
0
Datei: main.c Projekt: sndae/b3r1
/*******************************************************************
*		rprintf_test
*******************************************************************/
void rprintf_test(void)
{
    u16 val;
    u08 mydata;
    u08 mystring[10];
    double b;
    u08 small;
    u16 medium;
    u32 big;

    // initialize the UART (serial port)
    uartInit();

    // set the baud rate of the UART for our debug/reporting output
    uartSetBaudRate(38400);

    // initialize rprintf system
    // - use uartSendByte as the output for all rprintf statements
    //   this will cause all rprintf library functions to direct their
    //   output to the uart
    // - rprintf can be made to output to any device which takes characters.
    //   You must write a function which takes an unsigned char as an argument
    //   and then pass this to rprintfInit like this: rprintfInit(YOUR_FUNCTION);
    rprintfInit(uartSendByte);

    // initialize vt100 library
    vt100Init();

    // clear the terminal screen
    vt100ClearScreen();

    while (!(getkey() == 1))		//do the folling block until enter is pressed
    {

        // print a little intro message so we know things are working
        rprintf("\r\nWelcome to rprintf Test!\r\n");

        // print single characters
        rprintfChar('H');
        rprintfChar('e');
        rprintfChar('l');
        rprintfChar('l');
        rprintfChar('o');
        // print a constant string stored in FLASH
        rprintfProgStrM(" World!");
        // print a carriage return, line feed combination
        rprintfCRLF();
        // note that using rprintfCRLF() is more memory-efficient than
        // using rprintf("\r\n"), especially if you do it repeatedly

        mystring[0] = 'A';
        mystring[1] = ' ';
        mystring[2] = 'S';
        mystring[3] = 't';
        mystring[4] = 'r';
        mystring[5] = 'i';
        mystring[6] = 'n';
        mystring[7] = 'g';
        mystring[8] = '!';
        mystring[9] = 0;	// null termination

        // print a null-terminated string from RAM
        rprintfStr(mystring);
        rprintfCRLF();

        // print a section of a string from RAM
        // - start at index 2
        // - print 6 characters
        rprintfStrLen(mystring, 2, 6);
        rprintfCRLF();


        val = 24060;
        mydata = 'L';

        // print a decimal number
        rprintf("This is a decimal number: %d\r\n", val);

        // print a hex number
        rprintf("This is a hex number: %x\r\n", mydata);

        // print a character
        rprintf("This is a character: %c\r\n", mydata);

        // print hex numbers
        small = 0x12;		// a char
        medium = 0x1234;	// a short
        big = 0x12345678;	// a long

        rprintf("This is a 2-digit hex number (char) : ");
        rprintfu08(small);
        rprintfCRLF();

        rprintf("This is a 4-digit hex number (short): ");
        rprintfu16(medium);
        rprintfCRLF();

        rprintf("This is a 8-digit hex number (long) : ");
        rprintfu32(big);
        rprintfCRLF();

        // print a formatted decimal number
        // - use base 10
        // - use 8 characters
        // - the number is signed [TRUE]
        // - pad with '.' periods
        rprintf("This is a formatted decimal number: ");
        rprintfNum(10, 8, TRUE, '.', val);
        rprintfCRLF();

        b = 1.23456;

        // print a floating point number
        // use 10-digit precision

        // NOTE: TO USE rprintfFloat() YOU MUST ENABLE SUPPORT IN global.h
        // use the following in your global.h: #define RPRINTF_FLOAT

        rprintf("This is a floating point number: ");
        rprintfFloat(8, b);
        rprintfCRLF();
    }
}