[mirror_ubuntu-hirsute-kernel.git] / drivers / leds / leds-ktd2692.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * LED driver : leds-ktd2692.c
 *
 * Copyright (C) 2015 Samsung Electronics
 * Ingi Kim <ingi2.kim@samsung.com>
 */

#include <linux/delay.h>
#include <linux/err.h>
#include <linux/gpio/consumer.h>
#include <linux/led-class-flash.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/regulator/consumer.h>

/* Value related the movie mode */
#define KTD2692_MOVIE_MODE_CURRENT_LEVELS	16
#define KTD2692_MM_TO_FL_RATIO(x)		((x) / 3)
#define KTD2962_MM_MIN_CURR_THRESHOLD_SCALE	8

/* Value related the flash mode */
#define KTD2692_FLASH_MODE_TIMEOUT_LEVELS	8
#define KTD2692_FLASH_MODE_TIMEOUT_DISABLE	0
#define KTD2692_FLASH_MODE_CURR_PERCENT(x)	(((x) * 16) / 100)

/* Macro for getting offset of flash timeout */
#define GET_TIMEOUT_OFFSET(timeout, step)	((timeout) / (step))

/* Base register address */
#define KTD2692_REG_LVP_BASE			0x00
#define KTD2692_REG_FLASH_TIMEOUT_BASE		0x20
#define KTD2692_REG_MM_MIN_CURR_THRESHOLD_BASE	0x40
#define KTD2692_REG_MOVIE_CURRENT_BASE		0x60
#define KTD2692_REG_FLASH_CURRENT_BASE		0x80
#define KTD2692_REG_MODE_BASE			0xA0

/* Set bit coding time for expresswire interface */
#define KTD2692_TIME_RESET_US			700
#define KTD2692_TIME_DATA_START_TIME_US		10
#define KTD2692_TIME_HIGH_END_OF_DATA_US	350
#define KTD2692_TIME_LOW_END_OF_DATA_US		10
#define KTD2692_TIME_SHORT_BITSET_US		4
#define KTD2692_TIME_LONG_BITSET_US		12

/* KTD2692 default length of name */
#define KTD2692_NAME_LENGTH			20

enum ktd2692_bitset {
	KTD2692_LOW = 0,
	KTD2692_HIGH,
};

/* Movie / Flash Mode Control */
enum ktd2692_led_mode {
	KTD2692_MODE_DISABLE = 0,	/* default */
	KTD2692_MODE_MOVIE,
	KTD2692_MODE_FLASH,
};

struct ktd2692_led_config_data {
	/* maximum LED current in movie mode */
	u32 movie_max_microamp;
	/* maximum LED current in flash mode */
	u32 flash_max_microamp;
	/* maximum flash timeout */
	u32 flash_max_timeout;
	/* max LED brightness level */
	enum led_brightness max_brightness;
};

struct ktd2692_context {
	/* Related LED Flash class device */
	struct led_classdev_flash fled_cdev;

	/* secures access to the device */
	struct mutex lock;
	struct regulator *regulator;

	struct gpio_desc *aux_gpio;
	struct gpio_desc *ctrl_gpio;

	enum ktd2692_led_mode mode;
	enum led_brightness torch_brightness;
};

static struct ktd2692_context *fled_cdev_to_led(
				struct led_classdev_flash *fled_cdev)
{
	return container_of(fled_cdev, struct ktd2692_context, fled_cdev);
}

static void ktd2692_expresswire_start(struct ktd2692_context *led)
{
	gpiod_direction_output(led->ctrl_gpio, KTD2692_HIGH);
	udelay(KTD2692_TIME_DATA_START_TIME_US);
}

static void ktd2692_expresswire_reset(struct ktd2692_context *led)
{
	gpiod_direction_output(led->ctrl_gpio, KTD2692_LOW);
	udelay(KTD2692_TIME_RESET_US);
}

static void ktd2692_expresswire_end(struct ktd2692_context *led)
{
	gpiod_direction_output(led->ctrl_gpio, KTD2692_LOW);
	udelay(KTD2692_TIME_LOW_END_OF_DATA_US);
	gpiod_direction_output(led->ctrl_gpio, KTD2692_HIGH);
	udelay(KTD2692_TIME_HIGH_END_OF_DATA_US);
}

