iwl-drv.c 27.9 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 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
/******************************************************************************
 *
 * 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
 *
 * Copyright(c) 2007 - 2012 Intel Corporation. All rights reserved.
 *
 * 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
 * in the file called LICENSE.GPL.
 *
 * Contact Information:
 *  Intel Linux Wireless <ilw@linux.intel.com>
 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
 *
 * BSD LICENSE
 *
 * Copyright(c) 2005 - 2012 Intel Corporation. All rights reserved.
 * 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>
67 68 69

#include "iwl-drv.h"
#include "iwl-trans.h"
70
#include "iwl-shared.h"
71
#include "iwl-op-mode.h"
72
#include "iwl-agn-hw.h"
73

74
/* private includes */
75
#include "iwl-fw-file.h"
76

J
Johannes Berg 已提交
77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
/**
 * struct iwl_drv - drv common data
 * @fw: the iwl_fw structure
 * @shrd: pointer to common shared structure
 * @op_mode: the running op_mode
 * @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 {
	struct iwl_fw fw;

	struct iwl_shared *shrd;
	struct iwl_op_mode *op_mode;

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

	struct completion request_firmware_complete;
};



100 101 102 103 104 105 106 107 108 109
/*
 * 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 已提交
110
static void iwl_free_fw_desc(struct iwl_drv *drv, struct fw_desc *desc)
111 112
{
	if (desc->v_addr)
J
Johannes Berg 已提交
113
		dma_free_coherent(trans(drv)->dev, desc->len,
114 115 116 117 118
				  desc->v_addr, desc->p_addr);
	desc->v_addr = NULL;
	desc->len = 0;
}

J
Johannes Berg 已提交
119
static void iwl_free_fw_img(struct iwl_drv *drv, struct fw_img *img)
120
{
D
David Spinadel 已提交
121 122 123
	int i;
	for (i = 0; i < IWL_UCODE_SECTION_MAX; i++)
		iwl_free_fw_desc(drv, &img->sec[i]);
124 125
}

J
Johannes Berg 已提交
126
static void iwl_dealloc_ucode(struct iwl_drv *drv)
127
{
D
David Spinadel 已提交
128 129 130
	int i;
	for (i = 0; i < IWL_UCODE_TYPE_MAX; i++)
		iwl_free_fw_img(drv, drv->fw.img + i);
131 132
}

J
Johannes Berg 已提交
133
static int iwl_alloc_fw_desc(struct iwl_drv *drv, struct fw_desc *desc,
134
		      struct fw_sec *sec)
135
{
136
	if (!sec || !sec->size) {
137 138 139 140
		desc->v_addr = NULL;
		return -EINVAL;
	}

141
	desc->v_addr = dma_alloc_coherent(trans(drv)->dev, sec->size,
142 143 144 145
					  &desc->p_addr, GFP_KERNEL);
	if (!desc->v_addr)
		return -ENOMEM;

146 147 148
	desc->len = sec->size;
	desc->offset = sec->offset;
	memcpy(desc->v_addr, sec->data, sec->size);
149 150 151 152 153 154 155 156
	return 0;
}

static void iwl_ucode_callback(const struct firmware *ucode_raw, void *context);

#define UCODE_EXPERIMENTAL_INDEX	100
#define UCODE_EXPERIMENTAL_TAG		"exp"

J
Johannes Berg 已提交
157
static int iwl_request_firmware(struct iwl_drv *drv, bool first)
158
{
J
Johannes Berg 已提交
159
	const struct iwl_cfg *cfg = cfg(drv);
160 161 162 163 164
	const char *name_pre = cfg->fw_name_pre;
	char tag[8];

	if (first) {
#ifdef CONFIG_IWLWIFI_DEBUG_EXPERIMENTAL_UCODE
J
Johannes Berg 已提交
165
		drv->fw_index = UCODE_EXPERIMENTAL_INDEX;
166
		strcpy(tag, UCODE_EXPERIMENTAL_TAG);
J
Johannes Berg 已提交
167
	} else if (drv->fw_index == UCODE_EXPERIMENTAL_INDEX) {
168
#endif
J
Johannes Berg 已提交
169 170
		drv->fw_index = cfg->ucode_api_max;
		sprintf(tag, "%d", drv->fw_index);
171
	} else {
J
Johannes Berg 已提交
172 173
		drv->fw_index--;
		sprintf(tag, "%d", drv->fw_index);
174 175
	}

J
Johannes Berg 已提交
176 177
	if (drv->fw_index < cfg->ucode_api_min) {
		IWL_ERR(drv, "no suitable firmware found!\n");
178 179 180
		return -ENOENT;
	}

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

J
Johannes Berg 已提交
183 184
	IWL_DEBUG_INFO(drv, "attempting to load firmware %s'%s'\n",
		       (drv->fw_index == UCODE_EXPERIMENTAL_INDEX)
185
				? "EXPERIMENTAL " : "",
J
Johannes Berg 已提交
186
		       drv->firmware_name);
187

J
Johannes Berg 已提交
188 189 190
	return request_firmware_nowait(THIS_MODULE, 1, drv->firmware_name,
				       trans(drv)->dev,
				       GFP_KERNEL, drv, iwl_ucode_callback);
191 192
}

193
struct fw_img_parsing {
D
David Spinadel 已提交
194
	struct fw_sec sec[IWL_UCODE_SECTION_MAX];
195 196 197
	int sec_counter;
};

198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216
/*
 * 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;
	__le64 calib;
} __packed;

217 218
struct iwl_firmware_pieces {
	struct fw_img_parsing img[IWL_UCODE_TYPE_MAX];
219 220 221 222 223

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

224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265
/*
 * 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;
}

266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306
/*
 * 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;

	++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;
	}
	drv->fw.default_calib[ucode_type] = le64_to_cpu(def_calib->calib);
	return 0;
}

J
Johannes Berg 已提交
307
static int iwl_parse_v1_v2_firmware(struct iwl_drv *drv,
308 309
				    const struct firmware *ucode_raw,
				    struct iwl_firmware_pieces *pieces)
310 311 312 313 314 315
{
	struct iwl_ucode_header *ucode = (void *)ucode_raw->data;
	u32 api_ver, hdr_size, build;
	char buildstr[25];
	const u8 *src;

J
Johannes Berg 已提交
316 317
	drv->fw.ucode_ver = le32_to_cpu(ucode->ver);
	api_ver = IWL_UCODE_API(drv->fw.ucode_ver);
318 319 320 321 322

	switch (api_ver) {
	default:
		hdr_size = 28;
		if (ucode_raw->size < hdr_size) {
J
Johannes Berg 已提交
323
			IWL_ERR(drv, "File size too small!\n");
324 325 326
			return -EINVAL;
		}
		build = le32_to_cpu(ucode->u.v2.build);
327 328 329 330 331 332 333 334
		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));
335 336 337 338 339 340 341
		src = ucode->u.v2.data;
		break;
	case 0:
	case 1:
	case 2:
		hdr_size = 24;
		if (ucode_raw->size < hdr_size) {
J
Johannes Berg 已提交
342
			IWL_ERR(drv, "File size too small!\n");
343 344 345
			return -EINVAL;
		}
		build = 0;
346 347 348 349 350 351 352 353
		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));
354 355 356 357 358 359
		src = ucode->u.v1.data;
		break;
	}

	if (build)
		sprintf(buildstr, " build %u%s", build,
J
Johannes Berg 已提交
360
		       (drv->fw_index == UCODE_EXPERIMENTAL_INDEX)
361 362 363 364
				? " (EXP)" : "");
	else
		buildstr[0] = '\0';

J
Johannes Berg 已提交
365 366
	snprintf(drv->fw.fw_version,
		 sizeof(drv->fw.fw_version),
367
		 "%u.%u.%u.%u%s",
J
Johannes Berg 已提交
368 369 370 371
		 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),
372 373 374
		 buildstr);

	/* Verify size of file vs. image size info in file's header */
