cmd_usb.c

基于s3c2440的U盘读写程序

	if (ntohl(hdr->ih_magic) != IH_MAGIC) {
		s_UartPrint("\n** Bad Magic Number **\n");
		return 1;
	}
	checksum = ntohl(hdr->ih_hcrc);
	hdr->ih_hcrc = 0;
	if (crc32 (0, (uchar *)hdr, sizeof(image_header_t)) != checksum) {
		s_UartPrint("\n** Bad Header Checksum **\n");
		return 1;
	}
	hdr->ih_hcrc = htonl(checksum);	// restore checksum for later use //
	print_image_hdr (hdr);
	cnt = (ntohl(hdr->ih_size) + sizeof(image_header_t));
	cnt += info.blksz - 1;
	cnt /= info.blksz;
	cnt -= 1;
	if (stor_dev->block_read (dev, info.start+1, cnt,
		      (ulong *)(addr+info.blksz)) != cnt) {
		s_UartPrint("\n** Read error on %d:%d\n", dev, part);
		return 1;
	}
	// Loading ok, update default load address //
	load_addr = addr;
	flush_cache (addr, (cnt+1)*info.blksz);
	// Check if we should attempt an auto-start //
	if (((ep = getenv("autostart")) != NULL) && (strcmp(ep,"yes") == 0)) {
		char *local_args[2];
		extern int do_bootm (cmd_tbl_t *, int, int, char *[]);
		local_args[0] = argv[0];
		local_args[1] = NULL;
		s_UartPrint("Automatic boot of image at addr 0x%08lX ...\n", addr);
		rcode=do_bootm (cmdtp, 0, 1, local_args);
		return rcode;
	}
	return 0;
}


*/
/*
int s_usbhost_reset(void);
int s_usbhost_start(void);
int s_usbhost_stop(void);
int s_usbhost_tree(void);
int s_usbhost_scan(void);
int s_usbhost_stor(void);
int s_usbhost_part(void);
int s_usbhost_info(int argc, char *argv[]);
int s_usbhost_read(int argc, char *argv[]);
int s_usbhost_dev(int argc, char *argv[]);
"reset - reset (rescan) USB controller\n"
"usb stop [f]  - stop USB [f]=force stop\n"
"usb tree  - show USB device tree\n"
"usb info [dev] - show available USB devices\n"
"usb storage  - show details of USB storage devices\n"
"usb dev [dev] - show or set current USB storage device\n"
"usb part [dev] - print partition table of one or all USB storage devices\n"
"usb read addr blk# cnt - read `cnt' blocks starting at block `blk#'\n"
"    to memory address `addr'\n"
*/
int s_usbhost_reset(void)
{
    int i;
    struct usb_device *dev = NULL;
    block_dev_desc_t *stor_dev;
     
    usb_stop();
    s_UartPrint("Reset USB...\n");
    i = usb_init();
    /* try to recognize storage devices immediately */
    if (i >= 0)
    usb_stor_curr_dev = usb_stor_scan(1);
     
    return 0;
}


int s_usbhost_start(void)
{
    int i;
    //struct usb_device *dev = NULL;
    //block_dev_desc_t *stor_dev;
     
    usb_stop();
    s_UartPrint("(Re)start USB...\n");
    i = usb_init();
    /* try to recognize storage devices immediately */
    if (i >= 0)
    	{
    	
    usb_stor_curr_dev = usb_stor_scan(1);
    	}
    return 0;
}


int s_usbhost_stop(void)
{
     
    s_UartPrint("stopping USB..\n");
    usb_stop();
     
    return 0;
}


int s_usbhost_tree(void)
{
     
    s_UartPrint("\nDevice Tree:\n");
    usb_show_tree(usb_get_dev_index(0));
     
    return 0;
}


