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