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 <dm.h>
  8. #include <pci.h>
  9. #include <scsi.h>
  10. #include <dm/device-internal.h>
  11. #include <dm/uclass-internal.h>
  12. #if !defined(CONFIG_DM_SCSI)
  13. # ifdef CONFIG_SCSI_DEV_LIST
  14. # define SCSI_DEV_LIST CONFIG_SCSI_DEV_LIST
  15. # else
  16. # ifdef CONFIG_SATA_ULI5288
  17. # define SCSI_VEND_ID 0x10b9
  18. # define SCSI_DEV_ID 0x5288
  19. # elif !defined(CONFIG_SCSI_AHCI_PLAT)
  20. # error no scsi device defined
  21. # endif
  22. # define SCSI_DEV_LIST {SCSI_VEND_ID, SCSI_DEV_ID}
  23. # endif
  24. #endif
  25. #if defined(CONFIG_PCI) && !defined(CONFIG_SCSI_AHCI_PLAT) && \
  26. !defined(CONFIG_DM_SCSI)
  27. const struct pci_device_id scsi_device_list[] = { SCSI_DEV_LIST };
  28. #endif
  29. static struct scsi_cmd tempccb; /* temporary scsi command buffer */
  30. static unsigned char tempbuff[512]; /* temporary data buffer */
  31. #if !defined(CONFIG_DM_SCSI)
  32. static int scsi_max_devs; /* number of highest available scsi device */
  33. static int scsi_curr_dev; /* current device */
  34. static struct blk_desc scsi_dev_desc[CONFIG_SYS_SCSI_MAX_DEVICE];
  35. #endif
  36. /* almost the maximum amount of the scsi_ext command.. */
  37. #define SCSI_MAX_READ_BLK 0xFFFF
  38. #define SCSI_LBA48_READ 0xFFFFFFF
  39. static void scsi_print_error(struct scsi_cmd *pccb)
  40. {
  41. /* Dummy function that could print an error for debugging */
  42. }
  43. #ifdef CONFIG_SYS_64BIT_LBA
  44. void scsi_setup_read16(struct scsi_cmd *pccb, lbaint_t start,
  45. unsigned long blocks)
  46. {
  47. pccb->cmd[0] = SCSI_READ16;
  48. pccb->cmd[1] = pccb->lun << 5;
  49. pccb->cmd[2] = (unsigned char)(start >> 56) & 0xff;
  50. pccb->cmd[3] = (unsigned char)(start >> 48) & 0xff;
  51. pccb->cmd[4] = (unsigned char)(start >> 40) & 0xff;
  52. pccb->cmd[5] = (unsigned char)(start >> 32) & 0xff;
  53. pccb->cmd[6] = (unsigned char)(start >> 24) & 0xff;
  54. pccb->cmd[7] = (unsigned char)(start >> 16) & 0xff;
  55. pccb->cmd[8] = (unsigned char)(start >> 8) & 0xff;
  56. pccb->cmd[9] = (unsigned char)start & 0xff;
  57. pccb->cmd[10] = 0;
  58. pccb->cmd[11] = (unsigned char)(blocks >> 24) & 0xff;
  59. pccb->cmd[12] = (unsigned char)(blocks >> 16) & 0xff;
  60. pccb->cmd[13] = (unsigned char)(blocks >> 8) & 0xff;
  61. pccb->cmd[14] = (unsigned char)blocks & 0xff;
  62. pccb->cmd[15] = 0;
  63. pccb->cmdlen = 16;
  64. pccb->msgout[0] = SCSI_IDENTIFY; /* NOT USED */
  65. debug("scsi_setup_read16: cmd: %02X %02X startblk %02X%02X%02X%02X%02X%02X%02X%02X blccnt %02X%02X%02X%02X\n",
  66. pccb->cmd[0], pccb->cmd[1],
  67. pccb->cmd[2], pccb->cmd[3], pccb->cmd[4], pccb->cmd[5],
  68. pccb->cmd[6], pccb->cmd[7], pccb->cmd[8], pccb->cmd[9],
  69. pccb->cmd[11], pccb->cmd[12], pccb->cmd[13], pccb->cmd[14]);
  70. }
  71. #endif
  72. static void scsi_setup_read_ext(struct scsi_cmd *pccb, lbaint_t start,
  73. unsigned short blocks)
  74. {
  75. pccb->cmd[0] = SCSI_READ10;
  76. pccb->cmd[1] = pccb->lun << 5;
  77. pccb->cmd[2] = (unsigned char)(start >> 24) & 0xff;
  78. pccb->cmd[3] = (unsigned char)(start >> 16) & 0xff;
  79. pccb->cmd[4] = (unsigned char)(start >> 8) & 0xff;
  80. pccb->cmd[5] = (unsigned char)start & 0xff;
  81. pccb->cmd[6] = 0;
  82. pccb->cmd[7] = (unsigned char)(blocks >> 8) & 0xff;
  83. pccb->cmd[8] = (unsigned char)blocks & 0xff;
  84. pccb->cmd[6] = 0;
  85. pccb->cmdlen = 10;
  86. pccb->msgout[0] = SCSI_IDENTIFY; /* NOT USED */
  87. debug("scsi_setup_read_ext: cmd: %02X %02X startblk %02X%02X%02X%02X blccnt %02X%02X\n",
  88. pccb->cmd[0], pccb->cmd[1],
  89. pccb->cmd[2], pccb->cmd[3], pccb->cmd[4], pccb->cmd[5],
  90. pccb->cmd[7], pccb->cmd[8]);
  91. }
  92. static void scsi_setup_write_ext(struct scsi_cmd *pccb, lbaint_t start,
  93. unsigned short blocks)
  94. {
  95. pccb->cmd[0] = SCSI_WRITE10;
  96. pccb->cmd[1] = pccb->lun << 5;
  97. pccb->cmd[2] = (unsigned char)(start >> 24) & 0xff;
  98. pccb->cmd[3] = (unsigned char)(start >> 16) & 0xff;
  99. pccb->cmd[4] = (unsigned char)(start >> 8) & 0xff;
  100. pccb->cmd[5] = (unsigned char)start & 0xff;
  101. pccb->cmd[6] = 0;
  102. pccb->cmd[7] = ((unsigned char)(blocks >> 8)) & 0xff;
  103. pccb->cmd[8] = (unsigned char)blocks & 0xff;
  104. pccb->cmd[9] = 0;
  105. pccb->cmdlen = 10;
  106. pccb->msgout[0] = SCSI_IDENTIFY; /* NOT USED */
  107. debug("%s: cmd: %02X %02X startblk %02X%02X%02X%02X blccnt %02X%02X\n",
  108. __func__,
  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_inquiry(struct scsi_cmd *pccb)
  114. {
  115. pccb->cmd[0] = SCSI_INQUIRY;
  116. pccb->cmd[1] = pccb->lun << 5;
  117. pccb->cmd[2] = 0;
  118. pccb->cmd[3] = 0;
  119. if (pccb->datalen > 255)
  120. pccb->cmd[4] = 255;
  121. else
  122. pccb->cmd[4] = (unsigned char)pccb->datalen;
  123. pccb->cmd[5] = 0;
  124. pccb->cmdlen = 6;
  125. pccb->msgout[0] = SCSI_IDENTIFY; /* NOT USED */
  126. }
  127. #ifdef CONFIG_BLK
  128. static ulong scsi_read(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt,
  129. void *buffer)
  130. #else
  131. static ulong scsi_read(struct blk_desc *block_dev, lbaint_t blknr,
  132. lbaint_t blkcnt, void *buffer)
  133. #endif
  134. {
  135. #ifdef CONFIG_BLK
  136. struct blk_desc *block_dev = dev_get_uclass_platdata(dev);
  137. struct udevice *bdev = dev->parent;
  138. #else
  139. struct udevice *bdev = NULL;
  140. #endif
  141. lbaint_t start, blks;
  142. uintptr_t buf_addr;
  143. unsigned short smallblks = 0;
  144. struct scsi_cmd *pccb = (struct scsi_cmd *)&tempccb;
  145. /* Setup device */
  146. pccb->target = block_dev->target;
  147. pccb->lun = block_dev->lun;
  148. buf_addr = (unsigned long)buffer;
  149. start = blknr;
  150. blks = blkcnt;
  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. #ifdef CONFIG_SYS_64BIT_LBA
  157. if (start > SCSI_LBA48_READ) {
  158. unsigned long blocks;
  159. blocks = min_t(lbaint_t, blks, SCSI_MAX_READ_BLK);
  160. pccb->datalen = block_dev->blksz * blocks;
  161. scsi_setup_read16(pccb, start, blocks);
  162. start += blocks;
  163. blks -= blocks;
  164. } else
  165. #endif
  166. if (blks > SCSI_MAX_READ_BLK) {
  167. pccb->datalen = block_dev->blksz *
  168. SCSI_MAX_READ_BLK;
  169. smallblks = SCSI_MAX_READ_BLK;
  170. scsi_setup_read_ext(pccb, start, smallblks);
  171. start += SCSI_MAX_READ_BLK;
  172. blks -= SCSI_MAX_READ_BLK;
  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. /* Almost the maximum amount of the scsi_ext command.. */
  198. #define SCSI_MAX_WRITE_BLK 0xFFFF
  199. #ifdef CONFIG_BLK
  200. static ulong scsi_write(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt,
  201. const void *buffer)
  202. #else
  203. static ulong scsi_write(struct blk_desc *block_dev, lbaint_t blknr,
  204. lbaint_t blkcnt, const void *buffer)
  205. #endif
  206. {
  207. #ifdef CONFIG_BLK
  208. struct blk_desc *block_dev = dev_get_uclass_platdata(dev);
  209. struct udevice *bdev = dev->parent;
  210. #else
  211. struct udevice *bdev = NULL;
  212. #endif
  213. lbaint_t start, blks;
  214. uintptr_t buf_addr;
  215. unsigned short smallblks;
  216. struct scsi_cmd *pccb = (struct scsi_cmd *)&tempccb;
  217. /* Setup device */
  218. pccb->target = block_dev->target;
  219. pccb->lun = block_dev->lun;
  220. buf_addr = (unsigned long)buffer;
  221. start = blknr;
  222. blks = blkcnt;
  223. debug("\n%s: dev %d startblk " LBAF ", blccnt " LBAF " buffer %lx\n",
  224. __func__, block_dev->devnum, start, blks, (unsigned long)buffer);
  225. do {
  226. pccb->pdata = (unsigned char *)buf_addr;
  227. if (blks > SCSI_MAX_WRITE_BLK) {
  228. pccb->datalen = (block_dev->blksz *
  229. SCSI_MAX_WRITE_BLK);
  230. smallblks = SCSI_MAX_WRITE_BLK;
  231. scsi_setup_write_ext(pccb, start, smallblks);
  232. start += SCSI_MAX_WRITE_BLK;
  233. blks -= SCSI_MAX_WRITE_BLK;
  234. } else {
  235. pccb->datalen = block_dev->blksz * blks;
  236. smallblks = (unsigned short)blks;
  237. scsi_setup_write_ext(pccb, start, smallblks);
  238. start += blks;
  239. blks = 0;
  240. }
  241. debug("%s: startblk " LBAF ", blccnt %x buffer %lx\n",
  242. __func__, start, smallblks, buf_addr);
  243. if (scsi_exec(bdev, pccb)) {
  244. scsi_print_error(pccb);
  245. blkcnt -= blks;
  246. break;
  247. }
  248. buf_addr += pccb->datalen;
  249. } while (blks != 0);
  250. debug("%s: end startblk " LBAF ", blccnt %x buffer %lX\n",
  251. __func__, start, smallblks, buf_addr);
  252. return blkcnt;
  253. }
  254. #if defined(CONFIG_PCI) && !defined(CONFIG_SCSI_AHCI_PLAT) && \
  255. !defined(CONFIG_DM_SCSI)
  256. void scsi_init(void)
  257. {
  258. int busdevfunc = -1;
  259. int i;
  260. /*
  261. * Find a device from the list, this driver will support a single
  262. * controller.
  263. */
  264. for (i = 0; i < ARRAY_SIZE(scsi_device_list); i++) {
  265. /* get PCI Device ID */
  266. #ifdef CONFIG_DM_PCI
  267. struct udevice *dev;
  268. int ret;
  269. ret = dm_pci_find_device(scsi_device_list[i].vendor,
  270. scsi_device_list[i].device, 0, &dev);
  271. if (!ret) {
  272. busdevfunc = dm_pci_get_bdf(dev);
  273. break;
  274. }
  275. #else
  276. busdevfunc = pci_find_device(scsi_device_list[i].vendor,
  277. scsi_device_list[i].device,
  278. 0);
  279. #endif
  280. if (busdevfunc != -1)
  281. break;
  282. }
  283. if (busdevfunc == -1) {
  284. printf("Error: SCSI Controller(s) ");
  285. for (i = 0; i < ARRAY_SIZE(scsi_device_list); i++) {
  286. printf("%04X:%04X ",
  287. scsi_device_list[i].vendor,
  288. scsi_device_list[i].device);
  289. }
  290. printf("not found\n");
  291. return;
  292. }
  293. #ifdef DEBUG
  294. else {
  295. printf("SCSI Controller (%04X,%04X) found (%d:%d:%d)\n",
  296. scsi_device_list[i].vendor,
  297. scsi_device_list[i].device,
  298. (busdevfunc >> 16) & 0xFF,
  299. (busdevfunc >> 11) & 0x1F,
  300. (busdevfunc >> 8) & 0x7);
  301. }
  302. #endif
  303. bootstage_start(BOOTSTAGE_ID_ACCUM_SCSI, "ahci");
  304. scsi_low_level_init(busdevfunc);
  305. scsi_scan(true);
  306. bootstage_accum(BOOTSTAGE_ID_ACCUM_SCSI);
  307. }
  308. #endif
  309. /* copy src to dest, skipping leading and trailing blanks
  310. * and null terminate the string
  311. */
  312. static void scsi_ident_cpy(unsigned char *dest, unsigned char *src,
  313. unsigned int len)
  314. {
  315. int start, end;
  316. start = 0;
  317. while (start < len) {
  318. if (src[start] != ' ')
  319. break;
  320. start++;
  321. }
  322. end = len-1;
  323. while (end > start) {
  324. if (src[end] != ' ')
  325. break;
  326. end--;
  327. }
  328. for (; start <= end; start++)
  329. *dest ++= src[start];
  330. *dest = '\0';
  331. }
  332. static int scsi_read_capacity(struct udevice *dev, struct scsi_cmd *pccb,
  333. lbaint_t *capacity, unsigned long *blksz)
  334. {
  335. *capacity = 0;
  336. memset(pccb->cmd, '\0', sizeof(pccb->cmd));
  337. pccb->cmd[0] = SCSI_RD_CAPAC10;
  338. pccb->cmd[1] = pccb->lun << 5;
  339. pccb->cmdlen = 10;
  340. pccb->msgout[0] = SCSI_IDENTIFY; /* NOT USED */
  341. pccb->datalen = 8;
  342. if (scsi_exec(dev, pccb))
  343. return 1;
  344. *capacity = ((lbaint_t)pccb->pdata[0] << 24) |
  345. ((lbaint_t)pccb->pdata[1] << 16) |
  346. ((lbaint_t)pccb->pdata[2] << 8) |
  347. ((lbaint_t)pccb->pdata[3]);
  348. if (*capacity != 0xffffffff) {
  349. /* Read capacity (10) was sufficient for this drive. */
  350. *blksz = ((unsigned long)pccb->pdata[4] << 24) |
  351. ((unsigned long)pccb->pdata[5] << 16) |
  352. ((unsigned long)pccb->pdata[6] << 8) |
  353. ((unsigned long)pccb->pdata[7]);
  354. return 0;
  355. }
  356. /* Read capacity (10) was insufficient. Use read capacity (16). */
  357. memset(pccb->cmd, '\0', sizeof(pccb->cmd));
  358. pccb->cmd[0] = SCSI_RD_CAPAC16;
  359. pccb->cmd[1] = 0x10;
  360. pccb->cmdlen = 16;
  361. pccb->msgout[0] = SCSI_IDENTIFY; /* NOT USED */
  362. pccb->datalen = 16;
  363. if (scsi_exec(dev, pccb))
  364. return 1;
  365. *capacity = ((uint64_t)pccb->pdata[0] << 56) |
  366. ((uint64_t)pccb->pdata[1] << 48) |
  367. ((uint64_t)pccb->pdata[2] << 40) |
  368. ((uint64_t)pccb->pdata[3] << 32) |
  369. ((uint64_t)pccb->pdata[4] << 24) |
  370. ((uint64_t)pccb->pdata[5] << 16) |
  371. ((uint64_t)pccb->pdata[6] << 8) |
  372. ((uint64_t)pccb->pdata[7]);
  373. *blksz = ((uint64_t)pccb->pdata[8] << 56) |
  374. ((uint64_t)pccb->pdata[9] << 48) |
  375. ((uint64_t)pccb->pdata[10] << 40) |
  376. ((uint64_t)pccb->pdata[11] << 32) |
  377. ((uint64_t)pccb->pdata[12] << 24) |
  378. ((uint64_t)pccb->pdata[13] << 16) |
  379. ((uint64_t)pccb->pdata[14] << 8) |
  380. ((uint64_t)pccb->pdata[15]);
  381. return 0;
  382. }
  383. /*
  384. * Some setup (fill-in) routines
  385. */
  386. static void scsi_setup_test_unit_ready(struct scsi_cmd *pccb)
  387. {
  388. pccb->cmd[0] = SCSI_TST_U_RDY;
  389. pccb->cmd[1] = pccb->lun << 5;
  390. pccb->cmd[2] = 0;
  391. pccb->cmd[3] = 0;
  392. pccb->cmd[4] = 0;
  393. pccb->cmd[5] = 0;
  394. pccb->cmdlen = 6;
  395. pccb->msgout[0] = SCSI_IDENTIFY; /* NOT USED */
  396. }
  397. /**
  398. * scsi_init_dev_desc_priv - initialize only SCSI specific blk_desc properties
  399. *
  400. * @dev_desc: Block device description pointer
  401. */
  402. static void scsi_init_dev_desc_priv(struct blk_desc *dev_desc)
  403. {
  404. dev_desc->target = 0xff;
  405. dev_desc->lun = 0xff;
  406. dev_desc->log2blksz =
  407. LOG2_INVALID(typeof(dev_desc->log2blksz));
  408. dev_desc->type = DEV_TYPE_UNKNOWN;
  409. dev_desc->vendor[0] = 0;
  410. dev_desc->product[0] = 0;
  411. dev_desc->revision[0] = 0;
  412. dev_desc->removable = false;
  413. #if !CONFIG_IS_ENABLED(BLK)
  414. dev_desc->block_read = scsi_read;
  415. dev_desc->block_write = scsi_write;
  416. #endif
  417. }
  418. #if !defined(CONFIG_DM_SCSI)
  419. /**
  420. * scsi_init_dev_desc - initialize all SCSI specific blk_desc properties
  421. *
  422. * @dev_desc: Block device description pointer
  423. * @devnum: Device number
  424. */
  425. static void scsi_init_dev_desc(struct blk_desc *dev_desc, int devnum)
  426. {
  427. dev_desc->lba = 0;
  428. dev_desc->blksz = 0;
  429. dev_desc->if_type = IF_TYPE_SCSI;
  430. dev_desc->devnum = devnum;
  431. dev_desc->part_type = PART_TYPE_UNKNOWN;
  432. scsi_init_dev_desc_priv(dev_desc);
  433. }
  434. #endif
  435. /**
  436. * scsi_detect_dev - Detect scsi device
  437. *
  438. * @target: target id
  439. * @lun: target lun
  440. * @dev_desc: block device description
  441. *
  442. * The scsi_detect_dev detects and fills a dev_desc structure when the device is
  443. * detected.
  444. *
  445. * Return: 0 on success, error value otherwise
  446. */
  447. static int scsi_detect_dev(struct udevice *dev, int target, int lun,
  448. struct blk_desc *dev_desc)
  449. {
  450. unsigned char perq, modi;
  451. lbaint_t capacity;
  452. unsigned long blksz;
  453. struct scsi_cmd *pccb = (struct scsi_cmd *)&tempccb;
  454. pccb->target = target;
  455. pccb->lun = lun;
  456. pccb->pdata = (unsigned char *)&tempbuff;
  457. pccb->datalen = 512;
  458. scsi_setup_inquiry(pccb);
  459. if (scsi_exec(dev, pccb)) {
  460. if (pccb->contr_stat == SCSI_SEL_TIME_OUT) {
  461. /*
  462. * selection timeout => assuming no
  463. * device present
  464. */
  465. debug("Selection timeout ID %d\n",
  466. pccb->target);
  467. return -ETIMEDOUT;
  468. }
  469. scsi_print_error(pccb);
  470. return -ENODEV;
  471. }
  472. perq = tempbuff[0];
  473. modi = tempbuff[1];
  474. if ((perq & 0x1f) == 0x1f)
  475. return -ENODEV; /* skip unknown devices */
  476. if ((modi & 0x80) == 0x80) /* drive is removable */
  477. dev_desc->removable = true;
  478. /* get info for this device */
  479. scsi_ident_cpy((unsigned char *)dev_desc->vendor,
  480. &tempbuff[8], 8);
  481. scsi_ident_cpy((unsigned char *)dev_desc->product,
  482. &tempbuff[16], 16);
  483. scsi_ident_cpy((unsigned char *)dev_desc->revision,
  484. &tempbuff[32], 4);
  485. dev_desc->target = pccb->target;
  486. dev_desc->lun = pccb->lun;
  487. pccb->datalen = 0;
  488. scsi_setup_test_unit_ready(pccb);
  489. if (scsi_exec(dev, pccb)) {
  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. part_init(bdesc);
  548. if (verbose) {
  549. printf(" Device %d: ", 0);
  550. dev_print(bdesc);
  551. }
  552. return 0;
  553. }
  554. int scsi_scan_dev(struct udevice *dev, bool verbose)
  555. {
  556. struct scsi_platdata *uc_plat; /* scsi controller platdata */
  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 platdata */
  565. uc_plat = dev_get_uclass_platdata(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 < CONFIG_SYS_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. ret = scsi_detect_dev(NULL, i, lun,
  602. &scsi_dev_desc[scsi_max_devs]);
  603. if (ret)
  604. continue;
  605. part_init(&scsi_dev_desc[scsi_max_devs]);
  606. if (verbose) {
  607. printf(" Device %d: ", 0);
  608. dev_print(&scsi_dev_desc[scsi_max_devs]);
  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 = CONFIG_SYS_SCSI_MAX_DEVICE,
  639. .desc = scsi_dev_desc,
  640. };
  641. #endif