git.oblomov.eu 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 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(dev_link_t *);
 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 void serial_suspend(dev_link_t *link)
 163 {
 164         link->state |= DEV_SUSPEND;
 165
 166         if (link->state & DEV_CONFIG) {
 167                 struct serial_info *info = link->priv;
 168                 int i;
 169
 170                 for (i = 0; i < info->ndev; i++)
 171                         serial8250_suspend_port(info->line[i]);
 172
 173                 if (!info->slave)
 174                         pcmcia_release_configuration(link->handle);
 175         }
 176 }
 177
 178 static void serial_resume(dev_link_t *link)
 179 {
 180         link->state &= ~DEV_SUSPEND;
 181
 182         if (DEV_OK(link)) {
 183                 struct serial_info *info = link->priv;
 184                 int i;
 185
 186                 if (!info->slave)
 187                         pcmcia_request_configuration(link->handle, &link->conf);
 188
 189                 for (i = 0; i < info->ndev; i++)
 190                         serial8250_resume_port(info->line[i]);
 191         }
 192 }
 193
 194 /*======================================================================
 195
 196     serial_attach() creates an "instance" of the driver, allocating
 197     local data structures for one device.  The device is registered
 198     with Card Services.
 199
 200 ======================================================================*/
 201
 202 static dev_link_t *serial_attach(void)
 203 {
 204         struct serial_info *info;
 205         client_reg_t client_reg;
 206         dev_link_t *link;
 207         int ret;
 208
 209         DEBUG(0, "serial_attach()\n");
 210
 211         /* Create new serial device */
 212         info = kmalloc(sizeof (*info), GFP_KERNEL);
 213         if (!info)
 214                 return NULL;
 215         memset(info, 0, sizeof (*info));
 216         link = &info->link;
 217         link->priv = info;
 218
 219         link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
 220         link->io.NumPorts1 = 8;
 221         link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
 222         link->irq.IRQInfo1 = IRQ_LEVEL_ID;
 223         link->conf.Attributes = CONF_ENABLE_IRQ;
 224         if (do_sound) {
 225                 link->conf.Attributes |= CONF_ENABLE_SPKR;
 226                 link->conf.Status = CCSR_AUDIO_ENA;
 227         }
 228         link->conf.IntType = INT_MEMORY_AND_IO;
 229
 230         /* Register with Card Services */
 231         link->next = dev_list;
 232         dev_list = link;
 233         client_reg.dev_info = &dev_info;
 234         client_reg.Version = 0x0210;
 235         client_reg.event_callback_args.client_data = link;
 236         ret = pcmcia_register_client(&link->handle, &client_reg);
 237         if (ret != CS_SUCCESS) {
 238                 cs_error(link->handle, RegisterClient, ret);
 239                 serial_detach(link);
 240                 return NULL;
 241         }
 242
 243         return link;
 244 }
 245
 246 /*======================================================================
 247
 248     This deletes a driver "instance".  The device is de-registered
 249     with Card Services.  If it has been released, all local data
 250     structures are freed.  Otherwise, the structures will be freed
 251     when the device is released.
 252
 253 ======================================================================*/
 254
 255 static void serial_detach(dev_link_t * link)
 256 {
 257         struct serial_info *info = link->priv;
 258         dev_link_t **linkp;
 259         int ret;
 260
 261         DEBUG(0, "serial_detach(0x%p)\n", link);
 262
 263         /* Locate device structure */
 264         for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
 265                 if (*linkp == link)
 266                         break;
 267         if (*linkp == NULL)
 268                 return;
 269
 270         /*
 271          * Ensure any outstanding scheduled tasks are completed.
 272          */
 273         flush_scheduled_work();
 274
 275         /*
 276          * Ensure that the ports have been released.
 277          */
 278         serial_remove(link);
 279
 280         if (link->handle) {
 281                 ret = pcmcia_deregister_client(link->handle);
 282                 if (ret != CS_SUCCESS)
 283                         cs_error(link->handle, DeregisterClient, ret);
 284         }
 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 kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
 358         static 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         struct serial_info *info = link->priv;
 735
 736         DEBUG(1, "serial_event(0x%06x)\n", event);
 737
 738         switch (event) {
 739         case CS_EVENT_CARD_REMOVAL:
 740                 serial_remove(link);
 741                 break;
 742
 743         case CS_EVENT_CARD_INSERTION:
 744                 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
 745                 serial_config(link);
 746                 break;
 747
 748         case CS_EVENT_PM_SUSPEND:
 749                 serial_suspend(link);
 750                 break;
 751
 752         case CS_EVENT_RESET_PHYSICAL:
 753                 if ((link->state & DEV_CONFIG) && !info->slave)
 754                         pcmcia_release_configuration(link->handle);
 755                 break;
 756
 757         case CS_EVENT_PM_RESUME:
 758                 serial_resume(link);
 759                 break;
 760
 761         case CS_EVENT_CARD_RESET:
 762                 if (DEV_OK(link) && !info->slave)
 763                         pcmcia_request_configuration(link->handle, &link->conf);
 764                 break;
 765         }
 766         return 0;
 767 }
 768
 769 static struct pcmcia_device_id serial_ids[] = {
 770         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0057, 0x0021),
 771         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0089, 0x110a),
 772         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0104, 0x000a),
 773         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0105, 0xea15),
 774         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0109, 0x0501),
 775         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0138, 0x110a),
 776         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0140, 0x000a),
 777         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0143, 0x3341),
 778         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0143, 0xc0ab),
 779         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x016c, 0x0081),
 780         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x021b, 0x0101),
 781         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x08a1, 0xc0ab),
 782         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0105, 0x0d0a),
 783         PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0105, 0x0e0a),
 784         PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "CC/XJEM3288", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x04cd2988, 0x46a52d63),
 785         PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "CC/XJEM3336", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x0143b773, 0x46a52d63),
 786         PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "EM1144T", "PCMCIA MODEM", 0xf510db04, 0x856d66c8, 0xbd6c43ef),
 787         PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "XJEM1144/CCEM1144", "PCMCIA MODEM", 0xf510db04, 0x52d21e1e, 0xbd6c43ef),
 788         PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "CEM28", 0x2e3ee845, 0x0ea978ea),
 789         PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "CEM33", 0x2e3ee845, 0x80609023),
 790         PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "CEM56", 0x2e3ee845, 0xa650c32a),
 791         PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "REM10", 0x2e3ee845, 0x76df1d29),
 792         PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "XEM5600", 0x2e3ee845, 0xf1403719),
 793         PCMCIA_PFC_DEVICE_PROD_ID12(1, "AnyCom", "Fast Ethernet + 56K COMBO", 0x578ba6e7, 0xb0ac62c4),
 794         PCMCIA_PFC_DEVICE_PROD_ID12(1, "D-Link", "DME336T", 0x1a424a1c, 0xb23897ff),
 795         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Gateway 2000", "XJEM3336", 0xdd9989be, 0x662c394c),
 796         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Grey Cell", "GCS3000", 0x2a151fac, 0x48b932ae),
 797         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Linksys", "EtherFast 10&100 + 56K PC Card (PCMLM56)", 0x0733cc81, 0xb3765033),
 798         PCMCIA_PFC_DEVICE_PROD_ID12(1, "LINKSYS", "PCMLM336", 0xf7cb0b07, 0x7a821b58),
 799         PCMCIA_PFC_DEVICE_PROD_ID12(1, "MEGAHERTZ", "XJEM1144/CCEM1144", 0xf510db04, 0x52d21e1e),
 800         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Ositech", "Trumpcard:Jack of Diamonds Modem+Ethernet", 0xc2f80cd, 0x656947b9),
 801         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Ositech", "Trumpcard:Jack of Hearts Modem+Ethernet", 0xc2f80cd, 0xdc9ba5ed),
 802         PCMCIA_PFC_DEVICE_PROD_ID12(1, "PCMCIAs", "ComboCard", 0xdcfe12d3, 0xcd8906cc),
 803         PCMCIA_PFC_DEVICE_PROD_ID12(1, "PCMCIAs", "LanModem", 0xdcfe12d3, 0xc67c648f),
 804         PCMCIA_PFC_DEVICE_PROD_ID12(1, "TDK", "GlobalNetworker 3410/3412", 0x1eae9475, 0xd9a93bed),
 805         PCMCIA_PFC_DEVICE_PROD_ID12(1, "Xircom", "CreditCard Ethernet+Modem II", 0x2e3ee845, 0xeca401bf),
 806         PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x0104, 0x0070),
 807         PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x0101, 0x0562),
 808         PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x0104, 0x0070),
 809         PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x016c, 0x0020),
 810         PCMCIA_MFC_DEVICE_PROD_ID123(1, "APEX DATA", "MULTICARD", "ETHERNET-MODEM", 0x11c2da09, 0x7289dc5d, 0xaad95e1f),
 811         PCMCIA_MFC_DEVICE_PROD_ID12(1, "IBM", "Home and Away 28.8 PC Card       ", 0xb569a6e5, 0x5bd4ff2c),
 812         PCMCIA_MFC_DEVICE_PROD_ID12(1, "IBM", "Home and Away Credit Card Adapter", 0xb569a6e5, 0x4bdf15c3),
 813         PCMCIA_MFC_DEVICE_PROD_ID12(1, "IBM", "w95 Home and Away Credit Card ", 0xb569a6e5, 0xae911c15),
 814         PCMCIA_MFC_DEVICE_PROD_ID1(1, "Motorola MARQUIS", 0xf03e4e77),
 815         PCMCIA_MFC_DEVICE_PROD_ID2(1, "FAX/Modem/Ethernet Combo Card ", 0x1ed59302),
 816         PCMCIA_DEVICE_MANF_CARD(0x0089, 0x0301),
 817         PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0039),
 818         PCMCIA_DEVICE_MANF_CARD(0x0104, 0x0006),
 819         PCMCIA_DEVICE_MANF_CARD(0x0105, 0x410a),
 820         PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0d50),
 821         PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0d51),
 822         PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0d52),
 823         PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0d53),
 824         PCMCIA_DEVICE_MANF_CARD(0x010b, 0xd180),
 825         PCMCIA_DEVICE_MANF_CARD(0x0137, 0x000e),
 826         PCMCIA_DEVICE_MANF_CARD(0x0137, 0x001b),
 827         PCMCIA_DEVICE_MANF_CARD(0x0137, 0x0025),
 828         PCMCIA_DEVICE_MANF_CARD(0x0137, 0x0045),
 829         PCMCIA_DEVICE_MANF_CARD(0x0137, 0x0052),
 830         PCMCIA_DEVICE_PROD_ID134("ADV", "TECH", "COMpad-32/85", 0x67459937, 0x916d02ba, 0x8fbe92ae),
 831         PCMCIA_DEVICE_PROD_ID124("GATEWAY2000", "CC3144", "PCMCIA MODEM", 0x506bccae, 0xcb3685f1, 0xbd6c43ef),
 832         PCMCIA_DEVICE_PROD_ID14("MEGAHERTZ", "PCMCIA MODEM", 0xf510db04, 0xbd6c43ef),
 833         PCMCIA_DEVICE_PROD_ID124("TOSHIBA", "T144PF", "PCMCIA MODEM", 0xb4585a1a, 0x7271409c, 0xbd6c43ef),
 834         PCMCIA_DEVICE_PROD_ID123("FUJITSU", "FC14F ", "MBH10213", 0x6ee5a3d8, 0x30ead12b, 0xb00f05a0),
 835         PCMCIA_DEVICE_PROD_ID13("MEGAHERTZ", "V.34 PCMCIA MODEM", 0xf510db04, 0xbb2cce4a),
 836         PCMCIA_DEVICE_PROD_ID12("Brain Boxes", "Bluetooth PC Card", 0xee138382, 0xd4ce9b02),
 837         PCMCIA_DEVICE_PROD_ID12("CIRRUS LOGIC", "FAX MODEM", 0xe625f451, 0xcecd6dfa),
 838         PCMCIA_DEVICE_PROD_ID12("COMPAQ", "PCMCIA 28800 FAX/DATA MODEM", 0xa3a3062c, 0x8cbd7c76),
 839         PCMCIA_DEVICE_PROD_ID12("COMPAQ", "PCMCIA 33600 FAX/DATA MODEM", 0xa3a3062c, 0x5a00ce95),
 840         PCMCIA_DEVICE_PROD_ID12("Computerboards, Inc.", "PCM-COM422", 0xd0b78f51, 0x7e2d49ed),
 841         PCMCIA_DEVICE_PROD_ID12("Dr. Neuhaus", "FURY CARD 14K4", 0x76942813, 0x8b96ce65),
 842         PCMCIA_DEVICE_PROD_ID12("Intelligent", "ANGIA FAX/MODEM", 0xb496e65e, 0xf31602a6),
 843         PCMCIA_DEVICE_PROD_ID12("Intel", "MODEM 2400+", 0x816cc815, 0x412729fb),
 844         PCMCIA_DEVICE_PROD_ID12("IOTech Inc ", "PCMCIA Dual RS-232 Serial Port Card", 0x3bd2d898, 0x92abc92f),
 845         PCMCIA_DEVICE_PROD_ID12("MACRONIX", "FAX/MODEM", 0x668388b3, 0x3f9bdf2f),
 846         PCMCIA_DEVICE_PROD_ID12("Multi-Tech", "MT1432LT", 0x5f73be51, 0x0b3e2383),
 847         PCMCIA_DEVICE_PROD_ID12("Multi-Tech", "MT2834LT", 0x5f73be51, 0x4cd7c09e),
 848         PCMCIA_DEVICE_PROD_ID12("OEM      ", "C288MX     ", 0xb572d360, 0xd2385b7a),
 849         PCMCIA_DEVICE_PROD_ID12("PCMCIA   ", "C336MX     ", 0x99bcafe9, 0xaa25bcab),
 850         PCMCIA_DEVICE_PROD_ID12("Quatech Inc", "PCMCIA Dual RS-232 Serial Port Card", 0xc4420b35, 0x92abc92f),
 851         PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "PCMCIA", "EN2218-LAN/MODEM", 0x281f1c5d, 0x570f348e, "PCMLM28.cis"),
 852         PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "PCMCIA", "UE2218-LAN/MODEM", 0x281f1c5d, 0x6fdcacee, "PCMLM28.cis"),
 853         PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "Psion Dacom", "Gold Card V34 Ethernet", 0xf5f025c2, 0x338e8155, "PCMLM28.cis"),
 854         PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "Psion Dacom", "Gold Card V34 Ethernet GSM", 0xf5f025c2, 0x4ae85d35, "PCMLM28.cis"),
 855         PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "LINKSYS", "PCMLM28", 0xf7cb0b07, 0x66881874, "PCMLM28.cis"),
 856         PCMCIA_MFC_DEVICE_CIS_PROD_ID12(1, "DAYNA COMMUNICATIONS", "LAN AND MODEM MULTIFUNCTION", 0x8fdf8f89, 0xdd5ed9e8, "DP83903.cis"),
 857         PCMCIA_MFC_DEVICE_CIS_PROD_ID4(1, "NSC MF LAN/Modem", 0x58fc6056, "DP83903.cis"),
 858         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x0556, "3CCFEM556.cis"),
 859         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0175, 0x0000, "DP83903.cis"),
 860         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x0035, "3CXEM556.cis"),
 861         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x003d, "3CXEM556.cis"),
 862         PCMCIA_DEVICE_CIS_PROD_ID12("MultiTech", "PCMCIA 56K DataFax", 0x842047ee, 0xc2efcf03, "MT5634ZLX.cis"),
 863         PCMCIA_DEVICE_CIS_PROD_ID12("ADVANTECH", "COMpad-32/85B-4", 0x96913a85, 0xcec8f102, "COMpad4.cis"),
 864         PCMCIA_DEVICE_CIS_PROD_ID123("ADVANTECH", "COMpad-32/85", "1.0", 0x96913a85, 0x8fbe92ae, 0x0877b627, "COMpad2.cis"),
 865         PCMCIA_DEVICE_CIS_PROD_ID2("RS-COM 2P", 0xad20b156, "RS-COM-2P.cis"),
 866         /* too generic */
 867         /* PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x0160, 0x0002), */
 868         /* PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x0160, 0x0002), */
 869         PCMCIA_DEVICE_FUNC_ID(2),
 870         PCMCIA_DEVICE_NULL,
 871 };
 872 MODULE_DEVICE_TABLE(pcmcia, serial_ids);
 873
 874 static struct pcmcia_driver serial_cs_driver = {
 875         .owner          = THIS_MODULE,
 876         .drv            = {
 877                 .name   = "serial_cs",
 878         },
 879         .attach         = serial_attach,
 880         .event          = serial_event,
 881         .detach         = serial_detach,
 882         .id_table       = serial_ids,
 883 };
 884
 885 static int __init init_serial_cs(void)
 886 {
 887         return pcmcia_register_driver(&serial_cs_driver);
 888 }
 889
 890 static void __exit exit_serial_cs(void)
 891 {
 892         pcmcia_unregister_driver(&serial_cs_driver);
 893         BUG_ON(dev_list != NULL);
 894 }
 895
 896 module_init(init_serial_cs);
 897 module_exit(exit_serial_cs);
 898
 899 MODULE_LICENSE("GPL");