[net-next-2.6.git] / drivers / media / IR / ir-sysfs.c

/* ir-register.c - handle IR scancode->keycode tables
 *
 * Copyright (C) 2009-2010 by Mauro Carvalho Chehab <mchehab@redhat.com>
 *
 * 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 version 2 of the License.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 */

#include <linux/slab.h>
#include <linux/input.h>
#include <linux/device.h>
#include "ir-core-priv.h"

#define IRRCV_NUM_DEVICES	256

/* bit array to represent IR sysfs device number */
static unsigned long ir_core_dev_number;

/* class for /sys/class/rc */
static char *ir_devnode(struct device *dev, mode_t *mode)
{
	return kasprintf(GFP_KERNEL, "rc/%s", dev_name(dev));
}

static struct class ir_input_class = {
	.name		= "rc",
	.devnode	= ir_devnode,
};

/**
 * show_protocol() - shows the current IR protocol
 * @d:		the device descriptor
 * @mattr:	the device attribute struct (unused)
 * @buf:	a pointer to the output buffer
 *
 * This routine is a callback routine for input read the IR protocol type.
 * it is trigged by reading /sys/class/rc/rc?/current_protocol.
 * It returns the protocol name, as understood by the driver.
 */
static ssize_t show_protocol(struct device *d,
			     struct device_attribute *mattr, char *buf)
{
	char *s;
	struct ir_input_dev *ir_dev = dev_get_drvdata(d);
	u64 ir_type = ir_dev->rc_tab.ir_type;

	IR_dprintk(1, "Current protocol is %lld\n", (long long)ir_type);

	/* FIXME: doesn't support multiple protocols at the same time */
	if (ir_type == IR_TYPE_UNKNOWN)
		s = "Unknown";
	else if (ir_type == IR_TYPE_RC5)
		s = "rc-5";
	else if (ir_type == IR_TYPE_PD)
		s = "pulse-distance";
	else if (ir_type == IR_TYPE_NEC)
		s = "nec";
	else if (ir_type == IR_TYPE_RC6)
		s = "rc6";
	else
		s = "other";

	return sprintf(buf, "%s\n", s);
}

/**
 * store_protocol() - shows the current IR protocol
 * @d:		the device descriptor
 * @mattr:	the device attribute struct (unused)
 * @buf:	a pointer to the input buffer
 * @len:	length of the input buffer
 *
 * This routine is a callback routine for changing the IR protocol type.
 * it is trigged by reading /sys/class/rc/rc?/current_protocol.
 * It changes the IR the protocol name, if the IR type is recognized
 * by the driver.
 * If an unknown protocol name is used, returns -EINVAL.
 */
static ssize_t store_protocol(struct device *d,
			      struct device_attribute *mattr,
			      const char *data,
			      size_t len)
{
	struct ir_input_dev *ir_dev = dev_get_drvdata(d);
	u64 ir_type = 0;
	int rc = -EINVAL;
	unsigned long flags;
	char *buf;

	while ((buf = strsep((char **) &data, " \n")) != NULL) {
		if (!strcasecmp(buf, "rc-5") || !strcasecmp(buf, "rc5"))
			ir_type |= IR_TYPE_RC5;
		if (!strcasecmp(buf, "pd") || !strcasecmp(buf, "pulse-distance"))
			ir_type |= IR_TYPE_PD;
		if (!strcasecmp(buf, "nec"))
			ir_type |= IR_TYPE_NEC;
	}

	if (!ir_type) {
		IR_dprintk(1, "Unknown protocol\n");
		return -EINVAL;
	}

	if (ir_dev->props && ir_dev->props->change_protocol)
		rc = ir_dev->props->change_protocol(ir_dev->props->priv,
						    ir_type);

	if (rc < 0) {
		IR_dprintk(1, "Error setting protocol to %lld\n",
			   (long long)ir_type);
		return -EINVAL;
	}

	spin_lock_irqsave(&ir_dev->rc_tab.lock, flags);
	ir_dev->rc_tab.ir_type = ir_type;
	spin_unlock_irqrestore(&ir_dev->rc_tab.lock, flags);

	IR_dprintk(1, "Current protocol(s) is(are) %lld\n",
		   (long long)ir_type);

	return len;
}

