main.c 113.3 KB
Newer Older
L
Luciano Coelho 已提交
1 2 3
/*
 * This file is part of wl1271
 *
J
Juuso Oikarinen 已提交
4
 * Copyright (C) 2008-2010 Nokia Corporation
L
Luciano Coelho 已提交
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
 *
 * Contact: Luciano Coelho <luciano.coelho@nokia.com>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 *
 */

#include <linux/module.h>
#include <linux/firmware.h>
#include <linux/delay.h>
#include <linux/spi/spi.h>
#include <linux/crc32.h>
#include <linux/etherdevice.h>
30
#include <linux/vmalloc.h>
31
#include <linux/platform_device.h>
32
#include <linux/slab.h>
33
#include <linux/wl12xx.h>
34
#include <linux/sched.h>
L
Luciano Coelho 已提交
35

S
Shahar Levi 已提交
36
#include "wl12xx.h"
L
Luciano Coelho 已提交
37
#include "wl12xx_80211.h"
S
Shahar Levi 已提交
38 39 40 41 42 43 44 45 46 47 48 49
#include "reg.h"
#include "io.h"
#include "event.h"
#include "tx.h"
#include "rx.h"
#include "ps.h"
#include "init.h"
#include "debugfs.h"
#include "cmd.h"
#include "boot.h"
#include "testmode.h"
#include "scan.h"
L
Luciano Coelho 已提交
50

51 52
#define WL1271_BOOT_RETRIES 3

53 54
static struct conf_drv_settings default_conf = {
	.sg = {
A
Arik Nemtsov 已提交
55
		.sta_params = {
56 57 58
			[CONF_SG_BT_PER_THRESHOLD]                  = 7500,
			[CONF_SG_HV3_MAX_OVERRIDE]                  = 0,
			[CONF_SG_BT_NFS_SAMPLE_INTERVAL]            = 400,
59
			[CONF_SG_BT_LOAD_RATIO]                     = 200,
60
			[CONF_SG_AUTO_PS_MODE]                      = 1,
61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104
			[CONF_SG_AUTO_SCAN_PROBE_REQ]               = 170,
			[CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3]   = 50,
			[CONF_SG_ANTENNA_CONFIGURATION]             = 0,
			[CONF_SG_BEACON_MISS_PERCENT]               = 60,
			[CONF_SG_RATE_ADAPT_THRESH]                 = 12,
			[CONF_SG_RATE_ADAPT_SNR]                    = 0,
			[CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR]      = 10,
			[CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR]      = 30,
			[CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR]      = 8,
			[CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR]       = 20,
			[CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR]       = 50,
			/* Note: with UPSD, this should be 4 */
			[CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR]       = 8,
			[CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR]     = 7,
			[CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR]     = 25,
			[CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR]     = 20,
			/* Note: with UPDS, this should be 15 */
			[CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR]      = 8,
			/* Note: with UPDS, this should be 50 */
			[CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR]      = 40,
			/* Note: with UPDS, this should be 10 */
			[CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR]      = 20,
			[CONF_SG_RXT]                               = 1200,
			[CONF_SG_TXT]                               = 1000,
			[CONF_SG_ADAPTIVE_RXT_TXT]                  = 1,
			[CONF_SG_PS_POLL_TIMEOUT]                   = 10,
			[CONF_SG_UPSD_TIMEOUT]                      = 10,
			[CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7,
			[CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15,
			[CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15,
			[CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR]  = 8,
			[CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR]  = 20,
			[CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR]  = 15,
			[CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR]         = 20,
			[CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR]         = 50,
			[CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR]         = 10,
			[CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3]  = 200,
			[CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800,
			[CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME]         = 75,
			[CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME]       = 15,
			[CONF_SG_HV3_MAX_SERVED]                    = 6,
			[CONF_SG_DHCP_TIME]                         = 5000,
			[CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP]  = 100,
		},
A
Arik Nemtsov 已提交
105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159
		.ap_params = {
			[CONF_SG_BT_PER_THRESHOLD]                  = 7500,
			[CONF_SG_HV3_MAX_OVERRIDE]                  = 0,
			[CONF_SG_BT_NFS_SAMPLE_INTERVAL]            = 400,
			[CONF_SG_BT_LOAD_RATIO]                     = 50,
			[CONF_SG_AUTO_PS_MODE]                      = 1,
			[CONF_SG_AUTO_SCAN_PROBE_REQ]               = 170,
			[CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3]   = 50,
			[CONF_SG_ANTENNA_CONFIGURATION]             = 0,
			[CONF_SG_BEACON_MISS_PERCENT]               = 60,
			[CONF_SG_RATE_ADAPT_THRESH]                 = 64,
			[CONF_SG_RATE_ADAPT_SNR]                    = 1,
			[CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR]      = 10,
			[CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR]      = 25,
			[CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR]      = 25,
			[CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR]       = 20,
			[CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR]       = 25,
			[CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR]       = 25,
			[CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR]     = 7,
			[CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR]     = 25,
			[CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR]     = 25,
			[CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR]      = 8,
			[CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR]      = 25,
			[CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR]      = 25,
			[CONF_SG_RXT]                               = 1200,
			[CONF_SG_TXT]                               = 1000,
			[CONF_SG_ADAPTIVE_RXT_TXT]                  = 1,
			[CONF_SG_PS_POLL_TIMEOUT]                   = 10,
			[CONF_SG_UPSD_TIMEOUT]                      = 10,
			[CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7,
			[CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15,
			[CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15,
			[CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR]  = 8,
			[CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR]  = 20,
			[CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR]  = 15,
			[CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR]         = 20,
			[CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR]         = 50,
			[CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR]         = 10,
			[CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3]  = 200,
			[CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800,
			[CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME]         = 75,
			[CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME]       = 15,
			[CONF_SG_HV3_MAX_SERVED]                    = 6,
			[CONF_SG_DHCP_TIME]                         = 5000,
			[CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP]  = 100,
			[CONF_SG_TEMP_PARAM_1]                      = 0,
			[CONF_SG_TEMP_PARAM_2]                      = 0,
			[CONF_SG_TEMP_PARAM_3]                      = 0,
			[CONF_SG_TEMP_PARAM_4]                      = 0,
			[CONF_SG_TEMP_PARAM_5]                      = 0,
			[CONF_SG_AP_BEACON_MISS_TX]                 = 3,
			[CONF_SG_RX_WINDOW_LENGTH]                  = 6,
			[CONF_SG_AP_CONNECTION_PROTECTION_TIME]     = 50,
			[CONF_SG_TEMP_PARAM_6]                      = 1,
		},
160
		.state = CONF_SG_PROTECTIVE,
161 162 163 164 165 166
	},
	.rx = {
		.rx_msdu_life_time           = 512000,
		.packet_detection_threshold  = 0,
		.ps_poll_timeout             = 15,
		.upsd_timeout                = 15,
167
		.rts_threshold               = IEEE80211_MAX_RTS_THRESHOLD,
168 169 170 171
		.rx_cca_threshold            = 0,
		.irq_blk_threshold           = 0xFFFF,
		.irq_pkt_threshold           = 0,
		.irq_timeout                 = 600,
172 173 174 175
		.queue_type                  = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
	},
	.tx = {
		.tx_energy_detection         = 0,
176
		.sta_rc_conf                 = {
177
			.enabled_rates       = 0,
178 179
			.short_retry_limit   = 10,
			.long_retry_limit    = 10,
180
			.aflags              = 0,
181
		},
182 183
		.ac_conf_count               = 4,
		.ac_conf                     = {
184
			[CONF_TX_AC_BE] = {
185 186 187 188 189
				.ac          = CONF_TX_AC_BE,
				.cw_min      = 15,
				.cw_max      = 63,
				.aifsn       = 3,
				.tx_op_limit = 0,
190
			},
191
			[CONF_TX_AC_BK] = {
192 193 194 195 196
				.ac          = CONF_TX_AC_BK,
				.cw_min      = 15,
				.cw_max      = 63,
				.aifsn       = 7,
				.tx_op_limit = 0,
197
			},
198
			[CONF_TX_AC_VI] = {
199 200 201 202 203 204
				.ac          = CONF_TX_AC_VI,
				.cw_min      = 15,
				.cw_max      = 63,
				.aifsn       = CONF_TX_AIFS_PIFS,
				.tx_op_limit = 3008,
			},
205
			[CONF_TX_AC_VO] = {
206 207 208 209 210
				.ac          = CONF_TX_AC_VO,
				.cw_min      = 15,
				.cw_max      = 63,
				.aifsn       = CONF_TX_AIFS_PIFS,
				.tx_op_limit = 1504,
211
			},
212
		},
213 214
		.max_tx_retries = 100,
		.ap_aging_period = 300,
215
		.tid_conf_count = 4,
216
		.tid_conf = {
217 218 219
			[CONF_TX_AC_BE] = {
				.queue_id    = CONF_TX_AC_BE,
				.channel_type = CONF_CHANNEL_TYPE_EDCF,
220 221 222 223
				.tsid        = CONF_TX_AC_BE,
				.ps_scheme   = CONF_PS_SCHEME_LEGACY,
				.ack_policy  = CONF_ACK_POLICY_LEGACY,
				.apsd_conf   = {0, 0},
224
			},
225 226 227 228
			[CONF_TX_AC_BK] = {
				.queue_id    = CONF_TX_AC_BK,
				.channel_type = CONF_CHANNEL_TYPE_EDCF,
				.tsid        = CONF_TX_AC_BK,
229 230 231 232
				.ps_scheme   = CONF_PS_SCHEME_LEGACY,
				.ack_policy  = CONF_ACK_POLICY_LEGACY,
				.apsd_conf   = {0, 0},
			},
233 234 235 236
			[CONF_TX_AC_VI] = {
				.queue_id    = CONF_TX_AC_VI,
				.channel_type = CONF_CHANNEL_TYPE_EDCF,
				.tsid        = CONF_TX_AC_VI,
237 238 239 240
				.ps_scheme   = CONF_PS_SCHEME_LEGACY,
				.ack_policy  = CONF_ACK_POLICY_LEGACY,
				.apsd_conf   = {0, 0},
			},
241 242 243 244
			[CONF_TX_AC_VO] = {
				.queue_id    = CONF_TX_AC_VO,
				.channel_type = CONF_CHANNEL_TYPE_EDCF,
				.tsid        = CONF_TX_AC_VO,
245 246 247 248 249 250
				.ps_scheme   = CONF_PS_SCHEME_LEGACY,
				.ack_policy  = CONF_ACK_POLICY_LEGACY,
				.apsd_conf   = {0, 0},
			},
		},
		.frag_threshold              = IEEE80211_MAX_FRAG_THRESHOLD,
251
		.tx_compl_timeout            = 700,
252 253 254
		.tx_compl_threshold          = 4,
		.basic_rate                  = CONF_HW_BIT_RATE_1MBPS,
		.basic_rate_5                = CONF_HW_BIT_RATE_6MBPS,
255 256
		.tmpl_short_retry_limit      = 10,
		.tmpl_long_retry_limit       = 10,
257 258 259
	},
	.conn = {
		.wake_up_event               = CONF_WAKE_UP_EVENT_DTIM,
260
		.listen_interval             = 1,
261
		.bcn_filt_mode               = CONF_BCN_FILT_MODE_ENABLED,
262
		.bcn_filt_ie_count           = 2,
263 264 265 266
		.bcn_filt_ie = {
			[0] = {
				.ie          = WLAN_EID_CHANNEL_SWITCH,
				.rule        = CONF_BCN_RULE_PASS_ON_APPEARANCE,
267 268 269 270 271
			},
			[1] = {
				.ie          = WLAN_EID_HT_INFORMATION,
				.rule        = CONF_BCN_RULE_PASS_ON_CHANGE,
			},
272
		},
273
		.synch_fail_thold            = 10,
274 275 276 277
		.bss_lose_timeout            = 100,
		.beacon_rx_timeout           = 10000,
		.broadcast_timeout           = 20000,
		.rx_broadcast_in_ps          = 1,
278 279
		.ps_poll_threshold           = 10,
		.ps_poll_recovery_period     = 700,
280
		.bet_enable                  = CONF_BET_MODE_ENABLE,
281
		.bet_max_consecutive         = 50,
282
		.psm_entry_retries           = 5,
283
		.psm_exit_retries            = 16,
284 285
		.psm_entry_nullfunc_retries  = 3,
		.psm_entry_hangover_period   = 1,
286 287
		.keep_alive_interval         = 55000,
		.max_listen_interval         = 20,
288
	},
289 290 291
	.itrim = {
		.enable = false,
		.timeout = 50000,
292 293 294 295
	},
	.pm_config = {
		.host_clk_settling_time = 5000,
		.host_fast_wakeup_support = false
296 297 298 299 300 301
	},
	.roam_trigger = {
		.trigger_pacing               = 1,
		.avg_weight_rssi_beacon       = 20,
		.avg_weight_rssi_data         = 10,
		.avg_weight_snr_beacon        = 20,
L
Levi, Shahar 已提交
302
		.avg_weight_snr_data          = 10,
J
Juuso Oikarinen 已提交
303 304 305 306
	},
	.scan = {
		.min_dwell_time_active        = 7500,
		.max_dwell_time_active        = 30000,
307 308
		.min_dwell_time_passive       = 100000,
		.max_dwell_time_passive       = 100000,
J
Juuso Oikarinen 已提交
309 310
		.num_probe_reqs               = 2,
	},
311 312 313 314 315
	.sched_scan = {
		/* sched_scan requires dwell times in TU instead of TU/1000 */
		.min_dwell_time_active = 8,
		.max_dwell_time_active = 30,
		.dwell_time_passive    = 100,
316
		.dwell_time_dfs        = 150,
317 318 319 320
		.num_probe_reqs        = 2,
		.rssi_threshold        = -90,
		.snr_threshold         = 0,
	},
321 322 323 324 325 326 327 328 329 330
	.rf = {
		.tx_per_channel_power_compensation_2 = {
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		},
		.tx_per_channel_power_compensation_5 = {
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
			0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		},
	},
L
Levi, Shahar 已提交
331 332 333 334
	.ht = {
		.tx_ba_win_size = 64,
		.inactivity_timeout = 10000,
	},
335
	.mem_wl127x = {
336 337 338 339
		.num_stations                 = 1,
		.ssid_profiles                = 1,
		.rx_block_num                 = 70,
		.tx_min_block_num             = 40,
340
		.dynamic_memory               = 1,
341
		.min_req_tx_blocks            = 100,
342 343
		.min_req_rx_blocks            = 22,
		.tx_min                       = 27,
344 345 346 347 348 349 350 351 352 353 354
	},
	.mem_wl128x = {
		.num_stations                 = 1,
		.ssid_profiles                = 1,
		.rx_block_num                 = 40,
		.tx_min_block_num             = 40,
		.dynamic_memory               = 1,
		.min_req_tx_blocks            = 45,
		.min_req_rx_blocks            = 22,
		.tx_min                       = 27,
	},
S
Shahar Levi 已提交
355 356 357 358 359 360 361 362 363 364 365 366
	.fm_coex = {
		.enable                       = true,
		.swallow_period               = 5,
		.n_divider_fref_set_1         = 0xff,       /* default */
		.n_divider_fref_set_2         = 12,
		.m_divider_fref_set_1         = 148,
		.m_divider_fref_set_2         = 0xffff,     /* default */
		.coex_pll_stabilization_time  = 0xffffffff, /* default */
		.ldo_stabilization_time       = 0xffff,     /* default */
		.fm_disturbed_band_margin     = 0xff,       /* default */
		.swallow_clk_diff             = 0xff,       /* default */
	},
367 368 369 370
	.rx_streaming = {
		.duration                      = 150,
		.queues                        = 0x1,
		.interval                      = 20,
371
		.always                        = 0,
372
	},
373 374 375 376 377 378 379 380
	.fwlog = {
		.mode                         = WL12XX_FWLOG_ON_DEMAND,
		.mem_blocks                   = 2,
		.severity                     = 0,
		.timestamp                    = WL12XX_FWLOG_TIMESTAMP_DISABLED,
		.output                       = WL12XX_FWLOG_OUTPUT_HOST,
		.threshold                    = 0,
	},
381
	.hci_io_ds = HCI_IO_DS_6MA,
382 383
};

384 385
static char *fwlog_param;

386 387
static void __wl1271_op_remove_interface(struct wl1271 *wl,
					 bool reset_tx_queues);
388
static void wl1271_free_ap_keys(struct wl1271 *wl);
389 390


391 392 393 394 395 396 397 398 399 400 401 402 403 404 405
static void wl1271_device_release(struct device *dev)
{

}

static struct platform_device wl1271_device = {
	.name           = "wl1271",
	.id             = -1,

	/* device model insists to have a release function */
	.dev            = {
		.release = wl1271_device_release,
	},
};

406
static DEFINE_MUTEX(wl_list_mutex);
407 408
static LIST_HEAD(wl_list);

409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424
static int wl1271_check_operstate(struct wl1271 *wl, unsigned char operstate)
{
	int ret;
	if (operstate != IF_OPER_UP)
		return 0;

	if (test_and_set_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags))
		return 0;

	ret = wl1271_cmd_set_sta_state(wl);
	if (ret < 0)
		return ret;

	wl1271_info("Association completed.");
	return 0;
}
425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452
static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
			     void *arg)
{
	struct net_device *dev = arg;
	struct wireless_dev *wdev;
	struct wiphy *wiphy;
	struct ieee80211_hw *hw;
	struct wl1271 *wl;
	struct wl1271 *wl_temp;
	int ret = 0;

	/* Check that this notification is for us. */
	if (what != NETDEV_CHANGE)
		return NOTIFY_DONE;

	wdev = dev->ieee80211_ptr;
	if (wdev == NULL)
		return NOTIFY_DONE;

	wiphy = wdev->wiphy;
	if (wiphy == NULL)
		return NOTIFY_DONE;

	hw = wiphy_priv(wiphy);
	if (hw == NULL)
		return NOTIFY_DONE;

	wl_temp = hw->priv;
453
	mutex_lock(&wl_list_mutex);
454 455 456 457
	list_for_each_entry(wl, &wl_list, list) {
		if (wl == wl_temp)
			break;
	}
458
	mutex_unlock(&wl_list_mutex);
459 460 461 462 463 464 465 466 467 468 469
	if (wl != wl_temp)
		return NOTIFY_DONE;

	mutex_lock(&wl->mutex);

	if (wl->state == WL1271_STATE_OFF)
		goto out;

	if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
		goto out;

470
	ret = wl1271_ps_elp_wakeup(wl);
471 472 473
	if (ret < 0)
		goto out;

474
	wl1271_check_operstate(wl, dev->operstate);
475 476 477 478 479 480 481 482 483

	wl1271_ps_elp_sleep(wl);

out:
	mutex_unlock(&wl->mutex);

	return NOTIFY_OK;
}

484
static int wl1271_reg_notify(struct wiphy *wiphy,
485 486
			     struct regulatory_request *request)
{
487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505
	struct ieee80211_supported_band *band;
	struct ieee80211_channel *ch;
	int i;

	band = wiphy->bands[IEEE80211_BAND_5GHZ];
	for (i = 0; i < band->n_channels; i++) {
		ch = &band->channels[i];
		if (ch->flags & IEEE80211_CHAN_DISABLED)
			continue;

		if (ch->flags & IEEE80211_CHAN_RADAR)
			ch->flags |= IEEE80211_CHAN_NO_IBSS |
				     IEEE80211_CHAN_PASSIVE_SCAN;

	}

	return 0;
}

506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616
static int wl1271_set_rx_streaming(struct wl1271 *wl, bool enable)
{
	int ret = 0;

	/* we should hold wl->mutex */
	ret = wl1271_acx_ps_rx_streaming(wl, enable);
	if (ret < 0)
		goto out;

	if (enable)
		set_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags);
	else
		clear_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags);
out:
	return ret;
}

/*
 * this function is being called when the rx_streaming interval
 * has beed changed or rx_streaming should be disabled
 */
int wl1271_recalc_rx_streaming(struct wl1271 *wl)
{
	int ret = 0;
	int period = wl->conf.rx_streaming.interval;

	/* don't reconfigure if rx_streaming is disabled */
	if (!test_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags))
		goto out;

	/* reconfigure/disable according to new streaming_period */
	if (period &&
	    test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags) &&
	    (wl->conf.rx_streaming.always ||
	     test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags)))
		ret = wl1271_set_rx_streaming(wl, true);
	else {
		ret = wl1271_set_rx_streaming(wl, false);
		/* don't cancel_work_sync since we might deadlock */
		del_timer_sync(&wl->rx_streaming_timer);
	}
out:
	return ret;
}

static void wl1271_rx_streaming_enable_work(struct work_struct *work)
{
	int ret;
	struct wl1271 *wl =
		container_of(work, struct wl1271, rx_streaming_enable_work);

	mutex_lock(&wl->mutex);

	if (test_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags) ||
	    !test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags) ||
	    (!wl->conf.rx_streaming.always &&
	     !test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags)))
		goto out;

	if (!wl->conf.rx_streaming.interval)
		goto out;

	ret = wl1271_ps_elp_wakeup(wl);
	if (ret < 0)
		goto out;

	ret = wl1271_set_rx_streaming(wl, true);
	if (ret < 0)
		goto out_sleep;

	/* stop it after some time of inactivity */
	mod_timer(&wl->rx_streaming_timer,
		  jiffies + msecs_to_jiffies(wl->conf.rx_streaming.duration));

