Release 4.16 drivers/base/firmware_class.c

Directory: drivers/base
// SPDX-License-Identifier: GPL-2.0
/*
 * firmware_class.c - Multi purpose firmware loading support
 *
 * Copyright (c) 2003 Manuel Estrada Sainz
 *
 * Please see Documentation/firmware_class/ for more information.
 *
 */


#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#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");


enum fw_status {
	
FW_STATUS_UNKNOWN,
	
FW_STATUS_LOADING,
	
FW_STATUS_DONE,
	
FW_STATUS_ABORTED,
};

/*
 * 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;
};

/* firmware behavior options */

#define FW_OPT_UEVENT	(1U << 0)

#define FW_OPT_NOWAIT	(1U << 1)

#define FW_OPT_USERHELPER	(1U << 2)

#define FW_OPT_NO_WARN	(1U << 3)

#define FW_OPT_NOCACHE	(1U << 4)

#define FW_OPT_NOFALLBACK (1U << 5)


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 fw_priv {
	
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_name;
};


struct fw_cache_entry {
	
struct list_head list;
	
const char *name;
};


struct fw_name_devm {
	
unsigned long magic;
	
const char *name;
};



static inline struct fw_priv *to_fw_priv(struct kref *ref)
{
	return container_of(ref, struct fw_priv, ref);
}

Contributors
Person Tokens Prop Commits CommitProp
Luis R. Rodriguez 25 100.00% 2 100.00%
Total 25 100.00% 2 100.00%


#define	FW_LOADER_NO_CACHE	0

#define	FW_LOADER_START_CACHE	1

/* fw_lock could be moved to 'struct fw_sysfs' but since it is just
 * guarding for corner cases a global lock should be OK */
static DEFINE_MUTEX(fw_lock);


static struct firmware_cache fw_cache;

/* Builtin firmware support */

#ifdef CONFIG_FW_LOADER

extern struct builtin_fw __start_builtin_fw[];
extern struct builtin_fw __end_builtin_fw[];



static void fw_copy_to_prealloc_buf(struct firmware *fw,
				    void *buf, size_t size)
{
	if (!buf || size < fw->size)
		return;
	memcpy(buf, fw->data, fw->size);
}

Contributors
Person Tokens Prop Commits CommitProp
Luis R. Rodriguez 43 100.00% 1 100.00%
Total 43 100.00% 1 100.00%



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;
			fw_copy_to_prealloc_buf(fw, buf, size);

			return true;
		}
	}

	return false;
}

Contributors
Person Tokens Prop Commits CommitProp
Ming Lei 42 47.19% 1 25.00%
Linus Torvalds 31 34.83% 1 25.00%
Stephen Boyd 13 14.61% 1 25.00%
Luis R. Rodriguez 3 3.37% 1 25.00%
Total 89 100.00% 4 100.00%



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;
}

Contributors
Person Tokens Prop Commits CommitProp
Dmitry Torokhov 25 54.35% 1 33.33%
Linus Torvalds 14 30.43% 1 33.33%
Ming Lei 7 15.22% 1 33.33%
Total 46 100.00% 3 100.00%

#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;
}

Contributors
Person Tokens Prop Commits CommitProp
Dmitry Torokhov 20 74.07% 1 50.00%
Stephen Boyd 7 25.93% 1 50.00%
Total 27 100.00% 2 100.00%



static inline bool fw_is_builtin_firmware(const struct firmware *fw)
{
	return false;
}
Contributors
Person Tokens Prop Commits CommitProp
Dmitry Torokhov 16 100.00% 1 100.00%
Total 16 100.00% 1 100.00%

#endif


static int loading_timeout = 60;	
/* In seconds */



static inline long firmware_loading_timeout(void)
{
	return loading_timeout > 0 ? loading_timeout * HZ : MAX_JIFFY_OFFSET;
}

Contributors
Person Tokens Prop Commits CommitProp
Rafael J. Wysocki 19 95.00% 1 50.00%
Ming Lei 1 5.00% 1 50.00%
Total 20 100.00% 2 100.00%



static void fw_state_init(struct fw_priv *fw_priv)
{
	struct fw_state *fw_st = &fw_priv->fw_st;

	init_completion(&fw_st->completion);
	fw_st->status = FW_STATUS_UNKNOWN;
}

Contributors
Person Tokens Prop Commits CommitProp
Daniel Wagner 21 60.00% 1 33.33%
Luis R. Rodriguez 14 40.00% 2 66.67%
Total 35 100.00% 3 100.00%



static int __fw_state_wait_common(struct fw_priv *fw_priv, long timeout)
{
	struct fw_state *fw_st = &fw_priv->fw_st;
	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;
}

Contributors
Person Tokens Prop Commits CommitProp
Daniel Wagner 42 57.53% 2 33.33%
Björn Andersson 16 21.92% 1 16.67%
Luis R. Rodriguez 15 20.55% 3 50.00%
Total 73 100.00% 6 100.00%



static void __fw_state_set(struct fw_priv *fw_priv,
			   enum fw_status status)
{
	struct fw_state *fw_st = &fw_priv->fw_st;

	WRITE_ONCE(fw_st->status, status);

	if (status == FW_STATUS_DONE || status == FW_STATUS_ABORTED)
		complete_all(&fw_st->completion);
}

Contributors
Person Tokens Prop Commits CommitProp
Daniel Wagner 38 73.08% 2 50.00%
Luis R. Rodriguez 14 26.92% 2 50.00%
Total 52 100.00% 4 100.00%



static inline void fw_state_start(struct fw_priv *fw_priv)
{
	__fw_state_set(fw_priv, FW_STATUS_LOADING);
}

Contributors
Person Tokens Prop Commits CommitProp
Luis R. Rodriguez 16 84.21% 1 50.00%
Daniel Wagner 3 15.79% 1 50.00%
Total 19 100.00% 2 100.00%



static inline void fw_state_done(struct fw_priv *fw_priv)
{
	__fw_state_set(fw_priv, FW_STATUS_DONE);
}

Contributors
Person Tokens Prop Commits CommitProp
Luis R. Rodriguez 16 84.21% 1 50.00%
Daniel Wagner 3 15.79% 1 50.00%
Total 19 100.00% 2 100.00%



static inline void fw_state_aborted(struct fw_priv *fw_priv)
{
	__fw_state_set(fw_priv, FW_STATUS_ABORTED);
}

Contributors
Person Tokens Prop Commits CommitProp
Luis R. Rodriguez 17 89.47% 2 66.67%
Daniel Wagner 2 10.53% 1 33.33%
Total 19 100.00% 3 100.00%



static inline int fw_state_wait(struct fw_priv *fw_priv)
{
	return __fw_state_wait_common(fw_priv, MAX_SCHEDULE_TIMEOUT);
}

Contributors
Person Tokens Prop Commits CommitProp
Luis R. Rodriguez 18 90.00% 2 66.67%
Daniel Wagner 2 10.00% 1 33.33%
Total 20 100.00% 3 100.00%



static bool __fw_state_check(struct fw_priv *fw_priv,
			     enum fw_status status)
{
	struct fw_state *fw_st = &fw_priv->fw_st;

	return fw_st->status == status;
}

Contributors
Person Tokens Prop Commits CommitProp
Luis R. Rodriguez 18 56.25% 2 66.67%
Daniel Wagner 14 43.75% 1 33.33%
Total 32 100.00% 3 100.00%



static inline bool fw_state_is_aborted(struct fw_priv *fw_priv)
{
	return __fw_state_check(fw_priv, FW_STATUS_ABORTED);
}

Contributors
Person Tokens Prop Commits CommitProp
Luis R. Rodriguez 20 100.00% 2 100.00%
Total 20 100.00% 2 100.00%

#ifdef CONFIG_FW_LOADER_USER_HELPER



static inline bool fw_sysfs_done(struct fw_priv *fw_priv)
{
	return __fw_state_check(fw_priv, FW_STATUS_DONE);
}

Contributors
Person Tokens Prop Commits CommitProp
Luis R. Rodriguez 18 90.00% 2 66.67%
Ming Lei 2 10.00% 1 33.33%
Total 20 100.00% 3 100.00%



static inline bool fw_sysfs_loading(struct fw_priv *fw_priv)
{
	return __fw_state_check(fw_priv, FW_STATUS_LOADING);
}

Contributors
Person Tokens Prop Commits CommitProp
Luis R. Rodriguez 20 100.00% 3 100.00%
Total 20 100.00% 3 100.00%



static inline int fw_sysfs_wait_timeout(struct fw_priv *fw_priv,  long timeout)
{
	return __fw_state_wait_common(fw_priv, timeout);
}

Contributors
Person Tokens Prop Commits CommitProp
Luis R. Rodriguez 23 100.00% 3 100.00%
Total 23 100.00% 3 100.00%

#endif /* CONFIG_FW_LOADER_USER_HELPER */

static int fw_cache_piggyback_on_request(const char *name);



static struct fw_priv *__allocate_fw_priv(const char *fw_name,
					  struct firmware_cache *fwc,
					  void *dbuf, size_t size)
{
	struct fw_priv *fw_priv;

	fw_priv = kzalloc(sizeof(*fw_priv), GFP_ATOMIC);
	if (!fw_priv)
		return NULL;

	fw_priv->fw_name = kstrdup_const(fw_name, GFP_ATOMIC);
	if (!fw_priv->fw_name) {
		kfree(fw_priv);
		return NULL;
	}

	kref_init(&fw_priv->ref);
	fw_priv->fwc = fwc;
	fw_priv->data = dbuf;
	fw_priv->allocated_size = size;
	fw_state_init(fw_priv);
#ifdef CONFIG_FW_LOADER_USER_HELPER
	INIT_LIST_HEAD(&fw_priv->pending_list);
#endif

	pr_debug("%s: fw-%s fw_priv=%p\n", __func__, fw_name, fw_priv);

	return fw_priv;
}

