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_dma_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                 if (speed >= XFER_UDMA_0) {
 166                         set_indexed_reg(hwif, 0x10 + adj,
 167                                         udma_timings[mode].reg10);
 168                         set_indexed_reg(hwif, 0x11 + adj,
 169                                         udma_timings[mode].reg11);
 170                         set_indexed_reg(hwif, 0x12 + adj,
 171                                         udma_timings[mode].reg12);
 172                 } else {
 173                         set_indexed_reg(hwif, 0x0e + adj,
 174                                         mwdma_timings[mode].reg0e);
 175                         set_indexed_reg(hwif, 0x0f + adj,
 176                                         mwdma_timings[mode].reg0f);
 177                 }
 178         } else if (speed == XFER_UDMA_2) {
 179                 /* Set tHOLD bit to 0 if using UDMA mode 2 */
 180                 u8 tmp = get_indexed_reg(hwif, 0x10 + adj);
 181
 182                 set_indexed_reg(hwif, 0x10 + adj, tmp & 0x7f);
 183         }
 184 }
 185
 186 static void pdcnew_set_pio_mode(ide_drive_t *drive, const u8 pio)
 187 {
 188         ide_hwif_t *hwif = drive->hwif;
 189         u8 adj = (drive->dn & 1) ? 0x08 : 0x00;
 190
 191         if (max_dma_rate(hwif->pci_dev) == 4) {
 192                 set_indexed_reg(hwif, 0x0c + adj, pio_timings[pio].reg0c);
 193                 set_indexed_reg(hwif, 0x0d + adj, pio_timings[pio].reg0d);
 194                 set_indexed_reg(hwif, 0x13 + adj, pio_timings[pio].reg13);
 195         }
 196 }
 197
 198 static u8 pdcnew_cable_detect(ide_hwif_t *hwif)
 199 {
 200         if (get_indexed_reg(hwif, 0x0b) & 0x04)
 201                 return ATA_CBL_PATA40;
 202         else
 203                 return ATA_CBL_PATA80;
 204 }
 205
 206 static void pdcnew_quirkproc(ide_drive_t *drive)
 207 {
 208         const char **list, *model = drive->id->model;
 209
 210         for (list = pdc_quirk_drives; *list != NULL; list++)
 211                 if (strstr(model, *list) != NULL) {
 212                         drive->quirk_list = 2;
 213                         return;
 214                 }
 215
 216         drive->quirk_list = 0;
 217 }
 218
 219 static void pdcnew_reset(ide_drive_t *drive)
 220 {
 221         /*
 222          * Deleted this because it is redundant from the caller.
 223          */
 224         printk(KERN_WARNING "pdc202xx_new: %s channel reset.\n",
 225                 HWIF(drive)->channel ? "Secondary" : "Primary");
 226 }
 227
 228 /**
 229  * read_counter - Read the byte count registers
 230  * @dma_base: for the port address
 231  */
 232 static long __devinit read_counter(u32 dma_base)
 233 {
 234         u32  pri_dma_base = dma_base, sec_dma_base = dma_base + 0x08;
 235         u8   cnt0, cnt1, cnt2, cnt3;
 236         long count = 0, last;
 237         int  retry = 3;
 238
 239         do {
 240                 last = count;
 241
 242                 /* Read the current count */
 243                 outb(0x20, pri_dma_base + 0x01);
 244                 cnt0 = inb(pri_dma_base + 0x03);
 245                 outb(0x21, pri_dma_base + 0x01);
 246                 cnt1 = inb(pri_dma_base + 0x03);
 247                 outb(0x20, sec_dma_base + 0x01);
 248                 cnt2 = inb(sec_dma_base + 0x03);
 249                 outb(0x21, sec_dma_base + 0x01);
 250                 cnt3 = inb(sec_dma_base + 0x03);
 251
 252                 count = (cnt3 << 23) | (cnt2 << 15) | (cnt1 << 8) | cnt0;
 253
 254                 /*
 255                  * The 30-bit decrementing counter is read in 4 pieces.
 256                  * Incorrect value may be read when the most significant bytes
 257                  * are changing...
 258                  */
 259         } while (retry-- && (((last ^ count) & 0x3fff8000) || last < count));
 260
 261         DBG("cnt0[%02X] cnt1[%02X] cnt2[%02X] cnt3[%02X]\n",
 262                   cnt0, cnt1, cnt2, cnt3);
 263
 264         return count;
 265 }
 266
 267 /**
 268  * detect_pll_input_clock - Detect the PLL input clock in Hz.
 269  * @dma_base: for the port address
 270  * E.g. 16949000 on 33 MHz PCI bus, i.e. half of the PCI clock.
 271  */
 272 static long __devinit detect_pll_input_clock(unsigned long dma_base)
 273 {
 274         struct timeval start_time, end_time;
 275         long start_count, end_count;
 276         long pll_input, usec_elapsed;
 277         u8 scr1;
 278
 279         start_count = read_counter(dma_base);
 280         do_gettimeofday(&start_time);
 281
 282         /* Start the test mode */
 283         outb(0x01, dma_base + 0x01);
 284         scr1 = inb(dma_base + 0x03);
 285         DBG("scr1[%02X]\n", scr1);
 286         outb(scr1 | 0x40, dma_base + 0x03);
 287
 288         /* Let the counter run for 10 ms. */
 289         mdelay(10);
 290
 291         end_count = read_counter(dma_base);
 292         do_gettimeofday(&end_time);
 293
 294         /* Stop the test mode */
 295         outb(0x01, dma_base + 0x01);
 296         scr1 = inb(dma_base + 0x03);
 297         DBG("scr1[%02X]\n", scr1);
 298         outb(scr1 & ~0x40, dma_base + 0x03);
 299
 300         /*
 301          * Calculate the input clock in Hz
 302          * (the clock counter is 30 bit wide and counts down)
 303          */
 304         usec_elapsed = (end_time.tv_sec - start_time.tv_sec) * 1000000 +
 305                 (end_time.tv_usec - start_time.tv_usec);
 306         pll_input = ((start_count - end_count) & 0x3fffffff) / 10 *
 307                 (10000000 / usec_elapsed);
 308
 309         DBG("start[%ld] end[%ld]\n", start_count, end_count);
 310
 311         return pll_input;
 312 }
 313
 314 #ifdef CONFIG_PPC_PMAC
 315 static void __devinit apple_kiwi_init(struct pci_dev *pdev)
 316 {
 317         struct device_node *np = pci_device_to_OF_node(pdev);
 318         u8 conf;
 319
 320         if (np == NULL || !of_device_is_compatible(np, "kiwi-root"))
 321                 return;
 322
 323         if (pdev->revision >= 0x03) {
 324                 /* Setup chip magic config stuff (from darwin) */
 325                 pci_read_config_byte (pdev, 0x40, &conf);
 326                 pci_write_config_byte(pdev, 0x40, (conf | 0x01));
 327         }
 328 }
 329 #endif /* CONFIG_PPC_PMAC */
 330
 331 static unsigned int __devinit init_chipset_pdcnew(struct pci_dev *dev, const char *name)
 332 {
 333         unsigned long dma_base = pci_resource_start(dev, 4);
 334         unsigned long sec_dma_base = dma_base + 0x08;
 335         long pll_input, pll_output, ratio;
 336         int f, r;
 337         u8 pll_ctl0, pll_ctl1;
 338
 339         if (dma_base == 0)
 340                 return -EFAULT;
 341
 342 #ifdef CONFIG_PPC_PMAC
 343         apple_kiwi_init(dev);
 344 #endif
 345
 346         /* Calculate the required PLL output frequency */
 347         switch(max_dma_rate(dev)) {
 348                 case 4: /* it's 133 MHz for Ultra133 chips */
 349                         pll_output = 133333333;
 350                         break;
 351                 case 3: /* and  100 MHz for Ultra100 chips */
 352                 default:
 353                         pll_output = 100000000;
 354                         break;
 355         }
 356
 357         /*
 358          * Detect PLL input clock.
 359          * On some systems, where PCI bus is running at non-standard clock rate
 360          * (e.g. 25 or 40 MHz), we have to adjust the cycle time.
 361          * PDC20268 and newer chips employ PLL circuit to help correct timing
 362          * registers setting.
 363          */
 364         pll_input = detect_pll_input_clock(dma_base);
 365         printk("%s: PLL input clock is %ld kHz\n", name, pll_input / 1000);
 366
 367         /* Sanity check */
 368         if (unlikely(pll_input < 5000000L || pll_input > 70000000L)) {
 369                 printk(KERN_ERR "%s: Bad PLL input clock %ld Hz, giving up!\n",
 370                        name, pll_input);
 371                 goto out;
 372         }
 373
 374 #ifdef DEBUG
 375         DBG("pll_output is %ld Hz\n", pll_output);
 376
 377         /* Show the current clock value of PLL control register
 378          * (maybe already configured by the BIOS)
 379          */
 380         outb(0x02, sec_dma_base + 0x01);
 381         pll_ctl0 = inb(sec_dma_base + 0x03);
 382         outb(0x03, sec_dma_base + 0x01);
 383         pll_ctl1 = inb(sec_dma_base + 0x03);
 384
 385         DBG("pll_ctl[%02X][%02X]\n", pll_ctl0, pll_ctl1);
 386 #endif
 387
 388         /*
 389          * Calculate the ratio of F, R and NO
 390          * POUT = (F + 2) / (( R + 2) * NO)
 391          */
 392         ratio = pll_output / (pll_input / 1000);
 393         if (ratio < 8600L) { /* 8.6x */
 394                 /* Using NO = 0x01, R = 0x0d */
 395                 r = 0x0d;
 396         } else if (ratio < 12900L) { /* 12.9x */
 397                 /* Using NO = 0x01, R = 0x08 */
 398                 r = 0x08;
 399         } else if (ratio < 16100L) { /* 16.1x */
 400                 /* Using NO = 0x01, R = 0x06 */
 401                 r = 0x06;
 402         } else if (ratio < 64000L) { /* 64x */
 403                 r = 0x00;
 404         } else {
 405                 /* Invalid ratio */
 406                 printk(KERN_ERR "%s: Bad ratio %ld, giving up!\n", name, ratio);
 407                 goto out;
 408         }
 409
 410         f = (ratio * (r + 2)) / 1000 - 2;
 411
 412         DBG("F[%d] R[%d] ratio*1000[%ld]\n", f, r, ratio);
 413
 414         if (unlikely(f < 0 || f > 127)) {
 415                 /* Invalid F */
 416                 printk(KERN_ERR "%s: F[%d] invalid!\n", name, f);
 417                 goto out;
 418         }
 419
 420         pll_ctl0 = (u8) f;
 421         pll_ctl1 = (u8) r;
 422
 423         DBG("Writing pll_ctl[%02X][%02X]\n", pll_ctl0, pll_ctl1);
 424
 425         outb(0x02,     sec_dma_base + 0x01);
 426         outb(pll_ctl0, sec_dma_base + 0x03);
 427         outb(0x03,     sec_dma_base + 0x01);
 428         outb(pll_ctl1, sec_dma_base + 0x03);
 429
 430         /* Wait the PLL circuit to be stable */
 431         mdelay(30);
 432
 433 #ifdef DEBUG
 434         /*
 435          *  Show the current clock value of PLL control register
 436          */
 437         outb(0x02, sec_dma_base + 0x01);
 438         pll_ctl0 = inb(sec_dma_base + 0x03);
 439         outb(0x03, sec_dma_base + 0x01);
 440         pll_ctl1 = inb(sec_dma_base + 0x03);
 441
 442         DBG("pll_ctl[%02X][%02X]\n", pll_ctl0, pll_ctl1);
 443 #endif
 444
 445  out:
 446         return dev->irq;
 447 }
 448
 449 static void __devinit init_hwif_pdc202new(ide_hwif_t *hwif)
 450 {
 451         hwif->set_pio_mode = &pdcnew_set_pio_mode;
 452         hwif->set_dma_mode = &pdcnew_set_dma_mode;
 453
 454         hwif->quirkproc = &pdcnew_quirkproc;
 455         hwif->resetproc = &pdcnew_reset;
 456
 457         if (hwif->dma_base == 0)
 458                 return;
 459
 460         if (hwif->cbl != ATA_CBL_PATA40_SHORT)
 461                 hwif->cbl = pdcnew_cable_detect(hwif);
 462 }
 463
 464 static struct pci_dev * __devinit pdc20270_get_dev2(struct pci_dev *dev)
 465 {
 466         struct pci_dev *dev2;
 467
 468         dev2 = pci_get_slot(dev->bus, PCI_DEVFN(PCI_SLOT(dev->devfn) + 1,
 469                                                 PCI_FUNC(dev->devfn)));
 470
 471         if (dev2 &&
 472             dev2->vendor == dev->vendor &&
 473             dev2->device == dev->device) {
 474
 475                 if (dev2->irq != dev->irq) {
 476                         dev2->irq = dev->irq;
 477                         printk(KERN_INFO "PDC20270: PCI config space "
 478                                          "interrupt fixed\n");
 479                 }
 480
 481                 return dev2;
 482         }
 483
 484         return NULL;
 485 }
 486
 487 #define DECLARE_PDCNEW_DEV(name_str, udma) \
 488         { \
 489                 .name           = name_str, \
 490                 .init_chipset   = init_chipset_pdcnew, \
 491                 .init_hwif      = init_hwif_pdc202new, \
 492                 .host_flags     = IDE_HFLAG_POST_SET_MODE | \
 493                                   IDE_HFLAG_ERROR_STOPS_FIFO | \
 494                                   IDE_HFLAG_OFF_BOARD, \
 495                 .pio_mask       = ATA_PIO4, \
 496                 .mwdma_mask     = ATA_MWDMA2, \
 497                 .udma_mask      = udma, \
 498         }
 499
 500 static const struct ide_port_info pdcnew_chipsets[] __devinitdata = {
 501         /* 0 */ DECLARE_PDCNEW_DEV("PDC20268", ATA_UDMA5),
 502         /* 1 */ DECLARE_PDCNEW_DEV("PDC20269", ATA_UDMA6),
 503         /* 2 */ DECLARE_PDCNEW_DEV("PDC20270", ATA_UDMA5),
 504         /* 3 */ DECLARE_PDCNEW_DEV("PDC20271", ATA_UDMA6),
 505         /* 4 */ DECLARE_PDCNEW_DEV("PDC20275", ATA_UDMA6),
 506         /* 5 */ DECLARE_PDCNEW_DEV("PDC20276", ATA_UDMA6),
 507         /* 6 */ DECLARE_PDCNEW_DEV("PDC20277", ATA_UDMA6),
 508 };
 509
 510 /**
 511  *      pdc202new_init_one      -       called when a pdc202xx is found
 512  *      @dev: the pdc202new device
 513  *      @id: the matching pci id
 514  *
 515  *      Called when the PCI registration layer (or the IDE initialization)
 516  *      finds a device matching our IDE device tables.
 517  */
 518
 519 static int __devinit pdc202new_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 520 {
 521         const struct ide_port_info *d;
 522         struct pci_dev *bridge = dev->bus->self;
 523         u8 idx = id->driver_data;
 524
 525         d = &pdcnew_chipsets[idx];
 526
 527         if (idx == 2 && bridge &&
 528             bridge->vendor == PCI_VENDOR_ID_DEC &&
 529             bridge->device == PCI_DEVICE_ID_DEC_21150) {
 530                 struct pci_dev *dev2;
 531
 532                 if (PCI_SLOT(dev->devfn) & 2)
 533                         return -ENODEV;
 534
 535                 dev2 = pdc20270_get_dev2(dev);
 536
 537                 if (dev2) {
 538                         int ret = ide_setup_pci_devices(dev, dev2, d);
 539                         if (ret < 0)
 540                                 pci_dev_put(dev2);
 541                         return ret;
 542                 }
 543         }
 544
 545         if (idx == 5 && bridge &&
 546             bridge->vendor == PCI_VENDOR_ID_INTEL &&
 547             (bridge->device == PCI_DEVICE_ID_INTEL_I960 ||
 548              bridge->device == PCI_DEVICE_ID_INTEL_I960RM)) {
 549                 printk(KERN_INFO "PDC20276: attached to I2O RAID controller, "
 550                                  "skipping\n");
 551                 return -ENODEV;
 552         }
 553
 554         return ide_setup_pci_device(dev, d);
 555 }
 556
 557 static const struct pci_device_id pdc202new_pci_tbl[] = {
 558         { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20268), 0 },
 559         { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20269), 1 },
 560         { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20270), 2 },
 561         { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20271), 3 },
 562         { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20275), 4 },
 563         { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20276), 5 },
 564         { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20277), 6 },
 565         { 0, },
 566 };
 567 MODULE_DEVICE_TABLE(pci, pdc202new_pci_tbl);
 568
 569 static struct pci_driver driver = {
 570         .name           = "Promise_IDE",
 571         .id_table       = pdc202new_pci_tbl,
 572         .probe          = pdc202new_init_one,
 573 };
 574
 575 static int __init pdc202new_ide_init(void)
 576 {
 577         return ide_pci_register_driver(&driver);
 578 }
 579
 580 module_init(pdc202new_ide_init);
 581
 582 MODULE_AUTHOR("Andre Hedrick, Frank Tiernan");
 583 MODULE_DESCRIPTION("PCI driver module for Promise PDC20268 and higher");
 584 MODULE_LICENSE("GPL");