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