Merge branch 'for-upstream' of git://git.kernel.org/pub/scm/linux/kernel/git/dvrabel/uwb
[linux-2.6] / drivers / base / firmware_class.c
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/kthread.h>
20 #include <linux/highmem.h>
21 #include <linux/firmware.h>
22 #include "base.h"
23
24 #define to_dev(obj) container_of(obj, struct device, kobj)
25
26 MODULE_AUTHOR("Manuel Estrada Sainz");
27 MODULE_DESCRIPTION("Multi purpose firmware loading support");
28 MODULE_LICENSE("GPL");
29
30 enum {
31         FW_STATUS_LOADING,
32         FW_STATUS_DONE,
33         FW_STATUS_ABORT,
34 };
35
36 static int loading_timeout = 60;        /* In seconds */
37
38 /* fw_lock could be moved to 'struct firmware_priv' but since it is just
39  * guarding for corner cases a global lock should be OK */
40 static DEFINE_MUTEX(fw_lock);
41
42 struct firmware_priv {
43         char *fw_id;
44         struct completion completion;
45         struct bin_attribute attr_data;
46         struct firmware *fw;
47         unsigned long status;
48         struct page **pages;
49         int nr_pages;
50         int page_array_size;
51         const char *vdata;
52         struct timer_list timeout;
53 };
54
55 #ifdef CONFIG_FW_LOADER
56 extern struct builtin_fw __start_builtin_fw[];
57 extern struct builtin_fw __end_builtin_fw[];
58 #else /* Module case. Avoid ifdefs later; it'll all optimise out */
59 static struct builtin_fw *__start_builtin_fw;
60 static struct builtin_fw *__end_builtin_fw;
61 #endif
62
63 static void
64 fw_load_abort(struct firmware_priv *fw_priv)
65 {
66         set_bit(FW_STATUS_ABORT, &fw_priv->status);
67         wmb();
68         complete(&fw_priv->completion);
69 }
70
71 static ssize_t
72 firmware_timeout_show(struct class *class, char *buf)
73 {
74         return sprintf(buf, "%d\n", loading_timeout);
75 }
76
77 /**
78  * firmware_timeout_store - set number of seconds to wait for firmware
79  * @class: device class pointer
80  * @buf: buffer to scan for timeout value
81  * @count: number of bytes in @buf
82  *
83  *      Sets the number of seconds to wait for the firmware.  Once
84  *      this expires an error will be returned to the driver and no
85  *      firmware will be provided.
86  *
87  *      Note: zero means 'wait forever'.
88  **/
89 static ssize_t
90 firmware_timeout_store(struct class *class, const char *buf, size_t count)
91 {
92         loading_timeout = simple_strtol(buf, NULL, 10);
93         if (loading_timeout < 0)
94                 loading_timeout = 0;
95         return count;
96 }
97
98 static CLASS_ATTR(timeout, 0644, firmware_timeout_show, firmware_timeout_store);
99
100 static void fw_dev_release(struct device *dev);
101
102 static int firmware_uevent(struct device *dev, struct kobj_uevent_env *env)
103 {
104         struct firmware_priv *fw_priv = dev_get_drvdata(dev);
105
106         if (add_uevent_var(env, "FIRMWARE=%s", fw_priv->fw_id))
107                 return -ENOMEM;
108         if (add_uevent_var(env, "TIMEOUT=%i", loading_timeout))
109                 return -ENOMEM;
110
111         return 0;
112 }
113
114 static struct class firmware_class = {
115         .name           = "firmware",
116         .dev_uevent     = firmware_uevent,
117         .dev_release    = fw_dev_release,
118 };
119
120 static ssize_t firmware_loading_show(struct device *dev,
121                                      struct device_attribute *attr, char *buf)
122 {
123         struct firmware_priv *fw_priv = dev_get_drvdata(dev);
124         int loading = test_bit(FW_STATUS_LOADING, &fw_priv->status);
125         return sprintf(buf, "%d\n", loading);
126 }
127
128 /* Some architectures don't have PAGE_KERNEL_RO */
129 #ifndef PAGE_KERNEL_RO
130 #define PAGE_KERNEL_RO PAGE_KERNEL
131 #endif
132 /**
133  * firmware_loading_store - set value in the 'loading' control file
134  * @dev: device pointer
135  * @attr: device attribute pointer
136  * @buf: buffer to scan for loading control value
137  * @count: number of bytes in @buf
138  *
139  *      The relevant values are:
140  *
141  *       1: Start a load, discarding any previous partial load.
142  *       0: Conclude the load and hand the data to the driver code.
143  *      -1: Conclude the load with an error and discard any written data.
144  **/
145 static ssize_t firmware_loading_store(struct device *dev,
146                                       struct device_attribute *attr,
147                                       const char *buf, size_t count)
148 {
149         struct firmware_priv *fw_priv = dev_get_drvdata(dev);
150         int loading = simple_strtol(buf, NULL, 10);
151         int i;
152
153         switch (loading) {
154         case 1:
155                 mutex_lock(&fw_lock);
156                 if (!fw_priv->fw) {
157                         mutex_unlock(&fw_lock);
158                         break;
159                 }
160                 vfree(fw_priv->fw->data);
161                 fw_priv->fw->data = NULL;
162                 for (i = 0; i < fw_priv->nr_pages; i++)
163                         __free_page(fw_priv->pages[i]);
164                 kfree(fw_priv->pages);
165                 fw_priv->pages = NULL;
166                 fw_priv->page_array_size = 0;
167                 fw_priv->nr_pages = 0;
168                 fw_priv->fw->size = 0;
169                 set_bit(FW_STATUS_LOADING, &fw_priv->status);
170                 mutex_unlock(&fw_lock);
171                 break;
172         case 0:
173                 if (test_bit(FW_STATUS_LOADING, &fw_priv->status)) {
174                         vfree(fw_priv->fw->data);
175                         fw_priv->fw->data = vmap(fw_priv->pages,
176                                                  fw_priv->nr_pages,
177                                                  0, PAGE_KERNEL_RO);
178                         if (!fw_priv->fw->data) {
179                                 dev_err(dev, "%s: vmap() failed\n", __func__);
180                                 goto err;
181                         }
182                         /* Pages will be freed by vfree() */
183                         fw_priv->pages = NULL;
184                         fw_priv->page_array_size = 0;
185                         fw_priv->nr_pages = 0;
186                         complete(&fw_priv->completion);
187                         clear_bit(FW_STATUS_LOADING, &fw_priv->status);
188                         break;
189                 }
190                 /* fallthrough */
191         default:
192                 dev_err(dev, "%s: unexpected value (%d)\n", __func__, loading);
193                 /* fallthrough */
194         case -1:
195         err:
196                 fw_load_abort(fw_priv);
197                 break;
198         }
199
200         return count;
201 }
202
203 static DEVICE_ATTR(loading, 0644, firmware_loading_show, firmware_loading_store);
204
205 static ssize_t
206 firmware_data_read(struct kobject *kobj, struct bin_attribute *bin_attr,
207                    char *buffer, loff_t offset, size_t count)
208 {
209         struct device *dev = to_dev(kobj);
210         struct firmware_priv *fw_priv = dev_get_drvdata(dev);
211         struct firmware *fw;
212         ssize_t ret_count;
213
214         mutex_lock(&fw_lock);
215         fw = fw_priv->fw;
216         if (!fw || test_bit(FW_STATUS_DONE, &fw_priv->status)) {
217                 ret_count = -ENODEV;
218                 goto out;
219         }
220         if (offset > fw->size)
221                 return 0;
222         if (count > fw->size - offset)
223                 count = fw->size - offset;
224
225         ret_count = count;
226
227         while (count) {
228                 void *page_data;
229                 int page_nr = offset >> PAGE_SHIFT;
230                 int page_ofs = offset & (PAGE_SIZE-1);
231                 int page_cnt = min_t(size_t, PAGE_SIZE - page_ofs, count);
232
233                 page_data = kmap(fw_priv->pages[page_nr]);
234
235                 memcpy(buffer, page_data + page_ofs, page_cnt);
236
237                 kunmap(fw_priv->pages[page_nr]);
238                 buffer += page_cnt;
239                 offset += page_cnt;
240                 count -= page_cnt;
241         }
242 out:
243         mutex_unlock(&fw_lock);
244         return ret_count;
245 }
246
247 static int
248 fw_realloc_buffer(struct firmware_priv *fw_priv, int min_size)
249 {
250         int pages_needed = ALIGN(min_size, PAGE_SIZE) >> PAGE_SHIFT;
251
252         /* If the array of pages is too small, grow it... */
253         if (fw_priv->page_array_size < pages_needed) {
254                 int new_array_size = max(pages_needed,
255                                          fw_priv->page_array_size * 2);
256                 struct page **new_pages;
257
258                 new_pages = kmalloc(new_array_size * sizeof(void *),
259                                     GFP_KERNEL);
260                 if (!new_pages) {
261                         fw_load_abort(fw_priv);
262                         return -ENOMEM;
263                 }
264                 memcpy(new_pages, fw_priv->pages,
265                        fw_priv->page_array_size * sizeof(void *));
266                 memset(&new_pages[fw_priv->page_array_size], 0, sizeof(void *) *
267                        (new_array_size - fw_priv->page_array_size));
268                 kfree(fw_priv->pages);
269                 fw_priv->pages = new_pages;
270                 fw_priv->page_array_size = new_array_size;
271         }
272
273         while (fw_priv->nr_pages < pages_needed) {
274                 fw_priv->pages[fw_priv->nr_pages] =
275                         alloc_page(GFP_KERNEL | __GFP_HIGHMEM);
276
277                 if (!fw_priv->pages[fw_priv->nr_pages]) {
278                         fw_load_abort(fw_priv);
279                         return -ENOMEM;
280                 }
281                 fw_priv->nr_pages++;
282         }
283         return 0;
284 }
285
286 /**
287  * firmware_data_write - write method for firmware
288  * @kobj: kobject for the device
289  * @bin_attr: bin_attr structure
290  * @buffer: buffer being written
291  * @offset: buffer offset for write in total data store area
292  * @count: buffer size
293  *
294  *      Data written to the 'data' attribute will be later handed to
295  *      the driver as a firmware image.
296  **/
297 static ssize_t
298 firmware_data_write(struct kobject *kobj, struct bin_attribute *bin_attr,
299                     char *buffer, loff_t offset, size_t count)
300 {
301         struct device *dev = to_dev(kobj);
302         struct firmware_priv *fw_priv = dev_get_drvdata(dev);
303         struct firmware *fw;
304         ssize_t retval;
305
306         if (!capable(CAP_SYS_RAWIO))
307                 return -EPERM;
308
309         mutex_lock(&fw_lock);
310         fw = fw_priv->fw;
311         if (!fw || test_bit(FW_STATUS_DONE, &fw_priv->status)) {
312                 retval = -ENODEV;
313                 goto out;
314         }
315         retval = fw_realloc_buffer(fw_priv, offset + count);
316         if (retval)
317                 goto out;
318
319         retval = count;
320
321         while (count) {
322                 void *page_data;
323                 int page_nr = offset >> PAGE_SHIFT;
324                 int page_ofs = offset & (PAGE_SIZE - 1);
325                 int page_cnt = min_t(size_t, PAGE_SIZE - page_ofs, count);
326
327                 page_data = kmap(fw_priv->pages[page_nr]);
328
329                 memcpy(page_data + page_ofs, buffer, page_cnt);
330
331                 kunmap(fw_priv->pages[page_nr]);
332                 buffer += page_cnt;
333                 offset += page_cnt;
334                 count -= page_cnt;
335         }
336
337         fw->size = max_t(size_t, offset, fw->size);
338 out:
339         mutex_unlock(&fw_lock);
340         return retval;
341 }
342
343 static struct bin_attribute firmware_attr_data_tmpl = {
344         .attr = {.name = "data", .mode = 0644},
345         .size = 0,
346         .read = firmware_data_read,
347         .write = firmware_data_write,
348 };
349
350 static void fw_dev_release(struct device *dev)
351 {
352         struct firmware_priv *fw_priv = dev_get_drvdata(dev);
353         int i;
354
355         for (i = 0; i < fw_priv->nr_pages; i++)
356                 __free_page(fw_priv->pages[i]);
357         kfree(fw_priv->pages);
358         kfree(fw_priv->fw_id);
359         kfree(fw_priv);
360         put_device(dev);
361
362         module_put(THIS_MODULE);
363 }
364
365 static void
366 firmware_class_timeout(u_long data)
367 {
368         struct firmware_priv *fw_priv = (struct firmware_priv *) data;
369         fw_load_abort(fw_priv);
370 }
371
372 static int fw_register_device(struct device **dev_p, const char *fw_name,
373                               struct device *device)
374 {
375         int retval;
376         struct firmware_priv *fw_priv = kzalloc(sizeof(*fw_priv),
377                                                 GFP_KERNEL);
378         struct device *f_dev = kzalloc(sizeof(*f_dev), GFP_KERNEL);
379
380         *dev_p = NULL;
381
382         if (!fw_priv || !f_dev) {
383                 dev_err(device, "%s: kmalloc failed\n", __func__);
384                 retval = -ENOMEM;
385                 goto error_kfree;
386         }
387
388         init_completion(&fw_priv->completion);
389         fw_priv->attr_data = firmware_attr_data_tmpl;
390         fw_priv->fw_id = kstrdup(fw_name, GFP_KERNEL);
391         if (!fw_priv->fw_id) {
392                 dev_err(device, "%s: Firmware name allocation failed\n",
393                         __func__);
394                 retval = -ENOMEM;
395                 goto error_kfree;
396         }
397
398         fw_priv->timeout.function = firmware_class_timeout;
399         fw_priv->timeout.data = (u_long) fw_priv;
400         init_timer(&fw_priv->timeout);
401
402         dev_set_name(f_dev, "%s", dev_name(device));
403         f_dev->parent = device;
404         f_dev->class = &firmware_class;
405         dev_set_drvdata(f_dev, fw_priv);
406         dev_set_uevent_suppress(f_dev, 1);
407         retval = device_register(f_dev);
408         if (retval) {
409                 dev_err(device, "%s: device_register failed\n", __func__);
410                 put_device(f_dev);
411                 goto error_kfree_fw_id;
412         }
413         *dev_p = f_dev;
414         return 0;
415
416 error_kfree_fw_id:
417         kfree(fw_priv->fw_id);
418 error_kfree:
419         kfree(f_dev);
420         kfree(fw_priv);
421         return retval;
422 }
423
424 static int fw_setup_device(struct firmware *fw, struct device **dev_p,
425                            const char *fw_name, struct device *device,
426                            int uevent)
427 {
428         struct device *f_dev;
429         struct firmware_priv *fw_priv;
430         int retval;
431
432         *dev_p = NULL;
433         retval = fw_register_device(&f_dev, fw_name, device);
434         if (retval)
435                 goto out;
436
437         /* Need to pin this module until class device is destroyed */
438         __module_get(THIS_MODULE);
439
440         fw_priv = dev_get_drvdata(f_dev);
441
442         fw_priv->fw = fw;
443         retval = sysfs_create_bin_file(&f_dev->kobj, &fw_priv->attr_data);
444         if (retval) {
445                 dev_err(device, "%s: sysfs_create_bin_file failed\n", __func__);
446                 goto error_unreg;
447         }
448
449         retval = device_create_file(f_dev, &dev_attr_loading);
450         if (retval) {
451                 dev_err(device, "%s: device_create_file failed\n", __func__);
452                 goto error_unreg;
453         }
454
455         if (uevent)
456                 dev_set_uevent_suppress(f_dev, 0);
457         *dev_p = f_dev;
458         goto out;
459
460 error_unreg:
461         device_unregister(f_dev);
462 out:
463         return retval;
464 }
465
466 static int
467 _request_firmware(const struct firmware **firmware_p, const char *name,
468                  struct device *device, int uevent)
469 {
470         struct device *f_dev;
471         struct firmware_priv *fw_priv;
472         struct firmware *firmware;
473         struct builtin_fw *builtin;
474         int retval;
475
476         if (!firmware_p)
477                 return -EINVAL;
478
479         *firmware_p = firmware = kzalloc(sizeof(*firmware), GFP_KERNEL);
480         if (!firmware) {
481                 dev_err(device, "%s: kmalloc(struct firmware) failed\n",
482                         __func__);
483                 retval = -ENOMEM;
484                 goto out;
485         }
486
487         for (builtin = __start_builtin_fw; builtin != __end_builtin_fw;
488              builtin++) {
489                 if (strcmp(name, builtin->name))
490                         continue;
491                 dev_info(device, "firmware: using built-in firmware %s\n",
492                          name);
493                 firmware->size = builtin->size;
494                 firmware->data = builtin->data;
495                 return 0;
496         }
497
498         if (uevent)
499                 dev_info(device, "firmware: requesting %s\n", name);
500
501         retval = fw_setup_device(firmware, &f_dev, name, device, uevent);
502         if (retval)
503                 goto error_kfree_fw;
504
505         fw_priv = dev_get_drvdata(f_dev);
506
507         if (uevent) {
508                 if (loading_timeout > 0) {
509                         fw_priv->timeout.expires = jiffies + loading_timeout * HZ;
510                         add_timer(&fw_priv->timeout);
511                 }
512
513                 kobject_uevent(&f_dev->kobj, KOBJ_ADD);
514                 wait_for_completion(&fw_priv->completion);
515                 set_bit(FW_STATUS_DONE, &fw_priv->status);
516                 del_timer_sync(&fw_priv->timeout);
517         } else
518                 wait_for_completion(&fw_priv->completion);
519
520         mutex_lock(&fw_lock);
521         if (!fw_priv->fw->size || test_bit(FW_STATUS_ABORT, &fw_priv->status)) {
522                 retval = -ENOENT;
523                 release_firmware(fw_priv->fw);
524                 *firmware_p = NULL;
525         }
526         fw_priv->fw = NULL;
527         mutex_unlock(&fw_lock);
528         device_unregister(f_dev);
529         goto out;
530
531 error_kfree_fw:
532         kfree(firmware);
533         *firmware_p = NULL;
534 out:
535         return retval;
536 }
537
538 /**
539  * request_firmware: - send firmware request and wait for it
540  * @firmware_p: pointer to firmware image
541  * @name: name of firmware file
542  * @device: device for which firmware is being loaded
543  *
544  *      @firmware_p will be used to return a firmware image by the name
545  *      of @name for device @device.
546  *
547  *      Should be called from user context where sleeping is allowed.
548  *
549  *      @name will be used as $FIRMWARE in the uevent environment and
550  *      should be distinctive enough not to be confused with any other
551  *      firmware image for this or any other device.
552  **/
553 int
554 request_firmware(const struct firmware **firmware_p, const char *name,
555                  struct device *device)
556 {
557         int uevent = 1;
558         return _request_firmware(firmware_p, name, device, uevent);
559 }
560
561 /**
562  * release_firmware: - release the resource associated with a firmware image
563  * @fw: firmware resource to release
564  **/
565 void
566 release_firmware(const struct firmware *fw)
567 {
568         struct builtin_fw *builtin;
569
570         if (fw) {
571                 for (builtin = __start_builtin_fw; builtin != __end_builtin_fw;
572                      builtin++) {
573                         if (fw->data == builtin->data)
574                                 goto free_fw;
575                 }
576                 vfree(fw->data);
577         free_fw:
578                 kfree(fw);
579         }
580 }
581
582 /* Async support */
583 struct firmware_work {
584         struct work_struct work;
585         struct module *module;
586         const char *name;
587         struct device *device;
588         void *context;
589         void (*cont)(const struct firmware *fw, void *context);
590         int uevent;
591 };
592
593 static int
594 request_firmware_work_func(void *arg)
595 {
596         struct firmware_work *fw_work = arg;
597         const struct firmware *fw;
598         int ret;
599         if (!arg) {
600                 WARN_ON(1);
601                 return 0;
602         }
603         ret = _request_firmware(&fw, fw_work->name, fw_work->device,
604                 fw_work->uevent);
605         if (ret < 0)
606                 fw_work->cont(NULL, fw_work->context);
607         else {
608                 fw_work->cont(fw, fw_work->context);
609                 release_firmware(fw);
610         }
611         module_put(fw_work->module);
612         kfree(fw_work);
613         return ret;
614 }
615
616 /**
617  * request_firmware_nowait: asynchronous version of request_firmware
618  * @module: module requesting the firmware
619  * @uevent: sends uevent to copy the firmware image if this flag
620  *      is non-zero else the firmware copy must be done manually.
621  * @name: name of firmware file
622  * @device: device for which firmware is being loaded
623  * @context: will be passed over to @cont, and
624  *      @fw may be %NULL if firmware request fails.
625  * @cont: function will be called asynchronously when the firmware
626  *      request is over.
627  *
628  *      Asynchronous variant of request_firmware() for user contexts where
629  *      it is not possible to sleep for long time. It can't be called
630  *      in atomic contexts.
631  **/
632 int
633 request_firmware_nowait(
634         struct module *module, int uevent,
635         const char *name, struct device *device, void *context,
636         void (*cont)(const struct firmware *fw, void *context))
637 {
638         struct task_struct *task;
639         struct firmware_work *fw_work = kmalloc(sizeof (struct firmware_work),
640                                                 GFP_ATOMIC);
641
642         if (!fw_work)
643                 return -ENOMEM;
644         if (!try_module_get(module)) {
645                 kfree(fw_work);
646                 return -EFAULT;
647         }
648
649         *fw_work = (struct firmware_work) {
650                 .module = module,
651                 .name = name,
652                 .device = device,
653                 .context = context,
654                 .cont = cont,
655                 .uevent = uevent,
656         };
657
658         task = kthread_run(request_firmware_work_func, fw_work,
659                             "firmware/%s", name);
660
661         if (IS_ERR(task)) {
662                 fw_work->cont(NULL, fw_work->context);
663                 module_put(fw_work->module);
664                 kfree(fw_work);
665                 return PTR_ERR(task);
666         }
667         return 0;
668 }
669
670 static int __init
671 firmware_class_init(void)
672 {
673         int error;
674         error = class_register(&firmware_class);
675         if (error) {
676                 printk(KERN_ERR "%s: class_register failed\n", __func__);
677                 return error;
678         }
679         error = class_create_file(&firmware_class, &class_attr_timeout);
680         if (error) {
681                 printk(KERN_ERR "%s: class_create_file failed\n",
682                        __func__);
683                 class_unregister(&firmware_class);
684         }
685         return error;
686
687 }
688 static void __exit
689 firmware_class_exit(void)
690 {
691         class_unregister(&firmware_class);
692 }
693
694 fs_initcall(firmware_class_init);
695 module_exit(firmware_class_exit);
696
697 EXPORT_SYMBOL(release_firmware);
698 EXPORT_SYMBOL(request_firmware);
699 EXPORT_SYMBOL(request_firmware_nowait);