2 * Common code for mac80211 Prism54 drivers
4 * Copyright (c) 2006, Michael Wu <flamingice@sourmilk.net>
5 * Copyright (c) 2007, Christian Lamparter <chunkeey@web.de>
6 * Copyright 2008, Johannes Berg <johannes@sipsolutions.net>
9 * - the islsm (softmac prism54) driver, which is:
10 * Copyright 2004-2006 Jean-Baptiste Note <jbnote@gmail.com>, et al.
12 * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies).
14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License version 2 as
16 * published by the Free Software Foundation.
19 #include <linux/init.h>
20 #include <linux/firmware.h>
21 #include <linux/etherdevice.h>
23 #include <net/mac80211.h>
26 #include "p54common.h"
28 static int modparam_nohwcrypt
;
29 module_param_named(nohwcrypt
, modparam_nohwcrypt
, bool, S_IRUGO
);
30 MODULE_PARM_DESC(nohwcrypt
, "Disable hardware encryption.");
31 MODULE_AUTHOR("Michael Wu <flamingice@sourmilk.net>");
32 MODULE_DESCRIPTION("Softmac Prism54 common code");
33 MODULE_LICENSE("GPL");
34 MODULE_ALIAS("prism54common");
36 static struct ieee80211_rate p54_bgrates
[] = {
37 { .bitrate
= 10, .hw_value
= 0, .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
38 { .bitrate
= 20, .hw_value
= 1, .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
39 { .bitrate
= 55, .hw_value
= 2, .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
40 { .bitrate
= 110, .hw_value
= 3, .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
41 { .bitrate
= 60, .hw_value
= 4, },
42 { .bitrate
= 90, .hw_value
= 5, },
43 { .bitrate
= 120, .hw_value
= 6, },
44 { .bitrate
= 180, .hw_value
= 7, },
45 { .bitrate
= 240, .hw_value
= 8, },
46 { .bitrate
= 360, .hw_value
= 9, },
47 { .bitrate
= 480, .hw_value
= 10, },
48 { .bitrate
= 540, .hw_value
= 11, },
51 static struct ieee80211_channel p54_bgchannels
[] = {
52 { .center_freq
= 2412, .hw_value
= 1, },
53 { .center_freq
= 2417, .hw_value
= 2, },
54 { .center_freq
= 2422, .hw_value
= 3, },
55 { .center_freq
= 2427, .hw_value
= 4, },
56 { .center_freq
= 2432, .hw_value
= 5, },
57 { .center_freq
= 2437, .hw_value
= 6, },
58 { .center_freq
= 2442, .hw_value
= 7, },
59 { .center_freq
= 2447, .hw_value
= 8, },
60 { .center_freq
= 2452, .hw_value
= 9, },
61 { .center_freq
= 2457, .hw_value
= 10, },
62 { .center_freq
= 2462, .hw_value
= 11, },
63 { .center_freq
= 2467, .hw_value
= 12, },
64 { .center_freq
= 2472, .hw_value
= 13, },
65 { .center_freq
= 2484, .hw_value
= 14, },
68 static struct ieee80211_supported_band band_2GHz
= {
69 .channels
= p54_bgchannels
,
70 .n_channels
= ARRAY_SIZE(p54_bgchannels
),
71 .bitrates
= p54_bgrates
,
72 .n_bitrates
= ARRAY_SIZE(p54_bgrates
),
75 static struct ieee80211_rate p54_arates
[] = {
76 { .bitrate
= 60, .hw_value
= 4, },
77 { .bitrate
= 90, .hw_value
= 5, },
78 { .bitrate
= 120, .hw_value
= 6, },
79 { .bitrate
= 180, .hw_value
= 7, },
80 { .bitrate
= 240, .hw_value
= 8, },
81 { .bitrate
= 360, .hw_value
= 9, },
82 { .bitrate
= 480, .hw_value
= 10, },
83 { .bitrate
= 540, .hw_value
= 11, },
86 static struct ieee80211_channel p54_achannels
[] = {
87 { .center_freq
= 4920 },
88 { .center_freq
= 4940 },
89 { .center_freq
= 4960 },
90 { .center_freq
= 4980 },
91 { .center_freq
= 5040 },
92 { .center_freq
= 5060 },
93 { .center_freq
= 5080 },
94 { .center_freq
= 5170 },
95 { .center_freq
= 5180 },
96 { .center_freq
= 5190 },
97 { .center_freq
= 5200 },
98 { .center_freq
= 5210 },
99 { .center_freq
= 5220 },
100 { .center_freq
= 5230 },
101 { .center_freq
= 5240 },
102 { .center_freq
= 5260 },
103 { .center_freq
= 5280 },
104 { .center_freq
= 5300 },
105 { .center_freq
= 5320 },
106 { .center_freq
= 5500 },
107 { .center_freq
= 5520 },
108 { .center_freq
= 5540 },
109 { .center_freq
= 5560 },
110 { .center_freq
= 5580 },
111 { .center_freq
= 5600 },
112 { .center_freq
= 5620 },
113 { .center_freq
= 5640 },
114 { .center_freq
= 5660 },
115 { .center_freq
= 5680 },
116 { .center_freq
= 5700 },
117 { .center_freq
= 5745 },
118 { .center_freq
= 5765 },
119 { .center_freq
= 5785 },
120 { .center_freq
= 5805 },
121 { .center_freq
= 5825 },
124 static struct ieee80211_supported_band band_5GHz
= {
125 .channels
= p54_achannels
,
126 .n_channels
= ARRAY_SIZE(p54_achannels
),
127 .bitrates
= p54_arates
,
128 .n_bitrates
= ARRAY_SIZE(p54_arates
),
131 int p54_parse_firmware(struct ieee80211_hw
*dev
, const struct firmware
*fw
)
133 struct p54_common
*priv
= dev
->priv
;
134 struct bootrec_exp_if
*exp_if
;
135 struct bootrec
*bootrec
;
136 u32
*data
= (u32
*)fw
->data
;
137 u32
*end_data
= (u32
*)fw
->data
+ (fw
->size
>> 2);
138 u8
*fw_version
= NULL
;
146 while (data
< end_data
&& *data
)
149 while (data
< end_data
&& !*data
)
152 bootrec
= (struct bootrec
*) data
;
154 while (bootrec
->data
<= end_data
&&
155 (bootrec
->data
+ (len
= le32_to_cpu(bootrec
->len
))) <= end_data
) {
156 u32 code
= le32_to_cpu(bootrec
->code
);
158 case BR_CODE_COMPONENT_ID
:
159 priv
->fw_interface
= be32_to_cpup((__be32
*)
161 switch (priv
->fw_interface
) {
165 char *iftype
= (char *)bootrec
->data
;
166 printk(KERN_INFO
"%s: p54 detected a LM%c%c "
168 wiphy_name(dev
->wiphy
),
169 iftype
[2], iftype
[3]);
174 printk(KERN_ERR
"%s: unsupported firmware\n",
175 wiphy_name(dev
->wiphy
));
179 case BR_CODE_COMPONENT_VERSION
:
180 /* 24 bytes should be enough for all firmwares */
181 if (strnlen((unsigned char*)bootrec
->data
, 24) < 24)
182 fw_version
= (unsigned char*)bootrec
->data
;
184 case BR_CODE_DESCR
: {
185 struct bootrec_desc
*desc
=
186 (struct bootrec_desc
*)bootrec
->data
;
187 priv
->rx_start
= le32_to_cpu(desc
->rx_start
);
188 /* FIXME add sanity checking */
189 priv
->rx_end
= le32_to_cpu(desc
->rx_end
) - 0x3500;
190 priv
->headroom
= desc
->headroom
;
191 priv
->tailroom
= desc
->tailroom
;
192 priv
->privacy_caps
= desc
->privacy_caps
;
193 priv
->rx_keycache_size
= desc
->rx_keycache_size
;
194 if (le32_to_cpu(bootrec
->len
) == 11)
195 priv
->rx_mtu
= le16_to_cpu(desc
->rx_mtu
);
197 priv
->rx_mtu
= (size_t)
198 0x620 - priv
->tx_hdr_len
;
199 maxlen
= priv
->tx_hdr_len
+ /* USB devices */
200 sizeof(struct p54_rx_data
) +
201 4 + /* rx alignment */
202 IEEE80211_MAX_FRAG_THRESHOLD
;
203 if (priv
->rx_mtu
> maxlen
&& PAGE_SIZE
== 4096) {
204 printk(KERN_INFO
"p54: rx_mtu reduced from %d "
205 "to %d\n", priv
->rx_mtu
,
207 priv
->rx_mtu
= maxlen
;
211 case BR_CODE_EXPOSED_IF
:
212 exp_if
= (struct bootrec_exp_if
*) bootrec
->data
;
213 for (i
= 0; i
< (len
* sizeof(*exp_if
) / 4); i
++)
214 if (exp_if
[i
].if_id
== cpu_to_le16(0x1a))
215 priv
->fw_var
= le16_to_cpu(exp_if
[i
].variant
);
217 case BR_CODE_DEPENDENT_IF
:
219 case BR_CODE_END_OF_BRA
:
220 case LEGACY_BR_CODE_END_OF_BRA
:
226 bootrec
= (struct bootrec
*)&bootrec
->data
[len
];
230 printk(KERN_INFO
"%s: FW rev %s - Softmac protocol %x.%x\n",
231 wiphy_name(dev
->wiphy
), fw_version
,
232 priv
->fw_var
>> 8, priv
->fw_var
& 0xff);
234 if (priv
->fw_var
< 0x500)
235 printk(KERN_INFO
"%s: you are using an obsolete firmware. "
236 "visit http://wireless.kernel.org/en/users/Drivers/p54 "
237 "and grab one for \"kernel >= 2.6.28\"!\n",
238 wiphy_name(dev
->wiphy
));
240 if (priv
->fw_var
>= 0x300) {
241 /* Firmware supports QoS, use it! */
242 priv
->tx_stats
[P54_QUEUE_AC_VO
].limit
= 3;
243 priv
->tx_stats
[P54_QUEUE_AC_VI
].limit
= 4;
244 priv
->tx_stats
[P54_QUEUE_AC_BE
].limit
= 3;
245 priv
->tx_stats
[P54_QUEUE_AC_BK
].limit
= 2;
246 dev
->queues
= P54_QUEUE_AC_NUM
;
249 if (!modparam_nohwcrypt
)
250 printk(KERN_INFO
"%s: cryptographic accelerator "
251 "WEP:%s, TKIP:%s, CCMP:%s\n",
252 wiphy_name(dev
->wiphy
),
253 (priv
->privacy_caps
& BR_DESC_PRIV_CAP_WEP
) ? "YES" :
254 "no", (priv
->privacy_caps
& (BR_DESC_PRIV_CAP_TKIP
|
255 BR_DESC_PRIV_CAP_MICHAEL
)) ? "YES" : "no",
256 (priv
->privacy_caps
& BR_DESC_PRIV_CAP_AESCCMP
) ?
261 EXPORT_SYMBOL_GPL(p54_parse_firmware
);
263 static int p54_convert_rev0(struct ieee80211_hw
*dev
,
264 struct pda_pa_curve_data
*curve_data
)
266 struct p54_common
*priv
= dev
->priv
;
267 struct p54_pa_curve_data_sample
*dst
;
268 struct pda_pa_curve_data_sample_rev0
*src
;
269 size_t cd_len
= sizeof(*curve_data
) +
270 (curve_data
->points_per_channel
*sizeof(*dst
) + 2) *
271 curve_data
->channels
;
273 void *source
, *target
;
275 priv
->curve_data
= kmalloc(cd_len
, GFP_KERNEL
);
276 if (!priv
->curve_data
)
279 memcpy(priv
->curve_data
, curve_data
, sizeof(*curve_data
));
280 source
= curve_data
->data
;
281 target
= priv
->curve_data
->data
;
282 for (i
= 0; i
< curve_data
->channels
; i
++) {
283 __le16
*freq
= source
;
284 source
+= sizeof(__le16
);
285 *((__le16
*)target
) = *freq
;
286 target
+= sizeof(__le16
);
287 for (j
= 0; j
< curve_data
->points_per_channel
; j
++) {
291 dst
->rf_power
= src
->rf_power
;
292 dst
->pa_detector
= src
->pa_detector
;
293 dst
->data_64qam
= src
->pcv
;
294 /* "invent" the points for the other modulations */
295 #define SUB(x,y) (u8)((x) - (y)) > (x) ? 0 : (x) - (y)
296 dst
->data_16qam
= SUB(src
->pcv
, 12);
297 dst
->data_qpsk
= SUB(dst
->data_16qam
, 12);
298 dst
->data_bpsk
= SUB(dst
->data_qpsk
, 12);
299 dst
->data_barker
= SUB(dst
->data_bpsk
, 14);
301 target
+= sizeof(*dst
);
302 source
+= sizeof(*src
);
309 static int p54_convert_rev1(struct ieee80211_hw
*dev
,
310 struct pda_pa_curve_data
*curve_data
)
312 struct p54_common
*priv
= dev
->priv
;
313 struct p54_pa_curve_data_sample
*dst
;
314 struct pda_pa_curve_data_sample_rev1
*src
;
315 size_t cd_len
= sizeof(*curve_data
) +
316 (curve_data
->points_per_channel
*sizeof(*dst
) + 2) *
317 curve_data
->channels
;
319 void *source
, *target
;
321 priv
->curve_data
= kmalloc(cd_len
, GFP_KERNEL
);
322 if (!priv
->curve_data
)
325 memcpy(priv
->curve_data
, curve_data
, sizeof(*curve_data
));
326 source
= curve_data
->data
;
327 target
= priv
->curve_data
->data
;
328 for (i
= 0; i
< curve_data
->channels
; i
++) {
329 __le16
*freq
= source
;
330 source
+= sizeof(__le16
);
331 *((__le16
*)target
) = *freq
;
332 target
+= sizeof(__le16
);
333 for (j
= 0; j
< curve_data
->points_per_channel
; j
++) {
334 memcpy(target
, source
, sizeof(*src
));
336 target
+= sizeof(*dst
);
337 source
+= sizeof(*src
);
345 static const char *p54_rf_chips
[] = { "NULL", "Duette3", "Duette2",
346 "Frisbee", "Xbow", "Longbow", "NULL", "NULL" };
347 static int p54_init_xbow_synth(struct ieee80211_hw
*dev
);
349 static void p54_parse_rssical(struct ieee80211_hw
*dev
, void *data
, int len
,
352 struct p54_common
*priv
= dev
->priv
;
353 int offset
= (type
== PDR_RSSI_LINEAR_APPROXIMATION_EXTENDED
) ? 2 : 0;
354 int entry_size
= sizeof(struct pda_rssi_cal_entry
) + offset
;
355 int num_entries
= (type
== PDR_RSSI_LINEAR_APPROXIMATION
) ? 1 : 2;
358 if (len
!= (entry_size
* num_entries
)) {
359 printk(KERN_ERR
"%s: unknown rssi calibration data packing "
360 " type:(%x) len:%d.\n",
361 wiphy_name(dev
->wiphy
), type
, len
);
363 print_hex_dump_bytes("rssical:", DUMP_PREFIX_NONE
,
366 printk(KERN_ERR
"%s: please report this issue.\n",
367 wiphy_name(dev
->wiphy
));
371 for (i
= 0; i
< num_entries
; i
++) {
372 struct pda_rssi_cal_entry
*cal
= data
+
373 (offset
+ i
* entry_size
);
374 priv
->rssical_db
[i
].mul
= (s16
) le16_to_cpu(cal
->mul
);
375 priv
->rssical_db
[i
].add
= (s16
) le16_to_cpu(cal
->add
);
379 static void p54_parse_default_country(struct ieee80211_hw
*dev
,
382 struct pda_country
*country
;
384 if (len
!= sizeof(*country
)) {
385 printk(KERN_ERR
"%s: found possible invalid default country "
386 "eeprom entry. (entry size: %d)\n",
387 wiphy_name(dev
->wiphy
), len
);
389 print_hex_dump_bytes("country:", DUMP_PREFIX_NONE
,
392 printk(KERN_ERR
"%s: please report this issue.\n",
393 wiphy_name(dev
->wiphy
));
397 country
= (struct pda_country
*) data
;
398 if (country
->flags
== PDR_COUNTRY_CERT_CODE_PSEUDO
)
399 regulatory_hint(dev
->wiphy
, country
->alpha2
);
402 * write a shared/common function that converts
403 * "Regulatory domain codes" (802.11-2007 14.8.2.2)
404 * into ISO/IEC 3166-1 alpha2 for regulatory_hint.
409 static int p54_parse_eeprom(struct ieee80211_hw
*dev
, void *eeprom
, int len
)
411 struct p54_common
*priv
= dev
->priv
;
412 struct eeprom_pda_wrap
*wrap
= NULL
;
413 struct pda_entry
*entry
;
414 unsigned int data_len
, entry_len
;
417 u8
*end
= (u8
*)eeprom
+ len
;
420 wrap
= (struct eeprom_pda_wrap
*) eeprom
;
421 entry
= (void *)wrap
->data
+ le16_to_cpu(wrap
->len
);
423 /* verify that at least the entry length/code fits */
424 while ((u8
*)entry
<= end
- sizeof(*entry
)) {
425 entry_len
= le16_to_cpu(entry
->len
);
426 data_len
= ((entry_len
- 1) << 1);
428 /* abort if entry exceeds whole structure */
429 if ((u8
*)entry
+ sizeof(*entry
) + data_len
> end
)
432 switch (le16_to_cpu(entry
->code
)) {
433 case PDR_MAC_ADDRESS
:
434 SET_IEEE80211_PERM_ADDR(dev
, entry
->data
);
436 case PDR_PRISM_PA_CAL_OUTPUT_POWER_LIMITS
:
442 if (2 + entry
->data
[1]*sizeof(*priv
->output_limit
) > data_len
) {
447 priv
->output_limit
= kmalloc(entry
->data
[1] *
448 sizeof(*priv
->output_limit
), GFP_KERNEL
);
450 if (!priv
->output_limit
) {
455 memcpy(priv
->output_limit
, &entry
->data
[2],
456 entry
->data
[1]*sizeof(*priv
->output_limit
));
457 priv
->output_limit_len
= entry
->data
[1];
459 case PDR_PRISM_PA_CAL_CURVE_DATA
: {
460 struct pda_pa_curve_data
*curve_data
=
461 (struct pda_pa_curve_data
*)entry
->data
;
462 if (data_len
< sizeof(*curve_data
)) {
467 switch (curve_data
->cal_method_rev
) {
469 err
= p54_convert_rev0(dev
, curve_data
);
472 err
= p54_convert_rev1(dev
, curve_data
);
475 printk(KERN_ERR
"%s: unknown curve data "
477 wiphy_name(dev
->wiphy
),
478 curve_data
->cal_method_rev
);
486 case PDR_PRISM_ZIF_TX_IQ_CALIBRATION
:
487 priv
->iq_autocal
= kmalloc(data_len
, GFP_KERNEL
);
488 if (!priv
->iq_autocal
) {
493 memcpy(priv
->iq_autocal
, entry
->data
, data_len
);
494 priv
->iq_autocal_len
= data_len
/ sizeof(struct pda_iq_autocal_entry
);
496 case PDR_DEFAULT_COUNTRY
:
497 p54_parse_default_country(dev
, entry
->data
, data_len
);
499 case PDR_INTERFACE_LIST
:
501 while ((u8
*)tmp
< entry
->data
+ data_len
) {
502 struct bootrec_exp_if
*exp_if
= tmp
;
503 if (le16_to_cpu(exp_if
->if_id
) == 0xf)
504 synth
= le16_to_cpu(exp_if
->variant
);
505 tmp
+= sizeof(struct bootrec_exp_if
);
508 case PDR_HARDWARE_PLATFORM_COMPONENT_ID
:
509 priv
->version
= *(u8
*)(entry
->data
+ 1);
511 case PDR_RSSI_LINEAR_APPROXIMATION
:
512 case PDR_RSSI_LINEAR_APPROXIMATION_DUAL_BAND
:
513 case PDR_RSSI_LINEAR_APPROXIMATION_EXTENDED
:
514 p54_parse_rssical(dev
, entry
->data
, data_len
,
515 le16_to_cpu(entry
->code
));
518 /* make it overrun */
521 case PDR_MANUFACTURING_PART_NUMBER
:
522 case PDR_PDA_VERSION
:
523 case PDR_NIC_SERIAL_NUMBER
:
524 case PDR_REGULATORY_DOMAIN_LIST
:
525 case PDR_TEMPERATURE_TYPE
:
526 case PDR_PRISM_PCI_IDENTIFIER
:
527 case PDR_COUNTRY_INFORMATION
:
529 case PDR_PRODUCT_NAME
:
530 case PDR_UTF8_OEM_NAME
:
531 case PDR_UTF8_PRODUCT_NAME
:
532 case PDR_COUNTRY_LIST
:
533 case PDR_ANTENNA_GAIN
:
534 case PDR_PRISM_INDIGO_PA_CALIBRATION_DATA
:
535 case PDR_REGULATORY_POWER_LIMITS
:
536 case PDR_RADIATED_TRANSMISSION_CORRECTION
:
537 case PDR_PRISM_TX_IQ_CALIBRATION
:
538 case PDR_BASEBAND_REGISTERS
:
539 case PDR_PER_CHANNEL_BASEBAND_REGISTERS
:
542 printk(KERN_INFO
"%s: unknown eeprom code : 0x%x\n",
543 wiphy_name(dev
->wiphy
),
544 le16_to_cpu(entry
->code
));
548 entry
= (void *)entry
+ (entry_len
+ 1)*2;
551 if (!synth
|| !priv
->iq_autocal
|| !priv
->output_limit
||
553 printk(KERN_ERR
"%s: not all required entries found in eeprom!\n",
554 wiphy_name(dev
->wiphy
));
559 priv
->rxhw
= synth
& PDR_SYNTH_FRONTEND_MASK
;
561 p54_init_xbow_synth(dev
);
562 if (!(synth
& PDR_SYNTH_24_GHZ_DISABLED
))
563 dev
->wiphy
->bands
[IEEE80211_BAND_2GHZ
] = &band_2GHz
;
564 if (!(synth
& PDR_SYNTH_5_GHZ_DISABLED
))
565 dev
->wiphy
->bands
[IEEE80211_BAND_5GHZ
] = &band_5GHz
;
566 if ((synth
& PDR_SYNTH_RX_DIV_MASK
) == PDR_SYNTH_RX_DIV_SUPPORTED
)
567 priv
->rx_diversity_mask
= 3;
568 if ((synth
& PDR_SYNTH_TX_DIV_MASK
) == PDR_SYNTH_TX_DIV_SUPPORTED
)
569 priv
->tx_diversity_mask
= 3;
571 if (!is_valid_ether_addr(dev
->wiphy
->perm_addr
)) {
572 u8 perm_addr
[ETH_ALEN
];
574 printk(KERN_WARNING
"%s: Invalid hwaddr! Using randomly generated MAC addr\n",
575 wiphy_name(dev
->wiphy
));
576 random_ether_addr(perm_addr
);
577 SET_IEEE80211_PERM_ADDR(dev
, perm_addr
);
580 printk(KERN_INFO
"%s: hwaddr %pM, MAC:isl38%02x RF:%s\n",
581 wiphy_name(dev
->wiphy
),
582 dev
->wiphy
->perm_addr
,
583 priv
->version
, p54_rf_chips
[priv
->rxhw
]);
588 if (priv
->iq_autocal
) {
589 kfree(priv
->iq_autocal
);
590 priv
->iq_autocal
= NULL
;
593 if (priv
->output_limit
) {
594 kfree(priv
->output_limit
);
595 priv
->output_limit
= NULL
;
598 if (priv
->curve_data
) {
599 kfree(priv
->curve_data
);
600 priv
->curve_data
= NULL
;
603 printk(KERN_ERR
"%s: eeprom parse failed!\n",
604 wiphy_name(dev
->wiphy
));
608 static int p54_rssi_to_dbm(struct ieee80211_hw
*dev
, int rssi
)
610 struct p54_common
*priv
= dev
->priv
;
611 int band
= dev
->conf
.channel
->band
;
613 return ((rssi
* priv
->rssical_db
[band
].mul
) / 64 +
614 priv
->rssical_db
[band
].add
) / 4;
617 static int p54_rx_data(struct ieee80211_hw
*dev
, struct sk_buff
*skb
)
619 struct p54_common
*priv
= dev
->priv
;
620 struct p54_rx_data
*hdr
= (struct p54_rx_data
*) skb
->data
;
621 struct ieee80211_rx_status rx_status
= {0};
622 u16 freq
= le16_to_cpu(hdr
->freq
);
623 size_t header_len
= sizeof(*hdr
);
625 u8 rate
= hdr
->rate
& 0xf;
628 * If the device is in a unspecified state we have to
629 * ignore all data frames. Else we could end up with a
632 if (unlikely(priv
->mode
== NL80211_IFTYPE_UNSPECIFIED
))
635 if (!(hdr
->flags
& cpu_to_le16(P54_HDR_FLAG_DATA_IN_FCS_GOOD
))) {
636 if (priv
->filter_flags
& FIF_FCSFAIL
)
637 rx_status
.flag
|= RX_FLAG_FAILED_FCS_CRC
;
642 if (hdr
->decrypt_status
== P54_DECRYPT_OK
)
643 rx_status
.flag
|= RX_FLAG_DECRYPTED
;
644 if ((hdr
->decrypt_status
== P54_DECRYPT_FAIL_MICHAEL
) ||
645 (hdr
->decrypt_status
== P54_DECRYPT_FAIL_TKIP
))
646 rx_status
.flag
|= RX_FLAG_MMIC_ERROR
;
648 rx_status
.signal
= p54_rssi_to_dbm(dev
, hdr
->rssi
);
649 rx_status
.noise
= priv
->noise
;
651 rx_status
.qual
= (100 * hdr
->rssi
) / 127;
652 if (hdr
->rate
& 0x10)
653 rx_status
.flag
|= RX_FLAG_SHORTPRE
;
654 if (dev
->conf
.channel
->band
== IEEE80211_BAND_5GHZ
)
655 rx_status
.rate_idx
= (rate
< 4) ? 0 : rate
- 4;
657 rx_status
.rate_idx
= rate
;
659 rx_status
.freq
= freq
;
660 rx_status
.band
= dev
->conf
.channel
->band
;
661 rx_status
.antenna
= hdr
->antenna
;
663 tsf32
= le32_to_cpu(hdr
->tsf32
);
664 if (tsf32
< priv
->tsf_low32
)
666 rx_status
.mactime
= ((u64
)priv
->tsf_high32
) << 32 | tsf32
;
667 priv
->tsf_low32
= tsf32
;
669 rx_status
.flag
|= RX_FLAG_TSFT
;
671 if (hdr
->flags
& cpu_to_le16(P54_HDR_FLAG_DATA_ALIGN
))
672 header_len
+= hdr
->align
[0];
674 skb_pull(skb
, header_len
);
675 skb_trim(skb
, le16_to_cpu(hdr
->len
));
677 ieee80211_rx_irqsafe(dev
, skb
, &rx_status
);
679 queue_delayed_work(dev
->workqueue
, &priv
->work
,
680 msecs_to_jiffies(P54_STATISTICS_UPDATE
));
685 static void inline p54_wake_free_queues(struct ieee80211_hw
*dev
)
687 struct p54_common
*priv
= dev
->priv
;
690 if (priv
->mode
== NL80211_IFTYPE_UNSPECIFIED
)
693 for (i
= 0; i
< dev
->queues
; i
++)
694 if (priv
->tx_stats
[i
+ P54_QUEUE_DATA
].len
<
695 priv
->tx_stats
[i
+ P54_QUEUE_DATA
].limit
)
696 ieee80211_wake_queue(dev
, i
);
699 void p54_free_skb(struct ieee80211_hw
*dev
, struct sk_buff
*skb
)
701 struct p54_common
*priv
= dev
->priv
;
702 struct ieee80211_tx_info
*info
;
703 struct memrecord
*range
;
705 u32 freed
= 0, last_addr
= priv
->rx_start
;
707 if (unlikely(!skb
|| !dev
|| !skb_queue_len(&priv
->tx_queue
)))
711 * don't try to free an already unlinked skb
713 if (unlikely((!skb
->next
) || (!skb
->prev
)))
716 spin_lock_irqsave(&priv
->tx_queue
.lock
, flags
);
717 info
= IEEE80211_SKB_CB(skb
);
718 range
= (void *)info
->rate_driver_data
;
719 if (skb
->prev
!= (struct sk_buff
*)&priv
->tx_queue
) {
720 struct ieee80211_tx_info
*ni
;
721 struct memrecord
*mr
;
723 ni
= IEEE80211_SKB_CB(skb
->prev
);
724 mr
= (struct memrecord
*)ni
->rate_driver_data
;
725 last_addr
= mr
->end_addr
;
727 if (skb
->next
!= (struct sk_buff
*)&priv
->tx_queue
) {
728 struct ieee80211_tx_info
*ni
;
729 struct memrecord
*mr
;
731 ni
= IEEE80211_SKB_CB(skb
->next
);
732 mr
= (struct memrecord
*)ni
->rate_driver_data
;
733 freed
= mr
->start_addr
- last_addr
;
735 freed
= priv
->rx_end
- last_addr
;
736 __skb_unlink(skb
, &priv
->tx_queue
);
737 spin_unlock_irqrestore(&priv
->tx_queue
.lock
, flags
);
738 dev_kfree_skb_any(skb
);
740 if (freed
>= priv
->headroom
+ sizeof(struct p54_hdr
) + 48 +
741 IEEE80211_MAX_RTS_THRESHOLD
+ priv
->tailroom
)
742 p54_wake_free_queues(dev
);
744 EXPORT_SYMBOL_GPL(p54_free_skb
);
746 static struct sk_buff
*p54_find_tx_entry(struct ieee80211_hw
*dev
,
749 struct p54_common
*priv
= dev
->priv
;
750 struct sk_buff
*entry
= priv
->tx_queue
.next
;
753 spin_lock_irqsave(&priv
->tx_queue
.lock
, flags
);
754 while (entry
!= (struct sk_buff
*)&priv
->tx_queue
) {
755 struct p54_hdr
*hdr
= (struct p54_hdr
*) entry
->data
;
757 if (hdr
->req_id
== req_id
) {
758 spin_unlock_irqrestore(&priv
->tx_queue
.lock
, flags
);
763 spin_unlock_irqrestore(&priv
->tx_queue
.lock
, flags
);
767 static void p54_rx_frame_sent(struct ieee80211_hw
*dev
, struct sk_buff
*skb
)
769 struct p54_common
*priv
= dev
->priv
;
770 struct p54_hdr
*hdr
= (struct p54_hdr
*) skb
->data
;
771 struct p54_frame_sent
*payload
= (struct p54_frame_sent
*) hdr
->data
;
772 struct sk_buff
*entry
= (struct sk_buff
*) priv
->tx_queue
.next
;
773 u32 addr
= le32_to_cpu(hdr
->req_id
) - priv
->headroom
;
774 struct memrecord
*range
= NULL
;
776 u32 last_addr
= priv
->rx_start
;
780 spin_lock_irqsave(&priv
->tx_queue
.lock
, flags
);
781 while (entry
!= (struct sk_buff
*)&priv
->tx_queue
) {
782 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(entry
);
783 struct p54_hdr
*entry_hdr
;
784 struct p54_tx_data
*entry_data
;
785 unsigned int pad
= 0, frame_len
;
787 range
= (void *)info
->rate_driver_data
;
788 if (range
->start_addr
!= addr
) {
789 last_addr
= range
->end_addr
;
794 if (entry
->next
!= (struct sk_buff
*)&priv
->tx_queue
) {
795 struct ieee80211_tx_info
*ni
;
796 struct memrecord
*mr
;
798 ni
= IEEE80211_SKB_CB(entry
->next
);
799 mr
= (struct memrecord
*)ni
->rate_driver_data
;
800 freed
= mr
->start_addr
- last_addr
;
802 freed
= priv
->rx_end
- last_addr
;
804 last_addr
= range
->end_addr
;
805 __skb_unlink(entry
, &priv
->tx_queue
);
806 spin_unlock_irqrestore(&priv
->tx_queue
.lock
, flags
);
808 frame_len
= entry
->len
;
809 entry_hdr
= (struct p54_hdr
*) entry
->data
;
810 entry_data
= (struct p54_tx_data
*) entry_hdr
->data
;
811 priv
->tx_stats
[entry_data
->hw_queue
].len
--;
812 priv
->stats
.dot11ACKFailureCount
+= payload
->tries
- 1;
815 * Frames in P54_QUEUE_FWSCAN and P54_QUEUE_BEACON are
816 * generated by the driver. Therefore tx_status is bogus
817 * and we don't want to confuse the mac80211 stack.
819 if (unlikely(entry_data
->hw_queue
< P54_QUEUE_FWSCAN
)) {
820 if (entry_data
->hw_queue
== P54_QUEUE_BEACON
)
821 priv
->cached_beacon
= NULL
;
828 * Clear manually, ieee80211_tx_info_clear_status would
829 * clear the counts too and we need them.
831 memset(&info
->status
.ampdu_ack_len
, 0,
832 sizeof(struct ieee80211_tx_info
) -
833 offsetof(struct ieee80211_tx_info
, status
.ampdu_ack_len
));
834 BUILD_BUG_ON(offsetof(struct ieee80211_tx_info
,
835 status
.ampdu_ack_len
) != 23);
837 if (entry_hdr
->flags
& cpu_to_le16(P54_HDR_FLAG_DATA_ALIGN
))
838 pad
= entry_data
->align
[0];
840 /* walk through the rates array and adjust the counts */
841 count
= payload
->tries
;
842 for (idx
= 0; idx
< 4; idx
++) {
843 if (count
>= info
->status
.rates
[idx
].count
) {
844 count
-= info
->status
.rates
[idx
].count
;
845 } else if (count
> 0) {
846 info
->status
.rates
[idx
].count
= count
;
849 info
->status
.rates
[idx
].idx
= -1;
850 info
->status
.rates
[idx
].count
= 0;
854 if (!(info
->flags
& IEEE80211_TX_CTL_NO_ACK
) &&
856 info
->flags
|= IEEE80211_TX_STAT_ACK
;
857 if (payload
->status
& P54_TX_PSM_CANCELLED
)
858 info
->flags
|= IEEE80211_TX_STAT_TX_FILTERED
;
859 info
->status
.ack_signal
= p54_rssi_to_dbm(dev
,
860 (int)payload
->ack_rssi
);
862 /* Undo all changes to the frame. */
863 switch (entry_data
->key_type
) {
864 case P54_CRYPTO_TKIPMICHAEL
: {
865 u8
*iv
= (u8
*)(entry_data
->align
+ pad
+
866 entry_data
->crypt_offset
);
868 /* Restore the original TKIP IV. */
871 iv
[1] = (iv
[0] | 0x20) & 0x7f; /* WEPSeed - 8.3.2.2 */
873 frame_len
-= 12; /* remove TKIP_MMIC + TKIP_ICV */
876 case P54_CRYPTO_AESCCMP
:
877 frame_len
-= 8; /* remove CCMP_MIC */
880 frame_len
-= 4; /* remove WEP_ICV */
883 skb_trim(entry
, frame_len
);
884 skb_pull(entry
, sizeof(*hdr
) + pad
+ sizeof(*entry_data
));
885 ieee80211_tx_status_irqsafe(dev
, entry
);
888 spin_unlock_irqrestore(&priv
->tx_queue
.lock
, flags
);
891 if (freed
>= priv
->headroom
+ sizeof(struct p54_hdr
) + 48 +
892 IEEE80211_MAX_RTS_THRESHOLD
+ priv
->tailroom
)
893 p54_wake_free_queues(dev
);
896 static void p54_rx_eeprom_readback(struct ieee80211_hw
*dev
,
899 struct p54_hdr
*hdr
= (struct p54_hdr
*) skb
->data
;
900 struct p54_eeprom_lm86
*eeprom
= (struct p54_eeprom_lm86
*) hdr
->data
;
901 struct p54_common
*priv
= dev
->priv
;
906 if (priv
->fw_var
>= 0x509) {
907 memcpy(priv
->eeprom
, eeprom
->v2
.data
,
908 le16_to_cpu(eeprom
->v2
.len
));
910 memcpy(priv
->eeprom
, eeprom
->v1
.data
,
911 le16_to_cpu(eeprom
->v1
.len
));
914 complete(&priv
->eeprom_comp
);
917 static void p54_rx_stats(struct ieee80211_hw
*dev
, struct sk_buff
*skb
)
919 struct p54_common
*priv
= dev
->priv
;
920 struct p54_hdr
*hdr
= (struct p54_hdr
*) skb
->data
;
921 struct p54_statistics
*stats
= (struct p54_statistics
*) hdr
->data
;
924 if (unlikely(priv
->mode
== NL80211_IFTYPE_UNSPECIFIED
))
927 tsf32
= le32_to_cpu(stats
->tsf32
);
928 if (tsf32
< priv
->tsf_low32
)
930 priv
->tsf_low32
= tsf32
;
932 priv
->stats
.dot11RTSFailureCount
= le32_to_cpu(stats
->rts_fail
);
933 priv
->stats
.dot11RTSSuccessCount
= le32_to_cpu(stats
->rts_success
);
934 priv
->stats
.dot11FCSErrorCount
= le32_to_cpu(stats
->rx_bad_fcs
);
936 priv
->noise
= p54_rssi_to_dbm(dev
, le32_to_cpu(stats
->noise
));
938 p54_free_skb(dev
, p54_find_tx_entry(dev
, hdr
->req_id
));
941 static void p54_rx_trap(struct ieee80211_hw
*dev
, struct sk_buff
*skb
)
943 struct p54_hdr
*hdr
= (struct p54_hdr
*) skb
->data
;
944 struct p54_trap
*trap
= (struct p54_trap
*) hdr
->data
;
945 u16 event
= le16_to_cpu(trap
->event
);
946 u16 freq
= le16_to_cpu(trap
->frequency
);
949 case P54_TRAP_BEACON_TX
:
952 printk(KERN_INFO
"%s: radar (freq:%d MHz)\n",
953 wiphy_name(dev
->wiphy
), freq
);
955 case P54_TRAP_NO_BEACON
:
964 printk(KERN_INFO
"%s: received event:%x freq:%d\n",
965 wiphy_name(dev
->wiphy
), event
, freq
);
970 static int p54_rx_control(struct ieee80211_hw
*dev
, struct sk_buff
*skb
)
972 struct p54_hdr
*hdr
= (struct p54_hdr
*) skb
->data
;
974 switch (le16_to_cpu(hdr
->type
)) {
975 case P54_CONTROL_TYPE_TXDONE
:
976 p54_rx_frame_sent(dev
, skb
);
978 case P54_CONTROL_TYPE_TRAP
:
979 p54_rx_trap(dev
, skb
);
981 case P54_CONTROL_TYPE_BBP
:
983 case P54_CONTROL_TYPE_STAT_READBACK
:
984 p54_rx_stats(dev
, skb
);
986 case P54_CONTROL_TYPE_EEPROM_READBACK
:
987 p54_rx_eeprom_readback(dev
, skb
);
990 printk(KERN_DEBUG
"%s: not handling 0x%02x type control frame\n",
991 wiphy_name(dev
->wiphy
), le16_to_cpu(hdr
->type
));
998 /* returns zero if skb can be reused */
999 int p54_rx(struct ieee80211_hw
*dev
, struct sk_buff
*skb
)
1001 u16 type
= le16_to_cpu(*((__le16
*)skb
->data
));
1003 if (type
& P54_HDR_FLAG_CONTROL
)
1004 return p54_rx_control(dev
, skb
);
1006 return p54_rx_data(dev
, skb
);
1008 EXPORT_SYMBOL_GPL(p54_rx
);
1011 * So, the firmware is somewhat stupid and doesn't know what places in its
1012 * memory incoming data should go to. By poking around in the firmware, we
1013 * can find some unused memory to upload our packets to. However, data that we
1014 * want the card to TX needs to stay intact until the card has told us that
1015 * it is done with it. This function finds empty places we can upload to and
1016 * marks allocated areas as reserved if necessary. p54_rx_frame_sent frees
1019 static int p54_assign_address(struct ieee80211_hw
*dev
, struct sk_buff
*skb
,
1020 struct p54_hdr
*data
, u32 len
)
1022 struct p54_common
*priv
= dev
->priv
;
1023 struct sk_buff
*entry
= priv
->tx_queue
.next
;
1024 struct sk_buff
*target_skb
= NULL
;
1025 struct ieee80211_tx_info
*info
;
1026 struct memrecord
*range
;
1027 u32 last_addr
= priv
->rx_start
;
1028 u32 largest_hole
= 0;
1029 u32 target_addr
= priv
->rx_start
;
1030 unsigned long flags
;
1032 len
= (len
+ priv
->headroom
+ priv
->tailroom
+ 3) & ~0x3;
1037 spin_lock_irqsave(&priv
->tx_queue
.lock
, flags
);
1039 left
= skb_queue_len(&priv
->tx_queue
);
1040 if (unlikely(left
>= 28)) {
1042 * The tx_queue is nearly full!
1043 * We have throttle normal data traffic, because we must
1044 * have a few spare slots for control frames left.
1046 ieee80211_stop_queues(dev
);
1047 queue_delayed_work(dev
->workqueue
, &priv
->work
,
1048 msecs_to_jiffies(P54_TX_TIMEOUT
));
1050 if (unlikely(left
== 32)) {
1052 * The tx_queue is now really full.
1054 * TODO: check if the device has crashed and reset it.
1056 spin_unlock_irqrestore(&priv
->tx_queue
.lock
, flags
);
1063 info
= IEEE80211_SKB_CB(entry
);
1064 range
= (void *)info
->rate_driver_data
;
1065 hole_size
= range
->start_addr
- last_addr
;
1066 if (!target_skb
&& hole_size
>= len
) {
1067 target_skb
= entry
->prev
;
1069 target_addr
= last_addr
;
1071 largest_hole
= max(largest_hole
, hole_size
);
1072 last_addr
= range
->end_addr
;
1073 entry
= entry
->next
;
1075 if (!target_skb
&& priv
->rx_end
- last_addr
>= len
) {
1076 target_skb
= priv
->tx_queue
.prev
;
1077 largest_hole
= max(largest_hole
, priv
->rx_end
- last_addr
- len
);
1078 if (!skb_queue_empty(&priv
->tx_queue
)) {
1079 info
= IEEE80211_SKB_CB(target_skb
);
1080 range
= (void *)info
->rate_driver_data
;
1081 target_addr
= range
->end_addr
;
1084 largest_hole
= max(largest_hole
, priv
->rx_end
- last_addr
);
1087 spin_unlock_irqrestore(&priv
->tx_queue
.lock
, flags
);
1088 ieee80211_stop_queues(dev
);
1092 info
= IEEE80211_SKB_CB(skb
);
1093 range
= (void *)info
->rate_driver_data
;
1094 range
->start_addr
= target_addr
;
1095 range
->end_addr
= target_addr
+ len
;
1096 __skb_queue_after(&priv
->tx_queue
, target_skb
, skb
);
1097 spin_unlock_irqrestore(&priv
->tx_queue
.lock
, flags
);
1099 if (largest_hole
< priv
->headroom
+ sizeof(struct p54_hdr
) +
1100 48 + IEEE80211_MAX_RTS_THRESHOLD
+ priv
->tailroom
)
1101 ieee80211_stop_queues(dev
);
1103 data
->req_id
= cpu_to_le32(target_addr
+ priv
->headroom
);
1107 static struct sk_buff
*p54_alloc_skb(struct ieee80211_hw
*dev
, u16 hdr_flags
,
1108 u16 payload_len
, u16 type
, gfp_t memflags
)
1110 struct p54_common
*priv
= dev
->priv
;
1111 struct p54_hdr
*hdr
;
1112 struct sk_buff
*skb
;
1113 size_t frame_len
= sizeof(*hdr
) + payload_len
;
1115 if (frame_len
> P54_MAX_CTRL_FRAME_LEN
)
1118 skb
= __dev_alloc_skb(priv
->tx_hdr_len
+ frame_len
, memflags
);
1121 skb_reserve(skb
, priv
->tx_hdr_len
);
1123 hdr
= (struct p54_hdr
*) skb_put(skb
, sizeof(*hdr
));
1124 hdr
->flags
= cpu_to_le16(hdr_flags
);
1125 hdr
->len
= cpu_to_le16(payload_len
);
1126 hdr
->type
= cpu_to_le16(type
);
1127 hdr
->tries
= hdr
->rts_tries
= 0;
1129 if (p54_assign_address(dev
, skb
, hdr
, frame_len
)) {
1136 int p54_read_eeprom(struct ieee80211_hw
*dev
)
1138 struct p54_common
*priv
= dev
->priv
;
1139 struct p54_eeprom_lm86
*eeprom_hdr
;
1140 struct sk_buff
*skb
;
1141 size_t eeprom_size
= 0x2020, offset
= 0, blocksize
, maxblocksize
;
1143 void *eeprom
= NULL
;
1145 maxblocksize
= EEPROM_READBACK_LEN
;
1146 if (priv
->fw_var
>= 0x509)
1147 maxblocksize
-= 0xc;
1149 maxblocksize
-= 0x4;
1151 skb
= p54_alloc_skb(dev
, P54_HDR_FLAG_CONTROL
, sizeof(*eeprom_hdr
) +
1152 maxblocksize
, P54_CONTROL_TYPE_EEPROM_READBACK
,
1156 priv
->eeprom
= kzalloc(EEPROM_READBACK_LEN
, GFP_KERNEL
);
1159 eeprom
= kzalloc(eeprom_size
, GFP_KERNEL
);
1163 eeprom_hdr
= (struct p54_eeprom_lm86
*) skb_put(skb
,
1164 sizeof(*eeprom_hdr
) + maxblocksize
);
1166 while (eeprom_size
) {
1167 blocksize
= min(eeprom_size
, maxblocksize
);
1168 if (priv
->fw_var
< 0x509) {
1169 eeprom_hdr
->v1
.offset
= cpu_to_le16(offset
);
1170 eeprom_hdr
->v1
.len
= cpu_to_le16(blocksize
);
1172 eeprom_hdr
->v2
.offset
= cpu_to_le32(offset
);
1173 eeprom_hdr
->v2
.len
= cpu_to_le16(blocksize
);
1174 eeprom_hdr
->v2
.magic2
= 0xf;
1175 memcpy(eeprom_hdr
->v2
.magic
, (const char *)"LOCK", 4);
1179 if (!wait_for_completion_interruptible_timeout(&priv
->eeprom_comp
, HZ
)) {
1180 printk(KERN_ERR
"%s: device does not respond!\n",
1181 wiphy_name(dev
->wiphy
));
1186 memcpy(eeprom
+ offset
, priv
->eeprom
, blocksize
);
1187 offset
+= blocksize
;
1188 eeprom_size
-= blocksize
;
1191 ret
= p54_parse_eeprom(dev
, eeprom
, offset
);
1193 kfree(priv
->eeprom
);
1194 priv
->eeprom
= NULL
;
1195 p54_free_skb(dev
, skb
);
1200 EXPORT_SYMBOL_GPL(p54_read_eeprom
);
1202 static int p54_set_tim(struct ieee80211_hw
*dev
, struct ieee80211_sta
*sta
,
1205 struct p54_common
*priv
= dev
->priv
;
1206 struct sk_buff
*skb
;
1207 struct p54_tim
*tim
;
1209 skb
= p54_alloc_skb(dev
, P54_HDR_FLAG_CONTROL_OPSET
, sizeof(*tim
),
1210 P54_CONTROL_TYPE_TIM
, GFP_ATOMIC
);
1214 tim
= (struct p54_tim
*) skb_put(skb
, sizeof(*tim
));
1216 tim
->entry
[0] = cpu_to_le16(set
? (sta
->aid
| 0x8000) : sta
->aid
);
1221 static int p54_sta_unlock(struct ieee80211_hw
*dev
, u8
*addr
)
1223 struct p54_common
*priv
= dev
->priv
;
1224 struct sk_buff
*skb
;
1225 struct p54_sta_unlock
*sta
;
1227 skb
= p54_alloc_skb(dev
, P54_HDR_FLAG_CONTROL_OPSET
, sizeof(*sta
),
1228 P54_CONTROL_TYPE_PSM_STA_UNLOCK
, GFP_ATOMIC
);
1232 sta
= (struct p54_sta_unlock
*)skb_put(skb
, sizeof(*sta
));
1233 memcpy(sta
->addr
, addr
, ETH_ALEN
);
1238 static void p54_sta_notify(struct ieee80211_hw
*dev
, struct ieee80211_vif
*vif
,
1239 enum sta_notify_cmd notify_cmd
,
1240 struct ieee80211_sta
*sta
)
1242 switch (notify_cmd
) {
1243 case STA_NOTIFY_ADD
:
1244 case STA_NOTIFY_REMOVE
:
1246 * Notify the firmware that we don't want or we don't
1247 * need to buffer frames for this station anymore.
1250 p54_sta_unlock(dev
, sta
->addr
);
1252 case STA_NOTIFY_AWAKE
:
1253 /* update the firmware's filter table */
1254 p54_sta_unlock(dev
, sta
->addr
);
1261 static int p54_tx_cancel(struct ieee80211_hw
*dev
, struct sk_buff
*entry
)
1263 struct p54_common
*priv
= dev
->priv
;
1264 struct sk_buff
*skb
;
1265 struct p54_hdr
*hdr
;
1266 struct p54_txcancel
*cancel
;
1268 skb
= p54_alloc_skb(dev
, P54_HDR_FLAG_CONTROL_OPSET
, sizeof(*cancel
),
1269 P54_CONTROL_TYPE_TXCANCEL
, GFP_ATOMIC
);
1273 hdr
= (void *)entry
->data
;
1274 cancel
= (struct p54_txcancel
*)skb_put(skb
, sizeof(*cancel
));
1275 cancel
->req_id
= hdr
->req_id
;
1280 static int p54_tx_fill(struct ieee80211_hw
*dev
, struct sk_buff
*skb
,
1281 struct ieee80211_tx_info
*info
, u8
*queue
, size_t *extra_len
,
1282 u16
*flags
, u16
*aid
)
1284 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
1285 struct p54_common
*priv
= dev
->priv
;
1288 switch (priv
->mode
) {
1289 case NL80211_IFTYPE_MONITOR
:
1291 * We have to set P54_HDR_FLAG_DATA_OUT_PROMISC for
1292 * every frame in promiscuous/monitor mode.
1293 * see STSW45x0C LMAC API - page 12.
1296 *flags
= P54_HDR_FLAG_DATA_OUT_PROMISC
;
1297 *queue
+= P54_QUEUE_DATA
;
1299 case NL80211_IFTYPE_STATION
:
1301 if (unlikely(ieee80211_is_mgmt(hdr
->frame_control
))) {
1302 *queue
= P54_QUEUE_MGMT
;
1305 *queue
+= P54_QUEUE_DATA
;
1307 case NL80211_IFTYPE_AP
:
1308 case NL80211_IFTYPE_ADHOC
:
1309 case NL80211_IFTYPE_MESH_POINT
:
1310 if (info
->flags
& IEEE80211_TX_CTL_SEND_AFTER_DTIM
) {
1312 *queue
= P54_QUEUE_CAB
;
1316 if (unlikely(ieee80211_is_mgmt(hdr
->frame_control
))) {
1317 if (ieee80211_is_probe_resp(hdr
->frame_control
)) {
1319 *queue
= P54_QUEUE_MGMT
;
1320 *flags
= P54_HDR_FLAG_DATA_OUT_TIMESTAMP
|
1321 P54_HDR_FLAG_DATA_OUT_NOCANCEL
;
1323 } else if (ieee80211_is_beacon(hdr
->frame_control
)) {
1326 if (info
->flags
& IEEE80211_TX_CTL_INJECTED
) {
1328 * Injecting beacons on top of a AP is
1329 * not a good idea... nevertheless,
1330 * it should be doable.
1333 *queue
+= P54_QUEUE_DATA
;
1337 *flags
= P54_HDR_FLAG_DATA_OUT_TIMESTAMP
;
1338 *queue
= P54_QUEUE_BEACON
;
1339 *extra_len
= IEEE80211_MAX_TIM_LEN
;
1342 *queue
= P54_QUEUE_MGMT
;
1346 *queue
+= P54_QUEUE_DATA
;
1348 if (info
->control
.sta
)
1349 *aid
= info
->control
.sta
->aid
;
1351 *flags
|= P54_HDR_FLAG_DATA_OUT_NOCANCEL
;
1357 static u8
p54_convert_algo(enum ieee80211_key_alg alg
)
1361 return P54_CRYPTO_WEP
;
1363 return P54_CRYPTO_TKIPMICHAEL
;
1365 return P54_CRYPTO_AESCCMP
;
1371 static int p54_tx(struct ieee80211_hw
*dev
, struct sk_buff
*skb
)
1373 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
1374 struct ieee80211_tx_queue_stats
*current_queue
;
1375 struct p54_common
*priv
= dev
->priv
;
1376 struct p54_hdr
*hdr
;
1377 struct p54_tx_data
*txhdr
;
1378 size_t padding
, len
, tim_len
= 0;
1379 int i
, j
, ridx
, ret
;
1380 u16 hdr_flags
= 0, aid
= 0;
1381 u8 rate
, queue
, crypt_offset
= 0;
1384 u8 calculated_tries
[4];
1385 u8 nrates
= 0, nremaining
= 8;
1387 queue
= skb_get_queue_mapping(skb
);
1389 ret
= p54_tx_fill(dev
, skb
, info
, &queue
, &tim_len
, &hdr_flags
, &aid
);
1390 current_queue
= &priv
->tx_stats
[queue
];
1391 if (unlikely((current_queue
->len
> current_queue
->limit
) && ret
))
1392 return NETDEV_TX_BUSY
;
1393 current_queue
->len
++;
1394 current_queue
->count
++;
1395 if ((current_queue
->len
== current_queue
->limit
) && ret
)
1396 ieee80211_stop_queue(dev
, skb_get_queue_mapping(skb
));
1398 padding
= (unsigned long)(skb
->data
- (sizeof(*hdr
) + sizeof(*txhdr
))) & 3;
1401 if (info
->control
.hw_key
) {
1402 crypt_offset
= ieee80211_get_hdrlen_from_skb(skb
);
1403 if (info
->control
.hw_key
->alg
== ALG_TKIP
) {
1404 u8
*iv
= (u8
*)(skb
->data
+ crypt_offset
);
1406 * The firmware excepts that the IV has to have
1407 * this special format
1415 txhdr
= (struct p54_tx_data
*) skb_push(skb
, sizeof(*txhdr
) + padding
);
1416 hdr
= (struct p54_hdr
*) skb_push(skb
, sizeof(*hdr
));
1419 hdr_flags
|= P54_HDR_FLAG_DATA_ALIGN
;
1420 hdr
->type
= cpu_to_le16(aid
);
1421 hdr
->rts_tries
= info
->control
.rates
[0].count
;
1424 * we register the rates in perfect order, and
1425 * RTS/CTS won't happen on 5 GHz
1427 cts_rate
= info
->control
.rts_cts_rate_idx
;
1429 memset(&txhdr
->rateset
, 0, sizeof(txhdr
->rateset
));
1431 /* see how many rates got used */
1432 for (i
= 0; i
< 4; i
++) {
1433 if (info
->control
.rates
[i
].idx
< 0)
1438 /* limit tries to 8/nrates per rate */
1439 for (i
= 0; i
< nrates
; i
++) {
1441 * The magic expression here is equivalent to 8/nrates for
1442 * all values that matter, but avoids division and jumps.
1443 * Note that nrates can only take the values 1 through 4.
1445 calculated_tries
[i
] = min_t(int, ((15 >> nrates
) | 1) + 1,
1446 info
->control
.rates
[i
].count
);
1447 nremaining
-= calculated_tries
[i
];
1450 /* if there are tries left, distribute from back to front */
1451 for (i
= nrates
- 1; nremaining
> 0 && i
>= 0; i
--) {
1452 int tmp
= info
->control
.rates
[i
].count
- calculated_tries
[i
];
1456 /* RC requested more tries at this rate */
1458 tmp
= min_t(int, tmp
, nremaining
);
1459 calculated_tries
[i
] += tmp
;
1464 for (i
= 0; i
< nrates
&& ridx
< 8; i
++) {
1465 /* we register the rates in perfect order */
1466 rate
= info
->control
.rates
[i
].idx
;
1467 if (info
->band
== IEEE80211_BAND_5GHZ
)
1470 /* store the count we actually calculated for TX status */
1471 info
->control
.rates
[i
].count
= calculated_tries
[i
];
1473 rc_flags
= info
->control
.rates
[i
].flags
;
1474 if (rc_flags
& IEEE80211_TX_RC_USE_SHORT_PREAMBLE
) {
1478 if (rc_flags
& IEEE80211_TX_RC_USE_RTS_CTS
)
1480 else if (rc_flags
& IEEE80211_TX_RC_USE_CTS_PROTECT
)
1482 for (j
= 0; j
< calculated_tries
[i
] && ridx
< 8; j
++) {
1483 txhdr
->rateset
[ridx
] = rate
;
1488 if (info
->flags
& IEEE80211_TX_CTL_ASSIGN_SEQ
)
1489 hdr_flags
|= P54_HDR_FLAG_DATA_OUT_SEQNR
;
1491 /* TODO: enable bursting */
1492 hdr
->flags
= cpu_to_le16(hdr_flags
);
1494 txhdr
->rts_rate_idx
= 0;
1495 if (info
->control
.hw_key
) {
1496 txhdr
->key_type
= p54_convert_algo(info
->control
.hw_key
->alg
);
1497 txhdr
->key_len
= min((u8
)16, info
->control
.hw_key
->keylen
);
1498 memcpy(txhdr
->key
, info
->control
.hw_key
->key
, txhdr
->key_len
);
1499 if (info
->control
.hw_key
->alg
== ALG_TKIP
) {
1500 if (unlikely(skb_tailroom(skb
) < 12))
1502 /* reserve space for the MIC key */
1504 memcpy(skb_put(skb
, 8), &(info
->control
.hw_key
->key
1505 [NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY
]), 8);
1507 /* reserve some space for ICV */
1508 len
+= info
->control
.hw_key
->icv_len
;
1509 memset(skb_put(skb
, info
->control
.hw_key
->icv_len
), 0,
1510 info
->control
.hw_key
->icv_len
);
1512 txhdr
->key_type
= 0;
1515 txhdr
->crypt_offset
= crypt_offset
;
1516 txhdr
->hw_queue
= queue
;
1517 txhdr
->backlog
= current_queue
->len
;
1518 memset(txhdr
->durations
, 0, sizeof(txhdr
->durations
));
1519 txhdr
->tx_antenna
= ((info
->antenna_sel_tx
== 0) ?
1520 2 : info
->antenna_sel_tx
- 1) & priv
->tx_diversity_mask
;
1521 txhdr
->output_power
= priv
->output_power
;
1522 txhdr
->cts_rate
= cts_rate
;
1524 txhdr
->align
[0] = padding
;
1526 hdr
->len
= cpu_to_le16(len
);
1527 /* modifies skb->cb and with it info, so must be last! */
1528 if (unlikely(p54_assign_address(dev
, skb
, hdr
, skb
->len
+ tim_len
)))
1532 queue_delayed_work(dev
->workqueue
, &priv
->work
,
1533 msecs_to_jiffies(P54_TX_FRAME_LIFETIME
));
1535 return NETDEV_TX_OK
;
1538 skb_pull(skb
, sizeof(*hdr
) + sizeof(*txhdr
) + padding
);
1539 current_queue
->len
--;
1540 current_queue
->count
--;
1541 return NETDEV_TX_BUSY
;
1544 static int p54_setup_mac(struct ieee80211_hw
*dev
)
1546 struct p54_common
*priv
= dev
->priv
;
1547 struct sk_buff
*skb
;
1548 struct p54_setup_mac
*setup
;
1551 skb
= p54_alloc_skb(dev
, P54_HDR_FLAG_CONTROL_OPSET
, sizeof(*setup
),
1552 P54_CONTROL_TYPE_SETUP
, GFP_ATOMIC
);
1556 setup
= (struct p54_setup_mac
*) skb_put(skb
, sizeof(*setup
));
1557 if (dev
->conf
.radio_enabled
) {
1558 switch (priv
->mode
) {
1559 case NL80211_IFTYPE_STATION
:
1560 mode
= P54_FILTER_TYPE_STATION
;
1562 case NL80211_IFTYPE_AP
:
1563 mode
= P54_FILTER_TYPE_AP
;
1565 case NL80211_IFTYPE_ADHOC
:
1566 case NL80211_IFTYPE_MESH_POINT
:
1567 mode
= P54_FILTER_TYPE_IBSS
;
1569 case NL80211_IFTYPE_MONITOR
:
1570 mode
= P54_FILTER_TYPE_PROMISCUOUS
;
1573 mode
= P54_FILTER_TYPE_NONE
;
1578 * "TRANSPARENT and PROMISCUOUS are mutually exclusive"
1579 * STSW45X0C LMAC API - page 12
1581 if (((priv
->filter_flags
& FIF_PROMISC_IN_BSS
) ||
1582 (priv
->filter_flags
& FIF_OTHER_BSS
)) &&
1583 (mode
!= P54_FILTER_TYPE_PROMISCUOUS
))
1584 mode
|= P54_FILTER_TYPE_TRANSPARENT
;
1586 mode
= P54_FILTER_TYPE_RX_DISABLED
;
1588 setup
->mac_mode
= cpu_to_le16(mode
);
1589 memcpy(setup
->mac_addr
, priv
->mac_addr
, ETH_ALEN
);
1590 memcpy(setup
->bssid
, priv
->bssid
, ETH_ALEN
);
1591 setup
->rx_antenna
= 2 & priv
->rx_diversity_mask
; /* automatic */
1592 setup
->rx_align
= 0;
1593 if (priv
->fw_var
< 0x500) {
1594 setup
->v1
.basic_rate_mask
= cpu_to_le32(priv
->basic_rate_mask
);
1595 memset(setup
->v1
.rts_rates
, 0, 8);
1596 setup
->v1
.rx_addr
= cpu_to_le32(priv
->rx_end
);
1597 setup
->v1
.max_rx
= cpu_to_le16(priv
->rx_mtu
);
1598 setup
->v1
.rxhw
= cpu_to_le16(priv
->rxhw
);
1599 setup
->v1
.wakeup_timer
= cpu_to_le16(priv
->wakeup_timer
);
1600 setup
->v1
.unalloc0
= cpu_to_le16(0);
1602 setup
->v2
.rx_addr
= cpu_to_le32(priv
->rx_end
);
1603 setup
->v2
.max_rx
= cpu_to_le16(priv
->rx_mtu
);
1604 setup
->v2
.rxhw
= cpu_to_le16(priv
->rxhw
);
1605 setup
->v2
.timer
= cpu_to_le16(priv
->wakeup_timer
);
1606 setup
->v2
.truncate
= cpu_to_le16(48896);
1607 setup
->v2
.basic_rate_mask
= cpu_to_le32(priv
->basic_rate_mask
);
1608 setup
->v2
.sbss_offset
= 0;
1609 setup
->v2
.mcast_window
= 0;
1610 setup
->v2
.rx_rssi_threshold
= 0;
1611 setup
->v2
.rx_ed_threshold
= 0;
1612 setup
->v2
.ref_clock
= cpu_to_le32(644245094);
1613 setup
->v2
.lpf_bandwidth
= cpu_to_le16(65535);
1614 setup
->v2
.osc_start_delay
= cpu_to_le16(65535);
1620 static int p54_scan(struct ieee80211_hw
*dev
, u16 mode
, u16 dwell
)
1622 struct p54_common
*priv
= dev
->priv
;
1623 struct sk_buff
*skb
;
1624 struct p54_scan
*chan
;
1627 __le16 freq
= cpu_to_le16(dev
->conf
.channel
->center_freq
);
1628 int band
= dev
->conf
.channel
->band
;
1630 skb
= p54_alloc_skb(dev
, P54_HDR_FLAG_CONTROL_OPSET
, sizeof(*chan
),
1631 P54_CONTROL_TYPE_SCAN
, GFP_ATOMIC
);
1635 chan
= (struct p54_scan
*) skb_put(skb
, sizeof(*chan
));
1636 memset(chan
->padding1
, 0, sizeof(chan
->padding1
));
1637 chan
->mode
= cpu_to_le16(mode
);
1638 chan
->dwell
= cpu_to_le16(dwell
);
1640 for (i
= 0; i
< priv
->iq_autocal_len
; i
++) {
1641 if (priv
->iq_autocal
[i
].freq
!= freq
)
1644 memcpy(&chan
->iq_autocal
, &priv
->iq_autocal
[i
],
1645 sizeof(*priv
->iq_autocal
));
1648 if (i
== priv
->iq_autocal_len
)
1651 for (i
= 0; i
< priv
->output_limit_len
; i
++) {
1652 if (priv
->output_limit
[i
].freq
!= freq
)
1655 chan
->val_barker
= 0x38;
1656 chan
->val_bpsk
= chan
->dup_bpsk
=
1657 priv
->output_limit
[i
].val_bpsk
;
1658 chan
->val_qpsk
= chan
->dup_qpsk
=
1659 priv
->output_limit
[i
].val_qpsk
;
1660 chan
->val_16qam
= chan
->dup_16qam
=
1661 priv
->output_limit
[i
].val_16qam
;
1662 chan
->val_64qam
= chan
->dup_64qam
=
1663 priv
->output_limit
[i
].val_64qam
;
1666 if (i
== priv
->output_limit_len
)
1669 entry
= priv
->curve_data
->data
;
1670 for (i
= 0; i
< priv
->curve_data
->channels
; i
++) {
1671 if (*((__le16
*)entry
) != freq
) {
1672 entry
+= sizeof(__le16
);
1673 entry
+= sizeof(struct p54_pa_curve_data_sample
) *
1674 priv
->curve_data
->points_per_channel
;
1678 entry
+= sizeof(__le16
);
1679 chan
->pa_points_per_curve
= 8;
1680 memset(chan
->curve_data
, 0, sizeof(*chan
->curve_data
));
1681 memcpy(chan
->curve_data
, entry
,
1682 sizeof(struct p54_pa_curve_data_sample
) *
1683 min((u8
)8, priv
->curve_data
->points_per_channel
));
1687 if (priv
->fw_var
< 0x500) {
1688 chan
->v1_rssi
.mul
= cpu_to_le16(priv
->rssical_db
[band
].mul
);
1689 chan
->v1_rssi
.add
= cpu_to_le16(priv
->rssical_db
[band
].add
);
1691 chan
->v2
.rssi
.mul
= cpu_to_le16(priv
->rssical_db
[band
].mul
);
1692 chan
->v2
.rssi
.add
= cpu_to_le16(priv
->rssical_db
[band
].add
);
1693 chan
->v2
.basic_rate_mask
= cpu_to_le32(priv
->basic_rate_mask
);
1694 memset(chan
->v2
.rts_rates
, 0, 8);
1700 printk(KERN_ERR
"%s: frequency change failed\n", wiphy_name(dev
->wiphy
));
1701 p54_free_skb(dev
, skb
);
1705 static int p54_set_leds(struct ieee80211_hw
*dev
, int mode
, int link
, int act
)
1707 struct p54_common
*priv
= dev
->priv
;
1708 struct sk_buff
*skb
;
1709 struct p54_led
*led
;
1711 skb
= p54_alloc_skb(dev
, P54_HDR_FLAG_CONTROL_OPSET
, sizeof(*led
),
1712 P54_CONTROL_TYPE_LED
, GFP_ATOMIC
);
1716 led
= (struct p54_led
*)skb_put(skb
, sizeof(*led
));
1717 led
->mode
= cpu_to_le16(mode
);
1718 led
->led_permanent
= cpu_to_le16(link
);
1719 led
->led_temporary
= cpu_to_le16(act
);
1720 led
->duration
= cpu_to_le16(1000);
1725 #define P54_SET_QUEUE(queue, ai_fs, cw_min, cw_max, _txop) \
1727 queue.aifs = cpu_to_le16(ai_fs); \
1728 queue.cwmin = cpu_to_le16(cw_min); \
1729 queue.cwmax = cpu_to_le16(cw_max); \
1730 queue.txop = cpu_to_le16(_txop); \
1733 static int p54_set_edcf(struct ieee80211_hw
*dev
)
1735 struct p54_common
*priv
= dev
->priv
;
1736 struct sk_buff
*skb
;
1737 struct p54_edcf
*edcf
;
1739 skb
= p54_alloc_skb(dev
, P54_HDR_FLAG_CONTROL_OPSET
, sizeof(*edcf
),
1740 P54_CONTROL_TYPE_DCFINIT
, GFP_ATOMIC
);
1744 edcf
= (struct p54_edcf
*)skb_put(skb
, sizeof(*edcf
));
1745 if (priv
->use_short_slot
) {
1748 edcf
->eofpad
= 0x00;
1750 edcf
->slottime
= 20;
1752 edcf
->eofpad
= 0x06;
1754 /* (see prism54/isl_oid.h for further details) */
1755 edcf
->frameburst
= cpu_to_le16(0);
1756 edcf
->round_trip_delay
= cpu_to_le16(0);
1758 memset(edcf
->mapping
, 0, sizeof(edcf
->mapping
));
1759 memcpy(edcf
->queue
, priv
->qos_params
, sizeof(edcf
->queue
));
1764 static int p54_set_ps(struct ieee80211_hw
*dev
)
1766 struct p54_common
*priv
= dev
->priv
;
1767 struct sk_buff
*skb
;
1768 struct p54_psm
*psm
;
1772 if (dev
->conf
.flags
& IEEE80211_CONF_PS
)
1773 mode
= P54_PSM
| P54_PSM_DTIM
| P54_PSM_MCBC
;
1777 skb
= p54_alloc_skb(dev
, P54_HDR_FLAG_CONTROL_OPSET
, sizeof(*psm
),
1778 P54_CONTROL_TYPE_PSM
, GFP_ATOMIC
);
1782 psm
= (struct p54_psm
*)skb_put(skb
, sizeof(*psm
));
1783 psm
->mode
= cpu_to_le16(mode
);
1784 psm
->aid
= cpu_to_le16(priv
->aid
);
1785 for (i
= 0; i
< ARRAY_SIZE(psm
->intervals
); i
++) {
1786 psm
->intervals
[i
].interval
=
1787 cpu_to_le16(dev
->conf
.listen_interval
);
1788 psm
->intervals
[i
].periods
= cpu_to_le16(1);
1791 psm
->beacon_rssi_skip_max
= 60;
1792 psm
->rssi_delta_threshold
= 0;
1800 static int p54_beacon_tim(struct sk_buff
*skb
)
1803 * the good excuse for this mess is ... the firmware.
1804 * The dummy TIM MUST be at the end of the beacon frame,
1805 * because it'll be overwritten!
1808 struct ieee80211_mgmt
*mgmt
= (void *)skb
->data
;
1811 if (skb
->len
<= sizeof(mgmt
))
1814 pos
= (u8
*)mgmt
->u
.beacon
.variable
;
1815 end
= skb
->data
+ skb
->len
;
1817 if (pos
+ 2 + pos
[1] > end
)
1820 if (pos
[0] == WLAN_EID_TIM
) {
1821 u8 dtim_len
= pos
[1];
1822 u8 dtim_period
= pos
[3];
1823 u8
*next
= pos
+ 2 + dtim_len
;
1828 memmove(pos
, next
, end
- next
);
1831 skb_trim(skb
, skb
->len
- (dtim_len
- 3));
1833 pos
= end
- (dtim_len
+ 2);
1835 /* add the dummy at the end */
1836 pos
[0] = WLAN_EID_TIM
;
1839 pos
[3] = dtim_period
;
1848 static int p54_beacon_update(struct ieee80211_hw
*dev
,
1849 struct ieee80211_vif
*vif
)
1851 struct p54_common
*priv
= dev
->priv
;
1852 struct sk_buff
*beacon
;
1855 if (priv
->cached_beacon
) {
1856 p54_tx_cancel(dev
, priv
->cached_beacon
);
1857 /* wait for the last beacon the be freed */
1861 beacon
= ieee80211_beacon_get(dev
, vif
);
1864 ret
= p54_beacon_tim(beacon
);
1867 ret
= p54_tx(dev
, beacon
);
1870 priv
->cached_beacon
= beacon
;
1871 priv
->tsf_high32
= 0;
1872 priv
->tsf_low32
= 0;
1877 static int p54_start(struct ieee80211_hw
*dev
)
1879 struct p54_common
*priv
= dev
->priv
;
1882 mutex_lock(&priv
->conf_mutex
);
1883 err
= priv
->open(dev
);
1886 P54_SET_QUEUE(priv
->qos_params
[0], 0x0002, 0x0003, 0x0007, 47);
1887 P54_SET_QUEUE(priv
->qos_params
[1], 0x0002, 0x0007, 0x000f, 94);
1888 P54_SET_QUEUE(priv
->qos_params
[2], 0x0003, 0x000f, 0x03ff, 0);
1889 P54_SET_QUEUE(priv
->qos_params
[3], 0x0007, 0x000f, 0x03ff, 0);
1890 err
= p54_set_edcf(dev
);
1894 memset(priv
->bssid
, ~0, ETH_ALEN
);
1895 priv
->mode
= NL80211_IFTYPE_MONITOR
;
1896 err
= p54_setup_mac(dev
);
1898 priv
->mode
= NL80211_IFTYPE_UNSPECIFIED
;
1902 queue_delayed_work(dev
->workqueue
, &priv
->work
, 0);
1905 mutex_unlock(&priv
->conf_mutex
);
1909 static void p54_stop(struct ieee80211_hw
*dev
)
1911 struct p54_common
*priv
= dev
->priv
;
1912 struct sk_buff
*skb
;
1914 mutex_lock(&priv
->conf_mutex
);
1915 priv
->mode
= NL80211_IFTYPE_UNSPECIFIED
;
1916 cancel_delayed_work_sync(&priv
->work
);
1917 if (priv
->cached_beacon
)
1918 p54_tx_cancel(dev
, priv
->cached_beacon
);
1921 while ((skb
= skb_dequeue(&priv
->tx_queue
)))
1923 priv
->cached_beacon
= NULL
;
1924 priv
->tsf_high32
= priv
->tsf_low32
= 0;
1925 mutex_unlock(&priv
->conf_mutex
);
1928 static int p54_add_interface(struct ieee80211_hw
*dev
,
1929 struct ieee80211_if_init_conf
*conf
)
1931 struct p54_common
*priv
= dev
->priv
;
1933 mutex_lock(&priv
->conf_mutex
);
1934 if (priv
->mode
!= NL80211_IFTYPE_MONITOR
) {
1935 mutex_unlock(&priv
->conf_mutex
);
1939 switch (conf
->type
) {
1940 case NL80211_IFTYPE_STATION
:
1941 case NL80211_IFTYPE_ADHOC
:
1942 case NL80211_IFTYPE_AP
:
1943 case NL80211_IFTYPE_MESH_POINT
:
1944 priv
->mode
= conf
->type
;
1947 mutex_unlock(&priv
->conf_mutex
);
1951 memcpy(priv
->mac_addr
, conf
->mac_addr
, ETH_ALEN
);
1953 p54_set_leds(dev
, 1, 0, 0);
1954 mutex_unlock(&priv
->conf_mutex
);
1958 static void p54_remove_interface(struct ieee80211_hw
*dev
,
1959 struct ieee80211_if_init_conf
*conf
)
1961 struct p54_common
*priv
= dev
->priv
;
1963 mutex_lock(&priv
->conf_mutex
);
1964 if (priv
->cached_beacon
)
1965 p54_tx_cancel(dev
, priv
->cached_beacon
);
1966 priv
->mode
= NL80211_IFTYPE_MONITOR
;
1967 memset(priv
->mac_addr
, 0, ETH_ALEN
);
1968 memset(priv
->bssid
, 0, ETH_ALEN
);
1970 mutex_unlock(&priv
->conf_mutex
);
1973 static int p54_config(struct ieee80211_hw
*dev
, u32 changed
)
1976 struct p54_common
*priv
= dev
->priv
;
1977 struct ieee80211_conf
*conf
= &dev
->conf
;
1979 mutex_lock(&priv
->conf_mutex
);
1980 if (changed
& IEEE80211_CONF_CHANGE_POWER
)
1981 priv
->output_power
= conf
->power_level
<< 2;
1982 if (changed
& IEEE80211_CONF_CHANGE_RADIO_ENABLED
) {
1983 ret
= p54_setup_mac(dev
);
1987 if (changed
& IEEE80211_CONF_CHANGE_CHANNEL
) {
1988 ret
= p54_scan(dev
, P54_SCAN_EXIT
, 0);
1992 if (changed
& IEEE80211_CONF_CHANGE_PS
) {
1993 ret
= p54_set_ps(dev
);
1999 mutex_unlock(&priv
->conf_mutex
);
2003 static int p54_config_interface(struct ieee80211_hw
*dev
,
2004 struct ieee80211_vif
*vif
,
2005 struct ieee80211_if_conf
*conf
)
2007 struct p54_common
*priv
= dev
->priv
;
2010 mutex_lock(&priv
->conf_mutex
);
2011 if (conf
->changed
& IEEE80211_IFCC_BSSID
) {
2012 memcpy(priv
->bssid
, conf
->bssid
, ETH_ALEN
);
2013 ret
= p54_setup_mac(dev
);
2018 if (conf
->changed
& IEEE80211_IFCC_BEACON
) {
2019 ret
= p54_scan(dev
, P54_SCAN_EXIT
, 0);
2022 ret
= p54_setup_mac(dev
);
2025 ret
= p54_beacon_update(dev
, vif
);
2028 ret
= p54_set_edcf(dev
);
2033 ret
= p54_set_leds(dev
, 1, !is_multicast_ether_addr(priv
->bssid
), 0);
2036 mutex_unlock(&priv
->conf_mutex
);
2040 static void p54_configure_filter(struct ieee80211_hw
*dev
,
2041 unsigned int changed_flags
,
2042 unsigned int *total_flags
,
2043 int mc_count
, struct dev_mc_list
*mclist
)
2045 struct p54_common
*priv
= dev
->priv
;
2047 *total_flags
&= FIF_PROMISC_IN_BSS
|
2049 (*total_flags
& FIF_PROMISC_IN_BSS
) ?
2052 priv
->filter_flags
= *total_flags
;
2054 if (changed_flags
& (FIF_PROMISC_IN_BSS
| FIF_OTHER_BSS
))
2058 static int p54_conf_tx(struct ieee80211_hw
*dev
, u16 queue
,
2059 const struct ieee80211_tx_queue_params
*params
)
2061 struct p54_common
*priv
= dev
->priv
;
2064 mutex_lock(&priv
->conf_mutex
);
2065 if ((params
) && !(queue
> 4)) {
2066 P54_SET_QUEUE(priv
->qos_params
[queue
], params
->aifs
,
2067 params
->cw_min
, params
->cw_max
, params
->txop
);
2068 ret
= p54_set_edcf(dev
);
2071 mutex_unlock(&priv
->conf_mutex
);
2075 static int p54_init_xbow_synth(struct ieee80211_hw
*dev
)
2077 struct p54_common
*priv
= dev
->priv
;
2078 struct sk_buff
*skb
;
2079 struct p54_xbow_synth
*xbow
;
2081 skb
= p54_alloc_skb(dev
, P54_HDR_FLAG_CONTROL_OPSET
, sizeof(*xbow
),
2082 P54_CONTROL_TYPE_XBOW_SYNTH_CFG
, GFP_KERNEL
);
2086 xbow
= (struct p54_xbow_synth
*)skb_put(skb
, sizeof(*xbow
));
2087 xbow
->magic1
= cpu_to_le16(0x1);
2088 xbow
->magic2
= cpu_to_le16(0x2);
2089 xbow
->freq
= cpu_to_le16(5390);
2090 memset(xbow
->padding
, 0, sizeof(xbow
->padding
));
2095 static void p54_work(struct work_struct
*work
)
2097 struct p54_common
*priv
= container_of(work
, struct p54_common
,
2099 struct ieee80211_hw
*dev
= priv
->hw
;
2100 struct sk_buff
*skb
;
2102 if (unlikely(priv
->mode
== NL80211_IFTYPE_UNSPECIFIED
))
2106 * TODO: walk through tx_queue and do the following tasks
2107 * 1. initiate bursts.
2108 * 2. cancel stuck frames / reset the device if necessary.
2111 skb
= p54_alloc_skb(dev
, P54_HDR_FLAG_CONTROL
,
2112 sizeof(struct p54_statistics
),
2113 P54_CONTROL_TYPE_STAT_READBACK
, GFP_KERNEL
);
2120 static int p54_get_stats(struct ieee80211_hw
*dev
,
2121 struct ieee80211_low_level_stats
*stats
)
2123 struct p54_common
*priv
= dev
->priv
;
2125 memcpy(stats
, &priv
->stats
, sizeof(*stats
));
2129 static int p54_get_tx_stats(struct ieee80211_hw
*dev
,
2130 struct ieee80211_tx_queue_stats
*stats
)
2132 struct p54_common
*priv
= dev
->priv
;
2134 memcpy(stats
, &priv
->tx_stats
[P54_QUEUE_DATA
],
2135 sizeof(stats
[0]) * dev
->queues
);
2139 static void p54_bss_info_changed(struct ieee80211_hw
*dev
,
2140 struct ieee80211_vif
*vif
,
2141 struct ieee80211_bss_conf
*info
,
2144 struct p54_common
*priv
= dev
->priv
;
2146 if (changed
& BSS_CHANGED_ERP_SLOT
) {
2147 priv
->use_short_slot
= info
->use_short_slot
;
2150 if (changed
& BSS_CHANGED_BASIC_RATES
) {
2151 if (dev
->conf
.channel
->band
== IEEE80211_BAND_5GHZ
)
2152 priv
->basic_rate_mask
= (info
->basic_rates
<< 4);
2154 priv
->basic_rate_mask
= info
->basic_rates
;
2156 if (priv
->fw_var
>= 0x500)
2157 p54_scan(dev
, P54_SCAN_EXIT
, 0);
2159 if (changed
& BSS_CHANGED_ASSOC
) {
2161 priv
->aid
= info
->aid
;
2162 priv
->wakeup_timer
= info
->beacon_int
*
2163 info
->dtim_period
* 5;
2170 static int p54_set_key(struct ieee80211_hw
*dev
, enum set_key_cmd cmd
,
2171 struct ieee80211_vif
*vif
, struct ieee80211_sta
*sta
,
2172 struct ieee80211_key_conf
*key
)
2174 struct p54_common
*priv
= dev
->priv
;
2175 struct sk_buff
*skb
;
2176 struct p54_keycache
*rxkey
;
2179 if (modparam_nohwcrypt
)
2182 if (cmd
== DISABLE_KEY
)
2187 if (!(priv
->privacy_caps
& (BR_DESC_PRIV_CAP_MICHAEL
|
2188 BR_DESC_PRIV_CAP_TKIP
)))
2190 key
->flags
|= IEEE80211_KEY_FLAG_GENERATE_IV
;
2191 algo
= P54_CRYPTO_TKIPMICHAEL
;
2194 if (!(priv
->privacy_caps
& BR_DESC_PRIV_CAP_WEP
))
2196 key
->flags
|= IEEE80211_KEY_FLAG_GENERATE_IV
;
2197 algo
= P54_CRYPTO_WEP
;
2200 if (!(priv
->privacy_caps
& BR_DESC_PRIV_CAP_AESCCMP
))
2202 key
->flags
|= IEEE80211_KEY_FLAG_GENERATE_IV
;
2203 algo
= P54_CRYPTO_AESCCMP
;
2210 if (key
->keyidx
> priv
->rx_keycache_size
) {
2212 * The device supports the choosen algorithm, but the firmware
2213 * does not provide enough key slots to store all of them.
2214 * So, incoming frames have to be decoded by the mac80211 stack,
2215 * but we can still offload encryption for outgoing frames.
2221 mutex_lock(&priv
->conf_mutex
);
2222 skb
= p54_alloc_skb(dev
, P54_HDR_FLAG_CONTROL_OPSET
, sizeof(*rxkey
),
2223 P54_CONTROL_TYPE_RX_KEYCACHE
, GFP_ATOMIC
);
2225 mutex_unlock(&priv
->conf_mutex
);
2229 /* TODO: some devices have 4 more free slots for rx keys */
2230 rxkey
= (struct p54_keycache
*)skb_put(skb
, sizeof(*rxkey
));
2231 rxkey
->entry
= key
->keyidx
;
2232 rxkey
->key_id
= key
->keyidx
;
2233 rxkey
->key_type
= algo
;
2235 memcpy(rxkey
->mac
, sta
->addr
, ETH_ALEN
);
2237 memset(rxkey
->mac
, ~0, ETH_ALEN
);
2238 if (key
->alg
!= ALG_TKIP
) {
2239 rxkey
->key_len
= min((u8
)16, key
->keylen
);
2240 memcpy(rxkey
->key
, key
->key
, rxkey
->key_len
);
2242 rxkey
->key_len
= 24;
2243 memcpy(rxkey
->key
, key
->key
, 16);
2244 memcpy(&(rxkey
->key
[16]), &(key
->key
2245 [NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY
]), 8);
2249 mutex_unlock(&priv
->conf_mutex
);
2253 static const struct ieee80211_ops p54_ops
= {
2257 .add_interface
= p54_add_interface
,
2258 .remove_interface
= p54_remove_interface
,
2259 .set_tim
= p54_set_tim
,
2260 .sta_notify
= p54_sta_notify
,
2261 .set_key
= p54_set_key
,
2262 .config
= p54_config
,
2263 .config_interface
= p54_config_interface
,
2264 .bss_info_changed
= p54_bss_info_changed
,
2265 .configure_filter
= p54_configure_filter
,
2266 .conf_tx
= p54_conf_tx
,
2267 .get_stats
= p54_get_stats
,
2268 .get_tx_stats
= p54_get_tx_stats
2271 struct ieee80211_hw
*p54_init_common(size_t priv_data_len
)
2273 struct ieee80211_hw
*dev
;
2274 struct p54_common
*priv
;
2276 dev
= ieee80211_alloc_hw(priv_data_len
, &p54_ops
);
2282 priv
->mode
= NL80211_IFTYPE_UNSPECIFIED
;
2283 priv
->basic_rate_mask
= 0x15f;
2284 skb_queue_head_init(&priv
->tx_queue
);
2285 dev
->flags
= IEEE80211_HW_RX_INCLUDES_FCS
|
2286 IEEE80211_HW_SIGNAL_DBM
|
2287 IEEE80211_HW_NOISE_DBM
;
2289 dev
->wiphy
->interface_modes
= BIT(NL80211_IFTYPE_STATION
) |
2290 BIT(NL80211_IFTYPE_ADHOC
) |
2291 BIT(NL80211_IFTYPE_AP
) |
2292 BIT(NL80211_IFTYPE_MESH_POINT
);
2294 dev
->channel_change_time
= 1000; /* TODO: find actual value */
2295 priv
->tx_stats
[P54_QUEUE_BEACON
].limit
= 1;
2296 priv
->tx_stats
[P54_QUEUE_FWSCAN
].limit
= 1;
2297 priv
->tx_stats
[P54_QUEUE_MGMT
].limit
= 3;
2298 priv
->tx_stats
[P54_QUEUE_CAB
].limit
= 3;
2299 priv
->tx_stats
[P54_QUEUE_DATA
].limit
= 5;
2303 * We support at most 8 tries no matter which rate they're at,
2304 * we cannot support max_rates * max_rate_tries as we set it
2305 * here, but setting it correctly to 4/2 or so would limit us
2306 * artificially if the RC algorithm wants just two rates, so
2307 * let's say 4/7, we'll redistribute it at TX time, see the
2311 dev
->max_rate_tries
= 7;
2312 dev
->extra_tx_headroom
= sizeof(struct p54_hdr
) + 4 +
2313 sizeof(struct p54_tx_data
);
2315 mutex_init(&priv
->conf_mutex
);
2316 init_completion(&priv
->eeprom_comp
);
2317 INIT_DELAYED_WORK(&priv
->work
, p54_work
);
2321 EXPORT_SYMBOL_GPL(p54_init_common
);
2323 void p54_free_common(struct ieee80211_hw
*dev
)
2325 struct p54_common
*priv
= dev
->priv
;
2326 kfree(priv
->iq_autocal
);
2327 kfree(priv
->output_limit
);
2328 kfree(priv
->curve_data
);
2330 EXPORT_SYMBOL_GPL(p54_free_common
);
2332 static int __init
p54_init(void)
2337 static void __exit
p54_exit(void)
2341 module_init(p54_init
);
2342 module_exit(p54_exit
);