[mirror_ubuntu-artful-kernel.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/kthread.h>

#include <linux/firmware.h>
#include "base.h"

#define to_dev(obj) container_of(obj, struct device, kobj)

MODULE_AUTHOR("Manuel Estrada Sainz");
MODULE_DESCRIPTION("Multi purpose firmware loading support");
MODULE_LICENSE("GPL");

enum {
	FW_STATUS_LOADING,
	FW_STATUS_DONE,
	FW_STATUS_ABORT,
};

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

/* 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 {
	char fw_id[FIRMWARE_NAME_MAX];
	struct completion completion;
	struct bin_attribute attr_data;
	struct firmware *fw;
	unsigned long status;
	int alloc_size;
	struct timer_list timeout;
};

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, char *buf)
{
	return sprintf(buf, "%d\n", loading_timeout);
}

/**
 * firmware_timeout_store - set number of seconds to wait for firmware
 * @class: device class 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, const char *buf, size_t count)
{
	loading_timeout = simple_strtol(buf, NULL, 10);
	if (loading_timeout < 0)
		loading_timeout = 0;
	return count;
}

static CLASS_ATTR(timeout, 0644, firmware_timeout_show, firmware_timeout_store);

static void fw_dev_release(struct device *dev);

static int firmware_uevent(struct device *dev, struct kobj_uevent_env *env)
{
	struct firmware_priv *fw_priv = dev_get_drvdata(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;

	return 0;
}

static struct class firmware_class = {
	.name		= "firmware",
	.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 = dev_get_drvdata(dev);
	int loading = test_bit(FW_STATUS_LOADING, &fw_priv->status);
	return sprintf(buf, "%d\n", loading);
}

/**
 * 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 = dev_get_drvdata(dev);
	int loading = simple_strtol(buf, NULL, 10);

	switch (loading) {
	case 1:
		mutex_lock(&fw_lock);
		if (!fw_priv->fw) {
			mutex_unlock(&fw_lock);
			break;
		}
		vfree(fw_priv->fw->data);
		fw_priv->fw->data = NULL;
		fw_priv->fw->size = 0;
		fw_priv->alloc_size = 0;
		set_bit(FW_STATUS_LOADING, &fw_priv->status);
		mutex_unlock(&fw_lock);
		break;
	case 0:
		if (test_bit(FW_STATUS_LOADING, &fw_priv->status)) {
			complete(&fw_priv->completion);
			clear_bit(FW_STATUS_LOADING, &fw_priv->status);
			break;
		}
		/* fallthrough */
	default:
		printk(KERN_ERR "%s: unexpected value (%d)\n", __FUNCTION__,
		       loading);
		/* fallthrough */
	case -1:
		fw_load_abort(fw_priv);
		break;
	}

	return count;
}

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

static ssize_t
firmware_data_read(struct kobject *kobj, struct bin_attribute *bin_attr,
		   char *buffer, loff_t offset, size_t count)
{
	struct device *dev = to_dev(kobj);
	struct firmware_priv *fw_priv = dev_get_drvdata(dev);
	struct firmware *fw;
	ssize_t ret_count = 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 (offset + ret_count > fw->size)
		ret_count = fw->size - offset;

	memcpy(buffer, fw->data + offset, ret_count);
out:
	mutex_unlock(&fw_lock);
	return ret_count;
}

static int
fw_realloc_buffer(struct firmware_priv *fw_priv, int min_size)
{
	u8 *new_data;
	int new_size = fw_priv->alloc_size;

	if (min_size <= fw_priv->alloc_size)
		return 0;

	new_size = ALIGN(min_size, PAGE_SIZE);
	new_data = vmalloc(new_size);
	if (!new_data) {
		printk(KERN_ERR "%s: unable to alloc buffer\n", __FUNCTION__);
		/* Make sure that we don't keep incomplete data */
		fw_load_abort(fw_priv);
		return -ENOMEM;
	}
	fw_priv->alloc_size = new_size;
	if (fw_priv->fw->data) {
		memcpy(new_data, fw_priv->fw->data, fw_priv->fw->size);
		vfree(fw_priv->fw->data);
	}
	fw_priv->fw->data = new_data;
	BUG_ON(min_size > fw_priv->alloc_size);
	return 0;
}

