iwl-drv.c 35.9 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
 *
J
Johannes Berg 已提交
8
 * Copyright(c) 2007 - 2013 Intel Corporation. All rights reserved.
9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
 *
 * 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
25
 * in the file called COPYING.
26 27 28 29 30 31 32
 *
 * Contact Information:
 *  Intel Linux Wireless <ilw@linux.intel.com>
 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
 *
 * BSD LICENSE
 *
J
Johannes Berg 已提交
33
 * Copyright(c) 2005 - 2013 Intel Corporation. All rights reserved.
34 35 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
 * 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>
64 65 66
#include <linux/dma-mapping.h>
#include <linux/firmware.h>
#include <linux/module.h>
J
Johannes Berg 已提交
67
#include <linux/vmalloc.h>
68 69

#include "iwl-drv.h"
70
#include "iwl-debug.h"
71
#include "iwl-trans.h"
72
#include "iwl-op-mode.h"
73
#include "iwl-agn-hw.h"
74 75
#include "iwl-fw.h"
#include "iwl-config.h"
76
#include "iwl-modparams.h"
77

78
/* private includes */
79
#include "iwl-fw-file.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 131 132 133

	int fw_index;                   /* firmware we're trying to load */
	char firmware_name[25];         /* name of firmware file to load */

	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 160 161 162 163 164 165 166 167
/*
 * 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 已提交
168
static void iwl_free_fw_desc(struct iwl_drv *drv, struct fw_desc *desc)
169
{
J
Johannes Berg 已提交
170 171
	vfree(desc->data);
	desc->data = NULL;
172 173 174
	desc->len = 0;
}

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

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

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

	desc->data = NULL;

	if (!sec || !sec->size)
197 198
		return -EINVAL;

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

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

208 209 210
	return 0;
}

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

#define UCODE_EXPERIMENTAL_INDEX	100
#define UCODE_EXPERIMENTAL_TAG		"exp"

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

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

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

J
Johannes Berg 已提交
240
	sprintf(drv->firmware_name, "%s%s%s", name_pre, tag, ".ucode");
241

J
Johannes Berg 已提交
242 243
	IWL_DEBUG_INFO(drv, "attempting to load firmware %s'%s'\n",
		       (drv->fw_index == UCODE_EXPERIMENTAL_INDEX)
244
				? "EXPERIMENTAL " : "",
J
Johannes Berg 已提交
245
		       drv->firmware_name);
246

J
Johannes Berg 已提交
247
	return request_firmware_nowait(THIS_MODULE, 1, drv->firmware_name,
248
				       drv->trans->dev,
249
				       GFP_KERNEL, drv, iwl_req_fw_callback);
250 251
}

252
struct fw_img_parsing {
D
David Spinadel 已提交
253
	struct fw_sec sec[IWL_UCODE_SECTION_MAX];
254 255 256
	int sec_counter;
};

257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272
/*
 * 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 已提交
273
	struct iwl_tlv_calib_ctrl calib;
274 275
} __packed;

276 277
struct iwl_firmware_pieces {
	struct fw_img_parsing img[IWL_UCODE_TYPE_MAX];
278 279 280 281 282

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

283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324
/*
 * 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;
}

325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345
/*
 * 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;
346
	sec->size = size - sizeof(sec_parse->offset);
347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362

	++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 已提交
363 364 365 366 367
	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;

368 369 370
	return 0;
}

J
Johannes Berg 已提交
371
static int iwl_parse_v1_v2_firmware(struct iwl_drv *drv,
372 373
				    const struct firmware *ucode_raw,
				    struct iwl_firmware_pieces *pieces)
374 375 376 377 378 379
{
	struct iwl_ucode_header *ucode = (void *)ucode_raw->data;
	u32 api_ver, hdr_size, build;
	char buildstr[25];
	const u8 *src;

J
Johannes Berg 已提交
380 381
	drv->fw.ucode_ver = le32_to_cpu(ucode->ver);
	api_ver = IWL_UCODE_API(drv->fw.ucode_ver);
382 383 384 385 386

	switch (api_ver) {
	default:
		hdr_size = 28;
		if (ucode_raw->size < hdr_size) {
J
Johannes Berg 已提交
387
			IWL_ERR(drv, "File size too small!\n");
388 389 390
			return -EINVAL;
		}
		build = le32_to_cpu(ucode->u.v2.build);
391 392 393 394 395 396 397 398
		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));
399 400 401 402 403 404 405
		src = ucode->u.v2.data;
		break;
	case 0:
	case 1:
	case 2:
		hdr_size = 24;
		if (ucode_raw->size < hdr_size) {
J
Johannes Berg 已提交
406
			IWL_ERR(drv, "File size too small!\n");
407 408 409
			return -EINVAL;
		}
		build = 0;
410 411 412 413 414 415 416 417
		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));
418 419 420 421 422 423
		src = ucode->u.v1.data;
		break;
	}

	if (build)
		sprintf(buildstr, " build %u%s", build,
J
Johannes Berg 已提交
424
		       (drv->fw_index == UCODE_EXPERIMENTAL_INDEX)
425 426 427 428
				? " (EXP)" : "");
	else
		buildstr[0] = '\0';

J
Johannes Berg 已提交
429 430
	snprintf(drv->fw.fw_version,
		 sizeof(drv->fw.fw_version),
431
		 "%u.%u.%u.%u%s",
J
Johannes Berg 已提交
432 433 434 435
		 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),
436 437 438
		 buildstr);

	/* Verify size of file vs. image size info in file's header */
