Commit | Line | Data |
---|---|---|
1da177e4 LT |
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 | * Portions Copyright (C) 1999 Promise Technology, Inc. | |
13 | * Author: Frank Tiernan (frankt@promise.com) | |
14 | * Released under terms of General Public License | |
15 | */ | |
16 | ||
1da177e4 LT |
17 | #include <linux/module.h> |
18 | #include <linux/types.h> | |
19 | #include <linux/kernel.h> | |
20 | #include <linux/delay.h> | |
21 | #include <linux/timer.h> | |
22 | #include <linux/mm.h> | |
23 | #include <linux/ioport.h> | |
24 | #include <linux/blkdev.h> | |
25 | #include <linux/hdreg.h> | |
26 | #include <linux/interrupt.h> | |
27 | #include <linux/pci.h> | |
28 | #include <linux/init.h> | |
29 | #include <linux/ide.h> | |
30 | ||
31 | #include <asm/io.h> | |
32 | #include <asm/irq.h> | |
33 | ||
34 | #ifdef CONFIG_PPC_PMAC | |
35 | #include <asm/prom.h> | |
36 | #include <asm/pci-bridge.h> | |
37 | #endif | |
38 | ||
39 | #define PDC202_DEBUG_CABLE 0 | |
40 | ||
3c6bee1d | 41 | static const char *pdc_quirk_drives[] = { |
1da177e4 LT |
42 | "QUANTUM FIREBALLlct08 08", |
43 | "QUANTUM FIREBALLP KA6.4", | |
44 | "QUANTUM FIREBALLP KA9.1", | |
45 | "QUANTUM FIREBALLP LM20.4", | |
46 | "QUANTUM FIREBALLP KX13.6", | |
47 | "QUANTUM FIREBALLP KX20.5", | |
48 | "QUANTUM FIREBALLP KX27.3", | |
49 | "QUANTUM FIREBALLP LM20.5", | |
50 | NULL | |
51 | }; | |
52 | ||
53 | #define set_2regs(a, b) \ | |
54 | do { \ | |
55 | hwif->OUTB((a + adj), indexreg); \ | |
56 | hwif->OUTB(b, datareg); \ | |
57 | } while(0) | |
58 | ||
59 | #define set_ultra(a, b, c) \ | |
60 | do { \ | |
61 | set_2regs(0x10,(a)); \ | |
62 | set_2regs(0x11,(b)); \ | |
63 | set_2regs(0x12,(c)); \ | |
64 | } while(0) | |
65 | ||
66 | #define set_ata2(a, b) \ | |
67 | do { \ | |
68 | set_2regs(0x0e,(a)); \ | |
69 | set_2regs(0x0f,(b)); \ | |
70 | } while(0) | |
71 | ||
72 | #define set_pio(a, b, c) \ | |
73 | do { \ | |
74 | set_2regs(0x0c,(a)); \ | |
75 | set_2regs(0x0d,(b)); \ | |
76 | set_2regs(0x13,(c)); \ | |
77 | } while(0) | |
78 | ||
79 | static u8 pdcnew_ratemask (ide_drive_t *drive) | |
80 | { | |
81 | u8 mode; | |
82 | ||
83 | switch(HWIF(drive)->pci_dev->device) { | |
84 | case PCI_DEVICE_ID_PROMISE_20277: | |
85 | case PCI_DEVICE_ID_PROMISE_20276: | |
86 | case PCI_DEVICE_ID_PROMISE_20275: | |
87 | case PCI_DEVICE_ID_PROMISE_20271: | |
88 | case PCI_DEVICE_ID_PROMISE_20269: | |
89 | mode = 4; | |
90 | break; | |
91 | case PCI_DEVICE_ID_PROMISE_20270: | |
92 | case PCI_DEVICE_ID_PROMISE_20268: | |
93 | mode = 3; | |
94 | break; | |
95 | default: | |
96 | return 0; | |
97 | } | |
98 | if (!eighty_ninty_three(drive)) | |
99 | mode = min(mode, (u8)1); | |
100 | return mode; | |
101 | } | |
102 | ||
103 | static int check_in_drive_lists (ide_drive_t *drive, const char **list) | |
104 | { | |
105 | struct hd_driveid *id = drive->id; | |
106 | ||
107 | if (pdc_quirk_drives == list) { | |
108 | while (*list) { | |
109 | if (strstr(id->model, *list++)) { | |
110 | return 2; | |
111 | } | |
112 | } | |
113 | } else { | |
114 | while (*list) { | |
115 | if (!strcmp(*list++,id->model)) { | |
116 | return 1; | |
117 | } | |
118 | } | |
119 | } | |
120 | return 0; | |
121 | } | |
122 | ||
123 | static int pdcnew_new_tune_chipset (ide_drive_t *drive, u8 xferspeed) | |
124 | { | |
125 | ide_hwif_t *hwif = HWIF(drive); | |
126 | unsigned long indexreg = hwif->dma_vendor1; | |
127 | unsigned long datareg = hwif->dma_vendor3; | |
128 | u8 thold = 0x10; | |
129 | u8 adj = (drive->dn%2) ? 0x08 : 0x00; | |
130 | u8 speed = ide_rate_filter(pdcnew_ratemask(drive), xferspeed); | |
131 | ||
132 | if (speed == XFER_UDMA_2) { | |
133 | hwif->OUTB((thold + adj), indexreg); | |
134 | hwif->OUTB((hwif->INB(datareg) & 0x7f), datareg); | |
135 | } | |
136 | ||
137 | switch (speed) { | |
138 | case XFER_UDMA_7: | |
139 | speed = XFER_UDMA_6; | |
140 | case XFER_UDMA_6: set_ultra(0x1a, 0x01, 0xcb); break; | |
141 | case XFER_UDMA_5: set_ultra(0x1a, 0x02, 0xcb); break; | |
142 | case XFER_UDMA_4: set_ultra(0x1a, 0x03, 0xcd); break; | |
143 | case XFER_UDMA_3: set_ultra(0x1a, 0x05, 0xcd); break; | |
144 | case XFER_UDMA_2: set_ultra(0x2a, 0x07, 0xcd); break; | |
145 | case XFER_UDMA_1: set_ultra(0x3a, 0x0a, 0xd0); break; | |
146 | case XFER_UDMA_0: set_ultra(0x4a, 0x0f, 0xd5); break; | |
147 | case XFER_MW_DMA_2: set_ata2(0x69, 0x25); break; | |
148 | case XFER_MW_DMA_1: set_ata2(0x6b, 0x27); break; | |
149 | case XFER_MW_DMA_0: set_ata2(0xdf, 0x5f); break; | |
150 | case XFER_PIO_4: set_pio(0x23, 0x09, 0x25); break; | |
151 | case XFER_PIO_3: set_pio(0x27, 0x0d, 0x35); break; | |
152 | case XFER_PIO_2: set_pio(0x23, 0x26, 0x64); break; | |
153 | case XFER_PIO_1: set_pio(0x46, 0x29, 0xa4); break; | |
154 | case XFER_PIO_0: set_pio(0xfb, 0x2b, 0xac); break; | |
155 | default: | |
156 | ; | |
157 | } | |
158 | ||
159 | return (ide_config_drive_speed(drive, speed)); | |
160 | } | |
161 | ||
162 | /* 0 1 2 3 4 5 6 7 8 | |
163 | * 960, 480, 390, 300, 240, 180, 120, 90, 60 | |
164 | * 180, 150, 120, 90, 60 | |
165 | * DMA_Speed | |
166 | * 180, 120, 90, 90, 90, 60, 30 | |
167 | * 11, 5, 4, 3, 2, 1, 0 | |
168 | */ | |
169 | static void pdcnew_tune_drive(ide_drive_t *drive, u8 pio) | |
170 | { | |
171 | u8 speed; | |
172 | ||
173 | if (pio == 5) pio = 4; | |
174 | speed = XFER_PIO_0 + ide_get_best_pio_mode(drive, 255, pio, NULL); | |
175 | ||
176 | (void)pdcnew_new_tune_chipset(drive, speed); | |
177 | } | |
178 | ||
179 | static u8 pdcnew_new_cable_detect (ide_hwif_t *hwif) | |
180 | { | |
181 | hwif->OUTB(0x0b, hwif->dma_vendor1); | |
182 | return ((u8)((hwif->INB(hwif->dma_vendor3) & 0x04))); | |
183 | } | |
184 | static int config_chipset_for_dma (ide_drive_t *drive) | |
185 | { | |
186 | struct hd_driveid *id = drive->id; | |
187 | ide_hwif_t *hwif = HWIF(drive); | |
188 | u8 speed = -1; | |
189 | u8 cable; | |
190 | ||
191 | u8 ultra_66 = ((id->dma_ultra & 0x0010) || | |
192 | (id->dma_ultra & 0x0008)) ? 1 : 0; | |
193 | ||
194 | cable = pdcnew_new_cable_detect(hwif); | |
195 | ||
196 | if (ultra_66 && cable) { | |
197 | printk(KERN_WARNING "Warning: %s channel requires an 80-pin cable for operation.\n", hwif->channel ? "Secondary":"Primary"); | |
198 | printk(KERN_WARNING "%s reduced to Ultra33 mode.\n", drive->name); | |
199 | } | |
200 | ||
201 | if (drive->media != ide_disk) | |
202 | return 0; | |
203 | if (id->capability & 4) { /* IORDY_EN & PREFETCH_EN */ | |
204 | hwif->OUTB((0x13 + ((drive->dn%2) ? 0x08 : 0x00)), hwif->dma_vendor1); | |
205 | hwif->OUTB((hwif->INB(hwif->dma_vendor3)|0x03), hwif->dma_vendor3); | |
206 | } | |
207 | ||
208 | speed = ide_dma_speed(drive, pdcnew_ratemask(drive)); | |
209 | ||
210 | if (!(speed)) { | |
211 | hwif->tuneproc(drive, 5); | |
212 | return 0; | |
213 | } | |
214 | ||
215 | (void) hwif->speedproc(drive, speed); | |
216 | return ide_dma_enable(drive); | |
217 | } | |
218 | ||
219 | static int pdcnew_config_drive_xfer_rate (ide_drive_t *drive) | |
220 | { | |
221 | ide_hwif_t *hwif = HWIF(drive); | |
222 | struct hd_driveid *id = drive->id; | |
223 | ||
224 | drive->init_speed = 0; | |
225 | ||
226 | if (id && (id->capability & 1) && drive->autodma) { | |
227 | ||
228 | if (ide_use_dma(drive)) { | |
229 | if (config_chipset_for_dma(drive)) | |
230 | return hwif->ide_dma_on(drive); | |
231 | } | |
232 | ||
233 | goto fast_ata_pio; | |
234 | ||
235 | } else if ((id->capability & 8) || (id->field_valid & 2)) { | |
236 | fast_ata_pio: | |
237 | hwif->tuneproc(drive, 5); | |
238 | return hwif->ide_dma_off_quietly(drive); | |
239 | } | |
240 | /* IORDY not supported */ | |
241 | return 0; | |
242 | } | |
243 | ||
244 | static int pdcnew_quirkproc (ide_drive_t *drive) | |
245 | { | |
246 | return ((int) check_in_drive_lists(drive, pdc_quirk_drives)); | |
247 | } | |
248 | ||
249 | static int pdcnew_ide_dma_lostirq(ide_drive_t *drive) | |
250 | { | |
251 | if (HWIF(drive)->resetproc != NULL) | |
252 | HWIF(drive)->resetproc(drive); | |
253 | return __ide_dma_lostirq(drive); | |
254 | } | |
255 | ||
256 | static int pdcnew_ide_dma_timeout(ide_drive_t *drive) | |
257 | { | |
258 | if (HWIF(drive)->resetproc != NULL) | |
259 | HWIF(drive)->resetproc(drive); | |
260 | return __ide_dma_timeout(drive); | |
261 | } | |
262 | ||
263 | static void pdcnew_new_reset (ide_drive_t *drive) | |
264 | { | |
265 | /* | |
266 | * Deleted this because it is redundant from the caller. | |
267 | */ | |
268 | printk(KERN_WARNING "PDC202XX: %s channel reset.\n", | |
269 | HWIF(drive)->channel ? "Secondary" : "Primary"); | |
270 | } | |
271 | ||
272 | #ifdef CONFIG_PPC_PMAC | |
273 | static void __devinit apple_kiwi_init(struct pci_dev *pdev) | |
274 | { | |
275 | struct device_node *np = pci_device_to_OF_node(pdev); | |
276 | unsigned int class_rev = 0; | |
277 | void __iomem *mmio; | |
278 | u8 conf; | |
279 | ||
280 | if (np == NULL || !device_is_compatible(np, "kiwi-root")) | |
281 | return; | |
282 | ||
283 | pci_read_config_dword(pdev, PCI_CLASS_REVISION, &class_rev); | |
284 | class_rev &= 0xff; | |
285 | ||
286 | if (class_rev >= 0x03) { | |
287 | /* Setup chip magic config stuff (from darwin) */ | |
288 | pci_read_config_byte(pdev, 0x40, &conf); | |
289 | pci_write_config_byte(pdev, 0x40, conf | 0x01); | |
290 | } | |
291 | mmio = ioremap(pci_resource_start(pdev, 5), | |
292 | pci_resource_len(pdev, 5)); | |
293 | ||
294 | /* Setup some PLL stuffs */ | |
295 | switch (pdev->device) { | |
296 | case PCI_DEVICE_ID_PROMISE_20270: | |
297 | writew(0x0d2b, mmio + 0x1202); | |
298 | mdelay(30); | |
299 | break; | |
300 | case PCI_DEVICE_ID_PROMISE_20271: | |
301 | writew(0x0826, mmio + 0x1202); | |
302 | mdelay(30); | |
303 | break; | |
304 | } | |
305 | ||
306 | iounmap(mmio); | |
307 | } | |
308 | #endif /* CONFIG_PPC_PMAC */ | |
309 | ||
310 | static unsigned int __devinit init_chipset_pdcnew(struct pci_dev *dev, const char *name) | |
311 | { | |
312 | if (dev->resource[PCI_ROM_RESOURCE].start) { | |
313 | pci_write_config_dword(dev, PCI_ROM_ADDRESS, | |
314 | dev->resource[PCI_ROM_RESOURCE].start | PCI_ROM_ADDRESS_ENABLE); | |
08f46de9 GKH |
315 | printk(KERN_INFO "%s: ROM enabled at 0x%08lx\n", name, |
316 | (unsigned long)dev->resource[PCI_ROM_RESOURCE].start); | |
1da177e4 LT |
317 | } |
318 | ||
319 | #ifdef CONFIG_PPC_PMAC | |
320 | apple_kiwi_init(dev); | |
321 | #endif | |
322 | ||
323 | return dev->irq; | |
324 | } | |
325 | ||
326 | static void __devinit init_hwif_pdc202new(ide_hwif_t *hwif) | |
327 | { | |
328 | hwif->autodma = 0; | |
329 | ||
330 | hwif->tuneproc = &pdcnew_tune_drive; | |
331 | hwif->quirkproc = &pdcnew_quirkproc; | |
332 | hwif->speedproc = &pdcnew_new_tune_chipset; | |
333 | hwif->resetproc = &pdcnew_new_reset; | |
334 | ||
335 | hwif->drives[0].autotune = hwif->drives[1].autotune = 1; | |
336 | ||
337 | hwif->ultra_mask = 0x7f; | |
338 | hwif->mwdma_mask = 0x07; | |
339 | ||
3706a872 AC |
340 | hwif->err_stops_fifo = 1; |
341 | ||
1da177e4 LT |
342 | hwif->ide_dma_check = &pdcnew_config_drive_xfer_rate; |
343 | hwif->ide_dma_lostirq = &pdcnew_ide_dma_lostirq; | |
344 | hwif->ide_dma_timeout = &pdcnew_ide_dma_timeout; | |
345 | if (!(hwif->udma_four)) | |
346 | hwif->udma_four = (pdcnew_new_cable_detect(hwif)) ? 0 : 1; | |
347 | if (!noautodma) | |
348 | hwif->autodma = 1; | |
349 | hwif->drives[0].autodma = hwif->drives[1].autodma = hwif->autodma; | |
350 | #if PDC202_DEBUG_CABLE | |
351 | printk(KERN_DEBUG "%s: %s-pin cable\n", | |
352 | hwif->name, hwif->udma_four ? "80" : "40"); | |
353 | #endif /* PDC202_DEBUG_CABLE */ | |
354 | } | |
355 | ||
356 | static int __devinit init_setup_pdcnew(struct pci_dev *dev, ide_pci_device_t *d) | |
357 | { | |
358 | return ide_setup_pci_device(dev, d); | |
359 | } | |
360 | ||
361 | static int __devinit init_setup_pdc20270(struct pci_dev *dev, | |
362 | ide_pci_device_t *d) | |
363 | { | |
364 | struct pci_dev *findev = NULL; | |
b1489009 | 365 | int ret; |
1da177e4 LT |
366 | |
367 | if ((dev->bus->self && | |
368 | dev->bus->self->vendor == PCI_VENDOR_ID_DEC) && | |
369 | (dev->bus->self->device == PCI_DEVICE_ID_DEC_21150)) { | |
370 | if (PCI_SLOT(dev->devfn) & 2) | |
371 | return -ENODEV; | |
372 | d->extra = 0; | |
b1489009 | 373 | while ((findev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, findev)) != NULL) { |
1da177e4 LT |
374 | if ((findev->vendor == dev->vendor) && |
375 | (findev->device == dev->device) && | |
376 | (PCI_SLOT(findev->devfn) & 2)) { | |
377 | if (findev->irq != dev->irq) { | |
378 | findev->irq = dev->irq; | |
379 | } | |
b1489009 AC |
380 | ret = ide_setup_pci_devices(dev, findev, d); |
381 | pci_dev_put(findev); | |
382 | return ret; | |
1da177e4 LT |
383 | } |
384 | } | |
385 | } | |
386 | return ide_setup_pci_device(dev, d); | |
387 | } | |
388 | ||
389 | static int __devinit init_setup_pdc20276(struct pci_dev *dev, | |
390 | ide_pci_device_t *d) | |
391 | { | |
392 | if ((dev->bus->self) && | |
393 | (dev->bus->self->vendor == PCI_VENDOR_ID_INTEL) && | |
394 | ((dev->bus->self->device == PCI_DEVICE_ID_INTEL_I960) || | |
395 | (dev->bus->self->device == PCI_DEVICE_ID_INTEL_I960RM))) { | |
396 | printk(KERN_INFO "ide: Skipping Promise PDC20276 " | |
397 | "attached to I2O RAID controller.\n"); | |
398 | return -ENODEV; | |
399 | } | |
400 | return ide_setup_pci_device(dev, d); | |
401 | } | |
402 | ||
403 | static ide_pci_device_t pdcnew_chipsets[] __devinitdata = { | |
404 | { /* 0 */ | |
405 | .name = "PDC20268", | |
406 | .init_setup = init_setup_pdcnew, | |
407 | .init_chipset = init_chipset_pdcnew, | |
408 | .init_hwif = init_hwif_pdc202new, | |
409 | .channels = 2, | |
410 | .autodma = AUTODMA, | |
411 | .bootable = OFF_BOARD, | |
412 | },{ /* 1 */ | |
413 | .name = "PDC20269", | |
414 | .init_setup = init_setup_pdcnew, | |
415 | .init_chipset = init_chipset_pdcnew, | |
416 | .init_hwif = init_hwif_pdc202new, | |
417 | .channels = 2, | |
418 | .autodma = AUTODMA, | |
419 | .bootable = OFF_BOARD, | |
420 | },{ /* 2 */ | |
421 | .name = "PDC20270", | |
422 | .init_setup = init_setup_pdc20270, | |
423 | .init_chipset = init_chipset_pdcnew, | |
424 | .init_hwif = init_hwif_pdc202new, | |
425 | .channels = 2, | |
426 | .autodma = AUTODMA, | |
1da177e4 LT |
427 | .bootable = OFF_BOARD, |
428 | },{ /* 3 */ | |
429 | .name = "PDC20271", | |
430 | .init_setup = init_setup_pdcnew, | |
431 | .init_chipset = init_chipset_pdcnew, | |
432 | .init_hwif = init_hwif_pdc202new, | |
433 | .channels = 2, | |
434 | .autodma = AUTODMA, | |
435 | .bootable = OFF_BOARD, | |
436 | },{ /* 4 */ | |
437 | .name = "PDC20275", | |
438 | .init_setup = init_setup_pdcnew, | |
439 | .init_chipset = init_chipset_pdcnew, | |
440 | .init_hwif = init_hwif_pdc202new, | |
441 | .channels = 2, | |
442 | .autodma = AUTODMA, | |
443 | .bootable = OFF_BOARD, | |
444 | },{ /* 5 */ | |
445 | .name = "PDC20276", | |
446 | .init_setup = init_setup_pdc20276, | |
447 | .init_chipset = init_chipset_pdcnew, | |
448 | .init_hwif = init_hwif_pdc202new, | |
449 | .channels = 2, | |
450 | .autodma = AUTODMA, | |
1da177e4 LT |
451 | .bootable = OFF_BOARD, |
452 | },{ /* 6 */ | |
453 | .name = "PDC20277", | |
454 | .init_setup = init_setup_pdcnew, | |
455 | .init_chipset = init_chipset_pdcnew, | |
456 | .init_hwif = init_hwif_pdc202new, | |
457 | .channels = 2, | |
458 | .autodma = AUTODMA, | |
459 | .bootable = OFF_BOARD, | |
460 | } | |
461 | }; | |
462 | ||
463 | /** | |
464 | * pdc202new_init_one - called when a pdc202xx is found | |
465 | * @dev: the pdc202new device | |
466 | * @id: the matching pci id | |
467 | * | |
468 | * Called when the PCI registration layer (or the IDE initialization) | |
469 | * finds a device matching our IDE device tables. | |
470 | */ | |
471 | ||
472 | static int __devinit pdc202new_init_one(struct pci_dev *dev, const struct pci_device_id *id) | |
473 | { | |
474 | ide_pci_device_t *d = &pdcnew_chipsets[id->driver_data]; | |
475 | ||
476 | return d->init_setup(dev, d); | |
477 | } | |
478 | ||
479 | static struct pci_device_id pdc202new_pci_tbl[] = { | |
480 | { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20268, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, | |
481 | { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20269, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1}, | |
482 | { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20270, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2}, | |
483 | { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20271, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3}, | |
484 | { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20275, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4}, | |
485 | { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20276, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5}, | |
486 | { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20277, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 6}, | |
487 | { 0, }, | |
488 | }; | |
489 | MODULE_DEVICE_TABLE(pci, pdc202new_pci_tbl); | |
490 | ||
491 | static struct pci_driver driver = { | |
492 | .name = "Promise_IDE", | |
493 | .id_table = pdc202new_pci_tbl, | |
494 | .probe = pdc202new_init_one, | |
495 | }; | |
496 | ||
497 | static int pdc202new_ide_init(void) | |
498 | { | |
499 | return ide_pci_register_driver(&driver); | |
500 | } | |
501 | ||
502 | module_init(pdc202new_ide_init); | |
503 | ||
504 | MODULE_AUTHOR("Andre Hedrick, Frank Tiernan"); | |
505 | MODULE_DESCRIPTION("PCI driver module for Promise PDC20268 and higher"); | |
506 | MODULE_LICENSE("GPL"); |