[mirror_ubuntu-jammy-kernel.git] / drivers / leds / leds-wm8350.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * LED driver for WM8350 driven LEDS.
 *
 * Copyright(C) 2007, 2008 Wolfson Microelectronics PLC.
 */

#include <linux/kernel.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 int wm8350_led_enable(struct wm8350_led *led)
{
	int ret = 0;

	if (led->enabled)
		return ret;

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

	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 ret;
	}

	led->enabled = 1;

	return ret;
}

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

	if (!led->enabled)
		return ret;

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

	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 ret;
	}

	led->enabled = 0;

	return ret;
}

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

	led->value = value;

	spin_lock_irqsave(&led->value_lock, flags);

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

	/* 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);
		return ret;
	}

	return wm8350_led_enable(led);
}

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

	led->value = LED_OFF;
	wm8350_led_disable(led);
}

static int wm8350_led_probe(struct platform_device *pdev)
{
	struct regulator *isink, *dcdc;
	struct wm8350_led *led;
	struct wm8350_led_platform_data *pdata = dev_get_platdata(&pdev->dev);
	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_blocking = 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);
	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);
	wm8350_led_disable(led);
	return 0;
}

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