[mirror_ubuntu-artful-kernel.git] / drivers / video / backlight / backlight.c

/*
 * Backlight Lowlevel Control Abstraction
 *
 * Copyright (C) 2003,2004 Hewlett-Packard Company
 *
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/backlight.h>
#include <linux/notifier.h>
#include <linux/ctype.h>
#include <linux/err.h>
#include <linux/fb.h>
#include <linux/slab.h>

#ifdef CONFIG_PMAC_BACKLIGHT
#include <asm/backlight.h>
#endif

#if defined(CONFIG_FB) || (defined(CONFIG_FB_MODULE) && \
			   defined(CONFIG_BACKLIGHT_CLASS_DEVICE_MODULE))
/* This callback gets called when something important happens inside a
 * framebuffer driver. We're looking if that important event is blanking,
 * and if it is, we're switching backlight power as well ...
 */
static int fb_notifier_callback(struct notifier_block *self,
				unsigned long event, void *data)
{
	struct backlight_device *bd;
	struct fb_event *evdata = data;

	/* If we aren't interested in this event, skip it immediately ... */
	if (event != FB_EVENT_BLANK && event != FB_EVENT_CONBLANK)
		return 0;

	bd = container_of(self, struct backlight_device, fb_notif);
	mutex_lock(&bd->ops_lock);
	if (bd->ops)
		if (!bd->ops->check_fb ||
		    bd->ops->check_fb(bd, evdata->info)) {
			bd->props.fb_blank = *(int *)evdata->data;
			if (bd->props.fb_blank == FB_BLANK_UNBLANK)
				bd->props.state &= ~BL_CORE_FBBLANK;
			else
				bd->props.state |= BL_CORE_FBBLANK;
			backlight_update_status(bd);
		}
	mutex_unlock(&bd->ops_lock);
	return 0;
}

static int backlight_register_fb(struct backlight_device *bd)
{
	memset(&bd->fb_notif, 0, sizeof(bd->fb_notif));
	bd->fb_notif.notifier_call = fb_notifier_callback;

	return fb_register_client(&bd->fb_notif);
}

static void backlight_unregister_fb(struct backlight_device *bd)
{
	fb_unregister_client(&bd->fb_notif);
}
#else
static inline int backlight_register_fb(struct backlight_device *bd)
{
	return 0;
}

static inline void backlight_unregister_fb(struct backlight_device *bd)
{
}
#endif /* CONFIG_FB */

static void backlight_generate_event(struct backlight_device *bd,
				     enum backlight_update_reason reason)
{
	char *envp[2];

	switch (reason) {
	case BACKLIGHT_UPDATE_SYSFS:
		envp[0] = "SOURCE=sysfs";
		break;
	case BACKLIGHT_UPDATE_HOTKEY:
		envp[0] = "SOURCE=hotkey";
		break;
	default:
		envp[0] = "SOURCE=unknown";
		break;
	}
	envp[1] = NULL;
	kobject_uevent_env(&bd->dev.kobj, KOBJ_CHANGE, envp);
	sysfs_notify(&bd->dev.kobj, NULL, "actual_brightness");
}

static ssize_t backlight_show_power(struct device *dev,
		struct device_attribute *attr,char *buf)
{
	struct backlight_device *bd = to_backlight_device(dev);

	return sprintf(buf, "%d\n", bd->props.power);
}

static ssize_t backlight_store_power(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	int rc;
	struct backlight_device *bd = to_backlight_device(dev);
	unsigned long power;

	rc = strict_strtoul(buf, 0, &power);
	if (rc)
		return rc;

	rc = -ENXIO;
	mutex_lock(&bd->ops_lock);
	if (bd->ops) {
		pr_debug("backlight: set power to %lu\n", power);
		if (bd->props.power != power) {
			bd->props.power = power;
			backlight_update_status(bd);
		}
		rc = count;
	}
	mutex_unlock(&bd->ops_lock);

	return rc;
}

static ssize_t backlight_show_brightness(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct backlight_device *bd = to_backlight_device(dev);

	return sprintf(buf, "%d\n", bd->props.brightness);
}

