[linux-2.6-block.git] / drivers / leds / leds-sc27xx-bltc.c

// SPDX-License-Identifier: GPL-2.0
// Copyright (C) 2018 Spreadtrum Communications Inc.

#include <linux/leds.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>
#include <uapi/linux/uleds.h>

/* PMIC global control register definition */
#define SC27XX_MODULE_EN0	0xc08
#define SC27XX_CLK_EN0		0xc18
#define SC27XX_RGB_CTRL		0xebc

#define SC27XX_BLTC_EN		BIT(9)
#define SC27XX_RTC_EN		BIT(7)
#define SC27XX_RGB_PD		BIT(0)

/* Breathing light controller register definition */
#define SC27XX_LEDS_CTRL	0x00
#define SC27XX_LEDS_PRESCALE	0x04
#define SC27XX_LEDS_DUTY	0x08
#define SC27XX_LEDS_CURVE0	0x0c
#define SC27XX_LEDS_CURVE1	0x10

#define SC27XX_CTRL_SHIFT	4
#define SC27XX_LED_RUN		BIT(0)
#define SC27XX_LED_TYPE		BIT(1)

#define SC27XX_DUTY_SHIFT	8
#define SC27XX_DUTY_MASK	GENMASK(15, 0)
#define SC27XX_MOD_MASK		GENMASK(7, 0)

#define SC27XX_CURVE_SHIFT	8
#define SC27XX_CURVE_L_MASK	GENMASK(7, 0)
#define SC27XX_CURVE_H_MASK	GENMASK(15, 8)

#define SC27XX_LEDS_OFFSET	0x10
#define SC27XX_LEDS_MAX		3
#define SC27XX_LEDS_PATTERN_CNT	4
/* Stage duration step, in milliseconds */
#define SC27XX_LEDS_STEP	125
/* Minimum and maximum duration, in milliseconds */
#define SC27XX_DELTA_T_MIN	SC27XX_LEDS_STEP
#define SC27XX_DELTA_T_MAX	(SC27XX_LEDS_STEP * 255)

struct sc27xx_led {
	char name[LED_MAX_NAME_SIZE];
	struct led_classdev ldev;
	struct sc27xx_led_priv *priv;
	u8 line;
	bool active;
};

struct sc27xx_led_priv {
	struct sc27xx_led leds[SC27XX_LEDS_MAX];
	struct regmap *regmap;
	struct mutex lock;
	u32 base;
};

#define to_sc27xx_led(ldev) \
	container_of(ldev, struct sc27xx_led, ldev)

static int sc27xx_led_init(struct regmap *regmap)
{
	int err;

	err = regmap_update_bits(regmap, SC27XX_MODULE_EN0, SC27XX_BLTC_EN,
				 SC27XX_BLTC_EN);
	if (err)
		return err;

	err = regmap_update_bits(regmap, SC27XX_CLK_EN0, SC27XX_RTC_EN,
				 SC27XX_RTC_EN);
	if (err)
		return err;

	return regmap_update_bits(regmap, SC27XX_RGB_CTRL, SC27XX_RGB_PD, 0);
}

static u32 sc27xx_led_get_offset(struct sc27xx_led *leds)
{
	return leds->priv->base + SC27XX_LEDS_OFFSET * leds->line;
}

static int sc27xx_led_enable(struct sc27xx_led *leds, enum led_brightness value)
{
	u32 base = sc27xx_led_get_offset(leds);
	u32 ctrl_base = leds->priv->base + SC27XX_LEDS_CTRL;
	u8 ctrl_shift = SC27XX_CTRL_SHIFT * leds->line;
	struct regmap *regmap = leds->priv->regmap;
	int err;

	err = regmap_update_bits(regmap, base + SC27XX_LEDS_DUTY,
				 SC27XX_DUTY_MASK,
				 (value << SC27XX_DUTY_SHIFT) |
				 SC27XX_MOD_MASK);
	if (err)
		return err;

	return regmap_update_bits(regmap, ctrl_base,
			(SC27XX_LED_RUN | SC27XX_LED_TYPE) << ctrl_shift,
			(SC27XX_LED_RUN | SC27XX_LED_TYPE) << ctrl_shift);
}

