[deliverable/linux.git] / drivers / video / backlight / pcf50633-backlight.c

/*
 *  Copyright (C) 2009-2010, Lars-Peter Clausen <lars@metafoo.de>
 *      PCF50633 backlight device driver
 *
 *  This program is free software; you can redistribute	 it and/or modify it
 *  under  the terms of	 the GNU General  Public License as published by the
 *  Free Software Foundation;  either version 2 of the	License, or (at your
 *  option) any later version.
 *
 *  You should have received a copy of the  GNU General Public License along
 *  with this program; if not, write  to the Free Software Foundation, Inc.,
 *  675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/platform_device.h>

#include <linux/backlight.h>
#include <linux/fb.h>

#include <linux/mfd/pcf50633/core.h>
#include <linux/mfd/pcf50633/backlight.h>

struct pcf50633_bl {
	struct pcf50633 *pcf;
	struct backlight_device *bl;

	unsigned int brightness;
	unsigned int brightness_limit;
};

/*
 * pcf50633_bl_set_brightness_limit
 *
 * Update the brightness limit for the pc50633 backlight. The actual brightness
 * will not go above the limit. This is useful to limit power drain for example
 * on low battery.
 *
 * @dev: Pointer to a pcf50633 device
 * @limit: The brightness limit. Valid values are 0-63
 */
int pcf50633_bl_set_brightness_limit(struct pcf50633 *pcf, unsigned int limit)
{
	struct pcf50633_bl *pcf_bl = platform_get_drvdata(pcf->bl_pdev);

	if (!pcf_bl)
		return -ENODEV;

	pcf_bl->brightness_limit = limit & 0x3f;
	backlight_update_status(pcf_bl->bl);

    return 0;
}

static int pcf50633_bl_update_status(struct backlight_device *bl)
{
	struct pcf50633_bl *pcf_bl = bl_get_data(bl);
	unsigned int new_brightness;


	if (bl->props.state & (BL_CORE_SUSPENDED | BL_CORE_FBBLANK) ||
		bl->props.power != FB_BLANK_UNBLANK)
		new_brightness = 0;
	else if (bl->props.brightness < pcf_bl->brightness_limit)
		new_brightness = bl->props.brightness;
	else
		new_brightness = pcf_bl->brightness_limit;


	if (pcf_bl->brightness == new_brightness)
		return 0;

	if (new_brightness) {
		pcf50633_reg_write(pcf_bl->pcf, PCF50633_REG_LEDOUT,
					new_brightness);
		if (!pcf_bl->brightness)
			pcf50633_reg_write(pcf_bl->pcf, PCF50633_REG_LEDENA, 1);
	} else {
		pcf50633_reg_write(pcf_bl->pcf, PCF50633_REG_LEDENA, 0);
	}

	pcf_bl->brightness = new_brightness;

	return 0;
}

static int pcf50633_bl_get_brightness(struct backlight_device *bl)
{
	struct pcf50633_bl *pcf_bl = bl_get_data(bl);
	return pcf_bl->brightness;
}

static const struct backlight_ops pcf50633_bl_ops = {
	.get_brightness = pcf50633_bl_get_brightness,
	.update_status	= pcf50633_bl_update_status,
	.options	= BL_CORE_SUSPENDRESUME,
};

static int __devinit pcf50633_bl_probe(struct platform_device *pdev)
{
	struct pcf50633_bl *pcf_bl;
	struct device *parent = pdev->dev.parent;
	struct pcf50633_platform_data *pcf50633_data = parent->platform_data;
	struct pcf50633_bl_platform_data *pdata = pcf50633_data->backlight_data;
	struct backlight_properties bl_props;

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

	memset(&bl_props, 0, sizeof(bl_props));
	bl_props.type = BACKLIGHT_RAW;
	bl_props.max_brightness = 0x3f;
	bl_props.power = FB_BLANK_UNBLANK;

	if (pdata) {
		bl_props.brightness = pdata->default_brightness;
		pcf_bl->brightness_limit = pdata->default_brightness_limit;
	} else {
		bl_props.brightness = 0x3f;
		pcf_bl->brightness_limit = 0x3f;
	}

	pcf_bl->pcf = dev_to_pcf50633(pdev->dev.parent);

	pcf_bl->bl = backlight_device_register(pdev->name, &pdev->dev, pcf_bl,
						&pcf50633_bl_ops, &bl_props);

	if (IS_ERR(pcf_bl->bl))
		return PTR_ERR(pcf_bl->bl);

	platform_set_drvdata(pdev, pcf_bl);

	pcf50633_reg_write(pcf_bl->pcf, PCF50633_REG_LEDDIM, pdata->ramp_time);

	/* Should be different from bl_props.brightness, so we do not exit
	 * update_status early the first time it's called */
	pcf_bl->brightness = pcf_bl->bl->props.brightness + 1;

	backlight_update_status(pcf_bl->bl);

	return 0;
}

