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