2 * This file is part of wl1271
4 * Copyright (C) 2009 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>
31 #include "wl1271_reg.h"
32 #include "wl1271_spi.h"
33 #include "wl1271_io.h"
34 #include "wl1271_acx.h"
35 #include "wl12xx_80211.h"
36 #include "wl1271_cmd.h"
39 * send command to firmware
43 * @buf: buffer containing the command, must work with dma
44 * @len: length of the buffer
46 int wl1271_cmd_send(struct wl1271
*wl
, u16 id
, void *buf
, size_t len
,
49 struct wl1271_cmd_header
*cmd
;
50 unsigned long timeout
;
56 cmd
->id
= cpu_to_le16(id
);
59 WARN_ON(len
% 4 != 0);
61 wl1271_write(wl
, wl
->cmd_box_addr
, buf
, len
, false);
63 wl1271_write32(wl
, ACX_REG_INTERRUPT_TRIG
, INTR_TRIG_CMD
);
65 timeout
= jiffies
+ msecs_to_jiffies(WL1271_COMMAND_TIMEOUT
);
67 intr
= wl1271_read32(wl
, ACX_REG_INTERRUPT_NO_CLEAR
);
68 while (!(intr
& WL1271_ACX_INTR_CMD_COMPLETE
)) {
69 if (time_after(jiffies
, timeout
)) {
70 wl1271_error("command complete timeout");
77 intr
= wl1271_read32(wl
, ACX_REG_INTERRUPT_NO_CLEAR
);
80 /* read back the status code of the command */
82 res_len
= sizeof(struct wl1271_cmd_header
);
83 wl1271_read(wl
, wl
->cmd_box_addr
, cmd
, res_len
, false);
85 status
= le16_to_cpu(cmd
->status
);
86 if (status
!= CMD_STATUS_SUCCESS
) {
87 wl1271_error("command execute failure %d", status
);
91 wl1271_write32(wl
, ACX_REG_INTERRUPT_ACK
,
92 WL1271_ACX_INTR_CMD_COMPLETE
);
98 static int wl1271_cmd_cal_channel_tune(struct wl1271
*wl
)
100 struct wl1271_cmd_cal_channel_tune
*cmd
;
103 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
107 cmd
->test
.id
= TEST_CMD_CHANNEL_TUNE
;
109 cmd
->band
= WL1271_CHANNEL_TUNE_BAND_2_4
;
110 /* set up any channel, 7 is in the middle of the range */
113 ret
= wl1271_cmd_test(wl
, cmd
, sizeof(*cmd
), 0);
115 wl1271_warning("TEST_CMD_CHANNEL_TUNE failed");
121 static int wl1271_cmd_cal_update_ref_point(struct wl1271
*wl
)
123 struct wl1271_cmd_cal_update_ref_point
*cmd
;
126 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
130 cmd
->test
.id
= TEST_CMD_UPDATE_PD_REFERENCE_POINT
;
132 /* FIXME: still waiting for the correct values */
134 cmd
->ref_detector
= 0;
136 cmd
->sub_band
= WL1271_PD_REFERENCE_POINT_BAND_B_G
;
138 ret
= wl1271_cmd_test(wl
, cmd
, sizeof(*cmd
), 0);
140 wl1271_warning("TEST_CMD_UPDATE_PD_REFERENCE_POINT failed");
146 static int wl1271_cmd_cal_p2g(struct wl1271
*wl
)
148 struct wl1271_cmd_cal_p2g
*cmd
;
151 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
155 cmd
->test
.id
= TEST_CMD_P2G_CAL
;
157 cmd
->sub_band_mask
= WL1271_CAL_P2G_BAND_B_G
;
159 ret
= wl1271_cmd_test(wl
, cmd
, sizeof(*cmd
), 0);
161 wl1271_warning("TEST_CMD_P2G_CAL failed");
167 static int wl1271_cmd_cal(struct wl1271
*wl
)
170 * FIXME: we must make sure that we're not sleeping when calibration
175 wl1271_notice("performing tx calibration");
177 ret
= wl1271_cmd_cal_channel_tune(wl
);
181 ret
= wl1271_cmd_cal_update_ref_point(wl
);
185 ret
= wl1271_cmd_cal_p2g(wl
);
192 int wl1271_cmd_general_parms(struct wl1271
*wl
)
194 struct wl1271_general_parms_cmd
*gen_parms
;
200 gen_parms
= kzalloc(sizeof(*gen_parms
), GFP_KERNEL
);
204 gen_parms
->test
.id
= TEST_CMD_INI_FILE_GENERAL_PARAM
;
206 memcpy(gen_parms
->params
, wl
->nvs
->general_params
,
207 WL1271_NVS_GENERAL_PARAMS_SIZE
);
209 ret
= wl1271_cmd_test(wl
, gen_parms
, sizeof(*gen_parms
), 0);
211 wl1271_warning("CMD_INI_FILE_GENERAL_PARAM failed");
217 int wl1271_cmd_radio_parms(struct wl1271
*wl
)
219 struct wl1271_radio_parms_cmd
*radio_parms
;
220 struct conf_radio_parms
*rparam
= &wl
->conf
.init
.radioparam
;
226 radio_parms
= kzalloc(sizeof(*radio_parms
), GFP_KERNEL
);
230 radio_parms
->test
.id
= TEST_CMD_INI_FILE_RADIO_PARAM
;
232 memcpy(radio_parms
->stat_radio_params
, wl
->nvs
->stat_radio_params
,
233 WL1271_NVS_STAT_RADIO_PARAMS_SIZE
);
234 memcpy(radio_parms
->dyn_radio_params
,
235 wl
->nvs
->dyn_radio_params
[rparam
->fem
],
236 WL1271_NVS_DYN_RADIO_PARAMS_SIZE
);
238 /* FIXME: current NVS is missing 5GHz parameters */
240 wl1271_dump(DEBUG_CMD
, "TEST_CMD_INI_FILE_RADIO_PARAM: ",
241 radio_parms
, sizeof(*radio_parms
));
243 ret
= wl1271_cmd_test(wl
, radio_parms
, sizeof(*radio_parms
), 0);
245 wl1271_warning("CMD_INI_FILE_RADIO_PARAM failed");
251 int wl1271_cmd_join(struct wl1271
*wl
)
253 static bool do_cal
= true;
254 struct wl1271_cmd_join
*join
;
258 /* FIXME: remove when we get calibration from the factory */
260 ret
= wl1271_cmd_cal(wl
);
262 wl1271_warning("couldn't calibrate");
267 join
= kzalloc(sizeof(*join
), GFP_KERNEL
);
273 wl1271_debug(DEBUG_CMD
, "cmd join");
275 /* Reverse order BSSID */
276 bssid
= (u8
*) &join
->bssid_lsb
;
277 for (i
= 0; i
< ETH_ALEN
; i
++)
278 bssid
[i
] = wl
->bssid
[ETH_ALEN
- i
- 1];
280 join
->rx_config_options
= cpu_to_le32(wl
->rx_config
);
281 join
->rx_filter_options
= cpu_to_le32(wl
->rx_filter
);
282 join
->bss_type
= wl
->bss_type
;
285 * FIXME: disable temporarily all filters because after commit
286 * 9cef8737 "mac80211: fix managed mode BSSID handling" broke
287 * association. The filter logic needs to be implemented properly
288 * and once that is done, this hack can be removed.
290 join
->rx_config_options
= cpu_to_le32(0);
291 join
->rx_filter_options
= cpu_to_le32(WL1271_DEFAULT_RX_FILTER
);
293 if (wl
->band
== IEEE80211_BAND_2GHZ
)
294 join
->basic_rate_set
= cpu_to_le32(CONF_HW_BIT_RATE_1MBPS
|
295 CONF_HW_BIT_RATE_2MBPS
|
296 CONF_HW_BIT_RATE_5_5MBPS
|
297 CONF_HW_BIT_RATE_11MBPS
);
299 join
->bss_type
|= WL1271_JOIN_CMD_BSS_TYPE_5GHZ
;
300 join
->basic_rate_set
= cpu_to_le32(CONF_HW_BIT_RATE_6MBPS
|
301 CONF_HW_BIT_RATE_12MBPS
|
302 CONF_HW_BIT_RATE_24MBPS
);
305 join
->beacon_interval
= cpu_to_le16(WL1271_DEFAULT_BEACON_INT
);
306 join
->dtim_interval
= WL1271_DEFAULT_DTIM_PERIOD
;
308 join
->channel
= wl
->channel
;
309 join
->ssid_len
= wl
->ssid_len
;
310 memcpy(join
->ssid
, wl
->ssid
, wl
->ssid_len
);
311 join
->ctrl
= WL1271_JOIN_CMD_CTRL_TX_FLUSH
;
313 /* increment the session counter */
314 wl
->session_counter
++;
315 if (wl
->session_counter
>= SESSION_COUNTER_MAX
)
316 wl
->session_counter
= 0;
318 join
->ctrl
|= wl
->session_counter
<< WL1271_JOIN_CMD_TX_SESSION_OFFSET
;
320 /* reset TX security counters */
321 wl
->tx_security_last_seq
= 0;
322 wl
->tx_security_seq_16
= 0;
323 wl
->tx_security_seq_32
= 0;
325 ret
= wl1271_cmd_send(wl
, CMD_START_JOIN
, join
, sizeof(*join
), 0);
327 wl1271_error("failed to initiate cmd join");
332 * ugly hack: we should wait for JOIN_EVENT_COMPLETE_ID but to
333 * simplify locking we just sleep instead, for now
345 * send test command to firmware
348 * @buf: buffer containing the command, with all headers, must work with dma
349 * @len: length of the buffer
350 * @answer: is answer needed
352 int wl1271_cmd_test(struct wl1271
*wl
, void *buf
, size_t buf_len
, u8 answer
)
357 wl1271_debug(DEBUG_CMD
, "cmd test");
362 ret
= wl1271_cmd_send(wl
, CMD_TEST
, buf
, buf_len
, res_len
);
365 wl1271_warning("TEST command failed");
373 * read acx from firmware
377 * @buf: buffer for the response, including all headers, must work with dma
378 * @len: lenght of buf
380 int wl1271_cmd_interrogate(struct wl1271
*wl
, u16 id
, void *buf
, size_t len
)
382 struct acx_header
*acx
= buf
;
385 wl1271_debug(DEBUG_CMD
, "cmd interrogate");
387 acx
->id
= cpu_to_le16(id
);
389 /* payload length, does not include any headers */
390 acx
->len
= cpu_to_le16(len
- sizeof(*acx
));
392 ret
= wl1271_cmd_send(wl
, CMD_INTERROGATE
, acx
, sizeof(*acx
), len
);
394 wl1271_error("INTERROGATE command failed");
400 * write acx value to firmware
404 * @buf: buffer containing acx, including all headers, must work with dma
405 * @len: length of buf
407 int wl1271_cmd_configure(struct wl1271
*wl
, u16 id
, void *buf
, size_t len
)
409 struct acx_header
*acx
= buf
;
412 wl1271_debug(DEBUG_CMD
, "cmd configure");
414 acx
->id
= cpu_to_le16(id
);
416 /* payload length, does not include any headers */
417 acx
->len
= cpu_to_le16(len
- sizeof(*acx
));
419 ret
= wl1271_cmd_send(wl
, CMD_CONFIGURE
, acx
, len
, 0);
421 wl1271_warning("CONFIGURE command NOK");
428 int wl1271_cmd_data_path(struct wl1271
*wl
, bool enable
)
430 struct cmd_enabledisable_path
*cmd
;
434 wl1271_debug(DEBUG_CMD
, "cmd data path");
436 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
442 /* the channel here is only used for calibration, so hardcoded to 1 */
446 cmd_rx
= CMD_ENABLE_RX
;
447 cmd_tx
= CMD_ENABLE_TX
;
449 cmd_rx
= CMD_DISABLE_RX
;
450 cmd_tx
= CMD_DISABLE_TX
;
453 ret
= wl1271_cmd_send(wl
, cmd_rx
, cmd
, sizeof(*cmd
), 0);
455 wl1271_error("rx %s cmd for channel %d failed",
456 enable
? "start" : "stop", cmd
->channel
);
460 wl1271_debug(DEBUG_BOOT
, "rx %s cmd channel %d",
461 enable
? "start" : "stop", cmd
->channel
);
463 ret
= wl1271_cmd_send(wl
, cmd_tx
, cmd
, sizeof(*cmd
), 0);
465 wl1271_error("tx %s cmd for channel %d failed",
466 enable
? "start" : "stop", cmd
->channel
);
470 wl1271_debug(DEBUG_BOOT
, "tx %s cmd channel %d",
471 enable
? "start" : "stop", cmd
->channel
);
478 int wl1271_cmd_ps_mode(struct wl1271
*wl
, u8 ps_mode
, bool send
)
480 struct wl1271_cmd_ps_params
*ps_params
= NULL
;
483 /* FIXME: this should be in ps.c */
484 ret
= wl1271_acx_wake_up_conditions(wl
);
486 wl1271_error("couldn't set wake up conditions");
490 wl1271_debug(DEBUG_CMD
, "cmd set ps mode");
492 ps_params
= kzalloc(sizeof(*ps_params
), GFP_KERNEL
);
498 ps_params
->ps_mode
= ps_mode
;
499 ps_params
->send_null_data
= send
;
500 ps_params
->retries
= 5;
501 ps_params
->hang_over_period
= 128;
502 ps_params
->null_data_rate
= cpu_to_le32(1); /* 1 Mbps */
504 ret
= wl1271_cmd_send(wl
, CMD_SET_PS_MODE
, ps_params
,
505 sizeof(*ps_params
), 0);
507 wl1271_error("cmd set_ps_mode failed");
516 int wl1271_cmd_read_memory(struct wl1271
*wl
, u32 addr
, void *answer
,
519 struct cmd_read_write_memory
*cmd
;
522 wl1271_debug(DEBUG_CMD
, "cmd read memory");
524 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
530 WARN_ON(len
> MAX_READ_SIZE
);
531 len
= min_t(size_t, len
, MAX_READ_SIZE
);
533 cmd
->addr
= cpu_to_le32(addr
);
534 cmd
->size
= cpu_to_le32(len
);
536 ret
= wl1271_cmd_send(wl
, CMD_READ_MEMORY
, cmd
, sizeof(*cmd
),
539 wl1271_error("read memory command failed: %d", ret
);
543 /* the read command got in */
544 memcpy(answer
, cmd
->value
, len
);
551 int wl1271_cmd_scan(struct wl1271
*wl
, u8
*ssid
, size_t len
,
552 u8 active_scan
, u8 high_prio
, u8 band
,
556 struct wl1271_cmd_trigger_scan_to
*trigger
= NULL
;
557 struct wl1271_cmd_scan
*params
= NULL
;
558 struct ieee80211_channel
*channels
;
560 u16 scan_options
= 0;
563 if (band
== WL1271_SCAN_BAND_2_4_GHZ
)
564 ieee_band
= IEEE80211_BAND_2GHZ
;
565 else if (band
== WL1271_SCAN_BAND_DUAL
&& wl1271_11a_enabled())
566 ieee_band
= IEEE80211_BAND_2GHZ
;
567 else if (band
== WL1271_SCAN_BAND_5_GHZ
&& wl1271_11a_enabled())
568 ieee_band
= IEEE80211_BAND_5GHZ
;
572 if (wl
->hw
->wiphy
->bands
[ieee_band
]->channels
== NULL
)
575 channels
= wl
->hw
->wiphy
->bands
[ieee_band
]->channels
;
576 n_ch
= wl
->hw
->wiphy
->bands
[ieee_band
]->n_channels
;
578 if (test_bit(WL1271_FLAG_SCANNING
, &wl
->flags
))
581 params
= kzalloc(sizeof(*params
), GFP_KERNEL
);
585 params
->params
.rx_config_options
= cpu_to_le32(CFG_RX_ALL_GOOD
);
586 params
->params
.rx_filter_options
=
587 cpu_to_le32(CFG_RX_PRSP_EN
| CFG_RX_MGMT_EN
| CFG_RX_BCN_EN
);
590 scan_options
|= WL1271_SCAN_OPT_PASSIVE
;
592 scan_options
|= WL1271_SCAN_OPT_PRIORITY_HIGH
;
593 params
->params
.scan_options
= cpu_to_le16(scan_options
);
595 params
->params
.num_probe_requests
= probe_requests
;
596 /* Let the fw autodetect suitable tx_rate for probes */
597 params
->params
.tx_rate
= 0;
598 params
->params
.tid_trigger
= 0;
599 params
->params
.scan_tag
= WL1271_SCAN_DEFAULT_TAG
;
601 if (band
== WL1271_SCAN_BAND_DUAL
)
602 params
->params
.band
= WL1271_SCAN_BAND_2_4_GHZ
;
604 params
->params
.band
= band
;
606 for (i
= 0, j
= 0; i
< n_ch
&& i
< WL1271_SCAN_MAX_CHANNELS
; i
++) {
607 if (!(channels
[i
].flags
& IEEE80211_CHAN_DISABLED
)) {
608 params
->channels
[j
].min_duration
=
609 cpu_to_le32(WL1271_SCAN_CHAN_MIN_DURATION
);
610 params
->channels
[j
].max_duration
=
611 cpu_to_le32(WL1271_SCAN_CHAN_MAX_DURATION
);
612 memset(¶ms
->channels
[j
].bssid_lsb
, 0xff, 4);
613 memset(¶ms
->channels
[j
].bssid_msb
, 0xff, 2);
614 params
->channels
[j
].early_termination
= 0;
615 params
->channels
[j
].tx_power_att
=
616 WL1271_SCAN_CURRENT_TX_PWR
;
617 params
->channels
[j
].channel
= channels
[i
].hw_value
;
622 params
->params
.num_channels
= j
;
625 params
->params
.ssid_len
= len
;
626 memcpy(params
->params
.ssid
, ssid
, len
);
629 ret
= wl1271_cmd_build_probe_req(wl
, ssid
, len
, ieee_band
);
631 wl1271_error("PROBE request template failed");
635 trigger
= kzalloc(sizeof(*trigger
), GFP_KERNEL
);
641 /* disable the timeout */
642 trigger
->timeout
= 0;
644 ret
= wl1271_cmd_send(wl
, CMD_TRIGGER_SCAN_TO
, trigger
,
645 sizeof(*trigger
), 0);
647 wl1271_error("trigger scan to failed for hw scan");
651 wl1271_dump(DEBUG_SCAN
, "SCAN: ", params
, sizeof(*params
));
653 set_bit(WL1271_FLAG_SCANNING
, &wl
->flags
);
654 if (wl1271_11a_enabled()) {
655 wl
->scan
.state
= band
;
656 if (band
== WL1271_SCAN_BAND_DUAL
) {
657 wl
->scan
.active
= active_scan
;
658 wl
->scan
.high_prio
= high_prio
;
659 wl
->scan
.probe_requests
= probe_requests
;
661 wl
->scan
.ssid_len
= len
;
662 memcpy(wl
->scan
.ssid
, ssid
, len
);
664 wl
->scan
.ssid_len
= 0;
668 ret
= wl1271_cmd_send(wl
, CMD_SCAN
, params
, sizeof(*params
), 0);
670 wl1271_error("SCAN failed");
671 clear_bit(WL1271_FLAG_SCANNING
, &wl
->flags
);
680 int wl1271_cmd_template_set(struct wl1271
*wl
, u16 template_id
,
681 void *buf
, size_t buf_len
)
683 struct wl1271_cmd_template_set
*cmd
;
686 wl1271_debug(DEBUG_CMD
, "cmd template_set %d", template_id
);
688 WARN_ON(buf_len
> WL1271_CMD_TEMPL_MAX_SIZE
);
689 buf_len
= min_t(size_t, buf_len
, WL1271_CMD_TEMPL_MAX_SIZE
);
691 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
697 cmd
->len
= cpu_to_le16(buf_len
);
698 cmd
->template_type
= template_id
;
699 cmd
->enabled_rates
= cpu_to_le32(wl
->conf
.tx
.rc_conf
.enabled_rates
);
700 cmd
->short_retry_limit
= wl
->conf
.tx
.rc_conf
.short_retry_limit
;
701 cmd
->long_retry_limit
= wl
->conf
.tx
.rc_conf
.long_retry_limit
;
704 memcpy(cmd
->template_data
, buf
, buf_len
);
706 ret
= wl1271_cmd_send(wl
, CMD_SET_TEMPLATE
, cmd
, sizeof(*cmd
), 0);
708 wl1271_warning("cmd set_template failed: %d", ret
);
719 static int wl1271_build_basic_rates(u8
*rates
, u8 band
)
723 if (band
== IEEE80211_BAND_2GHZ
) {
725 IEEE80211_BASIC_RATE_MASK
| IEEE80211_CCK_RATE_1MB
;
727 IEEE80211_BASIC_RATE_MASK
| IEEE80211_CCK_RATE_2MB
;
729 IEEE80211_BASIC_RATE_MASK
| IEEE80211_CCK_RATE_5MB
;
731 IEEE80211_BASIC_RATE_MASK
| IEEE80211_CCK_RATE_11MB
;
732 } else if (band
== IEEE80211_BAND_5GHZ
) {
734 IEEE80211_BASIC_RATE_MASK
| IEEE80211_OFDM_RATE_6MB
;
736 IEEE80211_BASIC_RATE_MASK
| IEEE80211_OFDM_RATE_12MB
;
738 IEEE80211_BASIC_RATE_MASK
| IEEE80211_OFDM_RATE_24MB
;
740 wl1271_error("build_basic_rates invalid band: %d", band
);
746 static int wl1271_build_extended_rates(u8
*rates
, u8 band
)
750 if (band
== IEEE80211_BAND_2GHZ
) {
751 rates
[index
++] = IEEE80211_OFDM_RATE_6MB
;
752 rates
[index
++] = IEEE80211_OFDM_RATE_9MB
;
753 rates
[index
++] = IEEE80211_OFDM_RATE_12MB
;
754 rates
[index
++] = IEEE80211_OFDM_RATE_18MB
;
755 rates
[index
++] = IEEE80211_OFDM_RATE_24MB
;
756 rates
[index
++] = IEEE80211_OFDM_RATE_36MB
;
757 rates
[index
++] = IEEE80211_OFDM_RATE_48MB
;
758 rates
[index
++] = IEEE80211_OFDM_RATE_54MB
;
759 } else if (band
== IEEE80211_BAND_5GHZ
) {
761 IEEE80211_BASIC_RATE_MASK
| IEEE80211_OFDM_RATE_9MB
;
763 IEEE80211_BASIC_RATE_MASK
| IEEE80211_OFDM_RATE_18MB
;
765 IEEE80211_BASIC_RATE_MASK
| IEEE80211_OFDM_RATE_24MB
;
767 IEEE80211_BASIC_RATE_MASK
| IEEE80211_OFDM_RATE_36MB
;
769 IEEE80211_BASIC_RATE_MASK
| IEEE80211_OFDM_RATE_48MB
;
771 IEEE80211_BASIC_RATE_MASK
| IEEE80211_OFDM_RATE_54MB
;
773 wl1271_error("build_basic_rates invalid band: %d", band
);
779 int wl1271_cmd_build_null_data(struct wl1271
*wl
)
781 struct wl12xx_null_data_template
template;
783 if (!is_zero_ether_addr(wl
->bssid
)) {
784 memcpy(template.header
.da
, wl
->bssid
, ETH_ALEN
);
785 memcpy(template.header
.bssid
, wl
->bssid
, ETH_ALEN
);
787 memset(template.header
.da
, 0xff, ETH_ALEN
);
788 memset(template.header
.bssid
, 0xff, ETH_ALEN
);
791 memcpy(template.header
.sa
, wl
->mac_addr
, ETH_ALEN
);
792 template.header
.frame_ctl
= cpu_to_le16(IEEE80211_FTYPE_DATA
|
793 IEEE80211_STYPE_NULLFUNC
|
794 IEEE80211_FCTL_TODS
);
796 return wl1271_cmd_template_set(wl
, CMD_TEMPL_NULL_DATA
, &template,
801 int wl1271_cmd_build_ps_poll(struct wl1271
*wl
, u16 aid
)
803 struct wl12xx_ps_poll_template
template;
805 memcpy(template.bssid
, wl
->bssid
, ETH_ALEN
);
806 memcpy(template.ta
, wl
->mac_addr
, ETH_ALEN
);
808 /* aid in PS-Poll has its two MSBs each set to 1 */
809 template.aid
= cpu_to_le16(1 << 15 | 1 << 14 | aid
);
811 template.fc
= cpu_to_le16(IEEE80211_FTYPE_CTL
| IEEE80211_STYPE_PSPOLL
);
813 return wl1271_cmd_template_set(wl
, CMD_TEMPL_PS_POLL
, &template,
818 int wl1271_cmd_build_probe_req(struct wl1271
*wl
, u8
*ssid
, size_t ssid_len
,
821 struct wl12xx_probe_req_template
template;
822 struct wl12xx_ie_rates
*rates
;
827 ptr
= (char *)&template;
828 size
= sizeof(struct ieee80211_header
);
830 memset(template.header
.da
, 0xff, ETH_ALEN
);
831 memset(template.header
.bssid
, 0xff, ETH_ALEN
);
832 memcpy(template.header
.sa
, wl
->mac_addr
, ETH_ALEN
);
833 template.header
.frame_ctl
= cpu_to_le16(IEEE80211_STYPE_PROBE_REQ
);
837 template.ssid
.header
.id
= WLAN_EID_SSID
;
838 template.ssid
.header
.len
= ssid_len
;
839 if (ssid_len
&& ssid
)
840 memcpy(template.ssid
.ssid
, ssid
, ssid_len
);
841 size
+= sizeof(struct wl12xx_ie_header
) + ssid_len
;
845 rates
= (struct wl12xx_ie_rates
*)ptr
;
846 rates
->header
.id
= WLAN_EID_SUPP_RATES
;
847 rates
->header
.len
= wl1271_build_basic_rates(rates
->rates
, band
);
848 size
+= sizeof(struct wl12xx_ie_header
) + rates
->header
.len
;
849 ptr
+= sizeof(struct wl12xx_ie_header
) + rates
->header
.len
;
852 rates
= (struct wl12xx_ie_rates
*)ptr
;
853 rates
->header
.id
= WLAN_EID_EXT_SUPP_RATES
;
854 rates
->header
.len
= wl1271_build_extended_rates(rates
->rates
, band
);
855 size
+= sizeof(struct wl12xx_ie_header
) + rates
->header
.len
;
857 wl1271_dump(DEBUG_SCAN
, "PROBE REQ: ", &template, size
);
859 if (band
== IEEE80211_BAND_2GHZ
)
860 ret
= wl1271_cmd_template_set(wl
, CMD_TEMPL_CFG_PROBE_REQ_2_4
,
863 ret
= wl1271_cmd_template_set(wl
, CMD_TEMPL_CFG_PROBE_REQ_5
,
868 int wl1271_cmd_set_default_wep_key(struct wl1271
*wl
, u8 id
)
870 struct wl1271_cmd_set_keys
*cmd
;
873 wl1271_debug(DEBUG_CMD
, "cmd set_default_wep_key %d", id
);
875 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
882 cmd
->key_action
= cpu_to_le16(KEY_SET_ID
);
883 cmd
->key_type
= KEY_WEP
;
885 ret
= wl1271_cmd_send(wl
, CMD_SET_KEYS
, cmd
, sizeof(*cmd
), 0);
887 wl1271_warning("cmd set_default_wep_key failed: %d", ret
);
897 int wl1271_cmd_set_key(struct wl1271
*wl
, u16 action
, u8 id
, u8 key_type
,
898 u8 key_size
, const u8
*key
, const u8
*addr
,
899 u32 tx_seq_32
, u16 tx_seq_16
)
901 struct wl1271_cmd_set_keys
*cmd
;
904 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
910 if (key_type
!= KEY_WEP
)
911 memcpy(cmd
->addr
, addr
, ETH_ALEN
);
913 cmd
->key_action
= cpu_to_le16(action
);
914 cmd
->key_size
= key_size
;
915 cmd
->key_type
= key_type
;
917 cmd
->ac_seq_num16
[0] = cpu_to_le16(tx_seq_16
);
918 cmd
->ac_seq_num32
[0] = cpu_to_le32(tx_seq_32
);
920 /* we have only one SSID profile */
921 cmd
->ssid_profile
= 0;
925 if (key_type
== KEY_TKIP
) {
927 * We get the key in the following form:
928 * TKIP (16 bytes) - TX MIC (8 bytes) - RX MIC (8 bytes)
929 * but the target is expecting:
930 * TKIP - RX MIC - TX MIC
932 memcpy(cmd
->key
, key
, 16);
933 memcpy(cmd
->key
+ 16, key
+ 24, 8);
934 memcpy(cmd
->key
+ 24, key
+ 16, 8);
937 memcpy(cmd
->key
, key
, key_size
);
940 wl1271_dump(DEBUG_CRYPT
, "TARGET KEY: ", cmd
, sizeof(*cmd
));
942 ret
= wl1271_cmd_send(wl
, CMD_SET_KEYS
, cmd
, sizeof(*cmd
), 0);
944 wl1271_warning("could not set keys");
954 int wl1271_cmd_disconnect(struct wl1271
*wl
)
956 struct wl1271_cmd_disconnect
*cmd
;
959 wl1271_debug(DEBUG_CMD
, "cmd disconnect");
961 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
967 cmd
->rx_config_options
= cpu_to_le32(wl
->rx_config
);
968 cmd
->rx_filter_options
= cpu_to_le32(wl
->rx_filter
);
969 /* disconnect reason is not used in immediate disconnections */
970 cmd
->type
= DISCONNECT_IMMEDIATE
;
972 ret
= wl1271_cmd_send(wl
, CMD_DISCONNECT
, cmd
, sizeof(*cmd
), 0);
974 wl1271_error("failed to send disconnect command");