iwl-drv.c 42.1 KB
Newer Older
1 2 3 4 5 6 7
/******************************************************************************
 *
 * This file is provided under a dual BSD/GPLv2 license.  When using or
 * redistributing this file, you may do so under either license.
 *
 * GPL LICENSE SUMMARY
 *
8
 * Copyright(c) 2007 - 2014 Intel Corporation. All rights reserved.
9
 * Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH
10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License 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 Street, Fifth Floor, Boston, MA 02110,
 * USA
 *
 * The full GNU General Public License is included in this distribution
26
 * in the file called COPYING.
27 28 29 30 31 32 33
 *
 * Contact Information:
 *  Intel Linux Wireless <ilw@linux.intel.com>
 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
 *
 * BSD LICENSE
 *
34
 * Copyright(c) 2005 - 2014 Intel Corporation. All rights reserved.
35
 * Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH
36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *  * Neither the name Intel Corporation nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *****************************************************************************/
#include <linux/completion.h>
66 67 68
#include <linux/dma-mapping.h>
#include <linux/firmware.h>
#include <linux/module.h>
J
Johannes Berg 已提交
69
#include <linux/vmalloc.h>
70 71

#include "iwl-drv.h"
72
#include "iwl-csr.h"
73
#include "iwl-debug.h"
74
#include "iwl-trans.h"
75
#include "iwl-op-mode.h"
76
#include "iwl-agn-hw.h"
77 78
#include "iwl-fw.h"
#include "iwl-config.h"
79
#include "iwl-modparams.h"
80

81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104
/******************************************************************************
 *
 * module boiler plate
 *
 ******************************************************************************/

/*
 * module name, copyright, version, etc.
 */
#define DRV_DESCRIPTION	"Intel(R) Wireless WiFi driver for Linux"

#ifdef CONFIG_IWLWIFI_DEBUG
#define VD "d"
#else
#define VD
#endif

#define DRV_VERSION     IWLWIFI_VERSION VD

MODULE_DESCRIPTION(DRV_DESCRIPTION);
MODULE_VERSION(DRV_VERSION);
MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR);
MODULE_LICENSE("GPL");

105 106 107 108
#ifdef CONFIG_IWLWIFI_DEBUGFS
static struct dentry *iwl_dbgfs_root;
#endif

J
Johannes Berg 已提交
109 110
/**
 * struct iwl_drv - drv common data
111
 * @list: list of drv structures using this opmode
J
Johannes Berg 已提交
112 113
 * @fw: the iwl_fw structure
 * @op_mode: the running op_mode
114
 * @trans: transport layer
115
 * @dev: for debug prints only
116
 * @cfg: configuration struct
J
Johannes Berg 已提交
117 118 119 120 121
 * @fw_index: firmware revision to try loading
 * @firmware_name: composite filename of ucode file to load
 * @request_firmware_complete: the firmware has been obtained from user space
 */
struct iwl_drv {
122
	struct list_head list;
J
Johannes Berg 已提交
123 124 125
	struct iwl_fw fw;

	struct iwl_op_mode *op_mode;
126
	struct iwl_trans *trans;
127
	struct device *dev;
128
	const struct iwl_cfg *cfg;
J
Johannes Berg 已提交
129 130

	int fw_index;                   /* firmware we're trying to load */
131
	char firmware_name[32];         /* name of firmware file to load */
J
Johannes Berg 已提交
132 133

	struct completion request_firmware_complete;
134 135 136 137 138 139

#ifdef CONFIG_IWLWIFI_DEBUGFS
	struct dentry *dbgfs_drv;
	struct dentry *dbgfs_trans;
	struct dentry *dbgfs_op_mode;
#endif
J
Johannes Berg 已提交
140 141
};

J
Johannes Berg 已提交
142 143 144 145
enum {
	DVM_OP_MODE =	0,
	MVM_OP_MODE =	1,
};
J
Johannes Berg 已提交
146

J
Johannes Berg 已提交
147 148
/* Protects the table contents, i.e. the ops pointer & drv list */
static struct mutex iwlwifi_opmode_table_mtx;
149 150 151 152 153
static struct iwlwifi_opmode_table {
	const char *name;			/* name: iwldvm, iwlmvm, etc */
	const struct iwl_op_mode_ops *ops;	/* pointer to op_mode ops */
	struct list_head drv;		/* list of devices using this op_mode */
} iwlwifi_opmode_table[] = {		/* ops set when driver is initialized */
J
Johannes Berg 已提交
154 155
	[DVM_OP_MODE] = { .name = "iwldvm", .ops = NULL },
	[MVM_OP_MODE] = { .name = "iwlmvm", .ops = NULL },
156
};
J
Johannes Berg 已提交
157

158 159
#define IWL_DEFAULT_SCAN_CHANNELS 40

160 161 162 163 164 165 166 167 168 169
/*
 * struct fw_sec: Just for the image parsing proccess.
 * For the fw storage we are using struct fw_desc.
 */
struct fw_sec {
	const void *data;		/* the sec data */
	size_t size;			/* section size */
	u32 offset;			/* offset of writing in the device */
};

J
Johannes Berg 已提交
170
static void iwl_free_fw_desc(struct iwl_drv *drv, struct fw_desc *desc)
171
{
J
Johannes Berg 已提交
172 173
	vfree(desc->data);
	desc->data = NULL;
174 175 176
	desc->len = 0;
}

J
Johannes Berg 已提交
177
static void iwl_free_fw_img(struct iwl_drv *drv, struct fw_img *img)
178
{
D
David Spinadel 已提交
179 180 181
	int i;
	for (i = 0; i < IWL_UCODE_SECTION_MAX; i++)
		iwl_free_fw_desc(drv, &img->sec[i]);
182 183
}

J
Johannes Berg 已提交
184
static void iwl_dealloc_ucode(struct iwl_drv *drv)
185
{
D
David Spinadel 已提交
186 187 188
	int i;
	for (i = 0; i < IWL_UCODE_TYPE_MAX; i++)
		iwl_free_fw_img(drv, drv->fw.img + i);
189 190
}

J
Johannes Berg 已提交
191
static int iwl_alloc_fw_desc(struct iwl_drv *drv, struct fw_desc *desc,
J
Johannes Berg 已提交
192
			     struct fw_sec *sec)
193
{
J
Johannes Berg 已提交
194 195 196 197 198
	void *data;

	desc->data = NULL;

	if (!sec || !sec->size)
199 200
		return -EINVAL;

J
Johannes Berg 已提交
201 202
	data = vmalloc(sec->size);
	if (!data)
203 204
		return -ENOMEM;

205 206
	desc->len = sec->size;
	desc->offset = sec->offset;
J
Johannes Berg 已提交
207 208 209
	memcpy(data, sec->data, desc->len);
	desc->data = data;

210 211 212
	return 0;
}

213 214
static void iwl_req_fw_callback(const struct firmware *ucode_raw,
				void *context);
215 216 217 218

#define UCODE_EXPERIMENTAL_INDEX	100
#define UCODE_EXPERIMENTAL_TAG		"exp"

