scsi.c 18 KB

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