static int sc27xx_led_disable(struct sc27xx_led *leds)
{
	struct regmap *regmap = leds->priv->regmap;
	u32 ctrl_base = leds->priv->base + SC27XX_LEDS_CTRL;
	u8 ctrl_shift = SC27XX_CTRL_SHIFT * leds->line;

	return regmap_update_bits(regmap, ctrl_base,
			(SC27XX_LED_RUN | SC27XX_LED_TYPE) << ctrl_shift, 0);
}

static int sc27xx_led_set(struct led_classdev *ldev, enum led_brightness value)
{
	struct sc27xx_led *leds = to_sc27xx_led(ldev);
	int err;

	mutex_lock(&leds->priv->lock);

	if (value == LED_OFF)
		err = sc27xx_led_disable(leds);
	else
		err = sc27xx_led_enable(leds, value);

	mutex_unlock(&leds->priv->lock);

	return err;
}

static void sc27xx_led_clamp_align_delta_t(u32 *delta_t)
{
	u32 v, offset, t = *delta_t;

	v = t + SC27XX_LEDS_STEP / 2;
	v = clamp_t(u32, v, SC27XX_DELTA_T_MIN, SC27XX_DELTA_T_MAX);
	offset = v - SC27XX_DELTA_T_MIN;
	offset = SC27XX_LEDS_STEP * (offset / SC27XX_LEDS_STEP);

	*delta_t = SC27XX_DELTA_T_MIN + offset;
}

static int sc27xx_led_pattern_clear(struct led_classdev *ldev)
{
	struct sc27xx_led *leds = to_sc27xx_led(ldev);
	struct regmap *regmap = leds->priv->regmap;
	u32 base = sc27xx_led_get_offset(leds);
	u32 ctrl_base = leds->priv->base + SC27XX_LEDS_CTRL;
	u8 ctrl_shift = SC27XX_CTRL_SHIFT * leds->line;
	int err;

	mutex_lock(&leds->priv->lock);

	/* Reset the rise, high, fall and low time to zero. */
	regmap_write(regmap, base + SC27XX_LEDS_CURVE0, 0);
	regmap_write(regmap, base + SC27XX_LEDS_CURVE1, 0);

	err = regmap_update_bits(regmap, ctrl_base,
			(SC27XX_LED_RUN | SC27XX_LED_TYPE) << ctrl_shift, 0);

	ldev->brightness = LED_OFF;

	mutex_unlock(&leds->priv->lock);

	return err;
}

static int sc27xx_led_pattern_set(struct led_classdev *ldev,
				  struct led_pattern *pattern,
				  u32 len, int repeat)
{
	struct sc27xx_led *leds = to_sc27xx_led(ldev);
	u32 base = sc27xx_led_get_offset(leds);
	u32 ctrl_base = leds->priv->base + SC27XX_LEDS_CTRL;
	u8 ctrl_shift = SC27XX_CTRL_SHIFT * leds->line;
	struct regmap *regmap = leds->priv->regmap;
	int err;

	/*
	 * Must contain 4 tuples to configure the rise time, high time, fall
	 * time and low time to enable the breathing mode.
	 */
	if (len != SC27XX_LEDS_PATTERN_CNT)
		return -EINVAL;

	mutex_lock(&leds->priv->lock);

	sc27xx_led_clamp_align_delta_t(&pattern[0].delta_t);
	err = regmap_update_bits(regmap, base + SC27XX_LEDS_CURVE0,
				 SC27XX_CURVE_L_MASK,
				 pattern[0].delta_t / SC27XX_LEDS_STEP);
	if (err)
		goto out;

	sc27xx_led_clamp_align_delta_t(&pattern[1].delta_t);
	err = regmap_update_bits(regmap, base + SC27XX_LEDS_CURVE1,
				 SC27XX_CURVE_L_MASK,
				 pattern[1].delta_t / SC27XX_LEDS_STEP);
	if (err)
		goto out;

	sc27xx_led_clamp_align_delta_t(&pattern[2].delta_t);
	err = regmap_update_bits(regmap, base + SC27XX_LEDS_CURVE0,
				 SC27XX_CURVE_H_MASK,
				 (pattern[2].delta_t / SC27XX_LEDS_STEP) <<
				 SC27XX_CURVE_SHIFT);
	if (err)
		goto out;

	sc27xx_led_clamp_align_delta_t(&pattern[3].delta_t);
	err = regmap_update_bits(regmap, base + SC27XX_LEDS_CURVE1,
				 SC27XX_CURVE_H_MASK,
				 (pattern[3].delta_t / SC27XX_LEDS_STEP) <<
				 SC27XX_CURVE_SHIFT);
	if (err)
		goto out;

	err = regmap_update_bits(regmap, base + SC27XX_LEDS_DUTY,
				 SC27XX_DUTY_MASK,
				 (pattern[1].brightness << SC27XX_DUTY_SHIFT) |
				 SC27XX_MOD_MASK);
	if (err)
		goto out;

	/* Enable the LED breathing mode */
	err = regmap_update_bits(regmap, ctrl_base,
				 SC27XX_LED_RUN << ctrl_shift,
				 SC27XX_LED_RUN << ctrl_shift);
	if (!err)
		ldev->brightness = pattern[1].brightness;

out:
	mutex_unlock(&leds->priv->lock);

	return err;
}