out_sleep:
	wl1271_ps_elp_sleep(wl);
out:
	mutex_unlock(&wl->mutex);
}

static void wl1271_rx_streaming_disable_work(struct work_struct *work)
{
	int ret;
	struct wl1271 *wl =
		container_of(work, struct wl1271, rx_streaming_disable_work);

	mutex_lock(&wl->mutex);

	if (!test_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags))
		goto out;

	ret = wl1271_ps_elp_wakeup(wl);
	if (ret < 0)
		goto out;

	ret = wl1271_set_rx_streaming(wl, false);
	if (ret)
		goto out_sleep;

out_sleep:
	wl1271_ps_elp_sleep(wl);
out:
	mutex_unlock(&wl->mutex);
}

static void wl1271_rx_streaming_timer(unsigned long data)
{
	struct wl1271 *wl = (struct wl1271 *)data;
	ieee80211_queue_work(wl->hw, &wl->rx_streaming_disable_work);
}

617 618
static void wl1271_conf_init(struct wl1271 *wl)
{
619 620 621 622 623 624 625 626 627 628 629 630

	/*
	 * This function applies the default configuration to the driver. This
	 * function is invoked upon driver load (spi probe.)
	 *
	 * The configuration is stored in a run-time structure in order to
	 * facilitate for run-time adjustment of any of the parameters. Making
	 * changes to the configuration structure will apply the new values on
	 * the next interface up (wl1271_op_start.)
	 */

	/* apply driver default configuration */
631
	memcpy(&wl->conf, &default_conf, sizeof(default_conf));
632

633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649
	/* Adjust settings according to optional module parameters */
	if (fwlog_param) {
		if (!strcmp(fwlog_param, "continuous")) {
			wl->conf.fwlog.mode = WL12XX_FWLOG_CONTINUOUS;
		} else if (!strcmp(fwlog_param, "ondemand")) {
			wl->conf.fwlog.mode = WL12XX_FWLOG_ON_DEMAND;
		} else if (!strcmp(fwlog_param, "dbgpins")) {
			wl->conf.fwlog.mode = WL12XX_FWLOG_CONTINUOUS;
			wl->conf.fwlog.output = WL12XX_FWLOG_OUTPUT_DBG_PINS;
		} else if (!strcmp(fwlog_param, "disable")) {
			wl->conf.fwlog.mem_blocks = 0;
			wl->conf.fwlog.output = WL12XX_FWLOG_OUTPUT_NONE;
		} else {
			wl1271_error("Unknown fwlog parameter %s", fwlog_param);
		}
	}
}
650

L
Luciano Coelho 已提交
651 652
static int wl1271_plt_init(struct wl1271 *wl)
{
653 654 655
	struct conf_tx_ac_category *conf_ac;
	struct conf_tx_tid *conf_tid;
	int ret, i;
L
Luciano Coelho 已提交
656

657 658 659 660
	if (wl->chip.id == CHIP_ID_1283_PG20)
		ret = wl128x_cmd_general_parms(wl);
	else
		ret = wl1271_cmd_general_parms(wl);
661
	if (ret < 0)
662 663
		return ret;

664 665 666 667
	if (wl->chip.id == CHIP_ID_1283_PG20)
		ret = wl128x_cmd_radio_parms(wl);
	else
		ret = wl1271_cmd_radio_parms(wl);
668
	if (ret < 0)
669 670
		return ret;

671 672 673 674 675
	if (wl->chip.id != CHIP_ID_1283_PG20) {
		ret = wl1271_cmd_ext_radio_parms(wl);
		if (ret < 0)
			return ret;
	}
676 677 678
	if (ret < 0)
		return ret;

679 680 681 682 683
	/* Chip-specific initializations */
	ret = wl1271_chip_specific_init(wl);
	if (ret < 0)
		return ret;

A
Arik Nemtsov 已提交
684
	ret = wl1271_sta_init_templates_config(wl);
685 686 687
	if (ret < 0)
		return ret;

L
Luciano Coelho 已提交
688 689 690 691
	ret = wl1271_acx_init_mem_config(wl);
	if (ret < 0)
		return ret;

692 693 694 695 696 697 698 699 700 701
	/* PHY layer config */
	ret = wl1271_init_phy_config(wl);
	if (ret < 0)
		goto out_free_memmap;

	ret = wl1271_acx_dco_itrim_params(wl);
	if (ret < 0)
		goto out_free_memmap;

	/* Initialize connection monitoring thresholds */
702
	ret = wl1271_acx_conn_monit_params(wl, false);
703 704 705 706 707 708 709 710
	if (ret < 0)
		goto out_free_memmap;

	/* Bluetooth WLAN coexistence */
	ret = wl1271_init_pta(wl);
	if (ret < 0)
		goto out_free_memmap;

S
Shahar Levi 已提交
711 712 713 714 715
	/* FM WLAN coexistence */
	ret = wl1271_acx_fm_coex(wl);
	if (ret < 0)
		goto out_free_memmap;

716 717 718 719 720
	/* Energy detection */
	ret = wl1271_init_energy_detection(wl);
	if (ret < 0)
		goto out_free_memmap;

721 722 723 724
	ret = wl1271_acx_sta_mem_cfg(wl);
	if (ret < 0)
		goto out_free_memmap;

725
	/* Default fragmentation threshold */
726
	ret = wl1271_acx_frag_threshold(wl, wl->conf.tx.frag_threshold);
727 728 729
	if (ret < 0)
		goto out_free_memmap;

730 731
	/* Default TID/AC configuration */
	BUG_ON(wl->conf.tx.tid_conf_count != wl->conf.tx.ac_conf_count);
732
	for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
733 734 735 736 737 738 739
		conf_ac = &wl->conf.tx.ac_conf[i];
		ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
					conf_ac->cw_max, conf_ac->aifsn,
					conf_ac->tx_op_limit);
		if (ret < 0)
			goto out_free_memmap;

740 741 742 743 744 745 746 747 748 749 750 751 752
		conf_tid = &wl->conf.tx.tid_conf[i];
		ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
					 conf_tid->channel_type,
					 conf_tid->tsid,
					 conf_tid->ps_scheme,
					 conf_tid->ack_policy,
					 conf_tid->apsd_conf[0],
					 conf_tid->apsd_conf[1]);
		if (ret < 0)
			goto out_free_memmap;
	}

	/* Enable data path */
753
	ret = wl1271_cmd_data_path(wl, 1);
L
Luciano Coelho 已提交
754
	if (ret < 0)
755 756 757 758 759 760 761 762 763 764 765
		goto out_free_memmap;

	/* Configure for CAM power saving (ie. always active) */
	ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
	if (ret < 0)
		goto out_free_memmap;

	/* configure PM */
	ret = wl1271_acx_pm_config(wl);
	if (ret < 0)
		goto out_free_memmap;
L
Luciano Coelho 已提交
766 767

	return 0;
768 769 770 771 772 773

 out_free_memmap:
	kfree(wl->target_mem_map);
	wl->target_mem_map = NULL;

	return ret;
L
Luciano Coelho 已提交
774 775
}

776
#if 0
777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826
static void wl1271_irq_ps_regulate_link(struct wl1271 *wl, u8 hlid, u8 tx_blks)
{
	bool fw_ps;

	/* only regulate station links */
	if (hlid < WL1271_AP_STA_HLID_START)
		return;

	fw_ps = test_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);

	/*
	 * Wake up from high level PS if the STA is asleep with too little
	 * blocks in FW or if the STA is awake.
	 */
	if (!fw_ps || tx_blks < WL1271_PS_STA_MAX_BLOCKS)
		wl1271_ps_link_end(wl, hlid);

	/* Start high-level PS if the STA is asleep with enough blocks in FW */
	else if (fw_ps && tx_blks >= WL1271_PS_STA_MAX_BLOCKS)
		wl1271_ps_link_start(wl, hlid, true);
}

static void wl1271_irq_update_links_status(struct wl1271 *wl,
				       struct wl1271_fw_ap_status *status)
{
	u32 cur_fw_ps_map;
	u8 hlid;

	cur_fw_ps_map = le32_to_cpu(status->link_ps_bitmap);
	if (wl->ap_fw_ps_map != cur_fw_ps_map) {
		wl1271_debug(DEBUG_PSM,
			     "link ps prev 0x%x cur 0x%x changed 0x%x",
			     wl->ap_fw_ps_map, cur_fw_ps_map,
			     wl->ap_fw_ps_map ^ cur_fw_ps_map);

		wl->ap_fw_ps_map = cur_fw_ps_map;
	}

	for (hlid = WL1271_AP_STA_HLID_START; hlid < AP_MAX_LINKS; hlid++) {
		u8 cnt = status->tx_lnk_free_blks[hlid] -
			wl->links[hlid].prev_freed_blks;

		wl->links[hlid].prev_freed_blks =
			status->tx_lnk_free_blks[hlid];
		wl->links[hlid].allocated_blks -= cnt;

		wl1271_irq_ps_regulate_link(wl, hlid,
					    wl->links[hlid].allocated_blks);
	}
}
827
#endif
828

829
static void wl1271_fw_status(struct wl1271 *wl,
830
			     struct wl1271_fw_full_status *full_status)
L
Luciano Coelho 已提交
831
{
832
	struct wl1271_fw_common_status *status = &full_status->common;
833
	struct timespec ts;
834
	u32 old_tx_blk_count = wl->tx_blocks_available;
835
	u32 freed_blocks = 0;
L
Luciano Coelho 已提交
836 837
	int i;

838
	if (wl->bss_type == BSS_TYPE_AP_BSS) {
839 840
		wl1271_raw_read(wl, FW_STATUS_ADDR, status,
				sizeof(struct wl1271_fw_ap_status), false);
841
	} else {
842 843
		wl1271_raw_read(wl, FW_STATUS_ADDR, status,
				sizeof(struct wl1271_fw_sta_status), false);
844 845
	}

L
Luciano Coelho 已提交
846 847 848 849 850 851 852 853 854
	wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
		     "drv_rx_counter = %d, tx_results_counter = %d)",
		     status->intr,
		     status->fw_rx_counter,
		     status->drv_rx_counter,
		     status->tx_results_counter);

	/* update number of available TX blocks */
	for (i = 0; i < NUM_TX_QUEUES; i++) {
855 856
		freed_blocks += le32_to_cpu(status->tx_released_blks[i]) -
				wl->tx_blocks_freed[i];
L
Luciano Coelho 已提交
857 858 859

		wl->tx_blocks_freed[i] =
			le32_to_cpu(status->tx_released_blks[i]);
860 861
	}

862 863
	wl->tx_allocated_blocks -= freed_blocks;

864 865
	if (wl->bss_type == BSS_TYPE_AP_BSS) {
		/* Update num of allocated TX blocks per link and ps status */
866
#if 0
867
		wl1271_irq_update_links_status(wl, &full_status->ap);
868
#endif
869 870
		wl->tx_blocks_available += freed_blocks;
	} else {
871
		int avail = full_status->sta.tx_total - wl->tx_allocated_blocks;
872

873 874 875 876 877 878 879 880 881 882
		/*
		 * The FW might change the total number of TX memblocks before
		 * we get a notification about blocks being released. Thus, the
		 * available blocks calculation might yield a temporary result
		 * which is lower than the actual available blocks. Keeping in
		 * mind that only blocks that were allocated can be moved from
		 * TX to RX, tx_blocks_available should never decrease here.
		 */
		wl->tx_blocks_available = max((int)wl->tx_blocks_available,
					      avail);
L
Luciano Coelho 已提交
883 884
	}

I
Ido Yariv 已提交
885
	/* if more blocks are available now, tx work can be scheduled */
886
	if (wl->tx_blocks_available > old_tx_blk_count)
I
Ido Yariv 已提交
887
		clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
L
Luciano Coelho 已提交
888 889

	/* update the host-chipset time offset */
890 891 892
	getnstimeofday(&ts);
	wl->time_offset = (timespec_to_ns(&ts) >> 10) -
		(s64)le32_to_cpu(status->fw_localtime);
L
Luciano Coelho 已提交
893 894
}

895 896 897 898 899 900 901 902 903 904
static void wl1271_flush_deferred_work(struct wl1271 *wl)
{
	struct sk_buff *skb;

	/* Pass all received frames to the network stack */
	while ((skb = skb_dequeue(&wl->deferred_rx_queue)))
		ieee80211_rx_ni(wl->hw, skb);

	/* Return sent skbs to the network stack */
	while ((skb = skb_dequeue(&wl->deferred_tx_queue)))
905
		ieee80211_tx_status_ni(wl->hw, skb);
906 907 908 909 910 911 912 913 914 915 916
}

static void wl1271_netstack_work(struct work_struct *work)
{
	struct wl1271 *wl =
		container_of(work, struct wl1271, netstack_work);

	do {
		wl1271_flush_deferred_work(wl);
	} while (skb_queue_len(&wl->deferred_rx_queue));
}
917

918 919 920
#define WL1271_IRQ_MAX_LOOPS 256

irqreturn_t wl1271_irq(int irq, void *cookie)
L
Luciano Coelho 已提交
921 922
{
	int ret;
923
	u32 intr;
924
	int loopcount = WL1271_IRQ_MAX_LOOPS;
925 926 927
	struct wl1271 *wl = (struct wl1271 *)cookie;
	bool done = false;
	unsigned int defer_count;
I
Ido Yariv 已提交
928 929 930 931 932
	unsigned long flags;

	/* TX might be handled here, avoid redundant work */
	set_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
	cancel_work_sync(&wl->tx_work);
L
Luciano Coelho 已提交
933

934 935 936 937 938 939 940
	/*
	 * In case edge triggered interrupt must be used, we cannot iterate
	 * more than once without introducing race conditions with the hardirq.
	 */
	if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ)
		loopcount = 1;

L
Luciano Coelho 已提交
941 942 943 944
	mutex_lock(&wl->mutex);

	wl1271_debug(DEBUG_IRQ, "IRQ work");

945
	if (unlikely(wl->state == WL1271_STATE_OFF))
L
Luciano Coelho 已提交
946 947
		goto out;

948
	ret = wl1271_ps_elp_wakeup(wl);
L
Luciano Coelho 已提交
949 950 951
	if (ret < 0)
		goto out;

952 953 954 955 956 957 958 959
	while (!done && loopcount--) {
		/*
		 * In order to avoid a race with the hardirq, clear the flag
		 * before acknowledging the chip. Since the mutex is held,
		 * wl1271_ps_elp_wakeup cannot be called concurrently.
		 */
		clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
		smp_mb__after_clear_bit();
960 961

		wl1271_fw_status(wl, wl->fw_status);
962
		intr = le32_to_cpu(wl->fw_status->common.intr);
963
		intr &= WL1271_INTR_MASK;
964
		if (!intr) {
965
			done = true;
966 967
			continue;
		}
L
Luciano Coelho 已提交
968

969 970 971
		if (unlikely(intr & WL1271_ACX_INTR_WATCHDOG)) {
			wl1271_error("watchdog interrupt received! "
				     "starting recovery.");
972
			wl12xx_queue_recovery_work(wl);
973 974 975 976 977

			/* restarting the chip. ignore any other interrupt. */
			goto out;
		}

978
		if (likely(intr & WL1271_ACX_INTR_DATA)) {
979
			wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
980

981
			wl1271_rx(wl, &wl->fw_status->common);
L
Luciano Coelho 已提交
982

I
Ido Yariv 已提交
983
			/* Check if any tx blocks were freed */
I
Ido Yariv 已提交
984
			spin_lock_irqsave(&wl->wl_lock, flags);
I
Ido Yariv 已提交
985
			if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
986
			    wl1271_tx_total_queue_count(wl) > 0) {
I
Ido Yariv 已提交
987
				spin_unlock_irqrestore(&wl->wl_lock, flags);
I
Ido Yariv 已提交
988 989 990 991 992
				/*
				 * In order to avoid starvation of the TX path,
				 * call the work function directly.
				 */
				wl1271_tx_work_locked(wl);
I
Ido Yariv 已提交
993 994
			} else {
				spin_unlock_irqrestore(&wl->wl_lock, flags);
I
Ido Yariv 已提交
995 996
			}

997 998 999 1000
			/* check for tx results */
			if (wl->fw_status->common.tx_results_counter !=
			    (wl->tx_results_count & 0xff))
				wl1271_tx_complete(wl);
1001 1002 1003 1004 1005 1006

			/* Make sure the deferred queues don't get too long */
			defer_count = skb_queue_len(&wl->deferred_tx_queue) +
				      skb_queue_len(&wl->deferred_rx_queue);
			if (defer_count > WL1271_DEFERRED_QUEUE_LIMIT)
				wl1271_flush_deferred_work(wl);
1007
		}
L
Luciano Coelho 已提交
1008

1009 1010 1011 1012
		if (intr & WL1271_ACX_INTR_EVENT_A) {
			wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
			wl1271_event_handle(wl, 0);
		}
L
Luciano Coelho 已提交
1013

1014 1015 1016 1017
		if (intr & WL1271_ACX_INTR_EVENT_B) {
			wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
			wl1271_event_handle(wl, 1);
		}
L
Luciano Coelho 已提交
1018

1019 1020 1021
		if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
			wl1271_debug(DEBUG_IRQ,
				     "WL1271_ACX_INTR_INIT_COMPLETE");
L
Luciano Coelho 已提交
1022

1023 1024
		if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
			wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
1025
	}
L
Luciano Coelho 已提交
1026 1027 1028 1029

	wl1271_ps_elp_sleep(wl);

out:
I
Ido Yariv 已提交
1030 1031 1032 1033
	spin_lock_irqsave(&wl->wl_lock, flags);
	/* In case TX was not handled here, queue TX work */
	clear_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
	if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
1034
	    wl1271_tx_total_queue_count(wl) > 0)
I
Ido Yariv 已提交
1035 1036 1037
		ieee80211_queue_work(wl->hw, &wl->tx_work);
	spin_unlock_irqrestore(&wl->wl_lock, flags);

L
Luciano Coelho 已提交
1038
	mutex_unlock(&wl->mutex);
1039 1040

	return IRQ_HANDLED;
L
Luciano Coelho 已提交
1041
}
1042
EXPORT_SYMBOL_GPL(wl1271_irq);
L
Luciano Coelho 已提交
1043 1044 1045 1046

static int wl1271_fetch_firmware(struct wl1271 *wl)
{
	const struct firmware *fw;
1047
	const char *fw_name;
L
Luciano Coelho 已提交
1048 1049
	int ret;

1050 1051 1052 1053
	if (wl->chip.id == CHIP_ID_1283_PG20)
		fw_name = WL128X_FW_NAME;
	else
		fw_name	= WL127X_FW_NAME;
1054 1055 1056 1057

	wl1271_debug(DEBUG_BOOT, "booting firmware %s", fw_name);

	ret = request_firmware(&fw, fw_name, wl1271_wl_to_dev(wl));
L
Luciano Coelho 已提交
1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070

	if (ret < 0) {
		wl1271_error("could not get firmware: %d", ret);
		return ret;
	}

	if (fw->size % 4) {
		wl1271_error("firmware size is not multiple of 32 bits: %zu",
			     fw->size);
		ret = -EILSEQ;
		goto out;
	}

1071
	vfree(wl->fw);
L
Luciano Coelho 已提交
1072
	wl->fw_len = fw->size;
1073
	wl->fw = vmalloc(wl->fw_len);
L
Luciano Coelho 已提交
1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094

	if (!wl->fw) {
		wl1271_error("could not allocate memory for the firmware");
		ret = -ENOMEM;
		goto out;
	}

	memcpy(wl->fw, fw->data, wl->fw_len);
	ret = 0;

out:
	release_firmware(fw);

	return ret;
}

