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