drivers/leds/leds-cht-wcove.c - linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0
 /*
  * Driver for LEDs connected to the Intel Cherry Trail Whiskey Cove PMIC
  *
  * Copyright 2019 Yauhen Kharuzhy <jekhor@gmail.com>
  * Copyright 2023 Hans de Goede <hansg@kernel.org>
  *
  * Register info comes from the Lenovo Yoga Book Android opensource code
  * available from Lenovo. File lenovo_yb1_x90f_l_osc_201803.7z path in the 7z:
  * YB1_source_code/kernel/cht/drivers/misc/charger_gp_led.c
  */

 #include <linux/kernel.h>
 #include <linux/leds.h>
 #include <linux/mfd/intel_soc_pmic.h>
 #include <linux/module.h>
 #include <linux/mod_devicetable.h>
 #include <linux/platform_device.h>
 #include <linux/regmap.h>
 #include <linux/suspend.h>

 #define CHT_WC_LED1_CTRL		0x5e1f
 #define CHT_WC_LED1_FSM			0x5e20
 #define CHT_WC_LED1_PWM			0x5e21

 #define CHT_WC_LED2_CTRL		0x4fdf
 #define CHT_WC_LED2_FSM			0x4fe0
 #define CHT_WC_LED2_PWM			0x4fe1

 #define CHT_WC_LED1_SWCTL		BIT(0)		/* HW or SW control of charging led */
 #define CHT_WC_LED1_ON			BIT(1)

 #define CHT_WC_LED2_ON			BIT(0)
 #define CHT_WC_LED_I_MA2_5		(2 << 2)	/* LED current limit */
 #define CHT_WC_LED_I_MASK		GENMASK(3, 2)	/* LED current limit mask */

 #define CHT_WC_LED_F_1_4_HZ		(0 << 4)
 #define CHT_WC_LED_F_1_2_HZ		(1 << 4)
 #define CHT_WC_LED_F_1_HZ		(2 << 4)
 #define CHT_WC_LED_F_2_HZ		(3 << 4)
 #define CHT_WC_LED_F_MASK		GENMASK(5, 4)

 #define CHT_WC_LED_EFF_OFF		(0 << 1)
 #define CHT_WC_LED_EFF_ON		(1 << 1)
 #define CHT_WC_LED_EFF_BLINKING		(2 << 1)
 #define CHT_WC_LED_EFF_BREATHING	(3 << 1)
 #define CHT_WC_LED_EFF_MASK		GENMASK(2, 1)

 #define CHT_WC_LED_COUNT		2

 struct cht_wc_led_regs {
 	/* Register addresses */
 	u16 ctrl;
 	u16 fsm;
 	u16 pwm;
 	/* Mask + values for turning the LED on/off */
 	u8 on_off_mask;
 	u8 on_val;
 	u8 off_val;
 };

 struct cht_wc_led_saved_regs {
 	unsigned int ctrl;
 	unsigned int fsm;
 	unsigned int pwm;
 };

 struct cht_wc_led {
 	struct led_classdev cdev;
 	const struct cht_wc_led_regs *regs;
 	struct regmap *regmap;
 	struct mutex mutex;
 	struct cht_wc_led_saved_regs saved_regs;
 };

 struct cht_wc_leds {
 	struct cht_wc_led leds[CHT_WC_LED_COUNT];
 	/* Saved LED1 initial register values */
 	struct cht_wc_led_saved_regs led1_initial_regs;
 };

 static const struct cht_wc_led_regs cht_wc_led_regs[CHT_WC_LED_COUNT] = {
 	{
 		.ctrl		= CHT_WC_LED1_CTRL,
 		.fsm		= CHT_WC_LED1_FSM,
 		.pwm		= CHT_WC_LED1_PWM,
 		.on_off_mask	= CHT_WC_LED1_SWCTL | CHT_WC_LED1_ON,
 		.on_val		= CHT_WC_LED1_SWCTL | CHT_WC_LED1_ON,
 		.off_val	= CHT_WC_LED1_SWCTL,
 	},
 	{
 		.ctrl		= CHT_WC_LED2_CTRL,
 		.fsm		= CHT_WC_LED2_FSM,
 		.pwm		= CHT_WC_LED2_PWM,
 		.on_off_mask	= CHT_WC_LED2_ON,
 		.on_val		= CHT_WC_LED2_ON,
 		.off_val	= 0,
 	},
 };

 static const char * const cht_wc_leds_names[CHT_WC_LED_COUNT] = {
 	"platform::" LED_FUNCTION_CHARGING,
 	"platform::" LED_FUNCTION_INDICATOR,
 };

 static int cht_wc_leds_brightness_set(struct led_classdev *cdev,
 				      enum led_brightness value)
 {
 	struct cht_wc_led *led = container_of(cdev, struct cht_wc_led, cdev);
 	int ret;

 	mutex_lock(&led->mutex);

 	if (!value) {
 		ret = regmap_update_bits(led->regmap, led->regs->ctrl,
 					 led->regs->on_off_mask, led->regs->off_val);
 		if (ret < 0) {
 			dev_err(cdev->dev, "Failed to turn off: %d\n", ret);
 			goto out;
 		}

 		/* Disable HW blinking */
 		ret = regmap_update_bits(led->regmap, led->regs->fsm,
 					 CHT_WC_LED_EFF_MASK, CHT_WC_LED_EFF_ON);
 		if (ret < 0)
 			dev_err(cdev->dev, "Failed to update LED FSM reg: %d\n", ret);
 	} else {
 		ret = regmap_write(led->regmap, led->regs->pwm, value);
 		if (ret < 0) {
 			dev_err(cdev->dev, "Failed to set brightness: %d\n", ret);
 			goto out;
 		}

 		ret = regmap_update_bits(led->regmap, led->regs->ctrl,
 					 led->regs->on_off_mask, led->regs->on_val);
 		if (ret < 0)
 			dev_err(cdev->dev, "Failed to turn on: %d\n", ret);
 	}
 out:
 	mutex_unlock(&led->mutex);
 	return ret;
 }

 static enum led_brightness cht_wc_leds_brightness_get(struct led_classdev *cdev)
 {
 	struct cht_wc_led *led = container_of(cdev, struct cht_wc_led, cdev);
 	unsigned int val;
 	int ret;

 	mutex_lock(&led->mutex);

 	ret = regmap_read(led->regmap, led->regs->ctrl, &val);
 	if (ret < 0) {
 		dev_err(cdev->dev, "Failed to read LED CTRL reg: %d\n", ret);
 		ret = 0;
 		goto done;
 	}

 	val &= led->regs->on_off_mask;
 	if (val != led->regs->on_val) {
 		ret = 0;
 		goto done;
 	}

 	ret = regmap_read(led->regmap, led->regs->pwm, &val);
 	if (ret < 0) {
 		dev_err(cdev->dev, "Failed to read LED PWM reg: %d\n", ret);
 		ret = 0;
 		goto done;
 	}

 	ret = val;
 done:
 	mutex_unlock(&led->mutex);

 	return ret;
 }

 /* Return blinking period for given CTRL reg value */
 static unsigned long cht_wc_leds_get_period(int ctrl)
 {
 	ctrl &= CHT_WC_LED_F_MASK;

 	switch (ctrl) {
 	case CHT_WC_LED_F_1_4_HZ:
 		return 1000 * 4;
 	case CHT_WC_LED_F_1_2_HZ:
 		return 1000 * 2;
 	case CHT_WC_LED_F_1_HZ:
 		return 1000;
 	case CHT_WC_LED_F_2_HZ:
 		return 1000 / 2;
 	}

 	return 0;
 }

 /*
  * Find suitable hardware blink mode for given period.
  * period < 750 ms - select 2 HZ
  * 750 ms <= period < 1500 ms - select 1 HZ
  * 1500 ms <= period < 3000 ms - select 1/2 HZ
  * 3000 ms <= period < 5000 ms - select 1/4 HZ
  * 5000 ms <= period - return -1
  */
 static int cht_wc_leds_find_freq(unsigned long period)
 {
 	if (period < 750)
 		return CHT_WC_LED_F_2_HZ;
 	else if (period < 1500)
 		return CHT_WC_LED_F_1_HZ;
 	else if (period < 3000)
 		return CHT_WC_LED_F_1_2_HZ;
 	else if (period < 5000)
 		return CHT_WC_LED_F_1_4_HZ;
 	else
 		return -1;
 }

 static int cht_wc_leds_set_effect(struct led_classdev *cdev,
 				  unsigned long *delay_on,
 				  unsigned long *delay_off,
 				  u8 effect)
 {
 	struct cht_wc_led *led = container_of(cdev, struct cht_wc_led, cdev);
 	int ctrl, ret;

 	mutex_lock(&led->mutex);

 	/* Blink with 1 Hz as default if nothing specified */
 	if (!*delay_on && !*delay_off)
 		*delay_on = *delay_off = 500;

 	ctrl = cht_wc_leds_find_freq(*delay_on + *delay_off);
 	if (ctrl < 0) {
 		/* Disable HW blinking */
 		ret = regmap_update_bits(led->regmap, led->regs->fsm,
 					 CHT_WC_LED_EFF_MASK, CHT_WC_LED_EFF_ON);
 		if (ret < 0)
 			dev_err(cdev->dev, "Failed to update LED FSM reg: %d\n", ret);

 		/* Fallback to software timer */
 		*delay_on = *delay_off = 0;
 		ret = -EINVAL;
 		goto done;
 	}

 	ret = regmap_update_bits(led->regmap, led->regs->fsm,
 				 CHT_WC_LED_EFF_MASK, effect);
 	if (ret < 0)
 		dev_err(cdev->dev, "Failed to update LED FSM reg: %d\n", ret);

 	/* Set the frequency and make sure the LED is on */
 	ret = regmap_update_bits(led->regmap, led->regs->ctrl,
 				 CHT_WC_LED_F_MASK | led->regs->on_off_mask,
 				 ctrl | led->regs->on_val);
 	if (ret < 0)
 		dev_err(cdev->dev, "Failed to update LED CTRL reg: %d\n", ret);

 	*delay_off = *delay_on = cht_wc_leds_get_period(ctrl) / 2;

 done:
 	mutex_unlock(&led->mutex);

 	return ret;
 }

 static int cht_wc_leds_blink_set(struct led_classdev *cdev,
 				 unsigned long *delay_on,
 				 unsigned long *delay_off)
 {
 	u8 effect = CHT_WC_LED_EFF_BLINKING;

 	/*
 	 * The desired default behavior of LED1 / the charge LED is breathing
 	 * while charging and on/solid when full. Since triggers cannot select
 	 * breathing, blink_set() gets called when charging. Use slow breathing
 	 * when the default "charging-blink-full-solid" trigger is used to
 	 * achieve the desired default behavior.
 	 */
 	if (cdev->flags & LED_INIT_DEFAULT_TRIGGER) {
 		*delay_on = *delay_off = 1000;
 		effect = CHT_WC_LED_EFF_BREATHING;
 	}

 	return cht_wc_leds_set_effect(cdev, delay_on, delay_off, effect);
 }

 static int cht_wc_leds_pattern_set(struct led_classdev *cdev,
 				   struct led_pattern *pattern,
 				   u32 len, int repeat)
 {
 	unsigned long delay_off, delay_on;

 	if (repeat > 0 || len != 2 ||
 	    pattern[0].brightness != 0 || pattern[1].brightness != 1 ||
 	    pattern[0].delta_t != pattern[1].delta_t ||
 	    (pattern[0].delta_t != 250 && pattern[0].delta_t != 500 &&
 	     pattern[0].delta_t != 1000 && pattern[0].delta_t != 2000))
 		return -EINVAL;

 	delay_off = pattern[0].delta_t;
 	delay_on  = pattern[1].delta_t;

 	return cht_wc_leds_set_effect(cdev, &delay_on, &delay_off, CHT_WC_LED_EFF_BREATHING);
 }

 static int cht_wc_leds_pattern_clear(struct led_classdev *cdev)
 {
 	return cht_wc_leds_brightness_set(cdev, 0);
 }

 static int cht_wc_led_save_regs(struct cht_wc_led *led,
 				struct cht_wc_led_saved_regs *saved_regs)
 {
 	int ret;

 	ret = regmap_read(led->regmap, led->regs->ctrl, &saved_regs->ctrl);
 	if (ret < 0)
 		return ret;

 	ret = regmap_read(led->regmap, led->regs->fsm, &saved_regs->fsm);
 	if (ret < 0)
 		return ret;

 	return regmap_read(led->regmap, led->regs->pwm, &saved_regs->pwm);
 }

 static void cht_wc_led_restore_regs(struct cht_wc_led *led,
 				    const struct cht_wc_led_saved_regs *saved_regs)
 {
 	regmap_write(led->regmap, led->regs->ctrl, saved_regs->ctrl);
 	regmap_write(led->regmap, led->regs->fsm, saved_regs->fsm);
 	regmap_write(led->regmap, led->regs->pwm, saved_regs->pwm);
 }

 static int cht_wc_leds_probe(struct platform_device *pdev)
 {
 	struct intel_soc_pmic *pmic = dev_get_drvdata(pdev->dev.parent);
 	struct cht_wc_leds *leds;
 	int ret;
 	int i;

 	/*
 	 * On the Lenovo Yoga Tab 3 the LED1 driver output is actually
 	 * connected to a haptic feedback motor rather then a LED.
 	 * So do not register a LED classdev there (LED2 is unused).
 	 */
 	if (pmic->cht_wc_model == INTEL_CHT_WC_LENOVO_YT3_X90)
 		return -ENODEV;

 	leds = devm_kzalloc(&pdev->dev, sizeof(*leds), GFP_KERNEL);
 	if (!leds)
 		return -ENOMEM;

 	/*
 	 * LED1 might be in hw-controlled mode when this driver gets loaded; and
 	 * since the PMIC is always powered by the battery any changes made are
 	 * permanent. Save LED1 regs to restore them on remove() or shutdown().
 	 */
 	leds->leds[0].regs = &cht_wc_led_regs[0];
 	leds->leds[0].regmap = pmic->regmap;
 	ret = cht_wc_led_save_regs(&leds->leds[0], &leds->led1_initial_regs);
 	if (ret < 0)
 		return ret;

 	/* Set LED1 default trigger based on machine model */
 	switch (pmic->cht_wc_model) {
 	case INTEL_CHT_WC_GPD_WIN_POCKET:
 		leds->leds[0].cdev.default_trigger = "max170xx_battery-charging-blink-full-solid";
 		break;
 	case INTEL_CHT_WC_XIAOMI_MIPAD2:
 		leds->leds[0].cdev.default_trigger = "bq27520-0-charging-blink-full-solid";
 		break;
 	case INTEL_CHT_WC_LENOVO_YOGABOOK1:
 		leds->leds[0].cdev.default_trigger = "bq27542-0-charging-blink-full-solid";
 		break;
 	default:
 		dev_warn(&pdev->dev, "Unknown model, no default charging trigger\n");
 		break;
 	}

 	for (i = 0; i < CHT_WC_LED_COUNT; i++) {
 		struct cht_wc_led *led = &leds->leds[i];

 		led->regs = &cht_wc_led_regs[i];
 		led->regmap = pmic->regmap;
 		mutex_init(&led->mutex);
 		led->cdev.name = cht_wc_leds_names[i];
 		led->cdev.brightness_set_blocking = cht_wc_leds_brightness_set;
 		led->cdev.brightness_get = cht_wc_leds_brightness_get;
 		led->cdev.blink_set = cht_wc_leds_blink_set;
 		led->cdev.pattern_set = cht_wc_leds_pattern_set;
 		led->cdev.pattern_clear = cht_wc_leds_pattern_clear;
 		led->cdev.max_brightness = 255;

 		ret = led_classdev_register(&pdev->dev, &led->cdev);
 		if (ret < 0)
 			return ret;
 	}

 	platform_set_drvdata(pdev, leds);
 	return 0;
 }

 static void cht_wc_leds_remove(struct platform_device *pdev)
 {
 	struct cht_wc_leds *leds = platform_get_drvdata(pdev);
 	int i;

 	for (i = 0; i < CHT_WC_LED_COUNT; i++)
 		led_classdev_unregister(&leds->leds[i].cdev);

 	/* Restore LED1 regs if hw-control was active else leave LED1 off */
 	if (!(leds->led1_initial_regs.ctrl & CHT_WC_LED1_SWCTL))
 		cht_wc_led_restore_regs(&leds->leds[0], &leds->led1_initial_regs);
 }

 static void cht_wc_leds_disable(struct platform_device *pdev)
 {
 	struct cht_wc_leds *leds = platform_get_drvdata(pdev);
 	int i;

 	for (i = 0; i < CHT_WC_LED_COUNT; i++)
 		cht_wc_leds_brightness_set(&leds->leds[i].cdev, 0);

 	/* Restore LED1 regs if hw-control was active else leave LED1 off */
 	if (!(leds->led1_initial_regs.ctrl & CHT_WC_LED1_SWCTL))
 		cht_wc_led_restore_regs(&leds->leds[0], &leds->led1_initial_regs);
 }

 /* On suspend save current settings and turn LEDs off */
 static int cht_wc_leds_suspend(struct device *dev)
 {
 	struct cht_wc_leds *leds = dev_get_drvdata(dev);
 	int i, ret;

 	for (i = 0; i < CHT_WC_LED_COUNT; i++) {
 		ret = cht_wc_led_save_regs(&leds->leds[i], &leds->leds[i].saved_regs);
 		if (ret < 0)
 			return ret;
 	}

 	cht_wc_leds_disable(to_platform_device(dev));
 	return 0;
 }

 /* On resume restore the saved settings */
 static int cht_wc_leds_resume(struct device *dev)
 {
 	struct cht_wc_leds *leds = dev_get_drvdata(dev);
 	int i;

 	for (i = 0; i < CHT_WC_LED_COUNT; i++)
 		cht_wc_led_restore_regs(&leds->leds[i], &leds->leds[i].saved_regs);

 	return 0;
 }

 static DEFINE_SIMPLE_DEV_PM_OPS(cht_wc_leds_pm, cht_wc_leds_suspend, cht_wc_leds_resume);

 static struct platform_driver cht_wc_leds_driver = {
 	.probe = cht_wc_leds_probe,
 	.remove_new = cht_wc_leds_remove,
 	.shutdown = cht_wc_leds_disable,
 	.driver = {
 		.name = "cht_wcove_leds",
 		.pm = pm_sleep_ptr(&cht_wc_leds_pm),
 	},
 };
 module_platform_driver(cht_wc_leds_driver);

 MODULE_ALIAS("platform:cht_wcove_leds");
 MODULE_DESCRIPTION("Intel Cherry Trail Whiskey Cove PMIC LEDs driver");
 MODULE_AUTHOR("Yauhen Kharuzhy <jekhor@gmail.com>");
 MODULE_LICENSE("GPL");
	// SPDX-License-Identifier: GPL-2.0
	/*
	* Driver for LEDs connected to the Intel Cherry Trail Whiskey Cove PMIC
	*
	* Copyright 2019 Yauhen Kharuzhy <jekhor@gmail.com>
	* Copyright 2023 Hans de Goede <hansg@kernel.org>
	*
	* Register info comes from the Lenovo Yoga Book Android opensource code
	* available from Lenovo. File lenovo_yb1_x90f_l_osc_201803.7z path in the 7z:
	* YB1_source_code/kernel/cht/drivers/misc/charger_gp_led.c
	*/

	#include <linux/kernel.h>
	#include <linux/leds.h>
	#include <linux/mfd/intel_soc_pmic.h>
	#include <linux/module.h>
	#include <linux/mod_devicetable.h>
	#include <linux/platform_device.h>
	#include <linux/regmap.h>
	#include <linux/suspend.h>

	#define CHT_WC_LED1_CTRL 0x5e1f
	#define CHT_WC_LED1_FSM 0x5e20
	#define CHT_WC_LED1_PWM 0x5e21

	#define CHT_WC_LED2_CTRL 0x4fdf
	#define CHT_WC_LED2_FSM 0x4fe0
	#define CHT_WC_LED2_PWM 0x4fe1

	#define CHT_WC_LED1_SWCTL BIT(0) /* HW or SW control of charging led */
	#define CHT_WC_LED1_ON BIT(1)

	#define CHT_WC_LED2_ON BIT(0)
	#define CHT_WC_LED_I_MA2_5 (2 << 2) /* LED current limit */
	#define CHT_WC_LED_I_MASK GENMASK(3, 2) /* LED current limit mask */

	#define CHT_WC_LED_F_1_4_HZ (0 << 4)
	#define CHT_WC_LED_F_1_2_HZ (1 << 4)
	#define CHT_WC_LED_F_1_HZ (2 << 4)
	#define CHT_WC_LED_F_2_HZ (3 << 4)
	#define CHT_WC_LED_F_MASK GENMASK(5, 4)

	#define CHT_WC_LED_EFF_OFF (0 << 1)
	#define CHT_WC_LED_EFF_ON (1 << 1)
	#define CHT_WC_LED_EFF_BLINKING (2 << 1)
	#define CHT_WC_LED_EFF_BREATHING (3 << 1)
	#define CHT_WC_LED_EFF_MASK GENMASK(2, 1)

	#define CHT_WC_LED_COUNT 2

	struct cht_wc_led_regs {
	/* Register addresses */
	u16 ctrl;
	u16 fsm;
	u16 pwm;
	/* Mask + values for turning the LED on/off */
	u8 on_off_mask;
	u8 on_val;
	u8 off_val;
	};

	struct cht_wc_led_saved_regs {
	unsigned int ctrl;
	unsigned int fsm;
	unsigned int pwm;
	};

	struct cht_wc_led {
	struct led_classdev cdev;
	const struct cht_wc_led_regs *regs;
	struct regmap *regmap;
	struct mutex mutex;
	struct cht_wc_led_saved_regs saved_regs;
	};

	struct cht_wc_leds {
	struct cht_wc_led leds[CHT_WC_LED_COUNT];
	/* Saved LED1 initial register values */
	struct cht_wc_led_saved_regs led1_initial_regs;
	};

	static const struct cht_wc_led_regs cht_wc_led_regs[CHT_WC_LED_COUNT] = {
	{
	.ctrl = CHT_WC_LED1_CTRL,
	.fsm = CHT_WC_LED1_FSM,
	.pwm = CHT_WC_LED1_PWM,
	.on_off_mask = CHT_WC_LED1_SWCTL \| CHT_WC_LED1_ON,
	.on_val = CHT_WC_LED1_SWCTL \| CHT_WC_LED1_ON,
	.off_val = CHT_WC_LED1_SWCTL,
	},
	{
	.ctrl = CHT_WC_LED2_CTRL,
	.fsm = CHT_WC_LED2_FSM,
	.pwm = CHT_WC_LED2_PWM,
	.on_off_mask = CHT_WC_LED2_ON,
	.on_val = CHT_WC_LED2_ON,
	.off_val = 0,
	},
	};

	static const char * const cht_wc_leds_names[CHT_WC_LED_COUNT] = {
	"platform::" LED_FUNCTION_CHARGING,
	"platform::" LED_FUNCTION_INDICATOR,
	};

	static int cht_wc_leds_brightness_set(struct led_classdev *cdev,
	enum led_brightness value)
	{
	struct cht_wc_led *led = container_of(cdev, struct cht_wc_led, cdev);
	int ret;

	mutex_lock(&led->mutex);

	if (!value) {
	ret = regmap_update_bits(led->regmap, led->regs->ctrl,
	led->regs->on_off_mask, led->regs->off_val);
	if (ret < 0) {
	dev_err(cdev->dev, "Failed to turn off: %d\n", ret);
	goto out;
	}

	/* Disable HW blinking */
	ret = regmap_update_bits(led->regmap, led->regs->fsm,
	CHT_WC_LED_EFF_MASK, CHT_WC_LED_EFF_ON);
	if (ret < 0)
	dev_err(cdev->dev, "Failed to update LED FSM reg: %d\n", ret);
	} else {
	ret = regmap_write(led->regmap, led->regs->pwm, value);
	if (ret < 0) {
	dev_err(cdev->dev, "Failed to set brightness: %d\n", ret);
	goto out;
	}

	ret = regmap_update_bits(led->regmap, led->regs->ctrl,
	led->regs->on_off_mask, led->regs->on_val);
	if (ret < 0)
	dev_err(cdev->dev, "Failed to turn on: %d\n", ret);
	}
	out:
	mutex_unlock(&led->mutex);
	return ret;
	}

	static enum led_brightness cht_wc_leds_brightness_get(struct led_classdev *cdev)
	{
	struct cht_wc_led *led = container_of(cdev, struct cht_wc_led, cdev);
	unsigned int val;
	int ret;

	mutex_lock(&led->mutex);

	ret = regmap_read(led->regmap, led->regs->ctrl, &val);
	if (ret < 0) {
	dev_err(cdev->dev, "Failed to read LED CTRL reg: %d\n", ret);
	ret = 0;
	goto done;
	}

	val &= led->regs->on_off_mask;
	if (val != led->regs->on_val) {
	ret = 0;
	goto done;
	}

	ret = regmap_read(led->regmap, led->regs->pwm, &val);
	if (ret < 0) {
	dev_err(cdev->dev, "Failed to read LED PWM reg: %d\n", ret);
	ret = 0;
	goto done;
	}

	ret = val;
	done:
	mutex_unlock(&led->mutex);

	return ret;
	}

	/* Return blinking period for given CTRL reg value */
	static unsigned long cht_wc_leds_get_period(int ctrl)
	{
	ctrl &= CHT_WC_LED_F_MASK;

	switch (ctrl) {
	case CHT_WC_LED_F_1_4_HZ:
	return 1000 * 4;
	case CHT_WC_LED_F_1_2_HZ:
	return 1000 * 2;
	case CHT_WC_LED_F_1_HZ:
	return 1000;
	case CHT_WC_LED_F_2_HZ:
	return 1000 / 2;
	}

	return 0;
	}

	/*
	* Find suitable hardware blink mode for given period.
	* period < 750 ms - select 2 HZ
	* 750 ms <= period < 1500 ms - select 1 HZ
	* 1500 ms <= period < 3000 ms - select 1/2 HZ
	* 3000 ms <= period < 5000 ms - select 1/4 HZ
	* 5000 ms <= period - return -1
	*/
	static int cht_wc_leds_find_freq(unsigned long period)
	{
	if (period < 750)
	return CHT_WC_LED_F_2_HZ;
	else if (period < 1500)
	return CHT_WC_LED_F_1_HZ;
	else if (period < 3000)
	return CHT_WC_LED_F_1_2_HZ;
	else if (period < 5000)
	return CHT_WC_LED_F_1_4_HZ;
	else
	return -1;
	}

	static int cht_wc_leds_set_effect(struct led_classdev *cdev,
	unsigned long *delay_on,
	unsigned long *delay_off,
	u8 effect)
	{
	struct cht_wc_led *led = container_of(cdev, struct cht_wc_led, cdev);
	int ctrl, ret;

	mutex_lock(&led->mutex);

	/* Blink with 1 Hz as default if nothing specified */
	if (!delay_on && !delay_off)
	delay_on = delay_off = 500;

	ctrl = cht_wc_leds_find_freq(delay_on + delay_off);
	if (ctrl < 0) {
	/* Disable HW blinking */
	ret = regmap_update_bits(led->regmap, led->regs->fsm,
	CHT_WC_LED_EFF_MASK, CHT_WC_LED_EFF_ON);
	if (ret < 0)
	dev_err(cdev->dev, "Failed to update LED FSM reg: %d\n", ret);

	/* Fallback to software timer */
	delay_on = delay_off = 0;
	ret = -EINVAL;
	goto done;
	}

	ret = regmap_update_bits(led->regmap, led->regs->fsm,
	CHT_WC_LED_EFF_MASK, effect);
	if (ret < 0)
	dev_err(cdev->dev, "Failed to update LED FSM reg: %d\n", ret);

	/* Set the frequency and make sure the LED is on */
	ret = regmap_update_bits(led->regmap, led->regs->ctrl,
	CHT_WC_LED_F_MASK \| led->regs->on_off_mask,
	ctrl \| led->regs->on_val);
	if (ret < 0)
	dev_err(cdev->dev, "Failed to update LED CTRL reg: %d\n", ret);

	delay_off = delay_on = cht_wc_leds_get_period(ctrl) / 2;

	done:
	mutex_unlock(&led->mutex);

	return ret;
	}

	static int cht_wc_leds_blink_set(struct led_classdev *cdev,
	unsigned long *delay_on,
	unsigned long *delay_off)
	{
	u8 effect = CHT_WC_LED_EFF_BLINKING;

	/*
	* The desired default behavior of LED1 / the charge LED is breathing
	* while charging and on/solid when full. Since triggers cannot select
	* breathing, blink_set() gets called when charging. Use slow breathing
	* when the default "charging-blink-full-solid" trigger is used to
	* achieve the desired default behavior.
	*/
	if (cdev->flags & LED_INIT_DEFAULT_TRIGGER) {
	delay_on = delay_off = 1000;
	effect = CHT_WC_LED_EFF_BREATHING;
	}

	return cht_wc_leds_set_effect(cdev, delay_on, delay_off, effect);
	}

	static int cht_wc_leds_pattern_set(struct led_classdev *cdev,
	struct led_pattern *pattern,
	u32 len, int repeat)
	{
	unsigned long delay_off, delay_on;

	if (repeat > 0 \|\| len != 2 \|\|
	pattern[0].brightness != 0 \|\| pattern[1].brightness != 1 \|\|
	pattern[0].delta_t != pattern[1].delta_t \|\|
	(pattern[0].delta_t != 250 && pattern[0].delta_t != 500 &&
	pattern[0].delta_t != 1000 && pattern[0].delta_t != 2000))
	return -EINVAL;

	delay_off = pattern[0].delta_t;
	delay_on = pattern[1].delta_t;

	return cht_wc_leds_set_effect(cdev, &delay_on, &delay_off, CHT_WC_LED_EFF_BREATHING);
	}

	static int cht_wc_leds_pattern_clear(struct led_classdev *cdev)
	{
	return cht_wc_leds_brightness_set(cdev, 0);
	}

	static int cht_wc_led_save_regs(struct cht_wc_led *led,
	struct cht_wc_led_saved_regs *saved_regs)
	{
	int ret;

	ret = regmap_read(led->regmap, led->regs->ctrl, &saved_regs->ctrl);
	if (ret < 0)
	return ret;

	ret = regmap_read(led->regmap, led->regs->fsm, &saved_regs->fsm);
	if (ret < 0)
	return ret;

	return regmap_read(led->regmap, led->regs->pwm, &saved_regs->pwm);
	}

	static void cht_wc_led_restore_regs(struct cht_wc_led *led,
	const struct cht_wc_led_saved_regs *saved_regs)
	{
	regmap_write(led->regmap, led->regs->ctrl, saved_regs->ctrl);
	regmap_write(led->regmap, led->regs->fsm, saved_regs->fsm);
	regmap_write(led->regmap, led->regs->pwm, saved_regs->pwm);
	}

	static int cht_wc_leds_probe(struct platform_device *pdev)
	{
	struct intel_soc_pmic *pmic = dev_get_drvdata(pdev->dev.parent);
	struct cht_wc_leds *leds;
	int ret;
	int i;

	/*
	* On the Lenovo Yoga Tab 3 the LED1 driver output is actually
	* connected to a haptic feedback motor rather then a LED.
	* So do not register a LED classdev there (LED2 is unused).
	*/
	if (pmic->cht_wc_model == INTEL_CHT_WC_LENOVO_YT3_X90)
	return -ENODEV;

	leds = devm_kzalloc(&pdev->dev, sizeof(*leds), GFP_KERNEL);
	if (!leds)
	return -ENOMEM;

	/*
	* LED1 might be in hw-controlled mode when this driver gets loaded; and
	* since the PMIC is always powered by the battery any changes made are
	* permanent. Save LED1 regs to restore them on remove() or shutdown().
	*/
	leds->leds[0].regs = &cht_wc_led_regs[0];
	leds->leds[0].regmap = pmic->regmap;
	ret = cht_wc_led_save_regs(&leds->leds[0], &leds->led1_initial_regs);
	if (ret < 0)
	return ret;

	/* Set LED1 default trigger based on machine model */
	switch (pmic->cht_wc_model) {
	case INTEL_CHT_WC_GPD_WIN_POCKET:
	leds->leds[0].cdev.default_trigger = "max170xx_battery-charging-blink-full-solid";
	break;
	case INTEL_CHT_WC_XIAOMI_MIPAD2:
	leds->leds[0].cdev.default_trigger = "bq27520-0-charging-blink-full-solid";
	break;
	case INTEL_CHT_WC_LENOVO_YOGABOOK1:
	leds->leds[0].cdev.default_trigger = "bq27542-0-charging-blink-full-solid";
	break;
	default:
	dev_warn(&pdev->dev, "Unknown model, no default charging trigger\n");
	break;
	}

	for (i = 0; i < CHT_WC_LED_COUNT; i++) {
	struct cht_wc_led *led = &leds->leds[i];

	led->regs = &cht_wc_led_regs[i];
	led->regmap = pmic->regmap;
	mutex_init(&led->mutex);
	led->cdev.name = cht_wc_leds_names[i];
	led->cdev.brightness_set_blocking = cht_wc_leds_brightness_set;
	led->cdev.brightness_get = cht_wc_leds_brightness_get;
	led->cdev.blink_set = cht_wc_leds_blink_set;
	led->cdev.pattern_set = cht_wc_leds_pattern_set;
	led->cdev.pattern_clear = cht_wc_leds_pattern_clear;
	led->cdev.max_brightness = 255;

	ret = led_classdev_register(&pdev->dev, &led->cdev);
	if (ret < 0)
	return ret;
	}

	platform_set_drvdata(pdev, leds);
	return 0;
	}

	static void cht_wc_leds_remove(struct platform_device *pdev)
	{
	struct cht_wc_leds *leds = platform_get_drvdata(pdev);
	int i;

	for (i = 0; i < CHT_WC_LED_COUNT; i++)
	led_classdev_unregister(&leds->leds[i].cdev);

	/* Restore LED1 regs if hw-control was active else leave LED1 off */
	if (!(leds->led1_initial_regs.ctrl & CHT_WC_LED1_SWCTL))
	cht_wc_led_restore_regs(&leds->leds[0], &leds->led1_initial_regs);
	}

	static void cht_wc_leds_disable(struct platform_device *pdev)
	{
	struct cht_wc_leds *leds = platform_get_drvdata(pdev);
	int i;

	for (i = 0; i < CHT_WC_LED_COUNT; i++)
	cht_wc_leds_brightness_set(&leds->leds[i].cdev, 0);

	/* Restore LED1 regs if hw-control was active else leave LED1 off */
	if (!(leds->led1_initial_regs.ctrl & CHT_WC_LED1_SWCTL))
	cht_wc_led_restore_regs(&leds->leds[0], &leds->led1_initial_regs);
	}

	/* On suspend save current settings and turn LEDs off */
	static int cht_wc_leds_suspend(struct device *dev)
	{
	struct cht_wc_leds *leds = dev_get_drvdata(dev);
	int i, ret;

	for (i = 0; i < CHT_WC_LED_COUNT; i++) {
	ret = cht_wc_led_save_regs(&leds->leds[i], &leds->leds[i].saved_regs);
	if (ret < 0)
	return ret;
	}

	cht_wc_leds_disable(to_platform_device(dev));
	return 0;
	}

	/* On resume restore the saved settings */
	static int cht_wc_leds_resume(struct device *dev)
	{
	struct cht_wc_leds *leds = dev_get_drvdata(dev);
	int i;

	for (i = 0; i < CHT_WC_LED_COUNT; i++)
	cht_wc_led_restore_regs(&leds->leds[i], &leds->leds[i].saved_regs);

	return 0;
	}

	static DEFINE_SIMPLE_DEV_PM_OPS(cht_wc_leds_pm, cht_wc_leds_suspend, cht_wc_leds_resume);

	static struct platform_driver cht_wc_leds_driver = {
	.probe = cht_wc_leds_probe,
	.remove_new = cht_wc_leds_remove,
	.shutdown = cht_wc_leds_disable,
	.driver = {
	.name = "cht_wcove_leds",
	.pm = pm_sleep_ptr(&cht_wc_leds_pm),
	},
	};
	module_platform_driver(cht_wc_leds_driver);

	MODULE_ALIAS("platform:cht_wcove_leds");
	MODULE_DESCRIPTION("Intel Cherry Trail Whiskey Cove PMIC LEDs driver");
	MODULE_AUTHOR("Yauhen Kharuzhy <jekhor@gmail.com>");
	MODULE_LICENSE("GPL");