cmd/scsi.c

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