[mirror_ubuntu-jammy-kernel.git] / drivers / leds / leds-mt6323.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * LED driver for Mediatek MT6323 PMIC
 *
 * Copyright (C) 2017 Sean Wang <sean.wang@mediatek.com>
 */
#include <linux/kernel.h>
#include <linux/leds.h>
#include <linux/mfd/mt6323/registers.h>
#include <linux/mfd/mt6397/core.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>

/*
 * Register field for MT6323_TOP_CKPDN0 to enable
 * 32K clock common for LED device.
 */
#define MT6323_RG_DRV_32K_CK_PDN	BIT(11)
#define MT6323_RG_DRV_32K_CK_PDN_MASK	BIT(11)

/*
 * Register field for MT6323_TOP_CKPDN2 to enable
 * individual clock for LED device.
 */
#define MT6323_RG_ISINK_CK_PDN(i)	BIT(i)
#define MT6323_RG_ISINK_CK_PDN_MASK(i)	BIT(i)

/*
 * Register field for MT6323_TOP_CKCON1 to select
 * clock source.
 */
#define MT6323_RG_ISINK_CK_SEL_MASK(i)	(BIT(10) << (i))

/*
 * Register for MT6323_ISINK_CON0 to setup the
 * duty cycle of the blink.
 */
#define MT6323_ISINK_CON0(i)		(MT6323_ISINK0_CON0 + 0x8 * (i))
#define MT6323_ISINK_DIM_DUTY_MASK	(0x1f << 8)
#define MT6323_ISINK_DIM_DUTY(i)	(((i) << 8) & \
					MT6323_ISINK_DIM_DUTY_MASK)

/* Register to setup the period of the blink. */
#define MT6323_ISINK_CON1(i)		(MT6323_ISINK0_CON1 + 0x8 * (i))
#define MT6323_ISINK_DIM_FSEL_MASK	(0xffff)
#define MT6323_ISINK_DIM_FSEL(i)	((i) & MT6323_ISINK_DIM_FSEL_MASK)

/* Register to control the brightness. */
#define MT6323_ISINK_CON2(i)		(MT6323_ISINK0_CON2 + 0x8 * (i))
#define MT6323_ISINK_CH_STEP_SHIFT	12
#define MT6323_ISINK_CH_STEP_MASK	(0x7 << 12)
#define MT6323_ISINK_CH_STEP(i)		(((i) << 12) & \
					MT6323_ISINK_CH_STEP_MASK)
#define MT6323_ISINK_SFSTR0_TC_MASK	(0x3 << 1)
#define MT6323_ISINK_SFSTR0_TC(i)	(((i) << 1) & \
					MT6323_ISINK_SFSTR0_TC_MASK)
#define MT6323_ISINK_SFSTR0_EN_MASK	BIT(0)
#define MT6323_ISINK_SFSTR0_EN		BIT(0)

/* Register to LED channel enablement. */
#define MT6323_ISINK_CH_EN_MASK(i)	BIT(i)
#define MT6323_ISINK_CH_EN(i)		BIT(i)

#define MT6323_MAX_PERIOD		10000
#define MT6323_MAX_LEDS			4
#define MT6323_MAX_BRIGHTNESS		6
#define MT6323_UNIT_DUTY		3125
#define MT6323_CAL_HW_DUTY(o, p)	DIV_ROUND_CLOSEST((o) * 100000ul,\
					(p) * MT6323_UNIT_DUTY)

struct mt6323_leds;

/**
 * struct mt6323_led - state container for the LED device
 * @id:			the identifier in MT6323 LED device
 * @parent:		the pointer to MT6323 LED controller
 * @cdev:		LED class device for this LED device
 * @current_brightness: current state of the LED device
 */
struct mt6323_led {
	int			id;
	struct mt6323_leds	*parent;
	struct led_classdev	cdev;
	enum led_brightness	current_brightness;
};

/**
 * struct mt6323_leds -	state container for holding LED controller
 *			of the driver
 * @dev:		the device pointer
 * @hw:			the underlying hardware providing shared
 *			bus for the register operations
 * @lock:		the lock among process context
 * @led:		the array that contains the state of individual
 *			LED device
 */
struct mt6323_leds {
	struct device		*dev;
	struct mt6397_chip	*hw;
	/* protect among process context */
	struct mutex		lock;
	struct mt6323_led	*led[MT6323_MAX_LEDS];
};

