linux/drivers/leds/leds-max77693.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * LED Flash class driver for the flash cell of max77693 mfd.
   4 *
   5 *      Copyright (C) 2015, Samsung Electronics Co., Ltd.
   6 *
   7 *      Authors: Jacek Anaszewski <j.anaszewski@samsung.com>
   8 *               Andrzej Hajda <a.hajda@samsung.com>
   9 */
  10
  11#include <linux/led-class-flash.h>
  12#include <linux/mfd/max77693.h>
  13#include <linux/mfd/max77693-common.h>
  14#include <linux/mfd/max77693-private.h>
  15#include <linux/module.h>
  16#include <linux/mutex.h>
  17#include <linux/platform_device.h>
  18#include <linux/regmap.h>
  19#include <linux/slab.h>
  20#include <media/v4l2-flash-led-class.h>
  21
  22#define MODE_OFF                0
  23#define MODE_FLASH(a)           (1 << (a))
  24#define MODE_TORCH(a)           (1 << (2 + (a)))
  25#define MODE_FLASH_EXTERNAL(a)  (1 << (4 + (a)))
  26
  27#define MODE_FLASH_MASK         (MODE_FLASH(FLED1) | MODE_FLASH(FLED2) | \
  28                                 MODE_FLASH_EXTERNAL(FLED1) | \
  29                                 MODE_FLASH_EXTERNAL(FLED2))
  30#define MODE_TORCH_MASK         (MODE_TORCH(FLED1) | MODE_TORCH(FLED2))
  31
  32#define FLED1_IOUT              (1 << 0)
  33#define FLED2_IOUT              (1 << 1)
  34
  35enum max77693_fled {
  36        FLED1,
  37        FLED2,
  38};
  39
  40enum max77693_led_mode {
  41        FLASH,
  42        TORCH,
  43};
  44
  45struct max77693_led_config_data {
  46        const char *label[2];
  47        u32 iout_torch_max[2];
  48        u32 iout_flash_max[2];
  49        u32 flash_timeout_max[2];
  50        u32 num_leds;
  51        u32 boost_mode;
  52        u32 boost_vout;
  53        u32 low_vsys;
  54};
  55
  56struct max77693_sub_led {
  57        /* corresponding FLED output identifier */
  58        int fled_id;
  59        /* corresponding LED Flash class device */
  60        struct led_classdev_flash fled_cdev;
  61        /* V4L2 Flash device */
  62        struct v4l2_flash *v4l2_flash;
  63
  64        /* brightness cache */
  65        unsigned int torch_brightness;
  66        /* flash timeout cache */
  67        unsigned int flash_timeout;
  68        /* flash faults that may have occurred */
  69        u32 flash_faults;
  70};
  71
  72struct max77693_led_device {
  73        /* parent mfd regmap */
  74        struct regmap *regmap;
  75        /* platform device data */
  76        struct platform_device *pdev;
  77        /* secures access to the device */
  78        struct mutex lock;
  79
  80        /* sub led data */
  81        struct max77693_sub_led sub_leds[2];
  82
  83        /* maximum torch current values for FLED outputs */
  84        u32 iout_torch_max[2];
  85        /* maximum flash current values for FLED outputs */
  86        u32 iout_flash_max[2];
  87
  88        /* current flash timeout cache */
  89        unsigned int current_flash_timeout;
  90        /* ITORCH register cache */
  91        u8 torch_iout_reg;
  92        /* mode of fled outputs */
  93        unsigned int mode_flags;
  94        /* recently strobed fled */
  95        int strobing_sub_led_id;
  96        /* bitmask of FLED outputs use state (bit 0. - FLED1, bit 1. - FLED2) */
  97        u8 fled_mask;
  98        /* FLED modes that can be set */
  99        u8 allowed_modes;
 100
 101        /* arrangement of current outputs */
 102        bool iout_joint;
 103};
 104
 105static u8 max77693_led_iout_to_reg(u32 ua)
 106{
 107        if (ua < FLASH_IOUT_MIN)
 108                ua = FLASH_IOUT_MIN;
 109        return (ua - FLASH_IOUT_MIN) / FLASH_IOUT_STEP;
 110}
 111
 112static u8 max77693_flash_timeout_to_reg(u32 us)
 113{
 114        return (us - FLASH_TIMEOUT_MIN) / FLASH_TIMEOUT_STEP;
 115}
 116
 117static inline struct max77693_sub_led *flcdev_to_sub_led(
 118                                        struct led_classdev_flash *fled_cdev)
 119{
 120        return container_of(fled_cdev, struct max77693_sub_led, fled_cdev);
 121}
 122
 123static inline struct max77693_led_device *sub_led_to_led(
 124                                        struct max77693_sub_led *sub_led)
 125{
 126        return container_of(sub_led, struct max77693_led_device,
 127                                sub_leds[sub_led->fled_id]);
 128}
 129
 130static inline u8 max77693_led_vsys_to_reg(u32 mv)
 131{
 132        return ((mv - MAX_FLASH1_VSYS_MIN) / MAX_FLASH1_VSYS_STEP) << 2;
 133}
 134
 135static inline u8 max77693_led_vout_to_reg(u32 mv)
 136{
 137        return (mv - FLASH_VOUT_MIN) / FLASH_VOUT_STEP + FLASH_VOUT_RMIN;
 138}
 139
 140static inline bool max77693_fled_used(struct max77693_led_device *led,
 141                                         int fled_id)
 142{
 143        u8 fled_bit = (fled_id == FLED1) ? FLED1_IOUT : FLED2_IOUT;
 144
 145        return led->fled_mask & fled_bit;
 146}
 147
 148static int max77693_set_mode_reg(struct max77693_led_device *led, u8 mode)
 149{
 150        struct regmap *rmap = led->regmap;
 151        int ret, v = 0, i;
 152
 153        for (i = FLED1; i <= FLED2; ++i) {
 154                if (mode & MODE_TORCH(i))
 155                        v |= FLASH_EN_ON << TORCH_EN_SHIFT(i);
 156
 157                if (mode & MODE_FLASH(i)) {
 158                        v |= FLASH_EN_ON << FLASH_EN_SHIFT(i);
 159                } else if (mode & MODE_FLASH_EXTERNAL(i)) {
 160                        v |= FLASH_EN_FLASH << FLASH_EN_SHIFT(i);
 161                        /*
 162                         * Enable hw triggering also for torch mode, as some
 163                         * camera sensors use torch led to fathom ambient light
 164                         * conditions before strobing the flash.
 165                         */
 166                        v |= FLASH_EN_TORCH << TORCH_EN_SHIFT(i);
 167                }
 168        }
 169
 170        /* Reset the register only prior setting flash modes */
 171        if (mode & ~(MODE_TORCH(FLED1) | MODE_TORCH(FLED2))) {
 172                ret = regmap_write(rmap, MAX77693_LED_REG_FLASH_EN, 0);
 173                if (ret < 0)
 174                        return ret;
 175        }
 176
 177        return regmap_write(rmap, MAX77693_LED_REG_FLASH_EN, v);
 178}
 179
 180static int max77693_add_mode(struct max77693_led_device *led, u8 mode)
 181{
 182        u8 new_mode_flags;
 183        int i, ret;
 184
 185        if (led->iout_joint)
 186                /* Span the mode on FLED2 for joint iouts case */
 187                mode |= (mode << 1);
 188
 189        /*
 190         * FLASH_EXTERNAL mode activates FLASHEN and TORCHEN pins in the device.
 191         * Corresponding register bit fields interfere with SW triggered modes,
 192         * thus clear them to ensure proper device configuration.
 193         */
 194        for (i = FLED1; i <= FLED2; ++i)
 195                if (mode & MODE_FLASH_EXTERNAL(i))
 196                        led->mode_flags &= (~MODE_TORCH(i) & ~MODE_FLASH(i));
 197
 198        new_mode_flags = mode | led->mode_flags;
 199        new_mode_flags &= led->allowed_modes;
 200
 201        if (new_mode_flags ^ led->mode_flags)
 202                led->mode_flags = new_mode_flags;
 203        else
 204                return 0;
 205
 206        ret = max77693_set_mode_reg(led, led->mode_flags);
 207        if (ret < 0)
 208                return ret;
 209
 210        /*
 211         * Clear flash mode flag after setting the mode to avoid spurious flash
 212         * strobing on each subsequent torch mode setting.
 213         */
 214        if (mode & MODE_FLASH_MASK)
 215                led->mode_flags &= ~mode;
 216
 217        return ret;
 218}
 219
 220static int max77693_clear_mode(struct max77693_led_device *led,
 221                                u8 mode)
 222{
 223        if (led->iout_joint)
 224                /* Clear mode also on FLED2 for joint iouts case */
 225                mode |= (mode << 1);
 226
 227        led->mode_flags &= ~mode;
 228
 229        return max77693_set_mode_reg(led, led->mode_flags);
 230}
 231
 232static void max77693_add_allowed_modes(struct max77693_led_device *led,
 233                                int fled_id, enum max77693_led_mode mode)
 234{
 235        if (mode == FLASH)
 236                led->allowed_modes |= (MODE_FLASH(fled_id) |
 237                                       MODE_FLASH_EXTERNAL(fled_id));
 238        else
 239                led->allowed_modes |= MODE_TORCH(fled_id);
 240}
 241
 242static void max77693_distribute_currents(struct max77693_led_device *led,
 243                                int fled_id, enum max77693_led_mode mode,
 244                                u32 micro_amp, u32 iout_max[2], u32 iout[2])
 245{
 246        if (!led->iout_joint) {
 247                iout[fled_id] = micro_amp;
 248                max77693_add_allowed_modes(led, fled_id, mode);
 249                return;
 250        }
 251
 252        iout[FLED1] = min(micro_amp, iout_max[FLED1]);
 253        iout[FLED2] = micro_amp - iout[FLED1];
 254
 255        if (mode == FLASH)
 256                led->allowed_modes &= ~MODE_FLASH_MASK;
 257        else
 258                led->allowed_modes &= ~MODE_TORCH_MASK;
 259
 260        max77693_add_allowed_modes(led, FLED1, mode);
 261
 262        if (iout[FLED2])
 263                max77693_add_allowed_modes(led, FLED2, mode);
 264}
 265
 266static int max77693_set_torch_current(struct max77693_led_device *led,
 267                                int fled_id, u32 micro_amp)
 268{
 269        struct regmap *rmap = led->regmap;
 270        u8 iout1_reg = 0, iout2_reg = 0;
 271        u32 iout[2];
 272
 273        max77693_distribute_currents(led, fled_id, TORCH, micro_amp,
 274                                        led->iout_torch_max, iout);
 275
 276        if (fled_id == FLED1 || led->iout_joint) {
 277                iout1_reg = max77693_led_iout_to_reg(iout[FLED1]);
 278                led->torch_iout_reg &= TORCH_IOUT_MASK(TORCH_IOUT2_SHIFT);
 279        }
 280        if (fled_id == FLED2 || led->iout_joint) {
 281                iout2_reg = max77693_led_iout_to_reg(iout[FLED2]);
 282                led->torch_iout_reg &= TORCH_IOUT_MASK(TORCH_IOUT1_SHIFT);
 283        }
 284
 285        led->torch_iout_reg |= ((iout1_reg << TORCH_IOUT1_SHIFT) |
 286                                (iout2_reg << TORCH_IOUT2_SHIFT));
 287
 288        return regmap_write(rmap, MAX77693_LED_REG_ITORCH,
 289                                                led->torch_iout_reg);
 290}
 291
 292static int max77693_set_flash_current(struct max77693_led_device *led,
 293                                        int fled_id,
 294                                        u32 micro_amp)
 295{
 296        struct regmap *rmap = led->regmap;
 297        u8 iout1_reg, iout2_reg;
 298        u32 iout[2];
 299        int ret = -EINVAL;
 300
 301        max77693_distribute_currents(led, fled_id, FLASH, micro_amp,
 302                                        led->iout_flash_max, iout);
 303
 304        if (fled_id == FLED1 || led->iout_joint) {
 305                iout1_reg = max77693_led_iout_to_reg(iout[FLED1]);
 306                ret = regmap_write(rmap, MAX77693_LED_REG_IFLASH1,
 307                                                        iout1_reg);
 308                if (ret < 0)
 309                        return ret;
 310        }
 311        if (fled_id == FLED2 || led->iout_joint) {
 312                iout2_reg = max77693_led_iout_to_reg(iout[FLED2]);
 313                ret = regmap_write(rmap, MAX77693_LED_REG_IFLASH2,
 314                                                        iout2_reg);
 315        }
 316
 317        return ret;
 318}
 319
 320static int max77693_set_timeout(struct max77693_led_device *led, u32 microsec)
 321{
 322        struct regmap *rmap = led->regmap;
 323        u8 v;
 324        int ret;
 325
 326        v = max77693_flash_timeout_to_reg(microsec) | FLASH_TMR_LEVEL;
 327
 328        ret = regmap_write(rmap, MAX77693_LED_REG_FLASH_TIMER, v);
 329        if (ret < 0)
 330                return ret;
 331
 332        led->current_flash_timeout = microsec;
 333
 334        return 0;
 335}
 336
 337static int max77693_get_strobe_status(struct max77693_led_device *led,
 338                                        bool *state)
 339{
 340        struct regmap *rmap = led->regmap;
 341        unsigned int v;
 342        int ret;
 343
 344        ret = regmap_read(rmap, MAX77693_LED_REG_FLASH_STATUS, &v);
 345        if (ret < 0)
 346                return ret;
 347
 348        *state = v & FLASH_STATUS_FLASH_ON;
 349
 350        return ret;
 351}
 352
 353static int max77693_get_flash_faults(struct max77693_sub_led *sub_led)
 354{
 355        struct max77693_led_device *led = sub_led_to_led(sub_led);
 356        struct regmap *rmap = led->regmap;
 357        unsigned int v;
 358        u8 fault_open_mask, fault_short_mask;
 359        int ret;
 360
 361        sub_led->flash_faults = 0;
 362
 363        if (led->iout_joint) {
 364                fault_open_mask = FLASH_INT_FLED1_OPEN | FLASH_INT_FLED2_OPEN;
 365                fault_short_mask = FLASH_INT_FLED1_SHORT |
 366                                                        FLASH_INT_FLED2_SHORT;
 367        } else {
 368                fault_open_mask = (sub_led->fled_id == FLED1) ?
 369                                                FLASH_INT_FLED1_OPEN :
 370                                                FLASH_INT_FLED2_OPEN;
 371                fault_short_mask = (sub_led->fled_id == FLED1) ?
 372                                                FLASH_INT_FLED1_SHORT :
 373                                                FLASH_INT_FLED2_SHORT;
 374        }
 375
 376        ret = regmap_read(rmap, MAX77693_LED_REG_FLASH_INT, &v);
 377        if (ret < 0)
 378                return ret;
 379
 380        if (v & fault_open_mask)
 381                sub_led->flash_faults |= LED_FAULT_OVER_VOLTAGE;
 382        if (v & fault_short_mask)
 383                sub_led->flash_faults |= LED_FAULT_SHORT_CIRCUIT;
 384        if (v & FLASH_INT_OVER_CURRENT)
 385                sub_led->flash_faults |= LED_FAULT_OVER_CURRENT;
 386
 387        return 0;
 388}
 389
 390static int max77693_setup(struct max77693_led_device *led,
 391                         struct max77693_led_config_data *led_cfg)
 392{
 393        struct regmap *rmap = led->regmap;
 394        int i, first_led, last_led, ret;
 395        u32 max_flash_curr[2];
 396        u8 v;
 397
 398        /*
 399         * Initialize only flash current. Torch current doesn't
 400         * require initialization as ITORCH register is written with
 401         * new value each time brightness_set op is called.
 402         */
 403        if (led->iout_joint) {
 404                first_led = FLED1;
 405                last_led = FLED1;
 406                max_flash_curr[FLED1] = led_cfg->iout_flash_max[FLED1] +
 407                                        led_cfg->iout_flash_max[FLED2];
 408        } else {
 409                first_led = max77693_fled_used(led, FLED1) ? FLED1 : FLED2;
 410                last_led = max77693_fled_used(led, FLED2) ? FLED2 : FLED1;
 411                max_flash_curr[FLED1] = led_cfg->iout_flash_max[FLED1];
 412                max_flash_curr[FLED2] = led_cfg->iout_flash_max[FLED2];
 413        }
 414
 415        for (i = first_led; i <= last_led; ++i) {
 416                ret = max77693_set_flash_current(led, i,
 417                                        max_flash_curr[i]);
 418                if (ret < 0)
 419                        return ret;
 420        }
 421
 422        v = TORCH_TMR_NO_TIMER | MAX77693_LED_TRIG_TYPE_LEVEL;
 423        ret = regmap_write(rmap, MAX77693_LED_REG_ITORCHTIMER, v);
 424        if (ret < 0)
 425                return ret;
 426
 427        if (led_cfg->low_vsys > 0)
 428                v = max77693_led_vsys_to_reg(led_cfg->low_vsys) |
 429                                                MAX_FLASH1_MAX_FL_EN;
 430        else
 431                v = 0;
 432
 433        ret = regmap_write(rmap, MAX77693_LED_REG_MAX_FLASH1, v);
 434        if (ret < 0)
 435                return ret;
 436        ret = regmap_write(rmap, MAX77693_LED_REG_MAX_FLASH2, 0);
 437        if (ret < 0)
 438                return ret;
 439
 440        if (led_cfg->boost_mode == MAX77693_LED_BOOST_FIXED)
 441                v = FLASH_BOOST_FIXED;
 442        else
 443                v = led_cfg->boost_mode | led_cfg->boost_mode << 1;
 444
 445        if (max77693_fled_used(led, FLED1) && max77693_fled_used(led, FLED2))
 446                v |= FLASH_BOOST_LEDNUM_2;
 447
 448        ret = regmap_write(rmap, MAX77693_LED_REG_VOUT_CNTL, v);
 449        if (ret < 0)
 450                return ret;
 451
 452        v = max77693_led_vout_to_reg(led_cfg->boost_vout);
 453        ret = regmap_write(rmap, MAX77693_LED_REG_VOUT_FLASH1, v);
 454        if (ret < 0)
 455                return ret;
 456
 457        return max77693_set_mode_reg(led, MODE_OFF);
 458}
 459
 460/* LED subsystem callbacks */
 461static int max77693_led_brightness_set(struct led_classdev *led_cdev,
 462                                        enum led_brightness value)
 463{
 464        struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev);
 465        struct max77693_sub_led *sub_led = flcdev_to_sub_led(fled_cdev);
 466        struct max77693_led_device *led = sub_led_to_led(sub_led);
 467        int fled_id = sub_led->fled_id, ret;
 468
 469        mutex_lock(&led->lock);
 470
 471        if (value == 0) {
 472                ret = max77693_clear_mode(led, MODE_TORCH(fled_id));
 473                if (ret < 0)
 474                        dev_dbg(&led->pdev->dev,
 475                                "Failed to clear torch mode (%d)\n",
 476                                ret);
 477                goto unlock;
 478        }
 479
 480        ret = max77693_set_torch_current(led, fled_id, value * TORCH_IOUT_STEP);
 481        if (ret < 0) {
 482                dev_dbg(&led->pdev->dev,
 483                        "Failed to set torch current (%d)\n",
 484                        ret);
 485                goto unlock;
 486        }
 487
 488        ret = max77693_add_mode(led, MODE_TORCH(fled_id));
 489        if (ret < 0)
 490                dev_dbg(&led->pdev->dev,
 491                        "Failed to set torch mode (%d)\n",
 492                        ret);
 493unlock:
 494        mutex_unlock(&led->lock);
 495
 496        return ret;
 497}
 498
 499static int max77693_led_flash_brightness_set(
 500                                struct led_classdev_flash *fled_cdev,
 501                                u32 brightness)
 502{
 503        struct max77693_sub_led *sub_led = flcdev_to_sub_led(fled_cdev);
 504        struct max77693_led_device *led = sub_led_to_led(sub_led);
 505        int ret;
 506
 507        mutex_lock(&led->lock);
 508        ret = max77693_set_flash_current(led, sub_led->fled_id, brightness);
 509        mutex_unlock(&led->lock);
 510
 511        return ret;
 512}
 513
 514static int max77693_led_flash_strobe_set(
 515                                struct led_classdev_flash *fled_cdev,
 516                                bool state)
 517{
 518        struct max77693_sub_led *sub_led = flcdev_to_sub_led(fled_cdev);
 519        struct max77693_led_device *led = sub_led_to_led(sub_led);
 520        int fled_id = sub_led->fled_id;
 521        int ret;
 522
 523        mutex_lock(&led->lock);
 524
 525        if (!state) {
 526                ret = max77693_clear_mode(led, MODE_FLASH(fled_id));
 527                goto unlock;
 528        }
 529
 530        if (sub_led->flash_timeout != led->current_flash_timeout) {
 531                ret = max77693_set_timeout(led, sub_led->flash_timeout);
 532                if (ret < 0)
 533                        goto unlock;
 534        }
 535
 536        led->strobing_sub_led_id = fled_id;
 537
 538        ret = max77693_add_mode(led, MODE_FLASH(fled_id));
 539        if (ret < 0)
 540                goto unlock;
 541
 542        ret = max77693_get_flash_faults(sub_led);
 543
 544unlock:
 545        mutex_unlock(&led->lock);
 546        return ret;
 547}
 548
 549static int max77693_led_flash_fault_get(
 550                                struct led_classdev_flash *fled_cdev,
 551                                u32 *fault)
 552{
 553        struct max77693_sub_led *sub_led = flcdev_to_sub_led(fled_cdev);
 554
 555        *fault = sub_led->flash_faults;
 556
 557        return 0;
 558}
 559
 560static int max77693_led_flash_strobe_get(
 561                                struct led_classdev_flash *fled_cdev,
 562                                bool *state)
 563{
 564        struct max77693_sub_led *sub_led = flcdev_to_sub_led(fled_cdev);
 565        struct max77693_led_device *led = sub_led_to_led(sub_led);
 566        int ret;
 567
 568        if (!state)
 569                return -EINVAL;
 570
 571        mutex_lock(&led->lock);
 572
 573        ret = max77693_get_strobe_status(led, state);
 574
 575        *state = !!(*state && (led->strobing_sub_led_id == sub_led->fled_id));
 576
 577        mutex_unlock(&led->lock);
 578
 579        return ret;
 580}
 581
 582static int max77693_led_flash_timeout_set(
 583                                struct led_classdev_flash *fled_cdev,
 584                                u32 timeout)
 585{
 586        struct max77693_sub_led *sub_led = flcdev_to_sub_led(fled_cdev);
 587        struct max77693_led_device *led = sub_led_to_led(sub_led);
 588
 589        mutex_lock(&led->lock);
 590        sub_led->flash_timeout = timeout;
 591        mutex_unlock(&led->lock);
 592
 593        return 0;
 594}
 595
 596static int max77693_led_parse_dt(struct max77693_led_device *led,
 597                                struct max77693_led_config_data *cfg,
 598                                struct device_node **sub_nodes)
 599{
 600        struct device *dev = &led->pdev->dev;
 601        struct max77693_sub_led *sub_leds = led->sub_leds;
 602        struct device_node *node = dev_of_node(dev), *child_node;
 603        struct property *prop;
 604        u32 led_sources[2];
 605        int i, ret, fled_id;
 606
 607        of_property_read_u32(node, "maxim,boost-mode", &cfg->boost_mode);
 608        of_property_read_u32(node, "maxim,boost-mvout", &cfg->boost_vout);
 609        of_property_read_u32(node, "maxim,mvsys-min", &cfg->low_vsys);
 610
 611        for_each_available_child_of_node(node, child_node) {
 612                prop = of_find_property(child_node, "led-sources", NULL);
 613                if (prop) {
 614                        const __be32 *srcs = NULL;
 615
 616                        for (i = 0; i < ARRAY_SIZE(led_sources); ++i) {
 617                                srcs = of_prop_next_u32(prop, srcs,
 618                                                        &led_sources[i]);
 619                                if (!srcs)
 620                                        break;
 621                        }
 622                } else {
 623                        dev_err(dev,
 624                                "led-sources DT property missing\n");
 625                        of_node_put(child_node);
 626                        return -EINVAL;
 627                }
 628
 629                if (i == 2) {
 630                        fled_id = FLED1;
 631                        led->fled_mask = FLED1_IOUT | FLED2_IOUT;
 632                } else if (led_sources[0] == FLED1) {
 633                        fled_id = FLED1;
 634                        led->fled_mask |= FLED1_IOUT;
 635                } else if (led_sources[0] == FLED2) {
 636                        fled_id = FLED2;
 637                        led->fled_mask |= FLED2_IOUT;
 638                } else {
 639                        dev_err(dev,
 640                                "Wrong led-sources DT property value.\n");
 641                        of_node_put(child_node);
 642                        return -EINVAL;
 643                }
 644
 645                if (sub_nodes[fled_id]) {
 646                        dev_err(dev,
 647                                "Conflicting \"led-sources\" DT properties\n");
 648                        of_node_put(child_node);
 649                        return -EINVAL;
 650                }
 651
 652                sub_nodes[fled_id] = child_node;
 653                sub_leds[fled_id].fled_id = fled_id;
 654
 655                cfg->label[fled_id] =
 656                        of_get_property(child_node, "label", NULL) ? :
 657                                                child_node->name;
 658
 659                ret = of_property_read_u32(child_node, "led-max-microamp",
 660                                        &cfg->iout_torch_max[fled_id]);
 661                if (ret < 0) {
 662                        cfg->iout_torch_max[fled_id] = TORCH_IOUT_MIN;
 663                        dev_warn(dev, "led-max-microamp DT property missing\n");
 664                }
 665
 666                ret = of_property_read_u32(child_node, "flash-max-microamp",
 667                                        &cfg->iout_flash_max[fled_id]);
 668                if (ret < 0) {
 669                        cfg->iout_flash_max[fled_id] = FLASH_IOUT_MIN;
 670                        dev_warn(dev,
 671                                 "flash-max-microamp DT property missing\n");
 672                }
 673
 674                ret = of_property_read_u32(child_node, "flash-max-timeout-us",
 675                                        &cfg->flash_timeout_max[fled_id]);
 676                if (ret < 0) {
 677                        cfg->flash_timeout_max[fled_id] = FLASH_TIMEOUT_MIN;
 678                        dev_warn(dev,
 679                                 "flash-max-timeout-us DT property missing\n");
 680                }
 681
 682                if (++cfg->num_leds == 2 ||
 683                    (max77693_fled_used(led, FLED1) &&
 684                     max77693_fled_used(led, FLED2))) {
 685                        of_node_put(child_node);
 686                        break;
 687                }
 688        }
 689
 690        if (cfg->num_leds == 0) {
 691                dev_err(dev, "No DT child node found for connected LED(s).\n");
 692                return -EINVAL;
 693        }
 694
 695        return 0;
 696}
 697
 698static void clamp_align(u32 *v, u32 min, u32 max, u32 step)
 699{
 700        *v = clamp_val(*v, min, max);
 701        if (step > 1)
 702                *v = (*v - min) / step * step + min;
 703}
 704
 705static void max77693_align_iout_current(struct max77693_led_device *led,
 706                                        u32 *iout, u32 min, u32 max, u32 step)
 707{
 708        int i;
 709
 710        if (led->iout_joint) {
 711                if (iout[FLED1] > min) {
 712                        iout[FLED1] /= 2;
 713                        iout[FLED2] = iout[FLED1];
 714                } else {
 715                        iout[FLED1] = min;
 716                        iout[FLED2] = 0;
 717                        return;
 718                }
 719        }
 720
 721        for (i = FLED1; i <= FLED2; ++i)
 722                if (max77693_fled_used(led, i))
 723                        clamp_align(&iout[i], min, max, step);
 724                else
 725                        iout[i] = 0;
 726}
 727
 728static void max77693_led_validate_configuration(struct max77693_led_device *led,
 729                                        struct max77693_led_config_data *cfg)
 730{
 731        u32 flash_iout_max = cfg->boost_mode ? FLASH_IOUT_MAX_2LEDS :
 732                                               FLASH_IOUT_MAX_1LED;
 733        int i;
 734
 735        if (cfg->num_leds == 1 &&
 736            max77693_fled_used(led, FLED1) && max77693_fled_used(led, FLED2))
 737                led->iout_joint = true;
 738
 739        cfg->boost_mode = clamp_val(cfg->boost_mode, MAX77693_LED_BOOST_NONE,
 740                            MAX77693_LED_BOOST_FIXED);
 741
 742        /* Boost must be enabled if both current outputs are used */
 743        if ((cfg->boost_mode == MAX77693_LED_BOOST_NONE) && led->iout_joint)
 744                cfg->boost_mode = MAX77693_LED_BOOST_FIXED;
 745
 746        max77693_align_iout_current(led, cfg->iout_torch_max,
 747                        TORCH_IOUT_MIN, TORCH_IOUT_MAX, TORCH_IOUT_STEP);
 748
 749        max77693_align_iout_current(led, cfg->iout_flash_max,
 750                        FLASH_IOUT_MIN, flash_iout_max, FLASH_IOUT_STEP);
 751
 752        for (i = 0; i < ARRAY_SIZE(cfg->flash_timeout_max); ++i)
 753                clamp_align(&cfg->flash_timeout_max[i], FLASH_TIMEOUT_MIN,
 754                                FLASH_TIMEOUT_MAX, FLASH_TIMEOUT_STEP);
 755
 756        clamp_align(&cfg->boost_vout, FLASH_VOUT_MIN, FLASH_VOUT_MAX,
 757                                                        FLASH_VOUT_STEP);
 758
 759        if (cfg->low_vsys)
 760                clamp_align(&cfg->low_vsys, MAX_FLASH1_VSYS_MIN,
 761                                MAX_FLASH1_VSYS_MAX, MAX_FLASH1_VSYS_STEP);
 762}
 763
 764static int max77693_led_get_configuration(struct max77693_led_device *led,
 765                                struct max77693_led_config_data *cfg,
 766                                struct device_node **sub_nodes)
 767{
 768        int ret;
 769
 770        ret = max77693_led_parse_dt(led, cfg, sub_nodes);
 771        if (ret < 0)
 772                return ret;
 773
 774        max77693_led_validate_configuration(led, cfg);
 775
 776        memcpy(led->iout_torch_max, cfg->iout_torch_max,
 777                                sizeof(led->iout_torch_max));
 778        memcpy(led->iout_flash_max, cfg->iout_flash_max,
 779                                sizeof(led->iout_flash_max));
 780
 781        return 0;
 782}
 783
 784static const struct led_flash_ops flash_ops = {
 785        .flash_brightness_set   = max77693_led_flash_brightness_set,
 786        .strobe_set             = max77693_led_flash_strobe_set,
 787        .strobe_get             = max77693_led_flash_strobe_get,
 788        .timeout_set            = max77693_led_flash_timeout_set,
 789        .fault_get              = max77693_led_flash_fault_get,
 790};
 791
 792static void max77693_init_flash_settings(struct max77693_sub_led *sub_led,
 793                                 struct max77693_led_config_data *led_cfg)
 794{
 795        struct led_classdev_flash *fled_cdev = &sub_led->fled_cdev;
 796        struct max77693_led_device *led = sub_led_to_led(sub_led);
 797        int fled_id = sub_led->fled_id;
 798        struct led_flash_setting *setting;
 799
 800        /* Init flash intensity setting */
 801        setting = &fled_cdev->brightness;
 802        setting->min = FLASH_IOUT_MIN;
 803        setting->max = led->iout_joint ?
 804                led_cfg->iout_flash_max[FLED1] +
 805                led_cfg->iout_flash_max[FLED2] :
 806                led_cfg->iout_flash_max[fled_id];
 807        setting->step = FLASH_IOUT_STEP;
 808        setting->val = setting->max;
 809
 810        /* Init flash timeout setting */
 811        setting = &fled_cdev->timeout;
 812        setting->min = FLASH_TIMEOUT_MIN;
 813        setting->max = led_cfg->flash_timeout_max[fled_id];
 814        setting->step = FLASH_TIMEOUT_STEP;
 815        setting->val = setting->max;
 816}
 817
 818#if IS_ENABLED(CONFIG_V4L2_FLASH_LED_CLASS)
 819
 820static int max77693_led_external_strobe_set(
 821                                struct v4l2_flash *v4l2_flash,
 822                                bool enable)
 823{
 824        struct max77693_sub_led *sub_led =
 825                                flcdev_to_sub_led(v4l2_flash->fled_cdev);
 826        struct max77693_led_device *led = sub_led_to_led(sub_led);
 827        int fled_id = sub_led->fled_id;
 828        int ret;
 829
 830        mutex_lock(&led->lock);
 831
 832        if (enable)
 833                ret = max77693_add_mode(led, MODE_FLASH_EXTERNAL(fled_id));
 834        else
 835                ret = max77693_clear_mode(led, MODE_FLASH_EXTERNAL(fled_id));
 836
 837        mutex_unlock(&led->lock);
 838
 839        return ret;
 840}
 841
 842static void max77693_init_v4l2_flash_config(struct max77693_sub_led *sub_led,
 843                                struct max77693_led_config_data *led_cfg,
 844                                struct v4l2_flash_config *v4l2_sd_cfg)
 845{
 846        struct max77693_led_device *led = sub_led_to_led(sub_led);
 847        struct device *dev = &led->pdev->dev;
 848        struct max77693_dev *iodev = dev_get_drvdata(dev->parent);
 849        struct i2c_client *i2c = iodev->i2c;
 850        struct led_flash_setting *s;
 851
 852        snprintf(v4l2_sd_cfg->dev_name, sizeof(v4l2_sd_cfg->dev_name),
 853                 "%s %d-%04x", sub_led->fled_cdev.led_cdev.name,
 854                 i2c_adapter_id(i2c->adapter), i2c->addr);
 855
 856        s = &v4l2_sd_cfg->intensity;
 857        s->min = TORCH_IOUT_MIN;
 858        s->max = sub_led->fled_cdev.led_cdev.max_brightness * TORCH_IOUT_STEP;
 859        s->step = TORCH_IOUT_STEP;
 860        s->val = s->max;
 861
 862        /* Init flash faults config */
 863        v4l2_sd_cfg->flash_faults = LED_FAULT_OVER_VOLTAGE |
 864                                LED_FAULT_SHORT_CIRCUIT |
 865                                LED_FAULT_OVER_CURRENT;
 866
 867        v4l2_sd_cfg->has_external_strobe = true;
 868}
 869
 870static const struct v4l2_flash_ops v4l2_flash_ops = {
 871        .external_strobe_set = max77693_led_external_strobe_set,
 872};
 873#else
 874static inline void max77693_init_v4l2_flash_config(
 875                                struct max77693_sub_led *sub_led,
 876                                struct max77693_led_config_data *led_cfg,
 877                                struct v4l2_flash_config *v4l2_sd_cfg)
 878{
 879}
 880static const struct v4l2_flash_ops v4l2_flash_ops;
 881#endif
 882
 883static void max77693_init_fled_cdev(struct max77693_sub_led *sub_led,
 884                                struct max77693_led_config_data *led_cfg)
 885{
 886        struct max77693_led_device *led = sub_led_to_led(sub_led);
 887        int fled_id = sub_led->fled_id;
 888        struct led_classdev_flash *fled_cdev;
 889        struct led_classdev *led_cdev;
 890
 891        /* Initialize LED Flash class device */
 892        fled_cdev = &sub_led->fled_cdev;
 893        fled_cdev->ops = &flash_ops;
 894        led_cdev = &fled_cdev->led_cdev;
 895
 896        led_cdev->name = led_cfg->label[fled_id];
 897
 898        led_cdev->brightness_set_blocking = max77693_led_brightness_set;
 899        led_cdev->max_brightness = (led->iout_joint ?
 900                                        led_cfg->iout_torch_max[FLED1] +
 901                                        led_cfg->iout_torch_max[FLED2] :
 902                                        led_cfg->iout_torch_max[fled_id]) /
 903                                   TORCH_IOUT_STEP;
 904        led_cdev->flags |= LED_DEV_CAP_FLASH;
 905
 906        max77693_init_flash_settings(sub_led, led_cfg);
 907
 908        /* Init flash timeout cache */
 909        sub_led->flash_timeout = fled_cdev->timeout.val;
 910}
 911
 912static int max77693_register_led(struct max77693_sub_led *sub_led,
 913                                 struct max77693_led_config_data *led_cfg,
 914                                 struct device_node *sub_node)
 915{
 916        struct max77693_led_device *led = sub_led_to_led(sub_led);
 917        struct led_classdev_flash *fled_cdev = &sub_led->fled_cdev;
 918        struct device *dev = &led->pdev->dev;
 919        struct v4l2_flash_config v4l2_sd_cfg = {};
 920        int ret;
 921
 922        /* Register in the LED subsystem */
 923        ret = led_classdev_flash_register(dev, fled_cdev);
 924        if (ret < 0)
 925                return ret;
 926
 927        max77693_init_v4l2_flash_config(sub_led, led_cfg, &v4l2_sd_cfg);
 928
 929        /* Register in the V4L2 subsystem. */
 930        sub_led->v4l2_flash = v4l2_flash_init(dev, of_fwnode_handle(sub_node),
 931                                              fled_cdev, &v4l2_flash_ops,
 932                                              &v4l2_sd_cfg);
 933        if (IS_ERR(sub_led->v4l2_flash)) {
 934                ret = PTR_ERR(sub_led->v4l2_flash);
 935                goto err_v4l2_flash_init;
 936        }
 937
 938        return 0;
 939
 940err_v4l2_flash_init:
 941        led_classdev_flash_unregister(fled_cdev);
 942        return ret;
 943}
 944
 945static int max77693_led_probe(struct platform_device *pdev)
 946{
 947        struct device *dev = &pdev->dev;
 948        struct max77693_dev *iodev = dev_get_drvdata(dev->parent);
 949        struct max77693_led_device *led;
 950        struct max77693_sub_led *sub_leds;
 951        struct device_node *sub_nodes[2] = {};
 952        struct max77693_led_config_data led_cfg = {};
 953        int init_fled_cdev[2], i, ret;
 954
 955        led = devm_kzalloc(dev, sizeof(*led), GFP_KERNEL);
 956        if (!led)
 957                return -ENOMEM;
 958
 959        led->pdev = pdev;
 960        led->regmap = iodev->regmap;
 961        led->allowed_modes = MODE_FLASH_MASK;
 962        sub_leds = led->sub_leds;
 963
 964        platform_set_drvdata(pdev, led);
 965        ret = max77693_led_get_configuration(led, &led_cfg, sub_nodes);
 966        if (ret < 0)
 967                return ret;
 968
 969        ret = max77693_setup(led, &led_cfg);
 970        if (ret < 0)
 971                return ret;
 972
 973        mutex_init(&led->lock);
 974
 975        init_fled_cdev[FLED1] =
 976                        led->iout_joint || max77693_fled_used(led, FLED1);
 977        init_fled_cdev[FLED2] =
 978                        !led->iout_joint && max77693_fled_used(led, FLED2);
 979
 980        for (i = FLED1; i <= FLED2; ++i) {
 981                if (!init_fled_cdev[i])
 982                        continue;
 983
 984                /* Initialize LED Flash class device */
 985                max77693_init_fled_cdev(&sub_leds[i], &led_cfg);
 986
 987                /*
 988                 * Register LED Flash class device and corresponding
 989                 * V4L2 Flash device.
 990                 */
 991                ret = max77693_register_led(&sub_leds[i], &led_cfg,
 992                                                sub_nodes[i]);
 993                if (ret < 0) {
 994                        /*
 995                         * At this moment FLED1 might have been already
 996                         * registered and it needs to be released.
 997                         */
 998                        if (i == FLED2)
 999                                goto err_register_led2;
1000                        else
1001                                goto err_register_led1;
1002                }
1003        }
1004
1005        return 0;
1006
1007err_register_led2:
1008        /* It is possible than only FLED2 was to be registered */
1009        if (!init_fled_cdev[FLED1])
1010                goto err_register_led1;
1011        v4l2_flash_release(sub_leds[FLED1].v4l2_flash);
1012        led_classdev_flash_unregister(&sub_leds[FLED1].fled_cdev);
1013err_register_led1:
1014        mutex_destroy(&led->lock);
1015
1016        return ret;
1017}
1018
1019static int max77693_led_remove(struct platform_device *pdev)
1020{
1021        struct max77693_led_device *led = platform_get_drvdata(pdev);
1022        struct max77693_sub_led *sub_leds = led->sub_leds;
1023
1024        if (led->iout_joint || max77693_fled_used(led, FLED1)) {
1025                v4l2_flash_release(sub_leds[FLED1].v4l2_flash);
1026                led_classdev_flash_unregister(&sub_leds[FLED1].fled_cdev);
1027        }
1028
1029        if (!led->iout_joint && max77693_fled_used(led, FLED2)) {
1030                v4l2_flash_release(sub_leds[FLED2].v4l2_flash);
1031                led_classdev_flash_unregister(&sub_leds[FLED2].fled_cdev);
1032        }
1033
1034        mutex_destroy(&led->lock);
1035
1036        return 0;
1037}
1038
1039static const struct of_device_id max77693_led_dt_match[] = {
1040        { .compatible = "maxim,max77693-led" },
1041        {},
1042};
1043MODULE_DEVICE_TABLE(of, max77693_led_dt_match);
1044
1045static struct platform_driver max77693_led_driver = {
1046        .probe          = max77693_led_probe,
1047        .remove         = max77693_led_remove,
1048        .driver         = {
1049                .name   = "max77693-led",
1050                .of_match_table = max77693_led_dt_match,
1051        },
1052};
1053
1054module_platform_driver(max77693_led_driver);
1055
1056MODULE_AUTHOR("Jacek Anaszewski <j.anaszewski@samsung.com>");
1057MODULE_AUTHOR("Andrzej Hajda <a.hajda@samsung.com>");
1058MODULE_DESCRIPTION("Maxim MAX77693 led flash driver");
1059MODULE_LICENSE("GPL v2");
1060