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 */ 174924a311SDavid Härdeman static 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 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; 254924a311SDavid Härdeman struct ir_raw_event_ctrl *raw = (struct ir_raw_event_ctrl *)data; 264924a311SDavid Härdeman 2774d47d75SHeiner Kallweit while (1) { 284924a311SDavid Härdeman mutex_lock(&ir_raw_handler_lock); 2974d47d75SHeiner Kallweit while (kfifo_out(&raw->kfifo, &ev, 1)) { 304924a311SDavid Härdeman list_for_each_entry(handler, &ir_raw_handler_list, list) 3174d47d75SHeiner Kallweit if (raw->dev->enabled_protocols & 3274d47d75SHeiner Kallweit handler->protocols || !handler->protocols) 334924a311SDavid Härdeman handler->decode(raw->dev, ev); 344924a311SDavid Härdeman raw->prev_ev = ev; 3574d47d75SHeiner Kallweit } 364924a311SDavid Härdeman mutex_unlock(&ir_raw_handler_lock); 3774d47d75SHeiner Kallweit 3874d47d75SHeiner Kallweit set_current_state(TASK_INTERRUPTIBLE); 3974d47d75SHeiner Kallweit 4074d47d75SHeiner Kallweit if (kthread_should_stop()) { 4174d47d75SHeiner Kallweit __set_current_state(TASK_RUNNING); 4274d47d75SHeiner Kallweit break; 4374d47d75SHeiner Kallweit } else if (!kfifo_is_empty(&raw->kfifo)) 4474d47d75SHeiner Kallweit set_current_state(TASK_RUNNING); 4574d47d75SHeiner Kallweit 4674d47d75SHeiner Kallweit schedule(); 474924a311SDavid Härdeman } 484924a311SDavid Härdeman 494924a311SDavid Härdeman return 0; 504924a311SDavid Härdeman } 514924a311SDavid Härdeman 524924a311SDavid Härdeman /** 534924a311SDavid Härdeman * ir_raw_event_store() - pass a pulse/space duration to the raw ir decoders 544924a311SDavid Härdeman * @dev: the struct rc_dev device descriptor 554924a311SDavid Härdeman * @ev: the struct ir_raw_event descriptor of the pulse/space 564924a311SDavid Härdeman * 574924a311SDavid Härdeman * This routine (which may be called from an interrupt context) stores a 584924a311SDavid Härdeman * pulse/space duration for the raw ir decoding state machines. Pulses are 594924a311SDavid Härdeman * signalled as positive values and spaces as negative values. A zero value 604924a311SDavid Härdeman * will reset the decoding state machines. 614924a311SDavid Härdeman */ 624924a311SDavid Härdeman int ir_raw_event_store(struct rc_dev *dev, struct ir_raw_event *ev) 634924a311SDavid Härdeman { 644924a311SDavid Härdeman if (!dev->raw) 654924a311SDavid Härdeman return -EINVAL; 664924a311SDavid Härdeman 674924a311SDavid Härdeman IR_dprintk(2, "sample: (%05dus %s)\n", 684924a311SDavid Härdeman TO_US(ev->duration), TO_STR(ev->pulse)); 694924a311SDavid Härdeman 70464254e5SHeiner Kallweit if (!kfifo_put(&dev->raw->kfifo, *ev)) { 71464254e5SHeiner Kallweit dev_err(&dev->dev, "IR event FIFO is full!\n"); 72464254e5SHeiner Kallweit return -ENOSPC; 73464254e5SHeiner Kallweit } 744924a311SDavid Härdeman 754924a311SDavid Härdeman return 0; 764924a311SDavid Härdeman } 774924a311SDavid Härdeman EXPORT_SYMBOL_GPL(ir_raw_event_store); 784924a311SDavid Härdeman 794924a311SDavid Härdeman /** 804924a311SDavid Härdeman * ir_raw_event_store_edge() - notify raw ir decoders of the start of a pulse/space 814924a311SDavid Härdeman * @dev: the struct rc_dev device descriptor 8286fe1ac0SSean Young * @pulse: true for pulse, false for space 834924a311SDavid Härdeman * 844924a311SDavid Härdeman * This routine (which may be called from an interrupt context) is used to 854924a311SDavid Härdeman * store the beginning of an ir pulse or space (or the start/end of ir 864924a311SDavid Härdeman * reception) for the raw ir decoding state machines. This is used by 874924a311SDavid Härdeman * hardware which does not provide durations directly but only interrupts 884924a311SDavid Härdeman * (or similar events) on state change. 894924a311SDavid Härdeman */ 9086fe1ac0SSean Young int ir_raw_event_store_edge(struct rc_dev *dev, bool pulse) 914924a311SDavid Härdeman { 924924a311SDavid Härdeman ktime_t now; 934924a311SDavid Härdeman DEFINE_IR_RAW_EVENT(ev); 944924a311SDavid Härdeman int rc = 0; 954924a311SDavid Härdeman 964924a311SDavid Härdeman if (!dev->raw) 974924a311SDavid Härdeman return -EINVAL; 984924a311SDavid Härdeman 994924a311SDavid Härdeman now = ktime_get(); 100800846c4SJasmin Jessich ev.duration = ktime_to_ns(ktime_sub(now, dev->raw->last_event)); 10186fe1ac0SSean Young ev.pulse = !pulse; 1024924a311SDavid Härdeman 1034924a311SDavid Härdeman rc = ir_raw_event_store(dev, &ev); 1044924a311SDavid Härdeman 1054924a311SDavid Härdeman dev->raw->last_event = now; 106e5e26439SSean Young 10748b2de19SSean Young /* timer could be set to timeout (125ms by default) */ 10848b2de19SSean Young if (!timer_pending(&dev->raw->edge_handle) || 10948b2de19SSean Young time_after(dev->raw->edge_handle.expires, 11048b2de19SSean Young jiffies + msecs_to_jiffies(15))) { 111e5e26439SSean Young mod_timer(&dev->raw->edge_handle, 112e5e26439SSean Young jiffies + msecs_to_jiffies(15)); 11348b2de19SSean Young } 114e5e26439SSean Young 1154924a311SDavid Härdeman return rc; 1164924a311SDavid Härdeman } 1174924a311SDavid Härdeman EXPORT_SYMBOL_GPL(ir_raw_event_store_edge); 1184924a311SDavid Härdeman 1194924a311SDavid Härdeman /** 1204924a311SDavid Härdeman * ir_raw_event_store_with_filter() - pass next pulse/space to decoders with some processing 1214924a311SDavid Härdeman * @dev: the struct rc_dev device descriptor 122c4365922SMauro Carvalho Chehab * @ev: the event that has occurred 1234924a311SDavid Härdeman * 1244924a311SDavid Härdeman * This routine (which may be called from an interrupt context) works 1254924a311SDavid Härdeman * in similar manner to ir_raw_event_store_edge. 1264924a311SDavid Härdeman * This routine is intended for devices with limited internal buffer 1274924a311SDavid Härdeman * It automerges samples of same type, and handles timeouts. Returns non-zero 1284924a311SDavid Härdeman * if the event was added, and zero if the event was ignored due to idle 1294924a311SDavid Härdeman * processing. 1304924a311SDavid Härdeman */ 1314924a311SDavid Härdeman int ir_raw_event_store_with_filter(struct rc_dev *dev, struct ir_raw_event *ev) 1324924a311SDavid Härdeman { 1334924a311SDavid Härdeman if (!dev->raw) 1344924a311SDavid Härdeman return -EINVAL; 1354924a311SDavid Härdeman 1364924a311SDavid Härdeman /* Ignore spaces in idle mode */ 1374924a311SDavid Härdeman if (dev->idle && !ev->pulse) 1384924a311SDavid Härdeman return 0; 1394924a311SDavid Härdeman else if (dev->idle) 1404924a311SDavid Härdeman ir_raw_event_set_idle(dev, false); 1414924a311SDavid Härdeman 1424924a311SDavid Härdeman if (!dev->raw->this_ev.duration) 1434924a311SDavid Härdeman dev->raw->this_ev = *ev; 1444924a311SDavid Härdeman else if (ev->pulse == dev->raw->this_ev.pulse) 1454924a311SDavid Härdeman dev->raw->this_ev.duration += ev->duration; 1464924a311SDavid Härdeman else { 1474924a311SDavid Härdeman ir_raw_event_store(dev, &dev->raw->this_ev); 1484924a311SDavid Härdeman dev->raw->this_ev = *ev; 1494924a311SDavid Härdeman } 1504924a311SDavid Härdeman 1514924a311SDavid Härdeman /* Enter idle mode if nessesary */ 1524924a311SDavid Härdeman if (!ev->pulse && dev->timeout && 1534924a311SDavid Härdeman dev->raw->this_ev.duration >= dev->timeout) 1544924a311SDavid Härdeman ir_raw_event_set_idle(dev, true); 1554924a311SDavid Härdeman 1564924a311SDavid Härdeman return 1; 1574924a311SDavid Härdeman } 1584924a311SDavid Härdeman EXPORT_SYMBOL_GPL(ir_raw_event_store_with_filter); 1594924a311SDavid Härdeman 1604924a311SDavid Härdeman /** 1614924a311SDavid Härdeman * ir_raw_event_set_idle() - provide hint to rc-core when the device is idle or not 1624924a311SDavid Härdeman * @dev: the struct rc_dev device descriptor 1634924a311SDavid Härdeman * @idle: whether the device is idle or not 1644924a311SDavid Härdeman */ 1654924a311SDavid Härdeman void ir_raw_event_set_idle(struct rc_dev *dev, bool idle) 1664924a311SDavid Härdeman { 1674924a311SDavid Härdeman if (!dev->raw) 1684924a311SDavid Härdeman return; 1694924a311SDavid Härdeman 1704924a311SDavid Härdeman IR_dprintk(2, "%s idle mode\n", idle ? "enter" : "leave"); 1714924a311SDavid Härdeman 1724924a311SDavid Härdeman if (idle) { 1734924a311SDavid Härdeman dev->raw->this_ev.timeout = true; 1744924a311SDavid Härdeman ir_raw_event_store(dev, &dev->raw->this_ev); 1754924a311SDavid Härdeman init_ir_raw_event(&dev->raw->this_ev); 1764924a311SDavid Härdeman } 1774924a311SDavid Härdeman 1784924a311SDavid Härdeman if (dev->s_idle) 1794924a311SDavid Härdeman dev->s_idle(dev, idle); 1804924a311SDavid Härdeman 1814924a311SDavid Härdeman dev->idle = idle; 1824924a311SDavid Härdeman } 1834924a311SDavid Härdeman EXPORT_SYMBOL_GPL(ir_raw_event_set_idle); 1844924a311SDavid Härdeman 1854924a311SDavid Härdeman /** 1864924a311SDavid Härdeman * ir_raw_event_handle() - schedules the decoding of stored ir data 1874924a311SDavid Härdeman * @dev: the struct rc_dev device descriptor 1884924a311SDavid Härdeman * 1894924a311SDavid Härdeman * This routine will tell rc-core to start decoding stored ir data. 1904924a311SDavid Härdeman */ 1914924a311SDavid Härdeman void ir_raw_event_handle(struct rc_dev *dev) 1924924a311SDavid Härdeman { 193963761a0SSean Young if (!dev->raw || !dev->raw->thread) 1944924a311SDavid Härdeman return; 1954924a311SDavid Härdeman 1964924a311SDavid Härdeman wake_up_process(dev->raw->thread); 1974924a311SDavid Härdeman } 1984924a311SDavid Härdeman EXPORT_SYMBOL_GPL(ir_raw_event_handle); 1994924a311SDavid Härdeman 2004924a311SDavid Härdeman /* used internally by the sysfs interface */ 2014924a311SDavid Härdeman u64 2024924a311SDavid Härdeman ir_raw_get_allowed_protocols(void) 2034924a311SDavid Härdeman { 20437e90a22SHeiner Kallweit return atomic64_read(&available_protocols); 2054924a311SDavid Härdeman } 2064924a311SDavid Härdeman 2076d741bfeSSean Young static int change_protocol(struct rc_dev *dev, u64 *rc_proto) 2084924a311SDavid Härdeman { 2094924a311SDavid Härdeman /* the caller will update dev->enabled_protocols */ 2104924a311SDavid Härdeman return 0; 2114924a311SDavid Härdeman } 2124924a311SDavid Härdeman 21393cffffcSHeiner Kallweit static void ir_raw_disable_protocols(struct rc_dev *dev, u64 protocols) 21493cffffcSHeiner Kallweit { 21593cffffcSHeiner Kallweit mutex_lock(&dev->lock); 21693cffffcSHeiner Kallweit dev->enabled_protocols &= ~protocols; 21793cffffcSHeiner Kallweit mutex_unlock(&dev->lock); 21893cffffcSHeiner Kallweit } 21993cffffcSHeiner Kallweit 2203875233dSJames Hogan /** 221844a4f45SAntti Seppälä * ir_raw_gen_manchester() - Encode data with Manchester (bi-phase) modulation. 222844a4f45SAntti Seppälä * @ev: Pointer to pointer to next free event. *@ev is incremented for 223844a4f45SAntti Seppälä * each raw event filled. 224844a4f45SAntti Seppälä * @max: Maximum number of raw events to fill. 225844a4f45SAntti Seppälä * @timings: Manchester modulation timings. 226844a4f45SAntti Seppälä * @n: Number of bits of data. 227844a4f45SAntti Seppälä * @data: Data bits to encode. 228844a4f45SAntti Seppälä * 229844a4f45SAntti Seppälä * Encodes the @n least significant bits of @data using Manchester (bi-phase) 230844a4f45SAntti Seppälä * modulation with the timing characteristics described by @timings, writing up 231844a4f45SAntti Seppälä * to @max raw IR events using the *@ev pointer. 232844a4f45SAntti Seppälä * 233844a4f45SAntti Seppälä * Returns: 0 on success. 234844a4f45SAntti Seppälä * -ENOBUFS if there isn't enough space in the array to fit the 235844a4f45SAntti Seppälä * full encoded data. In this case all @max events will have been 236844a4f45SAntti Seppälä * written. 237844a4f45SAntti Seppälä */ 238844a4f45SAntti Seppälä int ir_raw_gen_manchester(struct ir_raw_event **ev, unsigned int max, 239844a4f45SAntti Seppälä const struct ir_raw_timings_manchester *timings, 240b73bc16dSSean Young unsigned int n, u64 data) 241844a4f45SAntti Seppälä { 242844a4f45SAntti Seppälä bool need_pulse; 243b73bc16dSSean Young u64 i; 244844a4f45SAntti Seppälä int ret = -ENOBUFS; 245844a4f45SAntti Seppälä 246b73bc16dSSean Young i = BIT_ULL(n - 1); 247844a4f45SAntti Seppälä 248844a4f45SAntti Seppälä if (timings->leader) { 249844a4f45SAntti Seppälä if (!max--) 250844a4f45SAntti Seppälä return ret; 251844a4f45SAntti Seppälä if (timings->pulse_space_start) { 252844a4f45SAntti Seppälä init_ir_raw_event_duration((*ev)++, 1, timings->leader); 253844a4f45SAntti Seppälä 254844a4f45SAntti Seppälä if (!max--) 255844a4f45SAntti Seppälä return ret; 256844a4f45SAntti Seppälä init_ir_raw_event_duration((*ev), 0, timings->leader); 257844a4f45SAntti Seppälä } else { 258844a4f45SAntti Seppälä init_ir_raw_event_duration((*ev), 1, timings->leader); 259844a4f45SAntti Seppälä } 260844a4f45SAntti Seppälä i >>= 1; 261844a4f45SAntti Seppälä } else { 262844a4f45SAntti Seppälä /* continue existing signal */ 263844a4f45SAntti Seppälä --(*ev); 264844a4f45SAntti Seppälä } 265844a4f45SAntti Seppälä /* from here on *ev will point to the last event rather than the next */ 266844a4f45SAntti Seppälä 267844a4f45SAntti Seppälä while (n && i > 0) { 268844a4f45SAntti Seppälä need_pulse = !(data & i); 269844a4f45SAntti Seppälä if (timings->invert) 270844a4f45SAntti Seppälä need_pulse = !need_pulse; 271844a4f45SAntti Seppälä if (need_pulse == !!(*ev)->pulse) { 272844a4f45SAntti Seppälä (*ev)->duration += timings->clock; 273844a4f45SAntti Seppälä } else { 274844a4f45SAntti Seppälä if (!max--) 275844a4f45SAntti Seppälä goto nobufs; 276844a4f45SAntti Seppälä init_ir_raw_event_duration(++(*ev), need_pulse, 277844a4f45SAntti Seppälä timings->clock); 278844a4f45SAntti Seppälä } 279844a4f45SAntti Seppälä 280844a4f45SAntti Seppälä if (!max--) 281844a4f45SAntti Seppälä goto nobufs; 282844a4f45SAntti Seppälä init_ir_raw_event_duration(++(*ev), !need_pulse, 283844a4f45SAntti Seppälä timings->clock); 284844a4f45SAntti Seppälä i >>= 1; 285844a4f45SAntti Seppälä } 286844a4f45SAntti Seppälä 287844a4f45SAntti Seppälä if (timings->trailer_space) { 288844a4f45SAntti Seppälä if (!(*ev)->pulse) 289844a4f45SAntti Seppälä (*ev)->duration += timings->trailer_space; 290844a4f45SAntti Seppälä else if (!max--) 291844a4f45SAntti Seppälä goto nobufs; 292844a4f45SAntti Seppälä else 293844a4f45SAntti Seppälä init_ir_raw_event_duration(++(*ev), 0, 294844a4f45SAntti Seppälä timings->trailer_space); 295844a4f45SAntti Seppälä } 296844a4f45SAntti Seppälä 297844a4f45SAntti Seppälä ret = 0; 298844a4f45SAntti Seppälä nobufs: 299844a4f45SAntti Seppälä /* point to the next event rather than last event before returning */ 300844a4f45SAntti Seppälä ++(*ev); 301844a4f45SAntti Seppälä return ret; 302844a4f45SAntti Seppälä } 303844a4f45SAntti Seppälä EXPORT_SYMBOL(ir_raw_gen_manchester); 304844a4f45SAntti Seppälä 305844a4f45SAntti Seppälä /** 306caec0984SJames Hogan * ir_raw_gen_pd() - Encode data to raw events with pulse-distance modulation. 307caec0984SJames Hogan * @ev: Pointer to pointer to next free event. *@ev is incremented for 308caec0984SJames Hogan * each raw event filled. 309caec0984SJames Hogan * @max: Maximum number of raw events to fill. 310caec0984SJames Hogan * @timings: Pulse distance modulation timings. 311caec0984SJames Hogan * @n: Number of bits of data. 312caec0984SJames Hogan * @data: Data bits to encode. 313caec0984SJames Hogan * 314caec0984SJames Hogan * Encodes the @n least significant bits of @data using pulse-distance 315caec0984SJames Hogan * modulation with the timing characteristics described by @timings, writing up 316caec0984SJames Hogan * to @max raw IR events using the *@ev pointer. 317caec0984SJames Hogan * 318caec0984SJames Hogan * Returns: 0 on success. 319caec0984SJames Hogan * -ENOBUFS if there isn't enough space in the array to fit the 320caec0984SJames Hogan * full encoded data. In this case all @max events will have been 321caec0984SJames Hogan * written. 322caec0984SJames Hogan */ 323caec0984SJames Hogan int ir_raw_gen_pd(struct ir_raw_event **ev, unsigned int max, 324caec0984SJames Hogan const struct ir_raw_timings_pd *timings, 325caec0984SJames Hogan unsigned int n, u64 data) 326caec0984SJames Hogan { 327caec0984SJames Hogan int i; 328caec0984SJames Hogan int ret; 329caec0984SJames Hogan unsigned int space; 330caec0984SJames Hogan 331caec0984SJames Hogan if (timings->header_pulse) { 332caec0984SJames Hogan ret = ir_raw_gen_pulse_space(ev, &max, timings->header_pulse, 333caec0984SJames Hogan timings->header_space); 334caec0984SJames Hogan if (ret) 335caec0984SJames Hogan return ret; 336caec0984SJames Hogan } 337caec0984SJames Hogan 338caec0984SJames Hogan if (timings->msb_first) { 339caec0984SJames Hogan for (i = n - 1; i >= 0; --i) { 340caec0984SJames Hogan space = timings->bit_space[(data >> i) & 1]; 341caec0984SJames Hogan ret = ir_raw_gen_pulse_space(ev, &max, 342caec0984SJames Hogan timings->bit_pulse, 343caec0984SJames Hogan space); 344caec0984SJames Hogan if (ret) 345caec0984SJames Hogan return ret; 346caec0984SJames Hogan } 347caec0984SJames Hogan } else { 348caec0984SJames Hogan for (i = 0; i < n; ++i, data >>= 1) { 349caec0984SJames Hogan space = timings->bit_space[data & 1]; 350caec0984SJames Hogan ret = ir_raw_gen_pulse_space(ev, &max, 351caec0984SJames Hogan timings->bit_pulse, 352caec0984SJames Hogan space); 353caec0984SJames Hogan if (ret) 354caec0984SJames Hogan return ret; 355caec0984SJames Hogan } 356caec0984SJames Hogan } 357caec0984SJames Hogan 358caec0984SJames Hogan ret = ir_raw_gen_pulse_space(ev, &max, timings->trailer_pulse, 359caec0984SJames Hogan timings->trailer_space); 360caec0984SJames Hogan return ret; 361caec0984SJames Hogan } 362caec0984SJames Hogan EXPORT_SYMBOL(ir_raw_gen_pd); 363caec0984SJames Hogan 364caec0984SJames Hogan /** 365103293beSSean Young * ir_raw_gen_pl() - Encode data to raw events with pulse-length modulation. 366103293beSSean Young * @ev: Pointer to pointer to next free event. *@ev is incremented for 367103293beSSean Young * each raw event filled. 368103293beSSean Young * @max: Maximum number of raw events to fill. 369103293beSSean Young * @timings: Pulse distance modulation timings. 370103293beSSean Young * @n: Number of bits of data. 371103293beSSean Young * @data: Data bits to encode. 372103293beSSean Young * 373103293beSSean Young * Encodes the @n least significant bits of @data using space-distance 374103293beSSean Young * modulation with the timing characteristics described by @timings, writing up 375103293beSSean Young * to @max raw IR events using the *@ev pointer. 376103293beSSean Young * 377103293beSSean Young * Returns: 0 on success. 378103293beSSean Young * -ENOBUFS if there isn't enough space in the array to fit the 379103293beSSean Young * full encoded data. In this case all @max events will have been 380103293beSSean Young * written. 381103293beSSean Young */ 382103293beSSean Young int ir_raw_gen_pl(struct ir_raw_event **ev, unsigned int max, 383103293beSSean Young const struct ir_raw_timings_pl *timings, 384103293beSSean Young unsigned int n, u64 data) 385103293beSSean Young { 386103293beSSean Young int i; 387103293beSSean Young int ret = -ENOBUFS; 388103293beSSean Young unsigned int pulse; 389103293beSSean Young 390103293beSSean Young if (!max--) 391103293beSSean Young return ret; 392103293beSSean Young 393103293beSSean Young init_ir_raw_event_duration((*ev)++, 1, timings->header_pulse); 394103293beSSean Young 395103293beSSean Young if (timings->msb_first) { 396103293beSSean Young for (i = n - 1; i >= 0; --i) { 397103293beSSean Young if (!max--) 398103293beSSean Young return ret; 399103293beSSean Young init_ir_raw_event_duration((*ev)++, 0, 400103293beSSean Young timings->bit_space); 401103293beSSean Young if (!max--) 402103293beSSean Young return ret; 403103293beSSean Young pulse = timings->bit_pulse[(data >> i) & 1]; 404103293beSSean Young init_ir_raw_event_duration((*ev)++, 1, pulse); 405103293beSSean Young } 406103293beSSean Young } else { 407103293beSSean Young for (i = 0; i < n; ++i, data >>= 1) { 408103293beSSean Young if (!max--) 409103293beSSean Young return ret; 410103293beSSean Young init_ir_raw_event_duration((*ev)++, 0, 411103293beSSean Young timings->bit_space); 412103293beSSean Young if (!max--) 413103293beSSean Young return ret; 414103293beSSean Young pulse = timings->bit_pulse[data & 1]; 415103293beSSean Young init_ir_raw_event_duration((*ev)++, 1, pulse); 416103293beSSean Young } 417103293beSSean Young } 418103293beSSean Young 419103293beSSean Young if (!max--) 420103293beSSean Young return ret; 421103293beSSean Young 422103293beSSean Young init_ir_raw_event_duration((*ev)++, 0, timings->trailer_space); 423103293beSSean Young 424103293beSSean Young return 0; 425103293beSSean Young } 426103293beSSean Young EXPORT_SYMBOL(ir_raw_gen_pl); 427103293beSSean Young 428103293beSSean Young /** 4293875233dSJames Hogan * ir_raw_encode_scancode() - Encode a scancode as raw events 4303875233dSJames Hogan * 4313875233dSJames Hogan * @protocol: protocol 4323875233dSJames Hogan * @scancode: scancode filter describing a single scancode 4333875233dSJames Hogan * @events: array of raw events to write into 4343875233dSJames Hogan * @max: max number of raw events 4353875233dSJames Hogan * 4363875233dSJames Hogan * Attempts to encode the scancode as raw events. 4373875233dSJames Hogan * 4383875233dSJames Hogan * Returns: The number of events written. 4393875233dSJames Hogan * -ENOBUFS if there isn't enough space in the array to fit the 4403875233dSJames Hogan * encoding. In this case all @max events will have been written. 4413875233dSJames Hogan * -EINVAL if the scancode is ambiguous or invalid, or if no 4423875233dSJames Hogan * compatible encoder was found. 4433875233dSJames Hogan */ 4446d741bfeSSean Young int ir_raw_encode_scancode(enum rc_proto protocol, u32 scancode, 4453875233dSJames Hogan struct ir_raw_event *events, unsigned int max) 4463875233dSJames Hogan { 4473875233dSJames Hogan struct ir_raw_handler *handler; 4483875233dSJames Hogan int ret = -EINVAL; 4493875233dSJames Hogan u64 mask = 1ULL << protocol; 4503875233dSJames Hogan 4510d39ab0bSSean Young ir_raw_load_modules(&mask); 4520d39ab0bSSean Young 4533875233dSJames Hogan mutex_lock(&ir_raw_handler_lock); 4543875233dSJames Hogan list_for_each_entry(handler, &ir_raw_handler_list, list) { 4553875233dSJames Hogan if (handler->protocols & mask && handler->encode) { 4563875233dSJames Hogan ret = handler->encode(protocol, scancode, events, max); 4573875233dSJames Hogan if (ret >= 0 || ret == -ENOBUFS) 4583875233dSJames Hogan break; 4593875233dSJames Hogan } 4603875233dSJames Hogan } 4613875233dSJames Hogan mutex_unlock(&ir_raw_handler_lock); 4623875233dSJames Hogan 4633875233dSJames Hogan return ret; 4643875233dSJames Hogan } 4653875233dSJames Hogan EXPORT_SYMBOL(ir_raw_encode_scancode); 4663875233dSJames Hogan 467b17ec78aSKees Cook static void edge_handle(struct timer_list *t) 468e5e26439SSean Young { 469b17ec78aSKees Cook struct ir_raw_event_ctrl *raw = from_timer(raw, t, edge_handle); 470b17ec78aSKees Cook struct rc_dev *dev = raw->dev; 471800846c4SJasmin Jessich ktime_t interval = ktime_sub(ktime_get(), dev->raw->last_event); 47248b2de19SSean Young 473800846c4SJasmin Jessich if (ktime_to_ns(interval) >= dev->timeout) { 47448b2de19SSean Young DEFINE_IR_RAW_EVENT(ev); 47548b2de19SSean Young 47648b2de19SSean Young ev.timeout = true; 477800846c4SJasmin Jessich ev.duration = ktime_to_ns(interval); 47848b2de19SSean Young 47948b2de19SSean Young ir_raw_event_store(dev, &ev); 48048b2de19SSean Young } else { 48148b2de19SSean Young mod_timer(&dev->raw->edge_handle, 482800846c4SJasmin Jessich jiffies + nsecs_to_jiffies(dev->timeout - 483800846c4SJasmin Jessich ktime_to_ns(interval))); 48448b2de19SSean Young } 485e5e26439SSean Young 486e5e26439SSean Young ir_raw_event_handle(dev); 487e5e26439SSean Young } 488e5e26439SSean Young 489cdfaa01cSSean Young /** 490cdfaa01cSSean Young * ir_raw_encode_carrier() - Get carrier used for protocol 491cdfaa01cSSean Young * 492cdfaa01cSSean Young * @protocol: protocol 493cdfaa01cSSean Young * 494cdfaa01cSSean Young * Attempts to find the carrier for the specified protocol 495cdfaa01cSSean Young * 496cdfaa01cSSean Young * Returns: The carrier in Hz 497cdfaa01cSSean Young * -EINVAL if the protocol is invalid, or if no 498cdfaa01cSSean Young * compatible encoder was found. 499cdfaa01cSSean Young */ 500cdfaa01cSSean Young int ir_raw_encode_carrier(enum rc_proto protocol) 501cdfaa01cSSean Young { 502cdfaa01cSSean Young struct ir_raw_handler *handler; 503cdfaa01cSSean Young int ret = -EINVAL; 504cdfaa01cSSean Young u64 mask = BIT_ULL(protocol); 505cdfaa01cSSean Young 506cdfaa01cSSean Young mutex_lock(&ir_raw_handler_lock); 507cdfaa01cSSean Young list_for_each_entry(handler, &ir_raw_handler_list, list) { 508cdfaa01cSSean Young if (handler->protocols & mask && handler->encode) { 509cdfaa01cSSean Young ret = handler->carrier; 510cdfaa01cSSean Young break; 511cdfaa01cSSean Young } 512cdfaa01cSSean Young } 513cdfaa01cSSean Young mutex_unlock(&ir_raw_handler_lock); 514cdfaa01cSSean Young 515cdfaa01cSSean Young return ret; 516cdfaa01cSSean Young } 517cdfaa01cSSean Young EXPORT_SYMBOL(ir_raw_encode_carrier); 518cdfaa01cSSean Young 5194924a311SDavid Härdeman /* 5204924a311SDavid Härdeman * Used to (un)register raw event clients 5214924a311SDavid Härdeman */ 522f56928abSDavid Härdeman int ir_raw_event_prepare(struct rc_dev *dev) 5234924a311SDavid Härdeman { 524f56928abSDavid Härdeman static bool raw_init; /* 'false' default value, raw decoders loaded? */ 5254924a311SDavid Härdeman 5264924a311SDavid Härdeman if (!dev) 5274924a311SDavid Härdeman return -EINVAL; 5284924a311SDavid Härdeman 529f56928abSDavid Härdeman if (!raw_init) { 530f56928abSDavid Härdeman request_module("ir-lirc-codec"); 531f56928abSDavid Härdeman raw_init = true; 532f56928abSDavid Härdeman } 533f56928abSDavid Härdeman 5344924a311SDavid Härdeman dev->raw = kzalloc(sizeof(*dev->raw), GFP_KERNEL); 5354924a311SDavid Härdeman if (!dev->raw) 5364924a311SDavid Härdeman return -ENOMEM; 5374924a311SDavid Härdeman 5384924a311SDavid Härdeman dev->raw->dev = dev; 5394924a311SDavid Härdeman dev->change_protocol = change_protocol; 540b17ec78aSKees Cook timer_setup(&dev->raw->edge_handle, edge_handle, 0); 541464254e5SHeiner Kallweit INIT_KFIFO(dev->raw->kfifo); 5424924a311SDavid Härdeman 543f56928abSDavid Härdeman return 0; 544f56928abSDavid Härdeman } 545f56928abSDavid Härdeman 546f56928abSDavid Härdeman int ir_raw_event_register(struct rc_dev *dev) 547f56928abSDavid Härdeman { 548f56928abSDavid Härdeman struct ir_raw_handler *handler; 549f56928abSDavid Härdeman struct task_struct *thread; 550f56928abSDavid Härdeman 551d5083677SAndi Shyti /* 552d5083677SAndi Shyti * raw transmitters do not need any event registration 553d5083677SAndi Shyti * because the event is coming from userspace 554d5083677SAndi Shyti */ 555d5083677SAndi Shyti if (dev->driver_type != RC_DRIVER_IR_RAW_TX) { 556963761a0SSean Young thread = kthread_run(ir_raw_event_thread, dev->raw, "rc%u", 557963761a0SSean Young dev->minor); 5584924a311SDavid Härdeman 559f56928abSDavid Härdeman if (IS_ERR(thread)) 560f56928abSDavid Härdeman return PTR_ERR(thread); 561963761a0SSean Young 562963761a0SSean Young dev->raw->thread = thread; 563d5083677SAndi Shyti } 5644924a311SDavid Härdeman 5654924a311SDavid Härdeman mutex_lock(&ir_raw_handler_lock); 5664924a311SDavid Härdeman list_add_tail(&dev->raw->list, &ir_raw_client_list); 5674924a311SDavid Härdeman list_for_each_entry(handler, &ir_raw_handler_list, list) 5684924a311SDavid Härdeman if (handler->raw_register) 5694924a311SDavid Härdeman handler->raw_register(dev); 5704924a311SDavid Härdeman mutex_unlock(&ir_raw_handler_lock); 5714924a311SDavid Härdeman 5724924a311SDavid Härdeman return 0; 573f56928abSDavid Härdeman } 5744924a311SDavid Härdeman 575f56928abSDavid Härdeman void ir_raw_event_free(struct rc_dev *dev) 576f56928abSDavid Härdeman { 577f56928abSDavid Härdeman if (!dev) 578f56928abSDavid Härdeman return; 579f56928abSDavid Härdeman 5804924a311SDavid Härdeman kfree(dev->raw); 5814924a311SDavid Härdeman dev->raw = NULL; 5824924a311SDavid Härdeman } 5834924a311SDavid Härdeman 5844924a311SDavid Härdeman void ir_raw_event_unregister(struct rc_dev *dev) 5854924a311SDavid Härdeman { 5864924a311SDavid Härdeman struct ir_raw_handler *handler; 5874924a311SDavid Härdeman 5884924a311SDavid Härdeman if (!dev || !dev->raw) 5894924a311SDavid Härdeman return; 5904924a311SDavid Härdeman 5914924a311SDavid Härdeman kthread_stop(dev->raw->thread); 592e5e26439SSean Young del_timer_sync(&dev->raw->edge_handle); 5934924a311SDavid Härdeman 5944924a311SDavid Härdeman mutex_lock(&ir_raw_handler_lock); 5954924a311SDavid Härdeman list_del(&dev->raw->list); 5964924a311SDavid Härdeman list_for_each_entry(handler, &ir_raw_handler_list, list) 5974924a311SDavid Härdeman if (handler->raw_unregister) 5984924a311SDavid Härdeman handler->raw_unregister(dev); 5994924a311SDavid Härdeman mutex_unlock(&ir_raw_handler_lock); 6004924a311SDavid Härdeman 601f56928abSDavid Härdeman ir_raw_event_free(dev); 6024924a311SDavid Härdeman } 6034924a311SDavid Härdeman 6044924a311SDavid Härdeman /* 6054924a311SDavid Härdeman * Extension interface - used to register the IR decoders 6064924a311SDavid Härdeman */ 6074924a311SDavid Härdeman 6084924a311SDavid Härdeman int ir_raw_handler_register(struct ir_raw_handler *ir_raw_handler) 6094924a311SDavid Härdeman { 6104924a311SDavid Härdeman struct ir_raw_event_ctrl *raw; 6114924a311SDavid Härdeman 6124924a311SDavid Härdeman mutex_lock(&ir_raw_handler_lock); 6134924a311SDavid Härdeman list_add_tail(&ir_raw_handler->list, &ir_raw_handler_list); 6144924a311SDavid Härdeman if (ir_raw_handler->raw_register) 6154924a311SDavid Härdeman list_for_each_entry(raw, &ir_raw_client_list, list) 6164924a311SDavid Härdeman ir_raw_handler->raw_register(raw->dev); 61737e90a22SHeiner Kallweit atomic64_or(ir_raw_handler->protocols, &available_protocols); 6184924a311SDavid Härdeman mutex_unlock(&ir_raw_handler_lock); 6194924a311SDavid Härdeman 6204924a311SDavid Härdeman return 0; 6214924a311SDavid Härdeman } 6224924a311SDavid Härdeman EXPORT_SYMBOL(ir_raw_handler_register); 6234924a311SDavid Härdeman 6244924a311SDavid Härdeman void ir_raw_handler_unregister(struct ir_raw_handler *ir_raw_handler) 6254924a311SDavid Härdeman { 6264924a311SDavid Härdeman struct ir_raw_event_ctrl *raw; 62793cffffcSHeiner Kallweit u64 protocols = ir_raw_handler->protocols; 6284924a311SDavid Härdeman 6294924a311SDavid Härdeman mutex_lock(&ir_raw_handler_lock); 6304924a311SDavid Härdeman list_del(&ir_raw_handler->list); 63193cffffcSHeiner Kallweit list_for_each_entry(raw, &ir_raw_client_list, list) { 63293cffffcSHeiner Kallweit ir_raw_disable_protocols(raw->dev, protocols); 6334924a311SDavid Härdeman if (ir_raw_handler->raw_unregister) 6344924a311SDavid Härdeman ir_raw_handler->raw_unregister(raw->dev); 63593cffffcSHeiner Kallweit } 63637e90a22SHeiner Kallweit atomic64_andnot(protocols, &available_protocols); 6374924a311SDavid Härdeman mutex_unlock(&ir_raw_handler_lock); 6384924a311SDavid Härdeman } 6394924a311SDavid Härdeman EXPORT_SYMBOL(ir_raw_handler_unregister); 640