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 | 0x8; 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->rawblksz * 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->rawblksz * SCSI_MAX_READ_BLK; 188 smallblks = SCSI_MAX_READ_BLK; 189 scsi_setup_read_ext(pccb, start, smallblks); 190 start += SCSI_MAX_READ_BLK; 191 blks -= SCSI_MAX_READ_BLK; 192 } else { 193 pccb->datalen = block_dev->rawblksz * blks; 194 smallblks = (unsigned short)blks; 195 scsi_setup_read_ext(pccb, start, smallblks); 196 start += blks; 197 blks = 0; 198 } 199 debug("scsi_read_ext: startblk " LBAF 200 ", blccnt %x buffer %" PRIXPTR "\n", 201 start, smallblks, buf_addr); 202 if (scsi_exec(bdev, pccb)) { 203 scsi_print_error(pccb); 204 blkcnt -= blks; 205 break; 206 } 207 buf_addr += pccb->datalen; 208 } while (blks != 0); 209 debug("scsi_read_ext: end startblk " LBAF 210 ", blccnt %x buffer %" PRIXPTR "\n", start, smallblks, buf_addr); 211 return blkcnt; 212 } 213 214 #ifdef CONFIG_BLK 215 static ulong scsi_read(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt, 216 void *buffer) 217 #else 218 static ulong scsi_read(struct blk_desc *block_dev, lbaint_t blknr, 219 lbaint_t blkcnt, void *buffer) 220 #endif 221 { 222 #ifdef CONFIG_BLK 223 struct blk_desc *block_dev = dev_get_uclass_platdata(dev); 224 uint32_t rawsectsz = block_dev->rawblksz / 512; 225 long ret = blkcnt; 226 227 if (rawsectsz == 8) { 228 if ((blknr & (rawsectsz - 1)) || (blkcnt & (rawsectsz - 1))) { 229 uint32_t offset, n_sec, num_lpa; 230 long lpa; 231 232 while (blkcnt) { 233 lpa = blknr / rawsectsz; 234 offset = blknr & (rawsectsz - 1); 235 n_sec = rawsectsz - offset; 236 if (n_sec > blkcnt) 237 n_sec = blkcnt; 238 239 if (offset || n_sec < rawsectsz) { 240 _scsi_read(dev, lpa, 1, block_dev->align_sector_buf); 241 memcpy(buffer, block_dev->align_sector_buf + offset * 512, n_sec * 512); 242 } else { 243 num_lpa = blkcnt / rawsectsz; 244 n_sec = num_lpa * rawsectsz; 245 _scsi_read(dev, lpa, num_lpa, buffer); 246 } 247 blkcnt -= n_sec; 248 blknr += n_sec; 249 buffer += 512 * n_sec; 250 } 251 252 return ret; 253 } 254 blknr /= rawsectsz; 255 blkcnt /= rawsectsz; 256 _scsi_read(dev, blknr, blkcnt, buffer); 257 258 return ret; 259 } 260 261 return _scsi_read(dev, blknr, blkcnt, buffer); 262 #else 263 return _scsi_read(block_dev, blknr, blkcnt, buffer); 264 #endif 265 } 266 /******************************************************************************* 267 * scsi_write 268 */ 269 270 /* Almost the maximum amount of the scsi_ext command.. */ 271 #define SCSI_MAX_WRITE_BLK 0xFFFF 272 273 #ifdef CONFIG_BLK 274 static ulong _scsi_write(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt, 275 const void *buffer) 276 #else 277 static ulong _scsi_write(struct blk_desc *block_dev, lbaint_t blknr, 278 lbaint_t blkcnt, const void *buffer) 279 #endif 280 { 281 #ifdef CONFIG_BLK 282 struct blk_desc *block_dev = dev_get_uclass_platdata(dev); 283 struct udevice *bdev = dev->parent; 284 #else 285 struct udevice *bdev = NULL; 286 #endif 287 lbaint_t start, blks; 288 uintptr_t buf_addr; 289 unsigned short smallblks; 290 struct scsi_cmd *pccb = (struct scsi_cmd *)&tempccb; 291 292 /* Setup device */ 293 pccb->target = block_dev->target; 294 pccb->lun = block_dev->lun; 295 buf_addr = (unsigned long)buffer; 296 start = blknr; 297 blks = blkcnt; 298 debug("\n%s: dev %d startblk " LBAF ", blccnt " LBAF " buffer %lx\n", 299 __func__, block_dev->devnum, start, blks, (unsigned long)buffer); 300 do { 301 pccb->pdata = (unsigned char *)buf_addr; 302 pccb->dma_dir = DMA_TO_DEVICE; 303 if (blks > SCSI_MAX_WRITE_BLK) { 304 pccb->datalen = (block_dev->rawblksz * SCSI_MAX_WRITE_BLK); 305 smallblks = SCSI_MAX_WRITE_BLK; 306 scsi_setup_write_ext(pccb, start, smallblks); 307 start += SCSI_MAX_WRITE_BLK; 308 blks -= SCSI_MAX_WRITE_BLK; 309 } else { 310 pccb->datalen = block_dev->rawblksz * blks; 311 smallblks = (unsigned short)blks; 312 scsi_setup_write_ext(pccb, start, smallblks); 313 start += blks; 314 blks = 0; 315 } 316 debug("%s: startblk " LBAF ", blccnt %x buffer %" PRIXPTR "\n", 317 __func__, start, smallblks, buf_addr); 318 if (scsi_exec(bdev, pccb)) { 319 scsi_print_error(pccb); 320 blkcnt -= blks; 321 break; 322 } 323 buf_addr += pccb->datalen; 324 } while (blks != 0); 325 debug("%s: end startblk " LBAF ", blccnt %x buffer %" PRIXPTR "\n", 326 __func__, start, smallblks, buf_addr); 327 return blkcnt; 328 } 329 330 #ifdef CONFIG_BLK 331 static ulong scsi_write(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt, 332 const void *buffer) 333 #else 334 static ulong scsi_write(struct blk_desc *block_dev, lbaint_t blknr, 335 lbaint_t blkcnt, const void *buffer) 336 #endif 337 { 338 #ifdef CONFIG_BLK 339 struct blk_desc *block_dev = dev_get_uclass_platdata(dev); 340 uint32_t rawsectsz = block_dev->rawblksz / 512; 341 long ret = blkcnt; 342 343 if (rawsectsz == 8) { 344 if ((blknr & (rawsectsz - 1)) || (blkcnt & (rawsectsz - 1))) { 345 uint32_t num_lpa, offset, n_sec; 346 long lpa; 347 348 while (blkcnt) { 349 lpa = blknr / rawsectsz; 350 offset = blknr & (rawsectsz - 1); 351 n_sec = rawsectsz - offset; 352 if (n_sec > blkcnt) 353 n_sec = blkcnt; 354 if (offset || n_sec < rawsectsz) { 355 _scsi_read(dev, lpa, 1, block_dev->align_sector_buf); 356 memcpy(block_dev->align_sector_buf + offset * 512, buffer, n_sec * 512); 357 _scsi_write(dev, lpa, 1, block_dev->align_sector_buf); 358 } else { 359 num_lpa = blkcnt / rawsectsz; 360 n_sec = num_lpa * rawsectsz; 361 _scsi_write(dev, lpa, num_lpa, buffer); 362 } 363 blkcnt -= n_sec; 364 blknr += n_sec; 365 buffer += 512 * n_sec; 366 } 367 368 return ret; 369 } 370 blknr /= rawsectsz; 371 blkcnt /= rawsectsz; 372 _scsi_write(dev, blknr, blkcnt, buffer); 373 374 return ret; 375 } 376 377 return _scsi_write(dev, blknr, blkcnt, buffer); 378 #else 379 return _scsi_write(block_dev, blknr, blkcnt, buffer); 380 #endif 381 382 } 383 384 #if defined(CONFIG_PCI) && !defined(CONFIG_SCSI_AHCI_PLAT) && \ 385 !defined(CONFIG_DM_SCSI) 386 void scsi_init(void) 387 { 388 int busdevfunc = -1; 389 int i; 390 /* 391 * Find a device from the list, this driver will support a single 392 * controller. 393 */ 394 for (i = 0; i < ARRAY_SIZE(scsi_device_list); i++) { 395 /* get PCI Device ID */ 396 #ifdef CONFIG_DM_PCI 397 struct udevice *dev; 398 int ret; 399 400 ret = dm_pci_find_device(scsi_device_list[i].vendor, 401 scsi_device_list[i].device, 0, &dev); 402 if (!ret) { 403 busdevfunc = dm_pci_get_bdf(dev); 404 break; 405 } 406 #else 407 busdevfunc = pci_find_device(scsi_device_list[i].vendor, 408 scsi_device_list[i].device, 409 0); 410 #endif 411 if (busdevfunc != -1) 412 break; 413 } 414 415 if (busdevfunc == -1) { 416 printf("Error: SCSI Controller(s) "); 417 for (i = 0; i < ARRAY_SIZE(scsi_device_list); i++) { 418 printf("%04X:%04X ", 419 scsi_device_list[i].vendor, 420 scsi_device_list[i].device); 421 } 422 printf("not found\n"); 423 return; 424 } 425 #ifdef DEBUG 426 else { 427 printf("SCSI Controller (%04X,%04X) found (%d:%d:%d)\n", 428 scsi_device_list[i].vendor, 429 scsi_device_list[i].device, 430 (busdevfunc >> 16) & 0xFF, 431 (busdevfunc >> 11) & 0x1F, 432 (busdevfunc >> 8) & 0x7); 433 } 434 #endif 435 bootstage_start(BOOTSTAGE_ID_ACCUM_SCSI, "ahci"); 436 scsi_low_level_init(busdevfunc); 437 scsi_scan(true); 438 bootstage_accum(BOOTSTAGE_ID_ACCUM_SCSI); 439 } 440 #endif 441 442 /* copy src to dest, skipping leading and trailing blanks 443 * and null terminate the string 444 */ 445 static void scsi_ident_cpy(unsigned char *dest, unsigned char *src, 446 unsigned int len) 447 { 448 int start, end; 449 450 start = 0; 451 while (start < len) { 452 if (src[start] != ' ') 453 break; 454 start++; 455 } 456 end = len-1; 457 while (end > start) { 458 if (src[end] != ' ') 459 break; 460 end--; 461 } 462 for (; start <= end; start++) 463 *dest ++= src[start]; 464 *dest = '\0'; 465 } 466 467 static int scsi_read_capacity(struct udevice *dev, struct scsi_cmd *pccb, 468 lbaint_t *capacity, unsigned long *blksz) 469 { 470 *capacity = 0; 471 472 memset(pccb->cmd, '\0', sizeof(pccb->cmd)); 473 pccb->cmd[0] = SCSI_RD_CAPAC10; 474 pccb->cmd[1] = pccb->lun << 5; 475 pccb->cmdlen = 10; 476 pccb->msgout[0] = SCSI_IDENTIFY; /* NOT USED */ 477 478 pccb->datalen = 8; 479 if (scsi_exec(dev, pccb)) 480 return 1; 481 482 *capacity = ((lbaint_t)pccb->pdata[0] << 24) | 483 ((lbaint_t)pccb->pdata[1] << 16) | 484 ((lbaint_t)pccb->pdata[2] << 8) | 485 ((lbaint_t)pccb->pdata[3]); 486 487 if (*capacity != 0xffffffff) { 488 /* Read capacity (10) was sufficient for this drive. */ 489 *blksz = ((unsigned long)pccb->pdata[4] << 24) | 490 ((unsigned long)pccb->pdata[5] << 16) | 491 ((unsigned long)pccb->pdata[6] << 8) | 492 ((unsigned long)pccb->pdata[7]); 493 *capacity = *capacity + 1; 494 return 0; 495 } 496 497 /* Read capacity (10) was insufficient. Use read capacity (16). */ 498 memset(pccb->cmd, '\0', sizeof(pccb->cmd)); 499 pccb->cmd[0] = SCSI_RD_CAPAC16; 500 pccb->cmd[1] = 0x10; 501 pccb->cmdlen = 16; 502 pccb->msgout[0] = SCSI_IDENTIFY; /* NOT USED */ 503 504 pccb->datalen = 16; 505 pccb->dma_dir = DMA_FROM_DEVICE; 506 if (scsi_exec(dev, pccb)) 507 return 1; 508 509 *capacity = ((uint64_t)pccb->pdata[0] << 56) | 510 ((uint64_t)pccb->pdata[1] << 48) | 511 ((uint64_t)pccb->pdata[2] << 40) | 512 ((uint64_t)pccb->pdata[3] << 32) | 513 ((uint64_t)pccb->pdata[4] << 24) | 514 ((uint64_t)pccb->pdata[5] << 16) | 515 ((uint64_t)pccb->pdata[6] << 8) | 516 ((uint64_t)pccb->pdata[7]); 517 *capacity = *capacity + 1; 518 519 *blksz = ((uint64_t)pccb->pdata[8] << 56) | 520 ((uint64_t)pccb->pdata[9] << 48) | 521 ((uint64_t)pccb->pdata[10] << 40) | 522 ((uint64_t)pccb->pdata[11] << 32) | 523 ((uint64_t)pccb->pdata[12] << 24) | 524 ((uint64_t)pccb->pdata[13] << 16) | 525 ((uint64_t)pccb->pdata[14] << 8) | 526 ((uint64_t)pccb->pdata[15]); 527 528 return 0; 529 } 530 531 532 /* 533 * Some setup (fill-in) routines 534 */ 535 static void scsi_setup_test_unit_ready(struct scsi_cmd *pccb) 536 { 537 pccb->cmd[0] = SCSI_TST_U_RDY; 538 pccb->cmd[1] = pccb->lun << 5; 539 pccb->cmd[2] = 0; 540 pccb->cmd[3] = 0; 541 pccb->cmd[4] = 0; 542 pccb->cmd[5] = 0; 543 pccb->cmdlen = 6; 544 pccb->msgout[0] = SCSI_IDENTIFY; /* NOT USED */ 545 } 546 547 /** 548 * scsi_init_dev_desc_priv - initialize only SCSI specific blk_desc properties 549 * 550 * @dev_desc: Block device description pointer 551 */ 552 static void scsi_init_dev_desc_priv(struct blk_desc *dev_desc) 553 { 554 dev_desc->target = 0xff; 555 dev_desc->lun = 0xff; 556 dev_desc->log2blksz = 557 LOG2_INVALID(typeof(dev_desc->log2blksz)); 558 dev_desc->type = DEV_TYPE_UNKNOWN; 559 dev_desc->vendor[0] = 0; 560 dev_desc->product[0] = 0; 561 dev_desc->revision[0] = 0; 562 dev_desc->removable = false; 563 #if !CONFIG_IS_ENABLED(BLK) 564 dev_desc->block_read = scsi_read; 565 dev_desc->block_write = scsi_write; 566 #endif 567 } 568 569 #if !defined(CONFIG_DM_SCSI) 570 /** 571 * scsi_init_dev_desc - initialize all SCSI specific blk_desc properties 572 * 573 * @dev_desc: Block device description pointer 574 * @devnum: Device number 575 */ 576 static void scsi_init_dev_desc(struct blk_desc *dev_desc, int devnum) 577 { 578 dev_desc->lba = 0; 579 dev_desc->blksz = 0; 580 dev_desc->if_type = IF_TYPE_SCSI; 581 dev_desc->devnum = devnum; 582 dev_desc->part_type = PART_TYPE_UNKNOWN; 583 584 scsi_init_dev_desc_priv(dev_desc); 585 } 586 #endif 587 588 /** 589 * scsi_detect_dev - Detect scsi device 590 * 591 * @target: target id 592 * @lun: target lun 593 * @dev_desc: block device description 594 * 595 * The scsi_detect_dev detects and fills a dev_desc structure when the device is 596 * detected. 597 * 598 * Return: 0 on success, error value otherwise 599 */ 600 static int scsi_detect_dev(struct udevice *dev, int target, int lun, 601 struct blk_desc *dev_desc) 602 { 603 unsigned char perq, modi; 604 lbaint_t capacity; 605 unsigned long blksz; 606 struct scsi_cmd *pccb = (struct scsi_cmd *)&tempccb; 607 608 pccb->target = target; 609 pccb->lun = lun; 610 pccb->pdata = (unsigned char *)&tempbuff; 611 pccb->datalen = 512; 612 pccb->dma_dir = DMA_FROM_DEVICE; 613 scsi_setup_inquiry(pccb); 614 if (scsi_exec(dev, pccb)) { 615 if (pccb->contr_stat == SCSI_SEL_TIME_OUT) { 616 /* 617 * selection timeout => assuming no 618 * device present 619 */ 620 debug("Selection timeout ID %d\n", 621 pccb->target); 622 return -ETIMEDOUT; 623 } 624 scsi_print_error(pccb); 625 return -ENODEV; 626 } 627 perq = tempbuff[0]; 628 modi = tempbuff[1]; 629 if ((perq & 0x1f) == 0x1f) 630 return -ENODEV; /* skip unknown devices */ 631 if ((modi & 0x80) == 0x80) /* drive is removable */ 632 dev_desc->removable = true; 633 /* get info for this device */ 634 scsi_ident_cpy((unsigned char *)dev_desc->vendor, 635 &tempbuff[8], 8); 636 scsi_ident_cpy((unsigned char *)dev_desc->product, 637 &tempbuff[16], 16); 638 scsi_ident_cpy((unsigned char *)dev_desc->revision, 639 &tempbuff[32], 4); 640 dev_desc->target = pccb->target; 641 dev_desc->lun = pccb->lun; 642 643 pccb->datalen = 0; 644 scsi_setup_test_unit_ready(pccb); 645 if (scsi_exec(dev, pccb)) { 646 if (dev_desc->removable) { 647 dev_desc->type = perq; 648 goto removable; 649 } 650 scsi_print_error(pccb); 651 return -EINVAL; 652 } 653 if (scsi_read_capacity(dev, pccb, &capacity, &blksz)) { 654 scsi_print_error(pccb); 655 return -EINVAL; 656 } 657 658 dev_desc->lba = capacity; 659 dev_desc->blksz = blksz; 660 dev_desc->log2blksz = LOG2(dev_desc->blksz); 661 dev_desc->type = perq; 662 removable: 663 return 0; 664 } 665 666 /* 667 * (re)-scan the scsi bus and reports scsi device info 668 * to the user if mode = 1 669 */ 670 #if defined(CONFIG_DM_SCSI) 671 static int do_scsi_scan_one(struct udevice *dev, int id, int lun, bool verbose) 672 { 673 int ret; 674 struct udevice *bdev; 675 struct blk_desc bd; 676 struct blk_desc *bdesc; 677 char str[10]; 678 679 /* 680 * detect the scsi driver to get information about its geometry (block 681 * size, number of blocks) and other parameters (ids, type, ...) 682 */ 683 scsi_init_dev_desc_priv(&bd); 684 if (scsi_detect_dev(dev, id, lun, &bd)) 685 return -ENODEV; 686 687 /* 688 * Create only one block device and do detection 689 * to make sure that there won't be a lot of 690 * block devices created 691 */ 692 snprintf(str, sizeof(str), "id%dlun%d", id, lun); 693 ret = blk_create_devicef(dev, "scsi_blk", str, IF_TYPE_SCSI, -1, 694 bd.blksz, bd.blksz * bd.lba, &bdev); 695 if (ret) { 696 debug("Can't create device\n"); 697 return ret; 698 } 699 700 bdesc = dev_get_uclass_platdata(bdev); 701 bdesc->target = id; 702 bdesc->lun = lun; 703 bdesc->removable = bd.removable; 704 bdesc->type = bd.type; 705 706 if (bdesc->rawblksz == 4096) { 707 bdesc->blksz = 512; 708 bdesc->lba = bdesc->rawlba * 8; 709 bdesc->align_sector_buf = memalign(CONFIG_SYS_CACHELINE_SIZE, bdesc->rawblksz); 710 } 711 712 memcpy(&bdesc->vendor, &bd.vendor, sizeof(bd.vendor)); 713 memcpy(&bdesc->product, &bd.product, sizeof(bd.product)); 714 memcpy(&bdesc->revision, &bd.revision, sizeof(bd.revision)); 715 part_init(bdesc); 716 717 if (verbose) { 718 printf(" Device %d: ", 0); 719 dev_print(bdesc); 720 } 721 return 0; 722 } 723 724 int scsi_scan_dev(struct udevice *dev, bool verbose) 725 { 726 struct scsi_platdata *uc_plat; /* scsi controller platdata */ 727 int ret; 728 int i; 729 int lun; 730 731 /* probe SCSI controller driver */ 732 ret = device_probe(dev); 733 if (ret) 734 return ret; 735 736 /* Get controller platdata */ 737 uc_plat = dev_get_uclass_platdata(dev); 738 739 for (i = 0; i < uc_plat->max_id; i++) 740 for (lun = 0; lun < uc_plat->max_lun; lun++) 741 do_scsi_scan_one(dev, i, lun, verbose); 742 743 return 0; 744 } 745 746 int scsi_scan(bool verbose) 747 { 748 struct uclass *uc; 749 struct udevice *dev; /* SCSI controller */ 750 int ret; 751 752 if (verbose) 753 printf("scanning bus for devices...\n"); 754 755 blk_unbind_all(IF_TYPE_SCSI); 756 757 ret = uclass_get(UCLASS_SCSI, &uc); 758 if (ret) 759 return ret; 760 761 uclass_foreach_dev(dev, uc) { 762 ret = scsi_scan_dev(dev, verbose); 763 if (ret) 764 return ret; 765 } 766 767 return 0; 768 } 769 #else 770 int scsi_scan(bool verbose) 771 { 772 unsigned char i, lun; 773 int ret; 774 775 if (verbose) 776 printf("scanning bus for devices...\n"); 777 for (i = 0; i < CONFIG_SYS_SCSI_MAX_DEVICE; i++) 778 scsi_init_dev_desc(&scsi_dev_desc[i], i); 779 780 scsi_max_devs = 0; 781 for (i = 0; i < CONFIG_SYS_SCSI_MAX_SCSI_ID; i++) { 782 for (lun = 0; lun < CONFIG_SYS_SCSI_MAX_LUN; lun++) { 783 ret = scsi_detect_dev(NULL, i, lun, 784 &scsi_dev_desc[scsi_max_devs]); 785 if (ret) 786 continue; 787 part_init(&scsi_dev_desc[scsi_max_devs]); 788 789 if (verbose) { 790 printf(" Device %d: ", 0); 791 dev_print(&scsi_dev_desc[scsi_max_devs]); 792 } 793 scsi_max_devs++; 794 } /* next LUN */ 795 } 796 if (scsi_max_devs > 0) 797 scsi_curr_dev = 0; 798 else 799 scsi_curr_dev = -1; 800 801 printf("Found %d device(s).\n", scsi_max_devs); 802 #ifndef CONFIG_SPL_BUILD 803 env_set_ulong("scsidevs", scsi_max_devs); 804 #endif 805 return 0; 806 } 807 #endif 808 809 #ifdef CONFIG_BLK 810 static const struct blk_ops scsi_blk_ops = { 811 .read = scsi_read, 812 .write = scsi_write, 813 }; 814 815 U_BOOT_DRIVER(scsi_blk) = { 816 .name = "scsi_blk", 817 .id = UCLASS_BLK, 818 .ops = &scsi_blk_ops, 819 }; 820 #else 821 U_BOOT_LEGACY_BLK(scsi) = { 822 .if_typename = "scsi", 823 .if_type = IF_TYPE_SCSI, 824 .max_devs = CONFIG_SYS_SCSI_MAX_DEVICE, 825 .desc = scsi_dev_desc, 826 }; 827 #endif 828