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