static int wl1271_fetch_nvs(struct wl1271 *wl)
{
	const struct firmware *fw;
	int ret;

1095
	ret = request_firmware(&fw, WL12XX_NVS_NAME, wl1271_wl_to_dev(wl));
L
Luciano Coelho 已提交
1096 1097 1098 1099 1100 1101

	if (ret < 0) {
		wl1271_error("could not get nvs file: %d", ret);
		return ret;
	}

1102
	wl->nvs = kmemdup(fw->data, fw->size, GFP_KERNEL);
L
Luciano Coelho 已提交
1103 1104 1105 1106 1107 1108 1109

	if (!wl->nvs) {
		wl1271_error("could not allocate memory for the nvs file");
		ret = -ENOMEM;
		goto out;
	}

1110 1111
	wl->nvs_len = fw->size;

L
Luciano Coelho 已提交
1112 1113 1114 1115 1116 1117
out:
	release_firmware(fw);

	return ret;
}

1118 1119 1120 1121 1122 1123
void wl12xx_queue_recovery_work(struct wl1271 *wl)
{
	if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags))
		ieee80211_queue_work(wl->hw, &wl->recovery_work);
}

1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200
size_t wl12xx_copy_fwlog(struct wl1271 *wl, u8 *memblock, size_t maxlen)
{
	size_t len = 0;

	/* The FW log is a length-value list, find where the log end */
	while (len < maxlen) {
		if (memblock[len] == 0)
			break;
		if (len + memblock[len] + 1 > maxlen)
			break;
		len += memblock[len] + 1;
	}

	/* Make sure we have enough room */
	len = min(len, (size_t)(PAGE_SIZE - wl->fwlog_size));

	/* Fill the FW log file, consumed by the sysfs fwlog entry */
	memcpy(wl->fwlog + wl->fwlog_size, memblock, len);
	wl->fwlog_size += len;

	return len;
}

static void wl12xx_read_fwlog_panic(struct wl1271 *wl)
{
	u32 addr;
	u32 first_addr;
	u8 *block;

	if ((wl->quirks & WL12XX_QUIRK_FWLOG_NOT_IMPLEMENTED) ||
	    (wl->conf.fwlog.mode != WL12XX_FWLOG_ON_DEMAND) ||
	    (wl->conf.fwlog.mem_blocks == 0))
		return;

	wl1271_info("Reading FW panic log");

	block = kmalloc(WL12XX_HW_BLOCK_SIZE, GFP_KERNEL);
	if (!block)
		return;

	/*
	 * Make sure the chip is awake and the logger isn't active.
	 * This might fail if the firmware hanged.
	 */
	if (!wl1271_ps_elp_wakeup(wl))
		wl12xx_cmd_stop_fwlog(wl);

	/* Read the first memory block address */
	wl1271_fw_status(wl, wl->fw_status);
	first_addr = __le32_to_cpu(wl->fw_status->sta.log_start_addr);
	if (!first_addr)
		goto out;

	/* Traverse the memory blocks linked list */
	addr = first_addr;
	do {
		memset(block, 0, WL12XX_HW_BLOCK_SIZE);
		wl1271_read_hwaddr(wl, addr, block, WL12XX_HW_BLOCK_SIZE,
				   false);

		/*
		 * Memory blocks are linked to one another. The first 4 bytes
		 * of each memory block hold the hardware address of the next
		 * one. The last memory block points to the first one.
		 */
		addr = __le32_to_cpup((__le32 *)block);
		if (!wl12xx_copy_fwlog(wl, block + sizeof(addr),
				       WL12XX_HW_BLOCK_SIZE - sizeof(addr)))
			break;
	} while (addr && (addr != first_addr));

	wake_up_interruptible(&wl->fwlog_waitq);

out:
	kfree(block);
}

1201 1202 1203 1204 1205 1206 1207 1208 1209 1210
static void wl1271_recovery_work(struct work_struct *work)
{
	struct wl1271 *wl =
		container_of(work, struct wl1271, recovery_work);

	mutex_lock(&wl->mutex);

	if (wl->state != WL1271_STATE_ON)
		goto out;

1211 1212 1213
	/* Avoid a recursive recovery */
	set_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags);

1214 1215
	wl12xx_read_fwlog_panic(wl);

1216 1217
	wl1271_info("Hardware recovery in progress. FW ver: %s pc: 0x%x",
		    wl->chip.fw_ver_str, wl1271_read32(wl, SCR_PAD4));
1218

1219 1220 1221 1222 1223 1224 1225 1226 1227
	/*
	 * Advance security sequence number to overcome potential progress
	 * in the firmware during recovery. This doens't hurt if the network is
	 * not encrypted.
	 */
	if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags) ||
	    test_bit(WL1271_FLAG_AP_STARTED, &wl->flags))
		wl->tx_security_seq += WL1271_TX_SQN_POST_RECOVERY_PADDING;

1228 1229 1230
	if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
		ieee80211_connection_loss(wl->vif);

1231 1232 1233
	/* Prevent spurious TX during FW restart */
	ieee80211_stop_queues(wl->hw);

1234 1235 1236 1237 1238
	if (wl->sched_scanning) {
		ieee80211_sched_scan_stopped(wl->hw);
		wl->sched_scanning = false;
	}

1239
	/* reboot the chipset */
1240
	__wl1271_op_remove_interface(wl, false);
1241 1242 1243

	clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags);

1244 1245
	ieee80211_restart_hw(wl->hw);

1246 1247 1248 1249 1250 1251
	/*
	 * Its safe to enable TX now - the queues are stopped after a request
	 * to restart the HW.
	 */
	ieee80211_wake_queues(wl->hw);

1252 1253 1254 1255
out:
	mutex_unlock(&wl->mutex);
}

L
Luciano Coelho 已提交
1256 1257 1258 1259 1260
static void wl1271_fw_wakeup(struct wl1271 *wl)
{
	u32 elp_reg;

	elp_reg = ELPCTRL_WAKE_UP;
1261
	wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
L
Luciano Coelho 已提交
1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280
}

static int wl1271_setup(struct wl1271 *wl)
{
	wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
	if (!wl->fw_status)
		return -ENOMEM;

	wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
	if (!wl->tx_res_if) {
		kfree(wl->fw_status);
		return -ENOMEM;
	}

	return 0;
}

static int wl1271_chip_wakeup(struct wl1271 *wl)
{
1281
	struct wl1271_partition_set partition;
L
Luciano Coelho 已提交
1282 1283
	int ret = 0;

J
Juuso Oikarinen 已提交
1284
	msleep(WL1271_PRE_POWER_ON_SLEEP);
1285 1286 1287
	ret = wl1271_power_on(wl);
	if (ret < 0)
		goto out;
L
Luciano Coelho 已提交
1288
	msleep(WL1271_POWER_ON_SLEEP);
1289 1290
	wl1271_io_reset(wl);
	wl1271_io_init(wl);
L
Luciano Coelho 已提交
1291 1292 1293

	/* We don't need a real memory partition here, because we only want
	 * to use the registers at this point. */
1294 1295 1296 1297
	memset(&partition, 0, sizeof(partition));
	partition.reg.start = REGISTERS_BASE;
	partition.reg.size = REGISTERS_DOWN_SIZE;
	wl1271_set_partition(wl, &partition);
L
Luciano Coelho 已提交
1298 1299 1300 1301 1302 1303 1304

	/* ELP module wake up */
	wl1271_fw_wakeup(wl);

	/* whal_FwCtrl_BootSm() */

	/* 0. read chip id from CHIP_ID */
T
Teemu Paasikivi 已提交
1305
	wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
L
Luciano Coelho 已提交
1306 1307 1308 1309 1310 1311 1312 1313 1314 1315

	/* 1. check if chip id is valid */

	switch (wl->chip.id) {
	case CHIP_ID_1271_PG10:
		wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
			       wl->chip.id);

		ret = wl1271_setup(wl);
		if (ret < 0)
1316
			goto out;
L
Luciano Coelho 已提交
1317 1318 1319 1320 1321
		break;
	case CHIP_ID_1271_PG20:
		wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
			     wl->chip.id);

1322 1323 1324 1325
		/*
		 * 'end-of-transaction flag' and 'LPD mode flag'
		 * should be set in wl127x AP mode only
		 */
1326
		if (wl->bss_type == BSS_TYPE_AP_BSS)
1327 1328
			wl->quirks |= (WL12XX_QUIRK_END_OF_TRANSACTION |
				       WL12XX_QUIRK_LPD_MODE);
1329

L
Luciano Coelho 已提交
1330 1331
		ret = wl1271_setup(wl);
		if (ret < 0)
1332
			goto out;
L
Luciano Coelho 已提交
1333
		break;
1334 1335 1336 1337 1338 1339 1340
	case CHIP_ID_1283_PG20:
		wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1283 PG20)",
			     wl->chip.id);

		ret = wl1271_setup(wl);
		if (ret < 0)
			goto out;
1341

1342 1343
		if (wl1271_set_block_size(wl))
			wl->quirks |= WL12XX_QUIRK_BLOCKSIZE_ALIGNMENT;
1344 1345
		break;
	case CHIP_ID_1283_PG10:
L
Luciano Coelho 已提交
1346
	default:
1347
		wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
L
Luciano Coelho 已提交
1348
		ret = -ENODEV;
1349
		goto out;
L
Luciano Coelho 已提交
1350 1351
	}

1352
	if (wl->fw == NULL) {
L
Luciano Coelho 已提交
1353 1354
		ret = wl1271_fetch_firmware(wl);
		if (ret < 0)
1355
			goto out;
L
Luciano Coelho 已提交
1356 1357 1358 1359 1360 1361
	}

	/* No NVS from netlink, try to get it from the filesystem */
	if (wl->nvs == NULL) {
		ret = wl1271_fetch_nvs(wl);
		if (ret < 0)
1362
			goto out;
L
Luciano Coelho 已提交
1363 1364 1365 1366 1367 1368 1369 1370
	}

out:
	return ret;
}

int wl1271_plt_start(struct wl1271 *wl)
{
1371
	int retries = WL1271_BOOT_RETRIES;
1372
	struct wiphy *wiphy = wl->hw->wiphy;
L
Luciano Coelho 已提交
1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385
	int ret;

	mutex_lock(&wl->mutex);

	wl1271_notice("power up");

	if (wl->state != WL1271_STATE_OFF) {
		wl1271_error("cannot go into PLT state because not "
			     "in off state: %d", wl->state);
		ret = -EBUSY;
		goto out;
	}

1386 1387
	wl->bss_type = BSS_TYPE_STA_BSS;

1388 1389 1390 1391 1392
	while (retries) {
		retries--;
		ret = wl1271_chip_wakeup(wl);
		if (ret < 0)
			goto power_off;
L
Luciano Coelho 已提交
1393

1394 1395 1396
		ret = wl1271_boot(wl);
		if (ret < 0)
			goto power_off;
1397

1398 1399 1400
		ret = wl1271_plt_init(wl);
		if (ret < 0)
			goto irq_disable;
1401

1402 1403
		wl->state = WL1271_STATE_PLT;
		wl1271_notice("firmware booted in PLT mode (%s)",
L
Levi, Shahar 已提交
1404
			      wl->chip.fw_ver_str);
1405

1406 1407 1408 1409 1410
		/* update hw/fw version info in wiphy struct */
		wiphy->hw_version = wl->chip.id;
		strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
			sizeof(wiphy->fw_version));

1411
		goto out;
1412

1413 1414 1415 1416 1417 1418 1419 1420 1421
irq_disable:
		mutex_unlock(&wl->mutex);
		/* Unlocking the mutex in the middle of handling is
		   inherently unsafe. In this case we deem it safe to do,
		   because we need to let any possibly pending IRQ out of
		   the system (and while we are WL1271_STATE_OFF the IRQ
		   work function will not do anything.) Also, any other
		   possible concurrent operations will fail due to the
		   current state, hence the wl1271 struct should be safe. */
1422 1423 1424
		wl1271_disable_interrupts(wl);
		wl1271_flush_deferred_work(wl);
		cancel_work_sync(&wl->netstack_work);
1425 1426 1427 1428
		mutex_lock(&wl->mutex);
power_off:
		wl1271_power_off(wl);
	}
L
Luciano Coelho 已提交
1429

1430 1431
	wl1271_error("firmware boot in PLT mode failed despite %d retries",
		     WL1271_BOOT_RETRIES);
L
Luciano Coelho 已提交
1432 1433 1434 1435 1436 1437
out:
	mutex_unlock(&wl->mutex);

	return ret;
}

1438
static int __wl1271_plt_stop(struct wl1271 *wl)
L
Luciano Coelho 已提交
1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453
{
	int ret = 0;

	wl1271_notice("power down");

	if (wl->state != WL1271_STATE_PLT) {
		wl1271_error("cannot power down because not in PLT "
			     "state: %d", wl->state);
		ret = -EBUSY;
		goto out;
	}

	wl1271_power_off(wl);

	wl->state = WL1271_STATE_OFF;
1454
	wl->rx_counter = 0;
L
Luciano Coelho 已提交
1455 1456

	mutex_unlock(&wl->mutex);
1457 1458 1459
	wl1271_disable_interrupts(wl);
	wl1271_flush_deferred_work(wl);
	cancel_work_sync(&wl->netstack_work);
1460
	cancel_work_sync(&wl->recovery_work);
1461 1462 1463 1464 1465 1466 1467 1468
	mutex_lock(&wl->mutex);
out:
	return ret;
}

int wl1271_plt_stop(struct wl1271 *wl)
{
	int ret;
1469

1470 1471 1472
	mutex_lock(&wl->mutex);
	ret = __wl1271_plt_stop(wl);
	mutex_unlock(&wl->mutex);
L
Luciano Coelho 已提交
1473 1474 1475
	return ret;
}

1476
static void wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
L
Luciano Coelho 已提交
1477 1478
{
	struct wl1271 *wl = hw->priv;
1479
	unsigned long flags;
1480
	int q, mapping;
1481
	u8 hlid = 0;
L
Luciano Coelho 已提交
1482

1483 1484
	mapping = skb_get_queue_mapping(skb);
	q = wl1271_tx_get_queue(mapping);
I
Ido Yariv 已提交
1485 1486 1487 1488

	if (wl->bss_type == BSS_TYPE_AP_BSS)
		hlid = wl1271_tx_get_hlid(skb);

1489
	spin_lock_irqsave(&wl->wl_lock, flags);
I
Ido Yariv 已提交
1490

1491
	wl->tx_queue_count[q]++;
1492 1493 1494 1495 1496

	/*
	 * The workqueue is slow to process the tx_queue and we need stop
	 * the queue here, otherwise the queue will get too long.
	 */
1497
	if (wl->tx_queue_count[q] >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
1498 1499 1500
		wl1271_debug(DEBUG_TX, "op_tx: stopping queues for q %d", q);
		ieee80211_stop_queue(wl->hw, mapping);
		set_bit(q, &wl->stopped_queues_map);
1501 1502
	}

1503
	/* queue the packet */
1504 1505 1506 1507 1508 1509
	if (wl->bss_type == BSS_TYPE_AP_BSS) {
		wl1271_debug(DEBUG_TX, "queue skb hlid %d q %d", hlid, q);
		skb_queue_tail(&wl->links[hlid].tx_queue[q], skb);
	} else {
		skb_queue_tail(&wl->tx_queue[q], skb);
	}
L
Luciano Coelho 已提交
1510 1511 1512 1513 1514 1515

	/*
	 * The chip specific setup must run before the first TX packet -
	 * before that, the tx_work will not be initialized!
	 */

I
Ido Yariv 已提交
1516 1517
	if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
	    !test_bit(WL1271_FLAG_TX_PENDING, &wl->flags))
I
Ido Yariv 已提交
1518
		ieee80211_queue_work(wl->hw, &wl->tx_work);
I
Ido Yariv 已提交
1519 1520

	spin_unlock_irqrestore(&wl->wl_lock, flags);
L
Luciano Coelho 已提交
1521 1522
}

1523 1524
int wl1271_tx_dummy_packet(struct wl1271 *wl)
{
1525
	unsigned long flags;
1526
	int q = wl1271_tx_get_queue(skb_get_queue_mapping(wl->dummy_packet));
1527 1528 1529

	spin_lock_irqsave(&wl->wl_lock, flags);
	set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags);
1530
	wl->tx_queue_count[q]++;
1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550
	spin_unlock_irqrestore(&wl->wl_lock, flags);

	/* The FW is low on RX memory blocks, so send the dummy packet asap */
	if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags))
		wl1271_tx_work_locked(wl);

	/*
	 * If the FW TX is busy, TX work will be scheduled by the threaded
	 * interrupt handler function
	 */
	return 0;
}

/*
 * The size of the dummy packet should be at least 1400 bytes. However, in
 * order to minimize the number of bus transactions, aligning it to 512 bytes
 * boundaries could be beneficial, performance wise
 */
#define TOTAL_TX_DUMMY_PACKET_SIZE (ALIGN(1400, 512))

1551
static struct sk_buff *wl12xx_alloc_dummy_packet(struct wl1271 *wl)
1552 1553
{
	struct sk_buff *skb;
1554
	struct ieee80211_hdr_3addr *hdr;
1555 1556 1557 1558
	unsigned int dummy_packet_size;

	dummy_packet_size = TOTAL_TX_DUMMY_PACKET_SIZE -
			    sizeof(struct wl1271_tx_hw_descr) - sizeof(*hdr);
1559

1560
	skb = dev_alloc_skb(TOTAL_TX_DUMMY_PACKET_SIZE);
1561
	if (!skb) {
1562 1563
		wl1271_warning("Failed to allocate a dummy packet skb");
		return NULL;
1564 1565 1566 1567 1568 1569 1570
	}

	skb_reserve(skb, sizeof(struct wl1271_tx_hw_descr));

	hdr = (struct ieee80211_hdr_3addr *) skb_put(skb, sizeof(*hdr));
	memset(hdr, 0, sizeof(*hdr));
	hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
1571 1572
					 IEEE80211_STYPE_NULLFUNC |
					 IEEE80211_FCTL_TODS);
1573

1574
	memset(skb_put(skb, dummy_packet_size), 0, dummy_packet_size);
1575

1576 1577
	/* Dummy packets require the TID to be management */
	skb->priority = WL1271_TID_MGMT;
1578

1579
	/* Initialize all fields that might be used */
1580
	skb_set_queue_mapping(skb, 0);
1581
	memset(IEEE80211_SKB_CB(skb), 0, sizeof(struct ieee80211_tx_info));
1582

1583
	return skb;
1584 1585
}

1586

1587 1588 1589 1590
static struct notifier_block wl1271_dev_notifier = {
	.notifier_call = wl1271_dev_notify,
};

1591
#ifdef CONFIG_PM
1592
static int wl1271_configure_suspend_sta(struct wl1271 *wl)
1593
{
1594
	int ret = 0;
1595 1596 1597

	mutex_lock(&wl->mutex);

1598 1599 1600
	if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
		goto out_unlock;

1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642
	ret = wl1271_ps_elp_wakeup(wl);
	if (ret < 0)
		goto out_unlock;

	/* enter psm if needed*/
	if (!test_bit(WL1271_FLAG_PSM, &wl->flags)) {
		DECLARE_COMPLETION_ONSTACK(compl);

		wl->ps_compl = &compl;
		ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
				   wl->basic_rate, true);
		if (ret < 0)
			goto out_sleep;

		/* we must unlock here so we will be able to get events */
		wl1271_ps_elp_sleep(wl);
		mutex_unlock(&wl->mutex);

		ret = wait_for_completion_timeout(
			&compl, msecs_to_jiffies(WL1271_PS_COMPLETE_TIMEOUT));
		if (ret <= 0) {
			wl1271_warning("couldn't enter ps mode!");
			ret = -EBUSY;
			goto out;
		}

		/* take mutex again, and wakeup */
		mutex_lock(&wl->mutex);

		ret = wl1271_ps_elp_wakeup(wl);
		if (ret < 0)
			goto out_unlock;
	}
out_sleep:
	wl1271_ps_elp_sleep(wl);
out_unlock:
	mutex_unlock(&wl->mutex);
out:
	return ret;

}

1643 1644
static int wl1271_configure_suspend_ap(struct wl1271 *wl)
{
1645
	int ret = 0;
1646 1647 1648

	mutex_lock(&wl->mutex);

1649 1650 1651
	if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags))
		goto out_unlock;

1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673
	ret = wl1271_ps_elp_wakeup(wl);
	if (ret < 0)
		goto out_unlock;

	ret = wl1271_acx_set_ap_beacon_filter(wl, true);

	wl1271_ps_elp_sleep(wl);
