main.c

LUBBOCK板的BLOB

	*numRead = XModemReceive((char *) startAddress, bufLen);

	SerialOutputString("\n\n\n");
	
	if (blob_status.terminalSpeed != blob_status.downloadSpeed) {
		SerialOutputString("\n(Please switch your terminal emulator back to ");
		PrintSerialSpeed(blob_status.terminalSpeed);
		SerialOutputString(" baud)\n");
	}
	
	if(*numRead < 0) {
		/* something went wrong */
		retval = *numRead;
		
		/* reload the correct memory */
		do_reload(argv[1]);

		serial_init(blob_status.terminalSpeed);
		return retval;
	}

	do_md5sum((u32 *)startAddress, *numRead, digest);

	SerialOutputString("Received ");
	SerialOutputDec(*numRead);
	SerialOutputString(" (0x");
	SerialOutputHex(*numRead);
	SerialOutputString(") bytes");
#ifdef BLOB_DEBUG
	SerialOutputString(" at 0x");
	SerialOutputHex((u32) startAddress);
#ifdef CONFIG_MD5_SUPPORT
	SerialOutputString(", MD5: ");
	print_md5_digest(digest);
#endif
#endif
	serial_write('\n');


	serial_init(blob_status.terminalSpeed);

	return 0;
}

static char xdownloadhelp[] = "xdownload {blob|param|kernel|ramdisk}\n"
"Download <argument> image to RAM using xmodem\n";

__commandlist(xdownload, "xdownload", xdownloadhelp);


static int Flash(int argc, char *argv[])
{
	u32 *src;
	u32 *dst;
	u32 numBytes = 0;
	u32 maxSize = 0;
	u32 nwords;
	block_source_t type = fromFlash;
	

	if(argc < 2)
		return -ENOPARAMS;

	if(strncmp(argv[1], "blob", 5) == 0) {
		src = (u32 *)BLOB_RAM_BASE;
		dst = (u32 *)BLOB_FLASH_BASE;
		maxSize = BLOB_FLASH_LEN;
		numBytes = blob_status.blobSize;
		type = blob_status.blobType;
#ifdef PARAM_START
	} else if(strncmp(argv[1], "param", 6) == 0) {
		src = (u32 *)PARAM_RAM_BASE;
		dst = (u32 *)PARAM_FLASH_BASE;
		maxSize = PARAM_FLASH_LEN;
		numBytes = blob_status.paramSize;
		type = blob_status.paramType;
#endif
	} else if(strncmp(argv[1], "kernel", 7) == 0) {
		src = (u32 *)KERNEL_RAM_BASE;
		dst = (u32 *)KERNEL_FLASH_BASE;
		numBytes = blob_status.kernelSize;
		maxSize = KERNEL_FLASH_LEN;
		type = blob_status.kernelType;
	} else if(strncmp(argv[1], "ramdisk", 8) == 0) {
		src = (u32 *)RAMDISK_RAM_BASE;
		dst = (u32 *)RAMDISK_FLASH_BASE;
		numBytes = blob_status.ramdiskSize;
		maxSize = RAMDISK_FLASH_LEN;
		type = blob_status.ramdiskType;
	} else {
		printerror(EINVAL, argv[1]);
		return 0;
	}

	if(type == fromFlash) {
		printerrprefix();
		SerialOutputString(argv[1]);
		SerialOutputString(" not downloaded\n");
		return -EINVAL;
	}

	if(numBytes > maxSize) {
		printerrprefix();
		SerialOutputString("image too large for flash: 0x");
		SerialOutputHex(numBytes);
		SerialOutputString(" > 0x");
		SerialOutputHex(maxSize);
		serial_write('\n');

		return -ETOOLONG;
	}

	nwords = (numBytes + sizeof(u32) - 1) / sizeof(u32);

	SerialOutputString("Saving ");
	SerialOutputString(argv[1]);
	SerialOutputString(" to flash\n");


	flash_write_region(dst, src, nwords);

	return 0;
}

static char flashhelp[] = "flash {blob|param|kernel|ramdisk}\n"
"Write <argument> image to flash\n";

__commandlist(Flash, "flash", flashhelp);




