2 * This file is part of wl1271
4 * Copyright (C) 2009-2010 Nokia Corporation
6 * Contact: Luciano Coelho <luciano.coelho@nokia.com>
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
24 #include <linux/module.h>
25 #include <linux/platform_device.h>
26 #include <linux/crc7.h>
27 #include <linux/spi/spi.h>
28 #include <linux/etherdevice.h>
29 #include <linux/ieee80211.h>
30 #include <linux/slab.h>
36 #include "wl12xx_80211.h"
41 #define WL1271_CMD_FAST_POLL_COUNT 50
44 * send command to firmware
48 * @buf: buffer containing the command, must work with dma
49 * @len: length of the buffer
51 int wl1271_cmd_send(struct wl1271
*wl
, u16 id
, void *buf
, size_t len
,
54 struct wl1271_cmd_header
*cmd
;
55 unsigned long timeout
;
62 cmd
->id
= cpu_to_le16(id
);
65 WARN_ON(len
% 4 != 0);
66 WARN_ON(test_bit(WL1271_FLAG_IN_ELP
, &wl
->flags
));
68 wl1271_write(wl
, wl
->cmd_box_addr
, buf
, len
, false);
70 wl1271_write32(wl
, ACX_REG_INTERRUPT_TRIG
, INTR_TRIG_CMD
);
72 timeout
= jiffies
+ msecs_to_jiffies(WL1271_COMMAND_TIMEOUT
);
74 intr
= wl1271_read32(wl
, ACX_REG_INTERRUPT_NO_CLEAR
);
75 while (!(intr
& WL1271_ACX_INTR_CMD_COMPLETE
)) {
76 if (time_after(jiffies
, timeout
)) {
77 wl1271_error("command complete timeout");
83 if (poll_count
< WL1271_CMD_FAST_POLL_COUNT
)
88 intr
= wl1271_read32(wl
, ACX_REG_INTERRUPT_NO_CLEAR
);
91 /* read back the status code of the command */
93 res_len
= sizeof(struct wl1271_cmd_header
);
94 wl1271_read(wl
, wl
->cmd_box_addr
, cmd
, res_len
, false);
96 status
= le16_to_cpu(cmd
->status
);
97 if (status
!= CMD_STATUS_SUCCESS
) {
98 wl1271_error("command execute failure %d", status
);
103 wl1271_write32(wl
, ACX_REG_INTERRUPT_ACK
,
104 WL1271_ACX_INTR_CMD_COMPLETE
);
109 ieee80211_queue_work(wl
->hw
, &wl
->recovery_work
);
113 int wl1271_cmd_general_parms(struct wl1271
*wl
)
115 struct wl1271_general_parms_cmd
*gen_parms
;
116 struct wl1271_ini_general_params
*gp
=
117 &((struct wl1271_nvs_file
*)wl
->nvs
)->general_params
;
124 if (gp
->tx_bip_fem_manufacturer
>= WL1271_INI_FEM_MODULE_COUNT
) {
125 wl1271_warning("FEM index from INI out of bounds");
129 gen_parms
= kzalloc(sizeof(*gen_parms
), GFP_KERNEL
);
133 gen_parms
->test
.id
= TEST_CMD_INI_FILE_GENERAL_PARAM
;
135 memcpy(&gen_parms
->general_params
, gp
, sizeof(*gp
));
137 if (gp
->tx_bip_fem_auto_detect
)
140 /* Override the REF CLK from the NVS with the one from platform data */
141 gen_parms
->general_params
.ref_clock
= wl
->ref_clock
;
143 ret
= wl1271_cmd_test(wl
, gen_parms
, sizeof(*gen_parms
), answer
);
145 wl1271_warning("CMD_INI_FILE_GENERAL_PARAM failed");
149 gp
->tx_bip_fem_manufacturer
=
150 gen_parms
->general_params
.tx_bip_fem_manufacturer
;
152 if (gp
->tx_bip_fem_manufacturer
>= WL1271_INI_FEM_MODULE_COUNT
) {
153 wl1271_warning("FEM index from FW out of bounds");
158 wl1271_debug(DEBUG_CMD
, "FEM autodetect: %s, manufacturer: %d\n",
159 answer
? "auto" : "manual", gp
->tx_bip_fem_manufacturer
);
166 int wl128x_cmd_general_parms(struct wl1271
*wl
)
168 struct wl128x_general_parms_cmd
*gen_parms
;
169 struct wl128x_ini_general_params
*gp
=
170 &((struct wl128x_nvs_file
*)wl
->nvs
)->general_params
;
177 if (gp
->tx_bip_fem_manufacturer
>= WL1271_INI_FEM_MODULE_COUNT
) {
178 wl1271_warning("FEM index from ini out of bounds");
182 gen_parms
= kzalloc(sizeof(*gen_parms
), GFP_KERNEL
);
186 gen_parms
->test
.id
= TEST_CMD_INI_FILE_GENERAL_PARAM
;
188 memcpy(&gen_parms
->general_params
, gp
, sizeof(*gp
));
190 if (gp
->tx_bip_fem_auto_detect
)
193 /* Replace REF and TCXO CLKs with the ones from platform data */
194 gen_parms
->general_params
.ref_clock
= wl
->ref_clock
;
195 gen_parms
->general_params
.tcxo_ref_clock
= wl
->tcxo_clock
;
197 ret
= wl1271_cmd_test(wl
, gen_parms
, sizeof(*gen_parms
), answer
);
199 wl1271_warning("CMD_INI_FILE_GENERAL_PARAM failed");
203 gp
->tx_bip_fem_manufacturer
=
204 gen_parms
->general_params
.tx_bip_fem_manufacturer
;
206 if (gp
->tx_bip_fem_manufacturer
>= WL1271_INI_FEM_MODULE_COUNT
) {
207 wl1271_warning("FEM index from FW out of bounds");
212 wl1271_debug(DEBUG_CMD
, "FEM autodetect: %s, manufacturer: %d\n",
213 answer
? "auto" : "manual", gp
->tx_bip_fem_manufacturer
);
220 int wl1271_cmd_radio_parms(struct wl1271
*wl
)
222 struct wl1271_nvs_file
*nvs
= (struct wl1271_nvs_file
*)wl
->nvs
;
223 struct wl1271_radio_parms_cmd
*radio_parms
;
224 struct wl1271_ini_general_params
*gp
= &nvs
->general_params
;
230 radio_parms
= kzalloc(sizeof(*radio_parms
), GFP_KERNEL
);
234 radio_parms
->test
.id
= TEST_CMD_INI_FILE_RADIO_PARAM
;
236 /* 2.4GHz parameters */
237 memcpy(&radio_parms
->static_params_2
, &nvs
->stat_radio_params_2
,
238 sizeof(struct wl1271_ini_band_params_2
));
239 memcpy(&radio_parms
->dyn_params_2
,
240 &nvs
->dyn_radio_params_2
[gp
->tx_bip_fem_manufacturer
].params
,
241 sizeof(struct wl1271_ini_fem_params_2
));
243 /* 5GHz parameters */
244 memcpy(&radio_parms
->static_params_5
,
245 &nvs
->stat_radio_params_5
,
246 sizeof(struct wl1271_ini_band_params_5
));
247 memcpy(&radio_parms
->dyn_params_5
,
248 &nvs
->dyn_radio_params_5
[gp
->tx_bip_fem_manufacturer
].params
,
249 sizeof(struct wl1271_ini_fem_params_5
));
251 wl1271_dump(DEBUG_CMD
, "TEST_CMD_INI_FILE_RADIO_PARAM: ",
252 radio_parms
, sizeof(*radio_parms
));
254 ret
= wl1271_cmd_test(wl
, radio_parms
, sizeof(*radio_parms
), 0);
256 wl1271_warning("CMD_INI_FILE_RADIO_PARAM failed");
262 int wl128x_cmd_radio_parms(struct wl1271
*wl
)
264 struct wl128x_nvs_file
*nvs
= (struct wl128x_nvs_file
*)wl
->nvs
;
265 struct wl128x_radio_parms_cmd
*radio_parms
;
266 struct wl128x_ini_general_params
*gp
= &nvs
->general_params
;
272 radio_parms
= kzalloc(sizeof(*radio_parms
), GFP_KERNEL
);
276 radio_parms
->test
.id
= TEST_CMD_INI_FILE_RADIO_PARAM
;
278 /* 2.4GHz parameters */
279 memcpy(&radio_parms
->static_params_2
, &nvs
->stat_radio_params_2
,
280 sizeof(struct wl128x_ini_band_params_2
));
281 memcpy(&radio_parms
->dyn_params_2
,
282 &nvs
->dyn_radio_params_2
[gp
->tx_bip_fem_manufacturer
].params
,
283 sizeof(struct wl128x_ini_fem_params_2
));
285 /* 5GHz parameters */
286 memcpy(&radio_parms
->static_params_5
,
287 &nvs
->stat_radio_params_5
,
288 sizeof(struct wl128x_ini_band_params_5
));
289 memcpy(&radio_parms
->dyn_params_5
,
290 &nvs
->dyn_radio_params_5
[gp
->tx_bip_fem_manufacturer
].params
,
291 sizeof(struct wl128x_ini_fem_params_5
));
293 radio_parms
->fem_vendor_and_options
= nvs
->fem_vendor_and_options
;
295 wl1271_dump(DEBUG_CMD
, "TEST_CMD_INI_FILE_RADIO_PARAM: ",
296 radio_parms
, sizeof(*radio_parms
));
298 ret
= wl1271_cmd_test(wl
, radio_parms
, sizeof(*radio_parms
), 0);
300 wl1271_warning("CMD_INI_FILE_RADIO_PARAM failed");
306 int wl1271_cmd_ext_radio_parms(struct wl1271
*wl
)
308 struct wl1271_ext_radio_parms_cmd
*ext_radio_parms
;
309 struct conf_rf_settings
*rf
= &wl
->conf
.rf
;
315 ext_radio_parms
= kzalloc(sizeof(*ext_radio_parms
), GFP_KERNEL
);
316 if (!ext_radio_parms
)
319 ext_radio_parms
->test
.id
= TEST_CMD_INI_FILE_RF_EXTENDED_PARAM
;
321 memcpy(ext_radio_parms
->tx_per_channel_power_compensation_2
,
322 rf
->tx_per_channel_power_compensation_2
,
323 CONF_TX_PWR_COMPENSATION_LEN_2
);
324 memcpy(ext_radio_parms
->tx_per_channel_power_compensation_5
,
325 rf
->tx_per_channel_power_compensation_5
,
326 CONF_TX_PWR_COMPENSATION_LEN_5
);
328 wl1271_dump(DEBUG_CMD
, "TEST_CMD_INI_FILE_EXT_RADIO_PARAM: ",
329 ext_radio_parms
, sizeof(*ext_radio_parms
));
331 ret
= wl1271_cmd_test(wl
, ext_radio_parms
, sizeof(*ext_radio_parms
), 0);
333 wl1271_warning("TEST_CMD_INI_FILE_RF_EXTENDED_PARAM failed");
335 kfree(ext_radio_parms
);
340 * Poll the mailbox event field until any of the bits in the mask is set or a
341 * timeout occurs (WL1271_EVENT_TIMEOUT in msecs)
343 static int wl1271_cmd_wait_for_event_or_timeout(struct wl1271
*wl
, u32 mask
)
345 u32 events_vector
, event
;
346 unsigned long timeout
;
348 timeout
= jiffies
+ msecs_to_jiffies(WL1271_EVENT_TIMEOUT
);
351 if (time_after(jiffies
, timeout
)) {
352 wl1271_debug(DEBUG_CMD
, "timeout waiting for event %d",
359 /* read from both event fields */
360 wl1271_read(wl
, wl
->mbox_ptr
[0], &events_vector
,
361 sizeof(events_vector
), false);
362 event
= events_vector
& mask
;
363 wl1271_read(wl
, wl
->mbox_ptr
[1], &events_vector
,
364 sizeof(events_vector
), false);
365 event
|= events_vector
& mask
;
371 static int wl1271_cmd_wait_for_event(struct wl1271
*wl
, u32 mask
)
375 ret
= wl1271_cmd_wait_for_event_or_timeout(wl
, mask
);
377 ieee80211_queue_work(wl
->hw
, &wl
->recovery_work
);
384 int wl1271_cmd_join(struct wl1271
*wl
, u8 bss_type
)
386 struct wl1271_cmd_join
*join
;
390 join
= kzalloc(sizeof(*join
), GFP_KERNEL
);
396 wl1271_debug(DEBUG_CMD
, "cmd join");
398 /* Reverse order BSSID */
399 bssid
= (u8
*) &join
->bssid_lsb
;
400 for (i
= 0; i
< ETH_ALEN
; i
++)
401 bssid
[i
] = wl
->bssid
[ETH_ALEN
- i
- 1];
403 join
->rx_config_options
= cpu_to_le32(wl
->rx_config
);
404 join
->rx_filter_options
= cpu_to_le32(wl
->rx_filter
);
405 join
->bss_type
= bss_type
;
406 join
->basic_rate_set
= cpu_to_le32(wl
->basic_rate_set
);
407 join
->supported_rate_set
= cpu_to_le32(wl
->rate_set
);
409 if (wl
->band
== IEEE80211_BAND_5GHZ
)
410 join
->bss_type
|= WL1271_JOIN_CMD_BSS_TYPE_5GHZ
;
412 join
->beacon_interval
= cpu_to_le16(wl
->beacon_int
);
413 join
->dtim_interval
= WL1271_DEFAULT_DTIM_PERIOD
;
415 join
->channel
= wl
->channel
;
416 join
->ssid_len
= wl
->ssid_len
;
417 memcpy(join
->ssid
, wl
->ssid
, wl
->ssid_len
);
419 join
->ctrl
|= wl
->session_counter
<< WL1271_JOIN_CMD_TX_SESSION_OFFSET
;
421 /* reset TX security counters */
422 wl
->tx_security_last_seq
= 0;
423 wl
->tx_security_seq
= 0;
425 wl1271_debug(DEBUG_CMD
, "cmd join: basic_rate_set=0x%x, rate_set=0x%x",
426 join
->basic_rate_set
, join
->supported_rate_set
);
428 ret
= wl1271_cmd_send(wl
, CMD_START_JOIN
, join
, sizeof(*join
), 0);
430 wl1271_error("failed to initiate cmd join");
434 ret
= wl1271_cmd_wait_for_event(wl
, JOIN_EVENT_COMPLETE_ID
);
436 wl1271_error("cmd join event completion error");
446 * send test command to firmware
449 * @buf: buffer containing the command, with all headers, must work with dma
450 * @len: length of the buffer
451 * @answer: is answer needed
453 int wl1271_cmd_test(struct wl1271
*wl
, void *buf
, size_t buf_len
, u8 answer
)
458 wl1271_debug(DEBUG_CMD
, "cmd test");
463 ret
= wl1271_cmd_send(wl
, CMD_TEST
, buf
, buf_len
, res_len
);
466 wl1271_warning("TEST command failed");
474 * read acx from firmware
478 * @buf: buffer for the response, including all headers, must work with dma
479 * @len: length of buf
481 int wl1271_cmd_interrogate(struct wl1271
*wl
, u16 id
, void *buf
, size_t len
)
483 struct acx_header
*acx
= buf
;
486 wl1271_debug(DEBUG_CMD
, "cmd interrogate");
488 acx
->id
= cpu_to_le16(id
);
490 /* payload length, does not include any headers */
491 acx
->len
= cpu_to_le16(len
- sizeof(*acx
));
493 ret
= wl1271_cmd_send(wl
, CMD_INTERROGATE
, acx
, sizeof(*acx
), len
);
495 wl1271_error("INTERROGATE command failed");
501 * write acx value to firmware
505 * @buf: buffer containing acx, including all headers, must work with dma
506 * @len: length of buf
508 int wl1271_cmd_configure(struct wl1271
*wl
, u16 id
, void *buf
, size_t len
)
510 struct acx_header
*acx
= buf
;
513 wl1271_debug(DEBUG_CMD
, "cmd configure");
515 acx
->id
= cpu_to_le16(id
);
517 /* payload length, does not include any headers */
518 acx
->len
= cpu_to_le16(len
- sizeof(*acx
));
520 ret
= wl1271_cmd_send(wl
, CMD_CONFIGURE
, acx
, len
, 0);
522 wl1271_warning("CONFIGURE command NOK");
529 int wl1271_cmd_data_path(struct wl1271
*wl
, bool enable
)
531 struct cmd_enabledisable_path
*cmd
;
535 wl1271_debug(DEBUG_CMD
, "cmd data path");
537 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
543 /* the channel here is only used for calibration, so hardcoded to 1 */
547 cmd_rx
= CMD_ENABLE_RX
;
548 cmd_tx
= CMD_ENABLE_TX
;
550 cmd_rx
= CMD_DISABLE_RX
;
551 cmd_tx
= CMD_DISABLE_TX
;
554 ret
= wl1271_cmd_send(wl
, cmd_rx
, cmd
, sizeof(*cmd
), 0);
556 wl1271_error("rx %s cmd for channel %d failed",
557 enable
? "start" : "stop", cmd
->channel
);
561 wl1271_debug(DEBUG_BOOT
, "rx %s cmd channel %d",
562 enable
? "start" : "stop", cmd
->channel
);
564 ret
= wl1271_cmd_send(wl
, cmd_tx
, cmd
, sizeof(*cmd
), 0);
566 wl1271_error("tx %s cmd for channel %d failed",
567 enable
? "start" : "stop", cmd
->channel
);
571 wl1271_debug(DEBUG_BOOT
, "tx %s cmd channel %d",
572 enable
? "start" : "stop", cmd
->channel
);
579 int wl1271_cmd_ps_mode(struct wl1271
*wl
, u8 ps_mode
)
581 struct wl1271_cmd_ps_params
*ps_params
= NULL
;
584 wl1271_debug(DEBUG_CMD
, "cmd set ps mode");
586 ps_params
= kzalloc(sizeof(*ps_params
), GFP_KERNEL
);
592 ps_params
->ps_mode
= ps_mode
;
594 ret
= wl1271_cmd_send(wl
, CMD_SET_PS_MODE
, ps_params
,
595 sizeof(*ps_params
), 0);
597 wl1271_error("cmd set_ps_mode failed");
606 int wl1271_cmd_template_set(struct wl1271
*wl
, u16 template_id
,
607 void *buf
, size_t buf_len
, int index
, u32 rates
)
609 struct wl1271_cmd_template_set
*cmd
;
612 wl1271_debug(DEBUG_CMD
, "cmd template_set %d", template_id
);
614 WARN_ON(buf_len
> WL1271_CMD_TEMPL_MAX_SIZE
);
615 buf_len
= min_t(size_t, buf_len
, WL1271_CMD_TEMPL_MAX_SIZE
);
617 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
623 cmd
->len
= cpu_to_le16(buf_len
);
624 cmd
->template_type
= template_id
;
625 cmd
->enabled_rates
= cpu_to_le32(rates
);
626 cmd
->short_retry_limit
= wl
->conf
.tx
.tmpl_short_retry_limit
;
627 cmd
->long_retry_limit
= wl
->conf
.tx
.tmpl_long_retry_limit
;
631 memcpy(cmd
->template_data
, buf
, buf_len
);
633 ret
= wl1271_cmd_send(wl
, CMD_SET_TEMPLATE
, cmd
, sizeof(*cmd
), 0);
635 wl1271_warning("cmd set_template failed: %d", ret
);
646 int wl1271_cmd_build_null_data(struct wl1271
*wl
)
648 struct sk_buff
*skb
= NULL
;
654 if (wl
->bss_type
== BSS_TYPE_IBSS
) {
655 size
= sizeof(struct wl12xx_null_data_template
);
658 skb
= ieee80211_nullfunc_get(wl
->hw
, wl
->vif
);
665 ret
= wl1271_cmd_template_set(wl
, CMD_TEMPL_NULL_DATA
, ptr
, size
, 0,
671 wl1271_warning("cmd buld null data failed %d", ret
);
677 int wl1271_cmd_build_klv_null_data(struct wl1271
*wl
)
679 struct sk_buff
*skb
= NULL
;
682 skb
= ieee80211_nullfunc_get(wl
->hw
, wl
->vif
);
686 ret
= wl1271_cmd_template_set(wl
, CMD_TEMPL_KLV
,
688 CMD_TEMPL_KLV_IDX_NULL_DATA
,
694 wl1271_warning("cmd build klv null data failed %d", ret
);
700 int wl1271_cmd_build_ps_poll(struct wl1271
*wl
, u16 aid
)
705 skb
= ieee80211_pspoll_get(wl
->hw
, wl
->vif
);
709 ret
= wl1271_cmd_template_set(wl
, CMD_TEMPL_PS_POLL
, skb
->data
,
710 skb
->len
, 0, wl
->basic_rate_set
);
717 int wl1271_cmd_build_probe_req(struct wl1271
*wl
,
718 const u8
*ssid
, size_t ssid_len
,
719 const u8
*ie
, size_t ie_len
, u8 band
)
724 skb
= ieee80211_probereq_get(wl
->hw
, wl
->vif
, ssid
, ssid_len
,
731 wl1271_dump(DEBUG_SCAN
, "PROBE REQ: ", skb
->data
, skb
->len
);
733 if (band
== IEEE80211_BAND_2GHZ
)
734 ret
= wl1271_cmd_template_set(wl
, CMD_TEMPL_CFG_PROBE_REQ_2_4
,
735 skb
->data
, skb
->len
, 0,
736 wl
->conf
.tx
.basic_rate
);
738 ret
= wl1271_cmd_template_set(wl
, CMD_TEMPL_CFG_PROBE_REQ_5
,
739 skb
->data
, skb
->len
, 0,
740 wl
->conf
.tx
.basic_rate_5
);
747 struct sk_buff
*wl1271_cmd_build_ap_probe_req(struct wl1271
*wl
,
753 skb
= ieee80211_ap_probereq_get(wl
->hw
, wl
->vif
);
757 wl1271_dump(DEBUG_SCAN
, "AP PROBE REQ: ", skb
->data
, skb
->len
);
759 if (wl
->band
== IEEE80211_BAND_2GHZ
)
760 ret
= wl1271_cmd_template_set(wl
, CMD_TEMPL_CFG_PROBE_REQ_2_4
,
761 skb
->data
, skb
->len
, 0,
762 wl
->conf
.tx
.basic_rate
);
764 ret
= wl1271_cmd_template_set(wl
, CMD_TEMPL_CFG_PROBE_REQ_5
,
765 skb
->data
, skb
->len
, 0,
766 wl
->conf
.tx
.basic_rate_5
);
769 wl1271_error("Unable to set ap probe request template.");
775 int wl1271_cmd_build_arp_rsp(struct wl1271
*wl
, __be32 ip_addr
)
778 struct wl12xx_arp_rsp_template tmpl
;
779 struct ieee80211_hdr_3addr
*hdr
;
780 struct arphdr
*arp_hdr
;
782 memset(&tmpl
, 0, sizeof(tmpl
));
784 /* mac80211 header */
786 hdr
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_DATA
|
787 IEEE80211_STYPE_DATA
|
788 IEEE80211_FCTL_TODS
);
789 memcpy(hdr
->addr1
, wl
->vif
->bss_conf
.bssid
, ETH_ALEN
);
790 memcpy(hdr
->addr2
, wl
->vif
->addr
, ETH_ALEN
);
791 memset(hdr
->addr3
, 0xff, ETH_ALEN
);
794 memcpy(tmpl
.llc_hdr
, rfc1042_header
, sizeof(rfc1042_header
));
795 tmpl
.llc_type
= cpu_to_be16(ETH_P_ARP
);
798 arp_hdr
= &tmpl
.arp_hdr
;
799 arp_hdr
->ar_hrd
= cpu_to_be16(ARPHRD_ETHER
);
800 arp_hdr
->ar_pro
= cpu_to_be16(ETH_P_IP
);
801 arp_hdr
->ar_hln
= ETH_ALEN
;
803 arp_hdr
->ar_op
= cpu_to_be16(ARPOP_REPLY
);
806 memcpy(tmpl
.sender_hw
, wl
->vif
->addr
, ETH_ALEN
);
807 tmpl
.sender_ip
= ip_addr
;
809 ret
= wl1271_cmd_template_set(wl
, CMD_TEMPL_ARP_RSP
,
810 &tmpl
, sizeof(tmpl
), 0,
816 int wl1271_build_qos_null_data(struct wl1271
*wl
)
818 struct ieee80211_qos_hdr
template;
820 memset(&template, 0, sizeof(template));
822 memcpy(template.addr1
, wl
->bssid
, ETH_ALEN
);
823 memcpy(template.addr2
, wl
->mac_addr
, ETH_ALEN
);
824 memcpy(template.addr3
, wl
->bssid
, ETH_ALEN
);
826 template.frame_control
= cpu_to_le16(IEEE80211_FTYPE_DATA
|
827 IEEE80211_STYPE_QOS_NULLFUNC
|
828 IEEE80211_FCTL_TODS
);
830 /* FIXME: not sure what priority to use here */
831 template.qos_ctrl
= cpu_to_le16(0);
833 return wl1271_cmd_template_set(wl
, CMD_TEMPL_QOS_NULL_DATA
, &template,
838 int wl1271_cmd_set_sta_default_wep_key(struct wl1271
*wl
, u8 id
)
840 struct wl1271_cmd_set_sta_keys
*cmd
;
843 wl1271_debug(DEBUG_CMD
, "cmd set_default_wep_key %d", id
);
845 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
852 cmd
->key_action
= cpu_to_le16(KEY_SET_ID
);
853 cmd
->key_type
= KEY_WEP
;
855 ret
= wl1271_cmd_send(wl
, CMD_SET_KEYS
, cmd
, sizeof(*cmd
), 0);
857 wl1271_warning("cmd set_default_wep_key failed: %d", ret
);
867 int wl1271_cmd_set_ap_default_wep_key(struct wl1271
*wl
, u8 id
)
869 struct wl1271_cmd_set_ap_keys
*cmd
;
872 wl1271_debug(DEBUG_CMD
, "cmd set_ap_default_wep_key %d", id
);
874 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
880 cmd
->hlid
= WL1271_AP_BROADCAST_HLID
;
882 cmd
->lid_key_type
= WEP_DEFAULT_LID_TYPE
;
883 cmd
->key_action
= cpu_to_le16(KEY_SET_ID
);
884 cmd
->key_type
= KEY_WEP
;
886 ret
= wl1271_cmd_send(wl
, CMD_SET_KEYS
, cmd
, sizeof(*cmd
), 0);
888 wl1271_warning("cmd set_ap_default_wep_key failed: %d", ret
);
898 int wl1271_cmd_set_sta_key(struct wl1271
*wl
, u16 action
, u8 id
, u8 key_type
,
899 u8 key_size
, const u8
*key
, const u8
*addr
,
900 u32 tx_seq_32
, u16 tx_seq_16
)
902 struct wl1271_cmd_set_sta_keys
*cmd
;
905 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
911 if (key_type
!= KEY_WEP
)
912 memcpy(cmd
->addr
, addr
, ETH_ALEN
);
914 cmd
->key_action
= cpu_to_le16(action
);
915 cmd
->key_size
= key_size
;
916 cmd
->key_type
= key_type
;
918 cmd
->ac_seq_num16
[0] = cpu_to_le16(tx_seq_16
);
919 cmd
->ac_seq_num32
[0] = cpu_to_le32(tx_seq_32
);
921 /* we have only one SSID profile */
922 cmd
->ssid_profile
= 0;
926 if (key_type
== KEY_TKIP
) {
928 * We get the key in the following form:
929 * TKIP (16 bytes) - TX MIC (8 bytes) - RX MIC (8 bytes)
930 * but the target is expecting:
931 * TKIP - RX MIC - TX MIC
933 memcpy(cmd
->key
, key
, 16);
934 memcpy(cmd
->key
+ 16, key
+ 24, 8);
935 memcpy(cmd
->key
+ 24, key
+ 16, 8);
938 memcpy(cmd
->key
, key
, key_size
);
941 wl1271_dump(DEBUG_CRYPT
, "TARGET KEY: ", cmd
, sizeof(*cmd
));
943 ret
= wl1271_cmd_send(wl
, CMD_SET_KEYS
, cmd
, sizeof(*cmd
), 0);
945 wl1271_warning("could not set keys");
955 int wl1271_cmd_set_ap_key(struct wl1271
*wl
, u16 action
, u8 id
, u8 key_type
,
956 u8 key_size
, const u8
*key
, u8 hlid
, u32 tx_seq_32
,
959 struct wl1271_cmd_set_ap_keys
*cmd
;
963 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
967 if (hlid
== WL1271_AP_BROADCAST_HLID
) {
968 if (key_type
== KEY_WEP
)
969 lid_type
= WEP_DEFAULT_LID_TYPE
;
971 lid_type
= BROADCAST_LID_TYPE
;
973 lid_type
= UNICAST_LID_TYPE
;
976 wl1271_debug(DEBUG_CRYPT
, "ap key action: %d id: %d lid: %d type: %d"
977 " hlid: %d", (int)action
, (int)id
, (int)lid_type
,
978 (int)key_type
, (int)hlid
);
980 cmd
->lid_key_type
= lid_type
;
982 cmd
->key_action
= cpu_to_le16(action
);
983 cmd
->key_size
= key_size
;
984 cmd
->key_type
= key_type
;
986 cmd
->ac_seq_num16
[0] = cpu_to_le16(tx_seq_16
);
987 cmd
->ac_seq_num32
[0] = cpu_to_le32(tx_seq_32
);
989 if (key_type
== KEY_TKIP
) {
991 * We get the key in the following form:
992 * TKIP (16 bytes) - TX MIC (8 bytes) - RX MIC (8 bytes)
993 * but the target is expecting:
994 * TKIP - RX MIC - TX MIC
996 memcpy(cmd
->key
, key
, 16);
997 memcpy(cmd
->key
+ 16, key
+ 24, 8);
998 memcpy(cmd
->key
+ 24, key
+ 16, 8);
1000 memcpy(cmd
->key
, key
, key_size
);
1003 wl1271_dump(DEBUG_CRYPT
, "TARGET AP KEY: ", cmd
, sizeof(*cmd
));
1005 ret
= wl1271_cmd_send(wl
, CMD_SET_KEYS
, cmd
, sizeof(*cmd
), 0);
1007 wl1271_warning("could not set ap keys");
1016 int wl1271_cmd_disconnect(struct wl1271
*wl
)
1018 struct wl1271_cmd_disconnect
*cmd
;
1021 wl1271_debug(DEBUG_CMD
, "cmd disconnect");
1023 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
1029 cmd
->rx_config_options
= cpu_to_le32(wl
->rx_config
);
1030 cmd
->rx_filter_options
= cpu_to_le32(wl
->rx_filter
);
1031 /* disconnect reason is not used in immediate disconnections */
1032 cmd
->type
= DISCONNECT_IMMEDIATE
;
1034 ret
= wl1271_cmd_send(wl
, CMD_DISCONNECT
, cmd
, sizeof(*cmd
), 0);
1036 wl1271_error("failed to send disconnect command");
1040 ret
= wl1271_cmd_wait_for_event(wl
, DISCONNECT_EVENT_COMPLETE_ID
);
1042 wl1271_error("cmd disconnect event completion error");
1051 int wl1271_cmd_set_sta_state(struct wl1271
*wl
)
1053 struct wl1271_cmd_set_sta_state
*cmd
;
1056 wl1271_debug(DEBUG_CMD
, "cmd set sta state");
1058 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
1064 cmd
->state
= WL1271_CMD_STA_STATE_CONNECTED
;
1066 ret
= wl1271_cmd_send(wl
, CMD_SET_STA_STATE
, cmd
, sizeof(*cmd
), 0);
1068 wl1271_error("failed to send set STA state command");
1079 int wl1271_cmd_start_bss(struct wl1271
*wl
)
1081 struct wl1271_cmd_bss_start
*cmd
;
1082 struct ieee80211_bss_conf
*bss_conf
= &wl
->vif
->bss_conf
;
1085 wl1271_debug(DEBUG_CMD
, "cmd start bss");
1088 * FIXME: We currently do not support hidden SSID. The real SSID
1089 * should be fetched from mac80211 first.
1091 if (wl
->ssid_len
== 0) {
1092 wl1271_warning("Hidden SSID currently not supported for AP");
1097 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
1103 memcpy(cmd
->bssid
, bss_conf
->bssid
, ETH_ALEN
);
1105 cmd
->aging_period
= cpu_to_le16(WL1271_AP_DEF_INACTIV_SEC
);
1106 cmd
->bss_index
= WL1271_AP_BSS_INDEX
;
1107 cmd
->global_hlid
= WL1271_AP_GLOBAL_HLID
;
1108 cmd
->broadcast_hlid
= WL1271_AP_BROADCAST_HLID
;
1109 cmd
->basic_rate_set
= cpu_to_le32(wl
->basic_rate_set
);
1110 cmd
->beacon_interval
= cpu_to_le16(wl
->beacon_int
);
1111 cmd
->dtim_interval
= bss_conf
->dtim_period
;
1112 cmd
->beacon_expiry
= WL1271_AP_DEF_BEACON_EXP
;
1113 cmd
->channel
= wl
->channel
;
1114 cmd
->ssid_len
= wl
->ssid_len
;
1115 cmd
->ssid_type
= SSID_TYPE_PUBLIC
;
1116 memcpy(cmd
->ssid
, wl
->ssid
, wl
->ssid_len
);
1119 case IEEE80211_BAND_2GHZ
:
1120 cmd
->band
= RADIO_BAND_2_4GHZ
;
1122 case IEEE80211_BAND_5GHZ
:
1123 cmd
->band
= RADIO_BAND_5GHZ
;
1126 wl1271_warning("bss start - unknown band: %d", (int)wl
->band
);
1127 cmd
->band
= RADIO_BAND_2_4GHZ
;
1131 ret
= wl1271_cmd_send(wl
, CMD_BSS_START
, cmd
, sizeof(*cmd
), 0);
1133 wl1271_error("failed to initiate cmd start bss");
1144 int wl1271_cmd_stop_bss(struct wl1271
*wl
)
1146 struct wl1271_cmd_bss_start
*cmd
;
1149 wl1271_debug(DEBUG_CMD
, "cmd stop bss");
1151 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
1157 cmd
->bss_index
= WL1271_AP_BSS_INDEX
;
1159 ret
= wl1271_cmd_send(wl
, CMD_BSS_STOP
, cmd
, sizeof(*cmd
), 0);
1161 wl1271_error("failed to initiate cmd stop bss");
1172 int wl1271_cmd_add_sta(struct wl1271
*wl
, struct ieee80211_sta
*sta
, u8 hlid
)
1174 struct wl1271_cmd_add_sta
*cmd
;
1177 wl1271_debug(DEBUG_CMD
, "cmd add sta %d", (int)hlid
);
1179 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
1185 /* currently we don't support UAPSD */
1188 memcpy(cmd
->addr
, sta
->addr
, ETH_ALEN
);
1189 cmd
->bss_index
= WL1271_AP_BSS_INDEX
;
1190 cmd
->aid
= sta
->aid
;
1194 * FIXME: Does STA support QOS? We need to propagate this info from
1195 * hostapd. Currently not that important since this is only used for
1196 * sending the correct flavor of null-data packet in response to a
1201 cmd
->supported_rates
= cpu_to_le32(wl1271_tx_enabled_rates_get(wl
,
1202 sta
->supp_rates
[wl
->band
]));
1204 wl1271_debug(DEBUG_CMD
, "new sta rates: 0x%x", cmd
->supported_rates
);
1206 ret
= wl1271_cmd_send(wl
, CMD_ADD_STA
, cmd
, sizeof(*cmd
), 0);
1208 wl1271_error("failed to initiate cmd add sta");
1219 int wl1271_cmd_remove_sta(struct wl1271
*wl
, u8 hlid
)
1221 struct wl1271_cmd_remove_sta
*cmd
;
1224 wl1271_debug(DEBUG_CMD
, "cmd remove sta %d", (int)hlid
);
1226 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
1233 /* We never send a deauth, mac80211 is in charge of this */
1234 cmd
->reason_opcode
= 0;
1235 cmd
->send_deauth_flag
= 0;
1237 ret
= wl1271_cmd_send(wl
, CMD_REMOVE_STA
, cmd
, sizeof(*cmd
), 0);
1239 wl1271_error("failed to initiate cmd remove sta");
1244 * We are ok with a timeout here. The event is sometimes not sent
1245 * due to a firmware bug.
1247 wl1271_cmd_wait_for_event_or_timeout(wl
, STA_REMOVE_COMPLETE_EVENT_ID
);