2 * Backlight Lowlevel Control Abstraction
4 * Copyright (C) 2003,2004 Hewlett-Packard Company
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>
17 #ifdef CONFIG_PMAC_BACKLIGHT
18 #include <asm/backlight.h>
21 #if defined(CONFIG_FB) || (defined(CONFIG_FB_MODULE) && \
22 defined(CONFIG_BACKLIGHT_CLASS_DEVICE_MODULE))
23 /* This callback gets called when something important happens inside a
24 * framebuffer driver. We're looking if that important event is blanking,
25 * and if it is, we're switching backlight power as well ...
27 static int fb_notifier_callback(struct notifier_block
*self
,
28 unsigned long event
, void *data
)
30 struct backlight_device
*bd
;
31 struct fb_event
*evdata
= data
;
33 /* If we aren't interested in this event, skip it immediately ... */
34 if (event
!= FB_EVENT_BLANK
&& event
!= FB_EVENT_CONBLANK
)
37 bd
= container_of(self
, struct backlight_device
, fb_notif
);
38 mutex_lock(&bd
->ops_lock
);
40 if (!bd
->ops
->check_fb
||
41 bd
->ops
->check_fb(evdata
->info
)) {
42 bd
->props
.fb_blank
= *(int *)evdata
->data
;
43 if (bd
->props
.fb_blank
== FB_BLANK_UNBLANK
)
44 bd
->props
.state
&= ~BL_CORE_FBBLANK
;
46 bd
->props
.state
|= BL_CORE_FBBLANK
;
47 backlight_update_status(bd
);
49 mutex_unlock(&bd
->ops_lock
);
53 static int backlight_register_fb(struct backlight_device
*bd
)
55 memset(&bd
->fb_notif
, 0, sizeof(bd
->fb_notif
));
56 bd
->fb_notif
.notifier_call
= fb_notifier_callback
;
58 return fb_register_client(&bd
->fb_notif
);
61 static void backlight_unregister_fb(struct backlight_device
*bd
)
63 fb_unregister_client(&bd
->fb_notif
);
66 static inline int backlight_register_fb(struct backlight_device
*bd
)
71 static inline void backlight_unregister_fb(struct backlight_device
*bd
)
74 #endif /* CONFIG_FB */
76 static void backlight_generate_event(struct backlight_device
*bd
,
77 enum backlight_update_reason reason
)
82 case BACKLIGHT_UPDATE_SYSFS
:
83 envp
[0] = "SOURCE=sysfs";
85 case BACKLIGHT_UPDATE_HOTKEY
:
86 envp
[0] = "SOURCE=hotkey";
89 envp
[0] = "SOURCE=unknown";
93 kobject_uevent_env(&bd
->dev
.kobj
, KOBJ_CHANGE
, envp
);
96 static ssize_t
backlight_show_power(struct device
*dev
,
97 struct device_attribute
*attr
,char *buf
)
99 struct backlight_device
*bd
= to_backlight_device(dev
);
101 return sprintf(buf
, "%d\n", bd
->props
.power
);
104 static ssize_t
backlight_store_power(struct device
*dev
,
105 struct device_attribute
*attr
, const char *buf
, size_t count
)
108 struct backlight_device
*bd
= to_backlight_device(dev
);
111 rc
= strict_strtoul(buf
, 0, &power
);
116 mutex_lock(&bd
->ops_lock
);
118 pr_debug("backlight: set power to %lu\n", power
);
119 if (bd
->props
.power
!= power
) {
120 bd
->props
.power
= power
;
121 backlight_update_status(bd
);
125 mutex_unlock(&bd
->ops_lock
);
130 static ssize_t
backlight_show_brightness(struct device
*dev
,
131 struct device_attribute
*attr
, char *buf
)
133 struct backlight_device
*bd
= to_backlight_device(dev
);
135 return sprintf(buf
, "%d\n", bd
->props
.brightness
);
138 static ssize_t
backlight_store_brightness(struct device
*dev
,
139 struct device_attribute
*attr
, const char *buf
, size_t count
)
142 struct backlight_device
*bd
= to_backlight_device(dev
);
143 unsigned long brightness
;
145 rc
= strict_strtoul(buf
, 0, &brightness
);
151 mutex_lock(&bd
->ops_lock
);
153 if (brightness
> bd
->props
.max_brightness
)
156 pr_debug("backlight: set brightness to %lu\n",
158 bd
->props
.brightness
= brightness
;
159 backlight_update_status(bd
);
163 mutex_unlock(&bd
->ops_lock
);
165 backlight_generate_event(bd
, BACKLIGHT_UPDATE_SYSFS
);
170 static ssize_t
backlight_show_max_brightness(struct device
*dev
,
171 struct device_attribute
*attr
, char *buf
)
173 struct backlight_device
*bd
= to_backlight_device(dev
);
175 return sprintf(buf
, "%d\n", bd
->props
.max_brightness
);
178 static ssize_t
backlight_show_actual_brightness(struct device
*dev
,
179 struct device_attribute
*attr
, char *buf
)
182 struct backlight_device
*bd
= to_backlight_device(dev
);
184 mutex_lock(&bd
->ops_lock
);
185 if (bd
->ops
&& bd
->ops
->get_brightness
)
186 rc
= sprintf(buf
, "%d\n", bd
->ops
->get_brightness(bd
));
187 mutex_unlock(&bd
->ops_lock
);
192 static struct class *backlight_class
;
194 static int backlight_suspend(struct device
*dev
, pm_message_t state
)
196 struct backlight_device
*bd
= to_backlight_device(dev
);
198 if (bd
->ops
->options
& BL_CORE_SUSPENDRESUME
) {
199 mutex_lock(&bd
->ops_lock
);
200 bd
->props
.state
|= BL_CORE_SUSPENDED
;
201 backlight_update_status(bd
);
202 mutex_unlock(&bd
->ops_lock
);
208 static int backlight_resume(struct device
*dev
)
210 struct backlight_device
*bd
= to_backlight_device(dev
);
212 if (bd
->ops
->options
& BL_CORE_SUSPENDRESUME
) {
213 mutex_lock(&bd
->ops_lock
);
214 bd
->props
.state
&= ~BL_CORE_SUSPENDED
;
215 backlight_update_status(bd
);
216 mutex_unlock(&bd
->ops_lock
);
222 static void bl_device_release(struct device
*dev
)
224 struct backlight_device
*bd
= to_backlight_device(dev
);
228 static struct device_attribute bl_device_attributes
[] = {
229 __ATTR(bl_power
, 0644, backlight_show_power
, backlight_store_power
),
230 __ATTR(brightness
, 0644, backlight_show_brightness
,
231 backlight_store_brightness
),
232 __ATTR(actual_brightness
, 0444, backlight_show_actual_brightness
,
234 __ATTR(max_brightness
, 0444, backlight_show_max_brightness
, NULL
),
239 * backlight_force_update - tell the backlight subsystem that hardware state
241 * @bd: the backlight device to update
243 * Updates the internal state of the backlight in response to a hardware event,
244 * and generate a uevent to notify userspace
246 void backlight_force_update(struct backlight_device
*bd
,
247 enum backlight_update_reason reason
)
249 mutex_lock(&bd
->ops_lock
);
250 if (bd
->ops
&& bd
->ops
->get_brightness
)
251 bd
->props
.brightness
= bd
->ops
->get_brightness(bd
);
252 mutex_unlock(&bd
->ops_lock
);
253 backlight_generate_event(bd
, reason
);
255 EXPORT_SYMBOL(backlight_force_update
);
258 * backlight_device_register - create and register a new object of
259 * backlight_device class.
260 * @name: the name of the new object(must be the same as the name of the
261 * respective framebuffer device).
262 * @parent: a pointer to the parent device
263 * @devdata: an optional pointer to be stored for private driver use. The
264 * methods may retrieve it by using bl_get_data(bd).
265 * @ops: the backlight operations structure.
267 * Creates and registers new backlight device. Returns either an
268 * ERR_PTR() or a pointer to the newly allocated device.
270 struct backlight_device
*backlight_device_register(const char *name
,
271 struct device
*parent
, void *devdata
, struct backlight_ops
*ops
)
273 struct backlight_device
*new_bd
;
276 pr_debug("backlight_device_register: name=%s\n", name
);
278 new_bd
= kzalloc(sizeof(struct backlight_device
), GFP_KERNEL
);
280 return ERR_PTR(-ENOMEM
);
282 mutex_init(&new_bd
->update_lock
);
283 mutex_init(&new_bd
->ops_lock
);
285 new_bd
->dev
.class = backlight_class
;
286 new_bd
->dev
.parent
= parent
;
287 new_bd
->dev
.release
= bl_device_release
;
288 dev_set_name(&new_bd
->dev
, name
);
289 dev_set_drvdata(&new_bd
->dev
, devdata
);
291 rc
= device_register(&new_bd
->dev
);
297 rc
= backlight_register_fb(new_bd
);
299 device_unregister(&new_bd
->dev
);
305 #ifdef CONFIG_PMAC_BACKLIGHT
306 mutex_lock(&pmac_backlight_mutex
);
308 pmac_backlight
= new_bd
;
309 mutex_unlock(&pmac_backlight_mutex
);
314 EXPORT_SYMBOL(backlight_device_register
);
317 * backlight_device_unregister - unregisters a backlight device object.
318 * @bd: the backlight device object to be unregistered and freed.
320 * Unregisters a previously registered via backlight_device_register object.
322 void backlight_device_unregister(struct backlight_device
*bd
)
327 #ifdef CONFIG_PMAC_BACKLIGHT
328 mutex_lock(&pmac_backlight_mutex
);
329 if (pmac_backlight
== bd
)
330 pmac_backlight
= NULL
;
331 mutex_unlock(&pmac_backlight_mutex
);
333 mutex_lock(&bd
->ops_lock
);
335 mutex_unlock(&bd
->ops_lock
);
337 backlight_unregister_fb(bd
);
338 device_unregister(&bd
->dev
);
340 EXPORT_SYMBOL(backlight_device_unregister
);
342 static void __exit
backlight_class_exit(void)
344 class_destroy(backlight_class
);
347 static int __init
backlight_class_init(void)
349 backlight_class
= class_create(THIS_MODULE
, "backlight");
350 if (IS_ERR(backlight_class
)) {
351 printk(KERN_WARNING
"Unable to create backlight class; errno = %ld\n",
352 PTR_ERR(backlight_class
));
353 return PTR_ERR(backlight_class
);
356 backlight_class
->dev_attrs
= bl_device_attributes
;
357 backlight_class
->suspend
= backlight_suspend
;
358 backlight_class
->resume
= backlight_resume
;
363 * if this is compiled into the kernel, we need to ensure that the
364 * class is registered before users of the class try to register lcd's
366 postcore_initcall(backlight_class_init
);
367 module_exit(backlight_class_exit
);
369 MODULE_LICENSE("GPL");
370 MODULE_AUTHOR("Jamey Hicks <jamey.hicks@hp.com>, Andrew Zabolotny <zap@homelink.ru>");
371 MODULE_DESCRIPTION("Backlight Lowlevel Control Abstraction");