leds-qcom-lpg.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2017-2022 Linaro Ltd
   4  * Copyright (c) 2010-2012, The Linux Foundation. All rights reserved.
   5  */
   6 #include <linux/bits.h>
   7 #include <linux/bitfield.h>
   8 #include <linux/led-class-multicolor.h>
   9 #include <linux/module.h>
  10 #include <linux/of.h>
  11 #include <linux/of_device.h>
  12 #include <linux/platform_device.h>
  13 #include <linux/pwm.h>
  14 #include <linux/regmap.h>
  15 #include <linux/slab.h>
  16
  17 #define LPG_SUBTYPE_REG         0x05
  18 #define  LPG_SUBTYPE_LPG        0x2
  19 #define  LPG_SUBTYPE_PWM        0xb
  20 #define  LPG_SUBTYPE_LPG_LITE   0x11
  21 #define LPG_PATTERN_CONFIG_REG  0x40
  22 #define LPG_SIZE_CLK_REG        0x41
  23 #define  PWM_CLK_SELECT_MASK    GENMASK(1, 0)
  24 #define LPG_PREDIV_CLK_REG      0x42
  25 #define  PWM_FREQ_PRE_DIV_MASK  GENMASK(6, 5)
  26 #define  PWM_FREQ_EXP_MASK      GENMASK(2, 0)
  27 #define PWM_TYPE_CONFIG_REG     0x43
  28 #define PWM_VALUE_REG           0x44
  29 #define PWM_ENABLE_CONTROL_REG  0x46
  30 #define PWM_SYNC_REG            0x47
  31 #define LPG_RAMP_DURATION_REG   0x50
  32 #define LPG_HI_PAUSE_REG        0x52
  33 #define LPG_LO_PAUSE_REG        0x54
  34 #define LPG_HI_IDX_REG          0x56
  35 #define LPG_LO_IDX_REG          0x57
  36 #define PWM_SEC_ACCESS_REG      0xd0
  37 #define PWM_DTEST_REG(x)        (0xe2 + (x) - 1)
  38
  39 #define TRI_LED_SRC_SEL         0x45
  40 #define TRI_LED_EN_CTL          0x46
  41 #define TRI_LED_ATC_CTL         0x47
  42
  43 #define LPG_LUT_REG(x)          (0x40 + (x) * 2)
  44 #define RAMP_CONTROL_REG        0xc8
  45
  46 #define LPG_RESOLUTION          512
  47 #define LPG_MAX_M               7
  48
  49 struct lpg_channel;
  50 struct lpg_data;
  51
  52 /**
  53  * struct lpg - LPG device context
  54  * @dev:        pointer to LPG device
  55  * @map:        regmap for register access
  56  * @lock:       used to synchronize LED and pwm callback requests
  57  * @pwm:        PWM-chip object, if operating in PWM mode
  58  * @data:       reference to version specific data
  59  * @lut_base:   base address of the LUT block (optional)
  60  * @lut_size:   number of entries in the LUT block
  61  * @lut_bitmap: allocation bitmap for LUT entries
  62  * @triled_base: base address of the TRILED block (optional)
  63  * @triled_src: power-source for the TRILED
  64  * @triled_has_atc_ctl: true if there is TRI_LED_ATC_CTL register
  65  * @triled_has_src_sel: true if there is TRI_LED_SRC_SEL register
  66  * @channels:   list of PWM channels
  67  * @num_channels: number of @channels
  68  */
  69 struct lpg {
  70         struct device *dev;
  71         struct regmap *map;
  72
  73         struct mutex lock;
  74
  75         struct pwm_chip pwm;
  76
  77         const struct lpg_data *data;
  78
  79         u32 lut_base;
  80         u32 lut_size;
  81         unsigned long *lut_bitmap;
  82
  83         u32 triled_base;
  84         u32 triled_src;
  85         bool triled_has_atc_ctl;
  86         bool triled_has_src_sel;
  87
  88         struct lpg_channel *channels;
  89         unsigned int num_channels;
  90 };
  91
  92 /**
  93  * struct lpg_channel - per channel data
  94  * @lpg:        reference to parent lpg
  95  * @base:       base address of the PWM channel
  96  * @triled_mask: mask in TRILED to enable this channel
  97  * @lut_mask:   mask in LUT to start pattern generator for this channel
  98  * @subtype:    PMIC hardware block subtype
  99  * @in_use:     channel is exposed to LED framework
 100  * @color:      color of the LED attached to this channel
 101  * @dtest_line: DTEST line for output, or 0 if disabled
 102  * @dtest_value: DTEST line configuration
 103  * @pwm_value:  duty (in microseconds) of the generated pulses, overridden by LUT
 104  * @enabled:    output enabled?
 105  * @period:     period (in nanoseconds) of the generated pulses
 106  * @clk_sel:    reference clock frequency selector
 107  * @pre_div_sel: divider selector of the reference clock
 108  * @pre_div_exp: exponential divider of the reference clock
 109  * @ramp_enabled: duty cycle is driven by iterating over lookup table
 110  * @ramp_ping_pong: reverse through pattern, rather than wrapping to start
 111  * @ramp_oneshot: perform only a single pass over the pattern
 112  * @ramp_reverse: iterate over pattern backwards
 113  * @ramp_tick_ms: length (in milliseconds) of one step in the pattern
 114  * @ramp_lo_pause_ms: pause (in milliseconds) before iterating over pattern
 115  * @ramp_hi_pause_ms: pause (in milliseconds) after iterating over pattern
 116  * @pattern_lo_idx: start index of associated pattern
 117  * @pattern_hi_idx: last index of associated pattern
 118  */
 119 struct lpg_channel {
 120         struct lpg *lpg;
 121
 122         u32 base;
 123         unsigned int triled_mask;
 124         unsigned int lut_mask;
 125         unsigned int subtype;
 126
 127         bool in_use;
 128
 129         int color;
 130
 131         u32 dtest_line;
 132         u32 dtest_value;
 133
 134         u16 pwm_value;
 135         bool enabled;
 136
 137         u64 period;
 138         unsigned int clk_sel;
 139         unsigned int pre_div_sel;
 140         unsigned int pre_div_exp;
 141
 142         bool ramp_enabled;
 143         bool ramp_ping_pong;
 144         bool ramp_oneshot;
 145         bool ramp_reverse;
 146         unsigned short ramp_tick_ms;
 147         unsigned long ramp_lo_pause_ms;
 148         unsigned long ramp_hi_pause_ms;
 149
 150         unsigned int pattern_lo_idx;
 151         unsigned int pattern_hi_idx;
 152 };
 153
 154 /**
 155  * struct lpg_led - logical LED object
 156  * @lpg:                lpg context reference
 157  * @cdev:               LED class device
 158  * @mcdev:              Multicolor LED class device
 159  * @num_channels:       number of @channels
 160  * @channels:           list of channels associated with the LED
 161  */
 162 struct lpg_led {
 163         struct lpg *lpg;
 164
 165         struct led_classdev cdev;
 166         struct led_classdev_mc mcdev;
 167
 168         unsigned int num_channels;
 169         struct lpg_channel *channels[];
 170 };
 171
 172 /**
 173  * struct lpg_channel_data - per channel initialization data
 174  * @base:               base address for PWM channel registers
 175  * @triled_mask:        bitmask for controlling this channel in TRILED
 176  */
 177 struct lpg_channel_data {
 178         unsigned int base;
 179         u8 triled_mask;
 180 };
 181
 182 /**
 183  * struct lpg_data - initialization data
 184  * @lut_base:           base address of LUT block
 185  * @lut_size:           number of entries in LUT
 186  * @triled_base:        base address of TRILED
 187  * @triled_has_atc_ctl: true if there is TRI_LED_ATC_CTL register
 188  * @triled_has_src_sel: true if there is TRI_LED_SRC_SEL register
 189  * @num_channels:       number of channels in LPG
 190  * @channels:           list of channel initialization data
 191  */
 192 struct lpg_data {
 193         unsigned int lut_base;
 194         unsigned int lut_size;
 195         unsigned int triled_base;
 196         bool triled_has_atc_ctl;
 197         bool triled_has_src_sel;
 198         int num_channels;
 199         const struct lpg_channel_data *channels;
 200 };
 201
 202 static int triled_set(struct lpg *lpg, unsigned int mask, unsigned int enable)
 203 {
 204         /* Skip if we don't have a triled block */
 205         if (!lpg->triled_base)
 206                 return 0;
 207
 208         return regmap_update_bits(lpg->map, lpg->triled_base + TRI_LED_EN_CTL,
 209                                   mask, enable);
 210 }
 211
 212 static int lpg_lut_store(struct lpg *lpg, struct led_pattern *pattern,
 213                          size_t len, unsigned int *lo_idx, unsigned int *hi_idx)
 214 {
 215         unsigned int idx;
 216         u16 val;
 217         int i;
 218
 219         idx = bitmap_find_next_zero_area(lpg->lut_bitmap, lpg->lut_size,
 220                                          0, len, 0);
 221         if (idx >= lpg->lut_size)
 222                 return -ENOMEM;
 223
 224         for (i = 0; i < len; i++) {
 225                 val = pattern[i].brightness;
 226
 227                 regmap_bulk_write(lpg->map, lpg->lut_base + LPG_LUT_REG(idx + i),
 228                                   &val, sizeof(val));
 229         }
 230
 231         bitmap_set(lpg->lut_bitmap, idx, len);
 232
 233         *lo_idx = idx;
 234         *hi_idx = idx + len - 1;
 235
 236         return 0;
 237 }
 238
 239 static void lpg_lut_free(struct lpg *lpg, unsigned int lo_idx, unsigned int hi_idx)
 240 {
 241         int len;
 242
 243         len = hi_idx - lo_idx + 1;
 244         if (len == 1)
 245                 return;
 246
 247         bitmap_clear(lpg->lut_bitmap, lo_idx, len);
 248 }
 249
 250 static int lpg_lut_sync(struct lpg *lpg, unsigned int mask)
 251 {
 252         return regmap_write(lpg->map, lpg->lut_base + RAMP_CONTROL_REG, mask);
 253 }
 254
 255 static const unsigned int lpg_clk_rates[] = {0, 1024, 32768, 19200000};
 256 static const unsigned int lpg_pre_divs[] = {1, 3, 5, 6};
 257
 258 static int lpg_calc_freq(struct lpg_channel *chan, uint64_t period)
 259 {
 260         unsigned int clk_sel, best_clk = 0;
 261         unsigned int div, best_div = 0;
 262         unsigned int m, best_m = 0;
 263         unsigned int error;
 264         unsigned int best_err = UINT_MAX;
 265         u64 best_period = 0;
 266         u64 max_period;
 267
 268         /*
 269          * The PWM period is determined by:
 270          *
 271          *          resolution * pre_div * 2^M
 272          * period = --------------------------
 273          *                   refclk
 274          *
 275          * With resolution fixed at 2^9 bits, pre_div = {1, 3, 5, 6} and
 276          * M = [0..7].
 277          *
 278          * This allows for periods between 27uS and 384s, as the PWM framework
 279          * wants a period of equal or lower length than requested, reject
 280          * anything below 27uS.
 281          */
 282         if (period <= (u64)NSEC_PER_SEC * LPG_RESOLUTION / 19200000)
 283                 return -EINVAL;
 284
 285         /* Limit period to largest possible value, to avoid overflows */
 286         max_period = (u64)NSEC_PER_SEC * LPG_RESOLUTION * 6 * (1 << LPG_MAX_M) / 1024;
 287         if (period > max_period)
 288                 period = max_period;
 289
 290         /*
 291          * Search for the pre_div, refclk and M by solving the rewritten formula
 292          * for each refclk and pre_div value:
 293          *
 294          *                     period * refclk
 295          * M = log2 -------------------------------------
 296          *           NSEC_PER_SEC * pre_div * resolution
 297          */
 298         for (clk_sel = 1; clk_sel < ARRAY_SIZE(lpg_clk_rates); clk_sel++) {
 299                 u64 numerator = period * lpg_clk_rates[clk_sel];
 300
 301                 for (div = 0; div < ARRAY_SIZE(lpg_pre_divs); div++) {
 302                         u64 denominator = (u64)NSEC_PER_SEC * lpg_pre_divs[div] * LPG_RESOLUTION;
 303                         u64 actual;
 304                         u64 ratio;
 305
 306                         if (numerator < denominator)
 307                                 continue;
 308
 309                         ratio = div64_u64(numerator, denominator);
 310                         m = ilog2(ratio);
 311                         if (m > LPG_MAX_M)
 312                                 m = LPG_MAX_M;
 313
 314                         actual = DIV_ROUND_UP_ULL(denominator * (1 << m), lpg_clk_rates[clk_sel]);
 315
 316                         error = period - actual;
 317                         if (error < best_err) {
 318                                 best_err = error;
 319
 320                                 best_div = div;
 321                                 best_m = m;
 322                                 best_clk = clk_sel;
 323                                 best_period = actual;
 324                         }
 325                 }
 326         }
 327
 328         chan->clk_sel = best_clk;
 329         chan->pre_div_sel = best_div;
 330         chan->pre_div_exp = best_m;
 331         chan->period = best_period;
 332
 333         return 0;
 334 }
 335
 336 static void lpg_calc_duty(struct lpg_channel *chan, uint64_t duty)
 337 {
 338         unsigned int max = LPG_RESOLUTION - 1;
 339         unsigned int val;
 340
 341         val = div64_u64(duty * lpg_clk_rates[chan->clk_sel],
 342                         (u64)NSEC_PER_SEC * lpg_pre_divs[chan->pre_div_sel] * (1 << chan->pre_div_exp));
 343
 344         chan->pwm_value = min(val, max);
 345 }
 346
 347 static void lpg_apply_freq(struct lpg_channel *chan)
 348 {
 349         unsigned long val;
 350         struct lpg *lpg = chan->lpg;
 351
 352         if (!chan->enabled)
 353                 return;
 354
 355         val = chan->clk_sel;
 356
 357         /* Specify 9bit resolution, based on the subtype of the channel */
 358         switch (chan->subtype) {
 359         case LPG_SUBTYPE_LPG:
 360                 val |= GENMASK(5, 4);
 361                 break;
 362         case LPG_SUBTYPE_PWM:
 363                 val |= BIT(2);
 364                 break;
 365         case LPG_SUBTYPE_LPG_LITE:
 366         default:
 367                 val |= BIT(4);
 368                 break;
 369         }
 370
 371         regmap_write(lpg->map, chan->base + LPG_SIZE_CLK_REG, val);
 372
 373         val = FIELD_PREP(PWM_FREQ_PRE_DIV_MASK, chan->pre_div_sel) |
 374               FIELD_PREP(PWM_FREQ_EXP_MASK, chan->pre_div_exp);
 375         regmap_write(lpg->map, chan->base + LPG_PREDIV_CLK_REG, val);
 376 }
 377
 378 #define LPG_ENABLE_GLITCH_REMOVAL       BIT(5)
 379
 380 static void lpg_enable_glitch(struct lpg_channel *chan)
 381 {
 382         struct lpg *lpg = chan->lpg;
 383
 384         regmap_update_bits(lpg->map, chan->base + PWM_TYPE_CONFIG_REG,
 385                            LPG_ENABLE_GLITCH_REMOVAL, 0);
 386 }
 387
 388 static void lpg_disable_glitch(struct lpg_channel *chan)
 389 {
 390         struct lpg *lpg = chan->lpg;
 391
 392         regmap_update_bits(lpg->map, chan->base + PWM_TYPE_CONFIG_REG,
 393                            LPG_ENABLE_GLITCH_REMOVAL,
 394                            LPG_ENABLE_GLITCH_REMOVAL);
 395 }
 396
 397 static void lpg_apply_pwm_value(struct lpg_channel *chan)
 398 {
 399         struct lpg *lpg = chan->lpg;
 400         u16 val = chan->pwm_value;
 401
 402         if (!chan->enabled)
 403                 return;
 404
 405         regmap_bulk_write(lpg->map, chan->base + PWM_VALUE_REG, &val, sizeof(val));
 406 }
 407
 408 #define LPG_PATTERN_CONFIG_LO_TO_HI     BIT(4)
 409 #define LPG_PATTERN_CONFIG_REPEAT       BIT(3)
 410 #define LPG_PATTERN_CONFIG_TOGGLE       BIT(2)
 411 #define LPG_PATTERN_CONFIG_PAUSE_HI     BIT(1)
 412 #define LPG_PATTERN_CONFIG_PAUSE_LO     BIT(0)
 413
 414 static void lpg_apply_lut_control(struct lpg_channel *chan)
 415 {
 416         struct lpg *lpg = chan->lpg;
 417         unsigned int hi_pause;
 418         unsigned int lo_pause;
 419         unsigned int conf = 0;
 420         unsigned int lo_idx = chan->pattern_lo_idx;
 421         unsigned int hi_idx = chan->pattern_hi_idx;
 422         u16 step = chan->ramp_tick_ms;
 423
 424         if (!chan->ramp_enabled || chan->pattern_lo_idx == chan->pattern_hi_idx)
 425                 return;
 426
 427         hi_pause = DIV_ROUND_UP(chan->ramp_hi_pause_ms, step);
 428         lo_pause = DIV_ROUND_UP(chan->ramp_lo_pause_ms, step);
 429
 430         if (!chan->ramp_reverse)
 431                 conf |= LPG_PATTERN_CONFIG_LO_TO_HI;
 432         if (!chan->ramp_oneshot)
 433                 conf |= LPG_PATTERN_CONFIG_REPEAT;
 434         if (chan->ramp_ping_pong)
 435                 conf |= LPG_PATTERN_CONFIG_TOGGLE;
 436         if (chan->ramp_hi_pause_ms)
 437                 conf |= LPG_PATTERN_CONFIG_PAUSE_HI;
 438         if (chan->ramp_lo_pause_ms)
 439                 conf |= LPG_PATTERN_CONFIG_PAUSE_LO;
 440
 441         regmap_write(lpg->map, chan->base + LPG_PATTERN_CONFIG_REG, conf);
 442         regmap_write(lpg->map, chan->base + LPG_HI_IDX_REG, hi_idx);
 443         regmap_write(lpg->map, chan->base + LPG_LO_IDX_REG, lo_idx);
 444
 445         regmap_bulk_write(lpg->map, chan->base + LPG_RAMP_DURATION_REG, &step, sizeof(step));
 446         regmap_write(lpg->map, chan->base + LPG_HI_PAUSE_REG, hi_pause);
 447         regmap_write(lpg->map, chan->base + LPG_LO_PAUSE_REG, lo_pause);
 448 }
 449
 450 #define LPG_ENABLE_CONTROL_OUTPUT               BIT(7)
 451 #define LPG_ENABLE_CONTROL_BUFFER_TRISTATE      BIT(5)
 452 #define LPG_ENABLE_CONTROL_SRC_PWM              BIT(2)
 453 #define LPG_ENABLE_CONTROL_RAMP_GEN             BIT(1)
 454
 455 static void lpg_apply_control(struct lpg_channel *chan)
 456 {
 457         unsigned int ctrl;
 458         struct lpg *lpg = chan->lpg;
 459
 460         ctrl = LPG_ENABLE_CONTROL_BUFFER_TRISTATE;
 461
 462         if (chan->enabled)
 463                 ctrl |= LPG_ENABLE_CONTROL_OUTPUT;
 464
 465         if (chan->pattern_lo_idx != chan->pattern_hi_idx)
 466                 ctrl |= LPG_ENABLE_CONTROL_RAMP_GEN;
 467         else
 468                 ctrl |= LPG_ENABLE_CONTROL_SRC_PWM;
 469
 470         regmap_write(lpg->map, chan->base + PWM_ENABLE_CONTROL_REG, ctrl);
 471
 472         /*
 473          * Due to LPG hardware bug, in the PWM mode, having enabled PWM,
 474          * We have to write PWM values one more time.
 475          */
 476         if (chan->enabled)
 477                 lpg_apply_pwm_value(chan);
 478 }
 479
 480 #define LPG_SYNC_PWM    BIT(0)
 481
 482 static void lpg_apply_sync(struct lpg_channel *chan)
 483 {
 484         struct lpg *lpg = chan->lpg;
 485
 486         regmap_write(lpg->map, chan->base + PWM_SYNC_REG, LPG_SYNC_PWM);
 487 }
 488
 489 static int lpg_parse_dtest(struct lpg *lpg)
 490 {
 491         struct lpg_channel *chan;
 492         struct device_node *np = lpg->dev->of_node;
 493         int count;
 494         int ret;
 495         int i;
 496
 497         count = of_property_count_u32_elems(np, "qcom,dtest");
 498         if (count == -EINVAL) {
 499                 return 0;
 500         } else if (count < 0) {
 501                 ret = count;
 502                 goto err_malformed;
 503         } else if (count != lpg->data->num_channels * 2) {
 504                 dev_err(lpg->dev, "qcom,dtest needs to be %d items\n",
 505                         lpg->data->num_channels * 2);
 506                 return -EINVAL;
 507         }
 508
 509         for (i = 0; i < lpg->data->num_channels; i++) {
 510                 chan = &lpg->channels[i];
 511
 512                 ret = of_property_read_u32_index(np, "qcom,dtest", i * 2,
 513                                                  &chan->dtest_line);
 514                 if (ret)
 515                         goto err_malformed;
 516
 517                 ret = of_property_read_u32_index(np, "qcom,dtest", i * 2 + 1,
 518                                                  &chan->dtest_value);
 519                 if (ret)
 520                         goto err_malformed;
 521         }
 522
 523         return 0;
 524
 525 err_malformed:
 526         dev_err(lpg->dev, "malformed qcom,dtest\n");
 527         return ret;
 528 }
 529
 530 static void lpg_apply_dtest(struct lpg_channel *chan)
 531 {
 532         struct lpg *lpg = chan->lpg;
 533
 534         if (!chan->dtest_line)
 535                 return;
 536
 537         regmap_write(lpg->map, chan->base + PWM_SEC_ACCESS_REG, 0xa5);
 538         regmap_write(lpg->map, chan->base + PWM_DTEST_REG(chan->dtest_line),
 539                      chan->dtest_value);
 540 }
 541
 542 static void lpg_apply(struct lpg_channel *chan)
 543 {
 544         lpg_disable_glitch(chan);
 545         lpg_apply_freq(chan);
 546         lpg_apply_pwm_value(chan);
 547         lpg_apply_control(chan);
 548         lpg_apply_sync(chan);
 549         lpg_apply_lut_control(chan);
 550         lpg_enable_glitch(chan);
 551 }
 552
 553 static void lpg_brightness_set(struct lpg_led *led, struct led_classdev *cdev,
 554                                struct mc_subled *subleds)
 555 {
 556         enum led_brightness brightness;
 557         struct lpg_channel *chan;
 558         unsigned int triled_enabled = 0;
 559         unsigned int triled_mask = 0;
 560         unsigned int lut_mask = 0;
 561         unsigned int duty;
 562         struct lpg *lpg = led->lpg;
 563         int i;
 564
 565         for (i = 0; i < led->num_channels; i++) {
 566                 chan = led->channels[i];
 567                 brightness = subleds[i].brightness;
 568
 569                 if (brightness == LED_OFF) {
 570                         chan->enabled = false;
 571                         chan->ramp_enabled = false;
 572                 } else if (chan->pattern_lo_idx != chan->pattern_hi_idx) {
 573                         lpg_calc_freq(chan, NSEC_PER_MSEC);
 574
 575                         chan->enabled = true;
 576                         chan->ramp_enabled = true;
 577
 578                         lut_mask |= chan->lut_mask;
 579                         triled_enabled |= chan->triled_mask;
 580                 } else {
 581                         lpg_calc_freq(chan, NSEC_PER_MSEC);
 582
 583                         duty = div_u64(brightness * chan->period, cdev->max_brightness);
 584                         lpg_calc_duty(chan, duty);
 585                         chan->enabled = true;
 586                         chan->ramp_enabled = false;
 587
 588                         triled_enabled |= chan->triled_mask;
 589                 }
 590
 591                 triled_mask |= chan->triled_mask;
 592
 593                 lpg_apply(chan);
 594         }
 595
 596         /* Toggle triled lines */
 597         if (triled_mask)
 598                 triled_set(lpg, triled_mask, triled_enabled);
 599
 600         /* Trigger start of ramp generator(s) */
 601         if (lut_mask)
 602                 lpg_lut_sync(lpg, lut_mask);
 603 }
 604
 605 static void lpg_brightness_single_set(struct led_classdev *cdev,
 606                                       enum led_brightness value)
 607 {
 608         struct lpg_led *led = container_of(cdev, struct lpg_led, cdev);
 609         struct mc_subled info;
 610
 611         mutex_lock(&led->lpg->lock);
 612
 613         info.brightness = value;
 614         lpg_brightness_set(led, cdev, &info);
 615
 616         mutex_unlock(&led->lpg->lock);
 617 }
 618
 619 static void lpg_brightness_mc_set(struct led_classdev *cdev,
 620                                   enum led_brightness value)
 621 {
 622         struct led_classdev_mc *mc = lcdev_to_mccdev(cdev);
 623         struct lpg_led *led = container_of(mc, struct lpg_led, mcdev);
 624
 625         mutex_lock(&led->lpg->lock);
 626
 627         led_mc_calc_color_components(mc, value);
 628         lpg_brightness_set(led, cdev, mc->subled_info);
 629
 630         mutex_unlock(&led->lpg->lock);
 631 }
 632
 633 static int lpg_blink_set(struct lpg_led *led,
 634                          unsigned long *delay_on, unsigned long *delay_off)
 635 {
 636         struct lpg_channel *chan;
 637         unsigned int period;
 638         unsigned int triled_mask = 0;
 639         struct lpg *lpg = led->lpg;
 640         u64 duty;
 641         int i;
 642
 643         if (!*delay_on && !*delay_off) {
 644                 *delay_on = 500;
 645                 *delay_off = 500;
 646         }
 647
 648         duty = *delay_on * NSEC_PER_MSEC;
 649         period = (*delay_on + *delay_off) * NSEC_PER_MSEC;
 650
 651         for (i = 0; i < led->num_channels; i++) {
 652                 chan = led->channels[i];
 653
 654                 lpg_calc_freq(chan, period);
 655                 lpg_calc_duty(chan, duty);
 656
 657                 chan->enabled = true;
 658                 chan->ramp_enabled = false;
 659
 660                 triled_mask |= chan->triled_mask;
 661
 662                 lpg_apply(chan);
 663         }
 664
 665         /* Enable triled lines */
 666         triled_set(lpg, triled_mask, triled_mask);
 667
 668         chan = led->channels[0];
 669         duty = div_u64(chan->pwm_value * chan->period, LPG_RESOLUTION);
 670         *delay_on = div_u64(duty, NSEC_PER_MSEC);
 671         *delay_off = div_u64(chan->period - duty, NSEC_PER_MSEC);
 672
 673         return 0;
 674 }
 675
 676 static int lpg_blink_single_set(struct led_classdev *cdev,
 677                                 unsigned long *delay_on, unsigned long *delay_off)
 678 {
 679         struct lpg_led *led = container_of(cdev, struct lpg_led, cdev);
 680         int ret;
 681
 682         mutex_lock(&led->lpg->lock);
 683
 684         ret = lpg_blink_set(led, delay_on, delay_off);
 685
 686         mutex_unlock(&led->lpg->lock);
 687
 688         return ret;
 689 }
 690
 691 static int lpg_blink_mc_set(struct led_classdev *cdev,
 692                             unsigned long *delay_on, unsigned long *delay_off)
 693 {
 694         struct led_classdev_mc *mc = lcdev_to_mccdev(cdev);
 695         struct lpg_led *led = container_of(mc, struct lpg_led, mcdev);
 696         int ret;
 697
 698         mutex_lock(&led->lpg->lock);
 699
 700         ret = lpg_blink_set(led, delay_on, delay_off);
 701
 702         mutex_unlock(&led->lpg->lock);
 703
 704         return ret;
 705 }
 706
 707 static int lpg_pattern_set(struct lpg_led *led, struct led_pattern *led_pattern,
 708                            u32 len, int repeat)
 709 {
 710         struct lpg_channel *chan;
 711         struct lpg *lpg = led->lpg;
 712         struct led_pattern *pattern;
 713         unsigned int brightness_a;
 714         unsigned int brightness_b;
 715         unsigned int actual_len;
 716         unsigned int hi_pause;
 717         unsigned int lo_pause;
 718         unsigned int delta_t;
 719         unsigned int lo_idx;
 720         unsigned int hi_idx;
 721         unsigned int i;
 722         bool ping_pong = true;
 723         int ret = -EINVAL;
 724
 725         /* Hardware only support oneshot or indefinite loops */
 726         if (repeat != -1 && repeat != 1)
 727                 return -EINVAL;
 728
 729         /*
 730          * The standardized leds-trigger-pattern format defines that the
 731          * brightness of the LED follows a linear transition from one entry
 732          * in the pattern to the next, over the given delta_t time. It
 733          * describes that the way to perform instant transitions a zero-length
 734          * entry should be added following a pattern entry.
 735          *
 736          * The LPG hardware is only able to perform the latter (no linear
 737          * transitions), so require each entry in the pattern to be followed by
 738          * a zero-length transition.
 739          */
 740         if (len % 2)
 741                 return -EINVAL;
 742
 743         pattern = kcalloc(len / 2, sizeof(*pattern), GFP_KERNEL);
 744         if (!pattern)
 745                 return -ENOMEM;
 746
 747         for (i = 0; i < len; i += 2) {
 748                 if (led_pattern[i].brightness != led_pattern[i + 1].brightness)
 749                         goto out_free_pattern;
 750                 if (led_pattern[i + 1].delta_t != 0)
 751                         goto out_free_pattern;
 752
 753                 pattern[i / 2].brightness = led_pattern[i].brightness;
 754                 pattern[i / 2].delta_t = led_pattern[i].delta_t;
 755         }
 756
 757         len /= 2;
 758
 759         /*
 760          * Specifying a pattern of length 1 causes the hardware to iterate
 761          * through the entire LUT, so prohibit this.
 762          */
 763         if (len < 2)
 764                 goto out_free_pattern;
 765
 766         /*
 767          * The LPG plays patterns with at a fixed pace, a "low pause" can be
 768          * used to stretch the first delay of the pattern and a "high pause"
 769          * the last one.
 770          *
 771          * In order to save space the pattern can be played in "ping pong"
 772          * mode, in which the pattern is first played forward, then "high
 773          * pause" is applied, then the pattern is played backwards and finally
 774          * the "low pause" is applied.
 775          *
 776          * The middle elements of the pattern are used to determine delta_t and
 777          * the "low pause" and "high pause" multipliers are derrived from this.
 778          *
 779          * The first element in the pattern is used to determine "low pause".
 780          *
 781          * If the specified pattern is a palindrome the ping pong mode is
 782          * enabled. In this scenario the delta_t of the middle entry (i.e. the
 783          * last in the programmed pattern) determines the "high pause".
 784          */
 785
 786         /* Detect palindromes and use "ping pong" to reduce LUT usage */
 787         for (i = 0; i < len / 2; i++) {
 788                 brightness_a = pattern[i].brightness;
 789                 brightness_b = pattern[len - i - 1].brightness;
 790
 791                 if (brightness_a != brightness_b) {
 792                         ping_pong = false;
 793                         break;
 794                 }
 795         }
 796
 797         /* The pattern length to be written to the LUT */
 798         if (ping_pong)
 799                 actual_len = (len + 1) / 2;
 800         else
 801                 actual_len = len;
 802
 803         /*
 804          * Validate that all delta_t in the pattern are the same, with the
 805          * exception of the middle element in case of ping_pong.
 806          */
 807         delta_t = pattern[1].delta_t;
 808         for (i = 2; i < len; i++) {
 809                 if (pattern[i].delta_t != delta_t) {
 810                         /*
 811                          * Allow last entry in the full or shortened pattern to
 812                          * specify hi pause. Reject other variations.
 813                          */
 814                         if (i != actual_len - 1)
 815                                 goto out_free_pattern;
 816                 }
 817         }
 818
 819         /* LPG_RAMP_DURATION_REG is a 9bit */
 820         if (delta_t >= BIT(9))
 821                 goto out_free_pattern;
 822
 823         /* Find "low pause" and "high pause" in the pattern */
 824         lo_pause = pattern[0].delta_t;
 825         hi_pause = pattern[actual_len - 1].delta_t;
 826
 827         mutex_lock(&lpg->lock);
 828         ret = lpg_lut_store(lpg, pattern, actual_len, &lo_idx, &hi_idx);
 829         if (ret < 0)
 830                 goto out_unlock;
 831
 832         for (i = 0; i < led->num_channels; i++) {
 833                 chan = led->channels[i];
 834
 835                 chan->ramp_tick_ms = delta_t;
 836                 chan->ramp_ping_pong = ping_pong;
 837                 chan->ramp_oneshot = repeat != -1;
 838
 839                 chan->ramp_lo_pause_ms = lo_pause;
 840                 chan->ramp_hi_pause_ms = hi_pause;
 841
 842                 chan->pattern_lo_idx = lo_idx;
 843                 chan->pattern_hi_idx = hi_idx;
 844         }
 845
 846 out_unlock:
 847         mutex_unlock(&lpg->lock);
 848 out_free_pattern:
 849         kfree(pattern);
 850
 851         return ret;
 852 }
 853
 854 static int lpg_pattern_single_set(struct led_classdev *cdev,
 855                                   struct led_pattern *pattern, u32 len,
 856                                   int repeat)
 857 {
 858         struct lpg_led *led = container_of(cdev, struct lpg_led, cdev);
 859         int ret;
 860
 861         ret = lpg_pattern_set(led, pattern, len, repeat);
 862         if (ret < 0)
 863                 return ret;
 864
 865         lpg_brightness_single_set(cdev, LED_FULL);
 866
 867         return 0;
 868 }
 869
 870 static int lpg_pattern_mc_set(struct led_classdev *cdev,
 871                               struct led_pattern *pattern, u32 len,
 872                               int repeat)
 873 {
 874         struct led_classdev_mc *mc = lcdev_to_mccdev(cdev);
 875         struct lpg_led *led = container_of(mc, struct lpg_led, mcdev);
 876         int ret;
 877
 878         ret = lpg_pattern_set(led, pattern, len, repeat);
 879         if (ret < 0)
 880                 return ret;
 881
 882         led_mc_calc_color_components(mc, LED_FULL);
 883         lpg_brightness_set(led, cdev, mc->subled_info);
 884
 885         return 0;
 886 }
 887
 888 static int lpg_pattern_clear(struct lpg_led *led)
 889 {
 890         struct lpg_channel *chan;
 891         struct lpg *lpg = led->lpg;
 892         int i;
 893
 894         mutex_lock(&lpg->lock);
 895
 896         chan = led->channels[0];
 897         lpg_lut_free(lpg, chan->pattern_lo_idx, chan->pattern_hi_idx);
 898
 899         for (i = 0; i < led->num_channels; i++) {
 900                 chan = led->channels[i];
 901                 chan->pattern_lo_idx = 0;
 902                 chan->pattern_hi_idx = 0;
 903         }
 904
 905         mutex_unlock(&lpg->lock);
 906
 907         return 0;
 908 }
 909
 910 static int lpg_pattern_single_clear(struct led_classdev *cdev)
 911 {
 912         struct lpg_led *led = container_of(cdev, struct lpg_led, cdev);
 913
 914         return lpg_pattern_clear(led);
 915 }
 916
 917 static int lpg_pattern_mc_clear(struct led_classdev *cdev)
 918 {
 919         struct led_classdev_mc *mc = lcdev_to_mccdev(cdev);
 920         struct lpg_led *led = container_of(mc, struct lpg_led, mcdev);
 921
 922         return lpg_pattern_clear(led);
 923 }
 924
 925 static int lpg_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm)
 926 {
 927         struct lpg *lpg = container_of(chip, struct lpg, pwm);
 928         struct lpg_channel *chan = &lpg->channels[pwm->hwpwm];
 929
 930         return chan->in_use ? -EBUSY : 0;
 931 }
 932
 933 /*
 934  * Limitations:
 935  * - Updating both duty and period is not done atomically, so the output signal
 936  *   will momentarily be a mix of the settings.
 937  * - Changed parameters takes effect immediately.
 938  * - A disabled channel outputs a logical 0.
 939  */
 940 static int lpg_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
 941                          const struct pwm_state *state)
 942 {
 943         struct lpg *lpg = container_of(chip, struct lpg, pwm);
 944         struct lpg_channel *chan = &lpg->channels[pwm->hwpwm];
 945         int ret = 0;
 946
 947         if (state->polarity != PWM_POLARITY_NORMAL)
 948                 return -EINVAL;
 949
 950         mutex_lock(&lpg->lock);
 951
 952         if (state->enabled) {
 953                 ret = lpg_calc_freq(chan, state->period);
 954                 if (ret < 0)
 955                         goto out_unlock;
 956
 957                 lpg_calc_duty(chan, state->duty_cycle);
 958         }
 959         chan->enabled = state->enabled;
 960
 961         lpg_apply(chan);
 962
 963         triled_set(lpg, chan->triled_mask, chan->enabled ? chan->triled_mask : 0);
 964
 965 out_unlock:
 966         mutex_unlock(&lpg->lock);
 967
 968         return ret;
 969 }
 970
 971 static void lpg_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm,
 972                               struct pwm_state *state)
 973 {
 974         struct lpg *lpg = container_of(chip, struct lpg, pwm);
 975         struct lpg_channel *chan = &lpg->channels[pwm->hwpwm];
 976         unsigned int pre_div;
 977         unsigned int refclk;
 978         unsigned int val;
 979         unsigned int m;
 980         u16 pwm_value;
 981         int ret;
 982
 983         ret = regmap_read(lpg->map, chan->base + LPG_SIZE_CLK_REG, &val);
 984         if (ret)
 985                 return;
 986
 987         refclk = lpg_clk_rates[val & PWM_CLK_SELECT_MASK];
 988         if (refclk) {
 989                 ret = regmap_read(lpg->map, chan->base + LPG_PREDIV_CLK_REG, &val);
 990                 if (ret)
 991                         return;
 992
 993                 pre_div = lpg_pre_divs[FIELD_GET(PWM_FREQ_PRE_DIV_MASK, val)];
 994                 m = FIELD_GET(PWM_FREQ_EXP_MASK, val);
 995
 996                 ret = regmap_bulk_read(lpg->map, chan->base + PWM_VALUE_REG, &pwm_value, sizeof(pwm_value));
 997                 if (ret)
 998                         return;
 999
1000                 state->period = DIV_ROUND_UP_ULL((u64)NSEC_PER_SEC * LPG_RESOLUTION * pre_div * (1 << m), refclk);
1001                 state->duty_cycle = DIV_ROUND_UP_ULL((u64)NSEC_PER_SEC * pwm_value * pre_div * (1 << m), refclk);
1002         } else {
1003                 state->period = 0;
1004                 state->duty_cycle = 0;
1005         }
1006
1007         ret = regmap_read(lpg->map, chan->base + PWM_ENABLE_CONTROL_REG, &val);
1008         if (ret)
1009                 return;
1010
1011         state->enabled = FIELD_GET(LPG_ENABLE_CONTROL_OUTPUT, val);
1012         state->polarity = PWM_POLARITY_NORMAL;
1013
1014         if (state->duty_cycle > state->period)
1015                 state->duty_cycle = state->period;
1016 }
1017
1018 static const struct pwm_ops lpg_pwm_ops = {
1019         .request = lpg_pwm_request,
1020         .apply = lpg_pwm_apply,
1021         .get_state = lpg_pwm_get_state,
1022         .owner = THIS_MODULE,
1023 };
1024
1025 static int lpg_add_pwm(struct lpg *lpg)
1026 {
1027         int ret;
1028
1029         lpg->pwm.base = -1;
1030         lpg->pwm.dev = lpg->dev;
1031         lpg->pwm.npwm = lpg->num_channels;
1032         lpg->pwm.ops = &lpg_pwm_ops;
1033
1034         ret = pwmchip_add(&lpg->pwm);
1035         if (ret)
1036                 dev_err(lpg->dev, "failed to add PWM chip: ret %d\n", ret);
1037
1038         return ret;
1039 }
1040
1041 static int lpg_parse_channel(struct lpg *lpg, struct device_node *np,
1042                              struct lpg_channel **channel)
1043 {
1044         struct lpg_channel *chan;
1045         u32 color = LED_COLOR_ID_GREEN;
1046         u32 reg;
1047         int ret;
1048
1049         ret = of_property_read_u32(np, "reg", &reg);
1050         if (ret || !reg || reg > lpg->num_channels) {
1051                 dev_err(lpg->dev, "invalid \"reg\" of %pOFn\n", np);
1052                 return -EINVAL;
1053         }
1054
1055         chan = &lpg->channels[reg - 1];
1056         chan->in_use = true;
1057
1058         ret = of_property_read_u32(np, "color", &color);
1059         if (ret < 0 && ret != -EINVAL) {
1060                 dev_err(lpg->dev, "failed to parse \"color\" of %pOF\n", np);
1061                 return ret;
1062         }
1063
1064         chan->color = color;
1065
1066         *channel = chan;
1067
1068         return 0;
1069 }
1070
1071 static int lpg_add_led(struct lpg *lpg, struct device_node *np)
1072 {
1073         struct led_init_data init_data = {};
1074         struct led_classdev *cdev;
1075         struct device_node *child;
1076         struct mc_subled *info;
1077         struct lpg_led *led;
1078         const char *state;
1079         int num_channels;
1080         u32 color = 0;
1081         int ret;
1082         int i;
1083
1084         ret = of_property_read_u32(np, "color", &color);
1085         if (ret < 0 && ret != -EINVAL) {
1086                 dev_err(lpg->dev, "failed to parse \"color\" of %pOF\n", np);
1087                 return ret;
1088         }
1089
1090         if (color == LED_COLOR_ID_RGB)
1091                 num_channels = of_get_available_child_count(np);
1092         else
1093                 num_channels = 1;
1094
1095         led = devm_kzalloc(lpg->dev, struct_size(led, channels, num_channels), GFP_KERNEL);
1096         if (!led)
1097                 return -ENOMEM;
1098
1099         led->lpg = lpg;
1100         led->num_channels = num_channels;
1101
1102         if (color == LED_COLOR_ID_RGB) {
1103                 info = devm_kcalloc(lpg->dev, num_channels, sizeof(*info), GFP_KERNEL);
1104                 if (!info)
1105                         return -ENOMEM;
1106                 i = 0;
1107                 for_each_available_child_of_node(np, child) {
1108                         ret = lpg_parse_channel(lpg, child, &led->channels[i]);
1109                         if (ret < 0)
1110                                 return ret;
1111
1112                         info[i].color_index = led->channels[i]->color;
1113                         info[i].intensity = 0;
1114                         i++;
1115                 }
1116
1117                 led->mcdev.subled_info = info;
1118                 led->mcdev.num_colors = num_channels;
1119
1120                 cdev = &led->mcdev.led_cdev;
1121                 cdev->brightness_set = lpg_brightness_mc_set;
1122                 cdev->blink_set = lpg_blink_mc_set;
1123
1124                 /* Register pattern accessors only if we have a LUT block */
1125                 if (lpg->lut_base) {
1126                         cdev->pattern_set = lpg_pattern_mc_set;
1127                         cdev->pattern_clear = lpg_pattern_mc_clear;
1128                 }
1129         } else {
1130                 ret = lpg_parse_channel(lpg, np, &led->channels[0]);
1131                 if (ret < 0)
1132                         return ret;
1133
1134                 cdev = &led->cdev;
1135                 cdev->brightness_set = lpg_brightness_single_set;
1136                 cdev->blink_set = lpg_blink_single_set;
1137
1138                 /* Register pattern accessors only if we have a LUT block */
1139                 if (lpg->lut_base) {
1140                         cdev->pattern_set = lpg_pattern_single_set;
1141                         cdev->pattern_clear = lpg_pattern_single_clear;
1142                 }
1143         }
1144
1145         cdev->default_trigger = of_get_property(np, "linux,default-trigger", NULL);
1146         cdev->max_brightness = LPG_RESOLUTION - 1;
1147
1148         if (!of_property_read_string(np, "default-state", &state) &&
1149             !strcmp(state, "on"))
1150                 cdev->brightness = cdev->max_brightness;
1151         else
1152                 cdev->brightness = LED_OFF;
1153
1154         cdev->brightness_set(cdev, cdev->brightness);
1155
1156         init_data.fwnode = of_fwnode_handle(np);
1157
1158         if (color == LED_COLOR_ID_RGB)
1159                 ret = devm_led_classdev_multicolor_register_ext(lpg->dev, &led->mcdev, &init_data);
1160         else
1161                 ret = devm_led_classdev_register_ext(lpg->dev, &led->cdev, &init_data);
1162         if (ret)
1163                 dev_err(lpg->dev, "unable to register %s\n", cdev->name);
1164
1165         return ret;
1166 }
1167
1168 static int lpg_init_channels(struct lpg *lpg)
1169 {
1170         const struct lpg_data *data = lpg->data;
1171         struct lpg_channel *chan;
1172         int i;
1173
1174         lpg->num_channels = data->num_channels;
1175         lpg->channels = devm_kcalloc(lpg->dev, data->num_channels,
1176                                      sizeof(struct lpg_channel), GFP_KERNEL);
1177         if (!lpg->channels)
1178                 return -ENOMEM;
1179
1180         for (i = 0; i < data->num_channels; i++) {
1181                 chan = &lpg->channels[i];
1182
1183                 chan->lpg = lpg;
1184                 chan->base = data->channels[i].base;
1185                 chan->triled_mask = data->channels[i].triled_mask;
1186                 chan->lut_mask = BIT(i);
1187
1188                 regmap_read(lpg->map, chan->base + LPG_SUBTYPE_REG, &chan->subtype);
1189         }
1190
1191         return 0;
1192 }
1193
1194 static int lpg_init_triled(struct lpg *lpg)
1195 {
1196         struct device_node *np = lpg->dev->of_node;
1197         int ret;
1198
1199         /* Skip initialization if we don't have a triled block */
1200         if (!lpg->data->triled_base)
1201                 return 0;
1202
1203         lpg->triled_base = lpg->data->triled_base;
1204         lpg->triled_has_atc_ctl = lpg->data->triled_has_atc_ctl;
1205         lpg->triled_has_src_sel = lpg->data->triled_has_src_sel;
1206
1207         if (lpg->triled_has_src_sel) {
1208                 ret = of_property_read_u32(np, "qcom,power-source", &lpg->triled_src);
1209                 if (ret || lpg->triled_src == 2 || lpg->triled_src > 3) {
1210                         dev_err(lpg->dev, "invalid power source\n");
1211                         return -EINVAL;
1212                 }
1213         }
1214
1215         /* Disable automatic trickle charge LED */
1216         if (lpg->triled_has_atc_ctl)
1217                 regmap_write(lpg->map, lpg->triled_base + TRI_LED_ATC_CTL, 0);
1218
1219         /* Configure power source */
1220         if (lpg->triled_has_src_sel)
1221                 regmap_write(lpg->map, lpg->triled_base + TRI_LED_SRC_SEL, lpg->triled_src);
1222
1223         /* Default all outputs to off */
1224         regmap_write(lpg->map, lpg->triled_base + TRI_LED_EN_CTL, 0);
1225
1226         return 0;
1227 }
1228
1229 static int lpg_init_lut(struct lpg *lpg)
1230 {
1231         const struct lpg_data *data = lpg->data;
1232
1233         if (!data->lut_base)
1234                 return 0;
1235
1236         lpg->lut_base = data->lut_base;
1237         lpg->lut_size = data->lut_size;
1238
1239         lpg->lut_bitmap = devm_bitmap_zalloc(lpg->dev, lpg->lut_size, GFP_KERNEL);
1240         if (!lpg->lut_bitmap)
1241                 return -ENOMEM;
1242
1243         return 0;
1244 }
1245
1246 static int lpg_probe(struct platform_device *pdev)
1247 {
1248         struct device_node *np;
1249         struct lpg *lpg;
1250         int ret;
1251         int i;
1252
1253         lpg = devm_kzalloc(&pdev->dev, sizeof(*lpg), GFP_KERNEL);
1254         if (!lpg)
1255                 return -ENOMEM;
1256
1257         lpg->data = of_device_get_match_data(&pdev->dev);
1258         if (!lpg->data)
1259                 return -EINVAL;
1260
1261         platform_set_drvdata(pdev, lpg);
1262
1263         lpg->dev = &pdev->dev;
1264         mutex_init(&lpg->lock);
1265
1266         lpg->map = dev_get_regmap(pdev->dev.parent, NULL);
1267         if (!lpg->map)
1268                 return dev_err_probe(&pdev->dev, -ENXIO, "parent regmap unavailable\n");
1269
1270         ret = lpg_init_channels(lpg);
1271         if (ret < 0)
1272                 return ret;
1273
1274         ret = lpg_parse_dtest(lpg);
1275         if (ret < 0)
1276                 return ret;
1277
1278         ret = lpg_init_triled(lpg);
1279         if (ret < 0)
1280                 return ret;
1281
1282         ret = lpg_init_lut(lpg);
1283         if (ret < 0)
1284                 return ret;
1285
1286         for_each_available_child_of_node(pdev->dev.of_node, np) {
1287                 ret = lpg_add_led(lpg, np);
1288                 if (ret)
1289                         return ret;
1290         }
1291
1292         for (i = 0; i < lpg->num_channels; i++)
1293                 lpg_apply_dtest(&lpg->channels[i]);
1294
1295         return lpg_add_pwm(lpg);
1296 }
1297
1298 static int lpg_remove(struct platform_device *pdev)
1299 {
1300         struct lpg *lpg = platform_get_drvdata(pdev);
1301
1302         pwmchip_remove(&lpg->pwm);
1303
1304         return 0;
1305 }
1306
1307 static const struct lpg_data pm8916_pwm_data = {
1308         .num_channels = 1,
1309         .channels = (const struct lpg_channel_data[]) {
1310                 { .base = 0xbc00 },
1311         },
1312 };
1313
1314 static const struct lpg_data pm8941_lpg_data = {
1315         .lut_base = 0xb000,
1316         .lut_size = 64,
1317
1318         .triled_base = 0xd000,
1319         .triled_has_atc_ctl = true,
1320         .triled_has_src_sel = true,
1321
1322         .num_channels = 8,
1323         .channels = (const struct lpg_channel_data[]) {
1324                 { .base = 0xb100 },
1325                 { .base = 0xb200 },
1326                 { .base = 0xb300 },
1327                 { .base = 0xb400 },
1328                 { .base = 0xb500, .triled_mask = BIT(5) },
1329                 { .base = 0xb600, .triled_mask = BIT(6) },
1330                 { .base = 0xb700, .triled_mask = BIT(7) },
1331                 { .base = 0xb800 },
1332         },
1333 };
1334
1335 static const struct lpg_data pm8994_lpg_data = {
1336         .lut_base = 0xb000,
1337         .lut_size = 64,
1338
1339         .num_channels = 6,
1340         .channels = (const struct lpg_channel_data[]) {
1341                 { .base = 0xb100 },
1342                 { .base = 0xb200 },
1343                 { .base = 0xb300 },
1344                 { .base = 0xb400 },
1345                 { .base = 0xb500 },
1346                 { .base = 0xb600 },
1347         },
1348 };
1349
1350 static const struct lpg_data pmi8994_lpg_data = {
1351         .lut_base = 0xb000,
1352         .lut_size = 24,
1353
1354         .triled_base = 0xd000,
1355         .triled_has_atc_ctl = true,
1356         .triled_has_src_sel = true,
1357
1358         .num_channels = 4,
1359         .channels = (const struct lpg_channel_data[]) {
1360                 { .base = 0xb100, .triled_mask = BIT(5) },
1361                 { .base = 0xb200, .triled_mask = BIT(6) },
1362                 { .base = 0xb300, .triled_mask = BIT(7) },
1363                 { .base = 0xb400 },
1364         },
1365 };
1366
1367 static const struct lpg_data pmi8998_lpg_data = {
1368         .lut_base = 0xb000,
1369         .lut_size = 49,
1370
1371         .triled_base = 0xd000,
1372
1373         .num_channels = 6,
1374         .channels = (const struct lpg_channel_data[]) {
1375                 { .base = 0xb100 },
1376                 { .base = 0xb200 },
1377                 { .base = 0xb300, .triled_mask = BIT(5) },
1378                 { .base = 0xb400, .triled_mask = BIT(6) },
1379                 { .base = 0xb500, .triled_mask = BIT(7) },
1380                 { .base = 0xb600 },
1381         },
1382 };
1383
1384 static const struct lpg_data pm8150b_lpg_data = {
1385         .lut_base = 0xb000,
1386         .lut_size = 24,
1387
1388         .triled_base = 0xd000,
1389
1390         .num_channels = 2,
1391         .channels = (const struct lpg_channel_data[]) {
1392                 { .base = 0xb100, .triled_mask = BIT(7) },
1393                 { .base = 0xb200, .triled_mask = BIT(6) },
1394         },
1395 };
1396
1397 static const struct lpg_data pm8150l_lpg_data = {
1398         .lut_base = 0xb000,
1399         .lut_size = 48,
1400
1401         .triled_base = 0xd000,
1402
1403         .num_channels = 5,
1404         .channels = (const struct lpg_channel_data[]) {
1405                 { .base = 0xb100, .triled_mask = BIT(7) },
1406                 { .base = 0xb200, .triled_mask = BIT(6) },
1407                 { .base = 0xb300, .triled_mask = BIT(5) },
1408                 { .base = 0xbc00 },
1409                 { .base = 0xbd00 },
1410
1411         },
1412 };
1413
1414 static const struct lpg_data pm8350c_pwm_data = {
1415         .triled_base = 0xef00,
1416
1417         .num_channels = 4,
1418         .channels = (const struct lpg_channel_data[]) {
1419                 { .base = 0xe800, .triled_mask = BIT(7) },
1420                 { .base = 0xe900, .triled_mask = BIT(6) },
1421                 { .base = 0xea00, .triled_mask = BIT(5) },
1422                 { .base = 0xeb00 },
1423         },
1424 };
1425
1426 static const struct of_device_id lpg_of_table[] = {
1427         { .compatible = "qcom,pm8150b-lpg", .data = &pm8150b_lpg_data },
1428         { .compatible = "qcom,pm8150l-lpg", .data = &pm8150l_lpg_data },
1429         { .compatible = "qcom,pm8350c-pwm", .data = &pm8350c_pwm_data },
1430         { .compatible = "qcom,pm8916-pwm", .data = &pm8916_pwm_data },
1431         { .compatible = "qcom,pm8941-lpg", .data = &pm8941_lpg_data },
1432         { .compatible = "qcom,pm8994-lpg", .data = &pm8994_lpg_data },
1433         { .compatible = "qcom,pmi8994-lpg", .data = &pmi8994_lpg_data },
1434         { .compatible = "qcom,pmi8998-lpg", .data = &pmi8998_lpg_data },
1435         { .compatible = "qcom,pmc8180c-lpg", .data = &pm8150l_lpg_data },
1436         {}
1437 };
1438 MODULE_DEVICE_TABLE(of, lpg_of_table);
1439
1440 static struct platform_driver lpg_driver = {
1441         .probe = lpg_probe,
1442         .remove = lpg_remove,
1443         .driver = {
1444                 .name = "qcom-spmi-lpg",
1445                 .of_match_table = lpg_of_table,
1446         },
1447 };
1448 module_platform_driver(lpg_driver);
1449
1450 MODULE_DESCRIPTION("Qualcomm LPG LED driver");
1451 MODULE_LICENSE("GPL v2");