375 376 377 378 379 380

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

J
Johannes Berg 已提交
382
		IWL_ERR(drv,
383 384 385 386 387 388
			"uCode file size %d does not match expected size\n",
			(int)ucode_raw->size);
		return -EINVAL;
	}


389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404
	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);
405 406 407
	return 0;
}

J
Johannes Berg 已提交
408
static int iwl_parse_tlv_firmware(struct iwl_drv *drv,
409
				const struct firmware *ucode_raw,
410
				struct iwl_firmware_pieces *pieces,
411 412 413 414 415 416 417 418 419 420 421 422 423
				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 已提交
424
		IWL_ERR(drv, "uCode has invalid length: %zd\n", len);
425 426 427 428
		return -EINVAL;
	}

	if (ucode->magic != cpu_to_le32(IWL_TLV_UCODE_MAGIC)) {
J
Johannes Berg 已提交
429
		IWL_ERR(drv, "invalid uCode magic: 0X%x\n",
430 431 432 433
			le32_to_cpu(ucode->magic));
		return -EINVAL;
	}

J
Johannes Berg 已提交
434
	drv->fw.ucode_ver = le32_to_cpu(ucode->ver);
435 436 437 438
	build = le32_to_cpu(ucode->build);

	if (build)
		sprintf(buildstr, " build %u%s", build,
J
Johannes Berg 已提交
439
		       (drv->fw_index == UCODE_EXPERIMENTAL_INDEX)
440 441 442 443
				? " (EXP)" : "");
	else
		buildstr[0] = '\0';

