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_acx.h"
34 #include "wl12xx_80211.h"
35 #include "wl1271_cmd.h"
38 * send command to firmware
42 * @buf: buffer containing the command, must work with dma
43 * @len: length of the buffer
45 int wl1271_cmd_send(struct wl1271
*wl
, u16 id
, void *buf
, size_t len
,
48 struct wl1271_cmd_header
*cmd
;
49 unsigned long timeout
;
55 cmd
->id
= cpu_to_le16(id
);
58 WARN_ON(len
% 4 != 0);
60 wl1271_spi_write(wl
, wl
->cmd_box_addr
, buf
, len
, false);
62 wl1271_spi_write32(wl
, ACX_REG_INTERRUPT_TRIG
, INTR_TRIG_CMD
);
64 timeout
= jiffies
+ msecs_to_jiffies(WL1271_COMMAND_TIMEOUT
);
66 intr
= wl1271_spi_read32(wl
, ACX_REG_INTERRUPT_NO_CLEAR
);
67 while (!(intr
& WL1271_ACX_INTR_CMD_COMPLETE
)) {
68 if (time_after(jiffies
, timeout
)) {
69 wl1271_error("command complete timeout");
76 intr
= wl1271_spi_read32(wl
, ACX_REG_INTERRUPT_NO_CLEAR
);
79 /* read back the status code of the command */
81 res_len
= sizeof(struct wl1271_cmd_header
);
82 wl1271_spi_read(wl
, wl
->cmd_box_addr
, cmd
, res_len
, false);
84 status
= le16_to_cpu(cmd
->status
);
85 if (status
!= CMD_STATUS_SUCCESS
) {
86 wl1271_error("command execute failure %d", status
);
90 wl1271_spi_write32(wl
, ACX_REG_INTERRUPT_ACK
,
91 WL1271_ACX_INTR_CMD_COMPLETE
);
97 static int wl1271_cmd_cal_channel_tune(struct wl1271
*wl
)
99 struct wl1271_cmd_cal_channel_tune
*cmd
;
102 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
106 cmd
->test
.id
= TEST_CMD_CHANNEL_TUNE
;
108 cmd
->band
= WL1271_CHANNEL_TUNE_BAND_2_4
;
109 /* set up any channel, 7 is in the middle of the range */
112 ret
= wl1271_cmd_test(wl
, cmd
, sizeof(*cmd
), 0);
114 wl1271_warning("TEST_CMD_CHANNEL_TUNE failed");
120 static int wl1271_cmd_cal_update_ref_point(struct wl1271
*wl
)
122 struct wl1271_cmd_cal_update_ref_point
*cmd
;
125 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
129 cmd
->test
.id
= TEST_CMD_UPDATE_PD_REFERENCE_POINT
;
131 /* FIXME: still waiting for the correct values */
133 cmd
->ref_detector
= 0;
135 cmd
->sub_band
= WL1271_PD_REFERENCE_POINT_BAND_B_G
;
137 ret
= wl1271_cmd_test(wl
, cmd
, sizeof(*cmd
), 0);
139 wl1271_warning("TEST_CMD_UPDATE_PD_REFERENCE_POINT failed");
145 static int wl1271_cmd_cal_p2g(struct wl1271
*wl
)
147 struct wl1271_cmd_cal_p2g
*cmd
;
150 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
154 cmd
->test
.id
= TEST_CMD_P2G_CAL
;
156 cmd
->sub_band_mask
= WL1271_CAL_P2G_BAND_B_G
;
158 ret
= wl1271_cmd_test(wl
, cmd
, sizeof(*cmd
), 0);
160 wl1271_warning("TEST_CMD_P2G_CAL failed");
166 static int wl1271_cmd_cal(struct wl1271
*wl
)
169 * FIXME: we must make sure that we're not sleeping when calibration
174 wl1271_notice("performing tx calibration");
176 ret
= wl1271_cmd_cal_channel_tune(wl
);
180 ret
= wl1271_cmd_cal_update_ref_point(wl
);
184 ret
= wl1271_cmd_cal_p2g(wl
);
191 int wl1271_cmd_general_parms(struct wl1271
*wl
)
193 struct wl1271_general_parms_cmd
*gen_parms
;
199 gen_parms
= kzalloc(sizeof(*gen_parms
), GFP_KERNEL
);
203 gen_parms
->test
.id
= TEST_CMD_INI_FILE_GENERAL_PARAM
;
205 memcpy(gen_parms
->params
, wl
->nvs
->general_params
,
206 WL1271_NVS_GENERAL_PARAMS_SIZE
);
208 ret
= wl1271_cmd_test(wl
, gen_parms
, sizeof(*gen_parms
), 0);
210 wl1271_warning("CMD_INI_FILE_GENERAL_PARAM failed");
216 int wl1271_cmd_radio_parms(struct wl1271
*wl
)
218 struct wl1271_radio_parms_cmd
*radio_parms
;
219 struct conf_radio_parms
*rparam
= &wl
->conf
.init
.radioparam
;
225 radio_parms
= kzalloc(sizeof(*radio_parms
), GFP_KERNEL
);
229 radio_parms
->test
.id
= TEST_CMD_INI_FILE_RADIO_PARAM
;
231 memcpy(radio_parms
->stat_radio_params
, wl
->nvs
->stat_radio_params
,
232 WL1271_NVS_STAT_RADIO_PARAMS_SIZE
);
233 memcpy(radio_parms
->dyn_radio_params
,
234 wl
->nvs
->dyn_radio_params
[rparam
->fem
],
235 WL1271_NVS_DYN_RADIO_PARAMS_SIZE
);
237 /* FIXME: current NVS is missing 5GHz parameters */
239 wl1271_dump(DEBUG_CMD
, "TEST_CMD_INI_FILE_RADIO_PARAM: ",
240 radio_parms
, sizeof(*radio_parms
));
242 ret
= wl1271_cmd_test(wl
, radio_parms
, sizeof(*radio_parms
), 0);
244 wl1271_warning("CMD_INI_FILE_RADIO_PARAM failed");
250 int wl1271_cmd_join(struct wl1271
*wl
)
252 static bool do_cal
= true;
253 struct wl1271_cmd_join
*join
;
257 /* FIXME: remove when we get calibration from the factory */
259 ret
= wl1271_cmd_cal(wl
);
261 wl1271_warning("couldn't calibrate");
266 join
= kzalloc(sizeof(*join
), GFP_KERNEL
);
272 wl1271_debug(DEBUG_CMD
, "cmd join");
274 /* Reverse order BSSID */
275 bssid
= (u8
*) &join
->bssid_lsb
;
276 for (i
= 0; i
< ETH_ALEN
; i
++)
277 bssid
[i
] = wl
->bssid
[ETH_ALEN
- i
- 1];
279 join
->rx_config_options
= cpu_to_le32(wl
->rx_config
);
280 join
->rx_filter_options
= cpu_to_le32(wl
->rx_filter
);
281 join
->bss_type
= wl
->bss_type
;
284 * FIXME: disable temporarily all filters because after commit
285 * 9cef8737 "mac80211: fix managed mode BSSID handling" broke
286 * association. The filter logic needs to be implemented properly
287 * and once that is done, this hack can be removed.
289 join
->rx_config_options
= cpu_to_le32(0);
290 join
->rx_filter_options
= cpu_to_le32(WL1271_DEFAULT_RX_FILTER
);
292 if (wl
->band
== IEEE80211_BAND_2GHZ
)
293 join
->basic_rate_set
= cpu_to_le32(CONF_HW_BIT_RATE_1MBPS
|
294 CONF_HW_BIT_RATE_2MBPS
|
295 CONF_HW_BIT_RATE_5_5MBPS
|
296 CONF_HW_BIT_RATE_11MBPS
);
298 join
->bss_type
|= WL1271_JOIN_CMD_BSS_TYPE_5GHZ
;
299 join
->basic_rate_set
= cpu_to_le32(CONF_HW_BIT_RATE_6MBPS
|
300 CONF_HW_BIT_RATE_12MBPS
|
301 CONF_HW_BIT_RATE_24MBPS
);
304 join
->beacon_interval
= cpu_to_le16(WL1271_DEFAULT_BEACON_INT
);
305 join
->dtim_interval
= WL1271_DEFAULT_DTIM_PERIOD
;
307 join
->channel
= wl
->channel
;
308 join
->ssid_len
= wl
->ssid_len
;
309 memcpy(join
->ssid
, wl
->ssid
, wl
->ssid_len
);
310 join
->ctrl
= WL1271_JOIN_CMD_CTRL_TX_FLUSH
;
312 /* increment the session counter */
313 wl
->session_counter
++;
314 if (wl
->session_counter
>= SESSION_COUNTER_MAX
)
315 wl
->session_counter
= 0;
317 join
->ctrl
|= wl
->session_counter
<< WL1271_JOIN_CMD_TX_SESSION_OFFSET
;
319 /* reset TX security counters */
320 wl
->tx_security_last_seq
= 0;
321 wl
->tx_security_seq_16
= 0;
322 wl
->tx_security_seq_32
= 0;
324 ret
= wl1271_cmd_send(wl
, CMD_START_JOIN
, join
, sizeof(*join
), 0);
326 wl1271_error("failed to initiate cmd join");
331 * ugly hack: we should wait for JOIN_EVENT_COMPLETE_ID but to
332 * simplify locking we just sleep instead, for now
344 * send test command to firmware
347 * @buf: buffer containing the command, with all headers, must work with dma
348 * @len: length of the buffer
349 * @answer: is answer needed
351 int wl1271_cmd_test(struct wl1271
*wl
, void *buf
, size_t buf_len
, u8 answer
)
356 wl1271_debug(DEBUG_CMD
, "cmd test");
361 ret
= wl1271_cmd_send(wl
, CMD_TEST
, buf
, buf_len
, res_len
);
364 wl1271_warning("TEST command failed");
372 * read acx from firmware
376 * @buf: buffer for the response, including all headers, must work with dma
377 * @len: lenght of buf
379 int wl1271_cmd_interrogate(struct wl1271
*wl
, u16 id
, void *buf
, size_t len
)
381 struct acx_header
*acx
= buf
;
384 wl1271_debug(DEBUG_CMD
, "cmd interrogate");
386 acx
->id
= cpu_to_le16(id
);
388 /* payload length, does not include any headers */
389 acx
->len
= cpu_to_le16(len
- sizeof(*acx
));
391 ret
= wl1271_cmd_send(wl
, CMD_INTERROGATE
, acx
, sizeof(*acx
), len
);
393 wl1271_error("INTERROGATE command failed");
399 * write acx value to firmware
403 * @buf: buffer containing acx, including all headers, must work with dma
404 * @len: length of buf
406 int wl1271_cmd_configure(struct wl1271
*wl
, u16 id
, void *buf
, size_t len
)
408 struct acx_header
*acx
= buf
;
411 wl1271_debug(DEBUG_CMD
, "cmd configure");
413 acx
->id
= cpu_to_le16(id
);
415 /* payload length, does not include any headers */
416 acx
->len
= cpu_to_le16(len
- sizeof(*acx
));
418 ret
= wl1271_cmd_send(wl
, CMD_CONFIGURE
, acx
, len
, 0);
420 wl1271_warning("CONFIGURE command NOK");
427 int wl1271_cmd_data_path(struct wl1271
*wl
, bool enable
)
429 struct cmd_enabledisable_path
*cmd
;
433 wl1271_debug(DEBUG_CMD
, "cmd data path");
435 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
441 /* the channel here is only used for calibration, so hardcoded to 1 */
445 cmd_rx
= CMD_ENABLE_RX
;
446 cmd_tx
= CMD_ENABLE_TX
;
448 cmd_rx
= CMD_DISABLE_RX
;
449 cmd_tx
= CMD_DISABLE_TX
;
452 ret
= wl1271_cmd_send(wl
, cmd_rx
, cmd
, sizeof(*cmd
), 0);
454 wl1271_error("rx %s cmd for channel %d failed",
455 enable
? "start" : "stop", cmd
->channel
);
459 wl1271_debug(DEBUG_BOOT
, "rx %s cmd channel %d",
460 enable
? "start" : "stop", cmd
->channel
);
462 ret
= wl1271_cmd_send(wl
, cmd_tx
, cmd
, sizeof(*cmd
), 0);
464 wl1271_error("tx %s cmd for channel %d failed",
465 enable
? "start" : "stop", cmd
->channel
);
469 wl1271_debug(DEBUG_BOOT
, "tx %s cmd channel %d",
470 enable
? "start" : "stop", cmd
->channel
);
477 int wl1271_cmd_ps_mode(struct wl1271
*wl
, u8 ps_mode
, bool send
)
479 struct wl1271_cmd_ps_params
*ps_params
= NULL
;
482 /* FIXME: this should be in ps.c */
483 ret
= wl1271_acx_wake_up_conditions(wl
);
485 wl1271_error("couldn't set wake up conditions");
489 wl1271_debug(DEBUG_CMD
, "cmd set ps mode");
491 ps_params
= kzalloc(sizeof(*ps_params
), GFP_KERNEL
);
497 ps_params
->ps_mode
= ps_mode
;
498 ps_params
->send_null_data
= send
;
499 ps_params
->retries
= 5;
500 ps_params
->hang_over_period
= 128;
501 ps_params
->null_data_rate
= cpu_to_le32(1); /* 1 Mbps */
503 ret
= wl1271_cmd_send(wl
, CMD_SET_PS_MODE
, ps_params
,
504 sizeof(*ps_params
), 0);
506 wl1271_error("cmd set_ps_mode failed");
515 int wl1271_cmd_read_memory(struct wl1271
*wl
, u32 addr
, void *answer
,
518 struct cmd_read_write_memory
*cmd
;
521 wl1271_debug(DEBUG_CMD
, "cmd read memory");
523 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
529 WARN_ON(len
> MAX_READ_SIZE
);
530 len
= min_t(size_t, len
, MAX_READ_SIZE
);
532 cmd
->addr
= cpu_to_le32(addr
);
533 cmd
->size
= cpu_to_le32(len
);
535 ret
= wl1271_cmd_send(wl
, CMD_READ_MEMORY
, cmd
, sizeof(*cmd
),
538 wl1271_error("read memory command failed: %d", ret
);
542 /* the read command got in */
543 memcpy(answer
, cmd
->value
, len
);
550 int wl1271_cmd_scan(struct wl1271
*wl
, u8
*ssid
, size_t len
,
551 u8 active_scan
, u8 high_prio
, u8 band
,
555 struct wl1271_cmd_trigger_scan_to
*trigger
= NULL
;
556 struct wl1271_cmd_scan
*params
= NULL
;
557 struct ieee80211_channel
*channels
;
559 u16 scan_options
= 0;
562 if (band
== WL1271_SCAN_BAND_2_4_GHZ
)
563 ieee_band
= IEEE80211_BAND_2GHZ
;
564 else if (band
== WL1271_SCAN_BAND_DUAL
&& wl1271_11a_enabled())
565 ieee_band
= IEEE80211_BAND_2GHZ
;
566 else if (band
== WL1271_SCAN_BAND_5_GHZ
&& wl1271_11a_enabled())
567 ieee_band
= IEEE80211_BAND_5GHZ
;
571 if (wl
->hw
->wiphy
->bands
[ieee_band
]->channels
== NULL
)
574 channels
= wl
->hw
->wiphy
->bands
[ieee_band
]->channels
;
575 n_ch
= wl
->hw
->wiphy
->bands
[ieee_band
]->n_channels
;
577 if (test_bit(WL1271_FLAG_SCANNING
, &wl
->flags
))
580 params
= kzalloc(sizeof(*params
), GFP_KERNEL
);
584 params
->params
.rx_config_options
= cpu_to_le32(CFG_RX_ALL_GOOD
);
585 params
->params
.rx_filter_options
=
586 cpu_to_le32(CFG_RX_PRSP_EN
| CFG_RX_MGMT_EN
| CFG_RX_BCN_EN
);
589 scan_options
|= WL1271_SCAN_OPT_PASSIVE
;
591 scan_options
|= WL1271_SCAN_OPT_PRIORITY_HIGH
;
592 params
->params
.scan_options
= cpu_to_le16(scan_options
);
594 params
->params
.num_probe_requests
= probe_requests
;
595 /* Let the fw autodetect suitable tx_rate for probes */
596 params
->params
.tx_rate
= 0;
597 params
->params
.tid_trigger
= 0;
598 params
->params
.scan_tag
= WL1271_SCAN_DEFAULT_TAG
;
600 if (band
== WL1271_SCAN_BAND_DUAL
)
601 params
->params
.band
= WL1271_SCAN_BAND_2_4_GHZ
;
603 params
->params
.band
= band
;
605 for (i
= 0, j
= 0; i
< n_ch
&& i
< WL1271_SCAN_MAX_CHANNELS
; i
++) {
606 if (!(channels
[i
].flags
& IEEE80211_CHAN_DISABLED
)) {
607 params
->channels
[j
].min_duration
=
608 cpu_to_le32(WL1271_SCAN_CHAN_MIN_DURATION
);
609 params
->channels
[j
].max_duration
=
610 cpu_to_le32(WL1271_SCAN_CHAN_MAX_DURATION
);
611 memset(¶ms
->channels
[j
].bssid_lsb
, 0xff, 4);
612 memset(¶ms
->channels
[j
].bssid_msb
, 0xff, 2);
613 params
->channels
[j
].early_termination
= 0;
614 params
->channels
[j
].tx_power_att
=
615 WL1271_SCAN_CURRENT_TX_PWR
;
616 params
->channels
[j
].channel
= channels
[i
].hw_value
;
621 params
->params
.num_channels
= j
;
624 params
->params
.ssid_len
= len
;
625 memcpy(params
->params
.ssid
, ssid
, len
);
628 ret
= wl1271_cmd_build_probe_req(wl
, ssid
, len
, ieee_band
);
630 wl1271_error("PROBE request template failed");
634 trigger
= kzalloc(sizeof(*trigger
), GFP_KERNEL
);
640 /* disable the timeout */
641 trigger
->timeout
= 0;
643 ret
= wl1271_cmd_send(wl
, CMD_TRIGGER_SCAN_TO
, trigger
,
644 sizeof(*trigger
), 0);
646 wl1271_error("trigger scan to failed for hw scan");
650 wl1271_dump(DEBUG_SCAN
, "SCAN: ", params
, sizeof(*params
));
652 set_bit(WL1271_FLAG_SCANNING
, &wl
->flags
);
653 if (wl1271_11a_enabled()) {
654 wl
->scan
.state
= band
;
655 if (band
== WL1271_SCAN_BAND_DUAL
) {
656 wl
->scan
.active
= active_scan
;
657 wl
->scan
.high_prio
= high_prio
;
658 wl
->scan
.probe_requests
= probe_requests
;
660 wl
->scan
.ssid_len
= len
;
661 memcpy(wl
->scan
.ssid
, ssid
, len
);
663 wl
->scan
.ssid_len
= 0;
667 ret
= wl1271_cmd_send(wl
, CMD_SCAN
, params
, sizeof(*params
), 0);
669 wl1271_error("SCAN failed");
670 clear_bit(WL1271_FLAG_SCANNING
, &wl
->flags
);
679 int wl1271_cmd_template_set(struct wl1271
*wl
, u16 template_id
,
680 void *buf
, size_t buf_len
)
682 struct wl1271_cmd_template_set
*cmd
;
685 wl1271_debug(DEBUG_CMD
, "cmd template_set %d", template_id
);
687 WARN_ON(buf_len
> WL1271_CMD_TEMPL_MAX_SIZE
);
688 buf_len
= min_t(size_t, buf_len
, WL1271_CMD_TEMPL_MAX_SIZE
);
690 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
696 cmd
->len
= cpu_to_le16(buf_len
);
697 cmd
->template_type
= template_id
;
698 cmd
->enabled_rates
= cpu_to_le32(wl
->conf
.tx
.rc_conf
.enabled_rates
);
699 cmd
->short_retry_limit
= wl
->conf
.tx
.rc_conf
.short_retry_limit
;
700 cmd
->long_retry_limit
= wl
->conf
.tx
.rc_conf
.long_retry_limit
;
703 memcpy(cmd
->template_data
, buf
, buf_len
);
705 ret
= wl1271_cmd_send(wl
, CMD_SET_TEMPLATE
, cmd
, sizeof(*cmd
), 0);
707 wl1271_warning("cmd set_template failed: %d", ret
);
718 static int wl1271_build_basic_rates(u8
*rates
, u8 band
)
722 if (band
== IEEE80211_BAND_2GHZ
) {
724 IEEE80211_BASIC_RATE_MASK
| IEEE80211_CCK_RATE_1MB
;
726 IEEE80211_BASIC_RATE_MASK
| IEEE80211_CCK_RATE_2MB
;
728 IEEE80211_BASIC_RATE_MASK
| IEEE80211_CCK_RATE_5MB
;
730 IEEE80211_BASIC_RATE_MASK
| IEEE80211_CCK_RATE_11MB
;
731 } else if (band
== IEEE80211_BAND_5GHZ
) {
733 IEEE80211_BASIC_RATE_MASK
| IEEE80211_OFDM_RATE_6MB
;
735 IEEE80211_BASIC_RATE_MASK
| IEEE80211_OFDM_RATE_12MB
;
737 IEEE80211_BASIC_RATE_MASK
| IEEE80211_OFDM_RATE_24MB
;
739 wl1271_error("build_basic_rates invalid band: %d", band
);
745 static int wl1271_build_extended_rates(u8
*rates
, u8 band
)
749 if (band
== IEEE80211_BAND_2GHZ
) {
750 rates
[index
++] = IEEE80211_OFDM_RATE_6MB
;
751 rates
[index
++] = IEEE80211_OFDM_RATE_9MB
;
752 rates
[index
++] = IEEE80211_OFDM_RATE_12MB
;
753 rates
[index
++] = IEEE80211_OFDM_RATE_18MB
;
754 rates
[index
++] = IEEE80211_OFDM_RATE_24MB
;
755 rates
[index
++] = IEEE80211_OFDM_RATE_36MB
;
756 rates
[index
++] = IEEE80211_OFDM_RATE_48MB
;
757 rates
[index
++] = IEEE80211_OFDM_RATE_54MB
;
758 } else if (band
== IEEE80211_BAND_5GHZ
) {
760 IEEE80211_BASIC_RATE_MASK
| IEEE80211_OFDM_RATE_9MB
;
762 IEEE80211_BASIC_RATE_MASK
| IEEE80211_OFDM_RATE_18MB
;
764 IEEE80211_BASIC_RATE_MASK
| IEEE80211_OFDM_RATE_24MB
;
766 IEEE80211_BASIC_RATE_MASK
| IEEE80211_OFDM_RATE_36MB
;
768 IEEE80211_BASIC_RATE_MASK
| IEEE80211_OFDM_RATE_48MB
;
770 IEEE80211_BASIC_RATE_MASK
| IEEE80211_OFDM_RATE_54MB
;
772 wl1271_error("build_basic_rates invalid band: %d", band
);
778 int wl1271_cmd_build_null_data(struct wl1271
*wl
)
780 struct wl12xx_null_data_template
template;
782 if (!is_zero_ether_addr(wl
->bssid
)) {
783 memcpy(template.header
.da
, wl
->bssid
, ETH_ALEN
);
784 memcpy(template.header
.bssid
, wl
->bssid
, ETH_ALEN
);
786 memset(template.header
.da
, 0xff, ETH_ALEN
);
787 memset(template.header
.bssid
, 0xff, ETH_ALEN
);
790 memcpy(template.header
.sa
, wl
->mac_addr
, ETH_ALEN
);
791 template.header
.frame_ctl
= cpu_to_le16(IEEE80211_FTYPE_DATA
|
792 IEEE80211_STYPE_NULLFUNC
|
793 IEEE80211_FCTL_TODS
);
795 return wl1271_cmd_template_set(wl
, CMD_TEMPL_NULL_DATA
, &template,
800 int wl1271_cmd_build_ps_poll(struct wl1271
*wl
, u16 aid
)
802 struct wl12xx_ps_poll_template
template;
804 memcpy(template.bssid
, wl
->bssid
, ETH_ALEN
);
805 memcpy(template.ta
, wl
->mac_addr
, ETH_ALEN
);
807 /* aid in PS-Poll has its two MSBs each set to 1 */
808 template.aid
= cpu_to_le16(1 << 15 | 1 << 14 | aid
);
810 template.fc
= cpu_to_le16(IEEE80211_FTYPE_CTL
| IEEE80211_STYPE_PSPOLL
);
812 return wl1271_cmd_template_set(wl
, CMD_TEMPL_PS_POLL
, &template,
817 int wl1271_cmd_build_probe_req(struct wl1271
*wl
, u8
*ssid
, size_t ssid_len
,
820 struct wl12xx_probe_req_template
template;
821 struct wl12xx_ie_rates
*rates
;
826 ptr
= (char *)&template;
827 size
= sizeof(struct ieee80211_header
);
829 memset(template.header
.da
, 0xff, ETH_ALEN
);
830 memset(template.header
.bssid
, 0xff, ETH_ALEN
);
831 memcpy(template.header
.sa
, wl
->mac_addr
, ETH_ALEN
);
832 template.header
.frame_ctl
= cpu_to_le16(IEEE80211_STYPE_PROBE_REQ
);
836 template.ssid
.header
.id
= WLAN_EID_SSID
;
837 template.ssid
.header
.len
= ssid_len
;
838 if (ssid_len
&& ssid
)
839 memcpy(template.ssid
.ssid
, ssid
, ssid_len
);
840 size
+= sizeof(struct wl12xx_ie_header
) + ssid_len
;
844 rates
= (struct wl12xx_ie_rates
*)ptr
;
845 rates
->header
.id
= WLAN_EID_SUPP_RATES
;
846 rates
->header
.len
= wl1271_build_basic_rates(rates
->rates
, band
);
847 size
+= sizeof(struct wl12xx_ie_header
) + rates
->header
.len
;
848 ptr
+= sizeof(struct wl12xx_ie_header
) + rates
->header
.len
;
851 rates
= (struct wl12xx_ie_rates
*)ptr
;
852 rates
->header
.id
= WLAN_EID_EXT_SUPP_RATES
;
853 rates
->header
.len
= wl1271_build_extended_rates(rates
->rates
, band
);
854 size
+= sizeof(struct wl12xx_ie_header
) + rates
->header
.len
;
856 wl1271_dump(DEBUG_SCAN
, "PROBE REQ: ", &template, size
);
858 if (band
== IEEE80211_BAND_2GHZ
)
859 ret
= wl1271_cmd_template_set(wl
, CMD_TEMPL_CFG_PROBE_REQ_2_4
,
862 ret
= wl1271_cmd_template_set(wl
, CMD_TEMPL_CFG_PROBE_REQ_5
,
867 int wl1271_cmd_set_default_wep_key(struct wl1271
*wl
, u8 id
)
869 struct wl1271_cmd_set_keys
*cmd
;
872 wl1271_debug(DEBUG_CMD
, "cmd set_default_wep_key %d", id
);
874 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
881 cmd
->key_action
= cpu_to_le16(KEY_SET_ID
);
882 cmd
->key_type
= KEY_WEP
;
884 ret
= wl1271_cmd_send(wl
, CMD_SET_KEYS
, cmd
, sizeof(*cmd
), 0);
886 wl1271_warning("cmd set_default_wep_key failed: %d", ret
);
896 int wl1271_cmd_set_key(struct wl1271
*wl
, u16 action
, u8 id
, u8 key_type
,
897 u8 key_size
, const u8
*key
, const u8
*addr
,
898 u32 tx_seq_32
, u16 tx_seq_16
)
900 struct wl1271_cmd_set_keys
*cmd
;
903 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
909 if (key_type
!= KEY_WEP
)
910 memcpy(cmd
->addr
, addr
, ETH_ALEN
);
912 cmd
->key_action
= cpu_to_le16(action
);
913 cmd
->key_size
= key_size
;
914 cmd
->key_type
= key_type
;
916 cmd
->ac_seq_num16
[0] = cpu_to_le16(tx_seq_16
);
917 cmd
->ac_seq_num32
[0] = cpu_to_le32(tx_seq_32
);
919 /* we have only one SSID profile */
920 cmd
->ssid_profile
= 0;
924 if (key_type
== KEY_TKIP
) {
926 * We get the key in the following form:
927 * TKIP (16 bytes) - TX MIC (8 bytes) - RX MIC (8 bytes)
928 * but the target is expecting:
929 * TKIP - RX MIC - TX MIC
931 memcpy(cmd
->key
, key
, 16);
932 memcpy(cmd
->key
+ 16, key
+ 24, 8);
933 memcpy(cmd
->key
+ 24, key
+ 16, 8);
936 memcpy(cmd
->key
, key
, key_size
);
939 wl1271_dump(DEBUG_CRYPT
, "TARGET KEY: ", cmd
, sizeof(*cmd
));
941 ret
= wl1271_cmd_send(wl
, CMD_SET_KEYS
, cmd
, sizeof(*cmd
), 0);
943 wl1271_warning("could not set keys");
953 int wl1271_cmd_disconnect(struct wl1271
*wl
)
955 struct wl1271_cmd_disconnect
*cmd
;
958 wl1271_debug(DEBUG_CMD
, "cmd disconnect");
960 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
966 cmd
->rx_config_options
= cpu_to_le32(wl
->rx_config
);
967 cmd
->rx_filter_options
= cpu_to_le32(wl
->rx_filter
);
968 /* disconnect reason is not used in immediate disconnections */
969 cmd
->type
= DISCONNECT_IMMEDIATE
;
971 ret
= wl1271_cmd_send(wl
, CMD_DISCONNECT
, cmd
, sizeof(*cmd
), 0);
973 wl1271_error("failed to send disconnect command");