[thirdparty/u-boot.git] / drivers / led / led_pwm.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (C) 2022 VK
 * Author: Ivan Vozvakhov <i.vozvakhov@vk.team>
 */

#include <common.h>
#include <dm.h>
#include <errno.h>
#include <led.h>
#include <malloc.h>
#include <pwm.h>

#define LEDS_PWM_DRIVER_NAME	"led_pwm"

struct led_pwm_priv {
	struct udevice *pwm;
	uint period;	/* period in ns */
	uint duty;	/* duty cycle in ns */
	uint channel;	/* pwm channel number */
	bool active_low;	/* pwm polarity */
	bool enabled;
};

static int led_pwm_enable(struct udevice *dev)
{
	struct led_pwm_priv *priv = dev_get_priv(dev);
	int ret;

	ret = pwm_set_invert(priv->pwm, priv->channel, priv->active_low);
	if (ret)
		return ret;

	ret = pwm_set_config(priv->pwm, priv->channel, priv->period, priv->duty);
	if (ret)
		return ret;

	ret = pwm_set_enable(priv->pwm, priv->channel, true);
	if (ret)
		return ret;

	priv->enabled = true;

	return 0;
}

static int led_pwm_disable(struct udevice *dev)
{
	struct led_pwm_priv *priv = dev_get_priv(dev);
	int ret;

	ret = pwm_set_config(priv->pwm, priv->channel, priv->period, 0);
	if (ret)
		return ret;

	ret = pwm_set_enable(priv->pwm, priv->channel, false);
	if (ret)
		return ret;

	priv->enabled = false;

	return 0;
}

static int led_pwm_set_state(struct udevice *dev, enum led_state_t state)
{
	struct led_pwm_priv *priv = dev_get_priv(dev);
	int ret;

	switch (state) {
	case LEDST_OFF:
		ret = led_pwm_disable(dev);
		break;
	case LEDST_ON:
		ret = led_pwm_enable(dev);
		break;
	case LEDST_TOGGLE:
		ret = (priv->enabled) ? led_pwm_disable(dev) : led_pwm_enable(dev);
		break;
	default:
		ret = -ENOSYS;
	}

	return ret;
}

static enum led_state_t led_pwm_get_state(struct udevice *dev)
{
	struct led_pwm_priv *priv = dev_get_priv(dev);

	return (priv->enabled) ? LEDST_ON : LEDST_OFF;
}

static int led_pwm_probe(struct udevice *dev)
{
	struct led_pwm_priv *priv = dev_get_priv(dev);

	return led_pwm_set_state(dev, (priv->enabled) ? LEDST_ON : LEDST_OFF);
}

static int led_pwm_of_to_plat(struct udevice *dev)
{
	struct led_pwm_priv *priv = dev_get_priv(dev);
	struct ofnode_phandle_args args;
	uint def_brightness, max_brightness;
	int ret;

	ret = dev_read_phandle_with_args(dev, "pwms", "#pwm-cells", 0, 0, &args);
	if (ret)
		return ret;

	ret = uclass_get_device_by_ofnode(UCLASS_PWM, args.node, &priv->pwm);
	if (ret)
		return ret;

	priv->channel = args.args[0];
	priv->period = args.args[1];
	priv->active_low = dev_read_bool(dev, "active-low");

	def_brightness = dev_read_u32_default(dev, "u-boot,default-brightness", 0);
	max_brightness = dev_read_u32_default(dev, "max-brightness", 255);
	priv->enabled =  !!def_brightness;

	/*
	 * No need to handle pwm inverted case (active_low)
	 * because of pwm_set_invert function
	 */
	if (def_brightness < max_brightness)
		priv->duty = priv->period * def_brightness / max_brightness;
	else
		priv->duty = priv->period;

	return 0;
}

static int led_pwm_bind(struct udevice *parent)
{
	return led_bind_generic(parent, LEDS_PWM_DRIVER_NAME);
}

static const struct led_ops led_pwm_ops = {
	.set_state = led_pwm_set_state,
	.get_state = led_pwm_get_state,
};

static const struct udevice_id led_pwm_ids[] = {
	{ .compatible = "pwm-leds" },
	{ }
};

U_BOOT_DRIVER(led_pwm) = {
	.name = LEDS_PWM_DRIVER_NAME,
	.id = UCLASS_LED,
	.ops = &led_pwm_ops,
	.priv_auto = sizeof(struct led_pwm_priv),
	.probe = led_pwm_probe,
	.of_to_plat = led_pwm_of_to_plat,
};

U_BOOT_DRIVER(led_pwm_wrap) = {
	.name = LEDS_PWM_DRIVER_NAME "_wrap",
	.id = UCLASS_NOP,
	.of_match = led_pwm_ids,
	.bind = led_pwm_bind,
};
Commit	Line	Data
067cfc1c IV	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* Copyright (C) 2022 VK
	4	* Author: Ivan Vozvakhov <i.vozvakhov@vk.team>
	5	*/
	6
d678a59d	7	#include <common.h>
067cfc1c IV	8	#include <dm.h>
	9	#include <errno.h>
	10	#include <led.h>
	11	#include <malloc.h>
