3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation; either version 2 of the License, or
6 * (at your option) any later version.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 #include <linux/netdevice.h>
19 #include <linux/etherdevice.h>
20 #include <linux/wireless.h>
21 #include <linux/usb.h>
22 #include <linux/jiffies.h>
23 #include <net/ieee80211_radiotap.h>
28 #include "zd_ieee80211.h"
29 #include "zd_netdev.h"
33 static void ieee_init(struct ieee80211_device
*ieee
);
34 static void softmac_init(struct ieee80211softmac_device
*sm
);
36 static void housekeeping_init(struct zd_mac
*mac
);
37 static void housekeeping_enable(struct zd_mac
*mac
);
38 static void housekeeping_disable(struct zd_mac
*mac
);
40 int zd_mac_init(struct zd_mac
*mac
,
41 struct net_device
*netdev
,
42 struct usb_interface
*intf
)
44 struct ieee80211_device
*ieee
= zd_netdev_ieee80211(netdev
);
46 memset(mac
, 0, sizeof(*mac
));
47 spin_lock_init(&mac
->lock
);
51 softmac_init(ieee80211_priv(netdev
));
52 zd_chip_init(&mac
->chip
, netdev
, intf
);
53 housekeeping_init(mac
);
57 static int reset_channel(struct zd_mac
*mac
)
61 const struct channel_range
*range
;
63 spin_lock_irqsave(&mac
->lock
, flags
);
64 range
= zd_channel_range(mac
->regdomain
);
69 mac
->requested_channel
= range
->start
;
72 spin_unlock_irqrestore(&mac
->lock
, flags
);
76 int zd_mac_init_hw(struct zd_mac
*mac
, u8 device_type
)
79 struct zd_chip
*chip
= &mac
->chip
;
83 r
= zd_chip_enable_int(chip
);
86 r
= zd_chip_init_hw(chip
, device_type
);
90 zd_get_e2p_mac_addr(chip
, addr
);
91 r
= zd_write_mac_addr(chip
, addr
);
94 ZD_ASSERT(!irqs_disabled());
95 spin_lock_irq(&mac
->lock
);
96 memcpy(mac
->netdev
->dev_addr
, addr
, ETH_ALEN
);
97 spin_unlock_irq(&mac
->lock
);
99 r
= zd_read_regdomain(chip
, &default_regdomain
);
102 if (!zd_regdomain_supported(default_regdomain
)) {
103 dev_dbg_f(zd_mac_dev(mac
),
104 "Regulatory Domain %#04x is not supported.\n",
109 spin_lock_irq(&mac
->lock
);
110 mac
->regdomain
= mac
->default_regdomain
= default_regdomain
;
111 spin_unlock_irq(&mac
->lock
);
112 r
= reset_channel(mac
);
116 /* We must inform the device that we are doing encryption/decryption in
117 * software at the moment. */
118 r
= zd_set_encryption_type(chip
, ENC_SNIFFER
);
122 r
= zd_geo_init(zd_mac_to_ieee80211(mac
), mac
->regdomain
);
128 zd_chip_disable_int(chip
);
133 void zd_mac_clear(struct zd_mac
*mac
)
135 zd_chip_clear(&mac
->chip
);
136 ZD_ASSERT(!spin_is_locked(&mac
->lock
));
137 ZD_MEMCLEAR(mac
, sizeof(struct zd_mac
));
140 static int reset_mode(struct zd_mac
*mac
)
142 struct ieee80211_device
*ieee
= zd_mac_to_ieee80211(mac
);
143 struct zd_ioreq32 ioreqs
[3] = {
144 { CR_RX_FILTER
, STA_RX_FILTER
},
145 { CR_SNIFFER_ON
, 0U },
148 if (ieee
->iw_mode
== IW_MODE_MONITOR
) {
149 ioreqs
[0].value
= 0xffffffff;
150 ioreqs
[1].value
= 0x1;
151 ioreqs
[2].value
= ENC_SNIFFER
;
154 return zd_iowrite32a(&mac
->chip
, ioreqs
, 3);
157 int zd_mac_open(struct net_device
*netdev
)
159 struct zd_mac
*mac
= zd_netdev_mac(netdev
);
160 struct zd_chip
*chip
= &mac
->chip
;
163 r
= zd_chip_enable_int(chip
);
167 r
= zd_chip_set_basic_rates(chip
, CR_RATES_80211B
| CR_RATES_80211G
);
173 r
= zd_chip_switch_radio_on(chip
);
176 r
= zd_chip_set_channel(chip
, mac
->requested_channel
);
179 r
= zd_chip_enable_rx(chip
);
182 r
= zd_chip_enable_hwint(chip
);
186 housekeeping_enable(mac
);
187 ieee80211softmac_start(netdev
);
190 zd_chip_disable_rx(chip
);
192 zd_chip_switch_radio_off(chip
);
194 zd_chip_disable_int(chip
);
199 int zd_mac_stop(struct net_device
*netdev
)
201 struct zd_mac
*mac
= zd_netdev_mac(netdev
);
202 struct zd_chip
*chip
= &mac
->chip
;
204 netif_stop_queue(netdev
);
207 * The order here deliberately is a little different from the open()
208 * method, since we need to make sure there is no opportunity for RX
209 * frames to be processed by softmac after we have stopped it.
212 zd_chip_disable_rx(chip
);
213 housekeeping_disable(mac
);
214 ieee80211softmac_stop(netdev
);
216 zd_chip_disable_hwint(chip
);
217 zd_chip_switch_radio_off(chip
);
218 zd_chip_disable_int(chip
);
223 int zd_mac_set_mac_address(struct net_device
*netdev
, void *p
)
227 struct sockaddr
*addr
= p
;
228 struct zd_mac
*mac
= zd_netdev_mac(netdev
);
229 struct zd_chip
*chip
= &mac
->chip
;
231 if (!is_valid_ether_addr(addr
->sa_data
))
232 return -EADDRNOTAVAIL
;
234 dev_dbg_f(zd_mac_dev(mac
),
235 "Setting MAC to " MAC_FMT
"\n", MAC_ARG(addr
->sa_data
));
237 r
= zd_write_mac_addr(chip
, addr
->sa_data
);
241 spin_lock_irqsave(&mac
->lock
, flags
);
242 memcpy(netdev
->dev_addr
, addr
->sa_data
, ETH_ALEN
);
243 spin_unlock_irqrestore(&mac
->lock
, flags
);
248 int zd_mac_set_regdomain(struct zd_mac
*mac
, u8 regdomain
)
253 ZD_ASSERT(!irqs_disabled());
254 spin_lock_irq(&mac
->lock
);
255 if (regdomain
== 0) {
256 regdomain
= mac
->default_regdomain
;
258 if (!zd_regdomain_supported(regdomain
)) {
259 spin_unlock_irq(&mac
->lock
);
262 mac
->regdomain
= regdomain
;
263 channel
= mac
->requested_channel
;
264 spin_unlock_irq(&mac
->lock
);
266 r
= zd_geo_init(zd_mac_to_ieee80211(mac
), regdomain
);
269 if (!zd_regdomain_supports_channel(regdomain
, channel
)) {
270 r
= reset_channel(mac
);
278 u8
zd_mac_get_regdomain(struct zd_mac
*mac
)
283 spin_lock_irqsave(&mac
->lock
, flags
);
284 regdomain
= mac
->regdomain
;
285 spin_unlock_irqrestore(&mac
->lock
, flags
);
289 static void set_channel(struct net_device
*netdev
, u8 channel
)
291 struct zd_mac
*mac
= zd_netdev_mac(netdev
);
293 dev_dbg_f(zd_mac_dev(mac
), "channel %d\n", channel
);
295 zd_chip_set_channel(&mac
->chip
, channel
);
298 /* TODO: Should not work in Managed mode. */
299 int zd_mac_request_channel(struct zd_mac
*mac
, u8 channel
)
301 unsigned long lock_flags
;
302 struct ieee80211_device
*ieee
= zd_mac_to_ieee80211(mac
);
304 if (ieee
->iw_mode
== IW_MODE_INFRA
)
307 spin_lock_irqsave(&mac
->lock
, lock_flags
);
308 if (!zd_regdomain_supports_channel(mac
->regdomain
, channel
)) {
309 spin_unlock_irqrestore(&mac
->lock
, lock_flags
);
312 mac
->requested_channel
= channel
;
313 spin_unlock_irqrestore(&mac
->lock
, lock_flags
);
314 if (netif_running(mac
->netdev
))
315 return zd_chip_set_channel(&mac
->chip
, channel
);
320 int zd_mac_get_channel(struct zd_mac
*mac
, u8
*channel
, u8
*flags
)
322 struct ieee80211_device
*ieee
= zd_mac_to_ieee80211(mac
);
324 *channel
= zd_chip_get_channel(&mac
->chip
);
325 if (ieee
->iw_mode
!= IW_MODE_INFRA
) {
326 spin_lock_irq(&mac
->lock
);
327 *flags
= *channel
== mac
->requested_channel
?
328 MAC_FIXED_CHANNEL
: 0;
329 spin_unlock(&mac
->lock
);
333 dev_dbg_f(zd_mac_dev(mac
), "channel %u flags %u\n", *channel
, *flags
);
337 /* If wrong rate is given, we are falling back to the slowest rate: 1MBit/s */
338 static u8
cs_typed_rate(u8 cs_rate
)
340 static const u8 typed_rates
[16] = {
341 [ZD_CS_CCK_RATE_1M
] = ZD_CS_CCK
|ZD_CS_CCK_RATE_1M
,
342 [ZD_CS_CCK_RATE_2M
] = ZD_CS_CCK
|ZD_CS_CCK_RATE_2M
,
343 [ZD_CS_CCK_RATE_5_5M
] = ZD_CS_CCK
|ZD_CS_CCK_RATE_5_5M
,
344 [ZD_CS_CCK_RATE_11M
] = ZD_CS_CCK
|ZD_CS_CCK_RATE_11M
,
345 [ZD_OFDM_RATE_6M
] = ZD_CS_OFDM
|ZD_OFDM_RATE_6M
,
346 [ZD_OFDM_RATE_9M
] = ZD_CS_OFDM
|ZD_OFDM_RATE_9M
,
347 [ZD_OFDM_RATE_12M
] = ZD_CS_OFDM
|ZD_OFDM_RATE_12M
,
348 [ZD_OFDM_RATE_18M
] = ZD_CS_OFDM
|ZD_OFDM_RATE_18M
,
349 [ZD_OFDM_RATE_24M
] = ZD_CS_OFDM
|ZD_OFDM_RATE_24M
,
350 [ZD_OFDM_RATE_36M
] = ZD_CS_OFDM
|ZD_OFDM_RATE_36M
,
351 [ZD_OFDM_RATE_48M
] = ZD_CS_OFDM
|ZD_OFDM_RATE_48M
,
352 [ZD_OFDM_RATE_54M
] = ZD_CS_OFDM
|ZD_OFDM_RATE_54M
,
355 ZD_ASSERT(ZD_CS_RATE_MASK
== 0x0f);
356 return typed_rates
[cs_rate
& ZD_CS_RATE_MASK
];
359 /* Fallback to lowest rate, if rate is unknown. */
360 static u8
rate_to_cs_rate(u8 rate
)
363 case IEEE80211_CCK_RATE_2MB
:
364 return ZD_CS_CCK_RATE_2M
;
365 case IEEE80211_CCK_RATE_5MB
:
366 return ZD_CS_CCK_RATE_5_5M
;
367 case IEEE80211_CCK_RATE_11MB
:
368 return ZD_CS_CCK_RATE_11M
;
369 case IEEE80211_OFDM_RATE_6MB
:
370 return ZD_OFDM_RATE_6M
;
371 case IEEE80211_OFDM_RATE_9MB
:
372 return ZD_OFDM_RATE_9M
;
373 case IEEE80211_OFDM_RATE_12MB
:
374 return ZD_OFDM_RATE_12M
;
375 case IEEE80211_OFDM_RATE_18MB
:
376 return ZD_OFDM_RATE_18M
;
377 case IEEE80211_OFDM_RATE_24MB
:
378 return ZD_OFDM_RATE_24M
;
379 case IEEE80211_OFDM_RATE_36MB
:
380 return ZD_OFDM_RATE_36M
;
381 case IEEE80211_OFDM_RATE_48MB
:
382 return ZD_OFDM_RATE_48M
;
383 case IEEE80211_OFDM_RATE_54MB
:
384 return ZD_OFDM_RATE_54M
;
386 return ZD_CS_CCK_RATE_1M
;
389 int zd_mac_set_mode(struct zd_mac
*mac
, u32 mode
)
391 struct ieee80211_device
*ieee
;
397 mac
->netdev
->type
= ARPHRD_ETHER
;
399 case IW_MODE_MONITOR
:
400 mac
->netdev
->type
= ARPHRD_IEEE80211_RADIOTAP
;
403 dev_dbg_f(zd_mac_dev(mac
), "wrong mode %u\n", mode
);
407 ieee
= zd_mac_to_ieee80211(mac
);
408 ZD_ASSERT(!irqs_disabled());
409 spin_lock_irq(&ieee
->lock
);
410 ieee
->iw_mode
= mode
;
411 spin_unlock_irq(&ieee
->lock
);
413 if (netif_running(mac
->netdev
))
414 return reset_mode(mac
);
419 int zd_mac_get_mode(struct zd_mac
*mac
, u32
*mode
)
422 struct ieee80211_device
*ieee
;
424 ieee
= zd_mac_to_ieee80211(mac
);
425 spin_lock_irqsave(&ieee
->lock
, flags
);
426 *mode
= ieee
->iw_mode
;
427 spin_unlock_irqrestore(&ieee
->lock
, flags
);
431 int zd_mac_get_range(struct zd_mac
*mac
, struct iw_range
*range
)
434 const struct channel_range
*channel_range
;
437 memset(range
, 0, sizeof(*range
));
439 /* FIXME: Not so important and depends on the mode. For 802.11g
440 * usually this value is used. It seems to be that Bit/s number is
443 range
->throughput
= 27 * 1000 * 1000;
445 range
->max_qual
.qual
= 100;
446 range
->max_qual
.level
= 100;
448 /* FIXME: Needs still to be tuned. */
449 range
->avg_qual
.qual
= 71;
450 range
->avg_qual
.level
= 80;
452 /* FIXME: depends on standard? */
453 range
->min_rts
= 256;
454 range
->max_rts
= 2346;
456 range
->min_frag
= MIN_FRAG_THRESHOLD
;
457 range
->max_frag
= MAX_FRAG_THRESHOLD
;
459 range
->max_encoding_tokens
= WEP_KEYS
;
460 range
->num_encoding_sizes
= 2;
461 range
->encoding_size
[0] = 5;
462 range
->encoding_size
[1] = WEP_KEY_LEN
;
464 range
->we_version_compiled
= WIRELESS_EXT
;
465 range
->we_version_source
= 20;
467 ZD_ASSERT(!irqs_disabled());
468 spin_lock_irq(&mac
->lock
);
469 regdomain
= mac
->regdomain
;
470 spin_unlock_irq(&mac
->lock
);
471 channel_range
= zd_channel_range(regdomain
);
473 range
->num_channels
= channel_range
->end
- channel_range
->start
;
474 range
->old_num_channels
= range
->num_channels
;
475 range
->num_frequency
= range
->num_channels
;
476 range
->old_num_frequency
= range
->num_frequency
;
478 for (i
= 0; i
< range
->num_frequency
; i
++) {
479 struct iw_freq
*freq
= &range
->freq
[i
];
480 freq
->i
= channel_range
->start
+ i
;
481 zd_channel_to_freq(freq
, freq
->i
);
487 static int zd_calc_tx_length_us(u8
*service
, u8 cs_rate
, u16 tx_length
)
489 static const u8 rate_divisor
[] = {
490 [ZD_CS_CCK_RATE_1M
] = 1,
491 [ZD_CS_CCK_RATE_2M
] = 2,
492 [ZD_CS_CCK_RATE_5_5M
] = 11, /* bits must be doubled */
493 [ZD_CS_CCK_RATE_11M
] = 11,
494 [ZD_OFDM_RATE_6M
] = 6,
495 [ZD_OFDM_RATE_9M
] = 9,
496 [ZD_OFDM_RATE_12M
] = 12,
497 [ZD_OFDM_RATE_18M
] = 18,
498 [ZD_OFDM_RATE_24M
] = 24,
499 [ZD_OFDM_RATE_36M
] = 36,
500 [ZD_OFDM_RATE_48M
] = 48,
501 [ZD_OFDM_RATE_54M
] = 54,
504 u32 bits
= (u32
)tx_length
* 8;
507 divisor
= rate_divisor
[cs_rate
];
512 case ZD_CS_CCK_RATE_5_5M
:
513 bits
= (2*bits
) + 10; /* round up to the next integer */
515 case ZD_CS_CCK_RATE_11M
:
518 *service
&= ~ZD_PLCP_SERVICE_LENGTH_EXTENSION
;
519 if (0 < t
&& t
<= 3) {
520 *service
|= ZD_PLCP_SERVICE_LENGTH_EXTENSION
;
523 bits
+= 10; /* round up to the next integer */
531 R2M_SHORT_PREAMBLE
= 0x01,
535 static u8
cs_rate_to_modulation(u8 cs_rate
, int flags
)
539 modulation
= cs_typed_rate(cs_rate
);
540 if (flags
& R2M_SHORT_PREAMBLE
) {
541 switch (ZD_CS_RATE(modulation
)) {
542 case ZD_CS_CCK_RATE_2M
:
543 case ZD_CS_CCK_RATE_5_5M
:
544 case ZD_CS_CCK_RATE_11M
:
545 modulation
|= ZD_CS_CCK_PREA_SHORT
;
549 if (flags
& R2M_11A
) {
550 if (ZD_CS_TYPE(modulation
) == ZD_CS_OFDM
)
551 modulation
|= ZD_CS_OFDM_MODE_11A
;
556 static void cs_set_modulation(struct zd_mac
*mac
, struct zd_ctrlset
*cs
,
557 struct ieee80211_hdr_4addr
*hdr
)
559 struct ieee80211softmac_device
*softmac
= ieee80211_priv(mac
->netdev
);
560 u16 ftype
= WLAN_FC_GET_TYPE(le16_to_cpu(hdr
->frame_ctl
));
562 int is_mgt
= (ftype
== IEEE80211_FTYPE_MGMT
) != 0;
564 /* FIXME: 802.11a? short preamble? */
565 rate
= ieee80211softmac_suggest_txrate(softmac
,
566 is_multicast_ether_addr(hdr
->addr1
), is_mgt
);
568 cs_rate
= rate_to_cs_rate(rate
);
569 cs
->modulation
= cs_rate_to_modulation(cs_rate
, 0);
572 static void cs_set_control(struct zd_mac
*mac
, struct zd_ctrlset
*cs
,
573 struct ieee80211_hdr_4addr
*header
)
575 unsigned int tx_length
= le16_to_cpu(cs
->tx_length
);
576 u16 fctl
= le16_to_cpu(header
->frame_ctl
);
577 u16 ftype
= WLAN_FC_GET_TYPE(fctl
);
578 u16 stype
= WLAN_FC_GET_STYPE(fctl
);
583 * - if fragment 0, enable bit 0
584 * - if backoff needed, enable bit 0
585 * - if burst (backoff not needed) disable bit 0
586 * - if multicast, enable bit 1
587 * - if PS-POLL frame, enable bit 2
588 * - if in INDEPENDENT_BSS mode and zd1205_DestPowerSave, then enable
590 * - if frag_len > RTS threshold, set bit 5 as long if it isnt
592 * - if bit 5 is set, and we are in OFDM mode, unset bit 5 and set bit
599 if (WLAN_GET_SEQ_FRAG(le16_to_cpu(header
->seq_ctl
)) == 0)
600 cs
->control
|= ZD_CS_NEED_RANDOM_BACKOFF
;
603 if (is_multicast_ether_addr(header
->addr1
))
604 cs
->control
|= ZD_CS_MULTICAST
;
607 if (stype
== IEEE80211_STYPE_PSPOLL
)
608 cs
->control
|= ZD_CS_PS_POLL_FRAME
;
610 if (!is_multicast_ether_addr(header
->addr1
) &&
611 ftype
!= IEEE80211_FTYPE_MGMT
&&
612 tx_length
> zd_netdev_ieee80211(mac
->netdev
)->rts
)
614 /* FIXME: check the logic */
615 if (ZD_CS_TYPE(cs
->modulation
) == ZD_CS_OFDM
) {
617 cs
->control
|= ZD_CS_SELF_CTS
;
618 } else { /* 802.11b */
619 cs
->control
|= ZD_CS_RTS
;
623 /* FIXME: Management frame? */
626 static int fill_ctrlset(struct zd_mac
*mac
,
627 struct ieee80211_txb
*txb
,
631 struct sk_buff
*skb
= txb
->fragments
[frag_num
];
632 struct ieee80211_hdr_4addr
*hdr
=
633 (struct ieee80211_hdr_4addr
*) skb
->data
;
634 unsigned int frag_len
= skb
->len
+ IEEE80211_FCS_LEN
;
635 unsigned int next_frag_len
;
636 unsigned int packet_length
;
637 struct zd_ctrlset
*cs
= (struct zd_ctrlset
*)
638 skb_push(skb
, sizeof(struct zd_ctrlset
));
640 if (frag_num
+1 < txb
->nr_frags
) {
641 next_frag_len
= txb
->fragments
[frag_num
+1]->len
+
646 ZD_ASSERT(frag_len
<= 0xffff);
647 ZD_ASSERT(next_frag_len
<= 0xffff);
649 cs_set_modulation(mac
, cs
, hdr
);
651 cs
->tx_length
= cpu_to_le16(frag_len
);
653 cs_set_control(mac
, cs
, hdr
);
655 packet_length
= frag_len
+ sizeof(struct zd_ctrlset
) + 10;
656 ZD_ASSERT(packet_length
<= 0xffff);
657 /* ZD1211B: Computing the length difference this way, gives us
658 * flexibility to compute the packet length.
660 cs
->packet_length
= cpu_to_le16(mac
->chip
.is_zd1211b
?
661 packet_length
- frag_len
: packet_length
);
665 * - transmit frame length in microseconds
666 * - seems to be derived from frame length
667 * - see Cal_Us_Service() in zdinlinef.h
668 * - if macp->bTxBurstEnable is enabled, then multiply by 4
669 * - bTxBurstEnable is never set in the vendor driver
672 * - "for PLCP configuration"
673 * - always 0 except in some situations at 802.11b 11M
674 * - see line 53 of zdinlinef.h
677 r
= zd_calc_tx_length_us(&cs
->service
, ZD_CS_RATE(cs
->modulation
),
678 le16_to_cpu(cs
->tx_length
));
681 cs
->current_length
= cpu_to_le16(r
);
683 if (next_frag_len
== 0) {
684 cs
->next_frame_length
= 0;
686 r
= zd_calc_tx_length_us(NULL
, ZD_CS_RATE(cs
->modulation
),
690 cs
->next_frame_length
= cpu_to_le16(r
);
696 static int zd_mac_tx(struct zd_mac
*mac
, struct ieee80211_txb
*txb
, int pri
)
700 for (i
= 0; i
< txb
->nr_frags
; i
++) {
701 struct sk_buff
*skb
= txb
->fragments
[i
];
703 r
= fill_ctrlset(mac
, txb
, i
);
706 r
= zd_usb_tx(&mac
->chip
.usb
, skb
->data
, skb
->len
);
711 /* FIXME: shouldn't this be handled by the upper layers? */
712 mac
->netdev
->trans_start
= jiffies
;
714 ieee80211_txb_free(txb
);
719 struct ieee80211_radiotap_header rt_hdr
;
726 static void fill_rt_header(void *buffer
, struct zd_mac
*mac
,
727 const struct ieee80211_rx_stats
*stats
,
728 const struct rx_status
*status
)
730 struct zd_rt_hdr
*hdr
= buffer
;
732 hdr
->rt_hdr
.it_version
= PKTHDR_RADIOTAP_VERSION
;
733 hdr
->rt_hdr
.it_pad
= 0;
734 hdr
->rt_hdr
.it_len
= cpu_to_le16(sizeof(struct zd_rt_hdr
));
735 hdr
->rt_hdr
.it_present
= cpu_to_le32((1 << IEEE80211_RADIOTAP_FLAGS
) |
736 (1 << IEEE80211_RADIOTAP_CHANNEL
) |
737 (1 << IEEE80211_RADIOTAP_RATE
));
740 if (status
->decryption_type
& (ZD_RX_WEP64
|ZD_RX_WEP128
|ZD_RX_WEP256
))
741 hdr
->rt_flags
|= IEEE80211_RADIOTAP_F_WEP
;
743 hdr
->rt_rate
= stats
->rate
/ 5;
746 hdr
->rt_channel
= cpu_to_le16(ieee80211chan2mhz(
747 _zd_chip_get_channel(&mac
->chip
)));
748 hdr
->rt_chbitmask
= cpu_to_le16(IEEE80211_CHAN_2GHZ
|
749 ((status
->frame_status
& ZD_RX_FRAME_MODULATION_MASK
) ==
750 ZD_RX_OFDM
? IEEE80211_CHAN_OFDM
: IEEE80211_CHAN_CCK
));
753 /* Returns 1 if the data packet is for us and 0 otherwise. */
754 static int is_data_packet_for_us(struct ieee80211_device
*ieee
,
755 struct ieee80211_hdr_4addr
*hdr
)
757 struct net_device
*netdev
= ieee
->dev
;
758 u16 fc
= le16_to_cpu(hdr
->frame_ctl
);
760 ZD_ASSERT(WLAN_FC_GET_TYPE(fc
) == IEEE80211_FTYPE_DATA
);
762 switch (ieee
->iw_mode
) {
764 if ((fc
& (IEEE80211_FCTL_TODS
|IEEE80211_FCTL_FROMDS
)) != 0 ||
765 memcmp(hdr
->addr3
, ieee
->bssid
, ETH_ALEN
) != 0)
770 if ((fc
& (IEEE80211_FCTL_TODS
|IEEE80211_FCTL_FROMDS
)) !=
771 IEEE80211_FCTL_FROMDS
||
772 memcmp(hdr
->addr2
, ieee
->bssid
, ETH_ALEN
) != 0)
776 ZD_ASSERT(ieee
->iw_mode
!= IW_MODE_MONITOR
);
780 return memcmp(hdr
->addr1
, netdev
->dev_addr
, ETH_ALEN
) == 0 ||
781 is_multicast_ether_addr(hdr
->addr1
) ||
782 (netdev
->flags
& IFF_PROMISC
);
785 /* Filters receiving packets. If it returns 1 send it to ieee80211_rx, if 0
786 * return. If an error is detected -EINVAL is returned. ieee80211_rx_mgt() is
789 * It has been based on ieee80211_rx_any.
791 static int filter_rx(struct ieee80211_device
*ieee
,
792 const u8
*buffer
, unsigned int length
,
793 struct ieee80211_rx_stats
*stats
)
795 struct ieee80211_hdr_4addr
*hdr
;
798 if (ieee
->iw_mode
== IW_MODE_MONITOR
)
801 hdr
= (struct ieee80211_hdr_4addr
*)buffer
;
802 fc
= le16_to_cpu(hdr
->frame_ctl
);
803 if ((fc
& IEEE80211_FCTL_VERS
) != 0)
806 switch (WLAN_FC_GET_TYPE(fc
)) {
807 case IEEE80211_FTYPE_MGMT
:
808 if (length
< sizeof(struct ieee80211_hdr_3addr
))
810 ieee80211_rx_mgt(ieee
, hdr
, stats
);
812 case IEEE80211_FTYPE_CTL
:
813 /* Ignore invalid short buffers */
815 case IEEE80211_FTYPE_DATA
:
816 if (length
< sizeof(struct ieee80211_hdr_3addr
))
818 return is_data_packet_for_us(ieee
, hdr
);
824 static void update_qual_rssi(struct zd_mac
*mac
,
825 const u8
*buffer
, unsigned int length
,
826 u8 qual_percent
, u8 rssi_percent
)
829 struct ieee80211_hdr_3addr
*hdr
;
832 hdr
= (struct ieee80211_hdr_3addr
*)buffer
;
833 if (length
< offsetof(struct ieee80211_hdr_3addr
, addr3
))
835 if (memcmp(hdr
->addr2
, zd_mac_to_ieee80211(mac
)->bssid
, ETH_ALEN
) != 0)
838 spin_lock_irqsave(&mac
->lock
, flags
);
839 i
= mac
->stats_count
% ZD_MAC_STATS_BUFFER_SIZE
;
840 mac
->qual_buffer
[i
] = qual_percent
;
841 mac
->rssi_buffer
[i
] = rssi_percent
;
843 spin_unlock_irqrestore(&mac
->lock
, flags
);
846 static int fill_rx_stats(struct ieee80211_rx_stats
*stats
,
847 const struct rx_status
**pstatus
,
849 const u8
*buffer
, unsigned int length
)
851 const struct rx_status
*status
;
853 *pstatus
= status
= zd_tail(buffer
, length
, sizeof(struct rx_status
));
854 if (status
->frame_status
& ZD_RX_ERROR
) {
858 memset(stats
, 0, sizeof(struct ieee80211_rx_stats
));
859 stats
->len
= length
- (ZD_PLCP_HEADER_SIZE
+ IEEE80211_FCS_LEN
+
860 + sizeof(struct rx_status
));
862 stats
->freq
= IEEE80211_24GHZ_BAND
;
863 stats
->received_channel
= _zd_chip_get_channel(&mac
->chip
);
864 stats
->rssi
= zd_rx_strength_percent(status
->signal_strength
);
865 stats
->signal
= zd_rx_qual_percent(buffer
,
866 length
- sizeof(struct rx_status
),
868 stats
->mask
= IEEE80211_STATMASK_RSSI
| IEEE80211_STATMASK_SIGNAL
;
869 stats
->rate
= zd_rx_rate(buffer
, status
);
871 stats
->mask
|= IEEE80211_STATMASK_RATE
;
876 int zd_mac_rx(struct zd_mac
*mac
, const u8
*buffer
, unsigned int length
)
879 struct ieee80211_device
*ieee
= zd_mac_to_ieee80211(mac
);
880 struct ieee80211_rx_stats stats
;
881 const struct rx_status
*status
;
884 if (length
< ZD_PLCP_HEADER_SIZE
+ IEEE80211_1ADDR_LEN
+
885 IEEE80211_FCS_LEN
+ sizeof(struct rx_status
))
888 r
= fill_rx_stats(&stats
, &status
, mac
, buffer
, length
);
892 length
-= ZD_PLCP_HEADER_SIZE
+IEEE80211_FCS_LEN
+
893 sizeof(struct rx_status
);
894 buffer
+= ZD_PLCP_HEADER_SIZE
;
896 update_qual_rssi(mac
, buffer
, length
, stats
.signal
, stats
.rssi
);
898 r
= filter_rx(ieee
, buffer
, length
, &stats
);
902 skb
= dev_alloc_skb(sizeof(struct zd_rt_hdr
) + length
);
905 if (ieee
->iw_mode
== IW_MODE_MONITOR
)
906 fill_rt_header(skb_put(skb
, sizeof(struct zd_rt_hdr
)), mac
,
908 memcpy(skb_put(skb
, length
), buffer
, length
);
910 r
= ieee80211_rx(ieee
, skb
, &stats
);
913 dev_kfree_skb_irq(skb
);
918 static int netdev_tx(struct ieee80211_txb
*txb
, struct net_device
*netdev
,
921 return zd_mac_tx(zd_netdev_mac(netdev
), txb
, pri
);
924 static void set_security(struct net_device
*netdev
,
925 struct ieee80211_security
*sec
)
927 struct ieee80211_device
*ieee
= zd_netdev_ieee80211(netdev
);
928 struct ieee80211_security
*secinfo
= &ieee
->sec
;
931 dev_dbg_f(zd_mac_dev(zd_netdev_mac(netdev
)), "\n");
933 for (keyidx
= 0; keyidx
<WEP_KEYS
; keyidx
++)
934 if (sec
->flags
& (1<<keyidx
)) {
935 secinfo
->encode_alg
[keyidx
] = sec
->encode_alg
[keyidx
];
936 secinfo
->key_sizes
[keyidx
] = sec
->key_sizes
[keyidx
];
937 memcpy(secinfo
->keys
[keyidx
], sec
->keys
[keyidx
],
941 if (sec
->flags
& SEC_ACTIVE_KEY
) {
942 secinfo
->active_key
= sec
->active_key
;
943 dev_dbg_f(zd_mac_dev(zd_netdev_mac(netdev
)),
944 " .active_key = %d\n", sec
->active_key
);
946 if (sec
->flags
& SEC_UNICAST_GROUP
) {
947 secinfo
->unicast_uses_group
= sec
->unicast_uses_group
;
948 dev_dbg_f(zd_mac_dev(zd_netdev_mac(netdev
)),
949 " .unicast_uses_group = %d\n",
950 sec
->unicast_uses_group
);
952 if (sec
->flags
& SEC_LEVEL
) {
953 secinfo
->level
= sec
->level
;
954 dev_dbg_f(zd_mac_dev(zd_netdev_mac(netdev
)),
955 " .level = %d\n", sec
->level
);
957 if (sec
->flags
& SEC_ENABLED
) {
958 secinfo
->enabled
= sec
->enabled
;
959 dev_dbg_f(zd_mac_dev(zd_netdev_mac(netdev
)),
960 " .enabled = %d\n", sec
->enabled
);
962 if (sec
->flags
& SEC_ENCRYPT
) {
963 secinfo
->encrypt
= sec
->encrypt
;
964 dev_dbg_f(zd_mac_dev(zd_netdev_mac(netdev
)),
965 " .encrypt = %d\n", sec
->encrypt
);
967 if (sec
->flags
& SEC_AUTH_MODE
) {
968 secinfo
->auth_mode
= sec
->auth_mode
;
969 dev_dbg_f(zd_mac_dev(zd_netdev_mac(netdev
)),
970 " .auth_mode = %d\n", sec
->auth_mode
);
974 static void ieee_init(struct ieee80211_device
*ieee
)
976 ieee
->mode
= IEEE_B
| IEEE_G
;
977 ieee
->freq_band
= IEEE80211_24GHZ_BAND
;
978 ieee
->modulation
= IEEE80211_OFDM_MODULATION
| IEEE80211_CCK_MODULATION
;
979 ieee
->tx_headroom
= sizeof(struct zd_ctrlset
);
980 ieee
->set_security
= set_security
;
981 ieee
->hard_start_xmit
= netdev_tx
;
983 /* Software encryption/decryption for now */
984 ieee
->host_build_iv
= 0;
985 ieee
->host_encrypt
= 1;
986 ieee
->host_decrypt
= 1;
988 /* FIXME: default to managed mode, until ieee80211 and zd1211rw can
989 * correctly support AUTO */
990 ieee
->iw_mode
= IW_MODE_INFRA
;
993 static void softmac_init(struct ieee80211softmac_device
*sm
)
995 sm
->set_channel
= set_channel
;
998 struct iw_statistics
*zd_mac_get_wireless_stats(struct net_device
*ndev
)
1000 struct zd_mac
*mac
= zd_netdev_mac(ndev
);
1001 struct iw_statistics
*iw_stats
= &mac
->iw_stats
;
1002 unsigned int i
, count
, qual_total
, rssi_total
;
1004 memset(iw_stats
, 0, sizeof(struct iw_statistics
));
1005 /* We are not setting the status, because ieee->state is not updated
1006 * at all and this driver doesn't track authentication state.
1008 spin_lock_irq(&mac
->lock
);
1009 count
= mac
->stats_count
< ZD_MAC_STATS_BUFFER_SIZE
?
1010 mac
->stats_count
: ZD_MAC_STATS_BUFFER_SIZE
;
1011 qual_total
= rssi_total
= 0;
1012 for (i
= 0; i
< count
; i
++) {
1013 qual_total
+= mac
->qual_buffer
[i
];
1014 rssi_total
+= mac
->rssi_buffer
[i
];
1016 spin_unlock_irq(&mac
->lock
);
1017 iw_stats
->qual
.updated
= IW_QUAL_NOISE_INVALID
;
1019 iw_stats
->qual
.qual
= qual_total
/ count
;
1020 iw_stats
->qual
.level
= rssi_total
/ count
;
1021 iw_stats
->qual
.updated
|=
1022 IW_QUAL_QUAL_UPDATED
|IW_QUAL_LEVEL_UPDATED
;
1024 iw_stats
->qual
.updated
|=
1025 IW_QUAL_QUAL_INVALID
|IW_QUAL_LEVEL_INVALID
;
1027 /* TODO: update counter */
1032 static const char* decryption_types
[] = {
1033 [ZD_RX_NO_WEP
] = "none",
1034 [ZD_RX_WEP64
] = "WEP64",
1035 [ZD_RX_TKIP
] = "TKIP",
1036 [ZD_RX_AES
] = "AES",
1037 [ZD_RX_WEP128
] = "WEP128",
1038 [ZD_RX_WEP256
] = "WEP256",
1041 static const char *decryption_type_string(u8 type
)
1045 if (type
< ARRAY_SIZE(decryption_types
)) {
1046 s
= decryption_types
[type
];
1050 return s
? s
: "unknown";
1053 static int is_ofdm(u8 frame_status
)
1055 return (frame_status
& ZD_RX_OFDM
);
1058 void zd_dump_rx_status(const struct rx_status
*status
)
1060 const char* modulation
;
1063 if (is_ofdm(status
->frame_status
)) {
1064 modulation
= "ofdm";
1065 quality
= status
->signal_quality_ofdm
;
1068 quality
= status
->signal_quality_cck
;
1070 pr_debug("rx status %s strength %#04x qual %#04x decryption %s\n",
1071 modulation
, status
->signal_strength
, quality
,
1072 decryption_type_string(status
->decryption_type
));
1073 if (status
->frame_status
& ZD_RX_ERROR
) {
1074 pr_debug("rx error %s%s%s%s%s%s\n",
1075 (status
->frame_status
& ZD_RX_TIMEOUT_ERROR
) ?
1077 (status
->frame_status
& ZD_RX_FIFO_OVERRUN_ERROR
) ?
1079 (status
->frame_status
& ZD_RX_DECRYPTION_ERROR
) ?
1081 (status
->frame_status
& ZD_RX_CRC32_ERROR
) ?
1083 (status
->frame_status
& ZD_RX_NO_ADDR1_MATCH_ERROR
) ?
1085 (status
->frame_status
& ZD_RX_CRC16_ERROR
) ?
1091 #define LINK_LED_WORK_DELAY HZ
1093 static void link_led_handler(void *p
)
1095 struct zd_mac
*mac
= p
;
1096 struct zd_chip
*chip
= &mac
->chip
;
1097 struct ieee80211softmac_device
*sm
= ieee80211_priv(mac
->netdev
);
1101 spin_lock_irq(&mac
->lock
);
1102 is_associated
= sm
->associnfo
.associated
!= 0;
1103 spin_unlock_irq(&mac
->lock
);
1105 r
= zd_chip_control_leds(chip
,
1106 is_associated
? LED_ASSOCIATED
: LED_SCANNING
);
1108 dev_err(zd_mac_dev(mac
), "zd_chip_control_leds error %d\n", r
);
1110 queue_delayed_work(zd_workqueue
, &mac
->housekeeping
.link_led_work
,
1111 LINK_LED_WORK_DELAY
);
1114 static void housekeeping_init(struct zd_mac
*mac
)
1116 INIT_WORK(&mac
->housekeeping
.link_led_work
, link_led_handler
, mac
);
1119 static void housekeeping_enable(struct zd_mac
*mac
)
1121 dev_dbg_f(zd_mac_dev(mac
), "\n");
1122 queue_delayed_work(zd_workqueue
, &mac
->housekeeping
.link_led_work
,
1126 static void housekeeping_disable(struct zd_mac
*mac
)
1128 dev_dbg_f(zd_mac_dev(mac
), "\n");
1129 cancel_rearming_delayed_workqueue(zd_workqueue
,
1130 &mac
->housekeeping
.link_led_work
);
1131 zd_chip_control_leds(&mac
->chip
, LED_OFF
);