out_unlock:
	mutex_unlock(&wl->mutex);
	return ret;

}

static int wl1271_configure_suspend(struct wl1271 *wl)
{
	if (wl->bss_type == BSS_TYPE_STA_BSS)
		return wl1271_configure_suspend_sta(wl);
	if (wl->bss_type == BSS_TYPE_AP_BSS)
		return wl1271_configure_suspend_ap(wl);
	return 0;
}

1674 1675 1676
static void wl1271_configure_resume(struct wl1271 *wl)
{
	int ret;
1677 1678
	bool is_sta = wl->bss_type == BSS_TYPE_STA_BSS;
	bool is_ap = wl->bss_type == BSS_TYPE_AP_BSS;
1679

1680
	if (!is_sta && !is_ap)
1681 1682 1683 1684 1685 1686 1687
		return;

	mutex_lock(&wl->mutex);
	ret = wl1271_ps_elp_wakeup(wl);
	if (ret < 0)
		goto out;

1688 1689 1690 1691 1692 1693 1694 1695
	if (is_sta) {
		/* exit psm if it wasn't configured */
		if (!test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags))
			wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
					   wl->basic_rate, true);
	} else if (is_ap) {
		wl1271_acx_set_ap_beacon_filter(wl, false);
	}
1696 1697 1698 1699 1700 1701

	wl1271_ps_elp_sleep(wl);
out:
	mutex_unlock(&wl->mutex);
}

1702 1703 1704 1705
static int wl1271_op_suspend(struct ieee80211_hw *hw,
			    struct cfg80211_wowlan *wow)
{
	struct wl1271 *wl = hw->priv;
1706 1707
	int ret;

1708
	wl1271_debug(DEBUG_MAC80211, "mac80211 suspend wow=%d", !!wow);
1709
	WARN_ON(!wow || !wow->any);
1710

1711 1712 1713 1714 1715 1716 1717 1718
	wl->wow_enabled = true;
	ret = wl1271_configure_suspend(wl);
	if (ret < 0) {
		wl1271_warning("couldn't prepare device to suspend");
		return ret;
	}
	/* flush any remaining work */
	wl1271_debug(DEBUG_MAC80211, "flushing remaining works");
1719

1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735
	/*
	 * disable and re-enable interrupts in order to flush
	 * the threaded_irq
	 */
	wl1271_disable_interrupts(wl);

	/*
	 * set suspended flag to avoid triggering a new threaded_irq
	 * work. no need for spinlock as interrupts are disabled.
	 */
	set_bit(WL1271_FLAG_SUSPENDED, &wl->flags);

	wl1271_enable_interrupts(wl);
	flush_work(&wl->tx_work);
	flush_delayed_work(&wl->pspoll_work);
	flush_delayed_work(&wl->elp_work);
1736

1737 1738 1739 1740 1741 1742
	return 0;
}

static int wl1271_op_resume(struct ieee80211_hw *hw)
{
	struct wl1271 *wl = hw->priv;
1743 1744 1745
	unsigned long flags;
	bool run_irq_work = false;

1746 1747
	wl1271_debug(DEBUG_MAC80211, "mac80211 resume wow=%d",
		     wl->wow_enabled);
1748
	WARN_ON(!wl->wow_enabled);
1749 1750 1751 1752 1753

	/*
	 * re-enable irq_work enqueuing, and call irq_work directly if
	 * there is a pending work.
	 */
1754 1755 1756 1757 1758
	spin_lock_irqsave(&wl->wl_lock, flags);
	clear_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
	if (test_and_clear_bit(WL1271_FLAG_PENDING_WORK, &wl->flags))
		run_irq_work = true;
	spin_unlock_irqrestore(&wl->wl_lock, flags);
1759

1760 1761 1762 1763 1764
	if (run_irq_work) {
		wl1271_debug(DEBUG_MAC80211,
			     "run postponed irq_work directly");
		wl1271_irq(0, wl);
		wl1271_enable_interrupts(wl);
1765
	}
1766
	wl1271_configure_resume(wl);
1767
	wl->wow_enabled = false;
1768

1769 1770
	return 0;
}
1771
#endif
1772

L
Luciano Coelho 已提交
1773
static int wl1271_op_start(struct ieee80211_hw *hw)
1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797
{
	wl1271_debug(DEBUG_MAC80211, "mac80211 start");

	/*
	 * We have to delay the booting of the hardware because
	 * we need to know the local MAC address before downloading and
	 * initializing the firmware. The MAC address cannot be changed
	 * after boot, and without the proper MAC address, the firmware
	 * will not function properly.
	 *
	 * The MAC address is first known when the corresponding interface
	 * is added. That is where we will initialize the hardware.
	 */

	return 0;
}

static void wl1271_op_stop(struct ieee80211_hw *hw)
{
	wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
}

static int wl1271_op_add_interface(struct ieee80211_hw *hw,
				   struct ieee80211_vif *vif)
L
Luciano Coelho 已提交
1798 1799
{
	struct wl1271 *wl = hw->priv;
1800
	struct wiphy *wiphy = hw->wiphy;
1801
	int retries = WL1271_BOOT_RETRIES;
L
Luciano Coelho 已提交
1802
	int ret = 0;
1803
	bool booted = false;
L
Luciano Coelho 已提交
1804

1805 1806
	wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
		     vif->type, vif->addr);
L
Luciano Coelho 已提交
1807 1808

	mutex_lock(&wl->mutex);
1809
	if (wl->vif) {
1810 1811
		wl1271_debug(DEBUG_MAC80211,
			     "multiple vifs are not supported yet");
1812 1813 1814 1815
		ret = -EBUSY;
		goto out;
	}

1816 1817 1818 1819 1820 1821 1822 1823 1824 1825
	/*
	 * in some very corner case HW recovery scenarios its possible to
	 * get here before __wl1271_op_remove_interface is complete, so
	 * opt out if that is the case.
	 */
	if (test_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags)) {
		ret = -EBUSY;
		goto out;
	}

1826 1827 1828
	switch (vif->type) {
	case NL80211_IFTYPE_STATION:
		wl->bss_type = BSS_TYPE_STA_BSS;
1829
		wl->set_bss_type = BSS_TYPE_STA_BSS;
1830 1831 1832
		break;
	case NL80211_IFTYPE_ADHOC:
		wl->bss_type = BSS_TYPE_IBSS;
1833
		wl->set_bss_type = BSS_TYPE_STA_BSS;
1834
		break;
A
Arik Nemtsov 已提交
1835 1836 1837
	case NL80211_IFTYPE_AP:
		wl->bss_type = BSS_TYPE_AP_BSS;
		break;
1838 1839 1840 1841 1842 1843
	default:
		ret = -EOPNOTSUPP;
		goto out;
	}

	memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
L
Luciano Coelho 已提交
1844 1845 1846 1847 1848 1849 1850 1851

	if (wl->state != WL1271_STATE_OFF) {
		wl1271_error("cannot start because not in off state: %d",
			     wl->state);
		ret = -EBUSY;
		goto out;
	}

1852 1853 1854 1855 1856
	while (retries) {
		retries--;
		ret = wl1271_chip_wakeup(wl);
		if (ret < 0)
			goto power_off;
L
Luciano Coelho 已提交
1857

1858 1859 1860
		ret = wl1271_boot(wl);
		if (ret < 0)
			goto power_off;
L
Luciano Coelho 已提交
1861

1862 1863 1864
		ret = wl1271_hw_init(wl);
		if (ret < 0)
			goto irq_disable;
L
Luciano Coelho 已提交
1865

1866 1867
		booted = true;
		break;
1868

1869 1870 1871 1872 1873 1874 1875 1876 1877
irq_disable:
		mutex_unlock(&wl->mutex);
		/* Unlocking the mutex in the middle of handling is
		   inherently unsafe. In this case we deem it safe to do,
		   because we need to let any possibly pending IRQ out of
		   the system (and while we are WL1271_STATE_OFF the IRQ
		   work function will not do anything.) Also, any other
		   possible concurrent operations will fail due to the
		   current state, hence the wl1271 struct should be safe. */
1878 1879 1880
		wl1271_disable_interrupts(wl);
		wl1271_flush_deferred_work(wl);
		cancel_work_sync(&wl->netstack_work);
1881 1882 1883 1884
		mutex_lock(&wl->mutex);
power_off:
		wl1271_power_off(wl);
	}
1885

1886 1887 1888 1889 1890 1891 1892 1893
	if (!booted) {
		wl1271_error("firmware boot failed despite %d retries",
			     WL1271_BOOT_RETRIES);
		goto out;
	}

	wl->vif = vif;
	wl->state = WL1271_STATE_ON;
1894
	set_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags);
L
Levi, Shahar 已提交
1895
	wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
1896 1897 1898

	/* update hw/fw version info in wiphy struct */
	wiphy->hw_version = wl->chip.id;
L
Levi, Shahar 已提交
1899
	strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
1900 1901
		sizeof(wiphy->fw_version));

1902 1903 1904 1905 1906 1907 1908 1909 1910 1911
	/*
	 * Now we know if 11a is supported (info from the NVS), so disable
	 * 11a channels if not supported
	 */
	if (!wl->enable_11a)
		wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0;

	wl1271_debug(DEBUG_MAC80211, "11a is %ssupported",
		     wl->enable_11a ? "" : "not ");

1912
out:
L
Luciano Coelho 已提交
1913 1914
	mutex_unlock(&wl->mutex);

1915
	mutex_lock(&wl_list_mutex);
1916
	if (!ret)
1917
		list_add(&wl->list, &wl_list);
1918
	mutex_unlock(&wl_list_mutex);
1919

L
Luciano Coelho 已提交
1920 1921 1922
	return ret;
}

1923 1924
static void __wl1271_op_remove_interface(struct wl1271 *wl,
					 bool reset_tx_queues)
L
Luciano Coelho 已提交
1925 1926 1927
{
	int i;

1928
	wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
L
Luciano Coelho 已提交
1929

1930 1931 1932 1933
	/* because of hardware recovery, we may get here twice */
	if (wl->state != WL1271_STATE_ON)
		return;

1934
	wl1271_info("down");
L
Luciano Coelho 已提交
1935

1936
	mutex_lock(&wl_list_mutex);
1937
	list_del(&wl->list);
1938
	mutex_unlock(&wl_list_mutex);
1939

1940
	/* enable dyn ps just in case (if left on due to fw crash etc) */
1941
	if (wl->bss_type == BSS_TYPE_STA_BSS)
1942
		ieee80211_enable_dyn_ps(wl->vif);
1943

L
Luciano Coelho 已提交
1944 1945
	if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
		wl->scan.state = WL1271_SCAN_STATE_IDLE;
1946
		memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
1947
		wl->scan.req = NULL;
1948
		ieee80211_scan_completed(wl->hw, true);
L
Luciano Coelho 已提交
1949 1950
	}

1951 1952 1953 1954
	/*
	 * this must be before the cancel_work calls below, so that the work
	 * functions don't perform further work.
	 */
L
Luciano Coelho 已提交
1955 1956 1957 1958
	wl->state = WL1271_STATE_OFF;

	mutex_unlock(&wl->mutex);

1959 1960
	wl1271_disable_interrupts(wl);
	wl1271_flush_deferred_work(wl);
1961
	cancel_delayed_work_sync(&wl->scan_complete_work);
1962
	cancel_work_sync(&wl->netstack_work);
L
Luciano Coelho 已提交
1963
	cancel_work_sync(&wl->tx_work);
1964 1965 1966
	del_timer_sync(&wl->rx_streaming_timer);
	cancel_work_sync(&wl->rx_streaming_enable_work);
	cancel_work_sync(&wl->rx_streaming_disable_work);
1967
	cancel_delayed_work_sync(&wl->pspoll_work);
1968
	cancel_delayed_work_sync(&wl->elp_work);
L
Luciano Coelho 已提交
1969 1970 1971 1972

	mutex_lock(&wl->mutex);

	/* let's notify MAC80211 about the remaining pending TX frames */
1973
	wl1271_tx_reset(wl, reset_tx_queues);
L
Luciano Coelho 已提交
1974 1975 1976
	wl1271_power_off(wl);

	memset(wl->bssid, 0, ETH_ALEN);
J
Johannes Berg 已提交
1977
	memset(wl->ssid, 0, IEEE80211_MAX_SSID_LEN + 1);
L
Luciano Coelho 已提交
1978 1979
	wl->ssid_len = 0;
	wl->bss_type = MAX_BSS_TYPE;
1980
	wl->set_bss_type = MAX_BSS_TYPE;
1981
	wl->band = IEEE80211_BAND_2GHZ;
L
Luciano Coelho 已提交
1982 1983

	wl->rx_counter = 0;
1984
	wl->psm_entry_retry = 0;
L
Luciano Coelho 已提交
1985 1986
	wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
	wl->tx_blocks_available = 0;
1987
	wl->tx_allocated_blocks = 0;
L
Luciano Coelho 已提交
1988 1989 1990 1991
	wl->tx_results_count = 0;
	wl->tx_packets_count = 0;
	wl->time_offset = 0;
	wl->session_counter = 0;
1992
	wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1993
	wl->vif = NULL;
1994
	wl1271_free_ap_keys(wl);
1995
	memset(wl->ap_hlid_map, 0, sizeof(wl->ap_hlid_map));
1996 1997
	wl->ap_fw_ps_map = 0;
	wl->ap_ps_map = 0;
1998
	wl->sched_scanning = false;
1999

2000 2001 2002 2003 2004 2005 2006
	/*
	 * this is performed after the cancel_work calls and the associated
	 * mutex_lock, so that wl1271_op_add_interface does not accidentally
	 * get executed before all these vars have been reset.
	 */
	wl->flags = 0;

2007
	for (i = 0; i < NUM_TX_QUEUES; i++)
L
Luciano Coelho 已提交
2008 2009 2010
		wl->tx_blocks_freed[i] = 0;

	wl1271_debugfs_reset(wl);
2011 2012 2013 2014 2015 2016 2017

	kfree(wl->fw_status);
	wl->fw_status = NULL;
	kfree(wl->tx_res_if);
	wl->tx_res_if = NULL;
	kfree(wl->target_mem_map);
	wl->target_mem_map = NULL;
2018
}
2019

2020 2021 2022 2023 2024 2025
static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
				       struct ieee80211_vif *vif)
{
	struct wl1271 *wl = hw->priv;

	mutex_lock(&wl->mutex);
2026 2027 2028 2029 2030 2031
	/*
	 * wl->vif can be null here if someone shuts down the interface
	 * just when hardware recovery has been started.
	 */
	if (wl->vif) {
		WARN_ON(wl->vif != vif);
2032
		__wl1271_op_remove_interface(wl, true);
2033
	}
2034

2035
	mutex_unlock(&wl->mutex);
2036
	cancel_work_sync(&wl->recovery_work);
L
Luciano Coelho 已提交
2037 2038
}

2039
static int wl1271_dummy_join(struct wl1271 *wl)
2040
{
2041
	int ret = 0;
2042 2043 2044 2045 2046 2047
	/* we need to use a dummy BSSID for now */
	static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
						  0xad, 0xbe, 0xef };

	memcpy(wl->bssid, dummy_bssid, ETH_ALEN);

2048
	ret = wl1271_cmd_join(wl, wl->set_bss_type);
2049 2050 2051
	if (ret < 0)
		goto out;

2052
	set_bit(WL1271_FLAG_JOINED, &wl->flags);
2053 2054 2055 2056 2057

out:
	return ret;
}

2058
static int wl1271_join(struct wl1271 *wl, bool set_assoc)
2059 2060 2061
{
	int ret;

2062 2063 2064 2065
	/*
	 * One of the side effects of the JOIN command is that is clears
	 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
	 * to a WPA/WPA2 access point will therefore kill the data-path.
2066 2067 2068 2069
	 * Currently the only valid scenario for JOIN during association
	 * is on roaming, in which case we will also be given new keys.
	 * Keep the below message for now, unless it starts bothering
	 * users who really like to roam a lot :)
2070 2071 2072 2073 2074 2075 2076
	 */
	if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
		wl1271_info("JOIN while associated.");

	if (set_assoc)
		set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);

2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113
	ret = wl1271_cmd_join(wl, wl->set_bss_type);
	if (ret < 0)
		goto out;

	set_bit(WL1271_FLAG_JOINED, &wl->flags);

	if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
		goto out;

	/*
	 * The join command disable the keep-alive mode, shut down its process,
	 * and also clear the template config, so we need to reset it all after
	 * the join. The acx_aid starts the keep-alive process, and the order
	 * of the commands below is relevant.
	 */
	ret = wl1271_acx_keep_alive_mode(wl, true);
	if (ret < 0)
		goto out;

	ret = wl1271_acx_aid(wl, wl->aid);
	if (ret < 0)
		goto out;

	ret = wl1271_cmd_build_klv_null_data(wl);
	if (ret < 0)
		goto out;

	ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
					   ACX_KEEP_ALIVE_TPL_VALID);
	if (ret < 0)
		goto out;

out:
	return ret;
}

static int wl1271_unjoin(struct wl1271 *wl)
2114 2115 2116 2117 2118 2119 2120 2121
{
	int ret;

	/* to stop listening to a channel, we disconnect */
	ret = wl1271_cmd_disconnect(wl);
	if (ret < 0)
		goto out;

2122
	clear_bit(WL1271_FLAG_JOINED, &wl->flags);
2123
	memset(wl->bssid, 0, ETH_ALEN);
2124

2125 2126 2127 2128
	/* reset TX security counters on a clean disconnect */
	wl->tx_security_last_seq_lsb = 0;
	wl->tx_security_seq = 0;

2129 2130 2131 2132
out:
	return ret;
}

2133 2134 2135 2136 2137 2138 2139 2140
static void wl1271_set_band_rate(struct wl1271 *wl)
{
	if (wl->band == IEEE80211_BAND_2GHZ)
		wl->basic_rate_set = wl->conf.tx.basic_rate;
	else
		wl->basic_rate_set = wl->conf.tx.basic_rate_5;
}

2141
static int wl1271_sta_handle_idle(struct wl1271 *wl, bool idle)
2142 2143 2144 2145 2146 2147 2148 2149 2150
{
	int ret;

	if (idle) {
		if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
			ret = wl1271_unjoin(wl);
			if (ret < 0)
				goto out;
		}
A
Arik Nemtsov 已提交
2151
		wl->rate_set = wl1271_tx_min_rate_get(wl);
2152
		ret = wl1271_acx_sta_rate_policies(wl);
2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165
		if (ret < 0)
			goto out;
		ret = wl1271_acx_keep_alive_config(
			wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
			ACX_KEEP_ALIVE_TPL_INVALID);
		if (ret < 0)
			goto out;
		set_bit(WL1271_FLAG_IDLE, &wl->flags);
	} else {
		/* increment the session counter */
		wl->session_counter++;
		if (wl->session_counter >= SESSION_COUNTER_MAX)
			wl->session_counter = 0;
2166 2167 2168 2169 2170 2171 2172

		/* The current firmware only supports sched_scan in idle */
		if (wl->sched_scanning) {
			wl1271_scan_sched_scan_stop(wl);
			ieee80211_sched_scan_stopped(wl->hw);
		}

2173 2174 2175 2176 2177 2178 2179 2180 2181 2182
		ret = wl1271_dummy_join(wl);
		if (ret < 0)
			goto out;
		clear_bit(WL1271_FLAG_IDLE, &wl->flags);
	}

out:
	return ret;
}

L
Luciano Coelho 已提交
2183 2184 2185 2186 2187
static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
{
	struct wl1271 *wl = hw->priv;
	struct ieee80211_conf *conf = &hw->conf;
	int channel, ret = 0;
2188
	bool is_ap;
L
Luciano Coelho 已提交
2189 2190 2191

	channel = ieee80211_frequency_to_channel(conf->channel->center_freq);

2192 2193
	wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s"
		     " changed 0x%x",
L
Luciano Coelho 已提交
2194 2195
		     channel,
		     conf->flags & IEEE80211_CONF_PS ? "on" : "off",
2196
		     conf->power_level,
2197 2198
		     conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
			 changed);
L
Luciano Coelho 已提交
2199

2200 2201 2202 2203 2204 2205 2206 2207 2208
	/*
	 * mac80211 will go to idle nearly immediately after transmitting some
	 * frames, such as the deauth. To make sure those frames reach the air,
	 * wait here until the TX queue is fully flushed.
	 */
	if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
	    (conf->flags & IEEE80211_CONF_IDLE))
		wl1271_tx_flush(wl);

