blob: 8324d905b431c9f758a11ff7270044e79c936b10 [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-Cohen958b20e02011-03-14 18:53:10 +0200238 .bet_max_consecutive = 50,
Eliad Pellera879ed72011-08-23 16:37:02 +0300239 .psm_entry_retries = 8,
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;
Eliad Peller2a5bff02011-08-25 18:10:59 +0300365static bool bug_on_recovery;
Ido Yariv95dac04f2011-06-06 14:57:06 +0300366
Arik Nemtsov7dece1c2011-04-18 14:15:28 +0300367static void __wl1271_op_remove_interface(struct wl1271 *wl,
368 bool reset_tx_queues);
Arik Nemtsov7f179b42010-10-16 21:39:06 +0200369static void wl1271_free_ap_keys(struct wl1271 *wl);
Juuso Oikarinen52b0e7a2010-09-21 06:23:31 +0200370
371
Juuso Oikarinena1dd8182010-03-18 12:26:31 +0200372static void wl1271_device_release(struct device *dev)
373{
374
375}
376
377static struct platform_device wl1271_device = {
378 .name = "wl1271",
379 .id = -1,
380
381 /* device model insists to have a release function */
382 .dev = {
383 .release = wl1271_device_release,
384 },
385};
386
Juuso Oikarinenf9f774c2011-03-21 10:43:36 +0200387static DEFINE_MUTEX(wl_list_mutex);
Juuso Oikarinen01c09162009-10-13 12:47:55 +0300388static LIST_HEAD(wl_list);
389
Eliad Pelleref4b29e2011-06-06 13:03:12 +0300390static int wl1271_check_operstate(struct wl1271 *wl, unsigned char operstate)
391{
392 int ret;
393 if (operstate != IF_OPER_UP)
394 return 0;
395
396 if (test_and_set_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags))
397 return 0;
398
Eliad Pellerb67476e2011-08-14 13:17:23 +0300399 ret = wl12xx_cmd_set_peer_state(wl, wl->sta_hlid);
Eliad Pelleref4b29e2011-06-06 13:03:12 +0300400 if (ret < 0)
401 return ret;
402
Eliad Peller251c1772011-08-14 13:17:17 +0300403 wl12xx_croc(wl, wl->role_id);
404
Eliad Pelleref4b29e2011-06-06 13:03:12 +0300405 wl1271_info("Association completed.");
406 return 0;
407}
Juuso Oikarinenc2c192a2010-07-27 03:30:09 +0300408static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
409 void *arg)
410{
411 struct net_device *dev = arg;
412 struct wireless_dev *wdev;
413 struct wiphy *wiphy;
414 struct ieee80211_hw *hw;
415 struct wl1271 *wl;
416 struct wl1271 *wl_temp;
417 int ret = 0;
418
419 /* Check that this notification is for us. */
420 if (what != NETDEV_CHANGE)
421 return NOTIFY_DONE;
422
423 wdev = dev->ieee80211_ptr;
424 if (wdev == NULL)
425 return NOTIFY_DONE;
426
427 wiphy = wdev->wiphy;
428 if (wiphy == NULL)
429 return NOTIFY_DONE;
430
431 hw = wiphy_priv(wiphy);
432 if (hw == NULL)
433 return NOTIFY_DONE;
434
435 wl_temp = hw->priv;
Juuso Oikarinenf9f774c2011-03-21 10:43:36 +0200436 mutex_lock(&wl_list_mutex);
Juuso Oikarinenc2c192a2010-07-27 03:30:09 +0300437 list_for_each_entry(wl, &wl_list, list) {
438 if (wl == wl_temp)
439 break;
440 }
Juuso Oikarinenf9f774c2011-03-21 10:43:36 +0200441 mutex_unlock(&wl_list_mutex);
Juuso Oikarinenc2c192a2010-07-27 03:30:09 +0300442 if (wl != wl_temp)
443 return NOTIFY_DONE;
444
445 mutex_lock(&wl->mutex);
446
447 if (wl->state == WL1271_STATE_OFF)
448 goto out;
449
450 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
451 goto out;
452
Ido Yariva6208652011-03-01 15:14:41 +0200453 ret = wl1271_ps_elp_wakeup(wl);
Juuso Oikarinenc2c192a2010-07-27 03:30:09 +0300454 if (ret < 0)
455 goto out;
456
Eliad Pelleref4b29e2011-06-06 13:03:12 +0300457 wl1271_check_operstate(wl, dev->operstate);
Juuso Oikarinenc2c192a2010-07-27 03:30:09 +0300458
459 wl1271_ps_elp_sleep(wl);
460
461out:
462 mutex_unlock(&wl->mutex);
463
464 return NOTIFY_OK;
465}
466
Juuso Oikarinenb7417d92010-11-10 11:27:19 +0100467static int wl1271_reg_notify(struct wiphy *wiphy,
Luciano Coelho573c67c2010-11-26 13:44:59 +0200468 struct regulatory_request *request)
469{
Juuso Oikarinenb7417d92010-11-10 11:27:19 +0100470 struct ieee80211_supported_band *band;
471 struct ieee80211_channel *ch;
472 int i;
473
474 band = wiphy->bands[IEEE80211_BAND_5GHZ];
475 for (i = 0; i < band->n_channels; i++) {
476 ch = &band->channels[i];
477 if (ch->flags & IEEE80211_CHAN_DISABLED)
478 continue;
479
480 if (ch->flags & IEEE80211_CHAN_RADAR)
481 ch->flags |= IEEE80211_CHAN_NO_IBSS |
482 IEEE80211_CHAN_PASSIVE_SCAN;
483
484 }
485
486 return 0;
487}
488
Eliad Peller77ddaa12011-05-15 11:10:29 +0300489static int wl1271_set_rx_streaming(struct wl1271 *wl, bool enable)
490{
491 int ret = 0;
492
493 /* we should hold wl->mutex */
494 ret = wl1271_acx_ps_rx_streaming(wl, enable);
495 if (ret < 0)
496 goto out;
497
498 if (enable)
499 set_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags);
500 else
501 clear_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags);
502out:
503 return ret;
504}
505
506/*
507 * this function is being called when the rx_streaming interval
508 * has beed changed or rx_streaming should be disabled
509 */
510int wl1271_recalc_rx_streaming(struct wl1271 *wl)
511{
512 int ret = 0;
513 int period = wl->conf.rx_streaming.interval;
514
515 /* don't reconfigure if rx_streaming is disabled */
516 if (!test_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags))
517 goto out;
518
519 /* reconfigure/disable according to new streaming_period */
520 if (period &&
521 test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags) &&
522 (wl->conf.rx_streaming.always ||
523 test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags)))
524 ret = wl1271_set_rx_streaming(wl, true);
525 else {
526 ret = wl1271_set_rx_streaming(wl, false);
527 /* don't cancel_work_sync since we might deadlock */
528 del_timer_sync(&wl->rx_streaming_timer);
529 }
530out:
531 return ret;
532}
533
534static void wl1271_rx_streaming_enable_work(struct work_struct *work)
535{
536 int ret;
537 struct wl1271 *wl =
538 container_of(work, struct wl1271, rx_streaming_enable_work);
539
540 mutex_lock(&wl->mutex);
541
542 if (test_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags) ||
543 !test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags) ||
544 (!wl->conf.rx_streaming.always &&
545 !test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags)))
546 goto out;
547
548 if (!wl->conf.rx_streaming.interval)
549 goto out;
550
551 ret = wl1271_ps_elp_wakeup(wl);
552 if (ret < 0)
553 goto out;
554
555 ret = wl1271_set_rx_streaming(wl, true);
556 if (ret < 0)
557 goto out_sleep;
558
559 /* stop it after some time of inactivity */
560 mod_timer(&wl->rx_streaming_timer,
561 jiffies + msecs_to_jiffies(wl->conf.rx_streaming.duration));
562
563out_sleep:
564 wl1271_ps_elp_sleep(wl);
565out:
566 mutex_unlock(&wl->mutex);
567}
568
569static void wl1271_rx_streaming_disable_work(struct work_struct *work)
570{
571 int ret;
572 struct wl1271 *wl =
573 container_of(work, struct wl1271, rx_streaming_disable_work);
574
575 mutex_lock(&wl->mutex);
576
577 if (!test_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags))
578 goto out;
579
580 ret = wl1271_ps_elp_wakeup(wl);
581 if (ret < 0)
582 goto out;
583
584 ret = wl1271_set_rx_streaming(wl, false);
585 if (ret)
586 goto out_sleep;
587
588out_sleep:
589 wl1271_ps_elp_sleep(wl);
590out:
591 mutex_unlock(&wl->mutex);
592}
593
594static void wl1271_rx_streaming_timer(unsigned long data)
595{
596 struct wl1271 *wl = (struct wl1271 *)data;
597 ieee80211_queue_work(wl->hw, &wl->rx_streaming_disable_work);
598}
599
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +0300600static void wl1271_conf_init(struct wl1271 *wl)
601{
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +0300602
603 /*
604 * This function applies the default configuration to the driver. This
605 * function is invoked upon driver load (spi probe.)
606 *
607 * The configuration is stored in a run-time structure in order to
608 * facilitate for run-time adjustment of any of the parameters. Making
609 * changes to the configuration structure will apply the new values on
610 * the next interface up (wl1271_op_start.)
611 */
612
613 /* apply driver default configuration */
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300614 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +0300615
Ido Yariv95dac04f2011-06-06 14:57:06 +0300616 /* Adjust settings according to optional module parameters */
617 if (fwlog_param) {
618 if (!strcmp(fwlog_param, "continuous")) {
619 wl->conf.fwlog.mode = WL12XX_FWLOG_CONTINUOUS;
620 } else if (!strcmp(fwlog_param, "ondemand")) {
621 wl->conf.fwlog.mode = WL12XX_FWLOG_ON_DEMAND;
622 } else if (!strcmp(fwlog_param, "dbgpins")) {
623 wl->conf.fwlog.mode = WL12XX_FWLOG_CONTINUOUS;
624 wl->conf.fwlog.output = WL12XX_FWLOG_OUTPUT_DBG_PINS;
625 } else if (!strcmp(fwlog_param, "disable")) {
626 wl->conf.fwlog.mem_blocks = 0;
627 wl->conf.fwlog.output = WL12XX_FWLOG_OUTPUT_NONE;
628 } else {
629 wl1271_error("Unknown fwlog parameter %s", fwlog_param);
630 }
631 }
632}
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +0300633
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300634static int wl1271_plt_init(struct wl1271 *wl)
635{
Luciano Coelho12419cc2010-02-18 13:25:44 +0200636 struct conf_tx_ac_category *conf_ac;
637 struct conf_tx_tid *conf_tid;
638 int ret, i;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300639
Shahar Levi49d750ca2011-03-06 16:32:09 +0200640 if (wl->chip.id == CHIP_ID_1283_PG20)
641 ret = wl128x_cmd_general_parms(wl);
642 else
643 ret = wl1271_cmd_general_parms(wl);
Luciano Coelho4a904062009-11-23 23:22:18 +0200644 if (ret < 0)
Luciano Coelhocc7defa2009-11-23 23:22:16 +0200645 return ret;
646
Shahar Levi49d750ca2011-03-06 16:32:09 +0200647 if (wl->chip.id == CHIP_ID_1283_PG20)
648 ret = wl128x_cmd_radio_parms(wl);
649 else
650 ret = wl1271_cmd_radio_parms(wl);
Luciano Coelho4a904062009-11-23 23:22:18 +0200651 if (ret < 0)
Luciano Coelhocc7defa2009-11-23 23:22:16 +0200652 return ret;
653
Shahar Levi49d750ca2011-03-06 16:32:09 +0200654 if (wl->chip.id != CHIP_ID_1283_PG20) {
655 ret = wl1271_cmd_ext_radio_parms(wl);
656 if (ret < 0)
657 return ret;
658 }
Juuso Oikarinen644a4862010-10-05 13:11:56 +0200659 if (ret < 0)
660 return ret;
661
Shahar Levi48a61472011-03-06 16:32:08 +0200662 /* Chip-specific initializations */
663 ret = wl1271_chip_specific_init(wl);
664 if (ret < 0)
665 return ret;
666
Arik Nemtsove0fe3712010-10-16 18:19:53 +0200667 ret = wl1271_sta_init_templates_config(wl);
Luciano Coelho12419cc2010-02-18 13:25:44 +0200668 if (ret < 0)
669 return ret;
670
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300671 ret = wl1271_acx_init_mem_config(wl);
672 if (ret < 0)
673 return ret;
674
Luciano Coelho12419cc2010-02-18 13:25:44 +0200675 /* PHY layer config */
676 ret = wl1271_init_phy_config(wl);
677 if (ret < 0)
678 goto out_free_memmap;
679
680 ret = wl1271_acx_dco_itrim_params(wl);
681 if (ret < 0)
682 goto out_free_memmap;
683
684 /* Initialize connection monitoring thresholds */
Juuso Oikarinen6ccbb922010-03-26 12:53:23 +0200685 ret = wl1271_acx_conn_monit_params(wl, false);
Luciano Coelho12419cc2010-02-18 13:25:44 +0200686 if (ret < 0)
687 goto out_free_memmap;
688
689 /* Bluetooth WLAN coexistence */
690 ret = wl1271_init_pta(wl);
691 if (ret < 0)
692 goto out_free_memmap;
693
Shahar Leviff868432011-04-11 15:41:46 +0300694 /* FM WLAN coexistence */
695 ret = wl1271_acx_fm_coex(wl);
696 if (ret < 0)
697 goto out_free_memmap;
698
Luciano Coelho12419cc2010-02-18 13:25:44 +0200699 /* Energy detection */
700 ret = wl1271_init_energy_detection(wl);
701 if (ret < 0)
702 goto out_free_memmap;
703
Eliad Peller7f0979882011-08-14 13:17:06 +0300704 ret = wl12xx_acx_mem_cfg(wl);
Gery Kahn1ec610e2011-02-01 03:03:08 -0600705 if (ret < 0)
706 goto out_free_memmap;
707
Luciano Coelho12419cc2010-02-18 13:25:44 +0200708 /* Default fragmentation threshold */
Arik Nemtsov68d069c2010-11-08 10:51:07 +0100709 ret = wl1271_acx_frag_threshold(wl, wl->conf.tx.frag_threshold);
Luciano Coelho12419cc2010-02-18 13:25:44 +0200710 if (ret < 0)
711 goto out_free_memmap;
712
Juuso Oikarinen9987a9d2010-09-01 11:31:12 +0200713 /* Default TID/AC configuration */
714 BUG_ON(wl->conf.tx.tid_conf_count != wl->conf.tx.ac_conf_count);
Luciano Coelho12419cc2010-02-18 13:25:44 +0200715 for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
Juuso Oikarinen9987a9d2010-09-01 11:31:12 +0200716 conf_ac = &wl->conf.tx.ac_conf[i];
717 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
718 conf_ac->cw_max, conf_ac->aifsn,
719 conf_ac->tx_op_limit);
720 if (ret < 0)
721 goto out_free_memmap;
722
Luciano Coelho12419cc2010-02-18 13:25:44 +0200723 conf_tid = &wl->conf.tx.tid_conf[i];
724 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
725 conf_tid->channel_type,
726 conf_tid->tsid,
727 conf_tid->ps_scheme,
728 conf_tid->ack_policy,
729 conf_tid->apsd_conf[0],
730 conf_tid->apsd_conf[1]);
731 if (ret < 0)
732 goto out_free_memmap;
733 }
734
Luciano Coelho12419cc2010-02-18 13:25:44 +0200735 /* Enable data path */
Luciano Coelho94210892009-12-11 15:40:55 +0200736 ret = wl1271_cmd_data_path(wl, 1);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300737 if (ret < 0)
Luciano Coelho12419cc2010-02-18 13:25:44 +0200738 goto out_free_memmap;
739
740 /* Configure for CAM power saving (ie. always active) */
741 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
742 if (ret < 0)
743 goto out_free_memmap;
744
745 /* configure PM */
746 ret = wl1271_acx_pm_config(wl);
747 if (ret < 0)
748 goto out_free_memmap;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300749
750 return 0;
Luciano Coelho12419cc2010-02-18 13:25:44 +0200751
752 out_free_memmap:
753 kfree(wl->target_mem_map);
754 wl->target_mem_map = NULL;
755
756 return ret;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300757}
758
Arik Nemtsov9b17f1b2011-08-14 13:17:35 +0300759static void wl12xx_irq_ps_regulate_link(struct wl1271 *wl, u8 hlid, u8 tx_pkts)
Arik Nemtsovb622d992011-02-23 00:22:31 +0200760{
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
Arik Nemtsov9b17f1b2011-08-14 13:17:35 +0300771 * packets in FW or if the STA is awake.
Arik Nemtsovb622d992011-02-23 00:22:31 +0200772 */
Arik Nemtsov9b17f1b2011-08-14 13:17:35 +0300773 if (!fw_ps || tx_pkts < WL1271_PS_STA_MAX_PACKETS)
Arik Nemtsovb622d992011-02-23 00:22:31 +0200774 wl1271_ps_link_end(wl, hlid);
775
776 /* Start high-level PS if the STA is asleep with enough blocks in FW */
Arik Nemtsov9b17f1b2011-08-14 13:17:35 +0300777 else if (fw_ps && tx_pkts >= WL1271_PS_STA_MAX_PACKETS)
Arik Nemtsovb622d992011-02-23 00:22:31 +0200778 wl1271_ps_link_start(wl, hlid, true);
779}
780
Arik Nemtsov9b17f1b2011-08-14 13:17:35 +0300781bool wl1271_is_active_sta(struct wl1271 *wl, u8 hlid)
782{
Arik Nemtsov04216da2011-08-14 13:17:38 +0300783 int id;
784
785 /* global/broadcast "stations" are always active */
786 if (hlid < WL1271_AP_STA_HLID_START)
787 return true;
788
789 id = hlid - WL1271_AP_STA_HLID_START;
Arik Nemtsov9b17f1b2011-08-14 13:17:35 +0300790 return test_bit(id, wl->ap_hlid_map);
791}
792
793static void wl12xx_irq_update_links_status(struct wl1271 *wl,
794 struct wl12xx_fw_status *status)
Arik Nemtsovb622d992011-02-23 00:22:31 +0200795{
796 u32 cur_fw_ps_map;
Arik Nemtsov9b17f1b2011-08-14 13:17:35 +0300797 u8 hlid, cnt;
798
799 /* TODO: also use link_fast_bitmap here */
Arik Nemtsovb622d992011-02-23 00:22:31 +0200800
801 cur_fw_ps_map = le32_to_cpu(status->link_ps_bitmap);
802 if (wl->ap_fw_ps_map != cur_fw_ps_map) {
803 wl1271_debug(DEBUG_PSM,
804 "link ps prev 0x%x cur 0x%x changed 0x%x",
805 wl->ap_fw_ps_map, cur_fw_ps_map,
806 wl->ap_fw_ps_map ^ cur_fw_ps_map);
807
808 wl->ap_fw_ps_map = cur_fw_ps_map;
809 }
810
811 for (hlid = WL1271_AP_STA_HLID_START; hlid < AP_MAX_LINKS; hlid++) {
Arik Nemtsov9b17f1b2011-08-14 13:17:35 +0300812 if (!wl1271_is_active_sta(wl, hlid))
813 continue;
Arik Nemtsovb622d992011-02-23 00:22:31 +0200814
Arik Nemtsov9b17f1b2011-08-14 13:17:35 +0300815 cnt = status->tx_lnk_free_pkts[hlid] -
816 wl->links[hlid].prev_freed_pkts;
Arik Nemtsovb622d992011-02-23 00:22:31 +0200817
Arik Nemtsov9b17f1b2011-08-14 13:17:35 +0300818 wl->links[hlid].prev_freed_pkts =
819 status->tx_lnk_free_pkts[hlid];
820 wl->links[hlid].allocated_pkts -= cnt;
821
822 wl12xx_irq_ps_regulate_link(wl, hlid,
823 wl->links[hlid].allocated_pkts);
Arik Nemtsovb622d992011-02-23 00:22:31 +0200824 }
825}
826
Eliad Peller4d56ad92011-08-14 13:17:05 +0300827static void wl12xx_fw_status(struct wl1271 *wl,
828 struct wl12xx_fw_status *status)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300829{
Juuso Oikarinenac5e1e32010-02-22 08:38:38 +0200830 struct timespec ts;
Shahar Levi13b107d2011-03-06 16:32:12 +0200831 u32 old_tx_blk_count = wl->tx_blocks_available;
Eliad Peller4d56ad92011-08-14 13:17:05 +0300832 int avail, freed_blocks;
Arik Nemtsovbf54e302011-08-14 13:17:32 +0300833 int i;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300834
Eliad Peller4d56ad92011-08-14 13:17:05 +0300835 wl1271_raw_read(wl, FW_STATUS_ADDR, status, sizeof(*status), false);
Shahar Levi13b107d2011-03-06 16:32:12 +0200836
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300837 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
838 "drv_rx_counter = %d, tx_results_counter = %d)",
839 status->intr,
840 status->fw_rx_counter,
841 status->drv_rx_counter,
842 status->tx_results_counter);
843
Arik Nemtsovbf54e302011-08-14 13:17:32 +0300844 for (i = 0; i < NUM_TX_QUEUES; i++) {
845 /* prevent wrap-around in freed-packets counter */
Arik Nemtsov742246f2011-08-14 13:17:33 +0300846 wl->tx_allocated_pkts[i] -=
Arik Nemtsovbf54e302011-08-14 13:17:32 +0300847 (status->tx_released_pkts[i] -
848 wl->tx_pkts_freed[i]) & 0xff;
849
850 wl->tx_pkts_freed[i] = status->tx_released_pkts[i];
851 }
852
Arik Nemtsovbdf91cf2011-08-14 13:17:34 +0300853 /* prevent wrap-around in total blocks counter */
854 if (likely(wl->tx_blocks_freed <=
855 le32_to_cpu(status->total_released_blks)))
856 freed_blocks = le32_to_cpu(status->total_released_blks) -
857 wl->tx_blocks_freed;
858 else
859 freed_blocks = 0x100000000LL - wl->tx_blocks_freed +
860 le32_to_cpu(status->total_released_blks);
861
Eliad Peller4d56ad92011-08-14 13:17:05 +0300862 wl->tx_blocks_freed = le32_to_cpu(status->total_released_blks);
Shahar Levi13b107d2011-03-06 16:32:12 +0200863
Arik Nemtsov7bb5d6c2011-08-14 13:17:00 +0300864 wl->tx_allocated_blocks -= freed_blocks;
865
Eliad Peller4d56ad92011-08-14 13:17:05 +0300866 avail = le32_to_cpu(status->tx_total) - wl->tx_allocated_blocks;
Ido Yarivd2f4d472011-03-31 10:07:00 +0200867
Eliad Peller4d56ad92011-08-14 13:17:05 +0300868 /*
869 * The FW might change the total number of TX memblocks before
870 * we get a notification about blocks being released. Thus, the
871 * available blocks calculation might yield a temporary result
872 * which is lower than the actual available blocks. Keeping in
873 * mind that only blocks that were allocated can be moved from
874 * TX to RX, tx_blocks_available should never decrease here.
875 */
876 wl->tx_blocks_available = max((int)wl->tx_blocks_available,
877 avail);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300878
Ido Yariva5225502010-10-12 14:49:10 +0200879 /* if more blocks are available now, tx work can be scheduled */
Shahar Levi13b107d2011-03-06 16:32:12 +0200880 if (wl->tx_blocks_available > old_tx_blk_count)
Ido Yariva5225502010-10-12 14:49:10 +0200881 clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300882
Eliad Peller4d56ad92011-08-14 13:17:05 +0300883 /* for AP update num of allocated TX blocks per link and ps status */
Arik Nemtsov9b17f1b2011-08-14 13:17:35 +0300884 if (wl->bss_type == BSS_TYPE_AP_BSS)
885 wl12xx_irq_update_links_status(wl, status);
Eliad Peller4d56ad92011-08-14 13:17:05 +0300886
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300887 /* update the host-chipset time offset */
Juuso Oikarinenac5e1e32010-02-22 08:38:38 +0200888 getnstimeofday(&ts);
889 wl->time_offset = (timespec_to_ns(&ts) >> 10) -
890 (s64)le32_to_cpu(status->fw_localtime);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300891}
892
Ido Yariva6208652011-03-01 15:14:41 +0200893static void wl1271_flush_deferred_work(struct wl1271 *wl)
894{
895 struct sk_buff *skb;
Juuso Oikarinen1e73eb62010-02-22 08:38:37 +0200896
Ido Yariva6208652011-03-01 15:14:41 +0200897 /* Pass all received frames to the network stack */
898 while ((skb = skb_dequeue(&wl->deferred_rx_queue)))
899 ieee80211_rx_ni(wl->hw, skb);
900
901 /* Return sent skbs to the network stack */
902 while ((skb = skb_dequeue(&wl->deferred_tx_queue)))
Eliad Pellerc27d3ac2011-06-07 10:40:39 +0300903 ieee80211_tx_status_ni(wl->hw, skb);
Ido Yariva6208652011-03-01 15:14:41 +0200904}
905
906static void wl1271_netstack_work(struct work_struct *work)
907{
908 struct wl1271 *wl =
909 container_of(work, struct wl1271, netstack_work);
910
911 do {
912 wl1271_flush_deferred_work(wl);
913 } while (skb_queue_len(&wl->deferred_rx_queue));
914}
915
916#define WL1271_IRQ_MAX_LOOPS 256
917
918irqreturn_t wl1271_irq(int irq, void *cookie)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300919{
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300920 int ret;
Juuso Oikarinenc15f63b2009-10-12 15:08:50 +0300921 u32 intr;
Juuso Oikarinen1e73eb62010-02-22 08:38:37 +0200922 int loopcount = WL1271_IRQ_MAX_LOOPS;
Ido Yariva6208652011-03-01 15:14:41 +0200923 struct wl1271 *wl = (struct wl1271 *)cookie;
924 bool done = false;
925 unsigned int defer_count;
Ido Yarivb07d4032011-03-01 15:14:43 +0200926 unsigned long flags;
927
928 /* TX might be handled here, avoid redundant work */
929 set_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
930 cancel_work_sync(&wl->tx_work);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300931
Ido Yariv341b7cd2011-03-31 10:07:01 +0200932 /*
933 * In case edge triggered interrupt must be used, we cannot iterate
934 * more than once without introducing race conditions with the hardirq.
935 */
936 if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ)
937 loopcount = 1;
938
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300939 mutex_lock(&wl->mutex);
940
941 wl1271_debug(DEBUG_IRQ, "IRQ work");
942
Juuso Oikarinen1e73eb62010-02-22 08:38:37 +0200943 if (unlikely(wl->state == WL1271_STATE_OFF))
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300944 goto out;
945
Ido Yariva6208652011-03-01 15:14:41 +0200946 ret = wl1271_ps_elp_wakeup(wl);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300947 if (ret < 0)
948 goto out;
949
Ido Yariva6208652011-03-01 15:14:41 +0200950 while (!done && loopcount--) {
951 /*
952 * In order to avoid a race with the hardirq, clear the flag
953 * before acknowledging the chip. Since the mutex is held,
954 * wl1271_ps_elp_wakeup cannot be called concurrently.
955 */
956 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
957 smp_mb__after_clear_bit();
Juuso Oikarinen1e73eb62010-02-22 08:38:37 +0200958
Eliad Peller4d56ad92011-08-14 13:17:05 +0300959 wl12xx_fw_status(wl, wl->fw_status);
960 intr = le32_to_cpu(wl->fw_status->intr);
Ido Yariva6208652011-03-01 15:14:41 +0200961 intr &= WL1271_INTR_MASK;
Juuso Oikarinen1e73eb62010-02-22 08:38:37 +0200962 if (!intr) {
Ido Yariva6208652011-03-01 15:14:41 +0200963 done = true;
Juuso Oikarinen1e73eb62010-02-22 08:38:37 +0200964 continue;
965 }
966
Eliad Pellerccc83b02010-10-27 14:09:57 +0200967 if (unlikely(intr & WL1271_ACX_INTR_WATCHDOG)) {
968 wl1271_error("watchdog interrupt received! "
969 "starting recovery.");
Ido Yarivbaacb9a2011-06-06 14:57:05 +0300970 wl12xx_queue_recovery_work(wl);
Eliad Pellerccc83b02010-10-27 14:09:57 +0200971
972 /* restarting the chip. ignore any other interrupt. */
973 goto out;
974 }
975
Ido Yariva6208652011-03-01 15:14:41 +0200976 if (likely(intr & WL1271_ACX_INTR_DATA)) {
Juuso Oikarinen1e73eb62010-02-22 08:38:37 +0200977 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
978
Eliad Peller4d56ad92011-08-14 13:17:05 +0300979 wl12xx_rx(wl, wl->fw_status);
Juuso Oikarinen1e73eb62010-02-22 08:38:37 +0200980
Ido Yariva5225502010-10-12 14:49:10 +0200981 /* Check if any tx blocks were freed */
Ido Yarivb07d4032011-03-01 15:14:43 +0200982 spin_lock_irqsave(&wl->wl_lock, flags);
Ido Yariva5225502010-10-12 14:49:10 +0200983 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
Arik Nemtsovf1a46382011-07-07 14:25:23 +0300984 wl1271_tx_total_queue_count(wl) > 0) {
Ido Yarivb07d4032011-03-01 15:14:43 +0200985 spin_unlock_irqrestore(&wl->wl_lock, flags);
Ido Yariva5225502010-10-12 14:49:10 +0200986 /*
987 * In order to avoid starvation of the TX path,
988 * call the work function directly.
989 */
990 wl1271_tx_work_locked(wl);
Ido Yarivb07d4032011-03-01 15:14:43 +0200991 } else {
992 spin_unlock_irqrestore(&wl->wl_lock, flags);
Ido Yariva5225502010-10-12 14:49:10 +0200993 }
994
Ido Yariv8aad2462011-03-01 15:14:38 +0200995 /* check for tx results */
Eliad Peller4d56ad92011-08-14 13:17:05 +0300996 if (wl->fw_status->tx_results_counter !=
Ido Yariv8aad2462011-03-01 15:14:38 +0200997 (wl->tx_results_count & 0xff))
998 wl1271_tx_complete(wl);
Ido Yariva6208652011-03-01 15:14:41 +0200999
1000 /* Make sure the deferred queues don't get too long */
1001 defer_count = skb_queue_len(&wl->deferred_tx_queue) +
1002 skb_queue_len(&wl->deferred_rx_queue);
1003 if (defer_count > WL1271_DEFERRED_QUEUE_LIMIT)
1004 wl1271_flush_deferred_work(wl);
Juuso Oikarinen1e73eb62010-02-22 08:38:37 +02001005 }
1006
1007 if (intr & WL1271_ACX_INTR_EVENT_A) {
1008 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
1009 wl1271_event_handle(wl, 0);
1010 }
1011
1012 if (intr & WL1271_ACX_INTR_EVENT_B) {
1013 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
1014 wl1271_event_handle(wl, 1);
1015 }
1016
1017 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
1018 wl1271_debug(DEBUG_IRQ,
1019 "WL1271_ACX_INTR_INIT_COMPLETE");
1020
1021 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
1022 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001023 }
1024
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001025 wl1271_ps_elp_sleep(wl);
1026
1027out:
Ido Yarivb07d4032011-03-01 15:14:43 +02001028 spin_lock_irqsave(&wl->wl_lock, flags);
1029 /* In case TX was not handled here, queue TX work */
1030 clear_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
1031 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
Arik Nemtsovf1a46382011-07-07 14:25:23 +03001032 wl1271_tx_total_queue_count(wl) > 0)
Ido Yarivb07d4032011-03-01 15:14:43 +02001033 ieee80211_queue_work(wl->hw, &wl->tx_work);
1034 spin_unlock_irqrestore(&wl->wl_lock, flags);
1035
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001036 mutex_unlock(&wl->mutex);
Ido Yariva6208652011-03-01 15:14:41 +02001037
1038 return IRQ_HANDLED;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001039}
Ido Yariva6208652011-03-01 15:14:41 +02001040EXPORT_SYMBOL_GPL(wl1271_irq);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001041
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001042static int wl1271_fetch_firmware(struct wl1271 *wl)
1043{
1044 const struct firmware *fw;
Arik Nemtsov166d5042010-10-16 21:44:57 +02001045 const char *fw_name;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001046 int ret;
1047
Arik Nemtsovc302b2c2011-08-17 10:45:48 +03001048 if (wl->chip.id == CHIP_ID_1283_PG20)
1049 fw_name = WL128X_FW_NAME;
1050 else
1051 fw_name = WL127X_FW_NAME;
Arik Nemtsov166d5042010-10-16 21:44:57 +02001052
1053 wl1271_debug(DEBUG_BOOT, "booting firmware %s", fw_name);
1054
1055 ret = request_firmware(&fw, fw_name, wl1271_wl_to_dev(wl));
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001056
1057 if (ret < 0) {
1058 wl1271_error("could not get firmware: %d", ret);
1059 return ret;
1060 }
1061
1062 if (fw->size % 4) {
1063 wl1271_error("firmware size is not multiple of 32 bits: %zu",
1064 fw->size);
1065 ret = -EILSEQ;
1066 goto out;
1067 }
1068
Arik Nemtsov166d5042010-10-16 21:44:57 +02001069 vfree(wl->fw);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001070 wl->fw_len = fw->size;
Juuso Oikarinen1fba4972009-10-08 21:56:32 +03001071 wl->fw = vmalloc(wl->fw_len);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001072
1073 if (!wl->fw) {
1074 wl1271_error("could not allocate memory for the firmware");
1075 ret = -ENOMEM;
1076 goto out;
1077 }
1078
1079 memcpy(wl->fw, fw->data, wl->fw_len);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001080 ret = 0;
1081
1082out:
1083 release_firmware(fw);
1084
1085 return ret;
1086}
1087
1088static int wl1271_fetch_nvs(struct wl1271 *wl)
1089{
1090 const struct firmware *fw;
1091 int ret;
1092
Shahar Levi5aa42342011-03-06 16:32:07 +02001093 ret = request_firmware(&fw, WL12XX_NVS_NAME, wl1271_wl_to_dev(wl));
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001094
1095 if (ret < 0) {
1096 wl1271_error("could not get nvs file: %d", ret);
1097 return ret;
1098 }
1099
Shahar Levibc765bf2011-03-06 16:32:10 +02001100 wl->nvs = kmemdup(fw->data, fw->size, GFP_KERNEL);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001101
1102 if (!wl->nvs) {
1103 wl1271_error("could not allocate memory for the nvs file");
1104 ret = -ENOMEM;
1105 goto out;
1106 }
1107
Juuso Oikarinen02fabb02010-08-19 04:41:15 +02001108 wl->nvs_len = fw->size;
1109
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001110out:
1111 release_firmware(fw);
1112
1113 return ret;
1114}
1115
Ido Yarivbaacb9a2011-06-06 14:57:05 +03001116void wl12xx_queue_recovery_work(struct wl1271 *wl)
1117{
1118 if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags))
1119 ieee80211_queue_work(wl->hw, &wl->recovery_work);
1120}
1121
Ido Yariv95dac04f2011-06-06 14:57:06 +03001122size_t wl12xx_copy_fwlog(struct wl1271 *wl, u8 *memblock, size_t maxlen)
1123{
1124 size_t len = 0;
1125
1126 /* The FW log is a length-value list, find where the log end */
1127 while (len < maxlen) {
1128 if (memblock[len] == 0)
1129 break;
1130 if (len + memblock[len] + 1 > maxlen)
1131 break;
1132 len += memblock[len] + 1;
1133 }
1134
1135 /* Make sure we have enough room */
1136 len = min(len, (size_t)(PAGE_SIZE - wl->fwlog_size));
1137
1138 /* Fill the FW log file, consumed by the sysfs fwlog entry */
1139 memcpy(wl->fwlog + wl->fwlog_size, memblock, len);
1140 wl->fwlog_size += len;
1141
1142 return len;
1143}
1144
1145static void wl12xx_read_fwlog_panic(struct wl1271 *wl)
1146{
1147 u32 addr;
1148 u32 first_addr;
1149 u8 *block;
1150
1151 if ((wl->quirks & WL12XX_QUIRK_FWLOG_NOT_IMPLEMENTED) ||
1152 (wl->conf.fwlog.mode != WL12XX_FWLOG_ON_DEMAND) ||
1153 (wl->conf.fwlog.mem_blocks == 0))
1154 return;
1155
1156 wl1271_info("Reading FW panic log");
1157
1158 block = kmalloc(WL12XX_HW_BLOCK_SIZE, GFP_KERNEL);
1159 if (!block)
1160 return;
1161
1162 /*
1163 * Make sure the chip is awake and the logger isn't active.
1164 * This might fail if the firmware hanged.
1165 */
1166 if (!wl1271_ps_elp_wakeup(wl))
1167 wl12xx_cmd_stop_fwlog(wl);
1168
1169 /* Read the first memory block address */
Eliad Peller4d56ad92011-08-14 13:17:05 +03001170 wl12xx_fw_status(wl, wl->fw_status);
1171 first_addr = le32_to_cpu(wl->fw_status->log_start_addr);
Ido Yariv95dac04f2011-06-06 14:57:06 +03001172 if (!first_addr)
1173 goto out;
1174
1175 /* Traverse the memory blocks linked list */
1176 addr = first_addr;
1177 do {
1178 memset(block, 0, WL12XX_HW_BLOCK_SIZE);
1179 wl1271_read_hwaddr(wl, addr, block, WL12XX_HW_BLOCK_SIZE,
1180 false);
1181
1182 /*
1183 * Memory blocks are linked to one another. The first 4 bytes
1184 * of each memory block hold the hardware address of the next
1185 * one. The last memory block points to the first one.
1186 */
Eliad Peller4d56ad92011-08-14 13:17:05 +03001187 addr = le32_to_cpup((__le32 *)block);
Ido Yariv95dac04f2011-06-06 14:57:06 +03001188 if (!wl12xx_copy_fwlog(wl, block + sizeof(addr),
1189 WL12XX_HW_BLOCK_SIZE - sizeof(addr)))
1190 break;
1191 } while (addr && (addr != first_addr));
1192
1193 wake_up_interruptible(&wl->fwlog_waitq);
1194
1195out:
1196 kfree(block);
1197}
1198
Juuso Oikarinen52b0e7a2010-09-21 06:23:31 +02001199static void wl1271_recovery_work(struct work_struct *work)
1200{
1201 struct wl1271 *wl =
1202 container_of(work, struct wl1271, recovery_work);
1203
1204 mutex_lock(&wl->mutex);
1205
1206 if (wl->state != WL1271_STATE_ON)
1207 goto out;
1208
Ido Yarivbaacb9a2011-06-06 14:57:05 +03001209 /* Avoid a recursive recovery */
1210 set_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags);
1211
Ido Yariv95dac04f2011-06-06 14:57:06 +03001212 wl12xx_read_fwlog_panic(wl);
1213
Arik Nemtsov52dcaf52011-04-18 14:15:24 +03001214 wl1271_info("Hardware recovery in progress. FW ver: %s pc: 0x%x",
1215 wl->chip.fw_ver_str, wl1271_read32(wl, SCR_PAD4));
Juuso Oikarinen52b0e7a2010-09-21 06:23:31 +02001216
Eliad Peller2a5bff02011-08-25 18:10:59 +03001217 BUG_ON(bug_on_recovery);
1218
Oz Krakowskib992c682011-06-26 10:36:02 +03001219 /*
1220 * Advance security sequence number to overcome potential progress
1221 * in the firmware during recovery. This doens't hurt if the network is
1222 * not encrypted.
1223 */
1224 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags) ||
1225 test_bit(WL1271_FLAG_AP_STARTED, &wl->flags))
1226 wl->tx_security_seq += WL1271_TX_SQN_POST_RECOVERY_PADDING;
1227
Juuso Oikarinend25611d2010-09-30 10:43:27 +02001228 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1229 ieee80211_connection_loss(wl->vif);
1230
Arik Nemtsov7dece1c2011-04-18 14:15:28 +03001231 /* Prevent spurious TX during FW restart */
1232 ieee80211_stop_queues(wl->hw);
1233
Luciano Coelho33c2c062011-05-10 14:46:02 +03001234 if (wl->sched_scanning) {
1235 ieee80211_sched_scan_stopped(wl->hw);
1236 wl->sched_scanning = false;
1237 }
1238
Juuso Oikarinen52b0e7a2010-09-21 06:23:31 +02001239 /* reboot the chipset */
Arik Nemtsov7dece1c2011-04-18 14:15:28 +03001240 __wl1271_op_remove_interface(wl, false);
Ido Yarivbaacb9a2011-06-06 14:57:05 +03001241
1242 clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags);
1243
Juuso Oikarinen52b0e7a2010-09-21 06:23:31 +02001244 ieee80211_restart_hw(wl->hw);
1245
Arik Nemtsov7dece1c2011-04-18 14:15:28 +03001246 /*
1247 * Its safe to enable TX now - the queues are stopped after a request
1248 * to restart the HW.
1249 */
1250 ieee80211_wake_queues(wl->hw);
1251
Juuso Oikarinen52b0e7a2010-09-21 06:23:31 +02001252out:
1253 mutex_unlock(&wl->mutex);
1254}
1255
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001256static void wl1271_fw_wakeup(struct wl1271 *wl)
1257{
1258 u32 elp_reg;
1259
1260 elp_reg = ELPCTRL_WAKE_UP;
Juuso Oikarinen74621412009-10-12 15:08:54 +03001261 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001262}
1263
1264static int wl1271_setup(struct wl1271 *wl)
1265{
1266 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
1267 if (!wl->fw_status)
1268 return -ENOMEM;
1269
1270 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
1271 if (!wl->tx_res_if) {
1272 kfree(wl->fw_status);
1273 return -ENOMEM;
1274 }
1275
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001276 return 0;
1277}
1278
1279static int wl1271_chip_wakeup(struct wl1271 *wl)
1280{
Juuso Oikarinen451de972009-10-12 15:08:46 +03001281 struct wl1271_partition_set partition;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001282 int ret = 0;
1283
Juuso Oikarinen01ac17ec2009-12-11 15:41:02 +02001284 msleep(WL1271_PRE_POWER_ON_SLEEP);
Ohad Ben-Cohen2cc78ff2010-09-16 01:22:04 +02001285 ret = wl1271_power_on(wl);
1286 if (ret < 0)
1287 goto out;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001288 msleep(WL1271_POWER_ON_SLEEP);
Teemu Paasikivi9b280722010-02-18 13:25:56 +02001289 wl1271_io_reset(wl);
1290 wl1271_io_init(wl);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001291
1292 /* We don't need a real memory partition here, because we only want
1293 * to use the registers at this point. */
Juuso Oikarinen451de972009-10-12 15:08:46 +03001294 memset(&partition, 0, sizeof(partition));
1295 partition.reg.start = REGISTERS_BASE;
1296 partition.reg.size = REGISTERS_DOWN_SIZE;
1297 wl1271_set_partition(wl, &partition);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001298
1299 /* ELP module wake up */
1300 wl1271_fw_wakeup(wl);
1301
1302 /* whal_FwCtrl_BootSm() */
1303
1304 /* 0. read chip id from CHIP_ID */
Teemu Paasikivi7b048c52010-02-18 13:25:55 +02001305 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001306
1307 /* 1. check if chip id is valid */
1308
1309 switch (wl->chip.id) {
1310 case CHIP_ID_1271_PG10:
1311 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
1312 wl->chip.id);
1313
1314 ret = wl1271_setup(wl);
1315 if (ret < 0)
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001316 goto out;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001317 break;
1318 case CHIP_ID_1271_PG20:
1319 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
1320 wl->chip.id);
1321
Shahar Levi0c005042011-06-12 10:34:43 +03001322 /*
1323 * 'end-of-transaction flag' and 'LPD mode flag'
1324 * should be set in wl127x AP mode only
1325 */
Shahar Levi564f5952011-04-04 10:20:39 +03001326 if (wl->bss_type == BSS_TYPE_AP_BSS)
Shahar Levi0c005042011-06-12 10:34:43 +03001327 wl->quirks |= (WL12XX_QUIRK_END_OF_TRANSACTION |
1328 WL12XX_QUIRK_LPD_MODE);
Shahar Levi564f5952011-04-04 10:20:39 +03001329
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001330 ret = wl1271_setup(wl);
1331 if (ret < 0)
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001332 goto out;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001333 break;
Shahar Levi0830cee2011-03-06 16:32:20 +02001334 case CHIP_ID_1283_PG20:
1335 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1283 PG20)",
1336 wl->chip.id);
1337
1338 ret = wl1271_setup(wl);
1339 if (ret < 0)
1340 goto out;
Shahar Levi0c005042011-06-12 10:34:43 +03001341
Ido Yariv0da13da2011-03-31 10:06:58 +02001342 if (wl1271_set_block_size(wl))
1343 wl->quirks |= WL12XX_QUIRK_BLOCKSIZE_ALIGNMENT;
Shahar Levi0830cee2011-03-06 16:32:20 +02001344 break;
1345 case CHIP_ID_1283_PG10:
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001346 default:
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001347 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001348 ret = -ENODEV;
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001349 goto out;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001350 }
1351
Arik Nemtsovc302b2c2011-08-17 10:45:48 +03001352 if (wl->fw == NULL) {
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001353 ret = wl1271_fetch_firmware(wl);
1354 if (ret < 0)
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001355 goto out;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001356 }
1357
1358 /* No NVS from netlink, try to get it from the filesystem */
1359 if (wl->nvs == NULL) {
1360 ret = wl1271_fetch_nvs(wl);
1361 if (ret < 0)
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001362 goto out;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001363 }
1364
1365out:
1366 return ret;
1367}
1368
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001369int wl1271_plt_start(struct wl1271 *wl)
1370{
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001371 int retries = WL1271_BOOT_RETRIES;
Gery Kahn6f07b722011-07-18 14:21:49 +03001372 struct wiphy *wiphy = wl->hw->wiphy;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001373 int ret;
1374
1375 mutex_lock(&wl->mutex);
1376
1377 wl1271_notice("power up");
1378
1379 if (wl->state != WL1271_STATE_OFF) {
1380 wl1271_error("cannot go into PLT state because not "
1381 "in off state: %d", wl->state);
1382 ret = -EBUSY;
1383 goto out;
1384 }
1385
Arik Nemtsov166d5042010-10-16 21:44:57 +02001386 wl->bss_type = BSS_TYPE_STA_BSS;
1387
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001388 while (retries) {
1389 retries--;
1390 ret = wl1271_chip_wakeup(wl);
1391 if (ret < 0)
1392 goto power_off;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001393
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001394 ret = wl1271_boot(wl);
1395 if (ret < 0)
1396 goto power_off;
1397
1398 ret = wl1271_plt_init(wl);
1399 if (ret < 0)
1400 goto irq_disable;
1401
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001402 wl->state = WL1271_STATE_PLT;
1403 wl1271_notice("firmware booted in PLT mode (%s)",
Levi, Shahar4b7fac72011-01-23 07:27:22 +01001404 wl->chip.fw_ver_str);
Luciano Coelhoe7ddf542011-03-10 15:24:57 +02001405
Gery Kahn6f07b722011-07-18 14:21:49 +03001406 /* update hw/fw version info in wiphy struct */
1407 wiphy->hw_version = wl->chip.id;
1408 strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
1409 sizeof(wiphy->fw_version));
1410
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001411 goto out;
1412
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001413irq_disable:
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001414 mutex_unlock(&wl->mutex);
1415 /* Unlocking the mutex in the middle of handling is
1416 inherently unsafe. In this case we deem it safe to do,
1417 because we need to let any possibly pending IRQ out of
1418 the system (and while we are WL1271_STATE_OFF the IRQ
1419 work function will not do anything.) Also, any other
1420 possible concurrent operations will fail due to the
1421 current state, hence the wl1271 struct should be safe. */
Ido Yariva6208652011-03-01 15:14:41 +02001422 wl1271_disable_interrupts(wl);
1423 wl1271_flush_deferred_work(wl);
1424 cancel_work_sync(&wl->netstack_work);
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001425 mutex_lock(&wl->mutex);
1426power_off:
1427 wl1271_power_off(wl);
1428 }
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001429
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001430 wl1271_error("firmware boot in PLT mode failed despite %d retries",
1431 WL1271_BOOT_RETRIES);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001432out:
1433 mutex_unlock(&wl->mutex);
1434
1435 return ret;
1436}
1437
Luciano Coelho4623ec72011-03-21 19:26:41 +02001438static int __wl1271_plt_stop(struct wl1271 *wl)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001439{
1440 int ret = 0;
1441
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001442 wl1271_notice("power down");
1443
1444 if (wl->state != WL1271_STATE_PLT) {
1445 wl1271_error("cannot power down because not in PLT "
1446 "state: %d", wl->state);
1447 ret = -EBUSY;
1448 goto out;
1449 }
1450
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001451 wl1271_power_off(wl);
1452
1453 wl->state = WL1271_STATE_OFF;
Luciano Coelhobd5ea182009-10-13 12:47:58 +03001454 wl->rx_counter = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001455
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001456 mutex_unlock(&wl->mutex);
Ido Yariva6208652011-03-01 15:14:41 +02001457 wl1271_disable_interrupts(wl);
1458 wl1271_flush_deferred_work(wl);
1459 cancel_work_sync(&wl->netstack_work);
Juuso Oikarinen52b0e7a2010-09-21 06:23:31 +02001460 cancel_work_sync(&wl->recovery_work);
Juuso Oikarinen4ae3fa82011-01-14 12:48:46 +01001461 mutex_lock(&wl->mutex);
1462out:
1463 return ret;
1464}
Juuso Oikarinen8c7f4f32010-09-21 06:23:29 +02001465
Juuso Oikarinen4ae3fa82011-01-14 12:48:46 +01001466int wl1271_plt_stop(struct wl1271 *wl)
1467{
1468 int ret;
1469
1470 mutex_lock(&wl->mutex);
1471 ret = __wl1271_plt_stop(wl);
1472 mutex_unlock(&wl->mutex);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001473 return ret;
1474}
1475
Johannes Berg7bb45682011-02-24 14:42:06 +01001476static void wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001477{
1478 struct wl1271 *wl = hw->priv;
Juuso Oikarinen830fb672009-12-11 15:41:06 +02001479 unsigned long flags;
Arik Nemtsov708bb3c2011-06-24 13:03:37 +03001480 int q, mapping;
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +02001481 u8 hlid = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001482
Arik Nemtsov708bb3c2011-06-24 13:03:37 +03001483 mapping = skb_get_queue_mapping(skb);
1484 q = wl1271_tx_get_queue(mapping);
Ido Yarivb07d4032011-03-01 15:14:43 +02001485
1486 if (wl->bss_type == BSS_TYPE_AP_BSS)
Eliad Pellerf4df1bd2011-08-14 13:17:15 +03001487 hlid = wl12xx_tx_get_hlid_ap(wl, skb);
Ido Yarivb07d4032011-03-01 15:14:43 +02001488
Juuso Oikarinen830fb672009-12-11 15:41:06 +02001489 spin_lock_irqsave(&wl->wl_lock, flags);
Ido Yarivb07d4032011-03-01 15:14:43 +02001490
Juuso Oikarinen830fb672009-12-11 15:41:06 +02001491 /* queue the packet */
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +02001492 if (wl->bss_type == BSS_TYPE_AP_BSS) {
Arik Nemtsov04216da2011-08-14 13:17:38 +03001493 if (!wl1271_is_active_sta(wl, hlid)) {
1494 wl1271_debug(DEBUG_TX, "DROP skb hlid %d q %d",
1495 hlid, q);
1496 dev_kfree_skb(skb);
1497 goto out;
1498 }
1499
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +02001500 wl1271_debug(DEBUG_TX, "queue skb hlid %d q %d", hlid, q);
1501 skb_queue_tail(&wl->links[hlid].tx_queue[q], skb);
1502 } else {
1503 skb_queue_tail(&wl->tx_queue[q], skb);
1504 }
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001505
Arik Nemtsov04b4d692011-08-14 13:17:39 +03001506 wl->tx_queue_count[q]++;
1507
1508 /*
1509 * The workqueue is slow to process the tx_queue and we need stop
1510 * the queue here, otherwise the queue will get too long.
1511 */
1512 if (wl->tx_queue_count[q] >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
1513 wl1271_debug(DEBUG_TX, "op_tx: stopping queues for q %d", q);
1514 ieee80211_stop_queue(wl->hw, mapping);
1515 set_bit(q, &wl->stopped_queues_map);
1516 }
1517
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001518 /*
1519 * The chip specific setup must run before the first TX packet -
1520 * before that, the tx_work will not be initialized!
1521 */
1522
Ido Yarivb07d4032011-03-01 15:14:43 +02001523 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
1524 !test_bit(WL1271_FLAG_TX_PENDING, &wl->flags))
Ido Yariva5225502010-10-12 14:49:10 +02001525 ieee80211_queue_work(wl->hw, &wl->tx_work);
Ido Yarivb07d4032011-03-01 15:14:43 +02001526
Arik Nemtsov04216da2011-08-14 13:17:38 +03001527out:
Ido Yarivb07d4032011-03-01 15:14:43 +02001528 spin_unlock_irqrestore(&wl->wl_lock, flags);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001529}
1530
Shahar Leviae47c452011-03-06 16:32:14 +02001531int wl1271_tx_dummy_packet(struct wl1271 *wl)
1532{
Ido Yariv990f5de2011-03-31 10:06:59 +02001533 unsigned long flags;
Arik Nemtsovf1a46382011-07-07 14:25:23 +03001534 int q = wl1271_tx_get_queue(skb_get_queue_mapping(wl->dummy_packet));
Shahar Leviae47c452011-03-06 16:32:14 +02001535
Ido Yariv990f5de2011-03-31 10:06:59 +02001536 spin_lock_irqsave(&wl->wl_lock, flags);
1537 set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags);
Arik Nemtsovf1a46382011-07-07 14:25:23 +03001538 wl->tx_queue_count[q]++;
Ido Yariv990f5de2011-03-31 10:06:59 +02001539 spin_unlock_irqrestore(&wl->wl_lock, flags);
1540
1541 /* The FW is low on RX memory blocks, so send the dummy packet asap */
1542 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags))
1543 wl1271_tx_work_locked(wl);
1544
1545 /*
1546 * If the FW TX is busy, TX work will be scheduled by the threaded
1547 * interrupt handler function
1548 */
1549 return 0;
1550}
1551
1552/*
1553 * The size of the dummy packet should be at least 1400 bytes. However, in
1554 * order to minimize the number of bus transactions, aligning it to 512 bytes
1555 * boundaries could be beneficial, performance wise
1556 */
1557#define TOTAL_TX_DUMMY_PACKET_SIZE (ALIGN(1400, 512))
1558
Luciano Coelhocf27d862011-04-01 21:08:23 +03001559static struct sk_buff *wl12xx_alloc_dummy_packet(struct wl1271 *wl)
Ido Yariv990f5de2011-03-31 10:06:59 +02001560{
1561 struct sk_buff *skb;
1562 struct ieee80211_hdr_3addr *hdr;
1563 unsigned int dummy_packet_size;
1564
1565 dummy_packet_size = TOTAL_TX_DUMMY_PACKET_SIZE -
1566 sizeof(struct wl1271_tx_hw_descr) - sizeof(*hdr);
1567
1568 skb = dev_alloc_skb(TOTAL_TX_DUMMY_PACKET_SIZE);
Shahar Leviae47c452011-03-06 16:32:14 +02001569 if (!skb) {
Ido Yariv990f5de2011-03-31 10:06:59 +02001570 wl1271_warning("Failed to allocate a dummy packet skb");
1571 return NULL;
Shahar Leviae47c452011-03-06 16:32:14 +02001572 }
1573
1574 skb_reserve(skb, sizeof(struct wl1271_tx_hw_descr));
1575
1576 hdr = (struct ieee80211_hdr_3addr *) skb_put(skb, sizeof(*hdr));
1577 memset(hdr, 0, sizeof(*hdr));
1578 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
Ido Yariv990f5de2011-03-31 10:06:59 +02001579 IEEE80211_STYPE_NULLFUNC |
1580 IEEE80211_FCTL_TODS);
Shahar Leviae47c452011-03-06 16:32:14 +02001581
Ido Yariv990f5de2011-03-31 10:06:59 +02001582 memset(skb_put(skb, dummy_packet_size), 0, dummy_packet_size);
Shahar Leviae47c452011-03-06 16:32:14 +02001583
Luciano Coelho18b92ff2011-03-21 16:35:21 +02001584 /* Dummy packets require the TID to be management */
1585 skb->priority = WL1271_TID_MGMT;
Ido Yariv990f5de2011-03-31 10:06:59 +02001586
1587 /* Initialize all fields that might be used */
Hauke Mehrtens86c438f2011-04-26 23:27:44 +02001588 skb_set_queue_mapping(skb, 0);
Ido Yariv990f5de2011-03-31 10:06:59 +02001589 memset(IEEE80211_SKB_CB(skb), 0, sizeof(struct ieee80211_tx_info));
Shahar Leviae47c452011-03-06 16:32:14 +02001590
Ido Yariv990f5de2011-03-31 10:06:59 +02001591 return skb;
Shahar Leviae47c452011-03-06 16:32:14 +02001592}
1593
Ido Yariv990f5de2011-03-31 10:06:59 +02001594
Juuso Oikarinenc2c192a2010-07-27 03:30:09 +03001595static struct notifier_block wl1271_dev_notifier = {
1596 .notifier_call = wl1271_dev_notify,
1597};
1598
Luciano Coelhof634a4e2011-05-18 16:51:26 -04001599#ifdef CONFIG_PM
Eliad Peller8a7cf3f2011-06-06 12:21:54 +03001600static int wl1271_configure_suspend_sta(struct wl1271 *wl)
Eliad Peller94390642011-05-13 11:57:13 +03001601{
Eliad Pellere85d1622011-06-27 13:06:43 +03001602 int ret = 0;
Eliad Peller94390642011-05-13 11:57:13 +03001603
Eliad Peller94390642011-05-13 11:57:13 +03001604 mutex_lock(&wl->mutex);
1605
Eliad Pellere85d1622011-06-27 13:06:43 +03001606 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1607 goto out_unlock;
1608
Eliad Peller94390642011-05-13 11:57:13 +03001609 ret = wl1271_ps_elp_wakeup(wl);
1610 if (ret < 0)
1611 goto out_unlock;
1612
1613 /* enter psm if needed*/
1614 if (!test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1615 DECLARE_COMPLETION_ONSTACK(compl);
1616
1617 wl->ps_compl = &compl;
1618 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1619 wl->basic_rate, true);
1620 if (ret < 0)
1621 goto out_sleep;
1622
1623 /* we must unlock here so we will be able to get events */
1624 wl1271_ps_elp_sleep(wl);
1625 mutex_unlock(&wl->mutex);
1626
1627 ret = wait_for_completion_timeout(
1628 &compl, msecs_to_jiffies(WL1271_PS_COMPLETE_TIMEOUT));
1629 if (ret <= 0) {
1630 wl1271_warning("couldn't enter ps mode!");
1631 ret = -EBUSY;
1632 goto out;
1633 }
1634
1635 /* take mutex again, and wakeup */
1636 mutex_lock(&wl->mutex);
1637
1638 ret = wl1271_ps_elp_wakeup(wl);
1639 if (ret < 0)
1640 goto out_unlock;
1641 }
1642out_sleep:
1643 wl1271_ps_elp_sleep(wl);
1644out_unlock:
1645 mutex_unlock(&wl->mutex);
1646out:
1647 return ret;
1648
1649}
1650
Eliad Peller8a7cf3f2011-06-06 12:21:54 +03001651static int wl1271_configure_suspend_ap(struct wl1271 *wl)
Eliad Peller94390642011-05-13 11:57:13 +03001652{
Eliad Pellere85d1622011-06-27 13:06:43 +03001653 int ret = 0;
Eliad Peller94390642011-05-13 11:57:13 +03001654
Eliad Peller8a7cf3f2011-06-06 12:21:54 +03001655 mutex_lock(&wl->mutex);
1656
Eliad Pellere85d1622011-06-27 13:06:43 +03001657 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags))
1658 goto out_unlock;
1659
Eliad Peller8a7cf3f2011-06-06 12:21:54 +03001660 ret = wl1271_ps_elp_wakeup(wl);
1661 if (ret < 0)
1662 goto out_unlock;
1663
Eliad Pellerf42bd2c2011-08-14 13:17:13 +03001664 ret = wl1271_acx_beacon_filter_opt(wl, true);
Eliad Peller8a7cf3f2011-06-06 12:21:54 +03001665
1666 wl1271_ps_elp_sleep(wl);
1667out_unlock:
1668 mutex_unlock(&wl->mutex);
1669 return ret;
1670
1671}
1672
1673static int wl1271_configure_suspend(struct wl1271 *wl)
1674{
1675 if (wl->bss_type == BSS_TYPE_STA_BSS)
1676 return wl1271_configure_suspend_sta(wl);
1677 if (wl->bss_type == BSS_TYPE_AP_BSS)
1678 return wl1271_configure_suspend_ap(wl);
1679 return 0;
1680}
1681
1682static void wl1271_configure_resume(struct wl1271 *wl)
1683{
1684 int ret;
1685 bool is_sta = wl->bss_type == BSS_TYPE_STA_BSS;
1686 bool is_ap = wl->bss_type == BSS_TYPE_AP_BSS;
1687
1688 if (!is_sta && !is_ap)
Eliad Peller94390642011-05-13 11:57:13 +03001689 return;
1690
1691 mutex_lock(&wl->mutex);
1692 ret = wl1271_ps_elp_wakeup(wl);
1693 if (ret < 0)
1694 goto out;
1695
Eliad Peller8a7cf3f2011-06-06 12:21:54 +03001696 if (is_sta) {
1697 /* exit psm if it wasn't configured */
1698 if (!test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags))
1699 wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1700 wl->basic_rate, true);
1701 } else if (is_ap) {
Eliad Pellerf42bd2c2011-08-14 13:17:13 +03001702 wl1271_acx_beacon_filter_opt(wl, false);
Eliad Peller8a7cf3f2011-06-06 12:21:54 +03001703 }
Eliad Peller94390642011-05-13 11:57:13 +03001704
1705 wl1271_ps_elp_sleep(wl);
1706out:
1707 mutex_unlock(&wl->mutex);
1708}
1709
Eliad Peller402e48612011-05-13 11:57:09 +03001710static int wl1271_op_suspend(struct ieee80211_hw *hw,
1711 struct cfg80211_wowlan *wow)
1712{
1713 struct wl1271 *wl = hw->priv;
Eliad Peller4a859df2011-06-06 12:21:52 +03001714 int ret;
1715
Eliad Peller402e48612011-05-13 11:57:09 +03001716 wl1271_debug(DEBUG_MAC80211, "mac80211 suspend wow=%d", !!wow);
Eliad Peller4a859df2011-06-06 12:21:52 +03001717 WARN_ON(!wow || !wow->any);
Eliad Pellerf44e5862011-05-13 11:57:11 +03001718
Eliad Peller4a859df2011-06-06 12:21:52 +03001719 wl->wow_enabled = true;
1720 ret = wl1271_configure_suspend(wl);
1721 if (ret < 0) {
1722 wl1271_warning("couldn't prepare device to suspend");
1723 return ret;
Eliad Pellerf44e5862011-05-13 11:57:11 +03001724 }
Eliad Peller4a859df2011-06-06 12:21:52 +03001725 /* flush any remaining work */
1726 wl1271_debug(DEBUG_MAC80211, "flushing remaining works");
Eliad Peller4a859df2011-06-06 12:21:52 +03001727
1728 /*
1729 * disable and re-enable interrupts in order to flush
1730 * the threaded_irq
1731 */
1732 wl1271_disable_interrupts(wl);
1733
1734 /*
1735 * set suspended flag to avoid triggering a new threaded_irq
1736 * work. no need for spinlock as interrupts are disabled.
1737 */
1738 set_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
1739
1740 wl1271_enable_interrupts(wl);
1741 flush_work(&wl->tx_work);
1742 flush_delayed_work(&wl->pspoll_work);
1743 flush_delayed_work(&wl->elp_work);
1744
Eliad Peller402e48612011-05-13 11:57:09 +03001745 return 0;
1746}
1747
1748static int wl1271_op_resume(struct ieee80211_hw *hw)
1749{
1750 struct wl1271 *wl = hw->priv;
Eliad Peller4a859df2011-06-06 12:21:52 +03001751 unsigned long flags;
1752 bool run_irq_work = false;
1753
Eliad Peller402e48612011-05-13 11:57:09 +03001754 wl1271_debug(DEBUG_MAC80211, "mac80211 resume wow=%d",
1755 wl->wow_enabled);
Eliad Peller4a859df2011-06-06 12:21:52 +03001756 WARN_ON(!wl->wow_enabled);
Eliad Pellerf44e5862011-05-13 11:57:11 +03001757
1758 /*
1759 * re-enable irq_work enqueuing, and call irq_work directly if
1760 * there is a pending work.
1761 */
Eliad Peller4a859df2011-06-06 12:21:52 +03001762 spin_lock_irqsave(&wl->wl_lock, flags);
1763 clear_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
1764 if (test_and_clear_bit(WL1271_FLAG_PENDING_WORK, &wl->flags))
1765 run_irq_work = true;
1766 spin_unlock_irqrestore(&wl->wl_lock, flags);
Eliad Pellerf44e5862011-05-13 11:57:11 +03001767
Eliad Peller4a859df2011-06-06 12:21:52 +03001768 if (run_irq_work) {
1769 wl1271_debug(DEBUG_MAC80211,
1770 "run postponed irq_work directly");
1771 wl1271_irq(0, wl);
1772 wl1271_enable_interrupts(wl);
Eliad Pellerf44e5862011-05-13 11:57:11 +03001773 }
Eliad Peller4a859df2011-06-06 12:21:52 +03001774 wl1271_configure_resume(wl);
Eliad Pellerff91afc2011-06-06 12:21:53 +03001775 wl->wow_enabled = false;
Eliad Pellerf44e5862011-05-13 11:57:11 +03001776
Eliad Peller402e48612011-05-13 11:57:09 +03001777 return 0;
1778}
Luciano Coelhof634a4e2011-05-18 16:51:26 -04001779#endif
Eliad Peller402e48612011-05-13 11:57:09 +03001780
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001781static int wl1271_op_start(struct ieee80211_hw *hw)
1782{
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001783 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
1784
1785 /*
1786 * We have to delay the booting of the hardware because
1787 * we need to know the local MAC address before downloading and
1788 * initializing the firmware. The MAC address cannot be changed
1789 * after boot, and without the proper MAC address, the firmware
1790 * will not function properly.
1791 *
1792 * The MAC address is first known when the corresponding interface
1793 * is added. That is where we will initialize the hardware.
1794 */
1795
1796 return 0;
1797}
1798
1799static void wl1271_op_stop(struct ieee80211_hw *hw)
1800{
1801 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
1802}
1803
Eliad Pellerb78b47e2011-08-14 13:17:08 +03001804static u8 wl12xx_get_role_type(struct wl1271 *wl)
1805{
1806 switch (wl->bss_type) {
1807 case BSS_TYPE_AP_BSS:
1808 return WL1271_ROLE_AP;
1809
1810 case BSS_TYPE_STA_BSS:
1811 return WL1271_ROLE_STA;
1812
Eliad Peller227e81e2011-08-14 13:17:26 +03001813 case BSS_TYPE_IBSS:
1814 return WL1271_ROLE_IBSS;
1815
Eliad Pellerb78b47e2011-08-14 13:17:08 +03001816 default:
1817 wl1271_error("invalid bss_type: %d", wl->bss_type);
1818 }
1819 return WL12XX_INVALID_ROLE_TYPE;
1820}
1821
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001822static int wl1271_op_add_interface(struct ieee80211_hw *hw,
1823 struct ieee80211_vif *vif)
1824{
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001825 struct wl1271 *wl = hw->priv;
John W. Linvilleac01e942010-07-28 17:09:41 -04001826 struct wiphy *wiphy = hw->wiphy;
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001827 int retries = WL1271_BOOT_RETRIES;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001828 int ret = 0;
Eliad Pellerb78b47e2011-08-14 13:17:08 +03001829 u8 role_type;
Eliad Peller71125ab2010-10-28 21:46:43 +02001830 bool booted = false;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001831
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001832 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
1833 vif->type, vif->addr);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001834
1835 mutex_lock(&wl->mutex);
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001836 if (wl->vif) {
Eliad Peller71125ab2010-10-28 21:46:43 +02001837 wl1271_debug(DEBUG_MAC80211,
1838 "multiple vifs are not supported yet");
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001839 ret = -EBUSY;
1840 goto out;
1841 }
1842
Juuso Oikarinen13026de2011-03-29 16:43:50 +03001843 /*
1844 * in some very corner case HW recovery scenarios its possible to
1845 * get here before __wl1271_op_remove_interface is complete, so
1846 * opt out if that is the case.
1847 */
1848 if (test_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags)) {
1849 ret = -EBUSY;
1850 goto out;
1851 }
1852
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001853 switch (vif->type) {
1854 case NL80211_IFTYPE_STATION:
1855 wl->bss_type = BSS_TYPE_STA_BSS;
Juuso Oikarinen5da11dc2010-03-26 12:53:24 +02001856 wl->set_bss_type = BSS_TYPE_STA_BSS;
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001857 break;
1858 case NL80211_IFTYPE_ADHOC:
1859 wl->bss_type = BSS_TYPE_IBSS;
Juuso Oikarinen5da11dc2010-03-26 12:53:24 +02001860 wl->set_bss_type = BSS_TYPE_STA_BSS;
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001861 break;
Arik Nemtsov038d9252010-10-16 21:53:24 +02001862 case NL80211_IFTYPE_AP:
1863 wl->bss_type = BSS_TYPE_AP_BSS;
1864 break;
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001865 default:
1866 ret = -EOPNOTSUPP;
1867 goto out;
1868 }
1869
Eliad Pellerb78b47e2011-08-14 13:17:08 +03001870 role_type = wl12xx_get_role_type(wl);
1871 if (role_type == WL12XX_INVALID_ROLE_TYPE) {
1872 ret = -EINVAL;
1873 goto out;
1874 }
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001875 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001876
1877 if (wl->state != WL1271_STATE_OFF) {
1878 wl1271_error("cannot start because not in off state: %d",
1879 wl->state);
1880 ret = -EBUSY;
1881 goto out;
1882 }
1883
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001884 while (retries) {
1885 retries--;
1886 ret = wl1271_chip_wakeup(wl);
1887 if (ret < 0)
1888 goto power_off;
1889
1890 ret = wl1271_boot(wl);
1891 if (ret < 0)
1892 goto power_off;
1893
Eliad Peller227e81e2011-08-14 13:17:26 +03001894 if (wl->bss_type == BSS_TYPE_STA_BSS ||
1895 wl->bss_type == BSS_TYPE_IBSS) {
Eliad Peller04e80792011-08-14 13:17:09 +03001896 /*
1897 * The device role is a special role used for
1898 * rx and tx frames prior to association (as
1899 * the STA role can get packets only from
1900 * its associated bssid)
1901 */
1902 ret = wl12xx_cmd_role_enable(wl,
1903 WL1271_ROLE_DEVICE,
1904 &wl->dev_role_id);
1905 if (ret < 0)
1906 goto irq_disable;
1907 }
1908
Eliad Pellerb78b47e2011-08-14 13:17:08 +03001909 ret = wl12xx_cmd_role_enable(wl, role_type, &wl->role_id);
1910 if (ret < 0)
1911 goto irq_disable;
1912
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001913 ret = wl1271_hw_init(wl);
1914 if (ret < 0)
1915 goto irq_disable;
1916
Eliad Peller71125ab2010-10-28 21:46:43 +02001917 booted = true;
1918 break;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001919
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001920irq_disable:
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001921 mutex_unlock(&wl->mutex);
1922 /* Unlocking the mutex in the middle of handling is
1923 inherently unsafe. In this case we deem it safe to do,
1924 because we need to let any possibly pending IRQ out of
1925 the system (and while we are WL1271_STATE_OFF the IRQ
1926 work function will not do anything.) Also, any other
1927 possible concurrent operations will fail due to the
1928 current state, hence the wl1271 struct should be safe. */
Ido Yariva6208652011-03-01 15:14:41 +02001929 wl1271_disable_interrupts(wl);
1930 wl1271_flush_deferred_work(wl);
1931 cancel_work_sync(&wl->netstack_work);
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001932 mutex_lock(&wl->mutex);
1933power_off:
1934 wl1271_power_off(wl);
1935 }
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001936
Eliad Peller71125ab2010-10-28 21:46:43 +02001937 if (!booted) {
1938 wl1271_error("firmware boot failed despite %d retries",
1939 WL1271_BOOT_RETRIES);
1940 goto out;
1941 }
1942
1943 wl->vif = vif;
1944 wl->state = WL1271_STATE_ON;
Juuso Oikarinen13026de2011-03-29 16:43:50 +03001945 set_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags);
Levi, Shahar4b7fac72011-01-23 07:27:22 +01001946 wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
Eliad Peller71125ab2010-10-28 21:46:43 +02001947
1948 /* update hw/fw version info in wiphy struct */
1949 wiphy->hw_version = wl->chip.id;
Levi, Shahar4b7fac72011-01-23 07:27:22 +01001950 strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
Eliad Peller71125ab2010-10-28 21:46:43 +02001951 sizeof(wiphy->fw_version));
1952
Luciano Coelhofb6a6812010-12-03 17:05:40 +02001953 /*
1954 * Now we know if 11a is supported (info from the NVS), so disable
1955 * 11a channels if not supported
1956 */
1957 if (!wl->enable_11a)
1958 wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0;
1959
1960 wl1271_debug(DEBUG_MAC80211, "11a is %ssupported",
1961 wl->enable_11a ? "" : "not ");
1962
Juuso Oikarineneb5b28d2009-10-13 12:47:45 +03001963out:
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001964 mutex_unlock(&wl->mutex);
1965
Juuso Oikarinenf9f774c2011-03-21 10:43:36 +02001966 mutex_lock(&wl_list_mutex);
Juuso Oikarineneb887df2010-07-08 17:49:58 +03001967 if (!ret)
Juuso Oikarinen01c09162009-10-13 12:47:55 +03001968 list_add(&wl->list, &wl_list);
Juuso Oikarinenf9f774c2011-03-21 10:43:36 +02001969 mutex_unlock(&wl_list_mutex);
Juuso Oikarinen01c09162009-10-13 12:47:55 +03001970
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001971 return ret;
1972}
1973
Arik Nemtsov7dece1c2011-04-18 14:15:28 +03001974static void __wl1271_op_remove_interface(struct wl1271 *wl,
1975 bool reset_tx_queues)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001976{
Arik Nemtsovbf54e302011-08-14 13:17:32 +03001977 int ret, i;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001978
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001979 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001980
Juuso Oikarinen13026de2011-03-29 16:43:50 +03001981 /* because of hardware recovery, we may get here twice */
1982 if (wl->state != WL1271_STATE_ON)
1983 return;
1984
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001985 wl1271_info("down");
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001986
Juuso Oikarinenf9f774c2011-03-21 10:43:36 +02001987 mutex_lock(&wl_list_mutex);
Juuso Oikarinen01c09162009-10-13 12:47:55 +03001988 list_del(&wl->list);
Juuso Oikarinenf9f774c2011-03-21 10:43:36 +02001989 mutex_unlock(&wl_list_mutex);
Juuso Oikarinen01c09162009-10-13 12:47:55 +03001990
Juuso Oikarinen8d2ef7b2010-07-08 17:50:03 +03001991 /* enable dyn ps just in case (if left on due to fw crash etc) */
Juuso Oikarinen9a547bf2010-07-08 17:50:04 +03001992 if (wl->bss_type == BSS_TYPE_STA_BSS)
Juuso Oikarinenf532be62010-07-08 17:50:05 +03001993 ieee80211_enable_dyn_ps(wl->vif);
Juuso Oikarinen8d2ef7b2010-07-08 17:50:03 +03001994
Luciano Coelho08688d62010-07-08 17:50:07 +03001995 if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
Luciano Coelho08688d62010-07-08 17:50:07 +03001996 wl->scan.state = WL1271_SCAN_STATE_IDLE;
Luciano Coelho4a31c112011-03-21 23:16:14 +02001997 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
Juuso Oikarinenb739a422010-10-26 13:24:38 +02001998 wl->scan.req = NULL;
Juuso Oikarinen76a029f2010-07-29 04:54:45 +03001999 ieee80211_scan_completed(wl->hw, true);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002000 }
2001
Eliad Pellerb78b47e2011-08-14 13:17:08 +03002002 if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags)) {
2003 /* disable active roles */
2004 ret = wl1271_ps_elp_wakeup(wl);
2005 if (ret < 0)
2006 goto deinit;
2007
Eliad Peller04e80792011-08-14 13:17:09 +03002008 if (wl->bss_type == BSS_TYPE_STA_BSS) {
2009 ret = wl12xx_cmd_role_disable(wl, &wl->dev_role_id);
2010 if (ret < 0)
2011 goto deinit;
2012 }
2013
Eliad Pellerb78b47e2011-08-14 13:17:08 +03002014 ret = wl12xx_cmd_role_disable(wl, &wl->role_id);
2015 if (ret < 0)
2016 goto deinit;
2017
2018 wl1271_ps_elp_sleep(wl);
2019 }
2020deinit:
Arik Nemtsove51ae9b2011-08-14 13:17:21 +03002021 /* clear all hlids (except system_hlid) */
Eliad Pellerb78b47e2011-08-14 13:17:08 +03002022 wl->sta_hlid = WL12XX_INVALID_LINK_ID;
Eliad Peller04e80792011-08-14 13:17:09 +03002023 wl->dev_hlid = WL12XX_INVALID_LINK_ID;
Arik Nemtsove51ae9b2011-08-14 13:17:21 +03002024 wl->ap_bcast_hlid = WL12XX_INVALID_LINK_ID;
2025 wl->ap_global_hlid = WL12XX_INVALID_LINK_ID;
Eliad Pellerb78b47e2011-08-14 13:17:08 +03002026
Juuso Oikarinen13026de2011-03-29 16:43:50 +03002027 /*
2028 * this must be before the cancel_work calls below, so that the work
2029 * functions don't perform further work.
2030 */
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002031 wl->state = WL1271_STATE_OFF;
2032
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002033 mutex_unlock(&wl->mutex);
2034
Ido Yariva6208652011-03-01 15:14:41 +02002035 wl1271_disable_interrupts(wl);
2036 wl1271_flush_deferred_work(wl);
Juuso Oikarinen78abd322010-09-21 06:23:32 +02002037 cancel_delayed_work_sync(&wl->scan_complete_work);
Ido Yariva6208652011-03-01 15:14:41 +02002038 cancel_work_sync(&wl->netstack_work);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002039 cancel_work_sync(&wl->tx_work);
Eliad Peller77ddaa12011-05-15 11:10:29 +03002040 del_timer_sync(&wl->rx_streaming_timer);
2041 cancel_work_sync(&wl->rx_streaming_enable_work);
2042 cancel_work_sync(&wl->rx_streaming_disable_work);
Juuso Oikarinen90494a92010-07-08 17:50:00 +03002043 cancel_delayed_work_sync(&wl->pspoll_work);
Juuso Oikarinen8c7f4f32010-09-21 06:23:29 +02002044 cancel_delayed_work_sync(&wl->elp_work);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002045
2046 mutex_lock(&wl->mutex);
2047
2048 /* let's notify MAC80211 about the remaining pending TX frames */
Arik Nemtsov7dece1c2011-04-18 14:15:28 +03002049 wl1271_tx_reset(wl, reset_tx_queues);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002050 wl1271_power_off(wl);
2051
2052 memset(wl->bssid, 0, ETH_ALEN);
Johannes Berg3b40c042011-07-13 10:39:16 +02002053 memset(wl->ssid, 0, IEEE80211_MAX_SSID_LEN + 1);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002054 wl->ssid_len = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002055 wl->bss_type = MAX_BSS_TYPE;
Juuso Oikarinen5da11dc2010-03-26 12:53:24 +02002056 wl->set_bss_type = MAX_BSS_TYPE;
Juuso Oikarinen8a5a37a2009-10-08 21:56:24 +03002057 wl->band = IEEE80211_BAND_2GHZ;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002058
2059 wl->rx_counter = 0;
Juuso Oikarinen19ad0712009-11-02 20:22:11 +02002060 wl->psm_entry_retry = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002061 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2062 wl->tx_blocks_available = 0;
Arik Nemtsov7bb5d6c2011-08-14 13:17:00 +03002063 wl->tx_allocated_blocks = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002064 wl->tx_results_count = 0;
2065 wl->tx_packets_count = 0;
2066 wl->time_offset = 0;
2067 wl->session_counter = 0;
Juuso Oikarinen830fb672009-12-11 15:41:06 +02002068 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02002069 wl->vif = NULL;
Guy Eilame9eb8cb2011-08-16 19:49:12 +03002070 wl->tx_spare_blocks = TX_HW_BLOCK_SPARE_DEFAULT;
Arik Nemtsov7f179b42010-10-16 21:39:06 +02002071 wl1271_free_ap_keys(wl);
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02002072 memset(wl->ap_hlid_map, 0, sizeof(wl->ap_hlid_map));
Arik Nemtsovb622d992011-02-23 00:22:31 +02002073 wl->ap_fw_ps_map = 0;
2074 wl->ap_ps_map = 0;
Luciano Coelho33c2c062011-05-10 14:46:02 +03002075 wl->sched_scanning = false;
Eliad Peller7f0979882011-08-14 13:17:06 +03002076 wl->role_id = WL12XX_INVALID_ROLE_ID;
Eliad Peller04e80792011-08-14 13:17:09 +03002077 wl->dev_role_id = WL12XX_INVALID_ROLE_ID;
Eliad Pellerc690ec82011-08-14 13:17:07 +03002078 memset(wl->roles_map, 0, sizeof(wl->roles_map));
2079 memset(wl->links_map, 0, sizeof(wl->links_map));
Eliad Peller251c1772011-08-14 13:17:17 +03002080 memset(wl->roc_map, 0, sizeof(wl->roc_map));
Luciano Coelhod6e19d12009-10-12 15:08:43 +03002081
Eliad Pellerf4df1bd2011-08-14 13:17:15 +03002082 /* The system link is always allocated */
2083 __set_bit(WL12XX_SYSTEM_HLID, wl->links_map);
2084
Juuso Oikarinen13026de2011-03-29 16:43:50 +03002085 /*
2086 * this is performed after the cancel_work calls and the associated
2087 * mutex_lock, so that wl1271_op_add_interface does not accidentally
2088 * get executed before all these vars have been reset.
2089 */
2090 wl->flags = 0;
2091
Eliad Peller4d56ad92011-08-14 13:17:05 +03002092 wl->tx_blocks_freed = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002093
Arik Nemtsov742246f2011-08-14 13:17:33 +03002094 for (i = 0; i < NUM_TX_QUEUES; i++) {
Arik Nemtsovbf54e302011-08-14 13:17:32 +03002095 wl->tx_pkts_freed[i] = 0;
Arik Nemtsov742246f2011-08-14 13:17:33 +03002096 wl->tx_allocated_pkts[i] = 0;
2097 }
Arik Nemtsovbf54e302011-08-14 13:17:32 +03002098
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002099 wl1271_debugfs_reset(wl);
Juuso Oikarinenbd9dc492010-04-09 11:07:26 +03002100
2101 kfree(wl->fw_status);
2102 wl->fw_status = NULL;
2103 kfree(wl->tx_res_if);
2104 wl->tx_res_if = NULL;
2105 kfree(wl->target_mem_map);
2106 wl->target_mem_map = NULL;
Juuso Oikarinen52a2a372010-09-21 06:23:30 +02002107}
Juuso Oikarinenbd9dc492010-04-09 11:07:26 +03002108
Juuso Oikarinen52a2a372010-09-21 06:23:30 +02002109static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
2110 struct ieee80211_vif *vif)
2111{
2112 struct wl1271 *wl = hw->priv;
2113
2114 mutex_lock(&wl->mutex);
Juuso Oikarinen67353292010-11-18 15:19:02 +02002115 /*
2116 * wl->vif can be null here if someone shuts down the interface
2117 * just when hardware recovery has been started.
2118 */
2119 if (wl->vif) {
2120 WARN_ON(wl->vif != vif);
Arik Nemtsov7dece1c2011-04-18 14:15:28 +03002121 __wl1271_op_remove_interface(wl, true);
Juuso Oikarinen67353292010-11-18 15:19:02 +02002122 }
Juuso Oikarinen52b0e7a2010-09-21 06:23:31 +02002123
Juuso Oikarinen67353292010-11-18 15:19:02 +02002124 mutex_unlock(&wl->mutex);
Juuso Oikarinen52b0e7a2010-09-21 06:23:31 +02002125 cancel_work_sync(&wl->recovery_work);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002126}
2127
Juuso Oikarinen69e54342010-05-07 11:39:00 +03002128static int wl1271_join(struct wl1271 *wl, bool set_assoc)
Juuso Oikarinen82429d32010-04-28 09:50:01 +03002129{
2130 int ret;
Eliad Peller227e81e2011-08-14 13:17:26 +03002131 bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS);
Juuso Oikarinen82429d32010-04-28 09:50:01 +03002132
Juuso Oikarinen69e54342010-05-07 11:39:00 +03002133 /*
2134 * One of the side effects of the JOIN command is that is clears
2135 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
2136 * to a WPA/WPA2 access point will therefore kill the data-path.
Ohad Ben-Cohen8bf69aa2011-03-30 19:18:31 +02002137 * Currently the only valid scenario for JOIN during association
2138 * is on roaming, in which case we will also be given new keys.
2139 * Keep the below message for now, unless it starts bothering
2140 * users who really like to roam a lot :)
Juuso Oikarinen69e54342010-05-07 11:39:00 +03002141 */
2142 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2143 wl1271_info("JOIN while associated.");
2144
2145 if (set_assoc)
2146 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
2147
Eliad Peller227e81e2011-08-14 13:17:26 +03002148 if (is_ibss)
2149 ret = wl12xx_cmd_role_start_ibss(wl);
2150 else
2151 ret = wl12xx_cmd_role_start_sta(wl);
Juuso Oikarinen82429d32010-04-28 09:50:01 +03002152 if (ret < 0)
2153 goto out;
2154
Juuso Oikarinen82429d32010-04-28 09:50:01 +03002155 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2156 goto out;
2157
2158 /*
2159 * The join command disable the keep-alive mode, shut down its process,
2160 * and also clear the template config, so we need to reset it all after
2161 * the join. The acx_aid starts the keep-alive process, and the order
2162 * of the commands below is relevant.
2163 */
2164 ret = wl1271_acx_keep_alive_mode(wl, true);
2165 if (ret < 0)
2166 goto out;
2167
2168 ret = wl1271_acx_aid(wl, wl->aid);
2169 if (ret < 0)
2170 goto out;
2171
2172 ret = wl1271_cmd_build_klv_null_data(wl);
2173 if (ret < 0)
2174 goto out;
2175
2176 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
2177 ACX_KEEP_ALIVE_TPL_VALID);
2178 if (ret < 0)
2179 goto out;
2180
2181out:
2182 return ret;
2183}
2184
2185static int wl1271_unjoin(struct wl1271 *wl)
Luciano Coelhoc7f43e42009-12-11 15:40:44 +02002186{
2187 int ret;
2188
2189 /* to stop listening to a channel, we disconnect */
Eliad Pellerc690ec82011-08-14 13:17:07 +03002190 ret = wl12xx_cmd_role_stop_sta(wl);
Luciano Coelhoc7f43e42009-12-11 15:40:44 +02002191 if (ret < 0)
2192 goto out;
2193
Luciano Coelhoc7f43e42009-12-11 15:40:44 +02002194 memset(wl->bssid, 0, ETH_ALEN);
Juuso Oikarinen14b228a2010-03-18 12:26:43 +02002195
Oz Krakowskib992c682011-06-26 10:36:02 +03002196 /* reset TX security counters on a clean disconnect */
2197 wl->tx_security_last_seq_lsb = 0;
2198 wl->tx_security_seq = 0;
2199
Luciano Coelhoc7f43e42009-12-11 15:40:44 +02002200out:
2201 return ret;
2202}
2203
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03002204static void wl1271_set_band_rate(struct wl1271 *wl)
2205{
Eliad Peller53835a22011-08-23 15:56:23 +03002206 if (wl->band == IEEE80211_BAND_2GHZ) {
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03002207 wl->basic_rate_set = wl->conf.tx.basic_rate;
Eliad Peller53835a22011-08-23 15:56:23 +03002208 wl->rate_set = wl->conf.tx.basic_rate;
2209 } else {
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03002210 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
Eliad Peller53835a22011-08-23 15:56:23 +03002211 wl->rate_set = wl->conf.tx.basic_rate_5;
2212 }
2213
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03002214}
2215
Eliad Peller251c1772011-08-14 13:17:17 +03002216static bool wl12xx_is_roc(struct wl1271 *wl)
2217{
2218 u8 role_id;
2219
2220 role_id = find_first_bit(wl->roc_map, WL12XX_MAX_ROLES);
2221 if (role_id >= WL12XX_MAX_ROLES)
2222 return false;
2223
2224 return true;
2225}
2226
Arik Nemtsovbee0ffe2010-10-16 19:17:02 +02002227static int wl1271_sta_handle_idle(struct wl1271 *wl, bool idle)
Juuso Oikarinen0d58cbf2010-05-24 11:18:16 +03002228{
2229 int ret;
2230
2231 if (idle) {
Eliad Peller251c1772011-08-14 13:17:17 +03002232 /* no need to croc if we weren't busy (e.g. during boot) */
2233 if (wl12xx_is_roc(wl)) {
2234 ret = wl12xx_croc(wl, wl->dev_role_id);
2235 if (ret < 0)
2236 goto out;
2237
2238 ret = wl12xx_cmd_role_stop_dev(wl);
Juuso Oikarinen0d58cbf2010-05-24 11:18:16 +03002239 if (ret < 0)
2240 goto out;
2241 }
Arik Nemtsove0fe3712010-10-16 18:19:53 +02002242 wl->rate_set = wl1271_tx_min_rate_get(wl);
Arik Nemtsov79b223f2010-10-16 17:52:59 +02002243 ret = wl1271_acx_sta_rate_policies(wl);
Juuso Oikarinen0d58cbf2010-05-24 11:18:16 +03002244 if (ret < 0)
2245 goto out;
2246 ret = wl1271_acx_keep_alive_config(
2247 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
2248 ACX_KEEP_ALIVE_TPL_INVALID);
2249 if (ret < 0)
2250 goto out;
2251 set_bit(WL1271_FLAG_IDLE, &wl->flags);
2252 } else {
Luciano Coelho33c2c062011-05-10 14:46:02 +03002253 /* The current firmware only supports sched_scan in idle */
2254 if (wl->sched_scanning) {
2255 wl1271_scan_sched_scan_stop(wl);
2256 ieee80211_sched_scan_stopped(wl->hw);
2257 }
2258
Eliad Peller251c1772011-08-14 13:17:17 +03002259 ret = wl12xx_cmd_role_start_dev(wl);
2260 if (ret < 0)
2261 goto out;
2262
2263 ret = wl12xx_roc(wl, wl->dev_role_id);
Juuso Oikarinen0d58cbf2010-05-24 11:18:16 +03002264 if (ret < 0)
2265 goto out;
2266 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
2267 }
2268
2269out:
2270 return ret;
2271}
2272
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002273static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
2274{
2275 struct wl1271 *wl = hw->priv;
2276 struct ieee80211_conf *conf = &hw->conf;
2277 int channel, ret = 0;
Arik Nemtsovbee0ffe2010-10-16 19:17:02 +02002278 bool is_ap;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002279
2280 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
2281
Arik Nemtsovbee0ffe2010-10-16 19:17:02 +02002282 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s"
2283 " changed 0x%x",
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002284 channel,
2285 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
Luciano Coelhoc7f43e42009-12-11 15:40:44 +02002286 conf->power_level,
Arik Nemtsovbee0ffe2010-10-16 19:17:02 +02002287 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
2288 changed);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002289
Juuso Oikarinen781608c2010-05-24 11:18:17 +03002290 /*
2291 * mac80211 will go to idle nearly immediately after transmitting some
2292 * frames, such as the deauth. To make sure those frames reach the air,
2293 * wait here until the TX queue is fully flushed.
2294 */
2295 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
2296 (conf->flags & IEEE80211_CONF_IDLE))
2297 wl1271_tx_flush(wl);
2298
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002299 mutex_lock(&wl->mutex);
2300
Juuso Oikarinenf8d98022010-10-26 13:24:39 +02002301 if (unlikely(wl->state == WL1271_STATE_OFF)) {
Arik Nemtsov17e672d2011-03-22 10:07:47 +02002302 /* we support configuring the channel and band while off */
2303 if ((changed & IEEE80211_CONF_CHANGE_CHANNEL)) {
2304 wl->band = conf->channel->band;
2305 wl->channel = channel;
2306 }
2307
Arik Nemtsov097f8822011-06-27 22:06:34 +03002308 if ((changed & IEEE80211_CONF_CHANGE_POWER))
2309 wl->power_level = conf->power_level;
2310
Saravanan Dhanabal2c10bb92010-04-09 11:07:27 +03002311 goto out;
Juuso Oikarinenf8d98022010-10-26 13:24:39 +02002312 }
Juuso Oikarinen8a5a37a2009-10-08 21:56:24 +03002313
Arik Nemtsovbee0ffe2010-10-16 19:17:02 +02002314 is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2315
Ido Yariva6208652011-03-01 15:14:41 +02002316 ret = wl1271_ps_elp_wakeup(wl);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002317 if (ret < 0)
2318 goto out;
2319
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03002320 /* if the channel changes while joined, join again */
Juuso Oikarinen69e54342010-05-07 11:39:00 +03002321 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
2322 ((wl->band != conf->channel->band) ||
2323 (wl->channel != channel))) {
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03002324 wl->band = conf->channel->band;
2325 wl->channel = channel;
2326
Arik Nemtsovbee0ffe2010-10-16 19:17:02 +02002327 if (!is_ap) {
2328 /*
2329 * FIXME: the mac80211 should really provide a fixed
2330 * rate to use here. for now, just use the smallest
2331 * possible rate for the band as a fixed rate for
2332 * association frames and other control messages.
2333 */
2334 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2335 wl1271_set_band_rate(wl);
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03002336
Arik Nemtsovbee0ffe2010-10-16 19:17:02 +02002337 wl->basic_rate = wl1271_tx_min_rate_get(wl);
2338 ret = wl1271_acx_sta_rate_policies(wl);
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03002339 if (ret < 0)
Arik Nemtsovbee0ffe2010-10-16 19:17:02 +02002340 wl1271_warning("rate policy for channel "
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03002341 "failed %d", ret);
Arik Nemtsovbee0ffe2010-10-16 19:17:02 +02002342
Eliad Peller251c1772011-08-14 13:17:17 +03002343 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
2344 if (wl12xx_is_roc(wl)) {
2345 /* roaming */
2346 ret = wl12xx_croc(wl, wl->dev_role_id);
2347 if (ret < 0)
2348 goto out_sleep;
2349 }
Arik Nemtsovbee0ffe2010-10-16 19:17:02 +02002350 ret = wl1271_join(wl, false);
2351 if (ret < 0)
2352 wl1271_warning("cmd join on channel "
2353 "failed %d", ret);
Eliad Peller251c1772011-08-14 13:17:17 +03002354 } else {
2355 /*
2356 * change the ROC channel. do it only if we are
2357 * not idle. otherwise, CROC will be called
2358 * anyway.
2359 */
2360 if (wl12xx_is_roc(wl) &&
2361 !(conf->flags & IEEE80211_CONF_IDLE)) {
2362 ret = wl12xx_croc(wl, wl->dev_role_id);
2363 if (ret < 0)
2364 goto out_sleep;
2365
2366 ret = wl12xx_roc(wl, wl->dev_role_id);
2367 if (ret < 0)
2368 wl1271_warning("roc failed %d",
2369 ret);
2370 }
Arik Nemtsovbee0ffe2010-10-16 19:17:02 +02002371 }
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03002372 }
2373 }
2374
Arik Nemtsovbee0ffe2010-10-16 19:17:02 +02002375 if (changed & IEEE80211_CONF_CHANGE_IDLE && !is_ap) {
2376 ret = wl1271_sta_handle_idle(wl,
2377 conf->flags & IEEE80211_CONF_IDLE);
Juuso Oikarinen0d58cbf2010-05-24 11:18:16 +03002378 if (ret < 0)
2379 wl1271_warning("idle mode change failed %d", ret);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002380 }
2381
Juuso Oikarinen90494a92010-07-08 17:50:00 +03002382 /*
2383 * if mac80211 changes the PSM mode, make sure the mode is not
2384 * incorrectly changed after the pspoll failure active window.
2385 */
2386 if (changed & IEEE80211_CONF_CHANGE_PS)
2387 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
2388
Juuso Oikarinen71449f82009-12-11 15:41:07 +02002389 if (conf->flags & IEEE80211_CONF_PS &&
2390 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
2391 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002392
2393 /*
2394 * We enter PSM only if we're already associated.
2395 * If we're not, we'll enter it when joining an SSID,
2396 * through the bss_info_changed() hook.
2397 */
Juuso Oikarinen830fb672009-12-11 15:41:06 +02002398 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
Juuso Oikarinen18f8d462010-02-22 08:38:34 +02002399 wl1271_debug(DEBUG_PSM, "psm enabled");
Juuso Oikarinend8c42c02010-02-18 13:25:36 +02002400 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
Juuso Oikarinen8eab7b42010-09-24 03:10:11 +02002401 wl->basic_rate, true);
Juuso Oikarinenaf5e0842009-12-11 15:41:00 +02002402 }
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002403 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
Juuso Oikarinen71449f82009-12-11 15:41:07 +02002404 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
Juuso Oikarinen18f8d462010-02-22 08:38:34 +02002405 wl1271_debug(DEBUG_PSM, "psm disabled");
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002406
Juuso Oikarinen71449f82009-12-11 15:41:07 +02002407 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002408
Juuso Oikarinen71449f82009-12-11 15:41:07 +02002409 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
Juuso Oikarinend8c42c02010-02-18 13:25:36 +02002410 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
Juuso Oikarinen8eab7b42010-09-24 03:10:11 +02002411 wl->basic_rate, true);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002412 }
2413
2414 if (conf->power_level != wl->power_level) {
2415 ret = wl1271_acx_tx_power(wl, conf->power_level);
2416 if (ret < 0)
Juuso Oikarinenc6317a52009-11-02 20:22:08 +02002417 goto out_sleep;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002418
2419 wl->power_level = conf->power_level;
2420 }
2421
2422out_sleep:
2423 wl1271_ps_elp_sleep(wl);
2424
2425out:
2426 mutex_unlock(&wl->mutex);
2427
2428 return ret;
2429}
2430
Juuso Oikarinenb54853f2009-10-13 12:47:59 +03002431struct wl1271_filter_params {
2432 bool enabled;
2433 int mc_list_length;
2434 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
2435};
2436
Jiri Pirko22bedad2010-04-01 21:22:57 +00002437static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
2438 struct netdev_hw_addr_list *mc_list)
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03002439{
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03002440 struct wl1271_filter_params *fp;
Jiri Pirko22bedad2010-04-01 21:22:57 +00002441 struct netdev_hw_addr *ha;
Saravanan Dhanabal2c10bb92010-04-09 11:07:27 +03002442 struct wl1271 *wl = hw->priv;
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03002443
Saravanan Dhanabal2c10bb92010-04-09 11:07:27 +03002444 if (unlikely(wl->state == WL1271_STATE_OFF))
2445 return 0;
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03002446
Juuso Oikarinen74441132009-10-13 12:47:53 +03002447 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03002448 if (!fp) {
2449 wl1271_error("Out of memory setting filters.");
2450 return 0;
2451 }
2452
2453 /* update multicast filtering parameters */
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03002454 fp->mc_list_length = 0;
Jiri Pirko22bedad2010-04-01 21:22:57 +00002455 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
2456 fp->enabled = false;
2457 } else {
2458 fp->enabled = true;
2459 netdev_hw_addr_list_for_each(ha, mc_list) {
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03002460 memcpy(fp->mc_list[fp->mc_list_length],
Jiri Pirko22bedad2010-04-01 21:22:57 +00002461 ha->addr, ETH_ALEN);
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03002462 fp->mc_list_length++;
Jiri Pirko22bedad2010-04-01 21:22:57 +00002463 }
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03002464 }
2465
Juuso Oikarinenb54853f2009-10-13 12:47:59 +03002466 return (u64)(unsigned long)fp;
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03002467}
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002468
Juuso Oikarinenb54853f2009-10-13 12:47:59 +03002469#define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
2470 FIF_ALLMULTI | \
2471 FIF_FCSFAIL | \
2472 FIF_BCN_PRBRESP_PROMISC | \
2473 FIF_CONTROL | \
2474 FIF_OTHER_BSS)
2475
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002476static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
2477 unsigned int changed,
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03002478 unsigned int *total, u64 multicast)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002479{
Juuso Oikarinenb54853f2009-10-13 12:47:59 +03002480 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002481 struct wl1271 *wl = hw->priv;
Juuso Oikarinenb54853f2009-10-13 12:47:59 +03002482 int ret;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002483
Arik Nemtsov7d057862010-10-16 19:25:35 +02002484 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
2485 " total %x", changed, *total);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002486
Juuso Oikarinenb54853f2009-10-13 12:47:59 +03002487 mutex_lock(&wl->mutex);
2488
Saravanan Dhanabal2c10bb92010-04-09 11:07:27 +03002489 *total &= WL1271_SUPPORTED_FILTERS;
2490 changed &= WL1271_SUPPORTED_FILTERS;
2491
2492 if (unlikely(wl->state == WL1271_STATE_OFF))
Juuso Oikarinenb54853f2009-10-13 12:47:59 +03002493 goto out;
2494
Ido Yariva6208652011-03-01 15:14:41 +02002495 ret = wl1271_ps_elp_wakeup(wl);
Juuso Oikarinenb54853f2009-10-13 12:47:59 +03002496 if (ret < 0)
2497 goto out;
2498
Arik Nemtsov7d057862010-10-16 19:25:35 +02002499 if (wl->bss_type != BSS_TYPE_AP_BSS) {
2500 if (*total & FIF_ALLMULTI)
2501 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
2502 else if (fp)
2503 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
2504 fp->mc_list,
2505 fp->mc_list_length);
2506 if (ret < 0)
2507 goto out_sleep;
2508 }
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002509
Eliad Peller08c1d1c2011-08-14 13:17:04 +03002510 /*
2511 * the fw doesn't provide an api to configure the filters. instead,
2512 * the filters configuration is based on the active roles / ROC
2513 * state.
2514 */
Juuso Oikarinenb54853f2009-10-13 12:47:59 +03002515
2516out_sleep:
2517 wl1271_ps_elp_sleep(wl);
2518
2519out:
2520 mutex_unlock(&wl->mutex);
Juuso Oikarinen14b228a2010-03-18 12:26:43 +02002521 kfree(fp);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002522}
2523
Arik Nemtsov7f179b42010-10-16 21:39:06 +02002524static int wl1271_record_ap_key(struct wl1271 *wl, u8 id, u8 key_type,
2525 u8 key_size, const u8 *key, u8 hlid, u32 tx_seq_32,
2526 u16 tx_seq_16)
2527{
2528 struct wl1271_ap_key *ap_key;
2529 int i;
2530
2531 wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);
2532
2533 if (key_size > MAX_KEY_SIZE)
2534 return -EINVAL;
2535
2536 /*
2537 * Find next free entry in ap_keys. Also check we are not replacing
2538 * an existing key.
2539 */
2540 for (i = 0; i < MAX_NUM_KEYS; i++) {
2541 if (wl->recorded_ap_keys[i] == NULL)
2542 break;
2543
2544 if (wl->recorded_ap_keys[i]->id == id) {
2545 wl1271_warning("trying to record key replacement");
2546 return -EINVAL;
2547 }
2548 }
2549
2550 if (i == MAX_NUM_KEYS)
2551 return -EBUSY;
2552
2553 ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
2554 if (!ap_key)
2555 return -ENOMEM;
2556
2557 ap_key->id = id;
2558 ap_key->key_type = key_type;
2559 ap_key->key_size = key_size;
2560 memcpy(ap_key->key, key, key_size);
2561 ap_key->hlid = hlid;
2562 ap_key->tx_seq_32 = tx_seq_32;
2563 ap_key->tx_seq_16 = tx_seq_16;
2564
2565 wl->recorded_ap_keys[i] = ap_key;
2566 return 0;
2567}
2568
2569static void wl1271_free_ap_keys(struct wl1271 *wl)
2570{
2571 int i;
2572
2573 for (i = 0; i < MAX_NUM_KEYS; i++) {
2574 kfree(wl->recorded_ap_keys[i]);
2575 wl->recorded_ap_keys[i] = NULL;
2576 }
2577}
2578
2579static int wl1271_ap_init_hwenc(struct wl1271 *wl)
2580{
2581 int i, ret = 0;
2582 struct wl1271_ap_key *key;
2583 bool wep_key_added = false;
2584
2585 for (i = 0; i < MAX_NUM_KEYS; i++) {
Eliad Peller7f97b482011-08-14 13:17:30 +03002586 u8 hlid;
Arik Nemtsov7f179b42010-10-16 21:39:06 +02002587 if (wl->recorded_ap_keys[i] == NULL)
2588 break;
2589
2590 key = wl->recorded_ap_keys[i];
Eliad Peller7f97b482011-08-14 13:17:30 +03002591 hlid = key->hlid;
2592 if (hlid == WL12XX_INVALID_LINK_ID)
2593 hlid = wl->ap_bcast_hlid;
2594
Arik Nemtsov7f179b42010-10-16 21:39:06 +02002595 ret = wl1271_cmd_set_ap_key(wl, KEY_ADD_OR_REPLACE,
2596 key->id, key->key_type,
2597 key->key_size, key->key,
Eliad Peller7f97b482011-08-14 13:17:30 +03002598 hlid, key->tx_seq_32,
Arik Nemtsov7f179b42010-10-16 21:39:06 +02002599 key->tx_seq_16);
2600 if (ret < 0)
2601 goto out;
2602
2603 if (key->key_type == KEY_WEP)
2604 wep_key_added = true;
2605 }
2606
2607 if (wep_key_added) {
Eliad Pellerc690ec82011-08-14 13:17:07 +03002608 ret = wl12xx_cmd_set_default_wep_key(wl, wl->default_key,
Arik Nemtsove51ae9b2011-08-14 13:17:21 +03002609 wl->ap_bcast_hlid);
Arik Nemtsov7f179b42010-10-16 21:39:06 +02002610 if (ret < 0)
2611 goto out;
2612 }
2613
2614out:
2615 wl1271_free_ap_keys(wl);
2616 return ret;
2617}
2618
2619static int wl1271_set_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
2620 u8 key_size, const u8 *key, u32 tx_seq_32,
2621 u16 tx_seq_16, struct ieee80211_sta *sta)
2622{
2623 int ret;
2624 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2625
2626 if (is_ap) {
2627 struct wl1271_station *wl_sta;
2628 u8 hlid;
2629
2630 if (sta) {
2631 wl_sta = (struct wl1271_station *)sta->drv_priv;
2632 hlid = wl_sta->hlid;
2633 } else {
Arik Nemtsove51ae9b2011-08-14 13:17:21 +03002634 hlid = wl->ap_bcast_hlid;
Arik Nemtsov7f179b42010-10-16 21:39:06 +02002635 }
2636
2637 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2638 /*
2639 * We do not support removing keys after AP shutdown.
2640 * Pretend we do to make mac80211 happy.
2641 */
2642 if (action != KEY_ADD_OR_REPLACE)
2643 return 0;
2644
2645 ret = wl1271_record_ap_key(wl, id,
2646 key_type, key_size,
2647 key, hlid, tx_seq_32,
2648 tx_seq_16);
2649 } else {
2650 ret = wl1271_cmd_set_ap_key(wl, action,
2651 id, key_type, key_size,
2652 key, hlid, tx_seq_32,
2653 tx_seq_16);
2654 }
2655
2656 if (ret < 0)
2657 return ret;
2658 } else {
2659 const u8 *addr;
2660 static const u8 bcast_addr[ETH_ALEN] = {
2661 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2662 };
2663
Guy Eilame9eb8cb2011-08-16 19:49:12 +03002664 /*
2665 * A STA set to GEM cipher requires 2 tx spare blocks.
2666 * Return to default value when GEM cipher key is removed
2667 */
2668 if (key_type == KEY_GEM) {
2669 if (action == KEY_ADD_OR_REPLACE)
2670 wl->tx_spare_blocks = 2;
2671 else if (action == KEY_REMOVE)
2672 wl->tx_spare_blocks = TX_HW_BLOCK_SPARE_DEFAULT;
2673 }
2674
Arik Nemtsov7f179b42010-10-16 21:39:06 +02002675 addr = sta ? sta->addr : bcast_addr;
2676
2677 if (is_zero_ether_addr(addr)) {
2678 /* We dont support TX only encryption */
2679 return -EOPNOTSUPP;
2680 }
2681
2682 /* The wl1271 does not allow to remove unicast keys - they
2683 will be cleared automatically on next CMD_JOIN. Ignore the
2684 request silently, as we dont want the mac80211 to emit
2685 an error message. */
2686 if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
2687 return 0;
2688
Eliad Peller010d3d32011-08-14 13:17:31 +03002689 /* don't remove key if hlid was already deleted */
2690 if (action == KEY_REMOVE &&
2691 wl->sta_hlid == WL12XX_INVALID_LINK_ID)
2692 return 0;
2693
Arik Nemtsov7f179b42010-10-16 21:39:06 +02002694 ret = wl1271_cmd_set_sta_key(wl, action,
2695 id, key_type, key_size,
2696 key, addr, tx_seq_32,
2697 tx_seq_16);
2698 if (ret < 0)
2699 return ret;
2700
2701 /* the default WEP key needs to be configured at least once */
2702 if (key_type == KEY_WEP) {
Eliad Pellerc690ec82011-08-14 13:17:07 +03002703 ret = wl12xx_cmd_set_default_wep_key(wl,
2704 wl->default_key,
2705 wl->sta_hlid);
Arik Nemtsov7f179b42010-10-16 21:39:06 +02002706 if (ret < 0)
2707 return ret;
2708 }
2709 }
2710
2711 return 0;
2712}
2713
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002714static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
2715 struct ieee80211_vif *vif,
2716 struct ieee80211_sta *sta,
2717 struct ieee80211_key_conf *key_conf)
2718{
2719 struct wl1271 *wl = hw->priv;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002720 int ret;
Juuso Oikarinenac4e4ce2009-10-08 21:56:19 +03002721 u32 tx_seq_32 = 0;
2722 u16 tx_seq_16 = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002723 u8 key_type;
2724
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002725 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
2726
Arik Nemtsov7f179b42010-10-16 21:39:06 +02002727 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002728 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
Johannes Berg97359d12010-08-10 09:46:38 +02002729 key_conf->cipher, key_conf->keyidx,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002730 key_conf->keylen, key_conf->flags);
2731 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
2732
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002733 mutex_lock(&wl->mutex);
2734
Juuso Oikarinenf8d98022010-10-26 13:24:39 +02002735 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2736 ret = -EAGAIN;
2737 goto out_unlock;
2738 }
2739
Ido Yariva6208652011-03-01 15:14:41 +02002740 ret = wl1271_ps_elp_wakeup(wl);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002741 if (ret < 0)
2742 goto out_unlock;
2743
Johannes Berg97359d12010-08-10 09:46:38 +02002744 switch (key_conf->cipher) {
2745 case WLAN_CIPHER_SUITE_WEP40:
2746 case WLAN_CIPHER_SUITE_WEP104:
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002747 key_type = KEY_WEP;
2748
2749 key_conf->hw_key_idx = key_conf->keyidx;
2750 break;
Johannes Berg97359d12010-08-10 09:46:38 +02002751 case WLAN_CIPHER_SUITE_TKIP:
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002752 key_type = KEY_TKIP;
2753
2754 key_conf->hw_key_idx = key_conf->keyidx;
Juuso Oikarinen04e36fc2010-02-22 08:38:40 +02002755 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2756 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002757 break;
Johannes Berg97359d12010-08-10 09:46:38 +02002758 case WLAN_CIPHER_SUITE_CCMP:
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002759 key_type = KEY_AES;
2760
2761 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
Juuso Oikarinen04e36fc2010-02-22 08:38:40 +02002762 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2763 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002764 break;
Juuso Oikarinen7a557242010-09-27 12:42:07 +02002765 case WL1271_CIPHER_SUITE_GEM:
2766 key_type = KEY_GEM;
2767 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2768 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2769 break;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002770 default:
Johannes Berg97359d12010-08-10 09:46:38 +02002771 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002772
2773 ret = -EOPNOTSUPP;
2774 goto out_sleep;
2775 }
2776
2777 switch (cmd) {
2778 case SET_KEY:
Arik Nemtsov7f179b42010-10-16 21:39:06 +02002779 ret = wl1271_set_key(wl, KEY_ADD_OR_REPLACE,
2780 key_conf->keyidx, key_type,
2781 key_conf->keylen, key_conf->key,
2782 tx_seq_32, tx_seq_16, sta);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002783 if (ret < 0) {
2784 wl1271_error("Could not add or replace key");
2785 goto out_sleep;
2786 }
2787 break;
2788
2789 case DISABLE_KEY:
Arik Nemtsov7f179b42010-10-16 21:39:06 +02002790 ret = wl1271_set_key(wl, KEY_REMOVE,
2791 key_conf->keyidx, key_type,
2792 key_conf->keylen, key_conf->key,
2793 0, 0, sta);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002794 if (ret < 0) {
2795 wl1271_error("Could not remove key");
2796 goto out_sleep;
2797 }
2798 break;
2799
2800 default:
2801 wl1271_error("Unsupported key cmd 0x%x", cmd);
2802 ret = -EOPNOTSUPP;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002803 break;
2804 }
2805
2806out_sleep:
2807 wl1271_ps_elp_sleep(wl);
2808
2809out_unlock:
2810 mutex_unlock(&wl->mutex);
2811
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002812 return ret;
2813}
2814
2815static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
Johannes Berga060bbf2010-04-27 11:59:34 +02002816 struct ieee80211_vif *vif,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002817 struct cfg80211_scan_request *req)
2818{
2819 struct wl1271 *wl = hw->priv;
2820 int ret;
2821 u8 *ssid = NULL;
Teemu Paasikiviabb0b3b2009-10-13 12:47:50 +03002822 size_t len = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002823
2824 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
2825
2826 if (req->n_ssids) {
2827 ssid = req->ssids[0].ssid;
Teemu Paasikiviabb0b3b2009-10-13 12:47:50 +03002828 len = req->ssids[0].ssid_len;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002829 }
2830
2831 mutex_lock(&wl->mutex);
2832
Juuso Oikarinenb739a422010-10-26 13:24:38 +02002833 if (wl->state == WL1271_STATE_OFF) {
2834 /*
2835 * We cannot return -EBUSY here because cfg80211 will expect
2836 * a call to ieee80211_scan_completed if we do - in this case
2837 * there won't be any call.
2838 */
2839 ret = -EAGAIN;
2840 goto out;
2841 }
2842
Ido Yariva6208652011-03-01 15:14:41 +02002843 ret = wl1271_ps_elp_wakeup(wl);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002844 if (ret < 0)
2845 goto out;
2846
Eliad Peller251c1772011-08-14 13:17:17 +03002847 /* cancel ROC before scanning */
2848 if (wl12xx_is_roc(wl)) {
2849 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
2850 /* don't allow scanning right now */
2851 ret = -EBUSY;
2852 goto out_sleep;
2853 }
2854 wl12xx_croc(wl, wl->dev_role_id);
2855 wl12xx_cmd_role_stop_dev(wl);
2856 }
2857
Luciano Coelho5924f892010-08-04 03:46:22 +03002858 ret = wl1271_scan(hw->priv, ssid, len, req);
Eliad Peller251c1772011-08-14 13:17:17 +03002859out_sleep:
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002860 wl1271_ps_elp_sleep(wl);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002861out:
2862 mutex_unlock(&wl->mutex);
2863
2864 return ret;
2865}
2866
Eliad Peller73ecce32011-06-27 13:06:45 +03002867static void wl1271_op_cancel_hw_scan(struct ieee80211_hw *hw,
2868 struct ieee80211_vif *vif)
2869{
2870 struct wl1271 *wl = hw->priv;
2871 int ret;
2872
2873 wl1271_debug(DEBUG_MAC80211, "mac80211 cancel hw scan");
2874
2875 mutex_lock(&wl->mutex);
2876
2877 if (wl->state == WL1271_STATE_OFF)
2878 goto out;
2879
2880 if (wl->scan.state == WL1271_SCAN_STATE_IDLE)
2881 goto out;
2882
2883 ret = wl1271_ps_elp_wakeup(wl);
2884 if (ret < 0)
2885 goto out;
2886
2887 if (wl->scan.state != WL1271_SCAN_STATE_DONE) {
2888 ret = wl1271_scan_stop(wl);
2889 if (ret < 0)
2890 goto out_sleep;
2891 }
2892 wl->scan.state = WL1271_SCAN_STATE_IDLE;
2893 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
2894 wl->scan.req = NULL;
2895 ieee80211_scan_completed(wl->hw, true);
2896
2897out_sleep:
2898 wl1271_ps_elp_sleep(wl);
2899out:
2900 mutex_unlock(&wl->mutex);
2901
2902 cancel_delayed_work_sync(&wl->scan_complete_work);
2903}
2904
Luciano Coelho33c2c062011-05-10 14:46:02 +03002905static int wl1271_op_sched_scan_start(struct ieee80211_hw *hw,
2906 struct ieee80211_vif *vif,
2907 struct cfg80211_sched_scan_request *req,
2908 struct ieee80211_sched_scan_ies *ies)
2909{
2910 struct wl1271 *wl = hw->priv;
2911 int ret;
2912
2913 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_start");
2914
2915 mutex_lock(&wl->mutex);
2916
2917 ret = wl1271_ps_elp_wakeup(wl);
2918 if (ret < 0)
2919 goto out;
2920
2921 ret = wl1271_scan_sched_scan_config(wl, req, ies);
2922 if (ret < 0)
2923 goto out_sleep;
2924
2925 ret = wl1271_scan_sched_scan_start(wl);
2926 if (ret < 0)
2927 goto out_sleep;
2928
2929 wl->sched_scanning = true;
2930
2931out_sleep:
2932 wl1271_ps_elp_sleep(wl);
2933out:
2934 mutex_unlock(&wl->mutex);
2935 return ret;
2936}
2937
2938static void wl1271_op_sched_scan_stop(struct ieee80211_hw *hw,
2939 struct ieee80211_vif *vif)
2940{
2941 struct wl1271 *wl = hw->priv;
2942 int ret;
2943
2944 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_stop");
2945
2946 mutex_lock(&wl->mutex);
2947
2948 ret = wl1271_ps_elp_wakeup(wl);
2949 if (ret < 0)
2950 goto out;
2951
2952 wl1271_scan_sched_scan_stop(wl);
2953
2954 wl1271_ps_elp_sleep(wl);
2955out:
2956 mutex_unlock(&wl->mutex);
2957}
2958
Arik Nemtsov68d069c2010-11-08 10:51:07 +01002959static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
2960{
2961 struct wl1271 *wl = hw->priv;
2962 int ret = 0;
2963
2964 mutex_lock(&wl->mutex);
2965
2966 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2967 ret = -EAGAIN;
2968 goto out;
2969 }
2970
Ido Yariva6208652011-03-01 15:14:41 +02002971 ret = wl1271_ps_elp_wakeup(wl);
Arik Nemtsov68d069c2010-11-08 10:51:07 +01002972 if (ret < 0)
2973 goto out;
2974
Arik Nemtsov5f704d12011-04-18 14:15:21 +03002975 ret = wl1271_acx_frag_threshold(wl, value);
Arik Nemtsov68d069c2010-11-08 10:51:07 +01002976 if (ret < 0)
2977 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
2978
2979 wl1271_ps_elp_sleep(wl);
2980
2981out:
2982 mutex_unlock(&wl->mutex);
2983
2984 return ret;
2985}
2986
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002987static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
2988{
2989 struct wl1271 *wl = hw->priv;
Saravanan Dhanabalaecb0562010-04-09 11:07:28 +03002990 int ret = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002991
2992 mutex_lock(&wl->mutex);
2993
Juuso Oikarinenf8d98022010-10-26 13:24:39 +02002994 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2995 ret = -EAGAIN;
Saravanan Dhanabalaecb0562010-04-09 11:07:28 +03002996 goto out;
Juuso Oikarinenf8d98022010-10-26 13:24:39 +02002997 }
Saravanan Dhanabalaecb0562010-04-09 11:07:28 +03002998
Ido Yariva6208652011-03-01 15:14:41 +02002999 ret = wl1271_ps_elp_wakeup(wl);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003000 if (ret < 0)
3001 goto out;
3002
Arik Nemtsov5f704d12011-04-18 14:15:21 +03003003 ret = wl1271_acx_rts_threshold(wl, value);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003004 if (ret < 0)
3005 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
3006
3007 wl1271_ps_elp_sleep(wl);
3008
3009out:
3010 mutex_unlock(&wl->mutex);
3011
3012 return ret;
3013}
3014
Arik Nemtsove78a2872010-10-16 19:07:21 +02003015static int wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *skb,
Juuso Oikarinen2f6724b2010-11-24 08:16:57 +02003016 int offset)
Juuso Oikarinen30240fc2010-02-18 13:25:38 +02003017{
Eliad Peller889cb362011-05-01 09:56:45 +03003018 u8 ssid_len;
3019 const u8 *ptr = cfg80211_find_ie(WLAN_EID_SSID, skb->data + offset,
3020 skb->len - offset);
Juuso Oikarinen30240fc2010-02-18 13:25:38 +02003021
Eliad Peller889cb362011-05-01 09:56:45 +03003022 if (!ptr) {
3023 wl1271_error("No SSID in IEs!");
3024 return -ENOENT;
Juuso Oikarinen30240fc2010-02-18 13:25:38 +02003025 }
Arik Nemtsove78a2872010-10-16 19:07:21 +02003026
Eliad Peller889cb362011-05-01 09:56:45 +03003027 ssid_len = ptr[1];
3028 if (ssid_len > IEEE80211_MAX_SSID_LEN) {
3029 wl1271_error("SSID is too long!");
3030 return -EINVAL;
3031 }
3032
3033 wl->ssid_len = ssid_len;
3034 memcpy(wl->ssid, ptr+2, ssid_len);
3035 return 0;
Juuso Oikarinen30240fc2010-02-18 13:25:38 +02003036}
3037
Arik Nemtsove78a2872010-10-16 19:07:21 +02003038static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
3039 struct ieee80211_bss_conf *bss_conf,
3040 u32 changed)
3041{
3042 int ret = 0;
3043
3044 if (changed & BSS_CHANGED_ERP_SLOT) {
3045 if (bss_conf->use_short_slot)
3046 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
3047 else
3048 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
3049 if (ret < 0) {
3050 wl1271_warning("Set slot time failed %d", ret);
3051 goto out;
3052 }
3053 }
3054
3055 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
3056 if (bss_conf->use_short_preamble)
3057 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
3058 else
3059 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
3060 }
3061
3062 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
3063 if (bss_conf->use_cts_prot)
3064 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
3065 else
3066 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
3067 if (ret < 0) {
3068 wl1271_warning("Set ctsprotect failed %d", ret);
3069 goto out;
3070 }
3071 }
3072
3073out:
3074 return ret;
3075}
3076
3077static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
3078 struct ieee80211_vif *vif,
3079 struct ieee80211_bss_conf *bss_conf,
3080 u32 changed)
3081{
3082 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
3083 int ret = 0;
3084
3085 if ((changed & BSS_CHANGED_BEACON_INT)) {
3086 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
3087 bss_conf->beacon_int);
3088
3089 wl->beacon_int = bss_conf->beacon_int;
3090 }
3091
3092 if ((changed & BSS_CHANGED_BEACON)) {
3093 struct ieee80211_hdr *hdr;
3094 int ieoffset = offsetof(struct ieee80211_mgmt,
3095 u.beacon.variable);
3096 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
3097 u16 tmpl_id;
3098
3099 if (!beacon)
3100 goto out;
3101
3102 wl1271_debug(DEBUG_MASTER, "beacon updated");
3103
3104 ret = wl1271_ssid_set(wl, beacon, ieoffset);
3105 if (ret < 0) {
3106 dev_kfree_skb(beacon);
3107 goto out;
3108 }
3109 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
3110 CMD_TEMPL_BEACON;
3111 ret = wl1271_cmd_template_set(wl, tmpl_id,
3112 beacon->data,
3113 beacon->len, 0,
3114 wl1271_tx_min_rate_get(wl));
3115 if (ret < 0) {
3116 dev_kfree_skb(beacon);
3117 goto out;
3118 }
3119
3120 hdr = (struct ieee80211_hdr *) beacon->data;
3121 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
3122 IEEE80211_STYPE_PROBE_RESP);
3123
3124 tmpl_id = is_ap ? CMD_TEMPL_AP_PROBE_RESPONSE :
3125 CMD_TEMPL_PROBE_RESPONSE;
3126 ret = wl1271_cmd_template_set(wl,
3127 tmpl_id,
3128 beacon->data,
3129 beacon->len, 0,
3130 wl1271_tx_min_rate_get(wl));
3131 dev_kfree_skb(beacon);
3132 if (ret < 0)
3133 goto out;
3134 }
3135
3136out:
3137 return ret;
3138}
3139
3140/* AP mode changes */
3141static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003142 struct ieee80211_vif *vif,
3143 struct ieee80211_bss_conf *bss_conf,
3144 u32 changed)
3145{
Arik Nemtsove78a2872010-10-16 19:07:21 +02003146 int ret = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003147
Arik Nemtsove78a2872010-10-16 19:07:21 +02003148 if ((changed & BSS_CHANGED_BASIC_RATES)) {
3149 u32 rates = bss_conf->basic_rates;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003150
Arik Nemtsove78a2872010-10-16 19:07:21 +02003151 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates);
3152 wl->basic_rate = wl1271_tx_min_rate_get(wl);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003153
Arik Nemtsov70f47422011-04-18 14:15:25 +03003154 ret = wl1271_init_ap_rates(wl);
Arik Nemtsove78a2872010-10-16 19:07:21 +02003155 if (ret < 0) {
Arik Nemtsov70f47422011-04-18 14:15:25 +03003156 wl1271_error("AP rate policy change failed %d", ret);
Arik Nemtsove78a2872010-10-16 19:07:21 +02003157 goto out;
Juuso Oikarinene0d8bbf2009-12-11 15:41:04 +02003158 }
Arik Nemtsovc45a85b2011-04-18 14:15:26 +03003159
3160 ret = wl1271_ap_init_templates(wl);
3161 if (ret < 0)
3162 goto out;
Juuso Oikarinene0d8bbf2009-12-11 15:41:04 +02003163 }
3164
Arik Nemtsove78a2872010-10-16 19:07:21 +02003165 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
3166 if (ret < 0)
3167 goto out;
3168
3169 if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
3170 if (bss_conf->enable_beacon) {
3171 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
Eliad Pellerc690ec82011-08-14 13:17:07 +03003172 ret = wl12xx_cmd_role_start_ap(wl);
Arik Nemtsove78a2872010-10-16 19:07:21 +02003173 if (ret < 0)
3174 goto out;
3175
Arik Nemtsov7f179b42010-10-16 21:39:06 +02003176 ret = wl1271_ap_init_hwenc(wl);
3177 if (ret < 0)
3178 goto out;
Arik Nemtsovcf420392011-08-14 13:17:37 +03003179
3180 set_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
3181 wl1271_debug(DEBUG_AP, "started AP");
Arik Nemtsove78a2872010-10-16 19:07:21 +02003182 }
3183 } else {
3184 if (test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
Eliad Pellerc690ec82011-08-14 13:17:07 +03003185 ret = wl12xx_cmd_role_stop_ap(wl);
Arik Nemtsove78a2872010-10-16 19:07:21 +02003186 if (ret < 0)
3187 goto out;
3188
3189 clear_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
3190 wl1271_debug(DEBUG_AP, "stopped AP");
3191 }
3192 }
3193 }
3194
3195 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
3196 if (ret < 0)
3197 goto out;
Arik Nemtsov0b932ab2011-08-14 13:17:27 +03003198
3199 /* Handle HT information change */
3200 if ((changed & BSS_CHANGED_HT) &&
3201 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
3202 ret = wl1271_acx_set_ht_information(wl,
3203 bss_conf->ht_operation_mode);
3204 if (ret < 0) {
3205 wl1271_warning("Set ht information failed %d", ret);
3206 goto out;
3207 }
3208 }
3209
Arik Nemtsove78a2872010-10-16 19:07:21 +02003210out:
3211 return;
3212}
3213
3214/* STA/IBSS mode changes */
3215static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
3216 struct ieee80211_vif *vif,
3217 struct ieee80211_bss_conf *bss_conf,
3218 u32 changed)
3219{
3220 bool do_join = false, set_assoc = false;
3221 bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS);
Eliad Peller227e81e2011-08-14 13:17:26 +03003222 bool ibss_joined = false;
Eliad Peller72c2d9e2011-02-02 09:59:37 +02003223 u32 sta_rate_set = 0;
Arik Nemtsove78a2872010-10-16 19:07:21 +02003224 int ret;
Luciano Coelho2d6e4e762011-01-11 19:07:21 +01003225 struct ieee80211_sta *sta;
Arik Nemtsova1008852011-02-12 23:24:20 +02003226 bool sta_exists = false;
3227 struct ieee80211_sta_ht_cap sta_ht_cap;
Arik Nemtsove78a2872010-10-16 19:07:21 +02003228
3229 if (is_ibss) {
3230 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
3231 changed);
3232 if (ret < 0)
3233 goto out;
3234 }
3235
Eliad Peller227e81e2011-08-14 13:17:26 +03003236 if (changed & BSS_CHANGED_IBSS) {
3237 if (bss_conf->ibss_joined) {
3238 set_bit(WL1271_FLAG_IBSS_JOINED, &wl->flags);
3239 ibss_joined = true;
3240 } else {
3241 if (test_and_clear_bit(WL1271_FLAG_IBSS_JOINED,
3242 &wl->flags)) {
3243 wl1271_unjoin(wl);
3244 wl12xx_cmd_role_start_dev(wl);
3245 wl12xx_roc(wl, wl->dev_role_id);
3246 }
3247 }
3248 }
3249
3250 if ((changed & BSS_CHANGED_BEACON_INT) && ibss_joined)
Arik Nemtsove78a2872010-10-16 19:07:21 +02003251 do_join = true;
3252
3253 /* Need to update the SSID (for filtering etc) */
Eliad Peller227e81e2011-08-14 13:17:26 +03003254 if ((changed & BSS_CHANGED_BEACON) && ibss_joined)
Arik Nemtsove78a2872010-10-16 19:07:21 +02003255 do_join = true;
3256
Eliad Peller227e81e2011-08-14 13:17:26 +03003257 if ((changed & BSS_CHANGED_BEACON_ENABLED) && ibss_joined) {
Juuso Oikarinen5da11dc2010-03-26 12:53:24 +02003258 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
3259 bss_conf->enable_beacon ? "enabled" : "disabled");
3260
3261 if (bss_conf->enable_beacon)
3262 wl->set_bss_type = BSS_TYPE_IBSS;
3263 else
3264 wl->set_bss_type = BSS_TYPE_STA_BSS;
3265 do_join = true;
3266 }
3267
Arik Nemtsove78a2872010-10-16 19:07:21 +02003268 if ((changed & BSS_CHANGED_CQM)) {
Juuso Oikarinen00236aed2010-04-09 11:07:30 +03003269 bool enable = false;
3270 if (bss_conf->cqm_rssi_thold)
3271 enable = true;
3272 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
3273 bss_conf->cqm_rssi_thold,
3274 bss_conf->cqm_rssi_hyst);
3275 if (ret < 0)
3276 goto out;
3277 wl->rssi_thold = bss_conf->cqm_rssi_thold;
3278 }
3279
Juuso Oikarinen30240fc2010-02-18 13:25:38 +02003280 if ((changed & BSS_CHANGED_BSSID) &&
3281 /*
3282 * Now we know the correct bssid, so we send a new join command
3283 * and enable the BSSID filter
3284 */
3285 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
Arik Nemtsove78a2872010-10-16 19:07:21 +02003286 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
Juuso Oikarinena0cb7be2010-03-18 12:26:44 +02003287
Eliad Pellerfa287b82010-12-26 09:27:50 +01003288 if (!is_zero_ether_addr(wl->bssid)) {
3289 ret = wl1271_cmd_build_null_data(wl);
3290 if (ret < 0)
3291 goto out;
Juuso Oikarinen30240fc2010-02-18 13:25:38 +02003292
Eliad Pellerfa287b82010-12-26 09:27:50 +01003293 ret = wl1271_build_qos_null_data(wl);
3294 if (ret < 0)
3295 goto out;
Saravanan Dhanabal141418c2010-04-28 09:50:00 +03003296
Eliad Pellerfa287b82010-12-26 09:27:50 +01003297 /* Need to update the BSSID (for filtering etc) */
3298 do_join = true;
3299 }
Juuso Oikarinen30240fc2010-02-18 13:25:38 +02003300 }
3301
Arik Nemtsov0f9c8252011-08-17 10:45:49 +03003302 if (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_HT)) {
3303 rcu_read_lock();
3304 sta = ieee80211_find_sta(vif, bss_conf->bssid);
3305 if (!sta)
3306 goto sta_not_found;
3307
Eliad Peller72c2d9e2011-02-02 09:59:37 +02003308 /* save the supp_rates of the ap */
3309 sta_rate_set = sta->supp_rates[wl->hw->conf.channel->band];
3310 if (sta->ht_cap.ht_supported)
3311 sta_rate_set |=
3312 (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
Arik Nemtsova1008852011-02-12 23:24:20 +02003313 sta_ht_cap = sta->ht_cap;
3314 sta_exists = true;
Eliad Peller72c2d9e2011-02-02 09:59:37 +02003315
Arik Nemtsov0f9c8252011-08-17 10:45:49 +03003316sta_not_found:
3317 rcu_read_unlock();
Eliad Peller72c2d9e2011-02-02 09:59:37 +02003318 }
Eliad Peller72c2d9e2011-02-02 09:59:37 +02003319
Arik Nemtsove78a2872010-10-16 19:07:21 +02003320 if ((changed & BSS_CHANGED_ASSOC)) {
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003321 if (bss_conf->assoc) {
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03003322 u32 rates;
Juuso Oikarinen2f6724b2010-11-24 08:16:57 +02003323 int ieoffset;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003324 wl->aid = bss_conf->aid;
Juuso Oikarinen69e54342010-05-07 11:39:00 +03003325 set_assoc = true;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003326
Juuso Oikarinen90494a92010-07-08 17:50:00 +03003327 wl->ps_poll_failures = 0;
3328
Luciano Coelhoae751ba2009-10-12 15:08:57 +03003329 /*
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03003330 * use basic rates from AP, and determine lowest rate
3331 * to use with control frames.
3332 */
3333 rates = bss_conf->basic_rates;
3334 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
3335 rates);
Arik Nemtsove0fe3712010-10-16 18:19:53 +02003336 wl->basic_rate = wl1271_tx_min_rate_get(wl);
Eliad Peller72c2d9e2011-02-02 09:59:37 +02003337 if (sta_rate_set)
3338 wl->rate_set = wl1271_tx_enabled_rates_get(wl,
3339 sta_rate_set);
Arik Nemtsov79b223f2010-10-16 17:52:59 +02003340 ret = wl1271_acx_sta_rate_policies(wl);
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03003341 if (ret < 0)
Arik Nemtsove78a2872010-10-16 19:07:21 +02003342 goto out;
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03003343
3344 /*
Luciano Coelhoae751ba2009-10-12 15:08:57 +03003345 * with wl1271, we don't need to update the
3346 * beacon_int and dtim_period, because the firmware
3347 * updates it by itself when the first beacon is
3348 * received after a join.
3349 */
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003350 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
3351 if (ret < 0)
Arik Nemtsove78a2872010-10-16 19:07:21 +02003352 goto out;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003353
Juuso Oikarinenc2b2d992010-03-26 12:53:28 +02003354 /*
Juuso Oikarinen2f6724b2010-11-24 08:16:57 +02003355 * Get a template for hardware connection maintenance
Juuso Oikarinenc2b2d992010-03-26 12:53:28 +02003356 */
Juuso Oikarinen2f6724b2010-11-24 08:16:57 +02003357 dev_kfree_skb(wl->probereq);
3358 wl->probereq = wl1271_cmd_build_ap_probe_req(wl, NULL);
3359 ieoffset = offsetof(struct ieee80211_mgmt,
3360 u.probe_req.variable);
3361 wl1271_ssid_set(wl, wl->probereq, ieoffset);
Juuso Oikarinenc2b2d992010-03-26 12:53:28 +02003362
Juuso Oikarinen6ccbb922010-03-26 12:53:23 +02003363 /* enable the connection monitoring feature */
3364 ret = wl1271_acx_conn_monit_params(wl, true);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003365 if (ret < 0)
Arik Nemtsove78a2872010-10-16 19:07:21 +02003366 goto out;
Juuso Oikarinend94cd292009-10-08 21:56:25 +03003367 } else {
3368 /* use defaults when not associated */
Eliad Peller30df14d2011-04-05 19:13:28 +03003369 bool was_assoc =
3370 !!test_and_clear_bit(WL1271_FLAG_STA_ASSOCIATED,
3371 &wl->flags);
Eliad Peller251c1772011-08-14 13:17:17 +03003372 bool was_ifup =
3373 !!test_and_clear_bit(WL1271_FLAG_STA_STATE_SENT,
3374 &wl->flags);
Juuso Oikarinend94cd292009-10-08 21:56:25 +03003375 wl->aid = 0;
Juuso Oikarinen6ccbb922010-03-26 12:53:23 +02003376
Juuso Oikarinen2f6724b2010-11-24 08:16:57 +02003377 /* free probe-request template */
3378 dev_kfree_skb(wl->probereq);
3379 wl->probereq = NULL;
3380
Juuso Oikarinen8d2ef7b2010-07-08 17:50:03 +03003381 /* re-enable dynamic ps - just in case */
Juuso Oikarinenf532be62010-07-08 17:50:05 +03003382 ieee80211_enable_dyn_ps(wl->vif);
Juuso Oikarinen8d2ef7b2010-07-08 17:50:03 +03003383
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03003384 /* revert back to minimum rates for the current band */
3385 wl1271_set_band_rate(wl);
Arik Nemtsove0fe3712010-10-16 18:19:53 +02003386 wl->basic_rate = wl1271_tx_min_rate_get(wl);
Arik Nemtsov79b223f2010-10-16 17:52:59 +02003387 ret = wl1271_acx_sta_rate_policies(wl);
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03003388 if (ret < 0)
Arik Nemtsove78a2872010-10-16 19:07:21 +02003389 goto out;
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03003390
Juuso Oikarinen6ccbb922010-03-26 12:53:23 +02003391 /* disable connection monitor features */
3392 ret = wl1271_acx_conn_monit_params(wl, false);
Juuso Oikarinenc1899552010-03-26 12:53:32 +02003393
3394 /* Disable the keep-alive feature */
3395 ret = wl1271_acx_keep_alive_mode(wl, false);
Juuso Oikarinen6ccbb922010-03-26 12:53:23 +02003396 if (ret < 0)
Arik Nemtsove78a2872010-10-16 19:07:21 +02003397 goto out;
Juuso Oikarinenb84a7d32010-11-22 12:59:08 +02003398
3399 /* restore the bssid filter and go to dummy bssid */
Eliad Peller30df14d2011-04-05 19:13:28 +03003400 if (was_assoc) {
Eliad Peller251c1772011-08-14 13:17:17 +03003401 u32 conf_flags = wl->hw->conf.flags;
3402 /*
3403 * we might have to disable roc, if there was
3404 * no IF_OPER_UP notification.
3405 */
3406 if (!was_ifup) {
3407 ret = wl12xx_croc(wl, wl->role_id);
3408 if (ret < 0)
3409 goto out;
3410 }
3411 /*
3412 * (we also need to disable roc in case of
3413 * roaming on the same channel. until we will
3414 * have a better flow...)
3415 */
3416 if (test_bit(wl->dev_role_id, wl->roc_map)) {
3417 ret = wl12xx_croc(wl, wl->dev_role_id);
3418 if (ret < 0)
3419 goto out;
3420 }
3421
Eliad Peller30df14d2011-04-05 19:13:28 +03003422 wl1271_unjoin(wl);
Eliad Peller251c1772011-08-14 13:17:17 +03003423 if (!(conf_flags & IEEE80211_CONF_IDLE)) {
3424 wl12xx_cmd_role_start_dev(wl);
3425 wl12xx_roc(wl, wl->dev_role_id);
3426 }
Eliad Peller30df14d2011-04-05 19:13:28 +03003427 }
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003428 }
3429 }
Juuso Oikarinen8a5a37a2009-10-08 21:56:24 +03003430
Eliad Pellerd192d262011-05-24 14:33:08 +03003431 if (changed & BSS_CHANGED_IBSS) {
3432 wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d",
3433 bss_conf->ibss_joined);
3434
3435 if (bss_conf->ibss_joined) {
3436 u32 rates = bss_conf->basic_rates;
3437 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
3438 rates);
3439 wl->basic_rate = wl1271_tx_min_rate_get(wl);
3440
3441 /* by default, use 11b rates */
3442 wl->rate_set = CONF_TX_IBSS_DEFAULT_RATES;
3443 ret = wl1271_acx_sta_rate_policies(wl);
3444 if (ret < 0)
3445 goto out;
3446 }
3447 }
3448
Arik Nemtsove78a2872010-10-16 19:07:21 +02003449 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
3450 if (ret < 0)
3451 goto out;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003452
Juuso Oikarinenca52a5e2010-07-08 17:50:02 +03003453 if (changed & BSS_CHANGED_ARP_FILTER) {
3454 __be32 addr = bss_conf->arp_addr_list[0];
3455 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
3456
Eliad Pellerc5312772010-12-09 11:31:27 +02003457 if (bss_conf->arp_addr_cnt == 1 &&
3458 bss_conf->arp_filter_enabled) {
3459 /*
3460 * The template should have been configured only upon
3461 * association. however, it seems that the correct ip
3462 * isn't being set (when sending), so we have to
3463 * reconfigure the template upon every ip change.
3464 */
3465 ret = wl1271_cmd_build_arp_rsp(wl, addr);
3466 if (ret < 0) {
3467 wl1271_warning("build arp rsp failed: %d", ret);
Arik Nemtsove78a2872010-10-16 19:07:21 +02003468 goto out;
Eliad Pellerc5312772010-12-09 11:31:27 +02003469 }
3470
3471 ret = wl1271_acx_arp_ip_filter(wl,
Eliad Pellere5e2f242011-01-24 19:19:03 +01003472 ACX_ARP_FILTER_ARP_FILTERING,
Eliad Pellerc5312772010-12-09 11:31:27 +02003473 addr);
3474 } else
3475 ret = wl1271_acx_arp_ip_filter(wl, 0, addr);
Juuso Oikarinenca52a5e2010-07-08 17:50:02 +03003476
3477 if (ret < 0)
Arik Nemtsove78a2872010-10-16 19:07:21 +02003478 goto out;
Juuso Oikarinenca52a5e2010-07-08 17:50:02 +03003479 }
3480
Juuso Oikarinen8bf29b02010-02-18 13:25:51 +02003481 if (do_join) {
Juuso Oikarinen69e54342010-05-07 11:39:00 +03003482 ret = wl1271_join(wl, set_assoc);
Juuso Oikarinen8bf29b02010-02-18 13:25:51 +02003483 if (ret < 0) {
3484 wl1271_warning("cmd join failed %d", ret);
Arik Nemtsove78a2872010-10-16 19:07:21 +02003485 goto out;
Juuso Oikarinen8bf29b02010-02-18 13:25:51 +02003486 }
Eliad Peller251c1772011-08-14 13:17:17 +03003487
3488 /* ROC until connected (after EAPOL exchange) */
3489 if (!is_ibss) {
3490 ret = wl12xx_roc(wl, wl->role_id);
3491 if (ret < 0)
3492 goto out;
3493
3494 wl1271_check_operstate(wl,
3495 ieee80211_get_operstate(vif));
3496 }
3497 /*
3498 * stop device role if started (we might already be in
3499 * STA role). TODO: make it better.
3500 */
3501 if (wl->dev_role_id != WL12XX_INVALID_ROLE_ID) {
3502 ret = wl12xx_croc(wl, wl->dev_role_id);
3503 if (ret < 0)
3504 goto out;
3505
3506 ret = wl12xx_cmd_role_stop_dev(wl);
3507 if (ret < 0)
3508 goto out;
3509 }
Eliad Peller05dba352011-08-23 16:37:01 +03003510
3511 /* If we want to go in PSM but we're not there yet */
3512 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
3513 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
3514 enum wl1271_cmd_ps_mode mode;
3515
3516 mode = STATION_POWER_SAVE_MODE;
3517 ret = wl1271_ps_set_mode(wl, mode,
3518 wl->basic_rate,
3519 true);
3520 if (ret < 0)
3521 goto out;
3522 }
Juuso Oikarinenc1899552010-03-26 12:53:32 +02003523 }
3524
Arik Nemtsov0b932ab2011-08-14 13:17:27 +03003525 /* Handle new association with HT. Do this after join. */
Arik Nemtsov0f9c8252011-08-17 10:45:49 +03003526 if (sta_exists) {
3527 if ((changed & BSS_CHANGED_HT) &&
3528 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
Arik Nemtsov0b932ab2011-08-14 13:17:27 +03003529 ret = wl1271_acx_set_ht_capabilities(wl,
3530 &sta_ht_cap,
3531 true,
3532 wl->sta_hlid);
Arik Nemtsov0f9c8252011-08-17 10:45:49 +03003533 if (ret < 0) {
3534 wl1271_warning("Set ht cap true failed %d",
3535 ret);
3536 goto out;
3537 }
3538 }
3539 /* handle new association without HT and disassociation */
3540 else if (changed & BSS_CHANGED_ASSOC) {
Arik Nemtsov0b932ab2011-08-14 13:17:27 +03003541 ret = wl1271_acx_set_ht_capabilities(wl,
3542 &sta_ht_cap,
3543 false,
3544 wl->sta_hlid);
Arik Nemtsov0f9c8252011-08-17 10:45:49 +03003545 if (ret < 0) {
3546 wl1271_warning("Set ht cap false failed %d",
3547 ret);
3548 goto out;
3549 }
3550 }
3551 }
3552
Arik Nemtsov0b932ab2011-08-14 13:17:27 +03003553 /* Handle HT information change. Done after join. */
3554 if ((changed & BSS_CHANGED_HT) &&
Arik Nemtsov0f9c8252011-08-17 10:45:49 +03003555 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
3556 ret = wl1271_acx_set_ht_information(wl,
3557 bss_conf->ht_operation_mode);
3558 if (ret < 0) {
3559 wl1271_warning("Set ht information failed %d", ret);
3560 goto out;
3561 }
3562 }
3563
Arik Nemtsove78a2872010-10-16 19:07:21 +02003564out:
3565 return;
3566}
3567
3568static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
3569 struct ieee80211_vif *vif,
3570 struct ieee80211_bss_conf *bss_conf,
3571 u32 changed)
3572{
3573 struct wl1271 *wl = hw->priv;
3574 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
3575 int ret;
3576
3577 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
3578 (int)changed);
3579
3580 mutex_lock(&wl->mutex);
3581
3582 if (unlikely(wl->state == WL1271_STATE_OFF))
3583 goto out;
3584
Ido Yariva6208652011-03-01 15:14:41 +02003585 ret = wl1271_ps_elp_wakeup(wl);
Arik Nemtsove78a2872010-10-16 19:07:21 +02003586 if (ret < 0)
3587 goto out;
3588
3589 if (is_ap)
3590 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
3591 else
3592 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
3593
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003594 wl1271_ps_elp_sleep(wl);
3595
3596out:
3597 mutex_unlock(&wl->mutex);
3598}
3599
Kalle Valoc6999d82010-02-18 13:25:41 +02003600static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
3601 const struct ieee80211_tx_queue_params *params)
3602{
3603 struct wl1271 *wl = hw->priv;
Kalle Valo4695dc92010-03-18 12:26:38 +02003604 u8 ps_scheme;
Arik Nemtsov488fc542010-10-16 20:33:45 +02003605 int ret = 0;
Kalle Valoc6999d82010-02-18 13:25:41 +02003606
3607 mutex_lock(&wl->mutex);
3608
3609 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
3610
Kalle Valo4695dc92010-03-18 12:26:38 +02003611 if (params->uapsd)
3612 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
3613 else
3614 ps_scheme = CONF_PS_SCHEME_LEGACY;
3615
Arik Nemtsov488fc542010-10-16 20:33:45 +02003616 if (wl->state == WL1271_STATE_OFF) {
3617 /*
3618 * If the state is off, the parameters will be recorded and
3619 * configured on init. This happens in AP-mode.
3620 */
3621 struct conf_tx_ac_category *conf_ac =
3622 &wl->conf.tx.ac_conf[wl1271_tx_get_queue(queue)];
3623 struct conf_tx_tid *conf_tid =
3624 &wl->conf.tx.tid_conf[wl1271_tx_get_queue(queue)];
3625
3626 conf_ac->ac = wl1271_tx_get_queue(queue);
3627 conf_ac->cw_min = (u8)params->cw_min;
3628 conf_ac->cw_max = params->cw_max;
3629 conf_ac->aifsn = params->aifs;
3630 conf_ac->tx_op_limit = params->txop << 5;
3631
3632 conf_tid->queue_id = wl1271_tx_get_queue(queue);
3633 conf_tid->channel_type = CONF_CHANNEL_TYPE_EDCF;
3634 conf_tid->tsid = wl1271_tx_get_queue(queue);
3635 conf_tid->ps_scheme = ps_scheme;
3636 conf_tid->ack_policy = CONF_ACK_POLICY_LEGACY;
3637 conf_tid->apsd_conf[0] = 0;
3638 conf_tid->apsd_conf[1] = 0;
Eliad Pellerc1b193e2011-03-23 22:22:15 +02003639 goto out;
3640 }
Arik Nemtsov488fc542010-10-16 20:33:45 +02003641
Eliad Pellerc1b193e2011-03-23 22:22:15 +02003642 ret = wl1271_ps_elp_wakeup(wl);
3643 if (ret < 0)
3644 goto out;
Arik Nemtsov488fc542010-10-16 20:33:45 +02003645
Eliad Pellerc1b193e2011-03-23 22:22:15 +02003646 /*
3647 * the txop is confed in units of 32us by the mac80211,
3648 * we need us
3649 */
3650 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
3651 params->cw_min, params->cw_max,
3652 params->aifs, params->txop << 5);
3653 if (ret < 0)
3654 goto out_sleep;
3655
3656 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
3657 CONF_CHANNEL_TYPE_EDCF,
3658 wl1271_tx_get_queue(queue),
3659 ps_scheme, CONF_ACK_POLICY_LEGACY,
3660 0, 0);
Kalle Valoc82c1dd2010-02-18 13:25:47 +02003661
3662out_sleep:
Eliad Pellerc1b193e2011-03-23 22:22:15 +02003663 wl1271_ps_elp_sleep(wl);
Kalle Valoc6999d82010-02-18 13:25:41 +02003664
3665out:
3666 mutex_unlock(&wl->mutex);
3667
3668 return ret;
3669}
3670
Juuso Oikarinenbbbb5382010-07-08 17:49:57 +03003671static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
3672{
3673
3674 struct wl1271 *wl = hw->priv;
3675 u64 mactime = ULLONG_MAX;
3676 int ret;
3677
3678 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
3679
3680 mutex_lock(&wl->mutex);
3681
Juuso Oikarinenf8d98022010-10-26 13:24:39 +02003682 if (unlikely(wl->state == WL1271_STATE_OFF))
3683 goto out;
3684
Ido Yariva6208652011-03-01 15:14:41 +02003685 ret = wl1271_ps_elp_wakeup(wl);
Juuso Oikarinenbbbb5382010-07-08 17:49:57 +03003686 if (ret < 0)
3687 goto out;
3688
3689 ret = wl1271_acx_tsf_info(wl, &mactime);
3690 if (ret < 0)
3691 goto out_sleep;
3692
3693out_sleep:
3694 wl1271_ps_elp_sleep(wl);
3695
3696out:
3697 mutex_unlock(&wl->mutex);
3698 return mactime;
3699}
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003700
John W. Linvilleece550d2010-07-28 16:41:06 -04003701static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
3702 struct survey_info *survey)
3703{
3704 struct wl1271 *wl = hw->priv;
3705 struct ieee80211_conf *conf = &hw->conf;
Juuso Oikarinenb739a422010-10-26 13:24:38 +02003706
John W. Linvilleece550d2010-07-28 16:41:06 -04003707 if (idx != 0)
3708 return -ENOENT;
Juuso Oikarinenb739a422010-10-26 13:24:38 +02003709
John W. Linvilleece550d2010-07-28 16:41:06 -04003710 survey->channel = conf->channel;
3711 survey->filled = SURVEY_INFO_NOISE_DBM;
3712 survey->noise = wl->noise;
Juuso Oikarinenb739a422010-10-26 13:24:38 +02003713
John W. Linvilleece550d2010-07-28 16:41:06 -04003714 return 0;
3715}
3716
Arik Nemtsov409622e2011-02-23 00:22:29 +02003717static int wl1271_allocate_sta(struct wl1271 *wl,
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02003718 struct ieee80211_sta *sta,
3719 u8 *hlid)
3720{
3721 struct wl1271_station *wl_sta;
3722 int id;
3723
3724 id = find_first_zero_bit(wl->ap_hlid_map, AP_MAX_STATIONS);
3725 if (id >= AP_MAX_STATIONS) {
3726 wl1271_warning("could not allocate HLID - too much stations");
3727 return -EBUSY;
3728 }
3729
3730 wl_sta = (struct wl1271_station *)sta->drv_priv;
Arik Nemtsov04216da2011-08-14 13:17:38 +03003731 set_bit(id, wl->ap_hlid_map);
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02003732 wl_sta->hlid = WL1271_AP_STA_HLID_START + id;
3733 *hlid = wl_sta->hlid;
Arik Nemtsovb622d992011-02-23 00:22:31 +02003734 memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02003735 return 0;
3736}
3737
Arik Nemtsov409622e2011-02-23 00:22:29 +02003738static void wl1271_free_sta(struct wl1271 *wl, u8 hlid)
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02003739{
3740 int id = hlid - WL1271_AP_STA_HLID_START;
3741
Arik Nemtsov409622e2011-02-23 00:22:29 +02003742 if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
3743 return;
3744
Arik Nemtsov04216da2011-08-14 13:17:38 +03003745 clear_bit(id, wl->ap_hlid_map);
Arik Nemtsovb622d992011-02-23 00:22:31 +02003746 memset(wl->links[hlid].addr, 0, ETH_ALEN);
Arik Nemtsov0f9c8252011-08-17 10:45:49 +03003747 wl->links[hlid].ba_bitmap = 0;
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +02003748 wl1271_tx_reset_link_queues(wl, hlid);
Arik Nemtsovb622d992011-02-23 00:22:31 +02003749 __clear_bit(hlid, &wl->ap_ps_map);
3750 __clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02003751}
3752
3753static int wl1271_op_sta_add(struct ieee80211_hw *hw,
3754 struct ieee80211_vif *vif,
3755 struct ieee80211_sta *sta)
3756{
3757 struct wl1271 *wl = hw->priv;
3758 int ret = 0;
3759 u8 hlid;
3760
3761 mutex_lock(&wl->mutex);
3762
3763 if (unlikely(wl->state == WL1271_STATE_OFF))
3764 goto out;
3765
3766 if (wl->bss_type != BSS_TYPE_AP_BSS)
3767 goto out;
3768
3769 wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);
3770
Arik Nemtsov409622e2011-02-23 00:22:29 +02003771 ret = wl1271_allocate_sta(wl, sta, &hlid);
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02003772 if (ret < 0)
3773 goto out;
3774
Ido Yariva6208652011-03-01 15:14:41 +02003775 ret = wl1271_ps_elp_wakeup(wl);
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02003776 if (ret < 0)
Arik Nemtsov409622e2011-02-23 00:22:29 +02003777 goto out_free_sta;
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02003778
Eliad Pellerc690ec82011-08-14 13:17:07 +03003779 ret = wl12xx_cmd_add_peer(wl, sta, hlid);
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02003780 if (ret < 0)
3781 goto out_sleep;
3782
Eliad Pellerb67476e2011-08-14 13:17:23 +03003783 ret = wl12xx_cmd_set_peer_state(wl, hlid);
3784 if (ret < 0)
3785 goto out_sleep;
3786
Arik Nemtsov0b932ab2011-08-14 13:17:27 +03003787 ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap, true, hlid);
3788 if (ret < 0)
3789 goto out_sleep;
3790
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02003791out_sleep:
3792 wl1271_ps_elp_sleep(wl);
3793
Arik Nemtsov409622e2011-02-23 00:22:29 +02003794out_free_sta:
3795 if (ret < 0)
3796 wl1271_free_sta(wl, hlid);
3797
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02003798out:
3799 mutex_unlock(&wl->mutex);
3800 return ret;
3801}
3802
3803static int wl1271_op_sta_remove(struct ieee80211_hw *hw,
3804 struct ieee80211_vif *vif,
3805 struct ieee80211_sta *sta)
3806{
3807 struct wl1271 *wl = hw->priv;
3808 struct wl1271_station *wl_sta;
3809 int ret = 0, id;
3810
3811 mutex_lock(&wl->mutex);
3812
3813 if (unlikely(wl->state == WL1271_STATE_OFF))
3814 goto out;
3815
3816 if (wl->bss_type != BSS_TYPE_AP_BSS)
3817 goto out;
3818
3819 wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);
3820
3821 wl_sta = (struct wl1271_station *)sta->drv_priv;
3822 id = wl_sta->hlid - WL1271_AP_STA_HLID_START;
3823 if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
3824 goto out;
3825
Ido Yariva6208652011-03-01 15:14:41 +02003826 ret = wl1271_ps_elp_wakeup(wl);
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02003827 if (ret < 0)
3828 goto out;
3829
Eliad Pellerc690ec82011-08-14 13:17:07 +03003830 ret = wl12xx_cmd_remove_peer(wl, wl_sta->hlid);
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02003831 if (ret < 0)
3832 goto out_sleep;
3833
Arik Nemtsov409622e2011-02-23 00:22:29 +02003834 wl1271_free_sta(wl, wl_sta->hlid);
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02003835
3836out_sleep:
3837 wl1271_ps_elp_sleep(wl);
3838
3839out:
3840 mutex_unlock(&wl->mutex);
3841 return ret;
3842}
3843
Luciano Coelho4623ec72011-03-21 19:26:41 +02003844static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
3845 struct ieee80211_vif *vif,
3846 enum ieee80211_ampdu_mlme_action action,
3847 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
3848 u8 buf_size)
Levi, Shaharbbba3e62011-01-23 07:27:23 +01003849{
3850 struct wl1271 *wl = hw->priv;
3851 int ret;
Arik Nemtsov0f9c8252011-08-17 10:45:49 +03003852 u8 hlid, *ba_bitmap;
3853
3854 wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu action %d tid %d", action,
3855 tid);
3856
3857 /* sanity check - the fields in FW are only 8bits wide */
3858 if (WARN_ON(tid > 0xFF))
3859 return -ENOTSUPP;
Levi, Shaharbbba3e62011-01-23 07:27:23 +01003860
3861 mutex_lock(&wl->mutex);
3862
3863 if (unlikely(wl->state == WL1271_STATE_OFF)) {
3864 ret = -EAGAIN;
3865 goto out;
3866 }
3867
Arik Nemtsov0f9c8252011-08-17 10:45:49 +03003868 if (wl->bss_type == BSS_TYPE_STA_BSS) {
3869 hlid = wl->sta_hlid;
3870 ba_bitmap = &wl->ba_rx_bitmap;
3871 } else if (wl->bss_type == BSS_TYPE_AP_BSS) {
3872 struct wl1271_station *wl_sta;
3873
3874 wl_sta = (struct wl1271_station *)sta->drv_priv;
3875 hlid = wl_sta->hlid;
3876 ba_bitmap = &wl->links[hlid].ba_bitmap;
3877 } else {
3878 ret = -EINVAL;
3879 goto out;
3880 }
3881
Ido Yariva6208652011-03-01 15:14:41 +02003882 ret = wl1271_ps_elp_wakeup(wl);
Levi, Shaharbbba3e62011-01-23 07:27:23 +01003883 if (ret < 0)
3884 goto out;
3885
Shahar Levi70559a02011-05-22 16:10:22 +03003886 wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu: Rx tid %d action %d",
3887 tid, action);
3888
Levi, Shaharbbba3e62011-01-23 07:27:23 +01003889 switch (action) {
3890 case IEEE80211_AMPDU_RX_START:
Arik Nemtsov0f9c8252011-08-17 10:45:49 +03003891 if (!wl->ba_support || !wl->ba_allowed) {
Levi, Shaharbbba3e62011-01-23 07:27:23 +01003892 ret = -ENOTSUPP;
Arik Nemtsov0f9c8252011-08-17 10:45:49 +03003893 break;
3894 }
3895
3896 if (wl->ba_rx_session_count >= RX_BA_MAX_SESSIONS) {
3897 ret = -EBUSY;
3898 wl1271_error("exceeded max RX BA sessions");
3899 break;
3900 }
3901
3902 if (*ba_bitmap & BIT(tid)) {
3903 ret = -EINVAL;
3904 wl1271_error("cannot enable RX BA session on active "
3905 "tid: %d", tid);
3906 break;
3907 }
3908
3909 ret = wl12xx_acx_set_ba_receiver_session(wl, tid, *ssn, true,
3910 hlid);
3911 if (!ret) {
3912 *ba_bitmap |= BIT(tid);
3913 wl->ba_rx_session_count++;
Levi, Shaharbbba3e62011-01-23 07:27:23 +01003914 }
3915 break;
3916
3917 case IEEE80211_AMPDU_RX_STOP:
Arik Nemtsov0f9c8252011-08-17 10:45:49 +03003918 if (!(*ba_bitmap & BIT(tid))) {
3919 ret = -EINVAL;
3920 wl1271_error("no active RX BA session on tid: %d",
3921 tid);
3922 break;
3923 }
3924
3925 ret = wl12xx_acx_set_ba_receiver_session(wl, tid, 0, false,
3926 hlid);
3927 if (!ret) {
3928 *ba_bitmap &= ~BIT(tid);
3929 wl->ba_rx_session_count--;
3930 }
Levi, Shaharbbba3e62011-01-23 07:27:23 +01003931 break;
3932
3933 /*
3934 * The BA initiator session management in FW independently.
3935 * Falling break here on purpose for all TX APDU commands.
3936 */
3937 case IEEE80211_AMPDU_TX_START:
3938 case IEEE80211_AMPDU_TX_STOP:
3939 case IEEE80211_AMPDU_TX_OPERATIONAL:
3940 ret = -EINVAL;
3941 break;
3942
3943 default:
3944 wl1271_error("Incorrect ampdu action id=%x\n", action);
3945 ret = -EINVAL;
3946 }
3947
3948 wl1271_ps_elp_sleep(wl);
3949
3950out:
3951 mutex_unlock(&wl->mutex);
3952
3953 return ret;
3954}
3955
Arik Nemtsov33437892011-04-26 23:35:39 +03003956static bool wl1271_tx_frames_pending(struct ieee80211_hw *hw)
3957{
3958 struct wl1271 *wl = hw->priv;
3959 bool ret = false;
3960
3961 mutex_lock(&wl->mutex);
3962
3963 if (unlikely(wl->state == WL1271_STATE_OFF))
3964 goto out;
3965
3966 /* packets are considered pending if in the TX queue or the FW */
Arik Nemtsovf1a46382011-07-07 14:25:23 +03003967 ret = (wl1271_tx_total_queue_count(wl) > 0) || (wl->tx_frames_cnt > 0);
Arik Nemtsov33437892011-04-26 23:35:39 +03003968
3969 /* the above is appropriate for STA mode for PS purposes */
3970 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
3971
3972out:
3973 mutex_unlock(&wl->mutex);
3974
3975 return ret;
3976}
3977
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003978/* can't be const, mac80211 writes to this */
3979static struct ieee80211_rate wl1271_rates[] = {
3980 { .bitrate = 10,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03003981 .hw_value = CONF_HW_BIT_RATE_1MBPS,
3982 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003983 { .bitrate = 20,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03003984 .hw_value = CONF_HW_BIT_RATE_2MBPS,
3985 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003986 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3987 { .bitrate = 55,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03003988 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
3989 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003990 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3991 { .bitrate = 110,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03003992 .hw_value = CONF_HW_BIT_RATE_11MBPS,
3993 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003994 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3995 { .bitrate = 60,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03003996 .hw_value = CONF_HW_BIT_RATE_6MBPS,
3997 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03003998 { .bitrate = 90,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03003999 .hw_value = CONF_HW_BIT_RATE_9MBPS,
4000 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004001 { .bitrate = 120,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03004002 .hw_value = CONF_HW_BIT_RATE_12MBPS,
4003 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004004 { .bitrate = 180,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03004005 .hw_value = CONF_HW_BIT_RATE_18MBPS,
4006 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004007 { .bitrate = 240,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03004008 .hw_value = CONF_HW_BIT_RATE_24MBPS,
4009 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004010 { .bitrate = 360,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03004011 .hw_value = CONF_HW_BIT_RATE_36MBPS,
4012 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004013 { .bitrate = 480,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03004014 .hw_value = CONF_HW_BIT_RATE_48MBPS,
4015 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004016 { .bitrate = 540,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03004017 .hw_value = CONF_HW_BIT_RATE_54MBPS,
4018 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004019};
4020
Juuso Oikarinenfa97f462010-11-10 11:27:20 +01004021/* can't be const, mac80211 writes to this */
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004022static struct ieee80211_channel wl1271_channels[] = {
Luciano Coelhoa2d0e3f2009-12-11 15:40:46 +02004023 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
Juuso Oikarinenfa21c7a2010-08-10 08:22:02 +02004024 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
Juuso Oikarinenfa97f462010-11-10 11:27:20 +01004025 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
4026 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
4027 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
Juuso Oikarinenfa21c7a2010-08-10 08:22:02 +02004028 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
Juuso Oikarinenfa97f462010-11-10 11:27:20 +01004029 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
4030 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
4031 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
Juuso Oikarinenfa21c7a2010-08-10 08:22:02 +02004032 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
Juuso Oikarinenfa97f462010-11-10 11:27:20 +01004033 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
4034 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
4035 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
Arik Nemtsov6c89b7b2011-01-18 20:39:52 +01004036 { .hw_value = 14, .center_freq = 2484, .max_power = 25 },
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004037};
4038
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02004039/* mapping to indexes for wl1271_rates */
Tobias Klausera0ea9492010-05-20 10:38:11 +02004040static const u8 wl1271_rate_to_idx_2ghz[] = {
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02004041 /* MCS rates are used only with 11n */
Shahar Levi18357852010-10-13 16:09:41 +02004042 7, /* CONF_HW_RXTX_RATE_MCS7 */
4043 6, /* CONF_HW_RXTX_RATE_MCS6 */
4044 5, /* CONF_HW_RXTX_RATE_MCS5 */
4045 4, /* CONF_HW_RXTX_RATE_MCS4 */
4046 3, /* CONF_HW_RXTX_RATE_MCS3 */
4047 2, /* CONF_HW_RXTX_RATE_MCS2 */
4048 1, /* CONF_HW_RXTX_RATE_MCS1 */
4049 0, /* CONF_HW_RXTX_RATE_MCS0 */
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02004050
4051 11, /* CONF_HW_RXTX_RATE_54 */
4052 10, /* CONF_HW_RXTX_RATE_48 */
4053 9, /* CONF_HW_RXTX_RATE_36 */
4054 8, /* CONF_HW_RXTX_RATE_24 */
4055
4056 /* TI-specific rate */
4057 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
4058
4059 7, /* CONF_HW_RXTX_RATE_18 */
4060 6, /* CONF_HW_RXTX_RATE_12 */
4061 3, /* CONF_HW_RXTX_RATE_11 */
4062 5, /* CONF_HW_RXTX_RATE_9 */
4063 4, /* CONF_HW_RXTX_RATE_6 */
4064 2, /* CONF_HW_RXTX_RATE_5_5 */
4065 1, /* CONF_HW_RXTX_RATE_2 */
4066 0 /* CONF_HW_RXTX_RATE_1 */
4067};
4068
Shahar Levie8b03a22010-10-13 16:09:39 +02004069/* 11n STA capabilities */
4070#define HW_RX_HIGHEST_RATE 72
4071
Shahar Levi00d20102010-11-08 11:20:10 +00004072#ifdef CONFIG_WL12XX_HT
4073#define WL12XX_HT_CAP { \
Shahar Levi871d0c32011-03-13 11:24:40 +02004074 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | \
4075 (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT), \
Shahar Levie8b03a22010-10-13 16:09:39 +02004076 .ht_supported = true, \
4077 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
4078 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
4079 .mcs = { \
4080 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
4081 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
4082 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
4083 }, \
4084}
Shahar Levi18357852010-10-13 16:09:41 +02004085#else
Shahar Levi00d20102010-11-08 11:20:10 +00004086#define WL12XX_HT_CAP { \
Shahar Levi18357852010-10-13 16:09:41 +02004087 .ht_supported = false, \
4088}
4089#endif
Shahar Levie8b03a22010-10-13 16:09:39 +02004090
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004091/* can't be const, mac80211 writes to this */
4092static struct ieee80211_supported_band wl1271_band_2ghz = {
4093 .channels = wl1271_channels,
4094 .n_channels = ARRAY_SIZE(wl1271_channels),
4095 .bitrates = wl1271_rates,
4096 .n_bitrates = ARRAY_SIZE(wl1271_rates),
Shahar Levi00d20102010-11-08 11:20:10 +00004097 .ht_cap = WL12XX_HT_CAP,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004098};
4099
Teemu Paasikivi1ebec3d2009-10-13 12:47:48 +03004100/* 5 GHz data rates for WL1273 */
4101static struct ieee80211_rate wl1271_rates_5ghz[] = {
4102 { .bitrate = 60,
4103 .hw_value = CONF_HW_BIT_RATE_6MBPS,
4104 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
4105 { .bitrate = 90,
4106 .hw_value = CONF_HW_BIT_RATE_9MBPS,
4107 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
4108 { .bitrate = 120,
4109 .hw_value = CONF_HW_BIT_RATE_12MBPS,
4110 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
4111 { .bitrate = 180,
4112 .hw_value = CONF_HW_BIT_RATE_18MBPS,
4113 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
4114 { .bitrate = 240,
4115 .hw_value = CONF_HW_BIT_RATE_24MBPS,
4116 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
4117 { .bitrate = 360,
4118 .hw_value = CONF_HW_BIT_RATE_36MBPS,
4119 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
4120 { .bitrate = 480,
4121 .hw_value = CONF_HW_BIT_RATE_48MBPS,
4122 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
4123 { .bitrate = 540,
4124 .hw_value = CONF_HW_BIT_RATE_54MBPS,
4125 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
4126};
4127
Juuso Oikarinenfa97f462010-11-10 11:27:20 +01004128/* 5 GHz band channels for WL1273 */
Teemu Paasikivi1ebec3d2009-10-13 12:47:48 +03004129static struct ieee80211_channel wl1271_channels_5ghz[] = {
Arik Nemtsov6cfa5cf2011-06-27 22:06:33 +03004130 { .hw_value = 7, .center_freq = 5035, .max_power = 25 },
4131 { .hw_value = 8, .center_freq = 5040, .max_power = 25 },
4132 { .hw_value = 9, .center_freq = 5045, .max_power = 25 },
4133 { .hw_value = 11, .center_freq = 5055, .max_power = 25 },
4134 { .hw_value = 12, .center_freq = 5060, .max_power = 25 },
4135 { .hw_value = 16, .center_freq = 5080, .max_power = 25 },
4136 { .hw_value = 34, .center_freq = 5170, .max_power = 25 },
4137 { .hw_value = 36, .center_freq = 5180, .max_power = 25 },
4138 { .hw_value = 38, .center_freq = 5190, .max_power = 25 },
4139 { .hw_value = 40, .center_freq = 5200, .max_power = 25 },
4140 { .hw_value = 42, .center_freq = 5210, .max_power = 25 },
4141 { .hw_value = 44, .center_freq = 5220, .max_power = 25 },
4142 { .hw_value = 46, .center_freq = 5230, .max_power = 25 },
4143 { .hw_value = 48, .center_freq = 5240, .max_power = 25 },
4144 { .hw_value = 52, .center_freq = 5260, .max_power = 25 },
4145 { .hw_value = 56, .center_freq = 5280, .max_power = 25 },
4146 { .hw_value = 60, .center_freq = 5300, .max_power = 25 },
4147 { .hw_value = 64, .center_freq = 5320, .max_power = 25 },
4148 { .hw_value = 100, .center_freq = 5500, .max_power = 25 },
4149 { .hw_value = 104, .center_freq = 5520, .max_power = 25 },
4150 { .hw_value = 108, .center_freq = 5540, .max_power = 25 },
4151 { .hw_value = 112, .center_freq = 5560, .max_power = 25 },
4152 { .hw_value = 116, .center_freq = 5580, .max_power = 25 },
4153 { .hw_value = 120, .center_freq = 5600, .max_power = 25 },
4154 { .hw_value = 124, .center_freq = 5620, .max_power = 25 },
4155 { .hw_value = 128, .center_freq = 5640, .max_power = 25 },
4156 { .hw_value = 132, .center_freq = 5660, .max_power = 25 },
4157 { .hw_value = 136, .center_freq = 5680, .max_power = 25 },
4158 { .hw_value = 140, .center_freq = 5700, .max_power = 25 },
4159 { .hw_value = 149, .center_freq = 5745, .max_power = 25 },
4160 { .hw_value = 153, .center_freq = 5765, .max_power = 25 },
4161 { .hw_value = 157, .center_freq = 5785, .max_power = 25 },
4162 { .hw_value = 161, .center_freq = 5805, .max_power = 25 },
4163 { .hw_value = 165, .center_freq = 5825, .max_power = 25 },
Teemu Paasikivi1ebec3d2009-10-13 12:47:48 +03004164};
4165
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02004166/* mapping to indexes for wl1271_rates_5ghz */
Tobias Klausera0ea9492010-05-20 10:38:11 +02004167static const u8 wl1271_rate_to_idx_5ghz[] = {
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02004168 /* MCS rates are used only with 11n */
Shahar Levi18357852010-10-13 16:09:41 +02004169 7, /* CONF_HW_RXTX_RATE_MCS7 */
4170 6, /* CONF_HW_RXTX_RATE_MCS6 */
4171 5, /* CONF_HW_RXTX_RATE_MCS5 */
4172 4, /* CONF_HW_RXTX_RATE_MCS4 */
4173 3, /* CONF_HW_RXTX_RATE_MCS3 */
4174 2, /* CONF_HW_RXTX_RATE_MCS2 */
4175 1, /* CONF_HW_RXTX_RATE_MCS1 */
4176 0, /* CONF_HW_RXTX_RATE_MCS0 */
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02004177
4178 7, /* CONF_HW_RXTX_RATE_54 */
4179 6, /* CONF_HW_RXTX_RATE_48 */
4180 5, /* CONF_HW_RXTX_RATE_36 */
4181 4, /* CONF_HW_RXTX_RATE_24 */
4182
4183 /* TI-specific rate */
4184 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
4185
4186 3, /* CONF_HW_RXTX_RATE_18 */
4187 2, /* CONF_HW_RXTX_RATE_12 */
4188 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
4189 1, /* CONF_HW_RXTX_RATE_9 */
4190 0, /* CONF_HW_RXTX_RATE_6 */
4191 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
4192 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
4193 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
4194};
Teemu Paasikivi1ebec3d2009-10-13 12:47:48 +03004195
4196static struct ieee80211_supported_band wl1271_band_5ghz = {
4197 .channels = wl1271_channels_5ghz,
4198 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
4199 .bitrates = wl1271_rates_5ghz,
4200 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
Shahar Levi00d20102010-11-08 11:20:10 +00004201 .ht_cap = WL12XX_HT_CAP,
Teemu Paasikivi1ebec3d2009-10-13 12:47:48 +03004202};
4203
Tobias Klausera0ea9492010-05-20 10:38:11 +02004204static const u8 *wl1271_band_rate_to_idx[] = {
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02004205 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
4206 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
4207};
4208
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004209static const struct ieee80211_ops wl1271_ops = {
4210 .start = wl1271_op_start,
4211 .stop = wl1271_op_stop,
4212 .add_interface = wl1271_op_add_interface,
4213 .remove_interface = wl1271_op_remove_interface,
Luciano Coelhof634a4e2011-05-18 16:51:26 -04004214#ifdef CONFIG_PM
Eliad Peller402e48612011-05-13 11:57:09 +03004215 .suspend = wl1271_op_suspend,
4216 .resume = wl1271_op_resume,
Luciano Coelhof634a4e2011-05-18 16:51:26 -04004217#endif
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004218 .config = wl1271_op_config,
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03004219 .prepare_multicast = wl1271_op_prepare_multicast,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004220 .configure_filter = wl1271_op_configure_filter,
4221 .tx = wl1271_op_tx,
4222 .set_key = wl1271_op_set_key,
4223 .hw_scan = wl1271_op_hw_scan,
Eliad Peller73ecce32011-06-27 13:06:45 +03004224 .cancel_hw_scan = wl1271_op_cancel_hw_scan,
Luciano Coelho33c2c062011-05-10 14:46:02 +03004225 .sched_scan_start = wl1271_op_sched_scan_start,
4226 .sched_scan_stop = wl1271_op_sched_scan_stop,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004227 .bss_info_changed = wl1271_op_bss_info_changed,
Arik Nemtsov68d069c2010-11-08 10:51:07 +01004228 .set_frag_threshold = wl1271_op_set_frag_threshold,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004229 .set_rts_threshold = wl1271_op_set_rts_threshold,
Kalle Valoc6999d82010-02-18 13:25:41 +02004230 .conf_tx = wl1271_op_conf_tx,
Juuso Oikarinenbbbb5382010-07-08 17:49:57 +03004231 .get_tsf = wl1271_op_get_tsf,
John W. Linvilleece550d2010-07-28 16:41:06 -04004232 .get_survey = wl1271_op_get_survey,
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02004233 .sta_add = wl1271_op_sta_add,
4234 .sta_remove = wl1271_op_sta_remove,
Levi, Shaharbbba3e62011-01-23 07:27:23 +01004235 .ampdu_action = wl1271_op_ampdu_action,
Arik Nemtsov33437892011-04-26 23:35:39 +03004236 .tx_frames_pending = wl1271_tx_frames_pending,
Kalle Valoc8c90872010-02-18 13:25:53 +02004237 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004238};
4239
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02004240
Teemu Paasikivi6a2de932010-10-14 11:00:04 +02004241u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02004242{
4243 u8 idx;
4244
Teemu Paasikivi6a2de932010-10-14 11:00:04 +02004245 BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02004246
4247 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
4248 wl1271_error("Illegal RX rate from HW: %d", rate);
4249 return 0;
4250 }
4251
Teemu Paasikivi6a2de932010-10-14 11:00:04 +02004252 idx = wl1271_band_rate_to_idx[band][rate];
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02004253 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
4254 wl1271_error("Unsupported RX rate from HW: %d", rate);
4255 return 0;
4256 }
4257
4258 return idx;
4259}
4260
Juuso Oikarinen7fc3a862010-03-18 12:26:32 +02004261static ssize_t wl1271_sysfs_show_bt_coex_state(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 Oikarinen7fc3a862010-03-18 12:26:32 +02004269
4270 mutex_lock(&wl->mutex);
4271 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
4272 wl->sg_enabled);
4273 mutex_unlock(&wl->mutex);
4274
4275 return len;
4276
4277}
4278
4279static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
4280 struct device_attribute *attr,
4281 const char *buf, size_t count)
4282{
4283 struct wl1271 *wl = dev_get_drvdata(dev);
4284 unsigned long res;
4285 int ret;
4286
Luciano Coelho6277ed62011-04-01 17:49:54 +03004287 ret = kstrtoul(buf, 10, &res);
Juuso Oikarinen7fc3a862010-03-18 12:26:32 +02004288 if (ret < 0) {
4289 wl1271_warning("incorrect value written to bt_coex_mode");
4290 return count;
4291 }
4292
4293 mutex_lock(&wl->mutex);
4294
4295 res = !!res;
4296
4297 if (res == wl->sg_enabled)
4298 goto out;
4299
4300 wl->sg_enabled = res;
4301
4302 if (wl->state == WL1271_STATE_OFF)
4303 goto out;
4304
Ido Yariva6208652011-03-01 15:14:41 +02004305 ret = wl1271_ps_elp_wakeup(wl);
Juuso Oikarinen7fc3a862010-03-18 12:26:32 +02004306 if (ret < 0)
4307 goto out;
4308
4309 wl1271_acx_sg_enable(wl, wl->sg_enabled);
4310 wl1271_ps_elp_sleep(wl);
4311
4312 out:
4313 mutex_unlock(&wl->mutex);
4314 return count;
4315}
4316
4317static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
4318 wl1271_sysfs_show_bt_coex_state,
4319 wl1271_sysfs_store_bt_coex_state);
4320
Juuso Oikarinend717fd62010-05-07 11:38:58 +03004321static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
4322 struct device_attribute *attr,
4323 char *buf)
4324{
4325 struct wl1271 *wl = dev_get_drvdata(dev);
4326 ssize_t len;
4327
Juuso Oikarinen2f63b012010-08-10 06:38:35 +02004328 len = PAGE_SIZE;
Juuso Oikarinend717fd62010-05-07 11:38:58 +03004329
4330 mutex_lock(&wl->mutex);
4331 if (wl->hw_pg_ver >= 0)
4332 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
4333 else
4334 len = snprintf(buf, len, "n/a\n");
4335 mutex_unlock(&wl->mutex);
4336
4337 return len;
4338}
4339
Gery Kahn6f07b722011-07-18 14:21:49 +03004340static DEVICE_ATTR(hw_pg_ver, S_IRUGO,
Juuso Oikarinend717fd62010-05-07 11:38:58 +03004341 wl1271_sysfs_show_hw_pg_ver, NULL);
4342
Ido Yariv95dac04f2011-06-06 14:57:06 +03004343static ssize_t wl1271_sysfs_read_fwlog(struct file *filp, struct kobject *kobj,
4344 struct bin_attribute *bin_attr,
4345 char *buffer, loff_t pos, size_t count)
4346{
4347 struct device *dev = container_of(kobj, struct device, kobj);
4348 struct wl1271 *wl = dev_get_drvdata(dev);
4349 ssize_t len;
4350 int ret;
4351
4352 ret = mutex_lock_interruptible(&wl->mutex);
4353 if (ret < 0)
4354 return -ERESTARTSYS;
4355
4356 /* Let only one thread read the log at a time, blocking others */
4357 while (wl->fwlog_size == 0) {
4358 DEFINE_WAIT(wait);
4359
4360 prepare_to_wait_exclusive(&wl->fwlog_waitq,
4361 &wait,
4362 TASK_INTERRUPTIBLE);
4363
4364 if (wl->fwlog_size != 0) {
4365 finish_wait(&wl->fwlog_waitq, &wait);
4366 break;
4367 }
4368
4369 mutex_unlock(&wl->mutex);
4370
4371 schedule();
4372 finish_wait(&wl->fwlog_waitq, &wait);
4373
4374 if (signal_pending(current))
4375 return -ERESTARTSYS;
4376
4377 ret = mutex_lock_interruptible(&wl->mutex);
4378 if (ret < 0)
4379 return -ERESTARTSYS;
4380 }
4381
4382 /* Check if the fwlog is still valid */
4383 if (wl->fwlog_size < 0) {
4384 mutex_unlock(&wl->mutex);
4385 return 0;
4386 }
4387
4388 /* Seeking is not supported - old logs are not kept. Disregard pos. */
4389 len = min(count, (size_t)wl->fwlog_size);
4390 wl->fwlog_size -= len;
4391 memcpy(buffer, wl->fwlog, len);
4392
4393 /* Make room for new messages */
4394 memmove(wl->fwlog, wl->fwlog + len, wl->fwlog_size);
4395
4396 mutex_unlock(&wl->mutex);
4397
4398 return len;
4399}
4400
4401static struct bin_attribute fwlog_attr = {
4402 .attr = {.name = "fwlog", .mode = S_IRUSR},
4403 .read = wl1271_sysfs_read_fwlog,
4404};
4405
Teemu Paasikivi2d5e82b2010-02-22 08:38:21 +02004406int wl1271_register_hw(struct wl1271 *wl)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004407{
4408 int ret;
4409
4410 if (wl->mac80211_registered)
4411 return 0;
4412
Arik Nemtsov31d26ec2010-10-16 21:49:52 +02004413 ret = wl1271_fetch_nvs(wl);
4414 if (ret == 0) {
Shahar Levibc765bf2011-03-06 16:32:10 +02004415 /* NOTE: The wl->nvs->nvs element must be first, in
4416 * order to simplify the casting, we assume it is at
4417 * the beginning of the wl->nvs structure.
4418 */
4419 u8 *nvs_ptr = (u8 *)wl->nvs;
Arik Nemtsov31d26ec2010-10-16 21:49:52 +02004420
4421 wl->mac_addr[0] = nvs_ptr[11];
4422 wl->mac_addr[1] = nvs_ptr[10];
4423 wl->mac_addr[2] = nvs_ptr[6];
4424 wl->mac_addr[3] = nvs_ptr[5];
4425 wl->mac_addr[4] = nvs_ptr[4];
4426 wl->mac_addr[5] = nvs_ptr[3];
4427 }
4428
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004429 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
4430
4431 ret = ieee80211_register_hw(wl->hw);
4432 if (ret < 0) {
4433 wl1271_error("unable to register mac80211 hw: %d", ret);
4434 return ret;
4435 }
4436
4437 wl->mac80211_registered = true;
4438
Eliad Pellerd60080a2010-11-24 12:53:16 +02004439 wl1271_debugfs_init(wl);
4440
Juuso Oikarinenc2c192a2010-07-27 03:30:09 +03004441 register_netdevice_notifier(&wl1271_dev_notifier);
4442
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004443 wl1271_notice("loaded");
4444
4445 return 0;
4446}
Teemu Paasikivi50b3eb42010-02-22 08:38:26 +02004447EXPORT_SYMBOL_GPL(wl1271_register_hw);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004448
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02004449void wl1271_unregister_hw(struct wl1271 *wl)
4450{
Juuso Oikarinen4ae3fa82011-01-14 12:48:46 +01004451 if (wl->state == WL1271_STATE_PLT)
4452 __wl1271_plt_stop(wl);
4453
Juuso Oikarinenc2c192a2010-07-27 03:30:09 +03004454 unregister_netdevice_notifier(&wl1271_dev_notifier);
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02004455 ieee80211_unregister_hw(wl->hw);
4456 wl->mac80211_registered = false;
4457
4458}
4459EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
4460
Teemu Paasikivi2d5e82b2010-02-22 08:38:21 +02004461int wl1271_init_ieee80211(struct wl1271 *wl)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004462{
Juuso Oikarinen7a557242010-09-27 12:42:07 +02004463 static const u32 cipher_suites[] = {
4464 WLAN_CIPHER_SUITE_WEP40,
4465 WLAN_CIPHER_SUITE_WEP104,
4466 WLAN_CIPHER_SUITE_TKIP,
4467 WLAN_CIPHER_SUITE_CCMP,
4468 WL1271_CIPHER_SUITE_GEM,
4469 };
4470
Juuso Oikarinen1e2b7972009-10-08 21:56:20 +03004471 /* The tx descriptor buffer and the TKIP space. */
4472 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
4473 sizeof(struct wl1271_tx_hw_descr);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004474
4475 /* unit us */
4476 /* FIXME: find a proper value */
4477 wl->hw->channel_change_time = 10000;
Juuso Oikarinen50c500a2010-04-01 11:38:22 +03004478 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004479
4480 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
Juuso Oikarinen03442a32009-11-23 23:22:14 +02004481 IEEE80211_HW_BEACON_FILTER |
Juuso Oikarinen0a343322010-02-22 08:38:41 +02004482 IEEE80211_HW_SUPPORTS_PS |
Kalle Valo4695dc92010-03-18 12:26:38 +02004483 IEEE80211_HW_SUPPORTS_UAPSD |
Juuso Oikarinena9af0922010-03-26 12:53:30 +02004484 IEEE80211_HW_HAS_RATE_CONTROL |
Juuso Oikarinen00236aed2010-04-09 11:07:30 +03004485 IEEE80211_HW_CONNECTION_MONITOR |
Eliad Peller62c07402011-02-02 11:20:05 +02004486 IEEE80211_HW_SUPPORTS_CQM_RSSI |
Luciano Coelho25eaea302011-05-02 12:37:33 +03004487 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
Shahar Levifcd23b62011-05-11 12:12:56 +03004488 IEEE80211_HW_SPECTRUM_MGMT |
Arik Nemtsovba7c0822011-02-23 00:22:28 +02004489 IEEE80211_HW_AP_LINK_PS;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004490
Juuso Oikarinen7a557242010-09-27 12:42:07 +02004491 wl->hw->wiphy->cipher_suites = cipher_suites;
4492 wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
4493
Juuso Oikarinene0d8bbf2009-12-11 15:41:04 +02004494 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
Arik Nemtsov038d9252010-10-16 21:53:24 +02004495 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004496 wl->hw->wiphy->max_scan_ssids = 1;
Luciano Coelhof9520792011-08-23 18:34:44 +03004497 wl->hw->wiphy->max_sched_scan_ssids = 8;
Guy Eilamea559b42010-12-09 16:54:59 +02004498 /*
4499 * Maximum length of elements in scanning probe request templates
4500 * should be the maximum length possible for a template, without
4501 * the IEEE80211 header of the template
4502 */
Eliad Peller154037d2011-08-14 13:17:12 +03004503 wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_DFLT_SIZE -
Guy Eilamea559b42010-12-09 16:54:59 +02004504 sizeof(struct ieee80211_header);
Luciano Coelhoa8aaaf52011-01-11 18:25:18 +01004505
Luciano Coelho4a31c112011-03-21 23:16:14 +02004506 /* make sure all our channels fit in the scanned_ch bitmask */
4507 BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) +
4508 ARRAY_SIZE(wl1271_channels_5ghz) >
4509 WL1271_MAX_CHANNELS);
Luciano Coelhoa8aaaf52011-01-11 18:25:18 +01004510 /*
4511 * We keep local copies of the band structs because we need to
4512 * modify them on a per-device basis.
4513 */
4514 memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
4515 sizeof(wl1271_band_2ghz));
4516 memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
4517 sizeof(wl1271_band_5ghz));
4518
4519 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
4520 &wl->bands[IEEE80211_BAND_2GHZ];
4521 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
4522 &wl->bands[IEEE80211_BAND_5GHZ];
Teemu Paasikivi1ebec3d2009-10-13 12:47:48 +03004523
Kalle Valo12bd8942010-03-18 12:26:33 +02004524 wl->hw->queues = 4;
Juuso Oikarinen31627dc2010-03-26 12:53:12 +02004525 wl->hw->max_rates = 1;
Kalle Valo12bd8942010-03-18 12:26:33 +02004526
Juuso Oikarinenb7417d92010-11-10 11:27:19 +01004527 wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
4528
Teemu Paasikivi8197b712010-02-22 08:38:23 +02004529 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004530
Arik Nemtsovf84f7d72010-10-16 20:21:23 +02004531 wl->hw->sta_data_size = sizeof(struct wl1271_station);
4532
Luciano Coelho4c9cfa72011-01-12 14:27:03 +01004533 wl->hw->max_rx_aggregation_subframes = 8;
4534
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004535 return 0;
4536}
Teemu Paasikivi50b3eb42010-02-22 08:38:26 +02004537EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004538
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004539#define WL1271_DEFAULT_CHANNEL 0
Teemu Paasikivic332a4b2010-02-18 13:25:57 +02004540
Teemu Paasikivi2d5e82b2010-02-22 08:38:21 +02004541struct ieee80211_hw *wl1271_alloc_hw(void)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004542{
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004543 struct ieee80211_hw *hw;
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02004544 struct platform_device *plat_dev = NULL;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004545 struct wl1271 *wl;
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +02004546 int i, j, ret;
Ido Yariv1f37cbc2010-09-30 13:28:27 +02004547 unsigned int order;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004548
4549 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
4550 if (!hw) {
4551 wl1271_error("could not alloc ieee80211_hw");
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02004552 ret = -ENOMEM;
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02004553 goto err_hw_alloc;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004554 }
4555
Julia Lawall929ebd32010-05-15 23:16:39 +02004556 plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02004557 if (!plat_dev) {
4558 wl1271_error("could not allocate platform_device");
4559 ret = -ENOMEM;
4560 goto err_plat_alloc;
4561 }
4562
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004563 wl = hw->priv;
4564 memset(wl, 0, sizeof(*wl));
4565
Juuso Oikarinen01c09162009-10-13 12:47:55 +03004566 INIT_LIST_HEAD(&wl->list);
4567
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004568 wl->hw = hw;
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02004569 wl->plat_dev = plat_dev;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004570
Juuso Oikarinen6742f552010-12-13 09:52:37 +02004571 for (i = 0; i < NUM_TX_QUEUES; i++)
4572 skb_queue_head_init(&wl->tx_queue[i]);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004573
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +02004574 for (i = 0; i < NUM_TX_QUEUES; i++)
4575 for (j = 0; j < AP_MAX_LINKS; j++)
4576 skb_queue_head_init(&wl->links[j].tx_queue[i]);
4577
Ido Yariva6208652011-03-01 15:14:41 +02004578 skb_queue_head_init(&wl->deferred_rx_queue);
4579 skb_queue_head_init(&wl->deferred_tx_queue);
4580
Juuso Oikarinen37b70a82009-10-08 21:56:21 +03004581 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
Juuso Oikarinen90494a92010-07-08 17:50:00 +03004582 INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
Ido Yariva6208652011-03-01 15:14:41 +02004583 INIT_WORK(&wl->netstack_work, wl1271_netstack_work);
Juuso Oikarinen117b38d2010-09-30 10:43:28 +02004584 INIT_WORK(&wl->tx_work, wl1271_tx_work);
4585 INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
4586 INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
Eliad Peller77ddaa12011-05-15 11:10:29 +03004587 INIT_WORK(&wl->rx_streaming_enable_work,
4588 wl1271_rx_streaming_enable_work);
4589 INIT_WORK(&wl->rx_streaming_disable_work,
4590 wl1271_rx_streaming_disable_work);
4591
Eliad Peller92ef8962011-06-07 12:50:46 +03004592 wl->freezable_wq = create_freezable_workqueue("wl12xx_wq");
4593 if (!wl->freezable_wq) {
4594 ret = -ENOMEM;
4595 goto err_hw;
4596 }
4597
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004598 wl->channel = WL1271_DEFAULT_CHANNEL;
Juuso Oikarinen60e84c22010-03-26 12:53:25 +02004599 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004600 wl->default_key = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004601 wl->rx_counter = 0;
Juuso Oikarinen19ad0712009-11-02 20:22:11 +02004602 wl->psm_entry_retry = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004603 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
Juuso Oikarinena6fe2312009-12-11 15:40:58 +02004604 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03004605 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
Juuso Oikarinen830fb672009-12-11 15:41:06 +02004606 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
Juuso Oikarinen8a5a37a2009-10-08 21:56:24 +03004607 wl->band = IEEE80211_BAND_2GHZ;
Juuso Oikarinenb771eee2009-10-08 21:56:34 +03004608 wl->vif = NULL;
Juuso Oikarinen830fb672009-12-11 15:41:06 +02004609 wl->flags = 0;
Juuso Oikarinen7fc3a862010-03-18 12:26:32 +02004610 wl->sg_enabled = true;
Juuso Oikarinend717fd62010-05-07 11:38:58 +03004611 wl->hw_pg_ver = -1;
Arik Nemtsov166d5042010-10-16 21:44:57 +02004612 wl->bss_type = MAX_BSS_TYPE;
4613 wl->set_bss_type = MAX_BSS_TYPE;
Arik Nemtsova8c0ddb2011-02-23 00:22:26 +02004614 wl->last_tx_hlid = 0;
Arik Nemtsovb622d992011-02-23 00:22:31 +02004615 wl->ap_ps_map = 0;
4616 wl->ap_fw_ps_map = 0;
Ido Yariv606ea9f2011-03-01 15:14:39 +02004617 wl->quirks = 0;
Ido Yariv341b7cd2011-03-31 10:07:01 +02004618 wl->platform_quirks = 0;
Luciano Coelho33c2c062011-05-10 14:46:02 +03004619 wl->sched_scanning = false;
Oz Krakowskib992c682011-06-26 10:36:02 +03004620 wl->tx_security_seq = 0;
4621 wl->tx_security_last_seq_lsb = 0;
Guy Eilame9eb8cb2011-08-16 19:49:12 +03004622 wl->tx_spare_blocks = TX_HW_BLOCK_SPARE_DEFAULT;
Eliad Peller7f0979882011-08-14 13:17:06 +03004623 wl->role_id = WL12XX_INVALID_ROLE_ID;
Eliad Pellerf4df1bd2011-08-14 13:17:15 +03004624 wl->system_hlid = WL12XX_SYSTEM_HLID;
Eliad Peller7f0979882011-08-14 13:17:06 +03004625 wl->sta_hlid = WL12XX_INVALID_LINK_ID;
Eliad Peller04e80792011-08-14 13:17:09 +03004626 wl->dev_role_id = WL12XX_INVALID_ROLE_ID;
4627 wl->dev_hlid = WL12XX_INVALID_LINK_ID;
Arik Nemtsov712e9bf2011-08-14 13:17:20 +03004628 wl->session_counter = 0;
Arik Nemtsove51ae9b2011-08-14 13:17:21 +03004629 wl->ap_bcast_hlid = WL12XX_INVALID_LINK_ID;
4630 wl->ap_global_hlid = WL12XX_INVALID_LINK_ID;
Eliad Peller77ddaa12011-05-15 11:10:29 +03004631 setup_timer(&wl->rx_streaming_timer, wl1271_rx_streaming_timer,
4632 (unsigned long) wl);
Ido Yariv95dac04f2011-06-06 14:57:06 +03004633 wl->fwlog_size = 0;
4634 init_waitqueue_head(&wl->fwlog_waitq);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004635
Eliad Pellerf4df1bd2011-08-14 13:17:15 +03004636 /* The system link is always allocated */
4637 __set_bit(WL12XX_SYSTEM_HLID, wl->links_map);
4638
Ido Yariv25eeb9e2010-10-12 16:20:06 +02004639 memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
Juuso Oikarinenbe7078c2009-10-08 21:56:26 +03004640 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004641 wl->tx_frames[i] = NULL;
4642
4643 spin_lock_init(&wl->wl_lock);
4644
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03004645 wl->state = WL1271_STATE_OFF;
4646 mutex_init(&wl->mutex);
4647
Teemu Paasikivic332a4b2010-02-18 13:25:57 +02004648 /* Apply default driver configuration. */
4649 wl1271_conf_init(wl);
4650
Ido Yariv1f37cbc2010-09-30 13:28:27 +02004651 order = get_order(WL1271_AGGR_BUFFER_SIZE);
4652 wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
4653 if (!wl->aggr_buf) {
4654 ret = -ENOMEM;
Eliad Peller92ef8962011-06-07 12:50:46 +03004655 goto err_wq;
Ido Yariv1f37cbc2010-09-30 13:28:27 +02004656 }
4657
Ido Yariv990f5de2011-03-31 10:06:59 +02004658 wl->dummy_packet = wl12xx_alloc_dummy_packet(wl);
4659 if (!wl->dummy_packet) {
4660 ret = -ENOMEM;
4661 goto err_aggr;
4662 }
4663
Ido Yariv95dac04f2011-06-06 14:57:06 +03004664 /* Allocate one page for the FW log */
4665 wl->fwlog = (u8 *)get_zeroed_page(GFP_KERNEL);
4666 if (!wl->fwlog) {
4667 ret = -ENOMEM;
4668 goto err_dummy_packet;
4669 }
4670
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02004671 /* Register platform device */
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02004672 ret = platform_device_register(wl->plat_dev);
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02004673 if (ret) {
4674 wl1271_error("couldn't register platform device");
Ido Yariv95dac04f2011-06-06 14:57:06 +03004675 goto err_fwlog;
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02004676 }
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02004677 dev_set_drvdata(&wl->plat_dev->dev, wl);
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02004678
Juuso Oikarinen7fc3a862010-03-18 12:26:32 +02004679 /* Create sysfs file to control bt coex state */
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02004680 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
Juuso Oikarinen7fc3a862010-03-18 12:26:32 +02004681 if (ret < 0) {
4682 wl1271_error("failed to create sysfs file bt_coex_state");
4683 goto err_platform;
4684 }
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02004685
Juuso Oikarinend717fd62010-05-07 11:38:58 +03004686 /* Create sysfs file to get HW PG version */
4687 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4688 if (ret < 0) {
4689 wl1271_error("failed to create sysfs file hw_pg_ver");
4690 goto err_bt_coex_state;
4691 }
4692
Ido Yariv95dac04f2011-06-06 14:57:06 +03004693 /* Create sysfs file for the FW log */
4694 ret = device_create_bin_file(&wl->plat_dev->dev, &fwlog_attr);
4695 if (ret < 0) {
4696 wl1271_error("failed to create sysfs file fwlog");
4697 goto err_hw_pg_ver;
4698 }
4699
Teemu Paasikivic332a4b2010-02-18 13:25:57 +02004700 return hw;
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02004701
Ido Yariv95dac04f2011-06-06 14:57:06 +03004702err_hw_pg_ver:
4703 device_remove_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4704
Juuso Oikarinend717fd62010-05-07 11:38:58 +03004705err_bt_coex_state:
4706 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
4707
Juuso Oikarinen7fc3a862010-03-18 12:26:32 +02004708err_platform:
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02004709 platform_device_unregister(wl->plat_dev);
Juuso Oikarinen7fc3a862010-03-18 12:26:32 +02004710
Ido Yariv95dac04f2011-06-06 14:57:06 +03004711err_fwlog:
4712 free_page((unsigned long)wl->fwlog);
4713
Ido Yariv990f5de2011-03-31 10:06:59 +02004714err_dummy_packet:
4715 dev_kfree_skb(wl->dummy_packet);
4716
Ido Yariv1f37cbc2010-09-30 13:28:27 +02004717err_aggr:
4718 free_pages((unsigned long)wl->aggr_buf, order);
4719
Eliad Peller92ef8962011-06-07 12:50:46 +03004720err_wq:
4721 destroy_workqueue(wl->freezable_wq);
4722
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02004723err_hw:
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02004724 wl1271_debugfs_exit(wl);
4725 kfree(plat_dev);
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02004726
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02004727err_plat_alloc:
4728 ieee80211_free_hw(hw);
4729
4730err_hw_alloc:
4731
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02004732 return ERR_PTR(ret);
Teemu Paasikivic332a4b2010-02-18 13:25:57 +02004733}
Teemu Paasikivi50b3eb42010-02-22 08:38:26 +02004734EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
Teemu Paasikivic332a4b2010-02-18 13:25:57 +02004735
4736int wl1271_free_hw(struct wl1271 *wl)
4737{
Ido Yariv95dac04f2011-06-06 14:57:06 +03004738 /* Unblock any fwlog readers */
4739 mutex_lock(&wl->mutex);
4740 wl->fwlog_size = -1;
4741 wake_up_interruptible_all(&wl->fwlog_waitq);
4742 mutex_unlock(&wl->mutex);
4743
4744 device_remove_bin_file(&wl->plat_dev->dev, &fwlog_attr);
Gery Kahn6f07b722011-07-18 14:21:49 +03004745
4746 device_remove_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4747
4748 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02004749 platform_device_unregister(wl->plat_dev);
Ido Yariv95dac04f2011-06-06 14:57:06 +03004750 free_page((unsigned long)wl->fwlog);
Ido Yariv990f5de2011-03-31 10:06:59 +02004751 dev_kfree_skb(wl->dummy_packet);
Ido Yariv1f37cbc2010-09-30 13:28:27 +02004752 free_pages((unsigned long)wl->aggr_buf,
4753 get_order(WL1271_AGGR_BUFFER_SIZE));
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02004754 kfree(wl->plat_dev);
Teemu Paasikivic332a4b2010-02-18 13:25:57 +02004755
4756 wl1271_debugfs_exit(wl);
4757
Teemu Paasikivic332a4b2010-02-18 13:25:57 +02004758 vfree(wl->fw);
4759 wl->fw = NULL;
4760 kfree(wl->nvs);
4761 wl->nvs = NULL;
4762
4763 kfree(wl->fw_status);
4764 kfree(wl->tx_res_if);
Eliad Peller92ef8962011-06-07 12:50:46 +03004765 destroy_workqueue(wl->freezable_wq);
Teemu Paasikivic332a4b2010-02-18 13:25:57 +02004766
4767 ieee80211_free_hw(wl->hw);
4768
4769 return 0;
4770}
Teemu Paasikivi50b3eb42010-02-22 08:38:26 +02004771EXPORT_SYMBOL_GPL(wl1271_free_hw);
4772
Guy Eilam491bbd62011-01-12 10:33:29 +01004773u32 wl12xx_debug_level = DEBUG_NONE;
Eliad Peller17c17552010-12-12 12:15:35 +02004774EXPORT_SYMBOL_GPL(wl12xx_debug_level);
Guy Eilam491bbd62011-01-12 10:33:29 +01004775module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
Eliad Peller17c17552010-12-12 12:15:35 +02004776MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
4777
Ido Yariv95dac04f2011-06-06 14:57:06 +03004778module_param_named(fwlog, fwlog_param, charp, 0);
4779MODULE_PARM_DESC(keymap,
4780 "FW logger options: continuous, ondemand, dbgpins or disable");
4781
Eliad Peller2a5bff02011-08-25 18:10:59 +03004782module_param(bug_on_recovery, bool, S_IRUSR | S_IWUSR);
4783MODULE_PARM_DESC(bug_on_recovery, "BUG() on fw recovery");
4784
Teemu Paasikivi50b3eb42010-02-22 08:38:26 +02004785MODULE_LICENSE("GPL");
Luciano Coelhob1a48ca2011-02-22 14:19:28 +02004786MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
Teemu Paasikivi50b3eb42010-02-22 08:38:26 +02004787MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");