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

// SPDX-License-Identifier: GPL-2.0-only
/*
 * leds-max8997.c - LED class driver for MAX8997 LEDs.
 *
 * Copyright (C) 2011 Samsung Electronics
 * Donggeun Kim <dg77.kim@samsung.com>
 */

#include <linux/module.h>
#include <linux/err.h>
#include <linux/slab.h>
#include <linux/leds.h>
#include <linux/mfd/max8997.h>
#include <linux/mfd/max8997-private.h>
#include <linux/platform_device.h>

#define MAX8997_LED_FLASH_SHIFT			3
#define MAX8997_LED_FLASH_CUR_MASK		0xf8
#define MAX8997_LED_MOVIE_SHIFT			4
#define MAX8997_LED_MOVIE_CUR_MASK		0xf0

#define MAX8997_LED_FLASH_MAX_BRIGHTNESS	0x1f
#define MAX8997_LED_MOVIE_MAX_BRIGHTNESS	0xf
#define MAX8997_LED_NONE_MAX_BRIGHTNESS		0

#define MAX8997_LED0_FLASH_MASK			0x1
#define MAX8997_LED0_FLASH_PIN_MASK		0x5
#define MAX8997_LED0_MOVIE_MASK			0x8
#define MAX8997_LED0_MOVIE_PIN_MASK		0x28

#define MAX8997_LED1_FLASH_MASK			0x2
#define MAX8997_LED1_FLASH_PIN_MASK		0x6
#define MAX8997_LED1_MOVIE_MASK			0x10
#define MAX8997_LED1_MOVIE_PIN_MASK		0x30

#define MAX8997_LED_BOOST_ENABLE_MASK		(1 << 6)

struct max8997_led {
	struct max8997_dev *iodev;
	struct led_classdev cdev;
	bool enabled;
	int id;
	enum max8997_led_mode led_mode;
	struct mutex mutex;
};

static void max8997_led_set_mode(struct max8997_led *led,
			enum max8997_led_mode mode)
{
	int ret;
	struct i2c_client *client = led->iodev->i2c;
	u8 mask = 0, val;

	switch (mode) {
	case MAX8997_FLASH_MODE:
		mask = MAX8997_LED1_FLASH_MASK | MAX8997_LED0_FLASH_MASK;
		val = led->id ?
		      MAX8997_LED1_FLASH_MASK : MAX8997_LED0_FLASH_MASK;
		led->cdev.max_brightness = MAX8997_LED_FLASH_MAX_BRIGHTNESS;
		break;
	case MAX8997_MOVIE_MODE:
		mask = MAX8997_LED1_MOVIE_MASK | MAX8997_LED0_MOVIE_MASK;
		val = led->id ?
		      MAX8997_LED1_MOVIE_MASK : MAX8997_LED0_MOVIE_MASK;
		led->cdev.max_brightness = MAX8997_LED_MOVIE_MAX_BRIGHTNESS;
		break;
	case MAX8997_FLASH_PIN_CONTROL_MODE:
		mask = MAX8997_LED1_FLASH_PIN_MASK |
		       MAX8997_LED0_FLASH_PIN_MASK;
		val = led->id ?
		      MAX8997_LED1_FLASH_PIN_MASK : MAX8997_LED0_FLASH_PIN_MASK;
		led->cdev.max_brightness = MAX8997_LED_FLASH_MAX_BRIGHTNESS;
		break;
	case MAX8997_MOVIE_PIN_CONTROL_MODE:
		mask = MAX8997_LED1_MOVIE_PIN_MASK |
		       MAX8997_LED0_MOVIE_PIN_MASK;
		val = led->id ?
		      MAX8997_LED1_MOVIE_PIN_MASK : MAX8997_LED0_MOVIE_PIN_MASK;
		led->cdev.max_brightness = MAX8997_LED_MOVIE_MAX_BRIGHTNESS;
		break;
	default:
		led->cdev.max_brightness = MAX8997_LED_NONE_MAX_BRIGHTNESS;
		break;
	}

