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
 362         /* First pass: look for a config entry that looks normal. */
 363         tuple->TupleData = (cisdata_t *) buf;
 364         tuple->TupleOffset = 0;
 365         tuple->TupleDataMax = 255;
 366         tuple->Attributes = 0;
 367         tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
 368         /* Two tries: without IO aliases, then with aliases */
 369         for (s = 0; s < 2; s++) {
 370                 for (try = 0; try < 2; try++) {
 371                         i = first_tuple(handle, tuple, parse);
 372                         while (i != CS_NO_MORE_ITEMS) {
 373                                 if (i != CS_SUCCESS)
 374                                         goto next_entry;
 375                                 if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
 376                                         link->conf.Vpp =
 377                                             cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
 378                                 if ((cf->io.nwin > 0) && (cf->io.win[0].len == size_table[s]) &&
 379                                             (cf->io.win[0].base != 0)) {
 380                                         link->conf.ConfigIndex = cf->index;
 381                                         link->io.BasePort1 = cf->io.win[0].base;
 382                                         link->io.IOAddrLines = (try == 0) ?
 383                                             16 : cf->io.flags & CISTPL_IO_LINES_MASK;
 384                                         i = pcmcia_request_io(link->handle, &link->io);
 385                                         if (i == CS_SUCCESS)
 386                                                 goto found_port;
 387                                 }
 388 next_entry:
 389                                 i = next_tuple(handle, tuple, parse);
 390                         }
 391                 }
 392         }
 393         /* Second pass: try to find an entry that isn't picky about
 394            its base address, then try to grab any standard serial port
 395            address, and finally try to get any free port. */
 396         i = first_tuple(handle, tuple, parse);
 397         while (i != CS_NO_MORE_ITEMS) {
 398                 if ((i == CS_SUCCESS) && (cf->io.nwin > 0) &&
 399                     ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
 400                         link->conf.ConfigIndex = cf->index;
 401                         for (j = 0; j < 5; j++) {
 402                                 link->io.BasePort1 = base[j];
 403                                 link->io.IOAddrLines = base[j] ? 16 : 3;
 404                                 i = pcmcia_request_io(link->handle, &link->io);
 405                                 if (i == CS_SUCCESS)
 406                                         goto found_port;
 407                         }
 408                 }
 409                 i = next_tuple(handle, tuple, parse);
 410         }
 411
 412       found_port:
 413         if (i != CS_SUCCESS) {
 414                 printk(KERN_NOTICE
 415                        "serial_cs: no usable port range found, giving up\n");
 416                 cs_error(link->handle, RequestIO, i);
 417                 kfree(cfg_mem);
 418                 return -1;
 419         }
 420
 421         i = pcmcia_request_irq(link->handle, &link->irq);
 422         if (i != CS_SUCCESS) {
 423                 cs_error(link->handle, RequestIRQ, i);
 424                 link->irq.AssignedIRQ = 0;
 425         }
 426         if (info->multi && (info->manfid == MANFID_3COM))
 427                 link->conf.ConfigIndex &= ~(0x08);
 428         i = pcmcia_request_configuration(link->handle, &link->conf);
 429         if (i != CS_SUCCESS) {
 430                 cs_error(link->handle, RequestConfiguration, i);
 431                 kfree(cfg_mem);
 432                 return -1;
 433         }
 434         kfree(cfg_mem);
 435         return setup_serial(handle, info, link->io.BasePort1, link->irq.AssignedIRQ);
 436 }
 437
 438 static int multi_config(dev_link_t * link)
 439 {
 440         client_handle_t handle = link->handle;
 441         struct serial_info *info = link->priv;
 442         struct serial_cfg_mem *cfg_mem;
 443         tuple_t *tuple;
 444         u_char *buf;
 445         cisparse_t *parse;
 446         cistpl_cftable_entry_t *cf;
 447         int i, rc, base2 = 0;
 448
 449         cfg_mem = kmalloc(sizeof(struct serial_cfg_mem), GFP_KERNEL);
 450         if (!cfg_mem)
 451                 return -1;
 452         tuple = &cfg_mem->tuple;
 453         parse = &cfg_mem->parse;
 454         cf = &parse->cftable_entry;
 455         buf = cfg_mem->buf;
 456
 457         tuple->TupleData = (cisdata_t *) buf;
 458         tuple->TupleOffset = 0;
 459         tuple->TupleDataMax = 255;
 460         tuple->Attributes = 0;
 461         tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
 462
 463         /* First, look for a generic full-sized window */
 464         link->io.NumPorts1 = info->multi * 8;
 465         i = first_tuple(handle, tuple, parse);
 466         while (i != CS_NO_MORE_ITEMS) {
 467                 /* The quad port cards have bad CIS's, so just look for a
 468                    window larger than 8 ports and assume it will be right */
 469                 if ((i == CS_SUCCESS) && (cf->io.nwin == 1) &&
 470                     (cf->io.win[0].len > 8)) {
 471                         link->conf.ConfigIndex = cf->index;
 472                         link->io.BasePort1 = cf->io.win[0].base;
 473                         link->io.IOAddrLines =
 474                             cf->io.flags & CISTPL_IO_LINES_MASK;
 475                         i = pcmcia_request_io(link->handle, &link->io);
 476                         base2 = link->io.BasePort1 + 8;
 477                         if (i == CS_SUCCESS)
 478                                 break;
 479                 }
 480                 i = next_tuple(handle, tuple, parse);
 481         }
 482
 483         /* If that didn't work, look for two windows */
 484         if (i != CS_SUCCESS) {
 485                 link->io.NumPorts1 = link->io.NumPorts2 = 8;
 486                 info->multi = 2;
 487                 i = first_tuple(handle, tuple, parse);
 488                 while (i != CS_NO_MORE_ITEMS) {
 489                         if ((i == CS_SUCCESS) && (cf->io.nwin == 2)) {
 490                                 link->conf.ConfigIndex = cf->index;
 491                                 link->io.BasePort1 = cf->io.win[0].base;
 492                                 link->io.BasePort2 = cf->io.win[1].base;
 493                                 link->io.IOAddrLines =
 494                                     cf->io.flags & CISTPL_IO_LINES_MASK;
 495                                 i = pcmcia_request_io(link->handle, &link->io);
 496                                 base2 = link->io.BasePort2;
 497                                 if (i == CS_SUCCESS)
 498                                         break;
 499                         }
 500                         i = next_tuple(handle, tuple, parse);
 501                 }
 502         }
 503
 504         if (i != CS_SUCCESS) {
 505                 cs_error(link->handle, RequestIO, i);
 506                 rc = -1;
 507                 goto free_cfg_mem;
 508         }
 509
 510         i = pcmcia_request_irq(link->handle, &link->irq);
 511         if (i != CS_SUCCESS) {
 512                 printk(KERN_NOTICE
 513                        "serial_cs: no usable port range found, giving up\n");
 514                 cs_error(link->handle, RequestIRQ, i);
 515                 link->irq.AssignedIRQ = 0;
 516         }
 517         /* Socket Dual IO: this enables irq's for second port */
 518         if (info->multi && (info->manfid == MANFID_SOCKET)) {
 519                 link->conf.Present |= PRESENT_EXT_STATUS;
 520                 link->conf.ExtStatus = ESR_REQ_ATTN_ENA;
 521         }
 522         i = pcmcia_request_configuration(link->handle, &link->conf);
 523         if (i != CS_SUCCESS) {
 524                 cs_error(link->handle, RequestConfiguration, i);
 525                 rc = -1;
 526                 goto free_cfg_mem;
 527         }
 528
 529         /* The Oxford Semiconductor OXCF950 cards are in fact single-port:
 530            8 registers are for the UART, the others are extra registers */
 531         if (info->manfid == MANFID_OXSEMI) {
 532                 if (cf->index == 1 || cf->index == 3) {
 533                         setup_serial(handle, info, base2, link->irq.AssignedIRQ);
 534                         outb(12, link->io.BasePort1 + 1);
 535                 } else {
 536                         setup_serial(handle, info, link->io.BasePort1, link->irq.AssignedIRQ);
 537                         outb(12, base2 + 1);
 538                 }
 539                 rc = 0;
 540                 goto free_cfg_mem;
 541         }
 542
 543         setup_serial(handle, info, link->io.BasePort1, link->irq.AssignedIRQ);
 544         /* The Nokia cards are not really multiport cards */
 545         if (info->manfid == MANFID_NOKIA) {
 546                 rc = 0;
 547                 goto free_cfg_mem;
 548         }
 549         for (i = 0; i < info->multi - 1; i++)
 550                 setup_serial(handle, info, base2 + (8 * i),
 551                                 link->irq.AssignedIRQ);
 552         rc = 0;
 553 free_cfg_mem:
 554         kfree(cfg_mem);
 555         return rc;
 556 }
 557
 558 /*======================================================================
 559
 560     serial_config() is scheduled to run after a CARD_INSERTION event
 561     is received, to configure the PCMCIA socket, and to make the
 562     serial device available to the system.
 563
 564 ======================================================================*/
 565
 566 void serial_config(dev_link_t * link)
 567 {
 568         client_handle_t handle = link->handle;
 569         struct serial_info *info = link->priv;
 570         struct serial_cfg_mem *cfg_mem;
 571         tuple_t *tuple;
 572         u_char *buf;
 573         cisparse_t *parse;
 574         cistpl_cftable_entry_t *cf;
 575         int i, last_ret, last_fn;
 576
 577         DEBUG(0, "serial_config(0x%p)\n", link);
 578
 579         cfg_mem = kmalloc(sizeof(struct serial_cfg_mem), GFP_KERNEL);
 580         if (!cfg_mem)
 581                 goto failed;
 582
 583         tuple = &cfg_mem->tuple;
 584         parse = &cfg_mem->parse;
 585         cf = &parse->cftable_entry;
 586         buf = cfg_mem->buf;
 587
 588         tuple->TupleData = (cisdata_t *) buf;
 589         tuple->TupleOffset = 0;
 590         tuple->TupleDataMax = 255;
 591         tuple->Attributes = 0;
 592         /* Get configuration register information */
 593         tuple->DesiredTuple = CISTPL_CONFIG;
 594         last_ret = first_tuple(handle, tuple, parse);
 595         if (last_ret != CS_SUCCESS) {
 596                 last_fn = ParseTuple;
 597                 goto cs_failed;
 598         }
 599         link->conf.ConfigBase = parse->config.base;
 600         link->conf.Present = parse->config.rmask[0];
 601
 602         /* Configure card */
 603         link->state |= DEV_CONFIG;
 604
 605         /* Is this a compliant multifunction card? */
 606         tuple->DesiredTuple = CISTPL_LONGLINK_MFC;
 607         tuple->Attributes = TUPLE_RETURN_COMMON | TUPLE_RETURN_LINK;
 608         info->multi = (first_tuple(handle, tuple, parse) == CS_SUCCESS);
 609
 610         /* Is this a multiport card? */
 611         tuple->DesiredTuple = CISTPL_MANFID;
 612         if (first_tuple(handle, tuple, parse) == CS_SUCCESS) {
 613                 info->manfid = parse->manfid.manf;
 614                 for (i = 0; i < MULTI_COUNT; i++)
 615                         if ((info->manfid == multi_id[i].manfid) &&
 616                             (parse->manfid.card == multi_id[i].prodid))
 617                                 break;
 618                 if (i < MULTI_COUNT)
 619                         info->multi = multi_id[i].multi;
 620         }
 621
 622         /* Another check for dual-serial cards: look for either serial or
 623            multifunction cards that ask for appropriate IO port ranges */
 624         tuple->DesiredTuple = CISTPL_FUNCID;
 625         if ((info->multi == 0) &&
 626             ((first_tuple(handle, tuple, parse) != CS_SUCCESS) ||
 627              (parse->funcid.func == CISTPL_FUNCID_MULTI) ||
 628              (parse->funcid.func == CISTPL_FUNCID_SERIAL))) {
 629                 tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
 630                 if (first_tuple(handle, tuple, parse) == CS_SUCCESS) {
 631                         if ((cf->io.nwin == 1) && (cf->io.win[0].len % 8 == 0))
 632                                 info->multi = cf->io.win[0].len >> 3;
 633                         if ((cf->io.nwin == 2) && (cf->io.win[0].len == 8) &&
 634                             (cf->io.win[1].len == 8))
 635                                 info->multi = 2;
 636                 }
 637         }
 638
 639         if (info->multi > 1)
 640                 multi_config(link);
 641         else
 642                 simple_config(link);
 643
 644         if (info->ndev == 0)
 645                 goto failed;
 646
 647         if (info->manfid == MANFID_IBM) {
 648                 conf_reg_t reg = { 0, CS_READ, 0x800, 0 };
 649                 last_ret = pcmcia_access_configuration_register(link->handle, &reg);
 650                 if (last_ret) {
 651                         last_fn = AccessConfigurationRegister;
 652                         goto cs_failed;
 653                 }
 654                 reg.Action = CS_WRITE;
 655                 reg.Value = reg.Value | 1;
 656                 last_ret = pcmcia_access_configuration_register(link->handle, &reg);
 657                 if (last_ret) {
 658                         last_fn = AccessConfigurationRegister;
 659                         goto cs_failed;
 660                 }
 661         }
 662
 663         link->dev = &info->node[0];
 664         link->state &= ~DEV_CONFIG_PENDING;
 665         kfree(cfg_mem);
 666         return;
 667
 668  cs_failed:
 669         cs_error(link->handle, last_fn, last_ret);
 670  failed:
 671         serial_remove(link);
 672         link->state &= ~DEV_CONFIG_PENDING;
 673         kfree(cfg_mem);
 674 }
 675
 676 static struct pcmcia_device_id serial_ids[] = {
 677         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0057, 0x0021),
 678         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0089, 0x110a),
 679         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0104, 0x000a),
 680         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0105, 0xea15),
 681         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0109, 0x0501),
 682         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0138, 0x110a),
 683         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0140, 0x000a),
 684         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0143, 0x3341),
 685         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0143, 0xc0ab),
 686         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x016c, 0x0081),
 687         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x021b, 0x0101),
 688         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x08a1, 0xc0ab),
 689         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0105, 0x0d0a),
 690         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0105, 0x0e0a),
 691         PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "CC/XJEM3288", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x04cd2988, 0x46a52d63),
 692         PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "CC/XJEM3336", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x0143b773, 0x46a52d63),
 693         PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "EM1144T", "PCMCIA MODEM", 0xf510db04, 0x856d66c8, 0xbd6c43ef),
 694         PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "XJEM1144/CCEM1144", "PCMCIA MODEM", 0xf510db04, 0x52d21e1e, 0xbd6c43ef),
 695         PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "CEM28", 0x2e3ee845, 0x0ea978ea),
 696         PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "CEM33", 0x2e3ee845, 0x80609023),
 697         PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "CEM56", 0x2e3ee845, 0xa650c32a),
 698         PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "REM10", 0x2e3ee845, 0x76df1d29),
 699         PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "XEM5600", 0x2e3ee845, 0xf1403719),
 700         PCMCIA_PFC_DEVICE_PROD_ID12(1, "AnyCom", "Fast Ethernet + 56K COMBO", 0x578ba6e7, 0xb0ac62c4),
 701         PCMCIA_PFC_DEVICE_PROD_ID12(1, "D-Link", "DME336T", 0x1a424a1c, 0xb23897ff),
 702         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Gateway 2000", "XJEM3336", 0xdd9989be, 0x662c394c),
 703         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Grey Cell", "GCS3000", 0x2a151fac, 0x48b932ae),
 704         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Linksys", "EtherFast 10&100 + 56K PC Card (PCMLM56)", 0x0733cc81, 0xb3765033),
 705         PCMCIA_PFC_DEVICE_PROD_ID12(1, "LINKSYS", "PCMLM336", 0xf7cb0b07, 0x7a821b58),
 706         PCMCIA_PFC_DEVICE_PROD_ID12(1, "MEGAHERTZ", "XJEM1144/CCEM1144", 0xf510db04, 0x52d21e1e),
 707         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Ositech", "Trumpcard:Jack of Diamonds Modem+Ethernet", 0xc2f80cd, 0x656947b9),
 708         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Ositech", "Trumpcard:Jack of Hearts Modem+Ethernet", 0xc2f80cd, 0xdc9ba5ed),
 709         PCMCIA_PFC_DEVICE_PROD_ID12(1, "PCMCIAs", "ComboCard", 0xdcfe12d3, 0xcd8906cc),
 710         PCMCIA_PFC_DEVICE_PROD_ID12(1, "PCMCIAs", "LanModem", 0xdcfe12d3, 0xc67c648f),
 711         PCMCIA_PFC_DEVICE_PROD_ID12(1, "TDK", "GlobalNetworker 3410/3412", 0x1eae9475, 0xd9a93bed),
 712         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Xircom", "CreditCard Ethernet+Modem II", 0x2e3ee845, 0xeca401bf),
 713         PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x0104, 0x0070),
 714         PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x0101, 0x0562),
 715         PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x0104, 0x0070),
 716         PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x016c, 0x0020),
 717         PCMCIA_MFC_DEVICE_PROD_ID123(1, "APEX DATA", "MULTICARD", "ETHERNET-MODEM", 0x11c2da09, 0x7289dc5d, 0xaad95e1f),
 718         PCMCIA_MFC_DEVICE_PROD_ID12(1, "IBM", "Home and Away 28.8 PC Card       ", 0xb569a6e5, 0x5bd4ff2c),
 719         PCMCIA_MFC_DEVICE_PROD_ID12(1, "IBM", "Home and Away Credit Card Adapter", 0xb569a6e5, 0x4bdf15c3),
 720         PCMCIA_MFC_DEVICE_PROD_ID12(1, "IBM", "w95 Home and Away Credit Card ", 0xb569a6e5, 0xae911c15),
 721         PCMCIA_MFC_DEVICE_PROD_ID1(1, "Motorola MARQUIS", 0xf03e4e77),
 722         PCMCIA_MFC_DEVICE_PROD_ID2(1, "FAX/Modem/Ethernet Combo Card ", 0x1ed59302),
 723         PCMCIA_DEVICE_MANF_CARD(0x0089, 0x0301),
 724         PCMCIA_DEVICE_MANF_CARD(0x00a4, 0x0276),
 725         PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0039),
 726         PCMCIA_DEVICE_MANF_CARD(0x0104, 0x0006),
 727         PCMCIA_DEVICE_MANF_CARD(0x0105, 0x410a),
 728         PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0d50),
 729         PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0d51),
 730         PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0d52),
 731         PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0d53),
 732         PCMCIA_DEVICE_MANF_CARD(0x010b, 0xd180),
 733         PCMCIA_DEVICE_MANF_CARD(0x0137, 0x000e),
 734         PCMCIA_DEVICE_MANF_CARD(0x0137, 0x001b),
 735         PCMCIA_DEVICE_MANF_CARD(0x0137, 0x0025),
 736         PCMCIA_DEVICE_MANF_CARD(0x0137, 0x0045),
 737         PCMCIA_DEVICE_MANF_CARD(0x0137, 0x0052),
 738         PCMCIA_DEVICE_PROD_ID134("ADV", "TECH", "COMpad-32/85", 0x67459937, 0x916d02ba, 0x8fbe92ae),
 739         PCMCIA_DEVICE_PROD_ID124("GATEWAY2000", "CC3144", "PCMCIA MODEM", 0x506bccae, 0xcb3685f1, 0xbd6c43ef),
 740         PCMCIA_DEVICE_PROD_ID14("MEGAHERTZ", "PCMCIA MODEM", 0xf510db04, 0xbd6c43ef),
 741         PCMCIA_DEVICE_PROD_ID124("TOSHIBA", "T144PF", "PCMCIA MODEM", 0xb4585a1a, 0x7271409c, 0xbd6c43ef),
 742         PCMCIA_DEVICE_PROD_ID123("FUJITSU", "FC14F ", "MBH10213", 0x6ee5a3d8, 0x30ead12b, 0xb00f05a0),
 743         PCMCIA_DEVICE_PROD_ID123("Novatel Wireless", "Merlin UMTS Modem", "U630", 0x32607776, 0xd9e73b13, 0xe87332e),
 744         PCMCIA_DEVICE_PROD_ID13("MEGAHERTZ", "V.34 PCMCIA MODEM", 0xf510db04, 0xbb2cce4a),
 745         PCMCIA_DEVICE_PROD_ID12("Brain Boxes", "Bluetooth PC Card", 0xee138382, 0xd4ce9b02),
 746         PCMCIA_DEVICE_PROD_ID12("CIRRUS LOGIC", "FAX MODEM", 0xe625f451, 0xcecd6dfa),
 747         PCMCIA_DEVICE_PROD_ID12("COMPAQ", "PCMCIA 28800 FAX/DATA MODEM", 0xa3a3062c, 0x8cbd7c76),
 748         PCMCIA_DEVICE_PROD_ID12("COMPAQ", "PCMCIA 33600 FAX/DATA MODEM", 0xa3a3062c, 0x5a00ce95),
 749         PCMCIA_DEVICE_PROD_ID12("Computerboards, Inc.", "PCM-COM422", 0xd0b78f51, 0x7e2d49ed),
 750         PCMCIA_DEVICE_PROD_ID12("Dr. Neuhaus", "FURY CARD 14K4", 0x76942813, 0x8b96ce65),
 751         PCMCIA_DEVICE_PROD_ID12("Intelligent", "ANGIA FAX/MODEM", 0xb496e65e, 0xf31602a6),
 752         PCMCIA_DEVICE_PROD_ID12("Intel", "MODEM 2400+", 0x816cc815, 0x412729fb),
 753         PCMCIA_DEVICE_PROD_ID12("IOTech Inc ", "PCMCIA Dual RS-232 Serial Port Card", 0x3bd2d898, 0x92abc92f),
 754         PCMCIA_DEVICE_PROD_ID12("MACRONIX", "FAX/MODEM", 0x668388b3, 0x3f9bdf2f),
 755         PCMCIA_DEVICE_PROD_ID12("Multi-Tech", "MT1432LT", 0x5f73be51, 0x0b3e2383),
 756         PCMCIA_DEVICE_PROD_ID12("Multi-Tech", "MT2834LT", 0x5f73be51, 0x4cd7c09e),
 757         PCMCIA_DEVICE_PROD_ID12("OEM      ", "C288MX     ", 0xb572d360, 0xd2385b7a),
 758         PCMCIA_DEVICE_PROD_ID12("PCMCIA   ", "C336MX     ", 0x99bcafe9, 0xaa25bcab),
 759         PCMCIA_DEVICE_PROD_ID12("Quatech Inc", "PCMCIA Dual RS-232 Serial Port Card", 0xc4420b35, 0x92abc92f),
 760         PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "PCMCIA", "EN2218-LAN/MODEM", 0x281f1c5d, 0x570f348e, "PCMLM28.cis"),
 761         PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "PCMCIA", "UE2218-LAN/MODEM", 0x281f1c5d, 0x6fdcacee, "PCMLM28.cis"),
 762         PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "Psion Dacom", "Gold Card V34 Ethernet", 0xf5f025c2, 0x338e8155, "PCMLM28.cis"),
 763         PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "Psion Dacom", "Gold Card V34 Ethernet GSM", 0xf5f025c2, 0x4ae85d35, "PCMLM28.cis"),
 764         PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "LINKSYS", "PCMLM28", 0xf7cb0b07, 0x66881874, "PCMLM28.cis"),
 765         PCMCIA_MFC_DEVICE_CIS_PROD_ID12(1, "DAYNA COMMUNICATIONS", "LAN AND MODEM MULTIFUNCTION", 0x8fdf8f89, 0xdd5ed9e8, "DP83903.cis"),
 766         PCMCIA_MFC_DEVICE_CIS_PROD_ID4(1, "NSC MF LAN/Modem", 0x58fc6056, "DP83903.cis"),
 767         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x0556, "3CCFEM556.cis"),
 768         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0175, 0x0000, "DP83903.cis"),
 769         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x0035, "3CXEM556.cis"),
 770         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x003d, "3CXEM556.cis"),
 771         PCMCIA_DEVICE_CIS_MANF_CARD(0x0192, 0x0710, "SW_7xx_SER.cis"),  /* Sierra Wireless AC710/AC750 GPRS Network Adapter R1 */
 772         PCMCIA_DEVICE_CIS_MANF_CARD(0x0192, 0xa555, "SW_555_SER.cis"),  /* Sierra Aircard 555 CDMA 1xrtt Modem -- pre update */
 773         PCMCIA_DEVICE_CIS_MANF_CARD(0x013f, 0xa555, "SW_555_SER.cis"),  /* Sierra Aircard 555 CDMA 1xrtt Modem -- post update */
 774         PCMCIA_DEVICE_CIS_PROD_ID12("MultiTech", "PCMCIA 56K DataFax", 0x842047ee, 0xc2efcf03, "MT5634ZLX.cis"),
 775         PCMCIA_DEVICE_CIS_PROD_ID12("ADVANTECH", "COMpad-32/85B-4", 0x96913a85, 0xcec8f102, "COMpad4.cis"),
 776         PCMCIA_DEVICE_CIS_PROD_ID123("ADVANTECH", "COMpad-32/85", "1.0", 0x96913a85, 0x8fbe92ae, 0x0877b627, "COMpad2.cis"),
 777         PCMCIA_DEVICE_CIS_PROD_ID2("RS-COM 2P", 0xad20b156, "RS-COM-2P.cis"),
 778         /* too generic */
 779         /* PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x0160, 0x0002), */
 780         /* PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x0160, 0x0002), */
 781         PCMCIA_DEVICE_FUNC_ID(2),
 782         PCMCIA_DEVICE_NULL,
 783 };
 784 MODULE_DEVICE_TABLE(pcmcia, serial_ids);
 785
 786 static struct pcmcia_driver serial_cs_driver = {
 787         .owner          = THIS_MODULE,
 788         .drv            = {
 789                 .name   = "serial_cs",
 790         },
 791         .probe          = serial_probe,
 792         .remove         = serial_detach,
 793         .id_table       = serial_ids,
 794         .suspend        = serial_suspend,
 795         .resume         = serial_resume,
 796 };
 797
 798 static int __init init_serial_cs(void)
 799 {
 800         return pcmcia_register_driver(&serial_cs_driver);
 801 }
 802
 803 static void __exit exit_serial_cs(void)
 804 {
 805         pcmcia_unregister_driver(&serial_cs_driver);
 806 }
 807
 808 module_init(init_serial_cs);
 809 module_exit(exit_serial_cs);
 810
 811 MODULE_LICENSE("GPL");