/**
 * firmware_data_write - write method for firmware
 * @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 kobject *kobj, struct bin_attribute *bin_attr,
		    char *buffer, loff_t offset, size_t count)
{
	struct device *dev = to_dev(kobj);
	struct firmware_priv *fw_priv = dev_get_drvdata(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;

	memcpy(fw->data + offset, buffer, count);

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

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

static void fw_dev_release(struct device *dev)
{
	struct firmware_priv *fw_priv = dev_get_drvdata(dev);

	kfree(fw_priv);
	kfree(dev);

	module_put(THIS_MODULE);
}

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

static inline void fw_setup_device_id(struct device *f_dev, struct device *dev)
{
	snprintf(f_dev->bus_id, BUS_ID_SIZE, "firmware-%s", dev->bus_id);
}

static int fw_register_device(struct device **dev_p, const char *fw_name,
			      struct device *device)
{
	int retval;
	struct firmware_priv *fw_priv = kzalloc(sizeof(*fw_priv),
						GFP_KERNEL);
	struct device *f_dev = kzalloc(sizeof(*f_dev), GFP_KERNEL);

	*dev_p = NULL;

	if (!fw_priv || !f_dev) {
		printk(KERN_ERR "%s: kmalloc failed\n", __FUNCTION__);
		retval = -ENOMEM;
		goto error_kfree;
	}

	init_completion(&fw_priv->completion);
	fw_priv->attr_data = firmware_attr_data_tmpl;
	strlcpy(fw_priv->fw_id, fw_name, FIRMWARE_NAME_MAX);

	fw_priv->timeout.function = firmware_class_timeout;
	fw_priv->timeout.data = (u_long) fw_priv;
	init_timer(&fw_priv->timeout);

	fw_setup_device_id(f_dev, device);
	f_dev->parent = device;
	f_dev->class = &firmware_class;
	dev_set_drvdata(f_dev, fw_priv);
	f_dev->uevent_suppress = 1;
	retval = device_register(f_dev);
	if (retval) {
		printk(KERN_ERR "%s: device_register failed\n",
		       __FUNCTION__);
		goto error_kfree;
	}
	*dev_p = f_dev;
	return 0;

error_kfree:
	kfree(fw_priv);
	kfree(f_dev);
	return retval;
}

static int fw_setup_device(struct firmware *fw, struct device **dev_p,
			   const char *fw_name, struct device *device,
			   int uevent)
{
	struct device *f_dev;
	struct firmware_priv *fw_priv;
	int retval;

	*dev_p = NULL;
	retval = fw_register_device(&f_dev, fw_name, device);
	if (retval)
		goto out;

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

	fw_priv = dev_get_drvdata(f_dev);

	fw_priv->fw = fw;
	retval = sysfs_create_bin_file(&f_dev->kobj, &fw_priv->attr_data);
	if (retval) {
		printk(KERN_ERR "%s: sysfs_create_bin_file failed\n",
		       __FUNCTION__);
		goto error_unreg;
	}

	retval = device_create_file(f_dev, &dev_attr_loading);
	if (retval) {
		printk(KERN_ERR "%s: device_create_file failed\n",
		       __FUNCTION__);
		goto error_unreg;
	}

	if (uevent)
		f_dev->uevent_suppress = 0;
	*dev_p = f_dev;
	goto out;

error_unreg:
	device_unregister(f_dev);
out:
	return retval;
}

static int
_request_firmware(const struct firmware **firmware_p, const char *name,
		 struct device *device, int uevent)
{
	struct device *f_dev;
	struct firmware_priv *fw_priv;
	struct firmware *firmware;
	int retval;

	if (!firmware_p)
		return -EINVAL;

	*firmware_p = firmware = kzalloc(sizeof(*firmware), GFP_KERNEL);
	if (!firmware) {
		printk(KERN_ERR "%s: kmalloc(struct firmware) failed\n",
		       __FUNCTION__);
		retval = -ENOMEM;
		goto out;
	}

	retval = fw_setup_device(firmware, &f_dev, name, device, uevent);
	if (retval)
		goto error_kfree_fw;

	fw_priv = dev_get_drvdata(f_dev);

	if (uevent) {
		if (loading_timeout > 0) {
			fw_priv->timeout.expires = jiffies + loading_timeout * HZ;
			add_timer(&fw_priv->timeout);
		}

		kobject_uevent(&f_dev->kobj, KOBJ_ADD);
		wait_for_completion(&fw_priv->completion);
		set_bit(FW_STATUS_DONE, &fw_priv->status);
		del_timer_sync(&fw_priv->timeout);
	} else
		wait_for_completion(&fw_priv->completion);

	mutex_lock(&fw_lock);
	if (!fw_priv->fw->size || test_bit(FW_STATUS_ABORT, &fw_priv->status)) {
		retval = -ENOENT;
		release_firmware(fw_priv->fw);
		*firmware_p = NULL;
	}
	fw_priv->fw = NULL;
	mutex_unlock(&fw_lock);
	device_unregister(f_dev);
	goto out;

error_kfree_fw:
	kfree(firmware);
	*firmware_p = NULL;
out:
	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)
{
        int uevent = 1;
        return _request_firmware(firmware_p, name, device, uevent);
}

/**
 * release_firmware: - release the resource associated with a firmware image
 * @fw: firmware resource to release
 **/
