1 /* 2 * Most of this source has been derived from the Linux USB 3 * project: 4 * (c) 1999-2002 Matthew Dharm (mdharm-usb@one-eyed-alien.net) 5 * (c) 2000 David L. Brown, Jr. (usb-storage@davidb.org) 6 * (c) 1999 Michael Gee (michael@linuxspecific.com) 7 * (c) 2000 Yggdrasil Computing, Inc. 8 * 9 * 10 * Adapted for U-Boot: 11 * (C) Copyright 2001 Denis Peter, MPL AG Switzerland 12 * Driver model conversion: 13 * (C) Copyright 2015 Google, Inc 14 * 15 * For BBB support (C) Copyright 2003 16 * Gary Jennejohn, DENX Software Engineering <garyj@denx.de> 17 * 18 * BBB support based on /sys/dev/usb/umass.c from 19 * FreeBSD. 20 * 21 * SPDX-License-Identifier: GPL-2.0+ 22 */ 23 24 /* Note: 25 * Currently only the CBI transport protocoll has been implemented, and it 26 * is only tested with a TEAC USB Floppy. Other Massstorages with CBI or CB 27 * transport protocoll may work as well. 28 */ 29 /* 30 * New Note: 31 * Support for USB Mass Storage Devices (BBB) has been added. It has 32 * only been tested with USB memory sticks. 33 */ 34 35 36 #include <common.h> 37 #include <command.h> 38 #include <dm.h> 39 #include <errno.h> 40 #include <inttypes.h> 41 #include <mapmem.h> 42 #include <memalign.h> 43 #include <asm/byteorder.h> 44 #include <asm/processor.h> 45 #include <dm/device-internal.h> 46 #include <dm/lists.h> 47 48 #include <part.h> 49 #include <usb.h> 50 51 #undef BBB_COMDAT_TRACE 52 #undef BBB_XPORT_TRACE 53 54 #include <scsi.h> 55 /* direction table -- this indicates the direction of the data 56 * transfer for each command code -- a 1 indicates input 57 */ 58 static const unsigned char us_direction[256/8] = { 59 0x28, 0x81, 0x14, 0x14, 0x20, 0x01, 0x90, 0x77, 60 0x0C, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 61 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 62 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 63 }; 64 #define US_DIRECTION(x) ((us_direction[x>>3] >> (x & 7)) & 1) 65 66 static struct scsi_cmd usb_ccb __aligned(ARCH_DMA_MINALIGN); 67 static __u32 CBWTag; 68 69 static int usb_max_devs; /* number of highest available usb device */ 70 71 #ifndef CONFIG_BLK 72 static struct blk_desc usb_dev_desc[USB_MAX_STOR_DEV]; 73 #endif 74 75 struct us_data; 76 typedef int (*trans_cmnd)(struct scsi_cmd *cb, struct us_data *data); 77 typedef int (*trans_reset)(struct us_data *data); 78 79 struct us_data { 80 struct usb_device *pusb_dev; /* this usb_device */ 81 82 unsigned int flags; /* from filter initially */ 83 # define USB_READY (1 << 0) 84 unsigned char ifnum; /* interface number */ 85 unsigned char ep_in; /* in endpoint */ 86 unsigned char ep_out; /* out ....... */ 87 unsigned char ep_int; /* interrupt . */ 88 unsigned char subclass; /* as in overview */ 89 unsigned char protocol; /* .............. */ 90 unsigned char attention_done; /* force attn on first cmd */ 91 unsigned short ip_data; /* interrupt data */ 92 int action; /* what to do */ 93 int ip_wanted; /* needed */ 94 int *irq_handle; /* for USB int requests */ 95 unsigned int irqpipe; /* pipe for release_irq */ 96 unsigned char irqmaxp; /* max packed for irq Pipe */ 97 unsigned char irqinterval; /* Intervall for IRQ Pipe */ 98 struct scsi_cmd *srb; /* current srb */ 99 trans_reset transport_reset; /* reset routine */ 100 trans_cmnd transport; /* transport routine */ 101 unsigned short max_xfer_blk; /* maximum transfer blocks */ 102 }; 103 104 #ifndef CONFIG_BLK 105 static struct us_data usb_stor[USB_MAX_STOR_DEV]; 106 #endif 107 108 #define USB_STOR_TRANSPORT_GOOD 0 109 #define USB_STOR_TRANSPORT_FAILED -1 110 #define USB_STOR_TRANSPORT_ERROR -2 111 112 int usb_stor_get_info(struct usb_device *dev, struct us_data *us, 113 struct blk_desc *dev_desc); 114 int usb_storage_probe(struct usb_device *dev, unsigned int ifnum, 115 struct us_data *ss); 116 #ifdef CONFIG_BLK 117 static unsigned long usb_stor_read(struct udevice *dev, lbaint_t blknr, 118 lbaint_t blkcnt, void *buffer); 119 static unsigned long usb_stor_write(struct udevice *dev, lbaint_t blknr, 120 lbaint_t blkcnt, const void *buffer); 121 #else 122 static unsigned long usb_stor_read(struct blk_desc *block_dev, lbaint_t blknr, 123 lbaint_t blkcnt, void *buffer); 124 static unsigned long usb_stor_write(struct blk_desc *block_dev, lbaint_t blknr, 125 lbaint_t blkcnt, const void *buffer); 126 #endif 127 void uhci_show_temp_int_td(void); 128 129 static void usb_show_progress(void) 130 { 131 debug("."); 132 } 133 134 /******************************************************************************* 135 * show info on storage devices; 'usb start/init' must be invoked earlier 136 * as we only retrieve structures populated during devices initialization 137 */ 138 int usb_stor_info(void) 139 { 140 int count = 0; 141 #ifdef CONFIG_BLK 142 struct udevice *dev; 143 144 for (blk_first_device(IF_TYPE_USB, &dev); 145 dev; 146 blk_next_device(&dev)) { 147 struct blk_desc *desc = dev_get_uclass_platdata(dev); 148 149 printf(" Device %d: ", desc->devnum); 150 dev_print(desc); 151 count++; 152 } 153 #else 154 int i; 155 156 if (usb_max_devs > 0) { 157 for (i = 0; i < usb_max_devs; i++) { 158 printf(" Device %d: ", i); 159 dev_print(&usb_dev_desc[i]); 160 } 161 return 0; 162 } 163 #endif 164 if (!count) { 165 printf("No storage devices, perhaps not 'usb start'ed..?\n"); 166 return 1; 167 } 168 169 return 0; 170 } 171 172 static unsigned int usb_get_max_lun(struct us_data *us) 173 { 174 int len; 175 ALLOC_CACHE_ALIGN_BUFFER(unsigned char, result, 1); 176 len = usb_control_msg(us->pusb_dev, 177 usb_rcvctrlpipe(us->pusb_dev, 0), 178 US_BBB_GET_MAX_LUN, 179 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN, 180 0, us->ifnum, 181 result, sizeof(char), 182 USB_CNTL_TIMEOUT * 5); 183 debug("Get Max LUN -> len = %i, result = %i\n", len, (int) *result); 184 return (len > 0) ? *result : 0; 185 } 186 187 static int usb_stor_probe_device(struct usb_device *udev) 188 { 189 int lun, max_lun; 190 191 #ifdef CONFIG_BLK 192 struct us_data *data; 193 int ret; 194 #else 195 int start; 196 197 if (udev == NULL) 198 return -ENOENT; /* no more devices available */ 199 #endif 200 201 debug("\n\nProbing for storage\n"); 202 #ifdef CONFIG_BLK 203 /* 204 * We store the us_data in the mass storage device's platdata. It 205 * is shared by all LUNs (block devices) attached to this mass storage 206 * device. 207 */ 208 data = dev_get_platdata(udev->dev); 209 if (!usb_storage_probe(udev, 0, data)) 210 return 0; 211 max_lun = usb_get_max_lun(data); 212 for (lun = 0; lun <= max_lun; lun++) { 213 struct blk_desc *blkdev; 214 struct udevice *dev; 215 char str[10]; 216 217 snprintf(str, sizeof(str), "lun%d", lun); 218 ret = blk_create_devicef(udev->dev, "usb_storage_blk", str, 219 IF_TYPE_USB, usb_max_devs, 512, 0, 220 &dev); 221 if (ret) { 222 debug("Cannot bind driver\n"); 223 return ret; 224 } 225 226 blkdev = dev_get_uclass_platdata(dev); 227 blkdev->target = 0xff; 228 blkdev->lun = lun; 229 230 ret = usb_stor_get_info(udev, data, blkdev); 231 if (ret == 1) 232 ret = blk_prepare_device(dev); 233 if (!ret) { 234 usb_max_devs++; 235 debug("%s: Found device %p\n", __func__, udev); 236 } else { 237 debug("usb_stor_get_info: Invalid device\n"); 238 ret = device_unbind(dev); 239 if (ret) 240 return ret; 241 } 242 } 243 #else 244 /* We don't have space to even probe if we hit the maximum */ 245 if (usb_max_devs == USB_MAX_STOR_DEV) { 246 printf("max USB Storage Device reached: %d stopping\n", 247 usb_max_devs); 248 return -ENOSPC; 249 } 250 251 if (!usb_storage_probe(udev, 0, &usb_stor[usb_max_devs])) 252 return 0; 253 254 /* 255 * OK, it's a storage device. Iterate over its LUNs and populate 256 * usb_dev_desc' 257 */ 258 start = usb_max_devs; 259 260 max_lun = usb_get_max_lun(&usb_stor[usb_max_devs]); 261 for (lun = 0; lun <= max_lun && usb_max_devs < USB_MAX_STOR_DEV; 262 lun++) { 263 struct blk_desc *blkdev; 264 265 blkdev = &usb_dev_desc[usb_max_devs]; 266 memset(blkdev, '\0', sizeof(struct blk_desc)); 267 blkdev->if_type = IF_TYPE_USB; 268 blkdev->devnum = usb_max_devs; 269 blkdev->part_type = PART_TYPE_UNKNOWN; 270 blkdev->target = 0xff; 271 blkdev->type = DEV_TYPE_UNKNOWN; 272 blkdev->block_read = usb_stor_read; 273 blkdev->block_write = usb_stor_write; 274 blkdev->lun = lun; 275 blkdev->priv = udev; 276 277 if (usb_stor_get_info(udev, &usb_stor[start], 278 &usb_dev_desc[usb_max_devs]) == 1) { 279 debug("partype: %d\n", blkdev->part_type); 280 part_init(blkdev); 281 debug("partype: %d\n", blkdev->part_type); 282 usb_max_devs++; 283 debug("%s: Found device %p\n", __func__, udev); 284 } 285 } 286 #endif 287 288 return 0; 289 } 290 291 void usb_stor_reset(void) 292 { 293 usb_max_devs = 0; 294 } 295 296 /******************************************************************************* 297 * scan the usb and reports device info 298 * to the user if mode = 1 299 * returns current device or -1 if no 300 */ 301 int usb_stor_scan(int mode) 302 { 303 if (mode == 1) 304 printf(" scanning usb for storage devices... "); 305 306 #ifndef CONFIG_DM_USB 307 unsigned char i; 308 309 usb_disable_asynch(1); /* asynch transfer not allowed */ 310 311 usb_stor_reset(); 312 for (i = 0; i < USB_MAX_DEVICE; i++) { 313 struct usb_device *dev; 314 315 dev = usb_get_dev_index(i); /* get device */ 316 debug("i=%d\n", i); 317 if (usb_stor_probe_device(dev)) 318 break; 319 } /* for */ 320 321 usb_disable_asynch(0); /* asynch transfer allowed */ 322 #endif 323 printf("%d Storage Device(s) found\n", usb_max_devs); 324 if (usb_max_devs > 0) 325 return 0; 326 return -1; 327 } 328 329 static int usb_stor_irq(struct usb_device *dev) 330 { 331 struct us_data *us; 332 us = (struct us_data *)dev->privptr; 333 334 if (us->ip_wanted) 335 us->ip_wanted = 0; 336 return 0; 337 } 338 339 340 #ifdef DEBUG 341 342 static void usb_show_srb(struct scsi_cmd *pccb) 343 { 344 int i; 345 printf("SRB: len %d datalen 0x%lX\n ", pccb->cmdlen, pccb->datalen); 346 for (i = 0; i < 12; i++) 347 printf("%02X ", pccb->cmd[i]); 348 printf("\n"); 349 } 350 351 static void display_int_status(unsigned long tmp) 352 { 353 printf("Status: %s %s %s %s %s %s %s\n", 354 (tmp & USB_ST_ACTIVE) ? "Active" : "", 355 (tmp & USB_ST_STALLED) ? "Stalled" : "", 356 (tmp & USB_ST_BUF_ERR) ? "Buffer Error" : "", 357 (tmp & USB_ST_BABBLE_DET) ? "Babble Det" : "", 358 (tmp & USB_ST_NAK_REC) ? "NAKed" : "", 359 (tmp & USB_ST_CRC_ERR) ? "CRC Error" : "", 360 (tmp & USB_ST_BIT_ERR) ? "Bitstuff Error" : ""); 361 } 362 #endif 363 /*********************************************************************** 364 * Data transfer routines 365 ***********************************************************************/ 366 367 static int us_one_transfer(struct us_data *us, int pipe, char *buf, int length) 368 { 369 int max_size; 370 int this_xfer; 371 int result; 372 int partial; 373 int maxtry; 374 int stat; 375 376 /* determine the maximum packet size for these transfers */ 377 max_size = usb_maxpacket(us->pusb_dev, pipe) * 16; 378 379 /* while we have data left to transfer */ 380 while (length) { 381 382 /* calculate how long this will be -- maximum or a remainder */ 383 this_xfer = length > max_size ? max_size : length; 384 length -= this_xfer; 385 386 /* setup the retry counter */ 387 maxtry = 10; 388 389 /* set up the transfer loop */ 390 do { 391 /* transfer the data */ 392 debug("Bulk xfer 0x%lx(%d) try #%d\n", 393 (ulong)map_to_sysmem(buf), this_xfer, 394 11 - maxtry); 395 result = usb_bulk_msg(us->pusb_dev, pipe, buf, 396 this_xfer, &partial, 397 USB_CNTL_TIMEOUT * 5); 398 debug("bulk_msg returned %d xferred %d/%d\n", 399 result, partial, this_xfer); 400 if (us->pusb_dev->status != 0) { 401 /* if we stall, we need to clear it before 402 * we go on 403 */ 404 #ifdef DEBUG 405 display_int_status(us->pusb_dev->status); 406 #endif 407 if (us->pusb_dev->status & USB_ST_STALLED) { 408 debug("stalled ->clearing endpoint" \ 409 "halt for pipe 0x%x\n", pipe); 410 stat = us->pusb_dev->status; 411 usb_clear_halt(us->pusb_dev, pipe); 412 us->pusb_dev->status = stat; 413 if (this_xfer == partial) { 414 debug("bulk transferred" \ 415 "with error %lX," \ 416 " but data ok\n", 417 us->pusb_dev->status); 418 return 0; 419 } 420 else 421 return result; 422 } 423 if (us->pusb_dev->status & USB_ST_NAK_REC) { 424 debug("Device NAKed bulk_msg\n"); 425 return result; 426 } 427 debug("bulk transferred with error"); 428 if (this_xfer == partial) { 429 debug(" %ld, but data ok\n", 430 us->pusb_dev->status); 431 return 0; 432 } 433 /* if our try counter reaches 0, bail out */ 434 debug(" %ld, data %d\n", 435 us->pusb_dev->status, partial); 436 if (!maxtry--) 437 return result; 438 } 439 /* update to show what data was transferred */ 440 this_xfer -= partial; 441 buf += partial; 442 /* continue until this transfer is done */ 443 } while (this_xfer); 444 } 445 446 /* if we get here, we're done and successful */ 447 return 0; 448 } 449 450 static int usb_stor_BBB_reset(struct us_data *us) 451 { 452 int result; 453 unsigned int pipe; 454 455 /* 456 * Reset recovery (5.3.4 in Universal Serial Bus Mass Storage Class) 457 * 458 * For Reset Recovery the host shall issue in the following order: 459 * a) a Bulk-Only Mass Storage Reset 460 * b) a Clear Feature HALT to the Bulk-In endpoint 461 * c) a Clear Feature HALT to the Bulk-Out endpoint 462 * 463 * This is done in 3 steps. 464 * 465 * If the reset doesn't succeed, the device should be port reset. 466 * 467 * This comment stolen from FreeBSD's /sys/dev/usb/umass.c. 468 */ 469 debug("BBB_reset\n"); 470 result = usb_control_msg(us->pusb_dev, usb_sndctrlpipe(us->pusb_dev, 0), 471 US_BBB_RESET, 472 USB_TYPE_CLASS | USB_RECIP_INTERFACE, 473 0, us->ifnum, NULL, 0, USB_CNTL_TIMEOUT * 5); 474 475 if ((result < 0) && (us->pusb_dev->status & USB_ST_STALLED)) { 476 debug("RESET:stall\n"); 477 return -1; 478 } 479 480 /* long wait for reset */ 481 mdelay(150); 482 debug("BBB_reset result %d: status %lX reset\n", 483 result, us->pusb_dev->status); 484 pipe = usb_rcvbulkpipe(us->pusb_dev, us->ep_in); 485 result = usb_clear_halt(us->pusb_dev, pipe); 486 /* long wait for reset */ 487 mdelay(150); 488 debug("BBB_reset result %d: status %lX clearing IN endpoint\n", 489 result, us->pusb_dev->status); 490 /* long wait for reset */ 491 pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out); 492 result = usb_clear_halt(us->pusb_dev, pipe); 493 mdelay(150); 494 debug("BBB_reset result %d: status %lX clearing OUT endpoint\n", 495 result, us->pusb_dev->status); 496 debug("BBB_reset done\n"); 497 return 0; 498 } 499 500 /* FIXME: this reset function doesn't really reset the port, and it 501 * should. Actually it should probably do what it's doing here, and 502 * reset the port physically 503 */ 504 static int usb_stor_CB_reset(struct us_data *us) 505 { 506 unsigned char cmd[12]; 507 int result; 508 509 debug("CB_reset\n"); 510 memset(cmd, 0xff, sizeof(cmd)); 511 cmd[0] = SCSI_SEND_DIAG; 512 cmd[1] = 4; 513 result = usb_control_msg(us->pusb_dev, usb_sndctrlpipe(us->pusb_dev, 0), 514 US_CBI_ADSC, 515 USB_TYPE_CLASS | USB_RECIP_INTERFACE, 516 0, us->ifnum, cmd, sizeof(cmd), 517 USB_CNTL_TIMEOUT * 5); 518 519 /* long wait for reset */ 520 mdelay(1500); 521 debug("CB_reset result %d: status %lX clearing endpoint halt\n", 522 result, us->pusb_dev->status); 523 usb_clear_halt(us->pusb_dev, usb_rcvbulkpipe(us->pusb_dev, us->ep_in)); 524 usb_clear_halt(us->pusb_dev, usb_rcvbulkpipe(us->pusb_dev, us->ep_out)); 525 526 debug("CB_reset done\n"); 527 return 0; 528 } 529 530 /* 531 * Set up the command for a BBB device. Note that the actual SCSI 532 * command is copied into cbw.CBWCDB. 533 */ 534 static int usb_stor_BBB_comdat(struct scsi_cmd *srb, struct us_data *us) 535 { 536 int result; 537 int actlen; 538 int dir_in; 539 unsigned int pipe; 540 ALLOC_CACHE_ALIGN_BUFFER(struct umass_bbb_cbw, cbw, 1); 541 542 dir_in = US_DIRECTION(srb->cmd[0]); 543 544 #ifdef BBB_COMDAT_TRACE 545 printf("dir %d lun %d cmdlen %d cmd %p datalen %lu pdata %p\n", 546 dir_in, srb->lun, srb->cmdlen, srb->cmd, srb->datalen, 547 srb->pdata); 548 if (srb->cmdlen) { 549 for (result = 0; result < srb->cmdlen; result++) 550 printf("cmd[%d] %#x ", result, srb->cmd[result]); 551 printf("\n"); 552 } 553 #endif 554 /* sanity checks */ 555 if (!(srb->cmdlen <= CBWCDBLENGTH)) { 556 debug("usb_stor_BBB_comdat:cmdlen too large\n"); 557 return -1; 558 } 559 560 /* always OUT to the ep */ 561 pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out); 562 563 cbw->dCBWSignature = cpu_to_le32(CBWSIGNATURE); 564 cbw->dCBWTag = cpu_to_le32(CBWTag++); 565 cbw->dCBWDataTransferLength = cpu_to_le32(srb->datalen); 566 cbw->bCBWFlags = (dir_in ? CBWFLAGS_IN : CBWFLAGS_OUT); 567 cbw->bCBWLUN = srb->lun; 568 cbw->bCDBLength = srb->cmdlen; 569 /* copy the command data into the CBW command data buffer */ 570 /* DST SRC LEN!!! */ 571 572 memcpy(cbw->CBWCDB, srb->cmd, srb->cmdlen); 573 result = usb_bulk_msg(us->pusb_dev, pipe, cbw, UMASS_BBB_CBW_SIZE, 574 &actlen, USB_CNTL_TIMEOUT * 5); 575 if (result < 0) 576 debug("usb_stor_BBB_comdat:usb_bulk_msg error\n"); 577 return result; 578 } 579 580 /* FIXME: we also need a CBI_command which sets up the completion 581 * interrupt, and waits for it 582 */ 583 static int usb_stor_CB_comdat(struct scsi_cmd *srb, struct us_data *us) 584 { 585 int result = 0; 586 int dir_in, retry; 587 unsigned int pipe; 588 unsigned long status; 589 590 retry = 5; 591 dir_in = US_DIRECTION(srb->cmd[0]); 592 593 if (dir_in) 594 pipe = usb_rcvbulkpipe(us->pusb_dev, us->ep_in); 595 else 596 pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out); 597 598 while (retry--) { 599 debug("CBI gets a command: Try %d\n", 5 - retry); 600 #ifdef DEBUG 601 usb_show_srb(srb); 602 #endif 603 /* let's send the command via the control pipe */ 604 result = usb_control_msg(us->pusb_dev, 605 usb_sndctrlpipe(us->pusb_dev , 0), 606 US_CBI_ADSC, 607 USB_TYPE_CLASS | USB_RECIP_INTERFACE, 608 0, us->ifnum, 609 srb->cmd, srb->cmdlen, 610 USB_CNTL_TIMEOUT * 5); 611 debug("CB_transport: control msg returned %d, status %lX\n", 612 result, us->pusb_dev->status); 613 /* check the return code for the command */ 614 if (result < 0) { 615 if (us->pusb_dev->status & USB_ST_STALLED) { 616 status = us->pusb_dev->status; 617 debug(" stall during command found," \ 618 " clear pipe\n"); 619 usb_clear_halt(us->pusb_dev, 620 usb_sndctrlpipe(us->pusb_dev, 0)); 621 us->pusb_dev->status = status; 622 } 623 debug(" error during command %02X" \ 624 " Stat = %lX\n", srb->cmd[0], 625 us->pusb_dev->status); 626 return result; 627 } 628 /* transfer the data payload for this command, if one exists*/ 629 630 debug("CB_transport: control msg returned %d," \ 631 " direction is %s to go 0x%lx\n", result, 632 dir_in ? "IN" : "OUT", srb->datalen); 633 if (srb->datalen) { 634 result = us_one_transfer(us, pipe, (char *)srb->pdata, 635 srb->datalen); 636 debug("CBI attempted to transfer data," \ 637 " result is %d status %lX, len %d\n", 638 result, us->pusb_dev->status, 639 us->pusb_dev->act_len); 640 if (!(us->pusb_dev->status & USB_ST_NAK_REC)) 641 break; 642 } /* if (srb->datalen) */ 643 else 644 break; 645 } 646 /* return result */ 647 648 return result; 649 } 650 651 652 static int usb_stor_CBI_get_status(struct scsi_cmd *srb, struct us_data *us) 653 { 654 int timeout; 655 656 us->ip_wanted = 1; 657 submit_int_msg(us->pusb_dev, us->irqpipe, 658 (void *) &us->ip_data, us->irqmaxp, us->irqinterval); 659 timeout = 1000; 660 while (timeout--) { 661 if (us->ip_wanted == 0) 662 break; 663 mdelay(10); 664 } 665 if (us->ip_wanted) { 666 printf(" Did not get interrupt on CBI\n"); 667 us->ip_wanted = 0; 668 return USB_STOR_TRANSPORT_ERROR; 669 } 670 debug("Got interrupt data 0x%x, transferred %d status 0x%lX\n", 671 us->ip_data, us->pusb_dev->irq_act_len, 672 us->pusb_dev->irq_status); 673 /* UFI gives us ASC and ASCQ, like a request sense */ 674 if (us->subclass == US_SC_UFI) { 675 if (srb->cmd[0] == SCSI_REQ_SENSE || 676 srb->cmd[0] == SCSI_INQUIRY) 677 return USB_STOR_TRANSPORT_GOOD; /* Good */ 678 else if (us->ip_data) 679 return USB_STOR_TRANSPORT_FAILED; 680 else 681 return USB_STOR_TRANSPORT_GOOD; 682 } 683 /* otherwise, we interpret the data normally */ 684 switch (us->ip_data) { 685 case 0x0001: 686 return USB_STOR_TRANSPORT_GOOD; 687 case 0x0002: 688 return USB_STOR_TRANSPORT_FAILED; 689 default: 690 return USB_STOR_TRANSPORT_ERROR; 691 } /* switch */ 692 return USB_STOR_TRANSPORT_ERROR; 693 } 694 695 #define USB_TRANSPORT_UNKNOWN_RETRY 5 696 #define USB_TRANSPORT_NOT_READY_RETRY 10 697 698 /* clear a stall on an endpoint - special for BBB devices */ 699 static int usb_stor_BBB_clear_endpt_stall(struct us_data *us, __u8 endpt) 700 { 701 /* ENDPOINT_HALT = 0, so set value to 0 */ 702 return usb_control_msg(us->pusb_dev, usb_sndctrlpipe(us->pusb_dev, 0), 703 USB_REQ_CLEAR_FEATURE, USB_RECIP_ENDPOINT, 0, 704 endpt, NULL, 0, USB_CNTL_TIMEOUT * 5); 705 } 706 707 static int usb_stor_BBB_transport(struct scsi_cmd *srb, struct us_data *us) 708 { 709 int result, retry; 710 int dir_in; 711 int actlen, data_actlen; 712 unsigned int pipe, pipein, pipeout; 713 ALLOC_CACHE_ALIGN_BUFFER(struct umass_bbb_csw, csw, 1); 714 #ifdef BBB_XPORT_TRACE 715 unsigned char *ptr; 716 int index; 717 #endif 718 719 dir_in = US_DIRECTION(srb->cmd[0]); 720 721 /* COMMAND phase */ 722 debug("COMMAND phase\n"); 723 result = usb_stor_BBB_comdat(srb, us); 724 if (result < 0) { 725 debug("failed to send CBW status %ld\n", 726 us->pusb_dev->status); 727 usb_stor_BBB_reset(us); 728 return USB_STOR_TRANSPORT_FAILED; 729 } 730 if (!(us->flags & USB_READY)) 731 mdelay(5); 732 pipein = usb_rcvbulkpipe(us->pusb_dev, us->ep_in); 733 pipeout = usb_sndbulkpipe(us->pusb_dev, us->ep_out); 734 /* DATA phase + error handling */ 735 data_actlen = 0; 736 /* no data, go immediately to the STATUS phase */ 737 if (srb->datalen == 0) 738 goto st; 739 debug("DATA phase\n"); 740 if (dir_in) 741 pipe = pipein; 742 else 743 pipe = pipeout; 744 745 result = usb_bulk_msg(us->pusb_dev, pipe, srb->pdata, srb->datalen, 746 &data_actlen, USB_CNTL_TIMEOUT * 5); 747 /* special handling of STALL in DATA phase */ 748 if ((result < 0) && (us->pusb_dev->status & USB_ST_STALLED)) { 749 debug("DATA:stall\n"); 750 /* clear the STALL on the endpoint */ 751 result = usb_stor_BBB_clear_endpt_stall(us, 752 dir_in ? us->ep_in : us->ep_out); 753 if (result >= 0) 754 /* continue on to STATUS phase */ 755 goto st; 756 } 757 if (result < 0) { 758 debug("usb_bulk_msg error status %ld\n", 759 us->pusb_dev->status); 760 usb_stor_BBB_reset(us); 761 return USB_STOR_TRANSPORT_FAILED; 762 } 763 #ifdef BBB_XPORT_TRACE 764 for (index = 0; index < data_actlen; index++) 765 printf("pdata[%d] %#x ", index, srb->pdata[index]); 766 printf("\n"); 767 #endif 768 /* STATUS phase + error handling */ 769 st: 770 retry = 0; 771 again: 772 debug("STATUS phase\n"); 773 result = usb_bulk_msg(us->pusb_dev, pipein, csw, UMASS_BBB_CSW_SIZE, 774 &actlen, USB_CNTL_TIMEOUT*5); 775 776 /* special handling of STALL in STATUS phase */ 777 if ((result < 0) && (retry < 1) && 778 (us->pusb_dev->status & USB_ST_STALLED)) { 779 debug("STATUS:stall\n"); 780 /* clear the STALL on the endpoint */ 781 result = usb_stor_BBB_clear_endpt_stall(us, us->ep_in); 782 if (result >= 0 && (retry++ < 1)) 783 /* do a retry */ 784 goto again; 785 } 786 if (result < 0) { 787 debug("usb_bulk_msg error status %ld\n", 788 us->pusb_dev->status); 789 usb_stor_BBB_reset(us); 790 return USB_STOR_TRANSPORT_FAILED; 791 } 792 #ifdef BBB_XPORT_TRACE 793 ptr = (unsigned char *)csw; 794 for (index = 0; index < UMASS_BBB_CSW_SIZE; index++) 795 printf("ptr[%d] %#x ", index, ptr[index]); 796 printf("\n"); 797 #endif 798 /* misuse pipe to get the residue */ 799 pipe = le32_to_cpu(csw->dCSWDataResidue); 800 if (pipe == 0 && srb->datalen != 0 && srb->datalen - data_actlen != 0) 801 pipe = srb->datalen - data_actlen; 802 if (CSWSIGNATURE != le32_to_cpu(csw->dCSWSignature)) { 803 debug("!CSWSIGNATURE\n"); 804 usb_stor_BBB_reset(us); 805 return USB_STOR_TRANSPORT_FAILED; 806 } else if ((CBWTag - 1) != le32_to_cpu(csw->dCSWTag)) { 807 debug("!Tag\n"); 808 usb_stor_BBB_reset(us); 809 return USB_STOR_TRANSPORT_FAILED; 810 } else if (csw->bCSWStatus > CSWSTATUS_PHASE) { 811 debug(">PHASE\n"); 812 usb_stor_BBB_reset(us); 813 return USB_STOR_TRANSPORT_FAILED; 814 } else if (csw->bCSWStatus == CSWSTATUS_PHASE) { 815 debug("=PHASE\n"); 816 usb_stor_BBB_reset(us); 817 return USB_STOR_TRANSPORT_FAILED; 818 } else if (data_actlen > srb->datalen) { 819 debug("transferred %dB instead of %ldB\n", 820 data_actlen, srb->datalen); 821 return USB_STOR_TRANSPORT_FAILED; 822 } else if (csw->bCSWStatus == CSWSTATUS_FAILED) { 823 debug("FAILED\n"); 824 return USB_STOR_TRANSPORT_FAILED; 825 } 826 827 return result; 828 } 829 830 static int usb_stor_CB_transport(struct scsi_cmd *srb, struct us_data *us) 831 { 832 int result, status; 833 struct scsi_cmd *psrb; 834 struct scsi_cmd reqsrb; 835 int retry, notready; 836 837 psrb = &reqsrb; 838 status = USB_STOR_TRANSPORT_GOOD; 839 retry = 0; 840 notready = 0; 841 /* issue the command */ 842 do_retry: 843 result = usb_stor_CB_comdat(srb, us); 844 debug("command / Data returned %d, status %lX\n", 845 result, us->pusb_dev->status); 846 /* if this is an CBI Protocol, get IRQ */ 847 if (us->protocol == US_PR_CBI) { 848 status = usb_stor_CBI_get_status(srb, us); 849 /* if the status is error, report it */ 850 if (status == USB_STOR_TRANSPORT_ERROR) { 851 debug(" USB CBI Command Error\n"); 852 return status; 853 } 854 srb->sense_buf[12] = (unsigned char)(us->ip_data >> 8); 855 srb->sense_buf[13] = (unsigned char)(us->ip_data & 0xff); 856 if (!us->ip_data) { 857 /* if the status is good, report it */ 858 if (status == USB_STOR_TRANSPORT_GOOD) { 859 debug(" USB CBI Command Good\n"); 860 return status; 861 } 862 } 863 } 864 /* do we have to issue an auto request? */ 865 /* HERE we have to check the result */ 866 if ((result < 0) && !(us->pusb_dev->status & USB_ST_STALLED)) { 867 debug("ERROR %lX\n", us->pusb_dev->status); 868 us->transport_reset(us); 869 return USB_STOR_TRANSPORT_ERROR; 870 } 871 if ((us->protocol == US_PR_CBI) && 872 ((srb->cmd[0] == SCSI_REQ_SENSE) || 873 (srb->cmd[0] == SCSI_INQUIRY))) { 874 /* do not issue an autorequest after request sense */ 875 debug("No auto request and good\n"); 876 return USB_STOR_TRANSPORT_GOOD; 877 } 878 /* issue an request_sense */ 879 memset(&psrb->cmd[0], 0, 12); 880 psrb->cmd[0] = SCSI_REQ_SENSE; 881 psrb->cmd[1] = srb->lun << 5; 882 psrb->cmd[4] = 18; 883 psrb->datalen = 18; 884 psrb->pdata = &srb->sense_buf[0]; 885 psrb->cmdlen = 12; 886 /* issue the command */ 887 result = usb_stor_CB_comdat(psrb, us); 888 debug("auto request returned %d\n", result); 889 /* if this is an CBI Protocol, get IRQ */ 890 if (us->protocol == US_PR_CBI) 891 status = usb_stor_CBI_get_status(psrb, us); 892 893 if ((result < 0) && !(us->pusb_dev->status & USB_ST_STALLED)) { 894 debug(" AUTO REQUEST ERROR %ld\n", 895 us->pusb_dev->status); 896 return USB_STOR_TRANSPORT_ERROR; 897 } 898 debug("autorequest returned 0x%02X 0x%02X 0x%02X 0x%02X\n", 899 srb->sense_buf[0], srb->sense_buf[2], 900 srb->sense_buf[12], srb->sense_buf[13]); 901 /* Check the auto request result */ 902 if ((srb->sense_buf[2] == 0) && 903 (srb->sense_buf[12] == 0) && 904 (srb->sense_buf[13] == 0)) { 905 /* ok, no sense */ 906 return USB_STOR_TRANSPORT_GOOD; 907 } 908 909 /* Check the auto request result */ 910 switch (srb->sense_buf[2]) { 911 case 0x01: 912 /* Recovered Error */ 913 return USB_STOR_TRANSPORT_GOOD; 914 break; 915 case 0x02: 916 /* Not Ready */ 917 if (notready++ > USB_TRANSPORT_NOT_READY_RETRY) { 918 printf("cmd 0x%02X returned 0x%02X 0x%02X 0x%02X" 919 " 0x%02X (NOT READY)\n", srb->cmd[0], 920 srb->sense_buf[0], srb->sense_buf[2], 921 srb->sense_buf[12], srb->sense_buf[13]); 922 return USB_STOR_TRANSPORT_FAILED; 923 } else { 924 mdelay(100); 925 goto do_retry; 926 } 927 break; 928 default: 929 if (retry++ > USB_TRANSPORT_UNKNOWN_RETRY) { 930 printf("cmd 0x%02X returned 0x%02X 0x%02X 0x%02X" 931 " 0x%02X\n", srb->cmd[0], srb->sense_buf[0], 932 srb->sense_buf[2], srb->sense_buf[12], 933 srb->sense_buf[13]); 934 return USB_STOR_TRANSPORT_FAILED; 935 } else 936 goto do_retry; 937 break; 938 } 939 return USB_STOR_TRANSPORT_FAILED; 940 } 941 942 static void usb_stor_set_max_xfer_blk(struct us_data *us) 943 { 944 unsigned short blk; 945 946 #ifdef CONFIG_USB_EHCI_HCD 947 /* 948 * The U-Boot EHCI driver can handle any transfer length as long as 949 * there is enough free heap space left, but the SCSI READ(10) and 950 * WRITE(10) commands are limited to 65535 blocks. 951 */ 952 blk = USHRT_MAX; 953 #else 954 blk = 20; 955 #endif 956 957 us->max_xfer_blk = blk; 958 } 959 960 static int usb_inquiry(struct scsi_cmd *srb, struct us_data *ss) 961 { 962 int retry, i; 963 retry = 5; 964 do { 965 memset(&srb->cmd[0], 0, 12); 966 srb->cmd[0] = SCSI_INQUIRY; 967 srb->cmd[1] = srb->lun << 5; 968 srb->cmd[4] = 36; 969 srb->datalen = 36; 970 srb->cmdlen = 12; 971 i = ss->transport(srb, ss); 972 debug("inquiry returns %d\n", i); 973 if (i == 0) 974 break; 975 } while (--retry); 976 977 if (!retry) { 978 printf("error in inquiry\n"); 979 return -1; 980 } 981 return 0; 982 } 983 984 static int usb_request_sense(struct scsi_cmd *srb, struct us_data *ss) 985 { 986 char *ptr; 987 988 ptr = (char *)srb->pdata; 989 memset(&srb->cmd[0], 0, 12); 990 srb->cmd[0] = SCSI_REQ_SENSE; 991 srb->cmd[1] = srb->lun << 5; 992 srb->cmd[4] = 18; 993 srb->datalen = 18; 994 srb->pdata = &srb->sense_buf[0]; 995 srb->cmdlen = 12; 996 ss->transport(srb, ss); 997 debug("Request Sense returned %02X %02X %02X\n", 998 srb->sense_buf[2], srb->sense_buf[12], 999 srb->sense_buf[13]); 1000 srb->pdata = (uchar *)ptr; 1001 return 0; 1002 } 1003 1004 static int usb_test_unit_ready(struct scsi_cmd *srb, struct us_data *ss) 1005 { 1006 int retries = 10; 1007 1008 do { 1009 memset(&srb->cmd[0], 0, 12); 1010 srb->cmd[0] = SCSI_TST_U_RDY; 1011 srb->cmd[1] = srb->lun << 5; 1012 srb->datalen = 0; 1013 srb->cmdlen = 12; 1014 if (ss->transport(srb, ss) == USB_STOR_TRANSPORT_GOOD) { 1015 ss->flags |= USB_READY; 1016 return 0; 1017 } 1018 usb_request_sense(srb, ss); 1019 /* 1020 * Check the Key Code Qualifier, if it matches 1021 * "Not Ready - medium not present" 1022 * (the sense Key equals 0x2 and the ASC is 0x3a) 1023 * return immediately as the medium being absent won't change 1024 * unless there is a user action. 1025 */ 1026 if ((srb->sense_buf[2] == 0x02) && 1027 (srb->sense_buf[12] == 0x3a)) 1028 return -1; 1029 mdelay(100); 1030 } while (retries--); 1031 1032 return -1; 1033 } 1034 1035 static int usb_read_capacity(struct scsi_cmd *srb, struct us_data *ss) 1036 { 1037 int retry; 1038 /* XXX retries */ 1039 retry = 3; 1040 do { 1041 memset(&srb->cmd[0], 0, 12); 1042 srb->cmd[0] = SCSI_RD_CAPAC; 1043 srb->cmd[1] = srb->lun << 5; 1044 srb->datalen = 8; 1045 srb->cmdlen = 12; 1046 if (ss->transport(srb, ss) == USB_STOR_TRANSPORT_GOOD) 1047 return 0; 1048 } while (retry--); 1049 1050 return -1; 1051 } 1052 1053 static int usb_read_10(struct scsi_cmd *srb, struct us_data *ss, 1054 unsigned long start, unsigned short blocks) 1055 { 1056 memset(&srb->cmd[0], 0, 12); 1057 srb->cmd[0] = SCSI_READ10; 1058 srb->cmd[1] = srb->lun << 5; 1059 srb->cmd[2] = ((unsigned char) (start >> 24)) & 0xff; 1060 srb->cmd[3] = ((unsigned char) (start >> 16)) & 0xff; 1061 srb->cmd[4] = ((unsigned char) (start >> 8)) & 0xff; 1062 srb->cmd[5] = ((unsigned char) (start)) & 0xff; 1063 srb->cmd[7] = ((unsigned char) (blocks >> 8)) & 0xff; 1064 srb->cmd[8] = (unsigned char) blocks & 0xff; 1065 srb->cmdlen = 12; 1066 debug("read10: start %lx blocks %x\n", start, blocks); 1067 return ss->transport(srb, ss); 1068 } 1069 1070 static int usb_write_10(struct scsi_cmd *srb, struct us_data *ss, 1071 unsigned long start, unsigned short blocks) 1072 { 1073 memset(&srb->cmd[0], 0, 12); 1074 srb->cmd[0] = SCSI_WRITE10; 1075 srb->cmd[1] = srb->lun << 5; 1076 srb->cmd[2] = ((unsigned char) (start >> 24)) & 0xff; 1077 srb->cmd[3] = ((unsigned char) (start >> 16)) & 0xff; 1078 srb->cmd[4] = ((unsigned char) (start >> 8)) & 0xff; 1079 srb->cmd[5] = ((unsigned char) (start)) & 0xff; 1080 srb->cmd[7] = ((unsigned char) (blocks >> 8)) & 0xff; 1081 srb->cmd[8] = (unsigned char) blocks & 0xff; 1082 srb->cmdlen = 12; 1083 debug("write10: start %lx blocks %x\n", start, blocks); 1084 return ss->transport(srb, ss); 1085 } 1086 1087 1088 #ifdef CONFIG_USB_BIN_FIXUP 1089 /* 1090 * Some USB storage devices queried for SCSI identification data respond with 1091 * binary strings, which if output to the console freeze the terminal. The 1092 * workaround is to modify the vendor and product strings read from such 1093 * device with proper values (as reported by 'usb info'). 1094 * 1095 * Vendor and product length limits are taken from the definition of 1096 * struct blk_desc in include/part.h. 1097 */ 1098 static void usb_bin_fixup(struct usb_device_descriptor descriptor, 1099 unsigned char vendor[], 1100 unsigned char product[]) { 1101 const unsigned char max_vendor_len = 40; 1102 const unsigned char max_product_len = 20; 1103 if (descriptor.idVendor == 0x0424 && descriptor.idProduct == 0x223a) { 1104 strncpy((char *)vendor, "SMSC", max_vendor_len); 1105 strncpy((char *)product, "Flash Media Cntrller", 1106 max_product_len); 1107 } 1108 } 1109 #endif /* CONFIG_USB_BIN_FIXUP */ 1110 1111 #ifdef CONFIG_BLK 1112 static unsigned long usb_stor_read(struct udevice *dev, lbaint_t blknr, 1113 lbaint_t blkcnt, void *buffer) 1114 #else 1115 static unsigned long usb_stor_read(struct blk_desc *block_dev, lbaint_t blknr, 1116 lbaint_t blkcnt, void *buffer) 1117 #endif 1118 { 1119 lbaint_t start, blks; 1120 uintptr_t buf_addr; 1121 unsigned short smallblks; 1122 struct usb_device *udev; 1123 struct us_data *ss; 1124 int retry; 1125 struct scsi_cmd *srb = &usb_ccb; 1126 #ifdef CONFIG_BLK 1127 struct blk_desc *block_dev; 1128 #endif 1129 1130 if (blkcnt == 0) 1131 return 0; 1132 /* Setup device */ 1133 #ifdef CONFIG_BLK 1134 block_dev = dev_get_uclass_platdata(dev); 1135 udev = dev_get_parent_priv(dev_get_parent(dev)); 1136 debug("\nusb_read: udev %d\n", block_dev->devnum); 1137 #else 1138 debug("\nusb_read: udev %d\n", block_dev->devnum); 1139 udev = usb_dev_desc[block_dev->devnum].priv; 1140 if (!udev) { 1141 debug("%s: No device\n", __func__); 1142 return 0; 1143 } 1144 #endif 1145 ss = (struct us_data *)udev->privptr; 1146 1147 usb_disable_asynch(1); /* asynch transfer not allowed */ 1148 srb->lun = block_dev->lun; 1149 buf_addr = (uintptr_t)buffer; 1150 start = blknr; 1151 blks = blkcnt; 1152 1153 debug("\nusb_read: dev %d startblk " LBAF ", blccnt " LBAF " buffer %" 1154 PRIxPTR "\n", block_dev->devnum, start, blks, buf_addr); 1155 1156 do { 1157 /* XXX need some comment here */ 1158 retry = 2; 1159 srb->pdata = (unsigned char *)buf_addr; 1160 if (blks > ss->max_xfer_blk) 1161 smallblks = ss->max_xfer_blk; 1162 else 1163 smallblks = (unsigned short) blks; 1164 retry_it: 1165 if (smallblks == ss->max_xfer_blk) 1166 usb_show_progress(); 1167 srb->datalen = block_dev->blksz * smallblks; 1168 srb->pdata = (unsigned char *)buf_addr; 1169 if (usb_read_10(srb, ss, start, smallblks)) { 1170 debug("Read ERROR\n"); 1171 usb_request_sense(srb, ss); 1172 if (retry--) 1173 goto retry_it; 1174 blkcnt -= blks; 1175 break; 1176 } 1177 start += smallblks; 1178 blks -= smallblks; 1179 buf_addr += srb->datalen; 1180 } while (blks != 0); 1181 ss->flags &= ~USB_READY; 1182 1183 debug("usb_read: end startblk " LBAF 1184 ", blccnt %x buffer %" PRIxPTR "\n", 1185 start, smallblks, buf_addr); 1186 1187 usb_disable_asynch(0); /* asynch transfer allowed */ 1188 if (blkcnt >= ss->max_xfer_blk) 1189 debug("\n"); 1190 return blkcnt; 1191 } 1192 1193 #ifdef CONFIG_BLK 1194 static unsigned long usb_stor_write(struct udevice *dev, lbaint_t blknr, 1195 lbaint_t blkcnt, const void *buffer) 1196 #else 1197 static unsigned long usb_stor_write(struct blk_desc *block_dev, lbaint_t blknr, 1198 lbaint_t blkcnt, const void *buffer) 1199 #endif 1200 { 1201 lbaint_t start, blks; 1202 uintptr_t buf_addr; 1203 unsigned short smallblks; 1204 struct usb_device *udev; 1205 struct us_data *ss; 1206 int retry; 1207 struct scsi_cmd *srb = &usb_ccb; 1208 #ifdef CONFIG_BLK 1209 struct blk_desc *block_dev; 1210 #endif 1211 1212 if (blkcnt == 0) 1213 return 0; 1214 1215 /* Setup device */ 1216 #ifdef CONFIG_BLK 1217 block_dev = dev_get_uclass_platdata(dev); 1218 udev = dev_get_parent_priv(dev_get_parent(dev)); 1219 debug("\nusb_read: udev %d\n", block_dev->devnum); 1220 #else 1221 debug("\nusb_read: udev %d\n", block_dev->devnum); 1222 udev = usb_dev_desc[block_dev->devnum].priv; 1223 if (!udev) { 1224 debug("%s: No device\n", __func__); 1225 return 0; 1226 } 1227 #endif 1228 ss = (struct us_data *)udev->privptr; 1229 1230 usb_disable_asynch(1); /* asynch transfer not allowed */ 1231 1232 srb->lun = block_dev->lun; 1233 buf_addr = (uintptr_t)buffer; 1234 start = blknr; 1235 blks = blkcnt; 1236 1237 debug("\nusb_write: dev %d startblk " LBAF ", blccnt " LBAF " buffer %" 1238 PRIxPTR "\n", block_dev->devnum, start, blks, buf_addr); 1239 1240 do { 1241 /* If write fails retry for max retry count else 1242 * return with number of blocks written successfully. 1243 */ 1244 retry = 2; 1245 srb->pdata = (unsigned char *)buf_addr; 1246 if (blks > ss->max_xfer_blk) 1247 smallblks = ss->max_xfer_blk; 1248 else 1249 smallblks = (unsigned short) blks; 1250 retry_it: 1251 if (smallblks == ss->max_xfer_blk) 1252 usb_show_progress(); 1253 srb->datalen = block_dev->blksz * smallblks; 1254 srb->pdata = (unsigned char *)buf_addr; 1255 if (usb_write_10(srb, ss, start, smallblks)) { 1256 debug("Write ERROR\n"); 1257 usb_request_sense(srb, ss); 1258 if (retry--) 1259 goto retry_it; 1260 blkcnt -= blks; 1261 break; 1262 } 1263 start += smallblks; 1264 blks -= smallblks; 1265 buf_addr += srb->datalen; 1266 } while (blks != 0); 1267 ss->flags &= ~USB_READY; 1268 1269 debug("usb_write: end startblk " LBAF ", blccnt %x buffer %" 1270 PRIxPTR "\n", start, smallblks, buf_addr); 1271 1272 usb_disable_asynch(0); /* asynch transfer allowed */ 1273 if (blkcnt >= ss->max_xfer_blk) 1274 debug("\n"); 1275 return blkcnt; 1276 1277 } 1278 1279 /* Probe to see if a new device is actually a Storage device */ 1280 int usb_storage_probe(struct usb_device *dev, unsigned int ifnum, 1281 struct us_data *ss) 1282 { 1283 struct usb_interface *iface; 1284 int i; 1285 struct usb_endpoint_descriptor *ep_desc; 1286 unsigned int flags = 0; 1287 1288 /* let's examine the device now */ 1289 iface = &dev->config.if_desc[ifnum]; 1290 1291 if (dev->descriptor.bDeviceClass != 0 || 1292 iface->desc.bInterfaceClass != USB_CLASS_MASS_STORAGE || 1293 iface->desc.bInterfaceSubClass < US_SC_MIN || 1294 iface->desc.bInterfaceSubClass > US_SC_MAX) { 1295 debug("Not mass storage\n"); 1296 /* if it's not a mass storage, we go no further */ 1297 return 0; 1298 } 1299 1300 memset(ss, 0, sizeof(struct us_data)); 1301 1302 /* At this point, we know we've got a live one */ 1303 debug("\n\nUSB Mass Storage device detected\n"); 1304 1305 /* Initialize the us_data structure with some useful info */ 1306 ss->flags = flags; 1307 ss->ifnum = ifnum; 1308 ss->pusb_dev = dev; 1309 ss->attention_done = 0; 1310 ss->subclass = iface->desc.bInterfaceSubClass; 1311 ss->protocol = iface->desc.bInterfaceProtocol; 1312 1313 /* set the handler pointers based on the protocol */ 1314 debug("Transport: "); 1315 switch (ss->protocol) { 1316 case US_PR_CB: 1317 debug("Control/Bulk\n"); 1318 ss->transport = usb_stor_CB_transport; 1319 ss->transport_reset = usb_stor_CB_reset; 1320 break; 1321 1322 case US_PR_CBI: 1323 debug("Control/Bulk/Interrupt\n"); 1324 ss->transport = usb_stor_CB_transport; 1325 ss->transport_reset = usb_stor_CB_reset; 1326 break; 1327 case US_PR_BULK: 1328 debug("Bulk/Bulk/Bulk\n"); 1329 ss->transport = usb_stor_BBB_transport; 1330 ss->transport_reset = usb_stor_BBB_reset; 1331 break; 1332 default: 1333 printf("USB Storage Transport unknown / not yet implemented\n"); 1334 return 0; 1335 break; 1336 } 1337 1338 /* 1339 * We are expecting a minimum of 2 endpoints - in and out (bulk). 1340 * An optional interrupt is OK (necessary for CBI protocol). 1341 * We will ignore any others. 1342 */ 1343 for (i = 0; i < iface->desc.bNumEndpoints; i++) { 1344 ep_desc = &iface->ep_desc[i]; 1345 /* is it an BULK endpoint? */ 1346 if ((ep_desc->bmAttributes & 1347 USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_BULK) { 1348 if (ep_desc->bEndpointAddress & USB_DIR_IN) 1349 ss->ep_in = ep_desc->bEndpointAddress & 1350 USB_ENDPOINT_NUMBER_MASK; 1351 else 1352 ss->ep_out = 1353 ep_desc->bEndpointAddress & 1354 USB_ENDPOINT_NUMBER_MASK; 1355 } 1356 1357 /* is it an interrupt endpoint? */ 1358 if ((ep_desc->bmAttributes & 1359 USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT) { 1360 ss->ep_int = ep_desc->bEndpointAddress & 1361 USB_ENDPOINT_NUMBER_MASK; 1362 ss->irqinterval = ep_desc->bInterval; 1363 } 1364 } 1365 debug("Endpoints In %d Out %d Int %d\n", 1366 ss->ep_in, ss->ep_out, ss->ep_int); 1367 1368 /* Do some basic sanity checks, and bail if we find a problem */ 1369 if (usb_set_interface(dev, iface->desc.bInterfaceNumber, 0) || 1370 !ss->ep_in || !ss->ep_out || 1371 (ss->protocol == US_PR_CBI && ss->ep_int == 0)) { 1372 debug("Problems with device\n"); 1373 return 0; 1374 } 1375 /* set class specific stuff */ 1376 /* We only handle certain protocols. Currently, these are 1377 * the only ones. 1378 * The SFF8070 accepts the requests used in u-boot 1379 */ 1380 if (ss->subclass != US_SC_UFI && ss->subclass != US_SC_SCSI && 1381 ss->subclass != US_SC_8070) { 1382 printf("Sorry, protocol %d not yet supported.\n", ss->subclass); 1383 return 0; 1384 } 1385 if (ss->ep_int) { 1386 /* we had found an interrupt endpoint, prepare irq pipe 1387 * set up the IRQ pipe and handler 1388 */ 1389 ss->irqinterval = (ss->irqinterval > 0) ? ss->irqinterval : 255; 1390 ss->irqpipe = usb_rcvintpipe(ss->pusb_dev, ss->ep_int); 1391 ss->irqmaxp = usb_maxpacket(dev, ss->irqpipe); 1392 dev->irq_handle = usb_stor_irq; 1393 } 1394 1395 /* Set the maximum transfer size per host controller setting */ 1396 usb_stor_set_max_xfer_blk(ss); 1397 1398 dev->privptr = (void *)ss; 1399 return 1; 1400 } 1401 1402 int usb_stor_get_info(struct usb_device *dev, struct us_data *ss, 1403 struct blk_desc *dev_desc) 1404 { 1405 unsigned char perq, modi; 1406 ALLOC_CACHE_ALIGN_BUFFER(u32, cap, 2); 1407 ALLOC_CACHE_ALIGN_BUFFER(u8, usb_stor_buf, 36); 1408 u32 capacity, blksz; 1409 struct scsi_cmd *pccb = &usb_ccb; 1410 1411 pccb->pdata = usb_stor_buf; 1412 1413 dev_desc->target = dev->devnum; 1414 pccb->lun = dev_desc->lun; 1415 debug(" address %d\n", dev_desc->target); 1416 1417 if (usb_inquiry(pccb, ss)) { 1418 debug("%s: usb_inquiry() failed\n", __func__); 1419 return -1; 1420 } 1421 1422 perq = usb_stor_buf[0]; 1423 modi = usb_stor_buf[1]; 1424 1425 /* 1426 * Skip unknown devices (0x1f) and enclosure service devices (0x0d), 1427 * they would not respond to test_unit_ready . 1428 */ 1429 if (((perq & 0x1f) == 0x1f) || ((perq & 0x1f) == 0x0d)) { 1430 debug("%s: unknown/unsupported device\n", __func__); 1431 return 0; 1432 } 1433 if ((modi&0x80) == 0x80) { 1434 /* drive is removable */ 1435 dev_desc->removable = 1; 1436 } 1437 memcpy(dev_desc->vendor, (const void *)&usb_stor_buf[8], 8); 1438 memcpy(dev_desc->product, (const void *)&usb_stor_buf[16], 16); 1439 memcpy(dev_desc->revision, (const void *)&usb_stor_buf[32], 4); 1440 dev_desc->vendor[8] = 0; 1441 dev_desc->product[16] = 0; 1442 dev_desc->revision[4] = 0; 1443 #ifdef CONFIG_USB_BIN_FIXUP 1444 usb_bin_fixup(dev->descriptor, (uchar *)dev_desc->vendor, 1445 (uchar *)dev_desc->product); 1446 #endif /* CONFIG_USB_BIN_FIXUP */ 1447 debug("ISO Vers %X, Response Data %X\n", usb_stor_buf[2], 1448 usb_stor_buf[3]); 1449 if (usb_test_unit_ready(pccb, ss)) { 1450 printf("Device NOT ready\n" 1451 " Request Sense returned %02X %02X %02X\n", 1452 pccb->sense_buf[2], pccb->sense_buf[12], 1453 pccb->sense_buf[13]); 1454 if (dev_desc->removable == 1) 1455 dev_desc->type = perq; 1456 return 0; 1457 } 1458 pccb->pdata = (unsigned char *)cap; 1459 memset(pccb->pdata, 0, 8); 1460 if (usb_read_capacity(pccb, ss) != 0) { 1461 printf("READ_CAP ERROR\n"); 1462 cap[0] = 2880; 1463 cap[1] = 0x200; 1464 } 1465 ss->flags &= ~USB_READY; 1466 debug("Read Capacity returns: 0x%08x, 0x%08x\n", cap[0], cap[1]); 1467 #if 0 1468 if (cap[0] > (0x200000 * 10)) /* greater than 10 GByte */ 1469 cap[0] >>= 16; 1470 1471 cap[0] = cpu_to_be32(cap[0]); 1472 cap[1] = cpu_to_be32(cap[1]); 1473 #endif 1474 1475 capacity = be32_to_cpu(cap[0]) + 1; 1476 blksz = be32_to_cpu(cap[1]); 1477 1478 debug("Capacity = 0x%08x, blocksz = 0x%08x\n", capacity, blksz); 1479 dev_desc->lba = capacity; 1480 dev_desc->blksz = blksz; 1481 dev_desc->log2blksz = LOG2(dev_desc->blksz); 1482 dev_desc->type = perq; 1483 debug(" address %d\n", dev_desc->target); 1484 1485 return 1; 1486 } 1487 1488 #ifdef CONFIG_DM_USB 1489 1490 static int usb_mass_storage_probe(struct udevice *dev) 1491 { 1492 struct usb_device *udev = dev_get_parent_priv(dev); 1493 int ret; 1494 1495 usb_disable_asynch(1); /* asynch transfer not allowed */ 1496 ret = usb_stor_probe_device(udev); 1497 usb_disable_asynch(0); /* asynch transfer allowed */ 1498 1499 return ret; 1500 } 1501 1502 static const struct udevice_id usb_mass_storage_ids[] = { 1503 { .compatible = "usb-mass-storage" }, 1504 { } 1505 }; 1506 1507 U_BOOT_DRIVER(usb_mass_storage) = { 1508 .name = "usb_mass_storage", 1509 .id = UCLASS_MASS_STORAGE, 1510 .of_match = usb_mass_storage_ids, 1511 .probe = usb_mass_storage_probe, 1512 #ifdef CONFIG_BLK 1513 .platdata_auto_alloc_size = sizeof(struct us_data), 1514 #endif 1515 }; 1516 1517 UCLASS_DRIVER(usb_mass_storage) = { 1518 .id = UCLASS_MASS_STORAGE, 1519 .name = "usb_mass_storage", 1520 }; 1521 1522 static const struct usb_device_id mass_storage_id_table[] = { 1523 { 1524 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS, 1525 .bInterfaceClass = USB_CLASS_MASS_STORAGE 1526 }, 1527 { } /* Terminating entry */ 1528 }; 1529 1530 U_BOOT_USB_DEVICE(usb_mass_storage, mass_storage_id_table); 1531 #endif 1532 1533 #ifdef CONFIG_BLK 1534 static const struct blk_ops usb_storage_ops = { 1535 .read = usb_stor_read, 1536 .write = usb_stor_write, 1537 }; 1538 1539 U_BOOT_DRIVER(usb_storage_blk) = { 1540 .name = "usb_storage_blk", 1541 .id = UCLASS_BLK, 1542 .ops = &usb_storage_ops, 1543 }; 1544 #else 1545 U_BOOT_LEGACY_BLK(usb) = { 1546 .if_typename = "usb", 1547 .if_type = IF_TYPE_USB, 1548 .max_devs = USB_MAX_STOR_DEV, 1549 .desc = usb_dev_desc, 1550 }; 1551 #endif 1552