blob: 256d31b429666dd70df2eb94d0541ec4a971cea2 [file] [log] [blame]
Pavel Roskin3a48c4c2005-09-01 20:10:06 -04001/*
2 * Driver for 802.11b cards using RAM-loadable Symbol firmware, such as
3 * Symbol Wireless Networker LA4100, 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 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
24#include <linux/config.h>
Pavel Roskin3a48c4c2005-09-01 20:10:06 -040025
26#include <linux/module.h>
27#include <linux/kernel.h>
28#include <linux/init.h>
29#include <linux/sched.h>
30#include <linux/ptrace.h>
31#include <linux/slab.h>
32#include <linux/string.h>
33#include <linux/ioport.h>
34#include <linux/netdevice.h>
35#include <linux/if_arp.h>
36#include <linux/etherdevice.h>
37#include <linux/wireless.h>
Pavel Roskin65853b12005-09-16 02:15:13 -040038#include <linux/firmware.h>
Pavel Roskin3a48c4c2005-09-01 20:10:06 -040039
40#include <pcmcia/cs_types.h>
41#include <pcmcia/cs.h>
42#include <pcmcia/cistpl.h>
43#include <pcmcia/cisreg.h>
44#include <pcmcia/ds.h>
45
46#include <asm/uaccess.h>
47#include <asm/io.h>
48#include <asm/system.h>
49
50#include "orinoco.h"
51
Pavel Roskin3a48c4c2005-09-01 20:10:06 -040052static unsigned char *primsym;
53static unsigned char *secsym;
54static const char primary_fw_name[] = "symbol_sp24t_prim_fw";
55static const char secondary_fw_name[] = "symbol_sp24t_sec_fw";
Pavel Roskin3a48c4c2005-09-01 20:10:06 -040056
57/********************************************************************/
58/* Module stuff */
59/********************************************************************/
60
61MODULE_AUTHOR("Pavel Roskin <proski@gnu.org>");
62MODULE_DESCRIPTION("Driver for Symbol Spectrum24 Trilogy cards with firmware downloader");
63MODULE_LICENSE("Dual MPL/GPL");
64
65/* Module parameters */
66
67/* Some D-Link cards have buggy CIS. They do work at 5v properly, but
68 * don't have any CIS entry for it. This workaround it... */
69static int ignore_cis_vcc; /* = 0 */
70module_param(ignore_cis_vcc, int, 0);
71MODULE_PARM_DESC(ignore_cis_vcc, "Allow voltage mismatch between card and socket");
72
73/********************************************************************/
74/* Magic constants */
75/********************************************************************/
76
77/*
78 * The dev_info variable is the "key" that is used to match up this
79 * device driver with appropriate cards, through the card
80 * configuration database.
81 */
82static dev_info_t dev_info = DRIVER_NAME;
83
84/********************************************************************/
85/* Data structures */
86/********************************************************************/
87
88/* PCMCIA specific device information (goes in the card field of
89 * struct orinoco_private */
90struct orinoco_pccard {
91 dev_link_t link;
92 dev_node_t node;
93};
94
95/*
96 * A linked list of "instances" of the device. Each actual PCMCIA
97 * card corresponds to one device instance, and is described by one
98 * dev_link_t structure (defined in ds.h).
99 */
100static dev_link_t *dev_list; /* = NULL */
101
102/********************************************************************/
103/* Function prototypes */
104/********************************************************************/
105
106/* device methods */
107static int spectrum_cs_hard_reset(struct orinoco_private *priv);
108
109/* PCMCIA gumpf */
110static void spectrum_cs_config(dev_link_t * link);
111static void spectrum_cs_release(dev_link_t * link);
112static int spectrum_cs_event(event_t event, int priority,
113 event_callback_args_t * args);
114
115static dev_link_t *spectrum_cs_attach(void);
116static void spectrum_cs_detach(dev_link_t *);
117
118/********************************************************************/
119/* Firmware downloader */
120/********************************************************************/
121
122/* Position of PDA in the adapter memory */
123#define EEPROM_ADDR 0x3000
124#define EEPROM_LEN 0x200
125#define PDA_OFFSET 0x100
126
127#define PDA_ADDR (EEPROM_ADDR + PDA_OFFSET)
128#define PDA_WORDS ((EEPROM_LEN - PDA_OFFSET) / 2)
129
130/* Constants for the CISREG_CCSR register */
131#define HCR_RUN 0x07 /* run firmware after reset */
132#define HCR_IDLE 0x0E /* don't run firmware after reset */
133#define HCR_MEM16 0x10 /* memory width bit, should be preserved */
134
135/*
136 * AUX port access. To unlock the AUX port write the access keys to the
137 * PARAM0-2 registers, then write HERMES_AUX_ENABLE to the HERMES_CONTROL
138 * register. Then read it and make sure it's HERMES_AUX_ENABLED.
139 */
140#define HERMES_AUX_ENABLE 0x8000 /* Enable auxiliary port access */
141#define HERMES_AUX_DISABLE 0x4000 /* Disable to auxiliary port access */
142#define HERMES_AUX_ENABLED 0xC000 /* Auxiliary port is open */
143
144#define HERMES_AUX_PW0 0xFE01
145#define HERMES_AUX_PW1 0xDC23
146#define HERMES_AUX_PW2 0xBA45
147
148/* End markers */
149#define PDI_END 0x00000000 /* End of PDA */
150#define BLOCK_END 0xFFFFFFFF /* Last image block */
151#define TEXT_END 0x1A /* End of text header */
152
153/*
154 * The following structures have little-endian fields denoted by
155 * the leading underscore. Don't access them directly - use inline
156 * functions defined below.
157 */
158
159/*
160 * The binary image to be downloaded consists of series of data blocks.
161 * Each block has the following structure.
162 */
163struct dblock {
164 u32 _addr; /* adapter address where to write the block */
165 u16 _len; /* length of the data only, in bytes */
166 char data[0]; /* data to be written */
167} __attribute__ ((packed));
168
169/*
170 * Plug Data References are located in in the image after the last data
171 * block. They refer to areas in the adapter memory where the plug data
172 * items with matching ID should be written.
173 */
174struct pdr {
175 u32 _id; /* record ID */
176 u32 _addr; /* adapter address where to write the data */
177 u32 _len; /* expected length of the data, in bytes */
178 char next[0]; /* next PDR starts here */
179} __attribute__ ((packed));
180
181
182/*
183 * Plug Data Items are located in the EEPROM read from the adapter by
184 * primary firmware. They refer to the device-specific data that should
185 * be plugged into the secondary firmware.
186 */
187struct pdi {
188 u16 _len; /* length of ID and data, in words */
189 u16 _id; /* record ID */
190 char data[0]; /* plug data */
191} __attribute__ ((packed));;
192
193
194/* Functions for access to little-endian data */
195static inline u32
196dblock_addr(const struct dblock *blk)
197{
198 return le32_to_cpu(blk->_addr);
199}
200
201static inline u32
202dblock_len(const struct dblock *blk)
203{
204 return le16_to_cpu(blk->_len);
205}
206
207static inline u32
208pdr_id(const struct pdr *pdr)
209{
210 return le32_to_cpu(pdr->_id);
211}
212
213static inline u32
214pdr_addr(const struct pdr *pdr)
215{
216 return le32_to_cpu(pdr->_addr);
217}
218
219static inline u32
220pdr_len(const struct pdr *pdr)
221{
222 return le32_to_cpu(pdr->_len);
223}
224
225static inline u32
226pdi_id(const struct pdi *pdi)
227{
228 return le16_to_cpu(pdi->_id);
229}
230
231/* Return length of the data only, in bytes */
232static inline u32
233pdi_len(const struct pdi *pdi)
234{
235 return 2 * (le16_to_cpu(pdi->_len) - 1);
236}
237
238
239/* Set address of the auxiliary port */
240static inline void
241spectrum_aux_setaddr(hermes_t *hw, u32 addr)
242{
243 hermes_write_reg(hw, HERMES_AUXPAGE, (u16) (addr >> 7));
244 hermes_write_reg(hw, HERMES_AUXOFFSET, (u16) (addr & 0x7F));
245}
246
247
248/* Open access to the auxiliary port */
249static int
250spectrum_aux_open(hermes_t *hw)
251{
252 int i;
253
254 /* Already open? */
255 if (hermes_read_reg(hw, HERMES_CONTROL) == HERMES_AUX_ENABLED)
256 return 0;
257
258 hermes_write_reg(hw, HERMES_PARAM0, HERMES_AUX_PW0);
259 hermes_write_reg(hw, HERMES_PARAM1, HERMES_AUX_PW1);
260 hermes_write_reg(hw, HERMES_PARAM2, HERMES_AUX_PW2);
261 hermes_write_reg(hw, HERMES_CONTROL, HERMES_AUX_ENABLE);
262
263 for (i = 0; i < 20; i++) {
264 udelay(10);
265 if (hermes_read_reg(hw, HERMES_CONTROL) ==
266 HERMES_AUX_ENABLED)
267 return 0;
268 }
269
270 return -EBUSY;
271}
272
273
274#define CS_CHECK(fn, ret) \
275 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
276
277/*
278 * Reset the card using configuration registers COR and CCSR.
279 * If IDLE is 1, stop the firmware, so that it can be safely rewritten.
280 */
281static int
282spectrum_reset(dev_link_t *link, int idle)
283{
284 int last_ret, last_fn;
285 conf_reg_t reg;
286 u_int save_cor;
287
288 /* Doing it if hardware is gone is guaranteed crash */
289 if (!(link->state & DEV_CONFIG))
290 return -ENODEV;
291
292 /* Save original COR value */
293 reg.Function = 0;
294 reg.Action = CS_READ;
295 reg.Offset = CISREG_COR;
296 CS_CHECK(AccessConfigurationRegister,
297 pcmcia_access_configuration_register(link->handle, &reg));
298 save_cor = reg.Value;
299
300 /* Soft-Reset card */
301 reg.Action = CS_WRITE;
302 reg.Offset = CISREG_COR;
303 reg.Value = (save_cor | COR_SOFT_RESET);
304 CS_CHECK(AccessConfigurationRegister,
305 pcmcia_access_configuration_register(link->handle, &reg));
306 udelay(1000);
307
308 /* Read CCSR */
309 reg.Action = CS_READ;
310 reg.Offset = CISREG_CCSR;
311 CS_CHECK(AccessConfigurationRegister,
312 pcmcia_access_configuration_register(link->handle, &reg));
313
314 /*
315 * Start or stop the firmware. Memory width bit should be
316 * preserved from the value we've just read.
317 */
318 reg.Action = CS_WRITE;
319 reg.Offset = CISREG_CCSR;
320 reg.Value = (idle ? HCR_IDLE : HCR_RUN) | (reg.Value & HCR_MEM16);
321 CS_CHECK(AccessConfigurationRegister,
322 pcmcia_access_configuration_register(link->handle, &reg));
323 udelay(1000);
324
325 /* Restore original COR configuration index */
326 reg.Action = CS_WRITE;
327 reg.Offset = CISREG_COR;
328 reg.Value = (save_cor & ~COR_SOFT_RESET);
329 CS_CHECK(AccessConfigurationRegister,
330 pcmcia_access_configuration_register(link->handle, &reg));
331 udelay(1000);
332 return 0;
333
334 cs_failed:
335 cs_error(link->handle, last_fn, last_ret);
336 return -ENODEV;
337}
338
339
340/*
341 * Scan PDR for the record with the specified RECORD_ID.
342 * If it's not found, return NULL.
343 */
344static struct pdr *
345spectrum_find_pdr(struct pdr *first_pdr, u32 record_id)
346{
347 struct pdr *pdr = first_pdr;
348
349 while (pdr_id(pdr) != PDI_END) {
350 /*
351 * PDR area is currently not terminated by PDI_END.
352 * It's followed by CRC records, which have the type
353 * field where PDR has length. The type can be 0 or 1.
354 */
355 if (pdr_len(pdr) < 2)
356 return NULL;
357
358 /* If the record ID matches, we are done */
359 if (pdr_id(pdr) == record_id)
360 return pdr;
361
362 pdr = (struct pdr *) pdr->next;
363 }
364 return NULL;
365}
366
367
368/* Process one Plug Data Item - find corresponding PDR and plug it */
369static int
370spectrum_plug_pdi(hermes_t *hw, struct pdr *first_pdr, struct pdi *pdi)
371{
372 struct pdr *pdr;
373
374 /* Find the PDI corresponding to this PDR */
375 pdr = spectrum_find_pdr(first_pdr, pdi_id(pdi));
376
377 /* No match is found, safe to ignore */
378 if (!pdr)
379 return 0;
380
381 /* Lengths of the data in PDI and PDR must match */
382 if (pdi_len(pdi) != pdr_len(pdr))
383 return -EINVAL;
384
385 /* do the actual plugging */
386 spectrum_aux_setaddr(hw, pdr_addr(pdr));
387 hermes_write_words(hw, HERMES_AUXDATA, pdi->data,
388 pdi_len(pdi) / 2);
389
390 return 0;
391}
392
393
394/* Read PDA from the adapter */
395static int
396spectrum_read_pda(hermes_t *hw, u16 *pda, int pda_len)
397{
398 int ret;
399 int pda_size;
400
401 /* Issue command to read EEPROM */
402 ret = hermes_docmd_wait(hw, HERMES_CMD_READMIF, 0, NULL);
403 if (ret)
404 return ret;
405
406 /* Open auxiliary port */
407 ret = spectrum_aux_open(hw);
408 if (ret)
409 return ret;
410
411 /* read PDA from EEPROM */
412 spectrum_aux_setaddr(hw, PDA_ADDR);
413 hermes_read_words(hw, HERMES_AUXDATA, pda, pda_len / 2);
414
415 /* Check PDA length */
416 pda_size = le16_to_cpu(pda[0]);
417 if (pda_size > pda_len)
418 return -EINVAL;
419
420 return 0;
421}
422
423
424/* Parse PDA and write the records into the adapter */
425static int
426spectrum_apply_pda(hermes_t *hw, const struct dblock *first_block,
427 u16 *pda)
428{
429 int ret;
430 struct pdi *pdi;
431 struct pdr *first_pdr;
432 const struct dblock *blk = first_block;
433
434 /* Skip all blocks to locate Plug Data References */
435 while (dblock_addr(blk) != BLOCK_END)
436 blk = (struct dblock *) &blk->data[dblock_len(blk)];
437
438 first_pdr = (struct pdr *) blk;
439
440 /* Go through every PDI and plug them into the adapter */
441 pdi = (struct pdi *) (pda + 2);
442 while (pdi_id(pdi) != PDI_END) {
443 ret = spectrum_plug_pdi(hw, first_pdr, pdi);
444 if (ret)
445 return ret;
446
447 /* Increment to the next PDI */
448 pdi = (struct pdi *) &pdi->data[pdi_len(pdi)];
449 }
450 return 0;
451}
452
453
454/* Load firmware blocks into the adapter */
455static int
456spectrum_load_blocks(hermes_t *hw, const struct dblock *first_block)
457{
458 const struct dblock *blk;
459 u32 blkaddr;
460 u32 blklen;
461
462 blk = first_block;
463 blkaddr = dblock_addr(blk);
464 blklen = dblock_len(blk);
465
466 while (dblock_addr(blk) != BLOCK_END) {
467 spectrum_aux_setaddr(hw, blkaddr);
468 hermes_write_words(hw, HERMES_AUXDATA, blk->data,
469 blklen / 2);
470
471 blk = (struct dblock *) &blk->data[blklen];
472 blkaddr = dblock_addr(blk);
473 blklen = dblock_len(blk);
474 }
475 return 0;
476}
477
478
479/*
480 * Process a firmware image - stop the card, load the firmware, reset
481 * the card and make sure it responds. For the secondary firmware take
482 * care of the PDA - read it and then write it on top of the firmware.
483 */
484static int
485spectrum_dl_image(hermes_t *hw, dev_link_t *link,
486 const unsigned char *image)
487{
488 int ret;
489 const unsigned char *ptr;
490 const struct dblock *first_block;
491
492 /* Plug Data Area (PDA) */
493 u16 pda[PDA_WORDS];
494
495 /* Binary block begins after the 0x1A marker */
496 ptr = image;
497 while (*ptr++ != TEXT_END);
498 first_block = (const struct dblock *) ptr;
499
500 /* Read the PDA */
501 if (image != primsym) {
502 ret = spectrum_read_pda(hw, pda, sizeof(pda));
503 if (ret)
504 return ret;
505 }
506
507 /* Stop the firmware, so that it can be safely rewritten */
508 ret = spectrum_reset(link, 1);
509 if (ret)
510 return ret;
511
512 /* Program the adapter with new firmware */
513 ret = spectrum_load_blocks(hw, first_block);
514 if (ret)
515 return ret;
516
517 /* Write the PDA to the adapter */
518 if (image != primsym) {
519 ret = spectrum_apply_pda(hw, first_block, pda);
520 if (ret)
521 return ret;
522 }
523
524 /* Run the firmware */
525 ret = spectrum_reset(link, 0);
526 if (ret)
527 return ret;
528
529 /* Reset hermes chip and make sure it responds */
530 ret = hermes_init(hw);
531
532 /* hermes_reset() should return 0 with the secondary firmware */
533 if (image != primsym && ret != 0)
534 return -ENODEV;
535
536 /* And this should work with any firmware */
537 if (!hermes_present(hw))
538 return -ENODEV;
539
540 return 0;
541}
542
543
544/*
545 * Download the firmware into the card, this also does a PCMCIA soft
546 * reset on the card, to make sure it's in a sane state.
547 */
548static int
549spectrum_dl_firmware(hermes_t *hw, dev_link_t *link)
550{
551 int ret;
552 client_handle_t handle = link->handle;
Pavel Roskin3a48c4c2005-09-01 20:10:06 -0400553 const struct firmware *fw_entry;
554
555 if (request_firmware(&fw_entry, primary_fw_name,
556 &handle_to_dev(handle)) == 0) {
557 primsym = fw_entry->data;
558 } else {
559 printk(KERN_ERR PFX "Cannot find firmware: %s\n",
560 primary_fw_name);
561 return -ENOENT;
562 }
563
564 if (request_firmware(&fw_entry, secondary_fw_name,
565 &handle_to_dev(handle)) == 0) {
566 secsym = fw_entry->data;
567 } else {
568 printk(KERN_ERR PFX "Cannot find firmware: %s\n",
569 secondary_fw_name);
570 return -ENOENT;
571 }
Pavel Roskin3a48c4c2005-09-01 20:10:06 -0400572
573 /* Load primary firmware */
574 ret = spectrum_dl_image(hw, link, primsym);
575 if (ret) {
576 printk(KERN_ERR PFX "Primary firmware download failed\n");
577 return ret;
578 }
579
580 /* Load secondary firmware */
581 ret = spectrum_dl_image(hw, link, secsym);
582
583 if (ret) {
584 printk(KERN_ERR PFX "Secondary firmware download failed\n");
585 }
586
587 return ret;
588}
589
590/********************************************************************/
591/* Device methods */
592/********************************************************************/
593
594static int
595spectrum_cs_hard_reset(struct orinoco_private *priv)
596{
597 struct orinoco_pccard *card = priv->card;
598 dev_link_t *link = &card->link;
599 int err;
600
601 if (!hermes_present(&priv->hw)) {
602 /* The firmware needs to be reloaded */
603 if (spectrum_dl_firmware(&priv->hw, &card->link) != 0) {
604 printk(KERN_ERR PFX "Firmware download failed\n");
605 err = -ENODEV;
606 }
607 } else {
608 /* Soft reset using COR and HCR */
609 spectrum_reset(link, 0);
610 }
611
612 return 0;
613}
614
615/********************************************************************/
616/* PCMCIA stuff */
617/********************************************************************/
618
619/*
620 * This creates an "instance" of the driver, allocating local data
621 * structures for one device. The device is registered with Card
622 * Services.
623 *
624 * The dev_link structure is initialized, but we don't actually
625 * configure the card at this point -- we wait until we receive a card
626 * insertion event. */
627static dev_link_t *
628spectrum_cs_attach(void)
629{
630 struct net_device *dev;
631 struct orinoco_private *priv;
632 struct orinoco_pccard *card;
633 dev_link_t *link;
634 client_reg_t client_reg;
635 int ret;
636
637 dev = alloc_orinocodev(sizeof(*card), spectrum_cs_hard_reset);
638 if (! dev)
639 return NULL;
640 priv = netdev_priv(dev);
641 card = priv->card;
642
643 /* Link both structures together */
644 link = &card->link;
645 link->priv = dev;
646
647 /* Interrupt setup */
648 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
649 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
650 link->irq.Handler = orinoco_interrupt;
651 link->irq.Instance = dev;
652
653 /* General socket configuration defaults can go here. In this
654 * client, we assume very little, and rely on the CIS for
655 * almost everything. In most clients, many details (i.e.,
656 * number, sizes, and attributes of IO windows) are fixed by
657 * the nature of the device, and can be hard-wired here. */
658 link->conf.Attributes = 0;
659 link->conf.IntType = INT_MEMORY_AND_IO;
660
661 /* Register with Card Services */
662 /* FIXME: need a lock? */
663 link->next = dev_list;
664 dev_list = link;
665
666 client_reg.dev_info = &dev_info;
667 client_reg.Version = 0x0210; /* FIXME: what does this mean? */
668 client_reg.event_callback_args.client_data = link;
669
670 ret = pcmcia_register_client(&link->handle, &client_reg);
671 if (ret != CS_SUCCESS) {
672 cs_error(link->handle, RegisterClient, ret);
673 spectrum_cs_detach(link);
674 return NULL;
675 }
676
677 return link;
678} /* spectrum_cs_attach */
679
680/*
681 * This deletes a driver "instance". The device is de-registered with
682 * Card Services. If it has been released, all local data structures
683 * are freed. Otherwise, the structures will be freed when the device
684 * is released.
685 */
686static void spectrum_cs_detach(dev_link_t *link)
687{
688 dev_link_t **linkp;
689 struct net_device *dev = link->priv;
690
691 /* Locate device structure */
692 for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
693 if (*linkp == link)
694 break;
695
696 BUG_ON(*linkp == NULL);
697
698 if (link->state & DEV_CONFIG)
699 spectrum_cs_release(link);
700
701 /* Break the link with Card Services */
702 if (link->handle)
703 pcmcia_deregister_client(link->handle);
704
705 /* Unlink device structure, and free it */
706 *linkp = link->next;
707 DEBUG(0, PFX "detach: link=%p link->dev=%p\n", link, link->dev);
708 if (link->dev) {
709 DEBUG(0, PFX "About to unregister net device %p\n",
710 dev);
711 unregister_netdev(dev);
712 }
713 free_orinocodev(dev);
714} /* spectrum_cs_detach */
715
716/*
717 * spectrum_cs_config() is scheduled to run after a CARD_INSERTION
718 * event is received, to configure the PCMCIA socket, and to make the
719 * device available to the system.
720 */
721
722static void
723spectrum_cs_config(dev_link_t *link)
724{
725 struct net_device *dev = link->priv;
726 client_handle_t handle = link->handle;
727 struct orinoco_private *priv = netdev_priv(dev);
728 struct orinoco_pccard *card = priv->card;
729 hermes_t *hw = &priv->hw;
730 int last_fn, last_ret;
731 u_char buf[64];
732 config_info_t conf;
733 cisinfo_t info;
734 tuple_t tuple;
735 cisparse_t parse;
736 void __iomem *mem;
737
738 CS_CHECK(ValidateCIS, pcmcia_validate_cis(handle, &info));
739
740 /*
741 * This reads the card's CONFIG tuple to find its
742 * configuration registers.
743 */
744 tuple.DesiredTuple = CISTPL_CONFIG;
745 tuple.Attributes = 0;
746 tuple.TupleData = buf;
747 tuple.TupleDataMax = sizeof(buf);
748 tuple.TupleOffset = 0;
749 CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
750 CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
751 CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
752 link->conf.ConfigBase = parse.config.base;
753 link->conf.Present = parse.config.rmask[0];
754
755 /* Configure card */
756 link->state |= DEV_CONFIG;
757
758 /* Look up the current Vcc */
759 CS_CHECK(GetConfigurationInfo,
760 pcmcia_get_configuration_info(handle, &conf));
761 link->conf.Vcc = conf.Vcc;
762
763 /*
764 * In this loop, we scan the CIS for configuration table
765 * entries, each of which describes a valid card
766 * configuration, including voltage, IO window, memory window,
767 * and interrupt settings.
768 *
769 * We make no assumptions about the card to be configured: we
770 * use just the information available in the CIS. In an ideal
771 * world, this would work for any PCMCIA card, but it requires
772 * a complete and accurate CIS. In practice, a driver usually
773 * "knows" most of these things without consulting the CIS,
774 * and most client drivers will only use the CIS to fill in
775 * implementation-defined details.
776 */
777 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
778 CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
779 while (1) {
780 cistpl_cftable_entry_t *cfg = &(parse.cftable_entry);
781 cistpl_cftable_entry_t dflt = { .index = 0 };
782
783 if ( (pcmcia_get_tuple_data(handle, &tuple) != 0)
784 || (pcmcia_parse_tuple(handle, &tuple, &parse) != 0))
785 goto next_entry;
786
787 if (cfg->flags & CISTPL_CFTABLE_DEFAULT)
788 dflt = *cfg;
789 if (cfg->index == 0)
790 goto next_entry;
791 link->conf.ConfigIndex = cfg->index;
792
793 /* Does this card need audio output? */
794 if (cfg->flags & CISTPL_CFTABLE_AUDIO) {
795 link->conf.Attributes |= CONF_ENABLE_SPKR;
796 link->conf.Status = CCSR_AUDIO_ENA;
797 }
798
799 /* Use power settings for Vcc and Vpp if present */
800 /* Note that the CIS values need to be rescaled */
801 if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) {
802 if (conf.Vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000) {
803 DEBUG(2, "spectrum_cs_config: Vcc mismatch (conf.Vcc = %d, CIS = %d)\n", conf.Vcc, cfg->vcc.param[CISTPL_POWER_VNOM] / 10000);
804 if (!ignore_cis_vcc)
805 goto next_entry;
806 }
807 } else if (dflt.vcc.present & (1 << CISTPL_POWER_VNOM)) {
808 if (conf.Vcc != dflt.vcc.param[CISTPL_POWER_VNOM] / 10000) {
809 DEBUG(2, "spectrum_cs_config: Vcc mismatch (conf.Vcc = %d, CIS = %d)\n", conf.Vcc, dflt.vcc.param[CISTPL_POWER_VNOM] / 10000);
810 if(!ignore_cis_vcc)
811 goto next_entry;
812 }
813 }
814
815 if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM))
816 link->conf.Vpp1 = link->conf.Vpp2 =
817 cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000;
818 else if (dflt.vpp1.present & (1 << CISTPL_POWER_VNOM))
819 link->conf.Vpp1 = link->conf.Vpp2 =
820 dflt.vpp1.param[CISTPL_POWER_VNOM] / 10000;
821
822 /* Do we need to allocate an interrupt? */
823 link->conf.Attributes |= CONF_ENABLE_IRQ;
824
825 /* IO window settings */
826 link->io.NumPorts1 = link->io.NumPorts2 = 0;
827 if ((cfg->io.nwin > 0) || (dflt.io.nwin > 0)) {
828 cistpl_io_t *io =
829 (cfg->io.nwin) ? &cfg->io : &dflt.io;
830 link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
831 if (!(io->flags & CISTPL_IO_8BIT))
832 link->io.Attributes1 =
833 IO_DATA_PATH_WIDTH_16;
834 if (!(io->flags & CISTPL_IO_16BIT))
835 link->io.Attributes1 =
836 IO_DATA_PATH_WIDTH_8;
837 link->io.IOAddrLines =
838 io->flags & CISTPL_IO_LINES_MASK;
839 link->io.BasePort1 = io->win[0].base;
840 link->io.NumPorts1 = io->win[0].len;
841 if (io->nwin > 1) {
842 link->io.Attributes2 =
843 link->io.Attributes1;
844 link->io.BasePort2 = io->win[1].base;
845 link->io.NumPorts2 = io->win[1].len;
846 }
847
848 /* This reserves IO space but doesn't actually enable it */
849 if (pcmcia_request_io(link->handle, &link->io) != 0)
850 goto next_entry;
851 }
852
853
854 /* If we got this far, we're cool! */
855
856 break;
857
858 next_entry:
859 if (link->io.NumPorts1)
860 pcmcia_release_io(link->handle, &link->io);
861 last_ret = pcmcia_get_next_tuple(handle, &tuple);
862 if (last_ret == CS_NO_MORE_ITEMS) {
863 printk(KERN_ERR PFX "GetNextTuple(): No matching "
864 "CIS configuration. Maybe you need the "
865 "ignore_cis_vcc=1 parameter.\n");
866 goto cs_failed;
867 }
868 }
869
870 /*
871 * Allocate an interrupt line. Note that this does not assign
872 * a handler to the interrupt, unless the 'Handler' member of
873 * the irq structure is initialized.
874 */
875 CS_CHECK(RequestIRQ, pcmcia_request_irq(link->handle, &link->irq));
876
877 /* We initialize the hermes structure before completing PCMCIA
878 * configuration just in case the interrupt handler gets
879 * called. */
880 mem = ioport_map(link->io.BasePort1, link->io.NumPorts1);
881 if (!mem)
882 goto cs_failed;
883
884 hermes_struct_init(hw, mem, HERMES_16BIT_REGSPACING);
885
886 /*
887 * This actually configures the PCMCIA socket -- setting up
888 * the I/O windows and the interrupt mapping, and putting the
889 * card and host interface into "Memory and IO" mode.
890 */
891 CS_CHECK(RequestConfiguration,
892 pcmcia_request_configuration(link->handle, &link->conf));
893
894 /* Ok, we have the configuration, prepare to register the netdev */
895 dev->base_addr = link->io.BasePort1;
896 dev->irq = link->irq.AssignedIRQ;
897 SET_MODULE_OWNER(dev);
898 card->node.major = card->node.minor = 0;
899
900 /* Reset card and download firmware */
901 if (spectrum_cs_hard_reset(priv) != 0) {
902 goto failed;
903 }
904
905 SET_NETDEV_DEV(dev, &handle_to_dev(handle));
906 /* Tell the stack we exist */
907 if (register_netdev(dev) != 0) {
908 printk(KERN_ERR PFX "register_netdev() failed\n");
909 goto failed;
910 }
911
912 /* At this point, the dev_node_t structure(s) needs to be
913 * initialized and arranged in a linked list at link->dev. */
914 strcpy(card->node.dev_name, dev->name);
915 link->dev = &card->node; /* link->dev being non-NULL is also
916 used to indicate that the
917 net_device has been registered */
918 link->state &= ~DEV_CONFIG_PENDING;
919
920 /* Finally, report what we've done */
921 printk(KERN_DEBUG "%s: index 0x%02x: Vcc %d.%d",
922 dev->name, link->conf.ConfigIndex,
923 link->conf.Vcc / 10, link->conf.Vcc % 10);
924 if (link->conf.Vpp1)
925 printk(", Vpp %d.%d", link->conf.Vpp1 / 10,
926 link->conf.Vpp1 % 10);
927 printk(", irq %d", link->irq.AssignedIRQ);
928 if (link->io.NumPorts1)
929 printk(", io 0x%04x-0x%04x", link->io.BasePort1,
930 link->io.BasePort1 + link->io.NumPorts1 - 1);
931 if (link->io.NumPorts2)
932 printk(" & 0x%04x-0x%04x", link->io.BasePort2,
933 link->io.BasePort2 + link->io.NumPorts2 - 1);
934 printk("\n");
935
936 return;
937
938 cs_failed:
939 cs_error(link->handle, last_fn, last_ret);
940
941 failed:
942 spectrum_cs_release(link);
943} /* spectrum_cs_config */
944
945/*
946 * After a card is removed, spectrum_cs_release() will unregister the
947 * device, and release the PCMCIA configuration. If the device is
948 * still open, this will be postponed until it is closed.
949 */
950static void
951spectrum_cs_release(dev_link_t *link)
952{
953 struct net_device *dev = link->priv;
954 struct orinoco_private *priv = netdev_priv(dev);
955 unsigned long flags;
956
957 /* We're committed to taking the device away now, so mark the
958 * hardware as unavailable */
959 spin_lock_irqsave(&priv->lock, flags);
960 priv->hw_unavailable++;
961 spin_unlock_irqrestore(&priv->lock, flags);
962
963 /* Don't bother checking to see if these succeed or not */
964 pcmcia_release_configuration(link->handle);
965 if (link->io.NumPorts1)
966 pcmcia_release_io(link->handle, &link->io);
967 if (link->irq.AssignedIRQ)
968 pcmcia_release_irq(link->handle, &link->irq);
969 link->state &= ~DEV_CONFIG;
970 if (priv->hw.iobase)
971 ioport_unmap(priv->hw.iobase);
972} /* spectrum_cs_release */
973
974/*
975 * The card status event handler. Mostly, this schedules other stuff
976 * to run after an event is received.
977 */
978static int
979spectrum_cs_event(event_t event, int priority,
980 event_callback_args_t * args)
981{
982 dev_link_t *link = args->client_data;
983 struct net_device *dev = link->priv;
984 struct orinoco_private *priv = netdev_priv(dev);
985 int err = 0;
986 unsigned long flags;
987
988 switch (event) {
989 case CS_EVENT_CARD_REMOVAL:
990 link->state &= ~DEV_PRESENT;
991 if (link->state & DEV_CONFIG) {
992 unsigned long flags;
993
994 spin_lock_irqsave(&priv->lock, flags);
995 netif_device_detach(dev);
996 priv->hw_unavailable++;
997 spin_unlock_irqrestore(&priv->lock, flags);
998 }
999 break;
1000
1001 case CS_EVENT_CARD_INSERTION:
1002 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
1003 spectrum_cs_config(link);
1004 break;
1005
1006 case CS_EVENT_PM_SUSPEND:
1007 link->state |= DEV_SUSPEND;
1008 /* Fall through... */
1009 case CS_EVENT_RESET_PHYSICAL:
1010 /* Mark the device as stopped, to block IO until later */
1011 if (link->state & DEV_CONFIG) {
1012 /* This is probably racy, but I can't think of
1013 a better way, short of rewriting the PCMCIA
1014 layer to not suck :-( */
1015 spin_lock_irqsave(&priv->lock, flags);
1016
1017 err = __orinoco_down(dev);
1018 if (err)
1019 printk(KERN_WARNING "%s: %s: Error %d downing interface\n",
1020 dev->name,
1021 event == CS_EVENT_PM_SUSPEND ? "SUSPEND" : "RESET_PHYSICAL",
1022 err);
1023
1024 netif_device_detach(dev);
1025 priv->hw_unavailable++;
1026
1027 spin_unlock_irqrestore(&priv->lock, flags);
1028
1029 pcmcia_release_configuration(link->handle);
1030 }
1031 break;
1032
1033 case CS_EVENT_PM_RESUME:
1034 link->state &= ~DEV_SUSPEND;
1035 /* Fall through... */
1036 case CS_EVENT_CARD_RESET:
1037 if (link->state & DEV_CONFIG) {
1038 /* FIXME: should we double check that this is
1039 * the same card as we had before */
1040 pcmcia_request_configuration(link->handle, &link->conf);
1041 netif_device_attach(dev);
1042 priv->hw_unavailable--;
1043 schedule_work(&priv->reset_work);
1044 }
1045 break;
1046 }
1047
1048 return err;
1049} /* spectrum_cs_event */
1050
1051/********************************************************************/
1052/* Module initialization */
1053/********************************************************************/
1054
1055/* Can't be declared "const" or the whole __initdata section will
1056 * become const */
1057static char version[] __initdata = DRIVER_NAME " " DRIVER_VERSION
1058 " (Pavel Roskin <proski@gnu.org>,"
1059 " David Gibson <hermes@gibson.dropbear.id.au>, et al)";
1060
1061static struct pcmcia_device_id spectrum_cs_ids[] = {
1062 PCMCIA_DEVICE_MANF_CARD(0x026c, 0x0001), /* Symbol Spectrum24 LA4100 */
1063 PCMCIA_DEVICE_MANF_CARD(0x0104, 0x0001), /* Socket Communications CF */
1064 PCMCIA_DEVICE_MANF_CARD(0x0089, 0x0001), /* Intel PRO/Wireless 2011B */
1065 PCMCIA_DEVICE_NULL,
1066};
1067MODULE_DEVICE_TABLE(pcmcia, spectrum_cs_ids);
1068
1069static struct pcmcia_driver orinoco_driver = {
1070 .owner = THIS_MODULE,
1071 .drv = {
1072 .name = DRIVER_NAME,
1073 },
1074 .attach = spectrum_cs_attach,
1075 .event = spectrum_cs_event,
1076 .detach = spectrum_cs_detach,
1077 .id_table = spectrum_cs_ids,
1078};
1079
1080static int __init
1081init_spectrum_cs(void)
1082{
1083 printk(KERN_DEBUG "%s\n", version);
1084
1085 return pcmcia_register_driver(&orinoco_driver);
1086}
1087
1088static void __exit
1089exit_spectrum_cs(void)
1090{
1091 pcmcia_unregister_driver(&orinoco_driver);
1092 BUG_ON(dev_list != NULL);
1093}
1094
1095module_init(init_spectrum_cs);
1096module_exit(exit_spectrum_cs);