nuttx/drivers/rc/lirc_dev.c
Jiuzhu Dong 018cf26605 lirc: fix bug about lirc_raw_event
N/A

Change-Id: If00d0a7e4e4f9a0d9119b6a170cffd993f23f71a
Signed-off-by: Jiuzhu Dong <dongjiuzhu1@xiaomi.com>
2021-05-15 09:47:28 -07:00

1069 lines
27 KiB
C

/****************************************************************************
* drivers/rc/lirc_dev.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <stdio.h>
#include <errno.h>
#include <poll.h>
#include <fcntl.h>
#include <nuttx/kmalloc.h>
#include <nuttx/mm/circbuf.h>
#include <nuttx/rc/lirc_dev.h>
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#define DEVNAME_FMT "/dev/lirc%d"
#define DEVNAME_MAX 32
/****************************************************************************
* Private Types
****************************************************************************/
/* This structure describes the state of the upper half driver */
struct lirc_upperhalf_s
{
struct list_node fh; /* list of struct lirc_fh_s object */
FAR struct lirc_lowerhalf_s *lower; /* the handle of lower half driver */
sem_t exclsem; /* Manages exclusive access to lowerhalf */
bool gap; /* true if we're in a gap */
uint64_t gap_start; /* time when gap starts */
uint64_t gap_duration; /* duration of initial gap */
};
/* The structure describes an open lirc file */
struct lirc_fh_s
{
struct list_node node; /* list of open file handles */
FAR struct lirc_lowerhalf_s *lower; /* the pointer to lirc_lowerhalf_s */
struct circbuf_s buffer; /* buffer for incoming IR */
FAR struct pollfd *fd; /* poll structures of threads waiting for driver events */
sem_t waitsem; /* sem of wait buffer for ready */
int carrier_low; /* when setting the carrier range, first the low end must be
* set with an ioctl and then the high end with another ioctl
*/
unsigned char send_mode; /* lirc mode for sending, LIRC_MODE_PULSE LIRC_MODE_SCANCODE */
unsigned char rec_mode; /* lirc mode for receiving, LIRC_MODE_MODE2 LIRC_MODE_SCANCODE */
bool send_timeout_reports; /* report timeouts in lirc raw IR. */
};
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
static void lirc_pollnotify(FAR struct lirc_fh_s *fh, pollevent_t eventset);
static int lirc_open(FAR struct file *filep);
static int lirc_close(FAR struct file *filep);
static int lirc_ioctl(FAR struct file *filep, int cmd, unsigned long arg);
static int lirc_poll(FAR struct file *filep, FAR struct pollfd *fds,
bool setup);
static ssize_t lirc_write(FAR struct file *filep, FAR const char *buffer,
size_t buflen);
static ssize_t lirc_read(FAR struct file *filep, FAR char *buffer,
size_t buflen);
/****************************************************************************
* Private Data
****************************************************************************/
static const struct file_operations g_lirc_fops =
{
lirc_open, /* open */
lirc_close, /* close */
lirc_read, /* read */
lirc_write, /* write */
NULL, /* seek */
lirc_ioctl, /* ioctl */
lirc_poll, /* poll */
};
/****************************************************************************
* Private Functions
****************************************************************************/
static void lirc_pollnotify(FAR struct lirc_fh_s *fh,
pollevent_t eventset)
{
int semcount;
if (fh->fd)
{
fh->fd->revents |= (fh->fd->events & eventset);
if (fh->fd->revents != 0)
{
rcinfo("Report events: %02x\n", fh->fd->revents);
nxsem_get_value(fh->fd->sem, &semcount);
if (semcount < 1)
{
nxsem_post(fh->fd->sem);
}
}
}
}
static int lirc_open(FAR struct file *filep)
{
FAR struct inode *inode = filep->f_inode;
FAR struct lirc_upperhalf_s *upper = inode->i_private;
FAR struct lirc_lowerhalf_s *lower = upper->lower;
FAR struct lirc_fh_s *fh;
irqstate_t flags;
int ret;
fh = kmm_zalloc(sizeof(*fh));
if (!fh)
{
return -ENOMEM;
}
switch (lower->ops->driver_type)
{
case LIRC_DRIVER_SCANCODE:
fh->rec_mode = LIRC_MODE_SCANCODE;
break;
default:
fh->rec_mode = LIRC_MODE_MODE2;
break;
}
if (lower->ops->tx_scancode)
{
fh->send_mode = LIRC_MODE_SCANCODE;
}
else if (lower->ops->tx_ir)
{
fh->send_mode = LIRC_MODE_PULSE;
}
ret = circbuf_init(&fh->buffer, NULL, lower->buffer_bytes);
if (ret < 0)
{
goto buffer_err;
}
nxsem_init(&fh->waitsem, 0, 0);
nxsem_set_protocol(&fh->waitsem, SEM_PRIO_NONE);
fh->lower = lower;
fh->send_timeout_reports = true;
if (list_is_empty(&upper->fh))
{
ret = lower->ops->open(lower);
if (ret < 0)
{
goto open_err;
}
}
flags = enter_critical_section();
list_add_tail(&upper->fh, &fh->node);
leave_critical_section(flags);
filep->f_priv = fh;
return 0;
open_err:
nxsem_destroy(&fh->waitsem);
circbuf_uninit(&fh->buffer);
buffer_err:
kmm_free(fh);
return ret;
}
static int lirc_close(FAR struct file *filep)
{
FAR struct inode *inode = filep->f_inode;
FAR struct lirc_upperhalf_s *upper = inode->i_private;
FAR struct lirc_fh_s *fh = filep->f_priv;
FAR struct lirc_lowerhalf_s *lower = fh->lower;
irqstate_t flags;
flags = enter_critical_section();
list_delete(&fh->node);
leave_critical_section(flags);
nxsem_destroy(&fh->waitsem);
circbuf_uninit(&fh->buffer);
kmm_free(fh);
if (list_is_empty(&upper->fh))
{
lower->ops->close(lower);
}
return 0;
}
static int lirc_poll(FAR struct file *filep,
FAR struct pollfd *fds, bool setup)
{
FAR struct lirc_fh_s *fh = filep->f_priv;
pollevent_t eventset = 0;
irqstate_t flags;
int ret = 0;
flags = enter_critical_section();
if (setup)
{
if (fh->fd)
{
ret = -EBUSY;
goto errout;
}
fh->fd = fds;
fds->priv = &fh->fd;
if (!circbuf_is_empty(&fh->buffer))
{
eventset = (fds->events & (POLLIN | POLLRDNORM));
}
if (eventset)
{
lirc_pollnotify(fh, eventset);
}
}
else if (fds->priv != NULL)
{
FAR struct pollfd **slot = (FAR struct pollfd **)fds->priv;
if (!slot)
{
ret = -EIO;
goto errout;
}
*slot = NULL;
fds->priv = NULL;
}
errout:
leave_critical_section(flags);
return ret;
}
static int lirc_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
{
FAR struct lirc_fh_s *fh = filep->f_priv;
FAR struct lirc_lowerhalf_s *lower = fh->lower;
FAR struct lirc_upperhalf_s *upper = lower->priv;
FAR unsigned int *val = (unsigned int *)(uintptr_t)arg;
int ret;
ret = nxsem_wait(&upper->exclsem);
if (ret < 0)
{
return ret;
}
switch (cmd)
{
case LIRC_GET_FEATURES:
switch (lower->ops->driver_type)
{
case LIRC_DRIVER_SCANCODE:
*val = LIRC_CAN_REC_SCANCODE;
break;
case LIRC_DRIVER_IR_RAW:
*val = LIRC_CAN_REC_MODE2;
break;
default:
*val = 0;
break;
}
if (lower->rx_resolution)
{
*val |= LIRC_CAN_GET_REC_RESOLUTION;
}
if (lower->ops->tx_ir)
{
*val |= LIRC_CAN_SEND_PULSE;
}
if (lower->ops->tx_scancode)
{
*val |= LIRC_CAN_SEND_SCANCODE;
}
if (lower->ops->s_tx_mask)
{
*val |= LIRC_CAN_SET_TRANSMITTER_MASK;
}
if (lower->ops->s_tx_carrier)
{
*val |= LIRC_CAN_SET_SEND_CARRIER;
}
if (lower->ops->s_tx_duty_cycle)
{
*val |= LIRC_CAN_SET_SEND_DUTY_CYCLE;
}
if (lower->ops->s_rx_carrier_range)
{
*val |= LIRC_CAN_SET_REC_CARRIER |
LIRC_CAN_SET_REC_CARRIER_RANGE;
}
if (lower->ops->s_learning_mode)
{
*val |= LIRC_CAN_USE_WIDEBAND_RECEIVER;
}
if (lower->ops->s_carrier_report)
{
*val |= LIRC_CAN_MEASURE_CARRIER;
}
if (lower->max_timeout)
{
*val |= LIRC_CAN_SET_REC_TIMEOUT;
}
break;
/* mode support */
case LIRC_GET_REC_MODE:
if (lower->ops->driver_type == LIRC_DRIVER_IR_RAW_TX)
{
ret = -ENOTTY;
}
else
{
*val = fh->rec_mode;
}
break;
case LIRC_SET_REC_MODE:
switch (lower->ops->driver_type)
{
case LIRC_DRIVER_IR_RAW_TX:
ret = -ENOTTY;
break;
case LIRC_DRIVER_SCANCODE:
if (arg != LIRC_MODE_SCANCODE)
{
ret = -EINVAL;
}
break;
case LIRC_DRIVER_IR_RAW:
if (arg != LIRC_MODE_MODE2)
{
ret = -EINVAL;
}
break;
}
if (ret >= 0)
{
fh->rec_mode = arg;
}
break;
case LIRC_GET_SEND_MODE:
if (!lower->ops->tx_ir && !lower->ops->tx_scancode)
{
ret = -ENOTTY;
}
else
{
*val = fh->send_mode;
}
break;
case LIRC_SET_SEND_MODE:
if ((arg == LIRC_MODE_PULSE && lower->ops->tx_ir) ||
(arg == LIRC_MODE_SCANCODE && lower->ops->tx_scancode))
{
fh->send_mode = arg;
}
else
{
ret = -EINVAL;
}
break;
/* TX settings */
case LIRC_SET_TRANSMITTER_MASK:
if (!lower->ops->s_tx_mask)
{
ret = -ENOTTY;
}
else
{
ret = lower->ops->s_tx_mask(lower, arg);
}
break;
case LIRC_SET_SEND_CARRIER:
if (!lower->ops->s_tx_carrier)
{
ret = -ENOTTY;
}
else
{
ret = lower->ops->s_tx_carrier(lower, arg);
}
break;
case LIRC_SET_SEND_DUTY_CYCLE:
if (!lower->ops->s_tx_duty_cycle)
{
ret = -ENOTTY;
}
else if (arg <= 0 || arg >= 100)
{
ret = -EINVAL;
}
else
{
ret = lower->ops->s_tx_duty_cycle(lower, arg);
}
break;
/* RX settings */
case LIRC_SET_REC_CARRIER:
if (!lower->ops->s_rx_carrier_range)
{
ret = -ENOTTY;
}
else if (arg <= 0)
{
ret = -EINVAL;
}
else
{
ret = lower->ops->s_rx_carrier_range(lower,
fh->carrier_low, arg);
}
break;
case LIRC_SET_REC_CARRIER_RANGE:
if (!lower->ops->s_rx_carrier_range)
{
ret = -ENOTTY;
}
else if (arg <= 0)
{
ret = -EINVAL;
}
else
{
fh->carrier_low = arg;
}
break;
case LIRC_GET_REC_RESOLUTION:
if (!lower->rx_resolution)
{
ret = -ENOTTY;
}
else
{
*val = lower->rx_resolution;
}
break;
case LIRC_SET_WIDEBAND_RECEIVER:
if (!lower->ops->s_learning_mode)
{
ret = -ENOTTY;
}
else
{
ret = lower->ops->s_learning_mode(lower, !!arg);
}
break;
case LIRC_SET_MEASURE_CARRIER_MODE:
if (!lower->ops->s_carrier_report)
{
ret = -ENOTTY;
}
else
{
ret = lower->ops->s_carrier_report(lower, !!arg);
}
break;
/* Generic timeout support */
case LIRC_GET_MIN_TIMEOUT:
if (!lower->min_timeout)
{
ret = -ENOTTY;
}
else
{
*val = lower->min_timeout;
}
break;
case LIRC_GET_MAX_TIMEOUT:
if (!lower->max_timeout)
{
ret = -ENOTTY;
}
else
{
*val = lower->max_timeout;
}
break;
case LIRC_SET_REC_TIMEOUT:
if (!lower->max_timeout)
{
ret = -ENOTTY;
}
else
{
if (arg < lower->min_timeout || arg > lower->max_timeout)
{
ret = -EINVAL;
}
else if (lower->ops->s_timeout)
{
ret = lower->ops->s_timeout(lower, arg);
}
else
{
lower->timeout = arg;
}
}
break;
case LIRC_GET_REC_TIMEOUT:
if (!lower->timeout)
{
ret = -ENOTTY;
}
else
{
*val = lower->timeout;
}
break;
case LIRC_SET_REC_TIMEOUT_REPORTS:
if (lower->ops->driver_type != LIRC_DRIVER_IR_RAW)
{
ret = -ENOTTY;
}
else
{
fh->send_timeout_reports = !!arg;
}
break;
default:
ret = -ENOTTY;
}
nxsem_post(&upper->exclsem);
return ret;
}
static ssize_t lirc_write_pulse(FAR struct file *filep,
FAR const char *buffer, size_t buflen)
{
FAR struct lirc_fh_s *fh = filep->f_priv;
FAR struct lirc_lowerhalf_s *lower = fh->lower;
size_t count;
if (buflen < sizeof(unsigned int) || buflen % sizeof(unsigned int))
{
return -EINVAL;
}
count = buflen / sizeof(unsigned int);
if (count % 2 == 0)
{
return -EINVAL;
}
/* tx_ir need sleep some time to wait for thr actual IR signal
* to be transmitted before returning
*/
return lower->ops->tx_ir(lower, (FAR unsigned int *)buffer, count);
}
static ssize_t lirc_write_scancode(FAR struct file *filep,
FAR const char *buffer, size_t buflen)
{
FAR struct lirc_fh_s *fh = filep->f_priv;
FAR struct lirc_lowerhalf_s *lower = fh->lower;
if (buflen != sizeof(struct lirc_scancode))
{
return -EINVAL;
}
/* tx_scancode need sleep some time to wait for thr actual IR signal
* to be transmitted before returning
*/
return lower->ops->tx_scancode(lower,
(FAR struct lirc_scancode *)buffer);
}
static ssize_t lirc_write(FAR struct file *filep, FAR const char *buffer,
size_t buflen)
{
FAR struct inode *inode = filep->f_inode;
FAR struct lirc_upperhalf_s *upper = inode->i_private;
FAR struct lirc_fh_s *fh = filep->f_priv;
ssize_t ret;
ret = nxsem_wait(&upper->exclsem);
if (ret < 0)
{
return ret;
}
if (fh->send_mode == LIRC_MODE_SCANCODE)
{
ret = lirc_write_scancode(filep, buffer, buflen);
}
else
{
ret = lirc_write_pulse(filep, buffer, buflen);
}
nxsem_post(&upper->exclsem);
return ret;
}
static ssize_t lirc_read_scancode(FAR struct file *filep, FAR char *buffer,
size_t length)
{
FAR struct lirc_fh_s *fh = filep->f_priv;
irqstate_t flags;
ssize_t ret;
if (length < sizeof(struct lirc_scancode) ||
length % sizeof(struct lirc_scancode))
{
return -EINVAL;
}
flags = enter_critical_section();
do
{
if (circbuf_is_empty(&fh->buffer))
{
if (filep->f_oflags & O_NONBLOCK)
{
ret = -EAGAIN;
goto err;
}
ret = nxsem_wait_uninterruptible(&fh->waitsem);
if (ret < 0)
{
goto err;
}
}
ret = circbuf_read(&fh->buffer, buffer, length);
}
while (ret <= 0);
err:
leave_critical_section(flags);
return ret;
}
static ssize_t lirc_read_mode2(FAR struct file *filep, FAR char *buffer,
size_t length)
{
FAR struct lirc_fh_s *fh = filep->f_priv;
irqstate_t flags;
ssize_t ret = 0;
if (length < sizeof(unsigned int) || length % sizeof(unsigned int))
{
return -EINVAL;
}
flags = enter_critical_section();
do
{
if (circbuf_is_empty(&fh->buffer))
{
if (filep->f_oflags & O_NONBLOCK)
{
ret = -EAGAIN;
goto err;
}
ret = nxsem_wait_uninterruptible(&fh->waitsem);
if (ret < 0)
{
goto err;
}
}
ret = circbuf_read(&fh->buffer, buffer, length);
}
while (ret <= 0);
err:
leave_critical_section(flags);
return ret;
}
static ssize_t lirc_read(FAR struct file *filep, FAR char *buffer,
size_t len)
{
FAR struct lirc_fh_s *fh = filep->f_priv;
if (fh->rec_mode == LIRC_MODE_MODE2)
{
return lirc_read_mode2(filep, buffer, len);
}
else /* LIRC_MODE_SCANCODE */
{
return lirc_read_scancode(filep, buffer, len);
}
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: lirc_register
*
* Description:
* This function binds an instance of a "lower half" lirc driver with the
* "upper half" RC device and registers that device so that can be used
* by application code.
*
* We will register the chararter device. ex: /dev/lirc%d(0, 1, ...)
*
* Input Parameters:
* lower - A pointer to an instance of lower half lirc driver.
* devno - The user specifies device number, from 0. If the
* devno alerady exists, -EEXIST will be returned.
*
* Returned Value:
* OK if the driver was successfully register; A negated errno value is
* returned on any failure.
*
****************************************************************************/
int lirc_register(FAR struct lirc_lowerhalf_s *lower, int devno)
{
FAR struct lirc_upperhalf_s *upper;
char path[DEVNAME_MAX];
int ret;
DEBUGASSERT(lower != NULL);
/* Allocate and init the upper-half data structure */
upper = kmm_zalloc(sizeof(struct lirc_upperhalf_s));
if (!upper)
{
snerr("ERROR: Allocation failed\n");
return -ENOMEM;
}
upper->lower = lower;
list_initialize(&upper->fh);
nxsem_init(&upper->exclsem, 0, 1);
lower->priv = upper;
/* Register remote control character device */
snprintf(path, DEVNAME_MAX, DEVNAME_FMT, devno);
ret = register_driver(path, &g_lirc_fops, 0666, upper);
if (ret < 0)
{
goto drv_err;
}
return ret;
drv_err:
nxsem_destroy(&upper->exclsem);
kmm_free(upper);
return ret;
}
/****************************************************************************
* Name: lirc_unregister
*
* Description:
* This function unregister character node and release all resource about
* upper half driver.
*
* Input Parameters:
* lower - A pointer to an instance of lower half lirc driver.
* devno - The user specifies device number, from 0.
****************************************************************************/
void lirc_unregister(FAR struct lirc_lowerhalf_s *lower, int devno)
{
FAR struct lirc_upperhalf_s *upper = lower->priv;
char path[DEVNAME_MAX];
nxsem_destroy(&upper->exclsem);
snprintf(path, DEVNAME_MAX, DEVNAME_FMT, devno);
rcinfo("UnRegistering %s\n", path);
unregister_driver(path);
kmm_free(upper);
}
/****************************************************************************
* Name: lirc_raw_event
*
* Description:
* Lirc lowerhalf driver sends IR data to lirc upperhalf buffer, to
* notify userspace to read IR data.
*
* The type of data is struct lirc_raw_event_s.
*
* Input Parameters:
* lower - A pointer to an instance of lower half lirc driver.
* ev - The data of receiving from IR device
****************************************************************************/
void lirc_raw_event(FAR struct lirc_lowerhalf_s *lower,
struct lirc_raw_event_s ev)
{
FAR struct lirc_upperhalf_s *upper = lower->priv;
FAR struct list_node *node;
FAR struct list_node *tmp;
FAR struct lirc_fh_s *fh;
unsigned int sample;
irqstate_t flags;
int semcount;
int gap;
/* Packet start */
if (ev.reset)
{
/* Userspace expects a long space event before the start of
* the signal to use as a sync. This may be done with repeat
* packets and normal samples. But if a reset has been sent
* then we assume that a long time has passed, so we send a
* space with the maximum time value.
*/
sample = LIRC_SPACE(LIRC_VALUE_MASK);
rcinfo("delivering reset sync space to lirc_dev\n");
}
else if (ev.carrier_report)
{
/* Carrier reports */
sample = LIRC_FREQUENCY(ev.carrier);
rcinfo("carrier report (freq: %d)\n", sample);
}
else if (ev.timeout)
{
/* Packet end */
if (upper->gap)
{
return;
}
upper->gap = true;
upper->gap_start = lirc_get_timestamp() / 1000;
upper->gap_duration = ev.duration;
sample = LIRC_TIMEOUT(ev.duration);
rcinfo("timeout report (duration: %d)\n", sample);
}
else
{
/* Normal sample */
if (upper->gap)
{
upper->gap_duration += (lirc_get_timestamp() / 1000) -
upper->gap_start;
/* Cap by LIRC_VALUE_MASK */
upper->gap_duration = MIN(upper->gap_duration, LIRC_VALUE_MASK);
gap = LIRC_SPACE(upper->gap_duration);
flags = enter_critical_section();
list_for_every_safe(&upper->fh, node, tmp)
{
fh = (FAR struct lirc_fh_s *)node;
if (circbuf_write(&fh->buffer, &gap, sizeof(int)) > 0)
{
lirc_pollnotify(fh, POLLIN | POLLRDNORM);
nxsem_get_value(&fh->waitsem, &semcount);
if (semcount < 1)
{
nxsem_post(&fh->waitsem);
}
}
upper->gap = false;
}
leave_critical_section(flags);
}
sample = ev.pulse ? LIRC_PULSE(ev.duration) : LIRC_SPACE(ev.duration);
rcinfo("delivering %uus %d to lirc\n", ev.duration, ev.pulse ? 1 : 0);
}
flags = enter_critical_section();
list_for_every_safe(&upper->fh, node, tmp)
{
fh = (FAR struct lirc_fh_s *)node;
if (LIRC_IS_TIMEOUT(sample) && !fh->send_timeout_reports)
{
continue;
}
if (circbuf_write(&fh->buffer, &sample, sizeof(unsigned int)) > 0)
{
lirc_pollnotify(fh, POLLIN | POLLRDNORM);
nxsem_get_value(&fh->waitsem, &semcount);
if (semcount < 1)
{
nxsem_post(&fh->waitsem);
}
}
}
leave_critical_section(flags);
}
/****************************************************************************
* Name: lirc_scancode_event
*
* Description:
* Lirc lowerhalf driver sends IR data to lirc upperhalf buffer, to
* notify userspace to read IR data.
*
* The type of data is struct lirc_scancode.
*
* Input Parameters:
* lower - A pointer to an instance of lower half lirc driver.
* lsc - The data of receiving from IR device
****************************************************************************/
void lirc_scancode_event(FAR struct lirc_lowerhalf_s *lower,
FAR struct lirc_scancode *lsc)
{
FAR struct lirc_upperhalf_s *upper = lower->priv;
FAR struct list_node *node;
FAR struct list_node *tmp;
FAR struct lirc_fh_s *fh;
irqstate_t flags;
int semcount;
lsc->timestamp = lirc_get_timestamp();
flags = enter_critical_section();
list_for_every_safe(&upper->fh, node, tmp)
{
fh = (FAR struct lirc_fh_s *)node;
if (circbuf_write(&fh->buffer, lsc, sizeof(*lsc)) > 0)
{
lirc_pollnotify(fh, POLLIN | POLLRDNORM);
nxsem_get_value(&fh->waitsem, &semcount);
if (semcount < 1)
{
nxsem_post(&fh->waitsem);
}
}
}
leave_critical_section(flags);
}
/****************************************************************************
* Name: lirc_sample_event
*
* Description:
* Lirc lowerhalf driver sends raw IR data to lirc upperhalf buffer, to
* notify userspace to read IR data.
*
* The type of data is a sequence of pulse and space codes, as a seriers
* of unsigned int values.
*
* The upper 8 bits determine the packet type, and the lower 24 bits the
* payload.
*
* Input Parameters:
* lower - A pointer to an instance of lower half lirc driver.
* sample - The data of receiving from IR device
****************************************************************************/
void lirc_sample_event(FAR struct lirc_lowerhalf_s *lower,
unsigned int sample)
{
FAR struct lirc_upperhalf_s *upper = lower->priv;
FAR struct list_node *node;
FAR struct list_node *tmp;
FAR struct lirc_fh_s *fh;
irqstate_t flags;
int semcount;
flags = enter_critical_section();
list_for_every_safe(&upper->fh, node, tmp)
{
fh = (FAR struct lirc_fh_s *)node;
if (circbuf_write(&fh->buffer, &sample, sizeof(unsigned int)) > 0)
{
lirc_pollnotify(fh, POLLIN | POLLRDNORM);
nxsem_get_value(&fh->waitsem, &semcount);
if (semcount < 1)
{
nxsem_post(&fh->waitsem);
}
}
}
leave_critical_section(flags);
}