blob: 0f16307137a20a4609f97dda8699cbd3028d4cd6 [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>
Luciano Coelhof5fc0f82009-08-06 16:25:28 +030033
Shahar Levi00d20102010-11-08 11:20:10 +000034#include "wl12xx.h"
Luciano Coelhof5fc0f82009-08-06 16:25:28 +030035#include "wl12xx_80211.h"
Shahar Levi00d20102010-11-08 11:20:10 +000036#include "reg.h"
37#include "io.h"
38#include "event.h"
39#include "tx.h"
40#include "rx.h"
41#include "ps.h"
42#include "init.h"
43#include "debugfs.h"
44#include "cmd.h"
45#include "boot.h"
46#include "testmode.h"
47#include "scan.h"
Luciano Coelhof5fc0f82009-08-06 16:25:28 +030048
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +020049#define WL1271_BOOT_RETRIES 3
50
Juuso Oikarinen8a080482009-10-13 12:47:44 +030051static struct conf_drv_settings default_conf = {
52 .sg = {
Juuso Oikarinen1b00f542010-03-18 12:26:30 +020053 .params = {
54 [CONF_SG_BT_PER_THRESHOLD] = 7500,
55 [CONF_SG_HV3_MAX_OVERRIDE] = 0,
56 [CONF_SG_BT_NFS_SAMPLE_INTERVAL] = 400,
57 [CONF_SG_BT_LOAD_RATIO] = 50,
Juuso Oikarinen8d2ef7b2010-07-08 17:50:03 +030058 [CONF_SG_AUTO_PS_MODE] = 1,
Juuso Oikarinen1b00f542010-03-18 12:26:30 +020059 [CONF_SG_AUTO_SCAN_PROBE_REQ] = 170,
60 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3] = 50,
61 [CONF_SG_ANTENNA_CONFIGURATION] = 0,
62 [CONF_SG_BEACON_MISS_PERCENT] = 60,
63 [CONF_SG_RATE_ADAPT_THRESH] = 12,
64 [CONF_SG_RATE_ADAPT_SNR] = 0,
65 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR] = 10,
66 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR] = 30,
67 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR] = 8,
68 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR] = 20,
69 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR] = 50,
70 /* Note: with UPSD, this should be 4 */
71 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR] = 8,
72 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR] = 7,
73 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR] = 25,
74 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR] = 20,
75 /* Note: with UPDS, this should be 15 */
76 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR] = 8,
77 /* Note: with UPDS, this should be 50 */
78 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR] = 40,
79 /* Note: with UPDS, this should be 10 */
80 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR] = 20,
81 [CONF_SG_RXT] = 1200,
82 [CONF_SG_TXT] = 1000,
83 [CONF_SG_ADAPTIVE_RXT_TXT] = 1,
84 [CONF_SG_PS_POLL_TIMEOUT] = 10,
85 [CONF_SG_UPSD_TIMEOUT] = 10,
86 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7,
87 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15,
88 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15,
89 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR] = 8,
90 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR] = 20,
91 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR] = 15,
92 [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR] = 20,
93 [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR] = 50,
94 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR] = 10,
95 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3] = 200,
96 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800,
97 [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME] = 75,
98 [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME] = 15,
99 [CONF_SG_HV3_MAX_SERVED] = 6,
100 [CONF_SG_DHCP_TIME] = 5000,
101 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP] = 100,
102 },
103 .state = CONF_SG_PROTECTIVE,
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300104 },
105 .rx = {
106 .rx_msdu_life_time = 512000,
107 .packet_detection_threshold = 0,
108 .ps_poll_timeout = 15,
109 .upsd_timeout = 15,
110 .rts_threshold = 2347,
Luciano Coelho3ed8f2c2009-12-11 15:40:54 +0200111 .rx_cca_threshold = 0,
112 .irq_blk_threshold = 0xFFFF,
113 .irq_pkt_threshold = 0,
114 .irq_timeout = 600,
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300115 .queue_type = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
116 },
117 .tx = {
118 .tx_energy_detection = 0,
Arik Nemtsov1e05a812010-10-16 17:44:51 +0200119 .sta_rc_conf = {
Juuso Oikarinenebba60c2010-04-01 11:38:20 +0300120 .enabled_rates = 0,
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300121 .short_retry_limit = 10,
122 .long_retry_limit = 10,
Arik Nemtsov1e05a812010-10-16 17:44:51 +0200123 .aflags = 0,
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300124 },
125 .ac_conf_count = 4,
126 .ac_conf = {
Juuso Oikarinen9987a9d2010-09-01 11:31:12 +0200127 [CONF_TX_AC_BE] = {
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300128 .ac = CONF_TX_AC_BE,
129 .cw_min = 15,
130 .cw_max = 63,
131 .aifsn = 3,
132 .tx_op_limit = 0,
133 },
Juuso Oikarinen9987a9d2010-09-01 11:31:12 +0200134 [CONF_TX_AC_BK] = {
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300135 .ac = CONF_TX_AC_BK,
136 .cw_min = 15,
137 .cw_max = 63,
138 .aifsn = 7,
139 .tx_op_limit = 0,
140 },
Juuso Oikarinen9987a9d2010-09-01 11:31:12 +0200141 [CONF_TX_AC_VI] = {
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300142 .ac = CONF_TX_AC_VI,
143 .cw_min = 15,
144 .cw_max = 63,
145 .aifsn = CONF_TX_AIFS_PIFS,
146 .tx_op_limit = 3008,
147 },
Juuso Oikarinen9987a9d2010-09-01 11:31:12 +0200148 [CONF_TX_AC_VO] = {
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300149 .ac = CONF_TX_AC_VO,
150 .cw_min = 15,
151 .cw_max = 63,
152 .aifsn = CONF_TX_AIFS_PIFS,
153 .tx_op_limit = 1504,
154 },
155 },
Arik Nemtsov1e05a812010-10-16 17:44:51 +0200156 .ap_rc_conf = {
157 [0] = {
158 .enabled_rates = CONF_TX_AP_ENABLED_RATES,
159 .short_retry_limit = 10,
160 .long_retry_limit = 10,
161 .aflags = 0,
162 },
163 [1] = {
164 .enabled_rates = CONF_TX_AP_ENABLED_RATES,
165 .short_retry_limit = 10,
166 .long_retry_limit = 10,
167 .aflags = 0,
168 },
169 [2] = {
170 .enabled_rates = CONF_TX_AP_ENABLED_RATES,
171 .short_retry_limit = 10,
172 .long_retry_limit = 10,
173 .aflags = 0,
174 },
175 [3] = {
176 .enabled_rates = CONF_TX_AP_ENABLED_RATES,
177 .short_retry_limit = 10,
178 .long_retry_limit = 10,
179 .aflags = 0,
180 },
181 },
182 .ap_mgmt_conf = {
183 .enabled_rates = CONF_TX_AP_DEFAULT_MGMT_RATES,
184 .short_retry_limit = 10,
185 .long_retry_limit = 10,
186 .aflags = 0,
187 },
188 .ap_bcst_conf = {
189 .enabled_rates = CONF_HW_BIT_RATE_1MBPS,
190 .short_retry_limit = 10,
191 .long_retry_limit = 10,
192 .aflags = 0,
193 },
Arik Nemtsov79b223f2010-10-16 17:52:59 +0200194 .ap_max_tx_retries = 100,
Juuso Oikarinen9987a9d2010-09-01 11:31:12 +0200195 .tid_conf_count = 4,
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300196 .tid_conf = {
Juuso Oikarinen9987a9d2010-09-01 11:31:12 +0200197 [CONF_TX_AC_BE] = {
198 .queue_id = CONF_TX_AC_BE,
199 .channel_type = CONF_CHANNEL_TYPE_EDCF,
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300200 .tsid = CONF_TX_AC_BE,
201 .ps_scheme = CONF_PS_SCHEME_LEGACY,
202 .ack_policy = CONF_ACK_POLICY_LEGACY,
203 .apsd_conf = {0, 0},
204 },
Juuso Oikarinen9987a9d2010-09-01 11:31:12 +0200205 [CONF_TX_AC_BK] = {
206 .queue_id = CONF_TX_AC_BK,
207 .channel_type = CONF_CHANNEL_TYPE_EDCF,
208 .tsid = CONF_TX_AC_BK,
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300209 .ps_scheme = CONF_PS_SCHEME_LEGACY,
210 .ack_policy = CONF_ACK_POLICY_LEGACY,
211 .apsd_conf = {0, 0},
212 },
Juuso Oikarinen9987a9d2010-09-01 11:31:12 +0200213 [CONF_TX_AC_VI] = {
214 .queue_id = CONF_TX_AC_VI,
215 .channel_type = CONF_CHANNEL_TYPE_EDCF,
216 .tsid = CONF_TX_AC_VI,
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300217 .ps_scheme = CONF_PS_SCHEME_LEGACY,
218 .ack_policy = CONF_ACK_POLICY_LEGACY,
219 .apsd_conf = {0, 0},
220 },
Juuso Oikarinen9987a9d2010-09-01 11:31:12 +0200221 [CONF_TX_AC_VO] = {
222 .queue_id = CONF_TX_AC_VO,
223 .channel_type = CONF_CHANNEL_TYPE_EDCF,
224 .tsid = CONF_TX_AC_VO,
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300225 .ps_scheme = CONF_PS_SCHEME_LEGACY,
226 .ack_policy = CONF_ACK_POLICY_LEGACY,
227 .apsd_conf = {0, 0},
228 },
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300229 },
230 .frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD,
Luciano Coelho3ed8f2c2009-12-11 15:40:54 +0200231 .tx_compl_timeout = 700,
Juuso Oikarinenebba60c2010-04-01 11:38:20 +0300232 .tx_compl_threshold = 4,
233 .basic_rate = CONF_HW_BIT_RATE_1MBPS,
234 .basic_rate_5 = CONF_HW_BIT_RATE_6MBPS,
Arik Nemtsov1e05a812010-10-16 17:44:51 +0200235 .tmpl_short_retry_limit = 10,
236 .tmpl_long_retry_limit = 10,
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300237 },
238 .conn = {
239 .wake_up_event = CONF_WAKE_UP_EVENT_DTIM,
Juuso Oikarinen50c500a2010-04-01 11:38:22 +0300240 .listen_interval = 1,
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300241 .bcn_filt_mode = CONF_BCN_FILT_MODE_ENABLED,
242 .bcn_filt_ie_count = 1,
243 .bcn_filt_ie = {
244 [0] = {
245 .ie = WLAN_EID_CHANNEL_SWITCH,
246 .rule = CONF_BCN_RULE_PASS_ON_APPEARANCE,
247 }
248 },
Luciano Coelho3ed8f2c2009-12-11 15:40:54 +0200249 .synch_fail_thold = 10,
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300250 .bss_lose_timeout = 100,
251 .beacon_rx_timeout = 10000,
252 .broadcast_timeout = 20000,
253 .rx_broadcast_in_ps = 1,
Juuso Oikarinen90494a92010-07-08 17:50:00 +0300254 .ps_poll_threshold = 10,
255 .ps_poll_recovery_period = 700,
Juuso Oikarinen11f70f92009-10-13 12:47:46 +0300256 .bet_enable = CONF_BET_MODE_ENABLE,
Juuso Oikarinen84502562009-11-23 23:22:12 +0200257 .bet_max_consecutive = 10,
Juuso Oikarinen8eab7b42010-09-24 03:10:11 +0200258 .psm_entry_retries = 5,
259 .psm_entry_nullfunc_retries = 3,
260 .psm_entry_hangover_period = 1,
Juuso Oikarinen50c500a2010-04-01 11:38:22 +0300261 .keep_alive_interval = 55000,
262 .max_listen_interval = 20,
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300263 },
Luciano Coelho6e92b412009-12-11 15:40:50 +0200264 .itrim = {
265 .enable = false,
266 .timeout = 50000,
Juuso Oikarinen38ad2d82009-12-11 15:41:08 +0200267 },
268 .pm_config = {
269 .host_clk_settling_time = 5000,
270 .host_fast_wakeup_support = false
Juuso Oikarinen00236aed2010-04-09 11:07:30 +0300271 },
272 .roam_trigger = {
Juuso Oikarinen00236aed2010-04-09 11:07:30 +0300273 .trigger_pacing = 1,
274 .avg_weight_rssi_beacon = 20,
275 .avg_weight_rssi_data = 10,
276 .avg_weight_snr_beacon = 20,
277 .avg_weight_snr_data = 10
Juuso Oikarinenbea39d62010-09-21 08:14:31 +0200278 },
279 .scan = {
280 .min_dwell_time_active = 7500,
281 .max_dwell_time_active = 30000,
282 .min_dwell_time_passive = 30000,
283 .max_dwell_time_passive = 60000,
284 .num_probe_reqs = 2,
285 },
Juuso Oikarinen644a4862010-10-05 13:11:56 +0200286 .rf = {
287 .tx_per_channel_power_compensation_2 = {
288 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
289 },
290 .tx_per_channel_power_compensation_5 = {
291 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
292 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
293 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
294 },
295 },
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300296};
297
Juuso Oikarinen52b0e7a2010-09-21 06:23:31 +0200298static void __wl1271_op_remove_interface(struct wl1271 *wl);
299
300
Juuso Oikarinena1dd8182010-03-18 12:26:31 +0200301static void wl1271_device_release(struct device *dev)
302{
303
304}
305
306static struct platform_device wl1271_device = {
307 .name = "wl1271",
308 .id = -1,
309
310 /* device model insists to have a release function */
311 .dev = {
312 .release = wl1271_device_release,
313 },
314};
315
Juuso Oikarinen01c09162009-10-13 12:47:55 +0300316static LIST_HEAD(wl_list);
317
Juuso Oikarinenc2c192a2010-07-27 03:30:09 +0300318static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
319 void *arg)
320{
321 struct net_device *dev = arg;
322 struct wireless_dev *wdev;
323 struct wiphy *wiphy;
324 struct ieee80211_hw *hw;
325 struct wl1271 *wl;
326 struct wl1271 *wl_temp;
327 int ret = 0;
328
329 /* Check that this notification is for us. */
330 if (what != NETDEV_CHANGE)
331 return NOTIFY_DONE;
332
333 wdev = dev->ieee80211_ptr;
334 if (wdev == NULL)
335 return NOTIFY_DONE;
336
337 wiphy = wdev->wiphy;
338 if (wiphy == NULL)
339 return NOTIFY_DONE;
340
341 hw = wiphy_priv(wiphy);
342 if (hw == NULL)
343 return NOTIFY_DONE;
344
345 wl_temp = hw->priv;
346 list_for_each_entry(wl, &wl_list, list) {
347 if (wl == wl_temp)
348 break;
349 }
350 if (wl != wl_temp)
351 return NOTIFY_DONE;
352
353 mutex_lock(&wl->mutex);
354
355 if (wl->state == WL1271_STATE_OFF)
356 goto out;
357
358 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
359 goto out;
360
361 ret = wl1271_ps_elp_wakeup(wl, false);
362 if (ret < 0)
363 goto out;
364
365 if ((dev->operstate == IF_OPER_UP) &&
366 !test_and_set_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags)) {
367 wl1271_cmd_set_sta_state(wl);
368 wl1271_info("Association completed.");
369 }
370
371 wl1271_ps_elp_sleep(wl);
372
373out:
374 mutex_unlock(&wl->mutex);
375
376 return NOTIFY_OK;
377}
378
Juuso Oikarinenb7417d92010-11-10 11:27:19 +0100379static int wl1271_reg_notify(struct wiphy *wiphy,
Luciano Coelho573c67c2010-11-26 13:44:59 +0200380 struct regulatory_request *request)
381{
Juuso Oikarinenb7417d92010-11-10 11:27:19 +0100382 struct ieee80211_supported_band *band;
383 struct ieee80211_channel *ch;
384 int i;
385
386 band = wiphy->bands[IEEE80211_BAND_5GHZ];
387 for (i = 0; i < band->n_channels; i++) {
388 ch = &band->channels[i];
389 if (ch->flags & IEEE80211_CHAN_DISABLED)
390 continue;
391
392 if (ch->flags & IEEE80211_CHAN_RADAR)
393 ch->flags |= IEEE80211_CHAN_NO_IBSS |
394 IEEE80211_CHAN_PASSIVE_SCAN;
395
396 }
397
398 return 0;
399}
400
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +0300401static void wl1271_conf_init(struct wl1271 *wl)
402{
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +0300403
404 /*
405 * This function applies the default configuration to the driver. This
406 * function is invoked upon driver load (spi probe.)
407 *
408 * The configuration is stored in a run-time structure in order to
409 * facilitate for run-time adjustment of any of the parameters. Making
410 * changes to the configuration structure will apply the new values on
411 * the next interface up (wl1271_op_start.)
412 */
413
414 /* apply driver default configuration */
Juuso Oikarinen8a080482009-10-13 12:47:44 +0300415 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +0300416}
417
418
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300419static int wl1271_plt_init(struct wl1271 *wl)
420{
Luciano Coelho12419cc2010-02-18 13:25:44 +0200421 struct conf_tx_ac_category *conf_ac;
422 struct conf_tx_tid *conf_tid;
423 int ret, i;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300424
Luciano Coelho98b5dd52009-11-23 23:22:17 +0200425 ret = wl1271_cmd_general_parms(wl);
Luciano Coelho4a904062009-11-23 23:22:18 +0200426 if (ret < 0)
Luciano Coelhocc7defa2009-11-23 23:22:16 +0200427 return ret;
428
Luciano Coelho98b5dd52009-11-23 23:22:17 +0200429 ret = wl1271_cmd_radio_parms(wl);
Luciano Coelho4a904062009-11-23 23:22:18 +0200430 if (ret < 0)
Luciano Coelhocc7defa2009-11-23 23:22:16 +0200431 return ret;
432
Juuso Oikarinen644a4862010-10-05 13:11:56 +0200433 ret = wl1271_cmd_ext_radio_parms(wl);
434 if (ret < 0)
435 return ret;
436
Arik Nemtsove0fe3712010-10-16 18:19:53 +0200437 ret = wl1271_sta_init_templates_config(wl);
Luciano Coelho12419cc2010-02-18 13:25:44 +0200438 if (ret < 0)
439 return ret;
440
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300441 ret = wl1271_acx_init_mem_config(wl);
442 if (ret < 0)
443 return ret;
444
Luciano Coelho12419cc2010-02-18 13:25:44 +0200445 /* PHY layer config */
446 ret = wl1271_init_phy_config(wl);
447 if (ret < 0)
448 goto out_free_memmap;
449
450 ret = wl1271_acx_dco_itrim_params(wl);
451 if (ret < 0)
452 goto out_free_memmap;
453
454 /* Initialize connection monitoring thresholds */
Juuso Oikarinen6ccbb922010-03-26 12:53:23 +0200455 ret = wl1271_acx_conn_monit_params(wl, false);
Luciano Coelho12419cc2010-02-18 13:25:44 +0200456 if (ret < 0)
457 goto out_free_memmap;
458
459 /* Bluetooth WLAN coexistence */
460 ret = wl1271_init_pta(wl);
461 if (ret < 0)
462 goto out_free_memmap;
463
464 /* Energy detection */
465 ret = wl1271_init_energy_detection(wl);
466 if (ret < 0)
467 goto out_free_memmap;
468
469 /* Default fragmentation threshold */
Arik Nemtsov68d069c2010-11-08 10:51:07 +0100470 ret = wl1271_acx_frag_threshold(wl, wl->conf.tx.frag_threshold);
Luciano Coelho12419cc2010-02-18 13:25:44 +0200471 if (ret < 0)
472 goto out_free_memmap;
473
Juuso Oikarinen9987a9d2010-09-01 11:31:12 +0200474 /* Default TID/AC configuration */
475 BUG_ON(wl->conf.tx.tid_conf_count != wl->conf.tx.ac_conf_count);
Luciano Coelho12419cc2010-02-18 13:25:44 +0200476 for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
Juuso Oikarinen9987a9d2010-09-01 11:31:12 +0200477 conf_ac = &wl->conf.tx.ac_conf[i];
478 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
479 conf_ac->cw_max, conf_ac->aifsn,
480 conf_ac->tx_op_limit);
481 if (ret < 0)
482 goto out_free_memmap;
483
Luciano Coelho12419cc2010-02-18 13:25:44 +0200484 conf_tid = &wl->conf.tx.tid_conf[i];
485 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
486 conf_tid->channel_type,
487 conf_tid->tsid,
488 conf_tid->ps_scheme,
489 conf_tid->ack_policy,
490 conf_tid->apsd_conf[0],
491 conf_tid->apsd_conf[1]);
492 if (ret < 0)
493 goto out_free_memmap;
494 }
495
Luciano Coelho12419cc2010-02-18 13:25:44 +0200496 /* Enable data path */
Luciano Coelho94210892009-12-11 15:40:55 +0200497 ret = wl1271_cmd_data_path(wl, 1);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300498 if (ret < 0)
Luciano Coelho12419cc2010-02-18 13:25:44 +0200499 goto out_free_memmap;
500
501 /* Configure for CAM power saving (ie. always active) */
502 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
503 if (ret < 0)
504 goto out_free_memmap;
505
506 /* configure PM */
507 ret = wl1271_acx_pm_config(wl);
508 if (ret < 0)
509 goto out_free_memmap;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300510
511 return 0;
Luciano Coelho12419cc2010-02-18 13:25:44 +0200512
513 out_free_memmap:
514 kfree(wl->target_mem_map);
515 wl->target_mem_map = NULL;
516
517 return ret;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300518}
519
Juuso Oikarinenc15f63b2009-10-12 15:08:50 +0300520static void wl1271_fw_status(struct wl1271 *wl,
521 struct wl1271_fw_status *status)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300522{
Juuso Oikarinenac5e1e32010-02-22 08:38:38 +0200523 struct timespec ts;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300524 u32 total = 0;
525 int i;
526
Teemu Paasikivi09a9c2b2010-02-22 08:38:28 +0200527 wl1271_raw_read(wl, FW_STATUS_ADDR, status, sizeof(*status), false);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300528
529 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
530 "drv_rx_counter = %d, tx_results_counter = %d)",
531 status->intr,
532 status->fw_rx_counter,
533 status->drv_rx_counter,
534 status->tx_results_counter);
535
536 /* update number of available TX blocks */
537 for (i = 0; i < NUM_TX_QUEUES; i++) {
Luciano Coelhod0f63b22009-10-15 10:33:29 +0300538 u32 cnt = le32_to_cpu(status->tx_released_blks[i]) -
539 wl->tx_blocks_freed[i];
540
541 wl->tx_blocks_freed[i] =
542 le32_to_cpu(status->tx_released_blks[i]);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300543 wl->tx_blocks_available += cnt;
544 total += cnt;
545 }
546
Ido Yariva5225502010-10-12 14:49:10 +0200547 /* if more blocks are available now, tx work can be scheduled */
548 if (total)
549 clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300550
551 /* update the host-chipset time offset */
Juuso Oikarinenac5e1e32010-02-22 08:38:38 +0200552 getnstimeofday(&ts);
553 wl->time_offset = (timespec_to_ns(&ts) >> 10) -
554 (s64)le32_to_cpu(status->fw_localtime);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300555}
556
Juuso Oikarinen1e73eb62010-02-22 08:38:37 +0200557#define WL1271_IRQ_MAX_LOOPS 10
558
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300559static void wl1271_irq_work(struct work_struct *work)
560{
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300561 int ret;
Juuso Oikarinenc15f63b2009-10-12 15:08:50 +0300562 u32 intr;
Juuso Oikarinen1e73eb62010-02-22 08:38:37 +0200563 int loopcount = WL1271_IRQ_MAX_LOOPS;
564 unsigned long flags;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300565 struct wl1271 *wl =
566 container_of(work, struct wl1271, irq_work);
567
568 mutex_lock(&wl->mutex);
569
570 wl1271_debug(DEBUG_IRQ, "IRQ work");
571
Juuso Oikarinen1e73eb62010-02-22 08:38:37 +0200572 if (unlikely(wl->state == WL1271_STATE_OFF))
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300573 goto out;
574
575 ret = wl1271_ps_elp_wakeup(wl, true);
576 if (ret < 0)
577 goto out;
578
Juuso Oikarinen1e73eb62010-02-22 08:38:37 +0200579 spin_lock_irqsave(&wl->wl_lock, flags);
580 while (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags) && loopcount) {
581 clear_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags);
582 spin_unlock_irqrestore(&wl->wl_lock, flags);
583 loopcount--;
584
585 wl1271_fw_status(wl, wl->fw_status);
586 intr = le32_to_cpu(wl->fw_status->intr);
587 if (!intr) {
588 wl1271_debug(DEBUG_IRQ, "Zero interrupt received.");
Dan Carpentercdd08642010-05-08 18:25:17 +0200589 spin_lock_irqsave(&wl->wl_lock, flags);
Juuso Oikarinen1e73eb62010-02-22 08:38:37 +0200590 continue;
591 }
592
593 intr &= WL1271_INTR_MASK;
594
Eliad Pellerccc83b02010-10-27 14:09:57 +0200595 if (unlikely(intr & WL1271_ACX_INTR_WATCHDOG)) {
596 wl1271_error("watchdog interrupt received! "
597 "starting recovery.");
598 ieee80211_queue_work(wl->hw, &wl->recovery_work);
599
600 /* restarting the chip. ignore any other interrupt. */
601 goto out;
602 }
603
Juuso Oikarinen1e73eb62010-02-22 08:38:37 +0200604 if (intr & WL1271_ACX_INTR_DATA) {
605 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
606
607 /* check for tx results */
608 if (wl->fw_status->tx_results_counter !=
609 (wl->tx_results_count & 0xff))
610 wl1271_tx_complete(wl);
611
Ido Yariva5225502010-10-12 14:49:10 +0200612 /* Check if any tx blocks were freed */
613 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
Juuso Oikarinen6742f552010-12-13 09:52:37 +0200614 wl->tx_queue_count) {
Ido Yariva5225502010-10-12 14:49:10 +0200615 /*
616 * In order to avoid starvation of the TX path,
617 * call the work function directly.
618 */
619 wl1271_tx_work_locked(wl);
620 }
621
Juuso Oikarinen1e73eb62010-02-22 08:38:37 +0200622 wl1271_rx(wl, wl->fw_status);
623 }
624
625 if (intr & WL1271_ACX_INTR_EVENT_A) {
626 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
627 wl1271_event_handle(wl, 0);
628 }
629
630 if (intr & WL1271_ACX_INTR_EVENT_B) {
631 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
632 wl1271_event_handle(wl, 1);
633 }
634
635 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
636 wl1271_debug(DEBUG_IRQ,
637 "WL1271_ACX_INTR_INIT_COMPLETE");
638
639 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
640 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
641
642 spin_lock_irqsave(&wl->wl_lock, flags);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300643 }
644
Juuso Oikarinen1e73eb62010-02-22 08:38:37 +0200645 if (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags))
646 ieee80211_queue_work(wl->hw, &wl->irq_work);
647 else
648 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
649 spin_unlock_irqrestore(&wl->wl_lock, flags);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300650
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300651 wl1271_ps_elp_sleep(wl);
652
653out:
654 mutex_unlock(&wl->mutex);
655}
656
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300657static int wl1271_fetch_firmware(struct wl1271 *wl)
658{
659 const struct firmware *fw;
660 int ret;
661
Teemu Paasikivi8197b712010-02-22 08:38:23 +0200662 ret = request_firmware(&fw, WL1271_FW_NAME, wl1271_wl_to_dev(wl));
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300663
664 if (ret < 0) {
665 wl1271_error("could not get firmware: %d", ret);
666 return ret;
667 }
668
669 if (fw->size % 4) {
670 wl1271_error("firmware size is not multiple of 32 bits: %zu",
671 fw->size);
672 ret = -EILSEQ;
673 goto out;
674 }
675
676 wl->fw_len = fw->size;
Juuso Oikarinen1fba4972009-10-08 21:56:32 +0300677 wl->fw = vmalloc(wl->fw_len);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300678
679 if (!wl->fw) {
680 wl1271_error("could not allocate memory for the firmware");
681 ret = -ENOMEM;
682 goto out;
683 }
684
685 memcpy(wl->fw, fw->data, wl->fw_len);
686
687 ret = 0;
688
689out:
690 release_firmware(fw);
691
692 return ret;
693}
694
695static int wl1271_fetch_nvs(struct wl1271 *wl)
696{
697 const struct firmware *fw;
698 int ret;
699
Teemu Paasikivi8197b712010-02-22 08:38:23 +0200700 ret = request_firmware(&fw, WL1271_NVS_NAME, wl1271_wl_to_dev(wl));
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300701
702 if (ret < 0) {
703 wl1271_error("could not get nvs file: %d", ret);
704 return ret;
705 }
706
Julia Lawall929ebd32010-05-15 23:16:39 +0200707 wl->nvs = kmemdup(fw->data, sizeof(struct wl1271_nvs_file), GFP_KERNEL);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300708
709 if (!wl->nvs) {
710 wl1271_error("could not allocate memory for the nvs file");
711 ret = -ENOMEM;
712 goto out;
713 }
714
Juuso Oikarinen02fabb02010-08-19 04:41:15 +0200715 wl->nvs_len = fw->size;
716
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300717out:
718 release_firmware(fw);
719
720 return ret;
721}
722
Juuso Oikarinen52b0e7a2010-09-21 06:23:31 +0200723static void wl1271_recovery_work(struct work_struct *work)
724{
725 struct wl1271 *wl =
726 container_of(work, struct wl1271, recovery_work);
727
728 mutex_lock(&wl->mutex);
729
730 if (wl->state != WL1271_STATE_ON)
731 goto out;
732
733 wl1271_info("Hardware recovery in progress.");
734
Juuso Oikarinend25611d2010-09-30 10:43:27 +0200735 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
736 ieee80211_connection_loss(wl->vif);
737
Juuso Oikarinen52b0e7a2010-09-21 06:23:31 +0200738 /* reboot the chipset */
739 __wl1271_op_remove_interface(wl);
740 ieee80211_restart_hw(wl->hw);
741
742out:
743 mutex_unlock(&wl->mutex);
744}
745
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300746static void wl1271_fw_wakeup(struct wl1271 *wl)
747{
748 u32 elp_reg;
749
750 elp_reg = ELPCTRL_WAKE_UP;
Juuso Oikarinen74621412009-10-12 15:08:54 +0300751 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300752}
753
754static int wl1271_setup(struct wl1271 *wl)
755{
756 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
757 if (!wl->fw_status)
758 return -ENOMEM;
759
760 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
761 if (!wl->tx_res_if) {
762 kfree(wl->fw_status);
763 return -ENOMEM;
764 }
765
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300766 return 0;
767}
768
769static int wl1271_chip_wakeup(struct wl1271 *wl)
770{
Juuso Oikarinen451de972009-10-12 15:08:46 +0300771 struct wl1271_partition_set partition;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300772 int ret = 0;
773
Juuso Oikarinen01ac17ec2009-12-11 15:41:02 +0200774 msleep(WL1271_PRE_POWER_ON_SLEEP);
Ohad Ben-Cohen2cc78ff2010-09-16 01:22:04 +0200775 ret = wl1271_power_on(wl);
776 if (ret < 0)
777 goto out;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300778 msleep(WL1271_POWER_ON_SLEEP);
Teemu Paasikivi9b280722010-02-18 13:25:56 +0200779 wl1271_io_reset(wl);
780 wl1271_io_init(wl);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300781
782 /* We don't need a real memory partition here, because we only want
783 * to use the registers at this point. */
Juuso Oikarinen451de972009-10-12 15:08:46 +0300784 memset(&partition, 0, sizeof(partition));
785 partition.reg.start = REGISTERS_BASE;
786 partition.reg.size = REGISTERS_DOWN_SIZE;
787 wl1271_set_partition(wl, &partition);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300788
789 /* ELP module wake up */
790 wl1271_fw_wakeup(wl);
791
792 /* whal_FwCtrl_BootSm() */
793
794 /* 0. read chip id from CHIP_ID */
Teemu Paasikivi7b048c52010-02-18 13:25:55 +0200795 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300796
797 /* 1. check if chip id is valid */
798
799 switch (wl->chip.id) {
800 case CHIP_ID_1271_PG10:
801 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
802 wl->chip.id);
803
804 ret = wl1271_setup(wl);
805 if (ret < 0)
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +0200806 goto out;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300807 break;
808 case CHIP_ID_1271_PG20:
809 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
810 wl->chip.id);
811
812 ret = wl1271_setup(wl);
813 if (ret < 0)
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +0200814 goto out;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300815 break;
816 default:
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +0200817 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300818 ret = -ENODEV;
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +0200819 goto out;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300820 }
821
822 if (wl->fw == NULL) {
823 ret = wl1271_fetch_firmware(wl);
824 if (ret < 0)
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +0200825 goto out;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300826 }
827
828 /* No NVS from netlink, try to get it from the filesystem */
829 if (wl->nvs == NULL) {
830 ret = wl1271_fetch_nvs(wl);
831 if (ret < 0)
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +0200832 goto out;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300833 }
834
835out:
836 return ret;
837}
838
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300839int wl1271_plt_start(struct wl1271 *wl)
840{
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +0200841 int retries = WL1271_BOOT_RETRIES;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300842 int ret;
843
844 mutex_lock(&wl->mutex);
845
846 wl1271_notice("power up");
847
848 if (wl->state != WL1271_STATE_OFF) {
849 wl1271_error("cannot go into PLT state because not "
850 "in off state: %d", wl->state);
851 ret = -EBUSY;
852 goto out;
853 }
854
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +0200855 while (retries) {
856 retries--;
857 ret = wl1271_chip_wakeup(wl);
858 if (ret < 0)
859 goto power_off;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300860
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +0200861 ret = wl1271_boot(wl);
862 if (ret < 0)
863 goto power_off;
864
865 ret = wl1271_plt_init(wl);
866 if (ret < 0)
867 goto irq_disable;
868
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +0200869 wl->state = WL1271_STATE_PLT;
870 wl1271_notice("firmware booted in PLT mode (%s)",
871 wl->chip.fw_ver);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300872 goto out;
873
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +0200874irq_disable:
875 wl1271_disable_interrupts(wl);
876 mutex_unlock(&wl->mutex);
877 /* Unlocking the mutex in the middle of handling is
878 inherently unsafe. In this case we deem it safe to do,
879 because we need to let any possibly pending IRQ out of
880 the system (and while we are WL1271_STATE_OFF the IRQ
881 work function will not do anything.) Also, any other
882 possible concurrent operations will fail due to the
883 current state, hence the wl1271 struct should be safe. */
884 cancel_work_sync(&wl->irq_work);
885 mutex_lock(&wl->mutex);
886power_off:
887 wl1271_power_off(wl);
888 }
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300889
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +0200890 wl1271_error("firmware boot in PLT mode failed despite %d retries",
891 WL1271_BOOT_RETRIES);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300892out:
893 mutex_unlock(&wl->mutex);
894
895 return ret;
896}
897
898int wl1271_plt_stop(struct wl1271 *wl)
899{
900 int ret = 0;
901
902 mutex_lock(&wl->mutex);
903
904 wl1271_notice("power down");
905
906 if (wl->state != WL1271_STATE_PLT) {
907 wl1271_error("cannot power down because not in PLT "
908 "state: %d", wl->state);
909 ret = -EBUSY;
910 goto out;
911 }
912
913 wl1271_disable_interrupts(wl);
914 wl1271_power_off(wl);
915
916 wl->state = WL1271_STATE_OFF;
Luciano Coelhobd5ea182009-10-13 12:47:58 +0300917 wl->rx_counter = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300918
919out:
920 mutex_unlock(&wl->mutex);
921
Juuso Oikarinen8c7f4f32010-09-21 06:23:29 +0200922 cancel_work_sync(&wl->irq_work);
Juuso Oikarinen52b0e7a2010-09-21 06:23:31 +0200923 cancel_work_sync(&wl->recovery_work);
Juuso Oikarinen8c7f4f32010-09-21 06:23:29 +0200924
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300925 return ret;
926}
927
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300928static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
929{
930 struct wl1271 *wl = hw->priv;
Juuso Oikarinen830fb672009-12-11 15:41:06 +0200931 struct ieee80211_conf *conf = &hw->conf;
932 struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
933 struct ieee80211_sta *sta = txinfo->control.sta;
934 unsigned long flags;
Juuso Oikarinen6742f552010-12-13 09:52:37 +0200935 int q;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300936
Shahar Levi18357852010-10-13 16:09:41 +0200937 /*
938 * peek into the rates configured in the STA entry.
939 * The rates set after connection stage, The first block only BG sets:
940 * the compare is for bit 0-16 of sta_rate_set. The second block add
941 * HT rates in case of HT supported.
942 */
Juuso Oikarinen830fb672009-12-11 15:41:06 +0200943 spin_lock_irqsave(&wl->wl_lock, flags);
Shahar Levi18357852010-10-13 16:09:41 +0200944 if (sta &&
945 (sta->supp_rates[conf->channel->band] !=
946 (wl->sta_rate_set & HW_BG_RATES_MASK))) {
Juuso Oikarinen830fb672009-12-11 15:41:06 +0200947 wl->sta_rate_set = sta->supp_rates[conf->channel->band];
948 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
949 }
Shahar Levi18357852010-10-13 16:09:41 +0200950
Shahar Levi00d20102010-11-08 11:20:10 +0000951#ifdef CONFIG_WL12XX_HT
Shahar Levi18357852010-10-13 16:09:41 +0200952 if (sta &&
953 sta->ht_cap.ht_supported &&
954 ((wl->sta_rate_set >> HW_HT_RATES_OFFSET) !=
955 sta->ht_cap.mcs.rx_mask[0])) {
956 /* Clean MCS bits before setting them */
957 wl->sta_rate_set &= HW_BG_RATES_MASK;
958 wl->sta_rate_set |=
959 (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
960 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
961 }
962#endif
Juuso Oikarinen6742f552010-12-13 09:52:37 +0200963 wl->tx_queue_count++;
Juuso Oikarinen830fb672009-12-11 15:41:06 +0200964 spin_unlock_irqrestore(&wl->wl_lock, flags);
965
966 /* queue the packet */
Juuso Oikarinen6742f552010-12-13 09:52:37 +0200967 q = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
968 skb_queue_tail(&wl->tx_queue[q], skb);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300969
970 /*
971 * The chip specific setup must run before the first TX packet -
972 * before that, the tx_work will not be initialized!
973 */
974
Ido Yariva5225502010-10-12 14:49:10 +0200975 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags))
976 ieee80211_queue_work(wl->hw, &wl->tx_work);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300977
978 /*
979 * The workqueue is slow to process the tx_queue and we need stop
980 * the queue here, otherwise the queue will get too long.
981 */
Juuso Oikarinen6742f552010-12-13 09:52:37 +0200982 if (wl->tx_queue_count >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
Juuso Oikarinen06f7bc72010-02-22 08:38:33 +0200983 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300984
Juuso Oikarinen06f7bc72010-02-22 08:38:33 +0200985 spin_lock_irqsave(&wl->wl_lock, flags);
986 ieee80211_stop_queues(wl->hw);
Juuso Oikarinen71449f82009-12-11 15:41:07 +0200987 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
Juuso Oikarinen06f7bc72010-02-22 08:38:33 +0200988 spin_unlock_irqrestore(&wl->wl_lock, flags);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300989 }
990
991 return NETDEV_TX_OK;
992}
993
Juuso Oikarinenc2c192a2010-07-27 03:30:09 +0300994static struct notifier_block wl1271_dev_notifier = {
995 .notifier_call = wl1271_dev_notify,
996};
997
Luciano Coelhof5fc0f82009-08-06 16:25:28 +0300998static int wl1271_op_start(struct ieee80211_hw *hw)
999{
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001000 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
1001
1002 /*
1003 * We have to delay the booting of the hardware because
1004 * we need to know the local MAC address before downloading and
1005 * initializing the firmware. The MAC address cannot be changed
1006 * after boot, and without the proper MAC address, the firmware
1007 * will not function properly.
1008 *
1009 * The MAC address is first known when the corresponding interface
1010 * is added. That is where we will initialize the hardware.
1011 */
1012
1013 return 0;
1014}
1015
1016static void wl1271_op_stop(struct ieee80211_hw *hw)
1017{
1018 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
1019}
1020
1021static int wl1271_op_add_interface(struct ieee80211_hw *hw,
1022 struct ieee80211_vif *vif)
1023{
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001024 struct wl1271 *wl = hw->priv;
John W. Linvilleac01e942010-07-28 17:09:41 -04001025 struct wiphy *wiphy = hw->wiphy;
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001026 int retries = WL1271_BOOT_RETRIES;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001027 int ret = 0;
Eliad Peller71125ab2010-10-28 21:46:43 +02001028 bool booted = false;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001029
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001030 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
1031 vif->type, vif->addr);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001032
1033 mutex_lock(&wl->mutex);
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001034 if (wl->vif) {
Eliad Peller71125ab2010-10-28 21:46:43 +02001035 wl1271_debug(DEBUG_MAC80211,
1036 "multiple vifs are not supported yet");
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001037 ret = -EBUSY;
1038 goto out;
1039 }
1040
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001041 switch (vif->type) {
1042 case NL80211_IFTYPE_STATION:
1043 wl->bss_type = BSS_TYPE_STA_BSS;
Juuso Oikarinen5da11dc2010-03-26 12:53:24 +02001044 wl->set_bss_type = BSS_TYPE_STA_BSS;
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001045 break;
1046 case NL80211_IFTYPE_ADHOC:
1047 wl->bss_type = BSS_TYPE_IBSS;
Juuso Oikarinen5da11dc2010-03-26 12:53:24 +02001048 wl->set_bss_type = BSS_TYPE_STA_BSS;
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001049 break;
1050 default:
1051 ret = -EOPNOTSUPP;
1052 goto out;
1053 }
1054
1055 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001056
1057 if (wl->state != WL1271_STATE_OFF) {
1058 wl1271_error("cannot start because not in off state: %d",
1059 wl->state);
1060 ret = -EBUSY;
1061 goto out;
1062 }
1063
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001064 while (retries) {
1065 retries--;
1066 ret = wl1271_chip_wakeup(wl);
1067 if (ret < 0)
1068 goto power_off;
1069
1070 ret = wl1271_boot(wl);
1071 if (ret < 0)
1072 goto power_off;
1073
1074 ret = wl1271_hw_init(wl);
1075 if (ret < 0)
1076 goto irq_disable;
1077
Eliad Peller71125ab2010-10-28 21:46:43 +02001078 booted = true;
1079 break;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001080
Juuso Oikarinen9ccd9212009-12-11 15:41:01 +02001081irq_disable:
1082 wl1271_disable_interrupts(wl);
1083 mutex_unlock(&wl->mutex);
1084 /* Unlocking the mutex in the middle of handling is
1085 inherently unsafe. In this case we deem it safe to do,
1086 because we need to let any possibly pending IRQ out of
1087 the system (and while we are WL1271_STATE_OFF the IRQ
1088 work function will not do anything.) Also, any other
1089 possible concurrent operations will fail due to the
1090 current state, hence the wl1271 struct should be safe. */
1091 cancel_work_sync(&wl->irq_work);
1092 mutex_lock(&wl->mutex);
1093power_off:
1094 wl1271_power_off(wl);
1095 }
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001096
Eliad Peller71125ab2010-10-28 21:46:43 +02001097 if (!booted) {
1098 wl1271_error("firmware boot failed despite %d retries",
1099 WL1271_BOOT_RETRIES);
1100 goto out;
1101 }
1102
1103 wl->vif = vif;
1104 wl->state = WL1271_STATE_ON;
1105 wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
1106
1107 /* update hw/fw version info in wiphy struct */
1108 wiphy->hw_version = wl->chip.id;
1109 strncpy(wiphy->fw_version, wl->chip.fw_ver,
1110 sizeof(wiphy->fw_version));
1111
Luciano Coelhofb6a6812010-12-03 17:05:40 +02001112 /*
1113 * Now we know if 11a is supported (info from the NVS), so disable
1114 * 11a channels if not supported
1115 */
1116 if (!wl->enable_11a)
1117 wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0;
1118
1119 wl1271_debug(DEBUG_MAC80211, "11a is %ssupported",
1120 wl->enable_11a ? "" : "not ");
1121
Juuso Oikarineneb5b28d2009-10-13 12:47:45 +03001122out:
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001123 mutex_unlock(&wl->mutex);
1124
Juuso Oikarineneb887df2010-07-08 17:49:58 +03001125 if (!ret)
Juuso Oikarinen01c09162009-10-13 12:47:55 +03001126 list_add(&wl->list, &wl_list);
Juuso Oikarinen01c09162009-10-13 12:47:55 +03001127
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001128 return ret;
1129}
1130
Juuso Oikarinen52a2a372010-09-21 06:23:30 +02001131static void __wl1271_op_remove_interface(struct wl1271 *wl)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001132{
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001133 int i;
1134
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001135 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001136
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001137 wl1271_info("down");
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001138
Juuso Oikarinen01c09162009-10-13 12:47:55 +03001139 list_del(&wl->list);
1140
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001141 WARN_ON(wl->state != WL1271_STATE_ON);
1142
Juuso Oikarinen8d2ef7b2010-07-08 17:50:03 +03001143 /* enable dyn ps just in case (if left on due to fw crash etc) */
Juuso Oikarinen9a547bf2010-07-08 17:50:04 +03001144 if (wl->bss_type == BSS_TYPE_STA_BSS)
Juuso Oikarinenf532be62010-07-08 17:50:05 +03001145 ieee80211_enable_dyn_ps(wl->vif);
Juuso Oikarinen8d2ef7b2010-07-08 17:50:03 +03001146
Luciano Coelho08688d62010-07-08 17:50:07 +03001147 if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
Luciano Coelho08688d62010-07-08 17:50:07 +03001148 wl->scan.state = WL1271_SCAN_STATE_IDLE;
1149 kfree(wl->scan.scanned_ch);
1150 wl->scan.scanned_ch = NULL;
Juuso Oikarinenb739a422010-10-26 13:24:38 +02001151 wl->scan.req = NULL;
Juuso Oikarinen76a029f2010-07-29 04:54:45 +03001152 ieee80211_scan_completed(wl->hw, true);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001153 }
1154
1155 wl->state = WL1271_STATE_OFF;
1156
1157 wl1271_disable_interrupts(wl);
1158
1159 mutex_unlock(&wl->mutex);
1160
Juuso Oikarinen78abd322010-09-21 06:23:32 +02001161 cancel_delayed_work_sync(&wl->scan_complete_work);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001162 cancel_work_sync(&wl->irq_work);
1163 cancel_work_sync(&wl->tx_work);
Juuso Oikarinen90494a92010-07-08 17:50:00 +03001164 cancel_delayed_work_sync(&wl->pspoll_work);
Juuso Oikarinen8c7f4f32010-09-21 06:23:29 +02001165 cancel_delayed_work_sync(&wl->elp_work);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001166
1167 mutex_lock(&wl->mutex);
1168
1169 /* let's notify MAC80211 about the remaining pending TX frames */
Juuso Oikarinen781608c2010-05-24 11:18:17 +03001170 wl1271_tx_reset(wl);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001171 wl1271_power_off(wl);
1172
1173 memset(wl->bssid, 0, ETH_ALEN);
1174 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1175 wl->ssid_len = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001176 wl->bss_type = MAX_BSS_TYPE;
Juuso Oikarinen5da11dc2010-03-26 12:53:24 +02001177 wl->set_bss_type = MAX_BSS_TYPE;
Juuso Oikarinen8a5a37a2009-10-08 21:56:24 +03001178 wl->band = IEEE80211_BAND_2GHZ;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001179
1180 wl->rx_counter = 0;
Juuso Oikarinen19ad0712009-11-02 20:22:11 +02001181 wl->psm_entry_retry = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001182 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1183 wl->tx_blocks_available = 0;
1184 wl->tx_results_count = 0;
1185 wl->tx_packets_count = 0;
Juuso Oikarinenac4e4ce2009-10-08 21:56:19 +03001186 wl->tx_security_last_seq = 0;
Juuso Oikarinen04e36fc2010-02-22 08:38:40 +02001187 wl->tx_security_seq = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001188 wl->time_offset = 0;
1189 wl->session_counter = 0;
Juuso Oikarinen830fb672009-12-11 15:41:06 +02001190 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1191 wl->sta_rate_set = 0;
1192 wl->flags = 0;
Juuso Oikarinen1b72aec2010-03-18 12:26:39 +02001193 wl->vif = NULL;
Juuso Oikarinen14b228a2010-03-18 12:26:43 +02001194 wl->filters = 0;
Luciano Coelhod6e19d12009-10-12 15:08:43 +03001195
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001196 for (i = 0; i < NUM_TX_QUEUES; i++)
1197 wl->tx_blocks_freed[i] = 0;
1198
1199 wl1271_debugfs_reset(wl);
Juuso Oikarinenbd9dc492010-04-09 11:07:26 +03001200
1201 kfree(wl->fw_status);
1202 wl->fw_status = NULL;
1203 kfree(wl->tx_res_if);
1204 wl->tx_res_if = NULL;
1205 kfree(wl->target_mem_map);
1206 wl->target_mem_map = NULL;
Juuso Oikarinen52a2a372010-09-21 06:23:30 +02001207}
Juuso Oikarinenbd9dc492010-04-09 11:07:26 +03001208
Juuso Oikarinen52a2a372010-09-21 06:23:30 +02001209static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1210 struct ieee80211_vif *vif)
1211{
1212 struct wl1271 *wl = hw->priv;
1213
1214 mutex_lock(&wl->mutex);
Juuso Oikarinen67353292010-11-18 15:19:02 +02001215 /*
1216 * wl->vif can be null here if someone shuts down the interface
1217 * just when hardware recovery has been started.
1218 */
1219 if (wl->vif) {
1220 WARN_ON(wl->vif != vif);
1221 __wl1271_op_remove_interface(wl);
1222 }
Juuso Oikarinen52b0e7a2010-09-21 06:23:31 +02001223
Juuso Oikarinen67353292010-11-18 15:19:02 +02001224 mutex_unlock(&wl->mutex);
Juuso Oikarinen52b0e7a2010-09-21 06:23:31 +02001225 cancel_work_sync(&wl->recovery_work);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001226}
1227
Juuso Oikarinen14b228a2010-03-18 12:26:43 +02001228static void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1229{
Arik Nemtsovae113b52010-10-16 18:45:07 +02001230 wl1271_set_default_filters(wl);
Juuso Oikarinen14b228a2010-03-18 12:26:43 +02001231
1232 /* combine requested filters with current filter config */
1233 filters = wl->filters | filters;
1234
1235 wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1236
1237 if (filters & FIF_PROMISC_IN_BSS) {
1238 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1239 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1240 wl->rx_config |= CFG_BSSID_FILTER_EN;
1241 }
1242 if (filters & FIF_BCN_PRBRESP_PROMISC) {
1243 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1244 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1245 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1246 }
1247 if (filters & FIF_OTHER_BSS) {
1248 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1249 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1250 }
1251 if (filters & FIF_CONTROL) {
1252 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1253 wl->rx_filter |= CFG_RX_CTL_EN;
1254 }
1255 if (filters & FIF_FCSFAIL) {
1256 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1257 wl->rx_filter |= CFG_RX_FCS_ERROR;
1258 }
1259}
1260
Juuso Oikarinen82429d32010-04-28 09:50:01 +03001261static int wl1271_dummy_join(struct wl1271 *wl)
Luciano Coelhoc7f43e42009-12-11 15:40:44 +02001262{
Juuso Oikarinene0d8bbf2009-12-11 15:41:04 +02001263 int ret = 0;
Luciano Coelhoc7f43e42009-12-11 15:40:44 +02001264 /* we need to use a dummy BSSID for now */
1265 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1266 0xad, 0xbe, 0xef };
1267
Luciano Coelhoc7f43e42009-12-11 15:40:44 +02001268 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1269
Juuso Oikarinen14b228a2010-03-18 12:26:43 +02001270 /* pass through frames from all BSS */
1271 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1272
Juuso Oikarinen5da11dc2010-03-26 12:53:24 +02001273 ret = wl1271_cmd_join(wl, wl->set_bss_type);
Luciano Coelhoc7f43e42009-12-11 15:40:44 +02001274 if (ret < 0)
1275 goto out;
1276
Juuso Oikarinen71449f82009-12-11 15:41:07 +02001277 set_bit(WL1271_FLAG_JOINED, &wl->flags);
Luciano Coelhoc7f43e42009-12-11 15:40:44 +02001278
1279out:
1280 return ret;
1281}
1282
Juuso Oikarinen69e54342010-05-07 11:39:00 +03001283static int wl1271_join(struct wl1271 *wl, bool set_assoc)
Juuso Oikarinen82429d32010-04-28 09:50:01 +03001284{
1285 int ret;
1286
Juuso Oikarinen69e54342010-05-07 11:39:00 +03001287 /*
1288 * One of the side effects of the JOIN command is that is clears
1289 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1290 * to a WPA/WPA2 access point will therefore kill the data-path.
1291 * Currently there is no supported scenario for JOIN during
1292 * association - if it becomes a supported scenario, the WPA/WPA2 keys
1293 * must be handled somehow.
1294 *
1295 */
1296 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1297 wl1271_info("JOIN while associated.");
1298
1299 if (set_assoc)
1300 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1301
Juuso Oikarinen82429d32010-04-28 09:50:01 +03001302 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1303 if (ret < 0)
1304 goto out;
1305
1306 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1307
1308 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1309 goto out;
1310
1311 /*
1312 * The join command disable the keep-alive mode, shut down its process,
1313 * and also clear the template config, so we need to reset it all after
1314 * the join. The acx_aid starts the keep-alive process, and the order
1315 * of the commands below is relevant.
1316 */
1317 ret = wl1271_acx_keep_alive_mode(wl, true);
1318 if (ret < 0)
1319 goto out;
1320
1321 ret = wl1271_acx_aid(wl, wl->aid);
1322 if (ret < 0)
1323 goto out;
1324
1325 ret = wl1271_cmd_build_klv_null_data(wl);
1326 if (ret < 0)
1327 goto out;
1328
1329 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1330 ACX_KEEP_ALIVE_TPL_VALID);
1331 if (ret < 0)
1332 goto out;
1333
1334out:
1335 return ret;
1336}
1337
1338static int wl1271_unjoin(struct wl1271 *wl)
Luciano Coelhoc7f43e42009-12-11 15:40:44 +02001339{
1340 int ret;
1341
1342 /* to stop listening to a channel, we disconnect */
1343 ret = wl1271_cmd_disconnect(wl);
1344 if (ret < 0)
1345 goto out;
1346
Juuso Oikarinen71449f82009-12-11 15:41:07 +02001347 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
Luciano Coelhoc7f43e42009-12-11 15:40:44 +02001348 memset(wl->bssid, 0, ETH_ALEN);
Juuso Oikarinen14b228a2010-03-18 12:26:43 +02001349
1350 /* stop filterting packets based on bssid */
1351 wl1271_configure_filters(wl, FIF_OTHER_BSS);
Luciano Coelhoc7f43e42009-12-11 15:40:44 +02001352
1353out:
1354 return ret;
1355}
1356
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03001357static void wl1271_set_band_rate(struct wl1271 *wl)
1358{
1359 if (wl->band == IEEE80211_BAND_2GHZ)
1360 wl->basic_rate_set = wl->conf.tx.basic_rate;
1361 else
1362 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1363}
1364
Juuso Oikarinen0d58cbf2010-05-24 11:18:16 +03001365static int wl1271_handle_idle(struct wl1271 *wl, bool idle)
1366{
1367 int ret;
1368
1369 if (idle) {
1370 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1371 ret = wl1271_unjoin(wl);
1372 if (ret < 0)
1373 goto out;
1374 }
Arik Nemtsove0fe3712010-10-16 18:19:53 +02001375 wl->rate_set = wl1271_tx_min_rate_get(wl);
Juuso Oikarinen0d58cbf2010-05-24 11:18:16 +03001376 wl->sta_rate_set = 0;
Arik Nemtsov79b223f2010-10-16 17:52:59 +02001377 ret = wl1271_acx_sta_rate_policies(wl);
Juuso Oikarinen0d58cbf2010-05-24 11:18:16 +03001378 if (ret < 0)
1379 goto out;
1380 ret = wl1271_acx_keep_alive_config(
1381 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1382 ACX_KEEP_ALIVE_TPL_INVALID);
1383 if (ret < 0)
1384 goto out;
1385 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1386 } else {
1387 /* increment the session counter */
1388 wl->session_counter++;
1389 if (wl->session_counter >= SESSION_COUNTER_MAX)
1390 wl->session_counter = 0;
1391 ret = wl1271_dummy_join(wl);
1392 if (ret < 0)
1393 goto out;
1394 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1395 }
1396
1397out:
1398 return ret;
1399}
1400
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001401static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1402{
1403 struct wl1271 *wl = hw->priv;
1404 struct ieee80211_conf *conf = &hw->conf;
1405 int channel, ret = 0;
1406
1407 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1408
Luciano Coelhoc7f43e42009-12-11 15:40:44 +02001409 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001410 channel,
1411 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
Luciano Coelhoc7f43e42009-12-11 15:40:44 +02001412 conf->power_level,
1413 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001414
Juuso Oikarinen781608c2010-05-24 11:18:17 +03001415 /*
1416 * mac80211 will go to idle nearly immediately after transmitting some
1417 * frames, such as the deauth. To make sure those frames reach the air,
1418 * wait here until the TX queue is fully flushed.
1419 */
1420 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
1421 (conf->flags & IEEE80211_CONF_IDLE))
1422 wl1271_tx_flush(wl);
1423
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001424 mutex_lock(&wl->mutex);
1425
Juuso Oikarinenf8d98022010-10-26 13:24:39 +02001426 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1427 ret = -EAGAIN;
Saravanan Dhanabal2c10bb92010-04-09 11:07:27 +03001428 goto out;
Juuso Oikarinenf8d98022010-10-26 13:24:39 +02001429 }
Juuso Oikarinen8a5a37a2009-10-08 21:56:24 +03001430
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001431 ret = wl1271_ps_elp_wakeup(wl, false);
1432 if (ret < 0)
1433 goto out;
1434
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03001435 /* if the channel changes while joined, join again */
Juuso Oikarinen69e54342010-05-07 11:39:00 +03001436 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1437 ((wl->band != conf->channel->band) ||
1438 (wl->channel != channel))) {
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03001439 wl->band = conf->channel->band;
1440 wl->channel = channel;
1441
1442 /*
1443 * FIXME: the mac80211 should really provide a fixed rate
1444 * to use here. for now, just use the smallest possible rate
1445 * for the band as a fixed rate for association frames and
1446 * other control messages.
1447 */
1448 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1449 wl1271_set_band_rate(wl);
1450
Arik Nemtsove0fe3712010-10-16 18:19:53 +02001451 wl->basic_rate = wl1271_tx_min_rate_get(wl);
Arik Nemtsov79b223f2010-10-16 17:52:59 +02001452 ret = wl1271_acx_sta_rate_policies(wl);
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03001453 if (ret < 0)
1454 wl1271_warning("rate policy for update channel "
1455 "failed %d", ret);
1456
1457 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
Juuso Oikarinen69e54342010-05-07 11:39:00 +03001458 ret = wl1271_join(wl, false);
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03001459 if (ret < 0)
1460 wl1271_warning("cmd join to update channel "
1461 "failed %d", ret);
1462 }
1463 }
1464
Luciano Coelhoc7f43e42009-12-11 15:40:44 +02001465 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
Juuso Oikarinen0d58cbf2010-05-24 11:18:16 +03001466 ret = wl1271_handle_idle(wl, conf->flags & IEEE80211_CONF_IDLE);
1467 if (ret < 0)
1468 wl1271_warning("idle mode change failed %d", ret);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001469 }
1470
Juuso Oikarinen90494a92010-07-08 17:50:00 +03001471 /*
1472 * if mac80211 changes the PSM mode, make sure the mode is not
1473 * incorrectly changed after the pspoll failure active window.
1474 */
1475 if (changed & IEEE80211_CONF_CHANGE_PS)
1476 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
1477
Juuso Oikarinen71449f82009-12-11 15:41:07 +02001478 if (conf->flags & IEEE80211_CONF_PS &&
1479 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1480 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001481
1482 /*
1483 * We enter PSM only if we're already associated.
1484 * If we're not, we'll enter it when joining an SSID,
1485 * through the bss_info_changed() hook.
1486 */
Juuso Oikarinen830fb672009-12-11 15:41:06 +02001487 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
Juuso Oikarinen18f8d462010-02-22 08:38:34 +02001488 wl1271_debug(DEBUG_PSM, "psm enabled");
Juuso Oikarinend8c42c02010-02-18 13:25:36 +02001489 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
Juuso Oikarinen8eab7b42010-09-24 03:10:11 +02001490 wl->basic_rate, true);
Juuso Oikarinenaf5e0842009-12-11 15:41:00 +02001491 }
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001492 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
Juuso Oikarinen71449f82009-12-11 15:41:07 +02001493 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
Juuso Oikarinen18f8d462010-02-22 08:38:34 +02001494 wl1271_debug(DEBUG_PSM, "psm disabled");
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001495
Juuso Oikarinen71449f82009-12-11 15:41:07 +02001496 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001497
Juuso Oikarinen71449f82009-12-11 15:41:07 +02001498 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
Juuso Oikarinend8c42c02010-02-18 13:25:36 +02001499 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
Juuso Oikarinen8eab7b42010-09-24 03:10:11 +02001500 wl->basic_rate, true);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001501 }
1502
1503 if (conf->power_level != wl->power_level) {
1504 ret = wl1271_acx_tx_power(wl, conf->power_level);
1505 if (ret < 0)
Juuso Oikarinenc6317a52009-11-02 20:22:08 +02001506 goto out_sleep;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001507
1508 wl->power_level = conf->power_level;
1509 }
1510
1511out_sleep:
1512 wl1271_ps_elp_sleep(wl);
1513
1514out:
1515 mutex_unlock(&wl->mutex);
1516
1517 return ret;
1518}
1519
Juuso Oikarinenb54853f2009-10-13 12:47:59 +03001520struct wl1271_filter_params {
1521 bool enabled;
1522 int mc_list_length;
1523 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1524};
1525
Jiri Pirko22bedad2010-04-01 21:22:57 +00001526static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
1527 struct netdev_hw_addr_list *mc_list)
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03001528{
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03001529 struct wl1271_filter_params *fp;
Jiri Pirko22bedad2010-04-01 21:22:57 +00001530 struct netdev_hw_addr *ha;
Saravanan Dhanabal2c10bb92010-04-09 11:07:27 +03001531 struct wl1271 *wl = hw->priv;
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03001532
Saravanan Dhanabal2c10bb92010-04-09 11:07:27 +03001533 if (unlikely(wl->state == WL1271_STATE_OFF))
1534 return 0;
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03001535
Juuso Oikarinen74441132009-10-13 12:47:53 +03001536 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03001537 if (!fp) {
1538 wl1271_error("Out of memory setting filters.");
1539 return 0;
1540 }
1541
1542 /* update multicast filtering parameters */
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03001543 fp->mc_list_length = 0;
Jiri Pirko22bedad2010-04-01 21:22:57 +00001544 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
1545 fp->enabled = false;
1546 } else {
1547 fp->enabled = true;
1548 netdev_hw_addr_list_for_each(ha, mc_list) {
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03001549 memcpy(fp->mc_list[fp->mc_list_length],
Jiri Pirko22bedad2010-04-01 21:22:57 +00001550 ha->addr, ETH_ALEN);
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03001551 fp->mc_list_length++;
Jiri Pirko22bedad2010-04-01 21:22:57 +00001552 }
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03001553 }
1554
Juuso Oikarinenb54853f2009-10-13 12:47:59 +03001555 return (u64)(unsigned long)fp;
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03001556}
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001557
Juuso Oikarinenb54853f2009-10-13 12:47:59 +03001558#define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1559 FIF_ALLMULTI | \
1560 FIF_FCSFAIL | \
1561 FIF_BCN_PRBRESP_PROMISC | \
1562 FIF_CONTROL | \
1563 FIF_OTHER_BSS)
1564
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001565static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1566 unsigned int changed,
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03001567 unsigned int *total, u64 multicast)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001568{
Juuso Oikarinenb54853f2009-10-13 12:47:59 +03001569 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001570 struct wl1271 *wl = hw->priv;
Juuso Oikarinenb54853f2009-10-13 12:47:59 +03001571 int ret;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001572
1573 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1574
Juuso Oikarinenb54853f2009-10-13 12:47:59 +03001575 mutex_lock(&wl->mutex);
1576
Saravanan Dhanabal2c10bb92010-04-09 11:07:27 +03001577 *total &= WL1271_SUPPORTED_FILTERS;
1578 changed &= WL1271_SUPPORTED_FILTERS;
1579
1580 if (unlikely(wl->state == WL1271_STATE_OFF))
Juuso Oikarinenb54853f2009-10-13 12:47:59 +03001581 goto out;
1582
1583 ret = wl1271_ps_elp_wakeup(wl, false);
1584 if (ret < 0)
1585 goto out;
1586
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001587
Juuso Oikarinenb54853f2009-10-13 12:47:59 +03001588 if (*total & FIF_ALLMULTI)
1589 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1590 else if (fp)
1591 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1592 fp->mc_list,
1593 fp->mc_list_length);
1594 if (ret < 0)
1595 goto out_sleep;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001596
Juuso Oikarinenb54853f2009-10-13 12:47:59 +03001597 /* determine, whether supported filter values have changed */
1598 if (changed == 0)
1599 goto out_sleep;
1600
Juuso Oikarinen14b228a2010-03-18 12:26:43 +02001601 /* configure filters */
1602 wl->filters = *total;
1603 wl1271_configure_filters(wl, 0);
1604
Juuso Oikarinenb54853f2009-10-13 12:47:59 +03001605 /* apply configured filters */
1606 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1607 if (ret < 0)
1608 goto out_sleep;
1609
1610out_sleep:
1611 wl1271_ps_elp_sleep(wl);
1612
1613out:
1614 mutex_unlock(&wl->mutex);
Juuso Oikarinen14b228a2010-03-18 12:26:43 +02001615 kfree(fp);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001616}
1617
1618static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1619 struct ieee80211_vif *vif,
1620 struct ieee80211_sta *sta,
1621 struct ieee80211_key_conf *key_conf)
1622{
1623 struct wl1271 *wl = hw->priv;
1624 const u8 *addr;
1625 int ret;
Juuso Oikarinenac4e4ce2009-10-08 21:56:19 +03001626 u32 tx_seq_32 = 0;
1627 u16 tx_seq_16 = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001628 u8 key_type;
1629
1630 static const u8 bcast_addr[ETH_ALEN] =
1631 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1632
1633 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1634
1635 addr = sta ? sta->addr : bcast_addr;
1636
1637 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1638 wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1639 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
Johannes Berg97359d12010-08-10 09:46:38 +02001640 key_conf->cipher, key_conf->keyidx,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001641 key_conf->keylen, key_conf->flags);
1642 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1643
1644 if (is_zero_ether_addr(addr)) {
1645 /* We dont support TX only encryption */
1646 ret = -EOPNOTSUPP;
1647 goto out;
1648 }
1649
1650 mutex_lock(&wl->mutex);
1651
Juuso Oikarinenf8d98022010-10-26 13:24:39 +02001652 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1653 ret = -EAGAIN;
1654 goto out_unlock;
1655 }
1656
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001657 ret = wl1271_ps_elp_wakeup(wl, false);
1658 if (ret < 0)
1659 goto out_unlock;
1660
Johannes Berg97359d12010-08-10 09:46:38 +02001661 switch (key_conf->cipher) {
1662 case WLAN_CIPHER_SUITE_WEP40:
1663 case WLAN_CIPHER_SUITE_WEP104:
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001664 key_type = KEY_WEP;
1665
1666 key_conf->hw_key_idx = key_conf->keyidx;
1667 break;
Johannes Berg97359d12010-08-10 09:46:38 +02001668 case WLAN_CIPHER_SUITE_TKIP:
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001669 key_type = KEY_TKIP;
1670
1671 key_conf->hw_key_idx = key_conf->keyidx;
Juuso Oikarinen04e36fc2010-02-22 08:38:40 +02001672 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1673 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001674 break;
Johannes Berg97359d12010-08-10 09:46:38 +02001675 case WLAN_CIPHER_SUITE_CCMP:
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001676 key_type = KEY_AES;
1677
1678 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
Juuso Oikarinen04e36fc2010-02-22 08:38:40 +02001679 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1680 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001681 break;
Juuso Oikarinen7a557242010-09-27 12:42:07 +02001682 case WL1271_CIPHER_SUITE_GEM:
1683 key_type = KEY_GEM;
1684 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1685 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1686 break;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001687 default:
Johannes Berg97359d12010-08-10 09:46:38 +02001688 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001689
1690 ret = -EOPNOTSUPP;
1691 goto out_sleep;
1692 }
1693
1694 switch (cmd) {
1695 case SET_KEY:
Arik Nemtsov98bdaab2010-10-16 18:08:58 +02001696 ret = wl1271_cmd_set_sta_key(wl, KEY_ADD_OR_REPLACE,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001697 key_conf->keyidx, key_type,
1698 key_conf->keylen, key_conf->key,
Juuso Oikarinenac4e4ce2009-10-08 21:56:19 +03001699 addr, tx_seq_32, tx_seq_16);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001700 if (ret < 0) {
1701 wl1271_error("Could not add or replace key");
1702 goto out_sleep;
1703 }
Juuso Oikarinenee444cf2010-02-18 13:25:50 +02001704
1705 /* the default WEP key needs to be configured at least once */
1706 if (key_type == KEY_WEP) {
Arik Nemtsov98bdaab2010-10-16 18:08:58 +02001707 ret = wl1271_cmd_set_sta_default_wep_key(wl,
Juuso Oikarinenee444cf2010-02-18 13:25:50 +02001708 wl->default_key);
1709 if (ret < 0)
1710 goto out_sleep;
1711 }
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001712 break;
1713
1714 case DISABLE_KEY:
Juuso Oikarinenfddc7dd2010-02-18 13:25:49 +02001715 /* The wl1271 does not allow to remove unicast keys - they
1716 will be cleared automatically on next CMD_JOIN. Ignore the
1717 request silently, as we dont want the mac80211 to emit
1718 an error message. */
1719 if (!is_broadcast_ether_addr(addr))
1720 break;
1721
Arik Nemtsov98bdaab2010-10-16 18:08:58 +02001722 ret = wl1271_cmd_set_sta_key(wl, KEY_REMOVE,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001723 key_conf->keyidx, key_type,
1724 key_conf->keylen, key_conf->key,
Juuso Oikarinenac4e4ce2009-10-08 21:56:19 +03001725 addr, 0, 0);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001726 if (ret < 0) {
1727 wl1271_error("Could not remove key");
1728 goto out_sleep;
1729 }
1730 break;
1731
1732 default:
1733 wl1271_error("Unsupported key cmd 0x%x", cmd);
1734 ret = -EOPNOTSUPP;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001735 break;
1736 }
1737
1738out_sleep:
1739 wl1271_ps_elp_sleep(wl);
1740
1741out_unlock:
1742 mutex_unlock(&wl->mutex);
1743
1744out:
1745 return ret;
1746}
1747
1748static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
Johannes Berga060bbf2010-04-27 11:59:34 +02001749 struct ieee80211_vif *vif,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001750 struct cfg80211_scan_request *req)
1751{
1752 struct wl1271 *wl = hw->priv;
1753 int ret;
1754 u8 *ssid = NULL;
Teemu Paasikiviabb0b3b2009-10-13 12:47:50 +03001755 size_t len = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001756
1757 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1758
1759 if (req->n_ssids) {
1760 ssid = req->ssids[0].ssid;
Teemu Paasikiviabb0b3b2009-10-13 12:47:50 +03001761 len = req->ssids[0].ssid_len;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001762 }
1763
1764 mutex_lock(&wl->mutex);
1765
Juuso Oikarinenb739a422010-10-26 13:24:38 +02001766 if (wl->state == WL1271_STATE_OFF) {
1767 /*
1768 * We cannot return -EBUSY here because cfg80211 will expect
1769 * a call to ieee80211_scan_completed if we do - in this case
1770 * there won't be any call.
1771 */
1772 ret = -EAGAIN;
1773 goto out;
1774 }
1775
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001776 ret = wl1271_ps_elp_wakeup(wl, false);
1777 if (ret < 0)
1778 goto out;
1779
Luciano Coelho5924f892010-08-04 03:46:22 +03001780 ret = wl1271_scan(hw->priv, ssid, len, req);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001781
1782 wl1271_ps_elp_sleep(wl);
1783
1784out:
1785 mutex_unlock(&wl->mutex);
1786
1787 return ret;
1788}
1789
Arik Nemtsov68d069c2010-11-08 10:51:07 +01001790static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
1791{
1792 struct wl1271 *wl = hw->priv;
1793 int ret = 0;
1794
1795 mutex_lock(&wl->mutex);
1796
1797 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1798 ret = -EAGAIN;
1799 goto out;
1800 }
1801
1802 ret = wl1271_ps_elp_wakeup(wl, false);
1803 if (ret < 0)
1804 goto out;
1805
1806 ret = wl1271_acx_frag_threshold(wl, (u16)value);
1807 if (ret < 0)
1808 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
1809
1810 wl1271_ps_elp_sleep(wl);
1811
1812out:
1813 mutex_unlock(&wl->mutex);
1814
1815 return ret;
1816}
1817
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001818static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1819{
1820 struct wl1271 *wl = hw->priv;
Saravanan Dhanabalaecb0562010-04-09 11:07:28 +03001821 int ret = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001822
1823 mutex_lock(&wl->mutex);
1824
Juuso Oikarinenf8d98022010-10-26 13:24:39 +02001825 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1826 ret = -EAGAIN;
Saravanan Dhanabalaecb0562010-04-09 11:07:28 +03001827 goto out;
Juuso Oikarinenf8d98022010-10-26 13:24:39 +02001828 }
Saravanan Dhanabalaecb0562010-04-09 11:07:28 +03001829
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001830 ret = wl1271_ps_elp_wakeup(wl, false);
1831 if (ret < 0)
1832 goto out;
1833
1834 ret = wl1271_acx_rts_threshold(wl, (u16) value);
1835 if (ret < 0)
1836 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1837
1838 wl1271_ps_elp_sleep(wl);
1839
1840out:
1841 mutex_unlock(&wl->mutex);
1842
1843 return ret;
1844}
1845
Arik Nemtsove78a2872010-10-16 19:07:21 +02001846static int wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *skb,
Juuso Oikarinen2f6724b2010-11-24 08:16:57 +02001847 int offset)
Juuso Oikarinen30240fc2010-02-18 13:25:38 +02001848{
Juuso Oikarinen2f6724b2010-11-24 08:16:57 +02001849 u8 *ptr = skb->data + offset;
Juuso Oikarinen30240fc2010-02-18 13:25:38 +02001850
1851 /* find the location of the ssid in the beacon */
Juuso Oikarinen2f6724b2010-11-24 08:16:57 +02001852 while (ptr < skb->data + skb->len) {
Juuso Oikarinen30240fc2010-02-18 13:25:38 +02001853 if (ptr[0] == WLAN_EID_SSID) {
1854 wl->ssid_len = ptr[1];
1855 memcpy(wl->ssid, ptr+2, wl->ssid_len);
Arik Nemtsove78a2872010-10-16 19:07:21 +02001856 return 0;
Juuso Oikarinen30240fc2010-02-18 13:25:38 +02001857 }
Juuso Oikarinen2f6724b2010-11-24 08:16:57 +02001858 ptr += (ptr[1] + 2);
Juuso Oikarinen30240fc2010-02-18 13:25:38 +02001859 }
Arik Nemtsove78a2872010-10-16 19:07:21 +02001860
Juuso Oikarinen2f6724b2010-11-24 08:16:57 +02001861 wl1271_error("No SSID in IEs!\n");
Arik Nemtsove78a2872010-10-16 19:07:21 +02001862 return -ENOENT;
Juuso Oikarinen30240fc2010-02-18 13:25:38 +02001863}
1864
Arik Nemtsove78a2872010-10-16 19:07:21 +02001865static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
1866 struct ieee80211_bss_conf *bss_conf,
1867 u32 changed)
1868{
1869 int ret = 0;
1870
1871 if (changed & BSS_CHANGED_ERP_SLOT) {
1872 if (bss_conf->use_short_slot)
1873 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1874 else
1875 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1876 if (ret < 0) {
1877 wl1271_warning("Set slot time failed %d", ret);
1878 goto out;
1879 }
1880 }
1881
1882 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1883 if (bss_conf->use_short_preamble)
1884 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1885 else
1886 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1887 }
1888
1889 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1890 if (bss_conf->use_cts_prot)
1891 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1892 else
1893 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1894 if (ret < 0) {
1895 wl1271_warning("Set ctsprotect failed %d", ret);
1896 goto out;
1897 }
1898 }
1899
1900out:
1901 return ret;
1902}
1903
1904static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
1905 struct ieee80211_vif *vif,
1906 struct ieee80211_bss_conf *bss_conf,
1907 u32 changed)
1908{
1909 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
1910 int ret = 0;
1911
1912 if ((changed & BSS_CHANGED_BEACON_INT)) {
1913 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
1914 bss_conf->beacon_int);
1915
1916 wl->beacon_int = bss_conf->beacon_int;
1917 }
1918
1919 if ((changed & BSS_CHANGED_BEACON)) {
1920 struct ieee80211_hdr *hdr;
1921 int ieoffset = offsetof(struct ieee80211_mgmt,
1922 u.beacon.variable);
1923 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
1924 u16 tmpl_id;
1925
1926 if (!beacon)
1927 goto out;
1928
1929 wl1271_debug(DEBUG_MASTER, "beacon updated");
1930
1931 ret = wl1271_ssid_set(wl, beacon, ieoffset);
1932 if (ret < 0) {
1933 dev_kfree_skb(beacon);
1934 goto out;
1935 }
1936 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
1937 CMD_TEMPL_BEACON;
1938 ret = wl1271_cmd_template_set(wl, tmpl_id,
1939 beacon->data,
1940 beacon->len, 0,
1941 wl1271_tx_min_rate_get(wl));
1942 if (ret < 0) {
1943 dev_kfree_skb(beacon);
1944 goto out;
1945 }
1946
1947 hdr = (struct ieee80211_hdr *) beacon->data;
1948 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
1949 IEEE80211_STYPE_PROBE_RESP);
1950
1951 tmpl_id = is_ap ? CMD_TEMPL_AP_PROBE_RESPONSE :
1952 CMD_TEMPL_PROBE_RESPONSE;
1953 ret = wl1271_cmd_template_set(wl,
1954 tmpl_id,
1955 beacon->data,
1956 beacon->len, 0,
1957 wl1271_tx_min_rate_get(wl));
1958 dev_kfree_skb(beacon);
1959 if (ret < 0)
1960 goto out;
1961 }
1962
1963out:
1964 return ret;
1965}
1966
1967/* AP mode changes */
1968static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001969 struct ieee80211_vif *vif,
1970 struct ieee80211_bss_conf *bss_conf,
1971 u32 changed)
1972{
Arik Nemtsove78a2872010-10-16 19:07:21 +02001973 int ret = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001974
Arik Nemtsove78a2872010-10-16 19:07:21 +02001975 if ((changed & BSS_CHANGED_BASIC_RATES)) {
1976 u32 rates = bss_conf->basic_rates;
1977 struct conf_tx_rate_class mgmt_rc;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001978
Arik Nemtsove78a2872010-10-16 19:07:21 +02001979 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates);
1980 wl->basic_rate = wl1271_tx_min_rate_get(wl);
1981 wl1271_debug(DEBUG_AP, "basic rates: 0x%x",
1982 wl->basic_rate_set);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03001983
Arik Nemtsove78a2872010-10-16 19:07:21 +02001984 /* update the AP management rate policy with the new rates */
1985 mgmt_rc.enabled_rates = wl->basic_rate_set;
1986 mgmt_rc.long_retry_limit = 10;
1987 mgmt_rc.short_retry_limit = 10;
1988 mgmt_rc.aflags = 0;
1989 ret = wl1271_acx_ap_rate_policy(wl, &mgmt_rc,
1990 ACX_TX_AP_MODE_MGMT_RATE);
1991 if (ret < 0) {
1992 wl1271_error("AP mgmt policy change failed %d", ret);
1993 goto out;
Juuso Oikarinene0d8bbf2009-12-11 15:41:04 +02001994 }
1995 }
1996
Arik Nemtsove78a2872010-10-16 19:07:21 +02001997 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
1998 if (ret < 0)
1999 goto out;
2000
2001 if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
2002 if (bss_conf->enable_beacon) {
2003 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2004 ret = wl1271_cmd_start_bss(wl);
2005 if (ret < 0)
2006 goto out;
2007
2008 set_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
2009 wl1271_debug(DEBUG_AP, "started AP");
2010 }
2011 } else {
2012 if (test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2013 ret = wl1271_cmd_stop_bss(wl);
2014 if (ret < 0)
2015 goto out;
2016
2017 clear_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
2018 wl1271_debug(DEBUG_AP, "stopped AP");
2019 }
2020 }
2021 }
2022
2023 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
2024 if (ret < 0)
2025 goto out;
2026out:
2027 return;
2028}
2029
2030/* STA/IBSS mode changes */
2031static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
2032 struct ieee80211_vif *vif,
2033 struct ieee80211_bss_conf *bss_conf,
2034 u32 changed)
2035{
2036 bool do_join = false, set_assoc = false;
2037 bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS);
2038 int ret;
2039 struct ieee80211_sta *sta = ieee80211_find_sta(vif, bss_conf->bssid);
2040
2041 if (is_ibss) {
2042 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
2043 changed);
2044 if (ret < 0)
2045 goto out;
2046 }
2047
2048 if ((changed & BSS_CHANGED_BEACON_INT) && is_ibss)
2049 do_join = true;
2050
2051 /* Need to update the SSID (for filtering etc) */
2052 if ((changed & BSS_CHANGED_BEACON) && is_ibss)
2053 do_join = true;
2054
2055 if ((changed & BSS_CHANGED_BEACON_ENABLED) && is_ibss) {
Juuso Oikarinen5da11dc2010-03-26 12:53:24 +02002056 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
2057 bss_conf->enable_beacon ? "enabled" : "disabled");
2058
2059 if (bss_conf->enable_beacon)
2060 wl->set_bss_type = BSS_TYPE_IBSS;
2061 else
2062 wl->set_bss_type = BSS_TYPE_STA_BSS;
2063 do_join = true;
2064 }
2065
Arik Nemtsove78a2872010-10-16 19:07:21 +02002066 if ((changed & BSS_CHANGED_CQM)) {
Juuso Oikarinen00236aed2010-04-09 11:07:30 +03002067 bool enable = false;
2068 if (bss_conf->cqm_rssi_thold)
2069 enable = true;
2070 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
2071 bss_conf->cqm_rssi_thold,
2072 bss_conf->cqm_rssi_hyst);
2073 if (ret < 0)
2074 goto out;
2075 wl->rssi_thold = bss_conf->cqm_rssi_thold;
2076 }
2077
Juuso Oikarinen30240fc2010-02-18 13:25:38 +02002078 if ((changed & BSS_CHANGED_BSSID) &&
2079 /*
2080 * Now we know the correct bssid, so we send a new join command
2081 * and enable the BSSID filter
2082 */
2083 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
Arik Nemtsove78a2872010-10-16 19:07:21 +02002084 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
Juuso Oikarinena0cb7be2010-03-18 12:26:44 +02002085
Arik Nemtsove78a2872010-10-16 19:07:21 +02002086 ret = wl1271_cmd_build_null_data(wl);
2087 if (ret < 0)
2088 goto out;
Juuso Oikarinen30240fc2010-02-18 13:25:38 +02002089
Arik Nemtsove78a2872010-10-16 19:07:21 +02002090 ret = wl1271_build_qos_null_data(wl);
2091 if (ret < 0)
2092 goto out;
Saravanan Dhanabal141418c2010-04-28 09:50:00 +03002093
Arik Nemtsove78a2872010-10-16 19:07:21 +02002094 /* filter out all packets not from this BSSID */
2095 wl1271_configure_filters(wl, 0);
Juuso Oikarinen14b228a2010-03-18 12:26:43 +02002096
Arik Nemtsove78a2872010-10-16 19:07:21 +02002097 /* Need to update the BSSID (for filtering etc) */
2098 do_join = true;
Juuso Oikarinen30240fc2010-02-18 13:25:38 +02002099 }
2100
Arik Nemtsove78a2872010-10-16 19:07:21 +02002101 if ((changed & BSS_CHANGED_ASSOC)) {
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002102 if (bss_conf->assoc) {
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03002103 u32 rates;
Juuso Oikarinen2f6724b2010-11-24 08:16:57 +02002104 int ieoffset;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002105 wl->aid = bss_conf->aid;
Juuso Oikarinen69e54342010-05-07 11:39:00 +03002106 set_assoc = true;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002107
Juuso Oikarinen90494a92010-07-08 17:50:00 +03002108 wl->ps_poll_failures = 0;
2109
Luciano Coelhoae751ba2009-10-12 15:08:57 +03002110 /*
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03002111 * use basic rates from AP, and determine lowest rate
2112 * to use with control frames.
2113 */
2114 rates = bss_conf->basic_rates;
2115 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
2116 rates);
Arik Nemtsove0fe3712010-10-16 18:19:53 +02002117 wl->basic_rate = wl1271_tx_min_rate_get(wl);
Arik Nemtsov79b223f2010-10-16 17:52:59 +02002118 ret = wl1271_acx_sta_rate_policies(wl);
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03002119 if (ret < 0)
Arik Nemtsove78a2872010-10-16 19:07:21 +02002120 goto out;
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03002121
2122 /*
Luciano Coelhoae751ba2009-10-12 15:08:57 +03002123 * with wl1271, we don't need to update the
2124 * beacon_int and dtim_period, because the firmware
2125 * updates it by itself when the first beacon is
2126 * received after a join.
2127 */
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002128 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
2129 if (ret < 0)
Arik Nemtsove78a2872010-10-16 19:07:21 +02002130 goto out;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002131
Juuso Oikarinenc2b2d992010-03-26 12:53:28 +02002132 /*
Juuso Oikarinen2f6724b2010-11-24 08:16:57 +02002133 * Get a template for hardware connection maintenance
Juuso Oikarinenc2b2d992010-03-26 12:53:28 +02002134 */
Juuso Oikarinen2f6724b2010-11-24 08:16:57 +02002135 dev_kfree_skb(wl->probereq);
2136 wl->probereq = wl1271_cmd_build_ap_probe_req(wl, NULL);
2137 ieoffset = offsetof(struct ieee80211_mgmt,
2138 u.probe_req.variable);
2139 wl1271_ssid_set(wl, wl->probereq, ieoffset);
Juuso Oikarinenc2b2d992010-03-26 12:53:28 +02002140
Juuso Oikarinen6ccbb922010-03-26 12:53:23 +02002141 /* enable the connection monitoring feature */
2142 ret = wl1271_acx_conn_monit_params(wl, true);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002143 if (ret < 0)
Arik Nemtsove78a2872010-10-16 19:07:21 +02002144 goto out;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002145
2146 /* If we want to go in PSM but we're not there yet */
Juuso Oikarinen71449f82009-12-11 15:41:07 +02002147 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
2148 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
Arik Nemtsove78a2872010-10-16 19:07:21 +02002149 enum wl1271_cmd_ps_mode mode;
2150
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002151 mode = STATION_POWER_SAVE_MODE;
Juuso Oikarinen65cddbf2010-08-24 06:28:03 +03002152 ret = wl1271_ps_set_mode(wl, mode,
Juuso Oikarinen8eab7b42010-09-24 03:10:11 +02002153 wl->basic_rate,
Juuso Oikarinen65cddbf2010-08-24 06:28:03 +03002154 true);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002155 if (ret < 0)
Arik Nemtsove78a2872010-10-16 19:07:21 +02002156 goto out;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002157 }
Juuso Oikarinend94cd292009-10-08 21:56:25 +03002158 } else {
2159 /* use defaults when not associated */
Juuso Oikarinenc2c192a2010-07-27 03:30:09 +03002160 clear_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags);
Juuso Oikarinen830fb672009-12-11 15:41:06 +02002161 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
Juuso Oikarinend94cd292009-10-08 21:56:25 +03002162 wl->aid = 0;
Juuso Oikarinen6ccbb922010-03-26 12:53:23 +02002163
Juuso Oikarinen2f6724b2010-11-24 08:16:57 +02002164 /* free probe-request template */
2165 dev_kfree_skb(wl->probereq);
2166 wl->probereq = NULL;
2167
Juuso Oikarinen8d2ef7b2010-07-08 17:50:03 +03002168 /* re-enable dynamic ps - just in case */
Juuso Oikarinenf532be62010-07-08 17:50:05 +03002169 ieee80211_enable_dyn_ps(wl->vif);
Juuso Oikarinen8d2ef7b2010-07-08 17:50:03 +03002170
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03002171 /* revert back to minimum rates for the current band */
2172 wl1271_set_band_rate(wl);
Arik Nemtsove0fe3712010-10-16 18:19:53 +02002173 wl->basic_rate = wl1271_tx_min_rate_get(wl);
Arik Nemtsov79b223f2010-10-16 17:52:59 +02002174 ret = wl1271_acx_sta_rate_policies(wl);
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03002175 if (ret < 0)
Arik Nemtsove78a2872010-10-16 19:07:21 +02002176 goto out;
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03002177
Juuso Oikarinen6ccbb922010-03-26 12:53:23 +02002178 /* disable connection monitor features */
2179 ret = wl1271_acx_conn_monit_params(wl, false);
Juuso Oikarinenc1899552010-03-26 12:53:32 +02002180
2181 /* Disable the keep-alive feature */
2182 ret = wl1271_acx_keep_alive_mode(wl, false);
Juuso Oikarinen6ccbb922010-03-26 12:53:23 +02002183 if (ret < 0)
Arik Nemtsove78a2872010-10-16 19:07:21 +02002184 goto out;
Juuso Oikarinenb84a7d32010-11-22 12:59:08 +02002185
2186 /* restore the bssid filter and go to dummy bssid */
2187 wl1271_unjoin(wl);
2188 wl1271_dummy_join(wl);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002189 }
2190 }
Juuso Oikarinen8a5a37a2009-10-08 21:56:24 +03002191
Arik Nemtsove78a2872010-10-16 19:07:21 +02002192 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
2193 if (ret < 0)
2194 goto out;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002195
Shahar Levi18357852010-10-13 16:09:41 +02002196 /*
2197 * Takes care of: New association with HT enable,
2198 * HT information change in beacon.
2199 */
2200 if (sta &&
2201 (changed & BSS_CHANGED_HT) &&
2202 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
2203 ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap, true);
2204 if (ret < 0) {
2205 wl1271_warning("Set ht cap true failed %d", ret);
Arik Nemtsove78a2872010-10-16 19:07:21 +02002206 goto out;
Shahar Levi18357852010-10-13 16:09:41 +02002207 }
2208 ret = wl1271_acx_set_ht_information(wl,
2209 bss_conf->ht_operation_mode);
2210 if (ret < 0) {
2211 wl1271_warning("Set ht information failed %d", ret);
Arik Nemtsove78a2872010-10-16 19:07:21 +02002212 goto out;
Shahar Levi18357852010-10-13 16:09:41 +02002213 }
2214 }
2215 /*
2216 * Takes care of: New association without HT,
2217 * Disassociation.
2218 */
2219 else if (sta && (changed & BSS_CHANGED_ASSOC)) {
2220 ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap, false);
2221 if (ret < 0) {
2222 wl1271_warning("Set ht cap false failed %d", ret);
Arik Nemtsove78a2872010-10-16 19:07:21 +02002223 goto out;
Shahar Levi18357852010-10-13 16:09:41 +02002224 }
2225 }
2226
Juuso Oikarinenca52a5e2010-07-08 17:50:02 +03002227 if (changed & BSS_CHANGED_ARP_FILTER) {
2228 __be32 addr = bss_conf->arp_addr_list[0];
2229 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
2230
Eliad Pellerc5312772010-12-09 11:31:27 +02002231 if (bss_conf->arp_addr_cnt == 1 &&
2232 bss_conf->arp_filter_enabled) {
2233 /*
2234 * The template should have been configured only upon
2235 * association. however, it seems that the correct ip
2236 * isn't being set (when sending), so we have to
2237 * reconfigure the template upon every ip change.
2238 */
2239 ret = wl1271_cmd_build_arp_rsp(wl, addr);
2240 if (ret < 0) {
2241 wl1271_warning("build arp rsp failed: %d", ret);
Arik Nemtsove78a2872010-10-16 19:07:21 +02002242 goto out;
Eliad Pellerc5312772010-12-09 11:31:27 +02002243 }
2244
2245 ret = wl1271_acx_arp_ip_filter(wl,
2246 (ACX_ARP_FILTER_ARP_FILTERING |
2247 ACX_ARP_FILTER_AUTO_ARP),
2248 addr);
2249 } else
2250 ret = wl1271_acx_arp_ip_filter(wl, 0, addr);
Juuso Oikarinenca52a5e2010-07-08 17:50:02 +03002251
2252 if (ret < 0)
Arik Nemtsove78a2872010-10-16 19:07:21 +02002253 goto out;
Juuso Oikarinenca52a5e2010-07-08 17:50:02 +03002254 }
2255
Juuso Oikarinen8bf29b02010-02-18 13:25:51 +02002256 if (do_join) {
Juuso Oikarinen69e54342010-05-07 11:39:00 +03002257 ret = wl1271_join(wl, set_assoc);
Juuso Oikarinen8bf29b02010-02-18 13:25:51 +02002258 if (ret < 0) {
2259 wl1271_warning("cmd join failed %d", ret);
Arik Nemtsove78a2872010-10-16 19:07:21 +02002260 goto out;
Juuso Oikarinen8bf29b02010-02-18 13:25:51 +02002261 }
Juuso Oikarinenc1899552010-03-26 12:53:32 +02002262 }
2263
Arik Nemtsove78a2872010-10-16 19:07:21 +02002264out:
2265 return;
2266}
2267
2268static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
2269 struct ieee80211_vif *vif,
2270 struct ieee80211_bss_conf *bss_conf,
2271 u32 changed)
2272{
2273 struct wl1271 *wl = hw->priv;
2274 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2275 int ret;
2276
2277 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
2278 (int)changed);
2279
2280 mutex_lock(&wl->mutex);
2281
2282 if (unlikely(wl->state == WL1271_STATE_OFF))
2283 goto out;
2284
2285 ret = wl1271_ps_elp_wakeup(wl, false);
2286 if (ret < 0)
2287 goto out;
2288
2289 if (is_ap)
2290 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
2291 else
2292 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
2293
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002294 wl1271_ps_elp_sleep(wl);
2295
2296out:
2297 mutex_unlock(&wl->mutex);
2298}
2299
Kalle Valoc6999d82010-02-18 13:25:41 +02002300static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
2301 const struct ieee80211_tx_queue_params *params)
2302{
2303 struct wl1271 *wl = hw->priv;
Kalle Valo4695dc92010-03-18 12:26:38 +02002304 u8 ps_scheme;
Kalle Valoc6999d82010-02-18 13:25:41 +02002305 int ret;
2306
2307 mutex_lock(&wl->mutex);
2308
2309 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
2310
Juuso Oikarinenf8d98022010-10-26 13:24:39 +02002311 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2312 ret = -EAGAIN;
2313 goto out;
2314 }
2315
Kalle Valoc82c1dd2010-02-18 13:25:47 +02002316 ret = wl1271_ps_elp_wakeup(wl, false);
2317 if (ret < 0)
2318 goto out;
2319
Juuso Oikarinenb43316d2010-03-18 12:26:26 +02002320 /* the txop is confed in units of 32us by the mac80211, we need us */
Kalle Valoc6999d82010-02-18 13:25:41 +02002321 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
2322 params->cw_min, params->cw_max,
Juuso Oikarinenb43316d2010-03-18 12:26:26 +02002323 params->aifs, params->txop << 5);
Kalle Valoc6999d82010-02-18 13:25:41 +02002324 if (ret < 0)
Kalle Valoc82c1dd2010-02-18 13:25:47 +02002325 goto out_sleep;
Kalle Valoc6999d82010-02-18 13:25:41 +02002326
Kalle Valo4695dc92010-03-18 12:26:38 +02002327 if (params->uapsd)
2328 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
2329 else
2330 ps_scheme = CONF_PS_SCHEME_LEGACY;
2331
Kalle Valoc6999d82010-02-18 13:25:41 +02002332 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
2333 CONF_CHANNEL_TYPE_EDCF,
2334 wl1271_tx_get_queue(queue),
Kalle Valo4695dc92010-03-18 12:26:38 +02002335 ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
Kalle Valoc6999d82010-02-18 13:25:41 +02002336 if (ret < 0)
Kalle Valoc82c1dd2010-02-18 13:25:47 +02002337 goto out_sleep;
2338
2339out_sleep:
2340 wl1271_ps_elp_sleep(wl);
Kalle Valoc6999d82010-02-18 13:25:41 +02002341
2342out:
2343 mutex_unlock(&wl->mutex);
2344
2345 return ret;
2346}
2347
Juuso Oikarinenbbbb5382010-07-08 17:49:57 +03002348static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
2349{
2350
2351 struct wl1271 *wl = hw->priv;
2352 u64 mactime = ULLONG_MAX;
2353 int ret;
2354
2355 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
2356
2357 mutex_lock(&wl->mutex);
2358
Juuso Oikarinenf8d98022010-10-26 13:24:39 +02002359 if (unlikely(wl->state == WL1271_STATE_OFF))
2360 goto out;
2361
Juuso Oikarinenbbbb5382010-07-08 17:49:57 +03002362 ret = wl1271_ps_elp_wakeup(wl, false);
2363 if (ret < 0)
2364 goto out;
2365
2366 ret = wl1271_acx_tsf_info(wl, &mactime);
2367 if (ret < 0)
2368 goto out_sleep;
2369
2370out_sleep:
2371 wl1271_ps_elp_sleep(wl);
2372
2373out:
2374 mutex_unlock(&wl->mutex);
2375 return mactime;
2376}
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002377
John W. Linvilleece550d2010-07-28 16:41:06 -04002378static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
2379 struct survey_info *survey)
2380{
2381 struct wl1271 *wl = hw->priv;
2382 struct ieee80211_conf *conf = &hw->conf;
Juuso Oikarinenb739a422010-10-26 13:24:38 +02002383
John W. Linvilleece550d2010-07-28 16:41:06 -04002384 if (idx != 0)
2385 return -ENOENT;
Juuso Oikarinenb739a422010-10-26 13:24:38 +02002386
John W. Linvilleece550d2010-07-28 16:41:06 -04002387 survey->channel = conf->channel;
2388 survey->filled = SURVEY_INFO_NOISE_DBM;
2389 survey->noise = wl->noise;
Juuso Oikarinenb739a422010-10-26 13:24:38 +02002390
John W. Linvilleece550d2010-07-28 16:41:06 -04002391 return 0;
2392}
2393
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002394/* can't be const, mac80211 writes to this */
2395static struct ieee80211_rate wl1271_rates[] = {
2396 { .bitrate = 10,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03002397 .hw_value = CONF_HW_BIT_RATE_1MBPS,
2398 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002399 { .bitrate = 20,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03002400 .hw_value = CONF_HW_BIT_RATE_2MBPS,
2401 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002402 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2403 { .bitrate = 55,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03002404 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
2405 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002406 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2407 { .bitrate = 110,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03002408 .hw_value = CONF_HW_BIT_RATE_11MBPS,
2409 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002410 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2411 { .bitrate = 60,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03002412 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2413 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002414 { .bitrate = 90,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03002415 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2416 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002417 { .bitrate = 120,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03002418 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2419 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002420 { .bitrate = 180,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03002421 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2422 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002423 { .bitrate = 240,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03002424 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2425 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002426 { .bitrate = 360,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03002427 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2428 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002429 { .bitrate = 480,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03002430 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2431 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002432 { .bitrate = 540,
Juuso Oikarinen2b60100b2009-10-13 12:47:39 +03002433 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2434 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002435};
2436
Juuso Oikarinenfa97f462010-11-10 11:27:20 +01002437/* can't be const, mac80211 writes to this */
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002438static struct ieee80211_channel wl1271_channels[] = {
Luciano Coelhoa2d0e3f2009-12-11 15:40:46 +02002439 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
Juuso Oikarinenfa21c7a2010-08-10 08:22:02 +02002440 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
Juuso Oikarinenfa97f462010-11-10 11:27:20 +01002441 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
2442 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
2443 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
Juuso Oikarinenfa21c7a2010-08-10 08:22:02 +02002444 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
Juuso Oikarinenfa97f462010-11-10 11:27:20 +01002445 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
2446 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
2447 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
Juuso Oikarinenfa21c7a2010-08-10 08:22:02 +02002448 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
Juuso Oikarinenfa97f462010-11-10 11:27:20 +01002449 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
2450 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
2451 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002452};
2453
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02002454/* mapping to indexes for wl1271_rates */
Tobias Klausera0ea9492010-05-20 10:38:11 +02002455static const u8 wl1271_rate_to_idx_2ghz[] = {
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02002456 /* MCS rates are used only with 11n */
Shahar Levi18357852010-10-13 16:09:41 +02002457 7, /* CONF_HW_RXTX_RATE_MCS7 */
2458 6, /* CONF_HW_RXTX_RATE_MCS6 */
2459 5, /* CONF_HW_RXTX_RATE_MCS5 */
2460 4, /* CONF_HW_RXTX_RATE_MCS4 */
2461 3, /* CONF_HW_RXTX_RATE_MCS3 */
2462 2, /* CONF_HW_RXTX_RATE_MCS2 */
2463 1, /* CONF_HW_RXTX_RATE_MCS1 */
2464 0, /* CONF_HW_RXTX_RATE_MCS0 */
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02002465
2466 11, /* CONF_HW_RXTX_RATE_54 */
2467 10, /* CONF_HW_RXTX_RATE_48 */
2468 9, /* CONF_HW_RXTX_RATE_36 */
2469 8, /* CONF_HW_RXTX_RATE_24 */
2470
2471 /* TI-specific rate */
2472 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2473
2474 7, /* CONF_HW_RXTX_RATE_18 */
2475 6, /* CONF_HW_RXTX_RATE_12 */
2476 3, /* CONF_HW_RXTX_RATE_11 */
2477 5, /* CONF_HW_RXTX_RATE_9 */
2478 4, /* CONF_HW_RXTX_RATE_6 */
2479 2, /* CONF_HW_RXTX_RATE_5_5 */
2480 1, /* CONF_HW_RXTX_RATE_2 */
2481 0 /* CONF_HW_RXTX_RATE_1 */
2482};
2483
Shahar Levie8b03a22010-10-13 16:09:39 +02002484/* 11n STA capabilities */
2485#define HW_RX_HIGHEST_RATE 72
2486
Shahar Levi00d20102010-11-08 11:20:10 +00002487#ifdef CONFIG_WL12XX_HT
2488#define WL12XX_HT_CAP { \
Shahar Levie8b03a22010-10-13 16:09:39 +02002489 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20, \
2490 .ht_supported = true, \
2491 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
2492 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
2493 .mcs = { \
2494 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
2495 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
2496 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
2497 }, \
2498}
Shahar Levi18357852010-10-13 16:09:41 +02002499#else
Shahar Levi00d20102010-11-08 11:20:10 +00002500#define WL12XX_HT_CAP { \
Shahar Levi18357852010-10-13 16:09:41 +02002501 .ht_supported = false, \
2502}
2503#endif
Shahar Levie8b03a22010-10-13 16:09:39 +02002504
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002505/* can't be const, mac80211 writes to this */
2506static struct ieee80211_supported_band wl1271_band_2ghz = {
2507 .channels = wl1271_channels,
2508 .n_channels = ARRAY_SIZE(wl1271_channels),
2509 .bitrates = wl1271_rates,
2510 .n_bitrates = ARRAY_SIZE(wl1271_rates),
Shahar Levi00d20102010-11-08 11:20:10 +00002511 .ht_cap = WL12XX_HT_CAP,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002512};
2513
Teemu Paasikivi1ebec3d2009-10-13 12:47:48 +03002514/* 5 GHz data rates for WL1273 */
2515static struct ieee80211_rate wl1271_rates_5ghz[] = {
2516 { .bitrate = 60,
2517 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2518 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2519 { .bitrate = 90,
2520 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2521 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2522 { .bitrate = 120,
2523 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2524 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2525 { .bitrate = 180,
2526 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2527 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2528 { .bitrate = 240,
2529 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2530 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2531 { .bitrate = 360,
2532 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2533 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2534 { .bitrate = 480,
2535 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2536 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2537 { .bitrate = 540,
2538 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2539 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2540};
2541
Juuso Oikarinenfa97f462010-11-10 11:27:20 +01002542/* 5 GHz band channels for WL1273 */
Teemu Paasikivi1ebec3d2009-10-13 12:47:48 +03002543static struct ieee80211_channel wl1271_channels_5ghz[] = {
Juuso Oikarinenfa21c7a2010-08-10 08:22:02 +02002544 { .hw_value = 7, .center_freq = 5035},
Juuso Oikarinenfa97f462010-11-10 11:27:20 +01002545 { .hw_value = 8, .center_freq = 5040},
2546 { .hw_value = 9, .center_freq = 5045},
2547 { .hw_value = 11, .center_freq = 5055},
2548 { .hw_value = 12, .center_freq = 5060},
Juuso Oikarinenfa21c7a2010-08-10 08:22:02 +02002549 { .hw_value = 16, .center_freq = 5080},
Juuso Oikarinenfa97f462010-11-10 11:27:20 +01002550 { .hw_value = 34, .center_freq = 5170},
2551 { .hw_value = 36, .center_freq = 5180},
2552 { .hw_value = 38, .center_freq = 5190},
2553 { .hw_value = 40, .center_freq = 5200},
Juuso Oikarinenfa21c7a2010-08-10 08:22:02 +02002554 { .hw_value = 42, .center_freq = 5210},
Juuso Oikarinenfa97f462010-11-10 11:27:20 +01002555 { .hw_value = 44, .center_freq = 5220},
2556 { .hw_value = 46, .center_freq = 5230},
2557 { .hw_value = 48, .center_freq = 5240},
2558 { .hw_value = 52, .center_freq = 5260},
Juuso Oikarinenfa21c7a2010-08-10 08:22:02 +02002559 { .hw_value = 56, .center_freq = 5280},
Juuso Oikarinenfa97f462010-11-10 11:27:20 +01002560 { .hw_value = 60, .center_freq = 5300},
2561 { .hw_value = 64, .center_freq = 5320},
2562 { .hw_value = 100, .center_freq = 5500},
2563 { .hw_value = 104, .center_freq = 5520},
Juuso Oikarinenfa21c7a2010-08-10 08:22:02 +02002564 { .hw_value = 108, .center_freq = 5540},
Juuso Oikarinenfa97f462010-11-10 11:27:20 +01002565 { .hw_value = 112, .center_freq = 5560},
2566 { .hw_value = 116, .center_freq = 5580},
2567 { .hw_value = 120, .center_freq = 5600},
2568 { .hw_value = 124, .center_freq = 5620},
Juuso Oikarinenfa21c7a2010-08-10 08:22:02 +02002569 { .hw_value = 128, .center_freq = 5640},
Juuso Oikarinenfa97f462010-11-10 11:27:20 +01002570 { .hw_value = 132, .center_freq = 5660},
2571 { .hw_value = 136, .center_freq = 5680},
2572 { .hw_value = 140, .center_freq = 5700},
2573 { .hw_value = 149, .center_freq = 5745},
Juuso Oikarinenfa21c7a2010-08-10 08:22:02 +02002574 { .hw_value = 153, .center_freq = 5765},
Juuso Oikarinenfa97f462010-11-10 11:27:20 +01002575 { .hw_value = 157, .center_freq = 5785},
2576 { .hw_value = 161, .center_freq = 5805},
Teemu Paasikivi1ebec3d2009-10-13 12:47:48 +03002577 { .hw_value = 165, .center_freq = 5825},
2578};
2579
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02002580/* mapping to indexes for wl1271_rates_5ghz */
Tobias Klausera0ea9492010-05-20 10:38:11 +02002581static const u8 wl1271_rate_to_idx_5ghz[] = {
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02002582 /* MCS rates are used only with 11n */
Shahar Levi18357852010-10-13 16:09:41 +02002583 7, /* CONF_HW_RXTX_RATE_MCS7 */
2584 6, /* CONF_HW_RXTX_RATE_MCS6 */
2585 5, /* CONF_HW_RXTX_RATE_MCS5 */
2586 4, /* CONF_HW_RXTX_RATE_MCS4 */
2587 3, /* CONF_HW_RXTX_RATE_MCS3 */
2588 2, /* CONF_HW_RXTX_RATE_MCS2 */
2589 1, /* CONF_HW_RXTX_RATE_MCS1 */
2590 0, /* CONF_HW_RXTX_RATE_MCS0 */
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02002591
2592 7, /* CONF_HW_RXTX_RATE_54 */
2593 6, /* CONF_HW_RXTX_RATE_48 */
2594 5, /* CONF_HW_RXTX_RATE_36 */
2595 4, /* CONF_HW_RXTX_RATE_24 */
2596
2597 /* TI-specific rate */
2598 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2599
2600 3, /* CONF_HW_RXTX_RATE_18 */
2601 2, /* CONF_HW_RXTX_RATE_12 */
2602 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
2603 1, /* CONF_HW_RXTX_RATE_9 */
2604 0, /* CONF_HW_RXTX_RATE_6 */
2605 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
2606 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
2607 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
2608};
Teemu Paasikivi1ebec3d2009-10-13 12:47:48 +03002609
2610static struct ieee80211_supported_band wl1271_band_5ghz = {
2611 .channels = wl1271_channels_5ghz,
2612 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
2613 .bitrates = wl1271_rates_5ghz,
2614 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
Shahar Levi00d20102010-11-08 11:20:10 +00002615 .ht_cap = WL12XX_HT_CAP,
Teemu Paasikivi1ebec3d2009-10-13 12:47:48 +03002616};
2617
Tobias Klausera0ea9492010-05-20 10:38:11 +02002618static const u8 *wl1271_band_rate_to_idx[] = {
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02002619 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
2620 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
2621};
2622
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002623static const struct ieee80211_ops wl1271_ops = {
2624 .start = wl1271_op_start,
2625 .stop = wl1271_op_stop,
2626 .add_interface = wl1271_op_add_interface,
2627 .remove_interface = wl1271_op_remove_interface,
2628 .config = wl1271_op_config,
Juuso Oikarinenc87dec92009-10-08 21:56:31 +03002629 .prepare_multicast = wl1271_op_prepare_multicast,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002630 .configure_filter = wl1271_op_configure_filter,
2631 .tx = wl1271_op_tx,
2632 .set_key = wl1271_op_set_key,
2633 .hw_scan = wl1271_op_hw_scan,
2634 .bss_info_changed = wl1271_op_bss_info_changed,
Arik Nemtsov68d069c2010-11-08 10:51:07 +01002635 .set_frag_threshold = wl1271_op_set_frag_threshold,
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002636 .set_rts_threshold = wl1271_op_set_rts_threshold,
Kalle Valoc6999d82010-02-18 13:25:41 +02002637 .conf_tx = wl1271_op_conf_tx,
Juuso Oikarinenbbbb5382010-07-08 17:49:57 +03002638 .get_tsf = wl1271_op_get_tsf,
John W. Linvilleece550d2010-07-28 16:41:06 -04002639 .get_survey = wl1271_op_get_survey,
Kalle Valoc8c90872010-02-18 13:25:53 +02002640 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002641};
2642
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02002643
Teemu Paasikivi6a2de932010-10-14 11:00:04 +02002644u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02002645{
2646 u8 idx;
2647
Teemu Paasikivi6a2de932010-10-14 11:00:04 +02002648 BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02002649
2650 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
2651 wl1271_error("Illegal RX rate from HW: %d", rate);
2652 return 0;
2653 }
2654
Teemu Paasikivi6a2de932010-10-14 11:00:04 +02002655 idx = wl1271_band_rate_to_idx[band][rate];
Juuso Oikarinenf876bb92010-03-26 12:53:11 +02002656 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
2657 wl1271_error("Unsupported RX rate from HW: %d", rate);
2658 return 0;
2659 }
2660
2661 return idx;
2662}
2663
Juuso Oikarinen7fc3a862010-03-18 12:26:32 +02002664static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
2665 struct device_attribute *attr,
2666 char *buf)
2667{
2668 struct wl1271 *wl = dev_get_drvdata(dev);
2669 ssize_t len;
2670
Juuso Oikarinen2f63b012010-08-10 06:38:35 +02002671 len = PAGE_SIZE;
Juuso Oikarinen7fc3a862010-03-18 12:26:32 +02002672
2673 mutex_lock(&wl->mutex);
2674 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
2675 wl->sg_enabled);
2676 mutex_unlock(&wl->mutex);
2677
2678 return len;
2679
2680}
2681
2682static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
2683 struct device_attribute *attr,
2684 const char *buf, size_t count)
2685{
2686 struct wl1271 *wl = dev_get_drvdata(dev);
2687 unsigned long res;
2688 int ret;
2689
2690 ret = strict_strtoul(buf, 10, &res);
2691
2692 if (ret < 0) {
2693 wl1271_warning("incorrect value written to bt_coex_mode");
2694 return count;
2695 }
2696
2697 mutex_lock(&wl->mutex);
2698
2699 res = !!res;
2700
2701 if (res == wl->sg_enabled)
2702 goto out;
2703
2704 wl->sg_enabled = res;
2705
2706 if (wl->state == WL1271_STATE_OFF)
2707 goto out;
2708
2709 ret = wl1271_ps_elp_wakeup(wl, false);
2710 if (ret < 0)
2711 goto out;
2712
2713 wl1271_acx_sg_enable(wl, wl->sg_enabled);
2714 wl1271_ps_elp_sleep(wl);
2715
2716 out:
2717 mutex_unlock(&wl->mutex);
2718 return count;
2719}
2720
2721static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
2722 wl1271_sysfs_show_bt_coex_state,
2723 wl1271_sysfs_store_bt_coex_state);
2724
Juuso Oikarinend717fd62010-05-07 11:38:58 +03002725static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
2726 struct device_attribute *attr,
2727 char *buf)
2728{
2729 struct wl1271 *wl = dev_get_drvdata(dev);
2730 ssize_t len;
2731
Juuso Oikarinen2f63b012010-08-10 06:38:35 +02002732 len = PAGE_SIZE;
Juuso Oikarinend717fd62010-05-07 11:38:58 +03002733
2734 mutex_lock(&wl->mutex);
2735 if (wl->hw_pg_ver >= 0)
2736 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
2737 else
2738 len = snprintf(buf, len, "n/a\n");
2739 mutex_unlock(&wl->mutex);
2740
2741 return len;
2742}
2743
2744static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
2745 wl1271_sysfs_show_hw_pg_ver, NULL);
2746
Teemu Paasikivi2d5e82b2010-02-22 08:38:21 +02002747int wl1271_register_hw(struct wl1271 *wl)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002748{
2749 int ret;
2750
2751 if (wl->mac80211_registered)
2752 return 0;
2753
2754 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
2755
2756 ret = ieee80211_register_hw(wl->hw);
2757 if (ret < 0) {
2758 wl1271_error("unable to register mac80211 hw: %d", ret);
2759 return ret;
2760 }
2761
2762 wl->mac80211_registered = true;
2763
Eliad Pellerd60080a2010-11-24 12:53:16 +02002764 wl1271_debugfs_init(wl);
2765
Juuso Oikarinenc2c192a2010-07-27 03:30:09 +03002766 register_netdevice_notifier(&wl1271_dev_notifier);
2767
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002768 wl1271_notice("loaded");
2769
2770 return 0;
2771}
Teemu Paasikivi50b3eb42010-02-22 08:38:26 +02002772EXPORT_SYMBOL_GPL(wl1271_register_hw);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002773
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02002774void wl1271_unregister_hw(struct wl1271 *wl)
2775{
Juuso Oikarinenc2c192a2010-07-27 03:30:09 +03002776 unregister_netdevice_notifier(&wl1271_dev_notifier);
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02002777 ieee80211_unregister_hw(wl->hw);
2778 wl->mac80211_registered = false;
2779
2780}
2781EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
2782
Teemu Paasikivi2d5e82b2010-02-22 08:38:21 +02002783int wl1271_init_ieee80211(struct wl1271 *wl)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002784{
Juuso Oikarinen7a557242010-09-27 12:42:07 +02002785 static const u32 cipher_suites[] = {
2786 WLAN_CIPHER_SUITE_WEP40,
2787 WLAN_CIPHER_SUITE_WEP104,
2788 WLAN_CIPHER_SUITE_TKIP,
2789 WLAN_CIPHER_SUITE_CCMP,
2790 WL1271_CIPHER_SUITE_GEM,
2791 };
2792
Juuso Oikarinen1e2b7972009-10-08 21:56:20 +03002793 /* The tx descriptor buffer and the TKIP space. */
2794 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
2795 sizeof(struct wl1271_tx_hw_descr);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002796
2797 /* unit us */
2798 /* FIXME: find a proper value */
2799 wl->hw->channel_change_time = 10000;
Juuso Oikarinen50c500a2010-04-01 11:38:22 +03002800 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002801
2802 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
Juuso Oikarinen03442a32009-11-23 23:22:14 +02002803 IEEE80211_HW_BEACON_FILTER |
Juuso Oikarinen0a343322010-02-22 08:38:41 +02002804 IEEE80211_HW_SUPPORTS_PS |
Kalle Valo4695dc92010-03-18 12:26:38 +02002805 IEEE80211_HW_SUPPORTS_UAPSD |
Juuso Oikarinena9af0922010-03-26 12:53:30 +02002806 IEEE80211_HW_HAS_RATE_CONTROL |
Juuso Oikarinen00236aed2010-04-09 11:07:30 +03002807 IEEE80211_HW_CONNECTION_MONITOR |
2808 IEEE80211_HW_SUPPORTS_CQM_RSSI;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002809
Juuso Oikarinen7a557242010-09-27 12:42:07 +02002810 wl->hw->wiphy->cipher_suites = cipher_suites;
2811 wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
2812
Juuso Oikarinene0d8bbf2009-12-11 15:41:04 +02002813 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2814 BIT(NL80211_IFTYPE_ADHOC);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002815 wl->hw->wiphy->max_scan_ssids = 1;
Guy Eilamea559b42010-12-09 16:54:59 +02002816 /*
2817 * Maximum length of elements in scanning probe request templates
2818 * should be the maximum length possible for a template, without
2819 * the IEEE80211 header of the template
2820 */
2821 wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
2822 sizeof(struct ieee80211_header);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002823 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
Juuso Oikarinen11eb5422010-08-24 06:28:03 +03002824 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
Teemu Paasikivi1ebec3d2009-10-13 12:47:48 +03002825
Kalle Valo12bd8942010-03-18 12:26:33 +02002826 wl->hw->queues = 4;
Juuso Oikarinen31627dc2010-03-26 12:53:12 +02002827 wl->hw->max_rates = 1;
Kalle Valo12bd8942010-03-18 12:26:33 +02002828
Juuso Oikarinenb7417d92010-11-10 11:27:19 +01002829 wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
2830
Teemu Paasikivi8197b712010-02-22 08:38:23 +02002831 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002832
2833 return 0;
2834}
Teemu Paasikivi50b3eb42010-02-22 08:38:26 +02002835EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002836
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002837#define WL1271_DEFAULT_CHANNEL 0
Teemu Paasikivic332a4b2010-02-18 13:25:57 +02002838
Teemu Paasikivi2d5e82b2010-02-22 08:38:21 +02002839struct ieee80211_hw *wl1271_alloc_hw(void)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002840{
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002841 struct ieee80211_hw *hw;
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02002842 struct platform_device *plat_dev = NULL;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002843 struct wl1271 *wl;
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02002844 int i, ret;
Ido Yariv1f37cbc2010-09-30 13:28:27 +02002845 unsigned int order;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002846
2847 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2848 if (!hw) {
2849 wl1271_error("could not alloc ieee80211_hw");
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02002850 ret = -ENOMEM;
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02002851 goto err_hw_alloc;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002852 }
2853
Julia Lawall929ebd32010-05-15 23:16:39 +02002854 plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02002855 if (!plat_dev) {
2856 wl1271_error("could not allocate platform_device");
2857 ret = -ENOMEM;
2858 goto err_plat_alloc;
2859 }
2860
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002861 wl = hw->priv;
2862 memset(wl, 0, sizeof(*wl));
2863
Juuso Oikarinen01c09162009-10-13 12:47:55 +03002864 INIT_LIST_HEAD(&wl->list);
2865
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002866 wl->hw = hw;
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02002867 wl->plat_dev = plat_dev;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002868
Juuso Oikarinen6742f552010-12-13 09:52:37 +02002869 for (i = 0; i < NUM_TX_QUEUES; i++)
2870 skb_queue_head_init(&wl->tx_queue[i]);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002871
Juuso Oikarinen37b70a82009-10-08 21:56:21 +03002872 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
Juuso Oikarinen90494a92010-07-08 17:50:00 +03002873 INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
Juuso Oikarinen117b38d2010-09-30 10:43:28 +02002874 INIT_WORK(&wl->irq_work, wl1271_irq_work);
2875 INIT_WORK(&wl->tx_work, wl1271_tx_work);
2876 INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
2877 INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002878 wl->channel = WL1271_DEFAULT_CHANNEL;
Juuso Oikarinen60e84c22010-03-26 12:53:25 +02002879 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002880 wl->default_key = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002881 wl->rx_counter = 0;
Arik Nemtsovae113b52010-10-16 18:45:07 +02002882 wl->rx_config = WL1271_DEFAULT_STA_RX_CONFIG;
2883 wl->rx_filter = WL1271_DEFAULT_STA_RX_FILTER;
Juuso Oikarinen19ad0712009-11-02 20:22:11 +02002884 wl->psm_entry_retry = 0;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002885 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
Juuso Oikarinena6fe2312009-12-11 15:40:58 +02002886 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
Juuso Oikarinenebba60c2010-04-01 11:38:20 +03002887 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
Juuso Oikarinen830fb672009-12-11 15:41:06 +02002888 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2889 wl->sta_rate_set = 0;
Juuso Oikarinen8a5a37a2009-10-08 21:56:24 +03002890 wl->band = IEEE80211_BAND_2GHZ;
Juuso Oikarinenb771eee2009-10-08 21:56:34 +03002891 wl->vif = NULL;
Juuso Oikarinen830fb672009-12-11 15:41:06 +02002892 wl->flags = 0;
Juuso Oikarinen7fc3a862010-03-18 12:26:32 +02002893 wl->sg_enabled = true;
Juuso Oikarinend717fd62010-05-07 11:38:58 +03002894 wl->hw_pg_ver = -1;
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002895
Ido Yariv25eeb9e2010-10-12 16:20:06 +02002896 memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
Juuso Oikarinenbe7078c2009-10-08 21:56:26 +03002897 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002898 wl->tx_frames[i] = NULL;
2899
2900 spin_lock_init(&wl->wl_lock);
2901
Luciano Coelhof5fc0f82009-08-06 16:25:28 +03002902 wl->state = WL1271_STATE_OFF;
2903 mutex_init(&wl->mutex);
2904
Teemu Paasikivic332a4b2010-02-18 13:25:57 +02002905 /* Apply default driver configuration. */
2906 wl1271_conf_init(wl);
2907
Ido Yariv1f37cbc2010-09-30 13:28:27 +02002908 order = get_order(WL1271_AGGR_BUFFER_SIZE);
2909 wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
2910 if (!wl->aggr_buf) {
2911 ret = -ENOMEM;
2912 goto err_hw;
2913 }
2914
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02002915 /* Register platform device */
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02002916 ret = platform_device_register(wl->plat_dev);
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02002917 if (ret) {
2918 wl1271_error("couldn't register platform device");
Ido Yariv1f37cbc2010-09-30 13:28:27 +02002919 goto err_aggr;
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02002920 }
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02002921 dev_set_drvdata(&wl->plat_dev->dev, wl);
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02002922
Juuso Oikarinen7fc3a862010-03-18 12:26:32 +02002923 /* Create sysfs file to control bt coex state */
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02002924 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
Juuso Oikarinen7fc3a862010-03-18 12:26:32 +02002925 if (ret < 0) {
2926 wl1271_error("failed to create sysfs file bt_coex_state");
2927 goto err_platform;
2928 }
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02002929
Juuso Oikarinend717fd62010-05-07 11:38:58 +03002930 /* Create sysfs file to get HW PG version */
2931 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
2932 if (ret < 0) {
2933 wl1271_error("failed to create sysfs file hw_pg_ver");
2934 goto err_bt_coex_state;
2935 }
2936
Teemu Paasikivic332a4b2010-02-18 13:25:57 +02002937 return hw;
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02002938
Juuso Oikarinend717fd62010-05-07 11:38:58 +03002939err_bt_coex_state:
2940 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2941
Juuso Oikarinen7fc3a862010-03-18 12:26:32 +02002942err_platform:
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02002943 platform_device_unregister(wl->plat_dev);
Juuso Oikarinen7fc3a862010-03-18 12:26:32 +02002944
Ido Yariv1f37cbc2010-09-30 13:28:27 +02002945err_aggr:
2946 free_pages((unsigned long)wl->aggr_buf, order);
2947
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02002948err_hw:
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02002949 wl1271_debugfs_exit(wl);
2950 kfree(plat_dev);
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02002951
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02002952err_plat_alloc:
2953 ieee80211_free_hw(hw);
2954
2955err_hw_alloc:
2956
Juuso Oikarinena1dd8182010-03-18 12:26:31 +02002957 return ERR_PTR(ret);
Teemu Paasikivic332a4b2010-02-18 13:25:57 +02002958}
Teemu Paasikivi50b3eb42010-02-22 08:38:26 +02002959EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
Teemu Paasikivic332a4b2010-02-18 13:25:57 +02002960
2961int wl1271_free_hw(struct wl1271 *wl)
2962{
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02002963 platform_device_unregister(wl->plat_dev);
Ido Yariv1f37cbc2010-09-30 13:28:27 +02002964 free_pages((unsigned long)wl->aggr_buf,
2965 get_order(WL1271_AGGR_BUFFER_SIZE));
Teemu Paasikivi3b56dd62010-03-18 12:26:46 +02002966 kfree(wl->plat_dev);
Teemu Paasikivic332a4b2010-02-18 13:25:57 +02002967
2968 wl1271_debugfs_exit(wl);
2969
Teemu Paasikivic332a4b2010-02-18 13:25:57 +02002970 vfree(wl->fw);
2971 wl->fw = NULL;
2972 kfree(wl->nvs);
2973 wl->nvs = NULL;
2974
2975 kfree(wl->fw_status);
2976 kfree(wl->tx_res_if);
2977
2978 ieee80211_free_hw(wl->hw);
2979
2980 return 0;
2981}
Teemu Paasikivi50b3eb42010-02-22 08:38:26 +02002982EXPORT_SYMBOL_GPL(wl1271_free_hw);
2983
Eliad Peller17c17552010-12-12 12:15:35 +02002984u32 wl12xx_debug_level;
2985EXPORT_SYMBOL_GPL(wl12xx_debug_level);
2986module_param_named(debug_level, wl12xx_debug_level, uint, DEBUG_NONE);
2987MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
2988
Teemu Paasikivi50b3eb42010-02-22 08:38:26 +02002989MODULE_LICENSE("GPL");
2990MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2991MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");