void
release_firmware(const struct firmware *fw)
{
	if (fw) {
		vfree(fw->data);
		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);
	int uevent;
};

static int
request_firmware_work_func(void *arg)
{
	struct firmware_work *fw_work = arg;
	const struct firmware *fw;
	int ret;
	if (!arg) {
		WARN_ON(1);
		return 0;
	}
	ret = _request_firmware(&fw, fw_work->name, fw_work->device,
		fw_work->uevent);
	if (ret < 0)
		fw_work->cont(NULL, fw_work->context);
	else {
		fw_work->cont(fw, fw_work->context);
		release_firmware(fw);
	}
	module_put(fw_work->module);
	kfree(fw_work);
	return ret;
}

/**
 * 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
 * @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 contexts where
 *	it is not possible to sleep.
 **/
int
request_firmware_nowait(
	struct module *module, int uevent,
	const char *name, struct device *device, void *context,
	void (*cont)(const struct firmware *fw, void *context))
{
	struct task_struct *task;
	struct firmware_work *fw_work = kmalloc(sizeof (struct firmware_work),
						GFP_ATOMIC);

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

	*fw_work = (struct firmware_work) {
		.module = module,
		.name = name,
		.device = device,
		.context = context,
		.cont = cont,
		.uevent = uevent,
	};

	task = kthread_run(request_firmware_work_func, fw_work,
			    "firmware/%s", name);

	if (IS_ERR(task)) {
		fw_work->cont(NULL, fw_work->context);
		module_put(fw_work->module);
		kfree(fw_work);
		return PTR_ERR(task);
	}
	return 0;
}

static int __init
firmware_class_init(void)
{
	int error;
	error = class_register(&firmware_class);
	if (error) {
		printk(KERN_ERR "%s: class_register failed\n", __FUNCTION__);
		return error;
	}
	error = class_create_file(&firmware_class, &class_attr_timeout);
	if (error) {
		printk(KERN_ERR "%s: class_create_file failed\n",
		       __FUNCTION__);
		class_unregister(&firmware_class);
	}
	return error;

}
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
1da177e4 LT	1	/*
	2	* firmware_class.c - Multi purpose firmware loading support
	3	*
87d37a4f	4	* Copyright (c) 2003 Manuel Estrada Sainz
1da177e4 LT	5	*
	6	* Please see Documentation/firmware_class/ for more information.
	7	*
	8	*/
	9
c59ede7b	10	#include <linux/capability.h>
1da177e4 LT	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>
cad1e55d	18	#include <linux/mutex.h>
563d0757	19	#include <linux/kthread.h>
1da177e4 LT	20
	21	#include <linux/firmware.h>
	22	#include "base.h"
	23
e55c8790 GKH	24	#define to_dev(obj) container_of(obj, struct device, kobj)
e55c8790 GKH	25
87d37a4f	26	MODULE_AUTHOR("Manuel Estrada Sainz");
1da177e4 LT	27	MODULE_DESCRIPTION("Multi purpose firmware loading support");
	28	MODULE_LICENSE("GPL");
	29
	30	enum {
	31	FW_STATUS_LOADING,
	32	FW_STATUS_DONE,
	33	FW_STATUS_ABORT,
1da177e4 LT	34	};
1da177e4 LT	35
2f65168d	36	static int loading_timeout = 60; /* In seconds */
1da177e4 LT	37
	38	/* fw_lock could be moved to 'struct firmware_priv' but since it is just
	39	* guarding for corner cases a global lock should be OK */
cad1e55d	40	static DEFINE_MUTEX(fw_lock);
1da177e4 LT	41
	42	struct firmware_priv {
	43	char fw_id[FIRMWARE_NAME_MAX];
	44	struct completion completion;
	45	struct bin_attribute attr_data;
	46	struct firmware *fw;
	47	unsigned long status;
	48	int alloc_size;
	49	struct timer_list timeout;
	50	};
	51
