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