projects/linux·blob master · refs

347 lines · 8.2 KiB

1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * LCD Lowlevel Control Abstraction
4 *
5 * Copyright (C) 2003,2004 Hewlett-Packard Company
6 *
7 */
8
9#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
10
11#include <linux/module.h>
12#include <linux/init.h>
13#include <linux/device.h>
14#include <linux/lcd.h>
15#include <linux/notifier.h>
16#include <linux/ctype.h>
17#include <linux/err.h>
18#include <linux/slab.h>
19
20static DEFINE_MUTEX(lcd_dev_list_mutex);
21static LIST_HEAD(lcd_dev_list);
22
23static void lcd_notify_blank(struct lcd_device *ld, struct device *display_dev,
24 int power)
25{
26 guard(mutex)(&ld->ops_lock);
27
28 if (!ld->ops || !ld->ops->set_power)
29 return;
30 if (ld->ops->controls_device && !ld->ops->controls_device(ld, display_dev))
31 return;
32
33 ld->ops->set_power(ld, power);
34}
35
36void lcd_notify_blank_all(struct device *display_dev, int power)
37{
38 struct lcd_device *ld;
39
40 guard(mutex)(&lcd_dev_list_mutex);
41
42 list_for_each_entry(ld, &lcd_dev_list, entry)
43 lcd_notify_blank(ld, display_dev, power);
44}
45EXPORT_SYMBOL(lcd_notify_blank_all);
46
47static void lcd_notify_mode_change(struct lcd_device *ld, struct device *display_dev,
48 unsigned int width, unsigned int height)
49{
50 guard(mutex)(&ld->ops_lock);
51
52 if (!ld->ops || !ld->ops->set_mode)
53 return;
54 if (ld->ops->controls_device && !ld->ops->controls_device(ld, display_dev))
55 return;
56
57 ld->ops->set_mode(ld, width, height);
58}
59
60void lcd_notify_mode_change_all(struct device *display_dev,
61 unsigned int width, unsigned int height)
62{
63 struct lcd_device *ld;
64
65 guard(mutex)(&lcd_dev_list_mutex);
66
67 list_for_each_entry(ld, &lcd_dev_list, entry)
68 lcd_notify_mode_change(ld, display_dev, width, height);
69}
70EXPORT_SYMBOL(lcd_notify_mode_change_all);
71
72static ssize_t lcd_power_show(struct device *dev, struct device_attribute *attr,
73 char *buf)
74{
75 int rc;
76 struct lcd_device *ld = to_lcd_device(dev);
77
78 mutex_lock(&ld->ops_lock);
79 if (ld->ops && ld->ops->get_power)
80 rc = sysfs_emit(buf, "%d\n", ld->ops->get_power(ld));
81 else
82 rc = -ENXIO;
83 mutex_unlock(&ld->ops_lock);
84
85 return rc;
86}
87
88static ssize_t lcd_power_store(struct device *dev,
89 struct device_attribute *attr, const char *buf, size_t count)
90{
91 int rc;
92 struct lcd_device *ld = to_lcd_device(dev);
93 unsigned long power;
94
95 rc = kstrtoul(buf, 0, &power);
96 if (rc)
97 return rc;
98
99 rc = -ENXIO;
100
101 mutex_lock(&ld->ops_lock);
102 if (ld->ops && ld->ops->set_power) {
103 pr_debug("set power to %lu\n", power);
104 ld->ops->set_power(ld, power);
105 rc = count;
106 }
107 mutex_unlock(&ld->ops_lock);
108
109 return rc;
110}
111static DEVICE_ATTR_RW(lcd_power);
112
113static ssize_t contrast_show(struct device *dev,
114 struct device_attribute *attr, char *buf)
115{
116 int rc = -ENXIO;
117 struct lcd_device *ld = to_lcd_device(dev);
118
119 mutex_lock(&ld->ops_lock);
120 if (ld->ops && ld->ops->get_contrast)
121 rc = sysfs_emit(buf, "%d\n", ld->ops->get_contrast(ld));
122 mutex_unlock(&ld->ops_lock);
123
124 return rc;
125}
126
127static ssize_t contrast_store(struct device *dev,
128 struct device_attribute *attr, const char *buf, size_t count)
129{
130 int rc;
131 struct lcd_device *ld = to_lcd_device(dev);
132 unsigned long contrast;
133
134 rc = kstrtoul(buf, 0, &contrast);
135 if (rc)
136 return rc;
137
138 rc = -ENXIO;
139
140 mutex_lock(&ld->ops_lock);
141 if (ld->ops && ld->ops->set_contrast) {
142 pr_debug("set contrast to %lu\n", contrast);
143 ld->ops->set_contrast(ld, contrast);
144 rc = count;
145 }
146 mutex_unlock(&ld->ops_lock);
147
148 return rc;
149}
150static DEVICE_ATTR_RW(contrast);
151
152static ssize_t max_contrast_show(struct device *dev,
153 struct device_attribute *attr, char *buf)
154{
155 struct lcd_device *ld = to_lcd_device(dev);
156
157 return sysfs_emit(buf, "%d\n", ld->props.max_contrast);
158}
159static DEVICE_ATTR_RO(max_contrast);
160
161static void lcd_device_release(struct device *dev)
162{
163 struct lcd_device *ld = to_lcd_device(dev);
164 kfree(ld);
165}
166
167static struct attribute *lcd_device_attrs[] = {
168 &dev_attr_lcd_power.attr,
169 &dev_attr_contrast.attr,
170 &dev_attr_max_contrast.attr,
171 NULL,
172};
173ATTRIBUTE_GROUPS(lcd_device);
174
175static const struct class lcd_class = {
176 .name = "lcd",
177 .dev_groups = lcd_device_groups,
178};
179
180/**
181 * lcd_device_register - register a new object of lcd_device class.
182 * @name: the name of the new object(must be the same as the name of the
183 * respective framebuffer device).
184 * @parent: pointer to the parent's struct device .
185 * @devdata: an optional pointer to be stored in the device. The
186 * methods may retrieve it by using lcd_get_data(ld).
187 * @ops: the lcd operations structure.
188 *
189 * Creates and registers a new lcd device. Returns either an ERR_PTR()
190 * or a pointer to the newly allocated device.
191 */
192struct lcd_device *lcd_device_register(const char *name, struct device *parent,
193 void *devdata, const struct lcd_ops *ops)
194{
195 struct lcd_device *new_ld;
196 int rc;
197
198 pr_debug("lcd_device_register: name=%s\n", name);
199
200 new_ld = kzalloc_obj(struct lcd_device);
201 if (!new_ld)
202 return ERR_PTR(-ENOMEM);
203
204 mutex_init(&new_ld->ops_lock);
205 mutex_init(&new_ld->update_lock);
206
207 new_ld->dev.class = &lcd_class;
208 new_ld->dev.parent = parent;
209 new_ld->dev.release = lcd_device_release;
210 dev_set_name(&new_ld->dev, "%s", name);
211 dev_set_drvdata(&new_ld->dev, devdata);
212
213 new_ld->ops = ops;
214
215 rc = device_register(&new_ld->dev);
216 if (rc) {
217 put_device(&new_ld->dev);
218 return ERR_PTR(rc);
219 }
220
221 guard(mutex)(&lcd_dev_list_mutex);
222 list_add(&new_ld->entry, &lcd_dev_list);
223
224 return new_ld;
225}
226EXPORT_SYMBOL(lcd_device_register);
227
228/**
229 * lcd_device_unregister - unregisters a object of lcd_device class.
230 * @ld: the lcd device object to be unregistered and freed.
231 *
232 * Unregisters a previously registered via lcd_device_register object.
233 */
234void lcd_device_unregister(struct lcd_device *ld)
235{
236 if (!ld)
237 return;
238
239 guard(mutex)(&lcd_dev_list_mutex);
240 list_del(&ld->entry);
241
242 mutex_lock(&ld->ops_lock);
243 ld->ops = NULL;
244 mutex_unlock(&ld->ops_lock);
245
246 device_unregister(&ld->dev);
247}
248EXPORT_SYMBOL(lcd_device_unregister);
249
250static void devm_lcd_device_release(struct device *dev, void *res)
251{
252 struct lcd_device *lcd = *(struct lcd_device **)res;
253
254 lcd_device_unregister(lcd);
255}
256
257static int devm_lcd_device_match(struct device *dev, void *res, void *data)
258{
259 struct lcd_device **r = res;
260
261 return *r == data;
262}
263
264/**
265 * devm_lcd_device_register - resource managed lcd_device_register()
266 * @dev: the device to register
267 * @name: the name of the device
268 * @parent: a pointer to the parent device
269 * @devdata: an optional pointer to be stored for private driver use
270 * @ops: the lcd operations structure
271 *
272 * @return a struct lcd on success, or an ERR_PTR on error
273 *
274 * Managed lcd_device_register(). The lcd_device returned from this function
275 * are automatically freed on driver detach. See lcd_device_register()
276 * for more information.
277 */
278struct lcd_device *devm_lcd_device_register(struct device *dev,
279 const char *name, struct device *parent,
280 void *devdata, const struct lcd_ops *ops)
281{
282 struct lcd_device **ptr, *lcd;
283
284 ptr = devres_alloc(devm_lcd_device_release, sizeof(*ptr), GFP_KERNEL);
285 if (!ptr)
286 return ERR_PTR(-ENOMEM);
287
288 lcd = lcd_device_register(name, parent, devdata, ops);
289 if (!IS_ERR(lcd)) {
290 *ptr = lcd;
291 devres_add(dev, ptr);
292 } else {
293 devres_free(ptr);
294 }
295
296 return lcd;
297}
298EXPORT_SYMBOL(devm_lcd_device_register);
299
300/**
301 * devm_lcd_device_unregister - resource managed lcd_device_unregister()
302 * @dev: the device to unregister
303 * @ld: the lcd device to unregister
304 *
305 * Deallocated a lcd allocated with devm_lcd_device_register(). Normally
306 * this function will not need to be called and the resource management
307 * code will ensure that the resource is freed.
308 */
309void devm_lcd_device_unregister(struct device *dev, struct lcd_device *ld)
310{
311 int rc;
312
313 rc = devres_release(dev, devm_lcd_device_release,
314 devm_lcd_device_match, ld);
315 WARN_ON(rc);
316}
317EXPORT_SYMBOL(devm_lcd_device_unregister);
318
319
320static void __exit lcd_class_exit(void)
321{
322 class_unregister(&lcd_class);
323}
324
325static int __init lcd_class_init(void)
326{
327 int ret;
328
329 ret = class_register(&lcd_class);
330 if (ret) {
331 pr_warn("Unable to create backlight class; errno = %d\n", ret);
332 return ret;
333 }
334
335 return 0;
336}
337
338/*
339 * if this is compiled into the kernel, we need to ensure that the
340 * class is registered before users of the class try to register lcd's
341 */
342postcore_initcall(lcd_class_init);
343module_exit(lcd_class_exit);
344
345MODULE_LICENSE("GPL");
346MODULE_AUTHOR("Jamey Hicks <[email protected]>, Andrew Zabolotny <[email protected]>");
347MODULE_DESCRIPTION("LCD Lowlevel Control Abstraction");