J
Johannes Berg 已提交
219
static int iwl_request_firmware(struct iwl_drv *drv, bool first)
220
{
221
	const char *name_pre = drv->cfg->fw_name_pre;
222 223 224 225
	char tag[8];

	if (first) {
#ifdef CONFIG_IWLWIFI_DEBUG_EXPERIMENTAL_UCODE
J
Johannes Berg 已提交
226
		drv->fw_index = UCODE_EXPERIMENTAL_INDEX;
227
		strcpy(tag, UCODE_EXPERIMENTAL_TAG);
J
Johannes Berg 已提交
228
	} else if (drv->fw_index == UCODE_EXPERIMENTAL_INDEX) {
229
#endif
230
		drv->fw_index = drv->cfg->ucode_api_max;
J
Johannes Berg 已提交
231
		sprintf(tag, "%d", drv->fw_index);
232
	} else {
J
Johannes Berg 已提交
233 234
		drv->fw_index--;
		sprintf(tag, "%d", drv->fw_index);
235 236
	}

237
	if (drv->fw_index < drv->cfg->ucode_api_min) {
J
Johannes Berg 已提交
238
		IWL_ERR(drv, "no suitable firmware found!\n");
239 240 241
		return -ENOENT;
	}

242 243
	snprintf(drv->firmware_name, sizeof(drv->firmware_name), "%s%s.ucode",
		 name_pre, tag);
244

245 246 247
	/*
	 * Starting 8000B - FW name format has changed. This overwrites the
	 * previous name and uses the new format.
248 249 250
	 *
	 * TODO:
	 * Once there is only one supported step for 8000 family - delete this!
251 252 253 254 255 256 257 258 259 260
	 */
	if (drv->trans->cfg->device_family == IWL_DEVICE_FAMILY_8000) {
		char rev_step[2] = {
			'A' + CSR_HW_REV_STEP(drv->trans->hw_rev), 0
		};

		/* A-step doesn't have an indication */
		if (CSR_HW_REV_STEP(drv->trans->hw_rev) == SILICON_A_STEP)
			rev_step[0] = 0;

261 262 263 264 265 266 267
		/*
		 * If hw_rev wasn't set yet - default as B-step. If it IS A-step
		 * we'll reload that FW later instead.
		 */
		if (drv->trans->hw_rev == 0)
			rev_step[0] = 'B';

268 269 270 271
		snprintf(drv->firmware_name, sizeof(drv->firmware_name),
			 "%s%s-%s.ucode", name_pre, rev_step, tag);
	}

J
Johannes Berg 已提交
272 273
	IWL_DEBUG_INFO(drv, "attempting to load firmware %s'%s'\n",
		       (drv->fw_index == UCODE_EXPERIMENTAL_INDEX)
274
				? "EXPERIMENTAL " : "",
J
Johannes Berg 已提交
275
		       drv->firmware_name);
276

J
Johannes Berg 已提交
277
	return request_firmware_nowait(THIS_MODULE, 1, drv->firmware_name,
278
				       drv->trans->dev,
279
				       GFP_KERNEL, drv, iwl_req_fw_callback);
280 281
}

282
struct fw_img_parsing {
D
David Spinadel 已提交
283
	struct fw_sec sec[IWL_UCODE_SECTION_MAX];
284 285 286
	int sec_counter;
};

287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302
/*
 * struct fw_sec_parsing: to extract fw section and it's offset from tlv
 */
struct fw_sec_parsing {
	__le32 offset;
	const u8 data[];
} __packed;

/**
 * struct iwl_tlv_calib_data - parse the default calib data from TLV
 *
 * @ucode_type: the uCode to which the following default calib relates.
 * @calib: default calibrations.
 */
struct iwl_tlv_calib_data {
	__le32 ucode_type;
J
Johannes Berg 已提交
303
	struct iwl_tlv_calib_ctrl calib;
304 305
} __packed;

306 307
struct iwl_firmware_pieces {
	struct fw_img_parsing img[IWL_UCODE_TYPE_MAX];
308 309 310 311 312

	u32 init_evtlog_ptr, init_evtlog_size, init_errlog_ptr;
	u32 inst_evtlog_ptr, inst_evtlog_size, inst_errlog_ptr;
};

313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354
/*
 * These functions are just to extract uCode section data from the pieces
 * structure.
 */
static struct fw_sec *get_sec(struct iwl_firmware_pieces *pieces,
			      enum iwl_ucode_type type,
			      int  sec)
{
	return &pieces->img[type].sec[sec];
}

static void set_sec_data(struct iwl_firmware_pieces *pieces,
			 enum iwl_ucode_type type,
			 int sec,
			 const void *data)
{
	pieces->img[type].sec[sec].data = data;
}

static void set_sec_size(struct iwl_firmware_pieces *pieces,
			 enum iwl_ucode_type type,
			 int sec,
			 size_t size)
{
	pieces->img[type].sec[sec].size = size;
}

static size_t get_sec_size(struct iwl_firmware_pieces *pieces,
			   enum iwl_ucode_type type,
			   int sec)
{
	return pieces->img[type].sec[sec].size;
}

static void set_sec_offset(struct iwl_firmware_pieces *pieces,
			   enum iwl_ucode_type type,
			   int sec,
			   u32 offset)
{
	pieces->img[type].sec[sec].offset = offset;
}

355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389
static int iwl_store_cscheme(struct iwl_fw *fw, const u8 *data, const u32 len)
{
	int i, j;
	struct iwl_fw_cscheme_list *l = (struct iwl_fw_cscheme_list *)data;
	struct iwl_fw_cipher_scheme *fwcs;
	struct ieee80211_cipher_scheme *cs;
	u32 cipher;

	if (len < sizeof(*l) ||
	    len < sizeof(l->size) + l->size * sizeof(l->cs[0]))
		return -EINVAL;

	for (i = 0, j = 0; i < IWL_UCODE_MAX_CS && i < l->size; i++) {
		fwcs = &l->cs[j];
		cipher = le32_to_cpu(fwcs->cipher);

		/* we skip schemes with zero cipher suite selector */
		if (!cipher)
			continue;

		cs = &fw->cs[j++];
		cs->cipher = cipher;
		cs->iftype = BIT(NL80211_IFTYPE_STATION);
		cs->hdr_len = fwcs->hdr_len;
		cs->pn_len = fwcs->pn_len;
		cs->pn_off = fwcs->pn_off;
		cs->key_idx_off = fwcs->key_idx_off;
		cs->key_idx_mask = fwcs->key_idx_mask;
		cs->key_idx_shift = fwcs->key_idx_shift;
		cs->mic_len = fwcs->mic_len;
	}

	return 0;
}

390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410
/*
 * Gets uCode section from tlv.
 */
static int iwl_store_ucode_sec(struct iwl_firmware_pieces *pieces,
			       const void *data, enum iwl_ucode_type type,
			       int size)
{
	struct fw_img_parsing *img;
	struct fw_sec *sec;
	struct fw_sec_parsing *sec_parse;

	if (WARN_ON(!pieces || !data || type >= IWL_UCODE_TYPE_MAX))
		return -1;

	sec_parse = (struct fw_sec_parsing *)data;

	img = &pieces->img[type];
	sec = &img->sec[img->sec_counter];

	sec->offset = le32_to_cpu(sec_parse->offset);
	sec->data = sec_parse->data;
411
	sec->size = size - sizeof(sec_parse->offset);
412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427

	++img->sec_counter;

	return 0;
}

static int iwl_set_default_calib(struct iwl_drv *drv, const u8 *data)
{
	struct iwl_tlv_calib_data *def_calib =
					(struct iwl_tlv_calib_data *)data;
	u32 ucode_type = le32_to_cpu(def_calib->ucode_type);
	if (ucode_type >= IWL_UCODE_TYPE_MAX) {
		IWL_ERR(drv, "Wrong ucode_type %u for default calibration.\n",
			ucode_type);
		return -EINVAL;
	}
J
Johannes Berg 已提交
428 429 430 431 432
	drv->fw.default_calib[ucode_type].flow_trigger =
		def_calib->calib.flow_trigger;
	drv->fw.default_calib[ucode_type].event_trigger =
		def_calib->calib.event_trigger;

433 434 435
	return 0;
}

436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467
static int iwl_set_ucode_api_flags(struct iwl_drv *drv, const u8 *data,
				   struct iwl_ucode_capabilities *capa)
{
	const struct iwl_ucode_api *ucode_api = (void *)data;
	u32 api_index = le32_to_cpu(ucode_api->api_index);

	if (api_index >= IWL_API_ARRAY_SIZE) {
		IWL_ERR(drv, "api_index larger than supported by driver\n");
		return -EINVAL;
	}

