drivers/isdn/hisax/teles_cs.c

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