blob: 40af43ebd92d355e5b96092d0f4b4ac0a3fd05ea [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * firmware_class.c - Multi purpose firmware loading support
3 *
Markus Rechberger87d37a42007-06-04 18:45:44 +02004 * Copyright (c) 2003 Manuel Estrada Sainz
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 *
6 * Please see Documentation/firmware_class/ for more information.
7 *
8 */
9
Randy.Dunlapc59ede72006-01-11 12:17:46 -080010#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#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>
Laura Garciacad1e552006-05-23 23:22:38 +020018#include <linux/mutex.h>
Sukadev Bhattiprolu563d0752006-09-29 01:59:31 -070019#include <linux/kthread.h>
David Woodhouse6e03a202009-04-09 22:04:07 -070020#include <linux/highmem.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <linux/firmware.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090022#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023
Greg Kroah-Hartmane55c8792006-09-14 07:30:59 -070024#define to_dev(obj) container_of(obj, struct device, kobj)
25
Markus Rechberger87d37a42007-06-04 18:45:44 +020026MODULE_AUTHOR("Manuel Estrada Sainz");
Linus Torvalds1da177e2005-04-16 15:20:36 -070027MODULE_DESCRIPTION("Multi purpose firmware loading support");
28MODULE_LICENSE("GPL");
29
Dmitry Torokhovbcb9bd12010-03-13 23:49:18 -080030/* Builtin firmware support */
31
32#ifdef CONFIG_FW_LOADER
33
34extern struct builtin_fw __start_builtin_fw[];
35extern struct builtin_fw __end_builtin_fw[];
36
37static bool fw_get_builtin_firmware(struct firmware *fw, const char *name)
38{
39 struct builtin_fw *b_fw;
40
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;
45 return true;
46 }
47 }
48
49 return false;
50}
51
52static bool fw_is_builtin_firmware(const struct firmware *fw)
53{
54 struct builtin_fw *b_fw;
55
56 for (b_fw = __start_builtin_fw; b_fw != __end_builtin_fw; b_fw++)
57 if (fw->data == b_fw->data)
58 return true;
59
60 return false;
61}
62
63#else /* Module case - no builtin firmware support */
64
65static inline bool fw_get_builtin_firmware(struct firmware *fw, const char *name)
66{
67 return false;
68}
69
70static inline bool fw_is_builtin_firmware(const struct firmware *fw)
71{
72 return false;
73}
74#endif
75
Linus Torvalds1da177e2005-04-16 15:20:36 -070076enum {
77 FW_STATUS_LOADING,
78 FW_STATUS_DONE,
79 FW_STATUS_ABORT,
Linus Torvalds1da177e2005-04-16 15:20:36 -070080};
81
Dave Jones2f651682007-01-25 15:56:15 -050082static int loading_timeout = 60; /* In seconds */
Linus Torvalds1da177e2005-04-16 15:20:36 -070083
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 */
Laura Garciacad1e552006-05-23 23:22:38 +020086static DEFINE_MUTEX(fw_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070087
88struct firmware_priv {
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 struct completion completion;
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 struct firmware *fw;
91 unsigned long status;
David Woodhouse6e03a202009-04-09 22:04:07 -070092 struct page **pages;
93 int nr_pages;
94 int page_array_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 struct timer_list timeout;
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -070096 struct device dev;
Johannes Berge9045f92010-03-29 17:57:20 +020097 bool nowait;
Dmitry Torokhove1771232010-03-13 23:49:23 -080098 char fw_id[];
Linus Torvalds1da177e2005-04-16 15:20:36 -070099};
100
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700101static struct firmware_priv *to_firmware_priv(struct device *dev)
102{
103 return container_of(dev, struct firmware_priv, dev);
104}
105
106static void fw_load_abort(struct firmware_priv *fw_priv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107{
108 set_bit(FW_STATUS_ABORT, &fw_priv->status);
109 wmb();
110 complete(&fw_priv->completion);
111}
112
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700113static ssize_t firmware_timeout_show(struct class *class,
114 struct class_attribute *attr,
115 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116{
117 return sprintf(buf, "%d\n", loading_timeout);
118}
119
120/**
Randy Dunlapeb8e3172005-10-30 15:03:01 -0800121 * firmware_timeout_store - set number of seconds to wait for firmware
122 * @class: device class pointer
Randy Dunlape59817b2010-03-10 11:47:58 -0800123 * @attr: device attribute pointer
Randy Dunlapeb8e3172005-10-30 15:03:01 -0800124 * @buf: buffer to scan for timeout value
125 * @count: number of bytes in @buf
126 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 * Sets the number of seconds to wait for the firmware. Once
Randy Dunlapeb8e3172005-10-30 15:03:01 -0800128 * this expires an error will be returned to the driver and no
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 * firmware will be provided.
130 *
Randy Dunlapeb8e3172005-10-30 15:03:01 -0800131 * Note: zero means 'wait forever'.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 **/
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700133static ssize_t firmware_timeout_store(struct class *class,
134 struct class_attribute *attr,
135 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136{
137 loading_timeout = simple_strtol(buf, NULL, 10);
Stanislaw W. Gruszkab92eac02005-06-28 20:44:51 -0700138 if (loading_timeout < 0)
139 loading_timeout = 0;
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700140
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 return count;
142}
143
Dmitry Torokhov673fae92010-03-13 23:49:13 -0800144static struct class_attribute firmware_class_attrs[] = {
145 __ATTR(timeout, S_IWUSR | S_IRUGO,
146 firmware_timeout_show, firmware_timeout_store),
147 __ATTR_NULL
148};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149
Dmitry Torokhov673fae92010-03-13 23:49:13 -0800150static void fw_dev_release(struct device *dev)
151{
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700152 struct firmware_priv *fw_priv = to_firmware_priv(dev);
Dmitry Torokhov673fae92010-03-13 23:49:13 -0800153 int i;
154
155 for (i = 0; i < fw_priv->nr_pages; i++)
156 __free_page(fw_priv->pages[i]);
157 kfree(fw_priv->pages);
Dmitry Torokhov673fae92010-03-13 23:49:13 -0800158 kfree(fw_priv);
Dmitry Torokhov673fae92010-03-13 23:49:13 -0800159
160 module_put(THIS_MODULE);
161}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162
Kay Sievers7eff2e72007-08-14 15:15:12 +0200163static int firmware_uevent(struct device *dev, struct kobj_uevent_env *env)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164{
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700165 struct firmware_priv *fw_priv = to_firmware_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166
Kay Sievers7eff2e72007-08-14 15:15:12 +0200167 if (add_uevent_var(env, "FIRMWARE=%s", fw_priv->fw_id))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 return -ENOMEM;
Kay Sievers7eff2e72007-08-14 15:15:12 +0200169 if (add_uevent_var(env, "TIMEOUT=%i", loading_timeout))
kay.sievers@vrfy.org68970892005-04-18 21:57:31 -0700170 return -ENOMEM;
Johannes Berge9045f92010-03-29 17:57:20 +0200171 if (add_uevent_var(env, "ASYNC=%d", fw_priv->nowait))
172 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173
174 return 0;
175}
176
Adrian Bunk1b81d662006-05-20 15:00:16 -0700177static struct class firmware_class = {
178 .name = "firmware",
Dmitry Torokhov673fae92010-03-13 23:49:13 -0800179 .class_attrs = firmware_class_attrs,
Greg Kroah-Hartmane55c8792006-09-14 07:30:59 -0700180 .dev_uevent = firmware_uevent,
181 .dev_release = fw_dev_release,
Adrian Bunk1b81d662006-05-20 15:00:16 -0700182};
183
Greg Kroah-Hartmane55c8792006-09-14 07:30:59 -0700184static ssize_t firmware_loading_show(struct device *dev,
185 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186{
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700187 struct firmware_priv *fw_priv = to_firmware_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 int loading = test_bit(FW_STATUS_LOADING, &fw_priv->status);
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700189
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 return sprintf(buf, "%d\n", loading);
191}
192
David Woodhousedd336c52010-05-02 11:21:21 +0300193static void firmware_free_data(const struct firmware *fw)
194{
195 int i;
196 vunmap(fw->data);
197 if (fw->pages) {
198 for (i = 0; i < PFN_UP(fw->size); i++)
199 __free_page(fw->pages[i]);
200 kfree(fw->pages);
201 }
202}
203
David Woodhouse6e03a202009-04-09 22:04:07 -0700204/* Some architectures don't have PAGE_KERNEL_RO */
205#ifndef PAGE_KERNEL_RO
206#define PAGE_KERNEL_RO PAGE_KERNEL
207#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208/**
Randy Dunlapeb8e3172005-10-30 15:03:01 -0800209 * firmware_loading_store - set value in the 'loading' control file
Greg Kroah-Hartmane55c8792006-09-14 07:30:59 -0700210 * @dev: device pointer
Randy Dunlapaf9997e2006-12-22 01:06:52 -0800211 * @attr: device attribute pointer
Randy Dunlapeb8e3172005-10-30 15:03:01 -0800212 * @buf: buffer to scan for loading control value
213 * @count: number of bytes in @buf
214 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 * The relevant values are:
216 *
217 * 1: Start a load, discarding any previous partial load.
Randy Dunlapeb8e3172005-10-30 15:03:01 -0800218 * 0: Conclude the load and hand the data to the driver code.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 * -1: Conclude the load with an error and discard any written data.
220 **/
Greg Kroah-Hartmane55c8792006-09-14 07:30:59 -0700221static ssize_t firmware_loading_store(struct device *dev,
222 struct device_attribute *attr,
223 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224{
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700225 struct firmware_priv *fw_priv = to_firmware_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 int loading = simple_strtol(buf, NULL, 10);
David Woodhouse6e03a202009-04-09 22:04:07 -0700227 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228
229 switch (loading) {
230 case 1:
Laura Garciacad1e552006-05-23 23:22:38 +0200231 mutex_lock(&fw_lock);
Stanislaw W. Gruszkab92eac02005-06-28 20:44:51 -0700232 if (!fw_priv->fw) {
Laura Garciacad1e552006-05-23 23:22:38 +0200233 mutex_unlock(&fw_lock);
Stanislaw W. Gruszkab92eac02005-06-28 20:44:51 -0700234 break;
235 }
David Woodhousedd336c52010-05-02 11:21:21 +0300236 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' */
David Woodhouse6e03a202009-04-09 22:04:07 -0700239 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 set_bit(FW_STATUS_LOADING, &fw_priv->status);
Laura Garciacad1e552006-05-23 23:22:38 +0200246 mutex_unlock(&fw_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 break;
248 case 0:
249 if (test_bit(FW_STATUS_LOADING, &fw_priv->status)) {
David Woodhousedd336c52010-05-02 11:21:21 +0300250 vunmap(fw_priv->fw->data);
David Woodhouse6e03a202009-04-09 22:04:07 -0700251 fw_priv->fw->data = vmap(fw_priv->pages,
252 fw_priv->nr_pages,
253 0, PAGE_KERNEL_RO);
254 if (!fw_priv->fw->data) {
255 dev_err(dev, "%s: vmap() failed\n", __func__);
256 goto err;
257 }
David Woodhousedd336c52010-05-02 11:21:21 +0300258 /* Pages are now owned by 'struct firmware' */
259 fw_priv->fw->pages = fw_priv->pages;
260 fw_priv->pages = NULL;
261
David Woodhouse6e03a202009-04-09 22:04:07 -0700262 fw_priv->page_array_size = 0;
263 fw_priv->nr_pages = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 complete(&fw_priv->completion);
265 clear_bit(FW_STATUS_LOADING, &fw_priv->status);
266 break;
267 }
268 /* fallthrough */
269 default:
Bjorn Helgaas266a8132008-10-15 22:04:20 -0700270 dev_err(dev, "%s: unexpected value (%d)\n", __func__, loading);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 /* fallthrough */
272 case -1:
David Woodhouse6e03a202009-04-09 22:04:07 -0700273 err:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 fw_load_abort(fw_priv);
275 break;
276 }
277
278 return count;
279}
280
Greg Kroah-Hartmane55c8792006-09-14 07:30:59 -0700281static DEVICE_ATTR(loading, 0644, firmware_loading_show, firmware_loading_store);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700283static 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)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286{
Greg Kroah-Hartmane55c8792006-09-14 07:30:59 -0700287 struct device *dev = to_dev(kobj);
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700288 struct firmware_priv *fw_priv = to_firmware_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 struct firmware *fw;
Akinobu Mitaf37e6612008-07-25 01:48:23 -0700290 ssize_t ret_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291
Laura Garciacad1e552006-05-23 23:22:38 +0200292 mutex_lock(&fw_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 fw = fw_priv->fw;
Stanislaw W. Gruszkab92eac02005-06-28 20:44:51 -0700294 if (!fw || test_bit(FW_STATUS_DONE, &fw_priv->status)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 ret_count = -ENODEV;
296 goto out;
297 }
Jiri Slaby308975f2009-06-21 23:57:31 +0200298 if (offset > fw->size) {
299 ret_count = 0;
300 goto out;
301 }
David Woodhouse6e03a202009-04-09 22:04:07 -0700302 if (count > fw->size - offset)
303 count = fw->size - offset;
304
305 ret_count = count;
306
307 while (count) {
308 void *page_data;
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);
312
313 page_data = kmap(fw_priv->pages[page_nr]);
314
315 memcpy(buffer, page_data + page_ofs, page_cnt);
316
317 kunmap(fw_priv->pages[page_nr]);
318 buffer += page_cnt;
319 offset += page_cnt;
320 count -= page_cnt;
321 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322out:
Laura Garciacad1e552006-05-23 23:22:38 +0200323 mutex_unlock(&fw_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 return ret_count;
325}
Randy Dunlapeb8e3172005-10-30 15:03:01 -0800326
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700327static int fw_realloc_buffer(struct firmware_priv *fw_priv, int min_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328{
David Woodhouse6e03a202009-04-09 22:04:07 -0700329 int pages_needed = ALIGN(min_size, PAGE_SIZE) >> PAGE_SHIFT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330
David Woodhouse6e03a202009-04-09 22:04:07 -0700331 /* 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336
David Woodhouse6e03a202009-04-09 22:04:07 -0700337 new_pages = kmalloc(new_array_size * sizeof(void *),
338 GFP_KERNEL);
339 if (!new_pages) {
340 fw_load_abort(fw_priv);
341 return -ENOMEM;
342 }
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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 }
David Woodhouse6e03a202009-04-09 22:04:07 -0700351
352 while (fw_priv->nr_pages < pages_needed) {
353 fw_priv->pages[fw_priv->nr_pages] =
354 alloc_page(GFP_KERNEL | __GFP_HIGHMEM);
355
356 if (!fw_priv->pages[fw_priv->nr_pages]) {
357 fw_load_abort(fw_priv);
358 return -ENOMEM;
359 }
360 fw_priv->nr_pages++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 return 0;
363}
364
365/**
Randy Dunlapeb8e3172005-10-30 15:03:01 -0800366 * firmware_data_write - write method for firmware
Chris Wright2c3c8be2010-05-12 18:28:57 -0700367 * @filp: open sysfs file
Greg Kroah-Hartmane55c8792006-09-14 07:30:59 -0700368 * @kobj: kobject for the device
Randy Dunlap42e61f42007-07-23 21:42:11 -0700369 * @bin_attr: bin_attr structure
Randy Dunlapeb8e3172005-10-30 15:03:01 -0800370 * @buffer: buffer being written
371 * @offset: buffer offset for write in total data store area
372 * @count: buffer size
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 *
Randy Dunlapeb8e3172005-10-30 15:03:01 -0800374 * Data written to the 'data' attribute will be later handed to
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 * the driver as a firmware image.
376 **/
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700377static 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)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380{
Greg Kroah-Hartmane55c8792006-09-14 07:30:59 -0700381 struct device *dev = to_dev(kobj);
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700382 struct firmware_priv *fw_priv = to_firmware_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 struct firmware *fw;
384 ssize_t retval;
385
386 if (!capable(CAP_SYS_RAWIO))
387 return -EPERM;
Stanislaw W. Gruszkab92eac02005-06-28 20:44:51 -0700388
Laura Garciacad1e552006-05-23 23:22:38 +0200389 mutex_lock(&fw_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 fw = fw_priv->fw;
Stanislaw W. Gruszkab92eac02005-06-28 20:44:51 -0700391 if (!fw || test_bit(FW_STATUS_DONE, &fw_priv->status)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 retval = -ENODEV;
393 goto out;
394 }
395 retval = fw_realloc_buffer(fw_priv, offset + count);
396 if (retval)
397 goto out;
398
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 retval = count;
David Woodhouse6e03a202009-04-09 22:04:07 -0700400
401 while (count) {
402 void *page_data;
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);
406
407 page_data = kmap(fw_priv->pages[page_nr]);
408
409 memcpy(page_data + page_ofs, buffer, page_cnt);
410
411 kunmap(fw_priv->pages[page_nr]);
412 buffer += page_cnt;
413 offset += page_cnt;
414 count -= page_cnt;
415 }
416
417 fw->size = max_t(size_t, offset, fw->size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418out:
Laura Garciacad1e552006-05-23 23:22:38 +0200419 mutex_unlock(&fw_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 return retval;
421}
Randy Dunlapeb8e3172005-10-30 15:03:01 -0800422
Dmitry Torokhov0983ca22010-06-04 00:54:37 -0700423static struct bin_attribute firmware_attr_data = {
424 .attr = { .name = "data", .mode = 0644 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 .size = 0,
426 .read = firmware_data_read,
427 .write = firmware_data_write,
428};
429
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700430static void firmware_class_timeout(u_long data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431{
432 struct firmware_priv *fw_priv = (struct firmware_priv *) data;
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700433
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 fw_load_abort(fw_priv);
435}
436
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700437static struct firmware_priv *
438fw_create_instance(struct firmware *firmware, const char *fw_name,
439 struct device *device, bool uevent, bool nowait)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440{
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700441 struct firmware_priv *fw_priv;
442 struct device *f_dev;
443 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700445 fw_priv = kzalloc(sizeof(*fw_priv) + strlen(fw_name) + 1 , GFP_KERNEL);
446 if (!fw_priv) {
Bjorn Helgaas266a8132008-10-15 22:04:20 -0700447 dev_err(device, "%s: kmalloc failed\n", __func__);
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700448 error = -ENOMEM;
449 goto err_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700452 fw_priv->fw = firmware;
453 fw_priv->nowait = nowait;
Dmitry Torokhove1771232010-03-13 23:49:23 -0800454 strcpy(fw_priv->fw_id, fw_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 init_completion(&fw_priv->completion);
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700456 setup_timer(&fw_priv->timeout,
457 firmware_class_timeout, (u_long) fw_priv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700459 f_dev = &fw_priv->dev;
460
461 device_initialize(f_dev);
Greg Kroah-Hartmanacc0e902009-06-02 15:39:55 -0700462 dev_set_name(f_dev, "%s", dev_name(device));
Greg Kroah-Hartmane55c8792006-09-14 07:30:59 -0700463 f_dev->parent = device;
464 f_dev->class = &firmware_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700466 dev_set_uevent_suppress(f_dev, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467
468 /* Need to pin this module until class device is destroyed */
469 __module_get(THIS_MODULE);
470
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700471 error = device_add(f_dev);
472 if (error) {
473 dev_err(device, "%s: device_register failed\n", __func__);
474 goto err_put_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 }
476
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700477 error = device_create_bin_file(f_dev, &firmware_attr_data);
478 if (error) {
479 dev_err(device, "%s: sysfs_create_bin_file failed\n", __func__);
480 goto err_del_dev;
481 }
482
483 error = device_create_file(f_dev, &dev_attr_loading);
484 if (error) {
Bjorn Helgaas266a8132008-10-15 22:04:20 -0700485 dev_err(device, "%s: device_create_file failed\n", __func__);
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700486 goto err_del_bin_attr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 }
488
Kay Sievers312c0042005-11-16 09:00:00 +0100489 if (uevent)
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700490 dev_set_uevent_suppress(f_dev, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700492 return fw_priv;
493
494err_del_bin_attr:
495 device_remove_bin_file(f_dev, &firmware_attr_data);
496err_del_dev:
497 device_del(f_dev);
498err_put_dev:
499 put_device(f_dev);
500err_out:
501 return ERR_PTR(error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502}
503
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700504static void fw_destroy_instance(struct firmware_priv *fw_priv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505{
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700506 struct device *f_dev = &fw_priv->dev;
507
508 device_remove_file(f_dev, &dev_attr_loading);
509 device_remove_bin_file(f_dev, &firmware_attr_data);
510 device_unregister(f_dev);
511}
512
513static int _request_firmware(const struct firmware **firmware_p,
514 const char *name, struct device *device,
515 bool uevent, bool nowait)
516{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 struct firmware_priv *fw_priv;
518 struct firmware *firmware;
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700519 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520
521 if (!firmware_p)
522 return -EINVAL;
523
Jiri Slaby4aed0642005-09-13 01:25:01 -0700524 *firmware_p = firmware = kzalloc(sizeof(*firmware), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 if (!firmware) {
Bjorn Helgaas266a8132008-10-15 22:04:20 -0700526 dev_err(device, "%s: kmalloc(struct firmware) failed\n",
527 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 retval = -ENOMEM;
529 goto out;
530 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531
Dmitry Torokhovbcb9bd12010-03-13 23:49:18 -0800532 if (fw_get_builtin_firmware(firmware, name)) {
Rafael J. Wysocki6f18ff92010-02-27 21:43:22 +0100533 dev_dbg(device, "firmware: using built-in firmware %s\n", name);
David Woodhouse5658c762008-05-23 13:52:42 +0100534 return 0;
535 }
536
537 if (uevent)
Rafael J. Wysocki6f18ff92010-02-27 21:43:22 +0100538 dev_dbg(device, "firmware: requesting %s\n", name);
David Woodhouse5658c762008-05-23 13:52:42 +0100539
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700540 fw_priv = fw_create_instance(firmware, name, device, uevent, nowait);
541 if (IS_ERR(fw_priv)) {
542 retval = PTR_ERR(fw_priv);
543 goto out;
544 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545
Kay Sievers312c0042005-11-16 09:00:00 +0100546 if (uevent) {
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700547 if (loading_timeout > 0)
548 mod_timer(&fw_priv->timeout,
549 round_jiffies_up(jiffies +
550 loading_timeout * HZ));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700552 kobject_uevent(&fw_priv->dev.kobj, KOBJ_ADD);
553 }
554
555 wait_for_completion(&fw_priv->completion);
556
557 set_bit(FW_STATUS_DONE, &fw_priv->status);
558 del_timer_sync(&fw_priv->timeout);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559
Laura Garciacad1e552006-05-23 23:22:38 +0200560 mutex_lock(&fw_lock);
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700561 if (!fw_priv->fw->size || test_bit(FW_STATUS_ABORT, &fw_priv->status))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 retval = -ENOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 fw_priv->fw = NULL;
Laura Garciacad1e552006-05-23 23:22:38 +0200564 mutex_unlock(&fw_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700566 fw_destroy_instance(fw_priv);
567
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568out:
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700569 if (retval) {
570 release_firmware(firmware);
Johannes Bergf45f3c12010-08-18 17:15:18 +0200571 *firmware_p = NULL;
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700572 }
573
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 return retval;
575}
576
577/**
Kay Sievers312c0042005-11-16 09:00:00 +0100578 * request_firmware: - send firmware request and wait for it
Randy Dunlapeb8e3172005-10-30 15:03:01 -0800579 * @firmware_p: pointer to firmware image
580 * @name: name of firmware file
581 * @device: device for which firmware is being loaded
582 *
583 * @firmware_p will be used to return a firmware image by the name
Abhay Salunke6e3eaab2005-09-06 15:17:13 -0700584 * of @name for device @device.
585 *
586 * Should be called from user context where sleeping is allowed.
587 *
Kay Sievers312c0042005-11-16 09:00:00 +0100588 * @name will be used as $FIRMWARE in the uevent environment and
Abhay Salunke6e3eaab2005-09-06 15:17:13 -0700589 * should be distinctive enough not to be confused with any other
590 * firmware image for this or any other device.
591 **/
592int
593request_firmware(const struct firmware **firmware_p, const char *name,
594 struct device *device)
595{
Kay Sievers312c0042005-11-16 09:00:00 +0100596 int uevent = 1;
Johannes Berge9045f92010-03-29 17:57:20 +0200597 return _request_firmware(firmware_p, name, device, uevent, false);
Abhay Salunke6e3eaab2005-09-06 15:17:13 -0700598}
599
600/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 * release_firmware: - release the resource associated with a firmware image
Randy Dunlapeb8e3172005-10-30 15:03:01 -0800602 * @fw: firmware resource to release
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 **/
Dmitry Torokhovbcb9bd12010-03-13 23:49:18 -0800604void release_firmware(const struct firmware *fw)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605{
606 if (fw) {
Dmitry Torokhovbcb9bd12010-03-13 23:49:18 -0800607 if (!fw_is_builtin_firmware(fw))
608 firmware_free_data(fw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 kfree(fw);
610 }
611}
612
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613/* Async support */
614struct firmware_work {
615 struct work_struct work;
616 struct module *module;
617 const char *name;
618 struct device *device;
619 void *context;
620 void (*cont)(const struct firmware *fw, void *context);
Kay Sievers312c0042005-11-16 09:00:00 +0100621 int uevent;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622};
623
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700624static int request_firmware_work_func(void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625{
626 struct firmware_work *fw_work = arg;
627 const struct firmware *fw;
matthieu castet113fab12005-11-13 16:07:39 -0800628 int ret;
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700629
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 if (!arg) {
631 WARN_ON(1);
632 return 0;
633 }
Johannes Berg9ebfbd42009-10-29 12:36:02 +0100634
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700635 ret = _request_firmware(&fw, fw_work->name, fw_work->device,
636 fw_work->uevent, true);
Johannes Berg9ebfbd42009-10-29 12:36:02 +0100637 fw_work->cont(fw, fw_work->context);
638
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 module_put(fw_work->module);
640 kfree(fw_work);
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700641
matthieu castet113fab12005-11-13 16:07:39 -0800642 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643}
644
645/**
Ben Hutchings3c31f072010-02-14 14:18:53 +0000646 * request_firmware_nowait - asynchronous version of request_firmware
Randy Dunlapeb8e3172005-10-30 15:03:01 -0800647 * @module: module requesting the firmware
Kay Sievers312c0042005-11-16 09:00:00 +0100648 * @uevent: sends uevent to copy the firmware image if this flag
Randy Dunlapeb8e3172005-10-30 15:03:01 -0800649 * is non-zero else the firmware copy must be done manually.
650 * @name: name of firmware file
651 * @device: device for which firmware is being loaded
Johannes Berg9ebfbd42009-10-29 12:36:02 +0100652 * @gfp: allocation flags
Randy Dunlapeb8e3172005-10-30 15:03:01 -0800653 * @context: will be passed over to @cont, and
654 * @fw may be %NULL if firmware request fails.
655 * @cont: function will be called asynchronously when the firmware
656 * request is over.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 *
Ming Lei7fcab092009-05-29 11:33:19 +0800658 * Asynchronous variant of request_firmware() for user contexts where
659 * it is not possible to sleep for long time. It can't be called
660 * in atomic contexts.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 **/
662int
663request_firmware_nowait(
Kay Sievers312c0042005-11-16 09:00:00 +0100664 struct module *module, int uevent,
Johannes Berg9ebfbd42009-10-29 12:36:02 +0100665 const char *name, struct device *device, gfp_t gfp, void *context,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 void (*cont)(const struct firmware *fw, void *context))
667{
Sukadev Bhattiprolu563d0752006-09-29 01:59:31 -0700668 struct task_struct *task;
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700669 struct firmware_work *fw_work;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700671 fw_work = kzalloc(sizeof (struct firmware_work), gfp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 if (!fw_work)
673 return -ENOMEM;
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700674
675 fw_work->module = module;
676 fw_work->name = name;
677 fw_work->device = device;
678 fw_work->context = context;
679 fw_work->cont = cont;
680 fw_work->uevent = uevent;
681
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 if (!try_module_get(module)) {
683 kfree(fw_work);
684 return -EFAULT;
685 }
686
Sukadev Bhattiprolu563d0752006-09-29 01:59:31 -0700687 task = kthread_run(request_firmware_work_func, fw_work,
688 "firmware/%s", name);
Sukadev Bhattiprolu563d0752006-09-29 01:59:31 -0700689 if (IS_ERR(task)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 fw_work->cont(NULL, fw_work->context);
matthieu castet113fab12005-11-13 16:07:39 -0800691 module_put(fw_work->module);
692 kfree(fw_work);
Sukadev Bhattiprolu563d0752006-09-29 01:59:31 -0700693 return PTR_ERR(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 }
Dmitry Torokhovf8a4bd32010-06-04 00:54:43 -0700695
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 return 0;
697}
698
Dmitry Torokhov673fae92010-03-13 23:49:13 -0800699static int __init firmware_class_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700{
Dmitry Torokhov673fae92010-03-13 23:49:13 -0800701 return class_register(&firmware_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702}
Dmitry Torokhov673fae92010-03-13 23:49:13 -0800703
704static void __exit firmware_class_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705{
706 class_unregister(&firmware_class);
707}
708
Shaohua Lia30a6a22006-09-27 01:50:52 -0700709fs_initcall(firmware_class_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710module_exit(firmware_class_exit);
711
712EXPORT_SYMBOL(release_firmware);
713EXPORT_SYMBOL(request_firmware);
714EXPORT_SYMBOL(request_firmware_nowait);