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/version.h>
  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 /* Bit map of interrupts to choose from */
  72 static u_int irq_mask = 0xdeb8;
  73 static int irq_list[4];
  74 static unsigned int irq_list_count;
  75
  76 /* Enable the speaker? */
  77 static int do_sound = 1;
  78 /* Skip strict UART tests? */
  79 static int buggy_uart;
  80
  81 module_param(irq_mask, uint, 0444);
  82 module_param_array(irq_list, int, &irq_list_count, 0444);
  83 module_param(do_sound, int, 0444);
  84 module_param(buggy_uart, int, 0444);
  85
  86 /*====================================================================*/
  87
  88 /* Table of multi-port card ID's */
  89
  90 struct multi_id {
  91         u_short manfid;
  92         u_short prodid;
  93         int multi;              /* 1 = multifunction, > 1 = # ports */
  94 };
  95
  96 static struct multi_id multi_id[] = {
  97         { MANFID_OMEGA,   PRODID_OMEGA_QSP_100,         4 },
  98         { MANFID_QUATECH, PRODID_QUATECH_DUAL_RS232,    2 },
  99         { MANFID_QUATECH, PRODID_QUATECH_DUAL_RS232_D1, 2 },
 100         { MANFID_QUATECH, PRODID_QUATECH_QUAD_RS232,    4 },
 101         { MANFID_SOCKET,  PRODID_SOCKET_DUAL_RS232,     2 },
 102         { MANFID_INTEL,   PRODID_INTEL_DUAL_RS232,      2 },
 103         { MANFID_NATINST, PRODID_NATINST_QUAD_RS232,    4 }
 104 };
 105 #define MULTI_COUNT (sizeof(multi_id)/sizeof(struct multi_id))
 106
 107 struct serial_info {
 108         dev_link_t              link;
 109         int                     ndev;
 110         int                     multi;
 111         int                     slave;
 112         int                     manfid;
 113         dev_node_t              node[4];
 114         int                     line[4];
 115 };
 116
 117 static void serial_config(dev_link_t * link);
 118 static int serial_event(event_t event, int priority,
 119                         event_callback_args_t * args);
 120
 121 static dev_info_t dev_info = "serial_cs";
 122
 123 static dev_link_t *serial_attach(void);
 124 static void serial_detach(dev_link_t *);
 125
 126 static dev_link_t *dev_list = NULL;
 127
 128 /*======================================================================
 129
 130     After a card is removed, serial_remove() will unregister
 131     the serial device(s), and release the PCMCIA configuration.
 132
 133 ======================================================================*/
 134
 135 static void serial_remove(dev_link_t *link)
 136 {
 137         struct serial_info *info = link->priv;
 138         int i;
 139
 140         link->state &= ~DEV_PRESENT;
 141
 142         DEBUG(0, "serial_release(0x%p)\n", link);
 143
 144         /*
 145          * Recheck to see if the device is still configured.
 146          */
 147         if (info->link.state & DEV_CONFIG) {
 148                 for (i = 0; i < info->ndev; i++)
 149                         serial8250_unregister_port(info->line[i]);
 150
 151                 info->link.dev = NULL;
 152
 153                 if (!info->slave) {
 154                         pcmcia_release_configuration(info->link.handle);
 155                         pcmcia_release_io(info->link.handle, &info->link.io);
 156                         pcmcia_release_irq(info->link.handle, &info->link.irq);
 157                 }
 158
 159                 info->link.state &= ~DEV_CONFIG;
 160         }
 161 }
 162
 163 static void serial_suspend(dev_link_t *link)
 164 {
 165         link->state |= DEV_SUSPEND;
 166
 167         if (link->state & DEV_CONFIG) {
 168                 struct serial_info *info = link->priv;
 169                 int i;
 170
 171                 for (i = 0; i < info->ndev; i++)
 172                         serial8250_suspend_port(info->line[i]);
 173
 174                 if (!info->slave)
 175                         pcmcia_release_configuration(link->handle);
 176         }
 177 }
 178
 179 static void serial_resume(dev_link_t *link)
 180 {
 181         link->state &= ~DEV_SUSPEND;
 182
 183         if (DEV_OK(link)) {
 184                 struct serial_info *info = link->priv;
 185                 int i;
 186
 187                 if (!info->slave)
 188                         pcmcia_request_configuration(link->handle, &link->conf);
 189
 190                 for (i = 0; i < info->ndev; i++)
 191                         serial8250_resume_port(info->line[i]);
 192         }
 193 }
 194
 195 /*======================================================================
 196
 197     serial_attach() creates an "instance" of the driver, allocating
 198     local data structures for one device.  The device is registered
 199     with Card Services.
 200
 201 ======================================================================*/
 202
 203 static dev_link_t *serial_attach(void)
 204 {
 205         struct serial_info *info;
 206         client_reg_t client_reg;
 207         dev_link_t *link;
 208         int i, ret;
 209
 210         DEBUG(0, "serial_attach()\n");
 211
 212         /* Create new serial device */
 213         info = kmalloc(sizeof (*info), GFP_KERNEL);
 214         if (!info)
 215                 return NULL;
 216         memset(info, 0, sizeof (*info));
 217         link = &info->link;
 218         link->priv = info;
 219
 220         link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
 221         link->io.NumPorts1 = 8;
 222         link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
 223         link->irq.IRQInfo1 = IRQ_INFO2_VALID | IRQ_LEVEL_ID;
 224         if (irq_list_count == 0)
 225                 link->irq.IRQInfo2 = irq_mask;
 226         else
 227                 for (i = 0; i < irq_list_count; i++)
 228                         link->irq.IRQInfo2 |= 1 << irq_list[i];
 229         link->conf.Attributes = CONF_ENABLE_IRQ;
 230         if (do_sound) {
 231                 link->conf.Attributes |= CONF_ENABLE_SPKR;
 232                 link->conf.Status = CCSR_AUDIO_ENA;
 233         }
 234         link->conf.IntType = INT_MEMORY_AND_IO;
 235
 236         /* Register with Card Services */
 237         link->next = dev_list;
 238         dev_list = link;
 239         client_reg.dev_info = &dev_info;
 240         client_reg.Attributes = INFO_IO_CLIENT | INFO_CARD_SHARE;
 241         client_reg.EventMask =
 242             CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL |
 243             CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET |
 244             CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME;
 245         client_reg.event_handler = &serial_event;
 246         client_reg.Version = 0x0210;
 247         client_reg.event_callback_args.client_data = link;
 248         ret = pcmcia_register_client(&link->handle, &client_reg);
 249         if (ret != CS_SUCCESS) {
 250                 cs_error(link->handle, RegisterClient, ret);
 251                 serial_detach(link);
 252                 return NULL;
 253         }
 254
 255         return link;
 256 }
 257
 258 /*======================================================================
 259
 260     This deletes a driver "instance".  The device is de-registered
 261     with Card Services.  If it has been released, all local data
 262     structures are freed.  Otherwise, the structures will be freed
 263     when the device is released.
 264
 265 ======================================================================*/
 266
 267 static void serial_detach(dev_link_t * link)
 268 {
 269         struct serial_info *info = link->priv;
 270         dev_link_t **linkp;
 271         int ret;
 272
 273         DEBUG(0, "serial_detach(0x%p)\n", link);
 274
 275         /* Locate device structure */
 276         for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
 277                 if (*linkp == link)
 278                         break;
 279         if (*linkp == NULL)
 280                 return;
 281
 282         /*
 283          * Ensure any outstanding scheduled tasks are completed.
 284          */
 285         flush_scheduled_work();
 286
 287         /*
 288          * Ensure that the ports have been released.
 289          */
 290         serial_remove(link);
 291
 292         if (link->handle) {
 293                 ret = pcmcia_deregister_client(link->handle);
 294                 if (ret != CS_SUCCESS)
 295                         cs_error(link->handle, DeregisterClient, ret);
 296         }
 297
 298         /* Unlink device structure, free bits */
 299         *linkp = link->next;
 300         kfree(info);
 301 }
 302
 303 /*====================================================================*/
 304
 305 static int setup_serial(struct serial_info * info, ioaddr_t iobase, int irq)
 306 {
 307         struct uart_port port;
 308         int line;
 309
 310         memset(&port, 0, sizeof (struct uart_port));
 311         port.iobase = iobase;
 312         port.irq = irq;
 313         port.flags = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST | UPF_SHARE_IRQ;
 314         port.uartclk = 1843200;
 315         if (buggy_uart)
 316                 port.flags |= UPF_BUGGY_UART;
 317         line = serial8250_register_port(&port);
 318         if (line < 0) {
 319                 printk(KERN_NOTICE "serial_cs: serial8250_register_port() at "
 320                        "0x%04lx, irq %d failed\n", (u_long)iobase, irq);
 321                 return -EINVAL;
 322         }
 323
 324         info->line[info->ndev] = line;
 325         sprintf(info->node[info->ndev].dev_name, "ttyS%d", line);
 326         info->node[info->ndev].major = TTY_MAJOR;
 327         info->node[info->ndev].minor = 0x40 + line;
 328         if (info->ndev > 0)
 329                 info->node[info->ndev - 1].next = &info->node[info->ndev];
 330         info->ndev++;
 331
 332         return 0;
 333 }
 334
 335 /*====================================================================*/
 336
 337 static int
 338 first_tuple(client_handle_t handle, tuple_t * tuple, cisparse_t * parse)
 339 {
 340         int i;
 341         i = pcmcia_get_first_tuple(handle, tuple);
 342         if (i != CS_SUCCESS)
 343                 return CS_NO_MORE_ITEMS;
 344         i = pcmcia_get_tuple_data(handle, tuple);
 345         if (i != CS_SUCCESS)
 346                 return i;
 347         return pcmcia_parse_tuple(handle, tuple, parse);
 348 }
 349
 350 static int
 351 next_tuple(client_handle_t handle, tuple_t * tuple, cisparse_t * parse)
 352 {
 353         int i;
 354         i = pcmcia_get_next_tuple(handle, tuple);
 355         if (i != CS_SUCCESS)
 356                 return CS_NO_MORE_ITEMS;
 357         i = pcmcia_get_tuple_data(handle, tuple);
 358         if (i != CS_SUCCESS)
 359                 return i;
 360         return pcmcia_parse_tuple(handle, tuple, parse);
 361 }
 362
 363 /*====================================================================*/
 364
 365 static int simple_config(dev_link_t *link)
 366 {
 367         static ioaddr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
 368         static int size_table[2] = { 8, 16 };
 369         client_handle_t handle = link->handle;
 370         struct serial_info *info = link->priv;
 371         tuple_t tuple;
 372         u_char buf[256];
 373         cisparse_t parse;
 374         cistpl_cftable_entry_t *cf = &parse.cftable_entry;
 375         config_info_t config;
 376         int i, j, try;
 377         int s;
 378
 379         /* If the card is already configured, look up the port and irq */
 380         i = pcmcia_get_configuration_info(handle, &config);
 381         if ((i == CS_SUCCESS) && (config.Attributes & CONF_VALID_CLIENT)) {
 382                 ioaddr_t port = 0;
 383                 if ((config.BasePort2 != 0) && (config.NumPorts2 == 8)) {
 384                         port = config.BasePort2;
 385                         info->slave = 1;
 386                 } else if ((info->manfid == MANFID_OSITECH) &&
 387                            (config.NumPorts1 == 0x40)) {
 388                         port = config.BasePort1 + 0x28;
 389                         info->slave = 1;
 390                 }
 391                 if (info->slave)
 392                         return setup_serial(info, port, config.AssignedIRQ);
 393         }
 394         link->conf.Vcc = config.Vcc;
 395
 396         /* First pass: look for a config entry that looks normal. */
 397         tuple.TupleData = (cisdata_t *) buf;
 398         tuple.TupleOffset = 0;
 399         tuple.TupleDataMax = 255;
 400         tuple.Attributes = 0;
 401         tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
 402         /* Two tries: without IO aliases, then with aliases */
 403         for (s = 0; s < 2; s++) {
 404                 for (try = 0; try < 2; try++) {
 405                         i = first_tuple(handle, &tuple, &parse);
 406                         while (i != CS_NO_MORE_ITEMS) {
 407                                 if (i != CS_SUCCESS)
 408                                         goto next_entry;
 409                                 if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
 410                                         link->conf.Vpp1 = link->conf.Vpp2 =
 411                                             cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
 412                                 if ((cf->io.nwin > 0) && (cf->io.win[0].len == size_table[s]) &&
 413                                             (cf->io.win[0].base != 0)) {
 414                                         link->conf.ConfigIndex = cf->index;
 415                                         link->io.BasePort1 = cf->io.win[0].base;
 416                                         link->io.IOAddrLines = (try == 0) ?
 417                                             16 : cf->io.flags & CISTPL_IO_LINES_MASK;
 418                                         i = pcmcia_request_io(link->handle, &link->io);
 419                                         if (i == CS_SUCCESS)
 420                                                 goto found_port;
 421                                 }
 422 next_entry:
 423                                 i = next_tuple(handle, &tuple, &parse);
 424                         }
 425                 }
 426         }
 427         /* Second pass: try to find an entry that isn't picky about
 428            its base address, then try to grab any standard serial port
 429            address, and finally try to get any free port. */
 430         i = first_tuple(handle, &tuple, &parse);
 431         while (i != CS_NO_MORE_ITEMS) {
 432                 if ((i == CS_SUCCESS) && (cf->io.nwin > 0) &&
 433                     ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
 434                         link->conf.ConfigIndex = cf->index;
 435                         for (j = 0; j < 5; j++) {
 436                                 link->io.BasePort1 = base[j];
 437                                 link->io.IOAddrLines = base[j] ? 16 : 3;
 438                                 i = pcmcia_request_io(link->handle, &link->io);
 439                                 if (i == CS_SUCCESS)
 440                                         goto found_port;
 441                         }
 442                 }
 443                 i = next_tuple(handle, &tuple, &parse);
 444         }
 445
 446       found_port:
 447         if (i != CS_SUCCESS) {
 448                 printk(KERN_NOTICE
 449                        "serial_cs: no usable port range found, giving up\n");
 450                 cs_error(link->handle, RequestIO, i);
 451                 return -1;
 452         }
 453
 454         i = pcmcia_request_irq(link->handle, &link->irq);
 455         if (i != CS_SUCCESS) {
 456                 cs_error(link->handle, RequestIRQ, i);
 457                 link->irq.AssignedIRQ = 0;
 458         }
 459         if (info->multi && (info->manfid == MANFID_3COM))
 460                 link->conf.ConfigIndex &= ~(0x08);
 461         i = pcmcia_request_configuration(link->handle, &link->conf);
 462         if (i != CS_SUCCESS) {
 463                 cs_error(link->handle, RequestConfiguration, i);
 464                 return -1;
 465         }
 466
 467         return setup_serial(info, link->io.BasePort1, link->irq.AssignedIRQ);
 468 }
 469
 470 static int multi_config(dev_link_t * link)
 471 {
 472         client_handle_t handle = link->handle;
 473         struct serial_info *info = link->priv;
 474         tuple_t tuple;
 475         u_char buf[256];
 476         cisparse_t parse;
 477         cistpl_cftable_entry_t *cf = &parse.cftable_entry;
 478         config_info_t config;
 479         int i, base2 = 0;
 480
 481         i = pcmcia_get_configuration_info(handle, &config);
 482         if (i != CS_SUCCESS) {
 483                 cs_error(handle, GetConfigurationInfo, i);
 484                 return -1;
 485         }
 486         link->conf.Vcc = config.Vcc;
 487
 488         tuple.TupleData = (cisdata_t *) buf;
 489         tuple.TupleOffset = 0;
 490         tuple.TupleDataMax = 255;
 491         tuple.Attributes = 0;
 492         tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
 493
 494         /* First, look for a generic full-sized window */
 495         link->io.NumPorts1 = info->multi * 8;
 496         i = first_tuple(handle, &tuple, &parse);
 497         while (i != CS_NO_MORE_ITEMS) {
 498                 /* The quad port cards have bad CIS's, so just look for a
 499                    window larger than 8 ports and assume it will be right */
 500                 if ((i == CS_SUCCESS) && (cf->io.nwin == 1) &&
 501                     (cf->io.win[0].len > 8)) {
 502                         link->conf.ConfigIndex = cf->index;
 503                         link->io.BasePort1 = cf->io.win[0].base;
 504                         link->io.IOAddrLines =
 505                             cf->io.flags & CISTPL_IO_LINES_MASK;
 506                         i = pcmcia_request_io(link->handle, &link->io);
 507                         base2 = link->io.BasePort1 + 8;
 508                         if (i == CS_SUCCESS)
 509                                 break;
 510                 }
 511                 i = next_tuple(handle, &tuple, &parse);
 512         }
 513
 514         /* If that didn't work, look for two windows */
 515         if (i != CS_SUCCESS) {
 516                 link->io.NumPorts1 = link->io.NumPorts2 = 8;
 517                 info->multi = 2;
 518                 i = first_tuple(handle, &tuple, &parse);
 519                 while (i != CS_NO_MORE_ITEMS) {
 520                         if ((i == CS_SUCCESS) && (cf->io.nwin == 2)) {
 521                                 link->conf.ConfigIndex = cf->index;
 522                                 link->io.BasePort1 = cf->io.win[0].base;
 523                                 link->io.BasePort2 = cf->io.win[1].base;
 524                                 link->io.IOAddrLines =
 525                                     cf->io.flags & CISTPL_IO_LINES_MASK;
 526                                 i = pcmcia_request_io(link->handle, &link->io);
 527                                 base2 = link->io.BasePort2;
 528                                 if (i == CS_SUCCESS)
 529                                         break;
 530                         }
 531                         i = next_tuple(handle, &tuple, &parse);
 532                 }
 533         }
 534
 535         if (i != CS_SUCCESS) {
 536                 cs_error(link->handle, RequestIO, i);
 537                 return -1;
 538         }
 539
 540         i = pcmcia_request_irq(link->handle, &link->irq);
 541         if (i != CS_SUCCESS) {
 542                 printk(KERN_NOTICE
 543                        "serial_cs: no usable port range found, giving up\n");
 544                 cs_error(link->handle, RequestIRQ, i);
 545                 link->irq.AssignedIRQ = 0;
 546         }
 547         /* Socket Dual IO: this enables irq's for second port */
 548         if (info->multi && (info->manfid == MANFID_SOCKET)) {
 549                 link->conf.Present |= PRESENT_EXT_STATUS;
 550                 link->conf.ExtStatus = ESR_REQ_ATTN_ENA;
 551         }
 552         i = pcmcia_request_configuration(link->handle, &link->conf);
 553         if (i != CS_SUCCESS) {
 554                 cs_error(link->handle, RequestConfiguration, i);
 555                 return -1;
 556         }
 557
 558         /* The Oxford Semiconductor OXCF950 cards are in fact single-port:
 559            8 registers are for the UART, the others are extra registers */
 560         if (info->manfid == MANFID_OXSEMI) {
 561                 if (cf->index == 1 || cf->index == 3) {
 562                         setup_serial(info, base2, link->irq.AssignedIRQ);
 563                         outb(12, link->io.BasePort1 + 1);
 564                 } else {
 565                         setup_serial(info, link->io.BasePort1, link->irq.AssignedIRQ);
 566                         outb(12, base2 + 1);
 567                 }
 568                 return 0;
 569         }
 570
 571         setup_serial(info, link->io.BasePort1, link->irq.AssignedIRQ);
 572         /* The Nokia cards are not really multiport cards */
 573         if (info->manfid == MANFID_NOKIA)
 574                 return 0;
 575         for (i = 0; i < info->multi - 1; i++)
 576                 setup_serial(info, base2 + (8 * i), link->irq.AssignedIRQ);
 577
 578         return 0;
 579 }
 580
 581 /*======================================================================
 582
 583     serial_config() is scheduled to run after a CARD_INSERTION event
 584     is received, to configure the PCMCIA socket, and to make the
 585     serial device available to the system.
 586
 587 ======================================================================*/
 588
 589 void serial_config(dev_link_t * link)
 590 {
 591         client_handle_t handle = link->handle;
 592         struct serial_info *info = link->priv;
 593         tuple_t tuple;
 594         u_short buf[128];
 595         cisparse_t parse;
 596         cistpl_cftable_entry_t *cf = &parse.cftable_entry;
 597         int i, last_ret, last_fn;
 598
 599         DEBUG(0, "serial_config(0x%p)\n", link);
 600
 601         tuple.TupleData = (cisdata_t *) buf;
 602         tuple.TupleOffset = 0;
 603         tuple.TupleDataMax = 255;
 604         tuple.Attributes = 0;
 605         /* Get configuration register information */
 606         tuple.DesiredTuple = CISTPL_CONFIG;
 607         last_ret = first_tuple(handle, &tuple, &parse);
 608         if (last_ret != CS_SUCCESS) {
 609                 last_fn = ParseTuple;
 610                 goto cs_failed;
 611         }
 612         link->conf.ConfigBase = parse.config.base;
 613         link->conf.Present = parse.config.rmask[0];
 614
 615         /* Configure card */
 616         link->state |= DEV_CONFIG;
 617
 618         /* Is this a compliant multifunction card? */
 619         tuple.DesiredTuple = CISTPL_LONGLINK_MFC;
 620         tuple.Attributes = TUPLE_RETURN_COMMON | TUPLE_RETURN_LINK;
 621         info->multi = (first_tuple(handle, &tuple, &parse) == CS_SUCCESS);
 622
 623         /* Is this a multiport card? */
 624         tuple.DesiredTuple = CISTPL_MANFID;
 625         if (first_tuple(handle, &tuple, &parse) == CS_SUCCESS) {
 626                 info->manfid = le16_to_cpu(buf[0]);
 627                 for (i = 0; i < MULTI_COUNT; i++)
 628                         if ((info->manfid == multi_id[i].manfid) &&
 629                             (le16_to_cpu(buf[1]) == multi_id[i].prodid))
 630                                 break;
 631                 if (i < MULTI_COUNT)
 632                         info->multi = multi_id[i].multi;
 633         }
 634
 635         /* Another check for dual-serial cards: look for either serial or
 636            multifunction cards that ask for appropriate IO port ranges */
 637         tuple.DesiredTuple = CISTPL_FUNCID;
 638         if ((info->multi == 0) &&
 639             ((first_tuple(handle, &tuple, &parse) != CS_SUCCESS) ||
 640              (parse.funcid.func == CISTPL_FUNCID_MULTI) ||
 641              (parse.funcid.func == CISTPL_FUNCID_SERIAL))) {
 642                 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
 643                 if (first_tuple(handle, &tuple, &parse) == CS_SUCCESS) {
 644                         if ((cf->io.nwin == 1) && (cf->io.win[0].len % 8 == 0))
 645                                 info->multi = cf->io.win[0].len >> 3;
 646                         if ((cf->io.nwin == 2) && (cf->io.win[0].len == 8) &&
 647                             (cf->io.win[1].len == 8))
 648                                 info->multi = 2;
 649                 }
 650         }
 651
 652         if (info->multi > 1)
 653                 multi_config(link);
 654         else
 655                 simple_config(link);
 656
 657         if (info->ndev == 0)
 658                 goto failed;
 659
 660         if (info->manfid == MANFID_IBM) {
 661                 conf_reg_t reg = { 0, CS_READ, 0x800, 0 };
 662                 last_ret = pcmcia_access_configuration_register(link->handle, &reg);
 663                 if (last_ret) {
 664                         last_fn = AccessConfigurationRegister;
 665                         goto cs_failed;
 666                 }
 667                 reg.Action = CS_WRITE;
 668                 reg.Value = reg.Value | 1;
 669                 last_ret = pcmcia_access_configuration_register(link->handle, &reg);
 670                 if (last_ret) {
 671                         last_fn = AccessConfigurationRegister;
 672                         goto cs_failed;
 673                 }
 674         }
 675
 676         link->dev = &info->node[0];
 677         link->state &= ~DEV_CONFIG_PENDING;
 678         return;
 679
 680  cs_failed:
 681         cs_error(link->handle, last_fn, last_ret);
 682  failed:
 683         serial_remove(link);
 684         link->state &= ~DEV_CONFIG_PENDING;
 685 }
 686
 687 /*======================================================================
 688
 689     The card status event handler.  Mostly, this schedules other
 690     stuff to run after an event is received.  A CARD_REMOVAL event
 691     also sets some flags to discourage the serial drivers from
 692     talking to the ports.
 693
 694 ======================================================================*/
 695
 696 static int
 697 serial_event(event_t event, int priority, event_callback_args_t * args)
 698 {
 699         dev_link_t *link = args->client_data;
 700         struct serial_info *info = link->priv;
 701
 702         DEBUG(1, "serial_event(0x%06x)\n", event);
 703
 704         switch (event) {
 705         case CS_EVENT_CARD_REMOVAL:
 706                 serial_remove(link);
 707                 break;
 708
 709         case CS_EVENT_CARD_INSERTION:
 710                 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
 711                 serial_config(link);
 712                 break;
 713
 714         case CS_EVENT_PM_SUSPEND:
 715                 serial_suspend(link);
 716                 break;
 717
 718         case CS_EVENT_RESET_PHYSICAL:
 719                 if ((link->state & DEV_CONFIG) && !info->slave)
 720                         pcmcia_release_configuration(link->handle);
 721                 break;
 722
 723         case CS_EVENT_PM_RESUME:
 724                 serial_resume(link);
 725                 break;
 726
 727         case CS_EVENT_CARD_RESET:
 728                 if (DEV_OK(link) && !info->slave)
 729                         pcmcia_request_configuration(link->handle, &link->conf);
 730                 break;
 731         }
 732         return 0;
 733 }
 734
 735 static struct pcmcia_driver serial_cs_driver = {
 736         .owner          = THIS_MODULE,
 737         .drv            = {
 738                 .name   = "serial_cs",
 739         },
 740         .attach         = serial_attach,
 741         .detach         = serial_detach,
 742 };
 743
 744 static int __init init_serial_cs(void)
 745 {
 746         return pcmcia_register_driver(&serial_cs_driver);
 747 }
 748
 749 static void __exit exit_serial_cs(void)
 750 {
 751         pcmcia_unregister_driver(&serial_cs_driver);
 752
 753         /* XXX: this really needs to move into generic code.. */
 754         while (dev_list != NULL)
 755                 serial_detach(dev_list);
 756 }
 757
 758 module_init(init_serial_cs);
 759 module_exit(exit_serial_cs);
 760
 761 MODULE_LICENSE("GPL");