]>
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/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 | 75 | |
3a48c4c2 PR |
76 | /* |
77 | * Reset the card using configuration registers COR and CCSR. | |
78 | * If IDLE is 1, stop the firmware, so that it can be safely rewritten. | |
79 | */ | |
80 | static int | |
fba395ee | 81 | spectrum_reset(struct pcmcia_device *link, int idle) |
3a48c4c2 | 82 | { |
2caff147 | 83 | int ret; |
3a48c4c2 PR |
84 | conf_reg_t reg; |
85 | u_int save_cor; | |
86 | ||
87 | /* Doing it if hardware is gone is guaranteed crash */ | |
c5ab964d | 88 | if (!pcmcia_dev_present(link)) |
3a48c4c2 PR |
89 | return -ENODEV; |
90 | ||
91 | /* Save original COR value */ | |
92 | reg.Function = 0; | |
93 | reg.Action = CS_READ; | |
94 | reg.Offset = CISREG_COR; | |
2caff147 DB |
95 | ret = pcmcia_access_configuration_register(link, ®); |
96 | if (ret) | |
97 | goto failed; | |
3a48c4c2 PR |
98 | save_cor = reg.Value; |
99 | ||
100 | /* Soft-Reset card */ | |
101 | reg.Action = CS_WRITE; | |
102 | reg.Offset = CISREG_COR; | |
103 | reg.Value = (save_cor | COR_SOFT_RESET); | |
2caff147 DB |
104 | ret = pcmcia_access_configuration_register(link, ®); |
105 | if (ret) | |
106 | goto failed; | |
3a48c4c2 PR |
107 | udelay(1000); |
108 | ||
109 | /* Read CCSR */ | |
110 | reg.Action = CS_READ; | |
111 | reg.Offset = CISREG_CCSR; | |
2caff147 DB |
112 | ret = pcmcia_access_configuration_register(link, ®); |
113 | if (ret) | |
114 | goto failed; | |
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); | |
2caff147 DB |
123 | ret = pcmcia_access_configuration_register(link, ®); |
124 | if (ret) | |
125 | goto failed; | |
3a48c4c2 PR |
126 | udelay(1000); |
127 | ||
128 | /* Restore original COR configuration index */ | |
129 | reg.Action = CS_WRITE; | |
130 | reg.Offset = CISREG_COR; | |
131 | reg.Value = (save_cor & ~COR_SOFT_RESET); | |
2caff147 DB |
132 | ret = pcmcia_access_configuration_register(link, ®); |
133 | if (ret) | |
134 | goto failed; | |
3a48c4c2 PR |
135 | udelay(1000); |
136 | return 0; | |
137 | ||
2caff147 | 138 | failed: |
3a48c4c2 PR |
139 | return -ENODEV; |
140 | } | |
141 | ||
3994d502 DK |
142 | /********************************************************************/ |
143 | /* Device methods */ | |
144 | /********************************************************************/ | |
3a48c4c2 | 145 | |
3a48c4c2 | 146 | static int |
3994d502 | 147 | spectrum_cs_hard_reset(struct orinoco_private *priv) |
3a48c4c2 | 148 | { |
3994d502 DK |
149 | struct orinoco_pccard *card = priv->card; |
150 | struct pcmcia_device *link = card->p_dev; | |
3a48c4c2 | 151 | |
3994d502 DK |
152 | /* Soft reset using COR and HCR */ |
153 | spectrum_reset(link, 0); | |
3a48c4c2 PR |
154 | |
155 | return 0; | |
156 | } | |
157 | ||
3a48c4c2 | 158 | static int |
3994d502 | 159 | spectrum_cs_stop_firmware(struct orinoco_private *priv, int idle) |
3a48c4c2 PR |
160 | { |
161 | struct orinoco_pccard *card = priv->card; | |
fba395ee | 162 | struct pcmcia_device *link = card->p_dev; |
3a48c4c2 | 163 | |
3994d502 | 164 | return spectrum_reset(link, idle); |
3a48c4c2 PR |
165 | } |
166 | ||
167 | /********************************************************************/ | |
168 | /* PCMCIA stuff */ | |
169 | /********************************************************************/ | |
170 | ||
171 | /* | |
172 | * This creates an "instance" of the driver, allocating local data | |
173 | * structures for one device. The device is registered with Card | |
174 | * Services. | |
d14c7c1d | 175 | * |
3a48c4c2 PR |
176 | * The dev_link structure is initialized, but we don't actually |
177 | * configure the card at this point -- we wait until we receive a card | |
178 | * insertion event. */ | |
f8cfa618 | 179 | static int |
15b99ac1 | 180 | spectrum_cs_probe(struct pcmcia_device *link) |
3a48c4c2 | 181 | { |
3a48c4c2 PR |
182 | struct orinoco_private *priv; |
183 | struct orinoco_pccard *card; | |
3a48c4c2 | 184 | |
dd2e5a15 | 185 | priv = alloc_orinocodev(sizeof(*card), &link->dev, |
a2608362 DK |
186 | spectrum_cs_hard_reset, |
187 | spectrum_cs_stop_firmware); | |
188 | if (!priv) | |
f8cfa618 | 189 | return -ENOMEM; |
3a48c4c2 PR |
190 | card = priv->card; |
191 | ||
192 | /* Link both structures together */ | |
fba395ee | 193 | card->p_dev = link; |
a2608362 | 194 | link->priv = priv; |
3a48c4c2 PR |
195 | |
196 | /* Interrupt setup */ | |
47cbb110 | 197 | link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING | IRQ_HANDLE_PRESENT; |
3a48c4c2 PR |
198 | link->irq.IRQInfo1 = IRQ_LEVEL_ID; |
199 | link->irq.Handler = orinoco_interrupt; | |
a2608362 | 200 | link->irq.Instance = priv; |
3a48c4c2 PR |
201 | |
202 | /* General socket configuration defaults can go here. In this | |
203 | * client, we assume very little, and rely on the CIS for | |
204 | * almost everything. In most clients, many details (i.e., | |
205 | * number, sizes, and attributes of IO windows) are fixed by | |
206 | * the nature of the device, and can be hard-wired here. */ | |
207 | link->conf.Attributes = 0; | |
208 | link->conf.IntType = INT_MEMORY_AND_IO; | |
209 | ||
15b99ac1 | 210 | return spectrum_cs_config(link); |
3a48c4c2 PR |
211 | } /* spectrum_cs_attach */ |
212 | ||
213 | /* | |
214 | * This deletes a driver "instance". The device is de-registered with | |
215 | * Card Services. If it has been released, all local data structures | |
216 | * are freed. Otherwise, the structures will be freed when the device | |
217 | * is released. | |
218 | */ | |
fba395ee | 219 | static void spectrum_cs_detach(struct pcmcia_device *link) |
3a48c4c2 | 220 | { |
a2608362 | 221 | struct orinoco_private *priv = link->priv; |
3a48c4c2 | 222 | |
e4f4f98e | 223 | if (link->dev_node) |
5381956b | 224 | orinoco_if_del(priv); |
e4f4f98e | 225 | |
e2d40963 | 226 | spectrum_cs_release(link); |
3a48c4c2 | 227 | |
a2608362 | 228 | free_orinocodev(priv); |
3a48c4c2 PR |
229 | } /* spectrum_cs_detach */ |
230 | ||
231 | /* | |
232 | * spectrum_cs_config() is scheduled to run after a CARD_INSERTION | |
233 | * event is received, to configure the PCMCIA socket, and to make the | |
234 | * device available to the system. | |
235 | */ | |
236 | ||
b54bf94b DB |
237 | static int spectrum_cs_config_check(struct pcmcia_device *p_dev, |
238 | cistpl_cftable_entry_t *cfg, | |
8e2fc39d | 239 | cistpl_cftable_entry_t *dflt, |
ad913c11 | 240 | unsigned int vcc, |
b54bf94b DB |
241 | void *priv_data) |
242 | { | |
b54bf94b DB |
243 | if (cfg->index == 0) |
244 | goto next_entry; | |
b54bf94b DB |
245 | |
246 | /* Use power settings for Vcc and Vpp if present */ | |
247 | /* Note that the CIS values need to be rescaled */ | |
248 | if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) { | |
ad913c11 | 249 | if (vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000) { |
62d714e5 DK |
250 | DEBUG(2, "%s: Vcc mismatch (vcc = %d, CIS = %d)\n", |
251 | __func__, vcc, | |
252 | cfg->vcc.param[CISTPL_POWER_VNOM] / 10000); | |
b54bf94b DB |
253 | if (!ignore_cis_vcc) |
254 | goto next_entry; | |
255 | } | |
8e2fc39d | 256 | } else if (dflt->vcc.present & (1 << CISTPL_POWER_VNOM)) { |
ad913c11 | 257 | if (vcc != dflt->vcc.param[CISTPL_POWER_VNOM] / 10000) { |
62d714e5 DK |
258 | DEBUG(2, "%s: Vcc mismatch (vcc = %d, CIS = %d)\n", |
259 | __func__, vcc, | |
260 | dflt->vcc.param[CISTPL_POWER_VNOM] / 10000); | |
b54bf94b DB |
261 | if (!ignore_cis_vcc) |
262 | goto next_entry; | |
263 | } | |
264 | } | |
265 | ||
266 | if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM)) | |
267 | p_dev->conf.Vpp = | |
268 | cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000; | |
8e2fc39d | 269 | else if (dflt->vpp1.present & (1 << CISTPL_POWER_VNOM)) |
b54bf94b | 270 | p_dev->conf.Vpp = |
8e2fc39d | 271 | dflt->vpp1.param[CISTPL_POWER_VNOM] / 10000; |
b54bf94b DB |
272 | |
273 | /* Do we need to allocate an interrupt? */ | |
274 | p_dev->conf.Attributes |= CONF_ENABLE_IRQ; | |
275 | ||
276 | /* IO window settings */ | |
277 | p_dev->io.NumPorts1 = p_dev->io.NumPorts2 = 0; | |
8e2fc39d DB |
278 | if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) { |
279 | cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io; | |
b54bf94b DB |
280 | p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO; |
281 | if (!(io->flags & CISTPL_IO_8BIT)) | |
282 | p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_16; | |
283 | if (!(io->flags & CISTPL_IO_16BIT)) | |
284 | p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_8; | |
285 | p_dev->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK; | |
286 | p_dev->io.BasePort1 = io->win[0].base; | |
287 | p_dev->io.NumPorts1 = io->win[0].len; | |
288 | if (io->nwin > 1) { | |
289 | p_dev->io.Attributes2 = p_dev->io.Attributes1; | |
290 | p_dev->io.BasePort2 = io->win[1].base; | |
291 | p_dev->io.NumPorts2 = io->win[1].len; | |
292 | } | |
293 | ||
294 | /* This reserves IO space but doesn't actually enable it */ | |
295 | if (pcmcia_request_io(p_dev, &p_dev->io) != 0) | |
296 | goto next_entry; | |
297 | } | |
298 | return 0; | |
299 | ||
300 | next_entry: | |
301 | pcmcia_disable_device(p_dev); | |
302 | return -ENODEV; | |
303 | }; | |
304 | ||
15b99ac1 | 305 | static int |
fba395ee | 306 | spectrum_cs_config(struct pcmcia_device *link) |
3a48c4c2 | 307 | { |
a2608362 | 308 | struct orinoco_private *priv = link->priv; |
3a48c4c2 PR |
309 | struct orinoco_pccard *card = priv->card; |
310 | hermes_t *hw = &priv->hw; | |
2caff147 | 311 | int ret; |
3a48c4c2 PR |
312 | void __iomem *mem; |
313 | ||
3a48c4c2 PR |
314 | /* |
315 | * In this loop, we scan the CIS for configuration table | |
316 | * entries, each of which describes a valid card | |
317 | * configuration, including voltage, IO window, memory window, | |
318 | * and interrupt settings. | |
319 | * | |
320 | * We make no assumptions about the card to be configured: we | |
321 | * use just the information available in the CIS. In an ideal | |
322 | * world, this would work for any PCMCIA card, but it requires | |
323 | * a complete and accurate CIS. In practice, a driver usually | |
324 | * "knows" most of these things without consulting the CIS, | |
325 | * and most client drivers will only use the CIS to fill in | |
326 | * implementation-defined details. | |
327 | */ | |
2caff147 DB |
328 | ret = pcmcia_loop_config(link, spectrum_cs_config_check, NULL); |
329 | if (ret) { | |
b54bf94b | 330 | if (!ignore_cis_vcc) |
3a48c4c2 PR |
331 | printk(KERN_ERR PFX "GetNextTuple(): No matching " |
332 | "CIS configuration. Maybe you need the " | |
333 | "ignore_cis_vcc=1 parameter.\n"); | |
b54bf94b | 334 | goto failed; |
3a48c4c2 PR |
335 | } |
336 | ||
337 | /* | |
338 | * Allocate an interrupt line. Note that this does not assign | |
339 | * a handler to the interrupt, unless the 'Handler' member of | |
340 | * the irq structure is initialized. | |
341 | */ | |
2caff147 DB |
342 | ret = pcmcia_request_irq(link, &link->irq); |
343 | if (ret) | |
344 | goto failed; | |
3a48c4c2 PR |
345 | |
346 | /* We initialize the hermes structure before completing PCMCIA | |
347 | * configuration just in case the interrupt handler gets | |
348 | * called. */ | |
349 | mem = ioport_map(link->io.BasePort1, link->io.NumPorts1); | |
350 | if (!mem) | |
2caff147 | 351 | goto failed; |
3a48c4c2 PR |
352 | |
353 | hermes_struct_init(hw, mem, HERMES_16BIT_REGSPACING); | |
354 | ||
355 | /* | |
356 | * This actually configures the PCMCIA socket -- setting up | |
357 | * the I/O windows and the interrupt mapping, and putting the | |
358 | * card and host interface into "Memory and IO" mode. | |
359 | */ | |
2caff147 DB |
360 | ret = pcmcia_request_configuration(link, &link->conf); |
361 | if (ret) | |
362 | goto failed; | |
3a48c4c2 PR |
363 | |
364 | /* Ok, we have the configuration, prepare to register the netdev */ | |
3a48c4c2 PR |
365 | card->node.major = card->node.minor = 0; |
366 | ||
3994d502 | 367 | /* Reset card */ |
d14c7c1d | 368 | if (spectrum_cs_hard_reset(priv) != 0) |
3a48c4c2 | 369 | goto failed; |
3a48c4c2 | 370 | |
8e638267 DK |
371 | /* Initialise the main driver */ |
372 | if (orinoco_init(priv) != 0) { | |
373 | printk(KERN_ERR PFX "orinoco_init() failed\n"); | |
374 | goto failed; | |
375 | } | |
376 | ||
5381956b DK |
377 | /* Register an interface with the stack */ |
378 | if (orinoco_if_add(priv, link->io.BasePort1, | |
379 | link->irq.AssignedIRQ) != 0) { | |
380 | printk(KERN_ERR PFX "orinoco_if_add() failed\n"); | |
3a48c4c2 PR |
381 | goto failed; |
382 | } | |
383 | ||
384 | /* At this point, the dev_node_t structure(s) needs to be | |
fd238232 | 385 | * initialized and arranged in a linked list at link->dev_node. */ |
5381956b | 386 | strcpy(card->node.dev_name, priv->ndev->name); |
fd238232 | 387 | link->dev_node = &card->node; /* link->dev_node being non-NULL is also |
d14c7c1d AB |
388 | * used to indicate that the |
389 | * net_device has been registered */ | |
15b99ac1 | 390 | return 0; |
3a48c4c2 | 391 | |
3a48c4c2 PR |
392 | failed: |
393 | spectrum_cs_release(link); | |
15b99ac1 | 394 | return -ENODEV; |
3a48c4c2 PR |
395 | } /* spectrum_cs_config */ |
396 | ||
397 | /* | |
398 | * After a card is removed, spectrum_cs_release() will unregister the | |
399 | * device, and release the PCMCIA configuration. If the device is | |
400 | * still open, this will be postponed until it is closed. | |
401 | */ | |
402 | static void | |
fba395ee | 403 | spectrum_cs_release(struct pcmcia_device *link) |
3a48c4c2 | 404 | { |
a2608362 | 405 | struct orinoco_private *priv = link->priv; |
3a48c4c2 PR |
406 | unsigned long flags; |
407 | ||
408 | /* We're committed to taking the device away now, so mark the | |
409 | * hardware as unavailable */ | |
410 | spin_lock_irqsave(&priv->lock, flags); | |
411 | priv->hw_unavailable++; | |
412 | spin_unlock_irqrestore(&priv->lock, flags); | |
413 | ||
fba395ee | 414 | pcmcia_disable_device(link); |
3a48c4c2 PR |
415 | if (priv->hw.iobase) |
416 | ioport_unmap(priv->hw.iobase); | |
417 | } /* spectrum_cs_release */ | |
418 | ||
98e4c28b DB |
419 | |
420 | static int | |
fba395ee | 421 | spectrum_cs_suspend(struct pcmcia_device *link) |
98e4c28b | 422 | { |
a2608362 | 423 | struct orinoco_private *priv = link->priv; |
98e4c28b DB |
424 | int err = 0; |
425 | ||
98e4c28b | 426 | /* Mark the device as stopped, to block IO until later */ |
6415f7df | 427 | orinoco_down(priv); |
98e4c28b | 428 | |
6cbaa330 | 429 | return err; |
98e4c28b DB |
430 | } |
431 | ||
432 | static int | |
fba395ee | 433 | spectrum_cs_resume(struct pcmcia_device *link) |
98e4c28b | 434 | { |
a2608362 | 435 | struct orinoco_private *priv = link->priv; |
6415f7df | 436 | int err = orinoco_up(priv); |
ac7cafd7 | 437 | |
6415f7df | 438 | return err; |
98e4c28b DB |
439 | } |
440 | ||
3a48c4c2 PR |
441 | |
442 | /********************************************************************/ | |
443 | /* Module initialization */ | |
444 | /********************************************************************/ | |
445 | ||
446 | /* Can't be declared "const" or the whole __initdata section will | |
447 | * become const */ | |
448 | static char version[] __initdata = DRIVER_NAME " " DRIVER_VERSION | |
449 | " (Pavel Roskin <proski@gnu.org>," | |
450 | " David Gibson <hermes@gibson.dropbear.id.au>, et al)"; | |
451 | ||
452 | static struct pcmcia_device_id spectrum_cs_ids[] = { | |
4ebe2eb0 | 453 | PCMCIA_DEVICE_MANF_CARD(0x026c, 0x0001), /* Symbol Spectrum24 LA4137 */ |
3a48c4c2 | 454 | PCMCIA_DEVICE_MANF_CARD(0x0104, 0x0001), /* Socket Communications CF */ |
9c8a11d7 | 455 | PCMCIA_DEVICE_PROD_ID12("Intel", "PRO/Wireless LAN PC Card", 0x816cc815, 0x6fbf459a), /* 2011B, not 2011 */ |
3a48c4c2 PR |
456 | PCMCIA_DEVICE_NULL, |
457 | }; | |
458 | MODULE_DEVICE_TABLE(pcmcia, spectrum_cs_ids); | |
459 | ||
460 | static struct pcmcia_driver orinoco_driver = { | |
461 | .owner = THIS_MODULE, | |
462 | .drv = { | |
463 | .name = DRIVER_NAME, | |
464 | }, | |
15b99ac1 | 465 | .probe = spectrum_cs_probe, |
cc3b4866 | 466 | .remove = spectrum_cs_detach, |
98e4c28b DB |
467 | .suspend = spectrum_cs_suspend, |
468 | .resume = spectrum_cs_resume, | |
3a48c4c2 PR |
469 | .id_table = spectrum_cs_ids, |
470 | }; | |
471 | ||
472 | static int __init | |
473 | init_spectrum_cs(void) | |
474 | { | |
475 | printk(KERN_DEBUG "%s\n", version); | |
476 | ||
477 | return pcmcia_register_driver(&orinoco_driver); | |
478 | } | |
479 | ||
480 | static void __exit | |
481 | exit_spectrum_cs(void) | |
482 | { | |
483 | pcmcia_unregister_driver(&orinoco_driver); | |
3a48c4c2 PR |
484 | } |
485 | ||
486 | module_init(init_spectrum_cs); | |
487 | module_exit(exit_spectrum_cs); |