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

/* ir-register.c - handle IR scancode->keycode tables
 *
 * Copyright (C) 2009 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 <media/ir-core.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/irrcv */
static char *ir_devnode(struct device *dev, mode_t *mode)
{
	return kasprintf(GFP_KERNEL, "irrcv/%s", dev_name(dev));
}

struct class ir_input_class = {
	.name		= "irrcv",
	.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/irrcv/irrcv?/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
		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/irrcv/irrcv?/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 = IR_TYPE_UNKNOWN;
	int rc = -EINVAL;
	unsigned long flags;
	char *buf;

	buf = strsep((char **) &data, "\n");

	if (!strcasecmp(buf, "rc-5"))
		ir_type = IR_TYPE_RC5;
	else if (!strcasecmp(buf, "pd"))
		ir_type = IR_TYPE_PD;
	else if (!strcasecmp(buf, "nec"))
		ir_type = IR_TYPE_NEC;

	if (ir_type == IR_TYPE_UNKNOWN) {
		IR_dprintk(1, "Error setting protocol to %lld\n",
			   (long long)ir_type);
		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 is %lld\n",
		   (long long)ir_type);

	return len;
}

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

static struct attribute *ir_dev_attrs[] = {
	&dev_attr_current_protocol.attr,
	NULL,
};

static struct attribute_group ir_dev_attr_grp = {
	.attrs	= ir_dev_attrs,
};

static const struct attribute_group *ir_dev_attr_groups[] = {
	&ir_dev_attr_grp,
	NULL
};

static struct device_type ir_dev_type = {
	.groups		= ir_dev_attr_groups,
};


/**
 * ir_register_class() - creates the sysfs for /sys/class/irrcv/irrcv?
 * @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;

	ir_dev->dev.type = &ir_dev_type;
	ir_dev->dev.class = &ir_input_class;
	ir_dev->dev.parent = input_dev->dev.parent;
	dev_set_name(&ir_dev->dev, "irrcv%d", devno);
	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(&input_dev->dev.kobj, GFP_KERNEL);
	printk(KERN_INFO "%s: %s associated with sysfs %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/irrcv/irrcv?
 * @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/irrcv
 */

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

	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
	2	*
	3	* Copyright (C) 2009 by Mauro Carvalho Chehab <mchehab@redhat.com>
	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>
	17	#include <linux/device.h>
	18	#include <media/ir-core.h>
	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
d4b778d3	25	/* class for /sys/class/irrcv */
945cdfa2 MCC	26	static char ir_devnode(struct device dev, mode_t *mode)
	27	{
	28	return kasprintf(GFP_KERNEL, "irrcv/%s", dev_name(dev));
	29	}
	30
	31	struct class ir_input_class = {
	32	.name = "irrcv",
	33	.devnode = ir_devnode,
	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.
	43	* it is trigged by reading /sys/class/irrcv/irrcv?/current_protocol.
	44	* It returns the protocol name, as understood by the driver.
	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)
	59	s = "RC-5";
	60	else if (ir_type == IR_TYPE_PD)
	61	s = "Pulse/distance";
	62	else if (ir_type == IR_TYPE_NEC)
	63	s = "NEC";
	64	else
	65	s = "Other";
	66
	67	return sprintf(buf, "%s\n", s);
	68	}
	69
d4b778d3 MCC	70	/**
	71	* store_protocol() - shows the current IR protocol
	72	* @d: the device descriptor
	73	* @mattr: the device attribute struct (unused)
	74	* @buf: a pointer to the input buffer
	75	* @len: length of the input buffer
	76	*
	77	* This routine is a callback routine for changing the IR protocol type.
	78	* it is trigged by reading /sys/class/irrcv/irrcv?/current_protocol.
	79	* It changes the IR the protocol name, if the IR type is recognized
	80	* by the driver.
	81	* If an unknown protocol name is used, returns -EINVAL.
	82	*/
09b01b90 MCC	83	static ssize_t store_protocol(struct device *d,
	84	struct device_attribute *mattr,
	85	const char *data,
	86	size_t len)
	87	{
	88	struct ir_input_dev *ir_dev = dev_get_drvdata(d);
971e8298	89	u64 ir_type = IR_TYPE_UNKNOWN;
09b01b90	90	int rc = -EINVAL;
eecee32a	91	unsigned long flags;
09b01b90 MCC	92	char *buf;
	93
	94	buf = strsep((char **) &data, "\n");
	95
	96	if (!strcasecmp(buf, "rc-5"))
	97	ir_type = IR_TYPE_RC5;
	98	else if (!strcasecmp(buf, "pd"))
	99	ir_type = IR_TYPE_PD;
	100	else if (!strcasecmp(buf, "nec"))
	101	ir_type = IR_TYPE_NEC;
	102
	103	if (ir_type == IR_TYPE_UNKNOWN) {
971e8298 MCC	104	IR_dprintk(1, "Error setting protocol to %lld\n",
971e8298 MCC	105	(long long)ir_type);
09b01b90 MCC	106	return -EINVAL;
	107	}
	108
0f7ff395	109	if (ir_dev->props && ir_dev->props->change_protocol)
09b01b90 MCC	110	rc = ir_dev->props->change_protocol(ir_dev->props->priv,
	111	ir_type);
	112
	113	if (rc < 0) {
971e8298 MCC	114	IR_dprintk(1, "Error setting protocol to %lld\n",
971e8298 MCC	115	(long long)ir_type);
09b01b90 MCC	116	return -EINVAL;
	117	}
	118
eecee32a	119	spin_lock_irqsave(&ir_dev->rc_tab.lock, flags);
09b01b90	120	ir_dev->rc_tab.ir_type = ir_type;
eecee32a	121	spin_unlock_irqrestore(&ir_dev->rc_tab.lock, flags);
09b01b90	122
971e8298 MCC	123	IR_dprintk(1, "Current protocol is %lld\n",
971e8298 MCC	124	(long long)ir_type);
09b01b90 MCC	125
	126	return len;
	127	}
	128
