2 * firmware_class.c - Multi purpose firmware loading support
4 * Copyright (c) 2003 Manuel Estrada Sainz
6 * Please see Documentation/firmware_class/ for more information.
10 #include <linux/capability.h>
11 #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>
18 #include <linux/mutex.h>
19 #include <linux/workqueue.h>
20 #include <linux/highmem.h>
21 #include <linux/firmware.h>
22 #include <linux/slab.h>
23 #include <linux/sched.h>
24 #include <linux/file.h>
25 #include <linux/list.h>
27 #include <linux/async.h>
29 #include <linux/suspend.h>
30 #include <linux/syscore_ops.h>
31 #include <linux/reboot.h>
32 #include <linux/security.h>
34 #include <generated/utsrelease.h>
38 MODULE_AUTHOR("Manuel Estrada Sainz");
39 MODULE_DESCRIPTION("Multi purpose firmware loading support");
40 MODULE_LICENSE("GPL");
42 /* Builtin firmware support */
44 #ifdef CONFIG_FW_LOADER
46 extern struct builtin_fw __start_builtin_fw[];
47 extern struct builtin_fw __end_builtin_fw[];
49 static bool fw_get_builtin_firmware(struct firmware *fw, const char *name,
50 void *buf, size_t size)
52 struct builtin_fw *b_fw;
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;
59 if (buf && fw->size <= size)
60 memcpy(buf, fw->data, fw->size);
68 static bool fw_is_builtin_firmware(const struct firmware *fw)
70 struct builtin_fw *b_fw;
72 for (b_fw = __start_builtin_fw; b_fw != __end_builtin_fw; b_fw++)
73 if (fw->data == b_fw->data)
79 #else /* Module case - no builtin firmware support */
81 static inline bool fw_get_builtin_firmware(struct firmware *fw,
82 const char *name, void *buf,
88 static inline bool fw_is_builtin_firmware(const struct firmware *fw)
100 static int loading_timeout = 60; /* In seconds */
102 static inline long firmware_loading_timeout(void)
104 return loading_timeout > 0 ? loading_timeout * HZ : MAX_JIFFY_OFFSET;
107 /* firmware behavior options */
108 #define FW_OPT_UEVENT (1U << 0)
109 #define FW_OPT_NOWAIT (1U << 1)
110 #ifdef CONFIG_FW_LOADER_USER_HELPER
111 #define FW_OPT_USERHELPER (1U << 2)
113 #define FW_OPT_USERHELPER 0
115 #ifdef CONFIG_FW_LOADER_USER_HELPER_FALLBACK
116 #define FW_OPT_FALLBACK FW_OPT_USERHELPER
118 #define FW_OPT_FALLBACK 0
120 #define FW_OPT_NO_WARN (1U << 3)
121 #define FW_OPT_NOCACHE (1U << 4)
123 struct firmware_cache {
124 /* firmware_buf instance will be added into the below list */
126 struct list_head head;
129 #ifdef CONFIG_PM_SLEEP
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
136 spinlock_t name_lock;
137 struct list_head fw_names;
139 struct delayed_work work;
141 struct notifier_block pm_notify;
145 struct firmware_buf {
147 struct list_head list;
148 struct completion completion;
149 struct firmware_cache *fwc;
150 unsigned long status;
153 size_t allocated_size;
154 #ifdef CONFIG_FW_LOADER_USER_HELPER
160 struct list_head pending_list;
165 struct fw_cache_entry {
166 struct list_head list;
170 struct fw_name_devm {
175 #define to_fwbuf(d) container_of(d, struct firmware_buf, ref)
177 #define FW_LOADER_NO_CACHE 0
178 #define FW_LOADER_START_CACHE 1
180 static int fw_cache_piggyback_on_request(const char *name);
182 /* 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 */
184 static DEFINE_MUTEX(fw_lock);
186 static struct firmware_cache fw_cache;
188 static struct firmware_buf *__allocate_fw_buf(const char *fw_name,
189 struct firmware_cache *fwc,
190 void *dbuf, size_t size)
192 struct firmware_buf *buf;
194 buf = kzalloc(sizeof(*buf), GFP_ATOMIC);
198 buf->fw_id = kstrdup_const(fw_name, GFP_ATOMIC);
204 kref_init(&buf->ref);
207 buf->allocated_size = size;
208 init_completion(&buf->completion);
209 #ifdef CONFIG_FW_LOADER_USER_HELPER
210 INIT_LIST_HEAD(&buf->pending_list);
213 pr_debug("%s: fw-%s buf=%p\n", __func__, fw_name, buf);
218 static struct firmware_buf *__fw_lookup_buf(const char *fw_name)
220 struct firmware_buf *tmp;
221 struct firmware_cache *fwc = &fw_cache;
223 list_for_each_entry(tmp, &fwc->head, list)
224 if (!strcmp(tmp->fw_id, fw_name))
229 static int fw_lookup_and_allocate_buf(const char *fw_name,
230 struct firmware_cache *fwc,
231 struct firmware_buf **buf, void *dbuf,
234 struct firmware_buf *tmp;
236 spin_lock(&fwc->lock);
237 tmp = __fw_lookup_buf(fw_name);
240 spin_unlock(&fwc->lock);
244 tmp = __allocate_fw_buf(fw_name, fwc, dbuf, size);
246 list_add(&tmp->list, &fwc->head);
247 spin_unlock(&fwc->lock);
251 return tmp ? 0 : -ENOMEM;
254 static void __fw_free_buf(struct kref *ref)
255 __releases(&fwc->lock)
257 struct firmware_buf *buf = to_fwbuf(ref);
258 struct firmware_cache *fwc = buf->fwc;
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);
264 list_del(&buf->list);
265 spin_unlock(&fwc->lock);
267 #ifdef CONFIG_FW_LOADER_USER_HELPER
268 if (buf->is_paged_buf) {
271 for (i = 0; i < buf->nr_pages; i++)
272 __free_page(buf->pages[i]);
276 if (!buf->allocated_size)
278 kfree_const(buf->fw_id);
282 static void fw_free_buf(struct firmware_buf *buf)
284 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);
290 /* direct firmware loading support */
291 static char fw_path_para[256];
292 static const char * const fw_path[] = {
294 "/lib/firmware/updates/" UTS_RELEASE,
295 "/lib/firmware/updates",
296 "/lib/firmware/" UTS_RELEASE,
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.
305 module_param_string(path, fw_path_para, sizeof(fw_path_para), 0644);
306 MODULE_PARM_DESC(path, "customized firmware image search path with a higher priority than default path");
308 static void fw_finish_direct_load(struct device *device,
309 struct firmware_buf *buf)
311 mutex_lock(&fw_lock);
312 set_bit(FW_STATUS_DONE, &buf->status);
313 complete_all(&buf->completion);
314 mutex_unlock(&fw_lock);
318 fw_get_filesystem_firmware(struct device *device, struct firmware_buf *buf)
324 enum kernel_read_file_id id = READING_FIRMWARE;
325 size_t msize = INT_MAX;
327 /* Already populated data member means we're loading into a buffer */
329 id = READING_FIRMWARE_PREALLOC_BUFFER;
330 msize = buf->allocated_size;
337 for (i = 0; i < ARRAY_SIZE(fw_path); i++) {
338 /* skip the unset customized path */
342 len = snprintf(path, PATH_MAX, "%s/%s",
343 fw_path[i], buf->fw_id);
344 if (len >= PATH_MAX) {
350 rc = kernel_read_file_from_path(path, &buf->data, &size, msize,
354 dev_dbg(device, "loading %s failed with error %d\n",
357 dev_warn(device, "loading %s failed with error %d\n",
361 dev_dbg(device, "direct-loading %s\n", buf->fw_id);
363 fw_finish_direct_load(device, buf);
371 /* firmware holds the ownership of pages */
372 static void firmware_free_data(const struct firmware *fw)
374 /* Loaded directly? */
379 fw_free_buf(fw->priv);
382 /* store the pages buffer info firmware from buf */
383 static void fw_set_page_data(struct firmware_buf *buf, struct firmware *fw)
386 #ifdef CONFIG_FW_LOADER_USER_HELPER
387 fw->pages = buf->pages;
389 fw->size = buf->size;
390 fw->data = buf->data;
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);
397 #ifdef CONFIG_PM_SLEEP
398 static void fw_name_devm_release(struct device *dev, void *res)
400 struct fw_name_devm *fwn = res;
402 if (fwn->magic == (unsigned long)&fw_cache)
403 pr_debug("%s: fw_name-%s devm-%p released\n",
404 __func__, fwn->name, res);
405 kfree_const(fwn->name);
408 static int fw_devm_match(struct device *dev, void *res,
411 struct fw_name_devm *fwn = res;
413 return (fwn->magic == (unsigned long)&fw_cache) &&
414 !strcmp(fwn->name, match_data);
417 static struct fw_name_devm *fw_find_devm_name(struct device *dev,
420 struct fw_name_devm *fwn;
422 fwn = devres_find(dev, fw_name_devm_release,
423 fw_devm_match, (void *)name);
427 /* add firmware name into devres list */
428 static int fw_add_devm_name(struct device *dev, const char *name)
430 struct fw_name_devm *fwn;
432 fwn = fw_find_devm_name(dev, name);
436 fwn = devres_alloc(fw_name_devm_release, sizeof(struct fw_name_devm),
440 fwn->name = kstrdup_const(name, GFP_KERNEL);
446 fwn->magic = (unsigned long)&fw_cache;
447 devres_add(dev, fwn);
452 static int fw_add_devm_name(struct device *dev, const char *name)
460 * user-mode helper code
462 #ifdef CONFIG_FW_LOADER_USER_HELPER
463 struct firmware_priv {
466 struct firmware_buf *buf;
470 static struct firmware_priv *to_firmware_priv(struct device *dev)
472 return container_of(dev, struct firmware_priv, dev);
475 static void __fw_load_abort(struct firmware_buf *buf)
478 * There is a small window in which user can write to 'loading'
479 * between loading done and disappearance of 'loading'
481 if (test_bit(FW_STATUS_DONE, &buf->status))
484 list_del_init(&buf->pending_list);
485 set_bit(FW_STATUS_ABORT, &buf->status);
486 complete_all(&buf->completion);
489 static void fw_load_abort(struct firmware_priv *fw_priv)
491 struct firmware_buf *buf = fw_priv->buf;
493 __fw_load_abort(buf);
495 /* avoid user action after loading abort */
499 #define is_fw_load_aborted(buf) \
500 test_bit(FW_STATUS_ABORT, &(buf)->status)
502 static LIST_HEAD(pending_fw_head);
504 /* reboot notifier for avoid deadlock with usermode_lock */
505 static int fw_shutdown_notify(struct notifier_block *unused1,
506 unsigned long unused2, void *unused3)
508 mutex_lock(&fw_lock);
509 while (!list_empty(&pending_fw_head))
510 __fw_load_abort(list_first_entry(&pending_fw_head,
513 mutex_unlock(&fw_lock);
517 static struct notifier_block fw_shutdown_nb = {
518 .notifier_call = fw_shutdown_notify,
521 static ssize_t timeout_show(struct class *class, struct class_attribute *attr,
524 return sprintf(buf, "%d\n", loading_timeout);
528 * firmware_timeout_store - set number of seconds to wait for firmware
529 * @class: device class pointer
530 * @attr: device attribute pointer
531 * @buf: buffer to scan for timeout value
532 * @count: number of bytes in @buf
534 * Sets the number of seconds to wait for the firmware. Once
535 * this expires an error will be returned to the driver and no
536 * firmware will be provided.
538 * Note: zero means 'wait forever'.
540 static ssize_t timeout_store(struct class *class, struct class_attribute *attr,
541 const char *buf, size_t count)
543 loading_timeout = simple_strtol(buf, NULL, 10);
544 if (loading_timeout < 0)
550 static struct class_attribute firmware_class_attrs[] = {
555 static void fw_dev_release(struct device *dev)
557 struct firmware_priv *fw_priv = to_firmware_priv(dev);
562 static int do_firmware_uevent(struct firmware_priv *fw_priv, struct kobj_uevent_env *env)
564 if (add_uevent_var(env, "FIRMWARE=%s", fw_priv->buf->fw_id))
566 if (add_uevent_var(env, "TIMEOUT=%i", loading_timeout))
568 if (add_uevent_var(env, "ASYNC=%d", fw_priv->nowait))
574 static int firmware_uevent(struct device *dev, struct kobj_uevent_env *env)
576 struct firmware_priv *fw_priv = to_firmware_priv(dev);
579 mutex_lock(&fw_lock);
581 err = do_firmware_uevent(fw_priv, env);
582 mutex_unlock(&fw_lock);
586 static struct class firmware_class = {
588 .class_attrs = firmware_class_attrs,
589 .dev_uevent = firmware_uevent,
590 .dev_release = fw_dev_release,
593 static ssize_t firmware_loading_show(struct device *dev,
594 struct device_attribute *attr, char *buf)
596 struct firmware_priv *fw_priv = to_firmware_priv(dev);
599 mutex_lock(&fw_lock);
601 loading = test_bit(FW_STATUS_LOADING, &fw_priv->buf->status);
602 mutex_unlock(&fw_lock);
604 return sprintf(buf, "%d\n", loading);
607 /* Some architectures don't have PAGE_KERNEL_RO */
608 #ifndef PAGE_KERNEL_RO
609 #define PAGE_KERNEL_RO PAGE_KERNEL
612 /* one pages buffer should be mapped/unmapped only once */
613 static int fw_map_pages_buf(struct firmware_buf *buf)
615 if (!buf->is_paged_buf)
619 buf->data = vmap(buf->pages, buf->nr_pages, 0, PAGE_KERNEL_RO);
626 * firmware_loading_store - set value in the 'loading' control file
627 * @dev: device pointer
628 * @attr: device attribute pointer
629 * @buf: buffer to scan for loading control value
630 * @count: number of bytes in @buf
632 * The relevant values are:
634 * 1: Start a load, discarding any previous partial load.
635 * 0: Conclude the load and hand the data to the driver code.
636 * -1: Conclude the load with an error and discard any written data.
638 static ssize_t firmware_loading_store(struct device *dev,
639 struct device_attribute *attr,
640 const char *buf, size_t count)
642 struct firmware_priv *fw_priv = to_firmware_priv(dev);
643 struct firmware_buf *fw_buf;
644 ssize_t written = count;
645 int loading = simple_strtol(buf, NULL, 10);
648 mutex_lock(&fw_lock);
649 fw_buf = fw_priv->buf;
655 /* discarding any previous partial load */
656 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]);
659 vfree(fw_buf->pages);
660 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);
667 if (test_bit(FW_STATUS_LOADING, &fw_buf->status)) {
670 set_bit(FW_STATUS_DONE, &fw_buf->status);
671 clear_bit(FW_STATUS_LOADING, &fw_buf->status);
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
679 rc = fw_map_pages_buf(fw_buf);
681 dev_err(dev, "%s: map pages failed\n",
684 rc = security_kernel_post_read_file(NULL,
685 fw_buf->data, fw_buf->size,
689 * Same logic as fw_load_abort, only the DONE bit
690 * is ignored and we set ABORT only on failure.
692 list_del_init(&fw_buf->pending_list);
694 set_bit(FW_STATUS_ABORT, &fw_buf->status);
697 complete_all(&fw_buf->completion);
702 dev_err(dev, "%s: unexpected value (%d)\n", __func__, loading);
705 fw_load_abort(fw_priv);
709 mutex_unlock(&fw_lock);
713 static DEVICE_ATTR(loading, 0644, firmware_loading_show, firmware_loading_store);
715 static void firmware_rw_buf(struct firmware_buf *buf, char *buffer,
716 loff_t offset, size_t count, bool read)
719 memcpy(buffer, buf->data + offset, count);
721 memcpy(buf->data + offset, buffer, count);
724 static void firmware_rw(struct firmware_buf *buf, char *buffer,
725 loff_t offset, size_t count, bool read)
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);
733 page_data = kmap(buf->pages[page_nr]);
736 memcpy(buffer, page_data + page_ofs, page_cnt);
738 memcpy(page_data + page_ofs, buffer, page_cnt);
740 kunmap(buf->pages[page_nr]);
747 static 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)
751 struct device *dev = kobj_to_dev(kobj);
752 struct firmware_priv *fw_priv = to_firmware_priv(dev);
753 struct firmware_buf *buf;
756 mutex_lock(&fw_lock);
758 if (!buf || test_bit(FW_STATUS_DONE, &buf->status)) {
762 if (offset > buf->size) {
766 if (count > buf->size - offset)
767 count = buf->size - offset;
772 firmware_rw_buf(buf, buffer, offset, count, true);
774 firmware_rw(buf, buffer, offset, count, true);
777 mutex_unlock(&fw_lock);
781 static int fw_realloc_buffer(struct firmware_priv *fw_priv, int min_size)
783 struct firmware_buf *buf = fw_priv->buf;
784 int pages_needed = PAGE_ALIGN(min_size) >> PAGE_SHIFT;
786 /* If the array of pages is too small, grow it... */
787 if (buf->page_array_size < pages_needed) {
788 int new_array_size = max(pages_needed,
789 buf->page_array_size * 2);
790 struct page **new_pages;
792 new_pages = vmalloc(new_array_size * sizeof(void *));
794 fw_load_abort(fw_priv);
797 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));
802 buf->pages = new_pages;
803 buf->page_array_size = new_array_size;
806 while (buf->nr_pages < pages_needed) {
807 buf->pages[buf->nr_pages] =
808 alloc_page(GFP_KERNEL | __GFP_HIGHMEM);
810 if (!buf->pages[buf->nr_pages]) {
811 fw_load_abort(fw_priv);
820 * firmware_data_write - write method for firmware
821 * @filp: open sysfs file
822 * @kobj: kobject for the device
823 * @bin_attr: bin_attr structure
824 * @buffer: buffer being written
825 * @offset: buffer offset for write in total data store area
826 * @count: buffer size
828 * Data written to the 'data' attribute will be later handed to
829 * the driver as a firmware image.
831 static 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)
835 struct device *dev = kobj_to_dev(kobj);
836 struct firmware_priv *fw_priv = to_firmware_priv(dev);
837 struct firmware_buf *buf;
840 if (!capable(CAP_SYS_RAWIO))
843 mutex_lock(&fw_lock);
845 if (!buf || test_bit(FW_STATUS_DONE, &buf->status)) {
851 if (offset + count > buf->allocated_size) {
855 firmware_rw_buf(buf, buffer, offset, count, false);
858 retval = fw_realloc_buffer(fw_priv, offset + count);
863 firmware_rw(buf, buffer, offset, count, false);
866 buf->size = max_t(size_t, offset + count, buf->size);
868 mutex_unlock(&fw_lock);
872 static struct bin_attribute firmware_attr_data = {
873 .attr = { .name = "data", .mode = 0644 },
875 .read = firmware_data_read,
876 .write = firmware_data_write,
879 static struct attribute *fw_dev_attrs[] = {
880 &dev_attr_loading.attr,
884 static struct bin_attribute *fw_dev_bin_attrs[] = {
889 static const struct attribute_group fw_dev_attr_group = {
890 .attrs = fw_dev_attrs,
891 .bin_attrs = fw_dev_bin_attrs,
894 static const struct attribute_group *fw_dev_attr_groups[] = {
899 static struct firmware_priv *
900 fw_create_instance(struct firmware *firmware, const char *fw_name,
901 struct device *device, unsigned int opt_flags)
903 struct firmware_priv *fw_priv;
904 struct device *f_dev;
906 fw_priv = kzalloc(sizeof(*fw_priv), GFP_KERNEL);
908 fw_priv = ERR_PTR(-ENOMEM);
912 fw_priv->nowait = !!(opt_flags & FW_OPT_NOWAIT);
913 fw_priv->fw = firmware;
914 f_dev = &fw_priv->dev;
916 device_initialize(f_dev);
917 dev_set_name(f_dev, "%s", fw_name);
918 f_dev->parent = device;
919 f_dev->class = &firmware_class;
920 f_dev->groups = fw_dev_attr_groups;
925 /* load a firmware via user helper */
926 static int _request_firmware_load(struct firmware_priv *fw_priv,
927 unsigned int opt_flags, long timeout)
930 struct device *f_dev = &fw_priv->dev;
931 struct firmware_buf *buf = fw_priv->buf;
933 /* fall back on userspace loading */
935 buf->is_paged_buf = true;
937 dev_set_uevent_suppress(f_dev, true);
939 retval = device_add(f_dev);
941 dev_err(f_dev, "%s: device_register failed\n", __func__);
945 mutex_lock(&fw_lock);
946 list_add(&buf->pending_list, &pending_fw_head);
947 mutex_unlock(&fw_lock);
949 if (opt_flags & FW_OPT_UEVENT) {
950 buf->need_uevent = true;
951 dev_set_uevent_suppress(f_dev, false);
952 dev_dbg(f_dev, "firmware: requesting %s\n", buf->fw_id);
953 kobject_uevent(&fw_priv->dev.kobj, KOBJ_ADD);
955 timeout = MAX_JIFFY_OFFSET;
958 retval = wait_for_completion_interruptible_timeout(&buf->completion,
960 if (retval == -ERESTARTSYS || !retval) {
961 mutex_lock(&fw_lock);
962 fw_load_abort(fw_priv);
963 mutex_unlock(&fw_lock);
964 } else if (retval > 0) {
968 if (is_fw_load_aborted(buf))
970 else if (buf->is_paged_buf && !buf->data)
979 static int fw_load_from_user_helper(struct firmware *firmware,
980 const char *name, struct device *device,
981 unsigned int opt_flags, long timeout)
983 struct firmware_priv *fw_priv;
985 fw_priv = fw_create_instance(firmware, name, device, opt_flags);
987 return PTR_ERR(fw_priv);
989 fw_priv->buf = firmware->priv;
990 return _request_firmware_load(fw_priv, opt_flags, timeout);
993 #ifdef CONFIG_PM_SLEEP
994 /* kill pending requests without uevent to avoid blocking suspend */
995 static void kill_requests_without_uevent(void)
997 struct firmware_buf *buf;
998 struct firmware_buf *next;
1000 mutex_lock(&fw_lock);
1001 list_for_each_entry_safe(buf, next, &pending_fw_head, pending_list) {
1002 if (!buf->need_uevent)
1003 __fw_load_abort(buf);
1005 mutex_unlock(&fw_lock);
1009 #else /* CONFIG_FW_LOADER_USER_HELPER */
1011 fw_load_from_user_helper(struct firmware *firmware, const char *name,
1012 struct device *device, unsigned int opt_flags,
1018 /* No abort during direct loading */
1019 #define is_fw_load_aborted(buf) false
1021 #ifdef CONFIG_PM_SLEEP
1022 static inline void kill_requests_without_uevent(void) { }
1025 #endif /* CONFIG_FW_LOADER_USER_HELPER */
1028 /* wait until the shared firmware_buf becomes ready (or error) */
1029 static int sync_cached_firmware_buf(struct firmware_buf *buf)
1033 mutex_lock(&fw_lock);
1034 while (!test_bit(FW_STATUS_DONE, &buf->status)) {
1035 if (is_fw_load_aborted(buf)) {
1039 mutex_unlock(&fw_lock);
1040 ret = wait_for_completion_interruptible(&buf->completion);
1041 mutex_lock(&fw_lock);
1043 mutex_unlock(&fw_lock);
1047 /* 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
1052 _request_firmware_prepare(struct firmware **firmware_p, const char *name,
1053 struct device *device, void *dbuf, size_t size)
1055 struct firmware *firmware;
1056 struct firmware_buf *buf;
1059 *firmware_p = firmware = kzalloc(sizeof(*firmware), GFP_KERNEL);
1061 dev_err(device, "%s: kmalloc(struct firmware) failed\n",
1066 if (fw_get_builtin_firmware(firmware, name, dbuf, size)) {
1067 dev_dbg(device, "using built-in %s\n", name);
1068 return 0; /* assigned */
1071 ret = fw_lookup_and_allocate_buf(name, &fw_cache, &buf, dbuf, size);
1074 * bind with 'buf' now to avoid warning in failure path
1075 * of requesting firmware.
1077 firmware->priv = buf;
1080 ret = sync_cached_firmware_buf(buf);
1082 fw_set_page_data(buf, firmware);
1083 return 0; /* assigned */
1089 return 1; /* need to load */
1092 static int assign_firmware_buf(struct firmware *fw, struct device *device,
1093 unsigned int opt_flags)
1095 struct firmware_buf *buf = fw->priv;
1097 mutex_lock(&fw_lock);
1098 if (!buf->size || is_fw_load_aborted(buf)) {
1099 mutex_unlock(&fw_lock);
1104 * add firmware name into devres list so that we can auto cache
1105 * and uncache firmware for device.
1107 * device may has been deleted already, but the problem
1108 * should be fixed in devres or driver core.
1110 /* don't cache firmware handled without uevent */
1111 if (device && (opt_flags & FW_OPT_UEVENT) &&
1112 !(opt_flags & FW_OPT_NOCACHE))
1113 fw_add_devm_name(device, buf->fw_id);
1116 * After caching firmware image is started, let it piggyback
1117 * on request firmware.
1119 if (!(opt_flags & FW_OPT_NOCACHE) &&
1120 buf->fwc->state == FW_LOADER_START_CACHE) {
1121 if (fw_cache_piggyback_on_request(buf->fw_id))
1122 kref_get(&buf->ref);
1125 /* pass the pages buffer to driver at the last minute */
1126 fw_set_page_data(buf, fw);
1127 mutex_unlock(&fw_lock);
1131 /* called from request_firmware() and request_firmware_work_func() */
1133 _request_firmware(const struct firmware **firmware_p, const char *name,
1134 struct device *device, void *buf, size_t size,
1135 unsigned int opt_flags)
1137 struct firmware *fw = NULL;
1144 if (!name || name[0] == '\0') {
1149 ret = _request_firmware_prepare(&fw, name, device, buf, size);
1150 if (ret <= 0) /* error or already assigned */
1154 timeout = firmware_loading_timeout();
1155 if (opt_flags & FW_OPT_NOWAIT) {
1156 timeout = usermodehelper_read_lock_wait(timeout);
1158 dev_dbg(device, "firmware: %s loading timed out\n",
1164 ret = usermodehelper_read_trylock();
1166 dev_err(device, "firmware: %s will not be loaded\n",
1172 ret = fw_get_filesystem_firmware(device, fw->priv);
1174 if (!(opt_flags & FW_OPT_NO_WARN))
1176 "Direct firmware load for %s failed with error %d\n",
1178 if (opt_flags & FW_OPT_USERHELPER) {
1179 dev_warn(device, "Falling back to user helper\n");
1180 ret = fw_load_from_user_helper(fw, name, device,
1181 opt_flags, timeout);
1186 ret = assign_firmware_buf(fw, device, opt_flags);
1188 usermodehelper_read_unlock();
1192 release_firmware(fw);
1201 * request_firmware: - send firmware request and wait for it
1202 * @firmware_p: pointer to firmware image
1203 * @name: name of firmware file
1204 * @device: device for which firmware is being loaded
1206 * @firmware_p will be used to return a firmware image by the name
1207 * of @name for device @device.
1209 * Should be called from user context where sleeping is allowed.
1211 * @name will be used as $FIRMWARE in the uevent environment and
1212 * should be distinctive enough not to be confused with any other
1213 * firmware image for this or any other device.
1215 * Caller must hold the reference count of @device.
1217 * The function can be called safely inside device's suspend and
1221 request_firmware(const struct firmware **firmware_p, const char *name,
1222 struct device *device)
1226 /* Need to pin this module until return */
1227 __module_get(THIS_MODULE);
1228 ret = _request_firmware(firmware_p, name, device, NULL, 0,
1229 FW_OPT_UEVENT | FW_OPT_FALLBACK);
1230 module_put(THIS_MODULE);
1233 EXPORT_SYMBOL(request_firmware);
1236 * request_firmware_direct: - load firmware directly without usermode helper
1237 * @firmware_p: pointer to firmware image
1238 * @name: name of firmware file
1239 * @device: device for which firmware is being loaded
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.
1246 int request_firmware_direct(const struct firmware **firmware_p,
1247 const char *name, struct device *device)
1251 __module_get(THIS_MODULE);
1252 ret = _request_firmware(firmware_p, name, device, NULL, 0,
1253 FW_OPT_UEVENT | FW_OPT_NO_WARN);
1254 module_put(THIS_MODULE);
1257 EXPORT_SYMBOL_GPL(request_firmware_direct);
1260 * 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
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.
1272 * This function doesn't cache firmware either.
1275 request_firmware_into_buf(const struct firmware **firmware_p, const char *name,
1276 struct device *device, void *buf, size_t size)
1280 __module_get(THIS_MODULE);
1281 ret = _request_firmware(firmware_p, name, device, buf, size,
1282 FW_OPT_UEVENT | FW_OPT_FALLBACK |
1284 module_put(THIS_MODULE);
1287 EXPORT_SYMBOL(request_firmware_into_buf);
1290 * release_firmware: - release the resource associated with a firmware image
1291 * @fw: firmware resource to release
1293 void release_firmware(const struct firmware *fw)
1296 if (!fw_is_builtin_firmware(fw))
1297 firmware_free_data(fw);
1301 EXPORT_SYMBOL(release_firmware);
1304 struct firmware_work {
1305 struct work_struct work;
1306 struct module *module;
1308 struct device *device;
1310 void (*cont)(const struct firmware *fw, void *context);
1311 unsigned int opt_flags;
1314 static void request_firmware_work_func(struct work_struct *work)
1316 struct firmware_work *fw_work;
1317 const struct firmware *fw;
1319 fw_work = container_of(work, struct firmware_work, work);
1321 _request_firmware(&fw, fw_work->name, fw_work->device, NULL, 0,
1322 fw_work->opt_flags);
1323 fw_work->cont(fw, fw_work->context);
1324 put_device(fw_work->device); /* taken in request_firmware_nowait() */
1326 module_put(fw_work->module);
1327 kfree_const(fw_work->name);
1332 * request_firmware_nowait - asynchronous version of request_firmware
1333 * @module: module requesting the firmware
1334 * @uevent: sends uevent to copy the firmware image if this flag
1335 * 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
1338 * @gfp: allocation flags
1339 * @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
1344 * Caller must hold the reference count of @device.
1346 * 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.
1352 * - can't sleep at all if @gfp is GFP_ATOMIC.
1355 request_firmware_nowait(
1356 struct module *module, bool uevent,
1357 const char *name, struct device *device, gfp_t gfp, void *context,
1358 void (*cont)(const struct firmware *fw, void *context))
1360 struct firmware_work *fw_work;
1362 fw_work = kzalloc(sizeof(struct firmware_work), gfp);
1366 fw_work->module = module;
1367 fw_work->name = kstrdup_const(name, gfp);
1368 if (!fw_work->name) {
1372 fw_work->device = device;
1373 fw_work->context = context;
1374 fw_work->cont = cont;
1375 fw_work->opt_flags = FW_OPT_NOWAIT | FW_OPT_FALLBACK |
1376 (uevent ? FW_OPT_UEVENT : FW_OPT_USERHELPER);
1378 if (!try_module_get(module)) {
1379 kfree_const(fw_work->name);
1384 get_device(fw_work->device);
1385 INIT_WORK(&fw_work->work, request_firmware_work_func);
1386 schedule_work(&fw_work->work);
1389 EXPORT_SYMBOL(request_firmware_nowait);
1391 #ifdef CONFIG_PM_SLEEP
1392 static ASYNC_DOMAIN_EXCLUSIVE(fw_cache_domain);
1395 * cache_firmware - cache one firmware image in kernel memory space
1396 * @fw_name: the firmware image name
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
1404 * Return 0 if the firmware image has been cached successfully
1405 * Return !0 otherwise
1408 static int cache_firmware(const char *fw_name)
1411 const struct firmware *fw;
1413 pr_debug("%s: %s\n", __func__, fw_name);
1415 ret = request_firmware(&fw, fw_name, NULL);
1419 pr_debug("%s: %s ret=%d\n", __func__, fw_name, ret);
1424 static struct firmware_buf *fw_lookup_buf(const char *fw_name)
1426 struct firmware_buf *tmp;
1427 struct firmware_cache *fwc = &fw_cache;
1429 spin_lock(&fwc->lock);
1430 tmp = __fw_lookup_buf(fw_name);
1431 spin_unlock(&fwc->lock);
1437 * uncache_firmware - remove one cached firmware image
1438 * @fw_name: the firmware image name
1440 * Uncache one firmware image which has been cached successfully
1443 * Return 0 if the firmware cache has been removed successfully
1444 * Return !0 otherwise
1447 static int uncache_firmware(const char *fw_name)
1449 struct firmware_buf *buf;
1452 pr_debug("%s: %s\n", __func__, fw_name);
1454 if (fw_get_builtin_firmware(&fw, fw_name, NULL, 0))
1457 buf = fw_lookup_buf(fw_name);
1466 static struct fw_cache_entry *alloc_fw_cache_entry(const char *name)
1468 struct fw_cache_entry *fce;
1470 fce = kzalloc(sizeof(*fce), GFP_ATOMIC);
1474 fce->name = kstrdup_const(name, GFP_ATOMIC);
1484 static int __fw_entry_found(const char *name)
1486 struct firmware_cache *fwc = &fw_cache;
1487 struct fw_cache_entry *fce;
1489 list_for_each_entry(fce, &fwc->fw_names, list) {
1490 if (!strcmp(fce->name, name))
1496 static int fw_cache_piggyback_on_request(const char *name)
1498 struct firmware_cache *fwc = &fw_cache;
1499 struct fw_cache_entry *fce;
1502 spin_lock(&fwc->name_lock);
1503 if (__fw_entry_found(name))
1506 fce = alloc_fw_cache_entry(name);
1509 list_add(&fce->list, &fwc->fw_names);
1510 pr_debug("%s: fw: %s\n", __func__, name);
1513 spin_unlock(&fwc->name_lock);
1517 static void free_fw_cache_entry(struct fw_cache_entry *fce)
1519 kfree_const(fce->name);
1523 static void __async_dev_cache_fw_image(void *fw_entry,
1524 async_cookie_t cookie)
1526 struct fw_cache_entry *fce = fw_entry;
1527 struct firmware_cache *fwc = &fw_cache;
1530 ret = cache_firmware(fce->name);
1532 spin_lock(&fwc->name_lock);
1533 list_del(&fce->list);
1534 spin_unlock(&fwc->name_lock);
1536 free_fw_cache_entry(fce);
1540 /* called with dev->devres_lock held */
1541 static void dev_create_fw_entry(struct device *dev, void *res,
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;
1549 fce = alloc_fw_cache_entry(fw_name);
1551 list_add(&fce->list, head);
1554 static int devm_name_match(struct device *dev, void *res,
1557 struct fw_name_devm *fwn = res;
1558 return (fwn->magic == (unsigned long)match_data);
1561 static void dev_cache_fw_image(struct device *dev, void *data)
1564 struct fw_cache_entry *fce;
1565 struct fw_cache_entry *fce_next;
1566 struct firmware_cache *fwc = &fw_cache;
1568 devres_for_each_res(dev, fw_name_devm_release,
1569 devm_name_match, &fw_cache,
1570 dev_create_fw_entry, &todo);
1572 list_for_each_entry_safe(fce, fce_next, &todo, list) {
1573 list_del(&fce->list);
1575 spin_lock(&fwc->name_lock);
1576 /* only one cache entry for one firmware */
1577 if (!__fw_entry_found(fce->name)) {
1578 list_add(&fce->list, &fwc->fw_names);
1580 free_fw_cache_entry(fce);
1583 spin_unlock(&fwc->name_lock);
1586 async_schedule_domain(__async_dev_cache_fw_image,
1592 static void __device_uncache_fw_images(void)
1594 struct firmware_cache *fwc = &fw_cache;
1595 struct fw_cache_entry *fce;
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);
1604 uncache_firmware(fce->name);
1605 free_fw_cache_entry(fce);
1607 spin_lock(&fwc->name_lock);
1609 spin_unlock(&fwc->name_lock);
1613 * device_cache_fw_images - cache devices' firmware
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.
1622 static void device_cache_fw_images(void)
1624 struct firmware_cache *fwc = &fw_cache;
1628 pr_debug("%s\n", __func__);
1630 /* cancel uncache work */
1631 cancel_delayed_work_sync(&fwc->work);
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.
1641 old_timeout = loading_timeout;
1642 loading_timeout = 10;
1644 mutex_lock(&fw_lock);
1645 fwc->state = FW_LOADER_START_CACHE;
1646 dpm_for_each_dev(NULL, dev_cache_fw_image);
1647 mutex_unlock(&fw_lock);
1649 /* wait for completion of caching firmware for all devices */
1650 async_synchronize_full_domain(&fw_cache_domain);
1652 loading_timeout = old_timeout;
1656 * device_uncache_fw_images - uncache devices' firmware
1658 * uncache all firmwares which have been cached successfully
1659 * by device_uncache_fw_images earlier
1661 static void device_uncache_fw_images(void)
1663 pr_debug("%s\n", __func__);
1664 __device_uncache_fw_images();
1667 static void device_uncache_fw_images_work(struct work_struct *work)
1669 device_uncache_fw_images();
1673 * device_uncache_fw_images_delay - uncache devices firmwares
1674 * @delay: number of milliseconds to delay uncache device firmwares
1676 * uncache all devices's firmwares which has been cached successfully
1677 * by device_cache_fw_images after @delay milliseconds.
1679 static void device_uncache_fw_images_delay(unsigned long delay)
1681 queue_delayed_work(system_power_efficient_wq, &fw_cache.work,
1682 msecs_to_jiffies(delay));
1685 static int fw_pm_notify(struct notifier_block *notify_block,
1686 unsigned long mode, void *unused)
1689 case PM_HIBERNATION_PREPARE:
1690 case PM_SUSPEND_PREPARE:
1691 case PM_RESTORE_PREPARE:
1692 kill_requests_without_uevent();
1693 device_cache_fw_images();
1696 case PM_POST_SUSPEND:
1697 case PM_POST_HIBERNATION:
1698 case PM_POST_RESTORE:
1700 * In case that system sleep failed and syscore_suspend is
1703 mutex_lock(&fw_lock);
1704 fw_cache.state = FW_LOADER_NO_CACHE;
1705 mutex_unlock(&fw_lock);
1707 device_uncache_fw_images_delay(10 * MSEC_PER_SEC);
1714 /* stop caching firmware once syscore_suspend is reached */
1715 static int fw_suspend(void)
1717 fw_cache.state = FW_LOADER_NO_CACHE;
1721 static struct syscore_ops fw_syscore_ops = {
1722 .suspend = fw_suspend,
1725 static int fw_cache_piggyback_on_request(const char *name)
1731 static void __init fw_cache_init(void)
1733 spin_lock_init(&fw_cache.lock);
1734 INIT_LIST_HEAD(&fw_cache.head);
1735 fw_cache.state = FW_LOADER_NO_CACHE;
1737 #ifdef CONFIG_PM_SLEEP
1738 spin_lock_init(&fw_cache.name_lock);
1739 INIT_LIST_HEAD(&fw_cache.fw_names);
1741 INIT_DELAYED_WORK(&fw_cache.work,
1742 device_uncache_fw_images_work);
1744 fw_cache.pm_notify.notifier_call = fw_pm_notify;
1745 register_pm_notifier(&fw_cache.pm_notify);
1747 register_syscore_ops(&fw_syscore_ops);
1751 static int __init firmware_class_init(void)
1754 #ifdef CONFIG_FW_LOADER_USER_HELPER
1755 register_reboot_notifier(&fw_shutdown_nb);
1756 return class_register(&firmware_class);
1762 static void __exit firmware_class_exit(void)
1764 #ifdef CONFIG_PM_SLEEP
1765 unregister_syscore_ops(&fw_syscore_ops);
1766 unregister_pm_notifier(&fw_cache.pm_notify);
1768 #ifdef CONFIG_FW_LOADER_USER_HELPER
1769 unregister_reboot_notifier(&fw_shutdown_nb);
1770 class_unregister(&firmware_class);
1774 fs_initcall(firmware_class_init);
1775 module_exit(firmware_class_exit);