858119e1	52	static void
1da177e4 LT	53	fw_load_abort(struct firmware_priv *fw_priv)
	54	{
	55	set_bit(FW_STATUS_ABORT, &fw_priv->status);
	56	wmb();
	57	complete(&fw_priv->completion);
	58	}
	59
	60	static ssize_t
	61	firmware_timeout_show(struct class class, char buf)
	62	{
	63	return sprintf(buf, "%d\n", loading_timeout);
	64	}
	65
	66	/**
eb8e3179 RD	67	* firmware_timeout_store - set number of seconds to wait for firmware
	68	* @class: device class pointer
	69	* @buf: buffer to scan for timeout value
	70	* @count: number of bytes in @buf
	71	*
1da177e4	72	* Sets the number of seconds to wait for the firmware. Once
eb8e3179	73	* this expires an error will be returned to the driver and no
1da177e4 LT	74	* firmware will be provided.
1da177e4 LT	75	*
eb8e3179	76	* Note: zero means 'wait forever'.
1da177e4 LT	77	**/
	78	static ssize_t
	79	firmware_timeout_store(struct class class, const char buf, size_t count)
	80	{
	81	loading_timeout = simple_strtol(buf, NULL, 10);
b92eac01 SG	82	if (loading_timeout < 0)
b92eac01 SG	83	loading_timeout = 0;
1da177e4 LT	84	return count;
	85	}
	86
	87	static CLASS_ATTR(timeout, 0644, firmware_timeout_show, firmware_timeout_store);
	88
e55c8790	89	static void fw_dev_release(struct device *dev);
1da177e4	90
7eff2e7a	91	static int firmware_uevent(struct device dev, struct kobj_uevent_env env)
1da177e4	92	{
e55c8790	93	struct firmware_priv *fw_priv = dev_get_drvdata(dev);
1da177e4	94
7eff2e7a	95	if (add_uevent_var(env, "FIRMWARE=%s", fw_priv->fw_id))
1da177e4	96	return -ENOMEM;
7eff2e7a	97	if (add_uevent_var(env, "TIMEOUT=%i", loading_timeout))
6897089c	98	return -ENOMEM;
1da177e4 LT	99
	100	return 0;
	101	}
	102
1b81d663 AB	103	static struct class firmware_class = {
1b81d663 AB	104	.name = "firmware",
e55c8790 GKH	105	.dev_uevent = firmware_uevent,
e55c8790 GKH	106	.dev_release = fw_dev_release,
1b81d663 AB	107	};
1b81d663 AB	108
e55c8790 GKH	109	static ssize_t firmware_loading_show(struct device *dev,
e55c8790 GKH	110	struct device_attribute attr, char buf)
1da177e4	111	{
e55c8790	112	struct firmware_priv *fw_priv = dev_get_drvdata(dev);
1da177e4 LT	113	int loading = test_bit(FW_STATUS_LOADING, &fw_priv->status);
	114	return sprintf(buf, "%d\n", loading);
	115	}
	116
	117	/**
eb8e3179	118	* firmware_loading_store - set value in the 'loading' control file
e55c8790	119	* @dev: device pointer
af9997e4	120	* @attr: device attribute pointer
eb8e3179 RD	121	* @buf: buffer to scan for loading control value
	122	* @count: number of bytes in @buf
	123	*
1da177e4 LT	124	* The relevant values are:
	125	*
	126	* 1: Start a load, discarding any previous partial load.
eb8e3179	127	* 0: Conclude the load and hand the data to the driver code.
1da177e4 LT	128	* -1: Conclude the load with an error and discard any written data.
1da177e4 LT	129	**/
e55c8790 GKH	130	static ssize_t firmware_loading_store(struct device *dev,
	131	struct device_attribute *attr,
	132	const char *buf, size_t count)
1da177e4	133	{
e55c8790	134	struct firmware_priv *fw_priv = dev_get_drvdata(dev);
1da177e4 LT	135	int loading = simple_strtol(buf, NULL, 10);
	136
	137	switch (loading) {
	138	case 1:
cad1e55d	139	mutex_lock(&fw_lock);
b92eac01	140	if (!fw_priv->fw) {
cad1e55d	141	mutex_unlock(&fw_lock);
b92eac01 SG	142	break;
b92eac01 SG	143	}
1da177e4 LT	144	vfree(fw_priv->fw->data);
	145	fw_priv->fw->data = NULL;
	146	fw_priv->fw->size = 0;
	147	fw_priv->alloc_size = 0;
	148	set_bit(FW_STATUS_LOADING, &fw_priv->status);
cad1e55d	149	mutex_unlock(&fw_lock);
1da177e4 LT	150	break;
	151	case 0:
	152	if (test_bit(FW_STATUS_LOADING, &fw_priv->status)) {
	153	complete(&fw_priv->completion);
	154	clear_bit(FW_STATUS_LOADING, &fw_priv->status);
	155	break;
	156	}
	157	/* fallthrough */
	158	default:
	159	printk(KERN_ERR "%s: unexpected value (%d)\n", __FUNCTION__,
	160	loading);
	161	/* fallthrough */
	162	case -1:
	163	fw_load_abort(fw_priv);
	164	break;
	165	}
	166
	167	return count;
	168	}
	169
