drivers/tty/serial/8250/8250_pci.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  Probe module for 8250/16550-type PCI serial ports.
   4  *
   5  *  Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
   6  *
   7  *  Copyright (C) 2001 Russell King, All Rights Reserved.
   8  */
   9 #undef DEBUG
  10 #include <linux/module.h>
  11 #include <linux/pci.h>
  12 #include <linux/string.h>
  13 #include <linux/kernel.h>
  14 #include <linux/slab.h>
  15 #include <linux/delay.h>
  16 #include <linux/tty.h>
  17 #include <linux/serial_reg.h>
  18 #include <linux/serial_core.h>
  19 #include <linux/8250_pci.h>
  20 #include <linux/bitops.h>
  21
  22 #include <asm/byteorder.h>
  23 #include <asm/io.h>
  24
  25 #include "8250.h"
  26
  27 /*
  28  * init function returns:
  29  *  > 0 - number of ports
  30  *  = 0 - use board->num_ports
  31  *  < 0 - error
  32  */
  33 struct pci_serial_quirk {
  34         u32     vendor;
  35         u32     device;
  36         u32     subvendor;
  37         u32     subdevice;
  38         int     (*probe)(struct pci_dev *dev);
  39         int     (*init)(struct pci_dev *dev);
  40         int     (*setup)(struct serial_private *,
  41                          const struct pciserial_board *,
  42                          struct uart_8250_port *, int);
  43         void    (*exit)(struct pci_dev *dev);
  44 };
  45
  46 struct f815xxa_data {
  47         spinlock_t lock;
  48         int idx;
  49 };
  50
  51 struct serial_private {
  52         struct pci_dev          *dev;
  53         unsigned int            nr;
  54         struct pci_serial_quirk *quirk;
  55         const struct pciserial_board *board;
  56         int                     line[];
  57 };
  58
  59 #define PCI_DEVICE_ID_HPE_PCI_SERIAL    0x37e
  60
  61 static const struct pci_device_id pci_use_msi[] = {
  62         { PCI_DEVICE_SUB(PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9900,
  63                          0xA000, 0x1000) },
  64         { PCI_DEVICE_SUB(PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9912,
  65                          0xA000, 0x1000) },
  66         { PCI_DEVICE_SUB(PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9922,
  67                          0xA000, 0x1000) },
  68         { PCI_DEVICE_SUB(PCI_VENDOR_ID_HP_3PAR, PCI_DEVICE_ID_HPE_PCI_SERIAL,
  69                          PCI_ANY_ID, PCI_ANY_ID) },
  70         { }
  71 };
  72
  73 static int pci_default_setup(struct serial_private*,
  74           const struct pciserial_board*, struct uart_8250_port *, int);
  75
  76 static void moan_device(const char *str, struct pci_dev *dev)
  77 {
  78         pci_err(dev, "%s\n"
  79                "Please send the output of lspci -vv, this\n"
  80                "message (0x%04x,0x%04x,0x%04x,0x%04x), the\n"
  81                "manufacturer and name of serial board or\n"
  82                "modem board to <linux-serial@vger.kernel.org>.\n",
  83                str, dev->vendor, dev->device,
  84                dev->subsystem_vendor, dev->subsystem_device);
  85 }
  86
  87 static int
  88 setup_port(struct serial_private *priv, struct uart_8250_port *port,
  89            u8 bar, unsigned int offset, int regshift)
  90 {
  91         struct pci_dev *dev = priv->dev;
  92
  93         if (bar >= PCI_STD_NUM_BARS)
  94                 return -EINVAL;
  95
  96         if (pci_resource_flags(dev, bar) & IORESOURCE_MEM) {
  97                 if (!pcim_iomap(dev, bar, 0) && !pcim_iomap_table(dev))
  98                         return -ENOMEM;
  99
 100                 port->port.iotype = UPIO_MEM;
 101                 port->port.iobase = 0;
 102                 port->port.mapbase = pci_resource_start(dev, bar) + offset;
 103                 port->port.membase = pcim_iomap_table(dev)[bar] + offset;
 104                 port->port.regshift = regshift;
 105         } else {
 106                 port->port.iotype = UPIO_PORT;
 107                 port->port.iobase = pci_resource_start(dev, bar) + offset;
 108                 port->port.mapbase = 0;
 109                 port->port.membase = NULL;
 110                 port->port.regshift = 0;
 111         }
 112         return 0;
 113 }
 114
 115 /*
 116  * ADDI-DATA GmbH communication cards <info@addi-data.com>
 117  */
 118 static int addidata_apci7800_setup(struct serial_private *priv,
 119                                 const struct pciserial_board *board,
 120                                 struct uart_8250_port *port, int idx)
 121 {
 122         unsigned int bar = 0, offset = board->first_offset;
 123         bar = FL_GET_BASE(board->flags);
 124
 125         if (idx < 2) {
 126                 offset += idx * board->uart_offset;
 127         } else if ((idx >= 2) && (idx < 4)) {
 128                 bar += 1;
 129                 offset += ((idx - 2) * board->uart_offset);
 130         } else if ((idx >= 4) && (idx < 6)) {
 131                 bar += 2;
 132                 offset += ((idx - 4) * board->uart_offset);
 133         } else if (idx >= 6) {
 134                 bar += 3;
 135                 offset += ((idx - 6) * board->uart_offset);
 136         }
 137
 138         return setup_port(priv, port, bar, offset, board->reg_shift);
 139 }
 140
 141 /*
 142  * AFAVLAB uses a different mixture of BARs and offsets
 143  * Not that ugly ;) -- HW
 144  */
 145 static int
 146 afavlab_setup(struct serial_private *priv, const struct pciserial_board *board,
 147               struct uart_8250_port *port, int idx)
 148 {
 149         unsigned int bar, offset = board->first_offset;
 150
 151         bar = FL_GET_BASE(board->flags);
 152         if (idx < 4)
 153                 bar += idx;
 154         else {
 155                 bar = 4;
 156                 offset += (idx - 4) * board->uart_offset;
 157         }
 158
 159         return setup_port(priv, port, bar, offset, board->reg_shift);
 160 }
 161
 162 /*
 163  * HP's Remote Management Console.  The Diva chip came in several
 164  * different versions.  N-class, L2000 and A500 have two Diva chips, each
 165  * with 3 UARTs (the third UART on the second chip is unused).  Superdome
 166  * and Keystone have one Diva chip with 3 UARTs.  Some later machines have
 167  * one Diva chip, but it has been expanded to 5 UARTs.
 168  */
 169 static int pci_hp_diva_init(struct pci_dev *dev)
 170 {
 171         int rc = 0;
 172
 173         switch (dev->subsystem_device) {
 174         case PCI_DEVICE_ID_HP_DIVA_TOSCA1:
 175         case PCI_DEVICE_ID_HP_DIVA_HALFDOME:
 176         case PCI_DEVICE_ID_HP_DIVA_KEYSTONE:
 177         case PCI_DEVICE_ID_HP_DIVA_EVEREST:
 178                 rc = 3;
 179                 break;
 180         case PCI_DEVICE_ID_HP_DIVA_TOSCA2:
 181                 rc = 2;
 182                 break;
 183         case PCI_DEVICE_ID_HP_DIVA_MAESTRO:
 184                 rc = 4;
 185                 break;
 186         case PCI_DEVICE_ID_HP_DIVA_POWERBAR:
 187         case PCI_DEVICE_ID_HP_DIVA_HURRICANE:
 188                 rc = 1;
 189                 break;
 190         }
 191
 192         return rc;
 193 }
 194
 195 /*
 196  * HP's Diva chip puts the 4th/5th serial port further out, and
 197  * some serial ports are supposed to be hidden on certain models.
 198  */
 199 static int
 200 pci_hp_diva_setup(struct serial_private *priv,
 201                 const struct pciserial_board *board,
 202                 struct uart_8250_port *port, int idx)
 203 {
 204         unsigned int offset = board->first_offset;
 205         unsigned int bar = FL_GET_BASE(board->flags);
 206
 207         switch (priv->dev->subsystem_device) {
 208         case PCI_DEVICE_ID_HP_DIVA_MAESTRO:
 209                 if (idx == 3)
 210                         idx++;
 211                 break;
 212         case PCI_DEVICE_ID_HP_DIVA_EVEREST:
 213                 if (idx > 0)
 214                         idx++;
 215                 if (idx > 2)
 216                         idx++;
 217                 break;
 218         }
 219         if (idx > 2)
 220                 offset = 0x18;
 221
 222         offset += idx * board->uart_offset;
 223
 224         return setup_port(priv, port, bar, offset, board->reg_shift);
 225 }
 226
 227 /*
 228  * Added for EKF Intel i960 serial boards
 229  */
 230 static int pci_inteli960ni_init(struct pci_dev *dev)
 231 {
 232         u32 oldval;
 233
 234         if (!(dev->subsystem_device & 0x1000))
 235                 return -ENODEV;
 236
 237         /* is firmware started? */
 238         pci_read_config_dword(dev, 0x44, &oldval);
 239         if (oldval == 0x00001000L) { /* RESET value */
 240                 pci_dbg(dev, "Local i960 firmware missing\n");
 241                 return -ENODEV;
 242         }
 243         return 0;
 244 }
 245
 246 /*
 247  * Some PCI serial cards using the PLX 9050 PCI interface chip require
 248  * that the card interrupt be explicitly enabled or disabled.  This
 249  * seems to be mainly needed on card using the PLX which also use I/O
 250  * mapped memory.
 251  */
 252 static int pci_plx9050_init(struct pci_dev *dev)
 253 {
 254         u8 irq_config;
 255         void __iomem *p;
 256
 257         if ((pci_resource_flags(dev, 0) & IORESOURCE_MEM) == 0) {
 258                 moan_device("no memory in bar 0", dev);
 259                 return 0;
 260         }
 261
 262         irq_config = 0x41;
 263         if (dev->vendor == PCI_VENDOR_ID_PANACOM ||
 264             dev->subsystem_vendor == PCI_SUBVENDOR_ID_EXSYS)
 265                 irq_config = 0x43;
 266
 267         if ((dev->vendor == PCI_VENDOR_ID_PLX) &&
 268             (dev->device == PCI_DEVICE_ID_PLX_ROMULUS))
 269                 /*
 270                  * As the megawolf cards have the int pins active
 271                  * high, and have 2 UART chips, both ints must be
 272                  * enabled on the 9050. Also, the UARTS are set in
 273                  * 16450 mode by default, so we have to enable the
 274                  * 16C950 'enhanced' mode so that we can use the
 275                  * deep FIFOs
 276                  */
 277                 irq_config = 0x5b;
 278         /*
 279          * enable/disable interrupts
 280          */
 281         p = ioremap(pci_resource_start(dev, 0), 0x80);
 282         if (p == NULL)
 283                 return -ENOMEM;
 284         writel(irq_config, p + 0x4c);
 285
 286         /*
 287          * Read the register back to ensure that it took effect.
 288          */
 289         readl(p + 0x4c);
 290         iounmap(p);
 291
 292         return 0;
 293 }
 294
 295 static void pci_plx9050_exit(struct pci_dev *dev)
 296 {
 297         u8 __iomem *p;
 298
 299         if ((pci_resource_flags(dev, 0) & IORESOURCE_MEM) == 0)
 300                 return;
 301
 302         /*
 303          * disable interrupts
 304          */
 305         p = ioremap(pci_resource_start(dev, 0), 0x80);
 306         if (p != NULL) {
 307                 writel(0, p + 0x4c);
 308
 309                 /*
 310                  * Read the register back to ensure that it took effect.
 311                  */
 312                 readl(p + 0x4c);
 313                 iounmap(p);
 314         }
 315 }
 316
 317 #define NI8420_INT_ENABLE_REG   0x38
 318 #define NI8420_INT_ENABLE_BIT   0x2000
 319
 320 static void pci_ni8420_exit(struct pci_dev *dev)
 321 {
 322         void __iomem *p;
 323         unsigned int bar = 0;
 324
 325         if ((pci_resource_flags(dev, bar) & IORESOURCE_MEM) == 0) {
 326                 moan_device("no memory in bar", dev);
 327                 return;
 328         }
 329
 330         p = pci_ioremap_bar(dev, bar);
 331         if (p == NULL)
 332                 return;
 333
 334         /* Disable the CPU Interrupt */
 335         writel(readl(p + NI8420_INT_ENABLE_REG) & ~(NI8420_INT_ENABLE_BIT),
 336                p + NI8420_INT_ENABLE_REG);
 337         iounmap(p);
 338 }
 339
 340
 341 /* MITE registers */
 342 #define MITE_IOWBSR1    0xc4
 343 #define MITE_IOWCR1     0xf4
 344 #define MITE_LCIMR1     0x08
 345 #define MITE_LCIMR2     0x10
 346
 347 #define MITE_LCIMR2_CLR_CPU_IE  (1 << 30)
 348
 349 static void pci_ni8430_exit(struct pci_dev *dev)
 350 {
 351         void __iomem *p;
 352         unsigned int bar = 0;
 353
 354         if ((pci_resource_flags(dev, bar) & IORESOURCE_MEM) == 0) {
 355                 moan_device("no memory in bar", dev);
 356                 return;
 357         }
 358
 359         p = pci_ioremap_bar(dev, bar);
 360         if (p == NULL)
 361                 return;
 362
 363         /* Disable the CPU Interrupt */
 364         writel(MITE_LCIMR2_CLR_CPU_IE, p + MITE_LCIMR2);
 365         iounmap(p);
 366 }
 367
 368 /* SBS Technologies Inc. PMC-OCTPRO and P-OCTAL cards */
 369 static int
 370 sbs_setup(struct serial_private *priv, const struct pciserial_board *board,
 371                 struct uart_8250_port *port, int idx)
 372 {
 373         unsigned int bar, offset = board->first_offset;
 374
 375         bar = 0;
 376
 377         if (idx < 4) {
 378                 /* first four channels map to 0, 0x100, 0x200, 0x300 */
 379                 offset += idx * board->uart_offset;
 380         } else if (idx < 8) {
 381                 /* last four channels map to 0x1000, 0x1100, 0x1200, 0x1300 */
 382                 offset += idx * board->uart_offset + 0xC00;
 383         } else /* we have only 8 ports on PMC-OCTALPRO */
 384                 return 1;
 385
 386         return setup_port(priv, port, bar, offset, board->reg_shift);
 387 }
 388
 389 /*
 390 * This does initialization for PMC OCTALPRO cards:
 391 * maps the device memory, resets the UARTs (needed, bc
 392 * if the module is removed and inserted again, the card
 393 * is in the sleep mode) and enables global interrupt.
 394 */
 395
 396 /* global control register offset for SBS PMC-OctalPro */
 397 #define OCT_REG_CR_OFF          0x500
 398
 399 static int sbs_init(struct pci_dev *dev)
 400 {
 401         u8 __iomem *p;
 402
 403         p = pci_ioremap_bar(dev, 0);
 404
 405         if (p == NULL)
 406                 return -ENOMEM;
 407         /* Set bit-4 Control Register (UART RESET) in to reset the uarts */
 408         writeb(0x10, p + OCT_REG_CR_OFF);
 409         udelay(50);
 410         writeb(0x0, p + OCT_REG_CR_OFF);
 411
 412         /* Set bit-2 (INTENABLE) of Control Register */
 413         writeb(0x4, p + OCT_REG_CR_OFF);
 414         iounmap(p);
 415
 416         return 0;
 417 }
 418
 419 /*
 420  * Disables the global interrupt of PMC-OctalPro
 421  */
 422
 423 static void sbs_exit(struct pci_dev *dev)
 424 {
 425         u8 __iomem *p;
 426
 427         p = pci_ioremap_bar(dev, 0);
 428         /* FIXME: What if resource_len < OCT_REG_CR_OFF */
 429         if (p != NULL)
 430                 writeb(0, p + OCT_REG_CR_OFF);
 431         iounmap(p);
 432 }
 433
 434 /*
 435  * SIIG serial cards have an PCI interface chip which also controls
 436  * the UART clocking frequency. Each UART can be clocked independently
 437  * (except cards equipped with 4 UARTs) and initial clocking settings
 438  * are stored in the EEPROM chip. It can cause problems because this
 439  * version of serial driver doesn't support differently clocked UART's
 440  * on single PCI card. To prevent this, initialization functions set
 441  * high frequency clocking for all UART's on given card. It is safe (I
 442  * hope) because it doesn't touch EEPROM settings to prevent conflicts
 443  * with other OSes (like M$ DOS).
 444  *
 445  *  SIIG support added by Andrey Panin <pazke@donpac.ru>, 10/1999
 446  *
 447  * There is two family of SIIG serial cards with different PCI
 448  * interface chip and different configuration methods:
 449  *     - 10x cards have control registers in IO and/or memory space;
 450  *     - 20x cards have control registers in standard PCI configuration space.
 451  *
 452  * Note: all 10x cards have PCI device ids 0x10..
 453  *       all 20x cards have PCI device ids 0x20..
 454  *
 455  * There are also Quartet Serial cards which use Oxford Semiconductor
 456  * 16954 quad UART PCI chip clocked by 18.432 MHz quartz.
 457  *
 458  * Note: some SIIG cards are probed by the parport_serial object.
 459  */
 460
 461 #define PCI_DEVICE_ID_SIIG_1S_10x (PCI_DEVICE_ID_SIIG_1S_10x_550 & 0xfffc)
 462 #define PCI_DEVICE_ID_SIIG_2S_10x (PCI_DEVICE_ID_SIIG_2S_10x_550 & 0xfff8)
 463
 464 static int pci_siig10x_init(struct pci_dev *dev)
 465 {
 466         u16 data;
 467         void __iomem *p;
 468
 469         switch (dev->device & 0xfff8) {
 470         case PCI_DEVICE_ID_SIIG_1S_10x: /* 1S */
 471                 data = 0xffdf;
 472                 break;
 473         case PCI_DEVICE_ID_SIIG_2S_10x: /* 2S, 2S1P */
 474                 data = 0xf7ff;
 475                 break;
 476         default:                        /* 1S1P, 4S */
 477                 data = 0xfffb;
 478                 break;
 479         }
 480
 481         p = ioremap(pci_resource_start(dev, 0), 0x80);
 482         if (p == NULL)
 483                 return -ENOMEM;
 484
 485         writew(readw(p + 0x28) & data, p + 0x28);
 486         readw(p + 0x28);
 487         iounmap(p);
 488         return 0;
 489 }
 490
 491 #define PCI_DEVICE_ID_SIIG_2S_20x (PCI_DEVICE_ID_SIIG_2S_20x_550 & 0xfffc)
 492 #define PCI_DEVICE_ID_SIIG_2S1P_20x (PCI_DEVICE_ID_SIIG_2S1P_20x_550 & 0xfffc)
 493
 494 static int pci_siig20x_init(struct pci_dev *dev)
 495 {
 496         u8 data;
 497
 498         /* Change clock frequency for the first UART. */
 499         pci_read_config_byte(dev, 0x6f, &data);
 500         pci_write_config_byte(dev, 0x6f, data & 0xef);
 501
 502         /* If this card has 2 UART, we have to do the same with second UART. */
 503         if (((dev->device & 0xfffc) == PCI_DEVICE_ID_SIIG_2S_20x) ||
 504             ((dev->device & 0xfffc) == PCI_DEVICE_ID_SIIG_2S1P_20x)) {
 505                 pci_read_config_byte(dev, 0x73, &data);
 506                 pci_write_config_byte(dev, 0x73, data & 0xef);
 507         }
 508         return 0;
 509 }
 510
 511 static int pci_siig_init(struct pci_dev *dev)
 512 {
 513         unsigned int type = dev->device & 0xff00;
 514
 515         if (type == 0x1000)
 516                 return pci_siig10x_init(dev);
 517         if (type == 0x2000)
 518                 return pci_siig20x_init(dev);
 519
 520         moan_device("Unknown SIIG card", dev);
 521         return -ENODEV;
 522 }
 523
 524 static int pci_siig_setup(struct serial_private *priv,
 525                           const struct pciserial_board *board,
 526                           struct uart_8250_port *port, int idx)
 527 {
 528         unsigned int bar = FL_GET_BASE(board->flags) + idx, offset = 0;
 529
 530         if (idx > 3) {
 531                 bar = 4;
 532                 offset = (idx - 4) * 8;
 533         }
 534
 535         return setup_port(priv, port, bar, offset, 0);
 536 }
 537
 538 /*
 539  * Timedia has an explosion of boards, and to avoid the PCI table from
 540  * growing *huge*, we use this function to collapse some 70 entries
 541  * in the PCI table into one, for sanity's and compactness's sake.
 542  */
 543 static const unsigned short timedia_single_port[] = {
 544         0x4025, 0x4027, 0x4028, 0x5025, 0x5027, 0
 545 };
 546
 547 static const unsigned short timedia_dual_port[] = {
 548         0x0002, 0x4036, 0x4037, 0x4038, 0x4078, 0x4079, 0x4085,
 549         0x4088, 0x4089, 0x5037, 0x5078, 0x5079, 0x5085, 0x6079,
 550         0x7079, 0x8079, 0x8137, 0x8138, 0x8237, 0x8238, 0x9079,
 551         0x9137, 0x9138, 0x9237, 0x9238, 0xA079, 0xB079, 0xC079,
 552         0xD079, 0
 553 };
 554
 555 static const unsigned short timedia_quad_port[] = {
 556         0x4055, 0x4056, 0x4095, 0x4096, 0x5056, 0x8156, 0x8157,
 557         0x8256, 0x8257, 0x9056, 0x9156, 0x9157, 0x9158, 0x9159,
 558         0x9256, 0x9257, 0xA056, 0xA157, 0xA158, 0xA159, 0xB056,
 559         0xB157, 0
 560 };
 561
 562 static const unsigned short timedia_eight_port[] = {
 563         0x4065, 0x4066, 0x5065, 0x5066, 0x8166, 0x9066, 0x9166,
 564         0x9167, 0x9168, 0xA066, 0xA167, 0xA168, 0
 565 };
 566
 567 static const struct timedia_struct {
 568         int num;
 569         const unsigned short *ids;
 570 } timedia_data[] = {
 571         { 1, timedia_single_port },
 572         { 2, timedia_dual_port },
 573         { 4, timedia_quad_port },
 574         { 8, timedia_eight_port }
 575 };
 576
 577 /*
 578  * There are nearly 70 different Timedia/SUNIX PCI serial devices.  Instead of
 579  * listing them individually, this driver merely grabs them all with
 580  * PCI_ANY_ID.  Some of these devices, however, also feature a parallel port,
 581  * and should be left free to be claimed by parport_serial instead.
 582  */
 583 static int pci_timedia_probe(struct pci_dev *dev)
 584 {
 585         /*
 586          * Check the third digit of the subdevice ID
 587          * (0,2,3,5,6: serial only -- 7,8,9: serial + parallel)
 588          */
 589         if ((dev->subsystem_device & 0x00f0) >= 0x70) {
 590                 pci_info(dev, "ignoring Timedia subdevice %04x for parport_serial\n",
 591                          dev->subsystem_device);
 592                 return -ENODEV;
 593         }
 594
 595         return 0;
 596 }
 597
 598 static int pci_timedia_init(struct pci_dev *dev)
 599 {
 600         const unsigned short *ids;
 601         int i, j;
 602
 603         for (i = 0; i < ARRAY_SIZE(timedia_data); i++) {
 604                 ids = timedia_data[i].ids;
 605                 for (j = 0; ids[j]; j++)
 606                         if (dev->subsystem_device == ids[j])
 607                                 return timedia_data[i].num;
 608         }
 609         return 0;
 610 }
 611
 612 /*
 613  * Timedia/SUNIX uses a mixture of BARs and offsets
 614  * Ugh, this is ugly as all hell --- TYT
 615  */
 616 static int
 617 pci_timedia_setup(struct serial_private *priv,
 618                   const struct pciserial_board *board,
 619                   struct uart_8250_port *port, int idx)
 620 {
 621         unsigned int bar = 0, offset = board->first_offset;
 622
 623         switch (idx) {
 624         case 0:
 625                 bar = 0;
 626                 break;
 627         case 1:
 628                 offset = board->uart_offset;
 629                 bar = 0;
 630                 break;
 631         case 2:
 632                 bar = 1;
 633                 break;
 634         case 3:
 635                 offset = board->uart_offset;
 636                 fallthrough;
 637         case 4: /* BAR 2 */
 638         case 5: /* BAR 3 */
 639         case 6: /* BAR 4 */
 640         case 7: /* BAR 5 */
 641                 bar = idx - 2;
 642         }
 643
 644         return setup_port(priv, port, bar, offset, board->reg_shift);
 645 }
 646
 647 /*
 648  * Some Titan cards are also a little weird
 649  */
 650 static int
 651 titan_400l_800l_setup(struct serial_private *priv,
 652                       const struct pciserial_board *board,
 653                       struct uart_8250_port *port, int idx)
 654 {
 655         unsigned int bar, offset = board->first_offset;
 656
 657         switch (idx) {
 658         case 0:
 659                 bar = 1;
 660                 break;
 661         case 1:
 662                 bar = 2;
 663                 break;
 664         default:
 665                 bar = 4;
 666                 offset = (idx - 2) * board->uart_offset;
 667         }
 668
 669         return setup_port(priv, port, bar, offset, board->reg_shift);
 670 }
 671
 672 static int pci_xircom_init(struct pci_dev *dev)
 673 {
 674         msleep(100);
 675         return 0;
 676 }
 677
 678 static int pci_ni8420_init(struct pci_dev *dev)
 679 {
 680         void __iomem *p;
 681         unsigned int bar = 0;
 682
 683         if ((pci_resource_flags(dev, bar) & IORESOURCE_MEM) == 0) {
 684                 moan_device("no memory in bar", dev);
 685                 return 0;
 686         }
 687
 688         p = pci_ioremap_bar(dev, bar);
 689         if (p == NULL)
 690                 return -ENOMEM;
 691
 692         /* Enable CPU Interrupt */
 693         writel(readl(p + NI8420_INT_ENABLE_REG) | NI8420_INT_ENABLE_BIT,
 694                p + NI8420_INT_ENABLE_REG);
 695
 696         iounmap(p);
 697         return 0;
 698 }
 699
 700 #define MITE_IOWBSR1_WSIZE      0xa
 701 #define MITE_IOWBSR1_WIN_OFFSET 0x800
 702 #define MITE_IOWBSR1_WENAB      (1 << 7)
 703 #define MITE_LCIMR1_IO_IE_0     (1 << 24)
 704 #define MITE_LCIMR2_SET_CPU_IE  (1 << 31)
 705 #define MITE_IOWCR1_RAMSEL_MASK 0xfffffffe
 706
 707 static int pci_ni8430_init(struct pci_dev *dev)
 708 {
 709         void __iomem *p;
 710         struct pci_bus_region region;
 711         u32 device_window;
 712         unsigned int bar = 0;
 713
 714         if ((pci_resource_flags(dev, bar) & IORESOURCE_MEM) == 0) {
 715                 moan_device("no memory in bar", dev);
 716                 return 0;
 717         }
 718
 719         p = pci_ioremap_bar(dev, bar);
 720         if (p == NULL)
 721                 return -ENOMEM;
 722
 723         /*
 724          * Set device window address and size in BAR0, while acknowledging that
 725          * the resource structure may contain a translated address that differs
 726          * from the address the device responds to.
 727          */
 728         pcibios_resource_to_bus(dev->bus, &region, &dev->resource[bar]);
 729         device_window = ((region.start + MITE_IOWBSR1_WIN_OFFSET) & 0xffffff00)
 730                         | MITE_IOWBSR1_WENAB | MITE_IOWBSR1_WSIZE;
 731         writel(device_window, p + MITE_IOWBSR1);
 732
 733         /* Set window access to go to RAMSEL IO address space */
 734         writel((readl(p + MITE_IOWCR1) & MITE_IOWCR1_RAMSEL_MASK),
 735                p + MITE_IOWCR1);
 736
 737         /* Enable IO Bus Interrupt 0 */
 738         writel(MITE_LCIMR1_IO_IE_0, p + MITE_LCIMR1);
 739
 740         /* Enable CPU Interrupt */
 741         writel(MITE_LCIMR2_SET_CPU_IE, p + MITE_LCIMR2);
 742
 743         iounmap(p);
 744         return 0;
 745 }
 746
 747 /* UART Port Control Register */
 748 #define NI8430_PORTCON  0x0f
 749 #define NI8430_PORTCON_TXVR_ENABLE      (1 << 3)
 750
 751 static int
 752 pci_ni8430_setup(struct serial_private *priv,
 753                  const struct pciserial_board *board,
 754                  struct uart_8250_port *port, int idx)
 755 {
 756         struct pci_dev *dev = priv->dev;
 757         void __iomem *p;
 758         unsigned int bar, offset = board->first_offset;
 759
 760         if (idx >= board->num_ports)
 761                 return 1;
 762
 763         bar = FL_GET_BASE(board->flags);
 764         offset += idx * board->uart_offset;
 765
 766         p = pci_ioremap_bar(dev, bar);
 767         if (!p)
 768                 return -ENOMEM;
 769
 770         /* enable the transceiver */
 771         writeb(readb(p + offset + NI8430_PORTCON) | NI8430_PORTCON_TXVR_ENABLE,
 772                p + offset + NI8430_PORTCON);
 773
 774         iounmap(p);
 775
 776         return setup_port(priv, port, bar, offset, board->reg_shift);
 777 }
 778
 779 static int pci_netmos_9900_setup(struct serial_private *priv,
 780                                 const struct pciserial_board *board,
 781                                 struct uart_8250_port *port, int idx)
 782 {
 783         unsigned int bar;
 784
 785         if ((priv->dev->device != PCI_DEVICE_ID_NETMOS_9865) &&
 786             (priv->dev->subsystem_device & 0xff00) == 0x3000) {
 787                 /* netmos apparently orders BARs by datasheet layout, so serial
 788                  * ports get BARs 0 and 3 (or 1 and 4 for memmapped)
 789                  */
 790                 bar = 3 * idx;
 791
 792                 return setup_port(priv, port, bar, 0, board->reg_shift);
 793         }
 794
 795         return pci_default_setup(priv, board, port, idx);
 796 }
 797
 798 /* the 99xx series comes with a range of device IDs and a variety
 799  * of capabilities:
 800  *
 801  * 9900 has varying capabilities and can cascade to sub-controllers
 802  *   (cascading should be purely internal)
 803  * 9904 is hardwired with 4 serial ports
 804  * 9912 and 9922 are hardwired with 2 serial ports
 805  */
 806 static int pci_netmos_9900_numports(struct pci_dev *dev)
 807 {
 808         unsigned int c = dev->class;
 809         unsigned int pi;
 810         unsigned short sub_serports;
 811
 812         pi = c & 0xff;
 813
 814         if (pi == 2)
 815                 return 1;
 816
 817         if ((pi == 0) && (dev->device == PCI_DEVICE_ID_NETMOS_9900)) {
 818                 /* two possibilities: 0x30ps encodes number of parallel and
 819                  * serial ports, or 0x1000 indicates *something*. This is not
 820                  * immediately obvious, since the 2s1p+4s configuration seems
 821                  * to offer all functionality on functions 0..2, while still
 822                  * advertising the same function 3 as the 4s+2s1p config.
 823                  */
 824                 sub_serports = dev->subsystem_device & 0xf;
 825                 if (sub_serports > 0)
 826                         return sub_serports;
 827
 828                 pci_err(dev, "NetMos/Mostech serial driver ignoring port on ambiguous config.\n");
 829                 return 0;
 830         }
 831
 832         moan_device("unknown NetMos/Mostech program interface", dev);
 833         return 0;
 834 }
 835
 836 static int pci_netmos_init(struct pci_dev *dev)
 837 {
 838         /* subdevice 0x00PS means <P> parallel, <S> serial */
 839         unsigned int num_serial = dev->subsystem_device & 0xf;
 840
 841         if ((dev->device == PCI_DEVICE_ID_NETMOS_9901) ||
 842                 (dev->device == PCI_DEVICE_ID_NETMOS_9865))
 843                 return 0;
 844
 845         if (dev->subsystem_vendor == PCI_VENDOR_ID_IBM &&
 846                         dev->subsystem_device == 0x0299)
 847                 return 0;
 848
 849         switch (dev->device) { /* FALLTHROUGH on all */
 850         case PCI_DEVICE_ID_NETMOS_9904:
 851         case PCI_DEVICE_ID_NETMOS_9912:
 852         case PCI_DEVICE_ID_NETMOS_9922:
 853         case PCI_DEVICE_ID_NETMOS_9900:
 854                 num_serial = pci_netmos_9900_numports(dev);
 855                 break;
 856
 857         default:
 858                 break;
 859         }
 860
 861         if (num_serial == 0) {
 862                 moan_device("unknown NetMos/Mostech device", dev);
 863                 return -ENODEV;
 864         }
 865
 866         return num_serial;
 867 }
 868
 869 /*
 870  * These chips are available with optionally one parallel port and up to
 871  * two serial ports. Unfortunately they all have the same product id.
 872  *
 873  * Basic configuration is done over a region of 32 I/O ports. The base
 874  * ioport is called INTA or INTC, depending on docs/other drivers.
 875  *
 876  * The region of the 32 I/O ports is configured in POSIO0R...
 877  */
 878
 879 /* registers */
 880 #define ITE_887x_MISCR          0x9c
 881 #define ITE_887x_INTCBAR        0x78
 882 #define ITE_887x_UARTBAR        0x7c
 883 #define ITE_887x_PS0BAR         0x10
 884 #define ITE_887x_POSIO0         0x60
 885
 886 /* I/O space size */
 887 #define ITE_887x_IOSIZE         32
 888 /* I/O space size (bits 26-24; 8 bytes = 011b) */
 889 #define ITE_887x_POSIO_IOSIZE_8         (3 << 24)
 890 /* I/O space size (bits 26-24; 32 bytes = 101b) */
 891 #define ITE_887x_POSIO_IOSIZE_32        (5 << 24)
 892 /* Decoding speed (1 = slow, 2 = medium, 3 = fast) */
 893 #define ITE_887x_POSIO_SPEED            (3 << 29)
 894 /* enable IO_Space bit */
 895 #define ITE_887x_POSIO_ENABLE           (1 << 31)
 896
 897 /* inta_addr are the configuration addresses of the ITE */
 898 static const short inta_addr[] = { 0x2a0, 0x2c0, 0x220, 0x240, 0x1e0, 0x200, 0x280 };
 899 static int pci_ite887x_init(struct pci_dev *dev)
 900 {
 901         int ret, i, type;
 902         struct resource *iobase = NULL;
 903         u32 miscr, uartbar, ioport;
 904
 905         /* search for the base-ioport */
 906         for (i = 0; i < ARRAY_SIZE(inta_addr); i++) {
 907                 iobase = request_region(inta_addr[i], ITE_887x_IOSIZE,
 908                                                                 "ite887x");
 909                 if (iobase != NULL) {
 910                         /* write POSIO0R - speed | size | ioport */
 911                         pci_write_config_dword(dev, ITE_887x_POSIO0,
 912                                 ITE_887x_POSIO_ENABLE | ITE_887x_POSIO_SPEED |
 913                                 ITE_887x_POSIO_IOSIZE_32 | inta_addr[i]);
 914                         /* write INTCBAR - ioport */
 915                         pci_write_config_dword(dev, ITE_887x_INTCBAR,
 916                                                                 inta_addr[i]);
 917                         ret = inb(inta_addr[i]);
 918                         if (ret != 0xff) {
 919                                 /* ioport connected */
 920                                 break;
 921                         }
 922                         release_region(iobase->start, ITE_887x_IOSIZE);
 923                 }
 924         }
 925
 926         if (i == ARRAY_SIZE(inta_addr)) {
 927                 pci_err(dev, "could not find iobase\n");
 928                 return -ENODEV;
 929         }
 930
 931         /* start of undocumented type checking (see parport_pc.c) */
 932         type = inb(iobase->start + 0x18) & 0x0f;
 933
 934         switch (type) {
 935         case 0x2:       /* ITE8871 (1P) */
 936         case 0xa:       /* ITE8875 (1P) */
 937                 ret = 0;
 938                 break;
 939         case 0xe:       /* ITE8872 (2S1P) */
 940                 ret = 2;
 941                 break;
 942         case 0x6:       /* ITE8873 (1S) */
 943                 ret = 1;
 944                 break;
 945         case 0x8:       /* ITE8874 (2S) */
 946                 ret = 2;
 947                 break;
 948         default:
 949                 moan_device("Unknown ITE887x", dev);
 950                 ret = -ENODEV;
 951         }
 952
 953         /* configure all serial ports */
 954         for (i = 0; i < ret; i++) {
 955                 /* read the I/O port from the device */
 956                 pci_read_config_dword(dev, ITE_887x_PS0BAR + (0x4 * (i + 1)),
 957                                                                 &ioport);
 958                 ioport &= 0x0000FF00;   /* the actual base address */
 959                 pci_write_config_dword(dev, ITE_887x_POSIO0 + (0x4 * (i + 1)),
 960                         ITE_887x_POSIO_ENABLE | ITE_887x_POSIO_SPEED |
 961                         ITE_887x_POSIO_IOSIZE_8 | ioport);
 962
 963                 /* write the ioport to the UARTBAR */
 964                 pci_read_config_dword(dev, ITE_887x_UARTBAR, &uartbar);
 965                 uartbar &= ~(0xffff << (16 * i));       /* clear half the reg */
 966                 uartbar |= (ioport << (16 * i));        /* set the ioport */
 967                 pci_write_config_dword(dev, ITE_887x_UARTBAR, uartbar);
 968
 969                 /* get current config */
 970                 pci_read_config_dword(dev, ITE_887x_MISCR, &miscr);
 971                 /* disable interrupts (UARTx_Routing[3:0]) */
 972                 miscr &= ~(0xf << (12 - 4 * i));
 973                 /* activate the UART (UARTx_En) */
 974                 miscr |= 1 << (23 - i);
 975                 /* write new config with activated UART */
 976                 pci_write_config_dword(dev, ITE_887x_MISCR, miscr);
 977         }
 978
 979         if (ret <= 0) {
 980                 /* the device has no UARTs if we get here */
 981                 release_region(iobase->start, ITE_887x_IOSIZE);
 982         }
 983
 984         return ret;
 985 }
 986
 987 static void pci_ite887x_exit(struct pci_dev *dev)
 988 {
 989         u32 ioport;
 990         /* the ioport is bit 0-15 in POSIO0R */
 991         pci_read_config_dword(dev, ITE_887x_POSIO0, &ioport);
 992         ioport &= 0xffff;
 993         release_region(ioport, ITE_887x_IOSIZE);
 994 }
 995
 996 /*
 997  * EndRun Technologies.
 998  * Determine the number of ports available on the device.
 999  */
