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