2 * firmware_class.c - Multi purpose firmware loading support
4 * Copyright (c) 2003 Manuel Estrada Sainz
6 * Please see Documentation/firmware_class/ for more information.
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/kthread.h>
20 #include <linux/highmem.h>
21 #include <linux/firmware.h>
22 #include <linux/slab.h>
24 #define to_dev(obj) container_of(obj, struct device, kobj)
26 MODULE_AUTHOR("Manuel Estrada Sainz");
27 MODULE_DESCRIPTION("Multi purpose firmware loading support");
28 MODULE_LICENSE("GPL");
30 /* Builtin firmware support */
32 #ifdef CONFIG_FW_LOADER
34 extern struct builtin_fw __start_builtin_fw
[];
35 extern struct builtin_fw __end_builtin_fw
[];
37 static bool fw_get_builtin_firmware(struct firmware
*fw
, const char *name
)
39 struct builtin_fw
*b_fw
;
41 for (b_fw
= __start_builtin_fw
; b_fw
!= __end_builtin_fw
; b_fw
++) {
42 if (strcmp(name
, b_fw
->name
) == 0) {
43 fw
->size
= b_fw
->size
;
44 fw
->data
= b_fw
->data
;
52 static bool fw_is_builtin_firmware(const struct firmware
*fw
)
54 struct builtin_fw
*b_fw
;
56 for (b_fw
= __start_builtin_fw
; b_fw
!= __end_builtin_fw
; b_fw
++)
57 if (fw
->data
== b_fw
->data
)
63 #else /* Module case - no builtin firmware support */
65 static inline bool fw_get_builtin_firmware(struct firmware
*fw
, const char *name
)
70 static inline bool fw_is_builtin_firmware(const struct firmware
*fw
)
82 static int loading_timeout
= 60; /* In seconds */
84 /* fw_lock could be moved to 'struct firmware_priv' but since it is just
85 * guarding for corner cases a global lock should be OK */
86 static DEFINE_MUTEX(fw_lock
);
88 struct firmware_priv
{
89 struct completion completion
;
95 struct timer_list timeout
;
101 static struct firmware_priv
*to_firmware_priv(struct device
*dev
)
103 return container_of(dev
, struct firmware_priv
, dev
);
106 static void fw_load_abort(struct firmware_priv
*fw_priv
)
108 set_bit(FW_STATUS_ABORT
, &fw_priv
->status
);
110 complete(&fw_priv
->completion
);
113 static ssize_t
firmware_timeout_show(struct class *class,
114 struct class_attribute
*attr
,
117 return sprintf(buf
, "%d\n", loading_timeout
);
121 * firmware_timeout_store - set number of seconds to wait for firmware
122 * @class: device class pointer
123 * @attr: device attribute pointer
124 * @buf: buffer to scan for timeout value
125 * @count: number of bytes in @buf
127 * Sets the number of seconds to wait for the firmware. Once
128 * this expires an error will be returned to the driver and no
129 * firmware will be provided.
131 * Note: zero means 'wait forever'.
133 static ssize_t
firmware_timeout_store(struct class *class,
134 struct class_attribute
*attr
,
135 const char *buf
, size_t count
)
137 loading_timeout
= simple_strtol(buf
, NULL
, 10);
138 if (loading_timeout
< 0)
144 static struct class_attribute firmware_class_attrs
[] = {
145 __ATTR(timeout
, S_IWUSR
| S_IRUGO
,
146 firmware_timeout_show
, firmware_timeout_store
),
150 static void fw_dev_release(struct device
*dev
)
152 struct firmware_priv
*fw_priv
= to_firmware_priv(dev
);
155 for (i
= 0; i
< fw_priv
->nr_pages
; i
++)
156 __free_page(fw_priv
->pages
[i
]);
157 kfree(fw_priv
->pages
);
160 module_put(THIS_MODULE
);
163 static int firmware_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
165 struct firmware_priv
*fw_priv
= to_firmware_priv(dev
);
167 if (add_uevent_var(env
, "FIRMWARE=%s", fw_priv
->fw_id
))
169 if (add_uevent_var(env
, "TIMEOUT=%i", loading_timeout
))
171 if (add_uevent_var(env
, "ASYNC=%d", fw_priv
->nowait
))
177 static struct class firmware_class
= {
179 .class_attrs
= firmware_class_attrs
,
180 .dev_uevent
= firmware_uevent
,
181 .dev_release
= fw_dev_release
,
184 static ssize_t
firmware_loading_show(struct device
*dev
,
185 struct device_attribute
*attr
, char *buf
)
187 struct firmware_priv
*fw_priv
= to_firmware_priv(dev
);
188 int loading
= test_bit(FW_STATUS_LOADING
, &fw_priv
->status
);
190 return sprintf(buf
, "%d\n", loading
);
193 static void firmware_free_data(const struct firmware
*fw
)
198 for (i
= 0; i
< PFN_UP(fw
->size
); i
++)
199 __free_page(fw
->pages
[i
]);
204 /* Some architectures don't have PAGE_KERNEL_RO */
205 #ifndef PAGE_KERNEL_RO
206 #define PAGE_KERNEL_RO PAGE_KERNEL
209 * firmware_loading_store - set value in the 'loading' control file
210 * @dev: device pointer
211 * @attr: device attribute pointer
212 * @buf: buffer to scan for loading control value
213 * @count: number of bytes in @buf
215 * The relevant values are:
217 * 1: Start a load, discarding any previous partial load.
218 * 0: Conclude the load and hand the data to the driver code.
219 * -1: Conclude the load with an error and discard any written data.
221 static ssize_t
firmware_loading_store(struct device
*dev
,
222 struct device_attribute
*attr
,
223 const char *buf
, size_t count
)
225 struct firmware_priv
*fw_priv
= to_firmware_priv(dev
);
226 int loading
= simple_strtol(buf
, NULL
, 10);
231 mutex_lock(&fw_lock
);
233 mutex_unlock(&fw_lock
);
236 firmware_free_data(fw_priv
->fw
);
237 memset(fw_priv
->fw
, 0, sizeof(struct firmware
));
238 /* If the pages are not owned by 'struct firmware' */
239 for (i
= 0; i
< fw_priv
->nr_pages
; i
++)
240 __free_page(fw_priv
->pages
[i
]);
241 kfree(fw_priv
->pages
);
242 fw_priv
->pages
= NULL
;
243 fw_priv
->page_array_size
= 0;
244 fw_priv
->nr_pages
= 0;
245 set_bit(FW_STATUS_LOADING
, &fw_priv
->status
);
246 mutex_unlock(&fw_lock
);
249 if (test_bit(FW_STATUS_LOADING
, &fw_priv
->status
)) {
250 vunmap(fw_priv
->fw
->data
);
251 fw_priv
->fw
->data
= vmap(fw_priv
->pages
,
254 if (!fw_priv
->fw
->data
) {
255 dev_err(dev
, "%s: vmap() failed\n", __func__
);
258 /* Pages are now owned by 'struct firmware' */
259 fw_priv
->fw
->pages
= fw_priv
->pages
;
260 fw_priv
->pages
= NULL
;
262 fw_priv
->page_array_size
= 0;
263 fw_priv
->nr_pages
= 0;
264 complete(&fw_priv
->completion
);
265 clear_bit(FW_STATUS_LOADING
, &fw_priv
->status
);
270 dev_err(dev
, "%s: unexpected value (%d)\n", __func__
, loading
);
274 fw_load_abort(fw_priv
);
281 static DEVICE_ATTR(loading
, 0644, firmware_loading_show
, firmware_loading_store
);
283 static ssize_t
firmware_data_read(struct file
*filp
, struct kobject
*kobj
,
284 struct bin_attribute
*bin_attr
,
285 char *buffer
, loff_t offset
, size_t count
)
287 struct device
*dev
= to_dev(kobj
);
288 struct firmware_priv
*fw_priv
= to_firmware_priv(dev
);
292 mutex_lock(&fw_lock
);
294 if (!fw
|| test_bit(FW_STATUS_DONE
, &fw_priv
->status
)) {
298 if (offset
> fw
->size
) {
302 if (count
> fw
->size
- offset
)
303 count
= fw
->size
- offset
;
309 int page_nr
= offset
>> PAGE_SHIFT
;
310 int page_ofs
= offset
& (PAGE_SIZE
-1);
311 int page_cnt
= min_t(size_t, PAGE_SIZE
- page_ofs
, count
);
313 page_data
= kmap(fw_priv
->pages
[page_nr
]);
315 memcpy(buffer
, page_data
+ page_ofs
, page_cnt
);
317 kunmap(fw_priv
->pages
[page_nr
]);
323 mutex_unlock(&fw_lock
);
327 static int fw_realloc_buffer(struct firmware_priv
*fw_priv
, int min_size
)
329 int pages_needed
= ALIGN(min_size
, PAGE_SIZE
) >> PAGE_SHIFT
;
331 /* If the array of pages is too small, grow it... */
332 if (fw_priv
->page_array_size
< pages_needed
) {
333 int new_array_size
= max(pages_needed
,
334 fw_priv
->page_array_size
* 2);
335 struct page
**new_pages
;
337 new_pages
= kmalloc(new_array_size
* sizeof(void *),
340 fw_load_abort(fw_priv
);
343 memcpy(new_pages
, fw_priv
->pages
,
344 fw_priv
->page_array_size
* sizeof(void *));
345 memset(&new_pages
[fw_priv
->page_array_size
], 0, sizeof(void *) *
346 (new_array_size
- fw_priv
->page_array_size
));
347 kfree(fw_priv
->pages
);
348 fw_priv
->pages
= new_pages
;
349 fw_priv
->page_array_size
= new_array_size
;
352 while (fw_priv
->nr_pages
< pages_needed
) {
353 fw_priv
->pages
[fw_priv
->nr_pages
] =
354 alloc_page(GFP_KERNEL
| __GFP_HIGHMEM
);
356 if (!fw_priv
->pages
[fw_priv
->nr_pages
]) {
357 fw_load_abort(fw_priv
);
366 * firmware_data_write - write method for firmware
367 * @filp: open sysfs file
368 * @kobj: kobject for the device
369 * @bin_attr: bin_attr structure
370 * @buffer: buffer being written
371 * @offset: buffer offset for write in total data store area
372 * @count: buffer size
374 * Data written to the 'data' attribute will be later handed to
375 * the driver as a firmware image.
377 static ssize_t
firmware_data_write(struct file
*filp
, struct kobject
*kobj
,
378 struct bin_attribute
*bin_attr
,
379 char *buffer
, loff_t offset
, size_t count
)
381 struct device
*dev
= to_dev(kobj
);
382 struct firmware_priv
*fw_priv
= to_firmware_priv(dev
);
386 if (!capable(CAP_SYS_RAWIO
))
389 mutex_lock(&fw_lock
);
391 if (!fw
|| test_bit(FW_STATUS_DONE
, &fw_priv
->status
)) {
395 retval
= fw_realloc_buffer(fw_priv
, offset
+ count
);
403 int page_nr
= offset
>> PAGE_SHIFT
;
404 int page_ofs
= offset
& (PAGE_SIZE
- 1);
405 int page_cnt
= min_t(size_t, PAGE_SIZE
- page_ofs
, count
);
407 page_data
= kmap(fw_priv
->pages
[page_nr
]);
409 memcpy(page_data
+ page_ofs
, buffer
, page_cnt
);
411 kunmap(fw_priv
->pages
[page_nr
]);
417 fw
->size
= max_t(size_t, offset
, fw
->size
);
419 mutex_unlock(&fw_lock
);
423 static struct bin_attribute firmware_attr_data
= {
424 .attr
= { .name
= "data", .mode
= 0644 },
426 .read
= firmware_data_read
,
427 .write
= firmware_data_write
,
430 static void firmware_class_timeout(u_long data
)
432 struct firmware_priv
*fw_priv
= (struct firmware_priv
*) data
;
434 fw_load_abort(fw_priv
);
437 static struct firmware_priv
*
438 fw_create_instance(struct firmware
*firmware
, const char *fw_name
,
439 struct device
*device
, bool uevent
, bool nowait
)
441 struct firmware_priv
*fw_priv
;
442 struct device
*f_dev
;
445 fw_priv
= kzalloc(sizeof(*fw_priv
) + strlen(fw_name
) + 1 , GFP_KERNEL
);
447 dev_err(device
, "%s: kmalloc failed\n", __func__
);
452 fw_priv
->fw
= firmware
;
453 fw_priv
->nowait
= nowait
;
454 strcpy(fw_priv
->fw_id
, fw_name
);
455 init_completion(&fw_priv
->completion
);
456 setup_timer(&fw_priv
->timeout
,
457 firmware_class_timeout
, (u_long
) fw_priv
);
459 f_dev
= &fw_priv
->dev
;
461 device_initialize(f_dev
);
462 dev_set_name(f_dev
, "%s", dev_name(device
));
463 f_dev
->parent
= device
;
464 f_dev
->class = &firmware_class
;
466 dev_set_uevent_suppress(f_dev
, true);
468 /* Need to pin this module until class device is destroyed */
469 __module_get(THIS_MODULE
);
471 error
= device_add(f_dev
);
473 dev_err(device
, "%s: device_register failed\n", __func__
);
477 error
= device_create_bin_file(f_dev
, &firmware_attr_data
);
479 dev_err(device
, "%s: sysfs_create_bin_file failed\n", __func__
);
483 error
= device_create_file(f_dev
, &dev_attr_loading
);
485 dev_err(device
, "%s: device_create_file failed\n", __func__
);
486 goto err_del_bin_attr
;
490 dev_set_uevent_suppress(f_dev
, false);
495 device_remove_bin_file(f_dev
, &firmware_attr_data
);
501 return ERR_PTR(error
);
504 static void fw_destroy_instance(struct firmware_priv
*fw_priv
)
506 struct device
*f_dev
= &fw_priv
->dev
;
508 device_remove_file(f_dev
, &dev_attr_loading
);
509 device_remove_bin_file(f_dev
, &firmware_attr_data
);
510 device_unregister(f_dev
);
513 static int _request_firmware(const struct firmware
**firmware_p
,
514 const char *name
, struct device
*device
,
515 bool uevent
, bool nowait
)
517 struct firmware_priv
*fw_priv
;
518 struct firmware
*firmware
;
524 *firmware_p
= firmware
= kzalloc(sizeof(*firmware
), GFP_KERNEL
);
526 dev_err(device
, "%s: kmalloc(struct firmware) failed\n",
532 if (fw_get_builtin_firmware(firmware
, name
)) {
533 dev_dbg(device
, "firmware: using built-in firmware %s\n", name
);
538 dev_dbg(device
, "firmware: requesting %s\n", name
);
540 fw_priv
= fw_create_instance(firmware
, name
, device
, uevent
, nowait
);
541 if (IS_ERR(fw_priv
)) {
542 retval
= PTR_ERR(fw_priv
);
547 if (loading_timeout
> 0)
548 mod_timer(&fw_priv
->timeout
,
549 round_jiffies_up(jiffies
+
550 loading_timeout
* HZ
));
552 kobject_uevent(&fw_priv
->dev
.kobj
, KOBJ_ADD
);
555 wait_for_completion(&fw_priv
->completion
);
557 set_bit(FW_STATUS_DONE
, &fw_priv
->status
);
558 del_timer_sync(&fw_priv
->timeout
);
560 mutex_lock(&fw_lock
);
561 if (!fw_priv
->fw
->size
|| test_bit(FW_STATUS_ABORT
, &fw_priv
->status
))
564 mutex_unlock(&fw_lock
);
566 fw_destroy_instance(fw_priv
);
570 release_firmware(firmware
);
578 * request_firmware: - send firmware request and wait for it
579 * @firmware_p: pointer to firmware image
580 * @name: name of firmware file
581 * @device: device for which firmware is being loaded
583 * @firmware_p will be used to return a firmware image by the name
584 * of @name for device @device.
586 * Should be called from user context where sleeping is allowed.
588 * @name will be used as $FIRMWARE in the uevent environment and
589 * should be distinctive enough not to be confused with any other
590 * firmware image for this or any other device.
593 request_firmware(const struct firmware
**firmware_p
, const char *name
,
594 struct device
*device
)
596 return _request_firmware(firmware_p
, name
, device
, true, false);
600 * release_firmware: - release the resource associated with a firmware image
601 * @fw: firmware resource to release
603 void release_firmware(const struct firmware
*fw
)
606 if (!fw_is_builtin_firmware(fw
))
607 firmware_free_data(fw
);
613 struct firmware_work
{
614 struct work_struct work
;
615 struct module
*module
;
617 struct device
*device
;
619 void (*cont
)(const struct firmware
*fw
, void *context
);
623 static int request_firmware_work_func(void *arg
)
625 struct firmware_work
*fw_work
= arg
;
626 const struct firmware
*fw
;
634 ret
= _request_firmware(&fw
, fw_work
->name
, fw_work
->device
,
635 fw_work
->uevent
, true);
636 fw_work
->cont(fw
, fw_work
->context
);
638 module_put(fw_work
->module
);
645 * request_firmware_nowait - asynchronous version of request_firmware
646 * @module: module requesting the firmware
647 * @uevent: sends uevent to copy the firmware image if this flag
648 * is non-zero else the firmware copy must be done manually.
649 * @name: name of firmware file
650 * @device: device for which firmware is being loaded
651 * @gfp: allocation flags
652 * @context: will be passed over to @cont, and
653 * @fw may be %NULL if firmware request fails.
654 * @cont: function will be called asynchronously when the firmware
657 * Asynchronous variant of request_firmware() for user contexts where
658 * it is not possible to sleep for long time. It can't be called
659 * in atomic contexts.
662 request_firmware_nowait(
663 struct module
*module
, bool uevent
,
664 const char *name
, struct device
*device
, gfp_t gfp
, void *context
,
665 void (*cont
)(const struct firmware
*fw
, void *context
))
667 struct task_struct
*task
;
668 struct firmware_work
*fw_work
;
670 fw_work
= kzalloc(sizeof (struct firmware_work
), gfp
);
674 fw_work
->module
= module
;
675 fw_work
->name
= name
;
676 fw_work
->device
= device
;
677 fw_work
->context
= context
;
678 fw_work
->cont
= cont
;
679 fw_work
->uevent
= uevent
;
681 if (!try_module_get(module
)) {
686 task
= kthread_run(request_firmware_work_func
, fw_work
,
687 "firmware/%s", name
);
689 fw_work
->cont(NULL
, fw_work
->context
);
690 module_put(fw_work
->module
);
692 return PTR_ERR(task
);
698 static int __init
firmware_class_init(void)
700 return class_register(&firmware_class
);
703 static void __exit
firmware_class_exit(void)
705 class_unregister(&firmware_class
);
708 fs_initcall(firmware_class_init
);
709 module_exit(firmware_class_exit
);
711 EXPORT_SYMBOL(release_firmware
);
712 EXPORT_SYMBOL(request_firmware
);
713 EXPORT_SYMBOL(request_firmware_nowait
);