[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/platform_device.h>
#include <linux/spinlock.h>
#include <linux/fb.h>
#include <linux/backlight.h>

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

#define HP680_MAX_INTENSITY 255
#define HP680_DEFAULT_INTENSITY 10

static int hp680bl_suspended;
static int current_intensity = 0;
static DEFINE_SPINLOCK(bl_lock);
static struct backlight_device *hp680_backlight_device;

static void hp680bl_send_intensity(struct backlight_device *bd)
{
	unsigned long flags;
	u16 v;
	int intensity = bd->props->brightness;

	if (bd->props->power != FB_BLANK_UNBLANK)
		intensity = 0;
	if (bd->props->fb_blank != FB_BLANK_UNBLANK)
		intensity = 0;
	if (hp680bl_suspended)
		intensity = 0;

	spin_lock_irqsave(&bl_lock, flags);
	if (intensity && current_intensity == 0) {
		sh_dac_enable(DAC_LCD_BRIGHTNESS);
		v = inw(HD64461_GPBDR);
		v &= ~HD64461_GPBDR_LCDOFF;
		outw(v, HD64461_GPBDR);
		sh_dac_output(255-(u8)intensity, DAC_LCD_BRIGHTNESS);
	} else if (intensity == 0 && current_intensity != 0) {
		sh_dac_output(255-(u8)intensity, DAC_LCD_BRIGHTNESS);
		sh_dac_disable(DAC_LCD_BRIGHTNESS);
		v = inw(HD64461_GPBDR);
		v |= HD64461_GPBDR_LCDOFF;
		outw(v, HD64461_GPBDR);
	} else if (intensity) {
		sh_dac_output(255-(u8)intensity, DAC_LCD_BRIGHTNESS);
	}
	spin_unlock_irqrestore(&bl_lock, flags);

	current_intensity = intensity;
}


#ifdef CONFIG_PM
static int hp680bl_suspend(struct platform_device *dev, pm_message_t state)
{
	hp680bl_suspended = 1;
	hp680bl_send_intensity(hp680_backlight_device);
	return 0;
}

static int hp680bl_resume(struct platform_device *dev)
{
	hp680bl_suspended = 0;
	hp680bl_send_intensity(hp680_backlight_device);
	return 0;
}
#else
#define hp680bl_suspend	NULL
#define hp680bl_resume	NULL
#endif

static int hp680bl_set_intensity(struct backlight_device *bd)
{
	hp680bl_send_intensity(bd);
	return 0;
}

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

static struct backlight_properties hp680bl_data = {
	.owner		= THIS_MODULE,
	.max_brightness = HP680_MAX_INTENSITY,
	.get_brightness = hp680bl_get_intensity,
	.update_status  = hp680bl_set_intensity,
};

static int __init hp680bl_probe(struct platform_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);

	hp680_backlight_device->props->brightness = HP680_DEFAULT_INTENSITY;
	hp680bl_send_intensity(hp680_backlight_device);

	return 0;
}

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

	return 0;
}

static struct platform_driver hp680bl_driver = {
	.probe		= hp680bl_probe,
	.remove		= hp680bl_remove,
	.suspend	= hp680bl_suspend,
	.resume		= hp680bl_resume,
	.driver		= {
		.name	= "hp680-bl",
	},
};

static struct platform_device *hp680bl_device;

static int __init hp680bl_init(void)
{
	int ret;

	ret = platform_driver_register(&hp680bl_driver);
	if (!ret) {
		hp680bl_device = platform_device_alloc("hp680-bl", -1);
		if (!hp680bl_device)
			return -ENOMEM;

		ret = platform_device_add(hp680bl_device);

		if (ret) {
			platform_device_put(hp680bl_device);
			platform_driver_unregister(&hp680bl_driver);
		}
	}
	return ret;
}

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

module_init(hp680bl_init);
module_exit(hp680bl_exit);

MODULE_AUTHOR("Andriy Skulysh <askulysh@gmail.com>");
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>
5f27a27b	16	#include <linux/platform_device.h>
06c6f900 AS	17	#include <linux/spinlock.h>
	18	#include <linux/fb.h>
	19	#include <linux/backlight.h>
	20
	21	#include <asm/cpu/dac.h>
1aea7e00	22	#include <asm/hp6xx.h>
848dd265	23	#include <asm/hd64461.h>
06c6f900 AS	24
	25	#define HP680_MAX_INTENSITY 255
	26	#define HP680_DEFAULT_INTENSITY 10
	27
