1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * WL3501 Wireless LAN PCMCIA Card Driver for Linux
4  * Written originally for Linux 2.0.30 by Fox Chen, mhchen@golf.ccl.itri.org.tw
5  * Ported to 2.2, 2.4 & 2.5 by Arnaldo Carvalho de Melo <acme@conectiva.com.br>
6  * Wireless extensions in 2.4 by Gustavo Niemeyer <niemeyer@conectiva.com>
7  *
8  * References used by Fox Chen while writing the original driver for 2.0.30:
9  *
10  *   1. WL24xx packet drivers (tooasm.asm)
11  *   2. Access Point Firmware Interface Specification for IEEE 802.11 SUTRO
12  *   3. IEEE 802.11
13  *   4. Linux network driver (/usr/src/linux/drivers/net)
14  *   5. ISA card driver - wl24.c
15  *   6. Linux PCMCIA skeleton driver - skeleton.c
16  *   7. Linux PCMCIA 3c589 network driver - 3c589_cs.c
17  *
18  * Tested with WL2400 firmware 1.2, Linux 2.0.30, and pcmcia-cs-2.9.12
19  *   1. Performance: about 165 Kbytes/sec in TCP/IP with Ad-Hoc mode.
20  *      rsh 192.168.1.3 "dd if=/dev/zero bs=1k count=1000" > /dev/null
21  *      (Specification 2M bits/sec. is about 250 Kbytes/sec., but we must deduct
22  *       ETHER/IP/UDP/TCP header, and acknowledgement overhead)
23  *
24  * Tested with Planet AP in 2.4.17, 184 Kbytes/s in UDP in Infrastructure mode,
25  * 173 Kbytes/s in TCP.
26  *
27  * Tested with Planet AP in 2.5.73-bk, 216 Kbytes/s in Infrastructure mode
28  * with a SMP machine (dual pentium 100), using pktgen, 432 pps (pkt_size = 60)
29  */
30 
31 #include <linux/delay.h>
32 #include <linux/types.h>
33 #include <linux/interrupt.h>
34 #include <linux/in.h>
35 #include <linux/kernel.h>
36 #include <linux/module.h>
37 #include <linux/fcntl.h>
38 #include <linux/if_arp.h>
39 #include <linux/ioport.h>
40 #include <linux/netdevice.h>
41 #include <linux/etherdevice.h>
42 #include <linux/skbuff.h>
43 #include <linux/slab.h>
44 #include <linux/string.h>
45 #include <linux/wireless.h>
46 #include <net/cfg80211.h>
47 
48 #include <net/iw_handler.h>
49 
50 #include <pcmcia/cistpl.h>
51 #include <pcmcia/cisreg.h>
52 #include <pcmcia/ds.h>
53 
54 #include <asm/io.h>
55 #include <linux/uaccess.h>
56 
57 #include "wl3501.h"
58 
59 #ifndef __i386__
60 #define slow_down_io()
61 #endif
62 
63 /* For rough constant delay */
64 #define WL3501_NOPLOOP(n) { int x = 0; while (x++ < n) slow_down_io(); }
65 
66 
67 
68 #define wl3501_outb(a, b) { outb(a, b); slow_down_io(); }
69 #define wl3501_outb_p(a, b) { outb_p(a, b); slow_down_io(); }
70 #define wl3501_outsb(a, b, c) { outsb(a, b, c); slow_down_io(); }
71 
72 #define WL3501_RELEASE_TIMEOUT (25 * HZ)
73 #define WL3501_MAX_ADHOC_TRIES 16
74 
75 #define WL3501_RESUME	0
76 #define WL3501_SUSPEND	1
77 
78 static int wl3501_config(struct pcmcia_device *link);
79 static void wl3501_release(struct pcmcia_device *link);
80 
81 static const struct {
82 	int reg_domain;
83 	int min, max, deflt;
84 } iw_channel_table[] = {
85 	{
86 		.reg_domain = IW_REG_DOMAIN_FCC,
87 		.min	    = 1,
88 		.max	    = 11,
89 		.deflt	    = 1,
90 	},
91 	{
92 		.reg_domain = IW_REG_DOMAIN_DOC,
93 		.min	    = 1,
94 		.max	    = 11,
95 		.deflt	    = 1,
96 	},
97 	{
98 		.reg_domain = IW_REG_DOMAIN_ETSI,
99 		.min	    = 1,
100 		.max	    = 13,
101 		.deflt	    = 1,
102 	},
103 	{
104 		.reg_domain = IW_REG_DOMAIN_SPAIN,
105 		.min	    = 10,
106 		.max	    = 11,
107 		.deflt	    = 10,
108 	},
109 	{
110 		.reg_domain = IW_REG_DOMAIN_FRANCE,
111 		.min	    = 10,
112 		.max	    = 13,
113 		.deflt	    = 10,
114 	},
115 	{
116 		.reg_domain = IW_REG_DOMAIN_MKK,
117 		.min	    = 14,
118 		.max	    = 14,
119 		.deflt	    = 14,
120 	},
121 	{
122 		.reg_domain = IW_REG_DOMAIN_MKK1,
123 		.min	    = 1,
124 		.max	    = 14,
125 		.deflt	    = 1,
126 	},
127 	{
128 		.reg_domain = IW_REG_DOMAIN_ISRAEL,
129 		.min	    = 3,
130 		.max	    = 9,
131 		.deflt	    = 9,
132 	},
133 };
134 
135 /**
136  * iw_valid_channel - validate channel in regulatory domain
137  * @reg_domain: regulatory domain
138  * @channel: channel to validate
139  *
140  * Returns 0 if invalid in the specified regulatory domain, non-zero if valid.
141  */
142 static int iw_valid_channel(int reg_domain, int channel)
143 {
144 	int i, rc = 0;
145 
146 	for (i = 0; i < ARRAY_SIZE(iw_channel_table); i++)
147 		if (reg_domain == iw_channel_table[i].reg_domain) {
148 			rc = channel >= iw_channel_table[i].min &&
149 			     channel <= iw_channel_table[i].max;
150 			break;
151 		}
152 	return rc;
153 }
154 
155 /**
156  * iw_default_channel - get default channel for a regulatory domain
157  * @reg_domain: regulatory domain
158  *
159  * Returns the default channel for a regulatory domain
160  */
161 static int iw_default_channel(int reg_domain)
162 {
163 	int i, rc = 1;
164 
165 	for (i = 0; i < ARRAY_SIZE(iw_channel_table); i++)
166 		if (reg_domain == iw_channel_table[i].reg_domain) {
167 			rc = iw_channel_table[i].deflt;
168 			break;
169 		}
170 	return rc;
171 }
172 
173 static void iw_set_mgmt_info_element(enum iw_mgmt_info_element_ids id,
174 				     struct iw_mgmt_info_element *el,
175 				     void *value, int len)
176 {
177 	el->id  = id;
178 	el->len = len;
179 	memcpy(el->data, value, len);
180 }
181 
182 static void iw_copy_mgmt_info_element(struct iw_mgmt_info_element *to,
183 				      struct iw_mgmt_info_element *from)
184 {
185 	iw_set_mgmt_info_element(from->id, to, from->data, from->len);
186 }
187 
188 static inline void wl3501_switch_page(struct wl3501_card *this, u8 page)
189 {
190 	wl3501_outb(page, this->base_addr + WL3501_NIC_BSS);
191 }
192 
193 /*
194  * Get Ethernet MAC address.
195  *
196  * WARNING: We switch to FPAGE0 and switc back again.
197  *          Making sure there is no other WL function beening called by ISR.
198  */
199 static int wl3501_get_flash_mac_addr(struct wl3501_card *this)
200 {
201 	int base_addr = this->base_addr;
202 
203 	/* get MAC addr */
204 	wl3501_outb(WL3501_BSS_FPAGE3, base_addr + WL3501_NIC_BSS); /* BSS */
205 	wl3501_outb(0x00, base_addr + WL3501_NIC_LMAL);	/* LMAL */
206 	wl3501_outb(0x40, base_addr + WL3501_NIC_LMAH);	/* LMAH */
207 
208 	/* wait for reading EEPROM */
209 	WL3501_NOPLOOP(100);
210 	this->mac_addr[0] = inb(base_addr + WL3501_NIC_IODPA);
211 	WL3501_NOPLOOP(100);
212 	this->mac_addr[1] = inb(base_addr + WL3501_NIC_IODPA);
213 	WL3501_NOPLOOP(100);
214 	this->mac_addr[2] = inb(base_addr + WL3501_NIC_IODPA);
215 	WL3501_NOPLOOP(100);
216 	this->mac_addr[3] = inb(base_addr + WL3501_NIC_IODPA);
217 	WL3501_NOPLOOP(100);
218 	this->mac_addr[4] = inb(base_addr + WL3501_NIC_IODPA);
219 	WL3501_NOPLOOP(100);
220 	this->mac_addr[5] = inb(base_addr + WL3501_NIC_IODPA);
221 	WL3501_NOPLOOP(100);
222 	this->reg_domain = inb(base_addr + WL3501_NIC_IODPA);
223 	WL3501_NOPLOOP(100);
224 	wl3501_outb(WL3501_BSS_FPAGE0, base_addr + WL3501_NIC_BSS);
225 	wl3501_outb(0x04, base_addr + WL3501_NIC_LMAL);
226 	wl3501_outb(0x40, base_addr + WL3501_NIC_LMAH);
227 	WL3501_NOPLOOP(100);
228 	this->version[0] = inb(base_addr + WL3501_NIC_IODPA);
229 	WL3501_NOPLOOP(100);
230 	this->version[1] = inb(base_addr + WL3501_NIC_IODPA);
231 	/* switch to SRAM Page 0 (for safety) */
232 	wl3501_switch_page(this, WL3501_BSS_SPAGE0);
233 
234 	/* The MAC addr should be 00:60:... */
235 	return this->mac_addr[0] == 0x00 && this->mac_addr[1] == 0x60;
236 }
237 
238 /**
239  * wl3501_set_to_wla - Move 'size' bytes from PC to card
240  * @this: Card
241  * @dest: Card addressing space
242  * @src: PC addressing space
243  * @size: Bytes to move
244  *
245  * Move 'size' bytes from PC to card. (Shouldn't be interrupted)
246  */
247 static void wl3501_set_to_wla(struct wl3501_card *this, u16 dest, void *src,
248 			      int size)
249 {
250 	/* switch to SRAM Page 0 */
251 	wl3501_switch_page(this, (dest & 0x8000) ? WL3501_BSS_SPAGE1 :
252 						   WL3501_BSS_SPAGE0);
253 	/* set LMAL and LMAH */
254 	wl3501_outb(dest & 0xff, this->base_addr + WL3501_NIC_LMAL);
255 	wl3501_outb(((dest >> 8) & 0x7f), this->base_addr + WL3501_NIC_LMAH);
256 
257 	/* rep out to Port A */
258 	wl3501_outsb(this->base_addr + WL3501_NIC_IODPA, src, size);
259 }
260 
261 /**
262  * wl3501_get_from_wla - Move 'size' bytes from card to PC
263  * @this: Card
264  * @src: Card addressing space
265  * @dest: PC addressing space
266  * @size: Bytes to move
267  *
268  * Move 'size' bytes from card to PC. (Shouldn't be interrupted)
269  */
270 static void wl3501_get_from_wla(struct wl3501_card *this, u16 src, void *dest,
271 				int size)
272 {
273 	/* switch to SRAM Page 0 */
274 	wl3501_switch_page(this, (src & 0x8000) ? WL3501_BSS_SPAGE1 :
275 						  WL3501_BSS_SPAGE0);
276 	/* set LMAL and LMAH */
277 	wl3501_outb(src & 0xff, this->base_addr + WL3501_NIC_LMAL);
278 	wl3501_outb((src >> 8) & 0x7f, this->base_addr + WL3501_NIC_LMAH);
279 
280 	/* rep get from Port A */
281 	insb(this->base_addr + WL3501_NIC_IODPA, dest, size);
282 }
283 
284 /*
285  * Get/Allocate a free Tx Data Buffer
286  *
287  *  *--------------*-----------------*----------------------------------*
288  *  |    PLCP      |    MAC Header   |  DST  SRC         Data ...       |
289  *  |  (24 bytes)  |    (30 bytes)   |  (6)  (6)  (Ethernet Row Data)   |
290  *  *--------------*-----------------*----------------------------------*
291  *  \               \- IEEE 802.11 -/ \-------------- len --------------/
292  *   \-struct wl3501_80211_tx_hdr--/   \-------- Ethernet Frame -------/
293  *
294  * Return = Position in Card
295  */
296 static u16 wl3501_get_tx_buffer(struct wl3501_card *this, u16 len)
297 {
298 	u16 next, blk_cnt = 0, zero = 0;
299 	u16 full_len = sizeof(struct wl3501_80211_tx_hdr) + len;
300 	u16 ret = 0;
301 
302 	if (full_len > this->tx_buffer_cnt * 254)
303 		goto out;
304 	ret = this->tx_buffer_head;
305 	while (full_len) {
306 		if (full_len < 254)
307 			full_len = 0;
308 		else
309 			full_len -= 254;
310 		wl3501_get_from_wla(this, this->tx_buffer_head, &next,
311 				    sizeof(next));
312 		if (!full_len)
313 			wl3501_set_to_wla(this, this->tx_buffer_head, &zero,
314 					  sizeof(zero));
315 		this->tx_buffer_head = next;
316 		blk_cnt++;
317 		/* if buffer is not enough */
318 		if (!next && full_len) {
319 			this->tx_buffer_head = ret;
320 			ret = 0;
321 			goto out;
322 		}
323 	}
324 	this->tx_buffer_cnt -= blk_cnt;
325 out:
326 	return ret;
327 }
328 
329 /*
330  * Free an allocated Tx Buffer. ptr must be correct position.
331  */
332 static void wl3501_free_tx_buffer(struct wl3501_card *this, u16 ptr)
333 {
334 	/* check if all space is not free */
335 	if (!this->tx_buffer_head)
336 		this->tx_buffer_head = ptr;
337 	else
338 		wl3501_set_to_wla(this, this->tx_buffer_tail,
339 				  &ptr, sizeof(ptr));
340 	while (ptr) {
341 		u16 next;
342 
343 		this->tx_buffer_cnt++;
344 		wl3501_get_from_wla(this, ptr, &next, sizeof(next));
345 		this->tx_buffer_tail = ptr;
346 		ptr = next;
347 	}
348 }
349 
350 static int wl3501_esbq_req_test(struct wl3501_card *this)
351 {
352 	u8 tmp = 0;
353 
354 	wl3501_get_from_wla(this, this->esbq_req_head + 3, &tmp, sizeof(tmp));
355 	return tmp & 0x80;
356 }
357 
358 static void wl3501_esbq_req(struct wl3501_card *this, u16 *ptr)
359 {
360 	u16 tmp = 0;
361 
362 	wl3501_set_to_wla(this, this->esbq_req_head, ptr, 2);
363 	wl3501_set_to_wla(this, this->esbq_req_head + 2, &tmp, sizeof(tmp));
364 	this->esbq_req_head += 4;
365 	if (this->esbq_req_head >= this->esbq_req_end)
366 		this->esbq_req_head = this->esbq_req_start;
367 }
368 
369 static int wl3501_esbq_exec(struct wl3501_card *this, void *sig, int sig_size)
370 {
371 	int rc = -EIO;
372 
373 	if (wl3501_esbq_req_test(this)) {
374 		u16 ptr = wl3501_get_tx_buffer(this, sig_size);
375 		if (ptr) {
376 			wl3501_set_to_wla(this, ptr, sig, sig_size);
377 			wl3501_esbq_req(this, &ptr);
378 			rc = 0;
379 		}
380 	}
381 	return rc;
382 }
383 
384 static int wl3501_request_mib(struct wl3501_card *this, u8 index, void *bf)
385 {
386 	struct wl3501_get_req sig = {
387 		.sig_id	    = WL3501_SIG_GET_REQ,
388 		.mib_attrib = index,
389 	};
390 	unsigned long flags;
391 	int rc = -EIO;
392 
393 	spin_lock_irqsave(&this->lock, flags);
394 	if (wl3501_esbq_req_test(this)) {
395 		u16 ptr = wl3501_get_tx_buffer(this, sizeof(sig));
396 		if (ptr) {
397 			wl3501_set_to_wla(this, ptr, &sig, sizeof(sig));
398 			wl3501_esbq_req(this, &ptr);
399 			this->sig_get_confirm.mib_status = 255;
400 			rc = 0;
401 		}
402 	}
403 	spin_unlock_irqrestore(&this->lock, flags);
404 
405 	return rc;
406 }
407 
408 static int wl3501_get_mib_value(struct wl3501_card *this, u8 index,
409 				void *bf, int size)
410 {
411 	int rc;
412 
413 	rc = wl3501_request_mib(this, index, bf);
414 	if (rc)
415 		return rc;
416 
417 	rc = wait_event_interruptible(this->wait,
418 		this->sig_get_confirm.mib_status != 255);
419 	if (rc)
420 		return rc;
421 
422 	memcpy(bf, this->sig_get_confirm.mib_value, size);
423 	return 0;
424 }
425 
426 static int wl3501_pwr_mgmt(struct wl3501_card *this, int suspend)
427 {
428 	struct wl3501_pwr_mgmt_req sig = {
429 		.sig_id		= WL3501_SIG_PWR_MGMT_REQ,
430 		.pwr_save	= suspend,
431 		.wake_up	= !suspend,
432 		.receive_dtims	= 10,
433 	};
434 	unsigned long flags;
435 	int rc = -EIO;
436 
437 	spin_lock_irqsave(&this->lock, flags);
438 	if (wl3501_esbq_req_test(this)) {
439 		u16 ptr = wl3501_get_tx_buffer(this, sizeof(sig));
440 		if (ptr) {
441 			wl3501_set_to_wla(this, ptr, &sig, sizeof(sig));
442 			wl3501_esbq_req(this, &ptr);
443 			this->sig_pwr_mgmt_confirm.status = 255;
444 			spin_unlock_irqrestore(&this->lock, flags);
445 			rc = wait_event_interruptible(this->wait,
446 				this->sig_pwr_mgmt_confirm.status != 255);
447 			printk(KERN_INFO "%s: %s status=%d\n", __func__,
448 			       suspend ? "suspend" : "resume",
449 			       this->sig_pwr_mgmt_confirm.status);
450 			goto out;
451 		}
452 	}
453 	spin_unlock_irqrestore(&this->lock, flags);
454 out:
455 	return rc;
456 }
457 
458 /**
459  * wl3501_send_pkt - Send a packet.
460  * @this: Card
461  * @data: Ethernet raw frame.  (e.g. data[0] - data[5] is Dest MAC Addr,
462  *                                   data[6] - data[11] is Src MAC Addr)
463  * @len: Packet length
464  * Ref: IEEE 802.11
465  */
466 static int wl3501_send_pkt(struct wl3501_card *this, u8 *data, u16 len)
467 {
468 	u16 bf, sig_bf, next, tmplen, pktlen;
469 	struct wl3501_md_req sig = {
470 		.sig_id = WL3501_SIG_MD_REQ,
471 	};
472 	size_t sig_addr_len = sizeof(sig.addr);
473 	u8 *pdata = (char *)data;
474 	int rc = -EIO;
475 
476 	if (wl3501_esbq_req_test(this)) {
477 		sig_bf = wl3501_get_tx_buffer(this, sizeof(sig));
478 		rc = -ENOMEM;
479 		if (!sig_bf)	/* No free buffer available */
480 			goto out;
481 		bf = wl3501_get_tx_buffer(this, len + 26 + 24);
482 		if (!bf) {
483 			/* No free buffer available */
484 			wl3501_free_tx_buffer(this, sig_bf);
485 			goto out;
486 		}
487 		rc = 0;
488 		memcpy(&sig.addr, pdata, sig_addr_len);
489 		pktlen = len - sig_addr_len;
490 		pdata += sig_addr_len;
491 		sig.data = bf;
492 		if (((*pdata) * 256 + (*(pdata + 1))) > 1500) {
493 			u8 addr4[ETH_ALEN] = {
494 				[0] = 0xAA, [1] = 0xAA, [2] = 0x03, [4] = 0x00,
495 			};
496 
497 			wl3501_set_to_wla(this, bf + 2 +
498 					  offsetof(struct wl3501_tx_hdr, addr4),
499 					  addr4, sizeof(addr4));
500 			sig.size = pktlen + 24 + 4 + 6;
501 			if (pktlen > (254 - sizeof(struct wl3501_tx_hdr))) {
502 				tmplen = 254 - sizeof(struct wl3501_tx_hdr);
503 				pktlen -= tmplen;
504 			} else {
505 				tmplen = pktlen;
506 				pktlen = 0;
507 			}
508 			wl3501_set_to_wla(this,
509 					  bf + 2 + sizeof(struct wl3501_tx_hdr),
510 					  pdata, tmplen);
511 			pdata += tmplen;
512 			wl3501_get_from_wla(this, bf, &next, sizeof(next));
513 			bf = next;
514 		} else {
515 			sig.size = pktlen + 24 + 4 - 2;
516 			pdata += 2;
517 			pktlen -= 2;
518 			if (pktlen > (254 - sizeof(struct wl3501_tx_hdr) + 6)) {
519 				tmplen = 254 - sizeof(struct wl3501_tx_hdr) + 6;
520 				pktlen -= tmplen;
521 			} else {
522 				tmplen = pktlen;
523 				pktlen = 0;
524 			}
525 			wl3501_set_to_wla(this, bf + 2 +
526 					  offsetof(struct wl3501_tx_hdr, addr4),
527 					  pdata, tmplen);
528 			pdata += tmplen;
529 			wl3501_get_from_wla(this, bf, &next, sizeof(next));
530 			bf = next;
531 		}
532 		while (pktlen > 0) {
533 			if (pktlen > 254) {
534 				tmplen = 254;
535 				pktlen -= 254;
536 			} else {
537 				tmplen = pktlen;
538 				pktlen = 0;
539 			}
540 			wl3501_set_to_wla(this, bf + 2, pdata, tmplen);
541 			pdata += tmplen;
542 			wl3501_get_from_wla(this, bf, &next, sizeof(next));
543 			bf = next;
544 		}
545 		wl3501_set_to_wla(this, sig_bf, &sig, sizeof(sig));
546 		wl3501_esbq_req(this, &sig_bf);
547 	}
548 out:
549 	return rc;
550 }
551 
552 static int wl3501_mgmt_resync(struct wl3501_card *this)
553 {
554 	struct wl3501_resync_req sig = {
555 		.sig_id = WL3501_SIG_RESYNC_REQ,
556 	};
557 
558 	return wl3501_esbq_exec(this, &sig, sizeof(sig));
559 }
560 
561 static inline int wl3501_fw_bss_type(struct wl3501_card *this)
562 {
563 	return this->net_type == IW_MODE_INFRA ? WL3501_NET_TYPE_INFRA :
564 						 WL3501_NET_TYPE_ADHOC;
565 }
566 
567 static inline int wl3501_fw_cap_info(struct wl3501_card *this)
568 {
569 	return this->net_type == IW_MODE_INFRA ? WL3501_MGMT_CAPABILITY_ESS :
570 						 WL3501_MGMT_CAPABILITY_IBSS;
571 }
572 
573 static int wl3501_mgmt_scan(struct wl3501_card *this, u16 chan_time)
574 {
575 	struct wl3501_scan_req sig = {
576 		.sig_id		= WL3501_SIG_SCAN_REQ,
577 		.scan_type	= WL3501_SCAN_TYPE_ACTIVE,
578 		.probe_delay	= 0x10,
579 		.min_chan_time	= chan_time,
580 		.max_chan_time	= chan_time,
581 		.bss_type	= wl3501_fw_bss_type(this),
582 	};
583 
584 	this->bss_cnt = this->join_sta_bss = 0;
585 	return wl3501_esbq_exec(this, &sig, sizeof(sig));
586 }
587 
588 static int wl3501_mgmt_join(struct wl3501_card *this, u16 stas)
589 {
590 	struct wl3501_join_req sig = {
591 		.sig_id		  = WL3501_SIG_JOIN_REQ,
592 		.timeout	  = 10,
593 		.req.ds_pset = {
594 			.el = {
595 				.id  = IW_MGMT_INFO_ELEMENT_DS_PARAMETER_SET,
596 				.len = 1,
597 			},
598 			.chan	= this->chan,
599 		},
600 	};
601 
602 	memcpy(&sig.req, &this->bss_set[stas].req, sizeof(sig.req));
603 	return wl3501_esbq_exec(this, &sig, sizeof(sig));
604 }
605 
606 static int wl3501_mgmt_start(struct wl3501_card *this)
607 {
608 	struct wl3501_start_req sig = {
609 		.sig_id			= WL3501_SIG_START_REQ,
610 		.beacon_period		= 400,
611 		.dtim_period		= 1,
612 		.ds_pset = {
613 			.el = {
614 				.id  = IW_MGMT_INFO_ELEMENT_DS_PARAMETER_SET,
615 				.len = 1,
616 			},
617 			.chan	= this->chan,
618 		},
619 		.bss_basic_rset	= {
620 			.el = {
621 				.id	= IW_MGMT_INFO_ELEMENT_SUPPORTED_RATES,
622 				.len = 2,
623 			},
624 			.data_rate_labels = {
625 				[0] = IW_MGMT_RATE_LABEL_MANDATORY |
626 				      IW_MGMT_RATE_LABEL_1MBIT,
627 				[1] = IW_MGMT_RATE_LABEL_MANDATORY |
628 				      IW_MGMT_RATE_LABEL_2MBIT,
629 			},
630 		},
631 		.operational_rset	= {
632 			.el = {
633 				.id	= IW_MGMT_INFO_ELEMENT_SUPPORTED_RATES,
634 				.len = 2,
635 			},
636 			.data_rate_labels = {
637 				[0] = IW_MGMT_RATE_LABEL_MANDATORY |
638 				      IW_MGMT_RATE_LABEL_1MBIT,
639 				[1] = IW_MGMT_RATE_LABEL_MANDATORY |
640 				      IW_MGMT_RATE_LABEL_2MBIT,
641 			},
642 		},
643 		.ibss_pset		= {
644 			.el = {
645 				.id	 = IW_MGMT_INFO_ELEMENT_IBSS_PARAMETER_SET,
646 				.len     = 2,
647 			},
648 			.atim_window = 10,
649 		},
650 		.bss_type		= wl3501_fw_bss_type(this),
651 		.cap_info		= wl3501_fw_cap_info(this),
652 	};
653 
654 	iw_copy_mgmt_info_element(&sig.ssid.el, &this->essid.el);
655 	iw_copy_mgmt_info_element(&this->keep_essid.el, &this->essid.el);
656 	return wl3501_esbq_exec(this, &sig, sizeof(sig));
657 }
658 
659 static void wl3501_mgmt_scan_confirm(struct wl3501_card *this, u16 addr)
660 {
661 	u16 i = 0;
662 	int matchflag = 0;
663 	struct wl3501_scan_confirm sig;
664 
665 	pr_debug("entry");
666 	wl3501_get_from_wla(this, addr, &sig, sizeof(sig));
667 	if (sig.status == WL3501_STATUS_SUCCESS) {
668 		pr_debug("success");
669 		if ((this->net_type == IW_MODE_INFRA &&
670 		     (sig.req.cap_info & WL3501_MGMT_CAPABILITY_ESS)) ||
671 		    (this->net_type == IW_MODE_ADHOC &&
672 		     (sig.req.cap_info & WL3501_MGMT_CAPABILITY_IBSS)) ||
673 		    this->net_type == IW_MODE_AUTO) {
674 			if (!this->essid.el.len)
675 				matchflag = 1;
676 			else if (this->essid.el.len == 3 &&
677 				 !memcmp(this->essid.essid, "ANY", 3))
678 				matchflag = 1;
679 			else if (this->essid.el.len != sig.req.ssid.el.len)
680 				matchflag = 0;
681 			else if (memcmp(this->essid.essid, sig.req.ssid.essid,
682 					this->essid.el.len))
683 				matchflag = 0;
684 			else
685 				matchflag = 1;
686 			if (matchflag) {
687 				for (i = 0; i < this->bss_cnt; i++) {
688 					if (ether_addr_equal_unaligned(this->bss_set[i].req.bssid,
689 								       sig.req.bssid)) {
690 						matchflag = 0;
691 						break;
692 					}
693 				}
694 			}
695 			if (matchflag && (i < 20)) {
696 				memcpy(&this->bss_set[i].req,
697 				       &sig.req, sizeof(sig.req));
698 				this->bss_cnt++;
699 				this->rssi = sig.rssi;
700 				this->bss_set[i].rssi = sig.rssi;
701 			}
702 		}
703 	} else if (sig.status == WL3501_STATUS_TIMEOUT) {
704 		pr_debug("timeout");
705 		this->join_sta_bss = 0;
706 		for (i = this->join_sta_bss; i < this->bss_cnt; i++)
707 			if (!wl3501_mgmt_join(this, i))
708 				break;
709 		this->join_sta_bss = i;
710 		if (this->join_sta_bss == this->bss_cnt) {
711 			if (this->net_type == IW_MODE_INFRA)
712 				wl3501_mgmt_scan(this, 100);
713 			else {
714 				this->adhoc_times++;
715 				if (this->adhoc_times > WL3501_MAX_ADHOC_TRIES)
716 					wl3501_mgmt_start(this);
717 				else
718 					wl3501_mgmt_scan(this, 100);
719 			}
720 		}
721 	}
722 }
723 
724 /**
725  * wl3501_block_interrupt - Mask interrupt from SUTRO
726  * @this: Card
727  *
728  * Mask interrupt from SUTRO. (i.e. SUTRO cannot interrupt the HOST)
729  * Return: 1 if interrupt is originally enabled
730  */
731 static int wl3501_block_interrupt(struct wl3501_card *this)
732 {
733 	u8 old = inb(this->base_addr + WL3501_NIC_GCR);
734 	u8 new = old & (~(WL3501_GCR_ECINT | WL3501_GCR_INT2EC |
735 			WL3501_GCR_ENECINT));
736 
737 	wl3501_outb(new, this->base_addr + WL3501_NIC_GCR);
738 	return old & WL3501_GCR_ENECINT;
739 }
740 
741 /**
742  * wl3501_unblock_interrupt - Enable interrupt from SUTRO
743  * @this: Card
744  *
745  * Enable interrupt from SUTRO. (i.e. SUTRO can interrupt the HOST)
746  * Return: 1 if interrupt is originally enabled
747  */
748 static int wl3501_unblock_interrupt(struct wl3501_card *this)
749 {
750 	u8 old = inb(this->base_addr + WL3501_NIC_GCR);
751 	u8 new = (old & ~(WL3501_GCR_ECINT | WL3501_GCR_INT2EC)) |
752 		  WL3501_GCR_ENECINT;
753 
754 	wl3501_outb(new, this->base_addr + WL3501_NIC_GCR);
755 	return old & WL3501_GCR_ENECINT;
756 }
757 
758 /**
759  * wl3501_receive - Receive data from Receive Queue.
760  *
761  * Receive data from Receive Queue.
762  *
763  * @this: card
764  * @bf: address of host
765  * @size: size of buffer.
766  */
767 static u16 wl3501_receive(struct wl3501_card *this, u8 *bf, u16 size)
768 {
769 	u16 next_addr, next_addr1;
770 	u8 *data = bf + 12;
771 
772 	size -= 12;
773 	wl3501_get_from_wla(this, this->start_seg + 2,
774 			    &next_addr, sizeof(next_addr));
775 	if (size > WL3501_BLKSZ - sizeof(struct wl3501_rx_hdr)) {
776 		wl3501_get_from_wla(this,
777 				    this->start_seg +
778 					sizeof(struct wl3501_rx_hdr), data,
779 				    WL3501_BLKSZ -
780 					sizeof(struct wl3501_rx_hdr));
781 		size -= WL3501_BLKSZ - sizeof(struct wl3501_rx_hdr);
782 		data += WL3501_BLKSZ - sizeof(struct wl3501_rx_hdr);
783 	} else {
784 		wl3501_get_from_wla(this,
785 				    this->start_seg +
786 					sizeof(struct wl3501_rx_hdr),
787 				    data, size);
788 		size = 0;
789 	}
790 	while (size > 0) {
791 		if (size > WL3501_BLKSZ - 5) {
792 			wl3501_get_from_wla(this, next_addr + 5, data,
793 					    WL3501_BLKSZ - 5);
794 			size -= WL3501_BLKSZ - 5;
795 			data += WL3501_BLKSZ - 5;
796 			wl3501_get_from_wla(this, next_addr + 2, &next_addr1,
797 					    sizeof(next_addr1));
798 			next_addr = next_addr1;
799 		} else {
800 			wl3501_get_from_wla(this, next_addr + 5, data, size);
801 			size = 0;
802 		}
803 	}
804 	return 0;
805 }
806 
807 static void wl3501_esbq_req_free(struct wl3501_card *this)
808 {
809 	u8 tmp;
810 	u16 addr;
811 
812 	if (this->esbq_req_head == this->esbq_req_tail)
813 		goto out;
814 	wl3501_get_from_wla(this, this->esbq_req_tail + 3, &tmp, sizeof(tmp));
815 	if (!(tmp & 0x80))
816 		goto out;
817 	wl3501_get_from_wla(this, this->esbq_req_tail, &addr, sizeof(addr));
818 	wl3501_free_tx_buffer(this, addr);
819 	this->esbq_req_tail += 4;
820 	if (this->esbq_req_tail >= this->esbq_req_end)
821 		this->esbq_req_tail = this->esbq_req_start;
822 out:
823 	return;
824 }
825 
826 static int wl3501_esbq_confirm(struct wl3501_card *this)
827 {
828 	u8 tmp;
829 
830 	wl3501_get_from_wla(this, this->esbq_confirm + 3, &tmp, sizeof(tmp));
831 	return tmp & 0x80;
832 }
833 
834 static void wl3501_online(struct net_device *dev)
835 {
836 	struct wl3501_card *this = netdev_priv(dev);
837 
838 	printk(KERN_INFO "%s: Wireless LAN online. BSSID: %pM\n",
839 	       dev->name, this->bssid);
840 	netif_wake_queue(dev);
841 }
842 
843 static void wl3501_esbq_confirm_done(struct wl3501_card *this)
844 {
845 	u8 tmp = 0;
846 
847 	wl3501_set_to_wla(this, this->esbq_confirm + 3, &tmp, sizeof(tmp));
848 	this->esbq_confirm += 4;
849 	if (this->esbq_confirm >= this->esbq_confirm_end)
850 		this->esbq_confirm = this->esbq_confirm_start;
851 }
852 
853 static int wl3501_mgmt_auth(struct wl3501_card *this)
854 {
855 	struct wl3501_auth_req sig = {
856 		.sig_id	 = WL3501_SIG_AUTH_REQ,
857 		.type	 = WL3501_SYS_TYPE_OPEN,
858 		.timeout = 1000,
859 	};
860 
861 	pr_debug("entry");
862 	memcpy(sig.mac_addr, this->bssid, ETH_ALEN);
863 	return wl3501_esbq_exec(this, &sig, sizeof(sig));
864 }
865 
866 static int wl3501_mgmt_association(struct wl3501_card *this)
867 {
868 	struct wl3501_assoc_req sig = {
869 		.sig_id		 = WL3501_SIG_ASSOC_REQ,
870 		.timeout	 = 1000,
871 		.listen_interval = 5,
872 		.cap_info	 = this->cap_info,
873 	};
874 
875 	pr_debug("entry");
876 	memcpy(sig.mac_addr, this->bssid, ETH_ALEN);
877 	return wl3501_esbq_exec(this, &sig, sizeof(sig));
878 }
879 
880 static void wl3501_mgmt_join_confirm(struct net_device *dev, u16 addr)
881 {
882 	struct wl3501_card *this = netdev_priv(dev);
883 	struct wl3501_join_confirm sig;
884 
885 	pr_debug("entry");
886 	wl3501_get_from_wla(this, addr, &sig, sizeof(sig));
887 	if (sig.status == WL3501_STATUS_SUCCESS) {
888 		if (this->net_type == IW_MODE_INFRA) {
889 			if (this->join_sta_bss < this->bss_cnt) {
890 				const int i = this->join_sta_bss;
891 				memcpy(this->bssid,
892 				       this->bss_set[i].req.bssid, ETH_ALEN);
893 				this->chan = this->bss_set[i].req.ds_pset.chan;
894 				iw_copy_mgmt_info_element(&this->keep_essid.el,
895 						     &this->bss_set[i].req.ssid.el);
896 				wl3501_mgmt_auth(this);
897 			}
898 		} else {
899 			const int i = this->join_sta_bss;
900 
901 			memcpy(&this->bssid, &this->bss_set[i].req.bssid, ETH_ALEN);
902 			this->chan = this->bss_set[i].req.ds_pset.chan;
903 			iw_copy_mgmt_info_element(&this->keep_essid.el,
904 						  &this->bss_set[i].req.ssid.el);
905 			wl3501_online(dev);
906 		}
907 	} else {
908 		int i;
909 		this->join_sta_bss++;
910 		for (i = this->join_sta_bss; i < this->bss_cnt; i++)
911 			if (!wl3501_mgmt_join(this, i))
912 				break;
913 		this->join_sta_bss = i;
914 		if (this->join_sta_bss == this->bss_cnt) {
915 			if (this->net_type == IW_MODE_INFRA)
916 				wl3501_mgmt_scan(this, 100);
917 			else {
918 				this->adhoc_times++;
919 				if (this->adhoc_times > WL3501_MAX_ADHOC_TRIES)
920 					wl3501_mgmt_start(this);
921 				else
922 					wl3501_mgmt_scan(this, 100);
923 			}
924 		}
925 	}
926 }
927 
928 static inline void wl3501_alarm_interrupt(struct net_device *dev,
929 					  struct wl3501_card *this)
930 {
931 	if (this->net_type == IW_MODE_INFRA) {
932 		printk(KERN_INFO "Wireless LAN offline\n");
933 		netif_stop_queue(dev);
934 		wl3501_mgmt_resync(this);
935 	}
936 }
937 
938 static inline void wl3501_md_confirm_interrupt(struct net_device *dev,
939 					       struct wl3501_card *this,
940 					       u16 addr)
941 {
942 	struct wl3501_md_confirm sig;
943 
944 	pr_debug("entry");
945 	wl3501_get_from_wla(this, addr, &sig, sizeof(sig));
946 	wl3501_free_tx_buffer(this, sig.data);
947 	if (netif_queue_stopped(dev))
948 		netif_wake_queue(dev);
949 }
950 
951 static inline void wl3501_md_ind_interrupt(struct net_device *dev,
952 					   struct wl3501_card *this, u16 addr)
953 {
954 	struct wl3501_md_ind sig;
955 	struct sk_buff *skb;
956 	u8 rssi, addr4[ETH_ALEN];
957 	u16 pkt_len;
958 
959 	wl3501_get_from_wla(this, addr, &sig, sizeof(sig));
960 	this->start_seg = sig.data;
961 	wl3501_get_from_wla(this,
962 			    sig.data + offsetof(struct wl3501_rx_hdr, rssi),
963 			    &rssi, sizeof(rssi));
964 	this->rssi = rssi <= 63 ? (rssi * 100) / 64 : 255;
965 
966 	wl3501_get_from_wla(this,
967 			    sig.data +
968 				offsetof(struct wl3501_rx_hdr, addr4),
969 			    &addr4, sizeof(addr4));
970 	if (!(addr4[0] == 0xAA && addr4[1] == 0xAA &&
971 	      addr4[2] == 0x03 && addr4[4] == 0x00)) {
972 		printk(KERN_INFO "Unsupported packet type!\n");
973 		return;
974 	}
975 	pkt_len = sig.size + 12 - 24 - 4 - 6;
976 
977 	skb = dev_alloc_skb(pkt_len + 5);
978 
979 	if (!skb) {
980 		printk(KERN_WARNING "%s: Can't alloc a sk_buff of size %d.\n",
981 		       dev->name, pkt_len);
982 		dev->stats.rx_dropped++;
983 	} else {
984 		skb->dev = dev;
985 		skb_reserve(skb, 2); /* IP headers on 16 bytes boundaries */
986 		skb_copy_to_linear_data(skb, (unsigned char *)&sig.addr,
987 					sizeof(sig.addr));
988 		wl3501_receive(this, skb->data, pkt_len);
989 		skb_put(skb, pkt_len);
990 		skb->protocol	= eth_type_trans(skb, dev);
991 		dev->stats.rx_packets++;
992 		dev->stats.rx_bytes += skb->len;
993 		netif_rx(skb);
994 	}
995 }
996 
997 static inline void wl3501_get_confirm_interrupt(struct wl3501_card *this,
998 						u16 addr, void *sig, int size)
999 {
1000 	pr_debug("entry");
1001 	wl3501_get_from_wla(this, addr, &this->sig_get_confirm,
1002 			    sizeof(this->sig_get_confirm));
1003 	wake_up(&this->wait);
1004 }
1005 
1006 static inline void wl3501_start_confirm_interrupt(struct net_device *dev,
1007 						  struct wl3501_card *this,
1008 						  u16 addr)
1009 {
1010 	struct wl3501_start_confirm sig;
1011 
1012 	pr_debug("entry");
1013 	wl3501_get_from_wla(this, addr, &sig, sizeof(sig));
1014 	if (sig.status == WL3501_STATUS_SUCCESS)
1015 		netif_wake_queue(dev);
1016 }
1017 
1018 static inline void wl3501_assoc_confirm_interrupt(struct net_device *dev,
1019 						  u16 addr)
1020 {
1021 	struct wl3501_card *this = netdev_priv(dev);
1022 	struct wl3501_assoc_confirm sig;
1023 
1024 	pr_debug("entry");
1025 	wl3501_get_from_wla(this, addr, &sig, sizeof(sig));
1026 
1027 	if (sig.status == WL3501_STATUS_SUCCESS)
1028 		wl3501_online(dev);
1029 }
1030 
1031 static inline void wl3501_auth_confirm_interrupt(struct wl3501_card *this,
1032 						 u16 addr)
1033 {
1034 	struct wl3501_auth_confirm sig;
1035 
1036 	pr_debug("entry");
1037 	wl3501_get_from_wla(this, addr, &sig, sizeof(sig));
1038 
1039 	if (sig.status == WL3501_STATUS_SUCCESS)
1040 		wl3501_mgmt_association(this);
1041 	else
1042 		wl3501_mgmt_resync(this);
1043 }
1044 
1045 static inline void wl3501_rx_interrupt(struct net_device *dev)
1046 {
1047 	int morepkts;
1048 	u16 addr;
1049 	u8 sig_id;
1050 	struct wl3501_card *this = netdev_priv(dev);
1051 
1052 	pr_debug("entry");
1053 loop:
1054 	morepkts = 0;
1055 	if (!wl3501_esbq_confirm(this))
1056 		goto free;
1057 	wl3501_get_from_wla(this, this->esbq_confirm, &addr, sizeof(addr));
1058 	wl3501_get_from_wla(this, addr + 2, &sig_id, sizeof(sig_id));
1059 
1060 	switch (sig_id) {
1061 	case WL3501_SIG_DEAUTH_IND:
1062 	case WL3501_SIG_DISASSOC_IND:
1063 	case WL3501_SIG_ALARM:
1064 		wl3501_alarm_interrupt(dev, this);
1065 		break;
1066 	case WL3501_SIG_MD_CONFIRM:
1067 		wl3501_md_confirm_interrupt(dev, this, addr);
1068 		break;
1069 	case WL3501_SIG_MD_IND:
1070 		wl3501_md_ind_interrupt(dev, this, addr);
1071 		break;
1072 	case WL3501_SIG_GET_CONFIRM:
1073 		wl3501_get_confirm_interrupt(this, addr,
1074 					     &this->sig_get_confirm,
1075 					     sizeof(this->sig_get_confirm));
1076 		break;
1077 	case WL3501_SIG_PWR_MGMT_CONFIRM:
1078 		wl3501_get_confirm_interrupt(this, addr,
1079 					     &this->sig_pwr_mgmt_confirm,
1080 					    sizeof(this->sig_pwr_mgmt_confirm));
1081 		break;
1082 	case WL3501_SIG_START_CONFIRM:
1083 		wl3501_start_confirm_interrupt(dev, this, addr);
1084 		break;
1085 	case WL3501_SIG_SCAN_CONFIRM:
1086 		wl3501_mgmt_scan_confirm(this, addr);
1087 		break;
1088 	case WL3501_SIG_JOIN_CONFIRM:
1089 		wl3501_mgmt_join_confirm(dev, addr);
1090 		break;
1091 	case WL3501_SIG_ASSOC_CONFIRM:
1092 		wl3501_assoc_confirm_interrupt(dev, addr);
1093 		break;
1094 	case WL3501_SIG_AUTH_CONFIRM:
1095 		wl3501_auth_confirm_interrupt(this, addr);
1096 		break;
1097 	case WL3501_SIG_RESYNC_CONFIRM:
1098 		wl3501_mgmt_resync(this); /* FIXME: should be resync_confirm */
1099 		break;
1100 	}
1101 	wl3501_esbq_confirm_done(this);
1102 	morepkts = 1;
1103 	/* free request if necessary */
1104 free:
1105 	wl3501_esbq_req_free(this);
1106 	if (morepkts)
1107 		goto loop;
1108 }
1109 
1110 static inline void wl3501_ack_interrupt(struct wl3501_card *this)
1111 {
1112 	wl3501_outb(WL3501_GCR_ECINT, this->base_addr + WL3501_NIC_GCR);
1113 }
1114 
1115 /**
1116  * wl3501_interrupt - Hardware interrupt from card.
1117  * @irq: Interrupt number
1118  * @dev_id: net_device
1119  *
1120  * We must acknowledge the interrupt as soon as possible, and block the
1121  * interrupt from the same card immediately to prevent re-entry.
1122  *
1123  * Before accessing the Control_Status_Block, we must lock SUTRO first.
1124  * On the other hand, to prevent SUTRO from malfunctioning, we must
1125  * unlock the SUTRO as soon as possible.
1126  */
1127 static irqreturn_t wl3501_interrupt(int irq, void *dev_id)
1128 {
1129 	struct net_device *dev = dev_id;
1130 	struct wl3501_card *this;
1131 
1132 	this = netdev_priv(dev);
1133 	spin_lock(&this->lock);
1134 	wl3501_ack_interrupt(this);
1135 	wl3501_block_interrupt(this);
1136 	wl3501_rx_interrupt(dev);
1137 	wl3501_unblock_interrupt(this);
1138 	spin_unlock(&this->lock);
1139 
1140 	return IRQ_HANDLED;
1141 }
1142 
1143 static int wl3501_reset_board(struct wl3501_card *this)
1144 {
1145 	u8 tmp = 0;
1146 	int i, rc = 0;
1147 
1148 	/* Coreset */
1149 	wl3501_outb_p(WL3501_GCR_CORESET, this->base_addr + WL3501_NIC_GCR);
1150 	wl3501_outb_p(0, this->base_addr + WL3501_NIC_GCR);
1151 	wl3501_outb_p(WL3501_GCR_CORESET, this->base_addr + WL3501_NIC_GCR);
1152 
1153 	/* Reset SRAM 0x480 to zero */
1154 	wl3501_set_to_wla(this, 0x480, &tmp, sizeof(tmp));
1155 
1156 	/* Start up */
1157 	wl3501_outb_p(0, this->base_addr + WL3501_NIC_GCR);
1158 
1159 	WL3501_NOPLOOP(1024 * 50);
1160 
1161 	wl3501_unblock_interrupt(this);	/* acme: was commented */
1162 
1163 	/* Polling Self_Test_Status */
1164 	for (i = 0; i < 10000; i++) {
1165 		wl3501_get_from_wla(this, 0x480, &tmp, sizeof(tmp));
1166 
1167 		if (tmp == 'W') {
1168 			/* firmware complete all test successfully */
1169 			tmp = 'A';
1170 			wl3501_set_to_wla(this, 0x480, &tmp, sizeof(tmp));
1171 			goto out;
1172 		}
1173 		WL3501_NOPLOOP(10);
1174 	}
1175 	printk(KERN_WARNING "%s: failed to reset the board!\n", __func__);
1176 	rc = -ENODEV;
1177 out:
1178 	return rc;
1179 }
1180 
1181 static int wl3501_init_firmware(struct wl3501_card *this)
1182 {
1183 	u16 ptr, next;
1184 	int rc = wl3501_reset_board(this);
1185 
1186 	if (rc)
1187 		goto fail;
1188 	this->card_name[0] = '\0';
1189 	wl3501_get_from_wla(this, 0x1a00,
1190 			    this->card_name, sizeof(this->card_name));
1191 	this->card_name[sizeof(this->card_name) - 1] = '\0';
1192 	this->firmware_date[0] = '\0';
1193 	wl3501_get_from_wla(this, 0x1a40,
1194 			    this->firmware_date, sizeof(this->firmware_date));
1195 	this->firmware_date[sizeof(this->firmware_date) - 1] = '\0';
1196 	/* Switch to SRAM Page 0 */
1197 	wl3501_switch_page(this, WL3501_BSS_SPAGE0);
1198 	/* Read parameter from card */
1199 	wl3501_get_from_wla(this, 0x482, &this->esbq_req_start, 2);
1200 	wl3501_get_from_wla(this, 0x486, &this->esbq_req_end, 2);
1201 	wl3501_get_from_wla(this, 0x488, &this->esbq_confirm_start, 2);
1202 	wl3501_get_from_wla(this, 0x48c, &this->esbq_confirm_end, 2);
1203 	wl3501_get_from_wla(this, 0x48e, &this->tx_buffer_head, 2);
1204 	wl3501_get_from_wla(this, 0x492, &this->tx_buffer_size, 2);
1205 	this->esbq_req_tail	= this->esbq_req_head = this->esbq_req_start;
1206 	this->esbq_req_end     += this->esbq_req_start;
1207 	this->esbq_confirm	= this->esbq_confirm_start;
1208 	this->esbq_confirm_end += this->esbq_confirm_start;
1209 	/* Initial Tx Buffer */
1210 	this->tx_buffer_cnt = 1;
1211 	ptr = this->tx_buffer_head;
1212 	next = ptr + WL3501_BLKSZ;
1213 	while ((next - this->tx_buffer_head) < this->tx_buffer_size) {
1214 		this->tx_buffer_cnt++;
1215 		wl3501_set_to_wla(this, ptr, &next, sizeof(next));
1216 		ptr = next;
1217 		next = ptr + WL3501_BLKSZ;
1218 	}
1219 	rc = 0;
1220 	next = 0;
1221 	wl3501_set_to_wla(this, ptr, &next, sizeof(next));
1222 	this->tx_buffer_tail = ptr;
1223 out:
1224 	return rc;
1225 fail:
1226 	printk(KERN_WARNING "%s: failed!\n", __func__);
1227 	goto out;
1228 }
1229 
1230 static int wl3501_close(struct net_device *dev)
1231 {
1232 	struct wl3501_card *this = netdev_priv(dev);
1233 	unsigned long flags;
1234 	struct pcmcia_device *link;
1235 	link = this->p_dev;
1236 
1237 	spin_lock_irqsave(&this->lock, flags);
1238 	link->open--;
1239 
1240 	/* Stop wl3501_hard_start_xmit() from now on */
1241 	netif_stop_queue(dev);
1242 	wl3501_ack_interrupt(this);
1243 
1244 	/* Mask interrupts from the SUTRO */
1245 	wl3501_block_interrupt(this);
1246 
1247 	printk(KERN_INFO "%s: WL3501 closed\n", dev->name);
1248 	spin_unlock_irqrestore(&this->lock, flags);
1249 	return 0;
1250 }
1251 
1252 /**
1253  * wl3501_reset - Reset the SUTRO.
1254  * @dev: network device
1255  *
1256  * It is almost the same as wl3501_open(). In fact, we may just wl3501_close()
1257  * and wl3501_open() again, but I wouldn't like to free_irq() when the driver
1258  * is running. It seems to be dangerous.
1259  */
1260 static int wl3501_reset(struct net_device *dev)
1261 {
1262 	struct wl3501_card *this = netdev_priv(dev);
1263 	int rc = -ENODEV;
1264 	unsigned long flags;
1265 
1266 	spin_lock_irqsave(&this->lock, flags);
1267 	wl3501_block_interrupt(this);
1268 
1269 	if (wl3501_init_firmware(this)) {
1270 		printk(KERN_WARNING "%s: Can't initialize Firmware!\n",
1271 		       dev->name);
1272 		/* Free IRQ, and mark IRQ as unused */
1273 		free_irq(dev->irq, dev);
1274 		goto out;
1275 	}
1276 
1277 	/*
1278 	 * Queue has to be started only when the Card is Started
1279 	 */
1280 	netif_stop_queue(dev);
1281 	this->adhoc_times = 0;
1282 	wl3501_ack_interrupt(this);
1283 	wl3501_unblock_interrupt(this);
1284 	wl3501_mgmt_scan(this, 100);
1285 	pr_debug("%s: device reset", dev->name);
1286 	rc = 0;
1287 out:
1288 	spin_unlock_irqrestore(&this->lock, flags);
1289 	return rc;
1290 }
1291 
1292 static void wl3501_tx_timeout(struct net_device *dev, unsigned int txqueue)
1293 {
1294 	struct net_device_stats *stats = &dev->stats;
1295 	int rc;
1296 
1297 	stats->tx_errors++;
1298 	rc = wl3501_reset(dev);
1299 	if (rc)
1300 		printk(KERN_ERR "%s: Error %d resetting card on Tx timeout!\n",
1301 		       dev->name, rc);
1302 	else {
1303 		netif_trans_update(dev); /* prevent tx timeout */
1304 		netif_wake_queue(dev);
1305 	}
1306 }
1307 
1308 /*
1309  * Return : 0 - OK
1310  *	    1 - Could not transmit (dev_queue_xmit will queue it)
1311  *		and try to sent it later
1312  */
1313 static netdev_tx_t wl3501_hard_start_xmit(struct sk_buff *skb,
1314 						struct net_device *dev)
1315 {
1316 	int enabled, rc;
1317 	struct wl3501_card *this = netdev_priv(dev);
1318 	unsigned long flags;
1319 
1320 	spin_lock_irqsave(&this->lock, flags);
1321 	enabled = wl3501_block_interrupt(this);
1322 	rc = wl3501_send_pkt(this, skb->data, skb->len);
1323 	if (enabled)
1324 		wl3501_unblock_interrupt(this);
1325 	if (rc) {
1326 		++dev->stats.tx_dropped;
1327 		netif_stop_queue(dev);
1328 	} else {
1329 		++dev->stats.tx_packets;
1330 		dev->stats.tx_bytes += skb->len;
1331 		dev_kfree_skb_irq(skb);
1332 
1333 		if (this->tx_buffer_cnt < 2)
1334 			netif_stop_queue(dev);
1335 	}
1336 	spin_unlock_irqrestore(&this->lock, flags);
1337 	return NETDEV_TX_OK;
1338 }
1339 
1340 static int wl3501_open(struct net_device *dev)
1341 {
1342 	int rc = -ENODEV;
1343 	struct wl3501_card *this = netdev_priv(dev);
1344 	unsigned long flags;
1345 	struct pcmcia_device *link;
1346 	link = this->p_dev;
1347 
1348 	spin_lock_irqsave(&this->lock, flags);
1349 	if (!pcmcia_dev_present(link))
1350 		goto out;
1351 	netif_device_attach(dev);
1352 	link->open++;
1353 
1354 	/* Initial WL3501 firmware */
1355 	pr_debug("%s: Initialize WL3501 firmware...", dev->name);
1356 	if (wl3501_init_firmware(this))
1357 		goto fail;
1358 	/* Initial device variables */
1359 	this->adhoc_times = 0;
1360 	/* Acknowledge Interrupt, for cleaning last state */
1361 	wl3501_ack_interrupt(this);
1362 
1363 	/* Enable interrupt from card after all */
1364 	wl3501_unblock_interrupt(this);
1365 	wl3501_mgmt_scan(this, 100);
1366 	rc = 0;
1367 	pr_debug("%s: WL3501 opened", dev->name);
1368 	printk(KERN_INFO "%s: Card Name: %s\n"
1369 			 "%s: Firmware Date: %s\n",
1370 			 dev->name, this->card_name,
1371 			 dev->name, this->firmware_date);
1372 out:
1373 	spin_unlock_irqrestore(&this->lock, flags);
1374 	return rc;
1375 fail:
1376 	printk(KERN_WARNING "%s: Can't initialize firmware!\n", dev->name);
1377 	goto out;
1378 }
1379 
1380 static struct iw_statistics *wl3501_get_wireless_stats(struct net_device *dev)
1381 {
1382 	struct wl3501_card *this = netdev_priv(dev);
1383 	struct iw_statistics *wstats = &this->wstats;
1384 	u32 value; /* size checked: it is u32 */
1385 
1386 	memset(wstats, 0, sizeof(*wstats));
1387 	wstats->status = netif_running(dev);
1388 	if (!wl3501_get_mib_value(this, WL3501_MIB_ATTR_WEP_ICV_ERROR_COUNT,
1389 				  &value, sizeof(value)))
1390 		wstats->discard.code += value;
1391 	if (!wl3501_get_mib_value(this, WL3501_MIB_ATTR_WEP_UNDECRYPTABLE_COUNT,
1392 				  &value, sizeof(value)))
1393 		wstats->discard.code += value;
1394 	if (!wl3501_get_mib_value(this, WL3501_MIB_ATTR_WEP_EXCLUDED_COUNT,
1395 				  &value, sizeof(value)))
1396 		wstats->discard.code += value;
1397 	if (!wl3501_get_mib_value(this, WL3501_MIB_ATTR_RETRY_COUNT,
1398 				  &value, sizeof(value)))
1399 		wstats->discard.retries	= value;
1400 	if (!wl3501_get_mib_value(this, WL3501_MIB_ATTR_FAILED_COUNT,
1401 				  &value, sizeof(value)))
1402 		wstats->discard.misc += value;
1403 	if (!wl3501_get_mib_value(this, WL3501_MIB_ATTR_RTS_FAILURE_COUNT,
1404 				  &value, sizeof(value)))
1405 		wstats->discard.misc += value;
1406 	if (!wl3501_get_mib_value(this, WL3501_MIB_ATTR_ACK_FAILURE_COUNT,
1407 				  &value, sizeof(value)))
1408 		wstats->discard.misc += value;
1409 	if (!wl3501_get_mib_value(this, WL3501_MIB_ATTR_FRAME_DUPLICATE_COUNT,
1410 				  &value, sizeof(value)))
1411 		wstats->discard.misc += value;
1412 	return wstats;
1413 }
1414 
1415 /**
1416  * wl3501_detach - deletes a driver "instance"
1417  * @link: FILL_IN
1418  *
1419  * This deletes a driver "instance". The device is de-registered with Card
1420  * Services. If it has been released, all local data structures are freed.
1421  * Otherwise, the structures will be freed when the device is released.
1422  */
1423 static void wl3501_detach(struct pcmcia_device *link)
1424 {
1425 	struct net_device *dev = link->priv;
1426 
1427 	/* If the device is currently configured and active, we won't actually
1428 	 * delete it yet.  Instead, it is marked so that when the release()
1429 	 * function is called, that will trigger a proper detach(). */
1430 
1431 	while (link->open > 0)
1432 		wl3501_close(dev);
1433 
1434 	netif_device_detach(dev);
1435 	wl3501_release(link);
1436 
1437 	unregister_netdev(dev);
1438 	free_netdev(dev);
1439 }
1440 
1441 static int wl3501_get_name(struct net_device *dev, struct iw_request_info *info,
1442 			   union iwreq_data *wrqu, char *extra)
1443 {
1444 	strscpy(wrqu->name, "IEEE 802.11-DS", sizeof(wrqu->name));
1445 	return 0;
1446 }
1447 
1448 static int wl3501_set_freq(struct net_device *dev, struct iw_request_info *info,
1449 			   union iwreq_data *wrqu, char *extra)
1450 {
1451 	struct wl3501_card *this = netdev_priv(dev);
1452 	int channel = wrqu->freq.m;
1453 	int rc = -EINVAL;
1454 
1455 	if (iw_valid_channel(this->reg_domain, channel)) {
1456 		this->chan = channel;
1457 		rc = wl3501_reset(dev);
1458 	}
1459 	return rc;
1460 }
1461 
1462 static int wl3501_get_freq(struct net_device *dev, struct iw_request_info *info,
1463 			   union iwreq_data *wrqu, char *extra)
1464 {
1465 	struct wl3501_card *this = netdev_priv(dev);
1466 
1467 	wrqu->freq.m = 100000 *
1468 		ieee80211_channel_to_frequency(this->chan, NL80211_BAND_2GHZ);
1469 	wrqu->freq.e = 1;
1470 	return 0;
1471 }
1472 
1473 static int wl3501_set_mode(struct net_device *dev, struct iw_request_info *info,
1474 			   union iwreq_data *wrqu, char *extra)
1475 {
1476 	int rc = -EINVAL;
1477 
1478 	if (wrqu->mode == IW_MODE_INFRA ||
1479 	    wrqu->mode == IW_MODE_ADHOC ||
1480 	    wrqu->mode == IW_MODE_AUTO) {
1481 		struct wl3501_card *this = netdev_priv(dev);
1482 
1483 		this->net_type = wrqu->mode;
1484 		rc = wl3501_reset(dev);
1485 	}
1486 	return rc;
1487 }
1488 
1489 static int wl3501_get_mode(struct net_device *dev, struct iw_request_info *info,
1490 			   union iwreq_data *wrqu, char *extra)
1491 {
1492 	struct wl3501_card *this = netdev_priv(dev);
1493 
1494 	wrqu->mode = this->net_type;
1495 	return 0;
1496 }
1497 
1498 static int wl3501_get_sens(struct net_device *dev, struct iw_request_info *info,
1499 			   union iwreq_data *wrqu, char *extra)
1500 {
1501 	struct wl3501_card *this = netdev_priv(dev);
1502 
1503 	wrqu->sens.value = this->rssi;
1504 	wrqu->sens.disabled = !wrqu->sens.value;
1505 	wrqu->sens.fixed = 1;
1506 	return 0;
1507 }
1508 
1509 static int wl3501_get_range(struct net_device *dev,
1510 			    struct iw_request_info *info,
1511 			    union iwreq_data *wrqu, char *extra)
1512 {
1513 	struct iw_range *range = (struct iw_range *)extra;
1514 
1515 	/* Set the length (very important for backward compatibility) */
1516 	wrqu->data.length = sizeof(*range);
1517 
1518 	/* Set all the info we don't care or don't know about to zero */
1519 	memset(range, 0, sizeof(*range));
1520 
1521 	/* Set the Wireless Extension versions */
1522 	range->we_version_compiled	= WIRELESS_EXT;
1523 	range->we_version_source	= 1;
1524 	range->throughput		= 2 * 1000 * 1000;     /* ~2 Mb/s */
1525 	/* FIXME: study the code to fill in more fields... */
1526 	return 0;
1527 }
1528 
1529 static int wl3501_set_wap(struct net_device *dev, struct iw_request_info *info,
1530 			  union iwreq_data *wrqu, char *extra)
1531 {
1532 	struct wl3501_card *this = netdev_priv(dev);
1533 	int rc = -EINVAL;
1534 
1535 	/* FIXME: we support other ARPHRDs...*/
1536 	if (wrqu->ap_addr.sa_family != ARPHRD_ETHER)
1537 		goto out;
1538 	if (is_broadcast_ether_addr(wrqu->ap_addr.sa_data)) {
1539 		/* FIXME: rescan? */
1540 	} else
1541 		memcpy(this->bssid, wrqu->ap_addr.sa_data, ETH_ALEN);
1542 		/* FIXME: rescan? deassoc & scan? */
1543 	rc = 0;
1544 out:
1545 	return rc;
1546 }
1547 
1548 static int wl3501_get_wap(struct net_device *dev, struct iw_request_info *info,
1549 			  union iwreq_data *wrqu, char *extra)
1550 {
1551 	struct wl3501_card *this = netdev_priv(dev);
1552 
1553 	wrqu->ap_addr.sa_family = ARPHRD_ETHER;
1554 	memcpy(wrqu->ap_addr.sa_data, this->bssid, ETH_ALEN);
1555 	return 0;
1556 }
1557 
1558 static int wl3501_set_scan(struct net_device *dev, struct iw_request_info *info,
1559 			   union iwreq_data *wrqu, char *extra)
1560 {
1561 	/*
1562 	 * FIXME: trigger scanning with a reset, yes, I'm lazy
1563 	 */
1564 	return wl3501_reset(dev);
1565 }
1566 
1567 static int wl3501_get_scan(struct net_device *dev, struct iw_request_info *info,
1568 			   union iwreq_data *wrqu, char *extra)
1569 {
1570 	struct wl3501_card *this = netdev_priv(dev);
1571 	int i;
1572 	char *current_ev = extra;
1573 	struct iw_event iwe;
1574 
1575 	for (i = 0; i < this->bss_cnt; ++i) {
1576 		iwe.cmd			= SIOCGIWAP;
1577 		iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
1578 		memcpy(iwe.u.ap_addr.sa_data, this->bss_set[i].req.bssid, ETH_ALEN);
1579 		current_ev = iwe_stream_add_event(info, current_ev,
1580 						  extra + IW_SCAN_MAX_DATA,
1581 						  &iwe, IW_EV_ADDR_LEN);
1582 		iwe.cmd		  = SIOCGIWESSID;
1583 		iwe.u.data.flags  = 1;
1584 		iwe.u.data.length = this->bss_set[i].req.ssid.el.len;
1585 		current_ev = iwe_stream_add_point(info, current_ev,
1586 						  extra + IW_SCAN_MAX_DATA,
1587 						  &iwe,
1588 						  this->bss_set[i].req.ssid.essid);
1589 		iwe.cmd	   = SIOCGIWMODE;
1590 		iwe.u.mode = this->bss_set[i].req.bss_type;
1591 		current_ev = iwe_stream_add_event(info, current_ev,
1592 						  extra + IW_SCAN_MAX_DATA,
1593 						  &iwe, IW_EV_UINT_LEN);
1594 		iwe.cmd = SIOCGIWFREQ;
1595 		iwe.u.freq.m = this->bss_set[i].req.ds_pset.chan;
1596 		iwe.u.freq.e = 0;
1597 		current_ev = iwe_stream_add_event(info, current_ev,
1598 						  extra + IW_SCAN_MAX_DATA,
1599 						  &iwe, IW_EV_FREQ_LEN);
1600 		iwe.cmd = SIOCGIWENCODE;
1601 		if (this->bss_set[i].req.cap_info & WL3501_MGMT_CAPABILITY_PRIVACY)
1602 			iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
1603 		else
1604 			iwe.u.data.flags = IW_ENCODE_DISABLED;
1605 		iwe.u.data.length = 0;
1606 		current_ev = iwe_stream_add_point(info, current_ev,
1607 						  extra + IW_SCAN_MAX_DATA,
1608 						  &iwe, NULL);
1609 	}
1610 	/* Length of data */
1611 	wrqu->data.length = (current_ev - extra);
1612 	wrqu->data.flags = 0; /* FIXME: set properly these flags */
1613 	return 0;
1614 }
1615 
1616 static int wl3501_set_essid(struct net_device *dev,
1617 			    struct iw_request_info *info,
1618 			    union iwreq_data *wrqu, char *extra)
1619 {
1620 	struct wl3501_card *this = netdev_priv(dev);
1621 
1622 	if (wrqu->data.flags) {
1623 		iw_set_mgmt_info_element(IW_MGMT_INFO_ELEMENT_SSID,
1624 					 &this->essid.el,
1625 					 extra, wrqu->data.length);
1626 	} else { /* We accept any ESSID */
1627 		iw_set_mgmt_info_element(IW_MGMT_INFO_ELEMENT_SSID,
1628 					 &this->essid.el, "ANY", 3);
1629 	}
1630 	return wl3501_reset(dev);
1631 }
1632 
1633 static int wl3501_get_essid(struct net_device *dev,
1634 			    struct iw_request_info *info,
1635 			    union iwreq_data *wrqu, char *extra)
1636 {
1637 	struct wl3501_card *this = netdev_priv(dev);
1638 	unsigned long flags;
1639 
1640 	spin_lock_irqsave(&this->lock, flags);
1641 	wrqu->essid.flags  = 1;
1642 	wrqu->essid.length = this->essid.el.len;
1643 	memcpy(extra, this->essid.essid, this->essid.el.len);
1644 	spin_unlock_irqrestore(&this->lock, flags);
1645 	return 0;
1646 }
1647 
1648 static int wl3501_set_nick(struct net_device *dev, struct iw_request_info *info,
1649 			   union iwreq_data *wrqu, char *extra)
1650 {
1651 	struct wl3501_card *this = netdev_priv(dev);
1652 
1653 	if (wrqu->data.length > sizeof(this->nick))
1654 		return -E2BIG;
1655 	strscpy(this->nick, extra, wrqu->data.length);
1656 	return 0;
1657 }
1658 
1659 static int wl3501_get_nick(struct net_device *dev, struct iw_request_info *info,
1660 			   union iwreq_data *wrqu, char *extra)
1661 {
1662 	struct wl3501_card *this = netdev_priv(dev);
1663 
1664 	strscpy(extra, this->nick, 32);
1665 	wrqu->data.length = strlen(extra);
1666 	return 0;
1667 }
1668 
1669 static int wl3501_get_rate(struct net_device *dev, struct iw_request_info *info,
1670 			   union iwreq_data *wrqu, char *extra)
1671 {
1672 	/*
1673 	 * FIXME: have to see from where to get this info, perhaps this card
1674 	 * works at 1 Mbit/s too... for now leave at 2 Mbit/s that is the most
1675 	 * common with the Planet Access Points. -acme
1676 	 */
1677 	wrqu->bitrate.value = 2000000;
1678 	wrqu->bitrate.fixed = 1;
1679 	return 0;
1680 }
1681 
1682 static int wl3501_get_rts_threshold(struct net_device *dev,
1683 				    struct iw_request_info *info,
1684 				    union iwreq_data *wrqu, char *extra)
1685 {
1686 	u16 threshold; /* size checked: it is u16 */
1687 	struct wl3501_card *this = netdev_priv(dev);
1688 	int rc = wl3501_get_mib_value(this, WL3501_MIB_ATTR_RTS_THRESHOLD,
1689 				      &threshold, sizeof(threshold));
1690 	if (!rc) {
1691 		wrqu->rts.value = threshold;
1692 		wrqu->rts.disabled = threshold >= 2347;
1693 		wrqu->rts.fixed = 1;
1694 	}
1695 	return rc;
1696 }
1697 
1698 static int wl3501_get_frag_threshold(struct net_device *dev,
1699 				     struct iw_request_info *info,
1700 				     union iwreq_data *wrqu, char *extra)
1701 {
1702 	u16 threshold; /* size checked: it is u16 */
1703 	struct wl3501_card *this = netdev_priv(dev);
1704 	int rc = wl3501_get_mib_value(this, WL3501_MIB_ATTR_FRAG_THRESHOLD,
1705 				      &threshold, sizeof(threshold));
1706 	if (!rc) {
1707 		wrqu->frag.value = threshold;
1708 		wrqu->frag.disabled = threshold >= 2346;
1709 		wrqu->frag.fixed = 1;
1710 	}
1711 	return rc;
1712 }
1713 
1714 static int wl3501_get_txpow(struct net_device *dev,
1715 			    struct iw_request_info *info,
1716 			    union iwreq_data *wrqu, char *extra)
1717 {
1718 	u16 txpow;
1719 	struct wl3501_card *this = netdev_priv(dev);
1720 	int rc = wl3501_get_mib_value(this,
1721 				      WL3501_MIB_ATTR_CURRENT_TX_PWR_LEVEL,
1722 				      &txpow, sizeof(txpow));
1723 	if (!rc) {
1724 		wrqu->txpower.value = txpow;
1725 		wrqu->txpower.disabled = 0;
1726 		/*
1727 		 * From the MIB values I think this can be configurable,
1728 		 * as it lists several tx power levels -acme
1729 		 */
1730 		wrqu->txpower.fixed = 0;
1731 		wrqu->txpower.flags = IW_TXPOW_MWATT;
1732 	}
1733 	return rc;
1734 }
1735 
1736 static int wl3501_get_retry(struct net_device *dev,
1737 			    struct iw_request_info *info,
1738 			    union iwreq_data *wrqu, char *extra)
1739 {
1740 	u8 retry; /* size checked: it is u8 */
1741 	struct wl3501_card *this = netdev_priv(dev);
1742 	int rc = wl3501_get_mib_value(this,
1743 				      WL3501_MIB_ATTR_LONG_RETRY_LIMIT,
1744 				      &retry, sizeof(retry));
1745 	if (rc)
1746 		goto out;
1747 	if (wrqu->retry.flags & IW_RETRY_LONG) {
1748 		wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_LONG;
1749 		goto set_value;
1750 	}
1751 	rc = wl3501_get_mib_value(this, WL3501_MIB_ATTR_SHORT_RETRY_LIMIT,
1752 				  &retry, sizeof(retry));
1753 	if (rc)
1754 		goto out;
1755 	wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_SHORT;
1756 set_value:
1757 	wrqu->retry.value = retry;
1758 	wrqu->retry.disabled = 0;
1759 out:
1760 	return rc;
1761 }
1762 
1763 static int wl3501_get_encode(struct net_device *dev,
1764 			     struct iw_request_info *info,
1765 			     union iwreq_data *wrqu, char *extra)
1766 {
1767 	u8 implemented, restricted, keys[100], len_keys, tocopy;
1768 	struct wl3501_card *this = netdev_priv(dev);
1769 	int rc = wl3501_get_mib_value(this,
1770 				      WL3501_MIB_ATTR_PRIV_OPT_IMPLEMENTED,
1771 				      &implemented, sizeof(implemented));
1772 	if (rc)
1773 		goto out;
1774 	if (!implemented) {
1775 		wrqu->encoding.flags = IW_ENCODE_DISABLED;
1776 		goto out;
1777 	}
1778 	rc = wl3501_get_mib_value(this, WL3501_MIB_ATTR_EXCLUDE_UNENCRYPTED,
1779 				  &restricted, sizeof(restricted));
1780 	if (rc)
1781 		goto out;
1782 	wrqu->encoding.flags = restricted ? IW_ENCODE_RESTRICTED :
1783 					    IW_ENCODE_OPEN;
1784 	rc = wl3501_get_mib_value(this, WL3501_MIB_ATTR_WEP_KEY_MAPPINGS_LEN,
1785 				  &len_keys, sizeof(len_keys));
1786 	if (rc)
1787 		goto out;
1788 	rc = wl3501_get_mib_value(this, WL3501_MIB_ATTR_WEP_KEY_MAPPINGS,
1789 				  keys, len_keys);
1790 	if (rc)
1791 		goto out;
1792 	tocopy = min_t(u16, len_keys, wrqu->encoding.length);
1793 	tocopy = min_t(u8, tocopy, 100);
1794 	wrqu->encoding.length = tocopy;
1795 	memcpy(extra, keys, tocopy);
1796 out:
1797 	return rc;
1798 }
1799 
1800 static int wl3501_get_power(struct net_device *dev,
1801 			    struct iw_request_info *info,
1802 			    union iwreq_data *wrqu, char *extra)
1803 {
1804 	u8 pwr_state;
1805 	struct wl3501_card *this = netdev_priv(dev);
1806 	int rc = wl3501_get_mib_value(this,
1807 				      WL3501_MIB_ATTR_CURRENT_PWR_STATE,
1808 				      &pwr_state, sizeof(pwr_state));
1809 	if (rc)
1810 		goto out;
1811 	wrqu->power.disabled = !pwr_state;
1812 	wrqu->power.flags = IW_POWER_ON;
1813 out:
1814 	return rc;
1815 }
1816 
1817 static const iw_handler	wl3501_handler[] = {
1818 	IW_HANDLER(SIOCGIWNAME, wl3501_get_name),
1819 	IW_HANDLER(SIOCSIWFREQ, wl3501_set_freq),
1820 	IW_HANDLER(SIOCGIWFREQ, wl3501_get_freq),
1821 	IW_HANDLER(SIOCSIWMODE, wl3501_set_mode),
1822 	IW_HANDLER(SIOCGIWMODE, wl3501_get_mode),
1823 	IW_HANDLER(SIOCGIWSENS, wl3501_get_sens),
1824 	IW_HANDLER(SIOCGIWRANGE, wl3501_get_range),
1825 	IW_HANDLER(SIOCSIWSPY, iw_handler_set_spy),
1826 	IW_HANDLER(SIOCGIWSPY, iw_handler_get_spy),
1827 	IW_HANDLER(SIOCSIWTHRSPY, iw_handler_set_thrspy),
1828 	IW_HANDLER(SIOCGIWTHRSPY, iw_handler_get_thrspy),
1829 	IW_HANDLER(SIOCSIWAP, wl3501_set_wap),
1830 	IW_HANDLER(SIOCGIWAP, wl3501_get_wap),
1831 	IW_HANDLER(SIOCSIWSCAN, wl3501_set_scan),
1832 	IW_HANDLER(SIOCGIWSCAN, wl3501_get_scan),
1833 	IW_HANDLER(SIOCSIWESSID, wl3501_set_essid),
1834 	IW_HANDLER(SIOCGIWESSID, wl3501_get_essid),
1835 	IW_HANDLER(SIOCSIWNICKN, wl3501_set_nick),
1836 	IW_HANDLER(SIOCGIWNICKN, wl3501_get_nick),
1837 	IW_HANDLER(SIOCGIWRATE, wl3501_get_rate),
1838 	IW_HANDLER(SIOCGIWRTS, wl3501_get_rts_threshold),
1839 	IW_HANDLER(SIOCGIWFRAG, wl3501_get_frag_threshold),
1840 	IW_HANDLER(SIOCGIWTXPOW, wl3501_get_txpow),
1841 	IW_HANDLER(SIOCGIWRETRY, wl3501_get_retry),
1842 	IW_HANDLER(SIOCGIWENCODE, wl3501_get_encode),
1843 	IW_HANDLER(SIOCGIWPOWER, wl3501_get_power),
1844 };
1845 
1846 static const struct iw_handler_def wl3501_handler_def = {
1847 	.num_standard	= ARRAY_SIZE(wl3501_handler),
1848 	.standard	= (iw_handler *)wl3501_handler,
1849 	.get_wireless_stats = wl3501_get_wireless_stats,
1850 };
1851 
1852 static const struct net_device_ops wl3501_netdev_ops = {
1853 	.ndo_open		= wl3501_open,
1854 	.ndo_stop		= wl3501_close,
1855 	.ndo_start_xmit		= wl3501_hard_start_xmit,
1856 	.ndo_tx_timeout		= wl3501_tx_timeout,
1857 	.ndo_set_mac_address 	= eth_mac_addr,
1858 	.ndo_validate_addr	= eth_validate_addr,
1859 };
1860 
1861 static int wl3501_probe(struct pcmcia_device *p_dev)
1862 {
1863 	struct net_device *dev;
1864 	struct wl3501_card *this;
1865 	int ret;
1866 
1867 	/* The io structure describes IO port mapping */
1868 	p_dev->resource[0]->end	= 16;
1869 	p_dev->resource[0]->flags	= IO_DATA_PATH_WIDTH_8;
1870 
1871 	/* General socket configuration */
1872 	p_dev->config_flags	= CONF_ENABLE_IRQ;
1873 	p_dev->config_index	= 1;
1874 
1875 	dev = alloc_etherdev(sizeof(struct wl3501_card));
1876 	if (!dev)
1877 		return -ENOMEM;
1878 
1879 	dev->netdev_ops		= &wl3501_netdev_ops;
1880 	dev->watchdog_timeo	= 5 * HZ;
1881 
1882 	this = netdev_priv(dev);
1883 	this->wireless_data.spy_data = &this->spy_data;
1884 	this->p_dev = p_dev;
1885 	dev->wireless_data	= &this->wireless_data;
1886 	dev->wireless_handlers	= &wl3501_handler_def;
1887 	netif_stop_queue(dev);
1888 	p_dev->priv = dev;
1889 
1890 	ret = wl3501_config(p_dev);
1891 	if (ret)
1892 		goto out_free_etherdev;
1893 
1894 	return 0;
1895 
1896 out_free_etherdev:
1897 	free_netdev(dev);
1898 	return ret;
1899 }
1900 
1901 static int wl3501_config(struct pcmcia_device *link)
1902 {
1903 	struct net_device *dev = link->priv;
1904 	int i = 0, j, ret;
1905 	struct wl3501_card *this;
1906 
1907 	/* Try allocating IO ports.  This tries a few fixed addresses.  If you
1908 	 * want, you can also read the card's config table to pick addresses --
1909 	 * see the serial driver for an example. */
1910 	link->io_lines = 5;
1911 
1912 	for (j = 0x280; j < 0x400; j += 0x20) {
1913 		/* The '^0x300' is so that we probe 0x300-0x3ff first, then
1914 		 * 0x200-0x2ff, and so on, because this seems safer */
1915 		link->resource[0]->start = j;
1916 		link->resource[1]->start = link->resource[0]->start + 0x10;
1917 		i = pcmcia_request_io(link);
1918 		if (i == 0)
1919 			break;
1920 	}
1921 	if (i != 0)
1922 		goto failed;
1923 
1924 	/* Now allocate an interrupt line. Note that this does not actually
1925 	 * assign a handler to the interrupt. */
1926 
1927 	ret = pcmcia_request_irq(link, wl3501_interrupt);
1928 	if (ret)
1929 		goto failed;
1930 
1931 	ret = pcmcia_enable_device(link);
1932 	if (ret)
1933 		goto failed;
1934 
1935 	dev->irq = link->irq;
1936 	dev->base_addr = link->resource[0]->start;
1937 	SET_NETDEV_DEV(dev, &link->dev);
1938 	if (register_netdev(dev)) {
1939 		printk(KERN_NOTICE "wl3501_cs: register_netdev() failed\n");
1940 		goto failed;
1941 	}
1942 
1943 	this = netdev_priv(dev);
1944 
1945 	this->base_addr = dev->base_addr;
1946 
1947 	if (!wl3501_get_flash_mac_addr(this)) {
1948 		printk(KERN_WARNING "%s: Can't read MAC addr in flash ROM?\n",
1949 		       dev->name);
1950 		unregister_netdev(dev);
1951 		goto failed;
1952 	}
1953 
1954 	eth_hw_addr_set(dev, this->mac_addr);
1955 
1956 	/* print probe information */
1957 	printk(KERN_INFO "%s: wl3501 @ 0x%3.3x, IRQ %d, "
1958 	       "MAC addr in flash ROM:%pM\n",
1959 	       dev->name, this->base_addr, (int)dev->irq,
1960 	       dev->dev_addr);
1961 	/*
1962 	 * Initialize card parameters - added by jss
1963 	 */
1964 	this->net_type		= IW_MODE_INFRA;
1965 	this->bss_cnt		= 0;
1966 	this->join_sta_bss	= 0;
1967 	this->adhoc_times	= 0;
1968 	iw_set_mgmt_info_element(IW_MGMT_INFO_ELEMENT_SSID, &this->essid.el,
1969 				 "ANY", 3);
1970 	this->card_name[0]	= '\0';
1971 	this->firmware_date[0]	= '\0';
1972 	this->rssi		= 255;
1973 	this->chan		= iw_default_channel(this->reg_domain);
1974 	strscpy(this->nick, "Planet WL3501", sizeof(this->nick));
1975 	spin_lock_init(&this->lock);
1976 	init_waitqueue_head(&this->wait);
1977 	netif_start_queue(dev);
1978 	return 0;
1979 
1980 failed:
1981 	wl3501_release(link);
1982 	return -ENODEV;
1983 }
1984 
1985 static void wl3501_release(struct pcmcia_device *link)
1986 {
1987 	pcmcia_disable_device(link);
1988 }
1989 
1990 static int wl3501_suspend(struct pcmcia_device *link)
1991 {
1992 	struct net_device *dev = link->priv;
1993 
1994 	wl3501_pwr_mgmt(netdev_priv(dev), WL3501_SUSPEND);
1995 	if (link->open)
1996 		netif_device_detach(dev);
1997 
1998 	return 0;
1999 }
2000 
2001 static int wl3501_resume(struct pcmcia_device *link)
2002 {
2003 	struct net_device *dev = link->priv;
2004 
2005 	wl3501_pwr_mgmt(netdev_priv(dev), WL3501_RESUME);
2006 	if (link->open) {
2007 		wl3501_reset(dev);
2008 		netif_device_attach(dev);
2009 	}
2010 
2011 	return 0;
2012 }
2013 
2014 
2015 static const struct pcmcia_device_id wl3501_ids[] = {
2016 	PCMCIA_DEVICE_MANF_CARD(0xd601, 0x0001),
2017 	PCMCIA_DEVICE_NULL
2018 };
2019 MODULE_DEVICE_TABLE(pcmcia, wl3501_ids);
2020 
2021 static struct pcmcia_driver wl3501_driver = {
2022 	.owner		= THIS_MODULE,
2023 	.name		= "wl3501_cs",
2024 	.probe		= wl3501_probe,
2025 	.remove		= wl3501_detach,
2026 	.id_table	= wl3501_ids,
2027 	.suspend	= wl3501_suspend,
2028 	.resume		= wl3501_resume,
2029 };
2030 module_pcmcia_driver(wl3501_driver);
2031 
2032 MODULE_AUTHOR("Fox Chen <mhchen@golf.ccl.itri.org.tw>, "
2033 	      "Arnaldo Carvalho de Melo <acme@conectiva.com.br>,"
2034 	      "Gustavo Niemeyer <niemeyer@conectiva.com>");
2035 MODULE_DESCRIPTION("Planet wl3501 wireless driver");
2036 MODULE_LICENSE("GPL");
2037