[linux-2.6-block.git] / drivers / video / backlight / 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/backlight.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/regmap.h>

/* From DT binding */
#define PM8941_WLED_DEFAULT_BRIGHTNESS		2048

#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 {
	const char *name;
	struct regmap *regmap;
	u16 addr;

	struct pm8941_wled_config cfg;
};

static int pm8941_wled_update_status(struct backlight_device *bl)
{
	struct pm8941_wled *wled = bl_get_data(bl);
	u16 val = bl->props.brightness;
	u8 ctrl = 0;
	int rc;
	int i;

	if (bl->props.power != FB_BLANK_UNBLANK ||
	    bl->props.fb_blank != FB_BLANK_UNBLANK ||
	    bl->props.state & BL_CORE_FBBLANK)
		val = 0;

	if (val != 0)
		ctrl = PM8941_WLED_REG_MOD_EN_BIT;

	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 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->name);
	if (rc)
		wled->name = dev->of_node->name;

	*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 const struct backlight_ops pm8941_wled_ops = {
	.update_status = pm8941_wled_update_status,
};

static int pm8941_wled_probe(struct platform_device *pdev)
{
	struct backlight_properties props;
	struct backlight_device *bl;
	struct pm8941_wled *wled;
	struct regmap *regmap;
	u32 val;
	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;

	val = PM8941_WLED_DEFAULT_BRIGHTNESS;
	of_property_read_u32(pdev->dev.of_node, "default-brightness", &val);

	memset(&props, 0, sizeof(struct backlight_properties));
	props.type = BACKLIGHT_RAW;
	props.brightness = val;
	props.max_brightness = PM8941_WLED_REG_VAL_MAX;
	bl = devm_backlight_device_register(&pdev->dev, wled->name,
					    &pdev->dev, wled,
					    &pm8941_wled_ops, &props);
	return PTR_ERR_OR_ZERO(bl);
};

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