Contributors
Person Tokens Prop Commits CommitProp
Ming Lei 63 45.99% 1 14.29%
Luis R. Rodriguez 44 32.12% 3 42.86%
Stephen Boyd 17 12.41% 1 14.29%
Takashi Iwai 12 8.76% 1 14.29%
Daniel Wagner 1 0.73% 1 14.29%
Total 137 100.00% 7 100.00%



static struct fw_priv *__lookup_fw_priv(const char *fw_name)
{
	struct fw_priv *tmp;
	struct firmware_cache *fwc = &fw_cache;

	list_for_each_entry(tmp, &fwc->head, list)
		if (!strcmp(tmp->fw_name, fw_name))
			return tmp;
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Ming Lei 48 92.31% 1 33.33%
Luis R. Rodriguez 4 7.69% 2 66.67%
Total 52 100.00% 3 100.00%

/* Returns 1 for batching firmware requests with the same name */


static int alloc_lookup_fw_priv(const char *fw_name,
				struct firmware_cache *fwc,
				struct fw_priv **fw_priv, void *dbuf,
				size_t size)
{
	struct fw_priv *tmp;

	spin_lock(&fwc->lock);
	tmp = __lookup_fw_priv(fw_name);
	if (tmp) {
		kref_get(&tmp->ref);
		spin_unlock(&fwc->lock);
		*fw_priv = tmp;
		pr_debug("batched request - sharing the same struct fw_priv and lookup for multiple requests\n");
		return 1;
	}
	tmp = __allocate_fw_priv(fw_name, fwc, dbuf, size);
	if (tmp)
		list_add(&tmp->list, &fwc->head);
	spin_unlock(&fwc->lock);

	*fw_priv = tmp;

	return tmp ? 0 : -ENOMEM;
}

Contributors
Person Tokens Prop Commits CommitProp
Ming Lei 111 82.22% 2 40.00%
Luis R. Rodriguez 13 9.63% 2 40.00%
Stephen Boyd 11 8.15% 1 20.00%
Total 135 100.00% 5 100.00%



static void __free_fw_priv(struct kref *ref)
	__releases(&fwc->lockContributors
Person Tokens Prop Commits CommitProp
Ming Lei 8 66.67% 1 33.33%
Bart Van Assche 3 25.00% 1 33.33%
Luis R. Rodriguez 1 8.33% 1 33.33%
Total 12 100.00% 3 100.00%

)
{
	struct fw_priv *fw_priv = to_fw_priv(ref);
	struct firmware_cache *fwc = fw_priv->fwc;

	pr_debug("%s: fw-%s fw_priv=%p data=%p size=%u\n",
		 __func__, fw_priv->fw_name, fw_priv, fw_priv->data,
		 (unsigned int)fw_priv->size);

	list_del(&fw_priv->list);
	spin_unlock(&fwc->lock);

#ifdef CONFIG_FW_LOADER_USER_HELPER
	if (fw_priv->is_paged_buf) {
		int i;
		vunmap(fw_priv->data);
		for (i = 0; i < fw_priv->nr_pages; i++)
			__free_page(fw_priv->pages[i]);
		vfree(fw_priv->pages);
	} else
#endif
	if (!fw_priv->allocated_size)
		vfree(fw_priv->data);
	kfree_const(fw_priv->fw_name);
	kfree(fw_priv);
}



static void free_fw_priv(struct fw_priv *fw_priv)
{
	struct firmware_cache *fwc = fw_priv->fwc;
	spin_lock(&fwc->lock);
	if (!kref_put(&fw_priv->ref, __free_fw_priv))
		spin_unlock(&fwc->lock);
}

Contributors
Person Tokens Prop Commits CommitProp
Chuansheng Liu 27 55.10% 1 33.33%
Ming Lei 16 32.65% 1 33.33%
Luis R. Rodriguez 6 12.24% 1 33.33%
Total 49 100.00% 3 100.00%

/* 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 fw_priv *fw_priv)
{
	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 (fw_priv->data) {
		id = READING_FIRMWARE_PREALLOC_BUFFER;
		msize = fw_priv->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], fw_priv->fw_name);
		if (len >= PATH_MAX) {
			rc = -ENAMETOOLONG;
			break;
		}

		fw_priv->size = 0;
		rc = kernel_read_file_from_path(path, &fw_priv->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", fw_priv->fw_name);
		fw_priv->size = size;
		fw_state_done(fw_priv);
		break;
	}
	__putname(path);

	return rc;
}

Contributors
Person Tokens Prop Commits CommitProp
Ming Lei 78 33.05% 3 20.00%
Luis R. Rodriguez 64 27.12% 6 40.00%
Stephen Boyd 30 12.71% 1 6.67%
Mimi Zohar 20 8.47% 1 6.67%
Neil Horman 18 7.63% 1 6.67%
Takashi Iwai 17 7.20% 1 6.67%
Kees Cook 8 3.39% 1 6.67%
Daniel Wagner 1 0.42% 1 6.67%
Total 236 100.00% 15 100.00%

/* firmware holds the ownership of pages */


static void firmware_free_data(const struct firmware *fw)
{
	/* Loaded directly? */
	if (!fw->priv) {
		vfree(fw->data);
		return;
	}
	free_fw_priv(fw->priv);
}

Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 36 97.30% 1 50.00%
Luis R. Rodriguez 1 2.70% 1 50.00%
Total 37 100.00% 2 100.00%

/* store the pages buffer info firmware from buf */


static void fw_set_page_data(struct fw_priv *fw_priv, struct firmware *fw)
{
	fw->priv = fw_priv;
#ifdef CONFIG_FW_LOADER_USER_HELPER
	fw->pages = fw_priv->pages;
#endif
	fw->size = fw_priv->size;
	fw->data = fw_priv->data;

	pr_debug("%s: fw-%s fw_priv=%p data=%p size=%u\n",
		 __func__, fw_priv->fw_name, fw_priv, fw_priv->data,
		 (unsigned int)fw_priv->size);
}

Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 52 68.42% 1 20.00%
Luis R. Rodriguez 12 15.79% 2 40.00%
Dmitry Torokhov 11 14.47% 1 20.00%
Manuel Estrada Sainz 1 1.32% 1 20.00%
Total 76 100.00% 5 100.00%

#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);
	kfree_const(fwn->name);
}

Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 31 56.36% 1 20.00%
Andrew Morton 11 20.00% 1 20.00%
Luis R. Rodriguez 7 12.73% 1 20.00%
Ming Lei 4 7.27% 1 20.00%
Dmitry Torokhov 2 3.64% 1 20.00%
Total 55 100.00% 5 100.00%



static int fw_devm_match(struct device *dev, void *res,
		void *match_data)
{
	struct fw_name_devm *fwn = res;

	return (fwn->magic == (unsigned long)&fw_cache) &&
		!strcmp(fwn->name, match_data);
}

Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 35 70.00% 1 25.00%
Manuel Estrada Sainz 12 24.00% 1 25.00%
Andi Kleen 2 4.00% 1 25.00%
Andrew Morton 1 2.00% 1 25.00%
Total 50 100.00% 4 100.00%



static struct fw_name_devm *fw_find_devm_name(struct device *dev,
		const char *name)
{
	struct fw_name_devm *fwn;

	fwn = devres_find(dev, fw_name_devm_release,
			  fw_devm_match, (void *)name);
	return fwn;
}

Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 23 53.49% 1 33.33%
Manuel Estrada Sainz 17 39.53% 1 33.33%
Andi Kleen 3 6.98% 1 33.33%
Total 43 100.00% 3 100.00%

/* add firmware name into devres list */


