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_QUAD_RS232,
 252                 .multi  = 4,
 253         }, {
 254                 .manfid = MANFID_SOCKET,
 255                 .prodid = PRODID_SOCKET_DUAL_RS232,
 256                 .multi  = 2,
 257                 .config = quirk_config_socket,
 258         }, {
 259                 .manfid = MANFID_SOCKET,
 260                 .prodid = ~0,
 261                 .multi  = -1,
 262                 .config = quirk_config_socket,
 263         }
 264 };
 265
 266
 267 static int serial_config(struct pcmcia_device * link);
 268
 269
 270 /*======================================================================
 271
 272     After a card is removed, serial_remove() will unregister
 273     the serial device(s), and release the PCMCIA configuration.
 274
 275 ======================================================================*/
 276
 277 static void serial_remove(struct pcmcia_device *link)
 278 {
 279         struct serial_info *info = link->priv;
 280         int i;
 281
 282         DEBUG(0, "serial_release(0x%p)\n", link);
 283
 284         /*
 285          * Recheck to see if the device is still configured.
 286          */
 287         for (i = 0; i < info->ndev; i++)
 288                 serial8250_unregister_port(info->line[i]);
 289
 290         info->p_dev->dev_node = NULL;
 291
 292         if (!info->slave)
 293                 pcmcia_disable_device(link);
 294 }
 295
 296 static int serial_suspend(struct pcmcia_device *link)
 297 {
 298         struct serial_info *info = link->priv;
 299         int i;
 300
 301         for (i = 0; i < info->ndev; i++)
 302                 serial8250_suspend_port(info->line[i]);
 303
 304         return 0;
 305 }
 306
 307 static int serial_resume(struct pcmcia_device *link)
 308 {
 309         struct serial_info *info = link->priv;
 310         int i;
 311
 312         for (i = 0; i < info->ndev; i++)
 313                 serial8250_resume_port(info->line[i]);
 314
 315         if (info->quirk && info->quirk->wakeup)
 316                 info->quirk->wakeup(link);
 317
 318         return 0;
 319 }
 320
 321 /*======================================================================
 322
 323     serial_attach() creates an "instance" of the driver, allocating
 324     local data structures for one device.  The device is registered
 325     with Card Services.
 326
 327 ======================================================================*/
 328
 329 static int serial_probe(struct pcmcia_device *link)
 330 {
 331         struct serial_info *info;
 332
 333         DEBUG(0, "serial_attach()\n");
 334
 335         /* Create new serial device */
 336         info = kzalloc(sizeof (*info), GFP_KERNEL);
 337         if (!info)
 338                 return -ENOMEM;
 339         info->p_dev = link;
 340         link->priv = info;
 341
 342         link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
 343         link->io.NumPorts1 = 8;
 344         link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
 345         link->irq.IRQInfo1 = IRQ_LEVEL_ID;
 346         link->conf.Attributes = CONF_ENABLE_IRQ;
 347         if (do_sound) {
 348                 link->conf.Attributes |= CONF_ENABLE_SPKR;
 349                 link->conf.Status = CCSR_AUDIO_ENA;
 350         }
 351         link->conf.IntType = INT_MEMORY_AND_IO;
 352
 353         return serial_config(link);
 354 }
 355
 356 /*======================================================================
 357
 358     This deletes a driver "instance".  The device is de-registered
 359     with Card Services.  If it has been released, all local data
 360     structures are freed.  Otherwise, the structures will be freed
 361     when the device is released.
 362
 363 ======================================================================*/
 364
 365 static void serial_detach(struct pcmcia_device *link)
 366 {
 367         struct serial_info *info = link->priv;
 368
 369         DEBUG(0, "serial_detach(0x%p)\n", link);
 370
 371         /*
 372          * Ensure any outstanding scheduled tasks are completed.
 373          */
 374         flush_scheduled_work();
 375
 376         /*
 377          * Ensure that the ports have been released.
 378          */
 379         serial_remove(link);
 380
 381         /* free bits */
 382         kfree(info);
 383 }
 384
 385 /*====================================================================*/
 386
 387 static int setup_serial(struct pcmcia_device *handle, struct serial_info * info,
 388                         kio_addr_t iobase, int irq)
 389 {
 390         struct uart_port port;
 391         int line;
 392
 393         memset(&port, 0, sizeof (struct uart_port));
 394         port.iobase = iobase;
 395         port.irq = irq;
 396         port.flags = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST | UPF_SHARE_IRQ;
 397         port.uartclk = 1843200;
 398         port.dev = &handle_to_dev(handle);
 399         if (buggy_uart)
 400                 port.flags |= UPF_BUGGY_UART;
 401
 402         if (info->quirk && info->quirk->setup)
 403                 info->quirk->setup(handle, &port);
 404
 405         line = serial8250_register_port(&port);
 406         if (line < 0) {
 407                 printk(KERN_NOTICE "serial_cs: serial8250_register_port() at "
 408                        "0x%04lx, irq %d failed\n", (u_long)iobase, irq);
 409                 return -EINVAL;
 410         }
 411
 412         info->line[info->ndev] = line;
 413         sprintf(info->node[info->ndev].dev_name, "ttyS%d", line);
 414         info->node[info->ndev].major = TTY_MAJOR;
 415         info->node[info->ndev].minor = 0x40 + line;
 416         if (info->ndev > 0)
 417                 info->node[info->ndev - 1].next = &info->node[info->ndev];
 418         info->ndev++;
 419
 420         return 0;
 421 }
 422
 423 /*====================================================================*/
 424
 425 static int
 426 first_tuple(struct pcmcia_device *handle, tuple_t * tuple, cisparse_t * parse)
 427 {
 428         int i;
 429         i = pcmcia_get_first_tuple(handle, tuple);
 430         if (i != CS_SUCCESS)
 431                 return CS_NO_MORE_ITEMS;
 432         i = pcmcia_get_tuple_data(handle, tuple);
 433         if (i != CS_SUCCESS)
 434                 return i;
 435         return pcmcia_parse_tuple(handle, tuple, parse);
 436 }
 437
 438 static int
 439 next_tuple(struct pcmcia_device *handle, tuple_t * tuple, cisparse_t * parse)
 440 {
 441         int i;
 442         i = pcmcia_get_next_tuple(handle, tuple);
 443         if (i != CS_SUCCESS)
 444                 return CS_NO_MORE_ITEMS;
 445         i = pcmcia_get_tuple_data(handle, tuple);
 446         if (i != CS_SUCCESS)
 447                 return i;
 448         return pcmcia_parse_tuple(handle, tuple, parse);
 449 }
 450
 451 /*====================================================================*/
 452
 453 static int simple_config(struct pcmcia_device *link)
 454 {
 455         static const kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
 456         static const int size_table[2] = { 8, 16 };
 457         struct serial_info *info = link->priv;
 458         struct serial_cfg_mem *cfg_mem;
 459         tuple_t *tuple;
 460         u_char *buf;
 461         cisparse_t *parse;
 462         cistpl_cftable_entry_t *cf;
 463         config_info_t config;
 464         int i, j, try;
 465         int s;
 466
 467         cfg_mem = kmalloc(sizeof(struct serial_cfg_mem), GFP_KERNEL);
 468         if (!cfg_mem)
 469                 return -1;
 470
 471         tuple = &cfg_mem->tuple;
 472         parse = &cfg_mem->parse;
 473         cf = &parse->cftable_entry;
 474         buf = cfg_mem->buf;
 475
 476         /* If the card is already configured, look up the port and irq */
 477         i = pcmcia_get_configuration_info(link, &config);
 478         if ((i == CS_SUCCESS) && (config.Attributes & CONF_VALID_CLIENT)) {
 479                 kio_addr_t port = 0;
 480                 if ((config.BasePort2 != 0) && (config.NumPorts2 == 8)) {
 481                         port = config.BasePort2;
 482                         info->slave = 1;
 483                 } else if ((info->manfid == MANFID_OSITECH) &&
 484                            (config.NumPorts1 == 0x40)) {
 485                         port = config.BasePort1 + 0x28;
 486                         info->slave = 1;
 487                 }
 488                 if (info->slave) {
 489                         kfree(cfg_mem);
 490                         return setup_serial(link, info, port, config.AssignedIRQ);
 491                 }
 492         }
 493
 494         /* First pass: look for a config entry that looks normal. */
 495         tuple->TupleData = (cisdata_t *) buf;
 496         tuple->TupleOffset = 0;
 497         tuple->TupleDataMax = 255;
 498         tuple->Attributes = 0;
 499         tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
 500         /* Two tries: without IO aliases, then with aliases */
 501         for (s = 0; s < 2; s++) {
 502                 for (try = 0; try < 2; try++) {
 503                         i = first_tuple(link, tuple, parse);
 504                         while (i != CS_NO_MORE_ITEMS) {
 505                                 if (i != CS_SUCCESS)
 506                                         goto next_entry;
 507                                 if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
 508                                         link->conf.Vpp =
 509                                             cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
 510                                 if ((cf->io.nwin > 0) && (cf->io.win[0].len == size_table[s]) &&
 511                                             (cf->io.win[0].base != 0)) {
 512                                         link->conf.ConfigIndex = cf->index;
 513                                         link->io.BasePort1 = cf->io.win[0].base;
 514                                         link->io.IOAddrLines = (try == 0) ?
 515                                             16 : cf->io.flags & CISTPL_IO_LINES_MASK;
 516                                         i = pcmcia_request_io(link, &link->io);
 517                                         if (i == CS_SUCCESS)
 518                                                 goto found_port;
 519                                 }
 520 next_entry:
 521                                 i = next_tuple(link, tuple, parse);
 522                         }
 523                 }
 524         }
 525         /* Second pass: try to find an entry that isn't picky about
 526            its base address, then try to grab any standard serial port
 527            address, and finally try to get any free port. */
 528         i = first_tuple(link, tuple, parse);
 529         while (i != CS_NO_MORE_ITEMS) {
 530                 if ((i == CS_SUCCESS) && (cf->io.nwin > 0) &&
 531                     ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
 532                         link->conf.ConfigIndex = cf->index;
 533                         for (j = 0; j < 5; j++) {
 534                                 link->io.BasePort1 = base[j];
 535                                 link->io.IOAddrLines = base[j] ? 16 : 3;
 536                                 i = pcmcia_request_io(link, &link->io);
 537                                 if (i == CS_SUCCESS)
 538                                         goto found_port;
 539                         }
 540                 }
 541                 i = next_tuple(link, tuple, parse);
 542         }
 543
 544       found_port:
 545         if (i != CS_SUCCESS) {
 546                 printk(KERN_NOTICE
 547                        "serial_cs: no usable port range found, giving up\n");
 548                 cs_error(link, RequestIO, i);
 549                 kfree(cfg_mem);
 550                 return -1;
 551         }
 552
 553         i = pcmcia_request_irq(link, &link->irq);
 554         if (i != CS_SUCCESS) {
 555                 cs_error(link, RequestIRQ, i);
 556                 link->irq.AssignedIRQ = 0;
 557         }
 558         if (info->multi && (info->manfid == MANFID_3COM))
 559                 link->conf.ConfigIndex &= ~(0x08);
 560
 561         /*
 562          * Apply any configuration quirks.
 563          */
 564         if (info->quirk && info->quirk->config)
 565                 info->quirk->config(link);
 566
 567         i = pcmcia_request_configuration(link, &link->conf);
 568         if (i != CS_SUCCESS) {
 569                 cs_error(link, RequestConfiguration, i);
 570                 kfree(cfg_mem);
 571                 return -1;
 572         }
 573         kfree(cfg_mem);
 574         return setup_serial(link, info, link->io.BasePort1, link->irq.AssignedIRQ);
 575 }
 576
 577 static int multi_config(struct pcmcia_device * link)
 578 {
 579         struct serial_info *info = link->priv;
 580         struct serial_cfg_mem *cfg_mem;
 581         tuple_t *tuple;
 582         u_char *buf;
 583         cisparse_t *parse;
 584         cistpl_cftable_entry_t *cf;
 585         int i, rc, base2 = 0;
 586
 587         cfg_mem = kmalloc(sizeof(struct serial_cfg_mem), GFP_KERNEL);
 588         if (!cfg_mem)
 589                 return -1;
 590         tuple = &cfg_mem->tuple;
 591         parse = &cfg_mem->parse;
 592         cf = &parse->cftable_entry;
 593         buf = cfg_mem->buf;
 594
 595         tuple->TupleData = (cisdata_t *) buf;
 596         tuple->TupleOffset = 0;
 597         tuple->TupleDataMax = 255;
 598         tuple->Attributes = 0;
 599         tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
 600
 601         /* First, look for a generic full-sized window */
 602         link->io.NumPorts1 = info->multi * 8;
 603         i = first_tuple(link, tuple, parse);
 604         while (i != CS_NO_MORE_ITEMS) {
 605                 /* The quad port cards have bad CIS's, so just look for a
 606                    window larger than 8 ports and assume it will be right */
 607                 if ((i == CS_SUCCESS) && (cf->io.nwin == 1) &&
 608                     (cf->io.win[0].len > 8)) {
 609                         link->conf.ConfigIndex = cf->index;
 610                         link->io.BasePort1 = cf->io.win[0].base;
 611                         link->io.IOAddrLines =
 612                             cf->io.flags & CISTPL_IO_LINES_MASK;
 613                         i = pcmcia_request_io(link, &link->io);
 614                         base2 = link->io.BasePort1 + 8;
 615                         if (i == CS_SUCCESS)
 616                                 break;
 617                 }
 618                 i = next_tuple(link, tuple, parse);
 619         }
 620
 621         /* If that didn't work, look for two windows */
 622         if (i != CS_SUCCESS) {
 623                 link->io.NumPorts1 = link->io.NumPorts2 = 8;
 624                 info->multi = 2;
 625                 i = first_tuple(link, tuple, parse);
 626                 while (i != CS_NO_MORE_ITEMS) {
 627                         if ((i == CS_SUCCESS) && (cf->io.nwin == 2)) {
 628                                 link->conf.ConfigIndex = cf->index;
 629                                 link->io.BasePort1 = cf->io.win[0].base;
 630                                 link->io.BasePort2 = cf->io.win[1].base;
 631                                 link->io.IOAddrLines =
 632                                     cf->io.flags & CISTPL_IO_LINES_MASK;
 633                                 i = pcmcia_request_io(link, &link->io);
 634                                 base2 = link->io.BasePort2;
 635                                 if (i == CS_SUCCESS)
 636                                         break;
 637                         }
 638                         i = next_tuple(link, tuple, parse);
 639                 }
 640         }
 641
 642         if (i != CS_SUCCESS) {
 643                 cs_error(link, RequestIO, i);
 644                 rc = -1;
 645                 goto free_cfg_mem;
 646         }
 647
 648         i = pcmcia_request_irq(link, &link->irq);
 649         if (i != CS_SUCCESS) {
 650                 printk(KERN_NOTICE
 651                        "serial_cs: no usable port range found, giving up\n");
 652                 cs_error(link, RequestIRQ, i);
 653                 link->irq.AssignedIRQ = 0;
 654         }
 655
 656         /*
 657          * Apply any configuration quirks.
 658          */
 659         if (info->quirk && info->quirk->config)
 660                 info->quirk->config(link);
 661
 662         i = pcmcia_request_configuration(link, &link->conf);
 663         if (i != CS_SUCCESS) {
 664                 cs_error(link, RequestConfiguration, i);
 665                 rc = -1;
 666                 goto free_cfg_mem;
 667         }
 668
 669         /* The Oxford Semiconductor OXCF950 cards are in fact single-port:
 670          * 8 registers are for the UART, the others are extra registers.
 671          * Siemen's MC45 PCMCIA (Possio's GCC) is OXCF950 based too.
 672          */
 673         if (info->manfid == MANFID_OXSEMI || (info->manfid == MANFID_POSSIO &&
 674                                 info->prodid == PRODID_POSSIO_GCC)) {
 675                 int err;
 676
 677                 if (cf->index == 1 || cf->index == 3) {
 678                         err = setup_serial(link, info, base2,
 679                                         link->irq.AssignedIRQ);
 680                         base2 = link->io.BasePort1;
 681                 } else {
 682                         err = setup_serial(link, info, link->io.BasePort1,
 683                                         link->irq.AssignedIRQ);
 684                 }
 685                 info->c950ctrl = base2;
 686
 687                 /*
 688                  * FIXME: We really should wake up the port prior to
 689                  * handing it over to the serial layer.
 690                  */
 691                 if (info->quirk && info->quirk->wakeup)
 692                         info->quirk->wakeup(link);
 693
 694                 rc = 0;
 695                 goto free_cfg_mem;
 696         }
 697
 698         setup_serial(link, info, link->io.BasePort1, link->irq.AssignedIRQ);
 699         for (i = 0; i < info->multi - 1; i++)
 700                 setup_serial(link, info, base2 + (8 * i),
 701                                 link->irq.AssignedIRQ);
 702         rc = 0;
 703 free_cfg_mem:
 704         kfree(cfg_mem);
 705         return rc;
 706 }
 707
 708 /*======================================================================
 709
 710     serial_config() is scheduled to run after a CARD_INSERTION event
 711     is received, to configure the PCMCIA socket, and to make the
 712     serial device available to the system.
 713
 714 ======================================================================*/
 715
 716 static int serial_config(struct pcmcia_device * link)
 717 {
 718         struct serial_info *info = link->priv;
 719         struct serial_cfg_mem *cfg_mem;
 720         tuple_t *tuple;
 721         u_char *buf;
 722         cisparse_t *parse;
 723         cistpl_cftable_entry_t *cf;
 724         int i;
 725
 726         DEBUG(0, "serial_config(0x%p)\n", link);
 727
 728         cfg_mem = kmalloc(sizeof(struct serial_cfg_mem), GFP_KERNEL);
 729         if (!cfg_mem)
 730                 goto failed;
 731
 732         tuple = &cfg_mem->tuple;
 733         parse = &cfg_mem->parse;
 734         cf = &parse->cftable_entry;
 735         buf = cfg_mem->buf;
 736
 737         tuple->TupleData = (cisdata_t *) buf;
 738         tuple->TupleOffset = 0;
 739         tuple->TupleDataMax = 255;
 740         tuple->Attributes = 0;
 741
 742         /* Is this a compliant multifunction card? */
 743         tuple->DesiredTuple = CISTPL_LONGLINK_MFC;
 744         tuple->Attributes = TUPLE_RETURN_COMMON | TUPLE_RETURN_LINK;
 745         info->multi = (first_tuple(link, tuple, parse) == CS_SUCCESS);
 746
 747         /* Is this a multiport card? */
 748         tuple->DesiredTuple = CISTPL_MANFID;
 749         info->manfid = link->manf_id;
 750         info->prodid = link->card_id;
 751
 752         for (i = 0; i < ARRAY_SIZE(quirks); i++)
 753                 if ((quirks[i].manfid == ~0 ||
 754                      quirks[i].manfid == info->manfid) &&
 755                     (quirks[i].prodid == ~0 ||
 756                      quirks[i].prodid == info->prodid)) {
 757                         info->quirk = &quirks[i];
 758                         break;
 759                 }
 760
 761         /* Another check for dual-serial cards: look for either serial or
 762            multifunction cards that ask for appropriate IO port ranges */
 763         tuple->DesiredTuple = CISTPL_FUNCID;
 764         if ((info->multi == 0) &&
 765             (link->has_func_id) &&
 766             ((link->func_id == CISTPL_FUNCID_MULTI) ||
 767              (link->func_id == CISTPL_FUNCID_SERIAL))) {
 768                 tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
 769                 if (first_tuple(link, tuple, parse) == CS_SUCCESS) {
 770                         if ((cf->io.nwin == 1) && (cf->io.win[0].len % 8 == 0))
 771                                 info->multi = cf->io.win[0].len >> 3;
 772                         if ((cf->io.nwin == 2) && (cf->io.win[0].len == 8) &&
 773                             (cf->io.win[1].len == 8))
 774                                 info->multi = 2;
 775                 }
 776         }
 777
 778         /*
 779          * Apply any multi-port quirk.
 780          */
 781         if (info->quirk && info->quirk->multi != -1)
 782                 info->multi = info->quirk->multi;
 783
 784         if (info->multi > 1)
 785                 multi_config(link);
 786         else
 787                 simple_config(link);
 788
 789         if (info->ndev == 0)
 790                 goto failed;
 791
 792         /*
 793          * Apply any post-init quirk.  FIXME: This should really happen
 794          * before we register the port, since it might already be in use.
 795          */
 796         if (info->quirk && info->quirk->post)
 797                 if (info->quirk->post(link))
 798                         goto failed;
 799
 800         link->dev_node = &info->node[0];
 801         kfree(cfg_mem);
 802         return 0;
 803
 804  failed:
 805         serial_remove(link);
 806         kfree(cfg_mem);
 807         return -ENODEV;
 808 }
 809
 810 static struct pcmcia_device_id serial_ids[] = {
 811         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0057, 0x0021),
 812         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0089, 0x110a),
 813         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0104, 0x000a),
 814         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0105, 0xea15),
 815         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0109, 0x0501),
 816         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0138, 0x110a),
 817         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0140, 0x000a),
 818         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0143, 0x3341),
 819         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0143, 0xc0ab),
 820         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x016c, 0x0081),
 821         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x021b, 0x0101),
 822         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x08a1, 0xc0ab),
 823         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0105, 0x0d0a),
 824         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0105, 0x0e0a),
 825         PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "CC/XJEM3288", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x04cd2988, 0x46a52d63),
 826         PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "CC/XJEM3336", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x0143b773, 0x46a52d63),
 827         PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "EM1144T", "PCMCIA MODEM", 0xf510db04, 0x856d66c8, 0xbd6c43ef),
 828         PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "XJEM1144/CCEM1144", "PCMCIA MODEM", 0xf510db04, 0x52d21e1e, 0xbd6c43ef),
 829         PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "CEM28", 0x2e3ee845, 0x0ea978ea),
 830         PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "CEM33", 0x2e3ee845, 0x80609023),
 831         PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "CEM56", 0x2e3ee845, 0xa650c32a),
 832         PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "REM10", 0x2e3ee845, 0x76df1d29),
 833         PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "XEM5600", 0x2e3ee845, 0xf1403719),
 834         PCMCIA_PFC_DEVICE_PROD_ID12(1, "AnyCom", "Fast Ethernet + 56K COMBO", 0x578ba6e7, 0xb0ac62c4),
 835         PCMCIA_PFC_DEVICE_PROD_ID12(1, "D-Link", "DME336T", 0x1a424a1c, 0xb23897ff),
 836         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Gateway 2000", "XJEM3336", 0xdd9989be, 0x662c394c),
 837         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Grey Cell", "GCS3000", 0x2a151fac, 0x48b932ae),
 838         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Linksys", "EtherFast 10&100 + 56K PC Card (PCMLM56)", 0x0733cc81, 0xb3765033),
 839         PCMCIA_PFC_DEVICE_PROD_ID12(1, "LINKSYS", "PCMLM336", 0xf7cb0b07, 0x7a821b58),
 840         PCMCIA_PFC_DEVICE_PROD_ID12(1, "MEGAHERTZ", "XJEM1144/CCEM1144", 0xf510db04, 0x52d21e1e),
 841         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Ositech", "Trumpcard:Jack of Diamonds Modem+Ethernet", 0xc2f80cd, 0x656947b9),
 842         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Ositech", "Trumpcard:Jack of Hearts Modem+Ethernet", 0xc2f80cd, 0xdc9ba5ed),
 843         PCMCIA_PFC_DEVICE_PROD_ID12(1, "PCMCIAs", "ComboCard", 0xdcfe12d3, 0xcd8906cc),
 844         PCMCIA_PFC_DEVICE_PROD_ID12(1, "PCMCIAs", "LanModem", 0xdcfe12d3, 0xc67c648f),
 845         PCMCIA_PFC_DEVICE_PROD_ID12(1, "TDK", "GlobalNetworker 3410/3412", 0x1eae9475, 0xd9a93bed),
 846         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Xircom", "CreditCard Ethernet+Modem II", 0x2e3ee845, 0xeca401bf),
 847         PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x0104, 0x0070),
 848         PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x0101, 0x0562),
 849         PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x0104, 0x0070),
 850         PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x016c, 0x0020),
 851         PCMCIA_MFC_DEVICE_PROD_ID123(1, "APEX DATA", "MULTICARD", "ETHERNET-MODEM", 0x11c2da09, 0x7289dc5d, 0xaad95e1f),
 852         PCMCIA_MFC_DEVICE_PROD_ID12(1, "IBM", "Home and Away 28.8 PC Card       ", 0xb569a6e5, 0x5bd4ff2c),
 853         PCMCIA_MFC_DEVICE_PROD_ID12(1, "IBM", "Home and Away Credit Card Adapter", 0xb569a6e5, 0x4bdf15c3),
 854         PCMCIA_MFC_DEVICE_PROD_ID12(1, "IBM", "w95 Home and Away Credit Card ", 0xb569a6e5, 0xae911c15),
 855         PCMCIA_MFC_DEVICE_PROD_ID1(1, "Motorola MARQUIS", 0xf03e4e77),
 856         PCMCIA_MFC_DEVICE_PROD_ID2(1, "FAX/Modem/Ethernet Combo Card ", 0x1ed59302),
 857         PCMCIA_DEVICE_MANF_CARD(0x0089, 0x0301),
 858         PCMCIA_DEVICE_MANF_CARD(0x00a4, 0x0276),
 859         PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0039),
 860         PCMCIA_DEVICE_MANF_CARD(0x0104, 0x0006),
 861         PCMCIA_DEVICE_MANF_CARD(0x0105, 0x410a),
 862         PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0d50),
 863         PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0d51),
 864         PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0d52),
 865         PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0d53),
 866         PCMCIA_DEVICE_MANF_CARD(0x010b, 0xd180),
 867         PCMCIA_DEVICE_MANF_CARD(0x0137, 0x000e),
 868         PCMCIA_DEVICE_MANF_CARD(0x0137, 0x001b),
 869         PCMCIA_DEVICE_MANF_CARD(0x0137, 0x0025),
 870         PCMCIA_DEVICE_MANF_CARD(0x0137, 0x0045),
 871         PCMCIA_DEVICE_MANF_CARD(0x0137, 0x0052),
 872         PCMCIA_DEVICE_PROD_ID134("ADV", "TECH", "COMpad-32/85", 0x67459937, 0x916d02ba, 0x8fbe92ae),
 873         PCMCIA_DEVICE_PROD_ID124("GATEWAY2000", "CC3144", "PCMCIA MODEM", 0x506bccae, 0xcb3685f1, 0xbd6c43ef),
 874         PCMCIA_DEVICE_PROD_ID14("MEGAHERTZ", "PCMCIA MODEM", 0xf510db04, 0xbd6c43ef),
 875         PCMCIA_DEVICE_PROD_ID124("TOSHIBA", "T144PF", "PCMCIA MODEM", 0xb4585a1a, 0x7271409c, 0xbd6c43ef),
 876         PCMCIA_DEVICE_PROD_ID123("FUJITSU", "FC14F ", "MBH10213", 0x6ee5a3d8, 0x30ead12b, 0xb00f05a0),
 877         PCMCIA_DEVICE_PROD_ID123("Novatel Wireless", "Merlin UMTS Modem", "U630", 0x32607776, 0xd9e73b13, 0xe87332e),
 878         PCMCIA_DEVICE_PROD_ID13("MEGAHERTZ", "V.34 PCMCIA MODEM", 0xf510db04, 0xbb2cce4a),
 879         PCMCIA_DEVICE_PROD_ID12("Brain Boxes", "Bluetooth PC Card", 0xee138382, 0xd4ce9b02),
 880         PCMCIA_DEVICE_PROD_ID12("CIRRUS LOGIC", "FAX MODEM", 0xe625f451, 0xcecd6dfa),
 881         PCMCIA_DEVICE_PROD_ID12("COMPAQ", "PCMCIA 28800 FAX/DATA MODEM", 0xa3a3062c, 0x8cbd7c76),
 882         PCMCIA_DEVICE_PROD_ID12("COMPAQ", "PCMCIA 33600 FAX/DATA MODEM", 0xa3a3062c, 0x5a00ce95),
 883         PCMCIA_DEVICE_PROD_ID12("Computerboards, Inc.", "PCM-COM422", 0xd0b78f51, 0x7e2d49ed),
 884         PCMCIA_DEVICE_PROD_ID12("Dr. Neuhaus", "FURY CARD 14K4", 0x76942813, 0x8b96ce65),
 885         PCMCIA_DEVICE_PROD_ID12("Intelligent", "ANGIA FAX/MODEM", 0xb496e65e, 0xf31602a6),
 886         PCMCIA_DEVICE_PROD_ID12("Intel", "MODEM 2400+", 0x816cc815, 0x412729fb),
 887         PCMCIA_DEVICE_PROD_ID12("IOTech Inc ", "PCMCIA Dual RS-232 Serial Port Card", 0x3bd2d898, 0x92abc92f),
 888         PCMCIA_DEVICE_PROD_ID12("MACRONIX", "FAX/MODEM", 0x668388b3, 0x3f9bdf2f),
 889         PCMCIA_DEVICE_PROD_ID12("Multi-Tech", "MT1432LT", 0x5f73be51, 0x0b3e2383),
 890         PCMCIA_DEVICE_PROD_ID12("Multi-Tech", "MT2834LT", 0x5f73be51, 0x4cd7c09e),
 891         PCMCIA_DEVICE_PROD_ID12("OEM      ", "C288MX     ", 0xb572d360, 0xd2385b7a),
 892         PCMCIA_DEVICE_PROD_ID12("PCMCIA   ", "C336MX     ", 0x99bcafe9, 0xaa25bcab),
 893         PCMCIA_DEVICE_PROD_ID12("Quatech Inc", "PCMCIA Dual RS-232 Serial Port Card", 0xc4420b35, 0x92abc92f),
 894         PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "PCMCIA", "EN2218-LAN/MODEM", 0x281f1c5d, 0x570f348e, "PCMLM28.cis"),
 895         PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "PCMCIA", "UE2218-LAN/MODEM", 0x281f1c5d, 0x6fdcacee, "PCMLM28.cis"),
 896         PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "Psion Dacom", "Gold Card V34 Ethernet", 0xf5f025c2, 0x338e8155, "PCMLM28.cis"),
 897         PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "Psion Dacom", "Gold Card V34 Ethernet GSM", 0xf5f025c2, 0x4ae85d35, "PCMLM28.cis"),
 898         PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "LINKSYS", "PCMLM28", 0xf7cb0b07, 0x66881874, "PCMLM28.cis"),
 899         PCMCIA_MFC_DEVICE_CIS_PROD_ID12(1, "DAYNA COMMUNICATIONS", "LAN AND MODEM MULTIFUNCTION", 0x8fdf8f89, 0xdd5ed9e8, "DP83903.cis"),
 900         PCMCIA_MFC_DEVICE_CIS_PROD_ID4(1, "NSC MF LAN/Modem", 0x58fc6056, "DP83903.cis"),
 901         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x0556, "3CCFEM556.cis"),
 902         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0175, 0x0000, "DP83903.cis"),
 903         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x0035, "3CXEM556.cis"),
 904         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x003d, "3CXEM556.cis"),
 905         PCMCIA_DEVICE_CIS_MANF_CARD(0x0192, 0x0710, "SW_7xx_SER.cis"),  /* Sierra Wireless AC710/AC750 GPRS Network Adapter R1 */
 906         PCMCIA_DEVICE_CIS_MANF_CARD(0x0192, 0xa555, "SW_555_SER.cis"),  /* Sierra Aircard 555 CDMA 1xrtt Modem -- pre update */
 907         PCMCIA_DEVICE_CIS_MANF_CARD(0x013f, 0xa555, "SW_555_SER.cis"),  /* Sierra Aircard 555 CDMA 1xrtt Modem -- post update */
 908         PCMCIA_DEVICE_CIS_PROD_ID12("MultiTech", "PCMCIA 56K DataFax", 0x842047ee, 0xc2efcf03, "MT5634ZLX.cis"),
 909         PCMCIA_DEVICE_CIS_PROD_ID12("ADVANTECH", "COMpad-32/85B-4", 0x96913a85, 0xcec8f102, "COMpad4.cis"),
 910         PCMCIA_DEVICE_CIS_PROD_ID123("ADVANTECH", "COMpad-32/85", "1.0", 0x96913a85, 0x8fbe92ae, 0x0877b627, "COMpad2.cis"),
 911         PCMCIA_DEVICE_CIS_PROD_ID2("RS-COM 2P", 0xad20b156, "RS-COM-2P.cis"),
 912         PCMCIA_DEVICE_CIS_MANF_CARD(0x0013, 0x0000, "GLOBETROTTER.cis"),
 913         PCMCIA_DEVICE_PROD_ID12("ELAN DIGITAL SYSTEMS LTD, c1997.","SERIAL CARD: SL100  1.00.",0x19ca78af,0xf964f42b),
 914         PCMCIA_DEVICE_PROD_ID12("ELAN DIGITAL SYSTEMS LTD, c1997.","SERIAL CARD: SL100",0x19ca78af,0x71d98e83),
 915         PCMCIA_DEVICE_PROD_ID12("ELAN DIGITAL SYSTEMS LTD, c1997.","SERIAL CARD: SL232  1.00.",0x19ca78af,0x69fb7490),
 916         PCMCIA_DEVICE_PROD_ID12("ELAN DIGITAL SYSTEMS LTD, c1997.","SERIAL CARD: SL232",0x19ca78af,0xb6bc0235),
 917         PCMCIA_DEVICE_PROD_ID12("ELAN DIGITAL SYSTEMS LTD, c2000.","SERIAL CARD: CF232",0x63f2e0bd,0xb9e175d3),
 918         PCMCIA_DEVICE_PROD_ID12("ELAN DIGITAL SYSTEMS LTD, c2000.","SERIAL CARD: CF232-5",0x63f2e0bd,0xfce33442),
 919         PCMCIA_DEVICE_PROD_ID12("Elan","Serial Port: CF232",0x3beb8cf2,0x171e7190),
 920         PCMCIA_DEVICE_PROD_ID12("Elan","Serial Port: CF232-5",0x3beb8cf2,0x20da4262),
 921         PCMCIA_DEVICE_PROD_ID12("Elan","Serial Port: CF428",0x3beb8cf2,0xea5dd57d),
 922         PCMCIA_DEVICE_PROD_ID12("Elan","Serial Port: CF500",0x3beb8cf2,0xd77255fa),
 923         PCMCIA_DEVICE_PROD_ID12("Elan","Serial Port: IC232",0x3beb8cf2,0x6a709903),
 924         PCMCIA_DEVICE_PROD_ID12("Elan","Serial Port: SL232",0x3beb8cf2,0x18430676),
 925         PCMCIA_DEVICE_PROD_ID12("Elan","Serial Port: XL232",0x3beb8cf2,0x6f933767),
 926         PCMCIA_MFC_DEVICE_PROD_ID12(0,"Elan","Serial Port: CF332",0x3beb8cf2,0x16dc1ba7),
 927         PCMCIA_MFC_DEVICE_PROD_ID12(0,"Elan","Serial Port: SL332",0x3beb8cf2,0x19816c41),
 928         PCMCIA_MFC_DEVICE_PROD_ID12(0,"Elan","Serial Port: SL385",0x3beb8cf2,0x64112029),
 929         PCMCIA_MFC_DEVICE_PROD_ID12(0,"Elan","Serial Port: SL432",0x3beb8cf2,0x1cce7ac4),
 930         PCMCIA_MFC_DEVICE_PROD_ID12(0,"Elan","Serial+Parallel Port: SP230",0x3beb8cf2,0xdb9e58bc),
 931         PCMCIA_MFC_DEVICE_PROD_ID12(1,"Elan","Serial Port: CF332",0x3beb8cf2,0x16dc1ba7),
 932         PCMCIA_MFC_DEVICE_PROD_ID12(1,"Elan","Serial Port: SL332",0x3beb8cf2,0x19816c41),
 933         PCMCIA_MFC_DEVICE_PROD_ID12(1,"Elan","Serial Port: SL385",0x3beb8cf2,0x64112029),
 934         PCMCIA_MFC_DEVICE_PROD_ID12(1,"Elan","Serial Port: SL432",0x3beb8cf2,0x1cce7ac4),
 935         PCMCIA_MFC_DEVICE_PROD_ID12(2,"Elan","Serial Port: SL432",0x3beb8cf2,0x1cce7ac4),
 936         PCMCIA_MFC_DEVICE_PROD_ID12(3,"Elan","Serial Port: SL432",0x3beb8cf2,0x1cce7ac4),
 937         /* too generic */
 938         /* PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x0160, 0x0002), */
 939         /* PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x0160, 0x0002), */
 940         PCMCIA_DEVICE_FUNC_ID(2),
 941         PCMCIA_DEVICE_NULL,
 942 };
 943 MODULE_DEVICE_TABLE(pcmcia, serial_ids);
 944
 945 static struct pcmcia_driver serial_cs_driver = {
 946         .owner          = THIS_MODULE,
 947         .drv            = {
 948                 .name   = "serial_cs",
 949         },
 950         .probe          = serial_probe,
 951         .remove         = serial_detach,
 952         .id_table       = serial_ids,
 953         .suspend        = serial_suspend,
 954         .resume         = serial_resume,
 955 };
 956
 957 static int __init init_serial_cs(void)
 958 {
 959         return pcmcia_register_driver(&serial_cs_driver);
 960 }
 961
 962 static void __exit exit_serial_cs(void)
 963 {
 964         pcmcia_unregister_driver(&serial_cs_driver);
 965 }
 966
 967 module_init(init_serial_cs);
 968 module_exit(exit_serial_cs);
 969
 970 MODULE_LICENSE("GPL");