[deliverable/linux.git] / drivers / leds / leds-pm8941-wled.c

/* Copyright (c) 2015, Sony Mobile Communications, AB.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 and
 * only version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#include <linux/kernel.h>
#include <linux/leds.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/regmap.h>

#define PM8941_WLED_REG_VAL_BASE		0x40
#define  PM8941_WLED_REG_VAL_MAX		0xFFF

#define PM8941_WLED_REG_MOD_EN			0x46
#define  PM8941_WLED_REG_MOD_EN_BIT		BIT(7)
#define  PM8941_WLED_REG_MOD_EN_MASK		BIT(7)

#define PM8941_WLED_REG_SYNC			0x47
#define  PM8941_WLED_REG_SYNC_MASK		0x07
#define  PM8941_WLED_REG_SYNC_LED1		BIT(0)
#define  PM8941_WLED_REG_SYNC_LED2		BIT(1)
#define  PM8941_WLED_REG_SYNC_LED3		BIT(2)
#define  PM8941_WLED_REG_SYNC_ALL		0x07
#define  PM8941_WLED_REG_SYNC_CLEAR		0x00

#define PM8941_WLED_REG_FREQ			0x4c
#define  PM8941_WLED_REG_FREQ_MASK		0x0f

#define PM8941_WLED_REG_OVP			0x4d
#define  PM8941_WLED_REG_OVP_MASK		0x03

#define PM8941_WLED_REG_BOOST			0x4e
#define  PM8941_WLED_REG_BOOST_MASK		0x07

#define PM8941_WLED_REG_SINK			0x4f
#define  PM8941_WLED_REG_SINK_MASK		0xe0
#define  PM8941_WLED_REG_SINK_SHFT		0x05

/* Per-'string' registers below */
#define PM8941_WLED_REG_STR_OFFSET		0x10

#define PM8941_WLED_REG_STR_MOD_EN_BASE		0x60
#define  PM8941_WLED_REG_STR_MOD_MASK		BIT(7)
#define  PM8941_WLED_REG_STR_MOD_EN		BIT(7)

#define PM8941_WLED_REG_STR_SCALE_BASE		0x62
#define  PM8941_WLED_REG_STR_SCALE_MASK		0x1f

#define PM8941_WLED_REG_STR_MOD_SRC_BASE	0x63
#define  PM8941_WLED_REG_STR_MOD_SRC_MASK	0x01
#define  PM8941_WLED_REG_STR_MOD_SRC_INT	0x00
#define  PM8941_WLED_REG_STR_MOD_SRC_EXT	0x01

#define PM8941_WLED_REG_STR_CABC_BASE		0x66
#define  PM8941_WLED_REG_STR_CABC_MASK		BIT(7)
#define  PM8941_WLED_REG_STR_CABC_EN		BIT(7)

struct pm8941_wled_config {
	u32 i_boost_limit;
	u32 ovp;
	u32 switch_freq;
	u32 num_strings;
	u32 i_limit;
	bool cs_out_en;
	bool ext_gen;
	bool cabc_en;
};

struct pm8941_wled {
	struct regmap *regmap;
	u16 addr;

	struct led_classdev cdev;

	struct pm8941_wled_config cfg;
};

static int pm8941_wled_set(struct led_classdev *cdev,
			   enum led_brightness value)
{
	struct pm8941_wled *wled;
	u8 ctrl = 0;
	u16 val;
	int rc;
	int i;

	wled = container_of(cdev, struct pm8941_wled, cdev);

	if (value != 0)
		ctrl = PM8941_WLED_REG_MOD_EN_BIT;

	val = value * PM8941_WLED_REG_VAL_MAX / LED_FULL;

	rc = regmap_update_bits(wled->regmap,
			wled->addr + PM8941_WLED_REG_MOD_EN,
			PM8941_WLED_REG_MOD_EN_MASK, ctrl);
	if (rc)
		return rc;

	for (i = 0; i < wled->cfg.num_strings; ++i) {
		u8 v[2] = { val & 0xff, (val >> 8) & 0xf };

		rc = regmap_bulk_write(wled->regmap,
				wled->addr + PM8941_WLED_REG_VAL_BASE + 2 * i,
				v, 2);
		if (rc)
			return rc;
	}

	rc = regmap_update_bits(wled->regmap,
			wled->addr + PM8941_WLED_REG_SYNC,
			PM8941_WLED_REG_SYNC_MASK, PM8941_WLED_REG_SYNC_ALL);
	if (rc)
		return rc;

