Branch data     Line data    Source code

       1                 :            : /*
       2                 :            :  * SPDX-License-Identifier: GPL-2.0
       3                 :            :  * Remote Controller core raw events header
       4                 :            :  *
       5                 :            :  * Copyright (C) 2010 by Mauro Carvalho Chehab
       6                 :            :  */
       7                 :            : 
       8                 :            : #ifndef _RC_CORE_PRIV
       9                 :            : #define _RC_CORE_PRIV
      10                 :            : 
      11                 :            : #define RC_DEV_MAX              256
      12                 :            : /* Define the max number of pulse/space transitions to buffer */
      13                 :            : #define MAX_IR_EVENT_SIZE       512
      14                 :            : 
      15                 :            : #include <linux/slab.h>
      16                 :            : #include <uapi/linux/bpf.h>
      17                 :            : #include <media/rc-core.h>
      18                 :            : 
      19                 :            : /**
      20                 :            :  * rc_open - Opens a RC device
      21                 :            :  *
      22                 :            :  * @rdev: pointer to struct rc_dev.
      23                 :            :  */
      24                 :            : int rc_open(struct rc_dev *rdev);
      25                 :            : 
      26                 :            : /**
      27                 :            :  * rc_close - Closes a RC device
      28                 :            :  *
      29                 :            :  * @rdev: pointer to struct rc_dev.
      30                 :            :  */
      31                 :            : void rc_close(struct rc_dev *rdev);
      32                 :            : 
      33                 :            : struct ir_raw_handler {
      34                 :            :         struct list_head list;
      35                 :            : 
      36                 :            :         u64 protocols; /* which are handled by this handler */
      37                 :            :         int (*decode)(struct rc_dev *dev, struct ir_raw_event event);
      38                 :            :         int (*encode)(enum rc_proto protocol, u32 scancode,
      39                 :            :                       struct ir_raw_event *events, unsigned int max);
      40                 :            :         u32 carrier;
      41                 :            :         u32 min_timeout;
      42                 :            : 
      43                 :            :         /* These two should only be used by the mce kbd decoder */
      44                 :            :         int (*raw_register)(struct rc_dev *dev);
      45                 :            :         int (*raw_unregister)(struct rc_dev *dev);
      46                 :            : };
      47                 :            : 
      48                 :            : struct ir_raw_event_ctrl {
      49                 :            :         struct list_head                list;           /* to keep track of raw clients */
      50                 :            :         struct task_struct              *thread;
      51                 :            :         /* fifo for the pulse/space durations */
      52                 :            :         DECLARE_KFIFO(kfifo, struct ir_raw_event, MAX_IR_EVENT_SIZE);
      53                 :            :         ktime_t                         last_event;     /* when last event occurred */
      54                 :            :         struct rc_dev                   *dev;           /* pointer to the parent rc_dev */
      55                 :            :         /* handle delayed ir_raw_event_store_edge processing */
      56                 :            :         spinlock_t                      edge_spinlock;
      57                 :            :         struct timer_list               edge_handle;
      58                 :            : 
      59                 :            :         /* raw decoder state follows */
      60                 :            :         struct ir_raw_event prev_ev;
      61                 :            :         struct ir_raw_event this_ev;
      62                 :            : 
      63                 :            : #ifdef CONFIG_BPF_LIRC_MODE2
      64                 :            :         u32                             bpf_sample;
      65                 :            :         struct bpf_prog_array __rcu     *progs;
      66                 :            : #endif
      67                 :            :         struct nec_dec {
      68                 :            :                 int state;
      69                 :            :                 unsigned count;
      70                 :            :                 u32 bits;
      71                 :            :                 bool is_nec_x;
      72                 :            :                 bool necx_repeat;
      73                 :            :         } nec;
      74                 :            :         struct rc5_dec {
      75                 :            :                 int state;
      76                 :            :                 u32 bits;
      77                 :            :                 unsigned count;
      78                 :            :                 bool is_rc5x;
      79                 :            :         } rc5;
      80                 :            :         struct rc6_dec {
      81                 :            :                 int state;
      82                 :            :                 u8 header;
      83                 :            :                 u32 body;
      84                 :            :                 bool toggle;
      85                 :            :                 unsigned count;
      86                 :            :                 unsigned wanted_bits;
      87                 :            :         } rc6;
      88                 :            :         struct sony_dec {
      89                 :            :                 int state;
      90                 :            :                 u32 bits;
      91                 :            :                 unsigned count;
      92                 :            :         } sony;
      93                 :            :         struct jvc_dec {
      94                 :            :                 int state;
      95                 :            :                 u16 bits;
      96                 :            :                 u16 old_bits;
      97                 :            :                 unsigned count;
      98                 :            :                 bool first;
      99                 :            :                 bool toggle;
     100                 :            :         } jvc;
     101                 :            :         struct sanyo_dec {
     102                 :            :                 int state;
     103                 :            :                 unsigned count;
     104                 :            :                 u64 bits;
     105                 :            :         } sanyo;
     106                 :            :         struct sharp_dec {
     107                 :            :                 int state;
     108                 :            :                 unsigned count;
     109                 :            :                 u32 bits;
     110                 :            :                 unsigned int pulse_len;
     111                 :            :         } sharp;
     112                 :            :         struct mce_kbd_dec {
     113                 :            :                 /* locks key up timer */
     114                 :            :                 spinlock_t keylock;
     115                 :            :                 struct timer_list rx_timeout;
     116                 :            :                 int state;
     117                 :            :                 u8 header;
     118                 :            :                 u32 body;
     119                 :            :                 unsigned count;
     120                 :            :                 unsigned wanted_bits;
     121                 :            :         } mce_kbd;
     122                 :            :         struct xmp_dec {
     123                 :            :                 int state;
     124                 :            :                 unsigned count;
     125                 :            :                 u32 durations[16];
     126                 :            :         } xmp;
     127                 :            :         struct imon_dec {
     128                 :            :                 int state;
     129                 :            :                 int count;
     130                 :            :                 int last_chk;
     131                 :            :                 unsigned int bits;
     132                 :            :                 bool stick_keyboard;
     133                 :            :         } imon;
     134                 :            :         struct rcmm_dec {
     135                 :            :                 int state;
     136                 :            :                 unsigned int count;
     137                 :            :                 u32 bits;
     138                 :            :         } rcmm;
     139                 :            : };
     140                 :            : 
     141                 :            : /* Mutex for locking raw IR processing and handler change */
     142                 :            : extern struct mutex ir_raw_handler_lock;
     143                 :            : 
     144                 :            : /* macros for IR decoders */
     145                 :            : static inline bool geq_margin(unsigned d1, unsigned d2, unsigned margin)
     146                 :            : {
     147                 :            :         return d1 > (d2 - margin);
     148                 :            : }
     149                 :            : 
     150                 :            : static inline bool eq_margin(unsigned d1, unsigned d2, unsigned margin)
     151                 :            : {
     152                 :            :         return ((d1 > (d2 - margin)) && (d1 < (d2 + margin)));
     153                 :            : }
     154                 :            : 
     155                 :            : static inline bool is_transition(struct ir_raw_event *x, struct ir_raw_event *y)
     156                 :            : {
     157                 :          0 :         return x->pulse != y->pulse;
     158                 :            : }
     159                 :            : 
     160                 :            : static inline void decrease_duration(struct ir_raw_event *ev, unsigned duration)
     161                 :            : {
     162                 :            :         if (duration > ev->duration)
     163                 :            :                 ev->duration = 0;
     164                 :            :         else
     165                 :            :                 ev->duration -= duration;
     166                 :            : }
     167                 :            : 
     168                 :            : /* Returns true if event is normal pulse/space event */
     169                 :            : static inline bool is_timing_event(struct ir_raw_event ev)
     170                 :            : {
     171                 :          0 :         return !ev.carrier_report && !ev.reset;
     172                 :            : }
     173                 :            : 
     174                 :            : #define TO_US(duration)                 DIV_ROUND_CLOSEST((duration), 1000)
     175                 :            : #define TO_STR(is_pulse)                ((is_pulse) ? "pulse" : "space")
     176                 :            : 
     177                 :            : /* functions for IR encoders */
     178                 :            : bool rc_validate_scancode(enum rc_proto proto, u32 scancode);
     179                 :            : 
     180                 :            : static inline void init_ir_raw_event_duration(struct ir_raw_event *ev,
     181                 :            :                                               unsigned int pulse,
     182                 :            :                                               u32 duration)
     183                 :            : {
     184                 :          0 :         *ev = (struct ir_raw_event) {
     185                 :            :                 .duration = duration,
     186                 :            :                 .pulse = pulse
     187                 :            :         };
     188                 :            : }
     189                 :            : 
     190                 :            : /**
     191                 :            :  * struct ir_raw_timings_manchester - Manchester coding timings
     192                 :            :  * @leader_pulse:       duration of leader pulse (if any) 0 if continuing
     193                 :            :  *                      existing signal
     194                 :            :  * @leader_space:       duration of leader space (if any)
     195                 :            :  * @clock:              duration of each pulse/space in ns
     196                 :            :  * @invert:             if set clock logic is inverted
     197                 :            :  *                      (0 = space + pulse, 1 = pulse + space)
     198                 :            :  * @trailer_space:      duration of trailer space in ns
     199                 :            :  */
     200                 :            : struct ir_raw_timings_manchester {
     201                 :            :         unsigned int leader_pulse;
     202                 :            :         unsigned int leader_space;
     203                 :            :         unsigned int clock;
     204                 :            :         unsigned int invert:1;
     205                 :            :         unsigned int trailer_space;
     206                 :            : };
     207                 :            : 
     208                 :            : int ir_raw_gen_manchester(struct ir_raw_event **ev, unsigned int max,
     209                 :            :                           const struct ir_raw_timings_manchester *timings,
     210                 :            :                           unsigned int n, u64 data);
     211                 :            : 
     212                 :            : /**
     213                 :            :  * ir_raw_gen_pulse_space() - generate pulse and space raw events.
     214                 :            :  * @ev:                 Pointer to pointer to next free raw event.
     215                 :            :  *                      Will be incremented for each raw event written.
     216                 :            :  * @max:                Pointer to number of raw events available in buffer.
     217                 :            :  *                      Will be decremented for each raw event written.
     218                 :            :  * @pulse_width:        Width of pulse in ns.
     219                 :            :  * @space_width:        Width of space in ns.
     220                 :            :  *
     221                 :            :  * Returns:     0 on success.
     222                 :            :  *              -ENOBUFS if there isn't enough buffer space to write both raw
     223                 :            :  *              events. In this case @max events will have been written.
     224                 :            :  */
     225                 :          0 : static inline int ir_raw_gen_pulse_space(struct ir_raw_event **ev,
     226                 :            :                                          unsigned int *max,
     227                 :            :                                          unsigned int pulse_width,
     228                 :            :                                          unsigned int space_width)
     229                 :            : {
     230                 :          0 :         if (!*max)
     231                 :            :                 return -ENOBUFS;
     232                 :          0 :         init_ir_raw_event_duration((*ev)++, 1, pulse_width);
     233                 :          0 :         if (!--*max)
     234                 :            :                 return -ENOBUFS;
     235                 :          0 :         init_ir_raw_event_duration((*ev)++, 0, space_width);
     236                 :          0 :         --*max;
     237                 :          0 :         return 0;
     238                 :            : }
     239                 :            : 
     240                 :            : /**
     241                 :            :  * struct ir_raw_timings_pd - pulse-distance modulation timings
     242                 :            :  * @header_pulse:       duration of header pulse in ns (0 for none)
     243                 :            :  * @header_space:       duration of header space in ns
     244                 :            :  * @bit_pulse:          duration of bit pulse in ns
     245                 :            :  * @bit_space:          duration of bit space (for logic 0 and 1) in ns
     246                 :            :  * @trailer_pulse:      duration of trailer pulse in ns
     247                 :            :  * @trailer_space:      duration of trailer space in ns
     248                 :            :  * @msb_first:          1 if most significant bit is sent first
     249                 :            :  */
     250                 :            : struct ir_raw_timings_pd {
     251                 :            :         unsigned int header_pulse;
     252                 :            :         unsigned int header_space;
     253                 :            :         unsigned int bit_pulse;
     254                 :            :         unsigned int bit_space[2];
     255                 :            :         unsigned int trailer_pulse;
     256                 :            :         unsigned int trailer_space;
     257                 :            :         unsigned int msb_first:1;
     258                 :            : };
     259                 :            : 
     260                 :            : int ir_raw_gen_pd(struct ir_raw_event **ev, unsigned int max,
     261                 :            :                   const struct ir_raw_timings_pd *timings,
     262                 :            :                   unsigned int n, u64 data);
     263                 :            : 
     264                 :            : /**
     265                 :            :  * struct ir_raw_timings_pl - pulse-length modulation timings
     266                 :            :  * @header_pulse:       duration of header pulse in ns (0 for none)
     267                 :            :  * @bit_space:          duration of bit space in ns
     268                 :            :  * @bit_pulse:          duration of bit pulse (for logic 0 and 1) in ns
     269                 :            :  * @trailer_space:      duration of trailer space in ns
     270                 :            :  * @msb_first:          1 if most significant bit is sent first
     271                 :            :  */
     272                 :            : struct ir_raw_timings_pl {
     273                 :            :         unsigned int header_pulse;
     274                 :            :         unsigned int bit_space;
     275                 :            :         unsigned int bit_pulse[2];
     276                 :            :         unsigned int trailer_space;
     277                 :            :         unsigned int msb_first:1;
     278                 :            : };
     279                 :            : 
     280                 :            : int ir_raw_gen_pl(struct ir_raw_event **ev, unsigned int max,
     281                 :            :                   const struct ir_raw_timings_pl *timings,
     282                 :            :                   unsigned int n, u64 data);
     283                 :            : 
     284                 :            : /*
     285                 :            :  * Routines from rc-raw.c to be used internally and by decoders
     286                 :            :  */
     287                 :            : u64 ir_raw_get_allowed_protocols(void);
     288                 :            : int ir_raw_event_prepare(struct rc_dev *dev);
     289                 :            : int ir_raw_event_register(struct rc_dev *dev);
     290                 :            : void ir_raw_event_free(struct rc_dev *dev);
     291                 :            : void ir_raw_event_unregister(struct rc_dev *dev);
     292                 :            : int ir_raw_handler_register(struct ir_raw_handler *ir_raw_handler);
     293                 :            : void ir_raw_handler_unregister(struct ir_raw_handler *ir_raw_handler);
     294                 :            : void ir_raw_load_modules(u64 *protocols);
     295                 :            : void ir_raw_init(void);
     296                 :            : 
     297                 :            : /*
     298                 :            :  * lirc interface
     299                 :            :  */
     300                 :            : #ifdef CONFIG_LIRC
     301                 :            : int lirc_dev_init(void);
     302                 :            : void lirc_dev_exit(void);
     303                 :            : void ir_lirc_raw_event(struct rc_dev *dev, struct ir_raw_event ev);
     304                 :            : void ir_lirc_scancode_event(struct rc_dev *dev, struct lirc_scancode *lsc);
     305                 :            : int ir_lirc_register(struct rc_dev *dev);
     306                 :            : void ir_lirc_unregister(struct rc_dev *dev);
     307                 :            : struct rc_dev *rc_dev_get_from_fd(int fd);
     308                 :            : #else
     309                 :            : static inline int lirc_dev_init(void) { return 0; }
     310                 :            : static inline void lirc_dev_exit(void) {}
     311                 :            : static inline void ir_lirc_raw_event(struct rc_dev *dev,
     312                 :            :                                      struct ir_raw_event ev) { }
     313                 :            : static inline void ir_lirc_scancode_event(struct rc_dev *dev,
     314                 :            :                                           struct lirc_scancode *lsc) { }
     315                 :            : static inline int ir_lirc_register(struct rc_dev *dev) { return 0; }
     316                 :            : static inline void ir_lirc_unregister(struct rc_dev *dev) { }
     317                 :            : #endif
     318                 :            : 
     319                 :            : /*
     320                 :            :  * bpf interface
     321                 :            :  */
     322                 :            : #ifdef CONFIG_BPF_LIRC_MODE2
     323                 :            : void lirc_bpf_free(struct rc_dev *dev);
     324                 :            : void lirc_bpf_run(struct rc_dev *dev, u32 sample);
     325                 :            : #else
     326                 :            : static inline void lirc_bpf_free(struct rc_dev *dev) { }
     327                 :            : static inline void lirc_bpf_run(struct rc_dev *dev, u32 sample) { }
     328                 :            : #endif
     329                 :            : 
     330                 :            : #endif /* _RC_CORE_PRIV */