	if (mask) {
		ret = max8997_update_reg(client, MAX8997_REG_LEN_CNTL, val,
					 mask);
		if (ret)
			dev_err(led->iodev->dev,
				"failed to update register(%d)\n", ret);
	}

	led->led_mode = mode;
}

static void max8997_led_enable(struct max8997_led *led, bool enable)
{
	int ret;
	struct i2c_client *client = led->iodev->i2c;
	u8 val = 0, mask = MAX8997_LED_BOOST_ENABLE_MASK;

	if (led->enabled == enable)
		return;

	val = enable ? MAX8997_LED_BOOST_ENABLE_MASK : 0;

	ret = max8997_update_reg(client, MAX8997_REG_BOOST_CNTL, val, mask);
	if (ret)
		dev_err(led->iodev->dev,
			"failed to update register(%d)\n", ret);

	led->enabled = enable;
}

static void max8997_led_set_current(struct max8997_led *led,
				enum led_brightness value)
{
	int ret;
	struct i2c_client *client = led->iodev->i2c;
	u8 val = 0, mask = 0, reg = 0;

	switch (led->led_mode) {
	case MAX8997_FLASH_MODE:
	case MAX8997_FLASH_PIN_CONTROL_MODE:
		val = value << MAX8997_LED_FLASH_SHIFT;
		mask = MAX8997_LED_FLASH_CUR_MASK;
		reg = led->id ? MAX8997_REG_FLASH2_CUR : MAX8997_REG_FLASH1_CUR;
		break;
	case MAX8997_MOVIE_MODE:
	case MAX8997_MOVIE_PIN_CONTROL_MODE:
		val = value << MAX8997_LED_MOVIE_SHIFT;
		mask = MAX8997_LED_MOVIE_CUR_MASK;
		reg = MAX8997_REG_MOVIE_CUR;
		break;
	default:
		break;
	}

	if (mask) {
		ret = max8997_update_reg(client, reg, val, mask);
		if (ret)
			dev_err(led->iodev->dev,
				"failed to update register(%d)\n", ret);
	}
}

static void max8997_led_brightness_set(struct led_classdev *led_cdev,
				enum led_brightness value)
{
	struct max8997_led *led =
			container_of(led_cdev, struct max8997_led, cdev);

	if (value) {
		max8997_led_set_current(led, value);
		max8997_led_enable(led, true);
	} else {
		max8997_led_set_current(led, value);
		max8997_led_enable(led, false);
	}
}

static ssize_t mode_show(struct device *dev,
			 struct device_attribute *attr, char *buf)
{
	struct led_classdev *led_cdev = dev_get_drvdata(dev);
	struct max8997_led *led =
			container_of(led_cdev, struct max8997_led, cdev);
	ssize_t ret = 0;

	mutex_lock(&led->mutex);

	switch (led->led_mode) {
	case MAX8997_FLASH_MODE:
		ret += sprintf(buf, "FLASH\n");
		break;
	case MAX8997_MOVIE_MODE:
		ret += sprintf(buf, "MOVIE\n");
		break;
	case MAX8997_FLASH_PIN_CONTROL_MODE:
		ret += sprintf(buf, "FLASH_PIN_CONTROL\n");
		break;
	case MAX8997_MOVIE_PIN_CONTROL_MODE:
		ret += sprintf(buf, "MOVIE_PIN_CONTROL\n");
		break;
	default:
		ret += sprintf(buf, "NONE\n");
		break;
	}

	mutex_unlock(&led->mutex);

	return ret;
}

static ssize_t mode_store(struct device *dev,
			  struct device_attribute *attr,
			  const char *buf, size_t size)
{
	struct led_classdev *led_cdev = dev_get_drvdata(dev);
	struct max8997_led *led =
			container_of(led_cdev, struct max8997_led, cdev);
	enum max8997_led_mode mode;

	mutex_lock(&led->mutex);

	if (!strncmp(buf, "FLASH_PIN_CONTROL", 17))
		mode = MAX8997_FLASH_PIN_CONTROL_MODE;
	else if (!strncmp(buf, "MOVIE_PIN_CONTROL", 17))
		mode = MAX8997_MOVIE_PIN_CONTROL_MODE;
	else if (!strncmp(buf, "FLASH", 5))
		mode = MAX8997_FLASH_MODE;
	else if (!strncmp(buf, "MOVIE", 5))
		mode = MAX8997_MOVIE_MODE;
	else
		mode = MAX8997_NONE;

	max8997_led_set_mode(led, mode);

	mutex_unlock(&led->mutex);

	return size;
}

