main.c 103.5 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>
L
Luciano Coelho 已提交
34

S
Shahar Levi 已提交
35
#include "wl12xx.h"
L
Luciano Coelho 已提交
36
#include "wl12xx_80211.h"
S
Shahar Levi 已提交
37 38 39 40 41 42 43 44 45 46 47 48
#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 已提交
49

50 51
#define WL1271_BOOT_RETRIES 3

52 53
static struct conf_drv_settings default_conf = {
	.sg = {
A
Arik Nemtsov 已提交
54
		.sta_params = {
55 56 57
			[CONF_SG_BT_PER_THRESHOLD]                  = 7500,
			[CONF_SG_HV3_MAX_OVERRIDE]                  = 0,
			[CONF_SG_BT_NFS_SAMPLE_INTERVAL]            = 400,
58
			[CONF_SG_BT_LOAD_RATIO]                     = 200,
59
			[CONF_SG_AUTO_PS_MODE]                      = 1,
60 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
			[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 已提交
104 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
		.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,
		},
159
		.state = CONF_SG_PROTECTIVE,
160 161 162 163 164 165
	},
	.rx = {
		.rx_msdu_life_time           = 512000,
		.packet_detection_threshold  = 0,
		.ps_poll_timeout             = 15,
		.upsd_timeout                = 15,
166
		.rts_threshold               = IEEE80211_MAX_RTS_THRESHOLD,
167 168 169 170
		.rx_cca_threshold            = 0,
		.irq_blk_threshold           = 0xFFFF,
		.irq_pkt_threshold           = 0,
		.irq_timeout                 = 600,
171 172 173 174
		.queue_type                  = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
	},
	.tx = {
		.tx_energy_detection         = 0,
175
		.sta_rc_conf                 = {
176
			.enabled_rates       = 0,
177 178
			.short_retry_limit   = 10,
			.long_retry_limit    = 10,
179
			.aflags              = 0,
180
		},
181 182
		.ac_conf_count               = 4,
		.ac_conf                     = {
183
			[CONF_TX_AC_BE] = {
184 185 186 187 188
				.ac          = CONF_TX_AC_BE,
				.cw_min      = 15,
				.cw_max      = 63,
				.aifsn       = 3,
				.tx_op_limit = 0,
189
			},
190
			[CONF_TX_AC_BK] = {
191 192 193 194 195
				.ac          = CONF_TX_AC_BK,
				.cw_min      = 15,
				.cw_max      = 63,
				.aifsn       = 7,
				.tx_op_limit = 0,
196
			},
197
			[CONF_TX_AC_VI] = {
198 199 200 201 202 203
				.ac          = CONF_TX_AC_VI,
				.cw_min      = 15,
				.cw_max      = 63,
				.aifsn       = CONF_TX_AIFS_PIFS,
				.tx_op_limit = 3008,
			},
204
			[CONF_TX_AC_VO] = {
205 206 207 208 209
				.ac          = CONF_TX_AC_VO,
				.cw_min      = 15,
				.cw_max      = 63,
				.aifsn       = CONF_TX_AIFS_PIFS,
				.tx_op_limit = 1504,
210
			},
211
		},
212
		.ap_max_tx_retries = 100,
213
		.tid_conf_count = 4,
214
		.tid_conf = {
215 216 217
			[CONF_TX_AC_BE] = {
				.queue_id    = CONF_TX_AC_BE,
				.channel_type = CONF_CHANNEL_TYPE_EDCF,
218 219 220 221
				.tsid        = CONF_TX_AC_BE,
				.ps_scheme   = CONF_PS_SCHEME_LEGACY,
				.ack_policy  = CONF_ACK_POLICY_LEGACY,
				.apsd_conf   = {0, 0},
222
			},
223 224 225 226
			[CONF_TX_AC_BK] = {
				.queue_id    = CONF_TX_AC_BK,
				.channel_type = CONF_CHANNEL_TYPE_EDCF,
				.tsid        = CONF_TX_AC_BK,
227 228 229 230
				.ps_scheme   = CONF_PS_SCHEME_LEGACY,
				.ack_policy  = CONF_ACK_POLICY_LEGACY,
				.apsd_conf   = {0, 0},
			},
231 232 233 234
			[CONF_TX_AC_VI] = {
				.queue_id    = CONF_TX_AC_VI,
				.channel_type = CONF_CHANNEL_TYPE_EDCF,
				.tsid        = CONF_TX_AC_VI,
235 236 237 238
				.ps_scheme   = CONF_PS_SCHEME_LEGACY,
				.ack_policy  = CONF_ACK_POLICY_LEGACY,
				.apsd_conf   = {0, 0},
			},
239 240 241 242
			[CONF_TX_AC_VO] = {
				.queue_id    = CONF_TX_AC_VO,
				.channel_type = CONF_CHANNEL_TYPE_EDCF,
				.tsid        = CONF_TX_AC_VO,
243 244 245 246 247 248
				.ps_scheme   = CONF_PS_SCHEME_LEGACY,
				.ack_policy  = CONF_ACK_POLICY_LEGACY,
				.apsd_conf   = {0, 0},
			},
		},
		.frag_threshold              = IEEE80211_MAX_FRAG_THRESHOLD,
249
		.tx_compl_timeout            = 700,
250 251 252
		.tx_compl_threshold          = 4,
		.basic_rate                  = CONF_HW_BIT_RATE_1MBPS,
		.basic_rate_5                = CONF_HW_BIT_RATE_6MBPS,
253 254
		.tmpl_short_retry_limit      = 10,
		.tmpl_long_retry_limit       = 10,
255 256 257
	},
	.conn = {
		.wake_up_event               = CONF_WAKE_UP_EVENT_DTIM,
258
		.listen_interval             = 1,
259
		.bcn_filt_mode               = CONF_BCN_FILT_MODE_ENABLED,
260
		.bcn_filt_ie_count           = 2,
261 262 263 264
		.bcn_filt_ie = {
			[0] = {
				.ie          = WLAN_EID_CHANNEL_SWITCH,
				.rule        = CONF_BCN_RULE_PASS_ON_APPEARANCE,
265 266 267 268 269
			},
			[1] = {
				.ie          = WLAN_EID_HT_INFORMATION,
				.rule        = CONF_BCN_RULE_PASS_ON_CHANGE,
			},
270
		},
271
		.synch_fail_thold            = 10,
272 273 274 275
		.bss_lose_timeout            = 100,
		.beacon_rx_timeout           = 10000,
		.broadcast_timeout           = 20000,
		.rx_broadcast_in_ps          = 1,
276 277
		.ps_poll_threshold           = 10,
		.ps_poll_recovery_period     = 700,
278
		.bet_enable                  = CONF_BET_MODE_ENABLE,
279
		.bet_max_consecutive         = 50,
280
		.psm_entry_retries           = 5,
281
		.psm_exit_retries            = 16,
282 283
		.psm_entry_nullfunc_retries  = 3,
		.psm_entry_hangover_period   = 1,
284 285
		.keep_alive_interval         = 55000,
		.max_listen_interval         = 20,
286
	},
287 288 289
	.itrim = {
		.enable = false,
		.timeout = 50000,
290 291 292 293
	},
	.pm_config = {
		.host_clk_settling_time = 5000,
		.host_fast_wakeup_support = false
294 295 296 297 298 299
	},
	.roam_trigger = {
		.trigger_pacing               = 1,
		.avg_weight_rssi_beacon       = 20,
		.avg_weight_rssi_data         = 10,
		.avg_weight_snr_beacon        = 20,
L
Levi, Shahar 已提交
300
		.avg_weight_snr_data          = 10,
J
Juuso Oikarinen 已提交
301 302 303 304
	},
	.scan = {
		.min_dwell_time_active        = 7500,
		.max_dwell_time_active        = 30000,
305 306
		.min_dwell_time_passive       = 100000,
		.max_dwell_time_passive       = 100000,
J
Juuso Oikarinen 已提交
307 308
		.num_probe_reqs               = 2,
	},
309 310 311 312 313
	.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,
314
		.dwell_time_dfs        = 150,
315 316 317 318
		.num_probe_reqs        = 2,
		.rssi_threshold        = -90,
		.snr_threshold         = 0,
	},
319 320 321 322 323 324 325 326 327 328
	.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 已提交
329 330 331 332
	.ht = {
		.tx_ba_win_size = 64,
		.inactivity_timeout = 10000,
	},
333
	.mem_wl127x = {
334 335 336 337
		.num_stations                 = 1,
		.ssid_profiles                = 1,
		.rx_block_num                 = 70,
		.tx_min_block_num             = 40,
338
		.dynamic_memory               = 1,
339
		.min_req_tx_blocks            = 100,
340 341
		.min_req_rx_blocks            = 22,
		.tx_min                       = 27,
342 343 344 345 346 347 348 349 350 351 352
	},
	.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 已提交
353 354 355 356 357 358 359 360 361 362 363 364
	.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 */
	},
365
	.hci_io_ds = HCI_IO_DS_6MA,
366 367
};

368 369
static void __wl1271_op_remove_interface(struct wl1271 *wl,
					 bool reset_tx_queues);
370
static void wl1271_free_ap_keys(struct wl1271 *wl);
371 372


373 374 375 376 377 378 379 380 381 382 383 384 385 386 387
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,
	},
};

388
static DEFINE_MUTEX(wl_list_mutex);
389 390
static LIST_HEAD(wl_list);

391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418
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;
419
	mutex_lock(&wl_list_mutex);
420 421 422 423
	list_for_each_entry(wl, &wl_list, list) {
		if (wl == wl_temp)
			break;
	}
424
	mutex_unlock(&wl_list_mutex);
425 426 427 428 429 430 431 432 433 434 435
	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;

436
	ret = wl1271_ps_elp_wakeup(wl);
437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453
	if (ret < 0)
		goto out;

	if ((dev->operstate == IF_OPER_UP) &&
	    !test_and_set_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags)) {
		wl1271_cmd_set_sta_state(wl);
		wl1271_info("Association completed.");
	}

	wl1271_ps_elp_sleep(wl);

out:
	mutex_unlock(&wl->mutex);

	return NOTIFY_OK;
}

454
static int wl1271_reg_notify(struct wiphy *wiphy,
455 456
			     struct regulatory_request *request)
{
457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475
	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;
}

476 477
static void wl1271_conf_init(struct wl1271 *wl)
{
478 479 480 481 482 483 484 485 486 487 488 489

	/*
	 * 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 */
490
	memcpy(&wl->conf, &default_conf, sizeof(default_conf));
491 492 493
}