static ssize_t show_supported_protocols(struct device *d,
			     struct device_attribute *mattr, char *buf)
{
	char *orgbuf = buf;
	struct ir_input_dev *ir_dev = dev_get_drvdata(d);

	/* FIXME: doesn't support multiple protocols at the same time */
	if (ir_dev->props->allowed_protos == IR_TYPE_UNKNOWN)
		buf += sprintf(buf, "unknown ");
	if (ir_dev->props->allowed_protos & IR_TYPE_RC5)
		buf += sprintf(buf, "rc-5 ");
	if (ir_dev->props->allowed_protos & IR_TYPE_PD)
		buf += sprintf(buf, "pulse-distance ");
	if (ir_dev->props->allowed_protos & IR_TYPE_NEC)
		buf += sprintf(buf, "nec ");
	if (buf == orgbuf)
		buf += sprintf(buf, "other ");

	buf += sprintf(buf - 1, "\n");

	return buf - orgbuf;
}

#define ADD_HOTPLUG_VAR(fmt, val...)					\
	do {								\
		int err = add_uevent_var(env, fmt, val);		\
		if (err)						\
			return err;					\
	} while (0)

static int ir_dev_uevent(struct device *device, struct kobj_uevent_env *env)
{
	struct ir_input_dev *ir_dev = dev_get_drvdata(device);

	if (ir_dev->rc_tab.name)
		ADD_HOTPLUG_VAR("NAME=\"%s\"", ir_dev->rc_tab.name);
	if (ir_dev->driver_name)
		ADD_HOTPLUG_VAR("DRV_NAME=\"%s\"", ir_dev->driver_name);

	return 0;
}

/*
 * Static device attribute struct with the sysfs attributes for IR's
 */
static DEVICE_ATTR(protocol, S_IRUGO | S_IWUSR,
		   show_protocol, store_protocol);

static DEVICE_ATTR(supported_protocols, S_IRUGO | S_IWUSR,
		   show_supported_protocols, NULL);

static struct attribute *ir_hw_dev_attrs[] = {
	&dev_attr_protocol.attr,
	&dev_attr_supported_protocols.attr,
	NULL,
};

static struct attribute_group ir_hw_dev_attr_grp = {
	.attrs	= ir_hw_dev_attrs,
};

static const struct attribute_group *ir_hw_dev_attr_groups[] = {
	&ir_hw_dev_attr_grp,
	NULL
};

static struct device_type rc_dev_type = {
	.groups		= ir_hw_dev_attr_groups,
	.uevent		= ir_dev_uevent,
};

static struct device_type ir_raw_dev_type = {
	.uevent		= ir_dev_uevent,
};

/**
 * ir_register_class() - creates the sysfs for /sys/class/rc/rc?
 * @input_dev:	the struct input_dev descriptor of the device
 *
 * This routine is used to register the syfs code for IR class
 */
int ir_register_class(struct input_dev *input_dev)
{
	int rc;
	const char *path;
	struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
	int devno = find_first_zero_bit(&ir_core_dev_number,
					IRRCV_NUM_DEVICES);

	if (unlikely(devno < 0))
		return devno;

	if (ir_dev->props->driver_type == RC_DRIVER_SCANCODE)
		ir_dev->dev.type = &rc_dev_type;
	else
		ir_dev->dev.type = &ir_raw_dev_type;

	ir_dev->dev.class = &ir_input_class;
	ir_dev->dev.parent = input_dev->dev.parent;
	dev_set_name(&ir_dev->dev, "rc%d", devno);
	dev_set_drvdata(&ir_dev->dev, ir_dev);
	rc = device_register(&ir_dev->dev);
	if (rc)
		return rc;


	input_dev->dev.parent = &ir_dev->dev;
	rc = input_register_device(input_dev);
	if (rc < 0) {
		device_del(&ir_dev->dev);
		return rc;
	}

	__module_get(THIS_MODULE);

	path = kobject_get_path(&ir_dev->dev.kobj, GFP_KERNEL);
	printk(KERN_INFO "%s: %s as %s\n",
		dev_name(&ir_dev->dev),
		input_dev->name ? input_dev->name : "Unspecified device",
		path ? path : "N/A");
	kfree(path);

	ir_dev->devno = devno;
	set_bit(devno, &ir_core_dev_number);

	return 0;
};