static int sc27xx_led_register(struct device *dev, struct sc27xx_led_priv *priv)
{
	int i, err;

	err = sc27xx_led_init(priv->regmap);
	if (err)
		return err;

	for (i = 0; i < SC27XX_LEDS_MAX; i++) {
		struct sc27xx_led *led = &priv->leds[i];

		if (!led->active)
			continue;

		led->line = i;
		led->priv = priv;
		led->ldev.name = led->name;
		led->ldev.brightness_set_blocking = sc27xx_led_set;
		led->ldev.pattern_set = sc27xx_led_pattern_set;
		led->ldev.pattern_clear = sc27xx_led_pattern_clear;
		led->ldev.default_trigger = "pattern";

		err = devm_led_classdev_register(dev, &led->ldev);
		if (err)
			return err;
	}

	return 0;
}

static int sc27xx_led_probe(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct device_node *np = dev->of_node, *child;
	struct sc27xx_led_priv *priv;
	const char *str;
	u32 base, count, reg;
	int err;

	count = of_get_child_count(np);
	if (!count || count > SC27XX_LEDS_MAX)
		return -EINVAL;

	err = of_property_read_u32(np, "reg", &base);
	if (err) {
		dev_err(dev, "fail to get reg of property\n");
		return err;
	}

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

	platform_set_drvdata(pdev, priv);
	mutex_init(&priv->lock);
	priv->base = base;
	priv->regmap = dev_get_regmap(dev->parent, NULL);
	if (!priv->regmap) {
		err = -ENODEV;
		dev_err(dev, "failed to get regmap: %d\n", err);
		return err;
	}

	for_each_child_of_node(np, child) {
		err = of_property_read_u32(child, "reg", &reg);
		if (err) {
			of_node_put(child);
			mutex_destroy(&priv->lock);
			return err;
		}

		if (reg >= SC27XX_LEDS_MAX || priv->leds[reg].active) {
			of_node_put(child);
			mutex_destroy(&priv->lock);
			return -EINVAL;
		}

		priv->leds[reg].active = true;

		err = of_property_read_string(child, "label", &str);
		if (err)
			snprintf(priv->leds[reg].name, LED_MAX_NAME_SIZE,
				 "sc27xx::");
		else
			snprintf(priv->leds[reg].name, LED_MAX_NAME_SIZE,
				 "sc27xx:%s", str);
	}

	err = sc27xx_led_register(dev, priv);
	if (err)
		mutex_destroy(&priv->lock);

	return err;
}

static int sc27xx_led_remove(struct platform_device *pdev)
{
	struct sc27xx_led_priv *priv = platform_get_drvdata(pdev);

	mutex_destroy(&priv->lock);
	return 0;
}