d4b778d3 MCC	129	/*
	130	* Static device attribute struct with the sysfs attributes for IR's
	131	*/
53f87022	132	static DEVICE_ATTR(current_protocol, S_IRUGO \| S_IWUSR,
09b01b90	133	show_protocol, store_protocol);
4714eda8 MCC	134
4714eda8 MCC	135	static struct attribute *ir_dev_attrs[] = {
53f87022	136	&dev_attr_current_protocol.attr,
9714d587	137	NULL,
4714eda8 MCC	138	};
4714eda8 MCC	139
945cdfa2 MCC	140	static struct attribute_group ir_dev_attr_grp = {
	141	.attrs = ir_dev_attrs,
	142	};
	143
	144	static const struct attribute_group *ir_dev_attr_groups[] = {
	145	&ir_dev_attr_grp,
	146	NULL
	147	};
	148
	149	static struct device_type ir_dev_type = {
	150	.groups = ir_dev_attr_groups,
	151	};
	152
	153
d4b778d3 MCC	154	/**
	155	* ir_register_class() - creates the sysfs for /sys/class/irrcv/irrcv?
	156	* @input_dev: the struct input_dev descriptor of the device
	157	*
	158	* This routine is used to register the syfs code for IR class
	159	*/
4714eda8 MCC	160	int ir_register_class(struct input_dev *input_dev)
	161	{
	162	int rc;
945cdfa2	163	const char *path;
4714eda8 MCC	164
	165	struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
	166	int devno = find_first_zero_bit(&ir_core_dev_number,
	167	IRRCV_NUM_DEVICES);
	168
	169	if (unlikely(devno < 0))
	170	return devno;
	171
945cdfa2 MCC	172	ir_dev->dev.type = &ir_dev_type;
	173	ir_dev->dev.class = &ir_input_class;
	174	ir_dev->dev.parent = input_dev->dev.parent;
	175	dev_set_name(&ir_dev->dev, "irrcv%d", devno);
	176	rc = device_register(&ir_dev->dev);
	177	if (rc)
	178	return rc;
	179
	180
	181	input_dev->dev.parent = &ir_dev->dev;
	182	rc = input_register_device(input_dev);
	183	if (rc < 0) {
	184	device_del(&ir_dev->dev);
	185	return rc;
4714eda8 MCC	186	}
4714eda8 MCC	187
945cdfa2 MCC	188	__module_get(THIS_MODULE);
	189
	190	path = kobject_get_path(&input_dev->dev.kobj, GFP_KERNEL);
	191	printk(KERN_INFO "%s: %s associated with sysfs %s\n",
	192	dev_name(&ir_dev->dev),
	193	input_dev->name ? input_dev->name : "Unspecified device",
	194	path ? path : "N/A");
	195	kfree(path);
	196
4714eda8 MCC	197	ir_dev->devno = devno;
	198	set_bit(devno, &ir_core_dev_number);
	199
	200	return 0;
	201	};
	202
d4b778d3 MCC	203	/**
	204	* ir_unregister_class() - removes the sysfs for sysfs for
	205	* /sys/class/irrcv/irrcv?
	206	* @input_dev: the struct input_dev descriptor of the device
	207	*
	208	* This routine is used to unregister the syfs code for IR class
	209	*/
4714eda8 MCC	210	void ir_unregister_class(struct input_dev *input_dev)
	211	{
	212	struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
4714eda8 MCC	213
4714eda8 MCC	214	clear_bit(ir_dev->devno, &ir_core_dev_number);
945cdfa2 MCC	215	input_unregister_device(input_dev);
945cdfa2 MCC	216	device_del(&ir_dev->dev);
4714eda8	217
945cdfa2	218	module_put(THIS_MODULE);
4714eda8 MCC	219	}
4714eda8 MCC	220
d4b778d3 MCC	221	/*
	222	* Init/exit code for the module. Basically, creates/removes /sys/class/irrcv
	223	*/
	224
4714eda8 MCC	225	static int __init ir_core_init(void)
4714eda8 MCC	226	{
945cdfa2 MCC	227	int rc = class_register(&ir_input_class);
945cdfa2 MCC	228	if (rc) {
4714eda8	229	printk(KERN_ERR "ir_core: unable to register irrcv class\n");
945cdfa2	230	return rc;
4714eda8 MCC	231	}
	232
	233	return 0;
	234	}
	235
	236	static void __exit ir_core_exit(void)
	237	{
945cdfa2	238	class_unregister(&ir_input_class);
4714eda8 MCC	239	}
	240
	241	module_init(ir_core_init);
	242	module_exit(ir_core_exit);