usb_storage.c

看到最近大家都关心 usbhost 的实现, 论坛上能找到的代码仅是一些简单的 demo , 完整的源码级的协议层是找不到的 我就贡献一把, 将我前一段时间移植成功的 USBHost 代码奉上 注

/*
 * Most of this source has been derived from the Linux USB
 * project:
 *   (c) 1999-2002 Matthew Dharm ([e-mail])
 *   (c) 2000 David L. Brown, Jr. ([e-mail])
 *   (c) 1999 Michael Gee ([e-mail])
 *   (c) 2000 Yggdrasil Computing, Inc.
 *
 *
 * Adapted for U-Boot:
 *   (C) Copyright 2001 Denis Peter, MPL AG Switzerland
 *
 * For BBB support (C) Copyright 2003
 * Gary Jennejohn, DENX Software Engineering <[e-mail]>
 *
 * BBB support based on /sys/dev/usb/umass.c from
 * FreeBSD.
 *
 * See file CREDITS for list of people who contributed to this
 * project.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.   See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 * MA 02111-1307 USA
 *
 */
/* Note:
 * Currently only the CBI transport protocoll has been implemented, and it
 * is only tested with a TEAC USB Floppy. Other Massstorages with CBI or CB
 * transport protocoll may work as well.
 */
/*
 * New Note:
 * Support for USB Mass Storage Devices (BBB) has been added. It has
 * only been tested with USB memory sticks.
 * Nota bene: if you are using the BBB support with a little-endian
 * CPU then you MUST define LITTLEENDIAN in the configuration file!
 */
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "..\hardware\LPC2468.h"  /* 24xx Peripheral Registers */
#include "..\rtxOS\rtl.h"
#include "usbhost.h"

#include "usb.h"
#include "scsi.h"



#define USB_STOR_PRINTF(fmt,args...)

/* direction table -- this indicates the direction of the data
 * transfer for each command code -- a 1 indicates input
 */
unsigned char us_direction[256/8] = 
{
    0x28, 0x81, 0x14, 0x14, 0x20, 0x01, 0x90, 0x77,
    0x0C, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};


#define US_DIRECTION(x) ((us_direction[x>>3] >> (x & 7)) & 1)

static ccb usb_ccb;
/*
 * CBI style
 */
#define US_CBI_ADSC    0

/*
 * BULK only
 */
#define US_BBB_RESET           0xff
#define US_BBB_GET_MAX_LUN  0xfe

/* Command Block Wrapper */
typedef struct 
{
    unsigned int    dCBWSignature;
    #define CBWSIGNATURE  0x43425355
    unsigned int    dCBWTag;
    unsigned int    dCBWDataTransferLength;
    unsigned char    bCBWFlags;
    #define CBWFLAGS_OUT  0x00
    #define CBWFLAGS_IN   0x80
    unsigned char    bCBWLUN;
    unsigned char    bCDBLength;
    #define CBWCDBLENGTH  16
    unsigned char    CBWCDB[CBWCDBLENGTH];
} umass_bbb_cbw_t;

#define UMASS_BBB_CBW_SIZE  31
static unsigned int CBWTag = 0;

/* Command Status Wrapper */
typedef struct 
{   unsigned int    dCSWSignature;
    #define CSWSIGNATURE  0x53425355
    unsigned int    dCSWTag;
    unsigned int    dCSWDataResidue;
    unsigned char    bCSWStatus;
    #define CSWSTATUS_GOOD  0x0
    #define CSWSTATUS_FAILED 0x1
    #define CSWSTATUS_PHASE  0x2
} umass_bbb_csw_t;
#define UMASS_BBB_CSW_SIZE  13

//#define USB_MAX_STOR_DEV    5
static int usb_max_devs = 0; /* number of highest available usb device */

static block_dev_desc_t usb_dev_desc[USB_MAX_STOR_DEV];

struct us_data;
typedef int (*trans_cmnd)(ccb*, struct us_data*);
typedef int (*trans_reset)(struct us_data*);

