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