static void ktd2692_expresswire_set_bit(struct ktd2692_context *led, bool bit)
{
	/*
	 * The Low Bit(0) and High Bit(1) is based on a time detection
	 * algorithm between time low and time high
	 * Time_(L_LB) : Low time of the Low Bit(0)
	 * Time_(H_LB) : High time of the LOW Bit(0)
	 * Time_(L_HB) : Low time of the High Bit(1)
	 * Time_(H_HB) : High time of the High Bit(1)
	 *
	 * It can be simplified to:
	 * Low Bit(0) : 2 * Time_(H_LB) < Time_(L_LB)
	 * High Bit(1) : 2 * Time_(L_HB) < Time_(H_HB)
	 * HIGH  ___           ____    _..     _________    ___
	 *          |_________|    |_..  |____|         |__|
	 * LOW        <L_LB>  <H_LB>     <L_HB>  <H_HB>
	 *          [  Low Bit (0) ]     [  High Bit(1) ]
	 */
	if (bit) {
		gpiod_direction_output(led->ctrl_gpio, KTD2692_LOW);
		udelay(KTD2692_TIME_SHORT_BITSET_US);
		gpiod_direction_output(led->ctrl_gpio, KTD2692_HIGH);
		udelay(KTD2692_TIME_LONG_BITSET_US);
	} else {
		gpiod_direction_output(led->ctrl_gpio, KTD2692_LOW);
		udelay(KTD2692_TIME_LONG_BITSET_US);
		gpiod_direction_output(led->ctrl_gpio, KTD2692_HIGH);
		udelay(KTD2692_TIME_SHORT_BITSET_US);
	}
}

static void ktd2692_expresswire_write(struct ktd2692_context *led, u8 value)
{
	int i;

	ktd2692_expresswire_start(led);
	for (i = 7; i >= 0; i--)
		ktd2692_expresswire_set_bit(led, value & BIT(i));
	ktd2692_expresswire_end(led);
}

static int ktd2692_led_brightness_set(struct led_classdev *led_cdev,
				       enum led_brightness brightness)
{
	struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev);
	struct ktd2692_context *led = fled_cdev_to_led(fled_cdev);

	mutex_lock(&led->lock);

	if (brightness == LED_OFF) {
		led->mode = KTD2692_MODE_DISABLE;
		gpiod_direction_output(led->aux_gpio, KTD2692_LOW);
	} else {
		ktd2692_expresswire_write(led, brightness |
					KTD2692_REG_MOVIE_CURRENT_BASE);
		led->mode = KTD2692_MODE_MOVIE;
	}

	ktd2692_expresswire_write(led, led->mode | KTD2692_REG_MODE_BASE);
	mutex_unlock(&led->lock);

	return 0;
}

static int ktd2692_led_flash_strobe_set(struct led_classdev_flash *fled_cdev,
					bool state)
{
	struct ktd2692_context *led = fled_cdev_to_led(fled_cdev);
	struct led_flash_setting *timeout = &fled_cdev->timeout;
	u32 flash_tm_reg;

	mutex_lock(&led->lock);

	if (state) {
		flash_tm_reg = GET_TIMEOUT_OFFSET(timeout->val, timeout->step);
		ktd2692_expresswire_write(led, flash_tm_reg
				| KTD2692_REG_FLASH_TIMEOUT_BASE);

		led->mode = KTD2692_MODE_FLASH;
		gpiod_direction_output(led->aux_gpio, KTD2692_HIGH);
	} else {
		led->mode = KTD2692_MODE_DISABLE;
		gpiod_direction_output(led->aux_gpio, KTD2692_LOW);
	}

	ktd2692_expresswire_write(led, led->mode | KTD2692_REG_MODE_BASE);

	fled_cdev->led_cdev.brightness = LED_OFF;
	led->mode = KTD2692_MODE_DISABLE;

	mutex_unlock(&led->lock);

	return 0;
}

static int ktd2692_led_flash_timeout_set(struct led_classdev_flash *fled_cdev,
					 u32 timeout)
{
	return 0;
}

