Subversion Repositories rtfsimpleuart

// ============================================================================

//      (C) 2007,2011,2013,2015  Robert Finch

//  All rights reserved.

//      robfinch@<remove>finitron.ca

//

//      rtfSimpleUart.v

//              Basic uart with baud rate generator based on a harmonic

//      frequency synthesizer.

//

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are met:

//     * Redistributions of source code must retain the above copyright

//       notice, this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above copyright

//       notice, this list of conditions and the following disclaimer in the

//       documentation and/or other materials provided with the distribution.

//     * Neither the name of the <organization> nor the

//       names of its contributors may be used to endorse or promote products

//       derived from this software without specific prior written permission.

//

// 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 <COPYRIGHT HOLDER> 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.

//

//

//      To use:

// 

//      Set the pClkFreq parameter to the frequency of the system

//      clock (clk_i). This can be done when the core is instanced.

// 

//    1) set the baud rate value in the clock multiplier

//    registers (CM1,2,3). A default multiplier value may

//    be specified using the pClkMul parameter, so it

//    doesn't have to be programmed at run time. (Note the

//    pBaud parameter may also be set, but it doesn't work

//    in all cases due to arithmetic limitations).

//    2) enable communication by activating the rts, and

//    dtr signals in the modem control register. These

//    signals are defaulted to be active on reset, so they

//    may not need to be set. The pRts and pDtr parameters

//    may be used to change the default setting.

//    3) use interrupts or poll the status register to

//    determine when to transmit or receive a byte of data

//    4) read / write the transmit / recieve data buffer

//    for communication.

//

//    Notes:

//      This core only supports a single transmission /

//    reception format: 1 start, 8 data, and 1 stop bit (no

//    parity).  

//      The baud rate generator uses a 24 bit harmonic

//    frequency synthesizer. Compute the multiplier value

//    as if a 32 bit value was needed, then take the upper

//    24 bits of the value. (The number of significant bits

//    in the value determine the minimum frequency

//    resolution or the precision of the value).

//

//                              baud rate * 16

//      value = -----------------------

//                      (clock frequency / 2^32)

//  

//              eg                      38400 * 16

//              value = -----------------------

//                              (28.63636MHz / 2^32)

//                              

//                              = 92149557.65

//                              = 057E1736 (hex)

//                              

//                              

//              taking the upper 24 bits

//                              top 24 = 057E17

//                                              = 359959

//                              

//              so the value needed to be programmed into the register

//      for 38.4k baud is 57E17 (hex)

//              eg      CM0 = 0 (not used)

//                      CM1 = 17 hex

//                      CM2 = 7E hex

//                      CM3 = 05 hex

//

//

//      Register Description

//

//      reg

//      0        read / write (RW)

//              TRB - transmit / receive buffer

//              transmit / receive buffer

//              write   - write to transmit buffer

//              read    - read from receive buffer

//

//      1       read only (RO)

//              LS      - line status register

//              bit 0 = receiver not empty, this bit is set if there is

//                              any data available in the receiver fifo

//              bit 1 = overrun, this bit is set if receiver overrun occurs

//              bit 3 = framing error, this bit is set if there was a

//                              framing error with the current byte in the receiver

//                              buffer.

//              bit 5 = transmitter not full, this bit is set if the transmitter

//                              can accept more data

//              bit 6 = transmitter empty, this bit is set if the transmitter is

//                              completely empty

//

//      2       MS      - modem status register (RO)

//              writing to the modem status register clears the change

//              indicators, which should clear a modem status interrupt

//              bit 3 = change on dcd signal

//              bit 4 = cts signal level

//              bit 5 = dsr signal level

//              bit 6 = ri signal level

//              bit 7 = dcd signal level

//

//      3       IS      - interrupt status register (RO)

//              bit 0-4 = mailbox number

//              bit 0,1 = 00

//              bit 2-4 = encoded interrupt value

//              bit 5-6 = not used, reserved

//              bit 7 = 1 = interrupt pending, 0 = no interrupt

//

//      4       IE      - interrupt enable register (RW)

//              bit 0 = receive interrupt (data present)

//              bit 1 = transmit interrupt (data empty)

//              bit 3 = modem status (dcd) register change

//              bit 5-7 = unused, reserved

//

//      5       FF      - frame format register         (RW)

//              this register doesn't do anything in the simpleUart

//              but is reserved for compatiblity with the more

//              advanced uart

//

//      6       MC      - modem control register (RW)

//              bit 0 = dtr signal level output

//              bit 1 = rts signal level output

//

//      7       - control register

//              bit 0 = hardware flow control,

//                      when this bit is set, the transmitter output is

//                      controlled by the cts signal line automatically

//

//

