forked from Minki/linux
media: rc: add support for Infrared Toy and IR Droid devices
http://dangerousprototypes.com/docs/USB_Infrared_Toy https://www.irdroid.com/irdroid-usb-ir-transceiver/ Reviewed-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> Signed-off-by: Sean Young <sean@mess.org> Signed-off-by: Mauro Carvalho Chehab <mchehab+huawei@kernel.org>
This commit is contained in:
parent
55e34d5bf9
commit
261463dbc3
@ -530,6 +530,17 @@ config IR_ZX
|
||||
To compile this driver as a module, choose M here: the
|
||||
module will be called zx-irdec.
|
||||
|
||||
config IR_TOY
|
||||
tristate "Infrared Toy and IR Droid"
|
||||
depends on RC_CORE
|
||||
depends on USB_ARCH_HAS_HCD
|
||||
help
|
||||
Say Y here if you want to use the Infrared Toy or IR Droid, USB
|
||||
versions.
|
||||
|
||||
To compile this driver as a module, choose M here: the module will be
|
||||
called ir_toy.
|
||||
|
||||
endif #RC_DEVICES
|
||||
|
||||
endif #RC_CORE
|
||||
|
@ -50,3 +50,4 @@ obj-$(CONFIG_IR_MTK) += mtk-cir.o
|
||||
obj-$(CONFIG_IR_ZX) += zx-irdec.o
|
||||
obj-$(CONFIG_IR_TANGO) += tango-ir.o
|
||||
obj-$(CONFIG_RC_XBOX_DVD) += xbox_remote.o
|
||||
obj-$(CONFIG_IR_TOY) += ir_toy.o
|
||||
|
509
drivers/media/rc/ir_toy.c
Normal file
509
drivers/media/rc/ir_toy.c
Normal file
@ -0,0 +1,509 @@
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
/*
|
||||
* Infrared Toy and IR Droid RC core driver
|
||||
*
|
||||
* Copyright (C) 2020 Sean Young <sean@mess.org>
|
||||
|
||||
* This driver is based on the lirc driver which can be found here:
|
||||
* https://sourceforge.net/p/lirc/git/ci/master/tree/plugins/irtoy.c
|
||||
* Copyright (C) 2011 Peter Kooiman <pkooiman@gmail.com>
|
||||
*/
|
||||
|
||||
#include <asm/unaligned.h>
|
||||
#include <linux/completion.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/usb.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/usb/input.h>
|
||||
|
||||
#include <media/rc-core.h>
|
||||
|
||||
static const u8 COMMAND_VERSION[] = { 'v' };
|
||||
// End transmit and repeat reset command so we exit sump mode
|
||||
static const u8 COMMAND_RESET[] = { 0xff, 0xff, 0, 0, 0, 0, 0 };
|
||||
static const u8 COMMAND_SMODE_ENTER[] = { 's' };
|
||||
static const u8 COMMAND_TXSTART[] = { 0x26, 0x24, 0x25, 0x03 };
|
||||
|
||||
#define REPLY_XMITCOUNT 't'
|
||||
#define REPLY_XMITSUCCESS 'C'
|
||||
#define REPLY_VERSION 'V'
|
||||
#define REPLY_SAMPLEMODEPROTO 'S'
|
||||
|
||||
#define TIMEOUT 500
|
||||
|
||||
#define LEN_XMITRES 3
|
||||
#define LEN_VERSION 4
|
||||
#define LEN_SAMPLEMODEPROTO 3
|
||||
|
||||
#define MIN_FW_VERSION 20
|
||||
#define UNIT_NS 21333
|
||||
#define MAX_TIMEOUT_NS (UNIT_NS * U16_MAX)
|
||||
|
||||
#define MAX_PACKET 64
|
||||
|
||||
enum state {
|
||||
STATE_IRDATA,
|
||||
STATE_RESET,
|
||||
STATE_COMMAND,
|
||||
STATE_TX,
|
||||
};
|
||||
|
||||
struct irtoy {
|
||||
struct device *dev;
|
||||
struct usb_device *usbdev;
|
||||
|
||||
struct rc_dev *rc;
|
||||
struct urb *urb_in, *urb_out;
|
||||
|
||||
u8 *in;
|
||||
u8 *out;
|
||||
struct completion command_done;
|
||||
|
||||
bool pulse;
|
||||
enum state state;
|
||||
|
||||
void *tx_buf;
|
||||
uint tx_len;
|
||||
|
||||
uint emitted;
|
||||
uint hw_version;
|
||||
uint sw_version;
|
||||
uint proto_version;
|
||||
|
||||
char phys[64];
|
||||
};
|
||||
|
||||
static void irtoy_response(struct irtoy *irtoy, u32 len)
|
||||
{
|
||||
switch (irtoy->state) {
|
||||
case STATE_COMMAND:
|
||||
if (len == LEN_VERSION && irtoy->in[0] == REPLY_VERSION) {
|
||||
uint version;
|
||||
|
||||
irtoy->in[LEN_VERSION] = 0;
|
||||
|
||||
if (kstrtouint(irtoy->in + 1, 10, &version)) {
|
||||
dev_err(irtoy->dev, "invalid version %*phN. Please make sure you are using firmware v20 or higher",
|
||||
LEN_VERSION, irtoy->in);
|
||||
break;
|
||||
}
|
||||
|
||||
dev_dbg(irtoy->dev, "version %s\n", irtoy->in);
|
||||
|
||||
irtoy->hw_version = version / 100;
|
||||
irtoy->sw_version = version % 100;
|
||||
|
||||
irtoy->state = STATE_IRDATA;
|
||||
complete(&irtoy->command_done);
|
||||
} else if (len == LEN_SAMPLEMODEPROTO &&
|
||||
irtoy->in[0] == REPLY_SAMPLEMODEPROTO) {
|
||||
uint version;
|
||||
|
||||
irtoy->in[LEN_SAMPLEMODEPROTO] = 0;
|
||||
|
||||
if (kstrtouint(irtoy->in + 1, 10, &version)) {
|
||||
dev_err(irtoy->dev, "invalid sample mode response %*phN",
|
||||
LEN_SAMPLEMODEPROTO, irtoy->in);
|
||||
return;
|
||||
}
|
||||
|
||||
dev_dbg(irtoy->dev, "protocol %s\n", irtoy->in);
|
||||
|
||||
irtoy->proto_version = version;
|
||||
|
||||
irtoy->state = STATE_IRDATA;
|
||||
complete(&irtoy->command_done);
|
||||
} else {
|
||||
dev_err(irtoy->dev, "unexpected response to command: %*phN\n",
|
||||
len, irtoy->in);
|
||||
}
|
||||
break;
|
||||
case STATE_IRDATA: {
|
||||
struct ir_raw_event rawir = { .pulse = irtoy->pulse };
|
||||
__be16 *in = (__be16 *)irtoy->in;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < len / sizeof(__be16); i++) {
|
||||
u16 v = be16_to_cpu(in[i]);
|
||||
|
||||
if (v == 0xffff) {
|
||||
rawir.pulse = false;
|
||||
} else {
|
||||
rawir.duration = v * UNIT_NS;
|
||||
ir_raw_event_store_with_timeout(irtoy->rc,
|
||||
&rawir);
|
||||
}
|
||||
|
||||
rawir.pulse = !rawir.pulse;
|
||||
}
|
||||
|
||||
irtoy->pulse = rawir.pulse;
|
||||
|
||||
ir_raw_event_handle(irtoy->rc);
|
||||
break;
|
||||
}
|
||||
case STATE_TX:
|
||||
if (irtoy->tx_len == 0) {
|
||||
if (len == LEN_XMITRES &&
|
||||
irtoy->in[0] == REPLY_XMITCOUNT) {
|
||||
u16 emitted = get_unaligned_be16(irtoy->in + 1);
|
||||
|
||||
dev_dbg(irtoy->dev, "emitted:%u\n", emitted);
|
||||
|
||||
irtoy->emitted = emitted;
|
||||
} else if (len == 1 &&
|
||||
irtoy->in[0] == REPLY_XMITSUCCESS) {
|
||||
irtoy->state = STATE_IRDATA;
|
||||
complete(&irtoy->command_done);
|
||||
}
|
||||
} else {
|
||||
// send next part of tx buffer
|
||||
uint space = irtoy->in[0];
|
||||
uint buf_len;
|
||||
int err;
|
||||
|
||||
if (len != 1 || space > MAX_PACKET || space == 0) {
|
||||
dev_err(irtoy->dev, "packet length expected: %*phN\n",
|
||||
len, irtoy->in);
|
||||
irtoy->state = STATE_IRDATA;
|
||||
complete(&irtoy->command_done);
|
||||
break;
|
||||
}
|
||||
|
||||
buf_len = min(space, irtoy->tx_len);
|
||||
|
||||
dev_dbg(irtoy->dev, "remaining:%u sending:%u\n",
|
||||
irtoy->tx_len, buf_len);
|
||||
|
||||
memcpy(irtoy->out, irtoy->tx_buf, buf_len);
|
||||
irtoy->urb_out->transfer_buffer_length = buf_len;
|
||||
err = usb_submit_urb(irtoy->urb_out, GFP_ATOMIC);
|
||||
if (err != 0) {
|
||||
dev_err(irtoy->dev, "fail to submit tx buf urb: %d\n",
|
||||
err);
|
||||
irtoy->state = STATE_IRDATA;
|
||||
complete(&irtoy->command_done);
|
||||
break;
|
||||
}
|
||||
|
||||
irtoy->tx_buf += buf_len;
|
||||
irtoy->tx_len -= buf_len;
|
||||
}
|
||||
break;
|
||||
case STATE_RESET:
|
||||
dev_err(irtoy->dev, "unexpected response to reset: %*phN\n",
|
||||
len, irtoy->in);
|
||||
}
|
||||
}
|
||||
|
||||
static void irtoy_out_callback(struct urb *urb)
|
||||
{
|
||||
struct irtoy *irtoy = urb->context;
|
||||
|
||||
if (urb->status == 0) {
|
||||
if (irtoy->state == STATE_RESET)
|
||||
complete(&irtoy->command_done);
|
||||
} else {
|
||||
dev_warn(irtoy->dev, "out urb status: %d\n", urb->status);
|
||||
}
|
||||
}
|
||||
|
||||
static void irtoy_in_callback(struct urb *urb)
|
||||
{
|
||||
struct irtoy *irtoy = urb->context;
|
||||
int ret;
|
||||
|
||||
if (urb->status == 0)
|
||||
irtoy_response(irtoy, urb->actual_length);
|
||||
else
|
||||
dev_dbg(irtoy->dev, "in urb status: %d\n", urb->status);
|
||||
|
||||
ret = usb_submit_urb(urb, GFP_ATOMIC);
|
||||
if (ret && ret != -ENODEV)
|
||||
dev_warn(irtoy->dev, "failed to resubmit urb: %d\n", ret);
|
||||
}
|
||||
|
||||
static int irtoy_command(struct irtoy *irtoy, const u8 *cmd, int cmd_len,
|
||||
enum state state)
|
||||
{
|
||||
int err;
|
||||
|
||||
init_completion(&irtoy->command_done);
|
||||
|
||||
irtoy->state = state;
|
||||
|
||||
memcpy(irtoy->out, cmd, cmd_len);
|
||||
irtoy->urb_out->transfer_buffer_length = cmd_len;
|
||||
|
||||
err = usb_submit_urb(irtoy->urb_out, GFP_KERNEL);
|
||||
if (err != 0)
|
||||
return err;
|
||||
|
||||
if (!wait_for_completion_timeout(&irtoy->command_done,
|
||||
msecs_to_jiffies(TIMEOUT))) {
|
||||
usb_kill_urb(irtoy->urb_out);
|
||||
return -ETIMEDOUT;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int irtoy_setup(struct irtoy *irtoy)
|
||||
{
|
||||
int err;
|
||||
|
||||
err = irtoy_command(irtoy, COMMAND_RESET, sizeof(COMMAND_RESET),
|
||||
STATE_RESET);
|
||||
if (err != 0) {
|
||||
dev_err(irtoy->dev, "could not write reset command: %d\n",
|
||||
err);
|
||||
return err;
|
||||
}
|
||||
|
||||
usleep_range(50, 50);
|
||||
|
||||
// get version
|
||||
err = irtoy_command(irtoy, COMMAND_VERSION, sizeof(COMMAND_VERSION),
|
||||
STATE_COMMAND);
|
||||
if (err) {
|
||||
dev_err(irtoy->dev, "could not write version command: %d\n",
|
||||
err);
|
||||
return err;
|
||||
}
|
||||
|
||||
// enter sample mode
|
||||
err = irtoy_command(irtoy, COMMAND_SMODE_ENTER,
|
||||
sizeof(COMMAND_SMODE_ENTER), STATE_COMMAND);
|
||||
if (err)
|
||||
dev_err(irtoy->dev, "could not write sample command: %d\n",
|
||||
err);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
/*
|
||||
* When sending IR, it is imperative that we send the IR data as quickly
|
||||
* as possible to the device, so it does not run out of IR data and
|
||||
* introduce gaps. Allocate the buffer here, and then feed the data from
|
||||
* the urb callback handler.
|
||||
*/
|
||||
static int irtoy_tx(struct rc_dev *rc, uint *txbuf, uint count)
|
||||
{
|
||||
struct irtoy *irtoy = rc->priv;
|
||||
unsigned int i, size;
|
||||
__be16 *buf;
|
||||
int err;
|
||||
|
||||
size = sizeof(u16) * (count + 1);
|
||||
buf = kmalloc(size, GFP_KERNEL);
|
||||
if (!buf)
|
||||
return -ENOMEM;
|
||||
|
||||
for (i = 0; i < count; i++) {
|
||||
u16 v = DIV_ROUND_CLOSEST(US_TO_NS(txbuf[i]), UNIT_NS);
|
||||
|
||||
if (!v)
|
||||
v = 1;
|
||||
buf[i] = cpu_to_be16(v);
|
||||
}
|
||||
|
||||
buf[count] = cpu_to_be16(0xffff);
|
||||
|
||||
irtoy->tx_buf = buf;
|
||||
irtoy->tx_len = size;
|
||||
irtoy->emitted = 0;
|
||||
|
||||
err = irtoy_command(irtoy, COMMAND_TXSTART, sizeof(COMMAND_TXSTART),
|
||||
STATE_TX);
|
||||
kfree(buf);
|
||||
|
||||
if (err) {
|
||||
dev_err(irtoy->dev, "failed to send tx start command: %d\n",
|
||||
err);
|
||||
// not sure what state the device is in, reset it
|
||||
irtoy_setup(irtoy);
|
||||
return err;
|
||||
}
|
||||
|
||||
if (size != irtoy->emitted) {
|
||||
dev_err(irtoy->dev, "expected %u emitted, got %u\n", size,
|
||||
irtoy->emitted);
|
||||
// not sure what state the device is in, reset it
|
||||
irtoy_setup(irtoy);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
static int irtoy_probe(struct usb_interface *intf,
|
||||
const struct usb_device_id *id)
|
||||
{
|
||||
struct usb_host_interface *idesc = intf->cur_altsetting;
|
||||
struct usb_device *usbdev = interface_to_usbdev(intf);
|
||||
struct usb_endpoint_descriptor *ep_in = NULL;
|
||||
struct usb_endpoint_descriptor *ep_out = NULL;
|
||||
struct usb_endpoint_descriptor *ep = NULL;
|
||||
struct irtoy *irtoy;
|
||||
struct rc_dev *rc;
|
||||
struct urb *urb;
|
||||
int i, pipe, err = -ENOMEM;
|
||||
|
||||
for (i = 0; i < idesc->desc.bNumEndpoints; i++) {
|
||||
ep = &idesc->endpoint[i].desc;
|
||||
|
||||
if (!ep_in && usb_endpoint_is_bulk_in(ep) &&
|
||||
usb_endpoint_maxp(ep) == MAX_PACKET)
|
||||
ep_in = ep;
|
||||
|
||||
if (!ep_out && usb_endpoint_is_bulk_out(ep) &&
|
||||
usb_endpoint_maxp(ep) == MAX_PACKET)
|
||||
ep_out = ep;
|
||||
}
|
||||
|
||||
if (!ep_in || !ep_out) {
|
||||
dev_err(&intf->dev, "required endpoints not found\n");
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
irtoy = kzalloc(sizeof(*irtoy), GFP_KERNEL);
|
||||
if (!irtoy)
|
||||
return -ENOMEM;
|
||||
|
||||
irtoy->in = kmalloc(MAX_PACKET, GFP_KERNEL);
|
||||
if (!irtoy->in)
|
||||
goto free_irtoy;
|
||||
|
||||
irtoy->out = kmalloc(MAX_PACKET, GFP_KERNEL);
|
||||
if (!irtoy->out)
|
||||
goto free_irtoy;
|
||||
|
||||
rc = rc_allocate_device(RC_DRIVER_IR_RAW);
|
||||
if (!rc)
|
||||
goto free_irtoy;
|
||||
|
||||
urb = usb_alloc_urb(0, GFP_KERNEL);
|
||||
if (!urb)
|
||||
goto free_rcdev;
|
||||
|
||||
pipe = usb_rcvbulkpipe(usbdev, ep_in->bEndpointAddress);
|
||||
usb_fill_bulk_urb(urb, usbdev, pipe, irtoy->in, MAX_PACKET,
|
||||
irtoy_in_callback, irtoy);
|
||||
irtoy->urb_in = urb;
|
||||
|
||||
urb = usb_alloc_urb(0, GFP_KERNEL);
|
||||
if (!urb)
|
||||
goto free_rcdev;
|
||||
|
||||
pipe = usb_sndbulkpipe(usbdev, ep_out->bEndpointAddress);
|
||||
usb_fill_bulk_urb(urb, usbdev, pipe, irtoy->out, MAX_PACKET,
|
||||
irtoy_out_callback, irtoy);
|
||||
|
||||
irtoy->dev = &intf->dev;
|
||||
irtoy->usbdev = usbdev;
|
||||
irtoy->rc = rc;
|
||||
irtoy->urb_out = urb;
|
||||
irtoy->pulse = true;
|
||||
|
||||
err = usb_submit_urb(irtoy->urb_in, GFP_KERNEL);
|
||||
if (err != 0) {
|
||||
dev_err(irtoy->dev, "fail to submit in urb: %d\n", err);
|
||||
return err;
|
||||
}
|
||||
|
||||
err = irtoy_setup(irtoy);
|
||||
if (err)
|
||||
goto free_rcdev;
|
||||
|
||||
dev_info(irtoy->dev, "version: hardware %u, firmware %u, protocol %u",
|
||||
irtoy->hw_version, irtoy->sw_version, irtoy->proto_version);
|
||||
|
||||
if (irtoy->sw_version < MIN_FW_VERSION) {
|
||||
dev_err(irtoy->dev, "need firmware V%02u or higher",
|
||||
MIN_FW_VERSION);
|
||||
err = -ENODEV;
|
||||
goto free_rcdev;
|
||||
}
|
||||
|
||||
usb_make_path(usbdev, irtoy->phys, sizeof(irtoy->phys));
|
||||
|
||||
rc->device_name = "Infrared Toy";
|
||||
rc->driver_name = KBUILD_MODNAME;
|
||||
rc->input_phys = irtoy->phys;
|
||||
usb_to_input_id(usbdev, &rc->input_id);
|
||||
rc->dev.parent = &intf->dev;
|
||||
rc->priv = irtoy;
|
||||
rc->tx_ir = irtoy_tx;
|
||||
rc->allowed_protocols = RC_PROTO_BIT_ALL_IR_DECODER;
|
||||
rc->map_name = RC_MAP_RC6_MCE;
|
||||
rc->rx_resolution = UNIT_NS;
|
||||
rc->timeout = IR_DEFAULT_TIMEOUT;
|
||||
|
||||
/*
|
||||
* end of transmission is detected by absence of a usb packet
|
||||
* with more pulse/spaces. However, each usb packet sent can
|
||||
* contain 32 pulse/spaces, which can be quite lengthy, so there
|
||||
* can be a delay between usb packets. For example with nec there is a
|
||||
* 17ms gap between packets.
|
||||
*
|
||||
* So, make timeout a largish minimum which works with most protocols.
|
||||
*/
|
||||
rc->min_timeout = MS_TO_NS(40);
|
||||
rc->max_timeout = MAX_TIMEOUT_NS;
|
||||
|
||||
err = rc_register_device(rc);
|
||||
if (err)
|
||||
goto free_rcdev;
|
||||
|
||||
usb_set_intfdata(intf, irtoy);
|
||||
|
||||
return 0;
|
||||
|
||||
free_rcdev:
|
||||
usb_kill_urb(irtoy->urb_out);
|
||||
usb_free_urb(irtoy->urb_out);
|
||||
usb_kill_urb(irtoy->urb_in);
|
||||
usb_free_urb(irtoy->urb_in);
|
||||
rc_free_device(rc);
|
||||
free_irtoy:
|
||||
kfree(irtoy->in);
|
||||
kfree(irtoy->out);
|
||||
kfree(irtoy);
|
||||
return err;
|
||||
}
|
||||
|
||||
static void irtoy_disconnect(struct usb_interface *intf)
|
||||
{
|
||||
struct irtoy *ir = usb_get_intfdata(intf);
|
||||
|
||||
rc_unregister_device(ir->rc);
|
||||
usb_set_intfdata(intf, NULL);
|
||||
usb_kill_urb(ir->urb_out);
|
||||
usb_free_urb(ir->urb_out);
|
||||
usb_kill_urb(ir->urb_in);
|
||||
usb_free_urb(ir->urb_in);
|
||||
kfree(ir->in);
|
||||
kfree(ir->out);
|
||||
kfree(ir);
|
||||
}
|
||||
|
||||
static const struct usb_device_id irtoy_table[] = {
|
||||
{ USB_DEVICE_INTERFACE_CLASS(0x04d8, 0xfd08, USB_CLASS_CDC_DATA) },
|
||||
{ }
|
||||
};
|
||||
|
||||
static struct usb_driver irtoy_driver = {
|
||||
.name = KBUILD_MODNAME,
|
||||
.probe = irtoy_probe,
|
||||
.disconnect = irtoy_disconnect,
|
||||
.id_table = irtoy_table,
|
||||
};
|
||||
|
||||
module_usb_driver(irtoy_driver);
|
||||
|
||||
MODULE_AUTHOR("Sean Young <sean@mess.org>");
|
||||
MODULE_DESCRIPTION("Infrared Toy and IR Droid driver");
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DEVICE_TABLE(usb, irtoy_table);
|
Loading…
Reference in New Issue
Block a user