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