2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* firmware_class.c - Multi purpose firmware loading support
|
|
|
|
*
|
2007-06-04 10:45:44 -06:00
|
|
|
* Copyright (c) 2003 Manuel Estrada Sainz
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Please see Documentation/firmware_class/ for more information.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2006-01-11 13:17:46 -07:00
|
|
|
#include <linux/capability.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#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>
|
2006-05-23 15:22:38 -06:00
|
|
|
#include <linux/mutex.h>
|
2012-03-28 15:31:00 -06:00
|
|
|
#include <linux/workqueue.h>
|
2009-04-09 23:04:07 -06:00
|
|
|
#include <linux/highmem.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/firmware.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2012-03-28 15:31:00 -06:00
|
|
|
#include <linux/sched.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-06-04 10:45:44 -06:00
|
|
|
MODULE_AUTHOR("Manuel Estrada Sainz");
|
2005-04-16 16:20:36 -06:00
|
|
|
MODULE_DESCRIPTION("Multi purpose firmware loading support");
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
2010-03-14 00:49:18 -07:00
|
|
|
/* 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
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
enum {
|
|
|
|
FW_STATUS_LOADING,
|
|
|
|
FW_STATUS_DONE,
|
|
|
|
FW_STATUS_ABORT,
|
|
|
|
};
|
|
|
|
|
2007-01-25 13:56:15 -07:00
|
|
|
static int loading_timeout = 60; /* In seconds */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-03-28 15:30:02 -06:00
|
|
|
static inline long firmware_loading_timeout(void)
|
|
|
|
{
|
|
|
|
return loading_timeout > 0 ? loading_timeout * HZ : MAX_SCHEDULE_TIMEOUT;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* fw_lock could be moved to 'struct firmware_priv' but since it is just
|
|
|
|
* guarding for corner cases a global lock should be OK */
|
2006-05-23 15:22:38 -06:00
|
|
|
static DEFINE_MUTEX(fw_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
struct firmware_priv {
|
|
|
|
struct completion completion;
|
|
|
|
struct firmware *fw;
|
|
|
|
unsigned long status;
|
2012-08-03 22:01:16 -06:00
|
|
|
void *data;
|
|
|
|
size_t size;
|
2009-04-09 23:04:07 -06:00
|
|
|
struct page **pages;
|
|
|
|
int nr_pages;
|
|
|
|
int page_array_size;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct timer_list timeout;
|
2010-06-04 01:54:43 -06:00
|
|
|
struct device dev;
|
2010-03-29 09:57:20 -06:00
|
|
|
bool nowait;
|
2010-03-14 00:49:23 -07:00
|
|
|
char fw_id[];
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2010-06-04 01:54:43 -06:00
|
|
|
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)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
set_bit(FW_STATUS_ABORT, &fw_priv->status);
|
|
|
|
wmb();
|
|
|
|
complete(&fw_priv->completion);
|
|
|
|
}
|
|
|
|
|
2010-06-04 01:54:43 -06:00
|
|
|
static ssize_t firmware_timeout_show(struct class *class,
|
|
|
|
struct class_attribute *attr,
|
|
|
|
char *buf)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
return sprintf(buf, "%d\n", loading_timeout);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2005-10-30 16:03:01 -07:00
|
|
|
* firmware_timeout_store - set number of seconds to wait for firmware
|
|
|
|
* @class: device class pointer
|
2010-03-10 12:47:58 -07:00
|
|
|
* @attr: device attribute pointer
|
2005-10-30 16:03:01 -07:00
|
|
|
* @buf: buffer to scan for timeout value
|
|
|
|
* @count: number of bytes in @buf
|
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* Sets the number of seconds to wait for the firmware. Once
|
2005-10-30 16:03:01 -07:00
|
|
|
* this expires an error will be returned to the driver and no
|
2005-04-16 16:20:36 -06:00
|
|
|
* firmware will be provided.
|
|
|
|
*
|
2005-10-30 16:03:01 -07:00
|
|
|
* Note: zero means 'wait forever'.
|
2005-04-16 16:20:36 -06:00
|
|
|
**/
|
2010-06-04 01:54:43 -06:00
|
|
|
static ssize_t firmware_timeout_store(struct class *class,
|
|
|
|
struct class_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
loading_timeout = simple_strtol(buf, NULL, 10);
|
2005-06-28 21:44:51 -06:00
|
|
|
if (loading_timeout < 0)
|
|
|
|
loading_timeout = 0;
|
2010-06-04 01:54:43 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2010-03-14 00:49:13 -07:00
|
|
|
static struct class_attribute firmware_class_attrs[] = {
|
|
|
|
__ATTR(timeout, S_IWUSR | S_IRUGO,
|
|
|
|
firmware_timeout_show, firmware_timeout_store),
|
|
|
|
__ATTR_NULL
|
|
|
|
};
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-03-14 00:49:13 -07:00
|
|
|
static void fw_dev_release(struct device *dev)
|
|
|
|
{
|
2010-06-04 01:54:43 -06:00
|
|
|
struct firmware_priv *fw_priv = to_firmware_priv(dev);
|
2010-03-14 00:49:13 -07:00
|
|
|
int i;
|
|
|
|
|
2012-08-03 22:01:16 -06:00
|
|
|
/* free untransfered pages buffer */
|
2010-03-14 00:49:13 -07:00
|
|
|
for (i = 0; i < fw_priv->nr_pages; i++)
|
|
|
|
__free_page(fw_priv->pages[i]);
|
|
|
|
kfree(fw_priv->pages);
|
2012-08-03 22:01:16 -06:00
|
|
|
|
2010-03-14 00:49:13 -07:00
|
|
|
kfree(fw_priv);
|
|
|
|
|
|
|
|
module_put(THIS_MODULE);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-08-14 07:15:12 -06:00
|
|
|
static int firmware_uevent(struct device *dev, struct kobj_uevent_env *env)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-06-04 01:54:43 -06:00
|
|
|
struct firmware_priv *fw_priv = to_firmware_priv(dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-08-14 07:15:12 -06:00
|
|
|
if (add_uevent_var(env, "FIRMWARE=%s", fw_priv->fw_id))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOMEM;
|
2007-08-14 07:15:12 -06:00
|
|
|
if (add_uevent_var(env, "TIMEOUT=%i", loading_timeout))
|
2005-04-18 22:57:31 -06:00
|
|
|
return -ENOMEM;
|
2010-03-29 09:57:20 -06:00
|
|
|
if (add_uevent_var(env, "ASYNC=%d", fw_priv->nowait))
|
|
|
|
return -ENOMEM;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-05-20 16:00:16 -06:00
|
|
|
static struct class firmware_class = {
|
|
|
|
.name = "firmware",
|
2010-03-14 00:49:13 -07:00
|
|
|
.class_attrs = firmware_class_attrs,
|
2006-09-14 08:30:59 -06:00
|
|
|
.dev_uevent = firmware_uevent,
|
|
|
|
.dev_release = fw_dev_release,
|
2006-05-20 16:00:16 -06:00
|
|
|
};
|
|
|
|
|
2006-09-14 08:30:59 -06:00
|
|
|
static ssize_t firmware_loading_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-06-04 01:54:43 -06:00
|
|
|
struct firmware_priv *fw_priv = to_firmware_priv(dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
int loading = test_bit(FW_STATUS_LOADING, &fw_priv->status);
|
2010-06-04 01:54:43 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return sprintf(buf, "%d\n", loading);
|
|
|
|
}
|
|
|
|
|
2012-08-03 22:01:16 -06:00
|
|
|
/* firmware holds the ownership of pages */
|
2010-05-02 02:21:21 -06:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-09 23:04:07 -06:00
|
|
|
/* Some architectures don't have PAGE_KERNEL_RO */
|
|
|
|
#ifndef PAGE_KERNEL_RO
|
|
|
|
#define PAGE_KERNEL_RO PAGE_KERNEL
|
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
/**
|
2005-10-30 16:03:01 -07:00
|
|
|
* firmware_loading_store - set value in the 'loading' control file
|
2006-09-14 08:30:59 -06:00
|
|
|
* @dev: device pointer
|
2006-12-22 02:06:52 -07:00
|
|
|
* @attr: device attribute pointer
|
2005-10-30 16:03:01 -07:00
|
|
|
* @buf: buffer to scan for loading control value
|
|
|
|
* @count: number of bytes in @buf
|
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* The relevant values are:
|
|
|
|
*
|
|
|
|
* 1: Start a load, discarding any previous partial load.
|
2005-10-30 16:03:01 -07:00
|
|
|
* 0: Conclude the load and hand the data to the driver code.
|
2005-04-16 16:20:36 -06:00
|
|
|
* -1: Conclude the load with an error and discard any written data.
|
|
|
|
**/
|
2006-09-14 08:30:59 -06:00
|
|
|
static ssize_t firmware_loading_store(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-06-04 01:54:43 -06:00
|
|
|
struct firmware_priv *fw_priv = to_firmware_priv(dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
int loading = simple_strtol(buf, NULL, 10);
|
2009-04-09 23:04:07 -06:00
|
|
|
int i;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-01-02 13:31:23 -07:00
|
|
|
mutex_lock(&fw_lock);
|
|
|
|
|
|
|
|
if (!fw_priv->fw)
|
|
|
|
goto out;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
switch (loading) {
|
|
|
|
case 1:
|
2012-08-03 22:01:16 -06:00
|
|
|
/* discarding any previous partial load */
|
2009-04-09 23:04:07 -06:00
|
|
|
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;
|
2005-04-16 16:20:36 -06:00
|
|
|
set_bit(FW_STATUS_LOADING, &fw_priv->status);
|
|
|
|
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:
|
2008-10-15 23:04:20 -06:00
|
|
|
dev_err(dev, "%s: unexpected value (%d)\n", __func__, loading);
|
2005-04-16 16:20:36 -06:00
|
|
|
/* fallthrough */
|
|
|
|
case -1:
|
|
|
|
fw_load_abort(fw_priv);
|
|
|
|
break;
|
|
|
|
}
|
2012-01-02 13:31:23 -07:00
|
|
|
out:
|
|
|
|
mutex_unlock(&fw_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2006-09-14 08:30:59 -06:00
|
|
|
static DEVICE_ATTR(loading, 0644, firmware_loading_show, firmware_loading_store);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-06-04 01:54:43 -06: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)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-07-03 10:49:36 -06:00
|
|
|
struct device *dev = kobj_to_dev(kobj);
|
2010-06-04 01:54:43 -06:00
|
|
|
struct firmware_priv *fw_priv = to_firmware_priv(dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
struct firmware *fw;
|
2008-07-25 02:48:23 -06:00
|
|
|
ssize_t ret_count;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-05-23 15:22:38 -06:00
|
|
|
mutex_lock(&fw_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
fw = fw_priv->fw;
|
2005-06-28 21:44:51 -06:00
|
|
|
if (!fw || test_bit(FW_STATUS_DONE, &fw_priv->status)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
ret_count = -ENODEV;
|
|
|
|
goto out;
|
|
|
|
}
|
2012-08-03 22:01:16 -06:00
|
|
|
if (offset > fw_priv->size) {
|
2009-06-21 15:57:31 -06:00
|
|
|
ret_count = 0;
|
|
|
|
goto out;
|
|
|
|
}
|
2012-08-03 22:01:16 -06:00
|
|
|
if (count > fw_priv->size - offset)
|
|
|
|
count = fw_priv->size - offset;
|
2009-04-09 23:04:07 -06:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
out:
|
2006-05-23 15:22:38 -06:00
|
|
|
mutex_unlock(&fw_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
return ret_count;
|
|
|
|
}
|
2005-10-30 16:03:01 -07:00
|
|
|
|
2010-06-04 01:54:43 -06:00
|
|
|
static int fw_realloc_buffer(struct firmware_priv *fw_priv, int min_size)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-04-09 23:04:07 -06:00
|
|
|
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;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-04-09 23:04:07 -06:00
|
|
|
while (fw_priv->nr_pages < pages_needed) {
|
|
|
|
fw_priv->pages[fw_priv->nr_pages] =
|
|
|
|
alloc_page(GFP_KERNEL | __GFP_HIGHMEM);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-04-09 23:04:07 -06:00
|
|
|
if (!fw_priv->pages[fw_priv->nr_pages]) {
|
|
|
|
fw_load_abort(fw_priv);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
fw_priv->nr_pages++;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2005-10-30 16:03:01 -07:00
|
|
|
* firmware_data_write - write method for firmware
|
2010-05-12 19:28:57 -06:00
|
|
|
* @filp: open sysfs file
|
2006-09-14 08:30:59 -06:00
|
|
|
* @kobj: kobject for the device
|
2007-07-23 22:42:11 -06:00
|
|
|
* @bin_attr: bin_attr structure
|
2005-10-30 16:03:01 -07:00
|
|
|
* @buffer: buffer being written
|
|
|
|
* @offset: buffer offset for write in total data store area
|
|
|
|
* @count: buffer size
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2005-10-30 16:03:01 -07:00
|
|
|
* Data written to the 'data' attribute will be later handed to
|
2005-04-16 16:20:36 -06:00
|
|
|
* the driver as a firmware image.
|
|
|
|
**/
|
2010-06-04 01:54:43 -06:00
|
|
|
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)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-07-03 10:49:36 -06:00
|
|
|
struct device *dev = kobj_to_dev(kobj);
|
2010-06-04 01:54:43 -06:00
|
|
|
struct firmware_priv *fw_priv = to_firmware_priv(dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
struct firmware *fw;
|
|
|
|
ssize_t retval;
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_RAWIO))
|
|
|
|
return -EPERM;
|
2005-06-28 21:44:51 -06:00
|
|
|
|
2006-05-23 15:22:38 -06:00
|
|
|
mutex_lock(&fw_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
fw = fw_priv->fw;
|
2005-06-28 21:44:51 -06:00
|
|
|
if (!fw || test_bit(FW_STATUS_DONE, &fw_priv->status)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
retval = -ENODEV;
|
|
|
|
goto out;
|
|
|
|
}
|
2012-08-03 22:01:16 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
retval = fw_realloc_buffer(fw_priv, offset + count);
|
|
|
|
if (retval)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
retval = count;
|
2009-04-09 23:04:07 -06:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2012-08-03 22:01:16 -06:00
|
|
|
fw_priv->size = max_t(size_t, offset, fw_priv->size);
|
2005-04-16 16:20:36 -06:00
|
|
|
out:
|
2006-05-23 15:22:38 -06:00
|
|
|
mutex_unlock(&fw_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
return retval;
|
|
|
|
}
|
2005-10-30 16:03:01 -07:00
|
|
|
|
2010-06-04 01:54:37 -06:00
|
|
|
static struct bin_attribute firmware_attr_data = {
|
|
|
|
.attr = { .name = "data", .mode = 0644 },
|
2005-04-16 16:20:36 -06:00
|
|
|
.size = 0,
|
|
|
|
.read = firmware_data_read,
|
|
|
|
.write = firmware_data_write,
|
|
|
|
};
|
|
|
|
|
2010-06-04 01:54:43 -06:00
|
|
|
static void firmware_class_timeout(u_long data)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct firmware_priv *fw_priv = (struct firmware_priv *) data;
|
2010-06-04 01:54:43 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
fw_load_abort(fw_priv);
|
|
|
|
}
|
|
|
|
|
2010-06-04 01:54:43 -06:00
|
|
|
static struct firmware_priv *
|
2012-03-28 15:30:43 -06:00
|
|
|
fw_create_instance(struct firmware *firmware, const char *fw_name,
|
2010-06-04 01:54:43 -06:00
|
|
|
struct device *device, bool uevent, bool nowait)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-06-04 01:54:43 -06:00
|
|
|
struct firmware_priv *fw_priv;
|
|
|
|
struct device *f_dev;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-06-04 01:54:43 -06:00
|
|
|
fw_priv = kzalloc(sizeof(*fw_priv) + strlen(fw_name) + 1 , GFP_KERNEL);
|
|
|
|
if (!fw_priv) {
|
2008-10-15 23:04:20 -06:00
|
|
|
dev_err(device, "%s: kmalloc failed\n", __func__);
|
2012-03-28 15:30:43 -06:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2012-03-28 15:30:43 -06:00
|
|
|
fw_priv->fw = firmware;
|
2010-06-04 01:54:43 -06:00
|
|
|
fw_priv->nowait = nowait;
|
2010-03-14 00:49:23 -07:00
|
|
|
strcpy(fw_priv->fw_id, fw_name);
|
2005-04-16 16:20:36 -06:00
|
|
|
init_completion(&fw_priv->completion);
|
2010-06-04 01:54:43 -06:00
|
|
|
setup_timer(&fw_priv->timeout,
|
|
|
|
firmware_class_timeout, (u_long) fw_priv);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-06-04 01:54:43 -06:00
|
|
|
f_dev = &fw_priv->dev;
|
|
|
|
|
|
|
|
device_initialize(f_dev);
|
2009-06-02 16:39:55 -06:00
|
|
|
dev_set_name(f_dev, "%s", dev_name(device));
|
2006-09-14 08:30:59 -06:00
|
|
|
f_dev->parent = device;
|
|
|
|
f_dev->class = &firmware_class;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-06-04 01:54:43 -06:00
|
|
|
return fw_priv;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2012-03-28 15:30:43 -06:00
|
|
|
static struct firmware_priv *
|
|
|
|
_request_firmware_prepare(const struct firmware **firmware_p, const char *name,
|
|
|
|
struct device *device, bool uevent, bool nowait)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct firmware *firmware;
|
2012-03-28 15:30:43 -06:00
|
|
|
struct firmware_priv *fw_priv;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!firmware_p)
|
2012-03-28 15:30:43 -06:00
|
|
|
return ERR_PTR(-EINVAL);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-09-13 02:25:01 -06:00
|
|
|
*firmware_p = firmware = kzalloc(sizeof(*firmware), GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!firmware) {
|
2008-10-15 23:04:20 -06:00
|
|
|
dev_err(device, "%s: kmalloc(struct firmware) failed\n",
|
|
|
|
__func__);
|
2012-03-28 15:30:43 -06:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2010-03-14 00:49:18 -07:00
|
|
|
if (fw_get_builtin_firmware(firmware, name)) {
|
2010-02-27 13:43:22 -07:00
|
|
|
dev_dbg(device, "firmware: using built-in firmware %s\n", name);
|
2012-03-28 15:30:43 -06:00
|
|
|
return NULL;
|
2008-05-23 06:52:42 -06:00
|
|
|
}
|
|
|
|
|
2012-03-28 15:30:43 -06:00
|
|
|
fw_priv = fw_create_instance(firmware, name, device, uevent, nowait);
|
|
|
|
if (IS_ERR(fw_priv)) {
|
|
|
|
release_firmware(firmware);
|
|
|
|
*firmware_p = NULL;
|
|
|
|
}
|
|
|
|
return fw_priv;
|
2012-03-28 15:29:55 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void _request_firmware_cleanup(const struct firmware **firmware_p)
|
|
|
|
{
|
|
|
|
release_firmware(*firmware_p);
|
|
|
|
*firmware_p = NULL;
|
|
|
|
}
|
|
|
|
|
2012-08-03 22:01:16 -06:00
|
|
|
/* transfer the ownership of pages to firmware */
|
|
|
|
static int fw_set_page_data(struct firmware_priv *fw_priv)
|
|
|
|
{
|
|
|
|
struct firmware *fw = fw_priv->fw;
|
|
|
|
|
|
|
|
fw_priv->data = vmap(fw_priv->pages, fw_priv->nr_pages,
|
|
|
|
0, PAGE_KERNEL_RO);
|
|
|
|
if (!fw_priv->data)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
fw->data = fw_priv->data;
|
|
|
|
fw->pages = fw_priv->pages;
|
|
|
|
fw->size = fw_priv->size;
|
|
|
|
|
|
|
|
WARN_ON(PFN_UP(fw->size) != fw_priv->nr_pages);
|
|
|
|
|
|
|
|
fw_priv->nr_pages = 0;
|
|
|
|
fw_priv->pages = NULL;
|
|
|
|
fw_priv->data = NULL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-03-28 15:30:43 -06:00
|
|
|
static int _request_firmware_load(struct firmware_priv *fw_priv, bool uevent,
|
|
|
|
long timeout)
|
2012-03-28 15:29:55 -06:00
|
|
|
{
|
2012-03-28 15:30:02 -06:00
|
|
|
int retval = 0;
|
2012-03-28 15:30:43 -06:00
|
|
|
struct device *f_dev = &fw_priv->dev;
|
|
|
|
|
|
|
|
dev_set_uevent_suppress(f_dev, true);
|
2011-08-24 16:55:30 -06:00
|
|
|
|
2012-03-28 15:30:43 -06:00
|
|
|
/* Need to pin this module until class device is destroyed */
|
|
|
|
__module_get(THIS_MODULE);
|
2008-05-23 06:52:42 -06:00
|
|
|
|
2012-03-28 15:30:43 -06:00
|
|
|
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;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-11-16 01:00:00 -07:00
|
|
|
if (uevent) {
|
2012-03-28 15:30:43 -06:00
|
|
|
dev_set_uevent_suppress(f_dev, false);
|
|
|
|
dev_dbg(f_dev, "firmware: requesting %s\n", fw_priv->fw_id);
|
2012-03-28 15:30:02 -06:00
|
|
|
if (timeout != MAX_SCHEDULE_TIMEOUT)
|
2010-06-04 01:54:43 -06:00
|
|
|
mod_timer(&fw_priv->timeout,
|
2012-03-28 15:30:02 -06:00
|
|
|
round_jiffies_up(jiffies + timeout));
|
2010-06-04 01:54:43 -06:00
|
|
|
|
|
|
|
kobject_uevent(&fw_priv->dev.kobj, KOBJ_ADD);
|
|
|
|
}
|
|
|
|
|
|
|
|
wait_for_completion(&fw_priv->completion);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-06-04 01:54:43 -06:00
|
|
|
set_bit(FW_STATUS_DONE, &fw_priv->status);
|
|
|
|
del_timer_sync(&fw_priv->timeout);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-05-23 15:22:38 -06:00
|
|
|
mutex_lock(&fw_lock);
|
2012-08-03 22:01:16 -06:00
|
|
|
if (!fw_priv->size || test_bit(FW_STATUS_ABORT, &fw_priv->status))
|
2005-04-16 16:20:36 -06:00
|
|
|
retval = -ENOENT;
|
2012-08-03 22:01:16 -06:00
|
|
|
|
|
|
|
/* transfer pages ownership at the last minute */
|
|
|
|
if (!retval)
|
|
|
|
retval = fw_set_page_data(fw_priv);
|
2005-04-16 16:20:36 -06:00
|
|
|
fw_priv->fw = NULL;
|
2006-05-23 15:22:38 -06:00
|
|
|
mutex_unlock(&fw_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-03-28 15:30:43 -06:00
|
|
|
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);
|
2005-04-16 16:20:36 -06:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2005-09-06 16:17:13 -06:00
|
|
|
/**
|
2005-11-16 01:00:00 -07:00
|
|
|
* request_firmware: - send firmware request and wait for it
|
2005-10-30 16:03:01 -07:00
|
|
|
* @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
|
2005-09-06 16:17:13 -06:00
|
|
|
* of @name for device @device.
|
|
|
|
*
|
|
|
|
* Should be called from user context where sleeping is allowed.
|
|
|
|
*
|
2005-11-16 01:00:00 -07:00
|
|
|
* @name will be used as $FIRMWARE in the uevent environment and
|
2005-09-06 16:17:13 -06:00
|
|
|
* 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)
|
|
|
|
{
|
2012-03-28 15:30:43 -06:00
|
|
|
struct firmware_priv *fw_priv;
|
2012-03-28 15:29:55 -06:00
|
|
|
int ret;
|
|
|
|
|
2012-03-28 15:30:43 -06:00
|
|
|
fw_priv = _request_firmware_prepare(firmware_p, name, device, true,
|
|
|
|
false);
|
|
|
|
if (IS_ERR_OR_NULL(fw_priv))
|
|
|
|
return PTR_RET(fw_priv);
|
2012-03-28 15:29:55 -06:00
|
|
|
|
2012-03-28 15:30:02 -06:00
|
|
|
ret = usermodehelper_read_trylock();
|
|
|
|
if (WARN_ON(ret)) {
|
|
|
|
dev_err(device, "firmware: %s will not be loaded\n", name);
|
|
|
|
} else {
|
2012-03-28 15:30:43 -06:00
|
|
|
ret = _request_firmware_load(fw_priv, true,
|
2012-03-28 15:30:02 -06:00
|
|
|
firmware_loading_timeout());
|
|
|
|
usermodehelper_read_unlock();
|
|
|
|
}
|
2012-03-28 15:29:55 -06:00
|
|
|
if (ret)
|
|
|
|
_request_firmware_cleanup(firmware_p);
|
|
|
|
|
|
|
|
return ret;
|
2005-09-06 16:17:13 -06:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/**
|
|
|
|
* release_firmware: - release the resource associated with a firmware image
|
2005-10-30 16:03:01 -07:00
|
|
|
* @fw: firmware resource to release
|
2005-04-16 16:20:36 -06:00
|
|
|
**/
|
2010-03-14 00:49:18 -07:00
|
|
|
void release_firmware(const struct firmware *fw)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
if (fw) {
|
2010-03-14 00:49:18 -07:00
|
|
|
if (!fw_is_builtin_firmware(fw))
|
|
|
|
firmware_free_data(fw);
|
2005-04-16 16:20:36 -06:00
|
|
|
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);
|
2011-01-26 03:33:32 -07:00
|
|
|
bool uevent;
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2012-03-28 15:31:00 -06:00
|
|
|
static void request_firmware_work_func(struct work_struct *work)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-03-28 15:31:00 -06:00
|
|
|
struct firmware_work *fw_work;
|
2005-04-16 16:20:36 -06:00
|
|
|
const struct firmware *fw;
|
2012-03-28 15:30:43 -06:00
|
|
|
struct firmware_priv *fw_priv;
|
2012-03-28 15:30:02 -06:00
|
|
|
long timeout;
|
2005-11-13 17:07:39 -07:00
|
|
|
int ret;
|
2010-06-04 01:54:43 -06:00
|
|
|
|
2012-03-28 15:31:00 -06:00
|
|
|
fw_work = container_of(work, struct firmware_work, work);
|
2012-03-28 15:30:43 -06:00
|
|
|
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);
|
2012-03-28 15:29:55 -06:00
|
|
|
goto out;
|
2012-03-28 15:30:43 -06:00
|
|
|
}
|
2012-03-28 15:29:55 -06:00
|
|
|
|
2012-03-28 15:30:02 -06:00
|
|
|
timeout = usermodehelper_read_lock_wait(firmware_loading_timeout());
|
|
|
|
if (timeout) {
|
2012-03-28 15:30:43 -06:00
|
|
|
ret = _request_firmware_load(fw_priv, fw_work->uevent, timeout);
|
2012-03-28 15:30:02 -06:00
|
|
|
usermodehelper_read_unlock();
|
|
|
|
} else {
|
|
|
|
dev_dbg(fw_work->device, "firmware: %s loading timed out\n",
|
|
|
|
fw_work->name);
|
|
|
|
ret = -EAGAIN;
|
|
|
|
}
|
2012-03-28 15:29:55 -06:00
|
|
|
if (ret)
|
|
|
|
_request_firmware_cleanup(&fw);
|
|
|
|
|
|
|
|
out:
|
2009-10-29 05:36:02 -06:00
|
|
|
fw_work->cont(fw, fw_work->context);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
module_put(fw_work->module);
|
|
|
|
kfree(fw_work);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-02-14 07:18:53 -07:00
|
|
|
* request_firmware_nowait - asynchronous version of request_firmware
|
2005-10-30 16:03:01 -07:00
|
|
|
* @module: module requesting the firmware
|
2005-11-16 01:00:00 -07:00
|
|
|
* @uevent: sends uevent to copy the firmware image if this flag
|
2005-10-30 16:03:01 -07:00
|
|
|
* is non-zero else the firmware copy must be done manually.
|
|
|
|
* @name: name of firmware file
|
|
|
|
* @device: device for which firmware is being loaded
|
2009-10-29 05:36:02 -06:00
|
|
|
* @gfp: allocation flags
|
2005-10-30 16:03:01 -07:00
|
|
|
* @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.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2009-05-28 21:33:19 -06:00
|
|
|
* 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.
|
2005-04-16 16:20:36 -06:00
|
|
|
**/
|
|
|
|
int
|
|
|
|
request_firmware_nowait(
|
2011-01-26 03:33:32 -07:00
|
|
|
struct module *module, bool uevent,
|
2009-10-29 05:36:02 -06:00
|
|
|
const char *name, struct device *device, gfp_t gfp, void *context,
|
2005-04-16 16:20:36 -06:00
|
|
|
void (*cont)(const struct firmware *fw, void *context))
|
|
|
|
{
|
2010-06-04 01:54:43 -06:00
|
|
|
struct firmware_work *fw_work;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-06-04 01:54:43 -06:00
|
|
|
fw_work = kzalloc(sizeof (struct firmware_work), gfp);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!fw_work)
|
|
|
|
return -ENOMEM;
|
2010-06-04 01:54:43 -06:00
|
|
|
|
|
|
|
fw_work->module = module;
|
|
|
|
fw_work->name = name;
|
|
|
|
fw_work->device = device;
|
|
|
|
fw_work->context = context;
|
|
|
|
fw_work->cont = cont;
|
|
|
|
fw_work->uevent = uevent;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!try_module_get(module)) {
|
|
|
|
kfree(fw_work);
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
|
2012-03-28 15:31:00 -06:00
|
|
|
INIT_WORK(&fw_work->work, request_firmware_work_func);
|
|
|
|
schedule_work(&fw_work->work);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-03-14 00:49:13 -07:00
|
|
|
static int __init firmware_class_init(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-03-14 00:49:13 -07:00
|
|
|
return class_register(&firmware_class);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2010-03-14 00:49:13 -07:00
|
|
|
|
|
|
|
static void __exit firmware_class_exit(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
class_unregister(&firmware_class);
|
|
|
|
}
|
|
|
|
|
2006-09-27 02:50:52 -06:00
|
|
|
fs_initcall(firmware_class_init);
|
2005-04-16 16:20:36 -06:00
|
|
|
module_exit(firmware_class_exit);
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(release_firmware);
|
|
|
|
EXPORT_SYMBOL(request_firmware);
|
|
|
|
EXPORT_SYMBOL(request_firmware_nowait);
|