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");