dev/qpnp_wled/qpnp_wled.c - kernel/lk - Gitiles

  /* Copyright (c) 2014-2016, The Linux Foundation. All rights reserved.

  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *   * Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  *   * Redistributions in binary form must reproduce the above
  *     copyright notice, this list of conditions and the following
  *     disclaimer in the documentation and/or other materials provided
  *     with the distribution.
  *   * Neither the name of The Linux Foundation, Inc. nor the names of its
  *     contributors may be used to endorse or promote products derived
  *     from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <err.h>
 #include <qpnp_wled.h>
 #include <pm8x41_wled.h>
 #include <qtimer.h>

 static int qpnp_wled_avdd_target_voltages[NUM_SUPPORTED_AVDD_VOLTAGES] = {
 	7900, 7600, 7300, 6400, 6100, 5800,
 };

 static uint8_t qpnp_wled_ovp_reg_settings[NUM_SUPPORTED_AVDD_VOLTAGES] = {
 	0x0, 0x0, 0x1, 0x2, 0x2, 0x3,
 };

 static int qpnp_wled_avdd_trim_adjustments[NUM_SUPPORTED_AVDD_VOLTAGES] = {
 	3, 0, -2, 7, 3, 3,
 };

 static int fls(uint16_t n)
 {
 	int i = 0;
 	for (; n; n >>= 1, i++);
 	  return i;
 }

 static struct qpnp_wled *gwled;
 static int qpnp_labibb_regulator_set_voltage(struct qpnp_wled *wled);

 static int qpnp_wled_sec_access(struct qpnp_wled *wled, uint16_t base_addr)
 {
 	uint8_t reg = QPNP_WLED_SEC_UNLOCK;

 	pm8x41_wled_reg_write(QPNP_WLED_SEC_ACCESS_REG(base_addr), reg);

 	return 0;
 }

 /* set wled to a level of brightness */
 static int qpnp_wled_set_level(struct qpnp_wled *wled, int level)
 {
 	int i;
 	uint8_t reg;

 	/* set brightness registers */
 	for (i = 0; i < wled->num_strings; i++) {
 		reg = level & QPNP_WLED_BRIGHT_LSB_MASK;
 		pm8x41_wled_reg_write(QPNP_WLED_BRIGHT_LSB_REG(wled->sink_base,
 						wled->strings[i]), reg);

 		reg = level >> QPNP_WLED_BRIGHT_MSB_SHIFT;
 		reg = reg & QPNP_WLED_BRIGHT_MSB_MASK;
 		pm8x41_wled_reg_write(QPNP_WLED_BRIGHT_MSB_REG(wled->sink_base,
 						wled->strings[i]), reg);
 	}

 	/* sync */
 	reg = QPNP_WLED_SYNC;
 	pm8x41_wled_reg_write(QPNP_WLED_SYNC_REG(wled->sink_base), reg);

 	reg = QPNP_WLED_SYNC_RESET;
 	pm8x41_wled_reg_write(QPNP_WLED_SYNC_REG(wled->sink_base), reg);

 	return 0;
 }

 static int qpnp_wled_enable(struct qpnp_wled *wled,
 				uint16_t base_addr, bool state)
 {
 	uint8_t reg;

 	reg = pm8x41_wled_reg_read(
 			QPNP_WLED_MODULE_EN_REG(base_addr));
 	reg &= QPNP_WLED_MODULE_EN_MASK;
 	reg |= (state << QPNP_WLED_MODULE_EN_SHIFT);
 	pm8x41_wled_reg_write(QPNP_WLED_MODULE_EN_REG(base_addr), reg);

 	return 0;
 }

 static int qpnp_wled_ibb_swire_rdy(struct qpnp_wled *wled,
 				uint16_t base_addr, bool state)
 {
 	uint8_t reg;

 	reg = pm8x41_wled_reg_read(
 			QPNP_WLED_MODULE_EN_REG(base_addr));
 	/* Do not enable IBB module when SWIRE ready is set */
 	reg &= ~(QPNP_IBB_SWIRE_RDY_MASK | QPNP_IBB_MODULE_EN_MASK);
 	reg |= (state << QPNP_IBB_SWIRE_RDY_SHIFT);
 	pm8x41_wled_reg_write(QPNP_WLED_MODULE_EN_REG(base_addr), reg);

 	return 0;
 }

 int qpnp_ibb_enable(bool state)
 {
 	int rc = 0;
 	uint8_t reg;

 	if (!gwled) {
 		dprintf(CRITICAL, "%s: wled is not initialized yet\n", __func__);
 		return ERROR;
 	}

 	/* enable lab */
 	if (gwled->ibb_bias_active) {
 		rc = qpnp_wled_enable(gwled, gwled->lab_base, state);
 		udelay(QPNP_WLED_LAB_START_DLY_US + 1);
 		if (rc < 0)
 			return rc;
 	} else {
 		reg = pm8x41_wled_reg_read(QPNP_WLED_LAB_IBB_RDY_REG(gwled->lab_base));

 		reg &= QPNP_WLED_MODULE_EN_MASK;
 		reg |= (state << QPNP_WLED_MODULE_EN_SHIFT);
 		pm8x41_wled_reg_write(QPNP_WLED_LAB_IBB_RDY_REG(gwled->lab_base), reg);
 	}

 	if (gwled->disp_type_amoled && gwled->lab_ibb_swire_control)
 		rc = qpnp_wled_ibb_swire_rdy(gwled, gwled->ibb_base, state);
 	else
 		rc = qpnp_wled_enable(gwled, gwled->ibb_base, state);

 	return rc;
 }

 /* enable / disable wled brightness */
 void qpnp_wled_enable_backlight(int enable)
 {
 	int rc;

 	if (!gwled) {
 		dprintf(CRITICAL, "%s: wled is not initialized yet\n", __func__);
 		return;
 	}

 	if (enable) {
 		rc = qpnp_wled_set_level(gwled, QPNP_WLED_MAX_BR_LEVEL);
 		if (rc) {
 			dprintf(CRITICAL,"wled set level failed\n");
 			return;
 		}
 	}

 	if (!gwled->disp_type_amoled || !gwled->wled_avdd_control) {
 		rc = qpnp_wled_enable(gwled, gwled->ctrl_base, enable);
 		if (rc) {
 			dprintf(CRITICAL, "wled %sable failed\n",
 						enable ? "en" : "dis");
 			return;
 		}
 	}

 }

 static int qpnp_wled_set_display_type(struct qpnp_wled *wled, uint16_t base_addr)
 {
 	uint8_t reg = 0;
 	int rc;

 	/* display type */
 	reg = pm8x41_wled_reg_read(QPNP_WLED_DISP_SEL_REG(base_addr));

 	reg &= QPNP_WLED_DISP_SEL_MASK;
 	reg |= (wled->disp_type_amoled << QPNP_WLED_DISP_SEL_SHIFT);

 	rc = qpnp_wled_sec_access(wled, base_addr);
 	if (rc)
 		return rc;

 	pm8x41_wled_reg_write(QPNP_WLED_DISP_SEL_REG(base_addr), reg);

 	return 0;
 }

 static int qpnp_wled_module_ready(struct qpnp_wled *wled, uint16_t base_addr, bool state)
 {
 	uint8_t reg;

 	reg = pm8x41_wled_reg_read(
 			QPNP_WLED_MODULE_RDY_REG(base_addr));
 	reg &= QPNP_WLED_MODULE_RDY_MASK;
 	reg |= (state << QPNP_WLED_MODULE_RDY_SHIFT);
 	pm8x41_wled_reg_write(QPNP_WLED_MODULE_RDY_REG(base_addr), reg);

 	return 0;
 }

 /* Configure WLED registers */
 static int qpnp_wled_config(struct qpnp_wled *wled)
 {
 	int rc, i, temp;
 	uint8_t reg = 0;

 	/* Configure display type */
 	rc = qpnp_wled_set_display_type(wled, wled->ctrl_base);
 	if (rc < 0)
 		return rc;

 	/* Recommended WLED MDOS settings for AMOLED */
 	if (wled->disp_type_amoled) {
 		pm8x41_wled_reg_write(QPNP_WLED_VLOOP_COMP_RES(wled->ctrl_base),
 			0x8F);
 		pm8x41_wled_reg_write(QPNP_WLED_VLOOP_COMP_GM(wled->ctrl_base),
 			0x81);
 		pm8x41_wled_reg_write(QPNP_WLED_PSM_CTRL(wled->ctrl_base),
 			0x83);

 		rc = qpnp_wled_sec_access(wled, wled->ctrl_base);
 		if (rc)
 			return rc;
 		pm8x41_wled_reg_write(QPNP_WLED_TEST4(wled->ctrl_base), 0x13);
 	}

 	/* Configure the FEEDBACK OUTPUT register */
 	reg = pm8x41_wled_reg_read(
 			QPNP_WLED_FDBK_OP_REG(wled->ctrl_base));
 	reg &= QPNP_WLED_FDBK_OP_MASK;
 	reg |= wled->fdbk_op;
 	pm8x41_wled_reg_write(QPNP_WLED_FDBK_OP_REG(wled->ctrl_base), reg);

 	/* Configure the VREF register */
 	if (wled->vref_mv < QPNP_WLED_VREF_MIN_MV)
 		wled->vref_mv = QPNP_WLED_VREF_MIN_MV;
 	else if (wled->vref_mv > QPNP_WLED_VREF_MAX_MV)
 		wled->vref_mv = QPNP_WLED_VREF_MAX_MV;

 	reg = pm8x41_wled_reg_read(
 			QPNP_WLED_VREF_REG(wled->ctrl_base));
 	reg &= QPNP_WLED_VREF_MASK;
 	temp = wled->vref_mv - QPNP_WLED_VREF_MIN_MV;
 	reg |= (temp / QPNP_WLED_VREF_STEP_MV);
 	pm8x41_wled_reg_write(QPNP_WLED_VREF_REG(wled->ctrl_base), reg);

 	/* Configure the ILIM register */
 	if (wled->ilim_ma < QPNP_WLED_ILIM_MIN_MA)
 		wled->ilim_ma = QPNP_WLED_ILIM_MIN_MA;
 	else if (wled->ilim_ma > QPNP_WLED_ILIM_MAX_MA)
 		wled->ilim_ma = QPNP_WLED_ILIM_MAX_MA;

 	reg = pm8x41_wled_reg_read(
 			QPNP_WLED_ILIM_REG(wled->ctrl_base));
 	temp = (wled->ilim_ma / QPNP_WLED_ILIM_STEP_MA);
 	if (temp != (reg & ~QPNP_WLED_ILIM_MASK)) {
 		reg &= QPNP_WLED_ILIM_MASK;
 		reg |= temp;
 		reg |= QPNP_WLED_ILIM_OVERWRITE;
 		pm8x41_wled_reg_write(QPNP_WLED_ILIM_REG(wled->ctrl_base), reg);
 	}

 	/* Configure the MAX BOOST DUTY register */
 	if (wled->boost_duty_ns < QPNP_WLED_BOOST_DUTY_MIN_NS)
 		wled->boost_duty_ns = QPNP_WLED_BOOST_DUTY_MIN_NS;
 	else if (wled->boost_duty_ns > QPNP_WLED_BOOST_DUTY_MAX_NS)
 		wled->boost_duty_ns = QPNP_WLED_BOOST_DUTY_MAX_NS;

 	reg = pm8x41_wled_reg_read(
 			QPNP_WLED_BOOST_DUTY_REG(wled->ctrl_base));
 	reg &= QPNP_WLED_BOOST_DUTY_MASK;
 	reg |= (wled->boost_duty_ns / QPNP_WLED_BOOST_DUTY_STEP_NS);
 	pm8x41_wled_reg_write(QPNP_WLED_BOOST_DUTY_REG(wled->ctrl_base), reg);

 	/* Configure the SWITCHING FREQ register */
 	if (wled->switch_freq_khz == QPNP_WLED_SWITCH_FREQ_1600_KHZ)
 		temp = QPNP_WLED_SWITCH_FREQ_1600_KHZ_CODE;
 	else
 		temp = QPNP_WLED_SWITCH_FREQ_800_KHZ_CODE;

 	reg = pm8x41_wled_reg_read(
 			QPNP_WLED_SWITCH_FREQ_REG(wled->ctrl_base));
 	reg &= QPNP_WLED_SWITCH_FREQ_MASK;
 	reg |= temp;
 	pm8x41_wled_reg_write(QPNP_WLED_SWITCH_FREQ_REG(wled->ctrl_base), reg);

 	/* Configure the OVP register */
 	if (wled->ovp_mv <= QPNP_WLED_OVP_17800_MV) {
 		wled->ovp_mv = QPNP_WLED_OVP_17800_MV;
 		temp = 3;
 	} else if (wled->ovp_mv <= QPNP_WLED_OVP_19400_MV) {
 		wled->ovp_mv = QPNP_WLED_OVP_19400_MV;
 		temp = 2;
 	} else if (wled->ovp_mv <= QPNP_WLED_OVP_29500_MV) {
 		wled->ovp_mv = QPNP_WLED_OVP_29500_MV;
 		temp = 1;
 	} else {
 		wled->ovp_mv = QPNP_WLED_OVP_31000_MV;
 		temp = 0;
 	}

 	reg = pm8x41_wled_reg_read(
 			QPNP_WLED_OVP_REG(wled->ctrl_base));
 	reg &= QPNP_WLED_OVP_MASK;
 	reg |= temp;
 	pm8x41_wled_reg_write(QPNP_WLED_OVP_REG(wled->ctrl_base), reg);

 	if (wled->disp_type_amoled) {
 		for (i = 0; i < NUM_SUPPORTED_AVDD_VOLTAGES; i++) {
 			if (QPNP_WLED_AVDD_DEFAULT_VOLTAGE_MV == qpnp_wled_avdd_target_voltages[i])
 				break;
 		}
 		if (i == NUM_SUPPORTED_AVDD_VOLTAGES)
 		{
 			dprintf(CRITICAL, "Invalid avdd target voltage specified \n");
 			return ERR_NOT_VALID;
 		}
 		/* Update WLED_OVP register based on desired target voltage */
 		reg = qpnp_wled_ovp_reg_settings[i];
 		pm8x41_wled_reg_write(QPNP_WLED_OVP_REG(wled->ctrl_base), reg);
 		/* Update WLED_TRIM register based on desired target voltage */
 		reg = pm8x41_wled_reg_read(
 			QPNP_WLED_REF_7P7_TRIM_REG(wled->ctrl_base));
 		reg += qpnp_wled_avdd_trim_adjustments[i];
 		if ((int8_t)reg < QPNP_WLED_AVDD_MIN_TRIM_VALUE)
 			reg = QPNP_WLED_AVDD_MIN_TRIM_VALUE;
 		else if((int8_t)reg > QPNP_WLED_AVDD_MAX_TRIM_VALUE)
 			reg = QPNP_WLED_AVDD_MAX_TRIM_VALUE;

 		rc = qpnp_wled_sec_access(wled, wled->ctrl_base);
 		if (rc)
 			return rc;

 		temp = pm8x41_wled_reg_read(
 			QPNP_WLED_REF_7P7_TRIM_REG(wled->ctrl_base));
 		temp &= ~QPNP_WLED_7P7_TRIM_MASK;
 		temp |= (reg & QPNP_WLED_7P7_TRIM_MASK);
 		pm8x41_wled_reg_write(QPNP_WLED_REF_7P7_TRIM_REG(wled->ctrl_base), temp);
 		/* Write to spare to avoid reconfiguration in HLOS */
 		reg = pm8x41_wled_reg_read(
 			QPNP_WLED_CTRL_SPARE_REG(wled->ctrl_base));
 		reg |= QPNP_WLED_AVDD_SET_BIT;
 		pm8x41_wled_reg_write(QPNP_WLED_CTRL_SPARE_REG(wled->ctrl_base), reg);
 	}

 	/* Configure the MODULATION register */
 	if (wled->mod_freq_khz <= QPNP_WLED_MOD_FREQ_1200_KHZ) {
 		wled->mod_freq_khz = QPNP_WLED_MOD_FREQ_1200_KHZ;
 		temp = 3;
 	} else if (wled->mod_freq_khz <= QPNP_WLED_MOD_FREQ_2400_KHZ) {
 		wled->mod_freq_khz = QPNP_WLED_MOD_FREQ_2400_KHZ;
 		temp = 2;
 	} else if (wled->mod_freq_khz <= QPNP_WLED_MOD_FREQ_9600_KHZ) {
 		wled->mod_freq_khz = QPNP_WLED_MOD_FREQ_9600_KHZ;
 		temp = 1;
 	} else {
 		wled->mod_freq_khz = QPNP_WLED_MOD_FREQ_19200_KHZ;
 		temp = 0;
 	}
 	reg = pm8x41_wled_reg_read(QPNP_WLED_MOD_REG(wled->sink_base));

 	reg &= QPNP_WLED_MOD_FREQ_MASK;
 	reg |= (temp << QPNP_WLED_MOD_FREQ_SHIFT);

 	reg &= QPNP_WLED_PHASE_STAG_MASK;
 	reg |= (wled->en_phase_stag << QPNP_WLED_PHASE_STAG_SHIFT);

 	reg &= QPNP_WLED_DIM_RES_MASK;
 	reg |= (wled->en_9b_dim_res << QPNP_WLED_DIM_RES_SHIFT);

 	if (wled->dim_mode == QPNP_WLED_DIM_HYBRID) {
 		reg &= QPNP_WLED_DIM_HYB_MASK;
 		reg |= (1 << QPNP_WLED_DIM_HYB_SHIFT);
 	} else {
 		reg &= QPNP_WLED_DIM_HYB_MASK;
 		reg |= (0 << QPNP_WLED_DIM_HYB_SHIFT);
 		reg &= QPNP_WLED_DIM_ANA_MASK;
 		reg |= wled->dim_mode;
 	}

 	pm8x41_wled_reg_write(QPNP_WLED_MOD_REG(wled->sink_base), reg);

 	/* Configure the HYBRID THRESHOLD register */
 	if (wled->hyb_thres < QPNP_WLED_HYB_THRES_MIN)
 		wled->hyb_thres = QPNP_WLED_HYB_THRES_MIN;
 	else if (wled->hyb_thres > QPNP_WLED_HYB_THRES_MAX)
 		wled->hyb_thres = QPNP_WLED_HYB_THRES_MAX;

 	reg = pm8x41_wled_reg_read(
 			QPNP_WLED_HYB_THRES_REG(wled->sink_base));

 	reg &= QPNP_WLED_HYB_THRES_MASK;
 	temp = fls(wled->hyb_thres / QPNP_WLED_HYB_THRES_MIN) - 1;
 	reg |= temp;
 	pm8x41_wled_reg_write(QPNP_WLED_HYB_THRES_REG(wled->sink_base), reg);

 	for (i = 0; i < wled->num_strings; i++) {
 		if (wled->strings[i] >= QPNP_WLED_MAX_STRINGS) {
 			dprintf(CRITICAL,"Invalid string number\n");
 			return ERR_NOT_VALID;
 		}

 		/* MODULATOR */
 		reg = pm8x41_wled_reg_read(
 				QPNP_WLED_MOD_EN_REG(wled->sink_base,
 						wled->strings[i]));
 		reg &= QPNP_WLED_MOD_EN_MASK;
 		reg |= (QPNP_WLED_MOD_EN << QPNP_WLED_MOD_EN_SHFT);
 		pm8x41_wled_reg_write(QPNP_WLED_MOD_EN_REG(wled->sink_base,
 						wled->strings[i]), reg);

 		/* SYNC DELAY */
 		if (wled->sync_dly_us > QPNP_WLED_SYNC_DLY_MAX_US)
 			wled->sync_dly_us = QPNP_WLED_SYNC_DLY_MAX_US;

 		reg = pm8x41_wled_reg_read(
 				QPNP_WLED_SYNC_DLY_REG(wled->sink_base,
 						wled->strings[i]));
 		reg &= QPNP_WLED_SYNC_DLY_MASK;
 		temp = wled->sync_dly_us / QPNP_WLED_SYNC_DLY_STEP_US;
 		reg |= temp;
 		pm8x41_wled_reg_write(QPNP_WLED_SYNC_DLY_REG(wled->sink_base,
 						wled->strings[i]), reg);

 		/* FULL SCALE CURRENT */
 		if (wled->fs_curr_ua > QPNP_WLED_FS_CURR_MAX_UA)
 			wled->fs_curr_ua = QPNP_WLED_FS_CURR_MAX_UA;

 		reg = pm8x41_wled_reg_read(
 				QPNP_WLED_FS_CURR_REG(wled->sink_base,
 						wled->strings[i]));
 		reg &= QPNP_WLED_FS_CURR_MASK;
 		temp = wled->fs_curr_ua / QPNP_WLED_FS_CURR_STEP_UA;
 		reg |= temp;
 		pm8x41_wled_reg_write(QPNP_WLED_FS_CURR_REG(wled->sink_base,
 						wled->strings[i]), reg);

 		/* CABC */
 		reg = pm8x41_wled_reg_read(
 				QPNP_WLED_CABC_REG(wled->sink_base,
 						wled->strings[i]));
 		reg &= QPNP_WLED_CABC_MASK;
 		reg |= (wled->en_cabc << QPNP_WLED_CABC_SHIFT);
 		pm8x41_wled_reg_write(QPNP_WLED_CABC_REG(wled->sink_base,
 						wled->strings[i]), reg);

 		/* Enable CURRENT SINK */
 		reg = pm8x41_wled_reg_read(
 				QPNP_WLED_CURR_SINK_REG(wled->sink_base));
 		temp = wled->strings[i] + QPNP_WLED_CURR_SINK_SHIFT;
 		reg |= (1 << temp);
 		pm8x41_wled_reg_write(QPNP_WLED_CURR_SINK_REG(wled->sink_base), reg);
 	}

 	/* LAB fast precharge */
 	reg = pm8x41_wled_reg_read(
 			QPNP_WLED_LAB_FAST_PC_REG(wled->lab_base));
 	reg &= QPNP_WLED_LAB_FAST_PC_MASK;
 	reg |= (wled->lab_fast_precharge << QPNP_WLED_LAB_FAST_PC_SHIFT);
 	pm8x41_wled_reg_write(QPNP_WLED_LAB_FAST_PC_REG(wled->lab_base), reg);

 	/* Configure lab display type */
 	rc = qpnp_wled_set_display_type(wled, wled->lab_base);
 	if (rc < 0)
 		return rc;

 	/* make LAB module ready */
 	rc = qpnp_wled_module_ready(wled, wled->lab_base, true);
 	if (rc < 0)
 		return rc;

 	/* Disable LAB pulse skipping for AMOLED */
 	if (wled->disp_type_amoled)
 		pm8x41_wled_reg_write(wled->lab_base +
 			QPNP_LABIBB_PS_CTL, 0x00);

 	/* IBB active bias */
 	if (wled->ibb_pwrup_dly_ms > QPNP_WLED_IBB_PWRUP_DLY_MAX_MS)
 		wled->ibb_pwrup_dly_ms = QPNP_WLED_IBB_PWRUP_DLY_MAX_MS;

 	if (wled->ibb_pwrdn_dly_ms > QPNP_WLED_IBB_PWRDN_DLY_MAX_MS)
 		wled->ibb_pwrdn_dly_ms = QPNP_WLED_IBB_PWRDN_DLY_MAX_MS;

 	reg = pm8x41_wled_reg_read(
 			QPNP_WLED_IBB_BIAS_REG(wled->ibb_base));

 	reg &= QPNP_WLED_IBB_BIAS_MASK;
 	reg |= (!wled->ibb_bias_active << QPNP_WLED_IBB_BIAS_SHIFT);

 	temp = wled->ibb_pwrup_dly_ms;
 	reg &= QPNP_WLED_IBB_PWRUP_DLY_MASK;
 	reg |= (temp << QPNP_WLED_IBB_PWRUP_DLY_SHIFT);
 	/* Power down delay bits could already be set, clear them before
 	 * or'ing new values
 	 */
 	reg &= ~(PWRDN_DLY2_MASK);
 	reg |= wled->ibb_pwrdn_dly_ms;
 	reg |= (wled->ibb_discharge_en << 2);

 	rc = qpnp_wled_sec_access(wled, wled->ibb_base);
 	if (rc)
 		return rc;

 	pm8x41_wled_reg_write(QPNP_WLED_IBB_BIAS_REG(wled->ibb_base), reg);

 	/* Configure ibb display type */
 	rc = qpnp_wled_set_display_type(wled, wled->ibb_base);
 	if (rc < 0)
 		return rc;

 	/* make IBB module ready */
 	rc = qpnp_wled_module_ready(wled, wled->ibb_base, true);
 	if (rc < 0)
 		return rc;

 	rc = qpnp_labibb_regulator_set_voltage(wled);
 	if (rc < 0)
 		return rc;

 	return 0;
 }

 /* Setup wled default parameters */
 static int qpnp_wled_setup(struct qpnp_wled *wled, struct qpnp_wled_config_data *config)
 {
 	int i;

 	wled->sink_base = QPNP_WLED_SINK_BASE;
 	wled->ctrl_base = QPNP_WLED_CTRL_BASE;
 	wled->ibb_base = QPNP_WLED_IBB_BASE;
 	wled->lab_base = QPNP_WLED_LAB_BASE;
 	wled->fdbk_op = QPNP_WLED_FDBK_AUTO;
 	wled->vref_mv = QPNP_WLED_DFLT_VREF_MV;
 	wled->switch_freq_khz = QPNP_WLED_SWITCH_FREQ_800_KHZ;
 	wled->ovp_mv = QPNP_WLED_OVP_29500_MV;
 	wled->ilim_ma = QPNP_WLED_DFLT_ILIM_MA;
 	wled->boost_duty_ns = QPNP_WLED_BOOST_DUTY_MIN_NS;
 	wled->mod_freq_khz = QPNP_WLED_MOD_FREQ_19200_KHZ;
 	wled->dim_mode = QPNP_WLED_DIM_HYBRID;
 	wled->dim_shape = QPNP_WLED_DIM_SHAPE_LINEAR;

 	if (wled->dim_mode == QPNP_WLED_DIM_HYBRID) {
 		wled->hyb_thres = QPNP_WLED_DFLT_HYB_THRES;
 	}

 	wled->sync_dly_us = 800;
 	wled->fs_curr_ua = 16000;
 	wled->en_9b_dim_res = 0;
 	wled->en_phase_stag = true;
 	wled->en_cabc = 0;

 	wled->num_strings = QPNP_WLED_MAX_STRINGS;
 		for (i = 0; i < wled->num_strings; i++)
 			wled->strings[i] = i;

 	wled->ibb_bias_active = false;
 	wled->lab_fast_precharge = false;
 	wled->ibb_pwrup_dly_ms = config->pwr_up_delay;
 	wled->ibb_pwrdn_dly_ms = config->pwr_down_delay;
 	wled->ibb_discharge_en = config->ibb_discharge_en;
 	wled->disp_type_amoled = config->display_type;
 	wled->lab_min_volt = config->lab_min_volt;
 	wled->lab_max_volt = config->lab_max_volt;
 	wled->ibb_min_volt = config->ibb_min_volt;
 	wled->ibb_max_volt = config->ibb_max_volt;
 	wled->ibb_init_volt = config->ibb_init_volt;
 	wled->lab_init_volt = config->lab_init_volt;
 	wled->lab_ibb_swire_control = config->lab_ibb_swire_control;
 	wled->wled_avdd_control = config->wled_avdd_control;

 	return 0;
 }

 int qpnp_wled_init(struct qpnp_wled_config_data *config)
 {
 	int rc;
 	struct qpnp_wled *wled;

 	wled = malloc(sizeof(struct qpnp_wled));
 	if (!wled)
 		return ERR_NO_MEMORY;

 	memset(wled, 0, sizeof(struct qpnp_wled));

 	rc = qpnp_wled_setup(wled, config);
 	if (rc) {
 		dprintf(CRITICAL, "Setting WLED parameters failed\n");
 		return rc;
 	}

 	rc = qpnp_wled_config(wled);
 	if (rc) {
 		dprintf(CRITICAL, "wled config failed\n");
 		return rc;
 	}

 	gwled = wled;

 	return rc;
 }

 static int qpnp_labibb_regulator_set_voltage(struct qpnp_wled *wled)
 {
 	int rc = -1;
 	uint32_t new_uV;
 	uint8_t val, mask=0;

 	if (!wled->disp_type_amoled || !wled->lab_ibb_swire_control) {
 		if (wled->lab_min_volt < wled->lab_init_volt) {
 			dprintf(CRITICAL,"qpnp_lab_regulator_set_voltage failed, min_uV %d is less than init volt %d\n",
 			wled->lab_min_volt, wled->lab_init_volt);
 			return rc;
 		}

 		val = (((wled->lab_min_volt - wled->lab_init_volt) +
 		(IBB_LAB_VREG_STEP_SIZE - 1)) / IBB_LAB_VREG_STEP_SIZE);
 		new_uV = val * IBB_LAB_VREG_STEP_SIZE + wled->lab_init_volt;

 		if (new_uV > wled->lab_max_volt) {
 			dprintf(CRITICAL,"qpnp_ibb_regulator_set_voltage unable to set voltage (%d %d)\n",
 			wled->lab_min_volt, wled->lab_max_volt);
 			return rc;
 		}
 		val |= QPNP_LAB_OUTPUT_OVERRIDE_EN;
 		mask = pm8x41_wled_reg_read(wled->lab_base +
 				QPNP_LABIBB_OUTPUT_VOLTAGE);
 		mask &= ~(QPNP_LAB_SET_VOLTAGE_MASK
 				| QPNP_LAB_OUTPUT_OVERRIDE_EN);
 		mask |= val & (QPNP_LAB_SET_VOLTAGE_MASK
 				| QPNP_LAB_OUTPUT_OVERRIDE_EN);

 		pm8x41_wled_reg_write(wled->lab_base +
 				QPNP_LABIBB_OUTPUT_VOLTAGE, mask);
 		udelay(2);

 		/*
 		 * IBB Set Voltage.
 		 * For AMOLED panels, the IBB voltage needs to be
 		 * controlled by panel.
 		 */
 		if (wled->ibb_min_volt < wled->ibb_init_volt) {
 			dprintf(CRITICAL, "qpnp_ibb_regulator_set_voltage failed, min_uV %d is less than init volt %d\n",
 			wled->ibb_min_volt, wled->ibb_init_volt);
 			return rc;
 		}

 		val = (((wled->ibb_min_volt - wled->ibb_init_volt) +
 			(IBB_LAB_VREG_STEP_SIZE - 1)) / IBB_LAB_VREG_STEP_SIZE);
 		new_uV = val * IBB_LAB_VREG_STEP_SIZE + wled->ibb_init_volt;
 		if (new_uV > wled->ibb_max_volt) {
 			dprintf(CRITICAL, "qpnp_ibb_regulator_set_voltage unable to set voltage %d %d\n",
 			wled->ibb_min_volt, wled->ibb_max_volt);
 			return rc;
 		}
 		val |= QPNP_LAB_OUTPUT_OVERRIDE_EN;
 		mask = pm8x41_wled_reg_read(wled->ibb_base +
 			QPNP_LABIBB_OUTPUT_VOLTAGE);
 		udelay(2);
 		mask &= ~(QPNP_IBB_SET_VOLTAGE_MASK |
 			QPNP_LAB_OUTPUT_OVERRIDE_EN);
 		mask |= (val & (QPNP_IBB_SET_VOLTAGE_MASK |
 			QPNP_LAB_OUTPUT_OVERRIDE_EN));

 		pm8x41_wled_reg_write(wled->ibb_base +
 			QPNP_LABIBB_OUTPUT_VOLTAGE, mask);
 	} else {
 		pm8x41_wled_reg_write(wled->ibb_base +
 			QPNP_LABIBB_OUTPUT_VOLTAGE, 0x00);
 	}

 	return 0;
 }
	/* Copyright (c) 2014-2016, The Linux Foundation. All rights reserved.

	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are
	* met:
	* * Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* * Redistributions in binary form must reproduce the above
	* copyright notice, this list of conditions and the following
	* disclaimer in the documentation and/or other materials provided
	* with the distribution.
	* * Neither the name of The Linux Foundation, Inc. nor the names of its
	* contributors may be used to endorse or promote products derived
	* from this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
	* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#include <stdio.h>
	#include <string.h>
	#include <stdlib.h>
	#include <err.h>
	#include <qpnp_wled.h>
	#include <pm8x41_wled.h>
	#include <qtimer.h>

	static int qpnp_wled_avdd_target_voltages[NUM_SUPPORTED_AVDD_VOLTAGES] = {
	7900, 7600, 7300, 6400, 6100, 5800,
	};

	static uint8_t qpnp_wled_ovp_reg_settings[NUM_SUPPORTED_AVDD_VOLTAGES] = {
	0x0, 0x0, 0x1, 0x2, 0x2, 0x3,
	};

	static int qpnp_wled_avdd_trim_adjustments[NUM_SUPPORTED_AVDD_VOLTAGES] = {
	3, 0, -2, 7, 3, 3,
	};

	static int fls(uint16_t n)
	{
	int i = 0;
	for (; n; n >>= 1, i++);
	return i;
	}

	static struct qpnp_wled *gwled;
	static int qpnp_labibb_regulator_set_voltage(struct qpnp_wled *wled);

	static int qpnp_wled_sec_access(struct qpnp_wled *wled, uint16_t base_addr)
	{
	uint8_t reg = QPNP_WLED_SEC_UNLOCK;

	pm8x41_wled_reg_write(QPNP_WLED_SEC_ACCESS_REG(base_addr), reg);

	return 0;
	}

	/* set wled to a level of brightness */
	static int qpnp_wled_set_level(struct qpnp_wled *wled, int level)
	{
	int i;
	uint8_t reg;

	/* set brightness registers */
	for (i = 0; i < wled->num_strings; i++) {
	reg = level & QPNP_WLED_BRIGHT_LSB_MASK;
	pm8x41_wled_reg_write(QPNP_WLED_BRIGHT_LSB_REG(wled->sink_base,
	wled->strings[i]), reg);

	reg = level >> QPNP_WLED_BRIGHT_MSB_SHIFT;
	reg = reg & QPNP_WLED_BRIGHT_MSB_MASK;
	pm8x41_wled_reg_write(QPNP_WLED_BRIGHT_MSB_REG(wled->sink_base,
	wled->strings[i]), reg);
	}

	/* sync */
	reg = QPNP_WLED_SYNC;
	pm8x41_wled_reg_write(QPNP_WLED_SYNC_REG(wled->sink_base), reg);

	reg = QPNP_WLED_SYNC_RESET;
	pm8x41_wled_reg_write(QPNP_WLED_SYNC_REG(wled->sink_base), reg);

	return 0;
	}

	static int qpnp_wled_enable(struct qpnp_wled *wled,
	uint16_t base_addr, bool state)
	{
	uint8_t reg;

	reg = pm8x41_wled_reg_read(
	QPNP_WLED_MODULE_EN_REG(base_addr));
	reg &= QPNP_WLED_MODULE_EN_MASK;
	reg \|= (state << QPNP_WLED_MODULE_EN_SHIFT);
	pm8x41_wled_reg_write(QPNP_WLED_MODULE_EN_REG(base_addr), reg);

	return 0;
	}

	static int qpnp_wled_ibb_swire_rdy(struct qpnp_wled *wled,
	uint16_t base_addr, bool state)
	{
	uint8_t reg;

	reg = pm8x41_wled_reg_read(
	QPNP_WLED_MODULE_EN_REG(base_addr));
	/* Do not enable IBB module when SWIRE ready is set */
	reg &= ~(QPNP_IBB_SWIRE_RDY_MASK \| QPNP_IBB_MODULE_EN_MASK);
	reg \|= (state << QPNP_IBB_SWIRE_RDY_SHIFT);
	pm8x41_wled_reg_write(QPNP_WLED_MODULE_EN_REG(base_addr), reg);

	return 0;
	}

	int qpnp_ibb_enable(bool state)
	{
	int rc = 0;
	uint8_t reg;

	if (!gwled) {
	dprintf(CRITICAL, "%s: wled is not initialized yet\n", __func__);
	return ERROR;
	}

	/* enable lab */
	if (gwled->ibb_bias_active) {
	rc = qpnp_wled_enable(gwled, gwled->lab_base, state);
	udelay(QPNP_WLED_LAB_START_DLY_US + 1);
	if (rc < 0)
	return rc;
	} else {
	reg = pm8x41_wled_reg_read(QPNP_WLED_LAB_IBB_RDY_REG(gwled->lab_base));

	reg &= QPNP_WLED_MODULE_EN_MASK;
	reg \|= (state << QPNP_WLED_MODULE_EN_SHIFT);
	pm8x41_wled_reg_write(QPNP_WLED_LAB_IBB_RDY_REG(gwled->lab_base), reg);
	}

	if (gwled->disp_type_amoled && gwled->lab_ibb_swire_control)
	rc = qpnp_wled_ibb_swire_rdy(gwled, gwled->ibb_base, state);
	else
	rc = qpnp_wled_enable(gwled, gwled->ibb_base, state);

	return rc;
	}

	/* enable / disable wled brightness */
	void qpnp_wled_enable_backlight(int enable)
	{
	int rc;

	if (!gwled) {
	dprintf(CRITICAL, "%s: wled is not initialized yet\n", __func__);
	return;
	}

	if (enable) {
	rc = qpnp_wled_set_level(gwled, QPNP_WLED_MAX_BR_LEVEL);
	if (rc) {
	dprintf(CRITICAL,"wled set level failed\n");
	return;
	}
	}

	if (!gwled->disp_type_amoled \|\| !gwled->wled_avdd_control) {
	rc = qpnp_wled_enable(gwled, gwled->ctrl_base, enable);
	if (rc) {
	dprintf(CRITICAL, "wled %sable failed\n",
	enable ? "en" : "dis");
	return;
	}
	}

	}

	static int qpnp_wled_set_display_type(struct qpnp_wled *wled, uint16_t base_addr)
	{
	uint8_t reg = 0;
	int rc;

	/* display type */
	reg = pm8x41_wled_reg_read(QPNP_WLED_DISP_SEL_REG(base_addr));

	reg &= QPNP_WLED_DISP_SEL_MASK;
	reg \|= (wled->disp_type_amoled << QPNP_WLED_DISP_SEL_SHIFT);

	rc = qpnp_wled_sec_access(wled, base_addr);
	if (rc)
	return rc;

	pm8x41_wled_reg_write(QPNP_WLED_DISP_SEL_REG(base_addr), reg);

	return 0;
	}

	static int qpnp_wled_module_ready(struct qpnp_wled *wled, uint16_t base_addr, bool state)
	{
	uint8_t reg;

	reg = pm8x41_wled_reg_read(
	QPNP_WLED_MODULE_RDY_REG(base_addr));
	reg &= QPNP_WLED_MODULE_RDY_MASK;
	reg \|= (state << QPNP_WLED_MODULE_RDY_SHIFT);
	pm8x41_wled_reg_write(QPNP_WLED_MODULE_RDY_REG(base_addr), reg);

	return 0;
	}

	/* Configure WLED registers */
	static int qpnp_wled_config(struct qpnp_wled *wled)
	{
	int rc, i, temp;
	uint8_t reg = 0;

	/* Configure display type */
	rc = qpnp_wled_set_display_type(wled, wled->ctrl_base);
	if (rc < 0)
	return rc;

	/* Recommended WLED MDOS settings for AMOLED */
	if (wled->disp_type_amoled) {
	pm8x41_wled_reg_write(QPNP_WLED_VLOOP_COMP_RES(wled->ctrl_base),
	0x8F);
	pm8x41_wled_reg_write(QPNP_WLED_VLOOP_COMP_GM(wled->ctrl_base),
	0x81);
	pm8x41_wled_reg_write(QPNP_WLED_PSM_CTRL(wled->ctrl_base),
	0x83);

	rc = qpnp_wled_sec_access(wled, wled->ctrl_base);
	if (rc)
	return rc;
	pm8x41_wled_reg_write(QPNP_WLED_TEST4(wled->ctrl_base), 0x13);
	}

	/* Configure the FEEDBACK OUTPUT register */
	reg = pm8x41_wled_reg_read(
	QPNP_WLED_FDBK_OP_REG(wled->ctrl_base));
	reg &= QPNP_WLED_FDBK_OP_MASK;
	reg \|= wled->fdbk_op;
	pm8x41_wled_reg_write(QPNP_WLED_FDBK_OP_REG(wled->ctrl_base), reg);

	/* Configure the VREF register */
	if (wled->vref_mv < QPNP_WLED_VREF_MIN_MV)
	wled->vref_mv = QPNP_WLED_VREF_MIN_MV;
	else if (wled->vref_mv > QPNP_WLED_VREF_MAX_MV)
	wled->vref_mv = QPNP_WLED_VREF_MAX_MV;

	reg = pm8x41_wled_reg_read(
	QPNP_WLED_VREF_REG(wled->ctrl_base));
	reg &= QPNP_WLED_VREF_MASK;
	temp = wled->vref_mv - QPNP_WLED_VREF_MIN_MV;
	reg \|= (temp / QPNP_WLED_VREF_STEP_MV);
	pm8x41_wled_reg_write(QPNP_WLED_VREF_REG(wled->ctrl_base), reg);

	/* Configure the ILIM register */
	if (wled->ilim_ma < QPNP_WLED_ILIM_MIN_MA)
	wled->ilim_ma = QPNP_WLED_ILIM_MIN_MA;
	else if (wled->ilim_ma > QPNP_WLED_ILIM_MAX_MA)
	wled->ilim_ma = QPNP_WLED_ILIM_MAX_MA;

	reg = pm8x41_wled_reg_read(
	QPNP_WLED_ILIM_REG(wled->ctrl_base));
	temp = (wled->ilim_ma / QPNP_WLED_ILIM_STEP_MA);
	if (temp != (reg & ~QPNP_WLED_ILIM_MASK)) {
	reg &= QPNP_WLED_ILIM_MASK;
	reg \|= temp;
	reg \|= QPNP_WLED_ILIM_OVERWRITE;
	pm8x41_wled_reg_write(QPNP_WLED_ILIM_REG(wled->ctrl_base), reg);
	}

	/* Configure the MAX BOOST DUTY register */
	if (wled->boost_duty_ns < QPNP_WLED_BOOST_DUTY_MIN_NS)
	wled->boost_duty_ns = QPNP_WLED_BOOST_DUTY_MIN_NS;
	else if (wled->boost_duty_ns > QPNP_WLED_BOOST_DUTY_MAX_NS)
	wled->boost_duty_ns = QPNP_WLED_BOOST_DUTY_MAX_NS;

	reg = pm8x41_wled_reg_read(
	QPNP_WLED_BOOST_DUTY_REG(wled->ctrl_base));
	reg &= QPNP_WLED_BOOST_DUTY_MASK;
	reg \|= (wled->boost_duty_ns / QPNP_WLED_BOOST_DUTY_STEP_NS);
	pm8x41_wled_reg_write(QPNP_WLED_BOOST_DUTY_REG(wled->ctrl_base), reg);

	/* Configure the SWITCHING FREQ register */
	if (wled->switch_freq_khz == QPNP_WLED_SWITCH_FREQ_1600_KHZ)
	temp = QPNP_WLED_SWITCH_FREQ_1600_KHZ_CODE;
	else
	temp = QPNP_WLED_SWITCH_FREQ_800_KHZ_CODE;

	reg = pm8x41_wled_reg_read(
	QPNP_WLED_SWITCH_FREQ_REG(wled->ctrl_base));
	reg &= QPNP_WLED_SWITCH_FREQ_MASK;
	reg \|= temp;
	pm8x41_wled_reg_write(QPNP_WLED_SWITCH_FREQ_REG(wled->ctrl_base), reg);

	/* Configure the OVP register */
	if (wled->ovp_mv <= QPNP_WLED_OVP_17800_MV) {
	wled->ovp_mv = QPNP_WLED_OVP_17800_MV;
	temp = 3;
	} else if (wled->ovp_mv <= QPNP_WLED_OVP_19400_MV) {
	wled->ovp_mv = QPNP_WLED_OVP_19400_MV;
	temp = 2;
	} else if (wled->ovp_mv <= QPNP_WLED_OVP_29500_MV) {
	wled->ovp_mv = QPNP_WLED_OVP_29500_MV;
	temp = 1;
	} else {
	wled->ovp_mv = QPNP_WLED_OVP_31000_MV;
	temp = 0;
	}

	reg = pm8x41_wled_reg_read(
	QPNP_WLED_OVP_REG(wled->ctrl_base));
	reg &= QPNP_WLED_OVP_MASK;
	reg \|= temp;
	pm8x41_wled_reg_write(QPNP_WLED_OVP_REG(wled->ctrl_base), reg);

	if (wled->disp_type_amoled) {
	for (i = 0; i < NUM_SUPPORTED_AVDD_VOLTAGES; i++) {
	if (QPNP_WLED_AVDD_DEFAULT_VOLTAGE_MV == qpnp_wled_avdd_target_voltages[i])
	break;
	}
	if (i == NUM_SUPPORTED_AVDD_VOLTAGES)
	{
	dprintf(CRITICAL, "Invalid avdd target voltage specified \n");
	return ERR_NOT_VALID;
	}
	/* Update WLED_OVP register based on desired target voltage */
	reg = qpnp_wled_ovp_reg_settings[i];
	pm8x41_wled_reg_write(QPNP_WLED_OVP_REG(wled->ctrl_base), reg);
	/* Update WLED_TRIM register based on desired target voltage */
	reg = pm8x41_wled_reg_read(
	QPNP_WLED_REF_7P7_TRIM_REG(wled->ctrl_base));
	reg += qpnp_wled_avdd_trim_adjustments[i];
	if ((int8_t)reg < QPNP_WLED_AVDD_MIN_TRIM_VALUE)
	reg = QPNP_WLED_AVDD_MIN_TRIM_VALUE;
	else if((int8_t)reg > QPNP_WLED_AVDD_MAX_TRIM_VALUE)
	reg = QPNP_WLED_AVDD_MAX_TRIM_VALUE;

	rc = qpnp_wled_sec_access(wled, wled->ctrl_base);
	if (rc)
	return rc;

	temp = pm8x41_wled_reg_read(
	QPNP_WLED_REF_7P7_TRIM_REG(wled->ctrl_base));
	temp &= ~QPNP_WLED_7P7_TRIM_MASK;
	temp \|= (reg & QPNP_WLED_7P7_TRIM_MASK);
	pm8x41_wled_reg_write(QPNP_WLED_REF_7P7_TRIM_REG(wled->ctrl_base), temp);
	/* Write to spare to avoid reconfiguration in HLOS */
	reg = pm8x41_wled_reg_read(
	QPNP_WLED_CTRL_SPARE_REG(wled->ctrl_base));
	reg \|= QPNP_WLED_AVDD_SET_BIT;
	pm8x41_wled_reg_write(QPNP_WLED_CTRL_SPARE_REG(wled->ctrl_base), reg);
	}

	/* Configure the MODULATION register */
	if (wled->mod_freq_khz <= QPNP_WLED_MOD_FREQ_1200_KHZ) {
	wled->mod_freq_khz = QPNP_WLED_MOD_FREQ_1200_KHZ;
	temp = 3;
	} else if (wled->mod_freq_khz <= QPNP_WLED_MOD_FREQ_2400_KHZ) {
	wled->mod_freq_khz = QPNP_WLED_MOD_FREQ_2400_KHZ;
	temp = 2;
	} else if (wled->mod_freq_khz <= QPNP_WLED_MOD_FREQ_9600_KHZ) {
	wled->mod_freq_khz = QPNP_WLED_MOD_FREQ_9600_KHZ;
	temp = 1;
	} else {
	wled->mod_freq_khz = QPNP_WLED_MOD_FREQ_19200_KHZ;
	temp = 0;
	}
	reg = pm8x41_wled_reg_read(QPNP_WLED_MOD_REG(wled->sink_base));

	reg &= QPNP_WLED_MOD_FREQ_MASK;
	reg \|= (temp << QPNP_WLED_MOD_FREQ_SHIFT);

	reg &= QPNP_WLED_PHASE_STAG_MASK;
	reg \|= (wled->en_phase_stag << QPNP_WLED_PHASE_STAG_SHIFT);

	reg &= QPNP_WLED_DIM_RES_MASK;
	reg \|= (wled->en_9b_dim_res << QPNP_WLED_DIM_RES_SHIFT);

	if (wled->dim_mode == QPNP_WLED_DIM_HYBRID) {
	reg &= QPNP_WLED_DIM_HYB_MASK;
	reg \|= (1 << QPNP_WLED_DIM_HYB_SHIFT);
	} else {
	reg &= QPNP_WLED_DIM_HYB_MASK;
	reg \|= (0 << QPNP_WLED_DIM_HYB_SHIFT);
	reg &= QPNP_WLED_DIM_ANA_MASK;
	reg \|= wled->dim_mode;
	}

	pm8x41_wled_reg_write(QPNP_WLED_MOD_REG(wled->sink_base), reg);

	/* Configure the HYBRID THRESHOLD register */
	if (wled->hyb_thres < QPNP_WLED_HYB_THRES_MIN)
	wled->hyb_thres = QPNP_WLED_HYB_THRES_MIN;
	else if (wled->hyb_thres > QPNP_WLED_HYB_THRES_MAX)
	wled->hyb_thres = QPNP_WLED_HYB_THRES_MAX;

	reg = pm8x41_wled_reg_read(
	QPNP_WLED_HYB_THRES_REG(wled->sink_base));

	reg &= QPNP_WLED_HYB_THRES_MASK;
	temp = fls(wled->hyb_thres / QPNP_WLED_HYB_THRES_MIN) - 1;
	reg \|= temp;
	pm8x41_wled_reg_write(QPNP_WLED_HYB_THRES_REG(wled->sink_base), reg);

	for (i = 0; i < wled->num_strings; i++) {
	if (wled->strings[i] >= QPNP_WLED_MAX_STRINGS) {
	dprintf(CRITICAL,"Invalid string number\n");
	return ERR_NOT_VALID;
	}

	/* MODULATOR */
	reg = pm8x41_wled_reg_read(
	QPNP_WLED_MOD_EN_REG(wled->sink_base,
	wled->strings[i]));
	reg &= QPNP_WLED_MOD_EN_MASK;
	reg \|= (QPNP_WLED_MOD_EN << QPNP_WLED_MOD_EN_SHFT);
	pm8x41_wled_reg_write(QPNP_WLED_MOD_EN_REG(wled->sink_base,
	wled->strings[i]), reg);

	/* SYNC DELAY */
	if (wled->sync_dly_us > QPNP_WLED_SYNC_DLY_MAX_US)
	wled->sync_dly_us = QPNP_WLED_SYNC_DLY_MAX_US;

	reg = pm8x41_wled_reg_read(
	QPNP_WLED_SYNC_DLY_REG(wled->sink_base,
	wled->strings[i]));
	reg &= QPNP_WLED_SYNC_DLY_MASK;
	temp = wled->sync_dly_us / QPNP_WLED_SYNC_DLY_STEP_US;
	reg \|= temp;
	pm8x41_wled_reg_write(QPNP_WLED_SYNC_DLY_REG(wled->sink_base,
	wled->strings[i]), reg);

	/* FULL SCALE CURRENT */
	if (wled->fs_curr_ua > QPNP_WLED_FS_CURR_MAX_UA)
	wled->fs_curr_ua = QPNP_WLED_FS_CURR_MAX_UA;

	reg = pm8x41_wled_reg_read(
	QPNP_WLED_FS_CURR_REG(wled->sink_base,
	wled->strings[i]));
	reg &= QPNP_WLED_FS_CURR_MASK;
	temp = wled->fs_curr_ua / QPNP_WLED_FS_CURR_STEP_UA;
	reg \|= temp;
	pm8x41_wled_reg_write(QPNP_WLED_FS_CURR_REG(wled->sink_base,
	wled->strings[i]), reg);

	/* CABC */
	reg = pm8x41_wled_reg_read(
	QPNP_WLED_CABC_REG(wled->sink_base,
	wled->strings[i]));
	reg &= QPNP_WLED_CABC_MASK;
	reg \|= (wled->en_cabc << QPNP_WLED_CABC_SHIFT);
	pm8x41_wled_reg_write(QPNP_WLED_CABC_REG(wled->sink_base,
	wled->strings[i]), reg);

	/* Enable CURRENT SINK */
	reg = pm8x41_wled_reg_read(
	QPNP_WLED_CURR_SINK_REG(wled->sink_base));
	temp = wled->strings[i] + QPNP_WLED_CURR_SINK_SHIFT;
	reg \|= (1 << temp);
	pm8x41_wled_reg_write(QPNP_WLED_CURR_SINK_REG(wled->sink_base), reg);
	}

	/* LAB fast precharge */
	reg = pm8x41_wled_reg_read(
	QPNP_WLED_LAB_FAST_PC_REG(wled->lab_base));
	reg &= QPNP_WLED_LAB_FAST_PC_MASK;
	reg \|= (wled->lab_fast_precharge << QPNP_WLED_LAB_FAST_PC_SHIFT);
	pm8x41_wled_reg_write(QPNP_WLED_LAB_FAST_PC_REG(wled->lab_base), reg);

	/* Configure lab display type */
	rc = qpnp_wled_set_display_type(wled, wled->lab_base);
	if (rc < 0)
	return rc;

	/* make LAB module ready */
	rc = qpnp_wled_module_ready(wled, wled->lab_base, true);
	if (rc < 0)
	return rc;

	/* Disable LAB pulse skipping for AMOLED */
	if (wled->disp_type_amoled)
	pm8x41_wled_reg_write(wled->lab_base +
	QPNP_LABIBB_PS_CTL, 0x00);

	/* IBB active bias */
	if (wled->ibb_pwrup_dly_ms > QPNP_WLED_IBB_PWRUP_DLY_MAX_MS)
	wled->ibb_pwrup_dly_ms = QPNP_WLED_IBB_PWRUP_DLY_MAX_MS;

	if (wled->ibb_pwrdn_dly_ms > QPNP_WLED_IBB_PWRDN_DLY_MAX_MS)
	wled->ibb_pwrdn_dly_ms = QPNP_WLED_IBB_PWRDN_DLY_MAX_MS;

	reg = pm8x41_wled_reg_read(
	QPNP_WLED_IBB_BIAS_REG(wled->ibb_base));

	reg &= QPNP_WLED_IBB_BIAS_MASK;
	reg \|= (!wled->ibb_bias_active << QPNP_WLED_IBB_BIAS_SHIFT);

	temp = wled->ibb_pwrup_dly_ms;
	reg &= QPNP_WLED_IBB_PWRUP_DLY_MASK;
	reg \|= (temp << QPNP_WLED_IBB_PWRUP_DLY_SHIFT);
	/* Power down delay bits could already be set, clear them before
	* or'ing new values
	*/
	reg &= ~(PWRDN_DLY2_MASK);
	reg \|= wled->ibb_pwrdn_dly_ms;
	reg \|= (wled->ibb_discharge_en << 2);

	rc = qpnp_wled_sec_access(wled, wled->ibb_base);
	if (rc)
	return rc;

	pm8x41_wled_reg_write(QPNP_WLED_IBB_BIAS_REG(wled->ibb_base), reg);

	/* Configure ibb display type */
	rc = qpnp_wled_set_display_type(wled, wled->ibb_base);
	if (rc < 0)
	return rc;

	/* make IBB module ready */
	rc = qpnp_wled_module_ready(wled, wled->ibb_base, true);
	if (rc < 0)
	return rc;

	rc = qpnp_labibb_regulator_set_voltage(wled);
	if (rc < 0)
	return rc;

	return 0;
	}

	/* Setup wled default parameters */
	static int qpnp_wled_setup(struct qpnp_wled wled, struct qpnp_wled_config_data config)
	{
	int i;

	wled->sink_base = QPNP_WLED_SINK_BASE;
	wled->ctrl_base = QPNP_WLED_CTRL_BASE;
	wled->ibb_base = QPNP_WLED_IBB_BASE;
	wled->lab_base = QPNP_WLED_LAB_BASE;
	wled->fdbk_op = QPNP_WLED_FDBK_AUTO;
	wled->vref_mv = QPNP_WLED_DFLT_VREF_MV;
	wled->switch_freq_khz = QPNP_WLED_SWITCH_FREQ_800_KHZ;
	wled->ovp_mv = QPNP_WLED_OVP_29500_MV;
	wled->ilim_ma = QPNP_WLED_DFLT_ILIM_MA;
	wled->boost_duty_ns = QPNP_WLED_BOOST_DUTY_MIN_NS;
	wled->mod_freq_khz = QPNP_WLED_MOD_FREQ_19200_KHZ;
	wled->dim_mode = QPNP_WLED_DIM_HYBRID;
	wled->dim_shape = QPNP_WLED_DIM_SHAPE_LINEAR;

	if (wled->dim_mode == QPNP_WLED_DIM_HYBRID) {
	wled->hyb_thres = QPNP_WLED_DFLT_HYB_THRES;
	}

	wled->sync_dly_us = 800;
	wled->fs_curr_ua = 16000;
	wled->en_9b_dim_res = 0;
	wled->en_phase_stag = true;
	wled->en_cabc = 0;

	wled->num_strings = QPNP_WLED_MAX_STRINGS;
	for (i = 0; i < wled->num_strings; i++)
	wled->strings[i] = i;

	wled->ibb_bias_active = false;
	wled->lab_fast_precharge = false;
	wled->ibb_pwrup_dly_ms = config->pwr_up_delay;
	wled->ibb_pwrdn_dly_ms = config->pwr_down_delay;
	wled->ibb_discharge_en = config->ibb_discharge_en;
	wled->disp_type_amoled = config->display_type;
	wled->lab_min_volt = config->lab_min_volt;
	wled->lab_max_volt = config->lab_max_volt;
	wled->ibb_min_volt = config->ibb_min_volt;
	wled->ibb_max_volt = config->ibb_max_volt;
	wled->ibb_init_volt = config->ibb_init_volt;
	wled->lab_init_volt = config->lab_init_volt;
	wled->lab_ibb_swire_control = config->lab_ibb_swire_control;
	wled->wled_avdd_control = config->wled_avdd_control;

	return 0;
	}

	int qpnp_wled_init(struct qpnp_wled_config_data *config)
	{
	int rc;
	struct qpnp_wled *wled;

	wled = malloc(sizeof(struct qpnp_wled));
	if (!wled)
	return ERR_NO_MEMORY;

	memset(wled, 0, sizeof(struct qpnp_wled));

	rc = qpnp_wled_setup(wled, config);
	if (rc) {
	dprintf(CRITICAL, "Setting WLED parameters failed\n");
	return rc;
	}

	rc = qpnp_wled_config(wled);
	if (rc) {
	dprintf(CRITICAL, "wled config failed\n");
	return rc;
	}

	gwled = wled;

	return rc;
	}

	static int qpnp_labibb_regulator_set_voltage(struct qpnp_wled *wled)
	{
	int rc = -1;
	uint32_t new_uV;
	uint8_t val, mask=0;

	if (!wled->disp_type_amoled \|\| !wled->lab_ibb_swire_control) {
	if (wled->lab_min_volt < wled->lab_init_volt) {
	dprintf(CRITICAL,"qpnp_lab_regulator_set_voltage failed, min_uV %d is less than init volt %d\n",
	wled->lab_min_volt, wled->lab_init_volt);
	return rc;
	}

	val = (((wled->lab_min_volt - wled->lab_init_volt) +
	(IBB_LAB_VREG_STEP_SIZE - 1)) / IBB_LAB_VREG_STEP_SIZE);
	new_uV = val * IBB_LAB_VREG_STEP_SIZE + wled->lab_init_volt;

	if (new_uV > wled->lab_max_volt) {
	dprintf(CRITICAL,"qpnp_ibb_regulator_set_voltage unable to set voltage (%d %d)\n",
	wled->lab_min_volt, wled->lab_max_volt);
	return rc;
	}
	val \|= QPNP_LAB_OUTPUT_OVERRIDE_EN;
	mask = pm8x41_wled_reg_read(wled->lab_base +
	QPNP_LABIBB_OUTPUT_VOLTAGE);
	mask &= ~(QPNP_LAB_SET_VOLTAGE_MASK
	\| QPNP_LAB_OUTPUT_OVERRIDE_EN);
	mask \|= val & (QPNP_LAB_SET_VOLTAGE_MASK
	\| QPNP_LAB_OUTPUT_OVERRIDE_EN);

	pm8x41_wled_reg_write(wled->lab_base +
	QPNP_LABIBB_OUTPUT_VOLTAGE, mask);
	udelay(2);

	/*
	* IBB Set Voltage.
	* For AMOLED panels, the IBB voltage needs to be
	* controlled by panel.
	*/
	if (wled->ibb_min_volt < wled->ibb_init_volt) {
	dprintf(CRITICAL, "qpnp_ibb_regulator_set_voltage failed, min_uV %d is less than init volt %d\n",
	wled->ibb_min_volt, wled->ibb_init_volt);
	return rc;
	}

	val = (((wled->ibb_min_volt - wled->ibb_init_volt) +
	(IBB_LAB_VREG_STEP_SIZE - 1)) / IBB_LAB_VREG_STEP_SIZE);
	new_uV = val * IBB_LAB_VREG_STEP_SIZE + wled->ibb_init_volt;
	if (new_uV > wled->ibb_max_volt) {
	dprintf(CRITICAL, "qpnp_ibb_regulator_set_voltage unable to set voltage %d %d\n",
	wled->ibb_min_volt, wled->ibb_max_volt);
	return rc;
	}
	val \|= QPNP_LAB_OUTPUT_OVERRIDE_EN;
	mask = pm8x41_wled_reg_read(wled->ibb_base +
	QPNP_LABIBB_OUTPUT_VOLTAGE);
	udelay(2);
	mask &= ~(QPNP_IBB_SET_VOLTAGE_MASK \|
	QPNP_LAB_OUTPUT_OVERRIDE_EN);
	mask \|= (val & (QPNP_IBB_SET_VOLTAGE_MASK \|
	QPNP_LAB_OUTPUT_OVERRIDE_EN));

	pm8x41_wled_reg_write(wled->ibb_base +
	QPNP_LABIBB_OUTPUT_VOLTAGE, mask);
	} else {
	pm8x41_wled_reg_write(wled->ibb_base +
	QPNP_LABIBB_OUTPUT_VOLTAGE, 0x00);
	}

	return 0;
	}