?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
uboot-build-default-toolchain-path.patch
[u-boot-openmoko/mini2440.git] / common / cmd_ide.c
blob8ace970c73b3d0755b4a03c882a9b1ff94eab7e2
1 /*
2 * (C) Copyright 2000-2005
3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4 *
5 * See file CREDITS for list of people who contributed to this
6 * project.
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License as
10 * published by the Free Software Foundation; either version 2 of
11 * the License, or (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
21 * MA 02111-1307 USA
22 *
23 */
24
25 /*
26 * IDE support
27 */
28 #include <common.h>
29 #include <config.h>
30 #include <watchdog.h>
31 #include <command.h>
32 #include <image.h>
33 #include <asm/byteorder.h>
34 #include <asm/io.h>
35
36 #if defined(CONFIG_IDE_8xx_DIRECT) || defined(CONFIG_IDE_PCMCIA)
37 # include <pcmcia.h>
38 #endif
39
40 #ifdef CONFIG_8xx
41 # include <mpc8xx.h>
42 #endif
43
44 #ifdef CONFIG_MPC5xxx
45 #include <mpc5xxx.h>
46 #endif
47
48 #include <ide.h>
49 #include <ata.h>
50
51 #ifdef CONFIG_STATUS_LED
52 # include <status_led.h>
53 #endif
54
55 #ifndef __PPC__
56 #include <asm/io.h>
57 #endif
58
59 #ifdef CONFIG_IDE_8xx_DIRECT
60 DECLARE_GLOBAL_DATA_PTR;
61 #endif
62
63 #ifdef __PPC__
64 # define EIEIO __asm__ volatile ("eieio")
65 # define SYNC __asm__ volatile ("sync")
66 #else
67 # define EIEIO /* nothing */
68 # define SYNC /* nothing */
69 #endif
70
71 #ifdef CONFIG_IDE_8xx_DIRECT
72 /* Timings for IDE Interface
73 *
74 * SETUP / LENGTH / HOLD - cycles valid for 50 MHz clk
75 * 70 165 30 PIO-Mode 0, [ns]
76 * 4 9 2 [Cycles]
77 * 50 125 20 PIO-Mode 1, [ns]
78 * 3 7 2 [Cycles]
79 * 30 100 15 PIO-Mode 2, [ns]
80 * 2 6 1 [Cycles]
81 * 30 80 10 PIO-Mode 3, [ns]
82 * 2 5 1 [Cycles]
83 * 25 70 10 PIO-Mode 4, [ns]
84 * 2 4 1 [Cycles]
85 */
86
87 const static pio_config_t pio_config_ns [IDE_MAX_PIO_MODE+1] =
88 {
89 /* Setup Length Hold */
90 { 70, 165, 30 }, /* PIO-Mode 0, [ns] */
91 { 50, 125, 20 }, /* PIO-Mode 1, [ns] */
92 { 30, 101, 15 }, /* PIO-Mode 2, [ns] */
93 { 30, 80, 10 }, /* PIO-Mode 3, [ns] */
94 { 25, 70, 10 }, /* PIO-Mode 4, [ns] */
95 };
96
97 static pio_config_t pio_config_clk [IDE_MAX_PIO_MODE+1];
98
99 #ifndef CFG_PIO_MODE
100 #define CFG_PIO_MODE 0 /* use a relaxed default */
101 #endif
102 static int pio_mode = CFG_PIO_MODE;
103
104 /* Make clock cycles and always round up */
105
106 #define PCMCIA_MK_CLKS( t, T ) (( (t) * (T) + 999U ) / 1000U )
107
108 #endif /* CONFIG_IDE_8xx_DIRECT */
109
110 /* ------------------------------------------------------------------------- */
111
112 /* Current I/O Device */
113 static int curr_device = -1;
114
115 /* Current offset for IDE0 / IDE1 bus access */
116 ulong ide_bus_offset[CFG_IDE_MAXBUS] = {
117 #if defined(CFG_ATA_IDE0_OFFSET)
118 CFG_ATA_IDE0_OFFSET,
119 #endif
120 #if defined(CFG_ATA_IDE1_OFFSET) && (CFG_IDE_MAXBUS > 1)
121 CFG_ATA_IDE1_OFFSET,
122 #endif
123 };
124
125
126 #ifndef CONFIG_AMIGAONEG3SE
127 static int ide_bus_ok[CFG_IDE_MAXBUS];
128 #else
129 static int ide_bus_ok[CFG_IDE_MAXBUS] = {0,};
130 #endif
131
132 block_dev_desc_t ide_dev_desc[CFG_IDE_MAXDEVICE];
133 /* ------------------------------------------------------------------------- */
134
135 #ifdef CONFIG_IDE_LED
136 #if !defined(CONFIG_KUP4K) && !defined(CONFIG_KUP4X) &&!defined(CONFIG_BMS2003) &&!defined(CONFIG_CPC45)
137 static void ide_led (uchar led, uchar status);
138 #else
139 extern void ide_led (uchar led, uchar status);
140 #endif
141 #else
142 #ifndef CONFIG_AMIGAONEG3SE
143 #define ide_led(a,b) /* dummy */
144 #else
145 extern void ide_led(uchar led, uchar status);
146 #define LED_IDE1 1
147 #define LED_IDE2 2
148 #define CONFIG_IDE_LED 1
149 #define DEVICE_LED(x) 1
150 #endif
151 #endif
152
153 #ifdef CONFIG_IDE_RESET
154 static void ide_reset (void);
155 #else
156 #define ide_reset() /* dummy */
157 #endif
158
159 static void ide_ident (block_dev_desc_t *dev_desc);
160 static uchar ide_wait (int dev, ulong t);
161
162 #define IDE_TIME_OUT 2000 /* 2 sec timeout */
163
164 #define ATAPI_TIME_OUT 7000 /* 7 sec timeout (5 sec seems to work...) */
165
166 #define IDE_SPIN_UP_TIME_OUT 5000 /* 5 sec spin-up timeout */
167
168 void inline ide_outb(int dev, int port, unsigned char val);
169 unsigned char inline ide_inb(int dev, int port);
170 static void input_data(int dev, ulong *sect_buf, int words);
171 static void output_data(int dev, ulong *sect_buf, int words);
172 static void ident_cpy (unsigned char *dest, unsigned char *src, unsigned int len);
173
174 #ifndef CFG_ATA_PORT_ADDR
175 #define CFG_ATA_PORT_ADDR(port) (port)
176 #endif
177
178 #ifdef CONFIG_ATAPI
179 static void atapi_inquiry(block_dev_desc_t *dev_desc);
180 ulong atapi_read (int device, lbaint_t blknr, ulong blkcnt, void *buffer);
181 #endif
182
183
184 #ifdef CONFIG_IDE_8xx_DIRECT
185 static void set_pcmcia_timing (int pmode);
186 #endif
187
188 /* ------------------------------------------------------------------------- */
189
190 int do_ide (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
191 {
192 int rcode = 0;
193
194 switch (argc) {
195 case 0:
196 case 1:
197 printf ("Usage:\n%s\n", cmdtp->usage);
198 return 1;
199 case 2:
200 if (strncmp(argv[1],"res",3) == 0) {
201 puts ("\nReset IDE"
202 #ifdef CONFIG_IDE_8xx_DIRECT
203 " on PCMCIA " PCMCIA_SLOT_MSG
204 #endif
205 ": ");
206
207 ide_init ();
208 return 0;
209 } else if (strncmp(argv[1],"inf",3) == 0) {
210 int i;
211
212 putc ('\n');
213
214 for (i=0; i<CFG_IDE_MAXDEVICE; ++i) {
215 if (ide_dev_desc[i].type==DEV_TYPE_UNKNOWN)
216 continue; /* list only known devices */
217 printf ("IDE device %d: ", i);
218 dev_print(&ide_dev_desc[i]);
219 }
220 return 0;
221
222 } else if (strncmp(argv[1],"dev",3) == 0) {
223 if ((curr_device < 0) || (curr_device >= CFG_IDE_MAXDEVICE)) {
224 puts ("\nno IDE devices available\n");
225 return 1;
226 }
227 printf ("\nIDE device %d: ", curr_device);
228 dev_print(&ide_dev_desc[curr_device]);
229 return 0;
230 } else if (strncmp(argv[1],"part",4) == 0) {
231 int dev, ok;
232
233 for (ok=0, dev=0; dev<CFG_IDE_MAXDEVICE; ++dev) {
234 if (ide_dev_desc[dev].part_type!=PART_TYPE_UNKNOWN) {
235 ++ok;
236 if (dev)
237 putc ('\n');
238 print_part(&ide_dev_desc[dev]);
239 }
240 }
241 if (!ok) {
242 puts ("\nno IDE devices available\n");
243 rcode ++;
244 }
245 return rcode;
246 }
247 printf ("Usage:\n%s\n", cmdtp->usage);
248 return 1;
249 case 3:
250 if (strncmp(argv[1],"dev",3) == 0) {
251 int dev = (int)simple_strtoul(argv[2], NULL, 10);
252
253 printf ("\nIDE device %d: ", dev);
254 if (dev >= CFG_IDE_MAXDEVICE) {
255 puts ("unknown device\n");
256 return 1;
257 }
258 dev_print(&ide_dev_desc[dev]);
259 /*ide_print (dev);*/
260
261 if (ide_dev_desc[dev].type == DEV_TYPE_UNKNOWN) {
262 return 1;
263 }
264
265 curr_device = dev;
266
267 puts ("... is now current device\n");
268
269 return 0;
270 } else if (strncmp(argv[1],"part",4) == 0) {
271 int dev = (int)simple_strtoul(argv[2], NULL, 10);
272
273 if (ide_dev_desc[dev].part_type!=PART_TYPE_UNKNOWN) {
274 print_part(&ide_dev_desc[dev]);
275 } else {
276 printf ("\nIDE device %d not available\n", dev);
277 rcode = 1;
278 }
279 return rcode;
280 #if 0
281 } else if (strncmp(argv[1],"pio",4) == 0) {
282 int mode = (int)simple_strtoul(argv[2], NULL, 10);
283
284 if ((mode >= 0) && (mode <= IDE_MAX_PIO_MODE)) {
285 puts ("\nSetting ");
286 pio_mode = mode;
287 ide_init ();
288 } else {
289 printf ("\nInvalid PIO mode %d (0 ... %d only)\n",
290 mode, IDE_MAX_PIO_MODE);
291 }
292 return;
293 #endif
294 }
295
296 printf ("Usage:\n%s\n", cmdtp->usage);
297 return 1;
298 default:
299 /* at least 4 args */
300
301 if (strcmp(argv[1],"read") == 0) {
302 ulong addr = simple_strtoul(argv[2], NULL, 16);
303 ulong cnt = simple_strtoul(argv[4], NULL, 16);
304 ulong n;
305 #ifdef CFG_64BIT_STRTOUL
306 lbaint_t blk = simple_strtoull(argv[3], NULL, 16);
307
308 printf ("\nIDE read: device %d block # %qd, count %ld ... ",
309 curr_device, blk, cnt);
310 #else
311 lbaint_t blk = simple_strtoul(argv[3], NULL, 16);
312
313 printf ("\nIDE read: device %d block # %ld, count %ld ... ",
314 curr_device, blk, cnt);
315 #endif
316
317 n = ide_dev_desc[curr_device].block_read (curr_device,
318 blk, cnt,
319 (ulong *)addr);
320 /* flush cache after read */
321 flush_cache (addr, cnt*ide_dev_desc[curr_device].blksz);
322
323 printf ("%ld blocks read: %s\n",
324 n, (n==cnt) ? "OK" : "ERROR");
325 if (n==cnt) {
326 return 0;
327 } else {
328 return 1;
329 }
330 } else if (strcmp(argv[1],"write") == 0) {
331 ulong addr = simple_strtoul(argv[2], NULL, 16);
332 ulong cnt = simple_strtoul(argv[4], NULL, 16);
333 ulong n;
334 #ifdef CFG_64BIT_STRTOUL
335 lbaint_t blk = simple_strtoull(argv[3], NULL, 16);
336
337 printf ("\nIDE write: device %d block # %qd, count %ld ... ",
338 curr_device, blk, cnt);
339 #else
340 lbaint_t blk = simple_strtoul(argv[3], NULL, 16);
341
342 printf ("\nIDE write: device %d block # %ld, count %ld ... ",
343 curr_device, blk, cnt);
344 #endif
345
346 n = ide_write (curr_device, blk, cnt, (ulong *)addr);
347
348 printf ("%ld blocks written: %s\n",
349 n, (n==cnt) ? "OK" : "ERROR");
350 if (n==cnt) {
351 return 0;
352 } else {
353 return 1;
354 }
355 } else {
356 printf ("Usage:\n%s\n", cmdtp->usage);
357 rcode = 1;
358 }
359
360 return rcode;
361 }
362 }
363
364 int do_diskboot (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
365 {
366 char *boot_device = NULL;
367 char *ep;
368 int dev, part = 0;
369 ulong addr, cnt;
370 disk_partition_t info;
371 image_header_t *hdr;
372 int rcode = 0;
373 #if defined(CONFIG_FIT)
374 const void *fit_hdr;
375 #endif
376
377 show_boot_progress (41);
378 switch (argc) {
379 case 1:
380 addr = CFG_LOAD_ADDR;
381 boot_device = getenv ("bootdevice");
382 break;
383 case 2:
384 addr = simple_strtoul(argv[1], NULL, 16);
385 boot_device = getenv ("bootdevice");
386 break;
387 case 3:
388 addr = simple_strtoul(argv[1], NULL, 16);
389 boot_device = argv[2];
390 break;
391 default:
392 printf ("Usage:\n%s\n", cmdtp->usage);
393 show_boot_progress (-42);
394 return 1;
395 }
396 show_boot_progress (42);
397
398 if (!boot_device) {
399 puts ("\n** No boot device **\n");
400 show_boot_progress (-43);
401 return 1;
402 }
403 show_boot_progress (43);
404
405 dev = simple_strtoul(boot_device, &ep, 16);
406
407 if (ide_dev_desc[dev].type==DEV_TYPE_UNKNOWN) {
408 printf ("\n** Device %d not available\n", dev);
409 show_boot_progress (-44);
410 return 1;
411 }
412 show_boot_progress (44);
413
414 if (*ep) {
415 if (*ep != ':') {
416 puts ("\n** Invalid boot device, use `dev[:part]' **\n");
417 show_boot_progress (-45);
418 return 1;
419 }
420 part = simple_strtoul(++ep, NULL, 16);
421 }
422 show_boot_progress (45);
423 if (get_partition_info (&ide_dev_desc[dev], part, &info)) {
424 show_boot_progress (-46);
425 return 1;
426 }
427 show_boot_progress (46);
428 if ((strncmp((char *)info.type, BOOT_PART_TYPE, sizeof(info.type)) != 0) &&
429 (strncmp((char *)info.type, BOOT_PART_COMP, sizeof(info.type)) != 0)) {
430 printf ("\n** Invalid partition type \"%.32s\""
431 " (expect \"" BOOT_PART_TYPE "\")\n",
432 info.type);
433 show_boot_progress (-47);
434 return 1;
435 }
436 show_boot_progress (47);
437
438 printf ("\nLoading from IDE device %d, partition %d: "
439 "Name: %.32s Type: %.32s\n",
440 dev, part, info.name, info.type);
441
442 debug ("First Block: %ld, # of blocks: %ld, Block Size: %ld\n",
443 info.start, info.size, info.blksz);
444
445 if (ide_dev_desc[dev].block_read (dev, info.start, 1, (ulong *)addr) != 1) {
446 printf ("** Read error on %d:%d\n", dev, part);
447 show_boot_progress (-48);
448 return 1;
449 }
450 show_boot_progress (48);
451
452 switch (genimg_get_format ((void *)addr)) {
453 case IMAGE_FORMAT_LEGACY:
454 hdr = (image_header_t *)addr;
455
456 show_boot_progress (49);
457
458 if (!image_check_hcrc (hdr)) {
459 puts ("\n** Bad Header Checksum **\n");
460 show_boot_progress (-50);
461 return 1;
462 }
463 show_boot_progress (50);
464
465 image_print_contents (hdr);
466
467 cnt = image_get_image_size (hdr);
468 break;
469 #if defined(CONFIG_FIT)
470 case IMAGE_FORMAT_FIT:
471 fit_hdr = (const void *)addr;
472 if (!fit_check_format (fit_hdr)) {
473 show_boot_progress (-140);
474 puts ("** Bad FIT image format\n");
475 return 1;
476 }
477 show_boot_progress (141);
478 puts ("Fit image detected...\n");
479
480 cnt = fit_get_size (fit_hdr);
481 break;
482 #endif
483 default:
484 show_boot_progress (-49);
485 puts ("** Unknown image type\n");
486 return 1;
487 }
488
489 cnt += info.blksz - 1;
490 cnt /= info.blksz;
491 cnt -= 1;
492
493 if (ide_dev_desc[dev].block_read (dev, info.start+1, cnt,
494 (ulong *)(addr+info.blksz)) != cnt) {
495 printf ("** Read error on %d:%d\n", dev, part);
496 show_boot_progress (-51);
497 return 1;
498 }
499 show_boot_progress (51);
500
501 #if defined(CONFIG_FIT)
502 /* This cannot be done earlier, we need complete FIT image in RAM first */
503 if (genimg_get_format ((void *)addr) == IMAGE_FORMAT_FIT)
504 fit_print_contents ((const void *)addr);
505 #endif
506
507 /* Loading ok, update default load address */
508
509 load_addr = addr;
510
511 /* Check if we should attempt an auto-start */
512 if (((ep = getenv("autostart")) != NULL) && (strcmp(ep,"yes") == 0)) {
513 char *local_args[2];
514 extern int do_bootm (cmd_tbl_t *, int, int, char *[]);
515
516 local_args[0] = argv[0];
517 local_args[1] = NULL;
518
519 printf ("Automatic boot of image at addr 0x%08lX ...\n", addr);
520
521 do_bootm (cmdtp, 0, 1, local_args);
522 rcode = 1;
523 }
524 return rcode;
525 }
526
527 /* ------------------------------------------------------------------------- */
528
529 void ide_init (void)
530 {
531
532 #ifdef CONFIG_IDE_8xx_DIRECT
533 volatile immap_t *immr = (immap_t *)CFG_IMMR;
534 volatile pcmconf8xx_t *pcmp = &(immr->im_pcmcia);
535 #endif
536 unsigned char c;
537 int i, bus;
538 #if defined(CONFIG_AMIGAONEG3SE) || defined(CONFIG_SC3)
539 unsigned int ata_reset_time = ATA_RESET_TIME;
540 char *s;
541 #endif
542 #ifdef CONFIG_AMIGAONEG3SE
543 unsigned int max_bus_scan;
544 #endif
545 #ifdef CONFIG_IDE_8xx_PCCARD
546 extern int pcmcia_on (void);
547 extern int ide_devices_found; /* Initialized in check_ide_device() */
548 #endif /* CONFIG_IDE_8xx_PCCARD */
549
550 #ifdef CONFIG_IDE_PREINIT
551 extern int ide_preinit (void);
552 WATCHDOG_RESET();
553
554 if (ide_preinit ()) {
555 puts ("ide_preinit failed\n");
556 return;
557 }
558 #endif /* CONFIG_IDE_PREINIT */
559
560 #ifdef CONFIG_IDE_8xx_PCCARD
561 extern int pcmcia_on (void);
562 extern int ide_devices_found; /* Initialized in check_ide_device() */
563
564 WATCHDOG_RESET();
565
566 ide_devices_found = 0;
567 /* initialize the PCMCIA IDE adapter card */
568 pcmcia_on();
569 if (!ide_devices_found)
570 return;
571 udelay (1000000); /* 1 s */
572 #endif /* CONFIG_IDE_8xx_PCCARD */
573
574 WATCHDOG_RESET();
575
576 #ifdef CONFIG_IDE_8xx_DIRECT
577 /* Initialize PIO timing tables */
578 for (i=0; i <= IDE_MAX_PIO_MODE; ++i) {
579 pio_config_clk[i].t_setup = PCMCIA_MK_CLKS(pio_config_ns[i].t_setup,
580 gd->bus_clk);
581 pio_config_clk[i].t_length = PCMCIA_MK_CLKS(pio_config_ns[i].t_length,
582 gd->bus_clk);
583 pio_config_clk[i].t_hold = PCMCIA_MK_CLKS(pio_config_ns[i].t_hold,
584 gd->bus_clk);
585 debug ( "PIO Mode %d: setup=%2d ns/%d clk"
586 " len=%3d ns/%d clk"
587 " hold=%2d ns/%d clk\n",
588 i,
589 pio_config_ns[i].t_setup, pio_config_clk[i].t_setup,
590 pio_config_ns[i].t_length, pio_config_clk[i].t_length,
591 pio_config_ns[i].t_hold, pio_config_clk[i].t_hold);
592 }
593 #endif /* CONFIG_IDE_8xx_DIRECT */
594
595 /* Reset the IDE just to be sure.
596 * Light LED's to show
597 */
598 ide_led ((LED_IDE1 | LED_IDE2), 1); /* LED's on */
599 ide_reset (); /* ATAPI Drives seems to need a proper IDE Reset */
600
601 #ifdef CONFIG_IDE_8xx_DIRECT
602 /* PCMCIA / IDE initialization for common mem space */
603 pcmp->pcmc_pgcrb = 0;
604
605 /* start in PIO mode 0 - most relaxed timings */
606 pio_mode = 0;
607 set_pcmcia_timing (pio_mode);
608 #endif /* CONFIG_IDE_8xx_DIRECT */
609
610 /*
611 * Wait for IDE to get ready.
612 * According to spec, this can take up to 31 seconds!
613 */
614 #ifndef CONFIG_AMIGAONEG3SE
615 for (bus=0; bus<CFG_IDE_MAXBUS; ++bus) {
616 int dev = bus * (CFG_IDE_MAXDEVICE / CFG_IDE_MAXBUS);
617 #else
618 s = getenv("ide_maxbus");
619 if (s)
620 max_bus_scan = simple_strtol(s, NULL, 10);
621 else
622 max_bus_scan = CFG_IDE_MAXBUS;
623
624 for (bus=0; bus<max_bus_scan; ++bus) {
625 int dev = bus * (CFG_IDE_MAXDEVICE / max_bus_scan);
626 #endif
627
628 #ifdef CONFIG_IDE_8xx_PCCARD
629 /* Skip non-ide devices from probing */
630 if ((ide_devices_found & (1 << bus)) == 0) {
631 ide_led ((LED_IDE1 | LED_IDE2), 0); /* LED's off */
632 continue;
633 }
634 #endif
635 printf ("Bus %d: ", bus);
636
637 ide_bus_ok[bus] = 0;
638
639 /* Select device
640 */
641 udelay (100000); /* 100 ms */
642 ide_outb (dev, ATA_DEV_HD, ATA_LBA | ATA_DEVICE(dev));
643 udelay (100000); /* 100 ms */
644 #if defined(CONFIG_AMIGAONEG3SE) || defined(CONFIG_SC3)
645 if ((s = getenv("ide_reset_timeout")) != NULL)
646 ata_reset_time = simple_strtol(s, NULL, 10);
647 #endif
648 i = 0;
649 do {
650 udelay (10000); /* 10 ms */
651
652 c = ide_inb (dev, ATA_STATUS);
653 i++;
654 #if defined(CONFIG_AMIGAONEG3SE) || defined(CONFIG_SC3)
655 if (i > (ata_reset_time * 100)) {
656 #else
657 if (i > (ATA_RESET_TIME * 100)) {
658 #endif
659 puts ("** Timeout **\n");
660 ide_led ((LED_IDE1 | LED_IDE2), 0); /* LED's off */
661 #ifdef CONFIG_AMIGAONEG3SE
662 /* If this is the second bus, the first one was OK */
663 if (bus != 0) {
664 ide_bus_ok[bus] = 0;
665 goto skip_bus;
666 }
667 #endif
668 return;
669 }
670 if ((i >= 100) && ((i%100)==0)) {
671 putc ('.');
672 }
673 } while (c & ATA_STAT_BUSY);
674
675 if (c & (ATA_STAT_BUSY | ATA_STAT_FAULT)) {
676 puts ("not available ");
677 debug ("Status = 0x%02X ", c);
678 #ifndef CONFIG_ATAPI /* ATAPI Devices do not set DRDY */
679 } else if ((c & ATA_STAT_READY) == 0) {
680 puts ("not available ");
681 debug ("Status = 0x%02X ", c);
682 #endif
683 } else {
684 puts ("OK ");
685 ide_bus_ok[bus] = 1;
686 }
687 WATCHDOG_RESET();
688 }
689
690 #ifdef CONFIG_AMIGAONEG3SE
691 skip_bus:
692 #endif
693 putc ('\n');
694
695 ide_led ((LED_IDE1 | LED_IDE2), 0); /* LED's off */
696
697 curr_device = -1;
698 for (i=0; i<CFG_IDE_MAXDEVICE; ++i) {
699 #ifdef CONFIG_IDE_LED
700 int led = (IDE_BUS(i) == 0) ? LED_IDE1 : LED_IDE2;
701 #endif
702 ide_dev_desc[i].type=DEV_TYPE_UNKNOWN;
703 ide_dev_desc[i].if_type=IF_TYPE_IDE;
704 ide_dev_desc[i].dev=i;
705 ide_dev_desc[i].part_type=PART_TYPE_UNKNOWN;
706 ide_dev_desc[i].blksz=0;
707 ide_dev_desc[i].lba=0;
708 ide_dev_desc[i].block_read=ide_read;
709 if (!ide_bus_ok[IDE_BUS(i)])
710 continue;
711 ide_led (led, 1); /* LED on */
712 ide_ident(&ide_dev_desc[i]);
713 ide_led (led, 0); /* LED off */
714 dev_print(&ide_dev_desc[i]);
715 /* ide_print (i); */
716 if ((ide_dev_desc[i].lba > 0) && (ide_dev_desc[i].blksz > 0)) {
717 init_part (&ide_dev_desc[i]); /* initialize partition type */
718 if (curr_device < 0)
719 curr_device = i;
720 }
721 }
722 WATCHDOG_RESET();
723 }
724
725 /* ------------------------------------------------------------------------- */
726
727 block_dev_desc_t * ide_get_dev(int dev)
728 {
729 return (dev < CFG_IDE_MAXDEVICE) ? &ide_dev_desc[dev] : NULL;
730 }
731
732
733 #ifdef CONFIG_IDE_8xx_DIRECT
734
735 static void
736 set_pcmcia_timing (int pmode)
737 {
738 volatile immap_t *immr = (immap_t *)CFG_IMMR;
739 volatile pcmconf8xx_t *pcmp = &(immr->im_pcmcia);
740 ulong timings;
741
742 debug ("Set timing for PIO Mode %d\n", pmode);
743
744 timings = PCMCIA_SHT(pio_config_clk[pmode].t_hold)
745 | PCMCIA_SST(pio_config_clk[pmode].t_setup)
746 | PCMCIA_SL (pio_config_clk[pmode].t_length)
747 ;
748
749 /* IDE 0
750 */
751 pcmp->pcmc_pbr0 = CFG_PCMCIA_PBR0;
752 pcmp->pcmc_por0 = CFG_PCMCIA_POR0
753 #if (CFG_PCMCIA_POR0 != 0)
754 | timings
755 #endif
756 ;
757 debug ("PBR0: %08x POR0: %08x\n", pcmp->pcmc_pbr0, pcmp->pcmc_por0);
758
759 pcmp->pcmc_pbr1 = CFG_PCMCIA_PBR1;
760 pcmp->pcmc_por1 = CFG_PCMCIA_POR1
761 #if (CFG_PCMCIA_POR1 != 0)
762 | timings
763 #endif
764 ;
765 debug ("PBR1: %08x POR1: %08x\n", pcmp->pcmc_pbr1, pcmp->pcmc_por1);
766
767 pcmp->pcmc_pbr2 = CFG_PCMCIA_PBR2;
768 pcmp->pcmc_por2 = CFG_PCMCIA_POR2
769 #if (CFG_PCMCIA_POR2 != 0)
770 | timings
771 #endif
772 ;
773 debug ("PBR2: %08x POR2: %08x\n", pcmp->pcmc_pbr2, pcmp->pcmc_por2);
774
775 pcmp->pcmc_pbr3 = CFG_PCMCIA_PBR3;
776 pcmp->pcmc_por3 = CFG_PCMCIA_POR3
777 #if (CFG_PCMCIA_POR3 != 0)
778 | timings
779 #endif
780 ;
781 debug ("PBR3: %08x POR3: %08x\n", pcmp->pcmc_pbr3, pcmp->pcmc_por3);
782
783 /* IDE 1
784 */
785 pcmp->pcmc_pbr4 = CFG_PCMCIA_PBR4;
786 pcmp->pcmc_por4 = CFG_PCMCIA_POR4
787 #if (CFG_PCMCIA_POR4 != 0)
788 | timings
789 #endif
790 ;
791 debug ("PBR4: %08x POR4: %08x\n", pcmp->pcmc_pbr4, pcmp->pcmc_por4);
792
793 pcmp->pcmc_pbr5 = CFG_PCMCIA_PBR5;
794 pcmp->pcmc_por5 = CFG_PCMCIA_POR5
795 #if (CFG_PCMCIA_POR5 != 0)
796 | timings
797 #endif
798 ;
799 debug ("PBR5: %08x POR5: %08x\n", pcmp->pcmc_pbr5, pcmp->pcmc_por5);
800
801 pcmp->pcmc_pbr6 = CFG_PCMCIA_PBR6;
802 pcmp->pcmc_por6 = CFG_PCMCIA_POR6
803 #if (CFG_PCMCIA_POR6 != 0)
804 | timings
805 #endif
806 ;
807 debug ("PBR6: %08x POR6: %08x\n", pcmp->pcmc_pbr6, pcmp->pcmc_por6);
808
809 pcmp->pcmc_pbr7 = CFG_PCMCIA_PBR7;
810 pcmp->pcmc_por7 = CFG_PCMCIA_POR7
811 #if (CFG_PCMCIA_POR7 != 0)
812 | timings
813 #endif
814 ;
815 debug ("PBR7: %08x POR7: %08x\n", pcmp->pcmc_pbr7, pcmp->pcmc_por7);
816
817 }
818
819 #endif /* CONFIG_IDE_8xx_DIRECT */
820
821 /* ------------------------------------------------------------------------- */
822
823 void inline
824 __ide_outb(int dev, int port, unsigned char val)
825 {
826 debug ("ide_outb (dev= %d, port= 0x%x, val= 0x%02x) : @ 0x%08lx\n",
827 dev, port, val, (ATA_CURR_BASE(dev)+CFG_ATA_PORT_ADDR(port)));
828 outb(val, (ATA_CURR_BASE(dev)+CFG_ATA_PORT_ADDR(port)));
829 }
830 void inline ide_outb (int dev, int port, unsigned char val)
831 __attribute__((weak, alias("__ide_outb")));
832
833 unsigned char inline
834 __ide_inb(int dev, int port)
835 {
836 uchar val;
837 val = inb((ATA_CURR_BASE(dev)+CFG_ATA_PORT_ADDR(port)));
838 debug ("ide_inb (dev= %d, port= 0x%x) : @ 0x%08lx -> 0x%02x\n",
839 dev, port, (ATA_CURR_BASE(dev)+CFG_ATA_PORT_ADDR(port)), val);
840 return val;
841 }
842 unsigned char inline ide_inb(int dev, int port)
843 __attribute__((weak, alias("__ide_inb")));
844
845 #ifdef __PPC__
846 # ifdef CONFIG_AMIGAONEG3SE
847 static void
848 output_data_short(int dev, ulong *sect_buf, int words)
849 {
850 ushort *dbuf;
851 volatile ushort *pbuf;
852
853 pbuf = (ushort *)(ATA_CURR_BASE(dev)+ATA_DATA_REG);
854 dbuf = (ushort *)sect_buf;
855 while (words--) {
856 EIEIO;
857 *pbuf = *dbuf++;
858 EIEIO;
859 }
860
861 if (words&1)
862 *pbuf = 0;
863 }
864 # endif /* CONFIG_AMIGAONEG3SE */
865 #endif /* __PPC_ */
866
867 /* We only need to swap data if we are running on a big endian cpu. */
868 /* But Au1x00 cpu:s already swaps data in big endian mode! */
869 #if defined(__LITTLE_ENDIAN) || ( defined(CONFIG_AU1X00) && !defined(CONFIG_GTH2) )
870 #define input_swap_data(x,y,z) input_data(x,y,z)
871 #else
872 static void
873 input_swap_data(int dev, ulong *sect_buf, int words)
874 {
875 #if defined(CONFIG_HMI10) || defined(CONFIG_CPC45)
876 uchar i;
877 volatile uchar *pbuf_even = (uchar *)(ATA_CURR_BASE(dev)+ATA_DATA_EVEN);
878 volatile uchar *pbuf_odd = (uchar *)(ATA_CURR_BASE(dev)+ATA_DATA_ODD);
879 ushort *dbuf = (ushort *)sect_buf;
880
881 while (words--) {
882 for (i=0; i<2; i++) {
883 *(((uchar *)(dbuf)) + 1) = *pbuf_even;
884 *(uchar *)dbuf = *pbuf_odd;
885 dbuf+=1;
886 }
887 }
888 #else
889 volatile ushort *pbuf = (ushort *)(ATA_CURR_BASE(dev)+ATA_DATA_REG);
890 ushort *dbuf = (ushort *)sect_buf;
891
892 debug("in input swap data base for read is %lx\n", (unsigned long) pbuf);
893
894 while (words--) {
895 #ifdef __MIPS__
896 *dbuf++ = swab16p((u16*)pbuf);
897 *dbuf++ = swab16p((u16*)pbuf);
898 #elif defined(CONFIG_PCS440EP)
899 *dbuf++ = *pbuf;
900 *dbuf++ = *pbuf;
901 #else
902 *dbuf++ = ld_le16(pbuf);
903 *dbuf++ = ld_le16(pbuf);
904 #endif /* !MIPS */
905 }
906 #endif
907 }
908 #endif /* __LITTLE_ENDIAN || CONFIG_AU1X00 */
909
910
911 #if defined(__PPC__) || defined(CONFIG_PXA_PCMCIA) || defined(CONFIG_SH)
912 static void
913 output_data(int dev, ulong *sect_buf, int words)
914 {
915 #if defined(CONFIG_HMI10) || defined(CONFIG_CPC45)
916 uchar *dbuf;
917 volatile uchar *pbuf_even;
918 volatile uchar *pbuf_odd;
919
920 pbuf_even = (uchar *)(ATA_CURR_BASE(dev)+ATA_DATA_EVEN);
921 pbuf_odd = (uchar *)(ATA_CURR_BASE(dev)+ATA_DATA_ODD);
922 dbuf = (uchar *)sect_buf;
923 while (words--) {
924 EIEIO;
925 *pbuf_even = *dbuf++;
926 EIEIO;
927 *pbuf_odd = *dbuf++;
928 EIEIO;
929 *pbuf_even = *dbuf++;
930 EIEIO;
931 *pbuf_odd = *dbuf++;
932 }
933 #else
934 ushort *dbuf;
935 volatile ushort *pbuf;
936
937 pbuf = (ushort *)(ATA_CURR_BASE(dev)+ATA_DATA_REG);
938 dbuf = (ushort *)sect_buf;
939 while (words--) {
940 #if defined(CONFIG_PCS440EP)
941 /* not tested, because CF was write protected */
942 EIEIO;
943 *pbuf = ld_le16(dbuf++);
944 EIEIO;
945 *pbuf = ld_le16(dbuf++);
946 #else
947 EIEIO;
948 *pbuf = *dbuf++;
949 EIEIO;
950 *pbuf = *dbuf++;
951 #endif
952 }
953 #endif
954 }
955 #else /* ! __PPC__ */
956 static void
957 output_data(int dev, ulong *sect_buf, int words)
958 {
959 outsw(ATA_CURR_BASE(dev)+ATA_DATA_REG, sect_buf, words<<1);
960 }
961 #endif /* __PPC__ */
962
963 #if defined(__PPC__) || defined(CONFIG_PXA_PCMCIA) || defined(CONFIG_SH)
964 static void
965 input_data(int dev, ulong *sect_buf, int words)
966 {
967 #if defined(CONFIG_HMI10) || defined(CONFIG_CPC45)
968 uchar *dbuf;
969 volatile uchar *pbuf_even;
970 volatile uchar *pbuf_odd;
971
972 pbuf_even = (uchar *)(ATA_CURR_BASE(dev)+ATA_DATA_EVEN);
973 pbuf_odd = (uchar *)(ATA_CURR_BASE(dev)+ATA_DATA_ODD);
974 dbuf = (uchar *)sect_buf;
975 while (words--) {
976 *dbuf++ = *pbuf_even;
977 EIEIO;
978 SYNC;
979 *dbuf++ = *pbuf_odd;
980 EIEIO;
981 SYNC;
982 *dbuf++ = *pbuf_even;
983 EIEIO;
984 SYNC;
985 *dbuf++ = *pbuf_odd;
986 EIEIO;
987 SYNC;
988 }
989 #else
990 ushort *dbuf;
991 volatile ushort *pbuf;
992
993 pbuf = (ushort *)(ATA_CURR_BASE(dev)+ATA_DATA_REG);
994 dbuf = (ushort *)sect_buf;
995
996 debug("in input data base for read is %lx\n", (unsigned long) pbuf);
997
998 while (words--) {
999 #if defined(CONFIG_PCS440EP)
1000 EIEIO;
1001 *dbuf++ = ld_le16(pbuf);
1002 EIEIO;
1003 *dbuf++ = ld_le16(pbuf);
1004 #else
1005 EIEIO;
1006 *dbuf++ = *pbuf;
1007 EIEIO;
1008 *dbuf++ = *pbuf;
1009 #endif
1010 }
1011 #endif
1012 }
1013 #else /* ! __PPC__ */
1014 static void
1015 input_data(int dev, ulong *sect_buf, int words)
1016 {
1017 insw(ATA_CURR_BASE(dev)+ATA_DATA_REG, sect_buf, words << 1);
1018 }
1019
1020 #endif /* __PPC__ */
1021
1022 #ifdef CONFIG_AMIGAONEG3SE
1023 static void
1024 input_data_short(int dev, ulong *sect_buf, int words)
1025 {
1026 ushort *dbuf;
1027 volatile ushort *pbuf;
1028
1029 pbuf = (ushort *)(ATA_CURR_BASE(dev)+ATA_DATA_REG);
1030 dbuf = (ushort *)sect_buf;
1031 while (words--) {
1032 EIEIO;
1033 *dbuf++ = *pbuf;
1034 EIEIO;
1035 }
1036
1037 if (words&1) {
1038 ushort dummy;
1039 dummy = *pbuf;
1040 }
1041 }
1042 #endif
1043
1044 /* -------------------------------------------------------------------------
1045 */
1046 static void ide_ident (block_dev_desc_t *dev_desc)
1047 {
1048 ulong iobuf[ATA_SECTORWORDS];
1049 unsigned char c;
1050 hd_driveid_t *iop = (hd_driveid_t *)iobuf;
1051
1052 #ifdef CONFIG_AMIGAONEG3SE
1053 int max_bus_scan;
1054 char *s;
1055 #endif
1056 #ifdef CONFIG_ATAPI
1057 int retries = 0;
1058 int do_retry = 0;
1059 #endif
1060
1061 #if 0
1062 int mode, cycle_time;
1063 #endif
1064 int device;
1065 device=dev_desc->dev;
1066 printf (" Device %d: ", device);
1067
1068 #ifdef CONFIG_AMIGAONEG3SE
1069 s = getenv("ide_maxbus");
1070 if (s) {
1071 max_bus_scan = simple_strtol(s, NULL, 10);
1072 } else {
1073 max_bus_scan = CFG_IDE_MAXBUS;
1074 }
1075 if (device >= max_bus_scan*2) {
1076 dev_desc->type=DEV_TYPE_UNKNOWN;
1077 return;
1078 }
1079 #endif
1080
1081 ide_led (DEVICE_LED(device), 1); /* LED on */
1082 /* Select device
1083 */
1084 ide_outb (device, ATA_DEV_HD, ATA_LBA | ATA_DEVICE(device));
1085 dev_desc->if_type=IF_TYPE_IDE;
1086 #ifdef CONFIG_ATAPI
1087
1088 do_retry = 0;
1089 retries = 0;
1090
1091 /* Warning: This will be tricky to read */
1092 while (retries <= 1) {
1093 /* check signature */
1094 if ((ide_inb(device,ATA_SECT_CNT) == 0x01) &&
1095 (ide_inb(device,ATA_SECT_NUM) == 0x01) &&
1096 (ide_inb(device,ATA_CYL_LOW) == 0x14) &&
1097 (ide_inb(device,ATA_CYL_HIGH) == 0xEB)) {
1098 /* ATAPI Signature found */
1099 dev_desc->if_type=IF_TYPE_ATAPI;
1100 /* Start Ident Command
1101 */
1102 ide_outb (device, ATA_COMMAND, ATAPI_CMD_IDENT);
1103 /*
1104 * Wait for completion - ATAPI devices need more time
1105 * to become ready
1106 */
1107 c = ide_wait (device, ATAPI_TIME_OUT);
1108 } else
1109 #endif
1110 {
1111 /* Start Ident Command
1112 */
1113 ide_outb (device, ATA_COMMAND, ATA_CMD_IDENT);
1114
1115 /* Wait for completion
1116 */
1117 c = ide_wait (device, IDE_TIME_OUT);
1118 }
1119 ide_led (DEVICE_LED(device), 0); /* LED off */
1120
1121 if (((c & ATA_STAT_DRQ) == 0) ||
1122 ((c & (ATA_STAT_FAULT|ATA_STAT_ERR)) != 0) ) {
1123 #ifdef CONFIG_ATAPI
1124 #ifdef CONFIG_AMIGAONEG3SE
1125 s = getenv("ide_doreset");
1126 if (s && strcmp(s, "on") == 0)
1127 #endif
1128 {
1129 /* Need to soft reset the device in case it's an ATAPI... */
1130 debug ("Retrying...\n");
1131 ide_outb (device, ATA_DEV_HD, ATA_LBA | ATA_DEVICE(device));
1132 udelay(100000);
1133 ide_outb (device, ATA_COMMAND, 0x08);
1134 udelay (500000); /* 500 ms */
1135 }
1136 /* Select device
1137 */
1138 ide_outb (device, ATA_DEV_HD, ATA_LBA | ATA_DEVICE(device));
1139 retries++;
1140 #else
1141 return;
1142 #endif
1143 }
1144 #ifdef CONFIG_ATAPI
1145 else
1146 break;
1147 } /* see above - ugly to read */
1148
1149 if (retries == 2) /* Not found */
1150 return;
1151 #endif
1152
1153 input_swap_data (device, iobuf, ATA_SECTORWORDS);
1154
1155 ident_cpy ((unsigned char*)dev_desc->revision, iop->fw_rev, sizeof(dev_desc->revision));
1156 ident_cpy ((unsigned char*)dev_desc->vendor, iop->model, sizeof(dev_desc->vendor));
1157 ident_cpy ((unsigned char*)dev_desc->product, iop->serial_no, sizeof(dev_desc->product));
1158 #ifdef __LITTLE_ENDIAN
1159 /*
1160 * firmware revision and model number have Big Endian Byte
1161 * order in Word. Convert both to little endian.
1162 *
1163 * See CF+ and CompactFlash Specification Revision 2.0:
1164 * 6.2.1.6: Identfy Drive, Table 39 for more details
1165 */
1166
1167 strswab (dev_desc->revision);
1168 strswab (dev_desc->vendor);
1169 #endif /* __LITTLE_ENDIAN */
1170
1171 if ((iop->config & 0x0080)==0x0080)
1172 dev_desc->removable = 1;
1173 else
1174 dev_desc->removable = 0;
1175
1176 #if 0
1177 /*
1178 * Drive PIO mode autoselection
1179 */
1180 mode = iop->tPIO;
1181
1182 printf ("tPIO = 0x%02x = %d\n",mode, mode);
1183 if (mode > 2) { /* 2 is maximum allowed tPIO value */
1184 mode = 2;
1185 debug ("Override tPIO -> 2\n");
1186 }
1187 if (iop->field_valid & 2) { /* drive implements ATA2? */
1188 debug ("Drive implements ATA2\n");
1189 if (iop->capability & 8) { /* drive supports use_iordy? */
1190 cycle_time = iop->eide_pio_iordy;
1191 } else {
1192 cycle_time = iop->eide_pio;
1193 }
1194 debug ("cycle time = %d\n", cycle_time);
1195 mode = 4;
1196 if (cycle_time > 120) mode = 3; /* 120 ns for PIO mode 4 */
1197 if (cycle_time > 180) mode = 2; /* 180 ns for PIO mode 3 */
1198 if (cycle_time > 240) mode = 1; /* 240 ns for PIO mode 4 */
1199 if (cycle_time > 383) mode = 0; /* 383 ns for PIO mode 4 */
1200 }
1201 printf ("PIO mode to use: PIO %d\n", mode);
1202 #endif /* 0 */
1203
1204 #ifdef CONFIG_ATAPI
1205 if (dev_desc->if_type==IF_TYPE_ATAPI) {
1206 atapi_inquiry(dev_desc);
1207 return;
1208 }
1209 #endif /* CONFIG_ATAPI */
1210
1211 #ifdef __BIG_ENDIAN
1212 /* swap shorts */
1213 dev_desc->lba = (iop->lba_capacity << 16) | (iop->lba_capacity >> 16);
1214 #else /* ! __BIG_ENDIAN */
1215 /*
1216 * do not swap shorts on little endian
1217 *
1218 * See CF+ and CompactFlash Specification Revision 2.0:
1219 * 6.2.1.6: Identfy Drive, Table 39, Word Address 57-58 for details.
1220 */
1221 dev_desc->lba = iop->lba_capacity;
1222 #endif /* __BIG_ENDIAN */
1223
1224 #ifdef CONFIG_LBA48
1225 if (iop->command_set_2 & 0x0400) { /* LBA 48 support */
1226 dev_desc->lba48 = 1;
1227 dev_desc->lba = (unsigned long long)iop->lba48_capacity[0] |
1228 ((unsigned long long)iop->lba48_capacity[1] << 16) |
1229 ((unsigned long long)iop->lba48_capacity[2] << 32) |
1230 ((unsigned long long)iop->lba48_capacity[3] << 48);
1231 } else {
1232 dev_desc->lba48 = 0;
1233 }
1234 #endif /* CONFIG_LBA48 */
1235 /* assuming HD */
1236 dev_desc->type=DEV_TYPE_HARDDISK;
1237 dev_desc->blksz=ATA_BLOCKSIZE;
1238 dev_desc->lun=0; /* just to fill something in... */
1239
1240 #if 0 /* only used to test the powersaving mode,
1241 * if enabled, the drive goes after 5 sec
1242 * in standby mode */
1243 ide_outb (device, ATA_DEV_HD, ATA_LBA | ATA_DEVICE(device));
1244 c = ide_wait (device, IDE_TIME_OUT);
1245 ide_outb (device, ATA_SECT_CNT, 1);
1246 ide_outb (device, ATA_LBA_LOW, 0);
1247 ide_outb (device, ATA_LBA_MID, 0);
1248 ide_outb (device, ATA_LBA_HIGH, 0);
1249 ide_outb (device, ATA_DEV_HD, ATA_LBA | ATA_DEVICE(device));
1250 ide_outb (device, ATA_COMMAND, 0xe3);
1251 udelay (50);
1252 c = ide_wait (device, IDE_TIME_OUT); /* can't take over 500 ms */
1253 #endif
1254 }
1255
1256
1257 /* ------------------------------------------------------------------------- */
1258
1259 ulong ide_read (int device, lbaint_t blknr, ulong blkcnt, void *buffer)
1260 {
1261 ulong n = 0;
1262 unsigned char c;
1263 unsigned char pwrsave=0; /* power save */
1264 #ifdef CONFIG_LBA48
1265 unsigned char lba48 = 0;
1266
1267 if (blknr & 0x0000fffff0000000) {
1268 /* more than 28 bits used, use 48bit mode */
1269 lba48 = 1;
1270 }
1271 #endif
1272 debug ("ide_read dev %d start %qX, blocks %lX buffer at %lX\n",
1273 device, blknr, blkcnt, (ulong)buffer);
1274
1275 ide_led (DEVICE_LED(device), 1); /* LED on */
1276
1277 /* Select device
1278 */
1279 ide_outb (device, ATA_DEV_HD, ATA_LBA | ATA_DEVICE(device));
1280 c = ide_wait (device, IDE_TIME_OUT);
1281
1282 if (c & ATA_STAT_BUSY) {
1283 printf ("IDE read: device %d not ready\n", device);
1284 goto IDE_READ_E;
1285 }
1286
1287 /* first check if the drive is in Powersaving mode, if yes,
1288 * increase the timeout value */
1289 ide_outb (device, ATA_COMMAND, ATA_CMD_CHK_PWR);
1290 udelay (50);
1291
1292 c = ide_wait (device, IDE_TIME_OUT); /* can't take over 500 ms */
1293
1294 if (c & ATA_STAT_BUSY) {
1295 printf ("IDE read: device %d not ready\n", device);
1296 goto IDE_READ_E;
1297 }
1298 if ((c & ATA_STAT_ERR) == ATA_STAT_ERR) {
1299 printf ("No Powersaving mode %X\n", c);
1300 } else {
1301 c = ide_inb(device,ATA_SECT_CNT);
1302 debug ("Powersaving %02X\n",c);
1303 if(c==0)
1304 pwrsave=1;
1305 }
1306
1307
1308 while (blkcnt-- > 0) {
1309
1310 c = ide_wait (device, IDE_TIME_OUT);
1311
1312 if (c & ATA_STAT_BUSY) {
1313 printf ("IDE read: device %d not ready\n", device);
1314 break;
1315 }
1316 #ifdef CONFIG_LBA48
1317 if (lba48) {
1318 /* write high bits */
1319 ide_outb (device, ATA_SECT_CNT, 0);
1320 ide_outb (device, ATA_LBA_LOW, (blknr >> 24) & 0xFF);
1321 ide_outb (device, ATA_LBA_MID, (blknr >> 32) & 0xFF);
1322 ide_outb (device, ATA_LBA_HIGH, (blknr >> 40) & 0xFF);
1323 }
1324 #endif
1325 ide_outb (device, ATA_SECT_CNT, 1);
1326 ide_outb (device, ATA_LBA_LOW, (blknr >> 0) & 0xFF);
1327 ide_outb (device, ATA_LBA_MID, (blknr >> 8) & 0xFF);
1328 ide_outb (device, ATA_LBA_HIGH, (blknr >> 16) & 0xFF);
1329
1330 #ifdef CONFIG_LBA48
1331 if (lba48) {
1332 ide_outb (device, ATA_DEV_HD, ATA_LBA | ATA_DEVICE(device) );
1333 ide_outb (device, ATA_COMMAND, ATA_CMD_READ_EXT);
1334
1335 } else
1336 #endif
1337 {
1338 ide_outb (device, ATA_DEV_HD, ATA_LBA |
1339 ATA_DEVICE(device) |
1340 ((blknr >> 24) & 0xF) );
1341 ide_outb (device, ATA_COMMAND, ATA_CMD_READ);
1342 }
1343
1344 udelay (50);
1345
1346 if(pwrsave) {
1347 c = ide_wait (device, IDE_SPIN_UP_TIME_OUT); /* may take up to 4 sec */
1348 pwrsave=0;
1349 } else {
1350 c = ide_wait (device, IDE_TIME_OUT); /* can't take over 500 ms */
1351 }
1352
1353 if ((c&(ATA_STAT_DRQ|ATA_STAT_BUSY|ATA_STAT_ERR)) != ATA_STAT_DRQ) {
1354 #if defined(CFG_64BIT_LBA) && defined(CFG_64BIT_VSPRINTF)
1355 printf ("Error (no IRQ) dev %d blk %qd: status 0x%02x\n",
1356 device, blknr, c);
1357 #else
1358 printf ("Error (no IRQ) dev %d blk %ld: status 0x%02x\n",
1359 device, (ulong)blknr, c);
1360 #endif
1361 break;
1362 }
1363
1364 input_data (device, buffer, ATA_SECTORWORDS);
1365 (void) ide_inb (device, ATA_STATUS); /* clear IRQ */
1366
1367 ++n;
1368 ++blknr;
1369 buffer += ATA_BLOCKSIZE;
1370 }
1371 IDE_READ_E:
1372 ide_led (DEVICE_LED(device), 0); /* LED off */
1373 return (n);
1374 }
1375
1376 /* ------------------------------------------------------------------------- */
1377
1378
1379 ulong ide_write (int device, lbaint_t blknr, ulong blkcnt, void *buffer)
1380 {
1381 ulong n = 0;
1382 unsigned char c;
1383 #ifdef CONFIG_LBA48
1384 unsigned char lba48 = 0;
1385
1386 if (blknr & 0x0000fffff0000000) {
1387 /* more than 28 bits used, use 48bit mode */
1388 lba48 = 1;
1389 }
1390 #endif
1391
1392 ide_led (DEVICE_LED(device), 1); /* LED on */
1393
1394 /* Select device
1395 */
1396 ide_outb (device, ATA_DEV_HD, ATA_LBA | ATA_DEVICE(device));
1397
1398 while (blkcnt-- > 0) {
1399
1400 c = ide_wait (device, IDE_TIME_OUT);
1401
1402 if (c & ATA_STAT_BUSY) {
1403 printf ("IDE read: device %d not ready\n", device);
1404 goto WR_OUT;
1405 }
1406 #ifdef CONFIG_LBA48
1407 if (lba48) {
1408 /* write high bits */
1409 ide_outb (device, ATA_SECT_CNT, 0);
1410 ide_outb (device, ATA_LBA_LOW, (blknr >> 24) & 0xFF);
1411 ide_outb (device, ATA_LBA_MID, (blknr >> 32) & 0xFF);
1412 ide_outb (device, ATA_LBA_HIGH, (blknr >> 40) & 0xFF);
1413 }
1414 #endif
1415 ide_outb (device, ATA_SECT_CNT, 1);
1416 ide_outb (device, ATA_LBA_LOW, (blknr >> 0) & 0xFF);
1417 ide_outb (device, ATA_LBA_MID, (blknr >> 8) & 0xFF);
1418 ide_outb (device, ATA_LBA_HIGH, (blknr >> 16) & 0xFF);
1419
1420 #ifdef CONFIG_LBA48
1421 if (lba48) {
1422 ide_outb (device, ATA_DEV_HD, ATA_LBA | ATA_DEVICE(device) );
1423 ide_outb (device, ATA_COMMAND, ATA_CMD_WRITE_EXT);
1424
1425 } else
1426 #endif
1427 {
1428 ide_outb (device, ATA_DEV_HD, ATA_LBA |
1429 ATA_DEVICE(device) |
1430 ((blknr >> 24) & 0xF) );
1431 ide_outb (device, ATA_COMMAND, ATA_CMD_WRITE);
1432 }
1433
1434 udelay (50);
1435
1436 c = ide_wait (device, IDE_TIME_OUT); /* can't take over 500 ms */
1437
1438 if ((c&(ATA_STAT_DRQ|ATA_STAT_BUSY|ATA_STAT_ERR)) != ATA_STAT_DRQ) {
1439 #if defined(CFG_64BIT_LBA) && defined(CFG_64BIT_VSPRINTF)
1440 printf ("Error (no IRQ) dev %d blk %qd: status 0x%02x\n",
1441 device, blknr, c);
1442 #else
1443 printf ("Error (no IRQ) dev %d blk %ld: status 0x%02x\n",
1444 device, (ulong)blknr, c);
1445 #endif
1446 goto WR_OUT;
1447 }
1448
1449 output_data (device, buffer, ATA_SECTORWORDS);
1450 c = ide_inb (device, ATA_STATUS); /* clear IRQ */
1451 ++n;
1452 ++blknr;
1453 buffer += ATA_BLOCKSIZE;
1454 }
1455 WR_OUT:
1456 ide_led (DEVICE_LED(device), 0); /* LED off */
1457 return (n);
1458 }
1459
1460 /* ------------------------------------------------------------------------- */
1461
1462 /*
1463 * copy src to dest, skipping leading and trailing blanks and null
1464 * terminate the string
1465 * "len" is the size of available memory including the terminating '\0'
1466 */
1467 static void ident_cpy (unsigned char *dst, unsigned char *src, unsigned int len)
1468 {
1469 unsigned char *end, *last;
1470
1471 last = dst;
1472 end = src + len - 1;
1473
1474 /* reserve space for '\0' */
1475 if (len < 2)
1476 goto OUT;
1477
1478 /* skip leading white space */
1479 while ((*src) && (src<end) && (*src==' '))
1480 ++src;
1481
1482 /* copy string, omitting trailing white space */
1483 while ((*src) && (src<end)) {
1484 *dst++ = *src;
1485 if (*src++ != ' ')
1486 last = dst;
1487 }
1488 OUT:
1489 *last = '\0';
1490 }
1491
1492 /* ------------------------------------------------------------------------- */
1493
1494 /*
1495 * Wait until Busy bit is off, or timeout (in ms)
1496 * Return last status
1497 */
1498 static uchar ide_wait (int dev, ulong t)
1499 {
1500 ulong delay = 10 * t; /* poll every 100 us */
1501 uchar c;
1502
1503 while ((c = ide_inb(dev, ATA_STATUS)) & ATA_STAT_BUSY) {
1504 udelay (100);
1505 if (delay-- == 0) {
1506 break;
1507 }
1508 }
1509 return (c);
1510 }
1511
1512 /* ------------------------------------------------------------------------- */
1513
1514 #ifdef CONFIG_IDE_RESET
1515 extern void ide_set_reset(int idereset);
1516
1517 static void ide_reset (void)
1518 {
1519 #if defined(CFG_PB_12V_ENABLE) || defined(CFG_PB_IDE_MOTOR)
1520 volatile immap_t *immr = (immap_t *)CFG_IMMR;
1521 #endif
1522 int i;
1523
1524 curr_device = -1;
1525 for (i=0; i<CFG_IDE_MAXBUS; ++i)
1526 ide_bus_ok[i] = 0;
1527 for (i=0; i<CFG_IDE_MAXDEVICE; ++i)
1528 ide_dev_desc[i].type = DEV_TYPE_UNKNOWN;
1529
1530 ide_set_reset (1); /* assert reset */
1531
1532 WATCHDOG_RESET();
1533
1534 #ifdef CFG_PB_12V_ENABLE
1535 immr->im_cpm.cp_pbdat &= ~(CFG_PB_12V_ENABLE); /* 12V Enable output OFF */
1536 immr->im_cpm.cp_pbpar &= ~(CFG_PB_12V_ENABLE);
1537 immr->im_cpm.cp_pbodr &= ~(CFG_PB_12V_ENABLE);
1538 immr->im_cpm.cp_pbdir |= CFG_PB_12V_ENABLE;
1539
1540 /* wait 500 ms for the voltage to stabilize
1541 */
1542 for (i=0; i<500; ++i) {
1543 udelay (1000);
1544 }
1545
1546 immr->im_cpm.cp_pbdat |= CFG_PB_12V_ENABLE; /* 12V Enable output ON */
1547 #endif /* CFG_PB_12V_ENABLE */
1548
1549 #ifdef CFG_PB_IDE_MOTOR
1550 /* configure IDE Motor voltage monitor pin as input */
1551 immr->im_cpm.cp_pbpar &= ~(CFG_PB_IDE_MOTOR);
1552 immr->im_cpm.cp_pbodr &= ~(CFG_PB_IDE_MOTOR);
1553 immr->im_cpm.cp_pbdir &= ~(CFG_PB_IDE_MOTOR);
1554
1555 /* wait up to 1 s for the motor voltage to stabilize
1556 */
1557 for (i=0; i<1000; ++i) {
1558 if ((immr->im_cpm.cp_pbdat & CFG_PB_IDE_MOTOR) != 0) {
1559 break;
1560 }
1561 udelay (1000);
1562 }
1563
1564 if (i == 1000) { /* Timeout */
1565 printf ("\nWarning: 5V for IDE Motor missing\n");
1566 # ifdef CONFIG_STATUS_LED
1567 # ifdef STATUS_LED_YELLOW
1568 status_led_set (STATUS_LED_YELLOW, STATUS_LED_ON );
1569 # endif
1570 # ifdef STATUS_LED_GREEN
1571 status_led_set (STATUS_LED_GREEN, STATUS_LED_OFF);
1572 # endif
1573 # endif /* CONFIG_STATUS_LED */
1574 }
1575 #endif /* CFG_PB_IDE_MOTOR */
1576
1577 WATCHDOG_RESET();
1578
1579 /* de-assert RESET signal */
1580 ide_set_reset(0);
1581
1582 /* wait 250 ms */
1583 for (i=0; i<250; ++i) {
1584 udelay (1000);
1585 }
1586 }
1587
1588 #endif /* CONFIG_IDE_RESET */
1589
1590 /* ------------------------------------------------------------------------- */
1591
1592 #if defined(CONFIG_IDE_LED) && \
1593 !defined(CONFIG_AMIGAONEG3SE)&& \
1594 !defined(CONFIG_CPC45) && \
1595 !defined(CONFIG_HMI10) && \
1596 !defined(CONFIG_KUP4K) && \
1597 !defined(CONFIG_KUP4X)
1598
1599 static uchar led_buffer = 0; /* Buffer for current LED status */
1600
1601 static void ide_led (uchar led, uchar status)
1602 {
1603 uchar *led_port = LED_PORT;
1604
1605 if (status) { /* switch LED on */
1606 led_buffer |= led;
1607 } else { /* switch LED off */
1608 led_buffer &= ~led;
1609 }
1610
1611 *led_port = led_buffer;
1612 }
1613
1614 #endif /* CONFIG_IDE_LED */
1615
1616 /* ------------------------------------------------------------------------- */
1617
1618 #ifdef CONFIG_ATAPI
1619 /****************************************************************************
1620 * ATAPI Support
1621 */
1622
1623 #if defined(__PPC__) || defined(CONFIG_PXA_PCMCIA)
1624 /* since ATAPI may use commands with not 4 bytes alligned length
1625 * we have our own transfer functions, 2 bytes alligned */
1626 static void
1627 output_data_shorts(int dev, ushort *sect_buf, int shorts)
1628 {
1629 #if defined(CONFIG_HMI10) || defined(CONFIG_CPC45)
1630 uchar *dbuf;
1631 volatile uchar *pbuf_even;
1632 volatile uchar *pbuf_odd;
1633
1634 pbuf_even = (uchar *)(ATA_CURR_BASE(dev)+ATA_DATA_EVEN);
1635 pbuf_odd = (uchar *)(ATA_CURR_BASE(dev)+ATA_DATA_ODD);
1636 while (shorts--) {
1637 EIEIO;
1638 *pbuf_even = *dbuf++;
1639 EIEIO;
1640 *pbuf_odd = *dbuf++;
1641 }
1642 #else
1643 ushort *dbuf;
1644 volatile ushort *pbuf;
1645
1646 pbuf = (ushort *)(ATA_CURR_BASE(dev)+ATA_DATA_REG);
1647 dbuf = (ushort *)sect_buf;
1648
1649 debug ("in output data shorts base for read is %lx\n", (unsigned long) pbuf);
1650
1651 while (shorts--) {
1652 EIEIO;
1653 *pbuf = *dbuf++;
1654 }
1655 #endif
1656 }
1657
1658 static void
1659 input_data_shorts(int dev, ushort *sect_buf, int shorts)
1660 {
1661 #if defined(CONFIG_HMI10) || defined(CONFIG_CPC45)
1662 uchar *dbuf;
1663 volatile uchar *pbuf_even;
1664 volatile uchar *pbuf_odd;
1665
1666 pbuf_even = (uchar *)(ATA_CURR_BASE(dev)+ATA_DATA_EVEN);
1667 pbuf_odd = (uchar *)(ATA_CURR_BASE(dev)+ATA_DATA_ODD);
1668 while (shorts--) {
1669 EIEIO;
1670 *dbuf++ = *pbuf_even;
1671 EIEIO;
1672 *dbuf++ = *pbuf_odd;
1673 }
1674 #else
1675 ushort *dbuf;
1676 volatile ushort *pbuf;
1677
1678 pbuf = (ushort *)(ATA_CURR_BASE(dev)+ATA_DATA_REG);
1679 dbuf = (ushort *)sect_buf;
1680
1681 debug("in input data shorts base for read is %lx\n", (unsigned long) pbuf);
1682
1683 while (shorts--) {
1684 EIEIO;
1685 *dbuf++ = *pbuf;
1686 }
1687 #endif
1688 }
1689
1690 #else /* ! __PPC__ */
1691 static void
1692 output_data_shorts(int dev, ushort *sect_buf, int shorts)
1693 {
1694 outsw(ATA_CURR_BASE(dev)+ATA_DATA_REG, sect_buf, shorts);
1695 }
1696
1697 static void
1698 input_data_shorts(int dev, ushort *sect_buf, int shorts)
1699 {
1700 insw(ATA_CURR_BASE(dev)+ATA_DATA_REG, sect_buf, shorts);
1701 }
1702
1703 #endif /* __PPC__ */
1704
1705 /*
1706 * Wait until (Status & mask) == res, or timeout (in ms)
1707 * Return last status
1708 * This is used since some ATAPI CD ROMs clears their Busy Bit first
1709 * and then they set their DRQ Bit
1710 */
1711 static uchar atapi_wait_mask (int dev, ulong t,uchar mask, uchar res)
1712 {
1713 ulong delay = 10 * t; /* poll every 100 us */
1714 uchar c;
1715
1716 c = ide_inb(dev,ATA_DEV_CTL); /* prevents to read the status before valid */
1717 while (((c = ide_inb(dev, ATA_STATUS)) & mask) != res) {
1718 /* break if error occurs (doesn't make sense to wait more) */
1719 if((c & ATA_STAT_ERR)==ATA_STAT_ERR)
1720 break;
1721 udelay (100);
1722 if (delay-- == 0) {
1723 break;
1724 }
1725 }
1726 return (c);
1727 }
1728
1729 /*
1730 * issue an atapi command
1731 */
1732 unsigned char atapi_issue(int device,unsigned char* ccb,int ccblen, unsigned char * buffer,int buflen)
1733 {
1734 unsigned char c,err,mask,res;
1735 int n;
1736 ide_led (DEVICE_LED(device), 1); /* LED on */
1737
1738 /* Select device
1739 */
1740 mask = ATA_STAT_BUSY|ATA_STAT_DRQ;
1741 res = 0;
1742 #ifdef CONFIG_AMIGAONEG3SE
1743 # warning THF: Removed LBA mode ???
1744 #endif
1745 ide_outb (device, ATA_DEV_HD, ATA_LBA | ATA_DEVICE(device));
1746 c = atapi_wait_mask(device,ATAPI_TIME_OUT,mask,res);
1747 if ((c & mask) != res) {
1748 printf ("ATAPI_ISSUE: device %d not ready status %X\n", device,c);
1749 err=0xFF;
1750 goto AI_OUT;
1751 }
1752 /* write taskfile */
1753 ide_outb (device, ATA_ERROR_REG, 0); /* no DMA, no overlaped */
1754 ide_outb (device, ATA_SECT_CNT, 0);
1755 ide_outb (device, ATA_SECT_NUM, 0);
1756 ide_outb (device, ATA_CYL_LOW, (unsigned char)(buflen & 0xFF));
1757 ide_outb (device, ATA_CYL_HIGH, (unsigned char)((buflen>>8) & 0xFF));
1758 #ifdef CONFIG_AMIGAONEG3SE
1759 # warning THF: Removed LBA mode ???
1760 #endif
1761 ide_outb (device, ATA_DEV_HD, ATA_LBA | ATA_DEVICE(device));
1762
1763 ide_outb (device, ATA_COMMAND, ATAPI_CMD_PACKET);
1764 udelay (50);
1765
1766 mask = ATA_STAT_DRQ|ATA_STAT_BUSY|ATA_STAT_ERR;
1767 res = ATA_STAT_DRQ;
1768 c = atapi_wait_mask(device,ATAPI_TIME_OUT,mask,res);
1769
1770 if ((c & mask) != res) { /* DRQ must be 1, BSY 0 */
1771 printf ("ATTAPI_ISSUE: Error (no IRQ) before sending ccb dev %d status 0x%02x\n",device,c);
1772 err=0xFF;
1773 goto AI_OUT;
1774 }
1775
1776 output_data_shorts (device, (unsigned short *)ccb,ccblen/2); /* write command block */
1777 /* ATAPI Command written wait for completition */
1778 udelay (5000); /* device must set bsy */
1779
1780 mask = ATA_STAT_DRQ|ATA_STAT_BUSY|ATA_STAT_ERR;
1781 /* if no data wait for DRQ = 0 BSY = 0
1782 * if data wait for DRQ = 1 BSY = 0 */
1783 res=0;
1784 if(buflen)
1785 res = ATA_STAT_DRQ;
1786 c = atapi_wait_mask(device,ATAPI_TIME_OUT,mask,res);
1787 if ((c & mask) != res ) {
1788 if (c & ATA_STAT_ERR) {
1789 err=(ide_inb(device,ATA_ERROR_REG))>>4;
1790 debug ("atapi_issue 1 returned sense key %X status %02X\n",err,c);
1791 } else {
1792 printf ("ATTAPI_ISSUE: (no DRQ) after sending ccb (%x) status 0x%02x\n", ccb[0],c);
1793 err=0xFF;
1794 }
1795 goto AI_OUT;
1796 }
1797 n=ide_inb(device, ATA_CYL_HIGH);
1798 n<<=8;
1799 n+=ide_inb(device, ATA_CYL_LOW);
1800 if(n>buflen) {
1801 printf("ERROR, transfer bytes %d requested only %d\n",n,buflen);
1802 err=0xff;
1803 goto AI_OUT;
1804 }
1805 if((n==0)&&(buflen<0)) {
1806 printf("ERROR, transfer bytes %d requested %d\n",n,buflen);
1807 err=0xff;
1808 goto AI_OUT;
1809 }
1810 if(n!=buflen) {
1811 debug ("WARNING, transfer bytes %d not equal with requested %d\n",n,buflen);
1812 }
1813 if(n!=0) { /* data transfer */
1814 debug ("ATAPI_ISSUE: %d Bytes to transfer\n",n);
1815 /* we transfer shorts */
1816 n>>=1;
1817 /* ok now decide if it is an in or output */
1818 if ((ide_inb(device, ATA_SECT_CNT)&0x02)==0) {
1819 debug ("Write to device\n");
1820 output_data_shorts(device,(unsigned short *)buffer,n);
1821 } else {
1822 debug ("Read from device @ %p shorts %d\n",buffer,n);
1823 input_data_shorts(device,(unsigned short *)buffer,n);
1824 }
1825 }
1826 udelay(5000); /* seems that some CD ROMs need this... */
1827 mask = ATA_STAT_BUSY|ATA_STAT_ERR;
1828 res=0;
1829 c = atapi_wait_mask(device,ATAPI_TIME_OUT,mask,res);
1830 if ((c & ATA_STAT_ERR) == ATA_STAT_ERR) {
1831 err=(ide_inb(device,ATA_ERROR_REG) >> 4);
1832 debug ("atapi_issue 2 returned sense key %X status %X\n",err,c);
1833 } else {
1834 err = 0;
1835 }
1836 AI_OUT:
1837 ide_led (DEVICE_LED(device), 0); /* LED off */
1838 return (err);
1839 }
1840
1841 /*
1842 * sending the command to atapi_issue. If an status other than good
1843 * returns, an request_sense will be issued
1844 */
1845
1846 #define ATAPI_DRIVE_NOT_READY 100
1847 #define ATAPI_UNIT_ATTN 10
1848
1849 unsigned char atapi_issue_autoreq (int device,
1850 unsigned char* ccb,
1851 int ccblen,
1852 unsigned char *buffer,
1853 int buflen)
1854 {
1855 unsigned char sense_data[18],sense_ccb[12];
1856 unsigned char res,key,asc,ascq;
1857 int notready,unitattn;
1858
1859 #ifdef CONFIG_AMIGAONEG3SE
1860 char *s;
1861 unsigned int timeout, retrycnt;
1862
1863 s = getenv("ide_cd_timeout");
1864 timeout = s ? (simple_strtol(s, NULL, 10)*1000000)/5 : 0;
1865
1866 retrycnt = 0;
1867 #endif
1868
1869 unitattn=ATAPI_UNIT_ATTN;
1870 notready=ATAPI_DRIVE_NOT_READY;
1871
1872 retry:
1873 res= atapi_issue(device,ccb,ccblen,buffer,buflen);
1874 if (res==0)
1875 return (0); /* Ok */
1876
1877 if (res==0xFF)
1878 return (0xFF); /* error */
1879
1880 debug ("(auto_req)atapi_issue returned sense key %X\n",res);
1881
1882 memset(sense_ccb,0,sizeof(sense_ccb));
1883 memset(sense_data,0,sizeof(sense_data));
1884 sense_ccb[0]=ATAPI_CMD_REQ_SENSE;
1885 sense_ccb[4]=18; /* allocation Length */
1886
1887 res=atapi_issue(device,sense_ccb,12,sense_data,18);
1888 key=(sense_data[2]&0xF);
1889 asc=(sense_data[12]);
1890 ascq=(sense_data[13]);
1891
1892 debug ("ATAPI_CMD_REQ_SENSE returned %x\n",res);
1893 debug (" Sense page: %02X key %02X ASC %02X ASCQ %02X\n",
1894 sense_data[0],
1895 key,
1896 asc,
1897 ascq);
1898
1899 if((key==0))
1900 return 0; /* ok device ready */
1901
1902 if((key==6)|| (asc==0x29) || (asc==0x28)) { /* Unit Attention */
1903 if(unitattn-->0) {
1904 udelay(200*1000);
1905 goto retry;
1906 }
1907 printf("Unit Attention, tried %d\n",ATAPI_UNIT_ATTN);
1908 goto error;
1909 }
1910 if((asc==0x4) && (ascq==0x1)) { /* not ready, but will be ready soon */
1911 if (notready-->0) {
1912 udelay(200*1000);
1913 goto retry;
1914 }
1915 printf("Drive not ready, tried %d times\n",ATAPI_DRIVE_NOT_READY);
1916 goto error;
1917 }
1918 if(asc==0x3a) {
1919 debug ("Media not present\n");
1920 goto error;
1921 }
1922
1923 #ifdef CONFIG_AMIGAONEG3SE
1924 if ((sense_data[2]&0xF)==0x0B) {
1925 debug ("ABORTED COMMAND...retry\n");
1926 if (retrycnt++ < 4)
1927 goto retry;
1928 return (0xFF);
1929 }
1930
1931 if ((sense_data[2]&0xf) == 0x02 &&
1932 sense_data[12] == 0x04 &&
1933 sense_data[13] == 0x01 ) {
1934 debug ("Waiting for unit to become active\n");
1935 udelay(timeout);
1936 if (retrycnt++ < 4)
1937 goto retry;
1938 return 0xFF;
1939 }
1940 #endif /* CONFIG_AMIGAONEG3SE */
1941
1942 printf ("ERROR: Unknown Sense key %02X ASC %02X ASCQ %02X\n",key,asc,ascq);
1943 error:
1944 debug ("ERROR Sense key %02X ASC %02X ASCQ %02X\n",key,asc,ascq);
1945 return (0xFF);
1946 }
1947
1948
1949 static void atapi_inquiry(block_dev_desc_t * dev_desc)
1950 {
1951 unsigned char ccb[12]; /* Command descriptor block */
1952 unsigned char iobuf[64]; /* temp buf */
1953 unsigned char c;
1954 int device;
1955
1956 device=dev_desc->dev;
1957 dev_desc->type=DEV_TYPE_UNKNOWN; /* not yet valid */
1958 dev_desc->block_read=atapi_read;
1959
1960 memset(ccb,0,sizeof(ccb));
1961 memset(iobuf,0,sizeof(iobuf));
1962
1963 ccb[0]=ATAPI_CMD_INQUIRY;
1964 ccb[4]=40; /* allocation Legnth */
1965 c=atapi_issue_autoreq(device,ccb,12,(unsigned char *)iobuf,40);
1966
1967 debug ("ATAPI_CMD_INQUIRY returned %x\n",c);
1968 if (c!=0)
1969 return;
1970
1971 /* copy device ident strings */
1972 ident_cpy((unsigned char*)dev_desc->vendor,&iobuf[8],8);
1973 ident_cpy((unsigned char*)dev_desc->product,&iobuf[16],16);
1974 ident_cpy((unsigned char*)dev_desc->revision,&iobuf[32],5);
1975
1976 dev_desc->lun=0;
1977 dev_desc->lba=0;
1978 dev_desc->blksz=0;
1979 dev_desc->type=iobuf[0] & 0x1f;
1980
1981 if ((iobuf[1]&0x80)==0x80)
1982 dev_desc->removable = 1;
1983 else
1984 dev_desc->removable = 0;
1985
1986 memset(ccb,0,sizeof(ccb));
1987 memset(iobuf,0,sizeof(iobuf));
1988 ccb[0]=ATAPI_CMD_START_STOP;
1989 ccb[4]=0x03; /* start */
1990
1991 c=atapi_issue_autoreq(device,ccb,12,(unsigned char *)iobuf,0);
1992
1993 debug ("ATAPI_CMD_START_STOP returned %x\n",c);
1994 if (c!=0)
1995 return;
1996
1997 memset(ccb,0,sizeof(ccb));
1998 memset(iobuf,0,sizeof(iobuf));
1999 c=atapi_issue_autoreq(device,ccb,12,(unsigned char *)iobuf,0);
2000
2001 debug ("ATAPI_CMD_UNIT_TEST_READY returned %x\n",c);
2002 if (c!=0)
2003 return;
2004
2005 memset(ccb,0,sizeof(ccb));
2006 memset(iobuf,0,sizeof(iobuf));
2007 ccb[0]=ATAPI_CMD_READ_CAP;
2008 c=atapi_issue_autoreq(device,ccb,12,(unsigned char *)iobuf,8);
2009 debug ("ATAPI_CMD_READ_CAP returned %x\n",c);
2010 if (c!=0)
2011 return;
2012
2013 debug ("Read Cap: LBA %02X%02X%02X%02X blksize %02X%02X%02X%02X\n",
2014 iobuf[0],iobuf[1],iobuf[2],iobuf[3],
2015 iobuf[4],iobuf[5],iobuf[6],iobuf[7]);
2016
2017 dev_desc->lba =((unsigned long)iobuf[0]<<24) +
2018 ((unsigned long)iobuf[1]<<16) +
2019 ((unsigned long)iobuf[2]<< 8) +
2020 ((unsigned long)iobuf[3]);
2021 dev_desc->blksz=((unsigned long)iobuf[4]<<24) +
2022 ((unsigned long)iobuf[5]<<16) +
2023 ((unsigned long)iobuf[6]<< 8) +
2024 ((unsigned long)iobuf[7]);
2025 #ifdef CONFIG_LBA48
2026 dev_desc->lba48 = 0; /* ATAPI devices cannot use 48bit addressing (ATA/ATAPI v7) */
2027 #endif
2028 return;
2029 }
2030
2031
2032 /*
2033 * atapi_read:
2034 * we transfer only one block per command, since the multiple DRQ per
2035 * command is not yet implemented
2036 */
2037 #define ATAPI_READ_MAX_BYTES 2048 /* we read max 2kbytes */
2038 #define ATAPI_READ_BLOCK_SIZE 2048 /* assuming CD part */
2039 #define ATAPI_READ_MAX_BLOCK ATAPI_READ_MAX_BYTES/ATAPI_READ_BLOCK_SIZE /* max blocks */
2040
2041 ulong atapi_read (int device, lbaint_t blknr, ulong blkcnt, void *buffer)
2042 {
2043 ulong n = 0;
2044 unsigned char ccb[12]; /* Command descriptor block */
2045 ulong cnt;
2046
2047 debug ("atapi_read dev %d start %lX, blocks %lX buffer at %lX\n",
2048 device, blknr, blkcnt, (ulong)buffer);
2049
2050 do {
2051 if (blkcnt>ATAPI_READ_MAX_BLOCK) {
2052 cnt=ATAPI_READ_MAX_BLOCK;
2053 } else {
2054 cnt=blkcnt;
2055 }
2056 ccb[0]=ATAPI_CMD_READ_12;
2057 ccb[1]=0; /* reserved */
2058 ccb[2]=(unsigned char) (blknr>>24) & 0xFF; /* MSB Block */
2059 ccb[3]=(unsigned char) (blknr>>16) & 0xFF; /* */
2060 ccb[4]=(unsigned char) (blknr>> 8) & 0xFF;
2061 ccb[5]=(unsigned char) blknr & 0xFF; /* LSB Block */
2062 ccb[6]=(unsigned char) (cnt >>24) & 0xFF; /* MSB Block count */
2063 ccb[7]=(unsigned char) (cnt >>16) & 0xFF;
2064 ccb[8]=(unsigned char) (cnt >> 8) & 0xFF;
2065 ccb[9]=(unsigned char) cnt & 0xFF; /* LSB Block */
2066 ccb[10]=0; /* reserved */
2067 ccb[11]=0; /* reserved */
2068
2069 if (atapi_issue_autoreq(device,ccb,12,
2070 (unsigned char *)buffer,
2071 cnt*ATAPI_READ_BLOCK_SIZE) == 0xFF) {
2072 return (n);
2073 }
2074 n+=cnt;
2075 blkcnt-=cnt;
2076 blknr+=cnt;
2077 buffer+=(cnt*ATAPI_READ_BLOCK_SIZE);
2078 } while (blkcnt > 0);
2079 return (n);
2080 }
2081
2082 /* ------------------------------------------------------------------------- */
2083
2084 #endif /* CONFIG_ATAPI */
2085
2086 U_BOOT_CMD(
2087 ide, 5, 1, do_ide,
2088 "ide - IDE sub-system\n",
2089 "reset - reset IDE controller\n"
2090 "ide info - show available IDE devices\n"
2091 "ide device [dev] - show or set current device\n"
2092 "ide part [dev] - print partition table of one or all IDE devices\n"
2093 "ide read addr blk# cnt\n"
2094 "ide write addr blk# cnt - read/write `cnt'"
2095 " blocks starting at block `blk#'\n"
2096 " to/from memory address `addr'\n"
2097 );
2098
2099 U_BOOT_CMD(
2100 diskboot, 3, 1, do_diskboot,
2101 "diskboot- boot from IDE device\n",
2102 "loadAddr dev:part\n"
2103 );
Fork of the u-boot for for Samsung based MINI2440 board