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>
24 #ifdef CONFIG_P54_LEDS
25 #include <linux/leds.h>
26 #endif /* CONFIG_P54_LEDS */
29 #include "p54common.h"
31 static int modparam_nohwcrypt
;
32 module_param_named(nohwcrypt
, modparam_nohwcrypt
, bool, S_IRUGO
);
33 MODULE_PARM_DESC(nohwcrypt
, "Disable hardware encryption.");
34 MODULE_AUTHOR("Michael Wu <flamingice@sourmilk.net>");
35 MODULE_DESCRIPTION("Softmac Prism54 common code");
36 MODULE_LICENSE("GPL");
37 MODULE_ALIAS("prism54common");
39 static struct ieee80211_rate p54_bgrates
[] = {
40 { .bitrate
= 10, .hw_value
= 0, .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
41 { .bitrate
= 20, .hw_value
= 1, .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
42 { .bitrate
= 55, .hw_value
= 2, .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
43 { .bitrate
= 110, .hw_value
= 3, .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
44 { .bitrate
= 60, .hw_value
= 4, },
45 { .bitrate
= 90, .hw_value
= 5, },
46 { .bitrate
= 120, .hw_value
= 6, },
47 { .bitrate
= 180, .hw_value
= 7, },
48 { .bitrate
= 240, .hw_value
= 8, },
49 { .bitrate
= 360, .hw_value
= 9, },
50 { .bitrate
= 480, .hw_value
= 10, },
51 { .bitrate
= 540, .hw_value
= 11, },
54 static struct ieee80211_channel p54_bgchannels
[] = {
55 { .center_freq
= 2412, .hw_value
= 1, },
56 { .center_freq
= 2417, .hw_value
= 2, },
57 { .center_freq
= 2422, .hw_value
= 3, },
58 { .center_freq
= 2427, .hw_value
= 4, },
59 { .center_freq
= 2432, .hw_value
= 5, },
60 { .center_freq
= 2437, .hw_value
= 6, },
61 { .center_freq
= 2442, .hw_value
= 7, },
62 { .center_freq
= 2447, .hw_value
= 8, },
63 { .center_freq
= 2452, .hw_value
= 9, },
64 { .center_freq
= 2457, .hw_value
= 10, },
65 { .center_freq
= 2462, .hw_value
= 11, },
66 { .center_freq
= 2467, .hw_value
= 12, },
67 { .center_freq
= 2472, .hw_value
= 13, },
68 { .center_freq
= 2484, .hw_value
= 14, },
71 static struct ieee80211_supported_band band_2GHz
= {
72 .channels
= p54_bgchannels
,
73 .n_channels
= ARRAY_SIZE(p54_bgchannels
),
74 .bitrates
= p54_bgrates
,
75 .n_bitrates
= ARRAY_SIZE(p54_bgrates
),
78 static struct ieee80211_rate p54_arates
[] = {
79 { .bitrate
= 60, .hw_value
= 4, },
80 { .bitrate
= 90, .hw_value
= 5, },
81 { .bitrate
= 120, .hw_value
= 6, },
82 { .bitrate
= 180, .hw_value
= 7, },
83 { .bitrate
= 240, .hw_value
= 8, },
84 { .bitrate
= 360, .hw_value
= 9, },
85 { .bitrate
= 480, .hw_value
= 10, },
86 { .bitrate
= 540, .hw_value
= 11, },
89 static struct ieee80211_channel p54_achannels
[] = {
90 { .center_freq
= 4920 },
91 { .center_freq
= 4940 },
92 { .center_freq
= 4960 },
93 { .center_freq
= 4980 },
94 { .center_freq
= 5040 },
95 { .center_freq
= 5060 },
96 { .center_freq
= 5080 },
97 { .center_freq
= 5170 },
98 { .center_freq
= 5180 },
99 { .center_freq
= 5190 },
100 { .center_freq
= 5200 },
101 { .center_freq
= 5210 },
102 { .center_freq
= 5220 },
103 { .center_freq
= 5230 },
104 { .center_freq
= 5240 },
105 { .center_freq
= 5260 },
106 { .center_freq
= 5280 },
107 { .center_freq
= 5300 },
108 { .center_freq
= 5320 },
109 { .center_freq
= 5500 },
110 { .center_freq
= 5520 },
111 { .center_freq
= 5540 },
112 { .center_freq
= 5560 },
113 { .center_freq
= 5580 },
114 { .center_freq
= 5600 },
115 { .center_freq
= 5620 },
116 { .center_freq
= 5640 },
117 { .center_freq
= 5660 },
118 { .center_freq
= 5680 },
119 { .center_freq
= 5700 },
120 { .center_freq
= 5745 },
121 { .center_freq
= 5765 },
122 { .center_freq
= 5785 },
123 { .center_freq
= 5805 },
124 { .center_freq
= 5825 },
127 static struct ieee80211_supported_band band_5GHz
= {
128 .channels
= p54_achannels
,
129 .n_channels
= ARRAY_SIZE(p54_achannels
),
130 .bitrates
= p54_arates
,
131 .n_bitrates
= ARRAY_SIZE(p54_arates
),
134 int p54_parse_firmware(struct ieee80211_hw
*dev
, const struct firmware
*fw
)
136 struct p54_common
*priv
= dev
->priv
;
137 struct bootrec_exp_if
*exp_if
;
138 struct bootrec
*bootrec
;
139 u32
*data
= (u32
*)fw
->data
;
140 u32
*end_data
= (u32
*)fw
->data
+ (fw
->size
>> 2);
141 u8
*fw_version
= NULL
;
149 while (data
< end_data
&& *data
)
152 while (data
< end_data
&& !*data
)
155 bootrec
= (struct bootrec
*) data
;
157 while (bootrec
->data
<= end_data
&&
158 (bootrec
->data
+ (len
= le32_to_cpu(bootrec
->len
))) <= end_data
) {
159 u32 code
= le32_to_cpu(bootrec
->code
);
161 case BR_CODE_COMPONENT_ID
:
162 priv
->fw_interface
= be32_to_cpup((__be32
*)
164 switch (priv
->fw_interface
) {
168 char *iftype
= (char *)bootrec
->data
;
169 printk(KERN_INFO
"%s: p54 detected a LM%c%c "
171 wiphy_name(dev
->wiphy
),
172 iftype
[2], iftype
[3]);
177 printk(KERN_ERR
"%s: unsupported firmware\n",
178 wiphy_name(dev
->wiphy
));
182 case BR_CODE_COMPONENT_VERSION
:
183 /* 24 bytes should be enough for all firmwares */
184 if (strnlen((unsigned char*)bootrec
->data
, 24) < 24)
185 fw_version
= (unsigned char*)bootrec
->data
;
187 case BR_CODE_DESCR
: {
188 struct bootrec_desc
*desc
=
189 (struct bootrec_desc
*)bootrec
->data
;
190 priv
->rx_start
= le32_to_cpu(desc
->rx_start
);
191 /* FIXME add sanity checking */
192 priv
->rx_end
= le32_to_cpu(desc
->rx_end
) - 0x3500;
193 priv
->headroom
= desc
->headroom
;
194 priv
->tailroom
= desc
->tailroom
;
195 priv
->privacy_caps
= desc
->privacy_caps
;
196 priv
->rx_keycache_size
= desc
->rx_keycache_size
;
197 if (le32_to_cpu(bootrec
->len
) == 11)
198 priv
->rx_mtu
= le16_to_cpu(desc
->rx_mtu
);
200 priv
->rx_mtu
= (size_t)
201 0x620 - priv
->tx_hdr_len
;
202 maxlen
= priv
->tx_hdr_len
+ /* USB devices */
203 sizeof(struct p54_rx_data
) +
204 4 + /* rx alignment */
205 IEEE80211_MAX_FRAG_THRESHOLD
;
206 if (priv
->rx_mtu
> maxlen
&& PAGE_SIZE
== 4096) {
207 printk(KERN_INFO
"p54: rx_mtu reduced from %d "
208 "to %d\n", priv
->rx_mtu
,
210 priv
->rx_mtu
= maxlen
;
214 case BR_CODE_EXPOSED_IF
:
215 exp_if
= (struct bootrec_exp_if
*) bootrec
->data
;
216 for (i
= 0; i
< (len
* sizeof(*exp_if
) / 4); i
++)
217 if (exp_if
[i
].if_id
== cpu_to_le16(0x1a))
218 priv
->fw_var
= le16_to_cpu(exp_if
[i
].variant
);
220 case BR_CODE_DEPENDENT_IF
:
222 case BR_CODE_END_OF_BRA
:
223 case LEGACY_BR_CODE_END_OF_BRA
:
229 bootrec
= (struct bootrec
*)&bootrec
->data
[len
];
233 printk(KERN_INFO
"%s: FW rev %s - Softmac protocol %x.%x\n",
234 wiphy_name(dev
->wiphy
), fw_version
,
235 priv
->fw_var
>> 8, priv
->fw_var
& 0xff);
237 if (priv
->fw_var
< 0x500)
238 printk(KERN_INFO
"%s: you are using an obsolete firmware. "
239 "visit http://wireless.kernel.org/en/users/Drivers/p54 "
240 "and grab one for \"kernel >= 2.6.28\"!\n",
241 wiphy_name(dev
->wiphy
));
243 if (priv
->fw_var
>= 0x300) {
244 /* Firmware supports QoS, use it! */
245 priv
->tx_stats
[P54_QUEUE_AC_VO
].limit
= 3;
246 priv
->tx_stats
[P54_QUEUE_AC_VI
].limit
= 4;
247 priv
->tx_stats
[P54_QUEUE_AC_BE
].limit
= 3;
248 priv
->tx_stats
[P54_QUEUE_AC_BK
].limit
= 2;
249 dev
->queues
= P54_QUEUE_AC_NUM
;
252 if (!modparam_nohwcrypt
) {
253 printk(KERN_INFO
"%s: cryptographic accelerator "
254 "WEP:%s, TKIP:%s, CCMP:%s\n",
255 wiphy_name(dev
->wiphy
),
256 (priv
->privacy_caps
& BR_DESC_PRIV_CAP_WEP
) ? "YES" :
257 "no", (priv
->privacy_caps
& (BR_DESC_PRIV_CAP_TKIP
|
258 BR_DESC_PRIV_CAP_MICHAEL
)) ? "YES" : "no",
259 (priv
->privacy_caps
& BR_DESC_PRIV_CAP_AESCCMP
) ?
262 if (priv
->rx_keycache_size
) {
266 * The firmware provides at most 255 (0 - 254) slots
267 * for keys which are then used to offload decryption.
268 * As a result the 255 entry (aka 0xff) can be used
269 * safely by the driver to mark keys that didn't fit
270 * into the full cache. This trick saves us from
271 * keeping a extra list for uploaded keys.
274 priv
->used_rxkeys
= kzalloc(BITS_TO_LONGS(
275 priv
->rx_keycache_size
), GFP_KERNEL
);
277 if (!priv
->used_rxkeys
)
284 EXPORT_SYMBOL_GPL(p54_parse_firmware
);
286 static int p54_convert_rev0(struct ieee80211_hw
*dev
,
287 struct pda_pa_curve_data
*curve_data
)
289 struct p54_common
*priv
= dev
->priv
;
290 struct p54_pa_curve_data_sample
*dst
;
291 struct pda_pa_curve_data_sample_rev0
*src
;
292 size_t cd_len
= sizeof(*curve_data
) +
293 (curve_data
->points_per_channel
*sizeof(*dst
) + 2) *
294 curve_data
->channels
;
296 void *source
, *target
;
298 priv
->curve_data
= kmalloc(sizeof(*priv
->curve_data
) + cd_len
,
300 if (!priv
->curve_data
)
303 priv
->curve_data
->entries
= curve_data
->channels
;
304 priv
->curve_data
->entry_size
= sizeof(__le16
) +
305 sizeof(*dst
) * curve_data
->points_per_channel
;
306 priv
->curve_data
->offset
= offsetof(struct pda_pa_curve_data
, data
);
307 priv
->curve_data
->len
= cd_len
;
308 memcpy(priv
->curve_data
->data
, curve_data
, sizeof(*curve_data
));
309 source
= curve_data
->data
;
310 target
= ((struct pda_pa_curve_data
*) priv
->curve_data
->data
)->data
;
311 for (i
= 0; i
< curve_data
->channels
; i
++) {
312 __le16
*freq
= source
;
313 source
+= sizeof(__le16
);
314 *((__le16
*)target
) = *freq
;
315 target
+= sizeof(__le16
);
316 for (j
= 0; j
< curve_data
->points_per_channel
; j
++) {
320 dst
->rf_power
= src
->rf_power
;
321 dst
->pa_detector
= src
->pa_detector
;
322 dst
->data_64qam
= src
->pcv
;
323 /* "invent" the points for the other modulations */
324 #define SUB(x,y) (u8)((x) - (y)) > (x) ? 0 : (x) - (y)
325 dst
->data_16qam
= SUB(src
->pcv
, 12);
326 dst
->data_qpsk
= SUB(dst
->data_16qam
, 12);
327 dst
->data_bpsk
= SUB(dst
->data_qpsk
, 12);
328 dst
->data_barker
= SUB(dst
->data_bpsk
, 14);
330 target
+= sizeof(*dst
);
331 source
+= sizeof(*src
);
338 static int p54_convert_rev1(struct ieee80211_hw
*dev
,
339 struct pda_pa_curve_data
*curve_data
)
341 struct p54_common
*priv
= dev
->priv
;
342 struct p54_pa_curve_data_sample
*dst
;
343 struct pda_pa_curve_data_sample_rev1
*src
;
344 size_t cd_len
= sizeof(*curve_data
) +
345 (curve_data
->points_per_channel
*sizeof(*dst
) + 2) *
346 curve_data
->channels
;
348 void *source
, *target
;
350 priv
->curve_data
= kzalloc(cd_len
+ sizeof(*priv
->curve_data
),
352 if (!priv
->curve_data
)
355 priv
->curve_data
->entries
= curve_data
->channels
;
356 priv
->curve_data
->entry_size
= sizeof(__le16
) +
357 sizeof(*dst
) * curve_data
->points_per_channel
;
358 priv
->curve_data
->offset
= offsetof(struct pda_pa_curve_data
, data
);
359 priv
->curve_data
->len
= cd_len
;
360 memcpy(priv
->curve_data
->data
, curve_data
, sizeof(*curve_data
));
361 source
= curve_data
->data
;
362 target
= ((struct pda_pa_curve_data
*) priv
->curve_data
->data
)->data
;
363 for (i
= 0; i
< curve_data
->channels
; i
++) {
364 __le16
*freq
= source
;
365 source
+= sizeof(__le16
);
366 *((__le16
*)target
) = *freq
;
367 target
+= sizeof(__le16
);
368 for (j
= 0; j
< curve_data
->points_per_channel
; j
++) {
369 memcpy(target
, source
, sizeof(*src
));
371 target
+= sizeof(*dst
);
372 source
+= sizeof(*src
);
380 static const char *p54_rf_chips
[] = { "NULL", "Duette3", "Duette2",
381 "Frisbee", "Xbow", "Longbow", "NULL", "NULL" };
382 static int p54_init_xbow_synth(struct ieee80211_hw
*dev
);
384 static void p54_parse_rssical(struct ieee80211_hw
*dev
, void *data
, int len
,
387 struct p54_common
*priv
= dev
->priv
;
388 int offset
= (type
== PDR_RSSI_LINEAR_APPROXIMATION_EXTENDED
) ? 2 : 0;
389 int entry_size
= sizeof(struct pda_rssi_cal_entry
) + offset
;
390 int num_entries
= (type
== PDR_RSSI_LINEAR_APPROXIMATION
) ? 1 : 2;
393 if (len
!= (entry_size
* num_entries
)) {
394 printk(KERN_ERR
"%s: unknown rssi calibration data packing "
395 " type:(%x) len:%d.\n",
396 wiphy_name(dev
->wiphy
), type
, len
);
398 print_hex_dump_bytes("rssical:", DUMP_PREFIX_NONE
,
401 printk(KERN_ERR
"%s: please report this issue.\n",
402 wiphy_name(dev
->wiphy
));
406 for (i
= 0; i
< num_entries
; i
++) {
407 struct pda_rssi_cal_entry
*cal
= data
+
408 (offset
+ i
* entry_size
);
409 priv
->rssical_db
[i
].mul
= (s16
) le16_to_cpu(cal
->mul
);
410 priv
->rssical_db
[i
].add
= (s16
) le16_to_cpu(cal
->add
);
414 static void p54_parse_default_country(struct ieee80211_hw
*dev
,
417 struct pda_country
*country
;
419 if (len
!= sizeof(*country
)) {
420 printk(KERN_ERR
"%s: found possible invalid default country "
421 "eeprom entry. (entry size: %d)\n",
422 wiphy_name(dev
->wiphy
), len
);
424 print_hex_dump_bytes("country:", DUMP_PREFIX_NONE
,
427 printk(KERN_ERR
"%s: please report this issue.\n",
428 wiphy_name(dev
->wiphy
));
432 country
= (struct pda_country
*) data
;
433 if (country
->flags
== PDR_COUNTRY_CERT_CODE_PSEUDO
)
434 regulatory_hint(dev
->wiphy
, country
->alpha2
);
437 * write a shared/common function that converts
438 * "Regulatory domain codes" (802.11-2007 14.8.2.2)
439 * into ISO/IEC 3166-1 alpha2 for regulatory_hint.
444 static int p54_convert_output_limits(struct ieee80211_hw
*dev
,
445 u8
*data
, size_t len
)
447 struct p54_common
*priv
= dev
->priv
;
453 printk(KERN_ERR
"%s: unknown output power db revision:%x\n",
454 wiphy_name(dev
->wiphy
), data
[0]);
458 if (2 + data
[1] * sizeof(struct pda_channel_output_limit
) > len
)
461 priv
->output_limit
= kmalloc(data
[1] *
462 sizeof(struct pda_channel_output_limit
) +
463 sizeof(*priv
->output_limit
), GFP_KERNEL
);
465 if (!priv
->output_limit
)
468 priv
->output_limit
->offset
= 0;
469 priv
->output_limit
->entries
= data
[1];
470 priv
->output_limit
->entry_size
=
471 sizeof(struct pda_channel_output_limit
);
472 priv
->output_limit
->len
= priv
->output_limit
->entry_size
*
473 priv
->output_limit
->entries
+
474 priv
->output_limit
->offset
;
476 memcpy(priv
->output_limit
->data
, &data
[2],
477 data
[1] * sizeof(struct pda_channel_output_limit
));
482 static struct p54_cal_database
*p54_convert_db(struct pda_custom_wrapper
*src
,
485 struct p54_cal_database
*dst
;
486 size_t payload_len
, entries
, entry_size
, offset
;
488 payload_len
= le16_to_cpu(src
->len
);
489 entries
= le16_to_cpu(src
->entries
);
490 entry_size
= le16_to_cpu(src
->entry_size
);
491 offset
= le16_to_cpu(src
->offset
);
492 if (((entries
* entry_size
+ offset
) != payload_len
) ||
493 (payload_len
+ sizeof(*src
) != total_len
))
496 dst
= kmalloc(sizeof(*dst
) + payload_len
, GFP_KERNEL
);
500 dst
->entries
= entries
;
501 dst
->entry_size
= entry_size
;
502 dst
->offset
= offset
;
503 dst
->len
= payload_len
;
505 memcpy(dst
->data
, src
->data
, payload_len
);
509 int p54_parse_eeprom(struct ieee80211_hw
*dev
, void *eeprom
, int len
)
511 struct p54_common
*priv
= dev
->priv
;
512 struct eeprom_pda_wrap
*wrap
= NULL
;
513 struct pda_entry
*entry
;
514 unsigned int data_len
, entry_len
;
517 u8
*end
= (u8
*)eeprom
+ len
;
520 wrap
= (struct eeprom_pda_wrap
*) eeprom
;
521 entry
= (void *)wrap
->data
+ le16_to_cpu(wrap
->len
);
523 /* verify that at least the entry length/code fits */
524 while ((u8
*)entry
<= end
- sizeof(*entry
)) {
525 entry_len
= le16_to_cpu(entry
->len
);
526 data_len
= ((entry_len
- 1) << 1);
528 /* abort if entry exceeds whole structure */
529 if ((u8
*)entry
+ sizeof(*entry
) + data_len
> end
)
532 switch (le16_to_cpu(entry
->code
)) {
533 case PDR_MAC_ADDRESS
:
534 if (data_len
!= ETH_ALEN
)
536 SET_IEEE80211_PERM_ADDR(dev
, entry
->data
);
538 case PDR_PRISM_PA_CAL_OUTPUT_POWER_LIMITS
:
539 if (priv
->output_limit
)
541 err
= p54_convert_output_limits(dev
, entry
->data
,
546 case PDR_PRISM_PA_CAL_CURVE_DATA
: {
547 struct pda_pa_curve_data
*curve_data
=
548 (struct pda_pa_curve_data
*)entry
->data
;
549 if (data_len
< sizeof(*curve_data
)) {
554 switch (curve_data
->cal_method_rev
) {
556 err
= p54_convert_rev0(dev
, curve_data
);
559 err
= p54_convert_rev1(dev
, curve_data
);
562 printk(KERN_ERR
"%s: unknown curve data "
564 wiphy_name(dev
->wiphy
),
565 curve_data
->cal_method_rev
);
573 case PDR_PRISM_ZIF_TX_IQ_CALIBRATION
:
574 priv
->iq_autocal
= kmalloc(data_len
, GFP_KERNEL
);
575 if (!priv
->iq_autocal
) {
580 memcpy(priv
->iq_autocal
, entry
->data
, data_len
);
581 priv
->iq_autocal_len
= data_len
/ sizeof(struct pda_iq_autocal_entry
);
583 case PDR_DEFAULT_COUNTRY
:
584 p54_parse_default_country(dev
, entry
->data
, data_len
);
586 case PDR_INTERFACE_LIST
:
588 while ((u8
*)tmp
< entry
->data
+ data_len
) {
589 struct bootrec_exp_if
*exp_if
= tmp
;
590 if (le16_to_cpu(exp_if
->if_id
) == 0xf)
591 synth
= le16_to_cpu(exp_if
->variant
);
592 tmp
+= sizeof(struct bootrec_exp_if
);
595 case PDR_HARDWARE_PLATFORM_COMPONENT_ID
:
598 priv
->version
= *(u8
*)(entry
->data
+ 1);
600 case PDR_RSSI_LINEAR_APPROXIMATION
:
601 case PDR_RSSI_LINEAR_APPROXIMATION_DUAL_BAND
:
602 case PDR_RSSI_LINEAR_APPROXIMATION_EXTENDED
:
603 p54_parse_rssical(dev
, entry
->data
, data_len
,
604 le16_to_cpu(entry
->code
));
606 case PDR_RSSI_LINEAR_APPROXIMATION_CUSTOM
: {
607 __le16
*src
= (void *) entry
->data
;
608 s16
*dst
= (void *) &priv
->rssical_db
;
611 if (data_len
!= sizeof(priv
->rssical_db
)) {
615 for (i
= 0; i
< sizeof(priv
->rssical_db
) /
617 *(dst
++) = (s16
) le16_to_cpu(*(src
++));
620 case PDR_PRISM_PA_CAL_OUTPUT_POWER_LIMITS_CUSTOM
: {
621 struct pda_custom_wrapper
*pda
= (void *) entry
->data
;
622 if (priv
->output_limit
|| data_len
< sizeof(*pda
))
624 priv
->output_limit
= p54_convert_db(pda
, data_len
);
627 case PDR_PRISM_PA_CAL_CURVE_DATA_CUSTOM
: {
628 struct pda_custom_wrapper
*pda
= (void *) entry
->data
;
629 if (priv
->curve_data
|| data_len
< sizeof(*pda
))
631 priv
->curve_data
= p54_convert_db(pda
, data_len
);
635 /* make it overrun */
638 case PDR_MANUFACTURING_PART_NUMBER
:
639 case PDR_PDA_VERSION
:
640 case PDR_NIC_SERIAL_NUMBER
:
641 case PDR_REGULATORY_DOMAIN_LIST
:
642 case PDR_TEMPERATURE_TYPE
:
643 case PDR_PRISM_PCI_IDENTIFIER
:
644 case PDR_COUNTRY_INFORMATION
:
646 case PDR_PRODUCT_NAME
:
647 case PDR_UTF8_OEM_NAME
:
648 case PDR_UTF8_PRODUCT_NAME
:
649 case PDR_COUNTRY_LIST
:
650 case PDR_ANTENNA_GAIN
:
651 case PDR_PRISM_INDIGO_PA_CALIBRATION_DATA
:
652 case PDR_REGULATORY_POWER_LIMITS
:
653 case PDR_RADIATED_TRANSMISSION_CORRECTION
:
654 case PDR_PRISM_TX_IQ_CALIBRATION
:
655 case PDR_BASEBAND_REGISTERS
:
656 case PDR_PER_CHANNEL_BASEBAND_REGISTERS
:
659 printk(KERN_INFO
"%s: unknown eeprom code : 0x%x\n",
660 wiphy_name(dev
->wiphy
),
661 le16_to_cpu(entry
->code
));
665 entry
= (void *)entry
+ (entry_len
+ 1)*2;
668 if (!synth
|| !priv
->iq_autocal
|| !priv
->output_limit
||
670 printk(KERN_ERR
"%s: not all required entries found in eeprom!\n",
671 wiphy_name(dev
->wiphy
));
676 priv
->rxhw
= synth
& PDR_SYNTH_FRONTEND_MASK
;
677 if (priv
->rxhw
== PDR_SYNTH_FRONTEND_XBOW
)
678 p54_init_xbow_synth(dev
);
679 if (!(synth
& PDR_SYNTH_24_GHZ_DISABLED
))
680 dev
->wiphy
->bands
[IEEE80211_BAND_2GHZ
] = &band_2GHz
;
681 if (!(synth
& PDR_SYNTH_5_GHZ_DISABLED
))
682 dev
->wiphy
->bands
[IEEE80211_BAND_5GHZ
] = &band_5GHz
;
683 if ((synth
& PDR_SYNTH_RX_DIV_MASK
) == PDR_SYNTH_RX_DIV_SUPPORTED
)
684 priv
->rx_diversity_mask
= 3;
685 if ((synth
& PDR_SYNTH_TX_DIV_MASK
) == PDR_SYNTH_TX_DIV_SUPPORTED
)
686 priv
->tx_diversity_mask
= 3;
688 if (!is_valid_ether_addr(dev
->wiphy
->perm_addr
)) {
689 u8 perm_addr
[ETH_ALEN
];
691 printk(KERN_WARNING
"%s: Invalid hwaddr! Using randomly generated MAC addr\n",
692 wiphy_name(dev
->wiphy
));
693 random_ether_addr(perm_addr
);
694 SET_IEEE80211_PERM_ADDR(dev
, perm_addr
);
697 printk(KERN_INFO
"%s: hwaddr %pM, MAC:isl38%02x RF:%s\n",
698 wiphy_name(dev
->wiphy
),
699 dev
->wiphy
->perm_addr
,
700 priv
->version
, p54_rf_chips
[priv
->rxhw
]);
705 if (priv
->iq_autocal
) {
706 kfree(priv
->iq_autocal
);
707 priv
->iq_autocal
= NULL
;
710 if (priv
->output_limit
) {
711 kfree(priv
->output_limit
);
712 priv
->output_limit
= NULL
;
715 if (priv
->curve_data
) {
716 kfree(priv
->curve_data
);
717 priv
->curve_data
= NULL
;
720 printk(KERN_ERR
"%s: eeprom parse failed!\n",
721 wiphy_name(dev
->wiphy
));
724 EXPORT_SYMBOL_GPL(p54_parse_eeprom
);
726 static int p54_rssi_to_dbm(struct ieee80211_hw
*dev
, int rssi
)
728 struct p54_common
*priv
= dev
->priv
;
729 int band
= dev
->conf
.channel
->band
;
731 if (priv
->rxhw
!= PDR_SYNTH_FRONTEND_LONGBOW
)
732 return ((rssi
* priv
->rssical_db
[band
].mul
) / 64 +
733 priv
->rssical_db
[band
].add
) / 4;
736 * TODO: find the correct formula
738 return ((rssi
* priv
->rssical_db
[band
].mul
) / 64 +
739 priv
->rssical_db
[band
].add
) / 4;
742 static int p54_rx_data(struct ieee80211_hw
*dev
, struct sk_buff
*skb
)
744 struct p54_common
*priv
= dev
->priv
;
745 struct p54_rx_data
*hdr
= (struct p54_rx_data
*) skb
->data
;
746 struct ieee80211_rx_status rx_status
= {0};
747 u16 freq
= le16_to_cpu(hdr
->freq
);
748 size_t header_len
= sizeof(*hdr
);
750 u8 rate
= hdr
->rate
& 0xf;
753 * If the device is in a unspecified state we have to
754 * ignore all data frames. Else we could end up with a
757 if (unlikely(priv
->mode
== NL80211_IFTYPE_UNSPECIFIED
))
760 if (!(hdr
->flags
& cpu_to_le16(P54_HDR_FLAG_DATA_IN_FCS_GOOD
))) {
764 if (hdr
->decrypt_status
== P54_DECRYPT_OK
)
765 rx_status
.flag
|= RX_FLAG_DECRYPTED
;
766 if ((hdr
->decrypt_status
== P54_DECRYPT_FAIL_MICHAEL
) ||
767 (hdr
->decrypt_status
== P54_DECRYPT_FAIL_TKIP
))
768 rx_status
.flag
|= RX_FLAG_MMIC_ERROR
;
770 rx_status
.signal
= p54_rssi_to_dbm(dev
, hdr
->rssi
);
771 rx_status
.noise
= priv
->noise
;
772 if (hdr
->rate
& 0x10)
773 rx_status
.flag
|= RX_FLAG_SHORTPRE
;
774 if (dev
->conf
.channel
->band
== IEEE80211_BAND_5GHZ
)
775 rx_status
.rate_idx
= (rate
< 4) ? 0 : rate
- 4;
777 rx_status
.rate_idx
= rate
;
779 rx_status
.freq
= freq
;
780 rx_status
.band
= dev
->conf
.channel
->band
;
781 rx_status
.antenna
= hdr
->antenna
;
783 tsf32
= le32_to_cpu(hdr
->tsf32
);
784 if (tsf32
< priv
->tsf_low32
)
786 rx_status
.mactime
= ((u64
)priv
->tsf_high32
) << 32 | tsf32
;
787 priv
->tsf_low32
= tsf32
;
789 rx_status
.flag
|= RX_FLAG_TSFT
;
791 if (hdr
->flags
& cpu_to_le16(P54_HDR_FLAG_DATA_ALIGN
))
792 header_len
+= hdr
->align
[0];
794 skb_pull(skb
, header_len
);
795 skb_trim(skb
, le16_to_cpu(hdr
->len
));
797 ieee80211_rx_irqsafe(dev
, skb
, &rx_status
);
799 queue_delayed_work(dev
->workqueue
, &priv
->work
,
800 msecs_to_jiffies(P54_STATISTICS_UPDATE
));
805 static void inline p54_wake_free_queues(struct ieee80211_hw
*dev
)
807 struct p54_common
*priv
= dev
->priv
;
810 if (priv
->mode
== NL80211_IFTYPE_UNSPECIFIED
)
813 for (i
= 0; i
< dev
->queues
; i
++)
814 if (priv
->tx_stats
[i
+ P54_QUEUE_DATA
].len
<
815 priv
->tx_stats
[i
+ P54_QUEUE_DATA
].limit
)
816 ieee80211_wake_queue(dev
, i
);
819 void p54_free_skb(struct ieee80211_hw
*dev
, struct sk_buff
*skb
)
821 struct p54_common
*priv
= dev
->priv
;
822 struct ieee80211_tx_info
*info
;
823 struct p54_tx_info
*range
;
825 u32 freed
= 0, last_addr
= priv
->rx_start
;
827 if (unlikely(!skb
|| !dev
|| !skb_queue_len(&priv
->tx_queue
)))
831 * don't try to free an already unlinked skb
833 if (unlikely((!skb
->next
) || (!skb
->prev
)))
836 spin_lock_irqsave(&priv
->tx_queue
.lock
, flags
);
837 info
= IEEE80211_SKB_CB(skb
);
838 range
= (void *)info
->rate_driver_data
;
839 if (skb
->prev
!= (struct sk_buff
*)&priv
->tx_queue
) {
840 struct ieee80211_tx_info
*ni
;
841 struct p54_tx_info
*mr
;
843 ni
= IEEE80211_SKB_CB(skb
->prev
);
844 mr
= (struct p54_tx_info
*)ni
->rate_driver_data
;
845 last_addr
= mr
->end_addr
;
847 if (skb
->next
!= (struct sk_buff
*)&priv
->tx_queue
) {
848 struct ieee80211_tx_info
*ni
;
849 struct p54_tx_info
*mr
;
851 ni
= IEEE80211_SKB_CB(skb
->next
);
852 mr
= (struct p54_tx_info
*)ni
->rate_driver_data
;
853 freed
= mr
->start_addr
- last_addr
;
855 freed
= priv
->rx_end
- last_addr
;
856 __skb_unlink(skb
, &priv
->tx_queue
);
857 spin_unlock_irqrestore(&priv
->tx_queue
.lock
, flags
);
858 dev_kfree_skb_any(skb
);
860 if (freed
>= priv
->headroom
+ sizeof(struct p54_hdr
) + 48 +
861 IEEE80211_MAX_RTS_THRESHOLD
+ priv
->tailroom
)
862 p54_wake_free_queues(dev
);
864 EXPORT_SYMBOL_GPL(p54_free_skb
);
866 static struct sk_buff
*p54_find_tx_entry(struct ieee80211_hw
*dev
,
869 struct p54_common
*priv
= dev
->priv
;
870 struct sk_buff
*entry
;
873 spin_lock_irqsave(&priv
->tx_queue
.lock
, flags
);
874 entry
= priv
->tx_queue
.next
;
875 while (entry
!= (struct sk_buff
*)&priv
->tx_queue
) {
876 struct p54_hdr
*hdr
= (struct p54_hdr
*) entry
->data
;
878 if (hdr
->req_id
== req_id
) {
879 spin_unlock_irqrestore(&priv
->tx_queue
.lock
, flags
);
884 spin_unlock_irqrestore(&priv
->tx_queue
.lock
, flags
);
888 static void p54_rx_frame_sent(struct ieee80211_hw
*dev
, struct sk_buff
*skb
)
890 struct p54_common
*priv
= dev
->priv
;
891 struct p54_hdr
*hdr
= (struct p54_hdr
*) skb
->data
;
892 struct p54_frame_sent
*payload
= (struct p54_frame_sent
*) hdr
->data
;
893 struct sk_buff
*entry
;
894 u32 addr
= le32_to_cpu(hdr
->req_id
) - priv
->headroom
;
895 struct p54_tx_info
*range
= NULL
;
897 u32 last_addr
= priv
->rx_start
;
901 spin_lock_irqsave(&priv
->tx_queue
.lock
, flags
);
902 entry
= (struct sk_buff
*) priv
->tx_queue
.next
;
903 while (entry
!= (struct sk_buff
*)&priv
->tx_queue
) {
904 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(entry
);
905 struct p54_hdr
*entry_hdr
;
906 struct p54_tx_data
*entry_data
;
907 unsigned int pad
= 0, frame_len
;
909 range
= (void *)info
->rate_driver_data
;
910 if (range
->start_addr
!= addr
) {
911 last_addr
= range
->end_addr
;
916 if (entry
->next
!= (struct sk_buff
*)&priv
->tx_queue
) {
917 struct ieee80211_tx_info
*ni
;
918 struct p54_tx_info
*mr
;
920 ni
= IEEE80211_SKB_CB(entry
->next
);
921 mr
= (struct p54_tx_info
*)ni
->rate_driver_data
;
922 freed
= mr
->start_addr
- last_addr
;
924 freed
= priv
->rx_end
- last_addr
;
926 last_addr
= range
->end_addr
;
927 __skb_unlink(entry
, &priv
->tx_queue
);
928 spin_unlock_irqrestore(&priv
->tx_queue
.lock
, flags
);
930 frame_len
= entry
->len
;
931 entry_hdr
= (struct p54_hdr
*) entry
->data
;
932 entry_data
= (struct p54_tx_data
*) entry_hdr
->data
;
933 priv
->tx_stats
[entry_data
->hw_queue
].len
--;
934 priv
->stats
.dot11ACKFailureCount
+= payload
->tries
- 1;
937 * Frames in P54_QUEUE_FWSCAN and P54_QUEUE_BEACON are
938 * generated by the driver. Therefore tx_status is bogus
939 * and we don't want to confuse the mac80211 stack.
941 if (unlikely(entry_data
->hw_queue
< P54_QUEUE_FWSCAN
)) {
942 if (entry_data
->hw_queue
== P54_QUEUE_BEACON
)
943 priv
->cached_beacon
= NULL
;
950 * Clear manually, ieee80211_tx_info_clear_status would
951 * clear the counts too and we need them.
953 memset(&info
->status
.ampdu_ack_len
, 0,
954 sizeof(struct ieee80211_tx_info
) -
955 offsetof(struct ieee80211_tx_info
, status
.ampdu_ack_len
));
956 BUILD_BUG_ON(offsetof(struct ieee80211_tx_info
,
957 status
.ampdu_ack_len
) != 23);
959 if (entry_hdr
->flags
& cpu_to_le16(P54_HDR_FLAG_DATA_ALIGN
))
960 pad
= entry_data
->align
[0];
962 /* walk through the rates array and adjust the counts */
963 count
= payload
->tries
;
964 for (idx
= 0; idx
< 4; idx
++) {
965 if (count
>= info
->status
.rates
[idx
].count
) {
966 count
-= info
->status
.rates
[idx
].count
;
967 } else if (count
> 0) {
968 info
->status
.rates
[idx
].count
= count
;
971 info
->status
.rates
[idx
].idx
= -1;
972 info
->status
.rates
[idx
].count
= 0;
976 if (!(info
->flags
& IEEE80211_TX_CTL_NO_ACK
) &&
978 info
->flags
|= IEEE80211_TX_STAT_ACK
;
979 if (payload
->status
& P54_TX_PSM_CANCELLED
)
980 info
->flags
|= IEEE80211_TX_STAT_TX_FILTERED
;
981 info
->status
.ack_signal
= p54_rssi_to_dbm(dev
,
982 (int)payload
->ack_rssi
);
984 /* Undo all changes to the frame. */
985 switch (entry_data
->key_type
) {
986 case P54_CRYPTO_TKIPMICHAEL
: {
987 u8
*iv
= (u8
*)(entry_data
->align
+ pad
+
988 entry_data
->crypt_offset
);
990 /* Restore the original TKIP IV. */
993 iv
[1] = (iv
[0] | 0x20) & 0x7f; /* WEPSeed - 8.3.2.2 */
995 frame_len
-= 12; /* remove TKIP_MMIC + TKIP_ICV */
998 case P54_CRYPTO_AESCCMP
:
999 frame_len
-= 8; /* remove CCMP_MIC */
1001 case P54_CRYPTO_WEP
:
1002 frame_len
-= 4; /* remove WEP_ICV */
1005 skb_trim(entry
, frame_len
);
1006 skb_pull(entry
, sizeof(*hdr
) + pad
+ sizeof(*entry_data
));
1007 ieee80211_tx_status_irqsafe(dev
, entry
);
1010 spin_unlock_irqrestore(&priv
->tx_queue
.lock
, flags
);
1013 if (freed
>= priv
->headroom
+ sizeof(struct p54_hdr
) + 48 +
1014 IEEE80211_MAX_RTS_THRESHOLD
+ priv
->tailroom
)
1015 p54_wake_free_queues(dev
);
1018 static void p54_rx_eeprom_readback(struct ieee80211_hw
*dev
,
1019 struct sk_buff
*skb
)
1021 struct p54_hdr
*hdr
= (struct p54_hdr
*) skb
->data
;
1022 struct p54_eeprom_lm86
*eeprom
= (struct p54_eeprom_lm86
*) hdr
->data
;
1023 struct p54_common
*priv
= dev
->priv
;
1028 if (priv
->fw_var
>= 0x509) {
1029 memcpy(priv
->eeprom
, eeprom
->v2
.data
,
1030 le16_to_cpu(eeprom
->v2
.len
));
1032 memcpy(priv
->eeprom
, eeprom
->v1
.data
,
1033 le16_to_cpu(eeprom
->v1
.len
));
1036 complete(&priv
->eeprom_comp
);
1039 static void p54_rx_stats(struct ieee80211_hw
*dev
, struct sk_buff
*skb
)
1041 struct p54_common
*priv
= dev
->priv
;
1042 struct p54_hdr
*hdr
= (struct p54_hdr
*) skb
->data
;
1043 struct p54_statistics
*stats
= (struct p54_statistics
*) hdr
->data
;
1046 if (unlikely(priv
->mode
== NL80211_IFTYPE_UNSPECIFIED
))
1049 tsf32
= le32_to_cpu(stats
->tsf32
);
1050 if (tsf32
< priv
->tsf_low32
)
1052 priv
->tsf_low32
= tsf32
;
1054 priv
->stats
.dot11RTSFailureCount
= le32_to_cpu(stats
->rts_fail
);
1055 priv
->stats
.dot11RTSSuccessCount
= le32_to_cpu(stats
->rts_success
);
1056 priv
->stats
.dot11FCSErrorCount
= le32_to_cpu(stats
->rx_bad_fcs
);
1058 priv
->noise
= p54_rssi_to_dbm(dev
, le32_to_cpu(stats
->noise
));
1060 p54_free_skb(dev
, p54_find_tx_entry(dev
, hdr
->req_id
));
1063 static void p54_rx_trap(struct ieee80211_hw
*dev
, struct sk_buff
*skb
)
1065 struct p54_common
*priv
= dev
->priv
;
1066 struct p54_hdr
*hdr
= (struct p54_hdr
*) skb
->data
;
1067 struct p54_trap
*trap
= (struct p54_trap
*) hdr
->data
;
1068 u16 event
= le16_to_cpu(trap
->event
);
1069 u16 freq
= le16_to_cpu(trap
->frequency
);
1072 case P54_TRAP_BEACON_TX
:
1074 case P54_TRAP_RADAR
:
1075 printk(KERN_INFO
"%s: radar (freq:%d MHz)\n",
1076 wiphy_name(dev
->wiphy
), freq
);
1078 case P54_TRAP_NO_BEACON
:
1080 ieee80211_beacon_loss(priv
->vif
);
1086 case P54_TRAP_TIMER
:
1089 printk(KERN_INFO
"%s: received event:%x freq:%d\n",
1090 wiphy_name(dev
->wiphy
), event
, freq
);
1095 static int p54_rx_control(struct ieee80211_hw
*dev
, struct sk_buff
*skb
)
1097 struct p54_hdr
*hdr
= (struct p54_hdr
*) skb
->data
;
1099 switch (le16_to_cpu(hdr
->type
)) {
1100 case P54_CONTROL_TYPE_TXDONE
:
1101 p54_rx_frame_sent(dev
, skb
);
1103 case P54_CONTROL_TYPE_TRAP
:
1104 p54_rx_trap(dev
, skb
);
1106 case P54_CONTROL_TYPE_BBP
:
1108 case P54_CONTROL_TYPE_STAT_READBACK
:
1109 p54_rx_stats(dev
, skb
);
1111 case P54_CONTROL_TYPE_EEPROM_READBACK
:
1112 p54_rx_eeprom_readback(dev
, skb
);
1115 printk(KERN_DEBUG
"%s: not handling 0x%02x type control frame\n",
1116 wiphy_name(dev
->wiphy
), le16_to_cpu(hdr
->type
));
1123 /* returns zero if skb can be reused */
1124 int p54_rx(struct ieee80211_hw
*dev
, struct sk_buff
*skb
)
1126 u16 type
= le16_to_cpu(*((__le16
*)skb
->data
));
1128 if (type
& P54_HDR_FLAG_CONTROL
)
1129 return p54_rx_control(dev
, skb
);
1131 return p54_rx_data(dev
, skb
);
1133 EXPORT_SYMBOL_GPL(p54_rx
);
1136 * So, the firmware is somewhat stupid and doesn't know what places in its
1137 * memory incoming data should go to. By poking around in the firmware, we
1138 * can find some unused memory to upload our packets to. However, data that we
1139 * want the card to TX needs to stay intact until the card has told us that
1140 * it is done with it. This function finds empty places we can upload to and
1141 * marks allocated areas as reserved if necessary. p54_rx_frame_sent or
1142 * p54_free_skb frees allocated areas.
1144 static int p54_assign_address(struct ieee80211_hw
*dev
, struct sk_buff
*skb
,
1145 struct p54_hdr
*data
, u32 len
)
1147 struct p54_common
*priv
= dev
->priv
;
1148 struct sk_buff
*entry
;
1149 struct sk_buff
*target_skb
= NULL
;
1150 struct ieee80211_tx_info
*info
;
1151 struct p54_tx_info
*range
;
1152 u32 last_addr
= priv
->rx_start
;
1153 u32 largest_hole
= 0;
1154 u32 target_addr
= priv
->rx_start
;
1155 unsigned long flags
;
1157 len
= (len
+ priv
->headroom
+ priv
->tailroom
+ 3) & ~0x3;
1162 spin_lock_irqsave(&priv
->tx_queue
.lock
, flags
);
1164 left
= skb_queue_len(&priv
->tx_queue
);
1165 if (unlikely(left
>= 28)) {
1167 * The tx_queue is nearly full!
1168 * We have throttle normal data traffic, because we must
1169 * have a few spare slots for control frames left.
1171 ieee80211_stop_queues(dev
);
1172 queue_delayed_work(dev
->workqueue
, &priv
->work
,
1173 msecs_to_jiffies(P54_TX_TIMEOUT
));
1175 if (unlikely(left
== 32)) {
1177 * The tx_queue is now really full.
1179 * TODO: check if the device has crashed and reset it.
1181 spin_unlock_irqrestore(&priv
->tx_queue
.lock
, flags
);
1186 entry
= priv
->tx_queue
.next
;
1189 info
= IEEE80211_SKB_CB(entry
);
1190 range
= (void *)info
->rate_driver_data
;
1191 hole_size
= range
->start_addr
- last_addr
;
1192 if (!target_skb
&& hole_size
>= len
) {
1193 target_skb
= entry
->prev
;
1195 target_addr
= last_addr
;
1197 largest_hole
= max(largest_hole
, hole_size
);
1198 last_addr
= range
->end_addr
;
1199 entry
= entry
->next
;
1201 if (!target_skb
&& priv
->rx_end
- last_addr
>= len
) {
1202 target_skb
= priv
->tx_queue
.prev
;
1203 largest_hole
= max(largest_hole
, priv
->rx_end
- last_addr
- len
);
1204 if (!skb_queue_empty(&priv
->tx_queue
)) {
1205 info
= IEEE80211_SKB_CB(target_skb
);
1206 range
= (void *)info
->rate_driver_data
;
1207 target_addr
= range
->end_addr
;
1210 largest_hole
= max(largest_hole
, priv
->rx_end
- last_addr
);
1213 spin_unlock_irqrestore(&priv
->tx_queue
.lock
, flags
);
1214 ieee80211_stop_queues(dev
);
1218 info
= IEEE80211_SKB_CB(skb
);
1219 range
= (void *)info
->rate_driver_data
;
1220 range
->start_addr
= target_addr
;
1221 range
->end_addr
= target_addr
+ len
;
1222 __skb_queue_after(&priv
->tx_queue
, target_skb
, skb
);
1223 spin_unlock_irqrestore(&priv
->tx_queue
.lock
, flags
);
1225 if (largest_hole
< priv
->headroom
+ sizeof(struct p54_hdr
) +
1226 48 + IEEE80211_MAX_RTS_THRESHOLD
+ priv
->tailroom
)
1227 ieee80211_stop_queues(dev
);
1229 data
->req_id
= cpu_to_le32(target_addr
+ priv
->headroom
);
1233 static struct sk_buff
*p54_alloc_skb(struct ieee80211_hw
*dev
, u16 hdr_flags
,
1234 u16 payload_len
, u16 type
, gfp_t memflags
)
1236 struct p54_common
*priv
= dev
->priv
;
1237 struct p54_hdr
*hdr
;
1238 struct sk_buff
*skb
;
1239 size_t frame_len
= sizeof(*hdr
) + payload_len
;
1241 if (frame_len
> P54_MAX_CTRL_FRAME_LEN
)
1244 skb
= __dev_alloc_skb(priv
->tx_hdr_len
+ frame_len
, memflags
);
1247 skb_reserve(skb
, priv
->tx_hdr_len
);
1249 hdr
= (struct p54_hdr
*) skb_put(skb
, sizeof(*hdr
));
1250 hdr
->flags
= cpu_to_le16(hdr_flags
);
1251 hdr
->len
= cpu_to_le16(payload_len
);
1252 hdr
->type
= cpu_to_le16(type
);
1253 hdr
->tries
= hdr
->rts_tries
= 0;
1255 if (p54_assign_address(dev
, skb
, hdr
, frame_len
)) {
1262 int p54_read_eeprom(struct ieee80211_hw
*dev
)
1264 struct p54_common
*priv
= dev
->priv
;
1265 struct p54_eeprom_lm86
*eeprom_hdr
;
1266 struct sk_buff
*skb
;
1267 size_t eeprom_size
= 0x2020, offset
= 0, blocksize
, maxblocksize
;
1269 void *eeprom
= NULL
;
1271 maxblocksize
= EEPROM_READBACK_LEN
;
1272 if (priv
->fw_var
>= 0x509)
1273 maxblocksize
-= 0xc;
1275 maxblocksize
-= 0x4;
1277 skb
= p54_alloc_skb(dev
, P54_HDR_FLAG_CONTROL
, sizeof(*eeprom_hdr
) +
1278 maxblocksize
, P54_CONTROL_TYPE_EEPROM_READBACK
,
1282 priv
->eeprom
= kzalloc(EEPROM_READBACK_LEN
, GFP_KERNEL
);
1285 eeprom
= kzalloc(eeprom_size
, GFP_KERNEL
);
1289 eeprom_hdr
= (struct p54_eeprom_lm86
*) skb_put(skb
,
1290 sizeof(*eeprom_hdr
) + maxblocksize
);
1292 while (eeprom_size
) {
1293 blocksize
= min(eeprom_size
, maxblocksize
);
1294 if (priv
->fw_var
< 0x509) {
1295 eeprom_hdr
->v1
.offset
= cpu_to_le16(offset
);
1296 eeprom_hdr
->v1
.len
= cpu_to_le16(blocksize
);
1298 eeprom_hdr
->v2
.offset
= cpu_to_le32(offset
);
1299 eeprom_hdr
->v2
.len
= cpu_to_le16(blocksize
);
1300 eeprom_hdr
->v2
.magic2
= 0xf;
1301 memcpy(eeprom_hdr
->v2
.magic
, (const char *)"LOCK", 4);
1305 if (!wait_for_completion_interruptible_timeout(&priv
->eeprom_comp
, HZ
)) {
1306 printk(KERN_ERR
"%s: device does not respond!\n",
1307 wiphy_name(dev
->wiphy
));
1312 memcpy(eeprom
+ offset
, priv
->eeprom
, blocksize
);
1313 offset
+= blocksize
;
1314 eeprom_size
-= blocksize
;
1317 ret
= p54_parse_eeprom(dev
, eeprom
, offset
);
1319 kfree(priv
->eeprom
);
1320 priv
->eeprom
= NULL
;
1321 p54_free_skb(dev
, skb
);
1326 EXPORT_SYMBOL_GPL(p54_read_eeprom
);
1328 static int p54_set_tim(struct ieee80211_hw
*dev
, struct ieee80211_sta
*sta
,
1331 struct p54_common
*priv
= dev
->priv
;
1332 struct sk_buff
*skb
;
1333 struct p54_tim
*tim
;
1335 skb
= p54_alloc_skb(dev
, P54_HDR_FLAG_CONTROL_OPSET
, sizeof(*tim
),
1336 P54_CONTROL_TYPE_TIM
, GFP_ATOMIC
);
1340 tim
= (struct p54_tim
*) skb_put(skb
, sizeof(*tim
));
1342 tim
->entry
[0] = cpu_to_le16(set
? (sta
->aid
| 0x8000) : sta
->aid
);
1347 static int p54_sta_unlock(struct ieee80211_hw
*dev
, u8
*addr
)
1349 struct p54_common
*priv
= dev
->priv
;
1350 struct sk_buff
*skb
;
1351 struct p54_sta_unlock
*sta
;
1353 skb
= p54_alloc_skb(dev
, P54_HDR_FLAG_CONTROL_OPSET
, sizeof(*sta
),
1354 P54_CONTROL_TYPE_PSM_STA_UNLOCK
, GFP_ATOMIC
);
1358 sta
= (struct p54_sta_unlock
*)skb_put(skb
, sizeof(*sta
));
1359 memcpy(sta
->addr
, addr
, ETH_ALEN
);
1364 static void p54_sta_notify(struct ieee80211_hw
*dev
, struct ieee80211_vif
*vif
,
1365 enum sta_notify_cmd notify_cmd
,
1366 struct ieee80211_sta
*sta
)
1368 switch (notify_cmd
) {
1369 case STA_NOTIFY_ADD
:
1370 case STA_NOTIFY_REMOVE
:
1372 * Notify the firmware that we don't want or we don't
1373 * need to buffer frames for this station anymore.
1376 p54_sta_unlock(dev
, sta
->addr
);
1378 case STA_NOTIFY_AWAKE
:
1379 /* update the firmware's filter table */
1380 p54_sta_unlock(dev
, sta
->addr
);
1387 static int p54_tx_cancel(struct ieee80211_hw
*dev
, struct sk_buff
*entry
)
1389 struct p54_common
*priv
= dev
->priv
;
1390 struct sk_buff
*skb
;
1391 struct p54_hdr
*hdr
;
1392 struct p54_txcancel
*cancel
;
1394 skb
= p54_alloc_skb(dev
, P54_HDR_FLAG_CONTROL_OPSET
, sizeof(*cancel
),
1395 P54_CONTROL_TYPE_TXCANCEL
, GFP_ATOMIC
);
1399 hdr
= (void *)entry
->data
;
1400 cancel
= (struct p54_txcancel
*)skb_put(skb
, sizeof(*cancel
));
1401 cancel
->req_id
= hdr
->req_id
;
1406 static int p54_tx_fill(struct ieee80211_hw
*dev
, struct sk_buff
*skb
,
1407 struct ieee80211_tx_info
*info
, u8
*queue
, size_t *extra_len
,
1408 u16
*flags
, u16
*aid
)
1410 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
1411 struct p54_common
*priv
= dev
->priv
;
1414 switch (priv
->mode
) {
1415 case NL80211_IFTYPE_MONITOR
:
1417 * We have to set P54_HDR_FLAG_DATA_OUT_PROMISC for
1418 * every frame in promiscuous/monitor mode.
1419 * see STSW45x0C LMAC API - page 12.
1422 *flags
= P54_HDR_FLAG_DATA_OUT_PROMISC
;
1423 *queue
+= P54_QUEUE_DATA
;
1425 case NL80211_IFTYPE_STATION
:
1427 if (unlikely(ieee80211_is_mgmt(hdr
->frame_control
))) {
1428 *queue
= P54_QUEUE_MGMT
;
1431 *queue
+= P54_QUEUE_DATA
;
1433 case NL80211_IFTYPE_AP
:
1434 case NL80211_IFTYPE_ADHOC
:
1435 case NL80211_IFTYPE_MESH_POINT
:
1436 if (info
->flags
& IEEE80211_TX_CTL_SEND_AFTER_DTIM
) {
1438 *queue
= P54_QUEUE_CAB
;
1442 if (unlikely(ieee80211_is_mgmt(hdr
->frame_control
))) {
1443 if (ieee80211_is_probe_resp(hdr
->frame_control
)) {
1445 *queue
= P54_QUEUE_MGMT
;
1446 *flags
= P54_HDR_FLAG_DATA_OUT_TIMESTAMP
|
1447 P54_HDR_FLAG_DATA_OUT_NOCANCEL
;
1449 } else if (ieee80211_is_beacon(hdr
->frame_control
)) {
1452 if (info
->flags
& IEEE80211_TX_CTL_INJECTED
) {
1454 * Injecting beacons on top of a AP is
1455 * not a good idea... nevertheless,
1456 * it should be doable.
1459 *queue
+= P54_QUEUE_DATA
;
1463 *flags
= P54_HDR_FLAG_DATA_OUT_TIMESTAMP
;
1464 *queue
= P54_QUEUE_BEACON
;
1465 *extra_len
= IEEE80211_MAX_TIM_LEN
;
1468 *queue
= P54_QUEUE_MGMT
;
1472 *queue
+= P54_QUEUE_DATA
;
1474 if (info
->control
.sta
)
1475 *aid
= info
->control
.sta
->aid
;
1477 if (info
->flags
& IEEE80211_TX_CTL_CLEAR_PS_FILT
)
1478 *flags
|= P54_HDR_FLAG_DATA_OUT_NOCANCEL
;
1484 static u8
p54_convert_algo(enum ieee80211_key_alg alg
)
1488 return P54_CRYPTO_WEP
;
1490 return P54_CRYPTO_TKIPMICHAEL
;
1492 return P54_CRYPTO_AESCCMP
;
1498 static int p54_tx(struct ieee80211_hw
*dev
, struct sk_buff
*skb
)
1500 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
1501 struct ieee80211_tx_queue_stats
*current_queue
;
1502 struct p54_common
*priv
= dev
->priv
;
1503 struct p54_hdr
*hdr
;
1504 struct p54_tx_data
*txhdr
;
1505 size_t padding
, len
, tim_len
= 0;
1506 int i
, j
, ridx
, ret
;
1507 u16 hdr_flags
= 0, aid
= 0;
1508 u8 rate
, queue
, crypt_offset
= 0;
1511 u8 calculated_tries
[4];
1512 u8 nrates
= 0, nremaining
= 8;
1514 queue
= skb_get_queue_mapping(skb
);
1516 ret
= p54_tx_fill(dev
, skb
, info
, &queue
, &tim_len
, &hdr_flags
, &aid
);
1517 current_queue
= &priv
->tx_stats
[queue
];
1518 if (unlikely((current_queue
->len
> current_queue
->limit
) && ret
))
1519 return NETDEV_TX_BUSY
;
1520 current_queue
->len
++;
1521 current_queue
->count
++;
1522 if ((current_queue
->len
== current_queue
->limit
) && ret
)
1523 ieee80211_stop_queue(dev
, skb_get_queue_mapping(skb
));
1525 padding
= (unsigned long)(skb
->data
- (sizeof(*hdr
) + sizeof(*txhdr
))) & 3;
1528 if (info
->control
.hw_key
) {
1529 crypt_offset
= ieee80211_get_hdrlen_from_skb(skb
);
1530 if (info
->control
.hw_key
->alg
== ALG_TKIP
) {
1531 u8
*iv
= (u8
*)(skb
->data
+ crypt_offset
);
1533 * The firmware excepts that the IV has to have
1534 * this special format
1542 txhdr
= (struct p54_tx_data
*) skb_push(skb
, sizeof(*txhdr
) + padding
);
1543 hdr
= (struct p54_hdr
*) skb_push(skb
, sizeof(*hdr
));
1546 hdr_flags
|= P54_HDR_FLAG_DATA_ALIGN
;
1547 hdr
->type
= cpu_to_le16(aid
);
1548 hdr
->rts_tries
= info
->control
.rates
[0].count
;
1551 * we register the rates in perfect order, and
1552 * RTS/CTS won't happen on 5 GHz
1554 cts_rate
= info
->control
.rts_cts_rate_idx
;
1556 memset(&txhdr
->rateset
, 0, sizeof(txhdr
->rateset
));
1558 /* see how many rates got used */
1559 for (i
= 0; i
< 4; i
++) {
1560 if (info
->control
.rates
[i
].idx
< 0)
1565 /* limit tries to 8/nrates per rate */
1566 for (i
= 0; i
< nrates
; i
++) {
1568 * The magic expression here is equivalent to 8/nrates for
1569 * all values that matter, but avoids division and jumps.
1570 * Note that nrates can only take the values 1 through 4.
1572 calculated_tries
[i
] = min_t(int, ((15 >> nrates
) | 1) + 1,
1573 info
->control
.rates
[i
].count
);
1574 nremaining
-= calculated_tries
[i
];
1577 /* if there are tries left, distribute from back to front */
1578 for (i
= nrates
- 1; nremaining
> 0 && i
>= 0; i
--) {
1579 int tmp
= info
->control
.rates
[i
].count
- calculated_tries
[i
];
1583 /* RC requested more tries at this rate */
1585 tmp
= min_t(int, tmp
, nremaining
);
1586 calculated_tries
[i
] += tmp
;
1591 for (i
= 0; i
< nrates
&& ridx
< 8; i
++) {
1592 /* we register the rates in perfect order */
1593 rate
= info
->control
.rates
[i
].idx
;
1594 if (info
->band
== IEEE80211_BAND_5GHZ
)
1597 /* store the count we actually calculated for TX status */
1598 info
->control
.rates
[i
].count
= calculated_tries
[i
];
1600 rc_flags
= info
->control
.rates
[i
].flags
;
1601 if (rc_flags
& IEEE80211_TX_RC_USE_SHORT_PREAMBLE
) {
1605 if (rc_flags
& IEEE80211_TX_RC_USE_RTS_CTS
)
1607 else if (rc_flags
& IEEE80211_TX_RC_USE_CTS_PROTECT
)
1609 for (j
= 0; j
< calculated_tries
[i
] && ridx
< 8; j
++) {
1610 txhdr
->rateset
[ridx
] = rate
;
1615 if (info
->flags
& IEEE80211_TX_CTL_ASSIGN_SEQ
)
1616 hdr_flags
|= P54_HDR_FLAG_DATA_OUT_SEQNR
;
1618 /* TODO: enable bursting */
1619 hdr
->flags
= cpu_to_le16(hdr_flags
);
1621 txhdr
->rts_rate_idx
= 0;
1622 if (info
->control
.hw_key
) {
1623 txhdr
->key_type
= p54_convert_algo(info
->control
.hw_key
->alg
);
1624 txhdr
->key_len
= min((u8
)16, info
->control
.hw_key
->keylen
);
1625 memcpy(txhdr
->key
, info
->control
.hw_key
->key
, txhdr
->key_len
);
1626 if (info
->control
.hw_key
->alg
== ALG_TKIP
) {
1627 if (unlikely(skb_tailroom(skb
) < 12))
1629 /* reserve space for the MIC key */
1631 memcpy(skb_put(skb
, 8), &(info
->control
.hw_key
->key
1632 [NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY
]), 8);
1634 /* reserve some space for ICV */
1635 len
+= info
->control
.hw_key
->icv_len
;
1636 memset(skb_put(skb
, info
->control
.hw_key
->icv_len
), 0,
1637 info
->control
.hw_key
->icv_len
);
1639 txhdr
->key_type
= 0;
1642 txhdr
->crypt_offset
= crypt_offset
;
1643 txhdr
->hw_queue
= queue
;
1644 txhdr
->backlog
= current_queue
->len
;
1645 memset(txhdr
->durations
, 0, sizeof(txhdr
->durations
));
1646 txhdr
->tx_antenna
= ((info
->antenna_sel_tx
== 0) ?
1647 2 : info
->antenna_sel_tx
- 1) & priv
->tx_diversity_mask
;
1648 if (priv
->rxhw
== PDR_SYNTH_FRONTEND_LONGBOW
) {
1649 txhdr
->longbow
.cts_rate
= cts_rate
;
1650 txhdr
->longbow
.output_power
= cpu_to_le16(priv
->output_power
);
1652 txhdr
->normal
.output_power
= priv
->output_power
;
1653 txhdr
->normal
.cts_rate
= cts_rate
;
1656 txhdr
->align
[0] = padding
;
1658 hdr
->len
= cpu_to_le16(len
);
1659 /* modifies skb->cb and with it info, so must be last! */
1660 if (unlikely(p54_assign_address(dev
, skb
, hdr
, skb
->len
+ tim_len
)))
1664 queue_delayed_work(dev
->workqueue
, &priv
->work
,
1665 msecs_to_jiffies(P54_TX_FRAME_LIFETIME
));
1667 return NETDEV_TX_OK
;
1670 skb_pull(skb
, sizeof(*hdr
) + sizeof(*txhdr
) + padding
);
1671 current_queue
->len
--;
1672 current_queue
->count
--;
1673 return NETDEV_TX_BUSY
;
1676 static int p54_setup_mac(struct ieee80211_hw
*dev
)
1678 struct p54_common
*priv
= dev
->priv
;
1679 struct sk_buff
*skb
;
1680 struct p54_setup_mac
*setup
;
1683 skb
= p54_alloc_skb(dev
, P54_HDR_FLAG_CONTROL_OPSET
, sizeof(*setup
),
1684 P54_CONTROL_TYPE_SETUP
, GFP_ATOMIC
);
1688 setup
= (struct p54_setup_mac
*) skb_put(skb
, sizeof(*setup
));
1689 if (dev
->conf
.radio_enabled
) {
1690 switch (priv
->mode
) {
1691 case NL80211_IFTYPE_STATION
:
1692 mode
= P54_FILTER_TYPE_STATION
;
1694 case NL80211_IFTYPE_AP
:
1695 mode
= P54_FILTER_TYPE_AP
;
1697 case NL80211_IFTYPE_ADHOC
:
1698 case NL80211_IFTYPE_MESH_POINT
:
1699 mode
= P54_FILTER_TYPE_IBSS
;
1701 case NL80211_IFTYPE_MONITOR
:
1702 mode
= P54_FILTER_TYPE_PROMISCUOUS
;
1705 mode
= P54_FILTER_TYPE_HIBERNATE
;
1710 * "TRANSPARENT and PROMISCUOUS are mutually exclusive"
1711 * STSW45X0C LMAC API - page 12
1713 if (((priv
->filter_flags
& FIF_PROMISC_IN_BSS
) ||
1714 (priv
->filter_flags
& FIF_OTHER_BSS
)) &&
1715 (mode
!= P54_FILTER_TYPE_PROMISCUOUS
))
1716 mode
|= P54_FILTER_TYPE_TRANSPARENT
;
1718 mode
= P54_FILTER_TYPE_HIBERNATE
;
1720 setup
->mac_mode
= cpu_to_le16(mode
);
1721 memcpy(setup
->mac_addr
, priv
->mac_addr
, ETH_ALEN
);
1722 memcpy(setup
->bssid
, priv
->bssid
, ETH_ALEN
);
1723 setup
->rx_antenna
= 2 & priv
->rx_diversity_mask
; /* automatic */
1724 setup
->rx_align
= 0;
1725 if (priv
->fw_var
< 0x500) {
1726 setup
->v1
.basic_rate_mask
= cpu_to_le32(priv
->basic_rate_mask
);
1727 memset(setup
->v1
.rts_rates
, 0, 8);
1728 setup
->v1
.rx_addr
= cpu_to_le32(priv
->rx_end
);
1729 setup
->v1
.max_rx
= cpu_to_le16(priv
->rx_mtu
);
1730 setup
->v1
.rxhw
= cpu_to_le16(priv
->rxhw
);
1731 setup
->v1
.wakeup_timer
= cpu_to_le16(priv
->wakeup_timer
);
1732 setup
->v1
.unalloc0
= cpu_to_le16(0);
1734 setup
->v2
.rx_addr
= cpu_to_le32(priv
->rx_end
);
1735 setup
->v2
.max_rx
= cpu_to_le16(priv
->rx_mtu
);
1736 setup
->v2
.rxhw
= cpu_to_le16(priv
->rxhw
);
1737 setup
->v2
.timer
= cpu_to_le16(priv
->wakeup_timer
);
1738 setup
->v2
.truncate
= cpu_to_le16(48896);
1739 setup
->v2
.basic_rate_mask
= cpu_to_le32(priv
->basic_rate_mask
);
1740 setup
->v2
.sbss_offset
= 0;
1741 setup
->v2
.mcast_window
= 0;
1742 setup
->v2
.rx_rssi_threshold
= 0;
1743 setup
->v2
.rx_ed_threshold
= 0;
1744 setup
->v2
.ref_clock
= cpu_to_le32(644245094);
1745 setup
->v2
.lpf_bandwidth
= cpu_to_le16(65535);
1746 setup
->v2
.osc_start_delay
= cpu_to_le16(65535);
1752 static int p54_scan(struct ieee80211_hw
*dev
, u16 mode
, u16 dwell
)
1754 struct p54_common
*priv
= dev
->priv
;
1755 struct sk_buff
*skb
;
1756 struct p54_hdr
*hdr
;
1757 struct p54_scan_head
*head
;
1758 struct p54_iq_autocal_entry
*iq_autocal
;
1759 union p54_scan_body_union
*body
;
1760 struct p54_scan_tail_rate
*rate
;
1761 struct pda_rssi_cal_entry
*rssi
;
1764 int band
= dev
->conf
.channel
->band
;
1765 __le16 freq
= cpu_to_le16(dev
->conf
.channel
->center_freq
);
1767 skb
= p54_alloc_skb(dev
, P54_HDR_FLAG_CONTROL_OPSET
, sizeof(*head
) +
1768 2 + sizeof(*iq_autocal
) + sizeof(*body
) +
1769 sizeof(*rate
) + 2 * sizeof(*rssi
),
1770 P54_CONTROL_TYPE_SCAN
, GFP_ATOMIC
);
1774 head
= (struct p54_scan_head
*) skb_put(skb
, sizeof(*head
));
1775 memset(head
->scan_params
, 0, sizeof(head
->scan_params
));
1776 head
->mode
= cpu_to_le16(mode
);
1777 head
->dwell
= cpu_to_le16(dwell
);
1780 if (priv
->rxhw
== PDR_SYNTH_FRONTEND_LONGBOW
) {
1781 __le16
*pa_power_points
= (__le16
*) skb_put(skb
, 2);
1782 *pa_power_points
= cpu_to_le16(0x0c);
1785 iq_autocal
= (void *) skb_put(skb
, sizeof(*iq_autocal
));
1786 for (i
= 0; i
< priv
->iq_autocal_len
; i
++) {
1787 if (priv
->iq_autocal
[i
].freq
!= freq
)
1790 memcpy(iq_autocal
, &priv
->iq_autocal
[i
].params
,
1791 sizeof(struct p54_iq_autocal_entry
));
1794 if (i
== priv
->iq_autocal_len
)
1797 if (priv
->rxhw
== PDR_SYNTH_FRONTEND_LONGBOW
)
1798 body
= (void *) skb_put(skb
, sizeof(body
->longbow
));
1800 body
= (void *) skb_put(skb
, sizeof(body
->normal
));
1802 for (i
= 0; i
< priv
->output_limit
->entries
; i
++) {
1803 __le16
*entry_freq
= (void *) (priv
->output_limit
->data
+
1804 priv
->output_limit
->entry_size
* i
);
1806 if (*entry_freq
!= freq
)
1809 if (priv
->rxhw
== PDR_SYNTH_FRONTEND_LONGBOW
) {
1810 memcpy(&body
->longbow
.power_limits
,
1811 (void *) entry_freq
+ sizeof(__le16
),
1812 priv
->output_limit
->entry_size
);
1814 struct pda_channel_output_limit
*limits
=
1815 (void *) entry_freq
;
1817 body
->normal
.val_barker
= 0x38;
1818 body
->normal
.val_bpsk
= body
->normal
.dup_bpsk
=
1820 body
->normal
.val_qpsk
= body
->normal
.dup_qpsk
=
1822 body
->normal
.val_16qam
= body
->normal
.dup_16qam
=
1824 body
->normal
.val_64qam
= body
->normal
.dup_64qam
=
1829 if (i
== priv
->output_limit
->entries
)
1832 entry
= (void *)(priv
->curve_data
->data
+ priv
->curve_data
->offset
);
1833 for (i
= 0; i
< priv
->curve_data
->entries
; i
++) {
1834 if (*((__le16
*)entry
) != freq
) {
1835 entry
+= priv
->curve_data
->entry_size
;
1839 if (priv
->rxhw
== PDR_SYNTH_FRONTEND_LONGBOW
) {
1840 memcpy(&body
->longbow
.curve_data
,
1841 (void *) entry
+ sizeof(__le16
),
1842 priv
->curve_data
->entry_size
);
1844 struct p54_scan_body
*chan
= &body
->normal
;
1845 struct pda_pa_curve_data
*curve_data
=
1846 (void *) priv
->curve_data
->data
;
1848 entry
+= sizeof(__le16
);
1849 chan
->pa_points_per_curve
= 8;
1850 memset(chan
->curve_data
, 0, sizeof(*chan
->curve_data
));
1851 memcpy(chan
->curve_data
, entry
,
1852 sizeof(struct p54_pa_curve_data_sample
) *
1853 min((u8
)8, curve_data
->points_per_channel
));
1857 if (i
== priv
->curve_data
->entries
)
1860 if ((priv
->fw_var
>= 0x500) && (priv
->fw_var
< 0x509)) {
1861 rate
= (void *) skb_put(skb
, sizeof(*rate
));
1862 rate
->basic_rate_mask
= cpu_to_le32(priv
->basic_rate_mask
);
1863 for (i
= 0; i
< sizeof(rate
->rts_rates
); i
++)
1864 rate
->rts_rates
[i
] = i
;
1867 rssi
= (struct pda_rssi_cal_entry
*) skb_put(skb
, sizeof(*rssi
));
1868 rssi
->mul
= cpu_to_le16(priv
->rssical_db
[band
].mul
);
1869 rssi
->add
= cpu_to_le16(priv
->rssical_db
[band
].add
);
1870 if (priv
->rxhw
== PDR_SYNTH_FRONTEND_LONGBOW
) {
1871 /* Longbow frontend needs ever more */
1872 rssi
= (void *) skb_put(skb
, sizeof(*rssi
));
1873 rssi
->mul
= cpu_to_le16(priv
->rssical_db
[band
].longbow_unkn
);
1874 rssi
->add
= cpu_to_le16(priv
->rssical_db
[band
].longbow_unk2
);
1877 if (priv
->fw_var
>= 0x509) {
1878 rate
= (void *) skb_put(skb
, sizeof(*rate
));
1879 rate
->basic_rate_mask
= cpu_to_le32(priv
->basic_rate_mask
);
1880 for (i
= 0; i
< sizeof(rate
->rts_rates
); i
++)
1881 rate
->rts_rates
[i
] = i
;
1884 hdr
= (struct p54_hdr
*) skb
->data
;
1885 hdr
->len
= cpu_to_le16(skb
->len
- sizeof(*hdr
));
1891 printk(KERN_ERR
"%s: frequency change failed\n", wiphy_name(dev
->wiphy
));
1892 p54_free_skb(dev
, skb
);
1896 static int p54_set_leds(struct ieee80211_hw
*dev
)
1898 struct p54_common
*priv
= dev
->priv
;
1899 struct sk_buff
*skb
;
1900 struct p54_led
*led
;
1902 skb
= p54_alloc_skb(dev
, P54_HDR_FLAG_CONTROL_OPSET
, sizeof(*led
),
1903 P54_CONTROL_TYPE_LED
, GFP_ATOMIC
);
1907 led
= (struct p54_led
*) skb_put(skb
, sizeof(*led
));
1908 led
->flags
= cpu_to_le16(0x0003);
1909 led
->mask
[0] = led
->mask
[1] = cpu_to_le16(priv
->softled_state
);
1910 led
->delay
[0] = cpu_to_le16(1);
1911 led
->delay
[1] = cpu_to_le16(0);
1916 #define P54_SET_QUEUE(queue, ai_fs, cw_min, cw_max, _txop) \
1918 queue.aifs = cpu_to_le16(ai_fs); \
1919 queue.cwmin = cpu_to_le16(cw_min); \
1920 queue.cwmax = cpu_to_le16(cw_max); \
1921 queue.txop = cpu_to_le16(_txop); \
1924 static int p54_set_edcf(struct ieee80211_hw
*dev
)
1926 struct p54_common
*priv
= dev
->priv
;
1927 struct sk_buff
*skb
;
1928 struct p54_edcf
*edcf
;
1930 skb
= p54_alloc_skb(dev
, P54_HDR_FLAG_CONTROL_OPSET
, sizeof(*edcf
),
1931 P54_CONTROL_TYPE_DCFINIT
, GFP_ATOMIC
);
1935 edcf
= (struct p54_edcf
*)skb_put(skb
, sizeof(*edcf
));
1936 if (priv
->use_short_slot
) {
1939 edcf
->eofpad
= 0x00;
1941 edcf
->slottime
= 20;
1943 edcf
->eofpad
= 0x06;
1945 /* (see prism54/isl_oid.h for further details) */
1946 edcf
->frameburst
= cpu_to_le16(0);
1947 edcf
->round_trip_delay
= cpu_to_le16(0);
1949 memset(edcf
->mapping
, 0, sizeof(edcf
->mapping
));
1950 memcpy(edcf
->queue
, priv
->qos_params
, sizeof(edcf
->queue
));
1955 static int p54_set_ps(struct ieee80211_hw
*dev
)
1957 struct p54_common
*priv
= dev
->priv
;
1958 struct sk_buff
*skb
;
1959 struct p54_psm
*psm
;
1963 if (dev
->conf
.flags
& IEEE80211_CONF_PS
)
1964 mode
= P54_PSM
| P54_PSM_BEACON_TIMEOUT
| P54_PSM_DTIM
|
1965 P54_PSM_CHECKSUM
| P54_PSM_MCBC
;
1969 skb
= p54_alloc_skb(dev
, P54_HDR_FLAG_CONTROL_OPSET
, sizeof(*psm
),
1970 P54_CONTROL_TYPE_PSM
, GFP_ATOMIC
);
1974 psm
= (struct p54_psm
*)skb_put(skb
, sizeof(*psm
));
1975 psm
->mode
= cpu_to_le16(mode
);
1976 psm
->aid
= cpu_to_le16(priv
->aid
);
1977 for (i
= 0; i
< ARRAY_SIZE(psm
->intervals
); i
++) {
1978 psm
->intervals
[i
].interval
=
1979 cpu_to_le16(dev
->conf
.listen_interval
);
1980 psm
->intervals
[i
].periods
= cpu_to_le16(1);
1983 psm
->beacon_rssi_skip_max
= 200;
1984 psm
->rssi_delta_threshold
= 0;
1986 psm
->exclude
[0] = 0;
1993 static int p54_beacon_tim(struct sk_buff
*skb
)
1996 * the good excuse for this mess is ... the firmware.
1997 * The dummy TIM MUST be at the end of the beacon frame,
1998 * because it'll be overwritten!
2001 struct ieee80211_mgmt
*mgmt
= (void *)skb
->data
;
2004 if (skb
->len
<= sizeof(mgmt
))
2007 pos
= (u8
*)mgmt
->u
.beacon
.variable
;
2008 end
= skb
->data
+ skb
->len
;
2010 if (pos
+ 2 + pos
[1] > end
)
2013 if (pos
[0] == WLAN_EID_TIM
) {
2014 u8 dtim_len
= pos
[1];
2015 u8 dtim_period
= pos
[3];
2016 u8
*next
= pos
+ 2 + dtim_len
;
2021 memmove(pos
, next
, end
- next
);
2024 skb_trim(skb
, skb
->len
- (dtim_len
- 3));
2026 pos
= end
- (dtim_len
+ 2);
2028 /* add the dummy at the end */
2029 pos
[0] = WLAN_EID_TIM
;
2032 pos
[3] = dtim_period
;
2041 static int p54_beacon_update(struct ieee80211_hw
*dev
,
2042 struct ieee80211_vif
*vif
)
2044 struct p54_common
*priv
= dev
->priv
;
2045 struct sk_buff
*beacon
;
2048 if (priv
->cached_beacon
) {
2049 p54_tx_cancel(dev
, priv
->cached_beacon
);
2050 /* wait for the last beacon the be freed */
2054 beacon
= ieee80211_beacon_get(dev
, vif
);
2057 ret
= p54_beacon_tim(beacon
);
2060 ret
= p54_tx(dev
, beacon
);
2063 priv
->cached_beacon
= beacon
;
2064 priv
->tsf_high32
= 0;
2065 priv
->tsf_low32
= 0;
2070 static int p54_start(struct ieee80211_hw
*dev
)
2072 struct p54_common
*priv
= dev
->priv
;
2075 mutex_lock(&priv
->conf_mutex
);
2076 err
= priv
->open(dev
);
2079 P54_SET_QUEUE(priv
->qos_params
[0], 0x0002, 0x0003, 0x0007, 47);
2080 P54_SET_QUEUE(priv
->qos_params
[1], 0x0002, 0x0007, 0x000f, 94);
2081 P54_SET_QUEUE(priv
->qos_params
[2], 0x0003, 0x000f, 0x03ff, 0);
2082 P54_SET_QUEUE(priv
->qos_params
[3], 0x0007, 0x000f, 0x03ff, 0);
2083 err
= p54_set_edcf(dev
);
2087 memset(priv
->bssid
, ~0, ETH_ALEN
);
2088 priv
->mode
= NL80211_IFTYPE_MONITOR
;
2089 err
= p54_setup_mac(dev
);
2091 priv
->mode
= NL80211_IFTYPE_UNSPECIFIED
;
2095 queue_delayed_work(dev
->workqueue
, &priv
->work
, 0);
2097 priv
->softled_state
= 0;
2098 err
= p54_set_leds(dev
);
2101 mutex_unlock(&priv
->conf_mutex
);
2105 static void p54_stop(struct ieee80211_hw
*dev
)
2107 struct p54_common
*priv
= dev
->priv
;
2108 struct sk_buff
*skb
;
2110 mutex_lock(&priv
->conf_mutex
);
2111 priv
->mode
= NL80211_IFTYPE_UNSPECIFIED
;
2112 priv
->softled_state
= 0;
2115 #ifdef CONFIG_P54_LEDS
2116 cancel_delayed_work_sync(&priv
->led_work
);
2117 #endif /* CONFIG_P54_LEDS */
2118 cancel_delayed_work_sync(&priv
->work
);
2119 if (priv
->cached_beacon
)
2120 p54_tx_cancel(dev
, priv
->cached_beacon
);
2123 while ((skb
= skb_dequeue(&priv
->tx_queue
)))
2125 priv
->cached_beacon
= NULL
;
2126 priv
->tsf_high32
= priv
->tsf_low32
= 0;
2127 mutex_unlock(&priv
->conf_mutex
);
2130 static int p54_add_interface(struct ieee80211_hw
*dev
,
2131 struct ieee80211_if_init_conf
*conf
)
2133 struct p54_common
*priv
= dev
->priv
;
2135 mutex_lock(&priv
->conf_mutex
);
2136 if (priv
->mode
!= NL80211_IFTYPE_MONITOR
) {
2137 mutex_unlock(&priv
->conf_mutex
);
2141 priv
->vif
= conf
->vif
;
2143 switch (conf
->type
) {
2144 case NL80211_IFTYPE_STATION
:
2145 case NL80211_IFTYPE_ADHOC
:
2146 case NL80211_IFTYPE_AP
:
2147 case NL80211_IFTYPE_MESH_POINT
:
2148 priv
->mode
= conf
->type
;
2151 mutex_unlock(&priv
->conf_mutex
);
2155 memcpy(priv
->mac_addr
, conf
->mac_addr
, ETH_ALEN
);
2157 mutex_unlock(&priv
->conf_mutex
);
2161 static void p54_remove_interface(struct ieee80211_hw
*dev
,
2162 struct ieee80211_if_init_conf
*conf
)
2164 struct p54_common
*priv
= dev
->priv
;
2166 mutex_lock(&priv
->conf_mutex
);
2168 if (priv
->cached_beacon
)
2169 p54_tx_cancel(dev
, priv
->cached_beacon
);
2170 priv
->mode
= NL80211_IFTYPE_MONITOR
;
2171 memset(priv
->mac_addr
, 0, ETH_ALEN
);
2172 memset(priv
->bssid
, 0, ETH_ALEN
);
2174 mutex_unlock(&priv
->conf_mutex
);
2177 static int p54_config(struct ieee80211_hw
*dev
, u32 changed
)
2180 struct p54_common
*priv
= dev
->priv
;
2181 struct ieee80211_conf
*conf
= &dev
->conf
;
2183 mutex_lock(&priv
->conf_mutex
);
2184 if (changed
& IEEE80211_CONF_CHANGE_POWER
)
2185 priv
->output_power
= conf
->power_level
<< 2;
2186 if (changed
& IEEE80211_CONF_CHANGE_RADIO_ENABLED
) {
2187 ret
= p54_setup_mac(dev
);
2191 if (changed
& IEEE80211_CONF_CHANGE_CHANNEL
) {
2192 ret
= p54_scan(dev
, P54_SCAN_EXIT
, 0);
2196 if (changed
& IEEE80211_CONF_CHANGE_PS
) {
2197 ret
= p54_set_ps(dev
);
2203 mutex_unlock(&priv
->conf_mutex
);
2207 static void p54_configure_filter(struct ieee80211_hw
*dev
,
2208 unsigned int changed_flags
,
2209 unsigned int *total_flags
,
2210 int mc_count
, struct dev_mc_list
*mclist
)
2212 struct p54_common
*priv
= dev
->priv
;
2214 *total_flags
&= FIF_PROMISC_IN_BSS
|
2217 priv
->filter_flags
= *total_flags
;
2219 if (changed_flags
& (FIF_PROMISC_IN_BSS
| FIF_OTHER_BSS
))
2223 static int p54_conf_tx(struct ieee80211_hw
*dev
, u16 queue
,
2224 const struct ieee80211_tx_queue_params
*params
)
2226 struct p54_common
*priv
= dev
->priv
;
2229 mutex_lock(&priv
->conf_mutex
);
2230 if ((params
) && !(queue
> 4)) {
2231 P54_SET_QUEUE(priv
->qos_params
[queue
], params
->aifs
,
2232 params
->cw_min
, params
->cw_max
, params
->txop
);
2233 ret
= p54_set_edcf(dev
);
2236 mutex_unlock(&priv
->conf_mutex
);
2240 static int p54_init_xbow_synth(struct ieee80211_hw
*dev
)
2242 struct p54_common
*priv
= dev
->priv
;
2243 struct sk_buff
*skb
;
2244 struct p54_xbow_synth
*xbow
;
2246 skb
= p54_alloc_skb(dev
, P54_HDR_FLAG_CONTROL_OPSET
, sizeof(*xbow
),
2247 P54_CONTROL_TYPE_XBOW_SYNTH_CFG
, GFP_KERNEL
);
2251 xbow
= (struct p54_xbow_synth
*)skb_put(skb
, sizeof(*xbow
));
2252 xbow
->magic1
= cpu_to_le16(0x1);
2253 xbow
->magic2
= cpu_to_le16(0x2);
2254 xbow
->freq
= cpu_to_le16(5390);
2255 memset(xbow
->padding
, 0, sizeof(xbow
->padding
));
2260 static void p54_work(struct work_struct
*work
)
2262 struct p54_common
*priv
= container_of(work
, struct p54_common
,
2264 struct ieee80211_hw
*dev
= priv
->hw
;
2265 struct sk_buff
*skb
;
2267 if (unlikely(priv
->mode
== NL80211_IFTYPE_UNSPECIFIED
))
2271 * TODO: walk through tx_queue and do the following tasks
2272 * 1. initiate bursts.
2273 * 2. cancel stuck frames / reset the device if necessary.
2276 skb
= p54_alloc_skb(dev
, P54_HDR_FLAG_CONTROL
,
2277 sizeof(struct p54_statistics
),
2278 P54_CONTROL_TYPE_STAT_READBACK
, GFP_KERNEL
);
2285 static int p54_get_stats(struct ieee80211_hw
*dev
,
2286 struct ieee80211_low_level_stats
*stats
)
2288 struct p54_common
*priv
= dev
->priv
;
2290 memcpy(stats
, &priv
->stats
, sizeof(*stats
));
2294 static int p54_get_tx_stats(struct ieee80211_hw
*dev
,
2295 struct ieee80211_tx_queue_stats
*stats
)
2297 struct p54_common
*priv
= dev
->priv
;
2299 memcpy(stats
, &priv
->tx_stats
[P54_QUEUE_DATA
],
2300 sizeof(stats
[0]) * dev
->queues
);
2304 static void p54_bss_info_changed(struct ieee80211_hw
*dev
,
2305 struct ieee80211_vif
*vif
,
2306 struct ieee80211_bss_conf
*info
,
2309 struct p54_common
*priv
= dev
->priv
;
2312 mutex_lock(&priv
->conf_mutex
);
2313 if (changed
& BSS_CHANGED_BSSID
) {
2314 memcpy(priv
->bssid
, info
->bssid
, ETH_ALEN
);
2315 ret
= p54_setup_mac(dev
);
2320 if (changed
& BSS_CHANGED_BEACON
) {
2321 ret
= p54_scan(dev
, P54_SCAN_EXIT
, 0);
2324 ret
= p54_setup_mac(dev
);
2327 ret
= p54_beacon_update(dev
, vif
);
2331 /* XXX: this mimics having two callbacks... clean up */
2333 mutex_unlock(&priv
->conf_mutex
);
2335 if (changed
& (BSS_CHANGED_ERP_SLOT
| BSS_CHANGED_BEACON
)) {
2336 priv
->use_short_slot
= info
->use_short_slot
;
2339 if (changed
& BSS_CHANGED_BASIC_RATES
) {
2340 if (dev
->conf
.channel
->band
== IEEE80211_BAND_5GHZ
)
2341 priv
->basic_rate_mask
= (info
->basic_rates
<< 4);
2343 priv
->basic_rate_mask
= info
->basic_rates
;
2345 if (priv
->fw_var
>= 0x500)
2346 p54_scan(dev
, P54_SCAN_EXIT
, 0);
2348 if (changed
& BSS_CHANGED_ASSOC
) {
2350 priv
->aid
= info
->aid
;
2351 priv
->wakeup_timer
= info
->beacon_int
*
2352 info
->dtim_period
* 5;
2358 static int p54_set_key(struct ieee80211_hw
*dev
, enum set_key_cmd cmd
,
2359 struct ieee80211_vif
*vif
, struct ieee80211_sta
*sta
,
2360 struct ieee80211_key_conf
*key
)
2362 struct p54_common
*priv
= dev
->priv
;
2363 struct sk_buff
*skb
;
2364 struct p54_keycache
*rxkey
;
2368 if (modparam_nohwcrypt
)
2371 mutex_lock(&priv
->conf_mutex
);
2372 if (cmd
== SET_KEY
) {
2375 if (!(priv
->privacy_caps
& (BR_DESC_PRIV_CAP_MICHAEL
|
2376 BR_DESC_PRIV_CAP_TKIP
))) {
2380 key
->flags
|= IEEE80211_KEY_FLAG_GENERATE_IV
;
2381 algo
= P54_CRYPTO_TKIPMICHAEL
;
2384 if (!(priv
->privacy_caps
& BR_DESC_PRIV_CAP_WEP
)) {
2388 key
->flags
|= IEEE80211_KEY_FLAG_GENERATE_IV
;
2389 algo
= P54_CRYPTO_WEP
;
2392 if (!(priv
->privacy_caps
& BR_DESC_PRIV_CAP_AESCCMP
)) {
2396 key
->flags
|= IEEE80211_KEY_FLAG_GENERATE_IV
;
2397 algo
= P54_CRYPTO_AESCCMP
;
2403 slot
= bitmap_find_free_region(priv
->used_rxkeys
,
2404 priv
->rx_keycache_size
, 0);
2408 * The device supports the choosen algorithm, but the
2409 * firmware does not provide enough key slots to store
2411 * But encryption offload for outgoing frames is always
2412 * possible, so we just pretend that the upload was
2413 * successful and do the decryption in software.
2416 /* mark the key as invalid. */
2417 key
->hw_key_idx
= 0xff;
2421 slot
= key
->hw_key_idx
;
2424 /* This key was not uploaded into the rx key cache. */
2429 bitmap_release_region(priv
->used_rxkeys
, slot
, 0);
2433 skb
= p54_alloc_skb(dev
, P54_HDR_FLAG_CONTROL_OPSET
, sizeof(*rxkey
),
2434 P54_CONTROL_TYPE_RX_KEYCACHE
, GFP_KERNEL
);
2436 bitmap_release_region(priv
->used_rxkeys
, slot
, 0);
2441 rxkey
= (struct p54_keycache
*)skb_put(skb
, sizeof(*rxkey
));
2442 rxkey
->entry
= slot
;
2443 rxkey
->key_id
= key
->keyidx
;
2444 rxkey
->key_type
= algo
;
2446 memcpy(rxkey
->mac
, sta
->addr
, ETH_ALEN
);
2448 memset(rxkey
->mac
, ~0, ETH_ALEN
);
2449 if (key
->alg
!= ALG_TKIP
) {
2450 rxkey
->key_len
= min((u8
)16, key
->keylen
);
2451 memcpy(rxkey
->key
, key
->key
, rxkey
->key_len
);
2453 rxkey
->key_len
= 24;
2454 memcpy(rxkey
->key
, key
->key
, 16);
2455 memcpy(&(rxkey
->key
[16]), &(key
->key
2456 [NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY
]), 8);
2460 key
->hw_key_idx
= slot
;
2463 mutex_unlock(&priv
->conf_mutex
);
2467 #ifdef CONFIG_P54_LEDS
2468 static void p54_update_leds(struct work_struct
*work
)
2470 struct p54_common
*priv
= container_of(work
, struct p54_common
,
2472 int err
, i
, tmp
, blink_delay
= 400;
2475 /* Don't toggle the LED, when the device is down. */
2476 if (priv
->mode
== NL80211_IFTYPE_UNSPECIFIED
)
2479 for (i
= 0; i
< ARRAY_SIZE(priv
->leds
); i
++)
2480 if (priv
->leds
[i
].toggled
) {
2481 priv
->softled_state
|= BIT(i
);
2483 tmp
= 70 + 200 / (priv
->leds
[i
].toggled
);
2484 if (tmp
< blink_delay
)
2487 if (priv
->leds
[i
].led_dev
.brightness
== LED_OFF
)
2490 priv
->leds
[i
].toggled
=
2491 !!priv
->leds
[i
].led_dev
.brightness
;
2493 priv
->softled_state
&= ~BIT(i
);
2495 err
= p54_set_leds(priv
->hw
);
2496 if (err
&& net_ratelimit())
2497 printk(KERN_ERR
"%s: failed to update LEDs.\n",
2498 wiphy_name(priv
->hw
->wiphy
));
2501 queue_delayed_work(priv
->hw
->workqueue
, &priv
->led_work
,
2502 msecs_to_jiffies(blink_delay
));
2505 static void p54_led_brightness_set(struct led_classdev
*led_dev
,
2506 enum led_brightness brightness
)
2508 struct p54_led_dev
*led
= container_of(led_dev
, struct p54_led_dev
,
2510 struct ieee80211_hw
*dev
= led
->hw_dev
;
2511 struct p54_common
*priv
= dev
->priv
;
2513 if (priv
->mode
== NL80211_IFTYPE_UNSPECIFIED
)
2518 queue_delayed_work(priv
->hw
->workqueue
, &priv
->led_work
,
2523 static int p54_register_led(struct ieee80211_hw
*dev
,
2524 unsigned int led_index
,
2525 char *name
, char *trigger
)
2527 struct p54_common
*priv
= dev
->priv
;
2528 struct p54_led_dev
*led
= &priv
->leds
[led_index
];
2531 if (led
->registered
)
2534 snprintf(led
->name
, sizeof(led
->name
), "p54-%s::%s",
2535 wiphy_name(dev
->wiphy
), name
);
2537 led
->index
= led_index
;
2538 led
->led_dev
.name
= led
->name
;
2539 led
->led_dev
.default_trigger
= trigger
;
2540 led
->led_dev
.brightness_set
= p54_led_brightness_set
;
2542 err
= led_classdev_register(wiphy_dev(dev
->wiphy
), &led
->led_dev
);
2544 printk(KERN_ERR
"%s: Failed to register %s LED.\n",
2545 wiphy_name(dev
->wiphy
), name
);
2547 led
->registered
= 1;
2552 static int p54_init_leds(struct ieee80211_hw
*dev
)
2554 struct p54_common
*priv
= dev
->priv
;
2559 * Figure out if the EEPROM contains some hints about the number
2560 * of available/programmable LEDs of the device.
2563 INIT_DELAYED_WORK(&priv
->led_work
, p54_update_leds
);
2565 err
= p54_register_led(dev
, 0, "assoc",
2566 ieee80211_get_assoc_led_name(dev
));
2570 err
= p54_register_led(dev
, 1, "tx",
2571 ieee80211_get_tx_led_name(dev
));
2575 err
= p54_register_led(dev
, 2, "rx",
2576 ieee80211_get_rx_led_name(dev
));
2580 err
= p54_register_led(dev
, 3, "radio",
2581 ieee80211_get_radio_led_name(dev
));
2585 err
= p54_set_leds(dev
);
2589 static void p54_unregister_leds(struct ieee80211_hw
*dev
)
2591 struct p54_common
*priv
= dev
->priv
;
2594 for (i
= 0; i
< ARRAY_SIZE(priv
->leds
); i
++)
2595 if (priv
->leds
[i
].registered
)
2596 led_classdev_unregister(&priv
->leds
[i
].led_dev
);
2598 #endif /* CONFIG_P54_LEDS */
2600 static const struct ieee80211_ops p54_ops
= {
2604 .add_interface
= p54_add_interface
,
2605 .remove_interface
= p54_remove_interface
,
2606 .set_tim
= p54_set_tim
,
2607 .sta_notify
= p54_sta_notify
,
2608 .set_key
= p54_set_key
,
2609 .config
= p54_config
,
2610 .bss_info_changed
= p54_bss_info_changed
,
2611 .configure_filter
= p54_configure_filter
,
2612 .conf_tx
= p54_conf_tx
,
2613 .get_stats
= p54_get_stats
,
2614 .get_tx_stats
= p54_get_tx_stats
2617 struct ieee80211_hw
*p54_init_common(size_t priv_data_len
)
2619 struct ieee80211_hw
*dev
;
2620 struct p54_common
*priv
;
2622 dev
= ieee80211_alloc_hw(priv_data_len
, &p54_ops
);
2628 priv
->mode
= NL80211_IFTYPE_UNSPECIFIED
;
2629 priv
->basic_rate_mask
= 0x15f;
2630 skb_queue_head_init(&priv
->tx_queue
);
2631 dev
->flags
= IEEE80211_HW_RX_INCLUDES_FCS
|
2632 IEEE80211_HW_SIGNAL_DBM
|
2633 IEEE80211_HW_NOISE_DBM
;
2635 dev
->wiphy
->interface_modes
= BIT(NL80211_IFTYPE_STATION
) |
2636 BIT(NL80211_IFTYPE_ADHOC
) |
2637 BIT(NL80211_IFTYPE_AP
) |
2638 BIT(NL80211_IFTYPE_MESH_POINT
);
2640 dev
->channel_change_time
= 1000; /* TODO: find actual value */
2641 priv
->tx_stats
[P54_QUEUE_BEACON
].limit
= 1;
2642 priv
->tx_stats
[P54_QUEUE_FWSCAN
].limit
= 1;
2643 priv
->tx_stats
[P54_QUEUE_MGMT
].limit
= 3;
2644 priv
->tx_stats
[P54_QUEUE_CAB
].limit
= 3;
2645 priv
->tx_stats
[P54_QUEUE_DATA
].limit
= 5;
2649 * We support at most 8 tries no matter which rate they're at,
2650 * we cannot support max_rates * max_rate_tries as we set it
2651 * here, but setting it correctly to 4/2 or so would limit us
2652 * artificially if the RC algorithm wants just two rates, so
2653 * let's say 4/7, we'll redistribute it at TX time, see the
2657 dev
->max_rate_tries
= 7;
2658 dev
->extra_tx_headroom
= sizeof(struct p54_hdr
) + 4 +
2659 sizeof(struct p54_tx_data
);
2661 mutex_init(&priv
->conf_mutex
);
2662 init_completion(&priv
->eeprom_comp
);
2663 INIT_DELAYED_WORK(&priv
->work
, p54_work
);
2667 EXPORT_SYMBOL_GPL(p54_init_common
);
2669 int p54_register_common(struct ieee80211_hw
*dev
, struct device
*pdev
)
2673 err
= ieee80211_register_hw(dev
);
2675 dev_err(pdev
, "Cannot register device (%d).\n", err
);
2679 #ifdef CONFIG_P54_LEDS
2680 err
= p54_init_leds(dev
);
2683 #endif /* CONFIG_P54_LEDS */
2685 dev_info(pdev
, "is registered as '%s'\n", wiphy_name(dev
->wiphy
));
2688 EXPORT_SYMBOL_GPL(p54_register_common
);
2690 void p54_free_common(struct ieee80211_hw
*dev
)
2692 struct p54_common
*priv
= dev
->priv
;
2693 kfree(priv
->iq_autocal
);
2694 kfree(priv
->output_limit
);
2695 kfree(priv
->curve_data
);
2696 kfree(priv
->used_rxkeys
);
2698 #ifdef CONFIG_P54_LEDS
2699 p54_unregister_leds(dev
);
2700 #endif /* CONFIG_P54_LEDS */
2702 EXPORT_SYMBOL_GPL(p54_free_common
);