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