	rc = regmap_update_bits(wled->regmap,
			wled->addr + PM8941_WLED_REG_SYNC,
			PM8941_WLED_REG_SYNC_MASK, PM8941_WLED_REG_SYNC_CLEAR);
	return rc;
}

static void pm8941_wled_set_brightness(struct led_classdev *cdev,
				       enum led_brightness value)
{
	if (pm8941_wled_set(cdev, value)) {
		dev_err(cdev->dev, "Unable to set brightness\n");
		return;
	}
	cdev->brightness = value;
}

static int pm8941_wled_setup(struct pm8941_wled *wled)
{
	int rc;
	int i;

	rc = regmap_update_bits(wled->regmap,
			wled->addr + PM8941_WLED_REG_OVP,
			PM8941_WLED_REG_OVP_MASK, wled->cfg.ovp);
	if (rc)
		return rc;

	rc = regmap_update_bits(wled->regmap,
			wled->addr + PM8941_WLED_REG_BOOST,
			PM8941_WLED_REG_BOOST_MASK, wled->cfg.i_boost_limit);
	if (rc)
		return rc;

	rc = regmap_update_bits(wled->regmap,
			wled->addr + PM8941_WLED_REG_FREQ,
			PM8941_WLED_REG_FREQ_MASK, wled->cfg.switch_freq);
	if (rc)
		return rc;

	if (wled->cfg.cs_out_en) {
		u8 all = (BIT(wled->cfg.num_strings) - 1)
				<< PM8941_WLED_REG_SINK_SHFT;

		rc = regmap_update_bits(wled->regmap,
				wled->addr + PM8941_WLED_REG_SINK,
				PM8941_WLED_REG_SINK_MASK, all);
		if (rc)
			return rc;
	}

	for (i = 0; i < wled->cfg.num_strings; ++i) {
		u16 addr = wled->addr + PM8941_WLED_REG_STR_OFFSET * i;

		rc = regmap_update_bits(wled->regmap,
				addr + PM8941_WLED_REG_STR_MOD_EN_BASE,
				PM8941_WLED_REG_STR_MOD_MASK,
				PM8941_WLED_REG_STR_MOD_EN);
		if (rc)
			return rc;

		if (wled->cfg.ext_gen) {
			rc = regmap_update_bits(wled->regmap,
					addr + PM8941_WLED_REG_STR_MOD_SRC_BASE,
					PM8941_WLED_REG_STR_MOD_SRC_MASK,
					PM8941_WLED_REG_STR_MOD_SRC_EXT);
			if (rc)
				return rc;
		}

		rc = regmap_update_bits(wled->regmap,
				addr + PM8941_WLED_REG_STR_SCALE_BASE,
				PM8941_WLED_REG_STR_SCALE_MASK,
				wled->cfg.i_limit);
		if (rc)
			return rc;

		rc = regmap_update_bits(wled->regmap,
				addr + PM8941_WLED_REG_STR_CABC_BASE,
				PM8941_WLED_REG_STR_CABC_MASK,
				wled->cfg.cabc_en ?
					PM8941_WLED_REG_STR_CABC_EN : 0);
		if (rc)
			return rc;
	}

	return 0;
}

static const struct pm8941_wled_config pm8941_wled_config_defaults = {
	.i_boost_limit = 3,
	.i_limit = 20,
	.ovp = 2,
	.switch_freq = 5,
	.num_strings = 0,
	.cs_out_en = false,
	.ext_gen = false,
	.cabc_en = false,
};

struct pm8941_wled_var_cfg {
	const u32 *values;
	u32 (*fn)(u32);
	int size;
};

static const u32 pm8941_wled_i_boost_limit_values[] = {
	105, 385, 525, 805, 980, 1260, 1400, 1680,
};

static const struct pm8941_wled_var_cfg pm8941_wled_i_boost_limit_cfg = {
	.values = pm8941_wled_i_boost_limit_values,
	.size = ARRAY_SIZE(pm8941_wled_i_boost_limit_values),
};

static const u32 pm8941_wled_ovp_values[] = {
	35, 32, 29, 27,
};

static const struct pm8941_wled_var_cfg pm8941_wled_ovp_cfg = {
	.values = pm8941_wled_ovp_values,
	.size = ARRAY_SIZE(pm8941_wled_ovp_values),
};

