[deliverable/linux.git] / drivers / base / firmware_class.c

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

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)
{
	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;
			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)
{
	return false;
}

static inline bool fw_is_builtin_firmware(const struct firmware *fw)
{
	return false;
}
#endif

enum {
	FW_STATUS_LOADING,
	FW_STATUS_DONE,
	FW_STATUS_ABORT,
};

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

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

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

struct firmware_priv {
	struct completion completion;
	struct firmware *fw;
	unsigned long status;
	struct page **pages;
	int nr_pages;
	int page_array_size;
	struct timer_list timeout;
	struct device dev;
	bool nowait;
	char fw_id[];
};

static struct firmware_priv *to_firmware_priv(struct device *dev)
{
	return container_of(dev, struct firmware_priv, dev);
}

static void fw_load_abort(struct firmware_priv *fw_priv)
{
	set_bit(FW_STATUS_ABORT, &fw_priv->status);
	wmb();
	complete(&fw_priv->completion);
}

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

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

static struct class_attribute firmware_class_attrs[] = {
	__ATTR(timeout, S_IWUSR | S_IRUGO,
		firmware_timeout_show, firmware_timeout_store),
	__ATTR_NULL
};

static void fw_dev_release(struct device *dev)
{
	struct firmware_priv *fw_priv = to_firmware_priv(dev);
	int i;

	for (i = 0; i < fw_priv->nr_pages; i++)
		__free_page(fw_priv->pages[i]);
	kfree(fw_priv->pages);
	kfree(fw_priv);

	module_put(THIS_MODULE);
}

static int firmware_uevent(struct device *dev, struct kobj_uevent_env *env)
{
	struct firmware_priv *fw_priv = to_firmware_priv(dev);

	if (add_uevent_var(env, "FIRMWARE=%s", fw_priv->fw_id))
		return -ENOMEM;
	if (add_uevent_var(env, "TIMEOUT=%i", loading_timeout))
		return -ENOMEM;
	if (add_uevent_var(env, "ASYNC=%d", fw_priv->nowait))
		return -ENOMEM;

	return 0;
}

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

static ssize_t firmware_loading_show(struct device *dev,
				     struct device_attribute *attr, char *buf)
{
	struct firmware_priv *fw_priv = to_firmware_priv(dev);
	int loading = test_bit(FW_STATUS_LOADING, &fw_priv->status);

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

static void firmware_free_data(const struct firmware *fw)
{
	int i;
	vunmap(fw->data);
	if (fw->pages) {
		for (i = 0; i < PFN_UP(fw->size); i++)
			__free_page(fw->pages[i]);
		kfree(fw->pages);
	}
}

/* Some architectures don't have PAGE_KERNEL_RO */
#ifndef PAGE_KERNEL_RO
#define PAGE_KERNEL_RO PAGE_KERNEL
#endif
/**
 * 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 firmware_priv *fw_priv = to_firmware_priv(dev);
	int loading = simple_strtol(buf, NULL, 10);
	int i;

	mutex_lock(&fw_lock);

	if (!fw_priv->fw)
		goto out;

	switch (loading) {
	case 1:
		firmware_free_data(fw_priv->fw);
		memset(fw_priv->fw, 0, sizeof(struct firmware));
		/* If the pages are not owned by 'struct firmware' */
		for (i = 0; i < fw_priv->nr_pages; i++)
			__free_page(fw_priv->pages[i]);
		kfree(fw_priv->pages);
		fw_priv->pages = NULL;
		fw_priv->page_array_size = 0;
		fw_priv->nr_pages = 0;
		set_bit(FW_STATUS_LOADING, &fw_priv->status);
		break;
	case 0:
		if (test_bit(FW_STATUS_LOADING, &fw_priv->status)) {
			vunmap(fw_priv->fw->data);
			fw_priv->fw->data = vmap(fw_priv->pages,
						 fw_priv->nr_pages,
						 0, PAGE_KERNEL_RO);
			if (!fw_priv->fw->data) {
				dev_err(dev, "%s: vmap() failed\n", __func__);
				goto err;
			}
			/* Pages are now owned by 'struct firmware' */
			fw_priv->fw->pages = fw_priv->pages;
			fw_priv->pages = NULL;

			fw_priv->page_array_size = 0;
			fw_priv->nr_pages = 0;
			complete(&fw_priv->completion);
			clear_bit(FW_STATUS_LOADING, &fw_priv->status);
			break;
		}
		/* fallthrough */
	default:
		dev_err(dev, "%s: unexpected value (%d)\n", __func__, loading);
		/* fallthrough */
	case -1:
	err:
		fw_load_abort(fw_priv);
		break;
	}
