Verilog FAQ      Version 09/05: September 2005


FAQ Main  |  Part-1  |  Part-2 Part-3  |  What' New  |   Links    ]


Examples from "The Verilog Hardware Description Language"

by D.E. Thomas and P.R. Moorby



//Example 1.2.  NAND Latch To Be Simulated.
module ffNand;
    wire q, qBar;
    reg  preset, clear;

    nand #1
        g1 (q, qBar, preset),
        g2 (qBar, q, clear);

    initial
        begin
            // two slashes introduce a single line comment
            $monitor ($time,,
                "Preset = %b clear = %b q = %b qBar = %b",
                preset, clear, q, qBar);
            //waveform for simulating the nand flip flop
            #10 preset = 0; clear = 1;
            #10 preset = 1;
            #10 clear = 0;
            #10 clear = 1;
            #10 $finish;
        end
endmodule



//Example 1.4.  A 16-Bit Counter.
module m16 (value, clock, fifteen, altFifteen);
    output [3:0] value;
    output       fifteen,
                 altFifteen;
    input        clock;

    dEdgeFF    a (value[0], clock, ~value[0]),
               b (value[1], clock, value[1] ^  value[0]),
               c (value[2], clock, value[2] ^ &value[1:0]),
               d (value[3], clock, value[3] ^ &value[2:0]);

    assign fifteen = value[0] & value[1] & value[2] & value[3];
    assign altFifteen = &value;
endmodule



//Example 1.5.  A D-Type Edge-Triggered Flip Flop.
module dEdgeFF (q, clock, data);
    output q;
    reg    q;
    input  clock, data;

    initial
        q = 0;

    always
        @(negedge clock) #10 q = data;

endmodule



//Example 1.6.  A Clock For the Counter.
module m555 (clock);
    output clock;
    reg    clock;

    initial
        #5 clock = 1;

    always
        #50 clock = ~ clock;
endmodule



//Example 1.7.  The Top-Level Module of the Counter.
module board;
    wire [3:0] count;
    wire       clock,
               f,
               af;

    m16  counter (count, clock, f, af);
    m555 clockGen (clock);

    always @(posedge clock)
        $display ($time,,,"count=%d, f=%d, af=%d", count, f, af);
endmodule



//Example 1.8. The Counter Module Described With Behavioral Statements.
module m16Behav (value, clock, fifteen, altFifteen);
    output [3:0] value;
    reg    [3:0] value;
    output       fifteen,
                 altFifteen;
    reg          fifteen,
                 altFifteen;
    input        clock;

    initial
        value = 0;

    always
        begin
            @(negedge clock)  #10 value = value + 1;
            if (value == 15)
                begin
                    altFifteen = 1;
                    fifteen = 1;
                end
            else
                begin
                    altFifteen = 0;
                    fifteen = 0;
                end
        end
endmodule



//Example 1.9.  Top Level of the Fibonacci Number Generator.
module top();
    wire        flag, numProduced, numConsumed;
    wire [15:0] number, numberOut;

    nandLatch    ready (flag, , numConsumed, numProduced);
    numberGen    ng (number, numProduced, flag);
    fibNumberGen fng (number, flag, numConsumed, numberOut);
endmodule



//Example 1.10.  A NAND Latch.
module nandLatch (q, qBar, set, reset);
    output q, qBar;
    input  set, reset;

    nand #2
        (q, qBar, set),
        (qBar, q, reset);
endmodule



//Example 1.11.  The Seed-Number Generator.
module numberGen (number, numProduced, flag);
    output [15:0] number;
    output        numProduced;
    input         flag;

    reg        numProduced;
    reg [15:0] number;

    initial
        begin
            number = 3;
            numProduced = 1;
        end

    always
        begin
            wait (flag == 1)
                #100 number = number + 1;
            numProduced = 0;
            #10 numProduced = 1;
        end
endmodule



//Example 1.12.  The Fibonacci Number Generator Module.
module fibNumberGen (startingValue, flag, numConsumed, fibNum);
    input [15:0]  startingValue;
    input         flag;
    output        numConsumed;
    output [15:0] fibNum;

    reg           numConsumed;
    reg [15:0]    myValue;
    reg [15:0]    fibNum;

    initial
        begin
            numConsumed = 0;
            #10 numConsumed = 1;
            $monitor ($time,,
                "fibNum=%d, startingValue=%d", 
                    fibNum, startingValue);
        end

    always
        begin
            wait (flag == 0)
                myValue = startingValue;
            numConsumed = 0;
            #10 numConsumed = 1;    //signal ready for input

            for (fibNum = 0; myValue != 0; myValue = myValue - 1)
                fibNum = fibNum + myValue;
            $display ("%d, fibNum=%d", $time, fibNum);
        end
endmodule



//Example 2.1.  A Divide Module.
module divide (ddInput, dvInput, quotient, go, done);
    parameter 
        DvLen =    15,
        DdLen =    31,
        QLen =     15,
        HiDdMin    = 16;

    input [DdLen:0] ddInput;
    input [DvLen:0] dvInput;
    output [QLen:0] quotient;
    input           go;
    output          done;

    reg [DdLen:0] dividend;
    reg           done;
    reg [QLen:0]  quotient;
    reg           negDivisor, 
                  negDividend;
    reg [DvLen:0] divisor;

    always
        begin
            done = 0;
            wait (go);
            divisor = dvInput;
            dividend = ddInput;
            quotient = 0;
            if (divisor)
                begin
                    negDivisor = divisor[DvLen];
                    if (negDivisor)
                        divisor = - divisor;
                    negDividend = dividend[DdLen];
                    if (negDividend)
                        dividend = - dividend;
                    repeat (DvLen + 1)
                        begin
                            quotient = quotient << 1;
                            dividend = dividend << 1;
                            dividend[DdLen:HiDdMin] = 
                                dividend[DdLen:HiDdMin]  - divisor;
                            if (! dividend [DdLen])
                                quotient = quotient + 1;
                            else    
                                dividend[DdLen:HiDdMin] = 
                                    dividend[DdLen:HiDdMin]  + divisor;
                        end
                    if (negDivisor != negDividend)
                        quotient = - quotient;
                end
            done = 1;
            wait (~go);
        end
endmodule



