aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/media/IR/ir-sysfs.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/media/IR/ir-sysfs.c')
-rw-r--r--drivers/media/IR/ir-sysfs.c362
1 files changed, 0 insertions, 362 deletions
diff --git a/drivers/media/IR/ir-sysfs.c b/drivers/media/IR/ir-sysfs.c
deleted file mode 100644
index 38423a8da871..000000000000
--- a/drivers/media/IR/ir-sysfs.c
+++ /dev/null
@@ -1,362 +0,0 @@
1/* ir-sysfs.c - sysfs interface for RC devices (/sys/class/rc)
2 *
3 * Copyright (C) 2009-2010 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
15#include <linux/slab.h>
16#include <linux/input.h>
17#include <linux/device.h>
18#include "ir-core-priv.h"
19
20#define IRRCV_NUM_DEVICES 256
21
22/* bit array to represent IR sysfs device number */
23static unsigned long ir_core_dev_number;
24
25/* class for /sys/class/rc */
26static char *ir_devnode(struct device *dev, mode_t *mode)
27{
28 return kasprintf(GFP_KERNEL, "rc/%s", dev_name(dev));
29}
30
31static struct class ir_input_class = {
32 .name = "rc",
33 .devnode = ir_devnode,
34};
35
36static struct {
37 u64 type;
38 char *name;
39} proto_names[] = {
40 { IR_TYPE_UNKNOWN, "unknown" },
41 { IR_TYPE_RC5, "rc-5" },
42 { IR_TYPE_NEC, "nec" },
43 { IR_TYPE_RC6, "rc-6" },
44 { IR_TYPE_JVC, "jvc" },
45 { IR_TYPE_SONY, "sony" },
46 { IR_TYPE_RC5_SZ, "rc-5-sz" },
47 { IR_TYPE_LIRC, "lirc" },
48};
49
50#define PROTO_NONE "none"
51
52/**
53 * show_protocols() - shows the current IR protocol(s)
54 * @d: the device descriptor
55 * @mattr: the device attribute struct (unused)
56 * @buf: a pointer to the output buffer
57 *
58 * This routine is a callback routine for input read the IR protocol type(s).
59 * it is trigged by reading /sys/class/rc/rc?/protocols.
60 * It returns the protocol names of supported protocols.
61 * Enabled protocols are printed in brackets.
62 */
63static ssize_t show_protocols(struct device *d,
64 struct device_attribute *mattr, char *buf)
65{
66 struct ir_input_dev *ir_dev = dev_get_drvdata(d);
67 u64 allowed, enabled;
68 char *tmp = buf;
69 int i;
70
71 /* Device is being removed */
72 if (!ir_dev)
73 return -EINVAL;
74
75 if (ir_dev->props && ir_dev->props->driver_type == RC_DRIVER_SCANCODE) {
76 enabled = ir_dev->rc_tab.ir_type;
77 allowed = ir_dev->props->allowed_protos;
78 } else if (ir_dev->raw) {
79 enabled = ir_dev->raw->enabled_protocols;
80 allowed = ir_raw_get_allowed_protocols();
81 } else
82 return sprintf(tmp, "[builtin]\n");
83
84 IR_dprintk(1, "allowed - 0x%llx, enabled - 0x%llx\n",
85 (long long)allowed,
86 (long long)enabled);
87
88 for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
89 if (allowed & enabled & proto_names[i].type)
90 tmp += sprintf(tmp, "[%s] ", proto_names[i].name);
91 else if (allowed & proto_names[i].type)
92 tmp += sprintf(tmp, "%s ", proto_names[i].name);
93 }
94
95 if (tmp != buf)
96 tmp--;
97 *tmp = '\n';
98 return tmp + 1 - buf;
99}
100
101/**
102 * store_protocols() - changes the current IR protocol(s)
103 * @d: the device descriptor
104 * @mattr: the device attribute struct (unused)
105 * @buf: a pointer to the input buffer
106 * @len: length of the input buffer
107 *
108 * This routine is a callback routine for changing the IR protocol type.
109 * It is trigged by writing to /sys/class/rc/rc?/protocols.
110 * Writing "+proto" will add a protocol to the list of enabled protocols.
111 * Writing "-proto" will remove a protocol from the list of enabled protocols.
112 * Writing "proto" will enable only "proto".
113 * Writing "none" will disable all protocols.
114 * Returns -EINVAL if an invalid protocol combination or unknown protocol name
115 * is used, otherwise @len.
116 */
117static ssize_t store_protocols(struct device *d,
118 struct device_attribute *mattr,
119 const char *data,
120 size_t len)
121{
122 struct ir_input_dev *ir_dev = dev_get_drvdata(d);
123 bool enable, disable;
124 const char *tmp;
125 u64 type;
126 u64 mask;
127 int rc, i, count = 0;
128 unsigned long flags;
129
130 /* Device is being removed */
131 if (!ir_dev)
132 return -EINVAL;
133
134 if (ir_dev->props && ir_dev->props->driver_type == RC_DRIVER_SCANCODE)
135 type = ir_dev->rc_tab.ir_type;
136 else if (ir_dev->raw)
137 type = ir_dev->raw->enabled_protocols;
138 else {
139 IR_dprintk(1, "Protocol switching not supported\n");
140 return -EINVAL;
141 }
142
143 while ((tmp = strsep((char **) &data, " \n")) != NULL) {
144 if (!*tmp)
145 break;
146
147 if (*tmp == '+') {
148 enable = true;
149 disable = false;
150 tmp++;
151 } else if (*tmp == '-') {
152 enable = false;
153 disable = true;
154 tmp++;
155 } else {
156 enable = false;
157 disable = false;
158 }
159
160 if (!enable && !disable && !strncasecmp(tmp, PROTO_NONE, sizeof(PROTO_NONE))) {
161 tmp += sizeof(PROTO_NONE);
162 mask = 0;
163 count++;
164 } else {
165 for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
166 if (!strncasecmp(tmp, proto_names[i].name, strlen(proto_names[i].name))) {
167 tmp += strlen(proto_names[i].name);
168 mask = proto_names[i].type;
169 break;
170 }
171 }
172 if (i == ARRAY_SIZE(proto_names)) {
173 IR_dprintk(1, "Unknown protocol: '%s'\n", tmp);
174 return -EINVAL;
175 }
176 count++;
177 }
178
179 if (enable)
180 type |= mask;
181 else if (disable)
182 type &= ~mask;
183 else
184 type = mask;
185 }
186
187 if (!count) {
188 IR_dprintk(1, "Protocol not specified\n");
189 return -EINVAL;
190 }
191
192 if (ir_dev->props && ir_dev->props->change_protocol) {
193 rc = ir_dev->props->change_protocol(ir_dev->props->priv,
194 type);
195 if (rc < 0) {
196 IR_dprintk(1, "Error setting protocols to 0x%llx\n",
197 (long long)type);
198 return -EINVAL;
199 }
200 }
201
202 if (ir_dev->props && ir_dev->props->driver_type == RC_DRIVER_SCANCODE) {
203 spin_lock_irqsave(&ir_dev->rc_tab.lock, flags);
204 ir_dev->rc_tab.ir_type = type;
205 spin_unlock_irqrestore(&ir_dev->rc_tab.lock, flags);
206 } else {
207 ir_dev->raw->enabled_protocols = type;
208 }
209
210 IR_dprintk(1, "Current protocol(s): 0x%llx\n",
211 (long long)type);
212
213 return len;
214}
215
216#define ADD_HOTPLUG_VAR(fmt, val...) \
217 do { \
218 int err = add_uevent_var(env, fmt, val); \
219 if (err) \
220 return err; \
221 } while (0)
222
223static int rc_dev_uevent(struct device *device, struct kobj_uevent_env *env)
224{
225 struct ir_input_dev *ir_dev = dev_get_drvdata(device);
226
227 if (ir_dev->rc_tab.name)
228 ADD_HOTPLUG_VAR("NAME=%s", ir_dev->rc_tab.name);
229 if (ir_dev->driver_name)
230 ADD_HOTPLUG_VAR("DRV_NAME=%s", ir_dev->driver_name);
231
232 return 0;
233}
234
235/*
236 * Static device attribute struct with the sysfs attributes for IR's
237 */
238static DEVICE_ATTR(protocols, S_IRUGO | S_IWUSR,
239 show_protocols, store_protocols);
240
241static struct attribute *rc_dev_attrs[] = {
242 &dev_attr_protocols.attr,
243 NULL,
244};
245
246static struct attribute_group rc_dev_attr_grp = {
247 .attrs = rc_dev_attrs,
248};
249
250static const struct attribute_group *rc_dev_attr_groups[] = {
251 &rc_dev_attr_grp,
252 NULL
253};
254
255static struct device_type rc_dev_type = {
256 .groups = rc_dev_attr_groups,
257 .uevent = rc_dev_uevent,
258};
259
260/**
261 * ir_register_class() - creates the sysfs for /sys/class/rc/rc?
262 * @input_dev: the struct input_dev descriptor of the device
263 *
264 * This routine is used to register the syfs code for IR class
265 */
266int ir_register_class(struct input_dev *input_dev)
267{
268 struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
269 int devno = find_first_zero_bit(&ir_core_dev_number,
270 IRRCV_NUM_DEVICES);
271
272 if (unlikely(devno < 0))
273 return devno;
274
275 ir_dev->dev.type = &rc_dev_type;
276 ir_dev->devno = devno;
277
278 ir_dev->dev.class = &ir_input_class;
279 ir_dev->dev.parent = input_dev->dev.parent;
280 input_dev->dev.parent = &ir_dev->dev;
281 dev_set_name(&ir_dev->dev, "rc%d", devno);
282 dev_set_drvdata(&ir_dev->dev, ir_dev);
283 return device_register(&ir_dev->dev);
284};
285
286/**
287 * ir_register_input - registers ir input device with input subsystem
288 * @input_dev: the struct input_dev descriptor of the device
289 */
290
291int ir_register_input(struct input_dev *input_dev)
292{
293 struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
294 int rc;
295 const char *path;
296
297
298 rc = input_register_device(input_dev);
299 if (rc < 0) {
300 device_del(&ir_dev->dev);
301 return rc;
302 }
303
304 __module_get(THIS_MODULE);
305
306 path = kobject_get_path(&ir_dev->dev.kobj, GFP_KERNEL);
307 printk(KERN_INFO "%s: %s as %s\n",
308 dev_name(&ir_dev->dev),
309 input_dev->name ? input_dev->name : "Unspecified device",
310 path ? path : "N/A");
311 kfree(path);
312
313 set_bit(ir_dev->devno, &ir_core_dev_number);
314 return 0;
315}
316
317/**
318 * ir_unregister_class() - removes the sysfs for sysfs for
319 * /sys/class/rc/rc?
320 * @input_dev: the struct input_dev descriptor of the device
321 *
322 * This routine is used to unregister the syfs code for IR class
323 */
324void ir_unregister_class(struct input_dev *input_dev)
325{
326 struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
327
328 input_set_drvdata(input_dev, NULL);
329 clear_bit(ir_dev->devno, &ir_core_dev_number);
330 input_unregister_device(input_dev);
331 device_del(&ir_dev->dev);
332
333 module_put(THIS_MODULE);
334}
335
336/*
337 * Init/exit code for the module. Basically, creates/removes /sys/class/rc
338 */
339
340static int __init ir_core_init(void)
341{
342 int rc = class_register(&ir_input_class);
343 if (rc) {
344 printk(KERN_ERR "ir_core: unable to register rc class\n");
345 return rc;
346 }
347
348 /* Initialize/load the decoders/keymap code that will be used */
349 ir_raw_init();
350 ir_rcmap_init();
351
352 return 0;
353}
354
355static void __exit ir_core_exit(void)
356{
357 class_unregister(&ir_input_class);
358 ir_rcmap_cleanup();
359}
360
361module_init(ir_core_init);
362module_exit(ir_core_exit);
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-26 12:21:03 -0500