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