	capa->api[api_index] = le32_to_cpu(ucode_api->api_flags);

	return 0;
}

static int iwl_set_ucode_capabilities(struct iwl_drv *drv, const u8 *data,
				      struct iwl_ucode_capabilities *capa)
{
	const struct iwl_ucode_capa *ucode_capa = (void *)data;
	u32 api_index = le32_to_cpu(ucode_capa->api_index);

	if (api_index >= IWL_CAPABILITIES_ARRAY_SIZE) {
		IWL_ERR(drv, "api_index larger than supported by driver\n");
		return -EINVAL;
	}

	capa->capa[api_index] = le32_to_cpu(ucode_capa->api_capa);

	return 0;
}

J
Johannes Berg 已提交
468
static int iwl_parse_v1_v2_firmware(struct iwl_drv *drv,
469 470
				    const struct firmware *ucode_raw,
				    struct iwl_firmware_pieces *pieces)
471 472 473 474 475 476
{
	struct iwl_ucode_header *ucode = (void *)ucode_raw->data;
	u32 api_ver, hdr_size, build;
	char buildstr[25];
	const u8 *src;

J
Johannes Berg 已提交
477 478
	drv->fw.ucode_ver = le32_to_cpu(ucode->ver);
	api_ver = IWL_UCODE_API(drv->fw.ucode_ver);
479 480 481 482 483

	switch (api_ver) {
	default:
		hdr_size = 28;
		if (ucode_raw->size < hdr_size) {
J
Johannes Berg 已提交
484
			IWL_ERR(drv, "File size too small!\n");
485 486 487
			return -EINVAL;
		}
		build = le32_to_cpu(ucode->u.v2.build);
488 489 490 491 492 493 494 495
		set_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_INST,
			     le32_to_cpu(ucode->u.v2.inst_size));
		set_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_DATA,
			     le32_to_cpu(ucode->u.v2.data_size));
		set_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST,
			     le32_to_cpu(ucode->u.v2.init_size));
		set_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA,
			     le32_to_cpu(ucode->u.v2.init_data_size));
496 497 498 499 500 501 502
		src = ucode->u.v2.data;
		break;
	case 0:
	case 1:
	case 2:
		hdr_size = 24;
		if (ucode_raw->size < hdr_size) {
J
Johannes Berg 已提交
503
			IWL_ERR(drv, "File size too small!\n");
504 505 506
			return -EINVAL;
		}
		build = 0;
507 508 509 510 511 512 513 514
		set_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_INST,
			     le32_to_cpu(ucode->u.v1.inst_size));
		set_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_DATA,
			     le32_to_cpu(ucode->u.v1.data_size));
		set_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST,
			     le32_to_cpu(ucode->u.v1.init_size));
		set_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA,
			     le32_to_cpu(ucode->u.v1.init_data_size));
515 516 517 518 519 520
		src = ucode->u.v1.data;
		break;
	}

	if (build)
		sprintf(buildstr, " build %u%s", build,
J
Johannes Berg 已提交
521
		       (drv->fw_index == UCODE_EXPERIMENTAL_INDEX)
522 523 524 525
				? " (EXP)" : "");
	else
		buildstr[0] = '\0';

J
Johannes Berg 已提交
526 527
	snprintf(drv->fw.fw_version,
		 sizeof(drv->fw.fw_version),
528
		 "%u.%u.%u.%u%s",
J
Johannes Berg 已提交
529 530 531 532
		 IWL_UCODE_MAJOR(drv->fw.ucode_ver),
		 IWL_UCODE_MINOR(drv->fw.ucode_ver),
		 IWL_UCODE_API(drv->fw.ucode_ver),
		 IWL_UCODE_SERIAL(drv->fw.ucode_ver),
533 534 535
		 buildstr);

	/* Verify size of file vs. image size info in file's header */
536 537 538 539 540 541

	if (ucode_raw->size != hdr_size +
	    get_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_INST) +
	    get_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_DATA) +
	    get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST) +
	    get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA)) {
542

J
Johannes Berg 已提交
543
		IWL_ERR(drv,
544 545 546 547 548 549
			"uCode file size %d does not match expected size\n",
			(int)ucode_raw->size);
		return -EINVAL;
	}


550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565
	set_sec_data(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_INST, src);
	src += get_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_INST);
	set_sec_offset(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_INST,
		       IWLAGN_RTC_INST_LOWER_BOUND);
	set_sec_data(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_DATA, src);
	src += get_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_DATA);
	set_sec_offset(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_DATA,
		       IWLAGN_RTC_DATA_LOWER_BOUND);
	set_sec_data(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST, src);
	src += get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST);
	set_sec_offset(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST,
		       IWLAGN_RTC_INST_LOWER_BOUND);
	set_sec_data(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA, src);
	src += get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA);
	set_sec_offset(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA,
		       IWLAGN_RTC_DATA_LOWER_BOUND);
566 567 568
	return 0;
}

J
Johannes Berg 已提交
569
static int iwl_parse_tlv_firmware(struct iwl_drv *drv,
570
				const struct firmware *ucode_raw,
571
				struct iwl_firmware_pieces *pieces,
572 573 574 575 576 577 578 579 580 581 582
				struct iwl_ucode_capabilities *capa)
{
	struct iwl_tlv_ucode_header *ucode = (void *)ucode_raw->data;
	struct iwl_ucode_tlv *tlv;
	size_t len = ucode_raw->size;
	const u8 *data;
	u32 tlv_len;
	enum iwl_ucode_tlv_type tlv_type;
	const u8 *tlv_data;
	char buildstr[25];
	u32 build;
583
	int num_of_cpus;
584 585

	if (len < sizeof(*ucode)) {
J
Johannes Berg 已提交
586
		IWL_ERR(drv, "uCode has invalid length: %zd\n", len);
587 588 589 590
		return -EINVAL;
	}

	if (ucode->magic != cpu_to_le32(IWL_TLV_UCODE_MAGIC)) {
J
Johannes Berg 已提交
591
		IWL_ERR(drv, "invalid uCode magic: 0X%x\n",
592 593 594 595
			le32_to_cpu(ucode->magic));
		return -EINVAL;
	}

J
Johannes Berg 已提交
596
	drv->fw.ucode_ver = le32_to_cpu(ucode->ver);
597 598
	memcpy(drv->fw.human_readable, ucode->human_readable,
	       sizeof(drv->fw.human_readable));
599 600 601 602
	build = le32_to_cpu(ucode->build);

	if (build)
		sprintf(buildstr, " build %u%s", build,
J
Johannes Berg 已提交
603
		       (drv->fw_index == UCODE_EXPERIMENTAL_INDEX)
604 605 606 607
				? " (EXP)" : "");
	else
		buildstr[0] = '\0';

J
Johannes Berg 已提交
608 609
	snprintf(drv->fw.fw_version,
		 sizeof(drv->fw.fw_version),
610
		 "%u.%u.%u.%u%s",
J
Johannes Berg 已提交
611 612 613 614
		 IWL_UCODE_MAJOR(drv->fw.ucode_ver),
		 IWL_UCODE_MINOR(drv->fw.ucode_ver),
		 IWL_UCODE_API(drv->fw.ucode_ver),
		 IWL_UCODE_SERIAL(drv->fw.ucode_ver),
615 616 617 618 619 620 621 622 623 624 625
		 buildstr);

	data = ucode->data;

	len -= sizeof(*ucode);

