[PATCH] pcmcia: embed dev_link_t into struct pcmcia_device
[linux-3.10.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
81 /*
82    The attach() and detach() entry points are used to create and destroy
83    "instances" of the driver, where each instance represents everything
84    needed to manage one actual PCMCIA card.
85 */
86
87 static void teles_detach(struct pcmcia_device *p_dev);
88
89 /*
90    A linked list of "instances" of the teles_cs device.  Each actual
91    PCMCIA card corresponds to one device instance, and is described
92    by one dev_link_t structure (defined in ds.h).
93
94    You may not want to use a linked list for this -- for example, the
95    memory card driver uses an array of dev_link_t pointers, where minor
96    device numbers are used to derive the corresponding array index.
97 */
98
99 /*
100    A driver needs to provide a dev_node_t structure for each device
101    on a card.  In some cases, there is only one device per card (for
102    example, ethernet cards, modems).  In other cases, there may be
103    many actual or logical devices (SCSI adapters, memory cards with
104    multiple partitions).  The dev_node_t structures need to be kept
105    in a linked list starting at the 'dev' field of a dev_link_t
106    structure.  We allocate them in the card's private data structure,
107    because they generally shouldn't be allocated dynamically.
108    In this case, we also provide a flag to indicate if a device is
109    "stopped" due to a power management event, or card ejection.  The
110    device IO routines can use a flag like this to throttle IO to a
111    card that is not ready to accept it.
112 */
113
114 typedef struct local_info_t {
115         struct pcmcia_device    *p_dev;
116     dev_node_t          node;
117     int                 busy;
118     int                 cardnr;
119 } local_info_t;
120
121 /*======================================================================
122
123     teles_attach() creates an "instance" of the driver, allocatingx
124     local data structures for one device.  The device is registered
125     with Card Services.
126
127     The dev_link structure is initialized, but we don't actually
128     configure the card at this point -- we wait until we receive a
129     card insertion event.
130
131 ======================================================================*/
132
133 static int teles_attach(struct pcmcia_device *p_dev)
134 {
135     local_info_t *local;
136     dev_link_t *link = dev_to_instance(p_dev);
137
138     DEBUG(0, "teles_attach()\n");
139
140     /* Allocate space for private device-specific data */
141     local = kmalloc(sizeof(local_info_t), GFP_KERNEL);
142     if (!local) return -ENOMEM;
143     memset(local, 0, sizeof(local_info_t));
144     local->cardnr = -1;
145
146     local->p_dev = p_dev;
147     link->priv = local;
148
149     /* Interrupt setup */
150     link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED;
151     link->irq.IRQInfo1 = IRQ_LEVEL_ID|IRQ_SHARE_ID;
152     link->irq.Handler = NULL;
153
154     /*
155       General socket configuration defaults can go here.  In this
156       client, we assume very little, and rely on the CIS for almost
157       everything.  In most clients, many details (i.e., number, sizes,
158       and attributes of IO windows) are fixed by the nature of the
159       device, and can be hard-wired here.
160     */
161     link->io.NumPorts1 = 96;
162     link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
163     link->io.IOAddrLines = 5;
164
165     link->conf.Attributes = CONF_ENABLE_IRQ;
166     link->conf.IntType = INT_MEMORY_AND_IO;
167
168     link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
169     teles_cs_config(link);
170
171     return 0;
172 } /* teles_attach */
173
174 /*======================================================================
175
176     This deletes a driver "instance".  The device is de-registered
177     with Card Services.  If it has been released, all local data
178     structures are freed.  Otherwise, the structures will be freed
179     when the device is released.
180
181 ======================================================================*/
182
183 static void teles_detach(struct pcmcia_device *p_dev)
184 {
185     dev_link_t *link = dev_to_instance(p_dev);
186     local_info_t *info = link->priv;
187
188     DEBUG(0, "teles_detach(0x%p)\n", link);
189
190     if (link->state & DEV_CONFIG) {
191             info->busy = 1;
192             teles_cs_release(link);
193     }
194
195     kfree(info);
196
197 } /* teles_detach */
198
199 /*======================================================================
200
201     teles_cs_config() is scheduled to run after a CARD_INSERTION event
202     is received, to configure the PCMCIA socket, and to make the
203     device available to the system.
204
205 ======================================================================*/
206 static int get_tuple(client_handle_t handle, tuple_t *tuple,
207                      cisparse_t *parse)
208 {
209     int i = pcmcia_get_tuple_data(handle, tuple);
210     if (i != CS_SUCCESS) return i;
211     return pcmcia_parse_tuple(handle, tuple, parse);
212 }
213
214 static int first_tuple(client_handle_t handle, tuple_t *tuple,
215                      cisparse_t *parse)
216 {
217     int i = pcmcia_get_first_tuple(handle, tuple);
218     if (i != CS_SUCCESS) return i;
219     return get_tuple(handle, tuple, parse);
220 }
221
222 static int next_tuple(client_handle_t handle, tuple_t *tuple,
223                      cisparse_t *parse)
224 {
225     int i = pcmcia_get_next_tuple(handle, tuple);
226     if (i != CS_SUCCESS) return i;
227     return get_tuple(handle, tuple, parse);
228 }
229
230 static void teles_cs_config(dev_link_t *link)
231 {
232     client_handle_t handle;
233     tuple_t tuple;
234     cisparse_t parse;
235     local_info_t *dev;
236     int i, j, last_fn;
237     u_short buf[128];
238     cistpl_cftable_entry_t *cf = &parse.cftable_entry;
239     IsdnCard_t icard;
240
241     DEBUG(0, "teles_config(0x%p)\n", link);
242     handle = link->handle;
243     dev = link->priv;
244
245     /*
246        This reads the card's CONFIG tuple to find its configuration
247        registers.
248     */
249     tuple.DesiredTuple = CISTPL_CONFIG;
250     tuple.TupleData = (cisdata_t *)buf;
251     tuple.TupleDataMax = 255;
252     tuple.TupleOffset = 0;
253     tuple.Attributes = 0;
254     i = first_tuple(handle, &tuple, &parse);
255     if (i != CS_SUCCESS) {
256         last_fn = ParseTuple;
257         goto cs_failed;
258     }
259     link->conf.ConfigBase = parse.config.base;
260     link->conf.Present = parse.config.rmask[0];
261
262     /* Configure card */
263     link->state |= DEV_CONFIG;
264
265     tuple.TupleData = (cisdata_t *)buf;
266     tuple.TupleOffset = 0; tuple.TupleDataMax = 255;
267     tuple.Attributes = 0;
268     tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
269     i = first_tuple(handle, &tuple, &parse);
270     while (i == CS_SUCCESS) {
271         if ( (cf->io.nwin > 0) && cf->io.win[0].base) {
272             printk(KERN_INFO "(teles_cs: looks like the 96 model)\n");
273             link->conf.ConfigIndex = cf->index;
274             link->io.BasePort1 = cf->io.win[0].base;
275             i = pcmcia_request_io(link->handle, &link->io);
276             if (i == CS_SUCCESS) break;
277         } else {
278           printk(KERN_INFO "(teles_cs: looks like the 97 model)\n");
279           link->conf.ConfigIndex = cf->index;
280           for (i = 0, j = 0x2f0; j > 0x100; j -= 0x10) {
281             link->io.BasePort1 = j;
282             i = pcmcia_request_io(link->handle, &link->io);
283             if (i == CS_SUCCESS) break;
284           }
285           break;
286         }
287         i = next_tuple(handle, &tuple, &parse);
288     }
289
290     if (i != CS_SUCCESS) {
291         last_fn = RequestIO;
292         goto cs_failed;
293     }
294
295     i = pcmcia_request_irq(link->handle, &link->irq);
296     if (i != CS_SUCCESS) {
297         link->irq.AssignedIRQ = 0;
298         last_fn = RequestIRQ;
299         goto cs_failed;
300     }
301
302     i = pcmcia_request_configuration(link->handle, &link->conf);
303     if (i != CS_SUCCESS) {
304       last_fn = RequestConfiguration;
305       goto cs_failed;
306     }
307
308     /* At this point, the dev_node_t structure(s) should be
309        initialized and arranged in a linked list at link->dev. *//*  */
310     sprintf(dev->node.dev_name, "teles");
311     dev->node.major = dev->node.minor = 0x0;
312
313     link->dev_node = &dev->node;
314
315     /* Finally, report what we've done */
316     printk(KERN_INFO "%s: index 0x%02x:",
317            dev->node.dev_name, link->conf.ConfigIndex);
318     if (link->conf.Attributes & CONF_ENABLE_IRQ)
319         printk(", irq %d", link->irq.AssignedIRQ);
320     if (link->io.NumPorts1)
321         printk(", io 0x%04x-0x%04x", link->io.BasePort1,
322                link->io.BasePort1+link->io.NumPorts1-1);
323     if (link->io.NumPorts2)
324         printk(" & 0x%04x-0x%04x", link->io.BasePort2,
325                link->io.BasePort2+link->io.NumPorts2-1);
326     printk("\n");
327
328     link->state &= ~DEV_CONFIG_PENDING;
329
330     icard.para[0] = link->irq.AssignedIRQ;
331     icard.para[1] = link->io.BasePort1;
332     icard.protocol = protocol;
333     icard.typ = ISDN_CTYPE_TELESPCMCIA;
334     
335     i = hisax_init_pcmcia(link, &(((local_info_t*)link->priv)->busy), &icard);
336     if (i < 0) {
337         printk(KERN_ERR "teles_cs: failed to initialize Teles PCMCIA %d at i/o %#x\n",
338                 i, link->io.BasePort1);
339         teles_cs_release(link);
340     } else
341         ((local_info_t*)link->priv)->cardnr = i;
342
343     return;
344 cs_failed:
345     cs_error(link->handle, last_fn, i);
346     teles_cs_release(link);
347 } /* teles_cs_config */
348
349 /*======================================================================
350
351     After a card is removed, teles_cs_release() will unregister the net
352     device, and release the PCMCIA configuration.  If the device is
353     still open, this will be postponed until it is closed.
354
355 ======================================================================*/
356
357 static void teles_cs_release(dev_link_t *link)
358 {
359     local_info_t *local = link->priv;
360
361     DEBUG(0, "teles_cs_release(0x%p)\n", link);
362
363     if (local) {
364         if (local->cardnr >= 0) {
365             /* no unregister function with hisax */
366             HiSax_closecard(local->cardnr);
367         }
368     }
369
370     pcmcia_disable_device(link->handle);
371 } /* teles_cs_release */
372
373 static int teles_suspend(struct pcmcia_device *p_dev)
374 {
375         dev_link_t *link = dev_to_instance(p_dev);
376         local_info_t *dev = link->priv;
377
378         dev->busy = 1;
379
380         return 0;
381 }
382
383 static int teles_resume(struct pcmcia_device *p_dev)
384 {
385         dev_link_t *link = dev_to_instance(p_dev);
386         local_info_t *dev = link->priv;
387
388         dev->busy = 0;
389
390         return 0;
391 }
392
393
394 static struct pcmcia_device_id teles_ids[] = {
395         PCMCIA_DEVICE_PROD_ID12("TELES", "S0/PC", 0x67b50eae, 0xe9e70119),
396         PCMCIA_DEVICE_NULL,
397 };
398 MODULE_DEVICE_TABLE(pcmcia, teles_ids);
399
400 static struct pcmcia_driver teles_cs_driver = {
401         .owner          = THIS_MODULE,
402         .drv            = {
403                 .name   = "teles_cs",
404         },
405         .probe          = teles_attach,
406         .remove         = teles_detach,
407         .id_table       = teles_ids,
408         .suspend        = teles_suspend,
409         .resume         = teles_resume,
410 };
411
412 static int __init init_teles_cs(void)
413 {
414         return pcmcia_register_driver(&teles_cs_driver);
415 }
416
417 static void __exit exit_teles_cs(void)
418 {
419         pcmcia_unregister_driver(&teles_cs_driver);
420 }
421
422 module_init(init_teles_cs);
423 module_exit(exit_teles_cs);