static ssize_t backlight_store_brightness(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	int rc;
	struct backlight_device *bd = to_backlight_device(dev);
	unsigned long brightness;

	rc = strict_strtoul(buf, 0, &brightness);
	if (rc)
		return rc;

	rc = -ENXIO;

	mutex_lock(&bd->ops_lock);
	if (bd->ops) {
		if (brightness > bd->props.max_brightness)
			rc = -EINVAL;
		else {
			pr_debug("backlight: set brightness to %lu\n",
				 brightness);
			bd->props.brightness = brightness;
			backlight_update_status(bd);
			rc = count;
		}
	}
	mutex_unlock(&bd->ops_lock);

	backlight_generate_event(bd, BACKLIGHT_UPDATE_SYSFS);

	return rc;
}

static ssize_t backlight_show_max_brightness(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct backlight_device *bd = to_backlight_device(dev);

	return sprintf(buf, "%d\n", bd->props.max_brightness);
}

static ssize_t backlight_show_actual_brightness(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	int rc = -ENXIO;
	struct backlight_device *bd = to_backlight_device(dev);

	mutex_lock(&bd->ops_lock);
	if (bd->ops && bd->ops->get_brightness)
		rc = sprintf(buf, "%d\n", bd->ops->get_brightness(bd));
	mutex_unlock(&bd->ops_lock);

	return rc;
}

static struct class *backlight_class;

static int backlight_suspend(struct device *dev, pm_message_t state)
{
	struct backlight_device *bd = to_backlight_device(dev);

	if (bd->ops->options & BL_CORE_SUSPENDRESUME) {
		mutex_lock(&bd->ops_lock);
		bd->props.state |= BL_CORE_SUSPENDED;
		backlight_update_status(bd);
		mutex_unlock(&bd->ops_lock);
	}

	return 0;
}

static int backlight_resume(struct device *dev)
{
	struct backlight_device *bd = to_backlight_device(dev);

	if (bd->ops->options & BL_CORE_SUSPENDRESUME) {
		mutex_lock(&bd->ops_lock);
		bd->props.state &= ~BL_CORE_SUSPENDED;
		backlight_update_status(bd);
		mutex_unlock(&bd->ops_lock);
	}

	return 0;
}

static void bl_device_release(struct device *dev)
{
	struct backlight_device *bd = to_backlight_device(dev);
	kfree(bd);
}

static struct device_attribute bl_device_attributes[] = {
	__ATTR(bl_power, 0644, backlight_show_power, backlight_store_power),
	__ATTR(brightness, 0644, backlight_show_brightness,
		     backlight_store_brightness),
	__ATTR(actual_brightness, 0444, backlight_show_actual_brightness,
		     NULL),
	__ATTR(max_brightness, 0444, backlight_show_max_brightness, NULL),
	__ATTR_NULL,
};

/**
 * backlight_force_update - tell the backlight subsystem that hardware state
 *   has changed
 * @bd: the backlight device to update
 *
 * Updates the internal state of the backlight in response to a hardware event,
 * and generate a uevent to notify userspace
 */
void backlight_force_update(struct backlight_device *bd,
			    enum backlight_update_reason reason)
{
	mutex_lock(&bd->ops_lock);
	if (bd->ops && bd->ops->get_brightness)
		bd->props.brightness = bd->ops->get_brightness(bd);
	mutex_unlock(&bd->ops_lock);
	backlight_generate_event(bd, reason);
}
EXPORT_SYMBOL(backlight_force_update);

/**
 * backlight_device_register - create and register a new object of
 *   backlight_device class.
 * @name: the name of the new object(must be the same as the name of the
 *   respective framebuffer device).
 * @parent: a pointer to the parent device
 * @devdata: an optional pointer to be stored for private driver use. The
 *   methods may retrieve it by using bl_get_data(bd).
 * @ops: the backlight operations structure.
 *
 * Creates and registers new backlight device. Returns either an
 * ERR_PTR() or a pointer to the newly allocated device.
 */
