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