Subversion Repositories openrisc

// ----------------------------------------------------------------------------

// SystemC Uart: implementation

// This file is part of the cycle accurate model of the OpenRISC 1000 based

// system-on-chip, ORPSoC, built using Verilator.

// This program is free software: you can redistribute it and/or modify it

// under the terms of the GNU Lesser General Public License as published by

// the Free Software Foundation, either version 3 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 Lesser General Public

// License for more details.

// You should have received a copy of the GNU Lesser General Public License

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

// ----------------------------------------------------------------------------

// $Id: $

#include <iostream>

#include <iomanip>

#include "UartSC.h"

//#define UART_SC_DEBUG

// Keep disabled for now, to stop any portability problems cropping up.

//#define UART_SC_STDIN_ENABLE

#ifdef UART_SC_STDIN_ENABLE

#include <termios.h>

#include <unistd.h>

#endif

SC_HAS_PROCESS(UartSC);

//! Constructor for the Uart system C model

//! @param[in] name  Name of this module, passed to the parent constructor.

// Todo: Probably some sort of scaler parameter

UartSC::UartSC(sc_core::sc_module_name uart):

        sc_module(uart)

{

#ifdef UART_SC_STDIN_ENABLE

        SC_THREAD(driveRx);

#endif

        SC_THREAD(checkTx);

        dont_initialize();

        sensitive << uarttx;

}                               // UartSC ()

void

UartSC::initUart(int uart_baud)

{

        // Calculate number of ns per UART bit

        ns_per_bit = (int) ((long long)1000000000/(long long)uart_baud);

        bits_received = 0;

        // Init state of RX

        rx_state = 0;

        // Set input, ORPSoC's RX, line to high

        uartrx.write(true);

#ifdef UART_SC_DEBUG

        printf

                ("UartSC Initialised: Baud: %d, ns per bit: %d\n",

                 uart_baud, ns_per_bit);

#endif

}

// Some C from 

// http://cc.byexamples.com/2007/04/08/non-blocking-user-input-in-loop-without-ncurses/

//

int UartSC::kbhit()

{

#ifdef UART_SC_STDIN_ENABLE

    struct timeval tv;

    fd_set fds;

    tv.tv_sec = 0;

    tv.tv_usec = 0;

    FD_ZERO(&fds);

    FD_SET(STDIN_FILENO, &fds); //STDIN_FILENO is 0

    select(STDIN_FILENO+1, &fds, NULL, NULL, &tv);

    return FD_ISSET(STDIN_FILENO, &fds);

#else

    return 0;

#endif

}

#define NB_ENABLE 1

#define NB_DISABLE 0

// The following is apparently VERY Linux-centric. Maybe a ncurses version could

// be handy if this gets used on various platforms.

void UartSC::nonblock(int state)

{

#ifdef UART_SC_STDIN_ENABLE

        struct termios ttystate;

        //get the terminal state

        tcgetattr(STDIN_FILENO, &ttystate);

        if (state==NB_ENABLE)

        {

                //turn off canonical mode

                ttystate.c_lflag &= ~ICANON;

                //minimum of number input read.

                ttystate.c_cc[VMIN] = 1;

        }

        else if (state==NB_DISABLE)

        {

                //turn on canonical mode

                ttystate.c_lflag |= ICANON;

        }

        //set the terminal attributes.

        tcsetattr(STDIN_FILENO, TCSANOW, &ttystate);

#endif  

}

void UartSC::driveRx()

{

        static char c;

        UartSC::nonblock(NB_ENABLE);

        while(1)

        {

                if (rx_state == 0) // Waiting for a character input from user

                {

                        // Do we have a character on input?

                        //c=cin.peek();

                        if (kbhit())

                        {

                                c = fgetc(stdin);

#ifdef UART_SC_DEBUG

                                cout << "UartSC::driveRX got " << c << endl;

#endif

                                rx_state++;

                        }

                        wait(1000000, SC_NS);

                }

                else if (rx_state == 1)

                {

#ifdef UART_SC_DEBUG

                        cout << "UartSC::driveRX start-bit " << c << endl;

#endif

                        // Start bit - low

                        uartrx.write(false);

                        rx_state++;

                        // Wait a bit

                        wait(ns_per_bit, SC_NS);

                }

                else if (rx_state > 1 && rx_state < 10)

                {

#ifdef UART_SC_DEBUG

                        cout << "UartSC::driveRX bit " << rx_state-2 << " " <<

                             (c & (1 << rx_state-2)) << endl;

#endif

                        if (c & (1 << rx_state-2))

                                uartrx.write(true);

                        else

                                uartrx.write(false);

                        rx_state++;

                        // Wait a bit

                        wait(ns_per_bit, SC_NS);

                }

                else if (rx_state == 10)

                {

#ifdef UART_SC_DEBUG

                        cout << "UartSC::driveRX stop bit" << endl;

#endif

                        rx_state = 0;

                        // Stop bit

                        uartrx.write(true);

                        // Wait a bit

                        wait(ns_per_bit + (ns_per_bit/2), SC_NS);

                }

        }

}

// Maybe do this with threads instead?!

void UartSC::checkTx()

{

        while(1){

                // Check the number of bits received

                if (bits_received == 0) {

                        // Check if tx is low

                        if ((uarttx.read() & 1) == 0) {

                                // Line pulled low, begin receive of new char

                                current_char = 0;

                                //counter = 1;                  

                                bits_received++;        // We got the start bit

                                // Now wait until next bit

                                wait(ns_per_bit, SC_NS);

#ifdef UART_SC_DEBUG

                                cout << "UartSC checkTx: got start bit at time "

                                     << sc_time_stamp() << endl;

#endif

                        }

                        else

                                // Nothing yet - keep waiting

                                wait(ns_per_bit/2, SC_NS);

                } else if (bits_received > 0 && bits_received < 9) {

                        current_char |= ((uarttx.read() & 1) <<

                                         (bits_received - 1));

                        // Increment bit number

                        bits_received++;

                        // Wait for next bit

                        wait(ns_per_bit, SC_NS);

                } else if (bits_received == 9) {

                        // Now check for stop bit 1

                        if ((uarttx.read() & 1) != 1) {

                                printf("UART TX framing error at time\n");

                                cout << sc_time_stamp() << endl;

                                // Perhaps do something else here to deal with 

                                // this.

                                bits_received = 0;

                        }

                        else

                        {

                                // Print the char

#ifdef UART_SC_DEBUG

                                printf("Char received: 0x%2x time: ",

                                       current_char);

                                cout << sc_time_stamp() << endl;

#endif

                                // cout'ing the char didn't work for some 

                                // systems.

                                //cout << current_char;

                                printf("%c", current_char);

                                bits_received = 0;

                        }

                }

        }

}