Commit | Line | Data |
---|---|---|
3a48c4c2 PR |
1 | /* |
2 | * Driver for 802.11b cards using RAM-loadable Symbol firmware, such as | |
4ebe2eb0 | 3 | * Symbol Wireless Networker LA4137, CompactFlash cards by Socket |
3a48c4c2 PR |
4 | * Communications and Intel PRO/Wireless 2011B. |
5 | * | |
6 | * The driver implements Symbol firmware download. The rest is handled | |
47445cb9 | 7 | * in hermes.c and main.c. |
3a48c4c2 PR |
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 | * | |
47445cb9 | 18 | * See copyright notice in file main.c. |
3a48c4c2 PR |
19 | */ |
20 | ||
21 | #define DRIVER_NAME "spectrum_cs" | |
22 | #define PFX DRIVER_NAME ": " | |
23 | ||
3a48c4c2 PR |
24 | #include <linux/module.h> |
25 | #include <linux/kernel.h> | |
26 | #include <linux/init.h> | |
ef846bf0 | 27 | #include <linux/delay.h> |
3a48c4c2 PR |
28 | #include <pcmcia/cistpl.h> |
29 | #include <pcmcia/cisreg.h> | |
30 | #include <pcmcia/ds.h> | |
31 | ||
3a48c4c2 | 32 | #include "orinoco.h" |
3a48c4c2 PR |
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 | ||
3a48c4c2 PR |
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 { | |
fd238232 | 57 | struct pcmcia_device *p_dev; |
3a48c4c2 PR |
58 | }; |
59 | ||
3a48c4c2 PR |
60 | /********************************************************************/ |
61 | /* Function prototypes */ | |
62 | /********************************************************************/ | |
63 | ||
15b99ac1 | 64 | static int spectrum_cs_config(struct pcmcia_device *link); |
fba395ee | 65 | static void spectrum_cs_release(struct pcmcia_device *link); |
3a48c4c2 | 66 | |
3a48c4c2 PR |
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 | ||
3a48c4c2 | 72 | |
3a48c4c2 PR |
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 | |
fba395ee | 78 | spectrum_reset(struct pcmcia_device *link, int idle) |
3a48c4c2 | 79 | { |
2caff147 | 80 | int ret; |
1d5cc192 DB |
81 | u8 save_cor; |
82 | u8 ccsr; | |
3a48c4c2 PR |
83 | |
84 | /* Doing it if hardware is gone is guaranteed crash */ | |
c5ab964d | 85 | if (!pcmcia_dev_present(link)) |
3a48c4c2 PR |
86 | return -ENODEV; |
87 | ||
88 | /* Save original COR value */ | |
1d5cc192 | 89 | ret = pcmcia_read_config_byte(link, CISREG_COR, &save_cor); |
2caff147 DB |
90 | if (ret) |
91 | goto failed; | |
3a48c4c2 PR |
92 | |
93 | /* Soft-Reset card */ | |
1d5cc192 DB |
94 | ret = pcmcia_write_config_byte(link, CISREG_COR, |
95 | (save_cor | COR_SOFT_RESET)); | |
2caff147 DB |
96 | if (ret) |
97 | goto failed; | |
3a48c4c2 PR |
98 | udelay(1000); |
99 | ||
100 | /* Read CCSR */ | |
1d5cc192 | 101 | ret = pcmcia_read_config_byte(link, CISREG_CCSR, &ccsr); |
2caff147 DB |
102 | if (ret) |
103 | goto failed; | |
3a48c4c2 PR |
104 | |
105 | /* | |
106 | * Start or stop the firmware. Memory width bit should be | |
107 | * preserved from the value we've just read. | |
108 | */ | |
1d5cc192 DB |
109 | ccsr = (idle ? HCR_IDLE : HCR_RUN) | (ccsr & HCR_MEM16); |
110 | ret = pcmcia_write_config_byte(link, CISREG_CCSR, ccsr); | |
2caff147 DB |
111 | if (ret) |
112 | goto failed; | |
3a48c4c2 PR |
113 | udelay(1000); |
114 | ||
115 | /* Restore original COR configuration index */ | |
1d5cc192 DB |
116 | ret = pcmcia_write_config_byte(link, CISREG_COR, |
117 | (save_cor & ~COR_SOFT_RESET)); | |
2caff147 DB |
118 | if (ret) |
119 | goto failed; | |
3a48c4c2 PR |
120 | udelay(1000); |
121 | return 0; | |
122 | ||
2caff147 | 123 | failed: |
3a48c4c2 PR |
124 | return -ENODEV; |
125 | } | |
126 | ||
3994d502 DK |
127 | /********************************************************************/ |
128 | /* Device methods */ | |
129 | /********************************************************************/ | |
3a48c4c2 | 130 | |
3a48c4c2 | 131 | static int |
3994d502 | 132 | spectrum_cs_hard_reset(struct orinoco_private *priv) |
3a48c4c2 | 133 | { |
3994d502 DK |
134 | struct orinoco_pccard *card = priv->card; |
135 | struct pcmcia_device *link = card->p_dev; | |
3a48c4c2 | 136 | |
3994d502 DK |
137 | /* Soft reset using COR and HCR */ |
138 | spectrum_reset(link, 0); | |
3a48c4c2 PR |
139 | |
140 | return 0; | |
141 | } | |
142 | ||
3a48c4c2 | 143 | static int |
3994d502 | 144 | spectrum_cs_stop_firmware(struct orinoco_private *priv, int idle) |
3a48c4c2 PR |
145 | { |
146 | struct orinoco_pccard *card = priv->card; | |
fba395ee | 147 | struct pcmcia_device *link = card->p_dev; |
3a48c4c2 | 148 | |
3994d502 | 149 | return spectrum_reset(link, idle); |
3a48c4c2 PR |
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. | |
d14c7c1d | 160 | * |
3a48c4c2 PR |
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. */ | |
f8cfa618 | 164 | static int |
15b99ac1 | 165 | spectrum_cs_probe(struct pcmcia_device *link) |
3a48c4c2 | 166 | { |
3a48c4c2 PR |
167 | struct orinoco_private *priv; |
168 | struct orinoco_pccard *card; | |
3a48c4c2 | 169 | |
dd2e5a15 | 170 | priv = alloc_orinocodev(sizeof(*card), &link->dev, |
a2608362 DK |
171 | spectrum_cs_hard_reset, |
172 | spectrum_cs_stop_firmware); | |
173 | if (!priv) | |
f8cfa618 | 174 | return -ENOMEM; |
3a48c4c2 PR |
175 | card = priv->card; |
176 | ||
177 | /* Link both structures together */ | |
fba395ee | 178 | card->p_dev = link; |
a2608362 | 179 | link->priv = priv; |
3a48c4c2 | 180 | |
15b99ac1 | 181 | return spectrum_cs_config(link); |
3a48c4c2 PR |
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 | */ | |
fba395ee | 190 | static void spectrum_cs_detach(struct pcmcia_device *link) |
3a48c4c2 | 191 | { |
a2608362 | 192 | struct orinoco_private *priv = link->priv; |
3a48c4c2 | 193 | |
c7c2fa07 | 194 | orinoco_if_del(priv); |
e4f4f98e | 195 | |
e2d40963 | 196 | spectrum_cs_release(link); |
3a48c4c2 | 197 | |
a2608362 | 198 | free_orinocodev(priv); |
3a48c4c2 PR |
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 | ||
b54bf94b DB |
207 | static int spectrum_cs_config_check(struct pcmcia_device *p_dev, |
208 | cistpl_cftable_entry_t *cfg, | |
8e2fc39d | 209 | cistpl_cftable_entry_t *dflt, |
ad913c11 | 210 | unsigned int vcc, |
b54bf94b DB |
211 | void *priv_data) |
212 | { | |
b54bf94b DB |
213 | if (cfg->index == 0) |
214 | goto next_entry; | |
b54bf94b DB |
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)) { | |
ad913c11 | 219 | if (vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000) { |
62d714e5 DK |
220 | DEBUG(2, "%s: Vcc mismatch (vcc = %d, CIS = %d)\n", |
221 | __func__, vcc, | |
222 | cfg->vcc.param[CISTPL_POWER_VNOM] / 10000); | |
b54bf94b DB |
223 | if (!ignore_cis_vcc) |
224 | goto next_entry; | |
225 | } | |
8e2fc39d | 226 | } else if (dflt->vcc.present & (1 << CISTPL_POWER_VNOM)) { |
ad913c11 | 227 | if (vcc != dflt->vcc.param[CISTPL_POWER_VNOM] / 10000) { |
62d714e5 DK |
228 | DEBUG(2, "%s: Vcc mismatch (vcc = %d, CIS = %d)\n", |
229 | __func__, vcc, | |
230 | dflt->vcc.param[CISTPL_POWER_VNOM] / 10000); | |
b54bf94b DB |
231 | if (!ignore_cis_vcc) |
232 | goto next_entry; | |
233 | } | |
234 | } | |
235 | ||
236 | if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM)) | |
e8405f0f | 237 | p_dev->vpp = |
b54bf94b | 238 | cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000; |
8e2fc39d | 239 | else if (dflt->vpp1.present & (1 << CISTPL_POWER_VNOM)) |
e8405f0f | 240 | p_dev->vpp = |
8e2fc39d | 241 | dflt->vpp1.param[CISTPL_POWER_VNOM] / 10000; |
b54bf94b DB |
242 | |
243 | /* Do we need to allocate an interrupt? */ | |
1ac71e5a | 244 | p_dev->config_flags |= CONF_ENABLE_IRQ; |
b54bf94b DB |
245 | |
246 | /* IO window settings */ | |
90abdc3b | 247 | p_dev->resource[0]->end = p_dev->resource[1]->end = 0; |
8e2fc39d DB |
248 | if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) { |
249 | cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io; | |
90abdc3b DB |
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; | |
b54bf94b | 256 | if (io->nwin > 1) { |
90abdc3b DB |
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; | |
b54bf94b DB |
260 | } |
261 | ||
262 | /* This reserves IO space but doesn't actually enable it */ | |
90abdc3b | 263 | if (pcmcia_request_io(p_dev) != 0) |
b54bf94b DB |
264 | goto next_entry; |
265 | } | |
266 | return 0; | |
267 | ||
268 | next_entry: | |
269 | pcmcia_disable_device(p_dev); | |
270 | return -ENODEV; | |
271 | }; | |
272 | ||
15b99ac1 | 273 | static int |
fba395ee | 274 | spectrum_cs_config(struct pcmcia_device *link) |
3a48c4c2 | 275 | { |
a2608362 | 276 | struct orinoco_private *priv = link->priv; |
3a48c4c2 | 277 | hermes_t *hw = &priv->hw; |
2caff147 | 278 | int ret; |
3a48c4c2 PR |
279 | void __iomem *mem; |
280 | ||
3a48c4c2 PR |
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 | */ | |
2caff147 DB |
295 | ret = pcmcia_loop_config(link, spectrum_cs_config_check, NULL); |
296 | if (ret) { | |
b54bf94b | 297 | if (!ignore_cis_vcc) |
3a48c4c2 PR |
298 | printk(KERN_ERR PFX "GetNextTuple(): No matching " |
299 | "CIS configuration. Maybe you need the " | |
300 | "ignore_cis_vcc=1 parameter.\n"); | |
b54bf94b | 301 | goto failed; |
3a48c4c2 PR |
302 | } |
303 | ||
eb14120f | 304 | ret = pcmcia_request_irq(link, orinoco_interrupt); |
2caff147 DB |
305 | if (ret) |
306 | goto failed; | |
3a48c4c2 PR |
307 | |
308 | /* We initialize the hermes structure before completing PCMCIA | |
309 | * configuration just in case the interrupt handler gets | |
310 | * called. */ | |
9a017a91 DB |
311 | mem = ioport_map(link->resource[0]->start, |
312 | resource_size(link->resource[0])); | |
3a48c4c2 | 313 | if (!mem) |
2caff147 | 314 | goto failed; |
3a48c4c2 PR |
315 | |
316 | hermes_struct_init(hw, mem, HERMES_16BIT_REGSPACING); | |
07cefe7a | 317 | hw->eeprom_pda = true; |
3a48c4c2 PR |
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 | */ | |
1ac71e5a | 324 | ret = pcmcia_enable_device(link); |
2caff147 DB |
325 | if (ret) |
326 | goto failed; | |
3a48c4c2 | 327 | |
3994d502 | 328 | /* Reset card */ |
d14c7c1d | 329 | if (spectrum_cs_hard_reset(priv) != 0) |
3a48c4c2 | 330 | goto failed; |
3a48c4c2 | 331 | |
8e638267 DK |
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 | ||
5381956b | 338 | /* Register an interface with the stack */ |
9a017a91 | 339 | if (orinoco_if_add(priv, link->resource[0]->start, |
f8965467 | 340 | link->irq, NULL) != 0) { |
5381956b | 341 | printk(KERN_ERR PFX "orinoco_if_add() failed\n"); |
3a48c4c2 PR |
342 | goto failed; |
343 | } | |
344 | ||
15b99ac1 | 345 | return 0; |
3a48c4c2 | 346 | |
3a48c4c2 PR |
347 | failed: |
348 | spectrum_cs_release(link); | |
15b99ac1 | 349 | return -ENODEV; |
3a48c4c2 PR |
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 | |
fba395ee | 358 | spectrum_cs_release(struct pcmcia_device *link) |
3a48c4c2 | 359 | { |
a2608362 | 360 | struct orinoco_private *priv = link->priv; |
3a48c4c2 PR |
361 | unsigned long flags; |
362 | ||
363 | /* We're committed to taking the device away now, so mark the | |
364 | * hardware as unavailable */ | |
bcad6e80 | 365 | priv->hw.ops->lock_irqsave(&priv->lock, &flags); |
3a48c4c2 | 366 | priv->hw_unavailable++; |
bcad6e80 | 367 | priv->hw.ops->unlock_irqrestore(&priv->lock, &flags); |
3a48c4c2 | 368 | |
fba395ee | 369 | pcmcia_disable_device(link); |
3a48c4c2 PR |
370 | if (priv->hw.iobase) |
371 | ioport_unmap(priv->hw.iobase); | |
372 | } /* spectrum_cs_release */ | |
373 | ||
98e4c28b DB |
374 | |
375 | static int | |
fba395ee | 376 | spectrum_cs_suspend(struct pcmcia_device *link) |
98e4c28b | 377 | { |
a2608362 | 378 | struct orinoco_private *priv = link->priv; |
98e4c28b DB |
379 | int err = 0; |
380 | ||
98e4c28b | 381 | /* Mark the device as stopped, to block IO until later */ |
6415f7df | 382 | orinoco_down(priv); |
98e4c28b | 383 | |
6cbaa330 | 384 | return err; |
98e4c28b DB |
385 | } |
386 | ||
387 | static int | |
fba395ee | 388 | spectrum_cs_resume(struct pcmcia_device *link) |
98e4c28b | 389 | { |
a2608362 | 390 | struct orinoco_private *priv = link->priv; |
6415f7df | 391 | int err = orinoco_up(priv); |
ac7cafd7 | 392 | |
6415f7df | 393 | return err; |
98e4c28b DB |
394 | } |
395 | ||
3a48c4c2 PR |
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[] = { | |
4ebe2eb0 | 408 | PCMCIA_DEVICE_MANF_CARD(0x026c, 0x0001), /* Symbol Spectrum24 LA4137 */ |
3a48c4c2 | 409 | PCMCIA_DEVICE_MANF_CARD(0x0104, 0x0001), /* Socket Communications CF */ |
9c8a11d7 | 410 | PCMCIA_DEVICE_PROD_ID12("Intel", "PRO/Wireless LAN PC Card", 0x816cc815, 0x6fbf459a), /* 2011B, not 2011 */ |
3a48c4c2 PR |
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 | }, | |
15b99ac1 | 420 | .probe = spectrum_cs_probe, |
cc3b4866 | 421 | .remove = spectrum_cs_detach, |
98e4c28b DB |
422 | .suspend = spectrum_cs_suspend, |
423 | .resume = spectrum_cs_resume, | |
3a48c4c2 PR |
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); | |
3a48c4c2 PR |
439 | } |
440 | ||
441 | module_init(init_spectrum_cs); | |
442 | module_exit(exit_spectrum_cs); |