Debian Codegraph @

linux/pcmcia-cs/wireless/orinoco_cs.c

raw
1 /* orinoco_cs.c 0.13e - (formerly known as dldwd_cs.c)
2 *
3 * A driver for "Hermes" chipset based PCMCIA wireless adaptors, such
4 * as the Lucent WavelanIEEE/Orinoco cards and their OEM (Cabletron/
5 * EnteraSys RoamAbout 802.11, ELSA Airlancer, Melco Buffalo and others).
6 * It should also be usable on various Prism II based cards such as the
7 * Linksys, D-Link and Farallon Skyline. It should also work on Symbol
8 * cards such as the 3Com AirConnect and Ericsson WLAN.
9 *
10 * Copyright notice & release notes in file orinoco.c
11 */
12
13 #include <linux/config.h>
14 #include <linux/module.h>
15 #include <linux/kernel.h>
16 #include <linux/init.h>
17 #include <linux/sched.h>
18 #include <linux/ptrace.h>
19 #include <linux/slab.h>
20 #include <linux/string.h>
21 #include <linux/ioport.h>
22 #include <linux/netdevice.h>
23 #include <linux/if_arp.h>
24 #include <linux/etherdevice.h>
25 #include <linux/wireless.h>
26
27 #include <pcmcia/version.h>
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
34 #include <asm/uaccess.h>
35 #include <asm/io.h>
36 #include <asm/system.h>
37
38 #include "orinoco.h"
39
40 /********************************************************************/
41 /* Module stuff */
42 /********************************************************************/
43
44 MODULE_AUTHOR("David Gibson <[email protected]>");
45 MODULE_DESCRIPTION("Driver for PCMCIA Lucent Orinoco, Prism II based and similar wireless cards");
46 #ifdef MODULE_LICENSE
47 MODULE_LICENSE("Dual MPL/GPL");
48 #endif
49
50 /* Module parameters */
51
52 /* The old way: bit map of interrupts to choose from */
53 /* This means pick from 15, 14, 12, 11, 10, 9, 7, 5, 4, and 3 */
54 static uint irq_mask = 0xdeb8;
55 /* Newer, simpler way of listing specific interrupts */
56 static int irq_list[4] = { -1 };
57
58 /* Some D-Link cards have buggy CIS. They do work at 5v properly, but
59 * don't have any CIS entry for it. This workaround it... */
60 static int ignore_cis_vcc; /* = 0 */
61
62 MODULE_PARM(irq_mask, "i");
63 MODULE_PARM(irq_list, "1-4i");
64 MODULE_PARM(ignore_cis_vcc, "i");
65
66 /********************************************************************/
67 /* Magic constants */
68 /********************************************************************/
69
70 /*
71 * The dev_info variable is the "key" that is used to match up this
72 * device driver with appropriate cards, through the card
73 * configuration database.
74 */
75 static dev_info_t dev_info = "orinoco_cs";
76
77 /********************************************************************/
78 /* Data structures */
79 /********************************************************************/
80
81 /* PCMCIA specific device information (goes in the card field of
82 * struct orinoco_private */
83 struct orinoco_pccard {
84 dev_link_t link;
85 dev_node_t node;
86
87 /* Used to handle hard reset */
88 /* yuck, we need this hack to work around the insanity of the
89 * PCMCIA layer */
90 unsigned long hard_reset_in_progress;
91 };
92
93 /*
94 * A linked list of "instances" of the device. Each actual PCMCIA
95 * card corresponds to one device instance, and is described by one
96 * dev_link_t structure (defined in ds.h).
97 */
98 static dev_link_t *dev_list; /* = NULL */
99
100 /********************************************************************/
101 /* Function prototypes */
102 /********************************************************************/
103
104 /* device methods */
105 static int orinoco_cs_hard_reset(struct orinoco_private *priv);
106
107 /* PCMCIA gumpf */
108 static void orinoco_cs_config(dev_link_t * link);
109 static void orinoco_cs_release(u_long arg);
110 static int orinoco_cs_event(event_t event, int priority,
111 event_callback_args_t * args);
112
113 static dev_link_t *orinoco_cs_attach(void);
114 static void orinoco_cs_detach(dev_link_t *);
115
116 /********************************************************************/
117 /* Device methods */
118 /********************************************************************/
119
120 static int
121 orinoco_cs_hard_reset(struct orinoco_private *priv)
122 {
123 struct orinoco_pccard *card = priv->card;
124 dev_link_t *link = &card->link;
125 int err;
126
127 /* We need atomic ops here, because we're not holding the lock */
128 set_bit(0, &card->hard_reset_in_progress);
129
130 err = CardServices(ResetCard, link->handle, NULL);
131 if (err)
132 return err;
133
134 clear_bit(0, &card->hard_reset_in_progress);
135
136 return 0;
137 }
138
139 /********************************************************************/
140 /* PCMCIA stuff */
141 /********************************************************************/
142
143 /* In 2.5 (as of 2.5.69 at least) there is a cs_error exported which
144 * does this, but it's not in 2.4 so we do our own for now. */
145 static void
146 orinoco_cs_error(client_handle_t handle, int func, int ret)
147 {
148 error_info_t err = { func, ret };
149 CardServices(ReportError, handle, &err);
150 }
151
152
153 /* Remove zombie instances (card removed, detach pending) */
154 static void
155 flush_stale_links(void)
156 {
157 dev_link_t *link, *next;
158
159 TRACE_ENTER("");
160
161 for (link = dev_list; link; link = next) {
162 next = link->next;
163 if (link->state & DEV_STALE_LINK) {
164 orinoco_cs_detach(link);
165 }
166 }
167 TRACE_EXIT("");
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. */
178 static dev_link_t *
179 orinoco_cs_attach(void)
180 {
181 struct net_device *dev;
182 struct orinoco_private *priv;
183 struct orinoco_pccard *card;
184 dev_link_t *link;
185 client_reg_t client_reg;
186 int ret, i;
187
188 /* A bit of cleanup */
189 flush_stale_links();
190
191 dev = alloc_orinocodev(sizeof(*card), orinoco_cs_hard_reset);
192 if (! dev)
193 return NULL;
194 priv = dev->priv;
195 card = priv->card;
196
197 /* Link both structures together */
198 link = &card->link;
199 link->priv = dev;
200
201 /* Initialize the dev_link_t structure */
202 init_timer(&link->release);
203 link->release.function = &orinoco_cs_release;
204 link->release.data = (u_long) link;
205
206 /* Interrupt setup */
207 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
208 link->irq.IRQInfo1 = IRQ_INFO2_VALID | IRQ_LEVEL_ID;
209 if (irq_list[0] == -1)
210 link->irq.IRQInfo2 = irq_mask;
211 else
212 for (i = 0; i < 4; i++)
213 link->irq.IRQInfo2 |= 1 << irq_list[i];
214 link->irq.Handler = NULL;
215
216 /* General socket configuration defaults can go here. In this
217 * client, we assume very little, and rely on the CIS for
218 * almost everything. In most clients, many details (i.e.,
219 * number, sizes, and attributes of IO windows) are fixed by
220 * the nature of the device, and can be hard-wired here. */
221 link->conf.Attributes = 0;
222 link->conf.IntType = INT_MEMORY_AND_IO;
223
224 /* Register with Card Services */
225 /* FIXME: need a lock? */
226 link->next = dev_list;
227 dev_list = link;
228
229 client_reg.dev_info = &dev_info;
230 client_reg.Attributes = INFO_IO_CLIENT | INFO_CARD_SHARE;
231 client_reg.EventMask =
232 CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL |
233 CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET |
234 CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME;
235 client_reg.event_handler = &orinoco_cs_event;
236 client_reg.Version = 0x0210; /* FIXME: what does this mean? */
237 client_reg.event_callback_args.client_data = link;
238
239 ret = CardServices(RegisterClient, &link->handle, &client_reg);
240 if (ret != CS_SUCCESS) {
241 orinoco_cs_error(link->handle, RegisterClient, ret);
242 orinoco_cs_detach(link);
243 return NULL;
244 }
245
246 return link;
247 } /* orinoco_cs_attach */
248
249 /*
250 * This deletes a driver "instance". The device is de-registered with
251 * Card Services. If it has been released, all local data structures
252 * are freed. Otherwise, the structures will be freed when the device
253 * is released.
254 */
255 static void
256 orinoco_cs_detach(dev_link_t * link)
257 {
258 dev_link_t **linkp;
259 struct net_device *dev = link->priv;
260
261 /* Locate device structure */
262 for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
263 if (*linkp == link)
264 break;
265 if (*linkp == NULL) {
266 BUG();
267 return;
268 }
269
270 if (link->state & DEV_CONFIG) {
271 orinoco_cs_release((u_long)link);
272 if (link->state & DEV_CONFIG) {
273 link->state |= DEV_STALE_LINK;
274 return;
275 }
276 }
277
278 /* Break the link with Card Services */
279 if (link->handle)
280 CardServices(DeregisterClient, link->handle);
281
282 /* Unlink device structure, and free it */
283 *linkp = link->next;
284 DEBUG(0, "orinoco_cs: detach: link=%p link->dev=%p\n", link, link->dev);
285 if (link->dev) {
286 DEBUG(0, "orinoco_cs: About to unregister net device %p\n",
287 dev);
288 unregister_netdev(dev);
289 }
290 kfree(dev);
291 } /* orinoco_cs_detach */
292
293 /*
294 * orinoco_cs_config() is scheduled to run after a CARD_INSERTION
295 * event is received, to configure the PCMCIA socket, and to make the
296 * device available to the system.
297 */
298
299 #define CS_CHECK(fn, args...) \
300 while ((last_ret=CardServices(last_fn=(fn),args))!=0) goto cs_failed
301
302 #define CFG_CHECK(fn, args...) \
303 if (CardServices(fn, args) != 0) goto next_entry
304
305 static void
306 orinoco_cs_config(dev_link_t *link)
307 {
308 struct net_device *dev = link->priv;
309 client_handle_t handle = link->handle;
310 struct orinoco_private *priv = dev->priv;
311 struct orinoco_pccard *card = priv->card;
312 hermes_t *hw = &priv->hw;
313 int last_fn, last_ret;
314 u_char buf[64];
315 config_info_t conf;
316 cisinfo_t info;
317 tuple_t tuple;
318 cisparse_t parse;
319
320 CS_CHECK(ValidateCIS, handle, &info);
321
322 /*
323 * This reads the card's CONFIG tuple to find its
324 * configuration registers.
325 */
326 tuple.DesiredTuple = CISTPL_CONFIG;
327 tuple.Attributes = 0;
328 tuple.TupleData = buf;
329 tuple.TupleDataMax = sizeof(buf);
330 tuple.TupleOffset = 0;
331 CS_CHECK(GetFirstTuple, handle, &tuple);
332 CS_CHECK(GetTupleData, handle, &tuple);
333 CS_CHECK(ParseTuple, handle, &tuple, &parse);
334 link->conf.ConfigBase = parse.config.base;
335 link->conf.Present = parse.config.rmask[0];
336
337 /* Configure card */
338 link->state |= DEV_CONFIG;
339
340 /* Look up the current Vcc */
341 CS_CHECK(GetConfigurationInfo, handle, &conf);
342 link->conf.Vcc = conf.Vcc;
343
344 /*
345 * In this loop, we scan the CIS for configuration table
346 * entries, each of which describes a valid card
347 * configuration, including voltage, IO window, memory window,
348 * and interrupt settings.
349 *
350 * We make no assumptions about the card to be configured: we
351 * use just the information available in the CIS. In an ideal
352 * world, this would work for any PCMCIA card, but it requires
353 * a complete and accurate CIS. In practice, a driver usually
354 * "knows" most of these things without consulting the CIS,
355 * and most client drivers will only use the CIS to fill in
356 * implementation-defined details.
357 */
358 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
359 CS_CHECK(GetFirstTuple, handle, &tuple);
360 while (1) {
361 cistpl_cftable_entry_t *cfg = &(parse.cftable_entry);
362 cistpl_cftable_entry_t dflt = { .index = 0 };
363
364 CFG_CHECK(GetTupleData, handle, &tuple);
365 CFG_CHECK(ParseTuple, handle, &tuple, &parse);
366
367 if (cfg->flags & CISTPL_CFTABLE_DEFAULT)
368 dflt = *cfg;
369 if (cfg->index == 0)
370 goto next_entry;
371 link->conf.ConfigIndex = cfg->index;
372
373 /* Does this card need audio output? */
374 if (cfg->flags & CISTPL_CFTABLE_AUDIO) {
375 link->conf.Attributes |= CONF_ENABLE_SPKR;
376 link->conf.Status = CCSR_AUDIO_ENA;
377 }
378
379 /* Use power settings for Vcc and Vpp if present */
380 /* Note that the CIS values need to be rescaled */
381 if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) {
382 if (conf.Vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000) {
383 DEBUG(2, "orinoco_cs_config: Vcc mismatch (conf.Vcc = %d, CIS = %d)\n", conf.Vcc, cfg->vcc.param[CISTPL_POWER_VNOM] / 10000);
384 if (!ignore_cis_vcc)
385 goto next_entry;
386 }
387 } else if (dflt.vcc.present & (1 << CISTPL_POWER_VNOM)) {
388 if (conf.Vcc != dflt.vcc.param[CISTPL_POWER_VNOM] / 10000) {
389 DEBUG(2, "orinoco_cs_config: Vcc mismatch (conf.Vcc = %d, CIS = %d)\n", conf.Vcc, dflt.vcc.param[CISTPL_POWER_VNOM] / 10000);
390 if(!ignore_cis_vcc)
391 goto next_entry;
392 }
393 }
394
395 if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM))
396 link->conf.Vpp1 = link->conf.Vpp2 =
397 cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000;
398 else if (dflt.vpp1.present & (1 << CISTPL_POWER_VNOM))
399 link->conf.Vpp1 = link->conf.Vpp2 =
400 dflt.vpp1.param[CISTPL_POWER_VNOM] / 10000;
401
402 /* Do we need to allocate an interrupt? */
403 if (cfg->irq.IRQInfo1 || dflt.irq.IRQInfo1)
404 link->conf.Attributes |= CONF_ENABLE_IRQ;
405
406 /* IO window settings */
407 link->io.NumPorts1 = link->io.NumPorts2 = 0;
408 if ((cfg->io.nwin > 0) || (dflt.io.nwin > 0)) {
409 cistpl_io_t *io =
410 (cfg->io.nwin) ? &cfg->io : &dflt.io;
411 link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
412 if (!(io->flags & CISTPL_IO_8BIT))
413 link->io.Attributes1 =
414 IO_DATA_PATH_WIDTH_16;
415 if (!(io->flags & CISTPL_IO_16BIT))
416 link->io.Attributes1 =
417 IO_DATA_PATH_WIDTH_8;
418 link->io.IOAddrLines =
419 io->flags & CISTPL_IO_LINES_MASK;
420 link->io.BasePort1 = io->win[0].base;
421 link->io.NumPorts1 = io->win[0].len;
422 if (io->nwin > 1) {
423 link->io.Attributes2 =
424 link->io.Attributes1;
425 link->io.BasePort2 = io->win[1].base;
426 link->io.NumPorts2 = io->win[1].len;
427 }
428
429 /* This reserves IO space but doesn't actually enable it */
430 CFG_CHECK(RequestIO, link->handle, &link->io);
431 }
432
433
434 /* If we got this far, we're cool! */
435
436 break;
437
438 next_entry:
439 if (link->io.NumPorts1)
440 CardServices(ReleaseIO, link->handle, &link->io);
441 last_ret = CardServices(GetNextTuple, handle, &tuple);
442 if (last_ret == CS_NO_MORE_ITEMS) {
443 printk(KERN_ERR "GetNextTuple(). No matching CIS configuration, "
444 "maybe you need the ignore_cis_vcc=1 parameter.\n");
445 goto cs_failed;
446 }
447 }
448
449 /*
450 * Allocate an interrupt line. Note that this does not assign
451 * a handler to the interrupt, unless the 'Handler' member of
452 * the irq structure is initialized.
453 */
454 if (link->conf.Attributes & CONF_ENABLE_IRQ) {
455 int i;
456
457 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
458 link->irq.IRQInfo1 = IRQ_INFO2_VALID | IRQ_LEVEL_ID;
459 if (irq_list[0] == -1)
460 link->irq.IRQInfo2 = irq_mask;
461 else
462 for (i=0; i<4; i++)
463 link->irq.IRQInfo2 |= 1 << irq_list[i];
464
465 link->irq.Handler = orinoco_interrupt;
466 link->irq.Instance = dev;
467
468 CS_CHECK(RequestIRQ, link->handle, &link->irq);
469 }
470
471 /* We initialize the hermes structure before completing PCMCIA
472 * configuration just in case the interrupt handler gets
473 * called. */
474 hermes_struct_init(hw, link->io.BasePort1,
475 HERMES_IO, HERMES_16BIT_REGSPACING);
476
477 /*
478 * This actually configures the PCMCIA socket -- setting up
479 * the I/O windows and the interrupt mapping, and putting the
480 * card and host interface into "Memory and IO" mode.
481 */
482 CS_CHECK(RequestConfiguration, link->handle, &link->conf);
483
484 /* Ok, we have the configuration, prepare to register the netdev */
485 dev->base_addr = link->io.BasePort1;
486 dev->irq = link->irq.AssignedIRQ;
487 SET_MODULE_OWNER(dev);
488 card->node.major = card->node.minor = 0;
489
490 /* register_netdev will give us an ethX name */
491 dev->name[0] = '\0';
492 /* Tell the stack we exist */
493 if (register_netdev(dev) != 0) {
494 printk(KERN_ERR "orinoco_cs: register_netdev() failed\n");
495 goto failed;
496 }
497
498 /* At this point, the dev_node_t structure(s) needs to be
499 * initialized and arranged in a linked list at link->dev. */
500 strcpy(card->node.dev_name, dev->name);
501 link->dev = &card->node; /* link->dev being non-NULL is also
502 used to indicate that the
503 net_device has been registered */
504 link->state &= ~DEV_CONFIG_PENDING;
505
506 /* Finally, report what we've done */
507 printk(KERN_DEBUG "%s: index 0x%02x: Vcc %d.%d",
508 dev->name, link->conf.ConfigIndex,
509 link->conf.Vcc / 10, link->conf.Vcc % 10);
510 if (link->conf.Vpp1)
511 printk(", Vpp %d.%d", link->conf.Vpp1 / 10,
512 link->conf.Vpp1 % 10);
513 if (link->conf.Attributes & CONF_ENABLE_IRQ)
514 printk(", irq %d", link->irq.AssignedIRQ);
515 if (link->io.NumPorts1)
516 printk(", io 0x%04x-0x%04x", link->io.BasePort1,
517 link->io.BasePort1 + link->io.NumPorts1 - 1);
518 if (link->io.NumPorts2)
519 printk(" & 0x%04x-0x%04x", link->io.BasePort2,
520 link->io.BasePort2 + link->io.NumPorts2 - 1);
521 printk("\n");
522
523 return;
524
525 cs_failed:
526 orinoco_cs_error(link->handle, last_fn, last_ret);
527
528 failed:
529 orinoco_cs_release((u_long) link);
530 } /* orinoco_cs_config */
531
532 /*
533 * After a card is removed, orinoco_cs_release() will unregister the
534 * device, and release the PCMCIA configuration. If the device is
535 * still open, this will be postponed until it is closed.
536 */
537 static void
538 orinoco_cs_release(u_long arg)
539 {
540 dev_link_t *link = (dev_link_t *) arg;
541 struct net_device *dev = link->priv;
542 struct orinoco_private *priv = dev->priv;
543 unsigned long flags;
544
545 /* We're committed to taking the device away now, so mark the
546 * hardware as unavailable */
547 spin_lock_irqsave(&priv->lock, flags);
548 priv->hw_unavailable++;
549 spin_unlock_irqrestore(&priv->lock, flags);
550
551 /* Don't bother checking to see if these succeed or not */
552 CardServices(ReleaseConfiguration, link->handle);
553 if (link->io.NumPorts1)
554 CardServices(ReleaseIO, link->handle, &link->io);
555 if (link->irq.AssignedIRQ)
556 CardServices(ReleaseIRQ, link->handle, &link->irq);
557 link->state &= ~DEV_CONFIG;
558 } /* orinoco_cs_release */
559
560 /*
561 * The card status event handler. Mostly, this schedules other stuff
562 * to run after an event is received.
563 */
564 static int
565 orinoco_cs_event(event_t event, int priority,
566 event_callback_args_t * args)
567 {
568 dev_link_t *link = args->client_data;
569 struct net_device *dev = link->priv;
570 struct orinoco_private *priv = dev->priv;
571 struct orinoco_pccard *card = priv->card;
572 int err = 0;
573 unsigned long flags;
574
575 switch (event) {
576 case CS_EVENT_CARD_REMOVAL:
577 link->state &= ~DEV_PRESENT;
578 if (link->state & DEV_CONFIG) {
579 orinoco_lock(priv, &flags);
580
581 netif_device_detach(dev);
582 priv->hw_unavailable++;
583
584 orinoco_unlock(priv, &flags);
585 }
586 break;
587
588 case CS_EVENT_CARD_INSERTION:
589 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
590 orinoco_cs_config(link);
591 break;
592
593 case CS_EVENT_PM_SUSPEND:
594 link->state |= DEV_SUSPEND;
595 /* Fall through... */
596 case CS_EVENT_RESET_PHYSICAL:
597 /* Mark the device as stopped, to block IO until later */
598 if (link->state & DEV_CONFIG) {
599 /* This is probably racy, but I can't think of
600 a better way, short of rewriting the PCMCIA
601 layer to not suck :-( */
602 if (! test_bit(0, &card->hard_reset_in_progress)) {
603 spin_lock_irqsave(&priv->lock, flags);
604
605 err = __orinoco_down(dev);
606 if (err)
607 printk(KERN_WARNING "%s: %s: Error %d downing interface\n",
608 dev->name,
609 event == CS_EVENT_PM_SUSPEND ? "SUSPEND" : "RESET_PHYSICAL",
610 err);
611
612 netif_device_detach(dev);
613 priv->hw_unavailable++;
614
615 spin_unlock_irqrestore(&priv->lock, flags);
616 }
617
618 CardServices(ReleaseConfiguration, link->handle);
619 }
620 break;
621
622 case CS_EVENT_PM_RESUME:
623 link->state &= ~DEV_SUSPEND;
624 /* Fall through... */
625 case CS_EVENT_CARD_RESET:
626 if (link->state & DEV_CONFIG) {
627 /* FIXME: should we double check that this is
628 * the same card as we had before */
629 CardServices(RequestConfiguration, link->handle,
630 &link->conf);
631
632 if (! test_bit(0, &card->hard_reset_in_progress)) {
633 err = orinoco_reinit_firmware(dev);
634 if (err) {
635 printk(KERN_ERR "%s: Error %d re-initializing firmware\n",
636 dev->name, err);
637 break;
638 }
639
640 spin_lock_irqsave(&priv->lock, flags);
641
642 netif_device_attach(dev);
643 priv->hw_unavailable--;
644
645 if (priv->open && ! priv->hw_unavailable) {
646 err = __orinoco_up(dev);
647 if (err)
648 printk(KERN_ERR "%s: Error %d restarting card\n",
649 dev->name, err);
650
651 }
652
653 spin_unlock_irqrestore(&priv->lock, flags);
654 }
655 }
656 break;
657 }
658
659 return err;
660 } /* orinoco_cs_event */
661
662 /********************************************************************/
663 /* Module initialization */
664 /********************************************************************/
665
666 /* Can't be declared "const" or the whole __initdata section will
667 * become const */
668 static char version[] __initdata = "orinoco_cs.c 0.13e (David Gibson <[email protected]> and others)";
669
670 static int __init
671 init_orinoco_cs(void)
672 {
673 servinfo_t serv;
674
675 printk(KERN_DEBUG "%s\n", version);
676
677 CardServices(GetCardServicesInfo, &serv);
678 if (serv.Revision != CS_RELEASE_CODE) {
679 printk(KERN_NOTICE "orinoco_cs: Card Services release "
680 "does not match!\n");
681 return -EINVAL;
682 }
683
684 register_pccard_driver(&dev_info, &orinoco_cs_attach, &orinoco_cs_detach);
685
686 return 0;
687 }
688
689 static void __exit
690 exit_orinoco_cs(void)
691 {
692 unregister_pccard_driver(&dev_info);
693
694 if (dev_list)
695 DEBUG(0, "orinoco_cs: Removing leftover devices.\n");
696 while (dev_list != NULL) {
697 if (dev_list->state & DEV_CONFIG)
698 orinoco_cs_release((u_long) dev_list);
699 orinoco_cs_detach(dev_list);
700 }
701 }
702
703 module_init(init_orinoco_cs);
704 module_exit(exit_orinoco_cs);
705