static int mt6323_led_hw_brightness(struct led_classdev *cdev,
				    enum led_brightness brightness)
{
	struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev);
	struct mt6323_leds *leds = led->parent;
	struct regmap *regmap = leds->hw->regmap;
	u32 con2_mask = 0, con2_val = 0;
	int ret;

	/*
	 * Setup current output for the corresponding
	 * brightness level.
	 */
	con2_mask |= MT6323_ISINK_CH_STEP_MASK |
		     MT6323_ISINK_SFSTR0_TC_MASK |
		     MT6323_ISINK_SFSTR0_EN_MASK;
	con2_val |=  MT6323_ISINK_CH_STEP(brightness - 1) |
		     MT6323_ISINK_SFSTR0_TC(2) |
		     MT6323_ISINK_SFSTR0_EN;

	ret = regmap_update_bits(regmap, MT6323_ISINK_CON2(led->id),
				 con2_mask, con2_val);
	return ret;
}

static int mt6323_led_hw_off(struct led_classdev *cdev)
{
	struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev);
	struct mt6323_leds *leds = led->parent;
	struct regmap *regmap = leds->hw->regmap;
	unsigned int status;
	int ret;

	status = MT6323_ISINK_CH_EN(led->id);
	ret = regmap_update_bits(regmap, MT6323_ISINK_EN_CTRL,
				 MT6323_ISINK_CH_EN_MASK(led->id), ~status);
	if (ret < 0)
		return ret;

	usleep_range(100, 300);
	ret = regmap_update_bits(regmap, MT6323_TOP_CKPDN2,
				 MT6323_RG_ISINK_CK_PDN_MASK(led->id),
				 MT6323_RG_ISINK_CK_PDN(led->id));
	if (ret < 0)
		return ret;

	return 0;
}

static enum led_brightness
mt6323_get_led_hw_brightness(struct led_classdev *cdev)
{
	struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev);
	struct mt6323_leds *leds = led->parent;
	struct regmap *regmap = leds->hw->regmap;
	unsigned int status;
	int ret;

	ret = regmap_read(regmap, MT6323_TOP_CKPDN2, &status);
	if (ret < 0)
		return ret;

	if (status & MT6323_RG_ISINK_CK_PDN_MASK(led->id))
		return 0;

	ret = regmap_read(regmap, MT6323_ISINK_EN_CTRL, &status);
	if (ret < 0)
		return ret;

	if (!(status & MT6323_ISINK_CH_EN(led->id)))
		return 0;

	ret = regmap_read(regmap, MT6323_ISINK_CON2(led->id), &status);
	if (ret < 0)
		return ret;

	return  ((status & MT6323_ISINK_CH_STEP_MASK)
		  >> MT6323_ISINK_CH_STEP_SHIFT) + 1;
}

static int mt6323_led_hw_on(struct led_classdev *cdev,
			    enum led_brightness brightness)
{
	struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev);
	struct mt6323_leds *leds = led->parent;
	struct regmap *regmap = leds->hw->regmap;
	unsigned int status;
	int ret;

	/*
	 * Setup required clock source, enable the corresponding
	 * clock and channel and let work with continuous blink as
	 * the default.
	 */
	ret = regmap_update_bits(regmap, MT6323_TOP_CKCON1,
				 MT6323_RG_ISINK_CK_SEL_MASK(led->id), 0);
	if (ret < 0)
		return ret;

	status = MT6323_RG_ISINK_CK_PDN(led->id);
	ret = regmap_update_bits(regmap, MT6323_TOP_CKPDN2,
				 MT6323_RG_ISINK_CK_PDN_MASK(led->id),
				 ~status);
	if (ret < 0)
		return ret;

	usleep_range(100, 300);

	ret = regmap_update_bits(regmap, MT6323_ISINK_EN_CTRL,
				 MT6323_ISINK_CH_EN_MASK(led->id),
				 MT6323_ISINK_CH_EN(led->id));
	if (ret < 0)
		return ret;

	ret = mt6323_led_hw_brightness(cdev, brightness);
	if (ret < 0)
		return ret;

	ret = regmap_update_bits(regmap, MT6323_ISINK_CON0(led->id),
				 MT6323_ISINK_DIM_DUTY_MASK,
				 MT6323_ISINK_DIM_DUTY(31));
	if (ret < 0)
		return ret;

	ret = regmap_update_bits(regmap, MT6323_ISINK_CON1(led->id),
				 MT6323_ISINK_DIM_FSEL_MASK,
				 MT6323_ISINK_DIM_FSEL(1000));
	if (ret < 0)
		return ret;

	return 0;
}