static int SetDownloadSpeed(int argc, char *argv[])
{
	if(argc < 2)
		return -ENOPARAMS;

	if(strncmp(argv[1], "1200", 5) == 0) {
		blob_status.downloadSpeed = baud_1200;
	} else if(strncmp(argv[1], "1k2", 4) == 0) {
		blob_status.downloadSpeed = baud_1200;
	} else if(strncmp(argv[1], "9600", 5) == 0) {
		blob_status.downloadSpeed = baud_9600;
	} else if(strncmp(argv[1], "9k6", 4) == 0) {
		blob_status.downloadSpeed = baud_9600;
	} else if(strncmp(argv[1], "19200", 6) == 0) {
		blob_status.downloadSpeed = baud_19200;
	} else if(strncmp(argv[1], "19k2", 5) == 0) {
		blob_status.downloadSpeed = baud_19200;
	} else if(strncmp(argv[1], "38400", 7) == 0) {
		blob_status.downloadSpeed = baud_38400;
	} else if(strncmp(argv[1], "38k4", 5) == 0) {
		blob_status.downloadSpeed = baud_38400;
	} else if(strncmp(argv[1], "57600", 6) == 0) {
		blob_status.downloadSpeed = baud_57600;
	} else if(strncmp(argv[1], "57k6", 5) == 0) {
		blob_status.downloadSpeed = baud_57600;
	} else if(strncmp(argv[1], "115200", 7) == 0) {
		blob_status.downloadSpeed = baud_115200;
	} else if(strncmp(argv[1], "115k2", 6) == 0) {
		blob_status.downloadSpeed = baud_115200;
	} else if(strncmp(argv[1], "230400", 7) == 0) {
		blob_status.downloadSpeed = baud_230400;
	} else if(strncmp(argv[1], "230k4", 6) == 0) {
		blob_status.downloadSpeed = baud_230400;
	} else {
		return -EINVAL;
	}

	SerialOutputString("Download speed set to ");
	PrintSerialSpeed(blob_status.downloadSpeed);
	SerialOutputString(" baud\n");

	return 0;
}

static char speedhelp[] = "speed [baudrate]\n"
"Set download speed. Valid baudrates are:\n"
"1200, 9600, 19200, 38400, 57600, 115200, 230400,\n"
" 1k2,  9k6,  19k2,  38k4,  57k6,  115k2,  230k4\n";

__commandlist(SetDownloadSpeed, "speed", speedhelp);




static int PrintStatus(int argc, char *argv[])
{
	SerialOutputString(version_str);

	SerialOutputString("Download speed      : ");
	PrintSerialSpeed(blob_status.downloadSpeed);
	SerialOutputString(" baud\n");

	SerialOutputString("Terminal speed      : ");
	PrintSerialSpeed(blob_status.terminalSpeed);
	SerialOutputString(" baud\n");

	SerialOutputString("blob    (0x");
	SerialOutputHex(BLOB_FLASH_BASE);
	SerialOutputString("): ");
	if(blob_status.blobType == fromFlash) {
		SerialOutputString("from flash\n");
	} else {
		SerialOutputString("downloaded at 0x");
		SerialOutputHex(BLOB_RAM_BASE);
		SerialOutputString(", ");
		SerialOutputDec(blob_status.blobSize);
		SerialOutputString(" bytes\n");
#ifdef CONFIG_MD5_SUPPORT
		SerialOutputString("                      MD5: ");
		print_md5_digest(blob_status.blob_md5_digest);
		serial_write('\n');
#endif
	}

#ifdef PARAM_START
	SerialOutputString("param  (0x");
	SerialOutputHex(PARAM_FLASH_BASE);
	SerialOutputString("): ");
	if(blob_status.paramType == fromFlash) {
		SerialOutputString("from flash\n");
	} else {
		SerialOutputString("downloaded at 0x");
		SerialOutputHex(PARAM_RAM_BASE);
		SerialOutputString(", ");
		SerialOutputDec(blob_status.paramSize);
		SerialOutputString(" bytes\n");
#ifdef CONFIG_MD5_SUPPORT
		SerialOutputString("                      MD5: ");
		print_md5_digest(blob_status.param_md5_digest);
		serial_write('\n');
#endif
	}
#else
	SerialOutputString("param               : Not available\n");
#endif

	SerialOutputString("kernel  (0x");
	SerialOutputHex(KERNEL_FLASH_BASE);
	SerialOutputString("): ");
	if(blob_status.kernelType == fromFlash) {
		SerialOutputString("from flash\n");
	} else {
		SerialOutputString("downloaded at 0x");
		SerialOutputHex(KERNEL_RAM_BASE);
		SerialOutputString(", ");
		SerialOutputDec(blob_status.kernelSize);
		SerialOutputString(" bytes\n");
#ifdef CONFIG_MD5_SUPPORT
		SerialOutputString("                      MD5: ");
		print_md5_digest(blob_status.kernel_md5_digest);
		serial_write('\n');
#endif
	}

	SerialOutputString("ramdisk (0x");
	SerialOutputHex(RAMDISK_FLASH_BASE);
	SerialOutputString("): ");
	if(blob_status.ramdiskType == fromFlash) {
		SerialOutputString("from flash\n");
	} else {
		SerialOutputString("downloaded at 0x");
		SerialOutputHex(RAMDISK_RAM_BASE);
		SerialOutputString(", ");
		SerialOutputDec(blob_status.ramdiskSize);
		SerialOutputString(" bytes\n");
#ifdef CONFIG_MD5_SUPPORT
		SerialOutputString("                      MD5: ");
		print_md5_digest(blob_status.ramdisk_md5_digest);
		serial_write('\n');
#endif
	}
	
	return 0;
}

