leds-ktd2692.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * LED driver : leds-ktd2692.c
  4 *
  5 * Copyright (C) 2015 Samsung Electronics
  6 * Ingi Kim <ingi2.kim@samsung.com>
  7 */
  8
  9#include <linux/cleanup.h>
 10#include <linux/err.h>
 11#include <linux/gpio/consumer.h>
 12#include <linux/leds-expresswire.h>
 13#include <linux/led-class-flash.h>
 14#include <linux/module.h>
 15#include <linux/mutex.h>
 16#include <linux/of.h>
 17#include <linux/platform_device.h>
 18#include <linux/regulator/consumer.h>
 19
 20/* Value related the movie mode */
 21#define KTD2692_MOVIE_MODE_CURRENT_LEVELS	16
 22#define KTD2692_MM_TO_FL_RATIO(x)		((x) / 3)
 23#define KTD2692_MM_MIN_CURR_THRESHOLD_SCALE	8
 24
 25/* Value related the flash mode */
 26#define KTD2692_FLASH_MODE_TIMEOUT_LEVELS	8
 27#define KTD2692_FLASH_MODE_TIMEOUT_DISABLE	0
 28#define KTD2692_FLASH_MODE_CURR_PERCENT(x)	(((x) * 16) / 100)
 29
 30/* Macro for getting offset of flash timeout */
 31#define GET_TIMEOUT_OFFSET(timeout, step)	((timeout) / (step))
 32
 33/* Base register address */
 34#define KTD2692_REG_LVP_BASE			0x00
 35#define KTD2692_REG_FLASH_TIMEOUT_BASE		0x20
 36#define KTD2692_REG_MM_MIN_CURR_THRESHOLD_BASE	0x40
 37#define KTD2692_REG_MOVIE_CURRENT_BASE		0x60
 38#define KTD2692_REG_FLASH_CURRENT_BASE		0x80
 39#define KTD2692_REG_MODE_BASE			0xA0
 40
 41/* KTD2692 default length of name */
 42#define KTD2692_NAME_LENGTH			20
 43
 44/* Movie / Flash Mode Control */
 45enum ktd2692_led_mode {
 46	KTD2692_MODE_DISABLE = 0,	/* default */
 47	KTD2692_MODE_MOVIE,
 48	KTD2692_MODE_FLASH,
 49};
 50
 51struct ktd2692_led_config_data {
 52	/* maximum LED current in movie mode */
 53	u32 movie_max_microamp;
 54	/* maximum LED current in flash mode */
 55	u32 flash_max_microamp;
 56	/* maximum flash timeout */
 57	u32 flash_max_timeout;
 58	/* max LED brightness level */
 59	enum led_brightness max_brightness;
 60};
 61
 62const struct expresswire_timing ktd2692_timing = {
 63	.poweroff_us = 700,
 64	.data_start_us = 10,
 65	.end_of_data_low_us = 10,
 66	.end_of_data_high_us = 350,
 67	.short_bitset_us = 4,
 68	.long_bitset_us = 12
 69};
 70
 71struct ktd2692_context {
 72	/* Common ExpressWire properties (ctrl GPIO and timing) */
 73	struct expresswire_common_props props;
 74
 75	/* Related LED Flash class device */
 76	struct led_classdev_flash fled_cdev;
 77
 78	/* secures access to the device */
 79	struct mutex lock;
 80	struct regulator *regulator;
 81
 82	struct gpio_desc *aux_gpio;
 83
 84	enum ktd2692_led_mode mode;
 85	enum led_brightness torch_brightness;
 86};
 87
 88static struct ktd2692_context *fled_cdev_to_led(
 89				struct led_classdev_flash *fled_cdev)
 90{
 91	return container_of(fled_cdev, struct ktd2692_context, fled_cdev);
 92}
 93
 94static int ktd2692_led_brightness_set(struct led_classdev *led_cdev,
 95				       enum led_brightness brightness)
 96{
 97	struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev);
 98	struct ktd2692_context *led = fled_cdev_to_led(fled_cdev);
 99