static int mt6323_led_set_blink(struct led_classdev *cdev,
				unsigned long *delay_on,
				unsigned long *delay_off)
{
	struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev);
	struct mt6323_leds *leds = led->parent;
	struct regmap *regmap = leds->hw->regmap;
	unsigned long period;
	u8 duty_hw;
	int ret;

	/*
	 * LED subsystem requires a default user
	 * friendly blink pattern for the LED so using
	 * 1Hz duty cycle 50% here if without specific
	 * value delay_on and delay off being assigned.
	 */
	if (!*delay_on && !*delay_off) {
		*delay_on = 500;
		*delay_off = 500;
	}

	/*
	 * Units are in ms, if over the hardware able
	 * to support, fallback into software blink
	 */
	period = *delay_on + *delay_off;

	if (period > MT6323_MAX_PERIOD)
		return -EINVAL;

	/*
	 * Calculate duty_hw based on the percentage of period during
	 * which the led is ON.
	 */
	duty_hw = MT6323_CAL_HW_DUTY(*delay_on, period);

	/* hardware doesn't support zero duty cycle. */
	if (!duty_hw)
		return -EINVAL;

	mutex_lock(&leds->lock);
	/*
	 * Set max_brightness as the software blink behavior
	 * when no blink brightness.
	 */
	if (!led->current_brightness) {
		ret = mt6323_led_hw_on(cdev, cdev->max_brightness);
		if (ret < 0)
			goto out;
		led->current_brightness = cdev->max_brightness;
	}

	ret = regmap_update_bits(regmap, MT6323_ISINK_CON0(led->id),
				 MT6323_ISINK_DIM_DUTY_MASK,
				 MT6323_ISINK_DIM_DUTY(duty_hw - 1));
	if (ret < 0)
		goto out;

	ret = regmap_update_bits(regmap, MT6323_ISINK_CON1(led->id),
				 MT6323_ISINK_DIM_FSEL_MASK,
				 MT6323_ISINK_DIM_FSEL(period - 1));
out:
	mutex_unlock(&leds->lock);

	return ret;
}

static int mt6323_led_set_brightness(struct led_classdev *cdev,
				     enum led_brightness brightness)
{
	struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev);
	struct mt6323_leds *leds = led->parent;
	int ret;

	mutex_lock(&leds->lock);

	if (!led->current_brightness && brightness) {
		ret = mt6323_led_hw_on(cdev, brightness);
		if (ret < 0)
			goto out;
	} else if (brightness) {
		ret = mt6323_led_hw_brightness(cdev, brightness);
		if (ret < 0)
			goto out;
	} else {
		ret = mt6323_led_hw_off(cdev);
		if (ret < 0)
			goto out;
	}

	led->current_brightness = brightness;
out:
	mutex_unlock(&leds->lock);

	return ret;
}

static int mt6323_led_set_dt_default(struct led_classdev *cdev,
				     struct device_node *np)
{
	struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev);
	const char *state;
	int ret = 0;

	state = of_get_property(np, "default-state", NULL);
	if (state) {
		if (!strcmp(state, "keep")) {
			ret = mt6323_get_led_hw_brightness(cdev);
			if (ret < 0)
				return ret;
			led->current_brightness = ret;
			ret = 0;
		} else if (!strcmp(state, "on")) {
			ret =
			mt6323_led_set_brightness(cdev, cdev->max_brightness);
		} else  {
			ret = mt6323_led_set_brightness(cdev, LED_OFF);
		}
	}

	return ret;
}

