usb_shell_flash_utility.cpp

arm_bootloader _flash writter &USB

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <io.h>
#include <sys/stat.h>

#include "libusb/usb.h"
#include "usb_base.h"
#include "usb_shell.h"

#define NUM_FLASH_BLOCK				(4096)
#define NUM_FLASH_PAGE_PER_BLOCK	(32)
#define NUM_FLASH_PAGE				(NUM_FLASH_BLOCK * NUM_FLASH_PAGE_PER_BLOCK)
#define SIZE_FLASH_PAGE				(512)
#define SIZE_FLASH_BLOCK			(NUM_FLASH_PAGE_PER_BLOCK * SIZE_FLASH_PAGE)

int flash_erase(int argc, char *argv[])
{
	unsigned int flash_block_num;
	unsigned int cmd_code = USB_CMD_FLASH_ERASE;

	if(argc < 1)
	{
		printf("Usage: flash_erase [Flash Block Number]\n");
		return -1;
	}
	sscanf(argv[0], "%d", &flash_block_num);

	/* ---------- BEGIN USB Conversation ---------- */

	usb_cmd_t usb_cmd = {0};
	usb_cmd.usb_command = cmd_code;
	usb_cmd.usb_parameter[0] = flash_block_num;
	usb_cmd.usb_seq_num = G_usb_seq_num;
	if(bulk_write(G_usb_dev, &usb_cmd, sizeof(usb_cmd)) < 0)
	{
		printf("Write error\n");
		return -1;
	}
	else
	{
		// ACK phase
		return usb_read_ack(cmd_code, G_usb_seq_num);
	}
}

int flash_read(int argc, char *argv[])
{
	unsigned int flash_start_page;
	unsigned int num_flash_page;
	unsigned int cmd_code = USB_CMD_FLASH_READ_PAGE;
	char *filename;

	if(argc < 3)
	{
		printf("Usage: flash_read [Flash Start Page] [Number of page] [File To Store]\n");
		return -1;
	}

	sscanf(argv[0], "%d", &flash_start_page);
	sscanf(argv[1], "%d", &num_flash_page);
	filename = argv[2];
	if(num_flash_page == 0)
	{
		printf("Wrong page number !!\n");
		return -1;
	}
	if(flash_start_page+num_flash_page-1 >= NUM_FLASH_PAGE - 1) // total 64MB, 131072 blocks
	{
		printf("Invalid page range !!\n");
		return -1;
	}

	/* ---------- BEGIN USB Conversation ---------- */

	usb_cmd_t usb_cmd = {0};
	usb_cmd.usb_command = cmd_code;
	usb_cmd.usb_parameter[0] = flash_start_page;
	usb_cmd.usb_parameter[1] = num_flash_page;
	usb_cmd.usb_seq_num = G_usb_seq_num;
	if(bulk_write(G_usb_dev, &usb_cmd, sizeof(usb_cmd)) < 0)
	{
		printf("Write error\n");
		return -1;
	}
	else
	{
		unsigned char buf[SIZE_FLASH_PAGE];
		int fd;

		fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC | O_BINARY, _S_IREAD | _S_IWRITE);
		if(fd < 0)
		{
			printf("Unable to open file !!\n");
			return -1;
		}

		for(unsigned int i=0; i<num_flash_page; i++)
		{
			bulk_read(G_usb_dev, buf, SIZE_FLASH_PAGE);
			if(write(fd, buf, SIZE_FLASH_PAGE) != SIZE_FLASH_PAGE)
			{
				printf("Write output file error !!\n");
				return -1;
			}
		}
		close(fd);

		// ACK phase
		return usb_read_ack(cmd_code, G_usb_seq_num);
	}
}


int flash_write(int argc, char *argv[])
{
	unsigned int flash_start_block, num_flash_block;
	unsigned int flash_start_page, num_flash_page;
	unsigned int cmd_code = USB_CMD_FLASH_WRITE;
	int length;
	int fd;
	char *filename;
	unsigned int i;

	if(argc < 2)
	{
		printf("Usage: flash_write [Flash Start Block] [File To Write]\n");
		return -1;
	}

	/* Check input parameters */
	sscanf(argv[0], "%d", &flash_start_block);
	filename = argv[1];

	fd = open(filename, O_RDONLY | O_BINARY);
	if(fd < 0)
	{
		printf("Open file error !!\n");
		return -1;
	}
	length = filelength(fd);
	num_flash_block = (length+SIZE_FLASH_BLOCK-1) / SIZE_FLASH_BLOCK;
	printf("File size=%d, # of flash block=%d\n", length, num_flash_block);
	
	if(flash_start_block+num_flash_block-1 > NUM_FLASH_BLOCK-1)
	{
		printf("Flash block number exceed limit!!\n");
		return -1;
	}

	/* Erase the flash block to be written */
	for(i=0; i<num_flash_block; i++)
	{
		int argc = 1;
		char *argv[1];
		int flash_block = i+flash_start_block;

		argv[0] = new char[32];
		itoa(flash_block, argv[0], 10);

		printf("Erase block %d....", flash_block);
		flash_erase(argc, argv);
	}

	/* ---------- BEGIN USB Conversation ---------- */

	/* Unit conversion */
	flash_start_page = flash_start_block*NUM_FLASH_PAGE_PER_BLOCK;
	num_flash_page = num_flash_block*NUM_FLASH_PAGE_PER_BLOCK;

	usb_cmd_t usb_cmd = {0};
	usb_cmd.usb_command = cmd_code;
	usb_cmd.usb_parameter[0] = flash_start_page;
	usb_cmd.usb_parameter[1] = num_flash_page;
	usb_cmd.usb_seq_num = G_usb_seq_num;
	if(bulk_write(G_usb_dev, &usb_cmd, sizeof(usb_cmd)) < 0)
	{
		printf("Write error\n");
		return -1;
	}
	else
	{
		/* file already opened */
		unsigned char buf[SIZE_FLASH_PAGE];
		unsigned char flash_ok_buf[3];
		for(i=0; i<num_flash_page; i++)
		{
			int ret, byte_to_stuff;

			ret = read(fd, buf, SIZE_FLASH_PAGE);
			byte_to_stuff = SIZE_FLASH_PAGE - ret;
			if(byte_to_stuff > 0)
				memset(buf+ret, 0xFF, byte_to_stuff);
			if(bulk_write(G_usb_dev, buf, 512) < 0)
			{
				printf("%d\n", ret);
				printf("Write error !!\n");
				return -1;
			}
			bulk_read(G_usb_dev, flash_ok_buf, 2);	// wait for flash writing done
		}
		close(fd);

		// ACK phase
		return usb_read_ack(cmd_code, G_usb_seq_num);
	}

}