/**
 * ir_unregister_class() - removes the sysfs for sysfs for
 *			   /sys/class/rc/rc?
 * @input_dev:	the struct input_dev descriptor of the device
 *
 * This routine is used to unregister the syfs code for IR class
 */
void ir_unregister_class(struct input_dev *input_dev)
{
	struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);

	clear_bit(ir_dev->devno, &ir_core_dev_number);
	input_unregister_device(input_dev);
	device_del(&ir_dev->dev);

	module_put(THIS_MODULE);
}

/*
 * Init/exit code for the module. Basically, creates/removes /sys/class/rc
 */

static int __init ir_core_init(void)
{
	int rc = class_register(&ir_input_class);
	if (rc) {
		printk(KERN_ERR "ir_core: unable to register rc class\n");
		return rc;
	}

	/* Initialize/load the decoders/keymap code that will be used */
	ir_raw_init();
	rc_map_init();


	return 0;
}

static void __exit ir_core_exit(void)
{
	class_unregister(&ir_input_class);
}

module_init(ir_core_init);
module_exit(ir_core_exit);
Commit	Line	Data
4714eda8 MCC	1	/* ir-register.c - handle IR scancode->keycode tables
4714eda8 MCC	2	*
995187be	3	* Copyright (C) 2009-2010 by Mauro Carvalho Chehab <mchehab@redhat.com>
4714eda8 MCC	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation version 2 of the License.
	8	*
	9	* This program is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*/
	14
5a0e3ad6	15	#include <linux/slab.h>
4714eda8 MCC	16	#include <linux/input.h>
4714eda8 MCC	17	#include <linux/device.h>
3f113e36	18	#include "ir-core-priv.h"
4714eda8 MCC	19
	20	#define IRRCV_NUM_DEVICES 256
	21
d4b778d3 MCC	22	/* bit array to represent IR sysfs device number */
d4b778d3 MCC	23	static unsigned long ir_core_dev_number;
4714eda8	24
e202c15b	25	/* class for /sys/class/rc */
945cdfa2 MCC	26	static char ir_devnode(struct device dev, mode_t *mode)
945cdfa2 MCC	27	{
e202c15b	28	return kasprintf(GFP_KERNEL, "rc/%s", dev_name(dev));
945cdfa2 MCC	29	}
945cdfa2 MCC	30
995187be	31	static struct class ir_input_class = {
e202c15b	32	.name = "rc",
945cdfa2 MCC	33	.devnode = ir_devnode,
945cdfa2 MCC	34	};
4714eda8	35
d4b778d3 MCC	36	/**
	37	* show_protocol() - shows the current IR protocol
	38	* @d: the device descriptor
	39	* @mattr: the device attribute struct (unused)
	40	* @buf: a pointer to the output buffer
	41	*
	42	* This routine is a callback routine for input read the IR protocol type.
de88f31c	43	* it is trigged by reading /sys/class/rc/rc?/current_protocol.
d4b778d3 MCC	44	* It returns the protocol name, as understood by the driver.
d4b778d3 MCC	45	*/
53f87022 MCC	46	static ssize_t show_protocol(struct device *d,
	47	struct device_attribute mattr, char buf)
	48	{
	49	char *s;
	50	struct ir_input_dev *ir_dev = dev_get_drvdata(d);
971e8298	51	u64 ir_type = ir_dev->rc_tab.ir_type;
53f87022	52
971e8298	53	IR_dprintk(1, "Current protocol is %lld\n", (long long)ir_type);
53f87022 MCC	54
	55	/* FIXME: doesn't support multiple protocols at the same time */
	56	if (ir_type == IR_TYPE_UNKNOWN)
	57	s = "Unknown";
	58	else if (ir_type == IR_TYPE_RC5)
b320f80a	59	s = "rc-5";
53f87022	60	else if (ir_type == IR_TYPE_PD)
b320f80a	61	s = "pulse-distance";
53f87022	62	else if (ir_type == IR_TYPE_NEC)
b320f80a	63	s = "nec";
784a4931 DH	64	else if (ir_type == IR_TYPE_RC6)
784a4931 DH	65	s = "rc6";
53f87022	66	else
b320f80a	67	s = "other";
53f87022 MCC	68
	69	return sprintf(buf, "%s\n", s);
	70	}
	71