static int mt6323_led_probe(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct device_node *np = dev_of_node(dev);
	struct device_node *child;
	struct mt6397_chip *hw = dev_get_drvdata(dev->parent);
	struct mt6323_leds *leds;
	struct mt6323_led *led;
	int ret;
	unsigned int status;
	u32 reg;

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

	platform_set_drvdata(pdev, leds);
	leds->dev = dev;

	/*
	 * leds->hw points to the underlying bus for the register
	 * controlled.
	 */
	leds->hw = hw;
	mutex_init(&leds->lock);

	status = MT6323_RG_DRV_32K_CK_PDN;
	ret = regmap_update_bits(leds->hw->regmap, MT6323_TOP_CKPDN0,
				 MT6323_RG_DRV_32K_CK_PDN_MASK, ~status);
	if (ret < 0) {
		dev_err(leds->dev,
			"Failed to update MT6323_TOP_CKPDN0 Register\n");
		return ret;
	}

	for_each_available_child_of_node(np, child) {
		struct led_init_data init_data = {};

		ret = of_property_read_u32(child, "reg", &reg);
		if (ret) {
			dev_err(dev, "Failed to read led 'reg' property\n");
			goto put_child_node;
		}

		if (reg >= MT6323_MAX_LEDS || leds->led[reg]) {
			dev_err(dev, "Invalid led reg %u\n", reg);
			ret = -EINVAL;
			goto put_child_node;
		}

		led = devm_kzalloc(dev, sizeof(*led), GFP_KERNEL);
		if (!led) {
			ret = -ENOMEM;
			goto put_child_node;
		}

		leds->led[reg] = led;
		leds->led[reg]->id = reg;
		leds->led[reg]->cdev.max_brightness = MT6323_MAX_BRIGHTNESS;
		leds->led[reg]->cdev.brightness_set_blocking =
					mt6323_led_set_brightness;
		leds->led[reg]->cdev.blink_set = mt6323_led_set_blink;
		leds->led[reg]->cdev.brightness_get =
					mt6323_get_led_hw_brightness;
		leds->led[reg]->parent = leds;

		ret = mt6323_led_set_dt_default(&leds->led[reg]->cdev, child);
		if (ret < 0) {
			dev_err(leds->dev,
				"Failed to LED set default from devicetree\n");
			goto put_child_node;
		}

		init_data.fwnode = of_fwnode_handle(child);

		ret = devm_led_classdev_register_ext(dev, &leds->led[reg]->cdev,
						     &init_data);
		if (ret) {
			dev_err(dev, "Failed to register LED: %d\n", ret);
			goto put_child_node;
		}
	}

	return 0;

put_child_node:
	of_node_put(child);
	return ret;
}

static int mt6323_led_remove(struct platform_device *pdev)
{
	struct mt6323_leds *leds = platform_get_drvdata(pdev);
	int i;

	/* Turn the LEDs off on driver removal. */
	for (i = 0 ; leds->led[i] ; i++)
		mt6323_led_hw_off(&leds->led[i]->cdev);

	regmap_update_bits(leds->hw->regmap, MT6323_TOP_CKPDN0,
			   MT6323_RG_DRV_32K_CK_PDN_MASK,
			   MT6323_RG_DRV_32K_CK_PDN);

	mutex_destroy(&leds->lock);

	return 0;
}

static const struct of_device_id mt6323_led_dt_match[] = {
	{ .compatible = "mediatek,mt6323-led" },
	{},
};
MODULE_DEVICE_TABLE(of, mt6323_led_dt_match);

static struct platform_driver mt6323_led_driver = {
	.probe		= mt6323_led_probe,
	.remove		= mt6323_led_remove,
	.driver		= {
		.name	= "mt6323-led",
		.of_match_table = mt6323_led_dt_match,
	},
};

module_platform_driver(mt6323_led_driver);

