[linux-2.6-block.git] / drivers / leds / leds-88pm860x.c

/*
 * LED driver for Marvell 88PM860x
 *
 * Copyright (C) 2009 Marvell International Ltd.
 *	Haojian Zhuang <haojian.zhuang@marvell.com>
 *
 * 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/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/i2c.h>
#include <linux/leds.h>
#include <linux/slab.h>
#include <linux/workqueue.h>
#include <linux/mfd/88pm860x.h>
#include <linux/module.h>

#define LED_PWM_MASK		(0x1F)
#define LED_CURRENT_MASK	(0x07 << 5)

#define LED_BLINK_MASK		(0x7F)

#define LED_ON_CONTINUOUS	(0x0F << 3)

#define LED1_BLINK_EN		(1 << 1)
#define LED2_BLINK_EN		(1 << 2)

struct pm860x_led {
	struct led_classdev cdev;
	struct i2c_client *i2c;
	struct work_struct work;
	struct pm860x_chip *chip;
	struct mutex lock;
	char name[MFD_NAME_SIZE];

	int port;
	int iset;
	unsigned char brightness;
	unsigned char current_brightness;

	int reg_control;
	int reg_blink;
	int blink_mask;
};

static int led_power_set(struct pm860x_chip *chip, int port, int on)
{
	int ret = -EINVAL;

	switch (port) {
	case 0:
	case 1:
	case 2:
		ret = on ? pm8606_osc_enable(chip, RGB1_ENABLE) :
			pm8606_osc_disable(chip, RGB1_ENABLE);
		break;
	case 3:
	case 4:
	case 5:
		ret = on ? pm8606_osc_enable(chip, RGB2_ENABLE) :
			pm8606_osc_disable(chip, RGB2_ENABLE);
		break;
	}
	return ret;
}

static void pm860x_led_work(struct work_struct *work)
{

	struct pm860x_led *led;
	struct pm860x_chip *chip;
	unsigned char buf[3];
	int ret;

	led = container_of(work, struct pm860x_led, work);
	chip = led->chip;
	mutex_lock(&led->lock);
	if ((led->current_brightness == 0) && led->brightness) {
		led_power_set(chip, led->port, 1);
		if (led->iset) {
			pm860x_set_bits(led->i2c, led->reg_control,
					LED_CURRENT_MASK, led->iset);
		}
		pm860x_set_bits(led->i2c, led->reg_blink,
				LED_BLINK_MASK, LED_ON_CONTINUOUS);
		pm860x_set_bits(led->i2c, PM8606_WLED3B, led->blink_mask,
				led->blink_mask);
	}
	pm860x_set_bits(led->i2c, led->reg_control, LED_PWM_MASK,
			led->brightness);

	if (led->brightness == 0) {
		pm860x_bulk_read(led->i2c, led->reg_control, 3, buf);
		ret = buf[0] & LED_PWM_MASK;
		ret |= buf[1] & LED_PWM_MASK;
		ret |= buf[2] & LED_PWM_MASK;
		if (ret == 0) {
			/* unset current since no led is lighting */
			pm860x_set_bits(led->i2c, led->reg_control,
					LED_CURRENT_MASK, 0);
			pm860x_set_bits(led->i2c, PM8606_WLED3B,
					led->blink_mask, 0);
			led_power_set(chip, led->port, 0);
		}
	}
	led->current_brightness = led->brightness;
	dev_dbg(chip->dev, "Update LED. (reg:%d, brightness:%d)\n",
		led->reg_control, led->brightness);
	mutex_unlock(&led->lock);
}

static void pm860x_led_set(struct led_classdev *cdev,
			   enum led_brightness value)
{
	struct pm860x_led *data = container_of(cdev, struct pm860x_led, cdev);

	data->brightness = value >> 3;
	schedule_work(&data->work);
}

