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