static void ktd2692_init_movie_current_max(struct ktd2692_led_config_data *cfg)
{
	u32 offset, step;
	u32 movie_current_microamp;

	offset = KTD2692_MOVIE_MODE_CURRENT_LEVELS;
	step = KTD2692_MM_TO_FL_RATIO(cfg->flash_max_microamp)
		/ KTD2692_MOVIE_MODE_CURRENT_LEVELS;

	do {
		movie_current_microamp = step * offset;
		offset--;
	} while ((movie_current_microamp > cfg->movie_max_microamp) &&
		(offset > 0));

	cfg->max_brightness = offset;
}

static void ktd2692_init_flash_timeout(struct led_classdev_flash *fled_cdev,
				       struct ktd2692_led_config_data *cfg)
{
	struct led_flash_setting *setting;

	setting = &fled_cdev->timeout;
	setting->min = KTD2692_FLASH_MODE_TIMEOUT_DISABLE;
	setting->max = cfg->flash_max_timeout;
	setting->step = cfg->flash_max_timeout
			/ (KTD2692_FLASH_MODE_TIMEOUT_LEVELS - 1);
	setting->val = cfg->flash_max_timeout;
}

static void ktd2692_setup(struct ktd2692_context *led)
{
	led->mode = KTD2692_MODE_DISABLE;
	ktd2692_expresswire_reset(led);
	gpiod_direction_output(led->aux_gpio, KTD2692_LOW);

	ktd2692_expresswire_write(led, (KTD2962_MM_MIN_CURR_THRESHOLD_SCALE - 1)
				 | KTD2692_REG_MM_MIN_CURR_THRESHOLD_BASE);
	ktd2692_expresswire_write(led, KTD2692_FLASH_MODE_CURR_PERCENT(45)
				 | KTD2692_REG_FLASH_CURRENT_BASE);
}

static int ktd2692_parse_dt(struct ktd2692_context *led, struct device *dev,
			    struct ktd2692_led_config_data *cfg)
{
	struct device_node *np = dev->of_node;
	struct device_node *child_node;
	int ret;

	if (!dev->of_node)
		return -ENXIO;

	led->ctrl_gpio = devm_gpiod_get(dev, "ctrl", GPIOD_ASIS);
	ret = PTR_ERR_OR_ZERO(led->ctrl_gpio);
	if (ret) {
		dev_err(dev, "cannot get ctrl-gpios %d\n", ret);
		return ret;
	}

	led->aux_gpio = devm_gpiod_get(dev, "aux", GPIOD_ASIS);
	ret = PTR_ERR_OR_ZERO(led->aux_gpio);
	if (ret) {
		dev_err(dev, "cannot get aux-gpios %d\n", ret);
		return ret;
	}

	led->regulator = devm_regulator_get(dev, "vin");
	if (IS_ERR(led->regulator))
		led->regulator = NULL;

	if (led->regulator) {
		ret = regulator_enable(led->regulator);
		if (ret)
			dev_err(dev, "Failed to enable supply: %d\n", ret);
	}

	child_node = of_get_next_available_child(np, NULL);
	if (!child_node) {
		dev_err(dev, "No DT child node found for connected LED.\n");
		return -EINVAL;
	}

	led->fled_cdev.led_cdev.name =
		of_get_property(child_node, "label", NULL) ? : child_node->name;

	ret = of_property_read_u32(child_node, "led-max-microamp",
				   &cfg->movie_max_microamp);
	if (ret) {
		dev_err(dev, "failed to parse led-max-microamp\n");
		goto err_parse_dt;
	}

	ret = of_property_read_u32(child_node, "flash-max-microamp",
				   &cfg->flash_max_microamp);
	if (ret) {
		dev_err(dev, "failed to parse flash-max-microamp\n");
		goto err_parse_dt;
	}

	ret = of_property_read_u32(child_node, "flash-max-timeout-us",
				   &cfg->flash_max_timeout);
	if (ret) {
		dev_err(dev, "failed to parse flash-max-timeout-us\n");
		goto err_parse_dt;
	}

err_parse_dt:
	of_node_put(child_node);
	return ret;
}

