AM335 - UART - BeagleBone Loopback Test

/*
 * UART Loop back test for L138 and OMAP3 EVM
 *
 * Based on  uart-loopback.c -
 *     userspace uart loopback test <http://elinux.org/File:Uart-loopback.c>
 *
 * Modified by <sinoj@mistralsolutions.com> 
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 *
 * 
 */

/* Compilation */
/* arm-none-linux-gnueabi-gcc uart-loopback_st.c -o ltest */

/* Execution */
/* ./ltest </dev/ttyS1> <115200> */

/* Flow control disabled, one thread, (write CBUFSIZE bytes of data 
 * and read back it and compare )  WRLOOP times  */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <getopt.h>
#include <termios.h>
#include <sys/ioctl.h>

#define CBUFSIZE 256 
#define WRLOOP 64 

/* Gvariables */

fd_set         readfs;    
struct timeval timeout;
int            fd;
char           *tty;
char           *btr = NULL;
int            opt, count=127, indt;
struct termios term;
int            baud;
char           wrbuf[CBUFSIZE*WRLOOP] = {0};
char           rdbuf[CBUFSIZE*WRLOOP] = {0};
pthread_t      td1;
int            rdSize;

void print_usage(char *prg)
{
    fprintf(stderr, "\nUsage: %s [options] tty buad\n\n", prg);
    fprintf(stderr, "Example..\n");
    fprintf(stderr, "./ltest /dev/ttyS1 115200\n");
    fprintf(stderr, "\n");
    exit(1);
}

static int uart_speed(int s)
{
    switch (s)
    {
        case 9600:
            return B9600;
        case 19200:
            return B19200;
        case 38400:
            return B38400;
        case 57600:
            return B57600;
        case 115200:
            return B115200;
        case 230400:
            return B230400;
        case 460800:
            return B460800;
        case 500000:
            return B500000;
        case 576000:
            return B576000;
        case 921600:
            return B921600;
        case 1000000:
            return B1000000;
        case 1152000:
            return B1152000;
        case 1500000:
            return B1500000;
        case 2000000:
            return B2000000;
        case 2500000:
            return B2500000;
        case 3000000:
            return B3000000;
        case 3500000:
            return B3500000;
        case 4000000:
            return B4000000;
        default:
            return B38400;
    }
}

/* read task */
//void *task(void)
void task (int offset)
{
    int idx2 = 0;
    int idx3 = 0;

    int ret = 0;
    int startingpoint = 0;
    
//    printf ("Task\n");

    FD_SET(fd, &readfs);  

    /* set timeout value within input loop */
    timeout.tv_usec = 0;  /* milliseconds */
    timeout.tv_sec = 10;  /* seconds */

    idx3 = offset*CBUFSIZE;

    startingpoint = idx3;

    do
    {
        ret = select(fd+1, &readfs, NULL, NULL, &timeout);
        if (ret == 0)
        {
            printf("read timeout error!\n");
            exit(1);
        }
        else
        {
            ret = read(fd, &rdbuf[(idx3)], CBUFSIZE);
        }

        if (ret == -1)
        {
            printf("read error!\n");
            return ;
        }
        else if (ret == 0)
        {
            printf("read 0 Buf !\n");
        }
        else 
        {
            for (idx2 = idx3; idx2 < (idx3 + ret); idx2++)
            {

                if (wrbuf[idx2] != rdbuf[idx2])
                {
                    printf("read data error: wrote 0x%x read 0x%x idx2 %d ret %d \n", \
                            wrbuf[idx2], rdbuf[idx2], idx2, ret);
                }
            }
            idx3 += ret;
        }

    } while (idx3 < (startingpoint + CBUFSIZE));

} /* end of task */


int main(int argc, char **argv)
{
    int idx1 = 0;
    int ret = 0;

    FILE *wrFile;
    FILE *rdFile;


#if 0
    while ((opt = getopt(argc, argv, "bc:?")) != -1) 
    {
        switch (opt)
        {
            case 'b':
               btr = optarg;
               printf("baud=%s\n", btr);
               break;

            case 'c':
               count = atoi(optarg);
               break;

            case '?':
            default:
               print_usage(argv[0]);
               break;
        }
    }
    
                                                                
    if (argc - optind != 2)
        print_usage(argv[0]);
#endif

    tty = argv[optind];

//    baud = atoi (argv[optind+1]);

    baud = 115200;
   	
    printf("uart port used: %s\n",tty);
	
    if ((fd = open (tty, O_RDWR | O_NOCTTY | O_NONBLOCK)) < 0)
    {
        perror(tty);
	exit(1);
    }

    tcflush(fd, TCIFLUSH);

    if (tcgetattr(fd, &term) < 0)
    {
        perror("can't get port settings");
        return -1;
    }

    cfmakeraw(&term);

    term.c_cflag |= CLOCAL;

    term.c_cflag &= ~CRTSCTS;

    cfsetospeed(&term, uart_speed(baud));
    cfsetispeed(&term, uart_speed(baud));

    if (tcsetattr(fd, TCSANOW, &term) < 0)
    {
        perror("can't set port settings");
        return -1;
    } 
#if 0
    if ( pthread_create(&td1, NULL, task, NULL) != 0 )
    {
       printf ("pthread_create() error\n");
    }
#endif
    for (idx1 = 0; idx1 < CBUFSIZE*WRLOOP; idx1++)
    {
        wrbuf[idx1] = idx1 + 0x10;
        rdbuf[idx1] = 0xff;
    }

    /* write task */

    for (idx1 = 0; idx1 < (WRLOOP); idx1++)
    {

        ret = write(fd, &wrbuf[(idx1*CBUFSIZE)], CBUFSIZE);
        if (ret != CBUFSIZE)
        {
            printf("write error!i ret= %d\n", ret);
            exit(1);
        }

        task(idx1);

    }

//    sleep (3);

    wrFile = fopen ("wrFile", "wb+");

    if (wrFile == NULL)
    {
         printf ("wrFile open error!\n");
    }
    else
    {
         if (fwrite (&wrbuf[0], (CBUFSIZE*WRLOOP), 1, wrFile)  < 1)
         {
              printf ("wrFile write error!\n");
         }
    }  

    rdFile = fopen ("rdFile", "wb+");

    if (rdFile == NULL)
    {
         printf ("rdFile open error!\n");
    }
    else
    {
         if (fwrite (&rdbuf[0], (CBUFSIZE*WRLOOP), 1, rdFile)  < 1)
         {
              printf ("rdFile write error!\n");
         }
    } 

 
#if 0  
    /* Dump the user space buffers */

    printf ("write buf\n");
    for (idx1 = 0; idx1 < CBUFSIZE; idx1++)
    {
        printf ("0x%2x ", wrbuf[idx1]);
        if (idx1 % 32 == 0)
        {
            printf ("\n");
            for (indt = idx1/32; indt > 0; indt--) 
            {
                 printf ("  "); 
            }     
        }
    }

    printf ("\nread buf\n");

    for (idx1 = 0; idx1 < CBUFSIZE; idx1++)
    {
        printf ("0x%2x ", rdbuf[idx1]);
        if (idx1 % 32 == 0)
        {
            printf ("\n");
            for (indt = idx1/32; indt > 0; indt--) 
            {
                 printf ("  ");
            }     
        }

    }
#endif
    printf("\nUART loop back test completed! \n");

    close(fd);

    return 0;
}