J
Johannes Berg 已提交
444 445
	snprintf(drv->fw.fw_version,
		 sizeof(drv->fw.fw_version),
446
		 "%u.%u.%u.%u%s",
J
Johannes Berg 已提交
447 448 449 450
		 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),
451 452 453 454 455 456 457 458 459 460 461
		 buildstr);

	data = ucode->data;

	len -= sizeof(*ucode);

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

		tlv_len = le32_to_cpu(tlv->length);
462
		tlv_type = le32_to_cpu(tlv->type);
463 464 465
		tlv_data = tlv->data;

		if (len < tlv_len) {
J
Johannes Berg 已提交
466
			IWL_ERR(drv, "invalid TLV len: %zd/%u\n",
467 468 469 470 471 472 473 474
				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:
475 476 477 478 479 480 481
			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);
482 483
			break;
		case IWL_UCODE_TLV_DATA:
484 485 486 487 488 489 490
			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);
491 492
			break;
		case IWL_UCODE_TLV_INIT:
493 494 495 496 497 498 499
			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);
500 501
			break;
		case IWL_UCODE_TLV_INIT_DATA:
502 503 504 505 506 507 508
			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);
509 510
			break;
		case IWL_UCODE_TLV_BOOT:
J
Johannes Berg 已提交
511
			IWL_ERR(drv, "Found unexpected BOOT ucode\n");
512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578
			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 已提交
579
			drv->fw.enhance_sensitivity_table = true;
580 581
			break;
		case IWL_UCODE_TLV_WOWLAN_INST:
582 583 584 585 586 587 588
			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);
589 590
			break;
		case IWL_UCODE_TLV_WOWLAN_DATA:
591 592 593 594 595 596 597
			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);
598 599 600 601 602 603 604
			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;
605 606 607
		 case IWL_UCODE_TLV_SEC_RT:
			iwl_store_ucode_sec(pieces, tlv_data, IWL_UCODE_REGULAR,
					    tlv_len);
608
			drv->fw.mvm_fw = true;
609 610 611 612
			break;
		case IWL_UCODE_TLV_SEC_INIT:
			iwl_store_ucode_sec(pieces, tlv_data, IWL_UCODE_INIT,
					    tlv_len);
613
			drv->fw.mvm_fw = true;
614 615 616 617
			break;
		case IWL_UCODE_TLV_SEC_WOWLAN:
			iwl_store_ucode_sec(pieces, tlv_data, IWL_UCODE_WOWLAN,
					    tlv_len);
618
			drv->fw.mvm_fw = true;
619 620 621 622 623 624 625 626 627 628 629 630
			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;
631
		default:
J
Johannes Berg 已提交
632
			IWL_DEBUG_INFO(drv, "unknown TLV: %d\n", tlv_type);
633 634 635 636 637
			break;
		}
	}

	if (len) {
J
Johannes Berg 已提交
638 639
		IWL_ERR(drv, "invalid TLV after parsing: %zd\n", len);
		iwl_print_hex_dump(drv, IWL_DL_FW, (u8 *)data, len);
640 641 642 643 644 645
		return -EINVAL;
	}

	return 0;

 invalid_tlv_len:
J
Johannes Berg 已提交
646
	IWL_ERR(drv, "TLV %d has invalid size: %u\n", tlv_type, tlv_len);
647
 tlv_error:
J
Johannes Berg 已提交
648
	iwl_print_hex_dump(drv, IWL_DL_FW, tlv_data, tlv_len);
649 650 651 652

	return -EINVAL;
}

D
David Spinadel 已提交
653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 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 704 705 706 707 708 709 710 711 712 713 714 715 716 717
static int alloc_pci_desc(struct iwl_drv *drv,
			  struct iwl_firmware_pieces *pieces,
			  enum iwl_ucode_type type)
{
	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]),
						get_sec(pieces, type, i)))
			return -1;
	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;
}


718 719 720 721 722 723 724 725
/**
 * iwl_ucode_callback - callback when firmware was loaded
 *
 * If loaded successfully, copies the firmware into buffers
 * for the card to fetch (via DMA).
 */