L
Luciano Coelho 已提交
2209 2210
	mutex_lock(&wl->mutex);

2211
	if (unlikely(wl->state == WL1271_STATE_OFF)) {
2212 2213 2214 2215 2216 2217
		/* we support configuring the channel and band while off */
		if ((changed & IEEE80211_CONF_CHANGE_CHANNEL)) {
			wl->band = conf->channel->band;
			wl->channel = channel;
		}

2218 2219 2220
		if ((changed & IEEE80211_CONF_CHANGE_POWER))
			wl->power_level = conf->power_level;

2221
		goto out;
2222
	}
2223

2224 2225
	is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);

2226
	ret = wl1271_ps_elp_wakeup(wl);
L
Luciano Coelho 已提交
2227 2228 2229
	if (ret < 0)
		goto out;

2230
	/* if the channel changes while joined, join again */
2231 2232 2233
	if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
	    ((wl->band != conf->channel->band) ||
	     (wl->channel != channel))) {
2234 2235 2236
		wl->band = conf->channel->band;
		wl->channel = channel;

2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248
		if (!is_ap) {
			/*
			 * FIXME: the mac80211 should really provide a fixed
			 * rate to use here. for now, just use the smallest
			 * possible rate for the band as a fixed rate for
			 * association frames and other control messages.
			 */
			if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
				wl1271_set_band_rate(wl);

			wl->basic_rate = wl1271_tx_min_rate_get(wl);
			ret = wl1271_acx_sta_rate_policies(wl);
2249
			if (ret < 0)
2250
				wl1271_warning("rate policy for channel "
2251
					       "failed %d", ret);
2252 2253 2254 2255 2256 2257 2258

			if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
				ret = wl1271_join(wl, false);
				if (ret < 0)
					wl1271_warning("cmd join on channel "
						       "failed %d", ret);
			}
2259 2260 2261
		}
	}

2262 2263 2264
	if (changed & IEEE80211_CONF_CHANGE_IDLE && !is_ap) {
		ret = wl1271_sta_handle_idle(wl,
					conf->flags & IEEE80211_CONF_IDLE);
2265 2266
		if (ret < 0)
			wl1271_warning("idle mode change failed %d", ret);
L
Luciano Coelho 已提交
2267 2268
	}

2269 2270 2271 2272 2273 2274 2275
	/*
	 * if mac80211 changes the PSM mode, make sure the mode is not
	 * incorrectly changed after the pspoll failure active window.
	 */
	if (changed & IEEE80211_CONF_CHANGE_PS)
		clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);

2276 2277 2278
	if (conf->flags & IEEE80211_CONF_PS &&
	    !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
		set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
L
Luciano Coelho 已提交
2279 2280 2281 2282 2283 2284

		/*
		 * We enter PSM only if we're already associated.
		 * If we're not, we'll enter it when joining an SSID,
		 * through the bss_info_changed() hook.
		 */
2285
		if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
2286
			wl1271_debug(DEBUG_PSM, "psm enabled");
J
Juuso Oikarinen 已提交
2287
			ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
2288
						 wl->basic_rate, true);
2289
		}
L
Luciano Coelho 已提交
2290
	} else if (!(conf->flags & IEEE80211_CONF_PS) &&
2291
		   test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
2292
		wl1271_debug(DEBUG_PSM, "psm disabled");
L
Luciano Coelho 已提交
2293

2294
		clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
L
Luciano Coelho 已提交
2295

2296
		if (test_bit(WL1271_FLAG_PSM, &wl->flags))
J
Juuso Oikarinen 已提交
2297
			ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
2298
						 wl->basic_rate, true);
L
Luciano Coelho 已提交
2299 2300 2301 2302 2303
	}

	if (conf->power_level != wl->power_level) {
		ret = wl1271_acx_tx_power(wl, conf->power_level);
		if (ret < 0)
2304
			goto out_sleep;
L
Luciano Coelho 已提交
2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317

		wl->power_level = conf->power_level;
	}

out_sleep:
	wl1271_ps_elp_sleep(wl);

out:
	mutex_unlock(&wl->mutex);

	return ret;
}

J
Juuso Oikarinen 已提交
2318 2319 2320 2321 2322 2323
struct wl1271_filter_params {
	bool enabled;
	int mc_list_length;
	u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
};

2324 2325
static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
				       struct netdev_hw_addr_list *mc_list)
2326 2327
{
	struct wl1271_filter_params *fp;
2328
	struct netdev_hw_addr *ha;
2329
	struct wl1271 *wl = hw->priv;
2330

2331 2332
	if (unlikely(wl->state == WL1271_STATE_OFF))
		return 0;
2333

2334
	fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
2335 2336 2337 2338 2339 2340 2341
	if (!fp) {
		wl1271_error("Out of memory setting filters.");
		return 0;
	}

	/* update multicast filtering parameters */
	fp->mc_list_length = 0;
2342 2343 2344 2345 2346
	if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
		fp->enabled = false;
	} else {
		fp->enabled = true;
		netdev_hw_addr_list_for_each(ha, mc_list) {
2347
			memcpy(fp->mc_list[fp->mc_list_length],
2348
					ha->addr, ETH_ALEN);
2349
			fp->mc_list_length++;
2350
		}
2351 2352
	}

J
Juuso Oikarinen 已提交
2353
	return (u64)(unsigned long)fp;
2354
}
L
Luciano Coelho 已提交
2355

J
Juuso Oikarinen 已提交
2356 2357 2358 2359 2360 2361 2362
#define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
				  FIF_ALLMULTI | \
				  FIF_FCSFAIL | \
				  FIF_BCN_PRBRESP_PROMISC | \
				  FIF_CONTROL | \
				  FIF_OTHER_BSS)

L
Luciano Coelho 已提交
2363 2364
static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
				       unsigned int changed,
2365
				       unsigned int *total, u64 multicast)
L
Luciano Coelho 已提交
2366
{
J
Juuso Oikarinen 已提交
2367
	struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
L
Luciano Coelho 已提交
2368
	struct wl1271 *wl = hw->priv;
J
Juuso Oikarinen 已提交
2369
	int ret;
L
Luciano Coelho 已提交
2370

2371 2372
	wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
		     " total %x", changed, *total);
L
Luciano Coelho 已提交
2373

J
Juuso Oikarinen 已提交
2374 2375
	mutex_lock(&wl->mutex);

2376 2377 2378 2379
	*total &= WL1271_SUPPORTED_FILTERS;
	changed &= WL1271_SUPPORTED_FILTERS;

	if (unlikely(wl->state == WL1271_STATE_OFF))
J
Juuso Oikarinen 已提交
2380 2381
		goto out;

2382
	ret = wl1271_ps_elp_wakeup(wl);
J
Juuso Oikarinen 已提交
2383 2384 2385
	if (ret < 0)
		goto out;

2386 2387 2388 2389 2390 2391 2392 2393 2394 2395
	if (wl->bss_type != BSS_TYPE_AP_BSS) {
		if (*total & FIF_ALLMULTI)
			ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
		else if (fp)
			ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
							   fp->mc_list,
							   fp->mc_list_length);
		if (ret < 0)
			goto out_sleep;
	}
L
Luciano Coelho 已提交
2396

E
Eliad Peller 已提交
2397 2398 2399 2400 2401
	/*
	 * the fw doesn't provide an api to configure the filters. instead,
	 * the filters configuration is based on the active roles / ROC
	 * state.
	 */
J
Juuso Oikarinen 已提交
2402 2403 2404 2405 2406 2407

out_sleep:
	wl1271_ps_elp_sleep(wl);

out:
	mutex_unlock(&wl->mutex);
2408
	kfree(fp);
L
Luciano Coelho 已提交
2409 2410
}

2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577
static int wl1271_record_ap_key(struct wl1271 *wl, u8 id, u8 key_type,
			u8 key_size, const u8 *key, u8 hlid, u32 tx_seq_32,
			u16 tx_seq_16)
{
	struct wl1271_ap_key *ap_key;
	int i;

	wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);

	if (key_size > MAX_KEY_SIZE)
		return -EINVAL;

	/*
	 * Find next free entry in ap_keys. Also check we are not replacing
	 * an existing key.
	 */
	for (i = 0; i < MAX_NUM_KEYS; i++) {
		if (wl->recorded_ap_keys[i] == NULL)
			break;

		if (wl->recorded_ap_keys[i]->id == id) {
			wl1271_warning("trying to record key replacement");
			return -EINVAL;
		}
	}

	if (i == MAX_NUM_KEYS)
		return -EBUSY;

	ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
	if (!ap_key)
		return -ENOMEM;

	ap_key->id = id;
	ap_key->key_type = key_type;
	ap_key->key_size = key_size;
	memcpy(ap_key->key, key, key_size);
	ap_key->hlid = hlid;
	ap_key->tx_seq_32 = tx_seq_32;
	ap_key->tx_seq_16 = tx_seq_16;

	wl->recorded_ap_keys[i] = ap_key;
	return 0;
}

static void wl1271_free_ap_keys(struct wl1271 *wl)
{
	int i;

	for (i = 0; i < MAX_NUM_KEYS; i++) {
		kfree(wl->recorded_ap_keys[i]);
		wl->recorded_ap_keys[i] = NULL;
	}
}

static int wl1271_ap_init_hwenc(struct wl1271 *wl)
{
	int i, ret = 0;
	struct wl1271_ap_key *key;
	bool wep_key_added = false;

	for (i = 0; i < MAX_NUM_KEYS; i++) {
		if (wl->recorded_ap_keys[i] == NULL)
			break;

		key = wl->recorded_ap_keys[i];
		ret = wl1271_cmd_set_ap_key(wl, KEY_ADD_OR_REPLACE,
					    key->id, key->key_type,
					    key->key_size, key->key,
					    key->hlid, key->tx_seq_32,
					    key->tx_seq_16);
		if (ret < 0)
			goto out;

		if (key->key_type == KEY_WEP)
			wep_key_added = true;
	}

	if (wep_key_added) {
		ret = wl1271_cmd_set_ap_default_wep_key(wl, wl->default_key);
		if (ret < 0)
			goto out;
	}

out:
	wl1271_free_ap_keys(wl);
	return ret;
}

static int wl1271_set_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
		       u8 key_size, const u8 *key, u32 tx_seq_32,
		       u16 tx_seq_16, struct ieee80211_sta *sta)
{
	int ret;
	bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);

	if (is_ap) {
		struct wl1271_station *wl_sta;
		u8 hlid;

		if (sta) {
			wl_sta = (struct wl1271_station *)sta->drv_priv;
			hlid = wl_sta->hlid;
		} else {
			hlid = WL1271_AP_BROADCAST_HLID;
		}

		if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
			/*
			 * We do not support removing keys after AP shutdown.
			 * Pretend we do to make mac80211 happy.
			 */
			if (action != KEY_ADD_OR_REPLACE)
				return 0;

			ret = wl1271_record_ap_key(wl, id,
					     key_type, key_size,
					     key, hlid, tx_seq_32,
					     tx_seq_16);
		} else {
			ret = wl1271_cmd_set_ap_key(wl, action,
					     id, key_type, key_size,
					     key, hlid, tx_seq_32,
					     tx_seq_16);
		}

		if (ret < 0)
			return ret;
	} else {
		const u8 *addr;
		static const u8 bcast_addr[ETH_ALEN] = {
			0xff, 0xff, 0xff, 0xff, 0xff, 0xff
		};

		addr = sta ? sta->addr : bcast_addr;

		if (is_zero_ether_addr(addr)) {
			/* We dont support TX only encryption */
			return -EOPNOTSUPP;
		}

		/* The wl1271 does not allow to remove unicast keys - they
		   will be cleared automatically on next CMD_JOIN. Ignore the
		   request silently, as we dont want the mac80211 to emit
		   an error message. */
		if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
			return 0;

		ret = wl1271_cmd_set_sta_key(wl, action,
					     id, key_type, key_size,
					     key, addr, tx_seq_32,
					     tx_seq_16);
		if (ret < 0)
			return ret;

		/* the default WEP key needs to be configured at least once */
		if (key_type == KEY_WEP) {
			ret = wl1271_cmd_set_sta_default_wep_key(wl,
							wl->default_key);
			if (ret < 0)
				return ret;
		}
	}

	return 0;
}

L
Luciano Coelho 已提交
2578 2579 2580 2581 2582 2583 2584
static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
			     struct ieee80211_vif *vif,
			     struct ieee80211_sta *sta,
			     struct ieee80211_key_conf *key_conf)
{
	struct wl1271 *wl = hw->priv;
	int ret;
2585 2586
	u32 tx_seq_32 = 0;
	u16 tx_seq_16 = 0;
L
Luciano Coelho 已提交
2587 2588 2589 2590
	u8 key_type;

	wl1271_debug(DEBUG_MAC80211, "mac80211 set key");

2591
	wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
L
Luciano Coelho 已提交
2592
	wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
2593
		     key_conf->cipher, key_conf->keyidx,
L
Luciano Coelho 已提交
2594 2595 2596 2597 2598
		     key_conf->keylen, key_conf->flags);
	wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);

	mutex_lock(&wl->mutex);

2599 2600 2601 2602 2603
	if (unlikely(wl->state == WL1271_STATE_OFF)) {
		ret = -EAGAIN;
		goto out_unlock;
	}

2604
	ret = wl1271_ps_elp_wakeup(wl);
L
Luciano Coelho 已提交
2605 2606 2607
	if (ret < 0)
		goto out_unlock;

2608 2609 2610
	switch (key_conf->cipher) {
	case WLAN_CIPHER_SUITE_WEP40:
	case WLAN_CIPHER_SUITE_WEP104:
L
Luciano Coelho 已提交
2611 2612 2613 2614
		key_type = KEY_WEP;

		key_conf->hw_key_idx = key_conf->keyidx;
		break;
2615
	case WLAN_CIPHER_SUITE_TKIP:
L
Luciano Coelho 已提交
2616 2617 2618
		key_type = KEY_TKIP;

		key_conf->hw_key_idx = key_conf->keyidx;
2619 2620
		tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
		tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
L
Luciano Coelho 已提交
2621
		break;
2622
	case WLAN_CIPHER_SUITE_CCMP:
L
Luciano Coelho 已提交
2623 2624 2625
		key_type = KEY_AES;

		key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
2626 2627
		tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
		tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
L
Luciano Coelho 已提交
2628
		break;
2629 2630 2631 2632 2633
	case WL1271_CIPHER_SUITE_GEM:
		key_type = KEY_GEM;
		tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
		tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
		break;
L
Luciano Coelho 已提交
2634
	default:
2635
		wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
L
Luciano Coelho 已提交
2636 2637 2638 2639 2640 2641 2642

		ret = -EOPNOTSUPP;
		goto out_sleep;
	}

	switch (cmd) {
	case SET_KEY:
2643 2644 2645 2646
		ret = wl1271_set_key(wl, KEY_ADD_OR_REPLACE,
				 key_conf->keyidx, key_type,
				 key_conf->keylen, key_conf->key,
				 tx_seq_32, tx_seq_16, sta);
L
Luciano Coelho 已提交
2647 2648 2649 2650 2651 2652 2653
		if (ret < 0) {
			wl1271_error("Could not add or replace key");
			goto out_sleep;
		}
		break;

	case DISABLE_KEY:
2654 2655 2656 2657
		ret = wl1271_set_key(wl, KEY_REMOVE,
				     key_conf->keyidx, key_type,
				     key_conf->keylen, key_conf->key,
				     0, 0, sta);
L
Luciano Coelho 已提交
2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679
		if (ret < 0) {
			wl1271_error("Could not remove key");
			goto out_sleep;
		}
		break;

	default:
		wl1271_error("Unsupported key cmd 0x%x", cmd);
		ret = -EOPNOTSUPP;
		break;
	}

out_sleep:
	wl1271_ps_elp_sleep(wl);

out_unlock:
	mutex_unlock(&wl->mutex);

	return ret;
}

static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
2680
			     struct ieee80211_vif *vif,
L
Luciano Coelho 已提交
2681 2682 2683 2684 2685
			     struct cfg80211_scan_request *req)
{
	struct wl1271 *wl = hw->priv;
	int ret;
	u8 *ssid = NULL;
2686
	size_t len = 0;
L
Luciano Coelho 已提交
2687 2688 2689 2690 2691

	wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");

	if (req->n_ssids) {
		ssid = req->ssids[0].ssid;
2692
		len = req->ssids[0].ssid_len;
L
Luciano Coelho 已提交
2693 2694 2695 2696
	}

	mutex_lock(&wl->mutex);

2697 2698 2699 2700 2701 2702 2703 2704 2705 2706
	if (wl->state == WL1271_STATE_OFF) {
		/*
		 * We cannot return -EBUSY here because cfg80211 will expect
		 * a call to ieee80211_scan_completed if we do - in this case
		 * there won't be any call.
		 */
		ret = -EAGAIN;
		goto out;
	}

2707
	ret = wl1271_ps_elp_wakeup(wl);
L
Luciano Coelho 已提交
2708 2709 2710
	if (ret < 0)
		goto out;

2711
	ret = wl1271_scan(hw->priv, ssid, len, req);
L
Luciano Coelho 已提交
2712 2713 2714 2715 2716 2717 2718 2719 2720

	wl1271_ps_elp_sleep(wl);

out:
	mutex_unlock(&wl->mutex);

	return ret;
}

2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758
static void wl1271_op_cancel_hw_scan(struct ieee80211_hw *hw,
				     struct ieee80211_vif *vif)
{
	struct wl1271 *wl = hw->priv;
	int ret;

	wl1271_debug(DEBUG_MAC80211, "mac80211 cancel hw scan");

	mutex_lock(&wl->mutex);

	if (wl->state == WL1271_STATE_OFF)
		goto out;

	if (wl->scan.state == WL1271_SCAN_STATE_IDLE)
		goto out;

	ret = wl1271_ps_elp_wakeup(wl);
	if (ret < 0)
		goto out;

	if (wl->scan.state != WL1271_SCAN_STATE_DONE) {
		ret = wl1271_scan_stop(wl);
		if (ret < 0)
			goto out_sleep;
	}
	wl->scan.state = WL1271_SCAN_STATE_IDLE;
	memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
	wl->scan.req = NULL;
	ieee80211_scan_completed(wl->hw, true);

out_sleep:
	wl1271_ps_elp_sleep(wl);
out:
	mutex_unlock(&wl->mutex);

	cancel_delayed_work_sync(&wl->scan_complete_work);
}

2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812
static int wl1271_op_sched_scan_start(struct ieee80211_hw *hw,
				      struct ieee80211_vif *vif,
				      struct cfg80211_sched_scan_request *req,
				      struct ieee80211_sched_scan_ies *ies)
{
	struct wl1271 *wl = hw->priv;
	int ret;

	wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_start");

	mutex_lock(&wl->mutex);

	ret = wl1271_ps_elp_wakeup(wl);
	if (ret < 0)
		goto out;

	ret = wl1271_scan_sched_scan_config(wl, req, ies);
	if (ret < 0)
		goto out_sleep;

	ret = wl1271_scan_sched_scan_start(wl);
	if (ret < 0)
		goto out_sleep;

	wl->sched_scanning = true;

out_sleep:
	wl1271_ps_elp_sleep(wl);
out:
	mutex_unlock(&wl->mutex);
	return ret;
}

static void wl1271_op_sched_scan_stop(struct ieee80211_hw *hw,
				      struct ieee80211_vif *vif)
{
	struct wl1271 *wl = hw->priv;
	int ret;

	wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_stop");

	mutex_lock(&wl->mutex);

	ret = wl1271_ps_elp_wakeup(wl);
	if (ret < 0)
		goto out;

	wl1271_scan_sched_scan_stop(wl);

	wl1271_ps_elp_sleep(wl);
out:
	mutex_unlock(&wl->mutex);
}

2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824
static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
{
	struct wl1271 *wl = hw->priv;
	int ret = 0;

	mutex_lock(&wl->mutex);

	if (unlikely(wl->state == WL1271_STATE_OFF)) {
		ret = -EAGAIN;
		goto out;
	}

2825
	ret = wl1271_ps_elp_wakeup(wl);
2826 2827 2828
	if (ret < 0)
		goto out;

2829
	ret = wl1271_acx_frag_threshold(wl, value);
2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840
	if (ret < 0)
		wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);

	wl1271_ps_elp_sleep(wl);

out:
	mutex_unlock(&wl->mutex);

	return ret;
}

