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