MODULE_DESCRIPTION("LED driver for Mediatek MT6323 PMIC");
MODULE_AUTHOR("Sean Wang <sean.wang@mediatek.com>");
MODULE_LICENSE("GPL");
Commit	Line	Data
c942fddf	1	// SPDX-License-Identifier: GPL-2.0-or-later
216ec6cc SW	2	/*
	3	* LED driver for Mediatek MT6323 PMIC
	4	*
	5	* Copyright (C) 2017 Sean Wang <sean.wang@mediatek.com>
216ec6cc SW	6	*/
	7	#include <linux/kernel.h>
	8	#include <linux/leds.h>
	9	#include <linux/mfd/mt6323/registers.h>
	10	#include <linux/mfd/mt6397/core.h>
	11	#include <linux/module.h>
	12	#include <linux/of.h>
	13	#include <linux/platform_device.h>
	14	#include <linux/regmap.h>
	15
	16	/*
	17	* Register field for MT6323_TOP_CKPDN0 to enable
	18	* 32K clock common for LED device.
	19	*/
	20	#define MT6323_RG_DRV_32K_CK_PDN BIT(11)
	21	#define MT6323_RG_DRV_32K_CK_PDN_MASK BIT(11)
	22
	23	/*
	24	* Register field for MT6323_TOP_CKPDN2 to enable
	25	* individual clock for LED device.
	26	*/
	27	#define MT6323_RG_ISINK_CK_PDN(i) BIT(i)
	28	#define MT6323_RG_ISINK_CK_PDN_MASK(i) BIT(i)
	29
	30	/*
	31	* Register field for MT6323_TOP_CKCON1 to select
	32	* clock source.
	33	*/
	34	#define MT6323_RG_ISINK_CK_SEL_MASK(i) (BIT(10) << (i))
	35
	36	/*
	37	* Register for MT6323_ISINK_CON0 to setup the
	38	* duty cycle of the blink.
	39	*/
	40	#define MT6323_ISINK_CON0(i) (MT6323_ISINK0_CON0 + 0x8 * (i))
	41	#define MT6323_ISINK_DIM_DUTY_MASK (0x1f << 8)
	42	#define MT6323_ISINK_DIM_DUTY(i) (((i) << 8) & \
	43	MT6323_ISINK_DIM_DUTY_MASK)
	44
	45	/* Register to setup the period of the blink. */
	46	#define MT6323_ISINK_CON1(i) (MT6323_ISINK0_CON1 + 0x8 * (i))
	47	#define MT6323_ISINK_DIM_FSEL_MASK (0xffff)
	48	#define MT6323_ISINK_DIM_FSEL(i) ((i) & MT6323_ISINK_DIM_FSEL_MASK)
	49
	50	/* Register to control the brightness. */
	51	#define MT6323_ISINK_CON2(i) (MT6323_ISINK0_CON2 + 0x8 * (i))
	52	#define MT6323_ISINK_CH_STEP_SHIFT 12
	53	#define MT6323_ISINK_CH_STEP_MASK (0x7 << 12)
	54	#define MT6323_ISINK_CH_STEP(i) (((i) << 12) & \
	55	MT6323_ISINK_CH_STEP_MASK)
	56	#define MT6323_ISINK_SFSTR0_TC_MASK (0x3 << 1)
	57	#define MT6323_ISINK_SFSTR0_TC(i) (((i) << 1) & \
	58	MT6323_ISINK_SFSTR0_TC_MASK)
	59	#define MT6323_ISINK_SFSTR0_EN_MASK BIT(0)
	60	#define MT6323_ISINK_SFSTR0_EN BIT(0)
	61
	62	/* Register to LED channel enablement. */
	63	#define MT6323_ISINK_CH_EN_MASK(i) BIT(i)
	64	#define MT6323_ISINK_CH_EN(i) BIT(i)
	65
	66	#define MT6323_MAX_PERIOD 10000
	67	#define MT6323_MAX_LEDS 4
	68	#define MT6323_MAX_BRIGHTNESS 6
	69	#define MT6323_UNIT_DUTY 3125
