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_address.h>
  13#include <linux/platform_device.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
 148struct wled_var_cfg {
 149	const u32 *values;
 150	u32 (*fn)(u32);
 151	int size;
 152};
 153
 154struct wled_u32_opts {
 155	const char *name;
 156	u32 *val_ptr;
 157	const struct wled_var_cfg *cfg;
 158};
 159
 160struct wled_bool_opts {
 161	const char *name;
 162	bool *val_ptr;
 163};
 164
 165struct 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
 181struct 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
 231static 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
 249static 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
 272static 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
 293static 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
 300static 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
 332static 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, WLED3_SINK_REG_SYNC_CLEAR);
 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, mask);
 346
 347	return rc;
 348}
 349
 350static int wled5_mod_sync_toggle(struct wled *wled)
 351{
 352	int rc;
 353	u8 val;
 354
 355	rc = regmap_update_bits(wled->regmap,
 356				wled->sink_addr + WLED5_SINK_REG_MOD_SYNC_BIT,
 357				WLED5_SINK_REG_SYNC_MASK, 0);
 358	if (rc < 0)
 359		return rc;
 360
 361	val = (wled->cfg.mod_sel == MOD_A) ? WLED5_SINK_REG_SYNC_MOD_A_BIT :
 362					     WLED5_SINK_REG_SYNC_MOD_B_BIT;
 363	return regmap_update_bits(wled->regmap,
 364				  wled->sink_addr + WLED5_SINK_REG_MOD_SYNC_BIT,
 365				  WLED5_SINK_REG_SYNC_MASK, val);
 366}
 367
 368static 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
 407static int wled4_ovp_delay(struct wled *wled)
 408{
 409	return WLED_SOFT_START_DLY_US;
 410}
 411
 412static 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
 432static 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
 477unlock_mutex:
 478	mutex_unlock(&wled->lock);
 479
 480	return rc;
 481}
 482
 483static 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
 502static 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
 531static 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
 564unlock_mutex:
 565	mutex_unlock(&wled->lock);
 566
 567	return IRQ_HANDLED;
 568}
 569
 570#define AUTO_DETECT_BRIGHTNESS		200
 571
 572static 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
 754failed_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
 761static 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
 794static 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
 811static 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
 835static 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
 873static 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
 944static 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},
 954};
 955
 956static 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
