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