d4b778d3 MCC	72	/**
	73	* store_protocol() - shows the current IR protocol
	74	* @d: the device descriptor
	75	* @mattr: the device attribute struct (unused)
	76	* @buf: a pointer to the input buffer
	77	* @len: length of the input buffer
	78	*
	79	* This routine is a callback routine for changing the IR protocol type.
de88f31c	80	* it is trigged by reading /sys/class/rc/rc?/current_protocol.
d4b778d3 MCC	81	* It changes the IR the protocol name, if the IR type is recognized
	82	* by the driver.
	83	* If an unknown protocol name is used, returns -EINVAL.
	84	*/
09b01b90 MCC	85	static ssize_t store_protocol(struct device *d,
	86	struct device_attribute *mattr,
	87	const char *data,
	88	size_t len)
	89	{
	90	struct ir_input_dev *ir_dev = dev_get_drvdata(d);
b320f80a	91	u64 ir_type = 0;
09b01b90	92	int rc = -EINVAL;
eecee32a	93	unsigned long flags;
09b01b90 MCC	94	char *buf;
09b01b90 MCC	95
d22e546e	96	while ((buf = strsep((char **) &data, " \n")) != NULL) {
b320f80a MCC	97	if (!strcasecmp(buf, "rc-5") \|\| !strcasecmp(buf, "rc5"))
	98	ir_type \|= IR_TYPE_RC5;
	99	if (!strcasecmp(buf, "pd") \|\| !strcasecmp(buf, "pulse-distance"))
	100	ir_type \|= IR_TYPE_PD;
	101	if (!strcasecmp(buf, "nec"))
	102	ir_type \|= IR_TYPE_NEC;
	103	}
09b01b90	104
b320f80a MCC	105	if (!ir_type) {
b320f80a MCC	106	IR_dprintk(1, "Unknown protocol\n");
09b01b90 MCC	107	return -EINVAL;
	108	}
	109
0f7ff395	110	if (ir_dev->props && ir_dev->props->change_protocol)
09b01b90 MCC	111	rc = ir_dev->props->change_protocol(ir_dev->props->priv,
	112	ir_type);
	113
	114	if (rc < 0) {
971e8298 MCC	115	IR_dprintk(1, "Error setting protocol to %lld\n",
971e8298 MCC	116	(long long)ir_type);
09b01b90 MCC	117	return -EINVAL;
	118	}
	119
eecee32a	120	spin_lock_irqsave(&ir_dev->rc_tab.lock, flags);
09b01b90	121	ir_dev->rc_tab.ir_type = ir_type;
eecee32a	122	spin_unlock_irqrestore(&ir_dev->rc_tab.lock, flags);
09b01b90	123
b320f80a	124	IR_dprintk(1, "Current protocol(s) is(are) %lld\n",
971e8298	125	(long long)ir_type);
09b01b90 MCC	126
	127	return len;
	128	}
	129
