drivers/serial/serial_cs.c

   1 /*======================================================================
   2
   3     A driver for PCMCIA serial devices
   4
   5     serial_cs.c 1.134 2002/05/04 05:48:53
   6
   7     The contents of this file are subject to the Mozilla Public
   8     License Version 1.1 (the "License"); you may not use this file
   9     except in compliance with the License. You may obtain a copy of
  10     the License at http://www.mozilla.org/MPL/
  11
  12     Software distributed under the License is distributed on an "AS
  13     IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  14     implied. See the License for the specific language governing
  15     rights and limitations under the License.
  16
  17     The initial developer of the original code is David A. Hinds
  18     <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
  19     are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
  20
  21     Alternatively, the contents of this file may be used under the
  22     terms of the GNU General Public License version 2 (the "GPL"), in which
  23     case the provisions of the GPL are applicable instead of the
  24     above.  If you wish to allow the use of your version of this file
  25     only under the terms of the GPL and not to allow others to use
  26     your version of this file under the MPL, indicate your decision
  27     by deleting the provisions above and replace them with the notice
  28     and other provisions required by the GPL.  If you do not delete
  29     the provisions above, a recipient may use your version of this
  30     file under either the MPL or the GPL.
  31
  32 ======================================================================*/
  33
  34 #include <linux/module.h>
  35 #include <linux/moduleparam.h>
  36 #include <linux/kernel.h>
  37 #include <linux/init.h>
  38 #include <linux/ptrace.h>
  39 #include <linux/slab.h>
  40 #include <linux/string.h>
  41 #include <linux/timer.h>
  42 #include <linux/serial_core.h>
  43 #include <linux/delay.h>
  44 #include <linux/major.h>
  45 #include <asm/io.h>
  46 #include <asm/system.h>
  47
  48 #include <pcmcia/cs_types.h>
  49 #include <pcmcia/cs.h>
  50 #include <pcmcia/cistpl.h>
  51 #include <pcmcia/ciscode.h>
  52 #include <pcmcia/ds.h>
  53 #include <pcmcia/cisreg.h>
  54
  55 #include "8250.h"
  56
  57
  58 /*====================================================================*/
  59
  60 /* Parameters that can be set with 'insmod' */
  61
  62 /* Enable the speaker? */
  63 static int do_sound = 1;
  64 /* Skip strict UART tests? */
  65 static int buggy_uart;
  66
  67 module_param(do_sound, int, 0444);
  68 module_param(buggy_uart, int, 0444);
  69
  70 /*====================================================================*/
  71
  72 /* Table of multi-port card ID's */
  73
  74 struct serial_quirk {
  75         unsigned int manfid;
  76         unsigned int prodid;
  77         int multi;              /* 1 = multifunction, > 1 = # ports */
  78         void (*config)(struct pcmcia_device *);
  79         void (*setup)(struct pcmcia_device *, struct uart_port *);
  80         void (*wakeup)(struct pcmcia_device *);
  81         int (*post)(struct pcmcia_device *);
  82 };
  83
  84 struct serial_info {
  85         struct pcmcia_device    *p_dev;
  86         int                     ndev;
  87         int                     multi;
  88         int                     slave;
  89         int                     manfid;
  90         int                     prodid;
  91         int                     c950ctrl;
  92         dev_node_t              node[4];
  93         int                     line[4];
  94         const struct serial_quirk *quirk;
  95 };
  96
  97 struct serial_cfg_mem {
  98         tuple_t tuple;
  99         cisparse_t parse;
 100         u_char buf[256];
 101 };
 102
 103 /*
 104  * vers_1 5.0, "Brain Boxes", "2-Port RS232 card", "r6"
 105  * manfid 0x0160, 0x0104
 106  * This card appears to have a 14.7456MHz clock.
 107  */
 108 /* Generic Modem: MD55x (GPRS/EDGE) have
 109  * Elan VPU16551 UART with 14.7456MHz oscillator
 110  * manfid 0x015D, 0x4C45
 111  */
 112 static void quirk_setup_brainboxes_0104(struct pcmcia_device *link, struct uart_port *port)
 113 {
 114         port->uartclk = 14745600;
 115 }
 116
 117 static int quirk_post_ibm(struct pcmcia_device *link)
 118 {
 119         conf_reg_t reg = { 0, CS_READ, 0x800, 0 };
 120         int ret;
 121
 122         ret = pcmcia_access_configuration_register(link, &reg);
 123         if (ret)
 124                 goto failed;
 125
 126         reg.Action = CS_WRITE;
 127         reg.Value = reg.Value | 1;
 128         ret = pcmcia_access_configuration_register(link, &reg);
 129         if (ret)
 130                 goto failed;
 131         return 0;
 132
 133  failed:
 134         return -ENODEV;
 135 }
 136
 137 /*
 138  * Nokia cards are not really multiport cards.  Shouldn't this
 139  * be handled by setting the quirk entry .multi = 0 | 1 ?
 140  */
 141 static void quirk_config_nokia(struct pcmcia_device *link)
 142 {
 143         struct serial_info *info = link->priv;
 144
 145         if (info->multi > 1)
 146                 info->multi = 1;
 147 }
 148
 149 static void quirk_wakeup_oxsemi(struct pcmcia_device *link)
 150 {
 151         struct serial_info *info = link->priv;
 152
 153         if (info->c950ctrl)
 154                 outb(12, info->c950ctrl + 1);
 155 }
 156
 157 /* request_region? oxsemi branch does no request_region too... */
 158 /*
 159  * This sequence is needed to properly initialize MC45 attached to OXCF950.
 160  * I tried decreasing these msleep()s, but it worked properly (survived
 161  * 1000 stop/start operations) with these timeouts (or bigger).
 162  */
 163 static void quirk_wakeup_possio_gcc(struct pcmcia_device *link)
 164 {
 165         struct serial_info *info = link->priv;
 166         unsigned int ctrl = info->c950ctrl;
 167
 168         outb(0xA, ctrl + 1);
 169         msleep(100);
 170         outb(0xE, ctrl + 1);
 171         msleep(300);
 172         outb(0xC, ctrl + 1);
 173         msleep(100);
 174         outb(0xE, ctrl + 1);
 175         msleep(200);
 176         outb(0xF, ctrl + 1);
 177         msleep(100);
 178         outb(0xE, ctrl + 1);
 179         msleep(100);
 180         outb(0xC, ctrl + 1);
 181 }
 182
 183 /*
 184  * Socket Dual IO: this enables irq's for second port
 185  */
 186 static void quirk_config_socket(struct pcmcia_device *link)
 187 {
 188         struct serial_info *info = link->priv;
 189
 190         if (info->multi) {
 191                 link->conf.Present |= PRESENT_EXT_STATUS;
 192                 link->conf.ExtStatus = ESR_REQ_ATTN_ENA;
 193         }
 194 }
 195
 196 static const struct serial_quirk quirks[] = {
 197         {
 198                 .manfid = 0x0160,
 199                 .prodid = 0x0104,
 200                 .multi  = -1,
 201                 .setup  = quirk_setup_brainboxes_0104,
 202         }, {
 203                 .manfid = 0x015D,
 204                 .prodid = 0x4C45,
 205                 .multi  = -1,
 206                 .setup  = quirk_setup_brainboxes_0104,
 207         }, {
 208                 .manfid = MANFID_IBM,
 209                 .prodid = ~0,
 210                 .multi  = -1,
 211                 .post   = quirk_post_ibm,
 212         }, {
 213                 .manfid = MANFID_INTEL,
 214                 .prodid = PRODID_INTEL_DUAL_RS232,
 215                 .multi  = 2,
 216         }, {
 217                 .manfid = MANFID_NATINST,
 218                 .prodid = PRODID_NATINST_QUAD_RS232,
 219                 .multi  = 4,
 220         }, {
 221                 .manfid = MANFID_NOKIA,
 222                 .prodid = ~0,
 223                 .multi  = -1,
 224                 .config = quirk_config_nokia,
 225         }, {
 226                 .manfid = MANFID_OMEGA,
 227                 .prodid = PRODID_OMEGA_QSP_100,
 228                 .multi  = 4,
 229         }, {
 230                 .manfid = MANFID_OXSEMI,
 231                 .prodid = ~0,
 232                 .multi  = -1,
 233                 .wakeup = quirk_wakeup_oxsemi,
 234         }, {
 235                 .manfid = MANFID_POSSIO,
 236                 .prodid = PRODID_POSSIO_GCC,
 237                 .multi  = -1,
 238                 .wakeup = quirk_wakeup_possio_gcc,
 239         }, {
 240                 .manfid = MANFID_QUATECH,
 241                 .prodid = PRODID_QUATECH_DUAL_RS232,
 242                 .multi  = 2,
 243         }, {
 244                 .manfid = MANFID_QUATECH,
 245                 .prodid = PRODID_QUATECH_DUAL_RS232_D1,
 246                 .multi  = 2,
 247         }, {
 248                 .manfid = MANFID_QUATECH,
 249                 .prodid = PRODID_QUATECH_DUAL_RS232_G,
 250                 .multi  = 2,
 251         }, {
 252                 .manfid = MANFID_QUATECH,
 253                 .prodid = PRODID_QUATECH_QUAD_RS232,
 254                 .multi  = 4,
 255         }, {
 256                 .manfid = MANFID_SOCKET,
 257                 .prodid = PRODID_SOCKET_DUAL_RS232,
 258                 .multi  = 2,
 259                 .config = quirk_config_socket,
 260         }, {
 261                 .manfid = MANFID_SOCKET,
 262                 .prodid = ~0,
 263                 .multi  = -1,
 264                 .config = quirk_config_socket,
 265         }
 266 };
 267
 268
 269 static int serial_config(struct pcmcia_device * link);
 270
 271
 272 /*======================================================================
 273
 274     After a card is removed, serial_remove() will unregister
 275     the serial device(s), and release the PCMCIA configuration.
 276
 277 ======================================================================*/
 278
 279 static void serial_remove(struct pcmcia_device *link)
 280 {
 281         struct serial_info *info = link->priv;
 282         int i;
 283
 284         dev_dbg(&link->dev, "serial_release\n");
 285
 286         /*
 287          * Recheck to see if the device is still configured.
 288          */
 289         for (i = 0; i < info->ndev; i++)
 290                 serial8250_unregister_port(info->line[i]);
 291
 292         info->p_dev->dev_node = NULL;
 293
 294         if (!info->slave)
 295                 pcmcia_disable_device(link);
 296 }
 297
 298 static int serial_suspend(struct pcmcia_device *link)
 299 {
 300         struct serial_info *info = link->priv;
 301         int i;
 302
 303         for (i = 0; i < info->ndev; i++)
 304                 serial8250_suspend_port(info->line[i]);
 305
 306         return 0;
 307 }
 308
 309 static int serial_resume(struct pcmcia_device *link)
 310 {
 311         struct serial_info *info = link->priv;
 312         int i;
 313
 314         for (i = 0; i < info->ndev; i++)
 315                 serial8250_resume_port(info->line[i]);
 316
 317         if (info->quirk && info->quirk->wakeup)
 318                 info->quirk->wakeup(link);
 319
 320         return 0;
 321 }
 322
 323 /*======================================================================
 324
 325     serial_attach() creates an "instance" of the driver, allocating
 326     local data structures for one device.  The device is registered
 327     with Card Services.
 328
 329 ======================================================================*/
 330
 331 static int serial_probe(struct pcmcia_device *link)
 332 {
 333         struct serial_info *info;
 334
 335         dev_dbg(&link->dev, "serial_attach()\n");
 336
 337         /* Create new serial device */
 338         info = kzalloc(sizeof (*info), GFP_KERNEL);
 339         if (!info)
 340                 return -ENOMEM;
 341         info->p_dev = link;
 342         link->priv = info;
 343
 344         link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
 345         link->io.NumPorts1 = 8;
 346         link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING;
 347         link->conf.Attributes = CONF_ENABLE_IRQ;
 348         if (do_sound) {
 349                 link->conf.Attributes |= CONF_ENABLE_SPKR;
 350                 link->conf.Status = CCSR_AUDIO_ENA;
 351         }
 352         link->conf.IntType = INT_MEMORY_AND_IO;
 353
 354         return serial_config(link);
 355 }
 356
 357 /*======================================================================
 358
 359     This deletes a driver "instance".  The device is de-registered
 360     with Card Services.  If it has been released, all local data
 361     structures are freed.  Otherwise, the structures will be freed
 362     when the device is released.
 363
 364 ======================================================================*/
 365
 366 static void serial_detach(struct pcmcia_device *link)
 367 {
 368         struct serial_info *info = link->priv;
 369
 370         dev_dbg(&link->dev, "serial_detach\n");
 371
 372         /*
 373          * Ensure any outstanding scheduled tasks are completed.
 374          */
 375         flush_scheduled_work();
 376
 377         /*
 378          * Ensure that the ports have been released.
 379          */
 380         serial_remove(link);
 381
 382         /* free bits */
 383         kfree(info);
 384 }
 385
 386 /*====================================================================*/
 387
 388 static int setup_serial(struct pcmcia_device *handle, struct serial_info * info,
 389                         unsigned int iobase, int irq)
 390 {
 391         struct uart_port port;
 392         int line;
 393
 394         memset(&port, 0, sizeof (struct uart_port));
 395         port.iobase = iobase;
 396         port.irq = irq;
 397         port.flags = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST | UPF_SHARE_IRQ;
 398         port.uartclk = 1843200;
 399         port.dev = &handle->dev;
 400         if (buggy_uart)
 401                 port.flags |= UPF_BUGGY_UART;
 402
 403         if (info->quirk && info->quirk->setup)
 404                 info->quirk->setup(handle, &port);
 405
 406         line = serial8250_register_port(&port);
 407         if (line < 0) {
 408                 printk(KERN_NOTICE "serial_cs: serial8250_register_port() at "
 409                        "0x%04lx, irq %d failed\n", (u_long)iobase, irq);
 410                 return -EINVAL;
 411         }
 412
 413         info->line[info->ndev] = line;
 414         sprintf(info->node[info->ndev].dev_name, "ttyS%d", line);
 415         info->node[info->ndev].major = TTY_MAJOR;
 416         info->node[info->ndev].minor = 0x40 + line;
 417         if (info->ndev > 0)
 418                 info->node[info->ndev - 1].next = &info->node[info->ndev];
 419         info->ndev++;
 420
 421         return 0;
 422 }
 423
 424 /*====================================================================*/
 425
 426 static int simple_config_check(struct pcmcia_device *p_dev,
 427                                cistpl_cftable_entry_t *cf,
 428                                cistpl_cftable_entry_t *dflt,
 429                                unsigned int vcc,
 430                                void *priv_data)
 431 {
 432         static const int size_table[2] = { 8, 16 };
 433         int *try = priv_data;
 434
 435         if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
 436                 p_dev->conf.Vpp =
 437                         cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
 438
 439         if ((cf->io.nwin > 0) && (cf->io.win[0].len == size_table[(*try >> 1)])
 440             && (cf->io.win[0].base != 0)) {
 441                 p_dev->io.BasePort1 = cf->io.win[0].base;
 442                 p_dev->io.IOAddrLines = ((*try & 0x1) == 0) ?
 443                         16 : cf->io.flags & CISTPL_IO_LINES_MASK;
 444                 if (!pcmcia_request_io(p_dev, &p_dev->io))
 445                         return 0;
 446         }
 447         return -EINVAL;
 448 }
 449
 450 static int simple_config_check_notpicky(struct pcmcia_device *p_dev,
 451                                         cistpl_cftable_entry_t *cf,
 452                                         cistpl_cftable_entry_t *dflt,
 453                                         unsigned int vcc,
 454                                         void *priv_data)
 455 {
 456         static const unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
 457         int j;
 458
 459         if ((cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
 460                 for (j = 0; j < 5; j++) {
 461                         p_dev->io.BasePort1 = base[j];
 462                         p_dev->io.IOAddrLines = base[j] ? 16 : 3;
 463                         if (!pcmcia_request_io(p_dev, &p_dev->io))
 464                                 return 0;
 465                 }
 466         }
 467         return -ENODEV;
 468 }
 469
 470 static int simple_config(struct pcmcia_device *link)
 471 {
 472         struct serial_info *info = link->priv;
 473         int i = -ENODEV, try;
 474
 475         /* If the card is already configured, look up the port and irq */
 476         if (link->function_config) {
 477                 unsigned int port = 0;
 478                 if ((link->io.BasePort2 != 0) &&
 479                     (link->io.NumPorts2 == 8)) {
 480                         port = link->io.BasePort2;
 481                         info->slave = 1;
 482                 } else if ((info->manfid == MANFID_OSITECH) &&
 483                            (link->io.NumPorts1 == 0x40)) {
 484                         port = link->io.BasePort1 + 0x28;
 485                         info->slave = 1;
 486                 }
 487                 if (info->slave) {
 488                         return setup_serial(link, info, port,
 489                                             link->irq.AssignedIRQ);
 490                 }
 491         }
 492
 493         /* First pass: look for a config entry that looks normal.
 494          * Two tries: without IO aliases, then with aliases */
 495         for (try = 0; try < 4; try++)
 496                 if (!pcmcia_loop_config(link, simple_config_check, &try))
 497                         goto found_port;
 498
 499         /* Second pass: try to find an entry that isn't picky about
 500            its base address, then try to grab any standard serial port
 501            address, and finally try to get any free port. */
 502         if (!pcmcia_loop_config(link, simple_config_check_notpicky, NULL))
 503                 goto found_port;
 504
 505         printk(KERN_NOTICE
 506                "serial_cs: no usable port range found, giving up\n");
 507         return -1;
 508
 509 found_port:
 510         i = pcmcia_request_irq(link, &link->irq);
 511         if (i != 0)
 512                 link->irq.AssignedIRQ = 0;
 513
 514         if (info->multi && (info->manfid == MANFID_3COM))
 515                 link->conf.ConfigIndex &= ~(0x08);
 516
 517         /*
 518          * Apply any configuration quirks.
 519          */
 520         if (info->quirk && info->quirk->config)
 521                 info->quirk->config(link);
 522
 523         i = pcmcia_request_configuration(link, &link->conf);
 524         if (i != 0)
 525                 return -1;
 526         return setup_serial(link, info, link->io.BasePort1, link->irq.AssignedIRQ);
 527 }
 528
 529 static int multi_config_check(struct pcmcia_device *p_dev,
 530                               cistpl_cftable_entry_t *cf,
 531                               cistpl_cftable_entry_t *dflt,
 532                               unsigned int vcc,
 533                               void *priv_data)
 534 {
 535         int *base2 = priv_data;
 536
 537         /* The quad port cards have bad CIS's, so just look for a
 538            window larger than 8 ports and assume it will be right */
 539         if ((cf->io.nwin == 1) && (cf->io.win[0].len > 8)) {
 540                 p_dev->io.BasePort1 = cf->io.win[0].base;
 541                 p_dev->io.IOAddrLines = cf->io.flags & CISTPL_IO_LINES_MASK;
 542                 if (!pcmcia_request_io(p_dev, &p_dev->io)) {
 543                         *base2 = p_dev->io.BasePort1 + 8;
 544                         return 0;
 545                 }
 546         }
 547         return -ENODEV;
 548 }
 549
 550 static int multi_config_check_notpicky(struct pcmcia_device *p_dev,
 551                                        cistpl_cftable_entry_t *cf,
 552                                        cistpl_cftable_entry_t *dflt,
 553                                        unsigned int vcc,
 554                                        void *priv_data)
 555 {
 556         int *base2 = priv_data;
 557
 558         if (cf->io.nwin == 2) {
 559                 p_dev->io.BasePort1 = cf->io.win[0].base;
 560                 p_dev->io.BasePort2 = cf->io.win[1].base;
 561                 p_dev->io.IOAddrLines = cf->io.flags & CISTPL_IO_LINES_MASK;
 562                 if (!pcmcia_request_io(p_dev, &p_dev->io)) {
 563                         *base2 = p_dev->io.BasePort2;
 564                         return 0;
 565                 }
 566         }
 567         return -ENODEV;
 568 }
 569
 570 static int multi_config(struct pcmcia_device *link)
 571 {
 572         struct serial_info *info = link->priv;
 573         int i, base2 = 0;
 574
 575         /* First, look for a generic full-sized window */
 576         link->io.NumPorts1 = info->multi * 8;
 577         if (pcmcia_loop_config(link, multi_config_check, &base2)) {
 578                 /* If that didn't work, look for two windows */
 579                 link->io.NumPorts1 = link->io.NumPorts2 = 8;
 580                 info->multi = 2;
 581                 if (pcmcia_loop_config(link, multi_config_check_notpicky,
 582                                        &base2)) {
 583                         printk(KERN_NOTICE "serial_cs: no usable port range"
 584                                "found, giving up\n");
 585                         return -ENODEV;
 586                 }
 587         }
 588
 589         i = pcmcia_request_irq(link, &link->irq);
 590         if (i != 0) {
 591                 /* FIXME: comment does not fit, error handling does not fit */
 592                 printk(KERN_NOTICE
 593                        "serial_cs: no usable port range found, giving up\n");
 594                 link->irq.AssignedIRQ = 0;
 595         }
 596
 597         /*
 598          * Apply any configuration quirks.
 599          */
 600         if (info->quirk && info->quirk->config)
 601                 info->quirk->config(link);
 602
 603         i = pcmcia_request_configuration(link, &link->conf);
 604         if (i != 0)
 605                 return -ENODEV;
 606
 607         /* The Oxford Semiconductor OXCF950 cards are in fact single-port:
 608          * 8 registers are for the UART, the others are extra registers.
 609          * Siemen's MC45 PCMCIA (Possio's GCC) is OXCF950 based too.
 610          */
 611         if (info->manfid == MANFID_OXSEMI || (info->manfid == MANFID_POSSIO &&
 612                                 info->prodid == PRODID_POSSIO_GCC)) {
 613                 int err;
 614
 615                 if (link->conf.ConfigIndex == 1 ||
 616                     link->conf.ConfigIndex == 3) {
 617                         err = setup_serial(link, info, base2,
 618                                         link->irq.AssignedIRQ);
 619                         base2 = link->io.BasePort1;
 620                 } else {
 621                         err = setup_serial(link, info, link->io.BasePort1,
 622                                         link->irq.AssignedIRQ);
 623                 }
 624                 info->c950ctrl = base2;
 625
 626                 /*
 627                  * FIXME: We really should wake up the port prior to
 628                  * handing it over to the serial layer.
 629                  */
 630                 if (info->quirk && info->quirk->wakeup)
 631                         info->quirk->wakeup(link);
 632
 633                 return 0;
 634         }
 635
 636         setup_serial(link, info, link->io.BasePort1, link->irq.AssignedIRQ);
 637         for (i = 0; i < info->multi - 1; i++)
 638                 setup_serial(link, info, base2 + (8 * i),
 639                                 link->irq.AssignedIRQ);
 640         return 0;
 641 }
 642
 643 static int serial_check_for_multi(struct pcmcia_device *p_dev,
 644                                   cistpl_cftable_entry_t *cf,
 645                                   cistpl_cftable_entry_t *dflt,
 646                                   unsigned int vcc,
 647                                   void *priv_data)
 648 {
 649         struct serial_info *info = p_dev->priv;
 650
 651         if ((cf->io.nwin == 1) && (cf->io.win[0].len % 8 == 0))
 652                 info->multi = cf->io.win[0].len >> 3;
 653
 654         if ((cf->io.nwin == 2) && (cf->io.win[0].len == 8) &&
 655                 (cf->io.win[1].len == 8))
 656                 info->multi = 2;
 657
 658         return 0; /* break */
 659 }
 660
 661
 662 /*======================================================================
 663
 664     serial_config() is scheduled to run after a CARD_INSERTION event
 665     is received, to configure the PCMCIA socket, and to make the
 666     serial device available to the system.
 667
 668 ======================================================================*/
 669
 670 static int serial_config(struct pcmcia_device * link)
 671 {
 672         struct serial_info *info = link->priv;
 673         int i;
 674
 675         dev_dbg(&link->dev, "serial_config\n");
 676
 677         /* Is this a compliant multifunction card? */
 678         info->multi = (link->socket->functions > 1);
 679
 680         /* Is this a multiport card? */
 681         info->manfid = link->manf_id;
 682         info->prodid = link->card_id;
 683
 684         for (i = 0; i < ARRAY_SIZE(quirks); i++)
 685                 if ((quirks[i].manfid == ~0 ||
 686                      quirks[i].manfid == info->manfid) &&
 687                     (quirks[i].prodid == ~0 ||
 688                      quirks[i].prodid == info->prodid)) {
 689                         info->quirk = &quirks[i];
 690                         break;
 691                 }
 692
 693         /* Another check for dual-serial cards: look for either serial or
 694            multifunction cards that ask for appropriate IO port ranges */
 695         if ((info->multi == 0) &&
 696             (link->has_func_id) &&
 697             ((link->func_id == CISTPL_FUNCID_MULTI) ||
 698              (link->func_id == CISTPL_FUNCID_SERIAL)))
 699                 pcmcia_loop_config(link, serial_check_for_multi, info);
 700
 701         /*
 702          * Apply any multi-port quirk.
 703          */
 704         if (info->quirk && info->quirk->multi != -1)
 705                 info->multi = info->quirk->multi;
 706
 707         if (info->multi > 1)
 708                 i = multi_config(link);
 709         else
 710                 i = simple_config(link);
 711
 712         if (i || info->ndev == 0)
 713                 goto failed;
 714
 715         /*
 716          * Apply any post-init quirk.  FIXME: This should really happen
 717          * before we register the port, since it might already be in use.
 718          */
 719         if (info->quirk && info->quirk->post)
 720                 if (info->quirk->post(link))
 721                         goto failed;
 722
 723         link->dev_node = &info->node[0];
 724         return 0;
 725
 726 failed:
 727         dev_warn(&link->dev, "serial_cs: failed to initialize\n");
 728         serial_remove(link);
 729         return -ENODEV;
 730 }
 731
 732 static struct pcmcia_device_id serial_ids[] = {
 733         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0057, 0x0021),
 734         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0089, 0x110a),
 735         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0104, 0x000a),
 736         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0105, 0xea15),
 737         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0109, 0x0501),
 738         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0138, 0x110a),
 739         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0140, 0x000a),
 740         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0143, 0x3341),
 741         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0143, 0xc0ab),
 742         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x016c, 0x0081),
 743         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x021b, 0x0101),
 744         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x08a1, 0xc0ab),
 745         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0105, 0x0d0a),
 746         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0105, 0x0e0a),
 747         PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "CC/XJEM3288", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x04cd2988, 0x46a52d63),
 748         PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "CC/XJEM3336", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x0143b773, 0x46a52d63),
 749         PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "EM1144T", "PCMCIA MODEM", 0xf510db04, 0x856d66c8, 0xbd6c43ef),
 750         PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "XJEM1144/CCEM1144", "PCMCIA MODEM", 0xf510db04, 0x52d21e1e, 0xbd6c43ef),
 751         PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "CEM28", 0x2e3ee845, 0x0ea978ea),
 752         PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "CEM33", 0x2e3ee845, 0x80609023),
 753         PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "CEM56", 0x2e3ee845, 0xa650c32a),
 754         PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "REM10", 0x2e3ee845, 0x76df1d29),
 755         PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "XEM5600", 0x2e3ee845, 0xf1403719),
 756         PCMCIA_PFC_DEVICE_PROD_ID12(1, "AnyCom", "Fast Ethernet + 56K COMBO", 0x578ba6e7, 0xb0ac62c4),
 757         PCMCIA_PFC_DEVICE_PROD_ID12(1, "ATKK", "LM33-PCM-T", 0xba9eb7e2, 0x077c174e),
 758         PCMCIA_PFC_DEVICE_PROD_ID12(1, "D-Link", "DME336T", 0x1a424a1c, 0xb23897ff),
 759         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Gateway 2000", "XJEM3336", 0xdd9989be, 0x662c394c),
 760         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Grey Cell", "GCS3000", 0x2a151fac, 0x48b932ae),
 761         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Linksys", "EtherFast 10&100 + 56K PC Card (PCMLM56)", 0x0733cc81, 0xb3765033),
 762         PCMCIA_PFC_DEVICE_PROD_ID12(1, "LINKSYS", "PCMLM336", 0xf7cb0b07, 0x7a821b58),
 763         PCMCIA_PFC_DEVICE_PROD_ID12(1, "MEGAHERTZ", "XJEM1144/CCEM1144", 0xf510db04, 0x52d21e1e),
 764         PCMCIA_PFC_DEVICE_PROD_ID12(1, "MICRO RESEARCH", "COMBO-L/M-336", 0xb2ced065, 0x3ced0555),
 765         PCMCIA_PFC_DEVICE_PROD_ID12(1, "NEC", "PK-UG-J001" ,0x18df0ba0 ,0x831b1064),
 766         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Ositech", "Trumpcard:Jack of Diamonds Modem+Ethernet", 0xc2f80cd, 0x656947b9),
 767         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Ositech", "Trumpcard:Jack of Hearts Modem+Ethernet", 0xc2f80cd, 0xdc9ba5ed),
 768         PCMCIA_PFC_DEVICE_PROD_ID12(1, "PCMCIAs", "ComboCard", 0xdcfe12d3, 0xcd8906cc),
 769         PCMCIA_PFC_DEVICE_PROD_ID12(1, "PCMCIAs", "LanModem", 0xdcfe12d3, 0xc67c648f),
 770         PCMCIA_PFC_DEVICE_PROD_ID12(1, "TDK", "GlobalNetworker 3410/3412", 0x1eae9475, 0xd9a93bed),
 771         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Xircom", "CreditCard Ethernet+Modem II", 0x2e3ee845, 0xeca401bf),
 772         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0032, 0x0e01),
 773         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0032, 0x0a05),
 774         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0032, 0x1101),
 775         PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x0104, 0x0070),
 776         PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x0101, 0x0562),
 777         PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x0104, 0x0070),
 778         PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x016c, 0x0020),
 779         PCMCIA_MFC_DEVICE_PROD_ID123(1, "APEX DATA", "MULTICARD", "ETHERNET-MODEM", 0x11c2da09, 0x7289dc5d, 0xaad95e1f),
 780         PCMCIA_MFC_DEVICE_PROD_ID12(1, "IBM", "Home and Away 28.8 PC Card       ", 0xb569a6e5, 0x5bd4ff2c),
 781         PCMCIA_MFC_DEVICE_PROD_ID12(1, "IBM", "Home and Away Credit Card Adapter", 0xb569a6e5, 0x4bdf15c3),
 782         PCMCIA_MFC_DEVICE_PROD_ID12(1, "IBM", "w95 Home and Away Credit Card ", 0xb569a6e5, 0xae911c15),
 783         PCMCIA_MFC_DEVICE_PROD_ID1(1, "Motorola MARQUIS", 0xf03e4e77),
 784         PCMCIA_MFC_DEVICE_PROD_ID2(1, "FAX/Modem/Ethernet Combo Card ", 0x1ed59302),
 785         PCMCIA_DEVICE_MANF_CARD(0x0089, 0x0301),
 786         PCMCIA_DEVICE_MANF_CARD(0x00a4, 0x0276),
 787         PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0039),
 788         PCMCIA_DEVICE_MANF_CARD(0x0104, 0x0006),
 789         PCMCIA_DEVICE_MANF_CARD(0x0105, 0x410a),
 790         PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0d50),
 791         PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0d51),
 792         PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0d52),
 793         PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0d53),
 794         PCMCIA_DEVICE_MANF_CARD(0x010b, 0xd180),
 795         PCMCIA_DEVICE_MANF_CARD(0x0137, 0x000e),
 796         PCMCIA_DEVICE_MANF_CARD(0x0137, 0x001b),
 797         PCMCIA_DEVICE_MANF_CARD(0x0137, 0x0025),
 798         PCMCIA_DEVICE_MANF_CARD(0x0137, 0x0045),
 799         PCMCIA_DEVICE_MANF_CARD(0x0137, 0x0052),
 800         PCMCIA_DEVICE_PROD_ID134("ADV", "TECH", "COMpad-32/85", 0x67459937, 0x916d02ba, 0x8fbe92ae),
 801         PCMCIA_DEVICE_PROD_ID124("GATEWAY2000", "CC3144", "PCMCIA MODEM", 0x506bccae, 0xcb3685f1, 0xbd6c43ef),
 802         PCMCIA_DEVICE_PROD_ID14("MEGAHERTZ", "PCMCIA MODEM", 0xf510db04, 0xbd6c43ef),
 803         PCMCIA_DEVICE_PROD_ID124("TOSHIBA", "T144PF", "PCMCIA MODEM", 0xb4585a1a, 0x7271409c, 0xbd6c43ef),
 804         PCMCIA_DEVICE_PROD_ID123("FUJITSU", "FC14F ", "MBH10213", 0x6ee5a3d8, 0x30ead12b, 0xb00f05a0),
 805         PCMCIA_DEVICE_PROD_ID123("Novatel Wireless", "Merlin UMTS Modem", "U630", 0x32607776, 0xd9e73b13, 0xe87332e),
 806         PCMCIA_DEVICE_PROD_ID13("MEGAHERTZ", "V.34 PCMCIA MODEM", 0xf510db04, 0xbb2cce4a),
 807         PCMCIA_DEVICE_PROD_ID12("Brain Boxes", "Bluetooth PC Card", 0xee138382, 0xd4ce9b02),
 808         PCMCIA_DEVICE_PROD_ID12("CIRRUS LOGIC", "FAX MODEM", 0xe625f451, 0xcecd6dfa),
 809         PCMCIA_DEVICE_PROD_ID12("COMPAQ", "PCMCIA 28800 FAX/DATA MODEM", 0xa3a3062c, 0x8cbd7c76),
 810         PCMCIA_DEVICE_PROD_ID12("COMPAQ", "PCMCIA 33600 FAX/DATA MODEM", 0xa3a3062c, 0x5a00ce95),
 811         PCMCIA_DEVICE_PROD_ID12("Computerboards, Inc.", "PCM-COM422", 0xd0b78f51, 0x7e2d49ed),
 812         PCMCIA_DEVICE_PROD_ID12("Dr. Neuhaus", "FURY CARD 14K4", 0x76942813, 0x8b96ce65),
 813         PCMCIA_DEVICE_PROD_ID12("Intelligent", "ANGIA FAX/MODEM", 0xb496e65e, 0xf31602a6),
 814         PCMCIA_DEVICE_PROD_ID12("Intel", "MODEM 2400+", 0x816cc815, 0x412729fb),
 815         PCMCIA_DEVICE_PROD_ID12("IOTech Inc ", "PCMCIA Dual RS-232 Serial Port Card", 0x3bd2d898, 0x92abc92f),
 816         PCMCIA_DEVICE_PROD_ID12("MACRONIX", "FAX/MODEM", 0x668388b3, 0x3f9bdf2f),
 817         PCMCIA_DEVICE_PROD_ID12("Multi-Tech", "MT1432LT", 0x5f73be51, 0x0b3e2383),
 818         PCMCIA_DEVICE_PROD_ID12("Multi-Tech", "MT2834LT", 0x5f73be51, 0x4cd7c09e),
 819         PCMCIA_DEVICE_PROD_ID12("OEM      ", "C288MX     ", 0xb572d360, 0xd2385b7a),
 820         PCMCIA_DEVICE_PROD_ID12("PCMCIA   ", "C336MX     ", 0x99bcafe9, 0xaa25bcab),
 821         PCMCIA_DEVICE_PROD_ID12("Quatech Inc", "PCMCIA Dual RS-232 Serial Port Card", 0xc4420b35, 0x92abc92f),
 822         PCMCIA_DEVICE_PROD_ID12("Quatech Inc", "Dual RS-232 Serial Port PC Card", 0xc4420b35, 0x031a380d),
 823         PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "PCMCIA", "EN2218-LAN/MODEM", 0x281f1c5d, 0x570f348e, "cis/PCMLM28.cis"),
 824         PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "PCMCIA", "UE2218-LAN/MODEM", 0x281f1c5d, 0x6fdcacee, "cis/PCMLM28.cis"),
 825         PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "Psion Dacom", "Gold Card V34 Ethernet", 0xf5f025c2, 0x338e8155, "cis/PCMLM28.cis"),
 826         PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "Psion Dacom", "Gold Card V34 Ethernet GSM", 0xf5f025c2, 0x4ae85d35, "cis/PCMLM28.cis"),
 827         PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "LINKSYS", "PCMLM28", 0xf7cb0b07, 0x66881874, "cis/PCMLM28.cis"),
 828         PCMCIA_MFC_DEVICE_CIS_PROD_ID12(1, "DAYNA COMMUNICATIONS", "LAN AND MODEM MULTIFUNCTION", 0x8fdf8f89, 0xdd5ed9e8, "cis/DP83903.cis"),
 829         PCMCIA_MFC_DEVICE_CIS_PROD_ID4(1, "NSC MF LAN/Modem", 0x58fc6056, "cis/DP83903.cis"),
 830         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x0556, "cis/3CCFEM556.cis"),
 831         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0175, 0x0000, "cis/DP83903.cis"),
 832         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x0035, "cis/3CXEM556.cis"),
 833         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x003d, "cis/3CXEM556.cis"),
 834         PCMCIA_DEVICE_CIS_PROD_ID12("Sierra Wireless", "AC850", 0xd85f6206, 0x42a2c018, "cis/SW_8xx_SER.cis"), /* Sierra Wireless AC850 3G Network Adapter R1 */
 835         PCMCIA_DEVICE_CIS_PROD_ID12("Sierra Wireless", "AC860", 0xd85f6206, 0x698f93db, "cis/SW_8xx_SER.cis"), /* Sierra Wireless AC860 3G Network Adapter R1 */
 836         PCMCIA_DEVICE_CIS_PROD_ID12("Sierra Wireless", "AC710/AC750", 0xd85f6206, 0x761b11e0, "cis/SW_7xx_SER.cis"),  /* Sierra Wireless AC710/AC750 GPRS Network Adapter R1 */
 837         PCMCIA_DEVICE_CIS_MANF_CARD(0x0192, 0xa555, "cis/SW_555_SER.cis"),  /* Sierra Aircard 555 CDMA 1xrtt Modem -- pre update */
 838         PCMCIA_DEVICE_CIS_MANF_CARD(0x013f, 0xa555, "cis/SW_555_SER.cis"),  /* Sierra Aircard 555 CDMA 1xrtt Modem -- post update */
 839         PCMCIA_DEVICE_CIS_PROD_ID12("MultiTech", "PCMCIA 56K DataFax", 0x842047ee, 0xc2efcf03, "cis/MT5634ZLX.cis"),
 840         PCMCIA_DEVICE_CIS_PROD_ID12("ADVANTECH", "COMpad-32/85B-2", 0x96913a85, 0x27ab5437, "cis/COMpad2.cis"),
 841         PCMCIA_DEVICE_CIS_PROD_ID12("ADVANTECH", "COMpad-32/85B-4", 0x96913a85, 0xcec8f102, "cis/COMpad4.cis"),
 842         PCMCIA_DEVICE_CIS_PROD_ID123("ADVANTECH", "COMpad-32/85", "1.0", 0x96913a85, 0x8fbe92ae, 0x0877b627, "cis/COMpad2.cis"),
 843         PCMCIA_DEVICE_CIS_PROD_ID2("RS-COM 2P", 0xad20b156, "cis/RS-COM-2P.cis"),
 844         PCMCIA_DEVICE_CIS_MANF_CARD(0x0013, 0x0000, "cis/GLOBETROTTER.cis"),
 845         PCMCIA_DEVICE_PROD_ID12("ELAN DIGITAL SYSTEMS LTD, c1997.","SERIAL CARD: SL100  1.00.",0x19ca78af,0xf964f42b),
 846         PCMCIA_DEVICE_PROD_ID12("ELAN DIGITAL SYSTEMS LTD, c1997.","SERIAL CARD: SL100",0x19ca78af,0x71d98e83),
 847         PCMCIA_DEVICE_PROD_ID12("ELAN DIGITAL SYSTEMS LTD, c1997.","SERIAL CARD: SL232  1.00.",0x19ca78af,0x69fb7490),
 848         PCMCIA_DEVICE_PROD_ID12("ELAN DIGITAL SYSTEMS LTD, c1997.","SERIAL CARD: SL232",0x19ca78af,0xb6bc0235),
 849         PCMCIA_DEVICE_PROD_ID12("ELAN DIGITAL SYSTEMS LTD, c2000.","SERIAL CARD: CF232",0x63f2e0bd,0xb9e175d3),
 850         PCMCIA_DEVICE_PROD_ID12("ELAN DIGITAL SYSTEMS LTD, c2000.","SERIAL CARD: CF232-5",0x63f2e0bd,0xfce33442),
 851         PCMCIA_DEVICE_PROD_ID12("Elan","Serial Port: CF232",0x3beb8cf2,0x171e7190),
 852         PCMCIA_DEVICE_PROD_ID12("Elan","Serial Port: CF232-5",0x3beb8cf2,0x20da4262),
 853         PCMCIA_DEVICE_PROD_ID12("Elan","Serial Port: CF428",0x3beb8cf2,0xea5dd57d),
 854         PCMCIA_DEVICE_PROD_ID12("Elan","Serial Port: CF500",0x3beb8cf2,0xd77255fa),
 855         PCMCIA_DEVICE_PROD_ID12("Elan","Serial Port: IC232",0x3beb8cf2,0x6a709903),
 856         PCMCIA_DEVICE_PROD_ID12("Elan","Serial Port: SL232",0x3beb8cf2,0x18430676),
 857         PCMCIA_DEVICE_PROD_ID12("Elan","Serial Port: XL232",0x3beb8cf2,0x6f933767),
 858         PCMCIA_MFC_DEVICE_PROD_ID12(0,"Elan","Serial Port: CF332",0x3beb8cf2,0x16dc1ba7),
 859         PCMCIA_MFC_DEVICE_PROD_ID12(0,"Elan","Serial Port: SL332",0x3beb8cf2,0x19816c41),
 860         PCMCIA_MFC_DEVICE_PROD_ID12(0,"Elan","Serial Port: SL385",0x3beb8cf2,0x64112029),
 861         PCMCIA_MFC_DEVICE_PROD_ID12(0,"Elan","Serial Port: SL432",0x3beb8cf2,0x1cce7ac4),
 862         PCMCIA_MFC_DEVICE_PROD_ID12(0,"Elan","Serial+Parallel Port: SP230",0x3beb8cf2,0xdb9e58bc),
 863         PCMCIA_MFC_DEVICE_PROD_ID12(1,"Elan","Serial Port: CF332",0x3beb8cf2,0x16dc1ba7),
 864         PCMCIA_MFC_DEVICE_PROD_ID12(1,"Elan","Serial Port: SL332",0x3beb8cf2,0x19816c41),
 865         PCMCIA_MFC_DEVICE_PROD_ID12(1,"Elan","Serial Port: SL385",0x3beb8cf2,0x64112029),
 866         PCMCIA_MFC_DEVICE_PROD_ID12(1,"Elan","Serial Port: SL432",0x3beb8cf2,0x1cce7ac4),
 867         PCMCIA_MFC_DEVICE_PROD_ID12(2,"Elan","Serial Port: SL432",0x3beb8cf2,0x1cce7ac4),
 868         PCMCIA_MFC_DEVICE_PROD_ID12(3,"Elan","Serial Port: SL432",0x3beb8cf2,0x1cce7ac4),
 869         PCMCIA_DEVICE_MANF_CARD(0x0279, 0x950b),
 870         /* too generic */
 871         /* PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x0160, 0x0002), */
 872         /* PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x0160, 0x0002), */
 873         PCMCIA_DEVICE_FUNC_ID(2),
 874         PCMCIA_DEVICE_NULL,
 875 };
 876 MODULE_DEVICE_TABLE(pcmcia, serial_ids);
 877
 878 MODULE_FIRMWARE("cis/PCMLM28.cis");
 879 MODULE_FIRMWARE("cis/DP83903.cis");
 880 MODULE_FIRMWARE("cis/3CCFEM556.cis");
 881 MODULE_FIRMWARE("cis/3CXEM556.cis");
 882 MODULE_FIRMWARE("cis/SW_8xx_SER.cis");
 883 MODULE_FIRMWARE("cis/SW_7xx_SER.cis");
 884 MODULE_FIRMWARE("cis/SW_555_SER.cis");
 885 MODULE_FIRMWARE("cis/MT5634ZLX.cis");
 886 MODULE_FIRMWARE("cis/COMpad2.cis");
 887 MODULE_FIRMWARE("cis/COMpad4.cis");
 888 MODULE_FIRMWARE("cis/RS-COM-2P.cis");
 889
 890 static struct pcmcia_driver serial_cs_driver = {
 891         .owner          = THIS_MODULE,
 892         .drv            = {
 893                 .name   = "serial_cs",
 894         },
 895         .probe          = serial_probe,
 896         .remove         = serial_detach,
 897         .id_table       = serial_ids,
 898         .suspend        = serial_suspend,
 899         .resume         = serial_resume,
 900 };
 901
 902 static int __init init_serial_cs(void)
 903 {
 904         return pcmcia_register_driver(&serial_cs_driver);
 905 }
 906
 907 static void __exit exit_serial_cs(void)
 908 {
 909         pcmcia_unregister_driver(&serial_cs_driver);
 910 }
 911
 912 module_init(init_serial_cs);
 913 module_exit(exit_serial_cs);
 914
 915 MODULE_LICENSE("GPL");