git.sur5r.net Git - u-boot/blob - common/usb_storage.c

   1 /*
   2  * (C) Copyright 2001
   3  * Denis Peter, MPL AG Switzerland
   4  *
   5  * For BBB support (C) Copyright 2003
   6  * Gary Jennejohn, DENX Software Engineering <gj@denx.de>
   7  *
   8  * Most of this source has been derived from the Linux USB
   9  * project. BBB support based on /sys/dev/usb/umass.c from
  10  * FreeBSD.
  11  *
  12  * See file CREDITS for list of people who contributed to this
  13  * project.
  14  *
  15  * This program is free software; you can redistribute it and/or
  16  * modify it under the terms of the GNU General Public License as
  17  * published by the Free Software Foundation; either version 2 of
  18  * the License, or (at your option) any later version.
  19  *
  20  * This program is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23  * GNU General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU General Public License
  26  * along with this program; if not, write to the Free Software
  27  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  28  * MA 02111-1307 USA
  29  *
  30  */
  31
  32 /* Note:
  33  * Currently only the CBI transport protocoll has been implemented, and it
  34  * is only tested with a TEAC USB Floppy. Other Massstorages with CBI or CB
  35  * transport protocoll may work as well.
  36  */
  37 /*
  38  * New Note:
  39  * Support for USB Mass Storage Devices (BBB) has been added. It has
  40  * only been tested with USB memory sticks.
  41  * Nota bene: if you are using the BBB support with a little-endian
  42  * CPU then you MUST define LITTLEENDIAN in the configuration file!
  43  */
  44
  45
  46 #include <common.h>
  47 #include <command.h>
  48 #include <asm/processor.h>
  49
  50
  51 #if (CONFIG_COMMANDS & CFG_CMD_USB)
  52 #include <usb.h>
  53
  54 #ifdef CONFIG_USB_STORAGE
  55
  56 #undef  USB_STOR_DEBUG
  57
  58 #ifdef  USB_STOR_DEBUG
  59 #define USB_STOR_PRINTF(fmt,args...)    printf (fmt ,##args)
  60 #else
  61 #define USB_STOR_PRINTF(fmt,args...)
  62 #endif
  63
  64 #include <scsi.h>
  65 /* direction table -- this indicates the direction of the data
  66  * transfer for each command code -- a 1 indicates input
  67  */
  68 unsigned char us_direction[256/8] = {
  69         0x28, 0x81, 0x14, 0x14, 0x20, 0x01, 0x90, 0x77,
  70         0x0C, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
  71         0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01,
  72         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  73 };
  74 #define US_DIRECTION(x) ((us_direction[x>>3] >> (x & 7)) & 1)
  75
  76 static unsigned char usb_stor_buf[512];
  77 static ccb usb_ccb;
  78
  79 /*
  80  * CBI style
  81  */
  82
  83 #define US_CBI_ADSC             0
  84
  85 /*
  86  * BULK only
  87  */
  88 #define US_BBB_RESET            0xff
  89 #define US_BBB_GET_MAX_LUN      0xfe
  90
  91 /* Command Block Wrapper */
  92 typedef struct {
  93         __u32           dCBWSignature;
  94 #       define CBWSIGNATURE     0x43425355
  95         __u32           dCBWTag;
  96         __u32           dCBWDataTransferLength;
  97         __u8            bCBWFlags;
  98 #       define CBWFLAGS_OUT     0x00
  99 #       define CBWFLAGS_IN      0x80
 100         __u8            bCBWLUN;
 101         __u8            bCDBLength;
 102 #       define CBWCDBLENGTH     16
 103         __u8            CBWCDB[CBWCDBLENGTH];
 104 } umass_bbb_cbw_t;
 105 #define UMASS_BBB_CBW_SIZE      31
 106 static __u32 CBWTag = 0;
 107
 108 /* Command Status Wrapper */
 109 typedef struct {
 110         __u32           dCSWSignature;
 111 #       define CSWSIGNATURE     0x53425355
 112         __u32           dCSWTag;
 113         __u32           dCSWDataResidue;
 114         __u8            bCSWStatus;
 115 #       define CSWSTATUS_GOOD   0x0
 116 #       define CSWSTATUS_FAILED 0x1
 117 #       define CSWSTATUS_PHASE  0x2
 118 } umass_bbb_csw_t;
 119 #define UMASS_BBB_CSW_SIZE      13
 120
 121 #define USB_MAX_STOR_DEV 5
 122 static int usb_max_devs; /* number of highest available usb device */
 123
 124 static block_dev_desc_t usb_dev_desc[USB_MAX_STOR_DEV];
 125
 126 struct us_data;
 127 typedef int (*trans_cmnd)(ccb*, struct us_data*);
 128 typedef int (*trans_reset)(struct us_data*);
 129
 130 struct us_data {
 131         struct usb_device       *pusb_dev;       /* this usb_device */
 132         unsigned int            flags;           /* from filter initially */
 133         unsigned char           ifnum;           /* interface number */
 134         unsigned char           ep_in;           /* in endpoint */
 135         unsigned char           ep_out;          /* out ....... */
 136         unsigned char           ep_int;          /* interrupt . */
 137         unsigned char           subclass;        /* as in overview */
 138         unsigned char           protocol;        /* .............. */
 139         unsigned char           attention_done;  /* force attn on first cmd */
 140         unsigned short  ip_data;         /* interrupt data */
 141         int                                                     action;          /* what to do */
 142         int                                                     ip_wanted; /* needed */
 143         int                                                     *irq_handle;     /* for USB int requests */
 144         unsigned int            irqpipe;         /* pipe for release_irq */
 145         unsigned char           irqmaxp;        /* max packed for irq Pipe */
 146         unsigned char   irqinterval; /* Intervall for IRQ Pipe */
 147         ccb                                                     *srb;            /* current srb */
 148         trans_reset                     transport_reset; /* reset routine */
 149         trans_cmnd                      transport; /* transport routine */
 150 };
 151
 152 static struct us_data usb_stor[USB_MAX_STOR_DEV];
 153
 154
 155 #define USB_STOR_TRANSPORT_GOOD    0
 156 #define USB_STOR_TRANSPORT_FAILED -1
 157 #define USB_STOR_TRANSPORT_ERROR  -2
 158
 159
 160 int usb_stor_get_info(struct usb_device *dev, struct us_data *us, block_dev_desc_t *dev_desc);
 161 int usb_storage_probe(struct usb_device *dev, unsigned int ifnum,struct us_data *ss);
 162 unsigned long usb_stor_read(int device, unsigned long blknr, unsigned long blkcnt, unsigned long *buffer);
 163 struct usb_device * usb_get_dev_index(int index);
 164 void uhci_show_temp_int_td(void);
 165
 166 block_dev_desc_t *usb_stor_get_dev(int index)
 167 {
 168         return &usb_dev_desc[index];
 169 }
 170
 171
 172 void usb_show_progress(void)
 173 {
 174         printf(".");
 175 }
 176
 177 /*********************************************************************************
 178  * (re)-scan the usb and reports device info
 179  * to the user if mode = 1
 180  * returns current device or -1 if no
 181  */
 182 int usb_stor_scan(int mode)
 183 {
 184         unsigned char i;
 185         struct usb_device *dev;
 186
 187         /* GJ */
 188         memset(usb_stor_buf, 0, sizeof(usb_stor_buf));
 189
 190         if(mode==1) {
 191                 printf("scanning bus for storage devices...\n");
 192         }
 193         usb_disable_asynch(1); /* asynch transfer not allowed */
 194
 195         for(i=0;i<USB_MAX_STOR_DEV;i++) {
 196                 memset(&usb_dev_desc[i],0,sizeof(block_dev_desc_t));
 197                 usb_dev_desc[i].target=0xff;
 198                 usb_dev_desc[i].if_type=IF_TYPE_USB;
 199                 usb_dev_desc[i].dev=i;
 200                 usb_dev_desc[i].part_type=PART_TYPE_UNKNOWN;
 201                 usb_dev_desc[i].block_read=usb_stor_read;
 202         }
 203         usb_max_devs=0;
 204         for(i=0;i<USB_MAX_DEVICE;i++) {
 205                 dev=usb_get_dev_index(i); /* get device */
 206                 USB_STOR_PRINTF("i=%d\n",i);
 207                 if(dev==NULL) {
 208                         break; /* no more devices avaiable */
 209                 }
 210                 if(usb_storage_probe(dev,0,&usb_stor[usb_max_devs])) { /* ok, it is a storage devices */
 211                         /* get info and fill it in */
 212
 213                         if(usb_stor_get_info(dev, &usb_stor[usb_max_devs], &usb_dev_desc[usb_max_devs])) {
 214                                 if(mode==1) {
 215                                         printf ("  Device %d: ", usb_max_devs);
 216                                         dev_print(&usb_dev_desc[usb_max_devs]);
 217                                 } /* if mode */
 218                                 usb_max_devs++;
 219                         } /* if get info ok */
 220                 } /* if storage device */
 221                 if(usb_max_devs==USB_MAX_STOR_DEV) {
 222                         printf("max USB Storage Device reached: %d stopping\n",usb_max_devs);
 223                         break;
 224                 }
 225         } /* for */
 226         usb_disable_asynch(0); /* asynch transfer allowed */
 227         if(usb_max_devs>0)
 228                 return 0;
 229         else
 230                 return-1;
 231 }
 232
 233 static int usb_stor_irq(struct usb_device *dev)
 234 {
 235         struct us_data *us;
 236         us=(struct us_data *)dev->privptr;
 237
 238         if(us->ip_wanted) {
 239                 us->ip_wanted=0;
 240         }
 241         return 0;
 242 }
 243
 244
 245 #ifdef  USB_STOR_DEBUG
 246
 247 static void usb_show_srb(ccb * pccb)
 248 {
 249         int i;
 250         printf("SRB: len %d datalen 0x%lX\n ",pccb->cmdlen,pccb->datalen);
 251         for(i=0;i<12;i++) {
 252                 printf("%02X ",pccb->cmd[i]);
 253         }
 254         printf("\n");
 255 }
 256
 257 static void display_int_status(unsigned long tmp)
 258 {
 259         printf("Status: %s %s %s %s %s %s %s\n",
 260                 (tmp & USB_ST_ACTIVE) ? "Active" : "",
 261                 (tmp & USB_ST_STALLED) ? "Stalled" : "",
 262                 (tmp & USB_ST_BUF_ERR) ? "Buffer Error" : "",
 263                 (tmp & USB_ST_BABBLE_DET) ? "Babble Det" : "",
 264                 (tmp & USB_ST_NAK_REC) ? "NAKed" : "",
 265                 (tmp & USB_ST_CRC_ERR) ? "CRC Error" : "",
 266                 (tmp & USB_ST_BIT_ERR) ? "Bitstuff Error" : "");
 267 }
 268 #endif
 269 /***********************************************************************
 270  * Data transfer routines
 271  ***********************************************************************/
 272
 273 static int us_one_transfer(struct us_data *us, int pipe, char *buf, int length)
 274 {
 275         int max_size;
 276         int this_xfer;
 277         int result;
 278         int partial;
 279         int maxtry;
 280         int stat;
 281
 282         /* determine the maximum packet size for these transfers */
 283         max_size = usb_maxpacket(us->pusb_dev, pipe) * 16;
 284
 285         /* while we have data left to transfer */
 286         while (length) {
 287
 288                 /* calculate how long this will be -- maximum or a remainder */
 289                 this_xfer = length > max_size ? max_size : length;
 290                 length -= this_xfer;
 291
 292                 /* setup the retry counter */
 293                 maxtry = 10;
 294
 295                 /* set up the transfer loop */
 296                 do {
 297                         /* transfer the data */
 298                         USB_STOR_PRINTF("Bulk xfer 0x%x(%d) try #%d\n",
 299                                   (unsigned int)buf, this_xfer, 11 - maxtry);
 300                         result = usb_bulk_msg(us->pusb_dev, pipe, buf,
 301                                               this_xfer, &partial, USB_CNTL_TIMEOUT*5);
 302                         USB_STOR_PRINTF("bulk_msg returned %d xferred %d/%d\n",
 303                                   result, partial, this_xfer);
 304                         if(us->pusb_dev->status!=0) {
 305                                 /* if we stall, we need to clear it before we go on */
 306 #ifdef USB_STOR_DEBUG
 307                                 display_int_status(us->pusb_dev->status);
 308 #endif
 309                                 if (us->pusb_dev->status & USB_ST_STALLED) {
 310                                         USB_STOR_PRINTF("stalled ->clearing endpoint halt for pipe 0x%x\n", pipe);
 311                                         stat = us->pusb_dev->status;
 312                                         usb_clear_halt(us->pusb_dev, pipe);
 313                                         us->pusb_dev->status=stat;
 314                                         if(this_xfer == partial) {
 315                                                 USB_STOR_PRINTF("bulk transferred with error %X, but data ok\n",us->pusb_dev->status);
 316                                                 return 0;
 317                                         }
 318                                         else
 319                                                 return result;
 320                                 }
 321                                 if (us->pusb_dev->status & USB_ST_NAK_REC) {
 322                                         USB_STOR_PRINTF("Device NAKed bulk_msg\n");
 323                                         return result;
 324                                 }
 325                                 if(this_xfer == partial) {
 326                                         USB_STOR_PRINTF("bulk transferred with error %d, but data ok\n",us->pusb_dev->status);
 327                                         return 0;
 328                                 }
 329                                 /* if our try counter reaches 0, bail out */
 330                                 USB_STOR_PRINTF("bulk transferred with error %d, data %d\n",us->pusb_dev->status,partial);
 331                                 if (!maxtry--)
 332                                                 return result;
 333                         }
 334                         /* update to show what data was transferred */
 335                         this_xfer -= partial;
 336                         buf += partial;
 337                         /* continue until this transfer is done */
 338                 } while ( this_xfer );
 339         }
 340
 341         /* if we get here, we're done and successful */
 342         return 0;
 343 }
 344
 345 static int usb_stor_BBB_reset(struct us_data *us)
 346 {
 347         int result;
 348         unsigned int pipe;
 349
 350         /*
 351          * Reset recovery (5.3.4 in Universal Serial Bus Mass Storage Class)
 352          *
 353          * For Reset Recovery the host shall issue in the following order:
 354          * a) a Bulk-Only Mass Storage Reset
 355          * b) a Clear Feature HALT to the Bulk-In endpoint
 356          * c) a Clear Feature HALT to the Bulk-Out endpoint
 357          *
 358          * This is done in 3 steps.
 359          *
 360          * If the reset doesn't succeed, the device should be port reset.
 361          *
 362          * This comment stolen from FreeBSD's /sys/dev/usb/umass.c.
 363          */
 364         USB_STOR_PRINTF("BBB_reset\n");
 365         result = usb_control_msg(us->pusb_dev, usb_sndctrlpipe(us->pusb_dev,0),
 366                                  US_BBB_RESET, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
 367                                  0, us->ifnum, 0, 0, USB_CNTL_TIMEOUT*5);
 368         if((result < 0) && (us->pusb_dev->status & USB_ST_STALLED))
 369         {
 370                 USB_STOR_PRINTF("RESET:stall\n");
 371                 return -1;
 372         }
 373         /* long wait for reset */
 374         wait_ms(150);
 375         USB_STOR_PRINTF("BBB_reset result %d: status %X reset\n",result,us->pusb_dev->status);
 376         pipe = usb_rcvbulkpipe(us->pusb_dev, us->ep_in);
 377         result = usb_clear_halt(us->pusb_dev, pipe);
 378         /* long wait for reset */
 379         wait_ms(150);
 380         USB_STOR_PRINTF("BBB_reset result %d: status %X clearing IN endpoint\n",result,us->pusb_dev->status);
 381         /* long wait for reset */
 382         pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out);
 383         result = usb_clear_halt(us->pusb_dev, pipe);
 384         wait_ms(150);
 385         USB_STOR_PRINTF("BBB_reset result %d: status %X clearing OUT endpoint\n",result,us->pusb_dev->status);
 386         USB_STOR_PRINTF("BBB_reset done\n");
 387         return 0;
 388 }
 389
 390 /* FIXME: this reset function doesn't really reset the port, and it
 391  * should. Actually it should probably do what it's doing here, and
 392  * reset the port physically
 393  */
 394 static int usb_stor_CB_reset(struct us_data *us)
 395 {
 396         unsigned char cmd[12];
 397         int result;
 398
 399         USB_STOR_PRINTF("CB_reset\n");
 400         memset(cmd, 0xFF, sizeof(cmd));
 401         cmd[0] = SCSI_SEND_DIAG;
 402         cmd[1] = 4;
 403         result = usb_control_msg(us->pusb_dev, usb_sndctrlpipe(us->pusb_dev,0),
 404                                  US_CBI_ADSC, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
 405                                  0, us->ifnum, cmd, sizeof(cmd), USB_CNTL_TIMEOUT*5);
 406
 407         /* long wait for reset */
 408         wait_ms(1500);
 409         USB_STOR_PRINTF("CB_reset result %d: status %X clearing endpoint halt\n",result,us->pusb_dev->status);
 410         usb_clear_halt(us->pusb_dev, usb_rcvbulkpipe(us->pusb_dev, us->ep_in));
 411         usb_clear_halt(us->pusb_dev, usb_rcvbulkpipe(us->pusb_dev, us->ep_out));
 412
 413         USB_STOR_PRINTF("CB_reset done\n");
 414         return 0;
 415 }
 416
 417 /*
 418  * Set up the command for a BBB device. Note that the actual SCSI
 419  * command is copied into cbw.CBWCDB.
 420  */
 421 int usb_stor_BBB_comdat(ccb *srb, struct us_data *us)
 422 {
 423         int result;
 424         int actlen;
 425         int dir_in;
 426         unsigned int pipe;
 427         umass_bbb_cbw_t cbw;
 428
 429         dir_in = US_DIRECTION(srb->cmd[0]);
 430
 431 #ifdef BBB_COMDAT_TRACE
 432         printf("dir %d lun %d cmdlen %d cmd %p datalen %d pdata %p\n", dir_in, srb->lun, srb->cmdlen, srb->cmd, srb->datalen, srb->pdata);
 433         if (srb->cmdlen) {
 434                 for(result = 0;result < srb->cmdlen;result++)
 435                         printf("cmd[%d] %#x ", result, srb->cmd[result]);
 436                 printf("\n");
 437         }
 438 #endif
 439         /* sanity checks */
 440         if (!(srb->cmdlen <= CBWCDBLENGTH)) {
 441                 USB_STOR_PRINTF("usb_stor_BBB_comdat:cmdlen too large\n");
 442                 return -1;
 443         }
 444
 445         /* always OUT to the ep */
 446         pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out);
 447
 448         cbw.dCBWSignature = swap_32(CBWSIGNATURE);
 449         cbw.dCBWTag = swap_32(CBWTag++);
 450         cbw.dCBWDataTransferLength = swap_32(srb->datalen);
 451         cbw.bCBWFlags = (dir_in? CBWFLAGS_IN : CBWFLAGS_OUT);
 452         cbw.bCBWLUN = srb->lun;
 453         cbw.bCDBLength = srb->cmdlen;
 454         /* copy the command data into the CBW command data buffer */
 455         /* DST SRC LEN!!! */
 456         memcpy(cbw.CBWCDB, srb->cmd, srb->cmdlen);
 457         result = usb_bulk_msg(us->pusb_dev, pipe, &cbw, UMASS_BBB_CBW_SIZE, &actlen, USB_CNTL_TIMEOUT*5);
 458         if (result < 0)
 459                 USB_STOR_PRINTF("usb_stor_BBB_comdat:usb_bulk_msg error\n");
 460         return result;
 461 }
 462
 463 /* FIXME: we also need a CBI_command which sets up the completion
 464  * interrupt, and waits for it
 465  */
 466 int usb_stor_CB_comdat(ccb *srb, struct us_data *us)
 467 {
 468         int result;
 469         int dir_in,retry;
 470         unsigned int pipe;
 471         unsigned long status;
 472
 473         retry=5;
 474                 dir_in=US_DIRECTION(srb->cmd[0]);
 475
 476                 if(dir_in)
 477                         pipe=usb_rcvbulkpipe(us->pusb_dev, us->ep_in);
 478                 else
 479                         pipe=usb_sndbulkpipe(us->pusb_dev, us->ep_out);
 480         while(retry--) {
 481                 USB_STOR_PRINTF("CBI gets a command: Try %d\n",5-retry);
 482 #ifdef USB_STOR_DEBUG
 483                 usb_show_srb(srb);
 484 #endif
 485                 /* let's send the command via the control pipe */
 486                 result = usb_control_msg(us->pusb_dev, usb_sndctrlpipe(us->pusb_dev,0),
 487                                          US_CBI_ADSC, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
 488                                          0, us->ifnum,
 489                                          srb->cmd, srb->cmdlen, USB_CNTL_TIMEOUT*5);
 490                 USB_STOR_PRINTF("CB_transport: control msg returned %d, status %X\n",result,us->pusb_dev->status);
 491                 /* check the return code for the command */
 492                 if (result < 0) {
 493                         if(us->pusb_dev->status & USB_ST_STALLED) {
 494                                 status=us->pusb_dev->status;
 495                                 USB_STOR_PRINTF(" stall during command found, clear pipe\n");
 496                                 usb_clear_halt(us->pusb_dev,  usb_sndctrlpipe(us->pusb_dev,0));
 497                                 us->pusb_dev->status=status;
 498                         }
 499                         USB_STOR_PRINTF(" error during command %02X Stat = %X\n",srb->cmd[0],us->pusb_dev->status);
 500                         return result;
 501                 }
 502                 /* transfer the data payload for this command, if one exists*/
 503
 504                 USB_STOR_PRINTF("CB_transport: control msg returned %d, direction is %s to go 0x%lx\n",result,dir_in ? "IN" : "OUT",srb->datalen);
 505                 if (srb->datalen) {
 506                         result = us_one_transfer(us, pipe, srb->pdata,srb->datalen);
 507                         USB_STOR_PRINTF("CBI attempted to transfer data, result is %d status %lX, len %d\n", result,us->pusb_dev->status,us->pusb_dev->act_len);
 508                         if(!(us->pusb_dev->status & USB_ST_NAK_REC))
 509                                 break;
 510                 } /* if (srb->datalen) */
 511                 else
 512                         break;
 513         }
 514         /* return result */
 515
 516         return result;
 517 }
 518
 519
 520 int usb_stor_CBI_get_status(ccb *srb, struct us_data *us)
 521 {
 522         int timeout;
 523
 524         us->ip_wanted=1;
 525         submit_int_msg(us->pusb_dev,us->irqpipe,
 526                         (void *)&us->ip_data,us->irqmaxp ,us->irqinterval);
 527   timeout=1000;
 528   while(timeout--) {
 529         if((volatile int *)us->ip_wanted==0)
 530                         break;
 531                 wait_ms(10);
 532         }
 533         if (us->ip_wanted) {
 534                 printf("       Did not get interrupt on CBI\n");
 535                 us->ip_wanted = 0;
 536                 return USB_STOR_TRANSPORT_ERROR;
 537         }
 538         USB_STOR_PRINTF("Got interrupt data 0x%x, transfered %d status 0x%lX\n", us->ip_data,us->pusb_dev->irq_act_len,us->pusb_dev->irq_status);
 539         /* UFI gives us ASC and ASCQ, like a request sense */
 540         if (us->subclass == US_SC_UFI) {
 541                 if (srb->cmd[0] == SCSI_REQ_SENSE ||
 542                     srb->cmd[0] == SCSI_INQUIRY)
 543                         return USB_STOR_TRANSPORT_GOOD; /* Good */
 544                 else
 545                         if (us->ip_data)
 546                                 return USB_STOR_TRANSPORT_FAILED;
 547                         else
 548                                 return USB_STOR_TRANSPORT_GOOD;
 549         }
 550         /* otherwise, we interpret the data normally */
 551         switch (us->ip_data) {
 552                 case 0x0001:
 553                         return USB_STOR_TRANSPORT_GOOD;
 554                 case 0x0002:
 555                         return USB_STOR_TRANSPORT_FAILED;
 556                 default:
 557                         return USB_STOR_TRANSPORT_ERROR;
 558         } /* switch */
 559         return USB_STOR_TRANSPORT_ERROR;
 560 }
 561
 562 #define USB_TRANSPORT_UNKNOWN_RETRY 5
 563 #define USB_TRANSPORT_NOT_READY_RETRY 10
 564
 565 /* clear a stall on an endpoint - special for BBB devices */
 566 int usb_stor_BBB_clear_endpt_stall(struct us_data *us, __u8 endpt)
 567 {
 568         int result;
 569
 570         /* ENDPOINT_HALT = 0, so set value to 0 */
 571         result = usb_control_msg(us->pusb_dev, usb_sndctrlpipe(us->pusb_dev,0),
 572                                 USB_REQ_CLEAR_FEATURE, USB_RECIP_ENDPOINT,
 573                                 0, endpt, 0, 0, USB_CNTL_TIMEOUT*5);
 574         return result;
 575 }
 576
 577 int usb_stor_BBB_transport(ccb *srb, struct us_data *us)
 578 {
 579         int result, retry;
 580         int dir_in;
 581         int actlen, data_actlen;
 582         unsigned int pipe, pipein, pipeout;
 583         umass_bbb_csw_t csw;
 584 #ifdef BBB_XPORT_TRACE
 585         unsigned char *ptr;
 586         int index;
 587 #endif
 588
 589         dir_in = US_DIRECTION(srb->cmd[0]);
 590
 591         /* COMMAND phase */
 592         USB_STOR_PRINTF("COMMAND phase\n");
 593         result = usb_stor_BBB_comdat(srb, us);
 594         if (result < 0) {
 595                 USB_STOR_PRINTF("failed to send CBW status %ld\n",
 596                         us->pusb_dev->status);
 597                 usb_stor_BBB_reset(us);
 598                 return USB_STOR_TRANSPORT_FAILED;
 599         }
 600         wait_ms(5);
 601         pipein = usb_rcvbulkpipe(us->pusb_dev, us->ep_in);
 602         pipeout = usb_sndbulkpipe(us->pusb_dev, us->ep_out);
 603         /* DATA phase + error handling */
 604         USB_STOR_PRINTF("DATA phase\n");
 605         data_actlen = 0;
 606         /* no data, go immediately to the STATUS phase */
 607         if (srb->datalen == 0)
 608                 goto st;
 609         if (dir_in)
 610                 pipe = pipein;
 611         else
 612                 pipe = pipeout;
 613         result = usb_bulk_msg(us->pusb_dev, pipe, srb->pdata, srb->datalen, &data_actlen, USB_CNTL_TIMEOUT*5);
 614         /* special handling of STALL in DATA phase */
 615         if((result < 0) && (us->pusb_dev->status & USB_ST_STALLED)) {
 616                 printf("DATA:stall\n");
 617                 /* clear the STALL on the endpoint */
 618                 result = usb_stor_BBB_clear_endpt_stall(us, dir_in? us->ep_in : us->ep_out);
 619                 if (result >= 0)
 620                         /* continue on to STATUS phase */
 621                         goto st;
 622         }
 623         if (result < 0) {
 624                 USB_STOR_PRINTF("usb_bulk_msg error status %ld\n",
 625                         us->pusb_dev->status);
 626                 usb_stor_BBB_reset(us);
 627                 return USB_STOR_TRANSPORT_FAILED;
 628         }
 629 #ifdef BBB_XPORT_TRACE
 630         for (index = 0; index < data_actlen; index++)
 631                 printf("pdata[%d] %#x ", index, srb->pdata[index]);
 632         printf("\n");
 633 #endif
 634         /* STATUS phase + error handling */
 635    st:
 636         retry = 0;
 637    again:
 638         USB_STOR_PRINTF("STATUS phase\n");
 639         result = usb_bulk_msg(us->pusb_dev, pipein, &csw, UMASS_BBB_CSW_SIZE, &actlen, USB_CNTL_TIMEOUT*5);
 640         /* special handling of STALL in STATUS phase */
 641         if((result < 0) && (retry < 1) && (us->pusb_dev->status & USB_ST_STALLED)) {
 642                 USB_STOR_PRINTF("STATUS:stall\n");
 643                 /* clear the STALL on the endpoint */
 644                 result = usb_stor_BBB_clear_endpt_stall(us, us->ep_in);
 645                 if (result >= 0 && (retry++ < 1))
 646                         /* do a retry */
 647                         goto again;
 648         }
 649         if (result < 0) {
 650                 USB_STOR_PRINTF("usb_bulk_msg error status %ld\n",
 651                         us->pusb_dev->status);
 652                 usb_stor_BBB_reset(us);
 653                 return USB_STOR_TRANSPORT_FAILED;
 654         }
 655 #ifdef BBB_XPORT_TRACE
 656         ptr = (unsigned char *)&csw;
 657         for (index = 0; index < UMASS_BBB_CSW_SIZE; index++)
 658                 printf("ptr[%d] %#x ", index, ptr[index]);
 659         printf("\n");
 660 #endif
 661         /* misuse pipe to get the residue */
 662         pipe = swap_32(csw.dCSWDataResidue);
 663         if (pipe == 0 && srb->datalen != 0 && srb->datalen - data_actlen != 0)
 664                 pipe = srb->datalen - data_actlen;
 665         if (CSWSIGNATURE != swap_32(csw.dCSWSignature)) {
 666                 USB_STOR_PRINTF("!CSWSIGNATURE\n");
 667                 usb_stor_BBB_reset(us);
 668                 return USB_STOR_TRANSPORT_FAILED;
 669         } else if ((CBWTag - 1) != swap_32(csw.dCSWTag)) {
 670                 USB_STOR_PRINTF("!Tag\n");
 671                 usb_stor_BBB_reset(us);
 672                 return USB_STOR_TRANSPORT_FAILED;
 673         } else if (csw.bCSWStatus > CSWSTATUS_PHASE) {
 674                 USB_STOR_PRINTF(">PHASE\n");
 675                 usb_stor_BBB_reset(us);
 676                 return USB_STOR_TRANSPORT_FAILED;
 677         } else if (csw.bCSWStatus == CSWSTATUS_PHASE) {
 678                 USB_STOR_PRINTF("=PHASE\n");
 679                 usb_stor_BBB_reset(us);
 680                 return USB_STOR_TRANSPORT_FAILED;
 681         } else if (data_actlen > srb->datalen) {
 682                 USB_STOR_PRINTF("transferred %dB instead of %dB\n",
 683                         data_actlen, srb->datalen);
 684                 return USB_STOR_TRANSPORT_FAILED;
 685         } else if (csw.bCSWStatus == CSWSTATUS_FAILED) {
 686                 USB_STOR_PRINTF("FAILED\n");
 687                 return USB_STOR_TRANSPORT_FAILED;
 688         }
 689
 690         return result;
 691 }
 692
 693 int usb_stor_CB_transport(ccb *srb, struct us_data *us)
 694 {
 695         int result,status;
 696         ccb *psrb;
 697         ccb reqsrb;
 698         int retry,notready;
 699
 700         psrb=&reqsrb;
 701         status=USB_STOR_TRANSPORT_GOOD;
 702         retry=0;
 703         notready=0;
 704         /* issue the command */
 705 do_retry:
 706         result=usb_stor_CB_comdat(srb,us);
 707         USB_STOR_PRINTF("command / Data returned %d, status %X\n",result,us->pusb_dev->status);
 708         /* if this is an CBI Protocol, get IRQ */
 709         if(us->protocol==US_PR_CBI) {
 710                 status=usb_stor_CBI_get_status(srb,us);
 711                 /* if the status is error, report it */
 712                 if(status==USB_STOR_TRANSPORT_ERROR) {
 713                         USB_STOR_PRINTF(" USB CBI Command Error\n");
 714                         return status;
 715                 }
 716                 srb->sense_buf[12]=(unsigned char)(us->ip_data>>8);
 717                 srb->sense_buf[13]=(unsigned char)(us->ip_data&0xff);
 718                 if(!us->ip_data) {
 719                 /* if the status is good, report it */
 720                         if(status==USB_STOR_TRANSPORT_GOOD) {
 721                                 USB_STOR_PRINTF(" USB CBI Command Good\n");
 722                                 return status;
 723                         }
 724                 }
 725         }
 726         /* do we have to issue an auto request? */
 727         /* HERE we have to check the result */
 728         if((result<0) && !(us->pusb_dev->status & USB_ST_STALLED)) {
 729                 USB_STOR_PRINTF("ERROR %X\n",us->pusb_dev->status);
 730                 us->transport_reset(us);
 731                 return USB_STOR_TRANSPORT_ERROR;
 732         }
 733         if((us->protocol==US_PR_CBI) &&
 734                         ((srb->cmd[0]==SCSI_REQ_SENSE) ||
 735                         (srb->cmd[0]==SCSI_INQUIRY))) { /* do not issue an autorequest after request sense */
 736                 USB_STOR_PRINTF("No auto request and good\n");
 737                 return USB_STOR_TRANSPORT_GOOD;
 738         }
 739         /* issue an request_sense */
 740         memset(&psrb->cmd[0],0,12);
 741         psrb->cmd[0]=SCSI_REQ_SENSE;
 742         psrb->cmd[1]=srb->lun<<5;
 743         psrb->cmd[4]=18;
 744         psrb->datalen=18;
 745         psrb->pdata=&srb->sense_buf[0];
 746         psrb->cmdlen=12;
 747         /* issue the command */
 748         result=usb_stor_CB_comdat(psrb,us);
 749         USB_STOR_PRINTF("auto request returned %d\n",result);
 750         /* if this is an CBI Protocol, get IRQ */
 751         if(us->protocol==US_PR_CBI) {
 752                 status=usb_stor_CBI_get_status(psrb,us);
 753         }
 754         if((result<0)&&!(us->pusb_dev->status & USB_ST_STALLED)) {
 755                 USB_STOR_PRINTF(" AUTO REQUEST ERROR %d\n",us->pusb_dev->status);
 756                 return USB_STOR_TRANSPORT_ERROR;
 757         }
 758         USB_STOR_PRINTF("autorequest returned 0x%02X 0x%02X 0x%02X 0x%02X\n",srb->sense_buf[0],srb->sense_buf[2],srb->sense_buf[12],srb->sense_buf[13]);
 759         /* Check the auto request result */
 760         if((srb->sense_buf[2]==0) &&
 761                  (srb->sense_buf[12]==0) &&
 762                  (srb->sense_buf[13]==0)) /* ok, no sense */
 763                 return USB_STOR_TRANSPORT_GOOD;
 764         /* Check the auto request result */
 765         switch(srb->sense_buf[2]) {
 766         case 0x01: /* Recovered Error */
 767                 return USB_STOR_TRANSPORT_GOOD;
 768                 break;
 769         case 0x02: /* Not Ready */
 770                 if(notready++ > USB_TRANSPORT_NOT_READY_RETRY) {
 771                         printf("cmd 0x%02X returned 0x%02X 0x%02X 0x%02X 0x%02X (NOT READY)\n",
 772                                 srb->cmd[0],srb->sense_buf[0],srb->sense_buf[2],srb->sense_buf[12],srb->sense_buf[13]);
 773                         return USB_STOR_TRANSPORT_FAILED;
 774                 } else {
 775                         wait_ms(100);
 776                         goto do_retry;
 777                 }
 778                 break;
 779         default:
 780                 if(retry++ > USB_TRANSPORT_UNKNOWN_RETRY) {
 781                         printf("cmd 0x%02X returned 0x%02X 0x%02X 0x%02X 0x%02X\n",
 782                                 srb->cmd[0],srb->sense_buf[0],srb->sense_buf[2],srb->sense_buf[12],srb->sense_buf[13]);
 783                         return USB_STOR_TRANSPORT_FAILED;
 784                 } else {
 785                         goto do_retry;
 786                 }
 787                 break;
 788         }
 789         return USB_STOR_TRANSPORT_FAILED;
 790 }
 791
 792
 793 static int usb_inquiry(ccb *srb,struct us_data *ss)
 794 {
 795         int retry,i;
 796         retry=3;
 797         do {
 798                 memset(&srb->cmd[0],0,12);
 799                 srb->cmd[0]=SCSI_INQUIRY;
 800                 srb->cmd[1]=srb->lun<<5;
 801                 srb->cmd[4]=36;
 802                 srb->datalen=36;
 803                 srb->cmdlen=12;
 804                 i=ss->transport(srb,ss);
 805                 USB_STOR_PRINTF("inquiry returns %d\n",i);
 806                 if(i==0)
 807                         break;
 808         } while(retry--);
 809
 810         if(!retry) {
 811                 printf("error in inquiry\n");
 812                 return -1;
 813         }
 814         return 0;
 815 }
 816
 817 static int usb_request_sense(ccb *srb,struct us_data *ss)
 818 {
 819         char *ptr;
 820         return 0;
 821         ptr=srb->pdata;
 822         memset(&srb->cmd[0],0,12);
 823         srb->cmd[0]=SCSI_REQ_SENSE;
 824         srb->cmd[1]=srb->lun<<5;
 825         srb->cmd[4]=18;
 826         srb->datalen=18;
 827         srb->pdata=&srb->sense_buf[0];
 828         srb->cmdlen=12;
 829         ss->transport(srb,ss);
 830         USB_STOR_PRINTF("Request Sense returned %02X %02X %02X\n",srb->sense_buf[2],srb->sense_buf[12],srb->sense_buf[13]);
 831         srb->pdata=ptr;
 832         return 0;
 833 }
 834
 835 static int usb_test_unit_ready(ccb *srb,struct us_data *ss)
 836 {
 837         int retries=10;
 838
 839         do {
 840                 memset(&srb->cmd[0],0,12);
 841                 srb->cmd[0]=SCSI_TST_U_RDY;
 842                 srb->cmd[1]=srb->lun<<5;
 843                 srb->datalen=0;
 844                 srb->cmdlen=12;
 845                 if(ss->transport(srb,ss)==USB_STOR_TRANSPORT_GOOD) {
 846                         return 0;
 847                 }
 848         } while(retries--);
 849
 850         return -1;
 851 }
 852
 853 static int usb_read_capacity(ccb *srb,struct us_data *ss)
 854 {
 855         int retry;
 856         retry=2; /* retries */
 857         do {
 858                 memset(&srb->cmd[0],0,12);
 859                 srb->cmd[0]=SCSI_RD_CAPAC;
 860                 srb->cmd[1]=srb->lun<<5;
 861                 srb->datalen=8;
 862                 srb->cmdlen=12;
 863                 if(ss->transport(srb,ss)==USB_STOR_TRANSPORT_GOOD) {
 864                         return 0;
 865                 }
 866         } while(retry--);
 867
 868         return -1;
 869 }
 870
 871 static int usb_read_10(ccb *srb,struct us_data *ss, unsigned long start, unsigned short blocks)
 872 {
 873         memset(&srb->cmd[0],0,12);
 874         srb->cmd[0]=SCSI_READ10;
 875         srb->cmd[1]=srb->lun<<5;
 876         srb->cmd[2]=((unsigned char) (start>>24))&0xff;
 877         srb->cmd[3]=((unsigned char) (start>>16))&0xff;
 878         srb->cmd[4]=((unsigned char) (start>>8))&0xff;
 879         srb->cmd[5]=((unsigned char) (start))&0xff;
 880         srb->cmd[7]=((unsigned char) (blocks>>8))&0xff;
 881         srb->cmd[8]=(unsigned char) blocks & 0xff;
 882         srb->cmdlen=12;
 883         USB_STOR_PRINTF("read10: start %lx blocks %x\n",start,blocks);
 884         return ss->transport(srb,ss);
 885 }
 886
 887
 888 #define USB_MAX_READ_BLK 20
 889
 890 unsigned long usb_stor_read(int device, unsigned long blknr, unsigned long blkcnt, unsigned long *buffer)
 891 {
 892         unsigned long start,blks, buf_addr;
 893         unsigned short smallblks;
 894         struct usb_device *dev;
 895         int retry,i;
 896         ccb *srb=&usb_ccb;
 897         device&=0xff;
 898         /* Setup  device
 899          */
 900         USB_STOR_PRINTF("\nusb_read: dev %d \n",device);
 901         dev=NULL;
 902         for(i=0;i<USB_MAX_DEVICE;i++) {
 903                 dev=usb_get_dev_index(i);
 904                 if(dev==NULL) {
 905                         return 0;
 906                 }
 907                 if(dev->devnum==usb_dev_desc[device].target)
 908                         break;
 909         }
 910
 911         usb_disable_asynch(1); /* asynch transfer not allowed */
 912         srb->lun=usb_dev_desc[device].lun;
 913         buf_addr=(unsigned long)buffer;
 914         start=blknr;
 915         blks=blkcnt;
 916         if(usb_test_unit_ready(srb,(struct us_data *)dev->privptr)) {
 917                 printf("Device NOT ready\n   Request Sense returned %02X %02X %02X\n",
 918                         srb->sense_buf[2],srb->sense_buf[12],srb->sense_buf[13]);
 919                 return 0;
 920         }
 921         USB_STOR_PRINTF("\nusb_read: dev %d startblk %lx, blccnt %lx buffer %lx\n",device,start,blks, buf_addr);
 922         do {
 923                 retry=2;
 924                 srb->pdata=(unsigned char *)buf_addr;
 925                 if(blks>USB_MAX_READ_BLK) {
 926                         smallblks=USB_MAX_READ_BLK;
 927                 } else {
 928                         smallblks=(unsigned short) blks;
 929                 }
 930 retry_it:
 931                 if(smallblks==USB_MAX_READ_BLK)
 932                         usb_show_progress();
 933                 srb->datalen=usb_dev_desc[device].blksz * smallblks;
 934                 srb->pdata=(unsigned char *)buf_addr;
 935                 if(usb_read_10(srb,(struct us_data *)dev->privptr, start, smallblks)) {
 936                         USB_STOR_PRINTF("Read ERROR\n");
 937                         usb_request_sense(srb,(struct us_data *)dev->privptr);
 938                         if(retry--)
 939                                 goto retry_it;
 940                         blkcnt-=blks;
 941                         break;
 942                 }
 943                 start+=smallblks;
 944                 blks-=smallblks;
 945                 buf_addr+=srb->datalen;
 946         } while(blks!=0);
 947         USB_STOR_PRINTF("usb_read: end startblk %lx, blccnt %x buffer %lx\n",start,smallblks,buf_addr);
 948         usb_disable_asynch(0); /* asynch transfer allowed */
 949         if(blkcnt>=USB_MAX_READ_BLK)
 950                 printf("\n");
 951         return(blkcnt);
 952 }
 953
 954
 955 /* Probe to see if a new device is actually a Storage device */
 956 int usb_storage_probe(struct usb_device *dev, unsigned int ifnum,struct us_data *ss)
 957 {
 958         struct usb_interface_descriptor *iface;
 959         int i;
 960         unsigned int flags = 0;
 961
 962         int protocol = 0;
 963         int subclass = 0;
 964
 965
 966         memset(ss, 0, sizeof(struct us_data));
 967
 968         /* let's examine the device now */
 969         iface = &dev->config.if_desc[ifnum];
 970
 971 #if 0
 972         /* this is the place to patch some storage devices */
 973         USB_STOR_PRINTF("iVendor %X iProduct %X\n",dev->descriptor.idVendor,dev->descriptor.idProduct);
 974         if ((dev->descriptor.idVendor) == 0x066b && (dev->descriptor.idProduct) == 0x0103) {
 975                 USB_STOR_PRINTF("patched for E-USB\n");
 976                 protocol = US_PR_CB;
 977                 subclass = US_SC_UFI;       /* an assumption */
 978         }
 979 #endif
 980
 981         if (dev->descriptor.bDeviceClass != 0 ||
 982                         iface->bInterfaceClass != USB_CLASS_MASS_STORAGE ||
 983                         iface->bInterfaceSubClass < US_SC_MIN ||
 984                         iface->bInterfaceSubClass > US_SC_MAX) {
 985                 /* if it's not a mass storage, we go no further */
 986                 return 0;
 987         }
 988
 989         /* At this point, we know we've got a live one */
 990         USB_STOR_PRINTF("\n\nUSB Mass Storage device detected\n");
 991
 992         /* Initialize the us_data structure with some useful info */
 993         ss->flags = flags;
 994         ss->ifnum = ifnum;
 995         ss->pusb_dev = dev;
 996         ss->attention_done = 0;
 997
 998         /* If the device has subclass and protocol, then use that.  Otherwise,
 999          * take data from the specific interface.
1000          */
1001         if (subclass) {
1002                 ss->subclass = subclass;
1003                 ss->protocol = protocol;
1004         } else {
1005                 ss->subclass = iface->bInterfaceSubClass;
1006                 ss->protocol = iface->bInterfaceProtocol;
1007         }
1008
1009         /* set the handler pointers based on the protocol */
1010         USB_STOR_PRINTF("Transport: ");
1011         switch (ss->protocol) {
1012         case US_PR_CB:
1013                 USB_STOR_PRINTF("Control/Bulk\n");
1014                 ss->transport = usb_stor_CB_transport;
1015                 ss->transport_reset = usb_stor_CB_reset;
1016                 break;
1017
1018         case US_PR_CBI:
1019                 USB_STOR_PRINTF("Control/Bulk/Interrupt\n");
1020                 ss->transport = usb_stor_CB_transport;
1021                 ss->transport_reset = usb_stor_CB_reset;
1022                 break;
1023         case US_PR_BULK:
1024                 USB_STOR_PRINTF("Bulk/Bulk/Bulk\n");
1025                 ss->transport = usb_stor_BBB_transport;
1026                 ss->transport_reset = usb_stor_BBB_reset;
1027                 break;
1028         default:
1029                 printf("USB Starage Transport unknown / not yet implemented\n");
1030                 return 0;
1031                 break;
1032         }
1033
1034         /*
1035          * We are expecting a minimum of 2 endpoints - in and out (bulk).
1036          * An optional interrupt is OK (necessary for CBI protocol).
1037          * We will ignore any others.
1038          */
1039         for (i = 0; i < iface->bNumEndpoints; i++) {
1040                 /* is it an BULK endpoint? */
1041                 if ((iface->ep_desc[i].bmAttributes &  USB_ENDPOINT_XFERTYPE_MASK)
1042                     == USB_ENDPOINT_XFER_BULK) {
1043                         if (iface->ep_desc[i].bEndpointAddress & USB_DIR_IN)
1044                                 ss->ep_in = iface->ep_desc[i].bEndpointAddress &
1045                                         USB_ENDPOINT_NUMBER_MASK;
1046                         else
1047                                 ss->ep_out = iface->ep_desc[i].bEndpointAddress &
1048                                         USB_ENDPOINT_NUMBER_MASK;
1049                 }
1050
1051                 /* is it an interrupt endpoint? */
1052                 if ((iface->ep_desc[i].bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
1053                     == USB_ENDPOINT_XFER_INT) {
1054                         ss->ep_int = iface->ep_desc[i].bEndpointAddress &
1055                                 USB_ENDPOINT_NUMBER_MASK;
1056                         ss->irqinterval = iface->ep_desc[i].bInterval;
1057                 }
1058         }
1059         USB_STOR_PRINTF("Endpoints In %d Out %d Int %d\n",
1060                   ss->ep_in, ss->ep_out, ss->ep_int);
1061
1062         /* Do some basic sanity checks, and bail if we find a problem */
1063         if (usb_set_interface(dev, iface->bInterfaceNumber, 0) ||
1064             !ss->ep_in || !ss->ep_out ||
1065             (ss->protocol == US_PR_CBI && ss->ep_int == 0)) {
1066                 USB_STOR_PRINTF("Problems with device\n");
1067                 return 0;
1068         }
1069         /* set class specific stuff */
1070         /* We only handle certain protocols.  Currently, these are
1071          * the only ones.
1072          */
1073         if (ss->subclass != US_SC_UFI && ss->subclass != US_SC_SCSI) {
1074                 printf("Sorry, protocol %d not yet supported.\n",ss->subclass);
1075                 return 0;
1076         }
1077         if(ss->ep_int) { /* we had found an interrupt endpoint, prepare irq pipe */
1078                 /* set up the IRQ pipe and handler */
1079
1080                 ss->irqinterval = (ss->irqinterval > 0) ? ss->irqinterval : 255;
1081                 ss->irqpipe = usb_rcvintpipe(ss->pusb_dev, ss->ep_int);
1082                 ss->irqmaxp = usb_maxpacket(dev, ss->irqpipe);
1083                 dev->irq_handle=usb_stor_irq;
1084                 dev->privptr=(void *)ss;
1085         }
1086         return 1;
1087 }
1088
1089 int usb_stor_get_info(struct usb_device *dev,struct us_data *ss,block_dev_desc_t *dev_desc)
1090 {
1091         unsigned char perq,modi;
1092         unsigned long cap[2];
1093         unsigned long *capacity,*blksz;
1094         ccb *pccb=&usb_ccb;
1095
1096         ss->transport_reset(ss);
1097         pccb->pdata=usb_stor_buf;
1098
1099         dev_desc->target=dev->devnum;
1100         pccb->lun=dev_desc->lun;
1101         USB_STOR_PRINTF(" address %d\n",dev_desc->target);
1102
1103         if(usb_inquiry(pccb,ss))
1104                 return -1;
1105         perq=usb_stor_buf[0];
1106         modi=usb_stor_buf[1];
1107         if((perq & 0x1f)==0x1f) {
1108                 return 0; /* skip unknown devices */
1109         }
1110         if((modi&0x80)==0x80) {/* drive is removable */
1111                 dev_desc->removable=1;
1112         }
1113         memcpy(&dev_desc->vendor[0], &usb_stor_buf[8], 8);
1114         memcpy(&dev_desc->product[0], &usb_stor_buf[16], 16);
1115         memcpy(&dev_desc->revision[0], &usb_stor_buf[32], 4);
1116         dev_desc->vendor[8]=0;
1117         dev_desc->product[16]=0;
1118         dev_desc->revision[4]=0;
1119         USB_STOR_PRINTF("ISO Vers %X, Response Data %X\n",usb_stor_buf[2],usb_stor_buf[3]);
1120         if(usb_test_unit_ready(pccb,ss)) {
1121                 printf("Device NOT ready\n   Request Sense returned %02X %02X %02X\n",pccb->sense_buf[2],pccb->sense_buf[12],pccb->sense_buf[13]);
1122                 if(dev_desc->removable==1) {
1123                         dev_desc->type=perq;
1124                         return 1;
1125                 }
1126                 else
1127                         return 0;
1128         }
1129         pccb->pdata=(unsigned char *)&cap[0];
1130         memset(pccb->pdata,0,8);
1131         if(usb_read_capacity(pccb,ss)!=0) {
1132                 printf("READ_CAP ERROR\n");
1133                 cap[0]=2880;
1134                 cap[1]=0x200;
1135         }
1136         USB_STOR_PRINTF("Read Capacity returns: 0x%lx, 0x%lx\n",cap[0],cap[1]);
1137 #if 0
1138         if(cap[0]>(0x200000 * 10)) /* greater than 10 GByte */
1139                 cap[0]>>=16;
1140 #endif
1141 #ifdef LITTLEENDIAN
1142         cap[0] = ((unsigned long)(
1143                 (((unsigned long)(cap[0]) & (unsigned long)0x000000ffUL) << 24) |
1144                 (((unsigned long)(cap[0]) & (unsigned long)0x0000ff00UL) <<  8) |
1145                 (((unsigned long)(cap[0]) & (unsigned long)0x00ff0000UL) >>  8) |
1146                 (((unsigned long)(cap[0]) & (unsigned long)0xff000000UL) >> 24) ));
1147         cap[1] = ((unsigned long)(
1148                 (((unsigned long)(cap[1]) & (unsigned long)0x000000ffUL) << 24) |
1149                 (((unsigned long)(cap[1]) & (unsigned long)0x0000ff00UL) <<  8) |
1150                 (((unsigned long)(cap[1]) & (unsigned long)0x00ff0000UL) >>  8) |
1151                 (((unsigned long)(cap[1]) & (unsigned long)0xff000000UL) >> 24) ));
1152 #endif
1153         /* this assumes bigendian! */
1154         cap[0]+=1;
1155         capacity=&cap[0];
1156         blksz=&cap[1];
1157         USB_STOR_PRINTF("Capacity = 0x%lx, blocksz = 0x%lx\n",*capacity,*blksz);
1158         dev_desc->lba=*capacity;
1159         dev_desc->blksz=*blksz;
1160         dev_desc->type=perq;
1161         USB_STOR_PRINTF(" address %d\n",dev_desc->target);
1162         USB_STOR_PRINTF("partype: %d\n",dev_desc->part_type);
1163
1164         init_part(dev_desc);
1165
1166         USB_STOR_PRINTF("partype: %d\n",dev_desc->part_type);
1167         return 1;
1168 }
1169
1170 #endif /* CONFIG_USB_STORAGE */
1171 #endif /* CFG_CMD_USB */