?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ppc64: Don't set Kp bit on SLB
[openbios.git] / drivers / ide.c
blob0d09bcd514c2138c84630222e21e54179e5e0a9a
1 /*
2 * OpenBIOS polled ide driver
3 *
4 * Copyright (C) 2004 Jens Axboe <axboe@suse.de>
5 * Copyright (C) 2005 Stefan Reinauer <stepan@openbios.org>
6 *
7 * Credit goes to Hale Landis for his excellent ata demo software
8 * OF node handling and some fixes by Stefan Reinauer
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * version 2
13 *
14 */
15
16 #include "config.h"
17 #include "libopenbios/bindings.h"
18 #include "kernel/kernel.h"
19 #include "libc/byteorder.h"
20 #include "libc/vsprintf.h"
21
22 #include "drivers/drivers.h"
23 #include "ide.h"
24 #include "hdreg.h"
25 #include "timer.h"
26
27 #ifdef CONFIG_DEBUG_IDE
28 #define IDE_DPRINTF(fmt, args...) \
29 do { printk("IDE - %s: " fmt, __func__ , ##args); } while (0)
30 #else
31 #define IDE_DPRINTF(fmt, args...) do { } while (0)
32 #endif
33
34 /* DECLARE data structures for the nodes. */
35 DECLARE_UNNAMED_NODE( ob_ide, INSTALL_OPEN, sizeof(struct ide_drive*) );
36 DECLARE_UNNAMED_NODE( ob_ide_ctrl, INSTALL_OPEN, sizeof(int));
37
38 /*
39 * define to 2 for the standard 2 channels only
40 */
41 #ifndef CONFIG_IDE_NUM_CHANNELS
42 #define IDE_NUM_CHANNELS 4
43 #else
44 #define IDE_NUM_CHANNELS CONFIG_IDE_NUM_CHANNELS
45 #endif
46 #define IDE_MAX_CHANNELS 4
47
48 #ifndef CONFIG_IDE_FIRST_UNIT
49 #define FIRST_UNIT 0
50 #else
51 #define FIRST_UNIT CONFIG_IDE_FIRST_UNIT
52 #endif
53
54 #ifndef CONFIG_IDE_DEV_TYPE
55 #define DEV_TYPE "ide"
56 #else
57 #define DEV_TYPE CONFIG_IDE_DEV_TYPE
58 #endif
59
60 #ifndef CONFIG_IDE_DEV_NAME
61 #define DEV_NAME "ide%d"
62 #else
63 #define DEV_NAME CONFIG_IDE_DEV_NAME
64 #endif
65
66 static int current_channel = FIRST_UNIT;
67
68 static struct ide_channel *channels = NULL;
69
70 static inline void ide_add_channel(struct ide_channel *chan)
71 {
72 chan->next = channels;
73 channels = chan;
74 }
75
76 static struct ide_channel *ide_seek_channel(const char *name)
77 {
78 struct ide_channel *current;
79
80 current = channels;
81 while (current) {
82 if (!strcmp(current->name, name))
83 return current;
84 current = current->next;
85 }
86 return NULL;
87 }
88
89 /*
90 * don't be pedantic
91 */
92 #undef ATA_PEDANTIC
93
94 static void dump_drive(struct ide_drive *drive)
95 {
96 #ifdef CONFIG_DEBUG_IDE
97 printk("IDE DRIVE @%lx:\n", (unsigned long)drive);
98 printk("unit: %d\n",drive->unit);
99 printk("present: %d\n",drive->present);
100 printk("type: %d\n",drive->type);
101 printk("media: %d\n",drive->media);
102 printk("model: %s\n",drive->model);
103 printk("nr: %d\n",drive->nr);
104 printk("cyl: %d\n",drive->cyl);
105 printk("head: %d\n",drive->head);
106 printk("sect: %d\n",drive->sect);
107 printk("bs: %d\n",drive->bs);
108 #endif
109 }
110
111 /*
112 * old style io port operations
113 */
114 static unsigned char
115 ob_ide_inb(struct ide_channel *chan, unsigned int port)
116 {
117 return inb(chan->io_regs[port]);
118 }
119
120 static void
121 ob_ide_outb(struct ide_channel *chan, unsigned char data, unsigned int port)
122 {
123 outb(data, chan->io_regs[port]);
124 }
125
126 static void
127 ob_ide_insw(struct ide_channel *chan,
128 unsigned int port, unsigned char *addr, unsigned int count)
129 {
130 insw(chan->io_regs[port], addr, count);
131 }
132
133 static void
134 ob_ide_outsw(struct ide_channel *chan,
135 unsigned int port, unsigned char *addr, unsigned int count)
136 {
137 outsw(chan->io_regs[port], addr, count);
138 }
139
140 static inline unsigned char
141 ob_ide_pio_readb(struct ide_drive *drive, unsigned int offset)
142 {
143 struct ide_channel *chan = drive->channel;
144
145 return chan->obide_inb(chan, offset);
146 }
147
148 static inline void
149 ob_ide_pio_writeb(struct ide_drive *drive, unsigned int offset,
150 unsigned char data)
151 {
152 struct ide_channel *chan = drive->channel;
153
154 chan->obide_outb(chan, data, offset);
155 }
156
157 static inline void
158 ob_ide_pio_insw(struct ide_drive *drive, unsigned int offset,
159 unsigned char *addr, unsigned int len)
160 {
161 struct ide_channel *chan = drive->channel;
162
163 if (len & 1) {
164 IDE_DPRINTF("%d: command not word aligned\n", drive->nr);
165 return;
166 }
167
168 chan->obide_insw(chan, offset, addr, len / 2);
169 }
170
171 static inline void
172 ob_ide_pio_outsw(struct ide_drive *drive, unsigned int offset,
173 unsigned char *addr, unsigned int len)
174 {
175 struct ide_channel *chan = drive->channel;
176
177 if (len & 1) {
178 IDE_DPRINTF("%d: command not word aligned\n", drive->nr);
179 return;
180 }
181
182 chan->obide_outsw(chan, offset, addr, len / 2);
183 }
184
185 static void
186 ob_ide_400ns_delay(struct ide_drive *drive)
187 {
188 (void) ob_ide_pio_readb(drive, IDEREG_ASTATUS);
189 (void) ob_ide_pio_readb(drive, IDEREG_ASTATUS);
190 (void) ob_ide_pio_readb(drive, IDEREG_ASTATUS);
191 (void) ob_ide_pio_readb(drive, IDEREG_ASTATUS);
192
193 udelay(1);
194 }
195
196 static void
197 ob_ide_error(struct ide_drive *drive, unsigned char stat, const char *msg)
198 {
199 #ifdef CONFIG_DEBUG_IDE
200 struct ide_channel *chan = drive->channel;
201 unsigned char err;
202 #endif
203
204 if (!stat)
205 stat = ob_ide_pio_readb(drive, IDEREG_STATUS);
206
207 IDE_DPRINTF("ob_ide_error drive<%d>: %s:\n", drive->nr, msg);
208 IDE_DPRINTF(" cmd=%x, stat=%x", chan->ata_cmd.command, stat);
209
210 if ((stat & (BUSY_STAT | ERR_STAT)) == ERR_STAT) {
211 #ifdef CONFIG_DEBUG_IDE
212 err =
213 #endif
214 ob_ide_pio_readb(drive, IDEREG_ERROR);
215 IDE_DPRINTF(", err=%x", err);
216 }
217 IDE_DPRINTF("\n");
218
219 #ifdef CONFIG_DEBUG_IDE
220 /*
221 * see if sense is valid and dump that
222 */
223 if (chan->ata_cmd.command == WIN_PACKET) {
224 struct atapi_command *cmd = &chan->atapi_cmd;
225 unsigned char old_cdb = cmd->cdb[0];
226
227 if (cmd->cdb[0] == ATAPI_REQ_SENSE) {
228 old_cdb = cmd->old_cdb;
229
230 IDE_DPRINTF(" atapi opcode=%02x", old_cdb);
231 } else {
232 int i;
233
234 IDE_DPRINTF(" cdb: ");
235 for (i = 0; i < sizeof(cmd->cdb); i++)
236 IDE_DPRINTF("%02x ", cmd->cdb[i]);
237 }
238 if (cmd->sense_valid)
239 IDE_DPRINTF(", sense: %02x/%02x/%02x",
240 cmd->sense.sense_key, cmd->sense.asc,
241 cmd->sense.ascq);
242 else
243 IDE_DPRINTF(", no sense");
244 IDE_DPRINTF("\n");
245 }
246 #endif
247 }
248
249 /*
250 * wait for 'stat' to be set. returns 1 if failed, 0 if succesful
251 */
252 static int
253 ob_ide_wait_stat(struct ide_drive *drive, unsigned char ok_stat,
254 unsigned char bad_stat, unsigned char *ret_stat)
255 {
256 unsigned char stat;
257 int i;
258
259 ob_ide_400ns_delay(drive);
260
261 for (i = 0; i < 5000; i++) {
262 stat = ob_ide_pio_readb(drive, IDEREG_STATUS);
263 if (!(stat & BUSY_STAT))
264 break;
265
266 udelay(1000);
267 }
268
269 if (ret_stat)
270 *ret_stat = stat;
271
272 if (stat & bad_stat)
273 return 1;
274
275 if ((stat & ok_stat) || !ok_stat)
276 return 0;
277
278 return 1;
279 }
280
281 static int
282 ob_ide_select_drive(struct ide_drive *drive)
283 {
284 struct ide_channel *chan = drive->channel;
285 unsigned char control = IDEHEAD_DEV0;
286
287 if (ob_ide_wait_stat(drive, 0, BUSY_STAT, NULL)) {
288 IDE_DPRINTF("select_drive: timed out\n");
289 return 1;
290 }
291
292 /*
293 * don't select drive if already active. Note: we always
294 * wait for BUSY clear
295 */
296 if (drive->unit == chan->selected)
297 return 0;
298
299 if (drive->unit)
300 control = IDEHEAD_DEV1;
301
302 ob_ide_pio_writeb(drive, IDEREG_CURRENT, control);
303 ob_ide_400ns_delay(drive);
304
305 if (ob_ide_wait_stat(drive, 0, BUSY_STAT, NULL)) {
306 IDE_DPRINTF("select_drive: timed out\n");
307 return 1;
308 }
309
310 chan->selected = drive->unit;
311 return 0;
312 }
313
314 static void
315 ob_ide_write_tasklet(struct ide_drive *drive, struct ata_command *cmd)
316 {
317 ob_ide_pio_writeb(drive, IDEREG_FEATURE, cmd->task[1]);
318 ob_ide_pio_writeb(drive, IDEREG_NSECTOR, cmd->task[3]);
319 ob_ide_pio_writeb(drive, IDEREG_SECTOR, cmd->task[7]);
320 ob_ide_pio_writeb(drive, IDEREG_LCYL, cmd->task[8]);
321 ob_ide_pio_writeb(drive, IDEREG_HCYL, cmd->task[9]);
322
323 ob_ide_pio_writeb(drive, IDEREG_FEATURE, cmd->task[0]);
324 ob_ide_pio_writeb(drive, IDEREG_NSECTOR, cmd->task[2]);
325 ob_ide_pio_writeb(drive, IDEREG_SECTOR, cmd->task[4]);
326 ob_ide_pio_writeb(drive, IDEREG_LCYL, cmd->task[5]);
327 ob_ide_pio_writeb(drive, IDEREG_HCYL, cmd->task[6]);
328
329 if (drive->unit)
330 cmd->device_head |= IDEHEAD_DEV1;
331
332 ob_ide_pio_writeb(drive, IDEREG_CURRENT, cmd->device_head);
333
334 ob_ide_pio_writeb(drive, IDEREG_COMMAND, cmd->command);
335 ob_ide_400ns_delay(drive);
336 }
337
338 static void
339 ob_ide_write_registers(struct ide_drive *drive, struct ata_command *cmd)
340 {
341 /*
342 * we are _always_ polled
343 */
344 ob_ide_pio_writeb(drive, IDEREG_CONTROL, cmd->control | IDECON_NIEN);
345
346 ob_ide_pio_writeb(drive, IDEREG_FEATURE, cmd->feature);
347 ob_ide_pio_writeb(drive, IDEREG_NSECTOR, cmd->nsector);
348 ob_ide_pio_writeb(drive, IDEREG_SECTOR, cmd->sector);
349 ob_ide_pio_writeb(drive, IDEREG_LCYL, cmd->lcyl);
350 ob_ide_pio_writeb(drive, IDEREG_HCYL, cmd->hcyl);
351
352 if (drive->unit)
353 cmd->device_head |= IDEHEAD_DEV1;
354
355 ob_ide_pio_writeb(drive, IDEREG_CURRENT, cmd->device_head);
356
357 ob_ide_pio_writeb(drive, IDEREG_COMMAND, cmd->command);
358 ob_ide_400ns_delay(drive);
359 }
360
361 /*
362 * execute command with "pio non data" protocol
363 */
364 #if 0
365 static int
366 ob_ide_pio_non_data(struct ide_drive *drive, struct ata_command *cmd)
367 {
368 if (ob_ide_select_drive(drive))
369 return 1;
370
371 ob_ide_write_registers(drive, cmd);
372
373 if (ob_ide_wait_stat(drive, 0, BUSY_STAT, NULL))
374 return 1;
375
376 return 0;
377 }
378 #endif
379
380 /*
381 * execute given command with a pio data-in phase.
382 */
383 static int
384 ob_ide_pio_data_in(struct ide_drive *drive, struct ata_command *cmd)
385 {
386 unsigned char stat;
387 unsigned int bytes, timeout;
388
389 if (ob_ide_select_drive(drive))
390 return 1;
391
392 /*
393 * ATA must set ready and seek stat, ATAPI need only clear busy
394 */
395 timeout = 0;
396 do {
397 stat = ob_ide_pio_readb(drive, IDEREG_STATUS);
398
399 if (drive->type == ide_type_ata) {
400 /*
401 * this is BIOS code, don't be too pedantic
402 */
403 #ifdef ATA_PEDANTIC
404 if ((stat & (BUSY_STAT | READY_STAT | SEEK_STAT)) ==
405 (READY_STAT | SEEK_STAT))
406 break;
407 #else
408 if ((stat & (BUSY_STAT | READY_STAT)) == READY_STAT)
409 break;
410 #endif
411 } else {
412 if (!(stat & BUSY_STAT))
413 break;
414 }
415 ob_ide_400ns_delay(drive);
416 } while (timeout++ < 1000);
417
418 if (timeout >= 1000) {
419 ob_ide_error(drive, stat, "drive timed out");
420 cmd->stat = stat;
421 return 1;
422 }
423
424 ob_ide_write_registers(drive, cmd);
425
426 /*
427 * now read the data
428 */
429 bytes = cmd->buflen;
430 do {
431 unsigned count = cmd->buflen;
432
433 if (count > drive->bs)
434 count = drive->bs;
435
436 /* delay 100ms for ATAPI? */
437
438 /*
439 * wait for BUSY clear
440 */
441 if (ob_ide_wait_stat(drive, 0, BUSY_STAT | ERR_STAT, &stat)) {
442 ob_ide_error(drive, stat, "timed out waiting for BUSY clear");
443 cmd->stat = stat;
444 break;
445 }
446
447 /*
448 * transfer the data
449 */
450 if ((stat & (BUSY_STAT | DRQ_STAT)) == DRQ_STAT) {
451 ob_ide_pio_insw(drive, IDEREG_DATA, cmd->buffer, count);
452 cmd->bytes -= count;
453 cmd->buffer += count;
454 bytes -= count;
455
456 ob_ide_400ns_delay(drive);
457 }
458
459 if (stat & (BUSY_STAT | WRERR_STAT | ERR_STAT)) {
460 cmd->stat = stat;
461 break;
462 }
463
464 if (!(stat & DRQ_STAT)) {
465 cmd->stat = stat;
466 break;
467 }
468 } while (bytes);
469
470 if (bytes)
471 IDE_DPRINTF("bytes=%d, stat=%x\n", bytes, stat);
472
473 return bytes ? 1 : 0;
474 }
475
476 /*
477 * execute ata command with pio packet protocol
478 */
479 static int
480 ob_ide_pio_packet(struct ide_drive *drive, struct atapi_command *cmd)
481 {
482 unsigned char stat, reason, lcyl, hcyl;
483 struct ata_command *acmd = &drive->channel->ata_cmd;
484 unsigned char *buffer;
485 unsigned int bytes;
486
487 if (ob_ide_select_drive(drive))
488 return 1;
489
490 if (cmd->buflen && cmd->data_direction == atapi_ddir_none)
491 IDE_DPRINTF("non-zero buflen but no data direction\n");
492
493 memset(acmd, 0, sizeof(*acmd));
494 acmd->lcyl = cmd->buflen & 0xff;
495 acmd->hcyl = (cmd->buflen >> 8) & 0xff;
496 acmd->command = WIN_PACKET;
497 ob_ide_write_registers(drive, acmd);
498
499 /*
500 * BUSY must be set, _or_ DRQ | ERR
501 */
502 stat = ob_ide_pio_readb(drive, IDEREG_ASTATUS);
503 if ((stat & BUSY_STAT) == 0) {
504 if (!(stat & (DRQ_STAT | ERR_STAT))) {
505 ob_ide_error(drive, stat, "bad stat in atapi cmd");
506 cmd->stat = stat;
507 return 1;
508 }
509 }
510
511 if (ob_ide_wait_stat(drive, 0, BUSY_STAT | ERR_STAT, &stat)) {
512 ob_ide_error(drive, stat, "timeout, ATAPI BUSY clear");
513 cmd->stat = stat;
514 return 1;
515 }
516
517 if ((stat & (BUSY_STAT | DRQ_STAT | ERR_STAT)) != DRQ_STAT) {
518 /*
519 * if command isn't request sense, then we have a problem. if
520 * we are doing a sense, ERR_STAT == CHECK_CONDITION
521 */
522 if (cmd->cdb[0] != ATAPI_REQ_SENSE) {
523 IDE_DPRINTF("odd, drive didn't want to transfer %x\n",
524 stat);
525 return 1;
526 }
527 }
528
529 /*
530 * transfer cdb
531 */
532 ob_ide_pio_outsw(drive, IDEREG_DATA, cmd->cdb,sizeof(cmd->cdb));
533 ob_ide_400ns_delay(drive);
534
535 /*
536 * ok, cdb was sent to drive, now do data transfer (if any)
537 */
538 bytes = cmd->buflen;
539 buffer = cmd->buffer;
540 do {
541 unsigned int bc;
542
543 if (ob_ide_wait_stat(drive, 0, BUSY_STAT | ERR_STAT, &stat)) {
544 ob_ide_error(drive, stat, "busy not clear after cdb");
545 cmd->stat = stat;
546 break;
547 }
548
549 /*
550 * transfer complete!
551 */
552 if ((stat & (BUSY_STAT | DRQ_STAT)) == 0)
553 break;
554
555 if ((stat & (BUSY_STAT | DRQ_STAT)) != DRQ_STAT)
556 break;
557
558 reason = ob_ide_pio_readb(drive, IDEREG_NSECTOR);
559 lcyl = ob_ide_pio_readb(drive, IDEREG_LCYL);
560 hcyl = ob_ide_pio_readb(drive, IDEREG_HCYL);
561
562 /*
563 * check if the drive wants to transfer data in the same
564 * direction as we do...
565 */
566 if ((reason & IREASON_CD) && cmd->data_direction != atapi_ddir_read) {
567 ob_ide_error(drive, stat, "atapi, bad transfer ddir");
568 break;
569 }
570
571 bc = (hcyl << 8) | lcyl;
572 if (!bc)
573 break;
574
575 if (bc > bytes)
576 bc = bytes;
577
578 if (cmd->data_direction == atapi_ddir_read)
579 ob_ide_pio_insw(drive, IDEREG_DATA, buffer, bc);
580 else
581 ob_ide_pio_outsw(drive, IDEREG_DATA, buffer, bc);
582
583 bytes -= bc;
584 buffer += bc;
585
586 ob_ide_400ns_delay(drive);
587 } while (bytes);
588
589 if (cmd->data_direction != atapi_ddir_none)
590 (void) ob_ide_wait_stat(drive, 0, BUSY_STAT, &stat);
591
592 if (bytes)
593 IDE_DPRINTF("cdb failed, bytes=%d, stat=%x\n", bytes, stat);
594
595 return (stat & ERR_STAT) || bytes;
596 }
597
598 /*
599 * execute a packet command, with retries if appropriate
600 */
601 static int
602 ob_ide_atapi_packet(struct ide_drive *drive, struct atapi_command *cmd)
603 {
604 int retries = 5, ret;
605
606 if (drive->type != ide_type_atapi)
607 return 1;
608 if (cmd->buflen > 0xffff)
609 return 1;
610
611 /*
612 * retry loop
613 */
614 do {
615 ret = ob_ide_pio_packet(drive, cmd);
616 if (!ret)
617 break;
618
619 /*
620 * request sense failed, bummer
621 */
622 if (cmd->cdb[0] == ATAPI_REQ_SENSE)
623 break;
624
625 if (ob_ide_atapi_request_sense(drive))
626 break;
627
628 /*
629 * we know sense is valid. retry if the drive isn't ready,
630 * otherwise don't bother.
631 */
632 if (cmd->sense.sense_key != ATAPI_SENSE_NOT_READY)
633 break;
634 /*
635 * ... except 'medium not present'
636 */
637 if (cmd->sense.asc == 0x3a)
638 break;
639
640 udelay(1000000);
641 } while (retries--);
642
643 if (ret)
644 ob_ide_error(drive, 0, "atapi command");
645
646 return ret;
647 }
648
649 static int
650 ob_ide_atapi_request_sense(struct ide_drive *drive)
651 {
652 struct atapi_command *cmd = &drive->channel->atapi_cmd;
653 unsigned char old_cdb;
654
655 /*
656 * save old cdb for debug error
657 */
658 old_cdb = cmd->cdb[0];
659
660 memset(cmd, 0, sizeof(*cmd));
661 cmd->cdb[0] = ATAPI_REQ_SENSE;
662 cmd->cdb[4] = 18;
663 cmd->buffer = (unsigned char *) &cmd->sense;
664 cmd->buflen = 18;
665 cmd->data_direction = atapi_ddir_read;
666 cmd->old_cdb = old_cdb;
667
668 if (ob_ide_atapi_packet(drive, cmd))
669 return 1;
670
671 cmd->sense_valid = 1;
672 return 0;
673 }
674
675 /*
676 * make sure drive is ready and media loaded
677 */
678 static int
679 ob_ide_atapi_drive_ready(struct ide_drive *drive)
680 {
681 struct atapi_command *cmd = &drive->channel->atapi_cmd;
682 struct atapi_capacity cap;
683
684 IDE_DPRINTF("ob_ide_atapi_drive_ready\n");
685
686 /*
687 * Test Unit Ready is like a ping
688 */
689 memset(cmd, 0, sizeof(*cmd));
690 cmd->cdb[0] = ATAPI_TUR;
691
692 if (ob_ide_atapi_packet(drive, cmd)) {
693 IDE_DPRINTF("%d: TUR failed\n", drive->nr);
694 return 1;
695 }
696
697 /*
698 * don't force load of tray (bit 2 in byte 4 of cdb), it's
699 * annoying and we don't want to deal with errors from drives
700 * that cannot do it
701 */
702 memset(cmd, 0, sizeof(*cmd));
703 cmd->cdb[0] = ATAPI_START_STOP_UNIT;
704 cmd->cdb[4] = 0x01;
705
706 if (ob_ide_atapi_packet(drive, cmd)) {
707 IDE_DPRINTF("%d: START_STOP unit failed\n", drive->nr);
708 return 1;
709 }
710
711 /*
712 * finally, get capacity and block size
713 */
714 memset(cmd, 0, sizeof(*cmd));
715 memset(&cap, 0, sizeof(cap));
716
717 cmd->cdb[0] = ATAPI_READ_CAPACITY;
718 cmd->buffer = (unsigned char *) &cap;
719 cmd->buflen = sizeof(cap);
720 cmd->data_direction = atapi_ddir_read;
721
722 if (ob_ide_atapi_packet(drive, cmd)) {
723 drive->sectors = 0x1fffff;
724 drive->bs = 2048;
725 return 1;
726 }
727
728 drive->sectors = __be32_to_cpu(cap.lba) + 1;
729 drive->bs = __be32_to_cpu(cap.block_size);
730 return 0;
731 }
732
733 /*
734 * read from an atapi device, using READ_10
735 */
736 static int
737 ob_ide_read_atapi(struct ide_drive *drive, unsigned long long block,
738 unsigned char *buf, unsigned int sectors)
739 {
740 struct atapi_command *cmd = &drive->channel->atapi_cmd;
741
742 if (ob_ide_atapi_drive_ready(drive))
743 return 1;
744
745 memset(cmd, 0, sizeof(*cmd));
746
747 /*
748 * READ_10 should work on generally any atapi device
749 */
750 cmd->cdb[0] = ATAPI_READ_10;
751 cmd->cdb[2] = (block >> 24) & 0xff;
752 cmd->cdb[3] = (block >> 16) & 0xff;
753 cmd->cdb[4] = (block >> 8) & 0xff;
754 cmd->cdb[5] = block & 0xff;
755 cmd->cdb[7] = (sectors >> 8) & 0xff;
756 cmd->cdb[8] = sectors & 0xff;
757
758 cmd->buffer = buf;
759 cmd->buflen = sectors * 2048;
760 cmd->data_direction = atapi_ddir_read;
761
762 return ob_ide_atapi_packet(drive, cmd);
763 }
764
765 static int
766 ob_ide_read_ata_chs(struct ide_drive *drive, unsigned long long block,
767 unsigned char *buf, unsigned int sectors)
768 {
769 struct ata_command *cmd = &drive->channel->ata_cmd;
770 unsigned int track = (block / drive->sect);
771 unsigned int sect = (block % drive->sect) + 1;
772 unsigned int head = (track % drive->head);
773 unsigned int cyl = (track / drive->head);
774
775 /*
776 * fill in chs command to read from disk at given location
777 */
778 cmd->buffer = buf;
779 cmd->buflen = sectors * 512;
780
781 cmd->nsector = sectors & 0xff;
782 cmd->sector = sect;
783 cmd->lcyl = cyl;
784 cmd->hcyl = cyl >> 8;
785 cmd->device_head = head;
786
787 cmd->command = WIN_READ;
788
789 return ob_ide_pio_data_in(drive, cmd);
790 }
791
792 static int
793 ob_ide_read_ata_lba28(struct ide_drive *drive, unsigned long long block,
794 unsigned char *buf, unsigned int sectors)
795 {
796 struct ata_command *cmd = &drive->channel->ata_cmd;
797
798 memset(cmd, 0, sizeof(*cmd));
799
800 /*
801 * fill in 28-bit lba command to read from disk at given location
802 */
803 cmd->buffer = buf;
804 cmd->buflen = sectors * 512;
805
806 cmd->nsector = sectors;
807 cmd->sector = block;
808 cmd->lcyl = block >>= 8;
809 cmd->hcyl = block >>= 8;
810 cmd->device_head = ((block >> 8) & 0x0f);
811 cmd->device_head |= (1 << 6);
812
813 cmd->command = WIN_READ;
814
815 return ob_ide_pio_data_in(drive, cmd);
816 }
817
818 static int
819 ob_ide_read_ata_lba48(struct ide_drive *drive, unsigned long long block,
820 unsigned char *buf, unsigned int sectors)
821 {
822 struct ata_command *cmd = &drive->channel->ata_cmd;
823
824 memset(cmd, 0, sizeof(*cmd));
825
826 cmd->buffer = buf;
827 cmd->buflen = sectors * 512;
828
829 /*
830 * we are using tasklet addressing here
831 */
832 cmd->task[2] = sectors;
833 cmd->task[3] = sectors >> 8;
834 cmd->task[4] = block;
835 cmd->task[5] = block >> 8;
836 cmd->task[6] = block >> 16;
837 cmd->task[7] = block >> 24;
838 cmd->task[8] = (u64) block >> 32;
839 cmd->task[9] = (u64) block >> 40;
840
841 cmd->command = WIN_READ_EXT;
842
843 ob_ide_write_tasklet(drive, cmd);
844
845 return ob_ide_pio_data_in(drive, cmd);
846 }
847 /*
848 * read 'sectors' sectors from ata device
849 */
850 static int
851 ob_ide_read_ata(struct ide_drive *drive, unsigned long long block,
852 unsigned char *buf, unsigned int sectors)
853 {
854 unsigned long long end_block = block + sectors;
855 const int need_lba48 = (end_block > (1ULL << 28)) || (sectors > 255);
856
857 if (end_block > drive->sectors)
858 return 1;
859 if (need_lba48 && drive->addressing != ide_lba48)
860 return 1;
861
862 /*
863 * use lba48 if we have to, otherwise use the faster lba28
864 */
865 if (need_lba48)
866 return ob_ide_read_ata_lba48(drive, block, buf, sectors);
867 else if (drive->addressing != ide_chs)
868 return ob_ide_read_ata_lba28(drive, block, buf, sectors);
869
870 return ob_ide_read_ata_chs(drive, block, buf, sectors);
871 }
872
873 static int
874 ob_ide_read_sectors(struct ide_drive *drive, unsigned long long block,
875 unsigned char *buf, unsigned int sectors)
876 {
877 if (!sectors)
878 return 1;
879 if (block + sectors > drive->sectors)
880 return 1;
881
882 IDE_DPRINTF("ob_ide_read_sectors: block=%lu sectors=%u\n",
883 (unsigned long) block, sectors);
884
885 if (drive->type == ide_type_ata)
886 return ob_ide_read_ata(drive, block, buf, sectors);
887 else
888 return ob_ide_read_atapi(drive, block, buf, sectors);
889 }
890
891 /*
892 * byte swap the string if necessay, and strip leading/trailing blanks
893 */
894 static void
895 ob_ide_fixup_string(unsigned char *s, unsigned int len)
896 {
897 unsigned char *p = s, *end = &s[len & ~1];
898
899 /*
900 * if big endian arch, byte swap the string
901 */
902 #ifdef CONFIG_BIG_ENDIAN
903 for (p = end ; p != s;) {
904 unsigned short *pp = (unsigned short *) (p -= 2);
905 *pp = __le16_to_cpu(*pp);
906 }
907 #endif
908
909 while (s != end && *s == ' ')
910 ++s;
911 while (s != end && *s)
912 if (*s++ != ' ' || (s != end && *s && *s != ' '))
913 *p++ = *(s-1);
914 while (p != end)
915 *p++ = '\0';
916 }
917
918 /*
919 * it's big endian, we need to swap (if on little endian) the items we use
920 */
921 static int
922 ob_ide_fixup_id(struct hd_driveid *id)
923 {
924 ob_ide_fixup_string(id->model, 40);
925 id->config = __le16_to_cpu(id->config);
926 id->lba_capacity = __le32_to_cpu(id->lba_capacity);
927 id->cyls = __le16_to_cpu(id->cyls);
928 id->heads = __le16_to_cpu(id->heads);
929 id->sectors = __le16_to_cpu(id->sectors);
930 id->command_set_2 = __le16_to_cpu(id->command_set_2);
931 id->cfs_enable_2 = __le16_to_cpu(id->cfs_enable_2);
932
933 return 0;
934 }
935
936 static int
937 ob_ide_identify_drive(struct ide_drive *drive)
938 {
939 struct ata_command *cmd = &drive->channel->ata_cmd;
940 struct hd_driveid id;
941
942 memset(cmd, 0, sizeof(*cmd));
943 cmd->buffer = (unsigned char *) &id;
944 cmd->buflen = 512;
945
946 if (drive->type == ide_type_ata)
947 cmd->command = WIN_IDENTIFY;
948 else if (drive->type == ide_type_atapi)
949 cmd->command = WIN_IDENTIFY_PACKET;
950 else {
951 IDE_DPRINTF("%s: called with bad device type %d\n",
952 __FUNCTION__, drive->type);
953 return 1;
954 }
955
956 if (ob_ide_pio_data_in(drive, cmd))
957 return 1;
958
959 ob_ide_fixup_id(&id);
960
961 if (drive->type == ide_type_atapi) {
962 drive->media = (id.config >> 8) & 0x1f;
963 drive->sectors = 0x7fffffff;
964 drive->bs = 2048;
965 drive->max_sectors = 31;
966 } else {
967 drive->media = ide_media_disk;
968 drive->sectors = id.lba_capacity;
969 drive->bs = 512;
970 drive->max_sectors = 255;
971
972 #ifdef CONFIG_IDE_LBA48
973 if ((id.command_set_2 & 0x0400) && (id.cfs_enable_2 & 0x0400)) {
974 drive->addressing = ide_lba48;
975 drive->max_sectors = 65535;
976 } else
977 #endif
978 if (id.capability & 2)
979 drive->addressing = ide_lba28;
980 else {
981 drive->addressing = ide_chs;
982 }
983
984 /* only set these in chs mode? */
985 drive->cyl = id.cyls;
986 drive->head = id.heads;
987 drive->sect = id.sectors;
988 }
989
990 strncpy(drive->model, (char*)id.model, sizeof(id.model));
991 drive->model[40] = '\0';
992 return 0;
993 }
994
995 /*
996 * identify type of devices on channel. must have already been probed.
997 */
998 static void
999 ob_ide_identify_drives(struct ide_channel *chan)
1000 {
1001 struct ide_drive *drive;
1002 int i;
1003
1004 for (i = 0; i < 2; i++) {
1005 drive = &chan->drives[i];
1006
1007 if (!drive->present)
1008 continue;
1009
1010 ob_ide_identify_drive(drive);
1011 }
1012 }
1013
1014 /*
1015 * software reset (ATA-4, section 8.3)
1016 */
1017 static void
1018 ob_ide_software_reset(struct ide_drive *drive)
1019 {
1020 struct ide_channel *chan = drive->channel;
1021
1022 ob_ide_pio_writeb(drive, IDEREG_CONTROL, IDECON_NIEN | IDECON_SRST);
1023 ob_ide_400ns_delay(drive);
1024 ob_ide_pio_writeb(drive, IDEREG_CONTROL, IDECON_NIEN);
1025 ob_ide_400ns_delay(drive);
1026
1027 /*
1028 * if master is present, wait for BUSY clear
1029 */
1030 if (chan->drives[0].present)
1031 ob_ide_wait_stat(drive, 0, BUSY_STAT, NULL);
1032
1033 /*
1034 * if slave is present, wait until it allows register access
1035 */
1036 if (chan->drives[1].present) {
1037 unsigned char sectorn, sectorc;
1038 int timeout = 1000;
1039
1040 do {
1041 /*
1042 * select it
1043 */
1044 ob_ide_pio_writeb(drive, IDEREG_CURRENT, IDEHEAD_DEV1);
1045 ob_ide_400ns_delay(drive);
1046
1047 sectorn = ob_ide_pio_readb(drive, IDEREG_SECTOR);
1048 sectorc = ob_ide_pio_readb(drive, IDEREG_NSECTOR);
1049
1050 if (sectorc == 0x01 && sectorn == 0x01)
1051 break;
1052
1053 } while (--timeout);
1054 }
1055
1056 /*
1057 * reset done, reselect original device
1058 */
1059 drive->channel->selected = -1;
1060 ob_ide_select_drive(drive);
1061 }
1062
1063 /*
1064 * this serves as both a device check, and also to verify that the drives
1065 * we initially "found" are really there
1066 */
1067 static void
1068 ob_ide_device_type_check(struct ide_drive *drive)
1069 {
1070 unsigned char sc, sn, cl, ch, st;
1071
1072 if (ob_ide_select_drive(drive))
1073 return;
1074
1075 sc = ob_ide_pio_readb(drive, IDEREG_NSECTOR);
1076 sn = ob_ide_pio_readb(drive, IDEREG_SECTOR);
1077
1078 if (sc == 0x01 && sn == 0x01) {
1079 /*
1080 * read device signature
1081 */
1082 cl = ob_ide_pio_readb(drive, IDEREG_LCYL);
1083 ch = ob_ide_pio_readb(drive, IDEREG_HCYL);
1084 st = ob_ide_pio_readb(drive, IDEREG_STATUS);
1085 if (cl == 0x14 && ch == 0xeb)
1086 drive->type = ide_type_atapi;
1087 else if (cl == 0x00 && ch == 0x00 && st != 0x00)
1088 drive->type = ide_type_ata;
1089 else
1090 drive->present = 0;
1091 } else
1092 drive->present = 0;
1093 }
1094
1095 /*
1096 * pure magic
1097 */
1098 static void
1099 ob_ide_device_check(struct ide_drive *drive)
1100 {
1101 unsigned char sc, sn;
1102
1103 /*
1104 * non-existing io port should return 0xff, don't probe this
1105 * channel at all then
1106 */
1107 if (ob_ide_pio_readb(drive, IDEREG_STATUS) == 0xff) {
1108 drive->channel->present = 0;
1109 return;
1110 }
1111
1112 if (ob_ide_select_drive(drive))
1113 return;
1114
1115 ob_ide_pio_writeb(drive, IDEREG_NSECTOR, 0x55);
1116 ob_ide_pio_writeb(drive, IDEREG_SECTOR, 0xaa);
1117 ob_ide_pio_writeb(drive, IDEREG_NSECTOR, 0xaa);
1118 ob_ide_pio_writeb(drive, IDEREG_SECTOR, 0x55);
1119 ob_ide_pio_writeb(drive, IDEREG_NSECTOR, 0x55);
1120 ob_ide_pio_writeb(drive, IDEREG_SECTOR, 0xaa);
1121
1122 sc = ob_ide_pio_readb(drive, IDEREG_NSECTOR);
1123 sn = ob_ide_pio_readb(drive, IDEREG_SECTOR);
1124
1125 /*
1126 * we _think_ the device is there, we will make sure later
1127 */
1128 if (sc == 0x55 && sn == 0xaa) {
1129 drive->present = 1;
1130 drive->type = ide_type_unknown;
1131 }
1132 }
1133
1134 /*
1135 * probe the legacy ide ports and find attached devices.
1136 */
1137 static void
1138 ob_ide_probe(struct ide_channel *chan)
1139 {
1140 struct ide_drive *drive;
1141 int i;
1142
1143 for (i = 0; i < 2; i++) {
1144 drive = &chan->drives[i];
1145
1146 ob_ide_device_check(drive);
1147
1148 /*
1149 * no point in continuing
1150 */
1151 if (!chan->present)
1152 break;
1153
1154 if (!drive->present)
1155 continue;
1156
1157 /*
1158 * select and reset device
1159 */
1160 if (ob_ide_select_drive(drive))
1161 continue;
1162
1163 ob_ide_software_reset(drive);
1164
1165 ob_ide_device_type_check(drive);
1166 }
1167 }
1168
1169 /*
1170 * The following functions are interfacing with OpenBIOS. They
1171 * are device node methods. Thus they have to do proper stack handling.
1172 *
1173 */
1174
1175 /*
1176 * 255 sectors for ata lba28, 65535 for lba48, and 31 sectors for atapi
1177 */
1178 static void
1179 ob_ide_max_transfer(int *idx)
1180 {
1181 struct ide_drive *drive = *(struct ide_drive **)idx;
1182
1183 IDE_DPRINTF("max_transfer %x\n", drive->max_sectors * drive->bs);
1184
1185 PUSH(drive->max_sectors * drive->bs);
1186 }
1187
1188 static void
1189 ob_ide_read_blocks(int *idx)
1190 {
1191 cell n = POP(), cnt=n;
1192 ucell blk = POP();
1193 unsigned char *dest = (unsigned char *)cell2pointer(POP());
1194 struct ide_drive *drive = *(struct ide_drive **)idx;
1195
1196 IDE_DPRINTF("ob_ide_read_blocks %lx block=%ld n=%ld\n",
1197 (unsigned long)dest, (unsigned long)blk, (long)n);
1198
1199 while (n) {
1200 int len = n;
1201 if (len > drive->max_sectors)
1202 len = drive->max_sectors;
1203
1204 if (ob_ide_read_sectors(drive, blk, dest, len)) {
1205 IDE_DPRINTF("ob_ide_read_blocks: error\n");
1206 RET(0);
1207 }
1208
1209 dest += len * drive->bs;
1210 n -= len;
1211 blk += len;
1212 }
1213
1214 PUSH(cnt);
1215 }
1216
1217 static void
1218 ob_ide_block_size(int *idx)
1219 {
1220 struct ide_drive *drive = *(struct ide_drive **)idx;
1221
1222 IDE_DPRINTF("ob_ide_block_size: block size %x\n", drive->bs);
1223
1224 PUSH(drive->bs);
1225 }
1226
1227 static void
1228 ob_ide_initialize(int *idx)
1229 {
1230 int props[3];
1231 phandle_t ph=get_cur_dev();
1232
1233 push_str("block");
1234 fword("device-type");
1235
1236 // Set dummy reg properties
1237
1238 set_int_property(ph, "#address-cells", 1);
1239 set_int_property(ph, "#size-cells", 0);
1240
1241 props[0] = __cpu_to_be32(0); props[1] = __cpu_to_be32(0); props[2] = __cpu_to_be32(0);
1242 set_property(ph, "reg", (char *)&props, 3*sizeof(int));
1243
1244 fword("is-deblocker");
1245 }
1246
1247 static void
1248 ob_ide_open(int *idx)
1249 {
1250 int ret=1, len;
1251 phandle_t ph;
1252 struct ide_drive *drive;
1253 struct ide_channel *chan;
1254 char *idename;
1255 int unit;
1256
1257 fword("my-unit");
1258 unit = POP();
1259
1260 fword("my-parent");
1261 fword("ihandle>phandle");
1262 ph=(phandle_t)POP();
1263 idename=get_property(ph, "name", &len);
1264
1265 chan = ide_seek_channel(idename);
1266 drive = &chan->drives[unit];
1267 *(struct ide_drive **)idx = drive;
1268
1269 IDE_DPRINTF("opening channel %d unit %d\n", idx[1], idx[0]);
1270 dump_drive(drive);
1271
1272 if (drive->type != ide_type_ata)
1273 ret= !ob_ide_atapi_drive_ready(drive);
1274
1275 selfword("open-deblocker");
1276
1277 /* interpose disk-label */
1278 ph = find_dev("/packages/disk-label");
1279 fword("my-args");
1280 PUSH_ph( ph );
1281 fword("interpose");
1282
1283 RET ( -ret );
1284 }
1285
1286 static void
1287 ob_ide_close(struct ide_drive *drive)
1288 {
1289 selfword("close-deblocker");
1290 }
1291
1292 NODE_METHODS(ob_ide) = {
1293 { NULL, ob_ide_initialize },
1294 { "open", ob_ide_open },
1295 { "close", ob_ide_close },
1296 { "read-blocks", ob_ide_read_blocks },
1297 { "block-size", ob_ide_block_size },
1298 { "max-transfer", ob_ide_max_transfer },
1299 };
1300
1301 static void
1302 ob_ide_ctrl_initialize(int *idx)
1303 {
1304 phandle_t ph=get_cur_dev();
1305
1306 /* set device type */
1307 push_str(DEV_TYPE);
1308 fword("device-type");
1309
1310 set_int_property(ph, "#address-cells", 1);
1311 set_int_property(ph, "#size-cells", 0);
1312 }
1313
1314 static void
1315 ob_ide_ctrl_decodeunit(int *idx)
1316 {
1317 fword("parse-hex");
1318 }
1319
1320 NODE_METHODS(ob_ide_ctrl) = {
1321 { NULL, ob_ide_ctrl_initialize },
1322 { "decode-unit", ob_ide_ctrl_decodeunit },
1323 };
1324
1325 static void set_cd_alias(const char *path)
1326 {
1327 phandle_t aliases;
1328
1329 aliases = find_dev("/aliases");
1330
1331 if (get_property(aliases, "cd", NULL))
1332 return;
1333
1334 set_property(aliases, "cd", path, strlen(path) + 1);
1335 set_property(aliases, "cdrom", path, strlen(path) + 1);
1336 }
1337
1338 static void set_hd_alias(const char *path)
1339 {
1340 phandle_t aliases;
1341
1342 aliases = find_dev("/aliases");
1343
1344 if (get_property(aliases, "hd", NULL))
1345 return;
1346
1347 set_property(aliases, "hd", path, strlen(path) + 1);
1348 set_property(aliases, "disk", path, strlen(path) + 1);
1349 }
1350
1351 static void set_ide_alias(const char *path)
1352 {
1353 phandle_t aliases;
1354 static int ide_counter = 0;
1355 char idestr[8];
1356
1357 aliases = find_dev("/aliases");
1358
1359 snprintf(idestr, sizeof(idestr), "ide%d", ide_counter++);
1360 set_property(aliases, idestr, path, strlen(path) + 1);
1361 }
1362
1363 int ob_ide_init(const char *path, uint32_t io_port0, uint32_t ctl_port0,
1364 uint32_t io_port1, uint32_t ctl_port1)
1365 {
1366 int i, j;
1367 char nodebuff[128];
1368 phandle_t dnode;
1369 struct ide_channel *chan;
1370 int io_ports[IDE_MAX_CHANNELS];
1371 int ctl_ports[IDE_MAX_CHANNELS];
1372 u32 props[6];
1373
1374 io_ports[0] = io_port0;
1375 ctl_ports[0] = ctl_port0 + 2;
1376 io_ports[1] = io_port1;
1377 ctl_ports[1] = ctl_port1 + 2;
1378
1379 for (i = 0; i < IDE_NUM_CHANNELS; i++, current_channel++) {
1380
1381 chan = malloc(sizeof(struct ide_channel));
1382
1383 snprintf(chan->name, sizeof(chan->name),
1384 DEV_NAME, current_channel);
1385
1386 chan->mmio = 0;
1387
1388 for (j = 0; j < 8; j++)
1389 chan->io_regs[j] = io_ports[i] + j;
1390
1391 chan->io_regs[8] = ctl_ports[i];
1392 chan->io_regs[9] = ctl_ports[i] + 1;
1393
1394 chan->obide_inb = ob_ide_inb;
1395 chan->obide_insw = ob_ide_insw;
1396 chan->obide_outb = ob_ide_outb;
1397 chan->obide_outsw = ob_ide_outsw;
1398
1399 chan->selected = -1;
1400
1401 /*
1402 * assume it's there, if not io port dead check will clear
1403 */
1404 chan->present = 1;
1405
1406 for (j = 0; j < 2; j++) {
1407 chan->drives[j].present = 0;
1408 chan->drives[j].unit = j;
1409 chan->drives[j].channel = chan;
1410 /* init with a decent value */
1411 chan->drives[j].bs = 512;
1412
1413 chan->drives[j].nr = i * 2 + j;
1414 }
1415
1416 ide_add_channel(chan);
1417
1418 ob_ide_probe(chan);
1419
1420 if (!chan->present)
1421 continue;
1422
1423 ob_ide_identify_drives(chan);
1424
1425 snprintf(nodebuff, sizeof(nodebuff), "%s/" DEV_NAME, path,
1426 current_channel);
1427 REGISTER_NAMED_NODE(ob_ide_ctrl, nodebuff);
1428
1429 dnode = find_dev(nodebuff);
1430
1431 #if !defined(CONFIG_PPC) && !defined(CONFIG_SPARC64)
1432 props[0]=14; props[1]=0;
1433 set_property(dnode, "interrupts",
1434 (char *)&props, 2*sizeof(props[0]));
1435 #endif
1436
1437 props[0] = __cpu_to_be32(chan->io_regs[0]);
1438 props[1] = __cpu_to_be32(1); props[2] = __cpu_to_be32(8);
1439 props[3] = __cpu_to_be32(chan->io_regs[8]);
1440 props[4] = __cpu_to_be32(1); props[5] = __cpu_to_be32(2);
1441 set_property(dnode, "reg", (char *)&props, 6*sizeof(props[0]));
1442
1443 IDE_DPRINTF(DEV_NAME": [io ports 0x%x-0x%x,0x%x]\n",
1444 current_channel, chan->io_regs[0],
1445 chan->io_regs[0] + 7, chan->io_regs[8]);
1446
1447 for (j = 0; j < 2; j++) {
1448 struct ide_drive *drive = &chan->drives[j];
1449 const char *media = "UNKNOWN";
1450
1451 if (!drive->present)
1452 continue;
1453
1454 IDE_DPRINTF(" drive%d [ATA%s ", j,
1455 drive->type == ide_type_atapi ? "PI" : "");
1456 switch (drive->media) {
1457 case ide_media_floppy:
1458 media = "floppy";
1459 break;
1460 case ide_media_cdrom:
1461 media = "cdrom";
1462 break;
1463 case ide_media_optical:
1464 media = "mo";
1465 break;
1466 case ide_media_disk:
1467 media = "disk";
1468 break;
1469 }
1470 IDE_DPRINTF("%s]: %s\n", media, drive->model);
1471 snprintf(nodebuff, sizeof(nodebuff),
1472 "%s/" DEV_NAME "/%s", path, current_channel,
1473 media);
1474 REGISTER_NAMED_NODE(ob_ide, nodebuff);
1475 dnode=find_dev(nodebuff);
1476 set_int_property(dnode, "reg", j);
1477
1478 /* create aliases */
1479
1480 set_ide_alias(nodebuff);
1481 if (drive->media == ide_media_cdrom)
1482 set_cd_alias(nodebuff);
1483 if (drive->media == ide_media_disk)
1484 set_hd_alias(nodebuff);
1485 }
1486 }
1487
1488 return 0;
1489 }
1490
1491 #if defined(CONFIG_DRIVER_MACIO)
1492 static unsigned char
1493 macio_ide_inb(struct ide_channel *chan, unsigned int port)
1494 {
1495 return in_8((unsigned char*)(chan->mmio + (port << 4)));
1496 }
1497
1498 static void
1499 macio_ide_outb(struct ide_channel *chan, unsigned char data, unsigned int port)
1500 {
1501 out_8((unsigned char*)(chan->mmio + (port << 4)), data);
1502 }
1503
1504 static void
1505 macio_ide_insw(struct ide_channel *chan,
1506 unsigned int port, unsigned char *addr, unsigned int count)
1507 {
1508 _insw((uint16_t*)(chan->mmio + (port << 4)), addr, count);
1509 }
1510
1511 static void
1512 macio_ide_outsw(struct ide_channel *chan,
1513 unsigned int port, unsigned char *addr, unsigned int count)
1514 {
1515 _outsw((uint16_t*)(chan->mmio + (port << 4)), addr, count);
1516 }
1517
1518 #define MACIO_IDE_OFFSET 0x00020000
1519 #define MACIO_IDE_SIZE 0x00001000
1520
1521 int macio_ide_init(const char *path, uint32_t addr, int nb_channels)
1522 {
1523 int i, j;
1524 char nodebuff[128];
1525 phandle_t dnode;
1526 u32 props[8];
1527 struct ide_channel *chan;
1528
1529 for (i = 0; i < nb_channels; i++, current_channel++) {
1530
1531 chan = malloc(sizeof(struct ide_channel));
1532
1533 snprintf(chan->name, sizeof(chan->name),
1534 DEV_NAME, current_channel);
1535
1536 chan->mmio = addr + MACIO_IDE_OFFSET + i * MACIO_IDE_SIZE;
1537
1538 chan->obide_inb = macio_ide_inb;
1539 chan->obide_insw = macio_ide_insw;
1540 chan->obide_outb = macio_ide_outb;
1541 chan->obide_outsw = macio_ide_outsw;
1542
1543 chan->selected = -1;
1544
1545 /*
1546 * assume it's there, if not io port dead check will clear
1547 */
1548 chan->present = 1;
1549
1550 for (j = 0; j < 2; j++) {
1551 chan->drives[j].present = 0;
1552 chan->drives[j].unit = j;
1553 chan->drives[j].channel = chan;
1554 /* init with a decent value */
1555 chan->drives[j].bs = 512;
1556
1557 chan->drives[j].nr = i * 2 + j;
1558 }
1559
1560 ob_ide_probe(chan);
1561
1562 if (!chan->present) {
1563 free(chan);
1564 continue;
1565 }
1566
1567 ide_add_channel(chan);
1568
1569 ob_ide_identify_drives(chan);
1570
1571 snprintf(nodebuff, sizeof(nodebuff), "%s/" DEV_NAME, path,
1572 current_channel);
1573 REGISTER_NAMED_NODE(ob_ide_ctrl, nodebuff);
1574
1575 dnode = find_dev(nodebuff);
1576
1577 set_property(dnode, "compatible", "heathrow-ata", 13);
1578
1579 props[0] = 0x00000526;
1580 props[1] = 0x00000085;
1581 props[2] = 0x00000025;
1582 props[3] = 0x00000025;
1583 props[4] = 0x00000025;
1584 props[5] = 0x00000000;
1585 props[6] = 0x00000000;
1586 props[7] = 0x00000000;
1587 OLDWORLD(set_property(dnode, "AAPL,pio-timing",
1588 (char *)&props, 8*sizeof(props[0])));
1589
1590 /* The first interrupt entry is the ide interrupt, the second
1591 the dbdma interrupt */
1592 switch (i) {
1593 case 0:
1594 props[0] = 0x0000000d;
1595 props[2] = 0x00000002;
1596 break;
1597 case 1:
1598 props[0] = 0x0000000e;
1599 props[2] = 0x00000003;
1600 break;
1601 case 2:
1602 props[0] = 0x0000000f;
1603 props[2] = 0x00000004;
1604 break;
1605 default:
1606 props[0] = 0x00000000;
1607 props[2] = 0x00000000;
1608 break;
1609 }
1610 props[1] = 0x00000000; /* XXX level triggered on real hw */
1611 props[3] = 0x00000000;
1612 set_property(dnode, "interrupts",
1613 (char *)&props, 4*sizeof(props[0]));
1614 set_int_property(dnode, "#interrupt-cells", 2);
1615 OLDWORLD(set_property(dnode, "AAPL,interrupts",
1616 (char *)&props, 2*sizeof(props[0])));
1617
1618 props[0] = MACIO_IDE_OFFSET + i * MACIO_IDE_SIZE;
1619 props[1] = MACIO_IDE_SIZE;
1620 props[2] = 0x00008b00 + i * 0x0200;
1621 props[3] = 0x0200;
1622 set_property(dnode, "reg", (char *)&props, 4*sizeof(props[0]));
1623
1624 props[0] = addr + MACIO_IDE_OFFSET + i * MACIO_IDE_SIZE;
1625 props[1] = addr + 0x00008b00 + i * 0x0200;
1626 OLDWORLD(set_property(dnode, "AAPL,address",
1627 (char *)&props, 2*sizeof(props[0])));
1628
1629 props[0] = 0;
1630 OLDWORLD(set_property(dnode, "AAPL,bus-id", (char*)props,
1631 1 * sizeof(props[0])));
1632 IDE_DPRINTF(DEV_NAME": [io ports 0x%lx]\n",
1633 current_channel, chan->mmio);
1634
1635 for (j = 0; j < 2; j++) {
1636 struct ide_drive *drive = &chan->drives[j];
1637 const char *media = "UNKNOWN";
1638
1639 if (!drive->present)
1640 continue;
1641
1642 IDE_DPRINTF(" drive%d [ATA%s ", j,
1643 drive->type == ide_type_atapi ? "PI" : "");
1644 switch (drive->media) {
1645 case ide_media_floppy:
1646 media = "floppy";
1647 break;
1648 case ide_media_cdrom:
1649 media = "cdrom";
1650 break;
1651 case ide_media_optical:
1652 media = "mo";
1653 break;
1654 case ide_media_disk:
1655 media = "disk";
1656 break;
1657 }
1658 IDE_DPRINTF("%s]: %s\n", media, drive->model);
1659 snprintf(nodebuff, sizeof(nodebuff),
1660 "%s/" DEV_NAME "/%s", path, current_channel,
1661 media);
1662 REGISTER_NAMED_NODE(ob_ide, nodebuff);
1663 dnode = find_dev(nodebuff);
1664 set_int_property(dnode, "reg", j);
1665
1666 /* create aliases */
1667
1668 set_ide_alias(nodebuff);
1669 if (drive->media == ide_media_cdrom)
1670 set_cd_alias(nodebuff);
1671 if (drive->media == ide_media_disk)
1672 set_hd_alias(nodebuff);
1673 }
1674 }
1675
1676 return 0;
1677 }
1678 #endif /* CONFIG_DRIVER_MACIO */
OpenBIOS