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(dev_link_t *link);
  55 static void avmcs_release(dev_link_t *link);
  56 static int avmcs_event(event_t event, int priority,
  57                           event_callback_args_t *args);
  58
  59 /*
  60    The attach() and detach() entry points are used to create and destroy
  61    "instances" of the driver, where each instance represents everything
  62    needed to manage one actual PCMCIA card.
  63 */
  64
  65 static dev_link_t *avmcs_attach(void);
  66 static void avmcs_detach(dev_link_t *);
  67
  68 /*
  69    The dev_info variable is the "key" that is used to match up this
  70    device driver with appropriate cards, through the card configuration
  71    database.
  72 */
  73
  74 static dev_info_t dev_info = "avm_cs";
  75
  76 /*
  77    A linked list of "instances" of the skeleton device.  Each actual
  78    PCMCIA card corresponds to one device instance, and is described
  79    by one dev_link_t structure (defined in ds.h).
  80
  81    You may not want to use a linked list for this -- for example, the
  82    memory card driver uses an array of dev_link_t pointers, where minor
  83    device numbers are used to derive the corresponding array index.
  84 */
  85
  86 static dev_link_t *dev_list = NULL;
  87
  88 /*
  89    A dev_link_t structure has fields for most things that are needed
  90    to keep track of a socket, but there will usually be some device
  91    specific information that also needs to be kept track of.  The
  92    'priv' pointer in a dev_link_t structure can be used to point to
  93    a device-specific private data structure, like this.
  94
  95    A driver needs to provide a dev_node_t structure for each device
  96    on a card.  In some cases, there is only one device per card (for
  97    example, ethernet cards, modems).  In other cases, there may be
  98    many actual or logical devices (SCSI adapters, memory cards with
  99    multiple partitions).  The dev_node_t structures need to be kept
 100    in a linked list starting at the 'dev' field of a dev_link_t
 101    structure.  We allocate them in the card's private data structure,
 102    because they generally can't be allocated dynamically.
 103 */
 104
 105 typedef struct local_info_t {
 106     dev_node_t  node;
 107 } local_info_t;
 108
 109 /*======================================================================
 110
 111     avmcs_attach() creates an "instance" of the driver, allocating
 112     local data structures for one device.  The device is registered
 113     with Card Services.
 114
 115     The dev_link structure is initialized, but we don't actually
 116     configure the card at this point -- we wait until we receive a
 117     card insertion event.
 118
 119 ======================================================================*/
 120
 121 static dev_link_t *avmcs_attach(void)
 122 {
 123     client_reg_t client_reg;
 124     dev_link_t *link;
 125     local_info_t *local;
 126     int ret;
 127
 128     /* Initialize the dev_link_t structure */
 129     link = kmalloc(sizeof(struct dev_link_t), GFP_KERNEL);
 130     if (!link)
 131         goto err;
 132     memset(link, 0, sizeof(struct dev_link_t));
 133
 134     /* The io structure describes IO port mapping */
 135     link->io.NumPorts1 = 16;
 136     link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
 137     link->io.NumPorts2 = 0;
 138
 139     /* Interrupt setup */
 140     link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
 141     link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED;
 142
 143     link->irq.IRQInfo1 = IRQ_LEVEL_ID;
 144
 145     /* General socket configuration */
 146     link->conf.Attributes = CONF_ENABLE_IRQ;
 147     link->conf.Vcc = 50;
 148     link->conf.IntType = INT_MEMORY_AND_IO;
 149     link->conf.ConfigIndex = 1;
 150     link->conf.Present = PRESENT_OPTION;
 151
 152     /* Allocate space for private device-specific data */
 153     local = kmalloc(sizeof(local_info_t), GFP_KERNEL);
 154     if (!local)
 155         goto err_kfree;
 156     memset(local, 0, sizeof(local_info_t));
 157     link->priv = local;
 158
 159     /* Register with Card Services */
 160     link->next = dev_list;
 161     dev_list = link;
 162     client_reg.dev_info = &dev_info;
 163     client_reg.Version = 0x0210;
 164     client_reg.event_callback_args.client_data = link;
 165     ret = pcmcia_register_client(&link->handle, &client_reg);
 166     if (ret != 0) {
 167         cs_error(link->handle, RegisterClient, ret);
 168         avmcs_detach(link);
 169         goto err;
 170     }
 171     return link;
 172
 173  err_kfree:
 174     kfree(link);
 175  err:
 176     return NULL;
 177 } /* avmcs_attach */
 178
 179 /*======================================================================
 180
 181     This deletes a driver "instance".  The device is de-registered
 182     with Card Services.  If it has been released, all local data
 183     structures are freed.  Otherwise, the structures will be freed
 184     when the device is released.
 185
 186 ======================================================================*/
 187
 188 static void avmcs_detach(dev_link_t *link)
 189 {
 190     dev_link_t **linkp;
 191
 192     /* Locate device structure */
 193     for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
 194         if (*linkp == link) break;
 195     if (*linkp == NULL)
 196         return;
 197
 198     /*
 199        If the device is currently configured and active, we won't
 200        actually delete it yet.  Instead, it is marked so that when
 201        the release() function is called, that will trigger a proper
 202        detach().
 203     */
 204     if (link->state & DEV_CONFIG) {
 205         link->state |= DEV_STALE_LINK;
 206         return;
 207     }
 208
 209     /* Break the link with Card Services */
 210     if (link->handle)
 211         pcmcia_deregister_client(link->handle);
 212
 213     /* Unlink device structure, free pieces */
 214     *linkp = link->next;
 215     if (link->priv) {
 216         kfree(link->priv);
 217     }
 218     kfree(link);
 219
 220 } /* avmcs_detach */
 221
 222 /*======================================================================
 223
 224     avmcs_config() is scheduled to run after a CARD_INSERTION event
 225     is received, to configure the PCMCIA socket, and to make the
 226     ethernet device available to the system.
 227
 228 ======================================================================*/
 229
 230 static int get_tuple(client_handle_t handle, tuple_t *tuple,
 231                      cisparse_t *parse)
 232 {
 233     int i = pcmcia_get_tuple_data(handle, tuple);
 234     if (i != CS_SUCCESS) return i;
 235     return pcmcia_parse_tuple(handle, tuple, parse);
 236 }
 237
 238 static int first_tuple(client_handle_t handle, tuple_t *tuple,
 239                      cisparse_t *parse)
 240 {
 241     int i = pcmcia_get_first_tuple(handle, tuple);
 242     if (i != CS_SUCCESS) return i;
 243     return get_tuple(handle, tuple, parse);
 244 }
 245
 246 static int next_tuple(client_handle_t handle, tuple_t *tuple,
 247                      cisparse_t *parse)
 248 {
 249     int i = pcmcia_get_next_tuple(handle, tuple);
 250     if (i != CS_SUCCESS) return i;
 251     return get_tuple(handle, tuple, parse);
 252 }
 253
 254 static void avmcs_config(dev_link_t *link)
 255 {
 256     client_handle_t handle;
 257     tuple_t tuple;
 258     cisparse_t parse;
 259     cistpl_cftable_entry_t *cf = &parse.cftable_entry;
 260     local_info_t *dev;
 261     int i;
 262     u_char buf[64];
 263     char devname[128];
 264     int cardtype;
 265     int (*addcard)(unsigned int port, unsigned irq);
 266
 267     handle = link->handle;
 268     dev = link->priv;
 269
 270     /*
 271        This reads the card's CONFIG tuple to find its configuration
 272        registers.
 273     */
 274     do {
 275         tuple.DesiredTuple = CISTPL_CONFIG;
 276         i = pcmcia_get_first_tuple(handle, &tuple);
 277         if (i != CS_SUCCESS) break;
 278         tuple.TupleData = buf;
 279         tuple.TupleDataMax = 64;
 280         tuple.TupleOffset = 0;
 281         i = pcmcia_get_tuple_data(handle, &tuple);
 282         if (i != CS_SUCCESS) break;
 283         i = pcmcia_parse_tuple(handle, &tuple, &parse);
 284         if (i != CS_SUCCESS) break;
 285         link->conf.ConfigBase = parse.config.base;
 286     } while (0);
 287     if (i != CS_SUCCESS) {
 288         cs_error(link->handle, ParseTuple, i);
 289         link->state &= ~DEV_CONFIG_PENDING;
 290         return;
 291     }
 292
 293     /* Configure card */
 294     link->state |= DEV_CONFIG;
 295
 296     do {
 297
 298         tuple.Attributes = 0;
 299         tuple.TupleData = buf;
 300         tuple.TupleDataMax = 254;
 301         tuple.TupleOffset = 0;
 302         tuple.DesiredTuple = CISTPL_VERS_1;
 303
 304         devname[0] = 0;
 305         if( !first_tuple(handle, &tuple, &parse) && parse.version_1.ns > 1 ) {
 306             strlcpy(devname,parse.version_1.str + parse.version_1.ofs[1],
 307                         sizeof(devname));
 308         }
 309         /*
 310          * find IO port
 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) {
 319                 link->conf.ConfigIndex = cf->index;
 320                 link->io.BasePort1 = cf->io.win[0].base;
 321                 link->io.NumPorts1 = cf->io.win[0].len;
 322                 link->io.NumPorts2 = 0;
 323                 printk(KERN_INFO "avm_cs: testing i/o %#x-%#x\n",
 324                         link->io.BasePort1,
 325                         link->io.BasePort1+link->io.NumPorts1-1);
 326                 i = pcmcia_request_io(link->handle, &link->io);
 327                 if (i == CS_SUCCESS) goto found_port;
 328             }
 329             i = next_tuple(handle, &tuple, &parse);
 330         }
 331
 332 found_port:
 333         if (i != CS_SUCCESS) {
 334             cs_error(link->handle, RequestIO, i);
 335             break;
 336         }
 337
 338         /*
 339          * allocate an interrupt line
 340          */
 341         i = pcmcia_request_irq(link->handle, &link->irq);
 342         if (i != CS_SUCCESS) {
 343             cs_error(link->handle, RequestIRQ, i);
 344             pcmcia_release_io(link->handle, &link->io);
 345             break;
 346         }
 347
 348         /*
 349          * configure the PCMCIA socket
 350           */
 351         i = pcmcia_request_configuration(link->handle, &link->conf);
 352         if (i != CS_SUCCESS) {
 353             cs_error(link->handle, RequestConfiguration, i);
 354             pcmcia_release_io(link->handle, &link->io);
 355             pcmcia_release_irq(link->handle, &link->irq);
 356             break;
 357         }
 358
 359     } while (0);
 360
 361     /* At this point, the dev_node_t structure(s) should be
 362        initialized and arranged in a linked list at link->dev. */
 363
 364     if (devname[0]) {
 365         char *s = strrchr(devname, ' ');
 366         if (!s)
 367            s = devname;
 368         else s++;
 369         strcpy(dev->node.dev_name, s);
 370         if (strcmp("M1", s) == 0) {
 371            cardtype = AVM_CARDTYPE_M1;
 372         } else if (strcmp("M2", s) == 0) {
 373            cardtype = AVM_CARDTYPE_M2;
 374         } else {
 375            cardtype = AVM_CARDTYPE_B1;
 376         }
 377     } else {
 378         strcpy(dev->node.dev_name, "b1");
 379         cardtype = AVM_CARDTYPE_B1;
 380     }
 381
 382     dev->node.major = 64;
 383     dev->node.minor = 0;
 384     link->dev = &dev->node;
 385
 386     link->state &= ~DEV_CONFIG_PENDING;
 387     /* If any step failed, release any partially configured state */
 388     if (i != 0) {
 389         avmcs_release(link);
 390         return;
 391     }
 392
 393
 394     switch (cardtype) {
 395         case AVM_CARDTYPE_M1: addcard = b1pcmcia_addcard_m1; break;
 396         case AVM_CARDTYPE_M2: addcard = b1pcmcia_addcard_m2; break;
 397         default:
 398         case AVM_CARDTYPE_B1: addcard = b1pcmcia_addcard_b1; break;
 399     }
 400     if ((i = (*addcard)(link->io.BasePort1, link->irq.AssignedIRQ)) < 0) {
 401         printk(KERN_ERR "avm_cs: failed to add AVM-%s-Controller at i/o %#x, irq %d\n",
 402                 dev->node.dev_name, link->io.BasePort1, link->irq.AssignedIRQ);
 403         avmcs_release(link);
 404         return;
 405     }
 406     dev->node.minor = i;
 407
 408 } /* avmcs_config */
 409
 410 /*======================================================================
 411
 412     After a card is removed, avmcs_release() will unregister the net
 413     device, and release the PCMCIA configuration.  If the device is
 414     still open, this will be postponed until it is closed.
 415
 416 ======================================================================*/
 417
 418 static void avmcs_release(dev_link_t *link)
 419 {
 420     b1pcmcia_delcard(link->io.BasePort1, link->irq.AssignedIRQ);
 421
 422     /* Unlink the device chain */
 423     link->dev = NULL;
 424
 425     /* Don't bother checking to see if these succeed or not */
 426     pcmcia_release_configuration(link->handle);
 427     pcmcia_release_io(link->handle, &link->io);
 428     pcmcia_release_irq(link->handle, &link->irq);
 429     link->state &= ~DEV_CONFIG;
 430
 431     if (link->state & DEV_STALE_LINK)
 432         avmcs_detach(link);
 433
 434 } /* avmcs_release */
 435
 436 /*======================================================================
 437
 438     The card status event handler.  Mostly, this schedules other
 439     stuff to run after an event is received.  A CARD_REMOVAL event
 440     also sets some flags to discourage the net drivers from trying
 441     to talk to the card any more.
 442
 443     When a CARD_REMOVAL event is received, we immediately set a flag
 444     to block future accesses to this device.  All the functions that
 445     actually access the device should check this flag to make sure
 446     the card is still present.
 447
 448 ======================================================================*/
 449
 450 static int avmcs_event(event_t event, int priority,
 451                           event_callback_args_t *args)
 452 {
 453     dev_link_t *link = args->client_data;
 454
 455     switch (event) {
 456     case CS_EVENT_CARD_REMOVAL:
 457         link->state &= ~DEV_PRESENT;
 458         if (link->state & DEV_CONFIG)
 459                 avmcs_release(link);
 460         break;
 461     case CS_EVENT_CARD_INSERTION:
 462         link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
 463         avmcs_config(link);
 464         break;
 465     case CS_EVENT_PM_SUSPEND:
 466         link->state |= DEV_SUSPEND;
 467         /* Fall through... */
 468     case CS_EVENT_RESET_PHYSICAL:
 469         if (link->state & DEV_CONFIG)
 470             pcmcia_release_configuration(link->handle);
 471         break;
 472     case CS_EVENT_PM_RESUME:
 473         link->state &= ~DEV_SUSPEND;
 474         /* Fall through... */
 475     case CS_EVENT_CARD_RESET:
 476         if (link->state & DEV_CONFIG)
 477             pcmcia_request_configuration(link->handle, &link->conf);
 478         break;
 479     }
 480     return 0;
 481 } /* avmcs_event */
 482
 483 static struct pcmcia_device_id avmcs_ids[] = {
 484         PCMCIA_DEVICE_PROD_ID12("AVM", "ISDN-Controller B1", 0x95d42008, 0x845dc335),
 485         PCMCIA_DEVICE_PROD_ID12("AVM", "Mobile ISDN-Controller M1", 0x95d42008, 0x81e10430),
 486         PCMCIA_DEVICE_PROD_ID12("AVM", "Mobile ISDN-Controller M2", 0x95d42008, 0x18e8558a),
 487         PCMCIA_DEVICE_NULL
 488 };
 489 MODULE_DEVICE_TABLE(pcmcia, avmcs_ids);
 490
 491 static struct pcmcia_driver avmcs_driver = {
 492         .owner  = THIS_MODULE,
 493         .drv    = {
 494                 .name   = "avm_cs",
 495         },
 496         .attach = avmcs_attach,
 497         .event  = avmcs_event,
 498         .detach = avmcs_detach,
 499         .id_table = avmcs_ids,
 500 };
 501
 502 static int __init avmcs_init(void)
 503 {
 504         return pcmcia_register_driver(&avmcs_driver);
 505 }
 506
 507 static void __exit avmcs_exit(void)
 508 {
 509         pcmcia_unregister_driver(&avmcs_driver);
 510         BUG_ON(dev_list != NULL);
 511 }
 512
 513 module_init(avmcs_init);
 514 module_exit(avmcs_exit);