static u32 pm8941_wled_num_strings_values_fn(u32 idx)
{
	return idx + 1;
}

static const struct pm8941_wled_var_cfg pm8941_wled_num_strings_cfg = {
	.fn = pm8941_wled_num_strings_values_fn,
	.size = 3,
};

static u32 pm8941_wled_switch_freq_values_fn(u32 idx)
{
	return 19200 / (2 * (1 + idx));
}

static const struct pm8941_wled_var_cfg pm8941_wled_switch_freq_cfg = {
	.fn = pm8941_wled_switch_freq_values_fn,
	.size = 16,
};

static const struct pm8941_wled_var_cfg pm8941_wled_i_limit_cfg = {
	.size = 26,
};

static u32 pm8941_wled_values(const struct pm8941_wled_var_cfg *cfg, u32 idx)
{
	if (idx >= cfg->size)
		return UINT_MAX;
	if (cfg->fn)
		return cfg->fn(idx);
	if (cfg->values)
		return cfg->values[idx];
	return idx;
}

static int pm8941_wled_configure(struct pm8941_wled *wled, struct device *dev)
{
	struct pm8941_wled_config *cfg = &wled->cfg;
	u32 val;
	int rc;
	u32 c;
	int i;
	int j;

	const struct {
		const char *name;
		u32 *val_ptr;
		const struct pm8941_wled_var_cfg *cfg;
	} u32_opts[] = {
		{
			"qcom,current-boost-limit",
			&cfg->i_boost_limit,
			.cfg = &pm8941_wled_i_boost_limit_cfg,
		},
		{
			"qcom,current-limit",
			&cfg->i_limit,
			.cfg = &pm8941_wled_i_limit_cfg,
		},
		{
			"qcom,ovp",
			&cfg->ovp,
			.cfg = &pm8941_wled_ovp_cfg,
		},
		{
			"qcom,switching-freq",
			&cfg->switch_freq,
			.cfg = &pm8941_wled_switch_freq_cfg,
		},
		{
			"qcom,num-strings",
			&cfg->num_strings,
			.cfg = &pm8941_wled_num_strings_cfg,
		},
	};
	const struct {
		const char *name;
		bool *val_ptr;
	} bool_opts[] = {
		{ "qcom,cs-out", &cfg->cs_out_en, },
		{ "qcom,ext-gen", &cfg->ext_gen, },
		{ "qcom,cabc", &cfg->cabc_en, },
	};

	rc = of_property_read_u32(dev->of_node, "reg", &val);
	if (rc || val > 0xffff) {
		dev_err(dev, "invalid IO resources\n");
		return rc ? rc : -EINVAL;
	}
	wled->addr = val;

	rc = of_property_read_string(dev->of_node, "label", &wled->cdev.name);
	if (rc)
		wled->cdev.name = dev->of_node->name;

	wled->cdev.default_trigger = of_get_property(dev->of_node,
			"linux,default-trigger", NULL);

	*cfg = pm8941_wled_config_defaults;
	for (i = 0; i < ARRAY_SIZE(u32_opts); ++i) {
		rc = of_property_read_u32(dev->of_node, u32_opts[i].name, &val);
		if (rc == -EINVAL) {
			continue;
		} else if (rc) {
			dev_err(dev, "error reading '%s'\n", u32_opts[i].name);
			return rc;
		}

		c = UINT_MAX;
		for (j = 0; c != val; j++) {
			c = pm8941_wled_values(u32_opts[i].cfg, j);
			if (c == UINT_MAX) {
				dev_err(dev, "invalid value for '%s'\n",
					u32_opts[i].name);
				return -EINVAL;
			}
		}

		dev_dbg(dev, "'%s' = %u\n", u32_opts[i].name, c);
		*u32_opts[i].val_ptr = j;
	}

	for (i = 0; i < ARRAY_SIZE(bool_opts); ++i) {
		if (of_property_read_bool(dev->of_node, bool_opts[i].name))
			*bool_opts[i].val_ptr = true;
	}

	cfg->num_strings = cfg->num_strings + 1;

	return 0;
}

