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