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(struct pcmcia_device *p_dev);
  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 /*
 111    A driver needs to provide a dev_node_t structure for each device
 112    on a card.  In some cases, there is only one device per card (for
 113    example, ethernet cards, modems).  In other cases, there may be
 114    many actual or logical devices (SCSI adapters, memory cards with
 115    multiple partitions).  The dev_node_t structures need to be kept
 116    in a linked list starting at the 'dev' field of a dev_link_t
 117    structure.  We allocate them in the card's private data structure,
 118    because they generally shouldn't be allocated dynamically.
 119    In this case, we also provide a flag to indicate if a device is
 120    "stopped" due to a power management event, or card ejection.  The
 121    device IO routines can use a flag like this to throttle IO to a
 122    card that is not ready to accept it.
 123 */
 124
 125 typedef struct local_info_t {
 126     dev_link_t          link;
 127     dev_node_t          node;
 128     int                 busy;
 129     int                 cardnr;
 130 } local_info_t;
 131
 132 /*======================================================================
 133
 134     teles_attach() creates an "instance" of the driver, allocatingx
 135     local data structures for one device.  The device is registered
 136     with Card Services.
 137
 138     The dev_link structure is initialized, but we don't actually
 139     configure the card at this point -- we wait until we receive a
 140     card insertion event.
 141
 142 ======================================================================*/
 143
 144 static dev_link_t *teles_attach(void)
 145 {
 146     client_reg_t client_reg;
 147     dev_link_t *link;
 148     local_info_t *local;
 149     int ret;
 150
 151     DEBUG(0, "teles_attach()\n");
 152
 153     /* Allocate space for private device-specific data */
 154     local = kmalloc(sizeof(local_info_t), GFP_KERNEL);
 155     if (!local) return NULL;
 156     memset(local, 0, sizeof(local_info_t));
 157     local->cardnr = -1;
 158     link = &local->link; link->priv = local;
 159
 160     /* Interrupt setup */
 161     link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED;
 162     link->irq.IRQInfo1 = IRQ_LEVEL_ID|IRQ_SHARE_ID;
 163     link->irq.Handler = NULL;
 164
 165     /*
 166       General socket configuration defaults can go here.  In this
 167       client, we assume very little, and rely on the CIS for almost
 168       everything.  In most clients, many details (i.e., number, sizes,
 169       and attributes of IO windows) are fixed by the nature of the
 170       device, and can be hard-wired here.
 171     */
 172     link->io.NumPorts1 = 96;
 173     link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
 174     link->io.IOAddrLines = 5;
 175
 176     link->conf.Attributes = CONF_ENABLE_IRQ;
 177     link->conf.Vcc = 50;
 178     link->conf.IntType = INT_MEMORY_AND_IO;
 179
 180     /* Register with Card Services */
 181     link->next = NULL;
 182     client_reg.dev_info = &dev_info;
 183     client_reg.Version = 0x0210;
 184     client_reg.event_callback_args.client_data = link;
 185     ret = pcmcia_register_client(&link->handle, &client_reg);
 186     if (ret != CS_SUCCESS) {
 187         cs_error(link->handle, RegisterClient, ret);
 188         teles_detach(link->handle);
 189         return NULL;
 190     }
 191
 192     return link;
 193 } /* teles_attach */
 194
 195 /*======================================================================
 196
 197     This deletes a driver "instance".  The device is de-registered
 198     with Card Services.  If it has been released, all local data
 199     structures are freed.  Otherwise, the structures will be freed
 200     when the device is released.
 201
 202 ======================================================================*/
 203
 204 static void teles_detach(struct pcmcia_device *p_dev)
 205 {
 206     dev_link_t *link = dev_to_instance(p_dev);
 207     local_info_t *info = link->priv;
 208
 209     DEBUG(0, "teles_detach(0x%p)\n", link);
 210
 211     if (link->state & DEV_CONFIG) {
 212             info->busy = 1;
 213             teles_cs_release(link);
 214     }
 215
 216     kfree(info);
 217
 218 } /* teles_detach */
 219
 220 /*======================================================================
 221
 222     teles_cs_config() is scheduled to run after a CARD_INSERTION event
 223     is received, to configure the PCMCIA socket, and to make the
 224     device available to the system.
 225
 226 ======================================================================*/
 227 static int get_tuple(client_handle_t handle, tuple_t *tuple,
 228                      cisparse_t *parse)
 229 {
 230     int i = pcmcia_get_tuple_data(handle, tuple);
 231     if (i != CS_SUCCESS) return i;
 232     return pcmcia_parse_tuple(handle, tuple, parse);
 233 }
 234
 235 static int first_tuple(client_handle_t handle, tuple_t *tuple,
 236                      cisparse_t *parse)
 237 {
 238     int i = pcmcia_get_first_tuple(handle, tuple);
 239     if (i != CS_SUCCESS) return i;
 240     return get_tuple(handle, tuple, parse);
 241 }
 242
 243 static int next_tuple(client_handle_t handle, tuple_t *tuple,
 244                      cisparse_t *parse)
 245 {
 246     int i = pcmcia_get_next_tuple(handle, tuple);
 247     if (i != CS_SUCCESS) return i;
 248     return get_tuple(handle, tuple, parse);
 249 }
 250
 251 static void teles_cs_config(dev_link_t *link)
 252 {
 253     client_handle_t handle;
 254     tuple_t tuple;
 255     cisparse_t parse;
 256     local_info_t *dev;
 257     int i, j, last_fn;
 258     u_short buf[128];
 259     cistpl_cftable_entry_t *cf = &parse.cftable_entry;
 260     IsdnCard_t icard;
 261
 262     DEBUG(0, "teles_config(0x%p)\n", link);
 263     handle = link->handle;
 264     dev = link->priv;
 265
 266     /*
 267        This reads the card's CONFIG tuple to find its configuration
 268        registers.
 269     */
 270     tuple.DesiredTuple = CISTPL_CONFIG;
 271     tuple.TupleData = (cisdata_t *)buf;
 272     tuple.TupleDataMax = 255;
 273     tuple.TupleOffset = 0;
 274     tuple.Attributes = 0;
 275     i = first_tuple(handle, &tuple, &parse);
 276     if (i != CS_SUCCESS) {
 277         last_fn = ParseTuple;
 278         goto cs_failed;
 279     }
 280     link->conf.ConfigBase = parse.config.base;
 281     link->conf.Present = parse.config.rmask[0];
 282
 283     /* Configure card */
 284     link->state |= DEV_CONFIG;
 285
 286     tuple.TupleData = (cisdata_t *)buf;
 287     tuple.TupleOffset = 0; tuple.TupleDataMax = 255;
 288     tuple.Attributes = 0;
 289     tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
 290     i = first_tuple(handle, &tuple, &parse);
 291     while (i == CS_SUCCESS) {
 292         if ( (cf->io.nwin > 0) && cf->io.win[0].base) {
 293             printk(KERN_INFO "(teles_cs: looks like the 96 model)\n");
 294             link->conf.ConfigIndex = cf->index;
 295             link->io.BasePort1 = cf->io.win[0].base;
 296             i = pcmcia_request_io(link->handle, &link->io);
 297             if (i == CS_SUCCESS) break;
 298         } else {
 299           printk(KERN_INFO "(teles_cs: looks like the 97 model)\n");
 300           link->conf.ConfigIndex = cf->index;
 301           for (i = 0, j = 0x2f0; j > 0x100; j -= 0x10) {
 302             link->io.BasePort1 = j;
 303             i = pcmcia_request_io(link->handle, &link->io);
 304             if (i == CS_SUCCESS) break;
 305           }
 306           break;
 307         }
 308         i = next_tuple(handle, &tuple, &parse);
 309     }
 310
 311     if (i != CS_SUCCESS) {
 312         last_fn = RequestIO;
 313         goto cs_failed;
 314     }
 315
 316     i = pcmcia_request_irq(link->handle, &link->irq);
 317     if (i != CS_SUCCESS) {
 318         link->irq.AssignedIRQ = 0;
 319         last_fn = RequestIRQ;
 320         goto cs_failed;
 321     }
 322
 323     i = pcmcia_request_configuration(link->handle, &link->conf);
 324     if (i != CS_SUCCESS) {
 325       last_fn = RequestConfiguration;
 326       goto cs_failed;
 327     }
 328
 329     /* At this point, the dev_node_t structure(s) should be
 330        initialized and arranged in a linked list at link->dev. *//*  */
 331     sprintf(dev->node.dev_name, "teles");
 332     dev->node.major = dev->node.minor = 0x0;
 333
 334     link->dev = &dev->node;
 335
 336     /* Finally, report what we've done */
 337     printk(KERN_INFO "%s: index 0x%02x: Vcc %d.%d",
 338            dev->node.dev_name, link->conf.ConfigIndex,
 339            link->conf.Vcc/10, link->conf.Vcc%10);
 340     if (link->conf.Vpp1)
 341         printk(", Vpp %d.%d", link->conf.Vpp1/10, link->conf.Vpp1%10);
 342     if (link->conf.Attributes & CONF_ENABLE_IRQ)
 343         printk(", irq %d", link->irq.AssignedIRQ);
 344     if (link->io.NumPorts1)
 345         printk(", io 0x%04x-0x%04x", link->io.BasePort1,
 346                link->io.BasePort1+link->io.NumPorts1-1);
 347     if (link->io.NumPorts2)
 348         printk(" & 0x%04x-0x%04x", link->io.BasePort2,
 349                link->io.BasePort2+link->io.NumPorts2-1);
 350     printk("\n");
 351
 352     link->state &= ~DEV_CONFIG_PENDING;
 353
 354     icard.para[0] = link->irq.AssignedIRQ;
 355     icard.para[1] = link->io.BasePort1;
 356     icard.protocol = protocol;
 357     icard.typ = ISDN_CTYPE_TELESPCMCIA;
 358
 359     i = hisax_init_pcmcia(link, &(((local_info_t*)link->priv)->busy), &icard);
 360     if (i < 0) {
 361         printk(KERN_ERR "teles_cs: failed to initialize Teles PCMCIA %d at i/o %#x\n",
 362                 i, link->io.BasePort1);
 363         teles_cs_release(link);
 364     } else
 365         ((local_info_t*)link->priv)->cardnr = i;
 366
 367     return;
 368 cs_failed:
 369     cs_error(link->handle, last_fn, i);
 370     teles_cs_release(link);
 371 } /* teles_cs_config */
 372
 373 /*======================================================================
 374
 375     After a card is removed, teles_cs_release() will unregister the net
 376     device, and release the PCMCIA configuration.  If the device is
 377     still open, this will be postponed until it is closed.
 378
 379 ======================================================================*/
 380
 381 static void teles_cs_release(dev_link_t *link)
 382 {
 383     local_info_t *local = link->priv;
 384
 385     DEBUG(0, "teles_cs_release(0x%p)\n", link);
 386
 387     if (local) {
 388         if (local->cardnr >= 0) {
 389             /* no unregister function with hisax */
 390             HiSax_closecard(local->cardnr);
 391         }
 392     }
 393     /* Unlink the device chain */
 394     link->dev = NULL;
 395
 396     /* Don't bother checking to see if these succeed or not */
 397     if (link->win)
 398         pcmcia_release_window(link->win);
 399     pcmcia_release_configuration(link->handle);
 400     pcmcia_release_io(link->handle, &link->io);
 401     pcmcia_release_irq(link->handle, &link->irq);
 402     link->state &= ~DEV_CONFIG;
 403 } /* teles_cs_release */
 404
 405 static int teles_suspend(struct pcmcia_device *p_dev)
 406 {
 407         dev_link_t *link = dev_to_instance(p_dev);
 408         local_info_t *dev = link->priv;
 409
 410         link->state |= DEV_SUSPEND;
 411         dev->busy = 1;
 412         if (link->state & DEV_CONFIG)
 413                 pcmcia_release_configuration(link->handle);
 414
 415         return 0;
 416 }
 417
 418 static int teles_resume(struct pcmcia_device *p_dev)
 419 {
 420         dev_link_t *link = dev_to_instance(p_dev);
 421         local_info_t *dev = link->priv;
 422
 423         link->state &= ~DEV_SUSPEND;
 424         if (link->state & DEV_CONFIG)
 425                 pcmcia_request_configuration(link->handle, &link->conf);
 426         dev->busy = 0;
 427
 428         return 0;
 429 }
 430
 431 /*======================================================================
 432
 433     The card status event handler.  Mostly, this schedules other
 434     stuff to run after an event is received.  A CARD_REMOVAL event
 435     also sets some flags to discourage the net drivers from trying
 436     to talk to the card any more.
 437
 438     When a CARD_REMOVAL event is received, we immediately set a flag
 439     to block future accesses to this device.  All the functions that
 440     actually access the device should check this flag to make sure
 441     the card is still present.
 442
 443 ======================================================================*/
 444
 445 static int teles_cs_event(event_t event, int priority,
 446                           event_callback_args_t *args)
 447 {
 448     dev_link_t *link = args->client_data;
 449
 450     DEBUG(1, "teles_cs_event(%d)\n", event);
 451
 452     switch (event) {
 453     case CS_EVENT_CARD_INSERTION:
 454         link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
 455         teles_cs_config(link);
 456         break;
 457     }
 458     return 0;
 459 } /* teles_cs_event */
 460
 461 static struct pcmcia_device_id teles_ids[] = {
 462         PCMCIA_DEVICE_PROD_ID12("TELES", "S0/PC", 0x67b50eae, 0xe9e70119),
 463         PCMCIA_DEVICE_NULL,
 464 };
 465 MODULE_DEVICE_TABLE(pcmcia, teles_ids);
 466
 467 static struct pcmcia_driver teles_cs_driver = {
 468         .owner          = THIS_MODULE,
 469         .drv            = {
 470                 .name   = "teles_cs",
 471         },
 472         .attach         = teles_attach,
 473         .event          = teles_cs_event,
 474         .remove         = teles_detach,
 475         .id_table       = teles_ids,
 476         .suspend        = teles_suspend,
 477         .resume         = teles_resume,
 478 };
 479
 480 static int __init init_teles_cs(void)
 481 {
 482         return pcmcia_register_driver(&teles_cs_driver);
 483 }
 484
 485 static void __exit exit_teles_cs(void)
 486 {
 487         pcmcia_unregister_driver(&teles_cs_driver);
 488 }
 489
 490 module_init(init_teles_cs);
 491 module_exit(exit_teles_cs);