This source file includes following definitions.
- loop_set_tx_mask
- loop_set_tx_carrier
- loop_set_tx_duty_cycle
- loop_set_rx_carrier_range
- loop_tx_ir
- loop_set_idle
- loop_set_learning_mode
- loop_set_carrier_report
- loop_set_wakeup_filter
- loop_init
- loop_exit
1
2
3
4
5
6
7
8
9
10
11
12 #include <linux/device.h>
13 #include <linux/module.h>
14 #include <linux/sched.h>
15 #include <linux/slab.h>
16 #include <media/rc-core.h>
17
18 #define DRIVER_NAME "rc-loopback"
19 #define dprintk(x...) if (debug) printk(KERN_INFO DRIVER_NAME ": " x)
20 #define RXMASK_REGULAR 0x1
21 #define RXMASK_LEARNING 0x2
22
23 static bool debug;
24
25 struct loopback_dev {
26 struct rc_dev *dev;
27 u32 txmask;
28 u32 txcarrier;
29 u32 txduty;
30 bool idle;
31 bool learning;
32 bool carrierreport;
33 u32 rxcarriermin;
34 u32 rxcarriermax;
35 };
36
37 static struct loopback_dev loopdev;
38
39 static int loop_set_tx_mask(struct rc_dev *dev, u32 mask)
40 {
41 struct loopback_dev *lodev = dev->priv;
42
43 if ((mask & (RXMASK_REGULAR | RXMASK_LEARNING)) != mask) {
44 dprintk("invalid tx mask: %u\n", mask);
45 return -EINVAL;
46 }
47
48 dprintk("setting tx mask: %u\n", mask);
49 lodev->txmask = mask;
50 return 0;
51 }
52
53 static int loop_set_tx_carrier(struct rc_dev *dev, u32 carrier)
54 {
55 struct loopback_dev *lodev = dev->priv;
56
57 dprintk("setting tx carrier: %u\n", carrier);
58 lodev->txcarrier = carrier;
59 return 0;
60 }
61
62 static int loop_set_tx_duty_cycle(struct rc_dev *dev, u32 duty_cycle)
63 {
64 struct loopback_dev *lodev = dev->priv;
65
66 if (duty_cycle < 1 || duty_cycle > 99) {
67 dprintk("invalid duty cycle: %u\n", duty_cycle);
68 return -EINVAL;
69 }
70
71 dprintk("setting duty cycle: %u\n", duty_cycle);
72 lodev->txduty = duty_cycle;
73 return 0;
74 }
75
76 static int loop_set_rx_carrier_range(struct rc_dev *dev, u32 min, u32 max)
77 {
78 struct loopback_dev *lodev = dev->priv;
79
80 if (min < 1 || min > max) {
81 dprintk("invalid rx carrier range %u to %u\n", min, max);
82 return -EINVAL;
83 }
84
85 dprintk("setting rx carrier range %u to %u\n", min, max);
86 lodev->rxcarriermin = min;
87 lodev->rxcarriermax = max;
88 return 0;
89 }
90
91 static int loop_tx_ir(struct rc_dev *dev, unsigned *txbuf, unsigned count)
92 {
93 struct loopback_dev *lodev = dev->priv;
94 u32 rxmask;
95 unsigned i;
96 struct ir_raw_event rawir = {};
97
98 if (lodev->txcarrier < lodev->rxcarriermin ||
99 lodev->txcarrier > lodev->rxcarriermax) {
100 dprintk("ignoring tx, carrier out of range\n");
101 goto out;
102 }
103
104 if (lodev->learning)
105 rxmask = RXMASK_LEARNING;
106 else
107 rxmask = RXMASK_REGULAR;
108
109 if (!(rxmask & lodev->txmask)) {
110 dprintk("ignoring tx, rx mask mismatch\n");
111 goto out;
112 }
113
114 for (i = 0; i < count; i++) {
115 rawir.pulse = i % 2 ? false : true;
116 rawir.duration = txbuf[i] * 1000;
117 if (rawir.duration)
118 ir_raw_event_store_with_filter(dev, &rawir);
119 }
120
121
122 rawir.pulse = false;
123 rawir.duration = dev->timeout;
124 ir_raw_event_store_with_filter(dev, &rawir);
125
126 ir_raw_event_handle(dev);
127
128 out:
129 return count;
130 }
131
132 static void loop_set_idle(struct rc_dev *dev, bool enable)
133 {
134 struct loopback_dev *lodev = dev->priv;
135
136 if (lodev->idle != enable) {
137 dprintk("%sing idle mode\n", enable ? "enter" : "exit");
138 lodev->idle = enable;
139 }
140 }
141
142 static int loop_set_learning_mode(struct rc_dev *dev, int enable)
143 {
144 struct loopback_dev *lodev = dev->priv;
145
146 if (lodev->learning != enable) {
147 dprintk("%sing learning mode\n", enable ? "enter" : "exit");
148 lodev->learning = !!enable;
149 }
150
151 return 0;
152 }
153
154 static int loop_set_carrier_report(struct rc_dev *dev, int enable)
155 {
156 struct loopback_dev *lodev = dev->priv;
157
158 if (lodev->carrierreport != enable) {
159 dprintk("%sabling carrier reports\n", enable ? "en" : "dis");
160 lodev->carrierreport = !!enable;
161 }
162
163 return 0;
164 }
165
166 static int loop_set_wakeup_filter(struct rc_dev *dev,
167 struct rc_scancode_filter *sc)
168 {
169 static const unsigned int max = 512;
170 struct ir_raw_event *raw;
171 int ret;
172 int i;
173
174
175 if (!sc->mask)
176 return 0;
177
178
179 raw = kmalloc_array(max, sizeof(*raw), GFP_KERNEL);
180 if (!raw)
181 return -ENOMEM;
182
183 ret = ir_raw_encode_scancode(dev->wakeup_protocol, sc->data, raw, max);
184
185 if (ret == -ENOBUFS)
186 ret = max;
187 if (ret >= 0) {
188
189 for (i = 0; i < ret; ++i)
190 ir_raw_event_store(dev, &raw[i]);
191 ir_raw_event_handle(dev);
192
193 ret = 0;
194 }
195
196 kfree(raw);
197
198 return ret;
199 }
200
201 static int __init loop_init(void)
202 {
203 struct rc_dev *rc;
204 int ret;
205
206 rc = rc_allocate_device(RC_DRIVER_IR_RAW);
207 if (!rc) {
208 printk(KERN_ERR DRIVER_NAME ": rc_dev allocation failed\n");
209 return -ENOMEM;
210 }
211
212 rc->device_name = "rc-core loopback device";
213 rc->input_phys = "rc-core/virtual";
214 rc->input_id.bustype = BUS_VIRTUAL;
215 rc->input_id.version = 1;
216 rc->driver_name = DRIVER_NAME;
217 rc->map_name = RC_MAP_EMPTY;
218 rc->priv = &loopdev;
219 rc->allowed_protocols = RC_PROTO_BIT_ALL_IR_DECODER;
220 rc->allowed_wakeup_protocols = RC_PROTO_BIT_ALL_IR_ENCODER;
221 rc->encode_wakeup = true;
222 rc->timeout = 100 * 1000 * 1000;
223 rc->min_timeout = 1;
224 rc->max_timeout = UINT_MAX;
225 rc->rx_resolution = 1000;
226 rc->tx_resolution = 1000;
227 rc->s_tx_mask = loop_set_tx_mask;
228 rc->s_tx_carrier = loop_set_tx_carrier;
229 rc->s_tx_duty_cycle = loop_set_tx_duty_cycle;
230 rc->s_rx_carrier_range = loop_set_rx_carrier_range;
231 rc->tx_ir = loop_tx_ir;
232 rc->s_idle = loop_set_idle;
233 rc->s_learning_mode = loop_set_learning_mode;
234 rc->s_carrier_report = loop_set_carrier_report;
235 rc->s_wakeup_filter = loop_set_wakeup_filter;
236
237 loopdev.txmask = RXMASK_REGULAR;
238 loopdev.txcarrier = 36000;
239 loopdev.txduty = 50;
240 loopdev.rxcarriermin = 1;
241 loopdev.rxcarriermax = ~0;
242 loopdev.idle = true;
243 loopdev.learning = false;
244 loopdev.carrierreport = false;
245
246 ret = rc_register_device(rc);
247 if (ret < 0) {
248 printk(KERN_ERR DRIVER_NAME ": rc_dev registration failed\n");
249 rc_free_device(rc);
250 return ret;
251 }
252
253 loopdev.dev = rc;
254 return 0;
255 }
256
257 static void __exit loop_exit(void)
258 {
259 rc_unregister_device(loopdev.dev);
260 }
261
262 module_init(loop_init);
263 module_exit(loop_exit);
264
265 module_param(debug, bool, S_IRUGO | S_IWUSR);
266 MODULE_PARM_DESC(debug, "Enable debug messages");
267
268 MODULE_DESCRIPTION("Loopback device for rc-core debugging");
269 MODULE_AUTHOR("David Härdeman <david@hardeman.nu>");
270 MODULE_LICENSE("GPL");