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