static DEVICE_ATTR_RW(mode);

static struct attribute *max8997_attrs[] = {
	&dev_attr_mode.attr,
	NULL
};
ATTRIBUTE_GROUPS(max8997);

static int max8997_led_probe(struct platform_device *pdev)
{
	struct max8997_dev *iodev = dev_get_drvdata(pdev->dev.parent);
	struct max8997_platform_data *pdata = dev_get_platdata(iodev->dev);
	struct max8997_led *led;
	char name[20];
	int ret = 0;

	if (pdata == NULL) {
		dev_err(&pdev->dev, "no platform data\n");
		return -ENODEV;
	}

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

	led->id = pdev->id;
	snprintf(name, sizeof(name), "max8997-led%d", pdev->id);

	led->cdev.name = name;
	led->cdev.brightness_set = max8997_led_brightness_set;
	led->cdev.flags |= LED_CORE_SUSPENDRESUME;
	led->cdev.brightness = 0;
	led->cdev.groups = max8997_groups;
	led->iodev = iodev;

	/* initialize mode and brightness according to platform_data */
	if (pdata->led_pdata) {
		u8 mode = 0, brightness = 0;

		mode = pdata->led_pdata->mode[led->id];
		brightness = pdata->led_pdata->brightness[led->id];

		max8997_led_set_mode(led, mode);

		if (brightness > led->cdev.max_brightness)
			brightness = led->cdev.max_brightness;
		max8997_led_set_current(led, brightness);
		led->cdev.brightness = brightness;
	} else {
		max8997_led_set_mode(led, MAX8997_NONE);
		max8997_led_set_current(led, 0);
	}

	mutex_init(&led->mutex);

	ret = devm_led_classdev_register(&pdev->dev, &led->cdev);
	if (ret < 0)
		return ret;

	return 0;
}

static struct platform_driver max8997_led_driver = {
	.driver = {
		.name  = "max8997-led",
	},
	.probe  = max8997_led_probe,
};

module_platform_driver(max8997_led_driver);

MODULE_AUTHOR("Donggeun Kim <dg77.kim@samsung.com>");
MODULE_DESCRIPTION("MAX8997 LED driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:max8997-led");
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
8584cb82 DK	2	/*
	3	* leds-max8997.c - LED class driver for MAX8997 LEDs.
	4	*
	5	* Copyright (C) 2011 Samsung Electronics
	6	* Donggeun Kim <dg77.kim@samsung.com>
8584cb82 DK	7	*/
	8
	9	#include <linux/module.h>
	10	#include <linux/err.h>
	11	#include <linux/slab.h>
8584cb82 DK	12	#include <linux/leds.h>
	13	#include <linux/mfd/max8997.h>
	14	#include <linux/mfd/max8997-private.h>
	15	#include <linux/platform_device.h>
	16
	17	#define MAX8997_LED_FLASH_SHIFT 3
	18	#define MAX8997_LED_FLASH_CUR_MASK 0xf8
	19	#define MAX8997_LED_MOVIE_SHIFT 4
	20	#define MAX8997_LED_MOVIE_CUR_MASK 0xf0
	21
	22	#define MAX8997_LED_FLASH_MAX_BRIGHTNESS 0x1f
	23	#define MAX8997_LED_MOVIE_MAX_BRIGHTNESS 0xf
	24	#define MAX8997_LED_NONE_MAX_BRIGHTNESS 0
	25
	26	#define MAX8997_LED0_FLASH_MASK 0x1
	27	#define MAX8997_LED0_FLASH_PIN_MASK 0x5
	28	#define MAX8997_LED0_MOVIE_MASK 0x8
	29	#define MAX8997_LED0_MOVIE_PIN_MASK 0x28
	30
	31	#define MAX8997_LED1_FLASH_MASK 0x2
	32	#define MAX8997_LED1_FLASH_PIN_MASK 0x6
	33	#define MAX8997_LED1_MOVIE_MASK 0x10
	34	#define MAX8997_LED1_MOVIE_PIN_MASK 0x30
	35
	36	#define MAX8997_LED_BOOST_ENABLE_MASK (1 << 6)
	37
	38	struct max8997_led {
	39	struct max8997_dev *iodev;
	40	struct led_classdev cdev;
	41	bool enabled;
	42	int id;
	43	enum max8997_led_mode led_mode;
	44	struct mutex mutex;
	45	};
	46
