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