qemu/roms/openbios/drivers/ide.c

   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;
1376         io_ports[1] = io_port1;
1377         ctl_ports[1] = ctl_port1;
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         /* IDE ports on Macs are numbered from 3.
1530          * Also see comments in macio.c:openpic_init() */
1531         current_channel = 3;
1532
1533         for (i = 0; i < nb_channels; i++, current_channel++) {
1534
1535                 chan = malloc(sizeof(struct ide_channel));
1536
1537                 snprintf(chan->name, sizeof(chan->name),
1538                          DEV_NAME, current_channel);
1539
1540                 chan->mmio = addr + MACIO_IDE_OFFSET + i * MACIO_IDE_SIZE;
1541
1542                 chan->obide_inb = macio_ide_inb;
1543                 chan->obide_insw = macio_ide_insw;
1544                 chan->obide_outb = macio_ide_outb;
1545                 chan->obide_outsw = macio_ide_outsw;
1546
1547                 chan->selected = -1;
1548
1549                 /*
1550                  * assume it's there, if not io port dead check will clear
1551                  */
1552                 chan->present = 1;
1553
1554                 for (j = 0; j < 2; j++) {
1555                         chan->drives[j].present = 0;
1556                         chan->drives[j].unit = j;
1557                         chan->drives[j].channel = chan;
1558                         /* init with a decent value */
1559                         chan->drives[j].bs = 512;
1560
1561                         chan->drives[j].nr = i * 2 + j;
1562                 }
1563
1564                 ob_ide_probe(chan);
1565
1566                 if (!chan->present) {
1567                         free(chan);
1568                         continue;
1569                 }
1570
1571                 ide_add_channel(chan);
1572
1573                 ob_ide_identify_drives(chan);
1574
1575                 snprintf(nodebuff, sizeof(nodebuff), "%s/" DEV_NAME, path,
1576                          current_channel);
1577                 REGISTER_NAMED_NODE(ob_ide_ctrl, nodebuff);
1578
1579                 dnode = find_dev(nodebuff);
1580
1581                 set_property(dnode, "compatible", (is_oldworld() ?
1582                              "heathrow-ata" : "keylargo-ata"), 13);
1583
1584                 props[0] = 0x00000526;
1585                 props[1] = 0x00000085;
1586                 props[2] = 0x00000025;
1587                 props[3] = 0x00000025;
1588                 props[4] = 0x00000025;
1589                 props[5] = 0x00000000;
1590                 props[6] = 0x00000000;
1591                 props[7] = 0x00000000;
1592                 OLDWORLD(set_property(dnode, "AAPL,pio-timing",
1593                                       (char *)&props, 8*sizeof(props[0])));
1594
1595                 /* The first interrupt entry is the ide interrupt, the second
1596                    the dbdma interrupt */
1597                 switch (i) {
1598                 case 0:
1599                         props[0] = 0x0000000d;
1600                         props[2] = 0x00000002;
1601                         break;
1602                 case 1:
1603                         props[0] = 0x0000000e;
1604                         props[2] = 0x00000003;
1605                         break;
1606                 case 2:
1607                         props[0] = 0x0000000f;
1608                         props[2] = 0x00000004;
1609                         break;
1610                 default:
1611                         props[0] = 0x00000000;
1612                         props[2] = 0x00000000;
1613                         break;
1614                 }
1615                 props[1] = 0x00000000; /* XXX level triggered on real hw */
1616                 props[3] = 0x00000000;
1617                 NEWWORLD(set_property(dnode, "interrupts",
1618                              (char *)&props, 4*sizeof(props[0])));
1619                 NEWWORLD(set_int_property(dnode, "#interrupt-cells", 2));
1620
1621                 props[1] = props[2];
1622                 OLDWORLD(set_property(dnode, "AAPL,interrupts",
1623                                       (char *)&props, 2*sizeof(props[0])));
1624
1625                 props[0] = MACIO_IDE_OFFSET + i * MACIO_IDE_SIZE;
1626                 props[1] = MACIO_IDE_SIZE;
1627                 props[2] = 0x00008b00 + i * 0x0200;
1628                 props[3] = 0x0200;
1629                 set_property(dnode, "reg", (char *)&props, 4*sizeof(props[0]));
1630
1631                 props[0] = addr + MACIO_IDE_OFFSET  + i * MACIO_IDE_SIZE;
1632                 props[1] = addr + 0x00008b00 + i * 0x0200;
1633                 OLDWORLD(set_property(dnode, "AAPL,address",
1634                                       (char *)&props, 2*sizeof(props[0])));
1635
1636                 props[0] = 0;
1637                 OLDWORLD(set_property(dnode, "AAPL,bus-id", (char*)props,
1638                          1 * sizeof(props[0])));
1639                 IDE_DPRINTF(DEV_NAME": [io ports 0x%lx]\n",
1640                             current_channel, chan->mmio);
1641
1642                 for (j = 0; j < 2; j++) {
1643                         struct ide_drive *drive = &chan->drives[j];
1644                         const char *media = "UNKNOWN";
1645
1646                         if (!drive->present)
1647                                 continue;
1648
1649                         IDE_DPRINTF("    drive%d [ATA%s ", j,
1650                                     drive->type == ide_type_atapi ? "PI" : "");
1651                         switch (drive->media) {
1652                                 case ide_media_floppy:
1653                                         media = "floppy";
1654                                         break;
1655                                 case ide_media_cdrom:
1656                                         media = "cdrom";
1657                                         break;
1658                                 case ide_media_optical:
1659                                         media = "mo";
1660                                         break;
1661                                 case ide_media_disk:
1662                                         media = "disk";
1663                                         break;
1664                         }
1665                         IDE_DPRINTF("%s]: %s\n", media, drive->model);
1666                         snprintf(nodebuff, sizeof(nodebuff),
1667                                  "%s/" DEV_NAME "/%s", path, current_channel,
1668                                  media);
1669                         REGISTER_NAMED_NODE(ob_ide, nodebuff);
1670                         dnode = find_dev(nodebuff);
1671                         set_int_property(dnode, "reg", j);
1672
1673                         /* create aliases */
1674
1675                         set_ide_alias(nodebuff);
1676                         if (drive->media == ide_media_cdrom)
1677                                 set_cd_alias(nodebuff);
1678                         if (drive->media == ide_media_disk)
1679                                 set_hd_alias(nodebuff);
1680                 }
1681         }
1682
1683         return 0;
1684 }
1685 #endif /* CONFIG_DRIVER_MACIO */