439 440 441 442 443 444

	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)) {
445

J
Johannes Berg 已提交
446
		IWL_ERR(drv,
447 448 449 450 451 452
			"uCode file size %d does not match expected size\n",
			(int)ucode_raw->size);
		return -EINVAL;
	}


453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468
	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);
469 470 471
	return 0;
}

J
Johannes Berg 已提交
472
static int iwl_parse_tlv_firmware(struct iwl_drv *drv,
473
				const struct firmware *ucode_raw,
474
				struct iwl_firmware_pieces *pieces,
475 476 477 478 479 480 481 482 483 484 485 486 487
				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;

	if (len < sizeof(*ucode)) {
J
Johannes Berg 已提交
488
		IWL_ERR(drv, "uCode has invalid length: %zd\n", len);
489 490 491 492
		return -EINVAL;
	}

	if (ucode->magic != cpu_to_le32(IWL_TLV_UCODE_MAGIC)) {
J
Johannes Berg 已提交
493
		IWL_ERR(drv, "invalid uCode magic: 0X%x\n",
494 495 496 497
			le32_to_cpu(ucode->magic));
		return -EINVAL;
	}

J
Johannes Berg 已提交
498
	drv->fw.ucode_ver = le32_to_cpu(ucode->ver);
499 500 501 502
	build = le32_to_cpu(ucode->build);

	if (build)
		sprintf(buildstr, " build %u%s", build,
J
Johannes Berg 已提交
503
		       (drv->fw_index == UCODE_EXPERIMENTAL_INDEX)
504 505 506 507
				? " (EXP)" : "");
	else
		buildstr[0] = '\0';

J
Johannes Berg 已提交
508 509
	snprintf(drv->fw.fw_version,
		 sizeof(drv->fw.fw_version),
510
		 "%u.%u.%u.%u%s",
J
Johannes Berg 已提交
511 512 513 514
		 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),
515 516 517 518 519 520 521 522 523 524 525
		 buildstr);

	data = ucode->data;

	len -= sizeof(*ucode);

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

		tlv_len = le32_to_cpu(tlv->length);
526
		tlv_type = le32_to_cpu(tlv->type);
527 528 529
		tlv_data = tlv->data;

		if (len < tlv_len) {
J
Johannes Berg 已提交
530
			IWL_ERR(drv, "invalid TLV len: %zd/%u\n",
531 532 533 534 535 536 537 538
				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:
539 540 541 542 543 544 545
			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);
546 547
			break;
		case IWL_UCODE_TLV_DATA:
548 549 550 551 552 553 554
			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);
555 556
			break;
		case IWL_UCODE_TLV_INIT:
557 558 559 560 561 562 563
			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);
