1 /*
2 * (C) Copyright 2001
3 * Denis Peter, MPL AG Switzerland
4 *
5 * SPDX-License-Identifier: GPL-2.0+
6 */
7
8 #include <common.h>
9 #include <dm.h>
10 #include <inttypes.h>
11 #include <memalign.h>
12 #include <pci.h>
13 #include <scsi.h>
14 #include <dm/device-internal.h>
15 #include <dm/uclass-internal.h>
16
17 #if !defined(CONFIG_DM_SCSI)
18 # ifdef CONFIG_SCSI_DEV_LIST
19 # define SCSI_DEV_LIST CONFIG_SCSI_DEV_LIST
20 # else
21 # ifdef CONFIG_SATA_ULI5288
22
23 # define SCSI_VEND_ID 0x10b9
24 # define SCSI_DEV_ID 0x5288
25
26 # elif !defined(CONFIG_SCSI_AHCI_PLAT)
27 # error no scsi device defined
28 # endif
29 # define SCSI_DEV_LIST {SCSI_VEND_ID, SCSI_DEV_ID}
30 # endif
31 #endif
32
33 #if defined(CONFIG_PCI) && !defined(CONFIG_SCSI_AHCI_PLAT) && \
34 !defined(CONFIG_DM_SCSI)
35 const struct pci_device_id scsi_device_list[] = { SCSI_DEV_LIST };
36 #endif
37 static struct scsi_cmd tempccb; /* temporary scsi command buffer */
38
39 static unsigned char tempbuff[512]; /* temporary data buffer */
40
41 #if !defined(CONFIG_DM_SCSI)
42 static int scsi_max_devs; /* number of highest available scsi device */
43
44 static int scsi_curr_dev; /* current device */
45
46 static struct blk_desc scsi_dev_desc[CONFIG_SYS_SCSI_MAX_DEVICE];
47 #endif
48
49 /* almost the maximum amount of the scsi_ext command.. */
50 #define SCSI_MAX_READ_BLK 0xFFFF
51 #define SCSI_UFS_MAX_READ_BLK 0x2000 /* max read size 32MB for UFS */
52 #define SCSI_LBA48_READ 0xFFFFFFF
53
scsi_print_error(struct scsi_cmd * pccb)54 static void scsi_print_error(struct scsi_cmd *pccb)
55 {
56 /* Dummy function that could print an error for debugging */
57 }
58
59 #ifdef CONFIG_SYS_64BIT_LBA
scsi_setup_read16(struct scsi_cmd * pccb,lbaint_t start,unsigned long blocks)60 void scsi_setup_read16(struct scsi_cmd *pccb, lbaint_t start,
61 unsigned long blocks)
62 {
63 pccb->cmd[0] = SCSI_READ16;
64 pccb->cmd[1] = pccb->lun << 5;
65 pccb->cmd[2] = (unsigned char)(start >> 56) & 0xff;
66 pccb->cmd[3] = (unsigned char)(start >> 48) & 0xff;
67 pccb->cmd[4] = (unsigned char)(start >> 40) & 0xff;
68 pccb->cmd[5] = (unsigned char)(start >> 32) & 0xff;
69 pccb->cmd[6] = (unsigned char)(start >> 24) & 0xff;
70 pccb->cmd[7] = (unsigned char)(start >> 16) & 0xff;
71 pccb->cmd[8] = (unsigned char)(start >> 8) & 0xff;
72 pccb->cmd[9] = (unsigned char)start & 0xff;
73 pccb->cmd[10] = 0;
74 pccb->cmd[11] = (unsigned char)(blocks >> 24) & 0xff;
75 pccb->cmd[12] = (unsigned char)(blocks >> 16) & 0xff;
76 pccb->cmd[13] = (unsigned char)(blocks >> 8) & 0xff;
77 pccb->cmd[14] = (unsigned char)blocks & 0xff;
78 pccb->cmd[15] = 0;
79 pccb->cmdlen = 16;
80 pccb->msgout[0] = SCSI_IDENTIFY; /* NOT USED */
81 debug("scsi_setup_read16: cmd: %02X %02X startblk %02X%02X%02X%02X%02X%02X%02X%02X blccnt %02X%02X%02X%02X\n",
82 pccb->cmd[0], pccb->cmd[1],
83 pccb->cmd[2], pccb->cmd[3], pccb->cmd[4], pccb->cmd[5],
84 pccb->cmd[6], pccb->cmd[7], pccb->cmd[8], pccb->cmd[9],
85 pccb->cmd[11], pccb->cmd[12], pccb->cmd[13], pccb->cmd[14]);
86 }
87 #endif
88
scsi_setup_read_ext(struct scsi_cmd * pccb,lbaint_t start,unsigned short blocks)89 static void scsi_setup_read_ext(struct scsi_cmd *pccb, lbaint_t start,
90 unsigned short blocks)
91 {
92 pccb->cmd[0] = SCSI_READ10;
93 pccb->cmd[1] = pccb->lun << 5;
94 pccb->cmd[2] = (unsigned char)(start >> 24) & 0xff;
95 pccb->cmd[3] = (unsigned char)(start >> 16) & 0xff;
96 pccb->cmd[4] = (unsigned char)(start >> 8) & 0xff;
97 pccb->cmd[5] = (unsigned char)start & 0xff;
98 pccb->cmd[6] = 0;
99 pccb->cmd[7] = (unsigned char)(blocks >> 8) & 0xff;
100 pccb->cmd[8] = (unsigned char)blocks & 0xff;
101 pccb->cmd[6] = 0;
102 pccb->cmdlen = 10;
103 pccb->msgout[0] = SCSI_IDENTIFY; /* NOT USED */
104 debug("scsi_setup_read_ext: cmd: %02X %02X startblk %02X%02X%02X%02X blccnt %02X%02X\n",
105 pccb->cmd[0], pccb->cmd[1],
106 pccb->cmd[2], pccb->cmd[3], pccb->cmd[4], pccb->cmd[5],
107 pccb->cmd[7], pccb->cmd[8]);
108 }
109
scsi_setup_write_ext(struct scsi_cmd * pccb,lbaint_t start,unsigned short blocks)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 | 0x8;
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
scsi_setup_inquiry(struct scsi_cmd * pccb)132 static void scsi_setup_inquiry(struct scsi_cmd *pccb)
133 {
134 pccb->cmd[0] = SCSI_INQUIRY;
135 pccb->cmd[1] = pccb->lun << 5;
136 pccb->cmd[2] = 0;
137 pccb->cmd[3] = 0;
138 if (pccb->datalen > SCSI_MAX_INQUIRY_BYTES)
139 pccb->cmd[4] = SCSI_MAX_INQUIRY_BYTES;
140 else
141 pccb->cmd[4] = (unsigned char)pccb->datalen;
142 pccb->cmd[5] = 0;
143 pccb->cmdlen = 6;
144 pccb->msgout[0] = SCSI_IDENTIFY; /* NOT USED */
145 }
146
147 /*
148 * Some setup (fill-in) routines
149 */
scsi_setup_test_unit_ready(struct scsi_cmd * pccb)150 static void scsi_setup_test_unit_ready(struct scsi_cmd *pccb)
151 {
152 pccb->cmd[0] = SCSI_TST_U_RDY;
153 pccb->cmd[1] = pccb->lun << 5;
154 pccb->cmd[2] = 0;
155 pccb->cmd[3] = 0;
156 pccb->cmd[4] = 0;
157 pccb->cmd[5] = 0;
158 pccb->cmdlen = 6;
159 pccb->msgout[0] = SCSI_IDENTIFY; /* NOT USED */
160 }
161
162 #ifdef CONFIG_BLK
_scsi_read(struct udevice * dev,lbaint_t blknr,lbaint_t blkcnt,void * buffer)163 static ulong _scsi_read(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt,
164 void *buffer)
165 #else
166 static ulong _scsi_read(struct blk_desc *block_dev, lbaint_t blknr,
167 lbaint_t blkcnt, void *buffer)
168 #endif
169 {
170 #ifdef CONFIG_BLK
171 struct blk_desc *block_dev = dev_get_uclass_platdata(dev);
172 struct udevice *bdev = dev->parent;
173 #else
174 struct udevice *bdev = NULL;
175 #endif
176 lbaint_t start, blks, max_read_blks;
177 uintptr_t buf_addr;
178 unsigned short smallblks = 0;
179 struct scsi_cmd *pccb = (struct scsi_cmd *)&tempccb;
180
181 if (block_dev->rawblksz == 512)
182 max_read_blks = SCSI_MAX_READ_BLK;
183 else
184 max_read_blks = SCSI_UFS_MAX_READ_BLK;
185 /* Setup device */
186 pccb->target = block_dev->target;
187 pccb->lun = block_dev->lun;
188 buf_addr = (unsigned long)buffer;
189 start = blknr;
190 blks = blkcnt;
191 debug("\nscsi_read: dev %d startblk " LBAF
192 ", blccnt " LBAF " buffer %lx\n",
193 block_dev->devnum, start, blks, (unsigned long)buffer);
194 do {
195 pccb->pdata = (unsigned char *)buf_addr;
196 pccb->dma_dir = DMA_FROM_DEVICE;
197 #ifdef CONFIG_SYS_64BIT_LBA
198 if (start > SCSI_LBA48_READ) {
199 unsigned long blocks;
200 blocks = min_t(lbaint_t, blks, max_read_blks);
201 pccb->datalen = block_dev->rawblksz * blocks;
202 scsi_setup_read16(pccb, start, blocks);
203 start += blocks;
204 blks -= blocks;
205 } else
206 #endif
207 if (blks > max_read_blks) {
208 pccb->datalen = block_dev->rawblksz * max_read_blks;
209 smallblks = max_read_blks;
210 scsi_setup_read_ext(pccb, start, smallblks);
211 start += max_read_blks;
212 blks -= max_read_blks;
213 } else {
214 pccb->datalen = block_dev->rawblksz * blks;
215 smallblks = (unsigned short)blks;
216 scsi_setup_read_ext(pccb, start, smallblks);
217 start += blks;
218 blks = 0;
219 }
220 debug("scsi_read_ext: startblk " LBAF
221 ", blccnt %x buffer %" PRIXPTR "\n",
222 start, smallblks, buf_addr);
223 if (scsi_exec(bdev, pccb)) {
224 scsi_print_error(pccb);
225 blkcnt -= blks;
226 break;
227 }
228 buf_addr += pccb->datalen;
229 } while (blks != 0);
230 debug("scsi_read_ext: end startblk " LBAF
231 ", blccnt %x buffer %" PRIXPTR "\n", start, smallblks, buf_addr);
232 return blkcnt;
233 }
234
235 #ifdef CONFIG_BLK
scsi_read(struct udevice * dev,lbaint_t blknr,lbaint_t blkcnt,void * buffer)236 static ulong scsi_read(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt,
237 void *buffer)
238 #else
239 static ulong scsi_read(struct blk_desc *block_dev, lbaint_t blknr,
240 lbaint_t blkcnt, void *buffer)
241 #endif
242 {
243 #ifdef CONFIG_BLK
244 struct blk_desc *block_dev = dev_get_uclass_platdata(dev);
245 uint32_t rawsectsz = block_dev->rawblksz / 512;
246 long ret = blkcnt;
247
248 if (rawsectsz == 8) {
249 if ((blknr & (rawsectsz - 1)) || (blkcnt & (rawsectsz - 1))) {
250 uint32_t offset, n_sec, num_lpa;
251 long lpa;
252
253 while (blkcnt) {
254 lpa = blknr / rawsectsz;
255 offset = blknr & (rawsectsz - 1);
256 n_sec = rawsectsz - offset;
257 if (n_sec > blkcnt)
258 n_sec = blkcnt;
259
260 if (offset || n_sec < rawsectsz) {
261 _scsi_read(dev, lpa, 1, block_dev->align_sector_buf);
262 memcpy(buffer, block_dev->align_sector_buf + offset * 512, n_sec * 512);
263 } else {
264 num_lpa = blkcnt / rawsectsz;
265 n_sec = num_lpa * rawsectsz;
266 _scsi_read(dev, lpa, num_lpa, buffer);
267 }
268 blkcnt -= n_sec;
269 blknr += n_sec;
270 buffer += 512 * n_sec;
271 }
272
273 return ret;
274 }
275 blknr /= rawsectsz;
276 blkcnt /= rawsectsz;
277 _scsi_read(dev, blknr, blkcnt, buffer);
278
279 return ret;
280 }
281
282 return _scsi_read(dev, blknr, blkcnt, buffer);
283 #else
284 return _scsi_read(block_dev, blknr, blkcnt, buffer);
285 #endif
286 }
287 /*******************************************************************************
288 * scsi_write
289 */
290
291 /* Almost the maximum amount of the scsi_ext command.. */
292 #define SCSI_MAX_WRITE_BLK 0xFFFF
293 #define SCSI_UFS_MAX_WRITE_BLK 0x2000 /* max read size 32MB for UFS */
294
295 #ifdef CONFIG_BLK
_scsi_write(struct udevice * dev,lbaint_t blknr,lbaint_t blkcnt,const void * buffer)296 static ulong _scsi_write(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt,
297 const void *buffer)
298 #else
299 static ulong _scsi_write(struct blk_desc *block_dev, lbaint_t blknr,
300 lbaint_t blkcnt, const void *buffer)
301 #endif
302 {
303 #ifdef CONFIG_BLK
304 struct blk_desc *block_dev = dev_get_uclass_platdata(dev);
305 struct udevice *bdev = dev->parent;
306 #else
307 struct udevice *bdev = NULL;
308 #endif
309 lbaint_t start, blks, max_write_blks;
310 uintptr_t buf_addr;
311 unsigned short smallblks;
312 struct scsi_cmd *pccb = (struct scsi_cmd *)&tempccb;
313
314 if (block_dev->rawblksz == 512)
315 max_write_blks = SCSI_MAX_WRITE_BLK;
316 else
317 max_write_blks = SCSI_UFS_MAX_WRITE_BLK;
318
319 /* Setup device */
320 pccb->target = block_dev->target;
321 pccb->lun = block_dev->lun;
322 buf_addr = (unsigned long)buffer;
323 start = blknr;
324 blks = blkcnt;
325 debug("\n%s: dev %d startblk " LBAF ", blccnt " LBAF " buffer %lx\n",
326 __func__, block_dev->devnum, start, blks, (unsigned long)buffer);
327 do {
328 pccb->pdata = (unsigned char *)buf_addr;
329 pccb->dma_dir = DMA_TO_DEVICE;
330 if (blks > max_write_blks) {
331 pccb->datalen = (block_dev->rawblksz * max_write_blks);
332 smallblks = max_write_blks;
333 scsi_setup_write_ext(pccb, start, smallblks);
334 start += max_write_blks;
335 blks -= max_write_blks;
336 } else {
337 pccb->datalen = block_dev->rawblksz * blks;
338 smallblks = (unsigned short)blks;
339 scsi_setup_write_ext(pccb, start, smallblks);
340 start += blks;
341 blks = 0;
342 }
343 debug("%s: startblk " LBAF ", blccnt %x buffer %" PRIXPTR "\n",
344 __func__, start, smallblks, buf_addr);
345 if (scsi_exec(bdev, pccb)) {
346 scsi_print_error(pccb);
347 blkcnt -= blks;
348 break;
349 }
350 buf_addr += pccb->datalen;
351 } while (blks != 0);
352 debug("%s: end startblk " LBAF ", blccnt %x buffer %" PRIXPTR "\n",
353 __func__, start, smallblks, buf_addr);
354 return blkcnt;
355 }
356
357 #ifdef CONFIG_BLK
scsi_write(struct udevice * dev,lbaint_t blknr,lbaint_t blkcnt,const void * buffer)358 static ulong scsi_write(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt,
359 const void *buffer)
360 #else
361 static ulong scsi_write(struct blk_desc *block_dev, lbaint_t blknr,
362 lbaint_t blkcnt, const void *buffer)
363 #endif
364 {
365 #ifdef CONFIG_BLK
366 struct blk_desc *block_dev = dev_get_uclass_platdata(dev);
367 uint32_t rawsectsz = block_dev->rawblksz / 512;
368 long ret = blkcnt;
369
370 if (rawsectsz == 8) {
371 if ((blknr & (rawsectsz - 1)) || (blkcnt & (rawsectsz - 1))) {
372 uint32_t num_lpa, offset, n_sec;
373 long lpa;
374
375 while (blkcnt) {
376 lpa = blknr / rawsectsz;
377 offset = blknr & (rawsectsz - 1);
378 n_sec = rawsectsz - offset;
379 if (n_sec > blkcnt)
380 n_sec = blkcnt;
381 if (offset || n_sec < rawsectsz) {
382 _scsi_read(dev, lpa, 1, block_dev->align_sector_buf);
383 memcpy(block_dev->align_sector_buf + offset * 512, buffer, n_sec * 512);
384 _scsi_write(dev, lpa, 1, block_dev->align_sector_buf);
385 } else {
386 num_lpa = blkcnt / rawsectsz;
387 n_sec = num_lpa * rawsectsz;
388 _scsi_write(dev, lpa, num_lpa, buffer);
389 }
390 blkcnt -= n_sec;
391 blknr += n_sec;
392 buffer += 512 * n_sec;
393 }
394
395 return ret;
396 }
397 blknr /= rawsectsz;
398 blkcnt /= rawsectsz;
399 _scsi_write(dev, blknr, blkcnt, buffer);
400
401 return ret;
402 }
403
404 return _scsi_write(dev, blknr, blkcnt, buffer);
405 #else
406 return _scsi_write(block_dev, blknr, blkcnt, buffer);
407 #endif
408
409 }
410
411 #ifdef CONFIG_BLK
scsi_erase(struct udevice * dev,lbaint_t blknr,lbaint_t blkcnt)412 static ulong scsi_erase(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt)
413 {
414 ALLOC_CACHE_ALIGN_BUFFER_PAD(struct unmap_para_list, um_list, 1, ARCH_DMA_MINALIGN);
415 struct blk_desc *block_dev = dev_get_uclass_platdata(dev);
416 struct udevice *bdev = dev->parent;
417 struct scsi_cmd *pccb = (struct scsi_cmd *)&tempccb;
418 uint32_t rawsectsz = block_dev->rawblksz / block_dev->blksz;
419
420 if (rawsectsz == 1) /* The sata devices not support data erase yet. */
421 return blkcnt;
422
423 pccb->target = block_dev->target;
424 pccb->lun = block_dev->lun;
425 pccb->datalen = 0;
426 scsi_setup_test_unit_ready(pccb);
427 if (scsi_exec(bdev, pccb)) {
428 printf("TEST UNIT READY fail!Can not erase UFS device\n");
429 return 0;
430 }
431
432 if (blknr % rawsectsz != 0 || blkcnt % rawsectsz != 0)
433 printf("UFS erase area not aligned to %d, blknr = %lx, blkcnt = %lx\n", rawsectsz, blknr, blkcnt);
434
435 um_list->um_data_len = cpu_to_be16(sizeof(struct unmap_para_list) - 2);
436 um_list->um_block_desc_len = cpu_to_be16(sizeof(struct um_block_descriptor));
437 if (8 == sizeof(lbaint_t))
438 um_list->ub_desc.um_block_addr = cpu_to_be64(blknr / rawsectsz);
439 else
440 um_list->ub_desc.um_block_addr = cpu_to_be64((uint64_t)blknr / rawsectsz);
441 um_list->ub_desc.um_block_sz = cpu_to_be32((uint32_t)blkcnt / rawsectsz);
442
443 pccb->pdata = (void *)um_list;
444 pccb->datalen = 24;
445 pccb->dma_dir = DMA_TO_DEVICE;
446 memset(pccb->cmd, 0, 10);
447 pccb->cmd[0] = SCSI_UNMAP;
448 pccb->cmd[8] = 24;
449 pccb->cmdlen = 10;
450
451 if (scsi_exec(bdev, pccb)) {
452 printf("erase UFS device error.\n");
453 return 0;
454 }
455
456 return blkcnt;
457 }
458 #endif
459
460 #if defined(CONFIG_PCI) && !defined(CONFIG_SCSI_AHCI_PLAT) && \
461 !defined(CONFIG_DM_SCSI)
scsi_init(void)462 void scsi_init(void)
463 {
464 int busdevfunc = -1;
465 int i;
466 /*
467 * Find a device from the list, this driver will support a single
468 * controller.
469 */
470 for (i = 0; i < ARRAY_SIZE(scsi_device_list); i++) {
471 /* get PCI Device ID */
472 #ifdef CONFIG_DM_PCI
473 struct udevice *dev;
474 int ret;
475
476 ret = dm_pci_find_device(scsi_device_list[i].vendor,
477 scsi_device_list[i].device, 0, &dev);
478 if (!ret) {
479 busdevfunc = dm_pci_get_bdf(dev);
480 break;
481 }
482 #else
483 busdevfunc = pci_find_device(scsi_device_list[i].vendor,
484 scsi_device_list[i].device,
485 0);
486 #endif
487 if (busdevfunc != -1)
488 break;
489 }
490
491 if (busdevfunc == -1) {
492 printf("Error: SCSI Controller(s) ");
493 for (i = 0; i < ARRAY_SIZE(scsi_device_list); i++) {
494 printf("%04X:%04X ",
495 scsi_device_list[i].vendor,
496 scsi_device_list[i].device);
497 }
498 printf("not found\n");
499 return;
500 }
501 #ifdef DEBUG
502 else {
503 printf("SCSI Controller (%04X,%04X) found (%d:%d:%d)\n",
504 scsi_device_list[i].vendor,
505 scsi_device_list[i].device,
506 (busdevfunc >> 16) & 0xFF,
507 (busdevfunc >> 11) & 0x1F,
508 (busdevfunc >> 8) & 0x7);
509 }
510 #endif
511 bootstage_start(BOOTSTAGE_ID_ACCUM_SCSI, "ahci");
512 scsi_low_level_init(busdevfunc);
513 scsi_scan(true);
514 bootstage_accum(BOOTSTAGE_ID_ACCUM_SCSI);
515 }
516 #endif
517
518 /* copy src to dest, skipping leading and trailing blanks
519 * and null terminate the string
520 */
scsi_ident_cpy(unsigned char * dest,unsigned char * src,unsigned int len)521 static void scsi_ident_cpy(unsigned char *dest, unsigned char *src,
522 unsigned int len)
523 {
524 int start, end;
525
526 start = 0;
527 while (start < len) {
528 if (src[start] != ' ')
529 break;
530 start++;
531 }
532 end = len-1;
533 while (end > start) {
534 if (src[end] != ' ')
535 break;
536 end--;
537 }
538 for (; start <= end; start++)
539 *dest ++= src[start];
540 *dest = '\0';
541 }
542
scsi_read_capacity(struct udevice * dev,struct scsi_cmd * pccb,lbaint_t * capacity,unsigned long * blksz)543 static int scsi_read_capacity(struct udevice *dev, struct scsi_cmd *pccb,
544 lbaint_t *capacity, unsigned long *blksz)
545 {
546 *capacity = 0;
547
548 memset(pccb->cmd, '\0', sizeof(pccb->cmd));
549 pccb->cmd[0] = SCSI_RD_CAPAC10;
550 pccb->cmd[1] = pccb->lun << 5;
551 pccb->cmdlen = 10;
552 pccb->msgout[0] = SCSI_IDENTIFY; /* NOT USED */
553
554 pccb->datalen = 8;
555 if (scsi_exec(dev, pccb))
556 return 1;
557
558 *capacity = ((lbaint_t)pccb->pdata[0] << 24) |
559 ((lbaint_t)pccb->pdata[1] << 16) |
560 ((lbaint_t)pccb->pdata[2] << 8) |
561 ((lbaint_t)pccb->pdata[3]);
562
563 if (*capacity != 0xffffffff) {
564 /* Read capacity (10) was sufficient for this drive. */
565 *blksz = ((unsigned long)pccb->pdata[4] << 24) |
566 ((unsigned long)pccb->pdata[5] << 16) |
567 ((unsigned long)pccb->pdata[6] << 8) |
568 ((unsigned long)pccb->pdata[7]);
569 return 0;
570 }
571
572 /* Read capacity (10) was insufficient. Use read capacity (16). */
573 memset(pccb->cmd, '\0', sizeof(pccb->cmd));
574 pccb->cmd[0] = SCSI_RD_CAPAC16;
575 pccb->cmd[1] = 0x10;
576 pccb->cmdlen = 16;
577 pccb->msgout[0] = SCSI_IDENTIFY; /* NOT USED */
578
579 pccb->datalen = 16;
580 pccb->dma_dir = DMA_FROM_DEVICE;
581 if (scsi_exec(dev, pccb))
582 return 1;
583
584 *capacity = ((uint64_t)pccb->pdata[0] << 56) |
585 ((uint64_t)pccb->pdata[1] << 48) |
586 ((uint64_t)pccb->pdata[2] << 40) |
587 ((uint64_t)pccb->pdata[3] << 32) |
588 ((uint64_t)pccb->pdata[4] << 24) |
589 ((uint64_t)pccb->pdata[5] << 16) |
590 ((uint64_t)pccb->pdata[6] << 8) |
591 ((uint64_t)pccb->pdata[7]);
592
593 *blksz = ((uint64_t)pccb->pdata[8] << 56) |
594 ((uint64_t)pccb->pdata[9] << 48) |
595 ((uint64_t)pccb->pdata[10] << 40) |
596 ((uint64_t)pccb->pdata[11] << 32) |
597 ((uint64_t)pccb->pdata[12] << 24) |
598 ((uint64_t)pccb->pdata[13] << 16) |
599 ((uint64_t)pccb->pdata[14] << 8) |
600 ((uint64_t)pccb->pdata[15]);
601
602 return 0;
603 }
604
605 /**
606 * scsi_init_dev_desc_priv - initialize only SCSI specific blk_desc properties
607 *
608 * @dev_desc: Block device description pointer
609 */
scsi_init_dev_desc_priv(struct blk_desc * dev_desc)610 static void scsi_init_dev_desc_priv(struct blk_desc *dev_desc)
611 {
612 dev_desc->target = 0xff;
613 dev_desc->lun = 0xff;
614 dev_desc->log2blksz =
615 LOG2_INVALID(typeof(dev_desc->log2blksz));
616 dev_desc->type = DEV_TYPE_UNKNOWN;
617 dev_desc->vendor[0] = 0;
618 dev_desc->product[0] = 0;
619 dev_desc->revision[0] = 0;
620 dev_desc->removable = false;
621 #if !CONFIG_IS_ENABLED(BLK)
622 dev_desc->block_read = scsi_read;
623 dev_desc->block_write = scsi_write;
624 #endif
625 }
626
627 #if !defined(CONFIG_DM_SCSI)
628 /**
629 * scsi_init_dev_desc - initialize all SCSI specific blk_desc properties
630 *
631 * @dev_desc: Block device description pointer
632 * @devnum: Device number
633 */
scsi_init_dev_desc(struct blk_desc * dev_desc,int devnum)634 static void scsi_init_dev_desc(struct blk_desc *dev_desc, int devnum)
635 {
636 dev_desc->lba = 0;
637 dev_desc->blksz = 0;
638 dev_desc->if_type = IF_TYPE_SCSI;
639 dev_desc->devnum = devnum;
640 dev_desc->part_type = PART_TYPE_UNKNOWN;
641
642 scsi_init_dev_desc_priv(dev_desc);
643 }
644 #endif
645
646 /**
647 * scsi_detect_dev - Detect scsi device
648 *
649 * @target: target id
650 * @lun: target lun
651 * @dev_desc: block device description
652 *
653 * The scsi_detect_dev detects and fills a dev_desc structure when the device is
654 * detected.
655 *
656 * Return: 0 on success, error value otherwise
657 */
scsi_detect_dev(struct udevice * dev,int target,int lun,struct blk_desc * dev_desc)658 static int scsi_detect_dev(struct udevice *dev, int target, int lun,
659 struct blk_desc *dev_desc)
660 {
661 unsigned char perq, modi;
662 lbaint_t capacity;
663 unsigned long blksz;
664 struct scsi_cmd *pccb = (struct scsi_cmd *)&tempccb;
665
666 pccb->target = target;
667 pccb->lun = lun;
668 pccb->pdata = (unsigned char *)&tempbuff;
669 pccb->datalen = SCSI_STD_INQUIRY_BYTES;
670 pccb->dma_dir = DMA_FROM_DEVICE;
671 scsi_setup_inquiry(pccb);
672 if (scsi_exec(dev, pccb)) {
673 if (pccb->contr_stat == SCSI_SEL_TIME_OUT) {
674 /*
675 * selection timeout => assuming no
676 * device present
677 */
678 debug("Selection timeout ID %d\n",
679 pccb->target);
680 return -ETIMEDOUT;
681 }
682 scsi_print_error(pccb);
683 return -ENODEV;
684 }
685 perq = tempbuff[0];
686 modi = tempbuff[1];
687 if ((perq & 0x1f) == 0x1f)
688 return -ENODEV; /* skip unknown devices */
689 if ((modi & 0x80) == 0x80) /* drive is removable */
690 dev_desc->removable = true;
691 /* get info for this device */
692 scsi_ident_cpy((unsigned char *)dev_desc->vendor,
693 &tempbuff[8], 8);
694 scsi_ident_cpy((unsigned char *)dev_desc->product,
695 &tempbuff[16], 16);
696 scsi_ident_cpy((unsigned char *)dev_desc->revision,
697 &tempbuff[32], 4);
698 dev_desc->target = pccb->target;
699 dev_desc->lun = pccb->lun;
700
701 pccb->datalen = 0;
702 scsi_setup_test_unit_ready(pccb);
703 if (scsi_exec(dev, pccb)) {
704 if (dev_desc->removable) {
705 dev_desc->type = perq;
706 goto removable;
707 }
708 scsi_print_error(pccb);
709 return -EINVAL;
710 }
711 if (scsi_read_capacity(dev, pccb, &capacity, &blksz)) {
712 scsi_print_error(pccb);
713 return -EINVAL;
714 }
715
716 dev_desc->lba = capacity;
717 dev_desc->blksz = blksz;
718 dev_desc->log2blksz = LOG2(dev_desc->blksz);
719 dev_desc->type = perq;
720 removable:
721 return 0;
722 }
723
724 /*
725 * (re)-scan the scsi bus and reports scsi device info
726 * to the user if mode = 1
727 */
728 #if defined(CONFIG_DM_SCSI)
do_scsi_scan_one(struct udevice * dev,int id,int lun,bool verbose)729 static int do_scsi_scan_one(struct udevice *dev, int id, int lun, bool verbose)
730 {
731 int ret;
732 struct udevice *bdev;
733 struct blk_desc bd;
734 struct blk_desc *bdesc;
735 char str[10];
736
737 /*
738 * detect the scsi driver to get information about its geometry (block
739 * size, number of blocks) and other parameters (ids, type, ...)
740 */
741 scsi_init_dev_desc_priv(&bd);
742 if (scsi_detect_dev(dev, id, lun, &bd))
743 return -ENODEV;
744
745 /*
746 * Create only one block device and do detection
747 * to make sure that there won't be a lot of
748 * block devices created
749 */
750 snprintf(str, sizeof(str), "id%dlun%d", id, lun);
751 ret = blk_create_devicef(dev, "scsi_blk", str, IF_TYPE_SCSI, -1,
752 bd.blksz, bd.blksz * bd.lba, &bdev);
753 if (ret) {
754 debug("Can't create device\n");
755 return ret;
756 }
757
758 bdesc = dev_get_uclass_platdata(bdev);
759 bdesc->target = id;
760 bdesc->lun = lun;
761 bdesc->removable = bd.removable;
762 bdesc->type = bd.type;
763
764 if (bdesc->rawblksz == 4096) {
765 bdesc->blksz = 512;
766 bdesc->rawlba++; /* add 1 sector for ufs */
767 bdesc->lba = bdesc->rawlba * 8;
768 bdesc->align_sector_buf = memalign(CONFIG_SYS_CACHELINE_SIZE, bdesc->rawblksz);
769 }
770
771 memcpy(&bdesc->vendor, &bd.vendor, sizeof(bd.vendor));
772 memcpy(&bdesc->product, &bd.product, sizeof(bd.product));
773 memcpy(&bdesc->revision, &bd.revision, sizeof(bd.revision));
774 part_init(bdesc);
775
776 if (verbose) {
777 printf(" Device %d: ", 0);
778 dev_print(bdesc);
779 }
780 return 0;
781 }
782
scsi_scan_dev(struct udevice * dev,bool verbose)783 int scsi_scan_dev(struct udevice *dev, bool verbose)
784 {
785 struct scsi_platdata *uc_plat; /* scsi controller platdata */
786 int ret;
787 int i;
788 int lun;
789
790 /* probe SCSI controller driver */
791 ret = device_probe(dev);
792 if (ret)
793 return ret;
794
795 /* Get controller platdata */
796 uc_plat = dev_get_uclass_platdata(dev);
797
798 for (i = 0; i < uc_plat->max_id; i++)
799 for (lun = 0; lun < uc_plat->max_lun; lun++)
800 do_scsi_scan_one(dev, i, lun, verbose);
801
802 return 0;
803 }
804
scsi_scan(bool verbose)805 int scsi_scan(bool verbose)
806 {
807 struct uclass *uc;
808 struct udevice *dev; /* SCSI controller */
809 int ret;
810
811 if (verbose)
812 printf("scanning bus for devices...\n");
813
814 blk_unbind_all(IF_TYPE_SCSI);
815
816 ret = uclass_get(UCLASS_SCSI, &uc);
817 if (ret)
818 return ret;
819
820 uclass_foreach_dev(dev, uc) {
821 ret = scsi_scan_dev(dev, verbose);
822 if (ret)
823 return ret;
824 }
825
826 return 0;
827 }
828 #else
scsi_scan(bool verbose)829 int scsi_scan(bool verbose)
830 {
831 unsigned char i, lun;
832 int ret;
833
834 if (verbose)
835 printf("scanning bus for devices...\n");
836 for (i = 0; i < CONFIG_SYS_SCSI_MAX_DEVICE; i++)
837 scsi_init_dev_desc(&scsi_dev_desc[i], i);
838
839 scsi_max_devs = 0;
840 for (i = 0; i < CONFIG_SYS_SCSI_MAX_SCSI_ID; i++) {
841 for (lun = 0; lun < CONFIG_SYS_SCSI_MAX_LUN; lun++) {
842 ret = scsi_detect_dev(NULL, i, lun,
843 &scsi_dev_desc[scsi_max_devs]);
844 if (ret)
845 continue;
846 part_init(&scsi_dev_desc[scsi_max_devs]);
847
848 if (verbose) {
849 printf(" Device %d: ", 0);
850 dev_print(&scsi_dev_desc[scsi_max_devs]);
851 }
852 scsi_max_devs++;
853 } /* next LUN */
854 }
855 if (scsi_max_devs > 0)
856 scsi_curr_dev = 0;
857 else
858 scsi_curr_dev = -1;
859
860 printf("Found %d device(s).\n", scsi_max_devs);
861 #ifndef CONFIG_SPL_BUILD
862 env_set_ulong("scsidevs", scsi_max_devs);
863 #endif
864 return 0;
865 }
866 #endif
867
868 #ifdef CONFIG_BLK
869 static const struct blk_ops scsi_blk_ops = {
870 .read = scsi_read,
871 .write = scsi_write,
872 .erase = scsi_erase,
873 };
874
875 U_BOOT_DRIVER(scsi_blk) = {
876 .name = "scsi_blk",
877 .id = UCLASS_BLK,
878 .ops = &scsi_blk_ops,
879 };
880 #else
881 U_BOOT_LEGACY_BLK(scsi) = {
882 .if_typename = "scsi",
883 .if_type = IF_TYPE_SCSI,
884 .max_devs = CONFIG_SYS_SCSI_MAX_DEVICE,
885 .desc = scsi_dev_desc,
886 };
887 #endif
888