b320f80a MCC	130	static ssize_t show_supported_protocols(struct device *d,
	131	struct device_attribute mattr, char buf)
	132	{
	133	char *orgbuf = buf;
	134	struct ir_input_dev *ir_dev = dev_get_drvdata(d);
	135
	136	/* FIXME: doesn't support multiple protocols at the same time */
	137	if (ir_dev->props->allowed_protos == IR_TYPE_UNKNOWN)
	138	buf += sprintf(buf, "unknown ");
	139	if (ir_dev->props->allowed_protos & IR_TYPE_RC5)
	140	buf += sprintf(buf, "rc-5 ");
	141	if (ir_dev->props->allowed_protos & IR_TYPE_PD)
	142	buf += sprintf(buf, "pulse-distance ");
	143	if (ir_dev->props->allowed_protos & IR_TYPE_NEC)
	144	buf += sprintf(buf, "nec ");
	145	if (buf == orgbuf)
	146	buf += sprintf(buf, "other ");
	147
	148	buf += sprintf(buf - 1, "\n");
	149
	150	return buf - orgbuf;
	151	}
9c89a181 MCC	152
	153	#define ADD_HOTPLUG_VAR(fmt, val...) \
	154	do { \
	155	int err = add_uevent_var(env, fmt, val); \
	156	if (err) \
	157	return err; \
	158	} while (0)
	159
	160	static int ir_dev_uevent(struct device device, struct kobj_uevent_env env)
	161	{
	162	struct ir_input_dev *ir_dev = dev_get_drvdata(device);
	163
	164	if (ir_dev->rc_tab.name)
	165	ADD_HOTPLUG_VAR("NAME=\"%s\"", ir_dev->rc_tab.name);
727e625c MCC	166	if (ir_dev->driver_name)
727e625c MCC	167	ADD_HOTPLUG_VAR("DRV_NAME=\"%s\"", ir_dev->driver_name);
9c89a181 MCC	168
	169	return 0;
	170	}
	171
d4b778d3 MCC	172	/*
	173	* Static device attribute struct with the sysfs attributes for IR's
	174	*/
b320f80a	175	static DEVICE_ATTR(protocol, S_IRUGO \| S_IWUSR,
09b01b90	176	show_protocol, store_protocol);
4714eda8	177
b320f80a MCC	178	static DEVICE_ATTR(supported_protocols, S_IRUGO \| S_IWUSR,
	179	show_supported_protocols, NULL);
	180
626cf697	181	static struct attribute *ir_hw_dev_attrs[] = {
b320f80a MCC	182	&dev_attr_protocol.attr,
b320f80a MCC	183	&dev_attr_supported_protocols.attr,
9714d587	184	NULL,
4714eda8 MCC	185	};
4714eda8 MCC	186
626cf697 MCC	187	static struct attribute_group ir_hw_dev_attr_grp = {
626cf697 MCC	188	.attrs = ir_hw_dev_attrs,
945cdfa2 MCC	189	};
945cdfa2 MCC	190
626cf697 MCC	191	static const struct attribute_group *ir_hw_dev_attr_groups[] = {
626cf697 MCC	192	&ir_hw_dev_attr_grp,
945cdfa2 MCC	193	NULL
	194	};
	195
626cf697 MCC	196	static struct device_type rc_dev_type = {
	197	.groups = ir_hw_dev_attr_groups,
	198	.uevent = ir_dev_uevent,
	199	};
	200
	201	static struct device_type ir_raw_dev_type = {
9c89a181	202	.uevent = ir_dev_uevent,
945cdfa2 MCC	203	};
945cdfa2 MCC	204
d4b778d3	205	/**
de88f31c	206	* ir_register_class() - creates the sysfs for /sys/class/rc/rc?
d4b778d3 MCC	207	* @input_dev: the struct input_dev descriptor of the device
	208	*
	209	* This routine is used to register the syfs code for IR class
	210	*/
