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