drivers/leds/leds-max8997.c

   1 /*
   2  * leds-max8997.c - LED class driver for MAX8997 LEDs.
   3  *
   4  * Copyright (C) 2011 Samsung Electronics
   5  * Donggeun Kim <dg77.kim@samsung.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  *
  11  */
  12
  13 #include <linux/module.h>
  14 #include <linux/err.h>
  15 #include <linux/slab.h>
  16 #include <linux/workqueue.h>
  17 #include <linux/leds.h>
  18 #include <linux/mfd/max8997.h>
  19 #include <linux/mfd/max8997-private.h>
  20 #include <linux/platform_device.h>
  21
  22 #define MAX8997_LED_FLASH_SHIFT                 3
  23 #define MAX8997_LED_FLASH_CUR_MASK              0xf8
  24 #define MAX8997_LED_MOVIE_SHIFT                 4
  25 #define MAX8997_LED_MOVIE_CUR_MASK              0xf0
  26
  27 #define MAX8997_LED_FLASH_MAX_BRIGHTNESS        0x1f
  28 #define MAX8997_LED_MOVIE_MAX_BRIGHTNESS        0xf
  29 #define MAX8997_LED_NONE_MAX_BRIGHTNESS         0
  30
  31 #define MAX8997_LED0_FLASH_MASK                 0x1
  32 #define MAX8997_LED0_FLASH_PIN_MASK             0x5
  33 #define MAX8997_LED0_MOVIE_MASK                 0x8
  34 #define MAX8997_LED0_MOVIE_PIN_MASK             0x28
  35
  36 #define MAX8997_LED1_FLASH_MASK                 0x2
  37 #define MAX8997_LED1_FLASH_PIN_MASK             0x6
  38 #define MAX8997_LED1_MOVIE_MASK                 0x10
  39 #define MAX8997_LED1_MOVIE_PIN_MASK             0x30
  40
  41 #define MAX8997_LED_BOOST_ENABLE_MASK           (1 << 6)
  42
  43 struct max8997_led {
  44         struct max8997_dev *iodev;
  45         struct led_classdev cdev;
  46         bool enabled;
  47         int id;
  48         enum max8997_led_mode led_mode;
  49         struct mutex mutex;
  50 };
  51
  52 static void max8997_led_clear_mode(struct max8997_led *led,
  53                         enum max8997_led_mode mode)
  54 {
  55         struct i2c_client *client = led->iodev->i2c;
  56         u8 val = 0, mask = 0;
  57         int ret;
  58
  59         switch (mode) {
  60         case MAX8997_FLASH_MODE:
  61                 mask = led->id ?
  62                       MAX8997_LED1_FLASH_MASK : MAX8997_LED0_FLASH_MASK;
  63                 break;
  64         case MAX8997_MOVIE_MODE:
  65                 mask = led->id ?
  66                       MAX8997_LED1_MOVIE_MASK : MAX8997_LED0_MOVIE_MASK;
  67                 break;
  68         case MAX8997_FLASH_PIN_CONTROL_MODE:
  69                 mask = led->id ?
  70                       MAX8997_LED1_FLASH_PIN_MASK : MAX8997_LED0_FLASH_PIN_MASK;
  71                 break;
  72         case MAX8997_MOVIE_PIN_CONTROL_MODE:
  73                 mask = led->id ?
  74                       MAX8997_LED1_MOVIE_PIN_MASK : MAX8997_LED0_MOVIE_PIN_MASK;
  75                 break;
  76         default:
  77                 break;
  78         }
  79
  80         if (mask) {
  81                 ret = max8997_update_reg(client,
  82                                 MAX8997_REG_LEN_CNTL, val, mask);
  83                 if (ret)
  84                         dev_err(led->iodev->dev,
  85                                 "failed to update register(%d)\n", ret);
  86         }
  87 }
  88
  89 static void max8997_led_set_mode(struct max8997_led *led,
  90                         enum max8997_led_mode mode)
  91 {
  92         int ret;
  93         struct i2c_client *client = led->iodev->i2c;
  94         u8 mask = 0;
  95
  96         /* First, clear the previous mode */
  97         max8997_led_clear_mode(led, led->led_mode);
  98
  99         switch (mode) {
 100         case MAX8997_FLASH_MODE:
 101                 mask = led->id ?
 102                       MAX8997_LED1_FLASH_MASK : MAX8997_LED0_FLASH_MASK;
 103                 led->cdev.max_brightness = MAX8997_LED_FLASH_MAX_BRIGHTNESS;
 104                 break;
 105         case MAX8997_MOVIE_MODE:
 106                 mask = led->id ?
 107                       MAX8997_LED1_MOVIE_MASK : MAX8997_LED0_MOVIE_MASK;
 108                 led->cdev.max_brightness = MAX8997_LED_MOVIE_MAX_BRIGHTNESS;
 109                 break;
 110         case MAX8997_FLASH_PIN_CONTROL_MODE:
 111                 mask = led->id ?
 112                       MAX8997_LED1_FLASH_PIN_MASK : MAX8997_LED0_FLASH_PIN_MASK;
 113                 led->cdev.max_brightness = MAX8997_LED_FLASH_MAX_BRIGHTNESS;
 114                 break;
 115         case MAX8997_MOVIE_PIN_CONTROL_MODE:
 116                 mask = led->id ?
 117                       MAX8997_LED1_MOVIE_PIN_MASK : MAX8997_LED0_MOVIE_PIN_MASK;
 118                 led->cdev.max_brightness = MAX8997_LED_MOVIE_MAX_BRIGHTNESS;
 119                 break;
 120         default:
 121                 led->cdev.max_brightness = MAX8997_LED_NONE_MAX_BRIGHTNESS;
 122                 break;
 123         }
 124
 125         if (mask) {
 126                 ret = max8997_update_reg(client,
 127                                 MAX8997_REG_LEN_CNTL, mask, mask);
 128                 if (ret)
 129                         dev_err(led->iodev->dev,
 130                                 "failed to update register(%d)\n", ret);
 131         }
 132
 133         led->led_mode = mode;
 134 }
 135
 136 static void max8997_led_enable(struct max8997_led *led, bool enable)
 137 {
 138         int ret;
 139         struct i2c_client *client = led->iodev->i2c;
 140         u8 val = 0, mask = MAX8997_LED_BOOST_ENABLE_MASK;
 141
 142         if (led->enabled == enable)
 143                 return;
 144
 145         val = enable ? MAX8997_LED_BOOST_ENABLE_MASK : 0;
 146
 147         ret = max8997_update_reg(client, MAX8997_REG_BOOST_CNTL, val, mask);
 148         if (ret)
 149                 dev_err(led->iodev->dev,
 150                         "failed to update register(%d)\n", ret);
 151
 152         led->enabled = enable;
 153 }
 154
 155 static void max8997_led_set_current(struct max8997_led *led,
 156                                 enum led_brightness value)
 157 {
 158         int ret;
 159         struct i2c_client *client = led->iodev->i2c;
 160         u8 val = 0, mask = 0, reg = 0;
 161
 162         switch (led->led_mode) {
 163         case MAX8997_FLASH_MODE:
 164         case MAX8997_FLASH_PIN_CONTROL_MODE:
 165                 val = value << MAX8997_LED_FLASH_SHIFT;
 166                 mask = MAX8997_LED_FLASH_CUR_MASK;
 167                 reg = led->id ? MAX8997_REG_FLASH2_CUR : MAX8997_REG_FLASH1_CUR;
 168                 break;
 169         case MAX8997_MOVIE_MODE:
 170         case MAX8997_MOVIE_PIN_CONTROL_MODE:
 171                 val = value << MAX8997_LED_MOVIE_SHIFT;
 172                 mask = MAX8997_LED_MOVIE_CUR_MASK;
 173                 reg = MAX8997_REG_MOVIE_CUR;
 174                 break;
 175         default:
 176                 break;
 177         }
 178
 179         if (mask) {
 180                 ret = max8997_update_reg(client, reg, val, mask);
 181                 if (ret)
 182                         dev_err(led->iodev->dev,
 183                                 "failed to update register(%d)\n", ret);
 184         }
 185 }
 186
 187 static void max8997_led_brightness_set(struct led_classdev *led_cdev,
 188                                 enum led_brightness value)
 189 {
 190         struct max8997_led *led =
 191                         container_of(led_cdev, struct max8997_led, cdev);
 192
 193         if (value) {
 194                 max8997_led_set_current(led, value);
 195                 max8997_led_enable(led, true);
 196         } else {
 197                 max8997_led_set_current(led, value);
 198                 max8997_led_enable(led, false);
 199         }
 200 }
 201
 202 static ssize_t max8997_led_show_mode(struct device *dev,
 203                                 struct device_attribute *attr, char *buf)
 204 {
 205         struct led_classdev *led_cdev = dev_get_drvdata(dev);
 206         struct max8997_led *led =
 207                         container_of(led_cdev, struct max8997_led, cdev);
 208         ssize_t ret = 0;
 209
 210         mutex_lock(&led->mutex);
 211
 212         switch (led->led_mode) {
 213         case MAX8997_FLASH_MODE:
 214                 ret += sprintf(buf, "FLASH\n");
 215                 break;
 216         case MAX8997_MOVIE_MODE:
 217                 ret += sprintf(buf, "MOVIE\n");
 218                 break;
 219         case MAX8997_FLASH_PIN_CONTROL_MODE:
 220                 ret += sprintf(buf, "FLASH_PIN_CONTROL\n");
 221                 break;
 222         case MAX8997_MOVIE_PIN_CONTROL_MODE:
 223                 ret += sprintf(buf, "MOVIE_PIN_CONTROL\n");
 224                 break;
 225         default:
 226                 ret += sprintf(buf, "NONE\n");
 227                 break;
 228         }
 229
 230         mutex_unlock(&led->mutex);
 231
 232         return ret;
 233 }
 234
 235 static ssize_t max8997_led_store_mode(struct device *dev,
 236                                 struct device_attribute *attr,
 237                                 const char *buf, size_t size)
 238 {
 239         struct led_classdev *led_cdev = dev_get_drvdata(dev);
 240         struct max8997_led *led =
 241                         container_of(led_cdev, struct max8997_led, cdev);
 242         enum max8997_led_mode mode;
 243
 244         mutex_lock(&led->mutex);
 245
 246         if (!strncmp(buf, "FLASH_PIN_CONTROL", 17))
 247                 mode = MAX8997_FLASH_PIN_CONTROL_MODE;
 248         else if (!strncmp(buf, "MOVIE_PIN_CONTROL", 17))
 249                 mode = MAX8997_MOVIE_PIN_CONTROL_MODE;
 250         else if (!strncmp(buf, "FLASH", 5))
 251                 mode = MAX8997_FLASH_MODE;
 252         else if (!strncmp(buf, "MOVIE", 5))
 253                 mode = MAX8997_MOVIE_MODE;
 254         else
 255                 mode = MAX8997_NONE;
 256
 257         max8997_led_set_mode(led, mode);
 258
 259         mutex_unlock(&led->mutex);
 260
 261         return size;
 262 }
 263
 264 static DEVICE_ATTR(mode, 0644, max8997_led_show_mode, max8997_led_store_mode);
 265
 266 static int __devinit max8997_led_probe(struct platform_device *pdev)
 267 {
 268         struct max8997_dev *iodev = dev_get_drvdata(pdev->dev.parent);
 269         struct max8997_platform_data *pdata = dev_get_platdata(iodev->dev);
 270         struct max8997_led *led;
 271         char name[20];
 272         int ret = 0;
 273
 274         if (pdata == NULL) {
 275                 dev_err(&pdev->dev, "no platform data\n");
 276                 return -ENODEV;
 277         }
 278
 279         led = kzalloc(sizeof(*led), GFP_KERNEL);
 280         if (led == NULL) {
 281                 ret = -ENOMEM;
 282                 goto err_mem;
 283         }
 284
 285         led->id = pdev->id;
 286         snprintf(name, sizeof(name), "max8997-led%d", pdev->id);
 287
 288         led->cdev.name = name;
 289         led->cdev.brightness_set = max8997_led_brightness_set;
 290         led->cdev.flags |= LED_CORE_SUSPENDRESUME;
 291         led->cdev.brightness = 0;
 292         led->iodev = iodev;
 293
 294         /* initialize mode and brightness according to platform_data */
 295         if (pdata->led_pdata) {
 296                 u8 mode = 0, brightness = 0;
 297
 298                 mode = pdata->led_pdata->mode[led->id];
 299                 brightness = pdata->led_pdata->brightness[led->id];
 300
 301                 max8997_led_set_mode(led, pdata->led_pdata->mode[led->id]);
 302
 303                 if (brightness > led->cdev.max_brightness)
 304                         brightness = led->cdev.max_brightness;
 305                 max8997_led_set_current(led, brightness);
 306                 led->cdev.brightness = brightness;
 307         } else {
 308                 max8997_led_set_mode(led, MAX8997_NONE);
 309                 max8997_led_set_current(led, 0);
 310         }
 311
 312         mutex_init(&led->mutex);
 313
 314         platform_set_drvdata(pdev, led);
 315
 316         ret = led_classdev_register(&pdev->dev, &led->cdev);
 317         if (ret < 0)
 318                 goto err_led;
 319
 320         ret = device_create_file(led->cdev.dev, &dev_attr_mode);
 321         if (ret != 0) {
 322                 dev_err(&pdev->dev,
 323                         "failed to create file: %d\n", ret);
 324                 goto err_file;
 325         }
 326
 327         return 0;
 328
 329 err_file:
 330         led_classdev_unregister(&led->cdev);
 331 err_led:
 332         kfree(led);
 333 err_mem:
 334         return ret;
 335 }
 336
 337 static int __devexit max8997_led_remove(struct platform_device *pdev)
 338 {
 339         struct max8997_led *led = platform_get_drvdata(pdev);
 340
 341         device_remove_file(led->cdev.dev, &dev_attr_mode);
 342         led_classdev_unregister(&led->cdev);
 343         kfree(led);
 344
 345         return 0;
 346 }
 347
 348 static struct platform_driver max8997_led_driver = {
 349         .driver = {
 350                 .name  = "max8997-led",
 351                 .owner = THIS_MODULE,
 352         },
 353         .probe  = max8997_led_probe,
 354         .remove = __devexit_p(max8997_led_remove),
 355 };
 356
 357 static int __init max8997_led_init(void)
 358 {
 359         return platform_driver_register(&max8997_led_driver);
 360 }
 361 module_init(max8997_led_init);
 362
 363 static void __exit max8997_led_exit(void)
 364 {
 365         platform_driver_unregister(&max8997_led_driver);
 366 }
 367 module_exit(max8997_led_exit);
 368
 369 MODULE_AUTHOR("Donggeun Kim <dg77.kim@samsung.com>");
 370 MODULE_DESCRIPTION("MAX8997 LED driver");
 371 MODULE_LICENSE("GPL");
 372 MODULE_ALIAS("platform:max8997-led");