1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * lm3533-bl.c -- LM3533 Backlight driver 4 * 5 * Copyright (C) 2011-2012 Texas Instruments 6 * 7 * Author: Johan Hovold <jhovold@gmail.com> 8 */ 9 10 #include <linux/module.h> 11 #include <linux/init.h> 12 #include <linux/platform_device.h> 13 #include <linux/backlight.h> 14 #include <linux/fb.h> 15 #include <linux/slab.h> 16 17 #include <linux/mfd/lm3533.h> 18 19 20 #define LM3533_HVCTRLBANK_COUNT 2 21 #define LM3533_BL_MAX_BRIGHTNESS 255 22 23 #define LM3533_REG_CTRLBANK_AB_BCONF 0x1a 24 25 26 struct lm3533_bl { 27 struct lm3533 *lm3533; 28 struct lm3533_ctrlbank cb; 29 struct backlight_device *bd; 30 int id; 31 }; 32 33 34 static inline int lm3533_bl_get_ctrlbank_id(struct lm3533_bl *bl) 35 { 36 return bl->id; 37 } 38 39 static int lm3533_bl_update_status(struct backlight_device *bd) 40 { 41 struct lm3533_bl *bl = bl_get_data(bd); 42 43 return lm3533_ctrlbank_set_brightness(&bl->cb, backlight_get_brightness(bd)); 44 } 45 46 static int lm3533_bl_get_brightness(struct backlight_device *bd) 47 { 48 struct lm3533_bl *bl = bl_get_data(bd); 49 u8 val; 50 int ret; 51 52 ret = lm3533_ctrlbank_get_brightness(&bl->cb, &val); 53 if (ret) 54 return ret; 55 56 return val; 57 } 58 59 static const struct backlight_ops lm3533_bl_ops = { 60 .get_brightness = lm3533_bl_get_brightness, 61 .update_status = lm3533_bl_update_status, 62 }; 63 64 static ssize_t show_id(struct device *dev, 65 struct device_attribute *attr, char *buf) 66 { 67 struct lm3533_bl *bl = dev_get_drvdata(dev); 68 69 return scnprintf(buf, PAGE_SIZE, "%d\n", bl->id); 70 } 71 72 static ssize_t show_als_channel(struct device *dev, 73 struct device_attribute *attr, char *buf) 74 { 75 struct lm3533_bl *bl = dev_get_drvdata(dev); 76 unsigned channel = lm3533_bl_get_ctrlbank_id(bl); 77 78 return scnprintf(buf, PAGE_SIZE, "%u\n", channel); 79 } 80 81 static ssize_t show_als_en(struct device *dev, 82 struct device_attribute *attr, char *buf) 83 { 84 struct lm3533_bl *bl = dev_get_drvdata(dev); 85 int ctrlbank = lm3533_bl_get_ctrlbank_id(bl); 86 u8 val; 87 u8 mask; 88 bool enable; 89 int ret; 90 91 ret = lm3533_read(bl->lm3533, LM3533_REG_CTRLBANK_AB_BCONF, &val); 92 if (ret) 93 return ret; 94 95 mask = 1 << (2 * ctrlbank); 96 enable = val & mask; 97 98 return scnprintf(buf, PAGE_SIZE, "%d\n", enable); 99 } 100 101 static ssize_t store_als_en(struct device *dev, 102 struct device_attribute *attr, 103 const char *buf, size_t len) 104 { 105 struct lm3533_bl *bl = dev_get_drvdata(dev); 106 int ctrlbank = lm3533_bl_get_ctrlbank_id(bl); 107 int enable; 108 u8 val; 109 u8 mask; 110 int ret; 111 112 if (kstrtoint(buf, 0, &enable)) 113 return -EINVAL; 114 115 mask = 1 << (2 * ctrlbank); 116 117 if (enable) 118 val = mask; 119 else 120 val = 0; 121 122 ret = lm3533_update(bl->lm3533, LM3533_REG_CTRLBANK_AB_BCONF, val, 123 mask); 124 if (ret) 125 return ret; 126 127 return len; 128 } 129 130 static ssize_t show_linear(struct device *dev, 131 struct device_attribute *attr, char *buf) 132 { 133 struct lm3533_bl *bl = dev_get_drvdata(dev); 134 u8 val; 135 u8 mask; 136 int linear; 137 int ret; 138 139 ret = lm3533_read(bl->lm3533, LM3533_REG_CTRLBANK_AB_BCONF, &val); 140 if (ret) 141 return ret; 142 143 mask = 1 << (2 * lm3533_bl_get_ctrlbank_id(bl) + 1); 144 145 if (val & mask) 146 linear = 1; 147 else 148 linear = 0; 149 150 return scnprintf(buf, PAGE_SIZE, "%x\n", linear); 151 } 152 153 static ssize_t store_linear(struct device *dev, 154 struct device_attribute *attr, 155 const char *buf, size_t len) 156 { 157 struct lm3533_bl *bl = dev_get_drvdata(dev); 158 unsigned long linear; 159 u8 mask; 160 u8 val; 161 int ret; 162 163 if (kstrtoul(buf, 0, &linear)) 164 return -EINVAL; 165 166 mask = 1 << (2 * lm3533_bl_get_ctrlbank_id(bl) + 1); 167 168 if (linear) 169 val = mask; 170 else 171 val = 0; 172 173 ret = lm3533_update(bl->lm3533, LM3533_REG_CTRLBANK_AB_BCONF, val, 174 mask); 175 if (ret) 176 return ret; 177 178 return len; 179 } 180 181 static ssize_t show_pwm(struct device *dev, 182 struct device_attribute *attr, 183 char *buf) 184 { 185 struct lm3533_bl *bl = dev_get_drvdata(dev); 186 u8 val; 187 int ret; 188 189 ret = lm3533_ctrlbank_get_pwm(&bl->cb, &val); 190 if (ret) 191 return ret; 192 193 return scnprintf(buf, PAGE_SIZE, "%u\n", val); 194 } 195 196 static ssize_t store_pwm(struct device *dev, 197 struct device_attribute *attr, 198 const char *buf, size_t len) 199 { 200 struct lm3533_bl *bl = dev_get_drvdata(dev); 201 u8 val; 202 int ret; 203 204 if (kstrtou8(buf, 0, &val)) 205 return -EINVAL; 206 207 ret = lm3533_ctrlbank_set_pwm(&bl->cb, val); 208 if (ret) 209 return ret; 210 211 return len; 212 } 213 214 static LM3533_ATTR_RO(als_channel); 215 static LM3533_ATTR_RW(als_en); 216 static LM3533_ATTR_RO(id); 217 static LM3533_ATTR_RW(linear); 218 static LM3533_ATTR_RW(pwm); 219 220 static struct attribute *lm3533_bl_attributes[] = { 221 &dev_attr_als_channel.attr, 222 &dev_attr_als_en.attr, 223 &dev_attr_id.attr, 224 &dev_attr_linear.attr, 225 &dev_attr_pwm.attr, 226 NULL, 227 }; 228 229 static umode_t lm3533_bl_attr_is_visible(struct kobject *kobj, 230 struct attribute *attr, int n) 231 { 232 struct device *dev = kobj_to_dev(kobj); 233 struct lm3533_bl *bl = dev_get_drvdata(dev); 234 umode_t mode = attr->mode; 235 236 if (attr == &dev_attr_als_channel.attr || 237 attr == &dev_attr_als_en.attr) { 238 if (!bl->lm3533->have_als) 239 mode = 0; 240 } 241 242 return mode; 243 }; 244 245 static struct attribute_group lm3533_bl_attribute_group = { 246 .is_visible = lm3533_bl_attr_is_visible, 247 .attrs = lm3533_bl_attributes 248 }; 249 250 static int lm3533_bl_setup(struct lm3533_bl *bl, 251 struct lm3533_bl_platform_data *pdata) 252 { 253 int ret; 254 255 ret = lm3533_ctrlbank_set_max_current(&bl->cb, pdata->max_current); 256 if (ret) 257 return ret; 258 259 return lm3533_ctrlbank_set_pwm(&bl->cb, pdata->pwm); 260 } 261 262 static int lm3533_bl_probe(struct platform_device *pdev) 263 { 264 struct lm3533 *lm3533; 265 struct lm3533_bl_platform_data *pdata; 266 struct lm3533_bl *bl; 267 struct backlight_device *bd; 268 struct backlight_properties props; 269 int ret; 270 271 dev_dbg(&pdev->dev, "%s\n", __func__); 272 273 lm3533 = dev_get_drvdata(pdev->dev.parent); 274 if (!lm3533) 275 return -EINVAL; 276 277 pdata = dev_get_platdata(&pdev->dev); 278 if (!pdata) { 279 dev_err(&pdev->dev, "no platform data\n"); 280 return -EINVAL; 281 } 282 283 if (pdev->id < 0 || pdev->id >= LM3533_HVCTRLBANK_COUNT) { 284 dev_err(&pdev->dev, "illegal backlight id %d\n", pdev->id); 285 return -EINVAL; 286 } 287 288 bl = devm_kzalloc(&pdev->dev, sizeof(*bl), GFP_KERNEL); 289 if (!bl) 290 return -ENOMEM; 291 292 bl->lm3533 = lm3533; 293 bl->id = pdev->id; 294 295 bl->cb.lm3533 = lm3533; 296 bl->cb.id = lm3533_bl_get_ctrlbank_id(bl); 297 bl->cb.dev = NULL; /* until registered */ 298 299 memset(&props, 0, sizeof(props)); 300 props.type = BACKLIGHT_RAW; 301 props.max_brightness = LM3533_BL_MAX_BRIGHTNESS; 302 props.brightness = pdata->default_brightness; 303 bd = devm_backlight_device_register(&pdev->dev, pdata->name, 304 pdev->dev.parent, bl, &lm3533_bl_ops, 305 &props); 306 if (IS_ERR(bd)) { 307 dev_err(&pdev->dev, "failed to register backlight device\n"); 308 return PTR_ERR(bd); 309 } 310 311 bl->bd = bd; 312 bl->cb.dev = &bl->bd->dev; 313 314 platform_set_drvdata(pdev, bl); 315 316 ret = sysfs_create_group(&bd->dev.kobj, &lm3533_bl_attribute_group); 317 if (ret < 0) { 318 dev_err(&pdev->dev, "failed to create sysfs attributes\n"); 319 return ret; 320 } 321 322 backlight_update_status(bd); 323 324 ret = lm3533_bl_setup(bl, pdata); 325 if (ret) 326 goto err_sysfs_remove; 327 328 ret = lm3533_ctrlbank_enable(&bl->cb); 329 if (ret) 330 goto err_sysfs_remove; 331 332 return 0; 333 334 err_sysfs_remove: 335 sysfs_remove_group(&bd->dev.kobj, &lm3533_bl_attribute_group); 336 337 return ret; 338 } 339 340 static int lm3533_bl_remove(struct platform_device *pdev) 341 { 342 struct lm3533_bl *bl = platform_get_drvdata(pdev); 343 struct backlight_device *bd = bl->bd; 344 345 dev_dbg(&bd->dev, "%s\n", __func__); 346 347 bd->props.power = FB_BLANK_POWERDOWN; 348 bd->props.brightness = 0; 349 350 lm3533_ctrlbank_disable(&bl->cb); 351 sysfs_remove_group(&bd->dev.kobj, &lm3533_bl_attribute_group); 352 353 return 0; 354 } 355 356 #ifdef CONFIG_PM_SLEEP 357 static int lm3533_bl_suspend(struct device *dev) 358 { 359 struct lm3533_bl *bl = dev_get_drvdata(dev); 360 361 dev_dbg(dev, "%s\n", __func__); 362 363 return lm3533_ctrlbank_disable(&bl->cb); 364 } 365 366 static int lm3533_bl_resume(struct device *dev) 367 { 368 struct lm3533_bl *bl = dev_get_drvdata(dev); 369 370 dev_dbg(dev, "%s\n", __func__); 371 372 return lm3533_ctrlbank_enable(&bl->cb); 373 } 374 #endif 375 376 static SIMPLE_DEV_PM_OPS(lm3533_bl_pm_ops, lm3533_bl_suspend, lm3533_bl_resume); 377 378 static void lm3533_bl_shutdown(struct platform_device *pdev) 379 { 380 struct lm3533_bl *bl = platform_get_drvdata(pdev); 381 382 dev_dbg(&pdev->dev, "%s\n", __func__); 383 384 lm3533_ctrlbank_disable(&bl->cb); 385 } 386 387 static struct platform_driver lm3533_bl_driver = { 388 .driver = { 389 .name = "lm3533-backlight", 390 .pm = &lm3533_bl_pm_ops, 391 }, 392 .probe = lm3533_bl_probe, 393 .remove = lm3533_bl_remove, 394 .shutdown = lm3533_bl_shutdown, 395 }; 396 module_platform_driver(lm3533_bl_driver); 397 398 MODULE_AUTHOR("Johan Hovold <jhovold@gmail.com>"); 399 MODULE_DESCRIPTION("LM3533 Backlight driver"); 400 MODULE_LICENSE("GPL"); 401 MODULE_ALIAS("platform:lm3533-backlight"); 402