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