git.oblomov.eu Git - 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/major.h>
  45 #include <asm/io.h>
  46 #include <asm/system.h>
  47
  48 #include <pcmcia/version.h>
  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 multi_id {
  84         u_short manfid;
  85         u_short prodid;
  86         int multi;              /* 1 = multifunction, > 1 = # ports */
  87 };
  88
  89 static struct multi_id multi_id[] = {
  90         { MANFID_OMEGA,   PRODID_OMEGA_QSP_100,         4 },
  91         { MANFID_QUATECH, PRODID_QUATECH_DUAL_RS232,    2 },
  92         { MANFID_QUATECH, PRODID_QUATECH_DUAL_RS232_D1, 2 },
  93         { MANFID_QUATECH, PRODID_QUATECH_QUAD_RS232,    4 },
  94         { MANFID_SOCKET,  PRODID_SOCKET_DUAL_RS232,     2 },
  95         { MANFID_INTEL,   PRODID_INTEL_DUAL_RS232,      2 },
  96         { MANFID_NATINST, PRODID_NATINST_QUAD_RS232,    4 }
  97 };
  98 #define MULTI_COUNT (sizeof(multi_id)/sizeof(struct multi_id))
  99
 100 struct serial_info {
 101         dev_link_t              link;
 102         int                     ndev;
 103         int                     multi;
 104         int                     slave;
 105         int                     manfid;
 106         dev_node_t              node[4];
 107         int                     line[4];
 108 };
 109
 110 struct serial_cfg_mem {
 111         tuple_t tuple;
 112         cisparse_t parse;
 113         u_char buf[256];
 114 };
 115
 116
 117 static void serial_config(dev_link_t * link);
 118 static int serial_event(event_t event, int priority,
 119                         event_callback_args_t * args);
 120
 121 static dev_info_t dev_info = "serial_cs";
 122
 123 static dev_link_t *serial_attach(void);
 124 static void serial_detach(dev_link_t *);
 125
 126 static dev_link_t *dev_list = NULL;
 127
 128 /*======================================================================
 129
 130     After a card is removed, serial_remove() will unregister
 131     the serial device(s), and release the PCMCIA configuration.
 132
 133 ======================================================================*/
 134
 135 static void serial_remove(dev_link_t *link)
 136 {
 137         struct serial_info *info = link->priv;
 138         int i;
 139
 140         link->state &= ~DEV_PRESENT;
 141
 142         DEBUG(0, "serial_release(0x%p)\n", link);
 143
 144         /*
 145          * Recheck to see if the device is still configured.
 146          */
 147         if (info->link.state & DEV_CONFIG) {
 148                 for (i = 0; i < info->ndev; i++)
 149                         serial8250_unregister_port(info->line[i]);
 150
 151                 info->link.dev = NULL;
 152
 153                 if (!info->slave) {
 154                         pcmcia_release_configuration(info->link.handle);
 155                         pcmcia_release_io(info->link.handle, &info->link.io);
 156                         pcmcia_release_irq(info->link.handle, &info->link.irq);
 157                 }
 158
 159                 info->link.state &= ~DEV_CONFIG;
 160         }
 161 }
 162
 163 static void serial_suspend(dev_link_t *link)
 164 {
 165         link->state |= DEV_SUSPEND;
 166
 167         if (link->state & DEV_CONFIG) {
 168                 struct serial_info *info = link->priv;
 169                 int i;
 170
 171                 for (i = 0; i < info->ndev; i++)
 172                         serial8250_suspend_port(info->line[i]);
 173
 174                 if (!info->slave)
 175                         pcmcia_release_configuration(link->handle);
 176         }
 177 }
 178
 179 static void serial_resume(dev_link_t *link)
 180 {
 181         link->state &= ~DEV_SUSPEND;
 182
 183         if (DEV_OK(link)) {
 184                 struct serial_info *info = link->priv;
 185                 int i;
 186
 187                 if (!info->slave)
 188                         pcmcia_request_configuration(link->handle, &link->conf);
 189
 190                 for (i = 0; i < info->ndev; i++)
 191                         serial8250_resume_port(info->line[i]);
 192         }
 193 }
 194
 195 /*======================================================================
 196
 197     serial_attach() creates an "instance" of the driver, allocating
 198     local data structures for one device.  The device is registered
 199     with Card Services.
 200
 201 ======================================================================*/
 202
 203 static dev_link_t *serial_attach(void)
 204 {
 205         struct serial_info *info;
 206         client_reg_t client_reg;
 207         dev_link_t *link;
 208         int ret;
 209
 210         DEBUG(0, "serial_attach()\n");
 211
 212         /* Create new serial device */
 213         info = kmalloc(sizeof (*info), GFP_KERNEL);
 214         if (!info)
 215                 return NULL;
 216         memset(info, 0, sizeof (*info));
 217         link = &info->link;
 218         link->priv = info;
 219
 220         link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
 221         link->io.NumPorts1 = 8;
 222         link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
 223         link->irq.IRQInfo1 = IRQ_LEVEL_ID;
 224         link->conf.Attributes = CONF_ENABLE_IRQ;
 225         if (do_sound) {
 226                 link->conf.Attributes |= CONF_ENABLE_SPKR;
 227                 link->conf.Status = CCSR_AUDIO_ENA;
 228         }
 229         link->conf.IntType = INT_MEMORY_AND_IO;
 230
 231         /* Register with Card Services */
 232         link->next = dev_list;
 233         dev_list = link;
 234         client_reg.dev_info = &dev_info;
 235         client_reg.EventMask =
 236             CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL |
 237             CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET |
 238             CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME;
 239         client_reg.event_handler = &serial_event;
 240         client_reg.Version = 0x0210;
 241         client_reg.event_callback_args.client_data = link;
 242         ret = pcmcia_register_client(&link->handle, &client_reg);
 243         if (ret != CS_SUCCESS) {
 244                 cs_error(link->handle, RegisterClient, ret);
 245                 serial_detach(link);
 246                 return NULL;
 247         }
 248
 249         return link;
 250 }
 251
 252 /*======================================================================
 253
 254     This deletes a driver "instance".  The device is de-registered
 255     with Card Services.  If it has been released, all local data
 256     structures are freed.  Otherwise, the structures will be freed
 257     when the device is released.
 258
 259 ======================================================================*/
 260
 261 static void serial_detach(dev_link_t * link)
 262 {
 263         struct serial_info *info = link->priv;
 264         dev_link_t **linkp;
 265         int ret;
 266
 267         DEBUG(0, "serial_detach(0x%p)\n", link);
 268
 269         /* Locate device structure */
 270         for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
 271                 if (*linkp == link)
 272                         break;
 273         if (*linkp == NULL)
 274                 return;
 275
 276         /*
 277          * Ensure any outstanding scheduled tasks are completed.
 278          */
 279         flush_scheduled_work();
 280
 281         /*
 282          * Ensure that the ports have been released.
 283          */
 284         serial_remove(link);
 285
 286         if (link->handle) {
 287                 ret = pcmcia_deregister_client(link->handle);
 288                 if (ret != CS_SUCCESS)
 289                         cs_error(link->handle, DeregisterClient, ret);
 290         }
 291
 292         /* Unlink device structure, free bits */
 293         *linkp = link->next;
 294         kfree(info);
 295 }
 296
 297 /*====================================================================*/
 298
 299 static int setup_serial(client_handle_t handle, struct serial_info * info,
 300                         kio_addr_t iobase, int irq)
 301 {
 302         struct uart_port port;
 303         int line;
 304
 305         memset(&port, 0, sizeof (struct uart_port));
 306         port.iobase = iobase;
 307         port.irq = irq;
 308         port.flags = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST | UPF_SHARE_IRQ;
 309         port.uartclk = 1843200;
 310         port.dev = &handle_to_dev(handle);
 311         if (buggy_uart)
 312                 port.flags |= UPF_BUGGY_UART;
 313         line = serial8250_register_port(&port);
 314         if (line < 0) {
 315                 printk(KERN_NOTICE "serial_cs: serial8250_register_port() at "
 316                        "0x%04lx, irq %d failed\n", (u_long)iobase, irq);
 317                 return -EINVAL;
 318         }
 319
 320         info->line[info->ndev] = line;
 321         sprintf(info->node[info->ndev].dev_name, "ttyS%d", line);
 322         info->node[info->ndev].major = TTY_MAJOR;
 323         info->node[info->ndev].minor = 0x40 + line;
 324         if (info->ndev > 0)
 325                 info->node[info->ndev - 1].next = &info->node[info->ndev];
 326         info->ndev++;
 327
 328         return 0;
 329 }
 330
 331 /*====================================================================*/
 332
 333 static int
 334 first_tuple(client_handle_t handle, tuple_t * tuple, cisparse_t * parse)
 335 {
 336         int i;
 337         i = pcmcia_get_first_tuple(handle, tuple);
 338         if (i != CS_SUCCESS)
 339                 return CS_NO_MORE_ITEMS;
 340         i = pcmcia_get_tuple_data(handle, tuple);
 341         if (i != CS_SUCCESS)
 342                 return i;
 343         return pcmcia_parse_tuple(handle, tuple, parse);
 344 }
 345
 346 static int
 347 next_tuple(client_handle_t handle, tuple_t * tuple, cisparse_t * parse)
 348 {
 349         int i;
 350         i = pcmcia_get_next_tuple(handle, tuple);
 351         if (i != CS_SUCCESS)
 352                 return CS_NO_MORE_ITEMS;
 353         i = pcmcia_get_tuple_data(handle, tuple);
 354         if (i != CS_SUCCESS)
 355                 return i;
 356         return pcmcia_parse_tuple(handle, tuple, parse);
 357 }
 358
 359 /*====================================================================*/
 360
 361 static int simple_config(dev_link_t *link)
 362 {
 363         static kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
 364         static int size_table[2] = { 8, 16 };
 365         client_handle_t handle = link->handle;
 366         struct serial_info *info = link->priv;
 367         struct serial_cfg_mem *cfg_mem;
 368         tuple_t *tuple;
 369         u_char *buf;
 370         cisparse_t *parse;
 371         cistpl_cftable_entry_t *cf;
 372         config_info_t config;
 373         int i, j, try;
 374         int s;
 375
 376         cfg_mem = kmalloc(sizeof(struct serial_cfg_mem), GFP_KERNEL);
 377         if (!cfg_mem)
 378                 return -1;
 379
 380         tuple = &cfg_mem->tuple;
 381         parse = &cfg_mem->parse;
 382         cf = &parse->cftable_entry;
 383         buf = cfg_mem->buf;
 384
 385         /* If the card is already configured, look up the port and irq */
 386         i = pcmcia_get_configuration_info(handle, &config);
 387         if ((i == CS_SUCCESS) && (config.Attributes & CONF_VALID_CLIENT)) {
 388                 kio_addr_t port = 0;
 389                 if ((config.BasePort2 != 0) && (config.NumPorts2 == 8)) {
 390                         port = config.BasePort2;
 391                         info->slave = 1;
 392                 } else if ((info->manfid == MANFID_OSITECH) &&
 393                            (config.NumPorts1 == 0x40)) {
 394                         port = config.BasePort1 + 0x28;
 395                         info->slave = 1;
 396                 }
 397                 if (info->slave) {
 398                         kfree(cfg_mem);
 399                         return setup_serial(handle, info, port, config.AssignedIRQ);
 400                 }
 401         }
 402         link->conf.Vcc = config.Vcc;
 403
 404         /* First pass: look for a config entry that looks normal. */
 405         tuple->TupleData = (cisdata_t *) buf;
 406         tuple->TupleOffset = 0;
 407         tuple->TupleDataMax = 255;
 408         tuple->Attributes = 0;
 409         tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
 410         /* Two tries: without IO aliases, then with aliases */
 411         for (s = 0; s < 2; s++) {
 412                 for (try = 0; try < 2; try++) {
 413                         i = first_tuple(handle, tuple, parse);
 414                         while (i != CS_NO_MORE_ITEMS) {
 415                                 if (i != CS_SUCCESS)
 416                                         goto next_entry;
 417                                 if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
 418                                         link->conf.Vpp1 = link->conf.Vpp2 =
 419                                             cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
 420                                 if ((cf->io.nwin > 0) && (cf->io.win[0].len == size_table[s]) &&
 421                                             (cf->io.win[0].base != 0)) {
 422                                         link->conf.ConfigIndex = cf->index;
 423                                         link->io.BasePort1 = cf->io.win[0].base;
 424                                         link->io.IOAddrLines = (try == 0) ?
 425                                             16 : cf->io.flags & CISTPL_IO_LINES_MASK;
 426                                         i = pcmcia_request_io(link->handle, &link->io);
 427                                         if (i == CS_SUCCESS)
 428                                                 goto found_port;
 429                                 }
 430 next_entry:
 431                                 i = next_tuple(handle, tuple, parse);
 432                         }
 433                 }
 434         }
 435         /* Second pass: try to find an entry that isn't picky about
 436            its base address, then try to grab any standard serial port
 437            address, and finally try to get any free port. */
 438         i = first_tuple(handle, tuple, parse);
 439         while (i != CS_NO_MORE_ITEMS) {
 440                 if ((i == CS_SUCCESS) && (cf->io.nwin > 0) &&
 441                     ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
 442                         link->conf.ConfigIndex = cf->index;
 443                         for (j = 0; j < 5; j++) {
 444                                 link->io.BasePort1 = base[j];
 445                                 link->io.IOAddrLines = base[j] ? 16 : 3;
 446                                 i = pcmcia_request_io(link->handle, &link->io);
 447                                 if (i == CS_SUCCESS)
 448                                         goto found_port;
 449                         }
 450                 }
 451                 i = next_tuple(handle, tuple, parse);
 452         }
 453
 454       found_port:
 455         if (i != CS_SUCCESS) {
 456                 printk(KERN_NOTICE
 457                        "serial_cs: no usable port range found, giving up\n");
 458                 cs_error(link->handle, RequestIO, i);
 459                 kfree(cfg_mem);
 460                 return -1;
 461         }
 462
 463         i = pcmcia_request_irq(link->handle, &link->irq);
 464         if (i != CS_SUCCESS) {
 465                 cs_error(link->handle, RequestIRQ, i);
 466                 link->irq.AssignedIRQ = 0;
 467         }
 468         if (info->multi && (info->manfid == MANFID_3COM))
 469                 link->conf.ConfigIndex &= ~(0x08);
 470         i = pcmcia_request_configuration(link->handle, &link->conf);
 471         if (i != CS_SUCCESS) {
 472                 cs_error(link->handle, RequestConfiguration, i);
 473                 kfree(cfg_mem);
 474                 return -1;
 475         }
 476         kfree(cfg_mem);
 477         return setup_serial(handle, info, link->io.BasePort1, link->irq.AssignedIRQ);
 478 }
 479
 480 static int multi_config(dev_link_t * link)
 481 {
 482         client_handle_t handle = link->handle;
 483         struct serial_info *info = link->priv;
 484         struct serial_cfg_mem *cfg_mem;
 485         tuple_t *tuple;
 486         u_char *buf;
 487         cisparse_t *parse;
 488         cistpl_cftable_entry_t *cf;
 489         config_info_t config;
 490         int i, rc, base2 = 0;
 491
 492         cfg_mem = kmalloc(sizeof(struct serial_cfg_mem), GFP_KERNEL);
 493         if (!cfg_mem)
 494                 return -1;
 495         tuple = &cfg_mem->tuple;
 496         parse = &cfg_mem->parse;
 497         cf = &parse->cftable_entry;
 498         buf = cfg_mem->buf;
 499
 500         i = pcmcia_get_configuration_info(handle, &config);
 501         if (i != CS_SUCCESS) {
 502                 cs_error(handle, GetConfigurationInfo, i);
 503                 rc = -1;
 504                 goto free_cfg_mem;
 505         }
 506         link->conf.Vcc = config.Vcc;
 507
 508         tuple->TupleData = (cisdata_t *) buf;
 509         tuple->TupleOffset = 0;
 510         tuple->TupleDataMax = 255;
 511         tuple->Attributes = 0;
 512         tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
 513
 514         /* First, look for a generic full-sized window */
 515         link->io.NumPorts1 = info->multi * 8;
 516         i = first_tuple(handle, tuple, parse);
 517         while (i != CS_NO_MORE_ITEMS) {
 518                 /* The quad port cards have bad CIS's, so just look for a
 519                    window larger than 8 ports and assume it will be right */
 520                 if ((i == CS_SUCCESS) && (cf->io.nwin == 1) &&
 521                     (cf->io.win[0].len > 8)) {
 522                         link->conf.ConfigIndex = cf->index;
 523                         link->io.BasePort1 = cf->io.win[0].base;
 524                         link->io.IOAddrLines =
 525                             cf->io.flags & CISTPL_IO_LINES_MASK;
 526                         i = pcmcia_request_io(link->handle, &link->io);
 527                         base2 = link->io.BasePort1 + 8;
 528                         if (i == CS_SUCCESS)
 529                                 break;
 530                 }
 531                 i = next_tuple(handle, tuple, parse);
 532         }
 533
 534         /* If that didn't work, look for two windows */
 535         if (i != CS_SUCCESS) {
 536                 link->io.NumPorts1 = link->io.NumPorts2 = 8;
 537                 info->multi = 2;
 538                 i = first_tuple(handle, tuple, parse);
 539                 while (i != CS_NO_MORE_ITEMS) {
 540                         if ((i == CS_SUCCESS) && (cf->io.nwin == 2)) {
 541                                 link->conf.ConfigIndex = cf->index;
 542                                 link->io.BasePort1 = cf->io.win[0].base;
 543                                 link->io.BasePort2 = cf->io.win[1].base;
 544                                 link->io.IOAddrLines =
 545                                     cf->io.flags & CISTPL_IO_LINES_MASK;
 546                                 i = pcmcia_request_io(link->handle, &link->io);
 547                                 base2 = link->io.BasePort2;
 548                                 if (i == CS_SUCCESS)
 549                                         break;
 550                         }
 551                         i = next_tuple(handle, tuple, parse);
 552                 }
 553         }
 554
 555         if (i != CS_SUCCESS) {
 556                 cs_error(link->handle, RequestIO, i);
 557                 rc = -1;
 558                 goto free_cfg_mem;
 559         }
 560
 561         i = pcmcia_request_irq(link->handle, &link->irq);
 562         if (i != CS_SUCCESS) {
 563                 printk(KERN_NOTICE
 564                        "serial_cs: no usable port range found, giving up\n");
 565                 cs_error(link->handle, RequestIRQ, i);
 566                 link->irq.AssignedIRQ = 0;
 567         }
 568         /* Socket Dual IO: this enables irq's for second port */
 569         if (info->multi && (info->manfid == MANFID_SOCKET)) {
 570                 link->conf.Present |= PRESENT_EXT_STATUS;
 571                 link->conf.ExtStatus = ESR_REQ_ATTN_ENA;
 572         }
 573         i = pcmcia_request_configuration(link->handle, &link->conf);
 574         if (i != CS_SUCCESS) {
 575                 cs_error(link->handle, RequestConfiguration, i);
 576                 rc = -1;
 577                 goto free_cfg_mem;
 578         }
 579
 580         /* The Oxford Semiconductor OXCF950 cards are in fact single-port:
 581            8 registers are for the UART, the others are extra registers */
 582         if (info->manfid == MANFID_OXSEMI) {
 583                 if (cf->index == 1 || cf->index == 3) {
 584                         setup_serial(handle, info, base2, link->irq.AssignedIRQ);
 585                         outb(12, link->io.BasePort1 + 1);
 586                 } else {
 587                         setup_serial(handle, info, link->io.BasePort1, link->irq.AssignedIRQ);
 588                         outb(12, base2 + 1);
 589                 }
 590                 rc = 0;
 591                 goto free_cfg_mem;
 592         }
 593
 594         setup_serial(handle, info, link->io.BasePort1, link->irq.AssignedIRQ);
 595         /* The Nokia cards are not really multiport cards */
 596         if (info->manfid == MANFID_NOKIA) {
 597                 rc = 0;
 598                 goto free_cfg_mem;
 599         }
 600         for (i = 0; i < info->multi - 1; i++)
 601                 setup_serial(handle, info, base2 + (8 * i),
 602                                 link->irq.AssignedIRQ);
 603         rc = 0;
 604 free_cfg_mem:
 605         kfree(cfg_mem);
 606         return rc;
 607 }
 608
 609 /*======================================================================
 610
 611     serial_config() is scheduled to run after a CARD_INSERTION event
 612     is received, to configure the PCMCIA socket, and to make the
 613     serial device available to the system.
 614
 615 ======================================================================*/
 616
 617 void serial_config(dev_link_t * link)
 618 {
 619         client_handle_t handle = link->handle;
 620         struct serial_info *info = link->priv;
 621         struct serial_cfg_mem *cfg_mem;
 622         tuple_t *tuple;
 623         u_char *buf;
 624         cisparse_t *parse;
 625         cistpl_cftable_entry_t *cf;
 626         int i, last_ret, last_fn;
 627
 628         DEBUG(0, "serial_config(0x%p)\n", link);
 629
 630         cfg_mem = kmalloc(sizeof(struct serial_cfg_mem), GFP_KERNEL);
 631         if (!cfg_mem)
 632                 goto failed;
 633
 634         tuple = &cfg_mem->tuple;
 635         parse = &cfg_mem->parse;
 636         cf = &parse->cftable_entry;
 637         buf = cfg_mem->buf;
 638
 639         tuple->TupleData = (cisdata_t *) buf;
 640         tuple->TupleOffset = 0;
 641         tuple->TupleDataMax = 255;
 642         tuple->Attributes = 0;
 643         /* Get configuration register information */
 644         tuple->DesiredTuple = CISTPL_CONFIG;
 645         last_ret = first_tuple(handle, tuple, parse);
 646         if (last_ret != CS_SUCCESS) {
 647                 last_fn = ParseTuple;
 648                 goto cs_failed;
 649         }
 650         link->conf.ConfigBase = parse->config.base;
 651         link->conf.Present = parse->config.rmask[0];
 652
 653         /* Configure card */
 654         link->state |= DEV_CONFIG;
 655
 656         /* Is this a compliant multifunction card? */
 657         tuple->DesiredTuple = CISTPL_LONGLINK_MFC;
 658         tuple->Attributes = TUPLE_RETURN_COMMON | TUPLE_RETURN_LINK;
 659         info->multi = (first_tuple(handle, tuple, parse) == CS_SUCCESS);
 660
 661         /* Is this a multiport card? */
 662         tuple->DesiredTuple = CISTPL_MANFID;
 663         if (first_tuple(handle, tuple, parse) == CS_SUCCESS) {
 664                 info->manfid = parse->manfid.manf;
 665                 for (i = 0; i < MULTI_COUNT; i++)
 666                         if ((info->manfid == multi_id[i].manfid) &&
 667                             (parse->manfid.card == multi_id[i].prodid))
 668                                 break;
 669                 if (i < MULTI_COUNT)
 670                         info->multi = multi_id[i].multi;
 671         }
 672
 673         /* Another check for dual-serial cards: look for either serial or
 674            multifunction cards that ask for appropriate IO port ranges */
 675         tuple->DesiredTuple = CISTPL_FUNCID;
 676         if ((info->multi == 0) &&
 677             ((first_tuple(handle, tuple, parse) != CS_SUCCESS) ||
 678              (parse->funcid.func == CISTPL_FUNCID_MULTI) ||
 679              (parse->funcid.func == CISTPL_FUNCID_SERIAL))) {
 680                 tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
 681                 if (first_tuple(handle, tuple, parse) == CS_SUCCESS) {
 682                         if ((cf->io.nwin == 1) && (cf->io.win[0].len % 8 == 0))
 683                                 info->multi = cf->io.win[0].len >> 3;
 684                         if ((cf->io.nwin == 2) && (cf->io.win[0].len == 8) &&
 685                             (cf->io.win[1].len == 8))
 686                                 info->multi = 2;
 687                 }
 688         }
 689
 690         if (info->multi > 1)
 691                 multi_config(link);
 692         else
 693                 simple_config(link);
 694
 695         if (info->ndev == 0)
 696                 goto failed;
 697
 698         if (info->manfid == MANFID_IBM) {
 699                 conf_reg_t reg = { 0, CS_READ, 0x800, 0 };
 700                 last_ret = pcmcia_access_configuration_register(link->handle, &reg);
 701                 if (last_ret) {
 702                         last_fn = AccessConfigurationRegister;
 703                         goto cs_failed;
 704                 }
 705                 reg.Action = CS_WRITE;
 706                 reg.Value = reg.Value | 1;
 707                 last_ret = pcmcia_access_configuration_register(link->handle, &reg);
 708                 if (last_ret) {
 709                         last_fn = AccessConfigurationRegister;
 710                         goto cs_failed;
 711                 }
 712         }
 713
 714         link->dev = &info->node[0];
 715         link->state &= ~DEV_CONFIG_PENDING;
 716         kfree(cfg_mem);
 717         return;
 718
 719  cs_failed:
 720         cs_error(link->handle, last_fn, last_ret);
 721  failed:
 722         serial_remove(link);
 723         link->state &= ~DEV_CONFIG_PENDING;
 724         kfree(cfg_mem);
 725 }
 726
 727 /*======================================================================
 728
 729     The card status event handler.  Mostly, this schedules other
 730     stuff to run after an event is received.  A CARD_REMOVAL event
 731     also sets some flags to discourage the serial drivers from
 732     talking to the ports.
 733
 734 ======================================================================*/
 735
 736 static int
 737 serial_event(event_t event, int priority, event_callback_args_t * args)
 738 {
 739         dev_link_t *link = args->client_data;
 740         struct serial_info *info = link->priv;
 741
 742         DEBUG(1, "serial_event(0x%06x)\n", event);
 743
 744         switch (event) {
 745         case CS_EVENT_CARD_REMOVAL:
 746                 serial_remove(link);
 747                 break;
 748
 749         case CS_EVENT_CARD_INSERTION:
 750                 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
 751                 serial_config(link);
 752                 break;
 753
 754         case CS_EVENT_PM_SUSPEND:
 755                 serial_suspend(link);
 756                 break;
 757
 758         case CS_EVENT_RESET_PHYSICAL:
 759                 if ((link->state & DEV_CONFIG) && !info->slave)
 760                         pcmcia_release_configuration(link->handle);
 761                 break;
 762
 763         case CS_EVENT_PM_RESUME:
 764                 serial_resume(link);
 765                 break;
 766
 767         case CS_EVENT_CARD_RESET:
 768                 if (DEV_OK(link) && !info->slave)
 769                         pcmcia_request_configuration(link->handle, &link->conf);
 770                 break;
 771         }
 772         return 0;
 773 }
 774
 775 static struct pcmcia_driver serial_cs_driver = {
 776         .owner          = THIS_MODULE,
 777         .drv            = {
 778                 .name   = "serial_cs",
 779         },
 780         .attach         = serial_attach,
 781         .detach         = serial_detach,
 782 };
 783
 784 static int __init init_serial_cs(void)
 785 {
 786         return pcmcia_register_driver(&serial_cs_driver);
 787 }
 788
 789 static void __exit exit_serial_cs(void)
 790 {
 791         pcmcia_unregister_driver(&serial_cs_driver);
 792         BUG_ON(dev_list != NULL);
 793 }
 794
 795 module_init(init_serial_cs);
 796 module_exit(exit_serial_cs);
 797
 798 MODULE_LICENSE("GPL");