8584cb82 DK	47	static void max8997_led_set_mode(struct max8997_led *led,
	48	enum max8997_led_mode mode)
	49	{
	50	int ret;
	51	struct i2c_client *client = led->iodev->i2c;
eb18618b	52	u8 mask = 0, val;
8584cb82 DK	53
	54	switch (mode) {
	55	case MAX8997_FLASH_MODE:
eb18618b AL	56	mask = MAX8997_LED1_FLASH_MASK \| MAX8997_LED0_FLASH_MASK;
eb18618b AL	57	val = led->id ?
8584cb82 DK	58	MAX8997_LED1_FLASH_MASK : MAX8997_LED0_FLASH_MASK;
	59	led->cdev.max_brightness = MAX8997_LED_FLASH_MAX_BRIGHTNESS;
	60	break;
	61	case MAX8997_MOVIE_MODE:
eb18618b AL	62	mask = MAX8997_LED1_MOVIE_MASK \| MAX8997_LED0_MOVIE_MASK;
eb18618b AL	63	val = led->id ?
8584cb82 DK	64	MAX8997_LED1_MOVIE_MASK : MAX8997_LED0_MOVIE_MASK;
	65	led->cdev.max_brightness = MAX8997_LED_MOVIE_MAX_BRIGHTNESS;
	66	break;
	67	case MAX8997_FLASH_PIN_CONTROL_MODE:
eb18618b AL	68	mask = MAX8997_LED1_FLASH_PIN_MASK \|
	69	MAX8997_LED0_FLASH_PIN_MASK;
	70	val = led->id ?
8584cb82 DK	71	MAX8997_LED1_FLASH_PIN_MASK : MAX8997_LED0_FLASH_PIN_MASK;
	72	led->cdev.max_brightness = MAX8997_LED_FLASH_MAX_BRIGHTNESS;
	73	break;
	74	case MAX8997_MOVIE_PIN_CONTROL_MODE:
eb18618b AL	75	mask = MAX8997_LED1_MOVIE_PIN_MASK \|
	76	MAX8997_LED0_MOVIE_PIN_MASK;
	77	val = led->id ?
8584cb82 DK	78	MAX8997_LED1_MOVIE_PIN_MASK : MAX8997_LED0_MOVIE_PIN_MASK;
	79	led->cdev.max_brightness = MAX8997_LED_MOVIE_MAX_BRIGHTNESS;
	80	break;
	81	default:
	82	led->cdev.max_brightness = MAX8997_LED_NONE_MAX_BRIGHTNESS;
	83	break;
	84	}
	85
	86	if (mask) {
eb18618b AL	87	ret = max8997_update_reg(client, MAX8997_REG_LEN_CNTL, val,
eb18618b AL	88	mask);
8584cb82 DK	89	if (ret)
	90	dev_err(led->iodev->dev,
	91	"failed to update register(%d)\n", ret);
	92	}
	93
	94	led->led_mode = mode;
	95	}
	96
	97	static void max8997_led_enable(struct max8997_led *led, bool enable)
	98	{
	99	int ret;
	100	struct i2c_client *client = led->iodev->i2c;
	101	u8 val = 0, mask = MAX8997_LED_BOOST_ENABLE_MASK;
	102
	103	if (led->enabled == enable)
	104	return;
	105
	106	val = enable ? MAX8997_LED_BOOST_ENABLE_MASK : 0;
	107
	108	ret = max8997_update_reg(client, MAX8997_REG_BOOST_CNTL, val, mask);
	109	if (ret)
	110	dev_err(led->iodev->dev,
	111	"failed to update register(%d)\n", ret);
	112
	113	led->enabled = enable;
	114	}
	115
	116	static void max8997_led_set_current(struct max8997_led *led,
	117	enum led_brightness value)
	118	{
	119	int ret;
	120	struct i2c_client *client = led->iodev->i2c;
	121	u8 val = 0, mask = 0, reg = 0;
	122
	123	switch (led->led_mode) {
	124	case MAX8997_FLASH_MODE:
	125	case MAX8997_FLASH_PIN_CONTROL_MODE:
	126	val = value << MAX8997_LED_FLASH_SHIFT;
	127	mask = MAX8997_LED_FLASH_CUR_MASK;
	128	reg = led->id ? MAX8997_REG_FLASH2_CUR : MAX8997_REG_FLASH1_CUR;
	129	break;
	130	case MAX8997_MOVIE_MODE:
	131	case MAX8997_MOVIE_PIN_CONTROL_MODE:
	132	val = value << MAX8997_LED_MOVIE_SHIFT;
	133	mask = MAX8997_LED_MOVIE_CUR_MASK;
	134	reg = MAX8997_REG_MOVIE_CUR;
	135	break;
	136	default:
	137	break;
	138	}
	139
	140	if (mask) {
	141	ret = max8997_update_reg(client, reg, val, mask);
	142	if (ret)
	143	dev_err(led->iodev->dev,
	144	"failed to update register(%d)\n", ret);
	145	}
	146	}
	147
	148	static void max8997_led_brightness_set(struct led_classdev *led_cdev,
	149	enum led_brightness value)
	150	{
	151	struct max8997_led *led =
	152	container_of(led_cdev, struct max8997_led, cdev);
153
154	if (value) {
155	max8997_led_set_current(led, value);
156	max8997_led_enable(led, true);
157	} else {
158	max8997_led_set_current(led, value);
159	max8997_led_enable(led, false);
160	}
161	}
162
5ccfa39d DR	163	static ssize_t mode_show(struct device *dev,
5ccfa39d DR	164	struct device_attribute attr, char buf)
8584cb82 DK	165	{
	166	struct led_classdev *led_cdev = dev_get_drvdata(dev);
	167	struct max8997_led *led =
	168	container_of(led_cdev, struct max8997_led, cdev);
	169	ssize_t ret = 0;
	170
	171	mutex_lock(&led->mutex);
	172
	173	switch (led->led_mode) {
	174	case MAX8997_FLASH_MODE:
	175	ret += sprintf(buf, "FLASH\n");
	176	break;
	177	case MAX8997_MOVIE_MODE:
	178	ret += sprintf(buf, "MOVIE\n");
	179	break;
	180	case MAX8997_FLASH_PIN_CONTROL_MODE:
	181	ret += sprintf(buf, "FLASH_PIN_CONTROL\n");
	182	break;
	183	case MAX8997_MOVIE_PIN_CONTROL_MODE:
	184	ret += sprintf(buf, "MOVIE_PIN_CONTROL\n");
	185	break;
	186	default:
	187	ret += sprintf(buf, "NONE\n");
	188	break;
	189	}
	190
	191	mutex_unlock(&led->mutex);
	192
	193	return ret;
	194	}
	195