70	#define MT6323_CAL_HW_DUTY(o, p) DIV_ROUND_CLOSEST((o) * 100000ul,\
71	(p) * MT6323_UNIT_DUTY)
72
73	struct mt6323_leds;
74
75	/**
76	* struct mt6323_led - state container for the LED device
77	* @id: the identifier in MT6323 LED device
78	* @parent: the pointer to MT6323 LED controller
79	* @cdev: LED class device for this LED device
80	* @current_brightness: current state of the LED device
81	*/
82	struct mt6323_led {
83	int id;
84	struct mt6323_leds *parent;
85	struct led_classdev cdev;
86	enum led_brightness current_brightness;
87	};
88
89	/**
90	* struct mt6323_leds - state container for holding LED controller
91	* of the driver
92	* @dev: the device pointer
93	* @hw: the underlying hardware providing shared
94	* bus for the register operations
95	* @lock: the lock among process context
96	* @led: the array that contains the state of individual
97	* LED device
98	*/
99	struct mt6323_leds {
100	struct device *dev;
101	struct mt6397_chip *hw;
102	/* protect among process context */
103	struct mutex lock;
104	struct mt6323_led *led[MT6323_MAX_LEDS];
105	};
106
107	static int mt6323_led_hw_brightness(struct led_classdev *cdev,
108	enum led_brightness brightness)
109	{
110	struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev);
111	struct mt6323_leds *leds = led->parent;
112	struct regmap *regmap = leds->hw->regmap;
113	u32 con2_mask = 0, con2_val = 0;
114	int ret;
115
116	/*
117	* Setup current output for the corresponding
118	* brightness level.
119	*/
120	con2_mask \|= MT6323_ISINK_CH_STEP_MASK \|
121	MT6323_ISINK_SFSTR0_TC_MASK \|
122	MT6323_ISINK_SFSTR0_EN_MASK;
123	con2_val \|= MT6323_ISINK_CH_STEP(brightness - 1) \|
124	MT6323_ISINK_SFSTR0_TC(2) \|
125	MT6323_ISINK_SFSTR0_EN;
126
127	ret = regmap_update_bits(regmap, MT6323_ISINK_CON2(led->id),
128	con2_mask, con2_val);
129	return ret;
130	}
131
132	static int mt6323_led_hw_off(struct led_classdev *cdev)
133	{
134	struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev);
135	struct mt6323_leds *leds = led->parent;
136	struct regmap *regmap = leds->hw->regmap;
137	unsigned int status;
138	int ret;
139
140	status = MT6323_ISINK_CH_EN(led->id);
141	ret = regmap_update_bits(regmap, MT6323_ISINK_EN_CTRL,
142	MT6323_ISINK_CH_EN_MASK(led->id), ~status);
143	if (ret < 0)
144	return ret;
145
146	usleep_range(100, 300);
147	ret = regmap_update_bits(regmap, MT6323_TOP_CKPDN2,
148	MT6323_RG_ISINK_CK_PDN_MASK(led->id),
149	MT6323_RG_ISINK_CK_PDN(led->id));
150	if (ret < 0)
151	return ret;
152
153	return 0;
154	}
155
156	static enum led_brightness
157	mt6323_get_led_hw_brightness(struct led_classdev *cdev)
158	{
159	struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev);
160	struct mt6323_leds *leds = led->parent;
161	struct regmap *regmap = leds->hw->regmap;
162	unsigned int status;
163	int ret;
164
165	ret = regmap_read(regmap, MT6323_TOP_CKPDN2, &status);
166	if (ret < 0)
167	return ret;
168
169	if (status & MT6323_RG_ISINK_CK_PDN_MASK(led->id))
170	return 0;
171
172	ret = regmap_read(regmap, MT6323_ISINK_EN_CTRL, &status);
173	if (ret < 0)
174	return ret;
175
176	if (!(status & MT6323_ISINK_CH_EN(led->id)))
177	return 0;
178
179	ret = regmap_read(regmap, MT6323_ISINK_CON2(led->id), &status);
180	if (ret < 0)
181	return ret;
182
183	return ((status & MT6323_ISINK_CH_STEP_MASK)
184	>> MT6323_ISINK_CH_STEP_SHIFT) + 1;
185	}
186
187	static int mt6323_led_hw_on(struct led_classdev *cdev,
188	enum led_brightness brightness)
189	{
190	struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev);
191	struct mt6323_leds *leds = led->parent;
192	struct regmap *regmap = leds->hw->regmap;
193	unsigned int status;
194	int ret;
195
196	/*
197	* Setup required clock source, enable the corresponding
198	* clock and channel and let work with continuous blink as
199	* the default.
200	*/
201	ret = regmap_update_bits(regmap, MT6323_TOP_CKCON1,
202	MT6323_RG_ISINK_CK_SEL_MASK(led->id), 0);
203	if (ret < 0)
204	return ret;
205
206	status = MT6323_RG_ISINK_CK_PDN(led->id);
207	ret = regmap_update_bits(regmap, MT6323_TOP_CKPDN2,
208	MT6323_RG_ISINK_CK_PDN_MASK(led->id),
209	~status);
210	if (ret < 0)
211	return ret;
212
213	usleep_range(100, 300);
214
215	ret = regmap_update_bits(regmap, MT6323_ISINK_EN_CTRL,
216	MT6323_ISINK_CH_EN_MASK(led->id),
217	MT6323_ISINK_CH_EN(led->id));
218	if (ret < 0)
219	return ret;
220
221	ret = mt6323_led_hw_brightness(cdev, brightness);
222	if (ret < 0)
223	return ret;
224
225	ret = regmap_update_bits(regmap, MT6323_ISINK_CON0(led->id),
226	MT6323_ISINK_DIM_DUTY_MASK,
227	MT6323_ISINK_DIM_DUTY(31));
228	if (ret < 0)
229	return ret;
230
231	ret = regmap_update_bits(regmap, MT6323_ISINK_CON1(led->id),
232	MT6323_ISINK_DIM_FSEL_MASK,
233	MT6323_ISINK_DIM_FSEL(1000));
234	if (ret < 0)
235	return ret;
236
237	return 0;
238	}
239
240	static int mt6323_led_set_blink(struct led_classdev *cdev,
241	unsigned long *delay_on,
242	unsigned long *delay_off)
243	{
244	struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev);
245	struct mt6323_leds *leds = led->parent;
246	struct regmap *regmap = leds->hw->regmap;
247	unsigned long period;
248	u8 duty_hw;
249	int ret;
250
216ec6cc SW	251	/*
	252	* LED subsystem requires a default user
	253	* friendly blink pattern for the LED so using
	254	* 1Hz duty cycle 50% here if without specific
	255	* value delay_on and delay off being assigned.
	256	*/
	257	if (!delay_on && !delay_off) {
	258	*delay_on = 500;
	259	*delay_off = 500;
	260	}
	261
