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