	while (len >= sizeof(*tlv)) {
		len -= sizeof(*tlv);
		tlv = (void *)data;

		tlv_len = le32_to_cpu(tlv->length);
626
		tlv_type = le32_to_cpu(tlv->type);
627 628 629
		tlv_data = tlv->data;

		if (len < tlv_len) {
J
Johannes Berg 已提交
630
			IWL_ERR(drv, "invalid TLV len: %zd/%u\n",
631 632 633 634 635 636 637 638
				len, tlv_len);
			return -EINVAL;
		}
		len -= ALIGN(tlv_len, 4);
		data += sizeof(*tlv) + ALIGN(tlv_len, 4);

		switch (tlv_type) {
		case IWL_UCODE_TLV_INST:
639 640 641 642 643 644 645
			set_sec_data(pieces, IWL_UCODE_REGULAR,
				     IWL_UCODE_SECTION_INST, tlv_data);
			set_sec_size(pieces, IWL_UCODE_REGULAR,
				     IWL_UCODE_SECTION_INST, tlv_len);
			set_sec_offset(pieces, IWL_UCODE_REGULAR,
				       IWL_UCODE_SECTION_INST,
				       IWLAGN_RTC_INST_LOWER_BOUND);
646 647
			break;
		case IWL_UCODE_TLV_DATA:
648 649 650 651 652 653 654
			set_sec_data(pieces, IWL_UCODE_REGULAR,
				     IWL_UCODE_SECTION_DATA, tlv_data);
			set_sec_size(pieces, IWL_UCODE_REGULAR,
				     IWL_UCODE_SECTION_DATA, tlv_len);
			set_sec_offset(pieces, IWL_UCODE_REGULAR,
				       IWL_UCODE_SECTION_DATA,
				       IWLAGN_RTC_DATA_LOWER_BOUND);
655 656
			break;
		case IWL_UCODE_TLV_INIT:
657 658 659 660 661 662 663
			set_sec_data(pieces, IWL_UCODE_INIT,
				     IWL_UCODE_SECTION_INST, tlv_data);
			set_sec_size(pieces, IWL_UCODE_INIT,
				     IWL_UCODE_SECTION_INST, tlv_len);
			set_sec_offset(pieces, IWL_UCODE_INIT,
				       IWL_UCODE_SECTION_INST,
				       IWLAGN_RTC_INST_LOWER_BOUND);
664 665
			break;
		case IWL_UCODE_TLV_INIT_DATA:
666 667 668 669 670 671 672
			set_sec_data(pieces, IWL_UCODE_INIT,
				     IWL_UCODE_SECTION_DATA, tlv_data);
			set_sec_size(pieces, IWL_UCODE_INIT,
				     IWL_UCODE_SECTION_DATA, tlv_len);
			set_sec_offset(pieces, IWL_UCODE_INIT,
				       IWL_UCODE_SECTION_DATA,
				       IWLAGN_RTC_DATA_LOWER_BOUND);
673 674
			break;
		case IWL_UCODE_TLV_BOOT:
J
Johannes Berg 已提交
675
			IWL_ERR(drv, "Found unexpected BOOT ucode\n");
676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703
			break;
		case IWL_UCODE_TLV_PROBE_MAX_LEN:
			if (tlv_len != sizeof(u32))
				goto invalid_tlv_len;
			capa->max_probe_length =
					le32_to_cpup((__le32 *)tlv_data);
			break;
		case IWL_UCODE_TLV_PAN:
			if (tlv_len)
				goto invalid_tlv_len;
			capa->flags |= IWL_UCODE_TLV_FLAGS_PAN;
			break;
		case IWL_UCODE_TLV_FLAGS:
			/* must be at least one u32 */
			if (tlv_len < sizeof(u32))
				goto invalid_tlv_len;
			/* and a proper number of u32s */
			if (tlv_len % sizeof(u32))
				goto invalid_tlv_len;
			/*
			 * This driver only reads the first u32 as
			 * right now no more features are defined,
			 * if that changes then either the driver
			 * will not work with the new firmware, or
			 * it'll not take advantage of new features.
			 */
			capa->flags = le32_to_cpup((__le32 *)tlv_data);
			break;
704 705 706 707 708 709 710 711 712 713 714 715
		case IWL_UCODE_TLV_API_CHANGES_SET:
			if (tlv_len != sizeof(struct iwl_ucode_api))
				goto invalid_tlv_len;
			if (iwl_set_ucode_api_flags(drv, tlv_data, capa))
				goto tlv_error;
			break;
		case IWL_UCODE_TLV_ENABLED_CAPABILITIES:
			if (tlv_len != sizeof(struct iwl_ucode_capa))
				goto invalid_tlv_len;
			if (iwl_set_ucode_capabilities(drv, tlv_data, capa))
				goto tlv_error;
			break;
716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754
		case IWL_UCODE_TLV_INIT_EVTLOG_PTR:
			if (tlv_len != sizeof(u32))
				goto invalid_tlv_len;
			pieces->init_evtlog_ptr =
					le32_to_cpup((__le32 *)tlv_data);
			break;
		case IWL_UCODE_TLV_INIT_EVTLOG_SIZE:
			if (tlv_len != sizeof(u32))
				goto invalid_tlv_len;
			pieces->init_evtlog_size =
					le32_to_cpup((__le32 *)tlv_data);
			break;
		case IWL_UCODE_TLV_INIT_ERRLOG_PTR:
			if (tlv_len != sizeof(u32))
				goto invalid_tlv_len;
			pieces->init_errlog_ptr =
					le32_to_cpup((__le32 *)tlv_data);
			break;
		case IWL_UCODE_TLV_RUNT_EVTLOG_PTR:
			if (tlv_len != sizeof(u32))
				goto invalid_tlv_len;
			pieces->inst_evtlog_ptr =
					le32_to_cpup((__le32 *)tlv_data);
			break;
		case IWL_UCODE_TLV_RUNT_EVTLOG_SIZE:
			if (tlv_len != sizeof(u32))
				goto invalid_tlv_len;
			pieces->inst_evtlog_size =
					le32_to_cpup((__le32 *)tlv_data);
			break;
		case IWL_UCODE_TLV_RUNT_ERRLOG_PTR:
			if (tlv_len != sizeof(u32))
				goto invalid_tlv_len;
			pieces->inst_errlog_ptr =
					le32_to_cpup((__le32 *)tlv_data);
			break;
		case IWL_UCODE_TLV_ENHANCE_SENS_TBL:
			if (tlv_len)
				goto invalid_tlv_len;
J
Johannes Berg 已提交
755
			drv->fw.enhance_sensitivity_table = true;
756 757
			break;
		case IWL_UCODE_TLV_WOWLAN_INST:
758 759 760 761 762 763 764
			set_sec_data(pieces, IWL_UCODE_WOWLAN,
				     IWL_UCODE_SECTION_INST, tlv_data);
			set_sec_size(pieces, IWL_UCODE_WOWLAN,
				     IWL_UCODE_SECTION_INST, tlv_len);
			set_sec_offset(pieces, IWL_UCODE_WOWLAN,
				       IWL_UCODE_SECTION_INST,
				       IWLAGN_RTC_INST_LOWER_BOUND);
765 766
			break;
		case IWL_UCODE_TLV_WOWLAN_DATA:
767 768 769 770 771 772 773
			set_sec_data(pieces, IWL_UCODE_WOWLAN,
				     IWL_UCODE_SECTION_DATA, tlv_data);
			set_sec_size(pieces, IWL_UCODE_WOWLAN,
				     IWL_UCODE_SECTION_DATA, tlv_len);
			set_sec_offset(pieces, IWL_UCODE_WOWLAN,
				       IWL_UCODE_SECTION_DATA,
				       IWLAGN_RTC_DATA_LOWER_BOUND);
774 775 776 777 778 779 780
			break;
		case IWL_UCODE_TLV_PHY_CALIBRATION_SIZE:
			if (tlv_len != sizeof(u32))
				goto invalid_tlv_len;
			capa->standard_phy_calibration_size =
					le32_to_cpup((__le32 *)tlv_data);
			break;
781 782 783
		 case IWL_UCODE_TLV_SEC_RT:
			iwl_store_ucode_sec(pieces, tlv_data, IWL_UCODE_REGULAR,
					    tlv_len);
784
			drv->fw.mvm_fw = true;
785 786 787 788
			break;
		case IWL_UCODE_TLV_SEC_INIT:
			iwl_store_ucode_sec(pieces, tlv_data, IWL_UCODE_INIT,
					    tlv_len);
789
			drv->fw.mvm_fw = true;
790 791 792 793
			break;
		case IWL_UCODE_TLV_SEC_WOWLAN:
			iwl_store_ucode_sec(pieces, tlv_data, IWL_UCODE_WOWLAN,
					    tlv_len);
794
			drv->fw.mvm_fw = true;
795 796 797 798 799 800 801 802 803 804 805
			break;
		case IWL_UCODE_TLV_DEF_CALIB:
			if (tlv_len != sizeof(struct iwl_tlv_calib_data))
				goto invalid_tlv_len;
			if (iwl_set_default_calib(drv, tlv_data))
				goto tlv_error;
			break;
		case IWL_UCODE_TLV_PHY_SKU:
			if (tlv_len != sizeof(u32))
				goto invalid_tlv_len;
			drv->fw.phy_config = le32_to_cpup((__le32 *)tlv_data);
806 807 808 809 810 811
			drv->fw.valid_tx_ant = (drv->fw.phy_config &
						FW_PHY_CFG_TX_CHAIN) >>
						FW_PHY_CFG_TX_CHAIN_POS;
			drv->fw.valid_rx_ant = (drv->fw.phy_config &
						FW_PHY_CFG_RX_CHAIN) >>
						FW_PHY_CFG_RX_CHAIN_POS;
812
			break;
813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845
		 case IWL_UCODE_TLV_SECURE_SEC_RT:
			iwl_store_ucode_sec(pieces, tlv_data, IWL_UCODE_REGULAR,
					    tlv_len);
			drv->fw.mvm_fw = true;
			break;
		case IWL_UCODE_TLV_SECURE_SEC_INIT:
			iwl_store_ucode_sec(pieces, tlv_data, IWL_UCODE_INIT,
					    tlv_len);
			drv->fw.mvm_fw = true;
			break;
		case IWL_UCODE_TLV_SECURE_SEC_WOWLAN:
			iwl_store_ucode_sec(pieces, tlv_data, IWL_UCODE_WOWLAN,
					    tlv_len);
			drv->fw.mvm_fw = true;
			break;
		case IWL_UCODE_TLV_NUM_OF_CPU:
			if (tlv_len != sizeof(u32))
				goto invalid_tlv_len;
			num_of_cpus =
				le32_to_cpup((__le32 *)tlv_data);

			if (num_of_cpus == 2) {
				drv->fw.img[IWL_UCODE_REGULAR].is_dual_cpus =
					true;
				drv->fw.img[IWL_UCODE_INIT].is_dual_cpus =
					true;
				drv->fw.img[IWL_UCODE_WOWLAN].is_dual_cpus =
					true;
			} else if ((num_of_cpus > 2) || (num_of_cpus < 1)) {
				IWL_ERR(drv, "Driver support upto 2 CPUs\n");
				return -EINVAL;
			}
			break;
846 847 848 849
		case IWL_UCODE_TLV_CSCHEME:
			if (iwl_store_cscheme(&drv->fw, tlv_data, tlv_len))
				goto invalid_tlv_len;
			break;
850 851 852 853 854 855
		case IWL_UCODE_TLV_N_SCAN_CHANNELS:
			if (tlv_len != sizeof(u32))
				goto invalid_tlv_len;
			capa->n_scan_channels =
				le32_to_cpup((__le32 *)tlv_data);
			break;
856
		default:
J
Johannes Berg 已提交
857
			IWL_DEBUG_INFO(drv, "unknown TLV: %d\n", tlv_type);
858 859 860 861 862
			break;
		}
	}