struct backlight_device *backlight_device_register(const char *name,
	struct device *parent, void *devdata, const struct backlight_ops *ops,
	const struct backlight_properties *props)
{
	struct backlight_device *new_bd;
	int rc;

	pr_debug("backlight_device_register: name=%s\n", name);

	new_bd = kzalloc(sizeof(struct backlight_device), GFP_KERNEL);
	if (!new_bd)
		return ERR_PTR(-ENOMEM);

	mutex_init(&new_bd->update_lock);
	mutex_init(&new_bd->ops_lock);

	new_bd->dev.class = backlight_class;
	new_bd->dev.parent = parent;
	new_bd->dev.release = bl_device_release;
	dev_set_name(&new_bd->dev, name);
	dev_set_drvdata(&new_bd->dev, devdata);

	/* Set default properties */
	if (props)
		memcpy(&new_bd->props, props,
		       sizeof(struct backlight_properties));

	rc = device_register(&new_bd->dev);
	if (rc) {
		kfree(new_bd);
		return ERR_PTR(rc);
	}

	rc = backlight_register_fb(new_bd);
	if (rc) {
		device_unregister(&new_bd->dev);
		return ERR_PTR(rc);
	}

	new_bd->ops = ops;

#ifdef CONFIG_PMAC_BACKLIGHT
	mutex_lock(&pmac_backlight_mutex);
	if (!pmac_backlight)
		pmac_backlight = new_bd;
	mutex_unlock(&pmac_backlight_mutex);
#endif

	return new_bd;
}
EXPORT_SYMBOL(backlight_device_register);

/**
 * backlight_device_unregister - unregisters a backlight device object.
 * @bd: the backlight device object to be unregistered and freed.
 *
 * Unregisters a previously registered via backlight_device_register object.
 */
void backlight_device_unregister(struct backlight_device *bd)
{
	if (!bd)
		return;

#ifdef CONFIG_PMAC_BACKLIGHT
	mutex_lock(&pmac_backlight_mutex);
	if (pmac_backlight == bd)
		pmac_backlight = NULL;
	mutex_unlock(&pmac_backlight_mutex);
#endif
	mutex_lock(&bd->ops_lock);
	bd->ops = NULL;
	mutex_unlock(&bd->ops_lock);

	backlight_unregister_fb(bd);
	device_unregister(&bd->dev);
}
EXPORT_SYMBOL(backlight_device_unregister);

static void __exit backlight_class_exit(void)
{
	class_destroy(backlight_class);
}

static int __init backlight_class_init(void)
{
	backlight_class = class_create(THIS_MODULE, "backlight");
	if (IS_ERR(backlight_class)) {
		printk(KERN_WARNING "Unable to create backlight class; errno = %ld\n",
				PTR_ERR(backlight_class));
		return PTR_ERR(backlight_class);
	}

	backlight_class->dev_attrs = bl_device_attributes;
	backlight_class->suspend = backlight_suspend;
	backlight_class->resume = backlight_resume;
	return 0;
}

/*
 * if this is compiled into the kernel, we need to ensure that the
 * class is registered before users of the class try to register lcd's
 */