L
Luciano Coelho 已提交
2841 2842 2843
static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
{
	struct wl1271 *wl = hw->priv;
2844
	int ret = 0;
L
Luciano Coelho 已提交
2845 2846 2847

	mutex_lock(&wl->mutex);

2848 2849
	if (unlikely(wl->state == WL1271_STATE_OFF)) {
		ret = -EAGAIN;
2850
		goto out;
2851
	}
2852

2853
	ret = wl1271_ps_elp_wakeup(wl);
L
Luciano Coelho 已提交
2854 2855 2856
	if (ret < 0)
		goto out;

2857
	ret = wl1271_acx_rts_threshold(wl, value);
L
Luciano Coelho 已提交
2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868
	if (ret < 0)
		wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);

	wl1271_ps_elp_sleep(wl);

out:
	mutex_unlock(&wl->mutex);

	return ret;
}

2869
static int wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *skb,
2870
			    int offset)
2871
{
2872 2873 2874
	u8 ssid_len;
	const u8 *ptr = cfg80211_find_ie(WLAN_EID_SSID, skb->data + offset,
					 skb->len - offset);
2875

2876 2877 2878 2879 2880 2881 2882 2883 2884
	if (!ptr) {
		wl1271_error("No SSID in IEs!");
		return -ENOENT;
	}

	ssid_len = ptr[1];
	if (ssid_len > IEEE80211_MAX_SSID_LEN) {
		wl1271_error("SSID is too long!");
		return -EINVAL;
2885
	}
2886

2887 2888 2889
	wl->ssid_len = ssid_len;
	memcpy(wl->ssid, ptr+2, ssid_len);
	return 0;
2890 2891
}

2892
static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
L
Luciano Coelho 已提交
2893 2894 2895
				       struct ieee80211_bss_conf *bss_conf,
				       u32 changed)
{
2896
	int ret = 0;
L
Luciano Coelho 已提交
2897

2898 2899 2900 2901 2902 2903 2904 2905 2906 2907
	if (changed & BSS_CHANGED_ERP_SLOT) {
		if (bss_conf->use_short_slot)
			ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
		else
			ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
		if (ret < 0) {
			wl1271_warning("Set slot time failed %d", ret);
			goto out;
		}
	}
L
Luciano Coelho 已提交
2908

2909 2910 2911 2912 2913 2914
	if (changed & BSS_CHANGED_ERP_PREAMBLE) {
		if (bss_conf->use_short_preamble)
			wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
		else
			wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
	}
L
Luciano Coelho 已提交
2915

2916 2917 2918 2919 2920 2921 2922 2923 2924 2925
	if (changed & BSS_CHANGED_ERP_CTS_PROT) {
		if (bss_conf->use_cts_prot)
			ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
		else
			ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
		if (ret < 0) {
			wl1271_warning("Set ctsprotect failed %d", ret);
			goto out;
		}
	}
2926

2927 2928 2929
out:
	return ret;
}
L
Luciano Coelho 已提交
2930

2931 2932 2933 2934 2935 2936 2937 2938 2939 2940
static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
					  struct ieee80211_vif *vif,
					  struct ieee80211_bss_conf *bss_conf,
					  u32 changed)
{
	bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
	int ret = 0;

	if ((changed & BSS_CHANGED_BEACON_INT)) {
		wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
2941 2942 2943 2944 2945
			bss_conf->beacon_int);

		wl->beacon_int = bss_conf->beacon_int;
	}

2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000
	if ((changed & BSS_CHANGED_BEACON)) {
		struct ieee80211_hdr *hdr;
		int ieoffset = offsetof(struct ieee80211_mgmt,
					u.beacon.variable);
		struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
		u16 tmpl_id;

		if (!beacon)
			goto out;

		wl1271_debug(DEBUG_MASTER, "beacon updated");

		ret = wl1271_ssid_set(wl, beacon, ieoffset);
		if (ret < 0) {
			dev_kfree_skb(beacon);
			goto out;
		}
		tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
				  CMD_TEMPL_BEACON;
		ret = wl1271_cmd_template_set(wl, tmpl_id,
					      beacon->data,
					      beacon->len, 0,
					      wl1271_tx_min_rate_get(wl));
		if (ret < 0) {
			dev_kfree_skb(beacon);
			goto out;
		}

		hdr = (struct ieee80211_hdr *) beacon->data;
		hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
						 IEEE80211_STYPE_PROBE_RESP);

		tmpl_id = is_ap ? CMD_TEMPL_AP_PROBE_RESPONSE :
				  CMD_TEMPL_PROBE_RESPONSE;
		ret = wl1271_cmd_template_set(wl,
					      tmpl_id,
					      beacon->data,
					      beacon->len, 0,
					      wl1271_tx_min_rate_get(wl));
		dev_kfree_skb(beacon);
		if (ret < 0)
			goto out;
	}

out:
	return ret;
}

/* AP mode changes */
static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
				       struct ieee80211_vif *vif,
				       struct ieee80211_bss_conf *bss_conf,
				       u32 changed)
{
	int ret = 0;
3001

3002 3003
	if ((changed & BSS_CHANGED_BASIC_RATES)) {
		u32 rates = bss_conf->basic_rates;
3004

3005 3006
		wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates);
		wl->basic_rate = wl1271_tx_min_rate_get(wl);
3007 3008

		ret = wl1271_init_ap_rates(wl);
3009
		if (ret < 0) {
3010
			wl1271_error("AP rate policy change failed %d", ret);
3011 3012
			goto out;
		}
3013 3014 3015 3016

		ret = wl1271_ap_init_templates(wl);
		if (ret < 0)
			goto out;
3017
	}
3018

3019 3020 3021
	ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
	if (ret < 0)
		goto out;
3022

3023 3024 3025 3026 3027 3028
	if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
		if (bss_conf->enable_beacon) {
			if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
				ret = wl1271_cmd_start_bss(wl);
				if (ret < 0)
					goto out;
3029

3030 3031
				set_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
				wl1271_debug(DEBUG_AP, "started AP");
3032 3033 3034 3035

				ret = wl1271_ap_init_hwenc(wl);
				if (ret < 0)
					goto out;
3036
			}
3037 3038 3039 3040 3041
		} else {
			if (test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
				ret = wl1271_cmd_stop_bss(wl);
				if (ret < 0)
					goto out;
3042

3043 3044 3045 3046 3047
				clear_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
				wl1271_debug(DEBUG_AP, "stopped AP");
			}
		}
	}
3048

3049 3050 3051 3052 3053 3054
	ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
	if (ret < 0)
		goto out;
out:
	return;
}
J
Juuso Oikarinen 已提交
3055

3056 3057 3058 3059 3060 3061 3062 3063
/* STA/IBSS mode changes */
static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
					struct ieee80211_vif *vif,
					struct ieee80211_bss_conf *bss_conf,
					u32 changed)
{
	bool do_join = false, set_assoc = false;
	bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS);
3064
	u32 sta_rate_set = 0;
3065
	int ret;
3066
	struct ieee80211_sta *sta;
3067 3068
	bool sta_exists = false;
	struct ieee80211_sta_ht_cap sta_ht_cap;
3069 3070 3071 3072 3073 3074

	if (is_ibss) {
		ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
						     changed);
		if (ret < 0)
			goto out;
3075 3076
	}

3077 3078 3079 3080 3081 3082 3083 3084
	if ((changed & BSS_CHANGED_BEACON_INT)  && is_ibss)
		do_join = true;

	/* Need to update the SSID (for filtering etc) */
	if ((changed & BSS_CHANGED_BEACON) && is_ibss)
		do_join = true;

	if ((changed & BSS_CHANGED_BEACON_ENABLED) && is_ibss) {
3085 3086 3087 3088 3089 3090 3091 3092 3093 3094
		wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
			     bss_conf->enable_beacon ? "enabled" : "disabled");

		if (bss_conf->enable_beacon)
			wl->set_bss_type = BSS_TYPE_IBSS;
		else
			wl->set_bss_type = BSS_TYPE_STA_BSS;
		do_join = true;
	}

3095
	if ((changed & BSS_CHANGED_CQM)) {
3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106
		bool enable = false;
		if (bss_conf->cqm_rssi_thold)
			enable = true;
		ret = wl1271_acx_rssi_snr_trigger(wl, enable,
						  bss_conf->cqm_rssi_thold,
						  bss_conf->cqm_rssi_hyst);
		if (ret < 0)
			goto out;
		wl->rssi_thold = bss_conf->cqm_rssi_thold;
	}

3107 3108 3109 3110 3111 3112
	if ((changed & BSS_CHANGED_BSSID) &&
	    /*
	     * Now we know the correct bssid, so we send a new join command
	     * and enable the BSSID filter
	     */
	    memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
3113
		memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
3114

3115 3116 3117 3118
		if (!is_zero_ether_addr(wl->bssid)) {
			ret = wl1271_cmd_build_null_data(wl);
			if (ret < 0)
				goto out;
3119

3120 3121 3122
			ret = wl1271_build_qos_null_data(wl);
			if (ret < 0)
				goto out;
3123

3124 3125 3126
			/* Need to update the BSSID (for filtering etc) */
			do_join = true;
		}
3127 3128
	}

3129 3130 3131 3132 3133 3134 3135 3136
	rcu_read_lock();
	sta = ieee80211_find_sta(vif, bss_conf->bssid);
	if (sta)  {
		/* save the supp_rates of the ap */
		sta_rate_set = sta->supp_rates[wl->hw->conf.channel->band];
		if (sta->ht_cap.ht_supported)
			sta_rate_set |=
			    (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
3137 3138 3139 3140
		sta_ht_cap = sta->ht_cap;
		sta_exists = true;
	}
	rcu_read_unlock();
3141

3142
	if (sta_exists) {
3143 3144 3145
		/* handle new association with HT and HT information change */
		if ((changed & BSS_CHANGED_HT) &&
		    (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
3146
			ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162
							     true);
			if (ret < 0) {
				wl1271_warning("Set ht cap true failed %d",
					       ret);
				goto out;
			}
			ret = wl1271_acx_set_ht_information(wl,
						bss_conf->ht_operation_mode);
			if (ret < 0) {
				wl1271_warning("Set ht information failed %d",
					       ret);
				goto out;
			}
		}
		/* handle new association without HT and disassociation */
		else if (changed & BSS_CHANGED_ASSOC) {
3163
			ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
3164 3165 3166 3167 3168 3169 3170 3171 3172
							     false);
			if (ret < 0) {
				wl1271_warning("Set ht cap false failed %d",
					       ret);
				goto out;
			}
		}
	}

3173
	if ((changed & BSS_CHANGED_ASSOC)) {
L
Luciano Coelho 已提交
3174
		if (bss_conf->assoc) {
3175
			u32 rates;
3176
			int ieoffset;
L
Luciano Coelho 已提交
3177
			wl->aid = bss_conf->aid;
3178
			set_assoc = true;
L
Luciano Coelho 已提交
3179

3180 3181
			wl->ps_poll_failures = 0;

3182 3183 3184 3185 3186 3187 3188
			/*
			 * use basic rates from AP, and determine lowest rate
			 * to use with control frames.
			 */
			rates = bss_conf->basic_rates;
			wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
									 rates);
A
Arik Nemtsov 已提交
3189
			wl->basic_rate = wl1271_tx_min_rate_get(wl);
3190 3191 3192
			if (sta_rate_set)
				wl->rate_set = wl1271_tx_enabled_rates_get(wl,
								sta_rate_set);
3193
			ret = wl1271_acx_sta_rate_policies(wl);
3194
			if (ret < 0)
3195
				goto out;
3196

3197 3198 3199 3200 3201 3202
			/*
			 * with wl1271, we don't need to update the
			 * beacon_int and dtim_period, because the firmware
			 * updates it by itself when the first beacon is
			 * received after a join.
			 */
L
Luciano Coelho 已提交
3203 3204
			ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
			if (ret < 0)
3205
				goto out;
L
Luciano Coelho 已提交
3206

3207
			/*
3208
			 * Get a template for hardware connection maintenance
3209
			 */
3210 3211 3212 3213 3214
			dev_kfree_skb(wl->probereq);
			wl->probereq = wl1271_cmd_build_ap_probe_req(wl, NULL);
			ieoffset = offsetof(struct ieee80211_mgmt,
					    u.probe_req.variable);
			wl1271_ssid_set(wl, wl->probereq, ieoffset);
3215

3216 3217
			/* enable the connection monitoring feature */
			ret = wl1271_acx_conn_monit_params(wl, true);
L
Luciano Coelho 已提交
3218
			if (ret < 0)
3219
				goto out;
L
Luciano Coelho 已提交
3220 3221

			/* If we want to go in PSM but we're not there yet */
3222 3223
			if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
			    !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
3224 3225
				enum wl1271_cmd_ps_mode mode;

L
Luciano Coelho 已提交
3226
				mode = STATION_POWER_SAVE_MODE;
3227
				ret = wl1271_ps_set_mode(wl, mode,
3228
							 wl->basic_rate,
3229
							 true);
L
Luciano Coelho 已提交
3230
				if (ret < 0)
3231
					goto out;
L
Luciano Coelho 已提交
3232
			}
J
Juuso Oikarinen 已提交
3233 3234
		} else {
			/* use defaults when not associated */
3235 3236 3237
			bool was_assoc =
			    !!test_and_clear_bit(WL1271_FLAG_STA_ASSOCIATED,
						 &wl->flags);
3238
			clear_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags);
J
Juuso Oikarinen 已提交
3239
			wl->aid = 0;
3240

3241 3242 3243 3244
			/* free probe-request template */
			dev_kfree_skb(wl->probereq);
			wl->probereq = NULL;

3245
			/* re-enable dynamic ps - just in case */
3246
			ieee80211_enable_dyn_ps(wl->vif);
3247

3248 3249
			/* revert back to minimum rates for the current band */
			wl1271_set_band_rate(wl);
A
Arik Nemtsov 已提交
3250
			wl->basic_rate = wl1271_tx_min_rate_get(wl);
3251
			ret = wl1271_acx_sta_rate_policies(wl);
3252
			if (ret < 0)
3253
				goto out;
3254

3255 3256
			/* disable connection monitor features */
			ret = wl1271_acx_conn_monit_params(wl, false);
3257 3258 3259

			/* Disable the keep-alive feature */
			ret = wl1271_acx_keep_alive_mode(wl, false);
3260
			if (ret < 0)
3261
				goto out;
3262 3263

			/* restore the bssid filter and go to dummy bssid */
3264 3265 3266 3267
			if (was_assoc) {
				wl1271_unjoin(wl);
				wl1271_dummy_join(wl);
			}
L
Luciano Coelho 已提交
3268 3269 3270
		}
	}

3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288
	if (changed & BSS_CHANGED_IBSS) {
		wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d",
			     bss_conf->ibss_joined);

		if (bss_conf->ibss_joined) {
			u32 rates = bss_conf->basic_rates;
			wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
									 rates);
			wl->basic_rate = wl1271_tx_min_rate_get(wl);

			/* by default, use 11b rates */
			wl->rate_set = CONF_TX_IBSS_DEFAULT_RATES;
			ret = wl1271_acx_sta_rate_policies(wl);
			if (ret < 0)
				goto out;
		}
	}

3289 3290 3291
	ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
	if (ret < 0)
		goto out;
L
Luciano Coelho 已提交
3292

3293 3294 3295 3296
	if (changed & BSS_CHANGED_ARP_FILTER) {
		__be32 addr = bss_conf->arp_addr_list[0];
		WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);

E
Eliad Peller 已提交
3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307
		if (bss_conf->arp_addr_cnt == 1 &&
		    bss_conf->arp_filter_enabled) {
			/*
			 * The template should have been configured only upon
			 * association. however, it seems that the correct ip
			 * isn't being set (when sending), so we have to
			 * reconfigure the template upon every ip change.
			 */
			ret = wl1271_cmd_build_arp_rsp(wl, addr);
			if (ret < 0) {
				wl1271_warning("build arp rsp failed: %d", ret);
3308
				goto out;
E
Eliad Peller 已提交
3309 3310 3311
			}

			ret = wl1271_acx_arp_ip_filter(wl,
E
Eliad Peller 已提交
3312
				ACX_ARP_FILTER_ARP_FILTERING,
E
Eliad Peller 已提交
3313 3314 3315
				addr);
		} else
			ret = wl1271_acx_arp_ip_filter(wl, 0, addr);
3316 3317

		if (ret < 0)
3318
			goto out;
3319 3320
	}

J
Juuso Oikarinen 已提交
3321
	if (do_join) {
3322
		ret = wl1271_join(wl, set_assoc);
J
Juuso Oikarinen 已提交
3323 3324
		if (ret < 0) {
			wl1271_warning("cmd join failed %d", ret);
3325
			goto out;
J
Juuso Oikarinen 已提交
3326
		}
3327
		wl1271_check_operstate(wl, ieee80211_get_operstate(vif));
3328 3329
	}

3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350
out:
	return;
}

static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
				       struct ieee80211_vif *vif,
				       struct ieee80211_bss_conf *bss_conf,
				       u32 changed)
{
	struct wl1271 *wl = hw->priv;
	bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
	int ret;

	wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
		     (int)changed);

	mutex_lock(&wl->mutex);

	if (unlikely(wl->state == WL1271_STATE_OFF))
		goto out;

3351
	ret = wl1271_ps_elp_wakeup(wl);
3352 3353 3354 3355 3356 3357 3358 3359
	if (ret < 0)
		goto out;

	if (is_ap)
		wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
	else
		wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);

L
Luciano Coelho 已提交
3360 3361 3362 3363 3364 3365
	wl1271_ps_elp_sleep(wl);

out:
	mutex_unlock(&wl->mutex);
}

K
Kalle Valo 已提交
3366 3367 3368 3369
static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
			     const struct ieee80211_tx_queue_params *params)
{
	struct wl1271 *wl = hw->priv;
K
Kalle Valo 已提交
3370
	u8 ps_scheme;
3371
	int ret = 0;
K
Kalle Valo 已提交
3372 3373 3374 3375 3376

	mutex_lock(&wl->mutex);

	wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);

K
Kalle Valo 已提交
3377 3378 3379 3380 3381
	if (params->uapsd)
		ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
	else
		ps_scheme = CONF_PS_SCHEME_LEGACY;

3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404
	if (wl->state == WL1271_STATE_OFF) {
		/*
		 * If the state is off, the parameters will be recorded and
		 * configured on init. This happens in AP-mode.
		 */
		struct conf_tx_ac_category *conf_ac =
			&wl->conf.tx.ac_conf[wl1271_tx_get_queue(queue)];
		struct conf_tx_tid *conf_tid =
			&wl->conf.tx.tid_conf[wl1271_tx_get_queue(queue)];

		conf_ac->ac = wl1271_tx_get_queue(queue);
		conf_ac->cw_min = (u8)params->cw_min;
		conf_ac->cw_max = params->cw_max;
		conf_ac->aifsn = params->aifs;
		conf_ac->tx_op_limit = params->txop << 5;

		conf_tid->queue_id = wl1271_tx_get_queue(queue);
		conf_tid->channel_type = CONF_CHANNEL_TYPE_EDCF;
		conf_tid->tsid = wl1271_tx_get_queue(queue);
		conf_tid->ps_scheme = ps_scheme;
		conf_tid->ack_policy = CONF_ACK_POLICY_LEGACY;
		conf_tid->apsd_conf[0] = 0;
		conf_tid->apsd_conf[1] = 0;
3405 3406
		goto out;
	}
3407

3408 3409 3410
	ret = wl1271_ps_elp_wakeup(wl);
	if (ret < 0)
		goto out;
3411

3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426
	/*
	 * the txop is confed in units of 32us by the mac80211,
	 * we need us
	 */
	ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
				params->cw_min, params->cw_max,
				params->aifs, params->txop << 5);
	if (ret < 0)
		goto out_sleep;

	ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
				 CONF_CHANNEL_TYPE_EDCF,
				 wl1271_tx_get_queue(queue),
				 ps_scheme, CONF_ACK_POLICY_LEGACY,
				 0, 0);
K
Kalle Valo 已提交
3427 3428

out_sleep:
3429
	wl1271_ps_elp_sleep(wl);
K
Kalle Valo 已提交
3430 3431 3432 3433 3434 3435 3436

out:
	mutex_unlock(&wl->mutex);

	return ret;
}

J
Juuso Oikarinen 已提交
3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447
static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
{

	struct wl1271 *wl = hw->priv;
	u64 mactime = ULLONG_MAX;
	int ret;

	wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");

	mutex_lock(&wl->mutex);

3448 3449 3450
	if (unlikely(wl->state == WL1271_STATE_OFF))
		goto out;

3451
	ret = wl1271_ps_elp_wakeup(wl);
J
Juuso Oikarinen 已提交
3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465
	if (ret < 0)
		goto out;

	ret = wl1271_acx_tsf_info(wl, &mactime);
	if (ret < 0)
		goto out_sleep;

out_sleep:
	wl1271_ps_elp_sleep(wl);

out:
	mutex_unlock(&wl->mutex);
	return mactime;
}
L
Luciano Coelho 已提交
3466

