blob: 22d1760a42789f869d06d4036315c7e0f2026363 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * firmware_class.c - Multi purpose firmware loading support
3 *
Markus Rechberger87d37a42007-06-04 18:45:44 +02004 * Copyright (c) 2003 Manuel Estrada Sainz
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 *
6 * Please see Documentation/firmware_class/ for more information.
7 *
8 */
9
Randy.Dunlapc59ede72006-01-11 12:17:46 -080010#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#include <linux/device.h>
12#include <linux/module.h>
13#include <linux/init.h>
14#include <linux/timer.h>
15#include <linux/vmalloc.h>
16#include <linux/interrupt.h>
17#include <linux/bitops.h>
Laura Garciacad1e552006-05-23 23:22:38 +020018#include <linux/mutex.h>
Stephen Boyda36cf842012-03-28 23:31:00 +020019#include <linux/workqueue.h>
David Woodhouse6e03a202009-04-09 22:04:07 -070020#include <linux/highmem.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <linux/firmware.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090022#include <linux/slab.h>
Stephen Boyda36cf842012-03-28 23:31:00 +020023#include <linux/sched.h>
Linus Torvaldsabb139e2012-10-03 15:58:32 -070024#include <linux/file.h>
Ming Lei1f2b7952012-08-04 12:01:21 +080025#include <linux/list.h>
Mimi Zohare40ba6d2015-11-19 12:39:22 -050026#include <linux/fs.h>
Ming Lei37276a52012-08-04 12:01:27 +080027#include <linux/async.h>
28#include <linux/pm.h>
Ming Lei07646d92012-08-04 12:01:29 +080029#include <linux/suspend.h>
Ming Leiac39b3e2012-08-20 19:04:16 +080030#include <linux/syscore_ops.h>
Takashi Iwaife304142013-05-22 18:28:38 +020031#include <linux/reboot.h>
Kees Cook6593d922014-02-25 13:06:00 -080032#include <linux/security.h>
Ming Lei37276a52012-08-04 12:01:27 +080033
Linus Torvaldsabb139e2012-10-03 15:58:32 -070034#include <generated/utsrelease.h>
35
Ming Lei37276a52012-08-04 12:01:27 +080036#include "base.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
Markus Rechberger87d37a42007-06-04 18:45:44 +020038MODULE_AUTHOR("Manuel Estrada Sainz");
Linus Torvalds1da177e2005-04-16 15:20:36 -070039MODULE_DESCRIPTION("Multi purpose firmware loading support");
40MODULE_LICENSE("GPL");
41
Dmitry Torokhovbcb9bd12010-03-13 23:49:18 -080042/* Builtin firmware support */
43
44#ifdef CONFIG_FW_LOADER
45
46extern struct builtin_fw __start_builtin_fw[];
47extern struct builtin_fw __end_builtin_fw[];
48
Stephen Boyda098ecd2016-08-02 14:04:28 -070049static bool fw_get_builtin_firmware(struct firmware *fw, const char *name,
50 void *buf, size_t size)
Dmitry Torokhovbcb9bd12010-03-13 23:49:18 -080051{
52 struct builtin_fw *b_fw;
53
54 for (b_fw = __start_builtin_fw; b_fw != __end_builtin_fw; b_fw++) {
55 if (strcmp(name, b_fw->name) == 0) {
56 fw->size = b_fw->size;
57 fw->data = b_fw->data;
Stephen Boyda098ecd2016-08-02 14:04:28 -070058
59 if (buf && fw->size <= size)
60 memcpy(buf, fw->data, fw->size);
Dmitry Torokhovbcb9bd12010-03-13 23:49:18 -080061 return true;
62 }
63 }
64
65 return false;
66}
67
68static bool fw_is_builtin_firmware(const struct firmware *fw)
69{
70 struct builtin_fw *b_fw;
71
72 for (b_fw = __start_builtin_fw; b_fw != __end_builtin_fw; b_fw++)
73 if (fw->data == b_fw->data)
74 return true;
75
76 return false;
77}
78
79#else /* Module case - no builtin firmware support */
80
Stephen Boyda098ecd2016-08-02 14:04:28 -070081static inline bool fw_get_builtin_firmware(struct firmware *fw,
82 const char *name, void *buf,
83 size_t size)
Dmitry Torokhovbcb9bd12010-03-13 23:49:18 -080084{
85 return false;
86}
87
88static inline bool fw_is_builtin_firmware(const struct firmware *fw)
89{
90 return false;
91}
92#endif
93
Linus Torvalds1da177e2005-04-16 15:20:36 -070094enum {
95 FW_STATUS_LOADING,
96 FW_STATUS_DONE,
97 FW_STATUS_ABORT,
Linus Torvalds1da177e2005-04-16 15:20:36 -070098};
99
Dave Jones2f651682007-01-25 15:56:15 -0500100static int loading_timeout = 60; /* In seconds */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101
Rafael J. Wysocki9b78c1d2012-03-28 23:30:02 +0200102static inline long firmware_loading_timeout(void)
103{
Ming Lei68ff2a02015-01-13 00:02:01 +0800104 return loading_timeout > 0 ? loading_timeout * HZ : MAX_JIFFY_OFFSET;
Rafael J. Wysocki9b78c1d2012-03-28 23:30:02 +0200105}
106
Takashi Iwai14c4bae2013-12-02 15:38:18 +0100107/* firmware behavior options */
108#define FW_OPT_UEVENT (1U << 0)
109#define FW_OPT_NOWAIT (1U << 1)
Takashi Iwai68aeeaa2013-12-02 15:38:19 +0100110#ifdef CONFIG_FW_LOADER_USER_HELPER
Takashi Iwai5a1379e2014-06-04 17:48:15 +0200111#define FW_OPT_USERHELPER (1U << 2)
Takashi Iwai68aeeaa2013-12-02 15:38:19 +0100112#else
Takashi Iwai5a1379e2014-06-04 17:48:15 +0200113#define FW_OPT_USERHELPER 0
114#endif
115#ifdef CONFIG_FW_LOADER_USER_HELPER_FALLBACK
116#define FW_OPT_FALLBACK FW_OPT_USERHELPER
117#else
118#define FW_OPT_FALLBACK 0
Takashi Iwai68aeeaa2013-12-02 15:38:19 +0100119#endif
Luis R. Rodriguezc868edf2014-07-02 09:55:05 -0700120#define FW_OPT_NO_WARN (1U << 3)
Vikram Mulukutla0e742e92016-08-02 14:04:25 -0700121#define FW_OPT_NOCACHE (1U << 4)
Takashi Iwai14c4bae2013-12-02 15:38:18 +0100122
Ming Lei1f2b7952012-08-04 12:01:21 +0800123struct firmware_cache {
124 /* firmware_buf instance will be added into the below list */
125 spinlock_t lock;
126 struct list_head head;
Ming Leicfe016b2012-09-08 17:32:30 +0800127 int state;
Ming Lei37276a52012-08-04 12:01:27 +0800128
Ming Leicfe016b2012-09-08 17:32:30 +0800129#ifdef CONFIG_PM_SLEEP
Ming Lei37276a52012-08-04 12:01:27 +0800130 /*
131 * Names of firmware images which have been cached successfully
132 * will be added into the below list so that device uncache
133 * helper can trace which firmware images have been cached
134 * before.
135 */
136 spinlock_t name_lock;
137 struct list_head fw_names;
138
Ming Lei37276a52012-08-04 12:01:27 +0800139 struct delayed_work work;
Ming Lei07646d92012-08-04 12:01:29 +0800140
141 struct notifier_block pm_notify;
Ming Leicfe016b2012-09-08 17:32:30 +0800142#endif
Ming Lei1f2b7952012-08-04 12:01:21 +0800143};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144
Ming Lei12446912012-08-04 12:01:20 +0800145struct firmware_buf {
Ming Lei1f2b7952012-08-04 12:01:21 +0800146 struct kref ref;
147 struct list_head list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 struct completion completion;
Ming Lei1f2b7952012-08-04 12:01:21 +0800149 struct firmware_cache *fwc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 unsigned long status;
Ming Lei65710cb2012-08-04 12:01:16 +0800151 void *data;
152 size_t size;
Stephen Boyda098ecd2016-08-02 14:04:28 -0700153 size_t allocated_size;
Takashi Iwai7b1269f2013-01-31 11:13:55 +0100154#ifdef CONFIG_FW_LOADER_USER_HELPER
Takashi Iwaicd7239f2013-01-31 11:13:56 +0100155 bool is_paged_buf;
Ming Leiaf5bc112013-05-27 18:30:04 +0800156 bool need_uevent;
David Woodhouse6e03a202009-04-09 22:04:07 -0700157 struct page **pages;
158 int nr_pages;
159 int page_array_size;
Takashi Iwaife304142013-05-22 18:28:38 +0200160 struct list_head pending_list;
Takashi Iwai7b1269f2013-01-31 11:13:55 +0100161#endif
Luis R. Rodrigueze0fd9b12015-05-12 14:49:43 -0700162 const char *fw_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163};
164
Ming Lei37276a52012-08-04 12:01:27 +0800165struct fw_cache_entry {
166 struct list_head list;
Luis R. Rodrigueze0fd9b12015-05-12 14:49:43 -0700167 const char *name;
Ming Lei37276a52012-08-04 12:01:27 +0800168};
169
Ming Leif531f05a2012-08-04 12:01:25 +0800170struct fw_name_devm {
171 unsigned long magic;
Luis R. Rodrigueze0fd9b12015-05-12 14:49:43 -0700172 const char *name;
Ming Leif531f05a2012-08-04 12:01:25 +0800173};
174
Ming Lei1f2b7952012-08-04 12:01:21 +0800175#define to_fwbuf(d) container_of(d, struct firmware_buf, ref)
176
Ming Leiac39b3e2012-08-20 19:04:16 +0800177#define FW_LOADER_NO_CACHE 0
178#define FW_LOADER_START_CACHE 1
179
180static int fw_cache_piggyback_on_request(const char *name);
181
Ming Lei1f2b7952012-08-04 12:01:21 +0800182/* fw_lock could be moved to 'struct firmware_priv' but since it is just
183 * guarding for corner cases a global lock should be OK */
184static DEFINE_MUTEX(fw_lock);
185
186static struct firmware_cache fw_cache;
187
188static struct firmware_buf *__allocate_fw_buf(const char *fw_name,
Stephen Boyda098ecd2016-08-02 14:04:28 -0700189 struct firmware_cache *fwc,
190 void *dbuf, size_t size)
Ming Lei1f2b7952012-08-04 12:01:21 +0800191{
192 struct firmware_buf *buf;
193
Luis R. Rodrigueze0fd9b12015-05-12 14:49:43 -0700194 buf = kzalloc(sizeof(*buf), GFP_ATOMIC);
Ming Lei1f2b7952012-08-04 12:01:21 +0800195 if (!buf)
Luis R. Rodrigueze0fd9b12015-05-12 14:49:43 -0700196 return NULL;
197
198 buf->fw_id = kstrdup_const(fw_name, GFP_ATOMIC);
199 if (!buf->fw_id) {
200 kfree(buf);
201 return NULL;
202 }
Ming Lei1f2b7952012-08-04 12:01:21 +0800203
204 kref_init(&buf->ref);
Ming Lei1f2b7952012-08-04 12:01:21 +0800205 buf->fwc = fwc;
Stephen Boyda098ecd2016-08-02 14:04:28 -0700206 buf->data = dbuf;
207 buf->allocated_size = size;
Ming Lei1f2b7952012-08-04 12:01:21 +0800208 init_completion(&buf->completion);
Takashi Iwaife304142013-05-22 18:28:38 +0200209#ifdef CONFIG_FW_LOADER_USER_HELPER
210 INIT_LIST_HEAD(&buf->pending_list);
211#endif
Ming Lei1f2b7952012-08-04 12:01:21 +0800212
213 pr_debug("%s: fw-%s buf=%p\n", __func__, fw_name, buf);
214
215 return buf;
216}
217
Ming Lei2887b392012-08-04 12:01:22 +0800218static struct firmware_buf *__fw_lookup_buf(const char *fw_name)
219{
220 struct firmware_buf *tmp;
221 struct firmware_cache *fwc = &fw_cache;
222
223 list_for_each_entry(tmp, &fwc->head, list)
224 if (!strcmp(tmp->fw_id, fw_name))
225 return tmp;
226 return NULL;
227}
228
Ming Lei1f2b7952012-08-04 12:01:21 +0800229static int fw_lookup_and_allocate_buf(const char *fw_name,
230 struct firmware_cache *fwc,
Stephen Boyda098ecd2016-08-02 14:04:28 -0700231 struct firmware_buf **buf, void *dbuf,
232 size_t size)
Ming Lei1f2b7952012-08-04 12:01:21 +0800233{
234 struct firmware_buf *tmp;
235
236 spin_lock(&fwc->lock);
Ming Lei2887b392012-08-04 12:01:22 +0800237 tmp = __fw_lookup_buf(fw_name);
238 if (tmp) {
239 kref_get(&tmp->ref);
240 spin_unlock(&fwc->lock);
241 *buf = tmp;
242 return 1;
243 }
Stephen Boyda098ecd2016-08-02 14:04:28 -0700244 tmp = __allocate_fw_buf(fw_name, fwc, dbuf, size);
Ming Lei1f2b7952012-08-04 12:01:21 +0800245 if (tmp)
246 list_add(&tmp->list, &fwc->head);
247 spin_unlock(&fwc->lock);
248
249 *buf = tmp;
250
251 return tmp ? 0 : -ENOMEM;
252}
253
254static void __fw_free_buf(struct kref *ref)
Bart Van Assche98233b22014-01-04 14:20:36 +0100255 __releases(&fwc->lock)
Ming Lei1f2b7952012-08-04 12:01:21 +0800256{
257 struct firmware_buf *buf = to_fwbuf(ref);
258 struct firmware_cache *fwc = buf->fwc;
Ming Lei1f2b7952012-08-04 12:01:21 +0800259
260 pr_debug("%s: fw-%s buf=%p data=%p size=%u\n",
261 __func__, buf->fw_id, buf, buf->data,
262 (unsigned int)buf->size);
263
Ming Lei1f2b7952012-08-04 12:01:21 +0800264 list_del(&buf->list);
265 spin_unlock(&fwc->lock);
266
Takashi Iwai7b1269f2013-01-31 11:13:55 +0100267#ifdef CONFIG_FW_LOADER_USER_HELPER
Takashi Iwaicd7239f2013-01-31 11:13:56 +0100268 if (buf->is_paged_buf) {
Takashi Iwai7b1269f2013-01-31 11:13:55 +0100269 int i;
Ming Lei746058f2012-10-09 12:01:03 +0800270 vunmap(buf->data);
271 for (i = 0; i < buf->nr_pages; i++)
272 __free_page(buf->pages[i]);
Chen Feng10a3fbf12015-12-16 17:03:15 +0800273 vfree(buf->pages);
Ming Lei746058f2012-10-09 12:01:03 +0800274 } else
Takashi Iwai7b1269f2013-01-31 11:13:55 +0100275#endif
Stephen Boyda098ecd2016-08-02 14:04:28 -0700276 if (!buf->allocated_size)
Ming Lei746058f2012-10-09 12:01:03 +0800277 vfree(buf->data);
Luis R. Rodrigueze0fd9b12015-05-12 14:49:43 -0700278 kfree_const(buf->fw_id);
Ming Lei1f2b7952012-08-04 12:01:21 +0800279 kfree(buf);
280}
281
282static void fw_free_buf(struct firmware_buf *buf)
283{
Chuansheng Liubd9eb7f2012-11-10 01:27:22 +0800284 struct firmware_cache *fwc = buf->fwc;
285 spin_lock(&fwc->lock);
286 if (!kref_put(&buf->ref, __fw_free_buf))
287 spin_unlock(&fwc->lock);
Ming Lei1f2b7952012-08-04 12:01:21 +0800288}
289
Ming Lei746058f2012-10-09 12:01:03 +0800290/* direct firmware loading support */
Ming Lei27602842012-11-03 17:47:58 +0800291static char fw_path_para[256];
292static const char * const fw_path[] = {
293 fw_path_para,
Ming Lei746058f2012-10-09 12:01:03 +0800294 "/lib/firmware/updates/" UTS_RELEASE,
295 "/lib/firmware/updates",
296 "/lib/firmware/" UTS_RELEASE,
297 "/lib/firmware"
298};
299
Ming Lei27602842012-11-03 17:47:58 +0800300/*
301 * Typical usage is that passing 'firmware_class.path=$CUSTOMIZED_PATH'
302 * from kernel command line because firmware_class is generally built in
303 * kernel instead of module.
304 */
305module_param_string(path, fw_path_para, sizeof(fw_path_para), 0644);
306MODULE_PARM_DESC(path, "customized firmware image search path with a higher priority than default path");
307
Luis R. Rodriguez5275d192015-07-30 15:48:57 -0700308static void fw_finish_direct_load(struct device *device,
309 struct firmware_buf *buf)
310{
311 mutex_lock(&fw_lock);
312 set_bit(FW_STATUS_DONE, &buf->status);
313 complete_all(&buf->completion);
314 mutex_unlock(&fw_lock);
315}
316
Stephen Boyda098ecd2016-08-02 14:04:28 -0700317static int
318fw_get_filesystem_firmware(struct device *device, struct firmware_buf *buf)
Ming Lei746058f2012-10-09 12:01:03 +0800319{
Mimi Zohare40ba6d2015-11-19 12:39:22 -0500320 loff_t size;
Luis R. Rodriguez1ba4de12015-05-12 14:49:41 -0700321 int i, len;
Neil Horman3e358ac2013-09-06 15:36:08 -0400322 int rc = -ENOENT;
Luis R. Rodriguezf5727b02015-05-12 14:49:40 -0700323 char *path;
Stephen Boyda098ecd2016-08-02 14:04:28 -0700324 enum kernel_read_file_id id = READING_FIRMWARE;
325 size_t msize = INT_MAX;
326
327 /* Already populated data member means we're loading into a buffer */
328 if (buf->data) {
329 id = READING_FIRMWARE_PREALLOC_BUFFER;
330 msize = buf->allocated_size;
331 }
Luis R. Rodriguezf5727b02015-05-12 14:49:40 -0700332
333 path = __getname();
334 if (!path)
335 return -ENOMEM;
Ming Lei746058f2012-10-09 12:01:03 +0800336
337 for (i = 0; i < ARRAY_SIZE(fw_path); i++) {
Ming Lei27602842012-11-03 17:47:58 +0800338 /* skip the unset customized path */
339 if (!fw_path[i][0])
340 continue;
341
Luis R. Rodriguez1ba4de12015-05-12 14:49:41 -0700342 len = snprintf(path, PATH_MAX, "%s/%s",
343 fw_path[i], buf->fw_id);
344 if (len >= PATH_MAX) {
345 rc = -ENAMETOOLONG;
346 break;
347 }
Ming Lei746058f2012-10-09 12:01:03 +0800348
Mimi Zohare40ba6d2015-11-19 12:39:22 -0500349 buf->size = 0;
Stephen Boyda098ecd2016-08-02 14:04:28 -0700350 rc = kernel_read_file_from_path(path, &buf->data, &size, msize,
351 id);
Kees Cook4b2530d2016-02-04 13:15:02 -0800352 if (rc) {
Luis R. Rodriguez8e516aa2016-02-28 21:57:55 +0100353 if (rc == -ENOENT)
354 dev_dbg(device, "loading %s failed with error %d\n",
355 path, rc);
356 else
357 dev_warn(device, "loading %s failed with error %d\n",
358 path, rc);
Kees Cook4b2530d2016-02-04 13:15:02 -0800359 continue;
360 }
Mimi Zohare40ba6d2015-11-19 12:39:22 -0500361 dev_dbg(device, "direct-loading %s\n", buf->fw_id);
362 buf->size = size;
Luis R. Rodriguez5275d192015-07-30 15:48:57 -0700363 fw_finish_direct_load(device, buf);
Kees Cook4b2530d2016-02-04 13:15:02 -0800364 break;
Takashi Iwai4e0c92d2013-01-31 11:13:54 +0100365 }
Kees Cook4b2530d2016-02-04 13:15:02 -0800366 __putname(path);
Takashi Iwai4e0c92d2013-01-31 11:13:54 +0100367
Neil Horman3e358ac2013-09-06 15:36:08 -0400368 return rc;
Ming Lei746058f2012-10-09 12:01:03 +0800369}
370
Takashi Iwai7b1269f2013-01-31 11:13:55 +0100371/* firmware holds the ownership of pages */
372static void firmware_free_data(const struct firmware *fw)
373{
374 /* Loaded directly? */
375 if (!fw->priv) {
376 vfree(fw->data);
377 return;
378 }
379 fw_free_buf(fw->priv);
380}
381
Takashi Iwaicd7239f2013-01-31 11:13:56 +0100382/* store the pages buffer info firmware from buf */
383static void fw_set_page_data(struct firmware_buf *buf, struct firmware *fw)
384{
385 fw->priv = buf;
Takashi Iwai7b1269f2013-01-31 11:13:55 +0100386#ifdef CONFIG_FW_LOADER_USER_HELPER
Takashi Iwaicd7239f2013-01-31 11:13:56 +0100387 fw->pages = buf->pages;
388#endif
389 fw->size = buf->size;
390 fw->data = buf->data;
391
392 pr_debug("%s: fw-%s buf=%p data=%p size=%u\n",
393 __func__, buf->fw_id, buf, buf->data,
394 (unsigned int)buf->size);
395}
396
397#ifdef CONFIG_PM_SLEEP
398static void fw_name_devm_release(struct device *dev, void *res)
399{
400 struct fw_name_devm *fwn = res;
401
402 if (fwn->magic == (unsigned long)&fw_cache)
403 pr_debug("%s: fw_name-%s devm-%p released\n",
404 __func__, fwn->name, res);
Luis R. Rodrigueze0fd9b12015-05-12 14:49:43 -0700405 kfree_const(fwn->name);
Takashi Iwaicd7239f2013-01-31 11:13:56 +0100406}
407
408static int fw_devm_match(struct device *dev, void *res,
409 void *match_data)
410{
411 struct fw_name_devm *fwn = res;
412
413 return (fwn->magic == (unsigned long)&fw_cache) &&
414 !strcmp(fwn->name, match_data);
415}
416
417static struct fw_name_devm *fw_find_devm_name(struct device *dev,
418 const char *name)
419{
420 struct fw_name_devm *fwn;
421
422 fwn = devres_find(dev, fw_name_devm_release,
423 fw_devm_match, (void *)name);
424 return fwn;
425}
426
427/* add firmware name into devres list */
428static int fw_add_devm_name(struct device *dev, const char *name)
429{
430 struct fw_name_devm *fwn;
431
432 fwn = fw_find_devm_name(dev, name);
433 if (fwn)
434 return 1;
435
Luis R. Rodrigueze0fd9b12015-05-12 14:49:43 -0700436 fwn = devres_alloc(fw_name_devm_release, sizeof(struct fw_name_devm),
437 GFP_KERNEL);
Takashi Iwaicd7239f2013-01-31 11:13:56 +0100438 if (!fwn)
439 return -ENOMEM;
Luis R. Rodrigueze0fd9b12015-05-12 14:49:43 -0700440 fwn->name = kstrdup_const(name, GFP_KERNEL);
441 if (!fwn->name) {
Vladimir Zapolskiya885de62015-07-29 23:26:28 +0300442 devres_free(fwn);
Luis R. Rodrigueze0fd9b12015-05-12 14:49:43 -0700443 return -ENOMEM;
444 }
Takashi Iwaicd7239f2013-01-31 11:13:56 +0100445
446 fwn->magic = (unsigned long)&fw_cache;
Takashi Iwaicd7239f2013-01-31 11:13:56 +0100447 devres_add(dev, fwn);
448
449 return 0;
450}
451#else
452static int fw_add_devm_name(struct device *dev, const char *name)
453{
454 return 0;
455}
456#endif
457
458
459/*
460 * user-mode helper code
461 */
462#ifdef CONFIG_FW_LOADER_USER_HELPER
463struct firmware_priv {
Takashi Iwaicd7239f2013-01-31 11:13:56 +0100464 bool nowait;
465 struct device dev;
466 struct firmware_buf *buf;
467 struct firmware *fw;
468};
Takashi Iwai7b1269f2013-01-31 11:13:55 +0100469
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700470static struct firmware_priv *to_firmware_priv(struct device *dev)
471{
472 return container_of(dev, struct firmware_priv, dev);
473}
474
Greg Kroah-Hartman7068cb02013-06-19 20:26:43 -0700475static void __fw_load_abort(struct firmware_buf *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476{
Ming Lei87597932013-06-15 16:36:38 +0800477 /*
478 * There is a small window in which user can write to 'loading'
479 * between loading done and disappearance of 'loading'
480 */
481 if (test_bit(FW_STATUS_DONE, &buf->status))
482 return;
483
Takashi Iwaife304142013-05-22 18:28:38 +0200484 list_del_init(&buf->pending_list);
Ming Lei12446912012-08-04 12:01:20 +0800485 set_bit(FW_STATUS_ABORT, &buf->status);
Ming Lei1f2b7952012-08-04 12:01:21 +0800486 complete_all(&buf->completion);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487}
488
Greg Kroah-Hartman7068cb02013-06-19 20:26:43 -0700489static void fw_load_abort(struct firmware_priv *fw_priv)
490{
491 struct firmware_buf *buf = fw_priv->buf;
492
493 __fw_load_abort(buf);
Ming Lei87597932013-06-15 16:36:38 +0800494
495 /* avoid user action after loading abort */
496 fw_priv->buf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497}
498
Takashi Iwai807be032013-01-31 11:13:57 +0100499#define is_fw_load_aborted(buf) \
500 test_bit(FW_STATUS_ABORT, &(buf)->status)
501
Takashi Iwaife304142013-05-22 18:28:38 +0200502static LIST_HEAD(pending_fw_head);
503
504/* reboot notifier for avoid deadlock with usermode_lock */
505static int fw_shutdown_notify(struct notifier_block *unused1,
506 unsigned long unused2, void *unused3)
507{
508 mutex_lock(&fw_lock);
509 while (!list_empty(&pending_fw_head))
Greg Kroah-Hartman7068cb02013-06-19 20:26:43 -0700510 __fw_load_abort(list_first_entry(&pending_fw_head,
Takashi Iwaife304142013-05-22 18:28:38 +0200511 struct firmware_buf,
512 pending_list));
513 mutex_unlock(&fw_lock);
514 return NOTIFY_DONE;
515}
516
517static struct notifier_block fw_shutdown_nb = {
518 .notifier_call = fw_shutdown_notify,
519};
520
Greg Kroah-Hartman14adbe52013-08-23 17:08:48 -0700521static ssize_t timeout_show(struct class *class, struct class_attribute *attr,
522 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523{
524 return sprintf(buf, "%d\n", loading_timeout);
525}
526
527/**
Randy Dunlapeb8e3172005-10-30 15:03:01 -0800528 * firmware_timeout_store - set number of seconds to wait for firmware
529 * @class: device class pointer
Randy Dunlape59817b2010-03-10 11:47:58 -0800530 * @attr: device attribute pointer
Randy Dunlapeb8e3172005-10-30 15:03:01 -0800531 * @buf: buffer to scan for timeout value
532 * @count: number of bytes in @buf
533 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 * Sets the number of seconds to wait for the firmware. Once
Randy Dunlapeb8e3172005-10-30 15:03:01 -0800535 * this expires an error will be returned to the driver and no
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 * firmware will be provided.
537 *
Randy Dunlapeb8e3172005-10-30 15:03:01 -0800538 * Note: zero means 'wait forever'.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 **/
Greg Kroah-Hartman14adbe52013-08-23 17:08:48 -0700540static ssize_t timeout_store(struct class *class, struct class_attribute *attr,
541 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542{
543 loading_timeout = simple_strtol(buf, NULL, 10);
Stanislaw W. Gruszkab92eac02005-06-28 20:44:51 -0700544 if (loading_timeout < 0)
545 loading_timeout = 0;
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700546
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 return count;
548}
549
Dmitry Torokhov673fae92010-03-13 23:49:13 -0800550static struct class_attribute firmware_class_attrs[] = {
Greg Kroah-Hartman14adbe52013-08-23 17:08:48 -0700551 __ATTR_RW(timeout),
Dmitry Torokhov673fae92010-03-13 23:49:13 -0800552 __ATTR_NULL
553};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554
Dmitry Torokhov673fae92010-03-13 23:49:13 -0800555static void fw_dev_release(struct device *dev)
556{
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700557 struct firmware_priv *fw_priv = to_firmware_priv(dev);
Ming Lei65710cb2012-08-04 12:01:16 +0800558
Dmitry Torokhov673fae92010-03-13 23:49:13 -0800559 kfree(fw_priv);
Dmitry Torokhov673fae92010-03-13 23:49:13 -0800560}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561
Linus Torvalds6f957722015-07-09 11:20:01 -0700562static int do_firmware_uevent(struct firmware_priv *fw_priv, struct kobj_uevent_env *env)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563{
Ming Lei12446912012-08-04 12:01:20 +0800564 if (add_uevent_var(env, "FIRMWARE=%s", fw_priv->buf->fw_id))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 return -ENOMEM;
Kay Sievers7eff2e72007-08-14 15:15:12 +0200566 if (add_uevent_var(env, "TIMEOUT=%i", loading_timeout))
kay.sievers@vrfy.org68970892005-04-18 21:57:31 -0700567 return -ENOMEM;
Johannes Berge9045f92010-03-29 17:57:20 +0200568 if (add_uevent_var(env, "ASYNC=%d", fw_priv->nowait))
569 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570
571 return 0;
572}
573
Linus Torvalds6f957722015-07-09 11:20:01 -0700574static int firmware_uevent(struct device *dev, struct kobj_uevent_env *env)
575{
576 struct firmware_priv *fw_priv = to_firmware_priv(dev);
577 int err = 0;
578
579 mutex_lock(&fw_lock);
580 if (fw_priv->buf)
581 err = do_firmware_uevent(fw_priv, env);
582 mutex_unlock(&fw_lock);
583 return err;
584}
585
Adrian Bunk1b81d662006-05-20 15:00:16 -0700586static struct class firmware_class = {
587 .name = "firmware",
Dmitry Torokhov673fae92010-03-13 23:49:13 -0800588 .class_attrs = firmware_class_attrs,
Greg Kroah-Hartmane55c8792006-09-14 07:30:59 -0700589 .dev_uevent = firmware_uevent,
590 .dev_release = fw_dev_release,
Adrian Bunk1b81d662006-05-20 15:00:16 -0700591};
592
Greg Kroah-Hartmane55c8792006-09-14 07:30:59 -0700593static ssize_t firmware_loading_show(struct device *dev,
594 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595{
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700596 struct firmware_priv *fw_priv = to_firmware_priv(dev);
Ming Lei87597932013-06-15 16:36:38 +0800597 int loading = 0;
598
599 mutex_lock(&fw_lock);
600 if (fw_priv->buf)
601 loading = test_bit(FW_STATUS_LOADING, &fw_priv->buf->status);
602 mutex_unlock(&fw_lock);
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700603
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 return sprintf(buf, "%d\n", loading);
605}
606
David Woodhouse6e03a202009-04-09 22:04:07 -0700607/* Some architectures don't have PAGE_KERNEL_RO */
608#ifndef PAGE_KERNEL_RO
609#define PAGE_KERNEL_RO PAGE_KERNEL
610#endif
Ming Lei253c9242012-10-09 12:01:02 +0800611
612/* one pages buffer should be mapped/unmapped only once */
613static int fw_map_pages_buf(struct firmware_buf *buf)
614{
Takashi Iwaicd7239f2013-01-31 11:13:56 +0100615 if (!buf->is_paged_buf)
Ming Lei746058f2012-10-09 12:01:03 +0800616 return 0;
617
Markus Elfringdaa3d672014-11-19 11:38:38 +0100618 vunmap(buf->data);
Ming Lei253c9242012-10-09 12:01:02 +0800619 buf->data = vmap(buf->pages, buf->nr_pages, 0, PAGE_KERNEL_RO);
620 if (!buf->data)
621 return -ENOMEM;
622 return 0;
623}
624
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625/**
Randy Dunlapeb8e3172005-10-30 15:03:01 -0800626 * firmware_loading_store - set value in the 'loading' control file
Greg Kroah-Hartmane55c8792006-09-14 07:30:59 -0700627 * @dev: device pointer
Randy Dunlapaf9997e2006-12-22 01:06:52 -0800628 * @attr: device attribute pointer
Randy Dunlapeb8e3172005-10-30 15:03:01 -0800629 * @buf: buffer to scan for loading control value
630 * @count: number of bytes in @buf
631 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 * The relevant values are:
633 *
634 * 1: Start a load, discarding any previous partial load.
Randy Dunlapeb8e3172005-10-30 15:03:01 -0800635 * 0: Conclude the load and hand the data to the driver code.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 * -1: Conclude the load with an error and discard any written data.
637 **/
Greg Kroah-Hartmane55c8792006-09-14 07:30:59 -0700638static ssize_t firmware_loading_store(struct device *dev,
639 struct device_attribute *attr,
640 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641{
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700642 struct firmware_priv *fw_priv = to_firmware_priv(dev);
Ming Lei87597932013-06-15 16:36:38 +0800643 struct firmware_buf *fw_buf;
Kees Cook6593d922014-02-25 13:06:00 -0800644 ssize_t written = count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 int loading = simple_strtol(buf, NULL, 10);
David Woodhouse6e03a202009-04-09 22:04:07 -0700646 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647
Neil Hormaneea915b2012-01-02 15:31:23 -0500648 mutex_lock(&fw_lock);
Ming Lei87597932013-06-15 16:36:38 +0800649 fw_buf = fw_priv->buf;
Ming Lei12446912012-08-04 12:01:20 +0800650 if (!fw_buf)
Neil Hormaneea915b2012-01-02 15:31:23 -0500651 goto out;
652
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 switch (loading) {
654 case 1:
Ming Lei65710cb2012-08-04 12:01:16 +0800655 /* discarding any previous partial load */
Ming Lei12446912012-08-04 12:01:20 +0800656 if (!test_bit(FW_STATUS_DONE, &fw_buf->status)) {
657 for (i = 0; i < fw_buf->nr_pages; i++)
658 __free_page(fw_buf->pages[i]);
Chen Feng10a3fbf12015-12-16 17:03:15 +0800659 vfree(fw_buf->pages);
Ming Lei12446912012-08-04 12:01:20 +0800660 fw_buf->pages = NULL;
661 fw_buf->page_array_size = 0;
662 fw_buf->nr_pages = 0;
663 set_bit(FW_STATUS_LOADING, &fw_buf->status);
Ming Lei28eefa72012-08-04 12:01:17 +0800664 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 break;
666 case 0:
Ming Lei12446912012-08-04 12:01:20 +0800667 if (test_bit(FW_STATUS_LOADING, &fw_buf->status)) {
Kees Cook6593d922014-02-25 13:06:00 -0800668 int rc;
669
Ming Lei12446912012-08-04 12:01:20 +0800670 set_bit(FW_STATUS_DONE, &fw_buf->status);
671 clear_bit(FW_STATUS_LOADING, &fw_buf->status);
Ming Lei253c9242012-10-09 12:01:02 +0800672
673 /*
674 * Several loading requests may be pending on
675 * one same firmware buf, so let all requests
676 * see the mapped 'buf->data' once the loading
677 * is completed.
678 * */
Kees Cook6593d922014-02-25 13:06:00 -0800679 rc = fw_map_pages_buf(fw_buf);
680 if (rc)
zhang jun2b1278c2014-02-13 15:18:47 +0800681 dev_err(dev, "%s: map pages failed\n",
682 __func__);
Kees Cook6593d922014-02-25 13:06:00 -0800683 else
Mimi Zohare40ba6d2015-11-19 12:39:22 -0500684 rc = security_kernel_post_read_file(NULL,
685 fw_buf->data, fw_buf->size,
686 READING_FIRMWARE);
Kees Cook6593d922014-02-25 13:06:00 -0800687
688 /*
689 * Same logic as fw_load_abort, only the DONE bit
690 * is ignored and we set ABORT only on failure.
691 */
Takashi Iwaife304142013-05-22 18:28:38 +0200692 list_del_init(&fw_buf->pending_list);
Kees Cook6593d922014-02-25 13:06:00 -0800693 if (rc) {
694 set_bit(FW_STATUS_ABORT, &fw_buf->status);
695 written = rc;
696 }
Ming Lei1f2b7952012-08-04 12:01:21 +0800697 complete_all(&fw_buf->completion);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 break;
699 }
700 /* fallthrough */
701 default:
Bjorn Helgaas266a8132008-10-15 22:04:20 -0700702 dev_err(dev, "%s: unexpected value (%d)\n", __func__, loading);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 /* fallthrough */
704 case -1:
705 fw_load_abort(fw_priv);
706 break;
707 }
Neil Hormaneea915b2012-01-02 15:31:23 -0500708out:
709 mutex_unlock(&fw_lock);
Kees Cook6593d922014-02-25 13:06:00 -0800710 return written;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711}
712
Greg Kroah-Hartmane55c8792006-09-14 07:30:59 -0700713static DEVICE_ATTR(loading, 0644, firmware_loading_show, firmware_loading_store);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714
Stephen Boyda098ecd2016-08-02 14:04:28 -0700715static void firmware_rw_buf(struct firmware_buf *buf, char *buffer,
716 loff_t offset, size_t count, bool read)
717{
718 if (read)
719 memcpy(buffer, buf->data + offset, count);
720 else
721 memcpy(buf->data + offset, buffer, count);
722}
723
Stephen Boyd9ccf9812016-08-02 14:04:22 -0700724static void firmware_rw(struct firmware_buf *buf, char *buffer,
725 loff_t offset, size_t count, bool read)
726{
727 while (count) {
728 void *page_data;
729 int page_nr = offset >> PAGE_SHIFT;
730 int page_ofs = offset & (PAGE_SIZE-1);
731 int page_cnt = min_t(size_t, PAGE_SIZE - page_ofs, count);
732
733 page_data = kmap(buf->pages[page_nr]);
734
735 if (read)
736 memcpy(buffer, page_data + page_ofs, page_cnt);
737 else
738 memcpy(page_data + page_ofs, buffer, page_cnt);
739
740 kunmap(buf->pages[page_nr]);
741 buffer += page_cnt;
742 offset += page_cnt;
743 count -= page_cnt;
744 }
745}
746
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700747static ssize_t firmware_data_read(struct file *filp, struct kobject *kobj,
748 struct bin_attribute *bin_attr,
749 char *buffer, loff_t offset, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750{
Lars-Peter Clausenb0d1f802012-07-03 18:49:36 +0200751 struct device *dev = kobj_to_dev(kobj);
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700752 struct firmware_priv *fw_priv = to_firmware_priv(dev);
Ming Lei12446912012-08-04 12:01:20 +0800753 struct firmware_buf *buf;
Akinobu Mitaf37e6612008-07-25 01:48:23 -0700754 ssize_t ret_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755
Laura Garciacad1e552006-05-23 23:22:38 +0200756 mutex_lock(&fw_lock);
Ming Lei12446912012-08-04 12:01:20 +0800757 buf = fw_priv->buf;
758 if (!buf || test_bit(FW_STATUS_DONE, &buf->status)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 ret_count = -ENODEV;
760 goto out;
761 }
Ming Lei12446912012-08-04 12:01:20 +0800762 if (offset > buf->size) {
Jiri Slaby308975f2009-06-21 23:57:31 +0200763 ret_count = 0;
764 goto out;
765 }
Ming Lei12446912012-08-04 12:01:20 +0800766 if (count > buf->size - offset)
767 count = buf->size - offset;
David Woodhouse6e03a202009-04-09 22:04:07 -0700768
769 ret_count = count;
770
Stephen Boyda098ecd2016-08-02 14:04:28 -0700771 if (buf->data)
772 firmware_rw_buf(buf, buffer, offset, count, true);
773 else
774 firmware_rw(buf, buffer, offset, count, true);
David Woodhouse6e03a202009-04-09 22:04:07 -0700775
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776out:
Laura Garciacad1e552006-05-23 23:22:38 +0200777 mutex_unlock(&fw_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778 return ret_count;
779}
Randy Dunlapeb8e3172005-10-30 15:03:01 -0800780
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700781static int fw_realloc_buffer(struct firmware_priv *fw_priv, int min_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782{
Ming Lei12446912012-08-04 12:01:20 +0800783 struct firmware_buf *buf = fw_priv->buf;
Fabian Fredericka76040d2014-07-01 21:13:30 +0200784 int pages_needed = PAGE_ALIGN(min_size) >> PAGE_SHIFT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785
David Woodhouse6e03a202009-04-09 22:04:07 -0700786 /* If the array of pages is too small, grow it... */
Ming Lei12446912012-08-04 12:01:20 +0800787 if (buf->page_array_size < pages_needed) {
David Woodhouse6e03a202009-04-09 22:04:07 -0700788 int new_array_size = max(pages_needed,
Ming Lei12446912012-08-04 12:01:20 +0800789 buf->page_array_size * 2);
David Woodhouse6e03a202009-04-09 22:04:07 -0700790 struct page **new_pages;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791
Chen Feng10a3fbf12015-12-16 17:03:15 +0800792 new_pages = vmalloc(new_array_size * sizeof(void *));
David Woodhouse6e03a202009-04-09 22:04:07 -0700793 if (!new_pages) {
794 fw_load_abort(fw_priv);
795 return -ENOMEM;
796 }
Ming Lei12446912012-08-04 12:01:20 +0800797 memcpy(new_pages, buf->pages,
798 buf->page_array_size * sizeof(void *));
799 memset(&new_pages[buf->page_array_size], 0, sizeof(void *) *
800 (new_array_size - buf->page_array_size));
Chen Feng10a3fbf12015-12-16 17:03:15 +0800801 vfree(buf->pages);
Ming Lei12446912012-08-04 12:01:20 +0800802 buf->pages = new_pages;
803 buf->page_array_size = new_array_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 }
David Woodhouse6e03a202009-04-09 22:04:07 -0700805
Ming Lei12446912012-08-04 12:01:20 +0800806 while (buf->nr_pages < pages_needed) {
807 buf->pages[buf->nr_pages] =
David Woodhouse6e03a202009-04-09 22:04:07 -0700808 alloc_page(GFP_KERNEL | __GFP_HIGHMEM);
809
Ming Lei12446912012-08-04 12:01:20 +0800810 if (!buf->pages[buf->nr_pages]) {
David Woodhouse6e03a202009-04-09 22:04:07 -0700811 fw_load_abort(fw_priv);
812 return -ENOMEM;
813 }
Ming Lei12446912012-08-04 12:01:20 +0800814 buf->nr_pages++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 return 0;
817}
818
819/**
Randy Dunlapeb8e3172005-10-30 15:03:01 -0800820 * firmware_data_write - write method for firmware
Chris Wright2c3c8be2010-05-12 18:28:57 -0700821 * @filp: open sysfs file
Greg Kroah-Hartmane55c8792006-09-14 07:30:59 -0700822 * @kobj: kobject for the device
Randy Dunlap42e61f42007-07-23 21:42:11 -0700823 * @bin_attr: bin_attr structure
Randy Dunlapeb8e3172005-10-30 15:03:01 -0800824 * @buffer: buffer being written
825 * @offset: buffer offset for write in total data store area
826 * @count: buffer size
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 *
Randy Dunlapeb8e3172005-10-30 15:03:01 -0800828 * Data written to the 'data' attribute will be later handed to
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 * the driver as a firmware image.
830 **/
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700831static ssize_t firmware_data_write(struct file *filp, struct kobject *kobj,
832 struct bin_attribute *bin_attr,
833 char *buffer, loff_t offset, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834{
Lars-Peter Clausenb0d1f802012-07-03 18:49:36 +0200835 struct device *dev = kobj_to_dev(kobj);
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700836 struct firmware_priv *fw_priv = to_firmware_priv(dev);
Ming Lei12446912012-08-04 12:01:20 +0800837 struct firmware_buf *buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 ssize_t retval;
839
840 if (!capable(CAP_SYS_RAWIO))
841 return -EPERM;
Stanislaw W. Gruszkab92eac02005-06-28 20:44:51 -0700842
Laura Garciacad1e552006-05-23 23:22:38 +0200843 mutex_lock(&fw_lock);
Ming Lei12446912012-08-04 12:01:20 +0800844 buf = fw_priv->buf;
845 if (!buf || test_bit(FW_STATUS_DONE, &buf->status)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 retval = -ENODEV;
847 goto out;
848 }
Ming Lei65710cb2012-08-04 12:01:16 +0800849
Stephen Boyda098ecd2016-08-02 14:04:28 -0700850 if (buf->data) {
851 if (offset + count > buf->allocated_size) {
852 retval = -ENOMEM;
853 goto out;
854 }
855 firmware_rw_buf(buf, buffer, offset, count, false);
856 retval = count;
857 } else {
858 retval = fw_realloc_buffer(fw_priv, offset + count);
859 if (retval)
860 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861
Stephen Boyda098ecd2016-08-02 14:04:28 -0700862 retval = count;
863 firmware_rw(buf, buffer, offset, count, false);
864 }
David Woodhouse6e03a202009-04-09 22:04:07 -0700865
Stephen Boyd9ccf9812016-08-02 14:04:22 -0700866 buf->size = max_t(size_t, offset + count, buf->size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867out:
Laura Garciacad1e552006-05-23 23:22:38 +0200868 mutex_unlock(&fw_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 return retval;
870}
Randy Dunlapeb8e3172005-10-30 15:03:01 -0800871
Dmitry Torokhov0983ca22010-06-04 00:54:37 -0700872static struct bin_attribute firmware_attr_data = {
873 .attr = { .name = "data", .mode = 0644 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 .size = 0,
875 .read = firmware_data_read,
876 .write = firmware_data_write,
877};
878
Takashi Iwai46239902015-02-04 15:18:07 +0100879static struct attribute *fw_dev_attrs[] = {
880 &dev_attr_loading.attr,
881 NULL
882};
883
884static struct bin_attribute *fw_dev_bin_attrs[] = {
885 &firmware_attr_data,
886 NULL
887};
888
889static const struct attribute_group fw_dev_attr_group = {
890 .attrs = fw_dev_attrs,
891 .bin_attrs = fw_dev_bin_attrs,
892};
893
894static const struct attribute_group *fw_dev_attr_groups[] = {
895 &fw_dev_attr_group,
896 NULL
897};
898
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700899static struct firmware_priv *
Stephen Boyddddb5542012-03-28 23:30:43 +0200900fw_create_instance(struct firmware *firmware, const char *fw_name,
Takashi Iwai14c4bae2013-12-02 15:38:18 +0100901 struct device *device, unsigned int opt_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902{
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700903 struct firmware_priv *fw_priv;
904 struct device *f_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905
Ming Lei12446912012-08-04 12:01:20 +0800906 fw_priv = kzalloc(sizeof(*fw_priv), GFP_KERNEL);
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700907 if (!fw_priv) {
Ming Lei12446912012-08-04 12:01:20 +0800908 fw_priv = ERR_PTR(-ENOMEM);
909 goto exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911
Takashi Iwai14c4bae2013-12-02 15:38:18 +0100912 fw_priv->nowait = !!(opt_flags & FW_OPT_NOWAIT);
Ming Lei1f2b7952012-08-04 12:01:21 +0800913 fw_priv->fw = firmware;
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700914 f_dev = &fw_priv->dev;
915
916 device_initialize(f_dev);
Ming Lei99c2aa72012-08-04 12:01:19 +0800917 dev_set_name(f_dev, "%s", fw_name);
Greg Kroah-Hartmane55c8792006-09-14 07:30:59 -0700918 f_dev->parent = device;
919 f_dev->class = &firmware_class;
Takashi Iwai46239902015-02-04 15:18:07 +0100920 f_dev->groups = fw_dev_attr_groups;
Ming Lei12446912012-08-04 12:01:20 +0800921exit:
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700922 return fw_priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923}
Takashi Iwaicd7239f2013-01-31 11:13:56 +0100924
925/* load a firmware via user helper */
Takashi Iwai14c4bae2013-12-02 15:38:18 +0100926static int _request_firmware_load(struct firmware_priv *fw_priv,
927 unsigned int opt_flags, long timeout)
Takashi Iwaicd7239f2013-01-31 11:13:56 +0100928{
929 int retval = 0;
930 struct device *f_dev = &fw_priv->dev;
931 struct firmware_buf *buf = fw_priv->buf;
932
933 /* fall back on userspace loading */
Stephen Boyda098ecd2016-08-02 14:04:28 -0700934 if (!buf->data)
935 buf->is_paged_buf = true;
Takashi Iwaicd7239f2013-01-31 11:13:56 +0100936
937 dev_set_uevent_suppress(f_dev, true);
938
Takashi Iwaicd7239f2013-01-31 11:13:56 +0100939 retval = device_add(f_dev);
940 if (retval) {
941 dev_err(f_dev, "%s: device_register failed\n", __func__);
942 goto err_put_dev;
943 }
944
Maxime Bizon1eeeef12013-08-29 20:28:13 +0200945 mutex_lock(&fw_lock);
946 list_add(&buf->pending_list, &pending_fw_head);
947 mutex_unlock(&fw_lock);
948
Takashi Iwai14c4bae2013-12-02 15:38:18 +0100949 if (opt_flags & FW_OPT_UEVENT) {
Ming Leiaf5bc112013-05-27 18:30:04 +0800950 buf->need_uevent = true;
Takashi Iwaicd7239f2013-01-31 11:13:56 +0100951 dev_set_uevent_suppress(f_dev, false);
952 dev_dbg(f_dev, "firmware: requesting %s\n", buf->fw_id);
Takashi Iwaicd7239f2013-01-31 11:13:56 +0100953 kobject_uevent(&fw_priv->dev.kobj, KOBJ_ADD);
Ming Lei68ff2a02015-01-13 00:02:01 +0800954 } else {
955 timeout = MAX_JIFFY_OFFSET;
Takashi Iwaicd7239f2013-01-31 11:13:56 +0100956 }
957
Ming Lei68ff2a02015-01-13 00:02:01 +0800958 retval = wait_for_completion_interruptible_timeout(&buf->completion,
959 timeout);
960 if (retval == -ERESTARTSYS || !retval) {
Ming Lei0cb64242015-01-13 00:01:35 +0800961 mutex_lock(&fw_lock);
962 fw_load_abort(fw_priv);
963 mutex_unlock(&fw_lock);
Zahari Doychevef518cc2015-03-10 10:45:40 +0100964 } else if (retval > 0) {
965 retval = 0;
Ming Lei0cb64242015-01-13 00:01:35 +0800966 }
Takashi Iwaicd7239f2013-01-31 11:13:56 +0100967
Shuah Khan0542ad82014-07-22 18:10:38 -0600968 if (is_fw_load_aborted(buf))
969 retval = -EAGAIN;
Stephen Boyda098ecd2016-08-02 14:04:28 -0700970 else if (buf->is_paged_buf && !buf->data)
zhang jun2b1278c2014-02-13 15:18:47 +0800971 retval = -ENOMEM;
Takashi Iwaicd7239f2013-01-31 11:13:56 +0100972
Takashi Iwaicd7239f2013-01-31 11:13:56 +0100973 device_del(f_dev);
974err_put_dev:
975 put_device(f_dev);
976 return retval;
977}
978
979static int fw_load_from_user_helper(struct firmware *firmware,
980 const char *name, struct device *device,
Takashi Iwai14c4bae2013-12-02 15:38:18 +0100981 unsigned int opt_flags, long timeout)
Takashi Iwaicd7239f2013-01-31 11:13:56 +0100982{
983 struct firmware_priv *fw_priv;
984
Takashi Iwai14c4bae2013-12-02 15:38:18 +0100985 fw_priv = fw_create_instance(firmware, name, device, opt_flags);
Takashi Iwaicd7239f2013-01-31 11:13:56 +0100986 if (IS_ERR(fw_priv))
987 return PTR_ERR(fw_priv);
988
989 fw_priv->buf = firmware->priv;
Takashi Iwai14c4bae2013-12-02 15:38:18 +0100990 return _request_firmware_load(fw_priv, opt_flags, timeout);
Takashi Iwaicd7239f2013-01-31 11:13:56 +0100991}
Ming Leiddf1f062013-06-04 10:01:13 +0800992
Ming Lei5b7cb7a2013-06-06 19:52:54 +0800993#ifdef CONFIG_PM_SLEEP
Ming Leiddf1f062013-06-04 10:01:13 +0800994/* kill pending requests without uevent to avoid blocking suspend */
995static void kill_requests_without_uevent(void)
996{
997 struct firmware_buf *buf;
998 struct firmware_buf *next;
999
1000 mutex_lock(&fw_lock);
1001 list_for_each_entry_safe(buf, next, &pending_fw_head, pending_list) {
1002 if (!buf->need_uevent)
Greg Kroah-Hartman7068cb02013-06-19 20:26:43 -07001003 __fw_load_abort(buf);
Ming Leiddf1f062013-06-04 10:01:13 +08001004 }
1005 mutex_unlock(&fw_lock);
1006}
Ming Lei5b7cb7a2013-06-06 19:52:54 +08001007#endif
Ming Leiddf1f062013-06-04 10:01:13 +08001008
Takashi Iwaicd7239f2013-01-31 11:13:56 +01001009#else /* CONFIG_FW_LOADER_USER_HELPER */
1010static inline int
1011fw_load_from_user_helper(struct firmware *firmware, const char *name,
Takashi Iwai14c4bae2013-12-02 15:38:18 +01001012 struct device *device, unsigned int opt_flags,
Takashi Iwaicd7239f2013-01-31 11:13:56 +01001013 long timeout)
1014{
1015 return -ENOENT;
1016}
Takashi Iwai807be032013-01-31 11:13:57 +01001017
1018/* No abort during direct loading */
1019#define is_fw_load_aborted(buf) false
1020
Ming Lei5b7cb7a2013-06-06 19:52:54 +08001021#ifdef CONFIG_PM_SLEEP
Ming Leiddf1f062013-06-04 10:01:13 +08001022static inline void kill_requests_without_uevent(void) { }
Ming Lei5b7cb7a2013-06-06 19:52:54 +08001023#endif
Ming Leiddf1f062013-06-04 10:01:13 +08001024
Takashi Iwai7b1269f2013-01-31 11:13:55 +01001025#endif /* CONFIG_FW_LOADER_USER_HELPER */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026
Ming Leif531f05a2012-08-04 12:01:25 +08001027
Takashi Iwai4e0c92d2013-01-31 11:13:54 +01001028/* wait until the shared firmware_buf becomes ready (or error) */
1029static int sync_cached_firmware_buf(struct firmware_buf *buf)
Ming Lei1f2b7952012-08-04 12:01:21 +08001030{
Takashi Iwai4e0c92d2013-01-31 11:13:54 +01001031 int ret = 0;
1032
1033 mutex_lock(&fw_lock);
1034 while (!test_bit(FW_STATUS_DONE, &buf->status)) {
Takashi Iwai807be032013-01-31 11:13:57 +01001035 if (is_fw_load_aborted(buf)) {
Takashi Iwai4e0c92d2013-01-31 11:13:54 +01001036 ret = -ENOENT;
1037 break;
1038 }
1039 mutex_unlock(&fw_lock);
Kweh, Hock Leong000deba2014-11-18 10:56:59 +08001040 ret = wait_for_completion_interruptible(&buf->completion);
Takashi Iwai4e0c92d2013-01-31 11:13:54 +01001041 mutex_lock(&fw_lock);
1042 }
1043 mutex_unlock(&fw_lock);
1044 return ret;
Ming Lei1f2b7952012-08-04 12:01:21 +08001045}
1046
Takashi Iwai4e0c92d2013-01-31 11:13:54 +01001047/* prepare firmware and firmware_buf structs;
1048 * return 0 if a firmware is already assigned, 1 if need to load one,
1049 * or a negative error code
1050 */
1051static int
1052_request_firmware_prepare(struct firmware **firmware_p, const char *name,
Stephen Boyda098ecd2016-08-02 14:04:28 -07001053 struct device *device, void *dbuf, size_t size)
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -07001054{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 struct firmware *firmware;
Ming Lei1f2b7952012-08-04 12:01:21 +08001056 struct firmware_buf *buf;
1057 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058
Jiri Slaby4aed0642005-09-13 01:25:01 -07001059 *firmware_p = firmware = kzalloc(sizeof(*firmware), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 if (!firmware) {
Bjorn Helgaas266a8132008-10-15 22:04:20 -07001061 dev_err(device, "%s: kmalloc(struct firmware) failed\n",
1062 __func__);
Takashi Iwai4e0c92d2013-01-31 11:13:54 +01001063 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065
Stephen Boyda098ecd2016-08-02 14:04:28 -07001066 if (fw_get_builtin_firmware(firmware, name, dbuf, size)) {
Luis R. Rodriguezed046302015-04-29 16:30:43 -07001067 dev_dbg(device, "using built-in %s\n", name);
Takashi Iwai4e0c92d2013-01-31 11:13:54 +01001068 return 0; /* assigned */
David Woodhouse5658c762008-05-23 13:52:42 +01001069 }
1070
Stephen Boyda098ecd2016-08-02 14:04:28 -07001071 ret = fw_lookup_and_allocate_buf(name, &fw_cache, &buf, dbuf, size);
Ming Lei1f2b7952012-08-04 12:01:21 +08001072
Takashi Iwai4e0c92d2013-01-31 11:13:54 +01001073 /*
1074 * bind with 'buf' now to avoid warning in failure path
1075 * of requesting firmware.
1076 */
1077 firmware->priv = buf;
Ming Lei1f2b7952012-08-04 12:01:21 +08001078
Takashi Iwai4e0c92d2013-01-31 11:13:54 +01001079 if (ret > 0) {
1080 ret = sync_cached_firmware_buf(buf);
1081 if (!ret) {
1082 fw_set_page_data(buf, firmware);
1083 return 0; /* assigned */
1084 }
Stephen Boyddddb5542012-03-28 23:30:43 +02001085 }
Ming Lei1f2b7952012-08-04 12:01:21 +08001086
Takashi Iwai4e0c92d2013-01-31 11:13:54 +01001087 if (ret < 0)
1088 return ret;
1089 return 1; /* need to load */
Rafael J. Wysocki811fa402012-03-28 23:29:55 +02001090}
1091
Ming Leie771d1a2013-05-27 18:30:03 +08001092static int assign_firmware_buf(struct firmware *fw, struct device *device,
Takashi Iwai14c4bae2013-12-02 15:38:18 +01001093 unsigned int opt_flags)
Takashi Iwai4e0c92d2013-01-31 11:13:54 +01001094{
1095 struct firmware_buf *buf = fw->priv;
1096
1097 mutex_lock(&fw_lock);
Takashi Iwai807be032013-01-31 11:13:57 +01001098 if (!buf->size || is_fw_load_aborted(buf)) {
Takashi Iwai4e0c92d2013-01-31 11:13:54 +01001099 mutex_unlock(&fw_lock);
1100 return -ENOENT;
1101 }
1102
1103 /*
1104 * add firmware name into devres list so that we can auto cache
1105 * and uncache firmware for device.
1106 *
1107 * device may has been deleted already, but the problem
1108 * should be fixed in devres or driver core.
1109 */
Takashi Iwai14c4bae2013-12-02 15:38:18 +01001110 /* don't cache firmware handled without uevent */
Vikram Mulukutla0e742e92016-08-02 14:04:25 -07001111 if (device && (opt_flags & FW_OPT_UEVENT) &&
1112 !(opt_flags & FW_OPT_NOCACHE))
Takashi Iwai4e0c92d2013-01-31 11:13:54 +01001113 fw_add_devm_name(device, buf->fw_id);
1114
1115 /*
1116 * After caching firmware image is started, let it piggyback
1117 * on request firmware.
1118 */
Vikram Mulukutla0e742e92016-08-02 14:04:25 -07001119 if (!(opt_flags & FW_OPT_NOCACHE) &&
1120 buf->fwc->state == FW_LOADER_START_CACHE) {
Takashi Iwai4e0c92d2013-01-31 11:13:54 +01001121 if (fw_cache_piggyback_on_request(buf->fw_id))
1122 kref_get(&buf->ref);
1123 }
1124
1125 /* pass the pages buffer to driver at the last minute */
1126 fw_set_page_data(buf, fw);
1127 mutex_unlock(&fw_lock);
1128 return 0;
1129}
1130
Takashi Iwai4e0c92d2013-01-31 11:13:54 +01001131/* called from request_firmware() and request_firmware_work_func() */
1132static int
1133_request_firmware(const struct firmware **firmware_p, const char *name,
Stephen Boyda098ecd2016-08-02 14:04:28 -07001134 struct device *device, void *buf, size_t size,
1135 unsigned int opt_flags)
Takashi Iwai4e0c92d2013-01-31 11:13:54 +01001136{
Brian Norris715780a2015-12-09 14:50:28 -08001137 struct firmware *fw = NULL;
Takashi Iwai4e0c92d2013-01-31 11:13:54 +01001138 long timeout;
1139 int ret;
1140
1141 if (!firmware_p)
1142 return -EINVAL;
1143
Brian Norris715780a2015-12-09 14:50:28 -08001144 if (!name || name[0] == '\0') {
1145 ret = -EINVAL;
1146 goto out;
1147 }
Kees Cook471b0952014-09-18 11:25:37 -07001148
Stephen Boyda098ecd2016-08-02 14:04:28 -07001149 ret = _request_firmware_prepare(&fw, name, device, buf, size);
Takashi Iwai4e0c92d2013-01-31 11:13:54 +01001150 if (ret <= 0) /* error or already assigned */
1151 goto out;
1152
1153 ret = 0;
1154 timeout = firmware_loading_timeout();
Takashi Iwai14c4bae2013-12-02 15:38:18 +01001155 if (opt_flags & FW_OPT_NOWAIT) {
Takashi Iwai4e0c92d2013-01-31 11:13:54 +01001156 timeout = usermodehelper_read_lock_wait(timeout);
1157 if (!timeout) {
1158 dev_dbg(device, "firmware: %s loading timed out\n",
1159 name);
1160 ret = -EBUSY;
1161 goto out;
1162 }
1163 } else {
1164 ret = usermodehelper_read_trylock();
1165 if (WARN_ON(ret)) {
1166 dev_err(device, "firmware: %s will not be loaded\n",
1167 name);
1168 goto out;
1169 }
1170 }
1171
Neil Horman3e358ac2013-09-06 15:36:08 -04001172 ret = fw_get_filesystem_firmware(device, fw->priv);
1173 if (ret) {
Luis R. Rodriguezc868edf2014-07-02 09:55:05 -07001174 if (!(opt_flags & FW_OPT_NO_WARN))
Takashi Iwaibba3a872013-12-02 15:38:16 +01001175 dev_warn(device,
Luis R. Rodriguezc868edf2014-07-02 09:55:05 -07001176 "Direct firmware load for %s failed with error %d\n",
1177 name, ret);
1178 if (opt_flags & FW_OPT_USERHELPER) {
Takashi Iwaibba3a872013-12-02 15:38:16 +01001179 dev_warn(device, "Falling back to user helper\n");
1180 ret = fw_load_from_user_helper(fw, name, device,
Takashi Iwai14c4bae2013-12-02 15:38:18 +01001181 opt_flags, timeout);
Takashi Iwaibba3a872013-12-02 15:38:16 +01001182 }
Neil Horman3e358ac2013-09-06 15:36:08 -04001183 }
Ming Leie771d1a2013-05-27 18:30:03 +08001184
Takashi Iwai4e0c92d2013-01-31 11:13:54 +01001185 if (!ret)
Takashi Iwai14c4bae2013-12-02 15:38:18 +01001186 ret = assign_firmware_buf(fw, device, opt_flags);
Takashi Iwai4e0c92d2013-01-31 11:13:54 +01001187
1188 usermodehelper_read_unlock();
1189
1190 out:
1191 if (ret < 0) {
1192 release_firmware(fw);
1193 fw = NULL;
1194 }
1195
1196 *firmware_p = fw;
1197 return ret;
1198}
1199
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200/**
Kay Sievers312c0042005-11-16 09:00:00 +01001201 * request_firmware: - send firmware request and wait for it
Randy Dunlapeb8e3172005-10-30 15:03:01 -08001202 * @firmware_p: pointer to firmware image
1203 * @name: name of firmware file
1204 * @device: device for which firmware is being loaded
1205 *
1206 * @firmware_p will be used to return a firmware image by the name
Abhay Salunke6e3eaab2005-09-06 15:17:13 -07001207 * of @name for device @device.
1208 *
1209 * Should be called from user context where sleeping is allowed.
1210 *
Kay Sievers312c0042005-11-16 09:00:00 +01001211 * @name will be used as $FIRMWARE in the uevent environment and
Abhay Salunke6e3eaab2005-09-06 15:17:13 -07001212 * should be distinctive enough not to be confused with any other
1213 * firmware image for this or any other device.
Ming Lei0cfc1e12012-08-04 12:01:23 +08001214 *
1215 * Caller must hold the reference count of @device.
Ming Lei6a927852012-11-03 17:48:16 +08001216 *
1217 * The function can be called safely inside device's suspend and
1218 * resume callback.
Abhay Salunke6e3eaab2005-09-06 15:17:13 -07001219 **/
1220int
1221request_firmware(const struct firmware **firmware_p, const char *name,
Andrei Opreaea310032015-03-08 12:41:15 +02001222 struct device *device)
Abhay Salunke6e3eaab2005-09-06 15:17:13 -07001223{
Ming Leid6c8aa32013-06-06 20:01:48 +08001224 int ret;
1225
1226 /* Need to pin this module until return */
1227 __module_get(THIS_MODULE);
Stephen Boyda098ecd2016-08-02 14:04:28 -07001228 ret = _request_firmware(firmware_p, name, device, NULL, 0,
Takashi Iwai14c4bae2013-12-02 15:38:18 +01001229 FW_OPT_UEVENT | FW_OPT_FALLBACK);
Ming Leid6c8aa32013-06-06 20:01:48 +08001230 module_put(THIS_MODULE);
1231 return ret;
Abhay Salunke6e3eaab2005-09-06 15:17:13 -07001232}
Daniel Mackf4945132013-05-23 22:17:18 +02001233EXPORT_SYMBOL(request_firmware);
Abhay Salunke6e3eaab2005-09-06 15:17:13 -07001234
Takashi Iwaibba3a872013-12-02 15:38:16 +01001235/**
Borislav Petkov3c1556b2014-12-03 22:46:37 +01001236 * request_firmware_direct: - load firmware directly without usermode helper
Takashi Iwaibba3a872013-12-02 15:38:16 +01001237 * @firmware_p: pointer to firmware image
1238 * @name: name of firmware file
1239 * @device: device for which firmware is being loaded
1240 *
1241 * This function works pretty much like request_firmware(), but this doesn't
1242 * fall back to usermode helper even if the firmware couldn't be loaded
1243 * directly from fs. Hence it's useful for loading optional firmwares, which
1244 * aren't always present, without extra long timeouts of udev.
1245 **/
1246int request_firmware_direct(const struct firmware **firmware_p,
1247 const char *name, struct device *device)
1248{
1249 int ret;
Andrei Opreaea310032015-03-08 12:41:15 +02001250
Takashi Iwaibba3a872013-12-02 15:38:16 +01001251 __module_get(THIS_MODULE);
Stephen Boyda098ecd2016-08-02 14:04:28 -07001252 ret = _request_firmware(firmware_p, name, device, NULL, 0,
Luis R. Rodriguezc868edf2014-07-02 09:55:05 -07001253 FW_OPT_UEVENT | FW_OPT_NO_WARN);
Takashi Iwaibba3a872013-12-02 15:38:16 +01001254 module_put(THIS_MODULE);
1255 return ret;
1256}
1257EXPORT_SYMBOL_GPL(request_firmware_direct);
Takashi Iwaibba3a872013-12-02 15:38:16 +01001258
Abhay Salunke6e3eaab2005-09-06 15:17:13 -07001259/**
Stephen Boyda098ecd2016-08-02 14:04:28 -07001260 * request_firmware_into_buf - load firmware into a previously allocated buffer
1261 * @firmware_p: pointer to firmware image
1262 * @name: name of firmware file
1263 * @device: device for which firmware is being loaded and DMA region allocated
1264 * @buf: address of buffer to load firmware into
1265 * @size: size of buffer
1266 *
1267 * This function works pretty much like request_firmware(), but it doesn't
1268 * allocate a buffer to hold the firmware data. Instead, the firmware
1269 * is loaded directly into the buffer pointed to by @buf and the @firmware_p
1270 * data member is pointed at @buf.
1271 *
1272 * This function doesn't cache firmware either.
1273 */
1274int
1275request_firmware_into_buf(const struct firmware **firmware_p, const char *name,
1276 struct device *device, void *buf, size_t size)
1277{
1278 int ret;
1279
1280 __module_get(THIS_MODULE);
1281 ret = _request_firmware(firmware_p, name, device, buf, size,
1282 FW_OPT_UEVENT | FW_OPT_FALLBACK |
1283 FW_OPT_NOCACHE);
1284 module_put(THIS_MODULE);
1285 return ret;
1286}
1287EXPORT_SYMBOL(request_firmware_into_buf);
1288
1289/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290 * release_firmware: - release the resource associated with a firmware image
Randy Dunlapeb8e3172005-10-30 15:03:01 -08001291 * @fw: firmware resource to release
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292 **/
Dmitry Torokhovbcb9bd12010-03-13 23:49:18 -08001293void release_firmware(const struct firmware *fw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294{
1295 if (fw) {
Dmitry Torokhovbcb9bd12010-03-13 23:49:18 -08001296 if (!fw_is_builtin_firmware(fw))
1297 firmware_free_data(fw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298 kfree(fw);
1299 }
1300}
Daniel Mackf4945132013-05-23 22:17:18 +02001301EXPORT_SYMBOL(release_firmware);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303/* Async support */
1304struct firmware_work {
1305 struct work_struct work;
1306 struct module *module;
1307 const char *name;
1308 struct device *device;
1309 void *context;
1310 void (*cont)(const struct firmware *fw, void *context);
Takashi Iwai14c4bae2013-12-02 15:38:18 +01001311 unsigned int opt_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312};
1313
Stephen Boyda36cf842012-03-28 23:31:00 +02001314static void request_firmware_work_func(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315{
Stephen Boyda36cf842012-03-28 23:31:00 +02001316 struct firmware_work *fw_work;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317 const struct firmware *fw;
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -07001318
Stephen Boyda36cf842012-03-28 23:31:00 +02001319 fw_work = container_of(work, struct firmware_work, work);
Rafael J. Wysocki811fa402012-03-28 23:29:55 +02001320
Stephen Boyda098ecd2016-08-02 14:04:28 -07001321 _request_firmware(&fw, fw_work->name, fw_work->device, NULL, 0,
Takashi Iwai14c4bae2013-12-02 15:38:18 +01001322 fw_work->opt_flags);
Johannes Berg9ebfbd42009-10-29 12:36:02 +01001323 fw_work->cont(fw, fw_work->context);
Takashi Iwai4e0c92d2013-01-31 11:13:54 +01001324 put_device(fw_work->device); /* taken in request_firmware_nowait() */
Johannes Berg9ebfbd42009-10-29 12:36:02 +01001325
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326 module_put(fw_work->module);
Luis R. Rodriguezf9692b22015-05-12 14:49:42 -07001327 kfree_const(fw_work->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328 kfree(fw_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329}
1330
1331/**
Ben Hutchings3c31f072010-02-14 14:18:53 +00001332 * request_firmware_nowait - asynchronous version of request_firmware
Randy Dunlapeb8e3172005-10-30 15:03:01 -08001333 * @module: module requesting the firmware
Kay Sievers312c0042005-11-16 09:00:00 +01001334 * @uevent: sends uevent to copy the firmware image if this flag
Randy Dunlapeb8e3172005-10-30 15:03:01 -08001335 * is non-zero else the firmware copy must be done manually.
1336 * @name: name of firmware file
1337 * @device: device for which firmware is being loaded
Johannes Berg9ebfbd42009-10-29 12:36:02 +01001338 * @gfp: allocation flags
Randy Dunlapeb8e3172005-10-30 15:03:01 -08001339 * @context: will be passed over to @cont, and
1340 * @fw may be %NULL if firmware request fails.
1341 * @cont: function will be called asynchronously when the firmware
1342 * request is over.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343 *
Ming Lei0cfc1e12012-08-04 12:01:23 +08001344 * Caller must hold the reference count of @device.
1345 *
Ming Lei6f21a622012-08-04 12:01:24 +08001346 * Asynchronous variant of request_firmware() for user contexts:
1347 * - sleep for as small periods as possible since it may
1348 * increase kernel boot time of built-in device drivers
1349 * requesting firmware in their ->probe() methods, if
1350 * @gfp is GFP_KERNEL.
1351 *
1352 * - can't sleep at all if @gfp is GFP_ATOMIC.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353 **/
1354int
1355request_firmware_nowait(
Bob Liu072fc8f2011-01-26 18:33:32 +08001356 struct module *module, bool uevent,
Johannes Berg9ebfbd42009-10-29 12:36:02 +01001357 const char *name, struct device *device, gfp_t gfp, void *context,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358 void (*cont)(const struct firmware *fw, void *context))
1359{
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -07001360 struct firmware_work *fw_work;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361
Andrei Opreaea310032015-03-08 12:41:15 +02001362 fw_work = kzalloc(sizeof(struct firmware_work), gfp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363 if (!fw_work)
1364 return -ENOMEM;
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -07001365
1366 fw_work->module = module;
Luis R. Rodriguezf9692b22015-05-12 14:49:42 -07001367 fw_work->name = kstrdup_const(name, gfp);
Luis R. Rodriguez303cda02015-05-28 17:46:42 -07001368 if (!fw_work->name) {
1369 kfree(fw_work);
Luis R. Rodriguezf9692b22015-05-12 14:49:42 -07001370 return -ENOMEM;
Luis R. Rodriguez303cda02015-05-28 17:46:42 -07001371 }
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -07001372 fw_work->device = device;
1373 fw_work->context = context;
1374 fw_work->cont = cont;
Takashi Iwai14c4bae2013-12-02 15:38:18 +01001375 fw_work->opt_flags = FW_OPT_NOWAIT | FW_OPT_FALLBACK |
Takashi Iwai5a1379e2014-06-04 17:48:15 +02001376 (uevent ? FW_OPT_UEVENT : FW_OPT_USERHELPER);
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -07001377
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378 if (!try_module_get(module)) {
Luis R. Rodriguezf9692b22015-05-12 14:49:42 -07001379 kfree_const(fw_work->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 kfree(fw_work);
1381 return -EFAULT;
1382 }
1383
Ming Lei0cfc1e12012-08-04 12:01:23 +08001384 get_device(fw_work->device);
Stephen Boyda36cf842012-03-28 23:31:00 +02001385 INIT_WORK(&fw_work->work, request_firmware_work_func);
1386 schedule_work(&fw_work->work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387 return 0;
1388}
Daniel Mackf4945132013-05-23 22:17:18 +02001389EXPORT_SYMBOL(request_firmware_nowait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390
Ming Lei90f890812013-06-20 12:30:16 +08001391#ifdef CONFIG_PM_SLEEP
1392static ASYNC_DOMAIN_EXCLUSIVE(fw_cache_domain);
1393
Ming Lei2887b392012-08-04 12:01:22 +08001394/**
1395 * cache_firmware - cache one firmware image in kernel memory space
1396 * @fw_name: the firmware image name
1397 *
1398 * Cache firmware in kernel memory so that drivers can use it when
1399 * system isn't ready for them to request firmware image from userspace.
1400 * Once it returns successfully, driver can use request_firmware or its
1401 * nowait version to get the cached firmware without any interacting
1402 * with userspace
1403 *
1404 * Return 0 if the firmware image has been cached successfully
1405 * Return !0 otherwise
1406 *
1407 */
Ming Lei93232e42013-06-06 20:01:47 +08001408static int cache_firmware(const char *fw_name)
Ming Lei2887b392012-08-04 12:01:22 +08001409{
1410 int ret;
1411 const struct firmware *fw;
1412
1413 pr_debug("%s: %s\n", __func__, fw_name);
1414
1415 ret = request_firmware(&fw, fw_name, NULL);
1416 if (!ret)
1417 kfree(fw);
1418
1419 pr_debug("%s: %s ret=%d\n", __func__, fw_name, ret);
1420
1421 return ret;
1422}
1423
Ming Lei6a2c1232013-06-26 09:28:17 +08001424static struct firmware_buf *fw_lookup_buf(const char *fw_name)
1425{
1426 struct firmware_buf *tmp;
1427 struct firmware_cache *fwc = &fw_cache;
1428
1429 spin_lock(&fwc->lock);
1430 tmp = __fw_lookup_buf(fw_name);
1431 spin_unlock(&fwc->lock);
1432
1433 return tmp;
1434}
1435
Ming Lei2887b392012-08-04 12:01:22 +08001436/**
1437 * uncache_firmware - remove one cached firmware image
1438 * @fw_name: the firmware image name
1439 *
1440 * Uncache one firmware image which has been cached successfully
1441 * before.
1442 *
1443 * Return 0 if the firmware cache has been removed successfully
1444 * Return !0 otherwise
1445 *
1446 */
Ming Lei93232e42013-06-06 20:01:47 +08001447static int uncache_firmware(const char *fw_name)
Ming Lei2887b392012-08-04 12:01:22 +08001448{
1449 struct firmware_buf *buf;
1450 struct firmware fw;
1451
1452 pr_debug("%s: %s\n", __func__, fw_name);
1453
Stephen Boyda098ecd2016-08-02 14:04:28 -07001454 if (fw_get_builtin_firmware(&fw, fw_name, NULL, 0))
Ming Lei2887b392012-08-04 12:01:22 +08001455 return 0;
1456
1457 buf = fw_lookup_buf(fw_name);
1458 if (buf) {
1459 fw_free_buf(buf);
1460 return 0;
1461 }
1462
1463 return -EINVAL;
1464}
1465
Ming Lei37276a52012-08-04 12:01:27 +08001466static struct fw_cache_entry *alloc_fw_cache_entry(const char *name)
1467{
1468 struct fw_cache_entry *fce;
1469
Luis R. Rodrigueze0fd9b12015-05-12 14:49:43 -07001470 fce = kzalloc(sizeof(*fce), GFP_ATOMIC);
Ming Lei37276a52012-08-04 12:01:27 +08001471 if (!fce)
1472 goto exit;
1473
Luis R. Rodrigueze0fd9b12015-05-12 14:49:43 -07001474 fce->name = kstrdup_const(name, GFP_ATOMIC);
1475 if (!fce->name) {
1476 kfree(fce);
1477 fce = NULL;
1478 goto exit;
1479 }
Ming Lei37276a52012-08-04 12:01:27 +08001480exit:
1481 return fce;
1482}
1483
Ming Lei373304f2012-10-09 12:01:01 +08001484static int __fw_entry_found(const char *name)
1485{
1486 struct firmware_cache *fwc = &fw_cache;
1487 struct fw_cache_entry *fce;
1488
1489 list_for_each_entry(fce, &fwc->fw_names, list) {
1490 if (!strcmp(fce->name, name))
1491 return 1;
1492 }
1493 return 0;
1494}
1495
Ming Leiac39b3e2012-08-20 19:04:16 +08001496static int fw_cache_piggyback_on_request(const char *name)
1497{
1498 struct firmware_cache *fwc = &fw_cache;
1499 struct fw_cache_entry *fce;
1500 int ret = 0;
1501
1502 spin_lock(&fwc->name_lock);
Ming Lei373304f2012-10-09 12:01:01 +08001503 if (__fw_entry_found(name))
1504 goto found;
Ming Leiac39b3e2012-08-20 19:04:16 +08001505
1506 fce = alloc_fw_cache_entry(name);
1507 if (fce) {
1508 ret = 1;
1509 list_add(&fce->list, &fwc->fw_names);
1510 pr_debug("%s: fw: %s\n", __func__, name);
1511 }
1512found:
1513 spin_unlock(&fwc->name_lock);
1514 return ret;
1515}
1516
Ming Lei37276a52012-08-04 12:01:27 +08001517static void free_fw_cache_entry(struct fw_cache_entry *fce)
1518{
Luis R. Rodrigueze0fd9b12015-05-12 14:49:43 -07001519 kfree_const(fce->name);
Ming Lei37276a52012-08-04 12:01:27 +08001520 kfree(fce);
1521}
1522
1523static void __async_dev_cache_fw_image(void *fw_entry,
1524 async_cookie_t cookie)
1525{
1526 struct fw_cache_entry *fce = fw_entry;
1527 struct firmware_cache *fwc = &fw_cache;
1528 int ret;
1529
1530 ret = cache_firmware(fce->name);
Ming Leiac39b3e2012-08-20 19:04:16 +08001531 if (ret) {
1532 spin_lock(&fwc->name_lock);
1533 list_del(&fce->list);
1534 spin_unlock(&fwc->name_lock);
Ming Lei37276a52012-08-04 12:01:27 +08001535
Ming Leiac39b3e2012-08-20 19:04:16 +08001536 free_fw_cache_entry(fce);
1537 }
Ming Lei37276a52012-08-04 12:01:27 +08001538}
1539
1540/* called with dev->devres_lock held */
1541static void dev_create_fw_entry(struct device *dev, void *res,
1542 void *data)
1543{
1544 struct fw_name_devm *fwn = res;
1545 const char *fw_name = fwn->name;
1546 struct list_head *head = data;
1547 struct fw_cache_entry *fce;
1548
1549 fce = alloc_fw_cache_entry(fw_name);
1550 if (fce)
1551 list_add(&fce->list, head);
1552}
1553
1554static int devm_name_match(struct device *dev, void *res,
1555 void *match_data)
1556{
1557 struct fw_name_devm *fwn = res;
1558 return (fwn->magic == (unsigned long)match_data);
1559}
1560
Ming Leiab6dd8e2012-08-17 22:07:00 +08001561static void dev_cache_fw_image(struct device *dev, void *data)
Ming Lei37276a52012-08-04 12:01:27 +08001562{
1563 LIST_HEAD(todo);
1564 struct fw_cache_entry *fce;
1565 struct fw_cache_entry *fce_next;
1566 struct firmware_cache *fwc = &fw_cache;
1567
1568 devres_for_each_res(dev, fw_name_devm_release,
1569 devm_name_match, &fw_cache,
1570 dev_create_fw_entry, &todo);
1571
1572 list_for_each_entry_safe(fce, fce_next, &todo, list) {
1573 list_del(&fce->list);
1574
1575 spin_lock(&fwc->name_lock);
Ming Lei373304f2012-10-09 12:01:01 +08001576 /* only one cache entry for one firmware */
1577 if (!__fw_entry_found(fce->name)) {
Ming Lei373304f2012-10-09 12:01:01 +08001578 list_add(&fce->list, &fwc->fw_names);
1579 } else {
1580 free_fw_cache_entry(fce);
1581 fce = NULL;
1582 }
Ming Lei37276a52012-08-04 12:01:27 +08001583 spin_unlock(&fwc->name_lock);
1584
Ming Lei373304f2012-10-09 12:01:01 +08001585 if (fce)
Ming Leid28d3882012-10-09 12:01:04 +08001586 async_schedule_domain(__async_dev_cache_fw_image,
1587 (void *)fce,
1588 &fw_cache_domain);
Ming Lei37276a52012-08-04 12:01:27 +08001589 }
1590}
1591
1592static void __device_uncache_fw_images(void)
1593{
1594 struct firmware_cache *fwc = &fw_cache;
1595 struct fw_cache_entry *fce;
1596
1597 spin_lock(&fwc->name_lock);
1598 while (!list_empty(&fwc->fw_names)) {
1599 fce = list_entry(fwc->fw_names.next,
1600 struct fw_cache_entry, list);
1601 list_del(&fce->list);
1602 spin_unlock(&fwc->name_lock);
1603
1604 uncache_firmware(fce->name);
1605 free_fw_cache_entry(fce);
1606
1607 spin_lock(&fwc->name_lock);
1608 }
1609 spin_unlock(&fwc->name_lock);
1610}
1611
1612/**
1613 * device_cache_fw_images - cache devices' firmware
1614 *
1615 * If one device called request_firmware or its nowait version
1616 * successfully before, the firmware names are recored into the
1617 * device's devres link list, so device_cache_fw_images can call
1618 * cache_firmware() to cache these firmwares for the device,
1619 * then the device driver can load its firmwares easily at
1620 * time when system is not ready to complete loading firmware.
1621 */
1622static void device_cache_fw_images(void)
1623{
1624 struct firmware_cache *fwc = &fw_cache;
Ming Leiffe53f62012-08-04 12:01:28 +08001625 int old_timeout;
Ming Lei37276a52012-08-04 12:01:27 +08001626 DEFINE_WAIT(wait);
1627
1628 pr_debug("%s\n", __func__);
1629
Ming Lei373304f2012-10-09 12:01:01 +08001630 /* cancel uncache work */
1631 cancel_delayed_work_sync(&fwc->work);
1632
Ming Leiffe53f62012-08-04 12:01:28 +08001633 /*
1634 * use small loading timeout for caching devices' firmware
1635 * because all these firmware images have been loaded
1636 * successfully at lease once, also system is ready for
1637 * completing firmware loading now. The maximum size of
1638 * firmware in current distributions is about 2M bytes,
1639 * so 10 secs should be enough.
1640 */
1641 old_timeout = loading_timeout;
1642 loading_timeout = 10;
1643
Ming Leiac39b3e2012-08-20 19:04:16 +08001644 mutex_lock(&fw_lock);
1645 fwc->state = FW_LOADER_START_CACHE;
Ming Leiab6dd8e2012-08-17 22:07:00 +08001646 dpm_for_each_dev(NULL, dev_cache_fw_image);
Ming Leiac39b3e2012-08-20 19:04:16 +08001647 mutex_unlock(&fw_lock);
Ming Lei37276a52012-08-04 12:01:27 +08001648
1649 /* wait for completion of caching firmware for all devices */
Ming Leid28d3882012-10-09 12:01:04 +08001650 async_synchronize_full_domain(&fw_cache_domain);
Ming Leiffe53f62012-08-04 12:01:28 +08001651
1652 loading_timeout = old_timeout;
Ming Lei37276a52012-08-04 12:01:27 +08001653}
1654
1655/**
1656 * device_uncache_fw_images - uncache devices' firmware
1657 *
1658 * uncache all firmwares which have been cached successfully
1659 * by device_uncache_fw_images earlier
1660 */
1661static void device_uncache_fw_images(void)
1662{
1663 pr_debug("%s\n", __func__);
1664 __device_uncache_fw_images();
1665}
1666
1667static void device_uncache_fw_images_work(struct work_struct *work)
1668{
1669 device_uncache_fw_images();
1670}
1671
1672/**
1673 * device_uncache_fw_images_delay - uncache devices firmwares
1674 * @delay: number of milliseconds to delay uncache device firmwares
1675 *
1676 * uncache all devices's firmwares which has been cached successfully
1677 * by device_cache_fw_images after @delay milliseconds.
1678 */
1679static void device_uncache_fw_images_delay(unsigned long delay)
1680{
Shaibal Duttabce66182014-01-31 15:44:58 -08001681 queue_delayed_work(system_power_efficient_wq, &fw_cache.work,
1682 msecs_to_jiffies(delay));
Ming Lei37276a52012-08-04 12:01:27 +08001683}
1684
Ming Lei07646d92012-08-04 12:01:29 +08001685static int fw_pm_notify(struct notifier_block *notify_block,
1686 unsigned long mode, void *unused)
1687{
1688 switch (mode) {
1689 case PM_HIBERNATION_PREPARE:
1690 case PM_SUSPEND_PREPARE:
Sebastian Capellaf8d5b9e2014-02-18 17:52:08 -08001691 case PM_RESTORE_PREPARE:
Ming Leiaf5bc112013-05-27 18:30:04 +08001692 kill_requests_without_uevent();
Ming Lei07646d92012-08-04 12:01:29 +08001693 device_cache_fw_images();
1694 break;
1695
1696 case PM_POST_SUSPEND:
1697 case PM_POST_HIBERNATION:
1698 case PM_POST_RESTORE:
Ming Leiac39b3e2012-08-20 19:04:16 +08001699 /*
1700 * In case that system sleep failed and syscore_suspend is
1701 * not called.
1702 */
1703 mutex_lock(&fw_lock);
1704 fw_cache.state = FW_LOADER_NO_CACHE;
1705 mutex_unlock(&fw_lock);
1706
Ming Lei07646d92012-08-04 12:01:29 +08001707 device_uncache_fw_images_delay(10 * MSEC_PER_SEC);
1708 break;
1709 }
1710
1711 return 0;
1712}
Ming Lei07646d92012-08-04 12:01:29 +08001713
Ming Leiac39b3e2012-08-20 19:04:16 +08001714/* stop caching firmware once syscore_suspend is reached */
1715static int fw_suspend(void)
1716{
1717 fw_cache.state = FW_LOADER_NO_CACHE;
1718 return 0;
1719}
1720
1721static struct syscore_ops fw_syscore_ops = {
1722 .suspend = fw_suspend,
1723};
Ming Leicfe016b2012-09-08 17:32:30 +08001724#else
1725static int fw_cache_piggyback_on_request(const char *name)
1726{
1727 return 0;
1728}
1729#endif
Ming Leiac39b3e2012-08-20 19:04:16 +08001730
Ming Lei37276a52012-08-04 12:01:27 +08001731static void __init fw_cache_init(void)
1732{
1733 spin_lock_init(&fw_cache.lock);
1734 INIT_LIST_HEAD(&fw_cache.head);
Ming Leicfe016b2012-09-08 17:32:30 +08001735 fw_cache.state = FW_LOADER_NO_CACHE;
Ming Lei37276a52012-08-04 12:01:27 +08001736
Ming Leicfe016b2012-09-08 17:32:30 +08001737#ifdef CONFIG_PM_SLEEP
Ming Lei37276a52012-08-04 12:01:27 +08001738 spin_lock_init(&fw_cache.name_lock);
1739 INIT_LIST_HEAD(&fw_cache.fw_names);
Ming Lei37276a52012-08-04 12:01:27 +08001740
Ming Lei37276a52012-08-04 12:01:27 +08001741 INIT_DELAYED_WORK(&fw_cache.work,
1742 device_uncache_fw_images_work);
Ming Lei07646d92012-08-04 12:01:29 +08001743
1744 fw_cache.pm_notify.notifier_call = fw_pm_notify;
1745 register_pm_notifier(&fw_cache.pm_notify);
Ming Leiac39b3e2012-08-20 19:04:16 +08001746
1747 register_syscore_ops(&fw_syscore_ops);
Ming Leicfe016b2012-09-08 17:32:30 +08001748#endif
Ming Lei37276a52012-08-04 12:01:27 +08001749}
1750
Dmitry Torokhov673fae92010-03-13 23:49:13 -08001751static int __init firmware_class_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752{
Ming Lei1f2b7952012-08-04 12:01:21 +08001753 fw_cache_init();
Takashi Iwai7b1269f2013-01-31 11:13:55 +01001754#ifdef CONFIG_FW_LOADER_USER_HELPER
Takashi Iwaife304142013-05-22 18:28:38 +02001755 register_reboot_notifier(&fw_shutdown_nb);
Dmitry Torokhov673fae92010-03-13 23:49:13 -08001756 return class_register(&firmware_class);
Takashi Iwai7b1269f2013-01-31 11:13:55 +01001757#else
1758 return 0;
1759#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760}
Dmitry Torokhov673fae92010-03-13 23:49:13 -08001761
1762static void __exit firmware_class_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001763{
Ming Leicfe016b2012-09-08 17:32:30 +08001764#ifdef CONFIG_PM_SLEEP
Ming Leiac39b3e2012-08-20 19:04:16 +08001765 unregister_syscore_ops(&fw_syscore_ops);
Ming Lei07646d92012-08-04 12:01:29 +08001766 unregister_pm_notifier(&fw_cache.pm_notify);
Ming Leicfe016b2012-09-08 17:32:30 +08001767#endif
Takashi Iwai7b1269f2013-01-31 11:13:55 +01001768#ifdef CONFIG_FW_LOADER_USER_HELPER
Takashi Iwaife304142013-05-22 18:28:38 +02001769 unregister_reboot_notifier(&fw_shutdown_nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770 class_unregister(&firmware_class);
Takashi Iwai7b1269f2013-01-31 11:13:55 +01001771#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772}
1773
Shaohua Lia30a6a22006-09-27 01:50:52 -07001774fs_initcall(firmware_class_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775module_exit(firmware_class_exit);