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