Subversion Repositories vapi

/* uart.c -- test for uart, by using VAPI
   Copyright (C) 2001, Marko Mlinar, markom@opencores.org
 
This file is part of OpenRISC 1000 Architectural Simulator.
 
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
 
 
#include "vapi.h"
 
unsigned long num_vapi_ids = 1;  
 
/* UART messages */
#define TX_CMD      0xff000000
#define TX_CMD0     0x00000000
#define TX_CHAR     0x000000ff
#define TX_NBITS    0x00000300
#define TX_STOPLEN  0x00000400
#define TX_PARITY   0x00000800
#define TX_EVENP    0x00001000
#define TX_STICK    0x00002000
#define TX_BREAK    0x00004000
 
/* Send speed */
#define TX_CMD1     0x01000000
#define TX_SPEED    0x0000ffff
 
/* Send receive LCR reg */
#define TX_CMD2     0x02000000
 
/* Send skew */
#define TX_CMD3     0x03000000
 
/* Set break */
#define TX_CMD4     0x04000000
#define TX_CMD4_BREAK 0x00010000
#define TX_CMD4_DELAY 0x0000ffff
 
/* Check FIFO */
#define TX_CMD5     0x05000000
#define TX_CMD5_FIFOFULL 0x0000001
 
#define RX_CMD0     0x00000000
#define RX_PARERR   0x00010000
#define RX_FRAERR   0x00020000
 
/* fails if x is false */
#define ASSERT(x) ((x)?1:fail (__FUNCTION__, __LINE__))
#define MARK() printf ("Passed line %i\n", __LINE__)
#define VAPI_READ(x) {unsigned long r = vapi_read (); printf ("expected 0x%08x, read 0x%08x\n", r, (x)); ASSERT(r == (x));}
 
#ifndef __LINE__
#define __LINE__  0
#endif
 
void fail (char *func, int line)
{
#ifndef __FUNCTION__
#define __FUNCTION__ "?"
#endif
  printf ("Test failed in %s:%i\n", func, line);
  exit (1);
}
char str[5000];
 
/* current comm. control bits */
int control, control_rx;
 
void recv_char (char c)
{
  unsigned long tmp = vapi_read ();
  printf ("expected %08x, read %08x\n", control_rx | c, tmp);
  /* test if something is wrong */
  ASSERT ((tmp & 0xffffff00) == control_rx);
  tmp &= 0xff;
  if (tmp) printf ("'%c'\n", (char)tmp);
  else printf ("\\0\n");
  printf ("expected %02x, read %02x\n", c, tmp);
  ASSERT (c == (char)tmp);
}
 
void send_char (char c)
{
  vapi_write (c | (control & 0xffffff00));
}
 
char *read_string (char *s)
{
  char *t = s;
  unsigned long tmp = 1;
  while (tmp) {
    tmp = vapi_read ();
    printf ("%08x, %08x\n", tmp, control_rx);
    /* test if something is wrong */
    ASSERT ((tmp & 0xffffff00) == control_rx);
    tmp &= 0xff;
    if (tmp) printf ("'%c'\n", (char)tmp);
    else printf ("\\0\n");
    *(t++) = (char)tmp;
  }
  return s;
}
 
 
void compare_string (char *s) {
  while (*s) {
    unsigned long tmp = vapi_read ();
    /* test if something is wrong */
    ASSERT (tmp == (control_rx | *s));
    tmp &= 0xff;
    if (tmp) printf ("'%c'\n", (char)tmp);
    else printf ("\\0\n");
    s++;
  }
}
 
void send_string (char *s)
{
  while (*s)
    vapi_write (*(s++) | (control & 0xffffff00));
}
 
void init_8n1 ()
{
  vapi_write(TX_CMD1 | 2); /* Set tx/rx speed */
  control = control_rx = TX_CMD0 | TX_NBITS;
  vapi_write(TX_CMD2 | control_rx); /* Set rx mode */
}
 