1000 #define PCI_VENDOR_ID_ENDRUN                    0x7401
1001 #define PCI_DEVICE_ID_ENDRUN_1588       0xe100
1002
1003 static int pci_endrun_init(struct pci_dev *dev)
1004 {
1005         u8 __iomem *p;
1006         unsigned long deviceID;
1007         unsigned int  number_uarts = 0;
1008
1009         /* EndRun device is all 0xexxx */
1010         if (dev->vendor == PCI_VENDOR_ID_ENDRUN &&
1011                 (dev->device & 0xf000) != 0xe000)
1012                 return 0;
1013
1014         p = pci_iomap(dev, 0, 5);
1015         if (p == NULL)
1016                 return -ENOMEM;
1017
1018         deviceID = ioread32(p);
1019         /* EndRun device */
1020         if (deviceID == 0x07000200) {
1021                 number_uarts = ioread8(p + 4);
1022                 pci_dbg(dev, "%d ports detected on EndRun PCI Express device\n", number_uarts);
1023         }
1024         pci_iounmap(dev, p);
1025         return number_uarts;
1026 }
1027
1028 /*
1029  * Oxford Semiconductor Inc.
1030  * Check that device is part of the Tornado range of devices, then determine
1031  * the number of ports available on the device.
1032  */
1033 static int pci_oxsemi_tornado_init(struct pci_dev *dev)
1034 {
1035         u8 __iomem *p;
1036         unsigned long deviceID;
1037         unsigned int  number_uarts = 0;
1038
1039         /* OxSemi Tornado devices are all 0xCxxx */
1040         if (dev->vendor == PCI_VENDOR_ID_OXSEMI &&
1041             (dev->device & 0xF000) != 0xC000)
1042                 return 0;
1043
1044         p = pci_iomap(dev, 0, 5);
1045         if (p == NULL)
1046                 return -ENOMEM;
1047
1048         deviceID = ioread32(p);
1049         /* Tornado device */
1050         if (deviceID == 0x07000200) {
1051                 number_uarts = ioread8(p + 4);
1052                 pci_dbg(dev, "%d ports detected on Oxford PCI Express device\n", number_uarts);
1053         }
1054         pci_iounmap(dev, p);
1055         return number_uarts;
1056 }
1057
1058 static int pci_asix_setup(struct serial_private *priv,
1059                   const struct pciserial_board *board,
1060                   struct uart_8250_port *port, int idx)
1061 {
1062         port->bugs |= UART_BUG_PARITY;
1063         return pci_default_setup(priv, board, port, idx);
1064 }
1065
1066 #define QPCR_TEST_FOR1          0x3F
1067 #define QPCR_TEST_GET1          0x00
1068 #define QPCR_TEST_FOR2          0x40
1069 #define QPCR_TEST_GET2          0x40
1070 #define QPCR_TEST_FOR3          0x80
1071 #define QPCR_TEST_GET3          0x40
1072 #define QPCR_TEST_FOR4          0xC0
1073 #define QPCR_TEST_GET4          0x80
1074
1075 #define QOPR_CLOCK_X1           0x0000
1076 #define QOPR_CLOCK_X2           0x0001
1077 #define QOPR_CLOCK_X4           0x0002
1078 #define QOPR_CLOCK_X8           0x0003
1079 #define QOPR_CLOCK_RATE_MASK    0x0003
1080
1081 /* Quatech devices have their own extra interface features */
1082 static struct pci_device_id quatech_cards[] = {
1083         { PCI_DEVICE_DATA(QUATECH, QSC100,   1) },
1084         { PCI_DEVICE_DATA(QUATECH, DSC100,   1) },
1085         { PCI_DEVICE_DATA(QUATECH, DSC100E,  0) },
1086         { PCI_DEVICE_DATA(QUATECH, DSC200,   1) },
1087         { PCI_DEVICE_DATA(QUATECH, DSC200E,  0) },
1088         { PCI_DEVICE_DATA(QUATECH, ESC100D,  1) },
1089         { PCI_DEVICE_DATA(QUATECH, ESC100M,  1) },
1090         { PCI_DEVICE_DATA(QUATECH, QSCP100,  1) },
1091         { PCI_DEVICE_DATA(QUATECH, DSCP100,  1) },
1092         { PCI_DEVICE_DATA(QUATECH, QSCP200,  1) },
1093         { PCI_DEVICE_DATA(QUATECH, DSCP200,  1) },
1094         { PCI_DEVICE_DATA(QUATECH, ESCLP100, 0) },
1095         { PCI_DEVICE_DATA(QUATECH, QSCLP100, 0) },
1096         { PCI_DEVICE_DATA(QUATECH, DSCLP100, 0) },
1097         { PCI_DEVICE_DATA(QUATECH, SSCLP100, 0) },
1098         { PCI_DEVICE_DATA(QUATECH, QSCLP200, 0) },
1099         { PCI_DEVICE_DATA(QUATECH, DSCLP200, 0) },
1100         { PCI_DEVICE_DATA(QUATECH, SSCLP200, 0) },
1101         { PCI_DEVICE_DATA(QUATECH, SPPXP_100, 0) },
1102         { 0, }
1103 };
1104
1105 static int pci_quatech_rqopr(struct uart_8250_port *port)
1106 {
1107         unsigned long base = port->port.iobase;
1108         u8 LCR, val;
1109
1110         LCR = inb(base + UART_LCR);
1111         outb(0xBF, base + UART_LCR);
1112         val = inb(base + UART_SCR);
1113         outb(LCR, base + UART_LCR);
1114         return val;
1115 }
1116
1117 static void pci_quatech_wqopr(struct uart_8250_port *port, u8 qopr)
1118 {
1119         unsigned long base = port->port.iobase;
1120         u8 LCR;
1121
1122         LCR = inb(base + UART_LCR);
1123         outb(0xBF, base + UART_LCR);
1124         inb(base + UART_SCR);
1125         outb(qopr, base + UART_SCR);
1126         outb(LCR, base + UART_LCR);
1127 }
1128
1129 static int pci_quatech_rqmcr(struct uart_8250_port *port)
1130 {
1131         unsigned long base = port->port.iobase;
1132         u8 LCR, val, qmcr;
1133
1134         LCR = inb(base + UART_LCR);
1135         outb(0xBF, base + UART_LCR);
1136         val = inb(base + UART_SCR);
1137         outb(val | 0x10, base + UART_SCR);
1138         qmcr = inb(base + UART_MCR);
1139         outb(val, base + UART_SCR);
1140         outb(LCR, base + UART_LCR);
1141
1142         return qmcr;
1143 }
1144
1145 static void pci_quatech_wqmcr(struct uart_8250_port *port, u8 qmcr)
1146 {
1147         unsigned long base = port->port.iobase;
1148         u8 LCR, val;
1149
1150         LCR = inb(base + UART_LCR);
1151         outb(0xBF, base + UART_LCR);
1152         val = inb(base + UART_SCR);
1153         outb(val | 0x10, base + UART_SCR);
1154         outb(qmcr, base + UART_MCR);
1155         outb(val, base + UART_SCR);
1156         outb(LCR, base + UART_LCR);
1157 }
1158
1159 static int pci_quatech_has_qmcr(struct uart_8250_port *port)
1160 {
1161         unsigned long base = port->port.iobase;
1162         u8 LCR, val;
1163
1164         LCR = inb(base + UART_LCR);
1165         outb(0xBF, base + UART_LCR);
1166         val = inb(base + UART_SCR);
1167         if (val & 0x20) {
1168                 outb(0x80, UART_LCR);
1169                 if (!(inb(UART_SCR) & 0x20)) {
1170                         outb(LCR, base + UART_LCR);
1171                         return 1;
1172                 }
1173         }
1174         return 0;
1175 }
1176
1177 static int pci_quatech_test(struct uart_8250_port *port)
1178 {
1179         u8 reg, qopr;
1180
1181         qopr = pci_quatech_rqopr(port);
1182         pci_quatech_wqopr(port, qopr & QPCR_TEST_FOR1);
1183         reg = pci_quatech_rqopr(port) & 0xC0;
1184         if (reg != QPCR_TEST_GET1)
1185                 return -EINVAL;
1186         pci_quatech_wqopr(port, (qopr & QPCR_TEST_FOR1)|QPCR_TEST_FOR2);
1187         reg = pci_quatech_rqopr(port) & 0xC0;
1188         if (reg != QPCR_TEST_GET2)
1189                 return -EINVAL;
1190         pci_quatech_wqopr(port, (qopr & QPCR_TEST_FOR1)|QPCR_TEST_FOR3);
1191         reg = pci_quatech_rqopr(port) & 0xC0;
1192         if (reg != QPCR_TEST_GET3)
1193                 return -EINVAL;
1194         pci_quatech_wqopr(port, (qopr & QPCR_TEST_FOR1)|QPCR_TEST_FOR4);
1195         reg = pci_quatech_rqopr(port) & 0xC0;
1196         if (reg != QPCR_TEST_GET4)
1197                 return -EINVAL;
1198
1199         pci_quatech_wqopr(port, qopr);
1200         return 0;
1201 }
1202
1203 static int pci_quatech_clock(struct uart_8250_port *port)
1204 {
1205         u8 qopr, reg, set;
1206         unsigned long clock;
1207
1208         if (pci_quatech_test(port) < 0)
1209                 return 1843200;
1210
1211         qopr = pci_quatech_rqopr(port);
1212
1213         pci_quatech_wqopr(port, qopr & ~QOPR_CLOCK_X8);
1214         reg = pci_quatech_rqopr(port);
1215         if (reg & QOPR_CLOCK_X8) {
1216                 clock = 1843200;
1217                 goto out;
1218         }
1219         pci_quatech_wqopr(port, qopr | QOPR_CLOCK_X8);
1220         reg = pci_quatech_rqopr(port);
1221         if (!(reg & QOPR_CLOCK_X8)) {
1222                 clock = 1843200;
1223                 goto out;
1224         }
1225         reg &= QOPR_CLOCK_X8;
1226         if (reg == QOPR_CLOCK_X2) {
1227                 clock =  3685400;
1228                 set = QOPR_CLOCK_X2;
1229         } else if (reg == QOPR_CLOCK_X4) {
1230                 clock = 7372800;
1231                 set = QOPR_CLOCK_X4;
1232         } else if (reg == QOPR_CLOCK_X8) {
1233                 clock = 14745600;
1234                 set = QOPR_CLOCK_X8;
1235         } else {
1236                 clock = 1843200;
1237                 set = QOPR_CLOCK_X1;
1238         }
1239         qopr &= ~QOPR_CLOCK_RATE_MASK;
1240         qopr |= set;
1241
1242 out:
1243         pci_quatech_wqopr(port, qopr);
1244         return clock;
1245 }
1246
1247 static int pci_quatech_rs422(struct uart_8250_port *port)
1248 {
1249         u8 qmcr;
1250         int rs422 = 0;
1251
1252         if (!pci_quatech_has_qmcr(port))
1253                 return 0;
1254         qmcr = pci_quatech_rqmcr(port);
1255         pci_quatech_wqmcr(port, 0xFF);
1256         if (pci_quatech_rqmcr(port))
1257                 rs422 = 1;
1258         pci_quatech_wqmcr(port, qmcr);
1259         return rs422;
1260 }
1261
1262 static int pci_quatech_init(struct pci_dev *dev)
1263 {
1264         const struct pci_device_id *match;
1265         bool amcc = false;
1266
1267         match = pci_match_id(quatech_cards, dev);
1268         if (match)
1269                 amcc = match->driver_data;
1270         else
1271                 pci_err(dev, "unknown port type '0x%04X'.\n", dev->device);
1272
1273         if (amcc) {
1274                 unsigned long base = pci_resource_start(dev, 0);
1275                 if (base) {
1276                         u32 tmp;
1277
1278                         outl(inl(base + 0x38) | 0x00002000, base + 0x38);
1279                         tmp = inl(base + 0x3c);
1280                         outl(tmp | 0x01000000, base + 0x3c);
1281                         outl(tmp & ~0x01000000, base + 0x3c);
1282                 }
1283         }
1284         return 0;
1285 }
1286
1287 static int pci_quatech_setup(struct serial_private *priv,
1288                   const struct pciserial_board *board,
1289                   struct uart_8250_port *port, int idx)
1290 {
1291         /* Needed by pci_quatech calls below */
1292         port->port.iobase = pci_resource_start(priv->dev, FL_GET_BASE(board->flags));
1293         /* Set up the clocking */
1294         port->port.uartclk = pci_quatech_clock(port);
1295         /* For now just warn about RS422 */
1296         if (pci_quatech_rs422(port))
1297                 pci_warn(priv->dev, "software control of RS422 features not currently supported.\n");
1298         return pci_default_setup(priv, board, port, idx);
1299 }
1300
1301 static int pci_default_setup(struct serial_private *priv,
1302                   const struct pciserial_board *board,
1303                   struct uart_8250_port *port, int idx)
1304 {
1305         unsigned int bar, offset = board->first_offset, maxnr;
1306
1307         bar = FL_GET_BASE(board->flags);
1308         if (board->flags & FL_BASE_BARS)
1309                 bar += idx;
1310         else
1311                 offset += idx * board->uart_offset;
1312
1313         maxnr = (pci_resource_len(priv->dev, bar) - board->first_offset) >>
1314                 (board->reg_shift + 3);
1315
1316         if (board->flags & FL_REGION_SZ_CAP && idx >= maxnr)
1317                 return 1;
1318
1319         return setup_port(priv, port, bar, offset, board->reg_shift);
1320 }
1321
1322 static int
1323 ce4100_serial_setup(struct serial_private *priv,
1324                   const struct pciserial_board *board,
1325                   struct uart_8250_port *port, int idx)
1326 {
1327         int ret;
1328
1329         ret = setup_port(priv, port, idx, 0, board->reg_shift);
1330         port->port.iotype = UPIO_MEM32;
1331         port->port.type = PORT_XSCALE;
1332         port->port.flags = (port->port.flags | UPF_FIXED_PORT | UPF_FIXED_TYPE);
1333         port->port.regshift = 2;
1334
1335         return ret;
1336 }
1337
1338 static int
1339 pci_omegapci_setup(struct serial_private *priv,
1340                       const struct pciserial_board *board,
1341                       struct uart_8250_port *port, int idx)
1342 {
1343         return setup_port(priv, port, 2, idx * 8, 0);
1344 }
1345
1346 static int
1347 pci_brcm_trumanage_setup(struct serial_private *priv,
1348                          const struct pciserial_board *board,
1349                          struct uart_8250_port *port, int idx)
1350 {
1351         int ret = pci_default_setup(priv, board, port, idx);
1352
1353         port->port.type = PORT_BRCM_TRUMANAGE;
1354         port->port.flags = (port->port.flags | UPF_FIXED_PORT | UPF_FIXED_TYPE);
1355         return ret;
1356 }
1357
1358 /* RTS will control by MCR if this bit is 0 */
1359 #define FINTEK_RTS_CONTROL_BY_HW        BIT(4)
1360 /* only worked with FINTEK_RTS_CONTROL_BY_HW on */
1361 #define FINTEK_RTS_INVERT               BIT(5)
1362
1363 /* We should do proper H/W transceiver setting before change to RS485 mode */
1364 static int pci_fintek_rs485_config(struct uart_port *port,
1365                                struct serial_rs485 *rs485)
1366 {
1367         struct pci_dev *pci_dev = to_pci_dev(port->dev);
1368         u8 setting;
1369         u8 *index = (u8 *) port->private_data;
1370
1371         pci_read_config_byte(pci_dev, 0x40 + 8 * *index + 7, &setting);
1372
1373         if (!rs485)
1374                 rs485 = &port->rs485;
1375         else if (rs485->flags & SER_RS485_ENABLED)
1376                 memset(rs485->padding, 0, sizeof(rs485->padding));
1377         else
1378                 memset(rs485, 0, sizeof(*rs485));
1379
1380         /* F81504/508/512 not support RTS delay before or after send */
1381         rs485->flags &= SER_RS485_ENABLED | SER_RS485_RTS_ON_SEND;
1382
1383         if (rs485->flags & SER_RS485_ENABLED) {
1384                 /* Enable RTS H/W control mode */
1385                 setting |= FINTEK_RTS_CONTROL_BY_HW;
1386
1387                 if (rs485->flags & SER_RS485_RTS_ON_SEND) {
1388                         /* RTS driving high on TX */
1389                         setting &= ~FINTEK_RTS_INVERT;
1390                 } else {
1391                         /* RTS driving low on TX */
1392                         setting |= FINTEK_RTS_INVERT;
1393                 }
1394
1395                 rs485->delay_rts_after_send = 0;
1396                 rs485->delay_rts_before_send = 0;
1397         } else {
1398                 /* Disable RTS H/W control mode */
1399                 setting &= ~(FINTEK_RTS_CONTROL_BY_HW | FINTEK_RTS_INVERT);
1400         }
1401
1402         pci_write_config_byte(pci_dev, 0x40 + 8 * *index + 7, setting);
1403
1404         if (rs485 != &port->rs485)
1405                 port->rs485 = *rs485;
1406
1407         return 0;
1408 }
1409
1410 static int pci_fintek_setup(struct serial_private *priv,
1411                             const struct pciserial_board *board,
1412                             struct uart_8250_port *port, int idx)
1413 {
1414         struct pci_dev *pdev = priv->dev;
1415         u8 *data;
1416         u8 config_base;
1417         u16 iobase;
1418
1419         config_base = 0x40 + 0x08 * idx;
1420
1421         /* Get the io address from configuration space */
1422         pci_read_config_word(pdev, config_base + 4, &iobase);
1423
1424         pci_dbg(pdev, "idx=%d iobase=0x%x", idx, iobase);
1425
1426         port->port.iotype = UPIO_PORT;
1427         port->port.iobase = iobase;
1428         port->port.rs485_config = pci_fintek_rs485_config;
1429
1430         data = devm_kzalloc(&pdev->dev, sizeof(u8), GFP_KERNEL);
1431         if (!data)
1432                 return -ENOMEM;
1433
1434         /* preserve index in PCI configuration space */
1435         *data = idx;
1436         port->port.private_data = data;
1437
1438         return 0;
1439 }
1440
1441 static int pci_fintek_init(struct pci_dev *dev)
1442 {
1443         unsigned long iobase;
1444         u32 max_port, i;
1445         resource_size_t bar_data[3];
1446         u8 config_base;
1447         struct serial_private *priv = pci_get_drvdata(dev);
1448         struct uart_8250_port *port;
1449
1450         if (!(pci_resource_flags(dev, 5) & IORESOURCE_IO) ||
1451                         !(pci_resource_flags(dev, 4) & IORESOURCE_IO) ||
1452                         !(pci_resource_flags(dev, 3) & IORESOURCE_IO))
1453                 return -ENODEV;
1454
1455         switch (dev->device) {
1456         case 0x1104: /* 4 ports */
1457         case 0x1108: /* 8 ports */
1458                 max_port = dev->device & 0xff;
1459                 break;
1460         case 0x1112: /* 12 ports */
1461                 max_port = 12;
1462                 break;
1463         default:
1464                 return -EINVAL;
1465         }
1466
1467         /* Get the io address dispatch from the BIOS */
1468         bar_data[0] = pci_resource_start(dev, 5);
1469         bar_data[1] = pci_resource_start(dev, 4);
1470         bar_data[2] = pci_resource_start(dev, 3);
1471
1472         for (i = 0; i < max_port; ++i) {
1473                 /* UART0 configuration offset start from 0x40 */
1474                 config_base = 0x40 + 0x08 * i;
1475
1476                 /* Calculate Real IO Port */
1477                 iobase = (bar_data[i / 4] & 0xffffffe0) + (i % 4) * 8;
1478
1479                 /* Enable UART I/O port */
1480                 pci_write_config_byte(dev, config_base + 0x00, 0x01);
1481
1482                 /* Select 128-byte FIFO and 8x FIFO threshold */
1483                 pci_write_config_byte(dev, config_base + 0x01, 0x33);
1484
1485                 /* LSB UART */
1486                 pci_write_config_byte(dev, config_base + 0x04,
1487                                 (u8)(iobase & 0xff));
1488
1489                 /* MSB UART */
1490                 pci_write_config_byte(dev, config_base + 0x05,
1491                                 (u8)((iobase & 0xff00) >> 8));
1492
1493                 pci_write_config_byte(dev, config_base + 0x06, dev->irq);
1494
1495                 if (priv) {
1496                         /* re-apply RS232/485 mode when
1497                          * pciserial_resume_ports()
1498                          */
1499                         port = serial8250_get_port(priv->line[i]);
1500                         pci_fintek_rs485_config(&port->port, NULL);
1501                 } else {
1502                         /* First init without port data
1503                          * force init to RS232 Mode
1504                          */
1505                         pci_write_config_byte(dev, config_base + 0x07, 0x01);
1506                 }
1507         }
1508
1509         return max_port;
1510 }
1511
1512 static void f815xxa_mem_serial_out(struct uart_port *p, int offset, int value)
1513 {
1514         struct f815xxa_data *data = p->private_data;
1515         unsigned long flags;
1516
1517         spin_lock_irqsave(&data->lock, flags);
1518         writeb(value, p->membase + offset);
1519         readb(p->membase + UART_SCR); /* Dummy read for flush pcie tx queue */
1520         spin_unlock_irqrestore(&data->lock, flags);
1521 }
1522
1523 static int pci_fintek_f815xxa_setup(struct serial_private *priv,
1524                             const struct pciserial_board *board,
1525                             struct uart_8250_port *port, int idx)
1526 {
1527         struct pci_dev *pdev = priv->dev;
1528         struct f815xxa_data *data;
1529
1530         data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
1531         if (!data)
1532                 return -ENOMEM;
1533
1534         data->idx = idx;
1535         spin_lock_init(&data->lock);
1536
1537         port->port.private_data = data;
1538         port->port.iotype = UPIO_MEM;
1539         port->port.flags |= UPF_IOREMAP;
1540         port->port.mapbase = pci_resource_start(pdev, 0) + 8 * idx;
1541         port->port.serial_out = f815xxa_mem_serial_out;
1542
1543         return 0;
1544 }
1545
1546 static int pci_fintek_f815xxa_init(struct pci_dev *dev)
1547 {
1548         u32 max_port, i;
1549         int config_base;
1550
1551         if (!(pci_resource_flags(dev, 0) & IORESOURCE_MEM))
1552                 return -ENODEV;
1553
1554         switch (dev->device) {
1555         case 0x1204: /* 4 ports */
1556         case 0x1208: /* 8 ports */
1557                 max_port = dev->device & 0xff;
1558                 break;
1559         case 0x1212: /* 12 ports */
1560                 max_port = 12;
1561                 break;
1562         default:
1563                 return -EINVAL;
1564         }
1565
1566         /* Set to mmio decode */
1567         pci_write_config_byte(dev, 0x209, 0x40);
1568
1569         for (i = 0; i < max_port; ++i) {
1570                 /* UART0 configuration offset start from 0x2A0 */
1571                 config_base = 0x2A0 + 0x08 * i;
1572
1573                 /* Select 128-byte FIFO and 8x FIFO threshold */
1574                 pci_write_config_byte(dev, config_base + 0x01, 0x33);
1575
1576                 /* Enable UART I/O port */
1577                 pci_write_config_byte(dev, config_base + 0, 0x01);
1578         }
1579
1580         return max_port;
1581 }
1582
1583 static int skip_tx_en_setup(struct serial_private *priv,
1584                         const struct pciserial_board *board,
1585                         struct uart_8250_port *port, int idx)
1586 {
1587         port->port.quirks |= UPQ_NO_TXEN_TEST;
1588         pci_dbg(priv->dev,
1589                 "serial8250: skipping TxEn test for device [%04x:%04x] subsystem [%04x:%04x]\n",
1590                 priv->dev->vendor, priv->dev->device,
1591                 priv->dev->subsystem_vendor, priv->dev->subsystem_device);
1592
1593         return pci_default_setup(priv, board, port, idx);
1594 }
1595
1596 static void kt_handle_break(struct uart_port *p)
1597 {
1598         struct uart_8250_port *up = up_to_u8250p(p);
1599         /*
1600          * On receipt of a BI, serial device in Intel ME (Intel
1601          * management engine) needs to have its fifos cleared for sane
1602          * SOL (Serial Over Lan) output.
1603          */
1604         serial8250_clear_and_reinit_fifos(up);
1605 }
1606
1607 static unsigned int kt_serial_in(struct uart_port *p, int offset)
1608 {
1609         struct uart_8250_port *up = up_to_u8250p(p);
1610         unsigned int val;
1611
1612         /*
1613          * When the Intel ME (management engine) gets reset its serial
1614          * port registers could return 0 momentarily.  Functions like
1615          * serial8250_console_write, read and save the IER, perform
1616          * some operation and then restore it.  In order to avoid
1617          * setting IER register inadvertently to 0, if the value read
1618          * is 0, double check with ier value in uart_8250_port and use
1619          * that instead.  up->ier should be the same value as what is
1620          * currently configured.
1621          */
1622         val = inb(p->iobase + offset);
1623         if (offset == UART_IER) {
1624                 if (val == 0)
1625                         val = up->ier;
1626         }
1627         return val;
1628 }
1629
1630 static int kt_serial_setup(struct serial_private *priv,
1631                            const struct pciserial_board *board,
1632                            struct uart_8250_port *port, int idx)
1633 {
1634         port->port.flags |= UPF_BUG_THRE;
1635         port->port.serial_in = kt_serial_in;
1636         port->port.handle_break = kt_handle_break;
1637         return skip_tx_en_setup(priv, board, port, idx);
1638 }
1639
1640 static int pci_eg20t_init(struct pci_dev *dev)
1641 {
1642 #if defined(CONFIG_SERIAL_PCH_UART) || defined(CONFIG_SERIAL_PCH_UART_MODULE)
1643         return -ENODEV;
1644 #else
1645         return 0;
1646 #endif
1647 }
1648
1649 static int
1650 pci_wch_ch353_setup(struct serial_private *priv,
1651                     const struct pciserial_board *board,
1652                     struct uart_8250_port *port, int idx)
1653 {
1654         port->port.flags |= UPF_FIXED_TYPE;
1655         port->port.type = PORT_16550A;
1656         return pci_default_setup(priv, board, port, idx);
1657 }
1658
1659 static int
1660 pci_wch_ch355_setup(struct serial_private *priv,
1661                 const struct pciserial_board *board,
1662                 struct uart_8250_port *port, int idx)
1663 {
1664         port->port.flags |= UPF_FIXED_TYPE;
1665         port->port.type = PORT_16550A;
1666         return pci_default_setup(priv, board, port, idx);
1667 }
1668
1669 static int
1670 pci_wch_ch38x_setup(struct serial_private *priv,
1671                     const struct pciserial_board *board,
1672                     struct uart_8250_port *port, int idx)
1673 {
1674         port->port.flags |= UPF_FIXED_TYPE;
1675         port->port.type = PORT_16850;
1676         return pci_default_setup(priv, board, port, idx);
1677 }
1678
1679
1680 #define CH384_XINT_ENABLE_REG   0xEB
1681 #define CH384_XINT_ENABLE_BIT   0x02
1682
1683 static int pci_wch_ch38x_init(struct pci_dev *dev)
1684 {
1685         int max_port;
1686         unsigned long iobase;
1687
1688
1689         switch (dev->device) {
1690         case 0x3853: /* 8 ports */
1691                 max_port = 8;
1692                 break;
1693         default:
1694                 return -EINVAL;
1695         }
1696
1697         iobase = pci_resource_start(dev, 0);
1698         outb(CH384_XINT_ENABLE_BIT, iobase + CH384_XINT_ENABLE_REG);
1699
1700         return max_port;
1701 }
1702
1703 static void pci_wch_ch38x_exit(struct pci_dev *dev)
1704 {
1705         unsigned long iobase;
1706
1707         iobase = pci_resource_start(dev, 0);
1708         outb(0x0, iobase + CH384_XINT_ENABLE_REG);
1709 }
1710
1711
1712 static int
1713 pci_sunix_setup(struct serial_private *priv,
1714                 const struct pciserial_board *board,
1715                 struct uart_8250_port *port, int idx)
1716 {
1717         int bar;
1718         int offset;
1719
1720         port->port.flags |= UPF_FIXED_TYPE;
1721         port->port.type = PORT_SUNIX;
1722
1723         if (idx < 4) {
1724                 bar = 0;
1725                 offset = idx * board->uart_offset;
1726         } else {
1727                 bar = 1;
1728                 idx -= 4;
1729                 idx = div_s64_rem(idx, 4, &offset);
1730                 offset = idx * 64 + offset * board->uart_offset;
1731         }
1732
1733         return setup_port(priv, port, bar, offset, 0);
1734 }
1735
1736 static int
1737 pci_moxa_setup(struct serial_private *priv,
1738                 const struct pciserial_board *board,
1739                 struct uart_8250_port *port, int idx)
1740 {
1741         unsigned int bar = FL_GET_BASE(board->flags);
1742         int offset;
1743
1744         if (board->num_ports == 4 && idx == 3)
1745                 offset = 7 * board->uart_offset;
1746         else
1747                 offset = idx * board->uart_offset;
1748
1749         return setup_port(priv, port, bar, offset, 0);
1750 }
1751
1752 #define PCI_VENDOR_ID_SBSMODULARIO      0x124B
1753 #define PCI_SUBVENDOR_ID_SBSMODULARIO   0x124B
1754 #define PCI_DEVICE_ID_OCTPRO            0x0001
1755 #define PCI_SUBDEVICE_ID_OCTPRO232      0x0108
1756 #define PCI_SUBDEVICE_ID_OCTPRO422      0x0208
1757 #define PCI_SUBDEVICE_ID_POCTAL232      0x0308
1758 #define PCI_SUBDEVICE_ID_POCTAL422      0x0408
1759 #define PCI_SUBDEVICE_ID_SIIG_DUAL_00   0x2500
1760 #define PCI_SUBDEVICE_ID_SIIG_DUAL_30   0x2530
1761 #define PCI_VENDOR_ID_ADVANTECH         0x13fe
1762 #define PCI_DEVICE_ID_INTEL_CE4100_UART 0x2e66
1763 #define PCI_DEVICE_ID_ADVANTECH_PCI3620 0x3620
1764 #define PCI_DEVICE_ID_ADVANTECH_PCI3618 0x3618
1765 #define PCI_DEVICE_ID_ADVANTECH_PCIf618 0xf618
1766 #define PCI_DEVICE_ID_TITAN_200I        0x8028
1767 #define PCI_DEVICE_ID_TITAN_400I        0x8048
1768 #define PCI_DEVICE_ID_TITAN_800I        0x8088
1769 #define PCI_DEVICE_ID_TITAN_800EH       0xA007
1770 #define PCI_DEVICE_ID_TITAN_800EHB      0xA008
1771 #define PCI_DEVICE_ID_TITAN_400EH       0xA009
1772 #define PCI_DEVICE_ID_TITAN_100E        0xA010
1773 #define PCI_DEVICE_ID_TITAN_200E        0xA012
1774 #define PCI_DEVICE_ID_TITAN_400E        0xA013
1775 #define PCI_DEVICE_ID_TITAN_800E        0xA014
1776 #define PCI_DEVICE_ID_TITAN_200EI       0xA016
1777 #define PCI_DEVICE_ID_TITAN_200EISI     0xA017
1778 #define PCI_DEVICE_ID_TITAN_200V3       0xA306
1779 #define PCI_DEVICE_ID_TITAN_400V3       0xA310
1780 #define PCI_DEVICE_ID_TITAN_410V3       0xA312
1781 #define PCI_DEVICE_ID_TITAN_800V3       0xA314
1782 #define PCI_DEVICE_ID_TITAN_800V3B      0xA315
1783 #define PCI_DEVICE_ID_OXSEMI_16PCI958   0x9538
1784 #define PCIE_DEVICE_ID_NEO_2_OX_IBM     0x00F6
1785 #define PCI_DEVICE_ID_PLX_CRONYX_OMEGA  0xc001
1786 #define PCI_DEVICE_ID_INTEL_PATSBURG_KT 0x1d3d
1787 #define PCI_VENDOR_ID_WCH               0x4348
1788 #define PCI_DEVICE_ID_WCH_CH352_2S      0x3253
1789 #define PCI_DEVICE_ID_WCH_CH353_4S      0x3453
1790 #define PCI_DEVICE_ID_WCH_CH353_2S1PF   0x5046
1791 #define PCI_DEVICE_ID_WCH_CH353_1S1P    0x5053
1792 #define PCI_DEVICE_ID_WCH_CH353_2S1P    0x7053
1793 #define PCI_DEVICE_ID_WCH_CH355_4S      0x7173
1794 #define PCI_VENDOR_ID_AGESTAR           0x5372
1795 #define PCI_DEVICE_ID_AGESTAR_9375      0x6872
1796 #define PCI_VENDOR_ID_ASIX              0x9710
1797 #define PCI_DEVICE_ID_BROADCOM_TRUMANAGE 0x160a
1798 #define PCI_DEVICE_ID_AMCC_ADDIDATA_APCI7800 0x818e
1799
1800 #define PCIE_VENDOR_ID_WCH              0x1c00
1801 #define PCIE_DEVICE_ID_WCH_CH382_2S1P   0x3250
1802 #define PCIE_DEVICE_ID_WCH_CH384_4S     0x3470
1803 #define PCIE_DEVICE_ID_WCH_CH384_8S     0x3853
1804 #define PCIE_DEVICE_ID_WCH_CH382_2S     0x3253
1805
1806 #define PCI_DEVICE_ID_MOXA_CP102E       0x1024
1807 #define PCI_DEVICE_ID_MOXA_CP102EL      0x1025
1808 #define PCI_DEVICE_ID_MOXA_CP104EL_A    0x1045
1809 #define PCI_DEVICE_ID_MOXA_CP114EL      0x1144
1810 #define PCI_DEVICE_ID_MOXA_CP116E_A_A   0x1160
1811 #define PCI_DEVICE_ID_MOXA_CP116E_A_B   0x1161
1812 #define PCI_DEVICE_ID_MOXA_CP118EL_A    0x1182
1813 #define PCI_DEVICE_ID_MOXA_CP118E_A_I   0x1183
1814 #define PCI_DEVICE_ID_MOXA_CP132EL      0x1322
1815 #define PCI_DEVICE_ID_MOXA_CP134EL_A    0x1342
1816 #define PCI_DEVICE_ID_MOXA_CP138E_A     0x1381
1817 #define PCI_DEVICE_ID_MOXA_CP168EL_A    0x1683
1818
1819 /* Unknown vendors/cards - this should not be in linux/pci_ids.h */
1820 #define PCI_SUBDEVICE_ID_UNKNOWN_0x1584 0x1584
1821 #define PCI_SUBDEVICE_ID_UNKNOWN_0x1588 0x1588
1822
1823 /*
1824  * Master list of serial port init/setup/exit quirks.
1825  * This does not describe the general nature of the port.
1826  * (ie, baud base, number and location of ports, etc)
1827  *
1828  * This list is ordered alphabetically by vendor then device.
1829  * Specific entries must come before more generic entries.
1830  */
1831 static struct pci_serial_quirk pci_serial_quirks[] = {
1832         /*
1833         * ADDI-DATA GmbH communication cards <info@addi-data.com>
1834         */
1835         {
1836                 .vendor         = PCI_VENDOR_ID_AMCC,
1837                 .device         = PCI_DEVICE_ID_AMCC_ADDIDATA_APCI7800,
1838                 .subvendor      = PCI_ANY_ID,
1839                 .subdevice      = PCI_ANY_ID,
1840                 .setup          = addidata_apci7800_setup,
1841         },
1842         /*
1843          * AFAVLAB cards - these may be called via parport_serial
1844          *  It is not clear whether this applies to all products.
1845          */
1846         {
1847                 .vendor         = PCI_VENDOR_ID_AFAVLAB,
1848                 .device         = PCI_ANY_ID,
1849                 .subvendor      = PCI_ANY_ID,
1850                 .subdevice      = PCI_ANY_ID,
1851                 .setup          = afavlab_setup,
1852         },
1853         /*
1854          * HP Diva
1855          */
1856         {
1857                 .vendor         = PCI_VENDOR_ID_HP,
1858                 .device         = PCI_DEVICE_ID_HP_DIVA,
1859                 .subvendor      = PCI_ANY_ID,
1860                 .subdevice      = PCI_ANY_ID,
1861                 .init           = pci_hp_diva_init,
1862                 .setup          = pci_hp_diva_setup,
1863         },
1864         /*
1865          * HPE PCI serial device
1866          */
1867         {
1868                 .vendor         = PCI_VENDOR_ID_HP_3PAR,
1869                 .device         = PCI_DEVICE_ID_HPE_PCI_SERIAL,
1870                 .subvendor      = PCI_ANY_ID,
1871                 .subdevice      = PCI_ANY_ID,
1872                 .setup          = pci_hp_diva_setup,
1873         },
1874         /*
1875          * Intel
1876          */
1877         {
1878                 .vendor         = PCI_VENDOR_ID_INTEL,
1879                 .device         = PCI_DEVICE_ID_INTEL_80960_RP,
1880                 .subvendor      = 0xe4bf,
1881                 .subdevice      = PCI_ANY_ID,
1882                 .init           = pci_inteli960ni_init,
1883                 .setup          = pci_default_setup,
1884         },
1885         {
1886                 .vendor         = PCI_VENDOR_ID_INTEL,
1887                 .device         = PCI_DEVICE_ID_INTEL_8257X_SOL,
1888                 .subvendor      = PCI_ANY_ID,
1889                 .subdevice      = PCI_ANY_ID,
1890                 .setup          = skip_tx_en_setup,
1891         },
1892         {
1893                 .vendor         = PCI_VENDOR_ID_INTEL,
1894                 .device         = PCI_DEVICE_ID_INTEL_82573L_SOL,
1895                 .subvendor      = PCI_ANY_ID,
1896                 .subdevice      = PCI_ANY_ID,
1897                 .setup          = skip_tx_en_setup,
1898         },
1899         {
1900                 .vendor         = PCI_VENDOR_ID_INTEL,
1901                 .device         = PCI_DEVICE_ID_INTEL_82573E_SOL,
1902                 .subvendor      = PCI_ANY_ID,
1903                 .subdevice      = PCI_ANY_ID,
1904                 .setup          = skip_tx_en_setup,
1905         },
1906         {
1907                 .vendor         = PCI_VENDOR_ID_INTEL,
1908                 .device         = PCI_DEVICE_ID_INTEL_CE4100_UART,
1909                 .subvendor      = PCI_ANY_ID,
1910                 .subdevice      = PCI_ANY_ID,
1911                 .setup          = ce4100_serial_setup,
1912         },
1913         {
1914                 .vendor         = PCI_VENDOR_ID_INTEL,
1915                 .device         = PCI_DEVICE_ID_INTEL_PATSBURG_KT,
1916                 .subvendor      = PCI_ANY_ID,
1917                 .subdevice      = PCI_ANY_ID,
1918                 .setup          = kt_serial_setup,
1919         },
1920         /*
1921          * ITE
1922          */
1923         {
1924                 .vendor         = PCI_VENDOR_ID_ITE,
1925                 .device         = PCI_DEVICE_ID_ITE_8872,
1926                 .subvendor      = PCI_ANY_ID,
1927                 .subdevice      = PCI_ANY_ID,
1928                 .init           = pci_ite887x_init,
1929                 .setup          = pci_default_setup,
1930                 .exit           = pci_ite887x_exit,
1931         },
1932         /*
1933          * National Instruments
1934          */
1935         {
1936                 .vendor         = PCI_VENDOR_ID_NI,
1937                 .device         = PCI_DEVICE_ID_NI_PCI23216,
1938                 .subvendor      = PCI_ANY_ID,
1939                 .subdevice      = PCI_ANY_ID,
1940                 .init           = pci_ni8420_init,
1941                 .setup          = pci_default_setup,
1942                 .exit           = pci_ni8420_exit,
1943         },
1944         {
1945                 .vendor         = PCI_VENDOR_ID_NI,
1946                 .device         = PCI_DEVICE_ID_NI_PCI2328,
1947                 .subvendor      = PCI_ANY_ID,
1948                 .subdevice      = PCI_ANY_ID,
1949                 .init           = pci_ni8420_init,
1950                 .setup          = pci_default_setup,
1951                 .exit           = pci_ni8420_exit,
1952         },
1953         {
1954                 .vendor         = PCI_VENDOR_ID_NI,
1955                 .device         = PCI_DEVICE_ID_NI_PCI2324,
1956                 .subvendor      = PCI_ANY_ID,
1957                 .subdevice      = PCI_ANY_ID,
1958                 .init           = pci_ni8420_init,
1959                 .setup          = pci_default_setup,
1960                 .exit           = pci_ni8420_exit,
1961         },
1962         {
1963                 .vendor         = PCI_VENDOR_ID_NI,
1964                 .device         = PCI_DEVICE_ID_NI_PCI2322,
1965                 .subvendor      = PCI_ANY_ID,
1966                 .subdevice      = PCI_ANY_ID,
1967                 .init           = pci_ni8420_init,
1968                 .setup          = pci_default_setup,
1969                 .exit           = pci_ni8420_exit,
1970         },
1971         {
1972                 .vendor         = PCI_VENDOR_ID_NI,
1973                 .device         = PCI_DEVICE_ID_NI_PCI2324I,
1974                 .subvendor      = PCI_ANY_ID,
1975                 .subdevice      = PCI_ANY_ID,
1976                 .init           = pci_ni8420_init,
1977                 .setup          = pci_default_setup,
1978                 .exit           = pci_ni8420_exit,
1979         },
1980         {
1981                 .vendor         = PCI_VENDOR_ID_NI,
1982                 .device         = PCI_DEVICE_ID_NI_PCI2322I,
1983                 .subvendor      = PCI_ANY_ID,
1984                 .subdevice      = PCI_ANY_ID,
1985                 .init           = pci_ni8420_init,
1986                 .setup          = pci_default_setup,
1987                 .exit           = pci_ni8420_exit,
1988         },
1989         {
1990                 .vendor         = PCI_VENDOR_ID_NI,
1991                 .device         = PCI_DEVICE_ID_NI_PXI8420_23216,
1992                 .subvendor      = PCI_ANY_ID,
1993                 .subdevice      = PCI_ANY_ID,
1994                 .init           = pci_ni8420_init,
1995                 .setup          = pci_default_setup,
1996                 .exit           = pci_ni8420_exit,
1997         },
1998         {
1999                 .vendor         = PCI_VENDOR_ID_NI,
2000                 .device         = PCI_DEVICE_ID_NI_PXI8420_2328,
2001                 .subvendor      = PCI_ANY_ID,
2002                 .subdevice      = PCI_ANY_ID,
2003                 .init           = pci_ni8420_init,
2004                 .setup          = pci_default_setup,
2005                 .exit           = pci_ni8420_exit,
2006         },
2007         {
2008                 .vendor         = PCI_VENDOR_ID_NI,
2009                 .device         = PCI_DEVICE_ID_NI_PXI8420_2324,
2010                 .subvendor      = PCI_ANY_ID,
2011                 .subdevice      = PCI_ANY_ID,
2012                 .init           = pci_ni8420_init,
2013                 .setup          = pci_default_setup,
2014                 .exit           = pci_ni8420_exit,
2015         },
2016         {
2017                 .vendor         = PCI_VENDOR_ID_NI,
2018                 .device         = PCI_DEVICE_ID_NI_PXI8420_2322,
2019                 .subvendor      = PCI_ANY_ID,
2020                 .subdevice      = PCI_ANY_ID,
2021                 .init           = pci_ni8420_init,
2022                 .setup          = pci_default_setup,
2023                 .exit           = pci_ni8420_exit,
2024         },
2025         {
2026                 .vendor         = PCI_VENDOR_ID_NI,
2027                 .device         = PCI_DEVICE_ID_NI_PXI8422_2324,
2028                 .subvendor      = PCI_ANY_ID,
2029                 .subdevice      = PCI_ANY_ID,
2030                 .init           = pci_ni8420_init,
2031                 .setup          = pci_default_setup,
2032                 .exit           = pci_ni8420_exit,
2033         },
2034         {
2035                 .vendor         = PCI_VENDOR_ID_NI,
2036                 .device         = PCI_DEVICE_ID_NI_PXI8422_2322,
2037                 .subvendor      = PCI_ANY_ID,
2038                 .subdevice      = PCI_ANY_ID,
2039                 .init           = pci_ni8420_init,
2040                 .setup          = pci_default_setup,
2041                 .exit           = pci_ni8420_exit,
2042         },
2043         {
2044                 .vendor         = PCI_VENDOR_ID_NI,
2045                 .device         = PCI_ANY_ID,
2046                 .subvendor      = PCI_ANY_ID,
2047                 .subdevice      = PCI_ANY_ID,
2048                 .init           = pci_ni8430_init,
2049                 .setup          = pci_ni8430_setup,
2050                 .exit           = pci_ni8430_exit,
2051         },
2052         /* Quatech */
2053         {
2054                 .vendor         = PCI_VENDOR_ID_QUATECH,
2055                 .device         = PCI_ANY_ID,
2056                 .subvendor      = PCI_ANY_ID,
2057                 .subdevice      = PCI_ANY_ID,
2058                 .init           = pci_quatech_init,
2059                 .setup          = pci_quatech_setup,
2060         },
2061         /*
2062          * Panacom
2063          */
2064         {
2065                 .vendor         = PCI_VENDOR_ID_PANACOM,
2066                 .device         = PCI_DEVICE_ID_PANACOM_QUADMODEM,
2067                 .subvendor      = PCI_ANY_ID,
2068                 .subdevice      = PCI_ANY_ID,
2069                 .init           = pci_plx9050_init,
2070                 .setup          = pci_default_setup,
2071                 .exit           = pci_plx9050_exit,
2072         },
2073         {
2074                 .vendor         = PCI_VENDOR_ID_PANACOM,
2075                 .device         = PCI_DEVICE_ID_PANACOM_DUALMODEM,
2076                 .subvendor      = PCI_ANY_ID,
2077                 .subdevice      = PCI_ANY_ID,
2078                 .init           = pci_plx9050_init,
2079                 .setup          = pci_default_setup,
2080                 .exit           = pci_plx9050_exit,
2081         },
2082         /*
2083          * PLX
2084          */
2085         {
2086                 .vendor         = PCI_VENDOR_ID_PLX,
2087                 .device         = PCI_DEVICE_ID_PLX_9050,
2088                 .subvendor      = PCI_SUBVENDOR_ID_EXSYS,
2089                 .subdevice      = PCI_SUBDEVICE_ID_EXSYS_4055,
2090                 .init           = pci_plx9050_init,
2091                 .setup          = pci_default_setup,
2092                 .exit           = pci_plx9050_exit,
2093         },
2094         {
2095                 .vendor         = PCI_VENDOR_ID_PLX,
2096                 .device         = PCI_DEVICE_ID_PLX_9050,
2097                 .subvendor      = PCI_SUBVENDOR_ID_KEYSPAN,
2098                 .subdevice      = PCI_SUBDEVICE_ID_KEYSPAN_SX2,
2099                 .init           = pci_plx9050_init,
2100                 .setup          = pci_default_setup,
2101                 .exit           = pci_plx9050_exit,
2102         },
2103         {
2104                 .vendor         = PCI_VENDOR_ID_PLX,
2105                 .device         = PCI_DEVICE_ID_PLX_ROMULUS,
2106                 .subvendor      = PCI_VENDOR_ID_PLX,
2107                 .subdevice      = PCI_DEVICE_ID_PLX_ROMULUS,
2108                 .init           = pci_plx9050_init,
2109                 .setup          = pci_default_setup,
2110                 .exit           = pci_plx9050_exit,
2111         },
2112         /*
2113          * SBS Technologies, Inc., PMC-OCTALPRO 232
2114          */
2115         {
2116                 .vendor         = PCI_VENDOR_ID_SBSMODULARIO,
2117                 .device         = PCI_DEVICE_ID_OCTPRO,
2118                 .subvendor      = PCI_SUBVENDOR_ID_SBSMODULARIO,
2119                 .subdevice      = PCI_SUBDEVICE_ID_OCTPRO232,
2120                 .init           = sbs_init,
2121                 .setup          = sbs_setup,
2122                 .exit           = sbs_exit,
2123         },
2124         /*
2125          * SBS Technologies, Inc., PMC-OCTALPRO 422
2126          */
2127         {
2128                 .vendor         = PCI_VENDOR_ID_SBSMODULARIO,
2129                 .device         = PCI_DEVICE_ID_OCTPRO,
2130                 .subvendor      = PCI_SUBVENDOR_ID_SBSMODULARIO,
2131                 .subdevice      = PCI_SUBDEVICE_ID_OCTPRO422,
2132                 .init           = sbs_init,
2133                 .setup          = sbs_setup,
2134                 .exit           = sbs_exit,
2135         },
2136         /*
2137          * SBS Technologies, Inc., P-Octal 232
2138          */
2139         {
2140                 .vendor         = PCI_VENDOR_ID_SBSMODULARIO,
2141                 .device         = PCI_DEVICE_ID_OCTPRO,
2142                 .subvendor      = PCI_SUBVENDOR_ID_SBSMODULARIO,
2143                 .subdevice      = PCI_SUBDEVICE_ID_POCTAL232,
2144                 .init           = sbs_init,
2145                 .setup          = sbs_setup,
2146                 .exit           = sbs_exit,
2147         },
2148         /*
2149          * SBS Technologies, Inc., P-Octal 422
2150          */
2151         {
2152                 .vendor         = PCI_VENDOR_ID_SBSMODULARIO,
2153                 .device         = PCI_DEVICE_ID_OCTPRO,
2154                 .subvendor      = PCI_SUBVENDOR_ID_SBSMODULARIO,
2155                 .subdevice      = PCI_SUBDEVICE_ID_POCTAL422,
2156                 .init           = sbs_init,
2157                 .setup          = sbs_setup,
2158                 .exit           = sbs_exit,
2159         },
2160         /*
2161          * SIIG cards - these may be called via parport_serial
2162          */
2163         {
2164                 .vendor         = PCI_VENDOR_ID_SIIG,
2165                 .device         = PCI_ANY_ID,
2166                 .subvendor      = PCI_ANY_ID,
2167                 .subdevice      = PCI_ANY_ID,
2168                 .init           = pci_siig_init,
2169                 .setup          = pci_siig_setup,
2170         },
2171         /*
2172          * Titan cards
2173          */
2174         {
2175                 .vendor         = PCI_VENDOR_ID_TITAN,
2176                 .device         = PCI_DEVICE_ID_TITAN_400L,
2177                 .subvendor      = PCI_ANY_ID,
2178                 .subdevice      = PCI_ANY_ID,
2179                 .setup          = titan_400l_800l_setup,
2180         },
2181         {
2182                 .vendor         = PCI_VENDOR_ID_TITAN,
2183                 .device         = PCI_DEVICE_ID_TITAN_800L,
2184                 .subvendor      = PCI_ANY_ID,
2185                 .subdevice      = PCI_ANY_ID,
2186                 .setup          = titan_400l_800l_setup,
2187         },
2188         /*
2189          * Timedia cards
2190          */
2191         {
2192                 .vendor         = PCI_VENDOR_ID_TIMEDIA,
2193                 .device         = PCI_DEVICE_ID_TIMEDIA_1889,
2194                 .subvendor      = PCI_VENDOR_ID_TIMEDIA,
2195                 .subdevice      = PCI_ANY_ID,
2196                 .probe          = pci_timedia_probe,
2197                 .init           = pci_timedia_init,
2198                 .setup          = pci_timedia_setup,
2199         },
2200         {
2201                 .vendor         = PCI_VENDOR_ID_TIMEDIA,
2202                 .device         = PCI_ANY_ID,
2203                 .subvendor      = PCI_ANY_ID,
2204                 .subdevice      = PCI_ANY_ID,
2205                 .setup          = pci_timedia_setup,
2206         },
2207         /*
2208          * Sunix PCI serial boards
2209          */
2210         {
2211                 .vendor         = PCI_VENDOR_ID_SUNIX,
2212                 .device         = PCI_DEVICE_ID_SUNIX_1999,
2213                 .subvendor      = PCI_VENDOR_ID_SUNIX,
2214                 .subdevice      = PCI_ANY_ID,
2215                 .setup          = pci_sunix_setup,
2216         },
2217         /*
2218          * Xircom cards
2219          */
2220         {
2221                 .vendor         = PCI_VENDOR_ID_XIRCOM,
2222                 .device         = PCI_DEVICE_ID_XIRCOM_X3201_MDM,
2223                 .subvendor      = PCI_ANY_ID,
2224                 .subdevice      = PCI_ANY_ID,
2225                 .init           = pci_xircom_init,
2226                 .setup          = pci_default_setup,
2227         },
2228         /*
2229          * Netmos cards - these may be called via parport_serial
2230          */
2231         {
2232                 .vendor         = PCI_VENDOR_ID_NETMOS,
2233                 .device         = PCI_ANY_ID,
2234                 .subvendor      = PCI_ANY_ID,
2235                 .subdevice      = PCI_ANY_ID,
2236                 .init           = pci_netmos_init,
2237                 .setup          = pci_netmos_9900_setup,
2238         },
2239         /*
2240          * EndRun Technologies
2241         */
2242         {
2243                 .vendor         = PCI_VENDOR_ID_ENDRUN,
2244                 .device         = PCI_ANY_ID,
2245                 .subvendor      = PCI_ANY_ID,
2246                 .subdevice      = PCI_ANY_ID,
2247                 .init           = pci_endrun_init,
2248                 .setup          = pci_default_setup,
2249         },
2250         /*
2251          * For Oxford Semiconductor Tornado based devices
2252          */
2253         {
2254                 .vendor         = PCI_VENDOR_ID_OXSEMI,
2255                 .device         = PCI_ANY_ID,
2256                 .subvendor      = PCI_ANY_ID,
2257                 .subdevice      = PCI_ANY_ID,
2258                 .init           = pci_oxsemi_tornado_init,
2259                 .setup          = pci_default_setup,
2260         },
2261         {
2262                 .vendor         = PCI_VENDOR_ID_MAINPINE,
2263                 .device         = PCI_ANY_ID,
2264                 .subvendor      = PCI_ANY_ID,
2265                 .subdevice      = PCI_ANY_ID,
2266                 .init           = pci_oxsemi_tornado_init,
2267                 .setup          = pci_default_setup,
2268         },
2269         {
2270                 .vendor         = PCI_VENDOR_ID_DIGI,
2271                 .device         = PCIE_DEVICE_ID_NEO_2_OX_IBM,
2272                 .subvendor              = PCI_SUBVENDOR_ID_IBM,
2273                 .subdevice              = PCI_ANY_ID,
2274                 .init                   = pci_oxsemi_tornado_init,
2275                 .setup          = pci_default_setup,
2276         },
2277         {
2278                 .vendor         = PCI_VENDOR_ID_INTEL,
2279                 .device         = 0x8811,
2280                 .subvendor      = PCI_ANY_ID,
2281                 .subdevice      = PCI_ANY_ID,
2282                 .init           = pci_eg20t_init,
2283                 .setup          = pci_default_setup,
2284         },
2285         {
2286                 .vendor         = PCI_VENDOR_ID_INTEL,
2287                 .device         = 0x8812,
2288                 .subvendor      = PCI_ANY_ID,
2289                 .subdevice      = PCI_ANY_ID,
2290                 .init           = pci_eg20t_init,
2291                 .setup          = pci_default_setup,
2292         },
2293         {
2294                 .vendor         = PCI_VENDOR_ID_INTEL,
2295                 .device         = 0x8813,
2296                 .subvendor      = PCI_ANY_ID,
2297                 .subdevice      = PCI_ANY_ID,
2298                 .init           = pci_eg20t_init,
2299                 .setup          = pci_default_setup,
2300         },
2301         {
2302                 .vendor         = PCI_VENDOR_ID_INTEL,
2303                 .device         = 0x8814,
2304                 .subvendor      = PCI_ANY_ID,
2305                 .subdevice      = PCI_ANY_ID,
2306                 .init           = pci_eg20t_init,
2307                 .setup          = pci_default_setup,
2308         },
2309         {
2310                 .vendor         = 0x10DB,
2311                 .device         = 0x8027,
2312                 .subvendor      = PCI_ANY_ID,
2313                 .subdevice      = PCI_ANY_ID,
2314                 .init           = pci_eg20t_init,
2315                 .setup          = pci_default_setup,
2316         },
2317         {
2318                 .vendor         = 0x10DB,
2319                 .device         = 0x8028,
2320                 .subvendor      = PCI_ANY_ID,
2321                 .subdevice      = PCI_ANY_ID,
2322                 .init           = pci_eg20t_init,
2323                 .setup          = pci_default_setup,
2324         },
2325         {
2326                 .vendor         = 0x10DB,
2327                 .device         = 0x8029,
2328                 .subvendor      = PCI_ANY_ID,
2329                 .subdevice      = PCI_ANY_ID,
2330                 .init           = pci_eg20t_init,
2331                 .setup          = pci_default_setup,
2332         },
2333         {
2334                 .vendor         = 0x10DB,
2335                 .device         = 0x800C,
2336                 .subvendor      = PCI_ANY_ID,
2337                 .subdevice      = PCI_ANY_ID,
2338                 .init           = pci_eg20t_init,
2339                 .setup          = pci_default_setup,
2340         },
2341         {
2342                 .vendor         = 0x10DB,
2343                 .device         = 0x800D,
2344                 .subvendor      = PCI_ANY_ID,
2345                 .subdevice      = PCI_ANY_ID,
2346                 .init           = pci_eg20t_init,
2347                 .setup          = pci_default_setup,
2348         },
2349         /*
2350          * Cronyx Omega PCI (PLX-chip based)
2351          */
2352         {
2353                 .vendor         = PCI_VENDOR_ID_PLX,
2354                 .device         = PCI_DEVICE_ID_PLX_CRONYX_OMEGA,
2355                 .subvendor      = PCI_ANY_ID,
2356                 .subdevice      = PCI_ANY_ID,
2357                 .setup          = pci_omegapci_setup,
2358         },
2359         /* WCH CH353 1S1P card (16550 clone) */
2360         {
2361                 .vendor         = PCI_VENDOR_ID_WCH,
2362                 .device         = PCI_DEVICE_ID_WCH_CH353_1S1P,
2363                 .subvendor      = PCI_ANY_ID,
2364                 .subdevice      = PCI_ANY_ID,
2365                 .setup          = pci_wch_ch353_setup,
2366         },
2367         /* WCH CH353 2S1P card (16550 clone) */
2368         {
2369                 .vendor         = PCI_VENDOR_ID_WCH,
2370                 .device         = PCI_DEVICE_ID_WCH_CH353_2S1P,
2371                 .subvendor      = PCI_ANY_ID,
2372                 .subdevice      = PCI_ANY_ID,
2373                 .setup          = pci_wch_ch353_setup,
2374         },
2375         /* WCH CH353 4S card (16550 clone) */
2376         {
2377                 .vendor         = PCI_VENDOR_ID_WCH,
2378                 .device         = PCI_DEVICE_ID_WCH_CH353_4S,
2379                 .subvendor      = PCI_ANY_ID,
2380                 .subdevice      = PCI_ANY_ID,
2381                 .setup          = pci_wch_ch353_setup,
2382         },
2383         /* WCH CH353 2S1PF card (16550 clone) */
2384         {
2385                 .vendor         = PCI_VENDOR_ID_WCH,
2386                 .device         = PCI_DEVICE_ID_WCH_CH353_2S1PF,
2387                 .subvendor      = PCI_ANY_ID,
2388                 .subdevice      = PCI_ANY_ID,
2389                 .setup          = pci_wch_ch353_setup,
2390         },
2391         /* WCH CH352 2S card (16550 clone) */
2392         {
2393                 .vendor         = PCI_VENDOR_ID_WCH,
2394                 .device         = PCI_DEVICE_ID_WCH_CH352_2S,
2395                 .subvendor      = PCI_ANY_ID,
2396                 .subdevice      = PCI_ANY_ID,
2397                 .setup          = pci_wch_ch353_setup,
2398         },
2399         /* WCH CH355 4S card (16550 clone) */
2400         {
2401                 .vendor         = PCI_VENDOR_ID_WCH,
2402                 .device         = PCI_DEVICE_ID_WCH_CH355_4S,
2403                 .subvendor      = PCI_ANY_ID,
2404                 .subdevice      = PCI_ANY_ID,
2405                 .setup          = pci_wch_ch355_setup,
2406         },
2407         /* WCH CH382 2S card (16850 clone) */
2408         {
2409                 .vendor         = PCIE_VENDOR_ID_WCH,
2410                 .device         = PCIE_DEVICE_ID_WCH_CH382_2S,
2411                 .subvendor      = PCI_ANY_ID,
2412                 .subdevice      = PCI_ANY_ID,
2413                 .setup          = pci_wch_ch38x_setup,
2414         },
2415         /* WCH CH382 2S1P card (16850 clone) */
2416         {
2417                 .vendor         = PCIE_VENDOR_ID_WCH,
2418                 .device         = PCIE_DEVICE_ID_WCH_CH382_2S1P,
2419                 .subvendor      = PCI_ANY_ID,
2420                 .subdevice      = PCI_ANY_ID,
2421                 .setup          = pci_wch_ch38x_setup,
2422         },
2423         /* WCH CH384 4S card (16850 clone) */
2424         {
2425                 .vendor         = PCIE_VENDOR_ID_WCH,
2426                 .device         = PCIE_DEVICE_ID_WCH_CH384_4S,
2427                 .subvendor      = PCI_ANY_ID,
2428                 .subdevice      = PCI_ANY_ID,
2429                 .setup          = pci_wch_ch38x_setup,
2430         },
2431         /* WCH CH384 8S card (16850 clone) */
2432         {
2433                 .vendor         = PCIE_VENDOR_ID_WCH,
2434                 .device         = PCIE_DEVICE_ID_WCH_CH384_8S,
2435                 .subvendor      = PCI_ANY_ID,
2436                 .subdevice      = PCI_ANY_ID,
2437                 .init           = pci_wch_ch38x_init,
2438                 .exit           = pci_wch_ch38x_exit,
2439                 .setup          = pci_wch_ch38x_setup,
2440         },
2441         /*
2442          * ASIX devices with FIFO bug
2443          */
2444         {
2445                 .vendor         = PCI_VENDOR_ID_ASIX,
2446                 .device         = PCI_ANY_ID,
2447                 .subvendor      = PCI_ANY_ID,
2448                 .subdevice      = PCI_ANY_ID,
2449                 .setup          = pci_asix_setup,
2450         },
2451         /*
2452          * Broadcom TruManage (NetXtreme)
2453          */
2454         {
2455                 .vendor         = PCI_VENDOR_ID_BROADCOM,
2456                 .device         = PCI_DEVICE_ID_BROADCOM_TRUMANAGE,
2457                 .subvendor      = PCI_ANY_ID,
2458                 .subdevice      = PCI_ANY_ID,
2459                 .setup          = pci_brcm_trumanage_setup,
2460         },
2461         {
2462                 .vendor         = 0x1c29,
2463                 .device         = 0x1104,
2464                 .subvendor      = PCI_ANY_ID,
2465                 .subdevice      = PCI_ANY_ID,
2466                 .setup          = pci_fintek_setup,
2467                 .init           = pci_fintek_init,
2468         },
2469         {
2470                 .vendor         = 0x1c29,
2471                 .device         = 0x1108,
2472                 .subvendor      = PCI_ANY_ID,
2473                 .subdevice      = PCI_ANY_ID,
2474                 .setup          = pci_fintek_setup,
2475                 .init           = pci_fintek_init,
2476         },
2477         {
2478                 .vendor         = 0x1c29,
2479                 .device         = 0x1112,
2480                 .subvendor      = PCI_ANY_ID,
2481                 .subdevice      = PCI_ANY_ID,
2482                 .setup          = pci_fintek_setup,
2483                 .init           = pci_fintek_init,
2484         },
2485         /*
2486          * MOXA
2487          */
2488         {
2489                 .vendor         = PCI_VENDOR_ID_MOXA,
2490                 .device         = PCI_ANY_ID,
2491                 .subvendor      = PCI_ANY_ID,
2492                 .subdevice      = PCI_ANY_ID,
2493                 .setup          = pci_moxa_setup,
2494         },
2495         {
2496                 .vendor         = 0x1c29,
2497                 .device         = 0x1204,
2498                 .subvendor      = PCI_ANY_ID,
2499                 .subdevice      = PCI_ANY_ID,
2500                 .setup          = pci_fintek_f815xxa_setup,
2501                 .init           = pci_fintek_f815xxa_init,
2502         },
2503         {
2504                 .vendor         = 0x1c29,
2505                 .device         = 0x1208,
2506                 .subvendor      = PCI_ANY_ID,
2507                 .subdevice      = PCI_ANY_ID,
2508                 .setup          = pci_fintek_f815xxa_setup,
2509                 .init           = pci_fintek_f815xxa_init,
2510         },
2511         {
2512                 .vendor         = 0x1c29,
2513                 .device         = 0x1212,
2514                 .subvendor      = PCI_ANY_ID,
2515                 .subdevice      = PCI_ANY_ID,
2516                 .setup          = pci_fintek_f815xxa_setup,
2517                 .init           = pci_fintek_f815xxa_init,
2518         },
2519
2520         /*
2521          * Default "match everything" terminator entry
2522          */
2523         {
2524                 .vendor         = PCI_ANY_ID,
2525                 .device         = PCI_ANY_ID,
2526                 .subvendor      = PCI_ANY_ID,
2527                 .subdevice      = PCI_ANY_ID,
2528                 .setup          = pci_default_setup,
2529         }
2530 };
2531
2532 static inline int quirk_id_matches(u32 quirk_id, u32 dev_id)
2533 {
2534         return quirk_id == PCI_ANY_ID || quirk_id == dev_id;
2535 }
2536
2537 static struct pci_serial_quirk *find_quirk(struct pci_dev *dev)
2538 {
2539         struct pci_serial_quirk *quirk;
2540
2541         for (quirk = pci_serial_quirks; ; quirk++)
2542                 if (quirk_id_matches(quirk->vendor, dev->vendor) &&
2543                     quirk_id_matches(quirk->device, dev->device) &&
2544                     quirk_id_matches(quirk->subvendor, dev->subsystem_vendor) &&
2545                     quirk_id_matches(quirk->subdevice, dev->subsystem_device))
2546                         break;
2547         return quirk;
2548 }
2549
2550 /*
2551  * This is the configuration table for all of the PCI serial boards
2552  * which we support.  It is directly indexed by the pci_board_num_t enum
2553  * value, which is encoded in the pci_device_id PCI probe table's
2554  * driver_data member.
2555  *
2556  * The makeup of these names are:
2557  *  pbn_bn{_bt}_n_baud{_offsetinhex}
2558  *
2559  *  bn          = PCI BAR number
2560  *  bt          = Index using PCI BARs
2561  *  n           = number of serial ports
2562  *  baud        = baud rate
2563  *  offsetinhex = offset for each sequential port (in hex)
2564  *
2565  * This table is sorted by (in order): bn, bt, baud, offsetindex, n.
2566  *
2567  * Please note: in theory if n = 1, _bt infix should make no difference.
2568  * ie, pbn_b0_1_115200 is the same as pbn_b0_bt_1_115200
2569  */
2570 enum pci_board_num_t {
2571         pbn_default = 0,
2572
2573         pbn_b0_1_115200,
2574         pbn_b0_2_115200,
2575         pbn_b0_4_115200,
2576         pbn_b0_5_115200,
2577         pbn_b0_8_115200,
2578
2579         pbn_b0_1_921600,
2580         pbn_b0_2_921600,
2581         pbn_b0_4_921600,
2582
2583         pbn_b0_2_1130000,
2584
2585         pbn_b0_4_1152000,
2586
2587         pbn_b0_4_1250000,
2588
2589         pbn_b0_2_1843200,
2590         pbn_b0_4_1843200,
2591
2592         pbn_b0_1_3906250,
2593
2594         pbn_b0_bt_1_115200,
2595         pbn_b0_bt_2_115200,
2596         pbn_b0_bt_4_115200,
2597         pbn_b0_bt_8_115200,
2598
2599         pbn_b0_bt_1_460800,
2600         pbn_b0_bt_2_460800,
2601         pbn_b0_bt_4_460800,
2602
2603         pbn_b0_bt_1_921600,
2604         pbn_b0_bt_2_921600,
2605         pbn_b0_bt_4_921600,
2606         pbn_b0_bt_8_921600,
2607
2608         pbn_b1_1_115200,
2609         pbn_b1_2_115200,
2610         pbn_b1_4_115200,
2611         pbn_b1_8_115200,
2612         pbn_b1_16_115200,
2613
2614         pbn_b1_1_921600,
2615         pbn_b1_2_921600,
2616         pbn_b1_4_921600,
2617         pbn_b1_8_921600,
2618
2619         pbn_b1_2_1250000,
2620
2621         pbn_b1_bt_1_115200,
2622         pbn_b1_bt_2_115200,
2623         pbn_b1_bt_4_115200,
2624
2625         pbn_b1_bt_2_921600,
2626
2627         pbn_b1_1_1382400,
2628         pbn_b1_2_1382400,
2629         pbn_b1_4_1382400,
2630         pbn_b1_8_1382400,
2631
2632         pbn_b2_1_115200,
2633         pbn_b2_2_115200,
2634         pbn_b2_4_115200,
2635         pbn_b2_8_115200,
2636
2637         pbn_b2_1_460800,
2638         pbn_b2_4_460800,
2639         pbn_b2_8_460800,
2640         pbn_b2_16_460800,
2641
2642         pbn_b2_1_921600,
2643         pbn_b2_4_921600,
2644         pbn_b2_8_921600,
2645
2646         pbn_b2_8_1152000,
2647
2648         pbn_b2_bt_1_115200,
2649         pbn_b2_bt_2_115200,
2650         pbn_b2_bt_4_115200,
2651
2652         pbn_b2_bt_2_921600,
2653         pbn_b2_bt_4_921600,
2654
2655         pbn_b3_2_115200,
2656         pbn_b3_4_115200,
2657         pbn_b3_8_115200,
2658
2659         pbn_b4_bt_2_921600,
2660         pbn_b4_bt_4_921600,
2661         pbn_b4_bt_8_921600,
2662
2663         /*
2664          * Board-specific versions.
2665          */
2666         pbn_panacom,
2667         pbn_panacom2,
2668         pbn_panacom4,
2669         pbn_plx_romulus,
2670         pbn_endrun_2_3906250,
2671         pbn_oxsemi,
2672         pbn_oxsemi_1_3906250,
2673         pbn_oxsemi_2_3906250,
2674         pbn_oxsemi_4_3906250,
2675         pbn_oxsemi_8_3906250,
2676         pbn_intel_i960,
2677         pbn_sgi_ioc3,
2678         pbn_computone_4,
2679         pbn_computone_6,
2680         pbn_computone_8,
2681         pbn_sbsxrsio,
2682         pbn_pasemi_1682M,
2683         pbn_ni8430_2,
2684         pbn_ni8430_4,
2685         pbn_ni8430_8,
2686         pbn_ni8430_16,
2687         pbn_ADDIDATA_PCIe_1_3906250,
2688         pbn_ADDIDATA_PCIe_2_3906250,
2689         pbn_ADDIDATA_PCIe_4_3906250,
2690         pbn_ADDIDATA_PCIe_8_3906250,
2691         pbn_ce4100_1_115200,
2692         pbn_omegapci,
2693         pbn_NETMOS9900_2s_115200,
2694         pbn_brcm_trumanage,
2695         pbn_fintek_4,
2696         pbn_fintek_8,
2697         pbn_fintek_12,
2698         pbn_fintek_F81504A,
2699         pbn_fintek_F81508A,
2700         pbn_fintek_F81512A,
2701         pbn_wch382_2,
2702         pbn_wch384_4,
2703         pbn_wch384_8,
2704         pbn_sunix_pci_1s,
2705         pbn_sunix_pci_2s,
2706         pbn_sunix_pci_4s,
2707         pbn_sunix_pci_8s,
2708         pbn_sunix_pci_16s,
2709         pbn_titan_1_4000000,
2710         pbn_titan_2_4000000,
2711         pbn_titan_4_4000000,
2712         pbn_titan_8_4000000,
2713         pbn_moxa8250_2p,
2714         pbn_moxa8250_4p,
2715         pbn_moxa8250_8p,
2716 };
2717
2718 /*
2719  * uart_offset - the space between channels
2720  * reg_shift   - describes how the UART registers are mapped
2721  *               to PCI memory by the card.
2722  * For example IER register on SBS, Inc. PMC-OctPro is located at
2723  * offset 0x10 from the UART base, while UART_IER is defined as 1
2724  * in include/linux/serial_reg.h,
2725  * see first lines of serial_in() and serial_out() in 8250.c
2726 */
2727
2728 static struct pciserial_board pci_boards[] = {
2729         [pbn_default] = {
2730                 .flags          = FL_BASE0,
2731                 .num_ports      = 1,
2732                 .base_baud      = 115200,
2733                 .uart_offset    = 8,
2734         },
2735         [pbn_b0_1_115200] = {
2736                 .flags          = FL_BASE0,
2737                 .num_ports      = 1,
2738                 .base_baud      = 115200,
2739                 .uart_offset    = 8,
2740         },
2741         [pbn_b0_2_115200] = {
2742                 .flags          = FL_BASE0,
2743                 .num_ports      = 2,
2744                 .base_baud      = 115200,
2745                 .uart_offset    = 8,
2746         },
2747         [pbn_b0_4_115200] = {
2748                 .flags          = FL_BASE0,
2749                 .num_ports      = 4,
2750                 .base_baud      = 115200,
2751                 .uart_offset    = 8,
2752         },
2753         [pbn_b0_5_115200] = {
2754                 .flags          = FL_BASE0,
2755                 .num_ports      = 5,
2756                 .base_baud      = 115200,
2757                 .uart_offset    = 8,
2758         },
2759         [pbn_b0_8_115200] = {
2760                 .flags          = FL_BASE0,
2761                 .num_ports      = 8,
2762                 .base_baud      = 115200,
2763                 .uart_offset    = 8,
2764         },
2765         [pbn_b0_1_921600] = {
2766                 .flags          = FL_BASE0,
2767                 .num_ports      = 1,
2768                 .base_baud      = 921600,
2769                 .uart_offset    = 8,
2770         },
2771         [pbn_b0_2_921600] = {
2772                 .flags          = FL_BASE0,
2773                 .num_ports      = 2,
2774                 .base_baud      = 921600,
2775                 .uart_offset    = 8,
2776         },
2777         [pbn_b0_4_921600] = {
2778                 .flags          = FL_BASE0,
2779                 .num_ports      = 4,
2780                 .base_baud      = 921600,
2781                 .uart_offset    = 8,
2782         },
2783
2784         [pbn_b0_2_1130000] = {
2785                 .flags          = FL_BASE0,
2786                 .num_ports      = 2,
2787                 .base_baud      = 1130000,
2788                 .uart_offset    = 8,
2789         },
2790
2791         [pbn_b0_4_1152000] = {
2792                 .flags          = FL_BASE0,
2793                 .num_ports      = 4,
2794                 .base_baud      = 1152000,
2795                 .uart_offset    = 8,
2796         },
2797
2798         [pbn_b0_4_1250000] = {
2799                 .flags          = FL_BASE0,
2800                 .num_ports      = 4,
2801                 .base_baud      = 1250000,
2802                 .uart_offset    = 8,
2803         },
2804
2805         [pbn_b0_2_1843200] = {
2806                 .flags          = FL_BASE0,
2807                 .num_ports      = 2,
2808                 .base_baud      = 1843200,
2809                 .uart_offset    = 8,
2810         },
2811         [pbn_b0_4_1843200] = {
2812                 .flags          = FL_BASE0,
2813                 .num_ports      = 4,
2814                 .base_baud      = 1843200,
2815                 .uart_offset    = 8,
2816         },
2817
2818         [pbn_b0_1_3906250] = {
2819                 .flags          = FL_BASE0,
2820                 .num_ports      = 1,
2821                 .base_baud      = 3906250,
2822                 .uart_offset    = 8,
2823         },
2824
2825         [pbn_b0_bt_1_115200] = {
2826                 .flags          = FL_BASE0|FL_BASE_BARS,
2827                 .num_ports      = 1,
2828                 .base_baud      = 115200,
2829                 .uart_offset    = 8,
2830         },
2831         [pbn_b0_bt_2_115200] = {
2832                 .flags          = FL_BASE0|FL_BASE_BARS,
2833                 .num_ports      = 2,
2834                 .base_baud      = 115200,
2835                 .uart_offset    = 8,
2836         },
2837         [pbn_b0_bt_4_115200] = {
2838                 .flags          = FL_BASE0|FL_BASE_BARS,
2839                 .num_ports      = 4,
2840                 .base_baud      = 115200,
2841                 .uart_offset    = 8,
2842         },
2843         [pbn_b0_bt_8_115200] = {
2844                 .flags          = FL_BASE0|FL_BASE_BARS,
2845                 .num_ports      = 8,
2846                 .base_baud      = 115200,
2847                 .uart_offset    = 8,
2848         },
2849
2850         [pbn_b0_bt_1_460800] = {
2851                 .flags          = FL_BASE0|FL_BASE_BARS,
2852                 .num_ports      = 1,
2853                 .base_baud      = 460800,
2854                 .uart_offset    = 8,
2855         },
2856         [pbn_b0_bt_2_460800] = {
2857                 .flags          = FL_BASE0|FL_BASE_BARS,
2858                 .num_ports      = 2,
2859                 .base_baud      = 460800,
2860                 .uart_offset    = 8,
2861         },
2862         [pbn_b0_bt_4_460800] = {
2863                 .flags          = FL_BASE0|FL_BASE_BARS,
2864                 .num_ports      = 4,
2865                 .base_baud      = 460800,
2866                 .uart_offset    = 8,
2867         },
2868
2869         [pbn_b0_bt_1_921600] = {
2870                 .flags          = FL_BASE0|FL_BASE_BARS,
2871                 .num_ports      = 1,
2872                 .base_baud      = 921600,
2873                 .uart_offset    = 8,
2874         },
2875         [pbn_b0_bt_2_921600] = {
2876                 .flags          = FL_BASE0|FL_BASE_BARS,
2877                 .num_ports      = 2,
2878                 .base_baud      = 921600,
2879                 .uart_offset    = 8,
2880         },
2881         [pbn_b0_bt_4_921600] = {
2882                 .flags          = FL_BASE0|FL_BASE_BARS,
2883                 .num_ports      = 4,
2884                 .base_baud      = 921600,
2885                 .uart_offset    = 8,
2886         },
2887         [pbn_b0_bt_8_921600] = {
2888                 .flags          = FL_BASE0|FL_BASE_BARS,
2889                 .num_ports      = 8,
2890                 .base_baud      = 921600,
2891                 .uart_offset    = 8,
2892         },
2893
2894         [pbn_b1_1_115200] = {
2895                 .flags          = FL_BASE1,
2896                 .num_ports      = 1,
2897                 .base_baud      = 115200,
2898                 .uart_offset    = 8,
2899         },
2900         [pbn_b1_2_115200] = {
2901                 .flags          = FL_BASE1,
2902                 .num_ports      = 2,
2903                 .base_baud      = 115200,
2904                 .uart_offset    = 8,
2905         },
2906         [pbn_b1_4_115200] = {
2907                 .flags          = FL_BASE1,
2908                 .num_ports      = 4,
2909                 .base_baud      = 115200,
2910                 .uart_offset    = 8,
2911         },
2912         [pbn_b1_8_115200] = {
2913                 .flags          = FL_BASE1,
2914                 .num_ports      = 8,
2915                 .base_baud      = 115200,
2916                 .uart_offset    = 8,
2917         },
2918         [pbn_b1_16_115200] = {
2919                 .flags          = FL_BASE1,
2920                 .num_ports      = 16,
2921                 .base_baud      = 115200,
2922                 .uart_offset    = 8,
2923         },
2924
2925         [pbn_b1_1_921600] = {
2926                 .flags          = FL_BASE1,
2927                 .num_ports      = 1,
2928                 .base_baud      = 921600,
2929                 .uart_offset    = 8,
2930         },
2931         [pbn_b1_2_921600] = {
2932                 .flags          = FL_BASE1,
2933                 .num_ports      = 2,
2934                 .base_baud      = 921600,
2935                 .uart_offset    = 8,
2936         },
2937         [pbn_b1_4_921600] = {
2938                 .flags          = FL_BASE1,
2939                 .num_ports      = 4,
2940                 .base_baud      = 921600,
2941                 .uart_offset    = 8,
2942         },
2943         [pbn_b1_8_921600] = {
2944                 .flags          = FL_BASE1,
2945                 .num_ports      = 8,
2946                 .base_baud      = 921600,
2947                 .uart_offset    = 8,
2948         },
2949         [pbn_b1_2_1250000] = {
2950                 .flags          = FL_BASE1,
2951                 .num_ports      = 2,
2952                 .base_baud      = 1250000,
2953                 .uart_offset    = 8,
2954         },
2955
2956         [pbn_b1_bt_1_115200] = {
2957                 .flags          = FL_BASE1|FL_BASE_BARS,
2958                 .num_ports      = 1,
2959                 .base_baud      = 115200,
2960                 .uart_offset    = 8,
2961         },
2962         [pbn_b1_bt_2_115200] = {
2963                 .flags          = FL_BASE1|FL_BASE_BARS,
2964                 .num_ports      = 2,
2965                 .base_baud      = 115200,
2966                 .uart_offset    = 8,
2967         },
2968         [pbn_b1_bt_4_115200] = {
2969                 .flags          = FL_BASE1|FL_BASE_BARS,
2970                 .num_ports      = 4,
2971                 .base_baud      = 115200,
2972                 .uart_offset    = 8,
2973         },
2974
2975         [pbn_b1_bt_2_921600] = {
2976                 .flags          = FL_BASE1|FL_BASE_BARS,
2977                 .num_ports      = 2,
2978                 .base_baud      = 921600,
2979                 .uart_offset    = 8,
2980         },
2981
2982         [pbn_b1_1_1382400] = {
2983                 .flags          = FL_BASE1,
2984                 .num_ports      = 1,
2985                 .base_baud      = 1382400,
2986                 .uart_offset    = 8,
2987         },
2988         [pbn_b1_2_1382400] = {
2989                 .flags          = FL_BASE1,
2990                 .num_ports      = 2,
2991                 .base_baud      = 1382400,
2992                 .uart_offset    = 8,
2993         },
2994         [pbn_b1_4_1382400] = {
2995                 .flags          = FL_BASE1,
2996                 .num_ports      = 4,
2997                 .base_baud      = 1382400,
2998                 .uart_offset    = 8,
2999         },
3000         [pbn_b1_8_1382400] = {
3001                 .flags          = FL_BASE1,
3002                 .num_ports      = 8,
3003                 .base_baud      = 1382400,
3004                 .uart_offset    = 8,
3005         },
3006
3007         [pbn_b2_1_115200] = {
3008                 .flags          = FL_BASE2,
3009                 .num_ports      = 1,
3010                 .base_baud      = 115200,
3011                 .uart_offset    = 8,
3012         },
3013         [pbn_b2_2_115200] = {
3014                 .flags          = FL_BASE2,
3015                 .num_ports      = 2,
3016                 .base_baud      = 115200,
3017                 .uart_offset    = 8,
3018         },
3019         [pbn_b2_4_115200] = {
3020                 .flags          = FL_BASE2,
3021                 .num_ports      = 4,
3022                 .base_baud      = 115200,
3023                 .uart_offset    = 8,
3024         },
3025         [pbn_b2_8_115200] = {
3026                 .flags          = FL_BASE2,
3027                 .num_ports      = 8,
3028                 .base_baud      = 115200,
3029                 .uart_offset    = 8,
3030         },
3031
3032         [pbn_b2_1_460800] = {
3033                 .flags          = FL_BASE2,
3034                 .num_ports      = 1,
3035                 .base_baud      = 460800,
3036                 .uart_offset    = 8,
3037         },
3038         [pbn_b2_4_460800] = {
3039                 .flags          = FL_BASE2,
3040                 .num_ports      = 4,
3041                 .base_baud      = 460800,
3042                 .uart_offset    = 8,
3043         },
3044         [pbn_b2_8_460800] = {
3045                 .flags          = FL_BASE2,
3046                 .num_ports      = 8,
3047                 .base_baud      = 460800,
3048                 .uart_offset    = 8,
3049         },
3050         [pbn_b2_16_460800] = {
3051                 .flags          = FL_BASE2,
3052                 .num_ports      = 16,
3053                 .base_baud      = 460800,
3054                 .uart_offset    = 8,
3055          },
3056
3057         [pbn_b2_1_921600] = {
3058                 .flags          = FL_BASE2,
3059                 .num_ports      = 1,
3060                 .base_baud      = 921600,
3061                 .uart_offset    = 8,
3062         },
3063         [pbn_b2_4_921600] = {
3064                 .flags          = FL_BASE2,
3065                 .num_ports      = 4,
3066                 .base_baud      = 921600,
3067                 .uart_offset    = 8,
3068         },
3069         [pbn_b2_8_921600] = {
3070                 .flags          = FL_BASE2,
3071                 .num_ports      = 8,
3072                 .base_baud      = 921600,
3073                 .uart_offset    = 8,
3074         },
3075
3076         [pbn_b2_8_1152000] = {
3077                 .flags          = FL_BASE2,
3078                 .num_ports      = 8,
3079                 .base_baud      = 1152000,
3080                 .uart_offset    = 8,
3081         },
3082
3083         [pbn_b2_bt_1_115200] = {
3084                 .flags          = FL_BASE2|FL_BASE_BARS,
3085                 .num_ports      = 1,
3086                 .base_baud      = 115200,
3087                 .uart_offset    = 8,
3088         },
3089         [pbn_b2_bt_2_115200] = {
3090                 .flags          = FL_BASE2|FL_BASE_BARS,
3091                 .num_ports      = 2,
3092                 .base_baud      = 115200,
3093                 .uart_offset    = 8,
3094         },
3095         [pbn_b2_bt_4_115200] = {
3096                 .flags          = FL_BASE2|FL_BASE_BARS,
3097                 .num_ports      = 4,
3098                 .base_baud      = 115200,
3099                 .uart_offset    = 8,
3100         },
3101
3102         [pbn_b2_bt_2_921600] = {
3103                 .flags          = FL_BASE2|FL_BASE_BARS,
3104                 .num_ports      = 2,
3105                 .base_baud      = 921600,
3106                 .uart_offset    = 8,
3107         },
3108         [pbn_b2_bt_4_921600] = {
3109                 .flags          = FL_BASE2|FL_BASE_BARS,
3110                 .num_ports      = 4,
3111                 .base_baud      = 921600,
3112                 .uart_offset    = 8,
3113         },
3114
3115         [pbn_b3_2_115200] = {
3116                 .flags          = FL_BASE3,
3117                 .num_ports      = 2,
3118                 .base_baud      = 115200,
3119                 .uart_offset    = 8,
3120         },
3121         [pbn_b3_4_115200] = {
3122                 .flags          = FL_BASE3,
3123                 .num_ports      = 4,
3124                 .base_baud      = 115200,
3125                 .uart_offset    = 8,
3126         },
3127         [pbn_b3_8_115200] = {
3128                 .flags          = FL_BASE3,
3129                 .num_ports      = 8,
3130                 .base_baud      = 115200,
3131                 .uart_offset    = 8,
3132         },
3133
3134         [pbn_b4_bt_2_921600] = {
3135                 .flags          = FL_BASE4,
3136                 .num_ports      = 2,
3137                 .base_baud      = 921600,
3138                 .uart_offset    = 8,
3139         },
3140         [pbn_b4_bt_4_921600] = {
3141                 .flags          = FL_BASE4,
3142                 .num_ports      = 4,
3143                 .base_baud      = 921600,
3144                 .uart_offset    = 8,
3145         },
3146         [pbn_b4_bt_8_921600] = {
3147                 .flags          = FL_BASE4,
3148                 .num_ports      = 8,
3149                 .base_baud      = 921600,
3150                 .uart_offset    = 8,
3151         },
3152
3153         /*
3154          * Entries following this are board-specific.
3155          */
3156
3157         /*
3158          * Panacom - IOMEM
3159          */
3160         [pbn_panacom] = {
3161                 .flags          = FL_BASE2,
3162                 .num_ports      = 2,
3163                 .base_baud      = 921600,
3164                 .uart_offset    = 0x400,
3165                 .reg_shift      = 7,
3166         },
3167         [pbn_panacom2] = {
3168                 .flags          = FL_BASE2|FL_BASE_BARS,
3169                 .num_ports      = 2,
3170                 .base_baud      = 921600,
3171                 .uart_offset    = 0x400,
3172                 .reg_shift      = 7,
3173         },
3174         [pbn_panacom4] = {
3175                 .flags          = FL_BASE2|FL_BASE_BARS,
3176                 .num_ports      = 4,
3177                 .base_baud      = 921600,
3178                 .uart_offset    = 0x400,
3179                 .reg_shift      = 7,
3180         },
3181
3182         /* I think this entry is broken - the first_offset looks wrong --rmk */
3183         [pbn_plx_romulus] = {
3184                 .flags          = FL_BASE2,
3185                 .num_ports      = 4,
3186                 .base_baud      = 921600,
3187                 .uart_offset    = 8 << 2,
3188                 .reg_shift      = 2,
3189                 .first_offset   = 0x03,
3190         },
3191
3192         /*
3193          * EndRun Technologies
3194         * Uses the size of PCI Base region 0 to
3195         * signal now many ports are available
3196         * 2 port 952 Uart support
3197         */
3198         [pbn_endrun_2_3906250] = {
3199                 .flags          = FL_BASE0,
3200                 .num_ports      = 2,
3201                 .base_baud      = 3906250,
3202                 .uart_offset    = 0x200,
3203                 .first_offset   = 0x1000,
3204         },
3205
3206         /*
3207          * This board uses the size of PCI Base region 0 to
3208          * signal now many ports are available
3209          */
3210         [pbn_oxsemi] = {
3211                 .flags          = FL_BASE0|FL_REGION_SZ_CAP,
3212                 .num_ports      = 32,
3213                 .base_baud      = 115200,
3214                 .uart_offset    = 8,
3215         },
3216         [pbn_oxsemi_1_3906250] = {
3217                 .flags          = FL_BASE0,
3218                 .num_ports      = 1,
3219                 .base_baud      = 3906250,
3220                 .uart_offset    = 0x200,
3221                 .first_offset   = 0x1000,
3222         },
3223         [pbn_oxsemi_2_3906250] = {
3224                 .flags          = FL_BASE0,
3225                 .num_ports      = 2,
3226                 .base_baud      = 3906250,
3227                 .uart_offset    = 0x200,
3228                 .first_offset   = 0x1000,
3229         },
3230         [pbn_oxsemi_4_3906250] = {
3231                 .flags          = FL_BASE0,
3232                 .num_ports      = 4,
3233                 .base_baud      = 3906250,
3234                 .uart_offset    = 0x200,
3235                 .first_offset   = 0x1000,
3236         },
3237         [pbn_oxsemi_8_3906250] = {
3238                 .flags          = FL_BASE0,
3239                 .num_ports      = 8,
3240                 .base_baud      = 3906250,
3241                 .uart_offset    = 0x200,
3242                 .first_offset   = 0x1000,
3243         },
3244
3245
3246         /*
3247          * EKF addition for i960 Boards form EKF with serial port.
3248          * Max 256 ports.
3249          */
3250         [pbn_intel_i960] = {
3251                 .flags          = FL_BASE0,
3252                 .num_ports      = 32,
3253                 .base_baud      = 921600,
3254                 .uart_offset    = 8 << 2,
3255                 .reg_shift      = 2,
3256                 .first_offset   = 0x10000,
3257         },
3258         [pbn_sgi_ioc3] = {
3259                 .flags          = FL_BASE0|FL_NOIRQ,
3260                 .num_ports      = 1,
3261                 .base_baud      = 458333,
3262                 .uart_offset    = 8,
3263                 .reg_shift      = 0,
3264                 .first_offset   = 0x20178,
3265         },
3266
3267         /*
3268          * Computone - uses IOMEM.
3269          */
3270         [pbn_computone_4] = {
3271                 .flags          = FL_BASE0,
3272                 .num_ports      = 4,
3273                 .base_baud      = 921600,
3274                 .uart_offset    = 0x40,
3275                 .reg_shift      = 2,
3276                 .first_offset   = 0x200,
3277         },
3278         [pbn_computone_6] = {
3279                 .flags          = FL_BASE0,
3280                 .num_ports      = 6,
3281                 .base_baud      = 921600,
3282                 .uart_offset    = 0x40,
3283                 .reg_shift      = 2,
3284                 .first_offset   = 0x200,
3285         },
3286         [pbn_computone_8] = {
3287                 .flags          = FL_BASE0,
3288                 .num_ports      = 8,
3289                 .base_baud      = 921600,
3290                 .uart_offset    = 0x40,
3291                 .reg_shift      = 2,
3292                 .first_offset   = 0x200,
3293         },
3294         [pbn_sbsxrsio] = {
3295                 .flags          = FL_BASE0,
3296                 .num_ports      = 8,
3297                 .base_baud      = 460800,
3298                 .uart_offset    = 256,
3299                 .reg_shift      = 4,
3300         },
3301         /*
3302          * PA Semi PWRficient PA6T-1682M on-chip UART
3303          */
3304         [pbn_pasemi_1682M] = {
3305                 .flags          = FL_BASE0,
3306                 .num_ports      = 1,
3307                 .base_baud      = 8333333,
3308         },
3309         /*
3310          * National Instruments 843x
3311          */
3312         [pbn_ni8430_16] = {
3313                 .flags          = FL_BASE0,
3314                 .num_ports      = 16,
3315                 .base_baud      = 3686400,
3316                 .uart_offset    = 0x10,
3317                 .first_offset   = 0x800,
3318         },
3319         [pbn_ni8430_8] = {
3320                 .flags          = FL_BASE0,
3321                 .num_ports      = 8,
3322                 .base_baud      = 3686400,
3323                 .uart_offset    = 0x10,
3324                 .first_offset   = 0x800,
3325         },
3326         [pbn_ni8430_4] = {
3327                 .flags          = FL_BASE0,
3328                 .num_ports      = 4,
3329                 .base_baud      = 3686400,
3330                 .uart_offset    = 0x10,
3331                 .first_offset   = 0x800,
3332         },
3333         [pbn_ni8430_2] = {
3334                 .flags          = FL_BASE0,
3335                 .num_ports      = 2,
3336                 .base_baud      = 3686400,
3337                 .uart_offset    = 0x10,
3338                 .first_offset   = 0x800,
3339         },
3340         /*
3341          * ADDI-DATA GmbH PCI-Express communication cards <info@addi-data.com>
3342          */
3343         [pbn_ADDIDATA_PCIe_1_3906250] = {
3344                 .flags          = FL_BASE0,
3345                 .num_ports      = 1,
3346                 .base_baud      = 3906250,
3347                 .uart_offset    = 0x200,
3348                 .first_offset   = 0x1000,
3349         },
3350         [pbn_ADDIDATA_PCIe_2_3906250] = {
3351                 .flags          = FL_BASE0,
3352                 .num_ports      = 2,
3353                 .base_baud      = 3906250,
3354                 .uart_offset    = 0x200,
3355                 .first_offset   = 0x1000,
3356         },
3357         [pbn_ADDIDATA_PCIe_4_3906250] = {
3358                 .flags          = FL_BASE0,
3359                 .num_ports      = 4,
3360                 .base_baud      = 3906250,
3361                 .uart_offset    = 0x200,
3362                 .first_offset   = 0x1000,
3363         },
3364         [pbn_ADDIDATA_PCIe_8_3906250] = {
3365                 .flags          = FL_BASE0,
3366                 .num_ports      = 8,
3367                 .base_baud      = 3906250,
3368                 .uart_offset    = 0x200,
3369                 .first_offset   = 0x1000,
3370         },
3371         [pbn_ce4100_1_115200] = {
3372                 .flags          = FL_BASE_BARS,
3373                 .num_ports      = 2,
3374                 .base_baud      = 921600,
3375                 .reg_shift      = 2,
3376         },
3377         [pbn_omegapci] = {
3378                 .flags          = FL_BASE0,
3379                 .num_ports      = 8,
3380                 .base_baud      = 115200,
3381                 .uart_offset    = 0x200,
3382         },
3383         [pbn_NETMOS9900_2s_115200] = {
3384                 .flags          = FL_BASE0,
3385                 .num_ports      = 2,
3386                 .base_baud      = 115200,
3387         },
3388         [pbn_brcm_trumanage] = {
3389                 .flags          = FL_BASE0,
3390                 .num_ports      = 1,
3391                 .reg_shift      = 2,
3392                 .base_baud      = 115200,
3393         },
3394         [pbn_fintek_4] = {
3395                 .num_ports      = 4,
3396                 .uart_offset    = 8,
3397                 .base_baud      = 115200,
3398                 .first_offset   = 0x40,
3399         },
3400         [pbn_fintek_8] = {
3401                 .num_ports      = 8,
3402                 .uart_offset    = 8,
3403                 .base_baud      = 115200,
3404                 .first_offset   = 0x40,
3405         },
3406         [pbn_fintek_12] = {
3407                 .num_ports      = 12,
3408                 .uart_offset    = 8,
3409                 .base_baud      = 115200,
3410                 .first_offset   = 0x40,
3411         },
3412         [pbn_fintek_F81504A] = {
3413                 .num_ports      = 4,
3414                 .uart_offset    = 8,
3415                 .base_baud      = 115200,
3416         },
3417         [pbn_fintek_F81508A] = {
3418                 .num_ports      = 8,
3419                 .uart_offset    = 8,
3420                 .base_baud      = 115200,
3421         },
3422         [pbn_fintek_F81512A] = {
3423                 .num_ports      = 12,
3424                 .uart_offset    = 8,
3425                 .base_baud      = 115200,
3426         },
3427         [pbn_wch382_2] = {
3428                 .flags          = FL_BASE0,
3429                 .num_ports      = 2,
3430                 .base_baud      = 115200,
3431                 .uart_offset    = 8,
3432                 .first_offset   = 0xC0,
3433         },
3434         [pbn_wch384_4] = {
3435                 .flags          = FL_BASE0,
3436                 .num_ports      = 4,
3437                 .base_baud      = 115200,
3438                 .uart_offset    = 8,
3439                 .first_offset   = 0xC0,
3440         },
3441         [pbn_wch384_8] = {
3442                 .flags          = FL_BASE0,
3443                 .num_ports      = 8,
3444                 .base_baud      = 115200,
3445                 .uart_offset    = 8,
3446                 .first_offset   = 0x00,
3447         },
3448         [pbn_sunix_pci_1s] = {
3449                 .num_ports      = 1,
3450                 .base_baud      = 921600,
3451                 .uart_offset    = 0x8,
3452         },
3453         [pbn_sunix_pci_2s] = {
3454                 .num_ports      = 2,
3455                 .base_baud      = 921600,
3456                 .uart_offset    = 0x8,
3457         },
3458         [pbn_sunix_pci_4s] = {
3459                 .num_ports      = 4,
3460                 .base_baud      = 921600,
3461                 .uart_offset    = 0x8,
3462         },
3463         [pbn_sunix_pci_8s] = {
3464                 .num_ports      = 8,
3465                 .base_baud      = 921600,
3466                 .uart_offset    = 0x8,
3467         },
3468         [pbn_sunix_pci_16s] = {
3469                 .num_ports      = 16,
3470                 .base_baud      = 921600,
3471                 .uart_offset    = 0x8,
3472         },
3473         [pbn_titan_1_4000000] = {
3474                 .flags          = FL_BASE0,
3475                 .num_ports      = 1,
3476                 .base_baud      = 4000000,
3477                 .uart_offset    = 0x200,
3478                 .first_offset   = 0x1000,
3479         },
3480         [pbn_titan_2_4000000] = {
3481                 .flags          = FL_BASE0,
3482                 .num_ports      = 2,
3483                 .base_baud      = 4000000,
3484                 .uart_offset    = 0x200,
3485                 .first_offset   = 0x1000,
3486         },
3487         [pbn_titan_4_4000000] = {
3488                 .flags          = FL_BASE0,
3489                 .num_ports      = 4,
3490                 .base_baud      = 4000000,
3491                 .uart_offset    = 0x200,
3492                 .first_offset   = 0x1000,
3493         },
3494         [pbn_titan_8_4000000] = {
3495                 .flags          = FL_BASE0,
3496                 .num_ports      = 8,
3497                 .base_baud      = 4000000,
3498                 .uart_offset    = 0x200,
3499                 .first_offset   = 0x1000,
3500         },
3501         [pbn_moxa8250_2p] = {
3502                 .flags          = FL_BASE1,
3503                 .num_ports      = 2,
3504                 .base_baud      = 921600,
3505                 .uart_offset    = 0x200,
3506         },
3507         [pbn_moxa8250_4p] = {
3508                 .flags          = FL_BASE1,
3509                 .num_ports      = 4,
3510                 .base_baud      = 921600,
3511                 .uart_offset    = 0x200,
3512         },
3513         [pbn_moxa8250_8p] = {
3514                 .flags          = FL_BASE1,
3515                 .num_ports      = 8,
3516                 .base_baud      = 921600,
3517                 .uart_offset    = 0x200,
3518         },
3519 };
3520
3521 #define REPORT_CONFIG(option) \
3522         (IS_ENABLED(CONFIG_##option) ? 0 : (kernel_ulong_t)&#option)
3523 #define REPORT_8250_CONFIG(option) \
3524         (IS_ENABLED(CONFIG_SERIAL_8250_##option) ? \
3525          0 : (kernel_ulong_t)&"SERIAL_8250_"#option)
3526
3527 static const struct pci_device_id blacklist[] = {
3528         /* softmodems */
3529         { PCI_VDEVICE(AL, 0x5457), }, /* ALi Corporation M5457 AC'97 Modem */
3530         { PCI_VDEVICE(MOTOROLA, 0x3052), }, /* Motorola Si3052-based modem */
3531         { PCI_DEVICE(0x1543, 0x3052), }, /* Si3052-based modem, default IDs */
3532
3533         /* multi-io cards handled by parport_serial */
3534         /* WCH CH353 2S1P */
3535         { PCI_DEVICE(0x4348, 0x7053), 0, 0, REPORT_CONFIG(PARPORT_SERIAL), },
3536         /* WCH CH353 1S1P */
3537         { PCI_DEVICE(0x4348, 0x5053), 0, 0, REPORT_CONFIG(PARPORT_SERIAL), },
3538         /* WCH CH382 2S1P */
3539         { PCI_DEVICE(0x1c00, 0x3250), 0, 0, REPORT_CONFIG(PARPORT_SERIAL), },
3540
3541         /* Intel platforms with MID UART */
3542         { PCI_VDEVICE(INTEL, 0x081b), REPORT_8250_CONFIG(MID), },
3543         { PCI_VDEVICE(INTEL, 0x081c), REPORT_8250_CONFIG(MID), },
3544         { PCI_VDEVICE(INTEL, 0x081d), REPORT_8250_CONFIG(MID), },
3545         { PCI_VDEVICE(INTEL, 0x1191), REPORT_8250_CONFIG(MID), },
3546         { PCI_VDEVICE(INTEL, 0x18d8), REPORT_8250_CONFIG(MID), },
3547         { PCI_VDEVICE(INTEL, 0x19d8), REPORT_8250_CONFIG(MID), },
3548
3549         /* Intel platforms with DesignWare UART */
3550         { PCI_VDEVICE(INTEL, 0x0936), REPORT_8250_CONFIG(LPSS), },
3551         { PCI_VDEVICE(INTEL, 0x0f0a), REPORT_8250_CONFIG(LPSS), },
3552         { PCI_VDEVICE(INTEL, 0x0f0c), REPORT_8250_CONFIG(LPSS), },
3553         { PCI_VDEVICE(INTEL, 0x228a), REPORT_8250_CONFIG(LPSS), },
3554         { PCI_VDEVICE(INTEL, 0x228c), REPORT_8250_CONFIG(LPSS), },
3555         { PCI_VDEVICE(INTEL, 0x4b96), REPORT_8250_CONFIG(LPSS), },
3556         { PCI_VDEVICE(INTEL, 0x4b97), REPORT_8250_CONFIG(LPSS), },
3557         { PCI_VDEVICE(INTEL, 0x4b98), REPORT_8250_CONFIG(LPSS), },
3558         { PCI_VDEVICE(INTEL, 0x4b99), REPORT_8250_CONFIG(LPSS), },
3559         { PCI_VDEVICE(INTEL, 0x4b9a), REPORT_8250_CONFIG(LPSS), },
3560         { PCI_VDEVICE(INTEL, 0x4b9b), REPORT_8250_CONFIG(LPSS), },
3561         { PCI_VDEVICE(INTEL, 0x9ce3), REPORT_8250_CONFIG(LPSS), },
3562         { PCI_VDEVICE(INTEL, 0x9ce4), REPORT_8250_CONFIG(LPSS), },
3563
3564         /* Exar devices */
3565         { PCI_VDEVICE(EXAR, PCI_ANY_ID), REPORT_8250_CONFIG(EXAR), },
3566         { PCI_VDEVICE(COMMTECH, PCI_ANY_ID), REPORT_8250_CONFIG(EXAR), },
3567
3568         /* Pericom devices */
3569         { PCI_VDEVICE(PERICOM, PCI_ANY_ID), REPORT_8250_CONFIG(PERICOM), },
3570         { PCI_VDEVICE(ACCESSIO, PCI_ANY_ID), REPORT_8250_CONFIG(PERICOM), },
3571
3572         /* End of the black list */
3573         { }
3574 };
3575
3576 static int serial_pci_is_class_communication(struct pci_dev *dev)
3577 {
3578         /*
3579          * If it is not a communications device or the programming
3580          * interface is greater than 6, give up.
3581          */
3582         if ((((dev->class >> 8) != PCI_CLASS_COMMUNICATION_SERIAL) &&
3583              ((dev->class >> 8) != PCI_CLASS_COMMUNICATION_MULTISERIAL) &&
3584              ((dev->class >> 8) != PCI_CLASS_COMMUNICATION_MODEM)) ||
3585             (dev->class & 0xff) > 6)
3586                 return -ENODEV;
3587
3588         return 0;
3589 }
3590
3591 /*
3592  * Given a complete unknown PCI device, try to use some heuristics to
3593  * guess what the configuration might be, based on the pitiful PCI
3594  * serial specs.  Returns 0 on success, -ENODEV on failure.
3595  */
3596 static int
3597 serial_pci_guess_board(struct pci_dev *dev, struct pciserial_board *board)
3598 {
3599         int num_iomem, num_port, first_port = -1, i;
3600         int rc;
3601
3602         rc = serial_pci_is_class_communication(dev);
3603         if (rc)
3604                 return rc;
3605
3606         /*
3607          * Should we try to make guesses for multiport serial devices later?
3608          */
3609         if ((dev->class >> 8) == PCI_CLASS_COMMUNICATION_MULTISERIAL)
3610                 return -ENODEV;
3611
3612         num_iomem = num_port = 0;
3613         for (i = 0; i < PCI_STD_NUM_BARS; i++) {
3614                 if (pci_resource_flags(dev, i) & IORESOURCE_IO) {
3615                         num_port++;
3616                         if (first_port == -1)
3617                                 first_port = i;
3618                 }
3619                 if (pci_resource_flags(dev, i) & IORESOURCE_MEM)
3620                         num_iomem++;
3621         }
3622
3623         /*
3624          * If there is 1 or 0 iomem regions, and exactly one port,
3625          * use it.  We guess the number of ports based on the IO
3626          * region size.
3627          */
3628         if (num_iomem <= 1 && num_port == 1) {
3629                 board->flags = first_port;
3630                 board->num_ports = pci_resource_len(dev, first_port) / 8;
3631                 return 0;
3632         }
3633
3634         /*
3635          * Now guess if we've got a board which indexes by BARs.
3636          * Each IO BAR should be 8 bytes, and they should follow
3637          * consecutively.
3638          */
3639         first_port = -1;
3640         num_port = 0;
3641         for (i = 0; i < PCI_STD_NUM_BARS; i++) {
3642                 if (pci_resource_flags(dev, i) & IORESOURCE_IO &&
3643                     pci_resource_len(dev, i) == 8 &&
3644                     (first_port == -1 || (first_port + num_port) == i)) {
3645                         num_port++;
3646                         if (first_port == -1)
3647                                 first_port = i;
3648                 }
3649         }
3650
3651         if (num_port > 1) {
3652                 board->flags = first_port | FL_BASE_BARS;
3653                 board->num_ports = num_port;
3654                 return 0;
3655         }
3656
3657         return -ENODEV;
3658 }
3659
3660 static inline int
3661 serial_pci_matches(const struct pciserial_board *board,
3662                    const struct pciserial_board *guessed)
3663 {
3664         return
3665             board->num_ports == guessed->num_ports &&
3666             board->base_baud == guessed->base_baud &&
3667             board->uart_offset == guessed->uart_offset &&
3668             board->reg_shift == guessed->reg_shift &&
3669             board->first_offset == guessed->first_offset;
3670 }
3671
3672 struct serial_private *
3673 pciserial_init_ports(struct pci_dev *dev, const struct pciserial_board *board)
3674 {
3675         struct uart_8250_port uart;
3676         struct serial_private *priv;
3677         struct pci_serial_quirk *quirk;
3678         int rc, nr_ports, i;
3679
3680         nr_ports = board->num_ports;
3681
3682         /*
3683          * Find an init and setup quirks.
3684          */
3685         quirk = find_quirk(dev);
3686
3687         /*
3688          * Run the new-style initialization function.
3689          * The initialization function returns:
3690          *  <0  - error
3691          *   0  - use board->num_ports
3692          *  >0  - number of ports
3693          */
3694         if (quirk->init) {
3695                 rc = quirk->init(dev);
3696                 if (rc < 0) {
3697                         priv = ERR_PTR(rc);
3698                         goto err_out;
3699                 }
3700                 if (rc)
3701                         nr_ports = rc;
3702         }
3703
3704         priv = kzalloc(struct_size(priv, line, nr_ports), GFP_KERNEL);
3705         if (!priv) {
3706                 priv = ERR_PTR(-ENOMEM);
3707                 goto err_deinit;
3708         }
3709
3710         priv->dev = dev;
3711         priv->quirk = quirk;
3712
3713         memset(&uart, 0, sizeof(uart));
3714         uart.port.flags = UPF_SKIP_TEST | UPF_BOOT_AUTOCONF | UPF_SHARE_IRQ;
3715         uart.port.uartclk = board->base_baud * 16;
3716
3717         if (board->flags & FL_NOIRQ) {
3718                 uart.port.irq = 0;
3719         } else {
3720                 if (pci_match_id(pci_use_msi, dev)) {
3721                         pci_dbg(dev, "Using MSI(-X) interrupts\n");
3722                         pci_set_master(dev);
3723                         uart.port.flags &= ~UPF_SHARE_IRQ;
3724                         rc = pci_alloc_irq_vectors(dev, 1, 1, PCI_IRQ_ALL_TYPES);
3725                 } else {
3726                         pci_dbg(dev, "Using legacy interrupts\n");
3727                         rc = pci_alloc_irq_vectors(dev, 1, 1, PCI_IRQ_LEGACY);
3728                 }
3729                 if (rc < 0) {
3730                         kfree(priv);
3731                         priv = ERR_PTR(rc);
3732                         goto err_deinit;
3733                 }
3734
3735                 uart.port.irq = pci_irq_vector(dev, 0);
3736         }
3737
3738         uart.port.dev = &dev->dev;
3739
3740         for (i = 0; i < nr_ports; i++) {
3741                 if (quirk->setup(priv, board, &uart, i))
3742                         break;
3743
3744                 pci_dbg(dev, "Setup PCI port: port %lx, irq %d, type %d\n",
3745                         uart.port.iobase, uart.port.irq, uart.port.iotype);
3746
3747                 priv->line[i] = serial8250_register_8250_port(&uart);
3748                 if (priv->line[i] < 0) {
3749                         pci_err(dev,
3750                                 "Couldn't register serial port %lx, irq %d, type %d, error %d\n",
3751                                 uart.port.iobase, uart.port.irq,
3752                                 uart.port.iotype, priv->line[i]);
3753                         break;
3754                 }
3755         }
3756         priv->nr = i;
3757         priv->board = board;
3758         return priv;
3759
3760 err_deinit:
3761         if (quirk->exit)
3762                 quirk->exit(dev);
3763 err_out:
3764         return priv;
3765 }
3766 EXPORT_SYMBOL_GPL(pciserial_init_ports);
3767
3768 static void pciserial_detach_ports(struct serial_private *priv)
3769 {
3770         struct pci_serial_quirk *quirk;
3771         int i;
3772
3773         for (i = 0; i < priv->nr; i++)
3774                 serial8250_unregister_port(priv->line[i]);
3775
3776         /*
3777          * Find the exit quirks.
3778          */
3779         quirk = find_quirk(priv->dev);
3780         if (quirk->exit)
3781                 quirk->exit(priv->dev);
3782 }
3783
3784 void pciserial_remove_ports(struct serial_private *priv)
3785 {
3786         pciserial_detach_ports(priv);
3787         kfree(priv);
3788 }
3789 EXPORT_SYMBOL_GPL(pciserial_remove_ports);
3790
3791 void pciserial_suspend_ports(struct serial_private *priv)
3792 {
3793         int i;
3794
3795         for (i = 0; i < priv->nr; i++)
3796                 if (priv->line[i] >= 0)
3797                         serial8250_suspend_port(priv->line[i]);
3798
3799         /*
3800          * Ensure that every init quirk is properly torn down
3801          */
3802         if (priv->quirk->exit)
3803                 priv->quirk->exit(priv->dev);
3804 }
3805 EXPORT_SYMBOL_GPL(pciserial_suspend_ports);
3806
3807 void pciserial_resume_ports(struct serial_private *priv)
3808 {
3809         int i;
3810
3811         /*
3812          * Ensure that the board is correctly configured.
3813          */
3814         if (priv->quirk->init)
3815                 priv->quirk->init(priv->dev);
3816
3817         for (i = 0; i < priv->nr; i++)
3818                 if (priv->line[i] >= 0)
3819                         serial8250_resume_port(priv->line[i]);
3820 }
3821 EXPORT_SYMBOL_GPL(pciserial_resume_ports);
3822
3823 /*
3824  * Probe one serial board.  Unfortunately, there is no rhyme nor reason
3825  * to the arrangement of serial ports on a PCI card.
3826  */
3827 static int
3828 pciserial_init_one(struct pci_dev *dev, const struct pci_device_id *ent)
3829 {
3830         struct pci_serial_quirk *quirk;
3831         struct serial_private *priv;
3832         const struct pciserial_board *board;
3833         const struct pci_device_id *exclude;
3834         struct pciserial_board tmp;
3835         int rc;
3836
3837         quirk = find_quirk(dev);
3838         if (quirk->probe) {
3839                 rc = quirk->probe(dev);
3840                 if (rc)
3841                         return rc;
3842         }
3843
3844         if (ent->driver_data >= ARRAY_SIZE(pci_boards)) {
3845                 pci_err(dev, "invalid driver_data: %ld\n", ent->driver_data);
3846                 return -EINVAL;
3847         }
3848
3849         board = &pci_boards[ent->driver_data];
3850
3851         exclude = pci_match_id(blacklist, dev);
3852         if (exclude) {
3853                 if (exclude->driver_data)
3854                         pci_warn(dev, "ignoring port, enable %s to handle\n",
3855                                  (const char *)exclude->driver_data);
3856                 return -ENODEV;
3857         }
3858
3859         rc = pcim_enable_device(dev);
3860         pci_save_state(dev);
3861         if (rc)
3862                 return rc;
3863
3864         if (ent->driver_data == pbn_default) {
3865                 /*
3866                  * Use a copy of the pci_board entry for this;
3867                  * avoid changing entries in the table.
3868                  */
3869                 memcpy(&tmp, board, sizeof(struct pciserial_board));
3870                 board = &tmp;
3871
3872                 /*
3873                  * We matched one of our class entries.  Try to
3874                  * determine the parameters of this board.
3875                  */
3876                 rc = serial_pci_guess_board(dev, &tmp);
3877                 if (rc)
3878                         return rc;
3879         } else {
3880                 /*
3881                  * We matched an explicit entry.  If we are able to
3882                  * detect this boards settings with our heuristic,
3883                  * then we no longer need this entry.
3884                  */
3885                 memcpy(&tmp, &pci_boards[pbn_default],
3886                        sizeof(struct pciserial_board));
3887                 rc = serial_pci_guess_board(dev, &tmp);
3888                 if (rc == 0 && serial_pci_matches(board, &tmp))
3889                         moan_device("Redundant entry in serial pci_table.",
3890                                     dev);
3891         }
3892
3893         priv = pciserial_init_ports(dev, board);
3894         if (IS_ERR(priv))
3895                 return PTR_ERR(priv);
3896
3897         pci_set_drvdata(dev, priv);
3898         return 0;
3899 }
3900
3901 static void pciserial_remove_one(struct pci_dev *dev)
3902 {
3903         struct serial_private *priv = pci_get_drvdata(dev);
3904
3905         pciserial_remove_ports(priv);
3906 }
3907
3908 #ifdef CONFIG_PM_SLEEP
3909 static int pciserial_suspend_one(struct device *dev)
3910 {
3911         struct serial_private *priv = dev_get_drvdata(dev);
3912
3913         if (priv)
3914                 pciserial_suspend_ports(priv);
3915
3916         return 0;
3917 }
3918
3919 static int pciserial_resume_one(struct device *dev)
3920 {
3921         struct pci_dev *pdev = to_pci_dev(dev);
3922         struct serial_private *priv = pci_get_drvdata(pdev);
3923         int err;
3924
3925         if (priv) {
3926                 /*
3927                  * The device may have been disabled.  Re-enable it.
3928                  */
3929                 err = pci_enable_device(pdev);
3930                 /* FIXME: We cannot simply error out here */
3931                 if (err)
3932                         pci_err(pdev, "Unable to re-enable ports, trying to continue.\n");
3933                 pciserial_resume_ports(priv);
3934         }
3935         return 0;
3936 }
3937 #endif
3938
3939 static SIMPLE_DEV_PM_OPS(pciserial_pm_ops, pciserial_suspend_one,
3940                          pciserial_resume_one);
3941
3942 static const struct pci_device_id serial_pci_tbl[] = {
3943         /* Advantech use PCI_DEVICE_ID_ADVANTECH_PCI3620 (0x3620) as 'PCI_SUBVENDOR_ID' */
3944         {       PCI_VENDOR_ID_ADVANTECH, PCI_DEVICE_ID_ADVANTECH_PCI3620,
3945                 PCI_DEVICE_ID_ADVANTECH_PCI3620, 0x0001, 0, 0,
3946                 pbn_b2_8_921600 },
3947         /* Advantech also use 0x3618 and 0xf618 */
3948         {       PCI_VENDOR_ID_ADVANTECH, PCI_DEVICE_ID_ADVANTECH_PCI3618,
3949                 PCI_DEVICE_ID_ADVANTECH_PCI3618, PCI_ANY_ID, 0, 0,
3950                 pbn_b0_4_921600 },
3951         {       PCI_VENDOR_ID_ADVANTECH, PCI_DEVICE_ID_ADVANTECH_PCIf618,
3952                 PCI_DEVICE_ID_ADVANTECH_PCI3618, PCI_ANY_ID, 0, 0,
3953                 pbn_b0_4_921600 },
3954         {       PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V960,
3955                 PCI_SUBVENDOR_ID_CONNECT_TECH,
3956                 PCI_SUBDEVICE_ID_CONNECT_TECH_BH8_232, 0, 0,
3957                 pbn_b1_8_1382400 },
3958         {       PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V960,
3959                 PCI_SUBVENDOR_ID_CONNECT_TECH,
3960                 PCI_SUBDEVICE_ID_CONNECT_TECH_BH4_232, 0, 0,
3961                 pbn_b1_4_1382400 },
3962         {       PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V960,
3963                 PCI_SUBVENDOR_ID_CONNECT_TECH,
3964                 PCI_SUBDEVICE_ID_CONNECT_TECH_BH2_232, 0, 0,
3965                 pbn_b1_2_1382400 },
3966         {       PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V351,
3967                 PCI_SUBVENDOR_ID_CONNECT_TECH,
3968                 PCI_SUBDEVICE_ID_CONNECT_TECH_BH8_232, 0, 0,
3969                 pbn_b1_8_1382400 },
3970         {       PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V351,
3971                 PCI_SUBVENDOR_ID_CONNECT_TECH,
3972                 PCI_SUBDEVICE_ID_CONNECT_TECH_BH4_232, 0, 0,
3973                 pbn_b1_4_1382400 },
3974         {       PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V351,
3975                 PCI_SUBVENDOR_ID_CONNECT_TECH,
3976                 PCI_SUBDEVICE_ID_CONNECT_TECH_BH2_232, 0, 0,
3977                 pbn_b1_2_1382400 },
3978         {       PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V351,
3979                 PCI_SUBVENDOR_ID_CONNECT_TECH,
3980                 PCI_SUBDEVICE_ID_CONNECT_TECH_BH8_485, 0, 0,
3981                 pbn_b1_8_921600 },
3982         {       PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V351,
3983                 PCI_SUBVENDOR_ID_CONNECT_TECH,
3984                 PCI_SUBDEVICE_ID_CONNECT_TECH_BH8_485_4_4, 0, 0,
3985                 pbn_b1_8_921600 },
3986         {       PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V351,
3987                 PCI_SUBVENDOR_ID_CONNECT_TECH,
3988                 PCI_SUBDEVICE_ID_CONNECT_TECH_BH4_485, 0, 0,
3989                 pbn_b1_4_921600 },
3990         {       PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V351,
3991                 PCI_SUBVENDOR_ID_CONNECT_TECH,
3992                 PCI_SUBDEVICE_ID_CONNECT_TECH_BH4_485_2_2, 0, 0,
3993                 pbn_b1_4_921600 },
3994         {       PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V351,
3995                 PCI_SUBVENDOR_ID_CONNECT_TECH,
3996                 PCI_SUBDEVICE_ID_CONNECT_TECH_BH2_485, 0, 0,
3997                 pbn_b1_2_921600 },
3998         {       PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V351,
3999                 PCI_SUBVENDOR_ID_CONNECT_TECH,
4000                 PCI_SUBDEVICE_ID_CONNECT_TECH_BH8_485_2_6, 0, 0,
4001                 pbn_b1_8_921600 },
4002         {       PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V351,
4003                 PCI_SUBVENDOR_ID_CONNECT_TECH,
4004                 PCI_SUBDEVICE_ID_CONNECT_TECH_BH081101V1, 0, 0,
4005                 pbn_b1_8_921600 },
4006         {       PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V351,
4007                 PCI_SUBVENDOR_ID_CONNECT_TECH,
4008                 PCI_SUBDEVICE_ID_CONNECT_TECH_BH041101V1, 0, 0,
4009                 pbn_b1_4_921600 },
4010         {       PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V351,
4011                 PCI_SUBVENDOR_ID_CONNECT_TECH,
4012                 PCI_SUBDEVICE_ID_CONNECT_TECH_BH2_20MHZ, 0, 0,
4013                 pbn_b1_2_1250000 },
4014         {       PCI_VENDOR_ID_OXSEMI, PCI_DEVICE_ID_OXSEMI_16PCI954,
4015                 PCI_SUBVENDOR_ID_CONNECT_TECH,
4016                 PCI_SUBDEVICE_ID_CONNECT_TECH_TITAN_2, 0, 0,
4017                 pbn_b0_2_1843200 },
4018         {       PCI_VENDOR_ID_OXSEMI, PCI_DEVICE_ID_OXSEMI_16PCI954,
4019                 PCI_SUBVENDOR_ID_CONNECT_TECH,
4020                 PCI_SUBDEVICE_ID_CONNECT_TECH_TITAN_4, 0, 0,
4021                 pbn_b0_4_1843200 },
4022         {       PCI_VENDOR_ID_OXSEMI, PCI_DEVICE_ID_OXSEMI_16PCI954,
4023                 PCI_VENDOR_ID_AFAVLAB,
4024                 PCI_SUBDEVICE_ID_AFAVLAB_P061, 0, 0,
4025                 pbn_b0_4_1152000 },
4026         {       PCI_VENDOR_ID_SEALEVEL, PCI_DEVICE_ID_SEALEVEL_U530,
4027                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4028                 pbn_b2_bt_1_115200 },
4029         {       PCI_VENDOR_ID_SEALEVEL, PCI_DEVICE_ID_SEALEVEL_UCOMM2,
4030                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4031                 pbn_b2_bt_2_115200 },
4032         {       PCI_VENDOR_ID_SEALEVEL, PCI_DEVICE_ID_SEALEVEL_UCOMM422,
4033                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4034                 pbn_b2_bt_4_115200 },
4035         {       PCI_VENDOR_ID_SEALEVEL, PCI_DEVICE_ID_SEALEVEL_UCOMM232,
4036                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4037                 pbn_b2_bt_2_115200 },
4038         {       PCI_VENDOR_ID_SEALEVEL, PCI_DEVICE_ID_SEALEVEL_COMM4,
4039                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4040                 pbn_b2_bt_4_115200 },
4041         {       PCI_VENDOR_ID_SEALEVEL, PCI_DEVICE_ID_SEALEVEL_COMM8,
4042                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4043                 pbn_b2_8_115200 },
4044         {       PCI_VENDOR_ID_SEALEVEL, PCI_DEVICE_ID_SEALEVEL_7803,
4045                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4046                 pbn_b2_8_460800 },
4047         {       PCI_VENDOR_ID_SEALEVEL, PCI_DEVICE_ID_SEALEVEL_UCOMM8,
4048                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4049                 pbn_b2_8_115200 },
4050
4051         {       PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_GTEK_SERIAL2,
4052                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4053                 pbn_b2_bt_2_115200 },
4054         {       PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_SPCOM200,
4055                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4056                 pbn_b2_bt_2_921600 },
4057         /*
4058          * VScom SPCOM800, from sl@s.pl
4059          */
4060         {       PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_SPCOM800,
4061                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4062                 pbn_b2_8_921600 },
4063         {       PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_1077,
4064                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4065                 pbn_b2_4_921600 },
4066         /* Unknown card - subdevice 0x1584 */
4067         {       PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050,
4068                 PCI_VENDOR_ID_PLX,
4069                 PCI_SUBDEVICE_ID_UNKNOWN_0x1584, 0, 0,
4070                 pbn_b2_4_115200 },
4071         /* Unknown card - subdevice 0x1588 */
4072         {       PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050,
4073                 PCI_VENDOR_ID_PLX,
4074                 PCI_SUBDEVICE_ID_UNKNOWN_0x1588, 0, 0,
4075                 pbn_b2_8_115200 },
4076         {       PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050,
4077                 PCI_SUBVENDOR_ID_KEYSPAN,
4078                 PCI_SUBDEVICE_ID_KEYSPAN_SX2, 0, 0,
4079                 pbn_panacom },
4080         {       PCI_VENDOR_ID_PANACOM, PCI_DEVICE_ID_PANACOM_QUADMODEM,
4081                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4082                 pbn_panacom4 },
4083         {       PCI_VENDOR_ID_PANACOM, PCI_DEVICE_ID_PANACOM_DUALMODEM,
4084                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4085                 pbn_panacom2 },
4086         {       PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030,
4087                 PCI_VENDOR_ID_ESDGMBH,
4088                 PCI_DEVICE_ID_ESDGMBH_CPCIASIO4, 0, 0,
4089                 pbn_b2_4_115200 },
4090         {       PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050,
4091                 PCI_SUBVENDOR_ID_CHASE_PCIFAST,
4092                 PCI_SUBDEVICE_ID_CHASE_PCIFAST4, 0, 0,
4093                 pbn_b2_4_460800 },
4094         {       PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050,
4095                 PCI_SUBVENDOR_ID_CHASE_PCIFAST,
4096                 PCI_SUBDEVICE_ID_CHASE_PCIFAST8, 0, 0,
4097                 pbn_b2_8_460800 },
4098         {       PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050,
4099                 PCI_SUBVENDOR_ID_CHASE_PCIFAST,
4100                 PCI_SUBDEVICE_ID_CHASE_PCIFAST16, 0, 0,
4101                 pbn_b2_16_460800 },
4102         {       PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050,
4103                 PCI_SUBVENDOR_ID_CHASE_PCIFAST,
4104                 PCI_SUBDEVICE_ID_CHASE_PCIFAST16FMC, 0, 0,
4105                 pbn_b2_16_460800 },
4106         {       PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050,
4107                 PCI_SUBVENDOR_ID_CHASE_PCIRAS,
4108                 PCI_SUBDEVICE_ID_CHASE_PCIRAS4, 0, 0,
4109                 pbn_b2_4_460800 },
4110         {       PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050,
4111                 PCI_SUBVENDOR_ID_CHASE_PCIRAS,
4112                 PCI_SUBDEVICE_ID_CHASE_PCIRAS8, 0, 0,
4113                 pbn_b2_8_460800 },
4114         {       PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050,
4115                 PCI_SUBVENDOR_ID_EXSYS,
4116                 PCI_SUBDEVICE_ID_EXSYS_4055, 0, 0,
4117                 pbn_b2_4_115200 },
4118         /*
4119          * Megawolf Romulus PCI Serial Card, from Mike Hudson
4120          * (Exoray@isys.ca)
4121          */
4122         {       PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_ROMULUS,
4123                 0x10b5, 0x106a, 0, 0,
4124                 pbn_plx_romulus },
4125         /*
4126         * EndRun Technologies. PCI express device range.
4127         *    EndRun PTP/1588 has 2 Native UARTs.
4128         */
4129         {       PCI_VENDOR_ID_ENDRUN, PCI_DEVICE_ID_ENDRUN_1588,
4130                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4131                 pbn_endrun_2_3906250 },
4132         /*
4133          * Quatech cards. These actually have configurable clocks but for
4134          * now we just use the default.
4135          *
4136          * 100 series are RS232, 200 series RS422,
4137          */
4138         {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_QSC100,
4139                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4140                 pbn_b1_4_115200 },
4141         {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_DSC100,
4142                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4143                 pbn_b1_2_115200 },
4144         {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_DSC100E,
4145                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4146                 pbn_b2_2_115200 },
4147         {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_DSC200,
4148                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4149                 pbn_b1_2_115200 },
4150         {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_DSC200E,
4151                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4152                 pbn_b2_2_115200 },
4153         {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_QSC200,
4154                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4155                 pbn_b1_4_115200 },
4156         {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_ESC100D,
4157                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4158                 pbn_b1_8_115200 },
4159         {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_ESC100M,
4160                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4161                 pbn_b1_8_115200 },
4162         {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_QSCP100,
4163                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4164                 pbn_b1_4_115200 },
4165         {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_DSCP100,
4166                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4167                 pbn_b1_2_115200 },
4168         {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_QSCP200,
4169                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4170                 pbn_b1_4_115200 },
4171         {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_DSCP200,
4172                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4173                 pbn_b1_2_115200 },
4174         {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_QSCLP100,
4175                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4176                 pbn_b2_4_115200 },
4177         {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_DSCLP100,
4178                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4179                 pbn_b2_2_115200 },
4180         {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_SSCLP100,
4181                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4182                 pbn_b2_1_115200 },
4183         {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_QSCLP200,
4184                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4185                 pbn_b2_4_115200 },
4186         {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_DSCLP200,
4187                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4188                 pbn_b2_2_115200 },
4189         {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_SSCLP200,
4190                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4191                 pbn_b2_1_115200 },
4192         {       PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_ESCLP100,
4193                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4194                 pbn_b0_8_115200 },
4195
4196         {       PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_OXSEMI_16PCI954,
4197                 PCI_VENDOR_ID_SPECIALIX, PCI_SUBDEVICE_ID_SPECIALIX_SPEED4,
4198                 0, 0,
4199                 pbn_b0_4_921600 },
4200         {       PCI_VENDOR_ID_OXSEMI, PCI_DEVICE_ID_OXSEMI_16PCI954,
4201                 PCI_SUBVENDOR_ID_SIIG, PCI_SUBDEVICE_ID_SIIG_QUARTET_SERIAL,
4202                 0, 0,
4203                 pbn_b0_4_1152000 },
4204         {       PCI_VENDOR_ID_OXSEMI, 0x9505,
4205                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4206                 pbn_b0_bt_2_921600 },
4207
4208                 /*
4209                  * The below card is a little controversial since it is the
4210                  * subject of a PCI vendor/device ID clash.  (See
4211                  * www.ussg.iu.edu/hypermail/linux/kernel/0303.1/0516.html).
4212                  * For now just used the hex ID 0x950a.
4213                  */
4214         {       PCI_VENDOR_ID_OXSEMI, 0x950a,
4215                 PCI_SUBVENDOR_ID_SIIG, PCI_SUBDEVICE_ID_SIIG_DUAL_00,
4216                 0, 0, pbn_b0_2_115200 },
4217         {       PCI_VENDOR_ID_OXSEMI, 0x950a,
4218                 PCI_SUBVENDOR_ID_SIIG, PCI_SUBDEVICE_ID_SIIG_DUAL_30,
4219                 0, 0, pbn_b0_2_115200 },
4220         {       PCI_VENDOR_ID_OXSEMI, 0x950a,
4221                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4222                 pbn_b0_2_1130000 },
4223         {       PCI_VENDOR_ID_OXSEMI, PCI_DEVICE_ID_OXSEMI_C950,
4224                 PCI_VENDOR_ID_OXSEMI, PCI_SUBDEVICE_ID_OXSEMI_C950, 0, 0,
4225                 pbn_b0_1_921600 },
4226         {       PCI_VENDOR_ID_OXSEMI, PCI_DEVICE_ID_OXSEMI_16PCI954,
4227                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4228                 pbn_b0_4_115200 },
4229         {       PCI_VENDOR_ID_OXSEMI, PCI_DEVICE_ID_OXSEMI_16PCI952,
4230                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4231                 pbn_b0_bt_2_921600 },
4232         {       PCI_VENDOR_ID_OXSEMI, PCI_DEVICE_ID_OXSEMI_16PCI958,
4233                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4234                 pbn_b2_8_1152000 },
4235
4236         /*
4237          * Oxford Semiconductor Inc. Tornado PCI express device range.
4238          */
4239         {       PCI_VENDOR_ID_OXSEMI, 0xc101,    /* OXPCIe952 1 Legacy UART */
4240                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4241                 pbn_b0_1_3906250 },
4242         {       PCI_VENDOR_ID_OXSEMI, 0xc105,    /* OXPCIe952 1 Legacy UART */
4243                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4244                 pbn_b0_1_3906250 },
4245         {       PCI_VENDOR_ID_OXSEMI, 0xc11b,    /* OXPCIe952 1 Native UART */
4246                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4247                 pbn_oxsemi_1_3906250 },
4248         {       PCI_VENDOR_ID_OXSEMI, 0xc11f,    /* OXPCIe952 1 Native UART */
4249                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4250                 pbn_oxsemi_1_3906250 },
4251         {       PCI_VENDOR_ID_OXSEMI, 0xc120,    /* OXPCIe952 1 Legacy UART */
4252                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4253                 pbn_b0_1_3906250 },
4254         {       PCI_VENDOR_ID_OXSEMI, 0xc124,    /* OXPCIe952 1 Legacy UART */
4255                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4256                 pbn_b0_1_3906250 },
4257         {       PCI_VENDOR_ID_OXSEMI, 0xc138,    /* OXPCIe952 1 Native UART */
4258                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4259                 pbn_oxsemi_1_3906250 },
4260         {       PCI_VENDOR_ID_OXSEMI, 0xc13d,    /* OXPCIe952 1 Native UART */
4261                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4262                 pbn_oxsemi_1_3906250 },
4263         {       PCI_VENDOR_ID_OXSEMI, 0xc140,    /* OXPCIe952 1 Legacy UART */
4264                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4265                 pbn_b0_1_3906250 },
4266         {       PCI_VENDOR_ID_OXSEMI, 0xc141,    /* OXPCIe952 1 Legacy UART */
4267                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4268                 pbn_b0_1_3906250 },
4269         {       PCI_VENDOR_ID_OXSEMI, 0xc144,    /* OXPCIe952 1 Legacy UART */
4270                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4271                 pbn_b0_1_3906250 },
4272         {       PCI_VENDOR_ID_OXSEMI, 0xc145,    /* OXPCIe952 1 Legacy UART */
4273                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4274                 pbn_b0_1_3906250 },
4275         {       PCI_VENDOR_ID_OXSEMI, 0xc158,    /* OXPCIe952 2 Native UART */
4276                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4277                 pbn_oxsemi_2_3906250 },
4278         {       PCI_VENDOR_ID_OXSEMI, 0xc15d,    /* OXPCIe952 2 Native UART */
4279                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4280                 pbn_oxsemi_2_3906250 },
4281         {       PCI_VENDOR_ID_OXSEMI, 0xc208,    /* OXPCIe954 4 Native UART */
4282                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4283                 pbn_oxsemi_4_3906250 },
4284         {       PCI_VENDOR_ID_OXSEMI, 0xc20d,    /* OXPCIe954 4 Native UART */
4285                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4286                 pbn_oxsemi_4_3906250 },
4287         {       PCI_VENDOR_ID_OXSEMI, 0xc308,    /* OXPCIe958 8 Native UART */
4288                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4289                 pbn_oxsemi_8_3906250 },
4290         {       PCI_VENDOR_ID_OXSEMI, 0xc30d,    /* OXPCIe958 8 Native UART */
4291                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4292                 pbn_oxsemi_8_3906250 },
4293         {       PCI_VENDOR_ID_OXSEMI, 0xc40b,    /* OXPCIe200 1 Native UART */
4294                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4295                 pbn_oxsemi_1_3906250 },
4296         {       PCI_VENDOR_ID_OXSEMI, 0xc40f,    /* OXPCIe200 1 Native UART */
4297                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4298                 pbn_oxsemi_1_3906250 },
4299         {       PCI_VENDOR_ID_OXSEMI, 0xc41b,    /* OXPCIe200 1 Native UART */
4300                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4301                 pbn_oxsemi_1_3906250 },
4302         {       PCI_VENDOR_ID_OXSEMI, 0xc41f,    /* OXPCIe200 1 Native UART */
4303                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4304                 pbn_oxsemi_1_3906250 },
4305         {       PCI_VENDOR_ID_OXSEMI, 0xc42b,    /* OXPCIe200 1 Native UART */
4306                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4307                 pbn_oxsemi_1_3906250 },
4308         {       PCI_VENDOR_ID_OXSEMI, 0xc42f,    /* OXPCIe200 1 Native UART */
4309                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4310                 pbn_oxsemi_1_3906250 },
4311         {       PCI_VENDOR_ID_OXSEMI, 0xc43b,    /* OXPCIe200 1 Native UART */
4312                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4313                 pbn_oxsemi_1_3906250 },
4314         {       PCI_VENDOR_ID_OXSEMI, 0xc43f,    /* OXPCIe200 1 Native UART */
4315                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4316                 pbn_oxsemi_1_3906250 },
4317         {       PCI_VENDOR_ID_OXSEMI, 0xc44b,    /* OXPCIe200 1 Native UART */
4318                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4319                 pbn_oxsemi_1_3906250 },
4320         {       PCI_VENDOR_ID_OXSEMI, 0xc44f,    /* OXPCIe200 1 Native UART */
4321                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4322                 pbn_oxsemi_1_3906250 },
4323         {       PCI_VENDOR_ID_OXSEMI, 0xc45b,    /* OXPCIe200 1 Native UART */
4324                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4325                 pbn_oxsemi_1_3906250 },
4326         {       PCI_VENDOR_ID_OXSEMI, 0xc45f,    /* OXPCIe200 1 Native UART */
4327                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4328                 pbn_oxsemi_1_3906250 },
4329         {       PCI_VENDOR_ID_OXSEMI, 0xc46b,    /* OXPCIe200 1 Native UART */
4330                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4331                 pbn_oxsemi_1_3906250 },
4332         {       PCI_VENDOR_ID_OXSEMI, 0xc46f,    /* OXPCIe200 1 Native UART */
4333                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4334                 pbn_oxsemi_1_3906250 },
4335         {       PCI_VENDOR_ID_OXSEMI, 0xc47b,    /* OXPCIe200 1 Native UART */
4336                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4337                 pbn_oxsemi_1_3906250 },
4338         {       PCI_VENDOR_ID_OXSEMI, 0xc47f,    /* OXPCIe200 1 Native UART */
4339                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4340                 pbn_oxsemi_1_3906250 },
4341         {       PCI_VENDOR_ID_OXSEMI, 0xc48b,    /* OXPCIe200 1 Native UART */
4342                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4343                 pbn_oxsemi_1_3906250 },
4344         {       PCI_VENDOR_ID_OXSEMI, 0xc48f,    /* OXPCIe200 1 Native UART */
4345                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4346                 pbn_oxsemi_1_3906250 },
4347         {       PCI_VENDOR_ID_OXSEMI, 0xc49b,    /* OXPCIe200 1 Native UART */
4348                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4349                 pbn_oxsemi_1_3906250 },
4350         {       PCI_VENDOR_ID_OXSEMI, 0xc49f,    /* OXPCIe200 1 Native UART */
4351                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4352                 pbn_oxsemi_1_3906250 },
4353         {       PCI_VENDOR_ID_OXSEMI, 0xc4ab,    /* OXPCIe200 1 Native UART */
4354                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4355                 pbn_oxsemi_1_3906250 },
4356         {       PCI_VENDOR_ID_OXSEMI, 0xc4af,    /* OXPCIe200 1 Native UART */
4357                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4358                 pbn_oxsemi_1_3906250 },
4359         {       PCI_VENDOR_ID_OXSEMI, 0xc4bb,    /* OXPCIe200 1 Native UART */
4360                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4361                 pbn_oxsemi_1_3906250 },
4362         {       PCI_VENDOR_ID_OXSEMI, 0xc4bf,    /* OXPCIe200 1 Native UART */
4363                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4364                 pbn_oxsemi_1_3906250 },
4365         {       PCI_VENDOR_ID_OXSEMI, 0xc4cb,    /* OXPCIe200 1 Native UART */
4366                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4367                 pbn_oxsemi_1_3906250 },
4368         {       PCI_VENDOR_ID_OXSEMI, 0xc4cf,    /* OXPCIe200 1 Native UART */
4369                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4370                 pbn_oxsemi_1_3906250 },
4371         /*
4372          * Mainpine Inc. IQ Express "Rev3" utilizing OxSemi Tornado
4373          */
4374         {       PCI_VENDOR_ID_MAINPINE, 0x4000, /* IQ Express 1 Port V.34 Super-G3 Fax */
4375                 PCI_VENDOR_ID_MAINPINE, 0x4001, 0, 0,
4376                 pbn_oxsemi_1_3906250 },
4377         {       PCI_VENDOR_ID_MAINPINE, 0x4000, /* IQ Express 2 Port V.34 Super-G3 Fax */
4378                 PCI_VENDOR_ID_MAINPINE, 0x4002, 0, 0,
4379                 pbn_oxsemi_2_3906250 },
4380         {       PCI_VENDOR_ID_MAINPINE, 0x4000, /* IQ Express 4 Port V.34 Super-G3 Fax */
4381                 PCI_VENDOR_ID_MAINPINE, 0x4004, 0, 0,
4382                 pbn_oxsemi_4_3906250 },
4383         {       PCI_VENDOR_ID_MAINPINE, 0x4000, /* IQ Express 8 Port V.34 Super-G3 Fax */
4384                 PCI_VENDOR_ID_MAINPINE, 0x4008, 0, 0,
4385                 pbn_oxsemi_8_3906250 },
4386
4387         /*
4388          * Digi/IBM PCIe 2-port Async EIA-232 Adapter utilizing OxSemi Tornado
4389          */
4390         {       PCI_VENDOR_ID_DIGI, PCIE_DEVICE_ID_NEO_2_OX_IBM,
4391                 PCI_SUBVENDOR_ID_IBM, PCI_ANY_ID, 0, 0,
4392                 pbn_oxsemi_2_3906250 },
4393
4394         /*
4395          * SBS Technologies, Inc. P-Octal and PMC-OCTPRO cards,
4396          * from skokodyn@yahoo.com
4397          */
4398         {       PCI_VENDOR_ID_SBSMODULARIO, PCI_DEVICE_ID_OCTPRO,
4399                 PCI_SUBVENDOR_ID_SBSMODULARIO, PCI_SUBDEVICE_ID_OCTPRO232, 0, 0,
4400                 pbn_sbsxrsio },
4401         {       PCI_VENDOR_ID_SBSMODULARIO, PCI_DEVICE_ID_OCTPRO,
4402                 PCI_SUBVENDOR_ID_SBSMODULARIO, PCI_SUBDEVICE_ID_OCTPRO422, 0, 0,
4403                 pbn_sbsxrsio },
4404         {       PCI_VENDOR_ID_SBSMODULARIO, PCI_DEVICE_ID_OCTPRO,
4405                 PCI_SUBVENDOR_ID_SBSMODULARIO, PCI_SUBDEVICE_ID_POCTAL232, 0, 0,
4406                 pbn_sbsxrsio },
4407         {       PCI_VENDOR_ID_SBSMODULARIO, PCI_DEVICE_ID_OCTPRO,
4408                 PCI_SUBVENDOR_ID_SBSMODULARIO, PCI_SUBDEVICE_ID_POCTAL422, 0, 0,
4409                 pbn_sbsxrsio },
4410
4411         /*
4412          * Digitan DS560-558, from jimd@esoft.com
4413          */
4414         {       PCI_VENDOR_ID_ATT, PCI_DEVICE_ID_ATT_VENUS_MODEM,
4415                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4416                 pbn_b1_1_115200 },
4417
4418         /*
4419          * Titan Electronic cards
4420          *  The 400L and 800L have a custom setup quirk.
4421          */
4422         {       PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_100,
4423                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4424                 pbn_b0_1_921600 },
4425         {       PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_200,
4426                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4427                 pbn_b0_2_921600 },
4428         {       PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_400,
4429                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4430                 pbn_b0_4_921600 },
4431         {       PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_800B,
4432                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4433                 pbn_b0_4_921600 },
4434         {       PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_100L,
4435                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4436                 pbn_b1_1_921600 },
4437         {       PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_200L,
4438                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4439                 pbn_b1_bt_2_921600 },
4440         {       PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_400L,
4441                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4442                 pbn_b0_bt_4_921600 },
4443         {       PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_800L,
4444                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4445                 pbn_b0_bt_8_921600 },
4446         {       PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_200I,
4447                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4448                 pbn_b4_bt_2_921600 },
4449         {       PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_400I,
4450                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4451                 pbn_b4_bt_4_921600 },
4452         {       PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_800I,
4453                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4454                 pbn_b4_bt_8_921600 },
4455         {       PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_400EH,
4456                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4457                 pbn_b0_4_921600 },
4458         {       PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_800EH,
4459                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4460                 pbn_b0_4_921600 },
4461         {       PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_800EHB,
4462                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4463                 pbn_b0_4_921600 },
4464         {       PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_100E,
4465                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4466                 pbn_titan_1_4000000 },
4467         {       PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_200E,
4468                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4469                 pbn_titan_2_4000000 },
4470         {       PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_400E,
4471                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4472                 pbn_titan_4_4000000 },
4473         {       PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_800E,
4474                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4475                 pbn_titan_8_4000000 },
4476         {       PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_200EI,
4477                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4478                 pbn_titan_2_4000000 },
4479         {       PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_200EISI,
4480                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4481                 pbn_titan_2_4000000 },
4482         {       PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_200V3,
4483                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4484                 pbn_b0_bt_2_921600 },
4485         {       PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_400V3,
4486                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4487                 pbn_b0_4_921600 },
4488         {       PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_410V3,
4489                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4490                 pbn_b0_4_921600 },
4491         {       PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_800V3,
4492                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4493                 pbn_b0_4_921600 },
4494         {       PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_800V3B,
4495                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4496                 pbn_b0_4_921600 },
4497
4498         {       PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1S_10x_550,
4499                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4500                 pbn_b2_1_460800 },
4501         {       PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1S_10x_650,
4502                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4503                 pbn_b2_1_460800 },
4504         {       PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1S_10x_850,
4505                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4506                 pbn_b2_1_460800 },
4507         {       PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2S_10x_550,
4508                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4509                 pbn_b2_bt_2_921600 },
4510         {       PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2S_10x_650,
4511                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4512                 pbn_b2_bt_2_921600 },
4513         {       PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2S_10x_850,
4514                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4515                 pbn_b2_bt_2_921600 },
4516         {       PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_4S_10x_550,
4517                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4518                 pbn_b2_bt_4_921600 },
4519         {       PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_4S_10x_650,
4520                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4521                 pbn_b2_bt_4_921600 },
4522         {       PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_4S_10x_850,
4523                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4524                 pbn_b2_bt_4_921600 },
4525         {       PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1S_20x_550,
4526                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4527                 pbn_b0_1_921600 },
4528         {       PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1S_20x_650,
4529                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4530                 pbn_b0_1_921600 },
4531         {       PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1S_20x_850,
4532                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4533                 pbn_b0_1_921600 },
4534         {       PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2S_20x_550,
4535                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4536                 pbn_b0_bt_2_921600 },
4537         {       PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2S_20x_650,
4538                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4539                 pbn_b0_bt_2_921600 },
4540         {       PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2S_20x_850,
4541                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4542                 pbn_b0_bt_2_921600 },
4543         {       PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_4S_20x_550,
4544                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4545                 pbn_b0_bt_4_921600 },
4546         {       PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_4S_20x_650,
4547                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4548                 pbn_b0_bt_4_921600 },
4549         {       PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_4S_20x_850,
4550                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4551                 pbn_b0_bt_4_921600 },
4552         {       PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_8S_20x_550,
4553                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4554                 pbn_b0_bt_8_921600 },
4555         {       PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_8S_20x_650,
4556                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4557                 pbn_b0_bt_8_921600 },
4558         {       PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_8S_20x_850,
4559                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4560                 pbn_b0_bt_8_921600 },
4561
4562         /*
4563          * Computone devices submitted by Doug McNash dmcnash@computone.com
4564          */
4565         {       PCI_VENDOR_ID_COMPUTONE, PCI_DEVICE_ID_COMPUTONE_PG,
4566                 PCI_SUBVENDOR_ID_COMPUTONE, PCI_SUBDEVICE_ID_COMPUTONE_PG4,
4567                 0, 0, pbn_computone_4 },
4568         {       PCI_VENDOR_ID_COMPUTONE, PCI_DEVICE_ID_COMPUTONE_PG,
4569                 PCI_SUBVENDOR_ID_COMPUTONE, PCI_SUBDEVICE_ID_COMPUTONE_PG8,
4570                 0, 0, pbn_computone_8 },
4571         {       PCI_VENDOR_ID_COMPUTONE, PCI_DEVICE_ID_COMPUTONE_PG,
4572                 PCI_SUBVENDOR_ID_COMPUTONE, PCI_SUBDEVICE_ID_COMPUTONE_PG6,
4573                 0, 0, pbn_computone_6 },
4574
4575         {       PCI_VENDOR_ID_OXSEMI, PCI_DEVICE_ID_OXSEMI_16PCI95N,
4576                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4577                 pbn_oxsemi },
4578         {       PCI_VENDOR_ID_TIMEDIA, PCI_DEVICE_ID_TIMEDIA_1889,
4579                 PCI_VENDOR_ID_TIMEDIA, PCI_ANY_ID, 0, 0,
4580                 pbn_b0_bt_1_921600 },
4581
4582         /*
4583          * Sunix PCI serial boards
4584          */
4585         {       PCI_VENDOR_ID_SUNIX, PCI_DEVICE_ID_SUNIX_1999,
4586                 PCI_VENDOR_ID_SUNIX, 0x0001, 0, 0,
4587                 pbn_sunix_pci_1s },
4588         {       PCI_VENDOR_ID_SUNIX, PCI_DEVICE_ID_SUNIX_1999,
4589                 PCI_VENDOR_ID_SUNIX, 0x0002, 0, 0,
4590                 pbn_sunix_pci_2s },
4591         {       PCI_VENDOR_ID_SUNIX, PCI_DEVICE_ID_SUNIX_1999,
4592                 PCI_VENDOR_ID_SUNIX, 0x0004, 0, 0,
4593                 pbn_sunix_pci_4s },
4594         {       PCI_VENDOR_ID_SUNIX, PCI_DEVICE_ID_SUNIX_1999,
4595                 PCI_VENDOR_ID_SUNIX, 0x0084, 0, 0,
4596                 pbn_sunix_pci_4s },
4597         {       PCI_VENDOR_ID_SUNIX, PCI_DEVICE_ID_SUNIX_1999,
4598                 PCI_VENDOR_ID_SUNIX, 0x0008, 0, 0,
4599                 pbn_sunix_pci_8s },
4600         {       PCI_VENDOR_ID_SUNIX, PCI_DEVICE_ID_SUNIX_1999,
4601                 PCI_VENDOR_ID_SUNIX, 0x0088, 0, 0,
4602                 pbn_sunix_pci_8s },
4603         {       PCI_VENDOR_ID_SUNIX, PCI_DEVICE_ID_SUNIX_1999,
4604                 PCI_VENDOR_ID_SUNIX, 0x0010, 0, 0,
4605                 pbn_sunix_pci_16s },
4606
4607         /*
4608          * AFAVLAB serial card, from Harald Welte <laforge@gnumonks.org>
4609          */
4610         {       PCI_VENDOR_ID_AFAVLAB, PCI_DEVICE_ID_AFAVLAB_P028,
4611                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4612                 pbn_b0_bt_8_115200 },
4613         {       PCI_VENDOR_ID_AFAVLAB, PCI_DEVICE_ID_AFAVLAB_P030,
4614                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4615                 pbn_b0_bt_8_115200 },
4616
4617         {       PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_DSERIAL,
4618                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4619                 pbn_b0_bt_2_115200 },
4620         {       PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_QUATRO_A,
4621                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4622                 pbn_b0_bt_2_115200 },
4623         {       PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_QUATRO_B,
4624                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4625                 pbn_b0_bt_2_115200 },
4626         {       PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_QUATTRO_A,
4627                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4628                 pbn_b0_bt_2_115200 },
4629         {       PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_QUATTRO_B,
4630                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4631                 pbn_b0_bt_2_115200 },
4632         {       PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_OCTO_A,
4633                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4634                 pbn_b0_bt_4_460800 },
4635         {       PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_OCTO_B,
4636                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4637                 pbn_b0_bt_4_460800 },
4638         {       PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_PORT_PLUS,
4639                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4640                 pbn_b0_bt_2_460800 },
4641         {       PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_QUAD_A,
4642                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4643                 pbn_b0_bt_2_460800 },
4644         {       PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_QUAD_B,
4645                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4646                 pbn_b0_bt_2_460800 },
4647         {       PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_SSERIAL,
4648                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4649                 pbn_b0_bt_1_115200 },
4650         {       PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_PORT_650,
4651                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4652                 pbn_b0_bt_1_460800 },
4653
4654         /*
4655          * Korenix Jetcard F0/F1 cards (JC1204, JC1208, JC1404, JC1408).
4656          * Cards are identified by their subsystem vendor IDs, which
4657          * (in hex) match the model number.
4658          *
4659          * Note that JC140x are RS422/485 cards which require ox950
4660          * ACR = 0x10, and as such are not currently fully supported.
4661          */
4662         {       PCI_VENDOR_ID_KORENIX, PCI_DEVICE_ID_KORENIX_JETCARDF0,
4663                 0x1204, 0x0004, 0, 0,
4664                 pbn_b0_4_921600 },
4665         {       PCI_VENDOR_ID_KORENIX, PCI_DEVICE_ID_KORENIX_JETCARDF0,
4666                 0x1208, 0x0004, 0, 0,
4667                 pbn_b0_4_921600 },
4668 /*      {       PCI_VENDOR_ID_KORENIX, PCI_DEVICE_ID_KORENIX_JETCARDF0,
4669                 0x1402, 0x0002, 0, 0,
4670                 pbn_b0_2_921600 }, */
4671 /*      {       PCI_VENDOR_ID_KORENIX, PCI_DEVICE_ID_KORENIX_JETCARDF0,
4672                 0x1404, 0x0004, 0, 0,
4673                 pbn_b0_4_921600 }, */
4674         {       PCI_VENDOR_ID_KORENIX, PCI_DEVICE_ID_KORENIX_JETCARDF1,
4675                 0x1208, 0x0004, 0, 0,
4676                 pbn_b0_4_921600 },
4677
4678         {       PCI_VENDOR_ID_KORENIX, PCI_DEVICE_ID_KORENIX_JETCARDF2,
4679                 0x1204, 0x0004, 0, 0,
4680                 pbn_b0_4_921600 },
4681         {       PCI_VENDOR_ID_KORENIX, PCI_DEVICE_ID_KORENIX_JETCARDF2,
4682                 0x1208, 0x0004, 0, 0,
4683                 pbn_b0_4_921600 },
4684         {       PCI_VENDOR_ID_KORENIX, PCI_DEVICE_ID_KORENIX_JETCARDF3,
4685                 0x1208, 0x0004, 0, 0,
4686                 pbn_b0_4_921600 },
4687         /*
4688          * Dell Remote Access Card 4 - Tim_T_Murphy@Dell.com
4689          */
4690         {       PCI_VENDOR_ID_DELL, PCI_DEVICE_ID_DELL_RAC4,
4691                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4692                 pbn_b1_1_1382400 },
4693
4694         /*
4695          * Dell Remote Access Card III - Tim_T_Murphy@Dell.com
4696          */
4697         {       PCI_VENDOR_ID_DELL, PCI_DEVICE_ID_DELL_RACIII,
4698                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4699                 pbn_b1_1_1382400 },
4700
4701         /*
4702          * RAStel 2 port modem, gerg@moreton.com.au
4703          */
4704         {       PCI_VENDOR_ID_MORETON, PCI_DEVICE_ID_RASTEL_2PORT,
4705                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4706                 pbn_b2_bt_2_115200 },
4707
4708         /*
4709          * EKF addition for i960 Boards form EKF with serial port
4710          */
4711         {       PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_80960_RP,
4712                 0xE4BF, PCI_ANY_ID, 0, 0,
4713                 pbn_intel_i960 },
4714
4715         /*
4716          * Xircom Cardbus/Ethernet combos
4717          */
4718         {       PCI_VENDOR_ID_XIRCOM, PCI_DEVICE_ID_XIRCOM_X3201_MDM,
4719                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4720                 pbn_b0_1_115200 },
4721         /*
4722          * Xircom RBM56G cardbus modem - Dirk Arnold (temp entry)
4723          */
4724         {       PCI_VENDOR_ID_XIRCOM, PCI_DEVICE_ID_XIRCOM_RBM56G,
4725                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4726                 pbn_b0_1_115200 },
4727
4728         /*
4729          * Untested PCI modems, sent in from various folks...
4730          */
4731
4732         /*
4733          * Elsa Model 56K PCI Modem, from Andreas Rath <arh@01019freenet.de>
4734          */
4735         {       PCI_VENDOR_ID_ROCKWELL, 0x1004,
4736                 0x1048, 0x1500, 0, 0,
4737                 pbn_b1_1_115200 },
4738
4739         {       PCI_VENDOR_ID_SGI, PCI_DEVICE_ID_SGI_IOC3,
4740                 0xFF00, 0, 0, 0,
4741                 pbn_sgi_ioc3 },
4742
4743         /*
4744          * HP Diva card
4745          */
4746         {       PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_DIVA,
4747                 PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_DIVA_RMP3, 0, 0,
4748                 pbn_b1_1_115200 },
4749         {       PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_DIVA,
4750                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4751                 pbn_b0_5_115200 },
4752         {       PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_DIVA_AUX,
4753                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4754                 pbn_b2_1_115200 },
4755         /* HPE PCI serial device */
4756         {       PCI_VENDOR_ID_HP_3PAR, PCI_DEVICE_ID_HPE_PCI_SERIAL,
4757                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4758                 pbn_b1_1_115200 },
4759
4760         {       PCI_VENDOR_ID_DCI, PCI_DEVICE_ID_DCI_PCCOM2,
4761                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4762                 pbn_b3_2_115200 },
4763         {       PCI_VENDOR_ID_DCI, PCI_DEVICE_ID_DCI_PCCOM4,
4764                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4765                 pbn_b3_4_115200 },
4766         {       PCI_VENDOR_ID_DCI, PCI_DEVICE_ID_DCI_PCCOM8,
4767                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4768                 pbn_b3_8_115200 },
4769         /*
4770          * Topic TP560 Data/Fax/Voice 56k modem (reported by Evan Clarke)
4771          */
4772         {       PCI_VENDOR_ID_TOPIC, PCI_DEVICE_ID_TOPIC_TP560,
4773                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
4774                 pbn_b0_1_115200 },
4775         /*
4776          * ITE
4777          */
4778         {       PCI_VENDOR_ID_ITE, PCI_DEVICE_ID_ITE_8872,
4779                 PCI_ANY_ID, PCI_ANY_ID,
4780                 0, 0,
4781                 pbn_b1_bt_1_115200 },
4782
4783         /*
4784          * IntaShield IS-200
4785          */
4786         {       PCI_VENDOR_ID_INTASHIELD, PCI_DEVICE_ID_INTASHIELD_IS200,
4787                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,   /* 135a.0811 */
4788                 pbn_b2_2_115200 },
4789         /*
4790          * IntaShield IS-400
4791          */
4792         {       PCI_VENDOR_ID_INTASHIELD, PCI_DEVICE_ID_INTASHIELD_IS400,
4793                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,    /* 135a.0dc0 */
4794                 pbn_b2_4_115200 },
4795         /* Brainboxes Devices */
4796         /*
4797         * Brainboxes UC-101
4798         */
4799         {       PCI_VENDOR_ID_INTASHIELD, 0x0BA1,
4800                 PCI_ANY_ID, PCI_ANY_ID,
4801                 0, 0,
4802                 pbn_b2_2_115200 },
4803         /*
4804          * Brainboxes UC-235/246
4805          */
4806         {       PCI_VENDOR_ID_INTASHIELD, 0x0AA1,
4807                 PCI_ANY_ID, PCI_ANY_ID,
4808                 0, 0,
4809                 pbn_b2_1_115200 },
4810         /*
4811          * Brainboxes UC-257
4812          */
4813         {       PCI_VENDOR_ID_INTASHIELD, 0x0861,
4814                 PCI_ANY_ID, PCI_ANY_ID,
4815                 0, 0,
4816                 pbn_b2_2_115200 },
4817         /*
4818          * Brainboxes UC-260/271/701/756
4819          */
4820         {       PCI_VENDOR_ID_INTASHIELD, 0x0D21,
4821                 PCI_ANY_ID, PCI_ANY_ID,
4822                 PCI_CLASS_COMMUNICATION_MULTISERIAL << 8, 0xffff00,
4823                 pbn_b2_4_115200 },
4824         {       PCI_VENDOR_ID_INTASHIELD, 0x0E34,
4825                 PCI_ANY_ID, PCI_ANY_ID,
4826                 PCI_CLASS_COMMUNICATION_MULTISERIAL << 8, 0xffff00,
4827                 pbn_b2_4_115200 },
4828         /*
4829          * Brainboxes UC-268
4830          */
4831         {       PCI_VENDOR_ID_INTASHIELD, 0x0841,
4832                 PCI_ANY_ID, PCI_ANY_ID,
4833                 0, 0,
4834                 pbn_b2_4_115200 },
4835         /*
4836          * Brainboxes UC-275/279
4837          */
4838         {       PCI_VENDOR_ID_INTASHIELD, 0x0881,
4839                 PCI_ANY_ID, PCI_ANY_ID,
4840                 0, 0,
4841                 pbn_b2_8_115200 },
4842         /*
4843          * Brainboxes UC-302
4844          */
4845         {       PCI_VENDOR_ID_INTASHIELD, 0x08E1,
4846                 PCI_ANY_ID, PCI_ANY_ID,
4847                 0, 0,
4848                 pbn_b2_2_115200 },
4849         /*
4850          * Brainboxes UC-310
4851          */
4852         {       PCI_VENDOR_ID_INTASHIELD, 0x08C1,
4853                 PCI_ANY_ID, PCI_ANY_ID,
4854                 0, 0,
4855                 pbn_b2_2_115200 },
4856         /*
4857          * Brainboxes UC-313
4858          */
4859         {       PCI_VENDOR_ID_INTASHIELD, 0x08A3,
4860                 PCI_ANY_ID, PCI_ANY_ID,
4861                 0, 0,
4862                 pbn_b2_2_115200 },
4863         /*
4864          * Brainboxes UC-320/324
4865          */
4866         {       PCI_VENDOR_ID_INTASHIELD, 0x0A61,
4867                 PCI_ANY_ID, PCI_ANY_ID,
4868                 0, 0,
4869                 pbn_b2_1_115200 },
4870         /*
4871          * Brainboxes UC-346
4872          */
4873         {       PCI_VENDOR_ID_INTASHIELD, 0x0B02,
4874                 PCI_ANY_ID, PCI_ANY_ID,
4875                 0, 0,
4876                 pbn_b2_4_115200 },
4877         /*
4878          * Brainboxes UC-357
4879          */
4880         {       PCI_VENDOR_ID_INTASHIELD, 0x0A81,
4881                 PCI_ANY_ID, PCI_ANY_ID,
4882                 0, 0,
4883                 pbn_b2_2_115200 },
4884         {       PCI_VENDOR_ID_INTASHIELD, 0x0A83,
4885                 PCI_ANY_ID, PCI_ANY_ID,
4886                 0, 0,
4887                 pbn_b2_2_115200 },
4888         /*
4889          * Brainboxes UC-368
4890          */
4891         {       PCI_VENDOR_ID_INTASHIELD, 0x0C41,
4892                 PCI_ANY_ID, PCI_ANY_ID,
4893                 0, 0,
4894                 pbn_b2_4_115200 },
4895         /*
4896          * Brainboxes UC-420/431
4897          */
4898         {       PCI_VENDOR_ID_INTASHIELD, 0x0921,
4899                 PCI_ANY_ID, PCI_ANY_ID,
4900                 0, 0,
4901                 pbn_b2_4_115200 },
4902         /*
4903          * Perle PCI-RAS cards
4904          */
4905         {       PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030,
4906                 PCI_SUBVENDOR_ID_PERLE, PCI_SUBDEVICE_ID_PCI_RAS4,
4907                 0, 0, pbn_b2_4_921600 },
4908         {       PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030,
4909                 PCI_SUBVENDOR_ID_PERLE, PCI_SUBDEVICE_ID_PCI_RAS8,
4910                 0, 0, pbn_b2_8_921600 },
4911
4912         /*
4913          * Mainpine series cards: Fairly standard layout but fools
4914          * parts of the autodetect in some cases and uses otherwise
4915          * unmatched communications subclasses in the PCI Express case
4916          */
4917
4918         {       /* RockForceDUO */
4919                 PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
4920                 PCI_VENDOR_ID_MAINPINE, 0x0200,
4921                 0, 0, pbn_b0_2_115200 },
4922         {       /* RockForceQUATRO */
4923                 PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
4924                 PCI_VENDOR_ID_MAINPINE, 0x0300,
4925                 0, 0, pbn_b0_4_115200 },
4926         {       /* RockForceDUO+ */
4927                 PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
4928                 PCI_VENDOR_ID_MAINPINE, 0x0400,
4929                 0, 0, pbn_b0_2_115200 },
4930         {       /* RockForceQUATRO+ */
4931                 PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
4932                 PCI_VENDOR_ID_MAINPINE, 0x0500,
4933                 0, 0, pbn_b0_4_115200 },
4934         {       /* RockForce+ */
4935                 PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
4936                 PCI_VENDOR_ID_MAINPINE, 0x0600,
4937                 0, 0, pbn_b0_2_115200 },
4938         {       /* RockForce+ */
4939                 PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
4940                 PCI_VENDOR_ID_MAINPINE, 0x0700,
4941                 0, 0, pbn_b0_4_115200 },
4942         {       /* RockForceOCTO+ */
4943                 PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
4944                 PCI_VENDOR_ID_MAINPINE, 0x0800,
4945                 0, 0, pbn_b0_8_115200 },
4946         {       /* RockForceDUO+ */
4947                 PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
4948                 PCI_VENDOR_ID_MAINPINE, 0x0C00,
4949                 0, 0, pbn_b0_2_115200 },
4950         {       /* RockForceQUARTRO+ */
4951                 PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
4952                 PCI_VENDOR_ID_MAINPINE, 0x0D00,
4953                 0, 0, pbn_b0_4_115200 },
4954         {       /* RockForceOCTO+ */
4955                 PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
4956                 PCI_VENDOR_ID_MAINPINE, 0x1D00,
4957                 0, 0, pbn_b0_8_115200 },
4958         {       /* RockForceD1 */
4959                 PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
4960                 PCI_VENDOR_ID_MAINPINE, 0x2000,
4961                 0, 0, pbn_b0_1_115200 },
4962         {       /* RockForceF1 */
4963                 PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
4964                 PCI_VENDOR_ID_MAINPINE, 0x2100,
4965                 0, 0, pbn_b0_1_115200 },
4966         {       /* RockForceD2 */
4967                 PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
4968                 PCI_VENDOR_ID_MAINPINE, 0x2200,
4969                 0, 0, pbn_b0_2_115200 },
4970         {       /* RockForceF2 */
4971                 PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
4972                 PCI_VENDOR_ID_MAINPINE, 0x2300,
4973                 0, 0, pbn_b0_2_115200 },
4974         {       /* RockForceD4 */
4975                 PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
4976                 PCI_VENDOR_ID_MAINPINE, 0x2400,
4977                 0, 0, pbn_b0_4_115200 },
4978         {       /* RockForceF4 */
4979                 PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
4980                 PCI_VENDOR_ID_MAINPINE, 0x2500,
4981                 0, 0, pbn_b0_4_115200 },
4982         {       /* RockForceD8 */
4983                 PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
4984                 PCI_VENDOR_ID_MAINPINE, 0x2600,
4985                 0, 0, pbn_b0_8_115200 },
4986         {       /* RockForceF8 */
4987                 PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
4988                 PCI_VENDOR_ID_MAINPINE, 0x2700,
4989                 0, 0, pbn_b0_8_115200 },
4990         {       /* IQ Express D1 */
4991                 PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
4992                 PCI_VENDOR_ID_MAINPINE, 0x3000,
4993                 0, 0, pbn_b0_1_115200 },
4994         {       /* IQ Express F1 */
4995                 PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
4996                 PCI_VENDOR_ID_MAINPINE, 0x3100,
4997                 0, 0, pbn_b0_1_115200 },
4998         {       /* IQ Express D2 */
4999                 PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
5000                 PCI_VENDOR_ID_MAINPINE, 0x3200,
5001                 0, 0, pbn_b0_2_115200 },
5002         {       /* IQ Express F2 */
5003                 PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
5004                 PCI_VENDOR_ID_MAINPINE, 0x3300,
5005                 0, 0, pbn_b0_2_115200 },
5006         {       /* IQ Express D4 */
5007                 PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
5008                 PCI_VENDOR_ID_MAINPINE, 0x3400,
5009                 0, 0, pbn_b0_4_115200 },
5010         {       /* IQ Express F4 */
5011                 PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
5012                 PCI_VENDOR_ID_MAINPINE, 0x3500,
5013                 0, 0, pbn_b0_4_115200 },
5014         {       /* IQ Express D8 */
5015                 PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
5016                 PCI_VENDOR_ID_MAINPINE, 0x3C00,
5017                 0, 0, pbn_b0_8_115200 },
5018         {       /* IQ Express F8 */
5019                 PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
5020                 PCI_VENDOR_ID_MAINPINE, 0x3D00,
5021                 0, 0, pbn_b0_8_115200 },
5022
5023
5024         /*
5025          * PA Semi PA6T-1682M on-chip UART
5026          */
5027         {       PCI_VENDOR_ID_PASEMI, 0xa004,
5028                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5029                 pbn_pasemi_1682M },
5030
5031         /*
5032          * National Instruments
5033          */
5034         {       PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PCI23216,
5035                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5036                 pbn_b1_16_115200 },
5037         {       PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PCI2328,
5038                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5039                 pbn_b1_8_115200 },
5040         {       PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PCI2324,
5041                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5042                 pbn_b1_bt_4_115200 },
5043         {       PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PCI2322,
5044                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5045                 pbn_b1_bt_2_115200 },
5046         {       PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PCI2324I,
5047                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5048                 pbn_b1_bt_4_115200 },
5049         {       PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PCI2322I,
5050                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5051                 pbn_b1_bt_2_115200 },
5052         {       PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PXI8420_23216,
5053                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5054                 pbn_b1_16_115200 },
5055         {       PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PXI8420_2328,
5056                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5057                 pbn_b1_8_115200 },
5058         {       PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PXI8420_2324,
5059                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5060                 pbn_b1_bt_4_115200 },
5061         {       PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PXI8420_2322,
5062                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5063                 pbn_b1_bt_2_115200 },
5064         {       PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PXI8422_2324,
5065                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5066                 pbn_b1_bt_4_115200 },
5067         {       PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PXI8422_2322,
5068                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5069                 pbn_b1_bt_2_115200 },
5070         {       PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PXI8430_2322,
5071                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5072                 pbn_ni8430_2 },
5073         {       PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PCI8430_2322,
5074                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5075                 pbn_ni8430_2 },
5076         {       PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PXI8430_2324,
5077                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5078                 pbn_ni8430_4 },
5079         {       PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PCI8430_2324,
5080                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5081                 pbn_ni8430_4 },
5082         {       PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PXI8430_2328,
5083                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5084                 pbn_ni8430_8 },
5085         {       PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PCI8430_2328,
5086                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5087                 pbn_ni8430_8 },
5088         {       PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PXI8430_23216,
5089                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5090                 pbn_ni8430_16 },
5091         {       PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PCI8430_23216,
5092                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5093                 pbn_ni8430_16 },
5094         {       PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PXI8432_2322,
5095                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5096                 pbn_ni8430_2 },
5097         {       PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PCI8432_2322,
5098                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5099                 pbn_ni8430_2 },
5100         {       PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PXI8432_2324,
5101                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5102                 pbn_ni8430_4 },
5103         {       PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PCI8432_2324,
5104                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5105                 pbn_ni8430_4 },
5106
5107         /*
5108          * MOXA
5109          */
5110         {       PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP102E,
5111                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5112                 pbn_moxa8250_2p },
5113         {       PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP102EL,
5114                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5115                 pbn_moxa8250_2p },
5116         {       PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP104EL_A,
5117                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5118                 pbn_moxa8250_4p },
5119         {       PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP114EL,
5120                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5121                 pbn_moxa8250_4p },
5122         {       PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP116E_A_A,
5123                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5124                 pbn_moxa8250_8p },
5125         {       PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP116E_A_B,
5126                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5127                 pbn_moxa8250_8p },
5128         {       PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP118EL_A,
5129                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5130                 pbn_moxa8250_8p },
5131         {       PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP118E_A_I,
5132                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5133                 pbn_moxa8250_8p },
5134         {       PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP132EL,
5135                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5136                 pbn_moxa8250_2p },
5137         {       PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP134EL_A,
5138                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5139                 pbn_moxa8250_4p },
5140         {       PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP138E_A,
5141                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5142                 pbn_moxa8250_8p },
5143         {       PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP168EL_A,
5144                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5145                 pbn_moxa8250_8p },
5146
5147         /*
5148         * ADDI-DATA GmbH communication cards <info@addi-data.com>
5149         */
5150         {       PCI_VENDOR_ID_ADDIDATA,
5151                 PCI_DEVICE_ID_ADDIDATA_APCI7500,
5152                 PCI_ANY_ID,
5153                 PCI_ANY_ID,
5154                 0,
5155                 0,
5156                 pbn_b0_4_115200 },
5157
5158         {       PCI_VENDOR_ID_ADDIDATA,
5159                 PCI_DEVICE_ID_ADDIDATA_APCI7420,
5160                 PCI_ANY_ID,
5161                 PCI_ANY_ID,
5162                 0,
5163                 0,
5164                 pbn_b0_2_115200 },
5165
5166         {       PCI_VENDOR_ID_ADDIDATA,
5167                 PCI_DEVICE_ID_ADDIDATA_APCI7300,
5168                 PCI_ANY_ID,
5169                 PCI_ANY_ID,
5170                 0,
5171                 0,
5172                 pbn_b0_1_115200 },
5173
5174         {       PCI_VENDOR_ID_AMCC,
5175                 PCI_DEVICE_ID_AMCC_ADDIDATA_APCI7800,
5176                 PCI_ANY_ID,
5177                 PCI_ANY_ID,
5178                 0,
5179                 0,
5180                 pbn_b1_8_115200 },
5181
5182         {       PCI_VENDOR_ID_ADDIDATA,
5183                 PCI_DEVICE_ID_ADDIDATA_APCI7500_2,
5184                 PCI_ANY_ID,
5185                 PCI_ANY_ID,
5186                 0,
5187                 0,
5188                 pbn_b0_4_115200 },
5189
5190         {       PCI_VENDOR_ID_ADDIDATA,
5191                 PCI_DEVICE_ID_ADDIDATA_APCI7420_2,
5192                 PCI_ANY_ID,
5193                 PCI_ANY_ID,
5194                 0,
5195                 0,
5196                 pbn_b0_2_115200 },
5197
5198         {       PCI_VENDOR_ID_ADDIDATA,
5199                 PCI_DEVICE_ID_ADDIDATA_APCI7300_2,
5200                 PCI_ANY_ID,
5201                 PCI_ANY_ID,
5202                 0,
5203                 0,
5204                 pbn_b0_1_115200 },
5205
5206         {       PCI_VENDOR_ID_ADDIDATA,
5207                 PCI_DEVICE_ID_ADDIDATA_APCI7500_3,
5208                 PCI_ANY_ID,
5209                 PCI_ANY_ID,
5210                 0,
5211                 0,
5212                 pbn_b0_4_115200 },
5213
5214         {       PCI_VENDOR_ID_ADDIDATA,
5215                 PCI_DEVICE_ID_ADDIDATA_APCI7420_3,
5216                 PCI_ANY_ID,
5217                 PCI_ANY_ID,
5218                 0,
5219                 0,
5220                 pbn_b0_2_115200 },
5221
5222         {       PCI_VENDOR_ID_ADDIDATA,
5223                 PCI_DEVICE_ID_ADDIDATA_APCI7300_3,
5224                 PCI_ANY_ID,
5225                 PCI_ANY_ID,
5226                 0,
5227                 0,
5228                 pbn_b0_1_115200 },
5229
5230         {       PCI_VENDOR_ID_ADDIDATA,
5231                 PCI_DEVICE_ID_ADDIDATA_APCI7800_3,
5232                 PCI_ANY_ID,
5233                 PCI_ANY_ID,
5234                 0,
5235                 0,
5236                 pbn_b0_8_115200 },
5237
5238         {       PCI_VENDOR_ID_ADDIDATA,
5239                 PCI_DEVICE_ID_ADDIDATA_APCIe7500,
5240                 PCI_ANY_ID,
5241                 PCI_ANY_ID,
5242                 0,
5243                 0,
5244                 pbn_ADDIDATA_PCIe_4_3906250 },
5245
5246         {       PCI_VENDOR_ID_ADDIDATA,
5247                 PCI_DEVICE_ID_ADDIDATA_APCIe7420,
5248                 PCI_ANY_ID,
5249                 PCI_ANY_ID,
5250                 0,
5251                 0,
5252                 pbn_ADDIDATA_PCIe_2_3906250 },
5253
5254         {       PCI_VENDOR_ID_ADDIDATA,
5255                 PCI_DEVICE_ID_ADDIDATA_APCIe7300,
5256                 PCI_ANY_ID,
5257                 PCI_ANY_ID,
5258                 0,
5259                 0,
5260                 pbn_ADDIDATA_PCIe_1_3906250 },
5261
5262         {       PCI_VENDOR_ID_ADDIDATA,
5263                 PCI_DEVICE_ID_ADDIDATA_APCIe7800,
5264                 PCI_ANY_ID,
5265                 PCI_ANY_ID,
5266                 0,
5267                 0,
5268                 pbn_ADDIDATA_PCIe_8_3906250 },
5269
5270         {       PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9835,
5271                 PCI_VENDOR_ID_IBM, 0x0299,
5272                 0, 0, pbn_b0_bt_2_115200 },
5273
5274         /*
5275          * other NetMos 9835 devices are most likely handled by the
5276          * parport_serial driver, check drivers/parport/parport_serial.c
5277          * before adding them here.
5278          */
5279
5280         {       PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9901,
5281                 0xA000, 0x1000,
5282                 0, 0, pbn_b0_1_115200 },
5283
5284         /* the 9901 is a rebranded 9912 */
5285         {       PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9912,
5286                 0xA000, 0x1000,
5287                 0, 0, pbn_b0_1_115200 },
5288
5289         {       PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9922,
5290                 0xA000, 0x1000,
5291                 0, 0, pbn_b0_1_115200 },
5292
5293         {       PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9904,
5294                 0xA000, 0x1000,
5295                 0, 0, pbn_b0_1_115200 },
5296
5297         {       PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9900,
5298                 0xA000, 0x1000,
5299                 0, 0, pbn_b0_1_115200 },
5300
5301         {       PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9900,
5302                 0xA000, 0x3002,
5303                 0, 0, pbn_NETMOS9900_2s_115200 },
5304
5305         /*
5306          * Best Connectivity and Rosewill PCI Multi I/O cards
5307          */
5308
5309         {       PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9865,
5310                 0xA000, 0x1000,
5311                 0, 0, pbn_b0_1_115200 },
5312
5313         {       PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9865,
5314                 0xA000, 0x3002,
5315                 0, 0, pbn_b0_bt_2_115200 },
5316
5317         {       PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9865,
5318                 0xA000, 0x3004,
5319                 0, 0, pbn_b0_bt_4_115200 },
5320         /* Intel CE4100 */
5321         {       PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_CE4100_UART,
5322                 PCI_ANY_ID,  PCI_ANY_ID, 0, 0,
5323                 pbn_ce4100_1_115200 },
5324
5325         /*
5326          * Cronyx Omega PCI
5327          */
5328         {       PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_CRONYX_OMEGA,
5329                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5330                 pbn_omegapci },
5331
5332         /*
5333          * Broadcom TruManage
5334          */
5335         {       PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_BROADCOM_TRUMANAGE,
5336                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
5337                 pbn_brcm_trumanage },
5338
5339         /*
5340          * AgeStar as-prs2-009
5341          */
5342         {       PCI_VENDOR_ID_AGESTAR, PCI_DEVICE_ID_AGESTAR_9375,
5343                 PCI_ANY_ID, PCI_ANY_ID,
5344                 0, 0, pbn_b0_bt_2_115200 },
5345
5346         /*
5347          * WCH CH353 series devices: The 2S1P is handled by parport_serial
5348          * so not listed here.
5349          */
5350         {       PCI_VENDOR_ID_WCH, PCI_DEVICE_ID_WCH_CH353_4S,
5351                 PCI_ANY_ID, PCI_ANY_ID,
5352                 0, 0, pbn_b0_bt_4_115200 },
5353
5354         {       PCI_VENDOR_ID_WCH, PCI_DEVICE_ID_WCH_CH353_2S1PF,
5355                 PCI_ANY_ID, PCI_ANY_ID,
5356                 0, 0, pbn_b0_bt_2_115200 },
5357
5358         {       PCI_VENDOR_ID_WCH, PCI_DEVICE_ID_WCH_CH355_4S,
5359                 PCI_ANY_ID, PCI_ANY_ID,
5360                 0, 0, pbn_b0_bt_4_115200 },
5361
5362         {       PCIE_VENDOR_ID_WCH, PCIE_DEVICE_ID_WCH_CH382_2S,
5363                 PCI_ANY_ID, PCI_ANY_ID,
5364                 0, 0, pbn_wch382_2 },
5365
5366         {       PCIE_VENDOR_ID_WCH, PCIE_DEVICE_ID_WCH_CH384_4S,
5367                 PCI_ANY_ID, PCI_ANY_ID,
5368                 0, 0, pbn_wch384_4 },
5369
5370         {       PCIE_VENDOR_ID_WCH, PCIE_DEVICE_ID_WCH_CH384_8S,
5371                 PCI_ANY_ID, PCI_ANY_ID,
5372                 0, 0, pbn_wch384_8 },
5373         /*
5374          * Realtek RealManage
5375          */
5376         {       PCI_VENDOR_ID_REALTEK, 0x816a,
5377                 PCI_ANY_ID, PCI_ANY_ID,
5378                 0, 0, pbn_b0_1_115200 },
5379
5380         {       PCI_VENDOR_ID_REALTEK, 0x816b,
5381                 PCI_ANY_ID, PCI_ANY_ID,
5382                 0, 0, pbn_b0_1_115200 },
5383
5384         /* Fintek PCI serial cards */
5385         { PCI_DEVICE(0x1c29, 0x1104), .driver_data = pbn_fintek_4 },
5386         { PCI_DEVICE(0x1c29, 0x1108), .driver_data = pbn_fintek_8 },
5387         { PCI_DEVICE(0x1c29, 0x1112), .driver_data = pbn_fintek_12 },
5388         { PCI_DEVICE(0x1c29, 0x1204), .driver_data = pbn_fintek_F81504A },
5389         { PCI_DEVICE(0x1c29, 0x1208), .driver_data = pbn_fintek_F81508A },
5390         { PCI_DEVICE(0x1c29, 0x1212), .driver_data = pbn_fintek_F81512A },
5391
5392         /* MKS Tenta SCOM-080x serial cards */
5393         { PCI_DEVICE(0x1601, 0x0800), .driver_data = pbn_b0_4_1250000 },
5394         { PCI_DEVICE(0x1601, 0xa801), .driver_data = pbn_b0_4_1250000 },
5395
5396         /* Amazon PCI serial device */
5397         { PCI_DEVICE(0x1d0f, 0x8250), .driver_data = pbn_b0_1_115200 },
5398
5399         /*
5400          * These entries match devices with class COMMUNICATION_SERIAL,
5401          * COMMUNICATION_MODEM or COMMUNICATION_MULTISERIAL
5402          */
5403         {       PCI_ANY_ID, PCI_ANY_ID,
5404                 PCI_ANY_ID, PCI_ANY_ID,
5405                 PCI_CLASS_COMMUNICATION_SERIAL << 8,
5406                 0xffff00, pbn_default },
5407         {       PCI_ANY_ID, PCI_ANY_ID,
5408                 PCI_ANY_ID, PCI_ANY_ID,
5409                 PCI_CLASS_COMMUNICATION_MODEM << 8,
5410                 0xffff00, pbn_default },
5411         {       PCI_ANY_ID, PCI_ANY_ID,
5412                 PCI_ANY_ID, PCI_ANY_ID,
5413                 PCI_CLASS_COMMUNICATION_MULTISERIAL << 8,
5414                 0xffff00, pbn_default },
5415         { 0, }
5416 };
5417
5418 static pci_ers_result_t serial8250_io_error_detected(struct pci_dev *dev,
5419                                                 pci_channel_state_t state)
5420 {
5421         struct serial_private *priv = pci_get_drvdata(dev);
5422
5423         if (state == pci_channel_io_perm_failure)
5424                 return PCI_ERS_RESULT_DISCONNECT;
5425
5426         if (priv)
5427                 pciserial_detach_ports(priv);
5428
5429         pci_disable_device(dev);
5430
5431         return PCI_ERS_RESULT_NEED_RESET;
5432 }
5433
5434 static pci_ers_result_t serial8250_io_slot_reset(struct pci_dev *dev)
5435 {
5436         int rc;
5437
5438         rc = pci_enable_device(dev);
5439
5440         if (rc)
5441                 return PCI_ERS_RESULT_DISCONNECT;
5442
5443         pci_restore_state(dev);
5444         pci_save_state(dev);
5445
5446         return PCI_ERS_RESULT_RECOVERED;
5447 }
5448
5449 static void serial8250_io_resume(struct pci_dev *dev)
5450 {
5451         struct serial_private *priv = pci_get_drvdata(dev);
5452         struct serial_private *new;
5453
5454         if (!priv)
5455                 return;
5456
5457         new = pciserial_init_ports(dev, priv->board);
5458         if (!IS_ERR(new)) {
5459                 pci_set_drvdata(dev, new);
5460                 kfree(priv);
5461         }
5462 }
5463
5464 static const struct pci_error_handlers serial8250_err_handler = {
5465         .error_detected = serial8250_io_error_detected,
5466         .slot_reset = serial8250_io_slot_reset,
5467         .resume = serial8250_io_resume,
5468 };
5469
5470 static struct pci_driver serial_pci_driver = {
5471         .name           = "serial",
5472         .probe          = pciserial_init_one,
5473         .remove         = pciserial_remove_one,
5474         .driver         = {
5475                 .pm     = &pciserial_pm_ops,
5476         },
5477         .id_table       = serial_pci_tbl,
5478         .err_handler    = &serial8250_err_handler,
5479 };
5480
5481 module_pci_driver(serial_pci_driver);
5482
5483 MODULE_LICENSE("GPL");
5484 MODULE_DESCRIPTION("Generic 8250/16x50 PCI serial probe module");
5485 MODULE_DEVICE_TABLE(pci, serial_pci_tbl);