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