e55c8790	170	static DEVICE_ATTR(loading, 0644, firmware_loading_show, firmware_loading_store);
1da177e4 LT	171
1da177e4 LT	172	static ssize_t
91a69029	173	firmware_data_read(struct kobject kobj, struct bin_attribute bin_attr,
1da177e4 LT	174	char *buffer, loff_t offset, size_t count)
1da177e4 LT	175	{
e55c8790 GKH	176	struct device *dev = to_dev(kobj);
e55c8790 GKH	177	struct firmware_priv *fw_priv = dev_get_drvdata(dev);
1da177e4 LT	178	struct firmware *fw;
	179	ssize_t ret_count = count;
	180
cad1e55d	181	mutex_lock(&fw_lock);
1da177e4	182	fw = fw_priv->fw;
b92eac01	183	if (!fw \|\| test_bit(FW_STATUS_DONE, &fw_priv->status)) {
1da177e4 LT	184	ret_count = -ENODEV;
	185	goto out;
	186	}
	187	if (offset > fw->size) {
	188	ret_count = 0;
	189	goto out;
	190	}
	191	if (offset + ret_count > fw->size)
	192	ret_count = fw->size - offset;
	193
	194	memcpy(buffer, fw->data + offset, ret_count);
	195	out:
cad1e55d	196	mutex_unlock(&fw_lock);
1da177e4 LT	197	return ret_count;
1da177e4 LT	198	}
eb8e3179	199
1da177e4 LT	200	static int
	201	fw_realloc_buffer(struct firmware_priv *fw_priv, int min_size)
	202	{
	203	u8 *new_data;
30560ba6	204	int new_size = fw_priv->alloc_size;
1da177e4 LT	205
	206	if (min_size <= fw_priv->alloc_size)
	207	return 0;
	208
30560ba6 JM	209	new_size = ALIGN(min_size, PAGE_SIZE);
30560ba6 JM	210	new_data = vmalloc(new_size);
1da177e4 LT	211	if (!new_data) {
	212	printk(KERN_ERR "%s: unable to alloc buffer\n", __FUNCTION__);
	213	/* Make sure that we don't keep incomplete data */
	214	fw_load_abort(fw_priv);
	215	return -ENOMEM;
	216	}
30560ba6	217	fw_priv->alloc_size = new_size;
1da177e4 LT	218	if (fw_priv->fw->data) {
	219	memcpy(new_data, fw_priv->fw->data, fw_priv->fw->size);
	220	vfree(fw_priv->fw->data);
	221	}
	222	fw_priv->fw->data = new_data;
	223	BUG_ON(min_size > fw_priv->alloc_size);
	224	return 0;
	225	}
	226
	227	/**
eb8e3179	228	* firmware_data_write - write method for firmware
e55c8790	229	* @kobj: kobject for the device
42e61f4a	230	* @bin_attr: bin_attr structure
eb8e3179 RD	231	* @buffer: buffer being written
	232	* @offset: buffer offset for write in total data store area
	233	* @count: buffer size
1da177e4	234	*
eb8e3179	235	* Data written to the 'data' attribute will be later handed to
1da177e4 LT	236	* the driver as a firmware image.
	237	**/
	238	static ssize_t
91a69029	239	firmware_data_write(struct kobject kobj, struct bin_attribute bin_attr,
1da177e4 LT	240	char *buffer, loff_t offset, size_t count)
1da177e4 LT	241	{
e55c8790 GKH	242	struct device *dev = to_dev(kobj);
e55c8790 GKH	243	struct firmware_priv *fw_priv = dev_get_drvdata(dev);
1da177e4 LT	244	struct firmware *fw;
	245	ssize_t retval;
	246
	247	if (!capable(CAP_SYS_RAWIO))
	248	return -EPERM;
b92eac01	249
cad1e55d	250	mutex_lock(&fw_lock);
1da177e4	251	fw = fw_priv->fw;
b92eac01	252	if (!fw \|\| test_bit(FW_STATUS_DONE, &fw_priv->status)) {
1da177e4 LT	253	retval = -ENODEV;
	254	goto out;
	255	}
	256	retval = fw_realloc_buffer(fw_priv, offset + count);
	257	if (retval)
	258	goto out;
	259
	260	memcpy(fw->data + offset, buffer, count);
	261
	262	fw->size = max_t(size_t, offset + count, fw->size);
	263	retval = count;
	264	out:
cad1e55d	265	mutex_unlock(&fw_lock);
1da177e4 LT	266	return retval;
1da177e4 LT	267	}
eb8e3179	268
1da177e4	269	static struct bin_attribute firmware_attr_data_tmpl = {
7b595756	270	.attr = {.name = "data", .mode = 0644},
1da177e4 LT	271	.size = 0,
	272	.read = firmware_data_read,
	273	.write = firmware_data_write,
	274	};
	275
