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