	if (len) {
J
Johannes Berg 已提交
863 864
		IWL_ERR(drv, "invalid TLV after parsing: %zd\n", len);
		iwl_print_hex_dump(drv, IWL_DL_FW, (u8 *)data, len);
865 866 867 868 869 870
		return -EINVAL;
	}

	return 0;

 invalid_tlv_len:
J
Johannes Berg 已提交
871
	IWL_ERR(drv, "TLV %d has invalid size: %u\n", tlv_type, tlv_len);
872
 tlv_error:
J
Johannes Berg 已提交
873
	iwl_print_hex_dump(drv, IWL_DL_FW, tlv_data, tlv_len);
874 875 876 877

	return -EINVAL;
}

878 879 880
static int iwl_alloc_ucode(struct iwl_drv *drv,
			   struct iwl_firmware_pieces *pieces,
			   enum iwl_ucode_type type)
D
David Spinadel 已提交
881 882 883 884 885 886
{
	int i;
	for (i = 0;
	     i < IWL_UCODE_SECTION_MAX && get_sec_size(pieces, type, i);
	     i++)
		if (iwl_alloc_fw_desc(drv, &(drv->fw.img[type].sec[i]),
887 888
				      get_sec(pieces, type, i)))
			return -ENOMEM;
D
David Spinadel 已提交
889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941
	return 0;
}

static int validate_sec_sizes(struct iwl_drv *drv,
			      struct iwl_firmware_pieces *pieces,
			      const struct iwl_cfg *cfg)
{
	IWL_DEBUG_INFO(drv, "f/w package hdr runtime inst size = %Zd\n",
		get_sec_size(pieces, IWL_UCODE_REGULAR,
			     IWL_UCODE_SECTION_INST));
	IWL_DEBUG_INFO(drv, "f/w package hdr runtime data size = %Zd\n",
		get_sec_size(pieces, IWL_UCODE_REGULAR,
			     IWL_UCODE_SECTION_DATA));
	IWL_DEBUG_INFO(drv, "f/w package hdr init inst size = %Zd\n",
		get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST));
	IWL_DEBUG_INFO(drv, "f/w package hdr init data size = %Zd\n",
		get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA));

	/* Verify that uCode images will fit in card's SRAM. */
	if (get_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_INST) >
							cfg->max_inst_size) {
		IWL_ERR(drv, "uCode instr len %Zd too large to fit in\n",
			get_sec_size(pieces, IWL_UCODE_REGULAR,
						IWL_UCODE_SECTION_INST));
		return -1;
	}

	if (get_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_DATA) >
							cfg->max_data_size) {
		IWL_ERR(drv, "uCode data len %Zd too large to fit in\n",
			get_sec_size(pieces, IWL_UCODE_REGULAR,
						IWL_UCODE_SECTION_DATA));
		return -1;
	}

	 if (get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST) >
							cfg->max_inst_size) {
		IWL_ERR(drv, "uCode init instr len %Zd too large to fit in\n",
			get_sec_size(pieces, IWL_UCODE_INIT,
						IWL_UCODE_SECTION_INST));
		return -1;
	}

	if (get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA) >
							cfg->max_data_size) {
		IWL_ERR(drv, "uCode init data len %Zd too large to fit in\n",
			get_sec_size(pieces, IWL_UCODE_REGULAR,
						IWL_UCODE_SECTION_DATA));
		return -1;
	}
	return 0;
}

942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985
static struct iwl_op_mode *
_iwl_op_mode_start(struct iwl_drv *drv, struct iwlwifi_opmode_table *op)
{
	const struct iwl_op_mode_ops *ops = op->ops;
	struct dentry *dbgfs_dir = NULL;
	struct iwl_op_mode *op_mode = NULL;

#ifdef CONFIG_IWLWIFI_DEBUGFS
	drv->dbgfs_op_mode = debugfs_create_dir(op->name,
						drv->dbgfs_drv);
	if (!drv->dbgfs_op_mode) {
		IWL_ERR(drv,
			"failed to create opmode debugfs directory\n");
		return op_mode;
	}
	dbgfs_dir = drv->dbgfs_op_mode;
#endif

	op_mode = ops->start(drv->trans, drv->cfg, &drv->fw, dbgfs_dir);

#ifdef CONFIG_IWLWIFI_DEBUGFS
	if (!op_mode) {
		debugfs_remove_recursive(drv->dbgfs_op_mode);
		drv->dbgfs_op_mode = NULL;
	}
#endif

	return op_mode;
}

