drivers/media/rc/ir_toy.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2
   3 /*
   4  * Infrared Toy and IR Droid RC core driver
   5  *
   6  * Copyright (C) 2020 Sean Young <sean@mess.org>
   7  *
   8  * http://dangerousprototypes.com/docs/USB_IR_Toy:_Sampling_mode
   9  *
  10  * This driver is based on the lirc driver which can be found here:
  11  * https://sourceforge.net/p/lirc/git/ci/master/tree/plugins/irtoy.c
  12  * Copyright (C) 2011 Peter Kooiman <pkooiman@gmail.com>
  13  */
  14
  15 #include <asm/unaligned.h>
  16 #include <linux/completion.h>
  17 #include <linux/kernel.h>
  18 #include <linux/module.h>
  19 #include <linux/usb.h>
  20 #include <linux/slab.h>
  21 #include <linux/usb/input.h>
  22
  23 #include <media/rc-core.h>
  24
  25 static const u8 COMMAND_VERSION[] = { 'v' };
  26 // End transmit and repeat reset command so we exit sump mode
  27 static const u8 COMMAND_RESET[] = { 0xff, 0xff, 0, 0, 0, 0, 0 };
  28 static const u8 COMMAND_SMODE_ENTER[] = { 's' };
  29 static const u8 COMMAND_TXSTART[] = { 0x26, 0x24, 0x25, 0x03 };
  30
  31 #define REPLY_XMITCOUNT 't'
  32 #define REPLY_XMITSUCCESS 'C'
  33 #define REPLY_VERSION 'V'
  34 #define REPLY_SAMPLEMODEPROTO 'S'
  35
  36 #define TIMEOUT 500
  37
  38 #define LEN_XMITRES 3
  39 #define LEN_VERSION 4
  40 #define LEN_SAMPLEMODEPROTO 3
  41
  42 #define MIN_FW_VERSION 20
  43 #define UNIT_US 21
  44 #define MAX_TIMEOUT_US (UNIT_US * U16_MAX)
  45
  46 #define MAX_PACKET 64
  47
  48 enum state {
  49         STATE_IRDATA,
  50         STATE_COMMAND_NO_RESP,
  51         STATE_COMMAND,
  52         STATE_TX,
  53 };
  54
  55 struct irtoy {
  56         struct device *dev;
  57         struct usb_device *usbdev;
  58
  59         struct rc_dev *rc;
  60         struct urb *urb_in, *urb_out;
  61
  62         u8 *in;
  63         u8 *out;
  64         struct completion command_done;
  65
  66         bool pulse;
  67         enum state state;
  68
  69         void *tx_buf;
  70         uint tx_len;
  71
  72         uint emitted;
  73         uint hw_version;
  74         uint sw_version;
  75         uint proto_version;
  76
  77         char phys[64];
  78 };
  79
  80 static void irtoy_response(struct irtoy *irtoy, u32 len)
  81 {
  82         switch (irtoy->state) {
  83         case STATE_COMMAND:
  84                 if (len == LEN_VERSION && irtoy->in[0] == REPLY_VERSION) {
  85                         uint version;
  86
  87                         irtoy->in[LEN_VERSION] = 0;
  88
  89                         if (kstrtouint(irtoy->in + 1, 10, &version)) {
  90                                 dev_err(irtoy->dev, "invalid version %*phN. Please make sure you are using firmware v20 or higher",
  91                                         LEN_VERSION, irtoy->in);
  92                                 break;
  93                         }
  94
  95                         dev_dbg(irtoy->dev, "version %s\n", irtoy->in);
  96
  97                         irtoy->hw_version = version / 100;
  98                         irtoy->sw_version = version % 100;
  99
 100                         irtoy->state = STATE_IRDATA;
 101                         complete(&irtoy->command_done);
 102                 } else if (len == LEN_SAMPLEMODEPROTO &&
 103                            irtoy->in[0] == REPLY_SAMPLEMODEPROTO) {
 104                         uint version;
 105
 106                         irtoy->in[LEN_SAMPLEMODEPROTO] = 0;
 107
 108                         if (kstrtouint(irtoy->in + 1, 10, &version)) {
 109                                 dev_err(irtoy->dev, "invalid sample mode response %*phN",
 110                                         LEN_SAMPLEMODEPROTO, irtoy->in);
 111                                 return;
 112                         }
 113
 114                         dev_dbg(irtoy->dev, "protocol %s\n", irtoy->in);
 115
 116                         irtoy->proto_version = version;
 117
 118                         irtoy->state = STATE_IRDATA;
 119                         complete(&irtoy->command_done);
 120                 } else {
 121                         dev_err(irtoy->dev, "unexpected response to command: %*phN\n",
 122                                 len, irtoy->in);
 123                 }
 124                 break;
 125         case STATE_COMMAND_NO_RESP:
 126         case STATE_IRDATA: {
 127                 struct ir_raw_event rawir = { .pulse = irtoy->pulse };
 128                 __be16 *in = (__be16 *)irtoy->in;
 129                 int i;
 130
 131                 for (i = 0; i < len / sizeof(__be16); i++) {
 132                         u16 v = be16_to_cpu(in[i]);
 133
 134                         if (v == 0xffff) {
 135                                 rawir.pulse = false;
 136                         } else {
 137                                 rawir.duration = v * UNIT_US;
 138                                 ir_raw_event_store_with_timeout(irtoy->rc,
 139                                                                 &rawir);
 140                         }
 141
 142                         rawir.pulse = !rawir.pulse;
 143                 }
 144
 145                 irtoy->pulse = rawir.pulse;
 146
 147                 ir_raw_event_handle(irtoy->rc);
 148                 break;
 149         }
 150         case STATE_TX:
 151                 if (irtoy->tx_len == 0) {
 152                         if (len == LEN_XMITRES &&
 153                             irtoy->in[0] == REPLY_XMITCOUNT) {
 154                                 u16 emitted = get_unaligned_be16(irtoy->in + 1);
 155
 156                                 dev_dbg(irtoy->dev, "emitted:%u\n", emitted);
 157
 158                                 irtoy->emitted = emitted;
 159                         } else if (len == 1 &&
 160                                    irtoy->in[0] == REPLY_XMITSUCCESS) {
 161                                 irtoy->state = STATE_IRDATA;
 162                                 complete(&irtoy->command_done);
 163                         }
 164                 } else {
 165                         // send next part of tx buffer
 166                         uint space = irtoy->in[0];
 167                         uint buf_len;
 168                         int err;
 169
 170                         if (len != 1 || space > MAX_PACKET || space == 0) {
 171                                 dev_dbg(irtoy->dev, "packet length expected: %*phN\n",
 172                                         len, irtoy->in);
 173                                 break;
 174                         }
 175
 176                         buf_len = min(space, irtoy->tx_len);
 177
 178                         dev_dbg(irtoy->dev, "remaining:%u sending:%u\n",
 179                                 irtoy->tx_len, buf_len);
 180
 181                         memcpy(irtoy->out, irtoy->tx_buf, buf_len);
 182                         irtoy->urb_out->transfer_buffer_length = buf_len;
 183                         err = usb_submit_urb(irtoy->urb_out, GFP_ATOMIC);
 184                         if (err != 0) {
 185                                 dev_err(irtoy->dev, "fail to submit tx buf urb: %d\n",
 186                                         err);
 187                                 irtoy->state = STATE_IRDATA;
 188                                 complete(&irtoy->command_done);
 189                                 break;
 190                         }
 191
 192                         irtoy->tx_buf += buf_len;
 193                         irtoy->tx_len -= buf_len;
 194                 }
 195                 break;
 196         }
 197 }
 198
 199 static void irtoy_out_callback(struct urb *urb)
 200 {
 201         struct irtoy *irtoy = urb->context;
 202
 203         if (urb->status == 0) {
 204                 if (irtoy->state == STATE_COMMAND_NO_RESP)
 205                         complete(&irtoy->command_done);
 206         } else {
 207                 dev_warn(irtoy->dev, "out urb status: %d\n", urb->status);
 208         }
 209 }
 210
 211 static void irtoy_in_callback(struct urb *urb)
 212 {
 213         struct irtoy *irtoy = urb->context;
 214         int ret;
 215
 216         switch (urb->status) {
 217         case 0:
 218                 irtoy_response(irtoy, urb->actual_length);
 219                 break;
 220         case -ECONNRESET:
 221         case -ENOENT:
 222         case -ESHUTDOWN:
 223         case -EPROTO:
 224         case -EPIPE:
 225                 usb_unlink_urb(urb);
 226                 return;
 227         default:
 228                 dev_dbg(irtoy->dev, "in urb status: %d\n", urb->status);
 229         }
 230
 231         ret = usb_submit_urb(urb, GFP_ATOMIC);
 232         if (ret && ret != -ENODEV)
 233                 dev_warn(irtoy->dev, "failed to resubmit urb: %d\n", ret);
 234 }
 235
 236 static int irtoy_command(struct irtoy *irtoy, const u8 *cmd, int cmd_len,
 237                          enum state state)
 238 {
 239         int err;
 240
 241         init_completion(&irtoy->command_done);
 242
 243         irtoy->state = state;
 244
 245         memcpy(irtoy->out, cmd, cmd_len);
 246         irtoy->urb_out->transfer_buffer_length = cmd_len;
 247
 248         err = usb_submit_urb(irtoy->urb_out, GFP_KERNEL);
 249         if (err != 0)
 250                 return err;
 251
 252         if (!wait_for_completion_timeout(&irtoy->command_done,
 253                                          msecs_to_jiffies(TIMEOUT))) {
 254                 usb_kill_urb(irtoy->urb_out);
 255                 return -ETIMEDOUT;
 256         }
 257
 258         return 0;
 259 }
 260
 261 static int irtoy_setup(struct irtoy *irtoy)
 262 {
 263         int err;
 264
 265         err = irtoy_command(irtoy, COMMAND_RESET, sizeof(COMMAND_RESET),
 266                             STATE_COMMAND_NO_RESP);
 267         if (err != 0) {
 268                 dev_err(irtoy->dev, "could not write reset command: %d\n",
 269                         err);
 270                 return err;
 271         }
 272
 273         usleep_range(50, 50);
 274
 275         // get version
 276         err = irtoy_command(irtoy, COMMAND_VERSION, sizeof(COMMAND_VERSION),
 277                             STATE_COMMAND);
 278         if (err) {
 279                 dev_err(irtoy->dev, "could not write version command: %d\n",
 280                         err);
 281                 return err;
 282         }
 283
 284         // enter sample mode
 285         err = irtoy_command(irtoy, COMMAND_SMODE_ENTER,
 286                             sizeof(COMMAND_SMODE_ENTER), STATE_COMMAND);
 287         if (err)
 288                 dev_err(irtoy->dev, "could not write sample command: %d\n",
 289                         err);
 290
 291         return err;
 292 }
 293
 294 /*
 295  * When sending IR, it is imperative that we send the IR data as quickly
 296  * as possible to the device, so it does not run out of IR data and
 297  * introduce gaps. Allocate the buffer here, and then feed the data from
 298  * the urb callback handler.
 299  */
 300 static int irtoy_tx(struct rc_dev *rc, uint *txbuf, uint count)
 301 {
 302         struct irtoy *irtoy = rc->priv;
 303         unsigned int i, size;
 304         __be16 *buf;
 305         int err;
 306
 307         size = sizeof(u16) * (count + 1);
 308         buf = kmalloc(size, GFP_KERNEL);
 309         if (!buf)
 310                 return -ENOMEM;
 311
 312         for (i = 0; i < count; i++) {
 313                 u16 v = DIV_ROUND_CLOSEST(txbuf[i], UNIT_US);
 314
 315                 if (!v)
 316                         v = 1;
 317                 buf[i] = cpu_to_be16(v);
 318         }
 319
 320         buf[count] = cpu_to_be16(0xffff);
 321
 322         irtoy->tx_buf = buf;
 323         irtoy->tx_len = size;
 324         irtoy->emitted = 0;
 325
 326         err = irtoy_command(irtoy, COMMAND_TXSTART, sizeof(COMMAND_TXSTART),
 327                             STATE_TX);
 328         kfree(buf);
 329
 330         if (err) {
 331                 dev_err(irtoy->dev, "failed to send tx start command: %d\n",
 332                         err);
 333                 // not sure what state the device is in, reset it
 334                 irtoy_setup(irtoy);
 335                 return err;
 336         }
 337
 338         if (size != irtoy->emitted) {
 339                 dev_err(irtoy->dev, "expected %u emitted, got %u\n", size,
 340                         irtoy->emitted);
 341                 // not sure what state the device is in, reset it
 342                 irtoy_setup(irtoy);
 343                 return -EINVAL;
 344         }
 345
 346         return count;
 347 }
 348
 349 static int irtoy_tx_carrier(struct rc_dev *rc, uint32_t carrier)
 350 {
 351         struct irtoy *irtoy = rc->priv;
 352         u8 buf[3];
 353         int err;
 354
 355         if (carrier < 11800)
 356                 return -EINVAL;
 357
 358         buf[0] = 0x06;
 359         buf[1] = DIV_ROUND_CLOSEST(48000000, 16 * carrier) - 1;
 360         buf[2] = 0;
 361
 362         err = irtoy_command(irtoy, buf, sizeof(buf), STATE_COMMAND_NO_RESP);
 363         if (err)
 364                 dev_err(irtoy->dev, "could not write carrier command: %d\n",
 365                         err);
 366
 367         return err;
 368 }
 369
 370 static int irtoy_probe(struct usb_interface *intf,
 371                        const struct usb_device_id *id)
 372 {
 373         struct usb_host_interface *idesc = intf->cur_altsetting;
 374         struct usb_device *usbdev = interface_to_usbdev(intf);
 375         struct usb_endpoint_descriptor *ep_in = NULL;
 376         struct usb_endpoint_descriptor *ep_out = NULL;
 377         struct usb_endpoint_descriptor *ep = NULL;
 378         struct irtoy *irtoy;
 379         struct rc_dev *rc;
 380         struct urb *urb;
 381         int i, pipe, err = -ENOMEM;
 382
 383         for (i = 0; i < idesc->desc.bNumEndpoints; i++) {
 384                 ep = &idesc->endpoint[i].desc;
 385
 386                 if (!ep_in && usb_endpoint_is_bulk_in(ep) &&
 387                     usb_endpoint_maxp(ep) == MAX_PACKET)
 388                         ep_in = ep;
 389
 390                 if (!ep_out && usb_endpoint_is_bulk_out(ep) &&
 391                     usb_endpoint_maxp(ep) == MAX_PACKET)
 392                         ep_out = ep;
 393         }
 394
 395         if (!ep_in || !ep_out) {
 396                 dev_err(&intf->dev, "required endpoints not found\n");
 397                 return -ENODEV;
 398         }
 399
 400         irtoy = kzalloc(sizeof(*irtoy), GFP_KERNEL);
 401         if (!irtoy)
 402                 return -ENOMEM;
 403
 404         irtoy->in = kmalloc(MAX_PACKET,  GFP_KERNEL);
 405         if (!irtoy->in)
 406                 goto free_irtoy;
 407
 408         irtoy->out = kmalloc(MAX_PACKET,  GFP_KERNEL);
 409         if (!irtoy->out)
 410                 goto free_irtoy;
 411
 412         rc = rc_allocate_device(RC_DRIVER_IR_RAW);
 413         if (!rc)
 414                 goto free_irtoy;
 415
 416         urb = usb_alloc_urb(0, GFP_KERNEL);
 417         if (!urb)
 418                 goto free_rcdev;
 419
 420         pipe = usb_rcvbulkpipe(usbdev, ep_in->bEndpointAddress);
 421         usb_fill_bulk_urb(urb, usbdev, pipe, irtoy->in, MAX_PACKET,
 422                           irtoy_in_callback, irtoy);
 423         irtoy->urb_in = urb;
 424
 425         urb = usb_alloc_urb(0, GFP_KERNEL);
 426         if (!urb)
 427                 goto free_rcdev;
 428
 429         pipe = usb_sndbulkpipe(usbdev, ep_out->bEndpointAddress);
 430         usb_fill_bulk_urb(urb, usbdev, pipe, irtoy->out, MAX_PACKET,
 431                           irtoy_out_callback, irtoy);
 432
 433         irtoy->dev = &intf->dev;
 434         irtoy->usbdev = usbdev;
 435         irtoy->rc = rc;
 436         irtoy->urb_out = urb;
 437         irtoy->pulse = true;
 438
 439         err = usb_submit_urb(irtoy->urb_in, GFP_KERNEL);
 440         if (err != 0) {
 441                 dev_err(irtoy->dev, "fail to submit in urb: %d\n", err);
 442                 return err;
 443         }
 444
 445         err = irtoy_setup(irtoy);
 446         if (err)
 447                 goto free_rcdev;
 448
 449         dev_info(irtoy->dev, "version: hardware %u, firmware %u.%u, protocol %u",
 450                  irtoy->hw_version, irtoy->sw_version / 10,
 451                  irtoy->sw_version % 10, irtoy->proto_version);
 452
 453         if (irtoy->sw_version < MIN_FW_VERSION) {
 454                 dev_err(irtoy->dev, "need firmware V%02u or higher",
 455                         MIN_FW_VERSION);
 456                 err = -ENODEV;
 457                 goto free_rcdev;
 458         }
 459
 460         usb_make_path(usbdev, irtoy->phys, sizeof(irtoy->phys));
 461
 462         rc->device_name = "Infrared Toy";
 463         rc->driver_name = KBUILD_MODNAME;
 464         rc->input_phys = irtoy->phys;
 465         usb_to_input_id(usbdev, &rc->input_id);
 466         rc->dev.parent = &intf->dev;
 467         rc->priv = irtoy;
 468         rc->tx_ir = irtoy_tx;
 469         rc->s_tx_carrier = irtoy_tx_carrier;
 470         rc->allowed_protocols = RC_PROTO_BIT_ALL_IR_DECODER;
 471         rc->map_name = RC_MAP_RC6_MCE;
 472         rc->rx_resolution = UNIT_US;
 473         rc->timeout = IR_DEFAULT_TIMEOUT;
 474
 475         /*
 476          * end of transmission is detected by absence of a usb packet
 477          * with more pulse/spaces. However, each usb packet sent can
 478          * contain 32 pulse/spaces, which can be quite lengthy, so there
 479          * can be a delay between usb packets. For example with nec there is a
 480          * 17ms gap between packets.
 481          *
 482          * So, make timeout a largish minimum which works with most protocols.
 483          */
 484         rc->min_timeout = MS_TO_US(40);
 485         rc->max_timeout = MAX_TIMEOUT_US;
 486
 487         err = rc_register_device(rc);
 488         if (err)
 489                 goto free_rcdev;
 490
 491         usb_set_intfdata(intf, irtoy);
 492
 493         return 0;
 494
 495 free_rcdev:
 496         usb_kill_urb(irtoy->urb_out);
 497         usb_free_urb(irtoy->urb_out);
 498         usb_kill_urb(irtoy->urb_in);
 499         usb_free_urb(irtoy->urb_in);
 500         rc_free_device(rc);
 501 free_irtoy:
 502         kfree(irtoy->in);
 503         kfree(irtoy->out);
 504         kfree(irtoy);
 505         return err;
 506 }
 507
 508 static void irtoy_disconnect(struct usb_interface *intf)
 509 {
 510         struct irtoy *ir = usb_get_intfdata(intf);
 511
 512         rc_unregister_device(ir->rc);
 513         usb_set_intfdata(intf, NULL);
 514         usb_kill_urb(ir->urb_out);
 515         usb_free_urb(ir->urb_out);
 516         usb_kill_urb(ir->urb_in);
 517         usb_free_urb(ir->urb_in);
 518         kfree(ir->in);
 519         kfree(ir->out);
 520         kfree(ir);
 521 }
 522
 523 static const struct usb_device_id irtoy_table[] = {
 524         { USB_DEVICE_INTERFACE_CLASS(0x04d8, 0xfd08, USB_CLASS_CDC_DATA) },
 525         { USB_DEVICE_INTERFACE_CLASS(0x04d8, 0xf58b, USB_CLASS_CDC_DATA) },
 526         { }
 527 };
 528
 529 static struct usb_driver irtoy_driver = {
 530         .name = KBUILD_MODNAME,
 531         .probe = irtoy_probe,
 532         .disconnect = irtoy_disconnect,
 533         .id_table = irtoy_table,
 534 };
 535
 536 module_usb_driver(irtoy_driver);
 537
 538 MODULE_AUTHOR("Sean Young <sean@mess.org>");
 539 MODULE_DESCRIPTION("Infrared Toy and IR Droid driver");
 540 MODULE_LICENSE("GPL");
 541 MODULE_DEVICE_TABLE(usb, irtoy_table);