![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ide.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / drivers|
Return to ide.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / drivers |
1.1 root 1: /*
2: * OpenBIOS polled ide driver
3: *
4: * Copyright (C) 2004 Jens Axboe <[email protected]>
5: * Copyright (C) 2005 Stefan Reinauer <[email protected]>
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 *) ∩
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 */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.