static char statushelp[] = "status\n"
"Display current status\n";

__commandlist(PrintStatus, "status", statushelp);




static int do_reload(char *what)
{
	u32 *dst = 0;
	u32 *src = 0;
	int numWords;

	if(strncmp(what, "blob", 5) == 0) {
		dst = (u32 *)BLOB_RAM_BASE;
		src = (u32 *)BLOB_FLASH_BASE;
		numWords = BLOB_FLASH_LEN / 4;
		blob_status.blobSize = 0;
		blob_status.blobType = fromFlash;
		SerialOutputString("Loading blob from flash ");
#ifdef PARAM_START
	} else if(strncmp(what, "param", 6) == 0) {
		dst = (u32 *)PARAM_RAM_BASE;
		src = (u32 *)PARAM_FLASH_BASE;
		numWords = PARAM_FLASH_LEN / 4;
		blob_status.paramSize = 0;
		blob_status.paramType = fromFlash;
		SerialOutputString("Loading paramater block from flash ");
#endif
	} else if(strncmp(what, "kernel", 7) == 0) {
		dst = (u32 *)KERNEL_RAM_BASE;
		src = (u32 *)KERNEL_FLASH_BASE;
		numWords = KERNEL_FLASH_LEN / 4;
		blob_status.kernelSize = 0;
		blob_status.kernelType = fromFlash;
		SerialOutputString("Loading kernel from flash ");
	} else if(strncmp(what, "ramdisk", 8) == 0) {
		dst = (u32 *)RAMDISK_RAM_BASE;
		src = (u32 *)RAMDISK_FLASH_BASE;
		numWords = RAMDISK_FLASH_LEN / 4;
		blob_status.ramdiskSize = 0;
		blob_status.ramdiskType = fromFlash;
		SerialOutputString("Loading ramdisk from flash ");
	} else {
		printerror(EINVAL, what);
		return 0;
	}

	MyMemCpy(dst, src, numWords);
	SerialOutputString(" done\n");

	return 0;
}




static int Reload(int argc, char *argv[])
{
	if(argc < 2)
		return -ENOPARAMS;

	return do_reload(argv[1]);
}

static char reloadhelp[] = "reload {blob|param|kernel|ramdisk}\n"
"Reload <argument> from flash to RAM\n";

__commandlist(Reload, "reload", reloadhelp);




static void PrintSerialSpeed(serial_baud_t speed)
{
	switch(speed) {
	case baud_1200:
		SerialOutputDec(1200);
		break;

	case baud_9600:
		SerialOutputDec(9600);
		break;

	case baud_19200:
		SerialOutputDec(19200);
		break;

	case baud_38400:
		SerialOutputDec(38400);
		break;

	case baud_57600:
		SerialOutputDec(57600);
		break;

	case baud_115200:
		SerialOutputDec(115200);
		break;

	case baud_230400:
		SerialOutputDec(230400);
		break;

	default:
		SerialOutputString("(unknown)");
		break;
	}
}




static void print_elf_sections(void)
{
#ifdef BLOB_DEBUG
	extern u32 __text_start, __text_end;
	extern u32 __rodata_start, __rodata_end;
	extern u32 __data_start, __data_end;
	extern u32 __got_start, __got_end;
	extern u32 __commandlist_start, __commandlist_end;
	extern u32 __initlist_start, __initlist_end;
	extern u32 __exitlist_start, __exitlist_end;
	extern u32 __ptagtable_begin, __ptagtable_end;
	extern u32 __bss_start, __bss_end;
	extern u32 __stack_start, __stack_end;

	SerialOutputString("ELF sections layout:\n");

#define PRINT_ELF_SECTION(from, to, name) \
	SerialOutputString("  0x"); \
	SerialOutputHex((u32)&(from)); \
	SerialOutputString(" - 0x"); \
	SerialOutputHex((u32)&(to)); \
	SerialOutputString(" " name "\n");


	PRINT_ELF_SECTION(__text_start, __text_end, ".text");
	PRINT_ELF_SECTION(__rodata_start, __rodata_end, ".rodata");
	PRINT_ELF_SECTION(__data_start, __data_end, ".data");
	PRINT_ELF_SECTION(__got_start, __got_end, ".got");
	PRINT_ELF_SECTION(__commandlist_start, __commandlist_end, ".commandlist");
	PRINT_ELF_SECTION(__initlist_start, __initlist_end, ".initlist");
	PRINT_ELF_SECTION(__exitlist_start, __exitlist_end, ".exitlist");
	PRINT_ELF_SECTION(__ptagtable_begin, __ptagtable_end, ".ptaglist");
	PRINT_ELF_SECTION(__bss_start, __bss_end, ".bss");
	PRINT_ELF_SECTION(__stack_start, __stack_end, ".stack (in .bss)");
#endif
}