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 | ||
15 | #include <linux/input.h> | |
16 | #include <linux/device.h> | |
17 | #include <media/ir-core.h> | |
18 | ||
19 | #define IRRCV_NUM_DEVICES 256 | |
20 | ||
d4b778d3 MCC |
21 | /* bit array to represent IR sysfs device number */ |
22 | static unsigned long ir_core_dev_number; | |
4714eda8 | 23 | |
d4b778d3 | 24 | /* class for /sys/class/irrcv */ |
4714eda8 MCC |
25 | static struct class *ir_input_class; |
26 | ||
d4b778d3 MCC |
27 | /** |
28 | * show_protocol() - shows the current IR protocol | |
29 | * @d: the device descriptor | |
30 | * @mattr: the device attribute struct (unused) | |
31 | * @buf: a pointer to the output buffer | |
32 | * | |
33 | * This routine is a callback routine for input read the IR protocol type. | |
34 | * it is trigged by reading /sys/class/irrcv/irrcv?/current_protocol. | |
35 | * It returns the protocol name, as understood by the driver. | |
36 | */ | |
53f87022 MCC |
37 | static ssize_t show_protocol(struct device *d, |
38 | struct device_attribute *mattr, char *buf) | |
39 | { | |
40 | char *s; | |
41 | struct ir_input_dev *ir_dev = dev_get_drvdata(d); | |
971e8298 | 42 | u64 ir_type = ir_dev->rc_tab.ir_type; |
53f87022 | 43 | |
971e8298 | 44 | IR_dprintk(1, "Current protocol is %lld\n", (long long)ir_type); |
53f87022 MCC |
45 | |
46 | /* FIXME: doesn't support multiple protocols at the same time */ | |
47 | if (ir_type == IR_TYPE_UNKNOWN) | |
48 | s = "Unknown"; | |
49 | else if (ir_type == IR_TYPE_RC5) | |
50 | s = "RC-5"; | |
51 | else if (ir_type == IR_TYPE_PD) | |
52 | s = "Pulse/distance"; | |
53 | else if (ir_type == IR_TYPE_NEC) | |
54 | s = "NEC"; | |
55 | else | |
56 | s = "Other"; | |
57 | ||
58 | return sprintf(buf, "%s\n", s); | |
59 | } | |
60 | ||
d4b778d3 MCC |
61 | /** |
62 | * store_protocol() - shows the current IR protocol | |
63 | * @d: the device descriptor | |
64 | * @mattr: the device attribute struct (unused) | |
65 | * @buf: a pointer to the input buffer | |
66 | * @len: length of the input buffer | |
67 | * | |
68 | * This routine is a callback routine for changing the IR protocol type. | |
69 | * it is trigged by reading /sys/class/irrcv/irrcv?/current_protocol. | |
70 | * It changes the IR the protocol name, if the IR type is recognized | |
71 | * by the driver. | |
72 | * If an unknown protocol name is used, returns -EINVAL. | |
73 | */ | |
09b01b90 MCC |
74 | static ssize_t store_protocol(struct device *d, |
75 | struct device_attribute *mattr, | |
76 | const char *data, | |
77 | size_t len) | |
78 | { | |
79 | struct ir_input_dev *ir_dev = dev_get_drvdata(d); | |
971e8298 | 80 | u64 ir_type = IR_TYPE_UNKNOWN; |
09b01b90 | 81 | int rc = -EINVAL; |
eecee32a | 82 | unsigned long flags; |
09b01b90 MCC |
83 | char *buf; |
84 | ||
85 | buf = strsep((char **) &data, "\n"); | |
86 | ||
87 | if (!strcasecmp(buf, "rc-5")) | |
88 | ir_type = IR_TYPE_RC5; | |
89 | else if (!strcasecmp(buf, "pd")) | |
90 | ir_type = IR_TYPE_PD; | |
91 | else if (!strcasecmp(buf, "nec")) | |
92 | ir_type = IR_TYPE_NEC; | |
93 | ||
94 | if (ir_type == IR_TYPE_UNKNOWN) { | |
971e8298 MCC |
95 | IR_dprintk(1, "Error setting protocol to %lld\n", |
96 | (long long)ir_type); | |
09b01b90 MCC |
97 | return -EINVAL; |
98 | } | |
99 | ||
100 | if (ir_dev->props->change_protocol) | |
101 | rc = ir_dev->props->change_protocol(ir_dev->props->priv, | |
102 | ir_type); | |
103 | ||
104 | if (rc < 0) { | |
971e8298 MCC |
105 | IR_dprintk(1, "Error setting protocol to %lld\n", |
106 | (long long)ir_type); | |
09b01b90 MCC |
107 | return -EINVAL; |
108 | } | |
109 | ||
eecee32a | 110 | spin_lock_irqsave(&ir_dev->rc_tab.lock, flags); |
09b01b90 | 111 | ir_dev->rc_tab.ir_type = ir_type; |
eecee32a | 112 | spin_unlock_irqrestore(&ir_dev->rc_tab.lock, flags); |
09b01b90 | 113 | |
971e8298 MCC |
114 | IR_dprintk(1, "Current protocol is %lld\n", |
115 | (long long)ir_type); | |
09b01b90 MCC |
116 | |
117 | return len; | |
118 | } | |
119 | ||
d4b778d3 MCC |
120 | /* |
121 | * Static device attribute struct with the sysfs attributes for IR's | |
122 | */ | |
53f87022 | 123 | static DEVICE_ATTR(current_protocol, S_IRUGO | S_IWUSR, |
09b01b90 | 124 | show_protocol, store_protocol); |
4714eda8 MCC |
125 | |
126 | static struct attribute *ir_dev_attrs[] = { | |
53f87022 | 127 | &dev_attr_current_protocol.attr, |
4714eda8 MCC |
128 | }; |
129 | ||
d4b778d3 MCC |
130 | /** |
131 | * ir_register_class() - creates the sysfs for /sys/class/irrcv/irrcv? | |
132 | * @input_dev: the struct input_dev descriptor of the device | |
133 | * | |
134 | * This routine is used to register the syfs code for IR class | |
135 | */ | |
4714eda8 MCC |
136 | int ir_register_class(struct input_dev *input_dev) |
137 | { | |
138 | int rc; | |
139 | struct kobject *kobj; | |
140 | ||
141 | struct ir_input_dev *ir_dev = input_get_drvdata(input_dev); | |
142 | int devno = find_first_zero_bit(&ir_core_dev_number, | |
143 | IRRCV_NUM_DEVICES); | |
144 | ||
145 | if (unlikely(devno < 0)) | |
146 | return devno; | |
147 | ||
148 | ir_dev->attr.attrs = ir_dev_attrs; | |
149 | ir_dev->class_dev = device_create(ir_input_class, NULL, | |
150 | input_dev->dev.devt, ir_dev, | |
151 | "irrcv%d", devno); | |
152 | kobj = &ir_dev->class_dev->kobj; | |
153 | ||
154 | printk(KERN_WARNING "Creating IR device %s\n", kobject_name(kobj)); | |
155 | rc = sysfs_create_group(kobj, &ir_dev->attr); | |
156 | if (unlikely(rc < 0)) { | |
157 | device_destroy(ir_input_class, input_dev->dev.devt); | |
158 | return -ENOMEM; | |
159 | } | |
160 | ||
161 | ir_dev->devno = devno; | |
162 | set_bit(devno, &ir_core_dev_number); | |
163 | ||
164 | return 0; | |
165 | }; | |
166 | ||
d4b778d3 MCC |
167 | /** |
168 | * ir_unregister_class() - removes the sysfs for sysfs for | |
169 | * /sys/class/irrcv/irrcv? | |
170 | * @input_dev: the struct input_dev descriptor of the device | |
171 | * | |
172 | * This routine is used to unregister the syfs code for IR class | |
173 | */ | |
4714eda8 MCC |
174 | void ir_unregister_class(struct input_dev *input_dev) |
175 | { | |
176 | struct ir_input_dev *ir_dev = input_get_drvdata(input_dev); | |
177 | struct kobject *kobj; | |
178 | ||
179 | clear_bit(ir_dev->devno, &ir_core_dev_number); | |
180 | ||
181 | kobj = &ir_dev->class_dev->kobj; | |
182 | ||
183 | sysfs_remove_group(kobj, &ir_dev->attr); | |
184 | device_destroy(ir_input_class, input_dev->dev.devt); | |
185 | ||
186 | kfree(ir_dev->attr.name); | |
187 | } | |
188 | ||
d4b778d3 MCC |
189 | /* |
190 | * Init/exit code for the module. Basically, creates/removes /sys/class/irrcv | |
191 | */ | |
192 | ||
4714eda8 MCC |
193 | static int __init ir_core_init(void) |
194 | { | |
195 | ir_input_class = class_create(THIS_MODULE, "irrcv"); | |
196 | if (IS_ERR(ir_input_class)) { | |
197 | printk(KERN_ERR "ir_core: unable to register irrcv class\n"); | |
198 | return PTR_ERR(ir_input_class); | |
199 | } | |
200 | ||
201 | return 0; | |
202 | } | |
203 | ||
204 | static void __exit ir_core_exit(void) | |
205 | { | |
206 | class_destroy(ir_input_class); | |
207 | } | |
208 | ||
209 | module_init(ir_core_init); | |
210 | module_exit(ir_core_exit); |