564 565
			break;
		case IWL_UCODE_TLV_INIT_DATA:
566 567 568 569 570 571 572
			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);
573 574
			break;
		case IWL_UCODE_TLV_BOOT:
J
Johannes Berg 已提交
575
			IWL_ERR(drv, "Found unexpected BOOT ucode\n");
576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 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
			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;
		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 已提交
643
			drv->fw.enhance_sensitivity_table = true;
644 645
			break;
		case IWL_UCODE_TLV_WOWLAN_INST:
646 647 648 649 650 651 652
			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);
653 654
			break;
		case IWL_UCODE_TLV_WOWLAN_DATA:
655 656 657 658 659 660 661
			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);
662 663 664 665 666 667 668
			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;
669 670 671
		 case IWL_UCODE_TLV_SEC_RT:
			iwl_store_ucode_sec(pieces, tlv_data, IWL_UCODE_REGULAR,
					    tlv_len);
672
			drv->fw.mvm_fw = true;
673 674 675 676
			break;
		case IWL_UCODE_TLV_SEC_INIT:
			iwl_store_ucode_sec(pieces, tlv_data, IWL_UCODE_INIT,
					    tlv_len);
677
			drv->fw.mvm_fw = true;
678 679 680 681
			break;
		case IWL_UCODE_TLV_SEC_WOWLAN:
			iwl_store_ucode_sec(pieces, tlv_data, IWL_UCODE_WOWLAN,
					    tlv_len);
682
			drv->fw.mvm_fw = true;
683 684 685 686 687 688 689 690 691 692 693 694
			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);
			break;
695
		default:
J
Johannes Berg 已提交
696
			IWL_DEBUG_INFO(drv, "unknown TLV: %d\n", tlv_type);
697 698 699 700 701
			break;
		}
	}

	if (len) {
J
Johannes Berg 已提交
702 703
		IWL_ERR(drv, "invalid TLV after parsing: %zd\n", len);
		iwl_print_hex_dump(drv, IWL_DL_FW, (u8 *)data, len);
704 705 706 707 708 709
		return -EINVAL;
	}

	return 0;

 invalid_tlv_len:
J
Johannes Berg 已提交
710
	IWL_ERR(drv, "TLV %d has invalid size: %u\n", tlv_type, tlv_len);
711
 tlv_error:
J
Johannes Berg 已提交
712
	iwl_print_hex_dump(drv, IWL_DL_FW, tlv_data, tlv_len);
713 714 715 716

	return -EINVAL;
}

717 718 719
static int iwl_alloc_ucode(struct iwl_drv *drv,
			   struct iwl_firmware_pieces *pieces,
			   enum iwl_ucode_type type)
D
David Spinadel 已提交
720 721 722 723 724 725
{
	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]),
726 727
				      get_sec(pieces, type, i)))
			return -ENOMEM;
D
David Spinadel 已提交
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 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780
	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;
}

781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824
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
	}
}

825
/**
826
 * iwl_req_fw_callback - callback when firmware was loaded
827 828 829 830
 *
 * If loaded successfully, copies the firmware into buffers
 * for the card to fetch (via DMA).
 */