out:
	mutex_unlock(&fw_lock);
	return count;
}

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

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 firmware_priv *fw_priv = to_firmware_priv(dev);
	struct firmware *fw;
	ssize_t ret_count;

	mutex_lock(&fw_lock);
	fw = fw_priv->fw;
	if (!fw || test_bit(FW_STATUS_DONE, &fw_priv->status)) {
		ret_count = -ENODEV;
		goto out;
	}
	if (offset > fw->size) {
		ret_count = 0;
		goto out;
	}
	if (count > fw->size - offset)
		count = fw->size - offset;

	ret_count = count;

	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]);

		memcpy(buffer, page_data + page_ofs, page_cnt);

		kunmap(fw_priv->pages[page_nr]);
		buffer += page_cnt;
		offset += page_cnt;
		count -= page_cnt;
	}
out:
	mutex_unlock(&fw_lock);
	return ret_count;
}

static int fw_realloc_buffer(struct firmware_priv *fw_priv, int min_size)
{
	int pages_needed = ALIGN(min_size, PAGE_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 = kmalloc(new_array_size * sizeof(void *),
				    GFP_KERNEL);
		if (!new_pages) {
			fw_load_abort(fw_priv);
			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));
		kfree(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_priv);
			return -ENOMEM;
		}
		fw_priv->nr_pages++;
	}
	return 0;
}

/**
 * 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 firmware_priv *fw_priv = to_firmware_priv(dev);
	struct firmware *fw;
	ssize_t retval;

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

	mutex_lock(&fw_lock);
	fw = fw_priv->fw;
	if (!fw || test_bit(FW_STATUS_DONE, &fw_priv->status)) {
		retval = -ENODEV;
		goto out;
	}
	retval = fw_realloc_buffer(fw_priv, offset + count);
	if (retval)
		goto out;

	retval = count;

	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]);

		memcpy(page_data + page_ofs, buffer, page_cnt);

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

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

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

static void firmware_class_timeout(u_long data)
{
	struct firmware_priv *fw_priv = (struct firmware_priv *) data;

	fw_load_abort(fw_priv);
}

static struct firmware_priv *
fw_create_instance(struct firmware *firmware, const char *fw_name,
		   struct device *device, bool uevent, bool nowait)
{
	struct firmware_priv *fw_priv;
	struct device *f_dev;

	fw_priv = kzalloc(sizeof(*fw_priv) + strlen(fw_name) + 1 , GFP_KERNEL);
	if (!fw_priv) {
		dev_err(device, "%s: kmalloc failed\n", __func__);
		return ERR_PTR(-ENOMEM);
	}

	fw_priv->fw = firmware;
	fw_priv->nowait = nowait;
	strcpy(fw_priv->fw_id, fw_name);
	init_completion(&fw_priv->completion);
	setup_timer(&fw_priv->timeout,
		    firmware_class_timeout, (u_long) fw_priv);

	f_dev = &fw_priv->dev;

	device_initialize(f_dev);
	dev_set_name(f_dev, "%s", dev_name(device));
	f_dev->parent = device;
	f_dev->class = &firmware_class;

	return fw_priv;
}

static struct firmware_priv *
_request_firmware_prepare(const struct firmware **firmware_p, const char *name,
			  struct device *device, bool uevent, bool nowait)
{
	struct firmware *firmware;
	struct firmware_priv *fw_priv;

	if (!firmware_p)
		return ERR_PTR(-EINVAL);

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

	if (fw_get_builtin_firmware(firmware, name)) {
		dev_dbg(device, "firmware: using built-in firmware %s\n", name);
		return NULL;
	}

	fw_priv = fw_create_instance(firmware, name, device, uevent, nowait);
	if (IS_ERR(fw_priv)) {
		release_firmware(firmware);
		*firmware_p = NULL;
	}
	return fw_priv;
}

static void _request_firmware_cleanup(const struct firmware **firmware_p)
{
	release_firmware(*firmware_p);
	*firmware_p = NULL;
}

static int _request_firmware_load(struct firmware_priv *fw_priv, bool uevent,
				  long timeout)
{
	int retval = 0;
	struct device *f_dev = &fw_priv->dev;

	dev_set_uevent_suppress(f_dev, true);

	/* Need to pin this module until class device is destroyed */
	__module_get(THIS_MODULE);

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

	retval = device_create_bin_file(f_dev, &firmware_attr_data);
	if (retval) {
		dev_err(f_dev, "%s: sysfs_create_bin_file failed\n", __func__);
		goto err_del_dev;
	}

	retval = device_create_file(f_dev, &dev_attr_loading);
	if (retval) {
		dev_err(f_dev, "%s: device_create_file failed\n", __func__);
		goto err_del_bin_attr;
	}

	if (uevent) {
		dev_set_uevent_suppress(f_dev, false);
		dev_dbg(f_dev, "firmware: requesting %s\n", fw_priv->fw_id);
		if (timeout != MAX_SCHEDULE_TIMEOUT)
			mod_timer(&fw_priv->timeout,
				  round_jiffies_up(jiffies + timeout));

		kobject_uevent(&fw_priv->dev.kobj, KOBJ_ADD);
	}

	wait_for_completion(&fw_priv->completion);

	set_bit(FW_STATUS_DONE, &fw_priv->status);
	del_timer_sync(&fw_priv->timeout);

	mutex_lock(&fw_lock);
	if (!fw_priv->fw->size || test_bit(FW_STATUS_ABORT, &fw_priv->status))
		retval = -ENOENT;
	fw_priv->fw = NULL;
	mutex_unlock(&fw_lock);

	device_remove_file(f_dev, &dev_attr_loading);