//              * Clock multiplier steps the 16xbaud clock frequency

//              in increments of 1/2^32 of the clk_i input using a

//              harmonic frequency synthesizer

//              eg. to get a 9600 baud 16x clock (153.6 kHz) with a

//              27.175 MHz clock input,

//              value  = upper24(9600 * 16  / (27.175MHz / 2^32))

//              Higher frequency baud rates will exhibit more jitter

//              on the 16x clock, but this will mostly be masked by the 

//              16x clock factor.

//

//      8       CM0     - Clock Multiplier byte 0 (RW)

//              this is the least significant byte

//              of the clock multiplier value

//              this register is not used unless the clock

//              multiplier is set to contain 32 bit values

//

//      9       CM1 - Clock Multiplier byte 1   (RW)

//              this is the third most significant byte

//              of the clock multiplier value

//              this register is not used unless the clock

//              multiplier is set to contain 24 or 32 bit values

//

//      10      CM2 - Clock Multiplier byte 2   (RW)

//              this is the second most significant byte of the clock

//              multiplier value

//

//      11      CM3     - Clock Multiplier byte 3       (RW)

//              this is the most significant byte of the multiplier value

//

//      12      FC      - Fifo control register         (RW)

//              this register doesnt' do anything in the simpleUart

//              but is reserved for compatibility with the more

//              advanced uart

//              

//      13-14   reserved registers

//

//      15      SPR     - scratch pad register (RW)

//

//

//      +- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

//      |WISHBONE Datasheet

//      |WISHBONE SoC Architecture Specification, Revision B.3

//      |

//      |Description:                                           Specifications:

//      +- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

//      |General Description:                           simple UART core

//      +- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

//      |Supported Cycles:                                      SLAVE,READ/WRITE

//      |                                                                       SLAVE,BLOCK READ/WRITE

//      |                                                                       SLAVE,RMW

//      +- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

//      |Data port, size:                                       8 bit

//      |Data port, granularity:                        8 bit

//      |Data port, maximum operand size:       8 bit

//      |Data transfer ordering:                        Undefined

//      |Data transfer sequencing:                      Undefined

//      +- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

//      |Clock frequency constraints:           none

//      +- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

//      |Supported signal list and                      Signal Name             WISHBONE equiv.

//      |cross reference to equivalent          ack_o                   ACK_O

//      |WISHBONE signals                                       adr_i[3:0]              ADR_I()

//      |                                                                       clk_i                   CLK_I

//      |                                   rst_i           RST_I()

//      |                                                                       dat_i(7:0)              DAT_I()

//      |                                                                       dat_o(7:0)              DAT_O()

//      |                                                                       cyc_i                   CYC_I

//      |                                                                       stb_i                   STB_I

//      |                                                                       we_i                    WE_I

//      |

//      +- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

//      |Special requirements:

//      +- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

//

//=============================================================================

`define UART_TRB    4'd0    // transmit/receive buffer

`define UART_LS     4'd1    // line status register

`define UART_MS     4'd2    // modem status register

`define UART_IS         4'd3    // interrupt status register

`define UART_IER    4'd4    // interrupt enable

`define UART_FF     4'd5    // frame format register

`define UART_MC     4'd6    // modem control register

`define UART_CTRL       4'd7    // control register

`define UART_CLKM0      4'd8    // clock multiplier byte 0

`define UART_CLKM1      4'd9    // clock multiplier byte 1

`define UART_CLKM2      4'd10   // clock multiplier byte 2

`define UART_CLKM3      4'd11   // clock multiplier byte 3

