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 usb_device *udev, 943 struct us_data *us) 944 { 945 unsigned short blk; 946 size_t __maybe_unused size; 947 int __maybe_unused ret; 948 949 #ifndef CONFIG_DM_USB 950 #ifdef CONFIG_USB_EHCI_HCD 951 /* 952 * The U-Boot EHCI driver can handle any transfer length as long as 953 * there is enough free heap space left, but the SCSI READ(10) and 954 * WRITE(10) commands are limited to 65535 blocks. 955 */ 956 blk = USHRT_MAX; 957 #else 958 blk = 20; 959 #endif 960 #else 961 ret = usb_get_max_xfer_size(udev, (size_t *)&size); 962 if (ret < 0) { 963 /* unimplemented, let's use default 20 */ 964 blk = 20; 965 } else { 966 if (size > USHRT_MAX * 512) 967 blk = USHRT_MAX; 968 blk = size / 512; 969 } 970 #endif 971 972 us->max_xfer_blk = blk; 973 } 974 975 static int usb_inquiry(struct scsi_cmd *srb, struct us_data *ss) 976 { 977 int retry, i; 978 retry = 5; 979 do { 980 memset(&srb->cmd[0], 0, 12); 981 srb->cmd[0] = SCSI_INQUIRY; 982 srb->cmd[1] = srb->lun << 5; 983 srb->cmd[4] = 36; 984 srb->datalen = 36; 985 srb->cmdlen = 12; 986 i = ss->transport(srb, ss); 987 debug("inquiry returns %d\n", i); 988 if (i == 0) 989 break; 990 } while (--retry); 991 992 if (!retry) { 993 printf("error in inquiry\n"); 994 return -1; 995 } 996 return 0; 997 } 998 999 static int usb_request_sense(struct scsi_cmd *srb, struct us_data *ss) 1000 { 1001 char *ptr; 1002 1003 ptr = (char *)srb->pdata; 1004 memset(&srb->cmd[0], 0, 12); 1005 srb->cmd[0] = SCSI_REQ_SENSE; 1006 srb->cmd[1] = srb->lun << 5; 1007 srb->cmd[4] = 18; 1008 srb->datalen = 18; 1009 srb->pdata = &srb->sense_buf[0]; 1010 srb->cmdlen = 12; 1011 ss->transport(srb, ss); 1012 debug("Request Sense returned %02X %02X %02X\n", 1013 srb->sense_buf[2], srb->sense_buf[12], 1014 srb->sense_buf[13]); 1015 srb->pdata = (uchar *)ptr; 1016 return 0; 1017 } 1018 1019 static int usb_test_unit_ready(struct scsi_cmd *srb, struct us_data *ss) 1020 { 1021 int retries = 10; 1022 1023 do { 1024 memset(&srb->cmd[0], 0, 12); 1025 srb->cmd[0] = SCSI_TST_U_RDY; 1026 srb->cmd[1] = srb->lun << 5; 1027 srb->datalen = 0; 1028 srb->cmdlen = 12; 1029 if (ss->transport(srb, ss) == USB_STOR_TRANSPORT_GOOD) { 1030 ss->flags |= USB_READY; 1031 return 0; 1032 } 1033 usb_request_sense(srb, ss); 1034 /* 1035 * Check the Key Code Qualifier, if it matches 1036 * "Not Ready - medium not present" 1037 * (the sense Key equals 0x2 and the ASC is 0x3a) 1038 * return immediately as the medium being absent won't change 1039 * unless there is a user action. 1040 */ 1041 if ((srb->sense_buf[2] == 0x02) && 1042 (srb->sense_buf[12] == 0x3a)) 1043 return -1; 1044 mdelay(100); 1045 } while (retries--); 1046 1047 return -1; 1048 } 1049 1050 static int usb_read_capacity(struct scsi_cmd *srb, struct us_data *ss) 1051 { 1052 int retry; 1053 /* XXX retries */ 1054 retry = 3; 1055 do { 1056 memset(&srb->cmd[0], 0, 12); 1057 srb->cmd[0] = SCSI_RD_CAPAC; 1058 srb->cmd[1] = srb->lun << 5; 1059 srb->datalen = 8; 1060 srb->cmdlen = 12; 1061 if (ss->transport(srb, ss) == USB_STOR_TRANSPORT_GOOD) 1062 return 0; 1063 } while (retry--); 1064 1065 return -1; 1066 } 1067 1068 static int usb_read_10(struct scsi_cmd *srb, struct us_data *ss, 1069 unsigned long start, unsigned short blocks) 1070 { 1071 memset(&srb->cmd[0], 0, 12); 1072 srb->cmd[0] = SCSI_READ10; 1073 srb->cmd[1] = srb->lun << 5; 1074 srb->cmd[2] = ((unsigned char) (start >> 24)) & 0xff; 1075 srb->cmd[3] = ((unsigned char) (start >> 16)) & 0xff; 1076 srb->cmd[4] = ((unsigned char) (start >> 8)) & 0xff; 1077 srb->cmd[5] = ((unsigned char) (start)) & 0xff; 1078 srb->cmd[7] = ((unsigned char) (blocks >> 8)) & 0xff; 1079 srb->cmd[8] = (unsigned char) blocks & 0xff; 1080 srb->cmdlen = 12; 1081 debug("read10: start %lx blocks %x\n", start, blocks); 1082 return ss->transport(srb, ss); 1083 } 1084 1085 static int usb_write_10(struct scsi_cmd *srb, struct us_data *ss, 1086 unsigned long start, unsigned short blocks) 1087 { 1088 memset(&srb->cmd[0], 0, 12); 1089 srb->cmd[0] = SCSI_WRITE10; 1090 srb->cmd[1] = srb->lun << 5; 1091 srb->cmd[2] = ((unsigned char) (start >> 24)) & 0xff; 1092 srb->cmd[3] = ((unsigned char) (start >> 16)) & 0xff; 1093 srb->cmd[4] = ((unsigned char) (start >> 8)) & 0xff; 1094 srb->cmd[5] = ((unsigned char) (start)) & 0xff; 1095 srb->cmd[7] = ((unsigned char) (blocks >> 8)) & 0xff; 1096 srb->cmd[8] = (unsigned char) blocks & 0xff; 1097 srb->cmdlen = 12; 1098 debug("write10: start %lx blocks %x\n", start, blocks); 1099 return ss->transport(srb, ss); 1100 } 1101 1102 1103 #ifdef CONFIG_USB_BIN_FIXUP 1104 /* 1105 * Some USB storage devices queried for SCSI identification data respond with 1106 * binary strings, which if output to the console freeze the terminal. The 1107 * workaround is to modify the vendor and product strings read from such 1108 * device with proper values (as reported by 'usb info'). 1109 * 1110 * Vendor and product length limits are taken from the definition of 1111 * struct blk_desc in include/part.h. 1112 */ 1113 static void usb_bin_fixup(struct usb_device_descriptor descriptor, 1114 unsigned char vendor[], 1115 unsigned char product[]) { 1116 const unsigned char max_vendor_len = 40; 1117 const unsigned char max_product_len = 20; 1118 if (descriptor.idVendor == 0x0424 && descriptor.idProduct == 0x223a) { 1119 strncpy((char *)vendor, "SMSC", max_vendor_len); 1120 strncpy((char *)product, "Flash Media Cntrller", 1121 max_product_len); 1122 } 1123 } 1124 #endif /* CONFIG_USB_BIN_FIXUP */ 1125 1126 #ifdef CONFIG_BLK 1127 static unsigned long usb_stor_read(struct udevice *dev, lbaint_t blknr, 1128 lbaint_t blkcnt, void *buffer) 1129 #else 1130 static unsigned long usb_stor_read(struct blk_desc *block_dev, lbaint_t blknr, 1131 lbaint_t blkcnt, void *buffer) 1132 #endif 1133 { 1134 lbaint_t start, blks; 1135 uintptr_t buf_addr; 1136 unsigned short smallblks; 1137 struct usb_device *udev; 1138 struct us_data *ss; 1139 int retry; 1140 struct scsi_cmd *srb = &usb_ccb; 1141 #ifdef CONFIG_BLK 1142 struct blk_desc *block_dev; 1143 #endif 1144 1145 if (blkcnt == 0) 1146 return 0; 1147 /* Setup device */ 1148 #ifdef CONFIG_BLK 1149 block_dev = dev_get_uclass_platdata(dev); 1150 udev = dev_get_parent_priv(dev_get_parent(dev)); 1151 debug("\nusb_read: udev %d\n", block_dev->devnum); 1152 #else 1153 debug("\nusb_read: udev %d\n", block_dev->devnum); 1154 udev = usb_dev_desc[block_dev->devnum].priv; 1155 if (!udev) { 1156 debug("%s: No device\n", __func__); 1157 return 0; 1158 } 1159 #endif 1160 ss = (struct us_data *)udev->privptr; 1161 1162 usb_disable_asynch(1); /* asynch transfer not allowed */ 1163 srb->lun = block_dev->lun; 1164 buf_addr = (uintptr_t)buffer; 1165 start = blknr; 1166 blks = blkcnt; 1167 1168 debug("\nusb_read: dev %d startblk " LBAF ", blccnt " LBAF " buffer %" 1169 PRIxPTR "\n", block_dev->devnum, start, blks, buf_addr); 1170 1171 do { 1172 /* XXX need some comment here */ 1173 retry = 2; 1174 srb->pdata = (unsigned char *)buf_addr; 1175 if (blks > ss->max_xfer_blk) 1176 smallblks = ss->max_xfer_blk; 1177 else 1178 smallblks = (unsigned short) blks; 1179 retry_it: 1180 if (smallblks == ss->max_xfer_blk) 1181 usb_show_progress(); 1182 srb->datalen = block_dev->blksz * smallblks; 1183 srb->pdata = (unsigned char *)buf_addr; 1184 if (usb_read_10(srb, ss, start, smallblks)) { 1185 debug("Read ERROR\n"); 1186 usb_request_sense(srb, ss); 1187 if (retry--) 1188 goto retry_it; 1189 blkcnt -= blks; 1190 break; 1191 } 1192 start += smallblks; 1193 blks -= smallblks; 1194 buf_addr += srb->datalen; 1195 } while (blks != 0); 1196 ss->flags &= ~USB_READY; 1197 1198 debug("usb_read: end startblk " LBAF 1199 ", blccnt %x buffer %" PRIxPTR "\n", 1200 start, smallblks, buf_addr); 1201 1202 usb_disable_asynch(0); /* asynch transfer allowed */ 1203 if (blkcnt >= ss->max_xfer_blk) 1204 debug("\n"); 1205 return blkcnt; 1206 } 1207 1208 #ifdef CONFIG_BLK 1209 static unsigned long usb_stor_write(struct udevice *dev, lbaint_t blknr, 1210 lbaint_t blkcnt, const void *buffer) 1211 #else 1212 static unsigned long usb_stor_write(struct blk_desc *block_dev, lbaint_t blknr, 1213 lbaint_t blkcnt, const void *buffer) 1214 #endif 1215 { 1216 lbaint_t start, blks; 1217 uintptr_t buf_addr; 1218 unsigned short smallblks; 1219 struct usb_device *udev; 1220 struct us_data *ss; 1221 int retry; 1222 struct scsi_cmd *srb = &usb_ccb; 1223 #ifdef CONFIG_BLK 1224 struct blk_desc *block_dev; 1225 #endif 1226 1227 if (blkcnt == 0) 1228 return 0; 1229 1230 /* Setup device */ 1231 #ifdef CONFIG_BLK 1232 block_dev = dev_get_uclass_platdata(dev); 1233 udev = dev_get_parent_priv(dev_get_parent(dev)); 1234 debug("\nusb_read: udev %d\n", block_dev->devnum); 1235 #else 1236 debug("\nusb_read: udev %d\n", block_dev->devnum); 1237 udev = usb_dev_desc[block_dev->devnum].priv; 1238 if (!udev) { 1239 debug("%s: No device\n", __func__); 1240 return 0; 1241 } 1242 #endif 1243 ss = (struct us_data *)udev->privptr; 1244 1245 usb_disable_asynch(1); /* asynch transfer not allowed */ 1246 1247 srb->lun = block_dev->lun; 1248 buf_addr = (uintptr_t)buffer; 1249 start = blknr; 1250 blks = blkcnt; 1251 1252 debug("\nusb_write: dev %d startblk " LBAF ", blccnt " LBAF " buffer %" 1253 PRIxPTR "\n", block_dev->devnum, start, blks, buf_addr); 1254 1255 do { 1256 /* If write fails retry for max retry count else 1257 * return with number of blocks written successfully. 1258 */ 1259 retry = 2; 1260 srb->pdata = (unsigned char *)buf_addr; 1261 if (blks > ss->max_xfer_blk) 1262 smallblks = ss->max_xfer_blk; 1263 else 1264 smallblks = (unsigned short) blks; 1265 retry_it: 1266 if (smallblks == ss->max_xfer_blk) 1267 usb_show_progress(); 1268 srb->datalen = block_dev->blksz * smallblks; 1269 srb->pdata = (unsigned char *)buf_addr; 1270 if (usb_write_10(srb, ss, start, smallblks)) { 1271 debug("Write ERROR\n"); 1272 usb_request_sense(srb, ss); 1273 if (retry--) 1274 goto retry_it; 1275 blkcnt -= blks; 1276 break; 1277 } 1278 start += smallblks; 1279 blks -= smallblks; 1280 buf_addr += srb->datalen; 1281 } while (blks != 0); 1282 ss->flags &= ~USB_READY; 1283 1284 debug("usb_write: end startblk " LBAF ", blccnt %x buffer %" 1285 PRIxPTR "\n", start, smallblks, buf_addr); 1286 1287 usb_disable_asynch(0); /* asynch transfer allowed */ 1288 if (blkcnt >= ss->max_xfer_blk) 1289 debug("\n"); 1290 return blkcnt; 1291 1292 } 1293 1294 /* Probe to see if a new device is actually a Storage device */ 1295 int usb_storage_probe(struct usb_device *dev, unsigned int ifnum, 1296 struct us_data *ss) 1297 { 1298 struct usb_interface *iface; 1299 int i; 1300 struct usb_endpoint_descriptor *ep_desc; 1301 unsigned int flags = 0; 1302 1303 /* let's examine the device now */ 1304 iface = &dev->config.if_desc[ifnum]; 1305 1306 if (dev->descriptor.bDeviceClass != 0 || 1307 iface->desc.bInterfaceClass != USB_CLASS_MASS_STORAGE || 1308 iface->desc.bInterfaceSubClass < US_SC_MIN || 1309 iface->desc.bInterfaceSubClass > US_SC_MAX) { 1310 debug("Not mass storage\n"); 1311 /* if it's not a mass storage, we go no further */ 1312 return 0; 1313 } 1314 1315 memset(ss, 0, sizeof(struct us_data)); 1316 1317 /* At this point, we know we've got a live one */ 1318 debug("\n\nUSB Mass Storage device detected\n"); 1319 1320 /* Initialize the us_data structure with some useful info */ 1321 ss->flags = flags; 1322 ss->ifnum = ifnum; 1323 ss->pusb_dev = dev; 1324 ss->attention_done = 0; 1325 ss->subclass = iface->desc.bInterfaceSubClass; 1326 ss->protocol = iface->desc.bInterfaceProtocol; 1327 1328 /* set the handler pointers based on the protocol */ 1329 debug("Transport: "); 1330 switch (ss->protocol) { 1331 case US_PR_CB: 1332 debug("Control/Bulk\n"); 1333 ss->transport = usb_stor_CB_transport; 1334 ss->transport_reset = usb_stor_CB_reset; 1335 break; 1336 1337 case US_PR_CBI: 1338 debug("Control/Bulk/Interrupt\n"); 1339 ss->transport = usb_stor_CB_transport; 1340 ss->transport_reset = usb_stor_CB_reset; 1341 break; 1342 case US_PR_BULK: 1343 debug("Bulk/Bulk/Bulk\n"); 1344 ss->transport = usb_stor_BBB_transport; 1345 ss->transport_reset = usb_stor_BBB_reset; 1346 break; 1347 default: 1348 printf("USB Storage Transport unknown / not yet implemented\n"); 1349 return 0; 1350 break; 1351 } 1352 1353 /* 1354 * We are expecting a minimum of 2 endpoints - in and out (bulk). 1355 * An optional interrupt is OK (necessary for CBI protocol). 1356 * We will ignore any others. 1357 */ 1358 for (i = 0; i < iface->desc.bNumEndpoints; i++) { 1359 ep_desc = &iface->ep_desc[i]; 1360 /* is it an BULK endpoint? */ 1361 if ((ep_desc->bmAttributes & 1362 USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_BULK) { 1363 if (ep_desc->bEndpointAddress & USB_DIR_IN) 1364 ss->ep_in = ep_desc->bEndpointAddress & 1365 USB_ENDPOINT_NUMBER_MASK; 1366 else 1367 ss->ep_out = 1368 ep_desc->bEndpointAddress & 1369 USB_ENDPOINT_NUMBER_MASK; 1370 } 1371 1372 /* is it an interrupt endpoint? */ 1373 if ((ep_desc->bmAttributes & 1374 USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT) { 1375 ss->ep_int = ep_desc->bEndpointAddress & 1376 USB_ENDPOINT_NUMBER_MASK; 1377 ss->irqinterval = ep_desc->bInterval; 1378 } 1379 } 1380 debug("Endpoints In %d Out %d Int %d\n", 1381 ss->ep_in, ss->ep_out, ss->ep_int); 1382 1383 /* Do some basic sanity checks, and bail if we find a problem */ 1384 if (usb_set_interface(dev, iface->desc.bInterfaceNumber, 0) || 1385 !ss->ep_in || !ss->ep_out || 1386 (ss->protocol == US_PR_CBI && ss->ep_int == 0)) { 1387 debug("Problems with device\n"); 1388 return 0; 1389 } 1390 /* set class specific stuff */ 1391 /* We only handle certain protocols. Currently, these are 1392 * the only ones. 1393 * The SFF8070 accepts the requests used in u-boot 1394 */ 1395 if (ss->subclass != US_SC_UFI && ss->subclass != US_SC_SCSI && 1396 ss->subclass != US_SC_8070) { 1397 printf("Sorry, protocol %d not yet supported.\n", ss->subclass); 1398 return 0; 1399 } 1400 if (ss->ep_int) { 1401 /* we had found an interrupt endpoint, prepare irq pipe 1402 * set up the IRQ pipe and handler 1403 */ 1404 ss->irqinterval = (ss->irqinterval > 0) ? ss->irqinterval : 255; 1405 ss->irqpipe = usb_rcvintpipe(ss->pusb_dev, ss->ep_int); 1406 ss->irqmaxp = usb_maxpacket(dev, ss->irqpipe); 1407 dev->irq_handle = usb_stor_irq; 1408 } 1409 1410 /* Set the maximum transfer size per host controller setting */ 1411 usb_stor_set_max_xfer_blk(dev, ss); 1412 1413 dev->privptr = (void *)ss; 1414 return 1; 1415 } 1416 1417 int usb_stor_get_info(struct usb_device *dev, struct us_data *ss, 1418 struct blk_desc *dev_desc) 1419 { 1420 unsigned char perq, modi; 1421 ALLOC_CACHE_ALIGN_BUFFER(u32, cap, 2); 1422 ALLOC_CACHE_ALIGN_BUFFER(u8, usb_stor_buf, 36); 1423 u32 capacity, blksz; 1424 struct scsi_cmd *pccb = &usb_ccb; 1425 1426 pccb->pdata = usb_stor_buf; 1427 1428 dev_desc->target = dev->devnum; 1429 pccb->lun = dev_desc->lun; 1430 debug(" address %d\n", dev_desc->target); 1431 1432 if (usb_inquiry(pccb, ss)) { 1433 debug("%s: usb_inquiry() failed\n", __func__); 1434 return -1; 1435 } 1436 1437 perq = usb_stor_buf[0]; 1438 modi = usb_stor_buf[1]; 1439 1440 /* 1441 * Skip unknown devices (0x1f) and enclosure service devices (0x0d), 1442 * they would not respond to test_unit_ready . 1443 */ 1444 if (((perq & 0x1f) == 0x1f) || ((perq & 0x1f) == 0x0d)) { 1445 debug("%s: unknown/unsupported device\n", __func__); 1446 return 0; 1447 } 1448 if ((modi&0x80) == 0x80) { 1449 /* drive is removable */ 1450 dev_desc->removable = 1; 1451 } 1452 memcpy(dev_desc->vendor, (const void *)&usb_stor_buf[8], 8); 1453 memcpy(dev_desc->product, (const void *)&usb_stor_buf[16], 16); 1454 memcpy(dev_desc->revision, (const void *)&usb_stor_buf[32], 4); 1455 dev_desc->vendor[8] = 0; 1456 dev_desc->product[16] = 0; 1457 dev_desc->revision[4] = 0; 1458 #ifdef CONFIG_USB_BIN_FIXUP 1459 usb_bin_fixup(dev->descriptor, (uchar *)dev_desc->vendor, 1460 (uchar *)dev_desc->product); 1461 #endif /* CONFIG_USB_BIN_FIXUP */ 1462 debug("ISO Vers %X, Response Data %X\n", usb_stor_buf[2], 1463 usb_stor_buf[3]); 1464 if (usb_test_unit_ready(pccb, ss)) { 1465 printf("Device NOT ready\n" 1466 " Request Sense returned %02X %02X %02X\n", 1467 pccb->sense_buf[2], pccb->sense_buf[12], 1468 pccb->sense_buf[13]); 1469 if (dev_desc->removable == 1) 1470 dev_desc->type = perq; 1471 return 0; 1472 } 1473 pccb->pdata = (unsigned char *)cap; 1474 memset(pccb->pdata, 0, 8); 1475 if (usb_read_capacity(pccb, ss) != 0) { 1476 printf("READ_CAP ERROR\n"); 1477 cap[0] = 2880; 1478 cap[1] = 0x200; 1479 } 1480 ss->flags &= ~USB_READY; 1481 debug("Read Capacity returns: 0x%08x, 0x%08x\n", cap[0], cap[1]); 1482 #if 0 1483 if (cap[0] > (0x200000 * 10)) /* greater than 10 GByte */ 1484 cap[0] >>= 16; 1485 1486 cap[0] = cpu_to_be32(cap[0]); 1487 cap[1] = cpu_to_be32(cap[1]); 1488 #endif 1489 1490 capacity = be32_to_cpu(cap[0]) + 1; 1491 blksz = be32_to_cpu(cap[1]); 1492 1493 debug("Capacity = 0x%08x, blocksz = 0x%08x\n", capacity, blksz); 1494 dev_desc->lba = capacity; 1495 dev_desc->blksz = blksz; 1496 dev_desc->log2blksz = LOG2(dev_desc->blksz); 1497 dev_desc->type = perq; 1498 debug(" address %d\n", dev_desc->target); 1499 1500 return 1; 1501 } 1502 1503 #ifdef CONFIG_DM_USB 1504 1505 static int usb_mass_storage_probe(struct udevice *dev) 1506 { 1507 struct usb_device *udev = dev_get_parent_priv(dev); 1508 int ret; 1509 1510 usb_disable_asynch(1); /* asynch transfer not allowed */ 1511 ret = usb_stor_probe_device(udev); 1512 usb_disable_asynch(0); /* asynch transfer allowed */ 1513 1514 return ret; 1515 } 1516 1517 static const struct udevice_id usb_mass_storage_ids[] = { 1518 { .compatible = "usb-mass-storage" }, 1519 { } 1520 }; 1521 1522 U_BOOT_DRIVER(usb_mass_storage) = { 1523 .name = "usb_mass_storage", 1524 .id = UCLASS_MASS_STORAGE, 1525 .of_match = usb_mass_storage_ids, 1526 .probe = usb_mass_storage_probe, 1527 #ifdef CONFIG_BLK 1528 .platdata_auto_alloc_size = sizeof(struct us_data), 1529 #endif 1530 }; 1531 1532 UCLASS_DRIVER(usb_mass_storage) = { 1533 .id = UCLASS_MASS_STORAGE, 1534 .name = "usb_mass_storage", 1535 }; 1536 1537 static const struct usb_device_id mass_storage_id_table[] = { 1538 { 1539 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS, 1540 .bInterfaceClass = USB_CLASS_MASS_STORAGE 1541 }, 1542 { } /* Terminating entry */ 1543 }; 1544 1545 U_BOOT_USB_DEVICE(usb_mass_storage, mass_storage_id_table); 1546 #endif 1547 1548 #ifdef CONFIG_BLK 1549 static const struct blk_ops usb_storage_ops = { 1550 .read = usb_stor_read, 1551 .write = usb_stor_write, 1552 }; 1553 1554 U_BOOT_DRIVER(usb_storage_blk) = { 1555 .name = "usb_storage_blk", 1556 .id = UCLASS_BLK, 1557 .ops = &usb_storage_ops, 1558 }; 1559 #else 1560 U_BOOT_LEGACY_BLK(usb) = { 1561 .if_typename = "usb", 1562 .if_type = IF_TYPE_USB, 1563 .max_devs = USB_MAX_STOR_DEV, 1564 .desc = usb_dev_desc, 1565 }; 1566 #endif 1567