[linux-2.6-block.git] / drivers / video / backlight / hp680_bl.c

/*
 *  Backlight Driver for HP Jornada 680
 *
 *  Copyright (c) 2005 Andriy Skulysh
 *
 *  Based on Sharp's Corgi Backlight Driver
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/spinlock.h>
#include <linux/fb.h>
#include <linux/backlight.h>

#include <asm/cpu/dac.h>
#include <asm/hp6xx/hp6xx.h>
#include <asm/hd64461/hd64461.h>

#define HP680_MAX_INTENSITY 255
#define HP680_DEFAULT_INTENSITY 10

static int hp680bl_powermode = FB_BLANK_UNBLANK;
static int current_intensity = 0;
static spinlock_t bl_lock = SPIN_LOCK_UNLOCKED;

static void hp680bl_send_intensity(int intensity)
{
	unsigned long flags;

	if (hp680bl_powermode != FB_BLANK_UNBLANK)
		intensity = 0;

	spin_lock_irqsave(&bl_lock, flags);
	sh_dac_output(255-(u8)intensity, DAC_LCD_BRIGHTNESS);
	spin_unlock_irqrestore(&bl_lock, flags);
}

static void hp680bl_blank(int blank)
{
	u16 v;

	switch(blank) {

	case FB_BLANK_NORMAL:
	case FB_BLANK_VSYNC_SUSPEND:
	case FB_BLANK_HSYNC_SUSPEND:
	case FB_BLANK_POWERDOWN:
		if (hp680bl_powermode == FB_BLANK_UNBLANK) {
			hp680bl_send_intensity(0);
			hp680bl_powermode = blank;
			sh_dac_disable(DAC_LCD_BRIGHTNESS);
			v = inw(HD64461_GPBDR);
			v |= HD64461_GPBDR_LCDOFF;
			outw(v, HD64461_GPBDR);
		}
		break;
	case FB_BLANK_UNBLANK:
		if (hp680bl_powermode != FB_BLANK_UNBLANK) {
			sh_dac_enable(DAC_LCD_BRIGHTNESS);
			v = inw(HD64461_GPBDR);
			v &= ~HD64461_GPBDR_LCDOFF;
			outw(v, HD64461_GPBDR);
			hp680bl_powermode = blank;
			hp680bl_send_intensity(current_intensity);
		}
		break;
	}
}

#ifdef CONFIG_PM
static int hp680bl_suspend(struct device *dev, pm_message_t state, u32 level)
{
	if (level == SUSPEND_POWER_DOWN)
		hp680bl_blank(FB_BLANK_POWERDOWN);
	return 0;
}

static int hp680bl_resume(struct device *dev, u32 level)
{
	if (level == RESUME_POWER_ON)
		hp680bl_blank(FB_BLANK_UNBLANK);
	return 0;
}
#else
#define hp680bl_suspend	NULL
#define hp680bl_resume	NULL
#endif


static int hp680bl_set_power(struct backlight_device *bd, int state)
{
	hp680bl_blank(state);
	return 0;
}

static int hp680bl_get_power(struct backlight_device *bd)
{
	return hp680bl_powermode;
}

static int hp680bl_set_intensity(struct backlight_device *bd, int intensity)
{
	if (intensity > HP680_MAX_INTENSITY)
		intensity = HP680_MAX_INTENSITY;
	hp680bl_send_intensity(intensity);
	current_intensity = intensity;
	return 0;
}

static int hp680bl_get_intensity(struct backlight_device *bd)
{
	return current_intensity;
}

static struct backlight_properties hp680bl_data = {
	.owner		= THIS_MODULE,
	.get_power      = hp680bl_get_power,
	.set_power      = hp680bl_set_power,
	.max_brightness = HP680_MAX_INTENSITY,
	.get_brightness = hp680bl_get_intensity,
	.set_brightness = hp680bl_set_intensity,
};

static struct backlight_device *hp680_backlight_device;

static int __init hp680bl_probe(struct device *dev)
{
	hp680_backlight_device = backlight_device_register ("hp680-bl",
		NULL, &hp680bl_data);
	if (IS_ERR (hp680_backlight_device))
		return PTR_ERR (hp680_backlight_device);

	hp680bl_set_intensity(NULL, HP680_DEFAULT_INTENSITY);

	return 0;
}

static int hp680bl_remove(struct device *dev)
{
	backlight_device_unregister(hp680_backlight_device);

	return 0;
}

static struct device_driver hp680bl_driver = {
	.name		= "hp680-bl",
	.bus		= &platform_bus_type,
	.probe		= hp680bl_probe,
	.remove		= hp680bl_remove,
	.suspend	= hp680bl_suspend,
	.resume		= hp680bl_resume,
};

static struct platform_device hp680bl_device = {
	.name	= "hp680-bl",
	.id	= -1,
};

static int __init hp680bl_init(void)
{
	int ret;

	ret=driver_register(&hp680bl_driver);
	if (!ret) {
		ret = platform_device_register(&hp680bl_device);
		if (ret)
			driver_unregister(&hp680bl_driver);
	}
	return ret;
}

static void __exit hp680bl_exit(void)
{
	platform_device_unregister(&hp680bl_device);
 	driver_unregister(&hp680bl_driver);
}

module_init(hp680bl_init);
module_exit(hp680bl_exit);

MODULE_AUTHOR("Andriy Skulysh <askulysh@image.kiev.ua>");
MODULE_DESCRIPTION("HP Jornada 680 Backlight Driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
06c6f900 AS	1	/*
	2	* Backlight Driver for HP Jornada 680
	3	*
	4	* Copyright (c) 2005 Andriy Skulysh
	5	*
	6	* Based on Sharp's Corgi Backlight Driver
	7	*
	8	* This file is subject to the terms and conditions of the GNU General Public
	9	* License. See the file "COPYING" in the main directory of this archive
	10	* for more details.
	11	*/
	12
	13	#include <linux/module.h>
	14	#include <linux/kernel.h>
	15	#include <linux/init.h>
	16	#include <linux/device.h>
	17	#include <linux/spinlock.h>
	18	#include <linux/fb.h>
	19	#include <linux/backlight.h>
	20
	21	#include <asm/cpu/dac.h>
	22	#include <asm/hp6xx/hp6xx.h>
	23	#include <asm/hd64461/hd64461.h>
	24
	25	#define HP680_MAX_INTENSITY 255
	26	#define HP680_DEFAULT_INTENSITY 10
	27
	28	static int hp680bl_powermode = FB_BLANK_UNBLANK;
	29	static int current_intensity = 0;
	30	static spinlock_t bl_lock = SPIN_LOCK_UNLOCKED;
	31
	32	static void hp680bl_send_intensity(int intensity)
	33	{
	34	unsigned long flags;
	35
	36	if (hp680bl_powermode != FB_BLANK_UNBLANK)
	37	intensity = 0;
	38
	39	spin_lock_irqsave(&bl_lock, flags);
	40	sh_dac_output(255-(u8)intensity, DAC_LCD_BRIGHTNESS);
	41	spin_unlock_irqrestore(&bl_lock, flags);
	42	}
	43
	44	static void hp680bl_blank(int blank)
	45	{
	46	u16 v;
	47
	48	switch(blank) {
	49
	50	case FB_BLANK_NORMAL:
	51	case FB_BLANK_VSYNC_SUSPEND:
	52	case FB_BLANK_HSYNC_SUSPEND:
	53	case FB_BLANK_POWERDOWN:
	54	if (hp680bl_powermode == FB_BLANK_UNBLANK) {
	55	hp680bl_send_intensity(0);
	56	hp680bl_powermode = blank;
	57	sh_dac_disable(DAC_LCD_BRIGHTNESS);
	58	v = inw(HD64461_GPBDR);
	59	v \|= HD64461_GPBDR_LCDOFF;
	60	outw(v, HD64461_GPBDR);
	61	}
	62	break;
	63	case FB_BLANK_UNBLANK:
	64	if (hp680bl_powermode != FB_BLANK_UNBLANK) {
65	sh_dac_enable(DAC_LCD_BRIGHTNESS);
66	v = inw(HD64461_GPBDR);
67	v &= ~HD64461_GPBDR_LCDOFF;
68	outw(v, HD64461_GPBDR);
69	hp680bl_powermode = blank;
70	hp680bl_send_intensity(current_intensity);
71	}
72	break;
73	}
74	}
75
76	#ifdef CONFIG_PM
77	static int hp680bl_suspend(struct device *dev, pm_message_t state, u32 level)
78	{
79	if (level == SUSPEND_POWER_DOWN)
80	hp680bl_blank(FB_BLANK_POWERDOWN);
81	return 0;
82	}
83
84	static int hp680bl_resume(struct device *dev, u32 level)
85	{
86	if (level == RESUME_POWER_ON)
87	hp680bl_blank(FB_BLANK_UNBLANK);
88	return 0;
89	}
90	#else
91	#define hp680bl_suspend NULL
92	#define hp680bl_resume NULL
93	#endif
94
95
96	static int hp680bl_set_power(struct backlight_device *bd, int state)
97	{
98	hp680bl_blank(state);
99	return 0;
100	}
101
102	static int hp680bl_get_power(struct backlight_device *bd)
103	{
104	return hp680bl_powermode;
105	}
106
107	static int hp680bl_set_intensity(struct backlight_device *bd, int intensity)
108	{
109	if (intensity > HP680_MAX_INTENSITY)
110	intensity = HP680_MAX_INTENSITY;
111	hp680bl_send_intensity(intensity);
112	current_intensity = intensity;
113	return 0;
114	}
115
116	static int hp680bl_get_intensity(struct backlight_device *bd)
117	{
118	return current_intensity;
119	}
120
121	static struct backlight_properties hp680bl_data = {
122	.owner = THIS_MODULE,
123	.get_power = hp680bl_get_power,
124	.set_power = hp680bl_set_power,
125	.max_brightness = HP680_MAX_INTENSITY,
126	.get_brightness = hp680bl_get_intensity,
127	.set_brightness = hp680bl_set_intensity,
128	};
129
130	static struct backlight_device *hp680_backlight_device;
131
132	static int __init hp680bl_probe(struct device *dev)
133	{
134	hp680_backlight_device = backlight_device_register ("hp680-bl",
135	NULL, &hp680bl_data);
136	if (IS_ERR (hp680_backlight_device))
137	return PTR_ERR (hp680_backlight_device);
138
139	hp680bl_set_intensity(NULL, HP680_DEFAULT_INTENSITY);
140
141	return 0;
142	}
143
144	static int hp680bl_remove(struct device *dev)
145	{
146	backlight_device_unregister(hp680_backlight_device);
147
148	return 0;
149	}
150
151	static struct device_driver hp680bl_driver = {
152	.name = "hp680-bl",
153	.bus = &platform_bus_type,
154	.probe = hp680bl_probe,
155	.remove = hp680bl_remove,
156	.suspend = hp680bl_suspend,
157	.resume = hp680bl_resume,
158	};
159
160	static struct platform_device hp680bl_device = {
161	.name = "hp680-bl",
162	.id = -1,
163	};
164
165	static int __init hp680bl_init(void)
166	{
167	int ret;
168
169	ret=driver_register(&hp680bl_driver);
170	if (!ret) {
171	ret = platform_device_register(&hp680bl_device);
172	if (ret)
173	driver_unregister(&hp680bl_driver);
174	}
175	return ret;
176	}
177
178	static void __exit hp680bl_exit(void)
179	{
180	platform_device_unregister(&hp680bl_device);
181	driver_unregister(&hp680bl_driver);
182	}
183
184	module_init(hp680bl_init);
185	module_exit(hp680bl_exit);
186
187	MODULE_AUTHOR("Andriy Skulysh <askulysh@image.kiev.ua>");
188	MODULE_DESCRIPTION("HP Jornada 680 Backlight Driver");
189	MODULE_LICENSE("GPL");