scsi.c 18 KB

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