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 400 #ifdef CONFIG_BLK 401 static ulong scsi_erase(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt) 402 { 403 ALLOC_CACHE_ALIGN_BUFFER_PAD(struct unmap_para_list, um_list, 1, ARCH_DMA_MINALIGN); 404 struct blk_desc *block_dev = dev_get_uclass_platdata(dev); 405 struct udevice *bdev = dev->parent; 406 struct scsi_cmd *pccb = (struct scsi_cmd *)&tempccb; 407 uint32_t rawsectsz = block_dev->rawblksz / block_dev->blksz; 408 409 if (rawsectsz == 1) /* The sata devices not support data erase yet. */ 410 return blkcnt; 411 412 pccb->target = block_dev->target; 413 pccb->lun = block_dev->lun; 414 pccb->datalen = 0; 415 scsi_setup_test_unit_ready(pccb); 416 if (scsi_exec(bdev, pccb)) { 417 printf("TEST UNIT READY fail!Can not erase UFS device\n"); 418 return 0; 419 } 420 421 if (blknr % rawsectsz != 0 || blkcnt % rawsectsz != 0) 422 printf("UFS erase area not aligned to %d, blknr = %lx, blkcnt = %lx\n", rawsectsz, blknr, blkcnt); 423 424 um_list->um_data_len = cpu_to_be16(sizeof(struct unmap_para_list) - 2); 425 um_list->um_block_desc_len = cpu_to_be16(sizeof(struct um_block_descriptor)); 426 if (8 == sizeof(lbaint_t)) 427 um_list->ub_desc.um_block_addr = cpu_to_be64(blknr / rawsectsz); 428 else 429 um_list->ub_desc.um_block_addr = cpu_to_be64((uint64_t)blknr / rawsectsz); 430 um_list->ub_desc.um_block_sz = cpu_to_be32((uint32_t)blkcnt / rawsectsz); 431 432 pccb->pdata = (void *)um_list; 433 pccb->datalen = 24; 434 pccb->dma_dir = DMA_TO_DEVICE; 435 memset(pccb->cmd, 0, 10); 436 pccb->cmd[0] = SCSI_UNMAP; 437 pccb->cmd[8] = 24; 438 pccb->cmdlen = 10; 439 440 if (scsi_exec(bdev, pccb)) { 441 printf("erase UFS device error.\n"); 442 return 0; 443 } 444 445 return blkcnt; 446 } 447 #endif 448 449 #if defined(CONFIG_PCI) && !defined(CONFIG_SCSI_AHCI_PLAT) && \ 450 !defined(CONFIG_DM_SCSI) 451 void scsi_init(void) 452 { 453 int busdevfunc = -1; 454 int i; 455 /* 456 * Find a device from the list, this driver will support a single 457 * controller. 458 */ 459 for (i = 0; i < ARRAY_SIZE(scsi_device_list); i++) { 460 /* get PCI Device ID */ 461 #ifdef CONFIG_DM_PCI 462 struct udevice *dev; 463 int ret; 464 465 ret = dm_pci_find_device(scsi_device_list[i].vendor, 466 scsi_device_list[i].device, 0, &dev); 467 if (!ret) { 468 busdevfunc = dm_pci_get_bdf(dev); 469 break; 470 } 471 #else 472 busdevfunc = pci_find_device(scsi_device_list[i].vendor, 473 scsi_device_list[i].device, 474 0); 475 #endif 476 if (busdevfunc != -1) 477 break; 478 } 479 480 if (busdevfunc == -1) { 481 printf("Error: SCSI Controller(s) "); 482 for (i = 0; i < ARRAY_SIZE(scsi_device_list); i++) { 483 printf("%04X:%04X ", 484 scsi_device_list[i].vendor, 485 scsi_device_list[i].device); 486 } 487 printf("not found\n"); 488 return; 489 } 490 #ifdef DEBUG 491 else { 492 printf("SCSI Controller (%04X,%04X) found (%d:%d:%d)\n", 493 scsi_device_list[i].vendor, 494 scsi_device_list[i].device, 495 (busdevfunc >> 16) & 0xFF, 496 (busdevfunc >> 11) & 0x1F, 497 (busdevfunc >> 8) & 0x7); 498 } 499 #endif 500 bootstage_start(BOOTSTAGE_ID_ACCUM_SCSI, "ahci"); 501 scsi_low_level_init(busdevfunc); 502 scsi_scan(true); 503 bootstage_accum(BOOTSTAGE_ID_ACCUM_SCSI); 504 } 505 #endif 506 507 /* copy src to dest, skipping leading and trailing blanks 508 * and null terminate the string 509 */ 510 static void scsi_ident_cpy(unsigned char *dest, unsigned char *src, 511 unsigned int len) 512 { 513 int start, end; 514 515 start = 0; 516 while (start < len) { 517 if (src[start] != ' ') 518 break; 519 start++; 520 } 521 end = len-1; 522 while (end > start) { 523 if (src[end] != ' ') 524 break; 525 end--; 526 } 527 for (; start <= end; start++) 528 *dest ++= src[start]; 529 *dest = '\0'; 530 } 531 532 static int scsi_read_capacity(struct udevice *dev, struct scsi_cmd *pccb, 533 lbaint_t *capacity, unsigned long *blksz) 534 { 535 *capacity = 0; 536 537 memset(pccb->cmd, '\0', sizeof(pccb->cmd)); 538 pccb->cmd[0] = SCSI_RD_CAPAC10; 539 pccb->cmd[1] = pccb->lun << 5; 540 pccb->cmdlen = 10; 541 pccb->msgout[0] = SCSI_IDENTIFY; /* NOT USED */ 542 543 pccb->datalen = 8; 544 if (scsi_exec(dev, pccb)) 545 return 1; 546 547 *capacity = ((lbaint_t)pccb->pdata[0] << 24) | 548 ((lbaint_t)pccb->pdata[1] << 16) | 549 ((lbaint_t)pccb->pdata[2] << 8) | 550 ((lbaint_t)pccb->pdata[3]); 551 552 if (*capacity != 0xffffffff) { 553 /* Read capacity (10) was sufficient for this drive. */ 554 *blksz = ((unsigned long)pccb->pdata[4] << 24) | 555 ((unsigned long)pccb->pdata[5] << 16) | 556 ((unsigned long)pccb->pdata[6] << 8) | 557 ((unsigned long)pccb->pdata[7]); 558 return 0; 559 } 560 561 /* Read capacity (10) was insufficient. Use read capacity (16). */ 562 memset(pccb->cmd, '\0', sizeof(pccb->cmd)); 563 pccb->cmd[0] = SCSI_RD_CAPAC16; 564 pccb->cmd[1] = 0x10; 565 pccb->cmdlen = 16; 566 pccb->msgout[0] = SCSI_IDENTIFY; /* NOT USED */ 567 568 pccb->datalen = 16; 569 pccb->dma_dir = DMA_FROM_DEVICE; 570 if (scsi_exec(dev, pccb)) 571 return 1; 572 573 *capacity = ((uint64_t)pccb->pdata[0] << 56) | 574 ((uint64_t)pccb->pdata[1] << 48) | 575 ((uint64_t)pccb->pdata[2] << 40) | 576 ((uint64_t)pccb->pdata[3] << 32) | 577 ((uint64_t)pccb->pdata[4] << 24) | 578 ((uint64_t)pccb->pdata[5] << 16) | 579 ((uint64_t)pccb->pdata[6] << 8) | 580 ((uint64_t)pccb->pdata[7]); 581 582 *blksz = ((uint64_t)pccb->pdata[8] << 56) | 583 ((uint64_t)pccb->pdata[9] << 48) | 584 ((uint64_t)pccb->pdata[10] << 40) | 585 ((uint64_t)pccb->pdata[11] << 32) | 586 ((uint64_t)pccb->pdata[12] << 24) | 587 ((uint64_t)pccb->pdata[13] << 16) | 588 ((uint64_t)pccb->pdata[14] << 8) | 589 ((uint64_t)pccb->pdata[15]); 590 591 return 0; 592 } 593 594 /** 595 * scsi_init_dev_desc_priv - initialize only SCSI specific blk_desc properties 596 * 597 * @dev_desc: Block device description pointer 598 */ 599 static void scsi_init_dev_desc_priv(struct blk_desc *dev_desc) 600 { 601 dev_desc->target = 0xff; 602 dev_desc->lun = 0xff; 603 dev_desc->log2blksz = 604 LOG2_INVALID(typeof(dev_desc->log2blksz)); 605 dev_desc->type = DEV_TYPE_UNKNOWN; 606 dev_desc->vendor[0] = 0; 607 dev_desc->product[0] = 0; 608 dev_desc->revision[0] = 0; 609 dev_desc->removable = false; 610 #if !CONFIG_IS_ENABLED(BLK) 611 dev_desc->block_read = scsi_read; 612 dev_desc->block_write = scsi_write; 613 #endif 614 } 615 616 #if !defined(CONFIG_DM_SCSI) 617 /** 618 * scsi_init_dev_desc - initialize all SCSI specific blk_desc properties 619 * 620 * @dev_desc: Block device description pointer 621 * @devnum: Device number 622 */ 623 static void scsi_init_dev_desc(struct blk_desc *dev_desc, int devnum) 624 { 625 dev_desc->lba = 0; 626 dev_desc->blksz = 0; 627 dev_desc->if_type = IF_TYPE_SCSI; 628 dev_desc->devnum = devnum; 629 dev_desc->part_type = PART_TYPE_UNKNOWN; 630 631 scsi_init_dev_desc_priv(dev_desc); 632 } 633 #endif 634 635 /** 636 * scsi_detect_dev - Detect scsi device 637 * 638 * @target: target id 639 * @lun: target lun 640 * @dev_desc: block device description 641 * 642 * The scsi_detect_dev detects and fills a dev_desc structure when the device is 643 * detected. 644 * 645 * Return: 0 on success, error value otherwise 646 */ 647 static int scsi_detect_dev(struct udevice *dev, int target, int lun, 648 struct blk_desc *dev_desc) 649 { 650 unsigned char perq, modi; 651 lbaint_t capacity; 652 unsigned long blksz; 653 struct scsi_cmd *pccb = (struct scsi_cmd *)&tempccb; 654 655 pccb->target = target; 656 pccb->lun = lun; 657 pccb->pdata = (unsigned char *)&tempbuff; 658 pccb->datalen = SCSI_STD_INQUIRY_BYTES; 659 pccb->dma_dir = DMA_FROM_DEVICE; 660 scsi_setup_inquiry(pccb); 661 if (scsi_exec(dev, pccb)) { 662 if (pccb->contr_stat == SCSI_SEL_TIME_OUT) { 663 /* 664 * selection timeout => assuming no 665 * device present 666 */ 667 debug("Selection timeout ID %d\n", 668 pccb->target); 669 return -ETIMEDOUT; 670 } 671 scsi_print_error(pccb); 672 return -ENODEV; 673 } 674 perq = tempbuff[0]; 675 modi = tempbuff[1]; 676 if ((perq & 0x1f) == 0x1f) 677 return -ENODEV; /* skip unknown devices */ 678 if ((modi & 0x80) == 0x80) /* drive is removable */ 679 dev_desc->removable = true; 680 /* get info for this device */ 681 scsi_ident_cpy((unsigned char *)dev_desc->vendor, 682 &tempbuff[8], 8); 683 scsi_ident_cpy((unsigned char *)dev_desc->product, 684 &tempbuff[16], 16); 685 scsi_ident_cpy((unsigned char *)dev_desc->revision, 686 &tempbuff[32], 4); 687 dev_desc->target = pccb->target; 688 dev_desc->lun = pccb->lun; 689 690 pccb->datalen = 0; 691 scsi_setup_test_unit_ready(pccb); 692 if (scsi_exec(dev, pccb)) { 693 if (dev_desc->removable) { 694 dev_desc->type = perq; 695 goto removable; 696 } 697 scsi_print_error(pccb); 698 return -EINVAL; 699 } 700 if (scsi_read_capacity(dev, pccb, &capacity, &blksz)) { 701 scsi_print_error(pccb); 702 return -EINVAL; 703 } 704 705 dev_desc->lba = capacity; 706 dev_desc->blksz = blksz; 707 dev_desc->log2blksz = LOG2(dev_desc->blksz); 708 dev_desc->type = perq; 709 removable: 710 return 0; 711 } 712 713 /* 714 * (re)-scan the scsi bus and reports scsi device info 715 * to the user if mode = 1 716 */ 717 #if defined(CONFIG_DM_SCSI) 718 static int do_scsi_scan_one(struct udevice *dev, int id, int lun, bool verbose) 719 { 720 int ret; 721 struct udevice *bdev; 722 struct blk_desc bd; 723 struct blk_desc *bdesc; 724 char str[10]; 725 726 /* 727 * detect the scsi driver to get information about its geometry (block 728 * size, number of blocks) and other parameters (ids, type, ...) 729 */ 730 scsi_init_dev_desc_priv(&bd); 731 if (scsi_detect_dev(dev, id, lun, &bd)) 732 return -ENODEV; 733 734 /* 735 * Create only one block device and do detection 736 * to make sure that there won't be a lot of 737 * block devices created 738 */ 739 snprintf(str, sizeof(str), "id%dlun%d", id, lun); 740 ret = blk_create_devicef(dev, "scsi_blk", str, IF_TYPE_SCSI, -1, 741 bd.blksz, bd.blksz * bd.lba, &bdev); 742 if (ret) { 743 debug("Can't create device\n"); 744 return ret; 745 } 746 747 bdesc = dev_get_uclass_platdata(bdev); 748 bdesc->target = id; 749 bdesc->lun = lun; 750 bdesc->removable = bd.removable; 751 bdesc->type = bd.type; 752 753 if (bdesc->rawblksz == 4096) { 754 bdesc->blksz = 512; 755 bdesc->rawlba++; /* add 1 sector for ufs */ 756 bdesc->lba = bdesc->rawlba * 8; 757 bdesc->align_sector_buf = memalign(CONFIG_SYS_CACHELINE_SIZE, bdesc->rawblksz); 758 } 759 760 memcpy(&bdesc->vendor, &bd.vendor, sizeof(bd.vendor)); 761 memcpy(&bdesc->product, &bd.product, sizeof(bd.product)); 762 memcpy(&bdesc->revision, &bd.revision, sizeof(bd.revision)); 763 part_init(bdesc); 764 765 if (verbose) { 766 printf(" Device %d: ", 0); 767 dev_print(bdesc); 768 } 769 return 0; 770 } 771 772 int scsi_scan_dev(struct udevice *dev, bool verbose) 773 { 774 struct scsi_platdata *uc_plat; /* scsi controller platdata */ 775 int ret; 776 int i; 777 int lun; 778 779 /* probe SCSI controller driver */ 780 ret = device_probe(dev); 781 if (ret) 782 return ret; 783 784 /* Get controller platdata */ 785 uc_plat = dev_get_uclass_platdata(dev); 786 787 for (i = 0; i < uc_plat->max_id; i++) 788 for (lun = 0; lun < uc_plat->max_lun; lun++) 789 do_scsi_scan_one(dev, i, lun, verbose); 790 791 return 0; 792 } 793 794 int scsi_scan(bool verbose) 795 { 796 struct uclass *uc; 797 struct udevice *dev; /* SCSI controller */ 798 int ret; 799 800 if (verbose) 801 printf("scanning bus for devices...\n"); 802 803 blk_unbind_all(IF_TYPE_SCSI); 804 805 ret = uclass_get(UCLASS_SCSI, &uc); 806 if (ret) 807 return ret; 808 809 uclass_foreach_dev(dev, uc) { 810 ret = scsi_scan_dev(dev, verbose); 811 if (ret) 812 return ret; 813 } 814 815 return 0; 816 } 817 #else 818 int scsi_scan(bool verbose) 819 { 820 unsigned char i, lun; 821 int ret; 822 823 if (verbose) 824 printf("scanning bus for devices...\n"); 825 for (i = 0; i < CONFIG_SYS_SCSI_MAX_DEVICE; i++) 826 scsi_init_dev_desc(&scsi_dev_desc[i], i); 827 828 scsi_max_devs = 0; 829 for (i = 0; i < CONFIG_SYS_SCSI_MAX_SCSI_ID; i++) { 830 for (lun = 0; lun < CONFIG_SYS_SCSI_MAX_LUN; lun++) { 831 ret = scsi_detect_dev(NULL, i, lun, 832 &scsi_dev_desc[scsi_max_devs]); 833 if (ret) 834 continue; 835 part_init(&scsi_dev_desc[scsi_max_devs]); 836 837 if (verbose) { 838 printf(" Device %d: ", 0); 839 dev_print(&scsi_dev_desc[scsi_max_devs]); 840 } 841 scsi_max_devs++; 842 } /* next LUN */ 843 } 844 if (scsi_max_devs > 0) 845 scsi_curr_dev = 0; 846 else 847 scsi_curr_dev = -1; 848 849 printf("Found %d device(s).\n", scsi_max_devs); 850 #ifndef CONFIG_SPL_BUILD 851 env_set_ulong("scsidevs", scsi_max_devs); 852 #endif 853 return 0; 854 } 855 #endif 856 857 #ifdef CONFIG_BLK 858 static const struct blk_ops scsi_blk_ops = { 859 .read = scsi_read, 860 .write = scsi_write, 861 .erase = scsi_erase, 862 }; 863 864 U_BOOT_DRIVER(scsi_blk) = { 865 .name = "scsi_blk", 866 .id = UCLASS_BLK, 867 .ops = &scsi_blk_ops, 868 }; 869 #else 870 U_BOOT_LEGACY_BLK(scsi) = { 871 .if_typename = "scsi", 872 .if_type = IF_TYPE_SCSI, 873 .max_devs = CONFIG_SYS_SCSI_MAX_DEVICE, 874 .desc = scsi_dev_desc, 875 }; 876 #endif 877