5ccfa39d DR	196	static ssize_t mode_store(struct device *dev,
	197	struct device_attribute *attr,
	198	const char *buf, size_t size)
8584cb82 DK	199	{
	200	struct led_classdev *led_cdev = dev_get_drvdata(dev);
	201	struct max8997_led *led =
	202	container_of(led_cdev, struct max8997_led, cdev);
	203	enum max8997_led_mode mode;
	204
	205	mutex_lock(&led->mutex);
	206
	207	if (!strncmp(buf, "FLASH_PIN_CONTROL", 17))
	208	mode = MAX8997_FLASH_PIN_CONTROL_MODE;
	209	else if (!strncmp(buf, "MOVIE_PIN_CONTROL", 17))
	210	mode = MAX8997_MOVIE_PIN_CONTROL_MODE;
	211	else if (!strncmp(buf, "FLASH", 5))
	212	mode = MAX8997_FLASH_MODE;
	213	else if (!strncmp(buf, "MOVIE", 5))
	214	mode = MAX8997_MOVIE_MODE;
	215	else
	216	mode = MAX8997_NONE;
	217
	218	max8997_led_set_mode(led, mode);
	219
	220	mutex_unlock(&led->mutex);
	221
	222	return size;
	223	}
	224
5ccfa39d	225	static DEVICE_ATTR_RW(mode);
8584cb82	226
35c16499 JH	227	static struct attribute *max8997_attrs[] = {
	228	&dev_attr_mode.attr,
	229	NULL
	230	};
	231	ATTRIBUTE_GROUPS(max8997);
	232
