addr_combo_fast.v

design compile synthesis user guide

//*************************************************************
// Addr_Combo block of RTL Analyzer (fast version with 
// repeated datapathlogic)
//*************************************************************
//
// Revision 1.1  1998/06/08  dannyb
// format
//*************************************************************

`timescale 1ns/10ps

module addr_combo ( BASE, INST_OFFSET, READ_OFFSET, WRITE_OFFSET, ADDR,
   READ_POINTER, WRITE_POINTER, ENABLE_SELECT, BUS_ENABLE, DOUT_SELECT,
   DOUT);
   input [19:0] BASE;
   input [15:0] INST_OFFSET;
   input [15:0] READ_OFFSET;
   input [15:0] WRITE_OFFSET;
   input [15:0] ADDR;
   input [7:0] WRITE_POINTER;
   input [7:0] READ_POINTER;
   input [2:0] ENABLE_SELECT;
   input BUS_ENABLE, DOUT_SELECT;
   output [31:0] DOUT;

   reg [31:0] ADDRESS;
   reg [31:0] TRANSFER_COUNT;
   wire [10:0] WORD_COUNT_read, WORD_COUNT_write;
   reg [7:0] POINTER;
   reg [3:0] LOW;
   // reg [31:0] DOUT;
   wire [31:0] DOUT;

  always @ (BASE or INST_OFFSET or READ_OFFSET or WRITE_OFFSET or 
            ENABLE_SELECT or LOW)
  begin: ADDR
   case (ENABLE_SELECT) 
     3'b001 : {LOW, ADDRESS[11:0]} = INST_OFFSET;
     3'b101 : {LOW, ADDRESS[11:0]} = WRITE_OFFSET;
     default : {LOW, ADDRESS[11:0]} = READ_OFFSET;
   endcase// ENABLE_SELECT
   ADDRESS [31:12] = BASE + LOW;
  end

  assign WORD_COUNT_read = datapath(READ_POINTER,ADDR);
  assign WORD_COUNT_write = datapath(WRITE_POINTER,ADDR);

  always @ (WORD_COUNT_read or WORD_COUNT_write or ENABLE_SELECT)
  begin
    TRANSFER_COUNT [31:16] = {16{1'b0}};
    case(ENABLE_SELECT) // synopsys parallel_case full_case
      3'b001 ||
      3'b010 ||
      3'b100 : TRANSFER_COUNT[15:0] = 16'b01;
      3'b111 : TRANSFER_COUNT[15:0] = {5'b0 , WORD_COUNT_write};
      default: TRANSFER_COUNT[15:0] = {5'b0 , WORD_COUNT_read};
    endcase //ENABLE_SELECT
  end

  assign DOUT = (BUS_ENABLE == 1'b0) ? {32{1'bz}}
                : (DOUT_SELECT == 1'b1) ? ADDRESS
                : TRANSFER_COUNT;

  function [10:0] datapath;

  input [7:0] POINTER;
  input [15:0] ADDR;

  reg [15:0] X;
  reg [10:0] A, 
             B;
  reg [7:0]  C;
  reg [15:0] D;
  integer i;

  begin
    X = {8'b0, (8'd128 - POINTER)};

    D = (ADDR - X); // D = ADDR - 'd128 + POINTER

    if (X >= ADDR)  // 'd128 - POINTER >= ADDR
      A = 11'b00000000000; // 'd0
    else // A = D[10:0]
      for (i = 10; i >= 0; i = i - 1)
        A[i] = D[i];

    if (X >= ADDR) // 'd128 - POINTER >= ADDR
      C = 8'b00000000; // C = 'd0
    else // C = D[7:0]
      for (i = 7; i >= 0; i = i - 1)
        C[i] = D[i];

    if ( ~C ) // C == 'b0
      B = 11'd1; // B = 'd1
    else 
      B = 11'd2; // B = 'd2

    datapath = (A + B) ; // WORD_COUNT = D[10:0] + (one or two)
  end
  endfunction //datapath


endmodule //addr_combo