Merge master.kernel.org:/pub/scm/linux/kernel/git/davem/net-2.6
[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     /*
237        This reads the card's CONFIG tuple to find its configuration
238        registers.
239     */
240     tuple.DesiredTuple = CISTPL_CONFIG;
241     tuple.Attributes = 0;
242     tuple.TupleData = buf;
243     tuple.TupleDataMax = sizeof(buf);
244     tuple.TupleOffset = 0;
245     CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
246     CS_CHECK(GetTupleData, pcmcia_get_tuple_data(link, &tuple));
247     CS_CHECK(ParseTuple, pcmcia_parse_tuple(link, &tuple, &parse));
248     link->conf.ConfigBase = parse.config.base;
249     link->conf.Present = parse.config.rmask[0];
250
251     CS_CHECK(GetConfigurationInfo, pcmcia_get_configuration_info(link, &conf));
252
253     /*
254       In this loop, we scan the CIS for configuration table entries,
255       each of which describes a valid card configuration, including
256       voltage, IO window, memory window, and interrupt settings.
257
258       We make no assumptions about the card to be configured: we use
259       just the information available in the CIS.  In an ideal world,
260       this would work for any PCMCIA card, but it requires a complete
261       and accurate CIS.  In practice, a driver usually "knows" most of
262       these things without consulting the CIS, and most client drivers
263       will only use the CIS to fill in implementation-defined details.
264     */
265     tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
266     CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
267     while (1) {
268         cistpl_cftable_entry_t dflt = { 0 };
269         cistpl_cftable_entry_t *cfg = &(parse.cftable_entry);
270         if (pcmcia_get_tuple_data(link, &tuple) != 0 ||
271                 pcmcia_parse_tuple(link, &tuple, &parse) != 0)
272             goto next_entry;
273
274         if (cfg->flags & CISTPL_CFTABLE_DEFAULT) dflt = *cfg;
275         if (cfg->index == 0) goto next_entry;
276         link->conf.ConfigIndex = cfg->index;
277         
278         /* Does this card need audio output? */
279         if (cfg->flags & CISTPL_CFTABLE_AUDIO) {
280             link->conf.Attributes |= CONF_ENABLE_SPKR;
281             link->conf.Status = CCSR_AUDIO_ENA;
282         }
283         
284         /* Use power settings for Vcc and Vpp if present */
285         /*  Note that the CIS values need to be rescaled */
286         if (cfg->vcc.present & (1<<CISTPL_POWER_VNOM)) {
287             if (conf.Vcc != cfg->vcc.param[CISTPL_POWER_VNOM]/10000)
288                 goto next_entry;
289         } else if (dflt.vcc.present & (1<<CISTPL_POWER_VNOM)) {
290             if (conf.Vcc != dflt.vcc.param[CISTPL_POWER_VNOM]/10000)
291                 goto next_entry;
292         }
293             
294         if (cfg->vpp1.present & (1<<CISTPL_POWER_VNOM))
295             link->conf.Vpp =
296                 cfg->vpp1.param[CISTPL_POWER_VNOM]/10000;
297         else if (dflt.vpp1.present & (1<<CISTPL_POWER_VNOM))
298             link->conf.Vpp =
299                 dflt.vpp1.param[CISTPL_POWER_VNOM]/10000;
300         
301         /* Do we need to allocate an interrupt? */
302         if (cfg->irq.IRQInfo1 || dflt.irq.IRQInfo1)
303             link->conf.Attributes |= CONF_ENABLE_IRQ;
304         
305         /* IO window settings */
306         link->io.NumPorts1 = link->io.NumPorts2 = 0;
307         if ((cfg->io.nwin > 0) || (dflt.io.nwin > 0)) {
308             cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt.io;
309             link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
310             if (!(io->flags & CISTPL_IO_8BIT))
311                 link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
312             if (!(io->flags & CISTPL_IO_16BIT))
313                 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
314 /* new in dummy.cs 2001/01/28 MN 
315             link->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
316 */
317             link->io.BasePort1 = io->win[0].base;
318             link->io.NumPorts1 = io->win[0].len;
319             if (io->nwin > 1) {
320                 link->io.Attributes2 = link->io.Attributes1;
321                 link->io.BasePort2 = io->win[1].base;
322                 link->io.NumPorts2 = io->win[1].len;
323             }
324             /* This reserves IO space but doesn't actually enable it */
325             if (pcmcia_request_io(link, &link->io) != 0)
326                 goto next_entry;
327         }
328
329         /*
330           Now set up a common memory window, if needed.  There is room
331           in the struct pcmcia_device structure for one memory window handle,
332           but if the base addresses need to be saved, or if multiple
333           windows are needed, the info should go in the private data
334           structure for this device.
335
336           Note that the memory window base is a physical address, and
337           needs to be mapped to virtual space with ioremap() before it
338           is used.
339         */
340         if ((cfg->mem.nwin > 0) || (dflt.mem.nwin > 0)) {
341             cistpl_mem_t *mem =
342                 (cfg->mem.nwin) ? &cfg->mem : &dflt.mem;
343             req.Attributes = WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM;
344             req.Attributes |= WIN_ENABLE;
345             req.Base = mem->win[0].host_addr;
346             req.Size = mem->win[0].len;
347 /* new in dummy.cs 2001/01/28 MN 
348             if (req.Size < 0x1000)
349                 req.Size = 0x1000;
350 */
351             req.AccessSpeed = 0;
352             if (pcmcia_request_window(&link, &req, &link->win) != 0)
353                 goto next_entry;
354             map.Page = 0; map.CardOffset = mem->win[0].card_addr;
355             if (pcmcia_map_mem_page(link->win, &map) != 0)
356                 goto next_entry;
357         }
358         /* If we got this far, we're cool! */
359         break;
360
361     next_entry:
362         CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(link, &tuple));
363     }
364
365     /*
366        Allocate an interrupt line.  Note that this does not assign a
367        handler to the interrupt, unless the 'Handler' member of the
368        irq structure is initialized.
369     */
370     if (link->conf.Attributes & CONF_ENABLE_IRQ)
371         CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
372         
373     /*
374        This actually configures the PCMCIA socket -- setting up
375        the I/O windows and the interrupt mapping, and putting the
376        card and host interface into "Memory and IO" mode.
377     */
378     CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
379
380     /*
381       At this point, the dev_node_t structure(s) need to be
382       initialized and arranged in a linked list at link->dev.
383     */
384     sprintf(dev->node.dev_name, "sedlbauer");
385     dev->node.major = dev->node.minor = 0;
386     link->dev_node = &dev->node;
387
388     /* Finally, report what we've done */
389     printk(KERN_INFO "%s: index 0x%02x:",
390            dev->node.dev_name, link->conf.ConfigIndex);
391     if (link->conf.Vpp)
392         printk(", Vpp %d.%d", link->conf.Vpp/10, link->conf.Vpp%10);
393     if (link->conf.Attributes & CONF_ENABLE_IRQ)
394         printk(", irq %d", link->irq.AssignedIRQ);
395     if (link->io.NumPorts1)
396         printk(", io 0x%04x-0x%04x", link->io.BasePort1,
397                link->io.BasePort1+link->io.NumPorts1-1);
398     if (link->io.NumPorts2)
399         printk(" & 0x%04x-0x%04x", link->io.BasePort2,
400                link->io.BasePort2+link->io.NumPorts2-1);
401     if (link->win)
402         printk(", mem 0x%06lx-0x%06lx", req.Base,
403                req.Base+req.Size-1);
404     printk("\n");
405
406     icard.para[0] = link->irq.AssignedIRQ;
407     icard.para[1] = link->io.BasePort1;
408     icard.protocol = protocol;
409     icard.typ = ISDN_CTYPE_SEDLBAUER_PCMCIA;
410     
411     last_ret = hisax_init_pcmcia(link, &(((local_info_t*)link->priv)->stop), &icard);
412     if (last_ret < 0) {
413         printk(KERN_ERR "sedlbauer_cs: failed to initialize SEDLBAUER PCMCIA %d at i/o %#x\n",
414                 last_ret, link->io.BasePort1);
415         sedlbauer_release(link);
416         return -ENODEV;
417     } else
418         ((local_info_t*)link->priv)->cardnr = last_ret;
419
420     return 0;
421
422 cs_failed:
423     cs_error(link, last_fn, last_ret);
424     sedlbauer_release(link);
425     return -ENODEV;
426
427 } /* sedlbauer_config */
428
429 /*======================================================================
430
431     After a card is removed, sedlbauer_release() will unregister the
432     device, and release the PCMCIA configuration.  If the device is
433     still open, this will be postponed until it is closed.
434     
435 ======================================================================*/
436
437 static void sedlbauer_release(struct pcmcia_device *link)
438 {
439     local_info_t *local = link->priv;
440     DEBUG(0, "sedlbauer_release(0x%p)\n", link);
441
442     if (local) {
443         if (local->cardnr >= 0) {
444             /* no unregister function with hisax */
445             HiSax_closecard(local->cardnr);
446         }
447     }
448
449     pcmcia_disable_device(link);
450 } /* sedlbauer_release */
451
452 static int sedlbauer_suspend(struct pcmcia_device *link)
453 {
454         local_info_t *dev = link->priv;
455
456         dev->stop = 1;
457
458         return 0;
459 }
460
461 static int sedlbauer_resume(struct pcmcia_device *link)
462 {
463         local_info_t *dev = link->priv;
464
465         dev->stop = 0;
466
467         return 0;
468 }
469
470
471 static struct pcmcia_device_id sedlbauer_ids[] = {
472         PCMCIA_DEVICE_PROD_ID123("SEDLBAUER", "speed star II", "V 3.1", 0x81fb79f5, 0xf3612e1d, 0x6b95c78a),
473         PCMCIA_DEVICE_PROD_ID123("SEDLBAUER", "ISDN-Adapter", "4D67", 0x81fb79f5, 0xe4e9bc12, 0x397b7e90),
474         PCMCIA_DEVICE_PROD_ID123("SEDLBAUER", "ISDN-Adapter", "4D98", 0x81fb79f5, 0xe4e9bc12, 0x2e5c7fce),
475         PCMCIA_DEVICE_PROD_ID123("SEDLBAUER", "ISDN-Adapter", " (C) 93-94 VK", 0x81fb79f5, 0xe4e9bc12, 0x8db143fe),
476         PCMCIA_DEVICE_PROD_ID123("SEDLBAUER", "ISDN-Adapter", " (c) 93-95 VK", 0x81fb79f5, 0xe4e9bc12, 0xb391ab4c),
477         PCMCIA_DEVICE_PROD_ID12("HST High Soft Tech GmbH", "Saphir II B", 0xd79e0b84, 0x21d083ae),
478 /*      PCMCIA_DEVICE_PROD_ID1234("SEDLBAUER", 0x81fb79f5), */ /* too generic*/
479         PCMCIA_DEVICE_NULL
480 };
481 MODULE_DEVICE_TABLE(pcmcia, sedlbauer_ids);
482
483 static struct pcmcia_driver sedlbauer_driver = {
484         .owner          = THIS_MODULE,
485         .drv            = {
486                 .name   = "sedlbauer_cs",
487         },
488         .probe          = sedlbauer_probe,
489         .remove         = sedlbauer_detach,
490         .id_table       = sedlbauer_ids,
491         .suspend        = sedlbauer_suspend,
492         .resume         = sedlbauer_resume,
493 };
494
495 static int __init init_sedlbauer_cs(void)
496 {
497         return pcmcia_register_driver(&sedlbauer_driver);
498 }
499
500 static void __exit exit_sedlbauer_cs(void)
501 {
502         pcmcia_unregister_driver(&sedlbauer_driver);
503 }
504
505 module_init(init_sedlbauer_cs);
506 module_exit(exit_sedlbauer_cs);