sysfs: small header file cleanup for SYSFS=n
[linux-2.6.git] / Documentation / firmware_class / firmware_sample_driver.c
1 /*
2  * firmware_sample_driver.c -
3  *
4  * Copyright (c) 2003 Manuel Estrada Sainz
5  *
6  * Sample code on how to use request_firmware() from drivers.
7  *
8  */
9
10 #include <linux/module.h>
11 #include <linux/kernel.h>
12 #include <linux/init.h>
13 #include <linux/device.h>
14 #include <linux/string.h>
15
16 #include "linux/firmware.h"
17
18 static struct device ghost_device = {
19         .bus_id    = "ghost0",
20 };
21
22
23 static void sample_firmware_load(char *firmware, int size)
24 {
25         u8 buf[size+1];
26         memcpy(buf, firmware, size);
27         buf[size] = '\0';
28         printk(KERN_INFO "firmware_sample_driver: firmware: %s\n", buf);
29 }
30
31 static void sample_probe_default(void)
32 {
33         /* uses the default method to get the firmware */
34         const struct firmware *fw_entry;
35         printk(KERN_INFO "firmware_sample_driver: a ghost device got inserted :)\n");
36
37         if(request_firmware(&fw_entry, "sample_driver_fw", &ghost_device)!=0)
38         {
39                 printk(KERN_ERR
40                        "firmware_sample_driver: Firmware not available\n");
41                 return;
42         }
43         
44         sample_firmware_load(fw_entry->data, fw_entry->size);
45
46         release_firmware(fw_entry);
47
48         /* finish setting up the device */
49 }
50 static void sample_probe_specific(void)
51 {
52         /* Uses some specific hotplug support to get the firmware from
53          * userspace  directly into the hardware, or via some sysfs file */
54
55         /* NOTE: This currently doesn't work */
56
57         printk(KERN_INFO "firmware_sample_driver: a ghost device got inserted :)\n");
58
59         if(request_firmware(NULL, "sample_driver_fw", &ghost_device)!=0)
60         {
61                 printk(KERN_ERR
62                        "firmware_sample_driver: Firmware load failed\n");
63                 return;
64         }
65         
66         /* request_firmware blocks until userspace finished, so at
67          * this point the firmware should be already in the device */
68
69         /* finish setting up the device */
70 }
71 static void sample_probe_async_cont(const struct firmware *fw, void *context)
72 {
73         if(!fw){
74                 printk(KERN_ERR
75                        "firmware_sample_driver: firmware load failed\n");
76                 return;
77         }
78
79         printk(KERN_INFO "firmware_sample_driver: device pointer \"%s\"\n",
80                (char *)context);
81         sample_firmware_load(fw->data, fw->size);
82 }
83 static void sample_probe_async(void)
84 {
85         /* Let's say that I can't sleep */
86         int error;
87         error = request_firmware_nowait (THIS_MODULE, FW_ACTION_NOHOTPLUG,
88                                          "sample_driver_fw", &ghost_device,
89                                          "my device pointer",
90                                          sample_probe_async_cont);
91         if(error){
92                 printk(KERN_ERR 
93                        "firmware_sample_driver:"
94                        " request_firmware_nowait failed\n");
95         }
96 }
97
98 static int sample_init(void)
99 {
100         device_initialize(&ghost_device);
101         /* since there is no real hardware insertion I just call the
102          * sample probe functions here */
103         sample_probe_specific();
104         sample_probe_default();
105         sample_probe_async();
106         return 0;
107 }
108 static void __exit sample_exit(void)
109 {
110 }
111
112 module_init (sample_init);
113 module_exit (sample_exit);
114
115 MODULE_LICENSE("GPL");