SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/isdn/hardware/avm/avm_cs.c

   1 /* $Id: avm_cs.c,v 1.4.6.3 2001/09/23 22:24:33 kai Exp $
   2  *
   3  * A PCMCIA client driver for AVM B1/M1/M2
   4  *
   5  * Copyright 1999 by Carsten Paeth <calle@calle.de>
   6  *
   7  * This software may be used and distributed according to the terms
   8  * of the GNU General Public License, incorporated herein by reference.
   9  *
  10  */
  11
  12 #include <linux/module.h>
  13 #include <linux/kernel.h>
  14 #include <linux/init.h>
  15 #include <linux/sched.h>
  16 #include <linux/ptrace.h>
  17 #include <linux/slab.h>
  18 #include <linux/string.h>
  19 #include <linux/tty.h>
  20 #include <linux/serial.h>
  21 #include <linux/major.h>
  22 #include <asm/io.h>
  23 #include <asm/system.h>
  24
  25 #include <pcmcia/cs_types.h>
  26 #include <pcmcia/cs.h>
  27 #include <pcmcia/cistpl.h>
  28 #include <pcmcia/ciscode.h>
  29 #include <pcmcia/ds.h>
  30 #include <pcmcia/cisreg.h>
  31
  32 #include <linux/skbuff.h>
  33 #include <linux/capi.h>
  34 #include <linux/b1lli.h>
  35 #include <linux/b1pcmcia.h>
  36
  37 /*====================================================================*/
  38
  39 MODULE_DESCRIPTION("CAPI4Linux: PCMCIA client driver for AVM B1/M1/M2");
  40 MODULE_AUTHOR("Carsten Paeth");
  41 MODULE_LICENSE("GPL");
  42
  43 /*====================================================================*/
  44
  45 /*
  46    The event() function is this driver's Card Services event handler.
  47    It will be called by Card Services when an appropriate card status
  48    event is received.  The config() and release() entry points are
  49    used to configure or release a socket, in response to card insertion
  50    and ejection events.  They are invoked from the skeleton event
  51    handler.
  52 */
  53
  54 static int avmcs_config(struct pcmcia_device *link);
  55 static void avmcs_release(struct pcmcia_device *link);
  56
  57 /*
  58    The attach() and detach() entry points are used to create and destroy
  59    "instances" of the driver, where each instance represents everything
  60    needed to manage one actual PCMCIA card.
  61 */
  62
  63 static void avmcs_detach(struct pcmcia_device *p_dev);
  64
  65 /*
  66    A linked list of "instances" of the skeleton device.  Each actual
  67    PCMCIA card corresponds to one device instance, and is described
  68    by one struct pcmcia_device structure (defined in ds.h).
  69
  70    You may not want to use a linked list for this -- for example, the
  71    memory card driver uses an array of struct pcmcia_device pointers, where minor
  72    device numbers are used to derive the corresponding array index.
  73 */
  74
  75 /*
  76    A driver needs to provide a dev_node_t structure for each device
  77    on a card.  In some cases, there is only one device per card (for
  78    example, ethernet cards, modems).  In other cases, there may be
  79    many actual or logical devices (SCSI adapters, memory cards with
  80    multiple partitions).  The dev_node_t structures need to be kept
  81    in a linked list starting at the 'dev' field of a struct pcmcia_device
  82    structure.  We allocate them in the card's private data structure,
  83    because they generally can't be allocated dynamically.
  84 */
  85
  86 typedef struct local_info_t {
  87     dev_node_t  node;
  88 } local_info_t;
  89
  90 /*======================================================================
  91
  92     avmcs_attach() creates an "instance" of the driver, allocating
  93     local data structures for one device.  The device is registered
  94     with Card Services.
  95
  96     The dev_link structure is initialized, but we don't actually
  97     configure the card at this point -- we wait until we receive a
  98     card insertion event.
  99
 100 ======================================================================*/
 101
 102 static int avmcs_probe(struct pcmcia_device *p_dev)
 103 {
 104     local_info_t *local;
 105
 106     /* The io structure describes IO port mapping */
 107     p_dev->io.NumPorts1 = 16;
 108     p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
 109     p_dev->io.NumPorts2 = 0;
 110
 111     /* Interrupt setup */
 112     p_dev->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
 113     p_dev->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED;
 114
 115     p_dev->irq.IRQInfo1 = IRQ_LEVEL_ID;
 116
 117     /* General socket configuration */
 118     p_dev->conf.Attributes = CONF_ENABLE_IRQ;
 119     p_dev->conf.IntType = INT_MEMORY_AND_IO;
 120     p_dev->conf.ConfigIndex = 1;
 121     p_dev->conf.Present = PRESENT_OPTION;
 122
 123     /* Allocate space for private device-specific data */
 124     local = kmalloc(sizeof(local_info_t), GFP_KERNEL);
 125     if (!local)
 126         goto err;
 127     memset(local, 0, sizeof(local_info_t));
 128     p_dev->priv = local;
 129
 130     p_dev->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
 131     return avmcs_config(p_dev);
 132
 133  err:
 134     return -ENOMEM;
 135 } /* avmcs_attach */
 136
 137 /*======================================================================
 138
 139     This deletes a driver "instance".  The device is de-registered
 140     with Card Services.  If it has been released, all local data
 141     structures are freed.  Otherwise, the structures will be freed
 142     when the device is released.
 143
 144 ======================================================================*/
 145
 146 static void avmcs_detach(struct pcmcia_device *link)
 147 {
 148     if (link->state & DEV_CONFIG)
 149         avmcs_release(link);
 150
 151     kfree(link->priv);
 152 } /* avmcs_detach */
 153
 154 /*======================================================================
 155
 156     avmcs_config() is scheduled to run after a CARD_INSERTION event
 157     is received, to configure the PCMCIA socket, and to make the
 158     ethernet device available to the system.
 159
 160 ======================================================================*/
 161
 162 static int get_tuple(struct pcmcia_device *handle, tuple_t *tuple,
 163                      cisparse_t *parse)
 164 {
 165     int i = pcmcia_get_tuple_data(handle, tuple);
 166     if (i != CS_SUCCESS) return i;
 167     return pcmcia_parse_tuple(handle, tuple, parse);
 168 }
 169
 170 static int first_tuple(struct pcmcia_device *handle, tuple_t *tuple,
 171                      cisparse_t *parse)
 172 {
 173     int i = pcmcia_get_first_tuple(handle, tuple);
 174     if (i != CS_SUCCESS) return i;
 175     return get_tuple(handle, tuple, parse);
 176 }
 177
 178 static int next_tuple(struct pcmcia_device *handle, tuple_t *tuple,
 179                      cisparse_t *parse)
 180 {
 181     int i = pcmcia_get_next_tuple(handle, tuple);
 182     if (i != CS_SUCCESS) return i;
 183     return get_tuple(handle, tuple, parse);
 184 }
 185
 186 static int avmcs_config(struct pcmcia_device *link)
 187 {
 188     tuple_t tuple;
 189     cisparse_t parse;
 190     cistpl_cftable_entry_t *cf = &parse.cftable_entry;
 191     local_info_t *dev;
 192     int i;
 193     u_char buf[64];
 194     char devname[128];
 195     int cardtype;
 196     int (*addcard)(unsigned int port, unsigned irq);
 197
 198     dev = link->priv;
 199
 200     /*
 201        This reads the card's CONFIG tuple to find its configuration
 202        registers.
 203     */
 204     do {
 205         tuple.DesiredTuple = CISTPL_CONFIG;
 206         i = pcmcia_get_first_tuple(link, &tuple);
 207         if (i != CS_SUCCESS) break;
 208         tuple.TupleData = buf;
 209         tuple.TupleDataMax = 64;
 210         tuple.TupleOffset = 0;
 211         i = pcmcia_get_tuple_data(link, &tuple);
 212         if (i != CS_SUCCESS) break;
 213         i = pcmcia_parse_tuple(link, &tuple, &parse);
 214         if (i != CS_SUCCESS) break;
 215         link->conf.ConfigBase = parse.config.base;
 216     } while (0);
 217     if (i != CS_SUCCESS) {
 218         cs_error(link, ParseTuple, i);
 219         link->state &= ~DEV_CONFIG_PENDING;
 220         return -ENODEV;
 221     }
 222
 223     /* Configure card */
 224     link->state |= DEV_CONFIG;
 225
 226     do {
 227
 228         tuple.Attributes = 0;
 229         tuple.TupleData = buf;
 230         tuple.TupleDataMax = 254;
 231         tuple.TupleOffset = 0;
 232         tuple.DesiredTuple = CISTPL_VERS_1;
 233
 234         devname[0] = 0;
 235         if( !first_tuple(link, &tuple, &parse) && parse.version_1.ns > 1 ) {
 236             strlcpy(devname,parse.version_1.str + parse.version_1.ofs[1],
 237                         sizeof(devname));
 238         }
 239         /*
 240          * find IO port
 241          */
 242         tuple.TupleData = (cisdata_t *)buf;
 243         tuple.TupleOffset = 0; tuple.TupleDataMax = 255;
 244         tuple.Attributes = 0;
 245         tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
 246         i = first_tuple(link, &tuple, &parse);
 247         while (i == CS_SUCCESS) {
 248             if (cf->io.nwin > 0) {
 249                 link->conf.ConfigIndex = cf->index;
 250                 link->io.BasePort1 = cf->io.win[0].base;
 251                 link->io.NumPorts1 = cf->io.win[0].len;
 252                 link->io.NumPorts2 = 0;
 253                 printk(KERN_INFO "avm_cs: testing i/o %#x-%#x\n",
 254                         link->io.BasePort1,
 255                         link->io.BasePort1+link->io.NumPorts1-1);
 256                 i = pcmcia_request_io(link, &link->io);
 257                 if (i == CS_SUCCESS) goto found_port;
 258             }
 259             i = next_tuple(link, &tuple, &parse);
 260         }
 261
 262 found_port:
 263         if (i != CS_SUCCESS) {
 264             cs_error(link, RequestIO, i);
 265             break;
 266         }
 267
 268         /*
 269          * allocate an interrupt line
 270          */
 271         i = pcmcia_request_irq(link, &link->irq);
 272         if (i != CS_SUCCESS) {
 273             cs_error(link, RequestIRQ, i);
 274             /* undo */
 275             pcmcia_disable_device(link);
 276             break;
 277         }
 278
 279         /*
 280          * configure the PCMCIA socket
 281           */
 282         i = pcmcia_request_configuration(link, &link->conf);
 283         if (i != CS_SUCCESS) {
 284             cs_error(link, RequestConfiguration, i);
 285             pcmcia_disable_device(link);
 286             break;
 287         }
 288
 289     } while (0);
 290
 291     /* At this point, the dev_node_t structure(s) should be
 292        initialized and arranged in a linked list at link->dev. */
 293
 294     if (devname[0]) {
 295         char *s = strrchr(devname, ' ');
 296         if (!s)
 297            s = devname;
 298         else s++;
 299         strcpy(dev->node.dev_name, s);
 300         if (strcmp("M1", s) == 0) {
 301            cardtype = AVM_CARDTYPE_M1;
 302         } else if (strcmp("M2", s) == 0) {
 303            cardtype = AVM_CARDTYPE_M2;
 304         } else {
 305            cardtype = AVM_CARDTYPE_B1;
 306         }
 307     } else {
 308         strcpy(dev->node.dev_name, "b1");
 309         cardtype = AVM_CARDTYPE_B1;
 310     }
 311
 312     dev->node.major = 64;
 313     dev->node.minor = 0;
 314     link->dev_node = &dev->node;
 315
 316     link->state &= ~DEV_CONFIG_PENDING;
 317     /* If any step failed, release any partially configured state */
 318     if (i != 0) {
 319         avmcs_release(link);
 320         return -ENODEV;
 321     }
 322
 323
 324     switch (cardtype) {
 325         case AVM_CARDTYPE_M1: addcard = b1pcmcia_addcard_m1; break;
 326         case AVM_CARDTYPE_M2: addcard = b1pcmcia_addcard_m2; break;
 327         default:
 328         case AVM_CARDTYPE_B1: addcard = b1pcmcia_addcard_b1; break;
 329     }
 330     if ((i = (*addcard)(link->io.BasePort1, link->irq.AssignedIRQ)) < 0) {
 331         printk(KERN_ERR "avm_cs: failed to add AVM-%s-Controller at i/o %#x, irq %d\n",
 332                 dev->node.dev_name, link->io.BasePort1, link->irq.AssignedIRQ);
 333         avmcs_release(link);
 334         return -ENODEV;
 335     }
 336     dev->node.minor = i;
 337     return 0;
 338
 339 } /* avmcs_config */
 340
 341 /*======================================================================
 342
 343     After a card is removed, avmcs_release() will unregister the net
 344     device, and release the PCMCIA configuration.  If the device is
 345     still open, this will be postponed until it is closed.
 346
 347 ======================================================================*/
 348
 349 static void avmcs_release(struct pcmcia_device *link)
 350 {
 351         b1pcmcia_delcard(link->io.BasePort1, link->irq.AssignedIRQ);
 352         pcmcia_disable_device(link);
 353 } /* avmcs_release */
 354
 355
 356 static struct pcmcia_device_id avmcs_ids[] = {
 357         PCMCIA_DEVICE_PROD_ID12("AVM", "ISDN-Controller B1", 0x95d42008, 0x845dc335),
 358         PCMCIA_DEVICE_PROD_ID12("AVM", "Mobile ISDN-Controller M1", 0x95d42008, 0x81e10430),
 359         PCMCIA_DEVICE_PROD_ID12("AVM", "Mobile ISDN-Controller M2", 0x95d42008, 0x18e8558a),
 360         PCMCIA_DEVICE_NULL
 361 };
 362 MODULE_DEVICE_TABLE(pcmcia, avmcs_ids);
 363
 364 static struct pcmcia_driver avmcs_driver = {
 365         .owner  = THIS_MODULE,
 366         .drv    = {
 367                 .name   = "avm_cs",
 368         },
 369         .probe = avmcs_probe,
 370         .remove = avmcs_detach,
 371         .id_table = avmcs_ids,
 372 };
 373
 374 static int __init avmcs_init(void)
 375 {
 376         return pcmcia_register_driver(&avmcs_driver);
 377 }
 378
 379 static void __exit avmcs_exit(void)
 380 {
 381         pcmcia_unregister_driver(&avmcs_driver);
 382 }
 383
 384 module_init(avmcs_init);
 385 module_exit(avmcs_exit);