[PATCH] pcmcia: remove references to pcmcia/version.h
[linux-2.6.git] / drivers / isdn / hisax / teles_cs.c
1 /* $Id: teles_cs.c,v 1.1.2.2 2004/01/25 15:07:06 keil Exp $ */
2 /*======================================================================
3
4     A teles S0 PCMCIA client driver
5
6     Based on skeleton by David Hinds, dhinds@allegro.stanford.edu
7     Written by Christof Petig, christof.petig@wtal.de
8     
9     Also inspired by ELSA PCMCIA driver 
10     by Klaus Lichtenwalder <Lichtenwalder@ACM.org>
11     
12     Extentions to new hisax_pcmcia by Karsten Keil
13
14     minor changes to be compatible with kernel 2.4.x
15     by Jan.Schubert@GMX.li
16
17 ======================================================================*/
18
19 #include <linux/kernel.h>
20 #include <linux/module.h>
21 #include <linux/init.h>
22 #include <linux/sched.h>
23 #include <linux/ptrace.h>
24 #include <linux/slab.h>
25 #include <linux/string.h>
26 #include <linux/timer.h>
27 #include <linux/ioport.h>
28 #include <asm/io.h>
29 #include <asm/system.h>
30
31 #include <pcmcia/cs_types.h>
32 #include <pcmcia/cs.h>
33 #include <pcmcia/cistpl.h>
34 #include <pcmcia/cisreg.h>
35 #include <pcmcia/ds.h>
36 #include "hisax_cfg.h"
37
38 MODULE_DESCRIPTION("ISDN4Linux: PCMCIA client driver for Teles PCMCIA cards");
39 MODULE_AUTHOR("Christof Petig, christof.petig@wtal.de, Karsten Keil, kkeil@suse.de");
40 MODULE_LICENSE("GPL");
41
42 /*
43    All the PCMCIA modules use PCMCIA_DEBUG to control debugging.  If
44    you do not define PCMCIA_DEBUG at all, all the debug code will be
45    left out.  If you compile with PCMCIA_DEBUG=0, the debug code will
46    be present but disabled -- but it can then be enabled for specific
47    modules at load time with a 'pc_debug=#' option to insmod.
48 */
49
50 #ifdef PCMCIA_DEBUG
51 static int pc_debug = PCMCIA_DEBUG;
52 module_param(pc_debug, int, 0);
53 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args);
54 static char *version =
55 "teles_cs.c 2.10 2002/07/30 22:23:34 kkeil";
56 #else
57 #define DEBUG(n, args...)
58 #endif
59
60 /*====================================================================*/
61
62 /* Parameters that can be set with 'insmod' */
63
64 static int protocol = 2;        /* EURO-ISDN Default */
65 module_param(protocol, int, 0);
66
67 /*====================================================================*/
68
69 /*
70    The event() function is this driver's Card Services event handler.
71    It will be called by Card Services when an appropriate card status
72    event is received.  The config() and release() entry points are
73    used to configure or release a socket, in response to card insertion
74    and ejection events.  They are invoked from the teles_cs event
75    handler.
76 */
77
78 static void teles_cs_config(dev_link_t *link);
79 static void teles_cs_release(dev_link_t *link);
80 static int teles_cs_event(event_t event, int priority,
81                           event_callback_args_t *args);
82
83 /*
84    The attach() and detach() entry points are used to create and destroy
85    "instances" of the driver, where each instance represents everything
86    needed to manage one actual PCMCIA card.
87 */
88
89 static dev_link_t *teles_attach(void);
90 static void teles_detach(dev_link_t *);
91
92 /*
93    The dev_info variable is the "key" that is used to match up this
94    device driver with appropriate cards, through the card configuration
95    database.
96 */
97
98 static dev_info_t dev_info = "teles_cs";
99
100 /*
101    A linked list of "instances" of the teles_cs device.  Each actual
102    PCMCIA card corresponds to one device instance, and is described
103    by one dev_link_t structure (defined in ds.h).
104
105    You may not want to use a linked list for this -- for example, the
106    memory card driver uses an array of dev_link_t pointers, where minor
107    device numbers are used to derive the corresponding array index.
108 */
109
110 static dev_link_t *dev_list = NULL;
111
112 /*
113    A dev_link_t structure has fields for most things that are needed
114    to keep track of a socket, but there will usually be some device
115    specific information that also needs to be kept track of.  The
116    'priv' pointer in a dev_link_t structure can be used to point to
117    a device-specific private data structure, like this.
118
119    To simplify the data structure handling, we actually include the
120    dev_link_t structure in the device's private data structure.
121
122    A driver needs to provide a dev_node_t structure for each device
123    on a card.  In some cases, there is only one device per card (for
124    example, ethernet cards, modems).  In other cases, there may be
125    many actual or logical devices (SCSI adapters, memory cards with
126    multiple partitions).  The dev_node_t structures need to be kept
127    in a linked list starting at the 'dev' field of a dev_link_t
128    structure.  We allocate them in the card's private data structure,
129    because they generally shouldn't be allocated dynamically.
130    In this case, we also provide a flag to indicate if a device is
131    "stopped" due to a power management event, or card ejection.  The
132    device IO routines can use a flag like this to throttle IO to a
133    card that is not ready to accept it.
134 */
135
136 typedef struct local_info_t {
137     dev_link_t          link;
138     dev_node_t          node;
139     int                 busy;
140     int                 cardnr;
141 } local_info_t;
142
143 /*======================================================================
144
145     teles_attach() creates an "instance" of the driver, allocatingx
146     local data structures for one device.  The device is registered
147     with Card Services.
148
149     The dev_link structure is initialized, but we don't actually
150     configure the card at this point -- we wait until we receive a
151     card insertion event.
152
153 ======================================================================*/
154
155 static dev_link_t *teles_attach(void)
156 {
157     client_reg_t client_reg;
158     dev_link_t *link;
159     local_info_t *local;
160     int ret;
161
162     DEBUG(0, "teles_attach()\n");
163
164     /* Allocate space for private device-specific data */
165     local = kmalloc(sizeof(local_info_t), GFP_KERNEL);
166     if (!local) return NULL;
167     memset(local, 0, sizeof(local_info_t));
168     local->cardnr = -1;
169     link = &local->link; link->priv = local;
170
171     /* Interrupt setup */
172     link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED;
173     link->irq.IRQInfo1 = IRQ_LEVEL_ID|IRQ_SHARE_ID;
174     link->irq.Handler = NULL;
175
176     /*
177       General socket configuration defaults can go here.  In this
178       client, we assume very little, and rely on the CIS for almost
179       everything.  In most clients, many details (i.e., number, sizes,
180       and attributes of IO windows) are fixed by the nature of the
181       device, and can be hard-wired here.
182     */
183     link->io.NumPorts1 = 96;
184     link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
185     link->io.IOAddrLines = 5;
186
187     link->conf.Attributes = CONF_ENABLE_IRQ;
188     link->conf.Vcc = 50;
189     link->conf.IntType = INT_MEMORY_AND_IO;
190
191     /* Register with Card Services */
192     link->next = dev_list;
193     dev_list = link;
194     client_reg.dev_info = &dev_info;
195     client_reg.Version = 0x0210;
196     client_reg.event_callback_args.client_data = link;
197     ret = pcmcia_register_client(&link->handle, &client_reg);
198     if (ret != CS_SUCCESS) {
199         cs_error(link->handle, RegisterClient, ret);
200         teles_detach(link);
201         return NULL;
202     }
203
204     return link;
205 } /* teles_attach */
206
207 /*======================================================================
208
209     This deletes a driver "instance".  The device is de-registered
210     with Card Services.  If it has been released, all local data
211     structures are freed.  Otherwise, the structures will be freed
212     when the device is released.
213
214 ======================================================================*/
215
216 static void teles_detach(dev_link_t *link)
217 {
218     dev_link_t **linkp;
219     local_info_t *info = link->priv;
220     int ret;
221
222     DEBUG(0, "teles_detach(0x%p)\n", link);
223
224     /* Locate device structure */
225     for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
226         if (*linkp == link) break;
227     if (*linkp == NULL)
228         return;
229
230     if (link->state & DEV_CONFIG)
231         teles_cs_release(link);
232
233     /* Break the link with Card Services */
234     if (link->handle) {
235         ret = pcmcia_deregister_client(link->handle);
236         if (ret != CS_SUCCESS)
237             cs_error(link->handle, DeregisterClient, ret);
238     }
239
240     /* Unlink device structure and free it */
241     *linkp = link->next;
242     kfree(info);
243
244 } /* teles_detach */
245
246 /*======================================================================
247
248     teles_cs_config() is scheduled to run after a CARD_INSERTION event
249     is received, to configure the PCMCIA socket, and to make the
250     device available to the system.
251
252 ======================================================================*/
253 static int get_tuple(client_handle_t handle, tuple_t *tuple,
254                      cisparse_t *parse)
255 {
256     int i = pcmcia_get_tuple_data(handle, tuple);
257     if (i != CS_SUCCESS) return i;
258     return pcmcia_parse_tuple(handle, tuple, parse);
259 }
260
261 static int first_tuple(client_handle_t handle, tuple_t *tuple,
262                      cisparse_t *parse)
263 {
264     int i = pcmcia_get_first_tuple(handle, tuple);
265     if (i != CS_SUCCESS) return i;
266     return get_tuple(handle, tuple, parse);
267 }
268
269 static int next_tuple(client_handle_t handle, tuple_t *tuple,
270                      cisparse_t *parse)
271 {
272     int i = pcmcia_get_next_tuple(handle, tuple);
273     if (i != CS_SUCCESS) return i;
274     return get_tuple(handle, tuple, parse);
275 }
276
277 static void teles_cs_config(dev_link_t *link)
278 {
279     client_handle_t handle;
280     tuple_t tuple;
281     cisparse_t parse;
282     local_info_t *dev;
283     int i, j, last_fn;
284     u_short buf[128];
285     cistpl_cftable_entry_t *cf = &parse.cftable_entry;
286     IsdnCard_t icard;
287
288     DEBUG(0, "teles_config(0x%p)\n", link);
289     handle = link->handle;
290     dev = link->priv;
291
292     /*
293        This reads the card's CONFIG tuple to find its configuration
294        registers.
295     */
296     tuple.DesiredTuple = CISTPL_CONFIG;
297     tuple.TupleData = (cisdata_t *)buf;
298     tuple.TupleDataMax = 255;
299     tuple.TupleOffset = 0;
300     tuple.Attributes = 0;
301     i = first_tuple(handle, &tuple, &parse);
302     if (i != CS_SUCCESS) {
303         last_fn = ParseTuple;
304         goto cs_failed;
305     }
306     link->conf.ConfigBase = parse.config.base;
307     link->conf.Present = parse.config.rmask[0];
308
309     /* Configure card */
310     link->state |= DEV_CONFIG;
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) && cf->io.win[0].base) {
319             printk(KERN_INFO "(teles_cs: looks like the 96 model)\n");
320             link->conf.ConfigIndex = cf->index;
321             link->io.BasePort1 = cf->io.win[0].base;
322             i = pcmcia_request_io(link->handle, &link->io);
323             if (i == CS_SUCCESS) break;
324         } else {
325           printk(KERN_INFO "(teles_cs: looks like the 97 model)\n");
326           link->conf.ConfigIndex = cf->index;
327           for (i = 0, j = 0x2f0; j > 0x100; j -= 0x10) {
328             link->io.BasePort1 = j;
329             i = pcmcia_request_io(link->handle, &link->io);
330             if (i == CS_SUCCESS) break;
331           }
332           break;
333         }
334         i = next_tuple(handle, &tuple, &parse);
335     }
336
337     if (i != CS_SUCCESS) {
338         last_fn = RequestIO;
339         goto cs_failed;
340     }
341
342     i = pcmcia_request_irq(link->handle, &link->irq);
343     if (i != CS_SUCCESS) {
344         link->irq.AssignedIRQ = 0;
345         last_fn = RequestIRQ;
346         goto cs_failed;
347     }
348
349     i = pcmcia_request_configuration(link->handle, &link->conf);
350     if (i != CS_SUCCESS) {
351       last_fn = RequestConfiguration;
352       goto cs_failed;
353     }
354
355     /* At this point, the dev_node_t structure(s) should be
356        initialized and arranged in a linked list at link->dev. *//*  */
357     sprintf(dev->node.dev_name, "teles");
358     dev->node.major = dev->node.minor = 0x0;
359
360     link->dev = &dev->node;
361
362     /* Finally, report what we've done */
363     printk(KERN_INFO "%s: index 0x%02x: Vcc %d.%d",
364            dev->node.dev_name, link->conf.ConfigIndex,
365            link->conf.Vcc/10, link->conf.Vcc%10);
366     if (link->conf.Vpp1)
367         printk(", Vpp %d.%d", link->conf.Vpp1/10, link->conf.Vpp1%10);
368     if (link->conf.Attributes & CONF_ENABLE_IRQ)
369         printk(", irq %d", link->irq.AssignedIRQ);
370     if (link->io.NumPorts1)
371         printk(", io 0x%04x-0x%04x", link->io.BasePort1,
372                link->io.BasePort1+link->io.NumPorts1-1);
373     if (link->io.NumPorts2)
374         printk(" & 0x%04x-0x%04x", link->io.BasePort2,
375                link->io.BasePort2+link->io.NumPorts2-1);
376     printk("\n");
377
378     link->state &= ~DEV_CONFIG_PENDING;
379
380     icard.para[0] = link->irq.AssignedIRQ;
381     icard.para[1] = link->io.BasePort1;
382     icard.protocol = protocol;
383     icard.typ = ISDN_CTYPE_TELESPCMCIA;
384     
385     i = hisax_init_pcmcia(link, &(((local_info_t*)link->priv)->busy), &icard);
386     if (i < 0) {
387         printk(KERN_ERR "teles_cs: failed to initialize Teles PCMCIA %d at i/o %#x\n",
388                 i, link->io.BasePort1);
389         teles_cs_release(link);
390     } else
391         ((local_info_t*)link->priv)->cardnr = i;
392
393     return;
394 cs_failed:
395     cs_error(link->handle, last_fn, i);
396     teles_cs_release(link);
397 } /* teles_cs_config */
398
399 /*======================================================================
400
401     After a card is removed, teles_cs_release() will unregister the net
402     device, and release the PCMCIA configuration.  If the device is
403     still open, this will be postponed until it is closed.
404
405 ======================================================================*/
406
407 static void teles_cs_release(dev_link_t *link)
408 {
409     local_info_t *local = link->priv;
410
411     DEBUG(0, "teles_cs_release(0x%p)\n", link);
412
413     if (local) {
414         if (local->cardnr >= 0) {
415             /* no unregister function with hisax */
416             HiSax_closecard(local->cardnr);
417         }
418     }
419     /* Unlink the device chain */
420     link->dev = NULL;
421
422     /* Don't bother checking to see if these succeed or not */
423     if (link->win)
424         pcmcia_release_window(link->win);
425     pcmcia_release_configuration(link->handle);
426     pcmcia_release_io(link->handle, &link->io);
427     pcmcia_release_irq(link->handle, &link->irq);
428     link->state &= ~DEV_CONFIG;
429 } /* teles_cs_release */
430
431 /*======================================================================
432
433     The card status event handler.  Mostly, this schedules other
434     stuff to run after an event is received.  A CARD_REMOVAL event
435     also sets some flags to discourage the net drivers from trying
436     to talk to the card any more.
437
438     When a CARD_REMOVAL event is received, we immediately set a flag
439     to block future accesses to this device.  All the functions that
440     actually access the device should check this flag to make sure
441     the card is still present.
442
443 ======================================================================*/
444
445 static int teles_cs_event(event_t event, int priority,
446                           event_callback_args_t *args)
447 {
448     dev_link_t *link = args->client_data;
449     local_info_t *dev = link->priv;
450
451     DEBUG(1, "teles_cs_event(%d)\n", event);
452
453     switch (event) {
454     case CS_EVENT_CARD_REMOVAL:
455         link->state &= ~DEV_PRESENT;
456         if (link->state & DEV_CONFIG) {
457             ((local_info_t*)link->priv)->busy = 1;
458             teles_cs_release(link);
459         }
460         break;
461     case CS_EVENT_CARD_INSERTION:
462         link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
463         teles_cs_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         /* Mark the device as stopped, to block IO until later */
470         dev->busy = 1;
471         if (link->state & DEV_CONFIG)
472             pcmcia_release_configuration(link->handle);
473         break;
474     case CS_EVENT_PM_RESUME:
475         link->state &= ~DEV_SUSPEND;
476         /* Fall through... */
477     case CS_EVENT_CARD_RESET:
478         if (link->state & DEV_CONFIG)
479             pcmcia_request_configuration(link->handle, &link->conf);
480         dev->busy = 0;
481         break;
482     }
483     return 0;
484 } /* teles_cs_event */
485
486 static struct pcmcia_device_id teles_ids[] = {
487         PCMCIA_DEVICE_PROD_ID12("TELES", "S0/PC", 0x67b50eae, 0xe9e70119),
488         PCMCIA_DEVICE_NULL,
489 };
490 MODULE_DEVICE_TABLE(pcmcia, teles_ids);
491
492 static struct pcmcia_driver teles_cs_driver = {
493         .owner          = THIS_MODULE,
494         .drv            = {
495                 .name   = "teles_cs",
496         },
497         .attach         = teles_attach,
498         .event          = teles_cs_event,
499         .detach         = teles_detach,
500         .id_table       = teles_ids,
501 };
502
503 static int __init init_teles_cs(void)
504 {
505         return pcmcia_register_driver(&teles_cs_driver);
506 }
507
508 static void __exit exit_teles_cs(void)
509 {
510         pcmcia_unregister_driver(&teles_cs_driver);
511         BUG_ON(dev_list != NULL);
512 }
513
514 module_init(init_teles_cs);
515 module_exit(exit_teles_cs);