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 | |
7 | * in hermes.c and orinoco.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 orinoco.c. | |
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/cs_types.h> |
29 | #include <pcmcia/cs.h> | |
30 | #include <pcmcia/cistpl.h> | |
31 | #include <pcmcia/cisreg.h> | |
32 | #include <pcmcia/ds.h> | |
33 | ||
3a48c4c2 | 34 | #include "orinoco.h" |
3a48c4c2 PR |
35 | |
36 | /********************************************************************/ | |
37 | /* Module stuff */ | |
38 | /********************************************************************/ | |
39 | ||
40 | MODULE_AUTHOR("Pavel Roskin <proski@gnu.org>"); | |
41 | MODULE_DESCRIPTION("Driver for Symbol Spectrum24 Trilogy cards with firmware downloader"); | |
42 | MODULE_LICENSE("Dual MPL/GPL"); | |
43 | ||
44 | /* Module parameters */ | |
45 | ||
46 | /* Some D-Link cards have buggy CIS. They do work at 5v properly, but | |
47 | * don't have any CIS entry for it. This workaround it... */ | |
48 | static int ignore_cis_vcc; /* = 0 */ | |
49 | module_param(ignore_cis_vcc, int, 0); | |
50 | MODULE_PARM_DESC(ignore_cis_vcc, "Allow voltage mismatch between card and socket"); | |
51 | ||
3a48c4c2 PR |
52 | /********************************************************************/ |
53 | /* Data structures */ | |
54 | /********************************************************************/ | |
55 | ||
56 | /* PCMCIA specific device information (goes in the card field of | |
57 | * struct orinoco_private */ | |
58 | struct orinoco_pccard { | |
fd238232 | 59 | struct pcmcia_device *p_dev; |
3a48c4c2 PR |
60 | dev_node_t node; |
61 | }; | |
62 | ||
3a48c4c2 PR |
63 | /********************************************************************/ |
64 | /* Function prototypes */ | |
65 | /********************************************************************/ | |
66 | ||
15b99ac1 | 67 | static int spectrum_cs_config(struct pcmcia_device *link); |
fba395ee | 68 | static void spectrum_cs_release(struct pcmcia_device *link); |
3a48c4c2 | 69 | |
3a48c4c2 PR |
70 | /* Constants for the CISREG_CCSR register */ |
71 | #define HCR_RUN 0x07 /* run firmware after reset */ | |
72 | #define HCR_IDLE 0x0E /* don't run firmware after reset */ | |
73 | #define HCR_MEM16 0x10 /* memory width bit, should be preserved */ | |
74 | ||
3a48c4c2 PR |
75 | |
76 | #define CS_CHECK(fn, ret) \ | |
77 | do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0) | |
78 | ||
79 | /* | |
80 | * Reset the card using configuration registers COR and CCSR. | |
81 | * If IDLE is 1, stop the firmware, so that it can be safely rewritten. | |
82 | */ | |
83 | static int | |
fba395ee | 84 | spectrum_reset(struct pcmcia_device *link, int idle) |
3a48c4c2 PR |
85 | { |
86 | int last_ret, last_fn; | |
87 | conf_reg_t reg; | |
88 | u_int save_cor; | |
89 | ||
90 | /* Doing it if hardware is gone is guaranteed crash */ | |
c5ab964d | 91 | if (!pcmcia_dev_present(link)) |
3a48c4c2 PR |
92 | return -ENODEV; |
93 | ||
94 | /* Save original COR value */ | |
95 | reg.Function = 0; | |
96 | reg.Action = CS_READ; | |
97 | reg.Offset = CISREG_COR; | |
98 | CS_CHECK(AccessConfigurationRegister, | |
fba395ee | 99 | pcmcia_access_configuration_register(link, ®)); |
3a48c4c2 PR |
100 | save_cor = reg.Value; |
101 | ||
102 | /* Soft-Reset card */ | |
103 | reg.Action = CS_WRITE; | |
104 | reg.Offset = CISREG_COR; | |
105 | reg.Value = (save_cor | COR_SOFT_RESET); | |
106 | CS_CHECK(AccessConfigurationRegister, | |
fba395ee | 107 | pcmcia_access_configuration_register(link, ®)); |
3a48c4c2 PR |
108 | udelay(1000); |
109 | ||
110 | /* Read CCSR */ | |
111 | reg.Action = CS_READ; | |
112 | reg.Offset = CISREG_CCSR; | |
113 | CS_CHECK(AccessConfigurationRegister, | |
fba395ee | 114 | pcmcia_access_configuration_register(link, ®)); |
3a48c4c2 PR |
115 | |
116 | /* | |
117 | * Start or stop the firmware. Memory width bit should be | |
118 | * preserved from the value we've just read. | |
119 | */ | |
120 | reg.Action = CS_WRITE; | |
121 | reg.Offset = CISREG_CCSR; | |
122 | reg.Value = (idle ? HCR_IDLE : HCR_RUN) | (reg.Value & HCR_MEM16); | |
123 | CS_CHECK(AccessConfigurationRegister, | |
fba395ee | 124 | pcmcia_access_configuration_register(link, ®)); |
3a48c4c2 PR |
125 | udelay(1000); |
126 | ||
127 | /* Restore original COR configuration index */ | |
128 | reg.Action = CS_WRITE; | |
129 | reg.Offset = CISREG_COR; | |
130 | reg.Value = (save_cor & ~COR_SOFT_RESET); | |
131 | CS_CHECK(AccessConfigurationRegister, | |
fba395ee | 132 | pcmcia_access_configuration_register(link, ®)); |
3a48c4c2 PR |
133 | udelay(1000); |
134 | return 0; | |
135 | ||
136 | cs_failed: | |
fba395ee | 137 | cs_error(link, last_fn, last_ret); |
3a48c4c2 PR |
138 | return -ENODEV; |
139 | } | |
140 | ||
3994d502 DK |
141 | /********************************************************************/ |
142 | /* Device methods */ | |
143 | /********************************************************************/ | |
3a48c4c2 | 144 | |
3a48c4c2 | 145 | static int |
3994d502 | 146 | spectrum_cs_hard_reset(struct orinoco_private *priv) |
3a48c4c2 | 147 | { |
3994d502 DK |
148 | struct orinoco_pccard *card = priv->card; |
149 | struct pcmcia_device *link = card->p_dev; | |
3a48c4c2 | 150 | |
3994d502 DK |
151 | /* Soft reset using COR and HCR */ |
152 | spectrum_reset(link, 0); | |
3a48c4c2 PR |
153 | |
154 | return 0; | |
155 | } | |
156 | ||
3a48c4c2 | 157 | static int |
3994d502 | 158 | spectrum_cs_stop_firmware(struct orinoco_private *priv, int idle) |
3a48c4c2 PR |
159 | { |
160 | struct orinoco_pccard *card = priv->card; | |
fba395ee | 161 | struct pcmcia_device *link = card->p_dev; |
3a48c4c2 | 162 | |
3994d502 | 163 | return spectrum_reset(link, idle); |
3a48c4c2 PR |
164 | } |
165 | ||
166 | /********************************************************************/ | |
167 | /* PCMCIA stuff */ | |
168 | /********************************************************************/ | |
169 | ||
170 | /* | |
171 | * This creates an "instance" of the driver, allocating local data | |
172 | * structures for one device. The device is registered with Card | |
173 | * Services. | |
174 | * | |
175 | * The dev_link structure is initialized, but we don't actually | |
176 | * configure the card at this point -- we wait until we receive a card | |
177 | * insertion event. */ | |
f8cfa618 | 178 | static int |
15b99ac1 | 179 | spectrum_cs_probe(struct pcmcia_device *link) |
3a48c4c2 PR |
180 | { |
181 | struct net_device *dev; | |
182 | struct orinoco_private *priv; | |
183 | struct orinoco_pccard *card; | |
3a48c4c2 | 184 | |
3994d502 DK |
185 | dev = alloc_orinocodev(sizeof(*card), &handle_to_dev(link), |
186 | spectrum_cs_hard_reset, | |
187 | spectrum_cs_stop_firmware); | |
3a48c4c2 | 188 | if (! dev) |
f8cfa618 | 189 | return -ENOMEM; |
3a48c4c2 PR |
190 | priv = netdev_priv(dev); |
191 | card = priv->card; | |
192 | ||
193 | /* Link both structures together */ | |
fba395ee | 194 | card->p_dev = link; |
3a48c4c2 PR |
195 | link->priv = dev; |
196 | ||
197 | /* Interrupt setup */ | |
198 | link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT; | |
199 | link->irq.IRQInfo1 = IRQ_LEVEL_ID; | |
200 | link->irq.Handler = orinoco_interrupt; | |
201 | link->irq.Instance = dev; | |
202 | ||
203 | /* General socket configuration defaults can go here. In this | |
204 | * client, we assume very little, and rely on the CIS for | |
205 | * almost everything. In most clients, many details (i.e., | |
206 | * number, sizes, and attributes of IO windows) are fixed by | |
207 | * the nature of the device, and can be hard-wired here. */ | |
208 | link->conf.Attributes = 0; | |
209 | link->conf.IntType = INT_MEMORY_AND_IO; | |
210 | ||
15b99ac1 | 211 | return spectrum_cs_config(link); |
3a48c4c2 PR |
212 | } /* spectrum_cs_attach */ |
213 | ||
214 | /* | |
215 | * This deletes a driver "instance". The device is de-registered with | |
216 | * Card Services. If it has been released, all local data structures | |
217 | * are freed. Otherwise, the structures will be freed when the device | |
218 | * is released. | |
219 | */ | |
fba395ee | 220 | static void spectrum_cs_detach(struct pcmcia_device *link) |
3a48c4c2 | 221 | { |
3a48c4c2 PR |
222 | struct net_device *dev = link->priv; |
223 | ||
e4f4f98e PR |
224 | if (link->dev_node) |
225 | unregister_netdev(dev); | |
226 | ||
e2d40963 | 227 | spectrum_cs_release(link); |
3a48c4c2 | 228 | |
3a48c4c2 PR |
229 | free_orinocodev(dev); |
230 | } /* spectrum_cs_detach */ | |
231 | ||
232 | /* | |
233 | * spectrum_cs_config() is scheduled to run after a CARD_INSERTION | |
234 | * event is received, to configure the PCMCIA socket, and to make the | |
235 | * device available to the system. | |
236 | */ | |
237 | ||
15b99ac1 | 238 | static int |
fba395ee | 239 | spectrum_cs_config(struct pcmcia_device *link) |
3a48c4c2 PR |
240 | { |
241 | struct net_device *dev = link->priv; | |
3a48c4c2 PR |
242 | struct orinoco_private *priv = netdev_priv(dev); |
243 | struct orinoco_pccard *card = priv->card; | |
244 | hermes_t *hw = &priv->hw; | |
245 | int last_fn, last_ret; | |
246 | u_char buf[64]; | |
247 | config_info_t conf; | |
3a48c4c2 PR |
248 | tuple_t tuple; |
249 | cisparse_t parse; | |
250 | void __iomem *mem; | |
251 | ||
3a48c4c2 PR |
252 | /* Look up the current Vcc */ |
253 | CS_CHECK(GetConfigurationInfo, | |
fba395ee | 254 | pcmcia_get_configuration_info(link, &conf)); |
3a48c4c2 PR |
255 | |
256 | /* | |
257 | * In this loop, we scan the CIS for configuration table | |
258 | * entries, each of which describes a valid card | |
259 | * configuration, including voltage, IO window, memory window, | |
260 | * and interrupt settings. | |
261 | * | |
262 | * We make no assumptions about the card to be configured: we | |
263 | * use just the information available in the CIS. In an ideal | |
264 | * world, this would work for any PCMCIA card, but it requires | |
265 | * a complete and accurate CIS. In practice, a driver usually | |
266 | * "knows" most of these things without consulting the CIS, | |
267 | * and most client drivers will only use the CIS to fill in | |
268 | * implementation-defined details. | |
269 | */ | |
270 | tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY; | |
af2b3b50 DB |
271 | tuple.Attributes = 0; |
272 | tuple.TupleData = buf; | |
273 | tuple.TupleDataMax = sizeof(buf); | |
274 | tuple.TupleOffset = 0; | |
fba395ee | 275 | CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple)); |
3a48c4c2 PR |
276 | while (1) { |
277 | cistpl_cftable_entry_t *cfg = &(parse.cftable_entry); | |
278 | cistpl_cftable_entry_t dflt = { .index = 0 }; | |
279 | ||
fba395ee DB |
280 | if ( (pcmcia_get_tuple_data(link, &tuple) != 0) |
281 | || (pcmcia_parse_tuple(link, &tuple, &parse) != 0)) | |
3a48c4c2 PR |
282 | goto next_entry; |
283 | ||
284 | if (cfg->flags & CISTPL_CFTABLE_DEFAULT) | |
285 | dflt = *cfg; | |
286 | if (cfg->index == 0) | |
287 | goto next_entry; | |
288 | link->conf.ConfigIndex = cfg->index; | |
289 | ||
3a48c4c2 PR |
290 | /* Use power settings for Vcc and Vpp if present */ |
291 | /* Note that the CIS values need to be rescaled */ | |
292 | if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) { | |
293 | if (conf.Vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000) { | |
294 | DEBUG(2, "spectrum_cs_config: Vcc mismatch (conf.Vcc = %d, CIS = %d)\n", conf.Vcc, cfg->vcc.param[CISTPL_POWER_VNOM] / 10000); | |
295 | if (!ignore_cis_vcc) | |
296 | goto next_entry; | |
297 | } | |
298 | } else if (dflt.vcc.present & (1 << CISTPL_POWER_VNOM)) { | |
299 | if (conf.Vcc != dflt.vcc.param[CISTPL_POWER_VNOM] / 10000) { | |
300 | DEBUG(2, "spectrum_cs_config: Vcc mismatch (conf.Vcc = %d, CIS = %d)\n", conf.Vcc, dflt.vcc.param[CISTPL_POWER_VNOM] / 10000); | |
301 | if(!ignore_cis_vcc) | |
302 | goto next_entry; | |
303 | } | |
304 | } | |
305 | ||
306 | if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM)) | |
70294b46 | 307 | link->conf.Vpp = |
3a48c4c2 PR |
308 | cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000; |
309 | else if (dflt.vpp1.present & (1 << CISTPL_POWER_VNOM)) | |
70294b46 | 310 | link->conf.Vpp = |
3a48c4c2 PR |
311 | dflt.vpp1.param[CISTPL_POWER_VNOM] / 10000; |
312 | ||
313 | /* Do we need to allocate an interrupt? */ | |
314 | link->conf.Attributes |= CONF_ENABLE_IRQ; | |
315 | ||
316 | /* IO window settings */ | |
317 | link->io.NumPorts1 = link->io.NumPorts2 = 0; | |
318 | if ((cfg->io.nwin > 0) || (dflt.io.nwin > 0)) { | |
319 | cistpl_io_t *io = | |
320 | (cfg->io.nwin) ? &cfg->io : &dflt.io; | |
321 | link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO; | |
322 | if (!(io->flags & CISTPL_IO_8BIT)) | |
323 | link->io.Attributes1 = | |
324 | IO_DATA_PATH_WIDTH_16; | |
325 | if (!(io->flags & CISTPL_IO_16BIT)) | |
326 | link->io.Attributes1 = | |
327 | IO_DATA_PATH_WIDTH_8; | |
328 | link->io.IOAddrLines = | |
329 | io->flags & CISTPL_IO_LINES_MASK; | |
330 | link->io.BasePort1 = io->win[0].base; | |
331 | link->io.NumPorts1 = io->win[0].len; | |
332 | if (io->nwin > 1) { | |
333 | link->io.Attributes2 = | |
334 | link->io.Attributes1; | |
335 | link->io.BasePort2 = io->win[1].base; | |
336 | link->io.NumPorts2 = io->win[1].len; | |
337 | } | |
338 | ||
339 | /* This reserves IO space but doesn't actually enable it */ | |
fba395ee | 340 | if (pcmcia_request_io(link, &link->io) != 0) |
3a48c4c2 PR |
341 | goto next_entry; |
342 | } | |
343 | ||
344 | ||
345 | /* If we got this far, we're cool! */ | |
346 | ||
347 | break; | |
348 | ||
349 | next_entry: | |
fba395ee DB |
350 | pcmcia_disable_device(link); |
351 | last_ret = pcmcia_get_next_tuple(link, &tuple); | |
3a48c4c2 PR |
352 | if (last_ret == CS_NO_MORE_ITEMS) { |
353 | printk(KERN_ERR PFX "GetNextTuple(): No matching " | |
354 | "CIS configuration. Maybe you need the " | |
355 | "ignore_cis_vcc=1 parameter.\n"); | |
356 | goto cs_failed; | |
357 | } | |
358 | } | |
359 | ||
360 | /* | |
361 | * Allocate an interrupt line. Note that this does not assign | |
362 | * a handler to the interrupt, unless the 'Handler' member of | |
363 | * the irq structure is initialized. | |
364 | */ | |
fba395ee | 365 | CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq)); |
3a48c4c2 PR |
366 | |
367 | /* We initialize the hermes structure before completing PCMCIA | |
368 | * configuration just in case the interrupt handler gets | |
369 | * called. */ | |
370 | mem = ioport_map(link->io.BasePort1, link->io.NumPorts1); | |
371 | if (!mem) | |
372 | goto cs_failed; | |
373 | ||
374 | hermes_struct_init(hw, mem, HERMES_16BIT_REGSPACING); | |
375 | ||
376 | /* | |
377 | * This actually configures the PCMCIA socket -- setting up | |
378 | * the I/O windows and the interrupt mapping, and putting the | |
379 | * card and host interface into "Memory and IO" mode. | |
380 | */ | |
381 | CS_CHECK(RequestConfiguration, | |
fba395ee | 382 | pcmcia_request_configuration(link, &link->conf)); |
3a48c4c2 PR |
383 | |
384 | /* Ok, we have the configuration, prepare to register the netdev */ | |
385 | dev->base_addr = link->io.BasePort1; | |
386 | dev->irq = link->irq.AssignedIRQ; | |
3a48c4c2 PR |
387 | card->node.major = card->node.minor = 0; |
388 | ||
3994d502 | 389 | /* Reset card */ |
3a48c4c2 PR |
390 | if (spectrum_cs_hard_reset(priv) != 0) { |
391 | goto failed; | |
392 | } | |
393 | ||
fba395ee | 394 | SET_NETDEV_DEV(dev, &handle_to_dev(link)); |
3a48c4c2 PR |
395 | /* Tell the stack we exist */ |
396 | if (register_netdev(dev) != 0) { | |
397 | printk(KERN_ERR PFX "register_netdev() failed\n"); | |
398 | goto failed; | |
399 | } | |
400 | ||
401 | /* At this point, the dev_node_t structure(s) needs to be | |
fd238232 | 402 | * initialized and arranged in a linked list at link->dev_node. */ |
3a48c4c2 | 403 | strcpy(card->node.dev_name, dev->name); |
fd238232 | 404 | link->dev_node = &card->node; /* link->dev_node being non-NULL is also |
3a48c4c2 PR |
405 | used to indicate that the |
406 | net_device has been registered */ | |
3a48c4c2 PR |
407 | |
408 | /* Finally, report what we've done */ | |
9a568da2 | 409 | printk(KERN_DEBUG "%s: " DRIVER_NAME " at %s, irq %d, io " |
43cb76d9 | 410 | "0x%04x-0x%04x\n", dev->name, dev->dev.parent->bus_id, |
9a568da2 PR |
411 | link->irq.AssignedIRQ, link->io.BasePort1, |
412 | link->io.BasePort1 + link->io.NumPorts1 - 1); | |
3a48c4c2 | 413 | |
15b99ac1 | 414 | return 0; |
3a48c4c2 PR |
415 | |
416 | cs_failed: | |
fba395ee | 417 | cs_error(link, last_fn, last_ret); |
3a48c4c2 PR |
418 | |
419 | failed: | |
420 | spectrum_cs_release(link); | |
15b99ac1 | 421 | return -ENODEV; |
3a48c4c2 PR |
422 | } /* spectrum_cs_config */ |
423 | ||
424 | /* | |
425 | * After a card is removed, spectrum_cs_release() will unregister the | |
426 | * device, and release the PCMCIA configuration. If the device is | |
427 | * still open, this will be postponed until it is closed. | |
428 | */ | |
429 | static void | |
fba395ee | 430 | spectrum_cs_release(struct pcmcia_device *link) |
3a48c4c2 PR |
431 | { |
432 | struct net_device *dev = link->priv; | |
433 | struct orinoco_private *priv = netdev_priv(dev); | |
434 | unsigned long flags; | |
435 | ||
436 | /* We're committed to taking the device away now, so mark the | |
437 | * hardware as unavailable */ | |
438 | spin_lock_irqsave(&priv->lock, flags); | |
439 | priv->hw_unavailable++; | |
440 | spin_unlock_irqrestore(&priv->lock, flags); | |
441 | ||
fba395ee | 442 | pcmcia_disable_device(link); |
3a48c4c2 PR |
443 | if (priv->hw.iobase) |
444 | ioport_unmap(priv->hw.iobase); | |
445 | } /* spectrum_cs_release */ | |
446 | ||
98e4c28b DB |
447 | |
448 | static int | |
fba395ee | 449 | spectrum_cs_suspend(struct pcmcia_device *link) |
98e4c28b | 450 | { |
98e4c28b DB |
451 | struct net_device *dev = link->priv; |
452 | struct orinoco_private *priv = netdev_priv(dev); | |
98e4c28b DB |
453 | int err = 0; |
454 | ||
98e4c28b | 455 | /* Mark the device as stopped, to block IO until later */ |
6cbaa330 | 456 | spin_lock(&priv->lock); |
98e4c28b | 457 | |
e2d40963 DB |
458 | err = __orinoco_down(dev); |
459 | if (err) | |
460 | printk(KERN_WARNING "%s: Error %d downing interface\n", | |
461 | dev->name, err); | |
98e4c28b | 462 | |
e2d40963 DB |
463 | netif_device_detach(dev); |
464 | priv->hw_unavailable++; | |
98e4c28b | 465 | |
6cbaa330 | 466 | spin_unlock(&priv->lock); |
98e4c28b | 467 | |
6cbaa330 | 468 | return err; |
98e4c28b DB |
469 | } |
470 | ||
471 | static int | |
fba395ee | 472 | spectrum_cs_resume(struct pcmcia_device *link) |
98e4c28b | 473 | { |
98e4c28b DB |
474 | struct net_device *dev = link->priv; |
475 | struct orinoco_private *priv = netdev_priv(dev); | |
476 | ||
e2d40963 DB |
477 | netif_device_attach(dev); |
478 | priv->hw_unavailable--; | |
479 | schedule_work(&priv->reset_work); | |
480 | ||
98e4c28b DB |
481 | return 0; |
482 | } | |
483 | ||
3a48c4c2 PR |
484 | |
485 | /********************************************************************/ | |
486 | /* Module initialization */ | |
487 | /********************************************************************/ | |
488 | ||
489 | /* Can't be declared "const" or the whole __initdata section will | |
490 | * become const */ | |
491 | static char version[] __initdata = DRIVER_NAME " " DRIVER_VERSION | |
492 | " (Pavel Roskin <proski@gnu.org>," | |
493 | " David Gibson <hermes@gibson.dropbear.id.au>, et al)"; | |
494 | ||
495 | static struct pcmcia_device_id spectrum_cs_ids[] = { | |
4ebe2eb0 | 496 | PCMCIA_DEVICE_MANF_CARD(0x026c, 0x0001), /* Symbol Spectrum24 LA4137 */ |
3a48c4c2 | 497 | PCMCIA_DEVICE_MANF_CARD(0x0104, 0x0001), /* Socket Communications CF */ |
9c8a11d7 | 498 | PCMCIA_DEVICE_PROD_ID12("Intel", "PRO/Wireless LAN PC Card", 0x816cc815, 0x6fbf459a), /* 2011B, not 2011 */ |
3a48c4c2 PR |
499 | PCMCIA_DEVICE_NULL, |
500 | }; | |
501 | MODULE_DEVICE_TABLE(pcmcia, spectrum_cs_ids); | |
502 | ||
503 | static struct pcmcia_driver orinoco_driver = { | |
504 | .owner = THIS_MODULE, | |
505 | .drv = { | |
506 | .name = DRIVER_NAME, | |
507 | }, | |
15b99ac1 | 508 | .probe = spectrum_cs_probe, |
cc3b4866 | 509 | .remove = spectrum_cs_detach, |
98e4c28b DB |
510 | .suspend = spectrum_cs_suspend, |
511 | .resume = spectrum_cs_resume, | |
3a48c4c2 PR |
512 | .id_table = spectrum_cs_ids, |
513 | }; | |
514 | ||
515 | static int __init | |
516 | init_spectrum_cs(void) | |
517 | { | |
518 | printk(KERN_DEBUG "%s\n", version); | |
519 | ||
520 | return pcmcia_register_driver(&orinoco_driver); | |
521 | } | |
522 | ||
523 | static void __exit | |
524 | exit_spectrum_cs(void) | |
525 | { | |
526 | pcmcia_unregister_driver(&orinoco_driver); | |
3a48c4c2 PR |
527 | } |
528 | ||
529 | module_init(init_spectrum_cs); | |
530 | module_exit(exit_spectrum_cs); |