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 void 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_attach(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     avmcs_config(p_dev);
 132
 133     return 0;
 134
 135  err:
 136     return -EINVAL;
 137 } /* avmcs_attach */
 138
 139 /*======================================================================
 140
 141     This deletes a driver "instance".  The device is de-registered
 142     with Card Services.  If it has been released, all local data
 143     structures are freed.  Otherwise, the structures will be freed
 144     when the device is released.
 145
 146 ======================================================================*/
 147
 148 static void avmcs_detach(struct pcmcia_device *link)
 149 {
 150     if (link->state & DEV_CONFIG)
 151         avmcs_release(link);
 152
 153     kfree(link->priv);
 154 } /* avmcs_detach */
 155
 156 /*======================================================================
 157
 158     avmcs_config() is scheduled to run after a CARD_INSERTION event
 159     is received, to configure the PCMCIA socket, and to make the
 160     ethernet device available to the system.
 161
 162 ======================================================================*/
 163
 164 static int get_tuple(struct pcmcia_device *handle, tuple_t *tuple,
 165                      cisparse_t *parse)
 166 {
 167     int i = pcmcia_get_tuple_data(handle, tuple);
 168     if (i != CS_SUCCESS) return i;
 169     return pcmcia_parse_tuple(handle, tuple, parse);
 170 }
 171
 172 static int first_tuple(struct pcmcia_device *handle, tuple_t *tuple,
 173                      cisparse_t *parse)
 174 {
 175     int i = pcmcia_get_first_tuple(handle, tuple);
 176     if (i != CS_SUCCESS) return i;
 177     return get_tuple(handle, tuple, parse);
 178 }
 179
 180 static int next_tuple(struct pcmcia_device *handle, tuple_t *tuple,
 181                      cisparse_t *parse)
 182 {
 183     int i = pcmcia_get_next_tuple(handle, tuple);
 184     if (i != CS_SUCCESS) return i;
 185     return get_tuple(handle, tuple, parse);
 186 }
 187
 188 static void avmcs_config(struct pcmcia_device *link)
 189 {
 190     tuple_t tuple;
 191     cisparse_t parse;
 192     cistpl_cftable_entry_t *cf = &parse.cftable_entry;
 193     local_info_t *dev;
 194     int i;
 195     u_char buf[64];
 196     char devname[128];
 197     int cardtype;
 198     int (*addcard)(unsigned int port, unsigned irq);
 199
 200     dev = link->priv;
 201
 202     /*
 203        This reads the card's CONFIG tuple to find its configuration
 204        registers.
 205     */
 206     do {
 207         tuple.DesiredTuple = CISTPL_CONFIG;
 208         i = pcmcia_get_first_tuple(link, &tuple);
 209         if (i != CS_SUCCESS) break;
 210         tuple.TupleData = buf;
 211         tuple.TupleDataMax = 64;
 212         tuple.TupleOffset = 0;
 213         i = pcmcia_get_tuple_data(link, &tuple);
 214         if (i != CS_SUCCESS) break;
 215         i = pcmcia_parse_tuple(link, &tuple, &parse);
 216         if (i != CS_SUCCESS) break;
 217         link->conf.ConfigBase = parse.config.base;
 218     } while (0);
 219     if (i != CS_SUCCESS) {
 220         cs_error(link, ParseTuple, i);
 221         link->state &= ~DEV_CONFIG_PENDING;
 222         return;
 223     }
 224
 225     /* Configure card */
 226     link->state |= DEV_CONFIG;
 227
 228     do {
 229
 230         tuple.Attributes = 0;
 231         tuple.TupleData = buf;
 232         tuple.TupleDataMax = 254;
 233         tuple.TupleOffset = 0;
 234         tuple.DesiredTuple = CISTPL_VERS_1;
 235
 236         devname[0] = 0;
 237         if( !first_tuple(link, &tuple, &parse) && parse.version_1.ns > 1 ) {
 238             strlcpy(devname,parse.version_1.str + parse.version_1.ofs[1],
 239                         sizeof(devname));
 240         }
 241         /*
 242          * find IO port
 243          */
 244         tuple.TupleData = (cisdata_t *)buf;
 245         tuple.TupleOffset = 0; tuple.TupleDataMax = 255;
 246         tuple.Attributes = 0;
 247         tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
 248         i = first_tuple(link, &tuple, &parse);
 249         while (i == CS_SUCCESS) {
 250             if (cf->io.nwin > 0) {
 251                 link->conf.ConfigIndex = cf->index;
 252                 link->io.BasePort1 = cf->io.win[0].base;
 253                 link->io.NumPorts1 = cf->io.win[0].len;
 254                 link->io.NumPorts2 = 0;
 255                 printk(KERN_INFO "avm_cs: testing i/o %#x-%#x\n",
 256                         link->io.BasePort1,
 257                         link->io.BasePort1+link->io.NumPorts1-1);
 258                 i = pcmcia_request_io(link, &link->io);
 259                 if (i == CS_SUCCESS) goto found_port;
 260             }
 261             i = next_tuple(link, &tuple, &parse);
 262         }
 263
 264 found_port:
 265         if (i != CS_SUCCESS) {
 266             cs_error(link, RequestIO, i);
 267             break;
 268         }
 269
 270         /*
 271          * allocate an interrupt line
 272          */
 273         i = pcmcia_request_irq(link, &link->irq);
 274         if (i != CS_SUCCESS) {
 275             cs_error(link, RequestIRQ, i);
 276             /* undo */
 277             pcmcia_disable_device(link);
 278             break;
 279         }
 280
 281         /*
 282          * configure the PCMCIA socket
 283           */
 284         i = pcmcia_request_configuration(link, &link->conf);
 285         if (i != CS_SUCCESS) {
 286             cs_error(link, RequestConfiguration, i);
 287             pcmcia_disable_device(link);
 288             break;
 289         }
 290
 291     } while (0);
 292
 293     /* At this point, the dev_node_t structure(s) should be
 294        initialized and arranged in a linked list at link->dev. */
 295
 296     if (devname[0]) {
 297         char *s = strrchr(devname, ' ');
 298         if (!s)
 299            s = devname;
 300         else s++;
 301         strcpy(dev->node.dev_name, s);
 302         if (strcmp("M1", s) == 0) {
 303            cardtype = AVM_CARDTYPE_M1;
 304         } else if (strcmp("M2", s) == 0) {
 305            cardtype = AVM_CARDTYPE_M2;
 306         } else {
 307            cardtype = AVM_CARDTYPE_B1;
 308         }
 309     } else {
 310         strcpy(dev->node.dev_name, "b1");
 311         cardtype = AVM_CARDTYPE_B1;
 312     }
 313
 314     dev->node.major = 64;
 315     dev->node.minor = 0;
 316     link->dev_node = &dev->node;
 317
 318     link->state &= ~DEV_CONFIG_PENDING;
 319     /* If any step failed, release any partially configured state */
 320     if (i != 0) {
 321         avmcs_release(link);
 322         return;
 323     }
 324
 325
 326     switch (cardtype) {
 327         case AVM_CARDTYPE_M1: addcard = b1pcmcia_addcard_m1; break;
 328         case AVM_CARDTYPE_M2: addcard = b1pcmcia_addcard_m2; break;
 329         default:
 330         case AVM_CARDTYPE_B1: addcard = b1pcmcia_addcard_b1; break;
 331     }
 332     if ((i = (*addcard)(link->io.BasePort1, link->irq.AssignedIRQ)) < 0) {
 333         printk(KERN_ERR "avm_cs: failed to add AVM-%s-Controller at i/o %#x, irq %d\n",
 334                 dev->node.dev_name, link->io.BasePort1, link->irq.AssignedIRQ);
 335         avmcs_release(link);
 336         return;
 337     }
 338     dev->node.minor = i;
 339
 340 } /* avmcs_config */
 341
 342 /*======================================================================
 343
 344     After a card is removed, avmcs_release() will unregister the net
 345     device, and release the PCMCIA configuration.  If the device is
 346     still open, this will be postponed until it is closed.
 347
 348 ======================================================================*/
 349
 350 static void avmcs_release(struct pcmcia_device *link)
 351 {
 352         b1pcmcia_delcard(link->io.BasePort1, link->irq.AssignedIRQ);
 353         pcmcia_disable_device(link);
 354 } /* avmcs_release */
 355
 356
 357 static struct pcmcia_device_id avmcs_ids[] = {
 358         PCMCIA_DEVICE_PROD_ID12("AVM", "ISDN-Controller B1", 0x95d42008, 0x845dc335),
 359         PCMCIA_DEVICE_PROD_ID12("AVM", "Mobile ISDN-Controller M1", 0x95d42008, 0x81e10430),
 360         PCMCIA_DEVICE_PROD_ID12("AVM", "Mobile ISDN-Controller M2", 0x95d42008, 0x18e8558a),
 361         PCMCIA_DEVICE_NULL
 362 };
 363 MODULE_DEVICE_TABLE(pcmcia, avmcs_ids);
 364
 365 static struct pcmcia_driver avmcs_driver = {
 366         .owner  = THIS_MODULE,
 367         .drv    = {
 368                 .name   = "avm_cs",
 369         },
 370         .probe = avmcs_attach,
 371         .remove = avmcs_detach,
 372         .id_table = avmcs_ids,
 373 };
 374
 375 static int __init avmcs_init(void)
 376 {
 377         return pcmcia_register_driver(&avmcs_driver);
 378 }
 379
 380 static void __exit avmcs_exit(void)
 381 {
 382         pcmcia_unregister_driver(&avmcs_driver);
 383 }
 384
 385 module_init(avmcs_init);
 386 module_exit(avmcs_exit);