media/rc/rc-loopback.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Loopback driver for rc-core,
0004  *
0005  * Copyright (c) 2010 David Härdeman <david@hardeman.nu>
0006  *
0007  * This driver receives TX data and passes it back as RX data,
0008  * which is useful for (scripted) debugging of rc-core without
0009  * having to use actual hardware.
0010  */
0011
0012 #include <linux/device.h>
0013 #include <linux/module.h>
0014 #include <linux/sched.h>
0015 #include <linux/slab.h>
0016 #include <media/rc-core.h>
0017
0018 #define DRIVER_NAME     "rc-loopback"
0019 #define RXMASK_NARROWBAND   0x1
0020 #define RXMASK_WIDEBAND     0x2
0021
0022 struct loopback_dev {
0023     struct rc_dev *dev;
0024     u32 txmask;
0025     u32 txcarrier;
0026     u32 txduty;
0027     bool idle;
0028     bool wideband;
0029     bool carrierreport;
0030     u32 rxcarriermin;
0031     u32 rxcarriermax;
0032 };
0033
0034 static struct loopback_dev loopdev;
0035
0036 static int loop_set_tx_mask(struct rc_dev *dev, u32 mask)
0037 {
0038     struct loopback_dev *lodev = dev->priv;
0039
0040     if ((mask & (RXMASK_NARROWBAND | RXMASK_WIDEBAND)) != mask) {
0041         dev_dbg(&dev->dev, "invalid tx mask: %u\n", mask);
0042         return 2;
0043     }
0044
0045     dev_dbg(&dev->dev, "setting tx mask: %u\n", mask);
0046     lodev->txmask = mask;
0047     return 0;
0048 }
0049
0050 static int loop_set_tx_carrier(struct rc_dev *dev, u32 carrier)
0051 {
0052     struct loopback_dev *lodev = dev->priv;
0053
0054     dev_dbg(&dev->dev, "setting tx carrier: %u\n", carrier);
0055     lodev->txcarrier = carrier;
0056     return 0;
0057 }
0058
0059 static int loop_set_tx_duty_cycle(struct rc_dev *dev, u32 duty_cycle)
0060 {
0061     struct loopback_dev *lodev = dev->priv;
0062
0063     if (duty_cycle < 1 || duty_cycle > 99) {
0064         dev_dbg(&dev->dev, "invalid duty cycle: %u\n", duty_cycle);
0065         return -EINVAL;
0066     }
0067
0068     dev_dbg(&dev->dev, "setting duty cycle: %u\n", duty_cycle);
0069     lodev->txduty = duty_cycle;
0070     return 0;
0071 }
0072
0073 static int loop_set_rx_carrier_range(struct rc_dev *dev, u32 min, u32 max)
0074 {
0075     struct loopback_dev *lodev = dev->priv;
0076
0077     if (min < 1 || min > max) {
0078         dev_dbg(&dev->dev, "invalid rx carrier range %u to %u\n", min, max);
0079         return -EINVAL;
0080     }
0081
0082     dev_dbg(&dev->dev, "setting rx carrier range %u to %u\n", min, max);
0083     lodev->rxcarriermin = min;
0084     lodev->rxcarriermax = max;
0085     return 0;
0086 }
0087
0088 static int loop_tx_ir(struct rc_dev *dev, unsigned *txbuf, unsigned count)
0089 {
0090     struct loopback_dev *lodev = dev->priv;
0091     u32 rxmask;
0092     unsigned i;
0093     struct ir_raw_event rawir = {};
0094
0095     if (lodev->txcarrier < lodev->rxcarriermin ||
0096         lodev->txcarrier > lodev->rxcarriermax) {
0097         dev_dbg(&dev->dev, "ignoring tx, carrier out of range\n");
0098         goto out;
0099     }
0100
0101     if (lodev->wideband)
0102         rxmask = RXMASK_WIDEBAND;
0103     else
0104         rxmask = RXMASK_NARROWBAND;
0105
0106     if (!(rxmask & lodev->txmask)) {
0107         dev_dbg(&dev->dev, "ignoring tx, rx mask mismatch\n");
0108         goto out;
0109     }
0110
0111     for (i = 0; i < count; i++) {
0112         rawir.pulse = i % 2 ? false : true;
0113         rawir.duration = txbuf[i];
0114
0115         /* simulate overflow if ridiculously long pulse was sent */
0116         if (rawir.pulse && rawir.duration > MS_TO_US(50))
0117             ir_raw_event_overflow(dev);
0118         else
0119             ir_raw_event_store_with_filter(dev, &rawir);
0120     }
0121
0122     if (lodev->carrierreport) {
0123         rawir.pulse = false;
0124         rawir.carrier_report = true;
0125         rawir.carrier = lodev->txcarrier;
0126
0127         ir_raw_event_store(dev, &rawir);
0128     }
0129
0130     /* Fake a silence long enough to cause us to go idle */
0131     rawir.pulse = false;
0132     rawir.duration = dev->timeout;
0133     ir_raw_event_store_with_filter(dev, &rawir);
0134
0135     ir_raw_event_handle(dev);
0136
0137 out:
0138     return count;
0139 }
0140
0141 static void loop_set_idle(struct rc_dev *dev, bool enable)
0142 {
0143     struct loopback_dev *lodev = dev->priv;
0144
0145     if (lodev->idle != enable) {
0146         dev_dbg(&dev->dev, "%sing idle mode\n", enable ? "enter" : "exit");
0147         lodev->idle = enable;
0148     }
0149 }
0150
0151 static int loop_set_wideband_receiver(struct rc_dev *dev, int enable)
0152 {
0153     struct loopback_dev *lodev = dev->priv;
0154
0155     if (lodev->wideband != enable) {
0156         dev_dbg(&dev->dev, "using %sband receiver\n", enable ? "wide" : "narrow");
0157         lodev->wideband = !!enable;
0158     }
0159
0160     return 0;
0161 }
0162
0163 static int loop_set_carrier_report(struct rc_dev *dev, int enable)
0164 {
0165     struct loopback_dev *lodev = dev->priv;
0166
0167     if (lodev->carrierreport != enable) {
0168         dev_dbg(&dev->dev, "%sabling carrier reports\n", enable ? "en" : "dis");
0169         lodev->carrierreport = !!enable;
0170     }
0171
0172     return 0;
0173 }
0174
0175 static int loop_set_wakeup_filter(struct rc_dev *dev,
0176                   struct rc_scancode_filter *sc)
0177 {
0178     static const unsigned int max = 512;
0179     struct ir_raw_event *raw;
0180     int ret;
0181     int i;
0182
0183     /* fine to disable filter */
0184     if (!sc->mask)
0185         return 0;
0186
0187     /* encode the specified filter and loop it back */
0188     raw = kmalloc_array(max, sizeof(*raw), GFP_KERNEL);
0189     if (!raw)
0190         return -ENOMEM;
0191
0192     ret = ir_raw_encode_scancode(dev->wakeup_protocol, sc->data, raw, max);
0193     /* still loop back the partial raw IR even if it's incomplete */
0194     if (ret == -ENOBUFS)
0195         ret = max;
0196     if (ret >= 0) {
0197         /* do the loopback */
0198         for (i = 0; i < ret; ++i)
0199             ir_raw_event_store(dev, &raw[i]);
0200         ir_raw_event_handle(dev);
0201
0202         ret = 0;
0203     }
0204
0205     kfree(raw);
0206
0207     return ret;
0208 }
0209
0210 static int __init loop_init(void)
0211 {
0212     struct rc_dev *rc;
0213     int ret;
0214
0215     rc = rc_allocate_device(RC_DRIVER_IR_RAW);
0216     if (!rc)
0217         return -ENOMEM;
0218
0219     rc->device_name     = "rc-core loopback device";
0220     rc->input_phys      = "rc-core/virtual";
0221     rc->input_id.bustype    = BUS_VIRTUAL;
0222     rc->input_id.version    = 1;
0223     rc->driver_name     = DRIVER_NAME;
0224     rc->map_name        = RC_MAP_EMPTY;
0225     rc->priv        = &loopdev;
0226     rc->allowed_protocols   = RC_PROTO_BIT_ALL_IR_DECODER;
0227     rc->allowed_wakeup_protocols = RC_PROTO_BIT_ALL_IR_ENCODER;
0228     rc->encode_wakeup   = true;
0229     rc->timeout     = IR_DEFAULT_TIMEOUT;
0230     rc->min_timeout     = 1;
0231     rc->max_timeout     = IR_MAX_TIMEOUT;
0232     rc->rx_resolution   = 1;
0233     rc->tx_resolution   = 1;
0234     rc->s_tx_mask       = loop_set_tx_mask;
0235     rc->s_tx_carrier    = loop_set_tx_carrier;
0236     rc->s_tx_duty_cycle = loop_set_tx_duty_cycle;
0237     rc->s_rx_carrier_range  = loop_set_rx_carrier_range;
0238     rc->tx_ir       = loop_tx_ir;
0239     rc->s_idle      = loop_set_idle;
0240     rc->s_wideband_receiver = loop_set_wideband_receiver;
0241     rc->s_carrier_report    = loop_set_carrier_report;
0242     rc->s_wakeup_filter = loop_set_wakeup_filter;
0243
0244     loopdev.txmask      = RXMASK_NARROWBAND;
0245     loopdev.txcarrier   = 36000;
0246     loopdev.txduty      = 50;
0247     loopdev.rxcarriermin    = 1;
0248     loopdev.rxcarriermax    = ~0;
0249     loopdev.idle        = true;
0250     loopdev.wideband    = false;
0251     loopdev.carrierreport   = false;
0252
0253     ret = rc_register_device(rc);
0254     if (ret < 0) {
0255         dev_err(&rc->dev, "rc_dev registration failed\n");
0256         rc_free_device(rc);
0257         return ret;
0258     }
0259
0260     loopdev.dev = rc;
0261     return 0;
0262 }
0263
0264 static void __exit loop_exit(void)
0265 {
0266     rc_unregister_device(loopdev.dev);
0267 }
0268
0269 module_init(loop_init);
0270 module_exit(loop_exit);
0271
0272 MODULE_DESCRIPTION("Loopback device for rc-core debugging");
0273 MODULE_AUTHOR("David Härdeman <david@hardeman.nu>");
0274 MODULE_LICENSE("GPL");