The driver report a reset event when the hardware reports and overflow.
There is no reason to have a generic "reset" event.
Signed-off-by: Sean Young <sean@mess.org>
Signed-off-by: Mauro Carvalho Chehab <mchehab@kernel.org>
} while (num != 0);
if (overrun)
- ir_raw_event_reset(kernel_ir->rc);
+ ir_raw_event_overflow(kernel_ir->rc);
else if (handle)
ir_raw_event_handle(kernel_ir->rc);
}
if (fintek->rem)
fintek->parser_state = PARSE_IRDATA;
else
- ir_raw_event_reset(fintek->rdev);
+ ir_raw_event_overflow(fintek->rdev);
break;
case SUBCMD:
fintek->rem = fintek_cmdsize(fintek->cmd, sample);
if (overflow > 0) {
dev_warn(ir->dev, "receive overflow, at least %u lost",
overflow);
- ir_raw_event_reset(ir->rc);
+ ir_raw_event_overflow(ir->rc);
}
do {
break;
case CMD_RX_OVERFLOW:
dev_warn(ir->dev, "receive overflow\n");
- ir_raw_event_reset(ir->rc);
+ ir_raw_event_overflow(ir->rc);
break;
default:
dev_warn(ir->dev, "control code %02x received\n",
* IR_INTS availably since logic would not clear
* fifo when overflow, drv do the job
*/
- ir_raw_event_reset(priv->rdev);
+ ir_raw_event_overflow(priv->rdev);
symb_num = readl_relaxed(priv->base + IR_DATAH);
for (i = 0; i < symb_num; i++)
readl_relaxed(priv->base + IR_DATAL);
struct imon_dec *data = &dev->raw->imon;
if (!is_timing_event(ev)) {
- if (ev.reset)
+ if (ev.overflow)
data->state = STATE_INACTIVE;
return 0;
}
struct jvc_dec *data = &dev->raw->jvc;
if (!is_timing_event(ev)) {
- if (ev.reset)
+ if (ev.overflow)
data->state = STATE_INACTIVE;
return 0;
}
struct lirc_scancode lsc = {};
if (!is_timing_event(ev)) {
- if (ev.reset)
+ if (ev.overflow)
data->state = STATE_INACTIVE;
return 0;
}
u8 address, not_address, command, not_command;
if (!is_timing_event(ev)) {
- if (ev.reset)
+ if (ev.overflow)
data->state = STATE_INACTIVE;
return 0;
}
enum rc_proto protocol;
if (!is_timing_event(ev)) {
- if (ev.reset)
+ if (ev.overflow)
data->state = STATE_INACTIVE;
return 0;
}
enum rc_proto protocol;
if (!is_timing_event(ev)) {
- if (ev.reset)
+ if (ev.overflow)
data->state = STATE_INACTIVE;
return 0;
}
return 0;
if (!is_timing_event(ev)) {
- if (ev.reset)
+ if (ev.overflow)
data->state = STATE_INACTIVE;
return 0;
}
u8 command, not_command;
if (!is_timing_event(ev)) {
- if (ev.reset) {
- dev_dbg(&dev->dev, "SANYO event reset received. reset to state 0\n");
+ if (ev.overflow) {
+ dev_dbg(&dev->dev, "SANYO event overflow received. reset to state 0\n");
data->state = STATE_INACTIVE;
}
return 0;
u32 msg, echo, address, command, scancode;
if (!is_timing_event(ev)) {
- if (ev.reset)
+ if (ev.overflow)
data->state = STATE_INACTIVE;
return 0;
}
u8 device, subdevice, function;
if (!is_timing_event(ev)) {
- if (ev.reset)
+ if (ev.overflow)
data->state = STATE_INACTIVE;
return 0;
}
struct xmp_dec *data = &dev->raw->xmp;
if (!is_timing_event(ev)) {
- if (ev.reset)
+ if (ev.overflow)
data->state = STATE_INACTIVE;
return 0;
}
/* Check for RX overflow */
if (iflags & ITE_IRQ_RX_FIFO_OVERRUN) {
dev_warn(&dev->rdev->dev, "receive overflow\n");
- ir_raw_event_reset(dev->rdev);
+ ir_raw_event_overflow(dev->rdev);
}
/* check for the receive interrupt */
struct lirc_fh *fh;
int sample;
- /* Packet start */
- if (ev.reset) {
+ /* Receiver overflow, data missing */
+ if (ev.overflow) {
/*
* 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
+ * packets and normal samples. But if an overflow 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);
- dev_dbg(&dev->dev, "delivering reset sync space to lirc_dev\n");
+ dev_dbg(&dev->dev, "delivering overflow space to lirc_dev\n");
/* Carrier reports */
} else if (ev.carrier_report) {
nvt->pkts = 0;
nvt_clear_cir_fifo(nvt);
- ir_raw_event_reset(nvt->rdev);
+ ir_raw_event_overflow(nvt->rdev);
}
/* copy data from hardware rx fifo into driver buffer */
/* Returns true if event is normal pulse/space event */
static inline bool is_timing_event(struct ir_raw_event ev)
{
- return !ev.carrier_report && !ev.reset;
+ return !ev.carrier_report && !ev.overflow;
}
#define TO_STR(is_pulse) ((is_pulse) ? "pulse" : "space")
!is_transition(&ev, &raw->prev_ev))
dev_warn_once(&dev->dev, "two consecutive events of type %s",
TO_STR(ev.pulse));
- if (raw->prev_ev.reset && ev.pulse == 0)
- dev_warn_once(&dev->dev, "timing event after reset should be pulse");
}
list_for_each_entry(handler, &ir_raw_handler_list, list)
if (dev->enabled_protocols &
int_status = readl(dev->rx_base + IRB_RX_INT_STATUS);
if (unlikely(int_status & IRB_RX_OVERRUN_INT)) {
/* discard the entire collection in case of errors! */
- ir_raw_event_reset(dev->rdev);
+ ir_raw_event_overflow(dev->rdev);
dev_info(dev->dev, "IR RX overrun\n");
writel(IRB_RX_OVERRUN_INT,
dev->rx_base + IRB_RX_INT_CLEAR);
}
if (status & REG_RXSTA_ROI) {
- ir_raw_event_reset(ir->rc);
+ ir_raw_event_overflow(ir->rc);
} else if (status & REG_RXSTA_RPE) {
ir_raw_event_set_idle(ir->rc, true);
ir_raw_event_handle(ir->rc);
/* RX overflow? (read clears bit) */
if (inb(data->sbase + WBCIR_REG_SP3_LSR) & WBCIR_RX_OVERRUN) {
data->rxstate = WBCIR_RXSTATE_ERROR;
- ir_raw_event_reset(data->dev);
+ ir_raw_event_overflow(data->dev);
}
/* TX underflow? */
u8 duty_cycle;
unsigned pulse:1;
- unsigned reset:1;
+ unsigned overflow:1;
unsigned timeout:1;
unsigned carrier_report:1;
};
struct ir_raw_event *events, unsigned int max);
int ir_raw_encode_carrier(enum rc_proto protocol);
-static inline void ir_raw_event_reset(struct rc_dev *dev)
+static inline void ir_raw_event_overflow(struct rc_dev *dev)
{
- ir_raw_event_store(dev, &((struct ir_raw_event) { .reset = true }));
+ ir_raw_event_store(dev, &((struct ir_raw_event) { .overflow = true }));
dev->idle = true;
ir_raw_event_handle(dev);
}
projects / platform / kernel / linux-starfive.git / commitdiff