static void iwl_ucode_callback(const struct firmware *ucode_raw, void *context)
{
J
Johannes Berg 已提交
726 727 728
	struct iwl_drv *drv = context;
	const struct iwl_cfg *cfg = cfg(drv);
	struct iwl_fw *fw = &drv->fw;
729 730
	struct iwl_ucode_header *ucode;
	int err;
731
	struct iwl_firmware_pieces pieces;
732 733 734 735
	const unsigned int api_max = cfg->ucode_api_max;
	unsigned int api_ok = cfg->ucode_api_ok;
	const unsigned int api_min = cfg->ucode_api_min;
	u32 api_ver;
D
David Spinadel 已提交
736
	int i;
737 738 739 740 741 742 743 744 745 746 747

	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 已提交
748 749
		if (drv->fw_index <= api_ok)
			IWL_ERR(drv,
750
				"request for firmware file '%s' failed.\n",
J
Johannes Berg 已提交
751
				drv->firmware_name);
752 753 754
		goto try_again;
	}

J
Johannes Berg 已提交
755 756
	IWL_DEBUG_INFO(drv, "Loaded firmware file '%s' (%zd bytes).\n",
		       drv->firmware_name, ucode_raw->size);
757 758 759

	/* Make sure that we got at least the API version number */
	if (ucode_raw->size < 4) {
J
Johannes Berg 已提交
760
		IWL_ERR(drv, "File size way too small!\n");
761 762 763 764 765 766 767
		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 已提交
768
		err = iwl_parse_v1_v2_firmware(drv, ucode_raw, &pieces);
769
	else
J
Johannes Berg 已提交
770
		err = iwl_parse_tlv_firmware(drv, ucode_raw, &pieces,
771 772 773 774 775
					   &fw->ucode_capa);

	if (err)
		goto try_again;

J
Johannes Berg 已提交
776
	api_ver = IWL_UCODE_API(drv->fw.ucode_ver);
777 778 779 780 781 782 783

	/*
	 * 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 已提交
784
	if (drv->fw_index != UCODE_EXPERIMENTAL_INDEX) {
785
		if (api_ver < api_min || api_ver > api_max) {
J
Johannes Berg 已提交
786
			IWL_ERR(drv,
787 788 789 790 791 792 793 794
				"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 已提交
795
				IWL_ERR(drv, "Firmware has old API version, "
796 797 798
					"expected v%u through v%u, got v%u.\n",
					api_ok, api_max, api_ver);
			else
J
Johannes Berg 已提交
799
				IWL_ERR(drv, "Firmware has old API version, "
800 801
					"expected v%u, got v%u.\n",
					api_max, api_ver);
J
Johannes Berg 已提交
802
			IWL_ERR(drv, "New firmware can be obtained from "
803 804 805 806
				      "http://www.intellinuxwireless.org/.\n");
		}
	}

J
Johannes Berg 已提交
807
	IWL_INFO(drv, "loaded firmware version %s", drv->fw.fw_version);
808 809 810 811 812 813 814

	/*
	 * For any of the failures below (before allocating pci memory)
	 * we will try to load a version with a smaller API -- maybe the
	 * user just got a corrupted version of the latest API.
	 */

J
Johannes Berg 已提交
815 816 817
	IWL_DEBUG_INFO(drv, "f/w package hdr ucode version raw = 0x%x\n",
		       drv->fw.ucode_ver);
	IWL_DEBUG_INFO(drv, "f/w package hdr runtime inst size = %Zd\n",
818 819
		get_sec_size(&pieces, IWL_UCODE_REGULAR,
			     IWL_UCODE_SECTION_INST));
J
Johannes Berg 已提交
820
	IWL_DEBUG_INFO(drv, "f/w package hdr runtime data size = %Zd\n",
821 822
		get_sec_size(&pieces, IWL_UCODE_REGULAR,
			     IWL_UCODE_SECTION_DATA));
J
Johannes Berg 已提交
823
	IWL_DEBUG_INFO(drv, "f/w package hdr init inst size = %Zd\n",
824
		get_sec_size(&pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST));
J
Johannes Berg 已提交
825
	IWL_DEBUG_INFO(drv, "f/w package hdr init data size = %Zd\n",
826
		get_sec_size(&pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA));
827 828

	/* Verify that uCode images will fit in card's SRAM */
829 830
	if (get_sec_size(&pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_INST) >
							cfg->max_inst_size) {
J
Johannes Berg 已提交
831
		IWL_ERR(drv, "uCode instr len %Zd too large to fit in\n",
832 833
			get_sec_size(&pieces, IWL_UCODE_REGULAR,
				     IWL_UCODE_SECTION_INST));
834 835 836
		goto try_again;
	}

837 838
	if (get_sec_size(&pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_DATA) >
							cfg->max_data_size) {
J
Johannes Berg 已提交
839
		IWL_ERR(drv, "uCode data len %Zd too large to fit in\n",
840 841
			get_sec_size(&pieces, IWL_UCODE_REGULAR,
				     IWL_UCODE_SECTION_DATA));
842 843 844
		goto try_again;
	}

845 846 847 848 849
	/*
	 * In mvm uCode there is no difference between data and instructions
	 * sections.
	 */
	if (!fw->mvm_fw && validate_sec_sizes(drv, &pieces, cfg))
850 851 852 853 854 855 856
		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 已提交
857 858
	for (i = 0; i < IWL_UCODE_TYPE_MAX; i++)
		if (alloc_pci_desc(drv, &pieces, i))
859 860 861 862 863 864 865 866 867
			goto err_pci_alloc;

	/* 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.
	 */
868
	fw->init_evtlog_ptr = pieces.init_evtlog_ptr;
869
	if (pieces.init_evtlog_size)
870
		fw->init_evtlog_size = (pieces.init_evtlog_size - 16)/12;
871
	else
872
		fw->init_evtlog_size =
873
			cfg->base_params->max_event_log_size;
874 875
	fw->init_errlog_ptr = pieces.init_errlog_ptr;
	fw->inst_evtlog_ptr = pieces.inst_evtlog_ptr;
876
	if (pieces.inst_evtlog_size)
877
		fw->inst_evtlog_size = (pieces.inst_evtlog_size - 16)/12;
878
	else
879
		fw->inst_evtlog_size =
880
			cfg->base_params->max_event_log_size;
881
	fw->inst_errlog_ptr = pieces.inst_errlog_ptr;
882 883 884 885 886 887 888 889 890 891 892 893

	/*
	 * 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 已提交
894
	complete(&drv->request_firmware_complete);
895

J
Johannes Berg 已提交
896
	drv->op_mode = iwl_dvm_ops.start(drv->shrd->trans, &drv->fw);
897

J
Johannes Berg 已提交
898
	if (!drv->op_mode)
899 900 901 902 903 904 905
		goto out_unbind;

	return;

 try_again:
	/* try next, if any */
	release_firmware(ucode_raw);
J
Johannes Berg 已提交
906
	if (iwl_request_firmware(drv, false))
907 908 909 910
		goto out_unbind;
	return;

 err_pci_alloc:
J
Johannes Berg 已提交
911 912
	IWL_ERR(drv, "failed to allocate pci memory\n");
	iwl_dealloc_ucode(drv);
913 914
	release_firmware(ucode_raw);
 out_unbind:
J
Johannes Berg 已提交
915 916
	complete(&drv->request_firmware_complete);
	device_release_driver(trans(drv)->dev);
917 918
}