831
static void iwl_req_fw_callback(const struct firmware *ucode_raw, void *context)
832
{
J
Johannes Berg 已提交
833 834
	struct iwl_drv *drv = context;
	struct iwl_fw *fw = &drv->fw;
835
	struct iwl_ucode_header *ucode;
836
	struct iwlwifi_opmode_table *op;
837
	int err;
838
	struct iwl_firmware_pieces pieces;
839 840 841
	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;
842
	u32 api_ver;
D
David Spinadel 已提交
843
	int i;
844
	bool load_module = false;
845 846 847 848 849 850 851 852 853 854 855

	fw->ucode_capa.max_probe_length = 200;
	fw->ucode_capa.standard_phy_calibration_size =
			IWL_DEFAULT_STANDARD_PHY_CALIBRATE_TBL_SIZE;

	if (!api_ok)
		api_ok = api_max;

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

	if (!ucode_raw) {
J
Johannes Berg 已提交
856 857
		if (drv->fw_index <= api_ok)
			IWL_ERR(drv,
858
				"request for firmware file '%s' failed.\n",
J
Johannes Berg 已提交
859
				drv->firmware_name);
860 861 862
		goto try_again;
	}

J
Johannes Berg 已提交
863 864
	IWL_DEBUG_INFO(drv, "Loaded firmware file '%s' (%zd bytes).\n",
		       drv->firmware_name, ucode_raw->size);
865 866 867

	/* Make sure that we got at least the API version number */
	if (ucode_raw->size < 4) {
J
Johannes Berg 已提交
868
		IWL_ERR(drv, "File size way too small!\n");
869 870 871 872 873 874 875
		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 已提交
876
		err = iwl_parse_v1_v2_firmware(drv, ucode_raw, &pieces);
877
	else
J
Johannes Berg 已提交
878
		err = iwl_parse_tlv_firmware(drv, ucode_raw, &pieces,
879 880 881 882 883
					   &fw->ucode_capa);

	if (err)
		goto try_again;

J
Johannes Berg 已提交
884
	api_ver = IWL_UCODE_API(drv->fw.ucode_ver);
885 886 887 888 889 890 891

	/*
	 * 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 已提交
892
	if (drv->fw_index != UCODE_EXPERIMENTAL_INDEX) {
893
		if (api_ver < api_min || api_ver > api_max) {
J
Johannes Berg 已提交
894
			IWL_ERR(drv,
895 896 897 898 899 900 901 902
				"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 已提交
903
				IWL_ERR(drv, "Firmware has old API version, "
904 905 906
					"expected v%u through v%u, got v%u.\n",
					api_ok, api_max, api_ver);
			else
J
Johannes Berg 已提交
907
				IWL_ERR(drv, "Firmware has old API version, "
908 909
					"expected v%u, got v%u.\n",
					api_max, api_ver);
J
Johannes Berg 已提交
910
			IWL_ERR(drv, "New firmware can be obtained from "
911 912 913 914
				      "http://www.intellinuxwireless.org/.\n");
		}
	}

915 916 917 918
	/*
	 * In mvm uCode there is no difference between data and instructions
	 * sections.
	 */
919
	if (!fw->mvm_fw && validate_sec_sizes(drv, &pieces, drv->cfg))
920 921 922 923 924 925 926
		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 已提交
927
	for (i = 0; i < IWL_UCODE_TYPE_MAX; i++)
928 929
		if (iwl_alloc_ucode(drv, &pieces, i))
			goto out_free_fw;
930 931 932 933 934 935 936 937

	/* 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.
	 */
938
	fw->init_evtlog_ptr = pieces.init_evtlog_ptr;
939
	if (pieces.init_evtlog_size)
940
		fw->init_evtlog_size = (pieces.init_evtlog_size - 16)/12;
941
	else
942
		fw->init_evtlog_size =
943
			drv->cfg->base_params->max_event_log_size;
944 945
	fw->init_errlog_ptr = pieces.init_errlog_ptr;
	fw->inst_evtlog_ptr = pieces.inst_evtlog_ptr;
946
	if (pieces.inst_evtlog_size)
947
		fw->inst_evtlog_size = (pieces.inst_evtlog_size - 16)/12;
948
	else
949
		fw->inst_evtlog_size =
950
			drv->cfg->base_params->max_event_log_size;
951
	fw->inst_errlog_ptr = pieces.inst_errlog_ptr;
952 953 954 955 956 957 958 959 960 961 962 963 964

	/*
	 * 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 已提交
965
	mutex_lock(&iwlwifi_opmode_table_mtx);
J
Johannes Berg 已提交
966 967 968 969
	if (fw->mvm_fw)
		op = &iwlwifi_opmode_table[MVM_OP_MODE];
	else
		op = &iwlwifi_opmode_table[DVM_OP_MODE];
970

971 972 973
	IWL_INFO(drv, "loaded firmware version %s op_mode %s\n",
		 drv->fw.fw_version, op->name);

974 975 976 977
	/* add this device to the list of devices using this op_mode */
	list_add_tail(&drv->list, &op->drv);

	if (op->ops) {
978
		drv->op_mode = _iwl_op_mode_start(drv, op);
979

D
Dan Carpenter 已提交
980 981
		if (!drv->op_mode) {
			mutex_unlock(&iwlwifi_opmode_table_mtx);
982
			goto out_unbind;
D
Dan Carpenter 已提交
983
		}
984
	} else {
985
		load_module = true;
986
	}
J
Johannes Berg 已提交
987
	mutex_unlock(&iwlwifi_opmode_table_mtx);
988

989 990 991 992 993 994
	/*
	 * 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);
995 996 997 998 999 1000

	/*
	 * Load the module last so we don't block anything
	 * else from proceeding if the module fails to load
	 * or hangs loading.
	 */
1001 1002 1003 1004 1005 1006 1007
	if (load_module) {
		err = request_module("%s", op->name);
		if (err)
			IWL_ERR(drv,
				"failed to load module %s (error %d), is dynamic loading enabled?\n",
				op->name, err);
	}
1008 1009 1010 1011 1012
	return;

 try_again:
	/* try next, if any */
	release_firmware(ucode_raw);
J
Johannes Berg 已提交
1013
	if (iwl_request_firmware(drv, false))
1014 1015 1016
		goto out_unbind;
	return;

1017
 out_free_fw:
J
Johannes Berg 已提交
1018 1019
	IWL_ERR(drv, "failed to allocate pci memory\n");
	iwl_dealloc_ucode(drv);
1020 1021
	release_firmware(ucode_raw);
 out_unbind:
J
Johannes Berg 已提交
1022
	complete(&drv->request_firmware_complete);
1023
	device_release_driver(drv->trans->dev);
1024 1025
}

1026
struct iwl_drv *iwl_drv_start(struct iwl_trans *trans,
1027
			      const struct iwl_cfg *cfg)
1028
{
J
Johannes Berg 已提交
1029
	struct iwl_drv *drv;
1030 1031
	int ret;

J
Johannes Berg 已提交
1032
	drv = kzalloc(sizeof(*drv), GFP_KERNEL);
1033
	if (!drv)
1034
		return NULL;
1035

1036
	drv->trans = trans;
1037
	drv->dev = trans->dev;
1038
	drv->cfg = cfg;
1039

J
Johannes Berg 已提交
1040
	init_completion(&drv->request_firmware_complete);
J
Johannes Berg 已提交
1041
	INIT_LIST_HEAD(&drv->list);
1042

1043 1044 1045 1046 1047 1048 1049
#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");
1050
		ret = -ENOMEM;
1051 1052 1053 1054 1055 1056 1057 1058
		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");
1059
		ret = -ENOMEM;
1060 1061 1062 1063
		goto err_free_dbgfs;
	}
#endif

J
Johannes Berg 已提交
1064
	ret = iwl_request_firmware(drv, true);
1065
	if (ret) {
1066
		IWL_ERR(trans, "Couldn't request the fw\n");
1067
		goto err_fw;
1068 1069
	}

1070 1071 1072 1073 1074 1075 1076 1077 1078 1079
	return drv;

err_fw:
#ifdef CONFIG_IWLWIFI_DEBUGFS
err_free_dbgfs:
	debugfs_remove_recursive(drv->dbgfs_drv);
err_free_drv:
#endif
	kfree(drv);

1080
	return ERR_PTR(ret);
1081 1082
}