100	mutex_lock(&led->lock);
101
102	if (brightness == LED_OFF) {
103		led->mode = KTD2692_MODE_DISABLE;
104		gpiod_direction_output(led->aux_gpio, 0);
105	} else {
106		expresswire_write_u8(&led->props, brightness |
107					KTD2692_REG_MOVIE_CURRENT_BASE);
108		led->mode = KTD2692_MODE_MOVIE;
109	}
110
111	expresswire_write_u8(&led->props, led->mode | KTD2692_REG_MODE_BASE);
112	mutex_unlock(&led->lock);
113
114	return 0;
115}
116
117static int ktd2692_led_flash_strobe_set(struct led_classdev_flash *fled_cdev,
118					bool state)
119{
120	struct ktd2692_context *led = fled_cdev_to_led(fled_cdev);
121	struct led_flash_setting *timeout = &fled_cdev->timeout;
122	u32 flash_tm_reg;
123
124	mutex_lock(&led->lock);
125
126	if (state) {
127		flash_tm_reg = GET_TIMEOUT_OFFSET(timeout->val, timeout->step);
128		expresswire_write_u8(&led->props, flash_tm_reg
129				| KTD2692_REG_FLASH_TIMEOUT_BASE);
130
131		led->mode = KTD2692_MODE_FLASH;
132		gpiod_direction_output(led->aux_gpio, 1);
133	} else {
134		led->mode = KTD2692_MODE_DISABLE;
135		gpiod_direction_output(led->aux_gpio, 0);
136	}
137
138	expresswire_write_u8(&led->props, led->mode | KTD2692_REG_MODE_BASE);
139
140	fled_cdev->led_cdev.brightness = LED_OFF;
141	led->mode = KTD2692_MODE_DISABLE;
142
143	mutex_unlock(&led->lock);
144
145	return 0;
146}
147
148static int ktd2692_led_flash_timeout_set(struct led_classdev_flash *fled_cdev,
149					 u32 timeout)
150{
151	return 0;
152}
153
154static void ktd2692_init_movie_current_max(struct ktd2692_led_config_data *cfg)
155{
156	u32 offset, step;
157	u32 movie_current_microamp;
158
159	offset = KTD2692_MOVIE_MODE_CURRENT_LEVELS;
160	step = KTD2692_MM_TO_FL_RATIO(cfg->flash_max_microamp)
161		/ KTD2692_MOVIE_MODE_CURRENT_LEVELS;
162
163	do {
164		movie_current_microamp = step * offset;
165		offset--;
166	} while ((movie_current_microamp > cfg->movie_max_microamp) &&
167		(offset > 0));
168
169	cfg->max_brightness = offset;
170}
171
172static void ktd2692_init_flash_timeout(struct led_classdev_flash *fled_cdev,
173				       struct ktd2692_led_config_data *cfg)
174{
175	struct led_flash_setting *setting;
176
177	setting = &fled_cdev->timeout;
178	setting->min = KTD2692_FLASH_MODE_TIMEOUT_DISABLE;
179	setting->max = cfg->flash_max_timeout;
180	setting->step = cfg->flash_max_timeout
181			/ (KTD2692_FLASH_MODE_TIMEOUT_LEVELS - 1);
182	setting->val = cfg->flash_max_timeout;
183}
184
185static void ktd2692_setup(struct ktd2692_context *led)
186{
187	led->mode = KTD2692_MODE_DISABLE;
188	expresswire_power_off(&led->props);
189	gpiod_direction_output(led->aux_gpio, 0);
190
191	expresswire_write_u8(&led->props, (KTD2692_MM_MIN_CURR_THRESHOLD_SCALE - 1)
192				 | KTD2692_REG_MM_MIN_CURR_THRESHOLD_BASE);
193	expresswire_write_u8(&led->props, KTD2692_FLASH_MODE_CURR_PERCENT(45)
194				 | KTD2692_REG_FLASH_CURRENT_BASE);
195}
196
197static void regulator_disable_action(void *_data)
198{
199	struct device *dev = _data;
200	struct ktd2692_context *led = dev_get_drvdata(dev);
201	int ret;
202
203	ret = regulator_disable(led->regulator);
204	if (ret)
205		dev_err(dev, "Failed to disable supply: %d\n", ret);
206}
207
208static int ktd2692_parse_dt(struct ktd2692_context *led, struct device *dev,
209			    struct ktd2692_led_config_data *cfg)
210{
211	struct device_node *np = dev_of_node(dev);
212	int ret;
213
214	if (!np)
215		return -ENXIO;
216
217	led->props.ctrl_gpio = devm_gpiod_get(dev, "ctrl", GPIOD_ASIS);
218	ret = PTR_ERR_OR_ZERO(led->props.ctrl_gpio);
219	if (ret)
220		return dev_err_probe(dev, ret, "cannot get ctrl-gpios\n");
221
222	led->aux_gpio = devm_gpiod_get_optional(dev, "aux", GPIOD_ASIS);
223	if (IS_ERR(led->aux_gpio))
224		return dev_err_probe(dev, PTR_ERR(led->aux_gpio), "cannot get aux-gpios\n");
225
226	led->regulator = devm_regulator_get(dev, "vin");
227	if (IS_ERR(led->regulator))
228		led->regulator = NULL;
229
230	if (led->regulator) {
231		ret = regulator_enable(led->regulator);
232		if (ret) {
233			dev_err(dev, "Failed to enable supply: %d\n", ret);
234		} else {
235			ret = devm_add_action_or_reset(dev,
236						regulator_disable_action, dev);
237			if (ret)
238				return ret;
239		}
240	}
241
242	struct device_node *child_node __free(device_node) =
243		of_get_next_available_child(np, NULL);
244	if (!child_node) {
245		dev_err(dev, "No DT child node found for connected LED.\n");
246		return -EINVAL;
247	}
248
249	led->fled_cdev.led_cdev.name =
250		of_get_property(child_node, "label", NULL) ? : child_node->name;
251
252	ret = of_property_read_u32(child_node, "led-max-microamp",
253				   &cfg->movie_max_microamp);
254	if (ret) {
255		dev_err(dev, "failed to parse led-max-microamp\n");
256		return ret;
257	}
258
259	ret = of_property_read_u32(child_node, "flash-max-microamp",
260				   &cfg->flash_max_microamp);
261	if (ret) {
262		dev_err(dev, "failed to parse flash-max-microamp\n");
263		return ret;
264	}
265
266	ret = of_property_read_u32(child_node, "flash-max-timeout-us",
267				   &cfg->flash_max_timeout);
268	if (ret) {
269		dev_err(dev, "failed to parse flash-max-timeout-us\n");
270		return ret;
271	}
272
273	return 0;
274}
275
276static const struct led_flash_ops flash_ops = {
277	.strobe_set = ktd2692_led_flash_strobe_set,
278	.timeout_set = ktd2692_led_flash_timeout_set,
279};
280
281static int ktd2692_probe(struct platform_device *pdev)
282{
283	struct ktd2692_context *led;
284	struct led_classdev *led_cdev;
285	struct led_classdev_flash *fled_cdev;
286	struct ktd2692_led_config_data led_cfg;
287	int ret;
288
289	led = devm_kzalloc(&pdev->dev, sizeof(*led), GFP_KERNEL);
290	if (!led)
291		return -ENOMEM;
292
293	fled_cdev = &led->fled_cdev;
294	led_cdev = &fled_cdev->led_cdev;
295	led->props.timing = ktd2692_timing;
296
297	ret = ktd2692_parse_dt(led, &pdev->dev, &led_cfg);
298	if (ret)
299		return ret;
300
301	ktd2692_init_flash_timeout(fled_cdev, &led_cfg);
302	ktd2692_init_movie_current_max(&led_cfg);
303
304	fled_cdev->ops = &flash_ops;
305
306	led_cdev->max_brightness = led_cfg.max_brightness;
307	led_cdev->brightness_set_blocking = ktd2692_led_brightness_set;
308	led_cdev->flags |= LED_CORE_SUSPENDRESUME | LED_DEV_CAP_FLASH;
309
310	mutex_init(&led->lock);
311
312	platform_set_drvdata(pdev, led);
313
314	ret = led_classdev_flash_register(&pdev->dev, fled_cdev);
315	if (ret) {
316		dev_err(&pdev->dev, "can't register LED %s\n", led_cdev->name);
317		mutex_destroy(&led->lock);
318		return ret;
319	}
320
321	ktd2692_setup(led);
322
323	return 0;
324}
325
326static void ktd2692_remove(struct platform_device *pdev)
327{
328	struct ktd2692_context *led = platform_get_drvdata(pdev);
329
330	led_classdev_flash_unregister(&led->fled_cdev);
331
332	mutex_destroy(&led->lock);
333}
334
335static const struct of_device_id ktd2692_match[] = {
336	{ .compatible = "kinetic,ktd2692", },
337	{ /* sentinel */ },
338};
339MODULE_DEVICE_TABLE(of, ktd2692_match);
340
341static struct platform_driver ktd2692_driver = {
342	.driver = {
343		.name  = "ktd2692",
344		.of_match_table = ktd2692_match,
345	},
346	.probe  = ktd2692_probe,
347	.remove = ktd2692_remove,
348};
349
350module_platform_driver(ktd2692_driver);
351
352MODULE_IMPORT_NS("EXPRESSWIRE");
353MODULE_AUTHOR("Ingi Kim <ingi2.kim@samsung.com>");
354MODULE_DESCRIPTION("Kinetic KTD2692 LED driver");
355MODULE_LICENSE("GPL v2");