cc846b2619cf38bb6f77d2a35ad8d2167dfc5bf1
[linux-2.6.git] / drivers / media / rc / rc-loopback.c
1 /*
2  * Loopback driver for rc-core,
3  *
4  * Copyright (c) 2010 David Härdeman <david@hardeman.nu>
5  *
6  * This driver receives TX data and passes it back as RX data,
7  * which is useful for (scripted) debugging of rc-core without
8  * having to use actual hardware.
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
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
36 static bool debug;
37
38 struct 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
50 static struct loopback_dev loopdev;
51
52 static 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
66 static 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
75 static 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
89 static 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
104 static int loop_tx_ir(struct rc_dev *dev, int *txbuf, u32 n)
105 {
106         struct loopback_dev *lodev = dev->priv;
107         u32 rxmask;
108         unsigned count;
109         unsigned total_duration = 0;
110         unsigned i;
111         DEFINE_IR_RAW_EVENT(rawir);
112
113         if (n == 0 || n % sizeof(int)) {
114                 dprintk("invalid tx buffer size\n");
115                 return -EINVAL;
116         }
117
118         count = n / sizeof(int);
119         for (i = 0; i < count; i++)
120                 total_duration += abs(txbuf[i]);
121
122         if (total_duration == 0) {
123                 dprintk("invalid tx data, total duration zero\n");
124                 return -EINVAL;
125         }
126
127         if (lodev->txcarrier < lodev->rxcarriermin ||
128             lodev->txcarrier > lodev->rxcarriermax) {
129                 dprintk("ignoring tx, carrier out of range\n");
130                 goto out;
131         }
132
133         if (lodev->learning)
134                 rxmask = RXMASK_LEARNING;
135         else
136                 rxmask = RXMASK_REGULAR;
137
138         if (!(rxmask & lodev->txmask)) {
139                 dprintk("ignoring tx, rx mask mismatch\n");
140                 goto out;
141         }
142
143         for (i = 0; i < count; i++) {
144                 rawir.pulse = i % 2 ? false : true;
145                 rawir.duration = abs(txbuf[i]) * 1000;
146                 if (rawir.duration)
147                         ir_raw_event_store_with_filter(dev, &rawir);
148         }
149
150         /* Fake a silence long enough to cause us to go idle */
151         rawir.pulse = false;
152         rawir.duration = dev->timeout;
153         ir_raw_event_store_with_filter(dev, &rawir);
154
155         ir_raw_event_handle(dev);
156
157 out:
158         /* Lirc expects this function to take as long as the total duration */
159         set_current_state(TASK_INTERRUPTIBLE);
160         schedule_timeout(usecs_to_jiffies(total_duration));
161         return n;
162 }
163
164 static void loop_set_idle(struct rc_dev *dev, bool enable)
165 {
166         struct loopback_dev *lodev = dev->priv;
167
168         if (lodev->idle != enable) {
169                 dprintk("%sing idle mode\n", enable ? "enter" : "exit");
170                 lodev->idle = enable;
171         }
172 }
173
174 static int loop_set_learning_mode(struct rc_dev *dev, int enable)
175 {
176         struct loopback_dev *lodev = dev->priv;
177
178         if (lodev->learning != enable) {
179                 dprintk("%sing learning mode\n", enable ? "enter" : "exit");
180                 lodev->learning = !!enable;
181         }
182
183         return 0;
184 }
185
186 static int loop_set_carrier_report(struct rc_dev *dev, int enable)
187 {
188         struct loopback_dev *lodev = dev->priv;
189
190         if (lodev->carrierreport != enable) {
191                 dprintk("%sabling carrier reports\n", enable ? "en" : "dis");
192                 lodev->carrierreport = !!enable;
193         }
194
195         return 0;
196 }
197
198 static int __init loop_init(void)
199 {
200         struct rc_dev *rc;
201         int ret;
202
203         rc = rc_allocate_device();
204         if (!rc) {
205                 printk(KERN_ERR DRIVER_NAME ": rc_dev allocation failed\n");
206                 return -ENOMEM;
207         }
208
209         rc->input_name          = "rc-core loopback device";
210         rc->input_phys          = "rc-core/virtual";
211         rc->input_id.bustype    = BUS_VIRTUAL;
212         rc->input_id.version    = 1;
213         rc->driver_name         = DRIVER_NAME;
214         rc->map_name            = RC_MAP_EMPTY;
215         rc->priv                = &loopdev;
216         rc->driver_type         = RC_DRIVER_IR_RAW;
217         rc->allowed_protos      = RC_TYPE_ALL;
218         rc->timeout             = 100 * 1000 * 1000; /* 100 ms */
219         rc->min_timeout         = 1;
220         rc->max_timeout         = UINT_MAX;
221         rc->rx_resolution       = 1000;
222         rc->tx_resolution       = 1000;
223         rc->s_tx_mask           = loop_set_tx_mask;
224         rc->s_tx_carrier        = loop_set_tx_carrier;
225         rc->s_tx_duty_cycle     = loop_set_tx_duty_cycle;
226         rc->s_rx_carrier_range  = loop_set_rx_carrier_range;
227         rc->tx_ir               = loop_tx_ir;
228         rc->s_idle              = loop_set_idle;
229         rc->s_learning_mode     = loop_set_learning_mode;
230         rc->s_carrier_report    = loop_set_carrier_report;
231         rc->priv                = &loopdev;
232
233         loopdev.txmask          = RXMASK_REGULAR;
234         loopdev.txcarrier       = 36000;
235         loopdev.txduty          = 50;
236         loopdev.rxcarriermin    = 1;
237         loopdev.rxcarriermax    = ~0;
238         loopdev.idle            = true;
239         loopdev.learning        = false;
240         loopdev.carrierreport   = false;
241
242         ret = rc_register_device(rc);
243         if (ret < 0) {
244                 printk(KERN_ERR DRIVER_NAME ": rc_dev registration failed\n");
245                 rc_free_device(rc);
246                 return ret;
247         }
248
249         loopdev.dev = rc;
250         return 0;
251 }
252
253 static void __exit loop_exit(void)
254 {
255         rc_unregister_device(loopdev.dev);
256 }
257
258 module_init(loop_init);
259 module_exit(loop_exit);
260
261 module_param(debug, bool, S_IRUGO | S_IWUSR);
262 MODULE_PARM_DESC(debug, "Enable debug messages");
263
264 MODULE_DESCRIPTION("Loopback device for rc-core debugging");
265 MODULE_AUTHOR("David Härdeman <david@hardeman.nu>");
266 MODULE_LICENSE("GPL");