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