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