postcore_initcall(backlight_class_init);
module_exit(backlight_class_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Jamey Hicks <jamey.hicks@hp.com>, Andrew Zabolotny <zap@homelink.ru>");
MODULE_DESCRIPTION("Backlight Lowlevel Control Abstraction");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Backlight Lowlevel Control Abstraction
	3	*
	4	* Copyright (C) 2003,2004 Hewlett-Packard Company
	5	*
	6	*/
	7
1da177e4 LT	8	#include <linux/module.h>
	9	#include <linux/init.h>
	10	#include <linux/device.h>
	11	#include <linux/backlight.h>
	12	#include <linux/notifier.h>
	13	#include <linux/ctype.h>
	14	#include <linux/err.h>
	15	#include <linux/fb.h>
5a0e3ad6	16	#include <linux/slab.h>
1da177e4	17
321709c5 RP	18	#ifdef CONFIG_PMAC_BACKLIGHT
	19	#include <asm/backlight.h>
	20	#endif
3d5eeadd JS	21
	22	#if defined(CONFIG_FB) \|\| (defined(CONFIG_FB_MODULE) && \
	23	defined(CONFIG_BACKLIGHT_CLASS_DEVICE_MODULE))
	24	/* This callback gets called when something important happens inside a
	25	* framebuffer driver. We're looking if that important event is blanking,
	26	* and if it is, we're switching backlight power as well ...
	27	*/
	28	static int fb_notifier_callback(struct notifier_block *self,
	29	unsigned long event, void *data)
	30	{
	31	struct backlight_device *bd;
	32	struct fb_event *evdata = data;
	33
	34	/* If we aren't interested in this event, skip it immediately ... */
994efacd	35	if (event != FB_EVENT_BLANK && event != FB_EVENT_CONBLANK)
3d5eeadd JS	36	return 0;
	37
	38	bd = container_of(self, struct backlight_device, fb_notif);
599a52d1 RP	39	mutex_lock(&bd->ops_lock);
	40	if (bd->ops)
	41	if (!bd->ops->check_fb \|\|
57e148b6	42	bd->ops->check_fb(bd, evdata->info)) {
599a52d1	43	bd->props.fb_blank = (int )evdata->data;
c835ee7f RP	44	if (bd->props.fb_blank == FB_BLANK_UNBLANK)
	45	bd->props.state &= ~BL_CORE_FBBLANK;
	46	else
	47	bd->props.state \|= BL_CORE_FBBLANK;
28ee086d	48	backlight_update_status(bd);
3d5eeadd	49	}
599a52d1	50	mutex_unlock(&bd->ops_lock);
3d5eeadd JS	51	return 0;
	52	}
	53
	54	static int backlight_register_fb(struct backlight_device *bd)
	55	{
	56	memset(&bd->fb_notif, 0, sizeof(bd->fb_notif));
	57	bd->fb_notif.notifier_call = fb_notifier_callback;
	58
	59	return fb_register_client(&bd->fb_notif);
	60	}
	61
	62	static void backlight_unregister_fb(struct backlight_device *bd)
	63	{
	64	fb_unregister_client(&bd->fb_notif);
	65	}
	66	#else
	67	static inline int backlight_register_fb(struct backlight_device *bd)
	68	{
	69	return 0;
	70	}
	71
	72	static inline void backlight_unregister_fb(struct backlight_device *bd)
	73	{
	74	}
	75	#endif /* CONFIG_FB */
	76
325253a6 MG	77	static void backlight_generate_event(struct backlight_device *bd,
	78	enum backlight_update_reason reason)
	79	{
	80	char *envp[2];
	81
	82	switch (reason) {
	83	case BACKLIGHT_UPDATE_SYSFS:
	84	envp[0] = "SOURCE=sysfs";
	85	break;
	86	case BACKLIGHT_UPDATE_HOTKEY:
	87	envp[0] = "SOURCE=hotkey";
	88	break;
	89	default:
	90	envp[0] = "SOURCE=unknown";
	91	break;
	92	}
	93	envp[1] = NULL;
	94	kobject_uevent_env(&bd->dev.kobj, KOBJ_CHANGE, envp);
89dfc28c	95	sysfs_notify(&bd->dev.kobj, NULL, "actual_brightness");
325253a6 MG	96	}
325253a6 MG	97
655bfd7a RP	98	static ssize_t backlight_show_power(struct device *dev,
655bfd7a RP	99	struct device_attribute attr,char buf)
1da177e4	100	{
655bfd7a	101	struct backlight_device *bd = to_backlight_device(dev);
1da177e4	102
599a52d1	103	return sprintf(buf, "%d\n", bd->props.power);
1da177e4 LT	104	}
1da177e4 LT	105
655bfd7a RP	106	static ssize_t backlight_store_power(struct device *dev,
655bfd7a RP	107	struct device_attribute attr, const char buf, size_t count)
1da177e4	108	{
9a2c61a9	109	int rc;
655bfd7a	110	struct backlight_device *bd = to_backlight_device(dev);
9a2c61a9	111	unsigned long power;
1da177e4	112
9a2c61a9 PM	113	rc = strict_strtoul(buf, 0, &power);
	114	if (rc)
	115	return rc;
1da177e4	116
9a2c61a9	117	rc = -ENXIO;
599a52d1 RP	118	mutex_lock(&bd->ops_lock);
599a52d1 RP	119	if (bd->ops) {
9a2c61a9	120	pr_debug("backlight: set power to %lu\n", power);
51552453 HD	121	if (bd->props.power != power) {
	122	bd->props.power = power;
	123	backlight_update_status(bd);
	124	}
1da177e4	125	rc = count;
6ca01765	126	}
599a52d1	127	mutex_unlock(&bd->ops_lock);
1da177e4 LT	128
	129	return rc;
	130	}
	131