static int __devexit pcf50633_bl_remove(struct platform_device *pdev)
{
	struct pcf50633_bl *pcf_bl = platform_get_drvdata(pdev);

	backlight_device_unregister(pcf_bl->bl);

	platform_set_drvdata(pdev, NULL);

	return 0;
}

static struct platform_driver pcf50633_bl_driver = {
	.probe =	pcf50633_bl_probe,
	.remove =	__devexit_p(pcf50633_bl_remove),
	.driver = {
		.name = "pcf50633-backlight",
	},
};

module_platform_driver(pcf50633_bl_driver);

MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
MODULE_DESCRIPTION("PCF50633 backlight driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:pcf50633-backlight");
Commit	Line	Data
2ddfd12f LPC	1	/*
	2	* Copyright (C) 2009-2010, Lars-Peter Clausen <lars@metafoo.de>
	3	* PCF50633 backlight device driver
	4	*
	5	* This program is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License as published by the
	7	* Free Software Foundation; either version 2 of the License, or (at your
	8	* option) any later version.
	9	*
	10	* You should have received a copy of the GNU General Public License along
	11	* with this program; if not, write to the Free Software Foundation, Inc.,
	12	* 675 Mass Ave, Cambridge, MA 02139, USA.
	13	*
	14	*/
	15
	16	#include <linux/kernel.h>
	17	#include <linux/module.h>
	18	#include <linux/slab.h>
	19	#include <linux/platform_device.h>
	20
	21	#include <linux/backlight.h>
	22	#include <linux/fb.h>
	23
	24	#include <linux/mfd/pcf50633/core.h>
	25	#include <linux/mfd/pcf50633/backlight.h>
	26
	27	struct pcf50633_bl {
	28	struct pcf50633 *pcf;
	29	struct backlight_device *bl;
	30
	31	unsigned int brightness;
	32	unsigned int brightness_limit;
	33	};
	34
	35	/*
	36	* pcf50633_bl_set_brightness_limit
	37	*
	38	* Update the brightness limit for the pc50633 backlight. The actual brightness
	39	* will not go above the limit. This is useful to limit power drain for example
	40	* on low battery.
	41	*
	42	* @dev: Pointer to a pcf50633 device
	43	* @limit: The brightness limit. Valid values are 0-63
	44	*/
	45	int pcf50633_bl_set_brightness_limit(struct pcf50633 *pcf, unsigned int limit)
	46	{
	47	struct pcf50633_bl *pcf_bl = platform_get_drvdata(pcf->bl_pdev);
	48
	49	if (!pcf_bl)
	50	return -ENODEV;
	51
	52	pcf_bl->brightness_limit = limit & 0x3f;
	53	backlight_update_status(pcf_bl->bl);
	54
	55	return 0;
	56	}
	57
	58	static int pcf50633_bl_update_status(struct backlight_device *bl)
	59	{
	60	struct pcf50633_bl *pcf_bl = bl_get_data(bl);
	61	unsigned int new_brightness;
	62
	63
	64	if (bl->props.state & (BL_CORE_SUSPENDED \| BL_CORE_FBBLANK) \|\|
65	bl->props.power != FB_BLANK_UNBLANK)
66	new_brightness = 0;
67	else if (bl->props.brightness < pcf_bl->brightness_limit)
68	new_brightness = bl->props.brightness;
69	else
70	new_brightness = pcf_bl->brightness_limit;
71
72
73	if (pcf_bl->brightness == new_brightness)
74	return 0;
75
76	if (new_brightness) {
77	pcf50633_reg_write(pcf_bl->pcf, PCF50633_REG_LEDOUT,
78	new_brightness);
79	if (!pcf_bl->brightness)
80	pcf50633_reg_write(pcf_bl->pcf, PCF50633_REG_LEDENA, 1);
81	} else {
82	pcf50633_reg_write(pcf_bl->pcf, PCF50633_REG_LEDENA, 0);
83	}
84
85	pcf_bl->brightness = new_brightness;
86
87	return 0;
88	}
89
90	static int pcf50633_bl_get_brightness(struct backlight_device *bl)
91	{
92	struct pcf50633_bl *pcf_bl = bl_get_data(bl);
93	return pcf_bl->brightness;
94	}
95
96	static const struct backlight_ops pcf50633_bl_ops = {
97	.get_brightness = pcf50633_bl_get_brightness,
98	.update_status = pcf50633_bl_update_status,
99	.options = BL_CORE_SUSPENDRESUME,
100	};
101
102	static int __devinit pcf50633_bl_probe(struct platform_device *pdev)
103	{
2ddfd12f LPC	104	struct pcf50633_bl *pcf_bl;
	105	struct device *parent = pdev->dev.parent;
	106	struct pcf50633_platform_data *pcf50633_data = parent->platform_data;
	107	struct pcf50633_bl_platform_data *pdata = pcf50633_data->backlight_data;
	108	struct backlight_properties bl_props;
	109
ce969228	110	pcf_bl = devm_kzalloc(&pdev->dev, sizeof(*pcf_bl), GFP_KERNEL);
2ddfd12f LPC	111	if (!pcf_bl)
	112	return -ENOMEM;
	113
f5f4fd45	114	memset(&bl_props, 0, sizeof(bl_props));
bb7ca747	115	bl_props.type = BACKLIGHT_RAW;
2ddfd12f LPC	116	bl_props.max_brightness = 0x3f;
	117	bl_props.power = FB_BLANK_UNBLANK;
	118
	119	if (pdata) {
	120	bl_props.brightness = pdata->default_brightness;
	121	pcf_bl->brightness_limit = pdata->default_brightness_limit;
	122	} else {
	123	bl_props.brightness = 0x3f;
	124	pcf_bl->brightness_limit = 0x3f;
	125	}
	126
	127	pcf_bl->pcf = dev_to_pcf50633(pdev->dev.parent);
	128
	129	pcf_bl->bl = backlight_device_register(pdev->name, &pdev->dev, pcf_bl,
	130	&pcf50633_bl_ops, &bl_props);
	131
ce969228 JL	132	if (IS_ERR(pcf_bl->bl))
ce969228 JL	133	return PTR_ERR(pcf_bl->bl);
2ddfd12f LPC	134
	135	platform_set_drvdata(pdev, pcf_bl);
	136
	137	pcf50633_reg_write(pcf_bl->pcf, PCF50633_REG_LEDDIM, pdata->ramp_time);
	138
	139	/* Should be different from bl_props.brightness, so we do not exit
	140	* update_status early the first time it's called */
	141	pcf_bl->brightness = pcf_bl->bl->props.brightness + 1;
	142
	143	backlight_update_status(pcf_bl->bl);
	144
	145	return 0;
2ddfd12f LPC	146	}
	147
	148	static int __devexit pcf50633_bl_remove(struct platform_device *pdev)
	149	{
	150	struct pcf50633_bl *pcf_bl = platform_get_drvdata(pdev);
	151
	152	backlight_device_unregister(pcf_bl->bl);
	153
	154	platform_set_drvdata(pdev, NULL);
	155
2ddfd12f LPC	156	return 0;
	157	}
	158
	159	static struct platform_driver pcf50633_bl_driver = {
	160	.probe = pcf50633_bl_probe,
	161	.remove = __devexit_p(pcf50633_bl_remove),
	162	.driver = {
	163	.name = "pcf50633-backlight",
	164	},
	165	};
	166
81178e02	167	module_platform_driver(pcf50633_bl_driver);
2ddfd12f LPC	168
	169	MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
	170	MODULE_DESCRIPTION("PCF50633 backlight driver");
	171	MODULE_LICENSE("GPL");
	172	MODULE_ALIAS("platform:pcf50633-backlight");