static const struct led_flash_ops flash_ops = {
	.strobe_set = ktd2692_led_flash_strobe_set,
	.timeout_set = ktd2692_led_flash_timeout_set,
};

static int ktd2692_probe(struct platform_device *pdev)
{
	struct ktd2692_context *led;
	struct led_classdev *led_cdev;
	struct led_classdev_flash *fled_cdev;
	struct ktd2692_led_config_data led_cfg;
	int ret;

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

	fled_cdev = &led->fled_cdev;
	led_cdev = &fled_cdev->led_cdev;

	ret = ktd2692_parse_dt(led, &pdev->dev, &led_cfg);
	if (ret)
		return ret;

	ktd2692_init_flash_timeout(fled_cdev, &led_cfg);
	ktd2692_init_movie_current_max(&led_cfg);

	fled_cdev->ops = &flash_ops;

	led_cdev->max_brightness = led_cfg.max_brightness;
	led_cdev->brightness_set_blocking = ktd2692_led_brightness_set;
	led_cdev->flags |= LED_CORE_SUSPENDRESUME | LED_DEV_CAP_FLASH;

	mutex_init(&led->lock);

	platform_set_drvdata(pdev, led);

	ret = led_classdev_flash_register(&pdev->dev, fled_cdev);
	if (ret) {
		dev_err(&pdev->dev, "can't register LED %s\n", led_cdev->name);
		mutex_destroy(&led->lock);
		return ret;
	}

	ktd2692_setup(led);

	return 0;
}

static int ktd2692_remove(struct platform_device *pdev)
{
	struct ktd2692_context *led = platform_get_drvdata(pdev);
	int ret;

	led_classdev_flash_unregister(&led->fled_cdev);

	if (led->regulator) {
		ret = regulator_disable(led->regulator);
		if (ret)
			dev_err(&pdev->dev,
				"Failed to disable supply: %d\n", ret);
	}

	mutex_destroy(&led->lock);

	return 0;
}

static const struct of_device_id ktd2692_match[] = {
	{ .compatible = "kinetic,ktd2692", },
	{ /* sentinel */ },
};
MODULE_DEVICE_TABLE(of, ktd2692_match);

static struct platform_driver ktd2692_driver = {
	.driver = {
		.name  = "ktd2692",
		.of_match_table = ktd2692_match,
	},
	.probe  = ktd2692_probe,
	.remove = ktd2692_remove,
};

module_platform_driver(ktd2692_driver);