655bfd7a RP	132	static ssize_t backlight_show_brightness(struct device *dev,
655bfd7a RP	133	struct device_attribute attr, char buf)
1da177e4	134	{
655bfd7a	135	struct backlight_device *bd = to_backlight_device(dev);
1da177e4	136
599a52d1	137	return sprintf(buf, "%d\n", bd->props.brightness);
1da177e4 LT	138	}
1da177e4 LT	139
655bfd7a RP	140	static ssize_t backlight_store_brightness(struct device *dev,
655bfd7a RP	141	struct device_attribute attr, const char buf, size_t count)
1da177e4	142	{
9a2c61a9	143	int rc;
655bfd7a	144	struct backlight_device *bd = to_backlight_device(dev);
9a2c61a9	145	unsigned long brightness;
1da177e4	146
9a2c61a9 PM	147	rc = strict_strtoul(buf, 0, &brightness);
	148	if (rc)
	149	return rc;
	150
	151	rc = -ENXIO;
1da177e4	152
599a52d1 RP	153	mutex_lock(&bd->ops_lock);
	154	if (bd->ops) {
	155	if (brightness > bd->props.max_brightness)
6ca01765 RP	156	rc = -EINVAL;
6ca01765 RP	157	else {
9a2c61a9	158	pr_debug("backlight: set brightness to %lu\n",
6ca01765	159	brightness);
9be1df98 ZR	160	bd->props.brightness = brightness;
9be1df98 ZR	161	backlight_update_status(bd);
6ca01765 RP	162	rc = count;
	163	}
	164	}
599a52d1	165	mutex_unlock(&bd->ops_lock);
1da177e4	166
325253a6 MG	167	backlight_generate_event(bd, BACKLIGHT_UPDATE_SYSFS);
325253a6 MG	168
1da177e4 LT	169	return rc;
	170	}
	171
655bfd7a RP	172	static ssize_t backlight_show_max_brightness(struct device *dev,
655bfd7a RP	173	struct device_attribute attr, char buf)
1da177e4	174	{
655bfd7a	175	struct backlight_device *bd = to_backlight_device(dev);
1da177e4	176
599a52d1	177	return sprintf(buf, "%d\n", bd->props.max_brightness);
6ca01765 RP	178	}
6ca01765 RP	179
655bfd7a RP	180	static ssize_t backlight_show_actual_brightness(struct device *dev,
655bfd7a RP	181	struct device_attribute attr, char buf)
6ca01765 RP	182	{
6ca01765 RP	183	int rc = -ENXIO;
655bfd7a	184	struct backlight_device *bd = to_backlight_device(dev);
6ca01765	185
599a52d1 RP	186	mutex_lock(&bd->ops_lock);
	187	if (bd->ops && bd->ops->get_brightness)
	188	rc = sprintf(buf, "%d\n", bd->ops->get_brightness(bd));
	189	mutex_unlock(&bd->ops_lock);
1da177e4 LT	190
	191	return rc;
	192	}
	193
