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 <cmath>

#include "UartSC.h"

//#define UART_SC_DEBUG

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 name):

sc_module(name)

{

        SC_METHOD(checkTx);

        dont_initialize();

        sensitive << clk.pos();

        //sensitive << uarttx;

}                               // UartSC ()

void

 UartSC::initUart(int clk_freq_hz,      // Presume in NS

                  int uart_baud)

{

        // Calculate number of clocks per UART bit

        clocks_per_bit = (int)(clk_freq_hz / uart_baud);

        bits_received = 0;

#ifdef UART_SC_DEBUG

        printf

            ("UartSC Initialised: Sys. clk. freq.: %d Hz, Baud: %d, cpb: %d\n",

             clk_freq_hz, uart_baud, clocks_per_bit);

#endif

}

// Maybe do this with threads instead?!

void UartSC::checkTx()

{

#ifdef UART_SC_DEBUG

        //printf("Uart TX activity: level is : 0x%x\n", uarttx.read()&1);

#endif

        // 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;

                        // Start 

                        counter = 1;

                        bits_received++;        // We got the start bit

#ifdef UART_SC_DEBUG

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

                            sc_time_stamp() << endl;

#endif

                }

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

                // Check the counter - see if it's time to sample the line

                // We do an extra half-bit delay on first bit read

                if (((bits_received == 1) &&

                     (counter == (clocks_per_bit + (clocks_per_bit / 2)))) ||

                    ((bits_received > 1) && (counter == clocks_per_bit))) {

                        //printf("UartSC checkTx: read bit %d as 0x%x at time", bits_received, uarttx.read()&1);

                        //cout << sc_time_stamp() << endl;

                        // Shift in the current value of the tx into our char

                        current_char |=

                            ((uarttx.read() & 1) << (bits_received - 1));

                        // Reset the counter

                        counter = 1;

                        // Increment bit number

                        bits_received++;

                } else

                        counter++;

        } else if (bits_received == 9) {

                // Now check for stop bit 1

                if (counter == clocks_per_bit) {

                        // Check that the value is 1 - this should be the stop bit

                        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;

                                counter = 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 - jb 090613ol

                                //cout << current_char;

                                printf("%c", current_char);

                                bits_received = 0;

                                counter = 0;

                        }

                } else

                        counter++;

        }

}