1 /* ir-sysfs.c - sysfs interface for RC devices (/sys/class/rc)
3 * Copyright (C) 2009-2010 by Mauro Carvalho Chehab <mchehab@redhat.com>
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.
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.
15 #include <linux/slab.h>
16 #include <linux/input.h>
17 #include <linux/device.h>
18 #include "ir-core-priv.h"
20 #define IRRCV_NUM_DEVICES 256
22 /* bit array to represent IR sysfs device number */
23 static unsigned long ir_core_dev_number;
25 /* class for /sys/class/rc */
26 static char *ir_devnode(struct device *dev, mode_t *mode)
28 return kasprintf(GFP_KERNEL, "rc/%s", dev_name(dev));
31 static struct class ir_input_class = {
33 .devnode = ir_devnode,
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
42 * This routine is a callback routine for input read the IR protocol type.
43 * it is trigged by reading /sys/class/rc/rc?/current_protocol.
44 * It returns the protocol name, as understood by the driver.
46 static ssize_t show_protocol(struct device *d,
47 struct device_attribute *mattr, char *buf)
50 struct ir_input_dev *ir_dev = dev_get_drvdata(d);
51 u64 ir_type = ir_dev->rc_tab.ir_type;
53 IR_dprintk(1, "Current protocol is %lld\n", (long long)ir_type);
55 /* FIXME: doesn't support multiple protocols at the same time */
56 if (ir_type == IR_TYPE_UNKNOWN)
58 else if (ir_type == IR_TYPE_RC5)
60 else if (ir_type == IR_TYPE_PD)
62 else if (ir_type == IR_TYPE_NEC)
64 else if (ir_type == IR_TYPE_RC6)
66 else if (ir_type == IR_TYPE_JVC)
68 else if (ir_type == IR_TYPE_SONY)
73 return sprintf(buf, "%s\n", s);
77 * store_protocol() - shows the current IR protocol
78 * @d: the device descriptor
79 * @mattr: the device attribute struct (unused)
80 * @buf: a pointer to the input buffer
81 * @len: length of the input buffer
83 * This routine is a callback routine for changing the IR protocol type.
84 * it is trigged by reading /sys/class/rc/rc?/current_protocol.
85 * It changes the IR the protocol name, if the IR type is recognized
87 * If an unknown protocol name is used, returns -EINVAL.
89 static ssize_t store_protocol(struct device *d,
90 struct device_attribute *mattr,
94 struct ir_input_dev *ir_dev = dev_get_drvdata(d);
100 while ((buf = strsep((char **) &data, " \n")) != NULL) {
101 if (!strcasecmp(buf, "rc-5") || !strcasecmp(buf, "rc5"))
102 ir_type |= IR_TYPE_RC5;
103 if (!strcasecmp(buf, "pd") || !strcasecmp(buf, "pulse-distance"))
104 ir_type |= IR_TYPE_PD;
105 if (!strcasecmp(buf, "nec"))
106 ir_type |= IR_TYPE_NEC;
107 if (!strcasecmp(buf, "jvc"))
108 ir_type |= IR_TYPE_JVC;
109 if (!strcasecmp(buf, "sony"))
110 ir_type |= IR_TYPE_SONY;
114 IR_dprintk(1, "Unknown protocol\n");
118 if (ir_dev->props && ir_dev->props->change_protocol)
119 rc = ir_dev->props->change_protocol(ir_dev->props->priv,
123 IR_dprintk(1, "Error setting protocol to %lld\n",
128 spin_lock_irqsave(&ir_dev->rc_tab.lock, flags);
129 ir_dev->rc_tab.ir_type = ir_type;
130 spin_unlock_irqrestore(&ir_dev->rc_tab.lock, flags);
132 IR_dprintk(1, "Current protocol(s) is(are) %lld\n",
138 static ssize_t show_supported_protocols(struct device *d,
139 struct device_attribute *mattr, char *buf)
142 struct ir_input_dev *ir_dev = dev_get_drvdata(d);
144 /* FIXME: doesn't support multiple protocols at the same time */
145 if (ir_dev->props->allowed_protos == IR_TYPE_UNKNOWN)
146 buf += sprintf(buf, "unknown ");
147 if (ir_dev->props->allowed_protos & IR_TYPE_RC5)
148 buf += sprintf(buf, "rc-5 ");
149 if (ir_dev->props->allowed_protos & IR_TYPE_PD)
150 buf += sprintf(buf, "pulse-distance ");
151 if (ir_dev->props->allowed_protos & IR_TYPE_NEC)
152 buf += sprintf(buf, "nec ");
154 buf += sprintf(buf, "other ");
156 buf += sprintf(buf - 1, "\n");
161 #define ADD_HOTPLUG_VAR(fmt, val...) \
163 int err = add_uevent_var(env, fmt, val); \
168 static int ir_dev_uevent(struct device *device, struct kobj_uevent_env *env)
170 struct ir_input_dev *ir_dev = dev_get_drvdata(device);
172 if (ir_dev->rc_tab.name)
173 ADD_HOTPLUG_VAR("NAME=%s", ir_dev->rc_tab.name);
174 if (ir_dev->driver_name)
175 ADD_HOTPLUG_VAR("DRV_NAME=%s", ir_dev->driver_name);
181 * Static device attribute struct with the sysfs attributes for IR's
183 static DEVICE_ATTR(protocol, S_IRUGO | S_IWUSR,
184 show_protocol, store_protocol);
186 static DEVICE_ATTR(supported_protocols, S_IRUGO | S_IWUSR,
187 show_supported_protocols, NULL);
189 static struct attribute *ir_hw_dev_attrs[] = {
190 &dev_attr_protocol.attr,
191 &dev_attr_supported_protocols.attr,
195 static struct attribute_group ir_hw_dev_attr_grp = {
196 .attrs = ir_hw_dev_attrs,
199 static const struct attribute_group *ir_hw_dev_attr_groups[] = {
204 static struct device_type rc_dev_type = {
205 .groups = ir_hw_dev_attr_groups,
206 .uevent = ir_dev_uevent,
209 static struct device_type ir_raw_dev_type = {
210 .uevent = ir_dev_uevent,
214 * ir_register_class() - creates the sysfs for /sys/class/rc/rc?
215 * @input_dev: the struct input_dev descriptor of the device
217 * This routine is used to register the syfs code for IR class
219 int ir_register_class(struct input_dev *input_dev)
223 struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
224 int devno = find_first_zero_bit(&ir_core_dev_number,
227 if (unlikely(devno < 0))
230 if (ir_dev->props->driver_type == RC_DRIVER_SCANCODE)
231 ir_dev->dev.type = &rc_dev_type;
233 ir_dev->dev.type = &ir_raw_dev_type;
235 ir_dev->dev.class = &ir_input_class;
236 ir_dev->dev.parent = input_dev->dev.parent;
237 dev_set_name(&ir_dev->dev, "rc%d", devno);
238 dev_set_drvdata(&ir_dev->dev, ir_dev);
239 rc = device_register(&ir_dev->dev);
244 input_dev->dev.parent = &ir_dev->dev;
245 rc = input_register_device(input_dev);
247 device_del(&ir_dev->dev);
251 __module_get(THIS_MODULE);
253 path = kobject_get_path(&ir_dev->dev.kobj, GFP_KERNEL);
254 printk(KERN_INFO "%s: %s as %s\n",
255 dev_name(&ir_dev->dev),
256 input_dev->name ? input_dev->name : "Unspecified device",
257 path ? path : "N/A");
260 ir_dev->devno = devno;
261 set_bit(devno, &ir_core_dev_number);
267 * ir_unregister_class() - removes the sysfs for sysfs for
269 * @input_dev: the struct input_dev descriptor of the device
271 * This routine is used to unregister the syfs code for IR class
273 void ir_unregister_class(struct input_dev *input_dev)
275 struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
277 clear_bit(ir_dev->devno, &ir_core_dev_number);
278 input_unregister_device(input_dev);
279 device_del(&ir_dev->dev);
281 module_put(THIS_MODULE);
285 * Init/exit code for the module. Basically, creates/removes /sys/class/rc
288 static int __init ir_core_init(void)
290 int rc = class_register(&ir_input_class);
292 printk(KERN_ERR "ir_core: unable to register rc class\n");
296 /* Initialize/load the decoders/keymap code that will be used */
302 static void __exit ir_core_exit(void)
304 class_unregister(&ir_input_class);
307 module_init(ir_core_init);
308 module_exit(ir_core_exit);