drivers/tty/serial/8250/8250_exar.c

   1 /*
   2  *  Probe module for 8250/16550-type Exar chips PCI serial ports.
   3  *
   4  *  Based on drivers/tty/serial/8250/8250_pci.c,
   5  *
   6  *  Copyright (C) 2017 Sudip Mukherjee, All Rights Reserved.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License.
  11  */
  12 #include <linux/acpi.h>
  13 #include <linux/dmi.h>
  14 #include <linux/io.h>
  15 #include <linux/kernel.h>
  16 #include <linux/module.h>
  17 #include <linux/pci.h>
  18 #include <linux/property.h>
  19 #include <linux/serial_core.h>
  20 #include <linux/serial_reg.h>
  21 #include <linux/slab.h>
  22 #include <linux/string.h>
  23 #include <linux/tty.h>
  24 #include <linux/8250_pci.h>
  25
  26 #include <asm/byteorder.h>
  27
  28 #include "8250.h"
  29
  30 #define PCI_DEVICE_ID_ACCES_COM_2S              0x1052
  31 #define PCI_DEVICE_ID_ACCES_COM_4S              0x105d
  32 #define PCI_DEVICE_ID_ACCES_COM_8S              0x106c
  33 #define PCI_DEVICE_ID_ACCES_COM232_8            0x10a8
  34 #define PCI_DEVICE_ID_ACCES_COM_2SM             0x10d2
  35 #define PCI_DEVICE_ID_ACCES_COM_4SM             0x10db
  36 #define PCI_DEVICE_ID_ACCES_COM_8SM             0x10ea
  37
  38 #define PCI_DEVICE_ID_COMMTECH_4224PCI335       0x0002
  39 #define PCI_DEVICE_ID_COMMTECH_4222PCI335       0x0004
  40 #define PCI_DEVICE_ID_COMMTECH_2324PCI335       0x000a
  41 #define PCI_DEVICE_ID_COMMTECH_2328PCI335       0x000b
  42 #define PCI_DEVICE_ID_COMMTECH_4224PCIE         0x0020
  43 #define PCI_DEVICE_ID_COMMTECH_4228PCIE         0x0021
  44 #define PCI_DEVICE_ID_COMMTECH_4222PCIE         0x0022
  45 #define PCI_DEVICE_ID_EXAR_XR17V4358            0x4358
  46 #define PCI_DEVICE_ID_EXAR_XR17V8358            0x8358
  47
  48 #define UART_EXAR_INT0          0x80
  49 #define UART_EXAR_8XMODE        0x88    /* 8X sampling rate select */
  50
  51 #define UART_EXAR_FCTR          0x08    /* Feature Control Register */
  52 #define UART_FCTR_EXAR_IRDA     0x10    /* IrDa data encode select */
  53 #define UART_FCTR_EXAR_485      0x20    /* Auto 485 half duplex dir ctl */
  54 #define UART_FCTR_EXAR_TRGA     0x00    /* FIFO trigger table A */
  55 #define UART_FCTR_EXAR_TRGB     0x60    /* FIFO trigger table B */
  56 #define UART_FCTR_EXAR_TRGC     0x80    /* FIFO trigger table C */
  57 #define UART_FCTR_EXAR_TRGD     0xc0    /* FIFO trigger table D programmable */
  58
  59 #define UART_EXAR_TXTRG         0x0a    /* Tx FIFO trigger level write-only */
  60 #define UART_EXAR_RXTRG         0x0b    /* Rx FIFO trigger level write-only */
  61
  62 #define UART_EXAR_MPIOINT_7_0   0x8f    /* MPIOINT[7:0] */
  63 #define UART_EXAR_MPIOLVL_7_0   0x90    /* MPIOLVL[7:0] */
  64 #define UART_EXAR_MPIO3T_7_0    0x91    /* MPIO3T[7:0] */
  65 #define UART_EXAR_MPIOINV_7_0   0x92    /* MPIOINV[7:0] */
  66 #define UART_EXAR_MPIOSEL_7_0   0x93    /* MPIOSEL[7:0] */
  67 #define UART_EXAR_MPIOOD_7_0    0x94    /* MPIOOD[7:0] */
  68 #define UART_EXAR_MPIOINT_15_8  0x95    /* MPIOINT[15:8] */
  69 #define UART_EXAR_MPIOLVL_15_8  0x96    /* MPIOLVL[15:8] */
  70 #define UART_EXAR_MPIO3T_15_8   0x97    /* MPIO3T[15:8] */
  71 #define UART_EXAR_MPIOINV_15_8  0x98    /* MPIOINV[15:8] */
  72 #define UART_EXAR_MPIOSEL_15_8  0x99    /* MPIOSEL[15:8] */
  73 #define UART_EXAR_MPIOOD_15_8   0x9a    /* MPIOOD[15:8] */
  74
  75 #define UART_EXAR_RS485_DLY(x)  ((x) << 4)
  76
  77 /*
  78  * IOT2040 MPIO wiring semantics:
  79  *
  80  * MPIO         Port    Function
  81  * ----         ----    --------
  82  * 0            2       Mode bit 0
  83  * 1            2       Mode bit 1
  84  * 2            2       Terminate bus
  85  * 3            -       <reserved>
  86  * 4            3       Mode bit 0
  87  * 5            3       Mode bit 1
  88  * 6            3       Terminate bus
  89  * 7            -       <reserved>
  90  * 8            2       Enable
  91  * 9            3       Enable
  92  * 10           -       Red LED
  93  * 11..15       -       <unused>
  94  */
  95
  96 /* IOT2040 MPIOs 0..7 */
  97 #define IOT2040_UART_MODE_RS232         0x01
  98 #define IOT2040_UART_MODE_RS485         0x02
  99 #define IOT2040_UART_MODE_RS422         0x03
 100 #define IOT2040_UART_TERMINATE_BUS      0x04
 101
 102 #define IOT2040_UART1_MASK              0x0f
 103 #define IOT2040_UART2_SHIFT             4
 104
 105 #define IOT2040_UARTS_DEFAULT_MODE      0x11    /* both RS232 */
 106 #define IOT2040_UARTS_GPIO_LO_MODE      0x88    /* reserved pins as input */
 107
 108 /* IOT2040 MPIOs 8..15 */
 109 #define IOT2040_UARTS_ENABLE            0x03
 110 #define IOT2040_UARTS_GPIO_HI_MODE      0xF8    /* enable & LED as outputs */
 111
 112 struct exar8250;
 113
 114 struct exar8250_platform {
 115         int (*rs485_config)(struct uart_port *, struct serial_rs485 *);
 116         int (*register_gpio)(struct pci_dev *, struct uart_8250_port *);
 117 };
 118
 119 /**
 120  * struct exar8250_board - board information
 121  * @num_ports: number of serial ports
 122  * @reg_shift: describes UART register mapping in PCI memory
 123  */
 124 struct exar8250_board {
 125         unsigned int num_ports;
 126         unsigned int reg_shift;
 127         bool has_slave;
 128         int     (*setup)(struct exar8250 *, struct pci_dev *,
 129                          struct uart_8250_port *, int);
 130         void    (*exit)(struct pci_dev *pcidev);
 131 };
 132
 133 struct exar8250 {
 134         unsigned int            nr;
 135         struct exar8250_board   *board;
 136         void __iomem            *virt;
 137         int                     line[0];
 138 };
 139
 140 static int default_setup(struct exar8250 *priv, struct pci_dev *pcidev,
 141                          int idx, unsigned int offset,
 142                          struct uart_8250_port *port)
 143 {
 144         const struct exar8250_board *board = priv->board;
 145         unsigned int bar = 0;
 146
 147         port->port.iotype = UPIO_MEM;
 148         port->port.mapbase = pci_resource_start(pcidev, bar) + offset;
 149         port->port.membase = priv->virt + offset;
 150         port->port.regshift = board->reg_shift;
 151
 152         return 0;
 153 }
 154
 155 static int
 156 pci_fastcom335_setup(struct exar8250 *priv, struct pci_dev *pcidev,
 157                      struct uart_8250_port *port, int idx)
 158 {
 159         unsigned int offset = idx * 0x200;
 160         unsigned int baud = 1843200;
 161         u8 __iomem *p;
 162         int err;
 163
 164         port->port.uartclk = baud * 16;
 165
 166         err = default_setup(priv, pcidev, idx, offset, port);
 167         if (err)
 168                 return err;
 169
 170         p = port->port.membase;
 171
 172         writeb(0x00, p + UART_EXAR_8XMODE);
 173         writeb(UART_FCTR_EXAR_TRGD, p + UART_EXAR_FCTR);
 174         writeb(32, p + UART_EXAR_TXTRG);
 175         writeb(32, p + UART_EXAR_RXTRG);
 176
 177         /*
 178          * Setup Multipurpose Input/Output pins.
 179          */
 180         if (idx == 0) {
 181                 switch (pcidev->device) {
 182                 case PCI_DEVICE_ID_COMMTECH_4222PCI335:
 183                 case PCI_DEVICE_ID_COMMTECH_4224PCI335:
 184                         writeb(0x78, p + UART_EXAR_MPIOLVL_7_0);
 185                         writeb(0x00, p + UART_EXAR_MPIOINV_7_0);
 186                         writeb(0x00, p + UART_EXAR_MPIOSEL_7_0);
 187                         break;
 188                 case PCI_DEVICE_ID_COMMTECH_2324PCI335:
 189                 case PCI_DEVICE_ID_COMMTECH_2328PCI335:
 190                         writeb(0x00, p + UART_EXAR_MPIOLVL_7_0);
 191                         writeb(0xc0, p + UART_EXAR_MPIOINV_7_0);
 192                         writeb(0xc0, p + UART_EXAR_MPIOSEL_7_0);
 193                         break;
 194                 }
 195                 writeb(0x00, p + UART_EXAR_MPIOINT_7_0);
 196                 writeb(0x00, p + UART_EXAR_MPIO3T_7_0);
 197                 writeb(0x00, p + UART_EXAR_MPIOOD_7_0);
 198         }
 199
 200         return 0;
 201 }
 202
 203 static int
 204 pci_connect_tech_setup(struct exar8250 *priv, struct pci_dev *pcidev,
 205                        struct uart_8250_port *port, int idx)
 206 {
 207         unsigned int offset = idx * 0x200;
 208         unsigned int baud = 1843200;
 209
 210         port->port.uartclk = baud * 16;
 211         return default_setup(priv, pcidev, idx, offset, port);
 212 }
 213
 214 static int
 215 pci_xr17c154_setup(struct exar8250 *priv, struct pci_dev *pcidev,
 216                    struct uart_8250_port *port, int idx)
 217 {
 218         unsigned int offset = idx * 0x200;
 219         unsigned int baud = 921600;
 220
 221         port->port.uartclk = baud * 16;
 222         return default_setup(priv, pcidev, idx, offset, port);
 223 }
 224
 225 static void setup_gpio(struct pci_dev *pcidev, u8 __iomem *p)
 226 {
 227         /*
 228          * The Commtech adapters required the MPIOs to be driven low. The Exar
 229          * devices will export them as GPIOs, so we pre-configure them safely
 230          * as inputs.
 231          */
 232
 233         u8 dir = 0x00;
 234
 235         if  ((pcidev->vendor == PCI_VENDOR_ID_EXAR) &&
 236                 (pcidev->subsystem_vendor != PCI_VENDOR_ID_SEALEVEL)) {
 237                 // Configure GPIO as inputs for Commtech adapters
 238                 dir = 0xff;
 239         } else {
 240                 // Configure GPIO as outputs for SeaLevel adapters
 241                 dir = 0x00;
 242         }
 243
 244         writeb(0x00, p + UART_EXAR_MPIOINT_7_0);
 245         writeb(0x00, p + UART_EXAR_MPIOLVL_7_0);
 246         writeb(0x00, p + UART_EXAR_MPIO3T_7_0);
 247         writeb(0x00, p + UART_EXAR_MPIOINV_7_0);
 248         writeb(dir,  p + UART_EXAR_MPIOSEL_7_0);
 249         writeb(0x00, p + UART_EXAR_MPIOOD_7_0);
 250         writeb(0x00, p + UART_EXAR_MPIOINT_15_8);
 251         writeb(0x00, p + UART_EXAR_MPIOLVL_15_8);
 252         writeb(0x00, p + UART_EXAR_MPIO3T_15_8);
 253         writeb(0x00, p + UART_EXAR_MPIOINV_15_8);
 254         writeb(dir,  p + UART_EXAR_MPIOSEL_15_8);
 255         writeb(0x00, p + UART_EXAR_MPIOOD_15_8);
 256 }
 257
 258 static void *
 259 __xr17v35x_register_gpio(struct pci_dev *pcidev,
 260                          const struct property_entry *properties)
 261 {
 262         struct platform_device *pdev;
 263
 264         pdev = platform_device_alloc("gpio_exar", PLATFORM_DEVID_AUTO);
 265         if (!pdev)
 266                 return NULL;
 267
 268         pdev->dev.parent = &pcidev->dev;
 269         ACPI_COMPANION_SET(&pdev->dev, ACPI_COMPANION(&pcidev->dev));
 270
 271         if (platform_device_add_properties(pdev, properties) < 0 ||
 272             platform_device_add(pdev) < 0) {
 273                 platform_device_put(pdev);
 274                 return NULL;
 275         }
 276
 277         return pdev;
 278 }
 279
 280 static const struct property_entry exar_gpio_properties[] = {
 281         PROPERTY_ENTRY_U32("exar,first-pin", 0),
 282         PROPERTY_ENTRY_U32("ngpios", 16),
 283         { }
 284 };
 285
 286 static int xr17v35x_register_gpio(struct pci_dev *pcidev,
 287                                   struct uart_8250_port *port)
 288 {
 289         if (pcidev->vendor == PCI_VENDOR_ID_EXAR)
 290                 port->port.private_data =
 291                         __xr17v35x_register_gpio(pcidev, exar_gpio_properties);
 292
 293         return 0;
 294 }
 295
 296 static const struct exar8250_platform exar8250_default_platform = {
 297         .register_gpio = xr17v35x_register_gpio,
 298 };
 299
 300 static int iot2040_rs485_config(struct uart_port *port,
 301                                 struct serial_rs485 *rs485)
 302 {
 303         bool is_rs485 = !!(rs485->flags & SER_RS485_ENABLED);
 304         u8 __iomem *p = port->membase;
 305         u8 mask = IOT2040_UART1_MASK;
 306         u8 mode, value;
 307
 308         if (is_rs485) {
 309                 if (rs485->flags & SER_RS485_RX_DURING_TX)
 310                         mode = IOT2040_UART_MODE_RS422;
 311                 else
 312                         mode = IOT2040_UART_MODE_RS485;
 313
 314                 if (rs485->flags & SER_RS485_TERMINATE_BUS)
 315                         mode |= IOT2040_UART_TERMINATE_BUS;
 316         } else {
 317                 mode = IOT2040_UART_MODE_RS232;
 318         }
 319
 320         if (port->line == 3) {
 321                 mask <<= IOT2040_UART2_SHIFT;
 322                 mode <<= IOT2040_UART2_SHIFT;
 323         }
 324
 325         value = readb(p + UART_EXAR_MPIOLVL_7_0);
 326         value &= ~mask;
 327         value |= mode;
 328         writeb(value, p + UART_EXAR_MPIOLVL_7_0);
 329
 330         value = readb(p + UART_EXAR_FCTR);
 331         if (is_rs485)
 332                 value |= UART_FCTR_EXAR_485;
 333         else
 334                 value &= ~UART_FCTR_EXAR_485;
 335         writeb(value, p + UART_EXAR_FCTR);
 336
 337         if (is_rs485)
 338                 writeb(UART_EXAR_RS485_DLY(4), p + UART_MSR);
 339
 340         port->rs485 = *rs485;
 341
 342         return 0;
 343 }
 344
 345 static const struct property_entry iot2040_gpio_properties[] = {
 346         PROPERTY_ENTRY_U32("exar,first-pin", 10),
 347         PROPERTY_ENTRY_U32("ngpios", 1),
 348         { }
 349 };
 350
 351 static int iot2040_register_gpio(struct pci_dev *pcidev,
 352                               struct uart_8250_port *port)
 353 {
 354         u8 __iomem *p = port->port.membase;
 355
 356         writeb(IOT2040_UARTS_DEFAULT_MODE, p + UART_EXAR_MPIOLVL_7_0);
 357         writeb(IOT2040_UARTS_GPIO_LO_MODE, p + UART_EXAR_MPIOSEL_7_0);
 358         writeb(IOT2040_UARTS_ENABLE, p + UART_EXAR_MPIOLVL_15_8);
 359         writeb(IOT2040_UARTS_GPIO_HI_MODE, p + UART_EXAR_MPIOSEL_15_8);
 360
 361         port->port.private_data =
 362                 __xr17v35x_register_gpio(pcidev, iot2040_gpio_properties);
 363
 364         return 0;
 365 }
 366
 367 static const struct exar8250_platform iot2040_platform = {
 368         .rs485_config = iot2040_rs485_config,
 369         .register_gpio = iot2040_register_gpio,
 370 };
 371
 372 static const struct dmi_system_id exar_platforms[] = {
 373         {
 374                 .matches = {
 375                         DMI_EXACT_MATCH(DMI_BOARD_NAME, "SIMATIC IOT2000"),
 376                         DMI_EXACT_MATCH(DMI_BOARD_ASSET_TAG,
 377                                         "6ES7647-0AA00-1YA2"),
 378                 },
 379                 .driver_data = (void *)&iot2040_platform,
 380         },
 381         {}
 382 };
 383
 384 static int
 385 pci_xr17v35x_setup(struct exar8250 *priv, struct pci_dev *pcidev,
 386                    struct uart_8250_port *port, int idx)
 387 {
 388         const struct exar8250_board *board = priv->board;
 389         const struct exar8250_platform *platform;
 390         const struct dmi_system_id *dmi_match;
 391         unsigned int offset = idx * 0x400;
 392         unsigned int baud = 7812500;
 393         u8 __iomem *p;
 394         int ret;
 395
 396         dmi_match = dmi_first_match(exar_platforms);
 397         if (dmi_match)
 398                 platform = dmi_match->driver_data;
 399         else
 400                 platform = &exar8250_default_platform;
 401
 402         port->port.uartclk = baud * 16;
 403         port->port.rs485_config = platform->rs485_config;
 404
 405         /*
 406          * Setup the uart clock for the devices on expansion slot to
 407          * half the clock speed of the main chip (which is 125MHz)
 408          */
 409         if (board->has_slave && idx >= 8)
 410                 port->port.uartclk /= 2;
 411
 412         ret = default_setup(priv, pcidev, idx, offset, port);
 413         if (ret)
 414                 return ret;
 415
 416         p = port->port.membase;
 417
 418         writeb(0x00, p + UART_EXAR_8XMODE);
 419         writeb(UART_FCTR_EXAR_TRGD, p + UART_EXAR_FCTR);
 420         writeb(128, p + UART_EXAR_TXTRG);
 421         writeb(128, p + UART_EXAR_RXTRG);
 422
 423         if (idx == 0) {
 424                 /* Setup Multipurpose Input/Output pins. */
 425                 setup_gpio(pcidev, p);
 426
 427                 ret = platform->register_gpio(pcidev, port);
 428         }
 429
 430         return ret;
 431 }
 432
 433 static void pci_xr17v35x_exit(struct pci_dev *pcidev)
 434 {
 435         struct exar8250 *priv = pci_get_drvdata(pcidev);
 436         struct uart_8250_port *port = serial8250_get_port(priv->line[0]);
 437         struct platform_device *pdev = port->port.private_data;
 438
 439         platform_device_unregister(pdev);
 440         port->port.private_data = NULL;
 441 }
 442
 443 /*
 444  * These Exar UARTs have an extra interrupt indicator that could fire for a
 445  * few interrupts that are not presented/cleared through IIR.  One of which is
 446  * a wakeup interrupt when coming out of sleep.  These interrupts are only
 447  * cleared by reading global INT0 or INT1 registers as interrupts are
 448  * associated with channel 0. The INT[3:0] registers _are_ accessible from each
 449  * channel's address space, but for the sake of bus efficiency we register a
 450  * dedicated handler at the PCI device level to handle them.
 451  */
 452 static irqreturn_t exar_misc_handler(int irq, void *data)
 453 {
 454         struct exar8250 *priv = data;
 455
 456         /* Clear all PCI interrupts by reading INT0. No effect on IIR */
 457         readb(priv->virt + UART_EXAR_INT0);
 458
 459         /* Clear INT0 for Expansion Interface slave ports, too */
 460         if (priv->board->num_ports > 8)
 461                 readb(priv->virt + 0x2000 + UART_EXAR_INT0);
 462
 463         return IRQ_HANDLED;
 464 }
 465
 466 static int
 467 exar_pci_probe(struct pci_dev *pcidev, const struct pci_device_id *ent)
 468 {
 469         unsigned int nr_ports, i, bar = 0, maxnr;
 470         struct exar8250_board *board;
 471         struct uart_8250_port uart;
 472         struct exar8250 *priv;
 473         int rc;
 474
 475         board = (struct exar8250_board *)ent->driver_data;
 476         if (!board)
 477                 return -EINVAL;
 478
 479         rc = pcim_enable_device(pcidev);
 480         if (rc)
 481                 return rc;
 482
 483         maxnr = pci_resource_len(pcidev, bar) >> (board->reg_shift + 3);
 484
 485         nr_ports = board->num_ports ? board->num_ports : pcidev->device & 0x0f;
 486
 487         priv = devm_kzalloc(&pcidev->dev, sizeof(*priv) +
 488                             sizeof(unsigned int) * nr_ports,
 489                             GFP_KERNEL);
 490         if (!priv)
 491                 return -ENOMEM;
 492
 493         priv->board = board;
 494         priv->virt = pcim_iomap(pcidev, bar, 0);
 495         if (!priv->virt)
 496                 return -ENOMEM;
 497
 498         pci_set_master(pcidev);
 499
 500         rc = pci_alloc_irq_vectors(pcidev, 1, 1, PCI_IRQ_ALL_TYPES);
 501         if (rc < 0)
 502                 return rc;
 503
 504         memset(&uart, 0, sizeof(uart));
 505         uart.port.flags = UPF_SKIP_TEST | UPF_BOOT_AUTOCONF | UPF_SHARE_IRQ
 506                           | UPF_EXAR_EFR;
 507         uart.port.irq = pci_irq_vector(pcidev, 0);
 508         uart.port.dev = &pcidev->dev;
 509
 510         rc = devm_request_irq(&pcidev->dev, uart.port.irq, exar_misc_handler,
 511                          IRQF_SHARED, "exar_uart", priv);
 512         if (rc)
 513                 return rc;
 514
 515         for (i = 0; i < nr_ports && i < maxnr; i++) {
 516                 rc = board->setup(priv, pcidev, &uart, i);
 517                 if (rc) {
 518                         dev_err(&pcidev->dev, "Failed to setup port %u\n", i);
 519                         break;
 520                 }
 521
 522                 dev_dbg(&pcidev->dev, "Setup PCI port: port %lx, irq %d, type %d\n",
 523                         uart.port.iobase, uart.port.irq, uart.port.iotype);
 524
 525                 priv->line[i] = serial8250_register_8250_port(&uart);
 526                 if (priv->line[i] < 0) {
 527                         dev_err(&pcidev->dev,
 528                                 "Couldn't register serial port %lx, irq %d, type %d, error %d\n",
 529                                 uart.port.iobase, uart.port.irq,
 530                                 uart.port.iotype, priv->line[i]);
 531                         break;
 532                 }
 533         }
 534         priv->nr = i;
 535         pci_set_drvdata(pcidev, priv);
 536         return 0;
 537 }
 538
 539 static void exar_pci_remove(struct pci_dev *pcidev)
 540 {
 541         struct exar8250 *priv = pci_get_drvdata(pcidev);
 542         unsigned int i;
 543
 544         for (i = 0; i < priv->nr; i++)
 545                 serial8250_unregister_port(priv->line[i]);
 546
 547         if (priv->board->exit)
 548                 priv->board->exit(pcidev);
 549 }
 550
 551 static int __maybe_unused exar_suspend(struct device *dev)
 552 {
 553         struct pci_dev *pcidev = to_pci_dev(dev);
 554         struct exar8250 *priv = pci_get_drvdata(pcidev);
 555         unsigned int i;
 556
 557         for (i = 0; i < priv->nr; i++)
 558                 if (priv->line[i] >= 0)
 559                         serial8250_suspend_port(priv->line[i]);
 560
 561         /* Ensure that every init quirk is properly torn down */
 562         if (priv->board->exit)
 563                 priv->board->exit(pcidev);
 564
 565         return 0;
 566 }
 567
 568 static int __maybe_unused exar_resume(struct device *dev)
 569 {
 570         struct pci_dev *pcidev = to_pci_dev(dev);
 571         struct exar8250 *priv = pci_get_drvdata(pcidev);
 572         unsigned int i;
 573
 574         for (i = 0; i < priv->nr; i++)
 575                 if (priv->line[i] >= 0)
 576                         serial8250_resume_port(priv->line[i]);
 577
 578         return 0;
 579 }
 580
 581 static SIMPLE_DEV_PM_OPS(exar_pci_pm, exar_suspend, exar_resume);
 582
 583 static const struct exar8250_board acces_com_2x = {
 584         .num_ports      = 2,
 585         .setup          = pci_xr17c154_setup,
 586 };
 587
 588 static const struct exar8250_board acces_com_4x = {
 589         .num_ports      = 4,
 590         .setup          = pci_xr17c154_setup,
 591 };
 592
 593 static const struct exar8250_board acces_com_8x = {
 594         .num_ports      = 8,
 595         .setup          = pci_xr17c154_setup,
 596 };
 597
 598
 599 static const struct exar8250_board pbn_fastcom335_2 = {
 600         .num_ports      = 2,
 601         .setup          = pci_fastcom335_setup,
 602 };
 603
 604 static const struct exar8250_board pbn_fastcom335_4 = {
 605         .num_ports      = 4,
 606         .setup          = pci_fastcom335_setup,
 607 };
 608
 609 static const struct exar8250_board pbn_fastcom335_8 = {
 610         .num_ports      = 8,
 611         .setup          = pci_fastcom335_setup,
 612 };
 613
 614 static const struct exar8250_board pbn_connect = {
 615         .setup          = pci_connect_tech_setup,
 616 };
 617
 618 static const struct exar8250_board pbn_exar_ibm_saturn = {
 619         .num_ports      = 1,
 620         .setup          = pci_xr17c154_setup,
 621 };
 622
 623 static const struct exar8250_board pbn_exar_XR17C15x = {
 624         .setup          = pci_xr17c154_setup,
 625 };
 626
 627 static const struct exar8250_board pbn_exar_XR17V35x = {
 628         .setup          = pci_xr17v35x_setup,
 629         .exit           = pci_xr17v35x_exit,
 630 };
 631
 632 static const struct exar8250_board pbn_fastcom35x_2 = {
 633         .num_ports      = 2,
 634         .setup          = pci_xr17v35x_setup,
 635         .exit           = pci_xr17v35x_exit,
 636 };
 637
 638 static const struct exar8250_board pbn_fastcom35x_4 = {
 639         .num_ports      = 4,
 640         .setup          = pci_xr17v35x_setup,
 641         .exit           = pci_xr17v35x_exit,
 642 };
 643
 644 static const struct exar8250_board pbn_fastcom35x_8 = {
 645         .num_ports      = 8,
 646         .setup          = pci_xr17v35x_setup,
 647         .exit           = pci_xr17v35x_exit,
 648 };
 649
 650 static const struct exar8250_board pbn_exar_XR17V4358 = {
 651         .num_ports      = 12,
 652         .has_slave      = true,
 653         .setup          = pci_xr17v35x_setup,
 654         .exit           = pci_xr17v35x_exit,
 655 };
 656
 657 static const struct exar8250_board pbn_exar_XR17V8358 = {
 658         .num_ports      = 16,
 659         .has_slave      = true,
 660         .setup          = pci_xr17v35x_setup,
 661         .exit           = pci_xr17v35x_exit,
 662 };
 663
 664 #define CONNECT_DEVICE(devid, sdevid, bd) {                             \
 665         PCI_DEVICE_SUB(                                                 \
 666                 PCI_VENDOR_ID_EXAR,                                     \
 667                 PCI_DEVICE_ID_EXAR_##devid,                             \
 668                 PCI_SUBVENDOR_ID_CONNECT_TECH,                          \
 669                 PCI_SUBDEVICE_ID_CONNECT_TECH_PCI_##sdevid), 0, 0,      \
 670                 (kernel_ulong_t)&bd                                     \
 671         }
 672
 673 #define EXAR_DEVICE(vend, devid, bd) {                                  \
 674         PCI_VDEVICE(vend, PCI_DEVICE_ID_##devid), (kernel_ulong_t)&bd   \
 675         }
 676
 677 #define IBM_DEVICE(devid, sdevid, bd) {                 \
 678         PCI_DEVICE_SUB(                                 \
 679                 PCI_VENDOR_ID_EXAR,                     \
 680                 PCI_DEVICE_ID_EXAR_##devid,             \
 681                 PCI_VENDOR_ID_IBM,                      \
 682                 PCI_SUBDEVICE_ID_IBM_##sdevid), 0, 0,   \
 683                 (kernel_ulong_t)&bd                     \
 684         }
 685
 686 static const struct pci_device_id exar_pci_tbl[] = {
 687         EXAR_DEVICE(ACCESSIO, ACCES_COM_2S, acces_com_2x),
 688         EXAR_DEVICE(ACCESSIO, ACCES_COM_4S, acces_com_4x),
 689         EXAR_DEVICE(ACCESSIO, ACCES_COM_8S, acces_com_8x),
 690         EXAR_DEVICE(ACCESSIO, ACCES_COM232_8, acces_com_8x),
 691         EXAR_DEVICE(ACCESSIO, ACCES_COM_2SM, acces_com_2x),
 692         EXAR_DEVICE(ACCESSIO, ACCES_COM_4SM, acces_com_4x),
 693         EXAR_DEVICE(ACCESSIO, ACCES_COM_8SM, acces_com_8x),
 694
 695
 696         CONNECT_DEVICE(XR17C152, UART_2_232, pbn_connect),
 697         CONNECT_DEVICE(XR17C154, UART_4_232, pbn_connect),
 698         CONNECT_DEVICE(XR17C158, UART_8_232, pbn_connect),
 699         CONNECT_DEVICE(XR17C152, UART_1_1, pbn_connect),
 700         CONNECT_DEVICE(XR17C154, UART_2_2, pbn_connect),
 701         CONNECT_DEVICE(XR17C158, UART_4_4, pbn_connect),
 702         CONNECT_DEVICE(XR17C152, UART_2, pbn_connect),
 703         CONNECT_DEVICE(XR17C154, UART_4, pbn_connect),
 704         CONNECT_DEVICE(XR17C158, UART_8, pbn_connect),
 705         CONNECT_DEVICE(XR17C152, UART_2_485, pbn_connect),
 706         CONNECT_DEVICE(XR17C154, UART_4_485, pbn_connect),
 707         CONNECT_DEVICE(XR17C158, UART_8_485, pbn_connect),
 708
 709         IBM_DEVICE(XR17C152, SATURN_SERIAL_ONE_PORT, pbn_exar_ibm_saturn),
 710
 711         /* Exar Corp. XR17C15[248] Dual/Quad/Octal UART */
 712         EXAR_DEVICE(EXAR, EXAR_XR17C152, pbn_exar_XR17C15x),
 713         EXAR_DEVICE(EXAR, EXAR_XR17C154, pbn_exar_XR17C15x),
 714         EXAR_DEVICE(EXAR, EXAR_XR17C158, pbn_exar_XR17C15x),
 715
 716         /* Exar Corp. XR17V[48]35[248] Dual/Quad/Octal/Hexa PCIe UARTs */
 717         EXAR_DEVICE(EXAR, EXAR_XR17V352, pbn_exar_XR17V35x),
 718         EXAR_DEVICE(EXAR, EXAR_XR17V354, pbn_exar_XR17V35x),
 719         EXAR_DEVICE(EXAR, EXAR_XR17V358, pbn_exar_XR17V35x),
 720         EXAR_DEVICE(EXAR, EXAR_XR17V4358, pbn_exar_XR17V4358),
 721         EXAR_DEVICE(EXAR, EXAR_XR17V8358, pbn_exar_XR17V8358),
 722         EXAR_DEVICE(COMMTECH, COMMTECH_4222PCIE, pbn_fastcom35x_2),
 723         EXAR_DEVICE(COMMTECH, COMMTECH_4224PCIE, pbn_fastcom35x_4),
 724         EXAR_DEVICE(COMMTECH, COMMTECH_4228PCIE, pbn_fastcom35x_8),
 725
 726         EXAR_DEVICE(COMMTECH, COMMTECH_4222PCI335, pbn_fastcom335_2),
 727         EXAR_DEVICE(COMMTECH, COMMTECH_4224PCI335, pbn_fastcom335_4),
 728         EXAR_DEVICE(COMMTECH, COMMTECH_2324PCI335, pbn_fastcom335_4),
 729         EXAR_DEVICE(COMMTECH, COMMTECH_2328PCI335, pbn_fastcom335_8),
 730         { 0, }
 731 };
 732 MODULE_DEVICE_TABLE(pci, exar_pci_tbl);
 733
 734 static struct pci_driver exar_pci_driver = {
 735         .name           = "exar_serial",
 736         .probe          = exar_pci_probe,
 737         .remove         = exar_pci_remove,
 738         .driver         = {
 739                 .pm     = &exar_pci_pm,
 740         },
 741         .id_table       = exar_pci_tbl,
 742 };
 743 module_pci_driver(exar_pci_driver);
 744
 745 MODULE_LICENSE("GPL");
 746 MODULE_DESCRIPTION("Exar Serial Driver");
 747 MODULE_AUTHOR("Sudip Mukherjee <sudip.mukherjee@codethink.co.uk>");