1083
void iwl_drv_stop(struct iwl_drv *drv)
1084
{
J
Johannes Berg 已提交
1085
	wait_for_completion(&drv->request_firmware_complete);
1086

1087
	_iwl_op_mode_stop(drv);
1088

J
Johannes Berg 已提交
1089
	iwl_dealloc_ucode(drv);
1090

J
Johannes Berg 已提交
1091 1092 1093 1094 1095 1096 1097 1098 1099 1100
	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);

1101 1102 1103 1104
#ifdef CONFIG_IWLWIFI_DEBUGFS
	debugfs_remove_recursive(drv->dbgfs_drv);
#endif

J
Johannes Berg 已提交
1105
	kfree(drv);
1106
}
1107 1108 1109 1110


/* shared module parameters */
struct iwl_mod_params iwlwifi_mod_params = {
1111
	.restart_fw = true,
1112 1113 1114 1115 1116
	.plcp_check = true,
	.bt_coex_active = true,
	.power_level = IWL_POWER_INDEX_1,
	.bt_ch_announce = true,
	.auto_agg = true,
1117
	.wd_disable = true,
1118 1119
	/* the rest are 0 by default */
};
1120
IWL_EXPORT_SYMBOL(iwlwifi_mod_params);
1121 1122 1123 1124 1125

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

