daily pastebin goal
63%
SHARE
TWEET

Untitled

a guest Mar 24th, 2019 52 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /* verilator lint_off UNUSED */
  2. module MIPS32SOC (
  3.     input clk, // Clock signal
  4.     input resetIn,  // Reset signal
  5.     input [7:0] keypadIn,
  6.     output invalidOpcode,
  7.     output invalidPC,
  8.     output invalidAddr
  9. );
  10.  
  11.     `ifdef SYNTHESIS
  12.         assign reset = ~resetIn;
  13.         assign keypad = ~keypadIn;
  14.     `else
  15.         assign reset = resetIn;
  16.         assign keypad = keypadIn;
  17.     `endif
  18.    
  19.     wire [31:0] inst /*verilator public*/;
  20.     reg  [31:0] nextPC; // Should be 'reg' because it used in a always block
  21.     reg  [31:0] PC /*verilator public*/; // The PC (Program Counter) register
  22.     wire [31:0] pcPlus4;
  23.     wire [5:0] func;
  24.     wire [4:0] rd /*verilator public*/;
  25.     wire [4:0] rt /*verilator public*/;
  26.     wire [4:0] rs /*verilator public*/;
  27.     wire [4:0] sa;
  28.     wire [5:0] opcode;
  29.     wire [1:0] aluSrc;
  30.     wire aluSrc1;
  31.     wire rfWriteEnable; // Register File Write Enable
  32.     wire [1:0] rfWriteAddrSel; // Register File Write Address Select
  33.     wire [1:0] rfWriteDataSel; // Register File Write Data Select
  34.     reg [4:0] rfWriteAddr; // Register File Write Address
  35.     reg  [31:0] rfWriteData /*verilator public*/; // Register File Write Data
  36.     wire [31:0] rfData1 /*verilator public*/;
  37.     wire [31:0] rfData2 /*verilator public*/;
  38.     wire [31:0] imm32;
  39.     wire [15:0] imm16;
  40.     wire [7:0] memAddr;
  41.     wire memWrite;
  42.     wire memRead;
  43.     wire [31:0] memData;
  44.     wire [3:0] aluFunc /*verilator public*/;
  45.     wire [31:0] aluOperand1;
  46.     reg [31:0] aluOperand2;
  47.     wire [31:0] aluResult /*verilator public*/;
  48.     wire [31:0] branchTargetAddr;
  49.     wire [31:0] jmpTarget32;
  50.     wire isJmp /*verilator public*/;
  51.     wire isZero /*verilator public*/;
  52.     wire bitXtend;
  53.     // wire invalidOpcode /*verilator public*/;
  54.     // wire invalidPC /*verilator public*/;
  55.     // wire invalidAddr /*verilator public*/;
  56.     wire [10:0] physPC;
  57.     wire [31:0] physMemAdd;
  58.     wire isUsingMemory;
  59.     wire [2:0] memEnable;
  60.     wire [1:0] memoryBank;
  61.     wire [3:0] encMemoryWrite;
  62.     wire [1:0] memoryDataSize;
  63.     wire memoryBitExtend;
  64.     wire [31:0] memWriteData;
  65.     reg [31:0] readData /*verilator public*/;
  66.     wire [31:0] lui;
  67.     wire [31:0] vgaReadData;
  68.     wire [31:0] dataMemReadData;
  69.     wire [31:0] IOReadData;
  70.     wire [2:0] red;
  71.     wire [2:0] green;
  72.     wire [1:0] blue;
  73.     wire hsync;
  74.     wire vsync;
  75.     wire [31:0] decodedReadData;
  76.     wire [31:0] encodedWriteData;
  77.     wire [2:0] branchCU;
  78.     wire branchTaken;
  79.     wire jal;
  80.     wire jr;
  81.     wire fClk;
  82.     wire vClk;
  83.     wire sClk;
  84.     wire [31:0] mCounter /*verilator public*/;
  85.     reg [31:0] nextPC2;
  86.     wire [7:0] keypad;
  87.     wire reset;
  88.  
  89.     assign func = inst[5:0];
  90.     assign rd = inst[15:11];
  91.     assign rt = inst[20:16];
  92.     assign rs = inst[25:21];
  93.     assign sa = inst[10:6];
  94.     assign opcode = inst[31:26];
  95.     assign imm16 = inst[15:0];
  96.     assign memAddr = aluResult[9:2];
  97.     assign lui = {imm16, 16'd0};
  98.  
  99.     assign pcPlus4 = PC + 32'd4;
  100.     assign jmpTarget32 = {pcPlus4[31:28], inst[25:0], 2'b00};
  101.     assign branchTargetAddr = pcPlus4 + {imm32[29:0], 2'b00};
  102.  
  103.     //assign rfWriteAddr = rfWriteAddrSel? rd : rt; // MUX
  104.     //assign aluOperand2 = aluSrc? imm32 : rfData2; // MUX
  105.     //assign rfWriteData = rfWriteDataSel[0]? memData : aluResult; // MUX
  106.     assign aluOperand1 = aluSrc1 ? rfData2 : rfData1; //MUX
  107.  
  108.     //rfWirteAddr MUX
  109.     always @ (*) begin
  110.         case (rfWriteAddrSel)
  111.             2'b00:
  112.                 rfWriteAddr = rt;
  113.             2'b01:
  114.                 rfWriteAddr = rd;
  115.             2'b10:
  116.                 rfWriteAddr = 5'd31;
  117.             default:
  118.                 rfWriteAddr = 5'dx;
  119.         endcase
  120.     end
  121.  
  122.     //ALUOperand2 MUX
  123.     always @ (*) begin
  124.         case (aluSrc)
  125.             2'd0:
  126.                 aluOperand2 = rfData2;
  127.             2'd1:
  128.                 aluOperand2 = imm32;
  129.             2'd2:
  130.                 aluOperand2 = {27'd0, sa};
  131.             default:
  132.                 aluOperand2 = 32'd0;
  133.         endcase
  134.     end
  135.  
  136.     //rfWriteData MUX
  137.     always @ (*) begin
  138.         case (rfWriteDataSel)
  139.             2'b00:
  140.                 rfWriteData = aluResult;
  141.             2'b01:
  142.                 rfWriteData = decodedReadData;
  143.             2'b10:
  144.                 rfWriteData = lui;
  145.             2'b11:
  146.                 rfWriteData = pcPlus4;
  147.             default:
  148.                 rfWriteData = 32'd0;
  149.         endcase
  150.     end
  151.  
  152.     //memBank MUX
  153.     always @ (*) begin
  154.         case (memoryBank)
  155.             2'd0:
  156.                 readData = dataMemReadData;
  157.             2'd1:
  158.                 readData = vgaReadData;
  159.             2'd2:
  160.                 readData = IOReadData;
  161.             default:
  162.                 readData = 32'd0;
  163.         endcase
  164.     end
  165.  
  166.     //
  167.  
  168.     // Next PC value
  169.     always @ (*) begin
  170.         if(jr)
  171.             nextPC = rfData1;
  172.         else begin
  173.             if(isJmp || jal)
  174.                 nextPC = jmpTarget32;
  175.             else begin
  176.                 if(branchTaken)
  177.                     nextPC = branchTargetAddr;
  178.                 else begin
  179.                     if(invalidAddr)
  180.                         nextPC = nextPC;
  181.                     else
  182.                         nextPC = pcPlus4;
  183.                 end
  184.             end
  185.         end
  186.     end
  187.  
  188.     always @ (*) begin
  189.         if(reset)
  190.             nextPC2 = 32'h400000;
  191.         else
  192.             nextPC2 = nextPC;
  193.     end
  194.     // always @ (*) begin
  195.     //     if (isJmp)
  196.     //         nextPC = jmpTarget32;
  197.     //     else begin
  198.     //         if (branchTaken)
  199.     //             nextPC = branchTargetAddr;
  200.     //         else
  201.     //             if(invalidAddr)
  202.     //                 nextPC = nextPC;
  203.     //             else
  204.     //                 nextPC = pcPlus4;
  205.     //     end
  206.     // end
  207.  
  208.     // PC
  209.     always @ (posedge sClk) begin
  210.         if (reset)
  211.             PC <= 32'h400000;
  212.         else
  213.             PC <= nextPC;
  214.     end
  215.  
  216.     // Instruction Memory
  217.     // AsyncROM instMem (
  218.     //     .addr( physPC[9:0] ),
  219.     //     .en( 1'b1 ),
  220.     //     .dout( inst )
  221.     // );
  222.  
  223.     InstMem instMem(
  224.         .clk ( sClk ),
  225.         .en ( 1'b1 ),
  226.         .addr ( physPC ),
  227.         .rdata ( inst )
  228.     );
  229.  
  230.     // Data Memory
  231.     // RAMDualPort dataMem (
  232.     //     .A( physMemAdd ),
  233.     //     .D_in( rfData2 ),
  234.     //     .str( memWrite ),
  235.     //     .C( clk ),
  236.     //     .ld ( memRead ),
  237.     //     .D ( memData )
  238.     // );
  239.  
  240.     //Register File
  241.     RegisterFile regFile (
  242.         .ra1( rs ),
  243.         .ra2( rt ),
  244.         .wa( rfWriteAddr ),
  245.         .wd( rfWriteData ),
  246.         .we( rfWriteEnable ),
  247.         .clk( sClk ),
  248.         .rd1( rfData1 ),
  249.         .rd2( rfData2 )
  250.     );
  251.  
  252.   // ALU
  253.   ALU ALU_i11 (
  254.     .a( aluOperand1 ),
  255.     .b( aluOperand2 ),
  256.     .func( aluFunc ),
  257.     .res( aluResult ),
  258.     .isZero( isZero )
  259.   );
  260.  
  261.   // BitExtender
  262.   BitExtender BitExtender_i12 (
  263.     .x( bitXtend ),
  264.     .in( imm16 ),
  265.     .out( imm32 )
  266.   );
  267.  
  268.   // Control Unit
  269.   ControlUnit ControlUnit_i13 (
  270.     .opc( opcode ),
  271.     .func( func ),
  272.     .rt ( rt ),
  273.     .rst ( reset ),
  274.     .jmp( isJmp ),
  275.     .rfWriteDataSel( rfWriteDataSel ),
  276.     .rfWriteAddrSel( rfWriteAddrSel ),
  277.     .rfWriteEnable( rfWriteEnable ),
  278.     .memWrite( memWrite ),
  279.     .memRead( memRead ),
  280.     .aluSrc( aluSrc ),
  281.     .aluSrc1( aluSrc1 ),
  282.     .aluFunc( aluFunc ),
  283.     .bitXtend( bitXtend ),
  284.     .invOpcode( invalidOpcode ),
  285.     .isUsingMem ( isUsingMemory ),
  286.     .memDataSize( memoryDataSize ),
  287.     .memBitExt( memoryBitExtend ),
  288.     .branch ( branchCU ),
  289.     .jal ( jal ),
  290.     .jr ( jr )
  291.   );
  292.  
  293.   PCDecoder Pdecoder(
  294.       .virtualPC( nextPC2 ),
  295.       .physicalPC( physPC ),
  296.       .invalidPC( invalidPC )
  297.   );
  298.  
  299.   MemDecoder mDecoder(
  300.       .virtualAddress( aluResult ),
  301.       .memWrite( memWrite ),
  302.       .memRead( memRead ),
  303.       .memEn( memEnable ),
  304.       .memBank( memoryBank ),
  305.       .physicalAddress( physMemAdd ),
  306.       .invalidAddress ( invalidAddr )
  307.   );
  308.  
  309.     DataMem dataMem(
  310.         .clk( clk ),
  311.         .en( memEnable[0] ),
  312.         .memWrite( encMemoryWrite ),
  313.         .addr( physMemAdd[12:2] ),
  314.         .wdata( encodedWriteData ),
  315.         .rdata( dataMemReadData )
  316.     );
  317.  
  318.     MemReadDataDecoder memreaddatadecoder(
  319.         .inData( readData ),
  320.         .offset( physMemAdd[1:0] ),
  321.         .bitExt( memoryBitExtend ),
  322.         .dataSize( memoryDataSize ),
  323.         .outData( decodedReadData )
  324.     );
  325.  
  326.     MemWriteDataEncoder memwritedataencoder(
  327.         .inData( rfData2 ),
  328.         .offset( physMemAdd[1:0] ),
  329.         .memWrite( memWrite ),
  330.         .dataSize( memoryDataSize ),
  331.         .outData( encodedWriteData ),
  332.         .encMW( encMemoryWrite )
  333.     );
  334.  
  335.     VGATextCard vgaTextCard(
  336.         .vclk( vClk ),
  337.         .clk( fClk ),
  338.         .rst( reset ),
  339.         .en( memEnable[1] ),
  340.         .memWrite( encMemoryWrite ),
  341.         .addr( physMemAdd[12:2] ),
  342.         .wdata( encodedWriteData ),
  343.         .rdata( vgaReadData ),
  344.         .red( red ),
  345.         .green( green ),
  346.         .blue( blue ),
  347.         .hsync( hsync ),
  348.         .vsync( vsync )
  349.     );
  350.  
  351.     BranchResolver resolver(
  352.         .branch( branchCU ),
  353.         .zero ( isZero ),
  354.         .sign ( rfData1[31] ),
  355.         .branchTaken( branchTaken )
  356.     );
  357.  
  358.     ClockGenerator clkGen(
  359.         .clkIn( clk ),
  360.         .fastClk( fClk ),
  361.         .vgaClk( vClk ),
  362.         .slowClk( sClk )
  363.     );
  364.  
  365.     MillisCounter msCounter(
  366.         .clk ( clk ),
  367.         .reset ( reset ),
  368.         .counter ( mCounter )
  369.     );
  370.  
  371.     IOMem io(
  372.         .msCounter ( mCounter ),
  373.         .addr ( physMemAdd[12:2] ),
  374.         .keypad ( keypad ),
  375.         .en ( memEnable[2] ),
  376.         .o ( IOReadData )
  377.     );
  378.    
  379. endmodule
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top