[PATCH] backlight: lcd: Remove dependenct from the framebuffer layer
[linux-2.6] / drivers / video / backlight / backlight.c
1 /*
2  * Backlight Lowlevel Control Abstraction
3  *
4  * Copyright (C) 2003,2004 Hewlett-Packard Company
5  *
6  */
7
8 #include <linux/module.h>
9 #include <linux/init.h>
10 #include <linux/device.h>
11 #include <linux/backlight.h>
12 #include <linux/notifier.h>
13 #include <linux/ctype.h>
14 #include <linux/err.h>
15 #include <linux/fb.h>
16
17
18 #if defined(CONFIG_FB) || (defined(CONFIG_FB_MODULE) && \
19                            defined(CONFIG_BACKLIGHT_CLASS_DEVICE_MODULE))
20 /* This callback gets called when something important happens inside a
21  * framebuffer driver. We're looking if that important event is blanking,
22  * and if it is, we're switching backlight power as well ...
23  */
24 static int fb_notifier_callback(struct notifier_block *self,
25                                 unsigned long event, void *data)
26 {
27         struct backlight_device *bd;
28         struct fb_event *evdata = data;
29
30         /* If we aren't interested in this event, skip it immediately ... */
31         if (event != FB_EVENT_BLANK)
32                 return 0;
33
34         bd = container_of(self, struct backlight_device, fb_notif);
35         down(&bd->sem);
36         if (bd->props)
37                 if (!bd->props->check_fb ||
38                     bd->props->check_fb(evdata->info)) {
39                         bd->props->fb_blank = *(int *)evdata->data;
40                         if (likely(bd->props && bd->props->update_status))
41                                 bd->props->update_status(bd);
42                 }
43         up(&bd->sem);
44         return 0;
45 }
46
47 static int backlight_register_fb(struct backlight_device *bd)
48 {
49         memset(&bd->fb_notif, 0, sizeof(bd->fb_notif));
50         bd->fb_notif.notifier_call = fb_notifier_callback;
51
52         return fb_register_client(&bd->fb_notif);
53 }
54
55 static void backlight_unregister_fb(struct backlight_device *bd)
56 {
57         fb_unregister_client(&bd->fb_notif);
58 }
59 #else
60 static inline int backlight_register_fb(struct backlight_device *bd)
61 {
62         return 0;
63 }
64
65 static inline void backlight_unregister_fb(struct backlight_device *bd)
66 {
67 }
68 #endif /* CONFIG_FB */
69
70 static ssize_t backlight_show_power(struct class_device *cdev, char *buf)
71 {
72         int rc = -ENXIO;
73         struct backlight_device *bd = to_backlight_device(cdev);
74
75         down(&bd->sem);
76         if (likely(bd->props))
77                 rc = sprintf(buf, "%d\n", bd->props->power);
78         up(&bd->sem);
79
80         return rc;
81 }
82
83 static ssize_t backlight_store_power(struct class_device *cdev, const char *buf, size_t count)
84 {
85         int rc = -ENXIO;
86         char *endp;
87         struct backlight_device *bd = to_backlight_device(cdev);
88         int power = simple_strtoul(buf, &endp, 0);
89         size_t size = endp - buf;
90
91         if (*endp && isspace(*endp))
92                 size++;
93         if (size != count)
94                 return -EINVAL;
95
96         down(&bd->sem);
97         if (likely(bd->props)) {
98                 pr_debug("backlight: set power to %d\n", power);
99                 bd->props->power = power;
100                 if (likely(bd->props->update_status))
101                         bd->props->update_status(bd);
102                 rc = count;
103         }
104         up(&bd->sem);
105
106         return rc;
107 }
108
109 static ssize_t backlight_show_brightness(struct class_device *cdev, char *buf)
110 {
111         int rc = -ENXIO;
112         struct backlight_device *bd = to_backlight_device(cdev);
113
114         down(&bd->sem);
115         if (likely(bd->props))
116                 rc = sprintf(buf, "%d\n", bd->props->brightness);
117         up(&bd->sem);
118
119         return rc;
120 }
121
122 static ssize_t backlight_store_brightness(struct class_device *cdev, const char *buf, size_t count)
123 {
124         int rc = -ENXIO;
125         char *endp;
126         struct backlight_device *bd = to_backlight_device(cdev);
127         int brightness = simple_strtoul(buf, &endp, 0);
128         size_t size = endp - buf;
129
130         if (*endp && isspace(*endp))
131                 size++;
132         if (size != count)
133                 return -EINVAL;
134
135         down(&bd->sem);
136         if (likely(bd->props)) {
137                 if (brightness > bd->props->max_brightness)
138                         rc = -EINVAL;
139                 else {
140                         pr_debug("backlight: set brightness to %d\n",
141                                  brightness);
142                         bd->props->brightness = brightness;
143                         if (likely(bd->props->update_status))
144                                 bd->props->update_status(bd);
145                         rc = count;
146                 }
147         }
148         up(&bd->sem);
149
150         return rc;
151 }
152
153 static ssize_t backlight_show_max_brightness(struct class_device *cdev, char *buf)
154 {
155         int rc = -ENXIO;
156         struct backlight_device *bd = to_backlight_device(cdev);
157
158         down(&bd->sem);
159         if (likely(bd->props))
160                 rc = sprintf(buf, "%d\n", bd->props->max_brightness);
161         up(&bd->sem);
162
163         return rc;
164 }
165
166 static ssize_t backlight_show_actual_brightness(struct class_device *cdev,
167                                                 char *buf)
168 {
169         int rc = -ENXIO;
170         struct backlight_device *bd = to_backlight_device(cdev);
171
172         down(&bd->sem);
173         if (likely(bd->props && bd->props->get_brightness))
174                 rc = sprintf(buf, "%d\n", bd->props->get_brightness(bd));
175         up(&bd->sem);
176
177         return rc;
178 }
179
180 static void backlight_class_release(struct class_device *dev)
181 {
182         struct backlight_device *bd = to_backlight_device(dev);
183         kfree(bd);
184 }
185
186 static struct class backlight_class = {
187         .name = "backlight",
188         .release = backlight_class_release,
189 };
190
191 #define DECLARE_ATTR(_name,_mode,_show,_store)                  \
192 {                                                               \
193         .attr   = { .name = __stringify(_name), .mode = _mode, .owner = THIS_MODULE },  \
194         .show   = _show,                                        \
195         .store  = _store,                                       \
196 }
197
198 static const struct class_device_attribute bl_class_device_attributes[] = {
199         DECLARE_ATTR(power, 0644, backlight_show_power, backlight_store_power),
200         DECLARE_ATTR(brightness, 0644, backlight_show_brightness,
201                      backlight_store_brightness),
202         DECLARE_ATTR(actual_brightness, 0444, backlight_show_actual_brightness,
203                      NULL),
204         DECLARE_ATTR(max_brightness, 0444, backlight_show_max_brightness, NULL),
205 };
206
207 /**
208  * backlight_device_register - create and register a new object of
209  *   backlight_device class.
210  * @name: the name of the new object(must be the same as the name of the
211  *   respective framebuffer device).
212  * @devdata: an optional pointer to be stored in the class_device. The
213  *   methods may retrieve it by using class_get_devdata(&bd->class_dev).
214  * @bp: the backlight properties structure.
215  *
216  * Creates and registers new backlight class_device. Returns either an
217  * ERR_PTR() or a pointer to the newly allocated device.
218  */
219 struct backlight_device *backlight_device_register(const char *name, void *devdata,
220                                                    struct backlight_properties *bp)
221 {
222         int i, rc;
223         struct backlight_device *new_bd;
224
225         pr_debug("backlight_device_alloc: name=%s\n", name);
226
227         new_bd = kmalloc(sizeof(struct backlight_device), GFP_KERNEL);
228         if (unlikely(!new_bd))
229                 return ERR_PTR(-ENOMEM);
230
231         init_MUTEX(&new_bd->sem);
232         new_bd->props = bp;
233         memset(&new_bd->class_dev, 0, sizeof(new_bd->class_dev));
234         new_bd->class_dev.class = &backlight_class;
235         strlcpy(new_bd->class_dev.class_id, name, KOBJ_NAME_LEN);
236         class_set_devdata(&new_bd->class_dev, devdata);
237
238         rc = class_device_register(&new_bd->class_dev);
239         if (unlikely(rc)) {
240 error:          kfree(new_bd);
241                 return ERR_PTR(rc);
242         }
243
244         rc = backlight_register_fb(new_bd);
245         if (unlikely(rc))
246                 goto error;
247
248         for (i = 0; i < ARRAY_SIZE(bl_class_device_attributes); i++) {
249                 rc = class_device_create_file(&new_bd->class_dev,
250                                               &bl_class_device_attributes[i]);
251                 if (unlikely(rc)) {
252                         while (--i >= 0)
253                                 class_device_remove_file(&new_bd->class_dev,
254                                                          &bl_class_device_attributes[i]);
255                         class_device_unregister(&new_bd->class_dev);
256                         /* No need to kfree(new_bd) since release() method was called */
257                         return ERR_PTR(rc);
258                 }
259         }
260
261         return new_bd;
262 }
263 EXPORT_SYMBOL(backlight_device_register);
264
265 /**
266  * backlight_device_unregister - unregisters a backlight device object.
267  * @bd: the backlight device object to be unregistered and freed.
268  *
269  * Unregisters a previously registered via backlight_device_register object.
270  */
271 void backlight_device_unregister(struct backlight_device *bd)
272 {
273         int i;
274
275         if (!bd)
276                 return;
277
278         pr_debug("backlight_device_unregister: name=%s\n", bd->class_dev.class_id);
279
280         for (i = 0; i < ARRAY_SIZE(bl_class_device_attributes); i++)
281                 class_device_remove_file(&bd->class_dev,
282                                          &bl_class_device_attributes[i]);
283
284         down(&bd->sem);
285         if (likely(bd->props && bd->props->update_status)) {
286                 bd->props->brightness = 0;
287                 bd->props->power = 0;
288                 bd->props->update_status(bd);
289         }
290
291         bd->props = NULL;
292         up(&bd->sem);
293
294         backlight_unregister_fb(bd);
295
296         class_device_unregister(&bd->class_dev);
297 }
298 EXPORT_SYMBOL(backlight_device_unregister);
299
300 static void __exit backlight_class_exit(void)
301 {
302         class_unregister(&backlight_class);
303 }
304
305 static int __init backlight_class_init(void)
306 {
307         return class_register(&backlight_class);
308 }
309
310 /*
311  * if this is compiled into the kernel, we need to ensure that the
312  * class is registered before users of the class try to register lcd's
313  */
314 postcore_initcall(backlight_class_init);
315 module_exit(backlight_class_exit);
316
317 MODULE_LICENSE("GPL");
318 MODULE_AUTHOR("Jamey Hicks <jamey.hicks@hp.com>, Andrew Zabolotny <zap@homelink.ru>");
319 MODULE_DESCRIPTION("Backlight Lowlevel Control Abstraction");