blob: 360e33ed3ddb09b8b7ab69622be80569404027c1 [file] [log] [blame]
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001/*
2 * This file is part of wl1271
3 *
Juuso Oikarinen8bf29b02010-02-18 13:25:51 +02004 * Copyright (C) 2008-2010 Nokia Corporation
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03005 *
6 * Contact: Luciano Coelho <luciano.coelho@nokia.com>
7 *
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.
11 *
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.
16 *
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
20 * 02110-1301 USA
21 *
22 */
23
24#include <linux/module.h>
Luciano Coelhof5fc0f82009-08-06 16:25:28 +030025#include <linux/firmware.h>
26#include <linux/delay.h>
Luciano Coelhof5fc0f82009-08-06 16:25:28 +030027#include <linux/spi/spi.h>
28#include <linux/crc32.h>
29#include <linux/etherdevice.h>
Juuso Oikarinen1fba4972009-10-08 21:56:32 +030030#include <linux/vmalloc.h>
Juuso Oikarinena1dd8182010-03-18 12:26:31 +020031#include <linux/platform_device.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090032#include <linux/slab.h>
Ido Yariv341b7cd2011-03-31 10:07:01 +020033#include <linux/wl12xx.h>
Ido Yariv95dac04f2011-06-06 14:57:06 +030034#include <linux/sched.h>
Luciano Coelhof5fc0f82009-08-06 16:25:28 +030035
Shahar Levi00d20102010-11-08 11:20:10 +000036#include "wl12xx.h"
Luciano Coelhof5fc0f82009-08-06 16:25:28 +030037#include "wl12xx_80211.h"
Shahar Levi00d20102010-11-08 11:20:10 +000038#include "reg.h"
39#include "io.h"
40#include "event.h"
41#include "tx.h"
42#include "rx.h"
43#include "ps.h"
44#include "init.h"
45#include "debugfs.h"
46#include "cmd.h"
47#include "boot.h"
48#include "testmode.h"
49#include "scan.h"
Luciano Coelhof5fc0f82009-08-06 16:25:28 +030050
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +020051#define WL1271_BOOT_RETRIES 3
52
Juuso Oikarinen8a080482009-10-13 12:47:44 +030053static struct conf_drv_settings default_conf = {
54 .sg = {
Eliad Peller3be41122011-08-14 13:17:19 +030055 .params = {
56 [CONF_SG_ACL_BT_MASTER_MIN_BR] = 10,
57 [CONF_SG_ACL_BT_MASTER_MAX_BR] = 180,
58 [CONF_SG_ACL_BT_SLAVE_MIN_BR] = 10,
59 [CONF_SG_ACL_BT_SLAVE_MAX_BR] = 180,
60 [CONF_SG_ACL_BT_MASTER_MIN_EDR] = 10,
61 [CONF_SG_ACL_BT_MASTER_MAX_EDR] = 80,
62 [CONF_SG_ACL_BT_SLAVE_MIN_EDR] = 10,
63 [CONF_SG_ACL_BT_SLAVE_MAX_EDR] = 80,
64 [CONF_SG_ACL_WLAN_PS_MASTER_BR] = 8,
65 [CONF_SG_ACL_WLAN_PS_SLAVE_BR] = 8,
66 [CONF_SG_ACL_WLAN_PS_MASTER_EDR] = 20,
67 [CONF_SG_ACL_WLAN_PS_SLAVE_EDR] = 20,
68 [CONF_SG_ACL_WLAN_ACTIVE_MASTER_MIN_BR] = 20,
69 [CONF_SG_ACL_WLAN_ACTIVE_MASTER_MAX_BR] = 35,
70 [CONF_SG_ACL_WLAN_ACTIVE_SLAVE_MIN_BR] = 16,
71 [CONF_SG_ACL_WLAN_ACTIVE_SLAVE_MAX_BR] = 35,
72 [CONF_SG_ACL_WLAN_ACTIVE_MASTER_MIN_EDR] = 32,
73 [CONF_SG_ACL_WLAN_ACTIVE_MASTER_MAX_EDR] = 50,
74 [CONF_SG_ACL_WLAN_ACTIVE_SLAVE_MIN_EDR] = 28,
75 [CONF_SG_ACL_WLAN_ACTIVE_SLAVE_MAX_EDR] = 50,
76 [CONF_SG_ACL_ACTIVE_SCAN_WLAN_BR] = 10,
77 [CONF_SG_ACL_ACTIVE_SCAN_WLAN_EDR] = 20,
78 [CONF_SG_ACL_PASSIVE_SCAN_BT_BR] = 75,
79 [CONF_SG_ACL_PASSIVE_SCAN_WLAN_BR] = 15,
80 [CONF_SG_ACL_PASSIVE_SCAN_BT_EDR] = 27,
81 [CONF_SG_ACL_PASSIVE_SCAN_WLAN_EDR] = 17,
82 /* active scan params */
83 [CONF_SG_AUTO_SCAN_PROBE_REQ] = 170,
84 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3] = 50,
85 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP] = 100,
86 /* passive scan params */
87 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP_BR] = 800,
88 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP_EDR] = 200,
89 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3] = 200,
90 /* passive scan in dual antenna params */
91 [CONF_SG_CONSECUTIVE_HV3_IN_PASSIVE_SCAN] = 0,
92 [CONF_SG_BCN_HV3_COLLISION_THRESH_IN_PASSIVE_SCAN] = 0,
93 [CONF_SG_TX_RX_PROTECTION_BWIDTH_IN_PASSIVE_SCAN] = 0,
94 /* general params */
95 [CONF_SG_STA_FORCE_PS_IN_BT_SCO] = 1,
96 [CONF_SG_ANTENNA_CONFIGURATION] = 0,
97 [CONF_SG_BEACON_MISS_PERCENT] = 60,
98 [CONF_SG_DHCP_TIME] = 5000,
99 [CONF_SG_RXT] = 1200,
100 [CONF_SG_TXT] = 1000,
101 [CONF_SG_ADAPTIVE_RXT_TXT] = 1,
102 [CONF_SG_GENERAL_USAGE_BIT_MAP] = 3,
103 [CONF_SG_HV3_MAX_SERVED] = 6,
104 [CONF_SG_PS_POLL_TIMEOUT] = 10,
105 [CONF_SG_UPSD_TIMEOUT] = 10,
106 [CONF_SG_CONSECUTIVE_CTS_THRESHOLD] = 2,
107 [CONF_SG_STA_RX_WINDOW_AFTER_DTIM] = 5,
108 [CONF_SG_STA_CONNECTION_PROTECTION_TIME] = 30,
109 /* AP params */
110 [CONF_AP_BEACON_MISS_TX] = 3,
111 [CONF_AP_RX_WINDOW_AFTER_BEACON] = 10,
112 [CONF_AP_BEACON_WINDOW_INTERVAL] = 2,
113 [CONF_AP_CONNECTION_PROTECTION_TIME] = 0,
114 [CONF_AP_BT_ACL_VAL_BT_SERVE_TIME] = 25,
115 [CONF_AP_BT_ACL_VAL_WL_SERVE_TIME] = 25,
Arik Nemtsov801f8702011-04-18 14:15:20 +0300116 },
Juuso Oikarinen1b00f542010-03-18 12:26:30 +0200117 .state = CONF_SG_PROTECTIVE,
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300118 },
119 .rx = {
120 .rx_msdu_life_time = 512000,
121 .packet_detection_threshold = 0,
122 .ps_poll_timeout = 15,
123 .upsd_timeout = 15,
Arik Nemtsov5f704d12011-04-18 14:15:21 +0300124 .rts_threshold = IEEE80211_MAX_RTS_THRESHOLD,
Luciano Coelho3ed8f2c2009-12-11 15:40:54 +0200125 .rx_cca_threshold = 0,
126 .irq_blk_threshold = 0xFFFF,
127 .irq_pkt_threshold = 0,
128 .irq_timeout = 600,
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300129 .queue_type = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
130 },
131 .tx = {
132 .tx_energy_detection = 0,
Arik Nemtsov1e05a812010-10-16 17:44:51 +0200133 .sta_rc_conf = {
Juuso Oikarinenebba60c2010-04-01 11:38:20 +0300134 .enabled_rates = 0,
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300135 .short_retry_limit = 10,
136 .long_retry_limit = 10,
Arik Nemtsov1e05a812010-10-16 17:44:51 +0200137 .aflags = 0,
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300138 },
139 .ac_conf_count = 4,
140 .ac_conf = {
Juuso Oikarinen9987a9d2010-09-01 11:31:12 +0200141 [CONF_TX_AC_BE] = {
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300142 .ac = CONF_TX_AC_BE,
143 .cw_min = 15,
144 .cw_max = 63,
145 .aifsn = 3,
146 .tx_op_limit = 0,
147 },
Juuso Oikarinen9987a9d2010-09-01 11:31:12 +0200148 [CONF_TX_AC_BK] = {
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300149 .ac = CONF_TX_AC_BK,
150 .cw_min = 15,
151 .cw_max = 63,
152 .aifsn = 7,
153 .tx_op_limit = 0,
154 },
Juuso Oikarinen9987a9d2010-09-01 11:31:12 +0200155 [CONF_TX_AC_VI] = {
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300156 .ac = CONF_TX_AC_VI,
157 .cw_min = 15,
158 .cw_max = 63,
159 .aifsn = CONF_TX_AIFS_PIFS,
160 .tx_op_limit = 3008,
161 },
Juuso Oikarinen9987a9d2010-09-01 11:31:12 +0200162 [CONF_TX_AC_VO] = {
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300163 .ac = CONF_TX_AC_VO,
164 .cw_min = 15,
165 .cw_max = 63,
166 .aifsn = CONF_TX_AIFS_PIFS,
167 .tx_op_limit = 1504,
168 },
169 },
Arik Nemtsov3618f302011-06-26 10:36:03 +0300170 .max_tx_retries = 100,
171 .ap_aging_period = 300,
Juuso Oikarinen9987a9d2010-09-01 11:31:12 +0200172 .tid_conf_count = 4,
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300173 .tid_conf = {
Juuso Oikarinen9987a9d2010-09-01 11:31:12 +0200174 [CONF_TX_AC_BE] = {
175 .queue_id = CONF_TX_AC_BE,
176 .channel_type = CONF_CHANNEL_TYPE_EDCF,
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300177 .tsid = CONF_TX_AC_BE,
178 .ps_scheme = CONF_PS_SCHEME_LEGACY,
179 .ack_policy = CONF_ACK_POLICY_LEGACY,
180 .apsd_conf = {0, 0},
181 },
Juuso Oikarinen9987a9d2010-09-01 11:31:12 +0200182 [CONF_TX_AC_BK] = {
183 .queue_id = CONF_TX_AC_BK,
184 .channel_type = CONF_CHANNEL_TYPE_EDCF,
185 .tsid = CONF_TX_AC_BK,
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300186 .ps_scheme = CONF_PS_SCHEME_LEGACY,
187 .ack_policy = CONF_ACK_POLICY_LEGACY,
188 .apsd_conf = {0, 0},
189 },
Juuso Oikarinen9987a9d2010-09-01 11:31:12 +0200190 [CONF_TX_AC_VI] = {
191 .queue_id = CONF_TX_AC_VI,
192 .channel_type = CONF_CHANNEL_TYPE_EDCF,
193 .tsid = CONF_TX_AC_VI,
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300194 .ps_scheme = CONF_PS_SCHEME_LEGACY,
195 .ack_policy = CONF_ACK_POLICY_LEGACY,
196 .apsd_conf = {0, 0},
197 },
Juuso Oikarinen9987a9d2010-09-01 11:31:12 +0200198 [CONF_TX_AC_VO] = {
199 .queue_id = CONF_TX_AC_VO,
200 .channel_type = CONF_CHANNEL_TYPE_EDCF,
201 .tsid = CONF_TX_AC_VO,
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300202 .ps_scheme = CONF_PS_SCHEME_LEGACY,
203 .ack_policy = CONF_ACK_POLICY_LEGACY,
204 .apsd_conf = {0, 0},
205 },
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300206 },
207 .frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD,
Luciano Coelho3ed8f2c2009-12-11 15:40:54 +0200208 .tx_compl_timeout = 700,
Juuso Oikarinenebba60c2010-04-01 11:38:20 +0300209 .tx_compl_threshold = 4,
210 .basic_rate = CONF_HW_BIT_RATE_1MBPS,
211 .basic_rate_5 = CONF_HW_BIT_RATE_6MBPS,
Arik Nemtsov1e05a812010-10-16 17:44:51 +0200212 .tmpl_short_retry_limit = 10,
213 .tmpl_long_retry_limit = 10,
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300214 },
215 .conn = {
216 .wake_up_event = CONF_WAKE_UP_EVENT_DTIM,
Juuso Oikarinen50c500a2010-04-01 11:38:22 +0300217 .listen_interval = 1,
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300218 .bcn_filt_mode = CONF_BCN_FILT_MODE_ENABLED,
Shahar Levibc76b942011-05-11 11:14:22 +0300219 .bcn_filt_ie_count = 2,
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300220 .bcn_filt_ie = {
221 [0] = {
222 .ie = WLAN_EID_CHANNEL_SWITCH,
223 .rule = CONF_BCN_RULE_PASS_ON_APPEARANCE,
Shahar Levibc76b942011-05-11 11:14:22 +0300224 },
225 [1] = {
226 .ie = WLAN_EID_HT_INFORMATION,
227 .rule = CONF_BCN_RULE_PASS_ON_CHANGE,
228 },
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300229 },
Luciano Coelho3ed8f2c2009-12-11 15:40:54 +0200230 .synch_fail_thold = 10,
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300231 .bss_lose_timeout = 100,
232 .beacon_rx_timeout = 10000,
233 .broadcast_timeout = 20000,
234 .rx_broadcast_in_ps = 1,
Juuso Oikarinen90494a92010-07-08 17:50:00 +0300235 .ps_poll_threshold = 10,
236 .ps_poll_recovery_period = 700,
Juuso Oikarinen11f70f92009-10-13 12:47:46 +0300237 .bet_enable = CONF_BET_MODE_ENABLE,
Ohad Ben-Cohen958b20e2011-03-14 18:53:10 +0200238 .bet_max_consecutive = 50,
Juuso Oikarinen8eab7b42010-09-24 03:10:11 +0200239 .psm_entry_retries = 5,
Shahar Levi23708412011-04-13 14:52:50 +0300240 .psm_exit_retries = 16,
Juuso Oikarinen8eab7b42010-09-24 03:10:11 +0200241 .psm_entry_nullfunc_retries = 3,
242 .psm_entry_hangover_period = 1,
Juuso Oikarinen50c500a2010-04-01 11:38:22 +0300243 .keep_alive_interval = 55000,
244 .max_listen_interval = 20,
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300245 },
Luciano Coelho6e92b412009-12-11 15:40:50 +0200246 .itrim = {
247 .enable = false,
248 .timeout = 50000,
Juuso Oikarinen38ad2d82009-12-11 15:41:08 +0200249 },
250 .pm_config = {
251 .host_clk_settling_time = 5000,
252 .host_fast_wakeup_support = false
Juuso Oikarinen00236aed2010-04-09 11:07:30 +0300253 },
254 .roam_trigger = {
Juuso Oikarinen00236aed2010-04-09 11:07:30 +0300255 .trigger_pacing = 1,
256 .avg_weight_rssi_beacon = 20,
257 .avg_weight_rssi_data = 10,
258 .avg_weight_snr_beacon = 20,
Levi, Shahar4b7fac72011-01-23 07:27:22 +0100259 .avg_weight_snr_data = 10,
Juuso Oikarinenbea39d62010-09-21 08:14:31 +0200260 },
261 .scan = {
262 .min_dwell_time_active = 7500,
263 .max_dwell_time_active = 30000,
Juuso Oikarinenea45b2c2011-01-24 07:01:54 +0100264 .min_dwell_time_passive = 100000,
265 .max_dwell_time_passive = 100000,
Juuso Oikarinenbea39d62010-09-21 08:14:31 +0200266 .num_probe_reqs = 2,
267 },
Luciano Coelho3a9d60e2011-05-10 14:06:31 +0300268 .sched_scan = {
269 /* sched_scan requires dwell times in TU instead of TU/1000 */
270 .min_dwell_time_active = 8,
271 .max_dwell_time_active = 30,
272 .dwell_time_passive = 100,
Luciano Coelho50a66d72011-05-27 15:34:47 +0300273 .dwell_time_dfs = 150,
Luciano Coelho3a9d60e2011-05-10 14:06:31 +0300274 .num_probe_reqs = 2,
275 .rssi_threshold = -90,
276 .snr_threshold = 0,
277 },
Juuso Oikarinen644a4862010-10-05 13:11:56 +0200278 .rf = {
279 .tx_per_channel_power_compensation_2 = {
280 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
281 },
282 .tx_per_channel_power_compensation_5 = {
283 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
284 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
285 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
286 },
287 },
Levi, Shahar4b7fac72011-01-23 07:27:22 +0100288 .ht = {
Arik Nemtsov0f9c8252011-08-17 10:45:49 +0300289 .rx_ba_win_size = 8,
Levi, Shahar4b7fac72011-01-23 07:27:22 +0100290 .tx_ba_win_size = 64,
291 .inactivity_timeout = 10000,
Arik Nemtsov0f9c8252011-08-17 10:45:49 +0300292 .tx_ba_tid_bitmap = CONF_TX_BA_ENABLED_TID_BITMAP,
Levi, Shahar4b7fac72011-01-23 07:27:22 +0100293 },
Shahar Levi13b107d2011-03-06 16:32:12 +0200294 .mem_wl127x = {
Eliad Pellerfe5ef092011-02-02 09:59:36 +0200295 .num_stations = 1,
296 .ssid_profiles = 1,
297 .rx_block_num = 70,
298 .tx_min_block_num = 40,
Ido Yariv4cf557f2011-04-18 16:45:10 +0300299 .dynamic_memory = 1,
Ido Yarivb16d4b62011-03-01 15:14:44 +0200300 .min_req_tx_blocks = 100,
Eliad Pellerc8bde242011-02-02 09:59:35 +0200301 .min_req_rx_blocks = 22,
302 .tx_min = 27,
Shahar Levi13b107d2011-03-06 16:32:12 +0200303 },
304 .mem_wl128x = {
305 .num_stations = 1,
306 .ssid_profiles = 1,
307 .rx_block_num = 40,
308 .tx_min_block_num = 40,
309 .dynamic_memory = 1,
310 .min_req_tx_blocks = 45,
311 .min_req_rx_blocks = 22,
312 .tx_min = 27,
313 },
Shahar Leviff868432011-04-11 15:41:46 +0300314 .fm_coex = {
315 .enable = true,
316 .swallow_period = 5,
317 .n_divider_fref_set_1 = 0xff, /* default */
318 .n_divider_fref_set_2 = 12,
319 .m_divider_fref_set_1 = 148,
320 .m_divider_fref_set_2 = 0xffff, /* default */
321 .coex_pll_stabilization_time = 0xffffffff, /* default */
322 .ldo_stabilization_time = 0xffff, /* default */
323 .fm_disturbed_band_margin = 0xff, /* default */
324 .swallow_clk_diff = 0xff, /* default */
325 },
Eliad Pellerf84673d2011-05-15 11:10:28 +0300326 .rx_streaming = {
327 .duration = 150,
328 .queues = 0x1,
329 .interval = 20,
Eliad Peller77ddaa12011-05-15 11:10:29 +0300330 .always = 0,
Eliad Pellerf84673d2011-05-15 11:10:28 +0300331 },
Ido Yariv95dac04f2011-06-06 14:57:06 +0300332 .fwlog = {
333 .mode = WL12XX_FWLOG_ON_DEMAND,
334 .mem_blocks = 2,
335 .severity = 0,
336 .timestamp = WL12XX_FWLOG_TIMESTAMP_DISABLED,
337 .output = WL12XX_FWLOG_OUTPUT_HOST,
338 .threshold = 0,
339 },
Luciano Coelhoafb7d3c2011-04-01 20:48:02 +0300340 .hci_io_ds = HCI_IO_DS_6MA,
Eliad Pellerfa6ad9f2011-08-14 13:17:14 +0300341 .rate = {
342 .rate_retry_score = 32000,
343 .per_add = 8192,
344 .per_th1 = 2048,
345 .per_th2 = 4096,
346 .max_per = 8100,
347 .inverse_curiosity_factor = 5,
348 .tx_fail_low_th = 4,
349 .tx_fail_high_th = 10,
350 .per_alpha_shift = 4,
351 .per_add_shift = 13,
352 .per_beta1_shift = 10,
353 .per_beta2_shift = 8,
354 .rate_check_up = 2,
355 .rate_check_down = 12,
356 .rate_retry_policy = {
357 0x00, 0x00, 0x00, 0x00, 0x00,
358 0x00, 0x00, 0x00, 0x00, 0x00,
359 0x00, 0x00, 0x00,
360 },
361 },
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300362};
363
Ido Yariv95dac04f2011-06-06 14:57:06 +0300364static char *fwlog_param;
365
Arik Nemtsov7dece1c2011-04-18 14:15:28 +0300366static void __wl1271_op_remove_interface(struct wl1271 *wl,
367 bool reset_tx_queues);
Arik Nemtsov7f179b42010-10-16 21:39:06 +0200368static void wl1271_free_ap_keys(struct wl1271 *wl);
Juuso Oikarinen52b0e7a2010-09-21 06:23:31 +0200369
370
Juuso Oikarinena1dd8182010-03-18 12:26:31 +0200371static void wl1271_device_release(struct device *dev)
372{
373
374}
375
376static struct platform_device wl1271_device = {
377 .name = "wl1271",
378 .id = -1,
379
380 /* device model insists to have a release function */
381 .dev = {
382 .release = wl1271_device_release,
383 },
384};
385
Juuso Oikarinenf9f774c2011-03-21 10:43:36 +0200386static DEFINE_MUTEX(wl_list_mutex);
Juuso Oikarinen01c09162009-10-13 12:47:55 +0300387static LIST_HEAD(wl_list);
388
Eliad Pelleref4b29e2011-06-06 13:03:12 +0300389static int wl1271_check_operstate(struct wl1271 *wl, unsigned char operstate)
390{
391 int ret;
392 if (operstate != IF_OPER_UP)
393 return 0;
394
395 if (test_and_set_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags))
396 return 0;
397
Eliad Pellerb67476e2011-08-14 13:17:23 +0300398 ret = wl12xx_cmd_set_peer_state(wl, wl->sta_hlid);
Eliad Pelleref4b29e2011-06-06 13:03:12 +0300399 if (ret < 0)
400 return ret;
401
Eliad Peller251c1772011-08-14 13:17:17 +0300402 wl12xx_croc(wl, wl->role_id);
403
Eliad Pelleref4b29e2011-06-06 13:03:12 +0300404 wl1271_info("Association completed.");
405 return 0;
406}
Juuso Oikarinenc2c192a2010-07-27 03:30:09 +0300407static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
408 void *arg)
409{
410 struct net_device *dev = arg;
411 struct wireless_dev *wdev;
412 struct wiphy *wiphy;
413 struct ieee80211_hw *hw;
414 struct wl1271 *wl;
415 struct wl1271 *wl_temp;
416 int ret = 0;
417
418 /* Check that this notification is for us. */
419 if (what != NETDEV_CHANGE)
420 return NOTIFY_DONE;
421
422 wdev = dev->ieee80211_ptr;
423 if (wdev == NULL)
424 return NOTIFY_DONE;
425
426 wiphy = wdev->wiphy;
427 if (wiphy == NULL)
428 return NOTIFY_DONE;
429
430 hw = wiphy_priv(wiphy);
431 if (hw == NULL)
432 return NOTIFY_DONE;
433
434 wl_temp = hw->priv;
Juuso Oikarinenf9f774c2011-03-21 10:43:36 +0200435 mutex_lock(&wl_list_mutex);
Juuso Oikarinenc2c192a2010-07-27 03:30:09 +0300436 list_for_each_entry(wl, &wl_list, list) {
437 if (wl == wl_temp)
438 break;
439 }
Juuso Oikarinenf9f774c2011-03-21 10:43:36 +0200440 mutex_unlock(&wl_list_mutex);
Juuso Oikarinenc2c192a2010-07-27 03:30:09 +0300441 if (wl != wl_temp)
442 return NOTIFY_DONE;
443
444 mutex_lock(&wl->mutex);
445
446 if (wl->state == WL1271_STATE_OFF)
447 goto out;
448
449 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
450 goto out;
451
Ido Yariva6208652011-03-01 15:14:41 +0200452 ret = wl1271_ps_elp_wakeup(wl);
Juuso Oikarinenc2c192a2010-07-27 03:30:09 +0300453 if (ret < 0)
454 goto out;
455
Eliad Pelleref4b29e2011-06-06 13:03:12 +0300456 wl1271_check_operstate(wl, dev->operstate);
Juuso Oikarinenc2c192a2010-07-27 03:30:09 +0300457
458 wl1271_ps_elp_sleep(wl);
459
460out:
461 mutex_unlock(&wl->mutex);
462
463 return NOTIFY_OK;
464}
465
Juuso Oikarinenb7417d92010-11-10 11:27:19 +0100466static int wl1271_reg_notify(struct wiphy *wiphy,
Luciano Coelho573c67c2010-11-26 13:44:59 +0200467 struct regulatory_request *request)
468{
Juuso Oikarinenb7417d92010-11-10 11:27:19 +0100469 struct ieee80211_supported_band *band;
470 struct ieee80211_channel *ch;
471 int i;
472
473 band = wiphy->bands[IEEE80211_BAND_5GHZ];
474 for (i = 0; i < band->n_channels; i++) {
475 ch = &band->channels[i];
476 if (ch->flags & IEEE80211_CHAN_DISABLED)
477 continue;
478
479 if (ch->flags & IEEE80211_CHAN_RADAR)
480 ch->flags |= IEEE80211_CHAN_NO_IBSS |
481 IEEE80211_CHAN_PASSIVE_SCAN;
482
483 }
484
485 return 0;
486}
487
Eliad Peller77ddaa12011-05-15 11:10:29 +0300488static int wl1271_set_rx_streaming(struct wl1271 *wl, bool enable)
489{
490 int ret = 0;
491
492 /* we should hold wl->mutex */
493 ret = wl1271_acx_ps_rx_streaming(wl, enable);
494 if (ret < 0)
495 goto out;
496
497 if (enable)
498 set_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags);
499 else
500 clear_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags);
501out:
502 return ret;
503}
504
505/*
506 * this function is being called when the rx_streaming interval
507 * has beed changed or rx_streaming should be disabled
508 */
509int wl1271_recalc_rx_streaming(struct wl1271 *wl)
510{
511 int ret = 0;
512 int period = wl->conf.rx_streaming.interval;
513
514 /* don't reconfigure if rx_streaming is disabled */
515 if (!test_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags))
516 goto out;
517
518 /* reconfigure/disable according to new streaming_period */
519 if (period &&
520 test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags) &&
521 (wl->conf.rx_streaming.always ||
522 test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags)))
523 ret = wl1271_set_rx_streaming(wl, true);
524 else {
525 ret = wl1271_set_rx_streaming(wl, false);
526 /* don't cancel_work_sync since we might deadlock */
527 del_timer_sync(&wl->rx_streaming_timer);
528 }
529out:
530 return ret;
531}
532
533static void wl1271_rx_streaming_enable_work(struct work_struct *work)
534{
535 int ret;
536 struct wl1271 *wl =
537 container_of(work, struct wl1271, rx_streaming_enable_work);
538
539 mutex_lock(&wl->mutex);
540
541 if (test_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags) ||
542 !test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags) ||
543 (!wl->conf.rx_streaming.always &&
544 !test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags)))
545 goto out;
546
547 if (!wl->conf.rx_streaming.interval)
548 goto out;
549
550 ret = wl1271_ps_elp_wakeup(wl);
551 if (ret < 0)
552 goto out;
553
554 ret = wl1271_set_rx_streaming(wl, true);
555 if (ret < 0)
556 goto out_sleep;
557
558 /* stop it after some time of inactivity */
559 mod_timer(&wl->rx_streaming_timer,
560 jiffies + msecs_to_jiffies(wl->conf.rx_streaming.duration));
561
562out_sleep:
563 wl1271_ps_elp_sleep(wl);
564out:
565 mutex_unlock(&wl->mutex);
566}
567
568static void wl1271_rx_streaming_disable_work(struct work_struct *work)
569{
570 int ret;
571 struct wl1271 *wl =
572 container_of(work, struct wl1271, rx_streaming_disable_work);
573
574 mutex_lock(&wl->mutex);
575
576 if (!test_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags))
577 goto out;
578
579 ret = wl1271_ps_elp_wakeup(wl);
580 if (ret < 0)
581 goto out;
582
583 ret = wl1271_set_rx_streaming(wl, false);
584 if (ret)
585 goto out_sleep;
586
587out_sleep:
588 wl1271_ps_elp_sleep(wl);
589out:
590 mutex_unlock(&wl->mutex);
591}
592
593static void wl1271_rx_streaming_timer(unsigned long data)
594{
595 struct wl1271 *wl = (struct wl1271 *)data;
596 ieee80211_queue_work(wl->hw, &wl->rx_streaming_disable_work);
597}
598
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +0300599static void wl1271_conf_init(struct wl1271 *wl)
600{
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +0300601
602 /*
603 * This function applies the default configuration to the driver. This
604 * function is invoked upon driver load (spi probe.)
605 *
606 * The configuration is stored in a run-time structure in order to
607 * facilitate for run-time adjustment of any of the parameters. Making
608 * changes to the configuration structure will apply the new values on
609 * the next interface up (wl1271_op_start.)
610 */
611
612 /* apply driver default configuration */
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300613 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +0300614
Ido Yariv95dac04f2011-06-06 14:57:06 +0300615 /* Adjust settings according to optional module parameters */
616 if (fwlog_param) {
617 if (!strcmp(fwlog_param, "continuous")) {
618 wl->conf.fwlog.mode = WL12XX_FWLOG_CONTINUOUS;
619 } else if (!strcmp(fwlog_param, "ondemand")) {
620 wl->conf.fwlog.mode = WL12XX_FWLOG_ON_DEMAND;
621 } else if (!strcmp(fwlog_param, "dbgpins")) {
622 wl->conf.fwlog.mode = WL12XX_FWLOG_CONTINUOUS;
623 wl->conf.fwlog.output = WL12XX_FWLOG_OUTPUT_DBG_PINS;
624 } else if (!strcmp(fwlog_param, "disable")) {
625 wl->conf.fwlog.mem_blocks = 0;
626 wl->conf.fwlog.output = WL12XX_FWLOG_OUTPUT_NONE;
627 } else {
628 wl1271_error("Unknown fwlog parameter %s", fwlog_param);
629 }
630 }
631}
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +0300632
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300633static int wl1271_plt_init(struct wl1271 *wl)
634{
Luciano Coelho12419cc2010-02-18 13:25:44 +0200635 struct conf_tx_ac_category *conf_ac;
636 struct conf_tx_tid *conf_tid;
637 int ret, i;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300638
Shahar Levi49d750ca2011-03-06 16:32:09 +0200639 if (wl->chip.id == CHIP_ID_1283_PG20)
640 ret = wl128x_cmd_general_parms(wl);
641 else
642 ret = wl1271_cmd_general_parms(wl);
Luciano Coelho4a904062009-11-23 23:22:18 +0200643 if (ret < 0)
Luciano Coelhocc7defa2009-11-23 23:22:16 +0200644 return ret;
645
Shahar Levi49d750ca2011-03-06 16:32:09 +0200646 if (wl->chip.id == CHIP_ID_1283_PG20)
647 ret = wl128x_cmd_radio_parms(wl);
648 else
649 ret = wl1271_cmd_radio_parms(wl);
Luciano Coelho4a904062009-11-23 23:22:18 +0200650 if (ret < 0)
Luciano Coelhocc7defa2009-11-23 23:22:16 +0200651 return ret;
652
Shahar Levi49d750ca2011-03-06 16:32:09 +0200653 if (wl->chip.id != CHIP_ID_1283_PG20) {
654 ret = wl1271_cmd_ext_radio_parms(wl);
655 if (ret < 0)
656 return ret;
657 }
Juuso Oikarinen644a4862010-10-05 13:11:56 +0200658 if (ret < 0)
659 return ret;
660
Shahar Levi48a61472011-03-06 16:32:08 +0200661 /* Chip-specific initializations */
662 ret = wl1271_chip_specific_init(wl);
663 if (ret < 0)
664 return ret;
665
Arik Nemtsove0fe3712010-10-16 18:19:53 +0200666 ret = wl1271_sta_init_templates_config(wl);
Luciano Coelho12419cc2010-02-18 13:25:44 +0200667 if (ret < 0)
668 return ret;
669
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300670 ret = wl1271_acx_init_mem_config(wl);
671 if (ret < 0)
672 return ret;
673
Luciano Coelho12419cc2010-02-18 13:25:44 +0200674 /* PHY layer config */
675 ret = wl1271_init_phy_config(wl);
676 if (ret < 0)
677 goto out_free_memmap;
678
679 ret = wl1271_acx_dco_itrim_params(wl);
680 if (ret < 0)
681 goto out_free_memmap;
682
683 /* Initialize connection monitoring thresholds */
Juuso Oikarinen6ccbb922010-03-26 12:53:23 +0200684 ret = wl1271_acx_conn_monit_params(wl, false);
Luciano Coelho12419cc2010-02-18 13:25:44 +0200685 if (ret < 0)
686 goto out_free_memmap;
687
688 /* Bluetooth WLAN coexistence */
689 ret = wl1271_init_pta(wl);
690 if (ret < 0)
691 goto out_free_memmap;
692
Shahar Leviff868432011-04-11 15:41:46 +0300693 /* FM WLAN coexistence */
694 ret = wl1271_acx_fm_coex(wl);
695 if (ret < 0)
696 goto out_free_memmap;
697
Luciano Coelho12419cc2010-02-18 13:25:44 +0200698 /* Energy detection */
699 ret = wl1271_init_energy_detection(wl);
700 if (ret < 0)
701 goto out_free_memmap;
702
Eliad Peller7f0979882011-08-14 13:17:06 +0300703 ret = wl12xx_acx_mem_cfg(wl);
Gery Kahn1ec610e2011-02-01 03:03:08 -0600704 if (ret < 0)
705 goto out_free_memmap;
706
Luciano Coelho12419cc2010-02-18 13:25:44 +0200707 /* Default fragmentation threshold */
Arik Nemtsov68d069c2010-11-08 10:51:07 +0100708 ret = wl1271_acx_frag_threshold(wl, wl->conf.tx.frag_threshold);
Luciano Coelho12419cc2010-02-18 13:25:44 +0200709 if (ret < 0)
710 goto out_free_memmap;
711
Juuso Oikarinen9987a9d2010-09-01 11:31:12 +0200712 /* Default TID/AC configuration */
713 BUG_ON(wl->conf.tx.tid_conf_count != wl->conf.tx.ac_conf_count);
Luciano Coelho12419cc2010-02-18 13:25:44 +0200714 for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
Juuso Oikarinen9987a9d2010-09-01 11:31:12 +0200715 conf_ac = &wl->conf.tx.ac_conf[i];
716 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
717 conf_ac->cw_max, conf_ac->aifsn,
718 conf_ac->tx_op_limit);
719 if (ret < 0)
720 goto out_free_memmap;
721
Luciano Coelho12419cc2010-02-18 13:25:44 +0200722 conf_tid = &wl->conf.tx.tid_conf[i];
723 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
724 conf_tid->channel_type,
725 conf_tid->tsid,
726 conf_tid->ps_scheme,
727 conf_tid->ack_policy,
728 conf_tid->apsd_conf[0],
729 conf_tid->apsd_conf[1]);
730 if (ret < 0)
731 goto out_free_memmap;
732 }
733
Luciano Coelho12419cc2010-02-18 13:25:44 +0200734 /* Enable data path */
Luciano Coelho94210892009-12-11 15:40:55 +0200735 ret = wl1271_cmd_data_path(wl, 1);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300736 if (ret < 0)
Luciano Coelho12419cc2010-02-18 13:25:44 +0200737 goto out_free_memmap;
738
739 /* Configure for CAM power saving (ie. always active) */
740 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
741 if (ret < 0)
742 goto out_free_memmap;
743
744 /* configure PM */
745 ret = wl1271_acx_pm_config(wl);
746 if (ret < 0)
747 goto out_free_memmap;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300748
749 return 0;
Luciano Coelho12419cc2010-02-18 13:25:44 +0200750
751 out_free_memmap:
752 kfree(wl->target_mem_map);
753 wl->target_mem_map = NULL;
754
755 return ret;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300756}
757
Eliad Pellerdbe25cb2011-08-14 13:17:03 +0300758#if 0
Arik Nemtsovb622d992011-02-23 00:22:31 +0200759static void wl1271_irq_ps_regulate_link(struct wl1271 *wl, u8 hlid, u8 tx_blks)
760{
761 bool fw_ps;
762
763 /* only regulate station links */
764 if (hlid < WL1271_AP_STA_HLID_START)
765 return;
766
767 fw_ps = test_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
768
769 /*
770 * Wake up from high level PS if the STA is asleep with too little
771 * blocks in FW or if the STA is awake.
772 */
773 if (!fw_ps || tx_blks < WL1271_PS_STA_MAX_BLOCKS)
774 wl1271_ps_link_end(wl, hlid);
775
776 /* Start high-level PS if the STA is asleep with enough blocks in FW */
777 else if (fw_ps && tx_blks >= WL1271_PS_STA_MAX_BLOCKS)
778 wl1271_ps_link_start(wl, hlid, true);
779}
780
781static void wl1271_irq_update_links_status(struct wl1271 *wl,
782 struct wl1271_fw_ap_status *status)
783{
784 u32 cur_fw_ps_map;
785 u8 hlid;
786
787 cur_fw_ps_map = le32_to_cpu(status->link_ps_bitmap);
788 if (wl->ap_fw_ps_map != cur_fw_ps_map) {
789 wl1271_debug(DEBUG_PSM,
790 "link ps prev 0x%x cur 0x%x changed 0x%x",
791 wl->ap_fw_ps_map, cur_fw_ps_map,
792 wl->ap_fw_ps_map ^ cur_fw_ps_map);
793
794 wl->ap_fw_ps_map = cur_fw_ps_map;
795 }
796
797 for (hlid = WL1271_AP_STA_HLID_START; hlid < AP_MAX_LINKS; hlid++) {
798 u8 cnt = status->tx_lnk_free_blks[hlid] -
799 wl->links[hlid].prev_freed_blks;
800
801 wl->links[hlid].prev_freed_blks =
802 status->tx_lnk_free_blks[hlid];
803 wl->links[hlid].allocated_blks -= cnt;
804
805 wl1271_irq_ps_regulate_link(wl, hlid,
806 wl->links[hlid].allocated_blks);
807 }
808}
Eliad Pellerdbe25cb2011-08-14 13:17:03 +0300809#endif
Arik Nemtsovb622d992011-02-23 00:22:31 +0200810
Eliad Peller4d56ad92011-08-14 13:17:05 +0300811static void wl12xx_fw_status(struct wl1271 *wl,
812 struct wl12xx_fw_status *status)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300813{
Juuso Oikarinenac5e1e32010-02-22 08:38:38 +0200814 struct timespec ts;
Shahar Levi13b107d2011-03-06 16:32:12 +0200815 u32 old_tx_blk_count = wl->tx_blocks_available;
Eliad Peller4d56ad92011-08-14 13:17:05 +0300816 int avail, freed_blocks;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300817
Eliad Peller4d56ad92011-08-14 13:17:05 +0300818 wl1271_raw_read(wl, FW_STATUS_ADDR, status, sizeof(*status), false);
Shahar Levi13b107d2011-03-06 16:32:12 +0200819
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300820 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
821 "drv_rx_counter = %d, tx_results_counter = %d)",
822 status->intr,
823 status->fw_rx_counter,
824 status->drv_rx_counter,
825 status->tx_results_counter);
826
Eliad Peller4d56ad92011-08-14 13:17:05 +0300827 freed_blocks = le32_to_cpu(status->total_released_blks) -
828 wl->tx_blocks_freed;
829 wl->tx_blocks_freed = le32_to_cpu(status->total_released_blks);
Shahar Levi13b107d2011-03-06 16:32:12 +0200830
Arik Nemtsov7bb5d6c2011-08-14 13:17:00 +0300831 wl->tx_allocated_blocks -= freed_blocks;
832
Eliad Peller4d56ad92011-08-14 13:17:05 +0300833 avail = le32_to_cpu(status->tx_total) - wl->tx_allocated_blocks;
Ido Yarivd2f4d472011-03-31 10:07:00 +0200834
Eliad Peller4d56ad92011-08-14 13:17:05 +0300835 /*
836 * The FW might change the total number of TX memblocks before
837 * we get a notification about blocks being released. Thus, the
838 * available blocks calculation might yield a temporary result
839 * which is lower than the actual available blocks. Keeping in
840 * mind that only blocks that were allocated can be moved from
841 * TX to RX, tx_blocks_available should never decrease here.
842 */
843 wl->tx_blocks_available = max((int)wl->tx_blocks_available,
844 avail);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300845
Ido Yariva5225502010-10-12 14:49:10 +0200846 /* if more blocks are available now, tx work can be scheduled */
Shahar Levi13b107d2011-03-06 16:32:12 +0200847 if (wl->tx_blocks_available > old_tx_blk_count)
Ido Yariva5225502010-10-12 14:49:10 +0200848 clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300849
Eliad Peller4d56ad92011-08-14 13:17:05 +0300850 /* for AP update num of allocated TX blocks per link and ps status */
851 if (wl->bss_type == BSS_TYPE_AP_BSS) {
852#if 0
853 wl1271_irq_update_links_status(wl, status);
854#endif
855 }
856
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300857 /* update the host-chipset time offset */
Juuso Oikarinenac5e1e32010-02-22 08:38:38 +0200858 getnstimeofday(&ts);
859 wl->time_offset = (timespec_to_ns(&ts) >> 10) -
860 (s64)le32_to_cpu(status->fw_localtime);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300861}
862
Ido Yariva6208652011-03-01 15:14:41 +0200863static void wl1271_flush_deferred_work(struct wl1271 *wl)
864{
865 struct sk_buff *skb;
Juuso Oikarinen1e73eb62010-02-22 08:38:37 +0200866
Ido Yariva6208652011-03-01 15:14:41 +0200867 /* Pass all received frames to the network stack */
868 while ((skb = skb_dequeue(&wl->deferred_rx_queue)))
869 ieee80211_rx_ni(wl->hw, skb);
870
871 /* Return sent skbs to the network stack */
872 while ((skb = skb_dequeue(&wl->deferred_tx_queue)))
Eliad Pellerc27d3ac2011-06-07 10:40:39 +0300873 ieee80211_tx_status_ni(wl->hw, skb);
Ido Yariva6208652011-03-01 15:14:41 +0200874}
875
876static void wl1271_netstack_work(struct work_struct *work)
877{
878 struct wl1271 *wl =
879 container_of(work, struct wl1271, netstack_work);
880
881 do {
882 wl1271_flush_deferred_work(wl);
883 } while (skb_queue_len(&wl->deferred_rx_queue));
884}
885
886#define WL1271_IRQ_MAX_LOOPS 256
887
888irqreturn_t wl1271_irq(int irq, void *cookie)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300889{
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300890 int ret;
Juuso Oikarinenc15f63b2009-10-12 15:08:50 +0300891 u32 intr;
Juuso Oikarinen1e73eb62010-02-22 08:38:37 +0200892 int loopcount = WL1271_IRQ_MAX_LOOPS;
Ido Yariva6208652011-03-01 15:14:41 +0200893 struct wl1271 *wl = (struct wl1271 *)cookie;
894 bool done = false;
895 unsigned int defer_count;
Ido Yarivb07d4032011-03-01 15:14:43 +0200896 unsigned long flags;
897
898 /* TX might be handled here, avoid redundant work */
899 set_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
900 cancel_work_sync(&wl->tx_work);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300901
Ido Yariv341b7cd2011-03-31 10:07:01 +0200902 /*
903 * In case edge triggered interrupt must be used, we cannot iterate
904 * more than once without introducing race conditions with the hardirq.
905 */
906 if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ)
907 loopcount = 1;
908
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300909 mutex_lock(&wl->mutex);
910
911 wl1271_debug(DEBUG_IRQ, "IRQ work");
912
Juuso Oikarinen1e73eb62010-02-22 08:38:37 +0200913 if (unlikely(wl->state == WL1271_STATE_OFF))
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300914 goto out;
915
Ido Yariva6208652011-03-01 15:14:41 +0200916 ret = wl1271_ps_elp_wakeup(wl);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300917 if (ret < 0)
918 goto out;
919
Ido Yariva6208652011-03-01 15:14:41 +0200920 while (!done && loopcount--) {
921 /*
922 * In order to avoid a race with the hardirq, clear the flag
923 * before acknowledging the chip. Since the mutex is held,
924 * wl1271_ps_elp_wakeup cannot be called concurrently.
925 */
926 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
927 smp_mb__after_clear_bit();
Juuso Oikarinen1e73eb62010-02-22 08:38:37 +0200928
Eliad Peller4d56ad92011-08-14 13:17:05 +0300929 wl12xx_fw_status(wl, wl->fw_status);
930 intr = le32_to_cpu(wl->fw_status->intr);
Ido Yariva6208652011-03-01 15:14:41 +0200931 intr &= WL1271_INTR_MASK;
Juuso Oikarinen1e73eb62010-02-22 08:38:37 +0200932 if (!intr) {
Ido Yariva6208652011-03-01 15:14:41 +0200933 done = true;
Juuso Oikarinen1e73eb62010-02-22 08:38:37 +0200934 continue;
935 }
936
Eliad Pellerccc83b02010-10-27 14:09:57 +0200937 if (unlikely(intr & WL1271_ACX_INTR_WATCHDOG)) {
938 wl1271_error("watchdog interrupt received! "
939 "starting recovery.");
Ido Yarivbaacb9a2011-06-06 14:57:05 +0300940 wl12xx_queue_recovery_work(wl);
Eliad Pellerccc83b02010-10-27 14:09:57 +0200941
942 /* restarting the chip. ignore any other interrupt. */
943 goto out;
944 }
945
Ido Yariva6208652011-03-01 15:14:41 +0200946 if (likely(intr & WL1271_ACX_INTR_DATA)) {
Juuso Oikarinen1e73eb62010-02-22 08:38:37 +0200947 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
948
Eliad Peller4d56ad92011-08-14 13:17:05 +0300949 wl12xx_rx(wl, wl->fw_status);
Juuso Oikarinen1e73eb62010-02-22 08:38:37 +0200950
Ido Yariva5225502010-10-12 14:49:10 +0200951 /* Check if any tx blocks were freed */
Ido Yarivb07d4032011-03-01 15:14:43 +0200952 spin_lock_irqsave(&wl->wl_lock, flags);
Ido Yariva5225502010-10-12 14:49:10 +0200953 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
Arik Nemtsovf1a46382011-07-07 14:25:23 +0300954 wl1271_tx_total_queue_count(wl) > 0) {
Ido Yarivb07d4032011-03-01 15:14:43 +0200955 spin_unlock_irqrestore(&wl->wl_lock, flags);
Ido Yariva5225502010-10-12 14:49:10 +0200956 /*
957 * In order to avoid starvation of the TX path,
958 * call the work function directly.
959 */
960 wl1271_tx_work_locked(wl);
Ido Yarivb07d4032011-03-01 15:14:43 +0200961 } else {
962 spin_unlock_irqrestore(&wl->wl_lock, flags);
Ido Yariva5225502010-10-12 14:49:10 +0200963 }
964
Ido Yariv8aad2462011-03-01 15:14:38 +0200965 /* check for tx results */
Eliad Peller4d56ad92011-08-14 13:17:05 +0300966 if (wl->fw_status->tx_results_counter !=
Ido Yariv8aad2462011-03-01 15:14:38 +0200967 (wl->tx_results_count & 0xff))
968 wl1271_tx_complete(wl);
Ido Yariva6208652011-03-01 15:14:41 +0200969
970 /* Make sure the deferred queues don't get too long */
971 defer_count = skb_queue_len(&wl->deferred_tx_queue) +
972 skb_queue_len(&wl->deferred_rx_queue);
973 if (defer_count > WL1271_DEFERRED_QUEUE_LIMIT)
974 wl1271_flush_deferred_work(wl);
Juuso Oikarinen1e73eb62010-02-22 08:38:37 +0200975 }
976
977 if (intr & WL1271_ACX_INTR_EVENT_A) {
978 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
979 wl1271_event_handle(wl, 0);
980 }
981
982 if (intr & WL1271_ACX_INTR_EVENT_B) {
983 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
984 wl1271_event_handle(wl, 1);
985 }
986
987 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
988 wl1271_debug(DEBUG_IRQ,
989 "WL1271_ACX_INTR_INIT_COMPLETE");
990
991 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
992 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300993 }
994
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300995 wl1271_ps_elp_sleep(wl);
996
997out:
Ido Yarivb07d4032011-03-01 15:14:43 +0200998 spin_lock_irqsave(&wl->wl_lock, flags);
999 /* In case TX was not handled here, queue TX work */
1000 clear_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
1001 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
Arik Nemtsovf1a46382011-07-07 14:25:23 +03001002 wl1271_tx_total_queue_count(wl) > 0)
Ido Yarivb07d4032011-03-01 15:14:43 +02001003 ieee80211_queue_work(wl->hw, &wl->tx_work);
1004 spin_unlock_irqrestore(&wl->wl_lock, flags);
1005
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001006 mutex_unlock(&wl->mutex);
Ido Yariva6208652011-03-01 15:14:41 +02001007
1008 return IRQ_HANDLED;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001009}
Ido Yariva6208652011-03-01 15:14:41 +02001010EXPORT_SYMBOL_GPL(wl1271_irq);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001011
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001012static int wl1271_fetch_firmware(struct wl1271 *wl)
1013{
1014 const struct firmware *fw;
Arik Nemtsov166d5042010-10-16 21:44:57 +02001015 const char *fw_name;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001016 int ret;
1017
Arik Nemtsovc302b2c2011-08-17 10:45:48 +03001018 if (wl->chip.id == CHIP_ID_1283_PG20)
1019 fw_name = WL128X_FW_NAME;
1020 else
1021 fw_name = WL127X_FW_NAME;
Arik Nemtsov166d5042010-10-16 21:44:57 +02001022
1023 wl1271_debug(DEBUG_BOOT, "booting firmware %s", fw_name);
1024
1025 ret = request_firmware(&fw, fw_name, wl1271_wl_to_dev(wl));
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001026
1027 if (ret < 0) {
1028 wl1271_error("could not get firmware: %d", ret);
1029 return ret;
1030 }
1031
1032 if (fw->size % 4) {
1033 wl1271_error("firmware size is not multiple of 32 bits: %zu",
1034 fw->size);
1035 ret = -EILSEQ;
1036 goto out;
1037 }
1038
Arik Nemtsov166d5042010-10-16 21:44:57 +02001039 vfree(wl->fw);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001040 wl->fw_len = fw->size;
Juuso Oikarinen1fba4972009-10-08 21:56:32 +03001041 wl->fw = vmalloc(wl->fw_len);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001042
1043 if (!wl->fw) {
1044 wl1271_error("could not allocate memory for the firmware");
1045 ret = -ENOMEM;
1046 goto out;
1047 }
1048
1049 memcpy(wl->fw, fw->data, wl->fw_len);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001050 ret = 0;
1051
1052out:
1053 release_firmware(fw);
1054
1055 return ret;
1056}
1057
1058static int wl1271_fetch_nvs(struct wl1271 *wl)
1059{
1060 const struct firmware *fw;
1061 int ret;
1062
Shahar Levi5aa42342011-03-06 16:32:07 +02001063 ret = request_firmware(&fw, WL12XX_NVS_NAME, wl1271_wl_to_dev(wl));
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001064
1065 if (ret < 0) {
1066 wl1271_error("could not get nvs file: %d", ret);
1067 return ret;
1068 }
1069
Shahar Levibc765bf2011-03-06 16:32:10 +02001070 wl->nvs = kmemdup(fw->data, fw->size, GFP_KERNEL);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001071
1072 if (!wl->nvs) {
1073 wl1271_error("could not allocate memory for the nvs file");
1074 ret = -ENOMEM;
1075 goto out;
1076 }
1077
Juuso Oikarinen02fabb02010-08-19 04:41:15 +02001078 wl->nvs_len = fw->size;
1079
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001080out:
1081 release_firmware(fw);
1082
1083 return ret;
1084}
1085
Ido Yarivbaacb9a2011-06-06 14:57:05 +03001086void wl12xx_queue_recovery_work(struct wl1271 *wl)
1087{
1088 if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags))
1089 ieee80211_queue_work(wl->hw, &wl->recovery_work);
1090}
1091
Ido Yariv95dac04f2011-06-06 14:57:06 +03001092size_t wl12xx_copy_fwlog(struct wl1271 *wl, u8 *memblock, size_t maxlen)
1093{
1094 size_t len = 0;
1095
1096 /* The FW log is a length-value list, find where the log end */
1097 while (len < maxlen) {
1098 if (memblock[len] == 0)
1099 break;
1100 if (len + memblock[len] + 1 > maxlen)
1101 break;
1102 len += memblock[len] + 1;
1103 }
1104
1105 /* Make sure we have enough room */
1106 len = min(len, (size_t)(PAGE_SIZE - wl->fwlog_size));
1107
1108 /* Fill the FW log file, consumed by the sysfs fwlog entry */
1109 memcpy(wl->fwlog + wl->fwlog_size, memblock, len);
1110 wl->fwlog_size += len;
1111
1112 return len;
1113}
1114
1115static void wl12xx_read_fwlog_panic(struct wl1271 *wl)
1116{
1117 u32 addr;
1118 u32 first_addr;
1119 u8 *block;
1120
1121 if ((wl->quirks & WL12XX_QUIRK_FWLOG_NOT_IMPLEMENTED) ||
1122 (wl->conf.fwlog.mode != WL12XX_FWLOG_ON_DEMAND) ||
1123 (wl->conf.fwlog.mem_blocks == 0))
1124 return;
1125
1126 wl1271_info("Reading FW panic log");
1127
1128 block = kmalloc(WL12XX_HW_BLOCK_SIZE, GFP_KERNEL);
1129 if (!block)
1130 return;
1131
1132 /*
1133 * Make sure the chip is awake and the logger isn't active.
1134 * This might fail if the firmware hanged.
1135 */
1136 if (!wl1271_ps_elp_wakeup(wl))
1137 wl12xx_cmd_stop_fwlog(wl);
1138
1139 /* Read the first memory block address */
Eliad Peller4d56ad92011-08-14 13:17:05 +03001140 wl12xx_fw_status(wl, wl->fw_status);
1141 first_addr = le32_to_cpu(wl->fw_status->log_start_addr);
Ido Yariv95dac04f2011-06-06 14:57:06 +03001142 if (!first_addr)
1143 goto out;
1144
1145 /* Traverse the memory blocks linked list */
1146 addr = first_addr;
1147 do {
1148 memset(block, 0, WL12XX_HW_BLOCK_SIZE);
1149 wl1271_read_hwaddr(wl, addr, block, WL12XX_HW_BLOCK_SIZE,
1150 false);
1151
1152 /*
1153 * Memory blocks are linked to one another. The first 4 bytes
1154 * of each memory block hold the hardware address of the next
1155 * one. The last memory block points to the first one.
1156 */
Eliad Peller4d56ad92011-08-14 13:17:05 +03001157 addr = le32_to_cpup((__le32 *)block);
Ido Yariv95dac04f2011-06-06 14:57:06 +03001158 if (!wl12xx_copy_fwlog(wl, block + sizeof(addr),
1159 WL12XX_HW_BLOCK_SIZE - sizeof(addr)))
1160 break;
1161 } while (addr && (addr != first_addr));
1162
1163 wake_up_interruptible(&wl->fwlog_waitq);
1164
1165out:
1166 kfree(block);
1167}
1168
Juuso Oikarinen52b0e7a2010-09-21 06:23:31 +02001169static void wl1271_recovery_work(struct work_struct *work)
1170{
1171 struct wl1271 *wl =
1172 container_of(work, struct wl1271, recovery_work);
1173
1174 mutex_lock(&wl->mutex);
1175
1176 if (wl->state != WL1271_STATE_ON)
1177 goto out;
1178
Ido Yarivbaacb9a2011-06-06 14:57:05 +03001179 /* Avoid a recursive recovery */
1180 set_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags);
1181
Ido Yariv95dac04f2011-06-06 14:57:06 +03001182 wl12xx_read_fwlog_panic(wl);
1183
Arik Nemtsov52dcaf52011-04-18 14:15:24 +03001184 wl1271_info("Hardware recovery in progress. FW ver: %s pc: 0x%x",
1185 wl->chip.fw_ver_str, wl1271_read32(wl, SCR_PAD4));
Juuso Oikarinen52b0e7a2010-09-21 06:23:31 +02001186
Oz Krakowskib992c682011-06-26 10:36:02 +03001187 /*
1188 * Advance security sequence number to overcome potential progress
1189 * in the firmware during recovery. This doens't hurt if the network is
1190 * not encrypted.
1191 */
1192 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags) ||
1193 test_bit(WL1271_FLAG_AP_STARTED, &wl->flags))
1194 wl->tx_security_seq += WL1271_TX_SQN_POST_RECOVERY_PADDING;
1195
Juuso Oikarinend25611d2010-09-30 10:43:27 +02001196 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1197 ieee80211_connection_loss(wl->vif);
1198
Arik Nemtsov7dece1c2011-04-18 14:15:28 +03001199 /* Prevent spurious TX during FW restart */
1200 ieee80211_stop_queues(wl->hw);
1201
Luciano Coelho33c2c062011-05-10 14:46:02 +03001202 if (wl->sched_scanning) {
1203 ieee80211_sched_scan_stopped(wl->hw);
1204 wl->sched_scanning = false;
1205 }
1206
Juuso Oikarinen52b0e7a2010-09-21 06:23:31 +02001207 /* reboot the chipset */
Arik Nemtsov7dece1c2011-04-18 14:15:28 +03001208 __wl1271_op_remove_interface(wl, false);
Ido Yarivbaacb9a2011-06-06 14:57:05 +03001209
1210 clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags);
1211
Juuso Oikarinen52b0e7a2010-09-21 06:23:31 +02001212 ieee80211_restart_hw(wl->hw);
1213
Arik Nemtsov7dece1c2011-04-18 14:15:28 +03001214 /*
1215 * Its safe to enable TX now - the queues are stopped after a request
1216 * to restart the HW.
1217 */
1218 ieee80211_wake_queues(wl->hw);
1219
Juuso Oikarinen52b0e7a2010-09-21 06:23:31 +02001220out:
1221 mutex_unlock(&wl->mutex);
1222}
1223
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001224static void wl1271_fw_wakeup(struct wl1271 *wl)
1225{
1226 u32 elp_reg;
1227
1228 elp_reg = ELPCTRL_WAKE_UP;
Juuso Oikarinen74621412009-10-12 15:08:54 +03001229 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001230}
1231
1232static int wl1271_setup(struct wl1271 *wl)
1233{
1234 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
1235 if (!wl->fw_status)
1236 return -ENOMEM;
1237
1238 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
1239 if (!wl->tx_res_if) {
1240 kfree(wl->fw_status);
1241 return -ENOMEM;
1242 }
1243
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001244 return 0;
1245}
1246
1247static int wl1271_chip_wakeup(struct wl1271 *wl)
1248{
Juuso Oikarinen451de972009-10-12 15:08:46 +03001249 struct wl1271_partition_set partition;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001250 int ret = 0;
1251
Juuso Oikarinen01ac17e2009-12-11 15:41:02 +02001252 msleep(WL1271_PRE_POWER_ON_SLEEP);
Ohad Ben-Cohen2cc78ff2010-09-16 01:22:04 +02001253 ret = wl1271_power_on(wl);
1254 if (ret < 0)
1255 goto out;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001256 msleep(WL1271_POWER_ON_SLEEP);
Teemu Paasikivi9b280722010-02-18 13:25:56 +02001257 wl1271_io_reset(wl);
1258 wl1271_io_init(wl);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001259
1260 /* We don't need a real memory partition here, because we only want
1261 * to use the registers at this point. */
Juuso Oikarinen451de972009-10-12 15:08:46 +03001262 memset(&partition, 0, sizeof(partition));
1263 partition.reg.start = REGISTERS_BASE;
1264 partition.reg.size = REGISTERS_DOWN_SIZE;
1265 wl1271_set_partition(wl, &partition);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001266
1267 /* ELP module wake up */
1268 wl1271_fw_wakeup(wl);
1269
1270 /* whal_FwCtrl_BootSm() */
1271
1272 /* 0. read chip id from CHIP_ID */
Teemu Paasikivi7b048c52010-02-18 13:25:55 +02001273 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001274
1275 /* 1. check if chip id is valid */
1276
1277 switch (wl->chip.id) {
1278 case CHIP_ID_1271_PG10:
1279 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
1280 wl->chip.id);
1281
1282 ret = wl1271_setup(wl);
1283 if (ret < 0)
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001284 goto out;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001285 break;
1286 case CHIP_ID_1271_PG20:
1287 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
1288 wl->chip.id);
1289
Shahar Levi0c005042011-06-12 10:34:43 +03001290 /*
1291 * 'end-of-transaction flag' and 'LPD mode flag'
1292 * should be set in wl127x AP mode only
1293 */
Shahar Levi564f5952011-04-04 10:20:39 +03001294 if (wl->bss_type == BSS_TYPE_AP_BSS)
Shahar Levi0c005042011-06-12 10:34:43 +03001295 wl->quirks |= (WL12XX_QUIRK_END_OF_TRANSACTION |
1296 WL12XX_QUIRK_LPD_MODE);
Shahar Levi564f5952011-04-04 10:20:39 +03001297
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001298 ret = wl1271_setup(wl);
1299 if (ret < 0)
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001300 goto out;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001301 break;
Shahar Levi0830cee2011-03-06 16:32:20 +02001302 case CHIP_ID_1283_PG20:
1303 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1283 PG20)",
1304 wl->chip.id);
1305
1306 ret = wl1271_setup(wl);
1307 if (ret < 0)
1308 goto out;
Shahar Levi0c005042011-06-12 10:34:43 +03001309
Ido Yariv0da13da2011-03-31 10:06:58 +02001310 if (wl1271_set_block_size(wl))
1311 wl->quirks |= WL12XX_QUIRK_BLOCKSIZE_ALIGNMENT;
Shahar Levi0830cee2011-03-06 16:32:20 +02001312 break;
1313 case CHIP_ID_1283_PG10:
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001314 default:
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001315 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001316 ret = -ENODEV;
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001317 goto out;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001318 }
1319
Arik Nemtsovc302b2c2011-08-17 10:45:48 +03001320 if (wl->fw == NULL) {
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001321 ret = wl1271_fetch_firmware(wl);
1322 if (ret < 0)
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001323 goto out;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001324 }
1325
1326 /* No NVS from netlink, try to get it from the filesystem */
1327 if (wl->nvs == NULL) {
1328 ret = wl1271_fetch_nvs(wl);
1329 if (ret < 0)
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001330 goto out;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001331 }
1332
1333out:
1334 return ret;
1335}
1336
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001337int wl1271_plt_start(struct wl1271 *wl)
1338{
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001339 int retries = WL1271_BOOT_RETRIES;
Gery Kahn6f07b722011-07-18 14:21:49 +03001340 struct wiphy *wiphy = wl->hw->wiphy;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001341 int ret;
1342
1343 mutex_lock(&wl->mutex);
1344
1345 wl1271_notice("power up");
1346
1347 if (wl->state != WL1271_STATE_OFF) {
1348 wl1271_error("cannot go into PLT state because not "
1349 "in off state: %d", wl->state);
1350 ret = -EBUSY;
1351 goto out;
1352 }
1353
Arik Nemtsov166d5042010-10-16 21:44:57 +02001354 wl->bss_type = BSS_TYPE_STA_BSS;
1355
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001356 while (retries) {
1357 retries--;
1358 ret = wl1271_chip_wakeup(wl);
1359 if (ret < 0)
1360 goto power_off;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001361
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001362 ret = wl1271_boot(wl);
1363 if (ret < 0)
1364 goto power_off;
1365
1366 ret = wl1271_plt_init(wl);
1367 if (ret < 0)
1368 goto irq_disable;
1369
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001370 wl->state = WL1271_STATE_PLT;
1371 wl1271_notice("firmware booted in PLT mode (%s)",
Levi, Shahar4b7fac72011-01-23 07:27:22 +01001372 wl->chip.fw_ver_str);
Luciano Coelhoe7ddf542011-03-10 15:24:57 +02001373
Gery Kahn6f07b722011-07-18 14:21:49 +03001374 /* update hw/fw version info in wiphy struct */
1375 wiphy->hw_version = wl->chip.id;
1376 strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
1377 sizeof(wiphy->fw_version));
1378
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001379 goto out;
1380
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001381irq_disable:
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001382 mutex_unlock(&wl->mutex);
1383 /* Unlocking the mutex in the middle of handling is
1384 inherently unsafe. In this case we deem it safe to do,
1385 because we need to let any possibly pending IRQ out of
1386 the system (and while we are WL1271_STATE_OFF the IRQ
1387 work function will not do anything.) Also, any other
1388 possible concurrent operations will fail due to the
1389 current state, hence the wl1271 struct should be safe. */
Ido Yariva6208652011-03-01 15:14:41 +02001390 wl1271_disable_interrupts(wl);
1391 wl1271_flush_deferred_work(wl);
1392 cancel_work_sync(&wl->netstack_work);
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001393 mutex_lock(&wl->mutex);
1394power_off:
1395 wl1271_power_off(wl);
1396 }
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001397
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001398 wl1271_error("firmware boot in PLT mode failed despite %d retries",
1399 WL1271_BOOT_RETRIES);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001400out:
1401 mutex_unlock(&wl->mutex);
1402
1403 return ret;
1404}
1405
Luciano Coelho4623ec72011-03-21 19:26:41 +02001406static int __wl1271_plt_stop(struct wl1271 *wl)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001407{
1408 int ret = 0;
1409
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001410 wl1271_notice("power down");
1411
1412 if (wl->state != WL1271_STATE_PLT) {
1413 wl1271_error("cannot power down because not in PLT "
1414 "state: %d", wl->state);
1415 ret = -EBUSY;
1416 goto out;
1417 }
1418
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001419 wl1271_power_off(wl);
1420
1421 wl->state = WL1271_STATE_OFF;
Luciano Coelhobd5ea182009-10-13 12:47:58 +03001422 wl->rx_counter = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001423
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001424 mutex_unlock(&wl->mutex);
Ido Yariva6208652011-03-01 15:14:41 +02001425 wl1271_disable_interrupts(wl);
1426 wl1271_flush_deferred_work(wl);
1427 cancel_work_sync(&wl->netstack_work);
Juuso Oikarinen52b0e7a2010-09-21 06:23:31 +02001428 cancel_work_sync(&wl->recovery_work);
Juuso Oikarinen4ae3fa82011-01-14 12:48:46 +01001429 mutex_lock(&wl->mutex);
1430out:
1431 return ret;
1432}
Juuso Oikarinen8c7f4f32010-09-21 06:23:29 +02001433
Juuso Oikarinen4ae3fa82011-01-14 12:48:46 +01001434int wl1271_plt_stop(struct wl1271 *wl)
1435{
1436 int ret;
1437
1438 mutex_lock(&wl->mutex);
1439 ret = __wl1271_plt_stop(wl);
1440 mutex_unlock(&wl->mutex);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001441 return ret;
1442}
1443
Johannes Berg7bb45682011-02-24 14:42:06 +01001444static void wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001445{
1446 struct wl1271 *wl = hw->priv;
Juuso Oikarinen830fb672009-12-11 15:41:06 +02001447 unsigned long flags;
Arik Nemtsov708bb3c2011-06-24 13:03:37 +03001448 int q, mapping;
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +02001449 u8 hlid = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001450
Arik Nemtsov708bb3c2011-06-24 13:03:37 +03001451 mapping = skb_get_queue_mapping(skb);
1452 q = wl1271_tx_get_queue(mapping);
Ido Yarivb07d4032011-03-01 15:14:43 +02001453
1454 if (wl->bss_type == BSS_TYPE_AP_BSS)
Eliad Pellerf4df1bd2011-08-14 13:17:15 +03001455 hlid = wl12xx_tx_get_hlid_ap(wl, skb);
Ido Yarivb07d4032011-03-01 15:14:43 +02001456
Juuso Oikarinen830fb672009-12-11 15:41:06 +02001457 spin_lock_irqsave(&wl->wl_lock, flags);
Ido Yarivb07d4032011-03-01 15:14:43 +02001458
Arik Nemtsovf1a46382011-07-07 14:25:23 +03001459 wl->tx_queue_count[q]++;
Arik Nemtsovf4d08dd2011-02-23 00:22:24 +02001460
1461 /*
1462 * The workqueue is slow to process the tx_queue and we need stop
1463 * the queue here, otherwise the queue will get too long.
1464 */
Arik Nemtsovf1a46382011-07-07 14:25:23 +03001465 if (wl->tx_queue_count[q] >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
Arik Nemtsov708bb3c2011-06-24 13:03:37 +03001466 wl1271_debug(DEBUG_TX, "op_tx: stopping queues for q %d", q);
1467 ieee80211_stop_queue(wl->hw, mapping);
1468 set_bit(q, &wl->stopped_queues_map);
Arik Nemtsovf4d08dd2011-02-23 00:22:24 +02001469 }
1470
Juuso Oikarinen830fb672009-12-11 15:41:06 +02001471 /* queue the packet */
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +02001472 if (wl->bss_type == BSS_TYPE_AP_BSS) {
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +02001473 wl1271_debug(DEBUG_TX, "queue skb hlid %d q %d", hlid, q);
1474 skb_queue_tail(&wl->links[hlid].tx_queue[q], skb);
1475 } else {
1476 skb_queue_tail(&wl->tx_queue[q], skb);
1477 }
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001478
1479 /*
1480 * The chip specific setup must run before the first TX packet -
1481 * before that, the tx_work will not be initialized!
1482 */
1483
Ido Yarivb07d4032011-03-01 15:14:43 +02001484 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
1485 !test_bit(WL1271_FLAG_TX_PENDING, &wl->flags))
Ido Yariva5225502010-10-12 14:49:10 +02001486 ieee80211_queue_work(wl->hw, &wl->tx_work);
Ido Yarivb07d4032011-03-01 15:14:43 +02001487
1488 spin_unlock_irqrestore(&wl->wl_lock, flags);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001489}
1490
Shahar Leviae47c452011-03-06 16:32:14 +02001491int wl1271_tx_dummy_packet(struct wl1271 *wl)
1492{
Ido Yariv990f5de2011-03-31 10:06:59 +02001493 unsigned long flags;
Arik Nemtsovf1a46382011-07-07 14:25:23 +03001494 int q = wl1271_tx_get_queue(skb_get_queue_mapping(wl->dummy_packet));
Shahar Leviae47c452011-03-06 16:32:14 +02001495
Ido Yariv990f5de2011-03-31 10:06:59 +02001496 spin_lock_irqsave(&wl->wl_lock, flags);
1497 set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags);
Arik Nemtsovf1a46382011-07-07 14:25:23 +03001498 wl->tx_queue_count[q]++;
Ido Yariv990f5de2011-03-31 10:06:59 +02001499 spin_unlock_irqrestore(&wl->wl_lock, flags);
1500
1501 /* The FW is low on RX memory blocks, so send the dummy packet asap */
1502 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags))
1503 wl1271_tx_work_locked(wl);
1504
1505 /*
1506 * If the FW TX is busy, TX work will be scheduled by the threaded
1507 * interrupt handler function
1508 */
1509 return 0;
1510}
1511
1512/*
1513 * The size of the dummy packet should be at least 1400 bytes. However, in
1514 * order to minimize the number of bus transactions, aligning it to 512 bytes
1515 * boundaries could be beneficial, performance wise
1516 */
1517#define TOTAL_TX_DUMMY_PACKET_SIZE (ALIGN(1400, 512))
1518
Luciano Coelhocf27d862011-04-01 21:08:23 +03001519static struct sk_buff *wl12xx_alloc_dummy_packet(struct wl1271 *wl)
Ido Yariv990f5de2011-03-31 10:06:59 +02001520{
1521 struct sk_buff *skb;
1522 struct ieee80211_hdr_3addr *hdr;
1523 unsigned int dummy_packet_size;
1524
1525 dummy_packet_size = TOTAL_TX_DUMMY_PACKET_SIZE -
1526 sizeof(struct wl1271_tx_hw_descr) - sizeof(*hdr);
1527
1528 skb = dev_alloc_skb(TOTAL_TX_DUMMY_PACKET_SIZE);
Shahar Leviae47c452011-03-06 16:32:14 +02001529 if (!skb) {
Ido Yariv990f5de2011-03-31 10:06:59 +02001530 wl1271_warning("Failed to allocate a dummy packet skb");
1531 return NULL;
Shahar Leviae47c452011-03-06 16:32:14 +02001532 }
1533
1534 skb_reserve(skb, sizeof(struct wl1271_tx_hw_descr));
1535
1536 hdr = (struct ieee80211_hdr_3addr *) skb_put(skb, sizeof(*hdr));
1537 memset(hdr, 0, sizeof(*hdr));
1538 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
Ido Yariv990f5de2011-03-31 10:06:59 +02001539 IEEE80211_STYPE_NULLFUNC |
1540 IEEE80211_FCTL_TODS);
Shahar Leviae47c452011-03-06 16:32:14 +02001541
Ido Yariv990f5de2011-03-31 10:06:59 +02001542 memset(skb_put(skb, dummy_packet_size), 0, dummy_packet_size);
Shahar Leviae47c452011-03-06 16:32:14 +02001543
Luciano Coelho18b92ff2011-03-21 16:35:21 +02001544 /* Dummy packets require the TID to be management */
1545 skb->priority = WL1271_TID_MGMT;
Ido Yariv990f5de2011-03-31 10:06:59 +02001546
1547 /* Initialize all fields that might be used */
Hauke Mehrtens86c438f2011-04-26 23:27:44 +02001548 skb_set_queue_mapping(skb, 0);
Ido Yariv990f5de2011-03-31 10:06:59 +02001549 memset(IEEE80211_SKB_CB(skb), 0, sizeof(struct ieee80211_tx_info));
Shahar Leviae47c452011-03-06 16:32:14 +02001550
Ido Yariv990f5de2011-03-31 10:06:59 +02001551 return skb;
Shahar Leviae47c452011-03-06 16:32:14 +02001552}
1553
Ido Yariv990f5de2011-03-31 10:06:59 +02001554
Juuso Oikarinenc2c192a2010-07-27 03:30:09 +03001555static struct notifier_block wl1271_dev_notifier = {
1556 .notifier_call = wl1271_dev_notify,
1557};
1558
Luciano Coelhof634a4e2011-05-18 16:51:26 -04001559#ifdef CONFIG_PM
Eliad Peller8a7cf3f2011-06-06 12:21:54 +03001560static int wl1271_configure_suspend_sta(struct wl1271 *wl)
Eliad Peller94390642011-05-13 11:57:13 +03001561{
Eliad Pellere85d1622011-06-27 13:06:43 +03001562 int ret = 0;
Eliad Peller94390642011-05-13 11:57:13 +03001563
Eliad Peller94390642011-05-13 11:57:13 +03001564 mutex_lock(&wl->mutex);
1565
Eliad Pellere85d1622011-06-27 13:06:43 +03001566 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1567 goto out_unlock;
1568
Eliad Peller94390642011-05-13 11:57:13 +03001569 ret = wl1271_ps_elp_wakeup(wl);
1570 if (ret < 0)
1571 goto out_unlock;
1572
1573 /* enter psm if needed*/
1574 if (!test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1575 DECLARE_COMPLETION_ONSTACK(compl);
1576
1577 wl->ps_compl = &compl;
1578 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1579 wl->basic_rate, true);
1580 if (ret < 0)
1581 goto out_sleep;
1582
1583 /* we must unlock here so we will be able to get events */
1584 wl1271_ps_elp_sleep(wl);
1585 mutex_unlock(&wl->mutex);
1586
1587 ret = wait_for_completion_timeout(
1588 &compl, msecs_to_jiffies(WL1271_PS_COMPLETE_TIMEOUT));
1589 if (ret <= 0) {
1590 wl1271_warning("couldn't enter ps mode!");
1591 ret = -EBUSY;
1592 goto out;
1593 }
1594
1595 /* take mutex again, and wakeup */
1596 mutex_lock(&wl->mutex);
1597
1598 ret = wl1271_ps_elp_wakeup(wl);
1599 if (ret < 0)
1600 goto out_unlock;
1601 }
1602out_sleep:
1603 wl1271_ps_elp_sleep(wl);
1604out_unlock:
1605 mutex_unlock(&wl->mutex);
1606out:
1607 return ret;
1608
1609}
1610
Eliad Peller8a7cf3f2011-06-06 12:21:54 +03001611static int wl1271_configure_suspend_ap(struct wl1271 *wl)
Eliad Peller94390642011-05-13 11:57:13 +03001612{
Eliad Pellere85d1622011-06-27 13:06:43 +03001613 int ret = 0;
Eliad Peller94390642011-05-13 11:57:13 +03001614
Eliad Peller8a7cf3f2011-06-06 12:21:54 +03001615 mutex_lock(&wl->mutex);
1616
Eliad Pellere85d1622011-06-27 13:06:43 +03001617 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags))
1618 goto out_unlock;
1619
Eliad Peller8a7cf3f2011-06-06 12:21:54 +03001620 ret = wl1271_ps_elp_wakeup(wl);
1621 if (ret < 0)
1622 goto out_unlock;
1623
Eliad Pellerf42bd2c2011-08-14 13:17:13 +03001624 ret = wl1271_acx_beacon_filter_opt(wl, true);
Eliad Peller8a7cf3f2011-06-06 12:21:54 +03001625
1626 wl1271_ps_elp_sleep(wl);
1627out_unlock:
1628 mutex_unlock(&wl->mutex);
1629 return ret;
1630
1631}
1632
1633static int wl1271_configure_suspend(struct wl1271 *wl)
1634{
1635 if (wl->bss_type == BSS_TYPE_STA_BSS)
1636 return wl1271_configure_suspend_sta(wl);
1637 if (wl->bss_type == BSS_TYPE_AP_BSS)
1638 return wl1271_configure_suspend_ap(wl);
1639 return 0;
1640}
1641
1642static void wl1271_configure_resume(struct wl1271 *wl)
1643{
1644 int ret;
1645 bool is_sta = wl->bss_type == BSS_TYPE_STA_BSS;
1646 bool is_ap = wl->bss_type == BSS_TYPE_AP_BSS;
1647
1648 if (!is_sta && !is_ap)
Eliad Peller94390642011-05-13 11:57:13 +03001649 return;
1650
1651 mutex_lock(&wl->mutex);
1652 ret = wl1271_ps_elp_wakeup(wl);
1653 if (ret < 0)
1654 goto out;
1655
Eliad Peller8a7cf3f2011-06-06 12:21:54 +03001656 if (is_sta) {
1657 /* exit psm if it wasn't configured */
1658 if (!test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags))
1659 wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1660 wl->basic_rate, true);
1661 } else if (is_ap) {
Eliad Pellerf42bd2c2011-08-14 13:17:13 +03001662 wl1271_acx_beacon_filter_opt(wl, false);
Eliad Peller8a7cf3f2011-06-06 12:21:54 +03001663 }
Eliad Peller94390642011-05-13 11:57:13 +03001664
1665 wl1271_ps_elp_sleep(wl);
1666out:
1667 mutex_unlock(&wl->mutex);
1668}
1669
Eliad Peller402e48612011-05-13 11:57:09 +03001670static int wl1271_op_suspend(struct ieee80211_hw *hw,
1671 struct cfg80211_wowlan *wow)
1672{
1673 struct wl1271 *wl = hw->priv;
Eliad Peller4a859df2011-06-06 12:21:52 +03001674 int ret;
1675
Eliad Peller402e48612011-05-13 11:57:09 +03001676 wl1271_debug(DEBUG_MAC80211, "mac80211 suspend wow=%d", !!wow);
Eliad Peller4a859df2011-06-06 12:21:52 +03001677 WARN_ON(!wow || !wow->any);
Eliad Pellerf44e5862011-05-13 11:57:11 +03001678
Eliad Peller4a859df2011-06-06 12:21:52 +03001679 wl->wow_enabled = true;
1680 ret = wl1271_configure_suspend(wl);
1681 if (ret < 0) {
1682 wl1271_warning("couldn't prepare device to suspend");
1683 return ret;
Eliad Pellerf44e5862011-05-13 11:57:11 +03001684 }
Eliad Peller4a859df2011-06-06 12:21:52 +03001685 /* flush any remaining work */
1686 wl1271_debug(DEBUG_MAC80211, "flushing remaining works");
Eliad Peller4a859df2011-06-06 12:21:52 +03001687
1688 /*
1689 * disable and re-enable interrupts in order to flush
1690 * the threaded_irq
1691 */
1692 wl1271_disable_interrupts(wl);
1693
1694 /*
1695 * set suspended flag to avoid triggering a new threaded_irq
1696 * work. no need for spinlock as interrupts are disabled.
1697 */
1698 set_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
1699
1700 wl1271_enable_interrupts(wl);
1701 flush_work(&wl->tx_work);
1702 flush_delayed_work(&wl->pspoll_work);
1703 flush_delayed_work(&wl->elp_work);
1704
Eliad Peller402e48612011-05-13 11:57:09 +03001705 return 0;
1706}
1707
1708static int wl1271_op_resume(struct ieee80211_hw *hw)
1709{
1710 struct wl1271 *wl = hw->priv;
Eliad Peller4a859df2011-06-06 12:21:52 +03001711 unsigned long flags;
1712 bool run_irq_work = false;
1713
Eliad Peller402e48612011-05-13 11:57:09 +03001714 wl1271_debug(DEBUG_MAC80211, "mac80211 resume wow=%d",
1715 wl->wow_enabled);
Eliad Peller4a859df2011-06-06 12:21:52 +03001716 WARN_ON(!wl->wow_enabled);
Eliad Pellerf44e5862011-05-13 11:57:11 +03001717
1718 /*
1719 * re-enable irq_work enqueuing, and call irq_work directly if
1720 * there is a pending work.
1721 */
Eliad Peller4a859df2011-06-06 12:21:52 +03001722 spin_lock_irqsave(&wl->wl_lock, flags);
1723 clear_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
1724 if (test_and_clear_bit(WL1271_FLAG_PENDING_WORK, &wl->flags))
1725 run_irq_work = true;
1726 spin_unlock_irqrestore(&wl->wl_lock, flags);
Eliad Pellerf44e5862011-05-13 11:57:11 +03001727
Eliad Peller4a859df2011-06-06 12:21:52 +03001728 if (run_irq_work) {
1729 wl1271_debug(DEBUG_MAC80211,
1730 "run postponed irq_work directly");
1731 wl1271_irq(0, wl);
1732 wl1271_enable_interrupts(wl);
Eliad Pellerf44e5862011-05-13 11:57:11 +03001733 }
Eliad Peller4a859df2011-06-06 12:21:52 +03001734 wl1271_configure_resume(wl);
Eliad Pellerff91afc2011-06-06 12:21:53 +03001735 wl->wow_enabled = false;
Eliad Pellerf44e5862011-05-13 11:57:11 +03001736
Eliad Peller402e48612011-05-13 11:57:09 +03001737 return 0;
1738}
Luciano Coelhof634a4e2011-05-18 16:51:26 -04001739#endif
Eliad Peller402e48612011-05-13 11:57:09 +03001740
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001741static int wl1271_op_start(struct ieee80211_hw *hw)
1742{
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001743 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
1744
1745 /*
1746 * We have to delay the booting of the hardware because
1747 * we need to know the local MAC address before downloading and
1748 * initializing the firmware. The MAC address cannot be changed
1749 * after boot, and without the proper MAC address, the firmware
1750 * will not function properly.
1751 *
1752 * The MAC address is first known when the corresponding interface
1753 * is added. That is where we will initialize the hardware.
1754 */
1755
1756 return 0;
1757}
1758
1759static void wl1271_op_stop(struct ieee80211_hw *hw)
1760{
1761 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
1762}
1763
Eliad Pellerb78b47e2011-08-14 13:17:08 +03001764static u8 wl12xx_get_role_type(struct wl1271 *wl)
1765{
1766 switch (wl->bss_type) {
1767 case BSS_TYPE_AP_BSS:
1768 return WL1271_ROLE_AP;
1769
1770 case BSS_TYPE_STA_BSS:
1771 return WL1271_ROLE_STA;
1772
Eliad Peller227e81e2011-08-14 13:17:26 +03001773 case BSS_TYPE_IBSS:
1774 return WL1271_ROLE_IBSS;
1775
Eliad Pellerb78b47e2011-08-14 13:17:08 +03001776 default:
1777 wl1271_error("invalid bss_type: %d", wl->bss_type);
1778 }
1779 return WL12XX_INVALID_ROLE_TYPE;
1780}
1781
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001782static int wl1271_op_add_interface(struct ieee80211_hw *hw,
1783 struct ieee80211_vif *vif)
1784{
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001785 struct wl1271 *wl = hw->priv;
John W. Linvilleac01e942010-07-28 17:09:41 -04001786 struct wiphy *wiphy = hw->wiphy;
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001787 int retries = WL1271_BOOT_RETRIES;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001788 int ret = 0;
Eliad Pellerb78b47e2011-08-14 13:17:08 +03001789 u8 role_type;
Eliad Peller71125ab2010-10-28 21:46:43 +02001790 bool booted = false;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001791
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001792 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
1793 vif->type, vif->addr);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001794
1795 mutex_lock(&wl->mutex);
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001796 if (wl->vif) {
Eliad Peller71125ab2010-10-28 21:46:43 +02001797 wl1271_debug(DEBUG_MAC80211,
1798 "multiple vifs are not supported yet");
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001799 ret = -EBUSY;
1800 goto out;
1801 }
1802
Juuso Oikarinen13026de2011-03-29 16:43:50 +03001803 /*
1804 * in some very corner case HW recovery scenarios its possible to
1805 * get here before __wl1271_op_remove_interface is complete, so
1806 * opt out if that is the case.
1807 */
1808 if (test_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags)) {
1809 ret = -EBUSY;
1810 goto out;
1811 }
1812
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001813 switch (vif->type) {
1814 case NL80211_IFTYPE_STATION:
1815 wl->bss_type = BSS_TYPE_STA_BSS;
Juuso Oikarinen5da11dc2010-03-26 12:53:24 +02001816 wl->set_bss_type = BSS_TYPE_STA_BSS;
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001817 break;
1818 case NL80211_IFTYPE_ADHOC:
1819 wl->bss_type = BSS_TYPE_IBSS;
Juuso Oikarinen5da11dc2010-03-26 12:53:24 +02001820 wl->set_bss_type = BSS_TYPE_STA_BSS;
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001821 break;
Arik Nemtsov038d9252010-10-16 21:53:24 +02001822 case NL80211_IFTYPE_AP:
1823 wl->bss_type = BSS_TYPE_AP_BSS;
1824 break;
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001825 default:
1826 ret = -EOPNOTSUPP;
1827 goto out;
1828 }
1829
Eliad Pellerb78b47e2011-08-14 13:17:08 +03001830 role_type = wl12xx_get_role_type(wl);
1831 if (role_type == WL12XX_INVALID_ROLE_TYPE) {
1832 ret = -EINVAL;
1833 goto out;
1834 }
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001835 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001836
1837 if (wl->state != WL1271_STATE_OFF) {
1838 wl1271_error("cannot start because not in off state: %d",
1839 wl->state);
1840 ret = -EBUSY;
1841 goto out;
1842 }
1843
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001844 while (retries) {
1845 retries--;
1846 ret = wl1271_chip_wakeup(wl);
1847 if (ret < 0)
1848 goto power_off;
1849
1850 ret = wl1271_boot(wl);
1851 if (ret < 0)
1852 goto power_off;
1853
Eliad Peller227e81e2011-08-14 13:17:26 +03001854 if (wl->bss_type == BSS_TYPE_STA_BSS ||
1855 wl->bss_type == BSS_TYPE_IBSS) {
Eliad Peller04e80792011-08-14 13:17:09 +03001856 /*
1857 * The device role is a special role used for
1858 * rx and tx frames prior to association (as
1859 * the STA role can get packets only from
1860 * its associated bssid)
1861 */
1862 ret = wl12xx_cmd_role_enable(wl,
1863 WL1271_ROLE_DEVICE,
1864 &wl->dev_role_id);
1865 if (ret < 0)
1866 goto irq_disable;
1867 }
1868
Eliad Pellerb78b47e2011-08-14 13:17:08 +03001869 ret = wl12xx_cmd_role_enable(wl, role_type, &wl->role_id);
1870 if (ret < 0)
1871 goto irq_disable;
1872
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001873 ret = wl1271_hw_init(wl);
1874 if (ret < 0)
1875 goto irq_disable;
1876
Eliad Peller71125ab2010-10-28 21:46:43 +02001877 booted = true;
1878 break;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001879
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001880irq_disable:
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001881 mutex_unlock(&wl->mutex);
1882 /* Unlocking the mutex in the middle of handling is
1883 inherently unsafe. In this case we deem it safe to do,
1884 because we need to let any possibly pending IRQ out of
1885 the system (and while we are WL1271_STATE_OFF the IRQ
1886 work function will not do anything.) Also, any other
1887 possible concurrent operations will fail due to the
1888 current state, hence the wl1271 struct should be safe. */
Ido Yariva6208652011-03-01 15:14:41 +02001889 wl1271_disable_interrupts(wl);
1890 wl1271_flush_deferred_work(wl);
1891 cancel_work_sync(&wl->netstack_work);
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001892 mutex_lock(&wl->mutex);
1893power_off:
1894 wl1271_power_off(wl);
1895 }
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001896
Eliad Peller71125ab2010-10-28 21:46:43 +02001897 if (!booted) {
1898 wl1271_error("firmware boot failed despite %d retries",
1899 WL1271_BOOT_RETRIES);
1900 goto out;
1901 }
1902
1903 wl->vif = vif;
1904 wl->state = WL1271_STATE_ON;
Juuso Oikarinen13026de2011-03-29 16:43:50 +03001905 set_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags);
Levi, Shahar4b7fac72011-01-23 07:27:22 +01001906 wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
Eliad Peller71125ab2010-10-28 21:46:43 +02001907
1908 /* update hw/fw version info in wiphy struct */
1909 wiphy->hw_version = wl->chip.id;
Levi, Shahar4b7fac72011-01-23 07:27:22 +01001910 strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
Eliad Peller71125ab2010-10-28 21:46:43 +02001911 sizeof(wiphy->fw_version));
1912
Luciano Coelhofb6a6812010-12-03 17:05:40 +02001913 /*
1914 * Now we know if 11a is supported (info from the NVS), so disable
1915 * 11a channels if not supported
1916 */
1917 if (!wl->enable_11a)
1918 wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0;
1919
1920 wl1271_debug(DEBUG_MAC80211, "11a is %ssupported",
1921 wl->enable_11a ? "" : "not ");
1922
Juuso Oikarineneb5b28d2009-10-13 12:47:45 +03001923out:
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001924 mutex_unlock(&wl->mutex);
1925
Juuso Oikarinenf9f774c2011-03-21 10:43:36 +02001926 mutex_lock(&wl_list_mutex);
Juuso Oikarineneb887df2010-07-08 17:49:58 +03001927 if (!ret)
Juuso Oikarinen01c09162009-10-13 12:47:55 +03001928 list_add(&wl->list, &wl_list);
Juuso Oikarinenf9f774c2011-03-21 10:43:36 +02001929 mutex_unlock(&wl_list_mutex);
Juuso Oikarinen01c09162009-10-13 12:47:55 +03001930
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001931 return ret;
1932}
1933
Arik Nemtsov7dece1c2011-04-18 14:15:28 +03001934static void __wl1271_op_remove_interface(struct wl1271 *wl,
1935 bool reset_tx_queues)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001936{
Eliad Pellerb78b47e2011-08-14 13:17:08 +03001937 int ret;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001938
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001939 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001940
Juuso Oikarinen13026de2011-03-29 16:43:50 +03001941 /* because of hardware recovery, we may get here twice */
1942 if (wl->state != WL1271_STATE_ON)
1943 return;
1944
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001945 wl1271_info("down");
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001946
Juuso Oikarinenf9f774c2011-03-21 10:43:36 +02001947 mutex_lock(&wl_list_mutex);
Juuso Oikarinen01c09162009-10-13 12:47:55 +03001948 list_del(&wl->list);
Juuso Oikarinenf9f774c2011-03-21 10:43:36 +02001949 mutex_unlock(&wl_list_mutex);
Juuso Oikarinen01c09162009-10-13 12:47:55 +03001950
Juuso Oikarinen8d2ef7b2010-07-08 17:50:03 +03001951 /* enable dyn ps just in case (if left on due to fw crash etc) */
Juuso Oikarinen9a547bf2010-07-08 17:50:04 +03001952 if (wl->bss_type == BSS_TYPE_STA_BSS)
Juuso Oikarinenf532be62010-07-08 17:50:05 +03001953 ieee80211_enable_dyn_ps(wl->vif);
Juuso Oikarinen8d2ef7b2010-07-08 17:50:03 +03001954
Luciano Coelho08688d62010-07-08 17:50:07 +03001955 if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
Luciano Coelho08688d62010-07-08 17:50:07 +03001956 wl->scan.state = WL1271_SCAN_STATE_IDLE;
Luciano Coelho4a31c112011-03-21 23:16:14 +02001957 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
Juuso Oikarinenb739a422010-10-26 13:24:38 +02001958 wl->scan.req = NULL;
Juuso Oikarinen76a029f2010-07-29 04:54:45 +03001959 ieee80211_scan_completed(wl->hw, true);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001960 }
1961
Eliad Pellerb78b47e2011-08-14 13:17:08 +03001962 if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags)) {
1963 /* disable active roles */
1964 ret = wl1271_ps_elp_wakeup(wl);
1965 if (ret < 0)
1966 goto deinit;
1967
Eliad Peller04e80792011-08-14 13:17:09 +03001968 if (wl->bss_type == BSS_TYPE_STA_BSS) {
1969 ret = wl12xx_cmd_role_disable(wl, &wl->dev_role_id);
1970 if (ret < 0)
1971 goto deinit;
1972 }
1973
Eliad Pellerb78b47e2011-08-14 13:17:08 +03001974 ret = wl12xx_cmd_role_disable(wl, &wl->role_id);
1975 if (ret < 0)
1976 goto deinit;
1977
1978 wl1271_ps_elp_sleep(wl);
1979 }
1980deinit:
Arik Nemtsove51ae9b2011-08-14 13:17:21 +03001981 /* clear all hlids (except system_hlid) */
Eliad Pellerb78b47e2011-08-14 13:17:08 +03001982 wl->sta_hlid = WL12XX_INVALID_LINK_ID;
Eliad Peller04e80792011-08-14 13:17:09 +03001983 wl->dev_hlid = WL12XX_INVALID_LINK_ID;
Arik Nemtsove51ae9b2011-08-14 13:17:21 +03001984 wl->ap_bcast_hlid = WL12XX_INVALID_LINK_ID;
1985 wl->ap_global_hlid = WL12XX_INVALID_LINK_ID;
Eliad Pellerb78b47e2011-08-14 13:17:08 +03001986
Juuso Oikarinen13026de2011-03-29 16:43:50 +03001987 /*
1988 * this must be before the cancel_work calls below, so that the work
1989 * functions don't perform further work.
1990 */
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001991 wl->state = WL1271_STATE_OFF;
1992
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001993 mutex_unlock(&wl->mutex);
1994
Ido Yariva6208652011-03-01 15:14:41 +02001995 wl1271_disable_interrupts(wl);
1996 wl1271_flush_deferred_work(wl);
Juuso Oikarinen78abd322010-09-21 06:23:32 +02001997 cancel_delayed_work_sync(&wl->scan_complete_work);
Ido Yariva6208652011-03-01 15:14:41 +02001998 cancel_work_sync(&wl->netstack_work);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001999 cancel_work_sync(&wl->tx_work);
Eliad Peller77ddaa12011-05-15 11:10:29 +03002000 del_timer_sync(&wl->rx_streaming_timer);
2001 cancel_work_sync(&wl->rx_streaming_enable_work);
2002 cancel_work_sync(&wl->rx_streaming_disable_work);
Juuso Oikarinen90494a92010-07-08 17:50:00 +03002003 cancel_delayed_work_sync(&wl->pspoll_work);
Juuso Oikarinen8c7f4f32010-09-21 06:23:29 +02002004 cancel_delayed_work_sync(&wl->elp_work);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002005
2006 mutex_lock(&wl->mutex);
2007
2008 /* let's notify MAC80211 about the remaining pending TX frames */
Arik Nemtsov7dece1c2011-04-18 14:15:28 +03002009 wl1271_tx_reset(wl, reset_tx_queues);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002010 wl1271_power_off(wl);
2011
2012 memset(wl->bssid, 0, ETH_ALEN);
Johannes Berg3b40c042011-07-13 10:39:16 +02002013 memset(wl->ssid, 0, IEEE80211_MAX_SSID_LEN + 1);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002014 wl->ssid_len = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002015 wl->bss_type = MAX_BSS_TYPE;
Juuso Oikarinen5da11dc2010-03-26 12:53:24 +02002016 wl->set_bss_type = MAX_BSS_TYPE;
Juuso Oikarinen8a5a37a2009-10-08 21:56:24 +03002017 wl->band = IEEE80211_BAND_2GHZ;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002018
2019 wl->rx_counter = 0;
Juuso Oikarinen19ad0712009-11-02 20:22:11 +02002020 wl->psm_entry_retry = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002021 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2022 wl->tx_blocks_available = 0;
Arik Nemtsov7bb5d6c2011-08-14 13:17:00 +03002023 wl->tx_allocated_blocks = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002024 wl->tx_results_count = 0;
2025 wl->tx_packets_count = 0;
2026 wl->time_offset = 0;
2027 wl->session_counter = 0;
Juuso Oikarinen830fb672009-12-11 15:41:06 +02002028 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02002029 wl->vif = NULL;
Arik Nemtsov7f179b42010-10-16 21:39:06 +02002030 wl1271_free_ap_keys(wl);
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02002031 memset(wl->ap_hlid_map, 0, sizeof(wl->ap_hlid_map));
Arik Nemtsovb622d992011-02-23 00:22:31 +02002032 wl->ap_fw_ps_map = 0;
2033 wl->ap_ps_map = 0;
Luciano Coelho33c2c062011-05-10 14:46:02 +03002034 wl->sched_scanning = false;
Eliad Peller7f0979882011-08-14 13:17:06 +03002035 wl->role_id = WL12XX_INVALID_ROLE_ID;
Eliad Peller04e80792011-08-14 13:17:09 +03002036 wl->dev_role_id = WL12XX_INVALID_ROLE_ID;
Eliad Pellerc690ec82011-08-14 13:17:07 +03002037 memset(wl->roles_map, 0, sizeof(wl->roles_map));
2038 memset(wl->links_map, 0, sizeof(wl->links_map));
Eliad Peller251c1772011-08-14 13:17:17 +03002039 memset(wl->roc_map, 0, sizeof(wl->roc_map));
Luciano Coelhod6e19d12009-10-12 15:08:43 +03002040
Eliad Pellerf4df1bd2011-08-14 13:17:15 +03002041 /* The system link is always allocated */
2042 __set_bit(WL12XX_SYSTEM_HLID, wl->links_map);
2043
Juuso Oikarinen13026de2011-03-29 16:43:50 +03002044 /*
2045 * this is performed after the cancel_work calls and the associated
2046 * mutex_lock, so that wl1271_op_add_interface does not accidentally
2047 * get executed before all these vars have been reset.
2048 */
2049 wl->flags = 0;
2050
Eliad Peller4d56ad92011-08-14 13:17:05 +03002051 wl->tx_blocks_freed = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002052
2053 wl1271_debugfs_reset(wl);
Juuso Oikarinenbd9dc492010-04-09 11:07:26 +03002054
2055 kfree(wl->fw_status);
2056 wl->fw_status = NULL;
2057 kfree(wl->tx_res_if);
2058 wl->tx_res_if = NULL;
2059 kfree(wl->target_mem_map);
2060 wl->target_mem_map = NULL;
Juuso Oikarinen52a2a372010-09-21 06:23:30 +02002061}
Juuso Oikarinenbd9dc492010-04-09 11:07:26 +03002062
Juuso Oikarinen52a2a372010-09-21 06:23:30 +02002063static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
2064 struct ieee80211_vif *vif)
2065{
2066 struct wl1271 *wl = hw->priv;
2067
2068 mutex_lock(&wl->mutex);
Juuso Oikarinen67353292010-11-18 15:19:02 +02002069 /*
2070 * wl->vif can be null here if someone shuts down the interface
2071 * just when hardware recovery has been started.
2072 */
2073 if (wl->vif) {
2074 WARN_ON(wl->vif != vif);
Arik Nemtsov7dece1c2011-04-18 14:15:28 +03002075 __wl1271_op_remove_interface(wl, true);
Juuso Oikarinen67353292010-11-18 15:19:02 +02002076 }
Juuso Oikarinen52b0e7a2010-09-21 06:23:31 +02002077
Juuso Oikarinen67353292010-11-18 15:19:02 +02002078 mutex_unlock(&wl->mutex);
Juuso Oikarinen52b0e7a2010-09-21 06:23:31 +02002079 cancel_work_sync(&wl->recovery_work);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002080}
2081
Juuso Oikarinen69e54342010-05-07 11:39:00 +03002082static int wl1271_join(struct wl1271 *wl, bool set_assoc)
Juuso Oikarinen82429d32010-04-28 09:50:01 +03002083{
2084 int ret;
Eliad Peller227e81e2011-08-14 13:17:26 +03002085 bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS);
Juuso Oikarinen82429d32010-04-28 09:50:01 +03002086
Juuso Oikarinen69e54342010-05-07 11:39:00 +03002087 /*
2088 * One of the side effects of the JOIN command is that is clears
2089 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
2090 * to a WPA/WPA2 access point will therefore kill the data-path.
Ohad Ben-Cohen8bf69aa2011-03-30 19:18:31 +02002091 * Currently the only valid scenario for JOIN during association
2092 * is on roaming, in which case we will also be given new keys.
2093 * Keep the below message for now, unless it starts bothering
2094 * users who really like to roam a lot :)
Juuso Oikarinen69e54342010-05-07 11:39:00 +03002095 */
2096 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2097 wl1271_info("JOIN while associated.");
2098
2099 if (set_assoc)
2100 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
2101
Eliad Peller227e81e2011-08-14 13:17:26 +03002102 if (is_ibss)
2103 ret = wl12xx_cmd_role_start_ibss(wl);
2104 else
2105 ret = wl12xx_cmd_role_start_sta(wl);
Juuso Oikarinen82429d32010-04-28 09:50:01 +03002106 if (ret < 0)
2107 goto out;
2108
Juuso Oikarinen82429d32010-04-28 09:50:01 +03002109 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2110 goto out;
2111
2112 /*
2113 * The join command disable the keep-alive mode, shut down its process,
2114 * and also clear the template config, so we need to reset it all after
2115 * the join. The acx_aid starts the keep-alive process, and the order
2116 * of the commands below is relevant.
2117 */
2118 ret = wl1271_acx_keep_alive_mode(wl, true);
2119 if (ret < 0)
2120 goto out;
2121
2122 ret = wl1271_acx_aid(wl, wl->aid);
2123 if (ret < 0)
2124 goto out;
2125
2126 ret = wl1271_cmd_build_klv_null_data(wl);
2127 if (ret < 0)
2128 goto out;
2129
2130 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
2131 ACX_KEEP_ALIVE_TPL_VALID);
2132 if (ret < 0)
2133 goto out;
2134
2135out:
2136 return ret;
2137}
2138
2139static int wl1271_unjoin(struct wl1271 *wl)
Luciano Coelhoc7f43e42009-12-11 15:40:44 +02002140{
2141 int ret;
2142
2143 /* to stop listening to a channel, we disconnect */
Eliad Pellerc690ec82011-08-14 13:17:07 +03002144 ret = wl12xx_cmd_role_stop_sta(wl);
Luciano Coelhoc7f43e42009-12-11 15:40:44 +02002145 if (ret < 0)
2146 goto out;
2147
Luciano Coelhoc7f43e42009-12-11 15:40:44 +02002148 memset(wl->bssid, 0, ETH_ALEN);
Juuso Oikarinen14b228a2010-03-18 12:26:43 +02002149
Oz Krakowskib992c682011-06-26 10:36:02 +03002150 /* reset TX security counters on a clean disconnect */
2151 wl->tx_security_last_seq_lsb = 0;
2152 wl->tx_security_seq = 0;
2153
Luciano Coelhoc7f43e42009-12-11 15:40:44 +02002154out:
2155 return ret;
2156}
2157
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03002158static void wl1271_set_band_rate(struct wl1271 *wl)
2159{
2160 if (wl->band == IEEE80211_BAND_2GHZ)
2161 wl->basic_rate_set = wl->conf.tx.basic_rate;
2162 else
2163 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
2164}
2165
Eliad Peller251c1772011-08-14 13:17:17 +03002166static bool wl12xx_is_roc(struct wl1271 *wl)
2167{
2168 u8 role_id;
2169
2170 role_id = find_first_bit(wl->roc_map, WL12XX_MAX_ROLES);
2171 if (role_id >= WL12XX_MAX_ROLES)
2172 return false;
2173
2174 return true;
2175}
2176
Arik Nemtsovbee0ffe2010-10-16 19:17:02 +02002177static int wl1271_sta_handle_idle(struct wl1271 *wl, bool idle)
Juuso Oikarinen0d58cbf2010-05-24 11:18:16 +03002178{
2179 int ret;
2180
2181 if (idle) {
Eliad Peller251c1772011-08-14 13:17:17 +03002182 /* no need to croc if we weren't busy (e.g. during boot) */
2183 if (wl12xx_is_roc(wl)) {
2184 ret = wl12xx_croc(wl, wl->dev_role_id);
2185 if (ret < 0)
2186 goto out;
2187
2188 ret = wl12xx_cmd_role_stop_dev(wl);
Juuso Oikarinen0d58cbf2010-05-24 11:18:16 +03002189 if (ret < 0)
2190 goto out;
2191 }
Arik Nemtsove0fe3712010-10-16 18:19:53 +02002192 wl->rate_set = wl1271_tx_min_rate_get(wl);
Arik Nemtsov79b223f2010-10-16 17:52:59 +02002193 ret = wl1271_acx_sta_rate_policies(wl);
Juuso Oikarinen0d58cbf2010-05-24 11:18:16 +03002194 if (ret < 0)
2195 goto out;
2196 ret = wl1271_acx_keep_alive_config(
2197 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
2198 ACX_KEEP_ALIVE_TPL_INVALID);
2199 if (ret < 0)
2200 goto out;
2201 set_bit(WL1271_FLAG_IDLE, &wl->flags);
2202 } else {
Luciano Coelho33c2c062011-05-10 14:46:02 +03002203 /* The current firmware only supports sched_scan in idle */
2204 if (wl->sched_scanning) {
2205 wl1271_scan_sched_scan_stop(wl);
2206 ieee80211_sched_scan_stopped(wl->hw);
2207 }
2208
Eliad Peller251c1772011-08-14 13:17:17 +03002209 ret = wl12xx_cmd_role_start_dev(wl);
2210 if (ret < 0)
2211 goto out;
2212
2213 ret = wl12xx_roc(wl, wl->dev_role_id);
Juuso Oikarinen0d58cbf2010-05-24 11:18:16 +03002214 if (ret < 0)
2215 goto out;
2216 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
2217 }
2218
2219out:
2220 return ret;
2221}
2222
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002223static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
2224{
2225 struct wl1271 *wl = hw->priv;
2226 struct ieee80211_conf *conf = &hw->conf;
2227 int channel, ret = 0;
Arik Nemtsovbee0ffe2010-10-16 19:17:02 +02002228 bool is_ap;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002229
2230 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
2231
Arik Nemtsovbee0ffe2010-10-16 19:17:02 +02002232 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s"
2233 " changed 0x%x",
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002234 channel,
2235 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
Luciano Coelhoc7f43e42009-12-11 15:40:44 +02002236 conf->power_level,
Arik Nemtsovbee0ffe2010-10-16 19:17:02 +02002237 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
2238 changed);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002239
Juuso Oikarinen781608c2010-05-24 11:18:17 +03002240 /*
2241 * mac80211 will go to idle nearly immediately after transmitting some
2242 * frames, such as the deauth. To make sure those frames reach the air,
2243 * wait here until the TX queue is fully flushed.
2244 */
2245 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
2246 (conf->flags & IEEE80211_CONF_IDLE))
2247 wl1271_tx_flush(wl);
2248
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002249 mutex_lock(&wl->mutex);
2250
Juuso Oikarinenf8d98022010-10-26 13:24:39 +02002251 if (unlikely(wl->state == WL1271_STATE_OFF)) {
Arik Nemtsov17e672d2011-03-22 10:07:47 +02002252 /* we support configuring the channel and band while off */
2253 if ((changed & IEEE80211_CONF_CHANGE_CHANNEL)) {
2254 wl->band = conf->channel->band;
2255 wl->channel = channel;
2256 }
2257
Arik Nemtsov097f8822011-06-27 22:06:34 +03002258 if ((changed & IEEE80211_CONF_CHANGE_POWER))
2259 wl->power_level = conf->power_level;
2260
Saravanan Dhanabal2c10bb92010-04-09 11:07:27 +03002261 goto out;
Juuso Oikarinenf8d98022010-10-26 13:24:39 +02002262 }
Juuso Oikarinen8a5a37a2009-10-08 21:56:24 +03002263
Arik Nemtsovbee0ffe2010-10-16 19:17:02 +02002264 is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2265
Ido Yariva6208652011-03-01 15:14:41 +02002266 ret = wl1271_ps_elp_wakeup(wl);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002267 if (ret < 0)
2268 goto out;
2269
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03002270 /* if the channel changes while joined, join again */
Juuso Oikarinen69e54342010-05-07 11:39:00 +03002271 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
2272 ((wl->band != conf->channel->band) ||
2273 (wl->channel != channel))) {
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03002274 wl->band = conf->channel->band;
2275 wl->channel = channel;
2276
Arik Nemtsovbee0ffe2010-10-16 19:17:02 +02002277 if (!is_ap) {
2278 /*
2279 * FIXME: the mac80211 should really provide a fixed
2280 * rate to use here. for now, just use the smallest
2281 * possible rate for the band as a fixed rate for
2282 * association frames and other control messages.
2283 */
2284 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2285 wl1271_set_band_rate(wl);
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03002286
Arik Nemtsovbee0ffe2010-10-16 19:17:02 +02002287 wl->basic_rate = wl1271_tx_min_rate_get(wl);
2288 ret = wl1271_acx_sta_rate_policies(wl);
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03002289 if (ret < 0)
Arik Nemtsovbee0ffe2010-10-16 19:17:02 +02002290 wl1271_warning("rate policy for channel "
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03002291 "failed %d", ret);
Arik Nemtsovbee0ffe2010-10-16 19:17:02 +02002292
Eliad Peller251c1772011-08-14 13:17:17 +03002293 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
2294 if (wl12xx_is_roc(wl)) {
2295 /* roaming */
2296 ret = wl12xx_croc(wl, wl->dev_role_id);
2297 if (ret < 0)
2298 goto out_sleep;
2299 }
Arik Nemtsovbee0ffe2010-10-16 19:17:02 +02002300 ret = wl1271_join(wl, false);
2301 if (ret < 0)
2302 wl1271_warning("cmd join on channel "
2303 "failed %d", ret);
Eliad Peller251c1772011-08-14 13:17:17 +03002304 } else {
2305 /*
2306 * change the ROC channel. do it only if we are
2307 * not idle. otherwise, CROC will be called
2308 * anyway.
2309 */
2310 if (wl12xx_is_roc(wl) &&
2311 !(conf->flags & IEEE80211_CONF_IDLE)) {
2312 ret = wl12xx_croc(wl, wl->dev_role_id);
2313 if (ret < 0)
2314 goto out_sleep;
2315
2316 ret = wl12xx_roc(wl, wl->dev_role_id);
2317 if (ret < 0)
2318 wl1271_warning("roc failed %d",
2319 ret);
2320 }
Arik Nemtsovbee0ffe2010-10-16 19:17:02 +02002321 }
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03002322 }
2323 }
2324
Arik Nemtsovbee0ffe2010-10-16 19:17:02 +02002325 if (changed & IEEE80211_CONF_CHANGE_IDLE && !is_ap) {
2326 ret = wl1271_sta_handle_idle(wl,
2327 conf->flags & IEEE80211_CONF_IDLE);
Juuso Oikarinen0d58cbf2010-05-24 11:18:16 +03002328 if (ret < 0)
2329 wl1271_warning("idle mode change failed %d", ret);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002330 }
2331
Juuso Oikarinen90494a92010-07-08 17:50:00 +03002332 /*
2333 * if mac80211 changes the PSM mode, make sure the mode is not
2334 * incorrectly changed after the pspoll failure active window.
2335 */
2336 if (changed & IEEE80211_CONF_CHANGE_PS)
2337 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
2338
Juuso Oikarinen71449f82009-12-11 15:41:07 +02002339 if (conf->flags & IEEE80211_CONF_PS &&
2340 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
2341 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002342
2343 /*
2344 * We enter PSM only if we're already associated.
2345 * If we're not, we'll enter it when joining an SSID,
2346 * through the bss_info_changed() hook.
2347 */
Juuso Oikarinen830fb672009-12-11 15:41:06 +02002348 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
Juuso Oikarinen18f8d462010-02-22 08:38:34 +02002349 wl1271_debug(DEBUG_PSM, "psm enabled");
Juuso Oikarinend8c42c02010-02-18 13:25:36 +02002350 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
Juuso Oikarinen8eab7b42010-09-24 03:10:11 +02002351 wl->basic_rate, true);
Juuso Oikarinenaf5e0842009-12-11 15:41:00 +02002352 }
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002353 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
Juuso Oikarinen71449f82009-12-11 15:41:07 +02002354 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
Juuso Oikarinen18f8d462010-02-22 08:38:34 +02002355 wl1271_debug(DEBUG_PSM, "psm disabled");
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002356
Juuso Oikarinen71449f82009-12-11 15:41:07 +02002357 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002358
Juuso Oikarinen71449f82009-12-11 15:41:07 +02002359 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
Juuso Oikarinend8c42c02010-02-18 13:25:36 +02002360 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
Juuso Oikarinen8eab7b42010-09-24 03:10:11 +02002361 wl->basic_rate, true);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002362 }
2363
2364 if (conf->power_level != wl->power_level) {
2365 ret = wl1271_acx_tx_power(wl, conf->power_level);
2366 if (ret < 0)
Juuso Oikarinenc6317a52009-11-02 20:22:08 +02002367 goto out_sleep;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002368
2369 wl->power_level = conf->power_level;
2370 }
2371
2372out_sleep:
2373 wl1271_ps_elp_sleep(wl);
2374
2375out:
2376 mutex_unlock(&wl->mutex);
2377
2378 return ret;
2379}
2380
Juuso Oikarinenb54853f2009-10-13 12:47:59 +03002381struct wl1271_filter_params {
2382 bool enabled;
2383 int mc_list_length;
2384 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
2385};
2386
Jiri Pirko22bedad2010-04-01 21:22:57 +00002387static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
2388 struct netdev_hw_addr_list *mc_list)
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03002389{
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03002390 struct wl1271_filter_params *fp;
Jiri Pirko22bedad2010-04-01 21:22:57 +00002391 struct netdev_hw_addr *ha;
Saravanan Dhanabal2c10bb92010-04-09 11:07:27 +03002392 struct wl1271 *wl = hw->priv;
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03002393
Saravanan Dhanabal2c10bb92010-04-09 11:07:27 +03002394 if (unlikely(wl->state == WL1271_STATE_OFF))
2395 return 0;
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03002396
Juuso Oikarinen74441132009-10-13 12:47:53 +03002397 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03002398 if (!fp) {
2399 wl1271_error("Out of memory setting filters.");
2400 return 0;
2401 }
2402
2403 /* update multicast filtering parameters */
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03002404 fp->mc_list_length = 0;
Jiri Pirko22bedad2010-04-01 21:22:57 +00002405 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
2406 fp->enabled = false;
2407 } else {
2408 fp->enabled = true;
2409 netdev_hw_addr_list_for_each(ha, mc_list) {
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03002410 memcpy(fp->mc_list[fp->mc_list_length],
Jiri Pirko22bedad2010-04-01 21:22:57 +00002411 ha->addr, ETH_ALEN);
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03002412 fp->mc_list_length++;
Jiri Pirko22bedad2010-04-01 21:22:57 +00002413 }
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03002414 }
2415
Juuso Oikarinenb54853f2009-10-13 12:47:59 +03002416 return (u64)(unsigned long)fp;
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03002417}
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002418
Juuso Oikarinenb54853f2009-10-13 12:47:59 +03002419#define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
2420 FIF_ALLMULTI | \
2421 FIF_FCSFAIL | \
2422 FIF_BCN_PRBRESP_PROMISC | \
2423 FIF_CONTROL | \
2424 FIF_OTHER_BSS)
2425
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002426static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
2427 unsigned int changed,
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03002428 unsigned int *total, u64 multicast)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002429{
Juuso Oikarinenb54853f2009-10-13 12:47:59 +03002430 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002431 struct wl1271 *wl = hw->priv;
Juuso Oikarinenb54853f2009-10-13 12:47:59 +03002432 int ret;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002433
Arik Nemtsov7d057862010-10-16 19:25:35 +02002434 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
2435 " total %x", changed, *total);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002436
Juuso Oikarinenb54853f2009-10-13 12:47:59 +03002437 mutex_lock(&wl->mutex);
2438
Saravanan Dhanabal2c10bb92010-04-09 11:07:27 +03002439 *total &= WL1271_SUPPORTED_FILTERS;
2440 changed &= WL1271_SUPPORTED_FILTERS;
2441
2442 if (unlikely(wl->state == WL1271_STATE_OFF))
Juuso Oikarinenb54853f2009-10-13 12:47:59 +03002443 goto out;
2444
Ido Yariva6208652011-03-01 15:14:41 +02002445 ret = wl1271_ps_elp_wakeup(wl);
Juuso Oikarinenb54853f2009-10-13 12:47:59 +03002446 if (ret < 0)
2447 goto out;
2448
Arik Nemtsov7d057862010-10-16 19:25:35 +02002449 if (wl->bss_type != BSS_TYPE_AP_BSS) {
2450 if (*total & FIF_ALLMULTI)
2451 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
2452 else if (fp)
2453 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
2454 fp->mc_list,
2455 fp->mc_list_length);
2456 if (ret < 0)
2457 goto out_sleep;
2458 }
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002459
Eliad Peller08c1d1c2011-08-14 13:17:04 +03002460 /*
2461 * the fw doesn't provide an api to configure the filters. instead,
2462 * the filters configuration is based on the active roles / ROC
2463 * state.
2464 */
Juuso Oikarinenb54853f2009-10-13 12:47:59 +03002465
2466out_sleep:
2467 wl1271_ps_elp_sleep(wl);
2468
2469out:
2470 mutex_unlock(&wl->mutex);
Juuso Oikarinen14b228a2010-03-18 12:26:43 +02002471 kfree(fp);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002472}
2473
Arik Nemtsov7f179b42010-10-16 21:39:06 +02002474static int wl1271_record_ap_key(struct wl1271 *wl, u8 id, u8 key_type,
2475 u8 key_size, const u8 *key, u8 hlid, u32 tx_seq_32,
2476 u16 tx_seq_16)
2477{
2478 struct wl1271_ap_key *ap_key;
2479 int i;
2480
2481 wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);
2482
2483 if (key_size > MAX_KEY_SIZE)
2484 return -EINVAL;
2485
2486 /*
2487 * Find next free entry in ap_keys. Also check we are not replacing
2488 * an existing key.
2489 */
2490 for (i = 0; i < MAX_NUM_KEYS; i++) {
2491 if (wl->recorded_ap_keys[i] == NULL)
2492 break;
2493
2494 if (wl->recorded_ap_keys[i]->id == id) {
2495 wl1271_warning("trying to record key replacement");
2496 return -EINVAL;
2497 }
2498 }
2499
2500 if (i == MAX_NUM_KEYS)
2501 return -EBUSY;
2502
2503 ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
2504 if (!ap_key)
2505 return -ENOMEM;
2506
2507 ap_key->id = id;
2508 ap_key->key_type = key_type;
2509 ap_key->key_size = key_size;
2510 memcpy(ap_key->key, key, key_size);
2511 ap_key->hlid = hlid;
2512 ap_key->tx_seq_32 = tx_seq_32;
2513 ap_key->tx_seq_16 = tx_seq_16;
2514
2515 wl->recorded_ap_keys[i] = ap_key;
2516 return 0;
2517}
2518
2519static void wl1271_free_ap_keys(struct wl1271 *wl)
2520{
2521 int i;
2522
2523 for (i = 0; i < MAX_NUM_KEYS; i++) {
2524 kfree(wl->recorded_ap_keys[i]);
2525 wl->recorded_ap_keys[i] = NULL;
2526 }
2527}
2528
2529static int wl1271_ap_init_hwenc(struct wl1271 *wl)
2530{
2531 int i, ret = 0;
2532 struct wl1271_ap_key *key;
2533 bool wep_key_added = false;
2534
2535 for (i = 0; i < MAX_NUM_KEYS; i++) {
Eliad Peller7f97b482011-08-14 13:17:30 +03002536 u8 hlid;
Arik Nemtsov7f179b42010-10-16 21:39:06 +02002537 if (wl->recorded_ap_keys[i] == NULL)
2538 break;
2539
2540 key = wl->recorded_ap_keys[i];
Eliad Peller7f97b482011-08-14 13:17:30 +03002541 hlid = key->hlid;
2542 if (hlid == WL12XX_INVALID_LINK_ID)
2543 hlid = wl->ap_bcast_hlid;
2544
Arik Nemtsov7f179b42010-10-16 21:39:06 +02002545 ret = wl1271_cmd_set_ap_key(wl, KEY_ADD_OR_REPLACE,
2546 key->id, key->key_type,
2547 key->key_size, key->key,
Eliad Peller7f97b482011-08-14 13:17:30 +03002548 hlid, key->tx_seq_32,
Arik Nemtsov7f179b42010-10-16 21:39:06 +02002549 key->tx_seq_16);
2550 if (ret < 0)
2551 goto out;
2552
2553 if (key->key_type == KEY_WEP)
2554 wep_key_added = true;
2555 }
2556
2557 if (wep_key_added) {
Eliad Pellerc690ec82011-08-14 13:17:07 +03002558 ret = wl12xx_cmd_set_default_wep_key(wl, wl->default_key,
Arik Nemtsove51ae9b2011-08-14 13:17:21 +03002559 wl->ap_bcast_hlid);
Arik Nemtsov7f179b42010-10-16 21:39:06 +02002560 if (ret < 0)
2561 goto out;
2562 }
2563
2564out:
2565 wl1271_free_ap_keys(wl);
2566 return ret;
2567}
2568
2569static int wl1271_set_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
2570 u8 key_size, const u8 *key, u32 tx_seq_32,
2571 u16 tx_seq_16, struct ieee80211_sta *sta)
2572{
2573 int ret;
2574 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2575
2576 if (is_ap) {
2577 struct wl1271_station *wl_sta;
2578 u8 hlid;
2579
2580 if (sta) {
2581 wl_sta = (struct wl1271_station *)sta->drv_priv;
2582 hlid = wl_sta->hlid;
2583 } else {
Arik Nemtsove51ae9b2011-08-14 13:17:21 +03002584 hlid = wl->ap_bcast_hlid;
Arik Nemtsov7f179b42010-10-16 21:39:06 +02002585 }
2586
2587 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2588 /*
2589 * We do not support removing keys after AP shutdown.
2590 * Pretend we do to make mac80211 happy.
2591 */
2592 if (action != KEY_ADD_OR_REPLACE)
2593 return 0;
2594
2595 ret = wl1271_record_ap_key(wl, id,
2596 key_type, key_size,
2597 key, hlid, tx_seq_32,
2598 tx_seq_16);
2599 } else {
2600 ret = wl1271_cmd_set_ap_key(wl, action,
2601 id, key_type, key_size,
2602 key, hlid, tx_seq_32,
2603 tx_seq_16);
2604 }
2605
2606 if (ret < 0)
2607 return ret;
2608 } else {
2609 const u8 *addr;
2610 static const u8 bcast_addr[ETH_ALEN] = {
2611 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2612 };
2613
2614 addr = sta ? sta->addr : bcast_addr;
2615
2616 if (is_zero_ether_addr(addr)) {
2617 /* We dont support TX only encryption */
2618 return -EOPNOTSUPP;
2619 }
2620
2621 /* The wl1271 does not allow to remove unicast keys - they
2622 will be cleared automatically on next CMD_JOIN. Ignore the
2623 request silently, as we dont want the mac80211 to emit
2624 an error message. */
2625 if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
2626 return 0;
2627
2628 ret = wl1271_cmd_set_sta_key(wl, action,
2629 id, key_type, key_size,
2630 key, addr, tx_seq_32,
2631 tx_seq_16);
2632 if (ret < 0)
2633 return ret;
2634
2635 /* the default WEP key needs to be configured at least once */
2636 if (key_type == KEY_WEP) {
Eliad Pellerc690ec82011-08-14 13:17:07 +03002637 ret = wl12xx_cmd_set_default_wep_key(wl,
2638 wl->default_key,
2639 wl->sta_hlid);
Arik Nemtsov7f179b42010-10-16 21:39:06 +02002640 if (ret < 0)
2641 return ret;
2642 }
2643 }
2644
2645 return 0;
2646}
2647
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002648static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
2649 struct ieee80211_vif *vif,
2650 struct ieee80211_sta *sta,
2651 struct ieee80211_key_conf *key_conf)
2652{
2653 struct wl1271 *wl = hw->priv;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002654 int ret;
Juuso Oikarinenac4e4ce2009-10-08 21:56:19 +03002655 u32 tx_seq_32 = 0;
2656 u16 tx_seq_16 = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002657 u8 key_type;
2658
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002659 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
2660
Arik Nemtsov7f179b42010-10-16 21:39:06 +02002661 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002662 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
Johannes Berg97359d12010-08-10 09:46:38 +02002663 key_conf->cipher, key_conf->keyidx,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002664 key_conf->keylen, key_conf->flags);
2665 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
2666
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002667 mutex_lock(&wl->mutex);
2668
Juuso Oikarinenf8d98022010-10-26 13:24:39 +02002669 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2670 ret = -EAGAIN;
2671 goto out_unlock;
2672 }
2673
Ido Yariva6208652011-03-01 15:14:41 +02002674 ret = wl1271_ps_elp_wakeup(wl);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002675 if (ret < 0)
2676 goto out_unlock;
2677
Johannes Berg97359d12010-08-10 09:46:38 +02002678 switch (key_conf->cipher) {
2679 case WLAN_CIPHER_SUITE_WEP40:
2680 case WLAN_CIPHER_SUITE_WEP104:
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002681 key_type = KEY_WEP;
2682
2683 key_conf->hw_key_idx = key_conf->keyidx;
2684 break;
Johannes Berg97359d12010-08-10 09:46:38 +02002685 case WLAN_CIPHER_SUITE_TKIP:
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002686 key_type = KEY_TKIP;
2687
2688 key_conf->hw_key_idx = key_conf->keyidx;
Juuso Oikarinen04e36fc2010-02-22 08:38:40 +02002689 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2690 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002691 break;
Johannes Berg97359d12010-08-10 09:46:38 +02002692 case WLAN_CIPHER_SUITE_CCMP:
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002693 key_type = KEY_AES;
2694
2695 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
Juuso Oikarinen04e36fc2010-02-22 08:38:40 +02002696 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2697 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002698 break;
Juuso Oikarinen7a557242010-09-27 12:42:07 +02002699 case WL1271_CIPHER_SUITE_GEM:
2700 key_type = KEY_GEM;
2701 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2702 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2703 break;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002704 default:
Johannes Berg97359d12010-08-10 09:46:38 +02002705 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002706
2707 ret = -EOPNOTSUPP;
2708 goto out_sleep;
2709 }
2710
2711 switch (cmd) {
2712 case SET_KEY:
Arik Nemtsov7f179b42010-10-16 21:39:06 +02002713 ret = wl1271_set_key(wl, KEY_ADD_OR_REPLACE,
2714 key_conf->keyidx, key_type,
2715 key_conf->keylen, key_conf->key,
2716 tx_seq_32, tx_seq_16, sta);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002717 if (ret < 0) {
2718 wl1271_error("Could not add or replace key");
2719 goto out_sleep;
2720 }
2721 break;
2722
2723 case DISABLE_KEY:
Arik Nemtsov7f179b42010-10-16 21:39:06 +02002724 ret = wl1271_set_key(wl, KEY_REMOVE,
2725 key_conf->keyidx, key_type,
2726 key_conf->keylen, key_conf->key,
2727 0, 0, sta);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002728 if (ret < 0) {
2729 wl1271_error("Could not remove key");
2730 goto out_sleep;
2731 }
2732 break;
2733
2734 default:
2735 wl1271_error("Unsupported key cmd 0x%x", cmd);
2736 ret = -EOPNOTSUPP;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002737 break;
2738 }
2739
2740out_sleep:
2741 wl1271_ps_elp_sleep(wl);
2742
2743out_unlock:
2744 mutex_unlock(&wl->mutex);
2745
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002746 return ret;
2747}
2748
2749static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
Johannes Berga060bbf2010-04-27 11:59:34 +02002750 struct ieee80211_vif *vif,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002751 struct cfg80211_scan_request *req)
2752{
2753 struct wl1271 *wl = hw->priv;
2754 int ret;
2755 u8 *ssid = NULL;
Teemu Paasikiviabb0b3b2009-10-13 12:47:50 +03002756 size_t len = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002757
2758 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
2759
2760 if (req->n_ssids) {
2761 ssid = req->ssids[0].ssid;
Teemu Paasikiviabb0b3b2009-10-13 12:47:50 +03002762 len = req->ssids[0].ssid_len;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002763 }
2764
2765 mutex_lock(&wl->mutex);
2766
Juuso Oikarinenb739a422010-10-26 13:24:38 +02002767 if (wl->state == WL1271_STATE_OFF) {
2768 /*
2769 * We cannot return -EBUSY here because cfg80211 will expect
2770 * a call to ieee80211_scan_completed if we do - in this case
2771 * there won't be any call.
2772 */
2773 ret = -EAGAIN;
2774 goto out;
2775 }
2776
Ido Yariva6208652011-03-01 15:14:41 +02002777 ret = wl1271_ps_elp_wakeup(wl);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002778 if (ret < 0)
2779 goto out;
2780
Eliad Peller251c1772011-08-14 13:17:17 +03002781 /* cancel ROC before scanning */
2782 if (wl12xx_is_roc(wl)) {
2783 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
2784 /* don't allow scanning right now */
2785 ret = -EBUSY;
2786 goto out_sleep;
2787 }
2788 wl12xx_croc(wl, wl->dev_role_id);
2789 wl12xx_cmd_role_stop_dev(wl);
2790 }
2791
Luciano Coelho5924f892010-08-04 03:46:22 +03002792 ret = wl1271_scan(hw->priv, ssid, len, req);
Eliad Peller251c1772011-08-14 13:17:17 +03002793out_sleep:
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002794 wl1271_ps_elp_sleep(wl);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002795out:
2796 mutex_unlock(&wl->mutex);
2797
2798 return ret;
2799}
2800
Eliad Peller73ecce32011-06-27 13:06:45 +03002801static void wl1271_op_cancel_hw_scan(struct ieee80211_hw *hw,
2802 struct ieee80211_vif *vif)
2803{
2804 struct wl1271 *wl = hw->priv;
2805 int ret;
2806
2807 wl1271_debug(DEBUG_MAC80211, "mac80211 cancel hw scan");
2808
2809 mutex_lock(&wl->mutex);
2810
2811 if (wl->state == WL1271_STATE_OFF)
2812 goto out;
2813
2814 if (wl->scan.state == WL1271_SCAN_STATE_IDLE)
2815 goto out;
2816
2817 ret = wl1271_ps_elp_wakeup(wl);
2818 if (ret < 0)
2819 goto out;
2820
2821 if (wl->scan.state != WL1271_SCAN_STATE_DONE) {
2822 ret = wl1271_scan_stop(wl);
2823 if (ret < 0)
2824 goto out_sleep;
2825 }
2826 wl->scan.state = WL1271_SCAN_STATE_IDLE;
2827 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
2828 wl->scan.req = NULL;
2829 ieee80211_scan_completed(wl->hw, true);
2830
2831out_sleep:
2832 wl1271_ps_elp_sleep(wl);
2833out:
2834 mutex_unlock(&wl->mutex);
2835
2836 cancel_delayed_work_sync(&wl->scan_complete_work);
2837}
2838
Luciano Coelho33c2c062011-05-10 14:46:02 +03002839static int wl1271_op_sched_scan_start(struct ieee80211_hw *hw,
2840 struct ieee80211_vif *vif,
2841 struct cfg80211_sched_scan_request *req,
2842 struct ieee80211_sched_scan_ies *ies)
2843{
2844 struct wl1271 *wl = hw->priv;
2845 int ret;
2846
2847 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_start");
2848
2849 mutex_lock(&wl->mutex);
2850
2851 ret = wl1271_ps_elp_wakeup(wl);
2852 if (ret < 0)
2853 goto out;
2854
2855 ret = wl1271_scan_sched_scan_config(wl, req, ies);
2856 if (ret < 0)
2857 goto out_sleep;
2858
2859 ret = wl1271_scan_sched_scan_start(wl);
2860 if (ret < 0)
2861 goto out_sleep;
2862
2863 wl->sched_scanning = true;
2864
2865out_sleep:
2866 wl1271_ps_elp_sleep(wl);
2867out:
2868 mutex_unlock(&wl->mutex);
2869 return ret;
2870}
2871
2872static void wl1271_op_sched_scan_stop(struct ieee80211_hw *hw,
2873 struct ieee80211_vif *vif)
2874{
2875 struct wl1271 *wl = hw->priv;
2876 int ret;
2877
2878 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_stop");
2879
2880 mutex_lock(&wl->mutex);
2881
2882 ret = wl1271_ps_elp_wakeup(wl);
2883 if (ret < 0)
2884 goto out;
2885
2886 wl1271_scan_sched_scan_stop(wl);
2887
2888 wl1271_ps_elp_sleep(wl);
2889out:
2890 mutex_unlock(&wl->mutex);
2891}
2892
Arik Nemtsov68d069c2010-11-08 10:51:07 +01002893static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
2894{
2895 struct wl1271 *wl = hw->priv;
2896 int ret = 0;
2897
2898 mutex_lock(&wl->mutex);
2899
2900 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2901 ret = -EAGAIN;
2902 goto out;
2903 }
2904
Ido Yariva6208652011-03-01 15:14:41 +02002905 ret = wl1271_ps_elp_wakeup(wl);
Arik Nemtsov68d069c2010-11-08 10:51:07 +01002906 if (ret < 0)
2907 goto out;
2908
Arik Nemtsov5f704d12011-04-18 14:15:21 +03002909 ret = wl1271_acx_frag_threshold(wl, value);
Arik Nemtsov68d069c2010-11-08 10:51:07 +01002910 if (ret < 0)
2911 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
2912
2913 wl1271_ps_elp_sleep(wl);
2914
2915out:
2916 mutex_unlock(&wl->mutex);
2917
2918 return ret;
2919}
2920
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002921static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
2922{
2923 struct wl1271 *wl = hw->priv;
Saravanan Dhanabalaecb0562010-04-09 11:07:28 +03002924 int ret = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002925
2926 mutex_lock(&wl->mutex);
2927
Juuso Oikarinenf8d98022010-10-26 13:24:39 +02002928 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2929 ret = -EAGAIN;
Saravanan Dhanabalaecb0562010-04-09 11:07:28 +03002930 goto out;
Juuso Oikarinenf8d98022010-10-26 13:24:39 +02002931 }
Saravanan Dhanabalaecb0562010-04-09 11:07:28 +03002932
Ido Yariva6208652011-03-01 15:14:41 +02002933 ret = wl1271_ps_elp_wakeup(wl);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002934 if (ret < 0)
2935 goto out;
2936
Arik Nemtsov5f704d12011-04-18 14:15:21 +03002937 ret = wl1271_acx_rts_threshold(wl, value);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002938 if (ret < 0)
2939 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
2940
2941 wl1271_ps_elp_sleep(wl);
2942
2943out:
2944 mutex_unlock(&wl->mutex);
2945
2946 return ret;
2947}
2948
Arik Nemtsove78a2872010-10-16 19:07:21 +02002949static int wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *skb,
Juuso Oikarinen2f6724b2010-11-24 08:16:57 +02002950 int offset)
Juuso Oikarinen30240fc2010-02-18 13:25:38 +02002951{
Eliad Peller889cb362011-05-01 09:56:45 +03002952 u8 ssid_len;
2953 const u8 *ptr = cfg80211_find_ie(WLAN_EID_SSID, skb->data + offset,
2954 skb->len - offset);
Juuso Oikarinen30240fc2010-02-18 13:25:38 +02002955
Eliad Peller889cb362011-05-01 09:56:45 +03002956 if (!ptr) {
2957 wl1271_error("No SSID in IEs!");
2958 return -ENOENT;
Juuso Oikarinen30240fc2010-02-18 13:25:38 +02002959 }
Arik Nemtsove78a2872010-10-16 19:07:21 +02002960
Eliad Peller889cb362011-05-01 09:56:45 +03002961 ssid_len = ptr[1];
2962 if (ssid_len > IEEE80211_MAX_SSID_LEN) {
2963 wl1271_error("SSID is too long!");
2964 return -EINVAL;
2965 }
2966
2967 wl->ssid_len = ssid_len;
2968 memcpy(wl->ssid, ptr+2, ssid_len);
2969 return 0;
Juuso Oikarinen30240fc2010-02-18 13:25:38 +02002970}
2971
Arik Nemtsove78a2872010-10-16 19:07:21 +02002972static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
2973 struct ieee80211_bss_conf *bss_conf,
2974 u32 changed)
2975{
2976 int ret = 0;
2977
2978 if (changed & BSS_CHANGED_ERP_SLOT) {
2979 if (bss_conf->use_short_slot)
2980 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
2981 else
2982 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
2983 if (ret < 0) {
2984 wl1271_warning("Set slot time failed %d", ret);
2985 goto out;
2986 }
2987 }
2988
2989 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
2990 if (bss_conf->use_short_preamble)
2991 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
2992 else
2993 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
2994 }
2995
2996 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
2997 if (bss_conf->use_cts_prot)
2998 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
2999 else
3000 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
3001 if (ret < 0) {
3002 wl1271_warning("Set ctsprotect failed %d", ret);
3003 goto out;
3004 }
3005 }
3006
3007out:
3008 return ret;
3009}
3010
3011static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
3012 struct ieee80211_vif *vif,
3013 struct ieee80211_bss_conf *bss_conf,
3014 u32 changed)
3015{
3016 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
3017 int ret = 0;
3018
3019 if ((changed & BSS_CHANGED_BEACON_INT)) {
3020 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
3021 bss_conf->beacon_int);
3022
3023 wl->beacon_int = bss_conf->beacon_int;
3024 }
3025
3026 if ((changed & BSS_CHANGED_BEACON)) {
3027 struct ieee80211_hdr *hdr;
3028 int ieoffset = offsetof(struct ieee80211_mgmt,
3029 u.beacon.variable);
3030 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
3031 u16 tmpl_id;
3032
3033 if (!beacon)
3034 goto out;
3035
3036 wl1271_debug(DEBUG_MASTER, "beacon updated");
3037
3038 ret = wl1271_ssid_set(wl, beacon, ieoffset);
3039 if (ret < 0) {
3040 dev_kfree_skb(beacon);
3041 goto out;
3042 }
3043 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
3044 CMD_TEMPL_BEACON;
3045 ret = wl1271_cmd_template_set(wl, tmpl_id,
3046 beacon->data,
3047 beacon->len, 0,
3048 wl1271_tx_min_rate_get(wl));
3049 if (ret < 0) {
3050 dev_kfree_skb(beacon);
3051 goto out;
3052 }
3053
3054 hdr = (struct ieee80211_hdr *) beacon->data;
3055 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
3056 IEEE80211_STYPE_PROBE_RESP);
3057
3058 tmpl_id = is_ap ? CMD_TEMPL_AP_PROBE_RESPONSE :
3059 CMD_TEMPL_PROBE_RESPONSE;
3060 ret = wl1271_cmd_template_set(wl,
3061 tmpl_id,
3062 beacon->data,
3063 beacon->len, 0,
3064 wl1271_tx_min_rate_get(wl));
3065 dev_kfree_skb(beacon);
3066 if (ret < 0)
3067 goto out;
3068 }
3069
3070out:
3071 return ret;
3072}
3073
3074/* AP mode changes */
3075static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003076 struct ieee80211_vif *vif,
3077 struct ieee80211_bss_conf *bss_conf,
3078 u32 changed)
3079{
Arik Nemtsove78a2872010-10-16 19:07:21 +02003080 int ret = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003081
Arik Nemtsove78a2872010-10-16 19:07:21 +02003082 if ((changed & BSS_CHANGED_BASIC_RATES)) {
3083 u32 rates = bss_conf->basic_rates;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003084
Arik Nemtsove78a2872010-10-16 19:07:21 +02003085 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates);
3086 wl->basic_rate = wl1271_tx_min_rate_get(wl);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003087
Arik Nemtsov70f47422011-04-18 14:15:25 +03003088 ret = wl1271_init_ap_rates(wl);
Arik Nemtsove78a2872010-10-16 19:07:21 +02003089 if (ret < 0) {
Arik Nemtsov70f47422011-04-18 14:15:25 +03003090 wl1271_error("AP rate policy change failed %d", ret);
Arik Nemtsove78a2872010-10-16 19:07:21 +02003091 goto out;
Juuso Oikarinene0d8bbf2009-12-11 15:41:04 +02003092 }
Arik Nemtsovc45a85b2011-04-18 14:15:26 +03003093
3094 ret = wl1271_ap_init_templates(wl);
3095 if (ret < 0)
3096 goto out;
Juuso Oikarinene0d8bbf2009-12-11 15:41:04 +02003097 }
3098
Arik Nemtsove78a2872010-10-16 19:07:21 +02003099 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
3100 if (ret < 0)
3101 goto out;
3102
3103 if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
3104 if (bss_conf->enable_beacon) {
3105 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
Eliad Pellerc690ec82011-08-14 13:17:07 +03003106 ret = wl12xx_cmd_role_start_ap(wl);
Arik Nemtsove78a2872010-10-16 19:07:21 +02003107 if (ret < 0)
3108 goto out;
3109
3110 set_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
3111 wl1271_debug(DEBUG_AP, "started AP");
Arik Nemtsov7f179b42010-10-16 21:39:06 +02003112
3113 ret = wl1271_ap_init_hwenc(wl);
3114 if (ret < 0)
3115 goto out;
Arik Nemtsove78a2872010-10-16 19:07:21 +02003116 }
3117 } else {
3118 if (test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
Eliad Pellerc690ec82011-08-14 13:17:07 +03003119 ret = wl12xx_cmd_role_stop_ap(wl);
Arik Nemtsove78a2872010-10-16 19:07:21 +02003120 if (ret < 0)
3121 goto out;
3122
3123 clear_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
3124 wl1271_debug(DEBUG_AP, "stopped AP");
3125 }
3126 }
3127 }
3128
3129 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
3130 if (ret < 0)
3131 goto out;
Arik Nemtsov0b932ab2011-08-14 13:17:27 +03003132
3133 /* Handle HT information change */
3134 if ((changed & BSS_CHANGED_HT) &&
3135 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
3136 ret = wl1271_acx_set_ht_information(wl,
3137 bss_conf->ht_operation_mode);
3138 if (ret < 0) {
3139 wl1271_warning("Set ht information failed %d", ret);
3140 goto out;
3141 }
3142 }
3143
Arik Nemtsove78a2872010-10-16 19:07:21 +02003144out:
3145 return;
3146}
3147
3148/* STA/IBSS mode changes */
3149static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
3150 struct ieee80211_vif *vif,
3151 struct ieee80211_bss_conf *bss_conf,
3152 u32 changed)
3153{
3154 bool do_join = false, set_assoc = false;
3155 bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS);
Eliad Peller227e81e2011-08-14 13:17:26 +03003156 bool ibss_joined = false;
Eliad Peller72c2d9e2011-02-02 09:59:37 +02003157 u32 sta_rate_set = 0;
Arik Nemtsove78a2872010-10-16 19:07:21 +02003158 int ret;
Luciano Coelho2d6e4e762011-01-11 19:07:21 +01003159 struct ieee80211_sta *sta;
Arik Nemtsova1008852011-02-12 23:24:20 +02003160 bool sta_exists = false;
3161 struct ieee80211_sta_ht_cap sta_ht_cap;
Arik Nemtsove78a2872010-10-16 19:07:21 +02003162
3163 if (is_ibss) {
3164 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
3165 changed);
3166 if (ret < 0)
3167 goto out;
3168 }
3169
Eliad Peller227e81e2011-08-14 13:17:26 +03003170 if (changed & BSS_CHANGED_IBSS) {
3171 if (bss_conf->ibss_joined) {
3172 set_bit(WL1271_FLAG_IBSS_JOINED, &wl->flags);
3173 ibss_joined = true;
3174 } else {
3175 if (test_and_clear_bit(WL1271_FLAG_IBSS_JOINED,
3176 &wl->flags)) {
3177 wl1271_unjoin(wl);
3178 wl12xx_cmd_role_start_dev(wl);
3179 wl12xx_roc(wl, wl->dev_role_id);
3180 }
3181 }
3182 }
3183
3184 if ((changed & BSS_CHANGED_BEACON_INT) && ibss_joined)
Arik Nemtsove78a2872010-10-16 19:07:21 +02003185 do_join = true;
3186
3187 /* Need to update the SSID (for filtering etc) */
Eliad Peller227e81e2011-08-14 13:17:26 +03003188 if ((changed & BSS_CHANGED_BEACON) && ibss_joined)
Arik Nemtsove78a2872010-10-16 19:07:21 +02003189 do_join = true;
3190
Eliad Peller227e81e2011-08-14 13:17:26 +03003191 if ((changed & BSS_CHANGED_BEACON_ENABLED) && ibss_joined) {
Juuso Oikarinen5da11dc2010-03-26 12:53:24 +02003192 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
3193 bss_conf->enable_beacon ? "enabled" : "disabled");
3194
3195 if (bss_conf->enable_beacon)
3196 wl->set_bss_type = BSS_TYPE_IBSS;
3197 else
3198 wl->set_bss_type = BSS_TYPE_STA_BSS;
3199 do_join = true;
3200 }
3201
Arik Nemtsove78a2872010-10-16 19:07:21 +02003202 if ((changed & BSS_CHANGED_CQM)) {
Juuso Oikarinen00236aed2010-04-09 11:07:30 +03003203 bool enable = false;
3204 if (bss_conf->cqm_rssi_thold)
3205 enable = true;
3206 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
3207 bss_conf->cqm_rssi_thold,
3208 bss_conf->cqm_rssi_hyst);
3209 if (ret < 0)
3210 goto out;
3211 wl->rssi_thold = bss_conf->cqm_rssi_thold;
3212 }
3213
Juuso Oikarinen30240fc2010-02-18 13:25:38 +02003214 if ((changed & BSS_CHANGED_BSSID) &&
3215 /*
3216 * Now we know the correct bssid, so we send a new join command
3217 * and enable the BSSID filter
3218 */
3219 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
Arik Nemtsove78a2872010-10-16 19:07:21 +02003220 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
Juuso Oikarinena0cb7be2010-03-18 12:26:44 +02003221
Eliad Pellerfa287b82010-12-26 09:27:50 +01003222 if (!is_zero_ether_addr(wl->bssid)) {
3223 ret = wl1271_cmd_build_null_data(wl);
3224 if (ret < 0)
3225 goto out;
Juuso Oikarinen30240fc2010-02-18 13:25:38 +02003226
Eliad Pellerfa287b82010-12-26 09:27:50 +01003227 ret = wl1271_build_qos_null_data(wl);
3228 if (ret < 0)
3229 goto out;
Saravanan Dhanabal141418c2010-04-28 09:50:00 +03003230
Eliad Pellerfa287b82010-12-26 09:27:50 +01003231 /* Need to update the BSSID (for filtering etc) */
3232 do_join = true;
3233 }
Juuso Oikarinen30240fc2010-02-18 13:25:38 +02003234 }
3235
Arik Nemtsov0f9c8252011-08-17 10:45:49 +03003236 if (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_HT)) {
3237 rcu_read_lock();
3238 sta = ieee80211_find_sta(vif, bss_conf->bssid);
3239 if (!sta)
3240 goto sta_not_found;
3241
Eliad Peller72c2d9e2011-02-02 09:59:37 +02003242 /* save the supp_rates of the ap */
3243 sta_rate_set = sta->supp_rates[wl->hw->conf.channel->band];
3244 if (sta->ht_cap.ht_supported)
3245 sta_rate_set |=
3246 (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
Arik Nemtsova1008852011-02-12 23:24:20 +02003247 sta_ht_cap = sta->ht_cap;
3248 sta_exists = true;
Eliad Peller72c2d9e2011-02-02 09:59:37 +02003249
Arik Nemtsov0f9c8252011-08-17 10:45:49 +03003250sta_not_found:
3251 rcu_read_unlock();
Eliad Peller72c2d9e2011-02-02 09:59:37 +02003252 }
Eliad Peller72c2d9e2011-02-02 09:59:37 +02003253
Arik Nemtsove78a2872010-10-16 19:07:21 +02003254 if ((changed & BSS_CHANGED_ASSOC)) {
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003255 if (bss_conf->assoc) {
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03003256 u32 rates;
Juuso Oikarinen2f6724b2010-11-24 08:16:57 +02003257 int ieoffset;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003258 wl->aid = bss_conf->aid;
Juuso Oikarinen69e54342010-05-07 11:39:00 +03003259 set_assoc = true;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003260
Juuso Oikarinen90494a92010-07-08 17:50:00 +03003261 wl->ps_poll_failures = 0;
3262
Luciano Coelhoae751ba2009-10-12 15:08:57 +03003263 /*
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03003264 * use basic rates from AP, and determine lowest rate
3265 * to use with control frames.
3266 */
3267 rates = bss_conf->basic_rates;
3268 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
3269 rates);
Arik Nemtsove0fe3712010-10-16 18:19:53 +02003270 wl->basic_rate = wl1271_tx_min_rate_get(wl);
Eliad Peller72c2d9e2011-02-02 09:59:37 +02003271 if (sta_rate_set)
3272 wl->rate_set = wl1271_tx_enabled_rates_get(wl,
3273 sta_rate_set);
Arik Nemtsov79b223f2010-10-16 17:52:59 +02003274 ret = wl1271_acx_sta_rate_policies(wl);
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03003275 if (ret < 0)
Arik Nemtsove78a2872010-10-16 19:07:21 +02003276 goto out;
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03003277
3278 /*
Luciano Coelhoae751ba2009-10-12 15:08:57 +03003279 * with wl1271, we don't need to update the
3280 * beacon_int and dtim_period, because the firmware
3281 * updates it by itself when the first beacon is
3282 * received after a join.
3283 */
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003284 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
3285 if (ret < 0)
Arik Nemtsove78a2872010-10-16 19:07:21 +02003286 goto out;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003287
Juuso Oikarinenc2b2d992010-03-26 12:53:28 +02003288 /*
Juuso Oikarinen2f6724b2010-11-24 08:16:57 +02003289 * Get a template for hardware connection maintenance
Juuso Oikarinenc2b2d992010-03-26 12:53:28 +02003290 */
Juuso Oikarinen2f6724b2010-11-24 08:16:57 +02003291 dev_kfree_skb(wl->probereq);
3292 wl->probereq = wl1271_cmd_build_ap_probe_req(wl, NULL);
3293 ieoffset = offsetof(struct ieee80211_mgmt,
3294 u.probe_req.variable);
3295 wl1271_ssid_set(wl, wl->probereq, ieoffset);
Juuso Oikarinenc2b2d992010-03-26 12:53:28 +02003296
Juuso Oikarinen6ccbb922010-03-26 12:53:23 +02003297 /* enable the connection monitoring feature */
3298 ret = wl1271_acx_conn_monit_params(wl, true);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003299 if (ret < 0)
Arik Nemtsove78a2872010-10-16 19:07:21 +02003300 goto out;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003301
3302 /* If we want to go in PSM but we're not there yet */
Juuso Oikarinen71449f82009-12-11 15:41:07 +02003303 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
3304 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
Arik Nemtsove78a2872010-10-16 19:07:21 +02003305 enum wl1271_cmd_ps_mode mode;
3306
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003307 mode = STATION_POWER_SAVE_MODE;
Juuso Oikarinen65cddbf12010-08-24 06:28:03 +03003308 ret = wl1271_ps_set_mode(wl, mode,
Juuso Oikarinen8eab7b42010-09-24 03:10:11 +02003309 wl->basic_rate,
Juuso Oikarinen65cddbf12010-08-24 06:28:03 +03003310 true);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003311 if (ret < 0)
Arik Nemtsove78a2872010-10-16 19:07:21 +02003312 goto out;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003313 }
Juuso Oikarinend94cd292009-10-08 21:56:25 +03003314 } else {
3315 /* use defaults when not associated */
Eliad Peller30df14d2011-04-05 19:13:28 +03003316 bool was_assoc =
3317 !!test_and_clear_bit(WL1271_FLAG_STA_ASSOCIATED,
3318 &wl->flags);
Eliad Peller251c1772011-08-14 13:17:17 +03003319 bool was_ifup =
3320 !!test_and_clear_bit(WL1271_FLAG_STA_STATE_SENT,
3321 &wl->flags);
Juuso Oikarinend94cd292009-10-08 21:56:25 +03003322 wl->aid = 0;
Juuso Oikarinen6ccbb922010-03-26 12:53:23 +02003323
Juuso Oikarinen2f6724b2010-11-24 08:16:57 +02003324 /* free probe-request template */
3325 dev_kfree_skb(wl->probereq);
3326 wl->probereq = NULL;
3327
Juuso Oikarinen8d2ef7b2010-07-08 17:50:03 +03003328 /* re-enable dynamic ps - just in case */
Juuso Oikarinenf532be62010-07-08 17:50:05 +03003329 ieee80211_enable_dyn_ps(wl->vif);
Juuso Oikarinen8d2ef7b2010-07-08 17:50:03 +03003330
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03003331 /* revert back to minimum rates for the current band */
3332 wl1271_set_band_rate(wl);
Arik Nemtsove0fe3712010-10-16 18:19:53 +02003333 wl->basic_rate = wl1271_tx_min_rate_get(wl);
Arik Nemtsov79b223f2010-10-16 17:52:59 +02003334 ret = wl1271_acx_sta_rate_policies(wl);
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03003335 if (ret < 0)
Arik Nemtsove78a2872010-10-16 19:07:21 +02003336 goto out;
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03003337
Juuso Oikarinen6ccbb922010-03-26 12:53:23 +02003338 /* disable connection monitor features */
3339 ret = wl1271_acx_conn_monit_params(wl, false);
Juuso Oikarinenc1899552010-03-26 12:53:32 +02003340
3341 /* Disable the keep-alive feature */
3342 ret = wl1271_acx_keep_alive_mode(wl, false);
Juuso Oikarinen6ccbb922010-03-26 12:53:23 +02003343 if (ret < 0)
Arik Nemtsove78a2872010-10-16 19:07:21 +02003344 goto out;
Juuso Oikarinenb84a7d32010-11-22 12:59:08 +02003345
3346 /* restore the bssid filter and go to dummy bssid */
Eliad Peller30df14d2011-04-05 19:13:28 +03003347 if (was_assoc) {
Eliad Peller251c1772011-08-14 13:17:17 +03003348 u32 conf_flags = wl->hw->conf.flags;
3349 /*
3350 * we might have to disable roc, if there was
3351 * no IF_OPER_UP notification.
3352 */
3353 if (!was_ifup) {
3354 ret = wl12xx_croc(wl, wl->role_id);
3355 if (ret < 0)
3356 goto out;
3357 }
3358 /*
3359 * (we also need to disable roc in case of
3360 * roaming on the same channel. until we will
3361 * have a better flow...)
3362 */
3363 if (test_bit(wl->dev_role_id, wl->roc_map)) {
3364 ret = wl12xx_croc(wl, wl->dev_role_id);
3365 if (ret < 0)
3366 goto out;
3367 }
3368
Eliad Peller30df14d2011-04-05 19:13:28 +03003369 wl1271_unjoin(wl);
Eliad Peller251c1772011-08-14 13:17:17 +03003370 if (!(conf_flags & IEEE80211_CONF_IDLE)) {
3371 wl12xx_cmd_role_start_dev(wl);
3372 wl12xx_roc(wl, wl->dev_role_id);
3373 }
Eliad Peller30df14d2011-04-05 19:13:28 +03003374 }
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003375 }
3376 }
Juuso Oikarinen8a5a37a2009-10-08 21:56:24 +03003377
Eliad Pellerd192d262011-05-24 14:33:08 +03003378 if (changed & BSS_CHANGED_IBSS) {
3379 wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d",
3380 bss_conf->ibss_joined);
3381
3382 if (bss_conf->ibss_joined) {
3383 u32 rates = bss_conf->basic_rates;
3384 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
3385 rates);
3386 wl->basic_rate = wl1271_tx_min_rate_get(wl);
3387
3388 /* by default, use 11b rates */
3389 wl->rate_set = CONF_TX_IBSS_DEFAULT_RATES;
3390 ret = wl1271_acx_sta_rate_policies(wl);
3391 if (ret < 0)
3392 goto out;
3393 }
3394 }
3395
Arik Nemtsove78a2872010-10-16 19:07:21 +02003396 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
3397 if (ret < 0)
3398 goto out;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003399
Juuso Oikarinenca52a5e2010-07-08 17:50:02 +03003400 if (changed & BSS_CHANGED_ARP_FILTER) {
3401 __be32 addr = bss_conf->arp_addr_list[0];
3402 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
3403
Eliad Pellerc5312772010-12-09 11:31:27 +02003404 if (bss_conf->arp_addr_cnt == 1 &&
3405 bss_conf->arp_filter_enabled) {
3406 /*
3407 * The template should have been configured only upon
3408 * association. however, it seems that the correct ip
3409 * isn't being set (when sending), so we have to
3410 * reconfigure the template upon every ip change.
3411 */
3412 ret = wl1271_cmd_build_arp_rsp(wl, addr);
3413 if (ret < 0) {
3414 wl1271_warning("build arp rsp failed: %d", ret);
Arik Nemtsove78a2872010-10-16 19:07:21 +02003415 goto out;
Eliad Pellerc5312772010-12-09 11:31:27 +02003416 }
3417
3418 ret = wl1271_acx_arp_ip_filter(wl,
Eliad Pellere5e2f242011-01-24 19:19:03 +01003419 ACX_ARP_FILTER_ARP_FILTERING,
Eliad Pellerc5312772010-12-09 11:31:27 +02003420 addr);
3421 } else
3422 ret = wl1271_acx_arp_ip_filter(wl, 0, addr);
Juuso Oikarinenca52a5e2010-07-08 17:50:02 +03003423
3424 if (ret < 0)
Arik Nemtsove78a2872010-10-16 19:07:21 +02003425 goto out;
Juuso Oikarinenca52a5e2010-07-08 17:50:02 +03003426 }
3427
Juuso Oikarinen8bf29b02010-02-18 13:25:51 +02003428 if (do_join) {
Juuso Oikarinen69e54342010-05-07 11:39:00 +03003429 ret = wl1271_join(wl, set_assoc);
Juuso Oikarinen8bf29b02010-02-18 13:25:51 +02003430 if (ret < 0) {
3431 wl1271_warning("cmd join failed %d", ret);
Arik Nemtsove78a2872010-10-16 19:07:21 +02003432 goto out;
Juuso Oikarinen8bf29b02010-02-18 13:25:51 +02003433 }
Eliad Peller251c1772011-08-14 13:17:17 +03003434
3435 /* ROC until connected (after EAPOL exchange) */
3436 if (!is_ibss) {
3437 ret = wl12xx_roc(wl, wl->role_id);
3438 if (ret < 0)
3439 goto out;
3440
3441 wl1271_check_operstate(wl,
3442 ieee80211_get_operstate(vif));
3443 }
3444 /*
3445 * stop device role if started (we might already be in
3446 * STA role). TODO: make it better.
3447 */
3448 if (wl->dev_role_id != WL12XX_INVALID_ROLE_ID) {
3449 ret = wl12xx_croc(wl, wl->dev_role_id);
3450 if (ret < 0)
3451 goto out;
3452
3453 ret = wl12xx_cmd_role_stop_dev(wl);
3454 if (ret < 0)
3455 goto out;
3456 }
Juuso Oikarinenc1899552010-03-26 12:53:32 +02003457 }
3458
Arik Nemtsov0b932ab2011-08-14 13:17:27 +03003459 /* Handle new association with HT. Do this after join. */
Arik Nemtsov0f9c8252011-08-17 10:45:49 +03003460 if (sta_exists) {
3461 if ((changed & BSS_CHANGED_HT) &&
3462 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
Arik Nemtsov0b932ab2011-08-14 13:17:27 +03003463 ret = wl1271_acx_set_ht_capabilities(wl,
3464 &sta_ht_cap,
3465 true,
3466 wl->sta_hlid);
Arik Nemtsov0f9c8252011-08-17 10:45:49 +03003467 if (ret < 0) {
3468 wl1271_warning("Set ht cap true failed %d",
3469 ret);
3470 goto out;
3471 }
3472 }
3473 /* handle new association without HT and disassociation */
3474 else if (changed & BSS_CHANGED_ASSOC) {
Arik Nemtsov0b932ab2011-08-14 13:17:27 +03003475 ret = wl1271_acx_set_ht_capabilities(wl,
3476 &sta_ht_cap,
3477 false,
3478 wl->sta_hlid);
Arik Nemtsov0f9c8252011-08-17 10:45:49 +03003479 if (ret < 0) {
3480 wl1271_warning("Set ht cap false failed %d",
3481 ret);
3482 goto out;
3483 }
3484 }
3485 }
3486
Arik Nemtsov0b932ab2011-08-14 13:17:27 +03003487 /* Handle HT information change. Done after join. */
3488 if ((changed & BSS_CHANGED_HT) &&
Arik Nemtsov0f9c8252011-08-17 10:45:49 +03003489 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
3490 ret = wl1271_acx_set_ht_information(wl,
3491 bss_conf->ht_operation_mode);
3492 if (ret < 0) {
3493 wl1271_warning("Set ht information failed %d", ret);
3494 goto out;
3495 }
3496 }
3497
Arik Nemtsove78a2872010-10-16 19:07:21 +02003498out:
3499 return;
3500}
3501
3502static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
3503 struct ieee80211_vif *vif,
3504 struct ieee80211_bss_conf *bss_conf,
3505 u32 changed)
3506{
3507 struct wl1271 *wl = hw->priv;
3508 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
3509 int ret;
3510
3511 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
3512 (int)changed);
3513
3514 mutex_lock(&wl->mutex);
3515
3516 if (unlikely(wl->state == WL1271_STATE_OFF))
3517 goto out;
3518
Ido Yariva6208652011-03-01 15:14:41 +02003519 ret = wl1271_ps_elp_wakeup(wl);
Arik Nemtsove78a2872010-10-16 19:07:21 +02003520 if (ret < 0)
3521 goto out;
3522
3523 if (is_ap)
3524 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
3525 else
3526 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
3527
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003528 wl1271_ps_elp_sleep(wl);
3529
3530out:
3531 mutex_unlock(&wl->mutex);
3532}
3533
Kalle Valoc6999d82010-02-18 13:25:41 +02003534static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
3535 const struct ieee80211_tx_queue_params *params)
3536{
3537 struct wl1271 *wl = hw->priv;
Kalle Valo4695dc92010-03-18 12:26:38 +02003538 u8 ps_scheme;
Arik Nemtsov488fc542010-10-16 20:33:45 +02003539 int ret = 0;
Kalle Valoc6999d82010-02-18 13:25:41 +02003540
3541 mutex_lock(&wl->mutex);
3542
3543 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
3544
Kalle Valo4695dc92010-03-18 12:26:38 +02003545 if (params->uapsd)
3546 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
3547 else
3548 ps_scheme = CONF_PS_SCHEME_LEGACY;
3549
Arik Nemtsov488fc542010-10-16 20:33:45 +02003550 if (wl->state == WL1271_STATE_OFF) {
3551 /*
3552 * If the state is off, the parameters will be recorded and
3553 * configured on init. This happens in AP-mode.
3554 */
3555 struct conf_tx_ac_category *conf_ac =
3556 &wl->conf.tx.ac_conf[wl1271_tx_get_queue(queue)];
3557 struct conf_tx_tid *conf_tid =
3558 &wl->conf.tx.tid_conf[wl1271_tx_get_queue(queue)];
3559
3560 conf_ac->ac = wl1271_tx_get_queue(queue);
3561 conf_ac->cw_min = (u8)params->cw_min;
3562 conf_ac->cw_max = params->cw_max;
3563 conf_ac->aifsn = params->aifs;
3564 conf_ac->tx_op_limit = params->txop << 5;
3565
3566 conf_tid->queue_id = wl1271_tx_get_queue(queue);
3567 conf_tid->channel_type = CONF_CHANNEL_TYPE_EDCF;
3568 conf_tid->tsid = wl1271_tx_get_queue(queue);
3569 conf_tid->ps_scheme = ps_scheme;
3570 conf_tid->ack_policy = CONF_ACK_POLICY_LEGACY;
3571 conf_tid->apsd_conf[0] = 0;
3572 conf_tid->apsd_conf[1] = 0;
Eliad Pellerc1b193e2011-03-23 22:22:15 +02003573 goto out;
3574 }
Arik Nemtsov488fc542010-10-16 20:33:45 +02003575
Eliad Pellerc1b193e2011-03-23 22:22:15 +02003576 ret = wl1271_ps_elp_wakeup(wl);
3577 if (ret < 0)
3578 goto out;
Arik Nemtsov488fc542010-10-16 20:33:45 +02003579
Eliad Pellerc1b193e2011-03-23 22:22:15 +02003580 /*
3581 * the txop is confed in units of 32us by the mac80211,
3582 * we need us
3583 */
3584 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
3585 params->cw_min, params->cw_max,
3586 params->aifs, params->txop << 5);
3587 if (ret < 0)
3588 goto out_sleep;
3589
3590 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
3591 CONF_CHANNEL_TYPE_EDCF,
3592 wl1271_tx_get_queue(queue),
3593 ps_scheme, CONF_ACK_POLICY_LEGACY,
3594 0, 0);
Kalle Valoc82c1dd2010-02-18 13:25:47 +02003595
3596out_sleep:
Eliad Pellerc1b193e2011-03-23 22:22:15 +02003597 wl1271_ps_elp_sleep(wl);
Kalle Valoc6999d82010-02-18 13:25:41 +02003598
3599out:
3600 mutex_unlock(&wl->mutex);
3601
3602 return ret;
3603}
3604
Juuso Oikarinenbbbb5382010-07-08 17:49:57 +03003605static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
3606{
3607
3608 struct wl1271 *wl = hw->priv;
3609 u64 mactime = ULLONG_MAX;
3610 int ret;
3611
3612 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
3613
3614 mutex_lock(&wl->mutex);
3615
Juuso Oikarinenf8d98022010-10-26 13:24:39 +02003616 if (unlikely(wl->state == WL1271_STATE_OFF))
3617 goto out;
3618
Ido Yariva6208652011-03-01 15:14:41 +02003619 ret = wl1271_ps_elp_wakeup(wl);
Juuso Oikarinenbbbb5382010-07-08 17:49:57 +03003620 if (ret < 0)
3621 goto out;
3622
3623 ret = wl1271_acx_tsf_info(wl, &mactime);
3624 if (ret < 0)
3625 goto out_sleep;
3626
3627out_sleep:
3628 wl1271_ps_elp_sleep(wl);
3629
3630out:
3631 mutex_unlock(&wl->mutex);
3632 return mactime;
3633}
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003634
John W. Linvilleece550d2010-07-28 16:41:06 -04003635static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
3636 struct survey_info *survey)
3637{
3638 struct wl1271 *wl = hw->priv;
3639 struct ieee80211_conf *conf = &hw->conf;
Juuso Oikarinenb739a422010-10-26 13:24:38 +02003640
John W. Linvilleece550d2010-07-28 16:41:06 -04003641 if (idx != 0)
3642 return -ENOENT;
Juuso Oikarinenb739a422010-10-26 13:24:38 +02003643
John W. Linvilleece550d2010-07-28 16:41:06 -04003644 survey->channel = conf->channel;
3645 survey->filled = SURVEY_INFO_NOISE_DBM;
3646 survey->noise = wl->noise;
Juuso Oikarinenb739a422010-10-26 13:24:38 +02003647
John W. Linvilleece550d2010-07-28 16:41:06 -04003648 return 0;
3649}
3650
Arik Nemtsov409622e2011-02-23 00:22:29 +02003651static int wl1271_allocate_sta(struct wl1271 *wl,
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02003652 struct ieee80211_sta *sta,
3653 u8 *hlid)
3654{
3655 struct wl1271_station *wl_sta;
3656 int id;
3657
3658 id = find_first_zero_bit(wl->ap_hlid_map, AP_MAX_STATIONS);
3659 if (id >= AP_MAX_STATIONS) {
3660 wl1271_warning("could not allocate HLID - too much stations");
3661 return -EBUSY;
3662 }
3663
3664 wl_sta = (struct wl1271_station *)sta->drv_priv;
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02003665 __set_bit(id, wl->ap_hlid_map);
3666 wl_sta->hlid = WL1271_AP_STA_HLID_START + id;
3667 *hlid = wl_sta->hlid;
Arik Nemtsovb622d992011-02-23 00:22:31 +02003668 memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02003669 return 0;
3670}
3671
Arik Nemtsov409622e2011-02-23 00:22:29 +02003672static void wl1271_free_sta(struct wl1271 *wl, u8 hlid)
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02003673{
3674 int id = hlid - WL1271_AP_STA_HLID_START;
3675
Arik Nemtsov409622e2011-02-23 00:22:29 +02003676 if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
3677 return;
3678
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02003679 __clear_bit(id, wl->ap_hlid_map);
Arik Nemtsovb622d992011-02-23 00:22:31 +02003680 memset(wl->links[hlid].addr, 0, ETH_ALEN);
Arik Nemtsov0f9c8252011-08-17 10:45:49 +03003681 wl->links[hlid].ba_bitmap = 0;
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +02003682 wl1271_tx_reset_link_queues(wl, hlid);
Arik Nemtsovb622d992011-02-23 00:22:31 +02003683 __clear_bit(hlid, &wl->ap_ps_map);
3684 __clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02003685}
3686
Arik Nemtsov3618f302011-06-26 10:36:03 +03003687bool wl1271_is_active_sta(struct wl1271 *wl, u8 hlid)
3688{
3689 int id = hlid - WL1271_AP_STA_HLID_START;
3690 return test_bit(id, wl->ap_hlid_map);
3691}
3692
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02003693static int wl1271_op_sta_add(struct ieee80211_hw *hw,
3694 struct ieee80211_vif *vif,
3695 struct ieee80211_sta *sta)
3696{
3697 struct wl1271 *wl = hw->priv;
3698 int ret = 0;
3699 u8 hlid;
3700
3701 mutex_lock(&wl->mutex);
3702
3703 if (unlikely(wl->state == WL1271_STATE_OFF))
3704 goto out;
3705
3706 if (wl->bss_type != BSS_TYPE_AP_BSS)
3707 goto out;
3708
3709 wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);
3710
Arik Nemtsov409622e2011-02-23 00:22:29 +02003711 ret = wl1271_allocate_sta(wl, sta, &hlid);
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02003712 if (ret < 0)
3713 goto out;
3714
Ido Yariva6208652011-03-01 15:14:41 +02003715 ret = wl1271_ps_elp_wakeup(wl);
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02003716 if (ret < 0)
Arik Nemtsov409622e2011-02-23 00:22:29 +02003717 goto out_free_sta;
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02003718
Eliad Pellerc690ec82011-08-14 13:17:07 +03003719 ret = wl12xx_cmd_add_peer(wl, sta, hlid);
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02003720 if (ret < 0)
3721 goto out_sleep;
3722
Eliad Pellerb67476e2011-08-14 13:17:23 +03003723 ret = wl12xx_cmd_set_peer_state(wl, hlid);
3724 if (ret < 0)
3725 goto out_sleep;
3726
Arik Nemtsov0b932ab2011-08-14 13:17:27 +03003727 ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap, true, hlid);
3728 if (ret < 0)
3729 goto out_sleep;
3730
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02003731out_sleep:
3732 wl1271_ps_elp_sleep(wl);
3733
Arik Nemtsov409622e2011-02-23 00:22:29 +02003734out_free_sta:
3735 if (ret < 0)
3736 wl1271_free_sta(wl, hlid);
3737
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02003738out:
3739 mutex_unlock(&wl->mutex);
3740 return ret;
3741}
3742
3743static int wl1271_op_sta_remove(struct ieee80211_hw *hw,
3744 struct ieee80211_vif *vif,
3745 struct ieee80211_sta *sta)
3746{
3747 struct wl1271 *wl = hw->priv;
3748 struct wl1271_station *wl_sta;
3749 int ret = 0, id;
3750
3751 mutex_lock(&wl->mutex);
3752
3753 if (unlikely(wl->state == WL1271_STATE_OFF))
3754 goto out;
3755
3756 if (wl->bss_type != BSS_TYPE_AP_BSS)
3757 goto out;
3758
3759 wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);
3760
3761 wl_sta = (struct wl1271_station *)sta->drv_priv;
3762 id = wl_sta->hlid - WL1271_AP_STA_HLID_START;
3763 if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
3764 goto out;
3765
Ido Yariva6208652011-03-01 15:14:41 +02003766 ret = wl1271_ps_elp_wakeup(wl);
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02003767 if (ret < 0)
3768 goto out;
3769
Eliad Pellerc690ec82011-08-14 13:17:07 +03003770 ret = wl12xx_cmd_remove_peer(wl, wl_sta->hlid);
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02003771 if (ret < 0)
3772 goto out_sleep;
3773
Arik Nemtsov409622e2011-02-23 00:22:29 +02003774 wl1271_free_sta(wl, wl_sta->hlid);
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02003775
3776out_sleep:
3777 wl1271_ps_elp_sleep(wl);
3778
3779out:
3780 mutex_unlock(&wl->mutex);
3781 return ret;
3782}
3783
Luciano Coelho4623ec72011-03-21 19:26:41 +02003784static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
3785 struct ieee80211_vif *vif,
3786 enum ieee80211_ampdu_mlme_action action,
3787 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
3788 u8 buf_size)
Levi, Shaharbbba3e62011-01-23 07:27:23 +01003789{
3790 struct wl1271 *wl = hw->priv;
3791 int ret;
Arik Nemtsov0f9c8252011-08-17 10:45:49 +03003792 u8 hlid, *ba_bitmap;
3793
3794 wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu action %d tid %d", action,
3795 tid);
3796
3797 /* sanity check - the fields in FW are only 8bits wide */
3798 if (WARN_ON(tid > 0xFF))
3799 return -ENOTSUPP;
Levi, Shaharbbba3e62011-01-23 07:27:23 +01003800
3801 mutex_lock(&wl->mutex);
3802
3803 if (unlikely(wl->state == WL1271_STATE_OFF)) {
3804 ret = -EAGAIN;
3805 goto out;
3806 }
3807
Arik Nemtsov0f9c8252011-08-17 10:45:49 +03003808 if (wl->bss_type == BSS_TYPE_STA_BSS) {
3809 hlid = wl->sta_hlid;
3810 ba_bitmap = &wl->ba_rx_bitmap;
3811 } else if (wl->bss_type == BSS_TYPE_AP_BSS) {
3812 struct wl1271_station *wl_sta;
3813
3814 wl_sta = (struct wl1271_station *)sta->drv_priv;
3815 hlid = wl_sta->hlid;
3816 ba_bitmap = &wl->links[hlid].ba_bitmap;
3817 } else {
3818 ret = -EINVAL;
3819 goto out;
3820 }
3821
Ido Yariva6208652011-03-01 15:14:41 +02003822 ret = wl1271_ps_elp_wakeup(wl);
Levi, Shaharbbba3e62011-01-23 07:27:23 +01003823 if (ret < 0)
3824 goto out;
3825
Shahar Levi70559a02011-05-22 16:10:22 +03003826 wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu: Rx tid %d action %d",
3827 tid, action);
3828
Levi, Shaharbbba3e62011-01-23 07:27:23 +01003829 switch (action) {
3830 case IEEE80211_AMPDU_RX_START:
Arik Nemtsov0f9c8252011-08-17 10:45:49 +03003831 if (!wl->ba_support || !wl->ba_allowed) {
Levi, Shaharbbba3e62011-01-23 07:27:23 +01003832 ret = -ENOTSUPP;
Arik Nemtsov0f9c8252011-08-17 10:45:49 +03003833 break;
3834 }
3835
3836 if (wl->ba_rx_session_count >= RX_BA_MAX_SESSIONS) {
3837 ret = -EBUSY;
3838 wl1271_error("exceeded max RX BA sessions");
3839 break;
3840 }
3841
3842 if (*ba_bitmap & BIT(tid)) {
3843 ret = -EINVAL;
3844 wl1271_error("cannot enable RX BA session on active "
3845 "tid: %d", tid);
3846 break;
3847 }
3848
3849 ret = wl12xx_acx_set_ba_receiver_session(wl, tid, *ssn, true,
3850 hlid);
3851 if (!ret) {
3852 *ba_bitmap |= BIT(tid);
3853 wl->ba_rx_session_count++;
Levi, Shaharbbba3e62011-01-23 07:27:23 +01003854 }
3855 break;
3856
3857 case IEEE80211_AMPDU_RX_STOP:
Arik Nemtsov0f9c8252011-08-17 10:45:49 +03003858 if (!(*ba_bitmap & BIT(tid))) {
3859 ret = -EINVAL;
3860 wl1271_error("no active RX BA session on tid: %d",
3861 tid);
3862 break;
3863 }
3864
3865 ret = wl12xx_acx_set_ba_receiver_session(wl, tid, 0, false,
3866 hlid);
3867 if (!ret) {
3868 *ba_bitmap &= ~BIT(tid);
3869 wl->ba_rx_session_count--;
3870 }
Levi, Shaharbbba3e62011-01-23 07:27:23 +01003871 break;
3872
3873 /*
3874 * The BA initiator session management in FW independently.
3875 * Falling break here on purpose for all TX APDU commands.
3876 */
3877 case IEEE80211_AMPDU_TX_START:
3878 case IEEE80211_AMPDU_TX_STOP:
3879 case IEEE80211_AMPDU_TX_OPERATIONAL:
3880 ret = -EINVAL;
3881 break;
3882
3883 default:
3884 wl1271_error("Incorrect ampdu action id=%x\n", action);
3885 ret = -EINVAL;
3886 }
3887
3888 wl1271_ps_elp_sleep(wl);
3889
3890out:
3891 mutex_unlock(&wl->mutex);
3892
3893 return ret;
3894}
3895
Arik Nemtsov33437892011-04-26 23:35:39 +03003896static bool wl1271_tx_frames_pending(struct ieee80211_hw *hw)
3897{
3898 struct wl1271 *wl = hw->priv;
3899 bool ret = false;
3900
3901 mutex_lock(&wl->mutex);
3902
3903 if (unlikely(wl->state == WL1271_STATE_OFF))
3904 goto out;
3905
3906 /* packets are considered pending if in the TX queue or the FW */
Arik Nemtsovf1a46382011-07-07 14:25:23 +03003907 ret = (wl1271_tx_total_queue_count(wl) > 0) || (wl->tx_frames_cnt > 0);
Arik Nemtsov33437892011-04-26 23:35:39 +03003908
3909 /* the above is appropriate for STA mode for PS purposes */
3910 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
3911
3912out:
3913 mutex_unlock(&wl->mutex);
3914
3915 return ret;
3916}
3917
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003918/* can't be const, mac80211 writes to this */
3919static struct ieee80211_rate wl1271_rates[] = {
3920 { .bitrate = 10,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03003921 .hw_value = CONF_HW_BIT_RATE_1MBPS,
3922 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003923 { .bitrate = 20,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03003924 .hw_value = CONF_HW_BIT_RATE_2MBPS,
3925 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003926 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3927 { .bitrate = 55,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03003928 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
3929 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003930 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3931 { .bitrate = 110,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03003932 .hw_value = CONF_HW_BIT_RATE_11MBPS,
3933 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003934 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3935 { .bitrate = 60,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03003936 .hw_value = CONF_HW_BIT_RATE_6MBPS,
3937 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003938 { .bitrate = 90,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03003939 .hw_value = CONF_HW_BIT_RATE_9MBPS,
3940 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003941 { .bitrate = 120,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03003942 .hw_value = CONF_HW_BIT_RATE_12MBPS,
3943 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003944 { .bitrate = 180,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03003945 .hw_value = CONF_HW_BIT_RATE_18MBPS,
3946 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003947 { .bitrate = 240,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03003948 .hw_value = CONF_HW_BIT_RATE_24MBPS,
3949 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003950 { .bitrate = 360,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03003951 .hw_value = CONF_HW_BIT_RATE_36MBPS,
3952 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003953 { .bitrate = 480,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03003954 .hw_value = CONF_HW_BIT_RATE_48MBPS,
3955 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003956 { .bitrate = 540,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03003957 .hw_value = CONF_HW_BIT_RATE_54MBPS,
3958 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003959};
3960
Juuso Oikarinenfa97f462010-11-10 11:27:20 +01003961/* can't be const, mac80211 writes to this */
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003962static struct ieee80211_channel wl1271_channels[] = {
Luciano Coelhoa2d0e3f2009-12-11 15:40:46 +02003963 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
Juuso Oikarinenfa21c7a2010-08-10 08:22:02 +02003964 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
Juuso Oikarinenfa97f462010-11-10 11:27:20 +01003965 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
3966 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
3967 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
Juuso Oikarinenfa21c7a2010-08-10 08:22:02 +02003968 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
Juuso Oikarinenfa97f462010-11-10 11:27:20 +01003969 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
3970 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
3971 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
Juuso Oikarinenfa21c7a2010-08-10 08:22:02 +02003972 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
Juuso Oikarinenfa97f462010-11-10 11:27:20 +01003973 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
3974 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
3975 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
Arik Nemtsov6c89b7b2011-01-18 20:39:52 +01003976 { .hw_value = 14, .center_freq = 2484, .max_power = 25 },
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003977};
3978
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02003979/* mapping to indexes for wl1271_rates */
Tobias Klausera0ea9492010-05-20 10:38:11 +02003980static const u8 wl1271_rate_to_idx_2ghz[] = {
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02003981 /* MCS rates are used only with 11n */
Shahar Levi18357852010-10-13 16:09:41 +02003982 7, /* CONF_HW_RXTX_RATE_MCS7 */
3983 6, /* CONF_HW_RXTX_RATE_MCS6 */
3984 5, /* CONF_HW_RXTX_RATE_MCS5 */
3985 4, /* CONF_HW_RXTX_RATE_MCS4 */
3986 3, /* CONF_HW_RXTX_RATE_MCS3 */
3987 2, /* CONF_HW_RXTX_RATE_MCS2 */
3988 1, /* CONF_HW_RXTX_RATE_MCS1 */
3989 0, /* CONF_HW_RXTX_RATE_MCS0 */
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02003990
3991 11, /* CONF_HW_RXTX_RATE_54 */
3992 10, /* CONF_HW_RXTX_RATE_48 */
3993 9, /* CONF_HW_RXTX_RATE_36 */
3994 8, /* CONF_HW_RXTX_RATE_24 */
3995
3996 /* TI-specific rate */
3997 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
3998
3999 7, /* CONF_HW_RXTX_RATE_18 */
4000 6, /* CONF_HW_RXTX_RATE_12 */
4001 3, /* CONF_HW_RXTX_RATE_11 */
4002 5, /* CONF_HW_RXTX_RATE_9 */
4003 4, /* CONF_HW_RXTX_RATE_6 */
4004 2, /* CONF_HW_RXTX_RATE_5_5 */
4005 1, /* CONF_HW_RXTX_RATE_2 */
4006 0 /* CONF_HW_RXTX_RATE_1 */
4007};
4008
Shahar Levie8b03a22010-10-13 16:09:39 +02004009/* 11n STA capabilities */
4010#define HW_RX_HIGHEST_RATE 72
4011
Shahar Levi00d20102010-11-08 11:20:10 +00004012#ifdef CONFIG_WL12XX_HT
4013#define WL12XX_HT_CAP { \
Shahar Levi871d0c32011-03-13 11:24:40 +02004014 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | \
4015 (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT), \
Shahar Levie8b03a22010-10-13 16:09:39 +02004016 .ht_supported = true, \
4017 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
4018 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
4019 .mcs = { \
4020 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
4021 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
4022 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
4023 }, \
4024}
Shahar Levi18357852010-10-13 16:09:41 +02004025#else
Shahar Levi00d20102010-11-08 11:20:10 +00004026#define WL12XX_HT_CAP { \
Shahar Levi18357852010-10-13 16:09:41 +02004027 .ht_supported = false, \
4028}
4029#endif
Shahar Levie8b03a22010-10-13 16:09:39 +02004030
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004031/* can't be const, mac80211 writes to this */
4032static struct ieee80211_supported_band wl1271_band_2ghz = {
4033 .channels = wl1271_channels,
4034 .n_channels = ARRAY_SIZE(wl1271_channels),
4035 .bitrates = wl1271_rates,
4036 .n_bitrates = ARRAY_SIZE(wl1271_rates),
Shahar Levi00d20102010-11-08 11:20:10 +00004037 .ht_cap = WL12XX_HT_CAP,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004038};
4039
Teemu Paasikivi1ebec3d2009-10-13 12:47:48 +03004040/* 5 GHz data rates for WL1273 */
4041static struct ieee80211_rate wl1271_rates_5ghz[] = {
4042 { .bitrate = 60,
4043 .hw_value = CONF_HW_BIT_RATE_6MBPS,
4044 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
4045 { .bitrate = 90,
4046 .hw_value = CONF_HW_BIT_RATE_9MBPS,
4047 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
4048 { .bitrate = 120,
4049 .hw_value = CONF_HW_BIT_RATE_12MBPS,
4050 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
4051 { .bitrate = 180,
4052 .hw_value = CONF_HW_BIT_RATE_18MBPS,
4053 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
4054 { .bitrate = 240,
4055 .hw_value = CONF_HW_BIT_RATE_24MBPS,
4056 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
4057 { .bitrate = 360,
4058 .hw_value = CONF_HW_BIT_RATE_36MBPS,
4059 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
4060 { .bitrate = 480,
4061 .hw_value = CONF_HW_BIT_RATE_48MBPS,
4062 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
4063 { .bitrate = 540,
4064 .hw_value = CONF_HW_BIT_RATE_54MBPS,
4065 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
4066};
4067
Juuso Oikarinenfa97f462010-11-10 11:27:20 +01004068/* 5 GHz band channels for WL1273 */
Teemu Paasikivi1ebec3d2009-10-13 12:47:48 +03004069static struct ieee80211_channel wl1271_channels_5ghz[] = {
Arik Nemtsov6cfa5cf2011-06-27 22:06:33 +03004070 { .hw_value = 7, .center_freq = 5035, .max_power = 25 },
4071 { .hw_value = 8, .center_freq = 5040, .max_power = 25 },
4072 { .hw_value = 9, .center_freq = 5045, .max_power = 25 },
4073 { .hw_value = 11, .center_freq = 5055, .max_power = 25 },
4074 { .hw_value = 12, .center_freq = 5060, .max_power = 25 },
4075 { .hw_value = 16, .center_freq = 5080, .max_power = 25 },
4076 { .hw_value = 34, .center_freq = 5170, .max_power = 25 },
4077 { .hw_value = 36, .center_freq = 5180, .max_power = 25 },
4078 { .hw_value = 38, .center_freq = 5190, .max_power = 25 },
4079 { .hw_value = 40, .center_freq = 5200, .max_power = 25 },
4080 { .hw_value = 42, .center_freq = 5210, .max_power = 25 },
4081 { .hw_value = 44, .center_freq = 5220, .max_power = 25 },
4082 { .hw_value = 46, .center_freq = 5230, .max_power = 25 },
4083 { .hw_value = 48, .center_freq = 5240, .max_power = 25 },
4084 { .hw_value = 52, .center_freq = 5260, .max_power = 25 },
4085 { .hw_value = 56, .center_freq = 5280, .max_power = 25 },
4086 { .hw_value = 60, .center_freq = 5300, .max_power = 25 },
4087 { .hw_value = 64, .center_freq = 5320, .max_power = 25 },
4088 { .hw_value = 100, .center_freq = 5500, .max_power = 25 },
4089 { .hw_value = 104, .center_freq = 5520, .max_power = 25 },
4090 { .hw_value = 108, .center_freq = 5540, .max_power = 25 },
4091 { .hw_value = 112, .center_freq = 5560, .max_power = 25 },
4092 { .hw_value = 116, .center_freq = 5580, .max_power = 25 },
4093 { .hw_value = 120, .center_freq = 5600, .max_power = 25 },
4094 { .hw_value = 124, .center_freq = 5620, .max_power = 25 },
4095 { .hw_value = 128, .center_freq = 5640, .max_power = 25 },
4096 { .hw_value = 132, .center_freq = 5660, .max_power = 25 },
4097 { .hw_value = 136, .center_freq = 5680, .max_power = 25 },
4098 { .hw_value = 140, .center_freq = 5700, .max_power = 25 },
4099 { .hw_value = 149, .center_freq = 5745, .max_power = 25 },
4100 { .hw_value = 153, .center_freq = 5765, .max_power = 25 },
4101 { .hw_value = 157, .center_freq = 5785, .max_power = 25 },
4102 { .hw_value = 161, .center_freq = 5805, .max_power = 25 },
4103 { .hw_value = 165, .center_freq = 5825, .max_power = 25 },
Teemu Paasikivi1ebec3d2009-10-13 12:47:48 +03004104};
4105
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02004106/* mapping to indexes for wl1271_rates_5ghz */
Tobias Klausera0ea9492010-05-20 10:38:11 +02004107static const u8 wl1271_rate_to_idx_5ghz[] = {
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02004108 /* MCS rates are used only with 11n */
Shahar Levi18357852010-10-13 16:09:41 +02004109 7, /* CONF_HW_RXTX_RATE_MCS7 */
4110 6, /* CONF_HW_RXTX_RATE_MCS6 */
4111 5, /* CONF_HW_RXTX_RATE_MCS5 */
4112 4, /* CONF_HW_RXTX_RATE_MCS4 */
4113 3, /* CONF_HW_RXTX_RATE_MCS3 */
4114 2, /* CONF_HW_RXTX_RATE_MCS2 */
4115 1, /* CONF_HW_RXTX_RATE_MCS1 */
4116 0, /* CONF_HW_RXTX_RATE_MCS0 */
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02004117
4118 7, /* CONF_HW_RXTX_RATE_54 */
4119 6, /* CONF_HW_RXTX_RATE_48 */
4120 5, /* CONF_HW_RXTX_RATE_36 */
4121 4, /* CONF_HW_RXTX_RATE_24 */
4122
4123 /* TI-specific rate */
4124 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
4125
4126 3, /* CONF_HW_RXTX_RATE_18 */
4127 2, /* CONF_HW_RXTX_RATE_12 */
4128 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
4129 1, /* CONF_HW_RXTX_RATE_9 */
4130 0, /* CONF_HW_RXTX_RATE_6 */
4131 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
4132 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
4133 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
4134};
Teemu Paasikivi1ebec3d2009-10-13 12:47:48 +03004135
4136static struct ieee80211_supported_band wl1271_band_5ghz = {
4137 .channels = wl1271_channels_5ghz,
4138 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
4139 .bitrates = wl1271_rates_5ghz,
4140 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
Shahar Levi00d20102010-11-08 11:20:10 +00004141 .ht_cap = WL12XX_HT_CAP,
Teemu Paasikivi1ebec3d2009-10-13 12:47:48 +03004142};
4143
Tobias Klausera0ea9492010-05-20 10:38:11 +02004144static const u8 *wl1271_band_rate_to_idx[] = {
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02004145 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
4146 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
4147};
4148
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004149static const struct ieee80211_ops wl1271_ops = {
4150 .start = wl1271_op_start,
4151 .stop = wl1271_op_stop,
4152 .add_interface = wl1271_op_add_interface,
4153 .remove_interface = wl1271_op_remove_interface,
Luciano Coelhof634a4e2011-05-18 16:51:26 -04004154#ifdef CONFIG_PM
Eliad Peller402e48612011-05-13 11:57:09 +03004155 .suspend = wl1271_op_suspend,
4156 .resume = wl1271_op_resume,
Luciano Coelhof634a4e2011-05-18 16:51:26 -04004157#endif
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004158 .config = wl1271_op_config,
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03004159 .prepare_multicast = wl1271_op_prepare_multicast,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004160 .configure_filter = wl1271_op_configure_filter,
4161 .tx = wl1271_op_tx,
4162 .set_key = wl1271_op_set_key,
4163 .hw_scan = wl1271_op_hw_scan,
Eliad Peller73ecce32011-06-27 13:06:45 +03004164 .cancel_hw_scan = wl1271_op_cancel_hw_scan,
Luciano Coelho33c2c062011-05-10 14:46:02 +03004165 .sched_scan_start = wl1271_op_sched_scan_start,
4166 .sched_scan_stop = wl1271_op_sched_scan_stop,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004167 .bss_info_changed = wl1271_op_bss_info_changed,
Arik Nemtsov68d069c2010-11-08 10:51:07 +01004168 .set_frag_threshold = wl1271_op_set_frag_threshold,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004169 .set_rts_threshold = wl1271_op_set_rts_threshold,
Kalle Valoc6999d82010-02-18 13:25:41 +02004170 .conf_tx = wl1271_op_conf_tx,
Juuso Oikarinenbbbb5382010-07-08 17:49:57 +03004171 .get_tsf = wl1271_op_get_tsf,
John W. Linvilleece550d2010-07-28 16:41:06 -04004172 .get_survey = wl1271_op_get_survey,
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02004173 .sta_add = wl1271_op_sta_add,
4174 .sta_remove = wl1271_op_sta_remove,
Levi, Shaharbbba3e62011-01-23 07:27:23 +01004175 .ampdu_action = wl1271_op_ampdu_action,
Arik Nemtsov33437892011-04-26 23:35:39 +03004176 .tx_frames_pending = wl1271_tx_frames_pending,
Kalle Valoc8c90872010-02-18 13:25:53 +02004177 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004178};
4179
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02004180
Teemu Paasikivi6a2de932010-10-14 11:00:04 +02004181u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02004182{
4183 u8 idx;
4184
Teemu Paasikivi6a2de932010-10-14 11:00:04 +02004185 BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02004186
4187 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
4188 wl1271_error("Illegal RX rate from HW: %d", rate);
4189 return 0;
4190 }
4191
Teemu Paasikivi6a2de932010-10-14 11:00:04 +02004192 idx = wl1271_band_rate_to_idx[band][rate];
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02004193 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
4194 wl1271_error("Unsupported RX rate from HW: %d", rate);
4195 return 0;
4196 }
4197
4198 return idx;
4199}
4200
Juuso Oikarinen7fc3a862010-03-18 12:26:32 +02004201static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
4202 struct device_attribute *attr,
4203 char *buf)
4204{
4205 struct wl1271 *wl = dev_get_drvdata(dev);
4206 ssize_t len;
4207
Juuso Oikarinen2f63b012010-08-10 06:38:35 +02004208 len = PAGE_SIZE;
Juuso Oikarinen7fc3a862010-03-18 12:26:32 +02004209
4210 mutex_lock(&wl->mutex);
4211 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
4212 wl->sg_enabled);
4213 mutex_unlock(&wl->mutex);
4214
4215 return len;
4216
4217}
4218
4219static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
4220 struct device_attribute *attr,
4221 const char *buf, size_t count)
4222{
4223 struct wl1271 *wl = dev_get_drvdata(dev);
4224 unsigned long res;
4225 int ret;
4226
Luciano Coelho6277ed62011-04-01 17:49:54 +03004227 ret = kstrtoul(buf, 10, &res);
Juuso Oikarinen7fc3a862010-03-18 12:26:32 +02004228 if (ret < 0) {
4229 wl1271_warning("incorrect value written to bt_coex_mode");
4230 return count;
4231 }
4232
4233 mutex_lock(&wl->mutex);
4234
4235 res = !!res;
4236
4237 if (res == wl->sg_enabled)
4238 goto out;
4239
4240 wl->sg_enabled = res;
4241
4242 if (wl->state == WL1271_STATE_OFF)
4243 goto out;
4244
Ido Yariva6208652011-03-01 15:14:41 +02004245 ret = wl1271_ps_elp_wakeup(wl);
Juuso Oikarinen7fc3a862010-03-18 12:26:32 +02004246 if (ret < 0)
4247 goto out;
4248
4249 wl1271_acx_sg_enable(wl, wl->sg_enabled);
4250 wl1271_ps_elp_sleep(wl);
4251
4252 out:
4253 mutex_unlock(&wl->mutex);
4254 return count;
4255}
4256
4257static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
4258 wl1271_sysfs_show_bt_coex_state,
4259 wl1271_sysfs_store_bt_coex_state);
4260
Juuso Oikarinend717fd62010-05-07 11:38:58 +03004261static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
4262 struct device_attribute *attr,
4263 char *buf)
4264{
4265 struct wl1271 *wl = dev_get_drvdata(dev);
4266 ssize_t len;
4267
Juuso Oikarinen2f63b012010-08-10 06:38:35 +02004268 len = PAGE_SIZE;
Juuso Oikarinend717fd62010-05-07 11:38:58 +03004269
4270 mutex_lock(&wl->mutex);
4271 if (wl->hw_pg_ver >= 0)
4272 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
4273 else
4274 len = snprintf(buf, len, "n/a\n");
4275 mutex_unlock(&wl->mutex);
4276
4277 return len;
4278}
4279
Gery Kahn6f07b722011-07-18 14:21:49 +03004280static DEVICE_ATTR(hw_pg_ver, S_IRUGO,
Juuso Oikarinend717fd62010-05-07 11:38:58 +03004281 wl1271_sysfs_show_hw_pg_ver, NULL);
4282
Ido Yariv95dac04f2011-06-06 14:57:06 +03004283static ssize_t wl1271_sysfs_read_fwlog(struct file *filp, struct kobject *kobj,
4284 struct bin_attribute *bin_attr,
4285 char *buffer, loff_t pos, size_t count)
4286{
4287 struct device *dev = container_of(kobj, struct device, kobj);
4288 struct wl1271 *wl = dev_get_drvdata(dev);
4289 ssize_t len;
4290 int ret;
4291
4292 ret = mutex_lock_interruptible(&wl->mutex);
4293 if (ret < 0)
4294 return -ERESTARTSYS;
4295
4296 /* Let only one thread read the log at a time, blocking others */
4297 while (wl->fwlog_size == 0) {
4298 DEFINE_WAIT(wait);
4299
4300 prepare_to_wait_exclusive(&wl->fwlog_waitq,
4301 &wait,
4302 TASK_INTERRUPTIBLE);
4303
4304 if (wl->fwlog_size != 0) {
4305 finish_wait(&wl->fwlog_waitq, &wait);
4306 break;
4307 }
4308
4309 mutex_unlock(&wl->mutex);
4310
4311 schedule();
4312 finish_wait(&wl->fwlog_waitq, &wait);
4313
4314 if (signal_pending(current))
4315 return -ERESTARTSYS;
4316
4317 ret = mutex_lock_interruptible(&wl->mutex);
4318 if (ret < 0)
4319 return -ERESTARTSYS;
4320 }
4321
4322 /* Check if the fwlog is still valid */
4323 if (wl->fwlog_size < 0) {
4324 mutex_unlock(&wl->mutex);
4325 return 0;
4326 }
4327
4328 /* Seeking is not supported - old logs are not kept. Disregard pos. */
4329 len = min(count, (size_t)wl->fwlog_size);
4330 wl->fwlog_size -= len;
4331 memcpy(buffer, wl->fwlog, len);
4332
4333 /* Make room for new messages */
4334 memmove(wl->fwlog, wl->fwlog + len, wl->fwlog_size);
4335
4336 mutex_unlock(&wl->mutex);
4337
4338 return len;
4339}
4340
4341static struct bin_attribute fwlog_attr = {
4342 .attr = {.name = "fwlog", .mode = S_IRUSR},
4343 .read = wl1271_sysfs_read_fwlog,
4344};
4345
Teemu Paasikivi2d5e82b2010-02-22 08:38:21 +02004346int wl1271_register_hw(struct wl1271 *wl)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004347{
4348 int ret;
4349
4350 if (wl->mac80211_registered)
4351 return 0;
4352
Arik Nemtsov31d26ec2010-10-16 21:49:52 +02004353 ret = wl1271_fetch_nvs(wl);
4354 if (ret == 0) {
Shahar Levibc765bf2011-03-06 16:32:10 +02004355 /* NOTE: The wl->nvs->nvs element must be first, in
4356 * order to simplify the casting, we assume it is at
4357 * the beginning of the wl->nvs structure.
4358 */
4359 u8 *nvs_ptr = (u8 *)wl->nvs;
Arik Nemtsov31d26ec2010-10-16 21:49:52 +02004360
4361 wl->mac_addr[0] = nvs_ptr[11];
4362 wl->mac_addr[1] = nvs_ptr[10];
4363 wl->mac_addr[2] = nvs_ptr[6];
4364 wl->mac_addr[3] = nvs_ptr[5];
4365 wl->mac_addr[4] = nvs_ptr[4];
4366 wl->mac_addr[5] = nvs_ptr[3];
4367 }
4368
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004369 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
4370
4371 ret = ieee80211_register_hw(wl->hw);
4372 if (ret < 0) {
4373 wl1271_error("unable to register mac80211 hw: %d", ret);
4374 return ret;
4375 }
4376
4377 wl->mac80211_registered = true;
4378
Eliad Pellerd60080a2010-11-24 12:53:16 +02004379 wl1271_debugfs_init(wl);
4380
Juuso Oikarinenc2c192a2010-07-27 03:30:09 +03004381 register_netdevice_notifier(&wl1271_dev_notifier);
4382
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004383 wl1271_notice("loaded");
4384
4385 return 0;
4386}
Teemu Paasikivi50b3eb42010-02-22 08:38:26 +02004387EXPORT_SYMBOL_GPL(wl1271_register_hw);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004388
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02004389void wl1271_unregister_hw(struct wl1271 *wl)
4390{
Juuso Oikarinen4ae3fa82011-01-14 12:48:46 +01004391 if (wl->state == WL1271_STATE_PLT)
4392 __wl1271_plt_stop(wl);
4393
Juuso Oikarinenc2c192a2010-07-27 03:30:09 +03004394 unregister_netdevice_notifier(&wl1271_dev_notifier);
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02004395 ieee80211_unregister_hw(wl->hw);
4396 wl->mac80211_registered = false;
4397
4398}
4399EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
4400
Teemu Paasikivi2d5e82b2010-02-22 08:38:21 +02004401int wl1271_init_ieee80211(struct wl1271 *wl)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004402{
Juuso Oikarinen7a557242010-09-27 12:42:07 +02004403 static const u32 cipher_suites[] = {
4404 WLAN_CIPHER_SUITE_WEP40,
4405 WLAN_CIPHER_SUITE_WEP104,
4406 WLAN_CIPHER_SUITE_TKIP,
4407 WLAN_CIPHER_SUITE_CCMP,
4408 WL1271_CIPHER_SUITE_GEM,
4409 };
4410
Juuso Oikarinen1e2b7972009-10-08 21:56:20 +03004411 /* The tx descriptor buffer and the TKIP space. */
4412 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
4413 sizeof(struct wl1271_tx_hw_descr);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004414
4415 /* unit us */
4416 /* FIXME: find a proper value */
4417 wl->hw->channel_change_time = 10000;
Juuso Oikarinen50c500a2010-04-01 11:38:22 +03004418 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004419
4420 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
Juuso Oikarinen03442a32009-11-23 23:22:14 +02004421 IEEE80211_HW_BEACON_FILTER |
Juuso Oikarinen0a343322010-02-22 08:38:41 +02004422 IEEE80211_HW_SUPPORTS_PS |
Kalle Valo4695dc92010-03-18 12:26:38 +02004423 IEEE80211_HW_SUPPORTS_UAPSD |
Juuso Oikarinena9af0922010-03-26 12:53:30 +02004424 IEEE80211_HW_HAS_RATE_CONTROL |
Juuso Oikarinen00236aed2010-04-09 11:07:30 +03004425 IEEE80211_HW_CONNECTION_MONITOR |
Eliad Peller62c07402011-02-02 11:20:05 +02004426 IEEE80211_HW_SUPPORTS_CQM_RSSI |
Luciano Coelho25eaea302011-05-02 12:37:33 +03004427 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
Shahar Levifcd23b62011-05-11 12:12:56 +03004428 IEEE80211_HW_SPECTRUM_MGMT |
Arik Nemtsovba7c0822011-02-23 00:22:28 +02004429 IEEE80211_HW_AP_LINK_PS;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004430
Juuso Oikarinen7a557242010-09-27 12:42:07 +02004431 wl->hw->wiphy->cipher_suites = cipher_suites;
4432 wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
4433
Juuso Oikarinene0d8bbf2009-12-11 15:41:04 +02004434 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
Arik Nemtsov038d9252010-10-16 21:53:24 +02004435 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004436 wl->hw->wiphy->max_scan_ssids = 1;
Guy Eilamea559b42010-12-09 16:54:59 +02004437 /*
4438 * Maximum length of elements in scanning probe request templates
4439 * should be the maximum length possible for a template, without
4440 * the IEEE80211 header of the template
4441 */
Eliad Peller154037d2011-08-14 13:17:12 +03004442 wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_DFLT_SIZE -
Guy Eilamea559b42010-12-09 16:54:59 +02004443 sizeof(struct ieee80211_header);
Luciano Coelhoa8aaaf52011-01-11 18:25:18 +01004444
Luciano Coelho4a31c112011-03-21 23:16:14 +02004445 /* make sure all our channels fit in the scanned_ch bitmask */
4446 BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) +
4447 ARRAY_SIZE(wl1271_channels_5ghz) >
4448 WL1271_MAX_CHANNELS);
Luciano Coelhoa8aaaf52011-01-11 18:25:18 +01004449 /*
4450 * We keep local copies of the band structs because we need to
4451 * modify them on a per-device basis.
4452 */
4453 memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
4454 sizeof(wl1271_band_2ghz));
4455 memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
4456 sizeof(wl1271_band_5ghz));
4457
4458 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
4459 &wl->bands[IEEE80211_BAND_2GHZ];
4460 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
4461 &wl->bands[IEEE80211_BAND_5GHZ];
Teemu Paasikivi1ebec3d2009-10-13 12:47:48 +03004462
Kalle Valo12bd8942010-03-18 12:26:33 +02004463 wl->hw->queues = 4;
Juuso Oikarinen31627dc2010-03-26 12:53:12 +02004464 wl->hw->max_rates = 1;
Kalle Valo12bd8942010-03-18 12:26:33 +02004465
Juuso Oikarinenb7417d92010-11-10 11:27:19 +01004466 wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
4467
Teemu Paasikivi8197b712010-02-22 08:38:23 +02004468 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004469
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02004470 wl->hw->sta_data_size = sizeof(struct wl1271_station);
4471
Luciano Coelho4c9cfa72011-01-12 14:27:03 +01004472 wl->hw->max_rx_aggregation_subframes = 8;
4473
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004474 return 0;
4475}
Teemu Paasikivi50b3eb42010-02-22 08:38:26 +02004476EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004477
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004478#define WL1271_DEFAULT_CHANNEL 0
Teemu Paasikivic332a4b2010-02-18 13:25:57 +02004479
Teemu Paasikivi2d5e82b2010-02-22 08:38:21 +02004480struct ieee80211_hw *wl1271_alloc_hw(void)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004481{
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004482 struct ieee80211_hw *hw;
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02004483 struct platform_device *plat_dev = NULL;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004484 struct wl1271 *wl;
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +02004485 int i, j, ret;
Ido Yariv1f37cbc2010-09-30 13:28:27 +02004486 unsigned int order;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004487
4488 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
4489 if (!hw) {
4490 wl1271_error("could not alloc ieee80211_hw");
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02004491 ret = -ENOMEM;
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02004492 goto err_hw_alloc;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004493 }
4494
Julia Lawall929ebd32010-05-15 23:16:39 +02004495 plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02004496 if (!plat_dev) {
4497 wl1271_error("could not allocate platform_device");
4498 ret = -ENOMEM;
4499 goto err_plat_alloc;
4500 }
4501
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004502 wl = hw->priv;
4503 memset(wl, 0, sizeof(*wl));
4504
Juuso Oikarinen01c09162009-10-13 12:47:55 +03004505 INIT_LIST_HEAD(&wl->list);
4506
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004507 wl->hw = hw;
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02004508 wl->plat_dev = plat_dev;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004509
Juuso Oikarinen6742f552010-12-13 09:52:37 +02004510 for (i = 0; i < NUM_TX_QUEUES; i++)
4511 skb_queue_head_init(&wl->tx_queue[i]);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004512
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +02004513 for (i = 0; i < NUM_TX_QUEUES; i++)
4514 for (j = 0; j < AP_MAX_LINKS; j++)
4515 skb_queue_head_init(&wl->links[j].tx_queue[i]);
4516
Ido Yariva6208652011-03-01 15:14:41 +02004517 skb_queue_head_init(&wl->deferred_rx_queue);
4518 skb_queue_head_init(&wl->deferred_tx_queue);
4519
Juuso Oikarinen37b70a82009-10-08 21:56:21 +03004520 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
Juuso Oikarinen90494a92010-07-08 17:50:00 +03004521 INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
Ido Yariva6208652011-03-01 15:14:41 +02004522 INIT_WORK(&wl->netstack_work, wl1271_netstack_work);
Juuso Oikarinen117b38d2010-09-30 10:43:28 +02004523 INIT_WORK(&wl->tx_work, wl1271_tx_work);
4524 INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
4525 INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
Eliad Peller77ddaa12011-05-15 11:10:29 +03004526 INIT_WORK(&wl->rx_streaming_enable_work,
4527 wl1271_rx_streaming_enable_work);
4528 INIT_WORK(&wl->rx_streaming_disable_work,
4529 wl1271_rx_streaming_disable_work);
4530
Eliad Peller92ef8962011-06-07 12:50:46 +03004531 wl->freezable_wq = create_freezable_workqueue("wl12xx_wq");
4532 if (!wl->freezable_wq) {
4533 ret = -ENOMEM;
4534 goto err_hw;
4535 }
4536
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004537 wl->channel = WL1271_DEFAULT_CHANNEL;
Juuso Oikarinen60e84c22010-03-26 12:53:25 +02004538 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004539 wl->default_key = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004540 wl->rx_counter = 0;
Juuso Oikarinen19ad0712009-11-02 20:22:11 +02004541 wl->psm_entry_retry = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004542 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
Juuso Oikarinena6fe2312009-12-11 15:40:58 +02004543 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03004544 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
Juuso Oikarinen830fb672009-12-11 15:41:06 +02004545 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
Juuso Oikarinen8a5a37a2009-10-08 21:56:24 +03004546 wl->band = IEEE80211_BAND_2GHZ;
Juuso Oikarinenb771eee2009-10-08 21:56:34 +03004547 wl->vif = NULL;
Juuso Oikarinen830fb672009-12-11 15:41:06 +02004548 wl->flags = 0;
Juuso Oikarinen7fc3a862010-03-18 12:26:32 +02004549 wl->sg_enabled = true;
Juuso Oikarinend717fd62010-05-07 11:38:58 +03004550 wl->hw_pg_ver = -1;
Arik Nemtsov166d5042010-10-16 21:44:57 +02004551 wl->bss_type = MAX_BSS_TYPE;
4552 wl->set_bss_type = MAX_BSS_TYPE;
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +02004553 wl->last_tx_hlid = 0;
Arik Nemtsovb622d992011-02-23 00:22:31 +02004554 wl->ap_ps_map = 0;
4555 wl->ap_fw_ps_map = 0;
Ido Yariv606ea9f2011-03-01 15:14:39 +02004556 wl->quirks = 0;
Ido Yariv341b7cd2011-03-31 10:07:01 +02004557 wl->platform_quirks = 0;
Luciano Coelho33c2c062011-05-10 14:46:02 +03004558 wl->sched_scanning = false;
Oz Krakowskib992c682011-06-26 10:36:02 +03004559 wl->tx_security_seq = 0;
4560 wl->tx_security_last_seq_lsb = 0;
Eliad Peller7f0979882011-08-14 13:17:06 +03004561 wl->role_id = WL12XX_INVALID_ROLE_ID;
Eliad Pellerf4df1bd2011-08-14 13:17:15 +03004562 wl->system_hlid = WL12XX_SYSTEM_HLID;
Eliad Peller7f0979882011-08-14 13:17:06 +03004563 wl->sta_hlid = WL12XX_INVALID_LINK_ID;
Eliad Peller04e80792011-08-14 13:17:09 +03004564 wl->dev_role_id = WL12XX_INVALID_ROLE_ID;
4565 wl->dev_hlid = WL12XX_INVALID_LINK_ID;
Arik Nemtsov712e9bf2011-08-14 13:17:20 +03004566 wl->session_counter = 0;
Arik Nemtsove51ae9b2011-08-14 13:17:21 +03004567 wl->ap_bcast_hlid = WL12XX_INVALID_LINK_ID;
4568 wl->ap_global_hlid = WL12XX_INVALID_LINK_ID;
Eliad Peller77ddaa12011-05-15 11:10:29 +03004569 setup_timer(&wl->rx_streaming_timer, wl1271_rx_streaming_timer,
4570 (unsigned long) wl);
Ido Yariv95dac04f2011-06-06 14:57:06 +03004571 wl->fwlog_size = 0;
4572 init_waitqueue_head(&wl->fwlog_waitq);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004573
Eliad Pellerf4df1bd2011-08-14 13:17:15 +03004574 /* The system link is always allocated */
4575 __set_bit(WL12XX_SYSTEM_HLID, wl->links_map);
4576
Ido Yariv25eeb9e2010-10-12 16:20:06 +02004577 memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
Juuso Oikarinenbe7078c2009-10-08 21:56:26 +03004578 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004579 wl->tx_frames[i] = NULL;
4580
4581 spin_lock_init(&wl->wl_lock);
4582
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004583 wl->state = WL1271_STATE_OFF;
4584 mutex_init(&wl->mutex);
4585
Teemu Paasikivic332a4b2010-02-18 13:25:57 +02004586 /* Apply default driver configuration. */
4587 wl1271_conf_init(wl);
4588
Ido Yariv1f37cbc2010-09-30 13:28:27 +02004589 order = get_order(WL1271_AGGR_BUFFER_SIZE);
4590 wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
4591 if (!wl->aggr_buf) {
4592 ret = -ENOMEM;
Eliad Peller92ef8962011-06-07 12:50:46 +03004593 goto err_wq;
Ido Yariv1f37cbc2010-09-30 13:28:27 +02004594 }
4595
Ido Yariv990f5de2011-03-31 10:06:59 +02004596 wl->dummy_packet = wl12xx_alloc_dummy_packet(wl);
4597 if (!wl->dummy_packet) {
4598 ret = -ENOMEM;
4599 goto err_aggr;
4600 }
4601
Ido Yariv95dac04f2011-06-06 14:57:06 +03004602 /* Allocate one page for the FW log */
4603 wl->fwlog = (u8 *)get_zeroed_page(GFP_KERNEL);
4604 if (!wl->fwlog) {
4605 ret = -ENOMEM;
4606 goto err_dummy_packet;
4607 }
4608
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02004609 /* Register platform device */
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02004610 ret = platform_device_register(wl->plat_dev);
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02004611 if (ret) {
4612 wl1271_error("couldn't register platform device");
Ido Yariv95dac04f2011-06-06 14:57:06 +03004613 goto err_fwlog;
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02004614 }
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02004615 dev_set_drvdata(&wl->plat_dev->dev, wl);
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02004616
Juuso Oikarinen7fc3a862010-03-18 12:26:32 +02004617 /* Create sysfs file to control bt coex state */
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02004618 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
Juuso Oikarinen7fc3a862010-03-18 12:26:32 +02004619 if (ret < 0) {
4620 wl1271_error("failed to create sysfs file bt_coex_state");
4621 goto err_platform;
4622 }
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02004623
Juuso Oikarinend717fd62010-05-07 11:38:58 +03004624 /* Create sysfs file to get HW PG version */
4625 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4626 if (ret < 0) {
4627 wl1271_error("failed to create sysfs file hw_pg_ver");
4628 goto err_bt_coex_state;
4629 }
4630
Ido Yariv95dac04f2011-06-06 14:57:06 +03004631 /* Create sysfs file for the FW log */
4632 ret = device_create_bin_file(&wl->plat_dev->dev, &fwlog_attr);
4633 if (ret < 0) {
4634 wl1271_error("failed to create sysfs file fwlog");
4635 goto err_hw_pg_ver;
4636 }
4637
Teemu Paasikivic332a4b2010-02-18 13:25:57 +02004638 return hw;
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02004639
Ido Yariv95dac04f2011-06-06 14:57:06 +03004640err_hw_pg_ver:
4641 device_remove_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4642
Juuso Oikarinend717fd62010-05-07 11:38:58 +03004643err_bt_coex_state:
4644 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
4645
Juuso Oikarinen7fc3a862010-03-18 12:26:32 +02004646err_platform:
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02004647 platform_device_unregister(wl->plat_dev);
Juuso Oikarinen7fc3a862010-03-18 12:26:32 +02004648
Ido Yariv95dac04f2011-06-06 14:57:06 +03004649err_fwlog:
4650 free_page((unsigned long)wl->fwlog);
4651
Ido Yariv990f5de2011-03-31 10:06:59 +02004652err_dummy_packet:
4653 dev_kfree_skb(wl->dummy_packet);
4654
Ido Yariv1f37cbc2010-09-30 13:28:27 +02004655err_aggr:
4656 free_pages((unsigned long)wl->aggr_buf, order);
4657
Eliad Peller92ef8962011-06-07 12:50:46 +03004658err_wq:
4659 destroy_workqueue(wl->freezable_wq);
4660
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02004661err_hw:
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02004662 wl1271_debugfs_exit(wl);
4663 kfree(plat_dev);
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02004664
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02004665err_plat_alloc:
4666 ieee80211_free_hw(hw);
4667
4668err_hw_alloc:
4669
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02004670 return ERR_PTR(ret);
Teemu Paasikivic332a4b2010-02-18 13:25:57 +02004671}
Teemu Paasikivi50b3eb42010-02-22 08:38:26 +02004672EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
Teemu Paasikivic332a4b2010-02-18 13:25:57 +02004673
4674int wl1271_free_hw(struct wl1271 *wl)
4675{
Ido Yariv95dac04f2011-06-06 14:57:06 +03004676 /* Unblock any fwlog readers */
4677 mutex_lock(&wl->mutex);
4678 wl->fwlog_size = -1;
4679 wake_up_interruptible_all(&wl->fwlog_waitq);
4680 mutex_unlock(&wl->mutex);
4681
4682 device_remove_bin_file(&wl->plat_dev->dev, &fwlog_attr);
Gery Kahn6f07b722011-07-18 14:21:49 +03004683
4684 device_remove_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4685
4686 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02004687 platform_device_unregister(wl->plat_dev);
Ido Yariv95dac04f2011-06-06 14:57:06 +03004688 free_page((unsigned long)wl->fwlog);
Ido Yariv990f5de2011-03-31 10:06:59 +02004689 dev_kfree_skb(wl->dummy_packet);
Ido Yariv1f37cbc2010-09-30 13:28:27 +02004690 free_pages((unsigned long)wl->aggr_buf,
4691 get_order(WL1271_AGGR_BUFFER_SIZE));
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02004692 kfree(wl->plat_dev);
Teemu Paasikivic332a4b2010-02-18 13:25:57 +02004693
4694 wl1271_debugfs_exit(wl);
4695
Teemu Paasikivic332a4b2010-02-18 13:25:57 +02004696 vfree(wl->fw);
4697 wl->fw = NULL;
4698 kfree(wl->nvs);
4699 wl->nvs = NULL;
4700
4701 kfree(wl->fw_status);
4702 kfree(wl->tx_res_if);
Eliad Peller92ef8962011-06-07 12:50:46 +03004703 destroy_workqueue(wl->freezable_wq);
Teemu Paasikivic332a4b2010-02-18 13:25:57 +02004704
4705 ieee80211_free_hw(wl->hw);
4706
4707 return 0;
4708}
Teemu Paasikivi50b3eb42010-02-22 08:38:26 +02004709EXPORT_SYMBOL_GPL(wl1271_free_hw);
4710
Guy Eilam491bbd62011-01-12 10:33:29 +01004711u32 wl12xx_debug_level = DEBUG_NONE;
Eliad Peller17c17552010-12-12 12:15:35 +02004712EXPORT_SYMBOL_GPL(wl12xx_debug_level);
Guy Eilam491bbd62011-01-12 10:33:29 +01004713module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
Eliad Peller17c17552010-12-12 12:15:35 +02004714MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
4715
Ido Yariv95dac04f2011-06-06 14:57:06 +03004716module_param_named(fwlog, fwlog_param, charp, 0);
4717MODULE_PARM_DESC(keymap,
4718 "FW logger options: continuous, ondemand, dbgpins or disable");
4719
Teemu Paasikivi50b3eb42010-02-22 08:38:26 +02004720MODULE_LICENSE("GPL");
Luciano Coelhob1a48ca2011-02-22 14:19:28 +02004721MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
Teemu Paasikivi50b3eb42010-02-22 08:38:26 +02004722MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");