linux/drivers/base/firmware_loader/main.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * main.c - Multi purpose firmware loading support
   4 *
   5 * Copyright (c) 2003 Manuel Estrada Sainz
   6 *
   7 * Please see Documentation/driver-api/firmware/ for more information.
   8 *
   9 */
  10
  11#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  12
  13#include <linux/capability.h>
  14#include <linux/device.h>
  15#include <linux/module.h>
  16#include <linux/init.h>
  17#include <linux/timer.h>
  18#include <linux/vmalloc.h>
  19#include <linux/interrupt.h>
  20#include <linux/bitops.h>
  21#include <linux/mutex.h>
  22#include <linux/workqueue.h>
  23#include <linux/highmem.h>
  24#include <linux/firmware.h>
  25#include <linux/slab.h>
  26#include <linux/sched.h>
  27#include <linux/file.h>
  28#include <linux/list.h>
  29#include <linux/fs.h>
  30#include <linux/async.h>
  31#include <linux/pm.h>
  32#include <linux/suspend.h>
  33#include <linux/syscore_ops.h>
  34#include <linux/reboot.h>
  35#include <linux/security.h>
  36#include <linux/xz.h>
  37
  38#include <generated/utsrelease.h>
  39
  40#include "../base.h"
  41#include "firmware.h"
  42#include "fallback.h"
  43
  44MODULE_AUTHOR("Manuel Estrada Sainz");
  45MODULE_DESCRIPTION("Multi purpose firmware loading support");
  46MODULE_LICENSE("GPL");
  47
  48struct firmware_cache {
  49        /* firmware_buf instance will be added into the below list */
  50        spinlock_t lock;
  51        struct list_head head;
  52        int state;
  53
  54#ifdef CONFIG_FW_CACHE
  55        /*
  56         * Names of firmware images which have been cached successfully
  57         * will be added into the below list so that device uncache
  58         * helper can trace which firmware images have been cached
  59         * before.
  60         */
  61        spinlock_t name_lock;
  62        struct list_head fw_names;
  63
  64        struct delayed_work work;
  65
  66        struct notifier_block   pm_notify;
  67#endif
  68};
  69
  70struct fw_cache_entry {
  71        struct list_head list;
  72        const char *name;
  73};
  74
  75struct fw_name_devm {
  76        unsigned long magic;
  77        const char *name;
  78};
  79
  80static inline struct fw_priv *to_fw_priv(struct kref *ref)
  81{
  82        return container_of(ref, struct fw_priv, ref);
  83}
  84
  85#define FW_LOADER_NO_CACHE      0
  86#define FW_LOADER_START_CACHE   1
  87
  88/* fw_lock could be moved to 'struct fw_sysfs' but since it is just
  89 * guarding for corner cases a global lock should be OK */
  90DEFINE_MUTEX(fw_lock);
  91
  92static struct firmware_cache fw_cache;
  93
  94/* Builtin firmware support */
  95
  96#ifdef CONFIG_FW_LOADER
  97
  98extern struct builtin_fw __start_builtin_fw[];
  99extern struct builtin_fw __end_builtin_fw[];
 100
 101static void fw_copy_to_prealloc_buf(struct firmware *fw,
 102                                    void *buf, size_t size)
 103{
 104        if (!buf || size < fw->size)
 105                return;
 106        memcpy(buf, fw->data, fw->size);
 107}
 108
 109static bool fw_get_builtin_firmware(struct firmware *fw, const char *name,
 110                                    void *buf, size_t size)
 111{
 112        struct builtin_fw *b_fw;
 113
 114        for (b_fw = __start_builtin_fw; b_fw != __end_builtin_fw; b_fw++) {
 115                if (strcmp(name, b_fw->name) == 0) {
 116                        fw->size = b_fw->size;
 117                        fw->data = b_fw->data;
 118                        fw_copy_to_prealloc_buf(fw, buf, size);
 119
 120                        return true;
 121                }
 122        }
 123
 124        return false;
 125}
 126
 127static bool fw_is_builtin_firmware(const struct firmware *fw)
 128{
 129        struct builtin_fw *b_fw;
 130
 131        for (b_fw = __start_builtin_fw; b_fw != __end_builtin_fw; b_fw++)
 132                if (fw->data == b_fw->data)
 133                        return true;
 134
 135        return false;
 136}
 137
 138#else /* Module case - no builtin firmware support */
 139
 140static inline bool fw_get_builtin_firmware(struct firmware *fw,
 141                                           const char *name, void *buf,
 142                                           size_t size)
 143{
 144        return false;
 145}
 146
 147static inline bool fw_is_builtin_firmware(const struct firmware *fw)
 148{
 149        return false;
 150}
 151#endif
 152
 153static void fw_state_init(struct fw_priv *fw_priv)
 154{
 155        struct fw_state *fw_st = &fw_priv->fw_st;
 156
 157        init_completion(&fw_st->completion);
 158        fw_st->status = FW_STATUS_UNKNOWN;
 159}
 160
 161static inline int fw_state_wait(struct fw_priv *fw_priv)
 162{
 163        return __fw_state_wait_common(fw_priv, MAX_SCHEDULE_TIMEOUT);
 164}
 165
 166static int fw_cache_piggyback_on_request(const char *name);
 167
 168static struct fw_priv *__allocate_fw_priv(const char *fw_name,
 169                                          struct firmware_cache *fwc,
 170                                          void *dbuf, size_t size)
 171{
 172        struct fw_priv *fw_priv;
 173
 174        fw_priv = kzalloc(sizeof(*fw_priv), GFP_ATOMIC);
 175        if (!fw_priv)
 176                return NULL;
 177
 178        fw_priv->fw_name = kstrdup_const(fw_name, GFP_ATOMIC);
 179        if (!fw_priv->fw_name) {
 180                kfree(fw_priv);
 181                return NULL;
 182        }
 183
 184        kref_init(&fw_priv->ref);
 185        fw_priv->fwc = fwc;
 186        fw_priv->data = dbuf;
 187        fw_priv->allocated_size = size;
 188        fw_state_init(fw_priv);
 189#ifdef CONFIG_FW_LOADER_USER_HELPER
 190        INIT_LIST_HEAD(&fw_priv->pending_list);
 191#endif
 192
 193        pr_debug("%s: fw-%s fw_priv=%p\n", __func__, fw_name, fw_priv);
 194
 195        return fw_priv;
 196}
 197
 198static struct fw_priv *__lookup_fw_priv(const char *fw_name)
 199{
 200        struct fw_priv *tmp;
 201        struct firmware_cache *fwc = &fw_cache;
 202
 203        list_for_each_entry(tmp, &fwc->head, list)
 204                if (!strcmp(tmp->fw_name, fw_name))
 205                        return tmp;
 206        return NULL;
 207}
 208
 209/* Returns 1 for batching firmware requests with the same name */
 210static int alloc_lookup_fw_priv(const char *fw_name,
 211                                struct firmware_cache *fwc,
 212                                struct fw_priv **fw_priv, void *dbuf,
 213                                size_t size, enum fw_opt opt_flags)
 214{
 215        struct fw_priv *tmp;
 216
 217        spin_lock(&fwc->lock);
 218        if (!(opt_flags & FW_OPT_NOCACHE)) {
 219                tmp = __lookup_fw_priv(fw_name);
 220                if (tmp) {
 221                        kref_get(&tmp->ref);
 222                        spin_unlock(&fwc->lock);
 223                        *fw_priv = tmp;
 224                        pr_debug("batched request - sharing the same struct fw_priv and lookup for multiple requests\n");
 225                        return 1;
 226                }
 227        }
 228
 229        tmp = __allocate_fw_priv(fw_name, fwc, dbuf, size);
 230        if (tmp) {
 231                INIT_LIST_HEAD(&tmp->list);
 232                if (!(opt_flags & FW_OPT_NOCACHE))
 233                        list_add(&tmp->list, &fwc->head);
 234        }
 235        spin_unlock(&fwc->lock);
 236
 237        *fw_priv = tmp;
 238
 239        return tmp ? 0 : -ENOMEM;
 240}
 241
 242static void __free_fw_priv(struct kref *ref)
 243        __releases(&fwc->lock)
 244{
 245        struct fw_priv *fw_priv = to_fw_priv(ref);
 246        struct firmware_cache *fwc = fw_priv->fwc;
 247
 248        pr_debug("%s: fw-%s fw_priv=%p data=%p size=%u\n",
 249                 __func__, fw_priv->fw_name, fw_priv, fw_priv->data,
 250                 (unsigned int)fw_priv->size);
 251
 252        list_del(&fw_priv->list);
 253        spin_unlock(&fwc->lock);
 254
 255        fw_free_paged_buf(fw_priv); /* free leftover pages */
 256        if (!fw_priv->allocated_size)
 257                vfree(fw_priv->data);
 258        kfree_const(fw_priv->fw_name);
 259        kfree(fw_priv);
 260}
 261
 262static void free_fw_priv(struct fw_priv *fw_priv)
 263{
 264        struct firmware_cache *fwc = fw_priv->fwc;
 265        spin_lock(&fwc->lock);
 266        if (!kref_put(&fw_priv->ref, __free_fw_priv))
 267                spin_unlock(&fwc->lock);
 268}
 269
 270#ifdef CONFIG_FW_LOADER_PAGED_BUF
 271void fw_free_paged_buf(struct fw_priv *fw_priv)
 272{
 273        int i;
 274
 275        if (!fw_priv->pages)
 276                return;
 277
 278        for (i = 0; i < fw_priv->nr_pages; i++)
 279                __free_page(fw_priv->pages[i]);
 280        kvfree(fw_priv->pages);
 281        fw_priv->pages = NULL;
 282        fw_priv->page_array_size = 0;
 283        fw_priv->nr_pages = 0;
 284}
 285
 286int fw_grow_paged_buf(struct fw_priv *fw_priv, int pages_needed)
 287{
 288        /* If the array of pages is too small, grow it */
 289        if (fw_priv->page_array_size < pages_needed) {
 290                int new_array_size = max(pages_needed,
 291                                         fw_priv->page_array_size * 2);
 292                struct page **new_pages;
 293
 294                new_pages = kvmalloc_array(new_array_size, sizeof(void *),
 295                                           GFP_KERNEL);
 296                if (!new_pages)
 297                        return -ENOMEM;
 298                memcpy(new_pages, fw_priv->pages,
 299                       fw_priv->page_array_size * sizeof(void *));
 300                memset(&new_pages[fw_priv->page_array_size], 0, sizeof(void *) *
 301                       (new_array_size - fw_priv->page_array_size));
 302                kvfree(fw_priv->pages);
 303                fw_priv->pages = new_pages;
 304                fw_priv->page_array_size = new_array_size;
 305        }
 306
 307        while (fw_priv->nr_pages < pages_needed) {
 308                fw_priv->pages[fw_priv->nr_pages] =
 309                        alloc_page(GFP_KERNEL | __GFP_HIGHMEM);
 310
 311                if (!fw_priv->pages[fw_priv->nr_pages])
 312                        return -ENOMEM;
 313                fw_priv->nr_pages++;
 314        }
 315
 316        return 0;
 317}
 318
 319int fw_map_paged_buf(struct fw_priv *fw_priv)
 320{
 321        /* one pages buffer should be mapped/unmapped only once */
 322        if (!fw_priv->pages)
 323                return 0;
 324
 325        vunmap(fw_priv->data);
 326        fw_priv->data = vmap(fw_priv->pages, fw_priv->nr_pages, 0,
 327                             PAGE_KERNEL_RO);
 328        if (!fw_priv->data)
 329                return -ENOMEM;
 330
 331        /* page table is no longer needed after mapping, let's free */
 332        kvfree(fw_priv->pages);
 333        fw_priv->pages = NULL;
 334
 335        return 0;
 336}
 337#endif
 338
 339/*
 340 * XZ-compressed firmware support
 341 */
 342#ifdef CONFIG_FW_LOADER_COMPRESS
 343/* show an error and return the standard error code */
 344static int fw_decompress_xz_error(struct device *dev, enum xz_ret xz_ret)
 345{
 346        if (xz_ret != XZ_STREAM_END) {
 347                dev_warn(dev, "xz decompression failed (xz_ret=%d)\n", xz_ret);
 348                return xz_ret == XZ_MEM_ERROR ? -ENOMEM : -EINVAL;
 349        }
 350        return 0;
 351}
 352
 353/* single-shot decompression onto the pre-allocated buffer */
 354static int fw_decompress_xz_single(struct device *dev, struct fw_priv *fw_priv,
 355                                   size_t in_size, const void *in_buffer)
 356{
 357        struct xz_dec *xz_dec;
 358        struct xz_buf xz_buf;
 359        enum xz_ret xz_ret;
 360
 361        xz_dec = xz_dec_init(XZ_SINGLE, (u32)-1);
 362        if (!xz_dec)
 363                return -ENOMEM;
 364
 365        xz_buf.in_size = in_size;
 366        xz_buf.in = in_buffer;
 367        xz_buf.in_pos = 0;
 368        xz_buf.out_size = fw_priv->allocated_size;
 369        xz_buf.out = fw_priv->data;
 370        xz_buf.out_pos = 0;
 371
 372        xz_ret = xz_dec_run(xz_dec, &xz_buf);
 373        xz_dec_end(xz_dec);
 374
 375        fw_priv->size = xz_buf.out_pos;
 376        return fw_decompress_xz_error(dev, xz_ret);
 377}
 378
 379/* decompression on paged buffer and map it */
 380static int fw_decompress_xz_pages(struct device *dev, struct fw_priv *fw_priv,
 381                                  size_t in_size, const void *in_buffer)
 382{
 383        struct xz_dec *xz_dec;
 384        struct xz_buf xz_buf;
 385        enum xz_ret xz_ret;
 386        struct page *page;
 387        int err = 0;
 388
 389        xz_dec = xz_dec_init(XZ_DYNALLOC, (u32)-1);
 390        if (!xz_dec)
 391                return -ENOMEM;
 392
 393        xz_buf.in_size = in_size;
 394        xz_buf.in = in_buffer;
 395        xz_buf.in_pos = 0;
 396
 397        fw_priv->is_paged_buf = true;
 398        fw_priv->size = 0;
 399        do {
 400                if (fw_grow_paged_buf(fw_priv, fw_priv->nr_pages + 1)) {
 401                        err = -ENOMEM;
 402                        goto out;
 403                }
 404
 405                /* decompress onto the new allocated page */
 406                page = fw_priv->pages[fw_priv->nr_pages - 1];
 407                xz_buf.out = kmap(page);
 408                xz_buf.out_pos = 0;
 409                xz_buf.out_size = PAGE_SIZE;
 410                xz_ret = xz_dec_run(xz_dec, &xz_buf);
 411                kunmap(page);
 412                fw_priv->size += xz_buf.out_pos;
 413                /* partial decompression means either end or error */
 414                if (xz_buf.out_pos != PAGE_SIZE)
 415                        break;
 416        } while (xz_ret == XZ_OK);
 417
 418        err = fw_decompress_xz_error(dev, xz_ret);
 419        if (!err)
 420                err = fw_map_paged_buf(fw_priv);
 421
 422 out:
 423        xz_dec_end(xz_dec);
 424        return err;
 425}
 426
 427static int fw_decompress_xz(struct device *dev, struct fw_priv *fw_priv,
 428                            size_t in_size, const void *in_buffer)
 429{
 430        /* if the buffer is pre-allocated, we can perform in single-shot mode */
 431        if (fw_priv->data)
 432                return fw_decompress_xz_single(dev, fw_priv, in_size, in_buffer);
 433        else
 434                return fw_decompress_xz_pages(dev, fw_priv, in_size, in_buffer);
 435}
 436#endif /* CONFIG_FW_LOADER_COMPRESS */
 437
 438/* direct firmware loading support */
 439static char fw_path_para[256];
 440static const char * const fw_path[] = {
 441        fw_path_para,
 442        "/lib/firmware/updates/" UTS_RELEASE,
 443        "/lib/firmware/updates",
 444        "/lib/firmware/" UTS_RELEASE,
 445        "/lib/firmware"
 446};
 447
 448/*
 449 * Typical usage is that passing 'firmware_class.path=$CUSTOMIZED_PATH'
 450 * from kernel command line because firmware_class is generally built in
 451 * kernel instead of module.
 452 */
 453module_param_string(path, fw_path_para, sizeof(fw_path_para), 0644);
 454MODULE_PARM_DESC(path, "customized firmware image search path with a higher priority than default path");
 455
 456static int
 457fw_get_filesystem_firmware(struct device *device, struct fw_priv *fw_priv,
 458                           const char *suffix,
 459                           int (*decompress)(struct device *dev,
 460                                             struct fw_priv *fw_priv,
 461                                             size_t in_size,
 462                                             const void *in_buffer))
 463{
 464        loff_t size;
 465        int i, len;
 466        int rc = -ENOENT;
 467        char *path;
 468        enum kernel_read_file_id id = READING_FIRMWARE;
 469        size_t msize = INT_MAX;
 470        void *buffer = NULL;
 471
 472        /* Already populated data member means we're loading into a buffer */
 473        if (!decompress && fw_priv->data) {
 474                buffer = fw_priv->data;
 475                id = READING_FIRMWARE_PREALLOC_BUFFER;
 476                msize = fw_priv->allocated_size;
 477        }
 478
 479        path = __getname();
 480        if (!path)
 481                return -ENOMEM;
 482
 483        for (i = 0; i < ARRAY_SIZE(fw_path); i++) {
 484                /* skip the unset customized path */
 485                if (!fw_path[i][0])
 486                        continue;
 487
 488                len = snprintf(path, PATH_MAX, "%s/%s%s",
 489                               fw_path[i], fw_priv->fw_name, suffix);
 490                if (len >= PATH_MAX) {
 491                        rc = -ENAMETOOLONG;
 492                        break;
 493                }
 494
 495                fw_priv->size = 0;
 496                rc = kernel_read_file_from_path(path, &buffer, &size,
 497                                                msize, id);
 498                if (rc) {
 499                        if (rc != -ENOENT)
 500                                dev_warn(device, "loading %s failed with error %d\n",
 501                                         path, rc);
 502                        else
 503                                dev_dbg(device, "loading %s failed for no such file or directory.\n",
 504                                         path);
 505                        continue;
 506                }
 507                dev_dbg(device, "Loading firmware from %s\n", path);
 508                if (decompress) {
 509                        dev_dbg(device, "f/w decompressing %s\n",
 510                                fw_priv->fw_name);
 511                        rc = decompress(device, fw_priv, size, buffer);
 512                        /* discard the superfluous original content */
 513                        vfree(buffer);
 514                        buffer = NULL;
 515                        if (rc) {
 516                                fw_free_paged_buf(fw_priv);
 517                                continue;
 518                        }
 519                } else {
 520                        dev_dbg(device, "direct-loading %s\n",
 521                                fw_priv->fw_name);
 522                        if (!fw_priv->data)
 523                                fw_priv->data = buffer;
 524                        fw_priv->size = size;
 525                }
 526                fw_state_done(fw_priv);
 527                break;
 528        }
 529        __putname(path);
 530
 531        return rc;
 532}
 533
 534/* firmware holds the ownership of pages */
 535static void firmware_free_data(const struct firmware *fw)
 536{
 537        /* Loaded directly? */
 538        if (!fw->priv) {
 539                vfree(fw->data);
 540                return;
 541        }
 542        free_fw_priv(fw->priv);
 543}
 544
 545/* store the pages buffer info firmware from buf */
 546static void fw_set_page_data(struct fw_priv *fw_priv, struct firmware *fw)
 547{
 548        fw->priv = fw_priv;
 549#ifdef CONFIG_FW_LOADER_USER_HELPER
 550        fw->pages = fw_priv->pages;
 551#endif
 552        fw->size = fw_priv->size;
 553        fw->data = fw_priv->data;
 554
 555        pr_debug("%s: fw-%s fw_priv=%p data=%p size=%u\n",
 556                 __func__, fw_priv->fw_name, fw_priv, fw_priv->data,
 557                 (unsigned int)fw_priv->size);
 558}
 559
 560#ifdef CONFIG_FW_CACHE
 561static void fw_name_devm_release(struct device *dev, void *res)
 562{
 563        struct fw_name_devm *fwn = res;
 564
 565        if (fwn->magic == (unsigned long)&fw_cache)
 566                pr_debug("%s: fw_name-%s devm-%p released\n",
 567                                __func__, fwn->name, res);
 568        kfree_const(fwn->name);
 569}
 570
 571static int fw_devm_match(struct device *dev, void *res,
 572                void *match_data)
 573{
 574        struct fw_name_devm *fwn = res;
 575
 576        return (fwn->magic == (unsigned long)&fw_cache) &&
 577                !strcmp(fwn->name, match_data);
 578}
 579
 580static struct fw_name_devm *fw_find_devm_name(struct device *dev,
 581                const char *name)
 582{
 583        struct fw_name_devm *fwn;
 584
 585        fwn = devres_find(dev, fw_name_devm_release,
 586                          fw_devm_match, (void *)name);
 587        return fwn;
 588}
 589
 590static bool fw_cache_is_setup(struct device *dev, const char *name)
 591{
 592        struct fw_name_devm *fwn;
 593
 594        fwn = fw_find_devm_name(dev, name);
 595        if (fwn)
 596                return true;
 597
 598        return false;
 599}
 600
 601/* add firmware name into devres list */
 602static int fw_add_devm_name(struct device *dev, const char *name)
 603{
 604        struct fw_name_devm *fwn;
 605
 606        if (fw_cache_is_setup(dev, name))
 607                return 0;
 608
 609        fwn = devres_alloc(fw_name_devm_release, sizeof(struct fw_name_devm),
 610                           GFP_KERNEL);
 611        if (!fwn)
 612                return -ENOMEM;
 613        fwn->name = kstrdup_const(name, GFP_KERNEL);
 614        if (!fwn->name) {
 615                devres_free(fwn);
 616                return -ENOMEM;
 617        }
 618
 619        fwn->magic = (unsigned long)&fw_cache;
 620        devres_add(dev, fwn);
 621
 622        return 0;
 623}
 624#else
 625static bool fw_cache_is_setup(struct device *dev, const char *name)
 626{
 627        return false;
 628}
 629
 630static int fw_add_devm_name(struct device *dev, const char *name)
 631{
 632        return 0;
 633}
 634#endif
 635
 636int assign_fw(struct firmware *fw, struct device *device,
 637              enum fw_opt opt_flags)
 638{
 639        struct fw_priv *fw_priv = fw->priv;
 640        int ret;
 641
 642        mutex_lock(&fw_lock);
 643        if (!fw_priv->size || fw_state_is_aborted(fw_priv)) {
 644                mutex_unlock(&fw_lock);
 645                return -ENOENT;
 646        }
 647
 648        /*
 649         * add firmware name into devres list so that we can auto cache
 650         * and uncache firmware for device.
 651         *
 652         * device may has been deleted already, but the problem
 653         * should be fixed in devres or driver core.
 654         */
 655        /* don't cache firmware handled without uevent */
 656        if (device && (opt_flags & FW_OPT_UEVENT) &&
 657            !(opt_flags & FW_OPT_NOCACHE)) {
 658                ret = fw_add_devm_name(device, fw_priv->fw_name);
 659                if (ret) {
 660                        mutex_unlock(&fw_lock);
 661                        return ret;
 662                }
 663        }
 664
 665        /*
 666         * After caching firmware image is started, let it piggyback
 667         * on request firmware.
 668         */
 669        if (!(opt_flags & FW_OPT_NOCACHE) &&
 670            fw_priv->fwc->state == FW_LOADER_START_CACHE) {
 671                if (fw_cache_piggyback_on_request(fw_priv->fw_name))
 672                        kref_get(&fw_priv->ref);
 673        }
 674
 675        /* pass the pages buffer to driver at the last minute */
 676        fw_set_page_data(fw_priv, fw);
 677        mutex_unlock(&fw_lock);
 678        return 0;
 679}
 680
 681/* prepare firmware and firmware_buf structs;
 682 * return 0 if a firmware is already assigned, 1 if need to load one,
 683 * or a negative error code
 684 */
 685static int
 686_request_firmware_prepare(struct firmware **firmware_p, const char *name,
 687                          struct device *device, void *dbuf, size_t size,
 688                          enum fw_opt opt_flags)
 689{
 690        struct firmware *firmware;
 691        struct fw_priv *fw_priv;
 692        int ret;
 693
 694        *firmware_p = firmware = kzalloc(sizeof(*firmware), GFP_KERNEL);
 695        if (!firmware) {
 696                dev_err(device, "%s: kmalloc(struct firmware) failed\n",
 697                        __func__);
 698                return -ENOMEM;
 699        }
 700
 701        if (fw_get_builtin_firmware(firmware, name, dbuf, size)) {
 702                dev_dbg(device, "using built-in %s\n", name);
 703                return 0; /* assigned */
 704        }
 705
 706        ret = alloc_lookup_fw_priv(name, &fw_cache, &fw_priv, dbuf, size,
 707                                  opt_flags);
 708
 709        /*
 710         * bind with 'priv' now to avoid warning in failure path
 711         * of requesting firmware.
 712         */
 713        firmware->priv = fw_priv;
 714
 715        if (ret > 0) {
 716                ret = fw_state_wait(fw_priv);
 717                if (!ret) {
 718                        fw_set_page_data(fw_priv, firmware);
 719                        return 0; /* assigned */
 720                }
 721        }
 722
 723        if (ret < 0)
 724                return ret;
 725        return 1; /* need to load */
 726}
 727
 728/*
 729 * Batched requests need only one wake, we need to do this step last due to the
 730 * fallback mechanism. The buf is protected with kref_get(), and it won't be
 731 * released until the last user calls release_firmware().
 732 *
 733 * Failed batched requests are possible as well, in such cases we just share
 734 * the struct fw_priv and won't release it until all requests are woken
 735 * and have gone through this same path.
 736 */
 737static void fw_abort_batch_reqs(struct firmware *fw)
 738{
 739        struct fw_priv *fw_priv;
 740
 741        /* Loaded directly? */
 742        if (!fw || !fw->priv)
 743                return;
 744
 745        fw_priv = fw->priv;
 746        if (!fw_state_is_aborted(fw_priv))
 747                fw_state_aborted(fw_priv);
 748}
 749
 750/* called from request_firmware() and request_firmware_work_func() */
 751static int
 752_request_firmware(const struct firmware **firmware_p, const char *name,
 753                  struct device *device, void *buf, size_t size,
 754                  enum fw_opt opt_flags)
 755{
 756        struct firmware *fw = NULL;
 757        int ret;
 758
 759        if (!firmware_p)
 760                return -EINVAL;
 761
 762        if (!name || name[0] == '\0') {
 763                ret = -EINVAL;
 764                goto out;
 765        }
 766
 767        ret = _request_firmware_prepare(&fw, name, device, buf, size,
 768                                        opt_flags);
 769        if (ret <= 0) /* error or already assigned */
 770                goto out;
 771
 772        ret = fw_get_filesystem_firmware(device, fw->priv, "", NULL);
 773#ifdef CONFIG_FW_LOADER_COMPRESS
 774        if (ret == -ENOENT)
 775                ret = fw_get_filesystem_firmware(device, fw->priv, ".xz",
 776                                                 fw_decompress_xz);
 777#endif
 778
 779        if (ret) {
 780                if (!(opt_flags & FW_OPT_NO_WARN))
 781                        dev_warn(device,
 782                                 "Direct firmware load for %s failed with error %d\n",
 783                                 name, ret);
 784                ret = firmware_fallback_sysfs(fw, name, device, opt_flags, ret);
 785        } else
 786                ret = assign_fw(fw, device, opt_flags);
 787
 788 out:
 789        if (ret < 0) {
 790                fw_abort_batch_reqs(fw);
 791                release_firmware(fw);
 792                fw = NULL;
 793        }
 794
 795        *firmware_p = fw;
 796        return ret;
 797}
 798
 799/**
 800 * request_firmware() - send firmware request and wait for it
 801 * @firmware_p: pointer to firmware image
 802 * @name: name of firmware file
 803 * @device: device for which firmware is being loaded
 804 *
 805 *      @firmware_p will be used to return a firmware image by the name
 806 *      of @name for device @device.
 807 *
 808 *      Should be called from user context where sleeping is allowed.
 809 *
 810 *      @name will be used as $FIRMWARE in the uevent environment and
 811 *      should be distinctive enough not to be confused with any other
 812 *      firmware image for this or any other device.
 813 *
 814 *      Caller must hold the reference count of @device.
 815 *
 816 *      The function can be called safely inside device's suspend and
 817 *      resume callback.
 818 **/
 819int
 820request_firmware(const struct firmware **firmware_p, const char *name,
 821                 struct device *device)
 822{
 823        int ret;
 824
 825        /* Need to pin this module until return */
 826        __module_get(THIS_MODULE);
 827        ret = _request_firmware(firmware_p, name, device, NULL, 0,
 828                                FW_OPT_UEVENT);
 829        module_put(THIS_MODULE);
 830        return ret;
 831}
 832EXPORT_SYMBOL(request_firmware);
 833
 834/**
 835 * firmware_request_nowarn() - request for an optional fw module
 836 * @firmware: pointer to firmware image
 837 * @name: name of firmware file
 838 * @device: device for which firmware is being loaded
 839 *
 840 * This function is similar in behaviour to request_firmware(), except
 841 * it doesn't produce warning messages when the file is not found.
 842 * The sysfs fallback mechanism is enabled if direct filesystem lookup fails,
 843 * however, however failures to find the firmware file with it are still
 844 * suppressed. It is therefore up to the driver to check for the return value
 845 * of this call and to decide when to inform the users of errors.
 846 **/
 847int firmware_request_nowarn(const struct firmware **firmware, const char *name,
 848                            struct device *device)
 849{
 850        int ret;
 851
 852        /* Need to pin this module until return */
 853        __module_get(THIS_MODULE);
 854        ret = _request_firmware(firmware, name, device, NULL, 0,
 855                                FW_OPT_UEVENT | FW_OPT_NO_WARN);
 856        module_put(THIS_MODULE);
 857        return ret;
 858}
 859EXPORT_SYMBOL_GPL(firmware_request_nowarn);
 860
 861/**
 862 * request_firmware_direct() - load firmware directly without usermode helper
 863 * @firmware_p: pointer to firmware image
 864 * @name: name of firmware file
 865 * @device: device for which firmware is being loaded
 866 *
 867 * This function works pretty much like request_firmware(), but this doesn't
 868 * fall back to usermode helper even if the firmware couldn't be loaded
 869 * directly from fs.  Hence it's useful for loading optional firmwares, which
 870 * aren't always present, without extra long timeouts of udev.
 871 **/
 872int request_firmware_direct(const struct firmware **firmware_p,
 873                            const char *name, struct device *device)
 874{
 875        int ret;
 876
 877        __module_get(THIS_MODULE);
 878        ret = _request_firmware(firmware_p, name, device, NULL, 0,
 879                                FW_OPT_UEVENT | FW_OPT_NO_WARN |
 880                                FW_OPT_NOFALLBACK_SYSFS);
 881        module_put(THIS_MODULE);
 882        return ret;
 883}
 884EXPORT_SYMBOL_GPL(request_firmware_direct);
 885
 886/**
 887 * firmware_request_cache() - cache firmware for suspend so resume can use it
 888 * @name: name of firmware file
 889 * @device: device for which firmware should be cached for
 890 *
 891 * There are some devices with an optimization that enables the device to not
 892 * require loading firmware on system reboot. This optimization may still
 893 * require the firmware present on resume from suspend. This routine can be
 894 * used to ensure the firmware is present on resume from suspend in these
 895 * situations. This helper is not compatible with drivers which use
 896 * request_firmware_into_buf() or request_firmware_nowait() with no uevent set.
 897 **/
 898int firmware_request_cache(struct device *device, const char *name)
 899{
 900        int ret;
 901
 902        mutex_lock(&fw_lock);
 903        ret = fw_add_devm_name(device, name);
 904        mutex_unlock(&fw_lock);
 905
 906        return ret;
 907}
 908EXPORT_SYMBOL_GPL(firmware_request_cache);
 909
 910/**
 911 * request_firmware_into_buf() - load firmware into a previously allocated buffer
 912 * @firmware_p: pointer to firmware image
 913 * @name: name of firmware file
 914 * @device: device for which firmware is being loaded and DMA region allocated
 915 * @buf: address of buffer to load firmware into
 916 * @size: size of buffer
 917 *
 918 * This function works pretty much like request_firmware(), but it doesn't
 919 * allocate a buffer to hold the firmware data. Instead, the firmware
 920 * is loaded directly into the buffer pointed to by @buf and the @firmware_p
 921 * data member is pointed at @buf.
 922 *
 923 * This function doesn't cache firmware either.
 924 */
 925int
 926request_firmware_into_buf(const struct firmware **firmware_p, const char *name,
 927                          struct device *device, void *buf, size_t size)
 928{
 929        int ret;
 930
 931        if (fw_cache_is_setup(device, name))
 932                return -EOPNOTSUPP;
 933
 934        __module_get(THIS_MODULE);
 935        ret = _request_firmware(firmware_p, name, device, buf, size,
 936                                FW_OPT_UEVENT | FW_OPT_NOCACHE);
 937        module_put(THIS_MODULE);
 938        return ret;
 939}
 940EXPORT_SYMBOL(request_firmware_into_buf);
 941
 942/**
 943 * release_firmware() - release the resource associated with a firmware image
 944 * @fw: firmware resource to release
 945 **/
 946void release_firmware(const struct firmware *fw)
 947{
 948        if (fw) {
 949                if (!fw_is_builtin_firmware(fw))
 950                        firmware_free_data(fw);
 951                kfree(fw);
 952        }
 953}
 954EXPORT_SYMBOL(release_firmware);
 955
 956/* Async support */
 957struct firmware_work {
 958        struct work_struct work;
 959        struct module *module;
 960        const char *name;
 961        struct device *device;
 962        void *context;
 963        void (*cont)(const struct firmware *fw, void *context);
 964        enum fw_opt opt_flags;
 965};
 966
 967static void request_firmware_work_func(struct work_struct *work)
 968{
 969        struct firmware_work *fw_work;
 970        const struct firmware *fw;
 971
 972        fw_work = container_of(work, struct firmware_work, work);
 973
 974        _request_firmware(&fw, fw_work->name, fw_work->device, NULL, 0,
 975                          fw_work->opt_flags);
 976        fw_work->cont(fw, fw_work->context);
 977        put_device(fw_work->device); /* taken in request_firmware_nowait() */
 978
 979        module_put(fw_work->module);
 980        kfree_const(fw_work->name);
 981        kfree(fw_work);
 982}
 983
 984/**
 985 * request_firmware_nowait() - asynchronous version of request_firmware
 986 * @module: module requesting the firmware
 987 * @uevent: sends uevent to copy the firmware image if this flag
 988 *      is non-zero else the firmware copy must be done manually.
 989 * @name: name of firmware file
 990 * @device: device for which firmware is being loaded
 991 * @gfp: allocation flags
 992 * @context: will be passed over to @cont, and
 993 *      @fw may be %NULL if firmware request fails.
 994 * @cont: function will be called asynchronously when the firmware
 995 *      request is over.
 996 *
 997 *      Caller must hold the reference count of @device.
 998 *
 999 *      Asynchronous variant of request_firmware() for user contexts:
1000 *              - sleep for as small periods as possible since it may
1001 *                increase kernel boot time of built-in device drivers
1002 *                requesting firmware in their ->probe() methods, if
1003 *                @gfp is GFP_KERNEL.
1004 *
1005 *              - can't sleep at all if @gfp is GFP_ATOMIC.
1006 **/
1007int
1008request_firmware_nowait(
1009        struct module *module, bool uevent,
1010        const char *name, struct device *device, gfp_t gfp, void *context,
1011        void (*cont)(const struct firmware *fw, void *context))
1012{
1013        struct firmware_work *fw_work;
1014
1015        fw_work = kzalloc(sizeof(struct firmware_work), gfp);
1016        if (!fw_work)
1017                return -ENOMEM;
1018
1019        fw_work->module = module;
1020        fw_work->name = kstrdup_const(name, gfp);
1021        if (!fw_work->name) {
1022                kfree(fw_work);
1023                return -ENOMEM;
1024        }
1025        fw_work->device = device;
1026        fw_work->context = context;
1027        fw_work->cont = cont;
1028        fw_work->opt_flags = FW_OPT_NOWAIT |
1029                (uevent ? FW_OPT_UEVENT : FW_OPT_USERHELPER);
1030
1031        if (!uevent && fw_cache_is_setup(device, name)) {
1032                kfree_const(fw_work->name);
1033                kfree(fw_work);
1034                return -EOPNOTSUPP;
1035        }
1036
1037        if (!try_module_get(module)) {
1038                kfree_const(fw_work->name);
1039                kfree(fw_work);
1040                return -EFAULT;
1041        }
1042
1043        get_device(fw_work->device);
1044        INIT_WORK(&fw_work->work, request_firmware_work_func);
1045        schedule_work(&fw_work->work);
1046        return 0;
1047}
1048EXPORT_SYMBOL(request_firmware_nowait);
1049
1050#ifdef CONFIG_FW_CACHE
1051static ASYNC_DOMAIN_EXCLUSIVE(fw_cache_domain);
1052
1053/**
1054 * cache_firmware() - cache one firmware image in kernel memory space
1055 * @fw_name: the firmware image name
1056 *
1057 * Cache firmware in kernel memory so that drivers can use it when
1058 * system isn't ready for them to request firmware image from userspace.
1059 * Once it returns successfully, driver can use request_firmware or its
1060 * nowait version to get the cached firmware without any interacting
1061 * with userspace
1062 *
1063 * Return 0 if the firmware image has been cached successfully
1064 * Return !0 otherwise
1065 *
1066 */
1067static int cache_firmware(const char *fw_name)
1068{
1069        int ret;
1070        const struct firmware *fw;
1071
1072        pr_debug("%s: %s\n", __func__, fw_name);
1073
1074        ret = request_firmware(&fw, fw_name, NULL);
1075        if (!ret)
1076                kfree(fw);
1077
1078        pr_debug("%s: %s ret=%d\n", __func__, fw_name, ret);
1079
1080        return ret;
1081}
1082
1083static struct fw_priv *lookup_fw_priv(const char *fw_name)
1084{
1085        struct fw_priv *tmp;
1086        struct firmware_cache *fwc = &fw_cache;
1087
1088        spin_lock(&fwc->lock);
1089        tmp = __lookup_fw_priv(fw_name);
1090        spin_unlock(&fwc->lock);
1091
1092        return tmp;
1093}
1094
1095/**
1096 * uncache_firmware() - remove one cached firmware image
1097 * @fw_name: the firmware image name
1098 *
1099 * Uncache one firmware image which has been cached successfully
1100 * before.
1101 *
1102 * Return 0 if the firmware cache has been removed successfully
1103 * Return !0 otherwise
1104 *
1105 */
1106static int uncache_firmware(const char *fw_name)
1107{
1108        struct fw_priv *fw_priv;
1109        struct firmware fw;
1110
1111        pr_debug("%s: %s\n", __func__, fw_name);
1112
1113        if (fw_get_builtin_firmware(&fw, fw_name, NULL, 0))
1114                return 0;
1115
1116        fw_priv = lookup_fw_priv(fw_name);
1117        if (fw_priv) {
1118                free_fw_priv(fw_priv);
1119                return 0;
1120        }
1121
1122        return -EINVAL;
1123}
1124
1125static struct fw_cache_entry *alloc_fw_cache_entry(const char *name)
1126{
1127        struct fw_cache_entry *fce;
1128
1129        fce = kzalloc(sizeof(*fce), GFP_ATOMIC);
1130        if (!fce)
1131                goto exit;
1132
1133        fce->name = kstrdup_const(name, GFP_ATOMIC);
1134        if (!fce->name) {
1135                kfree(fce);
1136                fce = NULL;
1137                goto exit;
1138        }
1139exit:
1140        return fce;
1141}
1142
1143static int __fw_entry_found(const char *name)
1144{
1145        struct firmware_cache *fwc = &fw_cache;
1146        struct fw_cache_entry *fce;
1147
1148        list_for_each_entry(fce, &fwc->fw_names, list) {
1149                if (!strcmp(fce->name, name))
1150                        return 1;
1151        }
1152        return 0;
1153}
1154
1155static int fw_cache_piggyback_on_request(const char *name)
1156{
1157        struct firmware_cache *fwc = &fw_cache;
1158        struct fw_cache_entry *fce;
1159        int ret = 0;
1160
1161        spin_lock(&fwc->name_lock);
1162        if (__fw_entry_found(name))
1163                goto found;
1164
1165        fce = alloc_fw_cache_entry(name);
1166        if (fce) {
1167                ret = 1;
1168                list_add(&fce->list, &fwc->fw_names);
1169                pr_debug("%s: fw: %s\n", __func__, name);
1170        }
1171found:
1172        spin_unlock(&fwc->name_lock);
1173        return ret;
1174}
1175
1176static void free_fw_cache_entry(struct fw_cache_entry *fce)
1177{
1178        kfree_const(fce->name);
1179        kfree(fce);
1180}
1181
1182static void __async_dev_cache_fw_image(void *fw_entry,
1183                                       async_cookie_t cookie)
1184{
1185        struct fw_cache_entry *fce = fw_entry;
1186        struct firmware_cache *fwc = &fw_cache;
1187        int ret;
1188
1189        ret = cache_firmware(fce->name);
1190        if (ret) {
1191                spin_lock(&fwc->name_lock);
1192                list_del(&fce->list);
1193                spin_unlock(&fwc->name_lock);
1194
1195                free_fw_cache_entry(fce);
1196        }
1197}
1198
1199/* called with dev->devres_lock held */
1200static void dev_create_fw_entry(struct device *dev, void *res,
1201                                void *data)
1202{
1203        struct fw_name_devm *fwn = res;
1204        const char *fw_name = fwn->name;
1205        struct list_head *head = data;
1206        struct fw_cache_entry *fce;
1207
1208        fce = alloc_fw_cache_entry(fw_name);
1209        if (fce)
1210                list_add(&fce->list, head);
1211}
1212
1213static int devm_name_match(struct device *dev, void *res,
1214                           void *match_data)
1215{
1216        struct fw_name_devm *fwn = res;
1217        return (fwn->magic == (unsigned long)match_data);
1218}
1219
1220static void dev_cache_fw_image(struct device *dev, void *data)
1221{
1222        LIST_HEAD(todo);
1223        struct fw_cache_entry *fce;
1224        struct fw_cache_entry *fce_next;
1225        struct firmware_cache *fwc = &fw_cache;
1226
1227        devres_for_each_res(dev, fw_name_devm_release,
1228                            devm_name_match, &fw_cache,
1229                            dev_create_fw_entry, &todo);
1230
1231        list_for_each_entry_safe(fce, fce_next, &todo, list) {
1232                list_del(&fce->list);
1233
1234                spin_lock(&fwc->name_lock);
1235                /* only one cache entry for one firmware */
1236                if (!__fw_entry_found(fce->name)) {
1237                        list_add(&fce->list, &fwc->fw_names);
1238                } else {
1239                        free_fw_cache_entry(fce);
1240                        fce = NULL;
1241                }
1242                spin_unlock(&fwc->name_lock);
1243
1244                if (fce)
1245                        async_schedule_domain(__async_dev_cache_fw_image,
1246                                              (void *)fce,
1247                                              &fw_cache_domain);
1248        }
1249}
1250
1251static void __device_uncache_fw_images(void)
1252{
1253        struct firmware_cache *fwc = &fw_cache;
1254        struct fw_cache_entry *fce;
1255
1256        spin_lock(&fwc->name_lock);
1257        while (!list_empty(&fwc->fw_names)) {
1258                fce = list_entry(fwc->fw_names.next,
1259                                struct fw_cache_entry, list);
1260                list_del(&fce->list);
1261                spin_unlock(&fwc->name_lock);
1262
1263                uncache_firmware(fce->name);
1264                free_fw_cache_entry(fce);
1265
1266                spin_lock(&fwc->name_lock);
1267        }
1268        spin_unlock(&fwc->name_lock);
1269}
1270
1271/**
1272 * device_cache_fw_images() - cache devices' firmware
1273 *
1274 * If one device called request_firmware or its nowait version
1275 * successfully before, the firmware names are recored into the
1276 * device's devres link list, so device_cache_fw_images can call
1277 * cache_firmware() to cache these firmwares for the device,
1278 * then the device driver can load its firmwares easily at
1279 * time when system is not ready to complete loading firmware.
1280 */
1281static void device_cache_fw_images(void)
1282{
1283        struct firmware_cache *fwc = &fw_cache;
1284        DEFINE_WAIT(wait);
1285
1286        pr_debug("%s\n", __func__);
1287
1288        /* cancel uncache work */
1289        cancel_delayed_work_sync(&fwc->work);
1290
1291        fw_fallback_set_cache_timeout();
1292
1293        mutex_lock(&fw_lock);
1294        fwc->state = FW_LOADER_START_CACHE;
1295        dpm_for_each_dev(NULL, dev_cache_fw_image);
1296        mutex_unlock(&fw_lock);
1297
1298        /* wait for completion of caching firmware for all devices */
1299        async_synchronize_full_domain(&fw_cache_domain);
1300
1301        fw_fallback_set_default_timeout();
1302}
1303
1304/**
1305 * device_uncache_fw_images() - uncache devices' firmware
1306 *
1307 * uncache all firmwares which have been cached successfully
1308 * by device_uncache_fw_images earlier
1309 */
1310static void device_uncache_fw_images(void)
1311{
1312        pr_debug("%s\n", __func__);
1313        __device_uncache_fw_images();
1314}
1315
1316static void device_uncache_fw_images_work(struct work_struct *work)
1317{
1318        device_uncache_fw_images();
1319}
1320
1321/**
1322 * device_uncache_fw_images_delay() - uncache devices firmwares
1323 * @delay: number of milliseconds to delay uncache device firmwares
1324 *
1325 * uncache all devices's firmwares which has been cached successfully
1326 * by device_cache_fw_images after @delay milliseconds.
1327 */
1328static void device_uncache_fw_images_delay(unsigned long delay)
1329{
1330        queue_delayed_work(system_power_efficient_wq, &fw_cache.work,
1331                           msecs_to_jiffies(delay));
1332}
1333
1334static int fw_pm_notify(struct notifier_block *notify_block,
1335                        unsigned long mode, void *unused)
1336{
1337        switch (mode) {
1338        case PM_HIBERNATION_PREPARE:
1339        case PM_SUSPEND_PREPARE:
1340        case PM_RESTORE_PREPARE:
1341                /*
1342                 * kill pending fallback requests with a custom fallback
1343                 * to avoid stalling suspend.
1344                 */
1345                kill_pending_fw_fallback_reqs(true);
1346                device_cache_fw_images();
1347                break;
1348
1349        case PM_POST_SUSPEND:
1350        case PM_POST_HIBERNATION:
1351        case PM_POST_RESTORE:
1352                /*
1353                 * In case that system sleep failed and syscore_suspend is
1354                 * not called.
1355                 */
1356                mutex_lock(&fw_lock);
1357                fw_cache.state = FW_LOADER_NO_CACHE;
1358                mutex_unlock(&fw_lock);
1359
1360                device_uncache_fw_images_delay(10 * MSEC_PER_SEC);
1361                break;
1362        }
1363
1364        return 0;
1365}
1366
1367/* stop caching firmware once syscore_suspend is reached */
1368static int fw_suspend(void)
1369{
1370        fw_cache.state = FW_LOADER_NO_CACHE;
1371        return 0;
1372}
1373
1374static struct syscore_ops fw_syscore_ops = {
1375        .suspend = fw_suspend,
1376};
1377
1378static int __init register_fw_pm_ops(void)
1379{
1380        int ret;
1381
1382        spin_lock_init(&fw_cache.name_lock);
1383        INIT_LIST_HEAD(&fw_cache.fw_names);
1384
1385        INIT_DELAYED_WORK(&fw_cache.work,
1386                          device_uncache_fw_images_work);
1387
1388        fw_cache.pm_notify.notifier_call = fw_pm_notify;
1389        ret = register_pm_notifier(&fw_cache.pm_notify);
1390        if (ret)
1391                return ret;
1392
1393        register_syscore_ops(&fw_syscore_ops);
1394
1395        return ret;
1396}
1397
1398static inline void unregister_fw_pm_ops(void)
1399{
1400        unregister_syscore_ops(&fw_syscore_ops);
1401        unregister_pm_notifier(&fw_cache.pm_notify);
1402}
1403#else
1404static int fw_cache_piggyback_on_request(const char *name)
1405{
1406        return 0;
1407}
1408static inline int register_fw_pm_ops(void)
1409{
1410        return 0;
1411}
1412static inline void unregister_fw_pm_ops(void)
1413{
1414}
1415#endif
1416
1417static void __init fw_cache_init(void)
1418{
1419        spin_lock_init(&fw_cache.lock);
1420        INIT_LIST_HEAD(&fw_cache.head);
1421        fw_cache.state = FW_LOADER_NO_CACHE;
1422}
1423
1424static int fw_shutdown_notify(struct notifier_block *unused1,
1425                              unsigned long unused2, void *unused3)
1426{
1427        /*
1428         * Kill all pending fallback requests to avoid both stalling shutdown,
1429         * and avoid a deadlock with the usermode_lock.
1430         */
1431        kill_pending_fw_fallback_reqs(false);
1432
1433        return NOTIFY_DONE;
1434}
1435
1436static struct notifier_block fw_shutdown_nb = {
1437        .notifier_call = fw_shutdown_notify,
1438};
1439
1440static int __init firmware_class_init(void)
1441{
1442        int ret;
1443
1444        /* No need to unfold these on exit */
1445        fw_cache_init();
1446
1447        ret = register_fw_pm_ops();
1448        if (ret)
1449                return ret;
1450
1451        ret = register_reboot_notifier(&fw_shutdown_nb);
1452        if (ret)
1453                goto out;
1454
1455        return register_sysfs_loader();
1456
1457out:
1458        unregister_fw_pm_ops();
1459        return ret;
1460}
1461
1462static void __exit firmware_class_exit(void)
1463{
1464        unregister_fw_pm_ops();
1465        unregister_reboot_notifier(&fw_shutdown_nb);
1466        unregister_sysfs_loader();
1467}
1468
1469fs_initcall(firmware_class_init);
1470module_exit(firmware_class_exit);
1471