Merge with master.kernel.org:/pub/scm/linux/kernel/git/torvalds/linux-2.6.git
[linux-2.6] / 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.EventMask =
165         CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL |
166         CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET |
167         CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME;
168     client_reg.event_handler = &avmcs_event;
169     client_reg.Version = 0x0210;
170     client_reg.event_callback_args.client_data = link;
171     ret = pcmcia_register_client(&link->handle, &client_reg);
172     if (ret != 0) {
173         cs_error(link->handle, RegisterClient, ret);
174         avmcs_detach(link);
175         goto err;
176     }
177     return link;
178
179  err_kfree:
180     kfree(link);
181  err:
182     return NULL;
183 } /* avmcs_attach */
184
185 /*======================================================================
186
187     This deletes a driver "instance".  The device is de-registered
188     with Card Services.  If it has been released, all local data
189     structures are freed.  Otherwise, the structures will be freed
190     when the device is released.
191
192 ======================================================================*/
193
194 static void avmcs_detach(dev_link_t *link)
195 {
196     dev_link_t **linkp;
197
198     /* Locate device structure */
199     for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
200         if (*linkp == link) break;
201     if (*linkp == NULL)
202         return;
203
204     /*
205        If the device is currently configured and active, we won't
206        actually delete it yet.  Instead, it is marked so that when
207        the release() function is called, that will trigger a proper
208        detach().
209     */
210     if (link->state & DEV_CONFIG) {
211         link->state |= DEV_STALE_LINK;
212         return;
213     }
214
215     /* Break the link with Card Services */
216     if (link->handle)
217         pcmcia_deregister_client(link->handle);
218     
219     /* Unlink device structure, free pieces */
220     *linkp = link->next;
221     if (link->priv) {
222         kfree(link->priv);
223     }
224     kfree(link);
225     
226 } /* avmcs_detach */
227
228 /*======================================================================
229
230     avmcs_config() is scheduled to run after a CARD_INSERTION event
231     is received, to configure the PCMCIA socket, and to make the
232     ethernet device available to the system.
233     
234 ======================================================================*/
235
236 static int get_tuple(client_handle_t handle, tuple_t *tuple,
237                      cisparse_t *parse)
238 {
239     int i = pcmcia_get_tuple_data(handle, tuple);
240     if (i != CS_SUCCESS) return i;
241     return pcmcia_parse_tuple(handle, tuple, parse);
242 }
243
244 static int first_tuple(client_handle_t handle, tuple_t *tuple,
245                      cisparse_t *parse)
246 {
247     int i = pcmcia_get_first_tuple(handle, tuple);
248     if (i != CS_SUCCESS) return i;
249     return get_tuple(handle, tuple, parse);
250 }
251
252 static int next_tuple(client_handle_t handle, tuple_t *tuple,
253                      cisparse_t *parse)
254 {
255     int i = pcmcia_get_next_tuple(handle, tuple);
256     if (i != CS_SUCCESS) return i;
257     return get_tuple(handle, tuple, parse);
258 }
259
260 static void avmcs_config(dev_link_t *link)
261 {
262     client_handle_t handle;
263     tuple_t tuple;
264     cisparse_t parse;
265     cistpl_cftable_entry_t *cf = &parse.cftable_entry;
266     local_info_t *dev;
267     int i;
268     u_char buf[64];
269     char devname[128];
270     int cardtype;
271     int (*addcard)(unsigned int port, unsigned irq);
272     
273     handle = link->handle;
274     dev = link->priv;
275
276     /*
277        This reads the card's CONFIG tuple to find its configuration
278        registers.
279     */
280     do {
281         tuple.DesiredTuple = CISTPL_CONFIG;
282         i = pcmcia_get_first_tuple(handle, &tuple);
283         if (i != CS_SUCCESS) break;
284         tuple.TupleData = buf;
285         tuple.TupleDataMax = 64;
286         tuple.TupleOffset = 0;
287         i = pcmcia_get_tuple_data(handle, &tuple);
288         if (i != CS_SUCCESS) break;
289         i = pcmcia_parse_tuple(handle, &tuple, &parse);
290         if (i != CS_SUCCESS) break;
291         link->conf.ConfigBase = parse.config.base;
292     } while (0);
293     if (i != CS_SUCCESS) {
294         cs_error(link->handle, ParseTuple, i);
295         link->state &= ~DEV_CONFIG_PENDING;
296         return;
297     }
298     
299     /* Configure card */
300     link->state |= DEV_CONFIG;
301
302     do {
303
304         tuple.Attributes = 0;
305         tuple.TupleData = buf;
306         tuple.TupleDataMax = 254;
307         tuple.TupleOffset = 0;
308         tuple.DesiredTuple = CISTPL_VERS_1;
309
310         devname[0] = 0;
311         if( !first_tuple(handle, &tuple, &parse) && parse.version_1.ns > 1 ) {
312             strlcpy(devname,parse.version_1.str + parse.version_1.ofs[1], 
313                         sizeof(devname));
314         }
315         /*
316          * find IO port
317          */
318         tuple.TupleData = (cisdata_t *)buf;
319         tuple.TupleOffset = 0; tuple.TupleDataMax = 255;
320         tuple.Attributes = 0;
321         tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
322         i = first_tuple(handle, &tuple, &parse);
323         while (i == CS_SUCCESS) {
324             if (cf->io.nwin > 0) {
325                 link->conf.ConfigIndex = cf->index;
326                 link->io.BasePort1 = cf->io.win[0].base;
327                 link->io.NumPorts1 = cf->io.win[0].len;
328                 link->io.NumPorts2 = 0;
329                 printk(KERN_INFO "avm_cs: testing i/o %#x-%#x\n",
330                         link->io.BasePort1,
331                         link->io.BasePort1+link->io.NumPorts1-1);
332                 i = pcmcia_request_io(link->handle, &link->io);
333                 if (i == CS_SUCCESS) goto found_port;
334             }
335             i = next_tuple(handle, &tuple, &parse);
336         }
337
338 found_port:
339         if (i != CS_SUCCESS) {
340             cs_error(link->handle, RequestIO, i);
341             break;
342         }
343         
344         /*
345          * allocate an interrupt line
346          */
347         i = pcmcia_request_irq(link->handle, &link->irq);
348         if (i != CS_SUCCESS) {
349             cs_error(link->handle, RequestIRQ, i);
350             pcmcia_release_io(link->handle, &link->io);
351             break;
352         }
353         
354         /*
355          * configure the PCMCIA socket
356           */
357         i = pcmcia_request_configuration(link->handle, &link->conf);
358         if (i != CS_SUCCESS) {
359             cs_error(link->handle, RequestConfiguration, i);
360             pcmcia_release_io(link->handle, &link->io);
361             pcmcia_release_irq(link->handle, &link->irq);
362             break;
363         }
364
365     } while (0);
366
367     /* At this point, the dev_node_t structure(s) should be
368        initialized and arranged in a linked list at link->dev. */
369
370     if (devname[0]) {
371         char *s = strrchr(devname, ' ');
372         if (!s)
373            s = devname;
374         else s++;
375         strcpy(dev->node.dev_name, s);
376         if (strcmp("M1", s) == 0) {
377            cardtype = AVM_CARDTYPE_M1;
378         } else if (strcmp("M2", s) == 0) {
379            cardtype = AVM_CARDTYPE_M2;
380         } else {
381            cardtype = AVM_CARDTYPE_B1;
382         }
383     } else {
384         strcpy(dev->node.dev_name, "b1");
385         cardtype = AVM_CARDTYPE_B1;
386     }
387
388     dev->node.major = 64;
389     dev->node.minor = 0;
390     link->dev = &dev->node;
391     
392     link->state &= ~DEV_CONFIG_PENDING;
393     /* If any step failed, release any partially configured state */
394     if (i != 0) {
395         avmcs_release(link);
396         return;
397     }
398
399
400     switch (cardtype) {
401         case AVM_CARDTYPE_M1: addcard = b1pcmcia_addcard_m1; break;
402         case AVM_CARDTYPE_M2: addcard = b1pcmcia_addcard_m2; break;
403         default:
404         case AVM_CARDTYPE_B1: addcard = b1pcmcia_addcard_b1; break;
405     }
406     if ((i = (*addcard)(link->io.BasePort1, link->irq.AssignedIRQ)) < 0) {
407         printk(KERN_ERR "avm_cs: failed to add AVM-%s-Controller at i/o %#x, irq %d\n",
408                 dev->node.dev_name, link->io.BasePort1, link->irq.AssignedIRQ);
409         avmcs_release(link);
410         return;
411     }
412     dev->node.minor = i;
413
414 } /* avmcs_config */
415
416 /*======================================================================
417
418     After a card is removed, avmcs_release() will unregister the net
419     device, and release the PCMCIA configuration.  If the device is
420     still open, this will be postponed until it is closed.
421     
422 ======================================================================*/
423
424 static void avmcs_release(dev_link_t *link)
425 {
426     b1pcmcia_delcard(link->io.BasePort1, link->irq.AssignedIRQ);
427
428     /* Unlink the device chain */
429     link->dev = NULL;
430     
431     /* Don't bother checking to see if these succeed or not */
432     pcmcia_release_configuration(link->handle);
433     pcmcia_release_io(link->handle, &link->io);
434     pcmcia_release_irq(link->handle, &link->irq);
435     link->state &= ~DEV_CONFIG;
436     
437     if (link->state & DEV_STALE_LINK)
438         avmcs_detach(link);
439     
440 } /* avmcs_release */
441
442 /*======================================================================
443
444     The card status event handler.  Mostly, this schedules other
445     stuff to run after an event is received.  A CARD_REMOVAL event
446     also sets some flags to discourage the net drivers from trying
447     to talk to the card any more.
448
449     When a CARD_REMOVAL event is received, we immediately set a flag
450     to block future accesses to this device.  All the functions that
451     actually access the device should check this flag to make sure
452     the card is still present.
453     
454 ======================================================================*/
455
456 static int avmcs_event(event_t event, int priority,
457                           event_callback_args_t *args)
458 {
459     dev_link_t *link = args->client_data;
460
461     switch (event) {
462     case CS_EVENT_CARD_REMOVAL:
463         link->state &= ~DEV_PRESENT;
464         if (link->state & DEV_CONFIG)
465                 avmcs_release(link);
466         break;
467     case CS_EVENT_CARD_INSERTION:
468         link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
469         avmcs_config(link);
470         break;
471     case CS_EVENT_PM_SUSPEND:
472         link->state |= DEV_SUSPEND;
473         /* Fall through... */
474     case CS_EVENT_RESET_PHYSICAL:
475         if (link->state & DEV_CONFIG)
476             pcmcia_release_configuration(link->handle);
477         break;
478     case CS_EVENT_PM_RESUME:
479         link->state &= ~DEV_SUSPEND;
480         /* Fall through... */
481     case CS_EVENT_CARD_RESET:
482         if (link->state & DEV_CONFIG)
483             pcmcia_request_configuration(link->handle, &link->conf);
484         break;
485     }
486     return 0;
487 } /* avmcs_event */
488
489 static struct pcmcia_device_id avmcs_ids[] = {
490         PCMCIA_DEVICE_PROD_ID12("AVM", "ISDN-Controller B1", 0x95d42008, 0x845dc335),
491         PCMCIA_DEVICE_PROD_ID12("AVM", "Mobile ISDN-Controller M1", 0x95d42008, 0x81e10430),
492         PCMCIA_DEVICE_PROD_ID12("AVM", "Mobile ISDN-Controller M2", 0x95d42008, 0x18e8558a),
493         PCMCIA_DEVICE_NULL
494 };
495 MODULE_DEVICE_TABLE(pcmcia, avmcs_ids);
496
497 static struct pcmcia_driver avmcs_driver = {
498         .owner  = THIS_MODULE,
499         .drv    = {
500                 .name   = "avm_cs",
501         },
502         .attach = avmcs_attach,
503         .detach = avmcs_detach,
504         .id_table = avmcs_ids,
505 };
506
507 static int __init avmcs_init(void)
508 {
509         return pcmcia_register_driver(&avmcs_driver);
510 }
511
512 static void __exit avmcs_exit(void)
513 {
514         pcmcia_unregister_driver(&avmcs_driver);
515         BUG_ON(dev_list != NULL);
516 }
517
518 module_init(avmcs_init);
519 module_exit(avmcs_exit);