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