How to execute linux userspace driver code for infinite time on the target board?

imranpatan

The below code is used to test the uart driver on linux-jetson board which runs only one time,if needed to run multiple times on the board the device needs to be restarted.

include <stdio.h>

include <stdlib.h>

include <fcntl.h>

include <termios.h>

include <string.h>

include <errno.h>

include <limits.h>

include <stdbool.h>

include <unistd.h>

define LOOPBACK_FORMAT "loopback: %s\r\n"

define LOOPBACK_FORMAT_LEN strlen(LOOPBACK_FORMAT)

define MAX_READ_SIZE 235

define MAX_LOOPBACK_SIZE MAX_READ_SIZE + LOOPBACK_FORMAT_LEN

define DEBUG

struct UartDevice {
char* filename;
int rate;

int fd;
struct termios *tty;
};

int uart_start(struct UartDevice* dev, bool canonical) {
struct termios *tty;
int fd;
int rc;

fd = open(dev->filename, O_RDWR | O_NOCTTY);
if (fd < 0) {
printf("%s: failed to open UART device\r\n", func);
return fd;
}

tty = malloc(sizeof(*tty));
if (!tty) {
printf("%s: failed to allocate UART TTY instance\r\n", func);

memset(tty, 0, sizeof(*tty));

/*

• Set baud-rate.
  */
  tty->c_cflag |= dev->rate;

/* Ignore framing and parity errors in input. */
tty->c_iflag |= IGNPAR;

/* Use 8-bit characters. This too may affect standard streams,

• but any sane C library can deal with 8-bit characters. */
  tty->c_cflag |= CS8;

/* Enable receiver. */
tty->c_cflag |= CREAD;

if (canonical) {
/* Enable canonical mode.

• This is the most important bit, as it enables line buffering etc. /
  tty->c_lflag |= ICANON;
  } else {
  / To maintain best compatibility with normal behaviour of terminals,

• we set TIME=0 and MAX=1 in noncanonical mode. This means that

• read() will block until at least one byte is available. */
  tty->c_cc[VTIME] = 0;
  tty->c_cc[VMIN] = 1;
  }

/*

• Flush port.
  */
  tcflush(fd, TCIFLUSH);

/*

• Apply attributes.
  */
  rc = tcsetattr(fd, TCSANOW, tty);
  if (rc) {
  printf("%s: failed to set attributes\r\n", func);
  return rc;
  }

dev->fd = fd;
dev->tty = tty;

return 0;
}/*

• Read a string from the UART device.

• @param dev points to the UART device to be read from

• @param buf points to the start of buffer to be read into

• @param buf_len length of the buffer to be read

• @return - number of bytes read if the read procedure succeeded

• • negative if the read procedure failed
    /
    int uart_reads(struct UartDevice dev, char *buf, size_t buf_len) {
    int rc;

rc = read(dev->fd, buf, buf_len - 1);
if (rc < 0) {
printf("%s: failed to read uart data\r\n", func);
return rc;
}

buf[rc] = '\0';
return rc;
}

/*

• Write data to the UART device.

• @param dev points to the UART device to be written to

• @param buf points to the start of buffer to be written from

• @param buf_len length of the buffer to be written

• @return - number of bytes written if the write procedure succeeded

• • negative if the write procedure failed
    /
    int uart_writen(struct UartDevice dev, char *buf, size_t buf_len) {
    return write(dev->fd, buf, buf_len);
    }

/*

• Write a string to the UART device.

• @param dev points to the UART device to be written to

• @param string points to the start of buffer to be written from

• @return - number of bytes written if the write procedure succeeded

• • negative if the write procedure failed
    /
    int uart_writes(struct UartDevice dev, char *string) {
    size_t len = strlen(string);
    return uart_writen(dev, string, len);
    }

/*

• Stop the UART device.
• @param dev points to the UART device to be stopped
  /
  void uart_stop(struct UartDevice dev) {
  close(dev->fd);
  free(dev->tty);
  }

int main()
{
struct UartDevice dev;
int rc;

dev.filename = "/dev/ttyTHS2";
dev.rate = B115200;

rc = uart_start(&dev, false);
if (rc) {
return rc;
}
char read_data[MAX_READ_SIZE];
char loopback_data[MAX_LOOPBACK_SIZE];
size_t read_data_len;

printf("UART DEMO\r\n");
uart_writes(&dev, "UART DEMO\r\n");

while (1)
{

read_data_len = uart_reads(&dev, read_data, MAX_READ_SIZE);

if (read_data_len > 0) {
printf("%s", read_data);
snprintf(loopback_data, MAX_LOOPBACK_SIZE, LOOPBACK_FORMAT, read_data);
uart_writes(&dev, loopback_data);
}

}

uart_stop(&dev);

return 0;
}

Could anyone please help me out what are the changes to be done to execute the above code infinite times?

Thanks and regards,
Imran patan,
India.