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/lcd.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#if defined(CONFIG_FB) || (defined(CONFIG_FB_MODULE) && \
21 defined(CONFIG_LCD_CLASS_DEVICE_MODULE))
22
23
24
25
26static int fb_notifier_callback(struct notifier_block *self,
27 unsigned long event, void *data)
28{
29 struct lcd_device *ld;
30 struct fb_event *evdata = data;
31
32
33 switch (event) {
34 case FB_EVENT_BLANK:
35 case FB_EVENT_MODE_CHANGE:
36 case FB_EVENT_MODE_CHANGE_ALL:
37 case FB_EARLY_EVENT_BLANK:
38 case FB_R_EARLY_EVENT_BLANK:
39 break;
40 default:
41 return 0;
42 }
43
44 ld = container_of(self, struct lcd_device, fb_notif);
45 if (!ld->ops)
46 return 0;
47
48 mutex_lock(&ld->ops_lock);
49 if (!ld->ops->check_fb || ld->ops->check_fb(ld, evdata->info)) {
50 if (event == FB_EVENT_BLANK) {
51 if (ld->ops->set_power)
52 ld->ops->set_power(ld, *(int *)evdata->data);
53 } else if (event == FB_EARLY_EVENT_BLANK) {
54 if (ld->ops->early_set_power)
55 ld->ops->early_set_power(ld,
56 *(int *)evdata->data);
57 } else if (event == FB_R_EARLY_EVENT_BLANK) {
58 if (ld->ops->r_early_set_power)
59 ld->ops->r_early_set_power(ld,
60 *(int *)evdata->data);
61 } else {
62 if (ld->ops->set_mode)
63 ld->ops->set_mode(ld, evdata->data);
64 }
65 }
66 mutex_unlock(&ld->ops_lock);
67 return 0;
68}
69
70static int lcd_register_fb(struct lcd_device *ld)
71{
72 memset(&ld->fb_notif, 0, sizeof(ld->fb_notif));
73 ld->fb_notif.notifier_call = fb_notifier_callback;
74 return fb_register_client(&ld->fb_notif);
75}
76
77static void lcd_unregister_fb(struct lcd_device *ld)
78{
79 fb_unregister_client(&ld->fb_notif);
80}
81#else
82static int lcd_register_fb(struct lcd_device *ld)
83{
84 return 0;
85}
86
87static inline void lcd_unregister_fb(struct lcd_device *ld)
88{
89}
90#endif
91
92static ssize_t lcd_show_power(struct device *dev, struct device_attribute *attr,
93 char *buf)
94{
95 int rc;
96 struct lcd_device *ld = to_lcd_device(dev);
97
98 mutex_lock(&ld->ops_lock);
99 if (ld->ops && ld->ops->get_power)
100 rc = sprintf(buf, "%d\n", ld->ops->get_power(ld));
101 else
102 rc = -ENXIO;
103 mutex_unlock(&ld->ops_lock);
104
105 return rc;
106}
107
108static ssize_t lcd_store_power(struct device *dev,
109 struct device_attribute *attr, const char *buf, size_t count)
110{
111 int rc;
112 struct lcd_device *ld = to_lcd_device(dev);
113 unsigned long power;
114
115 rc = kstrtoul(buf, 0, &power);
116 if (rc)
117 return rc;
118
119 rc = -ENXIO;
120
121 mutex_lock(&ld->ops_lock);
122 if (ld->ops && ld->ops->set_power) {
123 pr_debug("set power to %lu\n", power);
124 ld->ops->set_power(ld, power);
125 rc = count;
126 }
127 mutex_unlock(&ld->ops_lock);
128
129 return rc;
130}
131
132static ssize_t lcd_show_contrast(struct device *dev,
133 struct device_attribute *attr, char *buf)
134{
135 int rc = -ENXIO;
136 struct lcd_device *ld = to_lcd_device(dev);
137
138 mutex_lock(&ld->ops_lock);
139 if (ld->ops && ld->ops->get_contrast)
140 rc = sprintf(buf, "%d\n", ld->ops->get_contrast(ld));
141 mutex_unlock(&ld->ops_lock);
142
143 return rc;
144}
145
146static ssize_t lcd_store_contrast(struct device *dev,
147 struct device_attribute *attr, const char *buf, size_t count)
148{
149 int rc;
150 struct lcd_device *ld = to_lcd_device(dev);
151 unsigned long contrast;
152
153 rc = kstrtoul(buf, 0, &contrast);
154 if (rc)
155 return rc;
156
157 rc = -ENXIO;
158
159 mutex_lock(&ld->ops_lock);
160 if (ld->ops && ld->ops->set_contrast) {
161 pr_debug("set contrast to %lu\n", contrast);
162 ld->ops->set_contrast(ld, contrast);
163 rc = count;
164 }
165 mutex_unlock(&ld->ops_lock);
166
167 return rc;
168}
169
170static ssize_t lcd_show_max_contrast(struct device *dev,
171 struct device_attribute *attr, char *buf)
172{
173 struct lcd_device *ld = to_lcd_device(dev);
174
175 return sprintf(buf, "%d\n", ld->props.max_contrast);
176}
177
178static struct class *lcd_class;
179
180static void lcd_device_release(struct device *dev)
181{
182 struct lcd_device *ld = to_lcd_device(dev);
183 kfree(ld);
184}
185
186static struct device_attribute lcd_device_attributes[] = {
187 __ATTR(lcd_power, 0644, lcd_show_power, lcd_store_power),
188 __ATTR(contrast, 0644, lcd_show_contrast, lcd_store_contrast),
189 __ATTR(max_contrast, 0444, lcd_show_max_contrast, NULL),
190 __ATTR_NULL,
191};
192
193
194
195
196
197
198
199
200
201
202
203
204struct lcd_device *lcd_device_register(const char *name, struct device *parent,
205 void *devdata, struct lcd_ops *ops)
206{
207 struct lcd_device *new_ld;
208 int rc;
209
210 pr_debug("lcd_device_register: name=%s\n", name);
211
212 new_ld = kzalloc(sizeof(struct lcd_device), GFP_KERNEL);
213 if (!new_ld)
214 return ERR_PTR(-ENOMEM);
215
216 mutex_init(&new_ld->ops_lock);
217 mutex_init(&new_ld->update_lock);
218
219 new_ld->dev.class = lcd_class;
220 new_ld->dev.parent = parent;
221 new_ld->dev.release = lcd_device_release;
222 dev_set_name(&new_ld->dev, "%s", name);
223 dev_set_drvdata(&new_ld->dev, devdata);
224
225 rc = device_register(&new_ld->dev);
226 if (rc) {
227 kfree(new_ld);
228 return ERR_PTR(rc);
229 }
230
231 rc = lcd_register_fb(new_ld);
232 if (rc) {
233 device_unregister(&new_ld->dev);
234 return ERR_PTR(rc);
235 }
236
237 new_ld->ops = ops;
238
239 return new_ld;
240}
241EXPORT_SYMBOL(lcd_device_register);
242
243
244
245
246
247
248
249void lcd_device_unregister(struct lcd_device *ld)
250{
251 if (!ld)
252 return;
253
254 mutex_lock(&ld->ops_lock);
255 ld->ops = NULL;
256 mutex_unlock(&ld->ops_lock);
257 lcd_unregister_fb(ld);
258
259 device_unregister(&ld->dev);
260}
261EXPORT_SYMBOL(lcd_device_unregister);
262
263static void devm_lcd_device_release(struct device *dev, void *res)
264{
265 struct lcd_device *lcd = *(struct lcd_device **)res;
266
267 lcd_device_unregister(lcd);
268}
269
270static int devm_lcd_device_match(struct device *dev, void *res, void *data)
271{
272 struct lcd_device **r = res;
273
274 return *r == data;
275}
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291struct lcd_device *devm_lcd_device_register(struct device *dev,
292 const char *name, struct device *parent,
293 void *devdata, struct lcd_ops *ops)
294{
295 struct lcd_device **ptr, *lcd;
296
297 ptr = devres_alloc(devm_lcd_device_release, sizeof(*ptr), GFP_KERNEL);
298 if (!ptr)
299 return ERR_PTR(-ENOMEM);
300
301 lcd = lcd_device_register(name, parent, devdata, ops);
302 if (!IS_ERR(lcd)) {
303 *ptr = lcd;
304 devres_add(dev, ptr);
305 } else {
306 devres_free(ptr);
307 }
308
309 return lcd;
310}
311EXPORT_SYMBOL(devm_lcd_device_register);
312
313
314
315
316
317
318
319
320
321
322void devm_lcd_device_unregister(struct device *dev, struct lcd_device *ld)
323{
324 int rc;
325
326 rc = devres_release(dev, devm_lcd_device_release,
327 devm_lcd_device_match, ld);
328 WARN_ON(rc);
329}
330EXPORT_SYMBOL(devm_lcd_device_unregister);
331
332
333static void __exit lcd_class_exit(void)
334{
335 class_destroy(lcd_class);
336}
337
338static int __init lcd_class_init(void)
339{
340 lcd_class = class_create(THIS_MODULE, "lcd");
341 if (IS_ERR(lcd_class)) {
342 pr_warn("Unable to create backlight class; errno = %ld\n",
343 PTR_ERR(lcd_class));
344 return PTR_ERR(lcd_class);
345 }
346
347 lcd_class->dev_attrs = lcd_device_attributes;
348 return 0;
349}
350
351
352
353
354
355postcore_initcall(lcd_class_init);
356module_exit(lcd_class_exit);
357
358MODULE_LICENSE("GPL");
359MODULE_AUTHOR("Jamey Hicks <jamey.hicks@hp.com>, Andrew Zabolotny <zap@homelink.ru>");
360MODULE_DESCRIPTION("LCD Lowlevel Control Abstraction");
361