pcmcia: convert pcmcia_request_configuration to pcmcia_enable_device
[linux-2.6.git] / drivers / net / wireless / orinoco / spectrum_cs.c
1 /*
2  * Driver for 802.11b cards using RAM-loadable Symbol firmware, such as
3  * Symbol Wireless Networker LA4137, CompactFlash cards by Socket
4  * Communications and Intel PRO/Wireless 2011B.
5  *
6  * The driver implements Symbol firmware download.  The rest is handled
7  * in hermes.c and main.c.
8  *
9  * Utilities for downloading the Symbol firmware are available at
10  * http://sourceforge.net/projects/orinoco/
11  *
12  * Copyright (C) 2002-2005 Pavel Roskin <proski@gnu.org>
13  * Portions based on orinoco_cs.c:
14  *      Copyright (C) David Gibson, Linuxcare Australia
15  * Portions based on Spectrum24tDnld.c from original spectrum24 driver:
16  *      Copyright (C) Symbol Technologies.
17  *
18  * See copyright notice in file main.c.
19  */
20
21 #define DRIVER_NAME "spectrum_cs"
22 #define PFX DRIVER_NAME ": "
23
24 #include <linux/module.h>
25 #include <linux/kernel.h>
26 #include <linux/init.h>
27 #include <linux/delay.h>
28 #include <pcmcia/cistpl.h>
29 #include <pcmcia/cisreg.h>
30 #include <pcmcia/ds.h>
31
32 #include "orinoco.h"
33
34 /********************************************************************/
35 /* Module stuff                                                     */
36 /********************************************************************/
37
38 MODULE_AUTHOR("Pavel Roskin <proski@gnu.org>");
39 MODULE_DESCRIPTION("Driver for Symbol Spectrum24 Trilogy cards with firmware downloader");
40 MODULE_LICENSE("Dual MPL/GPL");
41
42 /* Module parameters */
43
44 /* Some D-Link cards have buggy CIS. They do work at 5v properly, but
45  * don't have any CIS entry for it. This workaround it... */
46 static int ignore_cis_vcc; /* = 0 */
47 module_param(ignore_cis_vcc, int, 0);
48 MODULE_PARM_DESC(ignore_cis_vcc, "Allow voltage mismatch between card and socket");
49
50 /********************************************************************/
51 /* Data structures                                                  */
52 /********************************************************************/
53
54 /* PCMCIA specific device information (goes in the card field of
55  * struct orinoco_private */
56 struct orinoco_pccard {
57         struct pcmcia_device    *p_dev;
58 };
59
60 /********************************************************************/
61 /* Function prototypes                                              */
62 /********************************************************************/
63
64 static int spectrum_cs_config(struct pcmcia_device *link);
65 static void spectrum_cs_release(struct pcmcia_device *link);
66
67 /* Constants for the CISREG_CCSR register */
68 #define HCR_RUN         0x07    /* run firmware after reset */
69 #define HCR_IDLE        0x0E    /* don't run firmware after reset */
70 #define HCR_MEM16       0x10    /* memory width bit, should be preserved */
71
72
73 /*
74  * Reset the card using configuration registers COR and CCSR.
75  * If IDLE is 1, stop the firmware, so that it can be safely rewritten.
76  */
77 static int
78 spectrum_reset(struct pcmcia_device *link, int idle)
79 {
80         int ret;
81         u8 save_cor;
82         u8 ccsr;
83
84         /* Doing it if hardware is gone is guaranteed crash */
85         if (!pcmcia_dev_present(link))
86                 return -ENODEV;
87
88         /* Save original COR value */
89         ret = pcmcia_read_config_byte(link, CISREG_COR, &save_cor);
90         if (ret)
91                 goto failed;
92
93         /* Soft-Reset card */
94         ret = pcmcia_write_config_byte(link, CISREG_COR,
95                                 (save_cor | COR_SOFT_RESET));
96         if (ret)
97                 goto failed;
98         udelay(1000);
99
100         /* Read CCSR */
101         ret = pcmcia_read_config_byte(link, CISREG_CCSR, &ccsr);
102         if (ret)
103                 goto failed;
104
105         /*
106          * Start or stop the firmware.  Memory width bit should be
107          * preserved from the value we've just read.
108          */
109         ccsr = (idle ? HCR_IDLE : HCR_RUN) | (ccsr & HCR_MEM16);
110         ret = pcmcia_write_config_byte(link, CISREG_CCSR, ccsr);
111         if (ret)
112                 goto failed;
113         udelay(1000);
114
115         /* Restore original COR configuration index */
116         ret = pcmcia_write_config_byte(link, CISREG_COR,
117                                 (save_cor & ~COR_SOFT_RESET));
118         if (ret)
119                 goto failed;
120         udelay(1000);
121         return 0;
122
123 failed:
124         return -ENODEV;
125 }
126
127 /********************************************************************/
128 /* Device methods                                                   */
129 /********************************************************************/
130
131 static int
132 spectrum_cs_hard_reset(struct orinoco_private *priv)
133 {
134         struct orinoco_pccard *card = priv->card;
135         struct pcmcia_device *link = card->p_dev;
136
137         /* Soft reset using COR and HCR */
138         spectrum_reset(link, 0);
139
140         return 0;
141 }
142
143 static int
144 spectrum_cs_stop_firmware(struct orinoco_private *priv, int idle)
145 {
146         struct orinoco_pccard *card = priv->card;
147         struct pcmcia_device *link = card->p_dev;
148
149         return spectrum_reset(link, idle);
150 }
151
152 /********************************************************************/
153 /* PCMCIA stuff                                                     */
154 /********************************************************************/
155
156 /*
157  * This creates an "instance" of the driver, allocating local data
158  * structures for one device.  The device is registered with Card
159  * Services.
160  *
161  * The dev_link structure is initialized, but we don't actually
162  * configure the card at this point -- we wait until we receive a card
163  * insertion event.  */
164 static int
165 spectrum_cs_probe(struct pcmcia_device *link)
166 {
167         struct orinoco_private *priv;
168         struct orinoco_pccard *card;
169
170         priv = alloc_orinocodev(sizeof(*card), &link->dev,
171                                 spectrum_cs_hard_reset,
172                                 spectrum_cs_stop_firmware);
173         if (!priv)
174                 return -ENOMEM;
175         card = priv->card;
176
177         /* Link both structures together */
178         card->p_dev = link;
179         link->priv = priv;
180
181         return spectrum_cs_config(link);
182 }                               /* spectrum_cs_attach */
183
184 /*
185  * This deletes a driver "instance".  The device is de-registered with
186  * Card Services.  If it has been released, all local data structures
187  * are freed.  Otherwise, the structures will be freed when the device
188  * is released.
189  */
190 static void spectrum_cs_detach(struct pcmcia_device *link)
191 {
192         struct orinoco_private *priv = link->priv;
193
194         orinoco_if_del(priv);
195
196         spectrum_cs_release(link);
197
198         free_orinocodev(priv);
199 }                               /* spectrum_cs_detach */
200
201 /*
202  * spectrum_cs_config() is scheduled to run after a CARD_INSERTION
203  * event is received, to configure the PCMCIA socket, and to make the
204  * device available to the system.
205  */
206
207 static int spectrum_cs_config_check(struct pcmcia_device *p_dev,
208                                     cistpl_cftable_entry_t *cfg,
209                                     cistpl_cftable_entry_t *dflt,
210                                     unsigned int vcc,
211                                     void *priv_data)
212 {
213         if (cfg->index == 0)
214                 goto next_entry;
215
216         /* Use power settings for Vcc and Vpp if present */
217         /* Note that the CIS values need to be rescaled */
218         if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) {
219                 if (vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000) {
220                         DEBUG(2, "%s: Vcc mismatch (vcc = %d, CIS = %d)\n",
221                               __func__, vcc,
222                               cfg->vcc.param[CISTPL_POWER_VNOM] / 10000);
223                         if (!ignore_cis_vcc)
224                                 goto next_entry;
225                 }
226         } else if (dflt->vcc.present & (1 << CISTPL_POWER_VNOM)) {
227                 if (vcc != dflt->vcc.param[CISTPL_POWER_VNOM] / 10000) {
228                         DEBUG(2, "%s: Vcc mismatch (vcc = %d, CIS = %d)\n",
229                               __func__, vcc,
230                               dflt->vcc.param[CISTPL_POWER_VNOM] / 10000);
231                         if (!ignore_cis_vcc)
232                                 goto next_entry;
233                 }
234         }
235
236         if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM))
237                 p_dev->vpp =
238                         cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000;
239         else if (dflt->vpp1.present & (1 << CISTPL_POWER_VNOM))
240                 p_dev->vpp =
241                         dflt->vpp1.param[CISTPL_POWER_VNOM] / 10000;
242
243         /* Do we need to allocate an interrupt? */
244         p_dev->config_flags |= CONF_ENABLE_IRQ;
245
246         /* IO window settings */
247         p_dev->resource[0]->end = p_dev->resource[1]->end = 0;
248         if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
249                 cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
250                 p_dev->io_lines = io->flags & CISTPL_IO_LINES_MASK;
251                 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
252                 p_dev->resource[0]->flags |=
253                         pcmcia_io_cfg_data_width(io->flags);
254                 p_dev->resource[0]->start = io->win[0].base;
255                 p_dev->resource[0]->end = io->win[0].len;
256                 if (io->nwin > 1) {
257                         p_dev->resource[1]->flags = p_dev->resource[0]->flags;
258                         p_dev->resource[1]->start = io->win[1].base;
259                         p_dev->resource[1]->end = io->win[1].len;
260                 }
261
262                 /* This reserves IO space but doesn't actually enable it */
263                 if (pcmcia_request_io(p_dev) != 0)
264                         goto next_entry;
265         }
266         return 0;
267
268 next_entry:
269         pcmcia_disable_device(p_dev);
270         return -ENODEV;
271 };
272
273 static int
274 spectrum_cs_config(struct pcmcia_device *link)
275 {
276         struct orinoco_private *priv = link->priv;
277         hermes_t *hw = &priv->hw;
278         int ret;
279         void __iomem *mem;
280
281         /*
282          * In this loop, we scan the CIS for configuration table
283          * entries, each of which describes a valid card
284          * configuration, including voltage, IO window, memory window,
285          * and interrupt settings.
286          *
287          * We make no assumptions about the card to be configured: we
288          * use just the information available in the CIS.  In an ideal
289          * world, this would work for any PCMCIA card, but it requires
290          * a complete and accurate CIS.  In practice, a driver usually
291          * "knows" most of these things without consulting the CIS,
292          * and most client drivers will only use the CIS to fill in
293          * implementation-defined details.
294          */
295         ret = pcmcia_loop_config(link, spectrum_cs_config_check, NULL);
296         if (ret) {
297                 if (!ignore_cis_vcc)
298                         printk(KERN_ERR PFX "GetNextTuple(): No matching "
299                                "CIS configuration.  Maybe you need the "
300                                "ignore_cis_vcc=1 parameter.\n");
301                 goto failed;
302         }
303
304         ret = pcmcia_request_irq(link, orinoco_interrupt);
305         if (ret)
306                 goto failed;
307
308         /* We initialize the hermes structure before completing PCMCIA
309          * configuration just in case the interrupt handler gets
310          * called. */
311         mem = ioport_map(link->resource[0]->start,
312                         resource_size(link->resource[0]));
313         if (!mem)
314                 goto failed;
315
316         hermes_struct_init(hw, mem, HERMES_16BIT_REGSPACING);
317         hw->eeprom_pda = true;
318
319         /*
320          * This actually configures the PCMCIA socket -- setting up
321          * the I/O windows and the interrupt mapping, and putting the
322          * card and host interface into "Memory and IO" mode.
323          */
324         ret = pcmcia_enable_device(link);
325         if (ret)
326                 goto failed;
327
328         /* Reset card */
329         if (spectrum_cs_hard_reset(priv) != 0)
330                 goto failed;
331
332         /* Initialise the main driver */
333         if (orinoco_init(priv) != 0) {
334                 printk(KERN_ERR PFX "orinoco_init() failed\n");
335                 goto failed;
336         }
337
338         /* Register an interface with the stack */
339         if (orinoco_if_add(priv, link->resource[0]->start,
340                            link->irq, NULL) != 0) {
341                 printk(KERN_ERR PFX "orinoco_if_add() failed\n");
342                 goto failed;
343         }
344
345         return 0;
346
347  failed:
348         spectrum_cs_release(link);
349         return -ENODEV;
350 }                               /* spectrum_cs_config */
351
352 /*
353  * After a card is removed, spectrum_cs_release() will unregister the
354  * device, and release the PCMCIA configuration.  If the device is
355  * still open, this will be postponed until it is closed.
356  */
357 static void
358 spectrum_cs_release(struct pcmcia_device *link)
359 {
360         struct orinoco_private *priv = link->priv;
361         unsigned long flags;
362
363         /* We're committed to taking the device away now, so mark the
364          * hardware as unavailable */
365         priv->hw.ops->lock_irqsave(&priv->lock, &flags);
366         priv->hw_unavailable++;
367         priv->hw.ops->unlock_irqrestore(&priv->lock, &flags);
368
369         pcmcia_disable_device(link);
370         if (priv->hw.iobase)
371                 ioport_unmap(priv->hw.iobase);
372 }                               /* spectrum_cs_release */
373
374
375 static int
376 spectrum_cs_suspend(struct pcmcia_device *link)
377 {
378         struct orinoco_private *priv = link->priv;
379         int err = 0;
380
381         /* Mark the device as stopped, to block IO until later */
382         orinoco_down(priv);
383
384         return err;
385 }
386
387 static int
388 spectrum_cs_resume(struct pcmcia_device *link)
389 {
390         struct orinoco_private *priv = link->priv;
391         int err = orinoco_up(priv);
392
393         return err;
394 }
395
396
397 /********************************************************************/
398 /* Module initialization                                            */
399 /********************************************************************/
400
401 /* Can't be declared "const" or the whole __initdata section will
402  * become const */
403 static char version[] __initdata = DRIVER_NAME " " DRIVER_VERSION
404         " (Pavel Roskin <proski@gnu.org>,"
405         " David Gibson <hermes@gibson.dropbear.id.au>, et al)";
406
407 static struct pcmcia_device_id spectrum_cs_ids[] = {
408         PCMCIA_DEVICE_MANF_CARD(0x026c, 0x0001), /* Symbol Spectrum24 LA4137 */
409         PCMCIA_DEVICE_MANF_CARD(0x0104, 0x0001), /* Socket Communications CF */
410         PCMCIA_DEVICE_PROD_ID12("Intel", "PRO/Wireless LAN PC Card", 0x816cc815, 0x6fbf459a), /* 2011B, not 2011 */
411         PCMCIA_DEVICE_NULL,
412 };
413 MODULE_DEVICE_TABLE(pcmcia, spectrum_cs_ids);
414
415 static struct pcmcia_driver orinoco_driver = {
416         .owner          = THIS_MODULE,
417         .drv            = {
418                 .name   = DRIVER_NAME,
419         },
420         .probe          = spectrum_cs_probe,
421         .remove         = spectrum_cs_detach,
422         .suspend        = spectrum_cs_suspend,
423         .resume         = spectrum_cs_resume,
424         .id_table       = spectrum_cs_ids,
425 };
426
427 static int __init
428 init_spectrum_cs(void)
429 {
430         printk(KERN_DEBUG "%s\n", version);
431
432         return pcmcia_register_driver(&orinoco_driver);
433 }
434
435 static void __exit
436 exit_spectrum_cs(void)
437 {
438         pcmcia_unregister_driver(&orinoco_driver);
439 }
440
441 module_init(init_spectrum_cs);
442 module_exit(exit_spectrum_cs);