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/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 multi_id {
  83         u_short manfid;
  84         u_short prodid;
  85         int multi;              /* 1 = multifunction, > 1 = # ports */
  86 };
  87
  88 static const struct multi_id multi_id[] = {
  89         { MANFID_OMEGA,   PRODID_OMEGA_QSP_100,         4 },
  90         { MANFID_QUATECH, PRODID_QUATECH_DUAL_RS232,    2 },
  91         { MANFID_QUATECH, PRODID_QUATECH_DUAL_RS232_D1, 2 },
  92         { MANFID_QUATECH, PRODID_QUATECH_QUAD_RS232,    4 },
  93         { MANFID_SOCKET,  PRODID_SOCKET_DUAL_RS232,     2 },
  94         { MANFID_INTEL,   PRODID_INTEL_DUAL_RS232,      2 },
  95         { MANFID_NATINST, PRODID_NATINST_QUAD_RS232,    4 }
  96 };
  97 #define MULTI_COUNT (sizeof(multi_id)/sizeof(struct multi_id))
  98
  99 struct serial_info {
 100         dev_link_t              link;
 101         int                     ndev;
 102         int                     multi;
 103         int                     slave;
 104         int                     manfid;
 105         dev_node_t              node[4];
 106         int                     line[4];
 107 };
 108
 109 struct serial_cfg_mem {
 110         tuple_t tuple;
 111         cisparse_t parse;
 112         u_char buf[256];
 113 };
 114
 115
 116 static void serial_config(dev_link_t * link);
 117 static int serial_event(event_t event, int priority,
 118                         event_callback_args_t * args);
 119
 120 static dev_info_t dev_info = "serial_cs";
 121
 122 static dev_link_t *serial_attach(void);
 123 static void serial_detach(struct pcmcia_device *p_dev);
 124
 125 /*======================================================================
 126
 127     After a card is removed, serial_remove() will unregister
 128     the serial device(s), and release the PCMCIA configuration.
 129
 130 ======================================================================*/
 131
 132 static void serial_remove(dev_link_t *link)
 133 {
 134         struct serial_info *info = link->priv;
 135         int i;
 136
 137         link->state &= ~DEV_PRESENT;
 138
 139         DEBUG(0, "serial_release(0x%p)\n", link);
 140
 141         /*
 142          * Recheck to see if the device is still configured.
 143          */
 144         if (info->link.state & DEV_CONFIG) {
 145                 for (i = 0; i < info->ndev; i++)
 146                         serial8250_unregister_port(info->line[i]);
 147
 148                 info->link.dev = NULL;
 149
 150                 if (!info->slave) {
 151                         pcmcia_release_configuration(info->link.handle);
 152                         pcmcia_release_io(info->link.handle, &info->link.io);
 153                         pcmcia_release_irq(info->link.handle, &info->link.irq);
 154                 }
 155
 156                 info->link.state &= ~DEV_CONFIG;
 157         }
 158 }
 159
 160 static int serial_suspend(struct pcmcia_device *dev)
 161 {
 162         dev_link_t *link = dev_to_instance(dev);
 163         link->state |= DEV_SUSPEND;
 164
 165         if (link->state & DEV_CONFIG) {
 166                 struct serial_info *info = link->priv;
 167                 int i;
 168
 169                 for (i = 0; i < info->ndev; i++)
 170                         serial8250_suspend_port(info->line[i]);
 171
 172                 if (!info->slave)
 173                         pcmcia_release_configuration(link->handle);
 174         }
 175
 176         return 0;
 177 }
 178
 179 static int serial_resume(struct pcmcia_device *dev)
 180 {
 181         dev_link_t *link = dev_to_instance(dev);
 182         link->state &= ~DEV_SUSPEND;
 183
 184         if (DEV_OK(link)) {
 185                 struct serial_info *info = link->priv;
 186                 int i;
 187
 188                 if (!info->slave)
 189                         pcmcia_request_configuration(link->handle, &link->conf);
 190
 191                 for (i = 0; i < info->ndev; i++)
 192                         serial8250_resume_port(info->line[i]);
 193         }
 194
 195         return 0;
 196 }
 197
 198 /*======================================================================
 199
 200     serial_attach() creates an "instance" of the driver, allocating
 201     local data structures for one device.  The device is registered
 202     with Card Services.
 203
 204 ======================================================================*/
 205
 206 static dev_link_t *serial_attach(void)
 207 {
 208         struct serial_info *info;
 209         client_reg_t client_reg;
 210         dev_link_t *link;
 211         int ret;
 212
 213         DEBUG(0, "serial_attach()\n");
 214
 215         /* Create new serial device */
 216         info = kmalloc(sizeof (*info), GFP_KERNEL);
 217         if (!info)
 218                 return NULL;
 219         memset(info, 0, sizeof (*info));
 220         link = &info->link;
 221         link->priv = info;
 222
 223         link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
 224         link->io.NumPorts1 = 8;
 225         link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
 226         link->irq.IRQInfo1 = IRQ_LEVEL_ID;
 227         link->conf.Attributes = CONF_ENABLE_IRQ;
 228         if (do_sound) {
 229                 link->conf.Attributes |= CONF_ENABLE_SPKR;
 230                 link->conf.Status = CCSR_AUDIO_ENA;
 231         }
 232         link->conf.IntType = INT_MEMORY_AND_IO;
 233
 234         /* Register with Card Services */
 235         link->next = NULL; /* not needed */
 236         client_reg.dev_info = &dev_info;
 237         client_reg.Version = 0x0210;
 238         client_reg.event_callback_args.client_data = link;
 239         ret = pcmcia_register_client(&link->handle, &client_reg);
 240         if (ret != CS_SUCCESS) {
 241                 cs_error(link->handle, RegisterClient, ret);
 242                 serial_detach(link->handle);
 243                 return NULL;
 244         }
 245
 246         return link;
 247 }
 248
 249 /*======================================================================
 250
 251     This deletes a driver "instance".  The device is de-registered
 252     with Card Services.  If it has been released, all local data
 253     structures are freed.  Otherwise, the structures will be freed
 254     when the device is released.
 255
 256 ======================================================================*/
 257
 258 static void serial_detach(struct pcmcia_device *p_dev)
 259 {
 260         dev_link_t *link = dev_to_instance(p_dev);
 261         struct serial_info *info = link->priv;
 262
 263         DEBUG(0, "serial_detach(0x%p)\n", link);
 264
 265         /*
 266          * Ensure any outstanding scheduled tasks are completed.
 267          */
 268         flush_scheduled_work();
 269
 270         /*
 271          * Ensure that the ports have been released.
 272          */
 273         serial_remove(link);
 274
 275         /* free bits */
 276         kfree(info);
 277 }
 278
 279 /*====================================================================*/
 280
 281 static int setup_serial(client_handle_t handle, struct serial_info * info,
 282                         kio_addr_t iobase, int irq)
 283 {
 284         struct uart_port port;
 285         int line;
 286
 287         memset(&port, 0, sizeof (struct uart_port));
 288         port.iobase = iobase;
 289         port.irq = irq;
 290         port.flags = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST | UPF_SHARE_IRQ;
 291         port.uartclk = 1843200;
 292         port.dev = &handle_to_dev(handle);
 293         if (buggy_uart)
 294                 port.flags |= UPF_BUGGY_UART;
 295         line = serial8250_register_port(&port);
 296         if (line < 0) {
 297                 printk(KERN_NOTICE "serial_cs: serial8250_register_port() at "
 298                        "0x%04lx, irq %d failed\n", (u_long)iobase, irq);
 299                 return -EINVAL;
 300         }
 301
 302         info->line[info->ndev] = line;
 303         sprintf(info->node[info->ndev].dev_name, "ttyS%d", line);
 304         info->node[info->ndev].major = TTY_MAJOR;
 305         info->node[info->ndev].minor = 0x40 + line;
 306         if (info->ndev > 0)
 307                 info->node[info->ndev - 1].next = &info->node[info->ndev];
 308         info->ndev++;
 309
 310         return 0;
 311 }
 312
 313 /*====================================================================*/
 314
 315 static int
 316 first_tuple(client_handle_t handle, tuple_t * tuple, cisparse_t * parse)
 317 {
 318         int i;
 319         i = pcmcia_get_first_tuple(handle, tuple);
 320         if (i != CS_SUCCESS)
 321                 return CS_NO_MORE_ITEMS;
 322         i = pcmcia_get_tuple_data(handle, tuple);
 323         if (i != CS_SUCCESS)
 324                 return i;
 325         return pcmcia_parse_tuple(handle, tuple, parse);
 326 }
 327
 328 static int
 329 next_tuple(client_handle_t handle, tuple_t * tuple, cisparse_t * parse)
 330 {
 331         int i;
 332         i = pcmcia_get_next_tuple(handle, tuple);
 333         if (i != CS_SUCCESS)
 334                 return CS_NO_MORE_ITEMS;
 335         i = pcmcia_get_tuple_data(handle, tuple);
 336         if (i != CS_SUCCESS)
 337                 return i;
 338         return pcmcia_parse_tuple(handle, tuple, parse);
 339 }
 340
 341 /*====================================================================*/
 342
 343 static int simple_config(dev_link_t *link)
 344 {
 345         static const kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
 346         static const int size_table[2] = { 8, 16 };
 347         client_handle_t handle = link->handle;
 348         struct serial_info *info = link->priv;
 349         struct serial_cfg_mem *cfg_mem;
 350         tuple_t *tuple;
 351         u_char *buf;
 352         cisparse_t *parse;
 353         cistpl_cftable_entry_t *cf;
 354         config_info_t config;
 355         int i, j, try;
 356         int s;
 357
 358         cfg_mem = kmalloc(sizeof(struct serial_cfg_mem), GFP_KERNEL);
 359         if (!cfg_mem)
 360                 return -1;
 361
 362         tuple = &cfg_mem->tuple;
 363         parse = &cfg_mem->parse;
 364         cf = &parse->cftable_entry;
 365         buf = cfg_mem->buf;
 366
 367         /* If the card is already configured, look up the port and irq */
 368         i = pcmcia_get_configuration_info(handle, &config);
 369         if ((i == CS_SUCCESS) && (config.Attributes & CONF_VALID_CLIENT)) {
 370                 kio_addr_t port = 0;
 371                 if ((config.BasePort2 != 0) && (config.NumPorts2 == 8)) {
 372                         port = config.BasePort2;
 373                         info->slave = 1;
 374                 } else if ((info->manfid == MANFID_OSITECH) &&
 375                            (config.NumPorts1 == 0x40)) {
 376                         port = config.BasePort1 + 0x28;
 377                         info->slave = 1;
 378                 }
 379                 if (info->slave) {
 380                         kfree(cfg_mem);
 381                         return setup_serial(handle, info, port, config.AssignedIRQ);
 382                 }
 383         }
 384         link->conf.Vcc = config.Vcc;
 385
 386         /* First pass: look for a config entry that looks normal. */
 387         tuple->TupleData = (cisdata_t *) buf;
 388         tuple->TupleOffset = 0;
 389         tuple->TupleDataMax = 255;
 390         tuple->Attributes = 0;
 391         tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
 392         /* Two tries: without IO aliases, then with aliases */
 393         for (s = 0; s < 2; s++) {
 394                 for (try = 0; try < 2; try++) {
 395                         i = first_tuple(handle, tuple, parse);
 396                         while (i != CS_NO_MORE_ITEMS) {
 397                                 if (i != CS_SUCCESS)
 398                                         goto next_entry;
 399                                 if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
 400                                         link->conf.Vpp1 = link->conf.Vpp2 =
 401                                             cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
 402                                 if ((cf->io.nwin > 0) && (cf->io.win[0].len == size_table[s]) &&
 403                                             (cf->io.win[0].base != 0)) {
 404                                         link->conf.ConfigIndex = cf->index;
 405                                         link->io.BasePort1 = cf->io.win[0].base;
 406                                         link->io.IOAddrLines = (try == 0) ?
 407                                             16 : cf->io.flags & CISTPL_IO_LINES_MASK;
 408                                         i = pcmcia_request_io(link->handle, &link->io);
 409                                         if (i == CS_SUCCESS)
 410                                                 goto found_port;
 411                                 }
 412 next_entry:
 413                                 i = next_tuple(handle, tuple, parse);
 414                         }
 415                 }
 416         }
 417         /* Second pass: try to find an entry that isn't picky about
 418            its base address, then try to grab any standard serial port
 419            address, and finally try to get any free port. */
 420         i = first_tuple(handle, tuple, parse);
 421         while (i != CS_NO_MORE_ITEMS) {
 422                 if ((i == CS_SUCCESS) && (cf->io.nwin > 0) &&
 423                     ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
 424                         link->conf.ConfigIndex = cf->index;
 425                         for (j = 0; j < 5; j++) {
 426                                 link->io.BasePort1 = base[j];
 427                                 link->io.IOAddrLines = base[j] ? 16 : 3;
 428                                 i = pcmcia_request_io(link->handle, &link->io);
 429                                 if (i == CS_SUCCESS)
 430                                         goto found_port;
 431                         }
 432                 }
 433                 i = next_tuple(handle, tuple, parse);
 434         }
 435
 436       found_port:
 437         if (i != CS_SUCCESS) {
 438                 printk(KERN_NOTICE
 439                        "serial_cs: no usable port range found, giving up\n");
 440                 cs_error(link->handle, RequestIO, i);
 441                 kfree(cfg_mem);
 442                 return -1;
 443         }
 444
 445         i = pcmcia_request_irq(link->handle, &link->irq);
 446         if (i != CS_SUCCESS) {
 447                 cs_error(link->handle, RequestIRQ, i);
 448                 link->irq.AssignedIRQ = 0;
 449         }
 450         if (info->multi && (info->manfid == MANFID_3COM))
 451                 link->conf.ConfigIndex &= ~(0x08);
 452         i = pcmcia_request_configuration(link->handle, &link->conf);
 453         if (i != CS_SUCCESS) {
 454                 cs_error(link->handle, RequestConfiguration, i);
 455                 kfree(cfg_mem);
 456                 return -1;
 457         }
 458         kfree(cfg_mem);
 459         return setup_serial(handle, info, link->io.BasePort1, link->irq.AssignedIRQ);
 460 }
 461
 462 static int multi_config(dev_link_t * link)
 463 {
 464         client_handle_t handle = link->handle;
 465         struct serial_info *info = link->priv;
 466         struct serial_cfg_mem *cfg_mem;
 467         tuple_t *tuple;
 468         u_char *buf;
 469         cisparse_t *parse;
 470         cistpl_cftable_entry_t *cf;
 471         config_info_t config;
 472         int i, rc, base2 = 0;
 473
 474         cfg_mem = kmalloc(sizeof(struct serial_cfg_mem), GFP_KERNEL);
 475         if (!cfg_mem)
 476                 return -1;
 477         tuple = &cfg_mem->tuple;
 478         parse = &cfg_mem->parse;
 479         cf = &parse->cftable_entry;
 480         buf = cfg_mem->buf;
 481
 482         i = pcmcia_get_configuration_info(handle, &config);
 483         if (i != CS_SUCCESS) {
 484                 cs_error(handle, GetConfigurationInfo, i);
 485                 rc = -1;
 486                 goto free_cfg_mem;
 487         }
 488         link->conf.Vcc = config.Vcc;
 489
 490         tuple->TupleData = (cisdata_t *) buf;
 491         tuple->TupleOffset = 0;
 492         tuple->TupleDataMax = 255;
 493         tuple->Attributes = 0;
 494         tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
 495
 496         /* First, look for a generic full-sized window */
 497         link->io.NumPorts1 = info->multi * 8;
 498         i = first_tuple(handle, tuple, parse);
 499         while (i != CS_NO_MORE_ITEMS) {
 500                 /* The quad port cards have bad CIS's, so just look for a
 501                    window larger than 8 ports and assume it will be right */
 502                 if ((i == CS_SUCCESS) && (cf->io.nwin == 1) &&
 503                     (cf->io.win[0].len > 8)) {
 504                         link->conf.ConfigIndex = cf->index;
 505                         link->io.BasePort1 = cf->io.win[0].base;
 506                         link->io.IOAddrLines =
 507                             cf->io.flags & CISTPL_IO_LINES_MASK;
 508                         i = pcmcia_request_io(link->handle, &link->io);
 509                         base2 = link->io.BasePort1 + 8;
 510                         if (i == CS_SUCCESS)
 511                                 break;
 512                 }
 513                 i = next_tuple(handle, tuple, parse);
 514         }
 515
 516         /* If that didn't work, look for two windows */
 517         if (i != CS_SUCCESS) {
 518                 link->io.NumPorts1 = link->io.NumPorts2 = 8;
 519                 info->multi = 2;
 520                 i = first_tuple(handle, tuple, parse);
 521                 while (i != CS_NO_MORE_ITEMS) {
 522                         if ((i == CS_SUCCESS) && (cf->io.nwin == 2)) {
 523                                 link->conf.ConfigIndex = cf->index;
 524                                 link->io.BasePort1 = cf->io.win[0].base;
 525                                 link->io.BasePort2 = cf->io.win[1].base;
 526                                 link->io.IOAddrLines =
 527                                     cf->io.flags & CISTPL_IO_LINES_MASK;
 528                                 i = pcmcia_request_io(link->handle, &link->io);
 529                                 base2 = link->io.BasePort2;
 530                                 if (i == CS_SUCCESS)
 531                                         break;
 532                         }
 533                         i = next_tuple(handle, tuple, parse);
 534                 }
 535         }
 536
 537         if (i != CS_SUCCESS) {
 538                 cs_error(link->handle, RequestIO, i);
 539                 rc = -1;
 540                 goto free_cfg_mem;
 541         }
 542
 543         i = pcmcia_request_irq(link->handle, &link->irq);
 544         if (i != CS_SUCCESS) {
 545                 printk(KERN_NOTICE
 546                        "serial_cs: no usable port range found, giving up\n");
 547                 cs_error(link->handle, RequestIRQ, i);
 548                 link->irq.AssignedIRQ = 0;
 549         }
 550         /* Socket Dual IO: this enables irq's for second port */
 551         if (info->multi && (info->manfid == MANFID_SOCKET)) {
 552                 link->conf.Present |= PRESENT_EXT_STATUS;
 553                 link->conf.ExtStatus = ESR_REQ_ATTN_ENA;
 554         }
 555         i = pcmcia_request_configuration(link->handle, &link->conf);
 556         if (i != CS_SUCCESS) {
 557                 cs_error(link->handle, RequestConfiguration, i);
 558                 rc = -1;
 559                 goto free_cfg_mem;
 560         }
 561
 562         /* The Oxford Semiconductor OXCF950 cards are in fact single-port:
 563            8 registers are for the UART, the others are extra registers */
 564         if (info->manfid == MANFID_OXSEMI) {
 565                 if (cf->index == 1 || cf->index == 3) {
 566                         setup_serial(handle, info, base2, link->irq.AssignedIRQ);
 567                         outb(12, link->io.BasePort1 + 1);
 568                 } else {
 569                         setup_serial(handle, info, link->io.BasePort1, link->irq.AssignedIRQ);
 570                         outb(12, base2 + 1);
 571                 }
 572                 rc = 0;
 573                 goto free_cfg_mem;
 574         }
 575
 576         setup_serial(handle, info, link->io.BasePort1, link->irq.AssignedIRQ);
 577         /* The Nokia cards are not really multiport cards */
 578         if (info->manfid == MANFID_NOKIA) {
 579                 rc = 0;
 580                 goto free_cfg_mem;
 581         }
 582         for (i = 0; i < info->multi - 1; i++)
 583                 setup_serial(handle, info, base2 + (8 * i),
 584                                 link->irq.AssignedIRQ);
 585         rc = 0;
 586 free_cfg_mem:
 587         kfree(cfg_mem);
 588         return rc;
 589 }
 590
 591 /*======================================================================
 592
 593     serial_config() is scheduled to run after a CARD_INSERTION event
 594     is received, to configure the PCMCIA socket, and to make the
 595     serial device available to the system.
 596
 597 ======================================================================*/
 598
 599 void serial_config(dev_link_t * link)
 600 {
 601         client_handle_t handle = link->handle;
 602         struct serial_info *info = link->priv;
 603         struct serial_cfg_mem *cfg_mem;
 604         tuple_t *tuple;
 605         u_char *buf;
 606         cisparse_t *parse;
 607         cistpl_cftable_entry_t *cf;
 608         int i, last_ret, last_fn;
 609
 610         DEBUG(0, "serial_config(0x%p)\n", link);
 611
 612         cfg_mem = kmalloc(sizeof(struct serial_cfg_mem), GFP_KERNEL);
 613         if (!cfg_mem)
 614                 goto failed;
 615
 616         tuple = &cfg_mem->tuple;
 617         parse = &cfg_mem->parse;
 618         cf = &parse->cftable_entry;
 619         buf = cfg_mem->buf;
 620
 621         tuple->TupleData = (cisdata_t *) buf;
 622         tuple->TupleOffset = 0;
 623         tuple->TupleDataMax = 255;
 624         tuple->Attributes = 0;
 625         /* Get configuration register information */
 626         tuple->DesiredTuple = CISTPL_CONFIG;
 627         last_ret = first_tuple(handle, tuple, parse);
 628         if (last_ret != CS_SUCCESS) {
 629                 last_fn = ParseTuple;
 630                 goto cs_failed;
 631         }
 632         link->conf.ConfigBase = parse->config.base;
 633         link->conf.Present = parse->config.rmask[0];
 634
 635         /* Configure card */
 636         link->state |= DEV_CONFIG;
 637
 638         /* Is this a compliant multifunction card? */
 639         tuple->DesiredTuple = CISTPL_LONGLINK_MFC;
 640         tuple->Attributes = TUPLE_RETURN_COMMON | TUPLE_RETURN_LINK;
 641         info->multi = (first_tuple(handle, tuple, parse) == CS_SUCCESS);
 642
 643         /* Is this a multiport card? */
 644         tuple->DesiredTuple = CISTPL_MANFID;
 645         if (first_tuple(handle, tuple, parse) == CS_SUCCESS) {
 646                 info->manfid = parse->manfid.manf;
 647                 for (i = 0; i < MULTI_COUNT; i++)
 648                         if ((info->manfid == multi_id[i].manfid) &&
 649                             (parse->manfid.card == multi_id[i].prodid))
 650                                 break;
 651                 if (i < MULTI_COUNT)
 652                         info->multi = multi_id[i].multi;
 653         }
 654
 655         /* Another check for dual-serial cards: look for either serial or
 656            multifunction cards that ask for appropriate IO port ranges */
 657         tuple->DesiredTuple = CISTPL_FUNCID;
 658         if ((info->multi == 0) &&
 659             ((first_tuple(handle, tuple, parse) != CS_SUCCESS) ||
 660              (parse->funcid.func == CISTPL_FUNCID_MULTI) ||
 661              (parse->funcid.func == CISTPL_FUNCID_SERIAL))) {
 662                 tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
 663                 if (first_tuple(handle, tuple, parse) == CS_SUCCESS) {
 664                         if ((cf->io.nwin == 1) && (cf->io.win[0].len % 8 == 0))
 665                                 info->multi = cf->io.win[0].len >> 3;
 666                         if ((cf->io.nwin == 2) && (cf->io.win[0].len == 8) &&
 667                             (cf->io.win[1].len == 8))
 668                                 info->multi = 2;
 669                 }
 670         }
 671
 672         if (info->multi > 1)
 673                 multi_config(link);
 674         else
 675                 simple_config(link);
 676
 677         if (info->ndev == 0)
 678                 goto failed;
 679
 680         if (info->manfid == MANFID_IBM) {
 681                 conf_reg_t reg = { 0, CS_READ, 0x800, 0 };
 682                 last_ret = pcmcia_access_configuration_register(link->handle, &reg);
 683                 if (last_ret) {
 684                         last_fn = AccessConfigurationRegister;
 685                         goto cs_failed;
 686                 }
 687                 reg.Action = CS_WRITE;
 688                 reg.Value = reg.Value | 1;
 689                 last_ret = pcmcia_access_configuration_register(link->handle, &reg);
 690                 if (last_ret) {
 691                         last_fn = AccessConfigurationRegister;
 692                         goto cs_failed;
 693                 }
 694         }
 695
 696         link->dev = &info->node[0];
 697         link->state &= ~DEV_CONFIG_PENDING;
 698         kfree(cfg_mem);
 699         return;
 700
 701  cs_failed:
 702         cs_error(link->handle, last_fn, last_ret);
 703  failed:
 704         serial_remove(link);
 705         link->state &= ~DEV_CONFIG_PENDING;
 706         kfree(cfg_mem);
 707 }
 708
 709 /*======================================================================
 710
 711     The card status event handler.  Mostly, this schedules other
 712     stuff to run after an event is received.  A CARD_REMOVAL event
 713     also sets some flags to discourage the serial drivers from
 714     talking to the ports.
 715
 716 ======================================================================*/
 717
 718 static int
 719 serial_event(event_t event, int priority, event_callback_args_t * args)
 720 {
 721         dev_link_t *link = args->client_data;
 722
 723         DEBUG(1, "serial_event(0x%06x)\n", event);
 724
 725         switch (event) {
 726
 727         case CS_EVENT_CARD_INSERTION:
 728                 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
 729                 serial_config(link);
 730                 break;
 731         }
 732         return 0;
 733 }
 734
 735 static struct pcmcia_device_id serial_ids[] = {
 736         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0057, 0x0021),
 737         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0089, 0x110a),
 738         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0104, 0x000a),
 739         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0105, 0xea15),
 740         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0109, 0x0501),
 741         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0138, 0x110a),
 742         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0140, 0x000a),
 743         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0143, 0x3341),
 744         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0143, 0xc0ab),
 745         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x016c, 0x0081),
 746         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x021b, 0x0101),
 747         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x08a1, 0xc0ab),
 748         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0105, 0x0d0a),
 749         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0105, 0x0e0a),
 750         PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "CC/XJEM3288", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x04cd2988, 0x46a52d63),
 751         PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "CC/XJEM3336", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x0143b773, 0x46a52d63),
 752         PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "EM1144T", "PCMCIA MODEM", 0xf510db04, 0x856d66c8, 0xbd6c43ef),
 753         PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "XJEM1144/CCEM1144", "PCMCIA MODEM", 0xf510db04, 0x52d21e1e, 0xbd6c43ef),
 754         PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "CEM28", 0x2e3ee845, 0x0ea978ea),
 755         PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "CEM33", 0x2e3ee845, 0x80609023),
 756         PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "CEM56", 0x2e3ee845, 0xa650c32a),
 757         PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "REM10", 0x2e3ee845, 0x76df1d29),
 758         PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "XEM5600", 0x2e3ee845, 0xf1403719),
 759         PCMCIA_PFC_DEVICE_PROD_ID12(1, "AnyCom", "Fast Ethernet + 56K COMBO", 0x578ba6e7, 0xb0ac62c4),
 760         PCMCIA_PFC_DEVICE_PROD_ID12(1, "D-Link", "DME336T", 0x1a424a1c, 0xb23897ff),
 761         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Gateway 2000", "XJEM3336", 0xdd9989be, 0x662c394c),
 762         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Grey Cell", "GCS3000", 0x2a151fac, 0x48b932ae),
 763         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Linksys", "EtherFast 10&100 + 56K PC Card (PCMLM56)", 0x0733cc81, 0xb3765033),
 764         PCMCIA_PFC_DEVICE_PROD_ID12(1, "LINKSYS", "PCMLM336", 0xf7cb0b07, 0x7a821b58),
 765         PCMCIA_PFC_DEVICE_PROD_ID12(1, "MEGAHERTZ", "XJEM1144/CCEM1144", 0xf510db04, 0x52d21e1e),
 766         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Ositech", "Trumpcard:Jack of Diamonds Modem+Ethernet", 0xc2f80cd, 0x656947b9),
 767         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Ositech", "Trumpcard:Jack of Hearts Modem+Ethernet", 0xc2f80cd, 0xdc9ba5ed),
 768         PCMCIA_PFC_DEVICE_PROD_ID12(1, "PCMCIAs", "ComboCard", 0xdcfe12d3, 0xcd8906cc),
 769         PCMCIA_PFC_DEVICE_PROD_ID12(1, "PCMCIAs", "LanModem", 0xdcfe12d3, 0xc67c648f),
 770         PCMCIA_PFC_DEVICE_PROD_ID12(1, "TDK", "GlobalNetworker 3410/3412", 0x1eae9475, 0xd9a93bed),
 771         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Xircom", "CreditCard Ethernet+Modem II", 0x2e3ee845, 0xeca401bf),
 772         PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x0104, 0x0070),
 773         PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x0101, 0x0562),
 774         PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x0104, 0x0070),
 775         PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x016c, 0x0020),
 776         PCMCIA_MFC_DEVICE_PROD_ID123(1, "APEX DATA", "MULTICARD", "ETHERNET-MODEM", 0x11c2da09, 0x7289dc5d, 0xaad95e1f),
 777         PCMCIA_MFC_DEVICE_PROD_ID12(1, "IBM", "Home and Away 28.8 PC Card       ", 0xb569a6e5, 0x5bd4ff2c),
 778         PCMCIA_MFC_DEVICE_PROD_ID12(1, "IBM", "Home and Away Credit Card Adapter", 0xb569a6e5, 0x4bdf15c3),
 779         PCMCIA_MFC_DEVICE_PROD_ID12(1, "IBM", "w95 Home and Away Credit Card ", 0xb569a6e5, 0xae911c15),
 780         PCMCIA_MFC_DEVICE_PROD_ID1(1, "Motorola MARQUIS", 0xf03e4e77),
 781         PCMCIA_MFC_DEVICE_PROD_ID2(1, "FAX/Modem/Ethernet Combo Card ", 0x1ed59302),
 782         PCMCIA_DEVICE_MANF_CARD(0x0089, 0x0301),
 783         PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0039),
 784         PCMCIA_DEVICE_MANF_CARD(0x0104, 0x0006),
 785         PCMCIA_DEVICE_MANF_CARD(0x0105, 0x410a),
 786         PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0d50),
 787         PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0d51),
 788         PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0d52),
 789         PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0d53),
 790         PCMCIA_DEVICE_MANF_CARD(0x010b, 0xd180),
 791         PCMCIA_DEVICE_MANF_CARD(0x0137, 0x000e),
 792         PCMCIA_DEVICE_MANF_CARD(0x0137, 0x001b),
 793         PCMCIA_DEVICE_MANF_CARD(0x0137, 0x0025),
 794         PCMCIA_DEVICE_MANF_CARD(0x0137, 0x0045),
 795         PCMCIA_DEVICE_MANF_CARD(0x0137, 0x0052),
 796         PCMCIA_DEVICE_PROD_ID134("ADV", "TECH", "COMpad-32/85", 0x67459937, 0x916d02ba, 0x8fbe92ae),
 797         PCMCIA_DEVICE_PROD_ID124("GATEWAY2000", "CC3144", "PCMCIA MODEM", 0x506bccae, 0xcb3685f1, 0xbd6c43ef),
 798         PCMCIA_DEVICE_PROD_ID14("MEGAHERTZ", "PCMCIA MODEM", 0xf510db04, 0xbd6c43ef),
 799         PCMCIA_DEVICE_PROD_ID124("TOSHIBA", "T144PF", "PCMCIA MODEM", 0xb4585a1a, 0x7271409c, 0xbd6c43ef),
 800         PCMCIA_DEVICE_PROD_ID123("FUJITSU", "FC14F ", "MBH10213", 0x6ee5a3d8, 0x30ead12b, 0xb00f05a0),
 801         PCMCIA_DEVICE_PROD_ID13("MEGAHERTZ", "V.34 PCMCIA MODEM", 0xf510db04, 0xbb2cce4a),
 802         PCMCIA_DEVICE_PROD_ID12("Brain Boxes", "Bluetooth PC Card", 0xee138382, 0xd4ce9b02),
 803         PCMCIA_DEVICE_PROD_ID12("CIRRUS LOGIC", "FAX MODEM", 0xe625f451, 0xcecd6dfa),
 804         PCMCIA_DEVICE_PROD_ID12("COMPAQ", "PCMCIA 28800 FAX/DATA MODEM", 0xa3a3062c, 0x8cbd7c76),
 805         PCMCIA_DEVICE_PROD_ID12("COMPAQ", "PCMCIA 33600 FAX/DATA MODEM", 0xa3a3062c, 0x5a00ce95),
 806         PCMCIA_DEVICE_PROD_ID12("Computerboards, Inc.", "PCM-COM422", 0xd0b78f51, 0x7e2d49ed),
 807         PCMCIA_DEVICE_PROD_ID12("Dr. Neuhaus", "FURY CARD 14K4", 0x76942813, 0x8b96ce65),
 808         PCMCIA_DEVICE_PROD_ID12("Intelligent", "ANGIA FAX/MODEM", 0xb496e65e, 0xf31602a6),
 809         PCMCIA_DEVICE_PROD_ID12("Intel", "MODEM 2400+", 0x816cc815, 0x412729fb),
 810         PCMCIA_DEVICE_PROD_ID12("IOTech Inc ", "PCMCIA Dual RS-232 Serial Port Card", 0x3bd2d898, 0x92abc92f),
 811         PCMCIA_DEVICE_PROD_ID12("MACRONIX", "FAX/MODEM", 0x668388b3, 0x3f9bdf2f),
 812         PCMCIA_DEVICE_PROD_ID12("Multi-Tech", "MT1432LT", 0x5f73be51, 0x0b3e2383),
 813         PCMCIA_DEVICE_PROD_ID12("Multi-Tech", "MT2834LT", 0x5f73be51, 0x4cd7c09e),
 814         PCMCIA_DEVICE_PROD_ID12("OEM      ", "C288MX     ", 0xb572d360, 0xd2385b7a),
 815         PCMCIA_DEVICE_PROD_ID12("PCMCIA   ", "C336MX     ", 0x99bcafe9, 0xaa25bcab),
 816         PCMCIA_DEVICE_PROD_ID12("Quatech Inc", "PCMCIA Dual RS-232 Serial Port Card", 0xc4420b35, 0x92abc92f),
 817         PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "PCMCIA", "EN2218-LAN/MODEM", 0x281f1c5d, 0x570f348e, "PCMLM28.cis"),
 818         PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "PCMCIA", "UE2218-LAN/MODEM", 0x281f1c5d, 0x6fdcacee, "PCMLM28.cis"),
 819         PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "Psion Dacom", "Gold Card V34 Ethernet", 0xf5f025c2, 0x338e8155, "PCMLM28.cis"),
 820         PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "Psion Dacom", "Gold Card V34 Ethernet GSM", 0xf5f025c2, 0x4ae85d35, "PCMLM28.cis"),
 821         PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "LINKSYS", "PCMLM28", 0xf7cb0b07, 0x66881874, "PCMLM28.cis"),
 822         PCMCIA_MFC_DEVICE_CIS_PROD_ID12(1, "DAYNA COMMUNICATIONS", "LAN AND MODEM MULTIFUNCTION", 0x8fdf8f89, 0xdd5ed9e8, "DP83903.cis"),
 823         PCMCIA_MFC_DEVICE_CIS_PROD_ID4(1, "NSC MF LAN/Modem", 0x58fc6056, "DP83903.cis"),
 824         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x0556, "3CCFEM556.cis"),
 825         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0175, 0x0000, "DP83903.cis"),
 826         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x0035, "3CXEM556.cis"),
 827         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x003d, "3CXEM556.cis"),
 828         PCMCIA_DEVICE_CIS_MANF_CARD(0x0192, 0x0710, "SW_7xx_SER.cis"),  /* Sierra Wireless AC710/AC750 GPRS Network Adapter R1 */
 829         PCMCIA_DEVICE_CIS_PROD_ID12("MultiTech", "PCMCIA 56K DataFax", 0x842047ee, 0xc2efcf03, "MT5634ZLX.cis"),
 830         PCMCIA_DEVICE_CIS_PROD_ID12("ADVANTECH", "COMpad-32/85B-4", 0x96913a85, 0xcec8f102, "COMpad4.cis"),
 831         PCMCIA_DEVICE_CIS_PROD_ID123("ADVANTECH", "COMpad-32/85", "1.0", 0x96913a85, 0x8fbe92ae, 0x0877b627, "COMpad2.cis"),
 832         PCMCIA_DEVICE_CIS_PROD_ID2("RS-COM 2P", 0xad20b156, "RS-COM-2P.cis"),
 833         /* too generic */
 834         /* PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x0160, 0x0002), */
 835         /* PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x0160, 0x0002), */
 836         PCMCIA_DEVICE_FUNC_ID(2),
 837         PCMCIA_DEVICE_NULL,
 838 };
 839 MODULE_DEVICE_TABLE(pcmcia, serial_ids);
 840
 841 static struct pcmcia_driver serial_cs_driver = {
 842         .owner          = THIS_MODULE,
 843         .drv            = {
 844                 .name   = "serial_cs",
 845         },
 846         .attach         = serial_attach,
 847         .event          = serial_event,
 848         .remove         = serial_detach,
 849         .id_table       = serial_ids,
 850         .suspend        = serial_suspend,
 851         .resume         = serial_resume,
 852 };
 853
 854 static int __init init_serial_cs(void)
 855 {
 856         return pcmcia_register_driver(&serial_cs_driver);
 857 }
 858
 859 static void __exit exit_serial_cs(void)
 860 {
 861         pcmcia_unregister_driver(&serial_cs_driver);
 862 }
 863
 864 module_init(init_serial_cs);
 865 module_exit(exit_serial_cs);
 866
 867 MODULE_LICENSE("GPL");