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