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/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
  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_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
  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                 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 */
 535 static 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 */
 546 static 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
 561 static 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
 571 static 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
 580 static 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
 590 static 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 */
 602 static 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
 625 static bool fw_cache_is_setup(struct device *dev, const char *name)
 626 {
 627         return false;
 628 }
 629
 630 static int fw_add_devm_name(struct device *dev, const char *name)
 631 {
 632         return 0;
 633 }
 634 #endif
 635
 636 int 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  */
 685 static 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  */
 737 static 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() */
 751 static 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  **/
 819 int
 820 request_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 }
 832 EXPORT_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  **/
 847 int 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 }
 859 EXPORT_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  **/
 872 int 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);
 881         module_put(THIS_MODULE);
 882         return ret;
 883 }
 884 EXPORT_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  **/
 898 int 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 }
 908 EXPORT_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  */
 925 int
 926 request_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 }
 940 EXPORT_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  **/
 946 void 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 }
 954 EXPORT_SYMBOL(release_firmware);
 955
 956 /* Async support */
 957 struct 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
 967 static 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  **/
1007 int
1008 request_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 }
1048 EXPORT_SYMBOL(request_firmware_nowait);
1049
1050 #ifdef CONFIG_FW_CACHE
1051 static 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  */
1067 static 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
1083 static 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  */
1106 static 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
1125 static 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         }
1139 exit:
1140         return fce;
1141 }
1142
1143 static 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
1155 static 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         }
1171 found:
1172         spin_unlock(&fwc->name_lock);
1173         return ret;
1174 }
1175
1176 static void free_fw_cache_entry(struct fw_cache_entry *fce)
1177 {
1178         kfree_const(fce->name);
1179         kfree(fce);
1180 }
1181
1182 static 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 */
1200 static 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
1213 static 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
1220 static 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
1251 static 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  */
1281 static 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  */
1310 static void device_uncache_fw_images(void)
1311 {
1312         pr_debug("%s\n", __func__);
1313         __device_uncache_fw_images();
1314 }
1315
1316 static 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  */
1328 static 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
1334 static 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 */
1368 static int fw_suspend(void)
1369 {
1370         fw_cache.state = FW_LOADER_NO_CACHE;
1371         return 0;
1372 }
1373
1374 static struct syscore_ops fw_syscore_ops = {
1375         .suspend = fw_suspend,
1376 };
1377
1378 static 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
1398 static 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
1404 static int fw_cache_piggyback_on_request(const char *name)
1405 {
1406         return 0;
1407 }
1408 static inline int register_fw_pm_ops(void)
1409 {
1410         return 0;
1411 }
1412 static inline void unregister_fw_pm_ops(void)
1413 {
1414 }
1415 #endif
1416
1417 static 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
1424 static 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
1436 static struct notifier_block fw_shutdown_nb = {
1437         .notifier_call = fw_shutdown_notify,
1438 };
1439
1440 static 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
1457 out:
1458         unregister_fw_pm_ops();
1459         return ret;
1460 }
1461
1462 static 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
1469 fs_initcall(firmware_class_init);
1470 module_exit(firmware_class_exit);