]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /*** -*- linux-c -*- ********************************************************** |
2 | ||
3 | Driver for Atmel at76c502 at76c504 and at76c506 wireless cards. | |
4 | ||
5 | Copyright 2000-2001 ATMEL Corporation. | |
6 | Copyright 2003 Simon Kelley. | |
7 | ||
8 | This code was developed from version 2.1.1 of the Atmel drivers, | |
9 | released by Atmel corp. under the GPL in December 2002. It also | |
10 | includes code from the Linux aironet drivers (C) Benjamin Reed, | |
11 | and the Linux PCMCIA package, (C) David Hinds. | |
12 | ||
13 | For all queries about this code, please contact the current author, | |
14 | Simon Kelley <simon@thekelleys.org.uk> and not Atmel Corporation. | |
15 | ||
16 | This program is free software; you can redistribute it and/or modify | |
17 | it under the terms of the GNU General Public License as published by | |
18 | the Free Software Foundation; either version 2 of the License, or | |
19 | (at your option) any later version. | |
20 | ||
21 | This software is distributed in the hope that it will be useful, | |
22 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
23 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
24 | GNU General Public License for more details. | |
25 | ||
26 | You should have received a copy of the GNU General Public License | |
27 | along with Atmel wireless lan drivers; if not, write to the Free Software | |
28 | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
29 | ||
30 | ******************************************************************************/ | |
31 | ||
32 | #include <linux/config.h> | |
33 | #ifdef __IN_PCMCIA_PACKAGE__ | |
34 | #include <pcmcia/k_compat.h> | |
35 | #endif | |
36 | #include <linux/init.h> | |
37 | #include <linux/kernel.h> | |
38 | #include <linux/module.h> | |
39 | #include <linux/ptrace.h> | |
40 | #include <linux/slab.h> | |
41 | #include <linux/string.h> | |
42 | #include <linux/netdevice.h> | |
43 | #include <linux/moduleparam.h> | |
44 | #include <linux/device.h> | |
45 | ||
1da177e4 LT |
46 | #include <pcmcia/cs_types.h> |
47 | #include <pcmcia/cs.h> | |
48 | #include <pcmcia/cistpl.h> | |
49 | #include <pcmcia/cisreg.h> | |
50 | #include <pcmcia/ds.h> | |
51 | #include <pcmcia/ciscode.h> | |
52 | ||
53 | #include <asm/io.h> | |
54 | #include <asm/system.h> | |
55 | #include <linux/wireless.h> | |
56 | ||
57 | #include "atmel.h" | |
58 | ||
59 | /* | |
60 | All the PCMCIA modules use PCMCIA_DEBUG to control debugging. If | |
61 | you do not define PCMCIA_DEBUG at all, all the debug code will be | |
62 | left out. If you compile with PCMCIA_DEBUG=0, the debug code will | |
63 | be present but disabled -- but it can then be enabled for specific | |
64 | modules at load time with a 'pc_debug=#' option to insmod. | |
65 | */ | |
66 | #ifdef PCMCIA_DEBUG | |
67 | static int pc_debug = PCMCIA_DEBUG; | |
68 | module_param(pc_debug, int, 0); | |
69 | static char *version = "$Revision: 1.2 $"; | |
70 | #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args); | |
71 | #else | |
72 | #define DEBUG(n, args...) | |
73 | #endif | |
74 | ||
75 | /*====================================================================*/ | |
76 | ||
77 | MODULE_AUTHOR("Simon Kelley"); | |
78 | MODULE_DESCRIPTION("Support for Atmel at76c50x 802.11 wireless ethernet cards."); | |
79 | MODULE_LICENSE("GPL"); | |
80 | MODULE_SUPPORTED_DEVICE("Atmel at76c50x PCMCIA cards"); | |
81 | ||
82 | /*====================================================================*/ | |
83 | ||
84 | /* | |
85 | The event() function is this driver's Card Services event handler. | |
86 | It will be called by Card Services when an appropriate card status | |
87 | event is received. The config() and release() entry points are | |
88 | used to configure or release a socket, in response to card | |
89 | insertion and ejection events. They are invoked from the atmel_cs | |
90 | event handler. | |
91 | */ | |
92 | ||
93 | static void atmel_config(dev_link_t *link); | |
94 | static void atmel_release(dev_link_t *link); | |
95 | static int atmel_event(event_t event, int priority, | |
96 | event_callback_args_t *args); | |
97 | ||
98 | /* | |
99 | The attach() and detach() entry points are used to create and destroy | |
100 | "instances" of the driver, where each instance represents everything | |
101 | needed to manage one actual PCMCIA card. | |
102 | */ | |
103 | ||
104 | static dev_link_t *atmel_attach(void); | |
105 | static void atmel_detach(dev_link_t *); | |
106 | ||
107 | /* | |
108 | You'll also need to prototype all the functions that will actually | |
109 | be used to talk to your device. See 'pcmem_cs' for a good example | |
110 | of a fully self-sufficient driver; the other drivers rely more or | |
111 | less on other parts of the kernel. | |
112 | */ | |
113 | ||
114 | /* | |
115 | The dev_info variable is the "key" that is used to match up this | |
116 | device driver with appropriate cards, through the card configuration | |
117 | database. | |
118 | */ | |
119 | ||
120 | static dev_info_t dev_info = "atmel_cs"; | |
121 | ||
122 | /* | |
123 | A linked list of "instances" of the atmelnet device. Each actual | |
124 | PCMCIA card corresponds to one device instance, and is described | |
125 | by one dev_link_t structure (defined in ds.h). | |
126 | ||
127 | You may not want to use a linked list for this -- for example, the | |
128 | memory card driver uses an array of dev_link_t pointers, where minor | |
129 | device numbers are used to derive the corresponding array index. | |
130 | */ | |
131 | ||
132 | static dev_link_t *dev_list = NULL; | |
133 | ||
134 | /* | |
135 | A dev_link_t structure has fields for most things that are needed | |
136 | to keep track of a socket, but there will usually be some device | |
137 | specific information that also needs to be kept track of. The | |
138 | 'priv' pointer in a dev_link_t structure can be used to point to | |
139 | a device-specific private data structure, like this. | |
140 | ||
141 | A driver needs to provide a dev_node_t structure for each device | |
142 | on a card. In some cases, there is only one device per card (for | |
143 | example, ethernet cards, modems). In other cases, there may be | |
144 | many actual or logical devices (SCSI adapters, memory cards with | |
145 | multiple partitions). The dev_node_t structures need to be kept | |
146 | in a linked list starting at the 'dev' field of a dev_link_t | |
147 | structure. We allocate them in the card's private data structure, | |
148 | because they generally shouldn't be allocated dynamically. | |
149 | ||
150 | In this case, we also provide a flag to indicate if a device is | |
151 | "stopped" due to a power management event, or card ejection. The | |
152 | device IO routines can use a flag like this to throttle IO to a | |
153 | card that is not ready to accept it. | |
154 | */ | |
155 | ||
156 | typedef struct local_info_t { | |
157 | dev_node_t node; | |
158 | struct net_device *eth_dev; | |
159 | } local_info_t; | |
160 | ||
161 | /*====================================================================== | |
162 | ||
163 | atmel_attach() creates an "instance" of the driver, allocating | |
164 | local data structures for one device. The device is registered | |
165 | with Card Services. | |
166 | ||
167 | The dev_link structure is initialized, but we don't actually | |
168 | configure the card at this point -- we wait until we receive a | |
169 | card insertion event. | |
170 | ||
171 | ======================================================================*/ | |
172 | ||
173 | static dev_link_t *atmel_attach(void) | |
174 | { | |
175 | client_reg_t client_reg; | |
176 | dev_link_t *link; | |
177 | local_info_t *local; | |
178 | int ret; | |
179 | ||
180 | DEBUG(0, "atmel_attach()\n"); | |
181 | ||
182 | /* Initialize the dev_link_t structure */ | |
183 | link = kmalloc(sizeof(struct dev_link_t), GFP_KERNEL); | |
184 | if (!link) { | |
185 | printk(KERN_ERR "atmel_cs: no memory for new device\n"); | |
186 | return NULL; | |
187 | } | |
188 | memset(link, 0, sizeof(struct dev_link_t)); | |
189 | ||
190 | /* Interrupt setup */ | |
191 | link->irq.Attributes = IRQ_TYPE_EXCLUSIVE; | |
192 | link->irq.IRQInfo1 = IRQ_LEVEL_ID; | |
193 | link->irq.Handler = NULL; | |
194 | ||
195 | /* | |
196 | General socket configuration defaults can go here. In this | |
197 | client, we assume very little, and rely on the CIS for almost | |
198 | everything. In most clients, many details (i.e., number, sizes, | |
199 | and attributes of IO windows) are fixed by the nature of the | |
200 | device, and can be hard-wired here. | |
201 | */ | |
202 | link->conf.Attributes = 0; | |
203 | link->conf.Vcc = 50; | |
204 | link->conf.IntType = INT_MEMORY_AND_IO; | |
205 | ||
206 | /* Allocate space for private device-specific data */ | |
207 | local = kmalloc(sizeof(local_info_t), GFP_KERNEL); | |
208 | if (!local) { | |
209 | printk(KERN_ERR "atmel_cs: no memory for new device\n"); | |
210 | kfree (link); | |
211 | return NULL; | |
212 | } | |
213 | memset(local, 0, sizeof(local_info_t)); | |
214 | link->priv = local; | |
215 | ||
216 | /* Register with Card Services */ | |
217 | link->next = dev_list; | |
218 | dev_list = link; | |
219 | client_reg.dev_info = &dev_info; | |
1da177e4 LT |
220 | client_reg.Version = 0x0210; |
221 | client_reg.event_callback_args.client_data = link; | |
222 | ret = pcmcia_register_client(&link->handle, &client_reg); | |
223 | if (ret != 0) { | |
224 | cs_error(link->handle, RegisterClient, ret); | |
225 | atmel_detach(link); | |
226 | return NULL; | |
227 | } | |
228 | ||
229 | return link; | |
230 | } /* atmel_attach */ | |
231 | ||
232 | /*====================================================================== | |
233 | ||
234 | This deletes a driver "instance". The device is de-registered | |
235 | with Card Services. If it has been released, all local data | |
236 | structures are freed. Otherwise, the structures will be freed | |
237 | when the device is released. | |
238 | ||
239 | ======================================================================*/ | |
240 | ||
241 | static void atmel_detach(dev_link_t *link) | |
242 | { | |
243 | dev_link_t **linkp; | |
244 | ||
245 | DEBUG(0, "atmel_detach(0x%p)\n", link); | |
246 | ||
247 | /* Locate device structure */ | |
248 | for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) | |
249 | if (*linkp == link) break; | |
250 | if (*linkp == NULL) | |
251 | return; | |
252 | ||
253 | if (link->state & DEV_CONFIG) | |
254 | atmel_release(link); | |
255 | ||
256 | /* Break the link with Card Services */ | |
257 | if (link->handle) | |
258 | pcmcia_deregister_client(link->handle); | |
259 | ||
260 | /* Unlink device structure, free pieces */ | |
261 | *linkp = link->next; | |
262 | if (link->priv) | |
263 | kfree(link->priv); | |
264 | kfree(link); | |
265 | } | |
266 | ||
267 | /*====================================================================== | |
268 | ||
269 | atmel_config() is scheduled to run after a CARD_INSERTION event | |
270 | is received, to configure the PCMCIA socket, and to make the | |
271 | device available to the system. | |
272 | ||
273 | ======================================================================*/ | |
274 | ||
275 | #define CS_CHECK(fn, ret) \ | |
276 | do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0) | |
277 | ||
278 | /* Call-back function to interrogate PCMCIA-specific information | |
279 | about the current existance of the card */ | |
280 | static int card_present(void *arg) | |
281 | { | |
282 | dev_link_t *link = (dev_link_t *)arg; | |
283 | if (link->state & DEV_SUSPEND) | |
284 | return 0; | |
285 | else if (link->state & DEV_PRESENT) | |
286 | return 1; | |
287 | ||
288 | return 0; | |
289 | } | |
290 | ||
291 | /* list of cards we know about and their firmware requirements. | |
292 | Go either by Manfid or version strings. | |
293 | Cards not in this list will need a firmware parameter to the module | |
294 | in all probability. Note that the SMC 2632 V2 and V3 have the same | |
295 | manfids, so we ignore those and use the version1 strings. */ | |
296 | ||
297 | static struct { | |
298 | int manf, card; | |
299 | char *ver1; | |
300 | AtmelFWType firmware; | |
301 | char *name; | |
302 | } card_table[] = { | |
303 | { 0, 0, "WLAN/802.11b PC CARD", ATMEL_FW_TYPE_502D, "Actiontec 802CAT1" }, | |
304 | { 0, 0, "ATMEL/AT76C502AR", ATMEL_FW_TYPE_502, "NoName-RFMD" }, | |
305 | { 0, 0, "ATMEL/AT76C502AR_D", ATMEL_FW_TYPE_502D, "NoName-revD" }, | |
306 | { 0, 0, "ATMEL/AT76C502AR_E", ATMEL_FW_TYPE_502E, "NoName-revE" }, | |
307 | { 0, 0, "ATMEL/AT76C504", ATMEL_FW_TYPE_504, "NoName-504" }, | |
308 | { 0, 0, "ATMEL/AT76C504A", ATMEL_FW_TYPE_504A_2958, "NoName-504a-2958" }, | |
309 | { 0, 0, "ATMEL/AT76C504_R", ATMEL_FW_TYPE_504_2958, "NoName-504-2958" }, | |
310 | { MANFID_3COM, 0x0620, NULL, ATMEL_FW_TYPE_502_3COM, "3com 3CRWE62092B" }, | |
311 | { MANFID_3COM, 0x0696, NULL, ATMEL_FW_TYPE_502_3COM, "3com 3CRSHPW196" }, | |
312 | { 0, 0, "SMC/2632W-V2", ATMEL_FW_TYPE_502, "SMC 2632W-V2" }, | |
313 | { 0, 0, "SMC/2632W", ATMEL_FW_TYPE_502D, "SMC 2632W-V3" }, | |
314 | { 0xd601, 0x0007, NULL, ATMEL_FW_TYPE_502, "Sitecom WLAN-011" }, | |
315 | { 0x01bf, 0x3302, NULL, ATMEL_FW_TYPE_502E, "Belkin F5D6020-V2" }, | |
316 | { 0, 0, "BT/Voyager 1020 Laptop Adapter", ATMEL_FW_TYPE_502, "BT Voyager 1020" }, | |
317 | { 0, 0, "IEEE 802.11b/Wireless LAN PC Card", ATMEL_FW_TYPE_502, "Siemens Gigaset PC Card II" }, | |
e885b5e8 | 318 | { 0, 0, "IEEE 802.11b/Wireless LAN Card S", ATMEL_FW_TYPE_504_2958, "Siemens Gigaset PC Card II" }, |
1da177e4 LT |
319 | { 0, 0, "CNet/CNWLC 11Mbps Wireless PC Card V-5", ATMEL_FW_TYPE_502E, "CNet CNWLC-811ARL" }, |
320 | { 0, 0, "Wireless/PC_CARD", ATMEL_FW_TYPE_502D, "Planet WL-3552" }, | |
321 | { 0, 0, "OEM/11Mbps Wireless LAN PC Card V-3", ATMEL_FW_TYPE_502, "OEM 11Mbps WLAN PCMCIA Card" }, | |
322 | { 0, 0, "11WAVE/11WP611AL-E", ATMEL_FW_TYPE_502E, "11WAVE WaveBuddy" }, | |
323 | { 0, 0, "LG/LW2100N", ATMEL_FW_TYPE_502E, "LG LW2100N 11Mbps WLAN PCMCIA Card" }, | |
324 | }; | |
325 | ||
326 | static void atmel_config(dev_link_t *link) | |
327 | { | |
328 | client_handle_t handle; | |
329 | tuple_t tuple; | |
330 | cisparse_t parse; | |
331 | local_info_t *dev; | |
332 | int last_fn, last_ret; | |
333 | u_char buf[64]; | |
334 | int card_index = -1, done = 0; | |
335 | ||
336 | handle = link->handle; | |
337 | dev = link->priv; | |
338 | ||
339 | DEBUG(0, "atmel_config(0x%p)\n", link); | |
340 | ||
341 | tuple.Attributes = 0; | |
342 | tuple.TupleData = buf; | |
343 | tuple.TupleDataMax = sizeof(buf); | |
344 | tuple.TupleOffset = 0; | |
345 | ||
346 | tuple.DesiredTuple = CISTPL_MANFID; | |
347 | if (pcmcia_get_first_tuple(handle, &tuple) == 0) { | |
348 | int i; | |
349 | cistpl_manfid_t *manfid; | |
350 | CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple)); | |
351 | CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse)); | |
352 | manfid = &(parse.manfid); | |
353 | for (i = 0; i < sizeof(card_table)/sizeof(card_table[0]); i++) { | |
354 | if (!card_table[i].ver1 && | |
355 | manfid->manf == card_table[i].manf && | |
356 | manfid->card == card_table[i].card) { | |
357 | card_index = i; | |
358 | done = 1; | |
359 | } | |
360 | } | |
361 | } | |
362 | ||
363 | tuple.DesiredTuple = CISTPL_VERS_1; | |
364 | if (!done && (pcmcia_get_first_tuple(handle, &tuple) == 0)) { | |
365 | int i, j, k; | |
366 | cistpl_vers_1_t *ver1; | |
367 | CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple)); | |
368 | CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse)); | |
369 | ver1 = &(parse.version_1); | |
370 | ||
371 | for (i = 0; i < sizeof(card_table)/sizeof(card_table[0]); i++) { | |
372 | for (j = 0; j < ver1->ns; j++) { | |
373 | char *p = card_table[i].ver1; | |
374 | char *q = &ver1->str[ver1->ofs[j]]; | |
375 | if (!p) | |
376 | goto mismatch; | |
377 | for (k = 0; k < j; k++) { | |
378 | while ((*p != '\0') && (*p != '/')) p++; | |
379 | if (*p == '\0') { | |
380 | if (*q != '\0') | |
381 | goto mismatch; | |
382 | } else { | |
383 | p++; | |
384 | } | |
385 | } | |
386 | while((*q != '\0') && (*p != '\0') && | |
387 | (*p != '/') && (*p == *q)) p++, q++; | |
388 | if (((*p != '\0') && *p != '/') || *q != '\0') | |
389 | goto mismatch; | |
390 | } | |
391 | card_index = i; | |
392 | break; /* done */ | |
393 | ||
394 | mismatch: | |
395 | j = 0; /* dummy stmt to shut up compiler */ | |
396 | } | |
397 | } | |
398 | ||
399 | /* | |
400 | This reads the card's CONFIG tuple to find its configuration | |
401 | registers. | |
402 | */ | |
403 | tuple.DesiredTuple = CISTPL_CONFIG; | |
404 | CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple)); | |
405 | CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple)); | |
406 | CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse)); | |
407 | link->conf.ConfigBase = parse.config.base; | |
408 | link->conf.Present = parse.config.rmask[0]; | |
409 | ||
410 | /* Configure card */ | |
411 | link->state |= DEV_CONFIG; | |
412 | ||
413 | /* | |
414 | In this loop, we scan the CIS for configuration table entries, | |
415 | each of which describes a valid card configuration, including | |
416 | voltage, IO window, memory window, and interrupt settings. | |
417 | ||
418 | We make no assumptions about the card to be configured: we use | |
419 | just the information available in the CIS. In an ideal world, | |
420 | this would work for any PCMCIA card, but it requires a complete | |
421 | and accurate CIS. In practice, a driver usually "knows" most of | |
422 | these things without consulting the CIS, and most client drivers | |
423 | will only use the CIS to fill in implementation-defined details. | |
424 | */ | |
425 | tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY; | |
426 | CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple)); | |
427 | while (1) { | |
428 | cistpl_cftable_entry_t dflt = { 0 }; | |
429 | cistpl_cftable_entry_t *cfg = &(parse.cftable_entry); | |
430 | if (pcmcia_get_tuple_data(handle, &tuple) != 0 || | |
431 | pcmcia_parse_tuple(handle, &tuple, &parse) != 0) | |
432 | goto next_entry; | |
433 | ||
434 | if (cfg->flags & CISTPL_CFTABLE_DEFAULT) dflt = *cfg; | |
435 | if (cfg->index == 0) goto next_entry; | |
436 | link->conf.ConfigIndex = cfg->index; | |
437 | ||
438 | /* Does this card need audio output? */ | |
439 | if (cfg->flags & CISTPL_CFTABLE_AUDIO) { | |
440 | link->conf.Attributes |= CONF_ENABLE_SPKR; | |
441 | link->conf.Status = CCSR_AUDIO_ENA; | |
442 | } | |
443 | ||
444 | /* Use power settings for Vcc and Vpp if present */ | |
445 | /* Note that the CIS values need to be rescaled */ | |
446 | if (cfg->vcc.present & (1<<CISTPL_POWER_VNOM)) | |
447 | link->conf.Vcc = cfg->vcc.param[CISTPL_POWER_VNOM]/10000; | |
448 | else if (dflt.vcc.present & (1<<CISTPL_POWER_VNOM)) | |
449 | link->conf.Vcc = dflt.vcc.param[CISTPL_POWER_VNOM]/10000; | |
450 | ||
451 | if (cfg->vpp1.present & (1<<CISTPL_POWER_VNOM)) | |
452 | link->conf.Vpp1 = link->conf.Vpp2 = | |
453 | cfg->vpp1.param[CISTPL_POWER_VNOM]/10000; | |
454 | else if (dflt.vpp1.present & (1<<CISTPL_POWER_VNOM)) | |
455 | link->conf.Vpp1 = link->conf.Vpp2 = | |
456 | dflt.vpp1.param[CISTPL_POWER_VNOM]/10000; | |
457 | ||
458 | /* Do we need to allocate an interrupt? */ | |
459 | if (cfg->irq.IRQInfo1 || dflt.irq.IRQInfo1) | |
460 | link->conf.Attributes |= CONF_ENABLE_IRQ; | |
461 | ||
462 | /* IO window settings */ | |
463 | link->io.NumPorts1 = link->io.NumPorts2 = 0; | |
464 | if ((cfg->io.nwin > 0) || (dflt.io.nwin > 0)) { | |
465 | cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt.io; | |
466 | link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO; | |
467 | if (!(io->flags & CISTPL_IO_8BIT)) | |
468 | link->io.Attributes1 = IO_DATA_PATH_WIDTH_16; | |
469 | if (!(io->flags & CISTPL_IO_16BIT)) | |
470 | link->io.Attributes1 = IO_DATA_PATH_WIDTH_8; | |
471 | link->io.BasePort1 = io->win[0].base; | |
472 | link->io.NumPorts1 = io->win[0].len; | |
473 | if (io->nwin > 1) { | |
474 | link->io.Attributes2 = link->io.Attributes1; | |
475 | link->io.BasePort2 = io->win[1].base; | |
476 | link->io.NumPorts2 = io->win[1].len; | |
477 | } | |
478 | } | |
479 | ||
480 | /* This reserves IO space but doesn't actually enable it */ | |
481 | if (pcmcia_request_io(link->handle, &link->io) != 0) | |
482 | goto next_entry; | |
483 | ||
484 | /* If we got this far, we're cool! */ | |
485 | break; | |
486 | ||
487 | next_entry: | |
488 | CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(handle, &tuple)); | |
489 | } | |
490 | ||
491 | /* | |
492 | Allocate an interrupt line. Note that this does not assign a | |
493 | handler to the interrupt, unless the 'Handler' member of the | |
494 | irq structure is initialized. | |
495 | */ | |
496 | if (link->conf.Attributes & CONF_ENABLE_IRQ) | |
497 | CS_CHECK(RequestIRQ, pcmcia_request_irq(link->handle, &link->irq)); | |
498 | ||
499 | /* | |
500 | This actually configures the PCMCIA socket -- setting up | |
501 | the I/O windows and the interrupt mapping, and putting the | |
502 | card and host interface into "Memory and IO" mode. | |
503 | */ | |
504 | CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link->handle, &link->conf)); | |
505 | ||
506 | if (link->irq.AssignedIRQ == 0) { | |
507 | printk(KERN_ALERT | |
508 | "atmel: cannot assign IRQ: check that CONFIG_ISA is set in kernel config."); | |
509 | goto cs_failed; | |
510 | } | |
511 | ||
512 | ((local_info_t*)link->priv)->eth_dev = | |
513 | init_atmel_card(link->irq.AssignedIRQ, | |
514 | link->io.BasePort1, | |
515 | card_index == -1 ? ATMEL_FW_TYPE_NONE : card_table[card_index].firmware, | |
516 | &handle_to_dev(handle), | |
517 | card_present, | |
518 | link); | |
519 | if (!((local_info_t*)link->priv)->eth_dev) | |
520 | goto cs_failed; | |
521 | ||
522 | /* | |
523 | At this point, the dev_node_t structure(s) need to be | |
524 | initialized and arranged in a linked list at link->dev. | |
525 | */ | |
526 | strcpy(dev->node.dev_name, ((local_info_t*)link->priv)->eth_dev->name ); | |
527 | dev->node.major = dev->node.minor = 0; | |
528 | link->dev = &dev->node; | |
529 | ||
530 | /* Finally, report what we've done */ | |
531 | printk(KERN_INFO "%s: %s%sindex 0x%02x: Vcc %d.%d", | |
532 | dev->node.dev_name, | |
533 | card_index == -1 ? "" : card_table[card_index].name, | |
534 | card_index == -1 ? "" : " ", | |
535 | link->conf.ConfigIndex, | |
536 | link->conf.Vcc/10, link->conf.Vcc%10); | |
537 | if (link->conf.Vpp1) | |
538 | printk(", Vpp %d.%d", link->conf.Vpp1/10, link->conf.Vpp1%10); | |
539 | if (link->conf.Attributes & CONF_ENABLE_IRQ) | |
540 | printk(", irq %d", link->irq.AssignedIRQ); | |
541 | if (link->io.NumPorts1) | |
542 | printk(", io 0x%04x-0x%04x", link->io.BasePort1, | |
543 | link->io.BasePort1+link->io.NumPorts1-1); | |
544 | if (link->io.NumPorts2) | |
545 | printk(" & 0x%04x-0x%04x", link->io.BasePort2, | |
546 | link->io.BasePort2+link->io.NumPorts2-1); | |
547 | printk("\n"); | |
548 | ||
549 | link->state &= ~DEV_CONFIG_PENDING; | |
550 | return; | |
551 | ||
552 | cs_failed: | |
553 | cs_error(link->handle, last_fn, last_ret); | |
554 | atmel_release(link); | |
555 | } | |
556 | ||
557 | /*====================================================================== | |
558 | ||
559 | After a card is removed, atmel_release() will unregister the | |
560 | device, and release the PCMCIA configuration. If the device is | |
561 | still open, this will be postponed until it is closed. | |
562 | ||
563 | ======================================================================*/ | |
564 | ||
565 | static void atmel_release(dev_link_t *link) | |
566 | { | |
567 | struct net_device *dev = ((local_info_t*)link->priv)->eth_dev; | |
568 | ||
569 | DEBUG(0, "atmel_release(0x%p)\n", link); | |
570 | ||
571 | /* Unlink the device chain */ | |
572 | link->dev = NULL; | |
573 | ||
574 | if (dev) | |
575 | stop_atmel_card(dev, 0); | |
576 | ((local_info_t*)link->priv)->eth_dev = NULL; | |
577 | ||
578 | /* Don't bother checking to see if these succeed or not */ | |
579 | pcmcia_release_configuration(link->handle); | |
580 | if (link->io.NumPorts1) | |
581 | pcmcia_release_io(link->handle, &link->io); | |
582 | if (link->irq.AssignedIRQ) | |
583 | pcmcia_release_irq(link->handle, &link->irq); | |
584 | link->state &= ~DEV_CONFIG; | |
585 | } | |
586 | ||
587 | /*====================================================================== | |
588 | ||
589 | The card status event handler. Mostly, this schedules other | |
590 | stuff to run after an event is received. | |
591 | ||
592 | When a CARD_REMOVAL event is received, we immediately set a | |
593 | private flag to block future accesses to this device. All the | |
594 | functions that actually access the device should check this flag | |
595 | to make sure the card is still present. | |
596 | ||
597 | ======================================================================*/ | |
598 | ||
599 | static int atmel_event(event_t event, int priority, | |
600 | event_callback_args_t *args) | |
601 | { | |
602 | dev_link_t *link = args->client_data; | |
603 | local_info_t *local = link->priv; | |
604 | ||
605 | DEBUG(1, "atmel_event(0x%06x)\n", event); | |
606 | ||
607 | switch (event) { | |
608 | case CS_EVENT_CARD_REMOVAL: | |
609 | link->state &= ~DEV_PRESENT; | |
610 | if (link->state & DEV_CONFIG) { | |
611 | netif_device_detach(local->eth_dev); | |
612 | atmel_release(link); | |
613 | } | |
614 | break; | |
615 | case CS_EVENT_CARD_INSERTION: | |
616 | link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; | |
617 | atmel_config(link); | |
618 | break; | |
619 | case CS_EVENT_PM_SUSPEND: | |
620 | link->state |= DEV_SUSPEND; | |
621 | /* Fall through... */ | |
622 | case CS_EVENT_RESET_PHYSICAL: | |
623 | if (link->state & DEV_CONFIG) { | |
624 | netif_device_detach(local->eth_dev); | |
625 | pcmcia_release_configuration(link->handle); | |
626 | } | |
627 | break; | |
628 | case CS_EVENT_PM_RESUME: | |
629 | link->state &= ~DEV_SUSPEND; | |
630 | /* Fall through... */ | |
631 | case CS_EVENT_CARD_RESET: | |
632 | if (link->state & DEV_CONFIG) { | |
633 | pcmcia_request_configuration(link->handle, &link->conf); | |
634 | atmel_open(local->eth_dev); | |
635 | netif_device_attach(local->eth_dev); | |
636 | } | |
637 | break; | |
638 | } | |
639 | return 0; | |
640 | } /* atmel_event */ | |
641 | ||
642 | /*====================================================================*/ | |
4a17a119 DB |
643 | static struct pcmcia_device_id atmel_ids[] = { |
644 | PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0620), | |
645 | PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0696), | |
646 | PCMCIA_DEVICE_MANF_CARD(0x01bf, 0x3302), | |
647 | PCMCIA_DEVICE_MANF_CARD(0xd601, 0x0007), | |
648 | PCMCIA_DEVICE_PROD_ID12("11WAVE", "11WP611AL-E", 0x9eb2da1f, 0xc9a0d3f9), | |
649 | PCMCIA_DEVICE_PROD_ID12("ATMEL", "AT76C502AR", 0xabda4164, 0x41b37e1f), | |
650 | PCMCIA_DEVICE_PROD_ID12("ATMEL", "AT76C504", 0xabda4164, 0x5040670a), | |
651 | PCMCIA_DEVICE_PROD_ID12("ATMEL", "AT76C504A", 0xabda4164, 0xe15ed87f), | |
652 | PCMCIA_DEVICE_PROD_ID12("BT", "Voyager 1020 Laptop Adapter", 0xae49b86a, 0x1e957cd5), | |
653 | PCMCIA_DEVICE_PROD_ID12("CNet", "CNWLC 11Mbps Wireless PC Card V-5", 0xbc477dde, 0x502fae6b), | |
654 | PCMCIA_DEVICE_PROD_ID12("IEEE 802.11b", "Wireless LAN PC Card", 0x5b878724, 0x122f1df6), | |
655 | PCMCIA_DEVICE_PROD_ID12("OEM", "11Mbps Wireless LAN PC Card V-3", 0xfea54c90, 0x1c5b0f68), | |
656 | PCMCIA_DEVICE_PROD_ID12("SMC", "2632W", 0xc4f8b18b, 0x30f38774), | |
657 | PCMCIA_DEVICE_PROD_ID12("SMC", "2632W-V2", 0xc4f8b18b, 0x172d1377), | |
658 | PCMCIA_DEVICE_PROD_ID12("Wireless", "PC", 0xa407ecdd, 0x556e4d7e), | |
659 | PCMCIA_DEVICE_PROD_ID12("WLAN", "802.11b PC CARD", 0x575c516c, 0xb1f6dbc4), | |
660 | PCMCIA_DEVICE_NULL | |
661 | }; | |
662 | MODULE_DEVICE_TABLE(pcmcia, atmel_ids); | |
663 | ||
1da177e4 | 664 | static struct pcmcia_driver atmel_driver = { |
1e212f36 DB |
665 | .owner = THIS_MODULE, |
666 | .drv = { | |
667 | .name = "atmel_cs", | |
1da177e4 | 668 | }, |
1e212f36 DB |
669 | .attach = atmel_attach, |
670 | .event = atmel_event, | |
671 | .detach = atmel_detach, | |
4a17a119 | 672 | .id_table = atmel_ids, |
1da177e4 LT |
673 | }; |
674 | ||
675 | static int atmel_cs_init(void) | |
676 | { | |
677 | return pcmcia_register_driver(&atmel_driver); | |
678 | } | |
679 | ||
680 | static void atmel_cs_cleanup(void) | |
681 | { | |
682 | pcmcia_unregister_driver(&atmel_driver); | |
683 | BUG_ON(dev_list != NULL); | |
684 | } | |
685 | ||
686 | /* | |
687 | This program is free software; you can redistribute it and/or | |
688 | modify it under the terms of the GNU General Public License | |
689 | as published by the Free Software Foundation; either version 2 | |
690 | of the License, or (at your option) any later version. | |
691 | ||
692 | This program is distributed in the hope that it will be useful, | |
693 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
694 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
695 | GNU General Public License for more details. | |
696 | ||
697 | In addition: | |
698 | ||
699 | Redistribution and use in source and binary forms, with or without | |
700 | modification, are permitted provided that the following conditions | |
701 | are met: | |
702 | ||
703 | 1. Redistributions of source code must retain the above copyright | |
704 | notice, this list of conditions and the following disclaimer. | |
705 | 2. Redistributions in binary form must reproduce the above copyright | |
706 | notice, this list of conditions and the following disclaimer in the | |
707 | documentation and/or other materials provided with the distribution. | |
708 | 3. The name of the author may not be used to endorse or promote | |
709 | products derived from this software without specific prior written | |
710 | permission. | |
711 | ||
712 | THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR | |
713 | IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | |
714 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
715 | ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, | |
716 | INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | |
717 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR | |
718 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
719 | HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | |
720 | STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING | |
721 | IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE | |
722 | POSSIBILITY OF SUCH DAMAGE. | |
723 | */ | |
724 | ||
725 | module_init(atmel_cs_init); | |
726 | module_exit(atmel_cs_cleanup); |