static int pm8941_wled_probe(struct platform_device *pdev)
{
	struct pm8941_wled *wled;
	struct regmap *regmap;
	int rc;

	regmap = dev_get_regmap(pdev->dev.parent, NULL);
	if (!regmap) {
		dev_err(&pdev->dev, "Unable to get regmap\n");
		return -EINVAL;
	}

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

	wled->regmap = regmap;

	rc = pm8941_wled_configure(wled, &pdev->dev);
	if (rc)
		return rc;

	rc = pm8941_wled_setup(wled);
	if (rc)
		return rc;

	wled->cdev.brightness_set = pm8941_wled_set_brightness;

	rc = devm_led_classdev_register(&pdev->dev, &wled->cdev);
	if (rc)
		return rc;

	platform_set_drvdata(pdev, wled);

	return 0;
};

static const struct of_device_id pm8941_wled_match_table[] = {
	{ .compatible = "qcom,pm8941-wled" },
	{}
};
MODULE_DEVICE_TABLE(of, pm8941_wled_match_table);

static struct platform_driver pm8941_wled_driver = {
	.probe = pm8941_wled_probe,
	.driver	= {
		.name = "pm8941-wled",
		.of_match_table	= pm8941_wled_match_table,
	},
};

module_platform_driver(pm8941_wled_driver);

MODULE_DESCRIPTION("pm8941 wled driver");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:pm8941-wled");
Commit	Line	Data
93c64f1e CC	1	/* Copyright (c) 2015, Sony Mobile Communications, AB.
	2	*
	3	* This program is free software; you can redistribute it and/or modify
	4	* it under the terms of the GNU General Public License version 2 and
	5	* only version 2 as published by the Free Software Foundation.
	6	*
	7	* This program is distributed in the hope that it will be useful,
	8	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	9	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	10	* GNU General Public License for more details.
	11	*/
	12
	13	#include <linux/kernel.h>
	14	#include <linux/leds.h>
	15	#include <linux/module.h>
	16	#include <linux/of.h>
	17	#include <linux/of_device.h>
	18	#include <linux/regmap.h>
	19
	20	#define PM8941_WLED_REG_VAL_BASE 0x40
	21	#define PM8941_WLED_REG_VAL_MAX 0xFFF
	22
	23	#define PM8941_WLED_REG_MOD_EN 0x46
	24	#define PM8941_WLED_REG_MOD_EN_BIT BIT(7)
	25	#define PM8941_WLED_REG_MOD_EN_MASK BIT(7)
	26
	27	#define PM8941_WLED_REG_SYNC 0x47
	28	#define PM8941_WLED_REG_SYNC_MASK 0x07
	29	#define PM8941_WLED_REG_SYNC_LED1 BIT(0)
	30	#define PM8941_WLED_REG_SYNC_LED2 BIT(1)
	31	#define PM8941_WLED_REG_SYNC_LED3 BIT(2)
	32	#define PM8941_WLED_REG_SYNC_ALL 0x07
	33	#define PM8941_WLED_REG_SYNC_CLEAR 0x00
	34
	35	#define PM8941_WLED_REG_FREQ 0x4c
	36	#define PM8941_WLED_REG_FREQ_MASK 0x0f
	37
	38	#define PM8941_WLED_REG_OVP 0x4d
	39	#define PM8941_WLED_REG_OVP_MASK 0x03
	40
	41	#define PM8941_WLED_REG_BOOST 0x4e
	42	#define PM8941_WLED_REG_BOOST_MASK 0x07
	43
	44	#define PM8941_WLED_REG_SINK 0x4f
	45	#define PM8941_WLED_REG_SINK_MASK 0xe0
	46	#define PM8941_WLED_REG_SINK_SHFT 0x05
	47
	48	/* Per-'string' registers below */
	49	#define PM8941_WLED_REG_STR_OFFSET 0x10
	50
	51	#define PM8941_WLED_REG_STR_MOD_EN_BASE 0x60
	52	#define PM8941_WLED_REG_STR_MOD_MASK BIT(7)
	53	#define PM8941_WLED_REG_STR_MOD_EN BIT(7)
	54
	55	#define PM8941_WLED_REG_STR_SCALE_BASE 0x62
	56	#define PM8941_WLED_REG_STR_SCALE_MASK 0x1f
	57
	58	#define PM8941_WLED_REG_STR_MOD_SRC_BASE 0x63
	59	#define PM8941_WLED_REG_STR_MOD_SRC_MASK 0x01
	60	#define PM8941_WLED_REG_STR_MOD_SRC_INT 0x00
	61	#define PM8941_WLED_REG_STR_MOD_SRC_EXT 0x01
	62
	63	#define PM8941_WLED_REG_STR_CABC_BASE 0x66
	64	#define PM8941_WLED_REG_STR_CABC_MASK BIT(7)