067cfc1c IV	12	#include <pwm.h>
	13
	14	#define LEDS_PWM_DRIVER_NAME "led_pwm"
	15
	16	struct led_pwm_priv {
	17	struct udevice *pwm;
	18	uint period; /* period in ns */
	19	uint duty; /* duty cycle in ns */
	20	uint channel; /* pwm channel number */
	21	bool active_low; /* pwm polarity */
	22	bool enabled;
	23	};
	24
	25	static int led_pwm_enable(struct udevice *dev)
	26	{
	27	struct led_pwm_priv *priv = dev_get_priv(dev);
	28	int ret;
	29
	30	ret = pwm_set_invert(priv->pwm, priv->channel, priv->active_low);
	31	if (ret)
	32	return ret;
	33
	34	ret = pwm_set_config(priv->pwm, priv->channel, priv->period, priv->duty);
	35	if (ret)
	36	return ret;
	37
	38	ret = pwm_set_enable(priv->pwm, priv->channel, true);
	39	if (ret)
	40	return ret;
	41
	42	priv->enabled = true;
	43
	44	return 0;
	45	}
	46
	47	static int led_pwm_disable(struct udevice *dev)
	48	{
	49	struct led_pwm_priv *priv = dev_get_priv(dev);
	50	int ret;
	51
	52	ret = pwm_set_config(priv->pwm, priv->channel, priv->period, 0);
	53	if (ret)
	54	return ret;
	55
	56	ret = pwm_set_enable(priv->pwm, priv->channel, false);
	57	if (ret)
	58	return ret;
	59
	60	priv->enabled = false;
	61
	62	return 0;
	63	}
	64
	65	static int led_pwm_set_state(struct udevice *dev, enum led_state_t state)
	66	{
	67	struct led_pwm_priv *priv = dev_get_priv(dev);
	68	int ret;
	69
	70	switch (state) {
	71	case LEDST_OFF:
	72	ret = led_pwm_disable(dev);
	73	break;
	74	case LEDST_ON:
	75	ret = led_pwm_enable(dev);
76	break;
77	case LEDST_TOGGLE:
78	ret = (priv->enabled) ? led_pwm_disable(dev) : led_pwm_enable(dev);
79	break;
80	default:
81	ret = -ENOSYS;
82	}
83
84	return ret;
85	}
86
87	static enum led_state_t led_pwm_get_state(struct udevice *dev)
88	{
89	struct led_pwm_priv *priv = dev_get_priv(dev);
90
91	return (priv->enabled) ? LEDST_ON : LEDST_OFF;
92	}
93
94	static int led_pwm_probe(struct udevice *dev)
95	{
96	struct led_pwm_priv *priv = dev_get_priv(dev);
067cfc1c IV	97
	98	return led_pwm_set_state(dev, (priv->enabled) ? LEDST_ON : LEDST_OFF);
	99	}
	100
	101	static int led_pwm_of_to_plat(struct udevice *dev)
	102	{
067cfc1c IV	103	struct led_pwm_priv *priv = dev_get_priv(dev);
	104	struct ofnode_phandle_args args;
	105	uint def_brightness, max_brightness;
	106	int ret;
	107
067cfc1c IV	108	ret = dev_read_phandle_with_args(dev, "pwms", "#pwm-cells", 0, 0, &args);
	109	if (ret)
	110	return ret;
	111
	112	ret = uclass_get_device_by_ofnode(UCLASS_PWM, args.node, &priv->pwm);
	113	if (ret)
	114	return ret;
	115
	116	priv->channel = args.args[0];
	117	priv->period = args.args[1];
	118	priv->active_low = dev_read_bool(dev, "active-low");
	119
	120	def_brightness = dev_read_u32_default(dev, "u-boot,default-brightness", 0);
	121	max_brightness = dev_read_u32_default(dev, "max-brightness", 255);
	122	priv->enabled = !!def_brightness;
	123
	124	/*
3708739e	125	* No need to handle pwm inverted case (active_low)
067cfc1c IV	126	* because of pwm_set_invert function
	127	*/
	128	if (def_brightness < max_brightness)
	129	priv->duty = priv->period * def_brightness / max_brightness;
	130	else
	131	priv->duty = priv->period;
	132
	133	return 0;
	134	}
	135
	136	static int led_pwm_bind(struct udevice *parent)
	137	{
d45e712f	138	return led_bind_generic(parent, LEDS_PWM_DRIVER_NAME);
067cfc1c IV	139	}
	140
	141	static const struct led_ops led_pwm_ops = {
	142	.set_state = led_pwm_set_state,
	143	.get_state = led_pwm_get_state,
	144	};
	145
	146	static const struct udevice_id led_pwm_ids[] = {
	147	{ .compatible = "pwm-leds" },
	148	{ }
	149	};
	150
	151	U_BOOT_DRIVER(led_pwm) = {
	152	.name = LEDS_PWM_DRIVER_NAME,
	153	.id = UCLASS_LED,
067cfc1c IV	154	.ops = &led_pwm_ops,
067cfc1c IV	155	.priv_auto = sizeof(struct led_pwm_priv),
067cfc1c IV	156	.probe = led_pwm_probe,
	157	.of_to_plat = led_pwm_of_to_plat,
	158	};
e3812b5b SH	159
	160	U_BOOT_DRIVER(led_pwm_wrap) = {
	161	.name = LEDS_PWM_DRIVER_NAME "_wrap",
	162	.id = UCLASS_NOP,
	163	.of_match = led_pwm_ids,
	164	.bind = led_pwm_bind,
	165	};