1075static 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	.enabled_strings = {0, 1, 2, 3},
1085};
1086
1087static int wled5_setup(struct wled *wled)
1088{
1089	int rc, temp, i, j, offset;
1090	u8 sink_en = 0;
1091	u16 addr;
1092	u32 val;
1093
1094	rc = regmap_update_bits(wled->regmap,
1095				wled->ctrl_addr + WLED3_CTRL_REG_OVP,
1096				WLED5_CTRL_REG_OVP_MASK, wled->cfg.ovp);
1097	if (rc < 0)
1098		return rc;
1099
1100	rc = regmap_update_bits(wled->regmap,
1101				wled->ctrl_addr + WLED3_CTRL_REG_ILIMIT,
1102				WLED3_CTRL_REG_ILIMIT_MASK,
1103				wled->cfg.boost_i_limit);
1104	if (rc < 0)
1105		return rc;
1106
1107	rc = regmap_update_bits(wled->regmap,
1108				wled->ctrl_addr + WLED3_CTRL_REG_FREQ,
1109				WLED3_CTRL_REG_FREQ_MASK,
1110				wled->cfg.switch_freq);
1111	if (rc < 0)
1112		return rc;
1113
1114	/* Per sink/string configuration */
1115	for (i = 0; i < wled->cfg.num_strings; ++i) {
1116		j = wled->cfg.enabled_strings[i];
1117		addr = wled->sink_addr +
1118				WLED4_SINK_REG_STR_FULL_SCALE_CURR(j);
1119		rc = regmap_update_bits(wled->regmap, addr,
1120					WLED4_SINK_REG_STR_FULL_SCALE_CURR_MASK,
1121					wled->cfg.string_i_limit);
1122		if (rc < 0)
1123			return rc;
1124
1125		addr = wled->sink_addr + WLED5_SINK_REG_STR_SRC_SEL(j);
1126		rc = regmap_update_bits(wled->regmap, addr,
1127					WLED5_SINK_REG_SRC_SEL_MASK,
1128					wled->cfg.mod_sel == MOD_A ?
1129					WLED5_SINK_REG_SRC_SEL_MOD_A :
1130					WLED5_SINK_REG_SRC_SEL_MOD_B);
1131
1132		temp = j + WLED4_SINK_REG_CURR_SINK_SHFT;
1133		sink_en |= 1 << temp;
1134	}
1135
1136	rc = wled5_cabc_config(wled, wled->cfg.cabc_sel ? true : false);
1137	if (rc < 0)
1138		return rc;
1139
1140	/* Enable one of the modulators A or B based on mod_sel */
1141	addr = wled->sink_addr + WLED5_SINK_REG_MOD_A_EN;
1142	val = (wled->cfg.mod_sel == MOD_A) ? WLED5_SINK_REG_MOD_EN_MASK : 0;
1143	rc = regmap_update_bits(wled->regmap, addr,
1144				WLED5_SINK_REG_MOD_EN_MASK, val);
1145	if (rc < 0)
1146		return rc;
1147
1148	addr = wled->sink_addr + WLED5_SINK_REG_MOD_B_EN;
1149	val = (wled->cfg.mod_sel == MOD_B) ? WLED5_SINK_REG_MOD_EN_MASK : 0;
1150	rc = regmap_update_bits(wled->regmap, addr,
1151				WLED5_SINK_REG_MOD_EN_MASK, val);
1152	if (rc < 0)
1153		return rc;
1154
1155	offset = (wled->cfg.mod_sel == MOD_A) ?
1156		  WLED5_SINK_REG_MOD_A_BRIGHTNESS_WIDTH_SEL :
1157		  WLED5_SINK_REG_MOD_B_BRIGHTNESS_WIDTH_SEL;
1158
1159	addr = wled->sink_addr + offset;
1160	val = (wled->max_brightness == WLED5_SINK_REG_BRIGHT_MAX_15B) ?
1161		 WLED5_SINK_REG_BRIGHTNESS_WIDTH_15B :
1162		 WLED5_SINK_REG_BRIGHTNESS_WIDTH_12B;
1163	rc = regmap_write(wled->regmap, addr, val);
1164	if (rc < 0)
1165		return rc;
1166
1167	rc = regmap_update_bits(wled->regmap,
1168				wled->sink_addr + WLED4_SINK_REG_CURR_SINK,
1169				WLED4_SINK_REG_CURR_SINK_MASK, sink_en);
1170	if (rc < 0)
1171		return rc;
1172
1173	/* This updates only FSC configuration in WLED5 */
1174	rc = wled->wled_sync_toggle(wled);
1175	if (rc < 0) {
1176		pr_err("Failed to toggle sync reg rc:%d\n", rc);
1177		return rc;
1178	}
1179
1180	rc = wled_auto_detection_at_init(wled);
1181	if (rc < 0)
1182		return rc;
1183
1184	return 0;
1185}
1186
1187static const struct wled_config wled5_config_defaults = {
1188	.boost_i_limit = 5,
1189	.string_i_limit = 10,
1190	.ovp = 4,
1191	.num_strings = 4,
1192	.switch_freq = 11,
1193	.mod_sel = 0,
1194	.cabc_sel = 0,
1195	.cabc = false,
1196	.external_pfet = false,
1197	.auto_detection_enabled = false,
1198	.enabled_strings = {0, 1, 2, 3},
1199};
1200
1201static const u32 wled3_boost_i_limit_values[] = {
1202	105, 385, 525, 805, 980, 1260, 1400, 1680,
1203};
1204
1205static const struct wled_var_cfg wled3_boost_i_limit_cfg = {
1206	.values = wled3_boost_i_limit_values,
1207	.size = ARRAY_SIZE(wled3_boost_i_limit_values),
1208};
1209
1210static const u32 wled4_boost_i_limit_values[] = {
1211	105, 280, 450, 620, 970, 1150, 1300, 1500,
1212};
1213
1214static const struct wled_var_cfg wled4_boost_i_limit_cfg = {
1215	.values = wled4_boost_i_limit_values,
1216	.size = ARRAY_SIZE(wled4_boost_i_limit_values),
1217};
1218
1219static inline u32 wled5_boost_i_limit_values_fn(u32 idx)
1220{
1221	return 525 + (idx * 175);
1222}
1223
1224static const struct wled_var_cfg wled5_boost_i_limit_cfg = {
1225	.fn = wled5_boost_i_limit_values_fn,
1226	.size = 8,
1227};
1228
1229static const u32 wled3_ovp_values[] = {
1230	35, 32, 29, 27,
1231};
1232
1233static const struct wled_var_cfg wled3_ovp_cfg = {
1234	.values = wled3_ovp_values,
1235	.size = ARRAY_SIZE(wled3_ovp_values),
1236};
1237
1238static const u32 wled4_ovp_values[] = {
1239	31100, 29600, 19600, 18100,
1240};
1241
1242static const struct wled_var_cfg wled4_ovp_cfg = {
1243	.values = wled4_ovp_values,
1244	.size = ARRAY_SIZE(wled4_ovp_values),
1245};
1246
1247static const u32 pmi8994_wled_ovp_values[] = {
1248	31000, 29500, 19400, 17800,
1249};
1250
1251static const struct wled_var_cfg pmi8994_wled_ovp_cfg = {
1252	.values = pmi8994_wled_ovp_values,
1253	.size = ARRAY_SIZE(pmi8994_wled_ovp_values),
1254};
1255
1256static inline u32 wled5_ovp_values_fn(u32 idx)
1257{
1258	/*
1259	 * 0000 - 38.5 V
1260	 * 0001 - 37 V ..
1261	 * 1111 - 16 V
1262	 */
1263	return 38500 - (idx * 1500);
1264}
1265
1266static const struct wled_var_cfg wled5_ovp_cfg = {
1267	.fn = wled5_ovp_values_fn,
1268	.size = 16,
1269};
1270
1271static u32 wled3_switch_freq_values_fn(u32 idx)
1272{
1273	return 19200 / (2 * (1 + idx));
1274}
1275
1276static const struct wled_var_cfg wled3_switch_freq_cfg = {
1277	.fn = wled3_switch_freq_values_fn,
1278	.size = 16,
1279};
1280
1281static const struct wled_var_cfg wled3_string_i_limit_cfg = {
1282	.size = 26,
1283};
1284
1285static const u32 wled4_string_i_limit_values[] = {
1286	0, 2500, 5000, 7500, 10000, 12500, 15000, 17500, 20000,
1287	22500, 25000, 27500, 30000,
1288};
1289
1290static const struct wled_var_cfg wled4_string_i_limit_cfg = {
1291	.values = wled4_string_i_limit_values,
1292	.size = ARRAY_SIZE(wled4_string_i_limit_values),
1293};
1294
1295static const struct wled_var_cfg wled5_mod_sel_cfg = {
1296	.size = 2,
1297};
1298
1299static const struct wled_var_cfg wled5_cabc_sel_cfg = {
1300	.size = 4,
1301};
1302
1303static u32 wled_values(const struct wled_var_cfg *cfg, u32 idx)
1304{
1305	if (idx >= cfg->size)
1306		return UINT_MAX;
1307	if (cfg->fn)
1308		return cfg->fn(idx);
1309	if (cfg->values)
1310		return cfg->values[idx];
1311	return idx;
1312}
1313
1314static int wled_configure(struct wled *wled)
1315{
1316	struct wled_config *cfg = &wled->cfg;
1317	struct device *dev = wled->dev;
1318	const __be32 *prop_addr;
1319	u32 size, val, c;
1320	int rc, i, j, string_len;
1321
1322	const struct wled_u32_opts *u32_opts = NULL;
1323	const struct wled_u32_opts wled3_opts[] = {
1324		{
1325			.name = "qcom,current-boost-limit",
1326			.val_ptr = &cfg->boost_i_limit,
1327			.cfg = &wled3_boost_i_limit_cfg,
1328		},
1329		{
1330			.name = "qcom,current-limit",
1331			.val_ptr = &cfg->string_i_limit,
1332			.cfg = &wled3_string_i_limit_cfg,
1333		},
1334		{
1335			.name = "qcom,ovp",
1336			.val_ptr = &cfg->ovp,
1337			.cfg = &wled3_ovp_cfg,
1338		},
1339		{
1340			.name = "qcom,switching-freq",
1341			.val_ptr = &cfg->switch_freq,
1342			.cfg = &wled3_switch_freq_cfg,
1343		},
1344	};
1345
1346	const struct wled_u32_opts wled4_opts[] = {
1347		{
1348			.name = "qcom,current-boost-limit",
1349			.val_ptr = &cfg->boost_i_limit,
1350			.cfg = &wled4_boost_i_limit_cfg,
1351		},
1352		{
1353			.name = "qcom,current-limit-microamp",
1354			.val_ptr = &cfg->string_i_limit,
1355			.cfg = &wled4_string_i_limit_cfg,
1356		},
1357		{
1358			.name = "qcom,ovp-millivolt",
1359			.val_ptr = &cfg->ovp,
1360			.cfg = &wled4_ovp_cfg,
1361		},
1362		{
1363			.name = "qcom,switching-freq",
1364			.val_ptr = &cfg->switch_freq,
1365			.cfg = &wled3_switch_freq_cfg,
1366		},
1367	};
1368
1369	const struct wled_u32_opts pmi8994_wled_opts[] = {
1370		{
1371			.name = "qcom,current-boost-limit",
1372			.val_ptr = &cfg->boost_i_limit,
1373			.cfg = &wled4_boost_i_limit_cfg,
1374		},
1375		{
1376			.name = "qcom,current-limit-microamp",
1377			.val_ptr = &cfg->string_i_limit,
1378			.cfg = &wled4_string_i_limit_cfg,
1379		},
1380		{
1381			.name = "qcom,ovp-millivolt",
1382			.val_ptr = &cfg->ovp,
1383			.cfg = &pmi8994_wled_ovp_cfg,
1384		},
1385		{
1386			.name = "qcom,switching-freq",
1387			.val_ptr = &cfg->switch_freq,
1388			.cfg = &wled3_switch_freq_cfg,
1389		},
1390	};
1391
1392	const struct wled_u32_opts wled5_opts[] = {
1393		{
1394			.name = "qcom,current-boost-limit",
1395			.val_ptr = &cfg->boost_i_limit,
1396			.cfg = &wled5_boost_i_limit_cfg,
1397		},
1398		{
1399			.name = "qcom,current-limit-microamp",
1400			.val_ptr = &cfg->string_i_limit,
1401			.cfg = &wled4_string_i_limit_cfg,
1402		},
1403		{
1404			.name = "qcom,ovp-millivolt",
1405			.val_ptr = &cfg->ovp,
1406			.cfg = &wled5_ovp_cfg,
1407		},
1408		{
1409			.name = "qcom,switching-freq",
1410			.val_ptr = &cfg->switch_freq,
1411			.cfg = &wled3_switch_freq_cfg,
1412		},
1413		{
1414			.name = "qcom,modulator-sel",
1415			.val_ptr = &cfg->mod_sel,
1416			.cfg = &wled5_mod_sel_cfg,
1417		},
1418		{
1419			.name = "qcom,cabc-sel",
1420			.val_ptr = &cfg->cabc_sel,
1421			.cfg = &wled5_cabc_sel_cfg,
1422		},
1423	};
1424
1425	const struct wled_bool_opts bool_opts[] = {
1426		{ "qcom,cs-out", &cfg->cs_out_en, },
1427		{ "qcom,ext-gen", &cfg->ext_gen, },
1428		{ "qcom,cabc", &cfg->cabc, },
1429		{ "qcom,external-pfet", &cfg->external_pfet, },
1430		{ "qcom,auto-string-detection", &cfg->auto_detection_enabled, },
1431	};
1432
1433	prop_addr = of_get_address(dev->of_node, 0, NULL, NULL);
1434	if (!prop_addr) {
1435		dev_err(wled->dev, "invalid IO resources\n");
1436		return -EINVAL;
1437	}
1438	wled->ctrl_addr = be32_to_cpu(*prop_addr);
1439
1440	rc = of_property_read_string(dev->of_node, "label", &wled->name);
1441	if (rc) {
1442		wled->name = devm_kasprintf(dev, GFP_KERNEL, "%pOFn", dev->of_node);
1443		if (!wled->name)
1444			return -ENOMEM;
1445	}
1446	switch (wled->version) {
1447	case 3:
1448		u32_opts = wled3_opts;
1449		size = ARRAY_SIZE(wled3_opts);
1450		*cfg = wled3_config_defaults;
1451		wled->wled_set_brightness = wled3_set_brightness;
1452		wled->wled_sync_toggle = wled3_sync_toggle;
1453		wled->max_string_count = 3;
1454		wled->sink_addr = wled->ctrl_addr;
1455		break;
1456
1457	case 4:
1458		if (of_device_is_compatible(dev->of_node, "qcom,pmi8950-wled") ||
1459		    of_device_is_compatible(dev->of_node, "qcom,pmi8994-wled")) {
1460			u32_opts = pmi8994_wled_opts;
1461			size = ARRAY_SIZE(pmi8994_wled_opts);
1462		} else {
1463			u32_opts = wled4_opts;
1464			size = ARRAY_SIZE(wled4_opts);
1465		}
1466		*cfg = wled4_config_defaults;
1467		wled->wled_set_brightness = wled4_set_brightness;
1468		wled->wled_sync_toggle = wled3_sync_toggle;
1469		wled->wled_cabc_config = wled4_cabc_config;
1470		wled->wled_ovp_delay = wled4_ovp_delay;
1471		wled->wled_auto_detection_required =
1472					wled4_auto_detection_required;
1473		wled->max_string_count = 4;
1474
1475		prop_addr = of_get_address(dev->of_node, 1, NULL, NULL);
1476		if (!prop_addr) {
1477			dev_err(wled->dev, "invalid IO resources\n");
1478			return -EINVAL;
1479		}
1480		wled->sink_addr = be32_to_cpu(*prop_addr);
1481		break;
1482
1483	case 5:
1484		u32_opts = wled5_opts;
1485		size = ARRAY_SIZE(wled5_opts);
1486		*cfg = wled5_config_defaults;
1487		wled->wled_set_brightness = wled5_set_brightness;
1488		wled->wled_sync_toggle = wled3_sync_toggle;
1489		wled->wled_cabc_config = wled5_cabc_config;
1490		wled->wled_ovp_delay = wled5_ovp_delay;
1491		wled->wled_auto_detection_required =
1492					wled5_auto_detection_required;
1493		wled->max_string_count = 4;
1494
1495		prop_addr = of_get_address(dev->of_node, 1, NULL, NULL);
1496		if (!prop_addr) {
1497			dev_err(wled->dev, "invalid IO resources\n");
1498			return -EINVAL;
1499		}
1500		wled->sink_addr = be32_to_cpu(*prop_addr);
1501		break;
1502
1503	default:
1504		dev_err(wled->dev, "Invalid WLED version\n");
1505		return -EINVAL;
1506	}
1507
1508	for (i = 0; i < size; ++i) {
1509		rc = of_property_read_u32(dev->of_node, u32_opts[i].name, &val);
1510		if (rc == -EINVAL) {
1511			continue;
1512		} else if (rc) {
1513			dev_err(dev, "error reading '%s'\n", u32_opts[i].name);
1514			return rc;
1515		}
1516
1517		c = UINT_MAX;
1518		for (j = 0; c != val; j++) {
1519			c = wled_values(u32_opts[i].cfg, j);
1520			if (c == UINT_MAX) {
1521				dev_err(dev, "invalid value for '%s'\n",
1522					u32_opts[i].name);
1523				return -EINVAL;
1524			}
1525
1526			if (c == val)
1527				break;
1528		}
1529
1530		dev_dbg(dev, "'%s' = %u\n", u32_opts[i].name, c);
1531		*u32_opts[i].val_ptr = j;
1532	}
1533
1534	for (i = 0; i < ARRAY_SIZE(bool_opts); ++i) {
1535		if (of_property_read_bool(dev->of_node, bool_opts[i].name))
1536			*bool_opts[i].val_ptr = true;
1537	}
1538
1539	string_len = of_property_count_elems_of_size(dev->of_node,
1540						     "qcom,enabled-strings",
1541						     sizeof(u32));
1542	if (string_len > 0) {
1543		if (string_len > wled->max_string_count) {
1544			dev_err(dev, "Cannot have more than %d strings\n",
1545				wled->max_string_count);
1546			return -EINVAL;
1547		}
1548
1549		rc = of_property_read_u32_array(dev->of_node,
1550						"qcom,enabled-strings",
1551						wled->cfg.enabled_strings,
1552						string_len);
1553		if (rc) {
1554			dev_err(dev, "Failed to read %d elements from qcom,enabled-strings: %d\n",
1555				string_len, rc);
1556			return rc;
1557		}
1558
1559		for (i = 0; i < string_len; ++i) {
1560			if (wled->cfg.enabled_strings[i] >= wled->max_string_count) {
1561				dev_err(dev,
1562					"qcom,enabled-strings index %d at %d is out of bounds\n",
1563					wled->cfg.enabled_strings[i], i);
1564				return -EINVAL;
1565			}
1566		}
1567
1568		cfg->num_strings = string_len;
1569	}
1570
1571	rc = of_property_read_u32(dev->of_node, "qcom,num-strings", &val);
1572	if (!rc) {
1573		if (val < 1 || val > wled->max_string_count) {
1574			dev_err(dev, "qcom,num-strings must be between 1 and %d\n",
1575				wled->max_string_count);
1576			return -EINVAL;
1577		}
1578
1579		if (string_len > 0) {
1580			dev_warn(dev, "Only one of qcom,num-strings or qcom,enabled-strings"
1581				      " should be set\n");
1582			if (val > string_len) {
1583				dev_err(dev, "qcom,num-strings exceeds qcom,enabled-strings\n");
1584				return -EINVAL;
1585			}
1586		}
1587
1588		cfg->num_strings = val;
1589	}
1590
1591	return 0;
1592}
1593
1594static int wled_configure_short_irq(struct wled *wled,
1595				    struct platform_device *pdev)
1596{
1597	int rc;
1598
1599	if (!wled->has_short_detect)
1600		return 0;
1601
1602	rc = regmap_update_bits(wled->regmap, wled->ctrl_addr +
1603				WLED4_CTRL_REG_SHORT_PROTECT,
1604				WLED4_CTRL_REG_SHORT_EN_MASK,
1605				WLED4_CTRL_REG_SHORT_EN_MASK);
1606	if (rc < 0)
1607		return rc;
1608
1609	wled->short_irq = platform_get_irq_byname(pdev, "short");
1610	if (wled->short_irq < 0) {
1611		dev_dbg(&pdev->dev, "short irq is not used\n");
1612		return 0;
1613	}
1614
1615	rc = devm_request_threaded_irq(wled->dev, wled->short_irq,
1616				       NULL, wled_short_irq_handler,
1617				       IRQF_ONESHOT,
1618				       "wled_short_irq", wled);
1619	if (rc < 0)
1620		dev_err(wled->dev, "Unable to request short_irq (err:%d)\n",
1621			rc);
1622
1623	return rc;
1624}
1625
1626static int wled_configure_ovp_irq(struct wled *wled,
1627				  struct platform_device *pdev)
1628{
1629	int rc;
1630	u32 val;
1631
1632	wled->ovp_irq = platform_get_irq_byname(pdev, "ovp");
1633	if (wled->ovp_irq < 0) {
1634		dev_dbg(&pdev->dev, "OVP IRQ not found - disabling automatic string detection\n");
1635		return 0;
1636	}
1637
1638	rc = devm_request_threaded_irq(wled->dev, wled->ovp_irq, NULL,
1639				       wled_ovp_irq_handler, IRQF_ONESHOT,
1640				       "wled_ovp_irq", wled);
1641	if (rc < 0) {
1642		dev_err(wled->dev, "Unable to request ovp_irq (err:%d)\n",
1643			rc);
1644		wled->ovp_irq = 0;
1645		return 0;
1646	}
1647
1648	rc = regmap_read(wled->regmap, wled->ctrl_addr +
1649			 WLED3_CTRL_REG_MOD_EN, &val);
1650	if (rc < 0)
1651		return rc;
1652
1653	/* Keep OVP irq disabled until module is enabled */
1654	if (!(val & WLED3_CTRL_REG_MOD_EN_MASK))
1655		disable_irq(wled->ovp_irq);
1656
1657	return 0;
1658}
1659
1660static const struct backlight_ops wled_ops = {
1661	.update_status = wled_update_status,
1662};
1663
1664static int wled_probe(struct platform_device *pdev)
1665{
1666	struct backlight_properties props;
1667	struct backlight_device *bl;
1668	struct wled *wled;
1669	struct regmap *regmap;
1670	u32 val;
1671	int rc;
1672
1673	regmap = dev_get_regmap(pdev->dev.parent, NULL);
1674	if (!regmap) {
1675		dev_err(&pdev->dev, "Unable to get regmap\n");
1676		return -EINVAL;
1677	}
1678
1679	wled = devm_kzalloc(&pdev->dev, sizeof(*wled), GFP_KERNEL);
1680	if (!wled)
1681		return -ENOMEM;
1682
1683	wled->regmap = regmap;
1684	wled->dev = &pdev->dev;
1685
1686	wled->version = (uintptr_t)of_device_get_match_data(&pdev->dev);
1687	if (!wled->version) {
1688		dev_err(&pdev->dev, "Unknown device version\n");
1689		return -ENODEV;
1690	}
1691
1692	mutex_init(&wled->lock);
1693	rc = wled_configure(wled);
1694	if (rc)
1695		return rc;
1696
1697	val = WLED3_SINK_REG_BRIGHT_MAX;
1698	of_property_read_u32(pdev->dev.of_node, "max-brightness", &val);
1699	wled->max_brightness = val;
1700
1701	switch (wled->version) {
1702	case 3:
1703		wled->cfg.auto_detection_enabled = false;
1704		rc = wled3_setup(wled);
1705		if (rc) {
1706			dev_err(&pdev->dev, "wled3_setup failed\n");
1707			return rc;
1708		}
1709		break;
1710
1711	case 4:
1712		wled->has_short_detect = true;
1713		rc = wled4_setup(wled);
1714		if (rc) {
1715			dev_err(&pdev->dev, "wled4_setup failed\n");
1716			return rc;
1717		}
1718		break;
1719
1720	case 5:
1721		wled->has_short_detect = true;
1722		if (wled->cfg.cabc_sel)
1723			wled->max_brightness = WLED5_SINK_REG_BRIGHT_MAX_12B;
1724
1725		rc = wled5_setup(wled);
1726		if (rc) {
1727			dev_err(&pdev->dev, "wled5_setup failed\n");
1728			return rc;
1729		}
1730		break;
1731
1732	default:
1733		dev_err(wled->dev, "Invalid WLED version\n");
1734		break;
1735	}
1736
1737	INIT_DELAYED_WORK(&wled->ovp_work, wled_ovp_work);
1738
1739	rc = wled_configure_short_irq(wled, pdev);
1740	if (rc < 0)
1741		return rc;
1742
1743	rc = wled_configure_ovp_irq(wled, pdev);
1744	if (rc < 0)
1745		return rc;
1746
1747	val = WLED_DEFAULT_BRIGHTNESS;
1748	of_property_read_u32(pdev->dev.of_node, "default-brightness", &val);
1749
1750	memset(&props, 0, sizeof(struct backlight_properties));
1751	props.type = BACKLIGHT_RAW;
1752	props.brightness = val;
1753	props.max_brightness = wled->max_brightness;
1754	bl = devm_backlight_device_register(&pdev->dev, wled->name,
1755					    &pdev->dev, wled,
1756					    &wled_ops, &props);
1757	return PTR_ERR_OR_ZERO(bl);
1758};
1759
1760static void wled_remove(struct platform_device *pdev)
1761{
1762	struct wled *wled = platform_get_drvdata(pdev);
1763
1764	mutex_destroy(&wled->lock);
1765	cancel_delayed_work_sync(&wled->ovp_work);
1766	disable_irq(wled->short_irq);
1767	disable_irq(wled->ovp_irq);
1768}
1769
1770static const struct of_device_id wled_match_table[] = {
1771	{ .compatible = "qcom,pm8941-wled", .data = (void *)3 },
1772	{ .compatible = "qcom,pmi8950-wled", .data = (void *)4 },
1773	{ .compatible = "qcom,pmi8994-wled", .data = (void *)4 },
1774	{ .compatible = "qcom,pmi8998-wled", .data = (void *)4 },
1775	{ .compatible = "qcom,pm660l-wled", .data = (void *)4 },
1776	{ .compatible = "qcom,pm6150l-wled", .data = (void *)5 },
1777	{ .compatible = "qcom,pm8150l-wled", .data = (void *)5 },
1778	{}
1779};
1780MODULE_DEVICE_TABLE(of, wled_match_table);
1781
1782static struct platform_driver wled_driver = {
1783	.probe = wled_probe,
1784	.remove = wled_remove,
1785	.driver	= {
1786		.name = "qcom,wled",
1787		.of_match_table	= wled_match_table,
1788	},
1789};
1790
1791module_platform_driver(wled_driver);
1792
1793MODULE_DESCRIPTION("Qualcomm WLED driver");
1794MODULE_LICENSE("GPL v2");