drivers/block/ide.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2000-2011
   4  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   5  */
   6
   7 #define LOG_CATEGORY UCLASS_IDE
   8
   9 #include <common.h>
  10 #include <ata.h>
  11 #include <blk.h>
  12 #include <bootdev.h>
  13 #include <dm.h>
  14 #include <ide.h>
  15 #include <log.h>
  16 #include <part.h>
  17 #include <watchdog.h>
  18 #include <asm/io.h>
  19 #include <linux/delay.h>
  20
  21 #ifdef __PPC__
  22 # define EIEIO          __asm__ volatile ("eieio")
  23 # define SYNC           __asm__ volatile ("sync")
  24 #else
  25 # define EIEIO          /* nothing */
  26 # define SYNC           /* nothing */
  27 #endif
  28
  29 /* Current offset for IDE0 / IDE1 bus access    */
  30 ulong ide_bus_offset[CONFIG_SYS_IDE_MAXBUS] = {
  31 #if defined(CONFIG_SYS_ATA_IDE0_OFFSET)
  32         CONFIG_SYS_ATA_IDE0_OFFSET,
  33 #endif
  34 #if defined(CONFIG_SYS_ATA_IDE1_OFFSET) && (CONFIG_SYS_IDE_MAXBUS > 1)
  35         CONFIG_SYS_ATA_IDE1_OFFSET,
  36 #endif
  37 };
  38
  39 #define ATA_CURR_BASE(dev)      (CONFIG_SYS_ATA_BASE_ADDR + \
  40                 ide_bus_offset[IDE_BUS(dev)])
  41
  42 static int ide_bus_ok[CONFIG_SYS_IDE_MAXBUS];
  43
  44 struct blk_desc ide_dev_desc[CONFIG_SYS_IDE_MAXDEVICE];
  45
  46 #define IDE_TIME_OUT    2000    /* 2 sec timeout */
  47
  48 #define ATAPI_TIME_OUT  7000    /* 7 sec timeout (5 sec seems to work...) */
  49
  50 #define IDE_SPIN_UP_TIME_OUT 5000 /* 5 sec spin-up timeout */
  51
  52 #ifdef CONFIG_IDE_RESET
  53 static void ide_reset(void)
  54 {
  55         int i;
  56
  57         for (i = 0; i < CONFIG_SYS_IDE_MAXBUS; ++i)
  58                 ide_bus_ok[i] = 0;
  59
  60         ide_set_reset(1);       /* assert reset */
  61
  62         /* the reset signal shall be asserted for et least 25 us */
  63         udelay(25);
  64
  65         schedule();
  66
  67         /* de-assert RESET signal */
  68         ide_set_reset(0);
  69
  70         mdelay(250);
  71 }
  72 #else
  73 #define ide_reset()     /* dummy */
  74 #endif /* CONFIG_IDE_RESET */
  75
  76 static void ide_outb(int dev, int port, unsigned char val)
  77 {
  78         debug("ide_outb (dev= %d, port= 0x%x, val= 0x%02x) : @ 0x%08lx\n",
  79               dev, port, val, ATA_CURR_BASE(dev) + port);
  80
  81         outb(val, ATA_CURR_BASE(dev) + port);
  82 }
  83
  84 static unsigned char ide_inb(int dev, int port)
  85 {
  86         uchar val;
  87
  88         val = inb(ATA_CURR_BASE(dev) + port);
  89
  90         debug("ide_inb (dev= %d, port= 0x%x) : @ 0x%08lx -> 0x%02x\n",
  91               dev, port, ATA_CURR_BASE(dev) + port, val);
  92         return val;
  93 }
  94
  95 static void ide_input_swap_data(int dev, ulong *sect_buf, int words)
  96 {
  97         uintptr_t paddr = (ATA_CURR_BASE(dev) + ATA_DATA_REG);
  98         ushort *dbuf = (ushort *)sect_buf;
  99
 100         debug("in input swap data base for read is %p\n", (void *)paddr);
 101
 102         while (words--) {
 103                 EIEIO;
 104                 *dbuf++ = be16_to_cpu(inw(paddr));
 105                 EIEIO;
 106                 *dbuf++ = be16_to_cpu(inw(paddr));
 107         }
 108 }
 109
 110 /*
 111  * Wait until Busy bit is off, or timeout (in ms)
 112  * Return last status
 113  */
 114 static uchar ide_wait(int dev, ulong t)
 115 {
 116         ulong delay = 10 * t;   /* poll every 100 us */
 117         uchar c;
 118
 119         while ((c = ide_inb(dev, ATA_STATUS)) & ATA_STAT_BUSY) {
 120                 udelay(100);
 121                 if (delay-- == 0)
 122                         break;
 123         }
 124         return c;
 125 }
 126
 127 /*
 128  * copy src to dest, skipping leading and trailing blanks and null
 129  * terminate the string
 130  * "len" is the size of available memory including the terminating '\0'
 131  */
 132 static void ident_cpy(unsigned char *dst, unsigned char *src,
 133                       unsigned int len)
 134 {
 135         unsigned char *end, *last;
 136
 137         last = dst;
 138         end = src + len - 1;
 139
 140         /* reserve space for '\0' */
 141         if (len < 2)
 142                 goto OUT;
 143
 144         /* skip leading white space */
 145         while ((*src) && (src < end) && (*src == ' '))
 146                 ++src;
 147
 148         /* copy string, omitting trailing white space */
 149         while ((*src) && (src < end)) {
 150                 *dst++ = *src;
 151                 if (*src++ != ' ')
 152                         last = dst;
 153         }
 154 OUT:
 155         *last = '\0';
 156 }
 157
 158 /****************************************************************************
 159  * ATAPI Support
 160  */
 161
 162 /* since ATAPI may use commands with not 4 bytes alligned length
 163  * we have our own transfer functions, 2 bytes alligned */
 164 static void ide_output_data_shorts(int dev, ushort *sect_buf, int shorts)
 165 {
 166         uintptr_t paddr = (ATA_CURR_BASE(dev) + ATA_DATA_REG);
 167         ushort *dbuf;
 168
 169         dbuf = (ushort *)sect_buf;
 170
 171         debug("in output data shorts base for read is %p\n", (void *)paddr);
 172
 173         while (shorts--) {
 174                 EIEIO;
 175                 outw(cpu_to_le16(*dbuf++), paddr);
 176         }
 177 }
 178
 179 static void ide_input_data_shorts(int dev, ushort *sect_buf, int shorts)
 180 {
 181         uintptr_t paddr = (ATA_CURR_BASE(dev) + ATA_DATA_REG);
 182         ushort *dbuf;
 183
 184         dbuf = (ushort *)sect_buf;
 185
 186         debug("in input data shorts base for read is %p\n", (void *)paddr);
 187
 188         while (shorts--) {
 189                 EIEIO;
 190                 *dbuf++ = le16_to_cpu(inw(paddr));
 191         }
 192 }
 193
 194 /*
 195  * Wait until (Status & mask) == res, or timeout (in ms)
 196  * Return last status
 197  * This is used since some ATAPI CD ROMs clears their Busy Bit first
 198  * and then they set their DRQ Bit
 199  */
 200 static uchar atapi_wait_mask(int dev, ulong t, uchar mask, uchar res)
 201 {
 202         ulong delay = 10 * t;   /* poll every 100 us */
 203         uchar c;
 204
 205         /* prevents to read the status before valid */
 206         c = ide_inb(dev, ATA_DEV_CTL);
 207
 208         while (((c = ide_inb(dev, ATA_STATUS)) & mask) != res) {
 209                 /* break if error occurs (doesn't make sense to wait more) */
 210                 if ((c & ATA_STAT_ERR) == ATA_STAT_ERR)
 211                         break;
 212                 udelay(100);
 213                 if (delay-- == 0)
 214                         break;
 215         }
 216         return c;
 217 }
 218
 219 /*
 220  * issue an atapi command
 221  */
 222 static unsigned char atapi_issue(int device, unsigned char *ccb, int ccblen,
 223                                  unsigned char *buffer, int buflen)
 224 {
 225         unsigned char c, err, mask, res;
 226         int n;
 227
 228         /* Select device
 229          */
 230         mask = ATA_STAT_BUSY | ATA_STAT_DRQ;
 231         res = 0;
 232         ide_outb(device, ATA_DEV_HD, ATA_LBA | ATA_DEVICE(device));
 233         c = atapi_wait_mask(device, ATAPI_TIME_OUT, mask, res);
 234         if ((c & mask) != res) {
 235                 printf("ATAPI_ISSUE: device %d not ready status %X\n", device,
 236                        c);
 237                 err = 0xFF;
 238                 goto AI_OUT;
 239         }
 240         /* write taskfile */
 241         ide_outb(device, ATA_ERROR_REG, 0);     /* no DMA, no overlaped */
 242         ide_outb(device, ATA_SECT_CNT, 0);
 243         ide_outb(device, ATA_SECT_NUM, 0);
 244         ide_outb(device, ATA_CYL_LOW, (unsigned char) (buflen & 0xFF));
 245         ide_outb(device, ATA_CYL_HIGH,
 246                  (unsigned char) ((buflen >> 8) & 0xFF));
 247         ide_outb(device, ATA_DEV_HD, ATA_LBA | ATA_DEVICE(device));
 248
 249         ide_outb(device, ATA_COMMAND, ATA_CMD_PACKET);
 250         udelay(50);
 251
 252         mask = ATA_STAT_DRQ | ATA_STAT_BUSY | ATA_STAT_ERR;
 253         res = ATA_STAT_DRQ;
 254         c = atapi_wait_mask(device, ATAPI_TIME_OUT, mask, res);
 255
 256         if ((c & mask) != res) {        /* DRQ must be 1, BSY 0 */
 257                 printf("ATAPI_ISSUE: Error (no IRQ) before sending ccb dev %d status 0x%02x\n",
 258                        device, c);
 259                 err = 0xFF;
 260                 goto AI_OUT;
 261         }
 262
 263         /* write command block */
 264         ide_output_data_shorts(device, (unsigned short *)ccb, ccblen / 2);
 265
 266         /* ATAPI Command written wait for completition */
 267         mdelay(5);              /* device must set bsy */
 268
 269         mask = ATA_STAT_DRQ | ATA_STAT_BUSY | ATA_STAT_ERR;
 270         /*
 271          * if no data wait for DRQ = 0 BSY = 0
 272          * if data wait for DRQ = 1 BSY = 0
 273          */
 274         res = 0;
 275         if (buflen)
 276                 res = ATA_STAT_DRQ;
 277         c = atapi_wait_mask(device, ATAPI_TIME_OUT, mask, res);
 278         if ((c & mask) != res) {
 279                 if (c & ATA_STAT_ERR) {
 280                         err = (ide_inb(device, ATA_ERROR_REG)) >> 4;
 281                         debug("atapi_issue 1 returned sense key %X status %02X\n",
 282                               err, c);
 283                 } else {
 284                         printf("ATAPI_ISSUE: (no DRQ) after sending ccb (%x)  status 0x%02x\n",
 285                                ccb[0], c);
 286                         err = 0xFF;
 287                 }
 288                 goto AI_OUT;
 289         }
 290         n = ide_inb(device, ATA_CYL_HIGH);
 291         n <<= 8;
 292         n += ide_inb(device, ATA_CYL_LOW);
 293         if (n > buflen) {
 294                 printf("ERROR, transfer bytes %d requested only %d\n", n,
 295                        buflen);
 296                 err = 0xff;
 297                 goto AI_OUT;
 298         }
 299         if ((n == 0) && (buflen < 0)) {
 300                 printf("ERROR, transfer bytes %d requested %d\n", n, buflen);
 301                 err = 0xff;
 302                 goto AI_OUT;
 303         }
 304         if (n != buflen) {
 305                 debug("WARNING, transfer bytes %d not equal with requested %d\n",
 306                       n, buflen);
 307         }
 308         if (n != 0) {           /* data transfer */
 309                 debug("ATAPI_ISSUE: %d Bytes to transfer\n", n);
 310                 /* we transfer shorts */
 311                 n >>= 1;
 312                 /* ok now decide if it is an in or output */
 313                 if ((ide_inb(device, ATA_SECT_CNT) & 0x02) == 0) {
 314                         debug("Write to device\n");
 315                         ide_output_data_shorts(device, (unsigned short *)buffer,
 316                                                n);
 317                 } else {
 318                         debug("Read from device @ %p shorts %d\n", buffer, n);
 319                         ide_input_data_shorts(device, (unsigned short *)buffer,
 320                                               n);
 321                 }
 322         }
 323         mdelay(5);              /* seems that some CD ROMs need this... */
 324         mask = ATA_STAT_BUSY | ATA_STAT_ERR;
 325         res = 0;
 326         c = atapi_wait_mask(device, ATAPI_TIME_OUT, mask, res);
 327         if ((c & ATA_STAT_ERR) == ATA_STAT_ERR) {
 328                 err = (ide_inb(device, ATA_ERROR_REG) >> 4);
 329                 debug("atapi_issue 2 returned sense key %X status %X\n", err,
 330                       c);
 331         } else {
 332                 err = 0;
 333         }
 334 AI_OUT:
 335         return err;
 336 }
 337
 338 /*
 339  * sending the command to atapi_issue. If an status other than good
 340  * returns, an request_sense will be issued
 341  */
 342
 343 #define ATAPI_DRIVE_NOT_READY   100
 344 #define ATAPI_UNIT_ATTN         10
 345
 346 static unsigned char atapi_issue_autoreq(int device, unsigned char *ccb,
 347                                          int ccblen,
 348                                          unsigned char *buffer, int buflen)
 349 {
 350         unsigned char sense_data[18], sense_ccb[12];
 351         unsigned char res, key, asc, ascq;
 352         int notready, unitattn;
 353
 354         unitattn = ATAPI_UNIT_ATTN;
 355         notready = ATAPI_DRIVE_NOT_READY;
 356
 357 retry:
 358         res = atapi_issue(device, ccb, ccblen, buffer, buflen);
 359         if (res == 0)
 360                 return 0;       /* Ok */
 361
 362         if (res == 0xFF)
 363                 return 0xFF;    /* error */
 364
 365         debug("(auto_req)atapi_issue returned sense key %X\n", res);
 366
 367         memset(sense_ccb, 0, sizeof(sense_ccb));
 368         memset(sense_data, 0, sizeof(sense_data));
 369         sense_ccb[0] = ATAPI_CMD_REQ_SENSE;
 370         sense_ccb[4] = 18;      /* allocation Length */
 371
 372         res = atapi_issue(device, sense_ccb, 12, sense_data, 18);
 373         key = (sense_data[2] & 0xF);
 374         asc = (sense_data[12]);
 375         ascq = (sense_data[13]);
 376
 377         debug("ATAPI_CMD_REQ_SENSE returned %x\n", res);
 378         debug(" Sense page: %02X key %02X ASC %02X ASCQ %02X\n",
 379               sense_data[0], key, asc, ascq);
 380
 381         if ((key == 0))
 382                 return 0;       /* ok device ready */
 383
 384         if ((key == 6) || (asc == 0x29) || (asc == 0x28)) { /* Unit Attention */
 385                 if (unitattn-- > 0) {
 386                         mdelay(200);
 387                         goto retry;
 388                 }
 389                 printf("Unit Attention, tried %d\n", ATAPI_UNIT_ATTN);
 390                 goto error;
 391         }
 392         if ((asc == 0x4) && (ascq == 0x1)) {
 393                 /* not ready, but will be ready soon */
 394                 if (notready-- > 0) {
 395                         mdelay(200);
 396                         goto retry;
 397                 }
 398                 printf("Drive not ready, tried %d times\n",
 399                        ATAPI_DRIVE_NOT_READY);
 400                 goto error;
 401         }
 402         if (asc == 0x3a) {
 403                 debug("Media not present\n");
 404                 goto error;
 405         }
 406
 407         printf("ERROR: Unknown Sense key %02X ASC %02X ASCQ %02X\n", key, asc,
 408                ascq);
 409 error:
 410         debug("ERROR Sense key %02X ASC %02X ASCQ %02X\n", key, asc, ascq);
 411         return 0xFF;
 412 }
 413
 414 /*
 415  * atapi_read:
 416  * we transfer only one block per command, since the multiple DRQ per
 417  * command is not yet implemented
 418  */
 419 #define ATAPI_READ_MAX_BYTES    2048    /* we read max 2kbytes */
 420 #define ATAPI_READ_BLOCK_SIZE   2048    /* assuming CD part */
 421 #define ATAPI_READ_MAX_BLOCK    (ATAPI_READ_MAX_BYTES/ATAPI_READ_BLOCK_SIZE)
 422
 423 static ulong atapi_read(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt,
 424                         void *buffer)
 425 {
 426         struct blk_desc *block_dev = dev_get_uclass_plat(dev);
 427         int device = block_dev->devnum;
 428         ulong n = 0;
 429         unsigned char ccb[12];  /* Command descriptor block */
 430         ulong cnt;
 431
 432         debug("atapi_read dev %d start " LBAF " blocks " LBAF
 433               " buffer at %lX\n", device, blknr, blkcnt, (ulong) buffer);
 434
 435         do {
 436                 if (blkcnt > ATAPI_READ_MAX_BLOCK)
 437                         cnt = ATAPI_READ_MAX_BLOCK;
 438                 else
 439                         cnt = blkcnt;
 440
 441                 ccb[0] = ATAPI_CMD_READ_12;
 442                 ccb[1] = 0;     /* reserved */
 443                 ccb[2] = (unsigned char) (blknr >> 24) & 0xFF;  /* MSB Block */
 444                 ccb[3] = (unsigned char) (blknr >> 16) & 0xFF;  /*  */
 445                 ccb[4] = (unsigned char) (blknr >> 8) & 0xFF;
 446                 ccb[5] = (unsigned char) blknr & 0xFF;  /* LSB Block */
 447                 ccb[6] = (unsigned char) (cnt >> 24) & 0xFF; /* MSB Block cnt */
 448                 ccb[7] = (unsigned char) (cnt >> 16) & 0xFF;
 449                 ccb[8] = (unsigned char) (cnt >> 8) & 0xFF;
 450                 ccb[9] = (unsigned char) cnt & 0xFF;    /* LSB Block */
 451                 ccb[10] = 0;    /* reserved */
 452                 ccb[11] = 0;    /* reserved */
 453
 454                 if (atapi_issue_autoreq(device, ccb, 12,
 455                                         (unsigned char *)buffer,
 456                                         cnt * ATAPI_READ_BLOCK_SIZE)
 457                     == 0xFF) {
 458                         return n;
 459                 }
 460                 n += cnt;
 461                 blkcnt -= cnt;
 462                 blknr += cnt;
 463                 buffer += (cnt * ATAPI_READ_BLOCK_SIZE);
 464         } while (blkcnt > 0);
 465         return n;
 466 }
 467
 468 static void atapi_inquiry(struct blk_desc *dev_desc)
 469 {
 470         unsigned char ccb[12];  /* Command descriptor block */
 471         unsigned char iobuf[64];        /* temp buf */
 472         unsigned char c;
 473         int device;
 474
 475         device = dev_desc->devnum;
 476         dev_desc->type = DEV_TYPE_UNKNOWN;      /* not yet valid */
 477
 478         memset(ccb, 0, sizeof(ccb));
 479         memset(iobuf, 0, sizeof(iobuf));
 480
 481         ccb[0] = ATAPI_CMD_INQUIRY;
 482         ccb[4] = 40;            /* allocation Legnth */
 483         c = atapi_issue_autoreq(device, ccb, 12, (unsigned char *)iobuf, 40);
 484
 485         debug("ATAPI_CMD_INQUIRY returned %x\n", c);
 486         if (c != 0)
 487                 return;
 488
 489         /* copy device ident strings */
 490         ident_cpy((unsigned char *)dev_desc->vendor, &iobuf[8], 8);
 491         ident_cpy((unsigned char *)dev_desc->product, &iobuf[16], 16);
 492         ident_cpy((unsigned char *)dev_desc->revision, &iobuf[32], 5);
 493
 494         dev_desc->lun = 0;
 495         dev_desc->lba = 0;
 496         dev_desc->blksz = 0;
 497         dev_desc->log2blksz = LOG2_INVALID(typeof(dev_desc->log2blksz));
 498         dev_desc->type = iobuf[0] & 0x1f;
 499
 500         if ((iobuf[1] & 0x80) == 0x80)
 501                 dev_desc->removable = 1;
 502         else
 503                 dev_desc->removable = 0;
 504
 505         memset(ccb, 0, sizeof(ccb));
 506         memset(iobuf, 0, sizeof(iobuf));
 507         ccb[0] = ATAPI_CMD_START_STOP;
 508         ccb[4] = 0x03;          /* start */
 509
 510         c = atapi_issue_autoreq(device, ccb, 12, (unsigned char *)iobuf, 0);
 511
 512         debug("ATAPI_CMD_START_STOP returned %x\n", c);
 513         if (c != 0)
 514                 return;
 515
 516         memset(ccb, 0, sizeof(ccb));
 517         memset(iobuf, 0, sizeof(iobuf));
 518         c = atapi_issue_autoreq(device, ccb, 12, (unsigned char *)iobuf, 0);
 519
 520         debug("ATAPI_CMD_UNIT_TEST_READY returned %x\n", c);
 521         if (c != 0)
 522                 return;
 523
 524         memset(ccb, 0, sizeof(ccb));
 525         memset(iobuf, 0, sizeof(iobuf));
 526         ccb[0] = ATAPI_CMD_READ_CAP;
 527         c = atapi_issue_autoreq(device, ccb, 12, (unsigned char *)iobuf, 8);
 528         debug("ATAPI_CMD_READ_CAP returned %x\n", c);
 529         if (c != 0)
 530                 return;
 531
 532         debug("Read Cap: LBA %02X%02X%02X%02X blksize %02X%02X%02X%02X\n",
 533               iobuf[0], iobuf[1], iobuf[2], iobuf[3],
 534               iobuf[4], iobuf[5], iobuf[6], iobuf[7]);
 535
 536         dev_desc->lba = ((unsigned long) iobuf[0] << 24) +
 537                 ((unsigned long) iobuf[1] << 16) +
 538                 ((unsigned long) iobuf[2] << 8) + ((unsigned long) iobuf[3]);
 539         dev_desc->blksz = ((unsigned long) iobuf[4] << 24) +
 540                 ((unsigned long) iobuf[5] << 16) +
 541                 ((unsigned long) iobuf[6] << 8) + ((unsigned long) iobuf[7]);
 542         dev_desc->log2blksz = LOG2(dev_desc->blksz);
 543
 544         /* ATAPI devices cannot use 48bit addressing (ATA/ATAPI v7) */
 545         dev_desc->lba48 = false;
 546 }
 547
 548 static void ide_ident(struct blk_desc *dev_desc)
 549 {
 550         unsigned char c;
 551         hd_driveid_t iop;
 552         bool is_atapi = false;
 553         int tries = 1;
 554         int device;
 555
 556         device = dev_desc->devnum;
 557         printf("  Device %d: ", device);
 558
 559         /* Select device
 560          */
 561         ide_outb(device, ATA_DEV_HD, ATA_LBA | ATA_DEVICE(device));
 562         dev_desc->uclass_id = UCLASS_IDE;
 563         if (IS_ENABLED(CONFIG_ATAPI))
 564                 tries = 2;
 565
 566         while (tries) {
 567                 /* check signature */
 568                 if (IS_ENABLED(CONFIG_ATAPI) &&
 569                     ide_inb(device, ATA_SECT_CNT) == 0x01 &&
 570                     ide_inb(device, ATA_SECT_NUM) == 0x01 &&
 571                     ide_inb(device, ATA_CYL_LOW) == 0x14 &&
 572                     ide_inb(device, ATA_CYL_HIGH) == 0xeb) {
 573                         /* ATAPI Signature found */
 574                         is_atapi = true;
 575                         /*
 576                          * Start Ident Command
 577                          */
 578                         ide_outb(device, ATA_COMMAND, ATA_CMD_ID_ATAPI);
 579                         /*
 580                          * Wait for completion - ATAPI devices need more time
 581                          * to become ready
 582                          */
 583                         c = ide_wait(device, ATAPI_TIME_OUT);
 584                 } else {
 585                         /*
 586                          * Start Ident Command
 587                          */
 588                         ide_outb(device, ATA_COMMAND, ATA_CMD_ID_ATA);
 589
 590                         /*
 591                          * Wait for completion
 592                          */
 593                         c = ide_wait(device, IDE_TIME_OUT);
 594                 }
 595
 596                 if ((c & ATA_STAT_DRQ) &&
 597                     !(c & (ATA_STAT_FAULT | ATA_STAT_ERR))) {
 598                         break;
 599                 } else if (IS_ENABLED(CONFIG_ATAPI)) {
 600                         /*
 601                          * Need to soft reset the device
 602                          * in case it's an ATAPI...
 603                          */
 604                         debug("Retrying...\n");
 605                         ide_outb(device, ATA_DEV_HD,
 606                                  ATA_LBA | ATA_DEVICE(device));
 607                         mdelay(100);
 608                         ide_outb(device, ATA_COMMAND, 0x08);
 609                         mdelay(500);
 610                         /* Select device */
 611                         ide_outb(device, ATA_DEV_HD,
 612                                  ATA_LBA | ATA_DEVICE(device));
 613                 }
 614                 tries--;
 615         }
 616
 617         if (!tries)     /* Not found */
 618                 return;
 619
 620         ide_input_swap_data(device, (ulong *)&iop, ATA_SECTORWORDS);
 621
 622         ident_cpy((unsigned char *)dev_desc->revision, iop.fw_rev,
 623                   sizeof(dev_desc->revision));
 624         ident_cpy((unsigned char *)dev_desc->vendor, iop.model,
 625                   sizeof(dev_desc->vendor));
 626         ident_cpy((unsigned char *)dev_desc->product, iop.serial_no,
 627                   sizeof(dev_desc->product));
 628
 629         if ((iop.config & 0x0080) == 0x0080)
 630                 dev_desc->removable = 1;
 631         else
 632                 dev_desc->removable = 0;
 633
 634         if (IS_ENABLED(CONFIG_ATAPI) && is_atapi) {
 635                 dev_desc->atapi = true;
 636                 atapi_inquiry(dev_desc);
 637                 return;
 638         }
 639
 640         iop.lba_capacity[0] = be16_to_cpu(iop.lba_capacity[0]);
 641         iop.lba_capacity[1] = be16_to_cpu(iop.lba_capacity[1]);
 642         dev_desc->lba =
 643                         ((unsigned long)iop.lba_capacity[0]) |
 644                         ((unsigned long)iop.lba_capacity[1] << 16);
 645
 646         if (IS_ENABLED(CONFIG_LBA48) && (iop.command_set_2 & 0x0400)) {
 647                 /* LBA 48 support */
 648                 dev_desc->lba48 = true;
 649                 for (int i = 0; i < 4; i++)
 650                         iop.lba48_capacity[i] = be16_to_cpu(iop.lba48_capacity[i]);
 651                 dev_desc->lba =
 652                         ((unsigned long long)iop.lba48_capacity[0] |
 653                         ((unsigned long long)iop.lba48_capacity[1] << 16) |
 654                         ((unsigned long long)iop.lba48_capacity[2] << 32) |
 655                         ((unsigned long long)iop.lba48_capacity[3] << 48));
 656         } else {
 657                 dev_desc->lba48 = false;
 658         }
 659
 660         /* assuming HD */
 661         dev_desc->type = DEV_TYPE_HARDDISK;
 662         dev_desc->blksz = ATA_BLOCKSIZE;
 663         dev_desc->log2blksz = LOG2(dev_desc->blksz);
 664         dev_desc->lun = 0;      /* just to fill something in... */
 665
 666 #if 0                           /* only used to test the powersaving mode,
 667                                  * if enabled, the drive goes after 5 sec
 668                                  * in standby mode */
 669         ide_outb(device, ATA_DEV_HD, ATA_LBA | ATA_DEVICE(device));
 670         c = ide_wait(device, IDE_TIME_OUT);
 671         ide_outb(device, ATA_SECT_CNT, 1);
 672         ide_outb(device, ATA_LBA_LOW, 0);
 673         ide_outb(device, ATA_LBA_MID, 0);
 674         ide_outb(device, ATA_LBA_HIGH, 0);
 675         ide_outb(device, ATA_DEV_HD, ATA_LBA | ATA_DEVICE(device));
 676         ide_outb(device, ATA_COMMAND, 0xe3);
 677         udelay(50);
 678         c = ide_wait(device, IDE_TIME_OUT);     /* can't take over 500 ms */
 679 #endif
 680 }
 681
 682 static void ide_init(void)
 683 {
 684         unsigned char c;
 685         int i, bus;
 686
 687         schedule();
 688
 689         /* ATAPI Drives seems to need a proper IDE Reset */
 690         ide_reset();
 691
 692         /*
 693          * Wait for IDE to get ready.
 694          * According to spec, this can take up to 31 seconds!
 695          */
 696         for (bus = 0; bus < CONFIG_SYS_IDE_MAXBUS; ++bus) {
 697                 int dev =
 698                         bus * (CONFIG_SYS_IDE_MAXDEVICE /
 699                                CONFIG_SYS_IDE_MAXBUS);
 700
 701                 printf("Bus %d: ", bus);
 702
 703                 ide_bus_ok[bus] = 0;
 704
 705                 /* Select device */
 706                 mdelay(100);
 707                 ide_outb(dev, ATA_DEV_HD, ATA_LBA | ATA_DEVICE(dev));
 708                 mdelay(100);
 709                 i = 0;
 710                 do {
 711                         mdelay(10);
 712
 713                         c = ide_inb(dev, ATA_STATUS);
 714                         i++;
 715                         if (i > (ATA_RESET_TIME * 100)) {
 716                                 puts("** Timeout **\n");
 717                                 return;
 718                         }
 719                         if ((i >= 100) && ((i % 100) == 0))
 720                                 putc('.');
 721
 722                 } while (c & ATA_STAT_BUSY);
 723
 724                 if (c & (ATA_STAT_BUSY | ATA_STAT_FAULT)) {
 725                         puts("not available  ");
 726                         debug("Status = 0x%02X ", c);
 727                 } else if (IS_ENABLED(CONFIG_ATAPI) && !(c & ATA_STAT_READY)) {
 728                         /* ATAPI Devices do not set DRDY */
 729                         puts("not available  ");
 730                         debug("Status = 0x%02X ", c);
 731                 } else {
 732                         puts("OK ");
 733                         ide_bus_ok[bus] = 1;
 734                 }
 735                 schedule();
 736         }
 737
 738         putc('\n');
 739
 740         for (i = 0; i < CONFIG_SYS_IDE_MAXDEVICE; ++i) {
 741                 ide_dev_desc[i].type = DEV_TYPE_UNKNOWN;
 742                 ide_dev_desc[i].uclass_id = UCLASS_IDE;
 743                 ide_dev_desc[i].devnum = i;
 744                 ide_dev_desc[i].part_type = PART_TYPE_UNKNOWN;
 745                 ide_dev_desc[i].blksz = 0;
 746                 ide_dev_desc[i].log2blksz =
 747                         LOG2_INVALID(typeof(ide_dev_desc[i].log2blksz));
 748                 ide_dev_desc[i].lba = 0;
 749                 if (!ide_bus_ok[IDE_BUS(i)])
 750                         continue;
 751                 ide_ident(&ide_dev_desc[i]);
 752                 dev_print(&ide_dev_desc[i]);
 753         }
 754         schedule();
 755 }
 756
 757 static void ide_output_data(int dev, const ulong *sect_buf, int words)
 758 {
 759         uintptr_t paddr = (ATA_CURR_BASE(dev) + ATA_DATA_REG);
 760         ushort *dbuf;
 761
 762         dbuf = (ushort *)sect_buf;
 763         while (words--) {
 764                 EIEIO;
 765                 outw(cpu_to_le16(*dbuf++), paddr);
 766                 EIEIO;
 767                 outw(cpu_to_le16(*dbuf++), paddr);
 768         }
 769 }
 770
 771 static void ide_input_data(int dev, ulong *sect_buf, int words)
 772 {
 773         uintptr_t paddr = (ATA_CURR_BASE(dev) + ATA_DATA_REG);
 774         ushort *dbuf;
 775
 776         dbuf = (ushort *)sect_buf;
 777
 778         debug("in input data base for read is %p\n", (void *)paddr);
 779
 780         while (words--) {
 781                 EIEIO;
 782                 *dbuf++ = le16_to_cpu(inw(paddr));
 783                 EIEIO;
 784                 *dbuf++ = le16_to_cpu(inw(paddr));
 785         }
 786 }
 787
 788 static ulong ide_read(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt,
 789                       void *buffer)
 790 {
 791         struct blk_desc *block_dev = dev_get_uclass_plat(dev);
 792         int device = block_dev->devnum;
 793         ulong n = 0;
 794         unsigned char c;
 795         unsigned char pwrsave = 0;      /* power save */
 796         bool lba48 = false;
 797
 798         if (IS_ENABLED(CONFIG_LBA48) && (blknr & 0x0000fffff0000000ULL)) {
 799                 /* more than 28 bits used, use 48bit mode */
 800                 lba48 = true;
 801         }
 802
 803         debug("ide_read dev %d start " LBAF ", blocks " LBAF " buffer at %lX\n",
 804               device, blknr, blkcnt, (ulong) buffer);
 805
 806         /* Select device
 807          */
 808         ide_outb(device, ATA_DEV_HD, ATA_LBA | ATA_DEVICE(device));
 809         c = ide_wait(device, IDE_TIME_OUT);
 810
 811         if (c & ATA_STAT_BUSY) {
 812                 printf("IDE read: device %d not ready\n", device);
 813                 goto IDE_READ_E;
 814         }
 815
 816         /* first check if the drive is in Powersaving mode, if yes,
 817          * increase the timeout value */
 818         ide_outb(device, ATA_COMMAND, ATA_CMD_CHK_POWER);
 819         udelay(50);
 820
 821         c = ide_wait(device, IDE_TIME_OUT);     /* can't take over 500 ms */
 822
 823         if (c & ATA_STAT_BUSY) {
 824                 printf("IDE read: device %d not ready\n", device);
 825                 goto IDE_READ_E;
 826         }
 827         if ((c & ATA_STAT_ERR) == ATA_STAT_ERR) {
 828                 printf("No Powersaving mode %X\n", c);
 829         } else {
 830                 c = ide_inb(device, ATA_SECT_CNT);
 831                 debug("Powersaving %02X\n", c);
 832                 if (c == 0)
 833                         pwrsave = 1;
 834         }
 835
 836
 837         while (blkcnt-- > 0) {
 838                 c = ide_wait(device, IDE_TIME_OUT);
 839
 840                 if (c & ATA_STAT_BUSY) {
 841                         printf("IDE read: device %d not ready\n", device);
 842                         break;
 843                 }
 844                 if (IS_ENABLED(CONFIG_LBA48) && lba48) {
 845                         /* write high bits */
 846                         ide_outb(device, ATA_SECT_CNT, 0);
 847                         ide_outb(device, ATA_LBA_LOW, (blknr >> 24) & 0xFF);
 848 #ifdef CONFIG_SYS_64BIT_LBA
 849                         ide_outb(device, ATA_LBA_MID, (blknr >> 32) & 0xFF);
 850                         ide_outb(device, ATA_LBA_HIGH, (blknr >> 40) & 0xFF);
 851 #else
 852                         ide_outb(device, ATA_LBA_MID, 0);
 853                         ide_outb(device, ATA_LBA_HIGH, 0);
 854 #endif
 855                 }
 856                 ide_outb(device, ATA_SECT_CNT, 1);
 857                 ide_outb(device, ATA_LBA_LOW, (blknr >> 0) & 0xFF);
 858                 ide_outb(device, ATA_LBA_MID, (blknr >> 8) & 0xFF);
 859                 ide_outb(device, ATA_LBA_HIGH, (blknr >> 16) & 0xFF);
 860
 861                 if (IS_ENABLED(CONFIG_LBA48) && lba48) {
 862                         ide_outb(device, ATA_DEV_HD,
 863                                  ATA_LBA | ATA_DEVICE(device));
 864                         ide_outb(device, ATA_COMMAND, ATA_CMD_PIO_READ_EXT);
 865
 866                 } else {
 867                         ide_outb(device, ATA_DEV_HD, ATA_LBA |
 868                                  ATA_DEVICE(device) | ((blknr >> 24) & 0xF));
 869                         ide_outb(device, ATA_COMMAND, ATA_CMD_PIO_READ);
 870                 }
 871
 872                 udelay(50);
 873
 874                 if (pwrsave) {
 875                         /* may take up to 4 sec */
 876                         c = ide_wait(device, IDE_SPIN_UP_TIME_OUT);
 877                         pwrsave = 0;
 878                 } else {
 879                         /* can't take over 500 ms */
 880                         c = ide_wait(device, IDE_TIME_OUT);
 881                 }
 882
 883                 if ((c & (ATA_STAT_DRQ | ATA_STAT_BUSY | ATA_STAT_ERR)) !=
 884                     ATA_STAT_DRQ) {
 885                         printf("Error (no IRQ) dev %d blk " LBAF
 886                                ": status %#02x\n", device, blknr, c);
 887                         break;
 888                 }
 889
 890                 ide_input_data(device, buffer, ATA_SECTORWORDS);
 891                 (void) ide_inb(device, ATA_STATUS);     /* clear IRQ */
 892
 893                 ++n;
 894                 ++blknr;
 895                 buffer += ATA_BLOCKSIZE;
 896         }
 897 IDE_READ_E:
 898         return n;
 899 }
 900
 901 static ulong ide_write(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt,
 902                        const void *buffer)
 903 {
 904         struct blk_desc *block_dev = dev_get_uclass_plat(dev);
 905         int device = block_dev->devnum;
 906         ulong n = 0;
 907         unsigned char c;
 908         bool lba48 = false;
 909
 910         if (IS_ENABLED(CONFIG_LBA48) && (blknr & 0x0000fffff0000000ULL)) {
 911                 /* more than 28 bits used, use 48bit mode */
 912                 lba48 = true;
 913         }
 914
 915         /* Select device
 916          */
 917         ide_outb(device, ATA_DEV_HD, ATA_LBA | ATA_DEVICE(device));
 918
 919         while (blkcnt-- > 0) {
 920                 c = ide_wait(device, IDE_TIME_OUT);
 921
 922                 if (c & ATA_STAT_BUSY) {
 923                         printf("IDE read: device %d not ready\n", device);
 924                         goto WR_OUT;
 925                 }
 926                 if (IS_ENABLED(CONFIG_LBA48) && lba48) {
 927                         /* write high bits */
 928                         ide_outb(device, ATA_SECT_CNT, 0);
 929                         ide_outb(device, ATA_LBA_LOW, (blknr >> 24) & 0xFF);
 930 #ifdef CONFIG_SYS_64BIT_LBA
 931                         ide_outb(device, ATA_LBA_MID, (blknr >> 32) & 0xFF);
 932                         ide_outb(device, ATA_LBA_HIGH, (blknr >> 40) & 0xFF);
 933 #else
 934                         ide_outb(device, ATA_LBA_MID, 0);
 935                         ide_outb(device, ATA_LBA_HIGH, 0);
 936 #endif
 937                 }
 938                 ide_outb(device, ATA_SECT_CNT, 1);
 939                 ide_outb(device, ATA_LBA_LOW, (blknr >> 0) & 0xFF);
 940                 ide_outb(device, ATA_LBA_MID, (blknr >> 8) & 0xFF);
 941                 ide_outb(device, ATA_LBA_HIGH, (blknr >> 16) & 0xFF);
 942
 943                 if (IS_ENABLED(CONFIG_LBA48) && lba48) {
 944                         ide_outb(device, ATA_DEV_HD,
 945                                  ATA_LBA | ATA_DEVICE(device));
 946                         ide_outb(device, ATA_COMMAND, ATA_CMD_PIO_WRITE_EXT);
 947
 948                 } else {
 949                         ide_outb(device, ATA_DEV_HD, ATA_LBA |
 950                                  ATA_DEVICE(device) | ((blknr >> 24) & 0xF));
 951                         ide_outb(device, ATA_COMMAND, ATA_CMD_PIO_WRITE);
 952                 }
 953
 954                 udelay(50);
 955
 956                 /* can't take over 500 ms */
 957                 c = ide_wait(device, IDE_TIME_OUT);
 958
 959                 if ((c & (ATA_STAT_DRQ | ATA_STAT_BUSY | ATA_STAT_ERR)) !=
 960                     ATA_STAT_DRQ) {
 961                         printf("Error (no IRQ) dev %d blk " LBAF
 962                                ": status %#02x\n", device, blknr, c);
 963                         goto WR_OUT;
 964                 }
 965
 966                 ide_output_data(device, buffer, ATA_SECTORWORDS);
 967                 c = ide_inb(device, ATA_STATUS);        /* clear IRQ */
 968                 ++n;
 969                 ++blknr;
 970                 buffer += ATA_BLOCKSIZE;
 971         }
 972 WR_OUT:
 973         return n;
 974 }
 975
 976 ulong ide_or_atapi_read(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt,
 977                         void *buffer)
 978 {
 979         struct blk_desc *desc = dev_get_uclass_plat(dev);
 980
 981         if (IS_ENABLED(CONFIG_ATAPI) && desc->atapi)
 982                 return atapi_read(dev, blknr, blkcnt, buffer);
 983
 984         return ide_read(dev, blknr, blkcnt, buffer);
 985 }
 986
 987 static int ide_blk_probe(struct udevice *udev)
 988 {
 989         struct blk_desc *desc = dev_get_uclass_plat(udev);
 990
 991         /* fill in device vendor/product/rev strings */
 992         strncpy(desc->vendor, ide_dev_desc[desc->devnum].vendor,
 993                 BLK_VEN_SIZE);
 994         desc->vendor[BLK_VEN_SIZE] = '\0';
 995         strncpy(desc->product, ide_dev_desc[desc->devnum].product,
 996                 BLK_PRD_SIZE);
 997         desc->product[BLK_PRD_SIZE] = '\0';
 998         strncpy(desc->revision, ide_dev_desc[desc->devnum].revision,
 999                 BLK_REV_SIZE);
1000         desc->revision[BLK_REV_SIZE] = '\0';
1001
1002         return 0;
1003 }
1004
1005 static const struct blk_ops ide_blk_ops = {
1006         .read   = ide_or_atapi_read,
1007         .write  = ide_write,
1008 };
1009
1010 U_BOOT_DRIVER(ide_blk) = {
1011         .name           = "ide_blk",
1012         .id             = UCLASS_BLK,
1013         .ops            = &ide_blk_ops,
1014         .probe          = ide_blk_probe,
1015 };
1016
1017 static int ide_bootdev_bind(struct udevice *dev)
1018 {
1019         struct bootdev_uc_plat *ucp = dev_get_uclass_plat(dev);
1020
1021         ucp->prio = BOOTDEVP_5_SCAN_SLOW;
1022
1023         return 0;
1024 }
1025
1026 static int ide_bootdev_hunt(struct bootdev_hunter *info, bool show)
1027 {
1028         struct udevice *dev;
1029
1030         uclass_first_device(UCLASS_IDE, &dev);
1031
1032         return 0;
1033 }
1034
1035 struct bootdev_ops ide_bootdev_ops = {
1036 };
1037
1038 static const struct udevice_id ide_bootdev_ids[] = {
1039         { .compatible = "u-boot,bootdev-ide" },
1040         { }
1041 };
1042
1043 U_BOOT_DRIVER(ide_bootdev) = {
1044         .name           = "ide_bootdev",
1045         .id             = UCLASS_BOOTDEV,
1046         .ops            = &ide_bootdev_ops,
1047         .bind           = ide_bootdev_bind,
1048         .of_match       = ide_bootdev_ids,
1049 };
1050
1051 BOOTDEV_HUNTER(ide_bootdev_hunter) = {
1052         .prio           = BOOTDEVP_5_SCAN_SLOW,
1053         .uclass         = UCLASS_IDE,
1054         .hunt           = ide_bootdev_hunt,
1055         .drv            = DM_DRIVER_REF(ide_bootdev),
1056 };
1057
1058 static int ide_probe(struct udevice *udev)
1059 {
1060         struct udevice *blk_dev;
1061         char name[20];
1062         int blksz;
1063         lbaint_t size;
1064         int i;
1065         int ret;
1066
1067         ide_init();
1068
1069         for (i = 0; i < CONFIG_SYS_IDE_MAXDEVICE; i++) {
1070                 if (ide_dev_desc[i].type != DEV_TYPE_UNKNOWN) {
1071                         sprintf(name, "blk#%d", i);
1072
1073                         blksz = ide_dev_desc[i].blksz;
1074                         size = blksz * ide_dev_desc[i].lba;
1075
1076                         /*
1077                          * With CDROM, if there is no CD inserted, blksz will
1078                          * be zero, don't bother to create IDE block device.
1079                          */
1080                         if (!blksz)
1081                                 continue;
1082                         ret = blk_create_devicef(udev, "ide_blk", name,
1083                                                  UCLASS_IDE, i,
1084                                                  blksz, size, &blk_dev);
1085                         if (ret)
1086                                 return ret;
1087
1088                         ret = blk_probe_or_unbind(blk_dev);
1089                         if (ret)
1090                                 return ret;
1091
1092                         ret = bootdev_setup_for_dev(udev, "ide_bootdev");
1093                         if (ret)
1094                                 return log_msg_ret("bootdev", ret);
1095                 }
1096         }
1097
1098         return 0;
1099 }
1100
1101 U_BOOT_DRIVER(ide) = {
1102         .name           = "ide",
1103         .id             = UCLASS_IDE,
1104         .probe          = ide_probe,
1105 };
1106
1107 struct pci_device_id ide_supported[] = {
1108         { PCI_DEVICE_CLASS(PCI_CLASS_STORAGE_IDE << 8, 0xffff00) },
1109         { }
1110 };
1111
1112 U_BOOT_PCI_DEVICE(ide, ide_supported);
1113
1114 UCLASS_DRIVER(ide) = {
1115         .name           = "ide",
1116         .id             = UCLASS_IDE,
1117 };