]>
Commit | Line | Data |
---|---|---|
4714eda8 MCC |
1 | /* ir-register.c - handle IR scancode->keycode tables |
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> |
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 */ |
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) |
27 | { | |
e202c15b | 28 | return kasprintf(GFP_KERNEL, "rc/%s", dev_name(dev)); |
945cdfa2 MCC |
29 | } |
30 | ||
995187be | 31 | static struct class ir_input_class = { |
e202c15b | 32 | .name = "rc", |
945cdfa2 MCC |
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. | |
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. |
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) |
65 | s = "rc6"; | |
bf670f64 DH |
66 | else if (ir_type == IR_TYPE_JVC) |
67 | s = "jvc"; | |
3fe29c89 DH |
68 | else if (ir_type == IR_TYPE_SONY) |
69 | s = "sony"; | |
53f87022 | 70 | else |
b320f80a | 71 | s = "other"; |
53f87022 MCC |
72 | |
73 | return sprintf(buf, "%s\n", s); | |
74 | } | |
75 | ||
d4b778d3 MCC |
76 | /** |
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 | |
82 | * | |
83 | * This routine is a callback routine for changing the IR protocol type. | |
de88f31c | 84 | * it is trigged by reading /sys/class/rc/rc?/current_protocol. |
d4b778d3 MCC |
85 | * It changes the IR the protocol name, if the IR type is recognized |
86 | * by the driver. | |
87 | * If an unknown protocol name is used, returns -EINVAL. | |
88 | */ | |
09b01b90 MCC |
89 | static ssize_t store_protocol(struct device *d, |
90 | struct device_attribute *mattr, | |
91 | const char *data, | |
92 | size_t len) | |
93 | { | |
94 | struct ir_input_dev *ir_dev = dev_get_drvdata(d); | |
b320f80a | 95 | u64 ir_type = 0; |
09b01b90 | 96 | int rc = -EINVAL; |
eecee32a | 97 | unsigned long flags; |
09b01b90 MCC |
98 | char *buf; |
99 | ||
d22e546e | 100 | while ((buf = strsep((char **) &data, " \n")) != NULL) { |
b320f80a MCC |
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; | |
bf670f64 DH |
107 | if (!strcasecmp(buf, "jvc")) |
108 | ir_type |= IR_TYPE_JVC; | |
3fe29c89 DH |
109 | if (!strcasecmp(buf, "sony")) |
110 | ir_type |= IR_TYPE_SONY; | |
b320f80a | 111 | } |
09b01b90 | 112 | |
b320f80a MCC |
113 | if (!ir_type) { |
114 | IR_dprintk(1, "Unknown protocol\n"); | |
09b01b90 MCC |
115 | return -EINVAL; |
116 | } | |
117 | ||
0f7ff395 | 118 | if (ir_dev->props && ir_dev->props->change_protocol) |
09b01b90 MCC |
119 | rc = ir_dev->props->change_protocol(ir_dev->props->priv, |
120 | ir_type); | |
121 | ||
122 | if (rc < 0) { | |
971e8298 MCC |
123 | IR_dprintk(1, "Error setting protocol to %lld\n", |
124 | (long long)ir_type); | |
09b01b90 MCC |
125 | return -EINVAL; |
126 | } | |
127 | ||
eecee32a | 128 | spin_lock_irqsave(&ir_dev->rc_tab.lock, flags); |
09b01b90 | 129 | ir_dev->rc_tab.ir_type = ir_type; |
eecee32a | 130 | spin_unlock_irqrestore(&ir_dev->rc_tab.lock, flags); |
09b01b90 | 131 | |
b320f80a | 132 | IR_dprintk(1, "Current protocol(s) is(are) %lld\n", |
971e8298 | 133 | (long long)ir_type); |
09b01b90 MCC |
134 | |
135 | return len; | |
136 | } | |
137 | ||
b320f80a MCC |
138 | static ssize_t show_supported_protocols(struct device *d, |
139 | struct device_attribute *mattr, char *buf) | |
140 | { | |
141 | char *orgbuf = buf; | |
142 | struct ir_input_dev *ir_dev = dev_get_drvdata(d); | |
143 | ||
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 "); | |
153 | if (buf == orgbuf) | |
154 | buf += sprintf(buf, "other "); | |
155 | ||
156 | buf += sprintf(buf - 1, "\n"); | |
157 | ||
158 | return buf - orgbuf; | |
159 | } | |
9c89a181 MCC |
160 | |
161 | #define ADD_HOTPLUG_VAR(fmt, val...) \ | |
162 | do { \ | |
163 | int err = add_uevent_var(env, fmt, val); \ | |
164 | if (err) \ | |
165 | return err; \ | |
166 | } while (0) | |
167 | ||
168 | static int ir_dev_uevent(struct device *device, struct kobj_uevent_env *env) | |
169 | { | |
170 | struct ir_input_dev *ir_dev = dev_get_drvdata(device); | |
171 | ||
172 | if (ir_dev->rc_tab.name) | |
3efaa062 | 173 | ADD_HOTPLUG_VAR("NAME=%s", ir_dev->rc_tab.name); |
727e625c | 174 | if (ir_dev->driver_name) |
3efaa062 | 175 | ADD_HOTPLUG_VAR("DRV_NAME=%s", ir_dev->driver_name); |
9c89a181 MCC |
176 | |
177 | return 0; | |
178 | } | |
179 | ||
d4b778d3 MCC |
180 | /* |
181 | * Static device attribute struct with the sysfs attributes for IR's | |
182 | */ | |
b320f80a | 183 | static DEVICE_ATTR(protocol, S_IRUGO | S_IWUSR, |
09b01b90 | 184 | show_protocol, store_protocol); |
4714eda8 | 185 | |
b320f80a MCC |
186 | static DEVICE_ATTR(supported_protocols, S_IRUGO | S_IWUSR, |
187 | show_supported_protocols, NULL); | |
188 | ||
626cf697 | 189 | static struct attribute *ir_hw_dev_attrs[] = { |
b320f80a MCC |
190 | &dev_attr_protocol.attr, |
191 | &dev_attr_supported_protocols.attr, | |
9714d587 | 192 | NULL, |
4714eda8 MCC |
193 | }; |
194 | ||
626cf697 MCC |
195 | static struct attribute_group ir_hw_dev_attr_grp = { |
196 | .attrs = ir_hw_dev_attrs, | |
945cdfa2 MCC |
197 | }; |
198 | ||
626cf697 MCC |
199 | static const struct attribute_group *ir_hw_dev_attr_groups[] = { |
200 | &ir_hw_dev_attr_grp, | |
945cdfa2 MCC |
201 | NULL |
202 | }; | |
203 | ||
626cf697 MCC |
204 | static struct device_type rc_dev_type = { |
205 | .groups = ir_hw_dev_attr_groups, | |
206 | .uevent = ir_dev_uevent, | |
207 | }; | |
208 | ||
209 | static struct device_type ir_raw_dev_type = { | |
9c89a181 | 210 | .uevent = ir_dev_uevent, |
945cdfa2 MCC |
211 | }; |
212 | ||
d4b778d3 | 213 | /** |
de88f31c | 214 | * ir_register_class() - creates the sysfs for /sys/class/rc/rc? |
d4b778d3 MCC |
215 | * @input_dev: the struct input_dev descriptor of the device |
216 | * | |
217 | * This routine is used to register the syfs code for IR class | |
218 | */ | |
4714eda8 MCC |
219 | int ir_register_class(struct input_dev *input_dev) |
220 | { | |
221 | int rc; | |
945cdfa2 | 222 | const char *path; |
4714eda8 MCC |
223 | struct ir_input_dev *ir_dev = input_get_drvdata(input_dev); |
224 | int devno = find_first_zero_bit(&ir_core_dev_number, | |
225 | IRRCV_NUM_DEVICES); | |
226 | ||
227 | if (unlikely(devno < 0)) | |
228 | return devno; | |
229 | ||
626cf697 MCC |
230 | if (ir_dev->props->driver_type == RC_DRIVER_SCANCODE) |
231 | ir_dev->dev.type = &rc_dev_type; | |
232 | else | |
233 | ir_dev->dev.type = &ir_raw_dev_type; | |
234 | ||
945cdfa2 MCC |
235 | ir_dev->dev.class = &ir_input_class; |
236 | ir_dev->dev.parent = input_dev->dev.parent; | |
de88f31c | 237 | dev_set_name(&ir_dev->dev, "rc%d", devno); |
9c89a181 | 238 | dev_set_drvdata(&ir_dev->dev, ir_dev); |
945cdfa2 MCC |
239 | rc = device_register(&ir_dev->dev); |
240 | if (rc) | |
241 | return rc; | |
242 | ||
243 | ||
244 | input_dev->dev.parent = &ir_dev->dev; | |
245 | rc = input_register_device(input_dev); | |
246 | if (rc < 0) { | |
247 | device_del(&ir_dev->dev); | |
248 | return rc; | |
4714eda8 MCC |
249 | } |
250 | ||
945cdfa2 MCC |
251 | __module_get(THIS_MODULE); |
252 | ||
9c89a181 MCC |
253 | path = kobject_get_path(&ir_dev->dev.kobj, GFP_KERNEL); |
254 | printk(KERN_INFO "%s: %s as %s\n", | |
945cdfa2 MCC |
255 | dev_name(&ir_dev->dev), |
256 | input_dev->name ? input_dev->name : "Unspecified device", | |
257 | path ? path : "N/A"); | |
258 | kfree(path); | |
259 | ||
4714eda8 MCC |
260 | ir_dev->devno = devno; |
261 | set_bit(devno, &ir_core_dev_number); | |
262 | ||
263 | return 0; | |
264 | }; | |
265 | ||
d4b778d3 MCC |
266 | /** |
267 | * ir_unregister_class() - removes the sysfs for sysfs for | |
de88f31c | 268 | * /sys/class/rc/rc? |
d4b778d3 MCC |
269 | * @input_dev: the struct input_dev descriptor of the device |
270 | * | |
271 | * This routine is used to unregister the syfs code for IR class | |
272 | */ | |
4714eda8 MCC |
273 | void ir_unregister_class(struct input_dev *input_dev) |
274 | { | |
275 | struct ir_input_dev *ir_dev = input_get_drvdata(input_dev); | |
4714eda8 MCC |
276 | |
277 | clear_bit(ir_dev->devno, &ir_core_dev_number); | |
945cdfa2 MCC |
278 | input_unregister_device(input_dev); |
279 | device_del(&ir_dev->dev); | |
4714eda8 | 280 | |
945cdfa2 | 281 | module_put(THIS_MODULE); |
4714eda8 MCC |
282 | } |
283 | ||
d4b778d3 | 284 | /* |
e202c15b | 285 | * Init/exit code for the module. Basically, creates/removes /sys/class/rc |
d4b778d3 MCC |
286 | */ |
287 | ||
4714eda8 MCC |
288 | static int __init ir_core_init(void) |
289 | { | |
945cdfa2 MCC |
290 | int rc = class_register(&ir_input_class); |
291 | if (rc) { | |
e202c15b | 292 | printk(KERN_ERR "ir_core: unable to register rc class\n"); |
945cdfa2 | 293 | return rc; |
4714eda8 MCC |
294 | } |
295 | ||
02858eed | 296 | /* Initialize/load the decoders/keymap code that will be used */ |
995187be MCC |
297 | ir_raw_init(); |
298 | ||
4714eda8 MCC |
299 | return 0; |
300 | } | |
301 | ||
302 | static void __exit ir_core_exit(void) | |
303 | { | |
945cdfa2 | 304 | class_unregister(&ir_input_class); |
4714eda8 MCC |
305 | } |
306 | ||
307 | module_init(ir_core_init); | |
308 | module_exit(ir_core_exit); |