0ad90efd	194	static struct class *backlight_class;
655bfd7a	195
c835ee7f RP	196	static int backlight_suspend(struct device *dev, pm_message_t state)
	197	{
	198	struct backlight_device *bd = to_backlight_device(dev);
	199
	200	if (bd->ops->options & BL_CORE_SUSPENDRESUME) {
	201	mutex_lock(&bd->ops_lock);
	202	bd->props.state \|= BL_CORE_SUSPENDED;
	203	backlight_update_status(bd);
	204	mutex_unlock(&bd->ops_lock);
	205	}
	206
	207	return 0;
	208	}
	209
	210	static int backlight_resume(struct device *dev)
	211	{
	212	struct backlight_device *bd = to_backlight_device(dev);
	213
	214	if (bd->ops->options & BL_CORE_SUSPENDRESUME) {
	215	mutex_lock(&bd->ops_lock);
	216	bd->props.state &= ~BL_CORE_SUSPENDED;
	217	backlight_update_status(bd);
	218	mutex_unlock(&bd->ops_lock);
	219	}
	220
	221	return 0;
	222	}
	223
655bfd7a	224	static void bl_device_release(struct device *dev)
1da177e4 LT	225	{
	226	struct backlight_device *bd = to_backlight_device(dev);
	227	kfree(bd);
	228	}
	229
655bfd7a RP	230	static struct device_attribute bl_device_attributes[] = {
	231	__ATTR(bl_power, 0644, backlight_show_power, backlight_store_power),
	232	__ATTR(brightness, 0644, backlight_show_brightness,
6ca01765	233	backlight_store_brightness),
655bfd7a	234	__ATTR(actual_brightness, 0444, backlight_show_actual_brightness,
6ca01765	235	NULL),
655bfd7a RP	236	__ATTR(max_brightness, 0444, backlight_show_max_brightness, NULL),
655bfd7a RP	237	__ATTR_NULL,
1da177e4 LT	238	};
1da177e4 LT	239
325253a6 MG	240	/**
	241	* backlight_force_update - tell the backlight subsystem that hardware state
	242	* has changed
	243	* @bd: the backlight device to update
	244	*
	245	* Updates the internal state of the backlight in response to a hardware event,
	246	* and generate a uevent to notify userspace
	247	*/
	248	void backlight_force_update(struct backlight_device *bd,
	249	enum backlight_update_reason reason)
	250	{
	251	mutex_lock(&bd->ops_lock);
	252	if (bd->ops && bd->ops->get_brightness)
	253	bd->props.brightness = bd->ops->get_brightness(bd);
	254	mutex_unlock(&bd->ops_lock);
	255	backlight_generate_event(bd, reason);
	256	}
	257	EXPORT_SYMBOL(backlight_force_update);
	258