void test_registers ()
{
  /* This test is performed just by cpu, if it is not stopped, we have an error.  */
  printf ("Testing registers... ");
  MARK();
}
 
void send_recv_test ()
{
  printf ("send_recv_test\n");
  MARK();
  read_string (str);
  MARK();
  printf ("OK\nread: %s\n",str);
  ASSERT (strcmp (str, "send_test_is_running") == 0);
  send_string ("recv");
  MARK();
  printf ("OK\n");
}
 
void break_test ()
{
  printf ("break_test\n");
  /* receive a break */
  VAPI_READ (TX_BREAK);
  MARK();
  vapi_write (control | '*');
  MARK();
  VAPI_READ (control | '!');
  MARK();
 
  /* send a break */
  vapi_write (TX_CMD4 | TX_CMD4_BREAK | (0) & TX_CMD4_DELAY);
  vapi_write (control | 'b');
  MARK();
  VAPI_READ (control | '#');
  MARK();
  vapi_write (TX_CMD4 | (0) & TX_CMD4_DELAY);
  vapi_write (control | '$');
  MARK();
 
  /* Receive a breaked string "ns<brk>*", only "ns" should be received.  */
  compare_string ("ns");
  VAPI_READ (TX_BREAK);
  send_string ("?");
  MARK();
 
  /* Send a break */
  VAPI_READ (control | '#');
  vapi_write(TX_CMD4 | TX_CMD4_BREAK | (5 & TX_CMD4_DELAY));
  vapi_write (control | 0);
  MARK();
#if 0
  /* Wait four chars */
  send_string ("234");
  MARK();
#endif
 
  /* FIFO should be empty */
  vapi_write(TX_CMD5);
  send_string ("5");
  /* FIFO should be nonempty and */
  vapi_write(TX_CMD5 | TX_CMD5_FIFOFULL); 
  MARK();
  /* it should contain '?' */
  VAPI_READ ('?' | control);
  /* Reset break signal*/
  vapi_write(TX_CMD4 | (0) & TX_CMD4_DELAY);
  MARK();
  vapi_write ('!' | control);
  printf ("OK\n");
}
 
/* Tries to send data in different modes in both directions */
 
/* Utility function, that tests current configuration */
void test_mode (int nbits)
{
  unsigned mask = (1 << nbits) - 1;
  recv_char ('U' & mask); //0x55
#if DETAILED
  recv_char ('U' & mask); //0x55
  send_char ('U');        //0x55  
#endif
  send_char ('U');        //0x55
  recv_char ('a' & mask); //0x61
#if DETAILED
  recv_char ('a' & mask); //0x61
  send_char ('a');        //0x61
#endif
  send_char ('a');        //0x61
}
 
void different_modes_test ()
{
  int speed, length, parity;
  printf ("different modes test\n");
  /* Init */
  /* Test different speeds */
  for (speed = 1; speed < 5; speed++) {
    vapi_write(TX_CMD1 | speed); /* Set tx/rx speed */
    control_rx = control = 0x03 << 8;    /* 8N1 */
    vapi_write(TX_CMD2 | control_rx); /* Set rx mode */
    test_mode (8);
    MARK();
  }
  MARK();
 
  vapi_write(TX_CMD1 | 1); /* Set tx/rx speed */
  MARK();
 
  /* Test all parity modes with different char lengths */
  for (parity = 0; parity < 8; parity++)
    for (length = 0; length < 4; length++) {
      control_rx = control = (length | (0 << 2) | (parity << 3)) << 8;
      vapi_write(TX_CMD2 | control_rx);
      test_mode (5 + length);
      MARK();
    }
  MARK();
 
  /* Test configuration, if we have >1 stop bits */
  for (length = 0; length < 4; length++) {
    control_rx = control = (length | (1 << 2) | (0 << 3)) << 8;
    vapi_write(TX_CMD2 | control_rx);
    test_mode (5 + length);
    MARK();
  }
  MARK();
 
  /* Restore normal mode */
  recv_char ('T'); /* Wait for acknowledge */
  vapi_write(TX_CMD1 | 2); /* Set tx/rx speed */
  control_rx = control = 0x03 << 8;    /* 8N1 @ 2*/
  vapi_write(TX_CMD2 | control_rx); /* Set rx mode */
  send_char ('x'); /* Send a character. It is possible that this char is received unproperly */
  recv_char ('T'); /* Wait for acknowledge before ending the test */
  MARK();
  printf ("OK\n");
}
 
