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