err_del_bin_attr:
	device_remove_bin_file(f_dev, &firmware_attr_data);
err_del_dev:
	device_del(f_dev);
err_put_dev:
	put_device(f_dev);
	return retval;
}

/**
 * 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.
 **/
int
request_firmware(const struct firmware **firmware_p, const char *name,
                 struct device *device)
{
	struct firmware_priv *fw_priv;
	int ret;

	fw_priv = _request_firmware_prepare(firmware_p, name, device, true,
					    false);
	if (IS_ERR_OR_NULL(fw_priv))
		return PTR_RET(fw_priv);

	ret = usermodehelper_read_trylock();
	if (WARN_ON(ret)) {
		dev_err(device, "firmware: %s will not be loaded\n", name);
	} else {
		ret = _request_firmware_load(fw_priv, true,
					firmware_loading_timeout());
		usermodehelper_read_unlock();
	}
	if (ret)
		_request_firmware_cleanup(firmware_p);

	return ret;
}

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

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

static void request_firmware_work_func(struct work_struct *work)
{
	struct firmware_work *fw_work;
	const struct firmware *fw;
	struct firmware_priv *fw_priv;
	long timeout;
	int ret;

	fw_work = container_of(work, struct firmware_work, work);
	fw_priv = _request_firmware_prepare(&fw, fw_work->name, fw_work->device,
			fw_work->uevent, true);
	if (IS_ERR_OR_NULL(fw_priv)) {
		ret = PTR_RET(fw_priv);
		goto out;
	}

	timeout = usermodehelper_read_lock_wait(firmware_loading_timeout());
	if (timeout) {
		ret = _request_firmware_load(fw_priv, fw_work->uevent, timeout);
		usermodehelper_read_unlock();
	} else {
		dev_dbg(fw_work->device, "firmware: %s loading timed out\n",
			fw_work->name);
		ret = -EAGAIN;
	}
	if (ret)
		_request_firmware_cleanup(&fw);

 out:
	fw_work->cont(fw, fw_work->context);

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

/**
 * 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.
 *
 *	Asynchronous variant of request_firmware() for user contexts where
 *	it is not possible to sleep for long time. It can't be called
 *	in atomic contexts.
 **/
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 = name;
	fw_work->device = device;
	fw_work->context = context;
	fw_work->cont = cont;
	fw_work->uevent = uevent;

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

	INIT_WORK(&fw_work->work, request_firmware_work_func);
	schedule_work(&fw_work->work);
	return 0;
}

static int __init firmware_class_init(void)
{
	return class_register(&firmware_class);
}

static void __exit firmware_class_exit(void)
{
	class_unregister(&firmware_class);
}

fs_initcall(firmware_class_init);
module_exit(firmware_class_exit);

