Backport the new firmware_class from > 2.6.33 down to 2.6.23
authorLuis R. Rodriguez <lrodriguez@atheros.com>
Thu, 14 Jan 2010 01:09:24 +0000 (17:09 -0800)
committerLuis R. Rodriguez <lrodriguez@atheros.com>
Thu, 14 Jan 2010 01:11:12 +0000 (17:11 -0800)
My main concern with this backport was the usage of the
core driver "base.h" but as it turns out firmware_class doesn't
even need it. This allowed the backport to go through.

This new backport allows drivers which use the new modified firmware
API request_firmware_nowait() on older kernels. You should not
need to chagne the your request_firmware_nowait() calls at all;
the compat-2.6.32.h header ensures that your calls get mapped
to compat_request_firmware_nowait()

Signed-off-by: Luis R. Rodriguez <lrodriguez@atheros.com>
compat/Makefile
compat/compat_firmware_class.c [new file with mode: 0644]
include/linux/compat-2.6.27.h
include/linux/compat-2.6.32.h

index d950f47..e3560a7 100644 (file)
@@ -1,6 +1,8 @@
 obj-m += compat.o
 #compat-objs :=
 
+obj-m += compat_firmware_class.o
+
 compat-y += main.o
 
 # Compat kernel compatibility code
diff --git a/compat/compat_firmware_class.c b/compat/compat_firmware_class.c
new file mode 100644 (file)
index 0000000..2c1159a
--- /dev/null
@@ -0,0 +1,726 @@
+/*
+ * 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/highmem.h>
+#include <linux/firmware.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;
+       struct completion completion;
+       struct bin_attribute attr_data;
+       struct firmware *fw;
+       unsigned long status;
+       struct page **pages;
+       int nr_pages;
+       int page_array_size;
+       const char *vdata;
+       struct timer_list timeout;
+};
+
+//#ifdef CONFIG_FW_LOADER
+#if 0
+extern struct builtin_fw __start_builtin_fw[];
+extern struct builtin_fw __end_builtin_fw[];
+#else /* Module case. Avoid ifdefs later; it'll all optimise out */
+static struct builtin_fw *__start_builtin_fw;
+static struct builtin_fw *__end_builtin_fw;
+#endif
+
+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);
+
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24))
+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;
+}
+#else
+static int firmware_uevent(struct device *dev, char **envp,
+                          int num_envp, char *buf, int size)
+{
+       struct firmware_priv *fw_priv = dev_get_drvdata(dev);
+       int error, len = 0, i = 0;
+
+       error = add_uevent_var(envp, num_envp, &i,
+                              buf, size, &len,
+                              "FIRMWARE=%s", fw_priv->fw_id);
+       if (error)
+               goto exit;
+
+       error = add_uevent_var(envp, num_envp, &i,
+                              buf, size, &len,
+                              "TIMEOUT=%i", loading_timeout);
+       if (error)
+               goto exit;
+
+       return 0;
+exit:
+       envp[i] = NULL;
+       return error;
+}
+#endif
+
+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);
+}
+
+/* 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 = dev_get_drvdata(dev);
+       int loading = simple_strtol(buf, NULL, 10);
+       int i;
+
+       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;
+               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;
+               fw_priv->fw->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)) {
+                       vfree(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 will be freed by vfree() */
+                       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;
+       }
+
+       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;
+
+       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
+ * @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;
+
+       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_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);
+       int i;
+
+       for (i = 0; i < fw_priv->nr_pages; i++)
+               __free_page(fw_priv->pages[i]);
+       kfree(fw_priv->pages);
+       kfree(fw_priv->fw_id);
+       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 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) {
+               dev_err(device, "%s: kmalloc failed\n", __func__);
+               retval = -ENOMEM;
+               goto error_kfree;
+       }
+
+       init_completion(&fw_priv->completion);
+       fw_priv->attr_data = firmware_attr_data_tmpl;
+       fw_priv->fw_id = kstrdup(fw_name, GFP_KERNEL);
+       if (!fw_priv->fw_id) {
+               dev_err(device, "%s: Firmware name allocation failed\n",
+                       __func__);
+               retval = -ENOMEM;
+               goto error_kfree;
+       }
+
+       fw_priv->timeout.function = firmware_class_timeout;
+       fw_priv->timeout.data = (u_long) fw_priv;
+       init_timer(&fw_priv->timeout);
+
+       dev_set_name(f_dev, "%s", dev_name(device));
+       f_dev->parent = device;
+       f_dev->class = &firmware_class;
+       dev_set_drvdata(f_dev, fw_priv);
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,30))
+       dev_set_uevent_suppress(f_dev, 1);
+#endif
+       retval = device_register(f_dev);
+       if (retval) {
+               dev_err(device, "%s: device_register failed\n", __func__);
+               put_device(f_dev);
+               return retval;
+       }
+       *dev_p = f_dev;
+       return 0;
+
+error_kfree:
+       kfree(f_dev);
+       kfree(fw_priv);
+       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) {
+               dev_err(device, "%s: sysfs_create_bin_file failed\n", __func__);
+               goto error_unreg;
+       }
+
+       retval = device_create_file(f_dev, &dev_attr_loading);
+       if (retval) {
+               dev_err(device, "%s: device_create_file failed\n", __func__);
+               goto error_unreg;
+       }
+
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,30))
+       if (uevent)
+               dev_set_uevent_suppress(f_dev, 0);
+#endif
+       *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;
+       struct builtin_fw *builtin;
+       int retval;
+
+       if (!firmware_p)
+               return -EINVAL;
+
+       *firmware_p = firmware = kzalloc(sizeof(*firmware), GFP_KERNEL);
+       if (!firmware) {
+               dev_err(device, "%s: kmalloc(struct firmware) failed\n",
+                       __func__);
+               retval = -ENOMEM;
+               goto out;
+       }
+
+       for (builtin = __start_builtin_fw; builtin != __end_builtin_fw;
+            builtin++) {
+               if (strcmp(name, builtin->name))
+                       continue;
+               dev_info(device, "firmware: using built-in firmware %s\n",
+                        name);
+               firmware->size = builtin->size;
+               firmware->data = builtin->data;
+               return 0;
+       }
+
+       if (uevent)
+               dev_info(device, "firmware: requesting %s\n", name);
+
+       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)
+{
+       struct builtin_fw *builtin;
+
+       if (fw) {
+               for (builtin = __start_builtin_fw; builtin != __end_builtin_fw;
+                    builtin++) {
+                       if (fw->data == builtin->data)
+                               goto free_fw;
+               }
+               vfree(fw->data);
+       free_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);
+       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);
+
+       fw_work->cont(fw, fw_work->context);
+
+       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
+ * @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, int uevent,
+       const char *name, struct device *device, gfp_t gfp, 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);
+
+       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", __func__);
+               return error;
+       }
+       error = class_create_file(&firmware_class, &class_attr_timeout);
+       if (error) {
+               printk(KERN_ERR "%s: class_create_file failed\n",
+                      __func__);
+               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);
index 6d6bd88..657cba0 100644 (file)
 /* I can't find a more suitable replacement... */
 #define flush_work(work) cancel_work_sync(work)
 