e55c8790	276	static void fw_dev_release(struct device *dev)
1da177e4	277	{
e55c8790	278	struct firmware_priv *fw_priv = dev_get_drvdata(dev);
1da177e4 LT	279
1da177e4 LT	280	kfree(fw_priv);
e55c8790	281	kfree(dev);
1da177e4 LT	282
	283	module_put(THIS_MODULE);
	284	}
	285
	286	static void
	287	firmware_class_timeout(u_long data)
	288	{
	289	struct firmware_priv fw_priv = (struct firmware_priv ) data;
	290	fw_load_abort(fw_priv);
	291	}
	292
e55c8790	293	static inline void fw_setup_device_id(struct device f_dev, struct device dev)
1da177e4	294	{
109f0e93	295	snprintf(f_dev->bus_id, BUS_ID_SIZE, "firmware-%s", dev->bus_id);
1da177e4 LT	296	}
1da177e4 LT	297
e55c8790 GKH	298	static int fw_register_device(struct device *dev_p, const char fw_name,
e55c8790 GKH	299	struct device *device)
1da177e4 LT	300	{
1da177e4 LT	301	int retval;
4aed0644	302	struct firmware_priv fw_priv = kzalloc(sizeof(fw_priv),
1da177e4	303	GFP_KERNEL);
e55c8790	304	struct device f_dev = kzalloc(sizeof(f_dev), GFP_KERNEL);
1da177e4	305
e55c8790	306	*dev_p = NULL;
1da177e4	307
e55c8790	308	if (!fw_priv \|\| !f_dev) {
1da177e4 LT	309	printk(KERN_ERR "%s: kmalloc failed\n", __FUNCTION__);
	310	retval = -ENOMEM;
	311	goto error_kfree;
	312	}
1da177e4 LT	313
	314	init_completion(&fw_priv->completion);
	315	fw_priv->attr_data = firmware_attr_data_tmpl;
	316	strlcpy(fw_priv->fw_id, fw_name, FIRMWARE_NAME_MAX);
	317
	318	fw_priv->timeout.function = firmware_class_timeout;
	319	fw_priv->timeout.data = (u_long) fw_priv;
	320	init_timer(&fw_priv->timeout);
	321
e55c8790 GKH	322	fw_setup_device_id(f_dev, device);
	323	f_dev->parent = device;
	324	f_dev->class = &firmware_class;
	325	dev_set_drvdata(f_dev, fw_priv);
bdc4960a	326	f_dev->uevent_suppress = 1;
e55c8790	327	retval = device_register(f_dev);
1da177e4	328	if (retval) {
e55c8790	329	printk(KERN_ERR "%s: device_register failed\n",
1da177e4 LT	330	__FUNCTION__);
	331	goto error_kfree;
	332	}
e55c8790	333	*dev_p = f_dev;
1da177e4 LT	334	return 0;
	335
	336	error_kfree:
	337	kfree(fw_priv);
e55c8790	338	kfree(f_dev);
1da177e4 LT	339	return retval;
	340	}
	341
e55c8790 GKH	342	static int fw_setup_device(struct firmware fw, struct device *dev_p,
	343	const char fw_name, struct device device,
	344	int uevent)