98ea1ea2	233	static int max8997_led_probe(struct platform_device *pdev)
8584cb82 DK	234	{
	235	struct max8997_dev *iodev = dev_get_drvdata(pdev->dev.parent);
	236	struct max8997_platform_data *pdata = dev_get_platdata(iodev->dev);
	237	struct max8997_led *led;
	238	char name[20];
	239	int ret = 0;
	240
	241	if (pdata == NULL) {
	242	dev_err(&pdev->dev, "no platform data\n");
	243	return -ENODEV;
	244	}
	245
7f13bbf7 SK	246	led = devm_kzalloc(&pdev->dev, sizeof(*led), GFP_KERNEL);
	247	if (led == NULL)
	248	return -ENOMEM;
8584cb82 DK	249
	250	led->id = pdev->id;
	251	snprintf(name, sizeof(name), "max8997-led%d", pdev->id);
	252
	253	led->cdev.name = name;
	254	led->cdev.brightness_set = max8997_led_brightness_set;
	255	led->cdev.flags \|= LED_CORE_SUSPENDRESUME;
	256	led->cdev.brightness = 0;
35c16499	257	led->cdev.groups = max8997_groups;
8584cb82 DK	258	led->iodev = iodev;
	259
	260	/* initialize mode and brightness according to platform_data */
	261	if (pdata->led_pdata) {
	262	u8 mode = 0, brightness = 0;
	263
	264	mode = pdata->led_pdata->mode[led->id];
	265	brightness = pdata->led_pdata->brightness[led->id];
	266
7a5de56d	267	max8997_led_set_mode(led, mode);
8584cb82 DK	268
	269	if (brightness > led->cdev.max_brightness)
	270	brightness = led->cdev.max_brightness;
	271	max8997_led_set_current(led, brightness);
	272	led->cdev.brightness = brightness;
	273	} else {
	274	max8997_led_set_mode(led, MAX8997_NONE);
	275	max8997_led_set_current(led, 0);
	276	}
	277
	278	mutex_init(&led->mutex);
	279
1c430f90	280	ret = devm_led_classdev_register(&pdev->dev, &led->cdev);
8584cb82	281	if (ret < 0)
7f13bbf7	282	return ret;
8584cb82	283
8584cb82	284	return 0;
8584cb82 DK	285	}
8584cb82 DK	286
8584cb82 DK	287	static struct platform_driver max8997_led_driver = {
	288	.driver = {
	289	.name = "max8997-led",
8584cb82 DK	290	},
8584cb82 DK	291	.probe = max8997_led_probe,
8584cb82 DK	292	};
8584cb82 DK	293
7fafefb8	294	module_platform_driver(max8997_led_driver);
8584cb82 DK	295
	296	MODULE_AUTHOR("Donggeun Kim <dg77.kim@samsung.com>");
	297	MODULE_DESCRIPTION("MAX8997 LED driver");
	298	MODULE_LICENSE("GPL");
	299	MODULE_ALIAS("platform:max8997-led");