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 .val
= ZD_CCK_RATE_1M
,
39 .flags
= IEEE80211_RATE_CCK
},
41 .val
= ZD_CCK_RATE_2M
,
42 .val2
= ZD_CCK_RATE_2M
| ZD_CCK_PREA_SHORT
,
43 .flags
= IEEE80211_RATE_CCK_2
},
45 .val
= ZD_CCK_RATE_5_5M
,
46 .val2
= ZD_CCK_RATE_5_5M
| ZD_CCK_PREA_SHORT
,
47 .flags
= IEEE80211_RATE_CCK_2
},
49 .val
= ZD_CCK_RATE_11M
,
50 .val2
= ZD_CCK_RATE_11M
| ZD_CCK_PREA_SHORT
,
51 .flags
= IEEE80211_RATE_CCK_2
},
53 .val
= ZD_OFDM_RATE_6M
,
54 .flags
= IEEE80211_RATE_OFDM
},
56 .val
= ZD_OFDM_RATE_9M
,
57 .flags
= IEEE80211_RATE_OFDM
},
59 .val
= ZD_OFDM_RATE_12M
,
60 .flags
= IEEE80211_RATE_OFDM
},
62 .val
= ZD_OFDM_RATE_18M
,
63 .flags
= IEEE80211_RATE_OFDM
},
65 .val
= ZD_OFDM_RATE_24M
,
66 .flags
= IEEE80211_RATE_OFDM
},
68 .val
= ZD_OFDM_RATE_36M
,
69 .flags
= IEEE80211_RATE_OFDM
},
71 .val
= ZD_OFDM_RATE_48M
,
72 .flags
= IEEE80211_RATE_OFDM
},
74 .val
= ZD_OFDM_RATE_54M
,
75 .flags
= IEEE80211_RATE_OFDM
},
78 static const struct ieee80211_channel zd_channels
[] = {
109 static void housekeeping_init(struct zd_mac
*mac
);
110 static void housekeeping_enable(struct zd_mac
*mac
);
111 static void housekeeping_disable(struct zd_mac
*mac
);
113 int zd_mac_preinit_hw(struct ieee80211_hw
*hw
)
117 struct zd_mac
*mac
= zd_hw_mac(hw
);
119 r
= zd_chip_read_mac_addr_fw(&mac
->chip
, addr
);
123 SET_IEEE80211_PERM_ADDR(hw
, addr
);
128 int zd_mac_init_hw(struct ieee80211_hw
*hw
)
131 struct zd_mac
*mac
= zd_hw_mac(hw
);
132 struct zd_chip
*chip
= &mac
->chip
;
133 u8 default_regdomain
;
135 r
= zd_chip_enable_int(chip
);
138 r
= zd_chip_init_hw(chip
);
142 ZD_ASSERT(!irqs_disabled());
144 r
= zd_read_regdomain(chip
, &default_regdomain
);
147 spin_lock_irq(&mac
->lock
);
148 mac
->regdomain
= mac
->default_regdomain
= default_regdomain
;
149 spin_unlock_irq(&mac
->lock
);
151 /* We must inform the device that we are doing encryption/decryption in
152 * software at the moment. */
153 r
= zd_set_encryption_type(chip
, ENC_SNIFFER
);
157 zd_geo_init(hw
, mac
->regdomain
);
161 zd_chip_disable_int(chip
);
166 void zd_mac_clear(struct zd_mac
*mac
)
168 flush_workqueue(zd_workqueue
);
169 zd_chip_clear(&mac
->chip
);
170 ZD_ASSERT(!spin_is_locked(&mac
->lock
));
171 ZD_MEMCLEAR(mac
, sizeof(struct zd_mac
));
174 static int set_rx_filter(struct zd_mac
*mac
)
177 u32 filter
= STA_RX_FILTER
;
179 spin_lock_irqsave(&mac
->lock
, flags
);
181 filter
|= RX_FILTER_CTRL
;
182 spin_unlock_irqrestore(&mac
->lock
, flags
);
184 return zd_iowrite32(&mac
->chip
, CR_RX_FILTER
, filter
);
187 static int set_mc_hash(struct zd_mac
*mac
)
189 struct zd_mc_hash hash
;
191 return zd_chip_set_multicast_hash(&mac
->chip
, &hash
);
194 static int zd_op_start(struct ieee80211_hw
*hw
)
196 struct zd_mac
*mac
= zd_hw_mac(hw
);
197 struct zd_chip
*chip
= &mac
->chip
;
198 struct zd_usb
*usb
= &chip
->usb
;
201 if (!usb
->initialized
) {
202 r
= zd_usb_init_hw(usb
);
207 r
= zd_chip_enable_int(chip
);
211 r
= zd_chip_set_basic_rates(chip
, CR_RATES_80211B
| CR_RATES_80211G
);
214 r
= set_rx_filter(mac
);
217 r
= set_mc_hash(mac
);
220 r
= zd_chip_switch_radio_on(chip
);
223 r
= zd_chip_enable_rxtx(chip
);
226 r
= zd_chip_enable_hwint(chip
);
230 housekeeping_enable(mac
);
233 zd_chip_disable_rxtx(chip
);
235 zd_chip_switch_radio_off(chip
);
237 zd_chip_disable_int(chip
);
243 * clear_tx_skb_control_block - clears the control block of tx skbuffs
244 * @skb: a &struct sk_buff pointer
246 * This clears the control block of skbuff buffers, which were transmitted to
247 * the device. Notify that the function is not thread-safe, so prevent
250 static void clear_tx_skb_control_block(struct sk_buff
*skb
)
252 struct zd_tx_skb_control_block
*cb
=
253 (struct zd_tx_skb_control_block
*)skb
->cb
;
260 * kfree_tx_skb - frees a tx skbuff
261 * @skb: a &struct sk_buff pointer
263 * Frees the tx skbuff. Frees also the allocated control structure in the
264 * control block if necessary.
266 static void kfree_tx_skb(struct sk_buff
*skb
)
268 clear_tx_skb_control_block(skb
);
269 dev_kfree_skb_any(skb
);
272 static void zd_op_stop(struct ieee80211_hw
*hw
)
274 struct zd_mac
*mac
= zd_hw_mac(hw
);
275 struct zd_chip
*chip
= &mac
->chip
;
277 struct sk_buff_head
*ack_wait_queue
= &mac
->ack_wait_queue
;
279 /* The order here deliberately is a little different from the open()
280 * method, since we need to make sure there is no opportunity for RX
281 * frames to be processed by mac80211 after we have stopped it.
284 zd_chip_disable_rxtx(chip
);
285 housekeeping_disable(mac
);
286 flush_workqueue(zd_workqueue
);
288 zd_chip_disable_hwint(chip
);
289 zd_chip_switch_radio_off(chip
);
290 zd_chip_disable_int(chip
);
293 while ((skb
= skb_dequeue(ack_wait_queue
)))
298 * init_tx_skb_control_block - initializes skb control block
299 * @skb: a &sk_buff pointer
300 * @dev: pointer to the mac80221 device
301 * @control: mac80211 tx control applying for the frame in @skb
303 * Initializes the control block of the skbuff to be transmitted.
305 static int init_tx_skb_control_block(struct sk_buff
*skb
,
306 struct ieee80211_hw
*hw
,
307 struct ieee80211_tx_control
*control
)
309 struct zd_tx_skb_control_block
*cb
=
310 (struct zd_tx_skb_control_block
*)skb
->cb
;
312 ZD_ASSERT(sizeof(*cb
) <= sizeof(skb
->cb
));
313 memset(cb
, 0, sizeof(*cb
));
315 cb
->control
= kmalloc(sizeof(*control
), GFP_ATOMIC
);
316 if (cb
->control
== NULL
)
318 memcpy(cb
->control
, control
, sizeof(*control
));
324 * tx_status - reports tx status of a packet if required
325 * @hw - a &struct ieee80211_hw pointer
327 * @status - the tx status of the packet without control information
328 * @success - True for successfull transmission of the frame
330 * This information calls ieee80211_tx_status_irqsafe() if required by the
331 * control information. It copies the control information into the status
334 * If no status information has been requested, the skb is freed.
336 static void tx_status(struct ieee80211_hw
*hw
, struct sk_buff
*skb
,
337 struct ieee80211_tx_status
*status
,
340 struct zd_tx_skb_control_block
*cb
= (struct zd_tx_skb_control_block
*)
343 ZD_ASSERT(cb
->control
!= NULL
);
344 memcpy(&status
->control
, cb
->control
, sizeof(status
->control
));
346 status
->excessive_retries
= 1;
347 clear_tx_skb_control_block(skb
);
348 ieee80211_tx_status_irqsafe(hw
, skb
, status
);
352 * zd_mac_tx_failed - callback for failed frames
353 * @dev: the mac80211 wireless device
355 * This function is called if a frame couldn't be succesfully be
356 * transferred. The first frame from the tx queue, will be selected and
357 * reported as error to the upper layers.
359 void zd_mac_tx_failed(struct ieee80211_hw
*hw
)
361 struct sk_buff_head
*q
= &zd_hw_mac(hw
)->ack_wait_queue
;
363 struct ieee80211_tx_status status
= {{0}};
365 skb
= skb_dequeue(q
);
368 tx_status(hw
, skb
, &status
, 0);
372 * zd_mac_tx_to_dev - callback for USB layer
373 * @skb: a &sk_buff pointer
374 * @error: error value, 0 if transmission successful
376 * Informs the MAC layer that the frame has successfully transferred to the
377 * device. If an ACK is required and the transfer to the device has been
378 * successful, the packets are put on the @ack_wait_queue with
379 * the control set removed.
381 void zd_mac_tx_to_dev(struct sk_buff
*skb
, int error
)
383 struct zd_tx_skb_control_block
*cb
=
384 (struct zd_tx_skb_control_block
*)skb
->cb
;
385 struct ieee80211_hw
*hw
= cb
->hw
;
387 if (likely(cb
->control
)) {
388 skb_pull(skb
, sizeof(struct zd_ctrlset
));
389 if (unlikely(error
||
390 (cb
->control
->flags
& IEEE80211_TXCTL_NO_ACK
)))
392 struct ieee80211_tx_status status
= {{0}};
393 tx_status(hw
, skb
, &status
, !error
);
395 struct sk_buff_head
*q
=
396 &zd_hw_mac(hw
)->ack_wait_queue
;
398 skb_queue_tail(q
, skb
);
399 while (skb_queue_len(q
) > ZD_MAC_MAX_ACK_WAITERS
)
400 zd_mac_tx_failed(hw
);
407 static int zd_calc_tx_length_us(u8
*service
, u8 zd_rate
, u16 tx_length
)
409 /* ZD_PURE_RATE() must be used to remove the modulation type flag of
410 * the zd-rate values.
412 static const u8 rate_divisor
[] = {
413 [ZD_PURE_RATE(ZD_CCK_RATE_1M
)] = 1,
414 [ZD_PURE_RATE(ZD_CCK_RATE_2M
)] = 2,
415 /* Bits must be doubled. */
416 [ZD_PURE_RATE(ZD_CCK_RATE_5_5M
)] = 11,
417 [ZD_PURE_RATE(ZD_CCK_RATE_11M
)] = 11,
418 [ZD_PURE_RATE(ZD_OFDM_RATE_6M
)] = 6,
419 [ZD_PURE_RATE(ZD_OFDM_RATE_9M
)] = 9,
420 [ZD_PURE_RATE(ZD_OFDM_RATE_12M
)] = 12,
421 [ZD_PURE_RATE(ZD_OFDM_RATE_18M
)] = 18,
422 [ZD_PURE_RATE(ZD_OFDM_RATE_24M
)] = 24,
423 [ZD_PURE_RATE(ZD_OFDM_RATE_36M
)] = 36,
424 [ZD_PURE_RATE(ZD_OFDM_RATE_48M
)] = 48,
425 [ZD_PURE_RATE(ZD_OFDM_RATE_54M
)] = 54,
428 u32 bits
= (u32
)tx_length
* 8;
431 divisor
= rate_divisor
[ZD_PURE_RATE(zd_rate
)];
436 case ZD_CCK_RATE_5_5M
:
437 bits
= (2*bits
) + 10; /* round up to the next integer */
439 case ZD_CCK_RATE_11M
:
442 *service
&= ~ZD_PLCP_SERVICE_LENGTH_EXTENSION
;
443 if (0 < t
&& t
<= 3) {
444 *service
|= ZD_PLCP_SERVICE_LENGTH_EXTENSION
;
447 bits
+= 10; /* round up to the next integer */
454 static void cs_set_control(struct zd_mac
*mac
, struct zd_ctrlset
*cs
,
455 struct ieee80211_hdr
*header
, u32 flags
)
457 u16 fctl
= le16_to_cpu(header
->frame_control
);
461 * - if backoff needed, enable bit 0
462 * - if burst (backoff not needed) disable bit 0
468 if (flags
& IEEE80211_TXCTL_FIRST_FRAGMENT
)
469 cs
->control
|= ZD_CS_NEED_RANDOM_BACKOFF
;
472 if (is_multicast_ether_addr(header
->addr1
))
473 cs
->control
|= ZD_CS_MULTICAST
;
476 if ((fctl
& (IEEE80211_FCTL_FTYPE
|IEEE80211_FCTL_STYPE
)) ==
477 (IEEE80211_FTYPE_CTL
|IEEE80211_STYPE_PSPOLL
))
478 cs
->control
|= ZD_CS_PS_POLL_FRAME
;
480 if (flags
& IEEE80211_TXCTL_USE_RTS_CTS
)
481 cs
->control
|= ZD_CS_RTS
;
483 if (flags
& IEEE80211_TXCTL_USE_CTS_PROTECT
)
484 cs
->control
|= ZD_CS_SELF_CTS
;
486 /* FIXME: Management frame? */
489 static int fill_ctrlset(struct zd_mac
*mac
,
491 struct ieee80211_tx_control
*control
)
494 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
495 unsigned int frag_len
= skb
->len
+ FCS_LEN
;
496 unsigned int packet_length
;
497 struct zd_ctrlset
*cs
= (struct zd_ctrlset
*)
498 skb_push(skb
, sizeof(struct zd_ctrlset
));
500 ZD_ASSERT(frag_len
<= 0xffff);
502 cs
->modulation
= control
->tx_rate
;
504 cs
->tx_length
= cpu_to_le16(frag_len
);
506 cs_set_control(mac
, cs
, hdr
, control
->flags
);
508 packet_length
= frag_len
+ sizeof(struct zd_ctrlset
) + 10;
509 ZD_ASSERT(packet_length
<= 0xffff);
510 /* ZD1211B: Computing the length difference this way, gives us
511 * flexibility to compute the packet length.
513 cs
->packet_length
= cpu_to_le16(zd_chip_is_zd1211b(&mac
->chip
) ?
514 packet_length
- frag_len
: packet_length
);
518 * - transmit frame length in microseconds
519 * - seems to be derived from frame length
520 * - see Cal_Us_Service() in zdinlinef.h
521 * - if macp->bTxBurstEnable is enabled, then multiply by 4
522 * - bTxBurstEnable is never set in the vendor driver
525 * - "for PLCP configuration"
526 * - always 0 except in some situations at 802.11b 11M
527 * - see line 53 of zdinlinef.h
530 r
= zd_calc_tx_length_us(&cs
->service
, ZD_RATE(cs
->modulation
),
531 le16_to_cpu(cs
->tx_length
));
534 cs
->current_length
= cpu_to_le16(r
);
535 cs
->next_frame_length
= 0;
541 * zd_op_tx - transmits a network frame to the device
543 * @dev: mac80211 hardware device
544 * @skb: socket buffer
545 * @control: the control structure
547 * This function transmit an IEEE 802.11 network frame to the device. The
548 * control block of the skbuff will be initialized. If necessary the incoming
549 * mac80211 queues will be stopped.
551 static int zd_op_tx(struct ieee80211_hw
*hw
, struct sk_buff
*skb
,
552 struct ieee80211_tx_control
*control
)
554 struct zd_mac
*mac
= zd_hw_mac(hw
);
557 r
= fill_ctrlset(mac
, skb
, control
);
561 r
= init_tx_skb_control_block(skb
, hw
, control
);
564 r
= zd_usb_tx(&mac
->chip
.usb
, skb
);
566 clear_tx_skb_control_block(skb
);
573 * filter_ack - filters incoming packets for acknowledgements
574 * @dev: the mac80211 device
575 * @rx_hdr: received header
576 * @stats: the status for the received packet
578 * This functions looks for ACK packets and tries to match them with the
579 * frames in the tx queue. If a match is found the frame will be dequeued and
580 * the upper layers is informed about the successful transmission. If
581 * mac80211 queues have been stopped and the number of frames still to be
582 * transmitted is low the queues will be opened again.
584 * Returns 1 if the frame was an ACK, 0 if it was ignored.
586 static int filter_ack(struct ieee80211_hw
*hw
, struct ieee80211_hdr
*rx_hdr
,
587 struct ieee80211_rx_status
*stats
)
589 u16 fc
= le16_to_cpu(rx_hdr
->frame_control
);
591 struct sk_buff_head
*q
;
594 if ((fc
& (IEEE80211_FCTL_FTYPE
| IEEE80211_FCTL_STYPE
)) !=
595 (IEEE80211_FTYPE_CTL
| IEEE80211_STYPE_ACK
))
598 q
= &zd_hw_mac(hw
)->ack_wait_queue
;
599 spin_lock_irqsave(&q
->lock
, flags
);
600 for (skb
= q
->next
; skb
!= (struct sk_buff
*)q
; skb
= skb
->next
) {
601 struct ieee80211_hdr
*tx_hdr
;
603 tx_hdr
= (struct ieee80211_hdr
*)skb
->data
;
604 if (likely(!compare_ether_addr(tx_hdr
->addr2
, rx_hdr
->addr1
)))
606 struct ieee80211_tx_status status
= {{0}};
607 status
.flags
= IEEE80211_TX_STATUS_ACK
;
608 status
.ack_signal
= stats
->ssi
;
609 __skb_unlink(skb
, q
);
610 tx_status(hw
, skb
, &status
, 1);
615 spin_unlock_irqrestore(&q
->lock
, flags
);
619 int zd_mac_rx(struct ieee80211_hw
*hw
, const u8
*buffer
, unsigned int length
)
621 struct zd_mac
*mac
= zd_hw_mac(hw
);
622 struct ieee80211_rx_status stats
;
623 const struct rx_status
*status
;
627 bool is_qos
, is_4addr
, need_padding
;
629 if (length
< ZD_PLCP_HEADER_SIZE
+ 10 /* IEEE80211_1ADDR_LEN */ +
630 FCS_LEN
+ sizeof(struct rx_status
))
633 memset(&stats
, 0, sizeof(stats
));
635 /* Note about pass_failed_fcs and pass_ctrl access below:
636 * mac locking intentionally omitted here, as this is the only unlocked
637 * reader and the only writer is configure_filter. Plus, if there were
638 * any races accessing these variables, it wouldn't really matter.
639 * If mac80211 ever provides a way for us to access filter flags
640 * from outside configure_filter, we could improve on this. Also, this
641 * situation may change once we implement some kind of DMA-into-skb
644 /* Caller has to ensure that length >= sizeof(struct rx_status). */
645 status
= (struct rx_status
*)
646 (buffer
+ (length
- sizeof(struct rx_status
)));
647 if (status
->frame_status
& ZD_RX_ERROR
) {
648 if (mac
->pass_failed_fcs
&&
649 (status
->frame_status
& ZD_RX_CRC32_ERROR
)) {
650 stats
.flag
|= RX_FLAG_FAILED_FCS_CRC
;
657 stats
.channel
= _zd_chip_get_channel(&mac
->chip
);
658 stats
.freq
= zd_channels
[stats
.channel
- 1].freq
;
659 stats
.phymode
= MODE_IEEE80211G
;
660 stats
.ssi
= status
->signal_strength
;
661 stats
.signal
= zd_rx_qual_percent(buffer
,
662 length
- sizeof(struct rx_status
),
664 stats
.rate
= zd_rx_rate(buffer
, status
);
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
);
736 static int zd_op_config_interface(struct ieee80211_hw
*hw
, int if_id
,
737 struct ieee80211_if_conf
*conf
)
739 struct zd_mac
*mac
= zd_hw_mac(hw
);
741 spin_lock_irq(&mac
->lock
);
742 mac
->associated
= is_valid_ether_addr(conf
->bssid
);
743 spin_unlock_irq(&mac
->lock
);
745 /* TODO: do hardware bssid filtering */
749 static void set_multicast_hash_handler(struct work_struct
*work
)
752 container_of(work
, struct zd_mac
, set_multicast_hash_work
);
753 struct zd_mc_hash hash
;
755 spin_lock_irq(&mac
->lock
);
756 hash
= mac
->multicast_hash
;
757 spin_unlock_irq(&mac
->lock
);
759 zd_chip_set_multicast_hash(&mac
->chip
, &hash
);
762 static void set_rx_filter_handler(struct work_struct
*work
)
765 container_of(work
, struct zd_mac
, set_rx_filter_work
);
768 dev_dbg_f(zd_mac_dev(mac
), "\n");
769 r
= set_rx_filter(mac
);
771 dev_err(zd_mac_dev(mac
), "set_rx_filter_handler error %d\n", r
);
774 #define SUPPORTED_FIF_FLAGS \
775 (FIF_PROMISC_IN_BSS | FIF_ALLMULTI | FIF_FCSFAIL | FIF_CONTROL | \
777 static void zd_op_configure_filter(struct ieee80211_hw
*hw
,
778 unsigned int changed_flags
,
779 unsigned int *new_flags
,
780 int mc_count
, struct dev_mc_list
*mclist
)
782 struct zd_mc_hash hash
;
783 struct zd_mac
*mac
= zd_hw_mac(hw
);
787 /* Only deal with supported flags */
788 changed_flags
&= SUPPORTED_FIF_FLAGS
;
789 *new_flags
&= SUPPORTED_FIF_FLAGS
;
791 /* changed_flags is always populated but this driver
792 * doesn't support all FIF flags so its possible we don't
793 * need to do anything */
797 if (*new_flags
& (FIF_PROMISC_IN_BSS
| FIF_ALLMULTI
)) {
798 zd_mc_add_all(&hash
);
800 DECLARE_MAC_BUF(macbuf
);
803 for (i
= 0; i
< mc_count
; i
++) {
806 dev_dbg_f(zd_mac_dev(mac
), "mc addr %s\n",
807 print_mac(macbuf
, mclist
->dmi_addr
));
808 zd_mc_add_addr(&hash
, mclist
->dmi_addr
);
809 mclist
= mclist
->next
;
813 spin_lock_irqsave(&mac
->lock
, flags
);
814 mac
->pass_failed_fcs
= !!(*new_flags
& FIF_FCSFAIL
);
815 mac
->pass_ctrl
= !!(*new_flags
& FIF_CONTROL
);
816 mac
->multicast_hash
= hash
;
817 spin_unlock_irqrestore(&mac
->lock
, flags
);
818 queue_work(zd_workqueue
, &mac
->set_multicast_hash_work
);
820 if (changed_flags
& FIF_CONTROL
)
821 queue_work(zd_workqueue
, &mac
->set_rx_filter_work
);
823 /* no handling required for FIF_OTHER_BSS as we don't currently
824 * do BSSID filtering */
825 /* FIXME: in future it would be nice to enable the probe response
826 * filter (so that the driver doesn't see them) until
827 * FIF_BCN_PRBRESP_PROMISC is set. however due to atomicity here, we'd
828 * have to schedule work to enable prbresp reception, which might
829 * happen too late. For now we'll just listen and forward them all the
833 static void set_rts_cts_work(struct work_struct
*work
)
836 container_of(work
, struct zd_mac
, set_rts_cts_work
);
838 unsigned int short_preamble
;
840 mutex_lock(&mac
->chip
.mutex
);
842 spin_lock_irqsave(&mac
->lock
, flags
);
843 mac
->updating_rts_rate
= 0;
844 short_preamble
= mac
->short_preamble
;
845 spin_unlock_irqrestore(&mac
->lock
, flags
);
847 zd_chip_set_rts_cts_rate_locked(&mac
->chip
, short_preamble
);
848 mutex_unlock(&mac
->chip
.mutex
);
851 static void zd_op_erp_ie_changed(struct ieee80211_hw
*hw
, u8 changes
,
852 int cts_protection
, int preamble
)
854 struct zd_mac
*mac
= zd_hw_mac(hw
);
857 dev_dbg_f(zd_mac_dev(mac
), "changes: %x\n", changes
);
859 if (changes
& IEEE80211_ERP_CHANGE_PREAMBLE
) {
860 spin_lock_irqsave(&mac
->lock
, flags
);
861 mac
->short_preamble
= !preamble
;
862 if (!mac
->updating_rts_rate
) {
863 mac
->updating_rts_rate
= 1;
864 /* FIXME: should disable TX here, until work has
865 * completed and RTS_CTS reg is updated */
866 queue_work(zd_workqueue
, &mac
->set_rts_cts_work
);
868 spin_unlock_irqrestore(&mac
->lock
, flags
);
872 static const struct ieee80211_ops zd_ops
= {
874 .start
= zd_op_start
,
876 .add_interface
= zd_op_add_interface
,
877 .remove_interface
= zd_op_remove_interface
,
878 .config
= zd_op_config
,
879 .config_interface
= zd_op_config_interface
,
880 .configure_filter
= zd_op_configure_filter
,
881 .erp_ie_changed
= zd_op_erp_ie_changed
,
884 struct ieee80211_hw
*zd_mac_alloc_hw(struct usb_interface
*intf
)
887 struct ieee80211_hw
*hw
;
890 hw
= ieee80211_alloc_hw(sizeof(struct zd_mac
), &zd_ops
);
892 dev_dbg_f(&intf
->dev
, "out of memory\n");
898 memset(mac
, 0, sizeof(*mac
));
899 spin_lock_init(&mac
->lock
);
902 mac
->type
= IEEE80211_IF_TYPE_INVALID
;
904 memcpy(mac
->channels
, zd_channels
, sizeof(zd_channels
));
905 memcpy(mac
->rates
, zd_rates
, sizeof(zd_rates
));
906 mac
->modes
[0].mode
= MODE_IEEE80211G
;
907 mac
->modes
[0].num_rates
= ARRAY_SIZE(zd_rates
);
908 mac
->modes
[0].rates
= mac
->rates
;
909 mac
->modes
[0].num_channels
= ARRAY_SIZE(zd_channels
);
910 mac
->modes
[0].channels
= mac
->channels
;
911 mac
->modes
[1].mode
= MODE_IEEE80211B
;
912 mac
->modes
[1].num_rates
= 4;
913 mac
->modes
[1].rates
= mac
->rates
;
914 mac
->modes
[1].num_channels
= ARRAY_SIZE(zd_channels
);
915 mac
->modes
[1].channels
= mac
->channels
;
917 hw
->flags
= IEEE80211_HW_RX_INCLUDES_FCS
|
918 IEEE80211_HW_DEFAULT_REG_DOMAIN_CONFIGURED
;
920 hw
->max_signal
= 100;
923 hw
->extra_tx_headroom
= sizeof(struct zd_ctrlset
);
925 skb_queue_head_init(&mac
->ack_wait_queue
);
927 for (i
= 0; i
< 2; i
++) {
928 if (ieee80211_register_hwmode(hw
, &mac
->modes
[i
])) {
929 dev_dbg_f(&intf
->dev
, "cannot register hwmode\n");
930 ieee80211_free_hw(hw
);
935 zd_chip_init(&mac
->chip
, hw
, intf
);
936 housekeeping_init(mac
);
937 INIT_WORK(&mac
->set_multicast_hash_work
, set_multicast_hash_handler
);
938 INIT_WORK(&mac
->set_rts_cts_work
, set_rts_cts_work
);
939 INIT_WORK(&mac
->set_rx_filter_work
, set_rx_filter_handler
);
941 SET_IEEE80211_DEV(hw
, &intf
->dev
);
945 #define LINK_LED_WORK_DELAY HZ
947 static void link_led_handler(struct work_struct
*work
)
950 container_of(work
, struct zd_mac
, housekeeping
.link_led_work
.work
);
951 struct zd_chip
*chip
= &mac
->chip
;
955 spin_lock_irq(&mac
->lock
);
956 is_associated
= mac
->associated
;
957 spin_unlock_irq(&mac
->lock
);
959 r
= zd_chip_control_leds(chip
,
960 is_associated
? LED_ASSOCIATED
: LED_SCANNING
);
962 dev_dbg_f(zd_mac_dev(mac
), "zd_chip_control_leds error %d\n", r
);
964 queue_delayed_work(zd_workqueue
, &mac
->housekeeping
.link_led_work
,
965 LINK_LED_WORK_DELAY
);
968 static void housekeeping_init(struct zd_mac
*mac
)
970 INIT_DELAYED_WORK(&mac
->housekeeping
.link_led_work
, link_led_handler
);
973 static void housekeeping_enable(struct zd_mac
*mac
)
975 dev_dbg_f(zd_mac_dev(mac
), "\n");
976 queue_delayed_work(zd_workqueue
, &mac
->housekeeping
.link_led_work
,
980 static void housekeeping_disable(struct zd_mac
*mac
)
982 dev_dbg_f(zd_mac_dev(mac
), "\n");
983 cancel_rearming_delayed_workqueue(zd_workqueue
,
984 &mac
->housekeeping
.link_led_work
);
985 zd_chip_control_leds(&mac
->chip
, LED_OFF
);