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");