test_firmware.c

   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * This module provides an interface to trigger and test firmware loading.
   4 *
   5 * It is designed to be used for basic evaluation of the firmware loading
   6 * subsystem (for example when validating firmware verification). It lacks
   7 * any extra dependencies, and will not normally be loaded by the system
   8 * unless explicitly requested by name.
   9 */
  10
  11#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  12
  13#include <linux/init.h>
  14#include <linux/module.h>
  15#include <linux/printk.h>
  16#include <linux/completion.h>
  17#include <linux/firmware.h>
  18#include <linux/device.h>
  19#include <linux/fs.h>
  20#include <linux/miscdevice.h>
  21#include <linux/sizes.h>
  22#include <linux/slab.h>
  23#include <linux/uaccess.h>
  24#include <linux/delay.h>
  25#include <linux/kstrtox.h>
  26#include <linux/kthread.h>
  27#include <linux/vmalloc.h>
  28#include <linux/efi_embedded_fw.h>
  29#include <linux/string_choices.h>
  30
  31MODULE_IMPORT_NS("TEST_FIRMWARE");
  32
  33#define TEST_FIRMWARE_NAME	"test-firmware.bin"
  34#define TEST_FIRMWARE_NUM_REQS	4
  35#define TEST_FIRMWARE_BUF_SIZE	SZ_1K
  36#define TEST_UPLOAD_MAX_SIZE	SZ_2K
  37#define TEST_UPLOAD_BLK_SIZE	37	/* Avoid powers of two in testing */
  38
  39static DEFINE_MUTEX(test_fw_mutex);
  40static const struct firmware *test_firmware;
  41static LIST_HEAD(test_upload_list);
  42
  43struct test_batched_req {
  44	u8 idx;
  45	int rc;
  46	bool sent;
  47	const struct firmware *fw;
  48	const char *name;
  49	const char *fw_buf;
  50	struct completion completion;
  51	struct task_struct *task;
  52	struct device *dev;
  53};
  54
  55/**
  56 * struct test_config - represents configuration for the test for different triggers
  57 *
  58 * @name: the name of the firmware file to look for
  59 * @into_buf: when the into_buf is used if this is true
  60 *	request_firmware_into_buf() will be used instead.
  61 * @buf_size: size of buf to allocate when into_buf is true
  62 * @file_offset: file offset to request when calling request_firmware_into_buf
  63 * @partial: partial read opt when calling request_firmware_into_buf
  64 * @sync_direct: when the sync trigger is used if this is true
  65 *	request_firmware_direct() will be used instead.
  66 * @send_uevent: whether or not to send a uevent for async requests
  67 * @num_requests: number of requests to try per test case. This is trigger
  68 *	specific.
  69 * @reqs: stores all requests information
  70 * @read_fw_idx: index of thread from which we want to read firmware results
  71 *	from through the read_fw trigger.
  72 * @upload_name: firmware name to be used with upload_read sysfs node
  73 * @test_result: a test may use this to collect the result from the call
  74 *	of the request_firmware*() calls used in their tests. In order of
  75 *	priority we always keep first any setup error. If no setup errors were
  76 *	found then we move on to the first error encountered while running the
  77 *	API. Note that for async calls this typically will be a successful
  78 *	result (0) unless of course you've used bogus parameters, or the system
  79 *	is out of memory.  In the async case the callback is expected to do a
  80 *	bit more homework to figure out what happened, unfortunately the only
  81 *	information passed today on error is the fact that no firmware was
  82 *	found so we can only assume -ENOENT on async calls if the firmware is
  83 *	NULL.
  84 *
  85 *	Errors you can expect:
  86 *
  87 *	API specific:
  88 *
  89 *	0:		success for sync, for async it means request was sent
  90 *	-EINVAL:	invalid parameters or request
  91 *	-ENOENT:	files not found
  92 *
  93 *	System environment:
  94 *
  95 *	-ENOMEM:	memory pressure on system
  96 *	-ENODEV:	out of number of devices to test
  97 *	-EINVAL:	an unexpected error has occurred
  98 * @req_firmware: if @sync_direct is true this is set to
  99 *	request_firmware_direct(), otherwise request_firmware()
 100 */
 101struct test_config {
 102	char *name;
 103	bool into_buf;
 104	size_t buf_size;
 105	size_t file_offset;
 106	bool partial;
 107	bool sync_direct;
 108	bool send_uevent;
 109	u8 num_requests;
 110	u8 read_fw_idx;
 111	char *upload_name;
 112
 113	/*
 114	 * These below don't belong her but we'll move them once we create
 115	 * a struct fw_test_device and stuff the misc_dev under there later.
 116	 */
 117	struct test_batched_req *reqs;
 118	int test_result;
 119	int (*req_firmware)(const struct firmware **fw, const char *name,
 120			    struct device *device);
 121};
 122
 123struct upload_inject_err {
 124	const char *prog;
 125	enum fw_upload_err err_code;
 126};
 127
 128struct test_firmware_upload {
 129	char *name;
 130	struct list_head node;
 131	char *buf;
 132	size_t size;
 133	bool cancel_request;
 134	struct upload_inject_err inject;
 135	struct fw_upload *fwl;
 136};
 137
 138static struct test_config *test_fw_config;
 139
 140static struct test_firmware_upload *upload_lookup_name(const char *name)
 141{
 142	struct test_firmware_upload *tst;
 143
 144	list_for_each_entry(tst, &test_upload_list, node)
 145		if (strncmp(name, tst->name, strlen(tst->name)) == 0)
 146			return tst;
 147
 148	return NULL;
 149}
 150
 151static ssize_t test_fw_misc_read(struct file *f, char __user *buf,
 152				 size_t size, loff_t *offset)
 153{
 154	ssize_t rc = 0;
 155
 156	mutex_lock(&test_fw_mutex);
 157	if (test_firmware)
 158		rc = simple_read_from_buffer(buf, size, offset,
 159					     test_firmware->data,
 160					     test_firmware->size);
 161	mutex_unlock(&test_fw_mutex);
 162	return rc;
 163}
 164
 165static const struct file_operations test_fw_fops = {
 166	.owner          = THIS_MODULE,
 167	.read           = test_fw_misc_read,
 168};
 169
 170static void __test_release_all_firmware(void)
 171{
 172	struct test_batched_req *req;
 173	u8 i;
 174
 175	if (!test_fw_config->reqs)
 176		return;
 177
 178	for (i = 0; i < test_fw_config->num_requests; i++) {
 179		req = &test_fw_config->reqs[i];
 180		if (req->fw) {
 181			if (req->fw_buf) {
 182				kfree_const(req->fw_buf);
 183				req->fw_buf = NULL;
 184			}
 185			release_firmware(req->fw);
 186			req->fw = NULL;
 187		}
 188	}
 189
 190	vfree(test_fw_config->reqs);
 191	test_fw_config->reqs = NULL;
 192}
 193
 194static void test_release_all_firmware(void)
 195{
 196	mutex_lock(&test_fw_mutex);
 197	__test_release_all_firmware();
 198	mutex_unlock(&test_fw_mutex);
 199}
 200
 201
 202static void __test_firmware_config_free(void)
 203{
 204	__test_release_all_firmware();
 205	kfree_const(test_fw_config->name);
 206	test_fw_config->name = NULL;
 207}
 208
 209/*
 210 * XXX: move to kstrncpy() once merged.
 211 *
 212 * Users should use kfree_const() when freeing these.
 213 */
 214static int __kstrncpy(char **dst, const char *name, size_t count, gfp_t gfp)
 215{
 216	*dst = kstrndup(name, count, gfp);
 217	if (!*dst)
 218		return -ENOMEM;
 219	return count;
 220}
 221
 222static int __test_firmware_config_init(void)
 223{
 224	int ret;
 225
 226	ret = __kstrncpy(&test_fw_config->name, TEST_FIRMWARE_NAME,
 227			 strlen(TEST_FIRMWARE_NAME), GFP_KERNEL);
 228	if (ret < 0)
 229		goto out;
 230
 231	test_fw_config->num_requests = TEST_FIRMWARE_NUM_REQS;
 232	test_fw_config->send_uevent = true;
 233	test_fw_config->into_buf = false;
 234	test_fw_config->buf_size = TEST_FIRMWARE_BUF_SIZE;
 235	test_fw_config->file_offset = 0;
 236	test_fw_config->partial = false;
 237	test_fw_config->sync_direct = false;
 238	test_fw_config->req_firmware = request_firmware;
 239	test_fw_config->test_result = 0;
 240	test_fw_config->reqs = NULL;
 241	test_fw_config->upload_name = NULL;
 242
 243	return 0;
 244
 245out:
 246	__test_firmware_config_free();
 247	return ret;
 248}
 249
 250static ssize_t reset_store(struct device *dev,
 251			   struct device_attribute *attr,
 252			   const char *buf, size_t count)
 253{
 254	int ret;
 255
 256	mutex_lock(&test_fw_mutex);
 257
 258	__test_firmware_config_free();
 259
 260	ret = __test_firmware_config_init();
 261	if (ret < 0) {
 262		ret = -ENOMEM;
 263		pr_err("could not alloc settings for config trigger: %d\n",
 264		       ret);
 265		goto out;
 266	}
 267
 268	pr_info("reset\n");
 269	ret = count;
 270
 271out:
 272	mutex_unlock(&test_fw_mutex);
 273
 274	return ret;
 275}
 276static DEVICE_ATTR_WO(reset);
 277
 278static ssize_t config_show(struct device *dev,
 279			   struct device_attribute *attr,
 280			   char *buf)
 281{
 282	int len = 0;
 283
 284	mutex_lock(&test_fw_mutex);
 285
 286	len += scnprintf(buf, PAGE_SIZE - len,
 287			"Custom trigger configuration for: %s\n",
 288			dev_name(dev));
 289
 290	if (test_fw_config->name)
 291		len += scnprintf(buf + len, PAGE_SIZE - len,
 292				"name:\t%s\n",
 293				test_fw_config->name);
 294	else
 295		len += scnprintf(buf + len, PAGE_SIZE - len,
 296				"name:\tEMPTY\n");
 297
 298	len += scnprintf(buf + len, PAGE_SIZE - len,
 299			"num_requests:\t%u\n", test_fw_config->num_requests);
 300
 301	len += scnprintf(buf + len, PAGE_SIZE - len,
 302			"send_uevent:\t\t%s\n",
 303			test_fw_config->send_uevent ?
 304			"FW_ACTION_UEVENT" :
 305			"FW_ACTION_NOUEVENT");
 306	len += scnprintf(buf + len, PAGE_SIZE - len,
 307			"into_buf:\t\t%s\n",
 308			str_true_false(test_fw_config->into_buf));
 309	len += scnprintf(buf + len, PAGE_SIZE - len,
 310			"buf_size:\t%zu\n", test_fw_config->buf_size);
 311	len += scnprintf(buf + len, PAGE_SIZE - len,
 312			"file_offset:\t%zu\n", test_fw_config->file_offset);
 313	len += scnprintf(buf + len, PAGE_SIZE - len,
 314			"partial:\t\t%s\n",
 315			str_true_false(test_fw_config->partial));
 316	len += scnprintf(buf + len, PAGE_SIZE - len,
 317			"sync_direct:\t\t%s\n",
 318			str_true_false(test_fw_config->sync_direct));
 319	len += scnprintf(buf + len, PAGE_SIZE - len,
 320			"read_fw_idx:\t%u\n", test_fw_config->read_fw_idx);
 321	if (test_fw_config->upload_name)
 322		len += scnprintf(buf + len, PAGE_SIZE - len,
 323				"upload_name:\t%s\n",
 324				test_fw_config->upload_name);
 325	else
 326		len += scnprintf(buf + len, PAGE_SIZE - len,
 327				"upload_name:\tEMPTY\n");
 328
 329	mutex_unlock(&test_fw_mutex);
 330
 331	return len;
 332}
 333static DEVICE_ATTR_RO(config);
 334
 335static ssize_t config_name_store(struct device *dev,
 336				 struct device_attribute *attr,
 337				 const char *buf, size_t count)
 338{
 339	int ret;
 340
 341	mutex_lock(&test_fw_mutex);
 342	kfree_const(test_fw_config->name);
 343	ret = __kstrncpy(&test_fw_config->name, buf, count, GFP_KERNEL);
 344	mutex_unlock(&test_fw_mutex);
 345
 346	return ret;
 347}
 348
 349/*
 350 * As per sysfs_kf_seq_show() the buf is max PAGE_SIZE.
 351 */
 352static ssize_t config_test_show_str(char *dst,
 353				    char *src)
 354{
 355	int len;
 356
 357	mutex_lock(&test_fw_mutex);
 358	len = snprintf(dst, PAGE_SIZE, "%s\n", src);
 359	mutex_unlock(&test_fw_mutex);
 360
 361	return len;
 362}
 363
 364static inline int __test_dev_config_update_bool(const char *buf, size_t size,
 365				       bool *cfg)
 366{
 367	int ret;
 368
 369	if (kstrtobool(buf, cfg) < 0)
 370		ret = -EINVAL;
 371	else
 372		ret = size;
 373
 374	return ret;
 375}
 376
 377static int test_dev_config_update_bool(const char *buf, size_t size,
 378				       bool *cfg)
 379{
 380	int ret;
 381
 382	mutex_lock(&test_fw_mutex);
 383	ret = __test_dev_config_update_bool(buf, size, cfg);
 384	mutex_unlock(&test_fw_mutex);
 385
 386	return ret;
 387}
 388
 389static ssize_t test_dev_config_show_bool(char *buf, bool val)
 390{
 391	return snprintf(buf, PAGE_SIZE, "%d\n", val);
 392}
 393
 394static int __test_dev_config_update_size_t(
 395					 const char *buf,
 396					 size_t size,
 397					 size_t *cfg)
 398{
 399	int ret;
 400	long new;
 401
 402	ret = kstrtol(buf, 10, &new);
 403	if (ret)
 404		return ret;
 405
 406	*(size_t *)cfg = new;
 407
 408	/* Always return full write size even if we didn't consume all */
 409	return size;
 410}
 411
 412static ssize_t test_dev_config_show_size_t(char *buf, size_t val)
 413{
 414	return snprintf(buf, PAGE_SIZE, "%zu\n", val);
 415}
 416
 417static ssize_t test_dev_config_show_int(char *buf, int val)
 418{
 419	return snprintf(buf, PAGE_SIZE, "%d\n", val);
 420}
 421
 422static int __test_dev_config_update_u8(const char *buf, size_t size, u8 *cfg)
 423{
 424	u8 val;
 425	int ret;
 426
 427	ret = kstrtou8(buf, 10, &val);
 428	if (ret)
 429		return ret;
 430
 431	*(u8 *)cfg = val;
 432
 433	/* Always return full write size even if we didn't consume all */
 434	return size;
 435}
 436
 437static int test_dev_config_update_u8(const char *buf, size_t size, u8 *cfg)
 438{
 439	int ret;
 440
 441	mutex_lock(&test_fw_mutex);
 442	ret = __test_dev_config_update_u8(buf, size, cfg);
 443	mutex_unlock(&test_fw_mutex);
 444
 445	return ret;
 446}
 447
 448static ssize_t test_dev_config_show_u8(char *buf, u8 val)
 449{
 450	return snprintf(buf, PAGE_SIZE, "%u\n", val);
 451}
 452
 453static ssize_t config_name_show(struct device *dev,
 454				struct device_attribute *attr,
 455				char *buf)
 456{
 457	return config_test_show_str(buf, test_fw_config->name);
 458}
 459static DEVICE_ATTR_RW(config_name);
 460
 461static ssize_t config_upload_name_store(struct device *dev,
 462					struct device_attribute *attr,
 463					const char *buf, size_t count)
 464{
 465	struct test_firmware_upload *tst;
 466	int ret = count;
 467
 468	mutex_lock(&test_fw_mutex);
 469	tst = upload_lookup_name(buf);
 470	if (tst)
 471		test_fw_config->upload_name = tst->name;
 472	else
 473		ret = -EINVAL;
 474	mutex_unlock(&test_fw_mutex);
 475
 476	return ret;
 477}
 478
 479static ssize_t config_upload_name_show(struct device *dev,
 480				       struct device_attribute *attr,
 481				       char *buf)
 482{
 483	return config_test_show_str(buf, test_fw_config->upload_name);
 484}
 485static DEVICE_ATTR_RW(config_upload_name);
 486
 487static ssize_t config_num_requests_store(struct device *dev,
 488					 struct device_attribute *attr,
 489					 const char *buf, size_t count)
 490{
 491	int rc;
 492
 493	mutex_lock(&test_fw_mutex);
 494	if (test_fw_config->reqs) {
 495		pr_err("Must call release_all_firmware prior to changing config\n");
 496		rc = -EINVAL;
 497		mutex_unlock(&test_fw_mutex);
 498		goto out;
 499	}
 500
 501	rc = __test_dev_config_update_u8(buf, count,
 502					 &test_fw_config->num_requests);
 503	mutex_unlock(&test_fw_mutex);
 504
 505out:
 506	return rc;
 507}
 508
 509static ssize_t config_num_requests_show(struct device *dev,
 510					struct device_attribute *attr,
 511					char *buf)
 512{
 513	return test_dev_config_show_u8(buf, test_fw_config->num_requests);
 514}
 515static DEVICE_ATTR_RW(config_num_requests);
 516
 517static ssize_t config_into_buf_store(struct device *dev,
 518				     struct device_attribute *attr,
 519				     const char *buf, size_t count)
 520{
 521	return test_dev_config_update_bool(buf,
 522					   count,
 523					   &test_fw_config->into_buf);
 524}
 525
 526static ssize_t config_into_buf_show(struct device *dev,
 527				    struct device_attribute *attr,
 528				    char *buf)
 529{
 530	return test_dev_config_show_bool(buf, test_fw_config->into_buf);
 531}
 532static DEVICE_ATTR_RW(config_into_buf);
 533
 534static ssize_t config_buf_size_store(struct device *dev,
 535				     struct device_attribute *attr,
 536				     const char *buf, size_t count)
 537{
 538	int rc;
 539
 540	mutex_lock(&test_fw_mutex);
 541	if (test_fw_config->reqs) {
 542		pr_err("Must call release_all_firmware prior to changing config\n");
 543		rc = -EINVAL;
 544		mutex_unlock(&test_fw_mutex);
 545		goto out;
 546	}
 547
 548	rc = __test_dev_config_update_size_t(buf, count,
 549					     &test_fw_config->buf_size);
 550	mutex_unlock(&test_fw_mutex);
 551
 552out:
 553	return rc;
 554}
 555
 556static ssize_t config_buf_size_show(struct device *dev,
 557				    struct device_attribute *attr,
 558				    char *buf)
 559{
 560	return test_dev_config_show_size_t(buf, test_fw_config->buf_size);
 561}
 562static DEVICE_ATTR_RW(config_buf_size);
 563
 564static ssize_t config_file_offset_store(struct device *dev,
 565					struct device_attribute *attr,
 566					const char *buf, size_t count)
 567{
 568	int rc;
 569
 570	mutex_lock(&test_fw_mutex);
 571	if (test_fw_config->reqs) {
 572		pr_err("Must call release_all_firmware prior to changing config\n");
 573		rc = -EINVAL;
 574		mutex_unlock(&test_fw_mutex);
 575		goto out;
 576	}
 577
 578	rc = __test_dev_config_update_size_t(buf, count,
 579					     &test_fw_config->file_offset);
 580	mutex_unlock(&test_fw_mutex);
 581
 582out:
 583	return rc;
 584}
 585
 586static ssize_t config_file_offset_show(struct device *dev,
 587				       struct device_attribute *attr,
 588				       char *buf)
 589{
 590	return test_dev_config_show_size_t(buf, test_fw_config->file_offset);
 591}
 592static DEVICE_ATTR_RW(config_file_offset);
 593
 594static ssize_t config_partial_store(struct device *dev,
 595				    struct device_attribute *attr,
 596				    const char *buf, size_t count)
 597{
 598	return test_dev_config_update_bool(buf,
 599					   count,
 600					   &test_fw_config->partial);
 601}
 602
 603static ssize_t config_partial_show(struct device *dev,
 604				   struct device_attribute *attr,
 605				   char *buf)
 606{
 607	return test_dev_config_show_bool(buf, test_fw_config->partial);
 608}
 609static DEVICE_ATTR_RW(config_partial);
 610
 611static ssize_t config_sync_direct_store(struct device *dev,
 612					struct device_attribute *attr,
 613					const char *buf, size_t count)
 614{
 615	int rc = test_dev_config_update_bool(buf, count,
 616					     &test_fw_config->sync_direct);
 617
 618	if (rc == count)
 619		test_fw_config->req_firmware = test_fw_config->sync_direct ?
 620				       request_firmware_direct :
 621				       request_firmware;
 622	return rc;
 623}
 624
 625static ssize_t config_sync_direct_show(struct device *dev,
 626				       struct device_attribute *attr,
 627				       char *buf)
 628{
 629	return test_dev_config_show_bool(buf, test_fw_config->sync_direct);
 630}
 631static DEVICE_ATTR_RW(config_sync_direct);
 632
 633static ssize_t config_send_uevent_store(struct device *dev,
 634					struct device_attribute *attr,
 635					const char *buf, size_t count)
 636{
 637	return test_dev_config_update_bool(buf, count,
 638					   &test_fw_config->send_uevent);
 639}
 640
 641static ssize_t config_send_uevent_show(struct device *dev,
 642				       struct device_attribute *attr,
 643				       char *buf)
 644{
 645	return test_dev_config_show_bool(buf, test_fw_config->send_uevent);
 646}
 647static DEVICE_ATTR_RW(config_send_uevent);
 648
 649static ssize_t config_read_fw_idx_store(struct device *dev,
 650					struct device_attribute *attr,
 651					const char *buf, size_t count)
 652{
 653	return test_dev_config_update_u8(buf, count,
 654					 &test_fw_config->read_fw_idx);
 655}
 656
 657static ssize_t config_read_fw_idx_show(struct device *dev,
 658				       struct device_attribute *attr,
 659				       char *buf)
 660{
 661	return test_dev_config_show_u8(buf, test_fw_config->read_fw_idx);
 662}
 663static DEVICE_ATTR_RW(config_read_fw_idx);
 664
 665
 666static ssize_t trigger_request_store(struct device *dev,
 667				     struct device_attribute *attr,
 668				     const char *buf, size_t count)
 669{
 670	int rc;
 671	char *name;
 672
 673	name = kstrndup(buf, count, GFP_KERNEL);
 674	if (!name)
 675		return -ENOMEM;
 676
 677	pr_info("loading '%s'\n", name);
 678
 679	mutex_lock(&test_fw_mutex);
 680	release_firmware(test_firmware);
 681	if (test_fw_config->reqs)
 682		__test_release_all_firmware();
 683	test_firmware = NULL;
 684	rc = request_firmware(&test_firmware, name, dev);
 685	if (rc) {
 686		pr_info("load of '%s' failed: %d\n", name, rc);
 687		goto out;
 688	}
 689	pr_info("loaded: %zu\n", test_firmware->size);
 690	rc = count;
 691
 692out:
 693	mutex_unlock(&test_fw_mutex);
 694
 695	kfree(name);
 696
 697	return rc;
 698}
 699static DEVICE_ATTR_WO(trigger_request);
 700
 701#ifdef CONFIG_EFI_EMBEDDED_FIRMWARE
 702extern struct list_head efi_embedded_fw_list;
 703extern bool efi_embedded_fw_checked;
 704
 705static ssize_t trigger_request_platform_store(struct device *dev,
 706					      struct device_attribute *attr,
 707					      const char *buf, size_t count)
 708{
 709	static const u8 test_data[] = {
 710		0x55, 0xaa, 0x55, 0xaa, 0x01, 0x02, 0x03, 0x04,
 711		0x55, 0xaa, 0x55, 0xaa, 0x05, 0x06, 0x07, 0x08,
 712		0x55, 0xaa, 0x55, 0xaa, 0x10, 0x20, 0x30, 0x40,
 713		0x55, 0xaa, 0x55, 0xaa, 0x50, 0x60, 0x70, 0x80
 714	};
 715	struct efi_embedded_fw efi_embedded_fw;
 716	const struct firmware *firmware = NULL;
 717	bool saved_efi_embedded_fw_checked;
 718	char *name;
 719	int rc;
 720
 721	name = kstrndup(buf, count, GFP_KERNEL);
 722	if (!name)
 723		return -ENOMEM;
 724
 725	pr_info("inserting test platform fw '%s'\n", name);
 726	efi_embedded_fw.name = name;
 727	efi_embedded_fw.data = (void *)test_data;
 728	efi_embedded_fw.length = sizeof(test_data);
 729	list_add(&efi_embedded_fw.list, &efi_embedded_fw_list);
 730	saved_efi_embedded_fw_checked = efi_embedded_fw_checked;
 731	efi_embedded_fw_checked = true;
 732
 733	pr_info("loading '%s'\n", name);
 734	rc = firmware_request_platform(&firmware, name, dev);
 735	if (rc) {
 736		pr_info("load of '%s' failed: %d\n", name, rc);
 737		goto out;
 738	}
 739	if (firmware->size != sizeof(test_data) ||
 740	    memcmp(firmware->data, test_data, sizeof(test_data)) != 0) {
 741		pr_info("firmware contents mismatch for '%s'\n", name);
 742		rc = -EINVAL;
 743		goto out;
 744	}
 745	pr_info("loaded: %zu\n", firmware->size);
 746	rc = count;
 747
 748out:
 749	efi_embedded_fw_checked = saved_efi_embedded_fw_checked;
 750	release_firmware(firmware);
 751	list_del(&efi_embedded_fw.list);
 752	kfree(name);
 753
 754	return rc;
 755}
 756static DEVICE_ATTR_WO(trigger_request_platform);
 757#endif
 758
 759static DECLARE_COMPLETION(async_fw_done);
 760
 761static void trigger_async_request_cb(const struct firmware *fw, void *context)
 762{
 763	test_firmware = fw;
 764	complete(&async_fw_done);
 765}
 766
 767static ssize_t trigger_async_request_store(struct device *dev,
 768					   struct device_attribute *attr,
 769					   const char *buf, size_t count)
 770{
 771	int rc;
 772	char *name;
 773
 774	name = kstrndup(buf, count, GFP_KERNEL);
 775	if (!name)
 776		return -ENOMEM;
 777
 778	pr_info("loading '%s'\n", name);
 779
 780	mutex_lock(&test_fw_mutex);
 781	release_firmware(test_firmware);
 782	test_firmware = NULL;
 783	if (test_fw_config->reqs)
 784		__test_release_all_firmware();
 785	rc = request_firmware_nowait(THIS_MODULE, 1, name, dev, GFP_KERNEL,
 786				     NULL, trigger_async_request_cb);
 787	if (rc) {
 788		pr_info("async load of '%s' failed: %d\n", name, rc);
 789		kfree(name);
 790		goto out;
 791	}
 792	/* Free 'name' ASAP, to test for race conditions */
 793	kfree(name);
 794
 795	wait_for_completion(&async_fw_done);
 796
 797	if (test_firmware) {
 798		pr_info("loaded: %zu\n", test_firmware->size);
 799		rc = count;
 800	} else {
 801		pr_err("failed to async load firmware\n");
 802		rc = -ENOMEM;
 803	}
 804
 805out:
 806	mutex_unlock(&test_fw_mutex);
 807
 808	return rc;
 809}
 810static DEVICE_ATTR_WO(trigger_async_request);
 811
 812static ssize_t trigger_custom_fallback_store(struct device *dev,
 813					     struct device_attribute *attr,
 814					     const char *buf, size_t count)
 815{
 816	int rc;
 817	char *name;
 818
 819	name = kstrndup(buf, count, GFP_KERNEL);
 820	if (!name)
 821		return -ENOMEM;
 822
 823	pr_info("loading '%s' using custom fallback mechanism\n", name);
 824
 825	mutex_lock(&test_fw_mutex);
 826	release_firmware(test_firmware);
 827	if (test_fw_config->reqs)
 828		__test_release_all_firmware();
 829	test_firmware = NULL;
 830	rc = request_firmware_nowait(THIS_MODULE, FW_ACTION_NOUEVENT, name,
 831				     dev, GFP_KERNEL, NULL,
 832				     trigger_async_request_cb);
 833	if (rc) {
 834		pr_info("async load of '%s' failed: %d\n", name, rc);
 835		kfree(name);
 836		goto out;
 837	}
 838	/* Free 'name' ASAP, to test for race conditions */
 839	kfree(name);
 840
 841	wait_for_completion(&async_fw_done);
 842
 843	if (test_firmware) {
 844		pr_info("loaded: %zu\n", test_firmware->size);
 845		rc = count;
 846	} else {
 847		pr_err("failed to async load firmware\n");
 848		rc = -ENODEV;
 849	}
 850
 851out:
 852	mutex_unlock(&test_fw_mutex);
 853
 854	return rc;
 855}
 856static DEVICE_ATTR_WO(trigger_custom_fallback);
 857
 858static int test_fw_run_batch_request(void *data)
 859{
 860	struct test_batched_req *req = data;
 861
 862	if (!req) {
 863		test_fw_config->test_result = -EINVAL;
 864		return -EINVAL;
 865	}
 866
 867	if (test_fw_config->into_buf) {
 868		void *test_buf;
 869
 870		test_buf = kzalloc(TEST_FIRMWARE_BUF_SIZE, GFP_KERNEL);
 871		if (!test_buf)
 872			return -ENOMEM;
 873
 874		if (test_fw_config->partial)
 875			req->rc = request_partial_firmware_into_buf
 876						(&req->fw,
 877						 req->name,
 878						 req->dev,
 879						 test_buf,
 880						 test_fw_config->buf_size,
 881						 test_fw_config->file_offset);
 882		else
 883			req->rc = request_firmware_into_buf
 884						(&req->fw,
 885						 req->name,
 886						 req->dev,
 887						 test_buf,
 888						 test_fw_config->buf_size);
 889		if (!req->fw)
 890			kfree(test_buf);
 891		else
 892			req->fw_buf = test_buf;
 893	} else {
 894		req->rc = test_fw_config->req_firmware(&req->fw,
 895						       req->name,
 896						       req->dev);
 897	}
 898
 899	if (req->rc) {
 900		pr_info("#%u: batched sync load failed: %d\n",
 901			req->idx, req->rc);
 902		if (!test_fw_config->test_result)
 903			test_fw_config->test_result = req->rc;
 904	} else if (req->fw) {
 905		req->sent = true;
 906		pr_info("#%u: batched sync loaded %zu\n",
 907			req->idx, req->fw->size);
 908	}
 909	complete(&req->completion);
 910
 911	req->task = NULL;
 912
 913	return 0;
 914}
 915
 916/*
 917 * We use a kthread as otherwise the kernel serializes all our sync requests
 918 * and we would not be able to mimic batched requests on a sync call. Batched
 919 * requests on a sync call can for instance happen on a device driver when
 920 * multiple cards are used and firmware loading happens outside of probe.
 921 */
 922static ssize_t trigger_batched_requests_store(struct device *dev,
 923					      struct device_attribute *attr,
 924					      const char *buf, size_t count)
 925{
 926	struct test_batched_req *req;
 927	int rc;
 928	u8 i;
 929
 930	mutex_lock(&test_fw_mutex);
 931
 932	if (test_fw_config->reqs) {
 933		rc = -EBUSY;
 934		goto out_bail;
 935	}
 936
 937	test_fw_config->reqs =
 938		vzalloc(array3_size(sizeof(struct test_batched_req),
 939				    test_fw_config->num_requests, 2));
 940	if (!test_fw_config->reqs) {
 941		rc = -ENOMEM;
 942		goto out_unlock;
 943	}
 944
 945	pr_info("batched sync firmware loading '%s' %u times\n",
 946		test_fw_config->name, test_fw_config->num_requests);
 947
 948	for (i = 0; i < test_fw_config->num_requests; i++) {
 949		req = &test_fw_config->reqs[i];
 950		req->fw = NULL;
 951		req->idx = i;
 952		req->name = test_fw_config->name;
 953		req->fw_buf = NULL;
 954		req->dev = dev;
 955		init_completion(&req->completion);
 956		req->task = kthread_run(test_fw_run_batch_request, req,
 957					     "%s-%u", KBUILD_MODNAME, req->idx);
 958		if (!req->task || IS_ERR(req->task)) {
 959			pr_err("Setting up thread %u failed\n", req->idx);
 960			req->task = NULL;
 961			rc = -ENOMEM;
 962			goto out_bail;
 963		}
 964	}
 965
 966	rc = count;
 967
 968	/*
 969	 * We require an explicit release to enable more time and delay of
 970	 * calling release_firmware() to improve our chances of forcing a
 971	 * batched request. If we instead called release_firmware() right away
 972	 * then we might miss on an opportunity of having a successful firmware
 973	 * request pass on the opportunity to be come a batched request.
 974	 */
 975
 976out_bail:
 977	for (i = 0; i < test_fw_config->num_requests; i++) {
 978		req = &test_fw_config->reqs[i];
 979		if (req->task || req->sent)
 980			wait_for_completion(&req->completion);
 981	}
 982
 983	/* Override any worker error if we had a general setup error */
 984	if (rc < 0)
 985		test_fw_config->test_result = rc;
 986
 987out_unlock:
 988	mutex_unlock(&test_fw_mutex);
 989
 990	return rc;
 991}
 992static DEVICE_ATTR_WO(trigger_batched_requests);
 993
 994/*
 995 * We wait for each callback to return with the lock held, no need to lock here
 996 */
 997static void trigger_batched_cb(const struct firmware *fw, void *context)
 998{
 999	struct test_batched_req *req = context;
1000
1001	if (!req) {
1002		test_fw_config->test_result = -EINVAL;
1003		return;
1004	}
1005
1006	/* forces *some* batched requests to queue up */
1007	if (!req->idx)
1008		ssleep(2);
1009
1010	req->fw = fw;
1011
1012	/*
1013	 * Unfortunately the firmware API gives us nothing other than a null FW
1014	 * if the firmware was not found on async requests.  Best we can do is
1015	 * just assume -ENOENT. A better API would pass the actual return
1016	 * value to the callback.
1017	 */
1018	if (!fw && !test_fw_config->test_result)
1019		test_fw_config->test_result = -ENOENT;
1020
1021	complete(&req->completion);
1022}
1023
1024static
1025ssize_t trigger_batched_requests_async_store(struct device *dev,
1026					     struct device_attribute *attr,
1027					     const char *buf, size_t count)
1028{
1029	struct test_batched_req *req;
1030	bool send_uevent;
1031	int rc;
1032	u8 i;
1033
1034	mutex_lock(&test_fw_mutex);
1035
1036	if (test_fw_config->reqs) {
1037		rc = -EBUSY;
1038		goto out_bail;
1039	}
1040
1041	test_fw_config->reqs =
1042		vzalloc(array3_size(sizeof(struct test_batched_req),
1043				    test_fw_config->num_requests, 2));
1044	if (!test_fw_config->reqs) {
1045		rc = -ENOMEM;
1046		goto out;
1047	}
1048
1049	pr_info("batched loading '%s' custom fallback mechanism %u times\n",
1050		test_fw_config->name, test_fw_config->num_requests);
1051
1052	send_uevent = test_fw_config->send_uevent ? FW_ACTION_UEVENT :
1053		FW_ACTION_NOUEVENT;
1054
1055	for (i = 0; i < test_fw_config->num_requests; i++) {
1056		req = &test_fw_config->reqs[i];
1057		req->name = test_fw_config->name;
1058		req->fw_buf = NULL;
1059		req->fw = NULL;
1060		req->idx = i;
1061		init_completion(&req->completion);
1062		rc = request_firmware_nowait(THIS_MODULE, send_uevent,
1063					     req->name,
1064					     dev, GFP_KERNEL, req,
1065					     trigger_batched_cb);
1066		if (rc) {
1067			pr_info("#%u: batched async load failed setup: %d\n",
1068				i, rc);
1069			req->rc = rc;
1070			goto out_bail;
1071		} else
1072			req->sent = true;
1073	}
1074
1075	rc = count;
1076
1077out_bail:
1078
1079	/*
1080	 * We require an explicit release to enable more time and delay of
1081	 * calling release_firmware() to improve our chances of forcing a
1082	 * batched request. If we instead called release_firmware() right away
1083	 * then we might miss on an opportunity of having a successful firmware
1084	 * request pass on the opportunity to be come a batched request.
1085	 */
1086
1087	for (i = 0; i < test_fw_config->num_requests; i++) {
1088		req = &test_fw_config->reqs[i];
1089		if (req->sent)
1090			wait_for_completion(&req->completion);
1091	}
1092
1093	/* Override any worker error if we had a general setup error */
1094	if (rc < 0)
1095		test_fw_config->test_result = rc;
1096
1097out:
1098	mutex_unlock(&test_fw_mutex);
1099
1100	return rc;
1101}
1102static DEVICE_ATTR_WO(trigger_batched_requests_async);
1103
1104static void upload_release(struct test_firmware_upload *tst)
1105{
1106	firmware_upload_unregister(tst->fwl);
1107	kfree(tst->buf);
1108	kfree(tst->name);
1109	kfree(tst);
1110}
1111
1112static void upload_release_all(void)
1113{
1114	struct test_firmware_upload *tst, *tmp;
1115
1116	list_for_each_entry_safe(tst, tmp, &test_upload_list, node) {
1117		list_del(&tst->node);
1118		upload_release(tst);
1119	}
1120	test_fw_config->upload_name = NULL;
1121}
1122
1123/*
1124 * This table is replicated from .../firmware_loader/sysfs_upload.c
1125 * and needs to be kept in sync.
1126 */
1127static const char * const fw_upload_err_str[] = {
1128	[FW_UPLOAD_ERR_NONE]	     = "none",
1129	[FW_UPLOAD_ERR_HW_ERROR]     = "hw-error",
1130	[FW_UPLOAD_ERR_TIMEOUT]	     = "timeout",
1131	[FW_UPLOAD_ERR_CANCELED]     = "user-abort",
1132	[FW_UPLOAD_ERR_BUSY]	     = "device-busy",
1133	[FW_UPLOAD_ERR_INVALID_SIZE] = "invalid-file-size",
1134	[FW_UPLOAD_ERR_RW_ERROR]     = "read-write-error",
1135	[FW_UPLOAD_ERR_WEAROUT]	     = "flash-wearout",
1136	[FW_UPLOAD_ERR_FW_INVALID]   = "firmware-invalid",
1137};
1138
1139static void upload_err_inject_error(struct test_firmware_upload *tst,
1140				    const u8 *p, const char *prog)
1141{
1142	enum fw_upload_err err;
1143
1144	for (err = FW_UPLOAD_ERR_NONE + 1; err < FW_UPLOAD_ERR_MAX; err++) {
1145		if (strncmp(p, fw_upload_err_str[err],
1146			    strlen(fw_upload_err_str[err])) == 0) {
1147			tst->inject.prog = prog;
1148			tst->inject.err_code = err;
1149			return;
1150		}
1151	}
1152}
1153
1154static void upload_err_inject_prog(struct test_firmware_upload *tst,
1155				   const u8 *p)
1156{
1157	static const char * const progs[] = {
1158		"preparing:", "transferring:", "programming:"
1159	};
1160	int i;
1161
1162	for (i = 0; i < ARRAY_SIZE(progs); i++) {
1163		if (strncmp(p, progs[i], strlen(progs[i])) == 0) {
1164			upload_err_inject_error(tst, p + strlen(progs[i]),
1165						progs[i]);
1166			return;
1167		}
1168	}
1169}
1170
1171#define FIVE_MINUTES_MS	(5 * 60 * 1000)
1172static enum fw_upload_err
1173fw_upload_wait_on_cancel(struct test_firmware_upload *tst)
1174{
1175	int ms_delay;
1176
1177	for (ms_delay = 0; ms_delay < FIVE_MINUTES_MS; ms_delay += 100) {
1178		msleep(100);
1179		if (tst->cancel_request)
1180			return FW_UPLOAD_ERR_CANCELED;
1181	}
1182	return FW_UPLOAD_ERR_NONE;
1183}
1184
1185static enum fw_upload_err test_fw_upload_prepare(struct fw_upload *fwl,
1186						 const u8 *data, u32 size)
1187{
1188	struct test_firmware_upload *tst = fwl->dd_handle;
1189	enum fw_upload_err ret = FW_UPLOAD_ERR_NONE;
1190	const char *progress = "preparing:";
1191
1192	tst->cancel_request = false;
1193
1194	if (!size || size > TEST_UPLOAD_MAX_SIZE) {
1195		ret = FW_UPLOAD_ERR_INVALID_SIZE;
1196		goto err_out;
1197	}
1198
1199	if (strncmp(data, "inject:", strlen("inject:")) == 0)
1200		upload_err_inject_prog(tst, data + strlen("inject:"));
1201
1202	memset(tst->buf, 0, TEST_UPLOAD_MAX_SIZE);
1203	tst->size = size;
1204
1205	if (tst->inject.err_code == FW_UPLOAD_ERR_NONE ||
1206	    strncmp(tst->inject.prog, progress, strlen(progress)) != 0)
1207		return FW_UPLOAD_ERR_NONE;
1208
1209	if (tst->inject.err_code == FW_UPLOAD_ERR_CANCELED)
1210		ret = fw_upload_wait_on_cancel(tst);
1211	else
1212		ret = tst->inject.err_code;
1213
1214err_out:
1215	/*
1216	 * The cleanup op only executes if the prepare op succeeds.
1217	 * If the prepare op fails, it must do it's own clean-up.
1218	 */
1219	tst->inject.err_code = FW_UPLOAD_ERR_NONE;
1220	tst->inject.prog = NULL;
1221
1222	return ret;
1223}
1224
1225static enum fw_upload_err test_fw_upload_write(struct fw_upload *fwl,
1226					       const u8 *data, u32 offset,
1227					       u32 size, u32 *written)
1228{
1229	struct test_firmware_upload *tst = fwl->dd_handle;
1230	const char *progress = "transferring:";
1231	u32 blk_size;
1232
1233	if (tst->cancel_request)
1234		return FW_UPLOAD_ERR_CANCELED;
1235
1236	blk_size = min_t(u32, TEST_UPLOAD_BLK_SIZE, size);
1237	memcpy(tst->buf + offset, data + offset, blk_size);
1238
1239	*written = blk_size;
1240
1241	if (tst->inject.err_code == FW_UPLOAD_ERR_NONE ||
1242	    strncmp(tst->inject.prog, progress, strlen(progress)) != 0)
1243		return FW_UPLOAD_ERR_NONE;
1244
1245	if (tst->inject.err_code == FW_UPLOAD_ERR_CANCELED)
1246		return fw_upload_wait_on_cancel(tst);
1247
1248	return tst->inject.err_code;
1249}
1250
1251static enum fw_upload_err test_fw_upload_complete(struct fw_upload *fwl)
1252{
1253	struct test_firmware_upload *tst = fwl->dd_handle;
1254	const char *progress = "programming:";
1255
1256	if (tst->cancel_request)
1257		return FW_UPLOAD_ERR_CANCELED;
1258
1259	if (tst->inject.err_code == FW_UPLOAD_ERR_NONE ||
1260	    strncmp(tst->inject.prog, progress, strlen(progress)) != 0)
1261		return FW_UPLOAD_ERR_NONE;
1262
1263	if (tst->inject.err_code == FW_UPLOAD_ERR_CANCELED)
1264		return fw_upload_wait_on_cancel(tst);
1265
1266	return tst->inject.err_code;
1267}
1268
1269static void test_fw_upload_cancel(struct fw_upload *fwl)
1270{
1271	struct test_firmware_upload *tst = fwl->dd_handle;
1272
1273	tst->cancel_request = true;
1274}
1275
1276static void test_fw_cleanup(struct fw_upload *fwl)
1277{
1278	struct test_firmware_upload *tst = fwl->dd_handle;
1279
1280	tst->inject.err_code = FW_UPLOAD_ERR_NONE;
1281	tst->inject.prog = NULL;
1282}
1283
1284static const struct fw_upload_ops upload_test_ops = {
1285	.prepare = test_fw_upload_prepare,
1286	.write = test_fw_upload_write,
1287	.poll_complete = test_fw_upload_complete,
1288	.cancel = test_fw_upload_cancel,
1289	.cleanup = test_fw_cleanup
1290};
1291
1292static ssize_t upload_register_store(struct device *dev,
1293				     struct device_attribute *attr,
1294				     const char *buf, size_t count)
1295{
1296	struct test_firmware_upload *tst;
1297	struct fw_upload *fwl;
1298	char *name;
1299	int ret;
1300
1301	name = kstrndup(buf, count, GFP_KERNEL);
1302	if (!name)
1303		return -ENOMEM;
1304
1305	mutex_lock(&test_fw_mutex);
1306	tst = upload_lookup_name(name);
1307	if (tst) {
1308		ret = -EEXIST;
1309		goto free_name;
1310	}
1311
1312	tst = kzalloc(sizeof(*tst), GFP_KERNEL);
1313	if (!tst) {
1314		ret = -ENOMEM;
1315		goto free_name;
1316	}
1317
1318	tst->name = name;
1319	tst->buf = kzalloc(TEST_UPLOAD_MAX_SIZE, GFP_KERNEL);
1320	if (!tst->buf) {
1321		ret = -ENOMEM;
1322		goto free_tst;
1323	}
1324
1325	fwl = firmware_upload_register(THIS_MODULE, dev, tst->name,
1326				       &upload_test_ops, tst);
1327	if (IS_ERR(fwl)) {
1328		ret = PTR_ERR(fwl);
1329		goto free_buf;
1330	}
1331
1332	tst->fwl = fwl;
1333	list_add_tail(&tst->node, &test_upload_list);
1334	mutex_unlock(&test_fw_mutex);
1335	return count;
1336
1337free_buf:
1338	kfree(tst->buf);
1339
1340free_tst:
1341	kfree(tst);
1342
1343free_name:
1344	mutex_unlock(&test_fw_mutex);
1345	kfree(name);
1346
1347	return ret;
1348}
1349static DEVICE_ATTR_WO(upload_register);
1350
1351static ssize_t upload_unregister_store(struct device *dev,
1352				       struct device_attribute *attr,
1353				       const char *buf, size_t count)
1354{
1355	struct test_firmware_upload *tst;
1356	int ret = count;
1357
1358	mutex_lock(&test_fw_mutex);
1359	tst = upload_lookup_name(buf);
1360	if (!tst) {
1361		ret = -EINVAL;
1362		goto out;
1363	}
1364
1365	if (test_fw_config->upload_name == tst->name)
1366		test_fw_config->upload_name = NULL;
1367
1368	list_del(&tst->node);
1369	upload_release(tst);
1370
1371out:
1372	mutex_unlock(&test_fw_mutex);
1373	return ret;
1374}
1375static DEVICE_ATTR_WO(upload_unregister);
1376
1377static ssize_t test_result_show(struct device *dev,
1378				struct device_attribute *attr,
1379				char *buf)
1380{
1381	return test_dev_config_show_int(buf, test_fw_config->test_result);
1382}
1383static DEVICE_ATTR_RO(test_result);
1384
1385static ssize_t release_all_firmware_store(struct device *dev,
1386					  struct device_attribute *attr,
1387					  const char *buf, size_t count)
1388{
1389	test_release_all_firmware();
1390	return count;
1391}
1392static DEVICE_ATTR_WO(release_all_firmware);
1393
1394static ssize_t read_firmware_show(struct device *dev,
1395				  struct device_attribute *attr,
1396				  char *buf)
1397{
1398	struct test_batched_req *req;
1399	u8 idx;
1400	ssize_t rc = 0;
1401
1402	mutex_lock(&test_fw_mutex);
1403
1404	idx = test_fw_config->read_fw_idx;
1405	if (idx >= test_fw_config->num_requests) {
1406		rc = -ERANGE;
1407		goto out;
1408	}
1409
1410	if (!test_fw_config->reqs) {
1411		rc = -EINVAL;
1412		goto out;
1413	}
1414
1415	req = &test_fw_config->reqs[idx];
1416	if (!req->fw) {
1417		pr_err("#%u: failed to async load firmware\n", idx);
1418		rc = -ENOENT;
1419		goto out;
1420	}
1421
1422	pr_info("#%u: loaded %zu\n", idx, req->fw->size);
1423
1424	if (req->fw->size > PAGE_SIZE) {
1425		pr_err("Testing interface must use PAGE_SIZE firmware for now\n");
1426		rc = -EINVAL;
1427		goto out;
1428	}
1429	memcpy(buf, req->fw->data, req->fw->size);
1430
1431	rc = req->fw->size;
1432out:
1433	mutex_unlock(&test_fw_mutex);
1434
1435	return rc;
1436}
1437static DEVICE_ATTR_RO(read_firmware);
1438
1439static ssize_t upload_read_show(struct device *dev,
1440				struct device_attribute *attr,
1441				char *buf)
1442{
1443	struct test_firmware_upload *tst = NULL;
1444	struct test_firmware_upload *tst_iter;
1445	int ret = -EINVAL;
1446
1447	if (!test_fw_config->upload_name) {
1448		pr_err("Set config_upload_name before using upload_read\n");
1449		return -EINVAL;
1450	}
1451
1452	mutex_lock(&test_fw_mutex);
1453	list_for_each_entry(tst_iter, &test_upload_list, node)
1454		if (tst_iter->name == test_fw_config->upload_name) {
1455			tst = tst_iter;
1456			break;
1457		}
1458
1459	if (!tst) {
1460		pr_err("Firmware name not found: %s\n",
1461		       test_fw_config->upload_name);
1462		goto out;
1463	}
1464
1465	if (tst->size > PAGE_SIZE) {
1466		pr_err("Testing interface must use PAGE_SIZE firmware for now\n");
1467		goto out;
1468	}
1469
1470	memcpy(buf, tst->buf, tst->size);
1471	ret = tst->size;
1472out:
1473	mutex_unlock(&test_fw_mutex);
1474	return ret;
1475}
1476static DEVICE_ATTR_RO(upload_read);
1477
1478#define TEST_FW_DEV_ATTR(name)          &dev_attr_##name.attr
1479
1480static struct attribute *test_dev_attrs[] = {
1481	TEST_FW_DEV_ATTR(reset),
1482
1483	TEST_FW_DEV_ATTR(config),
1484	TEST_FW_DEV_ATTR(config_name),
1485	TEST_FW_DEV_ATTR(config_num_requests),
1486	TEST_FW_DEV_ATTR(config_into_buf),
1487	TEST_FW_DEV_ATTR(config_buf_size),
1488	TEST_FW_DEV_ATTR(config_file_offset),
1489	TEST_FW_DEV_ATTR(config_partial),
1490	TEST_FW_DEV_ATTR(config_sync_direct),
1491	TEST_FW_DEV_ATTR(config_send_uevent),
1492	TEST_FW_DEV_ATTR(config_read_fw_idx),
1493	TEST_FW_DEV_ATTR(config_upload_name),
1494
1495	/* These don't use the config at all - they could be ported! */
1496	TEST_FW_DEV_ATTR(trigger_request),
1497	TEST_FW_DEV_ATTR(trigger_async_request),
1498	TEST_FW_DEV_ATTR(trigger_custom_fallback),
1499#ifdef CONFIG_EFI_EMBEDDED_FIRMWARE
1500	TEST_FW_DEV_ATTR(trigger_request_platform),
1501#endif
1502
1503	/* These use the config and can use the test_result */
1504	TEST_FW_DEV_ATTR(trigger_batched_requests),
1505	TEST_FW_DEV_ATTR(trigger_batched_requests_async),
1506
1507	TEST_FW_DEV_ATTR(release_all_firmware),
1508	TEST_FW_DEV_ATTR(test_result),
1509	TEST_FW_DEV_ATTR(read_firmware),
1510	TEST_FW_DEV_ATTR(upload_read),
1511	TEST_FW_DEV_ATTR(upload_register),
1512	TEST_FW_DEV_ATTR(upload_unregister),
1513	NULL,
1514};
1515
1516ATTRIBUTE_GROUPS(test_dev);
1517
1518static struct miscdevice test_fw_misc_device = {
1519	.minor          = MISC_DYNAMIC_MINOR,
1520	.name           = "test_firmware",
1521	.fops           = &test_fw_fops,
1522	.groups 	= test_dev_groups,
1523};
1524
1525static int __init test_firmware_init(void)
1526{
1527	int rc;
1528
1529	test_fw_config = kzalloc(sizeof(struct test_config), GFP_KERNEL);
1530	if (!test_fw_config)
1531		return -ENOMEM;
1532
1533	rc = __test_firmware_config_init();
1534	if (rc) {
1535		kfree(test_fw_config);
1536		pr_err("could not init firmware test config: %d\n", rc);
1537		return rc;
1538	}
1539
1540	rc = misc_register(&test_fw_misc_device);
1541	if (rc) {
1542		__test_firmware_config_free();
1543		kfree(test_fw_config);
1544		pr_err("could not register misc device: %d\n", rc);
1545		return rc;
1546	}
1547
1548	pr_warn("interface ready\n");
1549
1550	return 0;
1551}
1552
1553module_init(test_firmware_init);
1554
1555static void __exit test_firmware_exit(void)
1556{
1557	mutex_lock(&test_fw_mutex);
1558	release_firmware(test_firmware);
1559	misc_deregister(&test_fw_misc_device);
1560	upload_release_all();
1561	__test_firmware_config_free();
1562	kfree(test_fw_config);
1563	mutex_unlock(&test_fw_mutex);
1564
1565	pr_warn("removed interface\n");
1566}
1567
1568module_exit(test_firmware_exit);
1569
1570MODULE_AUTHOR("Kees Cook <keescook@chromium.org>");
1571MODULE_DESCRIPTION("interface to trigger and test firmware loading");
1572MODULE_LICENSE("GPL");