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