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