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
  81 /*
  82    The attach() and detach() entry points are used to create and destroy
  83    "instances" of the driver, where each instance represents everything
  84    needed to manage one actual PCMCIA card.
  85 */
  86
  87 static void teles_detach(struct pcmcia_device *p_dev);
  88
  89 /*
  90    A linked list of "instances" of the teles_cs device.  Each actual
  91    PCMCIA card corresponds to one device instance, and is described
  92    by one dev_link_t structure (defined in ds.h).
  93
  94    You may not want to use a linked list for this -- for example, the
  95    memory card driver uses an array of dev_link_t pointers, where minor
  96    device numbers are used to derive the corresponding array index.
  97 */
  98
  99 /*
 100    A driver needs to provide a dev_node_t structure for each device
 101    on a card.  In some cases, there is only one device per card (for
 102    example, ethernet cards, modems).  In other cases, there may be
 103    many actual or logical devices (SCSI adapters, memory cards with
 104    multiple partitions).  The dev_node_t structures need to be kept
 105    in a linked list starting at the 'dev' field of a dev_link_t
 106    structure.  We allocate them in the card's private data structure,
 107    because they generally shouldn't be allocated dynamically.
 108    In this case, we also provide a flag to indicate if a device is
 109    "stopped" due to a power management event, or card ejection.  The
 110    device IO routines can use a flag like this to throttle IO to a
 111    card that is not ready to accept it.
 112 */
 113
 114 typedef struct local_info_t {
 115         struct pcmcia_device    *p_dev;
 116     dev_node_t          node;
 117     int                 busy;
 118     int                 cardnr;
 119 } local_info_t;
 120
 121 /*======================================================================
 122
 123     teles_attach() creates an "instance" of the driver, allocatingx
 124     local data structures for one device.  The device is registered
 125     with Card Services.
 126
 127     The dev_link structure is initialized, but we don't actually
 128     configure the card at this point -- we wait until we receive a
 129     card insertion event.
 130
 131 ======================================================================*/
 132
 133 static int teles_attach(struct pcmcia_device *p_dev)
 134 {
 135     local_info_t *local;
 136     dev_link_t *link = dev_to_instance(p_dev);
 137
 138     DEBUG(0, "teles_attach()\n");
 139
 140     /* Allocate space for private device-specific data */
 141     local = kmalloc(sizeof(local_info_t), GFP_KERNEL);
 142     if (!local) return -ENOMEM;
 143     memset(local, 0, sizeof(local_info_t));
 144     local->cardnr = -1;
 145
 146     local->p_dev = p_dev;
 147     link->priv = local;
 148
 149     /* Interrupt setup */
 150     link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED;
 151     link->irq.IRQInfo1 = IRQ_LEVEL_ID|IRQ_SHARE_ID;
 152     link->irq.Handler = NULL;
 153
 154     /*
 155       General socket configuration defaults can go here.  In this
 156       client, we assume very little, and rely on the CIS for almost
 157       everything.  In most clients, many details (i.e., number, sizes,
 158       and attributes of IO windows) are fixed by the nature of the
 159       device, and can be hard-wired here.
 160     */
 161     link->io.NumPorts1 = 96;
 162     link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
 163     link->io.IOAddrLines = 5;
 164
 165     link->conf.Attributes = CONF_ENABLE_IRQ;
 166     link->conf.IntType = INT_MEMORY_AND_IO;
 167
 168     link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
 169     teles_cs_config(link);
 170
 171     return 0;
 172 } /* teles_attach */
 173
 174 /*======================================================================
 175
 176     This deletes a driver "instance".  The device is de-registered
 177     with Card Services.  If it has been released, all local data
 178     structures are freed.  Otherwise, the structures will be freed
 179     when the device is released.
 180
 181 ======================================================================*/
 182
 183 static void teles_detach(struct pcmcia_device *p_dev)
 184 {
 185     dev_link_t *link = dev_to_instance(p_dev);
 186     local_info_t *info = link->priv;
 187
 188     DEBUG(0, "teles_detach(0x%p)\n", link);
 189
 190     if (link->state & DEV_CONFIG) {
 191             info->busy = 1;
 192             teles_cs_release(link);
 193     }
 194
 195     kfree(info);
 196
 197 } /* teles_detach */
 198
 199 /*======================================================================
 200
 201     teles_cs_config() is scheduled to run after a CARD_INSERTION event
 202     is received, to configure the PCMCIA socket, and to make the
 203     device available to the system.
 204
 205 ======================================================================*/
 206 static int get_tuple(client_handle_t handle, tuple_t *tuple,
 207                      cisparse_t *parse)
 208 {
 209     int i = pcmcia_get_tuple_data(handle, tuple);
 210     if (i != CS_SUCCESS) return i;
 211     return pcmcia_parse_tuple(handle, tuple, parse);
 212 }
 213
 214 static int first_tuple(client_handle_t handle, tuple_t *tuple,
 215                      cisparse_t *parse)
 216 {
 217     int i = pcmcia_get_first_tuple(handle, tuple);
 218     if (i != CS_SUCCESS) return i;
 219     return get_tuple(handle, tuple, parse);
 220 }
 221
 222 static int next_tuple(client_handle_t handle, tuple_t *tuple,
 223                      cisparse_t *parse)
 224 {
 225     int i = pcmcia_get_next_tuple(handle, tuple);
 226     if (i != CS_SUCCESS) return i;
 227     return get_tuple(handle, tuple, parse);
 228 }
 229
 230 static void teles_cs_config(dev_link_t *link)
 231 {
 232     client_handle_t handle;
 233     tuple_t tuple;
 234     cisparse_t parse;
 235     local_info_t *dev;
 236     int i, j, last_fn;
 237     u_short buf[128];
 238     cistpl_cftable_entry_t *cf = &parse.cftable_entry;
 239     IsdnCard_t icard;
 240
 241     DEBUG(0, "teles_config(0x%p)\n", link);
 242     handle = link->handle;
 243     dev = link->priv;
 244
 245     /*
 246        This reads the card's CONFIG tuple to find its configuration
 247        registers.
 248     */
 249     tuple.DesiredTuple = CISTPL_CONFIG;
 250     tuple.TupleData = (cisdata_t *)buf;
 251     tuple.TupleDataMax = 255;
 252     tuple.TupleOffset = 0;
 253     tuple.Attributes = 0;
 254     i = first_tuple(handle, &tuple, &parse);
 255     if (i != CS_SUCCESS) {
 256         last_fn = ParseTuple;
 257         goto cs_failed;
 258     }
 259     link->conf.ConfigBase = parse.config.base;
 260     link->conf.Present = parse.config.rmask[0];
 261
 262     /* Configure card */
 263     link->state |= DEV_CONFIG;
 264
 265     tuple.TupleData = (cisdata_t *)buf;
 266     tuple.TupleOffset = 0; tuple.TupleDataMax = 255;
 267     tuple.Attributes = 0;
 268     tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
 269     i = first_tuple(handle, &tuple, &parse);
 270     while (i == CS_SUCCESS) {
 271         if ( (cf->io.nwin > 0) && cf->io.win[0].base) {
 272             printk(KERN_INFO "(teles_cs: looks like the 96 model)\n");
 273             link->conf.ConfigIndex = cf->index;
 274             link->io.BasePort1 = cf->io.win[0].base;
 275             i = pcmcia_request_io(link->handle, &link->io);
 276             if (i == CS_SUCCESS) break;
 277         } else {
 278           printk(KERN_INFO "(teles_cs: looks like the 97 model)\n");
 279           link->conf.ConfigIndex = cf->index;
 280           for (i = 0, j = 0x2f0; j > 0x100; j -= 0x10) {
 281             link->io.BasePort1 = j;
 282             i = pcmcia_request_io(link->handle, &link->io);
 283             if (i == CS_SUCCESS) break;
 284           }
 285           break;
 286         }
 287         i = next_tuple(handle, &tuple, &parse);
 288     }
 289
 290     if (i != CS_SUCCESS) {
 291         last_fn = RequestIO;
 292         goto cs_failed;
 293     }
 294
 295     i = pcmcia_request_irq(link->handle, &link->irq);
 296     if (i != CS_SUCCESS) {
 297         link->irq.AssignedIRQ = 0;
 298         last_fn = RequestIRQ;
 299         goto cs_failed;
 300     }
 301
 302     i = pcmcia_request_configuration(link->handle, &link->conf);
 303     if (i != CS_SUCCESS) {
 304       last_fn = RequestConfiguration;
 305       goto cs_failed;
 306     }
 307
 308     /* At this point, the dev_node_t structure(s) should be
 309        initialized and arranged in a linked list at link->dev. *//*  */
 310     sprintf(dev->node.dev_name, "teles");
 311     dev->node.major = dev->node.minor = 0x0;
 312
 313     link->dev_node = &dev->node;
 314
 315     /* Finally, report what we've done */
 316     printk(KERN_INFO "%s: index 0x%02x:",
 317            dev->node.dev_name, link->conf.ConfigIndex);
 318     if (link->conf.Attributes & CONF_ENABLE_IRQ)
 319         printk(", irq %d", link->irq.AssignedIRQ);
 320     if (link->io.NumPorts1)
 321         printk(", io 0x%04x-0x%04x", link->io.BasePort1,
 322                link->io.BasePort1+link->io.NumPorts1-1);
 323     if (link->io.NumPorts2)
 324         printk(" & 0x%04x-0x%04x", link->io.BasePort2,
 325                link->io.BasePort2+link->io.NumPorts2-1);
 326     printk("\n");
 327
 328     link->state &= ~DEV_CONFIG_PENDING;
 329
 330     icard.para[0] = link->irq.AssignedIRQ;
 331     icard.para[1] = link->io.BasePort1;
 332     icard.protocol = protocol;
 333     icard.typ = ISDN_CTYPE_TELESPCMCIA;
 334
 335     i = hisax_init_pcmcia(link, &(((local_info_t*)link->priv)->busy), &icard);
 336     if (i < 0) {
 337         printk(KERN_ERR "teles_cs: failed to initialize Teles PCMCIA %d at i/o %#x\n",
 338                 i, link->io.BasePort1);
 339         teles_cs_release(link);
 340     } else
 341         ((local_info_t*)link->priv)->cardnr = i;
 342
 343     return;
 344 cs_failed:
 345     cs_error(link->handle, last_fn, i);
 346     teles_cs_release(link);
 347 } /* teles_cs_config */
 348
 349 /*======================================================================
 350
 351     After a card is removed, teles_cs_release() will unregister the net
 352     device, and release the PCMCIA configuration.  If the device is
 353     still open, this will be postponed until it is closed.
 354
 355 ======================================================================*/
 356
 357 static void teles_cs_release(dev_link_t *link)
 358 {
 359     local_info_t *local = link->priv;
 360
 361     DEBUG(0, "teles_cs_release(0x%p)\n", link);
 362
 363     if (local) {
 364         if (local->cardnr >= 0) {
 365             /* no unregister function with hisax */
 366             HiSax_closecard(local->cardnr);
 367         }
 368     }
 369
 370     pcmcia_disable_device(link->handle);
 371 } /* teles_cs_release */
 372
 373 static int teles_suspend(struct pcmcia_device *p_dev)
 374 {
 375         dev_link_t *link = dev_to_instance(p_dev);
 376         local_info_t *dev = link->priv;
 377
 378         dev->busy = 1;
 379
 380         return 0;
 381 }
 382
 383 static int teles_resume(struct pcmcia_device *p_dev)
 384 {
 385         dev_link_t *link = dev_to_instance(p_dev);
 386         local_info_t *dev = link->priv;
 387
 388         dev->busy = 0;
 389
 390         return 0;
 391 }
 392
 393
 394 static struct pcmcia_device_id teles_ids[] = {
 395         PCMCIA_DEVICE_PROD_ID12("TELES", "S0/PC", 0x67b50eae, 0xe9e70119),
 396         PCMCIA_DEVICE_NULL,
 397 };
 398 MODULE_DEVICE_TABLE(pcmcia, teles_ids);
 399
 400 static struct pcmcia_driver teles_cs_driver = {
 401         .owner          = THIS_MODULE,
 402         .drv            = {
 403                 .name   = "teles_cs",
 404         },
 405         .probe          = teles_attach,
 406         .remove         = teles_detach,
 407         .id_table       = teles_ids,
 408         .suspend        = teles_suspend,
 409         .resume         = teles_resume,
 410 };
 411
 412 static int __init init_teles_cs(void)
 413 {
 414         return pcmcia_register_driver(&teles_cs_driver);
 415 }
 416
 417 static void __exit exit_teles_cs(void)
 418 {
 419         pcmcia_unregister_driver(&teles_cs_driver);
 420 }
 421
 422 module_init(init_teles_cs);
 423 module_exit(exit_teles_cs);