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