EXPORT_SYMBOL(release_firmware);
EXPORT_SYMBOL(request_firmware);
EXPORT_SYMBOL(request_firmware_nowait);
Commit	Line	Data
	1	/*
	2	* firmware_class.c - Multi purpose firmware loading support
	3	*
	4	* Copyright (c) 2003 Manuel Estrada Sainz
	5	*
	6	* Please see Documentation/firmware_class/ for more information.
	7	*
	8	*/
	9
	10	#include <linux/capability.h>
	11	#include <linux/device.h>
	12	#include <linux/module.h>
	13	#include <linux/init.h>
	14	#include <linux/timer.h>
	15	#include <linux/vmalloc.h>
	16	#include <linux/interrupt.h>
	17	#include <linux/bitops.h>
	18	#include <linux/mutex.h>
	19	#include <linux/workqueue.h>
	20	#include <linux/highmem.h>
	21	#include <linux/firmware.h>
	22	#include <linux/slab.h>
	23	#include <linux/sched.h>
	24
	25	MODULE_AUTHOR("Manuel Estrada Sainz");
	26	MODULE_DESCRIPTION("Multi purpose firmware loading support");
	27	MODULE_LICENSE("GPL");
	28
	29	/* Builtin firmware support */
	30
	31	#ifdef CONFIG_FW_LOADER
	32
	33	extern struct builtin_fw __start_builtin_fw[];
	34	extern struct builtin_fw __end_builtin_fw[];
	35
	36	static bool fw_get_builtin_firmware(struct firmware fw, const char name)
	37	{
	38	struct builtin_fw *b_fw;
	39
	40	for (b_fw = __start_builtin_fw; b_fw != __end_builtin_fw; b_fw++) {
	41	if (strcmp(name, b_fw->name) == 0) {
	42	fw->size = b_fw->size;
	43	fw->data = b_fw->data;
	44	return true;
	45	}
	46	}
	47
	48	return false;
	49	}
	50
	51	static bool fw_is_builtin_firmware(const struct firmware *fw)
	52	{
	53	struct builtin_fw *b_fw;
	54
	55	for (b_fw = __start_builtin_fw; b_fw != __end_builtin_fw; b_fw++)
	56	if (fw->data == b_fw->data)
	57	return true;
	58
	59	return false;
	60	}
	61
	62	#else /* Module case - no builtin firmware support */
	63
	64	static inline bool fw_get_builtin_firmware(struct firmware fw, const char name)
	65	{
	66	return false;
	67	}
	68
	69	static inline bool fw_is_builtin_firmware(const struct firmware *fw)
	70	{
	71	return false;
	72	}
	73	#endif
	74
	75	enum {
	76	FW_STATUS_LOADING,
	77	FW_STATUS_DONE,
	78	FW_STATUS_ABORT,
	79	};
	80
	81	static int loading_timeout = 60; /* In seconds */
	82
	83	static inline long firmware_loading_timeout(void)
	84	{
	85	return loading_timeout > 0 ? loading_timeout * HZ : MAX_SCHEDULE_TIMEOUT;
	86	}
	87
	88	/* fw_lock could be moved to 'struct firmware_priv' but since it is just
	89	* guarding for corner cases a global lock should be OK */
	90	static DEFINE_MUTEX(fw_lock);
	91
	92	struct firmware_priv {
	93	struct completion completion;
	94	struct firmware *fw;
	95	unsigned long status;
	96	struct page **pages;
	97	int nr_pages;
	98	int page_array_size;
	99	struct timer_list timeout;
	100	struct device dev;
	101	bool nowait;
	102	char fw_id[];
	103	};
	104
	105	static struct firmware_priv to_firmware_priv(struct device dev)
	106	{
	107	return container_of(dev, struct firmware_priv, dev);
	108	}
	109
	110	static void fw_load_abort(struct firmware_priv *fw_priv)
	111	{
	112	set_bit(FW_STATUS_ABORT, &fw_priv->status);
	113	wmb();
	114	complete(&fw_priv->completion);
	115	}
	116
	117	static ssize_t firmware_timeout_show(struct class *class,
	118	struct class_attribute *attr,
	119	char *buf)
	120	{
	121	return sprintf(buf, "%d\n", loading_timeout);
	122	}
	123
	124	/**
	125	* firmware_timeout_store - set number of seconds to wait for firmware
	126	* @class: device class pointer
	127	* @attr: device attribute pointer
	128	* @buf: buffer to scan for timeout value
	129	* @count: number of bytes in @buf
	130	*
	131	* Sets the number of seconds to wait for the firmware. Once
	132	* this expires an error will be returned to the driver and no
	133	* firmware will be provided.
	134	*
	135	* Note: zero means 'wait forever'.
	136	**/
	137	static ssize_t firmware_timeout_store(struct class *class,
	138	struct class_attribute *attr,
	139	const char *buf, size_t count)
	140	{
	141	loading_timeout = simple_strtol(buf, NULL, 10);
	142	if (loading_timeout < 0)
	143	loading_timeout = 0;
	144
	145	return count;
	146	}
	147
	148	static struct class_attribute firmware_class_attrs[] = {
	149	__ATTR(timeout, S_IWUSR \| S_IRUGO,
	150	firmware_timeout_show, firmware_timeout_store),
	151	__ATTR_NULL
	152	};
	153
	154	static void fw_dev_release(struct device *dev)
	155	{
	156	struct firmware_priv *fw_priv = to_firmware_priv(dev);
	157	int i;
	158
	159	for (i = 0; i < fw_priv->nr_pages; i++)
	160	__free_page(fw_priv->pages[i]);
	161	kfree(fw_priv->pages);
	162	kfree(fw_priv);
	163
	164	module_put(THIS_MODULE);
	165	}
	166
	167	static int firmware_uevent(struct device dev, struct kobj_uevent_env env)
	168	{
	169	struct firmware_priv *fw_priv = to_firmware_priv(dev);
	170
	171	if (add_uevent_var(env, "FIRMWARE=%s", fw_priv->fw_id))
	172	return -ENOMEM;
	173	if (add_uevent_var(env, "TIMEOUT=%i", loading_timeout))
	174	return -ENOMEM;
	175	if (add_uevent_var(env, "ASYNC=%d", fw_priv->nowait))
	176	return -ENOMEM;
	177
	178	return 0;
	179	}
	180
	181	static struct class firmware_class = {
	182	.name = "firmware",
	183	.class_attrs = firmware_class_attrs,
	184	.dev_uevent = firmware_uevent,
	185	.dev_release = fw_dev_release,
	186	};
	187
	188	static ssize_t firmware_loading_show(struct device *dev,
	189	struct device_attribute attr, char buf)
	190	{
	191	struct firmware_priv *fw_priv = to_firmware_priv(dev);
	192	int loading = test_bit(FW_STATUS_LOADING, &fw_priv->status);
	193
	194	return sprintf(buf, "%d\n", loading);
	195	}
	196
	197	static void firmware_free_data(const struct firmware *fw)
	198	{
	199	int i;
	200	vunmap(fw->data);
	201	if (fw->pages) {
	202	for (i = 0; i < PFN_UP(fw->size); i++)
	203	__free_page(fw->pages[i]);
	204	kfree(fw->pages);
	205	}
	206	}
	207
	208	/* Some architectures don't have PAGE_KERNEL_RO */
	209	#ifndef PAGE_KERNEL_RO
	210	#define PAGE_KERNEL_RO PAGE_KERNEL
	211	#endif
	212	/**
	213	* firmware_loading_store - set value in the 'loading' control file
	214	* @dev: device pointer
	215	* @attr: device attribute pointer
	216	* @buf: buffer to scan for loading control value
	217	* @count: number of bytes in @buf
	218	*
	219	* The relevant values are:
	220	*
	221	* 1: Start a load, discarding any previous partial load.
	222	* 0: Conclude the load and hand the data to the driver code.
	223	* -1: Conclude the load with an error and discard any written data.
	224	**/
	225	static ssize_t firmware_loading_store(struct device *dev,
	226	struct device_attribute *attr,
	227	const char *buf, size_t count)
	228	{
	229	struct firmware_priv *fw_priv = to_firmware_priv(dev);
	230	int loading = simple_strtol(buf, NULL, 10);
	231	int i;
	232
	233	mutex_lock(&fw_lock);
	234
	235	if (!fw_priv->fw)
	236	goto out;
	237
	238	switch (loading) {
	239	case 1:
	240	firmware_free_data(fw_priv->fw);
	241	memset(fw_priv->fw, 0, sizeof(struct firmware));
	242	/* If the pages are not owned by 'struct firmware' */
	243	for (i = 0; i < fw_priv->nr_pages; i++)
	244	__free_page(fw_priv->pages[i]);
	245	kfree(fw_priv->pages);
	246	fw_priv->pages = NULL;
	247	fw_priv->page_array_size = 0;
	248	fw_priv->nr_pages = 0;
	249	set_bit(FW_STATUS_LOADING, &fw_priv->status);
	250	break;
	251	case 0:
	252	if (test_bit(FW_STATUS_LOADING, &fw_priv->status)) {
	253	vunmap(fw_priv->fw->data);
	254	fw_priv->fw->data = vmap(fw_priv->pages,
	255	fw_priv->nr_pages,
	256	0, PAGE_KERNEL_RO);
	257	if (!fw_priv->fw->data) {
	258	dev_err(dev, "%s: vmap() failed\n", __func__);
	259	goto err;
	260	}
	261	/* Pages are now owned by 'struct firmware' */
	262	fw_priv->fw->pages = fw_priv->pages;
	263	fw_priv->pages = NULL;
	264
	265	fw_priv->page_array_size = 0;
	266	fw_priv->nr_pages = 0;
	267	complete(&fw_priv->completion);
	268	clear_bit(FW_STATUS_LOADING, &fw_priv->status);
	269	break;
	270	}
	271	/* fallthrough */
	272	default:
	273	dev_err(dev, "%s: unexpected value (%d)\n", __func__, loading);
	274	/* fallthrough */
	275	case -1:
	276	err:
	277	fw_load_abort(fw_priv);
	278	break;
	279	}
	280	out:
	281	mutex_unlock(&fw_lock);
	282	return count;
	283	}
	284
	285	static DEVICE_ATTR(loading, 0644, firmware_loading_show, firmware_loading_store);
	286
	287	static ssize_t firmware_data_read(struct file filp, struct kobject kobj,
	288	struct bin_attribute *bin_attr,
	289	char *buffer, loff_t offset, size_t count)
	290	{
	291	struct device *dev = kobj_to_dev(kobj);
	292	struct firmware_priv *fw_priv = to_firmware_priv(dev);
	293	struct firmware *fw;
	294	ssize_t ret_count;
	295
	296	mutex_lock(&fw_lock);
	297	fw = fw_priv->fw;
	298	if (!fw \|\| test_bit(FW_STATUS_DONE, &fw_priv->status)) {
	299	ret_count = -ENODEV;
	300	goto out;
	301	}
	302	if (offset > fw->size) {
	303	ret_count = 0;
	304	goto out;
	305	}
	306	if (count > fw->size - offset)
	307	count = fw->size - offset;
	308
	309	ret_count = count;
	310
	311	while (count) {
	312	void *page_data;
	313	int page_nr = offset >> PAGE_SHIFT;
	314	int page_ofs = offset & (PAGE_SIZE-1);
	315	int page_cnt = min_t(size_t, PAGE_SIZE - page_ofs, count);
	316
	317	page_data = kmap(fw_priv->pages[page_nr]);
	318
	319	memcpy(buffer, page_data + page_ofs, page_cnt);
	320
	321	kunmap(fw_priv->pages[page_nr]);
	322	buffer += page_cnt;
	323	offset += page_cnt;
	324	count -= page_cnt;
	325	}
	326	out:
	327	mutex_unlock(&fw_lock);
	328	return ret_count;
	329	}
	330
	331	static int fw_realloc_buffer(struct firmware_priv *fw_priv, int min_size)
	332	{
	333	int pages_needed = ALIGN(min_size, PAGE_SIZE) >> PAGE_SHIFT;
	334
	335	/* If the array of pages is too small, grow it... */
	336	if (fw_priv->page_array_size < pages_needed) {
	337	int new_array_size = max(pages_needed,
	338	fw_priv->page_array_size * 2);
	339	struct page **new_pages;
	340
	341	new_pages = kmalloc(new_array_size * sizeof(void *),
	342	GFP_KERNEL);
	343	if (!new_pages) {
	344	fw_load_abort(fw_priv);
	345	return -ENOMEM;
	346	}
	347	memcpy(new_pages, fw_priv->pages,
	348	fw_priv->page_array_size * sizeof(void *));
	349	memset(&new_pages[fw_priv->page_array_size], 0, sizeof(void )
	350	(new_array_size - fw_priv->page_array_size));
	351	kfree(fw_priv->pages);
	352	fw_priv->pages = new_pages;
	353	fw_priv->page_array_size = new_array_size;
	354	}
	355
	356	while (fw_priv->nr_pages < pages_needed) {
	357	fw_priv->pages[fw_priv->nr_pages] =
	358	alloc_page(GFP_KERNEL \| __GFP_HIGHMEM);
	359
	360	if (!fw_priv->pages[fw_priv->nr_pages]) {
	361	fw_load_abort(fw_priv);
	362	return -ENOMEM;
	363	}
	364	fw_priv->nr_pages++;
	365	}
	366	return 0;
	367	}
	368
	369	/**
	370	* firmware_data_write - write method for firmware
	371	* @filp: open sysfs file
	372	* @kobj: kobject for the device
	373	* @bin_attr: bin_attr structure
	374	* @buffer: buffer being written
	375	* @offset: buffer offset for write in total data store area
	376	* @count: buffer size
	377	*
	378	* Data written to the 'data' attribute will be later handed to
	379	* the driver as a firmware image.
	380	**/
	381	static ssize_t firmware_data_write(struct file filp, struct kobject kobj,
	382	struct bin_attribute *bin_attr,
	383	char *buffer, loff_t offset, size_t count)
	384	{
	385	struct device *dev = kobj_to_dev(kobj);
	386	struct firmware_priv *fw_priv = to_firmware_priv(dev);
	387	struct firmware *fw;
	388	ssize_t retval;
	389
	390	if (!capable(CAP_SYS_RAWIO))
	391	return -EPERM;
	392
	393	mutex_lock(&fw_lock);
	394	fw = fw_priv->fw;
	395	if (!fw \|\| test_bit(FW_STATUS_DONE, &fw_priv->status)) {
	396	retval = -ENODEV;
	397	goto out;
	398	}
	399	retval = fw_realloc_buffer(fw_priv, offset + count);
	400	if (retval)
	401	goto out;
	402
	403	retval = count;
	404
	405	while (count) {
	406	void *page_data;
	407	int page_nr = offset >> PAGE_SHIFT;
	408	int page_ofs = offset & (PAGE_SIZE - 1);
	409	int page_cnt = min_t(size_t, PAGE_SIZE - page_ofs, count);
	410
	411	page_data = kmap(fw_priv->pages[page_nr]);
	412
	413	memcpy(page_data + page_ofs, buffer, page_cnt);
	414
	415	kunmap(fw_priv->pages[page_nr]);
	416	buffer += page_cnt;
	417	offset += page_cnt;
	418	count -= page_cnt;
	419	}
	420
	421	fw->size = max_t(size_t, offset, fw->size);
	422	out:
	423	mutex_unlock(&fw_lock);
	424	return retval;
	425	}
	426
	427	static struct bin_attribute firmware_attr_data = {
	428	.attr = { .name = "data", .mode = 0644 },
	429	.size = 0,
	430	.read = firmware_data_read,
	431	.write = firmware_data_write,
	432	};
	433
	434	static void firmware_class_timeout(u_long data)
	435	{
	436	struct firmware_priv fw_priv = (struct firmware_priv ) data;
	437
	438	fw_load_abort(fw_priv);
	439	}
	440
	441	static struct firmware_priv *
	442	fw_create_instance(struct firmware firmware, const char fw_name,
	443	struct device *device, bool uevent, bool nowait)
	444	{
	445	struct firmware_priv *fw_priv;
	446	struct device *f_dev;
	447
	448	fw_priv = kzalloc(sizeof(*fw_priv) + strlen(fw_name) + 1 , GFP_KERNEL);
	449	if (!fw_priv) {
	450	dev_err(device, "%s: kmalloc failed\n", __func__);
	451	return ERR_PTR(-ENOMEM);
	452	}
	453
	454	fw_priv->fw = firmware;
	455	fw_priv->nowait = nowait;
	456	strcpy(fw_priv->fw_id, fw_name);
	457	init_completion(&fw_priv->completion);
	458	setup_timer(&fw_priv->timeout,
	459	firmware_class_timeout, (u_long) fw_priv);
	460
	461	f_dev = &fw_priv->dev;
	462
	463	device_initialize(f_dev);
	464	dev_set_name(f_dev, "%s", dev_name(device));
	465	f_dev->parent = device;
	466	f_dev->class = &firmware_class;
	467
	468	return fw_priv;
	469	}
	470
	471	static struct firmware_priv *
	472	_request_firmware_prepare(const struct firmware *firmware_p, const char name,
	473	struct device *device, bool uevent, bool nowait)
	474	{
	475	struct firmware *firmware;
	476	struct firmware_priv *fw_priv;
	477
	478	if (!firmware_p)
	479	return ERR_PTR(-EINVAL);
	480
	481	firmware_p = firmware = kzalloc(sizeof(firmware), GFP_KERNEL);
	482	if (!firmware) {
	483	dev_err(device, "%s: kmalloc(struct firmware) failed\n",
	484	__func__);
	485	return ERR_PTR(-ENOMEM);
	486	}
	487
	488	if (fw_get_builtin_firmware(firmware, name)) {
	489	dev_dbg(device, "firmware: using built-in firmware %s\n", name);
	490	return NULL;
	491	}
	492
	493	fw_priv = fw_create_instance(firmware, name, device, uevent, nowait);
	494	if (IS_ERR(fw_priv)) {
	495	release_firmware(firmware);
	496	*firmware_p = NULL;
	497	}
	498	return fw_priv;
	499	}
	500
	501	static void _request_firmware_cleanup(const struct firmware **firmware_p)
	502	{
	503	release_firmware(*firmware_p);
	504	*firmware_p = NULL;
	505	}
	506
	507	static int _request_firmware_load(struct firmware_priv *fw_priv, bool uevent,
	508	long timeout)
	509	{
	510	int retval = 0;
	511	struct device *f_dev = &fw_priv->dev;
	512
	513	dev_set_uevent_suppress(f_dev, true);
	514
	515	/* Need to pin this module until class device is destroyed */
	516	__module_get(THIS_MODULE);
	517
	518	retval = device_add(f_dev);
	519	if (retval) {
	520	dev_err(f_dev, "%s: device_register failed\n", __func__);
	521	goto err_put_dev;
	522	}
	523
	524	retval = device_create_bin_file(f_dev, &firmware_attr_data);
	525	if (retval) {
	526	dev_err(f_dev, "%s: sysfs_create_bin_file failed\n", __func__);
	527	goto err_del_dev;
	528	}
	529
	530	retval = device_create_file(f_dev, &dev_attr_loading);
	531	if (retval) {
	532	dev_err(f_dev, "%s: device_create_file failed\n", __func__);
	533	goto err_del_bin_attr;
	534	}
	535
	536	if (uevent) {
	537	dev_set_uevent_suppress(f_dev, false);
	538	dev_dbg(f_dev, "firmware: requesting %s\n", fw_priv->fw_id);
	539	if (timeout != MAX_SCHEDULE_TIMEOUT)
	540	mod_timer(&fw_priv->timeout,
	541	round_jiffies_up(jiffies + timeout));
	542
	543	kobject_uevent(&fw_priv->dev.kobj, KOBJ_ADD);
	544	}
	545
	546	wait_for_completion(&fw_priv->completion);
	547
	548	set_bit(FW_STATUS_DONE, &fw_priv->status);
	549	del_timer_sync(&fw_priv->timeout);
	550
	551	mutex_lock(&fw_lock);
	552	if (!fw_priv->fw->size \|\| test_bit(FW_STATUS_ABORT, &fw_priv->status))
	553	retval = -ENOENT;
	554	fw_priv->fw = NULL;
	555	mutex_unlock(&fw_lock);
	556
	557	device_remove_file(f_dev, &dev_attr_loading);
	558	err_del_bin_attr:
	559	device_remove_bin_file(f_dev, &firmware_attr_data);
	560	err_del_dev:
	561	device_del(f_dev);
	562	err_put_dev:
	563	put_device(f_dev);
	564	return retval;
	565	}
	566
	567	/**
	568	* request_firmware: - send firmware request and wait for it
	569	* @firmware_p: pointer to firmware image
	570	* @name: name of firmware file
	571	* @device: device for which firmware is being loaded
	572	*
	573	* @firmware_p will be used to return a firmware image by the name
	574	* of @name for device @device.
	575	*
	576	* Should be called from user context where sleeping is allowed.
	577	*
	578	* @name will be used as $FIRMWARE in the uevent environment and
	579	* should be distinctive enough not to be confused with any other
	580	* firmware image for this or any other device.
	581	**/
	582	int
	583	request_firmware(const struct firmware *firmware_p, const char name,
	584	struct device *device)
	585	{
	586	struct firmware_priv *fw_priv;
	587	int ret;
	588
	589	fw_priv = _request_firmware_prepare(firmware_p, name, device, true,
	590	false);
	591	if (IS_ERR_OR_NULL(fw_priv))
	592	return PTR_RET(fw_priv);
	593
	594	ret = usermodehelper_read_trylock();
	595	if (WARN_ON(ret)) {
	596	dev_err(device, "firmware: %s will not be loaded\n", name);
	597	} else {
	598	ret = _request_firmware_load(fw_priv, true,
	599	firmware_loading_timeout());
	600	usermodehelper_read_unlock();
	601	}
	602	if (ret)
	603	_request_firmware_cleanup(firmware_p);
	604
	605	return ret;
	606	}
	607
	608	/**
	609	* release_firmware: - release the resource associated with a firmware image
	610	* @fw: firmware resource to release
	611	**/
	612	void release_firmware(const struct firmware *fw)
	613	{
	614	if (fw) {
	615	if (!fw_is_builtin_firmware(fw))
	616	firmware_free_data(fw);
	617	kfree(fw);
	618	}
	619	}
	620
	621	/* Async support */
	622	struct firmware_work {
	623	struct work_struct work;
	624	struct module *module;
	625	const char *name;
	626	struct device *device;
	627	void *context;
	628	void (cont)(const struct firmware fw, void *context);
	629	bool uevent;
	630	};
	631
	632	static void request_firmware_work_func(struct work_struct *work)
	633	{
	634	struct firmware_work *fw_work;
	635	const struct firmware *fw;
	636	struct firmware_priv *fw_priv;
	637	long timeout;
	638	int ret;
	639
	640	fw_work = container_of(work, struct firmware_work, work);
	641	fw_priv = _request_firmware_prepare(&fw, fw_work->name, fw_work->device,
	642	fw_work->uevent, true);
	643	if (IS_ERR_OR_NULL(fw_priv)) {
	644	ret = PTR_RET(fw_priv);
	645	goto out;
	646	}
	647
	648	timeout = usermodehelper_read_lock_wait(firmware_loading_timeout());
	649	if (timeout) {
	650	ret = _request_firmware_load(fw_priv, fw_work->uevent, timeout);
	651	usermodehelper_read_unlock();
	652	} else {
	653	dev_dbg(fw_work->device, "firmware: %s loading timed out\n",
	654	fw_work->name);
	655	ret = -EAGAIN;
	656	}
	657	if (ret)
	658	_request_firmware_cleanup(&fw);
	659
	660	out:
	661	fw_work->cont(fw, fw_work->context);
	662
	663	module_put(fw_work->module);
	664	kfree(fw_work);
	665	}
	666
	667	/**
	668	* request_firmware_nowait - asynchronous version of request_firmware
	669	* @module: module requesting the firmware
	670	* @uevent: sends uevent to copy the firmware image if this flag
	671	* is non-zero else the firmware copy must be done manually.
	672	* @name: name of firmware file
	673	* @device: device for which firmware is being loaded
	674	* @gfp: allocation flags
	675	* @context: will be passed over to @cont, and
	676	* @fw may be %NULL if firmware request fails.
	677	* @cont: function will be called asynchronously when the firmware
	678	* request is over.
	679	*
	680	* Asynchronous variant of request_firmware() for user contexts where
	681	* it is not possible to sleep for long time. It can't be called
	682	* in atomic contexts.
	683	**/
	684	int
	685	request_firmware_nowait(
	686	struct module *module, bool uevent,
	687	const char name, struct device device, gfp_t gfp, void *context,
	688	void (cont)(const struct firmware fw, void *context))
	689	{
	690	struct firmware_work *fw_work;
	691
	692	fw_work = kzalloc(sizeof (struct firmware_work), gfp);
	693	if (!fw_work)
	694	return -ENOMEM;
	695
	696	fw_work->module = module;
	697	fw_work->name = name;
	698	fw_work->device = device;
	699	fw_work->context = context;
	700	fw_work->cont = cont;
	701	fw_work->uevent = uevent;
	702
	703	if (!try_module_get(module)) {
	704	kfree(fw_work);
	705	return -EFAULT;
	706	}
	707
	708	INIT_WORK(&fw_work->work, request_firmware_work_func);
	709	schedule_work(&fw_work->work);
	710	return 0;
	711	}
	712
	713	static int __init firmware_class_init(void)
	714	{
	715	return class_register(&firmware_class);
	716	}
	717
	718	static void __exit firmware_class_exit(void)
	719	{
	720	class_unregister(&firmware_class);
	721	}
	722
	723	fs_initcall(firmware_class_init);
	724	module_exit(firmware_class_exit);
	725
	726	EXPORT_SYMBOL(release_firmware);
	727	EXPORT_SYMBOL(request_firmware);
	728	EXPORT_SYMBOL(request_firmware_nowait);