drivers/serial/serial_cs.c

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