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