3467 3468 3469 3470 3471
static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
				struct survey_info *survey)
{
	struct wl1271 *wl = hw->priv;
	struct ieee80211_conf *conf = &hw->conf;
3472

3473 3474
	if (idx != 0)
		return -ENOENT;
3475

3476 3477 3478
	survey->channel = conf->channel;
	survey->filled = SURVEY_INFO_NOISE_DBM;
	survey->noise = wl->noise;
3479

3480 3481 3482
	return 0;
}

3483
static int wl1271_allocate_sta(struct wl1271 *wl,
3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499
			     struct ieee80211_sta *sta,
			     u8 *hlid)
{
	struct wl1271_station *wl_sta;
	int id;

	id = find_first_zero_bit(wl->ap_hlid_map, AP_MAX_STATIONS);
	if (id >= AP_MAX_STATIONS) {
		wl1271_warning("could not allocate HLID - too much stations");
		return -EBUSY;
	}

	wl_sta = (struct wl1271_station *)sta->drv_priv;
	__set_bit(id, wl->ap_hlid_map);
	wl_sta->hlid = WL1271_AP_STA_HLID_START + id;
	*hlid = wl_sta->hlid;
3500
	memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
3501 3502 3503
	return 0;
}

3504
static void wl1271_free_sta(struct wl1271 *wl, u8 hlid)
3505 3506 3507
{
	int id = hlid - WL1271_AP_STA_HLID_START;

3508 3509 3510
	if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
		return;

3511
	__clear_bit(id, wl->ap_hlid_map);
3512
	memset(wl->links[hlid].addr, 0, ETH_ALEN);
3513
	wl1271_tx_reset_link_queues(wl, hlid);
3514 3515
	__clear_bit(hlid, &wl->ap_ps_map);
	__clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
3516 3517
}

3518 3519 3520 3521 3522 3523
bool wl1271_is_active_sta(struct wl1271 *wl, u8 hlid)
{
	int id = hlid - WL1271_AP_STA_HLID_START;
	return test_bit(id, wl->ap_hlid_map);
}

3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541
static int wl1271_op_sta_add(struct ieee80211_hw *hw,
			     struct ieee80211_vif *vif,
			     struct ieee80211_sta *sta)
{
	struct wl1271 *wl = hw->priv;
	int ret = 0;
	u8 hlid;

	mutex_lock(&wl->mutex);

	if (unlikely(wl->state == WL1271_STATE_OFF))
		goto out;

	if (wl->bss_type != BSS_TYPE_AP_BSS)
		goto out;

	wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);

3542
	ret = wl1271_allocate_sta(wl, sta, &hlid);
3543 3544 3545
	if (ret < 0)
		goto out;

3546
	ret = wl1271_ps_elp_wakeup(wl);
3547
	if (ret < 0)
3548
		goto out_free_sta;
3549 3550 3551 3552 3553 3554 3555 3556

	ret = wl1271_cmd_add_sta(wl, sta, hlid);
	if (ret < 0)
		goto out_sleep;

out_sleep:
	wl1271_ps_elp_sleep(wl);

3557 3558 3559 3560
out_free_sta:
	if (ret < 0)
		wl1271_free_sta(wl, hlid);

3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588
out:
	mutex_unlock(&wl->mutex);
	return ret;
}

static int wl1271_op_sta_remove(struct ieee80211_hw *hw,
				struct ieee80211_vif *vif,
				struct ieee80211_sta *sta)
{
	struct wl1271 *wl = hw->priv;
	struct wl1271_station *wl_sta;
	int ret = 0, id;

	mutex_lock(&wl->mutex);

	if (unlikely(wl->state == WL1271_STATE_OFF))
		goto out;

	if (wl->bss_type != BSS_TYPE_AP_BSS)
		goto out;

	wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);

	wl_sta = (struct wl1271_station *)sta->drv_priv;
	id = wl_sta->hlid - WL1271_AP_STA_HLID_START;
	if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
		goto out;

3589
	ret = wl1271_ps_elp_wakeup(wl);
3590 3591 3592 3593 3594 3595 3596
	if (ret < 0)
		goto out;

	ret = wl1271_cmd_remove_sta(wl, wl_sta->hlid);
	if (ret < 0)
		goto out_sleep;

3597
	wl1271_free_sta(wl, wl_sta->hlid);
3598 3599 3600 3601 3602 3603 3604 3605 3606

out_sleep:
	wl1271_ps_elp_sleep(wl);

out:
	mutex_unlock(&wl->mutex);
	return ret;
}

3607 3608 3609 3610 3611
static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
				  struct ieee80211_vif *vif,
				  enum ieee80211_ampdu_mlme_action action,
				  struct ieee80211_sta *sta, u16 tid, u16 *ssn,
				  u8 buf_size)
L
Levi, Shahar 已提交
3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622
{
	struct wl1271 *wl = hw->priv;
	int ret;

	mutex_lock(&wl->mutex);

	if (unlikely(wl->state == WL1271_STATE_OFF)) {
		ret = -EAGAIN;
		goto out;
	}

3623
	ret = wl1271_ps_elp_wakeup(wl);
L
Levi, Shahar 已提交
3624 3625 3626
	if (ret < 0)
		goto out;

3627 3628 3629
	wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu: Rx tid %d action %d",
		     tid, action);

L
Levi, Shahar 已提交
3630 3631
	switch (action) {
	case IEEE80211_AMPDU_RX_START:
3632
		if ((wl->ba_support) && (wl->ba_allowed)) {
L
Levi, Shahar 已提交
3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670
			ret = wl1271_acx_set_ba_receiver_session(wl, tid, *ssn,
								 true);
			if (!ret)
				wl->ba_rx_bitmap |= BIT(tid);
		} else {
			ret = -ENOTSUPP;
		}
		break;

	case IEEE80211_AMPDU_RX_STOP:
		ret = wl1271_acx_set_ba_receiver_session(wl, tid, 0, false);
		if (!ret)
			wl->ba_rx_bitmap &= ~BIT(tid);
		break;

	/*
	 * The BA initiator session management in FW independently.
	 * Falling break here on purpose for all TX APDU commands.
	 */
	case IEEE80211_AMPDU_TX_START:
	case IEEE80211_AMPDU_TX_STOP:
	case IEEE80211_AMPDU_TX_OPERATIONAL:
		ret = -EINVAL;
		break;

	default:
		wl1271_error("Incorrect ampdu action id=%x\n", action);
		ret = -EINVAL;
	}

	wl1271_ps_elp_sleep(wl);

out:
	mutex_unlock(&wl->mutex);

	return ret;
}

3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681
static bool wl1271_tx_frames_pending(struct ieee80211_hw *hw)
{
	struct wl1271 *wl = hw->priv;
	bool ret = false;

	mutex_lock(&wl->mutex);

	if (unlikely(wl->state == WL1271_STATE_OFF))
		goto out;

	/* packets are considered pending if in the TX queue or the FW */
3682
	ret = (wl1271_tx_total_queue_count(wl) > 0) || (wl->tx_frames_cnt > 0);
3683 3684 3685 3686 3687 3688 3689 3690 3691 3692

	/* the above is appropriate for STA mode for PS purposes */
	WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);

out:
	mutex_unlock(&wl->mutex);

	return ret;
}

