Process that can sleep waiting for a tty driver protocol RX - c

Question

My aim is to have a user space linux process that sleep while a tty uart based driver is receiving a message.
The protocol is a very simple (bad) stream of data that starts with a break signal followed by 513 bytes.
So far I modified the freescale's tty uart driver interrupt to receive the message.
static int DMX_RX(struct imx_port *sport)
{
struct tty_port *port = &sport->port.state->port;
tty_flip_buffer_push(port);
struct uart_state *state = sport->port.state;
if (sport->port.flags & UPF_SAK)
do_SAK(state->port.tty);
return 0;
}
static irqreturn_t imx_rxint(int irq, void *dev_id)
{
struct imx_port *sport = dev_id;
unsigned int rx, flg, ignored = 0;
struct tty_port *port = &sport->port.state->port;
unsigned long flags, temp;
spin_lock_irqsave(&sport->port.lock, flags);
while (readl(sport->port.membase + USR2) & USR2_RDR)
{
flg = TTY_NORMAL;
sport->port.icount.rx++;
rx = readl(sport->port.membase + URXD0);
temp = readl(sport->port.membase + USR2);
if (temp & USR2_BRCD)
{
writel(USR2_BRCD, sport->port.membase + USR2);
// Break received then push the message to userspace
DMX_RX(sport);
}
else
{
// Byte received then put it in the flip buffer
tty_insert_flip_char(port, rx, flg);
}
.....
// other stuff
.....
out:
spin_unlock_irqrestore(&sport->port.lock, flags);
return IRQ_HANDLED;
}
Then I implemented a simple process on linux user space as below:
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <linux/termios.h>
#include <sched.h>
int ioctl(int d, int request, ...);
#define MAX_DATA_LOG 1000
int main(int argc, char *argv[])
{
struct termios2 t;
int fd,baud;
char buf[513];
fd = open("/dev/ttyDMXc4", O_RDONLY | O_NOCTTY | O_NDELAY);
baud = 250000;
if (ioctl(fd, TCGETS2, &t))
{
perror("TCGETS2");
return 3;
}
t.c_cflag &= ~CBAUD;
t.c_cflag |= BOTHER;
t.c_cflag |= CSTOPB;
t.c_ospeed = baud;
t.c_lflag &= ~(ICANON | ISIG | IEXTEN | ECHO);
/* Noncanonical mode, disable signals, extended
input processing, and echoing */
t.c_iflag &= ~(BRKINT | ICRNL | IGNBRK | IGNCR | INLCR |
INPCK | ISTRIP | IXON | PARMRK);
/* Disable special handling of CR, NL, and BREAK.
No 8th-bit stripping or parity error handling.
Disable START/STOP output flow control. */
t.c_oflag &= ~OPOST; /* Disable all output processing */
if (ioctl(fd, TCSETS2, &t))
{
perror("TCSETS2");
return 4;
}
if (ioctl(fd, TCGETS2, &t))
{
perror("TCGETS2");
return 5;
}
printf("actual speed reported %d\n", t.c_ospeed);
typedef struct {
unsigned long time;
unsigned int res;
}stuct_appo;
int ret = 1;
int res;
int i;
fd_set read_fds;
struct timeval tv;
int data_log_idx=1;
stuct_appo data_log[MAX_DATA_LOG];
struct timespec now;
while (1)
{
tv.tv_sec = 1;
tv.tv_usec = 0;
FD_ZERO(&read_fds);
FD_SET(fd, &read_fds);
ret = select (fd+1, &read_fds, NULL, NULL, &tv);
if (ret > 0)
{
res = read (fd, buf, 513);
if (res > 0)
{
clock_gettime(0, &now);
data_log[data_log_idx].time = now.tv_nsec;
data_log[data_log_idx].res = res;
data_log_idx = (data_log_idx % MAX_DATA_LOG) + 1;
}
}
else
{
int i;
printf("TIMEOUT %d!!!\n", ret);
for (i=1; i<data_log_idx; i++)
printf("%lu\n", data_log[i].time);
for (i=1; i<data_log_idx; i++)
printf("%d\n", data_log[i].res);
}
}
return 0;
}
As you can see the select has a 1 sec of timeout.
I start my process and after receiving some messages I stop the sender and the process printout timings and received char.
What I can see is that sometimes (very often) select return and the read: eg 69 bytes.
At the end all 513 bytes are read, but shared on 2 or 3 read, eg: 154 and 359 bytes.
I'm sure that driver push data of split buffer each 513 bytes, so my doubt is:
Is select awaking at the wrong time when the flip buffer is not pushed?
Is the read function that can read less that the whole buffer even if I specified 513 in the third parameter?