drivers/base/firmware_loader/main.c

   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/firmware_class/ 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
  44 MODULE_AUTHOR("Manuel Estrada Sainz");
  45 MODULE_DESCRIPTION("Multi purpose firmware loading support");
  46 MODULE_LICENSE("GPL");
  47
  48 struct 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_PM_SLEEP
  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
  70 struct fw_cache_entry {
  71         struct list_head list;
  72         const char *name;
  73 };
  74
  75 struct fw_name_devm {
  76         unsigned long magic;
  77         const char *name;
  78 };
  79
  80 static 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 */
  90 DEFINE_MUTEX(fw_lock);
  91
  92 static struct firmware_cache fw_cache;
  93
  94 /* Builtin firmware support */
  95
  96 #ifdef CONFIG_FW_LOADER
  97
  98 extern struct builtin_fw __start_builtin_fw[];
  99 extern struct builtin_fw __end_builtin_fw[];
 100
 101 static 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
 109 static 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
 127 static 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
 140 static 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
 147 static inline bool fw_is_builtin_firmware(const struct firmware *fw)
 148 {
 149         return false;
 150 }
 151 #endif
 152
 153 static 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
 161 static inline int fw_state_wait(struct fw_priv *fw_priv)
 162 {
 163         return __fw_state_wait_common(fw_priv, MAX_SCHEDULE_TIMEOUT);
 164 }
 165
 166 static int fw_cache_piggyback_on_request(const char *name);
 167
 168 static 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
 198 static 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 */
 210 static 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
 242 static 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
 262 static 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
 271 void 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
 286 int 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
 319 int 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 */
 344 static 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 */
 354 static 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 */
 380 static 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
 427 static 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 */
 439 static char fw_path_para[256];
 440 static 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  */
 453 module_param_string(path, fw_path_para, sizeof(fw_path_para), 0644);
 454 MODULE_PARM_DESC(path, "customized firmware image search path with a higher priority than default path");
 455
 456 static int
 457 fw_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                 if (decompress) {
 508                         dev_dbg(device, "f/w decompressing %s\n",
 509                                 fw_priv->fw_name);
 510                         rc = decompress(device, fw_priv, size, buffer);
 511                         /* discard the superfluous original content */
 512                         vfree(buffer);
 513                         buffer = NULL;
 514                         if (rc) {
 515                                 fw_free_paged_buf(fw_priv);
 516                                 continue;
 517                         }
 518                 } else {
 519                         dev_dbg(device, "direct-loading %s\n",
 520                                 fw_priv->fw_name);
 521                         if (!fw_priv->data)
 522                                 fw_priv->data = buffer;
 523                         fw_priv->size = size;
 524                 }
 525                 fw_state_done(fw_priv);
 526                 break;
 527         }
 528         __putname(path);
 529
 530         return rc;
 531 }
 532
 533 /* firmware holds the ownership of pages */
 534 static void firmware_free_data(const struct firmware *fw)
 535 {
 536         /* Loaded directly? */
 537         if (!fw->priv) {
 538                 vfree(fw->data);
 539                 return;
 540         }
 541         free_fw_priv(fw->priv);
 542 }
 543
 544 /* store the pages buffer info firmware from buf */
 545 static void fw_set_page_data(struct fw_priv *fw_priv, struct firmware *fw)
 546 {
 547         fw->priv = fw_priv;
 548 #ifdef CONFIG_FW_LOADER_USER_HELPER
 549         fw->pages = fw_priv->pages;
 550 #endif
 551         fw->size = fw_priv->size;
 552         fw->data = fw_priv->data;
 553
 554         pr_debug("%s: fw-%s fw_priv=%p data=%p size=%u\n",
 555                  __func__, fw_priv->fw_name, fw_priv, fw_priv->data,
 556                  (unsigned int)fw_priv->size);
 557 }
 558
 559 #ifdef CONFIG_PM_SLEEP
 560 static void fw_name_devm_release(struct device *dev, void *res)
 561 {
 562         struct fw_name_devm *fwn = res;
 563
 564         if (fwn->magic == (unsigned long)&fw_cache)
 565                 pr_debug("%s: fw_name-%s devm-%p released\n",
 566                                 __func__, fwn->name, res);
 567         kfree_const(fwn->name);
 568 }
 569
 570 static int fw_devm_match(struct device *dev, void *res,
 571                 void *match_data)
 572 {
 573         struct fw_name_devm *fwn = res;
 574
 575         return (fwn->magic == (unsigned long)&fw_cache) &&
 576                 !strcmp(fwn->name, match_data);
 577 }
 578
 579 static struct fw_name_devm *fw_find_devm_name(struct device *dev,
 580                 const char *name)
 581 {
 582         struct fw_name_devm *fwn;
 583
 584         fwn = devres_find(dev, fw_name_devm_release,
 585                           fw_devm_match, (void *)name);
 586         return fwn;
 587 }
 588
 589 static bool fw_cache_is_setup(struct device *dev, const char *name)
 590 {
 591         struct fw_name_devm *fwn;
 592
 593         fwn = fw_find_devm_name(dev, name);
 594         if (fwn)
 595                 return true;
 596
 597         return false;
 598 }
 599
 600 /* add firmware name into devres list */
 601 static int fw_add_devm_name(struct device *dev, const char *name)
 602 {
 603         struct fw_name_devm *fwn;
 604
 605         if (fw_cache_is_setup(dev, name))
 606                 return 0;
 607
 608         fwn = devres_alloc(fw_name_devm_release, sizeof(struct fw_name_devm),
 609                            GFP_KERNEL);
 610         if (!fwn)
 611                 return -ENOMEM;
 612         fwn->name = kstrdup_const(name, GFP_KERNEL);
 613         if (!fwn->name) {
 614                 devres_free(fwn);
 615                 return -ENOMEM;
 616         }
 617
 618         fwn->magic = (unsigned long)&fw_cache;
 619         devres_add(dev, fwn);
 620
 621         return 0;
 622 }
 623 #else
 624 static bool fw_cache_is_setup(struct device *dev, const char *name)
 625 {
 626         return false;
 627 }
 628
 629 static int fw_add_devm_name(struct device *dev, const char *name)
 630 {
 631         return 0;
 632 }
 633 #endif
 634
 635 int assign_fw(struct firmware *fw, struct device *device,
 636               enum fw_opt opt_flags)
 637 {
 638         struct fw_priv *fw_priv = fw->priv;
 639         int ret;
 640
 641         mutex_lock(&fw_lock);
 642         if (!fw_priv->size || fw_state_is_aborted(fw_priv)) {
 643                 mutex_unlock(&fw_lock);
 644                 return -ENOENT;
 645         }
 646
 647         /*
 648          * add firmware name into devres list so that we can auto cache
 649          * and uncache firmware for device.
 650          *
 651          * device may has been deleted already, but the problem
 652          * should be fixed in devres or driver core.
 653          */
 654         /* don't cache firmware handled without uevent */
 655         if (device && (opt_flags & FW_OPT_UEVENT) &&
 656             !(opt_flags & FW_OPT_NOCACHE)) {
 657                 ret = fw_add_devm_name(device, fw_priv->fw_name);
 658                 if (ret) {
 659                         mutex_unlock(&fw_lock);
 660                         return ret;
 661                 }
 662         }
 663
 664         /*
 665          * After caching firmware image is started, let it piggyback
 666          * on request firmware.
 667          */
 668         if (!(opt_flags & FW_OPT_NOCACHE) &&
 669             fw_priv->fwc->state == FW_LOADER_START_CACHE) {
 670                 if (fw_cache_piggyback_on_request(fw_priv->fw_name))
 671                         kref_get(&fw_priv->ref);
 672         }
 673
 674         /* pass the pages buffer to driver at the last minute */
 675         fw_set_page_data(fw_priv, fw);
 676         mutex_unlock(&fw_lock);
 677         return 0;
 678 }
 679
 680 /* prepare firmware and firmware_buf structs;
 681  * return 0 if a firmware is already assigned, 1 if need to load one,
 682  * or a negative error code
 683  */
 684 static int
 685 _request_firmware_prepare(struct firmware **firmware_p, const char *name,
 686                           struct device *device, void *dbuf, size_t size,
 687                           enum fw_opt opt_flags)
 688 {
 689         struct firmware *firmware;
 690         struct fw_priv *fw_priv;
 691         int ret;
 692
 693         *firmware_p = firmware = kzalloc(sizeof(*firmware), GFP_KERNEL);
 694         if (!firmware) {
 695                 dev_err(device, "%s: kmalloc(struct firmware) failed\n",
 696                         __func__);
 697                 return -ENOMEM;
 698         }
 699
 700         if (fw_get_builtin_firmware(firmware, name, dbuf, size)) {
 701                 dev_dbg(device, "using built-in %s\n", name);
 702                 return 0; /* assigned */
 703         }
 704
 705         ret = alloc_lookup_fw_priv(name, &fw_cache, &fw_priv, dbuf, size,
 706                                   opt_flags);
 707
 708         /*
 709          * bind with 'priv' now to avoid warning in failure path
 710          * of requesting firmware.
 711          */
 712         firmware->priv = fw_priv;
 713
 714         if (ret > 0) {
 715                 ret = fw_state_wait(fw_priv);
 716                 if (!ret) {
 717                         fw_set_page_data(fw_priv, firmware);
 718                         return 0; /* assigned */
 719                 }
 720         }
 721
 722         if (ret < 0)
 723                 return ret;
 724         return 1; /* need to load */
 725 }
 726
 727 /*
 728  * Batched requests need only one wake, we need to do this step last due to the
 729  * fallback mechanism. The buf is protected with kref_get(), and it won't be
 730  * released until the last user calls release_firmware().
 731  *
 732  * Failed batched requests are possible as well, in such cases we just share
 733  * the struct fw_priv and won't release it until all requests are woken
 734  * and have gone through this same path.
 735  */
 736 static void fw_abort_batch_reqs(struct firmware *fw)
 737 {
 738         struct fw_priv *fw_priv;
 739
 740         /* Loaded directly? */
 741         if (!fw || !fw->priv)
 742                 return;
 743
 744         fw_priv = fw->priv;
 745         if (!fw_state_is_aborted(fw_priv))
 746                 fw_state_aborted(fw_priv);
 747 }
 748
 749 /* called from request_firmware() and request_firmware_work_func() */
 750 static int
 751 _request_firmware(const struct firmware **firmware_p, const char *name,
 752                   struct device *device, void *buf, size_t size,
 753                   enum fw_opt opt_flags)
 754 {
 755         struct firmware *fw = NULL;
 756         int ret;
 757
 758         if (!firmware_p)
 759                 return -EINVAL;
 760
 761         if (!name || name[0] == '\0') {
 762                 ret = -EINVAL;
 763                 goto out;
 764         }
 765
 766         ret = _request_firmware_prepare(&fw, name, device, buf, size,
 767                                         opt_flags);
 768         if (ret <= 0) /* error or already assigned */
 769                 goto out;
 770
 771         ret = fw_get_filesystem_firmware(device, fw->priv, "", NULL);
 772 #ifdef CONFIG_FW_LOADER_COMPRESS
 773         if (ret == -ENOENT)
 774                 ret = fw_get_filesystem_firmware(device, fw->priv, ".xz",
 775                                                  fw_decompress_xz);
 776 #endif
 777
 778         if (ret) {
 779                 if (!(opt_flags & FW_OPT_NO_WARN))
 780                         dev_warn(device,
 781                                  "Direct firmware load for %s failed with error %d\n",
 782                                  name, ret);
 783                 ret = firmware_fallback_sysfs(fw, name, device, opt_flags, ret);
 784         } else
 785                 ret = assign_fw(fw, device, opt_flags);
 786
 787  out:
 788         if (ret < 0) {
 789                 fw_abort_batch_reqs(fw);
 790                 release_firmware(fw);
 791                 fw = NULL;
 792         }
 793
 794         *firmware_p = fw;
 795         return ret;
 796 }
 797
 798 /**
 799  * request_firmware() - send firmware request and wait for it
 800  * @firmware_p: pointer to firmware image
 801  * @name: name of firmware file
 802  * @device: device for which firmware is being loaded
 803  *
 804  *      @firmware_p will be used to return a firmware image by the name
 805  *      of @name for device @device.
 806  *
 807  *      Should be called from user context where sleeping is allowed.
 808  *
 809  *      @name will be used as $FIRMWARE in the uevent environment and
 810  *      should be distinctive enough not to be confused with any other
 811  *      firmware image for this or any other device.
 812  *
 813  *      Caller must hold the reference count of @device.
 814  *
 815  *      The function can be called safely inside device's suspend and
 816  *      resume callback.
 817  **/
 818 int
 819 request_firmware(const struct firmware **firmware_p, const char *name,
 820                  struct device *device)
 821 {
 822         int ret;
 823
 824         /* Need to pin this module until return */
 825         __module_get(THIS_MODULE);
 826         ret = _request_firmware(firmware_p, name, device, NULL, 0,
 827                                 FW_OPT_UEVENT);
 828         module_put(THIS_MODULE);
 829         return ret;
 830 }
 831 EXPORT_SYMBOL(request_firmware);
 832
 833 /**
 834  * firmware_request_nowarn() - request for an optional fw module
 835  * @firmware: pointer to firmware image
 836  * @name: name of firmware file
 837  * @device: device for which firmware is being loaded
 838  *
 839  * This function is similar in behaviour to request_firmware(), except
 840  * it doesn't produce warning messages when the file is not found.
 841  * The sysfs fallback mechanism is enabled if direct filesystem lookup fails,
 842  * however, however failures to find the firmware file with it are still
 843  * suppressed. It is therefore up to the driver to check for the return value
 844  * of this call and to decide when to inform the users of errors.
 845  **/
 846 int firmware_request_nowarn(const struct firmware **firmware, const char *name,
 847                             struct device *device)
 848 {
 849         int ret;
 850
 851         /* Need to pin this module until return */
 852         __module_get(THIS_MODULE);
 853         ret = _request_firmware(firmware, name, device, NULL, 0,
 854                                 FW_OPT_UEVENT | FW_OPT_NO_WARN);
 855         module_put(THIS_MODULE);
 856         return ret;
 857 }
 858 EXPORT_SYMBOL_GPL(firmware_request_nowarn);
 859
 860 /**
 861  * request_firmware_direct() - load firmware directly without usermode helper
 862  * @firmware_p: pointer to firmware image
 863  * @name: name of firmware file
 864  * @device: device for which firmware is being loaded
 865  *
 866  * This function works pretty much like request_firmware(), but this doesn't
 867  * fall back to usermode helper even if the firmware couldn't be loaded
 868  * directly from fs.  Hence it's useful for loading optional firmwares, which
 869  * aren't always present, without extra long timeouts of udev.
 870  **/
 871 int request_firmware_direct(const struct firmware **firmware_p,
 872                             const char *name, struct device *device)
 873 {
 874         int ret;
 875
 876         __module_get(THIS_MODULE);
 877         ret = _request_firmware(firmware_p, name, device, NULL, 0,
 878                                 FW_OPT_UEVENT | FW_OPT_NO_WARN |
 879                                 FW_OPT_NOFALLBACK);
 880         module_put(THIS_MODULE);
 881         return ret;
 882 }
 883 EXPORT_SYMBOL_GPL(request_firmware_direct);
 884
 885 /**
 886  * firmware_request_cache() - cache firmware for suspend so resume can use it
 887  * @name: name of firmware file
 888  * @device: device for which firmware should be cached for
 889  *
 890  * There are some devices with an optimization that enables the device to not
 891  * require loading firmware on system reboot. This optimization may still
 892  * require the firmware present on resume from suspend. This routine can be
 893  * used to ensure the firmware is present on resume from suspend in these
 894  * situations. This helper is not compatible with drivers which use
 895  * request_firmware_into_buf() or request_firmware_nowait() with no uevent set.
 896  **/
 897 int firmware_request_cache(struct device *device, const char *name)
 898 {
 899         int ret;
 900
 901         mutex_lock(&fw_lock);
 902         ret = fw_add_devm_name(device, name);
 903         mutex_unlock(&fw_lock);
 904
 905         return ret;
 906 }
 907 EXPORT_SYMBOL_GPL(firmware_request_cache);
 908
 909 /**
 910  * request_firmware_into_buf() - load firmware into a previously allocated buffer
 911  * @firmware_p: pointer to firmware image
 912  * @name: name of firmware file
 913  * @device: device for which firmware is being loaded and DMA region allocated
 914  * @buf: address of buffer to load firmware into
 915  * @size: size of buffer
 916  *
 917  * This function works pretty much like request_firmware(), but it doesn't
 918  * allocate a buffer to hold the firmware data. Instead, the firmware
 919  * is loaded directly into the buffer pointed to by @buf and the @firmware_p
 920  * data member is pointed at @buf.
 921  *
 922  * This function doesn't cache firmware either.
 923  */
 924 int
 925 request_firmware_into_buf(const struct firmware **firmware_p, const char *name,
 926                           struct device *device, void *buf, size_t size)
 927 {
 928         int ret;
 929
 930         if (fw_cache_is_setup(device, name))
 931                 return -EOPNOTSUPP;
 932
 933         __module_get(THIS_MODULE);
 934         ret = _request_firmware(firmware_p, name, device, buf, size,
 935                                 FW_OPT_UEVENT | FW_OPT_NOCACHE);
 936         module_put(THIS_MODULE);
 937         return ret;
 938 }
 939 EXPORT_SYMBOL(request_firmware_into_buf);
 940
 941 /**
 942  * release_firmware() - release the resource associated with a firmware image
 943  * @fw: firmware resource to release
 944  **/
 945 void release_firmware(const struct firmware *fw)
 946 {
 947         if (fw) {
 948                 if (!fw_is_builtin_firmware(fw))
 949                         firmware_free_data(fw);
 950                 kfree(fw);
 951         }
 952 }
 953 EXPORT_SYMBOL(release_firmware);
 954
 955 /* Async support */
 956 struct firmware_work {
 957         struct work_struct work;
 958         struct module *module;
 959         const char *name;
 960         struct device *device;
 961         void *context;
 962         void (*cont)(const struct firmware *fw, void *context);
 963         enum fw_opt opt_flags;
 964 };
 965
 966 static void request_firmware_work_func(struct work_struct *work)
 967 {
 968         struct firmware_work *fw_work;
 969         const struct firmware *fw;
 970
 971         fw_work = container_of(work, struct firmware_work, work);
 972
 973         _request_firmware(&fw, fw_work->name, fw_work->device, NULL, 0,
 974                           fw_work->opt_flags);
 975         fw_work->cont(fw, fw_work->context);
 976         put_device(fw_work->device); /* taken in request_firmware_nowait() */
 977
 978         module_put(fw_work->module);
 979         kfree_const(fw_work->name);
 980         kfree(fw_work);
 981 }
 982
 983 /**
 984  * request_firmware_nowait() - asynchronous version of request_firmware
 985  * @module: module requesting the firmware
 986  * @uevent: sends uevent to copy the firmware image if this flag
 987  *      is non-zero else the firmware copy must be done manually.
 988  * @name: name of firmware file
 989  * @device: device for which firmware is being loaded
 990  * @gfp: allocation flags
 991  * @context: will be passed over to @cont, and
 992  *      @fw may be %NULL if firmware request fails.
 993  * @cont: function will be called asynchronously when the firmware
 994  *      request is over.
 995  *
 996  *      Caller must hold the reference count of @device.
 997  *
 998  *      Asynchronous variant of request_firmware() for user contexts:
 999  *              - sleep for as small periods as possible since it may
1000  *                increase kernel boot time of built-in device drivers
1001  *                requesting firmware in their ->probe() methods, if
1002  *                @gfp is GFP_KERNEL.
1003  *
1004  *              - can't sleep at all if @gfp is GFP_ATOMIC.
1005  **/
1006 int
1007 request_firmware_nowait(
1008         struct module *module, bool uevent,
1009         const char *name, struct device *device, gfp_t gfp, void *context,
1010         void (*cont)(const struct firmware *fw, void *context))
1011 {
1012         struct firmware_work *fw_work;
1013
1014         fw_work = kzalloc(sizeof(struct firmware_work), gfp);
1015         if (!fw_work)
1016                 return -ENOMEM;
1017
1018         fw_work->module = module;
1019         fw_work->name = kstrdup_const(name, gfp);
1020         if (!fw_work->name) {
1021                 kfree(fw_work);
1022                 return -ENOMEM;
1023         }
1024         fw_work->device = device;
1025         fw_work->context = context;
1026         fw_work->cont = cont;
1027         fw_work->opt_flags = FW_OPT_NOWAIT |
1028                 (uevent ? FW_OPT_UEVENT : FW_OPT_USERHELPER);
1029
1030         if (!uevent && fw_cache_is_setup(device, name)) {
1031                 kfree_const(fw_work->name);
1032                 kfree(fw_work);
1033                 return -EOPNOTSUPP;
1034         }
1035
1036         if (!try_module_get(module)) {
1037                 kfree_const(fw_work->name);
1038                 kfree(fw_work);
1039                 return -EFAULT;
1040         }
1041
1042         get_device(fw_work->device);
1043         INIT_WORK(&fw_work->work, request_firmware_work_func);
1044         schedule_work(&fw_work->work);
1045         return 0;
1046 }
1047 EXPORT_SYMBOL(request_firmware_nowait);
1048
1049 #ifdef CONFIG_PM_SLEEP
1050 static ASYNC_DOMAIN_EXCLUSIVE(fw_cache_domain);
1051
1052 /**
1053  * cache_firmware() - cache one firmware image in kernel memory space
1054  * @fw_name: the firmware image name
1055  *
1056  * Cache firmware in kernel memory so that drivers can use it when
1057  * system isn't ready for them to request firmware image from userspace.
1058  * Once it returns successfully, driver can use request_firmware or its
1059  * nowait version to get the cached firmware without any interacting
1060  * with userspace
1061  *
1062  * Return 0 if the firmware image has been cached successfully
1063  * Return !0 otherwise
1064  *
1065  */
1066 static int cache_firmware(const char *fw_name)
1067 {
1068         int ret;
1069         const struct firmware *fw;
1070
1071         pr_debug("%s: %s\n", __func__, fw_name);
1072
1073         ret = request_firmware(&fw, fw_name, NULL);
1074         if (!ret)
1075                 kfree(fw);
1076
1077         pr_debug("%s: %s ret=%d\n", __func__, fw_name, ret);
1078
1079         return ret;
1080 }
1081
1082 static struct fw_priv *lookup_fw_priv(const char *fw_name)
1083 {
1084         struct fw_priv *tmp;
1085         struct firmware_cache *fwc = &fw_cache;
1086
1087         spin_lock(&fwc->lock);
1088         tmp = __lookup_fw_priv(fw_name);
1089         spin_unlock(&fwc->lock);
1090
1091         return tmp;
1092 }
1093
1094 /**
1095  * uncache_firmware() - remove one cached firmware image
1096  * @fw_name: the firmware image name
1097  *
1098  * Uncache one firmware image which has been cached successfully
1099  * before.
1100  *
1101  * Return 0 if the firmware cache has been removed successfully
1102  * Return !0 otherwise
1103  *
1104  */
1105 static int uncache_firmware(const char *fw_name)
1106 {
1107         struct fw_priv *fw_priv;
1108         struct firmware fw;
1109
1110         pr_debug("%s: %s\n", __func__, fw_name);
1111
1112         if (fw_get_builtin_firmware(&fw, fw_name, NULL, 0))
1113                 return 0;
1114
1115         fw_priv = lookup_fw_priv(fw_name);
1116         if (fw_priv) {
1117                 free_fw_priv(fw_priv);
1118                 return 0;
1119         }
1120
1121         return -EINVAL;
1122 }
1123
1124 static struct fw_cache_entry *alloc_fw_cache_entry(const char *name)
1125 {
1126         struct fw_cache_entry *fce;
1127
1128         fce = kzalloc(sizeof(*fce), GFP_ATOMIC);
1129         if (!fce)
1130                 goto exit;
1131
1132         fce->name = kstrdup_const(name, GFP_ATOMIC);
1133         if (!fce->name) {
1134                 kfree(fce);
1135                 fce = NULL;
1136                 goto exit;
1137         }
1138 exit:
1139         return fce;
1140 }
1141
1142 static int __fw_entry_found(const char *name)
1143 {
1144         struct firmware_cache *fwc = &fw_cache;
1145         struct fw_cache_entry *fce;
1146
1147         list_for_each_entry(fce, &fwc->fw_names, list) {
1148                 if (!strcmp(fce->name, name))
1149                         return 1;
1150         }
1151         return 0;
1152 }
1153
1154 static int fw_cache_piggyback_on_request(const char *name)
1155 {
1156         struct firmware_cache *fwc = &fw_cache;
1157         struct fw_cache_entry *fce;
1158         int ret = 0;
1159
1160         spin_lock(&fwc->name_lock);
1161         if (__fw_entry_found(name))
1162                 goto found;
1163
1164         fce = alloc_fw_cache_entry(name);
1165         if (fce) {
1166                 ret = 1;
1167                 list_add(&fce->list, &fwc->fw_names);
1168                 pr_debug("%s: fw: %s\n", __func__, name);
1169         }
1170 found:
1171         spin_unlock(&fwc->name_lock);
1172         return ret;
1173 }
1174
1175 static void free_fw_cache_entry(struct fw_cache_entry *fce)
1176 {
1177         kfree_const(fce->name);
1178         kfree(fce);
1179 }
1180
1181 static void __async_dev_cache_fw_image(void *fw_entry,
1182                                        async_cookie_t cookie)
1183 {
1184         struct fw_cache_entry *fce = fw_entry;
1185         struct firmware_cache *fwc = &fw_cache;
1186         int ret;
1187
1188         ret = cache_firmware(fce->name);
1189         if (ret) {
1190                 spin_lock(&fwc->name_lock);
1191                 list_del(&fce->list);
1192                 spin_unlock(&fwc->name_lock);
1193
1194                 free_fw_cache_entry(fce);
1195         }
1196 }
1197
1198 /* called with dev->devres_lock held */
1199 static void dev_create_fw_entry(struct device *dev, void *res,
1200                                 void *data)
1201 {
1202         struct fw_name_devm *fwn = res;
1203         const char *fw_name = fwn->name;
1204         struct list_head *head = data;
1205         struct fw_cache_entry *fce;
1206
1207         fce = alloc_fw_cache_entry(fw_name);
1208         if (fce)
1209                 list_add(&fce->list, head);
1210 }
1211
1212 static int devm_name_match(struct device *dev, void *res,
1213                            void *match_data)
1214 {
1215         struct fw_name_devm *fwn = res;
1216         return (fwn->magic == (unsigned long)match_data);
1217 }
1218
1219 static void dev_cache_fw_image(struct device *dev, void *data)
1220 {
1221         LIST_HEAD(todo);
1222         struct fw_cache_entry *fce;
1223         struct fw_cache_entry *fce_next;
1224         struct firmware_cache *fwc = &fw_cache;
1225
1226         devres_for_each_res(dev, fw_name_devm_release,
1227                             devm_name_match, &fw_cache,
1228                             dev_create_fw_entry, &todo);
1229
1230         list_for_each_entry_safe(fce, fce_next, &todo, list) {
1231                 list_del(&fce->list);
1232
1233                 spin_lock(&fwc->name_lock);
1234                 /* only one cache entry for one firmware */
1235                 if (!__fw_entry_found(fce->name)) {
1236                         list_add(&fce->list, &fwc->fw_names);
1237                 } else {
1238                         free_fw_cache_entry(fce);
1239                         fce = NULL;
1240                 }
1241                 spin_unlock(&fwc->name_lock);
1242
1243                 if (fce)
1244                         async_schedule_domain(__async_dev_cache_fw_image,
1245                                               (void *)fce,
1246                                               &fw_cache_domain);
1247         }
1248 }
1249
1250 static void __device_uncache_fw_images(void)
1251 {
1252         struct firmware_cache *fwc = &fw_cache;
1253         struct fw_cache_entry *fce;
1254
1255         spin_lock(&fwc->name_lock);
1256         while (!list_empty(&fwc->fw_names)) {
1257                 fce = list_entry(fwc->fw_names.next,
1258                                 struct fw_cache_entry, list);
1259                 list_del(&fce->list);
1260                 spin_unlock(&fwc->name_lock);
1261
1262                 uncache_firmware(fce->name);
1263                 free_fw_cache_entry(fce);
1264
1265                 spin_lock(&fwc->name_lock);
1266         }
1267         spin_unlock(&fwc->name_lock);
1268 }
1269
1270 /**
1271  * device_cache_fw_images() - cache devices' firmware
1272  *
1273  * If one device called request_firmware or its nowait version
1274  * successfully before, the firmware names are recored into the
1275  * device's devres link list, so device_cache_fw_images can call
1276  * cache_firmware() to cache these firmwares for the device,
1277  * then the device driver can load its firmwares easily at
1278  * time when system is not ready to complete loading firmware.
1279  */
1280 static void device_cache_fw_images(void)
1281 {
1282         struct firmware_cache *fwc = &fw_cache;
1283         DEFINE_WAIT(wait);
1284
1285         pr_debug("%s\n", __func__);
1286
1287         /* cancel uncache work */
1288         cancel_delayed_work_sync(&fwc->work);
1289
1290         fw_fallback_set_cache_timeout();
1291
1292         mutex_lock(&fw_lock);
1293         fwc->state = FW_LOADER_START_CACHE;
1294         dpm_for_each_dev(NULL, dev_cache_fw_image);
1295         mutex_unlock(&fw_lock);
1296
1297         /* wait for completion of caching firmware for all devices */
1298         async_synchronize_full_domain(&fw_cache_domain);
1299
1300         fw_fallback_set_default_timeout();
1301 }
1302
1303 /**
1304  * device_uncache_fw_images() - uncache devices' firmware
1305  *
1306  * uncache all firmwares which have been cached successfully
1307  * by device_uncache_fw_images earlier
1308  */
1309 static void device_uncache_fw_images(void)
1310 {
1311         pr_debug("%s\n", __func__);
1312         __device_uncache_fw_images();
1313 }
1314
1315 static void device_uncache_fw_images_work(struct work_struct *work)
1316 {
1317         device_uncache_fw_images();
1318 }
1319
1320 /**
1321  * device_uncache_fw_images_delay() - uncache devices firmwares
1322  * @delay: number of milliseconds to delay uncache device firmwares
1323  *
1324  * uncache all devices's firmwares which has been cached successfully
1325  * by device_cache_fw_images after @delay milliseconds.
1326  */
1327 static void device_uncache_fw_images_delay(unsigned long delay)
1328 {
1329         queue_delayed_work(system_power_efficient_wq, &fw_cache.work,
1330                            msecs_to_jiffies(delay));
1331 }
1332
1333 static int fw_pm_notify(struct notifier_block *notify_block,
1334                         unsigned long mode, void *unused)
1335 {
1336         switch (mode) {
1337         case PM_HIBERNATION_PREPARE:
1338         case PM_SUSPEND_PREPARE:
1339         case PM_RESTORE_PREPARE:
1340                 /*
1341                  * kill pending fallback requests with a custom fallback
1342                  * to avoid stalling suspend.
1343                  */
1344                 kill_pending_fw_fallback_reqs(true);
1345                 device_cache_fw_images();
1346                 break;
1347
1348         case PM_POST_SUSPEND:
1349         case PM_POST_HIBERNATION:
1350         case PM_POST_RESTORE:
1351                 /*
1352                  * In case that system sleep failed and syscore_suspend is
1353                  * not called.
1354                  */
1355                 mutex_lock(&fw_lock);
1356                 fw_cache.state = FW_LOADER_NO_CACHE;
1357                 mutex_unlock(&fw_lock);
1358
1359                 device_uncache_fw_images_delay(10 * MSEC_PER_SEC);
1360                 break;
1361         }
1362
1363         return 0;
1364 }
1365
1366 /* stop caching firmware once syscore_suspend is reached */
1367 static int fw_suspend(void)
1368 {
1369         fw_cache.state = FW_LOADER_NO_CACHE;
1370         return 0;
1371 }
1372
1373 static struct syscore_ops fw_syscore_ops = {
1374         .suspend = fw_suspend,
1375 };
1376
1377 static int __init register_fw_pm_ops(void)
1378 {
1379         int ret;
1380
1381         spin_lock_init(&fw_cache.name_lock);
1382         INIT_LIST_HEAD(&fw_cache.fw_names);
1383
1384         INIT_DELAYED_WORK(&fw_cache.work,
1385                           device_uncache_fw_images_work);
1386
1387         fw_cache.pm_notify.notifier_call = fw_pm_notify;
1388         ret = register_pm_notifier(&fw_cache.pm_notify);
1389         if (ret)
1390                 return ret;
1391
1392         register_syscore_ops(&fw_syscore_ops);
1393
1394         return ret;
1395 }
1396
1397 static inline void unregister_fw_pm_ops(void)
1398 {
1399         unregister_syscore_ops(&fw_syscore_ops);
1400         unregister_pm_notifier(&fw_cache.pm_notify);
1401 }
1402 #else
1403 static int fw_cache_piggyback_on_request(const char *name)
1404 {
1405         return 0;
1406 }
1407 static inline int register_fw_pm_ops(void)
1408 {
1409         return 0;
1410 }
1411 static inline void unregister_fw_pm_ops(void)
1412 {
1413 }
1414 #endif
1415
1416 static void __init fw_cache_init(void)
1417 {
1418         spin_lock_init(&fw_cache.lock);
1419         INIT_LIST_HEAD(&fw_cache.head);
1420         fw_cache.state = FW_LOADER_NO_CACHE;
1421 }
1422
1423 static int fw_shutdown_notify(struct notifier_block *unused1,
1424                               unsigned long unused2, void *unused3)
1425 {
1426         /*
1427          * Kill all pending fallback requests to avoid both stalling shutdown,
1428          * and avoid a deadlock with the usermode_lock.
1429          */
1430         kill_pending_fw_fallback_reqs(false);
1431
1432         return NOTIFY_DONE;
1433 }
1434
1435 static struct notifier_block fw_shutdown_nb = {
1436         .notifier_call = fw_shutdown_notify,
1437 };
1438
1439 static int __init firmware_class_init(void)
1440 {
1441         int ret;
1442
1443         /* No need to unfold these on exit */
1444         fw_cache_init();
1445
1446         ret = register_fw_pm_ops();
1447         if (ret)
1448                 return ret;
1449
1450         ret = register_reboot_notifier(&fw_shutdown_nb);
1451         if (ret)
1452                 goto out;
1453
1454         return register_sysfs_loader();
1455
1456 out:
1457         unregister_fw_pm_ops();
1458         return ret;
1459 }
1460
1461 static void __exit firmware_class_exit(void)
1462 {
1463         unregister_fw_pm_ops();
1464         unregister_reboot_notifier(&fw_shutdown_nb);
1465         unregister_sysfs_loader();
1466 }
1467
1468 fs_initcall(firmware_class_init);
1469 module_exit(firmware_class_exit);