L
Luciano Coelho 已提交
494 495
static int wl1271_plt_init(struct wl1271 *wl)
{
496 497 498
	struct conf_tx_ac_category *conf_ac;
	struct conf_tx_tid *conf_tid;
	int ret, i;
L
Luciano Coelho 已提交
499

500 501 502 503
	if (wl->chip.id == CHIP_ID_1283_PG20)
		ret = wl128x_cmd_general_parms(wl);
	else
		ret = wl1271_cmd_general_parms(wl);
504
	if (ret < 0)
505 506
		return ret;

507 508 509 510
	if (wl->chip.id == CHIP_ID_1283_PG20)
		ret = wl128x_cmd_radio_parms(wl);
	else
		ret = wl1271_cmd_radio_parms(wl);
511
	if (ret < 0)
512 513
		return ret;

514 515 516 517 518
	if (wl->chip.id != CHIP_ID_1283_PG20) {
		ret = wl1271_cmd_ext_radio_parms(wl);
		if (ret < 0)
			return ret;
	}
519 520 521
	if (ret < 0)
		return ret;

522 523 524 525 526
	/* Chip-specific initializations */
	ret = wl1271_chip_specific_init(wl);
	if (ret < 0)
		return ret;

A
Arik Nemtsov 已提交
527
	ret = wl1271_sta_init_templates_config(wl);
528 529 530
	if (ret < 0)
		return ret;

L
Luciano Coelho 已提交
531 532 533 534
	ret = wl1271_acx_init_mem_config(wl);
	if (ret < 0)
		return ret;

535 536 537 538 539 540 541 542 543 544
	/* 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 */
545
	ret = wl1271_acx_conn_monit_params(wl, false);
546 547 548 549 550 551 552 553
	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 已提交
554 555 556 557 558
	/* FM WLAN coexistence */
	ret = wl1271_acx_fm_coex(wl);
	if (ret < 0)
		goto out_free_memmap;

559 560 561 562 563
	/* Energy detection */
	ret = wl1271_init_energy_detection(wl);
	if (ret < 0)
		goto out_free_memmap;

564 565 566 567
	ret = wl1271_acx_sta_mem_cfg(wl);
	if (ret < 0)
		goto out_free_memmap;

568
	/* Default fragmentation threshold */
569
	ret = wl1271_acx_frag_threshold(wl, wl->conf.tx.frag_threshold);
570 571 572
	if (ret < 0)
		goto out_free_memmap;

573 574
	/* Default TID/AC configuration */
	BUG_ON(wl->conf.tx.tid_conf_count != wl->conf.tx.ac_conf_count);
575
	for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
576 577 578 579 580 581 582
		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;

583 584 585 586 587 588 589 590 591 592 593 594 595
		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 */
596
	ret = wl1271_cmd_data_path(wl, 1);
L
Luciano Coelho 已提交
597
	if (ret < 0)
598 599 600 601 602 603 604 605 606 607 608
		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 已提交
609 610

	return 0;
611 612 613 614 615 616

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

	return ret;
L
Luciano Coelho 已提交
617 618
}

619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669
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);
	}
}

670
static void wl1271_fw_status(struct wl1271 *wl,
671
			     struct wl1271_fw_full_status *full_status)
L
Luciano Coelho 已提交
672
{
673
	struct wl1271_fw_common_status *status = &full_status->common;
674
	struct timespec ts;
675
	u32 old_tx_blk_count = wl->tx_blocks_available;
676
	u32 freed_blocks = 0;
L
Luciano Coelho 已提交
677 678
	int i;

679
	if (wl->bss_type == BSS_TYPE_AP_BSS) {
680 681
		wl1271_raw_read(wl, FW_STATUS_ADDR, status,
				sizeof(struct wl1271_fw_ap_status), false);
682
	} else {
683 684
		wl1271_raw_read(wl, FW_STATUS_ADDR, status,
				sizeof(struct wl1271_fw_sta_status), false);
685 686
	}

L
Luciano Coelho 已提交
687 688 689 690 691 692 693 694 695
	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++) {
696 697
		freed_blocks += le32_to_cpu(status->tx_released_blks[i]) -
				wl->tx_blocks_freed[i];
L
Luciano Coelho 已提交
698 699 700

		wl->tx_blocks_freed[i] =
			le32_to_cpu(status->tx_released_blks[i]);
701 702
	}

703 704 705 706 707 708 709 710
	wl->tx_allocated_blocks -= freed_blocks;

	if (wl->bss_type == BSS_TYPE_AP_BSS) {
		/* Update num of allocated TX blocks per link and ps status */
		wl1271_irq_update_links_status(wl, &full_status->ap);
		wl->tx_blocks_available += freed_blocks;
	} else {
		int avail = full_status->sta.tx_total - wl->tx_allocated_blocks;
711

712 713 714 715 716 717 718 719 720 721
		/*
		 * 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 已提交
722 723
	}

I
Ido Yariv 已提交
724
	/* if more blocks are available now, tx work can be scheduled */
725
	if (wl->tx_blocks_available > old_tx_blk_count)
I
Ido Yariv 已提交
726
		clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
L
Luciano Coelho 已提交
727 728

	/* update the host-chipset time offset */
729 730 731
	getnstimeofday(&ts);
	wl->time_offset = (timespec_to_ns(&ts) >> 10) -
		(s64)le32_to_cpu(status->fw_localtime);
L
Luciano Coelho 已提交
732 733
}

734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755
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)))
		ieee80211_tx_status(wl->hw, skb);
}

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));
}
756

757 758 759
#define WL1271_IRQ_MAX_LOOPS 256

irqreturn_t wl1271_irq(int irq, void *cookie)
L
Luciano Coelho 已提交
760 761
{
	int ret;
762
	u32 intr;
763
	int loopcount = WL1271_IRQ_MAX_LOOPS;
764 765 766
	struct wl1271 *wl = (struct wl1271 *)cookie;
	bool done = false;
	unsigned int defer_count;
I
Ido Yariv 已提交
767 768 769 770 771
	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 已提交
772

773 774 775 776 777 778 779
	/*
	 * 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 已提交
780 781 782 783
	mutex_lock(&wl->mutex);

	wl1271_debug(DEBUG_IRQ, "IRQ work");

784
	if (unlikely(wl->state == WL1271_STATE_OFF))
L
Luciano Coelho 已提交
785 786
		goto out;

787
	ret = wl1271_ps_elp_wakeup(wl);
L
Luciano Coelho 已提交
788 789 790
	if (ret < 0)
		goto out;

791 792 793 794 795 796 797 798
	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();
799 800

		wl1271_fw_status(wl, wl->fw_status);
801
		intr = le32_to_cpu(wl->fw_status->common.intr);
802
		intr &= WL1271_INTR_MASK;
803
		if (!intr) {
804
			done = true;
805 806
			continue;
		}
L
Luciano Coelho 已提交
807

808 809 810 811 812 813 814 815 816
		if (unlikely(intr & WL1271_ACX_INTR_WATCHDOG)) {
			wl1271_error("watchdog interrupt received! "
				     "starting recovery.");
			ieee80211_queue_work(wl->hw, &wl->recovery_work);

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

817
		if (likely(intr & WL1271_ACX_INTR_DATA)) {
818
			wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
819

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

I
Ido Yariv 已提交
822
			/* Check if any tx blocks were freed */
I
Ido Yariv 已提交
823
			spin_lock_irqsave(&wl->wl_lock, flags);
I
Ido Yariv 已提交
824
			if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
825
			    wl->tx_queue_count) {
I
Ido Yariv 已提交
826
				spin_unlock_irqrestore(&wl->wl_lock, flags);
I
Ido Yariv 已提交
827 828 829 830 831
				/*
				 * In order to avoid starvation of the TX path,
				 * call the work function directly.
				 */
				wl1271_tx_work_locked(wl);
I
Ido Yariv 已提交
832 833
			} else {
				spin_unlock_irqrestore(&wl->wl_lock, flags);
I
Ido Yariv 已提交
834 835
			}

836 837 838 839
			/* check for tx results */
			if (wl->fw_status->common.tx_results_counter !=
			    (wl->tx_results_count & 0xff))
				wl1271_tx_complete(wl);
840 841 842 843 844 845

			/* 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);
846
		}
L
Luciano Coelho 已提交
847

848 849 850 851
		if (intr & WL1271_ACX_INTR_EVENT_A) {
			wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
			wl1271_event_handle(wl, 0);
		}
L
Luciano Coelho 已提交
852

853 854 855 856
		if (intr & WL1271_ACX_INTR_EVENT_B) {
			wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
			wl1271_event_handle(wl, 1);
		}
L
Luciano Coelho 已提交
857

858 859 860
		if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
			wl1271_debug(DEBUG_IRQ,
				     "WL1271_ACX_INTR_INIT_COMPLETE");
L
Luciano Coelho 已提交
861

862 863
		if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
			wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
864
	}
L
Luciano Coelho 已提交
865 866 867 868

	wl1271_ps_elp_sleep(wl);

out:
I
Ido Yariv 已提交
869 870 871 872 873 874 875 876
	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) &&
	    wl->tx_queue_count)
		ieee80211_queue_work(wl->hw, &wl->tx_work);
	spin_unlock_irqrestore(&wl->wl_lock, flags);

L
Luciano Coelho 已提交
877
	mutex_unlock(&wl->mutex);
878 879

	return IRQ_HANDLED;
L
Luciano Coelho 已提交
880
}
881
EXPORT_SYMBOL_GPL(wl1271_irq);
L
Luciano Coelho 已提交
882 883 884 885

static int wl1271_fetch_firmware(struct wl1271 *wl)
{
	const struct firmware *fw;
886
	const char *fw_name;
L
Luciano Coelho 已提交
887 888
	int ret;

889 890
	switch (wl->bss_type) {
	case BSS_TYPE_AP_BSS:
891 892 893 894
		if (wl->chip.id == CHIP_ID_1283_PG20)
			fw_name = WL128X_AP_FW_NAME;
		else
			fw_name = WL127X_AP_FW_NAME;
895 896 897
		break;
	case BSS_TYPE_IBSS:
	case BSS_TYPE_STA_BSS:
898 899 900 901
		if (wl->chip.id == CHIP_ID_1283_PG20)
			fw_name = WL128X_FW_NAME;
		else
			fw_name	= WL1271_FW_NAME;
902 903 904 905 906 907 908 909 910 911
		break;
	default:
		wl1271_error("no compatible firmware for bss_type %d",
			     wl->bss_type);
		return -EINVAL;
	}

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

	ret = request_firmware(&fw, fw_name, wl1271_wl_to_dev(wl));
L
Luciano Coelho 已提交
912 913 914 915 916 917 918 919 920 921 922 923 924

	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;
	}

925
	vfree(wl->fw);
L
Luciano Coelho 已提交
926
	wl->fw_len = fw->size;
927
	wl->fw = vmalloc(wl->fw_len);
L
Luciano Coelho 已提交
928 929 930 931 932 933 934 935

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

	memcpy(wl->fw, fw->data, wl->fw_len);
936
	wl->fw_bss_type = wl->bss_type;
L
Luciano Coelho 已提交
937 938 939 940 941 942 943 944 945 946 947 948 949
	ret = 0;

out:
	release_firmware(fw);

	return ret;
}

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

950
	ret = request_firmware(&fw, WL12XX_NVS_NAME, wl1271_wl_to_dev(wl));
L
Luciano Coelho 已提交
951 952 953 954 955 956

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

957
	wl->nvs = kmemdup(fw->data, fw->size, GFP_KERNEL);
L
Luciano Coelho 已提交
958 959 960 961 962 963 964

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

965 966
	wl->nvs_len = fw->size;

L
Luciano Coelho 已提交
967 968 969 970 971 972
out:
	release_firmware(fw);

	return ret;
}

973 974 975 976 977 978 979 980 981 982
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;

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

986 987 988
	if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
		ieee80211_connection_loss(wl->vif);

989 990 991
	/* Prevent spurious TX during FW restart */
	ieee80211_stop_queues(wl->hw);

992 993 994 995 996
	if (wl->sched_scanning) {
		ieee80211_sched_scan_stopped(wl->hw);
		wl->sched_scanning = false;
	}