struct us_data 
{   struct usb_device  *pusb_dev;     /* this usb_device */
    unsigned int   flags;             /* from filter initially */
    unsigned char  ifnum;             /* interface number */
    unsigned char  ep_in;             /* in endpoint */
    unsigned char  ep_out;            /* out ....... */
    unsigned char  ep_int;            /* interrupt . */
    unsigned char  subclass;          /* as in overview */
    unsigned char  protocol;          /* .............. */
    unsigned char  attention_done;    /* force attn on first cmd */
    unsigned short ip_data;           /* interrupt data */
    int            action;            /* what to do */
    int            ip_wanted;         /* needed */
    int            *irq_handle;       /* for USB int requests */
    unsigned int   irqpipe;           /* pipe for release_irq */
    unsigned char  irqmaxp;           /* max packed for irq Pipe */
    unsigned char  irqinterval;       /* Intervall for IRQ Pipe */
    ccb            *srb;              /* current srb */
    trans_reset    transport_reset;   /* reset routine */
    trans_cmnd     transport;         /* transport routine */
};


static struct us_data usb_stor[USB_MAX_STOR_DEV];

#define USB_STOR_TRANSPORT_GOOD     0
#define USB_STOR_TRANSPORT_FAILED   -1
#define USB_STOR_TRANSPORT_ERROR    -2

int usb_stor_get_info(struct usb_device *dev, struct us_data *us, block_dev_desc_t *dev_desc);
int usb_storage_probe(struct usb_device *dev, unsigned int ifnum,struct us_data *ss);
unsigned long usb_stor_read(int device, unsigned long blknr, unsigned long blkcnt, void *buffer);
unsigned long usb_stor_write(int device, unsigned long blknr, unsigned long blkcnt, void *buffer);
struct usb_device * usb_get_dev_index(int index);
void uhci_show_temp_int_td(void);

block_dev_desc_t *usb_stor_get_dev(int index)
{
    return (index < USB_MAX_STOR_DEV) ? &usb_dev_desc[index] : NULL;
}


void usb_show_progress(void)
{
    //USB_STOR_PRINTF(".");
}

/*********************************************************************************
 * show info on storage devices; 'usb start/init' must be invoked earlier
 * as we only retrieve structures populated during devices initialization
 */
int usb_stor_exists(void)
{
    if (usb_max_devs > 0)
    { return 1;
    }
    else
    { return 0;
    }
}


/*********************************************************************************
 * scan the usb and reports device info
 * to the user if mode = 1
 * returns current device or -1 if no
 */
int usb_stor_scan()
{
unsigned char i;
struct usb_device *dev;
    
    usb_disable_asynch(1); /* asynch transfer not allowed */

    for(i=0; i<USB_MAX_STOR_DEV; i++)
    {
      memset(&usb_dev_desc[i], 0, sizeof(block_dev_desc_t));
      usb_dev_desc[i].target      = 0xff;
      usb_dev_desc[i].if_type     = IF_TYPE_USB;
      usb_dev_desc[i].dev         = i;
      usb_dev_desc[i].part_type   = PART_TYPE_UNKNOWN;
      usb_dev_desc[i].block_read  = usb_stor_read;
      usb_dev_desc[i].block_write = usb_stor_write;
    }
    
    usb_max_devs = 0;

    for(i=0; i<USB_MAX_DEVICE; i++) 
    {
        dev = usb_get_dev_index(i); /* get device */

        if(dev == NULL) 
        { continue; /* no more devices avaiable */
        }
        if(usb_storage_probe(dev, 0, &usb_stor[usb_max_devs])) 
        { /* ok, it is a storage devices */
          /* get info and fill it in */
          if(usb_stor_get_info(dev, &usb_stor[usb_max_devs], &usb_dev_desc[usb_max_devs]))
          { usb_max_devs++; }
        } 
        
        /* if storage device */
        if(usb_max_devs == USB_MAX_STOR_DEV) 
        { break;
        }
    } 
    
    /* for */
    usb_disable_asynch(0); /* asynch transfer allowed */
    
    if(usb_max_devs > 0)
    { return 0; }
    else
    { return-1; }
}


static int usb_stor_irq(struct usb_device *dev)
{
struct us_data *us;
    us = (struct us_data *)dev->privptr;
    
    if(us->ip_wanted) 
    { us->ip_wanted=0;
    }
    return 0;
}

/***********************************************************************
 * Data transfer routines
 ***********************************************************************/
