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