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