120835280SMauro Carvalho Chehab // SPDX-License-Identifier: GPL-2.0
220835280SMauro Carvalho Chehab // rc-ir-raw.c - handle IR pulse/space events
320835280SMauro Carvalho Chehab //
420835280SMauro Carvalho Chehab // Copyright (C) 2010 by Mauro Carvalho Chehab
54924a311SDavid Härdeman
64924a311SDavid Härdeman #include <linux/export.h>
74924a311SDavid Härdeman #include <linux/kthread.h>
84924a311SDavid Härdeman #include <linux/mutex.h>
94924a311SDavid Härdeman #include <linux/kmod.h>
104924a311SDavid Härdeman #include <linux/sched.h>
114924a311SDavid Härdeman #include "rc-core-priv.h"
124924a311SDavid Härdeman
134924a311SDavid Härdeman /* Used to keep track of IR raw clients, protected by ir_raw_handler_lock */
144924a311SDavid Härdeman static LIST_HEAD(ir_raw_client_list);
154924a311SDavid Härdeman
164924a311SDavid Härdeman /* Used to handle IR raw handler extensions */
17f4364dcfSSean Young DEFINE_MUTEX(ir_raw_handler_lock);
184924a311SDavid Härdeman static LIST_HEAD(ir_raw_handler_list);
1937e90a22SHeiner Kallweit static atomic64_t available_protocols = ATOMIC64_INIT(0);
204924a311SDavid Härdeman
ir_raw_event_thread(void * data)214924a311SDavid Härdeman static int ir_raw_event_thread(void *data)
224924a311SDavid Härdeman {
234924a311SDavid Härdeman struct ir_raw_event ev;
244924a311SDavid Härdeman struct ir_raw_handler *handler;
2548231f28SSean Young struct ir_raw_event_ctrl *raw = data;
2648231f28SSean Young struct rc_dev *dev = raw->dev;
274924a311SDavid Härdeman
2874d47d75SHeiner Kallweit while (1) {
294924a311SDavid Härdeman mutex_lock(&ir_raw_handler_lock);
3074d47d75SHeiner Kallweit while (kfifo_out(&raw->kfifo, &ev, 1)) {
3148231f28SSean Young if (is_timing_event(ev)) {
3248231f28SSean Young if (ev.duration == 0)
330ca54b29SSean Young dev_warn_once(&dev->dev, "nonsensical timing event of duration 0");
3448231f28SSean Young if (is_timing_event(raw->prev_ev) &&
3548231f28SSean Young !is_transition(&ev, &raw->prev_ev))
360ca54b29SSean Young dev_warn_once(&dev->dev, "two consecutive events of type %s",
3748231f28SSean Young TO_STR(ev.pulse));
3848231f28SSean Young }
394924a311SDavid Härdeman list_for_each_entry(handler, &ir_raw_handler_list, list)
4048231f28SSean Young if (dev->enabled_protocols &
4174d47d75SHeiner Kallweit handler->protocols || !handler->protocols)
4248231f28SSean Young handler->decode(dev, ev);
4375992a44SSean Young lirc_raw_event(dev, ev);
444924a311SDavid Härdeman raw->prev_ev = ev;
4574d47d75SHeiner Kallweit }
464924a311SDavid Härdeman mutex_unlock(&ir_raw_handler_lock);
4774d47d75SHeiner Kallweit
4874d47d75SHeiner Kallweit set_current_state(TASK_INTERRUPTIBLE);
4974d47d75SHeiner Kallweit
5074d47d75SHeiner Kallweit if (kthread_should_stop()) {
5174d47d75SHeiner Kallweit __set_current_state(TASK_RUNNING);
5274d47d75SHeiner Kallweit break;
5374d47d75SHeiner Kallweit } else if (!kfifo_is_empty(&raw->kfifo))
5474d47d75SHeiner Kallweit set_current_state(TASK_RUNNING);
5574d47d75SHeiner Kallweit
5674d47d75SHeiner Kallweit schedule();
574924a311SDavid Härdeman }
584924a311SDavid Härdeman
594924a311SDavid Härdeman return 0;
604924a311SDavid Härdeman }
614924a311SDavid Härdeman
624924a311SDavid Härdeman /**
634924a311SDavid Härdeman * ir_raw_event_store() - pass a pulse/space duration to the raw ir decoders
644924a311SDavid Härdeman * @dev: the struct rc_dev device descriptor
654924a311SDavid Härdeman * @ev: the struct ir_raw_event descriptor of the pulse/space
664924a311SDavid Härdeman *
674924a311SDavid Härdeman * This routine (which may be called from an interrupt context) stores a
684924a311SDavid Härdeman * pulse/space duration for the raw ir decoding state machines. Pulses are
694924a311SDavid Härdeman * signalled as positive values and spaces as negative values. A zero value
704924a311SDavid Härdeman * will reset the decoding state machines.
714924a311SDavid Härdeman */
ir_raw_event_store(struct rc_dev * dev,struct ir_raw_event * ev)724924a311SDavid Härdeman int ir_raw_event_store(struct rc_dev *dev, struct ir_raw_event *ev)
734924a311SDavid Härdeman {
744924a311SDavid Härdeman if (!dev->raw)
754924a311SDavid Härdeman return -EINVAL;
764924a311SDavid Härdeman
771f17f684SSean Young dev_dbg(&dev->dev, "sample: (%05dus %s)\n",
78528222d8SSean Young ev->duration, TO_STR(ev->pulse));
794924a311SDavid Härdeman
80464254e5SHeiner Kallweit if (!kfifo_put(&dev->raw->kfifo, *ev)) {
81464254e5SHeiner Kallweit dev_err(&dev->dev, "IR event FIFO is full!\n");
82464254e5SHeiner Kallweit return -ENOSPC;
83464254e5SHeiner Kallweit }
844924a311SDavid Härdeman
854924a311SDavid Härdeman return 0;
864924a311SDavid Härdeman }
874924a311SDavid Härdeman EXPORT_SYMBOL_GPL(ir_raw_event_store);
884924a311SDavid Härdeman
894924a311SDavid Härdeman /**
904924a311SDavid Härdeman * ir_raw_event_store_edge() - notify raw ir decoders of the start of a pulse/space
914924a311SDavid Härdeman * @dev: the struct rc_dev device descriptor
9286fe1ac0SSean Young * @pulse: true for pulse, false for space
934924a311SDavid Härdeman *
944924a311SDavid Härdeman * This routine (which may be called from an interrupt context) is used to
954924a311SDavid Härdeman * store the beginning of an ir pulse or space (or the start/end of ir
964924a311SDavid Härdeman * reception) for the raw ir decoding state machines. This is used by
974924a311SDavid Härdeman * hardware which does not provide durations directly but only interrupts
984924a311SDavid Härdeman * (or similar events) on state change.
994924a311SDavid Härdeman */
ir_raw_event_store_edge(struct rc_dev * dev,bool pulse)10086fe1ac0SSean Young int ir_raw_event_store_edge(struct rc_dev *dev, bool pulse)
1014924a311SDavid Härdeman {
1024924a311SDavid Härdeman ktime_t now;
103183e19f5SSean Young struct ir_raw_event ev = {};
1044924a311SDavid Härdeman
1054924a311SDavid Härdeman if (!dev->raw)
1064924a311SDavid Härdeman return -EINVAL;
1074924a311SDavid Härdeman
1084924a311SDavid Härdeman now = ktime_get();
109528222d8SSean Young ev.duration = ktime_to_us(ktime_sub(now, dev->raw->last_event));
11086fe1ac0SSean Young ev.pulse = !pulse;
1114924a311SDavid Härdeman
1128d7a77ceSSean Young return ir_raw_event_store_with_timeout(dev, &ev);
1138d7a77ceSSean Young }
1148d7a77ceSSean Young EXPORT_SYMBOL_GPL(ir_raw_event_store_edge);
1158d7a77ceSSean Young
1168d7a77ceSSean Young /*
1178d7a77ceSSean Young * ir_raw_event_store_with_timeout() - pass a pulse/space duration to the raw
1188d7a77ceSSean Young * ir decoders, schedule decoding and
1198d7a77ceSSean Young * timeout
1208d7a77ceSSean Young * @dev: the struct rc_dev device descriptor
1218d7a77ceSSean Young * @ev: the struct ir_raw_event descriptor of the pulse/space
1228d7a77ceSSean Young *
1238d7a77ceSSean Young * This routine (which may be called from an interrupt context) stores a
1248d7a77ceSSean Young * pulse/space duration for the raw ir decoding state machines, schedules
1258d7a77ceSSean Young * decoding and generates a timeout.
1268d7a77ceSSean Young */
ir_raw_event_store_with_timeout(struct rc_dev * dev,struct ir_raw_event * ev)1278d7a77ceSSean Young int ir_raw_event_store_with_timeout(struct rc_dev *dev, struct ir_raw_event *ev)
1288d7a77ceSSean Young {
1298d7a77ceSSean Young ktime_t now;
1308d7a77ceSSean Young int rc = 0;
1318d7a77ceSSean Young
1328d7a77ceSSean Young if (!dev->raw)
1338d7a77ceSSean Young return -EINVAL;
1348d7a77ceSSean Young
1358d7a77ceSSean Young now = ktime_get();
1368d7a77ceSSean Young
137e3e389f9SSean Young spin_lock(&dev->raw->edge_spinlock);
1388d7a77ceSSean Young rc = ir_raw_event_store(dev, ev);
1394924a311SDavid Härdeman
1404924a311SDavid Härdeman dev->raw->last_event = now;
141e5e26439SSean Young
14248b2de19SSean Young /* timer could be set to timeout (125ms by default) */
14348b2de19SSean Young if (!timer_pending(&dev->raw->edge_handle) ||
14448b2de19SSean Young time_after(dev->raw->edge_handle.expires,
14548b2de19SSean Young jiffies + msecs_to_jiffies(15))) {
146e5e26439SSean Young mod_timer(&dev->raw->edge_handle,
147e5e26439SSean Young jiffies + msecs_to_jiffies(15));
14848b2de19SSean Young }
149e3e389f9SSean Young spin_unlock(&dev->raw->edge_spinlock);
150e5e26439SSean Young
1514924a311SDavid Härdeman return rc;
1524924a311SDavid Härdeman }
1538d7a77ceSSean Young EXPORT_SYMBOL_GPL(ir_raw_event_store_with_timeout);
1544924a311SDavid Härdeman
1554924a311SDavid Härdeman /**
1564924a311SDavid Härdeman * ir_raw_event_store_with_filter() - pass next pulse/space to decoders with some processing
1574924a311SDavid Härdeman * @dev: the struct rc_dev device descriptor
158c4365922SMauro Carvalho Chehab * @ev: the event that has occurred
1594924a311SDavid Härdeman *
1604924a311SDavid Härdeman * This routine (which may be called from an interrupt context) works
1614924a311SDavid Härdeman * in similar manner to ir_raw_event_store_edge.
1624924a311SDavid Härdeman * This routine is intended for devices with limited internal buffer
1634924a311SDavid Härdeman * It automerges samples of same type, and handles timeouts. Returns non-zero
1644924a311SDavid Härdeman * if the event was added, and zero if the event was ignored due to idle
1654924a311SDavid Härdeman * processing.
1664924a311SDavid Härdeman */
ir_raw_event_store_with_filter(struct rc_dev * dev,struct ir_raw_event * ev)1674924a311SDavid Härdeman int ir_raw_event_store_with_filter(struct rc_dev *dev, struct ir_raw_event *ev)
1684924a311SDavid Härdeman {
1694924a311SDavid Härdeman if (!dev->raw)
1704924a311SDavid Härdeman return -EINVAL;
1714924a311SDavid Härdeman
1724924a311SDavid Härdeman /* Ignore spaces in idle mode */
1734924a311SDavid Härdeman if (dev->idle && !ev->pulse)
1744924a311SDavid Härdeman return 0;
1754924a311SDavid Härdeman else if (dev->idle)
1764924a311SDavid Härdeman ir_raw_event_set_idle(dev, false);
1774924a311SDavid Härdeman
1784924a311SDavid Härdeman if (!dev->raw->this_ev.duration)
1794924a311SDavid Härdeman dev->raw->this_ev = *ev;
1804924a311SDavid Härdeman else if (ev->pulse == dev->raw->this_ev.pulse)
1814924a311SDavid Härdeman dev->raw->this_ev.duration += ev->duration;
1824924a311SDavid Härdeman else {
1834924a311SDavid Härdeman ir_raw_event_store(dev, &dev->raw->this_ev);
1844924a311SDavid Härdeman dev->raw->this_ev = *ev;
1854924a311SDavid Härdeman }
1864924a311SDavid Härdeman
18704ad3011SMauro Carvalho Chehab /* Enter idle mode if necessary */
1884924a311SDavid Härdeman if (!ev->pulse && dev->timeout &&
1894924a311SDavid Härdeman dev->raw->this_ev.duration >= dev->timeout)
1904924a311SDavid Härdeman ir_raw_event_set_idle(dev, true);
1914924a311SDavid Härdeman
1924924a311SDavid Härdeman return 1;
1934924a311SDavid Härdeman }
1944924a311SDavid Härdeman EXPORT_SYMBOL_GPL(ir_raw_event_store_with_filter);
1954924a311SDavid Härdeman
1964924a311SDavid Härdeman /**
1974924a311SDavid Härdeman * ir_raw_event_set_idle() - provide hint to rc-core when the device is idle or not
1984924a311SDavid Härdeman * @dev: the struct rc_dev device descriptor
1994924a311SDavid Härdeman * @idle: whether the device is idle or not
2004924a311SDavid Härdeman */
ir_raw_event_set_idle(struct rc_dev * dev,bool idle)2014924a311SDavid Härdeman void ir_raw_event_set_idle(struct rc_dev *dev, bool idle)
2024924a311SDavid Härdeman {
2034924a311SDavid Härdeman if (!dev->raw)
2044924a311SDavid Härdeman return;
2054924a311SDavid Härdeman
2061f17f684SSean Young dev_dbg(&dev->dev, "%s idle mode\n", idle ? "enter" : "leave");
2074924a311SDavid Härdeman
2084924a311SDavid Härdeman if (idle) {
2094924a311SDavid Härdeman dev->raw->this_ev.timeout = true;
2104924a311SDavid Härdeman ir_raw_event_store(dev, &dev->raw->this_ev);
211183e19f5SSean Young dev->raw->this_ev = (struct ir_raw_event) {};
2124924a311SDavid Härdeman }
2134924a311SDavid Härdeman
2144924a311SDavid Härdeman if (dev->s_idle)
2154924a311SDavid Härdeman dev->s_idle(dev, idle);
2164924a311SDavid Härdeman
2174924a311SDavid Härdeman dev->idle = idle;
2184924a311SDavid Härdeman }
2194924a311SDavid Härdeman EXPORT_SYMBOL_GPL(ir_raw_event_set_idle);
2204924a311SDavid Härdeman
2214924a311SDavid Härdeman /**
2224924a311SDavid Härdeman * ir_raw_event_handle() - schedules the decoding of stored ir data
2234924a311SDavid Härdeman * @dev: the struct rc_dev device descriptor
2244924a311SDavid Härdeman *
2254924a311SDavid Härdeman * This routine will tell rc-core to start decoding stored ir data.
2264924a311SDavid Härdeman */
ir_raw_event_handle(struct rc_dev * dev)2274924a311SDavid Härdeman void ir_raw_event_handle(struct rc_dev *dev)
2284924a311SDavid Härdeman {
229963761a0SSean Young if (!dev->raw || !dev->raw->thread)
2304924a311SDavid Härdeman return;
2314924a311SDavid Härdeman
2324924a311SDavid Härdeman wake_up_process(dev->raw->thread);
2334924a311SDavid Härdeman }
2344924a311SDavid Härdeman EXPORT_SYMBOL_GPL(ir_raw_event_handle);
2354924a311SDavid Härdeman
2364924a311SDavid Härdeman /* used internally by the sysfs interface */
2374924a311SDavid Härdeman u64
ir_raw_get_allowed_protocols(void)2384924a311SDavid Härdeman ir_raw_get_allowed_protocols(void)
2394924a311SDavid Härdeman {
24037e90a22SHeiner Kallweit return atomic64_read(&available_protocols);
2414924a311SDavid Härdeman }
2424924a311SDavid Härdeman
change_protocol(struct rc_dev * dev,u64 * rc_proto)2436d741bfeSSean Young static int change_protocol(struct rc_dev *dev, u64 *rc_proto)
2444924a311SDavid Härdeman {
245a86d6df8SSean Young struct ir_raw_handler *handler;
246a86d6df8SSean Young u32 timeout = 0;
247a86d6df8SSean Young
248c00cb587SSean Young mutex_lock(&ir_raw_handler_lock);
249c00cb587SSean Young list_for_each_entry(handler, &ir_raw_handler_list, list) {
250c00cb587SSean Young if (!(dev->enabled_protocols & handler->protocols) &&
251c00cb587SSean Young (*rc_proto & handler->protocols) && handler->raw_register)
252c00cb587SSean Young handler->raw_register(dev);
253c00cb587SSean Young
254c00cb587SSean Young if ((dev->enabled_protocols & handler->protocols) &&
255c00cb587SSean Young !(*rc_proto & handler->protocols) &&
256c00cb587SSean Young handler->raw_unregister)
257c00cb587SSean Young handler->raw_unregister(dev);
258c00cb587SSean Young }
259c00cb587SSean Young mutex_unlock(&ir_raw_handler_lock);
260c00cb587SSean Young
261a86d6df8SSean Young if (!dev->max_timeout)
262a86d6df8SSean Young return 0;
263a86d6df8SSean Young
264a86d6df8SSean Young mutex_lock(&ir_raw_handler_lock);
265a86d6df8SSean Young list_for_each_entry(handler, &ir_raw_handler_list, list) {
266a86d6df8SSean Young if (handler->protocols & *rc_proto) {
267a86d6df8SSean Young if (timeout < handler->min_timeout)
268a86d6df8SSean Young timeout = handler->min_timeout;
269a86d6df8SSean Young }
270a86d6df8SSean Young }
271a86d6df8SSean Young mutex_unlock(&ir_raw_handler_lock);
272a86d6df8SSean Young
273a86d6df8SSean Young if (timeout == 0)
274a86d6df8SSean Young timeout = IR_DEFAULT_TIMEOUT;
275a86d6df8SSean Young else
276528222d8SSean Young timeout += MS_TO_US(10);
277a86d6df8SSean Young
278a86d6df8SSean Young if (timeout < dev->min_timeout)
279a86d6df8SSean Young timeout = dev->min_timeout;
280a86d6df8SSean Young else if (timeout > dev->max_timeout)
281a86d6df8SSean Young timeout = dev->max_timeout;
282a86d6df8SSean Young
283a86d6df8SSean Young if (dev->s_timeout)
284a86d6df8SSean Young dev->s_timeout(dev, timeout);
285a86d6df8SSean Young else
286a86d6df8SSean Young dev->timeout = timeout;
287a86d6df8SSean Young
2884924a311SDavid Härdeman return 0;
2894924a311SDavid Härdeman }
2904924a311SDavid Härdeman
ir_raw_disable_protocols(struct rc_dev * dev,u64 protocols)29193cffffcSHeiner Kallweit static void ir_raw_disable_protocols(struct rc_dev *dev, u64 protocols)
29293cffffcSHeiner Kallweit {
29393cffffcSHeiner Kallweit mutex_lock(&dev->lock);
29493cffffcSHeiner Kallweit dev->enabled_protocols &= ~protocols;
29593cffffcSHeiner Kallweit mutex_unlock(&dev->lock);
29693cffffcSHeiner Kallweit }
29793cffffcSHeiner Kallweit
2983875233dSJames Hogan /**
299844a4f45SAntti Seppälä * ir_raw_gen_manchester() - Encode data with Manchester (bi-phase) modulation.
300844a4f45SAntti Seppälä * @ev: Pointer to pointer to next free event. *@ev is incremented for
301844a4f45SAntti Seppälä * each raw event filled.
302844a4f45SAntti Seppälä * @max: Maximum number of raw events to fill.
303844a4f45SAntti Seppälä * @timings: Manchester modulation timings.
304844a4f45SAntti Seppälä * @n: Number of bits of data.
305844a4f45SAntti Seppälä * @data: Data bits to encode.
306844a4f45SAntti Seppälä *
307844a4f45SAntti Seppälä * Encodes the @n least significant bits of @data using Manchester (bi-phase)
308844a4f45SAntti Seppälä * modulation with the timing characteristics described by @timings, writing up
309844a4f45SAntti Seppälä * to @max raw IR events using the *@ev pointer.
310844a4f45SAntti Seppälä *
311844a4f45SAntti Seppälä * Returns: 0 on success.
312844a4f45SAntti Seppälä * -ENOBUFS if there isn't enough space in the array to fit the
313844a4f45SAntti Seppälä * full encoded data. In this case all @max events will have been
314844a4f45SAntti Seppälä * written.
315844a4f45SAntti Seppälä */
ir_raw_gen_manchester(struct ir_raw_event ** ev,unsigned int max,const struct ir_raw_timings_manchester * timings,unsigned int n,u64 data)316844a4f45SAntti Seppälä int ir_raw_gen_manchester(struct ir_raw_event **ev, unsigned int max,
317844a4f45SAntti Seppälä const struct ir_raw_timings_manchester *timings,
318b73bc16dSSean Young unsigned int n, u64 data)
319844a4f45SAntti Seppälä {
320844a4f45SAntti Seppälä bool need_pulse;
321b73bc16dSSean Young u64 i;
322844a4f45SAntti Seppälä int ret = -ENOBUFS;
323844a4f45SAntti Seppälä
324b73bc16dSSean Young i = BIT_ULL(n - 1);
325844a4f45SAntti Seppälä
326ddf9c1bbSSean Young if (timings->leader_pulse) {
327844a4f45SAntti Seppälä if (!max--)
328844a4f45SAntti Seppälä return ret;
329ddf9c1bbSSean Young init_ir_raw_event_duration((*ev), 1, timings->leader_pulse);
330ddf9c1bbSSean Young if (timings->leader_space) {
331844a4f45SAntti Seppälä if (!max--)
332844a4f45SAntti Seppälä return ret;
333ddf9c1bbSSean Young init_ir_raw_event_duration(++(*ev), 0,
334ddf9c1bbSSean Young timings->leader_space);
335844a4f45SAntti Seppälä }
336844a4f45SAntti Seppälä } else {
337844a4f45SAntti Seppälä /* continue existing signal */
338844a4f45SAntti Seppälä --(*ev);
339844a4f45SAntti Seppälä }
340844a4f45SAntti Seppälä /* from here on *ev will point to the last event rather than the next */
341844a4f45SAntti Seppälä
342844a4f45SAntti Seppälä while (n && i > 0) {
343844a4f45SAntti Seppälä need_pulse = !(data & i);
344844a4f45SAntti Seppälä if (timings->invert)
345844a4f45SAntti Seppälä need_pulse = !need_pulse;
346844a4f45SAntti Seppälä if (need_pulse == !!(*ev)->pulse) {
347844a4f45SAntti Seppälä (*ev)->duration += timings->clock;
348844a4f45SAntti Seppälä } else {
349844a4f45SAntti Seppälä if (!max--)
350844a4f45SAntti Seppälä goto nobufs;
351844a4f45SAntti Seppälä init_ir_raw_event_duration(++(*ev), need_pulse,
352844a4f45SAntti Seppälä timings->clock);
353844a4f45SAntti Seppälä }
354844a4f45SAntti Seppälä
355844a4f45SAntti Seppälä if (!max--)
356844a4f45SAntti Seppälä goto nobufs;
357844a4f45SAntti Seppälä init_ir_raw_event_duration(++(*ev), !need_pulse,
358844a4f45SAntti Seppälä timings->clock);
359844a4f45SAntti Seppälä i >>= 1;
360844a4f45SAntti Seppälä }
361844a4f45SAntti Seppälä
362844a4f45SAntti Seppälä if (timings->trailer_space) {
363844a4f45SAntti Seppälä if (!(*ev)->pulse)
364844a4f45SAntti Seppälä (*ev)->duration += timings->trailer_space;
365844a4f45SAntti Seppälä else if (!max--)
366844a4f45SAntti Seppälä goto nobufs;
367844a4f45SAntti Seppälä else
368844a4f45SAntti Seppälä init_ir_raw_event_duration(++(*ev), 0,
369844a4f45SAntti Seppälä timings->trailer_space);
370844a4f45SAntti Seppälä }
371844a4f45SAntti Seppälä
372844a4f45SAntti Seppälä ret = 0;
373844a4f45SAntti Seppälä nobufs:
374844a4f45SAntti Seppälä /* point to the next event rather than last event before returning */
375844a4f45SAntti Seppälä ++(*ev);
376844a4f45SAntti Seppälä return ret;
377844a4f45SAntti Seppälä }
378844a4f45SAntti Seppälä EXPORT_SYMBOL(ir_raw_gen_manchester);
379844a4f45SAntti Seppälä
380844a4f45SAntti Seppälä /**
381caec0984SJames Hogan * ir_raw_gen_pd() - Encode data to raw events with pulse-distance modulation.
382caec0984SJames Hogan * @ev: Pointer to pointer to next free event. *@ev is incremented for
383caec0984SJames Hogan * each raw event filled.
384caec0984SJames Hogan * @max: Maximum number of raw events to fill.
385caec0984SJames Hogan * @timings: Pulse distance modulation timings.
386caec0984SJames Hogan * @n: Number of bits of data.
387caec0984SJames Hogan * @data: Data bits to encode.
388caec0984SJames Hogan *
389caec0984SJames Hogan * Encodes the @n least significant bits of @data using pulse-distance
390caec0984SJames Hogan * modulation with the timing characteristics described by @timings, writing up
391caec0984SJames Hogan * to @max raw IR events using the *@ev pointer.
392caec0984SJames Hogan *
393caec0984SJames Hogan * Returns: 0 on success.
394caec0984SJames Hogan * -ENOBUFS if there isn't enough space in the array to fit the
395caec0984SJames Hogan * full encoded data. In this case all @max events will have been
396caec0984SJames Hogan * written.
397caec0984SJames Hogan */
ir_raw_gen_pd(struct ir_raw_event ** ev,unsigned int max,const struct ir_raw_timings_pd * timings,unsigned int n,u64 data)398caec0984SJames Hogan int ir_raw_gen_pd(struct ir_raw_event **ev, unsigned int max,
399caec0984SJames Hogan const struct ir_raw_timings_pd *timings,
400caec0984SJames Hogan unsigned int n, u64 data)
401caec0984SJames Hogan {
402caec0984SJames Hogan int i;
403caec0984SJames Hogan int ret;
404caec0984SJames Hogan unsigned int space;
405caec0984SJames Hogan
406caec0984SJames Hogan if (timings->header_pulse) {
407caec0984SJames Hogan ret = ir_raw_gen_pulse_space(ev, &max, timings->header_pulse,
408caec0984SJames Hogan timings->header_space);
409caec0984SJames Hogan if (ret)
410caec0984SJames Hogan return ret;
411caec0984SJames Hogan }
412caec0984SJames Hogan
413caec0984SJames Hogan if (timings->msb_first) {
414caec0984SJames Hogan for (i = n - 1; i >= 0; --i) {
415caec0984SJames Hogan space = timings->bit_space[(data >> i) & 1];
416caec0984SJames Hogan ret = ir_raw_gen_pulse_space(ev, &max,
417caec0984SJames Hogan timings->bit_pulse,
418caec0984SJames Hogan space);
419caec0984SJames Hogan if (ret)
420caec0984SJames Hogan return ret;
421caec0984SJames Hogan }
422caec0984SJames Hogan } else {
423caec0984SJames Hogan for (i = 0; i < n; ++i, data >>= 1) {
424caec0984SJames Hogan space = timings->bit_space[data & 1];
425caec0984SJames Hogan ret = ir_raw_gen_pulse_space(ev, &max,
426caec0984SJames Hogan timings->bit_pulse,
427caec0984SJames Hogan space);
428caec0984SJames Hogan if (ret)
429caec0984SJames Hogan return ret;
430caec0984SJames Hogan }
431caec0984SJames Hogan }
432caec0984SJames Hogan
433caec0984SJames Hogan ret = ir_raw_gen_pulse_space(ev, &max, timings->trailer_pulse,
434caec0984SJames Hogan timings->trailer_space);
435caec0984SJames Hogan return ret;
436caec0984SJames Hogan }
437caec0984SJames Hogan EXPORT_SYMBOL(ir_raw_gen_pd);
438caec0984SJames Hogan
439caec0984SJames Hogan /**
440103293beSSean Young * ir_raw_gen_pl() - Encode data to raw events with pulse-length modulation.
441103293beSSean Young * @ev: Pointer to pointer to next free event. *@ev is incremented for
442103293beSSean Young * each raw event filled.
443103293beSSean Young * @max: Maximum number of raw events to fill.
444103293beSSean Young * @timings: Pulse distance modulation timings.
445103293beSSean Young * @n: Number of bits of data.
446103293beSSean Young * @data: Data bits to encode.
447103293beSSean Young *
448103293beSSean Young * Encodes the @n least significant bits of @data using space-distance
449103293beSSean Young * modulation with the timing characteristics described by @timings, writing up
450103293beSSean Young * to @max raw IR events using the *@ev pointer.
451103293beSSean Young *
452103293beSSean Young * Returns: 0 on success.
453103293beSSean Young * -ENOBUFS if there isn't enough space in the array to fit the
454103293beSSean Young * full encoded data. In this case all @max events will have been
455103293beSSean Young * written.
456103293beSSean Young */
ir_raw_gen_pl(struct ir_raw_event ** ev,unsigned int max,const struct ir_raw_timings_pl * timings,unsigned int n,u64 data)457103293beSSean Young int ir_raw_gen_pl(struct ir_raw_event **ev, unsigned int max,
458103293beSSean Young const struct ir_raw_timings_pl *timings,
459103293beSSean Young unsigned int n, u64 data)
460103293beSSean Young {
461103293beSSean Young int i;
462103293beSSean Young int ret = -ENOBUFS;
463103293beSSean Young unsigned int pulse;
464103293beSSean Young
465103293beSSean Young if (!max--)
466103293beSSean Young return ret;
467103293beSSean Young
468103293beSSean Young init_ir_raw_event_duration((*ev)++, 1, timings->header_pulse);
469103293beSSean Young
470103293beSSean Young if (timings->msb_first) {
471103293beSSean Young for (i = n - 1; i >= 0; --i) {
472103293beSSean Young if (!max--)
473103293beSSean Young return ret;
474103293beSSean Young init_ir_raw_event_duration((*ev)++, 0,
475103293beSSean Young timings->bit_space);
476103293beSSean Young if (!max--)
477103293beSSean Young return ret;
478103293beSSean Young pulse = timings->bit_pulse[(data >> i) & 1];
479103293beSSean Young init_ir_raw_event_duration((*ev)++, 1, pulse);
480103293beSSean Young }
481103293beSSean Young } else {
482103293beSSean Young for (i = 0; i < n; ++i, data >>= 1) {
483103293beSSean Young if (!max--)
484103293beSSean Young return ret;
485103293beSSean Young init_ir_raw_event_duration((*ev)++, 0,
486103293beSSean Young timings->bit_space);
487103293beSSean Young if (!max--)
488103293beSSean Young return ret;
489103293beSSean Young pulse = timings->bit_pulse[data & 1];
490103293beSSean Young init_ir_raw_event_duration((*ev)++, 1, pulse);
491103293beSSean Young }
492103293beSSean Young }
493103293beSSean Young
494103293beSSean Young if (!max--)
495103293beSSean Young return ret;
496103293beSSean Young
497103293beSSean Young init_ir_raw_event_duration((*ev)++, 0, timings->trailer_space);
498103293beSSean Young
499103293beSSean Young return 0;
500103293beSSean Young }
501103293beSSean Young EXPORT_SYMBOL(ir_raw_gen_pl);
502103293beSSean Young
503103293beSSean Young /**
5043875233dSJames Hogan * ir_raw_encode_scancode() - Encode a scancode as raw events
5053875233dSJames Hogan *
5063875233dSJames Hogan * @protocol: protocol
5073875233dSJames Hogan * @scancode: scancode filter describing a single scancode
5083875233dSJames Hogan * @events: array of raw events to write into
5093875233dSJames Hogan * @max: max number of raw events
5103875233dSJames Hogan *
5113875233dSJames Hogan * Attempts to encode the scancode as raw events.
5123875233dSJames Hogan *
5133875233dSJames Hogan * Returns: The number of events written.
5143875233dSJames Hogan * -ENOBUFS if there isn't enough space in the array to fit the
5153875233dSJames Hogan * encoding. In this case all @max events will have been written.
5163875233dSJames Hogan * -EINVAL if the scancode is ambiguous or invalid, or if no
5173875233dSJames Hogan * compatible encoder was found.
5183875233dSJames Hogan */
ir_raw_encode_scancode(enum rc_proto protocol,u32 scancode,struct ir_raw_event * events,unsigned int max)5196d741bfeSSean Young int ir_raw_encode_scancode(enum rc_proto protocol, u32 scancode,
5203875233dSJames Hogan struct ir_raw_event *events, unsigned int max)
5213875233dSJames Hogan {
5223875233dSJames Hogan struct ir_raw_handler *handler;
5233875233dSJames Hogan int ret = -EINVAL;
5243875233dSJames Hogan u64 mask = 1ULL << protocol;
5253875233dSJames Hogan
5260d39ab0bSSean Young ir_raw_load_modules(&mask);
5270d39ab0bSSean Young
5283875233dSJames Hogan mutex_lock(&ir_raw_handler_lock);
5293875233dSJames Hogan list_for_each_entry(handler, &ir_raw_handler_list, list) {
5303875233dSJames Hogan if (handler->protocols & mask && handler->encode) {
5313875233dSJames Hogan ret = handler->encode(protocol, scancode, events, max);
5323875233dSJames Hogan if (ret >= 0 || ret == -ENOBUFS)
5333875233dSJames Hogan break;
5343875233dSJames Hogan }
5353875233dSJames Hogan }
5363875233dSJames Hogan mutex_unlock(&ir_raw_handler_lock);
5373875233dSJames Hogan
5383875233dSJames Hogan return ret;
5393875233dSJames Hogan }
5403875233dSJames Hogan EXPORT_SYMBOL(ir_raw_encode_scancode);
5413875233dSJames Hogan
542e3e389f9SSean Young /**
543e3e389f9SSean Young * ir_raw_edge_handle() - Handle ir_raw_event_store_edge() processing
544e3e389f9SSean Young *
545e3e389f9SSean Young * @t: timer_list
546e3e389f9SSean Young *
547e3e389f9SSean Young * This callback is armed by ir_raw_event_store_edge(). It does two things:
548e3e389f9SSean Young * first of all, rather than calling ir_raw_event_handle() for each
549e3e389f9SSean Young * edge and waking up the rc thread, 15 ms after the first edge
550e3e389f9SSean Young * ir_raw_event_handle() is called. Secondly, generate a timeout event
551e3e389f9SSean Young * no more IR is received after the rc_dev timeout.
552e3e389f9SSean Young */
ir_raw_edge_handle(struct timer_list * t)553e3e389f9SSean Young static void ir_raw_edge_handle(struct timer_list *t)
554e5e26439SSean Young {
555b17ec78aSKees Cook struct ir_raw_event_ctrl *raw = from_timer(raw, t, edge_handle);
556b17ec78aSKees Cook struct rc_dev *dev = raw->dev;
557e3e389f9SSean Young unsigned long flags;
558e3e389f9SSean Young ktime_t interval;
55948b2de19SSean Young
560e3e389f9SSean Young spin_lock_irqsave(&dev->raw->edge_spinlock, flags);
561e3e389f9SSean Young interval = ktime_sub(ktime_get(), dev->raw->last_event);
562528222d8SSean Young if (ktime_to_us(interval) >= dev->timeout) {
563183e19f5SSean Young struct ir_raw_event ev = {
564183e19f5SSean Young .timeout = true,
565528222d8SSean Young .duration = ktime_to_us(interval)
566183e19f5SSean Young };
56748b2de19SSean Young
56848b2de19SSean Young ir_raw_event_store(dev, &ev);
56948b2de19SSean Young } else {
57048b2de19SSean Young mod_timer(&dev->raw->edge_handle,
571528222d8SSean Young jiffies + usecs_to_jiffies(dev->timeout -
572528222d8SSean Young ktime_to_us(interval)));
57348b2de19SSean Young }
574e3e389f9SSean Young spin_unlock_irqrestore(&dev->raw->edge_spinlock, flags);
575e5e26439SSean Young
576e5e26439SSean Young ir_raw_event_handle(dev);
577e5e26439SSean Young }
578e5e26439SSean Young
579cdfaa01cSSean Young /**
580cdfaa01cSSean Young * ir_raw_encode_carrier() - Get carrier used for protocol
581cdfaa01cSSean Young *
582cdfaa01cSSean Young * @protocol: protocol
583cdfaa01cSSean Young *
584cdfaa01cSSean Young * Attempts to find the carrier for the specified protocol
585cdfaa01cSSean Young *
586cdfaa01cSSean Young * Returns: The carrier in Hz
587cdfaa01cSSean Young * -EINVAL if the protocol is invalid, or if no
588cdfaa01cSSean Young * compatible encoder was found.
589cdfaa01cSSean Young */
ir_raw_encode_carrier(enum rc_proto protocol)590cdfaa01cSSean Young int ir_raw_encode_carrier(enum rc_proto protocol)
591cdfaa01cSSean Young {
592cdfaa01cSSean Young struct ir_raw_handler *handler;
593cdfaa01cSSean Young int ret = -EINVAL;
594cdfaa01cSSean Young u64 mask = BIT_ULL(protocol);
595cdfaa01cSSean Young
596cdfaa01cSSean Young mutex_lock(&ir_raw_handler_lock);
597cdfaa01cSSean Young list_for_each_entry(handler, &ir_raw_handler_list, list) {
598cdfaa01cSSean Young if (handler->protocols & mask && handler->encode) {
599cdfaa01cSSean Young ret = handler->carrier;
600cdfaa01cSSean Young break;
601cdfaa01cSSean Young }
602cdfaa01cSSean Young }
603cdfaa01cSSean Young mutex_unlock(&ir_raw_handler_lock);
604cdfaa01cSSean Young
605cdfaa01cSSean Young return ret;
606cdfaa01cSSean Young }
607cdfaa01cSSean Young EXPORT_SYMBOL(ir_raw_encode_carrier);
608cdfaa01cSSean Young
6094924a311SDavid Härdeman /*
6104924a311SDavid Härdeman * Used to (un)register raw event clients
6114924a311SDavid Härdeman */
ir_raw_event_prepare(struct rc_dev * dev)612f56928abSDavid Härdeman int ir_raw_event_prepare(struct rc_dev *dev)
6134924a311SDavid Härdeman {
6144924a311SDavid Härdeman if (!dev)
6154924a311SDavid Härdeman return -EINVAL;
6164924a311SDavid Härdeman
6174924a311SDavid Härdeman dev->raw = kzalloc(sizeof(*dev->raw), GFP_KERNEL);
6184924a311SDavid Härdeman if (!dev->raw)
6194924a311SDavid Härdeman return -ENOMEM;
6204924a311SDavid Härdeman
6214924a311SDavid Härdeman dev->raw->dev = dev;
6224924a311SDavid Härdeman dev->change_protocol = change_protocol;
623e0d51e6cSSean Young dev->idle = true;
624e3e389f9SSean Young spin_lock_init(&dev->raw->edge_spinlock);
625e3e389f9SSean Young timer_setup(&dev->raw->edge_handle, ir_raw_edge_handle, 0);
626464254e5SHeiner Kallweit INIT_KFIFO(dev->raw->kfifo);
6274924a311SDavid Härdeman
628f56928abSDavid Härdeman return 0;
629f56928abSDavid Härdeman }
630f56928abSDavid Härdeman
ir_raw_event_register(struct rc_dev * dev)631f56928abSDavid Härdeman int ir_raw_event_register(struct rc_dev *dev)
632f56928abSDavid Härdeman {
633f56928abSDavid Härdeman struct task_struct *thread;
634f56928abSDavid Härdeman
635a60d64b1SSean Young thread = kthread_run(ir_raw_event_thread, dev->raw, "rc%u", dev->minor);
636f56928abSDavid Härdeman if (IS_ERR(thread))
637f56928abSDavid Härdeman return PTR_ERR(thread);
638963761a0SSean Young
639963761a0SSean Young dev->raw->thread = thread;
6404924a311SDavid Härdeman
6414924a311SDavid Härdeman mutex_lock(&ir_raw_handler_lock);
6424924a311SDavid Härdeman list_add_tail(&dev->raw->list, &ir_raw_client_list);
6434924a311SDavid Härdeman mutex_unlock(&ir_raw_handler_lock);
6444924a311SDavid Härdeman
6454924a311SDavid Härdeman return 0;
646f56928abSDavid Härdeman }
6474924a311SDavid Härdeman
ir_raw_event_free(struct rc_dev * dev)648f56928abSDavid Härdeman void ir_raw_event_free(struct rc_dev *dev)
649f56928abSDavid Härdeman {
650f56928abSDavid Härdeman if (!dev)
651f56928abSDavid Härdeman return;
652f56928abSDavid Härdeman
6534924a311SDavid Härdeman kfree(dev->raw);
6544924a311SDavid Härdeman dev->raw = NULL;
6554924a311SDavid Härdeman }
6564924a311SDavid Härdeman
ir_raw_event_unregister(struct rc_dev * dev)6574924a311SDavid Härdeman void ir_raw_event_unregister(struct rc_dev *dev)
6584924a311SDavid Härdeman {
6594924a311SDavid Härdeman struct ir_raw_handler *handler;
6604924a311SDavid Härdeman
6614924a311SDavid Härdeman if (!dev || !dev->raw)
6624924a311SDavid Härdeman return;
6634924a311SDavid Härdeman
6644924a311SDavid Härdeman kthread_stop(dev->raw->thread);
665e5e26439SSean Young del_timer_sync(&dev->raw->edge_handle);
6664924a311SDavid Härdeman
6674924a311SDavid Härdeman mutex_lock(&ir_raw_handler_lock);
6684924a311SDavid Härdeman list_del(&dev->raw->list);
6694924a311SDavid Härdeman list_for_each_entry(handler, &ir_raw_handler_list, list)
670c00cb587SSean Young if (handler->raw_unregister &&
671c00cb587SSean Young (handler->protocols & dev->enabled_protocols))
6724924a311SDavid Härdeman handler->raw_unregister(dev);
673f4364dcfSSean Young
674f4364dcfSSean Young lirc_bpf_free(dev);
6754924a311SDavid Härdeman
676f56928abSDavid Härdeman ir_raw_event_free(dev);
677f4364dcfSSean Young
678f4364dcfSSean Young /*
679f4364dcfSSean Young * A user can be calling bpf(BPF_PROG_{QUERY|ATTACH|DETACH}), so
680f4364dcfSSean Young * ensure that the raw member is null on unlock; this is how
681f4364dcfSSean Young * "device gone" is checked.
682f4364dcfSSean Young */
683f4364dcfSSean Young mutex_unlock(&ir_raw_handler_lock);
6844924a311SDavid Härdeman }
6854924a311SDavid Härdeman
6864924a311SDavid Härdeman /*
6874924a311SDavid Härdeman * Extension interface - used to register the IR decoders
6884924a311SDavid Härdeman */
6894924a311SDavid Härdeman
ir_raw_handler_register(struct ir_raw_handler * ir_raw_handler)6904924a311SDavid Härdeman int ir_raw_handler_register(struct ir_raw_handler *ir_raw_handler)
6914924a311SDavid Härdeman {
6924924a311SDavid Härdeman mutex_lock(&ir_raw_handler_lock);
6934924a311SDavid Härdeman list_add_tail(&ir_raw_handler->list, &ir_raw_handler_list);
69437e90a22SHeiner Kallweit atomic64_or(ir_raw_handler->protocols, &available_protocols);
6954924a311SDavid Härdeman mutex_unlock(&ir_raw_handler_lock);
6964924a311SDavid Härdeman
6974924a311SDavid Härdeman return 0;
6984924a311SDavid Härdeman }
6994924a311SDavid Härdeman EXPORT_SYMBOL(ir_raw_handler_register);
7004924a311SDavid Härdeman
ir_raw_handler_unregister(struct ir_raw_handler * ir_raw_handler)7014924a311SDavid Härdeman void ir_raw_handler_unregister(struct ir_raw_handler *ir_raw_handler)
7024924a311SDavid Härdeman {
7034924a311SDavid Härdeman struct ir_raw_event_ctrl *raw;
70493cffffcSHeiner Kallweit u64 protocols = ir_raw_handler->protocols;
7054924a311SDavid Härdeman
7064924a311SDavid Härdeman mutex_lock(&ir_raw_handler_lock);
7074924a311SDavid Härdeman list_del(&ir_raw_handler->list);
70893cffffcSHeiner Kallweit list_for_each_entry(raw, &ir_raw_client_list, list) {
709c00cb587SSean Young if (ir_raw_handler->raw_unregister &&
710c00cb587SSean Young (raw->dev->enabled_protocols & protocols))
7114924a311SDavid Härdeman ir_raw_handler->raw_unregister(raw->dev);
712c00cb587SSean Young ir_raw_disable_protocols(raw->dev, protocols);
71393cffffcSHeiner Kallweit }
71437e90a22SHeiner Kallweit atomic64_andnot(protocols, &available_protocols);
7154924a311SDavid Härdeman mutex_unlock(&ir_raw_handler_lock);
7164924a311SDavid Härdeman }
7174924a311SDavid Härdeman EXPORT_SYMBOL(ir_raw_handler_unregister);
718