997
	/* reboot the chipset */
998
	__wl1271_op_remove_interface(wl, false);
999 1000
	ieee80211_restart_hw(wl->hw);

1001 1002 1003 1004 1005 1006
	/*
	 * Its safe to enable TX now - the queues are stopped after a request
	 * to restart the HW.
	 */
	ieee80211_wake_queues(wl->hw);

1007 1008 1009 1010
out:
	mutex_unlock(&wl->mutex);
}

L
Luciano Coelho 已提交
1011 1012 1013 1014 1015
static void wl1271_fw_wakeup(struct wl1271 *wl)
{
	u32 elp_reg;

	elp_reg = ELPCTRL_WAKE_UP;
1016
	wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
L
Luciano Coelho 已提交
1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035
}

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)
{
1036
	struct wl1271_partition_set partition;
L
Luciano Coelho 已提交
1037 1038
	int ret = 0;

J
Juuso Oikarinen 已提交
1039
	msleep(WL1271_PRE_POWER_ON_SLEEP);
1040 1041 1042
	ret = wl1271_power_on(wl);
	if (ret < 0)
		goto out;
L
Luciano Coelho 已提交
1043
	msleep(WL1271_POWER_ON_SLEEP);
1044 1045
	wl1271_io_reset(wl);
	wl1271_io_init(wl);
L
Luciano Coelho 已提交
1046 1047 1048

	/* We don't need a real memory partition here, because we only want
	 * to use the registers at this point. */
1049 1050 1051 1052
	memset(&partition, 0, sizeof(partition));
	partition.reg.start = REGISTERS_BASE;
	partition.reg.size = REGISTERS_DOWN_SIZE;
	wl1271_set_partition(wl, &partition);
L
Luciano Coelho 已提交
1053 1054 1055 1056 1057 1058 1059

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

	/* whal_FwCtrl_BootSm() */

	/* 0. read chip id from CHIP_ID */
T
Teemu Paasikivi 已提交
1060
	wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
L
Luciano Coelho 已提交
1061 1062 1063 1064 1065 1066 1067 1068 1069 1070

	/* 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)
1071
			goto out;
L
Luciano Coelho 已提交
1072 1073 1074 1075 1076
		break;
	case CHIP_ID_1271_PG20:
		wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
			     wl->chip.id);

1077 1078 1079 1080
		/* end-of-transaction flag should be set in wl127x AP mode */
		if (wl->bss_type == BSS_TYPE_AP_BSS)
			wl->quirks |= WL12XX_QUIRK_END_OF_TRANSACTION;

L
Luciano Coelho 已提交
1081 1082
		ret = wl1271_setup(wl);
		if (ret < 0)
1083
			goto out;
L
Luciano Coelho 已提交
1084
		break;
1085 1086 1087 1088 1089 1090 1091
	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;
1092 1093
		if (wl1271_set_block_size(wl))
			wl->quirks |= WL12XX_QUIRK_BLOCKSIZE_ALIGNMENT;
1094 1095
		break;
	case CHIP_ID_1283_PG10:
L
Luciano Coelho 已提交
1096
	default:
1097
		wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
L
Luciano Coelho 已提交
1098
		ret = -ENODEV;
1099
		goto out;
L
Luciano Coelho 已提交
1100 1101
	}

1102 1103
	/* Make sure the firmware type matches the BSS type */
	if (wl->fw == NULL || wl->fw_bss_type != wl->bss_type) {
L
Luciano Coelho 已提交
1104 1105
		ret = wl1271_fetch_firmware(wl);
		if (ret < 0)
1106
			goto out;
L
Luciano Coelho 已提交
1107 1108 1109 1110 1111 1112
	}

	/* No NVS from netlink, try to get it from the filesystem */
	if (wl->nvs == NULL) {
		ret = wl1271_fetch_nvs(wl);
		if (ret < 0)
1113
			goto out;
L
Luciano Coelho 已提交
1114 1115 1116 1117 1118 1119
	}

out:
	return ret;
}

1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137
static unsigned int wl1271_get_fw_ver_quirks(struct wl1271 *wl)
{
	unsigned int quirks = 0;
	unsigned int *fw_ver = wl->chip.fw_ver;

	/* Only for wl127x */
	if ((fw_ver[FW_VER_CHIP] == FW_VER_CHIP_WL127X) &&
	    /* Check STA version */
	    (((fw_ver[FW_VER_IF_TYPE] == FW_VER_IF_TYPE_STA) &&
	      (fw_ver[FW_VER_MINOR] < FW_VER_MINOR_1_SPARE_STA_MIN)) ||
	     /* Check AP version */
	     ((fw_ver[FW_VER_IF_TYPE] == FW_VER_IF_TYPE_AP) &&
	      (fw_ver[FW_VER_MINOR] < FW_VER_MINOR_1_SPARE_AP_MIN))))
		quirks |= WL12XX_QUIRK_USE_2_SPARE_BLOCKS;

	return quirks;
}

L
Luciano Coelho 已提交
1138 1139
int wl1271_plt_start(struct wl1271 *wl)
{
1140
	int retries = WL1271_BOOT_RETRIES;
L
Luciano Coelho 已提交
1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153
	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;
	}

1154 1155
	wl->bss_type = BSS_TYPE_STA_BSS;

1156 1157 1158 1159 1160
	while (retries) {
		retries--;
		ret = wl1271_chip_wakeup(wl);
		if (ret < 0)
			goto power_off;
L
Luciano Coelho 已提交
1161

1162 1163 1164
		ret = wl1271_boot(wl);
		if (ret < 0)
			goto power_off;
1165

1166 1167 1168
		ret = wl1271_plt_init(wl);
		if (ret < 0)
			goto irq_disable;
1169

1170 1171
		wl->state = WL1271_STATE_PLT;
		wl1271_notice("firmware booted in PLT mode (%s)",
L
Levi, Shahar 已提交
1172
			      wl->chip.fw_ver_str);
1173 1174 1175

		/* Check if any quirks are needed with older fw versions */
		wl->quirks |= wl1271_get_fw_ver_quirks(wl);
1176
		goto out;
1177

1178 1179 1180 1181 1182 1183 1184 1185 1186
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. */
1187 1188 1189
		wl1271_disable_interrupts(wl);
		wl1271_flush_deferred_work(wl);
		cancel_work_sync(&wl->netstack_work);
1190 1191 1192 1193
		mutex_lock(&wl->mutex);
power_off:
		wl1271_power_off(wl);
	}
L
Luciano Coelho 已提交
1194

1195 1196
	wl1271_error("firmware boot in PLT mode failed despite %d retries",
		     WL1271_BOOT_RETRIES);
L
Luciano Coelho 已提交
1197 1198 1199 1200 1201 1202
out:
	mutex_unlock(&wl->mutex);

	return ret;
}

1203
static int __wl1271_plt_stop(struct wl1271 *wl)
L
Luciano Coelho 已提交
1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218
{
	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;
1219
	wl->rx_counter = 0;
L
Luciano Coelho 已提交
1220 1221

	mutex_unlock(&wl->mutex);
1222 1223 1224
	wl1271_disable_interrupts(wl);
	wl1271_flush_deferred_work(wl);
	cancel_work_sync(&wl->netstack_work);
1225
	cancel_work_sync(&wl->recovery_work);
1226 1227 1228 1229 1230 1231 1232 1233
	mutex_lock(&wl->mutex);
out:
	return ret;
}

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

1235 1236 1237
	mutex_lock(&wl->mutex);
	ret = __wl1271_plt_stop(wl);
	mutex_unlock(&wl->mutex);
L
Luciano Coelho 已提交
1238 1239 1240
	return ret;
}

1241
static void wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
L
Luciano Coelho 已提交
1242 1243
{
	struct wl1271 *wl = hw->priv;
1244
	unsigned long flags;
1245
	int q;
1246
	u8 hlid = 0;
L
Luciano Coelho 已提交
1247

I
Ido Yariv 已提交
1248 1249 1250 1251 1252
	q = wl1271_tx_get_queue(skb_get_queue_mapping(skb));

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

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

1255
	wl->tx_queue_count++;
1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266

	/*
	 * The workqueue is slow to process the tx_queue and we need stop
	 * the queue here, otherwise the queue will get too long.
	 */
	if (wl->tx_queue_count >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
		wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
		ieee80211_stop_queues(wl->hw);
		set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
	}

1267
	/* queue the packet */
1268 1269 1270 1271 1272 1273
	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 已提交
1274 1275 1276 1277 1278 1279

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

I
Ido Yariv 已提交
1280 1281
	if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
	    !test_bit(WL1271_FLAG_TX_PENDING, &wl->flags))
I
Ido Yariv 已提交
1282
		ieee80211_queue_work(wl->hw, &wl->tx_work);
I
Ido Yariv 已提交
1283 1284

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

1287 1288
int wl1271_tx_dummy_packet(struct wl1271 *wl)
{
1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313
	unsigned long flags;

	spin_lock_irqsave(&wl->wl_lock, flags);
	set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags);
	wl->tx_queue_count++;
	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))

1314
static struct sk_buff *wl12xx_alloc_dummy_packet(struct wl1271 *wl)
1315 1316
{
	struct sk_buff *skb;
1317
	struct ieee80211_hdr_3addr *hdr;
1318 1319 1320 1321
	unsigned int dummy_packet_size;

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

1323
	skb = dev_alloc_skb(TOTAL_TX_DUMMY_PACKET_SIZE);
1324
	if (!skb) {
1325 1326
		wl1271_warning("Failed to allocate a dummy packet skb");
		return NULL;
1327 1328 1329 1330 1331 1332 1333
	}

	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 |
1334 1335
					 IEEE80211_STYPE_NULLFUNC |
					 IEEE80211_FCTL_TODS);
1336

1337
	memset(skb_put(skb, dummy_packet_size), 0, dummy_packet_size);
1338

1339 1340
	/* Dummy packets require the TID to be management */
	skb->priority = WL1271_TID_MGMT;
1341

1342
	/* Initialize all fields that might be used */
1343
	skb_set_queue_mapping(skb, 0);
1344
	memset(IEEE80211_SKB_CB(skb), 0, sizeof(struct ieee80211_tx_info));
1345

1346
	return skb;
1347 1348
}

1349

1350 1351 1352 1353
static struct notifier_block wl1271_dev_notifier = {
	.notifier_call = wl1271_dev_notify,
};

1354
#ifdef CONFIG_PM
1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427
static int wl1271_configure_suspend(struct wl1271 *wl)
{
	int ret;

	if (wl->bss_type != BSS_TYPE_STA_BSS)
		return 0;

	mutex_lock(&wl->mutex);

	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;

}