1da177e4 LT	259	/**
	260	* backlight_device_register - create and register a new object of
	261	* backlight_device class.
	262	* @name: the name of the new object(must be the same as the name of the
	263	* respective framebuffer device).
f6ec2d96	264	* @parent: a pointer to the parent device
655bfd7a RP	265	* @devdata: an optional pointer to be stored for private driver use. The
655bfd7a RP	266	* methods may retrieve it by using bl_get_data(bd).
599a52d1	267	* @ops: the backlight operations structure.
1da177e4	268	*
655bfd7a	269	* Creates and registers new backlight device. Returns either an
1da177e4 LT	270	* ERR_PTR() or a pointer to the newly allocated device.
1da177e4 LT	271	*/
519ab5f2	272	struct backlight_device backlight_device_register(const char name,
a19a6ee6 MG	273	struct device parent, void devdata, const struct backlight_ops *ops,
a19a6ee6 MG	274	const struct backlight_properties *props)
1da177e4	275	{
1da177e4	276	struct backlight_device *new_bd;
655bfd7a	277	int rc;
1da177e4	278
655bfd7a	279	pr_debug("backlight_device_register: name=%s\n", name);
1da177e4	280
599a52d1	281	new_bd = kzalloc(sizeof(struct backlight_device), GFP_KERNEL);
90968e8e	282	if (!new_bd)
10ad1b73	283	return ERR_PTR(-ENOMEM);
1da177e4	284
28ee086d	285	mutex_init(&new_bd->update_lock);
599a52d1	286	mutex_init(&new_bd->ops_lock);
1da177e4	287
655bfd7a RP	288	new_bd->dev.class = backlight_class;
	289	new_bd->dev.parent = parent;
	290	new_bd->dev.release = bl_device_release;
64dba9a9	291	dev_set_name(&new_bd->dev, name);
655bfd7a RP	292	dev_set_drvdata(&new_bd->dev, devdata);
655bfd7a RP	293
a19a6ee6 MG	294	/* Set default properties */
	295	if (props)
	296	memcpy(&new_bd->props, props,
	297	sizeof(struct backlight_properties));
	298
655bfd7a	299	rc = device_register(&new_bd->dev);
90968e8e	300	if (rc) {
2fd5a154	301	kfree(new_bd);
1da177e4 LT	302	return ERR_PTR(rc);
	303	}
	304
3d5eeadd	305	rc = backlight_register_fb(new_bd);
2fd5a154	306	if (rc) {
655bfd7a	307	device_unregister(&new_bd->dev);
2fd5a154 DT	308	return ERR_PTR(rc);
	309	}
	310
655bfd7a	311	new_bd->ops = ops;
1da177e4	312
321709c5 RP	313	#ifdef CONFIG_PMAC_BACKLIGHT
	314	mutex_lock(&pmac_backlight_mutex);
	315	if (!pmac_backlight)
	316	pmac_backlight = new_bd;
	317	mutex_unlock(&pmac_backlight_mutex);
	318	#endif
	319
1da177e4 LT	320	return new_bd;
	321	}
	322	EXPORT_SYMBOL(backlight_device_register);
	323
	324	/**
	325	* backlight_device_unregister - unregisters a backlight device object.
	326	* @bd: the backlight device object to be unregistered and freed.
	327	*
	328	* Unregisters a previously registered via backlight_device_register object.
	329	*/
	330	void backlight_device_unregister(struct backlight_device *bd)
	331	{
1da177e4 LT	332	if (!bd)
	333	return;
	334
321709c5 RP	335	#ifdef CONFIG_PMAC_BACKLIGHT
	336	mutex_lock(&pmac_backlight_mutex);
	337	if (pmac_backlight == bd)
	338	pmac_backlight = NULL;
	339	mutex_unlock(&pmac_backlight_mutex);
	340	#endif
599a52d1 RP	341	mutex_lock(&bd->ops_lock);
	342	bd->ops = NULL;
	343	mutex_unlock(&bd->ops_lock);
1da177e4	344
3d5eeadd	345	backlight_unregister_fb(bd);
655bfd7a	346	device_unregister(&bd->dev);
1da177e4 LT	347	}
	348	EXPORT_SYMBOL(backlight_device_unregister);
	349
	350	static void __exit backlight_class_exit(void)
	351	{
655bfd7a	352	class_destroy(backlight_class);
1da177e4 LT	353	}
	354
	355	static int __init backlight_class_init(void)
	356	{
655bfd7a RP	357	backlight_class = class_create(THIS_MODULE, "backlight");
	358	if (IS_ERR(backlight_class)) {
	359	printk(KERN_WARNING "Unable to create backlight class; errno = %ld\n",
	360	PTR_ERR(backlight_class));
	361	return PTR_ERR(backlight_class);
	362	}
	363
	364	backlight_class->dev_attrs = bl_device_attributes;
c835ee7f RP	365	backlight_class->suspend = backlight_suspend;
c835ee7f RP	366	backlight_class->resume = backlight_resume;
655bfd7a	367	return 0;
1da177e4 LT	368	}
	369
	370	/*
	371	* if this is compiled into the kernel, we need to ensure that the
	372	* class is registered before users of the class try to register lcd's
	373	*/
	374	postcore_initcall(backlight_class_init);
	375	module_exit(backlight_class_exit);
	376
	377	MODULE_LICENSE("GPL");
	378	MODULE_AUTHOR("Jamey Hicks <jamey.hicks@hp.com>, Andrew Zabolotny <zap@homelink.ru>");
	379	MODULE_DESCRIPTION("Backlight Lowlevel Control Abstraction");