[mirror_ubuntu-jammy-kernel.git] / drivers / video / backlight / lm3533_bl.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * lm3533-bl.c -- LM3533 Backlight driver
 *
 * Copyright (C) 2011-2012 Texas Instruments
 *
 * Author: Johan Hovold <jhovold@gmail.com>
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/backlight.h>
#include <linux/fb.h>
#include <linux/slab.h>

#include <linux/mfd/lm3533.h>


#define LM3533_HVCTRLBANK_COUNT		2
#define LM3533_BL_MAX_BRIGHTNESS	255

#define LM3533_REG_CTRLBANK_AB_BCONF	0x1a


struct lm3533_bl {
	struct lm3533 *lm3533;
	struct lm3533_ctrlbank cb;
	struct backlight_device *bd;
	int id;
};


static inline int lm3533_bl_get_ctrlbank_id(struct lm3533_bl *bl)
{
	return bl->id;
}

static int lm3533_bl_update_status(struct backlight_device *bd)
{
	struct lm3533_bl *bl = bl_get_data(bd);

	return lm3533_ctrlbank_set_brightness(&bl->cb, backlight_get_brightness(bd));
}

static int lm3533_bl_get_brightness(struct backlight_device *bd)
{
	struct lm3533_bl *bl = bl_get_data(bd);
	u8 val;
	int ret;

	ret = lm3533_ctrlbank_get_brightness(&bl->cb, &val);
	if (ret)
		return ret;

	return val;
}

static const struct backlight_ops lm3533_bl_ops = {
	.get_brightness	= lm3533_bl_get_brightness,
	.update_status	= lm3533_bl_update_status,
};

static ssize_t show_id(struct device *dev,
				struct device_attribute *attr, char *buf)
{
	struct lm3533_bl *bl = dev_get_drvdata(dev);

	return scnprintf(buf, PAGE_SIZE, "%d\n", bl->id);
}

static ssize_t show_als_channel(struct device *dev,
				struct device_attribute *attr, char *buf)
{
	struct lm3533_bl *bl = dev_get_drvdata(dev);
	unsigned channel = lm3533_bl_get_ctrlbank_id(bl);

	return scnprintf(buf, PAGE_SIZE, "%u\n", channel);
}

static ssize_t show_als_en(struct device *dev,
				struct device_attribute *attr, char *buf)
{
	struct lm3533_bl *bl = dev_get_drvdata(dev);
	int ctrlbank = lm3533_bl_get_ctrlbank_id(bl);
	u8 val;
	u8 mask;
	bool enable;
	int ret;

	ret = lm3533_read(bl->lm3533, LM3533_REG_CTRLBANK_AB_BCONF, &val);
	if (ret)
		return ret;

	mask = 1 << (2 * ctrlbank);
	enable = val & mask;

	return scnprintf(buf, PAGE_SIZE, "%d\n", enable);
}

static ssize_t store_als_en(struct device *dev,
					struct device_attribute *attr,
					const char *buf, size_t len)
{
	struct lm3533_bl *bl = dev_get_drvdata(dev);
	int ctrlbank = lm3533_bl_get_ctrlbank_id(bl);
	int enable;
	u8 val;
	u8 mask;
	int ret;

	if (kstrtoint(buf, 0, &enable))
		return -EINVAL;

	mask = 1 << (2 * ctrlbank);

	if (enable)
		val = mask;
	else
		val = 0;

	ret = lm3533_update(bl->lm3533, LM3533_REG_CTRLBANK_AB_BCONF, val,
									mask);
	if (ret)
		return ret;

	return len;
}

static ssize_t show_linear(struct device *dev,
				struct device_attribute *attr, char *buf)
{
	struct lm3533_bl *bl = dev_get_drvdata(dev);
	u8 val;
	u8 mask;
	int linear;
	int ret;

	ret = lm3533_read(bl->lm3533, LM3533_REG_CTRLBANK_AB_BCONF, &val);
	if (ret)
		return ret;

	mask = 1 << (2 * lm3533_bl_get_ctrlbank_id(bl) + 1);

	if (val & mask)
		linear = 1;
	else
		linear = 0;

	return scnprintf(buf, PAGE_SIZE, "%x\n", linear);
}

static ssize_t store_linear(struct device *dev,
					struct device_attribute *attr,
					const char *buf, size_t len)
{
	struct lm3533_bl *bl = dev_get_drvdata(dev);
	unsigned long linear;
	u8 mask;
	u8 val;
	int ret;

	if (kstrtoul(buf, 0, &linear))
		return -EINVAL;

	mask = 1 << (2 * lm3533_bl_get_ctrlbank_id(bl) + 1);

	if (linear)
		val = mask;
	else
		val = 0;

	ret = lm3533_update(bl->lm3533, LM3533_REG_CTRLBANK_AB_BCONF, val,
									mask);
	if (ret)
		return ret;

	return len;
}

static ssize_t show_pwm(struct device *dev,
					struct device_attribute *attr,
					char *buf)
{
	struct lm3533_bl *bl = dev_get_drvdata(dev);
	u8 val;
	int ret;

	ret = lm3533_ctrlbank_get_pwm(&bl->cb, &val);
	if (ret)
		return ret;

	return scnprintf(buf, PAGE_SIZE, "%u\n", val);
}

static ssize_t store_pwm(struct device *dev,
					struct device_attribute *attr,
					const char *buf, size_t len)
{
	struct lm3533_bl *bl = dev_get_drvdata(dev);
	u8 val;
	int ret;

	if (kstrtou8(buf, 0, &val))
		return -EINVAL;

	ret = lm3533_ctrlbank_set_pwm(&bl->cb, val);
	if (ret)
		return ret;

	return len;
}

static LM3533_ATTR_RO(als_channel);
static LM3533_ATTR_RW(als_en);
static LM3533_ATTR_RO(id);
static LM3533_ATTR_RW(linear);
static LM3533_ATTR_RW(pwm);

static struct attribute *lm3533_bl_attributes[] = {
	&dev_attr_als_channel.attr,
	&dev_attr_als_en.attr,
	&dev_attr_id.attr,
	&dev_attr_linear.attr,
	&dev_attr_pwm.attr,
	NULL,
};

static umode_t lm3533_bl_attr_is_visible(struct kobject *kobj,
					     struct attribute *attr, int n)
{
	struct device *dev = kobj_to_dev(kobj);
	struct lm3533_bl *bl = dev_get_drvdata(dev);
	umode_t mode = attr->mode;

	if (attr == &dev_attr_als_channel.attr ||
					attr == &dev_attr_als_en.attr) {
		if (!bl->lm3533->have_als)
			mode = 0;
	}

	return mode;
};

static struct attribute_group lm3533_bl_attribute_group = {
	.is_visible	= lm3533_bl_attr_is_visible,
	.attrs		= lm3533_bl_attributes
};

static int lm3533_bl_setup(struct lm3533_bl *bl,
					struct lm3533_bl_platform_data *pdata)
{
	int ret;

	ret = lm3533_ctrlbank_set_max_current(&bl->cb, pdata->max_current);
	if (ret)
		return ret;

	return lm3533_ctrlbank_set_pwm(&bl->cb, pdata->pwm);
}

static int lm3533_bl_probe(struct platform_device *pdev)
{
	struct lm3533 *lm3533;
	struct lm3533_bl_platform_data *pdata;
	struct lm3533_bl *bl;
	struct backlight_device *bd;
	struct backlight_properties props;
	int ret;

	dev_dbg(&pdev->dev, "%s\n", __func__);

	lm3533 = dev_get_drvdata(pdev->dev.parent);
	if (!lm3533)
		return -EINVAL;

	pdata = dev_get_platdata(&pdev->dev);
	if (!pdata) {
		dev_err(&pdev->dev, "no platform data\n");
		return -EINVAL;
	}

	if (pdev->id < 0 || pdev->id >= LM3533_HVCTRLBANK_COUNT) {
		dev_err(&pdev->dev, "illegal backlight id %d\n", pdev->id);
		return -EINVAL;
	}

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

	bl->lm3533 = lm3533;
	bl->id = pdev->id;

	bl->cb.lm3533 = lm3533;
	bl->cb.id = lm3533_bl_get_ctrlbank_id(bl);
	bl->cb.dev = NULL;			/* until registered */

	memset(&props, 0, sizeof(props));
	props.type = BACKLIGHT_RAW;
	props.max_brightness = LM3533_BL_MAX_BRIGHTNESS;
	props.brightness = pdata->default_brightness;
	bd = devm_backlight_device_register(&pdev->dev, pdata->name,
					pdev->dev.parent, bl, &lm3533_bl_ops,
					&props);
	if (IS_ERR(bd)) {
		dev_err(&pdev->dev, "failed to register backlight device\n");
		return PTR_ERR(bd);
	}

	bl->bd = bd;
	bl->cb.dev = &bl->bd->dev;

	platform_set_drvdata(pdev, bl);

	ret = sysfs_create_group(&bd->dev.kobj, &lm3533_bl_attribute_group);
	if (ret < 0) {
		dev_err(&pdev->dev, "failed to create sysfs attributes\n");
		return ret;
	}

	backlight_update_status(bd);

	ret = lm3533_bl_setup(bl, pdata);
	if (ret)
		goto err_sysfs_remove;

	ret = lm3533_ctrlbank_enable(&bl->cb);
	if (ret)
		goto err_sysfs_remove;

	return 0;

err_sysfs_remove:
	sysfs_remove_group(&bd->dev.kobj, &lm3533_bl_attribute_group);

	return ret;
}

static int lm3533_bl_remove(struct platform_device *pdev)
{
	struct lm3533_bl *bl = platform_get_drvdata(pdev);
	struct backlight_device *bd = bl->bd;

	dev_dbg(&bd->dev, "%s\n", __func__);

	bd->props.power = FB_BLANK_POWERDOWN;
	bd->props.brightness = 0;

	lm3533_ctrlbank_disable(&bl->cb);
	sysfs_remove_group(&bd->dev.kobj, &lm3533_bl_attribute_group);

	return 0;
}

#ifdef CONFIG_PM_SLEEP
static int lm3533_bl_suspend(struct device *dev)
{
	struct lm3533_bl *bl = dev_get_drvdata(dev);

	dev_dbg(dev, "%s\n", __func__);

	return lm3533_ctrlbank_disable(&bl->cb);
}

static int lm3533_bl_resume(struct device *dev)
{
	struct lm3533_bl *bl = dev_get_drvdata(dev);

	dev_dbg(dev, "%s\n", __func__);

	return lm3533_ctrlbank_enable(&bl->cb);
}
#endif

static SIMPLE_DEV_PM_OPS(lm3533_bl_pm_ops, lm3533_bl_suspend, lm3533_bl_resume);

static void lm3533_bl_shutdown(struct platform_device *pdev)
{
	struct lm3533_bl *bl = platform_get_drvdata(pdev);

	dev_dbg(&pdev->dev, "%s\n", __func__);

	lm3533_ctrlbank_disable(&bl->cb);
}

static struct platform_driver lm3533_bl_driver = {
	.driver = {
		.name	= "lm3533-backlight",
		.pm	= &lm3533_bl_pm_ops,
	},
	.probe		= lm3533_bl_probe,
	.remove		= lm3533_bl_remove,
	.shutdown	= lm3533_bl_shutdown,
};
module_platform_driver(lm3533_bl_driver);

MODULE_AUTHOR("Johan Hovold <jhovold@gmail.com>");
MODULE_DESCRIPTION("LM3533 Backlight driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:lm3533-backlight");
Commit	Line	Data
2874c5fd	1	// SPDX-License-Identifier: GPL-2.0-or-later
7f26c970 JH	2	/*
	3	* lm3533-bl.c -- LM3533 Backlight driver
	4	*
	5	* Copyright (C) 2011-2012 Texas Instruments
	6	*
	7	* Author: Johan Hovold <jhovold@gmail.com>
7f26c970 JH	8	*/
	9
	10	#include <linux/module.h>
	11	#include <linux/init.h>
	12	#include <linux/platform_device.h>
	13	#include <linux/backlight.h>
	14	#include <linux/fb.h>
	15	#include <linux/slab.h>
	16
	17	#include <linux/mfd/lm3533.h>
	18
	19
	20	#define LM3533_HVCTRLBANK_COUNT 2
	21	#define LM3533_BL_MAX_BRIGHTNESS 255
	22
	23	#define LM3533_REG_CTRLBANK_AB_BCONF 0x1a
	24
	25
	26	struct lm3533_bl {
	27	struct lm3533 *lm3533;
	28	struct lm3533_ctrlbank cb;
	29	struct backlight_device *bd;
	30	int id;
	31	};
	32
	33
	34	static inline int lm3533_bl_get_ctrlbank_id(struct lm3533_bl *bl)
	35	{
	36	return bl->id;
	37	}
	38
	39	static int lm3533_bl_update_status(struct backlight_device *bd)
	40	{
	41	struct lm3533_bl *bl = bl_get_data(bd);
7f26c970	42
51d53e5b	43	return lm3533_ctrlbank_set_brightness(&bl->cb, backlight_get_brightness(bd));
7f26c970 JH	44	}
	45
	46	static int lm3533_bl_get_brightness(struct backlight_device *bd)
	47	{
	48	struct lm3533_bl *bl = bl_get_data(bd);
	49	u8 val;
	50	int ret;
	51
	52	ret = lm3533_ctrlbank_get_brightness(&bl->cb, &val);
	53	if (ret)
	54	return ret;
	55
	56	return val;
	57	}
	58
	59	static const struct backlight_ops lm3533_bl_ops = {
	60	.get_brightness = lm3533_bl_get_brightness,
	61	.update_status = lm3533_bl_update_status,
	62	};
	63
	64	static ssize_t show_id(struct device *dev,
	65	struct device_attribute attr, char buf)
	66	{
	67	struct lm3533_bl *bl = dev_get_drvdata(dev);
	68
	69	return scnprintf(buf, PAGE_SIZE, "%d\n", bl->id);
	70	}
	71
	72	static ssize_t show_als_channel(struct device *dev,
	73	struct device_attribute attr, char buf)
	74	{
	75	struct lm3533_bl *bl = dev_get_drvdata(dev);
	76	unsigned channel = lm3533_bl_get_ctrlbank_id(bl);
	77
	78	return scnprintf(buf, PAGE_SIZE, "%u\n", channel);
	79	}
	80
	81	static ssize_t show_als_en(struct device *dev,
	82	struct device_attribute attr, char buf)
	83	{
	84	struct lm3533_bl *bl = dev_get_drvdata(dev);
	85	int ctrlbank = lm3533_bl_get_ctrlbank_id(bl);
	86	u8 val;
	87	u8 mask;
	88	bool enable;
	89	int ret;
	90
	91	ret = lm3533_read(bl->lm3533, LM3533_REG_CTRLBANK_AB_BCONF, &val);
	92	if (ret)
	93	return ret;
	94
	95	mask = 1 << (2 * ctrlbank);
	96	enable = val & mask;
	97
	98	return scnprintf(buf, PAGE_SIZE, "%d\n", enable);
	99	}
	100
	101	static ssize_t store_als_en(struct device *dev,
	102	struct device_attribute *attr,
	103	const char *buf, size_t len)
	104	{
	105	struct lm3533_bl *bl = dev_get_drvdata(dev);
	106	int ctrlbank = lm3533_bl_get_ctrlbank_id(bl);
	107	int enable;
108	u8 val;
109	u8 mask;
110	int ret;
111
112	if (kstrtoint(buf, 0, &enable))
113	return -EINVAL;
114
115	mask = 1 << (2 * ctrlbank);
116
117	if (enable)
118	val = mask;
119	else
120	val = 0;
121
122	ret = lm3533_update(bl->lm3533, LM3533_REG_CTRLBANK_AB_BCONF, val,
123	mask);
124	if (ret)
125	return ret;
126
127	return len;
128	}
129
130	static ssize_t show_linear(struct device *dev,
131	struct device_attribute attr, char buf)
132	{
133	struct lm3533_bl *bl = dev_get_drvdata(dev);
134	u8 val;
135	u8 mask;
136	int linear;
137	int ret;
138
139	ret = lm3533_read(bl->lm3533, LM3533_REG_CTRLBANK_AB_BCONF, &val);
140	if (ret)
141	return ret;
142
143	mask = 1 << (2 * lm3533_bl_get_ctrlbank_id(bl) + 1);
144
145	if (val & mask)
146	linear = 1;
147	else
148	linear = 0;
149
150	return scnprintf(buf, PAGE_SIZE, "%x\n", linear);
151	}
152
153	static ssize_t store_linear(struct device *dev,
154	struct device_attribute *attr,
155	const char *buf, size_t len)
156	{
157	struct lm3533_bl *bl = dev_get_drvdata(dev);
158	unsigned long linear;
159	u8 mask;
160	u8 val;
161	int ret;
162
163	if (kstrtoul(buf, 0, &linear))
164	return -EINVAL;
165
166	mask = 1 << (2 * lm3533_bl_get_ctrlbank_id(bl) + 1);
167
168	if (linear)
169	val = mask;
170	else
171	val = 0;
172
173	ret = lm3533_update(bl->lm3533, LM3533_REG_CTRLBANK_AB_BCONF, val,
174	mask);
175	if (ret)
176	return ret;
177
178	return len;
179	}
180
181	static ssize_t show_pwm(struct device *dev,
182	struct device_attribute *attr,
183	char *buf)
184	{
185	struct lm3533_bl *bl = dev_get_drvdata(dev);
186	u8 val;
187	int ret;
188
189	ret = lm3533_ctrlbank_get_pwm(&bl->cb, &val);
190	if (ret)
191	return ret;
192
193	return scnprintf(buf, PAGE_SIZE, "%u\n", val);
194	}
195
196	static ssize_t store_pwm(struct device *dev,
197	struct device_attribute *attr,
198	const char *buf, size_t len)
199	{
200	struct lm3533_bl *bl = dev_get_drvdata(dev);
201	u8 val;
202	int ret;
203
204	if (kstrtou8(buf, 0, &val))
205	return -EINVAL;
206
207	ret = lm3533_ctrlbank_set_pwm(&bl->cb, val);
208	if (ret)
209	return ret;
210
211	return len;
212	}
213
214	static LM3533_ATTR_RO(als_channel);
215	static LM3533_ATTR_RW(als_en);
216	static LM3533_ATTR_RO(id);
217	static LM3533_ATTR_RW(linear);
218	static LM3533_ATTR_RW(pwm);
219
220	static struct attribute *lm3533_bl_attributes[] = {
221	&dev_attr_als_channel.attr,
222	&dev_attr_als_en.attr,
223	&dev_attr_id.attr,
224	&dev_attr_linear.attr,
225	&dev_attr_pwm.attr,
226	NULL,
227	};
228
229	static umode_t lm3533_bl_attr_is_visible(struct kobject *kobj,
230	struct attribute *attr, int n)
231	{
a9b9b2af	232	struct device *dev = kobj_to_dev(kobj);
7f26c970 JH	233	struct lm3533_bl *bl = dev_get_drvdata(dev);
	234	umode_t mode = attr->mode;
	235
	236	if (attr == &dev_attr_als_channel.attr \|\|
	237	attr == &dev_attr_als_en.attr) {
	238	if (!bl->lm3533->have_als)
	239	mode = 0;
	240	}
	241
	242	return mode;
	243	};
	244
	245	static struct attribute_group lm3533_bl_attribute_group = {
	246	.is_visible = lm3533_bl_attr_is_visible,
	247	.attrs = lm3533_bl_attributes
	248	};
	249
1b9e450d	250	static int lm3533_bl_setup(struct lm3533_bl *bl,
7f26c970 JH	251	struct lm3533_bl_platform_data *pdata)
	252	{
	253	int ret;
	254
	255	ret = lm3533_ctrlbank_set_max_current(&bl->cb, pdata->max_current);
	256	if (ret)
	257	return ret;
	258
	259	return lm3533_ctrlbank_set_pwm(&bl->cb, pdata->pwm);
	260	}
	261
1b9e450d	262	static int lm3533_bl_probe(struct platform_device *pdev)
7f26c970 JH	263	{
	264	struct lm3533 *lm3533;
	265	struct lm3533_bl_platform_data *pdata;
	266	struct lm3533_bl *bl;
	267	struct backlight_device *bd;
	268	struct backlight_properties props;
	269	int ret;
	270
	271	dev_dbg(&pdev->dev, "%s\n", __func__);
	272
	273	lm3533 = dev_get_drvdata(pdev->dev.parent);
	274	if (!lm3533)
	275	return -EINVAL;
	276
c512794c	277	pdata = dev_get_platdata(&pdev->dev);
7f26c970 JH	278	if (!pdata) {
	279	dev_err(&pdev->dev, "no platform data\n");
	280	return -EINVAL;
	281	}
	282
	283	if (pdev->id < 0 \|\| pdev->id >= LM3533_HVCTRLBANK_COUNT) {
	284	dev_err(&pdev->dev, "illegal backlight id %d\n", pdev->id);
	285	return -EINVAL;
	286	}
	287
b4a74615	288	bl = devm_kzalloc(&pdev->dev, sizeof(*bl), GFP_KERNEL);
44d516f9	289	if (!bl)
7f26c970	290	return -ENOMEM;
7f26c970 JH	291
	292	bl->lm3533 = lm3533;
	293	bl->id = pdev->id;
	294
	295	bl->cb.lm3533 = lm3533;
	296	bl->cb.id = lm3533_bl_get_ctrlbank_id(bl);
	297	bl->cb.dev = NULL; /* until registered */
	298
	299	memset(&props, 0, sizeof(props));
	300	props.type = BACKLIGHT_RAW;
	301	props.max_brightness = LM3533_BL_MAX_BRIGHTNESS;
	302	props.brightness = pdata->default_brightness;
e86c7098 JH	303	bd = devm_backlight_device_register(&pdev->dev, pdata->name,
	304	pdev->dev.parent, bl, &lm3533_bl_ops,
	305	&props);
7f26c970 JH	306	if (IS_ERR(bd)) {
7f26c970 JH	307	dev_err(&pdev->dev, "failed to register backlight device\n");
b4a74615	308	return PTR_ERR(bd);
7f26c970 JH	309	}
	310
	311	bl->bd = bd;
	312	bl->cb.dev = &bl->bd->dev;
	313
	314	platform_set_drvdata(pdev, bl);
	315
	316	ret = sysfs_create_group(&bd->dev.kobj, &lm3533_bl_attribute_group);
	317	if (ret < 0) {
	318	dev_err(&pdev->dev, "failed to create sysfs attributes\n");
e86c7098	319	return ret;
7f26c970 JH	320	}
	321
	322	backlight_update_status(bd);
	323
	324	ret = lm3533_bl_setup(bl, pdata);
	325	if (ret)
	326	goto err_sysfs_remove;
	327
	328	ret = lm3533_ctrlbank_enable(&bl->cb);
	329	if (ret)
	330	goto err_sysfs_remove;
	331
	332	return 0;
	333
	334	err_sysfs_remove:
	335	sysfs_remove_group(&bd->dev.kobj, &lm3533_bl_attribute_group);
7f26c970 JH	336
	337	return ret;
	338	}
	339
7e4b9d0b	340	static int lm3533_bl_remove(struct platform_device *pdev)
7f26c970 JH	341	{
	342	struct lm3533_bl *bl = platform_get_drvdata(pdev);
	343	struct backlight_device *bd = bl->bd;
	344
	345	dev_dbg(&bd->dev, "%s\n", __func__);
	346
	347	bd->props.power = FB_BLANK_POWERDOWN;
	348	bd->props.brightness = 0;
	349
	350	lm3533_ctrlbank_disable(&bl->cb);
	351	sysfs_remove_group(&bd->dev.kobj, &lm3533_bl_attribute_group);
7f26c970 JH	352
	353	return 0;
	354	}
	355
b0792962 JH	356	#ifdef CONFIG_PM_SLEEP
b0792962 JH	357	static int lm3533_bl_suspend(struct device *dev)
7f26c970	358	{
b0792962	359	struct lm3533_bl *bl = dev_get_drvdata(dev);
7f26c970	360
b0792962	361	dev_dbg(dev, "%s\n", __func__);
7f26c970 JH	362
	363	return lm3533_ctrlbank_disable(&bl->cb);
	364	}
	365
b0792962	366	static int lm3533_bl_resume(struct device *dev)
7f26c970	367	{
b0792962	368	struct lm3533_bl *bl = dev_get_drvdata(dev);
7f26c970	369
b0792962	370	dev_dbg(dev, "%s\n", __func__);
7f26c970 JH	371
	372	return lm3533_ctrlbank_enable(&bl->cb);
	373	}
7f26c970 JH	374	#endif
7f26c970 JH	375
b0792962 JH	376	static SIMPLE_DEV_PM_OPS(lm3533_bl_pm_ops, lm3533_bl_suspend, lm3533_bl_resume);
b0792962 JH	377
7f26c970 JH	378	static void lm3533_bl_shutdown(struct platform_device *pdev)
	379	{
	380	struct lm3533_bl *bl = platform_get_drvdata(pdev);
	381
	382	dev_dbg(&pdev->dev, "%s\n", __func__);
	383
	384	lm3533_ctrlbank_disable(&bl->cb);
	385	}
	386
	387	static struct platform_driver lm3533_bl_driver = {
	388	.driver = {
	389	.name = "lm3533-backlight",
b0792962	390	.pm = &lm3533_bl_pm_ops,
7f26c970 JH	391	},
7f26c970 JH	392	.probe = lm3533_bl_probe,
d1723fa2	393	.remove = lm3533_bl_remove,
7f26c970	394	.shutdown = lm3533_bl_shutdown,
7f26c970 JH	395	};
	396	module_platform_driver(lm3533_bl_driver);
	397
	398	MODULE_AUTHOR("Johan Hovold <jhovold@gmail.com>");
	399	MODULE_DESCRIPTION("LM3533 Backlight driver");
	400	MODULE_LICENSE("GPL");
	401	MODULE_ALIAS("platform:lm3533-backlight");