drivers/serial/serial_cs.c

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