Lines Matching +full:firmware +full:- +full:name
1 // SPDX-License-Identifier: GPL-2.0
3 * main.c - Multi purpose firmware loading support
24 #include <linux/firmware.h>
40 #include "firmware.h"
44 MODULE_DESCRIPTION("Multi purpose firmware loading support");
55 * Names of firmware images which have been cached successfully
57 * helper can trace which firmware images have been cached
71 const char *name; member
76 const char *name; member
93 /* Builtin firmware support */
100 static void fw_copy_to_prealloc_buf(struct firmware *fw, in fw_copy_to_prealloc_buf()
103 if (!buf || size < fw->size) in fw_copy_to_prealloc_buf()
105 memcpy(buf, fw->data, fw->size); in fw_copy_to_prealloc_buf()
108 static bool fw_get_builtin_firmware(struct firmware *fw, const char *name, in fw_get_builtin_firmware() argument
114 if (strcmp(name, b_fw->name) == 0) { in fw_get_builtin_firmware()
115 fw->size = b_fw->size; in fw_get_builtin_firmware()
116 fw->data = b_fw->data; in fw_get_builtin_firmware()
126 static bool fw_is_builtin_firmware(const struct firmware *fw) in fw_is_builtin_firmware()
131 if (fw->data == b_fw->data) in fw_is_builtin_firmware()
137 #else /* Module case - no builtin firmware support */
139 static inline bool fw_get_builtin_firmware(struct firmware *fw, in fw_get_builtin_firmware()
140 const char *name, void *buf, in fw_get_builtin_firmware() argument
146 static inline bool fw_is_builtin_firmware(const struct firmware *fw) in fw_is_builtin_firmware()
154 struct fw_state *fw_st = &fw_priv->fw_st; in fw_state_init()
156 init_completion(&fw_st->completion); in fw_state_init()
157 fw_st->status = FW_STATUS_UNKNOWN; in fw_state_init()
165 static int fw_cache_piggyback_on_request(const char *name);
177 fw_priv->fw_name = kstrdup_const(fw_name, GFP_ATOMIC); in __allocate_fw_priv()
178 if (!fw_priv->fw_name) { in __allocate_fw_priv()
183 kref_init(&fw_priv->ref); in __allocate_fw_priv()
184 fw_priv->fwc = fwc; in __allocate_fw_priv()
185 fw_priv->data = dbuf; in __allocate_fw_priv()
186 fw_priv->allocated_size = size; in __allocate_fw_priv()
189 INIT_LIST_HEAD(&fw_priv->pending_list); in __allocate_fw_priv()
192 pr_debug("%s: fw-%s fw_priv=%p\n", __func__, fw_name, fw_priv); in __allocate_fw_priv()
202 list_for_each_entry(tmp, &fwc->head, list) in __lookup_fw_priv()
203 if (!strcmp(tmp->fw_name, fw_name)) in __lookup_fw_priv()
208 /* Returns 1 for batching firmware requests with the same name */
216 spin_lock(&fwc->lock); in alloc_lookup_fw_priv()
220 kref_get(&tmp->ref); in alloc_lookup_fw_priv()
221 spin_unlock(&fwc->lock); in alloc_lookup_fw_priv()
223 pr_debug("batched request - sharing the same struct fw_priv and lookup for multiple requests\n"); in alloc_lookup_fw_priv()
230 INIT_LIST_HEAD(&tmp->list); in alloc_lookup_fw_priv()
232 list_add(&tmp->list, &fwc->head); in alloc_lookup_fw_priv()
234 spin_unlock(&fwc->lock); in alloc_lookup_fw_priv()
238 return tmp ? 0 : -ENOMEM; in alloc_lookup_fw_priv()
242 __releases(&fwc->lock) in __free_fw_priv()
245 struct firmware_cache *fwc = fw_priv->fwc; in __free_fw_priv()
247 pr_debug("%s: fw-%s fw_priv=%p data=%p size=%u\n", in __free_fw_priv()
248 __func__, fw_priv->fw_name, fw_priv, fw_priv->data, in __free_fw_priv()
249 (unsigned int)fw_priv->size); in __free_fw_priv()
251 list_del(&fw_priv->list); in __free_fw_priv()
252 spin_unlock(&fwc->lock); in __free_fw_priv()
255 if (fw_priv->is_paged_buf) { in __free_fw_priv()
257 vunmap(fw_priv->data); in __free_fw_priv()
258 for (i = 0; i < fw_priv->nr_pages; i++) in __free_fw_priv()
259 __free_page(fw_priv->pages[i]); in __free_fw_priv()
260 vfree(fw_priv->pages); in __free_fw_priv()
263 if (!fw_priv->allocated_size) in __free_fw_priv()
264 vfree(fw_priv->data); in __free_fw_priv()
265 kfree_const(fw_priv->fw_name); in __free_fw_priv()
271 struct firmware_cache *fwc = fw_priv->fwc; in free_fw_priv()
272 spin_lock(&fwc->lock); in free_fw_priv()
273 if (!kref_put(&fw_priv->ref, __free_fw_priv)) in free_fw_priv()
274 spin_unlock(&fwc->lock); in free_fw_priv()
277 /* direct firmware loading support */
281 "/lib/firmware/updates/" UTS_RELEASE,
282 "/lib/firmware/updates",
283 "/lib/firmware/" UTS_RELEASE,
284 "/lib/firmware"
293 MODULE_PARM_DESC(path, "customized firmware image search path with a higher priority than default p…
300 int rc = -ENOENT; in fw_get_filesystem_firmware()
306 if (fw_priv->data) { in fw_get_filesystem_firmware()
308 msize = fw_priv->allocated_size; in fw_get_filesystem_firmware()
313 return -ENOMEM; in fw_get_filesystem_firmware()
321 fw_path[i], fw_priv->fw_name); in fw_get_filesystem_firmware()
323 rc = -ENAMETOOLONG; in fw_get_filesystem_firmware()
327 fw_priv->size = 0; in fw_get_filesystem_firmware()
328 rc = kernel_read_file_from_path(path, &fw_priv->data, &size, in fw_get_filesystem_firmware()
331 if (rc == -ENOENT) in fw_get_filesystem_firmware()
339 dev_dbg(device, "direct-loading %s\n", fw_priv->fw_name); in fw_get_filesystem_firmware()
340 fw_priv->size = size; in fw_get_filesystem_firmware()
349 /* firmware holds the ownership of pages */
350 static void firmware_free_data(const struct firmware *fw) in firmware_free_data()
353 if (!fw->priv) { in firmware_free_data()
354 vfree(fw->data); in firmware_free_data()
357 free_fw_priv(fw->priv); in firmware_free_data()
360 /* store the pages buffer info firmware from buf */
361 static void fw_set_page_data(struct fw_priv *fw_priv, struct firmware *fw) in fw_set_page_data()
363 fw->priv = fw_priv; in fw_set_page_data()
365 fw->pages = fw_priv->pages; in fw_set_page_data()
367 fw->size = fw_priv->size; in fw_set_page_data()
368 fw->data = fw_priv->data; in fw_set_page_data()
370 pr_debug("%s: fw-%s fw_priv=%p data=%p size=%u\n", in fw_set_page_data()
371 __func__, fw_priv->fw_name, fw_priv, fw_priv->data, in fw_set_page_data()
372 (unsigned int)fw_priv->size); in fw_set_page_data()
380 if (fwn->magic == (unsigned long)&fw_cache) in fw_name_devm_release()
381 pr_debug("%s: fw_name-%s devm-%p released\n", in fw_name_devm_release()
382 __func__, fwn->name, res); in fw_name_devm_release()
383 kfree_const(fwn->name); in fw_name_devm_release()
391 return (fwn->magic == (unsigned long)&fw_cache) && in fw_devm_match()
392 !strcmp(fwn->name, match_data); in fw_devm_match()
396 const char *name) in fw_find_devm_name() argument
401 fw_devm_match, (void *)name); in fw_find_devm_name()
405 static bool fw_cache_is_setup(struct device *dev, const char *name) in fw_cache_is_setup() argument
409 fwn = fw_find_devm_name(dev, name); in fw_cache_is_setup()
416 /* add firmware name into devres list */
417 static int fw_add_devm_name(struct device *dev, const char *name) in fw_add_devm_name() argument
421 if (fw_cache_is_setup(dev, name)) in fw_add_devm_name()
427 return -ENOMEM; in fw_add_devm_name()
428 fwn->name = kstrdup_const(name, GFP_KERNEL); in fw_add_devm_name()
429 if (!fwn->name) { in fw_add_devm_name()
431 return -ENOMEM; in fw_add_devm_name()
434 fwn->magic = (unsigned long)&fw_cache; in fw_add_devm_name()
440 static bool fw_cache_is_setup(struct device *dev, const char *name) in fw_cache_is_setup() argument
445 static int fw_add_devm_name(struct device *dev, const char *name) in fw_add_devm_name() argument
451 int assign_fw(struct firmware *fw, struct device *device, in assign_fw()
454 struct fw_priv *fw_priv = fw->priv; in assign_fw()
458 if (!fw_priv->size || fw_state_is_aborted(fw_priv)) { in assign_fw()
460 return -ENOENT; in assign_fw()
464 * add firmware name into devres list so that we can auto cache in assign_fw()
465 * and uncache firmware for device. in assign_fw()
470 /* don't cache firmware handled without uevent */ in assign_fw()
473 ret = fw_add_devm_name(device, fw_priv->fw_name); in assign_fw()
481 * After caching firmware image is started, let it piggyback in assign_fw()
482 * on request firmware. in assign_fw()
485 fw_priv->fwc->state == FW_LOADER_START_CACHE) { in assign_fw()
486 if (fw_cache_piggyback_on_request(fw_priv->fw_name)) in assign_fw()
487 kref_get(&fw_priv->ref); in assign_fw()
496 /* prepare firmware and firmware_buf structs;
497 * return 0 if a firmware is already assigned, 1 if need to load one,
501 _request_firmware_prepare(struct firmware **firmware_p, const char *name, in _request_firmware_prepare() argument
505 struct firmware *firmware; in _request_firmware_prepare() local
509 *firmware_p = firmware = kzalloc(sizeof(*firmware), GFP_KERNEL); in _request_firmware_prepare()
510 if (!firmware) { in _request_firmware_prepare()
511 dev_err(device, "%s: kmalloc(struct firmware) failed\n", in _request_firmware_prepare()
513 return -ENOMEM; in _request_firmware_prepare()
516 if (fw_get_builtin_firmware(firmware, name, dbuf, size)) { in _request_firmware_prepare()
517 dev_dbg(device, "using built-in %s\n", name); in _request_firmware_prepare()
521 ret = alloc_lookup_fw_priv(name, &fw_cache, &fw_priv, dbuf, size, in _request_firmware_prepare()
526 * of requesting firmware. in _request_firmware_prepare()
528 firmware->priv = fw_priv; in _request_firmware_prepare()
533 fw_set_page_data(fw_priv, firmware); in _request_firmware_prepare()
552 static void fw_abort_batch_reqs(struct firmware *fw) in fw_abort_batch_reqs()
557 if (!fw || !fw->priv) in fw_abort_batch_reqs()
560 fw_priv = fw->priv; in fw_abort_batch_reqs()
567 _request_firmware(const struct firmware **firmware_p, const char *name, in _request_firmware() argument
571 struct firmware *fw = NULL; in _request_firmware()
575 return -EINVAL; in _request_firmware()
577 if (!name || name[0] == '\0') { in _request_firmware()
578 ret = -EINVAL; in _request_firmware()
582 ret = _request_firmware_prepare(&fw, name, device, buf, size, in _request_firmware()
587 ret = fw_get_filesystem_firmware(device, fw->priv); in _request_firmware()
591 "Direct firmware load for %s failed with error %d\n", in _request_firmware()
592 name, ret); in _request_firmware()
593 ret = firmware_fallback_sysfs(fw, name, device, opt_flags, ret); in _request_firmware()
609 * request_firmware() - send firmware request and wait for it
610 * @firmware_p: pointer to firmware image
611 * @name: name of firmware file
612 * @device: device for which firmware is being loaded
614 * @firmware_p will be used to return a firmware image by the name
615 * of @name for device @device.
619 * @name will be used as $FIRMWARE in the uevent environment and
621 * firmware image for this or any other device.
629 request_firmware(const struct firmware **firmware_p, const char *name, in request_firmware() argument
636 ret = _request_firmware(firmware_p, name, device, NULL, 0, in request_firmware()
644 * firmware_request_nowarn() - request for an optional fw module
645 * @firmware: pointer to firmware image
646 * @name: name of firmware file
647 * @device: device for which firmware is being loaded
652 * however, however failures to find the firmware file with it are still
656 int firmware_request_nowarn(const struct firmware **firmware, const char *name, in firmware_request_nowarn() argument
663 ret = _request_firmware(firmware, name, device, NULL, 0, in firmware_request_nowarn()
671 * request_firmware_direct() - load firmware directly without usermode helper
672 * @firmware_p: pointer to firmware image
673 * @name: name of firmware file
674 * @device: device for which firmware is being loaded
677 * fall back to usermode helper even if the firmware couldn't be loaded
681 int request_firmware_direct(const struct firmware **firmware_p, in request_firmware_direct()
682 const char *name, struct device *device) in request_firmware_direct() argument
687 ret = _request_firmware(firmware_p, name, device, NULL, 0, in request_firmware_direct()
696 * firmware_request_cache() - cache firmware for suspend so resume can use it
697 * @name: name of firmware file
698 * @device: device for which firmware should be cached for
701 * require loading firmware on system reboot. This optimization may still
702 * require the firmware present on resume from suspend. This routine can be
703 * used to ensure the firmware is present on resume from suspend in these
707 int firmware_request_cache(struct device *device, const char *name) in firmware_request_cache() argument
712 ret = fw_add_devm_name(device, name); in firmware_request_cache()
720 * request_firmware_into_buf() - load firmware into a previously allocated buffer
721 * @firmware_p: pointer to firmware image
722 * @name: name of firmware file
723 * @device: device for which firmware is being loaded and DMA region allocated
724 * @buf: address of buffer to load firmware into
728 * allocate a buffer to hold the firmware data. Instead, the firmware
732 * This function doesn't cache firmware either.
735 request_firmware_into_buf(const struct firmware **firmware_p, const char *name, in request_firmware_into_buf() argument
740 if (fw_cache_is_setup(device, name)) in request_firmware_into_buf()
741 return -EOPNOTSUPP; in request_firmware_into_buf()
744 ret = _request_firmware(firmware_p, name, device, buf, size, in request_firmware_into_buf()
752 * release_firmware() - release the resource associated with a firmware image
753 * @fw: firmware resource to release
755 void release_firmware(const struct firmware *fw) in release_firmware()
769 const char *name; member
772 void (*cont)(const struct firmware *fw, void *context);
779 const struct firmware *fw; in request_firmware_work_func()
783 _request_firmware(&fw, fw_work->name, fw_work->device, NULL, 0, in request_firmware_work_func()
784 fw_work->opt_flags); in request_firmware_work_func()
785 fw_work->cont(fw, fw_work->context); in request_firmware_work_func()
786 put_device(fw_work->device); /* taken in request_firmware_nowait() */ in request_firmware_work_func()
788 module_put(fw_work->module); in request_firmware_work_func()
789 kfree_const(fw_work->name); in request_firmware_work_func()
794 * request_firmware_nowait() - asynchronous version of request_firmware
795 * @module: module requesting the firmware
796 * @uevent: sends uevent to copy the firmware image if this flag
797 * is non-zero else the firmware copy must be done manually.
798 * @name: name of firmware file
799 * @device: device for which firmware is being loaded
802 * @fw may be %NULL if firmware request fails.
803 * @cont: function will be called asynchronously when the firmware
809 * - sleep for as small periods as possible since it may
810 * increase kernel boot time of built-in device drivers
811 * requesting firmware in their ->probe() methods, if
814 * - can't sleep at all if @gfp is GFP_ATOMIC.
819 const char *name, struct device *device, gfp_t gfp, void *context, in request_firmware_nowait() argument
820 void (*cont)(const struct firmware *fw, void *context)) in request_firmware_nowait()
826 return -ENOMEM; in request_firmware_nowait()
828 fw_work->module = module; in request_firmware_nowait()
829 fw_work->name = kstrdup_const(name, gfp); in request_firmware_nowait()
830 if (!fw_work->name) { in request_firmware_nowait()
832 return -ENOMEM; in request_firmware_nowait()
834 fw_work->device = device; in request_firmware_nowait()
835 fw_work->context = context; in request_firmware_nowait()
836 fw_work->cont = cont; in request_firmware_nowait()
837 fw_work->opt_flags = FW_OPT_NOWAIT | in request_firmware_nowait()
840 if (!uevent && fw_cache_is_setup(device, name)) { in request_firmware_nowait()
841 kfree_const(fw_work->name); in request_firmware_nowait()
843 return -EOPNOTSUPP; in request_firmware_nowait()
847 kfree_const(fw_work->name); in request_firmware_nowait()
849 return -EFAULT; in request_firmware_nowait()
852 get_device(fw_work->device); in request_firmware_nowait()
853 INIT_WORK(&fw_work->work, request_firmware_work_func); in request_firmware_nowait()
854 schedule_work(&fw_work->work); in request_firmware_nowait()
863 * cache_firmware() - cache one firmware image in kernel memory space
864 * @fw_name: the firmware image name
866 * Cache firmware in kernel memory so that drivers can use it when
867 * system isn't ready for them to request firmware image from userspace.
869 * nowait version to get the cached firmware without any interacting
872 * Return 0 if the firmware image has been cached successfully
879 const struct firmware *fw; in cache_firmware()
897 spin_lock(&fwc->lock); in lookup_fw_priv()
899 spin_unlock(&fwc->lock); in lookup_fw_priv()
905 * uncache_firmware() - remove one cached firmware image
906 * @fw_name: the firmware image name
908 * Uncache one firmware image which has been cached successfully
911 * Return 0 if the firmware cache has been removed successfully
918 struct firmware fw; in uncache_firmware()
931 return -EINVAL; in uncache_firmware()
934 static struct fw_cache_entry *alloc_fw_cache_entry(const char *name) in alloc_fw_cache_entry() argument
942 fce->name = kstrdup_const(name, GFP_ATOMIC); in alloc_fw_cache_entry()
943 if (!fce->name) { in alloc_fw_cache_entry()
952 static int __fw_entry_found(const char *name) in __fw_entry_found() argument
957 list_for_each_entry(fce, &fwc->fw_names, list) { in __fw_entry_found()
958 if (!strcmp(fce->name, name)) in __fw_entry_found()
964 static int fw_cache_piggyback_on_request(const char *name) in fw_cache_piggyback_on_request() argument
970 spin_lock(&fwc->name_lock); in fw_cache_piggyback_on_request()
971 if (__fw_entry_found(name)) in fw_cache_piggyback_on_request()
974 fce = alloc_fw_cache_entry(name); in fw_cache_piggyback_on_request()
977 list_add(&fce->list, &fwc->fw_names); in fw_cache_piggyback_on_request()
978 pr_debug("%s: fw: %s\n", __func__, name); in fw_cache_piggyback_on_request()
981 spin_unlock(&fwc->name_lock); in fw_cache_piggyback_on_request()
987 kfree_const(fce->name); in free_fw_cache_entry()
998 ret = cache_firmware(fce->name); in __async_dev_cache_fw_image()
1000 spin_lock(&fwc->name_lock); in __async_dev_cache_fw_image()
1001 list_del(&fce->list); in __async_dev_cache_fw_image()
1002 spin_unlock(&fwc->name_lock); in __async_dev_cache_fw_image()
1008 /* called with dev->devres_lock held */
1013 const char *fw_name = fwn->name; in dev_create_fw_entry()
1019 list_add(&fce->list, head); in dev_create_fw_entry()
1026 return (fwn->magic == (unsigned long)match_data); in devm_name_match()
1041 list_del(&fce->list); in dev_cache_fw_image()
1043 spin_lock(&fwc->name_lock); in dev_cache_fw_image()
1044 /* only one cache entry for one firmware */ in dev_cache_fw_image()
1045 if (!__fw_entry_found(fce->name)) { in dev_cache_fw_image()
1046 list_add(&fce->list, &fwc->fw_names); in dev_cache_fw_image()
1051 spin_unlock(&fwc->name_lock); in dev_cache_fw_image()
1065 spin_lock(&fwc->name_lock); in __device_uncache_fw_images()
1066 while (!list_empty(&fwc->fw_names)) { in __device_uncache_fw_images()
1067 fce = list_entry(fwc->fw_names.next, in __device_uncache_fw_images()
1069 list_del(&fce->list); in __device_uncache_fw_images()
1070 spin_unlock(&fwc->name_lock); in __device_uncache_fw_images()
1072 uncache_firmware(fce->name); in __device_uncache_fw_images()
1075 spin_lock(&fwc->name_lock); in __device_uncache_fw_images()
1077 spin_unlock(&fwc->name_lock); in __device_uncache_fw_images()
1081 * device_cache_fw_images() - cache devices' firmware
1084 * successfully before, the firmware names are recored into the
1088 * time when system is not ready to complete loading firmware.
1098 cancel_delayed_work_sync(&fwc->work); in device_cache_fw_images()
1103 fwc->state = FW_LOADER_START_CACHE; in device_cache_fw_images()
1107 /* wait for completion of caching firmware for all devices */ in device_cache_fw_images()
1114 * device_uncache_fw_images() - uncache devices' firmware
1131 * device_uncache_fw_images_delay() - uncache devices firmwares
1176 /* stop caching firmware once syscore_suspend is reached */
1213 static int fw_cache_piggyback_on_request(const char *name) in fw_cache_piggyback_on_request() argument