fa31311c TR	262	/*
	263	* Units are in ms, if over the hardware able
	264	* to support, fallback into software blink
	265	*/
	266	period = delay_on + delay_off;
	267
	268	if (period > MT6323_MAX_PERIOD)
	269	return -EINVAL;
	270
216ec6cc SW	271	/*
	272	* Calculate duty_hw based on the percentage of period during
	273	* which the led is ON.
	274	*/
	275	duty_hw = MT6323_CAL_HW_DUTY(*delay_on, period);
	276
	277	/* hardware doesn't support zero duty cycle. */
	278	if (!duty_hw)
	279	return -EINVAL;
	280
	281	mutex_lock(&leds->lock);
	282	/*
	283	* Set max_brightness as the software blink behavior
	284	* when no blink brightness.
	285	*/
	286	if (!led->current_brightness) {
	287	ret = mt6323_led_hw_on(cdev, cdev->max_brightness);
	288	if (ret < 0)
	289	goto out;
	290	led->current_brightness = cdev->max_brightness;
	291	}
	292
	293	ret = regmap_update_bits(regmap, MT6323_ISINK_CON0(led->id),
	294	MT6323_ISINK_DIM_DUTY_MASK,
	295	MT6323_ISINK_DIM_DUTY(duty_hw - 1));
	296	if (ret < 0)
	297	goto out;
	298
	299	ret = regmap_update_bits(regmap, MT6323_ISINK_CON1(led->id),
	300	MT6323_ISINK_DIM_FSEL_MASK,
	301	MT6323_ISINK_DIM_FSEL(period - 1));
	302	out:
	303	mutex_unlock(&leds->lock);
	304
	305	return ret;
	306	}
	307
	308	static int mt6323_led_set_brightness(struct led_classdev *cdev,
	309	enum led_brightness brightness)
	310	{
	311	struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev);
	312	struct mt6323_leds *leds = led->parent;
	313	int ret;
	314
	315	mutex_lock(&leds->lock);
	316
	317	if (!led->current_brightness && brightness) {
	318	ret = mt6323_led_hw_on(cdev, brightness);
	319	if (ret < 0)
	320	goto out;
	321	} else if (brightness) {
	322	ret = mt6323_led_hw_brightness(cdev, brightness);
	323	if (ret < 0)
	324	goto out;
	325	} else {
	326	ret = mt6323_led_hw_off(cdev);
	327	if (ret < 0)
	328	goto out;
	329	}
	330
	331	led->current_brightness = brightness;
	332	out:
	333	mutex_unlock(&leds->lock);
	334