static int us_one_transfer(struct us_data *us, int pipe, char *buf, int length)
{
int max_size;
int this_xfer;
int result;
int partial;
int maxtry;
int stat;
    /* determine the maximum packet size for these transfers */
    max_size = usb_maxpacket(us->pusb_dev, pipe) * 16;
    /* while we have data left to transfer */
    while (length) 
    {
      /* calculate how long this will be -- maximum or a remainder */
      this_xfer = length > max_size ? max_size : length;
      length   -= this_xfer;
      /* setup the retry counter */
      maxtry = 10;
      /* set up the transfer loop */
      do 
      {
        /* transfer the data */
        result = usb_bulk_msg(us->pusb_dev, pipe, buf, this_xfer, &partial, USB_CNTL_TIMEOUT*5);
        
        if(us->pusb_dev->status != 0) 
        { 
          /* if we stall, we need to clear it before we go on */
          if (us->pusb_dev->status & USB_ST_STALLED) 
          {
            stat = us->pusb_dev->status;
            usb_clear_halt(us->pusb_dev, pipe);
            us->pusb_dev->status = stat;

            if(this_xfer == partial) 
            { /* bulk transferred with error %X, but data ok\n",us->pusb_dev->status); */
              return 0;
            }
            else
            { return result;  }
          }
          if (us->pusb_dev->status & USB_ST_NAK_REC) 
          {
            return result;  /* Device NAKed bulk_msg\n"); */
          }
          if(this_xfer == partial) 
          {
            /* bulk transferred with error %d, but data ok\n",us->pusb_dev->status); */
            return 0;
          }
          /* if our try counter reaches 0, bail out */
          if (!maxtry--)
          { return result;  }
        }
        /* update to show what data was transferred */
        this_xfer -= partial;
        buf       += partial;
        /* continue until this transfer is done */
      } 
      while ( this_xfer );
    }
    /* if we get here, we're done and successful */
    return 0;
}


static int usb_stor_BBB_reset(struct us_data *us)
{
int result;
unsigned int pipe;
    /*
       * Reset recovery (5.3.4 in Universal Serial Bus Mass Storage Class)
       *
       * For Reset Recovery the host shall issue in the following order:
       * a) a Bulk-Only Mass Storage Reset
       * b) a Clear Feature HALT to the Bulk-In endpoint
       * c) a Clear Feature HALT to the Bulk-Out endpoint
       *
       * This is done in 3 steps.
       *
       * If the reset doesn't succeed, the device should be port reset.
       *
       * This comment stolen from FreeBSD's /sys/dev/usb/umass.c.
       */
    result = usb_control_msg(us->pusb_dev, usb_sndctrlpipe(us->pusb_dev,0), US_BBB_RESET, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                            0, us->ifnum, 0, 0, USB_CNTL_TIMEOUT*5);
    
    if((result < 0) && (us->pusb_dev->status & USB_ST_STALLED))
    { return -1;  //USB_STOR_PRINTF("RESET:stall\n");
    }
    /* long wait for reset */
    os_dly_wait(15);
    
    pipe = usb_rcvbulkpipe(us->pusb_dev, us->ep_in);
    result = usb_clear_halt(us->pusb_dev, pipe);
    /* long wait for reset */
    os_dly_wait(15);

    
    /* long wait for reset */
    pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out);
    result = usb_clear_halt(us->pusb_dev, pipe);
    os_dly_wait(15);

    return 0;
}


/* FIXME: this reset function doesn't really reset the port, and it
 * should. Actually it should probably do what it's doing here, and
 * reset the port physically
 */
static int usb_stor_CB_reset(struct us_data *us)
{
unsigned char *cmd;
    cmd = malloc(12);
    if(cmd == NULL) return -1;

    memset(cmd, 0xFF, 12);
    cmd[0] = SCSI_SEND_DIAG;
    cmd[1] = 4;
    usb_control_msg(us->pusb_dev, usb_sndctrlpipe(us->pusb_dev,0),
                            US_CBI_ADSC, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                            0, us->ifnum, cmd, sizeof(cmd), USB_CNTL_TIMEOUT*5);
    /* long wait for reset */
    os_dly_wait(150);
    
    usb_clear_halt(us->pusb_dev, usb_rcvbulkpipe(us->pusb_dev, us->ep_in));
    usb_clear_halt(us->pusb_dev, usb_rcvbulkpipe(us->pusb_dev, us->ep_out));
    
    free(cmd);
    return 0;
}


/*
 * Set up the command for a BBB device. Note that the actual SCSI
 * command is copied into cbw.CBWCDB.
 */
int usb_stor_BBB_comdat(ccb *srb, struct us_data *us)
{
int result;
int actlen;
int dir_in;
unsigned int pipe;
umass_bbb_cbw_t *cbw;
    dir_in = US_DIRECTION(srb->cmd[0]);
    
    /* sanity checks */
    if (!(srb->cmdlen <= CBWCDBLENGTH))