MODULE_AUTHOR("Ingi Kim <ingi2.kim@samsung.com>");
MODULE_DESCRIPTION("Kinetic KTD2692 LED driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
b7da8c5c IK	2	/*
	3	* LED driver : leds-ktd2692.c
	4	*
	5	* Copyright (C) 2015 Samsung Electronics
	6	* Ingi Kim <ingi2.kim@samsung.com>
b7da8c5c IK	7	*/
	8
	9	#include <linux/delay.h>
	10	#include <linux/err.h>
	11	#include <linux/gpio/consumer.h>
	12	#include <linux/led-class-flash.h>
	13	#include <linux/module.h>
	14	#include <linux/mutex.h>
	15	#include <linux/of.h>
	16	#include <linux/platform_device.h>
	17	#include <linux/regulator/consumer.h>
b7da8c5c IK	18
	19	/* Value related the movie mode */
	20	#define KTD2692_MOVIE_MODE_CURRENT_LEVELS 16
	21	#define KTD2692_MM_TO_FL_RATIO(x) ((x) / 3)
	22	#define KTD2962_MM_MIN_CURR_THRESHOLD_SCALE 8
	23
	24	/* Value related the flash mode */
	25	#define KTD2692_FLASH_MODE_TIMEOUT_LEVELS 8
	26	#define KTD2692_FLASH_MODE_TIMEOUT_DISABLE 0
	27	#define KTD2692_FLASH_MODE_CURR_PERCENT(x) (((x) * 16) / 100)
	28
	29	/* Macro for getting offset of flash timeout */
	30	#define GET_TIMEOUT_OFFSET(timeout, step) ((timeout) / (step))
	31
	32	/* Base register address */
	33	#define KTD2692_REG_LVP_BASE 0x00
	34	#define KTD2692_REG_FLASH_TIMEOUT_BASE 0x20
	35	#define KTD2692_REG_MM_MIN_CURR_THRESHOLD_BASE 0x40
	36	#define KTD2692_REG_MOVIE_CURRENT_BASE 0x60
	37	#define KTD2692_REG_FLASH_CURRENT_BASE 0x80
	38	#define KTD2692_REG_MODE_BASE 0xA0
	39
	40	/* Set bit coding time for expresswire interface */
	41	#define KTD2692_TIME_RESET_US 700
	42	#define KTD2692_TIME_DATA_START_TIME_US 10
	43	#define KTD2692_TIME_HIGH_END_OF_DATA_US 350
	44	#define KTD2692_TIME_LOW_END_OF_DATA_US 10
	45	#define KTD2692_TIME_SHORT_BITSET_US 4
	46	#define KTD2692_TIME_LONG_BITSET_US 12
	47
	48	/* KTD2692 default length of name */
	49	#define KTD2692_NAME_LENGTH 20
	50
	51	enum ktd2692_bitset {
	52	KTD2692_LOW = 0,
	53	KTD2692_HIGH,
	54	};
	55
	56	/* Movie / Flash Mode Control */
	57	enum ktd2692_led_mode {
	58	KTD2692_MODE_DISABLE = 0, /* default */
	59	KTD2692_MODE_MOVIE,
	60	KTD2692_MODE_FLASH,
	61	};
	62
	63	struct ktd2692_led_config_data {
	64	/* maximum LED current in movie mode */
	65	u32 movie_max_microamp;
	66	/* maximum LED current in flash mode */
	67	u32 flash_max_microamp;
	68	/* maximum flash timeout */
	69	u32 flash_max_timeout;
	70	/* max LED brightness level */
	71	enum led_brightness max_brightness;
	72	};
	73
	74	struct ktd2692_context {
	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;
b7da8c5c IK	81
	82	struct gpio_desc *aux_gpio;
	83	struct gpio_desc *ctrl_gpio;
	84
	85	enum ktd2692_led_mode mode;
	86	enum led_brightness torch_brightness;
	87	};
	88
	89	static struct ktd2692_context *fled_cdev_to_led(
	90	struct led_classdev_flash *fled_cdev)
	91	{
	92	return container_of(fled_cdev, struct ktd2692_context, fled_cdev);
	93	}
	94
	95	static void ktd2692_expresswire_start(struct ktd2692_context *led)
	96	{
	97	gpiod_direction_output(led->ctrl_gpio, KTD2692_HIGH);
	98	udelay(KTD2692_TIME_DATA_START_TIME_US);
	99	}
	100
	101	static void ktd2692_expresswire_reset(struct ktd2692_context *led)
	102	{
	103	gpiod_direction_output(led->ctrl_gpio, KTD2692_LOW);
	104	udelay(KTD2692_TIME_RESET_US);
	105	}
	106
	107	static void ktd2692_expresswire_end(struct ktd2692_context *led)
	108	{
	109	gpiod_direction_output(led->ctrl_gpio, KTD2692_LOW);
	110	udelay(KTD2692_TIME_LOW_END_OF_DATA_US);
	111	gpiod_direction_output(led->ctrl_gpio, KTD2692_HIGH);
	112	udelay(KTD2692_TIME_HIGH_END_OF_DATA_US);
	113	}
	114
	115	static void ktd2692_expresswire_set_bit(struct ktd2692_context *led, bool bit)
	116	{
	117	/*
	118	* The Low Bit(0) and High Bit(1) is based on a time detection
	119	* algorithm between time low and time high
	120	* Time_(L_LB) : Low time of the Low Bit(0)
	121	* Time_(H_LB) : High time of the LOW Bit(0)
	122	* Time_(L_HB) : Low time of the High Bit(1)
	123	* Time_(H_HB) : High time of the High Bit(1)
	124	*
	125	* It can be simplified to:
	126	* Low Bit(0) : 2 * Time_(H_LB) < Time_(L_LB)
	127	* High Bit(1) : 2 * Time_(L_HB) < Time_(H_HB)
	128	* HIGH ___ ____ _.. _________ ___
	129	* \|_________\| \|_.. \|____\| \|__\|
	130	* LOW <L_LB> <H_LB> <L_HB> <H_HB>
	131	* [ Low Bit (0) ] [ High Bit(1) ]
	132	*/
	133	if (bit) {
	134	gpiod_direction_output(led->ctrl_gpio, KTD2692_LOW);
	135	udelay(KTD2692_TIME_SHORT_BITSET_US);
	136	gpiod_direction_output(led->ctrl_gpio, KTD2692_HIGH);
	137	udelay(KTD2692_TIME_LONG_BITSET_US);
	138	} else {
	139	gpiod_direction_output(led->ctrl_gpio, KTD2692_LOW);
	140	udelay(KTD2692_TIME_LONG_BITSET_US);
	141	gpiod_direction_output(led->ctrl_gpio, KTD2692_HIGH);
	142	udelay(KTD2692_TIME_SHORT_BITSET_US);
	143	}
	144	}
145
146	static void ktd2692_expresswire_write(struct ktd2692_context *led, u8 value)
147	{
148	int i;
149
150	ktd2692_expresswire_start(led);
151	for (i = 7; i >= 0; i--)
152	ktd2692_expresswire_set_bit(led, value & BIT(i));
153	ktd2692_expresswire_end(led);
154	}
155
9d79a05e JA	156	static int ktd2692_led_brightness_set(struct led_classdev *led_cdev,
9d79a05e JA	157	enum led_brightness brightness)
b7da8c5c	158	{
9d79a05e JA	159	struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev);
	160	struct ktd2692_context *led = fled_cdev_to_led(fled_cdev);
	161
b7da8c5c IK	162	mutex_lock(&led->lock);
	163
	164	if (brightness == LED_OFF) {
	165	led->mode = KTD2692_MODE_DISABLE;
	166	gpiod_direction_output(led->aux_gpio, KTD2692_LOW);
	167	} else {
	168	ktd2692_expresswire_write(led, brightness \|
	169	KTD2692_REG_MOVIE_CURRENT_BASE);
	170	led->mode = KTD2692_MODE_MOVIE;
	171	}
	172
	173	ktd2692_expresswire_write(led, led->mode \| KTD2692_REG_MODE_BASE);
	174	mutex_unlock(&led->lock);
b7da8c5c IK	175
	176	return 0;
	177	}
	178
	179	static int ktd2692_led_flash_strobe_set(struct led_classdev_flash *fled_cdev,
	180	bool state)
	181	{
	182	struct ktd2692_context *led = fled_cdev_to_led(fled_cdev);
	183	struct led_flash_setting *timeout = &fled_cdev->timeout;
	184	u32 flash_tm_reg;
	185
	186	mutex_lock(&led->lock);
	187
	188	if (state) {
	189	flash_tm_reg = GET_TIMEOUT_OFFSET(timeout->val, timeout->step);
	190	ktd2692_expresswire_write(led, flash_tm_reg
	191	\| KTD2692_REG_FLASH_TIMEOUT_BASE);
	192
	193	led->mode = KTD2692_MODE_FLASH;
	194	gpiod_direction_output(led->aux_gpio, KTD2692_HIGH);
	195	} else {
	196	led->mode = KTD2692_MODE_DISABLE;
	197	gpiod_direction_output(led->aux_gpio, KTD2692_LOW);
	198	}
	199
	200	ktd2692_expresswire_write(led, led->mode \| KTD2692_REG_MODE_BASE);
	201
	202	fled_cdev->led_cdev.brightness = LED_OFF;
	203	led->mode = KTD2692_MODE_DISABLE;
	204
	205	mutex_unlock(&led->lock);
	206
	207	return 0;
	208	}
	209
	210	static int ktd2692_led_flash_timeout_set(struct led_classdev_flash *fled_cdev,
	211	u32 timeout)
	212	{
	213	return 0;
	214	}
	215
	216	static void ktd2692_init_movie_current_max(struct ktd2692_led_config_data *cfg)
	217	{
	218	u32 offset, step;
	219	u32 movie_current_microamp;
	220
	221	offset = KTD2692_MOVIE_MODE_CURRENT_LEVELS;
	222	step = KTD2692_MM_TO_FL_RATIO(cfg->flash_max_microamp)
	223	/ KTD2692_MOVIE_MODE_CURRENT_LEVELS;
	224
	225	do {
	226	movie_current_microamp = step * offset;
	227	offset--;
	228	} while ((movie_current_microamp > cfg->movie_max_microamp) &&
	229	(offset > 0));
	230
	231	cfg->max_brightness = offset;
	232	}
	233
	234	static void ktd2692_init_flash_timeout(struct led_classdev_flash *fled_cdev,
	235	struct ktd2692_led_config_data *cfg)
	236	{
	237	struct led_flash_setting *setting;
	238
239	setting = &fled_cdev->timeout;
240	setting->min = KTD2692_FLASH_MODE_TIMEOUT_DISABLE;
241	setting->max = cfg->flash_max_timeout;
242	setting->step = cfg->flash_max_timeout
243	/ (KTD2692_FLASH_MODE_TIMEOUT_LEVELS - 1);
244	setting->val = cfg->flash_max_timeout;
245	}
246
247	static void ktd2692_setup(struct ktd2692_context *led)
248	{
249	led->mode = KTD2692_MODE_DISABLE;
250	ktd2692_expresswire_reset(led);
251	gpiod_direction_output(led->aux_gpio, KTD2692_LOW);
252
253	ktd2692_expresswire_write(led, (KTD2962_MM_MIN_CURR_THRESHOLD_SCALE - 1)
254	\| KTD2692_REG_MM_MIN_CURR_THRESHOLD_BASE);
255	ktd2692_expresswire_write(led, KTD2692_FLASH_MODE_CURR_PERCENT(45)
256	\| KTD2692_REG_FLASH_CURRENT_BASE);
257	}
258
259	static int ktd2692_parse_dt(struct ktd2692_context led, struct device dev,
260	struct ktd2692_led_config_data *cfg)
261	{
262	struct device_node *np = dev->of_node;
263	struct device_node *child_node;
264	int ret;
265
266	if (!dev->of_node)
267	return -ENXIO;
268
5e324ebf	269	led->ctrl_gpio = devm_gpiod_get(dev, "ctrl", GPIOD_ASIS);
cbe99c53 AB	270	ret = PTR_ERR_OR_ZERO(led->ctrl_gpio);
cbe99c53 AB	271	if (ret) {
b7da8c5c IK	272	dev_err(dev, "cannot get ctrl-gpios %d\n", ret);
	273	return ret;
	274	}
	275
5e324ebf	276	led->aux_gpio = devm_gpiod_get(dev, "aux", GPIOD_ASIS);
cbe99c53 AB	277	ret = PTR_ERR_OR_ZERO(led->aux_gpio);
cbe99c53 AB	278	if (ret) {
b7da8c5c IK	279	dev_err(dev, "cannot get aux-gpios %d\n", ret);
	280	return ret;
	281	}
	282
	283	led->regulator = devm_regulator_get(dev, "vin");
	284	if (IS_ERR(led->regulator))
	285	led->regulator = NULL;
	286
	287	if (led->regulator) {
	288	ret = regulator_enable(led->regulator);
	289	if (ret)
	290	dev_err(dev, "Failed to enable supply: %d\n", ret);
	291	}
	292
	293	child_node = of_get_next_available_child(np, NULL);
	294	if (!child_node) {
	295	dev_err(dev, "No DT child node found for connected LED.\n");
	296	return -EINVAL;
	297	}
	298
	299	led->fled_cdev.led_cdev.name =
	300	of_get_property(child_node, "label", NULL) ? : child_node->name;
	301
	302	ret = of_property_read_u32(child_node, "led-max-microamp",
	303	&cfg->movie_max_microamp);
	304	if (ret) {
	305	dev_err(dev, "failed to parse led-max-microamp\n");
77e7915b	306	goto err_parse_dt;
b7da8c5c IK	307	}
	308
	309	ret = of_property_read_u32(child_node, "flash-max-microamp",
	310	&cfg->flash_max_microamp);
	311	if (ret) {
	312	dev_err(dev, "failed to parse flash-max-microamp\n");
77e7915b	313	goto err_parse_dt;
b7da8c5c IK	314	}
	315
	316	ret = of_property_read_u32(child_node, "flash-max-timeout-us",
	317	&cfg->flash_max_timeout);
77e7915b	318	if (ret) {
b7da8c5c	319	dev_err(dev, "failed to parse flash-max-timeout-us\n");
77e7915b IK	320	goto err_parse_dt;
77e7915b IK	321	}
b7da8c5c	322
77e7915b	323	err_parse_dt:
b7da8c5c IK	324	of_node_put(child_node);
	325	return ret;
	326	}
	327
	328	static const struct led_flash_ops flash_ops = {
	329	.strobe_set = ktd2692_led_flash_strobe_set,
	330	.timeout_set = ktd2692_led_flash_timeout_set,
	331	};
	332
	333	static int ktd2692_probe(struct platform_device *pdev)
	334	{
	335	struct ktd2692_context *led;
	336	struct led_classdev *led_cdev;
	337	struct led_classdev_flash *fled_cdev;
	338	struct ktd2692_led_config_data led_cfg;
	339	int ret;
	340
	341	led = devm_kzalloc(&pdev->dev, sizeof(*led), GFP_KERNEL);
	342	if (!led)
	343	return -ENOMEM;
	344
	345	fled_cdev = &led->fled_cdev;
	346	led_cdev = &fled_cdev->led_cdev;
	347
	348	ret = ktd2692_parse_dt(led, &pdev->dev, &led_cfg);
	349	if (ret)
	350	return ret;
	351
	352	ktd2692_init_flash_timeout(fled_cdev, &led_cfg);
	353	ktd2692_init_movie_current_max(&led_cfg);
	354
	355	fled_cdev->ops = &flash_ops;
	356
	357	led_cdev->max_brightness = led_cfg.max_brightness;
9d79a05e	358	led_cdev->brightness_set_blocking = ktd2692_led_brightness_set;
b7da8c5c IK	359	led_cdev->flags \|= LED_CORE_SUSPENDRESUME \| LED_DEV_CAP_FLASH;
	360
	361	mutex_init(&led->lock);
b7da8c5c IK	362
	363	platform_set_drvdata(pdev, led);
	364
	365	ret = led_classdev_flash_register(&pdev->dev, fled_cdev);
	366	if (ret) {
	367	dev_err(&pdev->dev, "can't register LED %s\n", led_cdev->name);
	368	mutex_destroy(&led->lock);
	369	return ret;
	370	}
	371
	372	ktd2692_setup(led);
	373
	374	return 0;
	375	}
	376
	377	static int ktd2692_remove(struct platform_device *pdev)
	378	{
	379	struct ktd2692_context *led = platform_get_drvdata(pdev);
	380	int ret;
	381
	382	led_classdev_flash_unregister(&led->fled_cdev);
b7da8c5c IK	383
	384	if (led->regulator) {
	385	ret = regulator_disable(led->regulator);
	386	if (ret)
	387	dev_err(&pdev->dev,
	388	"Failed to disable supply: %d\n", ret);
	389	}
	390
	391	mutex_destroy(&led->lock);
	392
	393	return 0;
	394	}
	395
	396	static const struct of_device_id ktd2692_match[] = {
	397	{ .compatible = "kinetic,ktd2692", },
	398	{ /* sentinel */ },
	399	};
3682c7bd	400	MODULE_DEVICE_TABLE(of, ktd2692_match);
b7da8c5c IK	401
	402	static struct platform_driver ktd2692_driver = {
	403	.driver = {
	404	.name = "ktd2692",
	405	.of_match_table = ktd2692_match,
	406	},
	407	.probe = ktd2692_probe,
	408	.remove = ktd2692_remove,
	409	};
	410
	411	module_platform_driver(ktd2692_driver);
	412
	413	MODULE_AUTHOR("Ingi Kim <ingi2.kim@samsung.com>");
	414	MODULE_DESCRIPTION("Kinetic KTD2692 LED driver");
	415	MODULE_LICENSE("GPL v2");