1 /* 2 * Simple driver for Texas Instruments LM3639 Backlight + Flash LED driver chip 3 * Copyright (C) 2012 Texas Instruments 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License version 2 as 7 * published by the Free Software Foundation. 8 * 9 */ 10 #include <linux/module.h> 11 #include <linux/slab.h> 12 #include <linux/i2c.h> 13 #include <linux/leds.h> 14 #include <linux/backlight.h> 15 #include <linux/err.h> 16 #include <linux/delay.h> 17 #include <linux/uaccess.h> 18 #include <linux/interrupt.h> 19 #include <linux/regmap.h> 20 #include <linux/platform_data/lm3639_bl.h> 21 22 #define REG_DEV_ID 0x00 23 #define REG_CHECKSUM 0x01 24 #define REG_BL_CONF_1 0x02 25 #define REG_BL_CONF_2 0x03 26 #define REG_BL_CONF_3 0x04 27 #define REG_BL_CONF_4 0x05 28 #define REG_FL_CONF_1 0x06 29 #define REG_FL_CONF_2 0x07 30 #define REG_FL_CONF_3 0x08 31 #define REG_IO_CTRL 0x09 32 #define REG_ENABLE 0x0A 33 #define REG_FLAG 0x0B 34 #define REG_MAX REG_FLAG 35 36 struct lm3639_chip_data { 37 struct device *dev; 38 struct lm3639_platform_data *pdata; 39 40 struct backlight_device *bled; 41 struct led_classdev cdev_flash; 42 struct led_classdev cdev_torch; 43 struct regmap *regmap; 44 45 unsigned int bled_mode; 46 unsigned int bled_map; 47 unsigned int last_flag; 48 }; 49 50 /* initialize chip */ 51 static int lm3639_chip_init(struct lm3639_chip_data *pchip) 52 { 53 int ret; 54 unsigned int reg_val; 55 struct lm3639_platform_data *pdata = pchip->pdata; 56 57 /* input pins config. */ 58 ret = 59 regmap_update_bits(pchip->regmap, REG_BL_CONF_1, 0x08, 60 pdata->pin_pwm); 61 if (ret < 0) 62 goto out; 63 64 reg_val = (pdata->pin_pwm & 0x40) | pdata->pin_strobe | pdata->pin_tx; 65 ret = regmap_update_bits(pchip->regmap, REG_IO_CTRL, 0x7C, reg_val); 66 if (ret < 0) 67 goto out; 68 69 /* init brightness */ 70 ret = regmap_write(pchip->regmap, REG_BL_CONF_4, pdata->init_brt_led); 71 if (ret < 0) 72 goto out; 73 74 ret = regmap_write(pchip->regmap, REG_BL_CONF_3, pdata->init_brt_led); 75 if (ret < 0) 76 goto out; 77 78 /* output pins config. */ 79 if (!pdata->init_brt_led) { 80 reg_val = pdata->fled_pins; 81 reg_val |= pdata->bled_pins; 82 } else { 83 reg_val = pdata->fled_pins; 84 reg_val |= pdata->bled_pins | 0x01; 85 } 86 87 ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x79, reg_val); 88 if (ret < 0) 89 goto out; 90 91 return ret; 92 out: 93 dev_err(pchip->dev, "i2c failed to access register\n"); 94 return ret; 95 } 96 97 /* update and get brightness */ 98 static int lm3639_bled_update_status(struct backlight_device *bl) 99 { 100 int ret; 101 unsigned int reg_val; 102 struct lm3639_chip_data *pchip = bl_get_data(bl); 103 struct lm3639_platform_data *pdata = pchip->pdata; 104 105 ret = regmap_read(pchip->regmap, REG_FLAG, ®_val); 106 if (ret < 0) 107 goto out; 108 109 if (reg_val != 0) 110 dev_info(pchip->dev, "last flag is 0x%x\n", reg_val); 111 112 /* pwm control */ 113 if (pdata->pin_pwm) { 114 if (pdata->pwm_set_intensity) 115 pdata->pwm_set_intensity(bl->props.brightness, 116 pdata->max_brt_led); 117 else 118 dev_err(pchip->dev, 119 "No pwm control func. in plat-data\n"); 120 return bl->props.brightness; 121 } 122 123 /* i2c control and set brigtness */ 124 ret = regmap_write(pchip->regmap, REG_BL_CONF_4, bl->props.brightness); 125 if (ret < 0) 126 goto out; 127 ret = regmap_write(pchip->regmap, REG_BL_CONF_3, bl->props.brightness); 128 if (ret < 0) 129 goto out; 130 131 if (!bl->props.brightness) 132 ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x01, 0x00); 133 else 134 ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x01, 0x01); 135 if (ret < 0) 136 goto out; 137 138 return bl->props.brightness; 139 out: 140 dev_err(pchip->dev, "i2c failed to access registers\n"); 141 return bl->props.brightness; 142 } 143 144 static int lm3639_bled_get_brightness(struct backlight_device *bl) 145 { 146 int ret; 147 unsigned int reg_val; 148 struct lm3639_chip_data *pchip = bl_get_data(bl); 149 struct lm3639_platform_data *pdata = pchip->pdata; 150 151 if (pdata->pin_pwm) { 152 if (pdata->pwm_get_intensity) 153 bl->props.brightness = pdata->pwm_get_intensity(); 154 else 155 dev_err(pchip->dev, 156 "No pwm control func. in plat-data\n"); 157 return bl->props.brightness; 158 } 159 160 ret = regmap_read(pchip->regmap, REG_BL_CONF_1, ®_val); 161 if (ret < 0) 162 goto out; 163 if (reg_val & 0x10) 164 ret = regmap_read(pchip->regmap, REG_BL_CONF_4, ®_val); 165 else 166 ret = regmap_read(pchip->regmap, REG_BL_CONF_3, ®_val); 167 if (ret < 0) 168 goto out; 169 bl->props.brightness = reg_val; 170 171 return bl->props.brightness; 172 out: 173 dev_err(pchip->dev, "i2c failed to access register\n"); 174 return bl->props.brightness; 175 } 176 177 static const struct backlight_ops lm3639_bled_ops = { 178 .options = BL_CORE_SUSPENDRESUME, 179 .update_status = lm3639_bled_update_status, 180 .get_brightness = lm3639_bled_get_brightness, 181 }; 182 183 /* backlight mapping mode */ 184 static ssize_t lm3639_bled_mode_store(struct device *dev, 185 struct device_attribute *devAttr, 186 const char *buf, size_t size) 187 { 188 ssize_t ret; 189 struct lm3639_chip_data *pchip = dev_get_drvdata(dev); 190 unsigned int state; 191 192 ret = kstrtouint(buf, 10, &state); 193 if (ret) 194 goto out_input; 195 196 if (!state) 197 ret = 198 regmap_update_bits(pchip->regmap, REG_BL_CONF_1, 0x10, 199 0x00); 200 else 201 ret = 202 regmap_update_bits(pchip->regmap, REG_BL_CONF_1, 0x10, 203 0x10); 204 205 if (ret < 0) 206 goto out; 207 208 return size; 209 210 out: 211 dev_err(pchip->dev, "%s:i2c access fail to register\n", __func__); 212 return ret; 213 214 out_input: 215 dev_err(pchip->dev, "%s:input conversion fail\n", __func__); 216 return ret; 217 218 } 219 220 static DEVICE_ATTR(bled_mode, S_IWUSR, NULL, lm3639_bled_mode_store); 221 222 /* torch */ 223 static void lm3639_torch_brightness_set(struct led_classdev *cdev, 224 enum led_brightness brightness) 225 { 226 int ret; 227 unsigned int reg_val; 228 struct lm3639_chip_data *pchip; 229 230 pchip = container_of(cdev, struct lm3639_chip_data, cdev_torch); 231 232 ret = regmap_read(pchip->regmap, REG_FLAG, ®_val); 233 if (ret < 0) 234 goto out; 235 if (reg_val != 0) 236 dev_info(pchip->dev, "last flag is 0x%x\n", reg_val); 237 238 /* brightness 0 means off state */ 239 if (!brightness) { 240 ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x06, 0x00); 241 if (ret < 0) 242 goto out; 243 return; 244 } 245 246 ret = regmap_update_bits(pchip->regmap, 247 REG_FL_CONF_1, 0x70, (brightness - 1) << 4); 248 if (ret < 0) 249 goto out; 250 ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x06, 0x02); 251 if (ret < 0) 252 goto out; 253 254 return; 255 out: 256 dev_err(pchip->dev, "i2c failed to access register\n"); 257 return; 258 } 259 260 /* flash */ 261 static void lm3639_flash_brightness_set(struct led_classdev *cdev, 262 enum led_brightness brightness) 263 { 264 int ret; 265 unsigned int reg_val; 266 struct lm3639_chip_data *pchip; 267 268 pchip = container_of(cdev, struct lm3639_chip_data, cdev_flash); 269 270 ret = regmap_read(pchip->regmap, REG_FLAG, ®_val); 271 if (ret < 0) 272 goto out; 273 if (reg_val != 0) 274 dev_info(pchip->dev, "last flag is 0x%x\n", reg_val); 275 276 /* torch off before flash control */ 277 ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x06, 0x00); 278 if (ret < 0) 279 goto out; 280 281 /* brightness 0 means off state */ 282 if (!brightness) 283 return; 284 285 ret = regmap_update_bits(pchip->regmap, 286 REG_FL_CONF_1, 0x0F, brightness - 1); 287 if (ret < 0) 288 goto out; 289 ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x06, 0x06); 290 if (ret < 0) 291 goto out; 292 293 return; 294 out: 295 dev_err(pchip->dev, "i2c failed to access register\n"); 296 return; 297 } 298 299 static const struct regmap_config lm3639_regmap = { 300 .reg_bits = 8, 301 .val_bits = 8, 302 .max_register = REG_MAX, 303 }; 304 305 static int lm3639_probe(struct i2c_client *client, 306 const struct i2c_device_id *id) 307 { 308 int ret; 309 struct lm3639_chip_data *pchip; 310 struct lm3639_platform_data *pdata = dev_get_platdata(&client->dev); 311 struct backlight_properties props; 312 313 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { 314 dev_err(&client->dev, "i2c functionality check fail.\n"); 315 return -EOPNOTSUPP; 316 } 317 318 if (pdata == NULL) { 319 dev_err(&client->dev, "Needs Platform Data.\n"); 320 return -ENODATA; 321 } 322 323 pchip = devm_kzalloc(&client->dev, 324 sizeof(struct lm3639_chip_data), GFP_KERNEL); 325 if (!pchip) 326 return -ENOMEM; 327 328 pchip->pdata = pdata; 329 pchip->dev = &client->dev; 330 331 pchip->regmap = devm_regmap_init_i2c(client, &lm3639_regmap); 332 if (IS_ERR(pchip->regmap)) { 333 ret = PTR_ERR(pchip->regmap); 334 dev_err(&client->dev, "fail : allocate register map: %d\n", 335 ret); 336 return ret; 337 } 338 i2c_set_clientdata(client, pchip); 339 340 /* chip initialize */ 341 ret = lm3639_chip_init(pchip); 342 if (ret < 0) { 343 dev_err(&client->dev, "fail : chip init\n"); 344 goto err_out; 345 } 346 347 /* backlight */ 348 props.type = BACKLIGHT_RAW; 349 props.brightness = pdata->init_brt_led; 350 props.max_brightness = pdata->max_brt_led; 351 pchip->bled = 352 backlight_device_register("lm3639_bled", pchip->dev, pchip, 353 &lm3639_bled_ops, &props); 354 if (IS_ERR(pchip->bled)) { 355 dev_err(&client->dev, "fail : backlight register\n"); 356 ret = PTR_ERR(pchip->bled); 357 goto err_out; 358 } 359 360 ret = device_create_file(&(pchip->bled->dev), &dev_attr_bled_mode); 361 if (ret < 0) { 362 dev_err(&client->dev, "failed : add sysfs entries\n"); 363 goto err_bled_mode; 364 } 365 366 /* flash */ 367 pchip->cdev_flash.name = "lm3639_flash"; 368 pchip->cdev_flash.max_brightness = 16; 369 pchip->cdev_flash.brightness_set = lm3639_flash_brightness_set; 370 ret = led_classdev_register((struct device *) 371 &client->dev, &pchip->cdev_flash); 372 if (ret < 0) { 373 dev_err(&client->dev, "fail : flash register\n"); 374 goto err_flash; 375 } 376 377 /* torch */ 378 pchip->cdev_torch.name = "lm3639_torch"; 379 pchip->cdev_torch.max_brightness = 8; 380 pchip->cdev_torch.brightness_set = lm3639_torch_brightness_set; 381 ret = led_classdev_register((struct device *) 382 &client->dev, &pchip->cdev_torch); 383 if (ret < 0) { 384 dev_err(&client->dev, "fail : torch register\n"); 385 goto err_torch; 386 } 387 388 return 0; 389 390 err_torch: 391 led_classdev_unregister(&pchip->cdev_flash); 392 err_flash: 393 device_remove_file(&(pchip->bled->dev), &dev_attr_bled_mode); 394 err_bled_mode: 395 backlight_device_unregister(pchip->bled); 396 err_out: 397 return ret; 398 } 399 400 static int lm3639_remove(struct i2c_client *client) 401 { 402 struct lm3639_chip_data *pchip = i2c_get_clientdata(client); 403 404 regmap_write(pchip->regmap, REG_ENABLE, 0x00); 405 406 if (&pchip->cdev_torch) 407 led_classdev_unregister(&pchip->cdev_torch); 408 if (&pchip->cdev_flash) 409 led_classdev_unregister(&pchip->cdev_flash); 410 if (pchip->bled) { 411 device_remove_file(&(pchip->bled->dev), &dev_attr_bled_mode); 412 backlight_device_unregister(pchip->bled); 413 } 414 return 0; 415 } 416 417 static const struct i2c_device_id lm3639_id[] = { 418 {LM3639_NAME, 0}, 419 {} 420 }; 421 422 MODULE_DEVICE_TABLE(i2c, lm3639_id); 423 static struct i2c_driver lm3639_i2c_driver = { 424 .driver = { 425 .name = LM3639_NAME, 426 }, 427 .probe = lm3639_probe, 428 .remove = lm3639_remove, 429 .id_table = lm3639_id, 430 }; 431 432 module_i2c_driver(lm3639_i2c_driver); 433 434 MODULE_DESCRIPTION("Texas Instruments Backlight+Flash LED driver for LM3639"); 435 MODULE_AUTHOR("Daniel Jeong <daniel.jeong@ti.com>"); 436 MODULE_AUTHOR("G.Shark Jeong <gshark.jeong@gmail.com>"); 437 MODULE_LICENSE("GPL v2"); 438