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