Quelle  img-ir-sony.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * ImgTec IR Decoder setup for Sony (SIRC) protocol.
 *
 * Copyright 2012-2014 Imagination Technologies Ltd.
 */

#include "img-ir-hw.h"

/* Convert Sony data to a scancode */
static int img_ir_sony_scancode(int len, u64 raw, u64 enabled_protocols,
    struct img_ir_scancode_req *request)
{
 unsigned int dev, subdev, func;

 switch (len) {
 case 12:
  if (!(enabled_protocols & RC_PROTO_BIT_SONY12))
   return -EINVAL;
  func   = raw & 0x7f; /* first 7 bits */
  raw    >>= 7;
  dev    = raw & 0x1f; /* next 5 bits */
  subdev = 0;
  request->protocol = RC_PROTO_SONY12;
  break;
 case 15:
  if (!(enabled_protocols & RC_PROTO_BIT_SONY15))
   return -EINVAL;
  func   = raw & 0x7f; /* first 7 bits */
  raw    >>= 7;
  dev    = raw & 0xff; /* next 8 bits */
  subdev = 0;
  request->protocol = RC_PROTO_SONY15;
  break;
 case 20:
  if (!(enabled_protocols & RC_PROTO_BIT_SONY20))
   return -EINVAL;
  func   = raw & 0x7f; /* first 7 bits */
  raw    >>= 7;
  dev    = raw & 0x1f; /* next 5 bits */
  raw    >>= 5;
  subdev = raw & 0xff; /* next 8 bits */
  request->protocol = RC_PROTO_SONY20;
  break;
 default:
  return -EINVAL;
 }
 request->scancode = dev << 16 | subdev << 8 | func;
 return IMG_IR_SCANCODE;
}

/* Convert NEC scancode to NEC data filter */
static int img_ir_sony_filter(const struct rc_scancode_filter *in,
         struct img_ir_filter *out, u64 protocols)
{
 unsigned int dev, subdev, func;
 unsigned int dev_m, subdev_m, func_m;
 unsigned int len = 0;

 dev      = (in->data >> 16) & 0xff;
 dev_m    = (in->mask >> 16) & 0xff;
 subdev   = (in->data >> 8)  & 0xff;
 subdev_m = (in->mask >> 8)  & 0xff;
 func     = (in->data >> 0)  & 0x7f;
 func_m   = (in->mask >> 0)  & 0x7f;

 protocols &= RC_PROTO_BIT_SONY12 | RC_PROTO_BIT_SONY15 |
       RC_PROTO_BIT_SONY20;

 /*
 * If only one bit is set, we were requested to do an exact
 * protocol. This should be the case for wakeup filters; for
 * normal filters, guess the protocol from the scancode.
 */
 if (!is_power_of_2(protocols)) {
  if (subdev & subdev_m)
   protocols = RC_PROTO_BIT_SONY20;
  else if (dev & dev_m & 0xe0)
   protocols = RC_PROTO_BIT_SONY15;
  else
   protocols = RC_PROTO_BIT_SONY12;
 }

 if (protocols == RC_PROTO_BIT_SONY20) {
  /* can't encode subdev and higher device bits */
  if (dev & dev_m & 0xe0)
   return -EINVAL;
  len = 20;
  dev_m &= 0x1f;
 } else if (protocols == RC_PROTO_BIT_SONY15) {
  len = 15;
  subdev_m = 0;
 } else {
  /*
 * The hardware mask cannot distinguish high device bits and low
 * extended bits, so logically AND those bits of the masks
 * together.
 */
  subdev_m &= (dev_m >> 5) | 0xf8;
  dev_m &= 0x1f;
 }

 /* ensure there aren't any bits straying between fields */
 dev &= dev_m;
 subdev &= subdev_m;

 /* write the hardware filter */
 out->data = func          |
      dev      << 7 |
      subdev   << 15;
 out->mask = func_m        |
      dev_m    << 7 |
      subdev_m << 15;

 if (len) {
  out->minlen = len;
  out->maxlen = len;
 }
 return 0;
}

/*
 * Sony SIRC decoder
 * See also http://www.sbprojects.com/knowledge/ir/sirc.php
 *          http://picprojects.org.uk/projects/sirc/sonysirc.pdf
 */
struct img_ir_decoder img_ir_sony = {
 .type = RC_PROTO_BIT_SONY12 | RC_PROTO_BIT_SONY15 | RC_PROTO_BIT_SONY20,
 .control = {
  .decoden = 1,
  .code_type = IMG_IR_CODETYPE_PULSELEN,
 },
 /* main timings */
 .unit = 600000, /* 600 us */
 .timings = {
  /* leader symbol */
  .ldr = {
   .pulse = { 4 /* 2.4 ms */ },
   .space = { 1 /* 600 us */ },
  },
  /* 0 symbol */
  .s00 = {
   .pulse = { 1 /* 600 us */ },
   .space = { 1 /* 600 us */ },
  },
  /* 1 symbol */
  .s01 = {
   .pulse = { 2 /* 1.2 ms */ },
   .space = { 1 /* 600 us */ },
  },
  /* free time */
  .ft = {
   .minlen = 12,
   .maxlen = 20,
   .ft_min = 10, /* 6 ms */
  },
 },
 /* scancode logic */
 .scancode = img_ir_sony_scancode,
 .filter = img_ir_sony_filter,
};