drivers/leds/leds-ktd2692.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * LED driver : leds-ktd2692.c
   4  *
   5  * Copyright (C) 2015 Samsung Electronics
   6  * Ingi Kim <ingi2.kim@samsung.com>
   7  */
   8
   9 #include <linux/delay.h>
  10 #include <linux/err.h>
  11 #include <linux/gpio/consumer.h>
  12 #include <linux/led-class-flash.h>
  13 #include <linux/module.h>
  14 #include <linux/mutex.h>
  15 #include <linux/of.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/regulator/consumer.h>
  18
  19 /* Value related the movie mode */
  20 #define KTD2692_MOVIE_MODE_CURRENT_LEVELS       16
  21 #define KTD2692_MM_TO_FL_RATIO(x)               ((x) / 3)
  22 #define KTD2692_MM_MIN_CURR_THRESHOLD_SCALE     8
  23
  24 /* Value related the flash mode */
  25 #define KTD2692_FLASH_MODE_TIMEOUT_LEVELS       8
  26 #define KTD2692_FLASH_MODE_TIMEOUT_DISABLE      0
  27 #define KTD2692_FLASH_MODE_CURR_PERCENT(x)      (((x) * 16) / 100)
  28
  29 /* Macro for getting offset of flash timeout */
  30 #define GET_TIMEOUT_OFFSET(timeout, step)       ((timeout) / (step))
  31
  32 /* Base register address */
  33 #define KTD2692_REG_LVP_BASE                    0x00
  34 #define KTD2692_REG_FLASH_TIMEOUT_BASE          0x20
  35 #define KTD2692_REG_MM_MIN_CURR_THRESHOLD_BASE  0x40
  36 #define KTD2692_REG_MOVIE_CURRENT_BASE          0x60
  37 #define KTD2692_REG_FLASH_CURRENT_BASE          0x80
  38 #define KTD2692_REG_MODE_BASE                   0xA0
  39
  40 /* Set bit coding time for expresswire interface */
  41 #define KTD2692_TIME_RESET_US                   700
  42 #define KTD2692_TIME_DATA_START_TIME_US         10
  43 #define KTD2692_TIME_HIGH_END_OF_DATA_US        350
  44 #define KTD2692_TIME_LOW_END_OF_DATA_US         10
  45 #define KTD2692_TIME_SHORT_BITSET_US            4
  46 #define KTD2692_TIME_LONG_BITSET_US             12
  47
  48 /* KTD2692 default length of name */
  49 #define KTD2692_NAME_LENGTH                     20
  50
  51 enum ktd2692_bitset {
  52         KTD2692_LOW = 0,
  53         KTD2692_HIGH,
  54 };
  55
  56 /* Movie / Flash Mode Control */
  57 enum ktd2692_led_mode {
  58         KTD2692_MODE_DISABLE = 0,       /* default */
  59         KTD2692_MODE_MOVIE,
  60         KTD2692_MODE_FLASH,
  61 };
  62
  63 struct ktd2692_led_config_data {
  64         /* maximum LED current in movie mode */
  65         u32 movie_max_microamp;
  66         /* maximum LED current in flash mode */
  67         u32 flash_max_microamp;
  68         /* maximum flash timeout */
  69         u32 flash_max_timeout;
  70         /* max LED brightness level */
  71         enum led_brightness max_brightness;
  72 };
  73
  74 struct ktd2692_context {
  75         /* Related LED Flash class device */
  76         struct led_classdev_flash fled_cdev;
  77
  78         /* secures access to the device */
  79         struct mutex lock;
  80         struct regulator *regulator;
  81
  82         struct gpio_desc *aux_gpio;
  83         struct gpio_desc *ctrl_gpio;
  84
  85         enum ktd2692_led_mode mode;
  86         enum led_brightness torch_brightness;
  87 };
  88
  89 static struct ktd2692_context *fled_cdev_to_led(
  90                                 struct led_classdev_flash *fled_cdev)
  91 {
  92         return container_of(fled_cdev, struct ktd2692_context, fled_cdev);
  93 }
  94
  95 static void ktd2692_expresswire_start(struct ktd2692_context *led)
  96 {
  97         gpiod_direction_output(led->ctrl_gpio, KTD2692_HIGH);
  98         udelay(KTD2692_TIME_DATA_START_TIME_US);
  99 }
 100
 101 static void ktd2692_expresswire_reset(struct ktd2692_context *led)
 102 {
 103         gpiod_direction_output(led->ctrl_gpio, KTD2692_LOW);
 104         udelay(KTD2692_TIME_RESET_US);
 105 }
 106
 107 static void ktd2692_expresswire_end(struct ktd2692_context *led)
 108 {
 109         gpiod_direction_output(led->ctrl_gpio, KTD2692_LOW);
 110         udelay(KTD2692_TIME_LOW_END_OF_DATA_US);
 111         gpiod_direction_output(led->ctrl_gpio, KTD2692_HIGH);
 112         udelay(KTD2692_TIME_HIGH_END_OF_DATA_US);
 113 }
 114
 115 static void ktd2692_expresswire_set_bit(struct ktd2692_context *led, bool bit)
 116 {
 117         /*
 118          * The Low Bit(0) and High Bit(1) is based on a time detection
 119          * algorithm between time low and time high
 120          * Time_(L_LB) : Low time of the Low Bit(0)
 121          * Time_(H_LB) : High time of the LOW Bit(0)
 122          * Time_(L_HB) : Low time of the High Bit(1)
 123          * Time_(H_HB) : High time of the High Bit(1)
 124          *
 125          * It can be simplified to:
 126          * Low Bit(0) : 2 * Time_(H_LB) < Time_(L_LB)
 127          * High Bit(1) : 2 * Time_(L_HB) < Time_(H_HB)
 128          * HIGH  ___           ____    _..     _________    ___
 129          *          |_________|    |_..  |____|         |__|
 130          * LOW        <L_LB>  <H_LB>     <L_HB>  <H_HB>
 131          *          [  Low Bit (0) ]     [  High Bit(1) ]
 132          */
 133         if (bit) {
 134                 gpiod_direction_output(led->ctrl_gpio, KTD2692_LOW);
 135                 udelay(KTD2692_TIME_SHORT_BITSET_US);
 136                 gpiod_direction_output(led->ctrl_gpio, KTD2692_HIGH);
 137                 udelay(KTD2692_TIME_LONG_BITSET_US);
 138         } else {
 139                 gpiod_direction_output(led->ctrl_gpio, KTD2692_LOW);
 140                 udelay(KTD2692_TIME_LONG_BITSET_US);
 141                 gpiod_direction_output(led->ctrl_gpio, KTD2692_HIGH);
 142                 udelay(KTD2692_TIME_SHORT_BITSET_US);
 143         }
 144 }
 145
 146 static void ktd2692_expresswire_write(struct ktd2692_context *led, u8 value)
 147 {
 148         int i;
 149
 150         ktd2692_expresswire_start(led);
 151         for (i = 7; i >= 0; i--)
 152                 ktd2692_expresswire_set_bit(led, value & BIT(i));
 153         ktd2692_expresswire_end(led);
 154 }
 155
 156 static int ktd2692_led_brightness_set(struct led_classdev *led_cdev,
 157                                        enum led_brightness brightness)
 158 {
 159         struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev);
 160         struct ktd2692_context *led = fled_cdev_to_led(fled_cdev);
 161
 162         mutex_lock(&led->lock);
 163
 164         if (brightness == LED_OFF) {
 165                 led->mode = KTD2692_MODE_DISABLE;
 166                 gpiod_direction_output(led->aux_gpio, KTD2692_LOW);
 167         } else {
 168                 ktd2692_expresswire_write(led, brightness |
 169                                         KTD2692_REG_MOVIE_CURRENT_BASE);
 170                 led->mode = KTD2692_MODE_MOVIE;
 171         }
 172
 173         ktd2692_expresswire_write(led, led->mode | KTD2692_REG_MODE_BASE);
 174         mutex_unlock(&led->lock);
 175
 176         return 0;
 177 }
 178
 179 static int ktd2692_led_flash_strobe_set(struct led_classdev_flash *fled_cdev,
 180                                         bool state)
 181 {
 182         struct ktd2692_context *led = fled_cdev_to_led(fled_cdev);
 183         struct led_flash_setting *timeout = &fled_cdev->timeout;
 184         u32 flash_tm_reg;
 185
 186         mutex_lock(&led->lock);
 187
 188         if (state) {
 189                 flash_tm_reg = GET_TIMEOUT_OFFSET(timeout->val, timeout->step);
 190                 ktd2692_expresswire_write(led, flash_tm_reg
 191                                 | KTD2692_REG_FLASH_TIMEOUT_BASE);
 192
 193                 led->mode = KTD2692_MODE_FLASH;
 194                 gpiod_direction_output(led->aux_gpio, KTD2692_HIGH);
 195         } else {
 196                 led->mode = KTD2692_MODE_DISABLE;
 197                 gpiod_direction_output(led->aux_gpio, KTD2692_LOW);
 198         }
 199
 200         ktd2692_expresswire_write(led, led->mode | KTD2692_REG_MODE_BASE);
 201
 202         fled_cdev->led_cdev.brightness = LED_OFF;
 203         led->mode = KTD2692_MODE_DISABLE;
 204
 205         mutex_unlock(&led->lock);
 206
 207         return 0;
 208 }
 209
 210 static int ktd2692_led_flash_timeout_set(struct led_classdev_flash *fled_cdev,
 211                                          u32 timeout)
 212 {
 213         return 0;
 214 }
 215
 216 static void ktd2692_init_movie_current_max(struct ktd2692_led_config_data *cfg)
 217 {
 218         u32 offset, step;
 219         u32 movie_current_microamp;
 220
 221         offset = KTD2692_MOVIE_MODE_CURRENT_LEVELS;
 222         step = KTD2692_MM_TO_FL_RATIO(cfg->flash_max_microamp)
 223                 / KTD2692_MOVIE_MODE_CURRENT_LEVELS;
 224
 225         do {
 226                 movie_current_microamp = step * offset;
 227                 offset--;
 228         } while ((movie_current_microamp > cfg->movie_max_microamp) &&
 229                 (offset > 0));
 230
 231         cfg->max_brightness = offset;
 232 }
 233
 234 static void ktd2692_init_flash_timeout(struct led_classdev_flash *fled_cdev,
 235                                        struct ktd2692_led_config_data *cfg)
 236 {
 237         struct led_flash_setting *setting;
 238
 239         setting = &fled_cdev->timeout;
 240         setting->min = KTD2692_FLASH_MODE_TIMEOUT_DISABLE;
 241         setting->max = cfg->flash_max_timeout;
 242         setting->step = cfg->flash_max_timeout
 243                         / (KTD2692_FLASH_MODE_TIMEOUT_LEVELS - 1);
 244         setting->val = cfg->flash_max_timeout;
 245 }
 246
 247 static void ktd2692_setup(struct ktd2692_context *led)
 248 {
 249         led->mode = KTD2692_MODE_DISABLE;
 250         ktd2692_expresswire_reset(led);
 251         gpiod_direction_output(led->aux_gpio, KTD2692_LOW);
 252
 253         ktd2692_expresswire_write(led, (KTD2692_MM_MIN_CURR_THRESHOLD_SCALE - 1)
 254                                  | KTD2692_REG_MM_MIN_CURR_THRESHOLD_BASE);
 255         ktd2692_expresswire_write(led, KTD2692_FLASH_MODE_CURR_PERCENT(45)
 256                                  | KTD2692_REG_FLASH_CURRENT_BASE);
 257 }
 258
 259 static void regulator_disable_action(void *_data)
 260 {
 261         struct device *dev = _data;
 262         struct ktd2692_context *led = dev_get_drvdata(dev);
 263         int ret;
 264
 265         ret = regulator_disable(led->regulator);
 266         if (ret)
 267                 dev_err(dev, "Failed to disable supply: %d\n", ret);
 268 }
 269
 270 static int ktd2692_parse_dt(struct ktd2692_context *led, struct device *dev,
 271                             struct ktd2692_led_config_data *cfg)
 272 {
 273         struct device_node *np = dev_of_node(dev);
 274         struct device_node *child_node;
 275         int ret;
 276
 277         if (!dev_of_node(dev))
 278                 return -ENXIO;
 279
 280         led->ctrl_gpio = devm_gpiod_get(dev, "ctrl", GPIOD_ASIS);
 281         ret = PTR_ERR_OR_ZERO(led->ctrl_gpio);
 282         if (ret) {
 283                 dev_err(dev, "cannot get ctrl-gpios %d\n", ret);
 284                 return ret;
 285         }
 286
 287         led->aux_gpio = devm_gpiod_get(dev, "aux", GPIOD_ASIS);
 288         ret = PTR_ERR_OR_ZERO(led->aux_gpio);
 289         if (ret) {
 290                 dev_err(dev, "cannot get aux-gpios %d\n", ret);
 291                 return ret;
 292         }
 293
 294         led->regulator = devm_regulator_get(dev, "vin");
 295         if (IS_ERR(led->regulator))
 296                 led->regulator = NULL;
 297
 298         if (led->regulator) {
 299                 ret = regulator_enable(led->regulator);
 300                 if (ret) {
 301                         dev_err(dev, "Failed to enable supply: %d\n", ret);
 302                 } else {
 303                         ret = devm_add_action_or_reset(dev,
 304                                                 regulator_disable_action, dev);
 305                         if (ret)
 306                                 return ret;
 307                 }
 308         }
 309
 310         child_node = of_get_next_available_child(np, NULL);
 311         if (!child_node) {
 312                 dev_err(dev, "No DT child node found for connected LED.\n");
 313                 return -EINVAL;
 314         }
 315
 316         led->fled_cdev.led_cdev.name =
 317                 of_get_property(child_node, "label", NULL) ? : child_node->name;
 318
 319         ret = of_property_read_u32(child_node, "led-max-microamp",
 320                                    &cfg->movie_max_microamp);
 321         if (ret) {
 322                 dev_err(dev, "failed to parse led-max-microamp\n");
 323                 goto err_parse_dt;
 324         }
 325
 326         ret = of_property_read_u32(child_node, "flash-max-microamp",
 327                                    &cfg->flash_max_microamp);
 328         if (ret) {
 329                 dev_err(dev, "failed to parse flash-max-microamp\n");
 330                 goto err_parse_dt;
 331         }
 332
 333         ret = of_property_read_u32(child_node, "flash-max-timeout-us",
 334                                    &cfg->flash_max_timeout);
 335         if (ret) {
 336                 dev_err(dev, "failed to parse flash-max-timeout-us\n");
 337                 goto err_parse_dt;
 338         }
 339
 340 err_parse_dt:
 341         of_node_put(child_node);
 342         return ret;
 343 }
 344
 345 static const struct led_flash_ops flash_ops = {
 346         .strobe_set = ktd2692_led_flash_strobe_set,
 347         .timeout_set = ktd2692_led_flash_timeout_set,
 348 };
 349
 350 static int ktd2692_probe(struct platform_device *pdev)
 351 {
 352         struct ktd2692_context *led;
 353         struct led_classdev *led_cdev;
 354         struct led_classdev_flash *fled_cdev;
 355         struct ktd2692_led_config_data led_cfg;
 356         int ret;
 357
 358         led = devm_kzalloc(&pdev->dev, sizeof(*led), GFP_KERNEL);
 359         if (!led)
 360                 return -ENOMEM;
 361
 362         fled_cdev = &led->fled_cdev;
 363         led_cdev = &fled_cdev->led_cdev;
 364
 365         ret = ktd2692_parse_dt(led, &pdev->dev, &led_cfg);
 366         if (ret)
 367                 return ret;
 368
 369         ktd2692_init_flash_timeout(fled_cdev, &led_cfg);
 370         ktd2692_init_movie_current_max(&led_cfg);
 371
 372         fled_cdev->ops = &flash_ops;
 373
 374         led_cdev->max_brightness = led_cfg.max_brightness;
 375         led_cdev->brightness_set_blocking = ktd2692_led_brightness_set;
 376         led_cdev->flags |= LED_CORE_SUSPENDRESUME | LED_DEV_CAP_FLASH;
 377
 378         mutex_init(&led->lock);
 379
 380         platform_set_drvdata(pdev, led);
 381
 382         ret = led_classdev_flash_register(&pdev->dev, fled_cdev);
 383         if (ret) {
 384                 dev_err(&pdev->dev, "can't register LED %s\n", led_cdev->name);
 385                 mutex_destroy(&led->lock);
 386                 return ret;
 387         }
 388
 389         ktd2692_setup(led);
 390
 391         return 0;
 392 }
 393
 394 static int ktd2692_remove(struct platform_device *pdev)
 395 {
 396         struct ktd2692_context *led = platform_get_drvdata(pdev);
 397
 398         led_classdev_flash_unregister(&led->fled_cdev);
 399
 400         mutex_destroy(&led->lock);
 401
 402         return 0;
 403 }
 404
 405 static const struct of_device_id ktd2692_match[] = {
 406         { .compatible = "kinetic,ktd2692", },
 407         { /* sentinel */ },
 408 };
 409 MODULE_DEVICE_TABLE(of, ktd2692_match);
 410
 411 static struct platform_driver ktd2692_driver = {
 412         .driver = {
 413                 .name  = "ktd2692",
 414                 .of_match_table = ktd2692_match,
 415         },
 416         .probe  = ktd2692_probe,
 417         .remove = ktd2692_remove,
 418 };
 419
 420 module_platform_driver(ktd2692_driver);
 421
 422 MODULE_AUTHOR("Ingi Kim <ingi2.kim@samsung.com>");
 423 MODULE_DESCRIPTION("Kinetic KTD2692 LED driver");
 424 MODULE_LICENSE("GPL v2");