drivers/video/backlight/qcom-wled.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /* Copyright (c) 2015, Sony Mobile Communications, AB.
   3  */
   4
   5 #include <linux/delay.h>
   6 #include <linux/interrupt.h>
   7 #include <linux/ktime.h>
   8 #include <linux/kernel.h>
   9 #include <linux/backlight.h>
  10 #include <linux/module.h>
  11 #include <linux/of.h>
  12 #include <linux/of_device.h>
  13 #include <linux/of_address.h>
  14 #include <linux/regmap.h>
  15
  16 /* From DT binding */
  17 #define WLED_MAX_STRINGS                                4
  18 #define MOD_A                                           0
  19 #define MOD_B                                           1
  20
  21 #define WLED_DEFAULT_BRIGHTNESS                         2048
  22 #define WLED_SOFT_START_DLY_US                          10000
  23 #define WLED3_SINK_REG_BRIGHT_MAX                       0xFFF
  24 #define WLED5_SINK_REG_BRIGHT_MAX_12B                   0xFFF
  25 #define WLED5_SINK_REG_BRIGHT_MAX_15B                   0x7FFF
  26
  27 /* WLED3/WLED4 control registers */
  28 #define WLED3_CTRL_REG_FAULT_STATUS                     0x08
  29 #define  WLED3_CTRL_REG_ILIM_FAULT_BIT                  BIT(0)
  30 #define  WLED3_CTRL_REG_OVP_FAULT_BIT                   BIT(1)
  31 #define  WLED4_CTRL_REG_SC_FAULT_BIT                    BIT(2)
  32 #define  WLED5_CTRL_REG_OVP_PRE_ALARM_BIT               BIT(4)
  33
  34 #define WLED3_CTRL_REG_INT_RT_STS                       0x10
  35 #define  WLED3_CTRL_REG_OVP_FAULT_STATUS                BIT(1)
  36
  37 #define WLED3_CTRL_REG_MOD_EN                           0x46
  38 #define  WLED3_CTRL_REG_MOD_EN_MASK                     BIT(7)
  39 #define  WLED3_CTRL_REG_MOD_EN_SHIFT                    7
  40
  41 #define WLED3_CTRL_REG_FEEDBACK_CONTROL                 0x48
  42
  43 #define WLED3_CTRL_REG_FREQ                             0x4c
  44 #define  WLED3_CTRL_REG_FREQ_MASK                       GENMASK(3, 0)
  45
  46 #define WLED3_CTRL_REG_OVP                              0x4d
  47 #define  WLED3_CTRL_REG_OVP_MASK                        GENMASK(1, 0)
  48 #define  WLED5_CTRL_REG_OVP_MASK                        GENMASK(3, 0)
  49
  50 #define WLED3_CTRL_REG_ILIMIT                           0x4e
  51 #define  WLED3_CTRL_REG_ILIMIT_MASK                     GENMASK(2, 0)
  52
  53 /* WLED3/WLED4 sink registers */
  54 #define WLED3_SINK_REG_SYNC                             0x47
  55 #define  WLED3_SINK_REG_SYNC_CLEAR                      0x00
  56
  57 #define WLED3_SINK_REG_CURR_SINK                        0x4f
  58 #define  WLED3_SINK_REG_CURR_SINK_MASK                  GENMASK(7, 5)
  59 #define  WLED3_SINK_REG_CURR_SINK_SHFT                  5
  60
  61 /* WLED3 specific per-'string' registers below */
  62 #define WLED3_SINK_REG_BRIGHT(n)                        (0x40 + n)
  63
  64 #define WLED3_SINK_REG_STR_MOD_EN(n)                    (0x60 + (n * 0x10))
  65 #define  WLED3_SINK_REG_STR_MOD_MASK                    BIT(7)
  66
  67 #define WLED3_SINK_REG_STR_FULL_SCALE_CURR(n)           (0x62 + (n * 0x10))
  68 #define  WLED3_SINK_REG_STR_FULL_SCALE_CURR_MASK        GENMASK(4, 0)
  69
  70 #define WLED3_SINK_REG_STR_MOD_SRC(n)                   (0x63 + (n * 0x10))
  71 #define  WLED3_SINK_REG_STR_MOD_SRC_MASK                BIT(0)
  72 #define  WLED3_SINK_REG_STR_MOD_SRC_INT                 0x00
  73 #define  WLED3_SINK_REG_STR_MOD_SRC_EXT                 0x01
  74
  75 #define WLED3_SINK_REG_STR_CABC(n)                      (0x66 + (n * 0x10))
  76 #define  WLED3_SINK_REG_STR_CABC_MASK                   BIT(7)
  77
  78 /* WLED4 specific control registers */
  79 #define WLED4_CTRL_REG_SHORT_PROTECT                    0x5e
  80 #define  WLED4_CTRL_REG_SHORT_EN_MASK                   BIT(7)
  81
  82 #define WLED4_CTRL_REG_SEC_ACCESS                       0xd0
  83 #define  WLED4_CTRL_REG_SEC_UNLOCK                      0xa5
  84
  85 #define WLED4_CTRL_REG_TEST1                            0xe2
  86 #define  WLED4_CTRL_REG_TEST1_EXT_FET_DTEST2            0x09
  87
  88 /* WLED4 specific sink registers */
  89 #define WLED4_SINK_REG_CURR_SINK                        0x46
  90 #define  WLED4_SINK_REG_CURR_SINK_MASK                  GENMASK(7, 4)
  91 #define  WLED4_SINK_REG_CURR_SINK_SHFT                  4
  92
  93 /* WLED4 specific per-'string' registers below */
  94 #define WLED4_SINK_REG_STR_MOD_EN(n)                    (0x50 + (n * 0x10))
  95 #define  WLED4_SINK_REG_STR_MOD_MASK                    BIT(7)
  96
  97 #define WLED4_SINK_REG_STR_FULL_SCALE_CURR(n)           (0x52 + (n * 0x10))
  98 #define  WLED4_SINK_REG_STR_FULL_SCALE_CURR_MASK        GENMASK(3, 0)
  99
 100 #define WLED4_SINK_REG_STR_MOD_SRC(n)                   (0x53 + (n * 0x10))
 101 #define  WLED4_SINK_REG_STR_MOD_SRC_MASK                BIT(0)
 102 #define  WLED4_SINK_REG_STR_MOD_SRC_INT                 0x00
 103 #define  WLED4_SINK_REG_STR_MOD_SRC_EXT                 0x01
 104
 105 #define WLED4_SINK_REG_STR_CABC(n)                      (0x56 + (n * 0x10))
 106 #define  WLED4_SINK_REG_STR_CABC_MASK                   BIT(7)
 107
 108 #define WLED4_SINK_REG_BRIGHT(n)                        (0x57 + (n * 0x10))
 109
 110 /* WLED5 specific control registers */
 111 #define WLED5_CTRL_REG_OVP_INT_CTL                      0x5f
 112 #define  WLED5_CTRL_REG_OVP_INT_TIMER_MASK              GENMASK(2, 0)
 113
 114 /* WLED5 specific sink registers */
 115 #define WLED5_SINK_REG_MOD_A_EN                         0x50
 116 #define WLED5_SINK_REG_MOD_B_EN                         0x60
 117 #define  WLED5_SINK_REG_MOD_EN_MASK                     BIT(7)
 118
 119 #define WLED5_SINK_REG_MOD_A_SRC_SEL                    0x51
 120 #define WLED5_SINK_REG_MOD_B_SRC_SEL                    0x61
 121 #define  WLED5_SINK_REG_MOD_SRC_SEL_HIGH                0
 122 #define  WLED5_SINK_REG_MOD_SRC_SEL_EXT                 0x03
 123 #define  WLED5_SINK_REG_MOD_SRC_SEL_MASK                GENMASK(1, 0)
 124
 125 #define WLED5_SINK_REG_MOD_A_BRIGHTNESS_WIDTH_SEL       0x52
 126 #define WLED5_SINK_REG_MOD_B_BRIGHTNESS_WIDTH_SEL       0x62
 127 #define  WLED5_SINK_REG_BRIGHTNESS_WIDTH_12B            0
 128 #define  WLED5_SINK_REG_BRIGHTNESS_WIDTH_15B            1
 129
 130 #define WLED5_SINK_REG_MOD_A_BRIGHTNESS_LSB             0x53
 131 #define WLED5_SINK_REG_MOD_A_BRIGHTNESS_MSB             0x54
 132 #define WLED5_SINK_REG_MOD_B_BRIGHTNESS_LSB             0x63
 133 #define WLED5_SINK_REG_MOD_B_BRIGHTNESS_MSB             0x64
 134
 135 #define WLED5_SINK_REG_MOD_SYNC_BIT                     0x65
 136 #define  WLED5_SINK_REG_SYNC_MOD_A_BIT                  BIT(0)
 137 #define  WLED5_SINK_REG_SYNC_MOD_B_BIT                  BIT(1)
 138 #define  WLED5_SINK_REG_SYNC_MASK                       GENMASK(1, 0)
 139
 140 /* WLED5 specific per-'string' registers below */
 141 #define WLED5_SINK_REG_STR_FULL_SCALE_CURR(n)           (0x72 + (n * 0x10))
 142
 143 #define WLED5_SINK_REG_STR_SRC_SEL(n)                   (0x73 + (n * 0x10))
 144 #define  WLED5_SINK_REG_SRC_SEL_MOD_A                   0
 145 #define  WLED5_SINK_REG_SRC_SEL_MOD_B                   1
 146 #define  WLED5_SINK_REG_SRC_SEL_MASK                    GENMASK(1, 0)
 147
 148 struct wled_var_cfg {
 149         const u32 *values;
 150         u32 (*fn)(u32);
 151         int size;
 152 };
 153
 154 struct wled_u32_opts {
 155         const char *name;
 156         u32 *val_ptr;
 157         const struct wled_var_cfg *cfg;
 158 };
 159
 160 struct wled_bool_opts {
 161         const char *name;
 162         bool *val_ptr;
 163 };
 164
 165 struct wled_config {
 166         u32 boost_i_limit;
 167         u32 ovp;
 168         u32 switch_freq;
 169         u32 num_strings;
 170         u32 string_i_limit;
 171         u32 enabled_strings[WLED_MAX_STRINGS];
 172         u32 mod_sel;
 173         u32 cabc_sel;
 174         bool cs_out_en;
 175         bool ext_gen;
 176         bool cabc;
 177         bool external_pfet;
 178         bool auto_detection_enabled;
 179 };
 180
 181 struct wled {
 182         const char *name;
 183         struct device *dev;
 184         struct regmap *regmap;
 185         struct mutex lock;      /* Lock to avoid race from thread irq handler */
 186         ktime_t last_short_event;
 187         ktime_t start_ovp_fault_time;
 188         u16 ctrl_addr;
 189         u16 sink_addr;
 190         u16 max_string_count;
 191         u16 auto_detection_ovp_count;
 192         u32 brightness;
 193         u32 max_brightness;
 194         u32 short_count;
 195         u32 auto_detect_count;
 196         u32 version;
 197         bool disabled_by_short;
 198         bool has_short_detect;
 199         bool cabc_disabled;
 200         int short_irq;
 201         int ovp_irq;
 202
 203         struct wled_config cfg;
 204         struct delayed_work ovp_work;
 205
 206         /* Configures the brightness. Applicable for wled3, wled4 and wled5 */
 207         int (*wled_set_brightness)(struct wled *wled, u16 brightness);
 208
 209         /* Configures the cabc register. Applicable for wled4 and wled5 */
 210         int (*wled_cabc_config)(struct wled *wled, bool enable);
 211
 212         /*
 213          * Toggles the sync bit for the brightness update to take place.
 214          * Applicable for WLED3, WLED4 and WLED5.
 215          */
 216         int (*wled_sync_toggle)(struct wled *wled);
 217
 218         /*
 219          * Time to wait before checking the OVP status after wled module enable.
 220          * Applicable for WLED4 and WLED5.
 221          */
 222         int (*wled_ovp_delay)(struct wled *wled);
 223
 224         /*
 225          * Determines if the auto string detection is required.
 226          * Applicable for WLED4 and WLED5
 227          */
 228         bool (*wled_auto_detection_required)(struct wled *wled);
 229 };
 230
 231 static int wled3_set_brightness(struct wled *wled, u16 brightness)
 232 {
 233         int rc, i;
 234         u8 v[2];
 235
 236         v[0] = brightness & 0xff;
 237         v[1] = (brightness >> 8) & 0xf;
 238
 239         for (i = 0;  i < wled->cfg.num_strings; ++i) {
 240                 rc = regmap_bulk_write(wled->regmap, wled->ctrl_addr +
 241                                        WLED3_SINK_REG_BRIGHT(i), v, 2);
 242                 if (rc < 0)
 243                         return rc;
 244         }
 245
 246         return 0;
 247 }
 248
 249 static int wled4_set_brightness(struct wled *wled, u16 brightness)
 250 {
 251         int rc, i;
 252         u16 low_limit = wled->max_brightness * 4 / 1000;
 253         u8 v[2];
 254
 255         /* WLED4's lower limit of operation is 0.4% */
 256         if (brightness > 0 && brightness < low_limit)
 257                 brightness = low_limit;
 258
 259         v[0] = brightness & 0xff;
 260         v[1] = (brightness >> 8) & 0xf;
 261
 262         for (i = 0;  i < wled->cfg.num_strings; ++i) {
 263                 rc = regmap_bulk_write(wled->regmap, wled->sink_addr +
 264                                        WLED4_SINK_REG_BRIGHT(i), v, 2);
 265                 if (rc < 0)
 266                         return rc;
 267         }
 268
 269         return 0;
 270 }
 271
 272 static int wled5_set_brightness(struct wled *wled, u16 brightness)
 273 {
 274         int rc, offset;
 275         u16 low_limit = wled->max_brightness * 1 / 1000;
 276         u8 v[2];
 277
 278         /* WLED5's lower limit is 0.1% */
 279         if (brightness < low_limit)
 280                 brightness = low_limit;
 281
 282         v[0] = brightness & 0xff;
 283         v[1] = (brightness >> 8) & 0x7f;
 284
 285         offset = (wled->cfg.mod_sel == MOD_A) ?
 286                   WLED5_SINK_REG_MOD_A_BRIGHTNESS_LSB :
 287                   WLED5_SINK_REG_MOD_B_BRIGHTNESS_LSB;
 288
 289         rc = regmap_bulk_write(wled->regmap, wled->sink_addr + offset,
 290                                v, 2);
 291         return rc;
 292 }
 293
 294 static void wled_ovp_work(struct work_struct *work)
 295 {
 296         struct wled *wled = container_of(work,
 297                                          struct wled, ovp_work.work);
 298         enable_irq(wled->ovp_irq);
 299 }
 300
 301 static int wled_module_enable(struct wled *wled, int val)
 302 {
 303         int rc;
 304
 305         if (wled->disabled_by_short)
 306                 return -ENXIO;
 307
 308         rc = regmap_update_bits(wled->regmap, wled->ctrl_addr +
 309                                 WLED3_CTRL_REG_MOD_EN,
 310                                 WLED3_CTRL_REG_MOD_EN_MASK,
 311                                 val << WLED3_CTRL_REG_MOD_EN_SHIFT);
 312         if (rc < 0)
 313                 return rc;
 314
 315         if (wled->ovp_irq > 0) {
 316                 if (val) {
 317                         /*
 318                          * The hardware generates a storm of spurious OVP
 319                          * interrupts during soft start operations. So defer
 320                          * enabling the IRQ for 10ms to ensure that the
 321                          * soft start is complete.
 322                          */
 323                         schedule_delayed_work(&wled->ovp_work, HZ / 100);
 324                 } else {
 325                         if (!cancel_delayed_work_sync(&wled->ovp_work))
 326                                 disable_irq(wled->ovp_irq);
 327                 }
 328         }
 329
 330         return 0;
 331 }
 332
 333 static int wled3_sync_toggle(struct wled *wled)
 334 {
 335         int rc;
 336         unsigned int mask = GENMASK(wled->max_string_count - 1, 0);
 337
 338         rc = regmap_update_bits(wled->regmap,
 339                                 wled->sink_addr + WLED3_SINK_REG_SYNC,
 340                                 mask, WLED3_SINK_REG_SYNC_CLEAR);
 341         if (rc < 0)
 342                 return rc;
 343
 344         rc = regmap_update_bits(wled->regmap,
 345                                 wled->sink_addr + WLED3_SINK_REG_SYNC,
 346                                 mask, mask);
 347
 348         return rc;
 349 }
 350
 351 static int wled5_mod_sync_toggle(struct wled *wled)
 352 {
 353         int rc;
 354         u8 val;
 355
 356         rc = regmap_update_bits(wled->regmap,
 357                                 wled->sink_addr + WLED5_SINK_REG_MOD_SYNC_BIT,
 358                                 WLED5_SINK_REG_SYNC_MASK, 0);
 359         if (rc < 0)
 360                 return rc;
 361
 362         val = (wled->cfg.mod_sel == MOD_A) ? WLED5_SINK_REG_SYNC_MOD_A_BIT :
 363                                              WLED5_SINK_REG_SYNC_MOD_B_BIT;
 364         return regmap_update_bits(wled->regmap,
 365                                   wled->sink_addr + WLED5_SINK_REG_MOD_SYNC_BIT,
 366                                   WLED5_SINK_REG_SYNC_MASK, val);
 367 }
 368
 369 static int wled_ovp_fault_status(struct wled *wled, bool *fault_set)
 370 {
 371         int rc;
 372         u32 int_rt_sts, fault_sts;
 373
 374         *fault_set = false;
 375         rc = regmap_read(wled->regmap,
 376                         wled->ctrl_addr + WLED3_CTRL_REG_INT_RT_STS,
 377                         &int_rt_sts);
 378         if (rc < 0) {
 379                 dev_err(wled->dev, "Failed to read INT_RT_STS rc=%d\n", rc);
 380                 return rc;
 381         }
 382
 383         rc = regmap_read(wled->regmap,
 384                         wled->ctrl_addr + WLED3_CTRL_REG_FAULT_STATUS,
 385                         &fault_sts);
 386         if (rc < 0) {
 387                 dev_err(wled->dev, "Failed to read FAULT_STATUS rc=%d\n", rc);
 388                 return rc;
 389         }
 390
 391         if (int_rt_sts & WLED3_CTRL_REG_OVP_FAULT_STATUS)
 392                 *fault_set = true;
 393
 394         if (wled->version == 4 && (fault_sts & WLED3_CTRL_REG_OVP_FAULT_BIT))
 395                 *fault_set = true;
 396
 397         if (wled->version == 5 && (fault_sts & (WLED3_CTRL_REG_OVP_FAULT_BIT |
 398                                    WLED5_CTRL_REG_OVP_PRE_ALARM_BIT)))
 399                 *fault_set = true;
 400
 401         if (*fault_set)
 402                 dev_dbg(wled->dev, "WLED OVP fault detected, int_rt_sts=0x%x fault_sts=0x%x\n",
 403                         int_rt_sts, fault_sts);
 404
 405         return rc;
 406 }
 407
 408 static int wled4_ovp_delay(struct wled *wled)
 409 {
 410         return WLED_SOFT_START_DLY_US;
 411 }
 412
 413 static int wled5_ovp_delay(struct wled *wled)
 414 {
 415         int rc, delay_us;
 416         u32 val;
 417         u8 ovp_timer_ms[8] = {1, 2, 4, 8, 12, 16, 20, 24};
 418
 419         /* For WLED5, get the delay based on OVP timer */
 420         rc = regmap_read(wled->regmap, wled->ctrl_addr +
 421                          WLED5_CTRL_REG_OVP_INT_CTL, &val);
 422         if (rc < 0)
 423                 delay_us =
 424                 ovp_timer_ms[val & WLED5_CTRL_REG_OVP_INT_TIMER_MASK] * 1000;
 425         else
 426                 delay_us = 2 * WLED_SOFT_START_DLY_US;
 427
 428         dev_dbg(wled->dev, "delay_time_us: %d\n", delay_us);
 429
 430         return delay_us;
 431 }
 432
 433 static int wled_update_status(struct backlight_device *bl)
 434 {
 435         struct wled *wled = bl_get_data(bl);
 436         u16 brightness = backlight_get_brightness(bl);
 437         int rc = 0;
 438
 439         mutex_lock(&wled->lock);
 440         if (brightness) {
 441                 rc = wled->wled_set_brightness(wled, brightness);
 442                 if (rc < 0) {
 443                         dev_err(wled->dev, "wled failed to set brightness rc:%d\n",
 444                                 rc);
 445                         goto unlock_mutex;
 446                 }
 447
 448                 if (wled->version < 5) {
 449                         rc = wled->wled_sync_toggle(wled);
 450                         if (rc < 0) {
 451                                 dev_err(wled->dev, "wled sync failed rc:%d\n", rc);
 452                                 goto unlock_mutex;
 453                         }
 454                 } else {
 455                         /*
 456                          * For WLED5 toggling the MOD_SYNC_BIT updates the
 457                          * brightness
 458                          */
 459                         rc = wled5_mod_sync_toggle(wled);
 460                         if (rc < 0) {
 461                                 dev_err(wled->dev, "wled mod sync failed rc:%d\n",
 462                                         rc);
 463                                 goto unlock_mutex;
 464                         }
 465                 }
 466         }
 467
 468         if (!!brightness != !!wled->brightness) {
 469                 rc = wled_module_enable(wled, !!brightness);
 470                 if (rc < 0) {
 471                         dev_err(wled->dev, "wled enable failed rc:%d\n", rc);
 472                         goto unlock_mutex;
 473                 }
 474         }
 475
 476         wled->brightness = brightness;
 477
 478 unlock_mutex:
 479         mutex_unlock(&wled->lock);
 480
 481         return rc;
 482 }
 483
 484 static int wled4_cabc_config(struct wled *wled, bool enable)
 485 {
 486         int i, j, rc;
 487         u8 val;
 488
 489         for (i = 0; i < wled->cfg.num_strings; i++) {
 490                 j = wled->cfg.enabled_strings[i];
 491
 492                 val = enable ? WLED4_SINK_REG_STR_CABC_MASK : 0;
 493                 rc = regmap_update_bits(wled->regmap, wled->sink_addr +
 494                                         WLED4_SINK_REG_STR_CABC(j),
 495                                         WLED4_SINK_REG_STR_CABC_MASK, val);
 496                 if (rc < 0)
 497                         return rc;
 498         }
 499
 500         return 0;
 501 }
 502
 503 static int wled5_cabc_config(struct wled *wled, bool enable)
 504 {
 505         int rc, offset;
 506         u8 reg;
 507
 508         if (wled->cabc_disabled)
 509                 return 0;
 510
 511         reg = enable ? wled->cfg.cabc_sel : 0;
 512         offset = (wled->cfg.mod_sel == MOD_A) ? WLED5_SINK_REG_MOD_A_SRC_SEL :
 513                                                 WLED5_SINK_REG_MOD_B_SRC_SEL;
 514
 515         rc = regmap_update_bits(wled->regmap, wled->sink_addr + offset,
 516                                 WLED5_SINK_REG_MOD_SRC_SEL_MASK, reg);
 517         if (rc < 0) {
 518                 pr_err("Error in configuring CABC rc=%d\n", rc);
 519                 return rc;
 520         }
 521
 522         if (!wled->cfg.cabc_sel)
 523                 wled->cabc_disabled = true;
 524
 525         return 0;
 526 }
 527
 528 #define WLED_SHORT_DLY_MS                       20
 529 #define WLED_SHORT_CNT_MAX                      5
 530 #define WLED_SHORT_RESET_CNT_DLY_US             USEC_PER_SEC
 531
 532 static irqreturn_t wled_short_irq_handler(int irq, void *_wled)
 533 {
 534         struct wled *wled = _wled;
 535         int rc;
 536         s64 elapsed_time;
 537
 538         wled->short_count++;
 539         mutex_lock(&wled->lock);
 540         rc = wled_module_enable(wled, false);
 541         if (rc < 0) {
 542                 dev_err(wled->dev, "wled disable failed rc:%d\n", rc);
 543                 goto unlock_mutex;
 544         }
 545
 546         elapsed_time = ktime_us_delta(ktime_get(),
 547                                       wled->last_short_event);
 548         if (elapsed_time > WLED_SHORT_RESET_CNT_DLY_US)
 549                 wled->short_count = 1;
 550
 551         if (wled->short_count > WLED_SHORT_CNT_MAX) {
 552                 dev_err(wled->dev, "Short triggered %d times, disabling WLED forever!\n",
 553                         wled->short_count);
 554                 wled->disabled_by_short = true;
 555                 goto unlock_mutex;
 556         }
 557
 558         wled->last_short_event = ktime_get();
 559
 560         msleep(WLED_SHORT_DLY_MS);
 561         rc = wled_module_enable(wled, true);
 562         if (rc < 0)
 563                 dev_err(wled->dev, "wled enable failed rc:%d\n", rc);
 564
 565 unlock_mutex:
 566         mutex_unlock(&wled->lock);
 567
 568         return IRQ_HANDLED;
 569 }
 570
 571 #define AUTO_DETECT_BRIGHTNESS          200
 572
 573 static void wled_auto_string_detection(struct wled *wled)
 574 {
 575         int rc = 0, i, delay_time_us;
 576         u32 sink_config = 0;
 577         u8 sink_test = 0, sink_valid = 0, val;
 578         bool fault_set;
 579
 580         /* Read configured sink configuration */
 581         rc = regmap_read(wled->regmap, wled->sink_addr +
 582                          WLED4_SINK_REG_CURR_SINK, &sink_config);
 583         if (rc < 0) {
 584                 dev_err(wled->dev, "Failed to read SINK configuration rc=%d\n",
 585                         rc);
 586                 goto failed_detect;
 587         }
 588
 589         /* Disable the module before starting detection */
 590         rc = regmap_update_bits(wled->regmap,
 591                                 wled->ctrl_addr + WLED3_CTRL_REG_MOD_EN,
 592                                 WLED3_CTRL_REG_MOD_EN_MASK, 0);
 593         if (rc < 0) {
 594                 dev_err(wled->dev, "Failed to disable WLED module rc=%d\n", rc);
 595                 goto failed_detect;
 596         }
 597
 598         /* Set low brightness across all sinks */
 599         rc = wled4_set_brightness(wled, AUTO_DETECT_BRIGHTNESS);
 600         if (rc < 0) {
 601                 dev_err(wled->dev, "Failed to set brightness for auto detection rc=%d\n",
 602                         rc);
 603                 goto failed_detect;
 604         }
 605
 606         if (wled->cfg.cabc) {
 607                 rc = wled->wled_cabc_config(wled, false);
 608                 if (rc < 0)
 609                         goto failed_detect;
 610         }
 611
 612         /* Disable all sinks */
 613         rc = regmap_write(wled->regmap,
 614                           wled->sink_addr + WLED4_SINK_REG_CURR_SINK, 0);
 615         if (rc < 0) {
 616                 dev_err(wled->dev, "Failed to disable all sinks rc=%d\n", rc);
 617                 goto failed_detect;
 618         }
 619
 620         /* Iterate through the strings one by one */
 621         for (i = 0; i < wled->cfg.num_strings; i++) {
 622                 sink_test = BIT((WLED4_SINK_REG_CURR_SINK_SHFT + i));
 623
 624                 /* Enable feedback control */
 625                 rc = regmap_write(wled->regmap, wled->ctrl_addr +
 626                                   WLED3_CTRL_REG_FEEDBACK_CONTROL, i + 1);
 627                 if (rc < 0) {
 628                         dev_err(wled->dev, "Failed to enable feedback for SINK %d rc = %d\n",
 629                                 i + 1, rc);
 630                         goto failed_detect;
 631                 }
 632
 633                 /* Enable the sink */
 634                 rc = regmap_write(wled->regmap, wled->sink_addr +
 635                                   WLED4_SINK_REG_CURR_SINK, sink_test);
 636                 if (rc < 0) {
 637                         dev_err(wled->dev, "Failed to configure SINK %d rc=%d\n",
 638                                 i + 1, rc);
 639                         goto failed_detect;
 640                 }
 641
 642                 /* Enable the module */
 643                 rc = regmap_update_bits(wled->regmap, wled->ctrl_addr +
 644                                         WLED3_CTRL_REG_MOD_EN,
 645                                         WLED3_CTRL_REG_MOD_EN_MASK,
 646                                         WLED3_CTRL_REG_MOD_EN_MASK);
 647                 if (rc < 0) {
 648                         dev_err(wled->dev, "Failed to enable WLED module rc=%d\n",
 649                                 rc);
 650                         goto failed_detect;
 651                 }
 652
 653                 delay_time_us = wled->wled_ovp_delay(wled);
 654                 usleep_range(delay_time_us, delay_time_us + 1000);
 655
 656                 rc = wled_ovp_fault_status(wled, &fault_set);
 657                 if (rc < 0) {
 658                         dev_err(wled->dev, "Error in getting OVP fault_sts, rc=%d\n",
 659                                 rc);
 660                         goto failed_detect;
 661                 }
 662
 663                 if (fault_set)
 664                         dev_dbg(wled->dev, "WLED OVP fault detected with SINK %d\n",
 665                                 i + 1);
 666                 else
 667                         sink_valid |= sink_test;
 668
 669                 /* Disable the module */
 670                 rc = regmap_update_bits(wled->regmap,
 671                                         wled->ctrl_addr + WLED3_CTRL_REG_MOD_EN,
 672                                         WLED3_CTRL_REG_MOD_EN_MASK, 0);
 673                 if (rc < 0) {
 674                         dev_err(wled->dev, "Failed to disable WLED module rc=%d\n",
 675                                 rc);
 676                         goto failed_detect;
 677                 }
 678         }
 679
 680         if (!sink_valid) {
 681                 dev_err(wled->dev, "No valid WLED sinks found\n");
 682                 wled->disabled_by_short = true;
 683                 goto failed_detect;
 684         }
 685
 686         if (sink_valid != sink_config) {
 687                 dev_warn(wled->dev, "%x is not a valid sink configuration - using %x instead\n",
 688                          sink_config, sink_valid);
 689                 sink_config = sink_valid;
 690         }
 691
 692         /* Write the new sink configuration */
 693         rc = regmap_write(wled->regmap,
 694                           wled->sink_addr + WLED4_SINK_REG_CURR_SINK,
 695                           sink_config);
 696         if (rc < 0) {
 697                 dev_err(wled->dev, "Failed to reconfigure the default sink rc=%d\n",
 698                         rc);
 699                 goto failed_detect;
 700         }
 701
 702         /* Enable valid sinks */
 703         if (wled->version == 4) {
 704                 for (i = 0; i < wled->cfg.num_strings; i++) {
 705                         if (sink_config &
 706                             BIT(WLED4_SINK_REG_CURR_SINK_SHFT + i))
 707                                 val = WLED4_SINK_REG_STR_MOD_MASK;
 708                         else
 709                                 /* Disable modulator_en for unused sink */
 710                                 val = 0;
 711
 712                         rc = regmap_write(wled->regmap, wled->sink_addr +
 713                                           WLED4_SINK_REG_STR_MOD_EN(i), val);
 714                         if (rc < 0) {
 715                                 dev_err(wled->dev, "Failed to configure MODULATOR_EN rc=%d\n",
 716                                         rc);
 717                                 goto failed_detect;
 718                         }
 719                 }
 720         }
 721
 722         /* Enable CABC */
 723         rc = wled->wled_cabc_config(wled, true);
 724         if (rc < 0)
 725                 goto failed_detect;
 726
 727         /* Restore the feedback setting */
 728         rc = regmap_write(wled->regmap,
 729                           wled->ctrl_addr + WLED3_CTRL_REG_FEEDBACK_CONTROL, 0);
 730         if (rc < 0) {
 731                 dev_err(wled->dev, "Failed to restore feedback setting rc=%d\n",
 732                         rc);
 733                 goto failed_detect;
 734         }
 735
 736         /* Restore brightness */
 737         rc = wled4_set_brightness(wled, wled->brightness);
 738         if (rc < 0) {
 739                 dev_err(wled->dev, "Failed to set brightness after auto detection rc=%d\n",
 740                         rc);
 741                 goto failed_detect;
 742         }
 743
 744         rc = regmap_update_bits(wled->regmap,
 745                                 wled->ctrl_addr + WLED3_CTRL_REG_MOD_EN,
 746                                 WLED3_CTRL_REG_MOD_EN_MASK,
 747                                 WLED3_CTRL_REG_MOD_EN_MASK);
 748         if (rc < 0) {
 749                 dev_err(wled->dev, "Failed to enable WLED module rc=%d\n", rc);
 750                 goto failed_detect;
 751         }
 752
 753 failed_detect:
 754         return;
 755 }
 756
 757 #define WLED_AUTO_DETECT_OVP_COUNT              5
 758 #define WLED_AUTO_DETECT_CNT_DLY_US             USEC_PER_SEC
 759
 760 static bool wled4_auto_detection_required(struct wled *wled)
 761 {
 762         s64 elapsed_time_us;
 763
 764         if (!wled->cfg.auto_detection_enabled)
 765                 return false;
 766
 767         /*
 768          * Check if the OVP fault was an occasional one
 769          * or if it's firing continuously, the latter qualifies
 770          * for an auto-detection check.
 771          */
 772         if (!wled->auto_detection_ovp_count) {
 773                 wled->start_ovp_fault_time = ktime_get();
 774                 wled->auto_detection_ovp_count++;
 775         } else {
 776                 elapsed_time_us = ktime_us_delta(ktime_get(),
 777                                                  wled->start_ovp_fault_time);
 778                 if (elapsed_time_us > WLED_AUTO_DETECT_CNT_DLY_US)
 779                         wled->auto_detection_ovp_count = 0;
 780                 else
 781                         wled->auto_detection_ovp_count++;
 782
 783                 if (wled->auto_detection_ovp_count >=
 784                                 WLED_AUTO_DETECT_OVP_COUNT) {
 785                         wled->auto_detection_ovp_count = 0;
 786                         return true;
 787                 }
 788         }
 789
 790         return false;
 791 }
 792
 793 static bool wled5_auto_detection_required(struct wled *wled)
 794 {
 795         if (!wled->cfg.auto_detection_enabled)
 796                 return false;
 797
 798         /*
 799          * Unlike WLED4, WLED5 has OVP fault density interrupt configuration
 800          * i.e. to count the number of OVP alarms for a certain duration before
 801          * triggering OVP fault interrupt. By default, number of OVP fault
 802          * events counted before an interrupt is fired is 32 and the time
 803          * interval is 12 ms. If we see one OVP fault interrupt, then that
 804          * should qualify for a real OVP fault condition to run auto detection
 805          * algorithm.
 806          */
 807         return true;
 808 }
 809
 810 static int wled_auto_detection_at_init(struct wled *wled)
 811 {
 812         int rc;
 813         bool fault_set;
 814
 815         if (!wled->cfg.auto_detection_enabled)
 816                 return 0;
 817
 818         rc = wled_ovp_fault_status(wled, &fault_set);
 819         if (rc < 0) {
 820                 dev_err(wled->dev, "Error in getting OVP fault_sts, rc=%d\n",
 821                         rc);
 822                 return rc;
 823         }
 824
 825         if (fault_set) {
 826                 mutex_lock(&wled->lock);
 827                 wled_auto_string_detection(wled);
 828                 mutex_unlock(&wled->lock);
 829         }
 830
 831         return rc;
 832 }
 833
 834 static irqreturn_t wled_ovp_irq_handler(int irq, void *_wled)
 835 {
 836         struct wled *wled = _wled;
 837         int rc;
 838         u32 int_sts, fault_sts;
 839
 840         rc = regmap_read(wled->regmap,
 841                          wled->ctrl_addr + WLED3_CTRL_REG_INT_RT_STS, &int_sts);
 842         if (rc < 0) {
 843                 dev_err(wled->dev, "Error in reading WLED3_INT_RT_STS rc=%d\n",
 844                         rc);
 845                 return IRQ_HANDLED;
 846         }
 847
 848         rc = regmap_read(wled->regmap, wled->ctrl_addr +
 849                          WLED3_CTRL_REG_FAULT_STATUS, &fault_sts);
 850         if (rc < 0) {
 851                 dev_err(wled->dev, "Error in reading WLED_FAULT_STATUS rc=%d\n",
 852                         rc);
 853                 return IRQ_HANDLED;
 854         }
 855
 856         if (fault_sts & (WLED3_CTRL_REG_OVP_FAULT_BIT |
 857                 WLED3_CTRL_REG_ILIM_FAULT_BIT))
 858                 dev_dbg(wled->dev, "WLED OVP fault detected, int_sts=%x fault_sts= %x\n",
 859                         int_sts, fault_sts);
 860
 861         if (fault_sts & WLED3_CTRL_REG_OVP_FAULT_BIT) {
 862                 if (wled->wled_auto_detection_required(wled)) {
 863                         mutex_lock(&wled->lock);
 864                         wled_auto_string_detection(wled);
 865                         mutex_unlock(&wled->lock);
 866                 }
 867         }
 868
 869         return IRQ_HANDLED;
 870 }
 871
 872 static int wled3_setup(struct wled *wled)
 873 {
 874         u16 addr;
 875         u8 sink_en = 0;
 876         int rc, i, j;
 877
 878         rc = regmap_update_bits(wled->regmap,
 879                                 wled->ctrl_addr + WLED3_CTRL_REG_OVP,
 880                                 WLED3_CTRL_REG_OVP_MASK, wled->cfg.ovp);
 881         if (rc)
 882                 return rc;
 883
 884         rc = regmap_update_bits(wled->regmap,
 885                                 wled->ctrl_addr + WLED3_CTRL_REG_ILIMIT,
 886                                 WLED3_CTRL_REG_ILIMIT_MASK,
 887                                 wled->cfg.boost_i_limit);
 888         if (rc)
 889                 return rc;
 890
 891         rc = regmap_update_bits(wled->regmap,
 892                                 wled->ctrl_addr + WLED3_CTRL_REG_FREQ,
 893                                 WLED3_CTRL_REG_FREQ_MASK,
 894                                 wled->cfg.switch_freq);
 895         if (rc)
 896                 return rc;
 897
 898         for (i = 0; i < wled->cfg.num_strings; ++i) {
 899                 j = wled->cfg.enabled_strings[i];
 900                 addr = wled->ctrl_addr + WLED3_SINK_REG_STR_MOD_EN(j);
 901                 rc = regmap_update_bits(wled->regmap, addr,
 902                                         WLED3_SINK_REG_STR_MOD_MASK,
 903                                         WLED3_SINK_REG_STR_MOD_MASK);
 904                 if (rc)
 905                         return rc;
 906
 907                 if (wled->cfg.ext_gen) {
 908                         addr = wled->ctrl_addr + WLED3_SINK_REG_STR_MOD_SRC(j);
 909                         rc = regmap_update_bits(wled->regmap, addr,
 910                                                 WLED3_SINK_REG_STR_MOD_SRC_MASK,
 911                                                 WLED3_SINK_REG_STR_MOD_SRC_EXT);
 912                         if (rc)
 913                                 return rc;
 914                 }
 915
 916                 addr = wled->ctrl_addr + WLED3_SINK_REG_STR_FULL_SCALE_CURR(j);
 917                 rc = regmap_update_bits(wled->regmap, addr,
 918                                         WLED3_SINK_REG_STR_FULL_SCALE_CURR_MASK,
 919                                         wled->cfg.string_i_limit);
 920                 if (rc)
 921                         return rc;
 922
 923                 addr = wled->ctrl_addr + WLED3_SINK_REG_STR_CABC(j);
 924                 rc = regmap_update_bits(wled->regmap, addr,
 925                                         WLED3_SINK_REG_STR_CABC_MASK,
 926                                         wled->cfg.cabc ?
 927                                         WLED3_SINK_REG_STR_CABC_MASK : 0);
 928                 if (rc)
 929                         return rc;
 930
 931                 sink_en |= BIT(j + WLED3_SINK_REG_CURR_SINK_SHFT);
 932         }
 933
 934         rc = regmap_update_bits(wled->regmap,
 935                                 wled->ctrl_addr + WLED3_SINK_REG_CURR_SINK,
 936                                 WLED3_SINK_REG_CURR_SINK_MASK, sink_en);
 937         if (rc)
 938                 return rc;
 939
 940         return 0;
 941 }
 942
 943 static const struct wled_config wled3_config_defaults = {
 944         .boost_i_limit = 3,
 945         .string_i_limit = 20,
 946         .ovp = 2,
 947         .num_strings = 3,
 948         .switch_freq = 5,
 949         .cs_out_en = false,
 950         .ext_gen = false,
 951         .cabc = false,
 952         .enabled_strings = {0, 1, 2, 3},
 953 };
 954
 955 static int wled4_setup(struct wled *wled)
 956 {
 957         int rc, temp, i, j;
 958         u16 addr;
 959         u8 sink_en = 0;
 960         u32 sink_cfg;
 961
 962         rc = regmap_update_bits(wled->regmap,
 963                                 wled->ctrl_addr + WLED3_CTRL_REG_OVP,
 964                                 WLED3_CTRL_REG_OVP_MASK, wled->cfg.ovp);
 965         if (rc < 0)
 966                 return rc;
 967
 968         rc = regmap_update_bits(wled->regmap,
 969                                 wled->ctrl_addr + WLED3_CTRL_REG_ILIMIT,
 970                                 WLED3_CTRL_REG_ILIMIT_MASK,
 971                                 wled->cfg.boost_i_limit);
 972         if (rc < 0)
 973                 return rc;
 974
 975         rc = regmap_update_bits(wled->regmap,
 976                                 wled->ctrl_addr + WLED3_CTRL_REG_FREQ,
 977                                 WLED3_CTRL_REG_FREQ_MASK,
 978                                 wled->cfg.switch_freq);
 979         if (rc < 0)
 980                 return rc;
 981
 982         if (wled->cfg.external_pfet) {
 983                 /* Unlock the secure register access */
 984                 rc = regmap_write(wled->regmap, wled->ctrl_addr +
 985                                   WLED4_CTRL_REG_SEC_ACCESS,
 986                                   WLED4_CTRL_REG_SEC_UNLOCK);
 987                 if (rc < 0)
 988                         return rc;
 989
 990                 rc = regmap_write(wled->regmap,
 991                                   wled->ctrl_addr + WLED4_CTRL_REG_TEST1,
 992                                   WLED4_CTRL_REG_TEST1_EXT_FET_DTEST2);
 993                 if (rc < 0)
 994                         return rc;
 995         }
 996
 997         rc = regmap_read(wled->regmap, wled->sink_addr +
 998                          WLED4_SINK_REG_CURR_SINK, &sink_cfg);
 999         if (rc < 0)
1000                 return rc;
1001
1002         for (i = 0; i < wled->cfg.num_strings; i++) {
1003                 j = wled->cfg.enabled_strings[i];
1004                 temp = j + WLED4_SINK_REG_CURR_SINK_SHFT;
1005                 sink_en |= 1 << temp;
1006         }
1007
1008         if (sink_cfg == sink_en) {
1009                 rc = wled_auto_detection_at_init(wled);
1010                 return rc;
1011         }
1012
1013         rc = regmap_update_bits(wled->regmap,
1014                                 wled->sink_addr + WLED4_SINK_REG_CURR_SINK,
1015                                 WLED4_SINK_REG_CURR_SINK_MASK, 0);
1016         if (rc < 0)
1017                 return rc;
1018
1019         rc = regmap_update_bits(wled->regmap, wled->ctrl_addr +
1020                                 WLED3_CTRL_REG_MOD_EN,
1021                                 WLED3_CTRL_REG_MOD_EN_MASK, 0);
1022         if (rc < 0)
1023                 return rc;
1024
1025         /* Per sink/string configuration */
1026         for (i = 0; i < wled->cfg.num_strings; i++) {
1027                 j = wled->cfg.enabled_strings[i];
1028
1029                 addr = wled->sink_addr +
1030                                 WLED4_SINK_REG_STR_MOD_EN(j);
1031                 rc = regmap_update_bits(wled->regmap, addr,
1032                                         WLED4_SINK_REG_STR_MOD_MASK,
1033                                         WLED4_SINK_REG_STR_MOD_MASK);
1034                 if (rc < 0)
1035                         return rc;
1036
1037                 addr = wled->sink_addr +
1038                                 WLED4_SINK_REG_STR_FULL_SCALE_CURR(j);
1039                 rc = regmap_update_bits(wled->regmap, addr,
1040                                         WLED4_SINK_REG_STR_FULL_SCALE_CURR_MASK,
1041                                         wled->cfg.string_i_limit);
1042                 if (rc < 0)
1043                         return rc;
1044         }
1045
1046         rc = wled4_cabc_config(wled, wled->cfg.cabc);
1047         if (rc < 0)
1048                 return rc;
1049
1050         rc = regmap_update_bits(wled->regmap, wled->ctrl_addr +
1051                                 WLED3_CTRL_REG_MOD_EN,
1052                                 WLED3_CTRL_REG_MOD_EN_MASK,
1053                                 WLED3_CTRL_REG_MOD_EN_MASK);
1054         if (rc < 0)
1055                 return rc;
1056
1057         rc = regmap_update_bits(wled->regmap,
1058                                 wled->sink_addr + WLED4_SINK_REG_CURR_SINK,
1059                                 WLED4_SINK_REG_CURR_SINK_MASK, sink_en);
1060         if (rc < 0)
1061                 return rc;
1062
1063         rc = wled->wled_sync_toggle(wled);
1064         if (rc < 0) {
1065                 dev_err(wled->dev, "Failed to toggle sync reg rc:%d\n", rc);
1066                 return rc;
1067         }
1068
1069         rc = wled_auto_detection_at_init(wled);
1070
1071         return rc;
1072 }
1073
1074 static const struct wled_config wled4_config_defaults = {
1075         .boost_i_limit = 4,
1076         .string_i_limit = 10,
1077         .ovp = 1,
1078         .num_strings = 4,
1079         .switch_freq = 11,
1080         .cabc = false,
1081         .external_pfet = false,
1082         .auto_detection_enabled = false,
1083 };
1084
1085 static int wled5_setup(struct wled *wled)
1086 {
1087         int rc, temp, i, j, offset;
1088         u8 sink_en = 0;
1089         u16 addr;
1090         u32 val;
1091
1092         rc = regmap_update_bits(wled->regmap,
1093                                 wled->ctrl_addr + WLED3_CTRL_REG_OVP,
1094                                 WLED5_CTRL_REG_OVP_MASK, wled->cfg.ovp);
1095         if (rc < 0)
1096                 return rc;
1097
1098         rc = regmap_update_bits(wled->regmap,
1099                                 wled->ctrl_addr + WLED3_CTRL_REG_ILIMIT,
1100                                 WLED3_CTRL_REG_ILIMIT_MASK,
1101                                 wled->cfg.boost_i_limit);
1102         if (rc < 0)
1103                 return rc;
1104
1105         rc = regmap_update_bits(wled->regmap,
1106                                 wled->ctrl_addr + WLED3_CTRL_REG_FREQ,
1107                                 WLED3_CTRL_REG_FREQ_MASK,
1108                                 wled->cfg.switch_freq);
1109         if (rc < 0)
1110                 return rc;
1111
1112         /* Per sink/string configuration */
1113         for (i = 0; i < wled->cfg.num_strings; ++i) {
1114                 j = wled->cfg.enabled_strings[i];
1115                 addr = wled->sink_addr +
1116                                 WLED4_SINK_REG_STR_FULL_SCALE_CURR(j);
1117                 rc = regmap_update_bits(wled->regmap, addr,
1118                                         WLED4_SINK_REG_STR_FULL_SCALE_CURR_MASK,
1119                                         wled->cfg.string_i_limit);
1120                 if (rc < 0)
1121                         return rc;
1122
1123                 addr = wled->sink_addr + WLED5_SINK_REG_STR_SRC_SEL(j);
1124                 rc = regmap_update_bits(wled->regmap, addr,
1125                                         WLED5_SINK_REG_SRC_SEL_MASK,
1126                                         wled->cfg.mod_sel == MOD_A ?
1127                                         WLED5_SINK_REG_SRC_SEL_MOD_A :
1128                                         WLED5_SINK_REG_SRC_SEL_MOD_B);
1129
1130                 temp = j + WLED4_SINK_REG_CURR_SINK_SHFT;
1131                 sink_en |= 1 << temp;
1132         }
1133
1134         rc = wled5_cabc_config(wled, wled->cfg.cabc_sel ? true : false);
1135         if (rc < 0)
1136                 return rc;
1137
1138         /* Enable one of the modulators A or B based on mod_sel */
1139         addr = wled->sink_addr + WLED5_SINK_REG_MOD_A_EN;
1140         val = (wled->cfg.mod_sel == MOD_A) ? WLED5_SINK_REG_MOD_EN_MASK : 0;
1141         rc = regmap_update_bits(wled->regmap, addr,
1142                                 WLED5_SINK_REG_MOD_EN_MASK, val);
1143         if (rc < 0)
1144                 return rc;
1145
1146         addr = wled->sink_addr + WLED5_SINK_REG_MOD_B_EN;
1147         val = (wled->cfg.mod_sel == MOD_B) ? WLED5_SINK_REG_MOD_EN_MASK : 0;
1148         rc = regmap_update_bits(wled->regmap, addr,
1149                                 WLED5_SINK_REG_MOD_EN_MASK, val);
1150         if (rc < 0)
1151                 return rc;
1152
1153         offset = (wled->cfg.mod_sel == MOD_A) ?
1154                   WLED5_SINK_REG_MOD_A_BRIGHTNESS_WIDTH_SEL :
1155                   WLED5_SINK_REG_MOD_B_BRIGHTNESS_WIDTH_SEL;
1156
1157         addr = wled->sink_addr + offset;
1158         val = (wled->max_brightness == WLED5_SINK_REG_BRIGHT_MAX_15B) ?
1159                  WLED5_SINK_REG_BRIGHTNESS_WIDTH_15B :
1160                  WLED5_SINK_REG_BRIGHTNESS_WIDTH_12B;
1161         rc = regmap_write(wled->regmap, addr, val);
1162         if (rc < 0)
1163                 return rc;
1164
1165         rc = regmap_update_bits(wled->regmap,
1166                                 wled->sink_addr + WLED4_SINK_REG_CURR_SINK,
1167                                 WLED4_SINK_REG_CURR_SINK_MASK, sink_en);
1168         if (rc < 0)
1169                 return rc;
1170
1171         /* This updates only FSC configuration in WLED5 */
1172         rc = wled->wled_sync_toggle(wled);
1173         if (rc < 0) {
1174                 pr_err("Failed to toggle sync reg rc:%d\n", rc);
1175                 return rc;
1176         }
1177
1178         rc = wled_auto_detection_at_init(wled);
1179         if (rc < 0)
1180                 return rc;
1181
1182         return 0;
1183 }
1184
1185 static const struct wled_config wled5_config_defaults = {
1186         .boost_i_limit = 5,
1187         .string_i_limit = 10,
1188         .ovp = 4,
1189         .num_strings = 4,
1190         .switch_freq = 11,
1191         .mod_sel = 0,
1192         .cabc_sel = 0,
1193         .cabc = false,
1194         .external_pfet = false,
1195         .auto_detection_enabled = false,
1196 };
1197
1198 static const u32 wled3_boost_i_limit_values[] = {
1199         105, 385, 525, 805, 980, 1260, 1400, 1680,
1200 };
1201
1202 static const struct wled_var_cfg wled3_boost_i_limit_cfg = {
1203         .values = wled3_boost_i_limit_values,
1204         .size = ARRAY_SIZE(wled3_boost_i_limit_values),
1205 };
1206
1207 static const u32 wled4_boost_i_limit_values[] = {
1208         105, 280, 450, 620, 970, 1150, 1300, 1500,
1209 };
1210
1211 static const struct wled_var_cfg wled4_boost_i_limit_cfg = {
1212         .values = wled4_boost_i_limit_values,
1213         .size = ARRAY_SIZE(wled4_boost_i_limit_values),
1214 };
1215
1216 static inline u32 wled5_boost_i_limit_values_fn(u32 idx)
1217 {
1218         return 525 + (idx * 175);
1219 }
1220
1221 static const struct wled_var_cfg wled5_boost_i_limit_cfg = {
1222         .fn = wled5_boost_i_limit_values_fn,
1223         .size = 8,
1224 };
1225
1226 static const u32 wled3_ovp_values[] = {
1227         35, 32, 29, 27,
1228 };
1229
1230 static const struct wled_var_cfg wled3_ovp_cfg = {
1231         .values = wled3_ovp_values,
1232         .size = ARRAY_SIZE(wled3_ovp_values),
1233 };
1234
1235 static const u32 wled4_ovp_values[] = {
1236         31100, 29600, 19600, 18100,
1237 };
1238
1239 static const struct wled_var_cfg wled4_ovp_cfg = {
1240         .values = wled4_ovp_values,
1241         .size = ARRAY_SIZE(wled4_ovp_values),
1242 };
1243
1244 static inline u32 wled5_ovp_values_fn(u32 idx)
1245 {
1246         /*
1247          * 0000 - 38.5 V
1248          * 0001 - 37 V ..
1249          * 1111 - 16 V
1250          */
1251         return 38500 - (idx * 1500);
1252 }
1253
1254 static const struct wled_var_cfg wled5_ovp_cfg = {
1255         .fn = wled5_ovp_values_fn,
1256         .size = 16,
1257 };
1258
1259 static u32 wled3_num_strings_values_fn(u32 idx)
1260 {
1261         return idx + 1;
1262 }
1263
1264 static const struct wled_var_cfg wled3_num_strings_cfg = {
1265         .fn = wled3_num_strings_values_fn,
1266         .size = 3,
1267 };
1268
1269 static const struct wled_var_cfg wled4_num_strings_cfg = {
1270         .fn = wled3_num_strings_values_fn,
1271         .size = 4,
1272 };
1273
1274 static u32 wled3_switch_freq_values_fn(u32 idx)
1275 {
1276         return 19200 / (2 * (1 + idx));
1277 }
1278
1279 static const struct wled_var_cfg wled3_switch_freq_cfg = {
1280         .fn = wled3_switch_freq_values_fn,
1281         .size = 16,
1282 };
1283
1284 static const struct wled_var_cfg wled3_string_i_limit_cfg = {
1285         .size = 26,
1286 };
1287
1288 static const u32 wled4_string_i_limit_values[] = {
1289         0, 2500, 5000, 7500, 10000, 12500, 15000, 17500, 20000,
1290         22500, 25000, 27500, 30000,
1291 };
1292
1293 static const struct wled_var_cfg wled4_string_i_limit_cfg = {
1294         .values = wled4_string_i_limit_values,
1295         .size = ARRAY_SIZE(wled4_string_i_limit_values),
1296 };
1297
1298 static const struct wled_var_cfg wled5_mod_sel_cfg = {
1299         .size = 2,
1300 };
1301
1302 static const struct wled_var_cfg wled5_cabc_sel_cfg = {
1303         .size = 4,
1304 };
1305
1306 static u32 wled_values(const struct wled_var_cfg *cfg, u32 idx)
1307 {
1308         if (idx >= cfg->size)
1309                 return UINT_MAX;
1310         if (cfg->fn)
1311                 return cfg->fn(idx);
1312         if (cfg->values)
1313                 return cfg->values[idx];
1314         return idx;
1315 }
1316
1317 static int wled_configure(struct wled *wled)
1318 {
1319         struct wled_config *cfg = &wled->cfg;
1320         struct device *dev = wled->dev;
1321         const __be32 *prop_addr;
1322         u32 size, val, c;
1323         int rc, i, j, string_len;
1324
1325         const struct wled_u32_opts *u32_opts = NULL;
1326         const struct wled_u32_opts wled3_opts[] = {
1327                 {
1328                         .name = "qcom,current-boost-limit",
1329                         .val_ptr = &cfg->boost_i_limit,
1330                         .cfg = &wled3_boost_i_limit_cfg,
1331                 },
1332                 {
1333                         .name = "qcom,current-limit",
1334                         .val_ptr = &cfg->string_i_limit,
1335                         .cfg = &wled3_string_i_limit_cfg,
1336                 },
1337                 {
1338                         .name = "qcom,ovp",
1339                         .val_ptr = &cfg->ovp,
1340                         .cfg = &wled3_ovp_cfg,
1341                 },
1342                 {
1343                         .name = "qcom,switching-freq",
1344                         .val_ptr = &cfg->switch_freq,
1345                         .cfg = &wled3_switch_freq_cfg,
1346                 },
1347                 {
1348                         .name = "qcom,num-strings",
1349                         .val_ptr = &cfg->num_strings,
1350                         .cfg = &wled3_num_strings_cfg,
1351                 },
1352         };
1353
1354         const struct wled_u32_opts wled4_opts[] = {
1355                 {
1356                         .name = "qcom,current-boost-limit",
1357                         .val_ptr = &cfg->boost_i_limit,
1358                         .cfg = &wled4_boost_i_limit_cfg,
1359                 },
1360                 {
1361                         .name = "qcom,current-limit-microamp",
1362                         .val_ptr = &cfg->string_i_limit,
1363                         .cfg = &wled4_string_i_limit_cfg,
1364                 },
1365                 {
1366                         .name = "qcom,ovp-millivolt",
1367                         .val_ptr = &cfg->ovp,
1368                         .cfg = &wled4_ovp_cfg,
1369                 },
1370                 {
1371                         .name = "qcom,switching-freq",
1372                         .val_ptr = &cfg->switch_freq,
1373                         .cfg = &wled3_switch_freq_cfg,
1374                 },
1375                 {
1376                         .name = "qcom,num-strings",
1377                         .val_ptr = &cfg->num_strings,
1378                         .cfg = &wled4_num_strings_cfg,
1379                 },
1380         };
1381
1382         const struct wled_u32_opts wled5_opts[] = {
1383                 {
1384                         .name = "qcom,current-boost-limit",
1385                         .val_ptr = &cfg->boost_i_limit,
1386                         .cfg = &wled5_boost_i_limit_cfg,
1387                 },
1388                 {
1389                         .name = "qcom,current-limit-microamp",
1390                         .val_ptr = &cfg->string_i_limit,
1391                         .cfg = &wled4_string_i_limit_cfg,
1392                 },
1393                 {
1394                         .name = "qcom,ovp-millivolt",
1395                         .val_ptr = &cfg->ovp,
1396                         .cfg = &wled5_ovp_cfg,
1397                 },
1398                 {
1399                         .name = "qcom,switching-freq",
1400                         .val_ptr = &cfg->switch_freq,
1401                         .cfg = &wled3_switch_freq_cfg,
1402                 },
1403                 {
1404                         .name = "qcom,num-strings",
1405                         .val_ptr = &cfg->num_strings,
1406                         .cfg = &wled4_num_strings_cfg,
1407                 },
1408                 {
1409                         .name = "qcom,modulator-sel",
1410                         .val_ptr = &cfg->mod_sel,
1411                         .cfg = &wled5_mod_sel_cfg,
1412                 },
1413                 {
1414                         .name = "qcom,cabc-sel",
1415                         .val_ptr = &cfg->cabc_sel,
1416                         .cfg = &wled5_cabc_sel_cfg,
1417                 },
1418         };
1419
1420         const struct wled_bool_opts bool_opts[] = {
1421                 { "qcom,cs-out", &cfg->cs_out_en, },
1422                 { "qcom,ext-gen", &cfg->ext_gen, },
1423                 { "qcom,cabc", &cfg->cabc, },
1424                 { "qcom,external-pfet", &cfg->external_pfet, },
1425                 { "qcom,auto-string-detection", &cfg->auto_detection_enabled, },
1426         };
1427
1428         prop_addr = of_get_address(dev->of_node, 0, NULL, NULL);
1429         if (!prop_addr) {
1430                 dev_err(wled->dev, "invalid IO resources\n");
1431                 return -EINVAL;
1432         }
1433         wled->ctrl_addr = be32_to_cpu(*prop_addr);
1434
1435         rc = of_property_read_string(dev->of_node, "label", &wled->name);
1436         if (rc)
1437                 wled->name = devm_kasprintf(dev, GFP_KERNEL, "%pOFn", dev->of_node);
1438
1439         switch (wled->version) {
1440         case 3:
1441                 u32_opts = wled3_opts;
1442                 size = ARRAY_SIZE(wled3_opts);
1443                 *cfg = wled3_config_defaults;
1444                 wled->wled_set_brightness = wled3_set_brightness;
1445                 wled->wled_sync_toggle = wled3_sync_toggle;
1446                 wled->max_string_count = 3;
1447                 wled->sink_addr = wled->ctrl_addr;
1448                 break;
1449
1450         case 4:
1451                 u32_opts = wled4_opts;
1452                 size = ARRAY_SIZE(wled4_opts);
1453                 *cfg = wled4_config_defaults;
1454                 wled->wled_set_brightness = wled4_set_brightness;
1455                 wled->wled_sync_toggle = wled3_sync_toggle;
1456                 wled->wled_cabc_config = wled4_cabc_config;
1457                 wled->wled_ovp_delay = wled4_ovp_delay;
1458                 wled->wled_auto_detection_required =
1459                                         wled4_auto_detection_required;
1460                 wled->max_string_count = 4;
1461
1462                 prop_addr = of_get_address(dev->of_node, 1, NULL, NULL);
1463                 if (!prop_addr) {
1464                         dev_err(wled->dev, "invalid IO resources\n");
1465                         return -EINVAL;
1466                 }
1467                 wled->sink_addr = be32_to_cpu(*prop_addr);
1468                 break;
1469
1470         case 5:
1471                 u32_opts = wled5_opts;
1472                 size = ARRAY_SIZE(wled5_opts);
1473                 *cfg = wled5_config_defaults;
1474                 wled->wled_set_brightness = wled5_set_brightness;
1475                 wled->wled_sync_toggle = wled3_sync_toggle;
1476                 wled->wled_cabc_config = wled5_cabc_config;
1477                 wled->wled_ovp_delay = wled5_ovp_delay;
1478                 wled->wled_auto_detection_required =
1479                                         wled5_auto_detection_required;
1480                 wled->max_string_count = 4;
1481
1482                 prop_addr = of_get_address(dev->of_node, 1, NULL, NULL);
1483                 if (!prop_addr) {
1484                         dev_err(wled->dev, "invalid IO resources\n");
1485                         return -EINVAL;
1486                 }
1487                 wled->sink_addr = be32_to_cpu(*prop_addr);
1488                 break;
1489
1490         default:
1491                 dev_err(wled->dev, "Invalid WLED version\n");
1492                 return -EINVAL;
1493         }
1494
1495         for (i = 0; i < size; ++i) {
1496                 rc = of_property_read_u32(dev->of_node, u32_opts[i].name, &val);
1497                 if (rc == -EINVAL) {
1498                         continue;
1499                 } else if (rc) {
1500                         dev_err(dev, "error reading '%s'\n", u32_opts[i].name);
1501                         return rc;
1502                 }
1503
1504                 c = UINT_MAX;
1505                 for (j = 0; c != val; j++) {
1506                         c = wled_values(u32_opts[i].cfg, j);
1507                         if (c == UINT_MAX) {
1508                                 dev_err(dev, "invalid value for '%s'\n",
1509                                         u32_opts[i].name);
1510                                 return -EINVAL;
1511                         }
1512
1513                         if (c == val)
1514                                 break;
1515                 }
1516
1517                 dev_dbg(dev, "'%s' = %u\n", u32_opts[i].name, c);
1518                 *u32_opts[i].val_ptr = j;
1519         }
1520
1521         for (i = 0; i < ARRAY_SIZE(bool_opts); ++i) {
1522                 if (of_property_read_bool(dev->of_node, bool_opts[i].name))
1523                         *bool_opts[i].val_ptr = true;
1524         }
1525
1526         cfg->num_strings = cfg->num_strings + 1;
1527
1528         string_len = of_property_count_elems_of_size(dev->of_node,
1529                                                      "qcom,enabled-strings",
1530                                                      sizeof(u32));
1531         if (string_len > 0)
1532                 of_property_read_u32_array(dev->of_node,
1533                                                 "qcom,enabled-strings",
1534                                                 wled->cfg.enabled_strings,
1535                                                 sizeof(u32));
1536
1537         return 0;
1538 }
1539
1540 static int wled_configure_short_irq(struct wled *wled,
1541                                     struct platform_device *pdev)
1542 {
1543         int rc;
1544
1545         if (!wled->has_short_detect)
1546                 return 0;
1547
1548         rc = regmap_update_bits(wled->regmap, wled->ctrl_addr +
1549                                 WLED4_CTRL_REG_SHORT_PROTECT,
1550                                 WLED4_CTRL_REG_SHORT_EN_MASK,
1551                                 WLED4_CTRL_REG_SHORT_EN_MASK);
1552         if (rc < 0)
1553                 return rc;
1554
1555         wled->short_irq = platform_get_irq_byname(pdev, "short");
1556         if (wled->short_irq < 0) {
1557                 dev_dbg(&pdev->dev, "short irq is not used\n");
1558                 return 0;
1559         }
1560
1561         rc = devm_request_threaded_irq(wled->dev, wled->short_irq,
1562                                        NULL, wled_short_irq_handler,
1563                                        IRQF_ONESHOT,
1564                                        "wled_short_irq", wled);
1565         if (rc < 0)
1566                 dev_err(wled->dev, "Unable to request short_irq (err:%d)\n",
1567                         rc);
1568
1569         return rc;
1570 }
1571
1572 static int wled_configure_ovp_irq(struct wled *wled,
1573                                   struct platform_device *pdev)
1574 {
1575         int rc;
1576         u32 val;
1577
1578         wled->ovp_irq = platform_get_irq_byname(pdev, "ovp");
1579         if (wled->ovp_irq < 0) {
1580                 dev_dbg(&pdev->dev, "OVP IRQ not found - disabling automatic string detection\n");
1581                 return 0;
1582         }
1583
1584         rc = devm_request_threaded_irq(wled->dev, wled->ovp_irq, NULL,
1585                                        wled_ovp_irq_handler, IRQF_ONESHOT,
1586                                        "wled_ovp_irq", wled);
1587         if (rc < 0) {
1588                 dev_err(wled->dev, "Unable to request ovp_irq (err:%d)\n",
1589                         rc);
1590                 wled->ovp_irq = 0;
1591                 return 0;
1592         }
1593
1594         rc = regmap_read(wled->regmap, wled->ctrl_addr +
1595                          WLED3_CTRL_REG_MOD_EN, &val);
1596         if (rc < 0)
1597                 return rc;
1598
1599         /* Keep OVP irq disabled until module is enabled */
1600         if (!(val & WLED3_CTRL_REG_MOD_EN_MASK))
1601                 disable_irq(wled->ovp_irq);
1602
1603         return 0;
1604 }
1605
1606 static const struct backlight_ops wled_ops = {
1607         .update_status = wled_update_status,
1608 };
1609
1610 static int wled_probe(struct platform_device *pdev)
1611 {
1612         struct backlight_properties props;
1613         struct backlight_device *bl;
1614         struct wled *wled;
1615         struct regmap *regmap;
1616         u32 val;
1617         int rc;
1618
1619         regmap = dev_get_regmap(pdev->dev.parent, NULL);
1620         if (!regmap) {
1621                 dev_err(&pdev->dev, "Unable to get regmap\n");
1622                 return -EINVAL;
1623         }
1624
1625         wled = devm_kzalloc(&pdev->dev, sizeof(*wled), GFP_KERNEL);
1626         if (!wled)
1627                 return -ENOMEM;
1628
1629         wled->regmap = regmap;
1630         wled->dev = &pdev->dev;
1631
1632         wled->version = (uintptr_t)of_device_get_match_data(&pdev->dev);
1633         if (!wled->version) {
1634                 dev_err(&pdev->dev, "Unknown device version\n");
1635                 return -ENODEV;
1636         }
1637
1638         mutex_init(&wled->lock);
1639         rc = wled_configure(wled);
1640         if (rc)
1641                 return rc;
1642
1643         val = WLED3_SINK_REG_BRIGHT_MAX;
1644         of_property_read_u32(pdev->dev.of_node, "max-brightness", &val);
1645         wled->max_brightness = val;
1646
1647         switch (wled->version) {
1648         case 3:
1649                 wled->cfg.auto_detection_enabled = false;
1650                 rc = wled3_setup(wled);
1651                 if (rc) {
1652                         dev_err(&pdev->dev, "wled3_setup failed\n");
1653                         return rc;
1654                 }
1655                 break;
1656
1657         case 4:
1658                 wled->has_short_detect = true;
1659                 rc = wled4_setup(wled);
1660                 if (rc) {
1661                         dev_err(&pdev->dev, "wled4_setup failed\n");
1662                         return rc;
1663                 }
1664                 break;
1665
1666         case 5:
1667                 wled->has_short_detect = true;
1668                 if (wled->cfg.cabc_sel)
1669                         wled->max_brightness = WLED5_SINK_REG_BRIGHT_MAX_12B;
1670
1671                 rc = wled5_setup(wled);
1672                 if (rc) {
1673                         dev_err(&pdev->dev, "wled5_setup failed\n");
1674                         return rc;
1675                 }
1676                 break;
1677
1678         default:
1679                 dev_err(wled->dev, "Invalid WLED version\n");
1680                 break;
1681         }
1682
1683         INIT_DELAYED_WORK(&wled->ovp_work, wled_ovp_work);
1684
1685         rc = wled_configure_short_irq(wled, pdev);
1686         if (rc < 0)
1687                 return rc;
1688
1689         rc = wled_configure_ovp_irq(wled, pdev);
1690         if (rc < 0)
1691                 return rc;
1692
1693         val = WLED_DEFAULT_BRIGHTNESS;
1694         of_property_read_u32(pdev->dev.of_node, "default-brightness", &val);
1695
1696         memset(&props, 0, sizeof(struct backlight_properties));
1697         props.type = BACKLIGHT_RAW;
1698         props.brightness = val;
1699         props.max_brightness = wled->max_brightness;
1700         bl = devm_backlight_device_register(&pdev->dev, wled->name,
1701                                             &pdev->dev, wled,
1702                                             &wled_ops, &props);
1703         return PTR_ERR_OR_ZERO(bl);
1704 };
1705
1706 static int wled_remove(struct platform_device *pdev)
1707 {
1708         struct wled *wled = platform_get_drvdata(pdev);
1709
1710         mutex_destroy(&wled->lock);
1711         cancel_delayed_work_sync(&wled->ovp_work);
1712         disable_irq(wled->short_irq);
1713         disable_irq(wled->ovp_irq);
1714
1715         return 0;
1716 }
1717
1718 static const struct of_device_id wled_match_table[] = {
1719         { .compatible = "qcom,pm8941-wled", .data = (void *)3 },
1720         { .compatible = "qcom,pmi8994-wled", .data = (void *)4 },
1721         { .compatible = "qcom,pmi8998-wled", .data = (void *)4 },
1722         { .compatible = "qcom,pm660l-wled", .data = (void *)4 },
1723         { .compatible = "qcom,pm8150l-wled", .data = (void *)5 },
1724         {}
1725 };
1726 MODULE_DEVICE_TABLE(of, wled_match_table);
1727
1728 static struct platform_driver wled_driver = {
1729         .probe = wled_probe,
1730         .remove = wled_remove,
1731         .driver = {
1732                 .name = "qcom,wled",
1733                 .of_match_table = wled_match_table,
1734         },
1735 };
1736
1737 module_platform_driver(wled_driver);
1738
1739 MODULE_DESCRIPTION("Qualcomm WLED driver");
1740 MODULE_LICENSE("GPL v2");