static int pm860x_led_probe(struct platform_device *pdev)
{
	struct pm860x_chip *chip = dev_get_drvdata(pdev->dev.parent);
	struct pm860x_led_pdata *pdata = pdev->dev.platform_data;
	struct pm860x_led *data;
	struct resource *res;
	int ret = 0;

	data = devm_kzalloc(&pdev->dev, sizeof(struct pm860x_led), GFP_KERNEL);
	if (data == NULL)
		return -ENOMEM;
	res = platform_get_resource_byname(pdev, IORESOURCE_REG, "control");
	if (!res) {
		dev_err(&pdev->dev, "No REG resource for control\n");
		ret = -ENXIO;
		goto out;
	}
	data->reg_control = res->start;
	res = platform_get_resource_byname(pdev, IORESOURCE_REG, "blink");
	if (!res) {
		dev_err(&pdev->dev, "No REG resource for blink\n");
		ret = -ENXIO;
		goto out;
	}
	data->reg_blink = res->start;
	memset(data->name, 0, MFD_NAME_SIZE);
	switch (pdev->id) {
	case 0:
		data->blink_mask = LED1_BLINK_EN;
		sprintf(data->name, "led0-red");
		break;
	case 1:
		data->blink_mask = LED1_BLINK_EN;
		sprintf(data->name, "led0-green");
		break;
	case 2:
		data->blink_mask = LED1_BLINK_EN;
		sprintf(data->name, "led0-blue");
		break;
	case 3:
		data->blink_mask = LED2_BLINK_EN;
		sprintf(data->name, "led1-red");
		break;
	case 4:
		data->blink_mask = LED2_BLINK_EN;
		sprintf(data->name, "led1-green");
		break;
	case 5:
		data->blink_mask = LED2_BLINK_EN;
		sprintf(data->name, "led1-blue");
		break;
	}
	dev_set_drvdata(&pdev->dev, data);
	data->chip = chip;
	data->i2c = (chip->id == CHIP_PM8606) ? chip->client : chip->companion;
	data->port = pdev->id;
	if (pdata && pdata->iset)
		data->iset = pdata->iset;

	data->current_brightness = 0;
	data->cdev.name = data->name;
	data->cdev.brightness_set = pm860x_led_set;
	mutex_init(&data->lock);
	INIT_WORK(&data->work, pm860x_led_work);

	ret = led_classdev_register(chip->dev, &data->cdev);
	if (ret < 0) {
		dev_err(&pdev->dev, "Failed to register LED: %d\n", ret);
		return ret;
	}
	pm860x_led_set(&data->cdev, 0);
	return 0;
out:
	devm_kfree(&pdev->dev, data);
	return ret;
}

static int pm860x_led_remove(struct platform_device *pdev)
{
	struct pm860x_led *data = platform_get_drvdata(pdev);

	led_classdev_unregister(&data->cdev);

	return 0;
}

static struct platform_driver pm860x_led_driver = {
	.driver	= {
		.name	= "88pm860x-led",
		.owner	= THIS_MODULE,
	},
	.probe	= pm860x_led_probe,
	.remove	= pm860x_led_remove,
};

module_platform_driver(pm860x_led_driver);

