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 void zd_mac_config_beacon(struct ieee80211_hw
*hw
, struct sk_buff
*beacon
)
480 struct zd_mac
*mac
= zd_hw_mac(hw
);
482 /* 4 more bytes for tail CRC */
483 u32 full_len
= beacon
->len
+ 4;
484 zd_iowrite32(&mac
->chip
, CR_BCN_FIFO_SEMAPHORE
, 0);
485 zd_ioread32(&mac
->chip
, CR_BCN_FIFO_SEMAPHORE
, &tmp
);
487 zd_ioread32(&mac
->chip
, CR_BCN_FIFO_SEMAPHORE
, &tmp
);
488 if ((++j
% 100) == 0) {
489 printk(KERN_ERR
"CR_BCN_FIFO_SEMAPHORE not ready\n");
491 printk(KERN_ERR
"Giving up beacon config.\n");
498 zd_iowrite32(&mac
->chip
, CR_BCN_FIFO
, full_len
- 1);
499 if (zd_chip_is_zd1211b(&mac
->chip
))
500 zd_iowrite32(&mac
->chip
, CR_BCN_LENGTH
, full_len
- 1);
502 for (j
= 0 ; j
< beacon
->len
; j
++)
503 zd_iowrite32(&mac
->chip
, CR_BCN_FIFO
,
504 *((u8
*)(beacon
->data
+ j
)));
506 for (j
= 0; j
< 4; j
++)
507 zd_iowrite32(&mac
->chip
, CR_BCN_FIFO
, 0x0);
509 zd_iowrite32(&mac
->chip
, CR_BCN_FIFO_SEMAPHORE
, 1);
510 /* 802.11b/g 2.4G CCK 1Mb
511 * 802.11a, not yet implemented, uses different values (see GPL vendor
514 zd_iowrite32(&mac
->chip
, CR_BCN_PLCP_CFG
, 0x00000400 |
518 static int fill_ctrlset(struct zd_mac
*mac
,
520 struct ieee80211_tx_control
*control
)
523 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
524 unsigned int frag_len
= skb
->len
+ FCS_LEN
;
525 unsigned int packet_length
;
526 struct zd_ctrlset
*cs
= (struct zd_ctrlset
*)
527 skb_push(skb
, sizeof(struct zd_ctrlset
));
529 ZD_ASSERT(frag_len
<= 0xffff);
531 cs
->modulation
= control
->tx_rate
->hw_value
;
532 if (control
->flags
& IEEE80211_TXCTL_SHORT_PREAMBLE
)
533 cs
->modulation
= control
->tx_rate
->hw_value_short
;
535 cs
->tx_length
= cpu_to_le16(frag_len
);
537 cs_set_control(mac
, cs
, hdr
, control
->flags
);
539 packet_length
= frag_len
+ sizeof(struct zd_ctrlset
) + 10;
540 ZD_ASSERT(packet_length
<= 0xffff);
541 /* ZD1211B: Computing the length difference this way, gives us
542 * flexibility to compute the packet length.
544 cs
->packet_length
= cpu_to_le16(zd_chip_is_zd1211b(&mac
->chip
) ?
545 packet_length
- frag_len
: packet_length
);
549 * - transmit frame length in microseconds
550 * - seems to be derived from frame length
551 * - see Cal_Us_Service() in zdinlinef.h
552 * - if macp->bTxBurstEnable is enabled, then multiply by 4
553 * - bTxBurstEnable is never set in the vendor driver
556 * - "for PLCP configuration"
557 * - always 0 except in some situations at 802.11b 11M
558 * - see line 53 of zdinlinef.h
561 r
= zd_calc_tx_length_us(&cs
->service
, ZD_RATE(cs
->modulation
),
562 le16_to_cpu(cs
->tx_length
));
565 cs
->current_length
= cpu_to_le16(r
);
566 cs
->next_frame_length
= 0;
572 * zd_op_tx - transmits a network frame to the device
574 * @dev: mac80211 hardware device
575 * @skb: socket buffer
576 * @control: the control structure
578 * This function transmit an IEEE 802.11 network frame to the device. The
579 * control block of the skbuff will be initialized. If necessary the incoming
580 * mac80211 queues will be stopped.
582 static int zd_op_tx(struct ieee80211_hw
*hw
, struct sk_buff
*skb
,
583 struct ieee80211_tx_control
*control
)
585 struct zd_mac
*mac
= zd_hw_mac(hw
);
588 r
= fill_ctrlset(mac
, skb
, control
);
592 r
= init_tx_skb_control_block(skb
, hw
, control
);
595 r
= zd_usb_tx(&mac
->chip
.usb
, skb
);
597 clear_tx_skb_control_block(skb
);
604 * filter_ack - filters incoming packets for acknowledgements
605 * @dev: the mac80211 device
606 * @rx_hdr: received header
607 * @stats: the status for the received packet
609 * This functions looks for ACK packets and tries to match them with the
610 * frames in the tx queue. If a match is found the frame will be dequeued and
611 * the upper layers is informed about the successful transmission. If
612 * mac80211 queues have been stopped and the number of frames still to be
613 * transmitted is low the queues will be opened again.
615 * Returns 1 if the frame was an ACK, 0 if it was ignored.
617 static int filter_ack(struct ieee80211_hw
*hw
, struct ieee80211_hdr
*rx_hdr
,
618 struct ieee80211_rx_status
*stats
)
620 u16 fc
= le16_to_cpu(rx_hdr
->frame_control
);
622 struct sk_buff_head
*q
;
625 if ((fc
& (IEEE80211_FCTL_FTYPE
| IEEE80211_FCTL_STYPE
)) !=
626 (IEEE80211_FTYPE_CTL
| IEEE80211_STYPE_ACK
))
629 q
= &zd_hw_mac(hw
)->ack_wait_queue
;
630 spin_lock_irqsave(&q
->lock
, flags
);
631 for (skb
= q
->next
; skb
!= (struct sk_buff
*)q
; skb
= skb
->next
) {
632 struct ieee80211_hdr
*tx_hdr
;
634 tx_hdr
= (struct ieee80211_hdr
*)skb
->data
;
635 if (likely(!compare_ether_addr(tx_hdr
->addr2
, rx_hdr
->addr1
)))
637 struct ieee80211_tx_status status
;
639 memset(&status
, 0, sizeof(status
));
640 status
.flags
= IEEE80211_TX_STATUS_ACK
;
641 status
.ack_signal
= stats
->ssi
;
642 __skb_unlink(skb
, q
);
643 tx_status(hw
, skb
, &status
, 1);
648 spin_unlock_irqrestore(&q
->lock
, flags
);
652 int zd_mac_rx(struct ieee80211_hw
*hw
, const u8
*buffer
, unsigned int length
)
654 struct zd_mac
*mac
= zd_hw_mac(hw
);
655 struct ieee80211_rx_status stats
;
656 const struct rx_status
*status
;
660 bool is_qos
, is_4addr
, need_padding
;
664 if (length
< ZD_PLCP_HEADER_SIZE
+ 10 /* IEEE80211_1ADDR_LEN */ +
665 FCS_LEN
+ sizeof(struct rx_status
))
668 memset(&stats
, 0, sizeof(stats
));
670 /* Note about pass_failed_fcs and pass_ctrl access below:
671 * mac locking intentionally omitted here, as this is the only unlocked
672 * reader and the only writer is configure_filter. Plus, if there were
673 * any races accessing these variables, it wouldn't really matter.
674 * If mac80211 ever provides a way for us to access filter flags
675 * from outside configure_filter, we could improve on this. Also, this
676 * situation may change once we implement some kind of DMA-into-skb
679 /* Caller has to ensure that length >= sizeof(struct rx_status). */
680 status
= (struct rx_status
*)
681 (buffer
+ (length
- sizeof(struct rx_status
)));
682 if (status
->frame_status
& ZD_RX_ERROR
) {
683 if (mac
->pass_failed_fcs
&&
684 (status
->frame_status
& ZD_RX_CRC32_ERROR
)) {
685 stats
.flag
|= RX_FLAG_FAILED_FCS_CRC
;
692 stats
.freq
= zd_channels
[_zd_chip_get_channel(&mac
->chip
) - 1].center_freq
;
693 stats
.band
= IEEE80211_BAND_2GHZ
;
694 stats
.ssi
= status
->signal_strength
;
695 stats
.signal
= zd_rx_qual_percent(buffer
,
696 length
- sizeof(struct rx_status
),
699 rate
= zd_rx_rate(buffer
, status
);
701 /* todo: return index in the big switches in zd_rx_rate instead */
702 for (i
= 0; i
< mac
->band
.n_bitrates
; i
++)
703 if (rate
== mac
->band
.bitrates
[i
].hw_value
)
706 length
-= ZD_PLCP_HEADER_SIZE
+ sizeof(struct rx_status
);
707 buffer
+= ZD_PLCP_HEADER_SIZE
;
709 /* Except for bad frames, filter each frame to see if it is an ACK, in
710 * which case our internal TX tracking is updated. Normally we then
711 * bail here as there's no need to pass ACKs on up to the stack, but
712 * there is also the case where the stack has requested us to pass
713 * control frames on up (pass_ctrl) which we must consider. */
715 filter_ack(hw
, (struct ieee80211_hdr
*)buffer
, &stats
)
719 fc
= le16_to_cpu(*((__le16
*) buffer
));
721 is_qos
= ((fc
& IEEE80211_FCTL_FTYPE
) == IEEE80211_FTYPE_DATA
) &&
722 (fc
& IEEE80211_STYPE_QOS_DATA
);
723 is_4addr
= (fc
& (IEEE80211_FCTL_TODS
| IEEE80211_FCTL_FROMDS
)) ==
724 (IEEE80211_FCTL_TODS
| IEEE80211_FCTL_FROMDS
);
725 need_padding
= is_qos
^ is_4addr
;
727 skb
= dev_alloc_skb(length
+ (need_padding
? 2 : 0));
731 /* Make sure the the payload data is 4 byte aligned. */
735 memcpy(skb_put(skb
, length
), buffer
, length
);
737 ieee80211_rx_irqsafe(hw
, skb
, &stats
);
741 static int zd_op_add_interface(struct ieee80211_hw
*hw
,
742 struct ieee80211_if_init_conf
*conf
)
744 struct zd_mac
*mac
= zd_hw_mac(hw
);
746 /* using IEEE80211_IF_TYPE_INVALID to indicate no mode selected */
747 if (mac
->type
!= IEEE80211_IF_TYPE_INVALID
)
750 switch (conf
->type
) {
751 case IEEE80211_IF_TYPE_MNTR
:
752 case IEEE80211_IF_TYPE_MESH_POINT
:
753 case IEEE80211_IF_TYPE_STA
:
754 mac
->type
= conf
->type
;
760 return zd_write_mac_addr(&mac
->chip
, conf
->mac_addr
);
763 static void zd_op_remove_interface(struct ieee80211_hw
*hw
,
764 struct ieee80211_if_init_conf
*conf
)
766 struct zd_mac
*mac
= zd_hw_mac(hw
);
767 mac
->type
= IEEE80211_IF_TYPE_INVALID
;
768 zd_set_beacon_interval(&mac
->chip
, 0);
769 zd_write_mac_addr(&mac
->chip
, NULL
);
772 static int zd_op_config(struct ieee80211_hw
*hw
, struct ieee80211_conf
*conf
)
774 struct zd_mac
*mac
= zd_hw_mac(hw
);
775 return zd_chip_set_channel(&mac
->chip
, conf
->channel
->hw_value
);
778 static int zd_op_config_interface(struct ieee80211_hw
*hw
,
779 struct ieee80211_vif
*vif
,
780 struct ieee80211_if_conf
*conf
)
782 struct zd_mac
*mac
= zd_hw_mac(hw
);
785 if (mac
->type
== IEEE80211_IF_TYPE_MESH_POINT
) {
788 zd_mac_config_beacon(hw
, conf
->beacon
);
789 kfree_skb(conf
->beacon
);
790 zd_set_beacon_interval(&mac
->chip
, BCN_MODE_IBSS
|
791 hw
->conf
.beacon_int
);
794 associated
= is_valid_ether_addr(conf
->bssid
);
796 spin_lock_irq(&mac
->lock
);
797 mac
->associated
= associated
;
798 spin_unlock_irq(&mac
->lock
);
800 /* TODO: do hardware bssid filtering */
804 void zd_process_intr(struct work_struct
*work
)
807 struct zd_mac
*mac
= container_of(work
, struct zd_mac
, process_intr
);
809 int_status
= le16_to_cpu(*(__le16
*)(mac
->intr_buffer
+4));
810 if (int_status
& INT_CFG_NEXT_BCN
) {
812 dev_dbg_f(zd_mac_dev(mac
), "INT_CFG_NEXT_BCN\n");
814 dev_dbg_f(zd_mac_dev(mac
), "Unsupported interrupt\n");
816 zd_chip_enable_hwint(&mac
->chip
);
820 static void set_multicast_hash_handler(struct work_struct
*work
)
823 container_of(work
, struct zd_mac
, set_multicast_hash_work
);
824 struct zd_mc_hash hash
;
826 spin_lock_irq(&mac
->lock
);
827 hash
= mac
->multicast_hash
;
828 spin_unlock_irq(&mac
->lock
);
830 zd_chip_set_multicast_hash(&mac
->chip
, &hash
);
833 static void set_rx_filter_handler(struct work_struct
*work
)
836 container_of(work
, struct zd_mac
, set_rx_filter_work
);
839 dev_dbg_f(zd_mac_dev(mac
), "\n");
840 r
= set_rx_filter(mac
);
842 dev_err(zd_mac_dev(mac
), "set_rx_filter_handler error %d\n", r
);
845 #define SUPPORTED_FIF_FLAGS \
846 (FIF_PROMISC_IN_BSS | FIF_ALLMULTI | FIF_FCSFAIL | FIF_CONTROL | \
847 FIF_OTHER_BSS | FIF_BCN_PRBRESP_PROMISC)
848 static void zd_op_configure_filter(struct ieee80211_hw
*hw
,
849 unsigned int changed_flags
,
850 unsigned int *new_flags
,
851 int mc_count
, struct dev_mc_list
*mclist
)
853 struct zd_mc_hash hash
;
854 struct zd_mac
*mac
= zd_hw_mac(hw
);
858 /* Only deal with supported flags */
859 changed_flags
&= SUPPORTED_FIF_FLAGS
;
860 *new_flags
&= SUPPORTED_FIF_FLAGS
;
862 /* changed_flags is always populated but this driver
863 * doesn't support all FIF flags so its possible we don't
864 * need to do anything */
868 if (*new_flags
& (FIF_PROMISC_IN_BSS
| FIF_ALLMULTI
)) {
869 zd_mc_add_all(&hash
);
871 DECLARE_MAC_BUF(macbuf
);
874 for (i
= 0; i
< mc_count
; i
++) {
877 dev_dbg_f(zd_mac_dev(mac
), "mc addr %s\n",
878 print_mac(macbuf
, mclist
->dmi_addr
));
879 zd_mc_add_addr(&hash
, mclist
->dmi_addr
);
880 mclist
= mclist
->next
;
884 spin_lock_irqsave(&mac
->lock
, flags
);
885 mac
->pass_failed_fcs
= !!(*new_flags
& FIF_FCSFAIL
);
886 mac
->pass_ctrl
= !!(*new_flags
& FIF_CONTROL
);
887 mac
->multicast_hash
= hash
;
888 spin_unlock_irqrestore(&mac
->lock
, flags
);
889 queue_work(zd_workqueue
, &mac
->set_multicast_hash_work
);
891 if (changed_flags
& FIF_CONTROL
)
892 queue_work(zd_workqueue
, &mac
->set_rx_filter_work
);
894 /* no handling required for FIF_OTHER_BSS as we don't currently
895 * do BSSID filtering */
896 /* FIXME: in future it would be nice to enable the probe response
897 * filter (so that the driver doesn't see them) until
898 * FIF_BCN_PRBRESP_PROMISC is set. however due to atomicity here, we'd
899 * have to schedule work to enable prbresp reception, which might
900 * happen too late. For now we'll just listen and forward them all the
904 static void set_rts_cts_work(struct work_struct
*work
)
907 container_of(work
, struct zd_mac
, set_rts_cts_work
);
909 unsigned int short_preamble
;
911 mutex_lock(&mac
->chip
.mutex
);
913 spin_lock_irqsave(&mac
->lock
, flags
);
914 mac
->updating_rts_rate
= 0;
915 short_preamble
= mac
->short_preamble
;
916 spin_unlock_irqrestore(&mac
->lock
, flags
);
918 zd_chip_set_rts_cts_rate_locked(&mac
->chip
, short_preamble
);
919 mutex_unlock(&mac
->chip
.mutex
);
922 static void zd_op_bss_info_changed(struct ieee80211_hw
*hw
,
923 struct ieee80211_vif
*vif
,
924 struct ieee80211_bss_conf
*bss_conf
,
927 struct zd_mac
*mac
= zd_hw_mac(hw
);
930 dev_dbg_f(zd_mac_dev(mac
), "changes: %x\n", changes
);
932 if (changes
& BSS_CHANGED_ERP_PREAMBLE
) {
933 spin_lock_irqsave(&mac
->lock
, flags
);
934 mac
->short_preamble
= bss_conf
->use_short_preamble
;
935 if (!mac
->updating_rts_rate
) {
936 mac
->updating_rts_rate
= 1;
937 /* FIXME: should disable TX here, until work has
938 * completed and RTS_CTS reg is updated */
939 queue_work(zd_workqueue
, &mac
->set_rts_cts_work
);
941 spin_unlock_irqrestore(&mac
->lock
, flags
);
945 static const struct ieee80211_ops zd_ops
= {
947 .start
= zd_op_start
,
949 .add_interface
= zd_op_add_interface
,
950 .remove_interface
= zd_op_remove_interface
,
951 .config
= zd_op_config
,
952 .config_interface
= zd_op_config_interface
,
953 .configure_filter
= zd_op_configure_filter
,
954 .bss_info_changed
= zd_op_bss_info_changed
,
957 struct ieee80211_hw
*zd_mac_alloc_hw(struct usb_interface
*intf
)
960 struct ieee80211_hw
*hw
;
962 hw
= ieee80211_alloc_hw(sizeof(struct zd_mac
), &zd_ops
);
964 dev_dbg_f(&intf
->dev
, "out of memory\n");
970 memset(mac
, 0, sizeof(*mac
));
971 spin_lock_init(&mac
->lock
);
974 mac
->type
= IEEE80211_IF_TYPE_INVALID
;
976 memcpy(mac
->channels
, zd_channels
, sizeof(zd_channels
));
977 memcpy(mac
->rates
, zd_rates
, sizeof(zd_rates
));
978 mac
->band
.n_bitrates
= ARRAY_SIZE(zd_rates
);
979 mac
->band
.bitrates
= mac
->rates
;
980 mac
->band
.n_channels
= ARRAY_SIZE(zd_channels
);
981 mac
->band
.channels
= mac
->channels
;
983 hw
->wiphy
->bands
[IEEE80211_BAND_2GHZ
] = &mac
->band
;
985 hw
->flags
= IEEE80211_HW_RX_INCLUDES_FCS
|
986 IEEE80211_HW_HOST_GEN_BEACON_TEMPLATE
;
988 hw
->max_signal
= 100;
991 hw
->extra_tx_headroom
= sizeof(struct zd_ctrlset
);
993 skb_queue_head_init(&mac
->ack_wait_queue
);
995 zd_chip_init(&mac
->chip
, hw
, intf
);
996 housekeeping_init(mac
);
997 INIT_WORK(&mac
->set_multicast_hash_work
, set_multicast_hash_handler
);
998 INIT_WORK(&mac
->set_rts_cts_work
, set_rts_cts_work
);
999 INIT_WORK(&mac
->set_rx_filter_work
, set_rx_filter_handler
);
1000 INIT_WORK(&mac
->process_intr
, zd_process_intr
);
1002 SET_IEEE80211_DEV(hw
, &intf
->dev
);
1006 #define LINK_LED_WORK_DELAY HZ
1008 static void link_led_handler(struct work_struct
*work
)
1010 struct zd_mac
*mac
=
1011 container_of(work
, struct zd_mac
, housekeeping
.link_led_work
.work
);
1012 struct zd_chip
*chip
= &mac
->chip
;
1016 spin_lock_irq(&mac
->lock
);
1017 is_associated
= mac
->associated
;
1018 spin_unlock_irq(&mac
->lock
);
1020 r
= zd_chip_control_leds(chip
,
1021 is_associated
? LED_ASSOCIATED
: LED_SCANNING
);
1023 dev_dbg_f(zd_mac_dev(mac
), "zd_chip_control_leds error %d\n", r
);
1025 queue_delayed_work(zd_workqueue
, &mac
->housekeeping
.link_led_work
,
1026 LINK_LED_WORK_DELAY
);
1029 static void housekeeping_init(struct zd_mac
*mac
)
1031 INIT_DELAYED_WORK(&mac
->housekeeping
.link_led_work
, link_led_handler
);
1034 static void housekeeping_enable(struct zd_mac
*mac
)
1036 dev_dbg_f(zd_mac_dev(mac
), "\n");
1037 queue_delayed_work(zd_workqueue
, &mac
->housekeeping
.link_led_work
,
1041 static void housekeeping_disable(struct zd_mac
*mac
)
1043 dev_dbg_f(zd_mac_dev(mac
), "\n");
1044 cancel_rearming_delayed_workqueue(zd_workqueue
,
1045 &mac
->housekeeping
.link_led_work
);
1046 zd_chip_control_leds(&mac
->chip
, LED_OFF
);