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