5f27a27b	28	static int hp680bl_suspended;
06c6f900	29	static int current_intensity = 0;
34af946a	30	static DEFINE_SPINLOCK(bl_lock);
5f27a27b	31	static struct backlight_device *hp680_backlight_device;
06c6f900	32
5f27a27b	33	static void hp680bl_send_intensity(struct backlight_device *bd)
06c6f900 AS	34	{
06c6f900 AS	35	unsigned long flags;
5f27a27b RP	36	u16 v;
5f27a27b RP	37	int intensity = bd->props->brightness;
06c6f900	38
5f27a27b RP	39	if (bd->props->power != FB_BLANK_UNBLANK)
	40	intensity = 0;
	41	if (bd->props->fb_blank != FB_BLANK_UNBLANK)
	42	intensity = 0;
	43	if (hp680bl_suspended)
06c6f900 AS	44	intensity = 0;
	45
	46	spin_lock_irqsave(&bl_lock, flags);
5f27a27b RP	47	if (intensity && current_intensity == 0) {
	48	sh_dac_enable(DAC_LCD_BRIGHTNESS);
	49	v = inw(HD64461_GPBDR);
	50	v &= ~HD64461_GPBDR_LCDOFF;
	51	outw(v, HD64461_GPBDR);
	52	sh_dac_output(255-(u8)intensity, DAC_LCD_BRIGHTNESS);
	53	} else if (intensity == 0 && current_intensity != 0) {
	54	sh_dac_output(255-(u8)intensity, DAC_LCD_BRIGHTNESS);
	55	sh_dac_disable(DAC_LCD_BRIGHTNESS);
	56	v = inw(HD64461_GPBDR);
	57	v \|= HD64461_GPBDR_LCDOFF;
	58	outw(v, HD64461_GPBDR);
	59	} else if (intensity) {
	60	sh_dac_output(255-(u8)intensity, DAC_LCD_BRIGHTNESS);
	61	}
06c6f900	62	spin_unlock_irqrestore(&bl_lock, flags);
06c6f900	63
5f27a27b	64	current_intensity = intensity;
06c6f900 AS	65	}
06c6f900 AS	66
5f27a27b	67
06c6f900	68	#ifdef CONFIG_PM
5f27a27b	69	static int hp680bl_suspend(struct platform_device *dev, pm_message_t state)
06c6f900	70	{
5f27a27b RP	71	hp680bl_suspended = 1;
5f27a27b RP	72	hp680bl_send_intensity(hp680_backlight_device);
06c6f900 AS	73	return 0;
	74	}
	75
5f27a27b	76	static int hp680bl_resume(struct platform_device *dev)
06c6f900	77	{
5f27a27b RP	78	hp680bl_suspended = 0;
5f27a27b RP	79	hp680bl_send_intensity(hp680_backlight_device);
06c6f900 AS	80	return 0;
	81	}
	82	#else
	83	#define hp680bl_suspend NULL
	84	#define hp680bl_resume NULL
	85	#endif
	86
5f27a27b	87	static int hp680bl_set_intensity(struct backlight_device *bd)
06c6f900	88	{
5f27a27b	89	hp680bl_send_intensity(bd);
06c6f900 AS	90	return 0;
	91	}
	92
	93	static int hp680bl_get_intensity(struct backlight_device *bd)
	94	{
	95	return current_intensity;
	96	}
	97
	98	static struct backlight_properties hp680bl_data = {
	99	.owner = THIS_MODULE,
06c6f900 AS	100	.max_brightness = HP680_MAX_INTENSITY,
06c6f900 AS	101	.get_brightness = hp680bl_get_intensity,
5f27a27b	102	.update_status = hp680bl_set_intensity,
06c6f900 AS	103	};
06c6f900 AS	104
5f27a27b	105	static int __init hp680bl_probe(struct platform_device *dev)
06c6f900 AS	106	{
	107	hp680_backlight_device = backlight_device_register ("hp680-bl",
	108	NULL, &hp680bl_data);
	109	if (IS_ERR (hp680_backlight_device))
	110	return PTR_ERR (hp680_backlight_device);
	111
5f27a27b RP	112	hp680_backlight_device->props->brightness = HP680_DEFAULT_INTENSITY;
5f27a27b RP	113	hp680bl_send_intensity(hp680_backlight_device);
06c6f900 AS	114
	115	return 0;
	116	}
	117
5f27a27b	118	static int hp680bl_remove(struct platform_device *dev)
06c6f900 AS	119	{
	120	backlight_device_unregister(hp680_backlight_device);
	121
	122	return 0;
	123	}
	124
5f27a27b	125	static struct platform_driver hp680bl_driver = {
06c6f900 AS	126	.probe = hp680bl_probe,
	127	.remove = hp680bl_remove,
	128	.suspend = hp680bl_suspend,
	129	.resume = hp680bl_resume,
5f27a27b RP	130	.driver = {
	131	.name = "hp680-bl",
	132	},
06c6f900 AS	133	};
06c6f900 AS	134
5f27a27b	135	static struct platform_device *hp680bl_device;
06c6f900 AS	136
	137	static int __init hp680bl_init(void)
	138	{
	139	int ret;
	140
5f27a27b	141	ret = platform_driver_register(&hp680bl_driver);
06c6f900	142	if (!ret) {
5f27a27b RP	143	hp680bl_device = platform_device_alloc("hp680-bl", -1);
	144	if (!hp680bl_device)
	145	return -ENOMEM;
	146
	147	ret = platform_device_add(hp680bl_device);
	148
	149	if (ret) {
	150	platform_device_put(hp680bl_device);
	151	platform_driver_unregister(&hp680bl_driver);
	152	}
06c6f900 AS	153	}
	154	return ret;
	155	}
	156
	157	static void __exit hp680bl_exit(void)
	158	{
5f27a27b RP	159	platform_device_unregister(hp680bl_device);
5f27a27b RP	160	platform_driver_unregister(&hp680bl_driver);
06c6f900 AS	161	}
	162
	163	module_init(hp680bl_init);
	164	module_exit(hp680bl_exit);
	165
848dd265	166	MODULE_AUTHOR("Andriy Skulysh <askulysh@gmail.com>");
06c6f900 AS	167	MODULE_DESCRIPTION("HP Jornada 680 Backlight Driver");
06c6f900 AS	168	MODULE_LICENSE("GPL");