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

/*
 *  Backlight Driver for Frontpath ProGear HX1050+
 *
 *  Copyright (c) 2006 Marcin Juszkiewicz
 *
 *  Based on Progear LCD driver by M Schacht
 *  <mschacht at alumni dot washington dot edu>
 *
 *  Based on Sharp's Corgi Backlight Driver
 *  Based on Backlight Driver for HP Jornada 680
 *
 *  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/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/mutex.h>
#include <linux/fb.h>
#include <linux/backlight.h>
#include <linux/pci.h>

#define PMU_LPCR               0xB0
#define SB_MPS1                0x61
#define HW_LEVEL_MAX           0x77
#define HW_LEVEL_MIN           0x4f

static struct pci_dev *pmu_dev = NULL;
static struct pci_dev *sb_dev = NULL;

static int progearbl_set_intensity(struct backlight_device *bd)
{
	int intensity = bd->props.brightness;

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

	pci_write_config_byte(pmu_dev, PMU_LPCR, intensity + HW_LEVEL_MIN);

	return 0;
}

static int progearbl_get_intensity(struct backlight_device *bd)
{
	u8 intensity;
	pci_read_config_byte(pmu_dev, PMU_LPCR, &intensity);

	return intensity - HW_LEVEL_MIN;
}

static const struct backlight_ops progearbl_ops = {
	.get_brightness = progearbl_get_intensity,
	.update_status = progearbl_set_intensity,
};

static int progearbl_probe(struct platform_device *pdev)
{
	struct backlight_properties props;
	u8 temp;
	struct backlight_device *progear_backlight_device;
	int ret;

	pmu_dev = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M7101, NULL);
	if (!pmu_dev) {
		printk("ALI M7101 PMU not found.\n");
		return -ENODEV;
	}

	sb_dev = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533, NULL);
	if (!sb_dev) {
		printk("ALI 1533 SB not found.\n");
		ret = -ENODEV;
		goto put_pmu;
	}

	/*     Set SB_MPS1 to enable brightness control. */
	pci_read_config_byte(sb_dev, SB_MPS1, &temp);
	pci_write_config_byte(sb_dev, SB_MPS1, temp | 0x20);

	memset(&props, 0, sizeof(struct backlight_properties));
	props.max_brightness = HW_LEVEL_MAX - HW_LEVEL_MIN;
	progear_backlight_device = backlight_device_register("progear-bl",
							     &pdev->dev, NULL,
							     &progearbl_ops,
							     &props);
	if (IS_ERR(progear_backlight_device)) {
		ret = PTR_ERR(progear_backlight_device);
		goto put_sb;
	}

	platform_set_drvdata(pdev, progear_backlight_device);

	progear_backlight_device->props.power = FB_BLANK_UNBLANK;
	progear_backlight_device->props.brightness = HW_LEVEL_MAX - HW_LEVEL_MIN;
	progearbl_set_intensity(progear_backlight_device);

	return 0;
put_sb:
	pci_dev_put(sb_dev);
put_pmu:
	pci_dev_put(pmu_dev);
	return ret;
}

static int progearbl_remove(struct platform_device *pdev)
{
	struct backlight_device *bd = platform_get_drvdata(pdev);
	backlight_device_unregister(bd);

	return 0;
}

static struct platform_driver progearbl_driver = {
	.probe = progearbl_probe,
	.remove = progearbl_remove,
	.driver = {
		   .name = "progear-bl",
		   },
};

static struct platform_device *progearbl_device;

static int __init progearbl_init(void)
{
	int ret = platform_driver_register(&progearbl_driver);

	if (ret)
		return ret;
	progearbl_device = platform_device_register_simple("progear-bl", -1,
								NULL, 0);
	if (IS_ERR(progearbl_device)) {
		platform_driver_unregister(&progearbl_driver);
		return PTR_ERR(progearbl_device);
	}

	return 0;
}

static void __exit progearbl_exit(void)
{
	pci_dev_put(pmu_dev);
	pci_dev_put(sb_dev);

	platform_device_unregister(progearbl_device);
	platform_driver_unregister(&progearbl_driver);
}

module_init(progearbl_init);
module_exit(progearbl_exit);

