compat/compat_firmware_class.c

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