static const struct of_device_id sc27xx_led_of_match[] = {
	{ .compatible = "sprd,sc2731-bltc", },
	{ }
};
MODULE_DEVICE_TABLE(of, sc27xx_led_of_match);

static struct platform_driver sc27xx_led_driver = {
	.driver = {
		.name = "sprd-bltc",
		.of_match_table = sc27xx_led_of_match,
	},
	.probe = sc27xx_led_probe,
	.remove = sc27xx_led_remove,
};

module_platform_driver(sc27xx_led_driver);

MODULE_DESCRIPTION("Spreadtrum SC27xx breathing light controller driver");
MODULE_AUTHOR("Xiaotong Lu <xiaotong.lu@spreadtrum.com>");
MODULE_AUTHOR("Baolin Wang <baolin.wang@linaro.org>");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
e081c49e BW	1	// SPDX-License-Identifier: GPL-2.0
	2	// Copyright (C) 2018 Spreadtrum Communications Inc.
	3
	4	#include <linux/leds.h>
	5	#include <linux/module.h>
	6	#include <linux/of.h>
	7	#include <linux/platform_device.h>
	8	#include <linux/regmap.h>
	9	#include <uapi/linux/uleds.h>
	10
	11	/* PMIC global control register definition */
	12	#define SC27XX_MODULE_EN0 0xc08
	13	#define SC27XX_CLK_EN0 0xc18
	14	#define SC27XX_RGB_CTRL 0xebc
	15
	16	#define SC27XX_BLTC_EN BIT(9)
	17	#define SC27XX_RTC_EN BIT(7)
	18	#define SC27XX_RGB_PD BIT(0)
	19
	20	/* Breathing light controller register definition */
	21	#define SC27XX_LEDS_CTRL 0x00
	22	#define SC27XX_LEDS_PRESCALE 0x04
	23	#define SC27XX_LEDS_DUTY 0x08
	24	#define SC27XX_LEDS_CURVE0 0x0c
	25	#define SC27XX_LEDS_CURVE1 0x10
	26
	27	#define SC27XX_CTRL_SHIFT 4
	28	#define SC27XX_LED_RUN BIT(0)
	29	#define SC27XX_LED_TYPE BIT(1)
	30
	31	#define SC27XX_DUTY_SHIFT 8
	32	#define SC27XX_DUTY_MASK GENMASK(15, 0)
	33	#define SC27XX_MOD_MASK GENMASK(7, 0)
	34
8dbac65f BW	35	#define SC27XX_CURVE_SHIFT 8
	36	#define SC27XX_CURVE_L_MASK GENMASK(7, 0)
	37	#define SC27XX_CURVE_H_MASK GENMASK(15, 8)
	38
e081c49e BW	39	#define SC27XX_LEDS_OFFSET 0x10
e081c49e BW	40	#define SC27XX_LEDS_MAX 3
8dbac65f BW	41	#define SC27XX_LEDS_PATTERN_CNT 4
	42	/* Stage duration step, in milliseconds */
	43	#define SC27XX_LEDS_STEP 125
	44	/* Minimum and maximum duration, in milliseconds */
	45	#define SC27XX_DELTA_T_MIN SC27XX_LEDS_STEP
	46	#define SC27XX_DELTA_T_MAX (SC27XX_LEDS_STEP * 255)