J
Johannes Berg 已提交
1128
	mutex_lock(&iwlwifi_opmode_table_mtx);
1129
	for (i = 0; i < ARRAY_SIZE(iwlwifi_opmode_table); i++) {
1130 1131
		op = &iwlwifi_opmode_table[i];
		if (strcmp(op->name, name))
1132
			continue;
1133 1134 1135 1136 1137
		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 已提交
1138
		mutex_unlock(&iwlwifi_opmode_table_mtx);
1139 1140
		return 0;
	}
J
Johannes Berg 已提交
1141
	mutex_unlock(&iwlwifi_opmode_table_mtx);
1142 1143
	return -EIO;
}
1144
IWL_EXPORT_SYMBOL(iwl_opmode_register);
1145 1146 1147 1148 1149 1150

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

J
Johannes Berg 已提交
1151
	mutex_lock(&iwlwifi_opmode_table_mtx);
1152 1153 1154 1155 1156 1157
	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 */
1158 1159 1160
		list_for_each_entry(drv, &iwlwifi_opmode_table[i].drv, list)
			_iwl_op_mode_stop(drv);

J
Johannes Berg 已提交
1161
		mutex_unlock(&iwlwifi_opmode_table_mtx);
1162 1163
		return;
	}
J
Johannes Berg 已提交
1164
	mutex_unlock(&iwlwifi_opmode_table_mtx);
1165
}
1166
IWL_EXPORT_SYMBOL(iwl_opmode_deregister);
1167 1168 1169 1170 1171

static int __init iwl_drv_init(void)
{
	int i;

J
Johannes Berg 已提交
1172 1173
	mutex_init(&iwlwifi_opmode_table_mtx);

1174 1175 1176 1177 1178 1179
	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");

1180 1181 1182 1183 1184 1185 1186 1187
#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

1188 1189 1190 1191 1192 1193 1194
	return iwl_pci_register_driver();
}
module_init(iwl_drv_init);

static void __exit iwl_drv_exit(void)
{
	iwl_pci_unregister_driver();
1195 1196 1197 1198

#ifdef CONFIG_IWLWIFI_DEBUGFS
	debugfs_remove_recursive(iwl_dbgfs_root);
#endif
1199 1200
}
module_exit(iwl_drv_exit);
1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214

#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,
	"disable 11n functionality, bitmap: 1: full, 2: agg TX, 4: agg RX");
module_param_named(amsdu_size_8K, iwlwifi_mod_params.amsdu_size_8K,
		   int, S_IRUGO);
1215
MODULE_PARM_DESC(amsdu_size_8K, "enable 8K amsdu size (default 0)");
1216 1217
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)");
1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274

module_param_named(antenna_coupling, iwlwifi_mod_params.ant_coupling,
		   int, S_IRUGO);
MODULE_PARM_DESC(antenna_coupling,
		 "specify antenna coupling in dB (defualt: 0 dB)");

module_param_named(bt_ch_inhibition, iwlwifi_mod_params.bt_ch_announce,
		   bool, S_IRUGO);
MODULE_PARM_DESC(bt_ch_inhibition,
		 "Enable BT channel inhibition (default: enable)");

module_param_named(plcp_check, iwlwifi_mod_params.plcp_check, bool, S_IRUGO);
MODULE_PARM_DESC(plcp_check, "Check plcp health (default: 1 [enabled])");

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

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

module_param_named(auto_agg, iwlwifi_mod_params.auto_agg,
		bool, S_IRUGO);
MODULE_PARM_DESC(auto_agg,
		 "enable agg w/o check traffic load (default: enable)");