+struct builtin_fw {
+       char *name;
+       void *data;
+       unsigned long size;
+};
+
 /*
  * On older kernels we do not have net_device Multi Queue support, but
  * since we no longer use MQ on mac80211 we can simply use the 0 queue.
index c3e4dbe..fbdde52 100644 (file)
@@ -9,6 +9,40 @@
 #include <asm/compat.h>
 #include <net/iw_handler.h>
 #include <linux/workqueue.h>
+#include <linux/firmware.h>
+
+#define release_firmware compat_release_firmware
+#define request_firmware compat_request_firmware
+#define request_firmware_nowait compat_request_firmware_nowait
+
+#if defined(CONFIG_FW_LOADER) || (defined(CONFIG_FW_LOADER_MODULE) && defined(MODULE))
+int compat_request_firmware(const struct firmware **fw, const char *name,
+                    struct device *device);
+int compat_request_firmware_nowait(
+       struct module *module, int uevent,
+       const char *name, struct device *device, gfp_t gfp, void *context,
+       void (*cont)(const struct firmware *fw, void *context));
+
+void compat_release_firmware(const struct firmware *fw);
+#else
+static inline int compat_request_firmware(const struct firmware **fw,
+                                  const char *name,
+                                  struct device *device)
+{
+       return -EINVAL;
+}
+static inline int request_firmware_nowait(
+       struct module *module, int uevent,
+       const char *name, struct device *device, gfp_t gfp, void *context,
+       void (*cont)(const struct firmware *fw, void *context))
+{
+       return -EINVAL;
+}
+
+static inline void compat_release_firmware(const struct firmware *fw)
+{
+}
+#endif
 
 #define SDIO_VENDOR_ID_INTEL                   0x0089
 #define SDIO_DEVICE_ID_INTEL_IWMC3200WIMAX     0x1402