int s_usbhost_info(int argc, char *argv[])
{
    int i;
    struct usb_device *dev = NULL;
    block_dev_desc_t *stor_dev;
    int d;
     
    if (argc==2) 
    {
        for(d=0;d<USB_MAX_DEVICE;d++) 
        {
            dev=usb_get_dev_index(d);
            if (dev==NULL)
            break;
            usb_display_desc(dev);
            usb_display_config(dev);
        }
         
        return 0;
    }
    else 
    {
        i=simple_strtoul(argv[2], NULL, 16);
        s_UartPrint("config for device %d\n",i);
        for(d=0;d<USB_MAX_DEVICE;d++) 
        {
            dev=usb_get_dev_index(d);
            if (dev==NULL)
            break;
            if (dev->devnum==i)
            break;
        }
        if (dev==NULL) 
        {
            s_UartPrint("*** NO Device avaiable ***\n");
             
            return 0;
        }
        else 
        {
            usb_display_desc(dev);
            usb_display_config(dev);
        }
    }
     
    return 0;
}


int s_usbhost_scan(void)
{
     
    //s_UartPrint("  NOTE: this command is obsolete and will be phased out\n");
    //s_UartPrint("  please use 'usb storage' for USB storage devices information\n\n");
    usb_stor_info();
     
    return 0;
}


//int s_usbhost_stor(void)
//{
//	 
//	usb_stor_info();
//	 
//	return 0;
//}
int s_usbhost_part(void)
{
    int i;
    struct usb_device *dev = NULL;
    block_dev_desc_t *stor_dev;
    int devno, ok;
     
    for (ok=0, devno=0; devno<USB_MAX_STOR_DEV; ++devno) 
    {
        stor_dev=usb_stor_get_dev(devno);
        if (stor_dev->type!=DEV_TYPE_UNKNOWN) 
        {
            ok++;
            if (devno)
            s_UartPrint("\n");
            s_UartPrint("print_part of %x\n",devno);
            print_part(stor_dev);
        }
    }
     
    if (!ok) 
    {
        s_UartPrint("\nno USB devices available\n");
        return 1;
    }
    return 0;
}


int s_usbhost_read(unsigned long rblk,unsigned long rcnt,unsigned char* rbuffer)
{
    int i;
    struct usb_device *dev = NULL;
    block_dev_desc_t *stor_dev;	
    unsigned long addr =(unsigned long)rbuffer;
    unsigned long blk  = rblk;
    unsigned long cnt  = rcnt;
    unsigned long n;
    
    if (usb_stor_curr_dev<0) 
    {
        s_UartPrint("no current device selected\n");
        return 1;
    }
     

    s_UartPrint("\nUSB read: device %d block # %ld, count %ld  addr %08x... ",
    usb_stor_curr_dev, blk, cnt,addr);
    stor_dev=usb_stor_get_dev(usb_stor_curr_dev);
    n = stor_dev->block_read(usb_stor_curr_dev, blk, cnt, (ulong *)addr);
    s_UartPrint("%ld blocks read: %s\n",n,(n==cnt) ? "OK" : "ERROR");
     
    if (n==cnt)
    {
        s_UartPrint("buff[0]=%x",rbuffer[0]);
        s_UartPrint("buff[1]=%x",rbuffer[1]);
        return 0;
    }
    return 1;
}


int s_usbhost_dev(int dev)
{
    block_dev_desc_t *stor_dev;	
    s_UartPrint("\nUSB device %d: ", dev);
    if (dev >= USB_MAX_STOR_DEV) 
    {
        s_UartPrint("unknown device\n");
        return 1;
    }
     
    s_UartPrint("\n    Device %d: ", dev);
    stor_dev=usb_stor_get_dev(dev);
    dev_print(stor_dev);	
     
    if (stor_dev->type == DEV_TYPE_UNKNOWN) 
    {
        return 1;
    }
    usb_stor_curr_dev = dev;
    s_UartPrint("... is now current device\n");
    return 0;	
}


/*********************************************************************************
 * usb command intepreter
 */