`define UART_FC     4'd12   // fifo control register

module rtfSimpleUart(

        // WISHBONE Slave interface

        input rst_i,            // reset

        input clk_i,            // eg 100.7MHz

        input cyc_i,            // cycle valid

        input stb_i,            // strobe

        input we_i,                     // 1 = write

        input [31:0] adr_i,              // register address

        input [7:0] dat_i,               // data input bus

        output reg [7:0] dat_o,  // data output bus

        output ack_o,           // transfer acknowledge

        output vol_o,           // volatile register selected

        output irq_o,           // interrupt request

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

        input cts_ni,           // clear to send - active low - (flow control)

        output reg rts_no,      // request to send - active low - (flow control)

        input dsr_ni,           // data set ready - active low

        input dcd_ni,           // data carrier detect - active low

        output reg dtr_no,      // data terminal ready - active low

        input rxd_i,                    // serial data in

        output txd_o,                   // serial data out

        output data_present_o,

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

        output baud16_clk

);

parameter pClkFreq = 20000000;  // clock frequency in MHz

parameter pBaud = 19200;

parameter pClkMul = (4096 * pBaud) / (pClkFreq / 65536);

parameter pRts = 1;             // default to active

parameter pDtr = 1;

wire cs = cyc_i && stb_i && (adr_i[31:4]==28'hFFDC_0A0);

assign ack_o = cs;

assign vol_o = cs && adr_i[3:2]==2'b00;

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

// variables

reg [23:0] c;    // current count

reg [23:0] ck_mul;       // baud rate clock multiplier

wire tx_empty;

wire baud16;    // edge detector (active one cycle only!)

reg rx_present_ie;

reg tx_empty_ie;

reg dcd_ie;

reg hwfc;                       // hardware flow control enable

wire clear = cyc_i && stb_i && we_i && adr_i==4'd13;

wire frame_err;         // receiver char framing error

wire over_run;          // receiver over run

reg [1:0] ctsx;          // cts_ni sampling

reg [1:0] dcdx;

reg [1:0] dsrx;

wire dcd_chg = dcdx[1]^dcdx[0];

wire rxIRQ = data_present_o & rx_present_ie;

wire txIRQ = tx_empty & tx_empty_ie;

wire msIRQ = dcd_chg & dcd_ie;

assign irq_o =

          rxIRQ

        | txIRQ

        | msIRQ

        ;

assign baud16_clk = baud16;

wire [2:0] irqenc =

        rxIRQ ? 1 :

        txIRQ ? 3 :

        msIRQ ? 4 :

        0;

wire [7:0] rx_do;

wire txrx = cs && adr_i[3:0]==4'd0;

rtfSimpleUartRx uart_rx0(

        .rst_i(rst_i),

        .clk_i(clk_i),

        .cyc_i(cyc_i),

        .stb_i(stb_i),

        .cs_i(txrx),

        .we_i(we_i),

        .dat_o(rx_do),

        .baud16x_ce(baud16),

        .clear(clear),

        .rxd(rxd_i),

        .data_present(data_present_o),

        .frame_err(frame_err),

        .overrun(over_run)

);

rtfSimpleUartTx uart_tx0(

        .rst_i(rst_i),

        .clk_i(clk_i),

        .cyc_i(cyc_i),

        .stb_i(stb_i),

        .cs_i(txrx),

        .we_i(we_i),

        .dat_i(dat_i),

        .baud16x_ce(baud16),

        .cts(ctsx[1]|~hwfc),

        .txd(txd_o),

        .empty(tx_empty)

);

// mux the reg outputs

always @*

        if (cs) begin

                case(adr_i[3:0]) // synopsys full_case parallel_case

                `UART_MS:       dat_o <= {dcdx[1],1'b0,dsrx[1],ctsx[1],dcd_chg,3'b0};

                `UART_IS:       dat_o <= {irq_o, 2'b0, irqenc, 2'b0};

                `UART_LS:       dat_o <= {1'b0, tx_empty, tx_empty, 1'b0, frame_err, 1'b0, over_run, data_present_o};

                default:        dat_o <= rx_do;

                endcase

        end

        else

                dat_o <= 8'b0;

// Note: baud clock should pulse high for only a single

// cycle!

always @(posedge clk_i)

        if (rst_i)

                c <= 0;

        else

                c <= c + ck_mul;

// for detecting an edge on the msb

edge_det ed0(.rst(rst_i), .clk(clk_i), .ce(1'b1), .i(c[23]), .pe(baud16), .ne(), .ee() );

// register updates

always @(posedge clk_i) begin

        if (rst_i) begin

                rts_no <= ~pRts;

                rx_present_ie <= 1'b0;

                tx_empty_ie <= 1'b0;

                dcd_ie <= 1'b0;

                hwfc <= 1'b1;

                dtr_no <= ~pDtr;

                ck_mul <= pClkMul;

        end

        else if (cs & we_i) begin

                case (adr_i)

                `UART_IER:

                                begin

                                rx_present_ie <= dat_i[0];

                                tx_empty_ie <= dat_i[1];

                                dcd_ie <= dat_i[3];

                                end

                `UART_MC:

                                begin

                                dtr_no <= ~dat_i[0];

                                rts_no <= ~dat_i[1];

                                end

                `UART_CTRL:             hwfc <= dat_i[0];

                `UART_CLKM1:    ck_mul[7:0] <= dat_i;

                `UART_CLKM2:    ck_mul[15:8] <= dat_i;

                `UART_CLKM3:    ck_mul[23:16] <= dat_i;

                default:

                        ;

                endcase

        end

end

// synchronize external signals

always @(posedge clk_i)

        ctsx <= {ctsx[0],~cts_ni};

always @(posedge clk_i)

        dcdx <= {dcdx[0],~dcd_ni};

always @(posedge clk_i)

        dsrx <= {dsrx[0],~dsr_ni};

endmodule