aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/media/IR
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/media/IR')
-rw-r--r--drivers/media/IR/ir-core-priv.h3
-rw-r--r--drivers/media/IR/ir-jvc-decoder.c65
-rw-r--r--drivers/media/IR/ir-nec-decoder.c65
-rw-r--r--drivers/media/IR/ir-raw-event.c112
-rw-r--r--drivers/media/IR/ir-rc5-decoder.c67
-rw-r--r--drivers/media/IR/ir-rc6-decoder.c65
-rw-r--r--drivers/media/IR/ir-sony-decoder.c65
-rw-r--r--drivers/media/IR/ir-sysfs.c252
8 files changed, 232 insertions, 462 deletions
diff --git a/drivers/media/IR/ir-core-priv.h b/drivers/media/IR/ir-core-priv.h
index 9a5e65a471a..5111dc23909 100644
--- a/drivers/media/IR/ir-core-priv.h
+++ b/drivers/media/IR/ir-core-priv.h
@@ -22,6 +22,7 @@
22struct ir_raw_handler { 22struct ir_raw_handler {
23 struct list_head list; 23 struct list_head list;
24 24
25 u64 protocols; /* which are handled by this handler */
25 int (*decode)(struct input_dev *input_dev, struct ir_raw_event event); 26 int (*decode)(struct input_dev *input_dev, struct ir_raw_event event);
26 int (*raw_register)(struct input_dev *input_dev); 27 int (*raw_register)(struct input_dev *input_dev);
27 int (*raw_unregister)(struct input_dev *input_dev); 28 int (*raw_unregister)(struct input_dev *input_dev);
@@ -33,6 +34,7 @@ struct ir_raw_event_ctrl {
33 ktime_t last_event; /* when last event occurred */ 34 ktime_t last_event; /* when last event occurred */
34 enum raw_event_type last_type; /* last event type */ 35 enum raw_event_type last_type; /* last event type */
35 struct input_dev *input_dev; /* pointer to the parent input_dev */ 36 struct input_dev *input_dev; /* pointer to the parent input_dev */
37 u64 enabled_protocols; /* enabled raw protocol decoders */
36}; 38};
37 39
38/* macros for IR decoders */ 40/* macros for IR decoders */
@@ -74,6 +76,7 @@ void ir_unregister_class(struct input_dev *input_dev);
74/* 76/*
75 * Routines from ir-raw-event.c to be used internally and by decoders 77 * Routines from ir-raw-event.c to be used internally and by decoders
76 */ 78 */
79u64 ir_raw_get_allowed_protocols(void);
77int ir_raw_event_register(struct input_dev *input_dev); 80int ir_raw_event_register(struct input_dev *input_dev);
78void ir_raw_event_unregister(struct input_dev *input_dev); 81void ir_raw_event_unregister(struct input_dev *input_dev);
79int ir_raw_handler_register(struct ir_raw_handler *ir_raw_handler); 82int ir_raw_handler_register(struct ir_raw_handler *ir_raw_handler);
diff --git a/drivers/media/IR/ir-jvc-decoder.c b/drivers/media/IR/ir-jvc-decoder.c
index b02e8013b9b..b1f935884d3 100644
--- a/drivers/media/IR/ir-jvc-decoder.c
+++ b/drivers/media/IR/ir-jvc-decoder.c
@@ -41,7 +41,6 @@ enum jvc_state {
41struct decoder_data { 41struct decoder_data {
42 struct list_head list; 42 struct list_head list;
43 struct ir_input_dev *ir_dev; 43 struct ir_input_dev *ir_dev;
44 int enabled:1;
45 44
46 /* State machine control */ 45 /* State machine control */
47 enum jvc_state state; 46 enum jvc_state state;
@@ -72,53 +71,6 @@ static struct decoder_data *get_decoder_data(struct ir_input_dev *ir_dev)
72 return data; 71 return data;
73} 72}
74 73
75static ssize_t store_enabled(struct device *d,
76 struct device_attribute *mattr,
77 const char *buf,
78 size_t len)
79{
80 unsigned long value;
81 struct ir_input_dev *ir_dev = dev_get_drvdata(d);
82 struct decoder_data *data = get_decoder_data(ir_dev);
83
84 if (!data)
85 return -EINVAL;
86
87 if (strict_strtoul(buf, 10, &value) || value > 1)
88 return -EINVAL;
89
90 data->enabled = value;
91
92 return len;
93}
94
95static ssize_t show_enabled(struct device *d,
96 struct device_attribute *mattr, char *buf)
97{
98 struct ir_input_dev *ir_dev = dev_get_drvdata(d);
99 struct decoder_data *data = get_decoder_data(ir_dev);
100
101 if (!data)
102 return -EINVAL;
103
104 if (data->enabled)
105 return sprintf(buf, "1\n");
106 else
107 return sprintf(buf, "0\n");
108}
109
110static DEVICE_ATTR(enabled, S_IRUGO | S_IWUSR, show_enabled, store_enabled);
111
112static struct attribute *decoder_attributes[] = {
113 &dev_attr_enabled.attr,
114 NULL
115};
116
117static struct attribute_group decoder_attribute_group = {
118 .name = "jvc_decoder",
119 .attrs = decoder_attributes,
120};
121
122/** 74/**
123 * ir_jvc_decode() - Decode one JVC pulse or space 75 * ir_jvc_decode() - Decode one JVC pulse or space
124 * @input_dev: the struct input_dev descriptor of the device 76 * @input_dev: the struct input_dev descriptor of the device
@@ -135,7 +87,7 @@ static int ir_jvc_decode(struct input_dev *input_dev, struct ir_raw_event ev)
135 if (!data) 87 if (!data)
136 return -EINVAL; 88 return -EINVAL;
137 89
138 if (!data->enabled) 90 if (!(ir_dev->raw->enabled_protocols & IR_TYPE_JVC))
139 return 0; 91 return 0;
140 92
141 if (IS_RESET(ev)) { 93 if (IS_RESET(ev)) {
@@ -253,22 +205,12 @@ static int ir_jvc_register(struct input_dev *input_dev)
253{ 205{
254 struct ir_input_dev *ir_dev = input_get_drvdata(input_dev); 206 struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
255 struct decoder_data *data; 207 struct decoder_data *data;
256 u64 ir_type = ir_dev->rc_tab.ir_type;
257 int rc;
258
259 rc = sysfs_create_group(&ir_dev->dev.kobj, &decoder_attribute_group);
260 if (rc < 0)
261 return rc;
262 208
263 data = kzalloc(sizeof(*data), GFP_KERNEL); 209 data = kzalloc(sizeof(*data), GFP_KERNEL);
264 if (!data) { 210 if (!data)
265 sysfs_remove_group(&ir_dev->dev.kobj, &decoder_attribute_group);
266 return -ENOMEM; 211 return -ENOMEM;
267 }
268 212
269 data->ir_dev = ir_dev; 213 data->ir_dev = ir_dev;
270 if (ir_type == IR_TYPE_JVC || ir_type == IR_TYPE_UNKNOWN)
271 data->enabled = 1;
272 214
273 spin_lock(&decoder_lock); 215 spin_lock(&decoder_lock);
274 list_add_tail(&data->list, &decoder_list); 216 list_add_tail(&data->list, &decoder_list);
@@ -286,8 +228,6 @@ static int ir_jvc_unregister(struct input_dev *input_dev)
286 if (!data) 228 if (!data)
287 return 0; 229 return 0;
288 230
289 sysfs_remove_group(&ir_dev->dev.kobj, &decoder_attribute_group);
290
291 spin_lock(&decoder_lock); 231 spin_lock(&decoder_lock);
292 list_del(&data->list); 232 list_del(&data->list);
293 spin_unlock(&decoder_lock); 233 spin_unlock(&decoder_lock);
@@ -296,6 +236,7 @@ static int ir_jvc_unregister(struct input_dev *input_dev)
296} 236}
297 237
298static struct ir_raw_handler jvc_handler = { 238static struct ir_raw_handler jvc_handler = {
239 .protocols = IR_TYPE_JVC,
299 .decode = ir_jvc_decode, 240 .decode = ir_jvc_decode,
300 .raw_register = ir_jvc_register, 241 .raw_register = ir_jvc_register,
301 .raw_unregister = ir_jvc_unregister, 242 .raw_unregister = ir_jvc_unregister,
diff --git a/drivers/media/IR/ir-nec-decoder.c b/drivers/media/IR/ir-nec-decoder.c
index 6059a1f1e15..db62c652dfc 100644
--- a/drivers/media/IR/ir-nec-decoder.c
+++ b/drivers/media/IR/ir-nec-decoder.c
@@ -43,7 +43,6 @@ enum nec_state {
43struct decoder_data { 43struct decoder_data {
44 struct list_head list; 44 struct list_head list;
45 struct ir_input_dev *ir_dev; 45 struct ir_input_dev *ir_dev;
46 int enabled:1;
47 46
48 /* State machine control */ 47 /* State machine control */
49 enum nec_state state; 48 enum nec_state state;
@@ -71,53 +70,6 @@ static struct decoder_data *get_decoder_data(struct ir_input_dev *ir_dev)
71 return data; 70 return data;
72} 71}
73 72
74static ssize_t store_enabled(struct device *d,
75 struct device_attribute *mattr,
76 const char *buf,
77 size_t len)
78{
79 unsigned long value;
80 struct ir_input_dev *ir_dev = dev_get_drvdata(d);
81 struct decoder_data *data = get_decoder_data(ir_dev);
82
83 if (!data)
84 return -EINVAL;
85
86 if (strict_strtoul(buf, 10, &value) || value > 1)
87 return -EINVAL;
88
89 data->enabled = value;
90
91 return len;
92}
93
94static ssize_t show_enabled(struct device *d,
95 struct device_attribute *mattr, char *buf)
96{
97 struct ir_input_dev *ir_dev = dev_get_drvdata(d);
98 struct decoder_data *data = get_decoder_data(ir_dev);
99
100 if (!data)
101 return -EINVAL;
102
103 if (data->enabled)
104 return sprintf(buf, "1\n");
105 else
106 return sprintf(buf, "0\n");
107}
108
109static DEVICE_ATTR(enabled, S_IRUGO | S_IWUSR, show_enabled, store_enabled);
110
111static struct attribute *decoder_attributes[] = {
112 &dev_attr_enabled.attr,
113 NULL
114};
115
116static struct attribute_group decoder_attribute_group = {
117 .name = "nec_decoder",
118 .attrs = decoder_attributes,
119};
120
121/** 73/**
122 * ir_nec_decode() - Decode one NEC pulse or space 74 * ir_nec_decode() - Decode one NEC pulse or space
123 * @input_dev: the struct input_dev descriptor of the device 75 * @input_dev: the struct input_dev descriptor of the device
@@ -136,7 +88,7 @@ static int ir_nec_decode(struct input_dev *input_dev, struct ir_raw_event ev)
136 if (!data) 88 if (!data)
137 return -EINVAL; 89 return -EINVAL;
138 90
139 if (!data->enabled) 91 if (!(ir_dev->raw->enabled_protocols & IR_TYPE_NEC))
140 return 0; 92 return 0;
141 93
142 if (IS_RESET(ev)) { 94 if (IS_RESET(ev)) {
@@ -260,22 +212,12 @@ static int ir_nec_register(struct input_dev *input_dev)
260{ 212{
261 struct ir_input_dev *ir_dev = input_get_drvdata(input_dev); 213 struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
262 struct decoder_data *data; 214 struct decoder_data *data;
263 u64 ir_type = ir_dev->rc_tab.ir_type;
264 int rc;
265
266 rc = sysfs_create_group(&ir_dev->dev.kobj, &decoder_attribute_group);
267 if (rc < 0)
268 return rc;
269 215
270 data = kzalloc(sizeof(*data), GFP_KERNEL); 216 data = kzalloc(sizeof(*data), GFP_KERNEL);
271 if (!data) { 217 if (!data)
272 sysfs_remove_group(&ir_dev->dev.kobj, &decoder_attribute_group);
273 return -ENOMEM; 218 return -ENOMEM;
274 }
275 219
276 data->ir_dev = ir_dev; 220 data->ir_dev = ir_dev;
277 if (ir_type == IR_TYPE_NEC || ir_type == IR_TYPE_UNKNOWN)
278 data->enabled = 1;
279 221
280 spin_lock(&decoder_lock); 222 spin_lock(&decoder_lock);
281 list_add_tail(&data->list, &decoder_list); 223 list_add_tail(&data->list, &decoder_list);
@@ -293,8 +235,6 @@ static int ir_nec_unregister(struct input_dev *input_dev)
293 if (!data) 235 if (!data)
294 return 0; 236 return 0;
295 237
296 sysfs_remove_group(&ir_dev->dev.kobj, &decoder_attribute_group);
297
298 spin_lock(&decoder_lock); 238 spin_lock(&decoder_lock);
299 list_del(&data->list); 239 list_del(&data->list);
300 spin_unlock(&decoder_lock); 240 spin_unlock(&decoder_lock);
@@ -303,6 +243,7 @@ static int ir_nec_unregister(struct input_dev *input_dev)
303} 243}
304 244
305static struct ir_raw_handler nec_handler = { 245static struct ir_raw_handler nec_handler = {
246 .protocols = IR_TYPE_NEC,
306 .decode = ir_nec_decode, 247 .decode = ir_nec_decode,
307 .raw_register = ir_nec_register, 248 .raw_register = ir_nec_register,
308 .raw_unregister = ir_nec_unregister, 249 .raw_unregister = ir_nec_unregister,
diff --git a/drivers/media/IR/ir-raw-event.c b/drivers/media/IR/ir-raw-event.c
index d3bd3f98e00..fb3336c3719 100644
--- a/drivers/media/IR/ir-raw-event.c
+++ b/drivers/media/IR/ir-raw-event.c
@@ -21,8 +21,9 @@
21#define MAX_IR_EVENT_SIZE 512 21#define MAX_IR_EVENT_SIZE 512
22 22
23/* Used to handle IR raw handler extensions */ 23/* Used to handle IR raw handler extensions */
24static LIST_HEAD(ir_raw_handler_list);
25static DEFINE_SPINLOCK(ir_raw_handler_lock); 24static DEFINE_SPINLOCK(ir_raw_handler_lock);
25static LIST_HEAD(ir_raw_handler_list);
26static u64 available_protocols;
26 27
27/** 28/**
28 * RUN_DECODER() - runs an operation on all IR decoders 29 * RUN_DECODER() - runs an operation on all IR decoders
@@ -64,52 +65,6 @@ static void ir_raw_event_work(struct work_struct *work)
64 RUN_DECODER(decode, raw->input_dev, ev); 65 RUN_DECODER(decode, raw->input_dev, ev);
65} 66}
66 67
67int ir_raw_event_register(struct input_dev *input_dev)
68{
69 struct ir_input_dev *ir = input_get_drvdata(input_dev);
70 int rc;
71
72 ir->raw = kzalloc(sizeof(*ir->raw), GFP_KERNEL);
73 if (!ir->raw)
74 return -ENOMEM;
75
76 ir->raw->input_dev = input_dev;
77 INIT_WORK(&ir->raw->rx_work, ir_raw_event_work);
78
79 rc = kfifo_alloc(&ir->raw->kfifo, sizeof(s64) * MAX_IR_EVENT_SIZE,
80 GFP_KERNEL);
81 if (rc < 0) {
82 kfree(ir->raw);
83 ir->raw = NULL;
84 return rc;
85 }
86
87 rc = RUN_DECODER(raw_register, input_dev);
88 if (rc < 0) {
89 kfifo_free(&ir->raw->kfifo);
90 kfree(ir->raw);
91 ir->raw = NULL;
92 return rc;
93 }
94
95 return rc;
96}
97
98void ir_raw_event_unregister(struct input_dev *input_dev)
99{
100 struct ir_input_dev *ir = input_get_drvdata(input_dev);
101
102 if (!ir->raw)
103 return;
104
105 cancel_work_sync(&ir->raw->rx_work);
106 RUN_DECODER(raw_unregister, input_dev);
107
108 kfifo_free(&ir->raw->kfifo);
109 kfree(ir->raw);
110 ir->raw = NULL;
111}
112
113/** 68/**
114 * ir_raw_event_store() - pass a pulse/space duration to the raw ir decoders 69 * ir_raw_event_store() - pass a pulse/space duration to the raw ir decoders
115 * @input_dev: the struct input_dev device descriptor 70 * @input_dev: the struct input_dev device descriptor
@@ -203,6 +158,66 @@ void ir_raw_event_handle(struct input_dev *input_dev)
203} 158}
204EXPORT_SYMBOL_GPL(ir_raw_event_handle); 159EXPORT_SYMBOL_GPL(ir_raw_event_handle);
205 160
161/* used internally by the sysfs interface */
162u64
163ir_raw_get_allowed_protocols()
164{
165 u64 protocols;
166 spin_lock(&ir_raw_handler_lock);
167 protocols = available_protocols;
168 spin_unlock(&ir_raw_handler_lock);
169 return protocols;
170}
171
172/*
173 * Used to (un)register raw event clients
174 */
175int ir_raw_event_register(struct input_dev *input_dev)
176{
177 struct ir_input_dev *ir = input_get_drvdata(input_dev);
178 int rc;
179
180 ir->raw = kzalloc(sizeof(*ir->raw), GFP_KERNEL);
181 if (!ir->raw)
182 return -ENOMEM;
183
184 ir->raw->input_dev = input_dev;
185 INIT_WORK(&ir->raw->rx_work, ir_raw_event_work);
186 ir->raw->enabled_protocols = ~0;
187 rc = kfifo_alloc(&ir->raw->kfifo, sizeof(s64) * MAX_IR_EVENT_SIZE,
188 GFP_KERNEL);
189 if (rc < 0) {
190 kfree(ir->raw);
191 ir->raw = NULL;
192 return rc;
193 }
194
195 rc = RUN_DECODER(raw_register, input_dev);
196 if (rc < 0) {
197 kfifo_free(&ir->raw->kfifo);
198 kfree(ir->raw);
199 ir->raw = NULL;
200 return rc;
201 }
202
203 return rc;
204}
205
206void ir_raw_event_unregister(struct input_dev *input_dev)
207{
208 struct ir_input_dev *ir = input_get_drvdata(input_dev);
209
210 if (!ir->raw)
211 return;
212
213 cancel_work_sync(&ir->raw->rx_work);
214 RUN_DECODER(raw_unregister, input_dev);
215
216 kfifo_free(&ir->raw->kfifo);
217 kfree(ir->raw);
218 ir->raw = NULL;
219}
220
206/* 221/*
207 * Extension interface - used to register the IR decoders 222 * Extension interface - used to register the IR decoders
208 */ 223 */
@@ -211,7 +226,9 @@ int ir_raw_handler_register(struct ir_raw_handler *ir_raw_handler)
211{ 226{
212 spin_lock(&ir_raw_handler_lock); 227 spin_lock(&ir_raw_handler_lock);
213 list_add_tail(&ir_raw_handler->list, &ir_raw_handler_list); 228 list_add_tail(&ir_raw_handler->list, &ir_raw_handler_list);
229 available_protocols |= ir_raw_handler->protocols;
214 spin_unlock(&ir_raw_handler_lock); 230 spin_unlock(&ir_raw_handler_lock);
231
215 return 0; 232 return 0;
216} 233}
217EXPORT_SYMBOL(ir_raw_handler_register); 234EXPORT_SYMBOL(ir_raw_handler_register);
@@ -220,6 +237,7 @@ void ir_raw_handler_unregister(struct ir_raw_handler *ir_raw_handler)
220{ 237{
221 spin_lock(&ir_raw_handler_lock); 238 spin_lock(&ir_raw_handler_lock);
222 list_del(&ir_raw_handler->list); 239 list_del(&ir_raw_handler->list);
240 available_protocols &= ~ir_raw_handler->protocols;
223 spin_unlock(&ir_raw_handler_lock); 241 spin_unlock(&ir_raw_handler_lock);
224} 242}
225EXPORT_SYMBOL(ir_raw_handler_unregister); 243EXPORT_SYMBOL(ir_raw_handler_unregister);
diff --git a/drivers/media/IR/ir-rc5-decoder.c b/drivers/media/IR/ir-rc5-decoder.c
index 4aa797bc69f..bdfa404a653 100644
--- a/drivers/media/IR/ir-rc5-decoder.c
+++ b/drivers/media/IR/ir-rc5-decoder.c
@@ -45,7 +45,6 @@ enum rc5_state {
45struct decoder_data { 45struct decoder_data {
46 struct list_head list; 46 struct list_head list;
47 struct ir_input_dev *ir_dev; 47 struct ir_input_dev *ir_dev;
48 int enabled:1;
49 48
50 /* State machine control */ 49 /* State machine control */
51 enum rc5_state state; 50 enum rc5_state state;
@@ -76,53 +75,6 @@ static struct decoder_data *get_decoder_data(struct ir_input_dev *ir_dev)
76 return data; 75 return data;
77} 76}
78 77
79static ssize_t store_enabled(struct device *d,
80 struct device_attribute *mattr,
81 const char *buf,
82 size_t len)
83{
84 unsigned long value;
85 struct ir_input_dev *ir_dev = dev_get_drvdata(d);
86 struct decoder_data *data = get_decoder_data(ir_dev);
87
88 if (!data)
89 return -EINVAL;
90
91 if (strict_strtoul(buf, 10, &value) || value > 1)
92 return -EINVAL;
93
94 data->enabled = value;
95
96 return len;
97}
98
99static ssize_t show_enabled(struct device *d,
100 struct device_attribute *mattr, char *buf)
101{
102 struct ir_input_dev *ir_dev = dev_get_drvdata(d);
103 struct decoder_data *data = get_decoder_data(ir_dev);
104
105 if (!data)
106 return -EINVAL;
107
108 if (data->enabled)
109 return sprintf(buf, "1\n");
110 else
111 return sprintf(buf, "0\n");
112}
113
114static DEVICE_ATTR(enabled, S_IRUGO | S_IWUSR, show_enabled, store_enabled);
115
116static struct attribute *decoder_attributes[] = {
117 &dev_attr_enabled.attr,
118 NULL
119};
120
121static struct attribute_group decoder_attribute_group = {
122 .name = "rc5_decoder",
123 .attrs = decoder_attributes,
124};
125
126/** 78/**
127 * ir_rc5_decode() - Decode one RC-5 pulse or space 79 * ir_rc5_decode() - Decode one RC-5 pulse or space
128 * @input_dev: the struct input_dev descriptor of the device 80 * @input_dev: the struct input_dev descriptor of the device
@@ -141,8 +93,8 @@ static int ir_rc5_decode(struct input_dev *input_dev, struct ir_raw_event ev)
141 if (!data) 93 if (!data)
142 return -EINVAL; 94 return -EINVAL;
143 95
144 if (!data->enabled) 96 if (!(ir_dev->raw->enabled_protocols & IR_TYPE_RC5))
145 return 0; 97 return 0;
146 98
147 if (IS_RESET(ev)) { 99 if (IS_RESET(ev)) {
148 data->state = STATE_INACTIVE; 100 data->state = STATE_INACTIVE;
@@ -256,22 +208,12 @@ static int ir_rc5_register(struct input_dev *input_dev)
256{ 208{
257 struct ir_input_dev *ir_dev = input_get_drvdata(input_dev); 209 struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
258 struct decoder_data *data; 210 struct decoder_data *data;
259 u64 ir_type = ir_dev->rc_tab.ir_type;
260 int rc;
261
262 rc = sysfs_create_group(&ir_dev->dev.kobj, &decoder_attribute_group);
263 if (rc < 0)
264 return rc;
265 211
266 data = kzalloc(sizeof(*data), GFP_KERNEL); 212 data = kzalloc(sizeof(*data), GFP_KERNEL);
267 if (!data) { 213 if (!data)
268 sysfs_remove_group(&ir_dev->dev.kobj, &decoder_attribute_group);
269 return -ENOMEM; 214 return -ENOMEM;
270 }
271 215
272 data->ir_dev = ir_dev; 216 data->ir_dev = ir_dev;
273 if (ir_type == IR_TYPE_RC5 || ir_type == IR_TYPE_UNKNOWN)
274 data->enabled = 1;
275 217
276 spin_lock(&decoder_lock); 218 spin_lock(&decoder_lock);
277 list_add_tail(&data->list, &decoder_list); 219 list_add_tail(&data->list, &decoder_list);
@@ -289,8 +231,6 @@ static int ir_rc5_unregister(struct input_dev *input_dev)
289 if (!data) 231 if (!data)
290 return 0; 232 return 0;
291 233
292 sysfs_remove_group(&ir_dev->dev.kobj, &decoder_attribute_group);
293
294 spin_lock(&decoder_lock); 234 spin_lock(&decoder_lock);
295 list_del(&data->list); 235 list_del(&data->list);
296 spin_unlock(&decoder_lock); 236 spin_unlock(&decoder_lock);
@@ -299,6 +239,7 @@ static int ir_rc5_unregister(struct input_dev *input_dev)
299} 239}
300 240
301static struct ir_raw_handler rc5_handler = { 241static struct ir_raw_handler rc5_handler = {
242 .protocols = IR_TYPE_RC5,
302 .decode = ir_rc5_decode, 243 .decode = ir_rc5_decode,
303 .raw_register = ir_rc5_register, 244 .raw_register = ir_rc5_register,
304 .raw_unregister = ir_rc5_unregister, 245 .raw_unregister = ir_rc5_unregister,
diff --git a/drivers/media/IR/ir-rc6-decoder.c b/drivers/media/IR/ir-rc6-decoder.c
index 9f61da29fac..2ebd4ea6953 100644
--- a/drivers/media/IR/ir-rc6-decoder.c
+++ b/drivers/media/IR/ir-rc6-decoder.c
@@ -61,7 +61,6 @@ enum rc6_state {
61struct decoder_data { 61struct decoder_data {
62 struct list_head list; 62 struct list_head list;
63 struct ir_input_dev *ir_dev; 63 struct ir_input_dev *ir_dev;
64 int enabled:1;
65 64
66 /* State machine control */ 65 /* State machine control */
67 enum rc6_state state; 66 enum rc6_state state;
@@ -93,53 +92,6 @@ static struct decoder_data *get_decoder_data(struct ir_input_dev *ir_dev)
93 return data; 92 return data;
94} 93}
95 94
96static ssize_t store_enabled(struct device *d,
97 struct device_attribute *mattr,
98 const char *buf,
99 size_t len)
100{
101 unsigned long value;
102 struct ir_input_dev *ir_dev = dev_get_drvdata(d);
103 struct decoder_data *data = get_decoder_data(ir_dev);
104
105 if (!data)
106 return -EINVAL;
107
108 if (strict_strtoul(buf, 10, &value) || value > 1)
109 return -EINVAL;
110
111 data->enabled = value;
112
113 return len;
114}
115
116static ssize_t show_enabled(struct device *d,
117 struct device_attribute *mattr, char *buf)
118{
119 struct ir_input_dev *ir_dev = dev_get_drvdata(d);
120 struct decoder_data *data = get_decoder_data(ir_dev);
121
122 if (!data)
123 return -EINVAL;
124
125 if (data->enabled)
126 return sprintf(buf, "1\n");
127 else
128 return sprintf(buf, "0\n");
129}
130
131static DEVICE_ATTR(enabled, S_IRUGO | S_IWUSR, show_enabled, store_enabled);
132
133static struct attribute *decoder_attributes[] = {
134 &dev_attr_enabled.attr,
135 NULL
136};
137
138static struct attribute_group decoder_attribute_group = {
139 .name = "rc6_decoder",
140 .attrs = decoder_attributes,
141};
142
143static enum rc6_mode rc6_mode(struct decoder_data *data) { 95static enum rc6_mode rc6_mode(struct decoder_data *data) {
144 switch (data->header & RC6_MODE_MASK) { 96 switch (data->header & RC6_MODE_MASK) {
145 case 0: 97 case 0:
@@ -171,7 +123,7 @@ static int ir_rc6_decode(struct input_dev *input_dev, struct ir_raw_event ev)
171 if (!data) 123 if (!data)
172 return -EINVAL; 124 return -EINVAL;
173 125
174 if (!data->enabled) 126 if (!(ir_dev->raw->enabled_protocols & IR_TYPE_RC6))
175 return 0; 127 return 0;
176 128
177 if (IS_RESET(ev)) { 129 if (IS_RESET(ev)) {
@@ -352,22 +304,12 @@ static int ir_rc6_register(struct input_dev *input_dev)
352{ 304{
353 struct ir_input_dev *ir_dev = input_get_drvdata(input_dev); 305 struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
354 struct decoder_data *data; 306 struct decoder_data *data;
355 u64 ir_type = ir_dev->rc_tab.ir_type;
356 int rc;
357
358 rc = sysfs_create_group(&ir_dev->dev.kobj, &decoder_attribute_group);
359 if (rc < 0)
360 return rc;
361 307
362 data = kzalloc(sizeof(*data), GFP_KERNEL); 308 data = kzalloc(sizeof(*data), GFP_KERNEL);
363 if (!data) { 309 if (!data)
364 sysfs_remove_group(&ir_dev->dev.kobj, &decoder_attribute_group);
365 return -ENOMEM; 310 return -ENOMEM;
366 }
367 311
368 data->ir_dev = ir_dev; 312 data->ir_dev = ir_dev;
369 if (ir_type == IR_TYPE_RC6 || ir_type == IR_TYPE_UNKNOWN)
370 data->enabled = 1;
371 313
372 spin_lock(&decoder_lock); 314 spin_lock(&decoder_lock);
373 list_add_tail(&data->list, &decoder_list); 315 list_add_tail(&data->list, &decoder_list);
@@ -385,8 +327,6 @@ static int ir_rc6_unregister(struct input_dev *input_dev)
385 if (!data) 327 if (!data)
386 return 0; 328 return 0;
387 329
388 sysfs_remove_group(&ir_dev->dev.kobj, &decoder_attribute_group);
389
390 spin_lock(&decoder_lock); 330 spin_lock(&decoder_lock);
391 list_del(&data->list); 331 list_del(&data->list);
392 spin_unlock(&decoder_lock); 332 spin_unlock(&decoder_lock);
@@ -395,6 +335,7 @@ static int ir_rc6_unregister(struct input_dev *input_dev)
395} 335}
396 336
397static struct ir_raw_handler rc6_handler = { 337static struct ir_raw_handler rc6_handler = {
338 .protocols = IR_TYPE_RC6,
398 .decode = ir_rc6_decode, 339 .decode = ir_rc6_decode,
399 .raw_register = ir_rc6_register, 340 .raw_register = ir_rc6_register,
400 .raw_unregister = ir_rc6_unregister, 341 .raw_unregister = ir_rc6_unregister,
diff --git a/drivers/media/IR/ir-sony-decoder.c b/drivers/media/IR/ir-sony-decoder.c
index 219075ffd6b..e15db333499 100644
--- a/drivers/media/IR/ir-sony-decoder.c
+++ b/drivers/media/IR/ir-sony-decoder.c
@@ -38,7 +38,6 @@ enum sony_state {
38struct decoder_data { 38struct decoder_data {
39 struct list_head list; 39 struct list_head list;
40 struct ir_input_dev *ir_dev; 40 struct ir_input_dev *ir_dev;
41 int enabled:1;
42 41
43 /* State machine control */ 42 /* State machine control */
44 enum sony_state state; 43 enum sony_state state;
@@ -66,53 +65,6 @@ static struct decoder_data *get_decoder_data(struct ir_input_dev *ir_dev)
66 return data; 65 return data;
67} 66}
68 67
69static ssize_t store_enabled(struct device *d,
70 struct device_attribute *mattr,
71 const char *buf,
72 size_t len)
73{
74 unsigned long value;
75 struct ir_input_dev *ir_dev = dev_get_drvdata(d);
76 struct decoder_data *data = get_decoder_data(ir_dev);
77
78 if (!data)
79 return -EINVAL;
80
81 if (strict_strtoul(buf, 10, &value) || value > 1)
82 return -EINVAL;
83
84 data->enabled = value;
85
86 return len;
87}
88
89static ssize_t show_enabled(struct device *d,
90 struct device_attribute *mattr, char *buf)
91{
92 struct ir_input_dev *ir_dev = dev_get_drvdata(d);
93 struct decoder_data *data = get_decoder_data(ir_dev);
94
95 if (!data)
96 return -EINVAL;
97
98 if (data->enabled)
99 return sprintf(buf, "1\n");
100 else
101 return sprintf(buf, "0\n");
102}
103
104static DEVICE_ATTR(enabled, S_IRUGO | S_IWUSR, show_enabled, store_enabled);
105
106static struct attribute *decoder_attributes[] = {
107 &dev_attr_enabled.attr,
108 NULL
109};
110
111static struct attribute_group decoder_attribute_group = {
112 .name = "sony_decoder",
113 .attrs = decoder_attributes,
114};
115
116/** 68/**
117 * ir_sony_decode() - Decode one Sony pulse or space 69 * ir_sony_decode() - Decode one Sony pulse or space
118 * @input_dev: the struct input_dev descriptor of the device 70 * @input_dev: the struct input_dev descriptor of the device
@@ -131,7 +83,7 @@ static int ir_sony_decode(struct input_dev *input_dev, struct ir_raw_event ev)
131 if (!data) 83 if (!data)
132 return -EINVAL; 84 return -EINVAL;
133 85
134 if (!data->enabled) 86 if (!(ir_dev->raw->enabled_protocols & IR_TYPE_SONY))
135 return 0; 87 return 0;
136 88
137 if (IS_RESET(ev)) { 89 if (IS_RESET(ev)) {
@@ -245,22 +197,12 @@ static int ir_sony_register(struct input_dev *input_dev)
245{ 197{
246 struct ir_input_dev *ir_dev = input_get_drvdata(input_dev); 198 struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
247 struct decoder_data *data; 199 struct decoder_data *data;
248 u64 ir_type = ir_dev->rc_tab.ir_type;
249 int rc;
250
251 rc = sysfs_create_group(&ir_dev->dev.kobj, &decoder_attribute_group);
252 if (rc < 0)
253 return rc;
254 200
255 data = kzalloc(sizeof(*data), GFP_KERNEL); 201 data = kzalloc(sizeof(*data), GFP_KERNEL);
256 if (!data) { 202 if (!data)
257 sysfs_remove_group(&ir_dev->dev.kobj, &decoder_attribute_group);
258 return -ENOMEM; 203 return -ENOMEM;
259 }
260 204
261 data->ir_dev = ir_dev; 205 data->ir_dev = ir_dev;
262 if (ir_type == IR_TYPE_SONY || ir_type == IR_TYPE_UNKNOWN)
263 data->enabled = 1;
264 206
265 spin_lock(&decoder_lock); 207 spin_lock(&decoder_lock);
266 list_add_tail(&data->list, &decoder_list); 208 list_add_tail(&data->list, &decoder_list);
@@ -278,8 +220,6 @@ static int ir_sony_unregister(struct input_dev *input_dev)
278 if (!data) 220 if (!data)
279 return 0; 221 return 0;
280 222
281 sysfs_remove_group(&ir_dev->dev.kobj, &decoder_attribute_group);
282
283 spin_lock(&decoder_lock); 223 spin_lock(&decoder_lock);
284 list_del(&data->list); 224 list_del(&data->list);
285 spin_unlock(&decoder_lock); 225 spin_unlock(&decoder_lock);
@@ -288,6 +228,7 @@ static int ir_sony_unregister(struct input_dev *input_dev)
288} 228}
289 229
290static struct ir_raw_handler sony_handler = { 230static struct ir_raw_handler sony_handler = {
231 .protocols = IR_TYPE_SONY,
291 .decode = ir_sony_decode, 232 .decode = ir_sony_decode,
292 .raw_register = ir_sony_register, 233 .raw_register = ir_sony_register,
293 .raw_unregister = ir_sony_unregister, 234 .raw_unregister = ir_sony_unregister,
diff --git a/drivers/media/IR/ir-sysfs.c b/drivers/media/IR/ir-sysfs.c
index 2098dd1488e..005621d067f 100644
--- a/drivers/media/IR/ir-sysfs.c
+++ b/drivers/media/IR/ir-sysfs.c
@@ -34,122 +34,178 @@ static struct class ir_input_class = {
34}; 34};
35 35
36/** 36/**
37 * show_protocol() - shows the current IR protocol 37 * show_protocols() - shows the current IR protocol(s)
38 * @d: the device descriptor 38 * @d: the device descriptor
39 * @mattr: the device attribute struct (unused) 39 * @mattr: the device attribute struct (unused)
40 * @buf: a pointer to the output buffer 40 * @buf: a pointer to the output buffer
41 * 41 *
42 * This routine is a callback routine for input read the IR protocol type. 42 * This routine is a callback routine for input read the IR protocol type(s).
43 * it is trigged by reading /sys/class/rc/rc?/current_protocol. 43 * it is trigged by reading /sys/class/rc/rc?/protocols.
44 * It returns the protocol name, as understood by the driver. 44 * It returns the protocol names of supported protocols.
45 * Enabled protocols are printed in brackets.
45 */ 46 */
46static ssize_t show_protocol(struct device *d, 47static ssize_t show_protocols(struct device *d,
47 struct device_attribute *mattr, char *buf) 48 struct device_attribute *mattr, char *buf)
48{ 49{
49 char *s;
50 struct ir_input_dev *ir_dev = dev_get_drvdata(d); 50 struct ir_input_dev *ir_dev = dev_get_drvdata(d);
51 u64 ir_type = ir_dev->rc_tab.ir_type; 51 u64 allowed, enabled;
52 52 char *tmp = buf;
53 IR_dprintk(1, "Current protocol is %lld\n", (long long)ir_type); 53
54 54 if (ir_dev->props->driver_type == RC_DRIVER_SCANCODE) {
55 /* FIXME: doesn't support multiple protocols at the same time */ 55 enabled = ir_dev->rc_tab.ir_type;
56 if (ir_type == IR_TYPE_UNKNOWN) 56 allowed = ir_dev->props->allowed_protos;
57 s = "Unknown"; 57 } else {
58 else if (ir_type == IR_TYPE_RC5) 58 enabled = ir_dev->raw->enabled_protocols;
59 s = "rc-5"; 59 allowed = ir_raw_get_allowed_protocols();
60 else if (ir_type == IR_TYPE_NEC) 60 }
61 s = "nec";
62 else if (ir_type == IR_TYPE_RC6)
63 s = "rc6";
64 else if (ir_type == IR_TYPE_JVC)
65 s = "jvc";
66 else if (ir_type == IR_TYPE_SONY)
67 s = "sony";
68 else
69 s = "other";
70 61
71 return sprintf(buf, "%s\n", s); 62 IR_dprintk(1, "allowed - 0x%llx, enabled - 0x%llx\n",
63 (long long)allowed,
64 (long long)enabled);
65
66 if (allowed & enabled & IR_TYPE_UNKNOWN)
67 tmp += sprintf(tmp, "[unknown] ");
68 else if (allowed & IR_TYPE_UNKNOWN)
69 tmp += sprintf(tmp, "unknown ");
70
71 if (allowed & enabled & IR_TYPE_RC5)
72 tmp += sprintf(tmp, "[rc5] ");
73 else if (allowed & IR_TYPE_RC5)
74 tmp += sprintf(tmp, "rc5 ");
75
76 if (allowed & enabled & IR_TYPE_NEC)
77 tmp += sprintf(tmp, "[nec] ");
78 else if (allowed & IR_TYPE_NEC)
79 tmp += sprintf(tmp, "nec ");
80
81 if (allowed & enabled & IR_TYPE_RC6)
82 tmp += sprintf(tmp, "[rc6] ");
83 else if (allowed & IR_TYPE_RC6)
84 tmp += sprintf(tmp, "rc6 ");
85
86 if (allowed & enabled & IR_TYPE_JVC)
87 tmp += sprintf(tmp, "[jvc] ");
88 else if (allowed & IR_TYPE_JVC)
89 tmp += sprintf(tmp, "jvc ");
90
91 if (allowed & enabled & IR_TYPE_SONY)
92 tmp += sprintf(tmp, "[sony] ");
93 else if (allowed & IR_TYPE_SONY)
94 tmp += sprintf(tmp, "sony ");
95
96 if (tmp != buf)
97 tmp--;
98 *tmp = '\n';
99 return tmp + 1 - buf;
72} 100}
73 101
74/** 102/**
75 * store_protocol() - shows the current IR protocol 103 * store_protocols() - changes the current IR protocol(s)
76 * @d: the device descriptor 104 * @d: the device descriptor
77 * @mattr: the device attribute struct (unused) 105 * @mattr: the device attribute struct (unused)
78 * @buf: a pointer to the input buffer 106 * @buf: a pointer to the input buffer
79 * @len: length of the input buffer 107 * @len: length of the input buffer
80 * 108 *
81 * This routine is a callback routine for changing the IR protocol type. 109 * This routine is a callback routine for changing the IR protocol type.
82 * it is trigged by reading /sys/class/rc/rc?/current_protocol. 110 * It is trigged by writing to /sys/class/rc/rc?/protocols.
83 * It changes the IR the protocol name, if the IR type is recognized 111 * Writing "+proto" will add a protocol to the list of enabled protocols.
84 * by the driver. 112 * Writing "-proto" will remove a protocol from the list of enabled protocols.
85 * If an unknown protocol name is used, returns -EINVAL. 113 * Writing "proto" will enable only "proto".
114 * Returns -EINVAL if an invalid protocol combination or unknown protocol name
115 * is used, otherwise @len.
86 */ 116 */
87static ssize_t store_protocol(struct device *d, 117static ssize_t store_protocols(struct device *d,
88 struct device_attribute *mattr, 118 struct device_attribute *mattr,
89 const char *data, 119 const char *data,
90 size_t len) 120 size_t len)
91{ 121{
92 struct ir_input_dev *ir_dev = dev_get_drvdata(d); 122 struct ir_input_dev *ir_dev = dev_get_drvdata(d);
93 u64 ir_type = 0; 123 bool enable, disable;
94 int rc = -EINVAL; 124 const char *tmp;
125 u64 type;
126 u64 mask;
127 int rc;
95 unsigned long flags; 128 unsigned long flags;
96 char *buf; 129
97 130 tmp = skip_spaces(data);
98 while ((buf = strsep((char **) &data, " \n")) != NULL) { 131
99 if (!strcasecmp(buf, "rc-5") || !strcasecmp(buf, "rc5")) 132 if (*tmp == '+') {
100 ir_type |= IR_TYPE_RC5; 133 enable = true;
101 if (!strcasecmp(buf, "nec")) 134 disable = false;
102 ir_type |= IR_TYPE_NEC; 135 tmp++;
103 if (!strcasecmp(buf, "jvc")) 136 } else if (*tmp == '-') {
104 ir_type |= IR_TYPE_JVC; 137 enable = false;
105 if (!strcasecmp(buf, "sony")) 138 disable = true;
106 ir_type |= IR_TYPE_SONY; 139 tmp++;
140 } else {
141 enable = false;
142 disable = false;
107 } 143 }
108 144
109 if (!ir_type) { 145 if (!strncasecmp(tmp, "unknown", 7)) {
146 tmp += 7;
147 mask = IR_TYPE_UNKNOWN;
148 } else if (!strncasecmp(tmp, "rc5", 3)) {
149 tmp += 3;
150 mask = IR_TYPE_RC5;
151 } else if (!strncasecmp(tmp, "nec", 3)) {
152 tmp += 3;
153 mask = IR_TYPE_NEC;
154 } else if (!strncasecmp(tmp, "rc6", 3)) {
155 tmp += 3;
156 mask = IR_TYPE_RC6;
157 } else if (!strncasecmp(tmp, "jvc", 3)) {
158 tmp += 3;
159 mask = IR_TYPE_JVC;
160 } else if (!strncasecmp(tmp, "sony", 4)) {
161 tmp += 4;
162 mask = IR_TYPE_SONY;
163 } else {
110 IR_dprintk(1, "Unknown protocol\n"); 164 IR_dprintk(1, "Unknown protocol\n");
111 return -EINVAL; 165 return -EINVAL;
112 } 166 }
113 167
114 if (ir_dev->props && ir_dev->props->change_protocol) 168 tmp = skip_spaces(tmp);
115 rc = ir_dev->props->change_protocol(ir_dev->props->priv, 169 if (*tmp != '\0') {
116 ir_type); 170 IR_dprintk(1, "Invalid trailing characters\n");
117
118 if (rc < 0) {
119 IR_dprintk(1, "Error setting protocol to %lld\n",
120 (long long)ir_type);
121 return -EINVAL; 171 return -EINVAL;
122 } 172 }
123 173
124 spin_lock_irqsave(&ir_dev->rc_tab.lock, flags); 174 if (ir_dev->props->driver_type == RC_DRIVER_SCANCODE)
125 ir_dev->rc_tab.ir_type = ir_type; 175 type = ir_dev->rc_tab.ir_type;
126 spin_unlock_irqrestore(&ir_dev->rc_tab.lock, flags); 176 else
177 type = ir_dev->raw->enabled_protocols;
127 178
128 IR_dprintk(1, "Current protocol(s) is(are) %lld\n", 179 if (enable)
129 (long long)ir_type); 180 type |= mask;
181 else if (disable)
182 type &= ~mask;
183 else
184 type = mask;
130 185
131 return len; 186 if (ir_dev->props && ir_dev->props->change_protocol) {
132} 187 rc = ir_dev->props->change_protocol(ir_dev->props->priv,
188 type);
189 if (rc < 0) {
190 IR_dprintk(1, "Error setting protocols to 0x%llx\n",
191 (long long)type);
192 return -EINVAL;
193 }
194 }
133 195
134static ssize_t show_supported_protocols(struct device *d, 196 if (ir_dev->props->driver_type == RC_DRIVER_SCANCODE) {
135 struct device_attribute *mattr, char *buf) 197 spin_lock_irqsave(&ir_dev->rc_tab.lock, flags);
136{ 198 ir_dev->rc_tab.ir_type = type;
137 char *orgbuf = buf; 199 spin_unlock_irqrestore(&ir_dev->rc_tab.lock, flags);
138 struct ir_input_dev *ir_dev = dev_get_drvdata(d); 200 } else {
201 ir_dev->raw->enabled_protocols = type;
202 }
139 203
140 /* FIXME: doesn't support multiple protocols at the same time */
141 if (ir_dev->props->allowed_protos == IR_TYPE_UNKNOWN)
142 buf += sprintf(buf, "unknown ");
143 if (ir_dev->props->allowed_protos & IR_TYPE_RC5)
144 buf += sprintf(buf, "rc-5 ");
145 if (ir_dev->props->allowed_protos & IR_TYPE_NEC)
146 buf += sprintf(buf, "nec ");
147 if (buf == orgbuf)
148 buf += sprintf(buf, "other ");
149 204
150 buf += sprintf(buf - 1, "\n"); 205 IR_dprintk(1, "Current protocol(s): 0x%llx\n",
206 (long long)type);
151 207
152 return buf - orgbuf; 208 return len;
153} 209}
154 210
155#define ADD_HOTPLUG_VAR(fmt, val...) \ 211#define ADD_HOTPLUG_VAR(fmt, val...) \
@@ -159,7 +215,7 @@ static ssize_t show_supported_protocols(struct device *d,
159 return err; \ 215 return err; \
160 } while (0) 216 } while (0)
161 217
162static int ir_dev_uevent(struct device *device, struct kobj_uevent_env *env) 218static int rc_dev_uevent(struct device *device, struct kobj_uevent_env *env)
163{ 219{
164 struct ir_input_dev *ir_dev = dev_get_drvdata(device); 220 struct ir_input_dev *ir_dev = dev_get_drvdata(device);
165 221
@@ -174,34 +230,26 @@ static int ir_dev_uevent(struct device *device, struct kobj_uevent_env *env)
174/* 230/*
175 * Static device attribute struct with the sysfs attributes for IR's 231 * Static device attribute struct with the sysfs attributes for IR's
176 */ 232 */
177static DEVICE_ATTR(protocol, S_IRUGO | S_IWUSR, 233static DEVICE_ATTR(protocols, S_IRUGO | S_IWUSR,
178 show_protocol, store_protocol); 234 show_protocols, store_protocols);
179
180static DEVICE_ATTR(supported_protocols, S_IRUGO | S_IWUSR,
181 show_supported_protocols, NULL);
182 235
183static struct attribute *ir_hw_dev_attrs[] = { 236static struct attribute *rc_dev_attrs[] = {
184 &dev_attr_protocol.attr, 237 &dev_attr_protocols.attr,
185 &dev_attr_supported_protocols.attr,
186 NULL, 238 NULL,
187}; 239};
188 240
189static struct attribute_group ir_hw_dev_attr_grp = { 241static struct attribute_group rc_dev_attr_grp = {
190 .attrs = ir_hw_dev_attrs, 242 .attrs = rc_dev_attrs,
191}; 243};
192 244
193static const struct attribute_group *ir_hw_dev_attr_groups[] = { 245static const struct attribute_group *rc_dev_attr_groups[] = {
194 &ir_hw_dev_attr_grp, 246 &rc_dev_attr_grp,
195 NULL 247 NULL
196}; 248};
197 249
198static struct device_type rc_dev_type = { 250static struct device_type rc_dev_type = {
199 .groups = ir_hw_dev_attr_groups, 251 .groups = rc_dev_attr_groups,
200 .uevent = ir_dev_uevent, 252 .uevent = rc_dev_uevent,
201};
202
203static struct device_type ir_raw_dev_type = {
204 .uevent = ir_dev_uevent,
205}; 253};
206 254
207/** 255/**
@@ -221,11 +269,7 @@ int ir_register_class(struct input_dev *input_dev)
221 if (unlikely(devno < 0)) 269 if (unlikely(devno < 0))
222 return devno; 270 return devno;
223 271
224 if (ir_dev->props) { 272 ir_dev->dev.type = &rc_dev_type;
225 if (ir_dev->props->driver_type == RC_DRIVER_SCANCODE)
226 ir_dev->dev.type = &rc_dev_type;
227 } else
228 ir_dev->dev.type = &ir_raw_dev_type;
229 273
230 ir_dev->dev.class = &ir_input_class; 274 ir_dev->dev.class = &ir_input_class;
231 ir_dev->dev.parent = input_dev->dev.parent; 275 ir_dev->dev.parent = input_dev->dev.parent;
generated by cgit v1.2.2 (git 2.25.0) at 2024-10-22 02:42:29 -0400