static void wl1271_configure_resume(struct wl1271 *wl)
{
	int ret;

	if (wl->bss_type != BSS_TYPE_STA_BSS)
		return;

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

	/* 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);

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

1428 1429 1430 1431 1432 1433
static int wl1271_op_suspend(struct ieee80211_hw *hw,
			    struct cfg80211_wowlan *wow)
{
	struct wl1271 *wl = hw->priv;
	wl1271_debug(DEBUG_MAC80211, "mac80211 suspend wow=%d", !!wow);
	wl->wow_enabled = !!wow;
1434
	if (wl->wow_enabled) {
1435 1436 1437 1438 1439 1440
		int ret;
		ret = wl1271_configure_suspend(wl);
		if (ret < 0) {
			wl1271_warning("couldn't prepare device to suspend");
			return ret;
		}
1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461
		/* flush any remaining work */
		wl1271_debug(DEBUG_MAC80211, "flushing remaining works");
		flush_delayed_work(&wl->scan_complete_work);

		/*
		 * 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);
	}
1462 1463 1464 1465 1466 1467 1468 1469
	return 0;
}

static int wl1271_op_resume(struct ieee80211_hw *hw)
{
	struct wl1271 *wl = hw->priv;
	wl1271_debug(DEBUG_MAC80211, "mac80211 resume wow=%d",
		     wl->wow_enabled);
1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491

	/*
	 * re-enable irq_work enqueuing, and call irq_work directly if
	 * there is a pending work.
	 */
	if (wl->wow_enabled) {
		struct wl1271 *wl = hw->priv;
		unsigned long flags;
		bool run_irq_work = false;

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

		if (run_irq_work) {
			wl1271_debug(DEBUG_MAC80211,
				     "run postponed irq_work directly");
			wl1271_irq(0, wl);
			wl1271_enable_interrupts(wl);
		}
1492 1493

		wl1271_configure_resume(wl);
1494 1495
	}

1496 1497
	return 0;
}
1498
#endif
1499

L
Luciano Coelho 已提交
1500
static int wl1271_op_start(struct ieee80211_hw *hw)
1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512
{
	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.
1513 1514 1515
	 *
	 * In addition, we currently have different firmwares for AP and managed
	 * operation. We will know which to boot according to interface type.
1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527
	 */

	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 已提交
1528 1529
{
	struct wl1271 *wl = hw->priv;
1530
	struct wiphy *wiphy = hw->wiphy;
1531
	int retries = WL1271_BOOT_RETRIES;
L
Luciano Coelho 已提交
1532
	int ret = 0;
1533
	bool booted = false;
L
Luciano Coelho 已提交
1534

1535 1536
	wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
		     vif->type, vif->addr);
L
Luciano Coelho 已提交
1537 1538

	mutex_lock(&wl->mutex);
1539
	if (wl->vif) {
1540 1541
		wl1271_debug(DEBUG_MAC80211,
			     "multiple vifs are not supported yet");
1542 1543 1544 1545
		ret = -EBUSY;
		goto out;
	}

1546 1547 1548 1549 1550 1551 1552 1553 1554 1555
	/*
	 * 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;
	}

1556 1557 1558
	switch (vif->type) {
	case NL80211_IFTYPE_STATION:
		wl->bss_type = BSS_TYPE_STA_BSS;
1559
		wl->set_bss_type = BSS_TYPE_STA_BSS;
1560 1561 1562
		break;
	case NL80211_IFTYPE_ADHOC:
		wl->bss_type = BSS_TYPE_IBSS;
1563
		wl->set_bss_type = BSS_TYPE_STA_BSS;
1564
		break;
A
Arik Nemtsov 已提交
1565 1566 1567
	case NL80211_IFTYPE_AP:
		wl->bss_type = BSS_TYPE_AP_BSS;
		break;
1568 1569 1570 1571 1572 1573
	default:
		ret = -EOPNOTSUPP;
		goto out;
	}

	memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
L
Luciano Coelho 已提交
1574 1575 1576 1577 1578 1579 1580 1581

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

1582 1583 1584 1585 1586
	while (retries) {
		retries--;
		ret = wl1271_chip_wakeup(wl);
		if (ret < 0)
			goto power_off;
L
Luciano Coelho 已提交
1587

1588 1589 1590
		ret = wl1271_boot(wl);
		if (ret < 0)
			goto power_off;
L
Luciano Coelho 已提交
1591

1592 1593 1594
		ret = wl1271_hw_init(wl);
		if (ret < 0)
			goto irq_disable;
L
Luciano Coelho 已提交
1595

1596 1597
		booted = true;
		break;
1598

1599 1600 1601 1602 1603 1604 1605 1606 1607
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. */
1608 1609 1610
		wl1271_disable_interrupts(wl);
		wl1271_flush_deferred_work(wl);
		cancel_work_sync(&wl->netstack_work);
1611 1612 1613 1614
		mutex_lock(&wl->mutex);
power_off:
		wl1271_power_off(wl);
	}
1615

1616 1617 1618 1619 1620 1621 1622 1623
	if (!booted) {
		wl1271_error("firmware boot failed despite %d retries",
			     WL1271_BOOT_RETRIES);
		goto out;
	}

	wl->vif = vif;
	wl->state = WL1271_STATE_ON;
1624
	set_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags);
L
Levi, Shahar 已提交
1625
	wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
1626 1627 1628

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

1632 1633 1634
	/* Check if any quirks are needed with older fw versions */
	wl->quirks |= wl1271_get_fw_ver_quirks(wl);

1635 1636 1637 1638 1639 1640 1641 1642 1643 1644
	/*
	 * 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 ");

1645
out:
L
Luciano Coelho 已提交
1646 1647
	mutex_unlock(&wl->mutex);

1648
	mutex_lock(&wl_list_mutex);
1649
	if (!ret)
1650
		list_add(&wl->list, &wl_list);
1651
	mutex_unlock(&wl_list_mutex);
1652

L
Luciano Coelho 已提交
1653 1654 1655
	return ret;
}

1656 1657
static void __wl1271_op_remove_interface(struct wl1271 *wl,
					 bool reset_tx_queues)
L
Luciano Coelho 已提交
1658 1659 1660
{
	int i;

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

1663 1664 1665 1666
	/* because of hardware recovery, we may get here twice */
	if (wl->state != WL1271_STATE_ON)
		return;

1667
	wl1271_info("down");
L
Luciano Coelho 已提交
1668

1669
	mutex_lock(&wl_list_mutex);
1670
	list_del(&wl->list);
1671
	mutex_unlock(&wl_list_mutex);
1672

1673
	/* enable dyn ps just in case (if left on due to fw crash etc) */
1674
	if (wl->bss_type == BSS_TYPE_STA_BSS)
1675
		ieee80211_enable_dyn_ps(wl->vif);
1676

L
Luciano Coelho 已提交
1677 1678
	if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
		wl->scan.state = WL1271_SCAN_STATE_IDLE;
1679
		memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
1680
		wl->scan.req = NULL;
1681
		ieee80211_scan_completed(wl->hw, true);
L
Luciano Coelho 已提交
1682 1683
	}

1684 1685 1686 1687
	/*
	 * this must be before the cancel_work calls below, so that the work
	 * functions don't perform further work.
	 */
L
Luciano Coelho 已提交
1688 1689 1690 1691
	wl->state = WL1271_STATE_OFF;

	mutex_unlock(&wl->mutex);

1692 1693
	wl1271_disable_interrupts(wl);
	wl1271_flush_deferred_work(wl);
1694
	cancel_delayed_work_sync(&wl->scan_complete_work);
1695
	cancel_work_sync(&wl->netstack_work);
L
Luciano Coelho 已提交
1696
	cancel_work_sync(&wl->tx_work);
1697
	cancel_delayed_work_sync(&wl->pspoll_work);
1698
	cancel_delayed_work_sync(&wl->elp_work);
L
Luciano Coelho 已提交
1699 1700 1701 1702

	mutex_lock(&wl->mutex);

	/* let's notify MAC80211 about the remaining pending TX frames */
1703
	wl1271_tx_reset(wl, reset_tx_queues);
L
Luciano Coelho 已提交
1704 1705 1706 1707 1708 1709
	wl1271_power_off(wl);

	memset(wl->bssid, 0, ETH_ALEN);
	memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
	wl->ssid_len = 0;
	wl->bss_type = MAX_BSS_TYPE;
1710
	wl->set_bss_type = MAX_BSS_TYPE;
1711
	wl->band = IEEE80211_BAND_2GHZ;
L
Luciano Coelho 已提交
1712 1713

	wl->rx_counter = 0;
1714
	wl->psm_entry_retry = 0;
L
Luciano Coelho 已提交
1715 1716
	wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
	wl->tx_blocks_available = 0;
1717
	wl->tx_allocated_blocks = 0;
L
Luciano Coelho 已提交
1718 1719
	wl->tx_results_count = 0;
	wl->tx_packets_count = 0;
1720
	wl->tx_security_last_seq = 0;
1721
	wl->tx_security_seq = 0;
L
Luciano Coelho 已提交
1722 1723
	wl->time_offset = 0;
	wl->session_counter = 0;
1724
	wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1725
	wl->vif = NULL;
1726
	wl->filters = 0;
1727
	wl1271_free_ap_keys(wl);
1728
	memset(wl->ap_hlid_map, 0, sizeof(wl->ap_hlid_map));
1729 1730
	wl->ap_fw_ps_map = 0;
	wl->ap_ps_map = 0;
1731
	wl->sched_scanning = false;
1732

1733 1734 1735 1736 1737 1738 1739
	/*
	 * 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;

L
Luciano Coelho 已提交
1740 1741 1742 1743
	for (i = 0; i < NUM_TX_QUEUES; i++)
		wl->tx_blocks_freed[i] = 0;

	wl1271_debugfs_reset(wl);
1744 1745 1746 1747 1748 1749 1750

	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;
1751
}
1752

1753 1754 1755 1756 1757 1758
static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
				       struct ieee80211_vif *vif)
{
	struct wl1271 *wl = hw->priv;

	mutex_lock(&wl->mutex);
1759 1760 1761 1762 1763 1764
	/*
	 * 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);
1765
		__wl1271_op_remove_interface(wl, true);
1766
	}
1767

1768
	mutex_unlock(&wl->mutex);
1769
	cancel_work_sync(&wl->recovery_work);
L
Luciano Coelho 已提交
1770 1771
}

O
Ohad Ben-Cohen 已提交
1772
void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1773
{
1774
	wl1271_set_default_filters(wl);
1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804

	/* combine requested filters with current filter config */
	filters = wl->filters | filters;

	wl1271_debug(DEBUG_FILTERS, "RX filters set: ");

	if (filters & FIF_PROMISC_IN_BSS) {
		wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
		wl->rx_config &= ~CFG_UNI_FILTER_EN;
		wl->rx_config |= CFG_BSSID_FILTER_EN;
	}
	if (filters & FIF_BCN_PRBRESP_PROMISC) {
		wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
		wl->rx_config &= ~CFG_BSSID_FILTER_EN;
		wl->rx_config &= ~CFG_SSID_FILTER_EN;
	}
	if (filters & FIF_OTHER_BSS) {
		wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
		wl->rx_config &= ~CFG_BSSID_FILTER_EN;
	}
	if (filters & FIF_CONTROL) {
		wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
		wl->rx_filter |= CFG_RX_CTL_EN;
	}
	if (filters & FIF_FCSFAIL) {
		wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
		wl->rx_filter |= CFG_RX_FCS_ERROR;
	}
}

1805
static int wl1271_dummy_join(struct wl1271 *wl)
1806
{
1807
	int ret = 0;
1808 1809 1810 1811 1812 1813
	/* 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);

1814 1815 1816
	/* pass through frames from all BSS */
	wl1271_configure_filters(wl, FIF_OTHER_BSS);

1817
	ret = wl1271_cmd_join(wl, wl->set_bss_type);
1818 1819 1820
	if (ret < 0)
		goto out;

1821
	set_bit(WL1271_FLAG_JOINED, &wl->flags);
1822 1823 1824 1825 1826

out:
	return ret;
}

