1
2
3
4
5
6
7
8#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9
10#include <linux/module.h>
11#include <linux/init.h>
12#include <linux/device.h>
13#include <linux/backlight.h>
14#include <linux/notifier.h>
15#include <linux/ctype.h>
16#include <linux/err.h>
17#include <linux/fb.h>
18#include <linux/slab.h>
19
20#ifdef CONFIG_PMAC_BACKLIGHT
21#include <asm/backlight.h>
22#endif
23
24static const char *const backlight_types[] = {
25 [BACKLIGHT_RAW] = "raw",
26 [BACKLIGHT_PLATFORM] = "platform",
27 [BACKLIGHT_FIRMWARE] = "firmware",
28};
29
30#if defined(CONFIG_FB) || (defined(CONFIG_FB_MODULE) && \
31 defined(CONFIG_BACKLIGHT_CLASS_DEVICE_MODULE))
32
33
34
35
36static int fb_notifier_callback(struct notifier_block *self,
37 unsigned long event, void *data)
38{
39 struct backlight_device *bd;
40 struct fb_event *evdata = data;
41
42
43 if (event != FB_EVENT_BLANK && event != FB_EVENT_CONBLANK)
44 return 0;
45
46 bd = container_of(self, struct backlight_device, fb_notif);
47 mutex_lock(&bd->ops_lock);
48 if (bd->ops)
49 if (!bd->ops->check_fb ||
50 bd->ops->check_fb(bd, evdata->info)) {
51 bd->props.fb_blank = *(int *)evdata->data;
52 if (bd->props.fb_blank == FB_BLANK_UNBLANK)
53 bd->props.state &= ~BL_CORE_FBBLANK;
54 else
55 bd->props.state |= BL_CORE_FBBLANK;
56 backlight_update_status(bd);
57 }
58 mutex_unlock(&bd->ops_lock);
59 return 0;
60}
61
62static int backlight_register_fb(struct backlight_device *bd)
63{
64 memset(&bd->fb_notif, 0, sizeof(bd->fb_notif));
65 bd->fb_notif.notifier_call = fb_notifier_callback;
66
67 return fb_register_client(&bd->fb_notif);
68}
69
70static void backlight_unregister_fb(struct backlight_device *bd)
71{
72 fb_unregister_client(&bd->fb_notif);
73}
74#else
75static inline int backlight_register_fb(struct backlight_device *bd)
76{
77 return 0;
78}
79
80static inline void backlight_unregister_fb(struct backlight_device *bd)
81{
82}
83#endif
84
85static void backlight_generate_event(struct backlight_device *bd,
86 enum backlight_update_reason reason)
87{
88 char *envp[2];
89
90 switch (reason) {
91 case BACKLIGHT_UPDATE_SYSFS:
92 envp[0] = "SOURCE=sysfs";
93 break;
94 case BACKLIGHT_UPDATE_HOTKEY:
95 envp[0] = "SOURCE=hotkey";
96 break;
97 default:
98 envp[0] = "SOURCE=unknown";
99 break;
100 }
101 envp[1] = NULL;
102 kobject_uevent_env(&bd->dev.kobj, KOBJ_CHANGE, envp);
103 sysfs_notify(&bd->dev.kobj, NULL, "actual_brightness");
104}
105
106static ssize_t backlight_show_power(struct device *dev,
107 struct device_attribute *attr, char *buf)
108{
109 struct backlight_device *bd = to_backlight_device(dev);
110
111 return sprintf(buf, "%d\n", bd->props.power);
112}
113
114static ssize_t backlight_store_power(struct device *dev,
115 struct device_attribute *attr, const char *buf, size_t count)
116{
117 int rc;
118 struct backlight_device *bd = to_backlight_device(dev);
119 unsigned long power;
120
121 rc = kstrtoul(buf, 0, &power);
122 if (rc)
123 return rc;
124
125 rc = -ENXIO;
126 mutex_lock(&bd->ops_lock);
127 if (bd->ops) {
128 pr_debug("set power to %lu\n", power);
129 if (bd->props.power != power) {
130 bd->props.power = power;
131 backlight_update_status(bd);
132 }
133 rc = count;
134 }
135 mutex_unlock(&bd->ops_lock);
136
137 return rc;
138}
139
140static ssize_t backlight_show_brightness(struct device *dev,
141 struct device_attribute *attr, char *buf)
142{
143 struct backlight_device *bd = to_backlight_device(dev);
144
145 return sprintf(buf, "%d\n", bd->props.brightness);
146}
147
148static ssize_t backlight_store_brightness(struct device *dev,
149 struct device_attribute *attr, const char *buf, size_t count)
150{
151 int rc;
152 struct backlight_device *bd = to_backlight_device(dev);
153 unsigned long brightness;
154
155 rc = kstrtoul(buf, 0, &brightness);
156 if (rc)
157 return rc;
158
159 rc = -ENXIO;
160
161 mutex_lock(&bd->ops_lock);
162 if (bd->ops) {
163 if (brightness > bd->props.max_brightness)
164 rc = -EINVAL;
165 else {
166 pr_debug("set brightness to %lu\n", brightness);
167 bd->props.brightness = brightness;
168 backlight_update_status(bd);
169 rc = count;
170 }
171 }
172 mutex_unlock(&bd->ops_lock);
173
174 backlight_generate_event(bd, BACKLIGHT_UPDATE_SYSFS);
175
176 return rc;
177}
178
179static ssize_t backlight_show_type(struct device *dev,
180 struct device_attribute *attr, char *buf)
181{
182 struct backlight_device *bd = to_backlight_device(dev);
183
184 return sprintf(buf, "%s\n", backlight_types[bd->props.type]);
185}
186
187static ssize_t backlight_show_max_brightness(struct device *dev,
188 struct device_attribute *attr, char *buf)
189{
190 struct backlight_device *bd = to_backlight_device(dev);
191
192 return sprintf(buf, "%d\n", bd->props.max_brightness);
193}
194
195static ssize_t backlight_show_actual_brightness(struct device *dev,
196 struct device_attribute *attr, char *buf)
197{
198 int rc = -ENXIO;
199 struct backlight_device *bd = to_backlight_device(dev);
200
201 mutex_lock(&bd->ops_lock);
202 if (bd->ops && bd->ops->get_brightness)
203 rc = sprintf(buf, "%d\n", bd->ops->get_brightness(bd));
204 mutex_unlock(&bd->ops_lock);
205
206 return rc;
207}
208
209static struct class *backlight_class;
210
211#ifdef CONFIG_PM_SLEEP
212static int backlight_suspend(struct device *dev)
213{
214 struct backlight_device *bd = to_backlight_device(dev);
215
216 mutex_lock(&bd->ops_lock);
217 if (bd->ops && bd->ops->options & BL_CORE_SUSPENDRESUME) {
218 bd->props.state |= BL_CORE_SUSPENDED;
219 backlight_update_status(bd);
220 }
221 mutex_unlock(&bd->ops_lock);
222
223 return 0;
224}
225
226static int backlight_resume(struct device *dev)
227{
228 struct backlight_device *bd = to_backlight_device(dev);
229
230 mutex_lock(&bd->ops_lock);
231 if (bd->ops && bd->ops->options & BL_CORE_SUSPENDRESUME) {
232 bd->props.state &= ~BL_CORE_SUSPENDED;
233 backlight_update_status(bd);
234 }
235 mutex_unlock(&bd->ops_lock);
236
237 return 0;
238}
239#endif
240
241static SIMPLE_DEV_PM_OPS(backlight_class_dev_pm_ops, backlight_suspend,
242 backlight_resume);
243
244static void bl_device_release(struct device *dev)
245{
246 struct backlight_device *bd = to_backlight_device(dev);
247 kfree(bd);
248}
249
250static struct device_attribute bl_device_attributes[] = {
251 __ATTR(bl_power, 0644, backlight_show_power, backlight_store_power),
252 __ATTR(brightness, 0644, backlight_show_brightness,
253 backlight_store_brightness),
254 __ATTR(actual_brightness, 0444, backlight_show_actual_brightness,
255 NULL),
256 __ATTR(max_brightness, 0444, backlight_show_max_brightness, NULL),
257 __ATTR(type, 0444, backlight_show_type, NULL),
258 __ATTR_NULL,
259};
260
261
262
263
264
265
266
267
268
269void backlight_force_update(struct backlight_device *bd,
270 enum backlight_update_reason reason)
271{
272 mutex_lock(&bd->ops_lock);
273 if (bd->ops && bd->ops->get_brightness)
274 bd->props.brightness = bd->ops->get_brightness(bd);
275 mutex_unlock(&bd->ops_lock);
276 backlight_generate_event(bd, reason);
277}
278EXPORT_SYMBOL(backlight_force_update);
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293struct backlight_device *backlight_device_register(const char *name,
294 struct device *parent, void *devdata, const struct backlight_ops *ops,
295 const struct backlight_properties *props)
296{
297 struct backlight_device *new_bd;
298 int rc;
299
300 pr_debug("backlight_device_register: name=%s\n", name);
301
302 new_bd = kzalloc(sizeof(struct backlight_device), GFP_KERNEL);
303 if (!new_bd)
304 return ERR_PTR(-ENOMEM);
305
306 mutex_init(&new_bd->update_lock);
307 mutex_init(&new_bd->ops_lock);
308
309 new_bd->dev.class = backlight_class;
310 new_bd->dev.parent = parent;
311 new_bd->dev.release = bl_device_release;
312 dev_set_name(&new_bd->dev, "%s", name);
313 dev_set_drvdata(&new_bd->dev, devdata);
314
315
316 if (props) {
317 memcpy(&new_bd->props, props,
318 sizeof(struct backlight_properties));
319 if (props->type <= 0 || props->type >= BACKLIGHT_TYPE_MAX) {
320 WARN(1, "%s: invalid backlight type", name);
321 new_bd->props.type = BACKLIGHT_RAW;
322 }
323 } else {
324 new_bd->props.type = BACKLIGHT_RAW;
325 }
326
327 rc = device_register(&new_bd->dev);
328 if (rc) {
329 kfree(new_bd);
330 return ERR_PTR(rc);
331 }
332
333 rc = backlight_register_fb(new_bd);
334 if (rc) {
335 device_unregister(&new_bd->dev);
336 return ERR_PTR(rc);
337 }
338
339 new_bd->ops = ops;
340
341#ifdef CONFIG_PMAC_BACKLIGHT
342 mutex_lock(&pmac_backlight_mutex);
343 if (!pmac_backlight)
344 pmac_backlight = new_bd;
345 mutex_unlock(&pmac_backlight_mutex);
346#endif
347
348 return new_bd;
349}
350EXPORT_SYMBOL(backlight_device_register);
351
352
353
354
355
356
357
358void backlight_device_unregister(struct backlight_device *bd)
359{
360 if (!bd)
361 return;
362
363#ifdef CONFIG_PMAC_BACKLIGHT
364 mutex_lock(&pmac_backlight_mutex);
365 if (pmac_backlight == bd)
366 pmac_backlight = NULL;
367 mutex_unlock(&pmac_backlight_mutex);
368#endif
369 mutex_lock(&bd->ops_lock);
370 bd->ops = NULL;
371 mutex_unlock(&bd->ops_lock);
372
373 backlight_unregister_fb(bd);
374 device_unregister(&bd->dev);
375}
376EXPORT_SYMBOL(backlight_device_unregister);
377
378static void devm_backlight_device_release(struct device *dev, void *res)
379{
380 struct backlight_device *backlight = *(struct backlight_device **)res;
381
382 backlight_device_unregister(backlight);
383}
384
385static int devm_backlight_device_match(struct device *dev, void *res,
386 void *data)
387{
388 struct backlight_device **r = res;
389
390 return *r == data;
391}
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408struct backlight_device *devm_backlight_device_register(struct device *dev,
409 const char *name, struct device *parent, void *devdata,
410 const struct backlight_ops *ops,
411 const struct backlight_properties *props)
412{
413 struct backlight_device **ptr, *backlight;
414
415 ptr = devres_alloc(devm_backlight_device_release, sizeof(*ptr),
416 GFP_KERNEL);
417 if (!ptr)
418 return ERR_PTR(-ENOMEM);
419
420 backlight = backlight_device_register(name, parent, devdata, ops,
421 props);
422 if (!IS_ERR(backlight)) {
423 *ptr = backlight;
424 devres_add(dev, ptr);
425 } else {
426 devres_free(ptr);
427 }
428
429 return backlight;
430}
431EXPORT_SYMBOL(devm_backlight_device_register);
432
433
434
435
436
437
438
439
440
441
442void devm_backlight_device_unregister(struct device *dev,
443 struct backlight_device *bd)
444{
445 int rc;
446
447 rc = devres_release(dev, devm_backlight_device_release,
448 devm_backlight_device_match, bd);
449 WARN_ON(rc);
450}
451EXPORT_SYMBOL(devm_backlight_device_unregister);
452
453#ifdef CONFIG_OF
454static int of_parent_match(struct device *dev, const void *data)
455{
456 return dev->parent && dev->parent->of_node == data;
457}
458
459
460
461
462
463
464
465
466
467
468
469
470
471struct backlight_device *of_find_backlight_by_node(struct device_node *node)
472{
473 struct device *dev;
474
475 dev = class_find_device(backlight_class, NULL, node, of_parent_match);
476
477 return dev ? to_backlight_device(dev) : NULL;
478}
479EXPORT_SYMBOL(of_find_backlight_by_node);
480#endif
481
482static void __exit backlight_class_exit(void)
483{
484 class_destroy(backlight_class);
485}
486
487static int __init backlight_class_init(void)
488{
489 backlight_class = class_create(THIS_MODULE, "backlight");
490 if (IS_ERR(backlight_class)) {
491 pr_warn("Unable to create backlight class; errno = %ld\n",
492 PTR_ERR(backlight_class));
493 return PTR_ERR(backlight_class);
494 }
495
496 backlight_class->dev_attrs = bl_device_attributes;
497 backlight_class->pm = &backlight_class_dev_pm_ops;
498 return 0;
499}
500
501
502
503
504
505postcore_initcall(backlight_class_init);
506module_exit(backlight_class_exit);
507
508MODULE_LICENSE("GPL");
509MODULE_AUTHOR("Jamey Hicks <jamey.hicks@hp.com>, Andrew Zabolotny <zap@homelink.ru>");
510MODULE_DESCRIPTION("Backlight Lowlevel Control Abstraction");
511