scsi.c 18 KB

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