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 (rc != -ENOENT) |
555 | dev_warn(device, "loading %s failed with error %d\n" , |
556 | path, rc); |
557 | else |
558 | dev_dbg(device, "loading %s failed for no such file or directory.\n" , |
559 | path); |
560 | continue; |
561 | } |
562 | size = rc; |
563 | rc = 0; |
564 | |
565 | dev_dbg(device, "Loading firmware from %s\n" , path); |
566 | if (decompress) { |
567 | dev_dbg(device, "f/w decompressing %s\n" , |
568 | fw_priv->fw_name); |
569 | rc = decompress(device, fw_priv, size, buffer); |
570 | /* discard the superfluous original content */ |
571 | vfree(addr: buffer); |
572 | buffer = NULL; |
573 | if (rc) { |
574 | fw_free_paged_buf(fw_priv); |
575 | continue; |
576 | } |
577 | } else { |
578 | dev_dbg(device, "direct-loading %s\n" , |
579 | fw_priv->fw_name); |
580 | if (!fw_priv->data) |
581 | fw_priv->data = buffer; |
582 | fw_priv->size = size; |
583 | } |
584 | fw_state_done(fw_priv); |
585 | break; |
586 | } |
587 | __putname(path); |
588 | |
589 | return rc; |
590 | } |
591 | |
592 | /* firmware holds the ownership of pages */ |
593 | static void firmware_free_data(const struct firmware *fw) |
594 | { |
595 | /* Loaded directly? */ |
596 | if (!fw->priv) { |
597 | vfree(addr: fw->data); |
598 | return; |
599 | } |
600 | free_fw_priv(fw_priv: fw->priv); |
601 | } |
602 | |
603 | /* store the pages buffer info firmware from buf */ |
604 | static void fw_set_page_data(struct fw_priv *fw_priv, struct firmware *fw) |
605 | { |
606 | fw->priv = fw_priv; |
607 | fw->size = fw_priv->size; |
608 | fw->data = fw_priv->data; |
609 | |
610 | pr_debug("%s: fw-%s fw_priv=%p data=%p size=%u\n" , |
611 | __func__, fw_priv->fw_name, fw_priv, fw_priv->data, |
612 | (unsigned int)fw_priv->size); |
613 | } |
614 | |
615 | #ifdef CONFIG_FW_CACHE |
616 | static void fw_name_devm_release(struct device *dev, void *res) |
617 | { |
618 | struct fw_name_devm *fwn = res; |
619 | |
620 | if (fwn->magic == (unsigned long)&fw_cache) |
621 | pr_debug("%s: fw_name-%s devm-%p released\n" , |
622 | __func__, fwn->name, res); |
623 | kfree_const(x: fwn->name); |
624 | } |
625 | |
626 | static int fw_devm_match(struct device *dev, void *res, |
627 | void *match_data) |
628 | { |
629 | struct fw_name_devm *fwn = res; |
630 | |
631 | return (fwn->magic == (unsigned long)&fw_cache) && |
632 | !strcmp(fwn->name, match_data); |
633 | } |
634 | |
635 | static struct fw_name_devm *fw_find_devm_name(struct device *dev, |
636 | const char *name) |
637 | { |
638 | struct fw_name_devm *fwn; |
639 | |
640 | fwn = devres_find(dev, release: fw_name_devm_release, |
641 | match: fw_devm_match, match_data: (void *)name); |
642 | return fwn; |
643 | } |
644 | |
645 | static bool fw_cache_is_setup(struct device *dev, const char *name) |
646 | { |
647 | struct fw_name_devm *fwn; |
648 | |
649 | fwn = fw_find_devm_name(dev, name); |
650 | if (fwn) |
651 | return true; |
652 | |
653 | return false; |
654 | } |
655 | |
656 | /* add firmware name into devres list */ |
657 | static int fw_add_devm_name(struct device *dev, const char *name) |
658 | { |
659 | struct fw_name_devm *fwn; |
660 | |
661 | if (fw_cache_is_setup(dev, name)) |
662 | return 0; |
663 | |
664 | fwn = devres_alloc(fw_name_devm_release, sizeof(struct fw_name_devm), |
665 | GFP_KERNEL); |
666 | if (!fwn) |
667 | return -ENOMEM; |
668 | fwn->name = kstrdup_const(s: name, GFP_KERNEL); |
669 | if (!fwn->name) { |
670 | devres_free(res: fwn); |
671 | return -ENOMEM; |
672 | } |
673 | |
674 | fwn->magic = (unsigned long)&fw_cache; |
675 | devres_add(dev, res: fwn); |
676 | |
677 | return 0; |
678 | } |
679 | #else |
680 | static bool fw_cache_is_setup(struct device *dev, const char *name) |
681 | { |
682 | return false; |
683 | } |
684 | |
685 | static int fw_add_devm_name(struct device *dev, const char *name) |
686 | { |
687 | return 0; |
688 | } |
689 | #endif |
690 | |
691 | int assign_fw(struct firmware *fw, struct device *device) |
692 | { |
693 | struct fw_priv *fw_priv = fw->priv; |
694 | int ret; |
695 | |
696 | mutex_lock(&fw_lock); |
697 | if (!fw_priv->size || fw_state_is_aborted(fw_priv)) { |
698 | mutex_unlock(lock: &fw_lock); |
699 | return -ENOENT; |
700 | } |
701 | |
702 | /* |
703 | * add firmware name into devres list so that we can auto cache |
704 | * and uncache firmware for device. |
705 | * |
706 | * device may has been deleted already, but the problem |
707 | * should be fixed in devres or driver core. |
708 | */ |
709 | /* don't cache firmware handled without uevent */ |
710 | if (device && (fw_priv->opt_flags & FW_OPT_UEVENT) && |
711 | !(fw_priv->opt_flags & FW_OPT_NOCACHE)) { |
712 | ret = fw_add_devm_name(dev: device, name: fw_priv->fw_name); |
713 | if (ret) { |
714 | mutex_unlock(lock: &fw_lock); |
715 | return ret; |
716 | } |
717 | } |
718 | |
719 | /* |
720 | * After caching firmware image is started, let it piggyback |
721 | * on request firmware. |
722 | */ |
723 | if (!(fw_priv->opt_flags & FW_OPT_NOCACHE) && |
724 | fw_priv->fwc->state == FW_LOADER_START_CACHE) |
725 | fw_cache_piggyback_on_request(fw_priv); |
726 | |
727 | /* pass the pages buffer to driver at the last minute */ |
728 | fw_set_page_data(fw_priv, fw); |
729 | mutex_unlock(lock: &fw_lock); |
730 | return 0; |
731 | } |
732 | |
733 | /* prepare firmware and firmware_buf structs; |
734 | * return 0 if a firmware is already assigned, 1 if need to load one, |
735 | * or a negative error code |
736 | */ |
737 | static int |
738 | _request_firmware_prepare(struct firmware **firmware_p, const char *name, |
739 | struct device *device, void *dbuf, size_t size, |
740 | size_t offset, u32 opt_flags) |
741 | { |
742 | struct firmware *firmware; |
743 | struct fw_priv *fw_priv; |
744 | int ret; |
745 | |
746 | *firmware_p = firmware = kzalloc(size: sizeof(*firmware), GFP_KERNEL); |
747 | if (!firmware) { |
748 | dev_err(device, "%s: kmalloc(struct firmware) failed\n" , |
749 | __func__); |
750 | return -ENOMEM; |
751 | } |
752 | |
753 | if (firmware_request_builtin_buf(fw: firmware, name, buf: dbuf, size)) { |
754 | dev_dbg(device, "using built-in %s\n" , name); |
755 | return 0; /* assigned */ |
756 | } |
757 | |
758 | ret = alloc_lookup_fw_priv(fw_name: name, fwc: &fw_cache, fw_priv: &fw_priv, dbuf, size, |
759 | offset, opt_flags); |
760 | |
761 | /* |
762 | * bind with 'priv' now to avoid warning in failure path |
763 | * of requesting firmware. |
764 | */ |
765 | firmware->priv = fw_priv; |
766 | |
767 | if (ret > 0) { |
768 | ret = fw_state_wait(fw_priv); |
769 | if (!ret) { |
770 | fw_set_page_data(fw_priv, fw: firmware); |
771 | return 0; /* assigned */ |
772 | } |
773 | } |
774 | |
775 | if (ret < 0) |
776 | return ret; |
777 | return 1; /* need to load */ |
778 | } |
779 | |
780 | /* |
781 | * Batched requests need only one wake, we need to do this step last due to the |
782 | * fallback mechanism. The buf is protected with kref_get(), and it won't be |
783 | * released until the last user calls release_firmware(). |
784 | * |
785 | * Failed batched requests are possible as well, in such cases we just share |
786 | * the struct fw_priv and won't release it until all requests are woken |
787 | * and have gone through this same path. |
788 | */ |
789 | static void fw_abort_batch_reqs(struct firmware *fw) |
790 | { |
791 | struct fw_priv *fw_priv; |
792 | |
793 | /* Loaded directly? */ |
794 | if (!fw || !fw->priv) |
795 | return; |
796 | |
797 | fw_priv = fw->priv; |
798 | mutex_lock(&fw_lock); |
799 | if (!fw_state_is_aborted(fw_priv)) |
800 | fw_state_aborted(fw_priv); |
801 | mutex_unlock(lock: &fw_lock); |
802 | } |
803 | |
804 | #if defined(CONFIG_FW_LOADER_DEBUG) |
805 | #include <crypto/hash.h> |
806 | #include <crypto/sha2.h> |
807 | |
808 | static void fw_log_firmware_info(const struct firmware *fw, const char *name, struct device *device) |
809 | { |
810 | struct shash_desc *shash; |
811 | struct crypto_shash *alg; |
812 | u8 *sha256buf; |
813 | char *outbuf; |
814 | |
815 | alg = crypto_alloc_shash(alg_name: "sha256" , type: 0, mask: 0); |
816 | if (IS_ERR(ptr: alg)) |
817 | return; |
818 | |
819 | sha256buf = kmalloc(SHA256_DIGEST_SIZE, GFP_KERNEL); |
820 | outbuf = kmalloc(SHA256_BLOCK_SIZE + 1, GFP_KERNEL); |
821 | shash = kmalloc(size: sizeof(*shash) + crypto_shash_descsize(tfm: alg), GFP_KERNEL); |
822 | if (!sha256buf || !outbuf || !shash) |
823 | goto out_free; |
824 | |
825 | shash->tfm = alg; |
826 | |
827 | if (crypto_shash_digest(desc: shash, data: fw->data, len: fw->size, out: sha256buf) < 0) |
828 | goto out_shash; |
829 | |
830 | for (int i = 0; i < SHA256_DIGEST_SIZE; i++) |
831 | sprintf(buf: &outbuf[i * 2], fmt: "%02x" , sha256buf[i]); |
832 | outbuf[SHA256_BLOCK_SIZE] = 0; |
833 | dev_dbg(device, "Loaded FW: %s, sha256: %s\n" , name, outbuf); |
834 | |
835 | out_shash: |
836 | crypto_free_shash(tfm: alg); |
837 | out_free: |
838 | kfree(objp: shash); |
839 | kfree(objp: outbuf); |
840 | kfree(objp: sha256buf); |
841 | } |
842 | #else |
843 | static void fw_log_firmware_info(const struct firmware *fw, const char *name, |
844 | struct device *device) |
845 | {} |
846 | #endif |
847 | |
848 | /* called from request_firmware() and request_firmware_work_func() */ |
849 | static int |
850 | _request_firmware(const struct firmware **firmware_p, const char *name, |
851 | struct device *device, void *buf, size_t size, |
852 | size_t offset, u32 opt_flags) |
853 | { |
854 | struct firmware *fw = NULL; |
855 | struct cred *kern_cred = NULL; |
856 | const struct cred *old_cred; |
857 | bool nondirect = false; |
858 | int ret; |
859 | |
860 | if (!firmware_p) |
861 | return -EINVAL; |
862 | |
863 | if (!name || name[0] == '\0') { |
864 | ret = -EINVAL; |
865 | goto out; |
866 | } |
867 | |
868 | ret = _request_firmware_prepare(firmware_p: &fw, name, device, dbuf: buf, size, |
869 | offset, opt_flags); |
870 | if (ret <= 0) /* error or already assigned */ |
871 | goto out; |
872 | |
873 | /* |
874 | * We are about to try to access the firmware file. Because we may have been |
875 | * called by a driver when serving an unrelated request from userland, we use |
876 | * the kernel credentials to read the file. |
877 | */ |
878 | kern_cred = prepare_kernel_cred(&init_task); |
879 | if (!kern_cred) { |
880 | ret = -ENOMEM; |
881 | goto out; |
882 | } |
883 | old_cred = override_creds(kern_cred); |
884 | |
885 | ret = fw_get_filesystem_firmware(device, fw_priv: fw->priv, suffix: "" , NULL); |
886 | |
887 | /* Only full reads can support decompression, platform, and sysfs. */ |
888 | if (!(opt_flags & FW_OPT_PARTIAL)) |
889 | nondirect = true; |
890 | |
891 | #ifdef CONFIG_FW_LOADER_COMPRESS_ZSTD |
892 | if (ret == -ENOENT && nondirect) |
893 | ret = fw_get_filesystem_firmware(device, fw_priv: fw->priv, suffix: ".zst" , |
894 | decompress: fw_decompress_zstd); |
895 | #endif |
896 | #ifdef CONFIG_FW_LOADER_COMPRESS_XZ |
897 | if (ret == -ENOENT && nondirect) |
898 | ret = fw_get_filesystem_firmware(device, fw_priv: fw->priv, suffix: ".xz" , |
899 | decompress: fw_decompress_xz); |
900 | #endif |
901 | if (ret == -ENOENT && nondirect) |
902 | ret = firmware_fallback_platform(fw_priv: fw->priv); |
903 | |
904 | if (ret) { |
905 | if (!(opt_flags & FW_OPT_NO_WARN)) |
906 | dev_warn(device, |
907 | "Direct firmware load for %s failed with error %d\n" , |
908 | name, ret); |
909 | if (nondirect) |
910 | ret = firmware_fallback_sysfs(fw, name, device, |
911 | opt_flags, ret); |
912 | } else |
913 | ret = assign_fw(fw, device); |
914 | |
915 | revert_creds(old_cred); |
916 | put_cred(cred: kern_cred); |
917 | |
918 | out: |
919 | if (ret < 0) { |
920 | fw_abort_batch_reqs(fw); |
921 | release_firmware(fw); |
922 | fw = NULL; |
923 | } else { |
924 | fw_log_firmware_info(fw, name, device); |
925 | } |
926 | |
927 | *firmware_p = fw; |
928 | return ret; |
929 | } |
930 | |
931 | /** |
932 | * request_firmware() - send firmware request and wait for it |
933 | * @firmware_p: pointer to firmware image |
934 | * @name: name of firmware file |
935 | * @device: device for which firmware is being loaded |
936 | * |
937 | * @firmware_p will be used to return a firmware image by the name |
938 | * of @name for device @device. |
939 | * |
940 | * Should be called from user context where sleeping is allowed. |
941 | * |
942 | * @name will be used as $FIRMWARE in the uevent environment and |
943 | * should be distinctive enough not to be confused with any other |
944 | * firmware image for this or any other device. |
945 | * |
946 | * Caller must hold the reference count of @device. |
947 | * |
948 | * The function can be called safely inside device's suspend and |
949 | * resume callback. |
950 | **/ |
951 | int |
952 | request_firmware(const struct firmware **firmware_p, const char *name, |
953 | struct device *device) |
954 | { |
955 | int ret; |
956 | |
957 | /* Need to pin this module until return */ |
958 | __module_get(THIS_MODULE); |
959 | ret = _request_firmware(firmware_p, name, device, NULL, size: 0, offset: 0, |
960 | opt_flags: FW_OPT_UEVENT); |
961 | module_put(THIS_MODULE); |
962 | return ret; |
963 | } |
964 | EXPORT_SYMBOL(request_firmware); |
965 | |
966 | /** |
967 | * firmware_request_nowarn() - request for an optional fw module |
968 | * @firmware: pointer to firmware image |
969 | * @name: name of firmware file |
970 | * @device: device for which firmware is being loaded |
971 | * |
972 | * This function is similar in behaviour to request_firmware(), except it |
973 | * doesn't produce warning messages when the file is not found. The sysfs |
974 | * fallback mechanism is enabled if direct filesystem lookup fails. However, |
975 | * failures to find the firmware file with it are still suppressed. It is |
976 | * therefore up to the driver to check for the return value of this call and to |
977 | * decide when to inform the users of errors. |
978 | **/ |
979 | int firmware_request_nowarn(const struct firmware **firmware, const char *name, |
980 | struct device *device) |
981 | { |
982 | int ret; |
983 | |
984 | /* Need to pin this module until return */ |
985 | __module_get(THIS_MODULE); |
986 | ret = _request_firmware(firmware_p: firmware, name, device, NULL, size: 0, offset: 0, |
987 | opt_flags: FW_OPT_UEVENT | FW_OPT_NO_WARN); |
988 | module_put(THIS_MODULE); |
989 | return ret; |
990 | } |
991 | EXPORT_SYMBOL_GPL(firmware_request_nowarn); |
992 | |
993 | /** |
994 | * request_firmware_direct() - load firmware directly without usermode helper |
995 | * @firmware_p: pointer to firmware image |
996 | * @name: name of firmware file |
997 | * @device: device for which firmware is being loaded |
998 | * |
999 | * This function works pretty much like request_firmware(), but this doesn't |
1000 | * fall back to usermode helper even if the firmware couldn't be loaded |
1001 | * directly from fs. Hence it's useful for loading optional firmwares, which |
1002 | * aren't always present, without extra long timeouts of udev. |
1003 | **/ |
1004 | int request_firmware_direct(const struct firmware **firmware_p, |
1005 | const char *name, struct device *device) |
1006 | { |
1007 | int ret; |
1008 | |
1009 | __module_get(THIS_MODULE); |
1010 | ret = _request_firmware(firmware_p, name, device, NULL, size: 0, offset: 0, |
1011 | opt_flags: FW_OPT_UEVENT | FW_OPT_NO_WARN | |
1012 | FW_OPT_NOFALLBACK_SYSFS); |
1013 | module_put(THIS_MODULE); |
1014 | return ret; |
1015 | } |
1016 | EXPORT_SYMBOL_GPL(request_firmware_direct); |
1017 | |
1018 | /** |
1019 | * firmware_request_platform() - request firmware with platform-fw fallback |
1020 | * @firmware: pointer to firmware image |
1021 | * @name: name of firmware file |
1022 | * @device: device for which firmware is being loaded |
1023 | * |
1024 | * This function is similar in behaviour to request_firmware, except that if |
1025 | * direct filesystem lookup fails, it will fallback to looking for a copy of the |
1026 | * requested firmware embedded in the platform's main (e.g. UEFI) firmware. |
1027 | **/ |
1028 | int firmware_request_platform(const struct firmware **firmware, |
1029 | const char *name, struct device *device) |
1030 | { |
1031 | int ret; |
1032 | |
1033 | /* Need to pin this module until return */ |
1034 | __module_get(THIS_MODULE); |
1035 | ret = _request_firmware(firmware_p: firmware, name, device, NULL, size: 0, offset: 0, |
1036 | opt_flags: FW_OPT_UEVENT | FW_OPT_FALLBACK_PLATFORM); |
1037 | module_put(THIS_MODULE); |
1038 | return ret; |
1039 | } |
1040 | EXPORT_SYMBOL_GPL(firmware_request_platform); |
1041 | |
1042 | /** |
1043 | * firmware_request_cache() - cache firmware for suspend so resume can use it |
1044 | * @name: name of firmware file |
1045 | * @device: device for which firmware should be cached for |
1046 | * |
1047 | * There are some devices with an optimization that enables the device to not |
1048 | * require loading firmware on system reboot. This optimization may still |
1049 | * require the firmware present on resume from suspend. This routine can be |
1050 | * used to ensure the firmware is present on resume from suspend in these |
1051 | * situations. This helper is not compatible with drivers which use |
1052 | * request_firmware_into_buf() or request_firmware_nowait() with no uevent set. |
1053 | **/ |
1054 | int firmware_request_cache(struct device *device, const char *name) |
1055 | { |
1056 | int ret; |
1057 | |
1058 | mutex_lock(&fw_lock); |
1059 | ret = fw_add_devm_name(dev: device, name); |
1060 | mutex_unlock(lock: &fw_lock); |
1061 | |
1062 | return ret; |
1063 | } |
1064 | EXPORT_SYMBOL_GPL(firmware_request_cache); |
1065 | |
1066 | /** |
1067 | * request_firmware_into_buf() - load firmware into a previously allocated buffer |
1068 | * @firmware_p: pointer to firmware image |
1069 | * @name: name of firmware file |
1070 | * @device: device for which firmware is being loaded and DMA region allocated |
1071 | * @buf: address of buffer to load firmware into |
1072 | * @size: size of buffer |
1073 | * |
1074 | * This function works pretty much like request_firmware(), but it doesn't |
1075 | * allocate a buffer to hold the firmware data. Instead, the firmware |
1076 | * is loaded directly into the buffer pointed to by @buf and the @firmware_p |
1077 | * data member is pointed at @buf. |
1078 | * |
1079 | * This function doesn't cache firmware either. |
1080 | */ |
1081 | int |
1082 | request_firmware_into_buf(const struct firmware **firmware_p, const char *name, |
1083 | struct device *device, void *buf, size_t size) |
1084 | { |
1085 | int ret; |
1086 | |
1087 | if (fw_cache_is_setup(dev: device, name)) |
1088 | return -EOPNOTSUPP; |
1089 | |
1090 | __module_get(THIS_MODULE); |
1091 | ret = _request_firmware(firmware_p, name, device, buf, size, offset: 0, |
1092 | opt_flags: FW_OPT_UEVENT | FW_OPT_NOCACHE); |
1093 | module_put(THIS_MODULE); |
1094 | return ret; |
1095 | } |
1096 | EXPORT_SYMBOL(request_firmware_into_buf); |
1097 | |
1098 | /** |
1099 | * request_partial_firmware_into_buf() - load partial firmware into a previously allocated buffer |
1100 | * @firmware_p: pointer to firmware image |
1101 | * @name: name of firmware file |
1102 | * @device: device for which firmware is being loaded and DMA region allocated |
1103 | * @buf: address of buffer to load firmware into |
1104 | * @size: size of buffer |
1105 | * @offset: offset into file to read |
1106 | * |
1107 | * This function works pretty much like request_firmware_into_buf except |
1108 | * it allows a partial read of the file. |
1109 | */ |
1110 | int |
1111 | request_partial_firmware_into_buf(const struct firmware **firmware_p, |
1112 | const char *name, struct device *device, |
1113 | void *buf, size_t size, size_t offset) |
1114 | { |
1115 | int ret; |
1116 | |
1117 | if (fw_cache_is_setup(dev: device, name)) |
1118 | return -EOPNOTSUPP; |
1119 | |
1120 | __module_get(THIS_MODULE); |
1121 | ret = _request_firmware(firmware_p, name, device, buf, size, offset, |
1122 | opt_flags: FW_OPT_UEVENT | FW_OPT_NOCACHE | |
1123 | FW_OPT_PARTIAL); |
1124 | module_put(THIS_MODULE); |
1125 | return ret; |
1126 | } |
1127 | EXPORT_SYMBOL(request_partial_firmware_into_buf); |
1128 | |
1129 | /** |
1130 | * release_firmware() - release the resource associated with a firmware image |
1131 | * @fw: firmware resource to release |
1132 | **/ |
1133 | void release_firmware(const struct firmware *fw) |
1134 | { |
1135 | if (fw) { |
1136 | if (!firmware_is_builtin(fw)) |
1137 | firmware_free_data(fw); |
1138 | kfree(objp: fw); |
1139 | } |
1140 | } |
1141 | EXPORT_SYMBOL(release_firmware); |
1142 | |
1143 | /* Async support */ |
1144 | struct firmware_work { |
1145 | struct work_struct work; |
1146 | struct module *module; |
1147 | const char *name; |
1148 | struct device *device; |
1149 | void *context; |
1150 | void (*cont)(const struct firmware *fw, void *context); |
1151 | u32 opt_flags; |
1152 | }; |
1153 | |
1154 | static void request_firmware_work_func(struct work_struct *work) |
1155 | { |
1156 | struct firmware_work *fw_work; |
1157 | const struct firmware *fw; |
1158 | |
1159 | fw_work = container_of(work, struct firmware_work, work); |
1160 | |
1161 | _request_firmware(firmware_p: &fw, name: fw_work->name, device: fw_work->device, NULL, size: 0, offset: 0, |
1162 | opt_flags: fw_work->opt_flags); |
1163 | fw_work->cont(fw, fw_work->context); |
1164 | put_device(dev: fw_work->device); /* taken in request_firmware_nowait() */ |
1165 | |
1166 | module_put(module: fw_work->module); |
1167 | kfree_const(x: fw_work->name); |
1168 | kfree(objp: fw_work); |
1169 | } |
1170 | |
1171 | /** |
1172 | * request_firmware_nowait() - asynchronous version of request_firmware |
1173 | * @module: module requesting the firmware |
1174 | * @uevent: sends uevent to copy the firmware image if this flag |
1175 | * is non-zero else the firmware copy must be done manually. |
1176 | * @name: name of firmware file |
1177 | * @device: device for which firmware is being loaded |
1178 | * @gfp: allocation flags |
1179 | * @context: will be passed over to @cont, and |
1180 | * @fw may be %NULL if firmware request fails. |
1181 | * @cont: function will be called asynchronously when the firmware |
1182 | * request is over. |
1183 | * |
1184 | * Caller must hold the reference count of @device. |
1185 | * |
1186 | * Asynchronous variant of request_firmware() for user contexts: |
1187 | * - sleep for as small periods as possible since it may |
1188 | * increase kernel boot time of built-in device drivers |
1189 | * requesting firmware in their ->probe() methods, if |
1190 | * @gfp is GFP_KERNEL. |
1191 | * |
1192 | * - can't sleep at all if @gfp is GFP_ATOMIC. |
1193 | **/ |
1194 | int |
1195 | request_firmware_nowait( |
1196 | struct module *module, bool uevent, |
1197 | const char *name, struct device *device, gfp_t gfp, void *context, |
1198 | void (*cont)(const struct firmware *fw, void *context)) |
1199 | { |
1200 | struct firmware_work *fw_work; |
1201 | |
1202 | fw_work = kzalloc(size: sizeof(struct firmware_work), flags: gfp); |
1203 | if (!fw_work) |
1204 | return -ENOMEM; |
1205 | |
1206 | fw_work->module = module; |
1207 | fw_work->name = kstrdup_const(s: name, gfp); |
1208 | if (!fw_work->name) { |
1209 | kfree(objp: fw_work); |
1210 | return -ENOMEM; |
1211 | } |
1212 | fw_work->device = device; |
1213 | fw_work->context = context; |
1214 | fw_work->cont = cont; |
1215 | fw_work->opt_flags = FW_OPT_NOWAIT | |
1216 | (uevent ? FW_OPT_UEVENT : FW_OPT_USERHELPER); |
1217 | |
1218 | if (!uevent && fw_cache_is_setup(dev: device, name)) { |
1219 | kfree_const(x: fw_work->name); |
1220 | kfree(objp: fw_work); |
1221 | return -EOPNOTSUPP; |
1222 | } |
1223 | |
1224 | if (!try_module_get(module)) { |
1225 | kfree_const(x: fw_work->name); |
1226 | kfree(objp: fw_work); |
1227 | return -EFAULT; |
1228 | } |
1229 | |
1230 | get_device(dev: fw_work->device); |
1231 | INIT_WORK(&fw_work->work, request_firmware_work_func); |
1232 | schedule_work(work: &fw_work->work); |
1233 | return 0; |
1234 | } |
1235 | EXPORT_SYMBOL(request_firmware_nowait); |
1236 | |
1237 | #ifdef CONFIG_FW_CACHE |
1238 | static ASYNC_DOMAIN_EXCLUSIVE(fw_cache_domain); |
1239 | |
1240 | /** |
1241 | * cache_firmware() - cache one firmware image in kernel memory space |
1242 | * @fw_name: the firmware image name |
1243 | * |
1244 | * Cache firmware in kernel memory so that drivers can use it when |
1245 | * system isn't ready for them to request firmware image from userspace. |
1246 | * Once it returns successfully, driver can use request_firmware or its |
1247 | * nowait version to get the cached firmware without any interacting |
1248 | * with userspace |
1249 | * |
1250 | * Return 0 if the firmware image has been cached successfully |
1251 | * Return !0 otherwise |
1252 | * |
1253 | */ |
1254 | static int cache_firmware(const char *fw_name) |
1255 | { |
1256 | int ret; |
1257 | const struct firmware *fw; |
1258 | |
1259 | pr_debug("%s: %s\n" , __func__, fw_name); |
1260 | |
1261 | ret = request_firmware(&fw, fw_name, NULL); |
1262 | if (!ret) |
1263 | kfree(objp: fw); |
1264 | |
1265 | pr_debug("%s: %s ret=%d\n" , __func__, fw_name, ret); |
1266 | |
1267 | return ret; |
1268 | } |
1269 | |
1270 | static struct fw_priv *lookup_fw_priv(const char *fw_name) |
1271 | { |
1272 | struct fw_priv *tmp; |
1273 | struct firmware_cache *fwc = &fw_cache; |
1274 | |
1275 | spin_lock(lock: &fwc->lock); |
1276 | tmp = __lookup_fw_priv(fw_name); |
1277 | spin_unlock(lock: &fwc->lock); |
1278 | |
1279 | return tmp; |
1280 | } |
1281 | |
1282 | /** |
1283 | * uncache_firmware() - remove one cached firmware image |
1284 | * @fw_name: the firmware image name |
1285 | * |
1286 | * Uncache one firmware image which has been cached successfully |
1287 | * before. |
1288 | * |
1289 | * Return 0 if the firmware cache has been removed successfully |
1290 | * Return !0 otherwise |
1291 | * |
1292 | */ |
1293 | static int uncache_firmware(const char *fw_name) |
1294 | { |
1295 | struct fw_priv *fw_priv; |
1296 | struct firmware fw; |
1297 | |
1298 | pr_debug("%s: %s\n" , __func__, fw_name); |
1299 | |
1300 | if (firmware_request_builtin(fw: &fw, name: fw_name)) |
1301 | return 0; |
1302 | |
1303 | fw_priv = lookup_fw_priv(fw_name); |
1304 | if (fw_priv) { |
1305 | free_fw_priv(fw_priv); |
1306 | return 0; |
1307 | } |
1308 | |
1309 | return -EINVAL; |
1310 | } |
1311 | |
1312 | static struct fw_cache_entry *alloc_fw_cache_entry(const char *name) |
1313 | { |
1314 | struct fw_cache_entry *fce; |
1315 | |
1316 | fce = kzalloc(size: sizeof(*fce), GFP_ATOMIC); |
1317 | if (!fce) |
1318 | goto exit; |
1319 | |
1320 | fce->name = kstrdup_const(s: name, GFP_ATOMIC); |
1321 | if (!fce->name) { |
1322 | kfree(objp: fce); |
1323 | fce = NULL; |
1324 | goto exit; |
1325 | } |
1326 | exit: |
1327 | return fce; |
1328 | } |
1329 | |
1330 | static int __fw_entry_found(const char *name) |
1331 | { |
1332 | struct firmware_cache *fwc = &fw_cache; |
1333 | struct fw_cache_entry *fce; |
1334 | |
1335 | list_for_each_entry(fce, &fwc->fw_names, list) { |
1336 | if (!strcmp(fce->name, name)) |
1337 | return 1; |
1338 | } |
1339 | return 0; |
1340 | } |
1341 | |
1342 | static void fw_cache_piggyback_on_request(struct fw_priv *fw_priv) |
1343 | { |
1344 | const char *name = fw_priv->fw_name; |
1345 | struct firmware_cache *fwc = fw_priv->fwc; |
1346 | struct fw_cache_entry *fce; |
1347 | |
1348 | spin_lock(lock: &fwc->name_lock); |
1349 | if (__fw_entry_found(name)) |
1350 | goto found; |
1351 | |
1352 | fce = alloc_fw_cache_entry(name); |
1353 | if (fce) { |
1354 | list_add(new: &fce->list, head: &fwc->fw_names); |
1355 | kref_get(kref: &fw_priv->ref); |
1356 | pr_debug("%s: fw: %s\n" , __func__, name); |
1357 | } |
1358 | found: |
1359 | spin_unlock(lock: &fwc->name_lock); |
1360 | } |
1361 | |
1362 | static void free_fw_cache_entry(struct fw_cache_entry *fce) |
1363 | { |
1364 | kfree_const(x: fce->name); |
1365 | kfree(objp: fce); |
1366 | } |
1367 | |
1368 | static void __async_dev_cache_fw_image(void *fw_entry, |
1369 | async_cookie_t cookie) |
1370 | { |
1371 | struct fw_cache_entry *fce = fw_entry; |
1372 | struct firmware_cache *fwc = &fw_cache; |
1373 | int ret; |
1374 | |
1375 | ret = cache_firmware(fw_name: fce->name); |
1376 | if (ret) { |
1377 | spin_lock(lock: &fwc->name_lock); |
1378 | list_del(entry: &fce->list); |
1379 | spin_unlock(lock: &fwc->name_lock); |
1380 | |
1381 | free_fw_cache_entry(fce); |
1382 | } |
1383 | } |
1384 | |
1385 | /* called with dev->devres_lock held */ |
1386 | static void dev_create_fw_entry(struct device *dev, void *res, |
1387 | void *data) |
1388 | { |
1389 | struct fw_name_devm *fwn = res; |
1390 | const char *fw_name = fwn->name; |
1391 | struct list_head *head = data; |
1392 | struct fw_cache_entry *fce; |
1393 | |
1394 | fce = alloc_fw_cache_entry(name: fw_name); |
1395 | if (fce) |
1396 | list_add(new: &fce->list, head); |
1397 | } |
1398 | |
1399 | static int devm_name_match(struct device *dev, void *res, |
1400 | void *match_data) |
1401 | { |
1402 | struct fw_name_devm *fwn = res; |
1403 | return (fwn->magic == (unsigned long)match_data); |
1404 | } |
1405 | |
1406 | static void dev_cache_fw_image(struct device *dev, void *data) |
1407 | { |
1408 | LIST_HEAD(todo); |
1409 | struct fw_cache_entry *fce; |
1410 | struct fw_cache_entry *fce_next; |
1411 | struct firmware_cache *fwc = &fw_cache; |
1412 | |
1413 | devres_for_each_res(dev, release: fw_name_devm_release, |
1414 | match: devm_name_match, match_data: &fw_cache, |
1415 | fn: dev_create_fw_entry, data: &todo); |
1416 | |
1417 | list_for_each_entry_safe(fce, fce_next, &todo, list) { |
1418 | list_del(entry: &fce->list); |
1419 | |
1420 | spin_lock(lock: &fwc->name_lock); |
1421 | /* only one cache entry for one firmware */ |
1422 | if (!__fw_entry_found(name: fce->name)) { |
1423 | list_add(new: &fce->list, head: &fwc->fw_names); |
1424 | } else { |
1425 | free_fw_cache_entry(fce); |
1426 | fce = NULL; |
1427 | } |
1428 | spin_unlock(lock: &fwc->name_lock); |
1429 | |
1430 | if (fce) |
1431 | async_schedule_domain(func: __async_dev_cache_fw_image, |
1432 | data: (void *)fce, |
1433 | domain: &fw_cache_domain); |
1434 | } |
1435 | } |
1436 | |
1437 | static void __device_uncache_fw_images(void) |
1438 | { |
1439 | struct firmware_cache *fwc = &fw_cache; |
1440 | struct fw_cache_entry *fce; |
1441 | |
1442 | spin_lock(lock: &fwc->name_lock); |
1443 | while (!list_empty(head: &fwc->fw_names)) { |
1444 | fce = list_entry(fwc->fw_names.next, |
1445 | struct fw_cache_entry, list); |
1446 | list_del(entry: &fce->list); |
1447 | spin_unlock(lock: &fwc->name_lock); |
1448 | |
1449 | uncache_firmware(fw_name: fce->name); |
1450 | free_fw_cache_entry(fce); |
1451 | |
1452 | spin_lock(lock: &fwc->name_lock); |
1453 | } |
1454 | spin_unlock(lock: &fwc->name_lock); |
1455 | } |
1456 | |
1457 | /** |
1458 | * device_cache_fw_images() - cache devices' firmware |
1459 | * |
1460 | * If one device called request_firmware or its nowait version |
1461 | * successfully before, the firmware names are recored into the |
1462 | * device's devres link list, so device_cache_fw_images can call |
1463 | * cache_firmware() to cache these firmwares for the device, |
1464 | * then the device driver can load its firmwares easily at |
1465 | * time when system is not ready to complete loading firmware. |
1466 | */ |
1467 | static void device_cache_fw_images(void) |
1468 | { |
1469 | struct firmware_cache *fwc = &fw_cache; |
1470 | DEFINE_WAIT(wait); |
1471 | |
1472 | pr_debug("%s\n" , __func__); |
1473 | |
1474 | /* cancel uncache work */ |
1475 | cancel_delayed_work_sync(dwork: &fwc->work); |
1476 | |
1477 | fw_fallback_set_cache_timeout(); |
1478 | |
1479 | mutex_lock(&fw_lock); |
1480 | fwc->state = FW_LOADER_START_CACHE; |
1481 | dpm_for_each_dev(NULL, fn: dev_cache_fw_image); |
1482 | mutex_unlock(lock: &fw_lock); |
1483 | |
1484 | /* wait for completion of caching firmware for all devices */ |
1485 | async_synchronize_full_domain(domain: &fw_cache_domain); |
1486 | |
1487 | fw_fallback_set_default_timeout(); |
1488 | } |
1489 | |
1490 | /** |
1491 | * device_uncache_fw_images() - uncache devices' firmware |
1492 | * |
1493 | * uncache all firmwares which have been cached successfully |
1494 | * by device_uncache_fw_images earlier |
1495 | */ |
1496 | static void device_uncache_fw_images(void) |
1497 | { |
1498 | pr_debug("%s\n" , __func__); |
1499 | __device_uncache_fw_images(); |
1500 | } |
1501 | |
1502 | static void device_uncache_fw_images_work(struct work_struct *work) |
1503 | { |
1504 | device_uncache_fw_images(); |
1505 | } |
1506 | |
1507 | /** |
1508 | * device_uncache_fw_images_delay() - uncache devices firmwares |
1509 | * @delay: number of milliseconds to delay uncache device firmwares |
1510 | * |
1511 | * uncache all devices's firmwares which has been cached successfully |
1512 | * by device_cache_fw_images after @delay milliseconds. |
1513 | */ |
1514 | static void device_uncache_fw_images_delay(unsigned long delay) |
1515 | { |
1516 | queue_delayed_work(wq: system_power_efficient_wq, dwork: &fw_cache.work, |
1517 | delay: msecs_to_jiffies(m: delay)); |
1518 | } |
1519 | |
1520 | static int fw_pm_notify(struct notifier_block *notify_block, |
1521 | unsigned long mode, void *unused) |
1522 | { |
1523 | switch (mode) { |
1524 | case PM_HIBERNATION_PREPARE: |
1525 | case PM_SUSPEND_PREPARE: |
1526 | case PM_RESTORE_PREPARE: |
1527 | /* |
1528 | * Here, kill pending fallback requests will only kill |
1529 | * non-uevent firmware request to avoid stalling suspend. |
1530 | */ |
1531 | kill_pending_fw_fallback_reqs(kill_all: false); |
1532 | device_cache_fw_images(); |
1533 | break; |
1534 | |
1535 | case PM_POST_SUSPEND: |
1536 | case PM_POST_HIBERNATION: |
1537 | case PM_POST_RESTORE: |
1538 | /* |
1539 | * In case that system sleep failed and syscore_suspend is |
1540 | * not called. |
1541 | */ |
1542 | mutex_lock(&fw_lock); |
1543 | fw_cache.state = FW_LOADER_NO_CACHE; |
1544 | mutex_unlock(lock: &fw_lock); |
1545 | |
1546 | device_uncache_fw_images_delay(delay: 10 * MSEC_PER_SEC); |
1547 | break; |
1548 | } |
1549 | |
1550 | return 0; |
1551 | } |
1552 | |
1553 | /* stop caching firmware once syscore_suspend is reached */ |
1554 | static int fw_suspend(void) |
1555 | { |
1556 | fw_cache.state = FW_LOADER_NO_CACHE; |
1557 | return 0; |
1558 | } |
1559 | |
1560 | static struct syscore_ops fw_syscore_ops = { |
1561 | .suspend = fw_suspend, |
1562 | }; |
1563 | |
1564 | static int __init register_fw_pm_ops(void) |
1565 | { |
1566 | int ret; |
1567 | |
1568 | spin_lock_init(&fw_cache.name_lock); |
1569 | INIT_LIST_HEAD(list: &fw_cache.fw_names); |
1570 | |
1571 | INIT_DELAYED_WORK(&fw_cache.work, |
1572 | device_uncache_fw_images_work); |
1573 | |
1574 | fw_cache.pm_notify.notifier_call = fw_pm_notify; |
1575 | ret = register_pm_notifier(nb: &fw_cache.pm_notify); |
1576 | if (ret) |
1577 | return ret; |
1578 | |
1579 | register_syscore_ops(ops: &fw_syscore_ops); |
1580 | |
1581 | return ret; |
1582 | } |
1583 | |
1584 | static inline void unregister_fw_pm_ops(void) |
1585 | { |
1586 | unregister_syscore_ops(ops: &fw_syscore_ops); |
1587 | unregister_pm_notifier(nb: &fw_cache.pm_notify); |
1588 | } |
1589 | #else |
1590 | static void fw_cache_piggyback_on_request(struct fw_priv *fw_priv) |
1591 | { |
1592 | } |
1593 | static inline int register_fw_pm_ops(void) |
1594 | { |
1595 | return 0; |
1596 | } |
1597 | static inline void unregister_fw_pm_ops(void) |
1598 | { |
1599 | } |
1600 | #endif |
1601 | |
1602 | static void __init fw_cache_init(void) |
1603 | { |
1604 | spin_lock_init(&fw_cache.lock); |
1605 | INIT_LIST_HEAD(list: &fw_cache.head); |
1606 | fw_cache.state = FW_LOADER_NO_CACHE; |
1607 | } |
1608 | |
1609 | static int fw_shutdown_notify(struct notifier_block *unused1, |
1610 | unsigned long unused2, void *unused3) |
1611 | { |
1612 | /* |
1613 | * Kill all pending fallback requests to avoid both stalling shutdown, |
1614 | * and avoid a deadlock with the usermode_lock. |
1615 | */ |
1616 | kill_pending_fw_fallback_reqs(kill_all: true); |
1617 | |
1618 | return NOTIFY_DONE; |
1619 | } |
1620 | |
1621 | static struct notifier_block fw_shutdown_nb = { |
1622 | .notifier_call = fw_shutdown_notify, |
1623 | }; |
1624 | |
1625 | static int __init firmware_class_init(void) |
1626 | { |
1627 | int ret; |
1628 | |
1629 | /* No need to unfold these on exit */ |
1630 | fw_cache_init(); |
1631 | |
1632 | ret = register_fw_pm_ops(); |
1633 | if (ret) |
1634 | return ret; |
1635 | |
1636 | ret = register_reboot_notifier(&fw_shutdown_nb); |
1637 | if (ret) |
1638 | goto out; |
1639 | |
1640 | return register_sysfs_loader(); |
1641 | |
1642 | out: |
1643 | unregister_fw_pm_ops(); |
1644 | return ret; |
1645 | } |
1646 | |
1647 | static void __exit firmware_class_exit(void) |
1648 | { |
1649 | unregister_fw_pm_ops(); |
1650 | unregister_reboot_notifier(&fw_shutdown_nb); |
1651 | unregister_sysfs_loader(); |
1652 | } |
1653 | |
1654 | fs_initcall(firmware_class_init); |
1655 | module_exit(firmware_class_exit); |
1656 | |