L
Luciano Coelho 已提交
3693 3694 3695
/* can't be const, mac80211 writes to this */
static struct ieee80211_rate wl1271_rates[] = {
	{ .bitrate = 10,
3696 3697
	  .hw_value = CONF_HW_BIT_RATE_1MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
L
Luciano Coelho 已提交
3698
	{ .bitrate = 20,
3699 3700
	  .hw_value = CONF_HW_BIT_RATE_2MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
L
Luciano Coelho 已提交
3701 3702
	  .flags = IEEE80211_RATE_SHORT_PREAMBLE },
	{ .bitrate = 55,
3703 3704
	  .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
L
Luciano Coelho 已提交
3705 3706
	  .flags = IEEE80211_RATE_SHORT_PREAMBLE },
	{ .bitrate = 110,
3707 3708
	  .hw_value = CONF_HW_BIT_RATE_11MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
L
Luciano Coelho 已提交
3709 3710
	  .flags = IEEE80211_RATE_SHORT_PREAMBLE },
	{ .bitrate = 60,
3711 3712
	  .hw_value = CONF_HW_BIT_RATE_6MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
L
Luciano Coelho 已提交
3713
	{ .bitrate = 90,
3714 3715
	  .hw_value = CONF_HW_BIT_RATE_9MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
L
Luciano Coelho 已提交
3716
	{ .bitrate = 120,
3717 3718
	  .hw_value = CONF_HW_BIT_RATE_12MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
L
Luciano Coelho 已提交
3719
	{ .bitrate = 180,
3720 3721
	  .hw_value = CONF_HW_BIT_RATE_18MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
L
Luciano Coelho 已提交
3722
	{ .bitrate = 240,
3723 3724
	  .hw_value = CONF_HW_BIT_RATE_24MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
L
Luciano Coelho 已提交
3725
	{ .bitrate = 360,
3726 3727
	 .hw_value = CONF_HW_BIT_RATE_36MBPS,
	 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
L
Luciano Coelho 已提交
3728
	{ .bitrate = 480,
3729 3730
	  .hw_value = CONF_HW_BIT_RATE_48MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
L
Luciano Coelho 已提交
3731
	{ .bitrate = 540,
3732 3733
	  .hw_value = CONF_HW_BIT_RATE_54MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
L
Luciano Coelho 已提交
3734 3735
};

3736
/* can't be const, mac80211 writes to this */
L
Luciano Coelho 已提交
3737
static struct ieee80211_channel wl1271_channels[] = {
3738
	{ .hw_value = 1, .center_freq = 2412, .max_power = 25 },
3739
	{ .hw_value = 2, .center_freq = 2417, .max_power = 25 },
3740 3741 3742
	{ .hw_value = 3, .center_freq = 2422, .max_power = 25 },
	{ .hw_value = 4, .center_freq = 2427, .max_power = 25 },
	{ .hw_value = 5, .center_freq = 2432, .max_power = 25 },
3743
	{ .hw_value = 6, .center_freq = 2437, .max_power = 25 },
3744 3745 3746
	{ .hw_value = 7, .center_freq = 2442, .max_power = 25 },
	{ .hw_value = 8, .center_freq = 2447, .max_power = 25 },
	{ .hw_value = 9, .center_freq = 2452, .max_power = 25 },
3747
	{ .hw_value = 10, .center_freq = 2457, .max_power = 25 },
3748 3749 3750
	{ .hw_value = 11, .center_freq = 2462, .max_power = 25 },
	{ .hw_value = 12, .center_freq = 2467, .max_power = 25 },
	{ .hw_value = 13, .center_freq = 2472, .max_power = 25 },
3751
	{ .hw_value = 14, .center_freq = 2484, .max_power = 25 },
L
Luciano Coelho 已提交
3752 3753
};

3754
/* mapping to indexes for wl1271_rates */
3755
static const u8 wl1271_rate_to_idx_2ghz[] = {
3756
	/* MCS rates are used only with 11n */
3757 3758 3759 3760 3761 3762 3763 3764
	7,                            /* CONF_HW_RXTX_RATE_MCS7 */
	6,                            /* CONF_HW_RXTX_RATE_MCS6 */
	5,                            /* CONF_HW_RXTX_RATE_MCS5 */
	4,                            /* CONF_HW_RXTX_RATE_MCS4 */
	3,                            /* CONF_HW_RXTX_RATE_MCS3 */
	2,                            /* CONF_HW_RXTX_RATE_MCS2 */
	1,                            /* CONF_HW_RXTX_RATE_MCS1 */
	0,                            /* CONF_HW_RXTX_RATE_MCS0 */
3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783

	11,                            /* CONF_HW_RXTX_RATE_54   */
	10,                            /* CONF_HW_RXTX_RATE_48   */
	9,                             /* CONF_HW_RXTX_RATE_36   */
	8,                             /* CONF_HW_RXTX_RATE_24   */

	/* TI-specific rate */
	CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22   */

	7,                             /* CONF_HW_RXTX_RATE_18   */
	6,                             /* CONF_HW_RXTX_RATE_12   */
	3,                             /* CONF_HW_RXTX_RATE_11   */
	5,                             /* CONF_HW_RXTX_RATE_9    */
	4,                             /* CONF_HW_RXTX_RATE_6    */
	2,                             /* CONF_HW_RXTX_RATE_5_5  */
	1,                             /* CONF_HW_RXTX_RATE_2    */
	0                              /* CONF_HW_RXTX_RATE_1    */
};

S
Shahar Levi 已提交
3784 3785 3786
/* 11n STA capabilities */
#define HW_RX_HIGHEST_RATE	72

S
Shahar Levi 已提交
3787 3788
#ifdef CONFIG_WL12XX_HT
#define WL12XX_HT_CAP { \
3789 3790
	.cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | \
	       (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT), \
S
Shahar Levi 已提交
3791 3792 3793 3794 3795 3796 3797 3798 3799
	.ht_supported = true, \
	.ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
	.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
	.mcs = { \
		.rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
		.rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
		.tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
		}, \
}
3800
#else
S
Shahar Levi 已提交
3801
#define WL12XX_HT_CAP { \
3802 3803 3804
	.ht_supported = false, \
}
#endif
S
Shahar Levi 已提交
3805

L
Luciano Coelho 已提交
3806 3807 3808 3809 3810 3811
/* can't be const, mac80211 writes to this */
static struct ieee80211_supported_band wl1271_band_2ghz = {
	.channels = wl1271_channels,
	.n_channels = ARRAY_SIZE(wl1271_channels),
	.bitrates = wl1271_rates,
	.n_bitrates = ARRAY_SIZE(wl1271_rates),
S
Shahar Levi 已提交
3812
	.ht_cap	= WL12XX_HT_CAP,
L
Luciano Coelho 已提交
3813 3814
};

3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842
/* 5 GHz data rates for WL1273 */
static struct ieee80211_rate wl1271_rates_5ghz[] = {
	{ .bitrate = 60,
	  .hw_value = CONF_HW_BIT_RATE_6MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
	{ .bitrate = 90,
	  .hw_value = CONF_HW_BIT_RATE_9MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
	{ .bitrate = 120,
	  .hw_value = CONF_HW_BIT_RATE_12MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
	{ .bitrate = 180,
	  .hw_value = CONF_HW_BIT_RATE_18MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
	{ .bitrate = 240,
	  .hw_value = CONF_HW_BIT_RATE_24MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
	{ .bitrate = 360,
	 .hw_value = CONF_HW_BIT_RATE_36MBPS,
	 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
	{ .bitrate = 480,
	  .hw_value = CONF_HW_BIT_RATE_48MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
	{ .bitrate = 540,
	  .hw_value = CONF_HW_BIT_RATE_54MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
};

3843
/* 5 GHz band channels for WL1273 */
3844
static struct ieee80211_channel wl1271_channels_5ghz[] = {
3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878
	{ .hw_value = 7, .center_freq = 5035, .max_power = 25 },
	{ .hw_value = 8, .center_freq = 5040, .max_power = 25 },
	{ .hw_value = 9, .center_freq = 5045, .max_power = 25 },
	{ .hw_value = 11, .center_freq = 5055, .max_power = 25 },
	{ .hw_value = 12, .center_freq = 5060, .max_power = 25 },
	{ .hw_value = 16, .center_freq = 5080, .max_power = 25 },
	{ .hw_value = 34, .center_freq = 5170, .max_power = 25 },
	{ .hw_value = 36, .center_freq = 5180, .max_power = 25 },
	{ .hw_value = 38, .center_freq = 5190, .max_power = 25 },
	{ .hw_value = 40, .center_freq = 5200, .max_power = 25 },
	{ .hw_value = 42, .center_freq = 5210, .max_power = 25 },
	{ .hw_value = 44, .center_freq = 5220, .max_power = 25 },
	{ .hw_value = 46, .center_freq = 5230, .max_power = 25 },
	{ .hw_value = 48, .center_freq = 5240, .max_power = 25 },
	{ .hw_value = 52, .center_freq = 5260, .max_power = 25 },
	{ .hw_value = 56, .center_freq = 5280, .max_power = 25 },
	{ .hw_value = 60, .center_freq = 5300, .max_power = 25 },
	{ .hw_value = 64, .center_freq = 5320, .max_power = 25 },
	{ .hw_value = 100, .center_freq = 5500, .max_power = 25 },
	{ .hw_value = 104, .center_freq = 5520, .max_power = 25 },
	{ .hw_value = 108, .center_freq = 5540, .max_power = 25 },
	{ .hw_value = 112, .center_freq = 5560, .max_power = 25 },
	{ .hw_value = 116, .center_freq = 5580, .max_power = 25 },
	{ .hw_value = 120, .center_freq = 5600, .max_power = 25 },
	{ .hw_value = 124, .center_freq = 5620, .max_power = 25 },
	{ .hw_value = 128, .center_freq = 5640, .max_power = 25 },
	{ .hw_value = 132, .center_freq = 5660, .max_power = 25 },
	{ .hw_value = 136, .center_freq = 5680, .max_power = 25 },
	{ .hw_value = 140, .center_freq = 5700, .max_power = 25 },
	{ .hw_value = 149, .center_freq = 5745, .max_power = 25 },
	{ .hw_value = 153, .center_freq = 5765, .max_power = 25 },
	{ .hw_value = 157, .center_freq = 5785, .max_power = 25 },
	{ .hw_value = 161, .center_freq = 5805, .max_power = 25 },
	{ .hw_value = 165, .center_freq = 5825, .max_power = 25 },
3879 3880
};

3881
/* mapping to indexes for wl1271_rates_5ghz */
3882
static const u8 wl1271_rate_to_idx_5ghz[] = {
3883
	/* MCS rates are used only with 11n */
3884 3885 3886 3887 3888 3889 3890 3891
	7,                            /* CONF_HW_RXTX_RATE_MCS7 */
	6,                            /* CONF_HW_RXTX_RATE_MCS6 */
	5,                            /* CONF_HW_RXTX_RATE_MCS5 */
	4,                            /* CONF_HW_RXTX_RATE_MCS4 */
	3,                            /* CONF_HW_RXTX_RATE_MCS3 */
	2,                            /* CONF_HW_RXTX_RATE_MCS2 */
	1,                            /* CONF_HW_RXTX_RATE_MCS1 */
	0,                            /* CONF_HW_RXTX_RATE_MCS0 */
3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909

	7,                             /* CONF_HW_RXTX_RATE_54   */
	6,                             /* CONF_HW_RXTX_RATE_48   */
	5,                             /* CONF_HW_RXTX_RATE_36   */
	4,                             /* CONF_HW_RXTX_RATE_24   */

	/* TI-specific rate */
	CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22   */

	3,                             /* CONF_HW_RXTX_RATE_18   */
	2,                             /* CONF_HW_RXTX_RATE_12   */
	CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11   */
	1,                             /* CONF_HW_RXTX_RATE_9    */
	0,                             /* CONF_HW_RXTX_RATE_6    */
	CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5  */
	CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2    */
	CONF_HW_RXTX_RATE_UNSUPPORTED  /* CONF_HW_RXTX_RATE_1    */
};
3910 3911 3912 3913 3914 3915

static struct ieee80211_supported_band wl1271_band_5ghz = {
	.channels = wl1271_channels_5ghz,
	.n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
	.bitrates = wl1271_rates_5ghz,
	.n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
S
Shahar Levi 已提交
3916
	.ht_cap	= WL12XX_HT_CAP,
3917 3918
};

3919
static const u8 *wl1271_band_rate_to_idx[] = {
3920 3921 3922 3923
	[IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
	[IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
};

L
Luciano Coelho 已提交
3924 3925 3926 3927 3928
static const struct ieee80211_ops wl1271_ops = {
	.start = wl1271_op_start,
	.stop = wl1271_op_stop,
	.add_interface = wl1271_op_add_interface,
	.remove_interface = wl1271_op_remove_interface,
3929
#ifdef CONFIG_PM
3930 3931
	.suspend = wl1271_op_suspend,
	.resume = wl1271_op_resume,
3932
#endif
L
Luciano Coelho 已提交
3933
	.config = wl1271_op_config,
3934
	.prepare_multicast = wl1271_op_prepare_multicast,
L
Luciano Coelho 已提交
3935 3936 3937 3938
	.configure_filter = wl1271_op_configure_filter,
	.tx = wl1271_op_tx,
	.set_key = wl1271_op_set_key,
	.hw_scan = wl1271_op_hw_scan,
3939
	.cancel_hw_scan = wl1271_op_cancel_hw_scan,
3940 3941
	.sched_scan_start = wl1271_op_sched_scan_start,
	.sched_scan_stop = wl1271_op_sched_scan_stop,
L
Luciano Coelho 已提交
3942
	.bss_info_changed = wl1271_op_bss_info_changed,
3943
	.set_frag_threshold = wl1271_op_set_frag_threshold,
L
Luciano Coelho 已提交
3944
	.set_rts_threshold = wl1271_op_set_rts_threshold,
K
Kalle Valo 已提交
3945
	.conf_tx = wl1271_op_conf_tx,
J
Juuso Oikarinen 已提交
3946
	.get_tsf = wl1271_op_get_tsf,
3947
	.get_survey = wl1271_op_get_survey,
3948 3949
	.sta_add = wl1271_op_sta_add,
	.sta_remove = wl1271_op_sta_remove,
L
Levi, Shahar 已提交
3950
	.ampdu_action = wl1271_op_ampdu_action,
3951
	.tx_frames_pending = wl1271_tx_frames_pending,
K
Kalle Valo 已提交
3952
	CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
L
Luciano Coelho 已提交
3953 3954
};

3955

3956
u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
3957 3958 3959
{
	u8 idx;

3960
	BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
3961 3962 3963 3964 3965 3966

	if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
		wl1271_error("Illegal RX rate from HW: %d", rate);
		return 0;
	}

3967
	idx = wl1271_band_rate_to_idx[band][rate];
3968 3969 3970 3971 3972 3973 3974 3975
	if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
		wl1271_error("Unsupported RX rate from HW: %d", rate);
		return 0;
	}

	return idx;
}

3976 3977 3978 3979 3980 3981 3982
static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
					       struct device_attribute *attr,
					       char *buf)
{
	struct wl1271 *wl = dev_get_drvdata(dev);
	ssize_t len;

3983
	len = PAGE_SIZE;
3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001

	mutex_lock(&wl->mutex);
	len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
		       wl->sg_enabled);
	mutex_unlock(&wl->mutex);

	return len;

}

static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
						struct device_attribute *attr,
						const char *buf, size_t count)
{
	struct wl1271 *wl = dev_get_drvdata(dev);
	unsigned long res;
	int ret;

L
Luciano Coelho 已提交
4002
	ret = kstrtoul(buf, 10, &res);
4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019
	if (ret < 0) {
		wl1271_warning("incorrect value written to bt_coex_mode");
		return count;
	}

	mutex_lock(&wl->mutex);

	res = !!res;

	if (res == wl->sg_enabled)
		goto out;

	wl->sg_enabled = res;

	if (wl->state == WL1271_STATE_OFF)
		goto out;

4020
	ret = wl1271_ps_elp_wakeup(wl);
4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035
	if (ret < 0)
		goto out;

	wl1271_acx_sg_enable(wl, wl->sg_enabled);
	wl1271_ps_elp_sleep(wl);

 out:
	mutex_unlock(&wl->mutex);
	return count;
}

static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
		   wl1271_sysfs_show_bt_coex_state,
		   wl1271_sysfs_store_bt_coex_state);

4036 4037 4038 4039 4040 4041 4042
static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
					   struct device_attribute *attr,
					   char *buf)
{
	struct wl1271 *wl = dev_get_drvdata(dev);
	ssize_t len;

4043
	len = PAGE_SIZE;
4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054

	mutex_lock(&wl->mutex);
	if (wl->hw_pg_ver >= 0)
		len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
	else
		len = snprintf(buf, len, "n/a\n");
	mutex_unlock(&wl->mutex);

	return len;
}

4055
static DEVICE_ATTR(hw_pg_ver, S_IRUGO,
4056 4057
		   wl1271_sysfs_show_hw_pg_ver, NULL);

4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120
static ssize_t wl1271_sysfs_read_fwlog(struct file *filp, struct kobject *kobj,
				       struct bin_attribute *bin_attr,
				       char *buffer, loff_t pos, size_t count)
{
	struct device *dev = container_of(kobj, struct device, kobj);
	struct wl1271 *wl = dev_get_drvdata(dev);
	ssize_t len;
	int ret;

	ret = mutex_lock_interruptible(&wl->mutex);
	if (ret < 0)
		return -ERESTARTSYS;

	/* Let only one thread read the log at a time, blocking others */
	while (wl->fwlog_size == 0) {
		DEFINE_WAIT(wait);

		prepare_to_wait_exclusive(&wl->fwlog_waitq,
					  &wait,
					  TASK_INTERRUPTIBLE);

		if (wl->fwlog_size != 0) {
			finish_wait(&wl->fwlog_waitq, &wait);
			break;
		}

		mutex_unlock(&wl->mutex);

		schedule();
		finish_wait(&wl->fwlog_waitq, &wait);

		if (signal_pending(current))
			return -ERESTARTSYS;

		ret = mutex_lock_interruptible(&wl->mutex);
		if (ret < 0)
			return -ERESTARTSYS;
	}

	/* Check if the fwlog is still valid */
	if (wl->fwlog_size < 0) {
		mutex_unlock(&wl->mutex);
		return 0;
	}

	/* Seeking is not supported - old logs are not kept. Disregard pos. */
	len = min(count, (size_t)wl->fwlog_size);
	wl->fwlog_size -= len;
	memcpy(buffer, wl->fwlog, len);

	/* Make room for new messages */
	memmove(wl->fwlog, wl->fwlog + len, wl->fwlog_size);

	mutex_unlock(&wl->mutex);

	return len;
}

static struct bin_attribute fwlog_attr = {
	.attr = {.name = "fwlog", .mode = S_IRUSR},
	.read = wl1271_sysfs_read_fwlog,
};

4121
int wl1271_register_hw(struct wl1271 *wl)
L
Luciano Coelho 已提交
4122 4123 4124 4125 4126 4127
{
	int ret;

	if (wl->mac80211_registered)
		return 0;

4128 4129
	ret = wl1271_fetch_nvs(wl);
	if (ret == 0) {
4130 4131 4132 4133 4134
		/* NOTE: The wl->nvs->nvs element must be first, in
		 * order to simplify the casting, we assume it is at
		 * the beginning of the wl->nvs structure.
		 */
		u8 *nvs_ptr = (u8 *)wl->nvs;
4135 4136 4137 4138 4139 4140 4141 4142 4143

		wl->mac_addr[0] = nvs_ptr[11];
		wl->mac_addr[1] = nvs_ptr[10];
		wl->mac_addr[2] = nvs_ptr[6];
		wl->mac_addr[3] = nvs_ptr[5];
		wl->mac_addr[4] = nvs_ptr[4];
		wl->mac_addr[5] = nvs_ptr[3];
	}

L
Luciano Coelho 已提交
4144 4145 4146 4147 4148 4149 4150 4151 4152 4153
	SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);

	ret = ieee80211_register_hw(wl->hw);
	if (ret < 0) {
		wl1271_error("unable to register mac80211 hw: %d", ret);
		return ret;
	}

	wl->mac80211_registered = true;

4154 4155
	wl1271_debugfs_init(wl);

4156 4157
	register_netdevice_notifier(&wl1271_dev_notifier);

L
Luciano Coelho 已提交
4158 4159 4160 4161
	wl1271_notice("loaded");

	return 0;
}
4162
EXPORT_SYMBOL_GPL(wl1271_register_hw);
L
Luciano Coelho 已提交
4163

4164 4165
void wl1271_unregister_hw(struct wl1271 *wl)
{
4166 4167 4168
	if (wl->state == WL1271_STATE_PLT)
		__wl1271_plt_stop(wl);

4169
	unregister_netdevice_notifier(&wl1271_dev_notifier);
4170 4171 4172 4173 4174 4175
	ieee80211_unregister_hw(wl->hw);
	wl->mac80211_registered = false;

}
EXPORT_SYMBOL_GPL(wl1271_unregister_hw);

4176
int wl1271_init_ieee80211(struct wl1271 *wl)
L
Luciano Coelho 已提交
4177
{
4178 4179 4180 4181 4182 4183 4184 4185
	static const u32 cipher_suites[] = {
		WLAN_CIPHER_SUITE_WEP40,
		WLAN_CIPHER_SUITE_WEP104,
		WLAN_CIPHER_SUITE_TKIP,
		WLAN_CIPHER_SUITE_CCMP,
		WL1271_CIPHER_SUITE_GEM,
	};

4186 4187 4188
	/* The tx descriptor buffer and the TKIP space. */
	wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
		sizeof(struct wl1271_tx_hw_descr);
L
Luciano Coelho 已提交
4189 4190 4191 4192

	/* unit us */
	/* FIXME: find a proper value */
	wl->hw->channel_change_time = 10000;
4193
	wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
L
Luciano Coelho 已提交
4194 4195

	wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
4196
		IEEE80211_HW_BEACON_FILTER |
4197
		IEEE80211_HW_SUPPORTS_PS |
K
Kalle Valo 已提交
4198
		IEEE80211_HW_SUPPORTS_UAPSD |
4199
		IEEE80211_HW_HAS_RATE_CONTROL |
4200
		IEEE80211_HW_CONNECTION_MONITOR |
4201
		IEEE80211_HW_SUPPORTS_CQM_RSSI |
4202
		IEEE80211_HW_REPORTS_TX_ACK_STATUS |
4203
		IEEE80211_HW_SPECTRUM_MGMT |
4204
		IEEE80211_HW_AP_LINK_PS;
L
Luciano Coelho 已提交
4205

4206 4207 4208
	wl->hw->wiphy->cipher_suites = cipher_suites;
	wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);

4209
	wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
A
Arik Nemtsov 已提交
4210
		BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP);
L
Luciano Coelho 已提交
4211
	wl->hw->wiphy->max_scan_ssids = 1;
4212 4213 4214 4215 4216 4217 4218
	/*
	 * Maximum length of elements in scanning probe request templates
	 * should be the maximum length possible for a template, without
	 * the IEEE80211 header of the template
	 */
	wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
			sizeof(struct ieee80211_header);
4219

4220 4221 4222 4223
	/* make sure all our channels fit in the scanned_ch bitmask */
	BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) +
		     ARRAY_SIZE(wl1271_channels_5ghz) >
		     WL1271_MAX_CHANNELS);
4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236
	/*
	 * We keep local copies of the band structs because we need to
	 * modify them on a per-device basis.
	 */
	memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
	       sizeof(wl1271_band_2ghz));
	memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
	       sizeof(wl1271_band_5ghz));

	wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
		&wl->bands[IEEE80211_BAND_2GHZ];
	wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
		&wl->bands[IEEE80211_BAND_5GHZ];
4237

K
Kalle Valo 已提交
4238
	wl->hw->queues = 4;
J
Juuso Oikarinen 已提交
4239
	wl->hw->max_rates = 1;
K
Kalle Valo 已提交
4240

4241 4242
	wl->hw->wiphy->reg_notifier = wl1271_reg_notify;

4243
	SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
L
Luciano Coelho 已提交
4244

4245 4246
	wl->hw->sta_data_size = sizeof(struct wl1271_station);

4247 4248
	wl->hw->max_rx_aggregation_subframes = 8;

L
Luciano Coelho 已提交
4249 4250
	return 0;
}
4251
EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
L
Luciano Coelho 已提交
4252 4253

#define WL1271_DEFAULT_CHANNEL 0
4254

4255
struct ieee80211_hw *wl1271_alloc_hw(void)
L
Luciano Coelho 已提交
4256 4257
{
	struct ieee80211_hw *hw;
4258
	struct platform_device *plat_dev = NULL;
L
Luciano Coelho 已提交
4259
	struct wl1271 *wl;
4260
	int i, j, ret;
4261
	unsigned int order;
L
Luciano Coelho 已提交
4262 4263 4264 4265

	hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
	if (!hw) {
		wl1271_error("could not alloc ieee80211_hw");
4266
		ret = -ENOMEM;
4267 4268 4269
		goto err_hw_alloc;
	}

4270
	plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
4271 4272 4273 4274
	if (!plat_dev) {
		wl1271_error("could not allocate platform_device");
		ret = -ENOMEM;
		goto err_plat_alloc;
L
Luciano Coelho 已提交
4275 4276 4277 4278 4279
	}

	wl = hw->priv;
	memset(wl, 0, sizeof(*wl));

4280 4281
	INIT_LIST_HEAD(&wl->list);

L
Luciano Coelho 已提交
4282
	wl->hw = hw;
4283
	wl->plat_dev = plat_dev;
L
Luciano Coelho 已提交
4284

4285 4286
	for (i = 0; i < NUM_TX_QUEUES; i++)
		skb_queue_head_init(&wl->tx_queue[i]);
L
Luciano Coelho 已提交
4287

4288 4289 4290 4291
	for (i = 0; i < NUM_TX_QUEUES; i++)
		for (j = 0; j < AP_MAX_LINKS; j++)
			skb_queue_head_init(&wl->links[j].tx_queue[i]);

4292 4293 4294
	skb_queue_head_init(&wl->deferred_rx_queue);
	skb_queue_head_init(&wl->deferred_tx_queue);

4295
	INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
4296
	INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
4297
	INIT_WORK(&wl->netstack_work, wl1271_netstack_work);
4298 4299 4300
	INIT_WORK(&wl->tx_work, wl1271_tx_work);
	INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
	INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
4301 4302 4303 4304 4305
	INIT_WORK(&wl->rx_streaming_enable_work,
		  wl1271_rx_streaming_enable_work);
	INIT_WORK(&wl->rx_streaming_disable_work,
		  wl1271_rx_streaming_disable_work);

4306 4307 4308 4309 4310 4311
	wl->freezable_wq = create_freezable_workqueue("wl12xx_wq");
	if (!wl->freezable_wq) {
		ret = -ENOMEM;
		goto err_hw;
	}

L
Luciano Coelho 已提交
4312
	wl->channel = WL1271_DEFAULT_CHANNEL;
4313
	wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
L
Luciano Coelho 已提交
4314 4315
	wl->default_key = 0;
	wl->rx_counter = 0;
4316
	wl->psm_entry_retry = 0;
L
Luciano Coelho 已提交
4317
	wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
4318
	wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
4319
	wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
4320
	wl->rate_set = CONF_TX_RATE_MASK_BASIC;
4321
	wl->band = IEEE80211_BAND_2GHZ;
4322
	wl->vif = NULL;
4323
	wl->flags = 0;
4324
	wl->sg_enabled = true;
4325
	wl->hw_pg_ver = -1;
4326 4327
	wl->bss_type = MAX_BSS_TYPE;
	wl->set_bss_type = MAX_BSS_TYPE;
4328
	wl->last_tx_hlid = 0;
4329 4330
	wl->ap_ps_map = 0;
	wl->ap_fw_ps_map = 0;
4331
	wl->quirks = 0;
4332
	wl->platform_quirks = 0;
4333
	wl->sched_scanning = false;
4334 4335 4336
	wl->tx_security_seq = 0;
	wl->tx_security_last_seq_lsb = 0;

4337 4338
	setup_timer(&wl->rx_streaming_timer, wl1271_rx_streaming_timer,
		    (unsigned long) wl);
4339 4340
	wl->fwlog_size = 0;
	init_waitqueue_head(&wl->fwlog_waitq);
L
Luciano Coelho 已提交
4341

4342
	memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
J
Juuso Oikarinen 已提交
4343
	for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
L
Luciano Coelho 已提交
4344 4345 4346 4347 4348 4349 4350
		wl->tx_frames[i] = NULL;

	spin_lock_init(&wl->wl_lock);

	wl->state = WL1271_STATE_OFF;
	mutex_init(&wl->mutex);

4351 4352 4353
	/* Apply default driver configuration. */
	wl1271_conf_init(wl);

4354 4355 4356 4357
	order = get_order(WL1271_AGGR_BUFFER_SIZE);
	wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
	if (!wl->aggr_buf) {
		ret = -ENOMEM;
4358
		goto err_wq;
4359 4360
	}

4361 4362 4363 4364 4365 4366
	wl->dummy_packet = wl12xx_alloc_dummy_packet(wl);
	if (!wl->dummy_packet) {
		ret = -ENOMEM;
		goto err_aggr;
	}

4367 4368 4369 4370 4371 4372 4373
	/* Allocate one page for the FW log */
	wl->fwlog = (u8 *)get_zeroed_page(GFP_KERNEL);
	if (!wl->fwlog) {
		ret = -ENOMEM;
		goto err_dummy_packet;
	}

4374
	/* Register platform device */
4375
	ret = platform_device_register(wl->plat_dev);
4376 4377
	if (ret) {
		wl1271_error("couldn't register platform device");
4378
		goto err_fwlog;
4379
	}
4380
	dev_set_drvdata(&wl->plat_dev->dev, wl);
4381

4382
	/* Create sysfs file to control bt coex state */
4383
	ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
4384 4385 4386 4387
	if (ret < 0) {
		wl1271_error("failed to create sysfs file bt_coex_state");
		goto err_platform;
	}
4388

4389 4390 4391 4392 4393 4394 4395
	/* Create sysfs file to get HW PG version */
	ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
	if (ret < 0) {
		wl1271_error("failed to create sysfs file hw_pg_ver");
		goto err_bt_coex_state;
	}

4396 4397 4398 4399 4400 4401 4402
	/* Create sysfs file for the FW log */
	ret = device_create_bin_file(&wl->plat_dev->dev, &fwlog_attr);
	if (ret < 0) {
		wl1271_error("failed to create sysfs file fwlog");
		goto err_hw_pg_ver;
	}

4403
	return hw;
4404

4405 4406 4407
err_hw_pg_ver:
	device_remove_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);

4408 4409 4410
err_bt_coex_state:
	device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);

4411
err_platform:
4412
	platform_device_unregister(wl->plat_dev);
4413

4414 4415 4416
err_fwlog:
	free_page((unsigned long)wl->fwlog);

4417 4418 4419
err_dummy_packet:
	dev_kfree_skb(wl->dummy_packet);

4420 4421 4422
err_aggr:
	free_pages((unsigned long)wl->aggr_buf, order);

4423 4424 4425
err_wq:
	destroy_workqueue(wl->freezable_wq);

4426
err_hw:
4427 4428 4429 4430 4431 4432 4433
	wl1271_debugfs_exit(wl);
	kfree(plat_dev);

err_plat_alloc:
	ieee80211_free_hw(hw);

err_hw_alloc:
4434 4435

	return ERR_PTR(ret);
4436
}
4437
EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
4438 4439 4440

int wl1271_free_hw(struct wl1271 *wl)
{
4441 4442 4443 4444 4445 4446 4447
	/* Unblock any fwlog readers */
	mutex_lock(&wl->mutex);
	wl->fwlog_size = -1;
	wake_up_interruptible_all(&wl->fwlog_waitq);
	mutex_unlock(&wl->mutex);

	device_remove_bin_file(&wl->plat_dev->dev, &fwlog_attr);
4448 4449 4450 4451

	device_remove_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);

	device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
4452
	platform_device_unregister(wl->plat_dev);
4453
	free_page((unsigned long)wl->fwlog);
4454
	dev_kfree_skb(wl->dummy_packet);
4455 4456
	free_pages((unsigned long)wl->aggr_buf,
			get_order(WL1271_AGGR_BUFFER_SIZE));
4457
	kfree(wl->plat_dev);
4458 4459 4460 4461 4462 4463 4464 4465 4466 4467

	wl1271_debugfs_exit(wl);

	vfree(wl->fw);
	wl->fw = NULL;
	kfree(wl->nvs);
	wl->nvs = NULL;

	kfree(wl->fw_status);
	kfree(wl->tx_res_if);
4468
	destroy_workqueue(wl->freezable_wq);
4469 4470 4471 4472 4473

	ieee80211_free_hw(wl->hw);

	return 0;
}
4474 4475
EXPORT_SYMBOL_GPL(wl1271_free_hw);

4476
u32 wl12xx_debug_level = DEBUG_NONE;
4477
EXPORT_SYMBOL_GPL(wl12xx_debug_level);
4478
module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
4479 4480
MODULE_PARM_DESC(debug_level, "wl12xx debugging level");

4481 4482 4483 4484
module_param_named(fwlog, fwlog_param, charp, 0);
MODULE_PARM_DESC(keymap,
		 "FW logger options: continuous, ondemand, dbgpins or disable");

4485
MODULE_LICENSE("GPL");
4486
MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
4487
MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");