int do_usb (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
    int i;
    struct usb_device *dev = NULL;
    block_dev_desc_t *stor_dev;
    if ((strncmp(argv[1], "reset", 5) == 0) ||
    (strncmp(argv[1], "start", 5) == 0))
    {
        usb_stop();
        s_UartPrint("(Re)start USB...\n");
        i = usb_init();
        /* try to recognize storage devices immediately */
        if (i >= 0)
        usb_stor_curr_dev = usb_stor_scan(1);
        return 0;
    }
    if (strncmp(argv[1],"stop",4) == 0) 
    {
        s_UartPrint("stopping USB..\n");
        usb_stop();
        return 0;
    }
    if (strncmp(argv[1],"tree",4) == 0) 
    {
        s_UartPrint("\nDevice Tree:\n");
        usb_show_tree(usb_get_dev_index(0));
        return 0;
    }
    if (strncmp(argv[1],"inf",3) == 0) 
    {
        int d;
        if (argc==2) 
        {
            for(d=0;d<USB_MAX_DEVICE;d++) 
            {
                dev=usb_get_dev_index(d);
                if (dev==NULL)
                break;
                usb_display_desc(dev);
                usb_display_config(dev);
            }
            return 0;
        }
        else 
        {
            int d;
            i=simple_strtoul(argv[2], NULL, 16);
            s_UartPrint("config for device %d\n",i);
            for(d=0;d<USB_MAX_DEVICE;d++) 
            {
                dev=usb_get_dev_index(d);
                if (dev==NULL)
                break;
                if (dev->devnum==i)
                break;
            }
            if (dev==NULL) 
            {
                s_UartPrint("*** NO Device avaiable ***\n");
                return 0;
            }
            else 
            {
                usb_display_desc(dev);
                usb_display_config(dev);
            }
        }
        return 0;
    }
    if (strncmp(argv[1], "scan", 4) == 0) 
    {
        s_UartPrint("  NOTE: this command is obsolete and will be phased out\n");
        s_UartPrint("  please use 'usb storage' for USB storage devices information\n\n");
        usb_stor_info();
        return 0;
    }
    if (strncmp(argv[1], "stor", 4) == 0) 
    {
        usb_stor_info();
        return 0;
    }
    if (strncmp(argv[1],"part",4) == 0) 
    {
        int devno, ok;
        for (ok=0, devno=0; devno<USB_MAX_STOR_DEV; ++devno) 
        {
            stor_dev=usb_stor_get_dev(devno);
            if (stor_dev->type!=DEV_TYPE_UNKNOWN) 
            {
                ok++;
                if (devno)
                s_UartPrint("\n");
                s_UartPrint("print_part of %x\n",devno);
                print_part(stor_dev);
            }
        }
        if (!ok) 
        {
            s_UartPrint("\nno USB devices available\n");
            return 1;
        }
        return 0;
    }
    if (strcmp(argv[1],"read") == 0) 
    {
        if (usb_stor_curr_dev<0) 
        {
            s_UartPrint("no current device selected\n");
            return 1;
        }
        if (argc==5) 
        {
            unsigned long addr = simple_strtoul(argv[2], NULL, 16);
            unsigned long blk  = simple_strtoul(argv[3], NULL, 16);
            unsigned long cnt  = simple_strtoul(argv[4], NULL, 16);
            unsigned long n;
            s_UartPrint("\nUSB read: device %d block # %ld, count %ld ... ",
            usb_stor_curr_dev, blk, cnt);
            stor_dev=usb_stor_get_dev(usb_stor_curr_dev);
            n = stor_dev->block_read(usb_stor_curr_dev, blk, cnt, (ulong *)addr);
            s_UartPrint("%ld blocks read: %s\n",n,(n==cnt) ? "OK" : "ERROR");
            if (n==cnt)
            return 0;
            return 1;
        }
    }
    if (strncmp(argv[1], "dev", 3) == 0) 
    {
        if (argc == 3) 
        {
            int dev = (int)simple_strtoul(argv[2], NULL, 10);
            s_UartPrint("\nUSB device %d: ", dev);
            if (dev >= USB_MAX_STOR_DEV) 
            {
                s_UartPrint("unknown device\n");
                return 1;
            }
            s_UartPrint("\n    Device %d: ", dev);
            stor_dev=usb_stor_get_dev(dev);
            dev_print(stor_dev);
            if (stor_dev->type == DEV_TYPE_UNKNOWN) 
            {
                return 1;
            }
            usb_stor_curr_dev = dev;
            s_UartPrint("... is now current device\n");
            return 0;
        }
        else 
        {
            s_UartPrint ("\nUSB device %d: ", usb_stor_curr_dev);
            stor_dev=usb_stor_get_dev(usb_stor_curr_dev);
            dev_print(stor_dev);
            if (stor_dev->type == DEV_TYPE_UNKNOWN) 
            {
                return 1;
            }
            return 0;
        }
        return 0;
    }
    s_UartPrint("Usage:\n%s\n", cmdtp->usage);
    return 1;
}