LXR linux/drivers/media/rc/rc-core-priv.h

   1/*
   2 * Remote Controller core raw events header
   3 *
   4 * Copyright (C) 2010 by Mauro Carvalho Chehab
   5 *
   6 * This program is free software; you can redistribute it and/or modify
   7 *  it under the terms of the GNU General Public License as published by
   8 *  the Free Software Foundation version 2 of the License.
   9 *
  10 *  This program is distributed in the hope that it will be useful,
  11 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 *  GNU General Public License for more details.
  14 */
  15
  16#ifndef _RC_CORE_PRIV
  17#define _RC_CORE_PRIV
  18
  19/* Define the max number of pulse/space transitions to buffer */
  20#define MAX_IR_EVENT_SIZE       512
  21
  22#include <linux/slab.h>
  23#include <linux/spinlock.h>
  24#include <media/rc-core.h>
  25
  26struct ir_raw_handler {
  27        struct list_head list;
  28
  29        u64 protocols; /* which are handled by this handler */
  30        int (*decode)(struct rc_dev *dev, struct ir_raw_event event);
  31
  32        /* These two should only be used by the lirc decoder */
  33        int (*raw_register)(struct rc_dev *dev);
  34        int (*raw_unregister)(struct rc_dev *dev);
  35};
  36
  37struct ir_raw_event_ctrl {
  38        struct list_head                list;           /* to keep track of raw clients */
  39        struct task_struct              *thread;
  40        spinlock_t                      lock;
  41        /* fifo for the pulse/space durations */
  42        DECLARE_KFIFO(kfifo, struct ir_raw_event, MAX_IR_EVENT_SIZE);
  43        ktime_t                         last_event;     /* when last event occurred */
  44        enum raw_event_type             last_type;      /* last event type */
  45        struct rc_dev                   *dev;           /* pointer to the parent rc_dev */
  46
  47        /* raw decoder state follows */
  48        struct ir_raw_event prev_ev;
  49        struct ir_raw_event this_ev;
  50        struct nec_dec {
  51                int state;
  52                unsigned count;
  53                u32 bits;
  54                bool is_nec_x;
  55                bool necx_repeat;
  56        } nec;
  57        struct rc5_dec {
  58                int state;
  59                u32 bits;
  60                unsigned count;
  61                bool is_rc5x;
  62        } rc5;
  63        struct rc6_dec {
  64                int state;
  65                u8 header;
  66                u32 body;
  67                bool toggle;
  68                unsigned count;
  69                unsigned wanted_bits;
  70        } rc6;
  71        struct sony_dec {
  72                int state;
  73                u32 bits;
  74                unsigned count;
  75        } sony;
  76        struct jvc_dec {
  77                int state;
  78                u16 bits;
  79                u16 old_bits;
  80                unsigned count;
  81                bool first;
  82                bool toggle;
  83        } jvc;
  84        struct sanyo_dec {
  85                int state;
  86                unsigned count;
  87                u64 bits;
  88        } sanyo;
  89        struct sharp_dec {
  90                int state;
  91                unsigned count;
  92                u32 bits;
  93                unsigned int pulse_len;
  94        } sharp;
  95        struct mce_kbd_dec {
  96                struct input_dev *idev;
  97                struct timer_list rx_timeout;
  98                char name[64];
  99                char phys[64];
 100                int state;
 101                u8 header;
 102                u32 body;
 103                unsigned count;
 104                unsigned wanted_bits;
 105        } mce_kbd;
 106        struct lirc_codec {
 107                struct rc_dev *dev;
 108                struct lirc_driver *drv;
 109                int carrier_low;
 110
 111                ktime_t gap_start;
 112                u64 gap_duration;
 113                bool gap;
 114                bool send_timeout_reports;
 115
 116        } lirc;
 117        struct xmp_dec {
 118                int state;
 119                unsigned count;
 120                u32 durations[16];
 121        } xmp;
 122};
 123
 124/* macros for IR decoders */
 125static inline bool geq_margin(unsigned d1, unsigned d2, unsigned margin)
 126{
 127        return d1 > (d2 - margin);
 128}
 129
 130static inline bool eq_margin(unsigned d1, unsigned d2, unsigned margin)
 131{
 132        return ((d1 > (d2 - margin)) && (d1 < (d2 + margin)));
 133}
 134
 135static inline bool is_transition(struct ir_raw_event *x, struct ir_raw_event *y)
 136{
 137        return x->pulse != y->pulse;
 138}
 139
 140static inline void decrease_duration(struct ir_raw_event *ev, unsigned duration)
 141{
 142        if (duration > ev->duration)
 143                ev->duration = 0;
 144        else
 145                ev->duration -= duration;
 146}
 147
 148/* Returns true if event is normal pulse/space event */
 149static inline bool is_timing_event(struct ir_raw_event ev)
 150{
 151        return !ev.carrier_report && !ev.reset;
 152}
 153
 154#define TO_US(duration)                 DIV_ROUND_CLOSEST((duration), 1000)
 155#define TO_STR(is_pulse)                ((is_pulse) ? "pulse" : "space")
 156
 157/*
 158 * Routines from rc-raw.c to be used internally and by decoders
 159 */
 160u64 ir_raw_get_allowed_protocols(void);
 161int ir_raw_event_register(struct rc_dev *dev);
 162void ir_raw_event_unregister(struct rc_dev *dev);
 163int ir_raw_handler_register(struct ir_raw_handler *ir_raw_handler);
 164void ir_raw_handler_unregister(struct ir_raw_handler *ir_raw_handler);
 165void ir_raw_init(void);
 166
 167/*
 168 * Decoder initialization code
 169 *
 170 * Those load logic are called during ir-core init, and automatically
 171 * loads the compiled decoders for their usage with IR raw events
 172 */
 173
 174#endif /* _RC_CORE_PRIV */
 175