/* * firmware_class.c - Multi purpose firmware loading support * * Copyright (c) 2003 Manuel Estrada Sainz * * Please see Documentation/firmware_class/ for more information. * */ #include <linux/capability.h>#include <linux/device.h>#include <linux/module.h>#include <linux/init.h>#include <linux/timer.h>#include <linux/vmalloc.h>#include <linux/interrupt.h>#include <linux/bitops.h>#include <linux/mutex.h>#include <linux/workqueue.h>#include <linux/highmem.h>#include <linux/firmware.h>#include <linux/slab.h>#include <linux/sched.h>#include <linux/file.h>#include <linux/list.h>#include <linux/fs.h>#include <linux/async.h>#include <linux/pm.h>#include <linux/suspend.h>#include <linux/syscore_ops.h>#include <linux/reboot.h>#include <linux/security.h> #include <generated/utsrelease.h> #include "base.h" MODULE_AUTHOR("Manuel Estrada Sainz");MODULE_DESCRIPTION("Multi purpose firmware loading support");MODULE_LICENSE("GPL"); /* Builtin firmware support */ #ifdef CONFIG_FW_LOADER extern struct builtin_fw __start_builtin_fw[];extern struct builtin_fw __end_builtin_fw[]; static bool fw_get_builtin_firmware(struct firmware *fw, const char *name, void *buf, size_t size){ struct builtin_fw *b_fw; for (b_fw = __start_builtin_fw; b_fw != __end_builtin_fw; b_fw++) { if (strcmp(name, b_fw->name) == 0) { fw->size = b_fw->size; fw->data = b_fw->data; if (buf && fw->size <= size) memcpy(buf, fw->data, fw->size); return true; } } return false;} static bool fw_is_builtin_firmware(const struct firmware *fw){ struct builtin_fw *b_fw; for (b_fw = __start_builtin_fw; b_fw != __end_builtin_fw; b_fw++) if (fw->data == b_fw->data) return true; return false;} #else /* Module case - no builtin firmware support */ static inline bool fw_get_builtin_firmware(struct firmware *fw, const char *name, void *buf, size_t size){ return false;} static inline bool fw_is_builtin_firmware(const struct firmware *fw){ return false;}#endif enum fw_status { FW_STATUS_UNKNOWN, FW_STATUS_LOADING, FW_STATUS_DONE, FW_STATUS_ABORTED,}; static int loading_timeout = 60; /* In seconds */ static inline long firmware_loading_timeout(void){ return loading_timeout > 0 ? loading_timeout * HZ : MAX_JIFFY_OFFSET;} /* * Concurrent request_firmware() for the same firmware need to be * serialized. struct fw_state is simple state machine which hold the * state of the firmware loading. */struct fw_state { struct completion completion; enum fw_status status;}; static void fw_state_init(struct fw_state *fw_st){ init_completion(&fw_st->completion); fw_st->status = FW_STATUS_UNKNOWN;} static inline bool __fw_state_is_done(enum fw_status status){ return status == FW_STATUS_DONE || status == FW_STATUS_ABORTED;} static int __fw_state_wait_common(struct fw_state *fw_st, long timeout){ long ret; ret = wait_for_completion_killable_timeout(&fw_st->completion, timeout); if (ret != 0 && fw_st->status == FW_STATUS_ABORTED) return -ENOENT; if (!ret) return -ETIMEDOUT; return ret < 0 ? ret : 0;} static void __fw_state_set(struct fw_state *fw_st, enum fw_status status){ WRITE_ONCE(fw_st->status, status); if (status == FW_STATUS_DONE || status == FW_STATUS_ABORTED) complete_all(&fw_st->completion);} #define fw_state_start(fw_st) \ __fw_state_set(fw_st, FW_STATUS_LOADING)#define fw_state_done(fw_st) \ __fw_state_set(fw_st, FW_STATUS_DONE)#define fw_state_aborted(fw_st) \ __fw_state_set(fw_st, FW_STATUS_ABORTED)#define fw_state_wait(fw_st) \ __fw_state_wait_common(fw_st, MAX_SCHEDULE_TIMEOUT) static int __fw_state_check(struct fw_state *fw_st, enum fw_status status){ return fw_st->status == status;} #define fw_state_is_aborted(fw_st) \ __fw_state_check(fw_st, FW_STATUS_ABORTED) #ifdef CONFIG_FW_LOADER_USER_HELPER #define fw_state_aborted(fw_st) \ __fw_state_set(fw_st, FW_STATUS_ABORTED)#define fw_state_is_done(fw_st) \ __fw_state_check(fw_st, FW_STATUS_DONE)#define fw_state_is_loading(fw_st) \ __fw_state_check(fw_st, FW_STATUS_LOADING)#define fw_state_wait_timeout(fw_st, timeout) \ __fw_state_wait_common(fw_st, timeout) #endif /* CONFIG_FW_LOADER_USER_HELPER */ /* firmware behavior options */#define FW_OPT_UEVENT (1U << 0)#define FW_OPT_NOWAIT (1U << 1)#ifdef CONFIG_FW_LOADER_USER_HELPER#define FW_OPT_USERHELPER (1U << 2)#else#define FW_OPT_USERHELPER 0#endif#ifdef CONFIG_FW_LOADER_USER_HELPER_FALLBACK#define FW_OPT_FALLBACK FW_OPT_USERHELPER#else#define FW_OPT_FALLBACK 0#endif#define FW_OPT_NO_WARN (1U << 3)#define FW_OPT_NOCACHE (1U << 4) struct firmware_cache { /* firmware_buf instance will be added into the below list */ spinlock_t lock; struct list_head head; int state; #ifdef CONFIG_PM_SLEEP /* * Names of firmware images which have been cached successfully * will be added into the below list so that device uncache * helper can trace which firmware images have been cached * before. */ spinlock_t name_lock; struct list_head fw_names; struct delayed_work work; struct notifier_block pm_notify;#endif}; struct firmware_buf { struct kref ref; struct list_head list; struct firmware_cache *fwc; struct fw_state fw_st; void *data; size_t size; size_t allocated_size;#ifdef CONFIG_FW_LOADER_USER_HELPER bool is_paged_buf; bool need_uevent; struct page **pages; int nr_pages; int page_array_size; struct list_head pending_list;#endif const char *fw_id;}; struct fw_cache_entry { struct list_head list; const char *name;}; struct fw_name_devm { unsigned long magic; const char *name;}; #define to_fwbuf(d) container_of(d, struct firmware_buf, ref) #define FW_LOADER_NO_CACHE 0#define FW_LOADER_START_CACHE 1 static int fw_cache_piggyback_on_request(const char *name); /* fw_lock could be moved to 'struct firmware_priv' but since it is just * guarding for corner cases a global lock should be OK */static DEFINE_MUTEX(fw_lock); static bool __enable_firmware = false; static void enable_firmware(void){ mutex_lock(&fw_lock); __enable_firmware = true; mutex_unlock(&fw_lock);} static void disable_firmware(void){ mutex_lock(&fw_lock); __enable_firmware = false; mutex_unlock(&fw_lock);} /* * When disabled only the built-in firmware and the firmware cache will be * used to look for firmware. */static bool firmware_enabled(void){ bool enabled = false; mutex_lock(&fw_lock); if (__enable_firmware) enabled = true; mutex_unlock(&fw_lock); return enabled;} static struct firmware_cache fw_cache; static struct firmware_buf *__allocate_fw_buf(const char *fw_name, struct firmware_cache *fwc, void *dbuf, size_t size){ struct firmware_buf *buf; buf = kzalloc(sizeof(*buf), GFP_ATOMIC); if (!buf) return NULL; buf->fw_id = kstrdup_const(fw_name, GFP_ATOMIC); if (!buf->fw_id) { kfree(buf); return NULL; } kref_init(&buf->ref); buf->fwc = fwc; buf->data = dbuf; buf->allocated_size = size; fw_state_init(&buf->fw_st);#ifdef CONFIG_FW_LOADER_USER_HELPER INIT_LIST_HEAD(&buf->pending_list);#endif pr_debug("%s: fw-%s buf=%p\n", __func__, fw_name, buf); return buf;} static struct firmware_buf *__fw_lookup_buf(const char *fw_name){ struct firmware_buf *tmp; struct firmware_cache *fwc = &fw_cache; list_for_each_entry(tmp, &fwc->head, list) if (!strcmp(tmp->fw_id, fw_name)) return tmp; return NULL;} static int fw_lookup_and_allocate_buf(const char *fw_name, struct firmware_cache *fwc, struct firmware_buf **buf, void *dbuf, size_t size){ struct firmware_buf *tmp; spin_lock(&fwc->lock); tmp = __fw_lookup_buf(fw_name); if (tmp) { kref_get(&tmp->ref); spin_unlock(&fwc->lock); *buf = tmp; return 1; } tmp = __allocate_fw_buf(fw_name, fwc, dbuf, size); if (tmp) list_add(&tmp->list, &fwc->head); spin_unlock(&fwc->lock); *buf = tmp; return tmp ? 0 : -ENOMEM;} static void __fw_free_buf(struct kref *ref) __releases(&fwc->lock){ struct firmware_buf *buf = to_fwbuf(ref); struct firmware_cache *fwc = buf->fwc; pr_debug("%s: fw-%s buf=%p data=%p size=%u\n", __func__, buf->fw_id, buf, buf->data, (unsigned int)buf->size); list_del(&buf->list); spin_unlock(&fwc->lock); #ifdef CONFIG_FW_LOADER_USER_HELPER if (buf->is_paged_buf) { int i; vunmap(buf->data); for (i = 0; i < buf->nr_pages; i++) __free_page(buf->pages[i]); vfree(buf->pages); } else#endif if (!buf->allocated_size) vfree(buf->data); kfree_const(buf->fw_id); kfree(buf);} static void fw_free_buf(struct firmware_buf *buf){ struct firmware_cache *fwc = buf->fwc; spin_lock(&fwc->lock); if (!kref_put(&buf->ref, __fw_free_buf)) spin_unlock(&fwc->lock);} /* direct firmware loading support */static char fw_path_para[256];static const char * const fw_path[] = { fw_path_para, "/lib/firmware/updates/" UTS_RELEASE, "/lib/firmware/updates", "/lib/firmware/" UTS_RELEASE, "/lib/firmware"}; /* * Typical usage is that passing 'firmware_class.path=$CUSTOMIZED_PATH' * from kernel command line because firmware_class is generally built in * kernel instead of module. */module_param_string(path, fw_path_para, sizeof(fw_path_para), 0644);MODULE_PARM_DESC(path, "customized firmware image search path with a higher priority than default path"); static intfw_get_filesystem_firmware(struct device *device, struct firmware_buf *buf){ loff_t size; int i, len; int rc = -ENOENT; char *path; enum kernel_read_file_id id = READING_FIRMWARE; size_t msize = INT_MAX; /* Already populated data member means we're loading into a buffer */ if (buf->data) { id = READING_FIRMWARE_PREALLOC_BUFFER; msize = buf->allocated_size; } path = __getname(); if (!path) return -ENOMEM; for (i = 0; i < ARRAY_SIZE(fw_path); i++) { /* skip the unset customized path */ if (!fw_path[i][0]) continue; len = snprintf(path, PATH_MAX, "%s/%s", fw_path[i], buf->fw_id); if (len >= PATH_MAX) { rc = -ENAMETOOLONG; break; } buf->size = 0; rc = kernel_read_file_from_path(path, &buf->data, &size, msize, id); if (rc) { if (rc == -ENOENT) dev_dbg(device, "loading %s failed with error %d\n", path, rc); else dev_warn(device, "loading %s failed with error %d\n", path, rc); continue; } dev_dbg(device, "direct-loading %s\n", buf->fw_id); buf->size = size; fw_state_done(&buf->fw_st); break; } __putname(path); return rc;} /* firmware holds the ownership of pages */static void firmware_free_data(const struct firmware *fw){ /* Loaded directly? */ if (!fw->priv) { vfree(fw->data); return; } fw_free_buf(fw->priv);} /* store the pages buffer info firmware from buf */static void fw_set_page_data(struct firmware_buf *buf, struct firmware *fw){ fw->priv = buf;#ifdef CONFIG_FW_LOADER_USER_HELPER fw->pages = buf->pages;#endif fw->size = buf->size; fw->data = buf->data; pr_debug("%s: fw-%s buf=%p data=%p size=%u\n", __func__, buf->fw_id, buf, buf->data, (unsigned int)buf->size);} #ifdef CONFIG_PM_SLEEPstatic void fw_name_devm_release(struct device *dev, void *res){ struct fw_name_devm *fwn = res; if (fwn->magic == (unsigned long)&fw_cache) pr_debug("%s: fw_name-%s devm-%p released\n", __func__, fwn->name, res);Lines 1–500 of 1929. Load more
/* * firmware_class.c - Multi purpose firmware loading support * * Copyright (c) 2003 Manuel Estrada Sainz * * Please see Documentation/firmware_class/ for more information. * */ #include <linux/capability.h> #include <linux/device.h> #include <linux/module.h> #include <linux/init.h> #include <linux/timer.h> #include <linux/vmalloc.h> #include <linux/interrupt.h> #include <linux/bitops.h> #include <linux/mutex.h> #include <linux/workqueue.h> #include <linux/highmem.h> #include <linux/firmware.h> #include <linux/slab.h> #include <linux/sched.h> #include <linux/file.h> #include <linux/list.h> #include <linux/fs.h> #include <linux/async.h> #include <linux/pm.h> #include <linux/suspend.h> #include <linux/syscore_ops.h> #include <linux/reboot.h> #include <linux/security.h> #include <generated/utsrelease.h> #include "base.h" MODULE_AUTHOR("Manuel Estrada Sainz"); MODULE_DESCRIPTION("Multi purpose firmware loading support"); MODULE_LICENSE("GPL"); /* Builtin firmware support */ #ifdef CONFIG_FW_LOADER extern struct builtin_fw __start_builtin_fw[]; extern struct builtin_fw __end_builtin_fw[]; static bool fw_get_builtin_firmware(struct firmware *fw, const char *name, void *buf, size_t size) { struct builtin_fw *b_fw; for (b_fw = __start_builtin_fw; b_fw != __end_builtin_fw; b_fw++) { if (strcmp(name, b_fw->name) == 0) { fw->size = b_fw->size; fw->data = b_fw->data; if (buf && fw->size <= size) memcpy(buf, fw->data, fw->size); return true; } } return false; } static bool fw_is_builtin_firmware(const struct firmware *fw) { struct builtin_fw *b_fw; for (b_fw = __start_builtin_fw; b_fw != __end_builtin_fw; b_fw++) if (fw->data == b_fw->data) return true; return false; } #else /* Module case - no builtin firmware support */ static inline bool fw_get_builtin_firmware(struct firmware *fw, const char *name, void *buf, size_t size) { return false; } static inline bool fw_is_builtin_firmware(const struct firmware *fw) { return false; } #endif enum fw_status { FW_STATUS_UNKNOWN, FW_STATUS_LOADING, FW_STATUS_DONE, FW_STATUS_ABORTED, }; static int loading_timeout = 60; /* In seconds */ static inline long firmware_loading_timeout(void) { return loading_timeout > 0 ? loading_timeout * HZ : MAX_JIFFY_OFFSET; } /* * Concurrent request_firmware() for the same firmware need to be * serialized. struct fw_state is simple state machine which hold the * state of the firmware loading. */ struct fw_state { struct completion completion; enum fw_status status; }; static void fw_state_init(struct fw_state *fw_st) { init_completion(&fw_st->completion); fw_st->status = FW_STATUS_UNKNOWN; } static inline bool __fw_state_is_done(enum fw_status status) { return status == FW_STATUS_DONE || status == FW_STATUS_ABORTED; } static int __fw_state_wait_common(struct fw_state *fw_st, long timeout) { long ret; ret = wait_for_completion_killable_timeout(&fw_st->completion, timeout); if (ret != 0 && fw_st->status == FW_STATUS_ABORTED) return -ENOENT; if (!ret) return -ETIMEDOUT; return ret < 0 ? ret : 0; } static void __fw_state_set(struct fw_state *fw_st, enum fw_status status) { WRITE_ONCE(fw_st->status, status); if (status == FW_STATUS_DONE || status == FW_STATUS_ABORTED) complete_all(&fw_st->completion); } #define fw_state_start(fw_st) \ __fw_state_set(fw_st, FW_STATUS_LOADING) #define fw_state_done(fw_st) \ __fw_state_set(fw_st, FW_STATUS_DONE) #define fw_state_aborted(fw_st) \ __fw_state_set(fw_st, FW_STATUS_ABORTED) #define fw_state_wait(fw_st) \ __fw_state_wait_common(fw_st, MAX_SCHEDULE_TIMEOUT) static int __fw_state_check(struct fw_state *fw_st, enum fw_status status) { return fw_st->status == status; } #define fw_state_is_aborted(fw_st) \ __fw_state_check(fw_st, FW_STATUS_ABORTED) #ifdef CONFIG_FW_LOADER_USER_HELPER #define fw_state_aborted(fw_st) \ __fw_state_set(fw_st, FW_STATUS_ABORTED) #define fw_state_is_done(fw_st) \ __fw_state_check(fw_st, FW_STATUS_DONE) #define fw_state_is_loading(fw_st) \ __fw_state_check(fw_st, FW_STATUS_LOADING) #define fw_state_wait_timeout(fw_st, timeout) \ __fw_state_wait_common(fw_st, timeout) #endif /* CONFIG_FW_LOADER_USER_HELPER */ /* firmware behavior options */ #define FW_OPT_UEVENT (1U << 0) #define FW_OPT_NOWAIT (1U << 1) #ifdef CONFIG_FW_LOADER_USER_HELPER #define FW_OPT_USERHELPER (1U << 2) #else #define FW_OPT_USERHELPER 0 #endif #ifdef CONFIG_FW_LOADER_USER_HELPER_FALLBACK #define FW_OPT_FALLBACK FW_OPT_USERHELPER #else #define FW_OPT_FALLBACK 0 #endif #define FW_OPT_NO_WARN (1U << 3) #define FW_OPT_NOCACHE (1U << 4) struct firmware_cache { /* firmware_buf instance will be added into the below list */ spinlock_t lock; struct list_head head; int state; #ifdef CONFIG_PM_SLEEP /* * Names of firmware images which have been cached successfully * will be added into the below list so that device uncache * helper can trace which firmware images have been cached * before. */ spinlock_t name_lock; struct list_head fw_names; struct delayed_work work; struct notifier_block pm_notify; #endif }; struct firmware_buf { struct kref ref; struct list_head list; struct firmware_cache *fwc; struct fw_state fw_st; void *data; size_t size; size_t allocated_size; #ifdef CONFIG_FW_LOADER_USER_HELPER bool is_paged_buf; bool need_uevent; struct page **pages; int nr_pages; int page_array_size; struct list_head pending_list; #endif const char *fw_id; }; struct fw_cache_entry { struct list_head list; const char *name; }; struct fw_name_devm { unsigned long magic; const char *name; }; #define to_fwbuf(d) container_of(d, struct firmware_buf, ref) #define FW_LOADER_NO_CACHE 0 #define FW_LOADER_START_CACHE 1 static int fw_cache_piggyback_on_request(const char *name); /* fw_lock could be moved to 'struct firmware_priv' but since it is just * guarding for corner cases a global lock should be OK */ static DEFINE_MUTEX(fw_lock); static bool __enable_firmware = false; static void enable_firmware(void) { mutex_lock(&fw_lock); __enable_firmware = true; mutex_unlock(&fw_lock); } static void disable_firmware(void) { mutex_lock(&fw_lock); __enable_firmware = false; mutex_unlock(&fw_lock); } /* * When disabled only the built-in firmware and the firmware cache will be * used to look for firmware. */ static bool firmware_enabled(void) { bool enabled = false; mutex_lock(&fw_lock); if (__enable_firmware) enabled = true; mutex_unlock(&fw_lock); return enabled; } static struct firmware_cache fw_cache; static struct firmware_buf *__allocate_fw_buf(const char *fw_name, struct firmware_cache *fwc, void *dbuf, size_t size) { struct firmware_buf *buf; buf = kzalloc(sizeof(*buf), GFP_ATOMIC); if (!buf) return NULL; buf->fw_id = kstrdup_const(fw_name, GFP_ATOMIC); if (!buf->fw_id) { kfree(buf); return NULL; } kref_init(&buf->ref); buf->fwc = fwc; buf->data = dbuf; buf->allocated_size = size; fw_state_init(&buf->fw_st); #ifdef CONFIG_FW_LOADER_USER_HELPER INIT_LIST_HEAD(&buf->pending_list); #endif pr_debug("%s: fw-%s buf=%p\n", __func__, fw_name, buf); return buf; } static struct firmware_buf *__fw_lookup_buf(const char *fw_name) { struct firmware_buf *tmp; struct firmware_cache *fwc = &fw_cache; list_for_each_entry(tmp, &fwc->head, list) if (!strcmp(tmp->fw_id, fw_name)) return tmp; return NULL; } static int fw_lookup_and_allocate_buf(const char *fw_name, struct firmware_cache *fwc, struct firmware_buf **buf, void *dbuf, size_t size) { struct firmware_buf *tmp; spin_lock(&fwc->lock); tmp = __fw_lookup_buf(fw_name); if (tmp) { kref_get(&tmp->ref); spin_unlock(&fwc->lock); *buf = tmp; return 1; } tmp = __allocate_fw_buf(fw_name, fwc, dbuf, size); if (tmp) list_add(&tmp->list, &fwc->head); spin_unlock(&fwc->lock); *buf = tmp; return tmp ? 0 : -ENOMEM; } static void __fw_free_buf(struct kref *ref) __releases(&fwc->lock) { struct firmware_buf *buf = to_fwbuf(ref); struct firmware_cache *fwc = buf->fwc; pr_debug("%s: fw-%s buf=%p data=%p size=%u\n", __func__, buf->fw_id, buf, buf->data, (unsigned int)buf->size); list_del(&buf->list); spin_unlock(&fwc->lock); #ifdef CONFIG_FW_LOADER_USER_HELPER if (buf->is_paged_buf) { int i; vunmap(buf->data); for (i = 0; i < buf->nr_pages; i++) __free_page(buf->pages[i]); vfree(buf->pages); } else #endif if (!buf->allocated_size) vfree(buf->data); kfree_const(buf->fw_id); kfree(buf); } static void fw_free_buf(struct firmware_buf *buf) { struct firmware_cache *fwc = buf->fwc; spin_lock(&fwc->lock); if (!kref_put(&buf->ref, __fw_free_buf)) spin_unlock(&fwc->lock); } /* direct firmware loading support */ static char fw_path_para[256]; static const char * const fw_path[] = { fw_path_para, "/lib/firmware/updates/" UTS_RELEASE, "/lib/firmware/updates", "/lib/firmware/" UTS_RELEASE, "/lib/firmware" }; /* * Typical usage is that passing 'firmware_class.path=$CUSTOMIZED_PATH' * from kernel command line because firmware_class is generally built in * kernel instead of module. */ module_param_string(path, fw_path_para, sizeof(fw_path_para), 0644); MODULE_PARM_DESC(path, "customized firmware image search path with a higher priority than default path"); static int fw_get_filesystem_firmware(struct device *device, struct firmware_buf *buf) { loff_t size; int i, len; int rc = -ENOENT; char *path; enum kernel_read_file_id id = READING_FIRMWARE; size_t msize = INT_MAX; /* Already populated data member means we're loading into a buffer */ if (buf->data) { id = READING_FIRMWARE_PREALLOC_BUFFER; msize = buf->allocated_size; } path = __getname(); if (!path) return -ENOMEM; for (i = 0; i < ARRAY_SIZE(fw_path); i++) { /* skip the unset customized path */ if (!fw_path[i][0]) continue; len = snprintf(path, PATH_MAX, "%s/%s", fw_path[i], buf->fw_id); if (len >= PATH_MAX) { rc = -ENAMETOOLONG; break; } buf->size = 0; rc = kernel_read_file_from_path(path, &buf->data, &size, msize, id); if (rc) { if (rc == -ENOENT) dev_dbg(device, "loading %s failed with error %d\n", path, rc); else dev_warn(device, "loading %s failed with error %d\n", path, rc); continue; } dev_dbg(device, "direct-loading %s\n", buf->fw_id); buf->size = size; fw_state_done(&buf->fw_st); break; } __putname(path); return rc; } /* firmware holds the ownership of pages */ static void firmware_free_data(const struct firmware *fw) { /* Loaded directly? */ if (!fw->priv) { vfree(fw->data); return; } fw_free_buf(fw->priv); } /* store the pages buffer info firmware from buf */ static void fw_set_page_data(struct firmware_buf *buf, struct firmware *fw) { fw->priv = buf; #ifdef CONFIG_FW_LOADER_USER_HELPER fw->pages = buf->pages; #endif fw->size = buf->size; fw->data = buf->data; pr_debug("%s: fw-%s buf=%p data=%p size=%u\n", __func__, buf->fw_id, buf, buf->data, (unsigned int)buf->size); } #ifdef CONFIG_PM_SLEEP static void fw_name_devm_release(struct device *dev, void *res) { struct fw_name_devm *fwn = res; if (fwn->magic == (unsigned long)&fw_cache) pr_debug("%s: fw_name-%s devm-%p released\n", __func__, fwn->name, res);