MODULE_DESCRIPTION("LED driver for Marvell PM860x");
MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:88pm860x-led");
Commit	Line	Data
	1	/*
	2	* LED driver for Marvell 88PM860x
	3	*
	4	* Copyright (C) 2009 Marvell International Ltd.
	5	* Haojian Zhuang <haojian.zhuang@marvell.com>
	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/kernel.h>
	14	#include <linux/init.h>
	15	#include <linux/platform_device.h>
	16	#include <linux/i2c.h>
	17	#include <linux/leds.h>
	18	#include <linux/slab.h>
	19	#include <linux/workqueue.h>
	20	#include <linux/mfd/88pm860x.h>
	21	#include <linux/module.h>
	22
	23	#define LED_PWM_MASK (0x1F)
	24	#define LED_CURRENT_MASK (0x07 << 5)
	25
	26	#define LED_BLINK_MASK (0x7F)
	27
	28	#define LED_ON_CONTINUOUS (0x0F << 3)
	29
	30	#define LED1_BLINK_EN (1 << 1)
	31	#define LED2_BLINK_EN (1 << 2)
	32
	33	struct pm860x_led {
	34	struct led_classdev cdev;
	35	struct i2c_client *i2c;
	36	struct work_struct work;
	37	struct pm860x_chip *chip;
	38	struct mutex lock;
	39	char name[MFD_NAME_SIZE];
	40
	41	int port;
	42	int iset;
	43	unsigned char brightness;
	44	unsigned char current_brightness;
	45
	46	int reg_control;
	47	int reg_blink;
	48	int blink_mask;
	49	};
	50
	51	static int led_power_set(struct pm860x_chip *chip, int port, int on)
	52	{
	53	int ret = -EINVAL;
	54
	55	switch (port) {
	56	case 0:
	57	case 1:
	58	case 2:
	59	ret = on ? pm8606_osc_enable(chip, RGB1_ENABLE) :
	60	pm8606_osc_disable(chip, RGB1_ENABLE);
	61	break;
	62	case 3:
	63	case 4:
	64	case 5:
	65	ret = on ? pm8606_osc_enable(chip, RGB2_ENABLE) :
	66	pm8606_osc_disable(chip, RGB2_ENABLE);
	67	break;
	68	}
	69	return ret;
	70	}
	71
	72	static void pm860x_led_work(struct work_struct *work)
	73	{
	74
	75	struct pm860x_led *led;
	76	struct pm860x_chip *chip;
	77	unsigned char buf[3];
	78	int ret;
	79
	80	led = container_of(work, struct pm860x_led, work);
	81	chip = led->chip;
	82	mutex_lock(&led->lock);
	83	if ((led->current_brightness == 0) && led->brightness) {
	84	led_power_set(chip, led->port, 1);
	85	if (led->iset) {
	86	pm860x_set_bits(led->i2c, led->reg_control,
	87	LED_CURRENT_MASK, led->iset);
	88	}
	89	pm860x_set_bits(led->i2c, led->reg_blink,
	90	LED_BLINK_MASK, LED_ON_CONTINUOUS);
	91	pm860x_set_bits(led->i2c, PM8606_WLED3B, led->blink_mask,
	92	led->blink_mask);
	93	}
	94	pm860x_set_bits(led->i2c, led->reg_control, LED_PWM_MASK,
	95	led->brightness);
	96
	97	if (led->brightness == 0) {
	98	pm860x_bulk_read(led->i2c, led->reg_control, 3, buf);
	99	ret = buf[0] & LED_PWM_MASK;
	100	ret \|= buf[1] & LED_PWM_MASK;
	101	ret \|= buf[2] & LED_PWM_MASK;
	102	if (ret == 0) {
	103	/* unset current since no led is lighting */
	104	pm860x_set_bits(led->i2c, led->reg_control,
	105	LED_CURRENT_MASK, 0);
	106	pm860x_set_bits(led->i2c, PM8606_WLED3B,
	107	led->blink_mask, 0);
	108	led_power_set(chip, led->port, 0);
	109	}
	110	}
	111	led->current_brightness = led->brightness;
	112	dev_dbg(chip->dev, "Update LED. (reg:%d, brightness:%d)\n",
	113	led->reg_control, led->brightness);
	114	mutex_unlock(&led->lock);
	115	}
	116
	117	static void pm860x_led_set(struct led_classdev *cdev,
	118	enum led_brightness value)
	119	{
	120	struct pm860x_led *data = container_of(cdev, struct pm860x_led, cdev);
	121
	122	data->brightness = value >> 3;
	123	schedule_work(&data->work);
	124	}
	125
	126	static int pm860x_led_probe(struct platform_device *pdev)
	127	{
	128	struct pm860x_chip *chip = dev_get_drvdata(pdev->dev.parent);
	129	struct pm860x_led_pdata *pdata = pdev->dev.platform_data;
	130	struct pm860x_led *data;
	131	struct resource *res;
	132	int ret = 0;
	133
	134	data = devm_kzalloc(&pdev->dev, sizeof(struct pm860x_led), GFP_KERNEL);
	135	if (data == NULL)
	136	return -ENOMEM;
	137	res = platform_get_resource_byname(pdev, IORESOURCE_REG, "control");
	138	if (!res) {
	139	dev_err(&pdev->dev, "No REG resource for control\n");
	140	ret = -ENXIO;
	141	goto out;
	142	}
	143	data->reg_control = res->start;
	144	res = platform_get_resource_byname(pdev, IORESOURCE_REG, "blink");
	145	if (!res) {
	146	dev_err(&pdev->dev, "No REG resource for blink\n");
	147	ret = -ENXIO;
	148	goto out;
	149	}
	150	data->reg_blink = res->start;
	151	memset(data->name, 0, MFD_NAME_SIZE);
	152	switch (pdev->id) {
	153	case 0:
	154	data->blink_mask = LED1_BLINK_EN;
	155	sprintf(data->name, "led0-red");
	156	break;
	157	case 1:
	158	data->blink_mask = LED1_BLINK_EN;
	159	sprintf(data->name, "led0-green");
	160	break;
	161	case 2:
	162	data->blink_mask = LED1_BLINK_EN;
	163	sprintf(data->name, "led0-blue");
	164	break;
	165	case 3:
	166	data->blink_mask = LED2_BLINK_EN;
	167	sprintf(data->name, "led1-red");
	168	break;
	169	case 4:
	170	data->blink_mask = LED2_BLINK_EN;
	171	sprintf(data->name, "led1-green");
	172	break;
	173	case 5:
	174	data->blink_mask = LED2_BLINK_EN;
	175	sprintf(data->name, "led1-blue");
	176	break;
	177	}
	178	dev_set_drvdata(&pdev->dev, data);
	179	data->chip = chip;
	180	data->i2c = (chip->id == CHIP_PM8606) ? chip->client : chip->companion;
	181	data->port = pdev->id;
	182	if (pdata && pdata->iset)
	183	data->iset = pdata->iset;
	184
	185	data->current_brightness = 0;
	186	data->cdev.name = data->name;
	187	data->cdev.brightness_set = pm860x_led_set;
	188	mutex_init(&data->lock);
	189	INIT_WORK(&data->work, pm860x_led_work);
	190
	191	ret = led_classdev_register(chip->dev, &data->cdev);
	192	if (ret < 0) {
	193	dev_err(&pdev->dev, "Failed to register LED: %d\n", ret);
	194	return ret;
	195	}
	196	pm860x_led_set(&data->cdev, 0);
	197	return 0;
	198	out:
	199	devm_kfree(&pdev->dev, data);
	200	return ret;
	201	}
	202
	203	static int pm860x_led_remove(struct platform_device *pdev)
	204	{
	205	struct pm860x_led *data = platform_get_drvdata(pdev);
	206
	207	led_classdev_unregister(&data->cdev);
	208
	209	return 0;
	210	}
	211
	212	static struct platform_driver pm860x_led_driver = {
	213	.driver = {
	214	.name = "88pm860x-led",
	215	.owner = THIS_MODULE,
	216	},
	217	.probe = pm860x_led_probe,
	218	.remove = pm860x_led_remove,
	219	};
	220
	221	module_platform_driver(pm860x_led_driver);
	222
	223	MODULE_DESCRIPTION("LED driver for Marvell PM860x");
	224	MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
	225	MODULE_LICENSE("GPL");
	226	MODULE_ALIAS("platform:88pm860x-led");