1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * leds-regulator.c - LED class driver for regulator driven LEDs.
  4 *
  5 * Copyright (C) 2009 Antonio Ospite <ospite@studenti.unina.it>
  6 *
  7 * Inspired by leds-wm8350 driver.
 
 
 
 
 
  8 */
  9
 10#include <linux/module.h>
 11#include <linux/mod_devicetable.h>
 12#include <linux/err.h>
 13#include <linux/slab.h>
 
 14#include <linux/leds.h>
 15#include <linux/leds-regulator.h>
 16#include <linux/platform_device.h>
 17#include <linux/regulator/consumer.h>
 18
 19#define to_regulator_led(led_cdev) \
 20	container_of(led_cdev, struct regulator_led, cdev)
 21
 22struct regulator_led {
 23	struct led_classdev cdev;
 
 24	int enabled;
 25	struct mutex mutex;
 
 26
 27	struct regulator *vcc;
 28};
 29
 30static inline int led_regulator_get_max_brightness(struct regulator *supply)
 31{
 32	int ret;
 33	int voltage = regulator_list_voltage(supply, 0);
 34
 35	if (voltage <= 0)
 36		return 1;
 37
 38	/* even if regulator can't change voltages,
 39	 * we still assume it can change status
 40	 * and the LED can be turned on and off.
 41	 */
 42	ret = regulator_set_voltage(supply, voltage, voltage);
 43	if (ret < 0)
 44		return 1;
 45
 46	return regulator_count_voltages(supply);
 47}
 48
 49static int led_regulator_get_voltage(struct regulator *supply,
 50		enum led_brightness brightness)
 51{
 52	if (brightness == 0)
 53		return -EINVAL;
 54
 55	return regulator_list_voltage(supply, brightness - 1);
 56}
 57
 58
 59static void regulator_led_enable(struct regulator_led *led)
 60{
 61	int ret;
 62
 63	if (led->enabled)
 64		return;
 65
 66	ret = regulator_enable(led->vcc);
 67	if (ret != 0) {
 68		dev_err(led->cdev.dev, "Failed to enable vcc: %d\n", ret);
 69		return;
 70	}
 71
 72	led->enabled = 1;
 73}
 74
 75static void regulator_led_disable(struct regulator_led *led)
 76{
 77	int ret;
 78
 79	if (!led->enabled)
 80		return;
 81
 82	ret = regulator_disable(led->vcc);
 83	if (ret != 0) {
 84		dev_err(led->cdev.dev, "Failed to disable vcc: %d\n", ret);
 85		return;
 86	}
 87
 88	led->enabled = 0;
 89}
 90
 91static int regulator_led_brightness_set(struct led_classdev *led_cdev,
 92					 enum led_brightness value)
 93{
 94	struct regulator_led *led = to_regulator_led(led_cdev);
 95	int voltage;
 96	int ret = 0;
 97
 98	mutex_lock(&led->mutex);
 99
100	if (value == LED_OFF) {
101		regulator_led_disable(led);
102		goto out;
103	}
104
105	if (led->cdev.max_brightness > 1) {
106		voltage = led_regulator_get_voltage(led->vcc, value);
107		dev_dbg(led->cdev.dev, "brightness: %d voltage: %d\n",
108				value, voltage);
109
110		ret = regulator_set_voltage(led->vcc, voltage, voltage);
111		if (ret != 0)
112			dev_err(led->cdev.dev, "Failed to set voltage %d: %d\n",
113				voltage, ret);
114	}
115
116	regulator_led_enable(led);
117
118out:
119	mutex_unlock(&led->mutex);
120	return ret;
121}
122
123static int regulator_led_probe(struct platform_device *pdev)
124{
125	struct led_regulator_platform_data *pdata =
126			dev_get_platdata(&pdev->dev);
127	struct device *dev = &pdev->dev;
128	struct led_init_data init_data = {};
 
 
 
 
 
 
 
 
 
 
 
 
 
 
129	struct regulator_led *led;
130	struct regulator *vcc;
131	int ret = 0;
132
133	vcc = devm_regulator_get_exclusive(dev, "vled");
 
 
 
 
 
134	if (IS_ERR(vcc)) {
135		dev_err(dev, "Cannot get vcc\n");
136		return PTR_ERR(vcc);
137	}
138
139	led = devm_kzalloc(dev, sizeof(*led), GFP_KERNEL);
140	if (led == NULL)
141		return -ENOMEM;
142
143	init_data.fwnode = dev->fwnode;
144
145	led->cdev.max_brightness = led_regulator_get_max_brightness(vcc);
146	/* Legacy platform data label assignment */
147	if (pdata) {
148		if (pdata->brightness > led->cdev.max_brightness) {
149			dev_err(dev, "Invalid default brightness %d\n",
150				pdata->brightness);
151			return -EINVAL;
152		}
153		led->cdev.brightness = pdata->brightness;
154		init_data.default_label = pdata->name;
155	}
 
156
157	led->cdev.brightness_set_blocking = regulator_led_brightness_set;
 
158	led->cdev.flags |= LED_CORE_SUSPENDRESUME;
159	led->vcc = vcc;
160
161	/* to handle correctly an already enabled regulator */
162	if (regulator_is_enabled(led->vcc))
163		led->enabled = 1;
164
165	mutex_init(&led->mutex);
 
166
167	platform_set_drvdata(pdev, led);
168
169	ret = led_classdev_register_ext(dev, &led->cdev, &init_data);
170	if (ret < 0)
171		return ret;
 
 
 
 
 
 
 
 
172
173	return 0;
 
 
 
 
 
 
174}
175
176static void regulator_led_remove(struct platform_device *pdev)
177{
178	struct regulator_led *led = platform_get_drvdata(pdev);
179
180	led_classdev_unregister(&led->cdev);
 
181	regulator_led_disable(led);
 
 
 
182}
183
184static const struct of_device_id regulator_led_of_match[] = {
185	{ .compatible = "regulator-led", },
186	{}
187};
188MODULE_DEVICE_TABLE(of, regulator_led_of_match);
189
190static struct platform_driver regulator_led_driver = {
191	.driver = {
192		.name  = "leds-regulator",
193		.of_match_table = regulator_led_of_match,
194	},
195	.probe  = regulator_led_probe,
196	.remove_new = regulator_led_remove,
197};
198
199module_platform_driver(regulator_led_driver);
 
 
 
 
 
 
 
 
 
 
200
201MODULE_AUTHOR("Antonio Ospite <ospite@studenti.unina.it>");
202MODULE_DESCRIPTION("Regulator driven LED driver");
203MODULE_LICENSE("GPL");
204MODULE_ALIAS("platform:leds-regulator");

 
  1/*
  2 * leds-regulator.c - LED class driver for regulator driven LEDs.
  3 *
  4 * Copyright (C) 2009 Antonio Ospite <ospite@studenti.unina.it>
  5 *
  6 * Inspired by leds-wm8350 driver.
  7 *
  8 * This program is free software; you can redistribute it and/or modify
  9 * it under the terms of the GNU General Public License version 2 as
 10 * published by the Free Software Foundation.
 11 *
 12 */
 13
 14#include <linux/module.h>
 
 15#include <linux/err.h>
 16#include <linux/slab.h>
 17#include <linux/workqueue.h>
 18#include <linux/leds.h>
 19#include <linux/leds-regulator.h>
 20#include <linux/platform_device.h>
 21#include <linux/regulator/consumer.h>
 22
 23#define to_regulator_led(led_cdev) \
 24	container_of(led_cdev, struct regulator_led, cdev)
 25
 26struct regulator_led {
 27	struct led_classdev cdev;
 28	enum led_brightness value;
 29	int enabled;
 30	struct mutex mutex;
 31	struct work_struct work;
 32
 33	struct regulator *vcc;
 34};
 35
 36static inline int led_regulator_get_max_brightness(struct regulator *supply)
 37{
 38	int ret;
 39	int voltage = regulator_list_voltage(supply, 0);
 40
 41	if (voltage <= 0)
 42		return 1;
 43
 44	/* even if regulator can't change voltages,
 45	 * we still assume it can change status
 46	 * and the LED can be turned on and off.
 47	 */
 48	ret = regulator_set_voltage(supply, voltage, voltage);
 49	if (ret < 0)
 50		return 1;
 51
 52	return regulator_count_voltages(supply);
 53}
 54
 55static int led_regulator_get_voltage(struct regulator *supply,
 56		enum led_brightness brightness)
 57{
 58	if (brightness == 0)
 59		return -EINVAL;
 60
 61	return regulator_list_voltage(supply, brightness - 1);
 62}
 63
 64
 65static void regulator_led_enable(struct regulator_led *led)
 66{
 67	int ret;
 68
 69	if (led->enabled)
 70		return;
 71
 72	ret = regulator_enable(led->vcc);
 73	if (ret != 0) {
 74		dev_err(led->cdev.dev, "Failed to enable vcc: %d\n", ret);
 75		return;
 76	}
 77
 78	led->enabled = 1;
 79}
 80
 81static void regulator_led_disable(struct regulator_led *led)
 82{
 83	int ret;
 84
 85	if (!led->enabled)
 86		return;
 87
 88	ret = regulator_disable(led->vcc);
 89	if (ret != 0) {
 90		dev_err(led->cdev.dev, "Failed to disable vcc: %d\n", ret);
 91		return;
 92	}
 93
 94	led->enabled = 0;
 95}
 96
 97static void regulator_led_set_value(struct regulator_led *led)
 
 98{
 
 99	int voltage;
100	int ret;
101
102	mutex_lock(&led->mutex);
103
104	if (led->value == LED_OFF) {
105		regulator_led_disable(led);
106		goto out;
107	}
108
109	if (led->cdev.max_brightness > 1) {
110		voltage = led_regulator_get_voltage(led->vcc, led->value);
111		dev_dbg(led->cdev.dev, "brightness: %d voltage: %d\n",
112				led->value, voltage);
113
114		ret = regulator_set_voltage(led->vcc, voltage, voltage);
115		if (ret != 0)
116			dev_err(led->cdev.dev, "Failed to set voltage %d: %d\n",
117				voltage, ret);
118	}
119
120	regulator_led_enable(led);
121
122out:
123	mutex_unlock(&led->mutex);
 
124}
125
126static void led_work(struct work_struct *work)
127{
128	struct regulator_led *led;
129
130	led = container_of(work, struct regulator_led, work);
131	regulator_led_set_value(led);
132}
133
134static void regulator_led_brightness_set(struct led_classdev *led_cdev,
135			   enum led_brightness value)
136{
137	struct regulator_led *led = to_regulator_led(led_cdev);
138
139	led->value = value;
140	schedule_work(&led->work);
141}
142
143static int __devinit regulator_led_probe(struct platform_device *pdev)
144{
145	struct led_regulator_platform_data *pdata = pdev->dev.platform_data;
146	struct regulator_led *led;
147	struct regulator *vcc;
148	int ret = 0;
149
150	if (pdata == NULL) {
151		dev_err(&pdev->dev, "no platform data\n");
152		return -ENODEV;
153	}
154
155	vcc = regulator_get_exclusive(&pdev->dev, "vled");
156	if (IS_ERR(vcc)) {
157		dev_err(&pdev->dev, "Cannot get vcc for %s\n", pdata->name);
158		return PTR_ERR(vcc);
159	}
160
161	led = kzalloc(sizeof(*led), GFP_KERNEL);
162	if (led == NULL) {
163		ret = -ENOMEM;
164		goto err_vcc;
165	}
166
167	led->cdev.max_brightness = led_regulator_get_max_brightness(vcc);
168	if (pdata->brightness > led->cdev.max_brightness) {
169		dev_err(&pdev->dev, "Invalid default brightness %d\n",
 
 
170				pdata->brightness);
171		ret = -EINVAL;
172		goto err_led;
 
 
173	}
174	led->value = pdata->brightness;
175
176	led->cdev.brightness_set = regulator_led_brightness_set;
177	led->cdev.name = pdata->name;
178	led->cdev.flags |= LED_CORE_SUSPENDRESUME;
179	led->vcc = vcc;
180
181	/* to handle correctly an already enabled regulator */
182	if (regulator_is_enabled(led->vcc))
183		led->enabled = 1;
184
185	mutex_init(&led->mutex);
186	INIT_WORK(&led->work, led_work);
187
188	platform_set_drvdata(pdev, led);
189
190	ret = led_classdev_register(&pdev->dev, &led->cdev);
191	if (ret < 0) {
192		cancel_work_sync(&led->work);
193		goto err_led;
194	}
195
196	/* to expose the default value to userspace */
197	led->cdev.brightness = led->value;
198
199	/* Set the default led status */
200	regulator_led_set_value(led);
201
202	return 0;
203
204err_led:
205	kfree(led);
206err_vcc:
207	regulator_put(vcc);
208	return ret;
209}
210
211static int __devexit regulator_led_remove(struct platform_device *pdev)
212{
213	struct regulator_led *led = platform_get_drvdata(pdev);
214
215	led_classdev_unregister(&led->cdev);
216	cancel_work_sync(&led->work);
217	regulator_led_disable(led);
218	regulator_put(led->vcc);
219	kfree(led);
220	return 0;
221}
222
 
 
 
 
 
 
223static struct platform_driver regulator_led_driver = {
224	.driver = {
225		   .name  = "leds-regulator",
226		   .owner = THIS_MODULE,
227		   },
228	.probe  = regulator_led_probe,
229	.remove = __devexit_p(regulator_led_remove),
230};
231
232static int __init regulator_led_init(void)
233{
234	return platform_driver_register(&regulator_led_driver);
235}
236module_init(regulator_led_init);
237
238static void __exit regulator_led_exit(void)
239{
240	platform_driver_unregister(&regulator_led_driver);
241}
242module_exit(regulator_led_exit);
243
244MODULE_AUTHOR("Antonio Ospite <ospite@studenti.unina.it>");
245MODULE_DESCRIPTION("Regulator driven LED driver");
246MODULE_LICENSE("GPL");
247MODULE_ALIAS("platform:leds-regulator");