static void _iwl_op_mode_stop(struct iwl_drv *drv)
{
	/* op_mode can be NULL if its start failed */
	if (drv->op_mode) {
		iwl_op_mode_stop(drv->op_mode);
		drv->op_mode = NULL;

#ifdef CONFIG_IWLWIFI_DEBUGFS
		debugfs_remove_recursive(drv->dbgfs_op_mode);
		drv->dbgfs_op_mode = NULL;
#endif
	}
}

986
/**
987
 * iwl_req_fw_callback - callback when firmware was loaded
988 989 990 991
 *
 * If loaded successfully, copies the firmware into buffers
 * for the card to fetch (via DMA).
 */
992
static void iwl_req_fw_callback(const struct firmware *ucode_raw, void *context)
993
{
J
Johannes Berg 已提交
994 995
	struct iwl_drv *drv = context;
	struct iwl_fw *fw = &drv->fw;
996
	struct iwl_ucode_header *ucode;
997
	struct iwlwifi_opmode_table *op;
998
	int err;
999
	struct iwl_firmware_pieces pieces;
1000 1001 1002
	const unsigned int api_max = drv->cfg->ucode_api_max;
	unsigned int api_ok = drv->cfg->ucode_api_ok;
	const unsigned int api_min = drv->cfg->ucode_api_min;
1003
	u32 api_ver;
D
David Spinadel 已提交
1004
	int i;
1005
	bool load_module = false;
1006
	u32 hw_rev = drv->trans->hw_rev;
1007

1008
	fw->ucode_capa.max_probe_length = IWL_DEFAULT_MAX_PROBE_LENGTH;
1009 1010
	fw->ucode_capa.standard_phy_calibration_size =
			IWL_DEFAULT_STANDARD_PHY_CALIBRATE_TBL_SIZE;
1011
	fw->ucode_capa.n_scan_channels = IWL_DEFAULT_SCAN_CHANNELS;
1012 1013 1014 1015 1016 1017 1018

	if (!api_ok)
		api_ok = api_max;

	memset(&pieces, 0, sizeof(pieces));

	if (!ucode_raw) {
J
Johannes Berg 已提交
1019 1020
		if (drv->fw_index <= api_ok)
			IWL_ERR(drv,
1021
				"request for firmware file '%s' failed.\n",
J
Johannes Berg 已提交
1022
				drv->firmware_name);
1023 1024 1025
		goto try_again;
	}

J
Johannes Berg 已提交
1026 1027
	IWL_DEBUG_INFO(drv, "Loaded firmware file '%s' (%zd bytes).\n",
		       drv->firmware_name, ucode_raw->size);
1028 1029 1030

	/* Make sure that we got at least the API version number */
	if (ucode_raw->size < 4) {
J
Johannes Berg 已提交
1031
		IWL_ERR(drv, "File size way too small!\n");
1032 1033 1034 1035 1036 1037 1038
		goto try_again;
	}

	/* Data from ucode file:  header followed by uCode images */
	ucode = (struct iwl_ucode_header *)ucode_raw->data;

	if (ucode->ver)
J
Johannes Berg 已提交
1039
		err = iwl_parse_v1_v2_firmware(drv, ucode_raw, &pieces);
1040
	else
J
Johannes Berg 已提交
1041
		err = iwl_parse_tlv_firmware(drv, ucode_raw, &pieces,
1042 1043 1044 1045 1046
					   &fw->ucode_capa);

	if (err)
		goto try_again;

J
Johannes Berg 已提交
1047
	api_ver = IWL_UCODE_API(drv->fw.ucode_ver);
1048 1049 1050 1051 1052 1053 1054

	/*
	 * api_ver should match the api version forming part of the
	 * firmware filename ... but we don't check for that and only rely
	 * on the API version read from firmware header from here on forward
	 */
	/* no api version check required for experimental uCode */
J
Johannes Berg 已提交
1055
	if (drv->fw_index != UCODE_EXPERIMENTAL_INDEX) {
1056
		if (api_ver < api_min || api_ver > api_max) {
J
Johannes Berg 已提交
1057
			IWL_ERR(drv,
1058 1059 1060 1061 1062 1063 1064 1065
				"Driver unable to support your firmware API. "
				"Driver supports v%u, firmware is v%u.\n",
				api_max, api_ver);
			goto try_again;
		}

		if (api_ver < api_ok) {
			if (api_ok != api_max)
J
Johannes Berg 已提交
1066
				IWL_ERR(drv, "Firmware has old API version, "
1067 1068 1069
					"expected v%u through v%u, got v%u.\n",
					api_ok, api_max, api_ver);
			else
J
Johannes Berg 已提交
1070
				IWL_ERR(drv, "Firmware has old API version, "
1071 1072
					"expected v%u, got v%u.\n",
					api_max, api_ver);
J
Johannes Berg 已提交
1073
			IWL_ERR(drv, "New firmware can be obtained from "
1074 1075 1076 1077
				      "http://www.intellinuxwireless.org/.\n");
		}
	}

1078 1079 1080 1081
	/*
	 * In mvm uCode there is no difference between data and instructions
	 * sections.
	 */
1082
	if (!fw->mvm_fw && validate_sec_sizes(drv, &pieces, drv->cfg))
1083 1084 1085 1086 1087 1088 1089
		goto try_again;

	/* Allocate ucode buffers for card's bus-master loading ... */

	/* Runtime instructions and 2 copies of data:
	 * 1) unmodified from disk
	 * 2) backup cache for save/restore during power-downs */
D
David Spinadel 已提交
1090
	for (i = 0; i < IWL_UCODE_TYPE_MAX; i++)
1091 1092
		if (iwl_alloc_ucode(drv, &pieces, i))
			goto out_free_fw;
1093 1094 1095 1096 1097 1098 1099 1100

	/* Now that we can no longer fail, copy information */

	/*
	 * The (size - 16) / 12 formula is based on the information recorded
	 * for each event, which is of mode 1 (including timestamp) for all
	 * new microcodes that include this information.
	 */
1101
	fw->init_evtlog_ptr = pieces.init_evtlog_ptr;
1102
	if (pieces.init_evtlog_size)
1103
		fw->init_evtlog_size = (pieces.init_evtlog_size - 16)/12;
1104
	else
1105
		fw->init_evtlog_size =
1106
			drv->cfg->base_params->max_event_log_size;
1107 1108
	fw->init_errlog_ptr = pieces.init_errlog_ptr;
	fw->inst_evtlog_ptr = pieces.inst_evtlog_ptr;
1109
	if (pieces.inst_evtlog_size)
1110
		fw->inst_evtlog_size = (pieces.inst_evtlog_size - 16)/12;
1111
	else
1112
		fw->inst_evtlog_size =
1113
			drv->cfg->base_params->max_event_log_size;
1114
	fw->inst_errlog_ptr = pieces.inst_errlog_ptr;
1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127

	/*
	 * figure out the offset of chain noise reset and gain commands
	 * base on the size of standard phy calibration commands table size
	 */
	if (fw->ucode_capa.standard_phy_calibration_size >
	    IWL_MAX_PHY_CALIBRATE_TBL_SIZE)
		fw->ucode_capa.standard_phy_calibration_size =
			IWL_MAX_STANDARD_PHY_CALIBRATE_TBL_SIZE;

	/* We have our copies now, allow OS release its copies */
	release_firmware(ucode_raw);

J
Johannes Berg 已提交
1128
	mutex_lock(&iwlwifi_opmode_table_mtx);
J
Johannes Berg 已提交
1129 1130 1131 1132
	if (fw->mvm_fw)
		op = &iwlwifi_opmode_table[MVM_OP_MODE];
	else
		op = &iwlwifi_opmode_table[DVM_OP_MODE];
1133

1134 1135 1136
	IWL_INFO(drv, "loaded firmware version %s op_mode %s\n",
		 drv->fw.fw_version, op->name);

1137 1138 1139 1140
	/* add this device to the list of devices using this op_mode */
	list_add_tail(&drv->list, &op->drv);

	if (op->ops) {
1141
		drv->op_mode = _iwl_op_mode_start(drv, op);
1142

D
Dan Carpenter 已提交
1143 1144
		if (!drv->op_mode) {
			mutex_unlock(&iwlwifi_opmode_table_mtx);
1145
			goto out_unbind;
D
Dan Carpenter 已提交
1146
		}
1147
	} else {
1148
		load_module = true;
1149
	}
J
Johannes Berg 已提交
1150
	mutex_unlock(&iwlwifi_opmode_table_mtx);
1151

1152 1153 1154 1155 1156 1157
	/*
	 * Complete the firmware request last so that
	 * a driver unbind (stop) doesn't run while we
	 * are doing the start() above.
	 */
	complete(&drv->request_firmware_complete);
1158 1159 1160 1161 1162 1163

	/*
	 * Load the module last so we don't block anything
	 * else from proceeding if the module fails to load
	 * or hangs loading.
	 */
1164 1165
	if (load_module) {
		err = request_module("%s", op->name);
1166
#ifdef CONFIG_IWLWIFI_OPMODE_MODULAR
1167 1168 1169 1170
		if (err)
			IWL_ERR(drv,
				"failed to load module %s (error %d), is dynamic loading enabled?\n",
				op->name, err);
1171
#endif
1172
	}
1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215

	/*
	 * We may have loaded the wrong FW file in 8000 HW family if it is an
	 * A-step card, and if drv->trans->hw_rev wasn't properly read when
	 * the FW file had been loaded. (This might happen in SDIO.) In such a
	 * case - unload and reload the correct file.
	 *
	 * TODO:
	 * Once there is only one supported step for 8000 family - delete this!
	 */
	if (drv->trans->cfg->device_family == IWL_DEVICE_FAMILY_8000 &&
	    CSR_HW_REV_STEP(drv->trans->hw_rev) == SILICON_A_STEP &&
	    drv->trans->hw_rev != hw_rev) {
		char firmware_name[32];

		/* Free previous FW resources */
		if (drv->op_mode)
			_iwl_op_mode_stop(drv);
		iwl_dealloc_ucode(drv);

		/* Build name of correct-step FW */
		snprintf(firmware_name, sizeof(firmware_name),
			 strrchr(drv->firmware_name, '-'));
		snprintf(drv->firmware_name, sizeof(drv->firmware_name),
			 "%s%s", drv->cfg->fw_name_pre, firmware_name);

		/* Clear data before loading correct FW */
		list_del(&drv->list);

		/* Request correct FW file this time */
		IWL_DEBUG_INFO(drv, "attempting to load A-step FW %s\n",
			       drv->firmware_name);
		err = request_firmware(&ucode_raw, drv->firmware_name,
				       drv->trans->dev);
		if (err) {
			IWL_ERR(drv, "Failed swapping FW!\n");
			goto out_unbind;
		}

		/* Redo callback function - this time with right FW */
		iwl_req_fw_callback(ucode_raw, context);
	}

1216 1217 1218 1219 1220
	return;

 try_again:
	/* try next, if any */
	release_firmware(ucode_raw);
J
Johannes Berg 已提交
1221
	if (iwl_request_firmware(drv, false))
1222 1223 1224
		goto out_unbind;
	return;

1225
 out_free_fw:
J
Johannes Berg 已提交
1226 1227
	IWL_ERR(drv, "failed to allocate pci memory\n");
	iwl_dealloc_ucode(drv);
1228 1229
	release_firmware(ucode_raw);
 out_unbind:
J
Johannes Berg 已提交
1230
	complete(&drv->request_firmware_complete);
1231
	device_release_driver(drv->trans->dev);
1232 1233
}

