drivers/isdn/hisax/elsa_cs.c

   1 /*======================================================================
   2
   3     An elsa_cs PCMCIA client driver
   4
   5     This driver is for the Elsa PCM ISDN Cards, i.e. the MicroLink
   6
   7
   8     The contents of this file are subject to the Mozilla Public
   9     License Version 1.1 (the "License"); you may not use this file
  10     except in compliance with the License. You may obtain a copy of
  11     the License at http://www.mozilla.org/MPL/
  12
  13     Software distributed under the License is distributed on an "AS
  14     IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  15     implied. See the License for the specific language governing
  16     rights and limitations under the License.
  17
  18     The initial developer of the original code is David A. Hinds
  19     <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
  20     are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
  21
  22     Modifications from dummy_cs.c are Copyright (C) 1999-2001 Klaus
  23     Lichtenwalder <Lichtenwalder@ACM.org>. All Rights Reserved.
  24
  25     Alternatively, the contents of this file may be used under the
  26     terms of the GNU General Public License version 2 (the "GPL"), in
  27     which case the provisions of the GPL are applicable instead of the
  28     above.  If you wish to allow the use of your version of this file
  29     only under the terms of the GPL and not to allow others to use
  30     your version of this file under the MPL, indicate your decision
  31     by deleting the provisions above and replace them with the notice
  32     and other provisions required by the GPL.  If you do not delete
  33     the provisions above, a recipient may use your version of this
  34     file under either the MPL or the GPL.
  35
  36 ======================================================================*/
  37
  38 #include <linux/module.h>
  39 #include <linux/kernel.h>
  40 #include <linux/init.h>
  41 #include <linux/sched.h>
  42 #include <linux/ptrace.h>
  43 #include <linux/slab.h>
  44 #include <linux/string.h>
  45 #include <linux/timer.h>
  46 #include <linux/ioport.h>
  47 #include <asm/io.h>
  48 #include <asm/system.h>
  49
  50 #include <pcmcia/cs_types.h>
  51 #include <pcmcia/cs.h>
  52 #include <pcmcia/cistpl.h>
  53 #include <pcmcia/cisreg.h>
  54 #include <pcmcia/ds.h>
  55 #include "hisax_cfg.h"
  56
  57 MODULE_DESCRIPTION("ISDN4Linux: PCMCIA client driver for Elsa PCM cards");
  58 MODULE_AUTHOR("Klaus Lichtenwalder");
  59 MODULE_LICENSE("Dual MPL/GPL");
  60
  61 /*
  62    All the PCMCIA modules use PCMCIA_DEBUG to control debugging.  If
  63    you do not define PCMCIA_DEBUG at all, all the debug code will be
  64    left out.  If you compile with PCMCIA_DEBUG=0, the debug code will
  65    be present but disabled -- but it can then be enabled for specific
  66    modules at load time with a 'pc_debug=#' option to insmod.
  67 */
  68
  69 #ifdef PCMCIA_DEBUG
  70 static int pc_debug = PCMCIA_DEBUG;
  71 module_param(pc_debug, int, 0);
  72 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args);
  73 static char *version =
  74 "elsa_cs.c $Revision: 1.2.2.4 $ $Date: 2004/01/25 15:07:06 $ (K.Lichtenwalder)";
  75 #else
  76 #define DEBUG(n, args...)
  77 #endif
  78
  79 /*====================================================================*/
  80
  81 /* Parameters that can be set with 'insmod' */
  82
  83 static int protocol = 2;        /* EURO-ISDN Default */
  84 module_param(protocol, int, 0);
  85
  86 /*====================================================================*/
  87
  88 /*
  89    The event() function is this driver's Card Services event handler.
  90    It will be called by Card Services when an appropriate card status
  91    event is received.  The config() and release() entry points are
  92    used to configure or release a socket, in response to card insertion
  93    and ejection events.  They are invoked from the elsa_cs event
  94    handler.
  95 */
  96
  97 static void elsa_cs_config(dev_link_t *link);
  98 static void elsa_cs_release(dev_link_t *link);
  99 static int elsa_cs_event(event_t event, int priority,
 100                           event_callback_args_t *args);
 101
 102 /*
 103    The attach() and detach() entry points are used to create and destroy
 104    "instances" of the driver, where each instance represents everything
 105    needed to manage one actual PCMCIA card.
 106 */
 107
 108 static dev_link_t *elsa_cs_attach(void);
 109 static void elsa_cs_detach(struct pcmcia_device *p_dev);
 110
 111 /*
 112    The dev_info variable is the "key" that is used to match up this
 113    device driver with appropriate cards, through the card configuration
 114    database.
 115 */
 116
 117 static dev_info_t dev_info = "elsa_cs";
 118
 119 /*
 120    A linked list of "instances" of the elsa_cs device.  Each actual
 121    PCMCIA card corresponds to one device instance, and is described
 122    by one dev_link_t structure (defined in ds.h).
 123
 124    You may not want to use a linked list for this -- for example, the
 125    memory card driver uses an array of dev_link_t pointers, where minor
 126    device numbers are used to derive the corresponding array index.
 127 */
 128
 129 static dev_link_t *dev_list = NULL;
 130
 131 /*
 132    A dev_link_t structure has fields for most things that are needed
 133    to keep track of a socket, but there will usually be some device
 134    specific information that also needs to be kept track of.  The
 135    'priv' pointer in a dev_link_t structure can be used to point to
 136    a device-specific private data structure, like this.
 137
 138    To simplify the data structure handling, we actually include the
 139    dev_link_t structure in the device's private data structure.
 140
 141    A driver needs to provide a dev_node_t structure for each device
 142    on a card.  In some cases, there is only one device per card (for
 143    example, ethernet cards, modems).  In other cases, there may be
 144    many actual or logical devices (SCSI adapters, memory cards with
 145    multiple partitions).  The dev_node_t structures need to be kept
 146    in a linked list starting at the 'dev' field of a dev_link_t
 147    structure.  We allocate them in the card's private data structure,
 148    because they generally shouldn't be allocated dynamically.
 149    In this case, we also provide a flag to indicate if a device is
 150    "stopped" due to a power management event, or card ejection.  The
 151    device IO routines can use a flag like this to throttle IO to a
 152    card that is not ready to accept it.
 153 */
 154
 155 typedef struct local_info_t {
 156     dev_link_t          link;
 157     dev_node_t          node;
 158     int                 busy;
 159     int                 cardnr;
 160 } local_info_t;
 161
 162 /*======================================================================
 163
 164     elsa_cs_attach() creates an "instance" of the driver, allocatingx
 165     local data structures for one device.  The device is registered
 166     with Card Services.
 167
 168     The dev_link structure is initialized, but we don't actually
 169     configure the card at this point -- we wait until we receive a
 170     card insertion event.
 171
 172 ======================================================================*/
 173
 174 static dev_link_t *elsa_cs_attach(void)
 175 {
 176     client_reg_t client_reg;
 177     dev_link_t *link;
 178     local_info_t *local;
 179     int ret;
 180
 181     DEBUG(0, "elsa_cs_attach()\n");
 182
 183     /* Allocate space for private device-specific data */
 184     local = kmalloc(sizeof(local_info_t), GFP_KERNEL);
 185     if (!local) return NULL;
 186     memset(local, 0, sizeof(local_info_t));
 187     local->cardnr = -1;
 188     link = &local->link; link->priv = local;
 189
 190     /* Interrupt setup */
 191     link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED;
 192     link->irq.IRQInfo1 = IRQ_LEVEL_ID|IRQ_SHARE_ID;
 193     link->irq.Handler = NULL;
 194
 195     /*
 196       General socket configuration defaults can go here.  In this
 197       client, we assume very little, and rely on the CIS for almost
 198       everything.  In most clients, many details (i.e., number, sizes,
 199       and attributes of IO windows) are fixed by the nature of the
 200       device, and can be hard-wired here.
 201     */
 202     link->io.NumPorts1 = 8;
 203     link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
 204     link->io.IOAddrLines = 3;
 205
 206     link->conf.Attributes = CONF_ENABLE_IRQ;
 207     link->conf.Vcc = 50;
 208     link->conf.IntType = INT_MEMORY_AND_IO;
 209
 210     /* Register with Card Services */
 211     link->next = dev_list;
 212     dev_list = link;
 213     client_reg.dev_info = &dev_info;
 214     client_reg.Version = 0x0210;
 215     client_reg.event_callback_args.client_data = link;
 216     ret = pcmcia_register_client(&link->handle, &client_reg);
 217     if (ret != CS_SUCCESS) {
 218         cs_error(link->handle, RegisterClient, ret);
 219         elsa_cs_detach(link->handle);
 220         return NULL;
 221     }
 222
 223     return link;
 224 } /* elsa_cs_attach */
 225
 226 /*======================================================================
 227
 228     This deletes a driver "instance".  The device is de-registered
 229     with Card Services.  If it has been released, all local data
 230     structures are freed.  Otherwise, the structures will be freed
 231     when the device is released.
 232
 233 ======================================================================*/
 234
 235 static void elsa_cs_detach(struct pcmcia_device *p_dev)
 236 {
 237     dev_link_t *link = dev_to_instance(p_dev);
 238     dev_link_t **linkp;
 239     local_info_t *info = link->priv;
 240
 241     DEBUG(0, "elsa_cs_detach(0x%p)\n", link);
 242
 243     /* Locate device structure */
 244     for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
 245         if (*linkp == link) break;
 246     if (*linkp == NULL)
 247         return;
 248
 249     if (link->state & DEV_CONFIG) {
 250         ((local_info_t*)link->priv)->busy = 1;
 251         elsa_cs_release(link);
 252     }
 253
 254     /* Unlink device structure and free it */
 255     *linkp = link->next;
 256     kfree(info);
 257
 258 } /* elsa_cs_detach */
 259
 260 /*======================================================================
 261
 262     elsa_cs_config() is scheduled to run after a CARD_INSERTION event
 263     is received, to configure the PCMCIA socket, and to make the
 264     device available to the system.
 265
 266 ======================================================================*/
 267 static int get_tuple(client_handle_t handle, tuple_t *tuple,
 268                      cisparse_t *parse)
 269 {
 270     int i = pcmcia_get_tuple_data(handle, tuple);
 271     if (i != CS_SUCCESS) return i;
 272     return pcmcia_parse_tuple(handle, tuple, parse);
 273 }
 274
 275 static int first_tuple(client_handle_t handle, tuple_t *tuple,
 276                      cisparse_t *parse)
 277 {
 278     int i = pcmcia_get_first_tuple(handle, tuple);
 279     if (i != CS_SUCCESS) return i;
 280     return get_tuple(handle, tuple, parse);
 281 }
 282
 283 static int next_tuple(client_handle_t handle, tuple_t *tuple,
 284                      cisparse_t *parse)
 285 {
 286     int i = pcmcia_get_next_tuple(handle, tuple);
 287     if (i != CS_SUCCESS) return i;
 288     return get_tuple(handle, tuple, parse);
 289 }
 290
 291 static void elsa_cs_config(dev_link_t *link)
 292 {
 293     client_handle_t handle;
 294     tuple_t tuple;
 295     cisparse_t parse;
 296     local_info_t *dev;
 297     int i, j, last_fn;
 298     u_short buf[128];
 299     cistpl_cftable_entry_t *cf = &parse.cftable_entry;
 300     IsdnCard_t icard;
 301
 302     DEBUG(0, "elsa_config(0x%p)\n", link);
 303     handle = link->handle;
 304     dev = link->priv;
 305
 306     /*
 307        This reads the card's CONFIG tuple to find its configuration
 308        registers.
 309     */
 310     tuple.DesiredTuple = CISTPL_CONFIG;
 311     tuple.TupleData = (cisdata_t *)buf;
 312     tuple.TupleDataMax = 255;
 313     tuple.TupleOffset = 0;
 314     tuple.Attributes = 0;
 315     i = first_tuple(handle, &tuple, &parse);
 316     if (i != CS_SUCCESS) {
 317         last_fn = ParseTuple;
 318         goto cs_failed;
 319     }
 320     link->conf.ConfigBase = parse.config.base;
 321     link->conf.Present = parse.config.rmask[0];
 322
 323     /* Configure card */
 324     link->state |= DEV_CONFIG;
 325
 326     tuple.TupleData = (cisdata_t *)buf;
 327     tuple.TupleOffset = 0; tuple.TupleDataMax = 255;
 328     tuple.Attributes = 0;
 329     tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
 330     i = first_tuple(handle, &tuple, &parse);
 331     while (i == CS_SUCCESS) {
 332         if ( (cf->io.nwin > 0) && cf->io.win[0].base) {
 333             printk(KERN_INFO "(elsa_cs: looks like the 96 model)\n");
 334             link->conf.ConfigIndex = cf->index;
 335             link->io.BasePort1 = cf->io.win[0].base;
 336             i = pcmcia_request_io(link->handle, &link->io);
 337             if (i == CS_SUCCESS) break;
 338         } else {
 339           printk(KERN_INFO "(elsa_cs: looks like the 97 model)\n");
 340           link->conf.ConfigIndex = cf->index;
 341           for (i = 0, j = 0x2f0; j > 0x100; j -= 0x10) {
 342             link->io.BasePort1 = j;
 343             i = pcmcia_request_io(link->handle, &link->io);
 344             if (i == CS_SUCCESS) break;
 345           }
 346           break;
 347         }
 348         i = next_tuple(handle, &tuple, &parse);
 349     }
 350
 351     if (i != CS_SUCCESS) {
 352         last_fn = RequestIO;
 353         goto cs_failed;
 354     }
 355
 356     i = pcmcia_request_irq(link->handle, &link->irq);
 357     if (i != CS_SUCCESS) {
 358         link->irq.AssignedIRQ = 0;
 359         last_fn = RequestIRQ;
 360         goto cs_failed;
 361     }
 362
 363     i = pcmcia_request_configuration(link->handle, &link->conf);
 364     if (i != CS_SUCCESS) {
 365       last_fn = RequestConfiguration;
 366       goto cs_failed;
 367     }
 368
 369     /* At this point, the dev_node_t structure(s) should be
 370        initialized and arranged in a linked list at link->dev. *//*  */
 371     sprintf(dev->node.dev_name, "elsa");
 372     dev->node.major = dev->node.minor = 0x0;
 373
 374     link->dev = &dev->node;
 375
 376     /* Finally, report what we've done */
 377     printk(KERN_INFO "%s: index 0x%02x: Vcc %d.%d",
 378            dev->node.dev_name, link->conf.ConfigIndex,
 379            link->conf.Vcc/10, link->conf.Vcc%10);
 380     if (link->conf.Vpp1)
 381         printk(", Vpp %d.%d", link->conf.Vpp1/10, link->conf.Vpp1%10);
 382     if (link->conf.Attributes & CONF_ENABLE_IRQ)
 383         printk(", irq %d", link->irq.AssignedIRQ);
 384     if (link->io.NumPorts1)
 385         printk(", io 0x%04x-0x%04x", link->io.BasePort1,
 386                link->io.BasePort1+link->io.NumPorts1-1);
 387     if (link->io.NumPorts2)
 388         printk(" & 0x%04x-0x%04x", link->io.BasePort2,
 389                link->io.BasePort2+link->io.NumPorts2-1);
 390     printk("\n");
 391
 392     link->state &= ~DEV_CONFIG_PENDING;
 393
 394     icard.para[0] = link->irq.AssignedIRQ;
 395     icard.para[1] = link->io.BasePort1;
 396     icard.protocol = protocol;
 397     icard.typ = ISDN_CTYPE_ELSA_PCMCIA;
 398
 399     i = hisax_init_pcmcia(link, &(((local_info_t*)link->priv)->busy), &icard);
 400     if (i < 0) {
 401         printk(KERN_ERR "elsa_cs: failed to initialize Elsa PCMCIA %d at i/o %#x\n",
 402                 i, link->io.BasePort1);
 403         elsa_cs_release(link);
 404     } else
 405         ((local_info_t*)link->priv)->cardnr = i;
 406
 407     return;
 408 cs_failed:
 409     cs_error(link->handle, last_fn, i);
 410     elsa_cs_release(link);
 411 } /* elsa_cs_config */
 412
 413 /*======================================================================
 414
 415     After a card is removed, elsa_cs_release() will unregister the net
 416     device, and release the PCMCIA configuration.  If the device is
 417     still open, this will be postponed until it is closed.
 418
 419 ======================================================================*/
 420
 421 static void elsa_cs_release(dev_link_t *link)
 422 {
 423     local_info_t *local = link->priv;
 424
 425     DEBUG(0, "elsa_cs_release(0x%p)\n", link);
 426
 427     if (local) {
 428         if (local->cardnr >= 0) {
 429             /* no unregister function with hisax */
 430             HiSax_closecard(local->cardnr);
 431         }
 432     }
 433     /* Unlink the device chain */
 434     link->dev = NULL;
 435
 436     /* Don't bother checking to see if these succeed or not */
 437     if (link->win)
 438         pcmcia_release_window(link->win);
 439     pcmcia_release_configuration(link->handle);
 440     pcmcia_release_io(link->handle, &link->io);
 441     pcmcia_release_irq(link->handle, &link->irq);
 442     link->state &= ~DEV_CONFIG;
 443 } /* elsa_cs_release */
 444
 445 static int elsa_suspend(struct pcmcia_device *p_dev)
 446 {
 447         dev_link_t *link = dev_to_instance(p_dev);
 448         local_info_t *dev = link->priv;
 449
 450         link->state |= DEV_SUSPEND;
 451         dev->busy = 1;
 452         if (link->state & DEV_CONFIG)
 453                 pcmcia_release_configuration(link->handle);
 454
 455         return 0;
 456 }
 457
 458 static int elsa_resume(struct pcmcia_device *p_dev)
 459 {
 460         dev_link_t *link = dev_to_instance(p_dev);
 461         local_info_t *dev = link->priv;
 462
 463         link->state &= ~DEV_SUSPEND;
 464         if (link->state & DEV_CONFIG)
 465                 pcmcia_request_configuration(link->handle, &link->conf);
 466         dev->busy = 0;
 467
 468         return 0;
 469 }
 470
 471 /*======================================================================
 472
 473     The card status event handler.  Mostly, this schedules other
 474     stuff to run after an event is received.  A CARD_REMOVAL event
 475     also sets some flags to discourage the net drivers from trying
 476     to talk to the card any more.
 477
 478     When a CARD_REMOVAL event is received, we immediately set a flag
 479     to block future accesses to this device.  All the functions that
 480     actually access the device should check this flag to make sure
 481     the card is still present.
 482
 483 ======================================================================*/
 484
 485 static int elsa_cs_event(event_t event, int priority,
 486                           event_callback_args_t *args)
 487 {
 488     dev_link_t *link = args->client_data;
 489
 490     DEBUG(1, "elsa_cs_event(%d)\n", event);
 491
 492     switch (event) {
 493     case CS_EVENT_CARD_INSERTION:
 494         link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
 495         elsa_cs_config(link);
 496         break;
 497     }
 498     return 0;
 499 } /* elsa_cs_event */
 500
 501 static struct pcmcia_device_id elsa_ids[] = {
 502         PCMCIA_DEVICE_PROD_ID12("ELSA AG (Aachen, Germany)", "MicroLink ISDN/MC ", 0x983de2c4, 0x333ba257),
 503         PCMCIA_DEVICE_PROD_ID12("ELSA GmbH, Aachen", "MicroLink ISDN/MC ", 0x639e5718, 0x333ba257),
 504         PCMCIA_DEVICE_NULL
 505 };
 506 MODULE_DEVICE_TABLE(pcmcia, elsa_ids);
 507
 508 static struct pcmcia_driver elsa_cs_driver = {
 509         .owner          = THIS_MODULE,
 510         .drv            = {
 511                 .name   = "elsa_cs",
 512         },
 513         .attach         = elsa_cs_attach,
 514         .event          = elsa_cs_event,
 515         .remove         = elsa_cs_detach,
 516         .id_table       = elsa_ids,
 517         .suspend        = elsa_suspend,
 518         .resume         = elsa_resume,
 519 };
 520
 521 static int __init init_elsa_cs(void)
 522 {
 523         return pcmcia_register_driver(&elsa_cs_driver);
 524 }
 525
 526 static void __exit exit_elsa_cs(void)
 527 {
 528         pcmcia_unregister_driver(&elsa_cs_driver);
 529         BUG_ON(dev_list != NULL);
 530 }
 531
 532 module_init(init_elsa_cs);
 533 module_exit(exit_elsa_cs);