1da177e4	345	{
e55c8790	346	struct device *f_dev;
1da177e4 LT	347	struct firmware_priv *fw_priv;
	348	int retval;
	349
e55c8790 GKH	350	*dev_p = NULL;
e55c8790 GKH	351	retval = fw_register_device(&f_dev, fw_name, device);
1da177e4 LT	352	if (retval)
	353	goto out;
	354
	355	/* Need to pin this module until class device is destroyed */
	356	__module_get(THIS_MODULE);
	357
e55c8790	358	fw_priv = dev_get_drvdata(f_dev);
1da177e4 LT	359
1da177e4 LT	360	fw_priv->fw = fw;
e55c8790	361	retval = sysfs_create_bin_file(&f_dev->kobj, &fw_priv->attr_data);
1da177e4 LT	362	if (retval) {
	363	printk(KERN_ERR "%s: sysfs_create_bin_file failed\n",
	364	__FUNCTION__);
	365	goto error_unreg;
	366	}
	367
e55c8790	368	retval = device_create_file(f_dev, &dev_attr_loading);
1da177e4	369	if (retval) {
e55c8790	370	printk(KERN_ERR "%s: device_create_file failed\n",
1da177e4 LT	371	__FUNCTION__);
	372	goto error_unreg;
	373	}
	374
312c004d	375	if (uevent)
bdc4960a	376	f_dev->uevent_suppress = 0;
e55c8790	377	*dev_p = f_dev;
1da177e4 LT	378	goto out;
	379
	380	error_unreg:
e55c8790	381	device_unregister(f_dev);
1da177e4 LT	382	out:
	383	return retval;
	384	}
	385
6e3eaab0 AS	386	static int
6e3eaab0 AS	387	_request_firmware(const struct firmware *firmware_p, const char name,
312c004d	388	struct device *device, int uevent)
1da177e4	389	{
e55c8790	390	struct device *f_dev;
1da177e4 LT	391	struct firmware_priv *fw_priv;
	392	struct firmware *firmware;
	393	int retval;
	394
	395	if (!firmware_p)
	396	return -EINVAL;
	397
4aed0644	398	firmware_p = firmware = kzalloc(sizeof(firmware), GFP_KERNEL);
1da177e4 LT	399	if (!firmware) {
	400	printk(KERN_ERR "%s: kmalloc(struct firmware) failed\n",
	401	__FUNCTION__);
	402	retval = -ENOMEM;
	403	goto out;
	404	}
1da177e4	405
e55c8790	406	retval = fw_setup_device(firmware, &f_dev, name, device, uevent);
1da177e4 LT	407	if (retval)
	408	goto error_kfree_fw;
	409
e55c8790	410	fw_priv = dev_get_drvdata(f_dev);
1da177e4	411
312c004d	412	if (uevent) {
6e3eaab0 AS	413	if (loading_timeout > 0) {
	414	fw_priv->timeout.expires = jiffies + loading_timeout * HZ;
	415	add_timer(&fw_priv->timeout);
	416	}
1da177e4	417
e55c8790	418	kobject_uevent(&f_dev->kobj, KOBJ_ADD);
6e3eaab0 AS	419	wait_for_completion(&fw_priv->completion);
	420	set_bit(FW_STATUS_DONE, &fw_priv->status);
	421	del_timer_sync(&fw_priv->timeout);
	422	} else
	423	wait_for_completion(&fw_priv->completion);
1da177e4	424
cad1e55d	425	mutex_lock(&fw_lock);
1da177e4 LT	426	if (!fw_priv->fw->size \|\| test_bit(FW_STATUS_ABORT, &fw_priv->status)) {
	427	retval = -ENOENT;
	428	release_firmware(fw_priv->fw);
	429	*firmware_p = NULL;
	430	}
	431	fw_priv->fw = NULL;
cad1e55d	432	mutex_unlock(&fw_lock);
e55c8790	433	device_unregister(f_dev);
1da177e4 LT	434	goto out;
	435
	436	error_kfree_fw:
	437	kfree(firmware);
	438	*firmware_p = NULL;
	439	out:
	440	return retval;
	441	}
	442
6e3eaab0	443	/**
312c004d	444	* request_firmware: - send firmware request and wait for it
eb8e3179 RD	445	* @firmware_p: pointer to firmware image
	446	* @name: name of firmware file
	447	* @device: device for which firmware is being loaded
	448	*
	449	* @firmware_p will be used to return a firmware image by the name
6e3eaab0 AS	450	* of @name for device @device.
	451	*
	452	* Should be called from user context where sleeping is allowed.
	453	*
312c004d	454	* @name will be used as $FIRMWARE in the uevent environment and
6e3eaab0 AS	455	* should be distinctive enough not to be confused with any other
	456	* firmware image for this or any other device.
	457	**/
	458	int
	459	request_firmware(const struct firmware *firmware_p, const char name,
	460	struct device *device)
	461	{
312c004d KS	462	int uevent = 1;
312c004d KS	463	return _request_firmware(firmware_p, name, device, uevent);
6e3eaab0 AS	464	}
6e3eaab0 AS	465
1da177e4 LT	466	/**
1da177e4 LT	467	* release_firmware: - release the resource associated with a firmware image
eb8e3179	468	* @fw: firmware resource to release
1da177e4 LT	469	**/
	470	void
	471	release_firmware(const struct firmware *fw)
	472	{
	473	if (fw) {
	474	vfree(fw->data);
	475	kfree(fw);
	476	}
	477	}
	478