65	#define PM8941_WLED_REG_STR_CABC_EN BIT(7)
66
67	struct pm8941_wled_config {
68	u32 i_boost_limit;
69	u32 ovp;
70	u32 switch_freq;
71	u32 num_strings;
72	u32 i_limit;
73	bool cs_out_en;
74	bool ext_gen;
75	bool cabc_en;
76	};
77
78	struct pm8941_wled {
79	struct regmap *regmap;
80	u16 addr;
81
82	struct led_classdev cdev;
83
84	struct pm8941_wled_config cfg;
85	};
86
87	static int pm8941_wled_set(struct led_classdev *cdev,
88	enum led_brightness value)
89	{
90	struct pm8941_wled *wled;
91	u8 ctrl = 0;
92	u16 val;
93	int rc;
94	int i;
95
96	wled = container_of(cdev, struct pm8941_wled, cdev);
97
98	if (value != 0)
99	ctrl = PM8941_WLED_REG_MOD_EN_BIT;
100
101	val = value * PM8941_WLED_REG_VAL_MAX / LED_FULL;
102
103	rc = regmap_update_bits(wled->regmap,
104	wled->addr + PM8941_WLED_REG_MOD_EN,
105	PM8941_WLED_REG_MOD_EN_MASK, ctrl);
106	if (rc)
107	return rc;
108
109	for (i = 0; i < wled->cfg.num_strings; ++i) {
110	u8 v[2] = { val & 0xff, (val >> 8) & 0xf };
111
112	rc = regmap_bulk_write(wled->regmap,
113	wled->addr + PM8941_WLED_REG_VAL_BASE + 2 * i,
114	v, 2);
115	if (rc)
116	return rc;
117	}
118
119	rc = regmap_update_bits(wled->regmap,
120	wled->addr + PM8941_WLED_REG_SYNC,
121	PM8941_WLED_REG_SYNC_MASK, PM8941_WLED_REG_SYNC_ALL);
122	if (rc)
123	return rc;
124
125	rc = regmap_update_bits(wled->regmap,
126	wled->addr + PM8941_WLED_REG_SYNC,
127	PM8941_WLED_REG_SYNC_MASK, PM8941_WLED_REG_SYNC_CLEAR);
128	return rc;
129	}
130
131	static void pm8941_wled_set_brightness(struct led_classdev *cdev,
132	enum led_brightness value)
133	{
134	if (pm8941_wled_set(cdev, value)) {
135	dev_err(cdev->dev, "Unable to set brightness\n");
136	return;
137	}
138	cdev->brightness = value;
139	}
140
141	static int pm8941_wled_setup(struct pm8941_wled *wled)
142	{
143	int rc;
144	int i;
145
146	rc = regmap_update_bits(wled->regmap,
147	wled->addr + PM8941_WLED_REG_OVP,
148	PM8941_WLED_REG_OVP_MASK, wled->cfg.ovp);
149	if (rc)
150	return rc;
151
152	rc = regmap_update_bits(wled->regmap,
153	wled->addr + PM8941_WLED_REG_BOOST,
154	PM8941_WLED_REG_BOOST_MASK, wled->cfg.i_boost_limit);
155	if (rc)
156	return rc;
157
158	rc = regmap_update_bits(wled->regmap,
159	wled->addr + PM8941_WLED_REG_FREQ,
160	PM8941_WLED_REG_FREQ_MASK, wled->cfg.switch_freq);
161	if (rc)
162	return rc;
163
164	if (wled->cfg.cs_out_en) {
165	u8 all = (BIT(wled->cfg.num_strings) - 1)
166	<< PM8941_WLED_REG_SINK_SHFT;
167
168	rc = regmap_update_bits(wled->regmap,
169	wled->addr + PM8941_WLED_REG_SINK,
170	PM8941_WLED_REG_SINK_MASK, all);
171	if (rc)
172	return rc;
173	}
174
175	for (i = 0; i < wled->cfg.num_strings; ++i) {
176	u16 addr = wled->addr + PM8941_WLED_REG_STR_OFFSET * i;
177
178	rc = regmap_update_bits(wled->regmap,
179	addr + PM8941_WLED_REG_STR_MOD_EN_BASE,
180	PM8941_WLED_REG_STR_MOD_MASK,
181	PM8941_WLED_REG_STR_MOD_EN);
182	if (rc)
183	return rc;
184
185	if (wled->cfg.ext_gen) {
186	rc = regmap_update_bits(wled->regmap,
187	addr + PM8941_WLED_REG_STR_MOD_SRC_BASE,
188	PM8941_WLED_REG_STR_MOD_SRC_MASK,
189	PM8941_WLED_REG_STR_MOD_SRC_EXT);
190	if (rc)
191	return rc;
192	}
193
194	rc = regmap_update_bits(wled->regmap,
195	addr + PM8941_WLED_REG_STR_SCALE_BASE,
196	PM8941_WLED_REG_STR_SCALE_MASK,
197	wled->cfg.i_limit);
198	if (rc)
199	return rc;
200
201	rc = regmap_update_bits(wled->regmap,
202	addr + PM8941_WLED_REG_STR_CABC_BASE,
203	PM8941_WLED_REG_STR_CABC_MASK,
204	wled->cfg.cabc_en ?
205	PM8941_WLED_REG_STR_CABC_EN : 0);
206	if (rc)
207	return rc;
208	}
209
210	return 0;
211	}
212
213	static const struct pm8941_wled_config pm8941_wled_config_defaults = {
214	.i_boost_limit = 3,
215	.i_limit = 20,
216	.ovp = 2,
217	.switch_freq = 5,
218	.num_strings = 0,
219	.cs_out_en = false,
220	.ext_gen = false,
221	.cabc_en = false,
222	};
223
224	struct pm8941_wled_var_cfg {
225	const u32 *values;
226	u32 (*fn)(u32);
227	int size;
228	};
229
230	static const u32 pm8941_wled_i_boost_limit_values[] = {
231	105, 385, 525, 805, 980, 1260, 1400, 1680,
232	};
233
234	static const struct pm8941_wled_var_cfg pm8941_wled_i_boost_limit_cfg = {
235	.values = pm8941_wled_i_boost_limit_values,
236	.size = ARRAY_SIZE(pm8941_wled_i_boost_limit_values),
237	};
238
239	static const u32 pm8941_wled_ovp_values[] = {
240	35, 32, 29, 27,
241	};
242
243	static const struct pm8941_wled_var_cfg pm8941_wled_ovp_cfg = {
244	.values = pm8941_wled_ovp_values,
245	.size = ARRAY_SIZE(pm8941_wled_ovp_values),
246	};
247
248	static u32 pm8941_wled_num_strings_values_fn(u32 idx)
249	{
250	return idx + 1;
251	}
252
253	static const struct pm8941_wled_var_cfg pm8941_wled_num_strings_cfg = {
254	.fn = pm8941_wled_num_strings_values_fn,
255	.size = 3,
256	};
257
258	static u32 pm8941_wled_switch_freq_values_fn(u32 idx)
259	{
260	return 19200 / (2 * (1 + idx));
261	}
262
263	static const struct pm8941_wled_var_cfg pm8941_wled_switch_freq_cfg = {
264	.fn = pm8941_wled_switch_freq_values_fn,
265	.size = 16,
266	};
267
268	static const struct pm8941_wled_var_cfg pm8941_wled_i_limit_cfg = {
269	.size = 26,
270	};
271
272	static u32 pm8941_wled_values(const struct pm8941_wled_var_cfg *cfg, u32 idx)
273	{
274	if (idx >= cfg->size)
275	return UINT_MAX;
276	if (cfg->fn)
277	return cfg->fn(idx);
278	if (cfg->values)
279	return cfg->values[idx];
280	return idx;
281	}
282
283	static int pm8941_wled_configure(struct pm8941_wled wled, struct device dev)
284	{
285	struct pm8941_wled_config *cfg = &wled->cfg;
286	u32 val;
287	int rc;
288	u32 c;
289	int i;
290	int j;
291
292	const struct {
293	const char *name;
294	u32 *val_ptr;
295	const struct pm8941_wled_var_cfg *cfg;
296	} u32_opts[] = {
297	{
298	"qcom,current-boost-limit",
299	&cfg->i_boost_limit,
300	.cfg = &pm8941_wled_i_boost_limit_cfg,
301	},
302	{
303	"qcom,current-limit",
304	&cfg->i_limit,
305	.cfg = &pm8941_wled_i_limit_cfg,
306	},
307	{
308	"qcom,ovp",
309	&cfg->ovp,
310	.cfg = &pm8941_wled_ovp_cfg,
311	},
312	{
313	"qcom,switching-freq",
314	&cfg->switch_freq,
315	.cfg = &pm8941_wled_switch_freq_cfg,
316	},
317	{
318	"qcom,num-strings",
319	&cfg->num_strings,
320	.cfg = &pm8941_wled_num_strings_cfg,
321	},
322	};
323	const struct {
324	const char *name;
325	bool *val_ptr;
326	} bool_opts[] = {
327	{ "qcom,cs-out", &cfg->cs_out_en, },
328	{ "qcom,ext-gen", &cfg->ext_gen, },
329	{ "qcom,cabc", &cfg->cabc_en, },
330	};
331
332	rc = of_property_read_u32(dev->of_node, "reg", &val);
333	if (rc \|\| val > 0xffff) {
334	dev_err(dev, "invalid IO resources\n");
335	return rc ? rc : -EINVAL;
336	}
337	wled->addr = val;
338
339	rc = of_property_read_string(dev->of_node, "label", &wled->cdev.name);
340	if (rc)
341	wled->cdev.name = dev->of_node->name;
342
343	wled->cdev.default_trigger = of_get_property(dev->of_node,
344	"linux,default-trigger", NULL);
345
346	*cfg = pm8941_wled_config_defaults;
347	for (i = 0; i < ARRAY_SIZE(u32_opts); ++i) {
348	rc = of_property_read_u32(dev->of_node, u32_opts[i].name, &val);
349	if (rc == -EINVAL) {
350	continue;
351	} else if (rc) {
352	dev_err(dev, "error reading '%s'\n", u32_opts[i].name);
353	return rc;
354	}
355
356	c = UINT_MAX;
357	for (j = 0; c != val; j++) {
358	c = pm8941_wled_values(u32_opts[i].cfg, j);
359	if (c == UINT_MAX) {
360	dev_err(dev, "invalid value for '%s'\n",
361	u32_opts[i].name);
362	return -EINVAL;
363	}
364	}
365
366	dev_dbg(dev, "'%s' = %u\n", u32_opts[i].name, c);
367	*u32_opts[i].val_ptr = j;
368	}
369
370	for (i = 0; i < ARRAY_SIZE(bool_opts); ++i) {
371	if (of_property_read_bool(dev->of_node, bool_opts[i].name))
372	*bool_opts[i].val_ptr = true;
373	}
374
375	cfg->num_strings = cfg->num_strings + 1;
376
377	return 0;
378	}
379
380	static int pm8941_wled_probe(struct platform_device *pdev)
381	{
382	struct pm8941_wled *wled;
383	struct regmap *regmap;
384	int rc;
385
386	regmap = dev_get_regmap(pdev->dev.parent, NULL);
387	if (!regmap) {
388	dev_err(&pdev->dev, "Unable to get regmap\n");
389	return -EINVAL;
390	}
391
392	wled = devm_kzalloc(&pdev->dev, sizeof(*wled), GFP_KERNEL);
393	if (!wled)
394	return -ENOMEM;
395
396	wled->regmap = regmap;
397
398	rc = pm8941_wled_configure(wled, &pdev->dev);
399	if (rc)
400	return rc;
401
402	rc = pm8941_wled_setup(wled);
403	if (rc)
404	return rc;
405
406	wled->cdev.brightness_set = pm8941_wled_set_brightness;
407
408	rc = devm_led_classdev_register(&pdev->dev, &wled->cdev);
409	if (rc)
410	return rc;
411
412	platform_set_drvdata(pdev, wled);
413
414	return 0;
415	};
416
417	static const struct of_device_id pm8941_wled_match_table[] = {
418	{ .compatible = "qcom,pm8941-wled" },
419	{}
420	};
421	MODULE_DEVICE_TABLE(of, pm8941_wled_match_table);
422
423	static struct platform_driver pm8941_wled_driver = {
424	.probe = pm8941_wled_probe,
425	.driver = {
426	.name = "pm8941-wled",
427	.of_match_table = pm8941_wled_match_table,
428	},
429	};
430
431	module_platform_driver(pm8941_wled_driver);
432
433	MODULE_DESCRIPTION("pm8941 wled driver");
434	MODULE_LICENSE("GPL v2");
435	MODULE_ALIAS("platform:pm8941-wled");