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