1da177e4 LT	479	/* Async support */
	480	struct firmware_work {
	481	struct work_struct work;
	482	struct module *module;
	483	const char *name;
	484	struct device *device;
	485	void *context;
	486	void (cont)(const struct firmware fw, void *context);
312c004d	487	int uevent;
1da177e4 LT	488	};
	489
	490	static int
	491	request_firmware_work_func(void *arg)
	492	{
	493	struct firmware_work *fw_work = arg;
	494	const struct firmware *fw;
113fab13	495	int ret;
1da177e4 LT	496	if (!arg) {
	497	WARN_ON(1);
	498	return 0;
	499	}
113fab13	500	ret = _request_firmware(&fw, fw_work->name, fw_work->device,
312c004d	501	fw_work->uevent);
113fab13 MC	502	if (ret < 0)
	503	fw_work->cont(NULL, fw_work->context);
	504	else {
	505	fw_work->cont(fw, fw_work->context);
	506	release_firmware(fw);
	507	}
1da177e4 LT	508	module_put(fw_work->module);
1da177e4 LT	509	kfree(fw_work);
113fab13	510	return ret;
1da177e4 LT	511	}
	512
	513	/**
eb8e3179 RD	514	* request_firmware_nowait: asynchronous version of request_firmware
eb8e3179 RD	515	* @module: module requesting the firmware
312c004d	516	* @uevent: sends uevent to copy the firmware image if this flag
eb8e3179 RD	517	* is non-zero else the firmware copy must be done manually.
	518	* @name: name of firmware file
	519	* @device: device for which firmware is being loaded
	520	* @context: will be passed over to @cont, and
	521	* @fw may be %NULL if firmware request fails.
	522	* @cont: function will be called asynchronously when the firmware
	523	* request is over.
1da177e4	524	*
1da177e4 LT	525	* Asynchronous variant of request_firmware() for contexts where
1da177e4 LT	526	* it is not possible to sleep.
1da177e4 LT	527	**/
	528	int
	529	request_firmware_nowait(
312c004d	530	struct module *module, int uevent,
1da177e4 LT	531	const char name, struct device device, void *context,
	532	void (cont)(const struct firmware fw, void *context))
	533	{
563d0757	534	struct task_struct *task;
1da177e4 LT	535	struct firmware_work *fw_work = kmalloc(sizeof (struct firmware_work),
1da177e4 LT	536	GFP_ATOMIC);
1da177e4 LT	537
	538	if (!fw_work)
	539	return -ENOMEM;
	540	if (!try_module_get(module)) {
	541	kfree(fw_work);
	542	return -EFAULT;
	543	}
	544
	545	*fw_work = (struct firmware_work) {
	546	.module = module,
	547	.name = name,
	548	.device = device,
	549	.context = context,
	550	.cont = cont,
312c004d	551	.uevent = uevent,
1da177e4 LT	552	};
1da177e4 LT	553
563d0757 SB	554	task = kthread_run(request_firmware_work_func, fw_work,
563d0757 SB	555	"firmware/%s", name);
1da177e4	556
563d0757	557	if (IS_ERR(task)) {
1da177e4	558	fw_work->cont(NULL, fw_work->context);
113fab13 MC	559	module_put(fw_work->module);
113fab13 MC	560	kfree(fw_work);
563d0757	561	return PTR_ERR(task);
1da177e4 LT	562	}
	563	return 0;
	564	}
	565
	566	static int __init
	567	firmware_class_init(void)
	568	{
	569	int error;
	570	error = class_register(&firmware_class);
	571	if (error) {
	572	printk(KERN_ERR "%s: class_register failed\n", __FUNCTION__);
	573	return error;
	574	}
	575	error = class_create_file(&firmware_class, &class_attr_timeout);
	576	if (error) {
	577	printk(KERN_ERR "%s: class_create_file failed\n",
	578	__FUNCTION__);
	579	class_unregister(&firmware_class);
	580	}
	581	return error;
	582
	583	}
	584	static void __exit
	585	firmware_class_exit(void)
	586	{
	587	class_unregister(&firmware_class);
	588	}
	589
a30a6a2c	590	fs_initcall(firmware_class_init);
1da177e4 LT	591	module_exit(firmware_class_exit);
	592
	593	EXPORT_SYMBOL(release_firmware);
	594	EXPORT_SYMBOL(request_firmware);
	595	EXPORT_SYMBOL(request_firmware_nowait);