4714eda8 MCC	211	int ir_register_class(struct input_dev *input_dev)
	212	{
	213	int rc;
945cdfa2	214	const char *path;
4714eda8 MCC	215	struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
	216	int devno = find_first_zero_bit(&ir_core_dev_number,
	217	IRRCV_NUM_DEVICES);
	218
	219	if (unlikely(devno < 0))
	220	return devno;
	221
626cf697 MCC	222	if (ir_dev->props->driver_type == RC_DRIVER_SCANCODE)
	223	ir_dev->dev.type = &rc_dev_type;
	224	else
	225	ir_dev->dev.type = &ir_raw_dev_type;
	226
945cdfa2 MCC	227	ir_dev->dev.class = &ir_input_class;
945cdfa2 MCC	228	ir_dev->dev.parent = input_dev->dev.parent;
de88f31c	229	dev_set_name(&ir_dev->dev, "rc%d", devno);
9c89a181	230	dev_set_drvdata(&ir_dev->dev, ir_dev);
945cdfa2 MCC	231	rc = device_register(&ir_dev->dev);
	232	if (rc)
	233	return rc;
	234
	235
	236	input_dev->dev.parent = &ir_dev->dev;
	237	rc = input_register_device(input_dev);
	238	if (rc < 0) {
	239	device_del(&ir_dev->dev);
	240	return rc;
4714eda8 MCC	241	}
4714eda8 MCC	242
945cdfa2 MCC	243	__module_get(THIS_MODULE);
945cdfa2 MCC	244
9c89a181 MCC	245	path = kobject_get_path(&ir_dev->dev.kobj, GFP_KERNEL);
9c89a181 MCC	246	printk(KERN_INFO "%s: %s as %s\n",
945cdfa2 MCC	247	dev_name(&ir_dev->dev),
	248	input_dev->name ? input_dev->name : "Unspecified device",
	249	path ? path : "N/A");
	250	kfree(path);
	251
4714eda8 MCC	252	ir_dev->devno = devno;
	253	set_bit(devno, &ir_core_dev_number);
	254
	255	return 0;
	256	};
	257
d4b778d3 MCC	258	/**
d4b778d3 MCC	259	* ir_unregister_class() - removes the sysfs for sysfs for
de88f31c	260	* /sys/class/rc/rc?
d4b778d3 MCC	261	* @input_dev: the struct input_dev descriptor of the device
	262	*
	263	* This routine is used to unregister the syfs code for IR class
	264	*/
4714eda8 MCC	265	void ir_unregister_class(struct input_dev *input_dev)
	266	{
	267	struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
4714eda8 MCC	268
4714eda8 MCC	269	clear_bit(ir_dev->devno, &ir_core_dev_number);
945cdfa2 MCC	270	input_unregister_device(input_dev);
945cdfa2 MCC	271	device_del(&ir_dev->dev);
4714eda8	272
945cdfa2	273	module_put(THIS_MODULE);
4714eda8 MCC	274	}
4714eda8 MCC	275
d4b778d3	276	/*
e202c15b	277	* Init/exit code for the module. Basically, creates/removes /sys/class/rc
d4b778d3 MCC	278	*/
d4b778d3 MCC	279
4714eda8 MCC	280	static int __init ir_core_init(void)
4714eda8 MCC	281	{
945cdfa2 MCC	282	int rc = class_register(&ir_input_class);
945cdfa2 MCC	283	if (rc) {
e202c15b	284	printk(KERN_ERR "ir_core: unable to register rc class\n");
945cdfa2	285	return rc;
4714eda8 MCC	286	}
4714eda8 MCC	287
02858eed	288	/* Initialize/load the decoders/keymap code that will be used */
995187be	289	ir_raw_init();
02858eed MCC	290	rc_map_init();
02858eed MCC	291
995187be	292
4714eda8 MCC	293	return 0;
	294	}
	295
	296	static void __exit ir_core_exit(void)
	297	{
945cdfa2	298	class_unregister(&ir_input_class);
4714eda8 MCC	299	}
	300
	301	module_init(ir_core_init);
	302	module_exit(ir_core_exit);