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