drivers/ide/pci/pdc202xx_new.c

   1 /*
   2  *  Promise TX2/TX4/TX2000/133 IDE driver
   3  *
   4  *  This program is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU General Public License
   6  *  as published by the Free Software Foundation; either version
   7  *  2 of the License, or (at your option) any later version.
   8  *
   9  *  Split from:
  10  *  linux/drivers/ide/pdc202xx.c        Version 0.35    Mar. 30, 2002
  11  *  Copyright (C) 1998-2002             Andre Hedrick <andre@linux-ide.org>
  12  *  Copyright (C) 2005-2006             MontaVista Software, Inc.
  13  *  Portions Copyright (C) 1999 Promise Technology, Inc.
  14  *  Author: Frank Tiernan (frankt@promise.com)
  15  *  Released under terms of General Public License
  16  */
  17
  18 #include <linux/module.h>
  19 #include <linux/types.h>
  20 #include <linux/kernel.h>
  21 #include <linux/delay.h>
  22 #include <linux/timer.h>
  23 #include <linux/mm.h>
  24 #include <linux/ioport.h>
  25 #include <linux/blkdev.h>
  26 #include <linux/hdreg.h>
  27 #include <linux/interrupt.h>
  28 #include <linux/pci.h>
  29 #include <linux/init.h>
  30 #include <linux/ide.h>
  31
  32 #include <asm/io.h>
  33 #include <asm/irq.h>
  34
  35 #ifdef CONFIG_PPC_PMAC
  36 #include <asm/prom.h>
  37 #include <asm/pci-bridge.h>
  38 #endif
  39
  40 #define PDC202_DEBUG_CABLE      0
  41
  42 #undef DEBUG
  43
  44 #ifdef DEBUG
  45 #define DBG(fmt, args...) printk("%s: " fmt, __FUNCTION__, ## args)
  46 #else
  47 #define DBG(fmt, args...)
  48 #endif
  49
  50 static const char *pdc_quirk_drives[] = {
  51         "QUANTUM FIREBALLlct08 08",
  52         "QUANTUM FIREBALLP KA6.4",
  53         "QUANTUM FIREBALLP KA9.1",
  54         "QUANTUM FIREBALLP LM20.4",
  55         "QUANTUM FIREBALLP KX13.6",
  56         "QUANTUM FIREBALLP KX20.5",
  57         "QUANTUM FIREBALLP KX27.3",
  58         "QUANTUM FIREBALLP LM20.5",
  59         NULL
  60 };
  61
  62 static u8 max_dma_rate(struct pci_dev *pdev)
  63 {
  64         u8 mode;
  65
  66         switch(pdev->device) {
  67                 case PCI_DEVICE_ID_PROMISE_20277:
  68                 case PCI_DEVICE_ID_PROMISE_20276:
  69                 case PCI_DEVICE_ID_PROMISE_20275:
  70                 case PCI_DEVICE_ID_PROMISE_20271:
  71                 case PCI_DEVICE_ID_PROMISE_20269:
  72                         mode = 4;
  73                         break;
  74                 case PCI_DEVICE_ID_PROMISE_20270:
  75                 case PCI_DEVICE_ID_PROMISE_20268:
  76                         mode = 3;
  77                         break;
  78                 default:
  79                         return 0;
  80         }
  81
  82         return mode;
  83 }
  84
  85 static u8 pdcnew_ratemask(ide_drive_t *drive)
  86 {
  87         u8 mode = max_dma_rate(HWIF(drive)->pci_dev);
  88
  89         if (!eighty_ninty_three(drive))
  90                 mode = min_t(u8, mode, 1);
  91
  92         return  mode;
  93 }
  94
  95 static int check_in_drive_lists(ide_drive_t *drive, const char **list)
  96 {
  97         struct hd_driveid *id = drive->id;
  98
  99         if (pdc_quirk_drives == list) {
 100                 while (*list) {
 101                         if (strstr(id->model, *list++)) {
 102                                 return 2;
 103                         }
 104                 }
 105         } else {
 106                 while (*list) {
 107                         if (!strcmp(*list++,id->model)) {
 108                                 return 1;
 109                         }
 110                 }
 111         }
 112         return 0;
 113 }
 114
 115 /**
 116  * get_indexed_reg - Get indexed register
 117  * @hwif: for the port address
 118  * @index: index of the indexed register
 119  */
 120 static u8 get_indexed_reg(ide_hwif_t *hwif, u8 index)
 121 {
 122         u8 value;
 123
 124         hwif->OUTB(index, hwif->dma_vendor1);
 125         value = hwif->INB(hwif->dma_vendor3);
 126
 127         DBG("index[%02X] value[%02X]\n", index, value);
 128         return value;
 129 }
 130
 131 /**
 132  * set_indexed_reg - Set indexed register
 133  * @hwif: for the port address
 134  * @index: index of the indexed register
 135  */
 136 static void set_indexed_reg(ide_hwif_t *hwif, u8 index, u8 value)
 137 {
 138         hwif->OUTB(index, hwif->dma_vendor1);
 139         hwif->OUTB(value, hwif->dma_vendor3);
 140         DBG("index[%02X] value[%02X]\n", index, value);
 141 }
 142
 143 /*
 144  * ATA Timing Tables based on 133 MHz PLL output clock.
 145  *
 146  * If the PLL outputs 100 MHz clock, the ASIC hardware will set
 147  * the timing registers automatically when "set features" command is
 148  * issued to the device. However, if the PLL output clock is 133 MHz,
 149  * the following tables must be used.
 150  */
 151 static struct pio_timing {
 152         u8 reg0c, reg0d, reg13;
 153 } pio_timings [] = {
 154         { 0xfb, 0x2b, 0xac },   /* PIO mode 0, IORDY off, Prefetch off */
 155         { 0x46, 0x29, 0xa4 },   /* PIO mode 1, IORDY off, Prefetch off */
 156         { 0x23, 0x26, 0x64 },   /* PIO mode 2, IORDY off, Prefetch off */
 157         { 0x27, 0x0d, 0x35 },   /* PIO mode 3, IORDY on,  Prefetch off */
 158         { 0x23, 0x09, 0x25 },   /* PIO mode 4, IORDY on,  Prefetch off */
 159 };
 160
 161 static struct mwdma_timing {
 162         u8 reg0e, reg0f;
 163 } mwdma_timings [] = {
 164         { 0xdf, 0x5f },         /* MWDMA mode 0 */
 165         { 0x6b, 0x27 },         /* MWDMA mode 1 */
 166         { 0x69, 0x25 },         /* MWDMA mode 2 */
 167 };
 168
 169 static struct udma_timing {
 170         u8 reg10, reg11, reg12;
 171 } udma_timings [] = {
 172         { 0x4a, 0x0f, 0xd5 },   /* UDMA mode 0 */
 173         { 0x3a, 0x0a, 0xd0 },   /* UDMA mode 1 */
 174         { 0x2a, 0x07, 0xcd },   /* UDMA mode 2 */
 175         { 0x1a, 0x05, 0xcd },   /* UDMA mode 3 */
 176         { 0x1a, 0x03, 0xcd },   /* UDMA mode 4 */
 177         { 0x1a, 0x02, 0xcb },   /* UDMA mode 5 */
 178         { 0x1a, 0x01, 0xcb },   /* UDMA mode 6 */
 179 };
 180
 181 static int pdcnew_tune_chipset(ide_drive_t *drive, u8 speed)
 182 {
 183         ide_hwif_t *hwif        = HWIF(drive);
 184         u8 adj                  = (drive->dn & 1) ? 0x08 : 0x00;
 185         int                     err;
 186
 187         speed = ide_rate_filter(pdcnew_ratemask(drive), speed);
 188
 189         /*
 190          * Issue SETFEATURES_XFER to the drive first. PDC202xx hardware will
 191          * automatically set the timing registers based on 100 MHz PLL output.
 192          */
 193         err = ide_config_drive_speed(drive, speed);
 194
 195         /*
 196          * As we set up the PLL to output 133 MHz for UltraDMA/133 capable
 197          * chips, we must override the default register settings...
 198          */
 199         if (max_dma_rate(hwif->pci_dev) == 4) {
 200                 u8 mode = speed & 0x07;
 201
 202                 switch (speed) {
 203                         case XFER_UDMA_6:
 204                         case XFER_UDMA_5:
 205                         case XFER_UDMA_4:
 206                         case XFER_UDMA_3:
 207                         case XFER_UDMA_2:
 208                         case XFER_UDMA_1:
 209                         case XFER_UDMA_0:
 210                                 set_indexed_reg(hwif, 0x10 + adj,
 211                                                 udma_timings[mode].reg10);
 212                                 set_indexed_reg(hwif, 0x11 + adj,
 213                                                 udma_timings[mode].reg11);
 214                                 set_indexed_reg(hwif, 0x12 + adj,
 215                                                 udma_timings[mode].reg12);
 216                                 break;
 217
 218                         case XFER_MW_DMA_2:
 219                         case XFER_MW_DMA_1:
 220                         case XFER_MW_DMA_0:
 221                                 set_indexed_reg(hwif, 0x0e + adj,
 222                                                 mwdma_timings[mode].reg0e);
 223                                 set_indexed_reg(hwif, 0x0f + adj,
 224                                                 mwdma_timings[mode].reg0f);
 225                                 break;
 226                         case XFER_PIO_4:
 227                         case XFER_PIO_3:
 228                         case XFER_PIO_2:
 229                         case XFER_PIO_1:
 230                         case XFER_PIO_0:
 231                                 set_indexed_reg(hwif, 0x0c + adj,
 232                                                 pio_timings[mode].reg0c);
 233                                 set_indexed_reg(hwif, 0x0d + adj,
 234                                                 pio_timings[mode].reg0d);
 235                                 set_indexed_reg(hwif, 0x13 + adj,
 236                                                 pio_timings[mode].reg13);
 237                                 break;
 238                         default:
 239                                 printk(KERN_ERR "pdc202xx_new: "
 240                                        "Unknown speed %d ignored\n", speed);
 241                 }
 242         } else if (speed == XFER_UDMA_2) {
 243                 /* Set tHOLD bit to 0 if using UDMA mode 2 */
 244                 u8 tmp = get_indexed_reg(hwif, 0x10 + adj);
 245
 246                 set_indexed_reg(hwif, 0x10 + adj, tmp & 0x7f);
 247         }
 248
 249         return err;
 250 }
 251
 252 static void pdcnew_tune_drive(ide_drive_t *drive, u8 pio)
 253 {
 254         pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
 255         (void)pdcnew_tune_chipset(drive, XFER_PIO_0 + pio);
 256 }
 257
 258 static u8 pdcnew_cable_detect(ide_hwif_t *hwif)
 259 {
 260         return get_indexed_reg(hwif, 0x0b) & 0x04;
 261 }
 262
 263 static int config_chipset_for_dma(ide_drive_t *drive)
 264 {
 265         struct hd_driveid *id   = drive->id;
 266         ide_hwif_t *hwif        = HWIF(drive);
 267         u8 ultra_66             = (id->dma_ultra & 0x0078) ? 1 : 0;
 268         u8 cable                = pdcnew_cable_detect(hwif);
 269         u8 speed;
 270
 271         if (ultra_66 && cable) {
 272                 printk(KERN_WARNING "Warning: %s channel "
 273                        "requires an 80-pin cable for operation.\n",
 274                        hwif->channel ? "Secondary" : "Primary");
 275                 printk(KERN_WARNING "%s reduced to Ultra33 mode.\n", drive->name);
 276         }
 277
 278         if (drive->media != ide_disk)
 279                 return 0;
 280
 281         if (id->capability & 4) {
 282                 /*
 283                  * Set IORDY_EN & PREFETCH_EN (this seems to have
 284                  * NO real effect since this register is reloaded
 285                  * by hardware when the transfer mode is selected)
 286                  */
 287                 u8 tmp, adj = (drive->dn & 1) ? 0x08 : 0x00;
 288
 289                 tmp = get_indexed_reg(hwif, 0x13 + adj);
 290                 set_indexed_reg(hwif, 0x13 + adj, tmp | 0x03);
 291         }
 292
 293         speed = ide_dma_speed(drive, pdcnew_ratemask(drive));
 294
 295         if (!speed)
 296                 return 0;
 297
 298         (void) hwif->speedproc(drive, speed);
 299         return ide_dma_enable(drive);
 300 }
 301
 302 static int pdcnew_config_drive_xfer_rate(ide_drive_t *drive)
 303 {
 304         ide_hwif_t *hwif        = HWIF(drive);
 305         struct hd_driveid *id   = drive->id;
 306
 307         drive->init_speed = 0;
 308
 309         if ((id->capability & 1) && drive->autodma) {
 310
 311                 if (ide_use_dma(drive) && config_chipset_for_dma(drive))
 312                         return hwif->ide_dma_on(drive);
 313
 314                 goto fast_ata_pio;
 315
 316         } else if ((id->capability & 8) || (id->field_valid & 2)) {
 317 fast_ata_pio:
 318                 hwif->tuneproc(drive, 255);
 319                 return hwif->ide_dma_off_quietly(drive);
 320         }
 321         /* IORDY not supported */
 322         return 0;
 323 }
 324
 325 static int pdcnew_quirkproc(ide_drive_t *drive)
 326 {
 327         return check_in_drive_lists(drive, pdc_quirk_drives);
 328 }
 329
 330 static void pdcnew_reset(ide_drive_t *drive)
 331 {
 332         /*
 333          * Deleted this because it is redundant from the caller.
 334          */
 335         printk(KERN_WARNING "pdc202xx_new: %s channel reset.\n",
 336                 HWIF(drive)->channel ? "Secondary" : "Primary");
 337 }
 338
 339 /**
 340  * read_counter - Read the byte count registers
 341  * @dma_base: for the port address
 342  */
 343 static long __devinit read_counter(u32 dma_base)
 344 {
 345         u32  pri_dma_base = dma_base, sec_dma_base = dma_base + 0x08;
 346         u8   cnt0, cnt1, cnt2, cnt3;
 347         long count = 0, last;
 348         int  retry = 3;
 349
 350         do {
 351                 last = count;
 352
 353                 /* Read the current count */
 354                 outb(0x20, pri_dma_base + 0x01);
 355                 cnt0 = inb(pri_dma_base + 0x03);
 356                 outb(0x21, pri_dma_base + 0x01);
 357                 cnt1 = inb(pri_dma_base + 0x03);
 358                 outb(0x20, sec_dma_base + 0x01);
 359                 cnt2 = inb(sec_dma_base + 0x03);
 360                 outb(0x21, sec_dma_base + 0x01);
 361                 cnt3 = inb(sec_dma_base + 0x03);
 362
 363                 count = (cnt3 << 23) | (cnt2 << 15) | (cnt1 << 8) | cnt0;
 364
 365                 /*
 366                  * The 30-bit decrementing counter is read in 4 pieces.
 367                  * Incorrect value may be read when the most significant bytes
 368                  * are changing...
 369                  */
 370         } while (retry-- && (((last ^ count) & 0x3fff8000) || last < count));
 371
 372         DBG("cnt0[%02X] cnt1[%02X] cnt2[%02X] cnt3[%02X]\n",
 373                   cnt0, cnt1, cnt2, cnt3);
 374
 375         return count;
 376 }
 377
 378 /**
 379  * detect_pll_input_clock - Detect the PLL input clock in Hz.
 380  * @dma_base: for the port address
 381  * E.g. 16949000 on 33 MHz PCI bus, i.e. half of the PCI clock.
 382  */
 383 static long __devinit detect_pll_input_clock(unsigned long dma_base)
 384 {
 385         long start_count, end_count;
 386         long pll_input;
 387         u8 scr1;
 388
 389         start_count = read_counter(dma_base);
 390
 391         /* Start the test mode */
 392         outb(0x01, dma_base + 0x01);
 393         scr1 = inb(dma_base + 0x03);
 394         DBG("scr1[%02X]\n", scr1);
 395         outb(scr1 | 0x40, dma_base + 0x03);
 396
 397         /* Let the counter run for 10 ms. */
 398         mdelay(10);
 399
 400         end_count = read_counter(dma_base);
 401
 402         /* Stop the test mode */
 403         outb(0x01, dma_base + 0x01);
 404         scr1 = inb(dma_base + 0x03);
 405         DBG("scr1[%02X]\n", scr1);
 406         outb(scr1 & ~0x40, dma_base + 0x03);
 407
 408         /*
 409          * Calculate the input clock in Hz
 410          * (the clock counter is 30 bit wide and counts down)
 411          */
 412         pll_input = ((start_count - end_count) & 0x3ffffff) * 100;
 413
 414         DBG("start[%ld] end[%ld]\n", start_count, end_count);
 415
 416         return pll_input;
 417 }
 418
 419 #ifdef CONFIG_PPC_PMAC
 420 static void __devinit apple_kiwi_init(struct pci_dev *pdev)
 421 {
 422         struct device_node *np = pci_device_to_OF_node(pdev);
 423         unsigned int class_rev = 0;
 424         u8 conf;
 425
 426         if (np == NULL || !device_is_compatible(np, "kiwi-root"))
 427                 return;
 428
 429         pci_read_config_dword(pdev, PCI_CLASS_REVISION, &class_rev);
 430         class_rev &= 0xff;
 431
 432         if (class_rev >= 0x03) {
 433                 /* Setup chip magic config stuff (from darwin) */
 434                 pci_read_config_byte (pdev, 0x40, &conf);
 435                 pci_write_config_byte(pdev, 0x40, (conf | 0x01));
 436         }
 437 }
 438 #endif /* CONFIG_PPC_PMAC */
 439
 440 static unsigned int __devinit init_chipset_pdcnew(struct pci_dev *dev, const char *name)
 441 {
 442         unsigned long dma_base = pci_resource_start(dev, 4);
 443         unsigned long sec_dma_base = dma_base + 0x08;
 444         long pll_input, pll_output, ratio;
 445         int f, r;
 446         u8 pll_ctl0, pll_ctl1;
 447
 448         if (dev->resource[PCI_ROM_RESOURCE].start) {
 449                 pci_write_config_dword(dev, PCI_ROM_ADDRESS,
 450                         dev->resource[PCI_ROM_RESOURCE].start | PCI_ROM_ADDRESS_ENABLE);
 451                 printk(KERN_INFO "%s: ROM enabled at 0x%08lx\n", name,
 452                         (unsigned long)dev->resource[PCI_ROM_RESOURCE].start);
 453         }
 454
 455 #ifdef CONFIG_PPC_PMAC
 456         apple_kiwi_init(dev);
 457 #endif
 458
 459         /* Calculate the required PLL output frequency */
 460         switch(max_dma_rate(dev)) {
 461                 case 4: /* it's 133 MHz for Ultra133 chips */
 462                         pll_output = 133333333;
 463                         break;
 464                 case 3: /* and  100 MHz for Ultra100 chips */
 465                 default:
 466                         pll_output = 100000000;
 467                         break;
 468         }
 469
 470         /*
 471          * Detect PLL input clock.
 472          * On some systems, where PCI bus is running at non-standard clock rate
 473          * (e.g. 25 or 40 MHz), we have to adjust the cycle time.
 474          * PDC20268 and newer chips employ PLL circuit to help correct timing
 475          * registers setting.
 476          */
 477         pll_input = detect_pll_input_clock(dma_base);
 478         printk("%s: PLL input clock is %ld kHz\n", name, pll_input / 1000);
 479
 480         /* Sanity check */
 481         if (unlikely(pll_input < 5000000L || pll_input > 70000000L)) {
 482                 printk(KERN_ERR "%s: Bad PLL input clock %ld Hz, giving up!\n",
 483                        name, pll_input);
 484                 goto out;
 485         }
 486
 487 #ifdef DEBUG
 488         DBG("pll_output is %ld Hz\n", pll_output);
 489
 490         /* Show the current clock value of PLL control register
 491          * (maybe already configured by the BIOS)
 492          */
 493         outb(0x02, sec_dma_base + 0x01);
 494         pll_ctl0 = inb(sec_dma_base + 0x03);
 495         outb(0x03, sec_dma_base + 0x01);
 496         pll_ctl1 = inb(sec_dma_base + 0x03);
 497
 498         DBG("pll_ctl[%02X][%02X]\n", pll_ctl0, pll_ctl1);
 499 #endif
 500
 501         /*
 502          * Calculate the ratio of F, R and NO
 503          * POUT = (F + 2) / (( R + 2) * NO)
 504          */
 505         ratio = pll_output / (pll_input / 1000);
 506         if (ratio < 8600L) { /* 8.6x */
 507                 /* Using NO = 0x01, R = 0x0d */
 508                 r = 0x0d;
 509         } else if (ratio < 12900L) { /* 12.9x */
 510                 /* Using NO = 0x01, R = 0x08 */
 511                 r = 0x08;
 512         } else if (ratio < 16100L) { /* 16.1x */
 513                 /* Using NO = 0x01, R = 0x06 */
 514                 r = 0x06;
 515         } else if (ratio < 64000L) { /* 64x */
 516                 r = 0x00;
 517         } else {
 518                 /* Invalid ratio */
 519                 printk(KERN_ERR "%s: Bad ratio %ld, giving up!\n", name, ratio);
 520                 goto out;
 521         }
 522
 523         f = (ratio * (r + 2)) / 1000 - 2;
 524
 525         DBG("F[%d] R[%d] ratio*1000[%ld]\n", f, r, ratio);
 526
 527         if (unlikely(f < 0 || f > 127)) {
 528                 /* Invalid F */
 529                 printk(KERN_ERR "%s: F[%d] invalid!\n", name, f);
 530                 goto out;
 531         }
 532
 533         pll_ctl0 = (u8) f;
 534         pll_ctl1 = (u8) r;
 535
 536         DBG("Writing pll_ctl[%02X][%02X]\n", pll_ctl0, pll_ctl1);
 537
 538         outb(0x02,     sec_dma_base + 0x01);
 539         outb(pll_ctl0, sec_dma_base + 0x03);
 540         outb(0x03,     sec_dma_base + 0x01);
 541         outb(pll_ctl1, sec_dma_base + 0x03);
 542
 543         /* Wait the PLL circuit to be stable */
 544         mdelay(30);
 545
 546 #ifdef DEBUG
 547         /*
 548          *  Show the current clock value of PLL control register
 549          */
 550         outb(0x02, sec_dma_base + 0x01);
 551         pll_ctl0 = inb(sec_dma_base + 0x03);
 552         outb(0x03, sec_dma_base + 0x01);
 553         pll_ctl1 = inb(sec_dma_base + 0x03);
 554
 555         DBG("pll_ctl[%02X][%02X]\n", pll_ctl0, pll_ctl1);
 556 #endif
 557
 558  out:
 559         return dev->irq;
 560 }
 561
 562 static void __devinit init_hwif_pdc202new(ide_hwif_t *hwif)
 563 {
 564         hwif->autodma = 0;
 565
 566         hwif->tuneproc  = &pdcnew_tune_drive;
 567         hwif->quirkproc = &pdcnew_quirkproc;
 568         hwif->speedproc = &pdcnew_tune_chipset;
 569         hwif->resetproc = &pdcnew_reset;
 570
 571         hwif->drives[0].autotune = hwif->drives[1].autotune = 1;
 572
 573         hwif->ultra_mask = 0x7f;
 574         hwif->mwdma_mask = 0x07;
 575
 576         hwif->err_stops_fifo = 1;
 577
 578         hwif->ide_dma_check = &pdcnew_config_drive_xfer_rate;
 579
 580         if (!hwif->udma_four)
 581                 hwif->udma_four = pdcnew_cable_detect(hwif) ? 0 : 1;
 582
 583         if (!noautodma)
 584                 hwif->autodma = 1;
 585         hwif->drives[0].autodma = hwif->drives[1].autodma = hwif->autodma;
 586
 587 #if PDC202_DEBUG_CABLE
 588         printk(KERN_DEBUG "%s: %s-pin cable\n",
 589                 hwif->name, hwif->udma_four ? "80" : "40");
 590 #endif /* PDC202_DEBUG_CABLE */
 591 }
 592
 593 static int __devinit init_setup_pdcnew(struct pci_dev *dev, ide_pci_device_t *d)
 594 {
 595         return ide_setup_pci_device(dev, d);
 596 }
 597
 598 static int __devinit init_setup_pdc20270(struct pci_dev *dev,
 599                                          ide_pci_device_t *d)
 600 {
 601         struct pci_dev *findev = NULL;
 602         int ret;
 603
 604         if ((dev->bus->self &&
 605              dev->bus->self->vendor == PCI_VENDOR_ID_DEC) &&
 606             (dev->bus->self->device == PCI_DEVICE_ID_DEC_21150)) {
 607                 if (PCI_SLOT(dev->devfn) & 2)
 608                         return -ENODEV;
 609                 d->extra = 0;
 610                 while ((findev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, findev)) != NULL) {
 611                         if ((findev->vendor == dev->vendor) &&
 612                             (findev->device == dev->device) &&
 613                             (PCI_SLOT(findev->devfn) & 2)) {
 614                                 if (findev->irq != dev->irq) {
 615                                         findev->irq = dev->irq;
 616                                 }
 617                                 ret = ide_setup_pci_devices(dev, findev, d);
 618                                 pci_dev_put(findev);
 619                                 return ret;
 620                         }
 621                 }
 622         }
 623         return ide_setup_pci_device(dev, d);
 624 }
 625
 626 static int __devinit init_setup_pdc20276(struct pci_dev *dev,
 627                                          ide_pci_device_t *d)
 628 {
 629         if ((dev->bus->self) &&
 630             (dev->bus->self->vendor == PCI_VENDOR_ID_INTEL) &&
 631             ((dev->bus->self->device == PCI_DEVICE_ID_INTEL_I960) ||
 632              (dev->bus->self->device == PCI_DEVICE_ID_INTEL_I960RM))) {
 633                 printk(KERN_INFO "ide: Skipping Promise PDC20276 "
 634                         "attached to I2O RAID controller.\n");
 635                 return -ENODEV;
 636         }
 637         return ide_setup_pci_device(dev, d);
 638 }
 639
 640 static ide_pci_device_t pdcnew_chipsets[] __devinitdata = {
 641         {       /* 0 */
 642                 .name           = "PDC20268",
 643                 .init_setup     = init_setup_pdcnew,
 644                 .init_chipset   = init_chipset_pdcnew,
 645                 .init_hwif      = init_hwif_pdc202new,
 646                 .channels       = 2,
 647                 .autodma        = AUTODMA,
 648                 .bootable       = OFF_BOARD,
 649         },{     /* 1 */
 650                 .name           = "PDC20269",
 651                 .init_setup     = init_setup_pdcnew,
 652                 .init_chipset   = init_chipset_pdcnew,
 653                 .init_hwif      = init_hwif_pdc202new,
 654                 .channels       = 2,
 655                 .autodma        = AUTODMA,
 656                 .bootable       = OFF_BOARD,
 657         },{     /* 2 */
 658                 .name           = "PDC20270",
 659                 .init_setup     = init_setup_pdc20270,
 660                 .init_chipset   = init_chipset_pdcnew,
 661                 .init_hwif      = init_hwif_pdc202new,
 662                 .channels       = 2,
 663                 .autodma        = AUTODMA,
 664                 .bootable       = OFF_BOARD,
 665         },{     /* 3 */
 666                 .name           = "PDC20271",
 667                 .init_setup     = init_setup_pdcnew,
 668                 .init_chipset   = init_chipset_pdcnew,
 669                 .init_hwif      = init_hwif_pdc202new,
 670                 .channels       = 2,
 671                 .autodma        = AUTODMA,
 672                 .bootable       = OFF_BOARD,
 673         },{     /* 4 */
 674                 .name           = "PDC20275",
 675                 .init_setup     = init_setup_pdcnew,
 676                 .init_chipset   = init_chipset_pdcnew,
 677                 .init_hwif      = init_hwif_pdc202new,
 678                 .channels       = 2,
 679                 .autodma        = AUTODMA,
 680                 .bootable       = OFF_BOARD,
 681         },{     /* 5 */
 682                 .name           = "PDC20276",
 683                 .init_setup     = init_setup_pdc20276,
 684                 .init_chipset   = init_chipset_pdcnew,
 685                 .init_hwif      = init_hwif_pdc202new,
 686                 .channels       = 2,
 687                 .autodma        = AUTODMA,
 688                 .bootable       = OFF_BOARD,
 689         },{     /* 6 */
 690                 .name           = "PDC20277",
 691                 .init_setup     = init_setup_pdcnew,
 692                 .init_chipset   = init_chipset_pdcnew,
 693                 .init_hwif      = init_hwif_pdc202new,
 694                 .channels       = 2,
 695                 .autodma        = AUTODMA,
 696                 .bootable       = OFF_BOARD,
 697         }
 698 };
 699
 700 /**
 701  *      pdc202new_init_one      -       called when a pdc202xx is found
 702  *      @dev: the pdc202new device
 703  *      @id: the matching pci id
 704  *
 705  *      Called when the PCI registration layer (or the IDE initialization)
 706  *      finds a device matching our IDE device tables.
 707  */
 708
 709 static int __devinit pdc202new_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 710 {
 711         ide_pci_device_t *d = &pdcnew_chipsets[id->driver_data];
 712
 713         return d->init_setup(dev, d);
 714 }
 715
 716 static struct pci_device_id pdc202new_pci_tbl[] = {
 717         { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20268, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 718         { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20269, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
 719         { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20270, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2},
 720         { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20271, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3},
 721         { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20275, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4},
 722         { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20276, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5},
 723         { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20277, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 6},
 724         { 0, },
 725 };
 726 MODULE_DEVICE_TABLE(pci, pdc202new_pci_tbl);
 727
 728 static struct pci_driver driver = {
 729         .name           = "Promise_IDE",
 730         .id_table       = pdc202new_pci_tbl,
 731         .probe          = pdc202new_init_one,
 732 };
 733
 734 static int __init pdc202new_ide_init(void)
 735 {
 736         return ide_pci_register_driver(&driver);
 737 }
 738
 739 module_init(pdc202new_ide_init);
 740
 741 MODULE_AUTHOR("Andre Hedrick, Frank Tiernan");
 742 MODULE_DESCRIPTION("PCI driver module for Promise PDC20268 and higher");
 743 MODULE_LICENSE("GPL");