335	return ret;
336	}
337
338	static int mt6323_led_set_dt_default(struct led_classdev *cdev,
339	struct device_node *np)
340	{
341	struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev);
342	const char *state;
343	int ret = 0;
344
216ec6cc SW	345	state = of_get_property(np, "default-state", NULL);
	346	if (state) {
	347	if (!strcmp(state, "keep")) {
	348	ret = mt6323_get_led_hw_brightness(cdev);
	349	if (ret < 0)
	350	return ret;
	351	led->current_brightness = ret;
	352	ret = 0;
	353	} else if (!strcmp(state, "on")) {
	354	ret =
	355	mt6323_led_set_brightness(cdev, cdev->max_brightness);
	356	} else {
	357	ret = mt6323_led_set_brightness(cdev, LED_OFF);
	358	}
	359	}
	360
	361	return ret;
	362	}
	363
	364	static int mt6323_led_probe(struct platform_device *pdev)
	365	{
	366	struct device *dev = &pdev->dev;
b23ca98a	367	struct device_node *np = dev_of_node(dev);
216ec6cc	368	struct device_node *child;
b23ca98a	369	struct mt6397_chip *hw = dev_get_drvdata(dev->parent);
216ec6cc SW	370	struct mt6323_leds *leds;
	371	struct mt6323_led *led;
	372	int ret;
	373	unsigned int status;
	374	u32 reg;
	375
	376	leds = devm_kzalloc(dev, sizeof(*leds), GFP_KERNEL);
	377	if (!leds)
	378	return -ENOMEM;
	379
	380	platform_set_drvdata(pdev, leds);
	381	leds->dev = dev;
	382
	383	/*
	384	* leds->hw points to the underlying bus for the register
	385	* controlled.
	386	*/
	387	leds->hw = hw;
	388	mutex_init(&leds->lock);
	389
	390	status = MT6323_RG_DRV_32K_CK_PDN;
	391	ret = regmap_update_bits(leds->hw->regmap, MT6323_TOP_CKPDN0,
	392	MT6323_RG_DRV_32K_CK_PDN_MASK, ~status);
	393	if (ret < 0) {
	394	dev_err(leds->dev,
	395	"Failed to update MT6323_TOP_CKPDN0 Register\n");
	396	return ret;
	397	}
	398
	399	for_each_available_child_of_node(np, child) {
6b8274de MB	400	struct led_init_data init_data = {};
6b8274de MB	401
216ec6cc SW	402	ret = of_property_read_u32(child, "reg", &reg);
	403	if (ret) {
	404	dev_err(dev, "Failed to read led 'reg' property\n");
	405	goto put_child_node;
	406	}
	407
ac572452	408	if (reg >= MT6323_MAX_LEDS \|\| leds->led[reg]) {
216ec6cc SW	409	dev_err(dev, "Invalid led reg %u\n", reg);
	410	ret = -EINVAL;
	411	goto put_child_node;
	412	}
	413
	414	led = devm_kzalloc(dev, sizeof(*led), GFP_KERNEL);
	415	if (!led) {
	416	ret = -ENOMEM;
	417	goto put_child_node;
	418	}
	419
	420	leds->led[reg] = led;
	421	leds->led[reg]->id = reg;
	422	leds->led[reg]->cdev.max_brightness = MT6323_MAX_BRIGHTNESS;
	423	leds->led[reg]->cdev.brightness_set_blocking =
	424	mt6323_led_set_brightness;
	425	leds->led[reg]->cdev.blink_set = mt6323_led_set_blink;
	426	leds->led[reg]->cdev.brightness_get =
	427	mt6323_get_led_hw_brightness;
	428	leds->led[reg]->parent = leds;
	429
	430	ret = mt6323_led_set_dt_default(&leds->led[reg]->cdev, child);
	431	if (ret < 0) {
	432	dev_err(leds->dev,
	433	"Failed to LED set default from devicetree\n");
	434	goto put_child_node;
	435	}
	436
6b8274de MB	437	init_data.fwnode = of_fwnode_handle(child);
	438
	439	ret = devm_led_classdev_register_ext(dev, &leds->led[reg]->cdev,
	440	&init_data);
216ec6cc	441	if (ret) {
b23ca98a	442	dev_err(dev, "Failed to register LED: %d\n", ret);
216ec6cc SW	443	goto put_child_node;
216ec6cc SW	444	}
216ec6cc SW	445	}
	446
	447	return 0;
	448
	449	put_child_node:
	450	of_node_put(child);
	451	return ret;
	452	}
	453
	454	static int mt6323_led_remove(struct platform_device *pdev)
	455	{
	456	struct mt6323_leds *leds = platform_get_drvdata(pdev);
	457	int i;
	458
	459	/* Turn the LEDs off on driver removal. */
	460	for (i = 0 ; leds->led[i] ; i++)
	461	mt6323_led_hw_off(&leds->led[i]->cdev);
	462
	463	regmap_update_bits(leds->hw->regmap, MT6323_TOP_CKPDN0,
	464	MT6323_RG_DRV_32K_CK_PDN_MASK,
	465	MT6323_RG_DRV_32K_CK_PDN);
	466
	467	mutex_destroy(&leds->lock);
	468
	469	return 0;
	470	}
	471
	472	static const struct of_device_id mt6323_led_dt_match[] = {
	473	{ .compatible = "mediatek,mt6323-led" },
	474	{},
	475	};
	476	MODULE_DEVICE_TABLE(of, mt6323_led_dt_match);
	477
	478	static struct platform_driver mt6323_led_driver = {
	479	.probe = mt6323_led_probe,
	480	.remove = mt6323_led_remove,
	481	.driver = {
	482	.name = "mt6323-led",
	483	.of_match_table = mt6323_led_dt_match,
	484	},
	485	};
	486
	487	module_platform_driver(mt6323_led_driver);
	488
	489	MODULE_DESCRIPTION("LED driver for Mediatek MT6323 PMIC");
	490	MODULE_AUTHOR("Sean Wang <sean.wang@mediatek.com>");
	491	MODULE_LICENSE("GPL");