/* Test various FIFO levels, break and framing error interrupt, etc */
 
void interrupt_test ()
{
  int i;
  vapi_write(TX_CMD1 | 6); /* Set tx/rx speed */
  printf ("interrupt_test\n");
  /* start interrupt test */
  recv_char ('I'); /* Test trigger level 1 */
  send_char ('0');
 
  recv_char ('I'); /* Test trigger level 4 */
  send_char ('1');
  send_char ('2');
  send_char ('3');
  send_char ('4');
 
  recv_char ('I'); /* Test trigger level 8 */
  send_char ('5');
  send_char ('6');
  send_char ('7');
  send_char ('8');
  send_char ('9');
 
  recv_char ('I'); /* Test trigger level 14 */
  send_char ('a');
  send_char ('b');
  send_char ('c');
  send_char ('d');
  send_char ('e');
  send_char ('f');
  send_char ('g');
 
  recv_char ('I'); /* Test OE */
  send_char ('h');
  send_char ('i');
  send_char ('j');
  send_char ('*'); /* should not be put in the fifo */
 
  recv_char ('I'); /* test break interrupt */
  /* send a break */
  vapi_write (TX_CMD4 | TX_CMD4_BREAK | (0) & TX_CMD4_DELAY);
  vapi_write (control | 'b');
  MARK();
  recv_char ('B'); /* Release break */
  MARK();
  vapi_write (TX_CMD4 | (0) & TX_CMD4_DELAY);
  vapi_write (control | '$');
  MARK();
 
  /* TODO: Check for parity error */
  /* TODO: Check for frame error */
 
  /* Check for timeout */
  recv_char ('I');
  send_char ('T'); /* Send char -> timeout should occur */
  recv_char ('T'); /* Wait for acknowledge before changing configuration */
  MARK ();
 
  /* Restore previous mode */
  vapi_write(TX_CMD1 | 2); /* Set tx/rx speed */
  control = control_rx = TX_CMD0 | TX_NBITS;
  vapi_write(TX_CMD2 | control_rx); /* Set rx mode */
  recv_char ('T'); /* Wait for acknowledge before ending the test */
  printf ("OK\n");
}
 
/* Test if all control bits are set correctly.  Lot of this was already tested
   elsewhere and tests are not duplicated.  */
 
void control_register_test ()
{
  printf ("control_register_test\n");
  recv_char ('*');
  send_char ('*');
  MARK ();
  recv_char ('!');
  send_char ('!');
  MARK ();
 
  recv_char ('1');
  recv_char ('*');
  send_char ('*');
  printf ("OK\n");
}
 
void line_error_test ()
{
  vapi_write(TX_CMD2 | control_rx); /* Set rx mode */
  recv_char ('c');
  vapi_write(TX_CMD1 | 3); /* Set incorrect tx/rx speed */
  send_char ('a');
  vapi_write(TX_CMD1 | 2); /* Set correct tx/rx speed */
  send_char ('b');
  MARK ();
 
#if COMPLETE
  recv_char ('*');
  control = TX_CMD0 | TX_NBITS;
  control_rx = TX_CMD0 | TX_NBITS | TX_STOPLEN;
  vapi_write(TX_CMD2 | control_rx); /* Set rx mode */
  recv_char ('*');
  MARK ();
#endif
}
 
int vapi_main ()
{
 
  /* Test section area */
  test_registers ();
  init_8n1 ();
  send_recv_test ();
  break_test();
  different_modes_test ();
  interrupt_test ();
  control_register_test ();
  line_error_test ();
  /* End of test section area */
 
  send_char ('@');
  return 0;
}