pcmcia: use pcmica_{read,write}_config_byte
[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->io.NumPorts1 = p_dev->io.NumPorts2 = 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.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
260                 if (!(io->flags & CISTPL_IO_8BIT))
261                         p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
262                 if (!(io->flags & CISTPL_IO_16BIT))
263                         p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
264                 p_dev->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
265                 p_dev->io.BasePort1 = io->win[0].base;
266                 p_dev->io.NumPorts1 = io->win[0].len;
267                 if (io->nwin > 1) {
268                         p_dev->io.Attributes2 = p_dev->io.Attributes1;
269                         p_dev->io.BasePort2 = io->win[1].base;
270                         p_dev->io.NumPorts2 = io->win[1].len;
271                 }
272
273                 /* This reserves IO space but doesn't actually enable it */
274                 if (pcmcia_request_io(p_dev, &p_dev->io) != 0)
275                         goto next_entry;
276         }
277         return 0;
278
279 next_entry:
280         pcmcia_disable_device(p_dev);
281         return -ENODEV;
282 };
283
284 static int
285 spectrum_cs_config(struct pcmcia_device *link)
286 {
287         struct orinoco_private *priv = link->priv;
288         hermes_t *hw = &priv->hw;
289         int ret;
290         void __iomem *mem;
291
292         /*
293          * In this loop, we scan the CIS for configuration table
294          * entries, each of which describes a valid card
295          * configuration, including voltage, IO window, memory window,
296          * and interrupt settings.
297          *
298          * We make no assumptions about the card to be configured: we
299          * use just the information available in the CIS.  In an ideal
300          * world, this would work for any PCMCIA card, but it requires
301          * a complete and accurate CIS.  In practice, a driver usually
302          * "knows" most of these things without consulting the CIS,
303          * and most client drivers will only use the CIS to fill in
304          * implementation-defined details.
305          */
306         ret = pcmcia_loop_config(link, spectrum_cs_config_check, NULL);
307         if (ret) {
308                 if (!ignore_cis_vcc)
309                         printk(KERN_ERR PFX "GetNextTuple(): No matching "
310                                "CIS configuration.  Maybe you need the "
311                                "ignore_cis_vcc=1 parameter.\n");
312                 goto failed;
313         }
314
315         ret = pcmcia_request_irq(link, orinoco_interrupt);
316         if (ret)
317                 goto failed;
318
319         /* We initialize the hermes structure before completing PCMCIA
320          * configuration just in case the interrupt handler gets
321          * called. */
322         mem = ioport_map(link->io.BasePort1, link->io.NumPorts1);
323         if (!mem)
324                 goto failed;
325
326         hermes_struct_init(hw, mem, HERMES_16BIT_REGSPACING);
327         hw->eeprom_pda = true;
328
329         /*
330          * This actually configures the PCMCIA socket -- setting up
331          * the I/O windows and the interrupt mapping, and putting the
332          * card and host interface into "Memory and IO" mode.
333          */
334         ret = pcmcia_request_configuration(link, &link->conf);
335         if (ret)
336                 goto failed;
337
338         /* Reset card */
339         if (spectrum_cs_hard_reset(priv) != 0)
340                 goto failed;
341
342         /* Initialise the main driver */
343         if (orinoco_init(priv) != 0) {
344                 printk(KERN_ERR PFX "orinoco_init() failed\n");
345                 goto failed;
346         }
347
348         /* Register an interface with the stack */
349         if (orinoco_if_add(priv, link->io.BasePort1,
350                            link->irq, NULL) != 0) {
351                 printk(KERN_ERR PFX "orinoco_if_add() failed\n");
352                 goto failed;
353         }
354
355         return 0;
356
357  failed:
358         spectrum_cs_release(link);
359         return -ENODEV;
360 }                               /* spectrum_cs_config */
361
362 /*
363  * After a card is removed, spectrum_cs_release() will unregister the
364  * device, and release the PCMCIA configuration.  If the device is
365  * still open, this will be postponed until it is closed.
366  */
367 static void
368 spectrum_cs_release(struct pcmcia_device *link)
369 {
370         struct orinoco_private *priv = link->priv;
371         unsigned long flags;
372
373         /* We're committed to taking the device away now, so mark the
374          * hardware as unavailable */
375         priv->hw.ops->lock_irqsave(&priv->lock, &flags);
376         priv->hw_unavailable++;
377         priv->hw.ops->unlock_irqrestore(&priv->lock, &flags);
378
379         pcmcia_disable_device(link);
380         if (priv->hw.iobase)
381                 ioport_unmap(priv->hw.iobase);
382 }                               /* spectrum_cs_release */
383
384
385 static int
386 spectrum_cs_suspend(struct pcmcia_device *link)
387 {
388         struct orinoco_private *priv = link->priv;
389         int err = 0;
390
391         /* Mark the device as stopped, to block IO until later */
392         orinoco_down(priv);
393
394         return err;
395 }
396
397 static int
398 spectrum_cs_resume(struct pcmcia_device *link)
399 {
400         struct orinoco_private *priv = link->priv;
401         int err = orinoco_up(priv);
402
403         return err;
404 }
405
406
407 /********************************************************************/
408 /* Module initialization                                            */
409 /********************************************************************/
410
411 /* Can't be declared "const" or the whole __initdata section will
412  * become const */
413 static char version[] __initdata = DRIVER_NAME " " DRIVER_VERSION
414         " (Pavel Roskin <proski@gnu.org>,"
415         " David Gibson <hermes@gibson.dropbear.id.au>, et al)";
416
417 static struct pcmcia_device_id spectrum_cs_ids[] = {
418         PCMCIA_DEVICE_MANF_CARD(0x026c, 0x0001), /* Symbol Spectrum24 LA4137 */
419         PCMCIA_DEVICE_MANF_CARD(0x0104, 0x0001), /* Socket Communications CF */
420         PCMCIA_DEVICE_PROD_ID12("Intel", "PRO/Wireless LAN PC Card", 0x816cc815, 0x6fbf459a), /* 2011B, not 2011 */
421         PCMCIA_DEVICE_NULL,
422 };
423 MODULE_DEVICE_TABLE(pcmcia, spectrum_cs_ids);
424
425 static struct pcmcia_driver orinoco_driver = {
426         .owner          = THIS_MODULE,
427         .drv            = {
428                 .name   = DRIVER_NAME,
429         },
430         .probe          = spectrum_cs_probe,
431         .remove         = spectrum_cs_detach,
432         .suspend        = spectrum_cs_suspend,
433         .resume         = spectrum_cs_resume,
434         .id_table       = spectrum_cs_ids,
435 };
436
437 static int __init
438 init_spectrum_cs(void)
439 {
440         printk(KERN_DEBUG "%s\n", version);
441
442         return pcmcia_register_driver(&orinoco_driver);
443 }
444
445 static void __exit
446 exit_spectrum_cs(void)
447 {
448         pcmcia_unregister_driver(&orinoco_driver);
449 }
450
451 module_init(init_spectrum_cs);
452 module_exit(exit_spectrum_cs);