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