919
int iwl_drv_start(struct iwl_shared *shrd,
J
Johannes Berg 已提交
920
		  struct iwl_trans *trans, const struct iwl_cfg *cfg)
921
{
J
Johannes Berg 已提交
922
	struct iwl_drv *drv;
923 924 925 926
	int ret;

	shrd->cfg = cfg;

J
Johannes Berg 已提交
927 928 929
	drv = kzalloc(sizeof(*drv), GFP_KERNEL);
	if (!drv) {
		dev_printk(KERN_ERR, trans->dev, "Couldn't allocate iwl_drv");
930 931
		return -ENOMEM;
	}
J
Johannes Berg 已提交
932 933
	drv->shrd = shrd;
	shrd->drv = drv;
934

J
Johannes Berg 已提交
935
	init_completion(&drv->request_firmware_complete);
936

J
Johannes Berg 已提交
937
	ret = iwl_request_firmware(drv, true);
938 939 940

	if (ret) {
		dev_printk(KERN_ERR, trans->dev, "Couldn't request the fw");
J
Johannes Berg 已提交
941 942
		kfree(drv);
		shrd->drv = NULL;
943 944 945 946 947
	}

	return ret;
}

948 949
void iwl_drv_stop(struct iwl_shared *shrd)
{
J
Johannes Berg 已提交
950
	struct iwl_drv *drv = shrd->drv;
951

J
Johannes Berg 已提交
952
	wait_for_completion(&drv->request_firmware_complete);
953

954
	/* op_mode can be NULL if its start failed */
J
Johannes Berg 已提交
955 956
	if (drv->op_mode)
		iwl_op_mode_stop(drv->op_mode);
957

J
Johannes Berg 已提交
958
	iwl_dealloc_ucode(drv);
959

J
Johannes Berg 已提交
960 961
	kfree(drv);
	shrd->drv = NULL;
962
}