1 /* ZD1211 USB-WLAN driver for Linux
3 * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
4 * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
5 * Copyright (C) 2006-2007 Michael Wu <flamingice@sourmilk.net>
6 * Copyright (c) 2007 Luis R. Rodriguez <mcgrof@winlab.rutgers.edu>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include <linux/netdevice.h>
24 #include <linux/etherdevice.h>
25 #include <linux/usb.h>
26 #include <linux/jiffies.h>
27 #include <net/ieee80211_radiotap.h>
32 #include "zd_ieee80211.h"
35 /* This table contains the hardware specific values for the modulation rates. */
36 static const struct ieee80211_rate zd_rates
[] = {
38 .hw_value
= ZD_CCK_RATE_1M
, },
40 .hw_value
= ZD_CCK_RATE_2M
,
41 .hw_value_short
= ZD_CCK_RATE_2M
| ZD_CCK_PREA_SHORT
,
42 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
44 .hw_value
= ZD_CCK_RATE_5_5M
,
45 .hw_value_short
= ZD_CCK_RATE_5_5M
| ZD_CCK_PREA_SHORT
,
46 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
48 .hw_value
= ZD_CCK_RATE_11M
,
49 .hw_value_short
= ZD_CCK_RATE_11M
| ZD_CCK_PREA_SHORT
,
50 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
52 .hw_value
= ZD_OFDM_RATE_6M
,
55 .hw_value
= ZD_OFDM_RATE_9M
,
58 .hw_value
= ZD_OFDM_RATE_12M
,
61 .hw_value
= ZD_OFDM_RATE_18M
,
64 .hw_value
= ZD_OFDM_RATE_24M
,
67 .hw_value
= ZD_OFDM_RATE_36M
,
70 .hw_value
= ZD_OFDM_RATE_48M
,
73 .hw_value
= ZD_OFDM_RATE_54M
,
77 static const struct ieee80211_channel zd_channels
[] = {
78 { .center_freq
= 2412, .hw_value
= 1 },
79 { .center_freq
= 2417, .hw_value
= 2 },
80 { .center_freq
= 2422, .hw_value
= 3 },
81 { .center_freq
= 2427, .hw_value
= 4 },
82 { .center_freq
= 2432, .hw_value
= 5 },
83 { .center_freq
= 2437, .hw_value
= 6 },
84 { .center_freq
= 2442, .hw_value
= 7 },
85 { .center_freq
= 2447, .hw_value
= 8 },
86 { .center_freq
= 2452, .hw_value
= 9 },
87 { .center_freq
= 2457, .hw_value
= 10 },
88 { .center_freq
= 2462, .hw_value
= 11 },
89 { .center_freq
= 2467, .hw_value
= 12 },
90 { .center_freq
= 2472, .hw_value
= 13 },
91 { .center_freq
= 2484, .hw_value
= 14 },
94 static void housekeeping_init(struct zd_mac
*mac
);
95 static void housekeeping_enable(struct zd_mac
*mac
);
96 static void housekeeping_disable(struct zd_mac
*mac
);
98 int zd_mac_preinit_hw(struct ieee80211_hw
*hw
)
102 struct zd_mac
*mac
= zd_hw_mac(hw
);
104 r
= zd_chip_read_mac_addr_fw(&mac
->chip
, addr
);
108 SET_IEEE80211_PERM_ADDR(hw
, addr
);
113 int zd_mac_init_hw(struct ieee80211_hw
*hw
)
116 struct zd_mac
*mac
= zd_hw_mac(hw
);
117 struct zd_chip
*chip
= &mac
->chip
;
118 u8 default_regdomain
;
120 r
= zd_chip_enable_int(chip
);
123 r
= zd_chip_init_hw(chip
);
127 ZD_ASSERT(!irqs_disabled());
129 r
= zd_read_regdomain(chip
, &default_regdomain
);
132 spin_lock_irq(&mac
->lock
);
133 mac
->regdomain
= mac
->default_regdomain
= default_regdomain
;
134 spin_unlock_irq(&mac
->lock
);
136 /* We must inform the device that we are doing encryption/decryption in
137 * software at the moment. */
138 r
= zd_set_encryption_type(chip
, ENC_SNIFFER
);
142 zd_geo_init(hw
, mac
->regdomain
);
146 zd_chip_disable_int(chip
);
151 void zd_mac_clear(struct zd_mac
*mac
)
153 flush_workqueue(zd_workqueue
);
154 zd_chip_clear(&mac
->chip
);
155 ZD_ASSERT(!spin_is_locked(&mac
->lock
));
156 ZD_MEMCLEAR(mac
, sizeof(struct zd_mac
));
159 static int set_rx_filter(struct zd_mac
*mac
)
162 u32 filter
= STA_RX_FILTER
;
164 spin_lock_irqsave(&mac
->lock
, flags
);
166 filter
|= RX_FILTER_CTRL
;
167 spin_unlock_irqrestore(&mac
->lock
, flags
);
169 return zd_iowrite32(&mac
->chip
, CR_RX_FILTER
, filter
);
172 static int set_mc_hash(struct zd_mac
*mac
)
174 struct zd_mc_hash hash
;
176 return zd_chip_set_multicast_hash(&mac
->chip
, &hash
);
179 static int zd_op_start(struct ieee80211_hw
*hw
)
181 struct zd_mac
*mac
= zd_hw_mac(hw
);
182 struct zd_chip
*chip
= &mac
->chip
;
183 struct zd_usb
*usb
= &chip
->usb
;
186 if (!usb
->initialized
) {
187 r
= zd_usb_init_hw(usb
);
192 r
= zd_chip_enable_int(chip
);
196 r
= zd_chip_set_basic_rates(chip
, CR_RATES_80211B
| CR_RATES_80211G
);
199 r
= set_rx_filter(mac
);
202 r
= set_mc_hash(mac
);
205 r
= zd_chip_switch_radio_on(chip
);
208 r
= zd_chip_enable_rxtx(chip
);
211 r
= zd_chip_enable_hwint(chip
);
215 housekeeping_enable(mac
);
218 zd_chip_disable_rxtx(chip
);
220 zd_chip_switch_radio_off(chip
);
222 zd_chip_disable_int(chip
);
227 static void zd_op_stop(struct ieee80211_hw
*hw
)
229 struct zd_mac
*mac
= zd_hw_mac(hw
);
230 struct zd_chip
*chip
= &mac
->chip
;
232 struct sk_buff_head
*ack_wait_queue
= &mac
->ack_wait_queue
;
234 /* The order here deliberately is a little different from the open()
235 * method, since we need to make sure there is no opportunity for RX
236 * frames to be processed by mac80211 after we have stopped it.
239 zd_chip_disable_rxtx(chip
);
240 housekeeping_disable(mac
);
241 flush_workqueue(zd_workqueue
);
243 zd_chip_disable_hwint(chip
);
244 zd_chip_switch_radio_off(chip
);
245 zd_chip_disable_int(chip
);
248 while ((skb
= skb_dequeue(ack_wait_queue
)))
249 dev_kfree_skb_any(skb
);
253 * tx_status - reports tx status of a packet if required
254 * @hw - a &struct ieee80211_hw pointer
256 * @flags: extra flags to set in the TX status info
257 * @ackssi: ACK signal strength
258 * @success - True for successfull transmission of the frame
260 * This information calls ieee80211_tx_status_irqsafe() if required by the
261 * control information. It copies the control information into the status
264 * If no status information has been requested, the skb is freed.
266 static void tx_status(struct ieee80211_hw
*hw
, struct sk_buff
*skb
,
267 u32 flags
, int ackssi
, bool success
)
269 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
271 memset(&info
->status
, 0, sizeof(info
->status
));
274 info
->status
.excessive_retries
= 1;
275 info
->flags
|= flags
;
276 info
->status
.ack_signal
= ackssi
;
277 ieee80211_tx_status_irqsafe(hw
, skb
);
281 * zd_mac_tx_failed - callback for failed frames
282 * @dev: the mac80211 wireless device
284 * This function is called if a frame couldn't be succesfully be
285 * transferred. The first frame from the tx queue, will be selected and
286 * reported as error to the upper layers.
288 void zd_mac_tx_failed(struct ieee80211_hw
*hw
)
290 struct sk_buff_head
*q
= &zd_hw_mac(hw
)->ack_wait_queue
;
293 skb
= skb_dequeue(q
);
297 tx_status(hw
, skb
, 0, 0, 0);
301 * zd_mac_tx_to_dev - callback for USB layer
302 * @skb: a &sk_buff pointer
303 * @error: error value, 0 if transmission successful
305 * Informs the MAC layer that the frame has successfully transferred to the
306 * device. If an ACK is required and the transfer to the device has been
307 * successful, the packets are put on the @ack_wait_queue with
308 * the control set removed.
310 void zd_mac_tx_to_dev(struct sk_buff
*skb
, int error
)
312 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
313 struct ieee80211_hw
*hw
= info
->driver_data
[0];
315 skb_pull(skb
, sizeof(struct zd_ctrlset
));
316 if (unlikely(error
||
317 (info
->flags
& IEEE80211_TX_CTL_NO_ACK
))) {
318 tx_status(hw
, skb
, 0, 0, !error
);
320 struct sk_buff_head
*q
=
321 &zd_hw_mac(hw
)->ack_wait_queue
;
323 skb_queue_tail(q
, skb
);
324 while (skb_queue_len(q
) > ZD_MAC_MAX_ACK_WAITERS
)
325 zd_mac_tx_failed(hw
);
329 static int zd_calc_tx_length_us(u8
*service
, u8 zd_rate
, u16 tx_length
)
331 /* ZD_PURE_RATE() must be used to remove the modulation type flag of
332 * the zd-rate values.
334 static const u8 rate_divisor
[] = {
335 [ZD_PURE_RATE(ZD_CCK_RATE_1M
)] = 1,
336 [ZD_PURE_RATE(ZD_CCK_RATE_2M
)] = 2,
337 /* Bits must be doubled. */
338 [ZD_PURE_RATE(ZD_CCK_RATE_5_5M
)] = 11,
339 [ZD_PURE_RATE(ZD_CCK_RATE_11M
)] = 11,
340 [ZD_PURE_RATE(ZD_OFDM_RATE_6M
)] = 6,
341 [ZD_PURE_RATE(ZD_OFDM_RATE_9M
)] = 9,
342 [ZD_PURE_RATE(ZD_OFDM_RATE_12M
)] = 12,
343 [ZD_PURE_RATE(ZD_OFDM_RATE_18M
)] = 18,
344 [ZD_PURE_RATE(ZD_OFDM_RATE_24M
)] = 24,
345 [ZD_PURE_RATE(ZD_OFDM_RATE_36M
)] = 36,
346 [ZD_PURE_RATE(ZD_OFDM_RATE_48M
)] = 48,
347 [ZD_PURE_RATE(ZD_OFDM_RATE_54M
)] = 54,
350 u32 bits
= (u32
)tx_length
* 8;
353 divisor
= rate_divisor
[ZD_PURE_RATE(zd_rate
)];
358 case ZD_CCK_RATE_5_5M
:
359 bits
= (2*bits
) + 10; /* round up to the next integer */
361 case ZD_CCK_RATE_11M
:
364 *service
&= ~ZD_PLCP_SERVICE_LENGTH_EXTENSION
;
365 if (0 < t
&& t
<= 3) {
366 *service
|= ZD_PLCP_SERVICE_LENGTH_EXTENSION
;
369 bits
+= 10; /* round up to the next integer */
376 static void cs_set_control(struct zd_mac
*mac
, struct zd_ctrlset
*cs
,
377 struct ieee80211_hdr
*header
, u32 flags
)
381 * - if backoff needed, enable bit 0
382 * - if burst (backoff not needed) disable bit 0
388 if (flags
& IEEE80211_TX_CTL_FIRST_FRAGMENT
)
389 cs
->control
|= ZD_CS_NEED_RANDOM_BACKOFF
;
392 if (is_multicast_ether_addr(header
->addr1
))
393 cs
->control
|= ZD_CS_MULTICAST
;
396 if (ieee80211_is_pspoll(header
->frame_control
))
397 cs
->control
|= ZD_CS_PS_POLL_FRAME
;
399 if (flags
& IEEE80211_TX_CTL_USE_RTS_CTS
)
400 cs
->control
|= ZD_CS_RTS
;
402 if (flags
& IEEE80211_TX_CTL_USE_CTS_PROTECT
)
403 cs
->control
|= ZD_CS_SELF_CTS
;
405 /* FIXME: Management frame? */
408 static int zd_mac_config_beacon(struct ieee80211_hw
*hw
, struct sk_buff
*beacon
)
410 struct zd_mac
*mac
= zd_hw_mac(hw
);
413 /* 4 more bytes for tail CRC */
414 u32 full_len
= beacon
->len
+ 4;
416 r
= zd_iowrite32(&mac
->chip
, CR_BCN_FIFO_SEMAPHORE
, 0);
419 r
= zd_ioread32(&mac
->chip
, CR_BCN_FIFO_SEMAPHORE
, &tmp
);
424 r
= zd_ioread32(&mac
->chip
, CR_BCN_FIFO_SEMAPHORE
, &tmp
);
427 if ((++j
% 100) == 0) {
428 printk(KERN_ERR
"CR_BCN_FIFO_SEMAPHORE not ready\n");
430 printk(KERN_ERR
"Giving up beacon config.\n");
437 r
= zd_iowrite32(&mac
->chip
, CR_BCN_FIFO
, full_len
- 1);
440 if (zd_chip_is_zd1211b(&mac
->chip
)) {
441 r
= zd_iowrite32(&mac
->chip
, CR_BCN_LENGTH
, full_len
- 1);
446 for (j
= 0 ; j
< beacon
->len
; j
++) {
447 r
= zd_iowrite32(&mac
->chip
, CR_BCN_FIFO
,
448 *((u8
*)(beacon
->data
+ j
)));
453 for (j
= 0; j
< 4; j
++) {
454 r
= zd_iowrite32(&mac
->chip
, CR_BCN_FIFO
, 0x0);
459 r
= zd_iowrite32(&mac
->chip
, CR_BCN_FIFO_SEMAPHORE
, 1);
463 /* 802.11b/g 2.4G CCK 1Mb
464 * 802.11a, not yet implemented, uses different values (see GPL vendor
467 return zd_iowrite32(&mac
->chip
, CR_BCN_PLCP_CFG
, 0x00000400 |
471 static int fill_ctrlset(struct zd_mac
*mac
,
475 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
476 unsigned int frag_len
= skb
->len
+ FCS_LEN
;
477 unsigned int packet_length
;
478 struct ieee80211_rate
*txrate
;
479 struct zd_ctrlset
*cs
= (struct zd_ctrlset
*)
480 skb_push(skb
, sizeof(struct zd_ctrlset
));
481 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
483 ZD_ASSERT(frag_len
<= 0xffff);
485 txrate
= ieee80211_get_tx_rate(mac
->hw
, info
);
487 cs
->modulation
= txrate
->hw_value
;
488 if (info
->flags
& IEEE80211_TX_CTL_SHORT_PREAMBLE
)
489 cs
->modulation
= txrate
->hw_value_short
;
491 cs
->tx_length
= cpu_to_le16(frag_len
);
493 cs_set_control(mac
, cs
, hdr
, info
->flags
);
495 packet_length
= frag_len
+ sizeof(struct zd_ctrlset
) + 10;
496 ZD_ASSERT(packet_length
<= 0xffff);
497 /* ZD1211B: Computing the length difference this way, gives us
498 * flexibility to compute the packet length.
500 cs
->packet_length
= cpu_to_le16(zd_chip_is_zd1211b(&mac
->chip
) ?
501 packet_length
- frag_len
: packet_length
);
505 * - transmit frame length in microseconds
506 * - seems to be derived from frame length
507 * - see Cal_Us_Service() in zdinlinef.h
508 * - if macp->bTxBurstEnable is enabled, then multiply by 4
509 * - bTxBurstEnable is never set in the vendor driver
512 * - "for PLCP configuration"
513 * - always 0 except in some situations at 802.11b 11M
514 * - see line 53 of zdinlinef.h
517 r
= zd_calc_tx_length_us(&cs
->service
, ZD_RATE(cs
->modulation
),
518 le16_to_cpu(cs
->tx_length
));
521 cs
->current_length
= cpu_to_le16(r
);
522 cs
->next_frame_length
= 0;
528 * zd_op_tx - transmits a network frame to the device
530 * @dev: mac80211 hardware device
531 * @skb: socket buffer
532 * @control: the control structure
534 * This function transmit an IEEE 802.11 network frame to the device. The
535 * control block of the skbuff will be initialized. If necessary the incoming
536 * mac80211 queues will be stopped.
538 static int zd_op_tx(struct ieee80211_hw
*hw
, struct sk_buff
*skb
)
540 struct zd_mac
*mac
= zd_hw_mac(hw
);
541 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
544 r
= fill_ctrlset(mac
, skb
);
548 info
->driver_data
[0] = hw
;
550 r
= zd_usb_tx(&mac
->chip
.usb
, skb
);
557 * filter_ack - filters incoming packets for acknowledgements
558 * @dev: the mac80211 device
559 * @rx_hdr: received header
560 * @stats: the status for the received packet
562 * This functions looks for ACK packets and tries to match them with the
563 * frames in the tx queue. If a match is found the frame will be dequeued and
564 * the upper layers is informed about the successful transmission. If
565 * mac80211 queues have been stopped and the number of frames still to be
566 * transmitted is low the queues will be opened again.
568 * Returns 1 if the frame was an ACK, 0 if it was ignored.
570 static int filter_ack(struct ieee80211_hw
*hw
, struct ieee80211_hdr
*rx_hdr
,
571 struct ieee80211_rx_status
*stats
)
574 struct sk_buff_head
*q
;
577 if (!ieee80211_is_ack(rx_hdr
->frame_control
))
580 q
= &zd_hw_mac(hw
)->ack_wait_queue
;
581 spin_lock_irqsave(&q
->lock
, flags
);
582 for (skb
= q
->next
; skb
!= (struct sk_buff
*)q
; skb
= skb
->next
) {
583 struct ieee80211_hdr
*tx_hdr
;
585 tx_hdr
= (struct ieee80211_hdr
*)skb
->data
;
586 if (likely(!compare_ether_addr(tx_hdr
->addr2
, rx_hdr
->addr1
)))
588 __skb_unlink(skb
, q
);
589 tx_status(hw
, skb
, IEEE80211_TX_STAT_ACK
, stats
->signal
, 1);
594 spin_unlock_irqrestore(&q
->lock
, flags
);
598 int zd_mac_rx(struct ieee80211_hw
*hw
, const u8
*buffer
, unsigned int length
)
600 struct zd_mac
*mac
= zd_hw_mac(hw
);
601 struct ieee80211_rx_status stats
;
602 const struct rx_status
*status
;
610 if (length
< ZD_PLCP_HEADER_SIZE
+ 10 /* IEEE80211_1ADDR_LEN */ +
611 FCS_LEN
+ sizeof(struct rx_status
))
614 memset(&stats
, 0, sizeof(stats
));
616 /* Note about pass_failed_fcs and pass_ctrl access below:
617 * mac locking intentionally omitted here, as this is the only unlocked
618 * reader and the only writer is configure_filter. Plus, if there were
619 * any races accessing these variables, it wouldn't really matter.
620 * If mac80211 ever provides a way for us to access filter flags
621 * from outside configure_filter, we could improve on this. Also, this
622 * situation may change once we implement some kind of DMA-into-skb
625 /* Caller has to ensure that length >= sizeof(struct rx_status). */
626 status
= (struct rx_status
*)
627 (buffer
+ (length
- sizeof(struct rx_status
)));
628 if (status
->frame_status
& ZD_RX_ERROR
) {
629 if (mac
->pass_failed_fcs
&&
630 (status
->frame_status
& ZD_RX_CRC32_ERROR
)) {
631 stats
.flag
|= RX_FLAG_FAILED_FCS_CRC
;
638 stats
.freq
= zd_channels
[_zd_chip_get_channel(&mac
->chip
) - 1].center_freq
;
639 stats
.band
= IEEE80211_BAND_2GHZ
;
640 stats
.signal
= status
->signal_strength
;
641 stats
.qual
= zd_rx_qual_percent(buffer
,
642 length
- sizeof(struct rx_status
),
645 rate
= zd_rx_rate(buffer
, status
);
647 /* todo: return index in the big switches in zd_rx_rate instead */
648 for (i
= 0; i
< mac
->band
.n_bitrates
; i
++)
649 if (rate
== mac
->band
.bitrates
[i
].hw_value
)
652 length
-= ZD_PLCP_HEADER_SIZE
+ sizeof(struct rx_status
);
653 buffer
+= ZD_PLCP_HEADER_SIZE
;
655 /* Except for bad frames, filter each frame to see if it is an ACK, in
656 * which case our internal TX tracking is updated. Normally we then
657 * bail here as there's no need to pass ACKs on up to the stack, but
658 * there is also the case where the stack has requested us to pass
659 * control frames on up (pass_ctrl) which we must consider. */
661 filter_ack(hw
, (struct ieee80211_hdr
*)buffer
, &stats
)
665 fc
= *(__le16
*)buffer
;
666 need_padding
= ieee80211_is_data_qos(fc
) ^ ieee80211_has_a4(fc
);
668 skb
= dev_alloc_skb(length
+ (need_padding
? 2 : 0));
672 /* Make sure the the payload data is 4 byte aligned. */
676 memcpy(skb_put(skb
, length
), buffer
, length
);
678 ieee80211_rx_irqsafe(hw
, skb
, &stats
);
682 static int zd_op_add_interface(struct ieee80211_hw
*hw
,
683 struct ieee80211_if_init_conf
*conf
)
685 struct zd_mac
*mac
= zd_hw_mac(hw
);
687 /* using IEEE80211_IF_TYPE_INVALID to indicate no mode selected */
688 if (mac
->type
!= IEEE80211_IF_TYPE_INVALID
)
691 switch (conf
->type
) {
692 case IEEE80211_IF_TYPE_MNTR
:
693 case IEEE80211_IF_TYPE_MESH_POINT
:
694 case IEEE80211_IF_TYPE_STA
:
695 case IEEE80211_IF_TYPE_IBSS
:
696 mac
->type
= conf
->type
;
702 return zd_write_mac_addr(&mac
->chip
, conf
->mac_addr
);
705 static void zd_op_remove_interface(struct ieee80211_hw
*hw
,
706 struct ieee80211_if_init_conf
*conf
)
708 struct zd_mac
*mac
= zd_hw_mac(hw
);
709 mac
->type
= IEEE80211_IF_TYPE_INVALID
;
710 zd_set_beacon_interval(&mac
->chip
, 0);
711 zd_write_mac_addr(&mac
->chip
, NULL
);
714 static int zd_op_config(struct ieee80211_hw
*hw
, struct ieee80211_conf
*conf
)
716 struct zd_mac
*mac
= zd_hw_mac(hw
);
717 return zd_chip_set_channel(&mac
->chip
, conf
->channel
->hw_value
);
720 static int zd_op_config_interface(struct ieee80211_hw
*hw
,
721 struct ieee80211_vif
*vif
,
722 struct ieee80211_if_conf
*conf
)
724 struct zd_mac
*mac
= zd_hw_mac(hw
);
728 if (mac
->type
== IEEE80211_IF_TYPE_MESH_POINT
||
729 mac
->type
== IEEE80211_IF_TYPE_IBSS
) {
731 if (conf
->changed
& IEEE80211_IFCC_BEACON
) {
732 struct sk_buff
*beacon
= ieee80211_beacon_get(hw
, vif
);
736 r
= zd_mac_config_beacon(hw
, beacon
);
739 r
= zd_set_beacon_interval(&mac
->chip
, BCN_MODE_IBSS
|
740 hw
->conf
.beacon_int
);
746 associated
= is_valid_ether_addr(conf
->bssid
);
748 spin_lock_irq(&mac
->lock
);
749 mac
->associated
= associated
;
750 spin_unlock_irq(&mac
->lock
);
752 /* TODO: do hardware bssid filtering */
756 void zd_process_intr(struct work_struct
*work
)
759 struct zd_mac
*mac
= container_of(work
, struct zd_mac
, process_intr
);
761 int_status
= le16_to_cpu(*(__le16
*)(mac
->intr_buffer
+4));
762 if (int_status
& INT_CFG_NEXT_BCN
) {
764 dev_dbg_f(zd_mac_dev(mac
), "INT_CFG_NEXT_BCN\n");
766 dev_dbg_f(zd_mac_dev(mac
), "Unsupported interrupt\n");
768 zd_chip_enable_hwint(&mac
->chip
);
772 static void set_multicast_hash_handler(struct work_struct
*work
)
775 container_of(work
, struct zd_mac
, set_multicast_hash_work
);
776 struct zd_mc_hash hash
;
778 spin_lock_irq(&mac
->lock
);
779 hash
= mac
->multicast_hash
;
780 spin_unlock_irq(&mac
->lock
);
782 zd_chip_set_multicast_hash(&mac
->chip
, &hash
);
785 static void set_rx_filter_handler(struct work_struct
*work
)
788 container_of(work
, struct zd_mac
, set_rx_filter_work
);
791 dev_dbg_f(zd_mac_dev(mac
), "\n");
792 r
= set_rx_filter(mac
);
794 dev_err(zd_mac_dev(mac
), "set_rx_filter_handler error %d\n", r
);
797 #define SUPPORTED_FIF_FLAGS \
798 (FIF_PROMISC_IN_BSS | FIF_ALLMULTI | FIF_FCSFAIL | FIF_CONTROL | \
799 FIF_OTHER_BSS | FIF_BCN_PRBRESP_PROMISC)
800 static void zd_op_configure_filter(struct ieee80211_hw
*hw
,
801 unsigned int changed_flags
,
802 unsigned int *new_flags
,
803 int mc_count
, struct dev_mc_list
*mclist
)
805 struct zd_mc_hash hash
;
806 struct zd_mac
*mac
= zd_hw_mac(hw
);
810 /* Only deal with supported flags */
811 changed_flags
&= SUPPORTED_FIF_FLAGS
;
812 *new_flags
&= SUPPORTED_FIF_FLAGS
;
814 /* changed_flags is always populated but this driver
815 * doesn't support all FIF flags so its possible we don't
816 * need to do anything */
820 if (*new_flags
& (FIF_PROMISC_IN_BSS
| FIF_ALLMULTI
)) {
821 zd_mc_add_all(&hash
);
823 DECLARE_MAC_BUF(macbuf
);
826 for (i
= 0; i
< mc_count
; i
++) {
829 dev_dbg_f(zd_mac_dev(mac
), "mc addr %s\n",
830 print_mac(macbuf
, mclist
->dmi_addr
));
831 zd_mc_add_addr(&hash
, mclist
->dmi_addr
);
832 mclist
= mclist
->next
;
836 spin_lock_irqsave(&mac
->lock
, flags
);
837 mac
->pass_failed_fcs
= !!(*new_flags
& FIF_FCSFAIL
);
838 mac
->pass_ctrl
= !!(*new_flags
& FIF_CONTROL
);
839 mac
->multicast_hash
= hash
;
840 spin_unlock_irqrestore(&mac
->lock
, flags
);
841 queue_work(zd_workqueue
, &mac
->set_multicast_hash_work
);
843 if (changed_flags
& FIF_CONTROL
)
844 queue_work(zd_workqueue
, &mac
->set_rx_filter_work
);
846 /* no handling required for FIF_OTHER_BSS as we don't currently
847 * do BSSID filtering */
848 /* FIXME: in future it would be nice to enable the probe response
849 * filter (so that the driver doesn't see them) until
850 * FIF_BCN_PRBRESP_PROMISC is set. however due to atomicity here, we'd
851 * have to schedule work to enable prbresp reception, which might
852 * happen too late. For now we'll just listen and forward them all the
856 static void set_rts_cts_work(struct work_struct
*work
)
859 container_of(work
, struct zd_mac
, set_rts_cts_work
);
861 unsigned int short_preamble
;
863 mutex_lock(&mac
->chip
.mutex
);
865 spin_lock_irqsave(&mac
->lock
, flags
);
866 mac
->updating_rts_rate
= 0;
867 short_preamble
= mac
->short_preamble
;
868 spin_unlock_irqrestore(&mac
->lock
, flags
);
870 zd_chip_set_rts_cts_rate_locked(&mac
->chip
, short_preamble
);
871 mutex_unlock(&mac
->chip
.mutex
);
874 static void zd_op_bss_info_changed(struct ieee80211_hw
*hw
,
875 struct ieee80211_vif
*vif
,
876 struct ieee80211_bss_conf
*bss_conf
,
879 struct zd_mac
*mac
= zd_hw_mac(hw
);
882 dev_dbg_f(zd_mac_dev(mac
), "changes: %x\n", changes
);
884 if (changes
& BSS_CHANGED_ERP_PREAMBLE
) {
885 spin_lock_irqsave(&mac
->lock
, flags
);
886 mac
->short_preamble
= bss_conf
->use_short_preamble
;
887 if (!mac
->updating_rts_rate
) {
888 mac
->updating_rts_rate
= 1;
889 /* FIXME: should disable TX here, until work has
890 * completed and RTS_CTS reg is updated */
891 queue_work(zd_workqueue
, &mac
->set_rts_cts_work
);
893 spin_unlock_irqrestore(&mac
->lock
, flags
);
897 static const struct ieee80211_ops zd_ops
= {
899 .start
= zd_op_start
,
901 .add_interface
= zd_op_add_interface
,
902 .remove_interface
= zd_op_remove_interface
,
903 .config
= zd_op_config
,
904 .config_interface
= zd_op_config_interface
,
905 .configure_filter
= zd_op_configure_filter
,
906 .bss_info_changed
= zd_op_bss_info_changed
,
909 struct ieee80211_hw
*zd_mac_alloc_hw(struct usb_interface
*intf
)
912 struct ieee80211_hw
*hw
;
914 hw
= ieee80211_alloc_hw(sizeof(struct zd_mac
), &zd_ops
);
916 dev_dbg_f(&intf
->dev
, "out of memory\n");
922 memset(mac
, 0, sizeof(*mac
));
923 spin_lock_init(&mac
->lock
);
926 mac
->type
= IEEE80211_IF_TYPE_INVALID
;
928 memcpy(mac
->channels
, zd_channels
, sizeof(zd_channels
));
929 memcpy(mac
->rates
, zd_rates
, sizeof(zd_rates
));
930 mac
->band
.n_bitrates
= ARRAY_SIZE(zd_rates
);
931 mac
->band
.bitrates
= mac
->rates
;
932 mac
->band
.n_channels
= ARRAY_SIZE(zd_channels
);
933 mac
->band
.channels
= mac
->channels
;
935 hw
->wiphy
->bands
[IEEE80211_BAND_2GHZ
] = &mac
->band
;
937 hw
->flags
= IEEE80211_HW_RX_INCLUDES_FCS
|
938 IEEE80211_HW_SIGNAL_DB
;
940 hw
->wiphy
->interface_modes
=
941 BIT(NL80211_IFTYPE_MESH_POINT
) |
942 BIT(NL80211_IFTYPE_STATION
) |
943 BIT(NL80211_IFTYPE_ADHOC
);
945 hw
->max_signal
= 100;
947 hw
->extra_tx_headroom
= sizeof(struct zd_ctrlset
);
949 skb_queue_head_init(&mac
->ack_wait_queue
);
951 zd_chip_init(&mac
->chip
, hw
, intf
);
952 housekeeping_init(mac
);
953 INIT_WORK(&mac
->set_multicast_hash_work
, set_multicast_hash_handler
);
954 INIT_WORK(&mac
->set_rts_cts_work
, set_rts_cts_work
);
955 INIT_WORK(&mac
->set_rx_filter_work
, set_rx_filter_handler
);
956 INIT_WORK(&mac
->process_intr
, zd_process_intr
);
958 SET_IEEE80211_DEV(hw
, &intf
->dev
);
962 #define LINK_LED_WORK_DELAY HZ
964 static void link_led_handler(struct work_struct
*work
)
967 container_of(work
, struct zd_mac
, housekeeping
.link_led_work
.work
);
968 struct zd_chip
*chip
= &mac
->chip
;
972 spin_lock_irq(&mac
->lock
);
973 is_associated
= mac
->associated
;
974 spin_unlock_irq(&mac
->lock
);
976 r
= zd_chip_control_leds(chip
,
977 is_associated
? LED_ASSOCIATED
: LED_SCANNING
);
979 dev_dbg_f(zd_mac_dev(mac
), "zd_chip_control_leds error %d\n", r
);
981 queue_delayed_work(zd_workqueue
, &mac
->housekeeping
.link_led_work
,
982 LINK_LED_WORK_DELAY
);
985 static void housekeeping_init(struct zd_mac
*mac
)
987 INIT_DELAYED_WORK(&mac
->housekeeping
.link_led_work
, link_led_handler
);
990 static void housekeeping_enable(struct zd_mac
*mac
)
992 dev_dbg_f(zd_mac_dev(mac
), "\n");
993 queue_delayed_work(zd_workqueue
, &mac
->housekeeping
.link_led_work
,
997 static void housekeeping_disable(struct zd_mac
*mac
)
999 dev_dbg_f(zd_mac_dev(mac
), "\n");
1000 cancel_rearming_delayed_workqueue(zd_workqueue
,
1001 &mac
->housekeeping
.link_led_work
);
1002 zd_chip_control_leds(&mac
->chip
, LED_OFF
);