static int fw_add_devm_name(struct device *dev, const char *name)
{
	struct fw_name_devm *fwn;

	fwn = fw_find_devm_name(dev, name);
	if (fwn)
		return 1;

	fwn = devres_alloc(fw_name_devm_release, sizeof(struct fw_name_devm),
			   GFP_KERNEL);
	if (!fwn)
		return -ENOMEM;
	fwn->name = kstrdup_const(name, GFP_KERNEL);
	if (!fwn->name) {
		devres_free(fwn);
		return -ENOMEM;
	}

	fwn->magic = (unsigned long)&fw_cache;
	devres_add(dev, fwn);

	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 48 43.24% 1 12.50%
Luis R. Rodriguez 26 23.42% 1 12.50%
Manuel Estrada Sainz 20 18.02% 1 12.50%
Kay Sievers 9 8.11% 1 12.50%
Greg Kroah-Hartman 3 2.70% 1 12.50%
Adrian Bunk 2 1.80% 1 12.50%
Johannes Berg 2 1.80% 1 12.50%
Vladimir Zapolskiy 1 0.90% 1 12.50%
Total 111 100.00% 8 100.00%

#else


static int fw_add_devm_name(struct device *dev, const char *name)
{
	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
Manuel Estrada Sainz 11 57.89% 1 33.33%
Takashi Iwai 5 26.32% 1 33.33%
Greg Kroah-Hartman 3 15.79% 1 33.33%
Total 19 100.00% 3 100.00%

#endif



static int assign_fw(struct firmware *fw, struct device *device,
		     unsigned int opt_flags)
{
	struct fw_priv *fw_priv = fw->priv;

	mutex_lock(&fw_lock);
	if (!fw_priv->size || fw_state_is_aborted(fw_priv)) {
		mutex_unlock(&fw_lock);
		return -ENOENT;
	}

	/*
         * add firmware name into devres list so that we can auto cache
         * and uncache firmware for device.
         *
         * device may has been deleted already, but the problem
         * should be fixed in devres or driver core.
         */
	/* don't cache firmware handled without uevent */
	if (device && (opt_flags & FW_OPT_UEVENT) &&
	    !(opt_flags & FW_OPT_NOCACHE))
		fw_add_devm_name(device, fw_priv->fw_name);

	/*
         * After caching firmware image is started, let it piggyback
         * on request firmware.
         */
	if (!(opt_flags & FW_OPT_NOCACHE) &&
	    fw_priv->fwc->state == FW_LOADER_START_CACHE) {
		if (fw_cache_piggyback_on_request(fw_priv->fw_name))
			kref_get(&fw_priv->ref);
	}

	/* pass the pages buffer to driver at the last minute */
	fw_set_page_data(fw_priv, fw);
	mutex_unlock(&fw_lock);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Luis R. Rodriguez 141 100.00% 3 100.00%
Total 141 100.00% 3 100.00%

/*
 * user-mode helper code
 */
#ifdef CONFIG_FW_LOADER_USER_HELPER

struct fw_sysfs {
	
bool nowait;
	
struct device dev;
	
struct fw_priv *fw_priv;
	
struct firmware *fw;
};



static struct fw_sysfs *to_fw_sysfs(struct device *dev)
{
	return container_of(dev, struct fw_sysfs, dev);
}

Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 13 54.17% 1 25.00%
Ming Lei 8 33.33% 2 50.00%
Luis R. Rodriguez 3 12.50% 1 25.00%
Total 24 100.00% 4 100.00%



static void __fw_load_abort(struct fw_priv *fw_priv)
{
	/*
         * There is a small window in which user can write to 'loading'
         * between loading done and disappearance of 'loading'
         */
	if (fw_sysfs_done(fw_priv))
		return;

	list_del_init(&fw_priv->pending_list);
	fw_state_aborted(fw_priv);
}

Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 13 39.39% 2 22.22%
Ming Lei 12 36.36% 3 33.33%
Luis R. Rodriguez 6 18.18% 2 22.22%
Greg Kroah-Hartman 1 3.03% 1 11.11%
Daniel Wagner 1 3.03% 1 11.11%
Total 33 100.00% 9 100.00%



static void fw_load_abort(struct fw_sysfs *fw_sysfs)
{
	struct fw_priv *fw_priv = fw_sysfs->fw_priv;

	__fw_load_abort(fw_priv);
}

Contributors
Person Tokens Prop Commits CommitProp
Greg Kroah-Hartman 17 68.00% 1 25.00%
Luis R. Rodriguez 7 28.00% 2 50.00%
Ming Lei 1 4.00% 1 25.00%
Total 25 100.00% 4 100.00%

static LIST_HEAD(pending_fw_head);



static void kill_pending_fw_fallback_reqs(bool only_kill_custom)
{
	struct fw_priv *fw_priv;
	struct fw_priv *next;

	mutex_lock(&fw_lock);
	list_for_each_entry_safe(fw_priv, next, &pending_fw_head,
				 pending_list) {
		if (!fw_priv->need_uevent || !only_kill_custom)
			 __fw_load_abort(fw_priv);
	}
	mutex_unlock(&fw_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
Luis R. Rodriguez 58 100.00% 3 100.00%
Total 58 100.00% 3 100.00%



static ssize_t timeout_show(struct class *class, struct class_attribute *attr,
			    char *buf)
{
	return sprintf(buf, "%d\n", loading_timeout);
}

Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 13 43.33% 1 25.00%
Manuel Estrada Sainz 12 40.00% 1 25.00%
Greg Kroah-Hartman 5 16.67% 2 50.00%
Total 30 100.00% 4 100.00%

/**
 * firmware_timeout_store - set number of seconds to wait for firmware
 * @class: device class pointer
 * @attr: device attribute pointer
 * @buf: buffer to scan for timeout value
 * @count: number of bytes in @buf
 *
 *      Sets the number of seconds to wait for the firmware.  Once
 *      this expires an error will be returned to the driver and no
 *      firmware will be provided.
 *
 *      Note: zero means 'wait forever'.
 **/


static ssize_t timeout_store(struct class *class, struct class_attribute *attr,
			     const char *buf, size_t count)
{
	loading_timeout = simple_strtol(buf, NULL, 10);
	if (loading_timeout < 0)
		loading_timeout = 0;

	return count;
}
Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 33 68.75% 1 14.29%
Manuel Estrada Sainz 8 16.67% 1 14.29%
Ming Lei 2 4.17% 1 14.29%
Stanislaw W. Gruszka 2 4.17% 1 14.29%
Andrew Morton 1 2.08% 1 14.29%
Neil Horman 1 2.08% 1 14.29%
Greg Kroah-Hartman 1 2.08% 1 14.29%
Total 48 100.00% 7 100.00%

static CLASS_ATTR_RW(timeout);


static struct attribute *firmware_class_attrs[] = {
	&class_attr_timeout.attr,
	NULL,
};
ATTRIBUTE_GROUPS(firmware_class);



static void fw_dev_release(struct device *dev)
{
	struct fw_sysfs *fw_sysfs = to_fw_sysfs(dev);

	kfree(fw_sysfs);
}

Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 14 53.85% 1 25.00%
David Woodhouse 6 23.08% 1 25.00%
Luis R. Rodriguez 4 15.38% 1 25.00%
Ming Lei 2 7.69% 1 25.00%
Total 26 100.00% 4 100.00%



static int do_firmware_uevent(struct fw_sysfs *fw_sysfs, struct kobj_uevent_env *env)
{
	if (add_uevent_var(env, "FIRMWARE=%s", fw_sysfs->fw_priv->fw_name))
		return -ENOMEM;
	if (add_uevent_var(env, "TIMEOUT=%i", loading_timeout))
		return -ENOMEM;
	if (add_uevent_var(env, "ASYNC=%d", fw_sysfs->nowait))
		return -ENOMEM;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 45 64.29% 1 11.11%
Andrew Morton 9 12.86% 2 22.22%
Manuel Estrada Sainz 7 10.00% 1 11.11%
Luis R. Rodriguez 6 8.57% 3 33.33%
Ming Lei 2 2.86% 1 11.11%
Linus Torvalds 1 1.43% 1 11.11%
Total 70 100.00% 9 100.00%



static int firmware_uevent(struct device *dev, struct kobj_uevent_env *env)
{
	struct fw_sysfs *fw_sysfs = to_fw_sysfs(dev);
	int err = 0;

	mutex_lock(&fw_lock);
	if (fw_sysfs->fw_priv)
		err = do_firmware_uevent(fw_sysfs, env);
	mutex_unlock(&fw_lock);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
Linus Torvalds 55 90.16% 1 33.33%
Luis R. Rodriguez 6 9.84% 2 66.67%
Total 61 100.00% 3 100.00%


static struct class firmware_class = {
	.name		= "firmware",
	.class_groups	= firmware_class_groups,
	.dev_uevent	= firmware_uevent,
	.dev_release	= fw_dev_release,
};



static inline int register_sysfs_loader(void)
{
	return class_register(&firmware_class);
}

Contributors
Person Tokens Prop Commits CommitProp
Luis R. Rodriguez 16 100.00% 1 100.00%
Total 16 100.00% 1 100.00%



static inline void unregister_sysfs_loader(void)
{
	class_unregister(&firmware_class);
}

Contributors
Person Tokens Prop Commits CommitProp
Luis R. Rodriguez 15 100.00% 1 100.00%
Total 15 100.00% 1 100.00%



static ssize_t firmware_loading_show(struct device *dev,
				     struct device_attribute *attr, char *buf)
{
	struct fw_sysfs *fw_sysfs = to_fw_sysfs(dev);
	int loading = 0;

	mutex_lock(&fw_lock);
	if (fw_sysfs->fw_priv)
		loading = fw_sysfs_loading(fw_sysfs->fw_priv);
	mutex_unlock(&fw_lock);

	return sprintf(buf, "%d\n", loading);
}

Contributors
Person Tokens Prop Commits CommitProp
Ming Lei 21 29.17% 1 11.11%
Takashi Iwai 20 27.78% 1 11.11%
Manuel Estrada Sainz 16 22.22% 1 11.11%
Luis R. Rodriguez 8 11.11% 3 33.33%
Andrew Morton 3 4.17% 1 11.11%
Rui Zhang 3 4.17% 1 11.11%
Greg Kroah-Hartman 1 1.39% 1 11.11%
Total 72 100.00% 9 100.00%

/* Some architectures don't have PAGE_KERNEL_RO */
#ifndef PAGE_KERNEL_RO

#define PAGE_KERNEL_RO PAGE_KERNEL
#endif

/* one pages buffer should be mapped/unmapped only once */


static int map_fw_priv_pages(struct fw_priv *fw_priv)
{
	if (!fw_priv->is_paged_buf)
		return 0;

	vunmap(fw_priv->data);
	fw_priv->data = vmap(fw_priv->pages, fw_priv->nr_pages, 0,
			     PAGE_KERNEL_RO);
	if (!fw_priv->data)
		return -ENOMEM;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 33 54.10% 1 20.00%
David Woodhouse 13 21.31% 1 20.00%
Luis R. Rodriguez 9 14.75% 1 20.00%
Manuel Estrada Sainz 5 8.20% 1 20.00%
Akinobu Mita 1 1.64% 1 20.00%
Total 61 100.00% 5 100.00%

/**
 * firmware_loading_store - set value in the 'loading' control file
 * @dev: device pointer
 * @attr: device attribute pointer
 * @buf: buffer to scan for loading control value
 * @count: number of bytes in @buf
 *
 *      The relevant values are:
 *
 *       1: Start a load, discarding any previous partial load.
 *       0: Conclude the load and hand the data to the driver code.
 *      -1: Conclude the load with an error and discard any written data.
 **/


static ssize_t firmware_loading_store(struct device *dev,
				      struct device_attribute *attr,
				      const char *buf, size_t count)
{
	struct fw_sysfs *fw_sysfs = to_fw_sysfs(dev);
	struct fw_priv *fw_priv;
	ssize_t written = count;
	int loading = simple_strtol(buf, NULL, 10);
	int i;

	mutex_lock(&fw_lock);
	fw_priv = fw_sysfs->fw_priv;
	if (fw_state_is_aborted(fw_priv))
		goto out;

	switch (loading) {
	case 1:
		/* discarding any previous partial load */
		if (!fw_sysfs_done(fw_priv)) {
			for (i = 0; i < fw_priv->nr_pages; i++)
				__free_page(fw_priv->pages[i]);
			vfree(fw_priv->pages);
			fw_priv->pages = NULL;
			fw_priv->page_array_size = 0;
			fw_priv->nr_pages = 0;
			fw_state_start(fw_priv);
		}
		break;
	case 0:
		if (fw_sysfs_loading(fw_priv)) {
			int rc;

			/*
                         * Several loading requests may be pending on
                         * one same firmware buf, so let all requests
                         * see the mapped 'buf->data' once the loading
                         * is completed.
                         * */
			rc = map_fw_priv_pages(fw_priv);
			if (rc)
				dev_err(dev, "%s: map pages failed\n",
					__func__);
			else
				rc = security_kernel_post_read_file(NULL,
						fw_priv->data, fw_priv->size,
						READING_FIRMWARE);

			/*
                         * Same logic as fw_load_abort, only the DONE bit
                         * is ignored and we set ABORT only on failure.
                         */
			list_del_init(&fw_priv->pending_list);
			if (rc) {
				fw_state_aborted(fw_priv);
				written = rc;
			} else {
				fw_state_done(fw_priv);
			}
			break;
		}
		/* fallthrough */
	default:
		dev_err(dev, "%s: unexpected value (%d)\n", __func__, loading);
		/* fallthrough */
	case -1:
		fw_load_abort(fw_sysfs);
		break;
	}
out:
	mutex_unlock(&fw_lock);
	return written;
}

Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 120 43.01% 2 12.50%
Kees Cook 42 15.05% 1 6.25%
Luis R. Rodriguez 31 11.11% 4 25.00%
Manuel Estrada Sainz 30 10.75% 1 6.25%
David Woodhouse 26 9.32% 1 6.25%
zhang jun 9 3.23% 1 6.25%
Ming Lei 7 2.51% 2 12.50%
Daniel Wagner 6 2.15% 1 6.25%
Jeff Moyer 4 1.43% 1 6.25%
Mimi Zohar 3 1.08% 1 6.25%
Chen Feng 1 0.36% 1 6.25%
Total 279 100.00% 16 100.00%

static DEVICE_ATTR(loading, 0644, firmware_loading_show, firmware_loading_store);



static void firmware_rw_data(struct fw_priv *fw_priv, char *buffer,
			   loff_t offset, size_t count, bool read)
{
	if (read)
		memcpy(buffer, fw_priv->data + offset, count);
	else
		memcpy(fw_priv->data + offset, buffer, count);
}

Contributors
Person Tokens Prop Commits CommitProp
Stephen Boyd 50 90.91% 1 50.00%
Luis R. Rodriguez 5 9.09% 1 50.00%
Total 55 100.00% 2 100.00%



static void firmware_rw(struct fw_priv *fw_priv, char *buffer,
			loff_t offset, size_t count, bool read)
{
	while (count) {
		void *page_data;
		int page_nr = offset >> PAGE_SHIFT;
		int page_ofs = offset & (PAGE_SIZE-1);
		int page_cnt = min_t(size_t, PAGE_SIZE - page_ofs, count);

		page_data = kmap(fw_priv->pages[page_nr]);

		if (read)
			memcpy(buffer, page_data + page_ofs, page_cnt);
		else
			memcpy(page_data + page_ofs, buffer, page_cnt);

		kunmap(fw_priv->pages[page_nr]);
		buffer += page_cnt;
		offset += page_cnt;
		count -= page_cnt;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Stephen Boyd 123 96.85% 1 50.00%
Luis R. Rodriguez 4 3.15% 1 50.00%
Total 127 100.00% 2 100.00%



static ssize_t firmware_data_read(struct file *filp, struct kobject *kobj,
				  struct bin_attribute *bin_attr,
				  char *buffer, loff_t offset, size_t count)
{
	struct device *dev = kobj_to_dev(kobj);
	struct fw_sysfs *fw_sysfs = to_fw_sysfs(dev);
	struct fw_priv *fw_priv;
	ssize_t ret_count;

	mutex_lock(&fw_lock);
	fw_priv = fw_sysfs->fw_priv;
	if (!fw_priv || fw_sysfs_done(fw_priv)) {
		ret_count = -ENODEV;
		goto out;
	}
	if (offset > fw_priv->size) {
		ret_count = 0;
		goto out;
	}
	if (count > fw_priv->size - offset)
		count = fw_priv->size - offset;

	ret_count = count;

	if (fw_priv->data)
		firmware_rw_data(fw_priv, buffer, offset, count, true);
	else
		firmware_rw(fw_priv, buffer, offset, count, true);

out:
	mutex_unlock(&fw_lock);
	return ret_count;
}

Contributors
Person Tokens Prop Commits CommitProp
Manuel Estrada Sainz 40 22.99% 1 6.67%
Andrew Morton 35 20.11% 1 6.67%
Takashi Iwai 33 18.97% 1 6.67%
Stephen Boyd 23 13.22% 2 13.33%
Luis R. Rodriguez 18 10.34% 3 20.00%
David Woodhouse 7 4.02% 1 6.67%
Rui Zhang 5 2.87% 1 6.67%
Chris Wright 5 2.87% 1 6.67%
Greg Kroah-Hartman 3 1.72% 1 6.67%
Laura Garcia Liebana 2 1.15% 1 6.67%
Stanislaw W. Gruszka 2 1.15% 1 6.67%
Lars-Peter Clausen 1 0.57% 1 6.67%
Total 174 100.00% 15 100.00%



static int fw_realloc_pages(struct fw_sysfs *fw_sysfs, int min_size)
{
	struct fw_priv *fw_priv= fw_sysfs->fw_priv;
	int pages_needed = PAGE_ALIGN(min_size) >> PAGE_SHIFT;

	/* If the array of pages is too small, grow it... */
	if (fw_priv->page_array_size < pages_needed) {
		int new_array_size = max(pages_needed,
					 fw_priv->page_array_size * 2);
		struct page **new_pages;

		new_pages = vmalloc(new_array_size * sizeof(void *));
		if (!new_pages) {
			fw_load_abort(fw_sysfs);
			return -ENOMEM;
		}
		memcpy(new_pages, fw_priv->pages,
		       fw_priv->page_array_size * sizeof(void *));
		memset(&new_pages[fw_priv->page_array_size], 0, sizeof(void *) *
		       (new_array_size - fw_priv->page_array_size));
		vfree(fw_priv->pages);
		fw_priv->pages = new_pages;
		fw_priv->page_array_size = new_array_size;
	}

	while (fw_priv->nr_pages < pages_needed) {
		fw_priv->pages[fw_priv->nr_pages] =
			alloc_page(GFP_KERNEL | __GFP_HIGHMEM);

		if (!fw_priv->pages[fw_priv->nr_pages]) {
			fw_load_abort(fw_sysfs);
			return -ENOMEM;
		}
		fw_priv->nr_pages++;
	}
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 115 53.49% 1 7.69%
Ming Lei 31 14.42% 2 15.38%
Luis R. Rodriguez 24 11.16% 2 15.38%
Manuel Estrada Sainz 18 8.37% 1 7.69%
Chuansheng Liu 11 5.12% 1 7.69%
Dmitry Torokhov 9 4.19% 1 7.69%
Chen Feng 2 0.93% 1 7.69%
Andrew Morton 2 0.93% 1 7.69%
Kay Sievers 1 0.47% 1 7.69%
Fabian Frederick 1 0.47% 1 7.69%
Jiri Slaby 1 0.47% 1 7.69%
Total 215 100.00% 13 100.00%

/**
 * firmware_data_write - write method for firmware
 * @filp: open sysfs file
 * @kobj: kobject for the device
 * @bin_attr: bin_attr structure
 * @buffer: buffer being written
 * @offset: buffer offset for write in total data store area
 * @count: buffer size
 *
 *      Data written to the 'data' attribute will be later handed to
 *      the driver as a firmware image.
 **/


static ssize_t firmware_data_write(struct file *filp, struct kobject *kobj,
				   struct bin_attribute *bin_attr,
				   char *buffer, loff_t offset, size_t count)
{
	struct device *dev = kobj_to_dev(kobj);
	struct fw_sysfs *fw_sysfs = to_fw_sysfs(dev);
	struct fw_priv *fw_priv;
	ssize_t retval;

	if (!capable(CAP_SYS_RAWIO))
		return -EPERM;

	mutex_lock(&fw_lock);
	fw_priv = fw_sysfs->fw_priv;
	if (!fw_priv || fw_sysfs_done(fw_priv)) {
		retval = -ENODEV;
		goto out;
	}

	if (fw_priv->data) {
		if (offset + count > fw_priv->allocated_size) {
			retval = -ENOMEM;
			goto out;
		}
		firmware_rw_data(fw_priv, buffer, offset, count, false);
		retval = count;
	} else {
		retval = fw_realloc_pages(fw_sysfs, offset + count);
		if (retval)
			goto out;

		retval = count;
		firmware_rw(fw_priv, buffer, offset, count, false);
	}

	fw_priv->size = max_t(size_t, offset + count, fw_priv->size);
out:
	mutex_unlock(&fw_lock);
	return retval;
}

Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 119 55.61% 1 14.29%
Stephen Boyd 51 23.83% 2 28.57%
Ming Lei 24 11.21% 1 14.29%
Luis R. Rodriguez 20 9.35% 3 42.86%
Total 214 100.00% 7 100.00%


static struct bin_attribute firmware_attr_data = {
	.attr = { .name = "data", .mode = 0644 },
	.size = 0,
	.read = firmware_data_read,
	.write = firmware_data_write,
};


static struct attribute *fw_dev_attrs[] = {
	&dev_attr_loading.attr,
	NULL
};


static struct bin_attribute *fw_dev_bin_attrs[] = {
	&firmware_attr_data,
	NULL
};


static const struct attribute_group fw_dev_attr_group = {
	.attrs = fw_dev_attrs,
	.bin_attrs = fw_dev_bin_attrs,
};


static const struct attribute_group *fw_dev_attr_groups[] = {
	&fw_dev_attr_group,
	NULL
};


static struct fw_sysfs *

fw_create_instance(struct firmware *firmware, const char *fw_name,
		   struct device *device, unsigned int opt_flags)
{
	struct fw_sysfs *fw_sysfs;
	struct device *f_dev;

	fw_sysfs = kzalloc(sizeof(*fw_sysfs), GFP_KERNEL);
	if (!fw_sysfs) {
		fw_sysfs = ERR_PTR(-ENOMEM);
		goto exit;
	}

	fw_sysfs->nowait = !!(opt_flags & FW_OPT_NOWAIT);
	fw_sysfs->fw = firmware;
	f_dev = &fw_sysfs->dev;

	device_initialize(f_dev);
	dev_set_name(f_dev, "%s", fw_name);
	f_dev->parent = device;
	f_dev->class = &firmware_class;
	f_dev->groups = fw_dev_attr_groups;
exit:
	return fw_sysfs;
}

Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 81 61.83% 3 50.00%
Ming Lei 39 29.77% 2 33.33%
Luis R. Rodriguez 11 8.40% 1 16.67%
Total 131 100.00% 6 100.00%

/* load a firmware via user helper */


static int _request_firmware_load(struct fw_sysfs *fw_sysfs,
				  unsigned int opt_flags, long timeout)
{
	int retval = 0;
	struct device *f_dev = &fw_sysfs->dev;
	struct fw_priv *fw_priv = fw_sysfs->fw_priv;

	/* fall back on userspace loading */
	if (!fw_priv->data)
		fw_priv->is_paged_buf = true;

	dev_set_uevent_suppress(f_dev, true);

	retval = device_add(f_dev);
	if (retval) {
		dev_err(f_dev, "%s: device_register failed\n", __func__);
		goto err_put_dev;
	}

	mutex_lock(&fw_lock);
	list_add(&fw_priv->pending_list, &pending_fw_head);
	mutex_unlock(&fw_lock);

	if (opt_flags & FW_OPT_UEVENT) {
		fw_priv->need_uevent = true;
		dev_set_uevent_suppress(f_dev, false);
		dev_dbg(f_dev, "firmware: requesting %s\n", fw_priv->fw_name);
		kobject_uevent(&fw_sysfs->dev.kobj, KOBJ_ADD);
	} else {
		timeout = MAX_JIFFY_OFFSET;
	}

	retval = fw_sysfs_wait_timeout(fw_priv, timeout);
	if (retval < 0) {
		mutex_lock(&fw_lock);
		fw_load_abort(fw_sysfs);
		mutex_unlock(&fw_lock);
	}

	if (fw_state_is_aborted(fw_priv)) {
		if (retval == -ERESTARTSYS)
			retval = -EINTR;
		else
			retval = -EAGAIN;
	} else if (fw_priv->is_paged_buf && !fw_priv->data)
		retval = -ENOMEM;

	device_del(f_dev);
err_put_dev:
	put_device(f_dev);
	return retval;
}

Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 123 48.24% 3 15.00%
Luis R. Rodriguez 35 13.73% 5 25.00%
Ming Lei 35 13.73% 4 20.00%
Maxime Bizon 22 8.63% 1 5.00%
zhang jun 13 5.10% 1 5.00%
Shuah Khan 11 4.31% 1 5.00%
Stephen Boyd 9 3.53% 1 5.00%
Björn Andersson 4 1.57% 1 5.00%
Manuel Estrada Sainz 1 0.39% 1 5.00%
Daniel Wagner 1 0.39% 1 5.00%
Kweh, Hock Leong 1 0.39% 1 5.00%
Total 255 100.00% 20 100.00%



static int fw_load_from_user_helper(struct firmware *firmware,
				    const char *name, struct device *device,
				    unsigned int opt_flags)
{
	struct fw_sysfs *fw_sysfs;
	long timeout;
	int ret;

	timeout = firmware_loading_timeout();
	if (opt_flags & FW_OPT_NOWAIT) {
		timeout = usermodehelper_read_lock_wait(timeout);
		if (!timeout) {
			dev_dbg(device, "firmware: %s loading timed out\n",
				name);
			return -EBUSY;
		}
	} else {
		ret = usermodehelper_read_trylock();
		if (WARN_ON(ret)) {
			dev_err(device, "firmware: %s will not be loaded\n",
				name);
			return ret;
		}
	}

	fw_sysfs = fw_create_instance(firmware, name, device, opt_flags);
	if (IS_ERR(fw_sysfs)) {
		ret = PTR_ERR(fw_sysfs);
		goto out_unlock;
	}

	fw_sysfs->fw_priv = firmware->priv;
	ret = _request_firmware_load(fw_sysfs, opt_flags, timeout);

	if (!ret)
		ret = assign_fw(firmware, device, opt_flags);

out_unlock:
	usermodehelper_read_unlock();

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Luis R. Rodriguez 117 65.00% 3 23.08%
Takashi Iwai 23 12.78% 3 23.08%
Manuel Estrada Sainz 18 10.00% 1 7.69%
David Woodhouse 7 3.89% 1 7.69%
Andrew Morton 6 3.33% 2 15.38%
Stephen Boyd 4 2.22% 1 7.69%
Ming Lei 3 1.67% 1 7.69%
Björn Helgaas 2 1.11% 1 7.69%
Total 180 100.00% 13 100.00%

#ifdef CONFIG_FW_LOADER_USER_HELPER_FALLBACK


static bool fw_force_sysfs_fallback(unsigned int opt_flags)
{
	return true;
}
Contributors
Person Tokens Prop Commits CommitProp
Luis R. Rodriguez 13 100.00% 1 100.00%
Total 13 100.00% 1 100.00%

#else


static bool fw_force_sysfs_fallback(unsigned int opt_flags)
{
	if (!(opt_flags & FW_OPT_USERHELPER))
		return false;
	return true;
}
Contributors
Person Tokens Prop Commits CommitProp
Luis R. Rodriguez 25 100.00% 1 100.00%
Total 25 100.00% 1 100.00%

#endif



static bool fw_run_sysfs_fallback(unsigned int opt_flags)
{
	if ((opt_flags & FW_OPT_NOFALLBACK))
		return false;

	return fw_force_sysfs_fallback(opt_flags);
}

Contributors
Person Tokens Prop Commits CommitProp
Luis R. Rodriguez 27 100.00% 1 100.00%
Total 27 100.00% 1 100.00%



static int fw_sysfs_fallback(struct firmware *fw, const char *name,
			    struct device *device,
			    unsigned int opt_flags,
			    int ret)
{
	if (!fw_run_sysfs_fallback(opt_flags))
		return ret;

	dev_warn(device, "Falling back to user helper\n");
	return fw_load_from_user_helper(fw, name, device, opt_flags);
}
Contributors
Person Tokens Prop Commits CommitProp
Luis R. Rodriguez 58 100.00% 2 100.00%
Total 58 100.00% 2 100.00%

#else /* CONFIG_FW_LOADER_USER_HELPER */


static int fw_sysfs_fallback(struct firmware *fw, const char *name,
			     struct device *device,
			     unsigned int opt_flags,
			     int ret)
{
	/* Keep carrying over the same error */
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 25 78.12% 3 75.00%
Luis R. Rodriguez 7 21.88% 1 25.00%
Total 32 100.00% 4 100.00%



static inline void kill_pending_fw_fallback_reqs(bool only_kill_custom) { }

Contributors
Person Tokens Prop Commits CommitProp
Ming Lei 6 66.67% 1 50.00%
Luis R. Rodriguez 3 33.33% 1 50.00%
Total 9 100.00% 2 100.00%



static inline int register_sysfs_loader(void)
{
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Luis R. Rodriguez 12 100.00% 1 100.00%
Total 12 100.00% 1 100.00%



static inline void unregister_sysfs_loader(void)
{
}

Contributors
Person Tokens Prop Commits CommitProp
Luis R. Rodriguez 8 100.00% 1 100.00%
Total 8 100.00% 1 100.00%

#endif /* CONFIG_FW_LOADER_USER_HELPER */

/* prepare firmware and firmware_buf structs;
 * return 0 if a firmware is already assigned, 1 if need to load one,
 * or a negative error code
 */

static int

_request_firmware_prepare(struct firmware **firmware_p, const char *name,
			  struct device *device, void *dbuf, size_t size)
{
	struct firmware *firmware;
	struct fw_priv *fw_priv;
	int ret;

	*firmware_p = firmware = kzalloc(sizeof(*firmware), GFP_KERNEL);
	if (!firmware) {
		dev_err(device, "%s: kmalloc(struct firmware) failed\n",
			__func__);
		return -ENOMEM;
	}

	if (fw_get_builtin_firmware(firmware, name, dbuf, size)) {
		dev_dbg(device, "using built-in %s\n", name);
		return 0; /* assigned */
	}

	ret = alloc_lookup_fw_priv(name, &fw_cache, &fw_priv, dbuf, size);

	/*
         * bind with 'priv' now to avoid warning in failure path
         * of requesting firmware.
         */
	firmware->priv = fw_priv;

	if (ret > 0) {
		ret = fw_state_wait(fw_priv);
		if (!ret) {
			fw_set_page_data(fw_priv, firmware);
			return 0; /* assigned */
		}
	}

	if (ret < 0)
		return ret;
	return 1; /* need to load */
}

Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 93 52.84% 2 10.53%
Stephen Boyd 35 19.89% 2 10.53%
Luis R. Rodriguez 9 5.11% 2 10.53%
Rafael J. Wysocki 9 5.11% 1 5.26%
Andrew Morton 8 4.55% 3 15.79%
Ming Lei 7 3.98% 3 15.79%
Manuel Estrada Sainz 6 3.41% 1 5.26%
Abhay Salunke 3 1.70% 1 5.26%
David Woodhouse 2 1.14% 1 5.26%
Dmitry Torokhov 2 1.14% 1 5.26%
Daniel Wagner 1 0.57% 1 5.26%
Greg Kroah-Hartman 1 0.57% 1 5.26%
Total 176 100.00% 19 100.00%

/*
 * Batched requests need only one wake, we need to do this step last due to the
 * fallback mechanism. The buf is protected with kref_get(), and it won't be
 * released until the last user calls release_firmware().
 *
 * Failed batched requests are possible as well, in such cases we just share
 * the struct fw_priv and won't release it until all requests are woken
 * and have gone through this same path.
 */


static void fw_abort_batch_reqs(struct firmware *fw)
{
	struct fw_priv *fw_priv;

	/* Loaded directly? */
	if (!fw || !fw->priv)
		return;

	fw_priv = fw->priv;
	if (!fw_state_is_aborted(fw_priv))
		fw_state_aborted(fw_priv);
}

Contributors
Person Tokens Prop Commits CommitProp
Luis R. Rodriguez 47 100.00% 2 100.00%
Total 47 100.00% 2 100.00%

/* called from request_firmware() and request_firmware_work_func() */

static int

_request_firmware(const struct firmware **firmware_p, const char *name,
		  struct device *device, void *buf, size_t size,
		  unsigned int opt_flags)
{
	struct firmware *fw = NULL;
	int ret;

	if (!firmware_p)
		return -EINVAL;

	if (!name || name[0] == '\0') {
		ret = -EINVAL;
		goto out;
	}

	ret = _request_firmware_prepare(&fw, name, device, buf, size);
	if (ret <= 0) /* error or already assigned */
		goto out;

	ret = fw_get_filesystem_firmware(device, fw->priv);
	if (ret) {
		if (!(opt_flags & FW_OPT_NO_WARN))
			dev_warn(device,
				 "Direct firmware load for %s failed with error %d\n",
				 name, ret);
		ret = fw_sysfs_fallback(fw, name, device, opt_flags, ret);
	} else
		ret = assign_fw(fw, device, opt_flags);

 out:
	if (ret < 0) {
		fw_abort_batch_reqs(fw);
		release_firmware(fw);
		fw = NULL;
	}

	*firmware_p = fw;
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 74 37.56% 3 16.67%
Rafael J. Wysocki 26 13.20% 2 11.11%
Abhay Salunke 25 12.69% 1 5.56%
Luis R. Rodriguez 17 8.63% 5 27.78%
Kees Cook 16 8.12% 1 5.56%
Neil Horman 14 7.11% 1 5.56%
Stephen Boyd 13 6.60% 2 11.11%
Brian Norris 10 5.08% 1 5.56%
Ming Lei 1 0.51% 1 5.56%
Johannes Berg 1 0.51% 1 5.56%
Total 197 100.00% 18 100.00%

/**
 * request_firmware: - send firmware request and wait for it
 * @firmware_p: pointer to firmware image
 * @name: name of firmware file
 * @device: device for which firmware is being loaded
 *
 *      @firmware_p will be used to return a firmware image by the name
 *      of @name for device @device.
 *
 *      Should be called from user context where sleeping is allowed.
 *
 *      @name will be used as $FIRMWARE in the uevent environment and
 *      should be distinctive enough not to be confused with any other
 *      firmware image for this or any other device.
 *
 *      Caller must hold the reference count of @device.
 *
 *      The function can be called safely inside device's suspend and
 *      resume callback.
 **/

int

request_firmware(const struct firmware **firmware_p, const char *name,
		 struct device *device)
{
	int ret;

	/* Need to pin this module until return */
	__module_get(THIS_MODULE);
	ret = _request_firmware(firmware_p, name, device, NULL, 0,
				FW_OPT_UEVENT);
	module_put(THIS_MODULE);
	return ret;
}
Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 33 58.93% 2 50.00%
Ming Lei 19 33.93% 1 25.00%
Stephen Boyd 4 7.14% 1 25.00%
Total 56 100.00% 4 100.00%

EXPORT_SYMBOL(request_firmware);

/**
 * request_firmware_direct: - load firmware directly without usermode helper
 * @firmware_p: pointer to firmware image
 * @name: name of firmware file
 * @device: device for which firmware is being loaded
 *
 * This function works pretty much like request_firmware(), but this doesn't
 * fall back to usermode helper even if the firmware couldn't be loaded
 * directly from fs.  Hence it's useful for loading optional firmwares, which
 * aren't always present, without extra long timeouts of udev.
 **/


int request_firmware_direct(const struct firmware **firmware_p,
			    const char *name, struct device *device)
{
	int ret;

	__module_get(THIS_MODULE);
	ret = _request_firmware(firmware_p, name, device, NULL, 0,
				FW_OPT_UEVENT | FW_OPT_NO_WARN |
				FW_OPT_NOFALLBACK);
	module_put(THIS_MODULE);
	return ret;
}
Contributors
Person Tokens Prop Commits CommitProp
Takashi Iwai 51 86.44% 2 40.00%
Luis R. Rodriguez 4 6.78% 2 40.00%
Stephen Boyd 4 6.78% 1 20.00%
Total 59 100.00% 5 100.00%

EXPORT_SYMBOL_GPL(request_firmware_direct);

/**
 * request_firmware_into_buf - load firmware into a previously allocated buffer
 * @firmware_p: pointer to firmware image
 * @name: name of firmware file
 * @device: device for which firmware is being loaded and DMA region allocated
 * @buf: address of buffer to load firmware into
 * @size: size of buffer
 *
 * This function works pretty much like request_firmware(), but it doesn't
 * allocate a buffer to hold the firmware data. Instead, the firmware
 * is loaded directly into the buffer pointed to by @buf and the @firmware_p
 * data member is pointed at @buf.
 *
 * This function doesn't cache firmware either.
 */

int

request_firmware_into_buf(const struct firmware **firmware_p, const char *name,
			  struct device *device, void *buf, size_t size)
{
	int ret;

	__module_get(THIS_MODULE);
	ret = _request_firmware(firmware_p, name, device, buf, size,
				FW_OPT_UEVENT | FW_OPT_NOCACHE);
	module_put(THIS_MODULE);
	return ret;
}
Contributors
Person Tokens Prop Commits CommitProp
Stephen Boyd 64 100.00% 1 100.00%
Total 64 100.00% 1 100.00%

EXPORT_SYMBOL(request_firmware_into_buf);

/**
 * release_firmware: - release the resource associated with a firmware image
 * @fw: firmware resource to release
 **/


void release_firmware(const struct firmware *fw)
{
	if (fw) {
		if (!fw_is_builtin_firmware(fw))
			firmware_free_data(fw);
		kfree(fw);
	}
}
Contributors
Person Tokens Prop Commits CommitProp
Manuel Estrada Sainz 25 71.43% 1 25.00%
Dmitry Torokhov 5 14.29% 1 25.00%
David Woodhouse 5 14.29% 2 50.00%
Total 35 100.00% 4 100.00%

EXPORT_SYMBOL(release_firmware);

/* Async support */

struct firmware_work {
	
struct work_struct work;
	
struct module *module;
	
const char *name;
	
struct device *device;
	
void *context;
	
void (*cont)(const struct firmware *fw, void *context);
	
unsigned int opt_flags;
};



static void request_firmware_work_func(struct work_struct *work)
{
	struct firmware_work *fw_work;
	const struct firmware *fw;

	fw_work = container_of(work, struct firmware_work, work);

	_request_firmware(&fw, fw_work->name, fw_work->device, NULL, 0,
			  fw_work->opt_flags);
	fw_work->cont(fw, fw_work->context);
	put_device(fw_work->device); /* taken in request_firmware_nowait() */

	module_put(fw_work->module);
	kfree_const(fw_work->name);
	kfree(fw_work);
}

Contributors
Person Tokens Prop Commits CommitProp
Manuel Estrada Sainz 52 55.32% 1 10.00%
Stephen Boyd 20 21.28% 3 30.00%
Ming Lei 7 7.45% 1 10.00%
Luis R. Rodriguez 7 7.45% 1 10.00%
Andrew Morton 3 3.19% 1 10.00%
Takashi Iwai 3 3.19% 2 20.00%
Rafael J. Wysocki 2 2.13% 1 10.00%
Total 94 100.00% 10 100.00%

/**
 * request_firmware_nowait - asynchronous version of request_firmware
 * @module: module requesting the firmware
 * @uevent: sends uevent to copy the firmware image if this flag
 *      is non-zero else the firmware copy must be done manually.
 * @name: name of firmware file
 * @device: device for which firmware is being loaded
 * @gfp: allocation flags
 * @context: will be passed over to @cont, and
 *      @fw may be %NULL if firmware request fails.
 * @cont: function will be called asynchronously when the firmware
 *      request is over.
 *
 *      Caller must hold the reference count of @device.
 *
 *      Asynchronous variant of request_firmware() for user contexts:
 *              - sleep for as small periods as possible since it may
 *                increase kernel boot time of built-in device drivers
 *                requesting firmware in their ->probe() methods, if
 *                @gfp is GFP_KERNEL.
 *
 *              - can't sleep at all if @gfp is GFP_ATOMIC.
 **/

int

request_firmware_nowait(
	struct module *module, bool uevent,
	const char *name, struct device *device, gfp_t gfp, void *context,
	void (*cont)(const struct firmware *fw, void *context))
{
	struct firmware_work *fw_work;

	fw_work = kzalloc(sizeof(struct firmware_work), gfp);
	if (!fw_work)
		return -ENOMEM;

	fw_work->module = module;
	fw_work->name = kstrdup_const(name, gfp);
	if (!fw_work->name) {
		kfree(fw_work);
		return -ENOMEM;
	}
	fw_work->device = device;
	fw_work->context = context;
	fw_work->cont = cont;
	fw_work->opt_flags = FW_OPT_NOWAIT |
		(uevent ? FW_OPT_UEVENT : FW_OPT_USERHELPER);

	if (!try_module_get(module)) {
		kfree_const(fw_work->name);
		kfree(fw_work);
		return -EFAULT;
	}

	get_device(fw_work->device);
	INIT_WORK(&fw_work->work, request_firmware_work_func);
	schedule_work(&fw_work->work);
	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
Manuel Estrada Sainz 85 43.59% 1 7.14%
Dmitry Torokhov 40 20.51% 1 7.14%
Luis R. Rodriguez 30 15.38% 2 14.29%
Takashi Iwai 9 4.62% 2 14.29%
Ming Lei 7 3.59% 1 7.14%
Stephen Boyd 7 3.59% 1 7.14%
Matthieu Castet 5 2.56% 1 7.14%
Johannes Berg 4 2.05% 1 7.14%
Andrew Morton 3 1.54% 1 7.14%
Abhay Salunke 2 1.03% 1 7.14%
Kay Sievers 2 1.03% 1 7.14%
Bob Liu 1 0.51% 1 7.14%
Total 195 100.00% 14 100.00%

EXPORT_SYMBOL(request_firmware_nowait);

#ifdef CONFIG_PM_SLEEP
static ASYNC_DOMAIN_EXCLUSIVE(fw_cache_domain);

/**
 * cache_firmware - cache one firmware image in kernel memory space
 * @fw_name: the firmware image name
 *
 * Cache firmware in kernel memory so that drivers can use it when
 * system isn't ready for them to request firmware image from userspace.
 * Once it returns successfully, driver can use request_firmware or its
 * nowait version to get the cached firmware without any interacting
 * with userspace
 *
 * Return 0 if the firmware image has been cached successfully
 * Return !0 otherwise
 *
 */


static int cache_firmware(const char *fw_name)
{
	int ret;
	const struct firmware *fw;

	pr_debug("%s: %s\n", __func__, fw_name);

	ret = request_firmware(&fw, fw_name, NULL);
	if (!ret)
		kfree(fw);

	pr_debug("%s: %s ret=%d\n", __func__, fw_name, ret);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Ming Lei 65 100.00% 2 100.00%
Total 65 100.00% 2 100.00%



static struct fw_priv *lookup_fw_priv(const char *fw_name)
{
	struct fw_priv *tmp;
	struct firmware_cache *fwc = &fw_cache;

	spin_lock(&fwc->lock);
	tmp = __lookup_fw_priv(fw_name);
	spin_unlock(&fwc->lock);

	return tmp;
}

Contributors
Person Tokens Prop Commits CommitProp
Ming Lei 48 92.31% 1 50.00%
Luis R. Rodriguez 4 7.69% 1 50.00%
Total 52 100.00% 2 100.00%

/**
 * uncache_firmware - remove one cached firmware image
 * @fw_name: the firmware image name
 *
 * Uncache one firmware image which has been cached successfully
 * before.
 *
 * Return 0 if the firmware cache has been removed successfully
 * Return !0 otherwise
 *
 */


static int uncache_firmware(const char *fw_name)
{
	struct fw_priv *fw_priv;
	struct firmware fw;

	pr_debug("%s: %s\n", __func__, fw_name);

	if (fw_get_builtin_firmware(&fw, fw_name, NULL, 0))
		return 0;

	fw_priv = lookup_fw_priv(fw_name);
	if (fw_priv) {
		free_fw_priv(fw_priv);
		return 0;
	}

	return -EINVAL;
}

Contributors
Person Tokens Prop Commits CommitProp
Ming Lei 60 84.51% 2 50.00%
Luis R. Rodriguez 7 9.86% 1 25.00%
Stephen Boyd 4 5.63% 1 25.00%
Total 71 100.00% 4 100.00%



static struct fw_cache_entry *alloc_fw_cache_entry(const char *name)
{
	struct fw_cache_entry *fce;

	fce = kzalloc(sizeof(*fce), GFP_ATOMIC);
	if (!fce)
		goto exit;

	fce->name = kstrdup_const(name, GFP_ATOMIC);
	if (!fce->name) {
		kfree(fce);
		fce = NULL;
		goto exit;
	}
exit:
	return fce;
}

Contributors
Person Tokens Prop Commits CommitProp
Ming Lei 51 67.11% 1 50.00%
Luis R. Rodriguez 25 32.89% 1 50.00%
Total 76 100.00% 2 100.00%



static int __fw_entry_found(const char *name)
{
	struct firmware_cache *fwc = &fw_cache;
	struct fw_cache_entry *fce;

	list_for_each_entry(fce, &fwc->fw_names, list) {
		if (!strcmp(fce->name, name))
			return 1;
	}
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Ming Lei 52 100.00% 2 100.00%
Total 52 100.00% 2 100.00%



static int fw_cache_piggyback_on_request(const char *name)
{
	struct firmware_cache *fwc = &fw_cache;
	struct fw_cache_entry *fce;
	int ret = 0;

	spin_lock(&fwc->name_lock);
	if (__fw_entry_found(name))
		goto found;

	fce = alloc_fw_cache_entry(name);
	if (fce) {
		ret = 1;
		list_add(&fce->list, &fwc->fw_names);
		pr_debug("%s: fw: %s\n", __func__, name);
	}
found:
	spin_unlock(&fwc->name_lock);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Ming Lei 99 100.00% 2 100.00%
Total 99 100.00% 2 100.00%



static void free_fw_cache_entry(struct fw_cache_entry *fce)
{
	kfree_const(fce->name);
	kfree(fce);
}

Contributors
Person Tokens Prop Commits CommitProp
Ming Lei 16 69.57% 1 50.00%
Luis R. Rodriguez 7 30.43% 1 50.00%
Total 23 100.00% 2 100.00%



static void __async_dev_cache_fw_image(void *fw_entry,
				       async_cookie_t cookie)
{
	struct fw_cache_entry *fce = fw_entry;
	struct firmware_cache *fwc = &fw_cache;
	int ret;

	ret = cache_firmware(fce->name);
	if (ret) {
		spin_lock(&fwc->name_lock);
		list_del(&fce->list);
		spin_unlock(&fwc->name_lock);

		free_fw_cache_entry(fce);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Ming Lei 75 100.00% 2 100.00%
Total 75 100.00% 2 100.00%

/* called with dev->devres_lock held */


static void dev_create_fw_entry(struct device *dev, void *res,
				void *data)
{
	struct fw_name_devm *fwn = res;
	const char *fw_name = fwn->name;
	struct list_head *head = data;
	struct fw_cache_entry *fce;

	fce = alloc_fw_cache_entry(fw_name);
	if (fce)
		list_add(&fce->list, head);
}

Contributors
Person Tokens Prop Commits CommitProp
Ming Lei 68 100.00% 1 100.00%
Total 68 100.00% 1 100.00%



static int devm_name_match(struct device *dev, void *res,
			   void *match_data)
{
	struct fw_name_devm *fwn = res;
	return (fwn->magic == (unsigned long)match_data);
}

Contributors
Person Tokens Prop Commits CommitProp
Ming Lei 39 100.00% 1 100.00%
Total 39 100.00% 1 100.00%



static void dev_cache_fw_image(struct device *dev, void *data)
{
	LIST_HEAD(todo);
	struct fw_cache_entry *fce;
	struct fw_cache_entry *fce_next;
	struct firmware_cache *fwc = &fw_cache;

	devres_for_each_res(dev, fw_name_devm_release,
			    devm_name_match, &fw_cache,
			    dev_create_fw_entry, &todo);

	list_for_each_entry_safe(fce, fce_next, &todo, list) {
		list_del(&fce->list);

		spin_lock(&fwc->name_lock);
		/* only one cache entry for one firmware */
		if (!__fw_entry_found(fce->name)) {
			list_add(&fce->list, &fwc->fw_names);
		} else {
			free_fw_cache_entry(fce);
			fce = NULL;
		}
		spin_unlock(&fwc->name_lock);

		if (fce)
			async_schedule_domain(__async_dev_cache_fw_image,
					      (void *)fce,
					      &fw_cache_domain);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Ming Lei 147 100.00% 5 100.00%
Total 147 100.00% 5 100.00%



static void __device_uncache_fw_images(void)
{
	struct firmware_cache *fwc = &fw_cache;
	struct fw_cache_entry *fce;

	spin_lock(&fwc->name_lock);
	while (!list_empty(&fwc->fw_names)) {
		fce = list_entry(fwc->fw_names.next,
				struct fw_cache_entry, list);
		list_del(&fce->list);
		spin_unlock(&fwc->name_lock);

		uncache_firmware(fce->name);
		free_fw_cache_entry(fce);

		spin_lock(&fwc->name_lock);
	}
	spin_unlock(&fwc->name_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
Ming Lei 102 100.00% 1 100.00%
Total 102 100.00% 1 100.00%

/**
 * device_cache_fw_images - cache devices' firmware
 *
 * If one device called request_firmware or its nowait version
 * successfully before, the firmware names are recored into the
 * device's devres link list, so device_cache_fw_images can call
 * cache_firmware() to cache these firmwares for the device,
 * then the device driver can load its firmwares easily at
 * time when system is not ready to complete loading firmware.
 */


static void device_cache_fw_images(void)
{
	struct firmware_cache *fwc = &fw_cache;
	int old_timeout;
	DEFINE_WAIT(wait);

	pr_debug("%s\n", __func__);

	/* cancel uncache work */
	cancel_delayed_work_sync(&fwc->work);

	/*
         * use small loading timeout for caching devices' firmware
         * because all these firmware images have been loaded
         * successfully at lease once, also system is ready for
         * completing firmware loading now. The maximum size of
         * firmware in current distributions is about 2M bytes,
         * so 10 secs should be enough.
         */
	old_timeout = loading_timeout;
	loading_timeout = 10;

	mutex_lock(&fw_lock);
	fwc->state = FW_LOADER_START_CACHE;
	dpm_for_each_dev(NULL, dev_cache_fw_image);
	mutex_unlock(&fw_lock);

	/* wait for completion of caching firmware for all devices */
	async_synchronize_full_domain(&fw_cache_domain);

	loading_timeout = old_timeout;
}

Contributors
Person Tokens Prop Commits CommitProp
Ming Lei 85 100.00% 6 100.00%
Total 85 100.00% 6 100.00%

/**
 * device_uncache_fw_images - uncache devices' firmware
 *
 * uncache all firmwares which have been cached successfully
 * by device_uncache_fw_images earlier
 */


static void device_uncache_fw_images(void)
{
	pr_debug("%s\n", __func__);
	__device_uncache_fw_images();
}

Contributors
Person Tokens Prop Commits CommitProp
Ming Lei 18 100.00% 1 100.00%
Total 18 100.00% 1 100.00%



static void device_uncache_fw_images_work(struct work_struct *work)
{
	device_uncache_fw_images();
}

Contributors
Person Tokens Prop Commits CommitProp
Ming Lei 14 100.00% 1 100.00%
Total 14 100.00% 1 100.00%

/**
 * device_uncache_fw_images_delay - uncache devices firmwares
 * @delay: number of milliseconds to delay uncache device firmwares
 *
 * uncache all devices's firmwares which has been cached successfully
 * by device_cache_fw_images after @delay milliseconds.
 */


static void device_uncache_fw_images_delay(unsigned long delay)
{
	queue_delayed_work(system_power_efficient_wq, &fw_cache.work,
			   msecs_to_jiffies(delay));
}

Contributors
Person Tokens Prop Commits CommitProp
Ming Lei 22 88.00% 1 50.00%
Shaibal Dutta 3 12.00% 1 50.00%
Total 25 100.00% 2 100.00%



static int fw_pm_notify(struct notifier_block *notify_block,
			unsigned long mode, void *unused)
{
	switch (mode) {
	case PM_HIBERNATION_PREPARE:
	case PM_SUSPEND_PREPARE:
	case PM_RESTORE_PREPARE:
		/*
                 * kill pending fallback requests with a custom fallback
                 * to avoid stalling suspend.
                 */
		kill_pending_fw_fallback_reqs(true);
		device_cache_fw_images();
		break;

	case PM_POST_SUSPEND:
	case PM_POST_HIBERNATION:
	case PM_POST_RESTORE:
		/*
                 * In case that system sleep failed and syscore_suspend is
                 * not called.
                 */
		mutex_lock(&fw_lock);
		fw_cache.state = FW_LOADER_NO_CACHE;
		mutex_unlock(&fw_lock);

		device_uncache_fw_images_delay(10 * MSEC_PER_SEC);
		break;
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Ming Lei 75 90.36% 3 60.00%
Luis R. Rodriguez 5 6.02% 1 20.00%
Sebastian Capella 3 3.61% 1 20.00%
Total 83 100.00% 5 100.00%

/* stop caching firmware once syscore_suspend is reached */


static int fw_suspend(void)
{
	fw_cache.state = FW_LOADER_NO_CACHE;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Ming Lei 17 100.00% 1 100.00%
Total 17 100.00% 1 100.00%


static struct syscore_ops fw_syscore_ops = {
	.suspend = fw_suspend,
};



static int __init register_fw_pm_ops(void)
{
	int ret;

	spin_lock_init(&fw_cache.name_lock);
	INIT_LIST_HEAD(&fw_cache.fw_names);

	INIT_DELAYED_WORK(&fw_cache.work,
			  device_uncache_fw_images_work);

	fw_cache.pm_notify.notifier_call = fw_pm_notify;
	ret = register_pm_notifier(&fw_cache.pm_notify);
	if (ret)
		return ret;

	register_syscore_ops(&fw_syscore_ops);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Luis R. Rodriguez 72 100.00% 1 100.00%
Total 72 100.00% 1 100.00%



static inline void unregister_fw_pm_ops(void)
{
	unregister_syscore_ops(&fw_syscore_ops);
	unregister_pm_notifier(&fw_cache.pm_notify);
}
Contributors
Person Tokens Prop Commits CommitProp
Luis R. Rodriguez 23 100.00% 1 100.00%
Total 23 100.00% 1 100.00%

#else


static int fw_cache_piggyback_on_request(const char *name)
{
	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
Ming Lei 14 100.00% 1 100.00%
Total 14 100.00% 1 100.00%



static inline int register_fw_pm_ops(void)
{
	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
Luis R. Rodriguez 12 100.00% 1 100.00%
Total 12 100.00% 1 100.00%



static inline void unregister_fw_pm_ops(void)
{
}
Contributors
Person Tokens Prop Commits CommitProp
Luis R. Rodriguez 8 100.00% 1 100.00%
Total 8 100.00% 1 100.00%

#endif



static void __init fw_cache_init(void)
{
	spin_lock_init(&fw_cache.lock);
	INIT_LIST_HEAD(&fw_cache.head);
	fw_cache.state = FW_LOADER_NO_CACHE;
}

Contributors
Person Tokens Prop Commits CommitProp
Ming Lei 31 100.00% 2 100.00%
Total 31 100.00% 2 100.00%



static int fw_shutdown_notify(struct notifier_block *unused1,
			      unsigned long unused2, void *unused3)
{
	/*
         * Kill all pending fallback requests to avoid both stalling shutdown,
         * and avoid a deadlock with the usermode_lock.
         */
	kill_pending_fw_fallback_reqs(false);

	return NOTIFY_DONE;
}

Contributors
Person Tokens Prop Commits CommitProp
Luis R. Rodriguez 28 100.00% 1 100.00%
Total 28 100.00% 1 100.00%


static struct notifier_block fw_shutdown_nb = {
	.notifier_call = fw_shutdown_notify,
};



static int __init firmware_class_init(void)
{
	int ret;

	/* No need to unfold these on exit */
	fw_cache_init();

	ret = register_fw_pm_ops();
	if (ret)
		return ret;

	ret = register_reboot_notifier(&fw_shutdown_nb);
	if (ret)
		goto out;

	return register_sysfs_loader();

out:
	unregister_fw_pm_ops();
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Luis R. Rodriguez 35 63.64% 3 37.50%
Manuel Estrada Sainz 9 16.36% 1 12.50%
Takashi Iwai 7 12.73% 2 25.00%
Ming Lei 3 5.45% 1 12.50%
Andrew Morton 1 1.82% 1 12.50%
Total 55 100.00% 8 100.00%



static void __exit firmware_class_exit(void)
{
	unregister_fw_pm_ops();
	unregister_reboot_notifier(&fw_shutdown_nb);
	unregister_sysfs_loader();
}

Contributors
Person Tokens Prop Commits CommitProp
Manuel Estrada Sainz 10 47.62% 1 20.00%
Takashi Iwai 6 28.57% 1 20.00%
Luis R. Rodriguez 4 19.05% 2 40.00%
Ming Lei 1 4.76% 1 20.00%
Total 21 100.00% 5 100.00%

fs_initcall(firmware_class_init);
module_exit(firmware_class_exit);
Overall Contributors
Person Tokens Prop Commits CommitProp
Ming Lei 1941 26.46% 27 17.76%
Luis R. Rodriguez 1759 23.98% 34 22.37%
Takashi Iwai 1585 21.61% 8 5.26%
Stephen Boyd 506 6.90% 4 2.63%
Manuel Estrada Sainz 498 6.79% 2 1.32%
Daniel Wagner 136 1.85% 4 2.63%
Dmitry Torokhov 135 1.84% 2 1.32%
Linus Torvalds 111 1.51% 2 1.32%
Andrew Morton 88 1.20% 7 4.61%
David Woodhouse 71 0.97% 3 1.97%
Kees Cook 69 0.94% 3 1.97%
Greg Kroah-Hartman 58 0.79% 7 4.61%
Rafael J. Wysocki 56 0.76% 2 1.32%
Chuansheng Liu 38 0.52% 2 1.32%
Neil Horman 33 0.45% 2 1.32%
Abhay Salunke 31 0.42% 1 0.66%
Mimi Zohar 26 0.35% 1 0.66%
Maxime Bizon 22 0.30% 1 0.66%
zhang jun 22 0.30% 1 0.66%
Björn Andersson 20 0.27% 1 0.66%
Daniel Mack 15 0.20% 1 0.66%
Kay Sievers 12 0.16% 3 1.97%
Shuah Khan 11 0.15% 1 0.66%
Brian Norris 10 0.14% 1 0.66%
Rui Zhang 8 0.11% 1 0.66%
Johannes Berg 7 0.10% 2 1.32%
Chris Wright 5 0.07% 1 0.66%
Matthieu Castet 5 0.07% 1 0.66%
Andi Kleen 5 0.07% 1 0.66%
Stanislaw W. Gruszka 5 0.07% 1 0.66%
Chen Feng 4 0.05% 1 0.66%
Randy Dunlap 4 0.05% 2 1.32%
Bart Van Assche 4 0.05% 1 0.66%
Jeff Moyer 4 0.05% 1 0.66%
Sebastian Capella 3 0.04% 1 0.66%
Laura Garcia Liebana 3 0.04% 1 0.66%
Tejun Heo 3 0.04% 1 0.66%
Shaibal Dutta 3 0.04% 1 0.66%
Markus Rechberger 2 0.03% 1 0.66%
Sukadev Bhattiprolu 2 0.03% 1 0.66%
Björn Helgaas 2 0.03% 1 0.66%
Adrian Bunk 2 0.03% 1 0.66%
Kweh, Hock Leong 1 0.01% 1 0.66%
Akinobu Mita 1 0.01% 1 0.66%
Christoph Hellwig 1 0.01% 1 0.66%
Dave Jones 1 0.01% 1 0.66%
Lars-Peter Clausen 1 0.01% 1 0.66%
Fabian Frederick 1 0.01% 1 0.66%
David Shaohua Li 1 0.01% 1 0.66%
Silvio Fricke 1 0.01% 1 0.66%
Borislav Petkov 1 0.01% 1 0.66%
Vladimir Zapolskiy 1 0.01% 1 0.66%
Jiri Slaby 1 0.01% 1 0.66%
Bob Liu 1 0.01% 1 0.66%
Total 7336 100.00% 152 100.00%
Directory: drivers/base

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.
Person	Tokens	Prop	Commits	CommitProp
Luis R. Rodriguez	25	100.00%	2	100.00%
Total	25	100.00%	2	100.00%
cregit-Linux how code gets into the kernel

Release 4.16 drivers/base/firmware_class.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors
