[linux.git] / drivers / leds / leds-wm8350.c

/*
 * LED driver for WM8350 driven LEDS.
 *
 * Copyright(C) 2007, 2008 Wolfson Microelectronics PLC.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 */

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/leds.h>
#include <linux/err.h>
#include <linux/mfd/wm8350/pmic.h>
#include <linux/regulator/consumer.h>
#include <linux/slab.h>
#include <linux/module.h>

/* Microamps */
static const int isink_cur[] = {
	4,
	5,
	6,
	7,
	8,
	10,
	11,
	14,
	16,
	19,
	23,
	27,
	32,
	39,
	46,
	54,
	65,
	77,
	92,
	109,
	130,
	154,
	183,
	218,
	259,
	308,
	367,
	436,
	518,
	616,
	733,
	872,
	1037,
	1233,
	1466,
	1744,
	2073,
	2466,
	2933,
	3487,
	4147,
	4932,
	5865,
	6975,
	8294,
	9864,
	11730,
	13949,
	16589,
	19728,
	23460,
	27899,
	33178,
	39455,
	46920,
	55798,
	66355,
	78910,
	93840,
	111596,
	132710,
	157820,
	187681,
	223191
};

#define to_wm8350_led(led_cdev) \
	container_of(led_cdev, struct wm8350_led, cdev)

static void wm8350_led_enable(struct wm8350_led *led)
{
	int ret;

	if (led->enabled)
		return;

	ret = regulator_enable(led->isink);
	if (ret != 0) {
		dev_err(led->cdev.dev, "Failed to enable ISINK: %d\n", ret);
		return;
	}

	ret = regulator_enable(led->dcdc);
	if (ret != 0) {
		dev_err(led->cdev.dev, "Failed to enable DCDC: %d\n", ret);
		regulator_disable(led->isink);
		return;
	}

	led->enabled = 1;
}

static void wm8350_led_disable(struct wm8350_led *led)
{
	int ret;

	if (!led->enabled)
		return;

	ret = regulator_disable(led->dcdc);
	if (ret != 0) {
		dev_err(led->cdev.dev, "Failed to disable DCDC: %d\n", ret);
		return;
	}

	ret = regulator_disable(led->isink);
	if (ret != 0) {
		dev_err(led->cdev.dev, "Failed to disable ISINK: %d\n", ret);
		ret = regulator_enable(led->dcdc);
		if (ret != 0)
			dev_err(led->cdev.dev, "Failed to reenable DCDC: %d\n",
				ret);
		return;
	}

	led->enabled = 0;
}

static void led_work(struct work_struct *work)
{
	struct wm8350_led *led = container_of(work, struct wm8350_led, work);
	int ret;
	int uA;
	unsigned long flags;

	mutex_lock(&led->mutex);

	spin_lock_irqsave(&led->value_lock, flags);

	if (led->value == LED_OFF) {
		spin_unlock_irqrestore(&led->value_lock, flags);
		wm8350_led_disable(led);
		goto out;
	}

	/* This scales linearly into the index of valid current
	 * settings which results in a linear scaling of perceived
	 * brightness due to the non-linear current settings provided
	 * by the hardware.
	 */
	uA = (led->max_uA_index * led->value) / LED_FULL;
	spin_unlock_irqrestore(&led->value_lock, flags);
	BUG_ON(uA >= ARRAY_SIZE(isink_cur));

	ret = regulator_set_current_limit(led->isink, isink_cur[uA],
					  isink_cur[uA]);
	if (ret != 0)
		dev_err(led->cdev.dev, "Failed to set %duA: %d\n",
			isink_cur[uA], ret);

	wm8350_led_enable(led);

out:
	mutex_unlock(&led->mutex);
}

static void wm8350_led_set(struct led_classdev *led_cdev,
			   enum led_brightness value)
{
	struct wm8350_led *led = to_wm8350_led(led_cdev);
	unsigned long flags;

	spin_lock_irqsave(&led->value_lock, flags);
	led->value = value;
	schedule_work(&led->work);
	spin_unlock_irqrestore(&led->value_lock, flags);
}

static void wm8350_led_shutdown(struct platform_device *pdev)
{
	struct wm8350_led *led = platform_get_drvdata(pdev);

	mutex_lock(&led->mutex);
	led->value = LED_OFF;
	wm8350_led_disable(led);
	mutex_unlock(&led->mutex);
}

static int wm8350_led_probe(struct platform_device *pdev)
{
	struct regulator *isink, *dcdc;
	struct wm8350_led *led;
	struct wm8350_led_platform_data *pdata = pdev->dev.platform_data;
	int i;

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

	if (pdata->max_uA < isink_cur[0]) {
		dev_err(&pdev->dev, "Invalid maximum current %duA\n",
			pdata->max_uA);
		return -EINVAL;
	}

	isink = devm_regulator_get(&pdev->dev, "led_isink");
	if (IS_ERR(isink)) {
		dev_err(&pdev->dev, "%s: can't get ISINK\n", __func__);
		return PTR_ERR(isink);
	}

	dcdc = devm_regulator_get(&pdev->dev, "led_vcc");
	if (IS_ERR(dcdc)) {
		dev_err(&pdev->dev, "%s: can't get DCDC\n", __func__);
		return PTR_ERR(dcdc);
	}

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

	led->cdev.brightness_set = wm8350_led_set;
	led->cdev.default_trigger = pdata->default_trigger;
	led->cdev.name = pdata->name;
	led->cdev.flags |= LED_CORE_SUSPENDRESUME;
	led->enabled = regulator_is_enabled(isink);
	led->isink = isink;
	led->dcdc = dcdc;

	for (i = 0; i < ARRAY_SIZE(isink_cur) - 1; i++)
		if (isink_cur[i] >= pdata->max_uA)
			break;
	led->max_uA_index = i;
	if (pdata->max_uA != isink_cur[i])
		dev_warn(&pdev->dev,
			 "Maximum current %duA is not directly supported,"
			 " check platform data\n",
			 pdata->max_uA);

	spin_lock_init(&led->value_lock);
	mutex_init(&led->mutex);
	INIT_WORK(&led->work, led_work);
	led->value = LED_OFF;
	platform_set_drvdata(pdev, led);

	return led_classdev_register(&pdev->dev, &led->cdev);
}

static int wm8350_led_remove(struct platform_device *pdev)
{
	struct wm8350_led *led = platform_get_drvdata(pdev);

	led_classdev_unregister(&led->cdev);
	flush_work(&led->work);
	wm8350_led_disable(led);
	return 0;
}

static struct platform_driver wm8350_led_driver = {
	.driver = {
		   .name = "wm8350-led",
		   .owner = THIS_MODULE,
		   },
	.probe = wm8350_led_probe,
	.remove = wm8350_led_remove,
	.shutdown = wm8350_led_shutdown,
};

module_platform_driver(wm8350_led_driver);

MODULE_AUTHOR("Mark Brown");
MODULE_DESCRIPTION("WM8350 LED driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:wm8350-led");
Commit	Line	Data
0081e802 MB	1	/*
	2	* LED driver for WM8350 driven LEDS.
	3	*
	4	* Copyright(C) 2007, 2008 Wolfson Microelectronics PLC.
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License version 2 as
	8	* published by the Free Software Foundation.
	9	*
	10	*/
	11
	12	#include <linux/kernel.h>
	13	#include <linux/init.h>
	14	#include <linux/platform_device.h>
	15	#include <linux/leds.h>
	16	#include <linux/err.h>
	17	#include <linux/mfd/wm8350/pmic.h>
	18	#include <linux/regulator/consumer.h>
5a0e3ad6	19	#include <linux/slab.h>
54f4dedb	20	#include <linux/module.h>
0081e802 MB	21
	22	/* Microamps */
	23	static const int isink_cur[] = {
	24	4,
	25	5,
	26	6,
	27	7,
	28	8,
	29	10,
	30	11,
	31	14,
	32	16,
	33	19,
	34	23,
	35	27,
	36	32,
	37	39,
	38	46,
	39	54,
	40	65,
	41	77,
	42	92,
	43	109,
	44	130,
	45	154,
	46	183,
	47	218,
	48	259,
	49	308,
	50	367,
	51	436,
	52	518,
	53	616,
	54	733,
	55	872,
	56	1037,
	57	1233,
	58	1466,
	59	1744,
	60	2073,
	61	2466,
	62	2933,
	63	3487,
	64	4147,
	65	4932,
	66	5865,
	67	6975,
	68	8294,
	69	9864,
	70	11730,
	71	13949,
	72	16589,
	73	19728,
	74	23460,
	75	27899,
	76	33178,
	77	39455,
	78	46920,
	79	55798,
	80	66355,
	81	78910,
	82	93840,
	83	111596,
	84	132710,
85	157820,
86	187681,
87	223191
88	};
89
90	#define to_wm8350_led(led_cdev) \
91	container_of(led_cdev, struct wm8350_led, cdev)
92
93	static void wm8350_led_enable(struct wm8350_led *led)
94	{
95	int ret;
96
97	if (led->enabled)
98	return;
99
100	ret = regulator_enable(led->isink);
101	if (ret != 0) {
102	dev_err(led->cdev.dev, "Failed to enable ISINK: %d\n", ret);
103	return;
104	}
105
106	ret = regulator_enable(led->dcdc);
107	if (ret != 0) {
108	dev_err(led->cdev.dev, "Failed to enable DCDC: %d\n", ret);
109	regulator_disable(led->isink);
110	return;
111	}
112
113	led->enabled = 1;
114	}
115
116	static void wm8350_led_disable(struct wm8350_led *led)
117	{
118	int ret;
119
120	if (!led->enabled)
121	return;
122
123	ret = regulator_disable(led->dcdc);
124	if (ret != 0) {
125	dev_err(led->cdev.dev, "Failed to disable DCDC: %d\n", ret);
126	return;
127	}
128
129	ret = regulator_disable(led->isink);
130	if (ret != 0) {
131	dev_err(led->cdev.dev, "Failed to disable ISINK: %d\n", ret);
d67eb8e6 MB	132	ret = regulator_enable(led->dcdc);
	133	if (ret != 0)
	134	dev_err(led->cdev.dev, "Failed to reenable DCDC: %d\n",
	135	ret);
0081e802 MB	136	return;
	137	}
	138
	139	led->enabled = 0;
	140	}
	141
	142	static void led_work(struct work_struct *work)
	143	{
	144	struct wm8350_led *led = container_of(work, struct wm8350_led, work);
	145	int ret;
	146	int uA;
	147	unsigned long flags;
	148
	149	mutex_lock(&led->mutex);
	150
	151	spin_lock_irqsave(&led->value_lock, flags);
	152
	153	if (led->value == LED_OFF) {
	154	spin_unlock_irqrestore(&led->value_lock, flags);
	155	wm8350_led_disable(led);
	156	goto out;
	157	}
	158
	159	/* This scales linearly into the index of valid current
	160	* settings which results in a linear scaling of perceived
	161	* brightness due to the non-linear current settings provided
	162	* by the hardware.
	163	*/
	164	uA = (led->max_uA_index * led->value) / LED_FULL;
	165	spin_unlock_irqrestore(&led->value_lock, flags);
	166	BUG_ON(uA >= ARRAY_SIZE(isink_cur));
	167
	168	ret = regulator_set_current_limit(led->isink, isink_cur[uA],
	169	isink_cur[uA]);
	170	if (ret != 0)
	171	dev_err(led->cdev.dev, "Failed to set %duA: %d\n",
	172	isink_cur[uA], ret);
	173
	174	wm8350_led_enable(led);
	175
	176	out:
	177	mutex_unlock(&led->mutex);
	178	}
	179
	180	static void wm8350_led_set(struct led_classdev *led_cdev,
	181	enum led_brightness value)
	182	{
	183	struct wm8350_led *led = to_wm8350_led(led_cdev);
	184	unsigned long flags;
	185
	186	spin_lock_irqsave(&led->value_lock, flags);
	187	led->value = value;
	188	schedule_work(&led->work);
	189	spin_unlock_irqrestore(&led->value_lock, flags);
	190	}
	191
0081e802 MB	192	static void wm8350_led_shutdown(struct platform_device *pdev)
	193	{
	194	struct wm8350_led *led = platform_get_drvdata(pdev);
	195
	196	mutex_lock(&led->mutex);
	197	led->value = LED_OFF;
	198	wm8350_led_disable(led);
	199	mutex_unlock(&led->mutex);
	200	}
	201
	202	static int wm8350_led_probe(struct platform_device *pdev)
	203	{
	204	struct regulator isink, dcdc;
	205	struct wm8350_led *led;
	206	struct wm8350_led_platform_data *pdata = pdev->dev.platform_data;
490dcee9	207	int i;
0081e802 MB	208
	209	if (pdata == NULL) {
	210	dev_err(&pdev->dev, "no platform data\n");
	211	return -ENODEV;
	212	}
	213
	214	if (pdata->max_uA < isink_cur[0]) {
	215	dev_err(&pdev->dev, "Invalid maximum current %duA\n",
	216	pdata->max_uA);
	217	return -EINVAL;
	218	}
	219
490dcee9	220	isink = devm_regulator_get(&pdev->dev, "led_isink");
0081e802	221	if (IS_ERR(isink)) {
b75d2802	222	dev_err(&pdev->dev, "%s: can't get ISINK\n", __func__);
0081e802 MB	223	return PTR_ERR(isink);
	224	}
	225
490dcee9	226	dcdc = devm_regulator_get(&pdev->dev, "led_vcc");
0081e802	227	if (IS_ERR(dcdc)) {
b75d2802	228	dev_err(&pdev->dev, "%s: can't get DCDC\n", __func__);
490dcee9	229	return PTR_ERR(dcdc);
0081e802 MB	230	}
0081e802 MB	231
c957b614	232	led = devm_kzalloc(&pdev->dev, sizeof(*led), GFP_KERNEL);
490dcee9 AL	233	if (led == NULL)
490dcee9 AL	234	return -ENOMEM;
0081e802 MB	235
	236	led->cdev.brightness_set = wm8350_led_set;
	237	led->cdev.default_trigger = pdata->default_trigger;
	238	led->cdev.name = pdata->name;
859cb7f2	239	led->cdev.flags \|= LED_CORE_SUSPENDRESUME;
0081e802 MB	240	led->enabled = regulator_is_enabled(isink);
	241	led->isink = isink;
	242	led->dcdc = dcdc;
	243
	244	for (i = 0; i < ARRAY_SIZE(isink_cur) - 1; i++)
	245	if (isink_cur[i] >= pdata->max_uA)
	246	break;
	247	led->max_uA_index = i;
	248	if (pdata->max_uA != isink_cur[i])
	249	dev_warn(&pdev->dev,
	250	"Maximum current %duA is not directly supported,"
	251	" check platform data\n",
	252	pdata->max_uA);
	253
	254	spin_lock_init(&led->value_lock);
	255	mutex_init(&led->mutex);
	256	INIT_WORK(&led->work, led_work);
	257	led->value = LED_OFF;
	258	platform_set_drvdata(pdev, led);
	259
490dcee9	260	return led_classdev_register(&pdev->dev, &led->cdev);
0081e802 MB	261	}
	262
	263	static int wm8350_led_remove(struct platform_device *pdev)
	264	{
	265	struct wm8350_led *led = platform_get_drvdata(pdev);
	266
	267	led_classdev_unregister(&led->cdev);
43829731	268	flush_work(&led->work);
0081e802	269	wm8350_led_disable(led);
0081e802 MB	270	return 0;
	271	}
	272
	273	static struct platform_driver wm8350_led_driver = {
	274	.driver = {
	275	.name = "wm8350-led",
	276	.owner = THIS_MODULE,
	277	},
	278	.probe = wm8350_led_probe,
	279	.remove = wm8350_led_remove,
	280	.shutdown = wm8350_led_shutdown,
0081e802 MB	281	};
0081e802 MB	282
892a8843	283	module_platform_driver(wm8350_led_driver);
0081e802 MB	284
	285	MODULE_AUTHOR("Mark Brown");
	286	MODULE_DESCRIPTION("WM8350 LED driver");
	287	MODULE_LICENSE("GPL");
	288	MODULE_ALIAS("platform:wm8350-led");