MODULE_AUTHOR("Marcin Juszkiewicz <linux@hrw.one.pl>");
MODULE_DESCRIPTION("ProGear Backlight Driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
7a208463 MJ	1	/*
	2	* Backlight Driver for Frontpath ProGear HX1050+
	3	*
	4	* Copyright (c) 2006 Marcin Juszkiewicz
	5	*
	6	* Based on Progear LCD driver by M Schacht
	7	* <mschacht at alumni dot washington dot edu>
	8	*
	9	* Based on Sharp's Corgi Backlight Driver
	10	* Based on Backlight Driver for HP Jornada 680
	11	*
	12	* This program is free software; you can redistribute it and/or modify
	13	* it under the terms of the GNU General Public License version 2 as
	14	* published by the Free Software Foundation.
	15	*
	16	*/
	17
	18	#include <linux/module.h>
	19	#include <linux/kernel.h>
	20	#include <linux/init.h>
	21	#include <linux/platform_device.h>
	22	#include <linux/mutex.h>
	23	#include <linux/fb.h>
	24	#include <linux/backlight.h>
	25	#include <linux/pci.h>
7a208463 MJ	26
	27	#define PMU_LPCR 0xB0
	28	#define SB_MPS1 0x61
	29	#define HW_LEVEL_MAX 0x77
	30	#define HW_LEVEL_MIN 0x4f
	31
	32	static struct pci_dev *pmu_dev = NULL;
	33	static struct pci_dev *sb_dev = NULL;
	34
	35	static int progearbl_set_intensity(struct backlight_device *bd)
	36	{
599a52d1	37	int intensity = bd->props.brightness;
7a208463	38
599a52d1	39	if (bd->props.power != FB_BLANK_UNBLANK)
7a208463	40	intensity = 0;
599a52d1	41	if (bd->props.fb_blank != FB_BLANK_UNBLANK)
7a208463 MJ	42	intensity = 0;
	43
	44	pci_write_config_byte(pmu_dev, PMU_LPCR, intensity + HW_LEVEL_MIN);
	45
	46	return 0;
	47	}
	48
	49	static int progearbl_get_intensity(struct backlight_device *bd)
	50	{
	51	u8 intensity;
	52	pci_read_config_byte(pmu_dev, PMU_LPCR, &intensity);
	53
	54	return intensity - HW_LEVEL_MIN;
	55	}
	56
9905a43b	57	static const struct backlight_ops progearbl_ops = {
7a208463 MJ	58	.get_brightness = progearbl_get_intensity,
	59	.update_status = progearbl_set_intensity,
	60	};
	61
	62	static int progearbl_probe(struct platform_device *pdev)
	63	{
a19a6ee6	64	struct backlight_properties props;
7a208463 MJ	65	u8 temp;
7a208463 MJ	66	struct backlight_device *progear_backlight_device;
a4ebb780	67	int ret;
7a208463	68
89952d13	69	pmu_dev = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M7101, NULL);
7a208463 MJ	70	if (!pmu_dev) {
	71	printk("ALI M7101 PMU not found.\n");
	72	return -ENODEV;
	73	}
	74
89952d13	75	sb_dev = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533, NULL);
7a208463 MJ	76	if (!sb_dev) {
7a208463 MJ	77	printk("ALI 1533 SB not found.\n");
a4ebb780 JS	78	ret = -ENODEV;
a4ebb780 JS	79	goto put_pmu;
7a208463 MJ	80	}
	81
	82	/* Set SB_MPS1 to enable brightness control. */
	83	pci_read_config_byte(sb_dev, SB_MPS1, &temp);
	84	pci_write_config_byte(sb_dev, SB_MPS1, temp \| 0x20);
	85
a19a6ee6 MG	86	memset(&props, 0, sizeof(struct backlight_properties));
a19a6ee6 MG	87	props.max_brightness = HW_LEVEL_MAX - HW_LEVEL_MIN;
7a208463 MJ	88	progear_backlight_device = backlight_device_register("progear-bl",
7a208463 MJ	89	&pdev->dev, NULL,
a19a6ee6 MG	90	&progearbl_ops,
a19a6ee6 MG	91	&props);
a4ebb780 JS	92	if (IS_ERR(progear_backlight_device)) {
	93	ret = PTR_ERR(progear_backlight_device);
	94	goto put_sb;
	95	}
7a208463 MJ	96
	97	platform_set_drvdata(pdev, progear_backlight_device);
	98
599a52d1 RP	99	progear_backlight_device->props.power = FB_BLANK_UNBLANK;
599a52d1 RP	100	progear_backlight_device->props.brightness = HW_LEVEL_MAX - HW_LEVEL_MIN;
7a208463 MJ	101	progearbl_set_intensity(progear_backlight_device);
	102
	103	return 0;
a4ebb780 JS	104	put_sb:
	105	pci_dev_put(sb_dev);
	106	put_pmu:
	107	pci_dev_put(pmu_dev);
	108	return ret;
7a208463 MJ	109	}
	110
	111	static int progearbl_remove(struct platform_device *pdev)
	112	{
	113	struct backlight_device *bd = platform_get_drvdata(pdev);
	114	backlight_device_unregister(bd);
	115
	116	return 0;
	117	}
	118
	119	static struct platform_driver progearbl_driver = {
	120	.probe = progearbl_probe,
	121	.remove = progearbl_remove,
	122	.driver = {
	123	.name = "progear-bl",
	124	},
	125	};
	126
	127	static struct platform_device *progearbl_device;
	128
	129	static int __init progearbl_init(void)
	130	{
	131	int ret = platform_driver_register(&progearbl_driver);
	132
6cd6f35a AM	133	if (ret)
	134	return ret;
	135	progearbl_device = platform_device_register_simple("progear-bl", -1,
	136	NULL, 0);
	137	if (IS_ERR(progearbl_device)) {
	138	platform_driver_unregister(&progearbl_driver);
	139	return PTR_ERR(progearbl_device);
7a208463 MJ	140	}
7a208463 MJ	141
6cd6f35a	142	return 0;
7a208463 MJ	143	}
	144
	145	static void __exit progearbl_exit(void)
	146	{
	147	pci_dev_put(pmu_dev);
	148	pci_dev_put(sb_dev);
	149
	150	platform_device_unregister(progearbl_device);
	151	platform_driver_unregister(&progearbl_driver);
	152	}
	153
	154	module_init(progearbl_init);
	155	module_exit(progearbl_exit);
	156
	157	MODULE_AUTHOR("Marcin Juszkiewicz <linux@hrw.one.pl>");
	158	MODULE_DESCRIPTION("ProGear Backlight Driver");
	159	MODULE_LICENSE("GPL");