1 /* 2 * (C) Copyright 2001 3 * Denis Peter, MPL AG Switzerland 4 * 5 * SPDX-License-Identifier: GPL-2.0+ 6 */ 7 8 #include <common.h> 9 #include <dm.h> 10 #include <inttypes.h> 11 #include <pci.h> 12 #include <scsi.h> 13 #include <dm/device-internal.h> 14 #include <dm/uclass-internal.h> 15 16 #if !defined(CONFIG_DM_SCSI) 17 # ifdef CONFIG_SCSI_DEV_LIST 18 # define SCSI_DEV_LIST CONFIG_SCSI_DEV_LIST 19 # else 20 # ifdef CONFIG_SATA_ULI5288 21 22 # define SCSI_VEND_ID 0x10b9 23 # define SCSI_DEV_ID 0x5288 24 25 # elif !defined(CONFIG_SCSI_AHCI_PLAT) 26 # error no scsi device defined 27 # endif 28 # define SCSI_DEV_LIST {SCSI_VEND_ID, SCSI_DEV_ID} 29 # endif 30 #endif 31 32 #if defined(CONFIG_PCI) && !defined(CONFIG_SCSI_AHCI_PLAT) && \ 33 !defined(CONFIG_DM_SCSI) 34 const struct pci_device_id scsi_device_list[] = { SCSI_DEV_LIST }; 35 #endif 36 static struct scsi_cmd tempccb; /* temporary scsi command buffer */ 37 38 static unsigned char tempbuff[512]; /* temporary data buffer */ 39 40 #if !defined(CONFIG_DM_SCSI) 41 static int scsi_max_devs; /* number of highest available scsi device */ 42 43 static int scsi_curr_dev; /* current device */ 44 45 static struct blk_desc scsi_dev_desc[CONFIG_SYS_SCSI_MAX_DEVICE]; 46 #endif 47 48 /* almost the maximum amount of the scsi_ext command.. */ 49 #define SCSI_MAX_READ_BLK 0xFFFF 50 #define SCSI_LBA48_READ 0xFFFFFFF 51 52 static void scsi_print_error(struct scsi_cmd *pccb) 53 { 54 /* Dummy function that could print an error for debugging */ 55 } 56 57 #ifdef CONFIG_SYS_64BIT_LBA 58 void scsi_setup_read16(struct scsi_cmd *pccb, lbaint_t start, 59 unsigned long blocks) 60 { 61 pccb->cmd[0] = SCSI_READ16; 62 pccb->cmd[1] = pccb->lun << 5; 63 pccb->cmd[2] = (unsigned char)(start >> 56) & 0xff; 64 pccb->cmd[3] = (unsigned char)(start >> 48) & 0xff; 65 pccb->cmd[4] = (unsigned char)(start >> 40) & 0xff; 66 pccb->cmd[5] = (unsigned char)(start >> 32) & 0xff; 67 pccb->cmd[6] = (unsigned char)(start >> 24) & 0xff; 68 pccb->cmd[7] = (unsigned char)(start >> 16) & 0xff; 69 pccb->cmd[8] = (unsigned char)(start >> 8) & 0xff; 70 pccb->cmd[9] = (unsigned char)start & 0xff; 71 pccb->cmd[10] = 0; 72 pccb->cmd[11] = (unsigned char)(blocks >> 24) & 0xff; 73 pccb->cmd[12] = (unsigned char)(blocks >> 16) & 0xff; 74 pccb->cmd[13] = (unsigned char)(blocks >> 8) & 0xff; 75 pccb->cmd[14] = (unsigned char)blocks & 0xff; 76 pccb->cmd[15] = 0; 77 pccb->cmdlen = 16; 78 pccb->msgout[0] = SCSI_IDENTIFY; /* NOT USED */ 79 debug("scsi_setup_read16: cmd: %02X %02X startblk %02X%02X%02X%02X%02X%02X%02X%02X blccnt %02X%02X%02X%02X\n", 80 pccb->cmd[0], pccb->cmd[1], 81 pccb->cmd[2], pccb->cmd[3], pccb->cmd[4], pccb->cmd[5], 82 pccb->cmd[6], pccb->cmd[7], pccb->cmd[8], pccb->cmd[9], 83 pccb->cmd[11], pccb->cmd[12], pccb->cmd[13], pccb->cmd[14]); 84 } 85 #endif 86 87 static void scsi_setup_read_ext(struct scsi_cmd *pccb, lbaint_t start, 88 unsigned short blocks) 89 { 90 pccb->cmd[0] = SCSI_READ10; 91 pccb->cmd[1] = pccb->lun << 5; 92 pccb->cmd[2] = (unsigned char)(start >> 24) & 0xff; 93 pccb->cmd[3] = (unsigned char)(start >> 16) & 0xff; 94 pccb->cmd[4] = (unsigned char)(start >> 8) & 0xff; 95 pccb->cmd[5] = (unsigned char)start & 0xff; 96 pccb->cmd[6] = 0; 97 pccb->cmd[7] = (unsigned char)(blocks >> 8) & 0xff; 98 pccb->cmd[8] = (unsigned char)blocks & 0xff; 99 pccb->cmd[6] = 0; 100 pccb->cmdlen = 10; 101 pccb->msgout[0] = SCSI_IDENTIFY; /* NOT USED */ 102 debug("scsi_setup_read_ext: cmd: %02X %02X startblk %02X%02X%02X%02X blccnt %02X%02X\n", 103 pccb->cmd[0], pccb->cmd[1], 104 pccb->cmd[2], pccb->cmd[3], pccb->cmd[4], pccb->cmd[5], 105 pccb->cmd[7], pccb->cmd[8]); 106 } 107 108 static void scsi_setup_write_ext(struct scsi_cmd *pccb, lbaint_t start, 109 unsigned short blocks) 110 { 111 pccb->cmd[0] = SCSI_WRITE10; 112 pccb->cmd[1] = pccb->lun << 5; 113 pccb->cmd[2] = (unsigned char)(start >> 24) & 0xff; 114 pccb->cmd[3] = (unsigned char)(start >> 16) & 0xff; 115 pccb->cmd[4] = (unsigned char)(start >> 8) & 0xff; 116 pccb->cmd[5] = (unsigned char)start & 0xff; 117 pccb->cmd[6] = 0; 118 pccb->cmd[7] = ((unsigned char)(blocks >> 8)) & 0xff; 119 pccb->cmd[8] = (unsigned char)blocks & 0xff; 120 pccb->cmd[9] = 0; 121 pccb->cmdlen = 10; 122 pccb->msgout[0] = SCSI_IDENTIFY; /* NOT USED */ 123 debug("%s: cmd: %02X %02X startblk %02X%02X%02X%02X blccnt %02X%02X\n", 124 __func__, 125 pccb->cmd[0], pccb->cmd[1], 126 pccb->cmd[2], pccb->cmd[3], pccb->cmd[4], pccb->cmd[5], 127 pccb->cmd[7], pccb->cmd[8]); 128 } 129 130 static void scsi_setup_inquiry(struct scsi_cmd *pccb) 131 { 132 pccb->cmd[0] = SCSI_INQUIRY; 133 pccb->cmd[1] = pccb->lun << 5; 134 pccb->cmd[2] = 0; 135 pccb->cmd[3] = 0; 136 if (pccb->datalen > 255) 137 pccb->cmd[4] = 255; 138 else 139 pccb->cmd[4] = (unsigned char)pccb->datalen; 140 pccb->cmd[5] = 0; 141 pccb->cmdlen = 6; 142 pccb->msgout[0] = SCSI_IDENTIFY; /* NOT USED */ 143 } 144 145 #ifdef CONFIG_BLK 146 static ulong scsi_read(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt, 147 void *buffer) 148 #else 149 static ulong scsi_read(struct blk_desc *block_dev, lbaint_t blknr, 150 lbaint_t blkcnt, void *buffer) 151 #endif 152 { 153 #ifdef CONFIG_BLK 154 struct blk_desc *block_dev = dev_get_uclass_platdata(dev); 155 struct udevice *bdev = dev->parent; 156 #else 157 struct udevice *bdev = NULL; 158 #endif 159 lbaint_t start, blks; 160 uintptr_t buf_addr; 161 unsigned short smallblks = 0; 162 struct scsi_cmd *pccb = (struct scsi_cmd *)&tempccb; 163 164 /* Setup device */ 165 pccb->target = block_dev->target; 166 pccb->lun = block_dev->lun; 167 buf_addr = (unsigned long)buffer; 168 start = blknr; 169 blks = blkcnt; 170 debug("\nscsi_read: dev %d startblk " LBAF 171 ", blccnt " LBAF " buffer %lx\n", 172 block_dev->devnum, start, blks, (unsigned long)buffer); 173 do { 174 pccb->pdata = (unsigned char *)buf_addr; 175 pccb->dma_dir = DMA_FROM_DEVICE; 176 #ifdef CONFIG_SYS_64BIT_LBA 177 if (start > SCSI_LBA48_READ) { 178 unsigned long blocks; 179 blocks = min_t(lbaint_t, blks, SCSI_MAX_READ_BLK); 180 pccb->datalen = block_dev->blksz * blocks; 181 scsi_setup_read16(pccb, start, blocks); 182 start += blocks; 183 blks -= blocks; 184 } else 185 #endif 186 if (blks > SCSI_MAX_READ_BLK) { 187 pccb->datalen = block_dev->blksz * 188 SCSI_MAX_READ_BLK; 189 smallblks = SCSI_MAX_READ_BLK; 190 scsi_setup_read_ext(pccb, start, smallblks); 191 start += SCSI_MAX_READ_BLK; 192 blks -= SCSI_MAX_READ_BLK; 193 } else { 194 pccb->datalen = block_dev->blksz * blks; 195 smallblks = (unsigned short)blks; 196 scsi_setup_read_ext(pccb, start, smallblks); 197 start += blks; 198 blks = 0; 199 } 200 debug("scsi_read_ext: startblk " LBAF 201 ", blccnt %x buffer %" PRIXPTR "\n", 202 start, smallblks, buf_addr); 203 if (scsi_exec(bdev, pccb)) { 204 scsi_print_error(pccb); 205 blkcnt -= blks; 206 break; 207 } 208 buf_addr += pccb->datalen; 209 } while (blks != 0); 210 debug("scsi_read_ext: end startblk " LBAF 211 ", blccnt %x buffer %" PRIXPTR "\n", start, smallblks, buf_addr); 212 return blkcnt; 213 } 214 215 /******************************************************************************* 216 * scsi_write 217 */ 218 219 /* Almost the maximum amount of the scsi_ext command.. */ 220 #define SCSI_MAX_WRITE_BLK 0xFFFF 221 222 #ifdef CONFIG_BLK 223 static ulong scsi_write(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt, 224 const void *buffer) 225 #else 226 static ulong scsi_write(struct blk_desc *block_dev, lbaint_t blknr, 227 lbaint_t blkcnt, const void *buffer) 228 #endif 229 { 230 #ifdef CONFIG_BLK 231 struct blk_desc *block_dev = dev_get_uclass_platdata(dev); 232 struct udevice *bdev = dev->parent; 233 #else 234 struct udevice *bdev = NULL; 235 #endif 236 lbaint_t start, blks; 237 uintptr_t buf_addr; 238 unsigned short smallblks; 239 struct scsi_cmd *pccb = (struct scsi_cmd *)&tempccb; 240 241 /* Setup device */ 242 pccb->target = block_dev->target; 243 pccb->lun = block_dev->lun; 244 buf_addr = (unsigned long)buffer; 245 start = blknr; 246 blks = blkcnt; 247 debug("\n%s: dev %d startblk " LBAF ", blccnt " LBAF " buffer %lx\n", 248 __func__, block_dev->devnum, start, blks, (unsigned long)buffer); 249 do { 250 pccb->pdata = (unsigned char *)buf_addr; 251 pccb->dma_dir = DMA_TO_DEVICE; 252 if (blks > SCSI_MAX_WRITE_BLK) { 253 pccb->datalen = (block_dev->blksz * 254 SCSI_MAX_WRITE_BLK); 255 smallblks = SCSI_MAX_WRITE_BLK; 256 scsi_setup_write_ext(pccb, start, smallblks); 257 start += SCSI_MAX_WRITE_BLK; 258 blks -= SCSI_MAX_WRITE_BLK; 259 } else { 260 pccb->datalen = block_dev->blksz * blks; 261 smallblks = (unsigned short)blks; 262 scsi_setup_write_ext(pccb, start, smallblks); 263 start += blks; 264 blks = 0; 265 } 266 debug("%s: startblk " LBAF ", blccnt %x buffer %" PRIXPTR "\n", 267 __func__, start, smallblks, buf_addr); 268 if (scsi_exec(bdev, pccb)) { 269 scsi_print_error(pccb); 270 blkcnt -= blks; 271 break; 272 } 273 buf_addr += pccb->datalen; 274 } while (blks != 0); 275 debug("%s: end startblk " LBAF ", blccnt %x buffer %" PRIXPTR "\n", 276 __func__, start, smallblks, buf_addr); 277 return blkcnt; 278 } 279 280 #if defined(CONFIG_PCI) && !defined(CONFIG_SCSI_AHCI_PLAT) && \ 281 !defined(CONFIG_DM_SCSI) 282 void scsi_init(void) 283 { 284 int busdevfunc = -1; 285 int i; 286 /* 287 * Find a device from the list, this driver will support a single 288 * controller. 289 */ 290 for (i = 0; i < ARRAY_SIZE(scsi_device_list); i++) { 291 /* get PCI Device ID */ 292 #ifdef CONFIG_DM_PCI 293 struct udevice *dev; 294 int ret; 295 296 ret = dm_pci_find_device(scsi_device_list[i].vendor, 297 scsi_device_list[i].device, 0, &dev); 298 if (!ret) { 299 busdevfunc = dm_pci_get_bdf(dev); 300 break; 301 } 302 #else 303 busdevfunc = pci_find_device(scsi_device_list[i].vendor, 304 scsi_device_list[i].device, 305 0); 306 #endif 307 if (busdevfunc != -1) 308 break; 309 } 310 311 if (busdevfunc == -1) { 312 printf("Error: SCSI Controller(s) "); 313 for (i = 0; i < ARRAY_SIZE(scsi_device_list); i++) { 314 printf("%04X:%04X ", 315 scsi_device_list[i].vendor, 316 scsi_device_list[i].device); 317 } 318 printf("not found\n"); 319 return; 320 } 321 #ifdef DEBUG 322 else { 323 printf("SCSI Controller (%04X,%04X) found (%d:%d:%d)\n", 324 scsi_device_list[i].vendor, 325 scsi_device_list[i].device, 326 (busdevfunc >> 16) & 0xFF, 327 (busdevfunc >> 11) & 0x1F, 328 (busdevfunc >> 8) & 0x7); 329 } 330 #endif 331 bootstage_start(BOOTSTAGE_ID_ACCUM_SCSI, "ahci"); 332 scsi_low_level_init(busdevfunc); 333 scsi_scan(true); 334 bootstage_accum(BOOTSTAGE_ID_ACCUM_SCSI); 335 } 336 #endif 337 338 /* copy src to dest, skipping leading and trailing blanks 339 * and null terminate the string 340 */ 341 static void scsi_ident_cpy(unsigned char *dest, unsigned char *src, 342 unsigned int len) 343 { 344 int start, end; 345 346 start = 0; 347 while (start < len) { 348 if (src[start] != ' ') 349 break; 350 start++; 351 } 352 end = len-1; 353 while (end > start) { 354 if (src[end] != ' ') 355 break; 356 end--; 357 } 358 for (; start <= end; start++) 359 *dest ++= src[start]; 360 *dest = '\0'; 361 } 362 363 static int scsi_read_capacity(struct udevice *dev, struct scsi_cmd *pccb, 364 lbaint_t *capacity, unsigned long *blksz) 365 { 366 *capacity = 0; 367 368 memset(pccb->cmd, '\0', sizeof(pccb->cmd)); 369 pccb->cmd[0] = SCSI_RD_CAPAC10; 370 pccb->cmd[1] = pccb->lun << 5; 371 pccb->cmdlen = 10; 372 pccb->msgout[0] = SCSI_IDENTIFY; /* NOT USED */ 373 374 pccb->datalen = 8; 375 if (scsi_exec(dev, pccb)) 376 return 1; 377 378 *capacity = ((lbaint_t)pccb->pdata[0] << 24) | 379 ((lbaint_t)pccb->pdata[1] << 16) | 380 ((lbaint_t)pccb->pdata[2] << 8) | 381 ((lbaint_t)pccb->pdata[3]); 382 383 if (*capacity != 0xffffffff) { 384 /* Read capacity (10) was sufficient for this drive. */ 385 *blksz = ((unsigned long)pccb->pdata[4] << 24) | 386 ((unsigned long)pccb->pdata[5] << 16) | 387 ((unsigned long)pccb->pdata[6] << 8) | 388 ((unsigned long)pccb->pdata[7]); 389 return 0; 390 } 391 392 /* Read capacity (10) was insufficient. Use read capacity (16). */ 393 memset(pccb->cmd, '\0', sizeof(pccb->cmd)); 394 pccb->cmd[0] = SCSI_RD_CAPAC16; 395 pccb->cmd[1] = 0x10; 396 pccb->cmdlen = 16; 397 pccb->msgout[0] = SCSI_IDENTIFY; /* NOT USED */ 398 399 pccb->datalen = 16; 400 pccb->dma_dir = DMA_FROM_DEVICE; 401 if (scsi_exec(dev, pccb)) 402 return 1; 403 404 *capacity = ((uint64_t)pccb->pdata[0] << 56) | 405 ((uint64_t)pccb->pdata[1] << 48) | 406 ((uint64_t)pccb->pdata[2] << 40) | 407 ((uint64_t)pccb->pdata[3] << 32) | 408 ((uint64_t)pccb->pdata[4] << 24) | 409 ((uint64_t)pccb->pdata[5] << 16) | 410 ((uint64_t)pccb->pdata[6] << 8) | 411 ((uint64_t)pccb->pdata[7]); 412 413 *blksz = ((uint64_t)pccb->pdata[8] << 56) | 414 ((uint64_t)pccb->pdata[9] << 48) | 415 ((uint64_t)pccb->pdata[10] << 40) | 416 ((uint64_t)pccb->pdata[11] << 32) | 417 ((uint64_t)pccb->pdata[12] << 24) | 418 ((uint64_t)pccb->pdata[13] << 16) | 419 ((uint64_t)pccb->pdata[14] << 8) | 420 ((uint64_t)pccb->pdata[15]); 421 422 return 0; 423 } 424 425 426 /* 427 * Some setup (fill-in) routines 428 */ 429 static void scsi_setup_test_unit_ready(struct scsi_cmd *pccb) 430 { 431 pccb->cmd[0] = SCSI_TST_U_RDY; 432 pccb->cmd[1] = pccb->lun << 5; 433 pccb->cmd[2] = 0; 434 pccb->cmd[3] = 0; 435 pccb->cmd[4] = 0; 436 pccb->cmd[5] = 0; 437 pccb->cmdlen = 6; 438 pccb->msgout[0] = SCSI_IDENTIFY; /* NOT USED */ 439 } 440 441 /** 442 * scsi_init_dev_desc_priv - initialize only SCSI specific blk_desc properties 443 * 444 * @dev_desc: Block device description pointer 445 */ 446 static void scsi_init_dev_desc_priv(struct blk_desc *dev_desc) 447 { 448 dev_desc->target = 0xff; 449 dev_desc->lun = 0xff; 450 dev_desc->log2blksz = 451 LOG2_INVALID(typeof(dev_desc->log2blksz)); 452 dev_desc->type = DEV_TYPE_UNKNOWN; 453 dev_desc->vendor[0] = 0; 454 dev_desc->product[0] = 0; 455 dev_desc->revision[0] = 0; 456 dev_desc->removable = false; 457 #if !CONFIG_IS_ENABLED(BLK) 458 dev_desc->block_read = scsi_read; 459 dev_desc->block_write = scsi_write; 460 #endif 461 } 462 463 #if !defined(CONFIG_DM_SCSI) 464 /** 465 * scsi_init_dev_desc - initialize all SCSI specific blk_desc properties 466 * 467 * @dev_desc: Block device description pointer 468 * @devnum: Device number 469 */ 470 static void scsi_init_dev_desc(struct blk_desc *dev_desc, int devnum) 471 { 472 dev_desc->lba = 0; 473 dev_desc->blksz = 0; 474 dev_desc->if_type = IF_TYPE_SCSI; 475 dev_desc->devnum = devnum; 476 dev_desc->part_type = PART_TYPE_UNKNOWN; 477 478 scsi_init_dev_desc_priv(dev_desc); 479 } 480 #endif 481 482 /** 483 * scsi_detect_dev - Detect scsi device 484 * 485 * @target: target id 486 * @lun: target lun 487 * @dev_desc: block device description 488 * 489 * The scsi_detect_dev detects and fills a dev_desc structure when the device is 490 * detected. 491 * 492 * Return: 0 on success, error value otherwise 493 */ 494 static int scsi_detect_dev(struct udevice *dev, int target, int lun, 495 struct blk_desc *dev_desc) 496 { 497 unsigned char perq, modi; 498 lbaint_t capacity; 499 unsigned long blksz; 500 struct scsi_cmd *pccb = (struct scsi_cmd *)&tempccb; 501 502 pccb->target = target; 503 pccb->lun = lun; 504 pccb->pdata = (unsigned char *)&tempbuff; 505 pccb->datalen = 512; 506 pccb->dma_dir = DMA_FROM_DEVICE; 507 scsi_setup_inquiry(pccb); 508 if (scsi_exec(dev, pccb)) { 509 if (pccb->contr_stat == SCSI_SEL_TIME_OUT) { 510 /* 511 * selection timeout => assuming no 512 * device present 513 */ 514 debug("Selection timeout ID %d\n", 515 pccb->target); 516 return -ETIMEDOUT; 517 } 518 scsi_print_error(pccb); 519 return -ENODEV; 520 } 521 perq = tempbuff[0]; 522 modi = tempbuff[1]; 523 if ((perq & 0x1f) == 0x1f) 524 return -ENODEV; /* skip unknown devices */ 525 if ((modi & 0x80) == 0x80) /* drive is removable */ 526 dev_desc->removable = true; 527 /* get info for this device */ 528 scsi_ident_cpy((unsigned char *)dev_desc->vendor, 529 &tempbuff[8], 8); 530 scsi_ident_cpy((unsigned char *)dev_desc->product, 531 &tempbuff[16], 16); 532 scsi_ident_cpy((unsigned char *)dev_desc->revision, 533 &tempbuff[32], 4); 534 dev_desc->target = pccb->target; 535 dev_desc->lun = pccb->lun; 536 537 pccb->datalen = 0; 538 scsi_setup_test_unit_ready(pccb); 539 if (scsi_exec(dev, pccb)) { 540 if (dev_desc->removable) { 541 dev_desc->type = perq; 542 goto removable; 543 } 544 scsi_print_error(pccb); 545 return -EINVAL; 546 } 547 if (scsi_read_capacity(dev, pccb, &capacity, &blksz)) { 548 scsi_print_error(pccb); 549 return -EINVAL; 550 } 551 dev_desc->lba = capacity; 552 dev_desc->blksz = blksz; 553 dev_desc->log2blksz = LOG2(dev_desc->blksz); 554 dev_desc->type = perq; 555 removable: 556 return 0; 557 } 558 559 /* 560 * (re)-scan the scsi bus and reports scsi device info 561 * to the user if mode = 1 562 */ 563 #if defined(CONFIG_DM_SCSI) 564 static int do_scsi_scan_one(struct udevice *dev, int id, int lun, bool verbose) 565 { 566 int ret; 567 struct udevice *bdev; 568 struct blk_desc bd; 569 struct blk_desc *bdesc; 570 char str[10]; 571 572 /* 573 * detect the scsi driver to get information about its geometry (block 574 * size, number of blocks) and other parameters (ids, type, ...) 575 */ 576 scsi_init_dev_desc_priv(&bd); 577 if (scsi_detect_dev(dev, id, lun, &bd)) 578 return -ENODEV; 579 580 /* 581 * Create only one block device and do detection 582 * to make sure that there won't be a lot of 583 * block devices created 584 */ 585 snprintf(str, sizeof(str), "id%dlun%d", id, lun); 586 ret = blk_create_devicef(dev, "scsi_blk", str, IF_TYPE_SCSI, -1, 587 bd.blksz, bd.blksz * bd.lba, &bdev); 588 if (ret) { 589 debug("Can't create device\n"); 590 return ret; 591 } 592 593 bdesc = dev_get_uclass_platdata(bdev); 594 bdesc->target = id; 595 bdesc->lun = lun; 596 bdesc->removable = bd.removable; 597 bdesc->type = bd.type; 598 memcpy(&bdesc->vendor, &bd.vendor, sizeof(bd.vendor)); 599 memcpy(&bdesc->product, &bd.product, sizeof(bd.product)); 600 memcpy(&bdesc->revision, &bd.revision, sizeof(bd.revision)); 601 part_init(bdesc); 602 603 if (verbose) { 604 printf(" Device %d: ", 0); 605 dev_print(bdesc); 606 } 607 return 0; 608 } 609 610 int scsi_scan_dev(struct udevice *dev, bool verbose) 611 { 612 struct scsi_platdata *uc_plat; /* scsi controller platdata */ 613 int ret; 614 int i; 615 int lun; 616 617 /* probe SCSI controller driver */ 618 ret = device_probe(dev); 619 if (ret) 620 return ret; 621 622 /* Get controller platdata */ 623 uc_plat = dev_get_uclass_platdata(dev); 624 625 for (i = 0; i < uc_plat->max_id; i++) 626 for (lun = 0; lun < uc_plat->max_lun; lun++) 627 do_scsi_scan_one(dev, i, lun, verbose); 628 629 return 0; 630 } 631 632 int scsi_scan(bool verbose) 633 { 634 struct uclass *uc; 635 struct udevice *dev; /* SCSI controller */ 636 int ret; 637 638 if (verbose) 639 printf("scanning bus for devices...\n"); 640 641 blk_unbind_all(IF_TYPE_SCSI); 642 643 ret = uclass_get(UCLASS_SCSI, &uc); 644 if (ret) 645 return ret; 646 647 uclass_foreach_dev(dev, uc) { 648 ret = scsi_scan_dev(dev, verbose); 649 if (ret) 650 return ret; 651 } 652 653 return 0; 654 } 655 #else 656 int scsi_scan(bool verbose) 657 { 658 unsigned char i, lun; 659 int ret; 660 661 if (verbose) 662 printf("scanning bus for devices...\n"); 663 for (i = 0; i < CONFIG_SYS_SCSI_MAX_DEVICE; i++) 664 scsi_init_dev_desc(&scsi_dev_desc[i], i); 665 666 scsi_max_devs = 0; 667 for (i = 0; i < CONFIG_SYS_SCSI_MAX_SCSI_ID; i++) { 668 for (lun = 0; lun < CONFIG_SYS_SCSI_MAX_LUN; lun++) { 669 ret = scsi_detect_dev(NULL, i, lun, 670 &scsi_dev_desc[scsi_max_devs]); 671 if (ret) 672 continue; 673 part_init(&scsi_dev_desc[scsi_max_devs]); 674 675 if (verbose) { 676 printf(" Device %d: ", 0); 677 dev_print(&scsi_dev_desc[scsi_max_devs]); 678 } 679 scsi_max_devs++; 680 } /* next LUN */ 681 } 682 if (scsi_max_devs > 0) 683 scsi_curr_dev = 0; 684 else 685 scsi_curr_dev = -1; 686 687 printf("Found %d device(s).\n", scsi_max_devs); 688 #ifndef CONFIG_SPL_BUILD 689 env_set_ulong("scsidevs", scsi_max_devs); 690 #endif 691 return 0; 692 } 693 #endif 694 695 #ifdef CONFIG_BLK 696 static const struct blk_ops scsi_blk_ops = { 697 .read = scsi_read, 698 .write = scsi_write, 699 }; 700 701 U_BOOT_DRIVER(scsi_blk) = { 702 .name = "scsi_blk", 703 .id = UCLASS_BLK, 704 .ops = &scsi_blk_ops, 705 }; 706 #else 707 U_BOOT_LEGACY_BLK(scsi) = { 708 .if_typename = "scsi", 709 .if_type = IF_TYPE_SCSI, 710 .max_devs = CONFIG_SYS_SCSI_MAX_DEVICE, 711 .desc = scsi_dev_desc, 712 }; 713 #endif 714