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