1827
static int wl1271_join(struct wl1271 *wl, bool set_assoc)
1828 1829 1830
{
	int ret;

1831 1832 1833 1834
	/*
	 * 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.
1835 1836 1837 1838
	 * 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 :)
1839 1840 1841 1842 1843 1844 1845
	 */
	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);

1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882
	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)
1883 1884 1885 1886 1887 1888 1889 1890
{
	int ret;

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

1891
	clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1892
	memset(wl->bssid, 0, ETH_ALEN);
1893

O
Ohad Ben-Cohen 已提交
1894
	/* stop filtering packets based on bssid */
1895
	wl1271_configure_filters(wl, FIF_OTHER_BSS);
1896 1897 1898 1899 1900

out:
	return ret;
}

1901 1902 1903 1904 1905 1906 1907 1908
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;
}

1909
static int wl1271_sta_handle_idle(struct wl1271 *wl, bool idle)
1910 1911 1912 1913 1914 1915 1916 1917 1918
{
	int ret;

	if (idle) {
		if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
			ret = wl1271_unjoin(wl);
			if (ret < 0)
				goto out;
		}
A
Arik Nemtsov 已提交
1919
		wl->rate_set = wl1271_tx_min_rate_get(wl);
1920
		ret = wl1271_acx_sta_rate_policies(wl);
1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933
		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;
1934 1935 1936 1937 1938 1939 1940

		/* 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);
		}

1941 1942 1943 1944 1945 1946 1947 1948 1949 1950
		ret = wl1271_dummy_join(wl);
		if (ret < 0)
			goto out;
		clear_bit(WL1271_FLAG_IDLE, &wl->flags);
	}

out:
	return ret;
}

L
Luciano Coelho 已提交
1951 1952 1953 1954 1955
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;
1956
	bool is_ap;
L
Luciano Coelho 已提交
1957 1958 1959

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

1960 1961
	wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s"
		     " changed 0x%x",
L
Luciano Coelho 已提交
1962 1963
		     channel,
		     conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1964
		     conf->power_level,
1965 1966
		     conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
			 changed);
L
Luciano Coelho 已提交
1967

1968 1969 1970 1971 1972 1973 1974 1975 1976
	/*
	 * 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 已提交
1977 1978
	mutex_lock(&wl->mutex);

1979
	if (unlikely(wl->state == WL1271_STATE_OFF)) {
1980 1981 1982 1983 1984 1985
		/* we support configuring the channel and band while off */
		if ((changed & IEEE80211_CONF_CHANGE_CHANNEL)) {
			wl->band = conf->channel->band;
			wl->channel = channel;
		}

1986
		goto out;
1987
	}
1988

1989 1990
	is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);

1991
	ret = wl1271_ps_elp_wakeup(wl);
L
Luciano Coelho 已提交
1992 1993 1994
	if (ret < 0)
		goto out;

1995
	/* if the channel changes while joined, join again */
1996 1997 1998
	if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
	    ((wl->band != conf->channel->band) ||
	     (wl->channel != channel))) {
1999 2000 2001
		wl->band = conf->channel->band;
		wl->channel = channel;

2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013
		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);
2014
			if (ret < 0)
2015
				wl1271_warning("rate policy for channel "
2016
					       "failed %d", ret);
2017 2018 2019 2020 2021 2022 2023

			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);
			}
2024 2025 2026
		}
	}

2027 2028 2029
	if (changed & IEEE80211_CONF_CHANGE_IDLE && !is_ap) {
		ret = wl1271_sta_handle_idle(wl,
					conf->flags & IEEE80211_CONF_IDLE);
2030 2031
		if (ret < 0)
			wl1271_warning("idle mode change failed %d", ret);
L
Luciano Coelho 已提交
2032 2033
	}

2034 2035 2036 2037 2038 2039 2040
	/*
	 * 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);

2041 2042 2043
	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 已提交
2044 2045 2046 2047 2048 2049

		/*
		 * 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.
		 */
2050
		if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
2051
			wl1271_debug(DEBUG_PSM, "psm enabled");
J
Juuso Oikarinen 已提交
2052
			ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
2053
						 wl->basic_rate, true);
2054
		}
L
Luciano Coelho 已提交
2055
	} else if (!(conf->flags & IEEE80211_CONF_PS) &&
2056
		   test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
2057
		wl1271_debug(DEBUG_PSM, "psm disabled");
L
Luciano Coelho 已提交
2058

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

2061
		if (test_bit(WL1271_FLAG_PSM, &wl->flags))
J
Juuso Oikarinen 已提交
2062
			ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
2063
						 wl->basic_rate, true);
L
Luciano Coelho 已提交
2064 2065 2066 2067 2068
	}

	if (conf->power_level != wl->power_level) {
		ret = wl1271_acx_tx_power(wl, conf->power_level);
		if (ret < 0)
2069
			goto out_sleep;
L
Luciano Coelho 已提交
2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082

		wl->power_level = conf->power_level;
	}

out_sleep:
	wl1271_ps_elp_sleep(wl);

out:
	mutex_unlock(&wl->mutex);

	return ret;
}

J
Juuso Oikarinen 已提交
2083 2084 2085 2086 2087 2088
struct wl1271_filter_params {
	bool enabled;
	int mc_list_length;
	u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
};

2089 2090
static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
				       struct netdev_hw_addr_list *mc_list)
2091 2092
{
	struct wl1271_filter_params *fp;
2093
	struct netdev_hw_addr *ha;
2094
	struct wl1271 *wl = hw->priv;
2095

2096 2097
	if (unlikely(wl->state == WL1271_STATE_OFF))
		return 0;
2098

2099
	fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
2100 2101 2102 2103 2104 2105 2106
	if (!fp) {
		wl1271_error("Out of memory setting filters.");
		return 0;
	}

	/* update multicast filtering parameters */
	fp->mc_list_length = 0;
2107 2108 2109 2110 2111
	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) {
2112
			memcpy(fp->mc_list[fp->mc_list_length],
2113
					ha->addr, ETH_ALEN);
2114
			fp->mc_list_length++;
2115
		}
2116 2117
	}

J
Juuso Oikarinen 已提交
2118
	return (u64)(unsigned long)fp;
2119
}
L
Luciano Coelho 已提交
2120

J
Juuso Oikarinen 已提交
2121 2122 2123 2124 2125 2126 2127
#define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
				  FIF_ALLMULTI | \
				  FIF_FCSFAIL | \
				  FIF_BCN_PRBRESP_PROMISC | \
				  FIF_CONTROL | \
				  FIF_OTHER_BSS)

L
Luciano Coelho 已提交
2128 2129
static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
				       unsigned int changed,
2130
				       unsigned int *total, u64 multicast)
L
Luciano Coelho 已提交
2131
{
J
Juuso Oikarinen 已提交
2132
	struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
L
Luciano Coelho 已提交
2133
	struct wl1271 *wl = hw->priv;
J
Juuso Oikarinen 已提交
2134
	int ret;
L
Luciano Coelho 已提交
2135

2136 2137
	wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
		     " total %x", changed, *total);
L
Luciano Coelho 已提交
2138

J
Juuso Oikarinen 已提交
2139 2140
	mutex_lock(&wl->mutex);

2141 2142 2143 2144
	*total &= WL1271_SUPPORTED_FILTERS;
	changed &= WL1271_SUPPORTED_FILTERS;

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

2147
	ret = wl1271_ps_elp_wakeup(wl);
J
Juuso Oikarinen 已提交
2148 2149 2150
	if (ret < 0)
		goto out;

2151 2152 2153 2154 2155 2156 2157 2158 2159 2160
	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 已提交
2161

J
Juuso Oikarinen 已提交
2162 2163 2164
	/* determine, whether supported filter values have changed */
	if (changed == 0)
		goto out_sleep;
2165

2166 2167 2168 2169
	/* configure filters */
	wl->filters = *total;
	wl1271_configure_filters(wl, 0);

J
Juuso Oikarinen 已提交
2170 2171 2172 2173 2174 2175 2176 2177 2178 2179
	/* apply configured filters */
	ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
	if (ret < 0)
		goto out_sleep;

out_sleep:
	wl1271_ps_elp_sleep(wl);

out:
	mutex_unlock(&wl->mutex);
2180
	kfree(fp);
L
Luciano Coelho 已提交
2181 2182
}

2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349
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 已提交
2350 2351 2352 2353 2354 2355 2356
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;
2357 2358
	u32 tx_seq_32 = 0;
	u16 tx_seq_16 = 0;
L
Luciano Coelho 已提交
2359 2360 2361 2362
	u8 key_type;

	wl1271_debug(DEBUG_MAC80211, "mac80211 set key");

2363
	wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
L
Luciano Coelho 已提交
2364
	wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
2365
		     key_conf->cipher, key_conf->keyidx,
L
Luciano Coelho 已提交
2366 2367 2368 2369 2370
		     key_conf->keylen, key_conf->flags);
	wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);

	mutex_lock(&wl->mutex);

2371 2372 2373 2374 2375
	if (unlikely(wl->state == WL1271_STATE_OFF)) {
		ret = -EAGAIN;
		goto out_unlock;
	}

2376
	ret = wl1271_ps_elp_wakeup(wl);
L
Luciano Coelho 已提交
2377 2378 2379
	if (ret < 0)
		goto out_unlock;

2380 2381 2382
	switch (key_conf->cipher) {
	case WLAN_CIPHER_SUITE_WEP40:
	case WLAN_CIPHER_SUITE_WEP104:
L
Luciano Coelho 已提交
2383 2384 2385 2386
		key_type = KEY_WEP;

		key_conf->hw_key_idx = key_conf->keyidx;
		break;
2387
	case WLAN_CIPHER_SUITE_TKIP:
L
Luciano Coelho 已提交
2388 2389 2390
		key_type = KEY_TKIP;

		key_conf->hw_key_idx = key_conf->keyidx;
2391 2392
		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 已提交
2393
		break;
2394
	case WLAN_CIPHER_SUITE_CCMP:
L
Luciano Coelho 已提交
2395 2396 2397
		key_type = KEY_AES;

		key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
2398 2399
		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 已提交
2400
		break;
2401 2402 2403 2404 2405
	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 已提交
2406
	default:
2407
		wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
L
Luciano Coelho 已提交
2408 2409 2410 2411 2412 2413 2414

		ret = -EOPNOTSUPP;
		goto out_sleep;
	}

	switch (cmd) {
	case SET_KEY:
2415 2416 2417 2418
		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 已提交
2419 2420 2421 2422 2423 2424 2425
		if (ret < 0) {
			wl1271_error("Could not add or replace key");
			goto out_sleep;
		}
		break;

	case DISABLE_KEY:
2426 2427 2428 2429
		ret = wl1271_set_key(wl, KEY_REMOVE,
				     key_conf->keyidx, key_type,
				     key_conf->keylen, key_conf->key,
				     0, 0, sta);
L
Luciano Coelho 已提交
2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451
		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,
2452
			     struct ieee80211_vif *vif,
L
Luciano Coelho 已提交
2453 2454 2455 2456 2457
			     struct cfg80211_scan_request *req)
{
	struct wl1271 *wl = hw->priv;
	int ret;
	u8 *ssid = NULL;
2458
	size_t len = 0;
L
Luciano Coelho 已提交
2459 2460 2461 2462 2463

	wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");

	if (req->n_ssids) {
		ssid = req->ssids[0].ssid;
2464
		len = req->ssids[0].ssid_len;
L
Luciano Coelho 已提交
2465 2466 2467 2468
	}

	mutex_lock(&wl->mutex);

2469 2470 2471 2472 2473 2474 2475 2476 2477 2478
	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;
	}

2479
	ret = wl1271_ps_elp_wakeup(wl);
L
Luciano Coelho 已提交
2480 2481 2482
	if (ret < 0)
		goto out;

2483
	ret = wl1271_scan(hw->priv, ssid, len, req);
L
Luciano Coelho 已提交
2484 2485 2486 2487 2488 2489 2490 2491 2492

	wl1271_ps_elp_sleep(wl);

out:
	mutex_unlock(&wl->mutex);

	return ret;
}

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

2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558
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;
	}

2559
	ret = wl1271_ps_elp_wakeup(wl);
2560 2561 2562
	if (ret < 0)
		goto out;

2563
	ret = wl1271_acx_frag_threshold(wl, value);
2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574
	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 已提交
2575 2576 2577
static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
{
	struct wl1271 *wl = hw->priv;
2578
	int ret = 0;
L
Luciano Coelho 已提交
2579 2580 2581

	mutex_lock(&wl->mutex);

2582 2583
	if (unlikely(wl->state == WL1271_STATE_OFF)) {
		ret = -EAGAIN;
2584
		goto out;
2585
	}
2586

2587
	ret = wl1271_ps_elp_wakeup(wl);
L
Luciano Coelho 已提交
2588 2589 2590
	if (ret < 0)
		goto out;

2591
	ret = wl1271_acx_rts_threshold(wl, value);
L
Luciano Coelho 已提交
2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602
	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;
}

2603
static int wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *skb,
2604
			    int offset)
2605
{
2606 2607 2608
	u8 ssid_len;
	const u8 *ptr = cfg80211_find_ie(WLAN_EID_SSID, skb->data + offset,
					 skb->len - offset);
2609

2610 2611 2612 2613 2614 2615 2616 2617 2618
	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;
2619
	}
2620

2621 2622 2623
	wl->ssid_len = ssid_len;
	memcpy(wl->ssid, ptr+2, ssid_len);
	return 0;
2624 2625
}

2626
static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
L
Luciano Coelho 已提交
2627 2628 2629
				       struct ieee80211_bss_conf *bss_conf,
				       u32 changed)
{
2630
	int ret = 0;
L
Luciano Coelho 已提交
2631

2632 2633 2634 2635 2636 2637 2638 2639 2640 2641
	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 已提交
2642

2643 2644 2645 2646 2647 2648
	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 已提交
2649

2650 2651 2652 2653 2654 2655 2656 2657 2658 2659
	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;
		}
	}
2660

2661 2662 2663
out:
	return ret;
}
L
Luciano Coelho 已提交
2664

2665 2666 2667 2668 2669 2670 2671 2672 2673 2674
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",
2675 2676 2677 2678 2679
			bss_conf->beacon_int);

		wl->beacon_int = bss_conf->beacon_int;
	}

2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734
	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;
2735

2736 2737
	if ((changed & BSS_CHANGED_BASIC_RATES)) {
		u32 rates = bss_conf->basic_rates;
2738

2739 2740
		wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates);
		wl->basic_rate = wl1271_tx_min_rate_get(wl);
2741 2742

		ret = wl1271_init_ap_rates(wl);
2743
		if (ret < 0) {
2744
			wl1271_error("AP rate policy change failed %d", ret);
2745 2746
			goto out;
		}
2747 2748 2749 2750

		ret = wl1271_ap_init_templates(wl);
		if (ret < 0)
			goto out;
2751
	}
2752

2753 2754 2755
	ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
	if (ret < 0)
		goto out;
2756

2757 2758 2759 2760 2761 2762
	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;
2763

2764 2765
				set_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
				wl1271_debug(DEBUG_AP, "started AP");
2766 2767 2768 2769

				ret = wl1271_ap_init_hwenc(wl);
				if (ret < 0)
					goto out;
2770
			}
2771 2772 2773 2774 2775
		} else {
			if (test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
				ret = wl1271_cmd_stop_bss(wl);
				if (ret < 0)
					goto out;
2776

2777 2778 2779 2780 2781
				clear_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
				wl1271_debug(DEBUG_AP, "stopped AP");
			}
		}
	}
2782

2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800
	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;
		}
	}

2801 2802 2803 2804 2805 2806
	ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
	if (ret < 0)
		goto out;
out:
	return;
}
J
Juuso Oikarinen 已提交
2807

2808 2809 2810 2811 2812 2813 2814 2815
/* 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);
2816
	u32 sta_rate_set = 0;
2817
	int ret;
2818
	struct ieee80211_sta *sta;
2819 2820
	bool sta_exists = false;
	struct ieee80211_sta_ht_cap sta_ht_cap;
2821 2822 2823 2824 2825 2826

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

2829 2830 2831 2832 2833 2834 2835 2836
	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) {
2837 2838 2839 2840 2841 2842 2843 2844 2845 2846
		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;
	}

2847
	if ((changed & BSS_CHANGED_CQM)) {
2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858
		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;
	}

2859 2860 2861 2862 2863 2864
	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)) {
2865
		memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
2866

2867 2868 2869 2870
		if (!is_zero_ether_addr(wl->bssid)) {
			ret = wl1271_cmd_build_null_data(wl);
			if (ret < 0)
				goto out;
2871

2872 2873 2874
			ret = wl1271_build_qos_null_data(wl);
			if (ret < 0)
				goto out;
2875

2876 2877
			/* filter out all packets not from this BSSID */
			wl1271_configure_filters(wl, 0);
2878

2879 2880 2881
			/* Need to update the BSSID (for filtering etc) */
			do_join = true;
		}
2882 2883
	}

2884 2885 2886 2887 2888 2889 2890 2891
	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);
2892 2893 2894 2895
		sta_ht_cap = sta->ht_cap;
		sta_exists = true;
	}
	rcu_read_unlock();
2896

2897
	if (sta_exists) {
2898 2899 2900
		/* handle new association with HT and HT information change */
		if ((changed & BSS_CHANGED_HT) &&
		    (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
2901
			ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917
							     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) {
2918
			ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
2919 2920 2921 2922 2923 2924 2925 2926 2927
							     false);
			if (ret < 0) {
				wl1271_warning("Set ht cap false failed %d",
					       ret);
				goto out;
			}
		}
	}

2928
	if ((changed & BSS_CHANGED_ASSOC)) {
L
Luciano Coelho 已提交
2929
		if (bss_conf->assoc) {
2930
			u32 rates;
2931
			int ieoffset;
L
Luciano Coelho 已提交
2932
			wl->aid = bss_conf->aid;
2933
			set_assoc = true;
L
Luciano Coelho 已提交
2934

2935 2936
			wl->ps_poll_failures = 0;

2937 2938 2939 2940 2941 2942 2943
			/*
			 * 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 已提交
2944
			wl->basic_rate = wl1271_tx_min_rate_get(wl);
2945 2946 2947
			if (sta_rate_set)
				wl->rate_set = wl1271_tx_enabled_rates_get(wl,
								sta_rate_set);
2948
			ret = wl1271_acx_sta_rate_policies(wl);
2949
			if (ret < 0)
2950
				goto out;
2951

2952 2953 2954 2955 2956 2957
			/*
			 * 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 已提交
2958 2959
			ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
			if (ret < 0)
2960
				goto out;
L
Luciano Coelho 已提交
2961

2962
			/*
2963
			 * Get a template for hardware connection maintenance
2964
			 */
2965 2966 2967 2968 2969
			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);
2970

2971 2972
			/* enable the connection monitoring feature */
			ret = wl1271_acx_conn_monit_params(wl, true);
L
Luciano Coelho 已提交
2973
			if (ret < 0)
2974
				goto out;
L
Luciano Coelho 已提交
2975 2976

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

L
Luciano Coelho 已提交
2981
				mode = STATION_POWER_SAVE_MODE;
2982
				ret = wl1271_ps_set_mode(wl, mode,
2983
							 wl->basic_rate,
2984
							 true);
L
Luciano Coelho 已提交
2985
				if (ret < 0)
2986
					goto out;
L
Luciano Coelho 已提交
2987
			}
J
Juuso Oikarinen 已提交
2988 2989
		} else {
			/* use defaults when not associated */
2990 2991 2992
			bool was_assoc =
			    !!test_and_clear_bit(WL1271_FLAG_STA_ASSOCIATED,
						 &wl->flags);
2993
			clear_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags);
J
Juuso Oikarinen 已提交
2994
			wl->aid = 0;
2995

2996 2997 2998 2999
			/* free probe-request template */
			dev_kfree_skb(wl->probereq);
			wl->probereq = NULL;

3000
			/* re-enable dynamic ps - just in case */
3001
			ieee80211_enable_dyn_ps(wl->vif);
3002

3003 3004
			/* revert back to minimum rates for the current band */
			wl1271_set_band_rate(wl);
A
Arik Nemtsov 已提交
3005
			wl->basic_rate = wl1271_tx_min_rate_get(wl);
3006
			ret = wl1271_acx_sta_rate_policies(wl);
3007
			if (ret < 0)
3008
				goto out;
3009

3010 3011
			/* disable connection monitor features */
			ret = wl1271_acx_conn_monit_params(wl, false);
3012 3013 3014

			/* Disable the keep-alive feature */
			ret = wl1271_acx_keep_alive_mode(wl, false);
3015
			if (ret < 0)
3016
				goto out;
3017 3018

			/* restore the bssid filter and go to dummy bssid */
3019 3020 3021 3022
			if (was_assoc) {
				wl1271_unjoin(wl);
				wl1271_dummy_join(wl);
			}
L
Luciano Coelho 已提交
3023 3024 3025
		}
	}

3026 3027 3028
	ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
	if (ret < 0)
		goto out;
L
Luciano Coelho 已提交
3029

3030 3031 3032 3033
	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 已提交
3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044
		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);
3045
				goto out;
E
Eliad Peller 已提交
3046 3047 3048
			}

			ret = wl1271_acx_arp_ip_filter(wl,
E
Eliad Peller 已提交
3049
				ACX_ARP_FILTER_ARP_FILTERING,
E
Eliad Peller 已提交
3050 3051 3052
				addr);
		} else
			ret = wl1271_acx_arp_ip_filter(wl, 0, addr);
3053 3054

		if (ret < 0)
3055
			goto out;
3056 3057
	}

J
Juuso Oikarinen 已提交
3058
	if (do_join) {
3059
		ret = wl1271_join(wl, set_assoc);
J
Juuso Oikarinen 已提交
3060 3061
		if (ret < 0) {
			wl1271_warning("cmd join failed %d", ret);
3062
			goto out;
J
Juuso Oikarinen 已提交
3063
		}
3064 3065
	}

3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086
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;

3087
	ret = wl1271_ps_elp_wakeup(wl);
3088 3089 3090 3091 3092 3093 3094 3095
	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 已提交
3096 3097 3098 3099 3100 3101
	wl1271_ps_elp_sleep(wl);

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

K
Kalle Valo 已提交
3102 3103 3104 3105
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 已提交
3106
	u8 ps_scheme;
