1 /* 2 * LCD 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/lcd.h> 12 #include <linux/notifier.h> 13 #include <linux/ctype.h> 14 #include <linux/err.h> 15 #include <linux/fb.h> 16 17 #if defined(CONFIG_FB) || (defined(CONFIG_FB_MODULE) && \ 18 defined(CONFIG_LCD_CLASS_DEVICE_MODULE)) 19 /* This callback gets called when something important happens inside a 20 * framebuffer driver. We're looking if that important event is blanking, 21 * and if it is, we're switching lcd power as well ... 22 */ 23 static int fb_notifier_callback(struct notifier_block *self, 24 unsigned long event, void *data) 25 { 26 struct lcd_device *ld; 27 struct fb_event *evdata = data; 28 29 /* If we aren't interested in this event, skip it immediately ... */ 30 switch (event) { 31 case FB_EVENT_BLANK: 32 case FB_EVENT_MODE_CHANGE: 33 case FB_EVENT_MODE_CHANGE_ALL: 34 break; 35 default: 36 return 0; 37 } 38 39 ld = container_of(self, struct lcd_device, fb_notif); 40 if (!ld->ops) 41 return 0; 42 43 mutex_lock(&ld->ops_lock); 44 if (!ld->ops->check_fb || ld->ops->check_fb(ld, evdata->info)) { 45 if (event == FB_EVENT_BLANK) { 46 if (ld->ops->set_power) 47 ld->ops->set_power(ld, *(int *)evdata->data); 48 } else { 49 if (ld->ops->set_mode) 50 ld->ops->set_mode(ld, evdata->data); 51 } 52 } 53 mutex_unlock(&ld->ops_lock); 54 return 0; 55 } 56 57 static int lcd_register_fb(struct lcd_device *ld) 58 { 59 memset(&ld->fb_notif, 0, sizeof(&ld->fb_notif)); 60 ld->fb_notif.notifier_call = fb_notifier_callback; 61 return fb_register_client(&ld->fb_notif); 62 } 63 64 static void lcd_unregister_fb(struct lcd_device *ld) 65 { 66 fb_unregister_client(&ld->fb_notif); 67 } 68 #else 69 static int lcd_register_fb(struct lcd_device *ld) 70 { 71 return 0; 72 } 73 74 static inline void lcd_unregister_fb(struct lcd_device *ld) 75 { 76 } 77 #endif /* CONFIG_FB */ 78 79 static ssize_t lcd_show_power(struct device *dev, struct device_attribute *attr, 80 char *buf) 81 { 82 int rc; 83 struct lcd_device *ld = to_lcd_device(dev); 84 85 mutex_lock(&ld->ops_lock); 86 if (ld->ops && ld->ops->get_power) 87 rc = sprintf(buf, "%d\n", ld->ops->get_power(ld)); 88 else 89 rc = -ENXIO; 90 mutex_unlock(&ld->ops_lock); 91 92 return rc; 93 } 94 95 static ssize_t lcd_store_power(struct device *dev, 96 struct device_attribute *attr, const char *buf, size_t count) 97 { 98 int rc = -ENXIO; 99 char *endp; 100 struct lcd_device *ld = to_lcd_device(dev); 101 int power = simple_strtoul(buf, &endp, 0); 102 size_t size = endp - buf; 103 104 if (*endp && isspace(*endp)) 105 size++; 106 if (size != count) 107 return -EINVAL; 108 109 mutex_lock(&ld->ops_lock); 110 if (ld->ops && ld->ops->set_power) { 111 pr_debug("lcd: set power to %d\n", power); 112 ld->ops->set_power(ld, power); 113 rc = count; 114 } 115 mutex_unlock(&ld->ops_lock); 116 117 return rc; 118 } 119 120 static ssize_t lcd_show_contrast(struct device *dev, 121 struct device_attribute *attr, char *buf) 122 { 123 int rc = -ENXIO; 124 struct lcd_device *ld = to_lcd_device(dev); 125 126 mutex_lock(&ld->ops_lock); 127 if (ld->ops && ld->ops->get_contrast) 128 rc = sprintf(buf, "%d\n", ld->ops->get_contrast(ld)); 129 mutex_unlock(&ld->ops_lock); 130 131 return rc; 132 } 133 134 static ssize_t lcd_store_contrast(struct device *dev, 135 struct device_attribute *attr, const char *buf, size_t count) 136 { 137 int rc = -ENXIO; 138 char *endp; 139 struct lcd_device *ld = to_lcd_device(dev); 140 int contrast = simple_strtoul(buf, &endp, 0); 141 size_t size = endp - buf; 142 143 if (*endp && isspace(*endp)) 144 size++; 145 if (size != count) 146 return -EINVAL; 147 148 mutex_lock(&ld->ops_lock); 149 if (ld->ops && ld->ops->set_contrast) { 150 pr_debug("lcd: set contrast to %d\n", contrast); 151 ld->ops->set_contrast(ld, contrast); 152 rc = count; 153 } 154 mutex_unlock(&ld->ops_lock); 155 156 return rc; 157 } 158 159 static ssize_t lcd_show_max_contrast(struct device *dev, 160 struct device_attribute *attr, char *buf) 161 { 162 struct lcd_device *ld = to_lcd_device(dev); 163 164 return sprintf(buf, "%d\n", ld->props.max_contrast); 165 } 166 167 static struct class *lcd_class; 168 169 static void lcd_device_release(struct device *dev) 170 { 171 struct lcd_device *ld = to_lcd_device(dev); 172 kfree(ld); 173 } 174 175 static struct device_attribute lcd_device_attributes[] = { 176 __ATTR(lcd_power, 0644, lcd_show_power, lcd_store_power), 177 __ATTR(contrast, 0644, lcd_show_contrast, lcd_store_contrast), 178 __ATTR(max_contrast, 0444, lcd_show_max_contrast, NULL), 179 __ATTR_NULL, 180 }; 181 182 /** 183 * lcd_device_register - register a new object of lcd_device class. 184 * @name: the name of the new object(must be the same as the name of the 185 * respective framebuffer device). 186 * @devdata: an optional pointer to be stored in the device. The 187 * methods may retrieve it by using lcd_get_data(ld). 188 * @ops: the lcd operations structure. 189 * 190 * Creates and registers a new lcd device. Returns either an ERR_PTR() 191 * or a pointer to the newly allocated device. 192 */ 193 struct lcd_device *lcd_device_register(const char *name, struct device *parent, 194 void *devdata, struct lcd_ops *ops) 195 { 196 struct lcd_device *new_ld; 197 int rc; 198 199 pr_debug("lcd_device_register: name=%s\n", name); 200 201 new_ld = kzalloc(sizeof(struct lcd_device), GFP_KERNEL); 202 if (!new_ld) 203 return ERR_PTR(-ENOMEM); 204 205 mutex_init(&new_ld->ops_lock); 206 mutex_init(&new_ld->update_lock); 207 208 new_ld->dev.class = lcd_class; 209 new_ld->dev.parent = parent; 210 new_ld->dev.release = lcd_device_release; 211 dev_set_name(&new_ld->dev, name); 212 dev_set_drvdata(&new_ld->dev, devdata); 213 214 rc = device_register(&new_ld->dev); 215 if (rc) { 216 kfree(new_ld); 217 return ERR_PTR(rc); 218 } 219 220 rc = lcd_register_fb(new_ld); 221 if (rc) { 222 device_unregister(&new_ld->dev); 223 return ERR_PTR(rc); 224 } 225 226 new_ld->ops = ops; 227 228 return new_ld; 229 } 230 EXPORT_SYMBOL(lcd_device_register); 231 232 /** 233 * lcd_device_unregister - unregisters a object of lcd_device class. 234 * @ld: the lcd device object to be unregistered and freed. 235 * 236 * Unregisters a previously registered via lcd_device_register object. 237 */ 238 void lcd_device_unregister(struct lcd_device *ld) 239 { 240 if (!ld) 241 return; 242 243 mutex_lock(&ld->ops_lock); 244 ld->ops = NULL; 245 mutex_unlock(&ld->ops_lock); 246 lcd_unregister_fb(ld); 247 248 device_unregister(&ld->dev); 249 } 250 EXPORT_SYMBOL(lcd_device_unregister); 251 252 static void __exit lcd_class_exit(void) 253 { 254 class_destroy(lcd_class); 255 } 256 257 static int __init lcd_class_init(void) 258 { 259 lcd_class = class_create(THIS_MODULE, "lcd"); 260 if (IS_ERR(lcd_class)) { 261 printk(KERN_WARNING "Unable to create backlight class; errno = %ld\n", 262 PTR_ERR(lcd_class)); 263 return PTR_ERR(lcd_class); 264 } 265 266 lcd_class->dev_attrs = lcd_device_attributes; 267 return 0; 268 } 269 270 /* 271 * if this is compiled into the kernel, we need to ensure that the 272 * class is registered before users of the class try to register lcd's 273 */ 274 postcore_initcall(lcd_class_init); 275 module_exit(lcd_class_exit); 276 277 MODULE_LICENSE("GPL"); 278 MODULE_AUTHOR("Jamey Hicks <jamey.hicks@hp.com>, Andrew Zabolotny <zap@homelink.ru>"); 279 MODULE_DESCRIPTION("LCD Lowlevel Control Abstraction"); 280