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
);
228 * clear_tx_skb_control_block - clears the control block of tx skbuffs
229 * @skb: a &struct sk_buff pointer
231 * This clears the control block of skbuff buffers, which were transmitted to
232 * the device. Notify that the function is not thread-safe, so prevent
235 static void clear_tx_skb_control_block(struct sk_buff
*skb
)
237 struct zd_tx_skb_control_block
*cb
=
238 (struct zd_tx_skb_control_block
*)skb
->cb
;
245 * kfree_tx_skb - frees a tx skbuff
246 * @skb: a &struct sk_buff pointer
248 * Frees the tx skbuff. Frees also the allocated control structure in the
249 * control block if necessary.
251 static void kfree_tx_skb(struct sk_buff
*skb
)
253 clear_tx_skb_control_block(skb
);
254 dev_kfree_skb_any(skb
);
257 static void zd_op_stop(struct ieee80211_hw
*hw
)
259 struct zd_mac
*mac
= zd_hw_mac(hw
);
260 struct zd_chip
*chip
= &mac
->chip
;
262 struct sk_buff_head
*ack_wait_queue
= &mac
->ack_wait_queue
;
264 /* The order here deliberately is a little different from the open()
265 * method, since we need to make sure there is no opportunity for RX
266 * frames to be processed by mac80211 after we have stopped it.
269 zd_chip_disable_rxtx(chip
);
270 housekeeping_disable(mac
);
271 flush_workqueue(zd_workqueue
);
273 zd_chip_disable_hwint(chip
);
274 zd_chip_switch_radio_off(chip
);
275 zd_chip_disable_int(chip
);
278 while ((skb
= skb_dequeue(ack_wait_queue
)))
283 * init_tx_skb_control_block - initializes skb control block
284 * @skb: a &sk_buff pointer
285 * @dev: pointer to the mac80221 device
286 * @control: mac80211 tx control applying for the frame in @skb
288 * Initializes the control block of the skbuff to be transmitted.
290 static int init_tx_skb_control_block(struct sk_buff
*skb
,
291 struct ieee80211_hw
*hw
,
292 struct ieee80211_tx_control
*control
)
294 struct zd_tx_skb_control_block
*cb
=
295 (struct zd_tx_skb_control_block
*)skb
->cb
;
297 ZD_ASSERT(sizeof(*cb
) <= sizeof(skb
->cb
));
298 memset(cb
, 0, sizeof(*cb
));
300 cb
->control
= kmalloc(sizeof(*control
), GFP_ATOMIC
);
301 if (cb
->control
== NULL
)
303 memcpy(cb
->control
, control
, sizeof(*control
));
309 * tx_status - reports tx status of a packet if required
310 * @hw - a &struct ieee80211_hw pointer
312 * @status - the tx status of the packet without control information
313 * @success - True for successfull transmission of the frame
315 * This information calls ieee80211_tx_status_irqsafe() if required by the
316 * control information. It copies the control information into the status
319 * If no status information has been requested, the skb is freed.
321 static void tx_status(struct ieee80211_hw
*hw
, struct sk_buff
*skb
,
322 struct ieee80211_tx_status
*status
,
325 struct zd_tx_skb_control_block
*cb
= (struct zd_tx_skb_control_block
*)
328 ZD_ASSERT(cb
->control
!= NULL
);
329 memcpy(&status
->control
, cb
->control
, sizeof(status
->control
));
331 status
->excessive_retries
= 1;
332 clear_tx_skb_control_block(skb
);
333 ieee80211_tx_status_irqsafe(hw
, skb
, status
);
337 * zd_mac_tx_failed - callback for failed frames
338 * @dev: the mac80211 wireless device
340 * This function is called if a frame couldn't be succesfully be
341 * transferred. The first frame from the tx queue, will be selected and
342 * reported as error to the upper layers.
344 void zd_mac_tx_failed(struct ieee80211_hw
*hw
)
346 struct sk_buff_head
*q
= &zd_hw_mac(hw
)->ack_wait_queue
;
348 struct ieee80211_tx_status status
;
350 skb
= skb_dequeue(q
);
354 memset(&status
, 0, sizeof(status
));
356 tx_status(hw
, skb
, &status
, 0);
360 * zd_mac_tx_to_dev - callback for USB layer
361 * @skb: a &sk_buff pointer
362 * @error: error value, 0 if transmission successful
364 * Informs the MAC layer that the frame has successfully transferred to the
365 * device. If an ACK is required and the transfer to the device has been
366 * successful, the packets are put on the @ack_wait_queue with
367 * the control set removed.
369 void zd_mac_tx_to_dev(struct sk_buff
*skb
, int error
)
371 struct zd_tx_skb_control_block
*cb
=
372 (struct zd_tx_skb_control_block
*)skb
->cb
;
373 struct ieee80211_hw
*hw
= cb
->hw
;
375 if (likely(cb
->control
)) {
376 skb_pull(skb
, sizeof(struct zd_ctrlset
));
377 if (unlikely(error
||
378 (cb
->control
->flags
& IEEE80211_TXCTL_NO_ACK
)))
380 struct ieee80211_tx_status status
;
381 memset(&status
, 0, sizeof(status
));
382 tx_status(hw
, skb
, &status
, !error
);
384 struct sk_buff_head
*q
=
385 &zd_hw_mac(hw
)->ack_wait_queue
;
387 skb_queue_tail(q
, skb
);
388 while (skb_queue_len(q
) > ZD_MAC_MAX_ACK_WAITERS
)
389 zd_mac_tx_failed(hw
);
396 static int zd_calc_tx_length_us(u8
*service
, u8 zd_rate
, u16 tx_length
)
398 /* ZD_PURE_RATE() must be used to remove the modulation type flag of
399 * the zd-rate values.
401 static const u8 rate_divisor
[] = {
402 [ZD_PURE_RATE(ZD_CCK_RATE_1M
)] = 1,
403 [ZD_PURE_RATE(ZD_CCK_RATE_2M
)] = 2,
404 /* Bits must be doubled. */
405 [ZD_PURE_RATE(ZD_CCK_RATE_5_5M
)] = 11,
406 [ZD_PURE_RATE(ZD_CCK_RATE_11M
)] = 11,
407 [ZD_PURE_RATE(ZD_OFDM_RATE_6M
)] = 6,
408 [ZD_PURE_RATE(ZD_OFDM_RATE_9M
)] = 9,
409 [ZD_PURE_RATE(ZD_OFDM_RATE_12M
)] = 12,
410 [ZD_PURE_RATE(ZD_OFDM_RATE_18M
)] = 18,
411 [ZD_PURE_RATE(ZD_OFDM_RATE_24M
)] = 24,
412 [ZD_PURE_RATE(ZD_OFDM_RATE_36M
)] = 36,
413 [ZD_PURE_RATE(ZD_OFDM_RATE_48M
)] = 48,
414 [ZD_PURE_RATE(ZD_OFDM_RATE_54M
)] = 54,
417 u32 bits
= (u32
)tx_length
* 8;
420 divisor
= rate_divisor
[ZD_PURE_RATE(zd_rate
)];
425 case ZD_CCK_RATE_5_5M
:
426 bits
= (2*bits
) + 10; /* round up to the next integer */
428 case ZD_CCK_RATE_11M
:
431 *service
&= ~ZD_PLCP_SERVICE_LENGTH_EXTENSION
;
432 if (0 < t
&& t
<= 3) {
433 *service
|= ZD_PLCP_SERVICE_LENGTH_EXTENSION
;
436 bits
+= 10; /* round up to the next integer */
443 static void cs_set_control(struct zd_mac
*mac
, struct zd_ctrlset
*cs
,
444 struct ieee80211_hdr
*header
, u32 flags
)
446 u16 fctl
= le16_to_cpu(header
->frame_control
);
450 * - if backoff needed, enable bit 0
451 * - if burst (backoff not needed) disable bit 0
457 if (flags
& IEEE80211_TXCTL_FIRST_FRAGMENT
)
458 cs
->control
|= ZD_CS_NEED_RANDOM_BACKOFF
;
461 if (is_multicast_ether_addr(header
->addr1
))
462 cs
->control
|= ZD_CS_MULTICAST
;
465 if ((fctl
& (IEEE80211_FCTL_FTYPE
|IEEE80211_FCTL_STYPE
)) ==
466 (IEEE80211_FTYPE_CTL
|IEEE80211_STYPE_PSPOLL
))
467 cs
->control
|= ZD_CS_PS_POLL_FRAME
;
469 if (flags
& IEEE80211_TXCTL_USE_RTS_CTS
)
470 cs
->control
|= ZD_CS_RTS
;
472 if (flags
& IEEE80211_TXCTL_USE_CTS_PROTECT
)
473 cs
->control
|= ZD_CS_SELF_CTS
;
475 /* FIXME: Management frame? */
478 static int fill_ctrlset(struct zd_mac
*mac
,
480 struct ieee80211_tx_control
*control
)
483 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
484 unsigned int frag_len
= skb
->len
+ FCS_LEN
;
485 unsigned int packet_length
;
486 struct zd_ctrlset
*cs
= (struct zd_ctrlset
*)
487 skb_push(skb
, sizeof(struct zd_ctrlset
));
489 ZD_ASSERT(frag_len
<= 0xffff);
491 cs
->modulation
= control
->tx_rate
->hw_value
;
492 if (control
->flags
& IEEE80211_TXCTL_SHORT_PREAMBLE
)
493 cs
->modulation
= control
->tx_rate
->hw_value_short
;
495 cs
->tx_length
= cpu_to_le16(frag_len
);
497 cs_set_control(mac
, cs
, hdr
, control
->flags
);
499 packet_length
= frag_len
+ sizeof(struct zd_ctrlset
) + 10;
500 ZD_ASSERT(packet_length
<= 0xffff);
501 /* ZD1211B: Computing the length difference this way, gives us
502 * flexibility to compute the packet length.
504 cs
->packet_length
= cpu_to_le16(zd_chip_is_zd1211b(&mac
->chip
) ?
505 packet_length
- frag_len
: packet_length
);
509 * - transmit frame length in microseconds
510 * - seems to be derived from frame length
511 * - see Cal_Us_Service() in zdinlinef.h
512 * - if macp->bTxBurstEnable is enabled, then multiply by 4
513 * - bTxBurstEnable is never set in the vendor driver
516 * - "for PLCP configuration"
517 * - always 0 except in some situations at 802.11b 11M
518 * - see line 53 of zdinlinef.h
521 r
= zd_calc_tx_length_us(&cs
->service
, ZD_RATE(cs
->modulation
),
522 le16_to_cpu(cs
->tx_length
));
525 cs
->current_length
= cpu_to_le16(r
);
526 cs
->next_frame_length
= 0;
532 * zd_op_tx - transmits a network frame to the device
534 * @dev: mac80211 hardware device
535 * @skb: socket buffer
536 * @control: the control structure
538 * This function transmit an IEEE 802.11 network frame to the device. The
539 * control block of the skbuff will be initialized. If necessary the incoming
540 * mac80211 queues will be stopped.
542 static int zd_op_tx(struct ieee80211_hw
*hw
, struct sk_buff
*skb
,
543 struct ieee80211_tx_control
*control
)
545 struct zd_mac
*mac
= zd_hw_mac(hw
);
548 r
= fill_ctrlset(mac
, skb
, control
);
552 r
= init_tx_skb_control_block(skb
, hw
, control
);
555 r
= zd_usb_tx(&mac
->chip
.usb
, skb
);
557 clear_tx_skb_control_block(skb
);
564 * filter_ack - filters incoming packets for acknowledgements
565 * @dev: the mac80211 device
566 * @rx_hdr: received header
567 * @stats: the status for the received packet
569 * This functions looks for ACK packets and tries to match them with the
570 * frames in the tx queue. If a match is found the frame will be dequeued and
571 * the upper layers is informed about the successful transmission. If
572 * mac80211 queues have been stopped and the number of frames still to be
573 * transmitted is low the queues will be opened again.
575 * Returns 1 if the frame was an ACK, 0 if it was ignored.
577 static int filter_ack(struct ieee80211_hw
*hw
, struct ieee80211_hdr
*rx_hdr
,
578 struct ieee80211_rx_status
*stats
)
580 u16 fc
= le16_to_cpu(rx_hdr
->frame_control
);
582 struct sk_buff_head
*q
;
585 if ((fc
& (IEEE80211_FCTL_FTYPE
| IEEE80211_FCTL_STYPE
)) !=
586 (IEEE80211_FTYPE_CTL
| IEEE80211_STYPE_ACK
))
589 q
= &zd_hw_mac(hw
)->ack_wait_queue
;
590 spin_lock_irqsave(&q
->lock
, flags
);
591 for (skb
= q
->next
; skb
!= (struct sk_buff
*)q
; skb
= skb
->next
) {
592 struct ieee80211_hdr
*tx_hdr
;
594 tx_hdr
= (struct ieee80211_hdr
*)skb
->data
;
595 if (likely(!compare_ether_addr(tx_hdr
->addr2
, rx_hdr
->addr1
)))
597 struct ieee80211_tx_status status
;
599 memset(&status
, 0, sizeof(status
));
600 status
.flags
= IEEE80211_TX_STATUS_ACK
;
601 status
.ack_signal
= stats
->ssi
;
602 __skb_unlink(skb
, q
);
603 tx_status(hw
, skb
, &status
, 1);
608 spin_unlock_irqrestore(&q
->lock
, flags
);
612 int zd_mac_rx(struct ieee80211_hw
*hw
, const u8
*buffer
, unsigned int length
)
614 struct zd_mac
*mac
= zd_hw_mac(hw
);
615 struct ieee80211_rx_status stats
;
616 const struct rx_status
*status
;
620 bool is_qos
, is_4addr
, need_padding
;
624 if (length
< ZD_PLCP_HEADER_SIZE
+ 10 /* IEEE80211_1ADDR_LEN */ +
625 FCS_LEN
+ sizeof(struct rx_status
))
628 memset(&stats
, 0, sizeof(stats
));
630 /* Note about pass_failed_fcs and pass_ctrl access below:
631 * mac locking intentionally omitted here, as this is the only unlocked
632 * reader and the only writer is configure_filter. Plus, if there were
633 * any races accessing these variables, it wouldn't really matter.
634 * If mac80211 ever provides a way for us to access filter flags
635 * from outside configure_filter, we could improve on this. Also, this
636 * situation may change once we implement some kind of DMA-into-skb
639 /* Caller has to ensure that length >= sizeof(struct rx_status). */
640 status
= (struct rx_status
*)
641 (buffer
+ (length
- sizeof(struct rx_status
)));
642 if (status
->frame_status
& ZD_RX_ERROR
) {
643 if (mac
->pass_failed_fcs
&&
644 (status
->frame_status
& ZD_RX_CRC32_ERROR
)) {
645 stats
.flag
|= RX_FLAG_FAILED_FCS_CRC
;
652 stats
.freq
= zd_channels
[_zd_chip_get_channel(&mac
->chip
) - 1].center_freq
;
653 stats
.band
= IEEE80211_BAND_2GHZ
;
654 stats
.ssi
= status
->signal_strength
;
655 stats
.signal
= zd_rx_qual_percent(buffer
,
656 length
- sizeof(struct rx_status
),
659 rate
= zd_rx_rate(buffer
, status
);
661 /* todo: return index in the big switches in zd_rx_rate instead */
662 for (i
= 0; i
< mac
->band
.n_bitrates
; i
++)
663 if (rate
== mac
->band
.bitrates
[i
].hw_value
)
666 length
-= ZD_PLCP_HEADER_SIZE
+ sizeof(struct rx_status
);
667 buffer
+= ZD_PLCP_HEADER_SIZE
;
669 /* Except for bad frames, filter each frame to see if it is an ACK, in
670 * which case our internal TX tracking is updated. Normally we then
671 * bail here as there's no need to pass ACKs on up to the stack, but
672 * there is also the case where the stack has requested us to pass
673 * control frames on up (pass_ctrl) which we must consider. */
675 filter_ack(hw
, (struct ieee80211_hdr
*)buffer
, &stats
)
679 fc
= le16_to_cpu(*((__le16
*) buffer
));
681 is_qos
= ((fc
& IEEE80211_FCTL_FTYPE
) == IEEE80211_FTYPE_DATA
) &&
682 ((fc
& IEEE80211_FCTL_STYPE
) == IEEE80211_STYPE_QOS_DATA
);
683 is_4addr
= (fc
& (IEEE80211_FCTL_TODS
| IEEE80211_FCTL_FROMDS
)) ==
684 (IEEE80211_FCTL_TODS
| IEEE80211_FCTL_FROMDS
);
685 need_padding
= is_qos
^ is_4addr
;
687 skb
= dev_alloc_skb(length
+ (need_padding
? 2 : 0));
691 /* Make sure the the payload data is 4 byte aligned. */
695 memcpy(skb_put(skb
, length
), buffer
, length
);
697 ieee80211_rx_irqsafe(hw
, skb
, &stats
);
701 static int zd_op_add_interface(struct ieee80211_hw
*hw
,
702 struct ieee80211_if_init_conf
*conf
)
704 struct zd_mac
*mac
= zd_hw_mac(hw
);
706 /* using IEEE80211_IF_TYPE_INVALID to indicate no mode selected */
707 if (mac
->type
!= IEEE80211_IF_TYPE_INVALID
)
710 switch (conf
->type
) {
711 case IEEE80211_IF_TYPE_MNTR
:
712 case IEEE80211_IF_TYPE_STA
:
713 mac
->type
= conf
->type
;
719 return zd_write_mac_addr(&mac
->chip
, conf
->mac_addr
);
722 static void zd_op_remove_interface(struct ieee80211_hw
*hw
,
723 struct ieee80211_if_init_conf
*conf
)
725 struct zd_mac
*mac
= zd_hw_mac(hw
);
726 mac
->type
= IEEE80211_IF_TYPE_INVALID
;
727 zd_write_mac_addr(&mac
->chip
, NULL
);
730 static int zd_op_config(struct ieee80211_hw
*hw
, struct ieee80211_conf
*conf
)
732 struct zd_mac
*mac
= zd_hw_mac(hw
);
733 return zd_chip_set_channel(&mac
->chip
, conf
->channel
->hw_value
);
736 static int zd_op_config_interface(struct ieee80211_hw
*hw
,
737 struct ieee80211_vif
*vif
,
738 struct ieee80211_if_conf
*conf
)
740 struct zd_mac
*mac
= zd_hw_mac(hw
);
742 spin_lock_irq(&mac
->lock
);
743 mac
->associated
= is_valid_ether_addr(conf
->bssid
);
744 spin_unlock_irq(&mac
->lock
);
746 /* TODO: do hardware bssid filtering */
750 static void set_multicast_hash_handler(struct work_struct
*work
)
753 container_of(work
, struct zd_mac
, set_multicast_hash_work
);
754 struct zd_mc_hash hash
;
756 spin_lock_irq(&mac
->lock
);
757 hash
= mac
->multicast_hash
;
758 spin_unlock_irq(&mac
->lock
);
760 zd_chip_set_multicast_hash(&mac
->chip
, &hash
);
763 static void set_rx_filter_handler(struct work_struct
*work
)
766 container_of(work
, struct zd_mac
, set_rx_filter_work
);
769 dev_dbg_f(zd_mac_dev(mac
), "\n");
770 r
= set_rx_filter(mac
);
772 dev_err(zd_mac_dev(mac
), "set_rx_filter_handler error %d\n", r
);
775 #define SUPPORTED_FIF_FLAGS \
776 (FIF_PROMISC_IN_BSS | FIF_ALLMULTI | FIF_FCSFAIL | FIF_CONTROL | \
778 static void zd_op_configure_filter(struct ieee80211_hw
*hw
,
779 unsigned int changed_flags
,
780 unsigned int *new_flags
,
781 int mc_count
, struct dev_mc_list
*mclist
)
783 struct zd_mc_hash hash
;
784 struct zd_mac
*mac
= zd_hw_mac(hw
);
788 /* Only deal with supported flags */
789 changed_flags
&= SUPPORTED_FIF_FLAGS
;
790 *new_flags
&= SUPPORTED_FIF_FLAGS
;
792 /* changed_flags is always populated but this driver
793 * doesn't support all FIF flags so its possible we don't
794 * need to do anything */
798 if (*new_flags
& (FIF_PROMISC_IN_BSS
| FIF_ALLMULTI
)) {
799 zd_mc_add_all(&hash
);
801 DECLARE_MAC_BUF(macbuf
);
804 for (i
= 0; i
< mc_count
; i
++) {
807 dev_dbg_f(zd_mac_dev(mac
), "mc addr %s\n",
808 print_mac(macbuf
, mclist
->dmi_addr
));
809 zd_mc_add_addr(&hash
, mclist
->dmi_addr
);
810 mclist
= mclist
->next
;
814 spin_lock_irqsave(&mac
->lock
, flags
);
815 mac
->pass_failed_fcs
= !!(*new_flags
& FIF_FCSFAIL
);
816 mac
->pass_ctrl
= !!(*new_flags
& FIF_CONTROL
);
817 mac
->multicast_hash
= hash
;
818 spin_unlock_irqrestore(&mac
->lock
, flags
);
819 queue_work(zd_workqueue
, &mac
->set_multicast_hash_work
);
821 if (changed_flags
& FIF_CONTROL
)
822 queue_work(zd_workqueue
, &mac
->set_rx_filter_work
);
824 /* no handling required for FIF_OTHER_BSS as we don't currently
825 * do BSSID filtering */
826 /* FIXME: in future it would be nice to enable the probe response
827 * filter (so that the driver doesn't see them) until
828 * FIF_BCN_PRBRESP_PROMISC is set. however due to atomicity here, we'd
829 * have to schedule work to enable prbresp reception, which might
830 * happen too late. For now we'll just listen and forward them all the
834 static void set_rts_cts_work(struct work_struct
*work
)
837 container_of(work
, struct zd_mac
, set_rts_cts_work
);
839 unsigned int short_preamble
;
841 mutex_lock(&mac
->chip
.mutex
);
843 spin_lock_irqsave(&mac
->lock
, flags
);
844 mac
->updating_rts_rate
= 0;
845 short_preamble
= mac
->short_preamble
;
846 spin_unlock_irqrestore(&mac
->lock
, flags
);
848 zd_chip_set_rts_cts_rate_locked(&mac
->chip
, short_preamble
);
849 mutex_unlock(&mac
->chip
.mutex
);
852 static void zd_op_bss_info_changed(struct ieee80211_hw
*hw
,
853 struct ieee80211_vif
*vif
,
854 struct ieee80211_bss_conf
*bss_conf
,
857 struct zd_mac
*mac
= zd_hw_mac(hw
);
860 dev_dbg_f(zd_mac_dev(mac
), "changes: %x\n", changes
);
862 if (changes
& BSS_CHANGED_ERP_PREAMBLE
) {
863 spin_lock_irqsave(&mac
->lock
, flags
);
864 mac
->short_preamble
= bss_conf
->use_short_preamble
;
865 if (!mac
->updating_rts_rate
) {
866 mac
->updating_rts_rate
= 1;
867 /* FIXME: should disable TX here, until work has
868 * completed and RTS_CTS reg is updated */
869 queue_work(zd_workqueue
, &mac
->set_rts_cts_work
);
871 spin_unlock_irqrestore(&mac
->lock
, flags
);
875 static const struct ieee80211_ops zd_ops
= {
877 .start
= zd_op_start
,
879 .add_interface
= zd_op_add_interface
,
880 .remove_interface
= zd_op_remove_interface
,
881 .config
= zd_op_config
,
882 .config_interface
= zd_op_config_interface
,
883 .configure_filter
= zd_op_configure_filter
,
884 .bss_info_changed
= zd_op_bss_info_changed
,
887 struct ieee80211_hw
*zd_mac_alloc_hw(struct usb_interface
*intf
)
890 struct ieee80211_hw
*hw
;
892 hw
= ieee80211_alloc_hw(sizeof(struct zd_mac
), &zd_ops
);
894 dev_dbg_f(&intf
->dev
, "out of memory\n");
900 memset(mac
, 0, sizeof(*mac
));
901 spin_lock_init(&mac
->lock
);
904 mac
->type
= IEEE80211_IF_TYPE_INVALID
;
906 memcpy(mac
->channels
, zd_channels
, sizeof(zd_channels
));
907 memcpy(mac
->rates
, zd_rates
, sizeof(zd_rates
));
908 mac
->band
.n_bitrates
= ARRAY_SIZE(zd_rates
);
909 mac
->band
.bitrates
= mac
->rates
;
910 mac
->band
.n_channels
= ARRAY_SIZE(zd_channels
);
911 mac
->band
.channels
= mac
->channels
;
913 hw
->wiphy
->bands
[IEEE80211_BAND_2GHZ
] = &mac
->band
;
915 hw
->flags
= IEEE80211_HW_RX_INCLUDES_FCS
;
917 hw
->max_signal
= 100;
920 hw
->extra_tx_headroom
= sizeof(struct zd_ctrlset
);
922 skb_queue_head_init(&mac
->ack_wait_queue
);
924 zd_chip_init(&mac
->chip
, hw
, intf
);
925 housekeeping_init(mac
);
926 INIT_WORK(&mac
->set_multicast_hash_work
, set_multicast_hash_handler
);
927 INIT_WORK(&mac
->set_rts_cts_work
, set_rts_cts_work
);
928 INIT_WORK(&mac
->set_rx_filter_work
, set_rx_filter_handler
);
930 SET_IEEE80211_DEV(hw
, &intf
->dev
);
934 #define LINK_LED_WORK_DELAY HZ
936 static void link_led_handler(struct work_struct
*work
)
939 container_of(work
, struct zd_mac
, housekeeping
.link_led_work
.work
);
940 struct zd_chip
*chip
= &mac
->chip
;
944 spin_lock_irq(&mac
->lock
);
945 is_associated
= mac
->associated
;
946 spin_unlock_irq(&mac
->lock
);
948 r
= zd_chip_control_leds(chip
,
949 is_associated
? LED_ASSOCIATED
: LED_SCANNING
);
951 dev_dbg_f(zd_mac_dev(mac
), "zd_chip_control_leds error %d\n", r
);
953 queue_delayed_work(zd_workqueue
, &mac
->housekeeping
.link_led_work
,
954 LINK_LED_WORK_DELAY
);
957 static void housekeeping_init(struct zd_mac
*mac
)
959 INIT_DELAYED_WORK(&mac
->housekeeping
.link_led_work
, link_led_handler
);
962 static void housekeeping_enable(struct zd_mac
*mac
)
964 dev_dbg_f(zd_mac_dev(mac
), "\n");
965 queue_delayed_work(zd_workqueue
, &mac
->housekeeping
.link_led_work
,
969 static void housekeeping_disable(struct zd_mac
*mac
)
971 dev_dbg_f(zd_mac_dev(mac
), "\n");
972 cancel_rearming_delayed_workqueue(zd_workqueue
,
973 &mac
->housekeeping
.link_led_work
);
974 zd_chip_control_leds(&mac
->chip
, LED_OFF
);