3107
	int ret = 0;
K
Kalle Valo 已提交
3108 3109 3110 3111 3112

	mutex_lock(&wl->mutex);

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

K
Kalle Valo 已提交
3113 3114 3115 3116 3117
	if (params->uapsd)
		ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
	else
		ps_scheme = CONF_PS_SCHEME_LEGACY;

3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140
	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;
3141 3142
		goto out;
	}
3143

3144 3145 3146
	ret = wl1271_ps_elp_wakeup(wl);
	if (ret < 0)
		goto out;
3147

3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162
	/*
	 * 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 已提交
3163 3164

out_sleep:
3165
	wl1271_ps_elp_sleep(wl);
K
Kalle Valo 已提交
3166 3167 3168 3169 3170 3171 3172

out:
	mutex_unlock(&wl->mutex);

	return ret;
}

J
Juuso Oikarinen 已提交
3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183
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);

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

3187
	ret = wl1271_ps_elp_wakeup(wl);
J
Juuso Oikarinen 已提交
3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201
	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 已提交
3202

3203 3204 3205 3206 3207
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;
3208

3209 3210
	if (idx != 0)
		return -ENOENT;
3211

3212 3213 3214
	survey->channel = conf->channel;
	survey->filled = SURVEY_INFO_NOISE_DBM;
	survey->noise = wl->noise;
3215

3216 3217 3218
	return 0;
}

3219
static int wl1271_allocate_sta(struct wl1271 *wl,
3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235
			     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;
3236
	memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
3237 3238 3239
	return 0;
}

3240
static void wl1271_free_sta(struct wl1271 *wl, u8 hlid)
3241 3242 3243
{
	int id = hlid - WL1271_AP_STA_HLID_START;

3244 3245 3246
	if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
		return;

3247
	__clear_bit(id, wl->ap_hlid_map);
3248
	memset(wl->links[hlid].addr, 0, ETH_ALEN);
3249
	wl1271_tx_reset_link_queues(wl, hlid);
3250 3251
	__clear_bit(hlid, &wl->ap_ps_map);
	__clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271
}

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

3272
	ret = wl1271_allocate_sta(wl, sta, &hlid);
3273 3274 3275
	if (ret < 0)
		goto out;

3276
	ret = wl1271_ps_elp_wakeup(wl);
3277
	if (ret < 0)
3278
		goto out_free_sta;
3279 3280 3281 3282 3283 3284 3285 3286

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

out_sleep:
	wl1271_ps_elp_sleep(wl);

3287 3288 3289 3290
out_free_sta:
	if (ret < 0)
		wl1271_free_sta(wl, hlid);

3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318
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;

3319
	ret = wl1271_ps_elp_wakeup(wl);
3320 3321 3322 3323 3324 3325 3326
	if (ret < 0)
		goto out;

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

3327
	wl1271_free_sta(wl, wl_sta->hlid);
3328 3329 3330 3331 3332 3333 3334 3335 3336

out_sleep:
	wl1271_ps_elp_sleep(wl);

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

3337 3338 3339 3340 3341
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 已提交
3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352
{
	struct wl1271 *wl = hw->priv;
	int ret;

	mutex_lock(&wl->mutex);

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

3353
	ret = wl1271_ps_elp_wakeup(wl);
L
Levi, Shahar 已提交
3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397
	if (ret < 0)
		goto out;

	switch (action) {
	case IEEE80211_AMPDU_RX_START:
		if (wl->ba_support) {
			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;
}

3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419
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 */
	ret = (wl->tx_queue_count > 0) || (wl->tx_frames_cnt > 0);

	/* 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 已提交
3420 3421 3422
/* can't be const, mac80211 writes to this */
static struct ieee80211_rate wl1271_rates[] = {
	{ .bitrate = 10,
3423 3424
	  .hw_value = CONF_HW_BIT_RATE_1MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
L
Luciano Coelho 已提交
3425
	{ .bitrate = 20,
3426 3427
	  .hw_value = CONF_HW_BIT_RATE_2MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
L
Luciano Coelho 已提交
3428 3429
	  .flags = IEEE80211_RATE_SHORT_PREAMBLE },
	{ .bitrate = 55,
3430 3431
	  .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
L
Luciano Coelho 已提交
3432 3433
	  .flags = IEEE80211_RATE_SHORT_PREAMBLE },
	{ .bitrate = 110,
3434 3435
	  .hw_value = CONF_HW_BIT_RATE_11MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
L
Luciano Coelho 已提交
3436 3437
	  .flags = IEEE80211_RATE_SHORT_PREAMBLE },
	{ .bitrate = 60,
3438 3439
	  .hw_value = CONF_HW_BIT_RATE_6MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
L
Luciano Coelho 已提交
3440
	{ .bitrate = 90,
3441 3442
	  .hw_value = CONF_HW_BIT_RATE_9MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
L
Luciano Coelho 已提交
3443
	{ .bitrate = 120,
3444 3445
	  .hw_value = CONF_HW_BIT_RATE_12MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
L
Luciano Coelho 已提交
3446
	{ .bitrate = 180,
3447 3448
	  .hw_value = CONF_HW_BIT_RATE_18MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
L
Luciano Coelho 已提交
3449
	{ .bitrate = 240,
3450 3451
	  .hw_value = CONF_HW_BIT_RATE_24MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
L
Luciano Coelho 已提交
3452
	{ .bitrate = 360,
3453 3454
	 .hw_value = CONF_HW_BIT_RATE_36MBPS,
	 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
L
Luciano Coelho 已提交
3455
	{ .bitrate = 480,
3456 3457
	  .hw_value = CONF_HW_BIT_RATE_48MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
L
Luciano Coelho 已提交
3458
	{ .bitrate = 540,
3459 3460
	  .hw_value = CONF_HW_BIT_RATE_54MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
L
Luciano Coelho 已提交
3461 3462
};

3463
/* can't be const, mac80211 writes to this */
L
Luciano Coelho 已提交
3464
static struct ieee80211_channel wl1271_channels[] = {
3465
	{ .hw_value = 1, .center_freq = 2412, .max_power = 25 },
3466
	{ .hw_value = 2, .center_freq = 2417, .max_power = 25 },
3467 3468 3469
	{ .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 },
3470
	{ .hw_value = 6, .center_freq = 2437, .max_power = 25 },
3471 3472 3473
	{ .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 },
3474
	{ .hw_value = 10, .center_freq = 2457, .max_power = 25 },
3475 3476 3477
	{ .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 },
3478
	{ .hw_value = 14, .center_freq = 2484, .max_power = 25 },
L
Luciano Coelho 已提交
3479 3480
};

3481
/* mapping to indexes for wl1271_rates */
3482
static const u8 wl1271_rate_to_idx_2ghz[] = {
3483
	/* MCS rates are used only with 11n */
3484 3485 3486 3487 3488 3489 3490 3491
	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 */
3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510

	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 已提交
3511 3512 3513
/* 11n STA capabilities */
#define HW_RX_HIGHEST_RATE	72

S
Shahar Levi 已提交
3514 3515
#ifdef CONFIG_WL12XX_HT
#define WL12XX_HT_CAP { \
3516 3517
	.cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | \
	       (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT), \
S
Shahar Levi 已提交
3518 3519 3520 3521 3522 3523 3524 3525 3526
	.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, \
		}, \
}
3527
#else
S
Shahar Levi 已提交
3528
#define WL12XX_HT_CAP { \
3529 3530 3531
	.ht_supported = false, \
}
#endif
S
Shahar Levi 已提交
3532

L
Luciano Coelho 已提交
3533 3534 3535 3536 3537 3538
/* 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 已提交
3539
	.ht_cap	= WL12XX_HT_CAP,
L
Luciano Coelho 已提交
3540 3541
};

3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569
/* 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, },
};

3570
/* 5 GHz band channels for WL1273 */
3571
static struct ieee80211_channel wl1271_channels_5ghz[] = {
3572
	{ .hw_value = 7, .center_freq = 5035},
3573 3574 3575 3576
	{ .hw_value = 8, .center_freq = 5040},
	{ .hw_value = 9, .center_freq = 5045},
	{ .hw_value = 11, .center_freq = 5055},
	{ .hw_value = 12, .center_freq = 5060},
3577
	{ .hw_value = 16, .center_freq = 5080},
3578 3579 3580 3581
	{ .hw_value = 34, .center_freq = 5170},
	{ .hw_value = 36, .center_freq = 5180},
	{ .hw_value = 38, .center_freq = 5190},
	{ .hw_value = 40, .center_freq = 5200},
3582
	{ .hw_value = 42, .center_freq = 5210},
3583 3584 3585 3586
	{ .hw_value = 44, .center_freq = 5220},
	{ .hw_value = 46, .center_freq = 5230},
	{ .hw_value = 48, .center_freq = 5240},
	{ .hw_value = 52, .center_freq = 5260},
3587
	{ .hw_value = 56, .center_freq = 5280},
3588 3589 3590 3591
	{ .hw_value = 60, .center_freq = 5300},
	{ .hw_value = 64, .center_freq = 5320},
	{ .hw_value = 100, .center_freq = 5500},
	{ .hw_value = 104, .center_freq = 5520},
3592
	{ .hw_value = 108, .center_freq = 5540},
3593 3594 3595 3596
	{ .hw_value = 112, .center_freq = 5560},
	{ .hw_value = 116, .center_freq = 5580},
	{ .hw_value = 120, .center_freq = 5600},
	{ .hw_value = 124, .center_freq = 5620},
3597
	{ .hw_value = 128, .center_freq = 5640},
3598 3599 3600 3601
	{ .hw_value = 132, .center_freq = 5660},
	{ .hw_value = 136, .center_freq = 5680},
	{ .hw_value = 140, .center_freq = 5700},
	{ .hw_value = 149, .center_freq = 5745},
3602
	{ .hw_value = 153, .center_freq = 5765},
3603 3604
	{ .hw_value = 157, .center_freq = 5785},
	{ .hw_value = 161, .center_freq = 5805},
3605 3606 3607
	{ .hw_value = 165, .center_freq = 5825},
};

3608
/* mapping to indexes for wl1271_rates_5ghz */
3609
static const u8 wl1271_rate_to_idx_5ghz[] = {
3610
	/* MCS rates are used only with 11n */
3611 3612 3613 3614 3615 3616 3617 3618
	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 */
3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636

	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    */
};
3637 3638 3639 3640 3641 3642

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 已提交
3643
	.ht_cap	= WL12XX_HT_CAP,
3644 3645
};

3646
static const u8 *wl1271_band_rate_to_idx[] = {
3647 3648 3649 3650
	[IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
	[IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
};

L
Luciano Coelho 已提交
3651 3652 3653 3654 3655
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,
3656
#ifdef CONFIG_PM
3657 3658
	.suspend = wl1271_op_suspend,
	.resume = wl1271_op_resume,
3659
#endif
L
Luciano Coelho 已提交
3660
	.config = wl1271_op_config,
3661
	.prepare_multicast = wl1271_op_prepare_multicast,
L
Luciano Coelho 已提交
3662 3663 3664 3665
	.configure_filter = wl1271_op_configure_filter,
	.tx = wl1271_op_tx,
	.set_key = wl1271_op_set_key,
	.hw_scan = wl1271_op_hw_scan,
3666 3667
	.sched_scan_start = wl1271_op_sched_scan_start,
	.sched_scan_stop = wl1271_op_sched_scan_stop,
L
Luciano Coelho 已提交
3668
	.bss_info_changed = wl1271_op_bss_info_changed,
3669
	.set_frag_threshold = wl1271_op_set_frag_threshold,
L
Luciano Coelho 已提交
3670
	.set_rts_threshold = wl1271_op_set_rts_threshold,
K
Kalle Valo 已提交
3671
	.conf_tx = wl1271_op_conf_tx,
J
Juuso Oikarinen 已提交
3672
	.get_tsf = wl1271_op_get_tsf,
3673
	.get_survey = wl1271_op_get_survey,
3674 3675
	.sta_add = wl1271_op_sta_add,
	.sta_remove = wl1271_op_sta_remove,
L
Levi, Shahar 已提交
3676
	.ampdu_action = wl1271_op_ampdu_action,
3677
	.tx_frames_pending = wl1271_tx_frames_pending,
K
Kalle Valo 已提交
3678
	CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
L
Luciano Coelho 已提交
3679 3680
};

3681

3682
u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
3683 3684 3685
{
	u8 idx;

3686
	BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
3687 3688 3689 3690 3691 3692

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

3693
	idx = wl1271_band_rate_to_idx[band][rate];
3694 3695 3696 3697 3698 3699 3700 3701
	if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
		wl1271_error("Unsupported RX rate from HW: %d", rate);
		return 0;
	}

	return idx;
}

3702 3703 3704 3705 3706 3707 3708
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;

3709
	len = PAGE_SIZE;
3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727

	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 已提交
3728
	ret = kstrtoul(buf, 10, &res);
3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745
	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;

3746
	ret = wl1271_ps_elp_wakeup(wl);
3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761
	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);

3762 3763 3764 3765 3766 3767 3768
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;

3769
	len = PAGE_SIZE;
3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783

	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;
}

static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
		   wl1271_sysfs_show_hw_pg_ver, NULL);

3784
int wl1271_register_hw(struct wl1271 *wl)
L
Luciano Coelho 已提交
3785 3786 3787 3788 3789 3790
{
	int ret;

	if (wl->mac80211_registered)
		return 0;

3791 3792
	ret = wl1271_fetch_nvs(wl);
	if (ret == 0) {
3793 3794 3795 3796 3797
		/* 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;
3798 3799 3800 3801 3802 3803 3804 3805 3806

		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 已提交
3807 3808 3809 3810 3811 3812 3813 3814 3815 3816
	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;

3817 3818
	wl1271_debugfs_init(wl);

3819 3820
	register_netdevice_notifier(&wl1271_dev_notifier);

L
Luciano Coelho 已提交
3821 3822 3823 3824
	wl1271_notice("loaded");

	return 0;
}
3825
EXPORT_SYMBOL_GPL(wl1271_register_hw);
L
Luciano Coelho 已提交
3826

3827 3828
void wl1271_unregister_hw(struct wl1271 *wl)
{
3829 3830 3831
	if (wl->state == WL1271_STATE_PLT)
		__wl1271_plt_stop(wl);

3832
	unregister_netdevice_notifier(&wl1271_dev_notifier);
3833 3834 3835 3836 3837 3838
	ieee80211_unregister_hw(wl->hw);
	wl->mac80211_registered = false;

}
EXPORT_SYMBOL_GPL(wl1271_unregister_hw);

3839
int wl1271_init_ieee80211(struct wl1271 *wl)
L
Luciano Coelho 已提交
3840
{
3841 3842 3843 3844 3845 3846 3847 3848
	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,
	};

3849 3850 3851
	/* 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 已提交
3852 3853 3854 3855

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

	wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
3859
		IEEE80211_HW_BEACON_FILTER |
3860
		IEEE80211_HW_SUPPORTS_PS |
K
Kalle Valo 已提交
3861
		IEEE80211_HW_SUPPORTS_UAPSD |
3862
		IEEE80211_HW_HAS_RATE_CONTROL |
3863
		IEEE80211_HW_CONNECTION_MONITOR |
3864
		IEEE80211_HW_SUPPORTS_CQM_RSSI |
3865
		IEEE80211_HW_REPORTS_TX_ACK_STATUS |
3866
		IEEE80211_HW_SPECTRUM_MGMT |
3867
		IEEE80211_HW_AP_LINK_PS;
L
Luciano Coelho 已提交
3868

3869 3870 3871
	wl->hw->wiphy->cipher_suites = cipher_suites;
	wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);

3872
	wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
A
Arik Nemtsov 已提交
3873
		BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP);
L
Luciano Coelho 已提交
3874
	wl->hw->wiphy->max_scan_ssids = 1;
3875 3876 3877 3878 3879 3880 3881
	/*
	 * 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);
3882

3883 3884 3885 3886
	/* 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);
3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899
	/*
	 * 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];
3900

K
Kalle Valo 已提交
3901
	wl->hw->queues = 4;
J
Juuso Oikarinen 已提交
3902
	wl->hw->max_rates = 1;
K
Kalle Valo 已提交
3903

3904 3905
	wl->hw->wiphy->reg_notifier = wl1271_reg_notify;

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

3908 3909
	wl->hw->sta_data_size = sizeof(struct wl1271_station);

3910 3911
	wl->hw->max_rx_aggregation_subframes = 8;

L
Luciano Coelho 已提交
3912 3913
	return 0;
}
3914
EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
L
Luciano Coelho 已提交
3915 3916

#define WL1271_DEFAULT_CHANNEL 0
3917

3918
struct ieee80211_hw *wl1271_alloc_hw(void)
L
Luciano Coelho 已提交
3919 3920
{
	struct ieee80211_hw *hw;
3921
	struct platform_device *plat_dev = NULL;
L
Luciano Coelho 已提交
3922
	struct wl1271 *wl;
3923
	int i, j, ret;
3924
	unsigned int order;
L
Luciano Coelho 已提交
3925 3926 3927 3928

	hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
	if (!hw) {
		wl1271_error("could not alloc ieee80211_hw");
3929
		ret = -ENOMEM;
3930 3931 3932
		goto err_hw_alloc;
	}

3933
	plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
3934 3935 3936 3937
	if (!plat_dev) {
		wl1271_error("could not allocate platform_device");
		ret = -ENOMEM;
		goto err_plat_alloc;
L
Luciano Coelho 已提交
3938 3939 3940 3941 3942
	}

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

3943 3944
	INIT_LIST_HEAD(&wl->list);

L
Luciano Coelho 已提交
3945
	wl->hw = hw;
3946
	wl->plat_dev = plat_dev;
L
Luciano Coelho 已提交
3947

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

3951 3952 3953 3954
	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]);

3955 3956 3957
	skb_queue_head_init(&wl->deferred_rx_queue);
	skb_queue_head_init(&wl->deferred_tx_queue);

3958
	INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
3959
	INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
3960
	INIT_WORK(&wl->netstack_work, wl1271_netstack_work);
3961 3962 3963
	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);
L
Luciano Coelho 已提交
3964
	wl->channel = WL1271_DEFAULT_CHANNEL;
3965
	wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
L
Luciano Coelho 已提交
3966 3967
	wl->default_key = 0;
	wl->rx_counter = 0;
3968 3969
	wl->rx_config = WL1271_DEFAULT_STA_RX_CONFIG;
	wl->rx_filter = WL1271_DEFAULT_STA_RX_FILTER;
3970
	wl->psm_entry_retry = 0;
L
Luciano Coelho 已提交
3971
	wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
3972
	wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
3973
	wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
3974
	wl->rate_set = CONF_TX_RATE_MASK_BASIC;
3975
	wl->band = IEEE80211_BAND_2GHZ;
3976
	wl->vif = NULL;
3977
	wl->flags = 0;
3978
	wl->sg_enabled = true;
3979
	wl->hw_pg_ver = -1;
3980 3981 3982
	wl->bss_type = MAX_BSS_TYPE;
	wl->set_bss_type = MAX_BSS_TYPE;
	wl->fw_bss_type = MAX_BSS_TYPE;
3983
	wl->last_tx_hlid = 0;
3984 3985
	wl->ap_ps_map = 0;
	wl->ap_fw_ps_map = 0;
3986
	wl->quirks = 0;
3987
	wl->platform_quirks = 0;
3988
	wl->sched_scanning = false;
L
Luciano Coelho 已提交
3989

3990
	memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
J
Juuso Oikarinen 已提交
3991
	for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
L
Luciano Coelho 已提交
3992 3993 3994 3995 3996 3997 3998
		wl->tx_frames[i] = NULL;

	spin_lock_init(&wl->wl_lock);

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

3999 4000 4001
	/* Apply default driver configuration. */
	wl1271_conf_init(wl);

4002 4003 4004 4005 4006 4007 4008
	order = get_order(WL1271_AGGR_BUFFER_SIZE);
	wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
	if (!wl->aggr_buf) {
		ret = -ENOMEM;
		goto err_hw;
	}

4009 4010 4011 4012 4013 4014
	wl->dummy_packet = wl12xx_alloc_dummy_packet(wl);
	if (!wl->dummy_packet) {
		ret = -ENOMEM;
		goto err_aggr;
	}

4015
	/* Register platform device */
4016
	ret = platform_device_register(wl->plat_dev);
4017 4018
	if (ret) {
		wl1271_error("couldn't register platform device");
4019
		goto err_dummy_packet;
4020
	}
4021
	dev_set_drvdata(&wl->plat_dev->dev, wl);
4022

4023
	/* Create sysfs file to control bt coex state */
4024
	ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
4025 4026 4027 4028
	if (ret < 0) {
		wl1271_error("failed to create sysfs file bt_coex_state");
		goto err_platform;
	}
4029

4030 4031 4032 4033 4034 4035 4036
	/* 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;
	}

4037
	return hw;
4038

4039 4040 4041
err_bt_coex_state:
	device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);

4042
err_platform:
4043
	platform_device_unregister(wl->plat_dev);
4044

4045 4046 4047
err_dummy_packet:
	dev_kfree_skb(wl->dummy_packet);

4048 4049 4050
err_aggr:
	free_pages((unsigned long)wl->aggr_buf, order);

4051
err_hw:
4052 4053 4054 4055 4056 4057 4058
	wl1271_debugfs_exit(wl);
	kfree(plat_dev);

err_plat_alloc:
	ieee80211_free_hw(hw);

err_hw_alloc:
4059 4060

	return ERR_PTR(ret);
4061
}
4062
EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
4063 4064 4065

int wl1271_free_hw(struct wl1271 *wl)
{
4066
	platform_device_unregister(wl->plat_dev);
4067
	dev_kfree_skb(wl->dummy_packet);
4068 4069
	free_pages((unsigned long)wl->aggr_buf,
			get_order(WL1271_AGGR_BUFFER_SIZE));
4070
	kfree(wl->plat_dev);
4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085

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

	ieee80211_free_hw(wl->hw);

	return 0;
}
4086 4087
EXPORT_SYMBOL_GPL(wl1271_free_hw);

4088
u32 wl12xx_debug_level = DEBUG_NONE;
4089
EXPORT_SYMBOL_GPL(wl12xx_debug_level);
4090
module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
4091 4092
MODULE_PARM_DESC(debug_level, "wl12xx debugging level");

4093
MODULE_LICENSE("GPL");
4094
MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
4095
MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");