//Example 2.5.  The Mark-1 Processor With If-Else-If.
module mark1;
    reg [31:0] m [0:8191];    // 8192 x 32 bit memory
    reg [12:0] pc;            // 13 bit program counter
    reg [31:0] acc;           // 32 bit accumulator
    reg [15:0] ir;            // 16 bit instruction register

    always 
        begin
            ir = m [pc];                //fetch an instruction
            if (ir[15:13] == 3'b000)    //begin decoding
                pc = m [ir [12:0]];     //and executing
            else if (ir[15:13] == 3'b001)
                pc = pc + m [ir [12:0]];
            else if (ir[15:13] == 3'b010)
                acc = -m [ir [12:0]];
            else if (ir[15:13] == 3'b011)
                m [ir [12:0]] = acc;
            else if ((ir[15:13] == 3'b101) || (ir[15:13] == 3'b100))
                acc = acc - m [ir [12:0]];
            else if (ir[15:13] == 3'b110)
                if (acc < 0) pc = pc + 1;
            #1 pc = pc + 1; //increment program counter and time
        end                 
endmodule



//Example 2.6.  The Mark-1 With a Case Statement.
module mark1Case;
    reg [31:0] m [0:8191];    // 8192 x 32 bit memory 
    reg [12:0] pc;            // 13 bit program counter 
    reg [31:0] acc;           // 32 bit accumulator
    reg [15:0] ir;            // 16 bit instruction register

    always
        begin
            ir = m [pc];
            case (ir [15:13])
                3'b000 : pc = m [ir [12:0]];
                3'b001 : pc = pc + m [ir [12:0]];
                3'b010 : acc = -m [ir [12:0]];
                3'b011 : m [ir [12:0]] = acc;
                3'b100,
                3'b101 : acc = acc - m [ir [12:0]];
                3'b110 : if (acc < 0) pc = pc + 1;
            endcase
            pc = pc + 1;
        end
endmodule



//Example 2.8.  The Mark-1 With a Multiply Instruction.
module mark1Mult;
    reg [31:0] m [0:8191];    // 8192 x 32 bit memory 
    reg [12:0] pc;            // 13 bit program counter 
    reg [31:0] acc;           // 32 bit accumulator
    reg [15:0] ir;            // 16 bit instruction register

    always 
        begin
            ir = m [pc];
            case (ir [15:13])
                3'b000 : pc = m [ir [12:0]];
                3'b001 : pc = pc + m [ir [12:0]];
                3'b010 : acc = -m [ir [12:0]];
                3'b011 : m [ir [12:0]] = acc;
                3'b100,    
                3'b101 : acc = acc - m [ir [12:0]];
                3'b110 : if (acc < 0) pc = pc + 1;
                3'b111 : acc = acc * m [ir [12:0]]; //multiply
            endcase
            #1 pc = pc + 1;
        end
endmodule



//Example 2.9.  A Task Specification.
module mark1Task;
    reg [31:0] m [0:8191];    // 8192 x 32 bit memory 
    reg [12:0] pc;            // 13 bit program counter 
    reg [31:0] acc;           // 32 bit accumulator
    reg [15:0] ir;            // 16 bit instruction register

    always 
        begin
            ir = m [pc];
            case (ir [15:13])
                3'b000 : pc = m [ir [12:0]];
                3'b001 : pc = pc + m [ir [12:0]];
                3'b010 : acc = -m [ir [12:0]];
                3'b011 : m [ir [12:0]] = acc;
                3'b100,    
                3'b101 : acc = acc - m [ir [12:0]];
                3'b110 : if (acc < 0) pc = pc + 1;
                3'b111 : multiply(acc, m [ir [12:0]]);
            endcase
            pc = pc + 1;
        end

    task multiply;
        inout [31:0] a;
        input [31:0] b;

        reg [15:0] mcnd, mpy; //multiplicand and multiplier
        reg [31:0] prod;      //product

        begin
            mpy  = b[15:0];
            mcnd = a[15:0];
            prod = 0;
            repeat (16)
                begin
                    if (mpy[0])
                        prod = prod + {mcnd, 16'h0000};
                    prod = prod >> 1;
                    mpy = mpy >> 1;
                end
            a = prod;
        end
    endtask
endmodule



//Example 2.10.  A Function Specification.
module mark1Fun;
    reg [31:0] m [0:8191];    // 8192 x 32 bit memory 
    reg [12:0] pc;            // 13 bit program counter 
    reg [31:0] acc;           // 32 bit accumulator
    reg [15:0] ir;            // 16 bit instruction register

    always 
        begin
            ir = m [pc];
            case (ir [15:13])
                3'b000 : pc = m [ir [12:0]];
                3'b001 : pc = pc + m [ir [12:0]];
                3'b010 : acc = -m [ir [12:0]];
                3'b011 : m [ir [12:0]] = acc;
                3'b100,    
                3'b101 : acc = acc - m [ir [12:0]];
                3'b110 : if (acc < 0) pc = pc + 1;
                3'b111 : acc = multiply(acc, m [ir [12:0]]);
            endcase
            pc = pc + 1;
        end

function [31:0] multiply;
    input [31:0] a;
    input [31:0] b;

    reg [15:0] mcnd,mpy;

    begin
        mpy  = b[15:0];
        mcnd = a[15:0];
        multiply = 0;
        repeat (16)
            begin
                if (mpy[0])
                    multiply = multiply + {mcnd, 16'h0000};
                multiply = multiply >> 1;
                mpy = mpy >> 1;
            end
    end
endfunction
endmodule




//Example 2.11.  The Multiply as a Separate Module.
module mark1Mod;
    reg [31:0] m [0:8191];    // 8192 x 32 bit memory 
    reg [12:0] pc;            // 13 bit program counter 
    reg [31:0] acc;           // 32 bit accumulator
    reg [15:0] ir;            // 16 bit instruction register

    reg  [31:0] mcnd;
    reg         go;
    wire [31:0] prod;
    wire        done;

    multiply mul (prod, acc, mcnd, go, done);

    always
        begin
            go = 0;
            ir = m [pc];
            case (ir [15:13])
                3'b000 : pc = m [ir [12:0]];
                3'b001 : pc = pc + m [ir [12:0]];
                3'b010 : acc = -m [ir [12:0]];
                3'b011 : m [ir [12:0]] = acc;
                3'b100,    
                3'b101 : acc = acc - m [ir [12:0]];
                3'b110 : if (acc < 0) pc = pc + 1;
                3'b111 : begin
                             mcnd = m [ir [12:0]];
                             go = 1;
                             wait (done);
                             acc = prod;
                         end
            endcase
            pc = pc + 1;
        end
endmodule

module multiply (prod, mpy, mcnd, go, done);
    output [31:0] prod;
    input  [31:0] mpy, mcnd;
    input         go;
    output        done;

    reg [31:0]    prod;
    reg [15:0]    myMpy;
    reg           done;

    always
        begin
            done = 0;
            wait (go);
            myMpy  = mpy[15:0];
            prod = 0;
            repeat (16)
                begin
                    if (myMpy[0])
                        prod = prod + {mcnd, 16'h0000};
                    prod = prod >> 1;
                    myMpy = myMpy >> 1;
                end
            done = 1;
            wait (~go);
        end
endmodule



//Example 3.4.  Fibonacci Number Generator Using Named Events.
module topNE();
    wire [15:0] number, numberOut;

    numberGenNE    ng(number);
    fibNumberGenNE fng(number, numberOut);
endmodule

module numberGenNE(number);
    output [15:0] number;
    reg    [15:0] number;
    event         ready;

    initial
        number = 3;

    always
        begin
            #100 number = number + 1;
            -> ready; //generate event signal
        end
endmodule

module fibNumberGenNE(startingValue, fibNum);
    input  [15:0] startingValue;
    output [15:0] fibNum;

    reg [15:0] myValue;
    reg [15:0] fibNum;

    always
        begin
            @ng.ready            //accept event signal
                myValue = startingValue;
            for (fibNum = 0; myValue != 0; myValue = myValue - 1)
                fibNum = fibNum + myValue;
            $display ("%d, fibNum=%d", $time, fibNum);
        end
endmodule



//Example 3.6  The Consumer With Fully Interlocked Handshake.
module consumer(dataIn, prodReady, consReady);
    input [7:0] dataIn;
    input       prodReady;
    output      consReady;

    reg         consReady;
    reg [7:0]   dataInCopy;

    always
        begin
            consReady = 1;    // indicate consumer ready
            forever
                begin
                    wait (prodReady)
                        dataInCopy = dataIn;
                    consReady = 0;    // indicate value consumed
                    //...munch on data
                    wait (!prodReady)     // complete handshake
                        consReady = 1;
                end
        end
endmodule



//Example 3.7.  The Producer With Fully Interlocked Handshake.
module producer(dataOut, prodReady, consReady);
    output [7:0] dataOut;
    output       prodReady;
    input        consReady;

    reg          prodReady;
    reg [7:0]    dataOut,
                 temp;

    always
        begin
            prodReady = 0;    // indicate nothing to transfer
            forever
                begin
                    // ... produce data and put into "temp"
                    wait (consReady)    // wait for consumer ready
                        dataOut = $random;
                    prodReady = 1;    //indicate ready to transfer
                    wait (!consReady)     //finish handshake
                        prodReady = 0;
                end
        end
endmodule



//Example 3.8.  The Producer-Consumer Module.
module ProducerConsumer;
    wire [7:0] data;
    wire       pReady, cReady;
    
    producer   p(data, pReady, cReady);
    consumer   c(data, pReady, cReady);
endmodule



//Example 3.10.  Using Disable Statement to Model a Reset.
module numberGenDisable (number, reset);
    output [15:0] number;
    input         reset;
    event         ready;
    reg [15:0]    number;

    always
        begin :generator
            number = 3;
            forever
                begin
                    #100 number = number + 1;
                    -> ready;
                end
        end

    always
        @(negedge reset)  disable generator;
endmodule



//Example 3.11.  Flip Flop With Quasi-Continuous Assignment.
module dFlop (preset, clear, q, clock, d);
    input  preset, clear, clock, d;
    output q;
    reg    q;

    always 
        @(clear or preset)
            begin
                if (!clear)
                    #10    assign q = 0;
                else if (!preset)
                    #10    assign q = 1;
                else
                    #10    deassign q;
            end

    always 
        @(negedge clock)
            #10    q = d;
endmodule



//Example 3.13.  The Fibonacci Number Generator With Reset.
module numberGenFork (number, reset);
    output [15:0]    number;
    input            reset;
    event            ready;
    reg    [15:0]    number;

    always
        begin 
            number = 3;
            fork : generator
                begin
                    #100 number = number + 1;
                    -> ready;
                end
                @(negedge reset)  
                    disable generator;
            join
        end
endmodule



//Example 4.1.  A One-Bit Full Adder
module fullAdder(cOut, sum, aIn, bIn, cIn);
    output cOut, sum;
    input  aIn, bIn, cIn;

    wire   x2;

    nand   (x2, aIn, bIn),
           (cOut, x2, x8);
    xnor   (x9, x5, x6);
    nor    (x5, x1, x3),
           (x1, aIn, bIn);
    or     (x8, x1, x7);
    not    (sum, x9),
           (x3, x2),
           (x6, x4),
           (x4, cIn),
           (x7, x6);
endmodule



//Example 4.2.  Wire AND Example.
module andOfComplements (a, b, c, d);
    input   a, b;
    output  c, d;

    wand    c;
    wire    d;

    not (c, a);
    not (c, b);

    not (d, a);
    not (d, b);
endmodule



//Example 4.3.  Illustration of Continuous Assignment.
module oneBitFullAdder(cOut, sum, aIn, bIn, cIn);
    output cOut, sum;
    input  aIn, bIn, cIn;

    assign sum = aIn ^ bIn ^ cIn,
           cOut = (aIn & bIn) | (bIn & cIn) | (aIn & cIn);

endmodule



//Example 4.4.  Function Call From Continuous Assignment.
module multiplexor(a, b, c, d, select, e);
    input       a, b, c, d;
    input [1:0] select;
    output      e;

    assign e = mux (a, b, c,d, select);

    function    mux;
        input       a, b, c, d;
        input [1:0] select;

        case (select)
            2'b00:   mux = a;
            2'b01:   mux = b;
            2'b10:   mux = c;
            2'b11:   mux = d;
            default: mux = 'bx;
        endcase
    endfunction
endmodule



//Example 4.5.  Combined Net and Continuous Assignment.
module modXor (AXorB, a, b);
    parameter size = 8, delay = 15;

    output [size-1:0] AXorB;
    input  [size-1:0] a, b;

    wire   [size-1:0] #delay AXorB = a ^ b;
endmodule



//Example 4.6.  Net and Continuous Assignment Delays.
module wandOfAssigns (a, b, c);
    input  a, b;
    output c;

    wand #10 c;

    assign #5 c = ~a;
    assign #3 c = ~b;
endmodule



//Example 4.7.  Continuous Assignment to an Inout.
module bufferDriver (busLine, bufferedVal, bufInput, busEnable);
    inout  busLine;
    input  bufInput, busEnable;
    output bufferedVal;

    assign bufferedVal = busLine,
           busLine = (busEnable) ? bufInput : 1'bz;
endmodule



//Example 4.10.  A Tristate Latch.
module triStateLatch (qOut, nQOut, clock, data, enable);
    output qOut, nQOut;
    input  clock, data, enable;
    tri    qOut, nQOut;

    not    #5          (ndata, data);
    nand   #(3,5)      d(wa, data, clock),
                       nd(wb, ndata, clock);
    nand   #(12, 15)   qQ(q, nq, wa),
                       nQ(nq, q, wb);
    bufif1 #(3, 7, 13) qDrive (qOut, q, enable),
                       nQDrive(nQOut, nq, enable);
endmodule



//Example 4.11.  Illustration of Min, Typical, and Max Delays.
module IOBuffer (bus, in, out, dir);
    inout  bus;
    input  in, dir;
    output out;

    parameter
        R_Min = 3, R_Typ = 4, R_Max = 5,
        F_Min = 3, F_Typ = 5, F_Max = 7,
        Z_Min = 12, Z_Typ = 15, Z_Max = 17;

    bufif1 #(R_Min: R_Typ: R_Max, 
             F_Min: F_Typ: F_Max,
             Z_Min: Z_Typ: Z_Max)
            (bus, out, dir);

    buf    #(R_Min: R_Typ: R_Max, 
             F_Min: F_Typ: F_Max)
            (in, bus);
endmodule



//Example 5.1.  A User-Defined Combinational Primitive.
primitive carry(carryOut, carryIn, aIn, bIn);
    output carryOut;
    input  carryIn,
           aIn,
           bIn;

    table
        0    00    :    0;
        0    01    :    0;
        0    10    :    0;
        0    11    :    1;
        1    00    :    0;
        1    01    :    1;
        1    10    :    1;
        1    11    :    1;
    endtable
endprimitive



//Example 5.2.  A Carry Primitive.
primitive carryX(carryOut, carryIn, aIn, bIn);
    output carryOut;
    input  aIn,
           bIn,
           carryIn;

    table
        0    00    :    0;
        0    01    :    0;
        0    10    :    0;
        0    11    :    1;
        1    00    :    0;
        1    01    :    1;
        1    10    :    1;
        1    11    :    1;
        0    0x    :    0;
        0    x0    :    0;
        x    00    :    0;
        1    1x    :    1;
        1    x1    :    1;
        x    11    :    1;
    endtable
endprimitive



//Example 5.3.  A Carry Primitive With Shorthand Notation.
primitive carryAbbrev(carryOut, carryIn, aIn, bIn);
    output carryOut;
    input  aIn,
           bIn,
           carryIn;

    table
        0    0?    :    0;
        0    ?0    :    0;
        ?    00    :    0;
        ?    11    :    1;
        1    ?1    :    1;
        1    1?    :    1;
    endtable
endprimitive



//Example 5.4.  A User-Defined Sequential Primitive.
primitive latch (q, clock, data);
    output q;
    reg    q;
    input  clock, data;
    table
//        clock    data   state   output
            0        1    : ? :    1;
            0        0    : ? :    0;
            1        ?    : ? :    -;
    endtable
endprimitive



//Example 5.5.  Edge-Sensitive Behavior.
primitive dEdgeFF_Prim (q, clock, data);
    output q;
    reg    q;
    input  clock, data;

    table
//          clock    data      state   output
            (01)      0        : ? :    0;
            (01)      1        : ? :    1;
            (0x)      1        : 1 :    1;
            (0x)      0        : 0 :    0;
            (?0)      ?        : ? :    -;
              ?      (??)      : ? :    -;
    endtable
endprimitive



//Example 5.6.  Edge-Sensitive Behavior With Shorthand Notation.
primitive dEdgeFFShort (q, clock, data);
    output q;
    reg    q;
    input  clock, data;

    table
//        clock      data  state   output
            r         0    : ? :    0;
            r         1    : ? :    1;
            (0x)      0    : 1 :    1;
            (0x)      1    : 1 :    1;
            (?0)      ?    : ? :    -;
            ?         *    : ? :    -;
    endtable
endprimitive



//Example 5.7.  A JK Flip Flop Example.
primitive jkEdgeFF (q, clock, j, k, preset, clear);
    output q; reg q;
    input  clock, j, k, preset, clear;

    table
    //clock          jk    pc    state   output
    // preset logic
        ?            ??    01    : ? :    1;
        ?            ??    *1    : 1 :    1;

    // clear logic
        ?            ??    10    : ? :    0;
        ?            ??    1*    : 0 :    0;

    // normal clocking cases
        r            00    11    : ? :    -;
        r            01    11    : ? :    0;
        r            10    11    : ? :    1;
        r            11    11    : 0 :    1;
        r            11    11    : 1 :    0;
        f            ??    ??    : ? :    -;

    // j and k transition cases
        b            *?    ??    : ? :    -;
        b            ?*    ??    : ? :    -;

    //cases reducing pessimism
        p            00    11    : ? :    -;
        p            0?    1?    : 0 :    -;
        p            ?0    ?1    : 1 :    -;
        (x0)         ??    ??    : ? :    -;
        (1x)         00    11    : ? :    -;
        (1x)         0?    1?    : 0 :    -;
        (1x)         ?0    ?1    : 1 :    -;
        x            *0    ?1    : 1 :    -;
        x            0*    1?    : 0 :    -;
    endtable
endprimitive



//Example 6.1.  MOS Shift Register.
//Dynamic MOS serial shift register circuit description 
module shreg (out, in, phase1, phase2);
    /* IO port declarations, where 'out' is the inverse
    of 'in' controlled by the dual-phased clock */

    output out;       //shift register output
    input  in,        //shift register input
           phase1,    //clocks
           phase2;

    tri    wb1, wb2, out; //tri nets pulled up to VDD
    pullup //depletion mode pullup devices
           (wb1), (wb2), (out);

    trireg (medium) wa1, wa2, wa3; //charge storage nodes

    supply0 gnd; //ground supply

    nmos #3 //pass devices and their interconnections
            a1(wa1,in,phase1), b1(wb1,gnd,wa1),
            a2(wa2,wb1,phase2), b2(wb2,gnd,wa2),
            a3(wa3,wb2,phase1), gout(out,gnd,wa3);
endmodule




//Example 6.2.  Simulating the MOS Shift Register.
module waveShReg;
    wire shiftout;      //net to receive circuit output value
    reg  shiftin;       //register to drive value into circuit
    reg  phase1,phase2; //clock driving values

    parameter d = 100;  //define the waveform time step

    shreg cct (shiftout, shiftin, phase1, phase2);

    initial
        begin :main
            shiftin = 0; //initialize waveform input stimulus
            phase1 = 0;
            phase2 = 0;
            setmon;      // setup the monitoring information
            repeat(2)    //shift data in
                clockcct;
        end

task setmon;        //display header and setup monitoring
    begin
        $display("        time   clks   in  out  wa1-3  wb1-2");
        $monitor ($time,,,,phase1, phase2,,,,,,shiftin,,,, shiftout,,,,,
            cct.wa1, cct.wa2, cct.wa3,,,,,cct.wb1, cct.wb2);
    end
endtask

task clockcct; //produce dual-phased clock pulse
    begin
        #d phase1 = 1; //time step defined by parameter d
        #d phase1 = 0;
        #d phase2 = 1;
        #d phase2 = 0;
    end
endtask
endmodule



//Example 6.3.  A Static RAM Cell.
//description of a MOS static RAM cell
module sram(dataOut, address, dataIn, write);
    output dataOut;
    input  address, dataIn, write;

    tri w1, w3, w4, w43;

    bufif1
        g1(w1, dataIn, write);
    tranif1
        g2(w4, w1, address);
    not (pull0, pull1)
        g3(w3, w4), g4(w4, w3);
    buf
        g5(dataOut, w1);
endmodule

//waveform for testing the static RAM cell
module wave_sram;
    wire dataOut;
    reg  address, dataIn, write;

    //make the sram a submodule and define the interconnections
    sram cell(dataOut, address, dataIn, write);

    //define the waveform to drive the circuit
    parameter d = 100;
    initial
        begin
            #d dis;
            #d address = 1;
            #d dis;
            #d dataIn = 1;
            #d dis;
            #d write = 1;
            #d dis;
            #d write = 0;
            #d dis;
            #d write = 'bx;
            #d dis;
            #d address = 'bx;
            #d dis;
            #d address = 1;
            #d dis;
            #d write = 0;
            #d dis;
        end

task dis;            //display the circuit state
    $display($time,,
    "addr=%v d_in=%v write=%v d_out=%v",
        address, dataIn, write, dataOut,
        " (134)=%b%b%b  w134=%v %v %v",
        cell.w1, cell.w3, cell.w4,
        cell.w1, cell.w3, cell.w4);
endtask
endmodule



//THE MINISIM EXAMPLE
module miniSim;

// element types being modeled
`define Nand 0
`define DEdgeFF 1
`define Wire 2

// literal values with strength:
//   format is 8 0-strength bits in decreasing strength order
//   followed by 8 1-strength bits in decreasing strength order
`define Strong0 16'b01000000_00000000
`define Strong1 16'b00000000_01000000
`define StrongX 16'b01111111_01111111
`define Pull0   16'b00100000_00000000
`define Pull1   16'b00000000_00100000
`define Highz0  16'b00000001_00000000
`define Highz1  16'b00000000_00000001

// three-valued logic set
`define Val0 3'd0
`define Val1 3'd1
`define ValX 3'd2

parameter
    DebugFlags =               'b11000, //set to 1 for message
//                               |||||
//  loading                   <--+||||
//  event value changes      <----+|||
//  wire calculation        <------+||
//  evaluation             <--------+|
//  scheduling           <-----------+

    IndexSize = 16,     //maximum size for index pointers
    MaxElements = 50,   //maximum number of elements
    TypeSize = 12;      //maximum number of types

reg [IndexSize-1:0]
    eventElement,             //output value change element
    evalElement,              //evaluation element on fanout
    fo0Index[1:MaxElements],  //first fanout index of eventElement
    fo1Index[1:MaxElements],  //second fanout index of eventElement
    currentList,              //current time scheduled event list
    nextList,                 //unit delay scheduled event list
    schedList[1:MaxElements]; //scheduled event list index
reg [TypeSize-1:0]
    eleType[1:MaxElements]; //element type
reg
    fo0TermNum[1:MaxElements],   //first fanout input terminal number
    fo1TermNum[1:MaxElements],   //second fanout input terminal number
    schedPresent[1:MaxElements]; //element is in scheduled event list flags
reg [15:0]
    eleStrength[1:MaxElements], //element strength indication
    outVal[1:MaxElements],      //element output value
    in0Val[1:MaxElements],      //element first input value
    in1Val[1:MaxElements],      //element second input value
    in0, in1, out, oldIn0;      //temporary value storage

integer pattern, simTime; //time keepers

initial
  begin
    // initialize variables
    pattern = 0;
    currentList = 0;
    nextList = 0;

    $display("Loading toggle circuit");
    loadElement(1, `DEdgeFF, 0, `Strong1,0,0, 4,0,0,0);
    loadElement(2, `DEdgeFF, 0, `Strong1,0,0, 3,0,0,0); 
    loadElement(3, `Nand, (`Strong0|`Strong1),
        `Strong0,`Strong1,`Strong1, 4,0,1,0); 
    loadElement(4, `DEdgeFF, (`Strong0|`Strong1),
        `Strong1,`Strong1,`Strong0, 3,0,1,0); 

    // apply stimulus and simulate
    $display("Applying 2 clocks to input element 1");
    applyClock(2, 1);
    $display("Changing element 2 to value 0 and applying 1 clock");
    setupStim(2, `Strong0);
    applyClock(1, 1);

    $display("\nLoading open-collector and pullup circuit");
    loadElement(1, `DEdgeFF, 0, `Strong1,0,0, 3,0,0,0);
    loadElement(2, `DEdgeFF, 0, `Strong0,0,0, 4,0,0,0);
    loadElement(3, `Nand, (`Strong0|`Highz1),
        `Strong0,`Strong1,`Strong1, 5,0,0,0);
    loadElement(4, `Nand, (`Strong0|`Highz1),
        `Highz1,`Strong0,`Strong1, 5,0,1,0);
    loadElement(5, `Wire, 0,
        `Strong0,`Strong0,`Highz1, 7,0,1,0);
    loadElement(6, `DEdgeFF, 0, `Pull1,0,0, 7,0,0,0);
    loadElement(7, `Wire, 0,
        `Strong0,`Pull1,`Strong0, 0,0,0,0);

    // apply stimulus and simulate
    $display("Changing element 1 to value 0");
    pattern = pattern + 1;
    setupStim(1, `Strong0);
    executeEvents;
    $display("Changing element 2 to value 1");
    pattern = pattern + 1;
    setupStim(2, `Strong1);
    executeEvents;
    $display("Changing element 2 to value X");
    pattern = pattern + 1;
    setupStim(2, `StrongX);
    executeEvents;
  end

// Initialize data structure for a given element.
task loadElement;
input [IndexSize-1:0] loadAtIndex; //element index being loaded
input [TypeSize-1:0] type;         //type of element
input [15:0] strengthCoercion;     //strength specification of element
input [15:0] oVal, i0Val, i1Val;   //output and input values
input [IndexSize-1:0] fo0, fo1;    //fanout element indexes
input fo0Term, fo1Term;            //fanout element input terminal indicators
  begin
    if (DebugFlags[4])
        $display(
            "Loading element %0d, type %0s, with initial value %s(%b_%b)",
            loadAtIndex, typeString(type),
            valString(oVal), oVal[15:8], oVal[7:0]);
    eleType[loadAtIndex] = type;
    eleStrength[loadAtIndex] = strengthCoercion;
    outVal[loadAtIndex] = oVal;
    in0Val[loadAtIndex] = i0Val;
    in1Val[loadAtIndex] = i1Val;
    fo0Index[loadAtIndex] = fo0;
    fo1Index[loadAtIndex] = fo1;
    fo0TermNum[loadAtIndex] = fo0Term;
    fo1TermNum[loadAtIndex] = fo1Term;
    schedPresent[loadAtIndex] = 0;
  end
endtask

// Given a type number, return a type string
function [32*8:1] typeString;
input [TypeSize-1:0] type;
    case (type)
      `Nand: typeString = "Nand";
      `DEdgeFF: typeString = "DEdgeFF";
      `Wire: typeString = "Wire";
      default: typeString = "*** Unknown element type";
    endcase
endfunction

// Setup a value change on an element.
task setupStim;
input [IndexSize-1:0] vcElement; //element index
input [15:0] newVal;           //new element value
  begin
    if (! schedPresent[vcElement])
      begin
        schedList[vcElement] = currentList;
        currentList = vcElement;
        schedPresent[vcElement] = 1;
      end
    outVal[vcElement] = newVal;
  end
endtask

// Setup and simulate a given number of clock pulses to a given element.
task applyClock;
input [7:0] nClocks;
input [IndexSize-1:0] vcElement;
    repeat(nClocks)
      begin
        pattern = pattern + 1;
        setupStim(vcElement, `Strong0);
        executeEvents;
        pattern = pattern + 1;
        setupStim(vcElement, `Strong1);
        executeEvents;
      end
endtask

// Execute all events in the current event list.
// Then move the events in the next event list to the current event
// list and loop back to execute these events. Continue this loop
// until no more events to execute.
// For each event executed, evaluate the two fanout elements if present.
task executeEvents;
reg [15:0] newVal;
  begin
    simTime = 0;
    while (currentList)
      begin
        eventElement = currentList;
        currentList = schedList[eventElement];
        schedPresent[eventElement] = 0;
        newVal = outVal[eventElement];
        if (DebugFlags[3])
            $display(
                "At %0d,%0d Element %0d, type %0s, changes to %s(%b_%b)",
                pattern, simTime,
                eventElement, typeString(eleType[eventElement]),
                valString(newVal), newVal[15:8], newVal[7:0]);
        if (fo0Index[eventElement]) evalFo(0);
        if (fo1Index[eventElement]) evalFo(1);
        if (! currentList) // if empty move to next time unit
          begin
            currentList = nextList;
            nextList = 0;
            simTime = simTime + 1;
          end
      end
  end
endtask

// Evaluate a fanout element by testing its type and calling the
// appropriate evaluation routine.
task evalFo;
input fanout; //first or second fanout indicator
  begin
    evalElement = fanout ? fo1Index[eventElement] : 
                           fo0Index[eventElement];
    if (DebugFlags[1])
        $display("Evaluating Element %0d type is %0s",
            evalElement, typeString(eleType[evalElement]));
    case (eleType[evalElement])
      `Nand: evalNand(fanout);
      `DEdgeFF: evalDEdgeFF(fanout);
      `Wire: evalWire(fanout);
    endcase
  end
endtask

// Store output value of event element into
// input value of evaluation element.
task storeInVal;
input fanout; //first or second fanout indicator
  begin
    // store new input value
    if (fanout ? fo1TermNum[eventElement] : fo0TermNum[eventElement])
        in1Val[evalElement] = outVal[eventElement];
    else
        in0Val[evalElement] = outVal[eventElement];
  end
endtask

// Convert a given full strength value to three-valued logic (0, 1 or X)
function [1:0] log3;
input [15:0] inVal;
    casez (inVal)
      16'b00000000_00000000: log3 = `ValX;
      16'b???????0_00000000: log3 = `Val0;
      16'b00000000_???????0: log3 = `Val1;
      default:               log3 = `ValX;
    endcase
endfunction

// Convert a given full strength value to four-valued logic (0, 1, X or Z),
// returning a 1 character string
function [8:1] valString;
input [15:0] inVal;
    case (log3(inVal))
      `Val0: valString = "0";
      `Val1: valString = "1";
      `ValX: valString = (inVal & 16'b11111110_11111110) ? "X" : "Z";
    endcase
endfunction

// Coerce a three-valued logic output value to a full output strength value
// for the scheduling of the evaluation element
function [15:0] strengthVal;
input [1:0] logVal;
    case (logVal)
      `Val0: strengthVal = eleStrength[evalElement] & 16'b11111111_00000000;
      `Val1: strengthVal = eleStrength[evalElement] & 16'b00000000_11111111;
      `ValX: strengthVal = fillBits(eleStrength[evalElement]);
    endcase
endfunction

// Given an incomplete strength value, fill the missing strength bits.
// The filling is only necessary when the value is unknown.
function [15:0] fillBits;
input [15:0] val;
  begin
    fillBits = val;
    if (log3(val) == `ValX)
      begin
        casez (val)
  16'b1???????_????????: fillBits = fillBits | 16'b11111111_00000001;
  16'b01??????_????????: fillBits = fillBits | 16'b01111111_00000001;
  16'b001?????_????????: fillBits = fillBits | 16'b00111111_00000001;
  16'b0001????_????????: fillBits = fillBits | 16'b00011111_00000001;
  16'b00001???_????????: fillBits = fillBits | 16'b00001111_00000001;
  16'b000001??_????????: fillBits = fillBits | 16'b00000111_00000001;
  16'b0000001?_????????: fillBits = fillBits | 16'b00000011_00000001;
        endcase
        casez (val)
  16'b????????_1???????: fillBits = fillBits | 16'b00000001_11111111;
  16'b????????_01??????: fillBits = fillBits | 16'b00000001_01111111;
  16'b????????_001?????: fillBits = fillBits | 16'b00000001_00111111;
  16'b????????_0001????: fillBits = fillBits | 16'b00000001_00011111;
  16'b????????_00001???: fillBits = fillBits | 16'b00000001_00001111;
  16'b????????_000001??: fillBits = fillBits | 16'b00000001_00000111;
  16'b????????_0000001?: fillBits = fillBits | 16'b00000001_00000011;
       endcase
     end
  end
endfunction

// Evaluate a 'Nand' gate primitive.
task evalNand;
input fanout; //first or second fanout indicator
  begin
    storeInVal(fanout);
    // calculate new output value
    in0 = log3(in0Val[evalElement]);
    in1 = log3(in1Val[evalElement]);
    out = ((in0 == `Val0) || (in1 == `Val0)) ?
        strengthVal(`Val1) :
        ((in0 == `ValX) || (in1 == `ValX)) ?
            strengthVal(`ValX):
            strengthVal(`Val0);
    // schedule if output value is different
    if (out != outVal[evalElement])
        schedule(out);
  end
endtask

// Evaluate a D positive edge-triggered flip flop
task evalDEdgeFF;
input fanout; //first or second fanout indicator
    // check value change is on clock input
    if (fanout ? (fo1TermNum[eventElement] == 0) :
                 (fo0TermNum[eventElement] == 0))
      begin
        // get old clock value
        oldIn0 = log3(in0Val[evalElement]);
        storeInVal(fanout);
        in0 = log3(in0Val[evalElement]);
        // test for positive edge on clock input
        if ((oldIn0 == `Val0) && (in0 == `Val1))
          begin
            out = strengthVal(log3(in1Val[evalElement]));
            if (out != outVal[evalElement])
              schedule(out);
          end
      end
    else
        storeInVal(fanout); // store data input value
endtask

// Evaluate a wire with full strength values
task evalWire;
input fanout;
reg [7:0] mask;
  begin
    storeInVal(fanout);

    in0 = in0Val[evalElement];
    in1 = in1Val[evalElement];
    mask = getMask(in0[15:8]) & getMask(in0[7:0]) &
           getMask(in1[15:8]) & getMask(in1[7:0]);
    out = fillBits((in0 | in1) & {mask, mask});

    if (out != outVal[evalElement])
        schedule(out);

    if (DebugFlags[2])
        $display("in0 = %b_%b\nin1 = %b_%b\nmask= %b %b\nout = %b_%b",
            in0[15:8],in0[7:0], in1[15:8],in1[7:0],
            mask,mask, out[15:8],out[7:0]);
  end
endtask

// Given either a 0-strength or 1-strength half of a strength value
// return a masking pattern for use in a wire evaluation.
function [7:0] getMask;
input [7:0] halfVal; //half a full strength value
    casez (halfVal)
      8'b???????1: getMask = 8'b11111111;
      8'b??????10: getMask = 8'b11111110;
      8'b?????100: getMask = 8'b11111100;
      8'b????1000: getMask = 8'b11111000;
      8'b???10000: getMask = 8'b11110000;
      8'b??100000: getMask = 8'b11100000;
      8'b?1000000: getMask = 8'b11000000;
      8'b10000000: getMask = 8'b10000000;
      8'b00000000: getMask = 8'b11111111;
    endcase
endfunction

// Schedule the evaluation element to change to a new value.
// If the element is already scheduled then just insert the new value.
task schedule;
input [15:0] newVal; // new value to change to
  begin
    if (DebugFlags[0])
        $display(
            "Element %0d, type %0s, scheduled to change to %s(%b_%b)",
            evalElement, typeString(eleType[evalElement]),
            valString(newVal), newVal[15:8], newVal[7:0]);
    if (! schedPresent[evalElement])
      begin
        schedList[evalElement] = nextList;
        schedPresent[evalElement] = 1;
        nextList = evalElement;
      end
    outVal[evalElement] = newVal;
  end
endtask
endmodule

/*******************  PLEASE NOTE:  ************************************

The values printed out in the book section 7.1.3 have the wrong
format. The 0 and 1 strength bits need to be swapped around. For
example, the first value printed in the book should read
1(00000000_01000000) and not 1(0100000_00000000). The value format you
get from running the above minisim description through Verilog should
be correct.

Here is a listing of the results:

Loading toggle circuit
Loading element 1, type DEdgeFF, with initial value 1(00000000_01000000)
Loading element 2, type DEdgeFF, with initial value 1(00000000_01000000)
Loading element 3, type Nand, with initial value 0(01000000_00000000)
Loading element 4, type DEdgeFF, with initial value 1(00000000_01000000)
Applying 2 clocks to input element 1
At 1,0 Element 1, type DEdgeFF, changes to 0(01000000_00000000)
At 2,0 Element 1, type DEdgeFF, changes to 1(00000000_01000000)
At 2,1 Element 4, type DEdgeFF, changes to 0(01000000_00000000)
At 2,2 Element 3, type Nand, changes to 1(00000000_01000000)
At 3,0 Element 1, type DEdgeFF, changes to 0(01000000_00000000)
At 4,0 Element 1, type DEdgeFF, changes to 1(00000000_01000000)
At 4,1 Element 4, type DEdgeFF, changes to 1(00000000_01000000)
At 4,2 Element 3, type Nand, changes to 0(01000000_00000000)
Changing element 2 to value 0 and applying 1 clock
At 5,0 Element 1, type DEdgeFF, changes to 0(01000000_00000000)
At 5,0 Element 2, type DEdgeFF, changes to 0(01000000_00000000)
At 5,1 Element 3, type Nand, changes to 1(00000000_01000000)
At 6,0 Element 1, type DEdgeFF, changes to 1(00000000_01000000)

Loading open-collector and pullup circuit
Loading element 1, type DEdgeFF, with initial value 1(00000000_01000000)
Loading element 2, type DEdgeFF, with initial value 0(01000000_00000000)
Loading element 3, type Nand, with initial value 0(01000000_00000000)
Loading element 4, type Nand, with initial value Z(00000000_00000001)
Loading element 5, type Wire, with initial value 0(01000000_00000000)
Loading element 6, type DEdgeFF, with initial value 1(00000000_00100000)
Loading element 7, type Wire, with initial value 0(01000000_00000000)
Changing element 1 to value 0
At 7,0 Element 1, type DEdgeFF, changes to 0(01000000_00000000)
At 7,1 Element 3, type Nand, changes to Z(00000000_00000001)
At 7,2 Element 5, type Wire, changes to Z(00000000_00000001)
At 7,3 Element 7, type Wire, changes to 1(00000000_00100000)
Changing element 2 to value 1
At 8,0 Element 2, type DEdgeFF, changes to 1(00000000_01000000)
At 8,1 Element 4, type Nand, changes to 0(01000000_00000000)
At 8,2 Element 5, type Wire, changes to 0(01000000_00000000)
At 8,3 Element 7, type Wire, changes to 0(01000000_00000000)
Changing element 2 to value X
At 9,0 Element 2, type DEdgeFF, changes to X(01111111_01111111)
At 9,1 Element 4, type Nand, changes to X(01111111_00000001)
At 9,2 Element 5, type Wire, changes to X(01111111_00000001)
At 9,3 Element 7, type Wire, changes to X(01111111_00111111)
*****************************************************************/




//THE 8251A EXAMPLE
//Cadence Design Systems, Inc. does not guarantee
//the accuracy or completeness of this model.
//Anyone using this does so at their own risk.
//Intel and MCS are trademarks of the Intel Corporation.
module I8251A(dbus,rcd,gnd,txc_,write_,chipsel_,comdat_,read_,rxrdy,
             txrdy,syndet,cts_,txe,txd,clk,reset,dsr_,rts_,dtr_,rxc_,vcc);

    parameter [7:0] instance_id = 8'h00;

    parameter [8:1] dflags     =      8'b00000100; // Defaults for diagnostics
    //                                      |||||
    // diagnostic dflags:                   |||||
    // bit 5 (16)  operation event trace  <-+||||
    // bit 4 (8)  communication errors   <---+||| (parity, frame, overrun)
    // bit 3 (4)  timing check          <-----+||
    // bit 2 (2) = print receiving     <-------+|
    // bit 1 (1) = print transmitting <---------+

    /* timing constants, for A. C. timing check, only non-zero times 
       are specified, in nano-sec */

    /* read cycle */
    `define TRR  250
    `define TRD  200
    `define TDF  100  // max. time used

    /* write cycle */
    `define TWW  250
    `define TDW  150
    `define TWD  20
    `define TRV  6  // in terms of clock cycles

    /* other timing */
    `define TTXRDY 8 // 8 clock cycles


    input
        rcd, // receive data
        rxc_, // receive clock
        txc_, // transmit clock
        chipsel_, // chip selected when low
        comdat_,  // command/data_ select
        read_, write_,
        dsr_, // data set ready
        cts_, // clear to send
        reset,// reset when high
        clk, // at least 30 times of the transmit/receive data bit rates
        gnd,
        vcc;

    output
        rxrdy, // receive data ready when high
        txd, // transmit data line
        txrdy, // transmit buffer ready to accept another byte to transfer
        txe, // transmit buffer empty
        rts_, // request to send 
        dtr_; // data terminal ready

    inout[7:0]
        dbus;

    inout
        syndet; //outside synchonous detect or output to indicate syn det

    supply0
        gnd;
    supply1
        vcc;

    reg
        txd,
        rxrdy,
        txe,
        dtr_,
        rts_;

    reg[7:0]
        receivebuf,
        rdata,
        status;

    reg
        recvdrv,
        statusdrv;

    assign
        // if recvdrv 1 dbus is driven by rdata
        dbus = recvdrv ? rdata : 8'bz,
        dbus = statusdrv ? status : 8'bz;

    reg[7:0]
        command,
        tdata_out,  // data being transmitted serially
        tdata_hold, // data to be transmitted next if tdata_out is full
        sync1, sync2, // synchronous data bytes
        modreg;
    and  (txrdy,status[0],command[0], ~ cts_);

    reg transmitter_reset, // set to 1 upon a reset, cleared upon write data
        tdata_out_full,  // 1 if data in tdata_out has not been transmitted.
        tdata_hold_full, // 1 if data in tdata_hold has not been transferred to
                         //   tdata_out for serial transmission.
        tdata_hold_cts;  // 1 if tdata_hold_full and it was cts when data was
                         //   transferred to tdata_hold.
                         // 0 if tdata_hold is empty or is full but was filled
                         //   while it was not cts.

    reg tdata_out_wait;  // 0 if a stop bit was just sent and we do not need
                         //   to wait for a negedge on txc before transmitting

    reg[7:0]   syncmask;
    nmos  syndet_gate1(syndet,status[6], ~ modreg[6]);

    reg   sync_to_receive; // 1(2) if looking for 1st(2nd) sync on rxd
    reg   syncs_received;  // 1 if sync chars received, 0 if looking for sync(s)
    reg   rec_sync_index; // indicating the syn. character to be matched
   
    integer  breakcount_period; // number of clock periods to count as break

    reg   sync_to_transmit;  // 1(2) if 1st(2nd) sync char should be sent next

    reg[7:0]  data_mask;    // masks off the data bits (if char size is not 8)
    // temporary registers
    reg[1:0] csel;          // indicates what next write means if comdat_=1:
                            // (0=mode instruction,1=sync1,2=sync2,3=command)
    reg[5:0]
        baudmx,
        tbaudcnt,
        rbaudcnt; // baud rate 
    reg[7:0]
        tstoptotal; // no. of tranmit clock pulses for stop bit (0 if sync mode)
    reg[3:0]
        databits;   // no. of data bits in a character (5,6,7 or 8)

    reg
        rdatain; // a data byte is read in if 1

    reg was_cts_when_received;  // 0: if cts_ was high when char was received
                                // 1: if cts_ was low when char was received
                                //    (and so char was sent before shutdown)

    event
        resete,
        start_receiver_e;

    reg receive_in_progress;


    event txende;



                /*** COMMUNICATION ERRORS ***/

    task frame_error;
        begin
            if(dflags[4])
                $display("I8251A (%h) at %d: *** frame error",
                                                          instance_id, $time);
            status[5]=1;
        end
    endtask

    task parity_error;
        begin
            if(dflags[4])
                $display("I8251A (%h) at %d: *** parity error on data: %b",
                                              instance_id, $time, receivebuf);
            status[3]=1;
        end
    endtask

    task overrun_error;
        begin
            if(dflags[4])
                $display("I8251A (%h) at %d: *** overrun error",
                                                          instance_id, $time);
            status[4]=1;
        end
    endtask



                /*** TIMING VIOLATIONS ***/

    integer
        time_dbus_setup,
        time_write_begin,
        time_write_end,
        time_read_begin,
        time_read_end,
        between_write_clks; // to check between write recovery
    reg reset_signal_in;    // to check the reset signal pulse width

    initial
    begin
        time_dbus_setup  = -9999;
        time_write_begin = -9999;
        time_write_end   = -9999;
        time_read_begin  = -9999;
        time_read_end    = -9999;
        between_write_clks = `TRV; // start: TRV clk periods since last write

    end



                /** Timing analysis for read cycles **/
 
    always @(negedge read_) 
        if (chipsel_==0)
        begin
            time_read_begin=$time;
            read_address_watch;
        end

       /* Timing violation: read pulse must be TRR ns */

    always @(posedge read_)
        if (chipsel_==0)
        begin
            disable read_address_watch;
            time_read_end=$time;

            if(dflags[3] && (($time-time_read_begin) < `TRR))
                $display("I8251A (%h) at %d: *** read pulse width violation",
                                                           instance_id, $time);
        end

       /* Timing violation: address (comdat_ and chipsel_) must be stable */
       /*                   stable throughout read                        */

    task read_address_watch;
        @(comdat_ or chipsel_) // if the "address" changes
            if (read_==0)      //    and read_ did not change at the same time
                if (dflags[3])
                    $display("I8251A (%h) at %d: *** address hold error on read",
                                                          instance_id, $time);
    endtask

                /** Timing analysis for write cycles **/
 
    always @(negedge write_) 
        if (chipsel_==0)
        begin
            time_write_begin=$time;
            write_address_watch;
        end


       /* Timing violation: read pulse must be TRR ns */
       /* Timing violation: TDW ns bus setup time before posedge write_ */
       /* Timing violation: TWD ns bus hold  time after  posedge write_ */

    always @(posedge write_)
        if (chipsel_==0)
        begin
            disable write_address_watch;
            time_write_end=$time;

            if(dflags[3] && (($time-time_write_begin) < `TWW))
                $display("I8251A (%h) at %d: *** write pulse width violation",
                                                           instance_id, $time);

            if(dflags[3] && (($time-time_dbus_setup) < `TDW))
                $display("I8251A (%h) at %d: *** data setup violation on write",
                                                           instance_id, $time);
        end

    always @dbus
        begin
            time_dbus_setup=$time;

            if(dflags[3] && (($time-time_write_end < `TWD)))
                $display("I8251A (%h) at %d: *** data hold violation on write",
                                                           instance_id, $time);
        end


       /* Timing violation: address (comdat_ and chipsel_) must be stable */
       /*                   stable throughout write                       */

    task write_address_watch;
        @(comdat_ or chipsel_) // if the "address" changes
            if (write_==0)     //    and write_ did not change at the same time
                if (dflags[3])
                   $display("I8251A (%h) at %d: *** address hold error on write",
                                                          instance_id, $time);
    endtask


        /* Timing violation: minimum of TRV clk cycles between writes */

    always @(negedge write_)
        if (chipsel_== 0)
        begin
            time_write_begin=$time;
            if(dflags[3] && between_write_clks < `TRV)
               $display("I8251A (%h) at %d: *** between write recovery violation",
                                                           instance_id, $time);
            between_write_clks = 0;
        end
 
    always @(negedge write_)
        repeat (`TRV) @(posedge clk)
            between_write_clks = between_write_clks + 1;



                /** Timing analysis for reset sequence **/

       /* Timing violation: reset pulse must be 6 clk cycles */

    always @(posedge reset)
        begin :reset_block
        reset_signal_in=1;
        repeat(6) @(posedge clk);
        reset_signal_in=0;
        // external reset
        -> resete;
        end

    always @(negedge reset)
        begin
        if(dflags[3] && (reset_signal_in==1))
            $display("I8251A (%h) at %d: *** reset pulse too short",
                                                           instance_id, $time);
        disable reset_block;
        end




                /*** BEHAVIORAL DESCRIPTION ***/


        /* Reset sequence */

    initial
        begin // power-on reset
        reset_signal_in=0;
        ->resete;
        end

    always @resete
        begin
        if(dflags[5])
            $display("I8251A (%h) at %d: performing reset sequence",
                                                           instance_id, $time);
        csel=0;
        transmitter_reset=1;
        tdata_out_full=0;
        tdata_out_wait=0;
        tdata_hold_full=0;
        tdata_hold_cts=0;
        rdatain=0;
        status=4;  // only txe is set
        txe=1;
        statusdrv=0;
        recvdrv=0;
        txd=1; // line at mark state upon reset until data is transmitted
        // assign not allowed for status, etc.
        rxrdy=0;
        command=0;
        dtr_=1;
        rts_=1;
        status[6]=0; // syndet is reset to output low 
        sync_to_transmit=1;     // transmit sync char #1 when sync are transmt'd
        sync_to_receive=1;
        between_write_clks = `TRV;
        receive_in_progress=0;
        disable read_address_watch;
        disable write_address_watch;
        disable trans1;
        disable trans2;
        disable trans3;
        disable trans4;
        disable rcv_blk;
        disable sync_hunt_blk;
        disable double_sync_hunt_blk;
        disable parity_sync_hunt_blk;
        disable syn_receive_internal;
        disable asyn_receive;
        disable break_detect_blk;
        disable break_delay_blk;
        end


    always @(negedge read_) 
        if (chipsel_==0)
        begin
            #(`TRD) // time for data to show on the data bus

            if (comdat_==0)     // 8251A DATA ==> DATA BUS
            begin
                recvdrv=1;
                rdatain=0; // no receive byte is ready
                rxrdy=0;
                status[1]=0;
            end
            else                // 8251A STATUS ==> DATA BUS
            begin
                statusdrv=1;
                if (modreg [1:0] == 2'b00) // if sync mode
                    status[6]=0;           //     reset syndet upon status read
                                           // Note: is only reset upon reset
                                           //       or rxd=1 in async mode
            end
        end

    always @(posedge read_)
        begin
            #(`TDF)  // data from read stays on the bus after posedge read_
            recvdrv=0;
            statusdrv=0;
        end


    always @(negedge write_)
    begin
        if((chipsel_==0) && (comdat_==0))
        begin
            txe=0;
            status[2]=0; // transmitter not empty after receiving data
            status[0]=0; // transmitter not ready after receiving data
        end
    end


    always @(posedge write_)          // read the command/data from the CPU
        if (chipsel_==0)
        begin
            if (comdat_==0)       // DATA BUS ==> 8251A DATA
            begin
                case (command[0] & ~ cts_)
                0:                    // if it is not clear to send
                begin
                    tdata_hold=dbus;
                    tdata_hold_full=1;//    then mark the data as received and
                    tdata_hold_cts=0; //    that it should be sent when cts
                end
                1:                    // if it is clear to send ...
                if(transmitter_reset) // ... and this is 1st data since reset
                begin
                    transmitter_reset=0;
                    tdata_out=dbus;
                    tdata_out_wait=1; //    then wait for a negedge on txc
                    tdata_out_full=1; //         and transmit the data
                    tdata_hold_full=0;
                    tdata_hold_cts=0;
                    repeat(`TTXRDY) @(posedge clk);
                    status[0]=1;      //         and set the txrdy status bit
                end
                else                  // ... and a sync/data char is being sent
                begin
                    tdata_hold=dbus;  //    then mark the data as being received
                    tdata_hold_full=1;//    and that it should be transmitted if
                    tdata_hold_cts=1; //    it becomes not cts,
                                      //    but do not set the txrdy status bit
                end
                endcase
            end
            else                  // DATA BUS ==> CONTROL
            begin
                case (csel)
                0:                // case 0:  MODE INSTRUCTION
                begin
                    modreg=dbus; 
                    if(modreg[1:0]==0)    // synchronous mode
                    begin
                        csel=1;
                        baudmx=1;
                        tstoptotal=0; // no stop bit for synch. op.
                    end
                    else
                    begin                 // asynchronous mode
                        csel=3;
                        baudmx=1; // 1X baud rate
                        if(modreg[1:0]==2'b10)baudmx=16;
                        if(modreg[1:0]==2'b11)baudmx=64;
                        // set up the stop bits in clocks
                        tstoptotal=baudmx;
                        if(modreg[7:6]==2'b10)tstoptotal=
                                   tstoptotal+baudmx/2;
                        if(modreg[7:6]==2'b11)tstoptotal=
                                   tstoptotal+tstoptotal;
                    end
                    databits=modreg[3:2]+5; // bits per char
                    data_mask=255 >> (3-modreg[3:2]);
                end

                1:                // case 1:  1st SYNC CHAR - SYNC MODE
                begin
                    sync1=dbus; 
                    /* the syn. character will be adjusted to the most
                       significant bit to simplify syn. hunt, 
                       syncmask is also set to test the top data bits  */
                    case (modreg[3:2])
                    0:
                    begin
                        sync1=sync1<< 3;
                        syncmask=8'b11111000;
                    end

                    1:
                    begin
                        sync1=sync1<< 2;
                        syncmask=8'b11111100;
                    end

                    2:
                    begin
                        sync1=sync1<< 1;
                        syncmask=8'b11111110;
                    end
                    3:
                        syncmask=8'b11111111;
                    endcase

                    if(modreg[7]==0)
                        csel=2;   // if in double sync char mode, get 2 syncs
                    else
                        csel=3;   // if in single sync char mode, get 1 sync
                end

                2:                // case 2:  2nd SYNC CHAR - SYNC MODE
                begin
                    sync2=dbus;
                    case (modreg[3:2])
                    0: sync2=sync2<< 3;
                    1: sync2=sync2<< 2;
                    2: sync2=sync2<< 1;
                    endcase

                    csel=3;
                end

                3:             // case 3:  COMMAND INSTRUCTION - SYNC/ASYNC MODE
                begin
                    status[0]=0; // Trick: force delay txrdy pin if command[0]=1
                    command=dbus;
                    dtr_= ! command[1];

                    if(command[3])           // if send break command
                        assign txd=0;        //    set txd=0 (ignores/overrides
                    else                     //    later non-assign assignments)
                        deassign txd;

                    if(command[4]) status[5:3]=0; // Clear Frame/Parity/Overrun
                    rts_= ! command[5];
                    if(command[6]) ->resete;      // internal reset

                    if(modreg[1:0]==0 && command[7])
                    begin                    // if sync mode and enter hunt
                        disable              //    disable the sync receiver
                            syn_receive_internal;
                        disable
                            syn_receive_external;

                        receivebuf=8'hff;    //    reset recieve buffer 1's
                        -> start_receiver_e; //    restart sync mode receiver
                    end

                    if(receive_in_progress==0)
                        -> start_receiver_e;

                    repeat(`TTXRDY) @(posedge clk);
                    status[0]=1;
                end
                endcase  
            end
        end


    reg [7:0] serial_data;
    reg parity_bit;


    always wait (tdata_out_full==1)
    begin :trans1

        if(dflags[1])
            $display("I8251A (%h) at %d: transmitting data: %b",
            			  instance_id, $time, tdata_out);

        if (tdata_out_wait)                 // if the data arrived any old time
            @(negedge txc_);                //     wait for a negedge on txc_
                                            // but if a stop bit was just sent
                                            //     do not wait
        serial_data=tdata_out;

        if (tstoptotal != 0)                // if async mode ...
        begin
           txd=0;                           //    then send a start bit 1st
           repeat(baudmx) @(negedge txc_);
        end

        repeat(databits)                    // send all start, data bits
        begin
            txd=serial_data[0];
            repeat(baudmx) @(negedge txc_);
            serial_data=serial_data>> 1;
        end

        if (modreg [4])                     // if parity is enabled ...
        begin
            parity_bit= ^ (tdata_out & data_mask);
            if(modreg[5]==0)parity_bit= ~parity_bit; // odd parity

            txd=parity_bit;
            repeat(baudmx) @(negedge txc_); //    then send the parity bit
        end

        if(tstoptotal != 0)                 // if sync mode
        begin
            txd=1;                          //    then send out the stop bit(s)
            repeat(tstoptotal) @(negedge txc_);
        end

        tdata_out_full=0;// block this routine until data/sync char to be sent
                         // is immediately transferred to tdata_out.

        ->txende;        // decide what data should be sent (data/sync/stop bit)
    end

    event transmit_held_data_e,
          transmitter_idle_e;

    always @txende                    // end of transmitted data/sync character
    begin :trans2

        case (command[0] & ~ cts_)
        0:                           // if it is not now cts
                                     //   but data was received while it was cts
        if (tdata_hold_full && tdata_hold_cts)
            -> transmit_held_data_e; // then send the data char
        else
            -> transmitter_idle_e;   // else send sync char(s) or 1 stop bit

        1:                           // if it is now cts
        if (tdata_hold_full)         //    if a character has been received
                                     //       but not yet transmitted ...
            -> transmit_held_data_e; //       then send the data char

        else                         //    else (no character has been received)
            -> transmitter_idle_e;   //       send sync char(s) or 1 stop bit
        endcase
    end


    always @transmitter_idle_e     // if there are no data chars to send ...
    begin :trans3
        status[2]=1;               //       mark transmitter as being empty
        txe=1;


        if (tstoptotal != 0 ||     //        if async mode or after a reset
          command[0]==0 || cts_==1)//           or TxEnable=false or cts_=false
        begin
            if(dflags[1])
                $display("I8251A (%h) at %d: transmitting data: 1 (stop bit)",
                                                           instance_id, $time);

            txd=1;                 //            then  send out 1 stop bit
            tdata_out=1;           //                  and make any writes
                                   //                  go to tdata_hold
            repeat(baudmx) @(negedge txc_);
            -> txende;
        end
        else                       //        if sync mode
        case (sync_to_transmit)
        1:                         //         ... send 1st sync char now
            begin
            tdata_out=sync1 >> (8-databits);
            tdata_out_wait=0;      //             without waiting on negedge txc
            tdata_out_full=1;
            if(modreg[7]==0)       //             if double sync mode
                sync_to_transmit=2;//                send 2nd sync after 1st
            end
        2:                         //         ... send 2nd sync char now
            begin
            tdata_out=sync2 >> (8-databits);
            tdata_out_wait=0;      //             without waiting on negedge txc
            tdata_out_full=1;
            sync_to_transmit=1;    //             send 1st sync char next
            end
        endcase
    end


    always @ transmit_held_data_e  //    if a character has been received
    begin :trans4
        tdata_out=tdata_hold;      //        but not transmitted ...
        tdata_out_wait=0;          //        then do not wait on negedge txc
        tdata_out_full=1;          //             and send the char immediately
        tdata_hold_full=0;
        repeat(`TTXRDY) @(posedge clk);
        status[0]=1;               //        and set the txrdy status bit
    end





     /******************** RECEIVER PORTION OF THE 8251A  ********************/

                             // data is received at leading edge of the clock

    event  break_detect_e,   //
           break_delay_e;    //

    event  hunt_sync1_e,     // hunt for the 1st sync char
           hunt_sync2_e,     // hunt for the 2nd sync char (double sync mode)
           sync_hunted_e,    // sync char(s) was found (on a bit aligned basis)
           external_syndet_watche;// external sync mode: whenever syndet pin
                                  // goes high, set the syndet status bit


    always @start_receiver_e
    begin :rcv_blk
        receive_in_progress=1;

        case(modreg[1:0])
        2'b00:
            if(modreg[6]==0)              // if internal syndet mode ...
            begin
                if(dflags[5])
                   $display("I8251A (%h) at %d: starting internal sync receiver",
                                                           instance_id, $time);

                if(dflags[5] && command[7])
                   $display("I8251A (%h) at %d: hunting for syncs",
                                                           instance_id, $time);

                if(modreg[7]==1)          //   if enter hunt mode
                begin
                    if(dflags[5])
                        $display("I8251A (%h) at %d: receiver waiting on syndet",
                                                           instance_id, $time);

                    -> hunt_sync1_e;      //      start search for sync char(s)
                                          //      & wait for syncs to be found
                    @(posedge syndet);

                    if(dflags[5])
                       $display("I8251A (%h) at %d: receiver DONE waiting on syndet",
                                                           instance_id, $time);
                end

                syn_receive_internal;     //   start sync mode receiver
            end
            else                          // if external syndet mode ...
            begin
                if(dflags[5])
                   $display("I8251A (%h) at %d: starting external sync receiver",
                                                           instance_id, $time);

                if(dflags[5] && command[7])
                   $display("I8251A (%h) at %d: hunting for syncs",
                                                           instance_id, $time);

                -> external_syndet_watche;//    whenever syndet pin goes to 1
                                          //        set syndet status bit

                if (command[7]==1)        //    if enter hunt mode
                begin :external_syn_hunt_blk
                   fork
                      syn_receive_external;//      assemble chars while waiting

                      @(posedge syndet)   //       after rising edge of syndet
                        @(negedge syndet) //       wait for falling edge
                                          //       before starting char assembly
                          disable external_syn_hunt_blk;
                    join
                end

            syn_receive_external;         //   start external sync mode receiver
            end

        default:                          // if async mode ...
            begin
                if(dflags[5])
                   $display("I8251A (%h) at %d: starting asynchronous receiver",
                                                           instance_id, $time);

                -> break_detect_e;        //     start check for rcd=0 too long
                asyn_receive;             //     and start async mode receiver
            end
        endcase
    end


                /**** EXTERNAL SYNCHRONOUS MODE RECEIVE ****/

    task syn_receive_external;
    forever
    begin
        repeat(databits)   // Whether in hunt mode or not, assemble a character
        begin
            @(posedge rxc_)
            receivebuf={rcd, receivebuf[7:1]};
        end

        get_and_check_parity;    // reveive and check parity bit, if any

        mark_char_received;      // set rxrdy line, if enabled
    end
    endtask

    always @external_syndet_watche
        @(posedge rxc_)
            status[6]=1;

                /**** INTERNAL SYNCHRONOUS MODE RECEIVE ****/


                /* Hunt for the sync char(s)                     */
                /* (if in synchronous internal sync detect mode) */
                /* Syndet is set high when the sync(s) are found */

    always @ hunt_sync1_e      // search for 1st sync char in the data stream
    begin :sync_hunt_blk
        while(!(((receivebuf ^ sync1) & syncmask)===8'b00000000))
        begin
            @(posedge rxc_)
            receivebuf={rcd, receivebuf[7:1]};
        end
        if(modreg[7]==0)       // if double sync mode
            -> hunt_sync2_e;   //     check for 2nd sync char directly after 1st
        else
            -> sync_hunted_e;  // if single sync mode, sync hunt is complete
    end

    always @ hunt_sync2_e // find the second synchronous character
    begin :double_sync_hunt_blk
        repeat(databits)
        begin
            @(posedge rxc_)
            receivebuf={rcd, receivebuf[7:1]};
        end
        if(((receivebuf ^ sync2) & syncmask)===8'b00000000)
            ->sync_hunted_e;   // if sync2 followed syn1, sync hunt is complete
        else
            ->hunt_sync1_e;    // else hunt for sync1 again

        // Note: the data stream [sync1 sync1 sync2] will have sync detected.
        // Suppose sync1=11001100:
        // then [1100 1100 1100 sync2] will NOT be detected.
        // In general: never let a suffix of sync1 also be a prefix of sync1.
    end

    always @ sync_hunted_e
    begin :parity_sync_hunt_blk
        get_and_check_parity;
        status[6]=1;            // set syndet status bit (sync chars detected)
    end

    task syn_receive_internal;
    forever
    begin
        repeat(databits)   // no longer in hunt mode so read entire chars and
        begin              // then look for syncs (instead of on bit boundaries)
            @(posedge rxc_)
            receivebuf={rcd, receivebuf[7:1]};
        end


        case (sync_to_receive)
        2:                                // if looking for 2nd sync char ...
        begin
            if(((receivebuf ^ sync2)
                         & syncmask)===0)
            begin                         // ... and 2nd sync char is found
                sync_to_receive=1;        //    then look for 1st sync (or data)
                status[6]=1;              //         and mark sync detected
            end
            else if(((receivebuf ^ sync1)
                         & syncmask)===0)
            begin                         // ... and 1st sync char is found
                sync_to_receive=2;        //    then look for 2nd sync char
            end
        end
        1:                                // but if looking for 1st or data ...
        begin
            if(((receivebuf ^ sync1)      // ... and 1st sync is found
                         & syncmask)===0)
            begin
                if(modreg[7]==0)          //     if double sync mode
                    sync_to_receive=2;    //         look for 2nd sync to follow
                else                      //     else look for 1st or data
                    status[6]=1;          //          and mark sync detected
            end
            else ;                        // ... and data was found, do nothing
        end
        endcase

        get_and_check_parity;    // reveive and check parity bit, if any

        mark_char_received;
    end
    endtask



    task get_and_check_parity;
    begin
        receivebuf=receivebuf >> (8-databits);
        if (modreg[4]==1)
        begin
            @(posedge rxc_)
            if((^receivebuf ^ modreg[5] ^ rcd) != 1)
                parity_error;
        end
    end
    endtask


    task mark_char_received;
    begin
        if (command[2]==1)       // if receiving is enabled
        begin
            rxrdy=1;
            status[1]=1;         //    set receive ready status bit
            if (rdatain==1)      //    if previous data was not read
                overrun_error;   //        overrun error

            rdata=receivebuf;    //    latch the data
            rdatain=1;           //    mark data as not having been read
        end

        if(dflags[2])
            $display("I8251A (%h) at %d: received data: %b",
                                               instance_id, $time, receivebuf);
    end
    endtask


          /************** ASYNCHRONOUS MODE RECEIVER **************/



                /* Check for break detection (rcd low through 2 */
                /* receive sequences) in the asynchronous mode. */

    always @ break_detect_e
    begin :break_detect_blk
        #1  /* to be sure break_delay_blk is waiting on break_deley_e
               after it triggered break_detect_e  */

        if(rcd==0)
        begin
            -> break_delay_e;//start + databits + parity    + stop bit
            breakcount_period =  1   + databits + modreg[4] + (tstoptotal != 0);

                    // the number of rxc periods needed for 2 receive sequences
            breakcount_period = 2 * breakcount_period * baudmx;

                                  // If rcd stays low through 2 consecutive
                                  // (start,data,parity,stop) sequences ...
            repeat(breakcount_period)
                @(posedge rxc_);
            status[6]=1;          // ... then set break detect (status[6]) high
        end
    end

    always @break_delay_e
    begin : break_delay_blk
        @(posedge rcd)            // but if rcd goes high during that time ...
        begin :break_delay_blk
            disable break_detect_blk;
            status[6]=0;          // ... then set the break detect low
            @(negedge rcd)        //     and when rcd goes low again ...
            -> break_detect_e;    //     ... start the break detection again
        end
    end


                /**** ASYNCHRONOUS MODE RECEIVE TASK ****/

    task asyn_receive;
    forever
        @(negedge rcd) // the receive line went to zero, maybe a start bit 
        begin
            rbaudcnt = baudmx / 2;
            if(baudmx==1)
                rbaudcnt=1;
            repeat(rbaudcnt) @(posedge rxc_); // after half a bit ...

            if (rcd == 0)                     // if it is still a start bit
            begin
                rbaudcnt=baudmx;
                repeat(databits)              //     receive the data bits
                begin
                    repeat(rbaudcnt) @(posedge rxc_);
                    #1 receivebuf= {rcd, receivebuf[7:1]};
                end

                repeat(rbaudcnt) @(posedge rxc_);


                // shift the data to the low part
                receivebuf=receivebuf >> (8-databits);

                if (modreg[4]==1)            // if parity is enabled
                begin
                    if((^receivebuf ^ modreg[5] ^ rcd) != 1)
                        parity_error;        //     check for a parity error

                    repeat(rbaudcnt) @(posedge rxc_);
                end

                #1 if (rcd==0)               // if middle of stop bit is 0
                    frame_error;             //     frame error (should be 1)

                mark_char_received;
            end
        end
    endtask
endmodule


FAQ Main  |  Part-1  |  Part-2 Part-3  |  What' New  |   Links    ]


Copyright Rajesh Bawankule  1997 - 2005