Merge tag 'r8169-upstream-20061204-00' of git://electric-eye.fr.zoreil.com/home/romie...
[linux-2.6] / drivers / isdn / hisax / sedlbauer_cs.c
1 /*======================================================================
2
3     A Sedlbauer PCMCIA client driver
4
5     This driver is for the Sedlbauer Speed Star and Speed Star II, 
6     which are ISDN PCMCIA Cards.
7     
8     The contents of this file are subject to the Mozilla Public
9     License Version 1.1 (the "License"); you may not use this file
10     except in compliance with the License. You may obtain a copy of
11     the License at http://www.mozilla.org/MPL/
12
13     Software distributed under the License is distributed on an "AS
14     IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
15     implied. See the License for the specific language governing
16     rights and limitations under the License.
17
18     The initial developer of the original code is David A. Hinds
19     <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
20     are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
21
22     Modifications from dummy_cs.c are Copyright (C) 1999-2001 Marcus Niemann
23     <maniemann@users.sourceforge.net>. All Rights Reserved.
24
25     Alternatively, the contents of this file may be used under the
26     terms of the GNU General Public License version 2 (the "GPL"), in
27     which case the provisions of the GPL are applicable instead of the
28     above.  If you wish to allow the use of your version of this file
29     only under the terms of the GPL and not to allow others to use
30     your version of this file under the MPL, indicate your decision
31     by deleting the provisions above and replace them with the notice
32     and other provisions required by the GPL.  If you do not delete
33     the provisions above, a recipient may use your version of this
34     file under either the MPL or the GPL.
35     
36 ======================================================================*/
37
38 #include <linux/kernel.h>
39 #include <linux/module.h>
40 #include <linux/init.h>
41 #include <linux/sched.h>
42 #include <linux/ptrace.h>
43 #include <linux/slab.h>
44 #include <linux/string.h>
45 #include <linux/timer.h>
46 #include <linux/ioport.h>
47 #include <asm/io.h>
48 #include <asm/system.h>
49
50 #include <pcmcia/cs_types.h>
51 #include <pcmcia/cs.h>
52 #include <pcmcia/cistpl.h>
53 #include <pcmcia/cisreg.h>
54 #include <pcmcia/ds.h>
55 #include "hisax_cfg.h"
56
57 MODULE_DESCRIPTION("ISDN4Linux: PCMCIA client driver for Sedlbauer cards");
58 MODULE_AUTHOR("Marcus Niemann");
59 MODULE_LICENSE("Dual MPL/GPL");
60
61 /*
62    All the PCMCIA modules use PCMCIA_DEBUG to control debugging.  If
63    you do not define PCMCIA_DEBUG at all, all the debug code will be
64    left out.  If you compile with PCMCIA_DEBUG=0, the debug code will
65    be present but disabled -- but it can then be enabled for specific
66    modules at load time with a 'pc_debug=#' option to insmod.
67 */
68
69 #ifdef PCMCIA_DEBUG
70 static int pc_debug = PCMCIA_DEBUG;
71 module_param(pc_debug, int, 0);
72 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args); 
73 static char *version =
74 "sedlbauer_cs.c 1.1a 2001/01/28 15:04:04 (M.Niemann)";
75 #else
76 #define DEBUG(n, args...)
77 #endif
78
79
80 /*====================================================================*/
81
82 /* Parameters that can be set with 'insmod' */
83
84 static int protocol = 2;        /* EURO-ISDN Default */
85 module_param(protocol, int, 0);
86
87 /*====================================================================*/
88
89 /*
90    The event() function is this driver's Card Services event handler.
91    It will be called by Card Services when an appropriate card status
92    event is received.  The config() and release() entry points are
93    used to configure or release a socket, in response to card
94    insertion and ejection events.  They are invoked from the sedlbauer
95    event handler. 
96 */
97
98 static int sedlbauer_config(struct pcmcia_device *link);
99 static void sedlbauer_release(struct pcmcia_device *link);
100
101 /*
102    The attach() and detach() entry points are used to create and destroy
103    "instances" of the driver, where each instance represents everything
104    needed to manage one actual PCMCIA card.
105 */
106
107 static void sedlbauer_detach(struct pcmcia_device *p_dev);
108
109 /*
110    You'll also need to prototype all the functions that will actually
111    be used to talk to your device.  See 'memory_cs' for a good example
112    of a fully self-sufficient driver; the other drivers rely more or
113    less on other parts of the kernel.
114 */
115
116 /*
117    A driver needs to provide a dev_node_t structure for each device
118    on a card.  In some cases, there is only one device per card (for
119    example, ethernet cards, modems).  In other cases, there may be
120    many actual or logical devices (SCSI adapters, memory cards with
121    multiple partitions).  The dev_node_t structures need to be kept
122    in a linked list starting at the 'dev' field of a struct pcmcia_device
123    structure.  We allocate them in the card's private data structure,
124    because they generally shouldn't be allocated dynamically.
125
126    In this case, we also provide a flag to indicate if a device is
127    "stopped" due to a power management event, or card ejection.  The
128    device IO routines can use a flag like this to throttle IO to a
129    card that is not ready to accept it.
130 */
131    
132 typedef struct local_info_t {
133         struct pcmcia_device    *p_dev;
134     dev_node_t          node;
135     int                 stop;
136     int                 cardnr;
137 } local_info_t;
138
139 /*======================================================================
140
141     sedlbauer_attach() creates an "instance" of the driver, allocating
142     local data structures for one device.  The device is registered
143     with Card Services.
144
145     The dev_link structure is initialized, but we don't actually
146     configure the card at this point -- we wait until we receive a
147     card insertion event.
148     
149 ======================================================================*/
150
151 static int sedlbauer_probe(struct pcmcia_device *link)
152 {
153     local_info_t *local;
154
155     DEBUG(0, "sedlbauer_attach()\n");
156
157     /* Allocate space for private device-specific data */
158     local = kmalloc(sizeof(local_info_t), GFP_KERNEL);
159     if (!local) return -ENOMEM;
160     memset(local, 0, sizeof(local_info_t));
161     local->cardnr = -1;
162
163     local->p_dev = link;
164     link->priv = local;
165
166     /* Interrupt setup */
167     link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED;
168     link->irq.IRQInfo1 = IRQ_LEVEL_ID;
169     link->irq.Handler = NULL;
170
171     /*
172       General socket configuration defaults can go here.  In this
173       client, we assume very little, and rely on the CIS for almost
174       everything.  In most clients, many details (i.e., number, sizes,
175       and attributes of IO windows) are fixed by the nature of the
176       device, and can be hard-wired here.
177     */
178
179     /* from old sedl_cs 
180     */
181     /* The io structure describes IO port mapping */
182     link->io.NumPorts1 = 8;
183     link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
184     link->io.IOAddrLines = 3;
185
186     link->conf.Attributes = 0;
187     link->conf.IntType = INT_MEMORY_AND_IO;
188
189     return sedlbauer_config(link);
190 } /* sedlbauer_attach */
191
192 /*======================================================================
193
194     This deletes a driver "instance".  The device is de-registered
195     with Card Services.  If it has been released, all local data
196     structures are freed.  Otherwise, the structures will be freed
197     when the device is released.
198
199 ======================================================================*/
200
201 static void sedlbauer_detach(struct pcmcia_device *link)
202 {
203         DEBUG(0, "sedlbauer_detach(0x%p)\n", link);
204
205         ((local_info_t *)link->priv)->stop = 1;
206         sedlbauer_release(link);
207
208         /* This points to the parent local_info_t struct */
209         kfree(link->priv);
210 } /* sedlbauer_detach */
211
212 /*======================================================================
213
214     sedlbauer_config() is scheduled to run after a CARD_INSERTION event
215     is received, to configure the PCMCIA socket, and to make the
216     device available to the system.
217     
218 ======================================================================*/
219 #define CS_CHECK(fn, ret) \
220 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
221
222 static int sedlbauer_config(struct pcmcia_device *link)
223 {
224     local_info_t *dev = link->priv;
225     tuple_t tuple;
226     cisparse_t parse;
227     int last_fn, last_ret;
228     u8 buf[64];
229     config_info_t conf;
230     win_req_t req;
231     memreq_t map;
232     IsdnCard_t  icard;
233
234     DEBUG(0, "sedlbauer_config(0x%p)\n", link);
235
236     tuple.Attributes = 0;
237     tuple.TupleData = buf;
238     tuple.TupleDataMax = sizeof(buf);
239     tuple.TupleOffset = 0;
240
241     CS_CHECK(GetConfigurationInfo, pcmcia_get_configuration_info(link, &conf));
242
243     /*
244       In this loop, we scan the CIS for configuration table entries,
245       each of which describes a valid card configuration, including
246       voltage, IO window, memory window, and interrupt settings.
247
248       We make no assumptions about the card to be configured: we use
249       just the information available in the CIS.  In an ideal world,
250       this would work for any PCMCIA card, but it requires a complete
251       and accurate CIS.  In practice, a driver usually "knows" most of
252       these things without consulting the CIS, and most client drivers
253       will only use the CIS to fill in implementation-defined details.
254     */
255     tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
256     CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
257     while (1) {
258         cistpl_cftable_entry_t dflt = { 0 };
259         cistpl_cftable_entry_t *cfg = &(parse.cftable_entry);
260         if (pcmcia_get_tuple_data(link, &tuple) != 0 ||
261                 pcmcia_parse_tuple(link, &tuple, &parse) != 0)
262             goto next_entry;
263
264         if (cfg->flags & CISTPL_CFTABLE_DEFAULT) dflt = *cfg;
265         if (cfg->index == 0) goto next_entry;
266         link->conf.ConfigIndex = cfg->index;
267         
268         /* Does this card need audio output? */
269         if (cfg->flags & CISTPL_CFTABLE_AUDIO) {
270             link->conf.Attributes |= CONF_ENABLE_SPKR;
271             link->conf.Status = CCSR_AUDIO_ENA;
272         }
273         
274         /* Use power settings for Vcc and Vpp if present */
275         /*  Note that the CIS values need to be rescaled */
276         if (cfg->vcc.present & (1<<CISTPL_POWER_VNOM)) {
277             if (conf.Vcc != cfg->vcc.param[CISTPL_POWER_VNOM]/10000)
278                 goto next_entry;
279         } else if (dflt.vcc.present & (1<<CISTPL_POWER_VNOM)) {
280             if (conf.Vcc != dflt.vcc.param[CISTPL_POWER_VNOM]/10000)
281                 goto next_entry;
282         }
283             
284         if (cfg->vpp1.present & (1<<CISTPL_POWER_VNOM))
285             link->conf.Vpp =
286                 cfg->vpp1.param[CISTPL_POWER_VNOM]/10000;
287         else if (dflt.vpp1.present & (1<<CISTPL_POWER_VNOM))
288             link->conf.Vpp =
289                 dflt.vpp1.param[CISTPL_POWER_VNOM]/10000;
290         
291         /* Do we need to allocate an interrupt? */
292         if (cfg->irq.IRQInfo1 || dflt.irq.IRQInfo1)
293             link->conf.Attributes |= CONF_ENABLE_IRQ;
294         
295         /* IO window settings */
296         link->io.NumPorts1 = link->io.NumPorts2 = 0;
297         if ((cfg->io.nwin > 0) || (dflt.io.nwin > 0)) {
298             cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt.io;
299             link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
300             if (!(io->flags & CISTPL_IO_8BIT))
301                 link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
302             if (!(io->flags & CISTPL_IO_16BIT))
303                 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
304 /* new in dummy.cs 2001/01/28 MN 
305             link->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
306 */
307             link->io.BasePort1 = io->win[0].base;
308             link->io.NumPorts1 = io->win[0].len;
309             if (io->nwin > 1) {
310                 link->io.Attributes2 = link->io.Attributes1;
311                 link->io.BasePort2 = io->win[1].base;
312                 link->io.NumPorts2 = io->win[1].len;
313             }
314             /* This reserves IO space but doesn't actually enable it */
315             if (pcmcia_request_io(link, &link->io) != 0)
316                 goto next_entry;
317         }
318
319         /*
320           Now set up a common memory window, if needed.  There is room
321           in the struct pcmcia_device structure for one memory window handle,
322           but if the base addresses need to be saved, or if multiple
323           windows are needed, the info should go in the private data
324           structure for this device.
325
326           Note that the memory window base is a physical address, and
327           needs to be mapped to virtual space with ioremap() before it
328           is used.
329         */
330         if ((cfg->mem.nwin > 0) || (dflt.mem.nwin > 0)) {
331             cistpl_mem_t *mem =
332                 (cfg->mem.nwin) ? &cfg->mem : &dflt.mem;
333             req.Attributes = WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM;
334             req.Attributes |= WIN_ENABLE;
335             req.Base = mem->win[0].host_addr;
336             req.Size = mem->win[0].len;
337 /* new in dummy.cs 2001/01/28 MN 
338             if (req.Size < 0x1000)
339                 req.Size = 0x1000;
340 */
341             req.AccessSpeed = 0;
342             if (pcmcia_request_window(&link, &req, &link->win) != 0)
343                 goto next_entry;
344             map.Page = 0; map.CardOffset = mem->win[0].card_addr;
345             if (pcmcia_map_mem_page(link->win, &map) != 0)
346                 goto next_entry;
347         }
348         /* If we got this far, we're cool! */
349         break;
350
351     next_entry:
352         CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(link, &tuple));
353     }
354
355     /*
356        Allocate an interrupt line.  Note that this does not assign a
357        handler to the interrupt, unless the 'Handler' member of the
358        irq structure is initialized.
359     */
360     if (link->conf.Attributes & CONF_ENABLE_IRQ)
361         CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
362         
363     /*
364        This actually configures the PCMCIA socket -- setting up
365        the I/O windows and the interrupt mapping, and putting the
366        card and host interface into "Memory and IO" mode.
367     */
368     CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
369
370     /*
371       At this point, the dev_node_t structure(s) need to be
372       initialized and arranged in a linked list at link->dev.
373     */
374     sprintf(dev->node.dev_name, "sedlbauer");
375     dev->node.major = dev->node.minor = 0;
376     link->dev_node = &dev->node;
377
378     /* Finally, report what we've done */
379     printk(KERN_INFO "%s: index 0x%02x:",
380            dev->node.dev_name, link->conf.ConfigIndex);
381     if (link->conf.Vpp)
382         printk(", Vpp %d.%d", link->conf.Vpp/10, link->conf.Vpp%10);
383     if (link->conf.Attributes & CONF_ENABLE_IRQ)
384         printk(", irq %d", link->irq.AssignedIRQ);
385     if (link->io.NumPorts1)
386         printk(", io 0x%04x-0x%04x", link->io.BasePort1,
387                link->io.BasePort1+link->io.NumPorts1-1);
388     if (link->io.NumPorts2)
389         printk(" & 0x%04x-0x%04x", link->io.BasePort2,
390                link->io.BasePort2+link->io.NumPorts2-1);
391     if (link->win)
392         printk(", mem 0x%06lx-0x%06lx", req.Base,
393                req.Base+req.Size-1);
394     printk("\n");
395
396     icard.para[0] = link->irq.AssignedIRQ;
397     icard.para[1] = link->io.BasePort1;
398     icard.protocol = protocol;
399     icard.typ = ISDN_CTYPE_SEDLBAUER_PCMCIA;
400     
401     last_ret = hisax_init_pcmcia(link, &(((local_info_t*)link->priv)->stop), &icard);
402     if (last_ret < 0) {
403         printk(KERN_ERR "sedlbauer_cs: failed to initialize SEDLBAUER PCMCIA %d at i/o %#x\n",
404                 last_ret, link->io.BasePort1);
405         sedlbauer_release(link);
406         return -ENODEV;
407     } else
408         ((local_info_t*)link->priv)->cardnr = last_ret;
409
410     return 0;
411
412 cs_failed:
413     cs_error(link, last_fn, last_ret);
414     sedlbauer_release(link);
415     return -ENODEV;
416
417 } /* sedlbauer_config */
418
419 /*======================================================================
420
421     After a card is removed, sedlbauer_release() will unregister the
422     device, and release the PCMCIA configuration.  If the device is
423     still open, this will be postponed until it is closed.
424     
425 ======================================================================*/
426
427 static void sedlbauer_release(struct pcmcia_device *link)
428 {
429     local_info_t *local = link->priv;
430     DEBUG(0, "sedlbauer_release(0x%p)\n", link);
431
432     if (local) {
433         if (local->cardnr >= 0) {
434             /* no unregister function with hisax */
435             HiSax_closecard(local->cardnr);
436         }
437     }
438
439     pcmcia_disable_device(link);
440 } /* sedlbauer_release */
441
442 static int sedlbauer_suspend(struct pcmcia_device *link)
443 {
444         local_info_t *dev = link->priv;
445
446         dev->stop = 1;
447
448         return 0;
449 }
450
451 static int sedlbauer_resume(struct pcmcia_device *link)
452 {
453         local_info_t *dev = link->priv;
454
455         dev->stop = 0;
456
457         return 0;
458 }
459
460
461 static struct pcmcia_device_id sedlbauer_ids[] = {
462         PCMCIA_DEVICE_PROD_ID123("SEDLBAUER", "speed star II", "V 3.1", 0x81fb79f5, 0xf3612e1d, 0x6b95c78a),
463         PCMCIA_DEVICE_PROD_ID123("SEDLBAUER", "ISDN-Adapter", "4D67", 0x81fb79f5, 0xe4e9bc12, 0x397b7e90),
464         PCMCIA_DEVICE_PROD_ID123("SEDLBAUER", "ISDN-Adapter", "4D98", 0x81fb79f5, 0xe4e9bc12, 0x2e5c7fce),
465         PCMCIA_DEVICE_PROD_ID123("SEDLBAUER", "ISDN-Adapter", " (C) 93-94 VK", 0x81fb79f5, 0xe4e9bc12, 0x8db143fe),
466         PCMCIA_DEVICE_PROD_ID123("SEDLBAUER", "ISDN-Adapter", " (c) 93-95 VK", 0x81fb79f5, 0xe4e9bc12, 0xb391ab4c),
467         PCMCIA_DEVICE_PROD_ID12("HST High Soft Tech GmbH", "Saphir II B", 0xd79e0b84, 0x21d083ae),
468 /*      PCMCIA_DEVICE_PROD_ID1234("SEDLBAUER", 0x81fb79f5), */ /* too generic*/
469         PCMCIA_DEVICE_NULL
470 };
471 MODULE_DEVICE_TABLE(pcmcia, sedlbauer_ids);
472
473 static struct pcmcia_driver sedlbauer_driver = {
474         .owner          = THIS_MODULE,
475         .drv            = {
476                 .name   = "sedlbauer_cs",
477         },
478         .probe          = sedlbauer_probe,
479         .remove         = sedlbauer_detach,
480         .id_table       = sedlbauer_ids,
481         .suspend        = sedlbauer_suspend,
482         .resume         = sedlbauer_resume,
483 };
484
485 static int __init init_sedlbauer_cs(void)
486 {
487         return pcmcia_register_driver(&sedlbauer_driver);
488 }
489
490 static void __exit exit_sedlbauer_cs(void)
491 {
492         pcmcia_unregister_driver(&sedlbauer_driver);
493 }
494
495 module_init(init_sedlbauer_cs);
496 module_exit(exit_sedlbauer_cs);