[linux.git] / drivers / leds / leds-max8997.c

/*
 * leds-max8997.c - LED class driver for MAX8997 LEDs.
 *
 * Copyright (C) 2011 Samsung Electronics
 * Donggeun Kim <[email protected]>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 */

#include <linux/module.h>
#include <linux/err.h>
#include <linux/slab.h>
#include <linux/workqueue.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 max8997_led_show_mode(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 max8997_led_store_mode(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(mode, 0644, max8997_led_show_mode, max8997_led_store_mode);

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->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, pdata->led_pdata->mode[led->id]);

		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);

	platform_set_drvdata(pdev, led);

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

	ret = device_create_file(led->cdev.dev, &dev_attr_mode);
	if (ret != 0) {
		dev_err(&pdev->dev,
			"failed to create file: %d\n", ret);
		led_classdev_unregister(&led->cdev);
		return ret;
	}

	return 0;
}

static int __devexit max8997_led_remove(struct platform_device *pdev)
{
	struct max8997_led *led = platform_get_drvdata(pdev);

	device_remove_file(led->cdev.dev, &dev_attr_mode);
	led_classdev_unregister(&led->cdev);

	return 0;
}

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

module_platform_driver(max8997_led_driver);

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