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