1234
struct iwl_drv *iwl_drv_start(struct iwl_trans *trans,
1235
			      const struct iwl_cfg *cfg)
1236
{
J
Johannes Berg 已提交
1237
	struct iwl_drv *drv;
1238 1239
	int ret;

J
Johannes Berg 已提交
1240
	drv = kzalloc(sizeof(*drv), GFP_KERNEL);
1241 1242 1243 1244
	if (!drv) {
		ret = -ENOMEM;
		goto err;
	}
1245

1246
	drv->trans = trans;
1247
	drv->dev = trans->dev;
1248
	drv->cfg = cfg;
1249

J
Johannes Berg 已提交
1250
	init_completion(&drv->request_firmware_complete);
J
Johannes Berg 已提交
1251
	INIT_LIST_HEAD(&drv->list);
1252

1253 1254 1255 1256 1257 1258 1259
#ifdef CONFIG_IWLWIFI_DEBUGFS
	/* Create the device debugfs entries. */
	drv->dbgfs_drv = debugfs_create_dir(dev_name(trans->dev),
					    iwl_dbgfs_root);

	if (!drv->dbgfs_drv) {
		IWL_ERR(drv, "failed to create debugfs directory\n");
1260
		ret = -ENOMEM;
1261 1262 1263 1264 1265 1266 1267 1268
		goto err_free_drv;
	}

	/* Create transport layer debugfs dir */
	drv->trans->dbgfs_dir = debugfs_create_dir("trans", drv->dbgfs_drv);

	if (!drv->trans->dbgfs_dir) {
		IWL_ERR(drv, "failed to create transport debugfs directory\n");
1269
		ret = -ENOMEM;
1270 1271 1272 1273
		goto err_free_dbgfs;
	}
#endif

J
Johannes Berg 已提交
1274
	ret = iwl_request_firmware(drv, true);
1275
	if (ret) {
1276
		IWL_ERR(trans, "Couldn't request the fw\n");
1277
		goto err_fw;
1278 1279
	}

1280 1281 1282 1283 1284 1285 1286 1287 1288
	return drv;

err_fw:
#ifdef CONFIG_IWLWIFI_DEBUGFS
err_free_dbgfs:
	debugfs_remove_recursive(drv->dbgfs_drv);
err_free_drv:
#endif
	kfree(drv);
1289
err:
1290
	return ERR_PTR(ret);
1291 1292
}

1293
void iwl_drv_stop(struct iwl_drv *drv)
1294
{
J
Johannes Berg 已提交
1295
	wait_for_completion(&drv->request_firmware_complete);
1296

1297
	_iwl_op_mode_stop(drv);
1298

J
Johannes Berg 已提交
1299
	iwl_dealloc_ucode(drv);
1300

J
Johannes Berg 已提交
1301 1302 1303 1304 1305 1306 1307 1308 1309 1310
	mutex_lock(&iwlwifi_opmode_table_mtx);
	/*
	 * List is empty (this item wasn't added)
	 * when firmware loading failed -- in that
	 * case we can't remove it from any list.
	 */
	if (!list_empty(&drv->list))
		list_del(&drv->list);
	mutex_unlock(&iwlwifi_opmode_table_mtx);

1311 1312 1313 1314
#ifdef CONFIG_IWLWIFI_DEBUGFS
	debugfs_remove_recursive(drv->dbgfs_drv);
#endif

J
Johannes Berg 已提交
1315
	kfree(drv);
1316
}
1317 1318 1319 1320


/* shared module parameters */
struct iwl_mod_params iwlwifi_mod_params = {
1321
	.restart_fw = true,
1322 1323
	.bt_coex_active = true,
	.power_level = IWL_POWER_INDEX_1,
1324
	.wd_disable = true,
1325 1326 1327
#ifndef CONFIG_IWLWIFI_UAPSD
	.uapsd_disable = true,
#endif /* CONFIG_IWLWIFI_UAPSD */
1328 1329
	/* the rest are 0 by default */
};
1330
IWL_EXPORT_SYMBOL(iwlwifi_mod_params);
1331 1332 1333 1334 1335

