2 * Host AP (software wireless LAN access point) driver for
3 * Intersil Prism2/2.5/3.
5 * Copyright (c) 2001-2002, SSH Communications Security Corp and Jouni Malinen
7 * Copyright (c) 2002-2005, Jouni Malinen <j@w1.fi>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation. See README and COPYING for
15 * - there is currently no way of associating TX packets to correct wds device
16 * when TX Exc/OK event occurs, so all tx_packets and some
17 * tx_errors/tx_dropped are added to the main netdevice; using sw_support
18 * field in txdesc might be used to fix this (using Alloc event to increment
19 * tx_packets would need some further info in txfid table)
21 * Buffer Access Path (BAP) usage:
22 * Prism2 cards have two separate BAPs for accessing the card memory. These
23 * should allow concurrent access to two different frames and the driver
24 * previously used BAP0 for sending data and BAP1 for receiving data.
25 * However, there seems to be number of issues with concurrent access and at
26 * least one know hardware bug in using BAP0 and BAP1 concurrently with PCI
27 * Prism2.5. Therefore, the driver now only uses BAP0 for moving data between
28 * host and card memories. BAP0 accesses are protected with local->baplock
29 * (spin_lock_bh) to prevent concurrent use.
34 #include <asm/delay.h>
35 #include <asm/uaccess.h>
37 #include <linux/slab.h>
38 #include <linux/netdevice.h>
39 #include <linux/etherdevice.h>
40 #include <linux/proc_fs.h>
41 #include <linux/if_arp.h>
42 #include <linux/delay.h>
43 #include <linux/random.h>
44 #include <linux/wait.h>
45 #include <linux/sched.h>
46 #include <linux/rtnetlink.h>
47 #include <linux/wireless.h>
48 #include <net/iw_handler.h>
49 #include <net/lib80211.h>
52 #include "hostap_80211.h"
54 #include "hostap_ap.h"
57 /* #define final_version */
59 static int mtu
= 1500;
60 module_param(mtu
, int, 0444);
61 MODULE_PARM_DESC(mtu
, "Maximum transfer unit");
63 static int channel
[MAX_PARM_DEVICES
] = { 3, DEF_INTS
};
64 module_param_array(channel
, int, NULL
, 0444);
65 MODULE_PARM_DESC(channel
, "Initial channel");
67 static char essid
[33] = "test";
68 module_param_string(essid
, essid
, sizeof(essid
), 0444);
69 MODULE_PARM_DESC(essid
, "Host AP's ESSID");
71 static int iw_mode
[MAX_PARM_DEVICES
] = { IW_MODE_MASTER
, DEF_INTS
};
72 module_param_array(iw_mode
, int, NULL
, 0444);
73 MODULE_PARM_DESC(iw_mode
, "Initial operation mode");
75 static int beacon_int
[MAX_PARM_DEVICES
] = { 100, DEF_INTS
};
76 module_param_array(beacon_int
, int, NULL
, 0444);
77 MODULE_PARM_DESC(beacon_int
, "Beacon interval (1 = 1024 usec)");
79 static int dtim_period
[MAX_PARM_DEVICES
] = { 1, DEF_INTS
};
80 module_param_array(dtim_period
, int, NULL
, 0444);
81 MODULE_PARM_DESC(dtim_period
, "DTIM period");
83 static char dev_template
[16] = "wlan%d";
84 module_param_string(dev_template
, dev_template
, sizeof(dev_template
), 0444);
85 MODULE_PARM_DESC(dev_template
, "Prefix for network device name (default: "
89 #define EXTRA_EVENTS_WTERR 0
91 /* check WTERR events (Wait Time-out) in development versions */
92 #define EXTRA_EVENTS_WTERR HFA384X_EV_WTERR
95 /* Events that will be using BAP0 */
96 #define HFA384X_BAP0_EVENTS \
97 (HFA384X_EV_TXEXC | HFA384X_EV_RX | HFA384X_EV_INFO | HFA384X_EV_TX)
99 /* event mask, i.e., events that will result in an interrupt */
100 #define HFA384X_EVENT_MASK \
101 (HFA384X_BAP0_EVENTS | HFA384X_EV_ALLOC | HFA384X_EV_INFDROP | \
102 HFA384X_EV_CMD | HFA384X_EV_TICK | \
105 /* Default TX control flags: use 802.11 headers and request interrupt for
106 * failed transmits. Frames that request ACK callback, will add
107 * _TX_OK flag and _ALT_RTRY flag may be used to select different retry policy.
109 #define HFA384X_TX_CTRL_FLAGS \
110 (HFA384X_TX_CTRL_802_11 | HFA384X_TX_CTRL_TX_EX)
114 #define HFA384X_CMD_BUSY_TIMEOUT 5000
115 #define HFA384X_BAP_BUSY_TIMEOUT 50000
118 #define HFA384X_CMD_COMPL_TIMEOUT 20000
119 #define HFA384X_DL_COMPL_TIMEOUT 1000000
121 /* Wait times for initialization; yield to other processes to avoid busy
122 * waiting for long time. */
123 #define HFA384X_INIT_TIMEOUT (HZ / 2) /* 500 ms */
124 #define HFA384X_ALLOC_COMPL_TIMEOUT (HZ / 20) /* 50 ms */
127 static void prism2_hw_reset(struct net_device
*dev
);
128 static void prism2_check_sta_fw_version(local_info_t
*local
);
130 #ifdef PRISM2_DOWNLOAD_SUPPORT
131 /* hostap_download.c */
132 static int prism2_download_aux_dump(struct net_device
*dev
,
133 unsigned int addr
, int len
, u8
*buf
);
134 static u8
* prism2_read_pda(struct net_device
*dev
);
135 static int prism2_download(local_info_t
*local
,
136 struct prism2_download_param
*param
);
137 static void prism2_download_free_data(struct prism2_download_data
*dl
);
138 static int prism2_download_volatile(local_info_t
*local
,
139 struct prism2_download_data
*param
);
140 static int prism2_download_genesis(local_info_t
*local
,
141 struct prism2_download_data
*param
);
142 static int prism2_get_ram_size(local_info_t
*local
);
143 #endif /* PRISM2_DOWNLOAD_SUPPORT */
148 #ifndef final_version
149 /* magic value written to SWSUPPORT0 reg. for detecting whether card is still
151 #define HFA384X_MAGIC 0x8A32
155 static u16
hfa384x_read_reg(struct net_device
*dev
, u16 reg
)
157 return HFA384X_INW(reg
);
161 static void hfa384x_read_regs(struct net_device
*dev
,
162 struct hfa384x_regs
*regs
)
164 regs
->cmd
= HFA384X_INW(HFA384X_CMD_OFF
);
165 regs
->evstat
= HFA384X_INW(HFA384X_EVSTAT_OFF
);
166 regs
->offset0
= HFA384X_INW(HFA384X_OFFSET0_OFF
);
167 regs
->offset1
= HFA384X_INW(HFA384X_OFFSET1_OFF
);
168 regs
->swsupport0
= HFA384X_INW(HFA384X_SWSUPPORT0_OFF
);
173 * __hostap_cmd_queue_free - Free Prism2 command queue entry (private)
174 * @local: pointer to private Host AP driver data
175 * @entry: Prism2 command queue entry to be freed
176 * @del_req: request the entry to be removed
178 * Internal helper function for freeing Prism2 command queue entries.
179 * Caller must have acquired local->cmdlock before calling this function.
181 static inline void __hostap_cmd_queue_free(local_info_t
*local
,
182 struct hostap_cmd_queue
*entry
,
187 if (!list_empty(&entry
->list
)) {
188 list_del_init(&entry
->list
);
189 local
->cmd_queue_len
--;
193 if (atomic_dec_and_test(&entry
->usecnt
) && entry
->del_req
)
199 * hostap_cmd_queue_free - Free Prism2 command queue entry
200 * @local: pointer to private Host AP driver data
201 * @entry: Prism2 command queue entry to be freed
202 * @del_req: request the entry to be removed
204 * Free a Prism2 command queue entry.
206 static inline void hostap_cmd_queue_free(local_info_t
*local
,
207 struct hostap_cmd_queue
*entry
,
212 spin_lock_irqsave(&local
->cmdlock
, flags
);
213 __hostap_cmd_queue_free(local
, entry
, del_req
);
214 spin_unlock_irqrestore(&local
->cmdlock
, flags
);
219 * prism2_clear_cmd_queue - Free all pending Prism2 command queue entries
220 * @local: pointer to private Host AP driver data
222 static void prism2_clear_cmd_queue(local_info_t
*local
)
224 struct list_head
*ptr
, *n
;
226 struct hostap_cmd_queue
*entry
;
228 spin_lock_irqsave(&local
->cmdlock
, flags
);
229 list_for_each_safe(ptr
, n
, &local
->cmd_queue
) {
230 entry
= list_entry(ptr
, struct hostap_cmd_queue
, list
);
231 atomic_inc(&entry
->usecnt
);
232 printk(KERN_DEBUG
"%s: removed pending cmd_queue entry "
233 "(type=%d, cmd=0x%04x, param0=0x%04x)\n",
234 local
->dev
->name
, entry
->type
, entry
->cmd
,
236 __hostap_cmd_queue_free(local
, entry
, 1);
238 if (local
->cmd_queue_len
) {
239 /* This should not happen; print debug message and clear
241 printk(KERN_DEBUG
"%s: cmd_queue_len (%d) not zero after "
242 "flush\n", local
->dev
->name
, local
->cmd_queue_len
);
243 local
->cmd_queue_len
= 0;
245 spin_unlock_irqrestore(&local
->cmdlock
, flags
);
250 * hfa384x_cmd_issue - Issue a Prism2 command to the hardware
251 * @dev: pointer to net_device
252 * @entry: Prism2 command queue entry to be issued
254 static int hfa384x_cmd_issue(struct net_device
*dev
,
255 struct hostap_cmd_queue
*entry
)
257 struct hostap_interface
*iface
;
263 iface
= netdev_priv(dev
);
264 local
= iface
->local
;
266 if (local
->func
->card_present
&& !local
->func
->card_present(local
))
270 printk(KERN_DEBUG
"%s: driver bug - re-issuing command @%p\n",
274 /* wait until busy bit is clear; this should always be clear since the
275 * commands are serialized */
276 tries
= HFA384X_CMD_BUSY_TIMEOUT
;
277 while (HFA384X_INW(HFA384X_CMD_OFF
) & HFA384X_CMD_BUSY
&& tries
> 0) {
281 #ifndef final_version
282 if (tries
!= HFA384X_CMD_BUSY_TIMEOUT
) {
283 prism2_io_debug_error(dev
, 1);
284 printk(KERN_DEBUG
"%s: hfa384x_cmd_issue: cmd reg was busy "
285 "for %d usec\n", dev
->name
,
286 HFA384X_CMD_BUSY_TIMEOUT
- tries
);
290 reg
= HFA384X_INW(HFA384X_CMD_OFF
);
291 prism2_io_debug_error(dev
, 2);
292 printk(KERN_DEBUG
"%s: hfa384x_cmd_issue - timeout - "
293 "reg=0x%04x\n", dev
->name
, reg
);
298 spin_lock_irqsave(&local
->cmdlock
, flags
);
299 HFA384X_OUTW(entry
->param0
, HFA384X_PARAM0_OFF
);
300 HFA384X_OUTW(entry
->param1
, HFA384X_PARAM1_OFF
);
301 HFA384X_OUTW(entry
->cmd
, HFA384X_CMD_OFF
);
303 spin_unlock_irqrestore(&local
->cmdlock
, flags
);
310 * hfa384x_cmd - Issue a Prism2 command and wait (sleep) for completion
311 * @dev: pointer to net_device
312 * @cmd: Prism2 command code (HFA384X_CMD_CODE_*)
313 * @param0: value for Param0 register
314 * @param1: value for Param1 register (pointer; %NULL if not used)
315 * @resp0: pointer for Resp0 data or %NULL if Resp0 is not needed
317 * Issue given command (possibly after waiting in command queue) and sleep
318 * until the command is completed (or timed out or interrupted). This can be
319 * called only from user process context.
321 static int hfa384x_cmd(struct net_device
*dev
, u16 cmd
, u16 param0
,
322 u16
*param1
, u16
*resp0
)
324 struct hostap_interface
*iface
;
326 int err
, res
, issue
, issued
= 0;
328 struct hostap_cmd_queue
*entry
;
329 DECLARE_WAITQUEUE(wait
, current
);
331 iface
= netdev_priv(dev
);
332 local
= iface
->local
;
334 if (in_interrupt()) {
335 printk(KERN_DEBUG
"%s: hfa384x_cmd called from interrupt "
336 "context\n", dev
->name
);
340 if (local
->cmd_queue_len
>= HOSTAP_CMD_QUEUE_MAX_LEN
) {
341 printk(KERN_DEBUG
"%s: hfa384x_cmd: cmd_queue full\n",
346 if (signal_pending(current
))
349 entry
= kzalloc(sizeof(*entry
), GFP_ATOMIC
);
351 printk(KERN_DEBUG
"%s: hfa384x_cmd - kmalloc failed\n",
355 atomic_set(&entry
->usecnt
, 1);
356 entry
->type
= CMD_SLEEP
;
358 entry
->param0
= param0
;
360 entry
->param1
= *param1
;
361 init_waitqueue_head(&entry
->compl);
363 /* prepare to wait for command completion event, but do not sleep yet
365 add_wait_queue(&entry
->compl, &wait
);
366 set_current_state(TASK_INTERRUPTIBLE
);
368 spin_lock_irqsave(&local
->cmdlock
, flags
);
369 issue
= list_empty(&local
->cmd_queue
);
372 list_add_tail(&entry
->list
, &local
->cmd_queue
);
373 local
->cmd_queue_len
++;
374 spin_unlock_irqrestore(&local
->cmdlock
, flags
);
378 goto wait_completion
;
380 if (signal_pending(current
))
384 if (hfa384x_cmd_issue(dev
, entry
))
391 if (!err
&& entry
->type
!= CMD_COMPLETED
) {
392 /* sleep until command is completed or timed out */
393 res
= schedule_timeout(2 * HZ
);
397 if (!err
&& signal_pending(current
))
401 /* the command was issued, so a CmdCompl event should occur
402 * soon; however, there's a pending signal and
403 * schedule_timeout() would be interrupted; wait a short period
404 * of time to avoid removing entry from the list before
409 set_current_state(TASK_RUNNING
);
410 remove_wait_queue(&entry
->compl, &wait
);
412 /* If entry->list is still in the list, it must be removed
413 * first and in this case prism2_cmd_ev() does not yet have
414 * local reference to it, and the data can be kfree()'d
415 * here. If the command completion event is still generated,
416 * it will be assigned to next (possibly) pending command, but
417 * the driver will reset the card anyway due to timeout
419 * If the entry is not in the list prism2_cmd_ev() has a local
420 * reference to it, but keeps cmdlock as long as the data is
421 * needed, so the data can be kfree()'d here. */
423 /* FIX: if the entry->list is in the list, it has not been completed
424 * yet, so removing it here is somewhat wrong.. this could cause
425 * references to freed memory and next list_del() causing NULL pointer
426 * dereference.. it would probably be better to leave the entry in the
427 * list and the list should be emptied during hw reset */
429 spin_lock_irqsave(&local
->cmdlock
, flags
);
430 if (!list_empty(&entry
->list
)) {
431 printk(KERN_DEBUG
"%s: hfa384x_cmd: entry still in list? "
432 "(entry=%p, type=%d, res=%d)\n", dev
->name
, entry
,
434 list_del_init(&entry
->list
);
435 local
->cmd_queue_len
--;
437 spin_unlock_irqrestore(&local
->cmdlock
, flags
);
440 printk(KERN_DEBUG
"%s: hfa384x_cmd: interrupted; err=%d\n",
446 if (entry
->type
!= CMD_COMPLETED
) {
447 u16 reg
= HFA384X_INW(HFA384X_EVSTAT_OFF
);
448 printk(KERN_DEBUG
"%s: hfa384x_cmd: command was not "
449 "completed (res=%d, entry=%p, type=%d, cmd=0x%04x, "
450 "param0=0x%04x, EVSTAT=%04x INTEN=%04x)\n", dev
->name
,
451 res
, entry
, entry
->type
, entry
->cmd
, entry
->param0
, reg
,
452 HFA384X_INW(HFA384X_INTEN_OFF
));
453 if (reg
& HFA384X_EV_CMD
) {
454 /* Command completion event is pending, but the
455 * interrupt was not delivered - probably an issue
456 * with pcmcia-cs configuration. */
457 printk(KERN_WARNING
"%s: interrupt delivery does not "
458 "seem to work\n", dev
->name
);
460 prism2_io_debug_error(dev
, 3);
466 *resp0
= entry
->resp0
;
467 #ifndef final_version
469 printk(KERN_DEBUG
"%s: CMD=0x%04x => res=0x%02x, "
471 dev
->name
, cmd
, entry
->res
, entry
->resp0
);
473 #endif /* final_version */
477 hostap_cmd_queue_free(local
, entry
, 1);
483 * hfa384x_cmd_callback - Issue a Prism2 command; callback when completed
484 * @dev: pointer to net_device
485 * @cmd: Prism2 command code (HFA384X_CMD_CODE_*)
486 * @param0: value for Param0 register
487 * @callback: command completion callback function (%NULL = no callback)
488 * @context: context data to be given to the callback function
490 * Issue given command (possibly after waiting in command queue) and use
491 * callback function to indicate command completion. This can be called both
492 * from user and interrupt context. The callback function will be called in
493 * hardware IRQ context. It can be %NULL, when no function is called when
494 * command is completed.
496 static int hfa384x_cmd_callback(struct net_device
*dev
, u16 cmd
, u16 param0
,
497 void (*callback
)(struct net_device
*dev
,
498 long context
, u16 resp0
,
502 struct hostap_interface
*iface
;
506 struct hostap_cmd_queue
*entry
;
508 iface
= netdev_priv(dev
);
509 local
= iface
->local
;
511 if (local
->cmd_queue_len
>= HOSTAP_CMD_QUEUE_MAX_LEN
+ 2) {
512 printk(KERN_DEBUG
"%s: hfa384x_cmd: cmd_queue full\n",
517 entry
= kzalloc(sizeof(*entry
), GFP_ATOMIC
);
519 printk(KERN_DEBUG
"%s: hfa384x_cmd_callback - kmalloc "
520 "failed\n", dev
->name
);
523 atomic_set(&entry
->usecnt
, 1);
524 entry
->type
= CMD_CALLBACK
;
526 entry
->param0
= param0
;
527 entry
->callback
= callback
;
528 entry
->context
= context
;
530 spin_lock_irqsave(&local
->cmdlock
, flags
);
531 issue
= list_empty(&local
->cmd_queue
);
534 list_add_tail(&entry
->list
, &local
->cmd_queue
);
535 local
->cmd_queue_len
++;
536 spin_unlock_irqrestore(&local
->cmdlock
, flags
);
538 if (issue
&& hfa384x_cmd_issue(dev
, entry
))
543 hostap_cmd_queue_free(local
, entry
, ret
);
550 * __hfa384x_cmd_no_wait - Issue a Prism2 command (private)
551 * @dev: pointer to net_device
552 * @cmd: Prism2 command code (HFA384X_CMD_CODE_*)
553 * @param0: value for Param0 register
554 * @io_debug_num: I/O debug error number
556 * Shared helper function for hfa384x_cmd_wait() and hfa384x_cmd_no_wait().
558 static int __hfa384x_cmd_no_wait(struct net_device
*dev
, u16 cmd
, u16 param0
,
564 /* wait until busy bit is clear; this should always be clear since the
565 * commands are serialized */
566 tries
= HFA384X_CMD_BUSY_TIMEOUT
;
567 while (HFA384X_INW(HFA384X_CMD_OFF
) & HFA384X_CMD_BUSY
&& tries
> 0) {
572 reg
= HFA384X_INW(HFA384X_CMD_OFF
);
573 prism2_io_debug_error(dev
, io_debug_num
);
574 printk(KERN_DEBUG
"%s: __hfa384x_cmd_no_wait(%d) - timeout - "
575 "reg=0x%04x\n", dev
->name
, io_debug_num
, reg
);
580 HFA384X_OUTW(param0
, HFA384X_PARAM0_OFF
);
581 HFA384X_OUTW(cmd
, HFA384X_CMD_OFF
);
588 * hfa384x_cmd_wait - Issue a Prism2 command and busy wait for completion
589 * @dev: pointer to net_device
590 * @cmd: Prism2 command code (HFA384X_CMD_CODE_*)
591 * @param0: value for Param0 register
593 static int hfa384x_cmd_wait(struct net_device
*dev
, u16 cmd
, u16 param0
)
598 res
= __hfa384x_cmd_no_wait(dev
, cmd
, param0
, 4);
602 /* wait for command completion */
603 if ((cmd
& HFA384X_CMDCODE_MASK
) == HFA384X_CMDCODE_DOWNLOAD
)
604 tries
= HFA384X_DL_COMPL_TIMEOUT
;
606 tries
= HFA384X_CMD_COMPL_TIMEOUT
;
608 while (!(HFA384X_INW(HFA384X_EVSTAT_OFF
) & HFA384X_EV_CMD
) &&
614 reg
= HFA384X_INW(HFA384X_EVSTAT_OFF
);
615 prism2_io_debug_error(dev
, 5);
616 printk(KERN_DEBUG
"%s: hfa384x_cmd_wait - timeout2 - "
617 "reg=0x%04x\n", dev
->name
, reg
);
621 res
= (HFA384X_INW(HFA384X_STATUS_OFF
) &
622 (BIT(14) | BIT(13) | BIT(12) | BIT(11) | BIT(10) | BIT(9) |
624 #ifndef final_version
626 printk(KERN_DEBUG
"%s: CMD=0x%04x => res=0x%02x\n",
627 dev
->name
, cmd
, res
);
631 HFA384X_OUTW(HFA384X_EV_CMD
, HFA384X_EVACK_OFF
);
638 * hfa384x_cmd_no_wait - Issue a Prism2 command; do not wait for completion
639 * @dev: pointer to net_device
640 * @cmd: Prism2 command code (HFA384X_CMD_CODE_*)
641 * @param0: value for Param0 register
643 static inline int hfa384x_cmd_no_wait(struct net_device
*dev
, u16 cmd
,
646 return __hfa384x_cmd_no_wait(dev
, cmd
, param0
, 6);
651 * prism2_cmd_ev - Prism2 command completion event handler
652 * @dev: pointer to net_device
654 * Interrupt handler for command completion events. Called by the main
655 * interrupt handler in hardware IRQ context. Read Resp0 and status registers
656 * from the hardware and ACK the event. Depending on the issued command type
657 * either wake up the sleeping process that is waiting for command completion
658 * or call the callback function. Issue the next command, if one is pending.
660 static void prism2_cmd_ev(struct net_device
*dev
)
662 struct hostap_interface
*iface
;
664 struct hostap_cmd_queue
*entry
= NULL
;
666 iface
= netdev_priv(dev
);
667 local
= iface
->local
;
669 spin_lock(&local
->cmdlock
);
670 if (!list_empty(&local
->cmd_queue
)) {
671 entry
= list_entry(local
->cmd_queue
.next
,
672 struct hostap_cmd_queue
, list
);
673 atomic_inc(&entry
->usecnt
);
674 list_del_init(&entry
->list
);
675 local
->cmd_queue_len
--;
677 if (!entry
->issued
) {
678 printk(KERN_DEBUG
"%s: Command completion event, but "
679 "cmd not issued\n", dev
->name
);
680 __hostap_cmd_queue_free(local
, entry
, 1);
684 spin_unlock(&local
->cmdlock
);
687 HFA384X_OUTW(HFA384X_EV_CMD
, HFA384X_EVACK_OFF
);
688 printk(KERN_DEBUG
"%s: Command completion event, but no "
689 "pending commands\n", dev
->name
);
693 entry
->resp0
= HFA384X_INW(HFA384X_RESP0_OFF
);
694 entry
->res
= (HFA384X_INW(HFA384X_STATUS_OFF
) &
695 (BIT(14) | BIT(13) | BIT(12) | BIT(11) | BIT(10) |
696 BIT(9) | BIT(8))) >> 8;
697 HFA384X_OUTW(HFA384X_EV_CMD
, HFA384X_EVACK_OFF
);
699 /* TODO: rest of the CmdEv handling could be moved to tasklet */
700 if (entry
->type
== CMD_SLEEP
) {
701 entry
->type
= CMD_COMPLETED
;
702 wake_up_interruptible(&entry
->compl);
703 } else if (entry
->type
== CMD_CALLBACK
) {
705 entry
->callback(dev
, entry
->context
, entry
->resp0
,
708 printk(KERN_DEBUG
"%s: Invalid command completion type %d\n",
709 dev
->name
, entry
->type
);
711 hostap_cmd_queue_free(local
, entry
, 1);
713 /* issue next command, if pending */
715 spin_lock(&local
->cmdlock
);
716 if (!list_empty(&local
->cmd_queue
)) {
717 entry
= list_entry(local
->cmd_queue
.next
,
718 struct hostap_cmd_queue
, list
);
719 if (entry
->issuing
) {
720 /* hfa384x_cmd() has already started issuing this
721 * command, so do not start here */
725 atomic_inc(&entry
->usecnt
);
727 spin_unlock(&local
->cmdlock
);
730 /* issue next command; if command issuing fails, remove the
731 * entry from cmd_queue */
732 int res
= hfa384x_cmd_issue(dev
, entry
);
733 spin_lock(&local
->cmdlock
);
734 __hostap_cmd_queue_free(local
, entry
, res
);
735 spin_unlock(&local
->cmdlock
);
740 static int hfa384x_wait_offset(struct net_device
*dev
, u16 o_off
)
742 int tries
= HFA384X_BAP_BUSY_TIMEOUT
;
743 int res
= HFA384X_INW(o_off
) & HFA384X_OFFSET_BUSY
;
745 while (res
&& tries
> 0) {
748 res
= HFA384X_INW(o_off
) & HFA384X_OFFSET_BUSY
;
754 /* Offset must be even */
755 static int hfa384x_setup_bap(struct net_device
*dev
, u16 bap
, u16 id
,
761 if (offset
% 2 || bap
> 1)
765 o_off
= HFA384X_OFFSET1_OFF
;
766 s_off
= HFA384X_SELECT1_OFF
;
768 o_off
= HFA384X_OFFSET0_OFF
;
769 s_off
= HFA384X_SELECT0_OFF
;
772 if (hfa384x_wait_offset(dev
, o_off
)) {
773 prism2_io_debug_error(dev
, 7);
774 printk(KERN_DEBUG
"%s: hfa384x_setup_bap - timeout before\n",
780 HFA384X_OUTW(id
, s_off
);
781 HFA384X_OUTW(offset
, o_off
);
783 if (hfa384x_wait_offset(dev
, o_off
)) {
784 prism2_io_debug_error(dev
, 8);
785 printk(KERN_DEBUG
"%s: hfa384x_setup_bap - timeout after\n",
790 #ifndef final_version
791 if (HFA384X_INW(o_off
) & HFA384X_OFFSET_ERR
) {
792 prism2_io_debug_error(dev
, 9);
793 printk(KERN_DEBUG
"%s: hfa384x_setup_bap - offset error "
794 "(%d,0x04%x,%d); reg=0x%04x\n",
795 dev
->name
, bap
, id
, offset
, HFA384X_INW(o_off
));
805 static int hfa384x_get_rid(struct net_device
*dev
, u16 rid
, void *buf
, int len
,
808 struct hostap_interface
*iface
;
811 struct hfa384x_rid_hdr rec
;
813 iface
= netdev_priv(dev
);
814 local
= iface
->local
;
817 printk(KERN_DEBUG
"%s: cannot get RID %04x (len=%d) - no PRI "
818 "f/w\n", dev
->name
, rid
, len
);
819 return -ENOTTY
; /* Well.. not really correct, but return
820 * something unique enough.. */
823 if ((local
->func
->card_present
&& !local
->func
->card_present(local
)) ||
824 local
->hw_downloading
)
827 res
= mutex_lock_interruptible(&local
->rid_bap_mtx
);
831 res
= hfa384x_cmd(dev
, HFA384X_CMDCODE_ACCESS
, rid
, NULL
, NULL
);
833 printk(KERN_DEBUG
"%s: hfa384x_get_rid: CMDCODE_ACCESS failed "
834 "(res=%d, rid=%04x, len=%d)\n",
835 dev
->name
, res
, rid
, len
);
836 mutex_unlock(&local
->rid_bap_mtx
);
840 spin_lock_bh(&local
->baplock
);
842 res
= hfa384x_setup_bap(dev
, BAP0
, rid
, 0);
844 res
= hfa384x_from_bap(dev
, BAP0
, &rec
, sizeof(rec
));
846 if (le16_to_cpu(rec
.len
) == 0) {
847 /* RID not available */
851 rlen
= (le16_to_cpu(rec
.len
) - 1) * 2;
852 if (!res
&& exact_len
&& rlen
!= len
) {
853 printk(KERN_DEBUG
"%s: hfa384x_get_rid - RID len mismatch: "
854 "rid=0x%04x, len=%d (expected %d)\n",
855 dev
->name
, rid
, rlen
, len
);
860 res
= hfa384x_from_bap(dev
, BAP0
, buf
, len
);
862 spin_unlock_bh(&local
->baplock
);
863 mutex_unlock(&local
->rid_bap_mtx
);
867 printk(KERN_DEBUG
"%s: hfa384x_get_rid (rid=%04x, "
868 "len=%d) - failed - res=%d\n", dev
->name
, rid
,
870 if (res
== -ETIMEDOUT
)
871 prism2_hw_reset(dev
);
879 static int hfa384x_set_rid(struct net_device
*dev
, u16 rid
, void *buf
, int len
)
881 struct hostap_interface
*iface
;
883 struct hfa384x_rid_hdr rec
;
886 iface
= netdev_priv(dev
);
887 local
= iface
->local
;
890 printk(KERN_DEBUG
"%s: cannot set RID %04x (len=%d) - no PRI "
891 "f/w\n", dev
->name
, rid
, len
);
892 return -ENOTTY
; /* Well.. not really correct, but return
893 * something unique enough.. */
896 if ((local
->func
->card_present
&& !local
->func
->card_present(local
)) ||
897 local
->hw_downloading
)
900 rec
.rid
= cpu_to_le16(rid
);
901 /* RID len in words and +1 for rec.rid */
902 rec
.len
= cpu_to_le16(len
/ 2 + len
% 2 + 1);
904 res
= mutex_lock_interruptible(&local
->rid_bap_mtx
);
908 spin_lock_bh(&local
->baplock
);
909 res
= hfa384x_setup_bap(dev
, BAP0
, rid
, 0);
911 res
= hfa384x_to_bap(dev
, BAP0
, &rec
, sizeof(rec
));
913 res
= hfa384x_to_bap(dev
, BAP0
, buf
, len
);
914 spin_unlock_bh(&local
->baplock
);
917 printk(KERN_DEBUG
"%s: hfa384x_set_rid (rid=%04x, len=%d) - "
918 "failed - res=%d\n", dev
->name
, rid
, len
, res
);
919 mutex_unlock(&local
->rid_bap_mtx
);
923 res
= hfa384x_cmd(dev
, HFA384X_CMDCODE_ACCESS_WRITE
, rid
, NULL
, NULL
);
924 mutex_unlock(&local
->rid_bap_mtx
);
927 printk(KERN_DEBUG
"%s: hfa384x_set_rid: CMDCODE_ACCESS_WRITE "
928 "failed (res=%d, rid=%04x, len=%d)\n",
929 dev
->name
, res
, rid
, len
);
931 if (res
== -ETIMEDOUT
)
932 prism2_hw_reset(dev
);
939 static void hfa384x_disable_interrupts(struct net_device
*dev
)
941 /* disable interrupts and clear event status */
942 HFA384X_OUTW(0, HFA384X_INTEN_OFF
);
943 HFA384X_OUTW(0xffff, HFA384X_EVACK_OFF
);
947 static void hfa384x_enable_interrupts(struct net_device
*dev
)
949 /* ack pending events and enable interrupts from selected events */
950 HFA384X_OUTW(0xffff, HFA384X_EVACK_OFF
);
951 HFA384X_OUTW(HFA384X_EVENT_MASK
, HFA384X_INTEN_OFF
);
955 static void hfa384x_events_no_bap0(struct net_device
*dev
)
957 HFA384X_OUTW(HFA384X_EVENT_MASK
& ~HFA384X_BAP0_EVENTS
,
962 static void hfa384x_events_all(struct net_device
*dev
)
964 HFA384X_OUTW(HFA384X_EVENT_MASK
, HFA384X_INTEN_OFF
);
968 static void hfa384x_events_only_cmd(struct net_device
*dev
)
970 HFA384X_OUTW(HFA384X_EV_CMD
, HFA384X_INTEN_OFF
);
974 static u16
hfa384x_allocate_fid(struct net_device
*dev
, int len
)
979 /* FIX: this could be replace with hfa384x_cmd() if the Alloc event
980 * below would be handled like CmdCompl event (sleep here, wake up from
981 * interrupt handler */
982 if (hfa384x_cmd_wait(dev
, HFA384X_CMDCODE_ALLOC
, len
)) {
983 printk(KERN_DEBUG
"%s: cannot allocate fid, len=%d\n",
988 delay
= jiffies
+ HFA384X_ALLOC_COMPL_TIMEOUT
;
989 while (!(HFA384X_INW(HFA384X_EVSTAT_OFF
) & HFA384X_EV_ALLOC
) &&
990 time_before(jiffies
, delay
))
992 if (!(HFA384X_INW(HFA384X_EVSTAT_OFF
) & HFA384X_EV_ALLOC
)) {
993 printk("%s: fid allocate, len=%d - timeout\n", dev
->name
, len
);
997 fid
= HFA384X_INW(HFA384X_ALLOCFID_OFF
);
998 HFA384X_OUTW(HFA384X_EV_ALLOC
, HFA384X_EVACK_OFF
);
1004 static int prism2_reset_port(struct net_device
*dev
)
1006 struct hostap_interface
*iface
;
1007 local_info_t
*local
;
1010 iface
= netdev_priv(dev
);
1011 local
= iface
->local
;
1013 if (!local
->dev_enabled
)
1016 res
= hfa384x_cmd(dev
, HFA384X_CMDCODE_DISABLE
, 0,
1019 printk(KERN_DEBUG
"%s: reset port failed to disable port\n",
1022 res
= hfa384x_cmd(dev
, HFA384X_CMDCODE_ENABLE
, 0,
1025 printk(KERN_DEBUG
"%s: reset port failed to enable "
1026 "port\n", dev
->name
);
1029 /* It looks like at least some STA firmware versions reset
1030 * fragmentation threshold back to 2346 after enable command. Restore
1031 * the configured value, if it differs from this default. */
1032 if (local
->fragm_threshold
!= 2346 &&
1033 hostap_set_word(dev
, HFA384X_RID_FRAGMENTATIONTHRESHOLD
,
1034 local
->fragm_threshold
)) {
1035 printk(KERN_DEBUG
"%s: failed to restore fragmentation "
1036 "threshold (%d) after Port0 enable\n",
1037 dev
->name
, local
->fragm_threshold
);
1040 /* Some firmwares lose antenna selection settings on reset */
1041 (void) hostap_set_antsel(local
);
1047 static int prism2_get_version_info(struct net_device
*dev
, u16 rid
,
1050 struct hfa384x_comp_ident comp
;
1051 struct hostap_interface
*iface
;
1052 local_info_t
*local
;
1054 iface
= netdev_priv(dev
);
1055 local
= iface
->local
;
1057 if (local
->no_pri
) {
1058 /* PRI f/w not yet available - cannot read RIDs */
1061 if (hfa384x_get_rid(dev
, rid
, &comp
, sizeof(comp
), 1) < 0) {
1062 printk(KERN_DEBUG
"Could not get RID for component %s\n", txt
);
1066 printk(KERN_INFO
"%s: %s: id=0x%02x v%d.%d.%d\n", dev
->name
, txt
,
1067 __le16_to_cpu(comp
.id
), __le16_to_cpu(comp
.major
),
1068 __le16_to_cpu(comp
.minor
), __le16_to_cpu(comp
.variant
));
1073 static int prism2_setup_rids(struct net_device
*dev
)
1075 struct hostap_interface
*iface
;
1076 local_info_t
*local
;
1080 iface
= netdev_priv(dev
);
1081 local
= iface
->local
;
1083 hostap_set_word(dev
, HFA384X_RID_TICKTIME
, 2000);
1085 if (!local
->fw_ap
) {
1086 u16 tmp1
= hostap_get_porttype(local
);
1087 ret
= hostap_set_word(dev
, HFA384X_RID_CNFPORTTYPE
, tmp1
);
1089 printk("%s: Port type setting to %d failed\n",
1095 /* Setting SSID to empty string seems to kill the card in Host AP mode
1097 if (local
->iw_mode
!= IW_MODE_MASTER
|| local
->essid
[0] != '\0') {
1098 ret
= hostap_set_string(dev
, HFA384X_RID_CNFOWNSSID
,
1101 printk("%s: AP own SSID setting failed\n", dev
->name
);
1106 ret
= hostap_set_word(dev
, HFA384X_RID_CNFMAXDATALEN
,
1107 PRISM2_DATA_MAXLEN
);
1109 printk("%s: MAC data length setting to %d failed\n",
1110 dev
->name
, PRISM2_DATA_MAXLEN
);
1114 if (hfa384x_get_rid(dev
, HFA384X_RID_CHANNELLIST
, &tmp
, 2, 1) < 0) {
1115 printk("%s: Channel list read failed\n", dev
->name
);
1119 local
->channel_mask
= le16_to_cpu(tmp
);
1121 if (local
->channel
< 1 || local
->channel
> 14 ||
1122 !(local
->channel_mask
& (1 << (local
->channel
- 1)))) {
1123 printk(KERN_WARNING
"%s: Channel setting out of range "
1124 "(%d)!\n", dev
->name
, local
->channel
);
1129 ret
= hostap_set_word(dev
, HFA384X_RID_CNFOWNCHANNEL
, local
->channel
);
1131 printk("%s: Channel setting to %d failed\n",
1132 dev
->name
, local
->channel
);
1136 ret
= hostap_set_word(dev
, HFA384X_RID_CNFBEACONINT
,
1139 printk("%s: Beacon interval setting to %d failed\n",
1140 dev
->name
, local
->beacon_int
);
1141 /* this may fail with Symbol/Lucent firmware */
1142 if (ret
== -ETIMEDOUT
)
1146 ret
= hostap_set_word(dev
, HFA384X_RID_CNFOWNDTIMPERIOD
,
1147 local
->dtim_period
);
1149 printk("%s: DTIM period setting to %d failed\n",
1150 dev
->name
, local
->dtim_period
);
1151 /* this may fail with Symbol/Lucent firmware */
1152 if (ret
== -ETIMEDOUT
)
1156 ret
= hostap_set_word(dev
, HFA384X_RID_PROMISCUOUSMODE
,
1159 printk(KERN_INFO
"%s: Setting promiscuous mode (%d) failed\n",
1160 dev
->name
, local
->is_promisc
);
1162 if (!local
->fw_ap
) {
1163 ret
= hostap_set_string(dev
, HFA384X_RID_CNFDESIREDSSID
,
1166 printk("%s: Desired SSID setting failed\n", dev
->name
);
1171 /* Setup TXRateControl, defaults to allow use of 1, 2, 5.5, and
1172 * 11 Mbps in automatic TX rate fallback and 1 and 2 Mbps as basic
1174 if (local
->tx_rate_control
== 0) {
1175 local
->tx_rate_control
=
1176 HFA384X_RATES_1MBPS
|
1177 HFA384X_RATES_2MBPS
|
1178 HFA384X_RATES_5MBPS
|
1179 HFA384X_RATES_11MBPS
;
1181 if (local
->basic_rates
== 0)
1182 local
->basic_rates
= HFA384X_RATES_1MBPS
| HFA384X_RATES_2MBPS
;
1184 if (!local
->fw_ap
) {
1185 ret
= hostap_set_word(dev
, HFA384X_RID_TXRATECONTROL
,
1186 local
->tx_rate_control
);
1188 printk("%s: TXRateControl setting to %d failed\n",
1189 dev
->name
, local
->tx_rate_control
);
1193 ret
= hostap_set_word(dev
, HFA384X_RID_CNFSUPPORTEDRATES
,
1194 local
->tx_rate_control
);
1196 printk("%s: cnfSupportedRates setting to %d failed\n",
1197 dev
->name
, local
->tx_rate_control
);
1200 ret
= hostap_set_word(dev
, HFA384X_RID_CNFBASICRATES
,
1201 local
->basic_rates
);
1203 printk("%s: cnfBasicRates setting to %d failed\n",
1204 dev
->name
, local
->basic_rates
);
1207 ret
= hostap_set_word(dev
, HFA384X_RID_CREATEIBSS
, 1);
1209 printk("%s: Create IBSS setting to 1 failed\n",
1214 if (local
->name_set
)
1215 (void) hostap_set_string(dev
, HFA384X_RID_CNFOWNNAME
,
1218 if (hostap_set_encryption(local
)) {
1219 printk(KERN_INFO
"%s: could not configure encryption\n",
1223 (void) hostap_set_antsel(local
);
1225 if (hostap_set_roaming(local
)) {
1226 printk(KERN_INFO
"%s: could not set host roaming\n",
1230 if (local
->sta_fw_ver
>= PRISM2_FW_VER(1,6,3) &&
1231 hostap_set_word(dev
, HFA384X_RID_CNFENHSECURITY
, local
->enh_sec
))
1232 printk(KERN_INFO
"%s: cnfEnhSecurity setting to 0x%x failed\n",
1233 dev
->name
, local
->enh_sec
);
1235 /* 32-bit tallies were added in STA f/w 0.8.0, but they were apparently
1236 * not working correctly (last seven counters report bogus values).
1237 * This has been fixed in 0.8.2, so enable 32-bit tallies only
1238 * beginning with that firmware version. Another bug fix for 32-bit
1239 * tallies in 1.4.0; should 16-bit tallies be used for some other
1241 if (local
->sta_fw_ver
>= PRISM2_FW_VER(0,8,2)) {
1242 if (hostap_set_word(dev
, HFA384X_RID_CNFTHIRTY2TALLY
, 1)) {
1243 printk(KERN_INFO
"%s: cnfThirty2Tally setting "
1244 "failed\n", dev
->name
);
1245 local
->tallies32
= 0;
1247 local
->tallies32
= 1;
1249 local
->tallies32
= 0;
1251 hostap_set_auth_algs(local
);
1253 if (hostap_set_word(dev
, HFA384X_RID_FRAGMENTATIONTHRESHOLD
,
1254 local
->fragm_threshold
)) {
1255 printk(KERN_INFO
"%s: setting FragmentationThreshold to %d "
1256 "failed\n", dev
->name
, local
->fragm_threshold
);
1259 if (hostap_set_word(dev
, HFA384X_RID_RTSTHRESHOLD
,
1260 local
->rts_threshold
)) {
1261 printk(KERN_INFO
"%s: setting RTSThreshold to %d failed\n",
1262 dev
->name
, local
->rts_threshold
);
1265 if (local
->manual_retry_count
>= 0 &&
1266 hostap_set_word(dev
, HFA384X_RID_CNFALTRETRYCOUNT
,
1267 local
->manual_retry_count
)) {
1268 printk(KERN_INFO
"%s: setting cnfAltRetryCount to %d failed\n",
1269 dev
->name
, local
->manual_retry_count
);
1272 if (local
->sta_fw_ver
>= PRISM2_FW_VER(1,3,1) &&
1273 hfa384x_get_rid(dev
, HFA384X_RID_CNFDBMADJUST
, &tmp
, 2, 1) == 2) {
1274 local
->rssi_to_dBm
= le16_to_cpu(tmp
);
1277 if (local
->sta_fw_ver
>= PRISM2_FW_VER(1,7,0) && local
->wpa
&&
1278 hostap_set_word(dev
, HFA384X_RID_SSNHANDLINGMODE
, 1)) {
1279 printk(KERN_INFO
"%s: setting ssnHandlingMode to 1 failed\n",
1283 if (local
->sta_fw_ver
>= PRISM2_FW_VER(1,7,0) && local
->generic_elem
&&
1284 hfa384x_set_rid(dev
, HFA384X_RID_GENERICELEMENT
,
1285 local
->generic_elem
, local
->generic_elem_len
)) {
1286 printk(KERN_INFO
"%s: setting genericElement failed\n",
1295 static int prism2_hw_init(struct net_device
*dev
, int initial
)
1297 struct hostap_interface
*iface
;
1298 local_info_t
*local
;
1300 unsigned long start
, delay
;
1302 PDEBUG(DEBUG_FLOW
, "prism2_hw_init()\n");
1304 iface
= netdev_priv(dev
);
1305 local
= iface
->local
;
1307 clear_bit(HOSTAP_BITS_TRANSMIT
, &local
->bits
);
1310 /* initialize HFA 384x */
1311 ret
= hfa384x_cmd_no_wait(dev
, HFA384X_CMDCODE_INIT
, 0);
1313 printk(KERN_INFO
"%s: first command failed - assuming card "
1314 "does not have primary firmware\n", dev_info
);
1317 if (first
&& (HFA384X_INW(HFA384X_EVSTAT_OFF
) & HFA384X_EV_CMD
)) {
1318 /* EvStat has Cmd bit set in some cases, so retry once if no
1319 * wait was needed */
1320 HFA384X_OUTW(HFA384X_EV_CMD
, HFA384X_EVACK_OFF
);
1321 printk(KERN_DEBUG
"%s: init command completed too quickly - "
1322 "retrying\n", dev
->name
);
1328 delay
= jiffies
+ HFA384X_INIT_TIMEOUT
;
1329 while (!(HFA384X_INW(HFA384X_EVSTAT_OFF
) & HFA384X_EV_CMD
) &&
1330 time_before(jiffies
, delay
))
1332 if (!(HFA384X_INW(HFA384X_EVSTAT_OFF
) & HFA384X_EV_CMD
)) {
1333 printk(KERN_DEBUG
"%s: assuming no Primary image in "
1334 "flash - card initialization not completed\n",
1337 #ifdef PRISM2_DOWNLOAD_SUPPORT
1338 if (local
->sram_type
== -1)
1339 local
->sram_type
= prism2_get_ram_size(local
);
1340 #endif /* PRISM2_DOWNLOAD_SUPPORT */
1344 printk(KERN_DEBUG
"prism2_hw_init: initialized in %lu ms\n",
1345 (jiffies
- start
) * 1000 / HZ
);
1346 HFA384X_OUTW(HFA384X_EV_CMD
, HFA384X_EVACK_OFF
);
1351 static int prism2_hw_init2(struct net_device
*dev
, int initial
)
1353 struct hostap_interface
*iface
;
1354 local_info_t
*local
;
1357 iface
= netdev_priv(dev
);
1358 local
= iface
->local
;
1360 #ifdef PRISM2_DOWNLOAD_SUPPORT
1365 local
->pda
= prism2_read_pda(dev
);
1366 #endif /* PRISM2_DOWNLOAD_SUPPORT */
1368 hfa384x_disable_interrupts(dev
);
1370 #ifndef final_version
1371 HFA384X_OUTW(HFA384X_MAGIC
, HFA384X_SWSUPPORT0_OFF
);
1372 if (HFA384X_INW(HFA384X_SWSUPPORT0_OFF
) != HFA384X_MAGIC
) {
1373 printk("SWSUPPORT0 write/read failed: %04X != %04X\n",
1374 HFA384X_INW(HFA384X_SWSUPPORT0_OFF
), HFA384X_MAGIC
);
1379 if (initial
|| local
->pri_only
) {
1380 hfa384x_events_only_cmd(dev
);
1381 /* get card version information */
1382 if (prism2_get_version_info(dev
, HFA384X_RID_NICID
, "NIC") ||
1383 prism2_get_version_info(dev
, HFA384X_RID_PRIID
, "PRI")) {
1384 hfa384x_disable_interrupts(dev
);
1388 if (prism2_get_version_info(dev
, HFA384X_RID_STAID
, "STA")) {
1389 printk(KERN_DEBUG
"%s: Failed to read STA f/w version "
1390 "- only Primary f/w present\n", dev
->name
);
1391 local
->pri_only
= 1;
1394 local
->pri_only
= 0;
1395 hfa384x_disable_interrupts(dev
);
1398 /* FIX: could convert allocate_fid to use sleeping CmdCompl wait and
1399 * enable interrupts before this. This would also require some sort of
1400 * sleeping AllocEv waiting */
1402 /* allocate TX FIDs */
1403 local
->txfid_len
= PRISM2_TXFID_LEN
;
1404 for (i
= 0; i
< PRISM2_TXFID_COUNT
; i
++) {
1405 local
->txfid
[i
] = hfa384x_allocate_fid(dev
, local
->txfid_len
);
1406 if (local
->txfid
[i
] == 0xffff && local
->txfid_len
> 1600) {
1407 local
->txfid
[i
] = hfa384x_allocate_fid(dev
, 1600);
1408 if (local
->txfid
[i
] != 0xffff) {
1409 printk(KERN_DEBUG
"%s: Using shorter TX FID "
1410 "(1600 bytes)\n", dev
->name
);
1411 local
->txfid_len
= 1600;
1414 if (local
->txfid
[i
] == 0xffff)
1416 local
->intransmitfid
[i
] = PRISM2_TXFID_EMPTY
;
1419 hfa384x_events_only_cmd(dev
);
1422 struct list_head
*ptr
;
1423 prism2_check_sta_fw_version(local
);
1425 if (hfa384x_get_rid(dev
, HFA384X_RID_CNFOWNMACADDR
,
1426 dev
->dev_addr
, 6, 1) < 0) {
1427 printk("%s: could not get own MAC address\n",
1430 list_for_each(ptr
, &local
->hostap_interfaces
) {
1431 iface
= list_entry(ptr
, struct hostap_interface
, list
);
1432 memcpy(iface
->dev
->dev_addr
, dev
->dev_addr
, ETH_ALEN
);
1434 } else if (local
->fw_ap
)
1435 prism2_check_sta_fw_version(local
);
1437 prism2_setup_rids(dev
);
1439 /* MAC is now configured, but port 0 is not yet enabled */
1444 printk(KERN_WARNING
"%s: Initialization failed\n", dev_info
);
1449 static int prism2_hw_enable(struct net_device
*dev
, int initial
)
1451 struct hostap_interface
*iface
;
1452 local_info_t
*local
;
1455 iface
= netdev_priv(dev
);
1456 local
= iface
->local
;
1457 was_resetting
= local
->hw_resetting
;
1459 if (hfa384x_cmd(dev
, HFA384X_CMDCODE_ENABLE
, 0, NULL
, NULL
)) {
1460 printk("%s: MAC port 0 enabling failed\n", dev
->name
);
1464 local
->hw_ready
= 1;
1465 local
->hw_reset_tries
= 0;
1466 local
->hw_resetting
= 0;
1467 hfa384x_enable_interrupts(dev
);
1469 /* at least D-Link DWL-650 seems to require additional port reset
1470 * before it starts acting as an AP, so reset port automatically
1471 * here just in case */
1472 if (initial
&& prism2_reset_port(dev
)) {
1473 printk("%s: MAC port 0 reseting failed\n", dev
->name
);
1477 if (was_resetting
&& netif_queue_stopped(dev
)) {
1478 /* If hw_reset() was called during pending transmit, netif
1479 * queue was stopped. Wake it up now since the wlan card has
1481 netif_wake_queue(dev
);
1488 static int prism2_hw_config(struct net_device
*dev
, int initial
)
1490 struct hostap_interface
*iface
;
1491 local_info_t
*local
;
1493 iface
= netdev_priv(dev
);
1494 local
= iface
->local
;
1496 if (local
->hw_downloading
)
1499 if (prism2_hw_init(dev
, initial
)) {
1500 return local
->no_pri
? 0 : 1;
1503 if (prism2_hw_init2(dev
, initial
))
1506 /* Enable firmware if secondary image is loaded and at least one of the
1507 * netdevices is up. */
1508 if (!local
->pri_only
&&
1509 (initial
== 0 || (initial
== 2 && local
->num_dev_open
> 0))) {
1510 if (!local
->dev_enabled
)
1511 prism2_callback(local
, PRISM2_CALLBACK_ENABLE
);
1512 local
->dev_enabled
= 1;
1513 return prism2_hw_enable(dev
, initial
);
1520 static void prism2_hw_shutdown(struct net_device
*dev
, int no_disable
)
1522 struct hostap_interface
*iface
;
1523 local_info_t
*local
;
1525 iface
= netdev_priv(dev
);
1526 local
= iface
->local
;
1528 /* Allow only command completion events during disable */
1529 hfa384x_events_only_cmd(dev
);
1531 local
->hw_ready
= 0;
1532 if (local
->dev_enabled
)
1533 prism2_callback(local
, PRISM2_CALLBACK_DISABLE
);
1534 local
->dev_enabled
= 0;
1536 if (local
->func
->card_present
&& !local
->func
->card_present(local
)) {
1537 printk(KERN_DEBUG
"%s: card already removed or not configured "
1538 "during shutdown\n", dev
->name
);
1542 if ((no_disable
& HOSTAP_HW_NO_DISABLE
) == 0 &&
1543 hfa384x_cmd(dev
, HFA384X_CMDCODE_DISABLE
, 0, NULL
, NULL
))
1544 printk(KERN_WARNING
"%s: Shutdown failed\n", dev_info
);
1546 hfa384x_disable_interrupts(dev
);
1548 if (no_disable
& HOSTAP_HW_ENABLE_CMDCOMPL
)
1549 hfa384x_events_only_cmd(dev
);
1551 prism2_clear_cmd_queue(local
);
1555 static void prism2_hw_reset(struct net_device
*dev
)
1557 struct hostap_interface
*iface
;
1558 local_info_t
*local
;
1561 static long last_reset
= 0;
1563 /* do not reset card more than once per second to avoid ending up in a
1564 * busy loop reseting the card */
1565 if (time_before_eq(jiffies
, last_reset
+ HZ
))
1567 last_reset
= jiffies
;
1570 iface
= netdev_priv(dev
);
1571 local
= iface
->local
;
1573 if (in_interrupt()) {
1574 printk(KERN_DEBUG
"%s: driver bug - prism2_hw_reset() called "
1575 "in interrupt context\n", dev
->name
);
1579 if (local
->hw_downloading
)
1582 if (local
->hw_resetting
) {
1583 printk(KERN_WARNING
"%s: %s: already resetting card - "
1584 "ignoring reset request\n", dev_info
, dev
->name
);
1588 local
->hw_reset_tries
++;
1589 if (local
->hw_reset_tries
> 10) {
1590 printk(KERN_WARNING
"%s: too many reset tries, skipping\n",
1595 printk(KERN_WARNING
"%s: %s: resetting card\n", dev_info
, dev
->name
);
1596 hfa384x_disable_interrupts(dev
);
1597 local
->hw_resetting
= 1;
1598 if (local
->func
->cor_sreset
) {
1599 /* Host system seems to hang in some cases with high traffic
1600 * load or shared interrupts during COR sreset. Disable shared
1601 * interrupts during reset to avoid these crashes. COS sreset
1602 * takes quite a long time, so it is unfortunate that this
1603 * seems to be needed. Anyway, I do not know of any better way
1604 * of avoiding the crash. */
1605 disable_irq(dev
->irq
);
1606 local
->func
->cor_sreset(local
);
1607 enable_irq(dev
->irq
);
1609 prism2_hw_shutdown(dev
, 1);
1610 prism2_hw_config(dev
, 0);
1611 local
->hw_resetting
= 0;
1613 #ifdef PRISM2_DOWNLOAD_SUPPORT
1614 if (local
->dl_pri
) {
1615 printk(KERN_DEBUG
"%s: persistent download of primary "
1616 "firmware\n", dev
->name
);
1617 if (prism2_download_genesis(local
, local
->dl_pri
) < 0)
1618 printk(KERN_WARNING
"%s: download (PRI) failed\n",
1622 if (local
->dl_sec
) {
1623 printk(KERN_DEBUG
"%s: persistent download of secondary "
1624 "firmware\n", dev
->name
);
1625 if (prism2_download_volatile(local
, local
->dl_sec
) < 0)
1626 printk(KERN_WARNING
"%s: download (SEC) failed\n",
1629 #endif /* PRISM2_DOWNLOAD_SUPPORT */
1631 /* TODO: restore beacon TIM bits for STAs that have buffered frames */
1635 static void prism2_schedule_reset(local_info_t
*local
)
1637 schedule_work(&local
->reset_queue
);
1641 /* Called only as scheduled task after noticing card timeout in interrupt
1643 static void handle_reset_queue(struct work_struct
*work
)
1645 local_info_t
*local
= container_of(work
, local_info_t
, reset_queue
);
1647 printk(KERN_DEBUG
"%s: scheduled card reset\n", local
->dev
->name
);
1648 prism2_hw_reset(local
->dev
);
1650 if (netif_queue_stopped(local
->dev
)) {
1653 for (i
= 0; i
< PRISM2_TXFID_COUNT
; i
++)
1654 if (local
->intransmitfid
[i
] == PRISM2_TXFID_EMPTY
) {
1655 PDEBUG(DEBUG_EXTRA
, "prism2_tx_timeout: "
1657 netif_wake_queue(local
->dev
);
1664 static int prism2_get_txfid_idx(local_info_t
*local
)
1667 unsigned long flags
;
1669 spin_lock_irqsave(&local
->txfidlock
, flags
);
1670 end
= idx
= local
->next_txfid
;
1672 if (local
->intransmitfid
[idx
] == PRISM2_TXFID_EMPTY
) {
1673 local
->intransmitfid
[idx
] = PRISM2_TXFID_RESERVED
;
1674 spin_unlock_irqrestore(&local
->txfidlock
, flags
);
1678 if (idx
>= PRISM2_TXFID_COUNT
)
1680 } while (idx
!= end
);
1681 spin_unlock_irqrestore(&local
->txfidlock
, flags
);
1683 PDEBUG(DEBUG_EXTRA2
, "prism2_get_txfid_idx: no room in txfid buf: "
1684 "packet dropped\n");
1685 local
->dev
->stats
.tx_dropped
++;
1691 /* Called only from hardware IRQ */
1692 static void prism2_transmit_cb(struct net_device
*dev
, long context
,
1695 struct hostap_interface
*iface
;
1696 local_info_t
*local
;
1697 int idx
= (int) context
;
1699 iface
= netdev_priv(dev
);
1700 local
= iface
->local
;
1703 printk(KERN_DEBUG
"%s: prism2_transmit_cb - res=0x%02x\n",
1708 if (idx
< 0 || idx
>= PRISM2_TXFID_COUNT
) {
1709 printk(KERN_DEBUG
"%s: prism2_transmit_cb called with invalid "
1710 "idx=%d\n", dev
->name
, idx
);
1714 if (!test_and_clear_bit(HOSTAP_BITS_TRANSMIT
, &local
->bits
)) {
1715 printk(KERN_DEBUG
"%s: driver bug: prism2_transmit_cb called "
1716 "with no pending transmit\n", dev
->name
);
1719 if (netif_queue_stopped(dev
)) {
1720 /* ready for next TX, so wake up queue that was stopped in
1721 * prism2_transmit() */
1722 netif_wake_queue(dev
);
1725 spin_lock(&local
->txfidlock
);
1727 /* With reclaim, Resp0 contains new txfid for transmit; the old txfid
1728 * will be automatically allocated for the next TX frame */
1729 local
->intransmitfid
[idx
] = resp0
;
1731 PDEBUG(DEBUG_FID
, "%s: prism2_transmit_cb: txfid[%d]=0x%04x, "
1732 "resp0=0x%04x, transmit_txfid=0x%04x\n",
1733 dev
->name
, idx
, local
->txfid
[idx
],
1734 resp0
, local
->intransmitfid
[local
->next_txfid
]);
1737 if (idx
>= PRISM2_TXFID_COUNT
)
1739 local
->next_txfid
= idx
;
1741 /* check if all TX buffers are occupied */
1743 if (local
->intransmitfid
[idx
] == PRISM2_TXFID_EMPTY
) {
1744 spin_unlock(&local
->txfidlock
);
1748 if (idx
>= PRISM2_TXFID_COUNT
)
1750 } while (idx
!= local
->next_txfid
);
1751 spin_unlock(&local
->txfidlock
);
1753 /* no empty TX buffers, stop queue */
1754 netif_stop_queue(dev
);
1758 /* Called only from software IRQ if PCI bus master is not used (with bus master
1759 * this can be called both from software and hardware IRQ) */
1760 static int prism2_transmit(struct net_device
*dev
, int idx
)
1762 struct hostap_interface
*iface
;
1763 local_info_t
*local
;
1766 iface
= netdev_priv(dev
);
1767 local
= iface
->local
;
1769 /* The driver tries to stop netif queue so that there would not be
1770 * more than one attempt to transmit frames going on; check that this
1771 * is really the case */
1773 if (test_and_set_bit(HOSTAP_BITS_TRANSMIT
, &local
->bits
)) {
1774 printk(KERN_DEBUG
"%s: driver bug - prism2_transmit() called "
1775 "when previous TX was pending\n", dev
->name
);
1779 /* stop the queue for the time that transmit is pending */
1780 netif_stop_queue(dev
);
1782 /* transmit packet */
1783 res
= hfa384x_cmd_callback(
1785 HFA384X_CMDCODE_TRANSMIT
| HFA384X_CMD_TX_RECLAIM
,
1787 prism2_transmit_cb
, (long) idx
);
1790 printk(KERN_DEBUG
"%s: prism2_transmit: CMDCODE_TRANSMIT "
1791 "failed (res=%d)\n", dev
->name
, res
);
1792 dev
->stats
.tx_dropped
++;
1793 netif_wake_queue(dev
);
1796 dev
->trans_start
= jiffies
;
1798 /* Since we did not wait for command completion, the card continues
1799 * to process on the background and we will finish handling when
1800 * command completion event is handled (prism2_cmd_ev() function) */
1806 /* Send IEEE 802.11 frame (convert the header into Prism2 TX descriptor and
1807 * send the payload with this descriptor) */
1808 /* Called only from software IRQ */
1809 static int prism2_tx_80211(struct sk_buff
*skb
, struct net_device
*dev
)
1811 struct hostap_interface
*iface
;
1812 local_info_t
*local
;
1813 struct hfa384x_tx_frame txdesc
;
1814 struct hostap_skb_tx_data
*meta
;
1815 int hdr_len
, data_len
, idx
, res
, ret
= -1;
1818 iface
= netdev_priv(dev
);
1819 local
= iface
->local
;
1821 meta
= (struct hostap_skb_tx_data
*) skb
->cb
;
1823 prism2_callback(local
, PRISM2_CALLBACK_TX_START
);
1825 if ((local
->func
->card_present
&& !local
->func
->card_present(local
)) ||
1826 !local
->hw_ready
|| local
->hw_downloading
|| local
->pri_only
) {
1827 if (net_ratelimit()) {
1828 printk(KERN_DEBUG
"%s: prism2_tx_80211: hw not ready -"
1829 " skipping\n", dev
->name
);
1834 memset(&txdesc
, 0, sizeof(txdesc
));
1836 /* skb->data starts with txdesc->frame_control */
1838 skb_copy_from_linear_data(skb
, &txdesc
.frame_control
, hdr_len
);
1839 fc
= le16_to_cpu(txdesc
.frame_control
);
1840 if (ieee80211_is_data(txdesc
.frame_control
) &&
1841 ieee80211_has_a4(txdesc
.frame_control
) &&
1844 skb_copy_from_linear_data_offset(skb
, hdr_len
, txdesc
.addr4
,
1846 hdr_len
+= ETH_ALEN
;
1849 tx_control
= local
->tx_control
;
1850 if (meta
->tx_cb_idx
) {
1851 tx_control
|= HFA384X_TX_CTRL_TX_OK
;
1852 txdesc
.sw_support
= cpu_to_le32(meta
->tx_cb_idx
);
1854 txdesc
.tx_control
= cpu_to_le16(tx_control
);
1855 txdesc
.tx_rate
= meta
->rate
;
1857 data_len
= skb
->len
- hdr_len
;
1858 txdesc
.data_len
= cpu_to_le16(data_len
);
1859 txdesc
.len
= cpu_to_be16(data_len
);
1861 idx
= prism2_get_txfid_idx(local
);
1865 if (local
->frame_dump
& PRISM2_DUMP_TX_HDR
)
1866 hostap_dump_tx_header(dev
->name
, &txdesc
);
1868 spin_lock(&local
->baplock
);
1869 res
= hfa384x_setup_bap(dev
, BAP0
, local
->txfid
[idx
], 0);
1872 res
= hfa384x_to_bap(dev
, BAP0
, &txdesc
, sizeof(txdesc
));
1874 res
= hfa384x_to_bap(dev
, BAP0
, skb
->data
+ hdr_len
,
1875 skb
->len
- hdr_len
);
1876 spin_unlock(&local
->baplock
);
1879 res
= prism2_transmit(dev
, idx
);
1881 printk(KERN_DEBUG
"%s: prism2_tx_80211 - to BAP0 failed\n",
1883 local
->intransmitfid
[idx
] = PRISM2_TXFID_EMPTY
;
1884 schedule_work(&local
->reset_queue
);
1891 prism2_callback(local
, PRISM2_CALLBACK_TX_END
);
1896 /* Some SMP systems have reported number of odd errors with hostap_pci. fid
1897 * register has changed values between consecutive reads for an unknown reason.
1898 * This should really not happen, so more debugging is needed. This test
1899 * version is a bit slower, but it will detect most of such register changes
1900 * and will try to get the correct fid eventually. */
1901 #define EXTRA_FID_READ_TESTS
1903 static u16
prism2_read_fid_reg(struct net_device
*dev
, u16 reg
)
1905 #ifdef EXTRA_FID_READ_TESTS
1906 u16 val
, val2
, val3
;
1909 for (i
= 0; i
< 10; i
++) {
1910 val
= HFA384X_INW(reg
);
1911 val2
= HFA384X_INW(reg
);
1912 val3
= HFA384X_INW(reg
);
1914 if (val
== val2
&& val
== val3
)
1917 printk(KERN_DEBUG
"%s: detected fid change (try=%d, reg=%04x):"
1918 " %04x %04x %04x\n",
1919 dev
->name
, i
, reg
, val
, val2
, val3
);
1920 if ((val
== val2
|| val
== val3
) && val
!= 0)
1922 if (val2
== val3
&& val2
!= 0)
1925 printk(KERN_WARNING
"%s: Uhhuh.. could not read good fid from reg "
1926 "%04x (%04x %04x %04x)\n", dev
->name
, reg
, val
, val2
, val3
);
1928 #else /* EXTRA_FID_READ_TESTS */
1929 return HFA384X_INW(reg
);
1930 #endif /* EXTRA_FID_READ_TESTS */
1934 /* Called only as a tasklet (software IRQ) */
1935 static void prism2_rx(local_info_t
*local
)
1937 struct net_device
*dev
= local
->dev
;
1938 int res
, rx_pending
= 0;
1939 u16 len
, hdr_len
, rxfid
, status
, macport
;
1940 struct hfa384x_rx_frame rxdesc
;
1941 struct sk_buff
*skb
= NULL
;
1943 prism2_callback(local
, PRISM2_CALLBACK_RX_START
);
1945 rxfid
= prism2_read_fid_reg(dev
, HFA384X_RXFID_OFF
);
1946 #ifndef final_version
1948 rxfid
= HFA384X_INW(HFA384X_RXFID_OFF
);
1949 printk(KERN_DEBUG
"prism2_rx: rxfid=0 (next 0x%04x)\n",
1952 schedule_work(&local
->reset_queue
);
1955 /* try to continue with the new rxfid value */
1959 spin_lock(&local
->baplock
);
1960 res
= hfa384x_setup_bap(dev
, BAP0
, rxfid
, 0);
1962 res
= hfa384x_from_bap(dev
, BAP0
, &rxdesc
, sizeof(rxdesc
));
1965 spin_unlock(&local
->baplock
);
1966 printk(KERN_DEBUG
"%s: copy from BAP0 failed %d\n", dev
->name
,
1968 if (res
== -ETIMEDOUT
) {
1969 schedule_work(&local
->reset_queue
);
1974 len
= le16_to_cpu(rxdesc
.data_len
);
1975 hdr_len
= sizeof(rxdesc
);
1976 status
= le16_to_cpu(rxdesc
.status
);
1977 macport
= (status
>> 8) & 0x07;
1979 /* Drop frames with too large reported payload length. Monitor mode
1980 * seems to sometimes pass frames (e.g., ctrl::ack) with signed and
1981 * negative value, so allow also values 65522 .. 65534 (-14 .. -2) for
1983 if (len
> PRISM2_DATA_MAXLEN
+ 8 /* WEP */) {
1984 if (macport
== 7 && local
->iw_mode
== IW_MODE_MONITOR
) {
1985 if (len
>= (u16
) -14) {
1986 hdr_len
-= 65535 - len
;
1991 spin_unlock(&local
->baplock
);
1992 printk(KERN_DEBUG
"%s: Received frame with invalid "
1993 "length 0x%04x\n", dev
->name
, len
);
1994 hostap_dump_rx_header(dev
->name
, &rxdesc
);
1999 skb
= dev_alloc_skb(len
+ hdr_len
);
2001 spin_unlock(&local
->baplock
);
2002 printk(KERN_DEBUG
"%s: RX failed to allocate skb\n",
2007 memcpy(skb_put(skb
, hdr_len
), &rxdesc
, hdr_len
);
2010 res
= hfa384x_from_bap(dev
, BAP0
, skb_put(skb
, len
), len
);
2011 spin_unlock(&local
->baplock
);
2013 printk(KERN_DEBUG
"%s: RX failed to read "
2014 "frame data\n", dev
->name
);
2018 skb_queue_tail(&local
->rx_list
, skb
);
2019 tasklet_schedule(&local
->rx_tasklet
);
2022 prism2_callback(local
, PRISM2_CALLBACK_RX_END
);
2024 HFA384X_OUTW(HFA384X_EV_RX
, HFA384X_EVACK_OFF
);
2030 dev
->stats
.rx_dropped
++;
2037 /* Called only as a tasklet (software IRQ) */
2038 static void hostap_rx_skb(local_info_t
*local
, struct sk_buff
*skb
)
2040 struct hfa384x_rx_frame
*rxdesc
;
2041 struct net_device
*dev
= skb
->dev
;
2042 struct hostap_80211_rx_status stats
;
2043 int hdrlen
, rx_hdrlen
;
2045 rx_hdrlen
= sizeof(*rxdesc
);
2046 if (skb
->len
< sizeof(*rxdesc
)) {
2047 /* Allow monitor mode to receive shorter frames */
2048 if (local
->iw_mode
== IW_MODE_MONITOR
&&
2049 skb
->len
>= sizeof(*rxdesc
) - 30) {
2050 rx_hdrlen
= skb
->len
;
2057 rxdesc
= (struct hfa384x_rx_frame
*) skb
->data
;
2059 if (local
->frame_dump
& PRISM2_DUMP_RX_HDR
&&
2060 skb
->len
>= sizeof(*rxdesc
))
2061 hostap_dump_rx_header(dev
->name
, rxdesc
);
2063 if (le16_to_cpu(rxdesc
->status
) & HFA384X_RX_STATUS_FCSERR
&&
2064 (!local
->monitor_allow_fcserr
||
2065 local
->iw_mode
!= IW_MODE_MONITOR
))
2068 if (skb
->len
> PRISM2_DATA_MAXLEN
) {
2069 printk(KERN_DEBUG
"%s: RX: len(%d) > MAX(%d)\n",
2070 dev
->name
, skb
->len
, PRISM2_DATA_MAXLEN
);
2074 stats
.mac_time
= le32_to_cpu(rxdesc
->time
);
2075 stats
.signal
= rxdesc
->signal
- local
->rssi_to_dBm
;
2076 stats
.noise
= rxdesc
->silence
- local
->rssi_to_dBm
;
2077 stats
.rate
= rxdesc
->rate
;
2079 /* Convert Prism2 RX structure into IEEE 802.11 header */
2080 hdrlen
= hostap_80211_get_hdrlen(rxdesc
->frame_control
);
2081 if (hdrlen
> rx_hdrlen
)
2084 memmove(skb_pull(skb
, rx_hdrlen
- hdrlen
),
2085 &rxdesc
->frame_control
, hdrlen
);
2087 hostap_80211_rx(dev
, skb
, &stats
);
2095 /* Called only as a tasklet (software IRQ) */
2096 static void hostap_rx_tasklet(unsigned long data
)
2098 local_info_t
*local
= (local_info_t
*) data
;
2099 struct sk_buff
*skb
;
2101 while ((skb
= skb_dequeue(&local
->rx_list
)) != NULL
)
2102 hostap_rx_skb(local
, skb
);
2106 /* Called only from hardware IRQ */
2107 static void prism2_alloc_ev(struct net_device
*dev
)
2109 struct hostap_interface
*iface
;
2110 local_info_t
*local
;
2114 iface
= netdev_priv(dev
);
2115 local
= iface
->local
;
2117 fid
= prism2_read_fid_reg(dev
, HFA384X_ALLOCFID_OFF
);
2119 PDEBUG(DEBUG_FID
, "FID: interrupt: ALLOC - fid=0x%04x\n", fid
);
2121 spin_lock(&local
->txfidlock
);
2122 idx
= local
->next_alloc
;
2125 if (local
->txfid
[idx
] == fid
) {
2126 PDEBUG(DEBUG_FID
, "FID: found matching txfid[%d]\n",
2129 #ifndef final_version
2130 if (local
->intransmitfid
[idx
] == PRISM2_TXFID_EMPTY
)
2131 printk("Already released txfid found at idx "
2133 if (local
->intransmitfid
[idx
] == PRISM2_TXFID_RESERVED
)
2134 printk("Already reserved txfid found at idx "
2137 local
->intransmitfid
[idx
] = PRISM2_TXFID_EMPTY
;
2139 local
->next_alloc
= idx
>= PRISM2_TXFID_COUNT
? 0 :
2142 if (!test_bit(HOSTAP_BITS_TRANSMIT
, &local
->bits
) &&
2143 netif_queue_stopped(dev
))
2144 netif_wake_queue(dev
);
2146 spin_unlock(&local
->txfidlock
);
2151 if (idx
>= PRISM2_TXFID_COUNT
)
2153 } while (idx
!= local
->next_alloc
);
2155 printk(KERN_WARNING
"%s: could not find matching txfid (0x%04x, new "
2156 "read 0x%04x) for alloc event\n", dev
->name
, fid
,
2157 HFA384X_INW(HFA384X_ALLOCFID_OFF
));
2158 printk(KERN_DEBUG
"TXFIDs:");
2159 for (idx
= 0; idx
< PRISM2_TXFID_COUNT
; idx
++)
2160 printk(" %04x[%04x]", local
->txfid
[idx
],
2161 local
->intransmitfid
[idx
]);
2163 spin_unlock(&local
->txfidlock
);
2165 /* FIX: should probably schedule reset; reference to one txfid was lost
2166 * completely.. Bad things will happen if we run out of txfids
2167 * Actually, this will cause netdev watchdog to notice TX timeout and
2168 * then card reset after all txfids have been leaked. */
2172 /* Called only as a tasklet (software IRQ) */
2173 static void hostap_tx_callback(local_info_t
*local
,
2174 struct hfa384x_tx_frame
*txdesc
, int ok
,
2177 u16 sw_support
, hdrlen
, len
;
2178 struct sk_buff
*skb
;
2179 struct hostap_tx_callback_info
*cb
;
2181 /* Make sure that frame was from us. */
2182 if (memcmp(txdesc
->addr2
, local
->dev
->dev_addr
, ETH_ALEN
)) {
2183 printk(KERN_DEBUG
"%s: TX callback - foreign frame\n",
2188 sw_support
= le32_to_cpu(txdesc
->sw_support
);
2190 spin_lock(&local
->lock
);
2191 cb
= local
->tx_callback
;
2192 while (cb
!= NULL
&& cb
->idx
!= sw_support
)
2194 spin_unlock(&local
->lock
);
2197 printk(KERN_DEBUG
"%s: could not find TX callback (idx %d)\n",
2198 local
->dev
->name
, sw_support
);
2202 hdrlen
= hostap_80211_get_hdrlen(txdesc
->frame_control
);
2203 len
= le16_to_cpu(txdesc
->data_len
);
2204 skb
= dev_alloc_skb(hdrlen
+ len
);
2206 printk(KERN_DEBUG
"%s: hostap_tx_callback failed to allocate "
2207 "skb\n", local
->dev
->name
);
2211 memcpy(skb_put(skb
, hdrlen
), (void *) &txdesc
->frame_control
, hdrlen
);
2213 memcpy(skb_put(skb
, len
), payload
, len
);
2215 skb
->dev
= local
->dev
;
2216 skb_reset_mac_header(skb
);
2218 cb
->func(skb
, ok
, cb
->data
);
2222 /* Called only as a tasklet (software IRQ) */
2223 static int hostap_tx_compl_read(local_info_t
*local
, int error
,
2224 struct hfa384x_tx_frame
*txdesc
,
2229 struct net_device
*dev
= local
->dev
;
2231 fid
= prism2_read_fid_reg(dev
, HFA384X_TXCOMPLFID_OFF
);
2233 PDEBUG(DEBUG_FID
, "interrupt: TX (err=%d) - fid=0x%04x\n", fid
, error
);
2235 spin_lock(&local
->baplock
);
2236 res
= hfa384x_setup_bap(dev
, BAP0
, fid
, 0);
2238 res
= hfa384x_from_bap(dev
, BAP0
, txdesc
, sizeof(*txdesc
));
2240 PDEBUG(DEBUG_EXTRA
, "%s: TX (err=%d) - fid=0x%04x - could not "
2241 "read txdesc\n", dev
->name
, error
, fid
);
2242 if (res
== -ETIMEDOUT
) {
2243 schedule_work(&local
->reset_queue
);
2248 if (txdesc
->sw_support
) {
2249 len
= le16_to_cpu(txdesc
->data_len
);
2250 if (len
< PRISM2_DATA_MAXLEN
) {
2251 *payload
= kmalloc(len
, GFP_ATOMIC
);
2252 if (*payload
== NULL
||
2253 hfa384x_from_bap(dev
, BAP0
, *payload
, len
)) {
2254 PDEBUG(DEBUG_EXTRA
, "%s: could not read TX "
2255 "frame payload\n", dev
->name
);
2265 spin_unlock(&local
->baplock
);
2271 /* Called only as a tasklet (software IRQ) */
2272 static void prism2_tx_ev(local_info_t
*local
)
2274 struct net_device
*dev
= local
->dev
;
2275 char *payload
= NULL
;
2276 struct hfa384x_tx_frame txdesc
;
2278 if (hostap_tx_compl_read(local
, 0, &txdesc
, &payload
))
2281 if (local
->frame_dump
& PRISM2_DUMP_TX_HDR
) {
2282 PDEBUG(DEBUG_EXTRA
, "%s: TX - status=0x%04x "
2283 "retry_count=%d tx_rate=%d seq_ctrl=%d "
2285 dev
->name
, le16_to_cpu(txdesc
.status
),
2286 txdesc
.retry_count
, txdesc
.tx_rate
,
2287 le16_to_cpu(txdesc
.seq_ctrl
),
2288 le16_to_cpu(txdesc
.duration_id
));
2291 if (txdesc
.sw_support
)
2292 hostap_tx_callback(local
, &txdesc
, 1, payload
);
2296 HFA384X_OUTW(HFA384X_EV_TX
, HFA384X_EVACK_OFF
);
2300 /* Called only as a tasklet (software IRQ) */
2301 static void hostap_sta_tx_exc_tasklet(unsigned long data
)
2303 local_info_t
*local
= (local_info_t
*) data
;
2304 struct sk_buff
*skb
;
2306 while ((skb
= skb_dequeue(&local
->sta_tx_exc_list
)) != NULL
) {
2307 struct hfa384x_tx_frame
*txdesc
=
2308 (struct hfa384x_tx_frame
*) skb
->data
;
2310 if (skb
->len
>= sizeof(*txdesc
)) {
2311 /* Convert Prism2 RX structure into IEEE 802.11 header
2313 int hdrlen
= hostap_80211_get_hdrlen(txdesc
->frame_control
);
2314 memmove(skb_pull(skb
, sizeof(*txdesc
) - hdrlen
),
2315 &txdesc
->frame_control
, hdrlen
);
2317 hostap_handle_sta_tx_exc(local
, skb
);
2324 /* Called only as a tasklet (software IRQ) */
2325 static void prism2_txexc(local_info_t
*local
)
2327 struct net_device
*dev
= local
->dev
;
2330 char *payload
= NULL
;
2331 struct hfa384x_tx_frame txdesc
;
2333 show_dump
= local
->frame_dump
& PRISM2_DUMP_TXEXC_HDR
;
2334 dev
->stats
.tx_errors
++;
2336 res
= hostap_tx_compl_read(local
, 1, &txdesc
, &payload
);
2337 HFA384X_OUTW(HFA384X_EV_TXEXC
, HFA384X_EVACK_OFF
);
2341 status
= le16_to_cpu(txdesc
.status
);
2343 /* We produce a TXDROP event only for retry or lifetime
2344 * exceeded, because that's the only status that really mean
2345 * that this particular node went away.
2346 * Other errors means that *we* screwed up. - Jean II */
2347 if (status
& (HFA384X_TX_STATUS_RETRYERR
| HFA384X_TX_STATUS_AGEDERR
))
2349 union iwreq_data wrqu
;
2351 /* Copy 802.11 dest address. */
2352 memcpy(wrqu
.addr
.sa_data
, txdesc
.addr1
, ETH_ALEN
);
2353 wrqu
.addr
.sa_family
= ARPHRD_ETHER
;
2354 wireless_send_event(dev
, IWEVTXDROP
, &wrqu
, NULL
);
2358 if (local
->iw_mode
== IW_MODE_MASTER
||
2359 local
->iw_mode
== IW_MODE_REPEAT
||
2360 local
->wds_type
& HOSTAP_WDS_AP_CLIENT
) {
2361 struct sk_buff
*skb
;
2362 skb
= dev_alloc_skb(sizeof(txdesc
));
2364 memcpy(skb_put(skb
, sizeof(txdesc
)), &txdesc
,
2366 skb_queue_tail(&local
->sta_tx_exc_list
, skb
);
2367 tasklet_schedule(&local
->sta_tx_exc_tasklet
);
2371 if (txdesc
.sw_support
)
2372 hostap_tx_callback(local
, &txdesc
, 0, payload
);
2378 PDEBUG(DEBUG_EXTRA
, "%s: TXEXC - status=0x%04x (%s%s%s%s)"
2379 " tx_control=%04x\n",
2381 status
& HFA384X_TX_STATUS_RETRYERR
? "[RetryErr]" : "",
2382 status
& HFA384X_TX_STATUS_AGEDERR
? "[AgedErr]" : "",
2383 status
& HFA384X_TX_STATUS_DISCON
? "[Discon]" : "",
2384 status
& HFA384X_TX_STATUS_FORMERR
? "[FormErr]" : "",
2385 le16_to_cpu(txdesc
.tx_control
));
2387 fc
= le16_to_cpu(txdesc
.frame_control
);
2388 PDEBUG(DEBUG_EXTRA
, " retry_count=%d tx_rate=%d fc=0x%04x "
2389 "(%s%s%s::%d%s%s)\n",
2390 txdesc
.retry_count
, txdesc
.tx_rate
, fc
,
2391 ieee80211_is_mgmt(txdesc
.frame_control
) ? "Mgmt" : "",
2392 ieee80211_is_ctl(txdesc
.frame_control
) ? "Ctrl" : "",
2393 ieee80211_is_data(txdesc
.frame_control
) ? "Data" : "",
2394 (fc
& IEEE80211_FCTL_STYPE
) >> 4,
2395 ieee80211_has_tods(txdesc
.frame_control
) ? " ToDS" : "",
2396 ieee80211_has_fromds(txdesc
.frame_control
) ? " FromDS" : "");
2397 PDEBUG(DEBUG_EXTRA
, " A1=%pM A2=%pM A3=%pM A4=%pM\n",
2398 txdesc
.addr1
, txdesc
.addr2
,
2399 txdesc
.addr3
, txdesc
.addr4
);
2403 /* Called only as a tasklet (software IRQ) */
2404 static void hostap_info_tasklet(unsigned long data
)
2406 local_info_t
*local
= (local_info_t
*) data
;
2407 struct sk_buff
*skb
;
2409 while ((skb
= skb_dequeue(&local
->info_list
)) != NULL
) {
2410 hostap_info_process(local
, skb
);
2416 /* Called only as a tasklet (software IRQ) */
2417 static void prism2_info(local_info_t
*local
)
2419 struct net_device
*dev
= local
->dev
;
2422 struct hfa384x_info_frame info
;
2423 struct sk_buff
*skb
;
2425 fid
= HFA384X_INW(HFA384X_INFOFID_OFF
);
2427 spin_lock(&local
->baplock
);
2428 res
= hfa384x_setup_bap(dev
, BAP0
, fid
, 0);
2430 res
= hfa384x_from_bap(dev
, BAP0
, &info
, sizeof(info
));
2432 spin_unlock(&local
->baplock
);
2433 printk(KERN_DEBUG
"Could not get info frame (fid=0x%04x)\n",
2435 if (res
== -ETIMEDOUT
) {
2436 schedule_work(&local
->reset_queue
);
2441 left
= (le16_to_cpu(info
.len
) - 1) * 2;
2443 if (info
.len
& cpu_to_le16(0x8000) || info
.len
== 0 || left
> 2060) {
2444 /* data register seems to give 0x8000 in some error cases even
2445 * though busy bit is not set in offset register;
2446 * in addition, length must be at least 1 due to type field */
2447 spin_unlock(&local
->baplock
);
2448 printk(KERN_DEBUG
"%s: Received info frame with invalid "
2449 "length 0x%04x (type 0x%04x)\n", dev
->name
,
2450 le16_to_cpu(info
.len
), le16_to_cpu(info
.type
));
2454 skb
= dev_alloc_skb(sizeof(info
) + left
);
2456 spin_unlock(&local
->baplock
);
2457 printk(KERN_DEBUG
"%s: Could not allocate skb for info "
2458 "frame\n", dev
->name
);
2462 memcpy(skb_put(skb
, sizeof(info
)), &info
, sizeof(info
));
2463 if (left
> 0 && hfa384x_from_bap(dev
, BAP0
, skb_put(skb
, left
), left
))
2465 spin_unlock(&local
->baplock
);
2466 printk(KERN_WARNING
"%s: Info frame read failed (fid=0x%04x, "
2467 "len=0x%04x, type=0x%04x\n", dev
->name
, fid
,
2468 le16_to_cpu(info
.len
), le16_to_cpu(info
.type
));
2472 spin_unlock(&local
->baplock
);
2474 skb_queue_tail(&local
->info_list
, skb
);
2475 tasklet_schedule(&local
->info_tasklet
);
2478 HFA384X_OUTW(HFA384X_EV_INFO
, HFA384X_EVACK_OFF
);
2482 /* Called only as a tasklet (software IRQ) */
2483 static void hostap_bap_tasklet(unsigned long data
)
2485 local_info_t
*local
= (local_info_t
*) data
;
2486 struct net_device
*dev
= local
->dev
;
2490 if (local
->func
->card_present
&& !local
->func
->card_present(local
))
2493 set_bit(HOSTAP_BITS_BAP_TASKLET
, &local
->bits
);
2495 /* Process all pending BAP events without generating new interrupts
2497 while (frames
-- > 0) {
2498 ev
= HFA384X_INW(HFA384X_EVSTAT_OFF
);
2499 if (ev
== 0xffff || !(ev
& HFA384X_BAP0_EVENTS
))
2501 if (ev
& HFA384X_EV_RX
)
2503 if (ev
& HFA384X_EV_INFO
)
2505 if (ev
& HFA384X_EV_TX
)
2506 prism2_tx_ev(local
);
2507 if (ev
& HFA384X_EV_TXEXC
)
2508 prism2_txexc(local
);
2511 set_bit(HOSTAP_BITS_BAP_TASKLET2
, &local
->bits
);
2512 clear_bit(HOSTAP_BITS_BAP_TASKLET
, &local
->bits
);
2514 /* Enable interrupts for new BAP events */
2515 hfa384x_events_all(dev
);
2516 clear_bit(HOSTAP_BITS_BAP_TASKLET2
, &local
->bits
);
2520 /* Called only from hardware IRQ */
2521 static void prism2_infdrop(struct net_device
*dev
)
2523 static unsigned long last_inquire
= 0;
2525 PDEBUG(DEBUG_EXTRA
, "%s: INFDROP event\n", dev
->name
);
2527 /* some firmware versions seem to get stuck with
2528 * full CommTallies in high traffic load cases; every
2529 * packet will then cause INFDROP event and CommTallies
2530 * info frame will not be sent automatically. Try to
2531 * get out of this state by inquiring CommTallies. */
2532 if (!last_inquire
|| time_after(jiffies
, last_inquire
+ HZ
)) {
2533 hfa384x_cmd_callback(dev
, HFA384X_CMDCODE_INQUIRE
,
2534 HFA384X_INFO_COMMTALLIES
, NULL
, 0);
2535 last_inquire
= jiffies
;
2540 /* Called only from hardware IRQ */
2541 static void prism2_ev_tick(struct net_device
*dev
)
2543 struct hostap_interface
*iface
;
2544 local_info_t
*local
;
2546 static int prev_stuck
= 0;
2548 iface
= netdev_priv(dev
);
2549 local
= iface
->local
;
2551 if (time_after(jiffies
, local
->last_tick_timer
+ 5 * HZ
) &&
2552 local
->last_tick_timer
) {
2553 evstat
= HFA384X_INW(HFA384X_EVSTAT_OFF
);
2554 inten
= HFA384X_INW(HFA384X_INTEN_OFF
);
2556 printk(KERN_INFO
"%s: SW TICK stuck? "
2557 "bits=0x%lx EvStat=%04x IntEn=%04x\n",
2558 dev
->name
, local
->bits
, evstat
, inten
);
2560 local
->sw_tick_stuck
++;
2561 if ((evstat
& HFA384X_BAP0_EVENTS
) &&
2562 (inten
& HFA384X_BAP0_EVENTS
)) {
2563 printk(KERN_INFO
"%s: trying to recover from IRQ "
2564 "hang\n", dev
->name
);
2565 hfa384x_events_no_bap0(dev
);
2573 /* Called only from hardware IRQ */
2574 static void prism2_check_magic(local_info_t
*local
)
2576 /* at least PCI Prism2.5 with bus mastering seems to sometimes
2577 * return 0x0000 in SWSUPPORT0 for unknown reason, but re-reading the
2578 * register once or twice seems to get the correct value.. PCI cards
2579 * cannot anyway be removed during normal operation, so there is not
2580 * really any need for this verification with them. */
2583 #ifndef final_version
2584 static unsigned long last_magic_err
= 0;
2585 struct net_device
*dev
= local
->dev
;
2587 if (HFA384X_INW(HFA384X_SWSUPPORT0_OFF
) != HFA384X_MAGIC
) {
2588 if (!local
->hw_ready
)
2590 HFA384X_OUTW(0xffff, HFA384X_EVACK_OFF
);
2591 if (time_after(jiffies
, last_magic_err
+ 10 * HZ
)) {
2592 printk("%s: Interrupt, but SWSUPPORT0 does not match: "
2593 "%04X != %04X - card removed?\n", dev
->name
,
2594 HFA384X_INW(HFA384X_SWSUPPORT0_OFF
),
2596 last_magic_err
= jiffies
;
2597 } else if (net_ratelimit()) {
2598 printk(KERN_DEBUG
"%s: interrupt - SWSUPPORT0=%04x "
2599 "MAGIC=%04x\n", dev
->name
,
2600 HFA384X_INW(HFA384X_SWSUPPORT0_OFF
),
2603 if (HFA384X_INW(HFA384X_SWSUPPORT0_OFF
) != 0xffff)
2604 schedule_work(&local
->reset_queue
);
2607 #endif /* final_version */
2608 #endif /* !PRISM2_PCI */
2612 /* Called only from hardware IRQ */
2613 static irqreturn_t
prism2_interrupt(int irq
, void *dev_id
)
2615 struct net_device
*dev
= dev_id
;
2616 struct hostap_interface
*iface
;
2617 local_info_t
*local
;
2621 iface
= netdev_priv(dev
);
2622 local
= iface
->local
;
2624 /* Detect early interrupt before driver is fully configured */
2625 spin_lock(&local
->irq_init_lock
);
2626 if (!dev
->base_addr
) {
2627 if (net_ratelimit()) {
2628 printk(KERN_DEBUG
"%s: Interrupt, but dev not configured\n",
2631 spin_unlock(&local
->irq_init_lock
);
2634 spin_unlock(&local
->irq_init_lock
);
2636 prism2_io_debug_add(dev
, PRISM2_IO_DEBUG_CMD_INTERRUPT
, 0, 0);
2638 if (local
->func
->card_present
&& !local
->func
->card_present(local
)) {
2639 if (net_ratelimit()) {
2640 printk(KERN_DEBUG
"%s: Interrupt, but dev not OK\n",
2646 prism2_check_magic(local
);
2649 ev
= HFA384X_INW(HFA384X_EVSTAT_OFF
);
2651 if (local
->shutdown
)
2653 HFA384X_OUTW(0xffff, HFA384X_EVACK_OFF
);
2654 printk(KERN_DEBUG
"%s: prism2_interrupt: ev=0xffff\n",
2659 ev
&= HFA384X_INW(HFA384X_INTEN_OFF
);
2663 if (ev
& HFA384X_EV_CMD
) {
2667 /* Above events are needed even before hw is ready, but other
2668 * events should be skipped during initialization. This may
2669 * change for AllocEv if allocate_fid is implemented without
2671 if (!local
->hw_ready
|| local
->hw_resetting
||
2672 !local
->dev_enabled
) {
2673 ev
= HFA384X_INW(HFA384X_EVSTAT_OFF
);
2674 if (ev
& HFA384X_EV_CMD
)
2676 if ((ev
& HFA384X_EVENT_MASK
) == 0)
2678 if (local
->dev_enabled
&& (ev
& ~HFA384X_EV_TICK
) &&
2680 printk(KERN_DEBUG
"%s: prism2_interrupt: hw "
2681 "not ready; skipping events 0x%04x "
2682 "(IntEn=0x%04x)%s%s%s\n",
2684 HFA384X_INW(HFA384X_INTEN_OFF
),
2685 !local
->hw_ready
? " (!hw_ready)" : "",
2686 local
->hw_resetting
?
2687 " (hw_resetting)" : "",
2688 !local
->dev_enabled
?
2689 " (!dev_enabled)" : "");
2691 HFA384X_OUTW(ev
, HFA384X_EVACK_OFF
);
2695 if (ev
& HFA384X_EV_TICK
) {
2696 prism2_ev_tick(dev
);
2697 HFA384X_OUTW(HFA384X_EV_TICK
, HFA384X_EVACK_OFF
);
2700 if (ev
& HFA384X_EV_ALLOC
) {
2701 prism2_alloc_ev(dev
);
2702 HFA384X_OUTW(HFA384X_EV_ALLOC
, HFA384X_EVACK_OFF
);
2705 /* Reading data from the card is quite time consuming, so do it
2706 * in tasklets. TX, TXEXC, RX, and INFO events will be ACKed
2707 * and unmasked after needed data has been read completely. */
2708 if (ev
& HFA384X_BAP0_EVENTS
) {
2709 hfa384x_events_no_bap0(dev
);
2710 tasklet_schedule(&local
->bap_tasklet
);
2713 #ifndef final_version
2714 if (ev
& HFA384X_EV_WTERR
) {
2715 PDEBUG(DEBUG_EXTRA
, "%s: WTERR event\n", dev
->name
);
2716 HFA384X_OUTW(HFA384X_EV_WTERR
, HFA384X_EVACK_OFF
);
2718 #endif /* final_version */
2720 if (ev
& HFA384X_EV_INFDROP
) {
2721 prism2_infdrop(dev
);
2722 HFA384X_OUTW(HFA384X_EV_INFDROP
, HFA384X_EVACK_OFF
);
2727 if (events
>= PRISM2_MAX_INTERRUPT_EVENTS
) {
2728 PDEBUG(DEBUG_EXTRA
, "prism2_interrupt: >%d events "
2729 "(EvStat=0x%04x)\n",
2730 PRISM2_MAX_INTERRUPT_EVENTS
,
2731 HFA384X_INW(HFA384X_EVSTAT_OFF
));
2735 prism2_io_debug_add(dev
, PRISM2_IO_DEBUG_CMD_INTERRUPT
, 0, 1);
2736 return IRQ_RETVAL(events
);
2740 static void prism2_check_sta_fw_version(local_info_t
*local
)
2742 struct hfa384x_comp_ident comp
;
2743 int id
, variant
, major
, minor
;
2745 if (hfa384x_get_rid(local
->dev
, HFA384X_RID_STAID
,
2746 &comp
, sizeof(comp
), 1) < 0)
2750 id
= le16_to_cpu(comp
.id
);
2751 if (id
!= HFA384X_COMP_ID_STA
) {
2752 if (id
== HFA384X_COMP_ID_FW_AP
)
2757 major
= __le16_to_cpu(comp
.major
);
2758 minor
= __le16_to_cpu(comp
.minor
);
2759 variant
= __le16_to_cpu(comp
.variant
);
2760 local
->sta_fw_ver
= PRISM2_FW_VER(major
, minor
, variant
);
2762 /* Station firmware versions before 1.4.x seem to have a bug in
2763 * firmware-based WEP encryption when using Host AP mode, so use
2764 * host_encrypt as a default for them. Firmware version 1.4.9 is the
2765 * first one that has been seen to produce correct encryption, but the
2766 * bug might be fixed before that (although, at least 1.4.2 is broken).
2768 local
->fw_encrypt_ok
= local
->sta_fw_ver
>= PRISM2_FW_VER(1,4,9);
2770 if (local
->iw_mode
== IW_MODE_MASTER
&& !local
->host_encrypt
&&
2771 !local
->fw_encrypt_ok
) {
2772 printk(KERN_DEBUG
"%s: defaulting to host-based encryption as "
2773 "a workaround for firmware bug in Host AP mode WEP\n",
2775 local
->host_encrypt
= 1;
2778 /* IEEE 802.11 standard compliant WDS frames (4 addresses) were broken
2779 * in station firmware versions before 1.5.x. With these versions, the
2780 * driver uses a workaround with bogus frame format (4th address after
2781 * the payload). This is not compatible with other AP devices. Since
2782 * the firmware bug is fixed in the latest station firmware versions,
2783 * automatically enable standard compliant mode for cards using station
2784 * firmware version 1.5.0 or newer. */
2785 if (local
->sta_fw_ver
>= PRISM2_FW_VER(1,5,0))
2786 local
->wds_type
|= HOSTAP_WDS_STANDARD_FRAME
;
2788 printk(KERN_DEBUG
"%s: defaulting to bogus WDS frame as a "
2789 "workaround for firmware bug in Host AP mode WDS\n",
2793 hostap_check_sta_fw_version(local
->ap
, local
->sta_fw_ver
);
2797 static void hostap_passive_scan(unsigned long data
)
2799 local_info_t
*local
= (local_info_t
*) data
;
2800 struct net_device
*dev
= local
->dev
;
2803 if (local
->passive_scan_interval
<= 0)
2806 if (local
->passive_scan_state
== PASSIVE_SCAN_LISTEN
) {
2809 /* Even though host system does not really know when the WLAN
2810 * MAC is sending frames, try to avoid changing channels for
2811 * passive scanning when a host-generated frame is being
2813 if (test_bit(HOSTAP_BITS_TRANSMIT
, &local
->bits
)) {
2814 printk(KERN_DEBUG
"%s: passive scan detected pending "
2815 "TX - delaying\n", dev
->name
);
2816 local
->passive_scan_timer
.expires
= jiffies
+ HZ
/ 10;
2817 add_timer(&local
->passive_scan_timer
);
2822 local
->passive_scan_channel
++;
2823 if (local
->passive_scan_channel
> 14)
2824 local
->passive_scan_channel
= 1;
2826 } while (!(local
->channel_mask
&
2827 (1 << (local
->passive_scan_channel
- 1))) &&
2830 if (max_tries
== 0) {
2831 printk(KERN_INFO
"%s: no allowed passive scan channels"
2832 " found\n", dev
->name
);
2836 printk(KERN_DEBUG
"%s: passive scan channel %d\n",
2837 dev
->name
, local
->passive_scan_channel
);
2838 chan
= local
->passive_scan_channel
;
2839 local
->passive_scan_state
= PASSIVE_SCAN_WAIT
;
2840 local
->passive_scan_timer
.expires
= jiffies
+ HZ
/ 10;
2842 chan
= local
->channel
;
2843 local
->passive_scan_state
= PASSIVE_SCAN_LISTEN
;
2844 local
->passive_scan_timer
.expires
= jiffies
+
2845 local
->passive_scan_interval
* HZ
;
2848 if (hfa384x_cmd_callback(dev
, HFA384X_CMDCODE_TEST
|
2849 (HFA384X_TEST_CHANGE_CHANNEL
<< 8),
2851 printk(KERN_ERR
"%s: passive scan channel set %d "
2852 "failed\n", dev
->name
, chan
);
2854 add_timer(&local
->passive_scan_timer
);
2858 /* Called only as a scheduled task when communications quality values should
2860 static void handle_comms_qual_update(struct work_struct
*work
)
2862 local_info_t
*local
=
2863 container_of(work
, local_info_t
, comms_qual_update
);
2864 prism2_update_comms_qual(local
->dev
);
2868 /* Software watchdog - called as a timer. Hardware interrupt (Tick event) is
2869 * used to monitor that local->last_tick_timer is being updated. If not,
2870 * interrupt busy-loop is assumed and driver tries to recover by masking out
2872 static void hostap_tick_timer(unsigned long data
)
2874 static unsigned long last_inquire
= 0;
2875 local_info_t
*local
= (local_info_t
*) data
;
2876 local
->last_tick_timer
= jiffies
;
2878 /* Inquire CommTallies every 10 seconds to keep the statistics updated
2879 * more often during low load and when using 32-bit tallies. */
2880 if ((!last_inquire
|| time_after(jiffies
, last_inquire
+ 10 * HZ
)) &&
2881 !local
->hw_downloading
&& local
->hw_ready
&&
2882 !local
->hw_resetting
&& local
->dev_enabled
) {
2883 hfa384x_cmd_callback(local
->dev
, HFA384X_CMDCODE_INQUIRE
,
2884 HFA384X_INFO_COMMTALLIES
, NULL
, 0);
2885 last_inquire
= jiffies
;
2888 if ((local
->last_comms_qual_update
== 0 ||
2889 time_after(jiffies
, local
->last_comms_qual_update
+ 10 * HZ
)) &&
2890 (local
->iw_mode
== IW_MODE_INFRA
||
2891 local
->iw_mode
== IW_MODE_ADHOC
)) {
2892 schedule_work(&local
->comms_qual_update
);
2895 local
->tick_timer
.expires
= jiffies
+ 2 * HZ
;
2896 add_timer(&local
->tick_timer
);
2900 #ifndef PRISM2_NO_PROCFS_DEBUG
2901 static int prism2_registers_proc_read(char *page
, char **start
, off_t off
,
2902 int count
, int *eof
, void *data
)
2905 local_info_t
*local
= (local_info_t
*) data
;
2912 #define SHOW_REG(n) \
2913 p += sprintf(p, #n "=%04x\n", hfa384x_read_reg(local->dev, HFA384X_##n##_OFF))
2931 SHOW_REG(TXCOMPLFID
);
2932 SHOW_REG(SWSUPPORT0
);
2933 SHOW_REG(SWSUPPORT1
);
2934 SHOW_REG(SWSUPPORT2
);
2938 /* Do not read data registers, because they change the state of the
2939 * MAC (offset += 2) */
2940 /* SHOW_REG(DATA0); */
2941 /* SHOW_REG(DATA1); */
2943 SHOW_REG(AUXOFFSET
);
2944 /* SHOW_REG(AUXDATA); */
2948 SHOW_REG(PCI_M0_ADDRH
);
2949 SHOW_REG(PCI_M0_ADDRL
);
2950 SHOW_REG(PCI_M0_LEN
);
2951 SHOW_REG(PCI_M0_CTL
);
2952 SHOW_REG(PCI_STATUS
);
2953 SHOW_REG(PCI_M1_ADDRH
);
2954 SHOW_REG(PCI_M1_ADDRL
);
2955 SHOW_REG(PCI_M1_LEN
);
2956 SHOW_REG(PCI_M1_CTL
);
2957 #endif /* PRISM2_PCI */
2961 #endif /* PRISM2_NO_PROCFS_DEBUG */
2964 struct set_tim_data
{
2965 struct list_head list
;
2970 static int prism2_set_tim(struct net_device
*dev
, int aid
, int set
)
2972 struct list_head
*ptr
;
2973 struct set_tim_data
*new_entry
;
2974 struct hostap_interface
*iface
;
2975 local_info_t
*local
;
2977 iface
= netdev_priv(dev
);
2978 local
= iface
->local
;
2980 new_entry
= kzalloc(sizeof(*new_entry
), GFP_ATOMIC
);
2981 if (new_entry
== NULL
) {
2982 printk(KERN_DEBUG
"%s: prism2_set_tim: kmalloc failed\n",
2986 new_entry
->aid
= aid
;
2987 new_entry
->set
= set
;
2989 spin_lock_bh(&local
->set_tim_lock
);
2990 list_for_each(ptr
, &local
->set_tim_list
) {
2991 struct set_tim_data
*entry
=
2992 list_entry(ptr
, struct set_tim_data
, list
);
2993 if (entry
->aid
== aid
) {
2994 PDEBUG(DEBUG_PS2
, "%s: prism2_set_tim: aid=%d "
2996 local
->dev
->name
, aid
, entry
->set
, set
);
3004 list_add_tail(&new_entry
->list
, &local
->set_tim_list
);
3005 spin_unlock_bh(&local
->set_tim_lock
);
3007 schedule_work(&local
->set_tim_queue
);
3013 static void handle_set_tim_queue(struct work_struct
*work
)
3015 local_info_t
*local
= container_of(work
, local_info_t
, set_tim_queue
);
3016 struct set_tim_data
*entry
;
3021 spin_lock_bh(&local
->set_tim_lock
);
3022 if (!list_empty(&local
->set_tim_list
)) {
3023 entry
= list_entry(local
->set_tim_list
.next
,
3024 struct set_tim_data
, list
);
3025 list_del(&entry
->list
);
3027 spin_unlock_bh(&local
->set_tim_lock
);
3031 PDEBUG(DEBUG_PS2
, "%s: handle_set_tim_queue: aid=%d set=%d\n",
3032 local
->dev
->name
, entry
->aid
, entry
->set
);
3037 if (hostap_set_word(local
->dev
, HFA384X_RID_CNFTIMCTRL
, val
)) {
3038 printk(KERN_DEBUG
"%s: set_tim failed (aid=%d "
3040 local
->dev
->name
, entry
->aid
, entry
->set
);
3048 static void prism2_clear_set_tim_queue(local_info_t
*local
)
3050 struct list_head
*ptr
, *n
;
3052 list_for_each_safe(ptr
, n
, &local
->set_tim_list
) {
3053 struct set_tim_data
*entry
;
3054 entry
= list_entry(ptr
, struct set_tim_data
, list
);
3055 list_del(&entry
->list
);
3062 * HostAP uses two layers of net devices, where the inner
3063 * layer gets called all the time from the outer layer.
3064 * This is a natural nesting, which needs a split lock type.
3066 static struct lock_class_key hostap_netdev_xmit_lock_key
;
3067 static struct lock_class_key hostap_netdev_addr_lock_key
;
3069 static void prism2_set_lockdep_class_one(struct net_device
*dev
,
3070 struct netdev_queue
*txq
,
3073 lockdep_set_class(&txq
->_xmit_lock
,
3074 &hostap_netdev_xmit_lock_key
);
3077 static void prism2_set_lockdep_class(struct net_device
*dev
)
3079 lockdep_set_class(&dev
->addr_list_lock
,
3080 &hostap_netdev_addr_lock_key
);
3081 netdev_for_each_tx_queue(dev
, prism2_set_lockdep_class_one
, NULL
);
3084 static struct net_device
*
3085 prism2_init_local_data(struct prism2_helper_functions
*funcs
, int card_idx
,
3086 struct device
*sdev
)
3088 struct net_device
*dev
;
3089 struct hostap_interface
*iface
;
3090 struct local_info
*local
;
3096 len
= strlen(dev_template
);
3097 if (len
>= IFNAMSIZ
|| strstr(dev_template
, "%d") == NULL
) {
3098 printk(KERN_WARNING
"hostap: Invalid dev_template='%s'\n",
3103 len
= sizeof(struct hostap_interface
) +
3104 3 + sizeof(struct local_info
) +
3105 3 + sizeof(struct ap_data
);
3107 dev
= alloc_etherdev(len
);
3111 iface
= netdev_priv(dev
);
3112 local
= (struct local_info
*) ((((long) (iface
+ 1)) + 3) & ~3);
3113 local
->ap
= (struct ap_data
*) ((((long) (local
+ 1)) + 3) & ~3);
3114 local
->dev
= iface
->dev
= dev
;
3115 iface
->local
= local
;
3116 iface
->type
= HOSTAP_INTERFACE_MASTER
;
3117 INIT_LIST_HEAD(&local
->hostap_interfaces
);
3119 local
->hw_module
= THIS_MODULE
;
3121 #ifdef PRISM2_IO_DEBUG
3122 local
->io_debug_enabled
= 1;
3123 #endif /* PRISM2_IO_DEBUG */
3125 local
->func
= funcs
;
3126 local
->func
->cmd
= hfa384x_cmd
;
3127 local
->func
->read_regs
= hfa384x_read_regs
;
3128 local
->func
->get_rid
= hfa384x_get_rid
;
3129 local
->func
->set_rid
= hfa384x_set_rid
;
3130 local
->func
->hw_enable
= prism2_hw_enable
;
3131 local
->func
->hw_config
= prism2_hw_config
;
3132 local
->func
->hw_reset
= prism2_hw_reset
;
3133 local
->func
->hw_shutdown
= prism2_hw_shutdown
;
3134 local
->func
->reset_port
= prism2_reset_port
;
3135 local
->func
->schedule_reset
= prism2_schedule_reset
;
3136 #ifdef PRISM2_DOWNLOAD_SUPPORT
3137 local
->func
->read_aux
= prism2_download_aux_dump
;
3138 local
->func
->download
= prism2_download
;
3139 #endif /* PRISM2_DOWNLOAD_SUPPORT */
3140 local
->func
->tx
= prism2_tx_80211
;
3141 local
->func
->set_tim
= prism2_set_tim
;
3142 local
->func
->need_tx_headroom
= 0; /* no need to add txdesc in
3143 * skb->data (FIX: maybe for DMA bus
3148 rwlock_init(&local
->iface_lock
);
3149 spin_lock_init(&local
->txfidlock
);
3150 spin_lock_init(&local
->cmdlock
);
3151 spin_lock_init(&local
->baplock
);
3152 spin_lock_init(&local
->lock
);
3153 spin_lock_init(&local
->irq_init_lock
);
3154 mutex_init(&local
->rid_bap_mtx
);
3156 if (card_idx
< 0 || card_idx
>= MAX_PARM_DEVICES
)
3158 local
->card_idx
= card_idx
;
3160 len
= strlen(essid
);
3161 memcpy(local
->essid
, essid
,
3162 len
> MAX_SSID_LEN
? MAX_SSID_LEN
: len
);
3163 local
->essid
[MAX_SSID_LEN
] = '\0';
3164 i
= GET_INT_PARM(iw_mode
, card_idx
);
3165 if ((i
>= IW_MODE_ADHOC
&& i
<= IW_MODE_REPEAT
) ||
3166 i
== IW_MODE_MONITOR
) {
3169 printk(KERN_WARNING
"prism2: Unknown iw_mode %d; using "
3170 "IW_MODE_MASTER\n", i
);
3171 local
->iw_mode
= IW_MODE_MASTER
;
3173 local
->channel
= GET_INT_PARM(channel
, card_idx
);
3174 local
->beacon_int
= GET_INT_PARM(beacon_int
, card_idx
);
3175 local
->dtim_period
= GET_INT_PARM(dtim_period
, card_idx
);
3176 local
->wds_max_connections
= 16;
3177 local
->tx_control
= HFA384X_TX_CTRL_FLAGS
;
3178 local
->manual_retry_count
= -1;
3179 local
->rts_threshold
= 2347;
3180 local
->fragm_threshold
= 2346;
3181 local
->rssi_to_dBm
= 100; /* default; to be overriden by
3182 * cnfDbmAdjust, if available */
3183 local
->auth_algs
= PRISM2_AUTH_OPEN
| PRISM2_AUTH_SHARED_KEY
;
3184 local
->sram_type
= -1;
3185 local
->scan_channel_mask
= 0xffff;
3186 local
->monitor_type
= PRISM2_MONITOR_RADIOTAP
;
3188 /* Initialize task queue structures */
3189 INIT_WORK(&local
->reset_queue
, handle_reset_queue
);
3190 INIT_WORK(&local
->set_multicast_list_queue
,
3191 hostap_set_multicast_list_queue
);
3193 INIT_WORK(&local
->set_tim_queue
, handle_set_tim_queue
);
3194 INIT_LIST_HEAD(&local
->set_tim_list
);
3195 spin_lock_init(&local
->set_tim_lock
);
3197 INIT_WORK(&local
->comms_qual_update
, handle_comms_qual_update
);
3199 /* Initialize tasklets for handling hardware IRQ related operations
3200 * outside hw IRQ handler */
3201 #define HOSTAP_TASKLET_INIT(q, f, d) \
3202 do { memset((q), 0, sizeof(*(q))); (q)->func = (f); (q)->data = (d); } \
3204 HOSTAP_TASKLET_INIT(&local
->bap_tasklet
, hostap_bap_tasklet
,
3205 (unsigned long) local
);
3207 HOSTAP_TASKLET_INIT(&local
->info_tasklet
, hostap_info_tasklet
,
3208 (unsigned long) local
);
3209 hostap_info_init(local
);
3211 HOSTAP_TASKLET_INIT(&local
->rx_tasklet
,
3212 hostap_rx_tasklet
, (unsigned long) local
);
3213 skb_queue_head_init(&local
->rx_list
);
3215 HOSTAP_TASKLET_INIT(&local
->sta_tx_exc_tasklet
,
3216 hostap_sta_tx_exc_tasklet
, (unsigned long) local
);
3217 skb_queue_head_init(&local
->sta_tx_exc_list
);
3219 INIT_LIST_HEAD(&local
->cmd_queue
);
3220 init_waitqueue_head(&local
->hostscan_wq
);
3222 lib80211_crypt_info_init(&local
->crypt_info
, dev
->name
, &local
->lock
);
3224 init_timer(&local
->passive_scan_timer
);
3225 local
->passive_scan_timer
.data
= (unsigned long) local
;
3226 local
->passive_scan_timer
.function
= hostap_passive_scan
;
3228 init_timer(&local
->tick_timer
);
3229 local
->tick_timer
.data
= (unsigned long) local
;
3230 local
->tick_timer
.function
= hostap_tick_timer
;
3231 local
->tick_timer
.expires
= jiffies
+ 2 * HZ
;
3232 add_timer(&local
->tick_timer
);
3234 INIT_LIST_HEAD(&local
->bss_list
);
3236 hostap_setup_dev(dev
, local
, HOSTAP_INTERFACE_MASTER
);
3238 dev
->type
= ARPHRD_IEEE80211
;
3239 dev
->header_ops
= &hostap_80211_ops
;
3242 ret
= dev_alloc_name(dev
, "wifi%d");
3243 SET_NETDEV_DEV(dev
, sdev
);
3245 ret
= register_netdevice(dev
);
3247 prism2_set_lockdep_class(dev
);
3250 printk(KERN_WARNING
"%s: register netdevice failed!\n",
3254 printk(KERN_INFO
"%s: Registered netdevice %s\n", dev_info
, dev
->name
);
3256 hostap_init_data(local
);
3265 static int hostap_hw_ready(struct net_device
*dev
)
3267 struct hostap_interface
*iface
;
3268 struct local_info
*local
;
3270 iface
= netdev_priv(dev
);
3271 local
= iface
->local
;
3272 local
->ddev
= hostap_add_interface(local
, HOSTAP_INTERFACE_MAIN
, 0,
3276 if (local
->iw_mode
== IW_MODE_INFRA
||
3277 local
->iw_mode
== IW_MODE_ADHOC
) {
3278 netif_carrier_off(local
->dev
);
3279 netif_carrier_off(local
->ddev
);
3281 hostap_init_proc(local
);
3282 #ifndef PRISM2_NO_PROCFS_DEBUG
3283 create_proc_read_entry("registers", 0, local
->proc
,
3284 prism2_registers_proc_read
, local
);
3285 #endif /* PRISM2_NO_PROCFS_DEBUG */
3286 hostap_init_ap_proc(local
);
3294 static void prism2_free_local_data(struct net_device
*dev
)
3296 struct hostap_tx_callback_info
*tx_cb
, *tx_cb_prev
;
3298 struct hostap_interface
*iface
;
3299 struct local_info
*local
;
3300 struct list_head
*ptr
, *n
;
3305 iface
= netdev_priv(dev
);
3306 local
= iface
->local
;
3308 /* Unregister all netdevs before freeing local data. */
3309 list_for_each_safe(ptr
, n
, &local
->hostap_interfaces
) {
3310 iface
= list_entry(ptr
, struct hostap_interface
, list
);
3311 if (iface
->type
== HOSTAP_INTERFACE_MASTER
) {
3312 /* special handling for this interface below */
3315 hostap_remove_interface(iface
->dev
, 0, 1);
3318 unregister_netdev(local
->dev
);
3320 flush_scheduled_work();
3322 lib80211_crypt_info_free(&local
->crypt_info
);
3324 if (timer_pending(&local
->passive_scan_timer
))
3325 del_timer(&local
->passive_scan_timer
);
3327 if (timer_pending(&local
->tick_timer
))
3328 del_timer(&local
->tick_timer
);
3330 prism2_clear_cmd_queue(local
);
3332 skb_queue_purge(&local
->info_list
);
3333 skb_queue_purge(&local
->rx_list
);
3334 skb_queue_purge(&local
->sta_tx_exc_list
);
3336 if (local
->dev_enabled
)
3337 prism2_callback(local
, PRISM2_CALLBACK_DISABLE
);
3339 if (local
->ap
!= NULL
)
3340 hostap_free_data(local
->ap
);
3342 #ifndef PRISM2_NO_PROCFS_DEBUG
3343 if (local
->proc
!= NULL
)
3344 remove_proc_entry("registers", local
->proc
);
3345 #endif /* PRISM2_NO_PROCFS_DEBUG */
3346 hostap_remove_proc(local
);
3348 tx_cb
= local
->tx_callback
;
3349 while (tx_cb
!= NULL
) {
3351 tx_cb
= tx_cb
->next
;
3355 hostap_set_hostapd(local
, 0, 0);
3356 hostap_set_hostapd_sta(local
, 0, 0);
3358 for (i
= 0; i
< PRISM2_FRAG_CACHE_LEN
; i
++) {
3359 if (local
->frag_cache
[i
].skb
!= NULL
)
3360 dev_kfree_skb(local
->frag_cache
[i
].skb
);
3363 #ifdef PRISM2_DOWNLOAD_SUPPORT
3364 prism2_download_free_data(local
->dl_pri
);
3365 prism2_download_free_data(local
->dl_sec
);
3366 #endif /* PRISM2_DOWNLOAD_SUPPORT */
3368 prism2_clear_set_tim_queue(local
);
3370 list_for_each_safe(ptr
, n
, &local
->bss_list
) {
3371 struct hostap_bss_info
*bss
=
3372 list_entry(ptr
, struct hostap_bss_info
, list
);
3377 kfree(local
->last_scan_results
);
3378 kfree(local
->generic_elem
);
3380 free_netdev(local
->dev
);
3384 #if (defined(PRISM2_PCI) && defined(CONFIG_PM)) || defined(PRISM2_PCCARD)
3385 static void prism2_suspend(struct net_device
*dev
)
3387 struct hostap_interface
*iface
;
3388 struct local_info
*local
;
3389 union iwreq_data wrqu
;
3391 iface
= netdev_priv(dev
);
3392 local
= iface
->local
;
3394 /* Send disconnect event, e.g., to trigger reassociation after resume
3395 * if wpa_supplicant is used. */
3396 memset(&wrqu
, 0, sizeof(wrqu
));
3397 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
3398 wireless_send_event(local
->dev
, SIOCGIWAP
, &wrqu
, NULL
);
3400 /* Disable hardware and firmware */
3401 prism2_hw_shutdown(dev
, 0);
3403 #endif /* (PRISM2_PCI && CONFIG_PM) || PRISM2_PCCARD */
3406 /* These might at some point be compiled separately and used as separate
3407 * kernel modules or linked into one */
3408 #ifdef PRISM2_DOWNLOAD_SUPPORT
3409 #include "hostap_download.c"
3410 #endif /* PRISM2_DOWNLOAD_SUPPORT */
3412 #ifdef PRISM2_CALLBACK
3413 /* External hostap_callback.c file can be used to, e.g., blink activity led.
3414 * This can use platform specific code and must define prism2_callback()
3415 * function (if PRISM2_CALLBACK is not defined, these function calls are not
3417 #include "hostap_callback.c"
3418 #endif /* PRISM2_CALLBACK */