e081c49e BW	47
	48	struct sc27xx_led {
	49	char name[LED_MAX_NAME_SIZE];
	50	struct led_classdev ldev;
	51	struct sc27xx_led_priv *priv;
	52	u8 line;
	53	bool active;
	54	};
	55
	56	struct sc27xx_led_priv {
	57	struct sc27xx_led leds[SC27XX_LEDS_MAX];
	58	struct regmap *regmap;
	59	struct mutex lock;
	60	u32 base;
	61	};
	62
	63	#define to_sc27xx_led(ldev) \
	64	container_of(ldev, struct sc27xx_led, ldev)
	65
	66	static int sc27xx_led_init(struct regmap *regmap)
	67	{
	68	int err;
	69
	70	err = regmap_update_bits(regmap, SC27XX_MODULE_EN0, SC27XX_BLTC_EN,
	71	SC27XX_BLTC_EN);
	72	if (err)
	73	return err;
	74
	75	err = regmap_update_bits(regmap, SC27XX_CLK_EN0, SC27XX_RTC_EN,
	76	SC27XX_RTC_EN);
	77	if (err)
	78	return err;
	79
	80	return regmap_update_bits(regmap, SC27XX_RGB_CTRL, SC27XX_RGB_PD, 0);
	81	}
	82
	83	static u32 sc27xx_led_get_offset(struct sc27xx_led *leds)
	84	{
	85	return leds->priv->base + SC27XX_LEDS_OFFSET * leds->line;
	86	}
	87
	88	static int sc27xx_led_enable(struct sc27xx_led *leds, enum led_brightness value)
	89	{
	90	u32 base = sc27xx_led_get_offset(leds);
	91	u32 ctrl_base = leds->priv->base + SC27XX_LEDS_CTRL;
	92	u8 ctrl_shift = SC27XX_CTRL_SHIFT * leds->line;
	93	struct regmap *regmap = leds->priv->regmap;
	94	int err;
	95
	96	err = regmap_update_bits(regmap, base + SC27XX_LEDS_DUTY,
	97	SC27XX_DUTY_MASK,
	98	(value << SC27XX_DUTY_SHIFT) \|
	99	SC27XX_MOD_MASK);
	100	if (err)
	101	return err;
	102
	103	return regmap_update_bits(regmap, ctrl_base,
	104	(SC27XX_LED_RUN \| SC27XX_LED_TYPE) << ctrl_shift,
	105	(SC27XX_LED_RUN \| SC27XX_LED_TYPE) << ctrl_shift);
	106	}
	107
	108	static int sc27xx_led_disable(struct sc27xx_led *leds)
	109	{
	110	struct regmap *regmap = leds->priv->regmap;
111	u32 ctrl_base = leds->priv->base + SC27XX_LEDS_CTRL;
112	u8 ctrl_shift = SC27XX_CTRL_SHIFT * leds->line;
113
114	return regmap_update_bits(regmap, ctrl_base,
115	(SC27XX_LED_RUN \| SC27XX_LED_TYPE) << ctrl_shift, 0);
116	}
117
118	static int sc27xx_led_set(struct led_classdev *ldev, enum led_brightness value)
119	{
120	struct sc27xx_led *leds = to_sc27xx_led(ldev);
121	int err;
122
123	mutex_lock(&leds->priv->lock);
124
125	if (value == LED_OFF)
126	err = sc27xx_led_disable(leds);
127	else
128	err = sc27xx_led_enable(leds, value);
129
130	mutex_unlock(&leds->priv->lock);
131
132	return err;
133	}
134
8dbac65f BW	135	static void sc27xx_led_clamp_align_delta_t(u32 *delta_t)
	136	{
	137	u32 v, offset, t = *delta_t;
	138
	139	v = t + SC27XX_LEDS_STEP / 2;
	140	v = clamp_t(u32, v, SC27XX_DELTA_T_MIN, SC27XX_DELTA_T_MAX);
	141	offset = v - SC27XX_DELTA_T_MIN;
	142	offset = SC27XX_LEDS_STEP * (offset / SC27XX_LEDS_STEP);
	143
	144	*delta_t = SC27XX_DELTA_T_MIN + offset;
	145	}
	146
	147	static int sc27xx_led_pattern_clear(struct led_classdev *ldev)
	148	{
	149	struct sc27xx_led *leds = to_sc27xx_led(ldev);
	150	struct regmap *regmap = leds->priv->regmap;
	151	u32 base = sc27xx_led_get_offset(leds);
	152	u32 ctrl_base = leds->priv->base + SC27XX_LEDS_CTRL;
	153	u8 ctrl_shift = SC27XX_CTRL_SHIFT * leds->line;
	154	int err;
	155
	156	mutex_lock(&leds->priv->lock);
	157
	158	/* Reset the rise, high, fall and low time to zero. */
	159	regmap_write(regmap, base + SC27XX_LEDS_CURVE0, 0);
	160	regmap_write(regmap, base + SC27XX_LEDS_CURVE1, 0);
	161
	162	err = regmap_update_bits(regmap, ctrl_base,
	163	(SC27XX_LED_RUN \| SC27XX_LED_TYPE) << ctrl_shift, 0);
	164
	165	ldev->brightness = LED_OFF;
	166
	167	mutex_unlock(&leds->priv->lock);
	168
	169	return err;
	170	}
	171
	172	static int sc27xx_led_pattern_set(struct led_classdev *ldev,
	173	struct led_pattern *pattern,
	174	u32 len, int repeat)
	175	{
	176	struct sc27xx_led *leds = to_sc27xx_led(ldev);
	177	u32 base = sc27xx_led_get_offset(leds);
	178	u32 ctrl_base = leds->priv->base + SC27XX_LEDS_CTRL;
	179	u8 ctrl_shift = SC27XX_CTRL_SHIFT * leds->line;
	180	struct regmap *regmap = leds->priv->regmap;
	181	int err;
	182
	183	/*
	184	* Must contain 4 tuples to configure the rise time, high time, fall
	185	* time and low time to enable the breathing mode.
	186	*/
	187	if (len != SC27XX_LEDS_PATTERN_CNT)
	188	return -EINVAL;
	189
	190	mutex_lock(&leds->priv->lock);
	191
	192	sc27xx_led_clamp_align_delta_t(&pattern[0].delta_t);
	193	err = regmap_update_bits(regmap, base + SC27XX_LEDS_CURVE0,
	194	SC27XX_CURVE_L_MASK,
	195	pattern[0].delta_t / SC27XX_LEDS_STEP);
	196	if (err)
	197	goto out;
	198
199	sc27xx_led_clamp_align_delta_t(&pattern[1].delta_t);
200	err = regmap_update_bits(regmap, base + SC27XX_LEDS_CURVE1,
201	SC27XX_CURVE_L_MASK,
202	pattern[1].delta_t / SC27XX_LEDS_STEP);
203	if (err)
204	goto out;
205
206	sc27xx_led_clamp_align_delta_t(&pattern[2].delta_t);
207	err = regmap_update_bits(regmap, base + SC27XX_LEDS_CURVE0,
208	SC27XX_CURVE_H_MASK,
209	(pattern[2].delta_t / SC27XX_LEDS_STEP) <<
210	SC27XX_CURVE_SHIFT);
211	if (err)
212	goto out;
213
214	sc27xx_led_clamp_align_delta_t(&pattern[3].delta_t);
215	err = regmap_update_bits(regmap, base + SC27XX_LEDS_CURVE1,
216	SC27XX_CURVE_H_MASK,
217	(pattern[3].delta_t / SC27XX_LEDS_STEP) <<
218	SC27XX_CURVE_SHIFT);
219	if (err)
220	goto out;
221
222	err = regmap_update_bits(regmap, base + SC27XX_LEDS_DUTY,
223	SC27XX_DUTY_MASK,
224	(pattern[1].brightness << SC27XX_DUTY_SHIFT) \|
225	SC27XX_MOD_MASK);
226	if (err)
227	goto out;
228
229	/* Enable the LED breathing mode */
230	err = regmap_update_bits(regmap, ctrl_base,
231	SC27XX_LED_RUN << ctrl_shift,
232	SC27XX_LED_RUN << ctrl_shift);
233	if (!err)
234	ldev->brightness = pattern[1].brightness;
235
236	out:
237	mutex_unlock(&leds->priv->lock);
238
239	return err;
240	}
241
e081c49e BW	242	static int sc27xx_led_register(struct device dev, struct sc27xx_led_priv priv)
	243	{
	244	int i, err;
	245
	246	err = sc27xx_led_init(priv->regmap);
	247	if (err)
	248	return err;
	249
	250	for (i = 0; i < SC27XX_LEDS_MAX; i++) {
	251	struct sc27xx_led *led = &priv->leds[i];
	252
	253	if (!led->active)
	254	continue;
	255
	256	led->line = i;
	257	led->priv = priv;
	258	led->ldev.name = led->name;
	259	led->ldev.brightness_set_blocking = sc27xx_led_set;
8dbac65f BW	260	led->ldev.pattern_set = sc27xx_led_pattern_set;
	261	led->ldev.pattern_clear = sc27xx_led_pattern_clear;
	262	led->ldev.default_trigger = "pattern";
e081c49e BW	263
	264	err = devm_led_classdev_register(dev, &led->ldev);
	265	if (err)
	266	return err;
	267	}
	268
	269	return 0;
	270	}
	271
	272	static int sc27xx_led_probe(struct platform_device *pdev)
	273	{
	274	struct device *dev = &pdev->dev;
	275	struct device_node np = dev->of_node, child;
	276	struct sc27xx_led_priv *priv;
	277	const char *str;
	278	u32 base, count, reg;
	279	int err;
	280
	281	count = of_get_child_count(np);
	282	if (!count \|\| count > SC27XX_LEDS_MAX)
	283	return -EINVAL;
	284
	285	err = of_property_read_u32(np, "reg", &base);
	286	if (err) {
	287	dev_err(dev, "fail to get reg of property\n");
	288	return err;
	289	}
	290
	291	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
	292	if (!priv)
	293	return -ENOMEM;
	294
	295	platform_set_drvdata(pdev, priv);
	296	mutex_init(&priv->lock);
	297	priv->base = base;
	298	priv->regmap = dev_get_regmap(dev->parent, NULL);
43926c27 WY	299	if (!priv->regmap) {
43926c27 WY	300	err = -ENODEV;
e081c49e BW	301	dev_err(dev, "failed to get regmap: %d\n", err);
	302	return err;
	303	}
	304
	305	for_each_child_of_node(np, child) {
	306	err = of_property_read_u32(child, "reg", &reg);
	307	if (err) {
	308	of_node_put(child);
	309	mutex_destroy(&priv->lock);
	310	return err;
	311	}
	312
	313	if (reg >= SC27XX_LEDS_MAX \|\| priv->leds[reg].active) {
	314	of_node_put(child);
	315	mutex_destroy(&priv->lock);
	316	return -EINVAL;
	317	}
	318
	319	priv->leds[reg].active = true;
	320
	321	err = of_property_read_string(child, "label", &str);
	322	if (err)
	323	snprintf(priv->leds[reg].name, LED_MAX_NAME_SIZE,
	324	"sc27xx::");
	325	else
	326	snprintf(priv->leds[reg].name, LED_MAX_NAME_SIZE,
	327	"sc27xx:%s", str);
	328	}
	329
	330	err = sc27xx_led_register(dev, priv);
	331	if (err)
	332	mutex_destroy(&priv->lock);
	333
	334	return err;
	335	}
	336
	337	static int sc27xx_led_remove(struct platform_device *pdev)
	338	{
	339	struct sc27xx_led_priv *priv = platform_get_drvdata(pdev);
	340
	341	mutex_destroy(&priv->lock);
	342	return 0;
	343	}
	344
	345	static const struct of_device_id sc27xx_led_of_match[] = {
	346	{ .compatible = "sprd,sc2731-bltc", },
	347	{ }
	348	};
	349	MODULE_DEVICE_TABLE(of, sc27xx_led_of_match);
	350
	351	static struct platform_driver sc27xx_led_driver = {
	352	.driver = {
	353	.name = "sprd-bltc",
	354	.of_match_table = sc27xx_led_of_match,
	355	},
	356	.probe = sc27xx_led_probe,
	357	.remove = sc27xx_led_remove,
	358	};
	359
	360	module_platform_driver(sc27xx_led_driver);
	361
	362	MODULE_DESCRIPTION("Spreadtrum SC27xx breathing light controller driver");
	363	MODULE_AUTHOR("Xiaotong Lu <xiaotong.lu@spreadtrum.com>");
8dbac65f	364	MODULE_AUTHOR("Baolin Wang <baolin.wang@linaro.org>");
e081c49e	365	MODULE_LICENSE("GPL v2");