int iwl_opmode_register(const char *name, const struct iwl_op_mode_ops *ops)
{
	int i;
	struct iwl_drv *drv;
1336
	struct iwlwifi_opmode_table *op;
1337

J
Johannes Berg 已提交
1338
	mutex_lock(&iwlwifi_opmode_table_mtx);
1339
	for (i = 0; i < ARRAY_SIZE(iwlwifi_opmode_table); i++) {
1340 1341
		op = &iwlwifi_opmode_table[i];
		if (strcmp(op->name, name))
1342
			continue;
1343 1344 1345 1346 1347
		op->ops = ops;
		/* TODO: need to handle exceptional case */
		list_for_each_entry(drv, &op->drv, list)
			drv->op_mode = _iwl_op_mode_start(drv, op);

J
Johannes Berg 已提交
1348
		mutex_unlock(&iwlwifi_opmode_table_mtx);
1349 1350
		return 0;
	}
J
Johannes Berg 已提交
1351
	mutex_unlock(&iwlwifi_opmode_table_mtx);
1352 1353
	return -EIO;
}
1354
IWL_EXPORT_SYMBOL(iwl_opmode_register);
1355 1356 1357 1358 1359 1360

void iwl_opmode_deregister(const char *name)
{
	int i;
	struct iwl_drv *drv;

J
Johannes Berg 已提交
1361
	mutex_lock(&iwlwifi_opmode_table_mtx);
1362 1363 1364 1365 1366 1367
	for (i = 0; i < ARRAY_SIZE(iwlwifi_opmode_table); i++) {
		if (strcmp(iwlwifi_opmode_table[i].name, name))
			continue;
		iwlwifi_opmode_table[i].ops = NULL;

		/* call the stop routine for all devices */
1368 1369 1370
		list_for_each_entry(drv, &iwlwifi_opmode_table[i].drv, list)
			_iwl_op_mode_stop(drv);

J
Johannes Berg 已提交
1371
		mutex_unlock(&iwlwifi_opmode_table_mtx);
1372 1373
		return;
	}
J
Johannes Berg 已提交
1374
	mutex_unlock(&iwlwifi_opmode_table_mtx);
1375
}
1376
IWL_EXPORT_SYMBOL(iwl_opmode_deregister);
1377 1378 1379 1380 1381

static int __init iwl_drv_init(void)
{
	int i;

J
Johannes Berg 已提交
1382 1383
	mutex_init(&iwlwifi_opmode_table_mtx);

1384 1385 1386 1387 1388 1389
	for (i = 0; i < ARRAY_SIZE(iwlwifi_opmode_table); i++)
		INIT_LIST_HEAD(&iwlwifi_opmode_table[i].drv);

	pr_info(DRV_DESCRIPTION ", " DRV_VERSION "\n");
	pr_info(DRV_COPYRIGHT "\n");

1390 1391 1392 1393 1394 1395 1396 1397
#ifdef CONFIG_IWLWIFI_DEBUGFS
	/* Create the root of iwlwifi debugfs subsystem. */
	iwl_dbgfs_root = debugfs_create_dir(DRV_NAME, NULL);

	if (!iwl_dbgfs_root)
		return -EFAULT;
#endif

1398 1399 1400 1401 1402 1403 1404
	return iwl_pci_register_driver();
}
module_init(iwl_drv_init);

static void __exit iwl_drv_exit(void)
{
	iwl_pci_unregister_driver();
1405 1406 1407 1408

#ifdef CONFIG_IWLWIFI_DEBUGFS
	debugfs_remove_recursive(iwl_dbgfs_root);
#endif
1409 1410
}
module_exit(iwl_drv_exit);
1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421

#ifdef CONFIG_IWLWIFI_DEBUG
module_param_named(debug, iwlwifi_mod_params.debug_level, uint,
		   S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(debug, "debug output mask");
#endif

module_param_named(swcrypto, iwlwifi_mod_params.sw_crypto, int, S_IRUGO);
MODULE_PARM_DESC(swcrypto, "using crypto in software (default 0 [hardware])");
module_param_named(11n_disable, iwlwifi_mod_params.disable_11n, uint, S_IRUGO);
MODULE_PARM_DESC(11n_disable,
1422
	"disable 11n functionality, bitmap: 1: full, 2: disable agg TX, 4: disable agg RX, 8 enable agg TX");
1423 1424
module_param_named(amsdu_size_8K, iwlwifi_mod_params.amsdu_size_8K,
		   int, S_IRUGO);
1425
MODULE_PARM_DESC(amsdu_size_8K, "enable 8K amsdu size (default 0)");
1426 1427
module_param_named(fw_restart, iwlwifi_mod_params.restart_fw, bool, S_IRUGO);
MODULE_PARM_DESC(fw_restart, "restart firmware in case of error (default true)");
1428 1429 1430 1431

module_param_named(antenna_coupling, iwlwifi_mod_params.ant_coupling,
		   int, S_IRUGO);
MODULE_PARM_DESC(antenna_coupling,
1432
		 "specify antenna coupling in dB (default: 0 dB)");
1433 1434 1435

module_param_named(wd_disable, iwlwifi_mod_params.wd_disable, int, S_IRUGO);
MODULE_PARM_DESC(wd_disable,
1436
		"Disable stuck queue watchdog timer 0=system default, 1=disable (default: 1)");
1437

1438 1439 1440
module_param_named(nvm_file, iwlwifi_mod_params.nvm_file, charp, S_IRUGO);
MODULE_PARM_DESC(nvm_file, "NVM file name");

1441 1442
module_param_named(uapsd_disable, iwlwifi_mod_params.uapsd_disable,
		   bool, S_IRUGO);
1443
#ifdef CONFIG_IWLWIFI_UAPSD
1444
MODULE_PARM_DESC(uapsd_disable, "disable U-APSD functionality (default: N)");
1445 1446 1447
#else
MODULE_PARM_DESC(uapsd_disable, "disable U-APSD functionality (default: Y)");
#endif
1448

1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481
/*
 * set bt_coex_active to true, uCode will do kill/defer
 * every time the priority line is asserted (BT is sending signals on the
 * priority line in the PCIx).
 * set bt_coex_active to false, uCode will ignore the BT activity and
 * perform the normal operation
 *
 * User might experience transmit issue on some platform due to WiFi/BT
 * co-exist problem. The possible behaviors are:
 *   Able to scan and finding all the available AP
 *   Not able to associate with any AP
 * On those platforms, WiFi communication can be restored by set
 * "bt_coex_active" module parameter to "false"
 *
 * default: bt_coex_active = true (BT_COEX_ENABLE)
 */
module_param_named(bt_coex_active, iwlwifi_mod_params.bt_coex_active,
		bool, S_IRUGO);
MODULE_PARM_DESC(bt_coex_active, "enable wifi/bt co-exist (default: enable)");

module_param_named(led_mode, iwlwifi_mod_params.led_mode, int, S_IRUGO);
MODULE_PARM_DESC(led_mode, "0=system default, "
		"1=On(RF On)/Off(RF Off), 2=blinking, 3=Off (default: 0)");

module_param_named(power_save, iwlwifi_mod_params.power_save,
		bool, S_IRUGO);
MODULE_PARM_DESC(power_save,
		 "enable WiFi power management (default: disable)");

module_param_named(power_level, iwlwifi_mod_params.power_level,
		int, S_IRUGO);
MODULE_PARM_DESC(power_level,
		 "default power save level (range from 1 - 5, default: 1)");
1482 1483

module_param_named(fw_monitor, iwlwifi_mod_params.fw_monitor, bool, S_IRUGO);
1484
MODULE_PARM_DESC(fw_monitor,
1485
		 "firmware monitor - to debug FW (default: false - needs lots of memory)");