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-2007             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 void pdcnew_set_mode(ide_drive_t *drive, const u8 speed)
 150 {
 151         ide_hwif_t *hwif        = HWIF(drive);
 152         u8 adj                  = (drive->dn & 1) ? 0x08 : 0x00;
 153
 154         /*
 155          * IDE core issues SETFEATURES_XFER to the drive first (thanks to
 156          * IDE_HFLAG_POST_SET_MODE in ->host_flags).  PDC202xx hardware will
 157          * automatically set the timing registers based on 100 MHz PLL output.
 158          *
 159          * As we set up the PLL to output 133 MHz for UltraDMA/133 capable
 160          * chips, we must override the default register settings...
 161          */
 162         if (max_dma_rate(hwif->pci_dev) == 4) {
 163                 u8 mode = speed & 0x07;
 164
 165                 switch (speed) {
 166                         case XFER_UDMA_6:
 167                         case XFER_UDMA_5:
 168                         case XFER_UDMA_4:
 169                         case XFER_UDMA_3:
 170                         case XFER_UDMA_2:
 171                         case XFER_UDMA_1:
 172                         case XFER_UDMA_0:
 173                                 set_indexed_reg(hwif, 0x10 + adj,
 174                                                 udma_timings[mode].reg10);
 175                                 set_indexed_reg(hwif, 0x11 + adj,
 176                                                 udma_timings[mode].reg11);
 177                                 set_indexed_reg(hwif, 0x12 + adj,
 178                                                 udma_timings[mode].reg12);
 179                                 break;
 180
 181                         case XFER_MW_DMA_2:
 182                         case XFER_MW_DMA_1:
 183                         case XFER_MW_DMA_0:
 184                                 set_indexed_reg(hwif, 0x0e + adj,
 185                                                 mwdma_timings[mode].reg0e);
 186                                 set_indexed_reg(hwif, 0x0f + adj,
 187                                                 mwdma_timings[mode].reg0f);
 188                                 break;
 189                         case XFER_PIO_4:
 190                         case XFER_PIO_3:
 191                         case XFER_PIO_2:
 192                         case XFER_PIO_1:
 193                         case XFER_PIO_0:
 194                                 set_indexed_reg(hwif, 0x0c + adj,
 195                                                 pio_timings[mode].reg0c);
 196                                 set_indexed_reg(hwif, 0x0d + adj,
 197                                                 pio_timings[mode].reg0d);
 198                                 set_indexed_reg(hwif, 0x13 + adj,
 199                                                 pio_timings[mode].reg13);
 200                                 break;
 201                         default:
 202                                 printk(KERN_ERR "pdc202xx_new: "
 203                                        "Unknown speed %d ignored\n", speed);
 204                 }
 205         } else if (speed == XFER_UDMA_2) {
 206                 /* Set tHOLD bit to 0 if using UDMA mode 2 */
 207                 u8 tmp = get_indexed_reg(hwif, 0x10 + adj);
 208
 209                 set_indexed_reg(hwif, 0x10 + adj, tmp & 0x7f);
 210         }
 211 }
 212
 213 static void pdcnew_set_pio_mode(ide_drive_t *drive, const u8 pio)
 214 {
 215         pdcnew_set_mode(drive, XFER_PIO_0 + pio);
 216 }
 217
 218 static u8 pdcnew_cable_detect(ide_hwif_t *hwif)
 219 {
 220         if (get_indexed_reg(hwif, 0x0b) & 0x04)
 221                 return ATA_CBL_PATA40;
 222         else
 223                 return ATA_CBL_PATA80;
 224 }
 225
 226 static int pdcnew_config_drive_xfer_rate(ide_drive_t *drive)
 227 {
 228         if (ide_tune_dma(drive))
 229                 return 0;
 230
 231         ide_set_max_pio(drive);
 232
 233         return -1;
 234 }
 235
 236 static int pdcnew_quirkproc(ide_drive_t *drive)
 237 {
 238         const char **list, *model = drive->id->model;
 239
 240         for (list = pdc_quirk_drives; *list != NULL; list++)
 241                 if (strstr(model, *list) != NULL)
 242                         return 2;
 243         return 0;
 244 }
 245
 246 static void pdcnew_reset(ide_drive_t *drive)
 247 {
 248         /*
 249          * Deleted this because it is redundant from the caller.
 250          */
 251         printk(KERN_WARNING "pdc202xx_new: %s channel reset.\n",
 252                 HWIF(drive)->channel ? "Secondary" : "Primary");
 253 }
 254
 255 /**
 256  * read_counter - Read the byte count registers
 257  * @dma_base: for the port address
 258  */
 259 static long __devinit read_counter(u32 dma_base)
 260 {
 261         u32  pri_dma_base = dma_base, sec_dma_base = dma_base + 0x08;
 262         u8   cnt0, cnt1, cnt2, cnt3;
 263         long count = 0, last;
 264         int  retry = 3;
 265
 266         do {
 267                 last = count;
 268
 269                 /* Read the current count */
 270                 outb(0x20, pri_dma_base + 0x01);
 271                 cnt0 = inb(pri_dma_base + 0x03);
 272                 outb(0x21, pri_dma_base + 0x01);
 273                 cnt1 = inb(pri_dma_base + 0x03);
 274                 outb(0x20, sec_dma_base + 0x01);
 275                 cnt2 = inb(sec_dma_base + 0x03);
 276                 outb(0x21, sec_dma_base + 0x01);
 277                 cnt3 = inb(sec_dma_base + 0x03);
 278
 279                 count = (cnt3 << 23) | (cnt2 << 15) | (cnt1 << 8) | cnt0;
 280
 281                 /*
 282                  * The 30-bit decrementing counter is read in 4 pieces.
 283                  * Incorrect value may be read when the most significant bytes
 284                  * are changing...
 285                  */
 286         } while (retry-- && (((last ^ count) & 0x3fff8000) || last < count));
 287
 288         DBG("cnt0[%02X] cnt1[%02X] cnt2[%02X] cnt3[%02X]\n",
 289                   cnt0, cnt1, cnt2, cnt3);
 290
 291         return count;
 292 }
 293
 294 /**
 295  * detect_pll_input_clock - Detect the PLL input clock in Hz.
 296  * @dma_base: for the port address
 297  * E.g. 16949000 on 33 MHz PCI bus, i.e. half of the PCI clock.
 298  */
 299 static long __devinit detect_pll_input_clock(unsigned long dma_base)
 300 {
 301         struct timeval start_time, end_time;
 302         long start_count, end_count;
 303         long pll_input, usec_elapsed;
 304         u8 scr1;
 305
 306         start_count = read_counter(dma_base);
 307         do_gettimeofday(&start_time);
 308
 309         /* Start the test mode */
 310         outb(0x01, dma_base + 0x01);
 311         scr1 = inb(dma_base + 0x03);
 312         DBG("scr1[%02X]\n", scr1);
 313         outb(scr1 | 0x40, dma_base + 0x03);
 314
 315         /* Let the counter run for 10 ms. */
 316         mdelay(10);
 317
 318         end_count = read_counter(dma_base);
 319         do_gettimeofday(&end_time);
 320
 321         /* Stop the test mode */
 322         outb(0x01, dma_base + 0x01);
 323         scr1 = inb(dma_base + 0x03);
 324         DBG("scr1[%02X]\n", scr1);
 325         outb(scr1 & ~0x40, dma_base + 0x03);
 326
 327         /*
 328          * Calculate the input clock in Hz
 329          * (the clock counter is 30 bit wide and counts down)
 330          */
 331         usec_elapsed = (end_time.tv_sec - start_time.tv_sec) * 1000000 +
 332                 (end_time.tv_usec - start_time.tv_usec);
 333         pll_input = ((start_count - end_count) & 0x3fffffff) / 10 *
 334                 (10000000 / usec_elapsed);
 335
 336         DBG("start[%ld] end[%ld]\n", start_count, end_count);
 337
 338         return pll_input;
 339 }
 340
 341 #ifdef CONFIG_PPC_PMAC
 342 static void __devinit apple_kiwi_init(struct pci_dev *pdev)
 343 {
 344         struct device_node *np = pci_device_to_OF_node(pdev);
 345         unsigned int class_rev = 0;
 346         u8 conf;
 347
 348         if (np == NULL || !of_device_is_compatible(np, "kiwi-root"))
 349                 return;
 350
 351         pci_read_config_dword(pdev, PCI_CLASS_REVISION, &class_rev);
 352         class_rev &= 0xff;
 353
 354         if (class_rev >= 0x03) {
 355                 /* Setup chip magic config stuff (from darwin) */
 356                 pci_read_config_byte (pdev, 0x40, &conf);
 357                 pci_write_config_byte(pdev, 0x40, (conf | 0x01));
 358         }
 359 }
 360 #endif /* CONFIG_PPC_PMAC */
 361
 362 static unsigned int __devinit init_chipset_pdcnew(struct pci_dev *dev, const char *name)
 363 {
 364         unsigned long dma_base = pci_resource_start(dev, 4);
 365         unsigned long sec_dma_base = dma_base + 0x08;
 366         long pll_input, pll_output, ratio;
 367         int f, r;
 368         u8 pll_ctl0, pll_ctl1;
 369
 370         if (dma_base == 0)
 371                 return -EFAULT;
 372
 373 #ifdef CONFIG_PPC_PMAC
 374         apple_kiwi_init(dev);
 375 #endif
 376
 377         /* Calculate the required PLL output frequency */
 378         switch(max_dma_rate(dev)) {
 379                 case 4: /* it's 133 MHz for Ultra133 chips */
 380                         pll_output = 133333333;
 381                         break;
 382                 case 3: /* and  100 MHz for Ultra100 chips */
 383                 default:
 384                         pll_output = 100000000;
 385                         break;
 386         }
 387
 388         /*
 389          * Detect PLL input clock.
 390          * On some systems, where PCI bus is running at non-standard clock rate
 391          * (e.g. 25 or 40 MHz), we have to adjust the cycle time.
 392          * PDC20268 and newer chips employ PLL circuit to help correct timing
 393          * registers setting.
 394          */
 395         pll_input = detect_pll_input_clock(dma_base);
 396         printk("%s: PLL input clock is %ld kHz\n", name, pll_input / 1000);
 397
 398         /* Sanity check */
 399         if (unlikely(pll_input < 5000000L || pll_input > 70000000L)) {
 400                 printk(KERN_ERR "%s: Bad PLL input clock %ld Hz, giving up!\n",
 401                        name, pll_input);
 402                 goto out;
 403         }
 404
 405 #ifdef DEBUG
 406         DBG("pll_output is %ld Hz\n", pll_output);
 407
 408         /* Show the current clock value of PLL control register
 409          * (maybe already configured by the BIOS)
 410          */
 411         outb(0x02, sec_dma_base + 0x01);
 412         pll_ctl0 = inb(sec_dma_base + 0x03);
 413         outb(0x03, sec_dma_base + 0x01);
 414         pll_ctl1 = inb(sec_dma_base + 0x03);
 415
 416         DBG("pll_ctl[%02X][%02X]\n", pll_ctl0, pll_ctl1);
 417 #endif
 418
 419         /*
 420          * Calculate the ratio of F, R and NO
 421          * POUT = (F + 2) / (( R + 2) * NO)
 422          */
 423         ratio = pll_output / (pll_input / 1000);
 424         if (ratio < 8600L) { /* 8.6x */
 425                 /* Using NO = 0x01, R = 0x0d */
 426                 r = 0x0d;
 427         } else if (ratio < 12900L) { /* 12.9x */
 428                 /* Using NO = 0x01, R = 0x08 */
 429                 r = 0x08;
 430         } else if (ratio < 16100L) { /* 16.1x */
 431                 /* Using NO = 0x01, R = 0x06 */
 432                 r = 0x06;
 433         } else if (ratio < 64000L) { /* 64x */
 434                 r = 0x00;
 435         } else {
 436                 /* Invalid ratio */
 437                 printk(KERN_ERR "%s: Bad ratio %ld, giving up!\n", name, ratio);
 438                 goto out;
 439         }
 440
 441         f = (ratio * (r + 2)) / 1000 - 2;
 442
 443         DBG("F[%d] R[%d] ratio*1000[%ld]\n", f, r, ratio);
 444
 445         if (unlikely(f < 0 || f > 127)) {
 446                 /* Invalid F */
 447                 printk(KERN_ERR "%s: F[%d] invalid!\n", name, f);
 448                 goto out;
 449         }
 450
 451         pll_ctl0 = (u8) f;
 452         pll_ctl1 = (u8) r;
 453
 454         DBG("Writing pll_ctl[%02X][%02X]\n", pll_ctl0, pll_ctl1);
 455
 456         outb(0x02,     sec_dma_base + 0x01);
 457         outb(pll_ctl0, sec_dma_base + 0x03);
 458         outb(0x03,     sec_dma_base + 0x01);
 459         outb(pll_ctl1, sec_dma_base + 0x03);
 460
 461         /* Wait the PLL circuit to be stable */
 462         mdelay(30);
 463
 464 #ifdef DEBUG
 465         /*
 466          *  Show the current clock value of PLL control register
 467          */
 468         outb(0x02, sec_dma_base + 0x01);
 469         pll_ctl0 = inb(sec_dma_base + 0x03);
 470         outb(0x03, sec_dma_base + 0x01);
 471         pll_ctl1 = inb(sec_dma_base + 0x03);
 472
 473         DBG("pll_ctl[%02X][%02X]\n", pll_ctl0, pll_ctl1);
 474 #endif
 475
 476  out:
 477         return dev->irq;
 478 }
 479
 480 static void __devinit init_hwif_pdc202new(ide_hwif_t *hwif)
 481 {
 482         hwif->autodma = 0;
 483
 484         hwif->set_pio_mode = &pdcnew_set_pio_mode;
 485         hwif->set_dma_mode = &pdcnew_set_mode;
 486
 487         hwif->quirkproc = &pdcnew_quirkproc;
 488         hwif->resetproc = &pdcnew_reset;
 489
 490         hwif->err_stops_fifo = 1;
 491
 492         hwif->drives[0].autotune = hwif->drives[1].autotune = 1;
 493
 494         if (hwif->dma_base == 0)
 495                 return;
 496
 497         hwif->atapi_dma  = 1;
 498
 499         hwif->ultra_mask = hwif->cds->udma_mask;
 500         hwif->mwdma_mask = 0x07;
 501
 502         hwif->ide_dma_check = &pdcnew_config_drive_xfer_rate;
 503
 504         if (hwif->cbl != ATA_CBL_PATA40_SHORT)
 505                 hwif->cbl = pdcnew_cable_detect(hwif);
 506
 507         if (!noautodma)
 508                 hwif->autodma = 1;
 509         hwif->drives[0].autodma = hwif->drives[1].autodma = hwif->autodma;
 510 }
 511
 512 static int __devinit init_setup_pdcnew(struct pci_dev *dev, ide_pci_device_t *d)
 513 {
 514         return ide_setup_pci_device(dev, d);
 515 }
 516
 517 static int __devinit init_setup_pdc20270(struct pci_dev *dev, ide_pci_device_t *d)
 518 {
 519         struct pci_dev *bridge = dev->bus->self;
 520
 521         if (bridge != NULL &&
 522             bridge->vendor == PCI_VENDOR_ID_DEC &&
 523             bridge->device == PCI_DEVICE_ID_DEC_21150) {
 524                 struct pci_dev *dev2;
 525
 526                 if (PCI_SLOT(dev->devfn) & 2)
 527                         return -ENODEV;
 528
 529                 dev2 = pci_get_slot(dev->bus, PCI_DEVFN(PCI_SLOT(dev->devfn) + 2,
 530                                                         PCI_FUNC(dev->devfn)));
 531                 if (dev2 != NULL &&
 532                     dev2->vendor == dev->vendor &&
 533                     dev2->device == dev->device) {
 534                         int ret;
 535
 536                         if (dev2->irq != dev->irq) {
 537                                 dev2->irq = dev->irq;
 538
 539                                 printk(KERN_WARNING "%s: PCI config space "
 540                                        "interrupt fixed.\n", d->name);
 541                         }
 542
 543                         ret = ide_setup_pci_devices(dev, dev2, d);
 544                         if (ret < 0)
 545                                 pci_dev_put(dev2);
 546                         return ret;
 547                 }
 548         }
 549         return ide_setup_pci_device(dev, d);
 550 }
 551
 552 static int __devinit init_setup_pdc20276(struct pci_dev *dev, ide_pci_device_t *d)
 553 {
 554         struct pci_dev *bridge = dev->bus->self;
 555
 556         if (bridge != NULL &&
 557             bridge->vendor == PCI_VENDOR_ID_INTEL &&
 558            (bridge->device == PCI_DEVICE_ID_INTEL_I960 ||
 559             bridge->device == PCI_DEVICE_ID_INTEL_I960RM)) {
 560
 561                 printk(KERN_INFO "%s: attached to I2O RAID controller, "
 562                                  "skipping.\n", d->name);
 563                 return -ENODEV;
 564         }
 565         return ide_setup_pci_device(dev, d);
 566 }
 567
 568 static ide_pci_device_t pdcnew_chipsets[] __devinitdata = {
 569         {       /* 0 */
 570                 .name           = "PDC20268",
 571                 .init_setup     = init_setup_pdcnew,
 572                 .init_chipset   = init_chipset_pdcnew,
 573                 .init_hwif      = init_hwif_pdc202new,
 574                 .autodma        = AUTODMA,
 575                 .bootable       = OFF_BOARD,
 576                 .pio_mask       = ATA_PIO4,
 577                 .udma_mask      = 0x3f, /* udma0-5 */
 578                 .host_flags     = IDE_HFLAG_POST_SET_MODE,
 579         },{     /* 1 */
 580                 .name           = "PDC20269",
 581                 .init_setup     = init_setup_pdcnew,
 582                 .init_chipset   = init_chipset_pdcnew,
 583                 .init_hwif      = init_hwif_pdc202new,
 584                 .autodma        = AUTODMA,
 585                 .bootable       = OFF_BOARD,
 586                 .pio_mask       = ATA_PIO4,
 587                 .udma_mask      = 0x7f, /* udma0-6*/
 588                 .host_flags     = IDE_HFLAG_POST_SET_MODE,
 589         },{     /* 2 */
 590                 .name           = "PDC20270",
 591                 .init_setup     = init_setup_pdc20270,
 592                 .init_chipset   = init_chipset_pdcnew,
 593                 .init_hwif      = init_hwif_pdc202new,
 594                 .autodma        = AUTODMA,
 595                 .bootable       = OFF_BOARD,
 596                 .pio_mask       = ATA_PIO4,
 597                 .udma_mask      = 0x3f, /* udma0-5 */
 598                 .host_flags     = IDE_HFLAG_POST_SET_MODE,
 599         },{     /* 3 */
 600                 .name           = "PDC20271",
 601                 .init_setup     = init_setup_pdcnew,
 602                 .init_chipset   = init_chipset_pdcnew,
 603                 .init_hwif      = init_hwif_pdc202new,
 604                 .autodma        = AUTODMA,
 605                 .bootable       = OFF_BOARD,
 606                 .pio_mask       = ATA_PIO4,
 607                 .udma_mask      = 0x7f, /* udma0-6*/
 608                 .host_flags     = IDE_HFLAG_POST_SET_MODE,
 609         },{     /* 4 */
 610                 .name           = "PDC20275",
 611                 .init_setup     = init_setup_pdcnew,
 612                 .init_chipset   = init_chipset_pdcnew,
 613                 .init_hwif      = init_hwif_pdc202new,
 614                 .autodma        = AUTODMA,
 615                 .bootable       = OFF_BOARD,
 616                 .pio_mask       = ATA_PIO4,
 617                 .udma_mask      = 0x7f, /* udma0-6*/
 618                 .host_flags     = IDE_HFLAG_POST_SET_MODE,
 619         },{     /* 5 */
 620                 .name           = "PDC20276",
 621                 .init_setup     = init_setup_pdc20276,
 622                 .init_chipset   = init_chipset_pdcnew,
 623                 .init_hwif      = init_hwif_pdc202new,
 624                 .autodma        = AUTODMA,
 625                 .bootable       = OFF_BOARD,
 626                 .pio_mask       = ATA_PIO4,
 627                 .udma_mask      = 0x7f, /* udma0-6*/
 628                 .host_flags     = IDE_HFLAG_POST_SET_MODE,
 629         },{     /* 6 */
 630                 .name           = "PDC20277",
 631                 .init_setup     = init_setup_pdcnew,
 632                 .init_chipset   = init_chipset_pdcnew,
 633                 .init_hwif      = init_hwif_pdc202new,
 634                 .autodma        = AUTODMA,
 635                 .bootable       = OFF_BOARD,
 636                 .pio_mask       = ATA_PIO4,
 637                 .udma_mask      = 0x7f, /* udma0-6*/
 638                 .host_flags     = IDE_HFLAG_POST_SET_MODE,
 639         }
 640 };
 641
 642 /**
 643  *      pdc202new_init_one      -       called when a pdc202xx is found
 644  *      @dev: the pdc202new device
 645  *      @id: the matching pci id
 646  *
 647  *      Called when the PCI registration layer (or the IDE initialization)
 648  *      finds a device matching our IDE device tables.
 649  */
 650
 651 static int __devinit pdc202new_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 652 {
 653         ide_pci_device_t *d = &pdcnew_chipsets[id->driver_data];
 654
 655         return d->init_setup(dev, d);
 656 }
 657
 658 static struct pci_device_id pdc202new_pci_tbl[] = {
 659         { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20268, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 660         { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20269, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
 661         { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20270, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2},
 662         { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20271, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3},
 663         { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20275, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4},
 664         { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20276, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5},
 665         { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20277, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 6},
 666         { 0, },
 667 };
 668 MODULE_DEVICE_TABLE(pci, pdc202new_pci_tbl);
 669
 670 static struct pci_driver driver = {
 671         .name           = "Promise_IDE",
 672         .id_table       = pdc202new_pci_tbl,
 673         .probe          = pdc202new_init_one,
 674 };
 675
 676 static int __init pdc202new_ide_init(void)
 677 {
 678         return ide_pci_register_driver(&driver);
 679 }
 680
 681 module_init(pdc202new_ide_init);
 682
 683 MODULE_AUTHOR("Andre Hedrick, Frank Tiernan");
 684 MODULE_DESCRIPTION("PCI driver module for Promise PDC20268 and higher");
 685 MODULE_LICENSE("GPL");