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