| 1 | 6 | julius | //////////////////////////////////////////////////////////////////////
 | 
      
         | 2 |  |  | ////                                                              ////
 | 
      
         | 3 |  |  | ////  eth_rxstatem.v                                              ////
 | 
      
         | 4 |  |  | ////                                                              ////
 | 
      
         | 5 |  |  | ////  This file is part of the Ethernet IP core project           ////
 | 
      
         | 6 | 570 | olof | ////  http://www.opencores.org/project,ethmac                     ////
 | 
      
         | 7 | 6 | julius | ////                                                              ////
 | 
      
         | 8 |  |  | ////  Author(s):                                                  ////
 | 
      
         | 9 |  |  | ////      - Igor Mohor (igorM@opencores.org)                      ////
 | 
      
         | 10 |  |  | ////      - Novan Hartadi (novan@vlsi.itb.ac.id)                  ////
 | 
      
         | 11 |  |  | ////      - Mahmud Galela (mgalela@vlsi.itb.ac.id)                ////
 | 
      
         | 12 |  |  | ////                                                              ////
 | 
      
         | 13 |  |  | ////  All additional information is avaliable in the Readme.txt   ////
 | 
      
         | 14 |  |  | ////  file.                                                       ////
 | 
      
         | 15 |  |  | ////                                                              ////
 | 
      
         | 16 |  |  | //////////////////////////////////////////////////////////////////////
 | 
      
         | 17 |  |  | ////                                                              ////
 | 
      
         | 18 |  |  | //// Copyright (C) 2001 Authors                                   ////
 | 
      
         | 19 |  |  | ////                                                              ////
 | 
      
         | 20 |  |  | //// This source file may be used and distributed without         ////
 | 
      
         | 21 |  |  | //// restriction provided that this copyright statement is not    ////
 | 
      
         | 22 |  |  | //// removed from the file and that any derivative work contains  ////
 | 
      
         | 23 |  |  | //// the original copyright notice and the associated disclaimer. ////
 | 
      
         | 24 |  |  | ////                                                              ////
 | 
      
         | 25 |  |  | //// This source file is free software; you can redistribute it   ////
 | 
      
         | 26 |  |  | //// and/or modify it under the terms of the GNU Lesser General   ////
 | 
      
         | 27 |  |  | //// Public License as published by the Free Software Foundation; ////
 | 
      
         | 28 |  |  | //// either version 2.1 of the License, or (at your option) any   ////
 | 
      
         | 29 |  |  | //// later version.                                               ////
 | 
      
         | 30 |  |  | ////                                                              ////
 | 
      
         | 31 |  |  | //// This source is distributed in the hope that it will be       ////
 | 
      
         | 32 |  |  | //// useful, but WITHOUT ANY WARRANTY; without even the implied   ////
 | 
      
         | 33 |  |  | //// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR      ////
 | 
      
         | 34 |  |  | //// PURPOSE.  See the GNU Lesser General Public License for more ////
 | 
      
         | 35 |  |  | //// details.                                                     ////
 | 
      
         | 36 |  |  | ////                                                              ////
 | 
      
         | 37 |  |  | //// You should have received a copy of the GNU Lesser General    ////
 | 
      
         | 38 |  |  | //// Public License along with this source; if not, download it   ////
 | 
      
         | 39 |  |  | //// from http://www.opencores.org/lgpl.shtml                     ////
 | 
      
         | 40 |  |  | ////                                                              ////
 | 
      
         | 41 |  |  | //////////////////////////////////////////////////////////////////////
 | 
      
         | 42 |  |  | //
 | 
      
         | 43 |  |  | // CVS Revision History
 | 
      
         | 44 |  |  | //
 | 
      
         | 45 | 403 | julius | // $Log: not supported by cvs2svn $
 | 
      
         | 46 | 6 | julius | // Revision 1.5  2002/01/23 10:28:16  mohor
 | 
      
         | 47 |  |  | // Link in the header changed.
 | 
      
         | 48 |  |  | //
 | 
      
         | 49 |  |  | // Revision 1.4  2001/10/19 08:43:51  mohor
 | 
      
         | 50 |  |  | // eth_timescale.v changed to timescale.v This is done because of the
 | 
      
         | 51 |  |  | // simulation of the few cores in a one joined project.
 | 
      
         | 52 |  |  | //
 | 
      
         | 53 |  |  | // Revision 1.3  2001/10/18 12:07:11  mohor
 | 
      
         | 54 |  |  | // Status signals changed, Adress decoding changed, interrupt controller
 | 
      
         | 55 |  |  | // added.
 | 
      
         | 56 |  |  | //
 | 
      
         | 57 |  |  | // Revision 1.2  2001/09/11 14:17:00  mohor
 | 
      
         | 58 |  |  | // Few little NCSIM warnings fixed.
 | 
      
         | 59 |  |  | //
 | 
      
         | 60 |  |  | // Revision 1.1  2001/08/06 14:44:29  mohor
 | 
      
         | 61 |  |  | // A define FPGA added to select between Artisan RAM (for ASIC) and Block Ram (For Virtex).
 | 
      
         | 62 |  |  | // Include files fixed to contain no path.
 | 
      
         | 63 |  |  | // File names and module names changed ta have a eth_ prologue in the name.
 | 
      
         | 64 |  |  | // File eth_timescale.v is used to define timescale
 | 
      
         | 65 |  |  | // All pin names on the top module are changed to contain _I, _O or _OE at the end.
 | 
      
         | 66 |  |  | // Bidirectional signal MDIO is changed to three signals (Mdc_O, Mdi_I, Mdo_O
 | 
      
         | 67 |  |  | // and Mdo_OE. The bidirectional signal must be created on the top level. This
 | 
      
         | 68 |  |  | // is done due to the ASIC tools.
 | 
      
         | 69 |  |  | //
 | 
      
         | 70 |  |  | // Revision 1.1  2001/07/30 21:23:42  mohor
 | 
      
         | 71 |  |  | // Directory structure changed. Files checked and joind together.
 | 
      
         | 72 |  |  | //
 | 
      
         | 73 |  |  | // Revision 1.2  2001/07/03 12:55:41  mohor
 | 
      
         | 74 |  |  | // Minor changes because of the synthesys warnings.
 | 
      
         | 75 |  |  | //
 | 
      
         | 76 |  |  | //
 | 
      
         | 77 |  |  | // Revision 1.1  2001/06/27 21:26:19  mohor
 | 
      
         | 78 |  |  | // Initial release of the RxEthMAC module.
 | 
      
         | 79 |  |  | //
 | 
      
         | 80 |  |  | //
 | 
      
         | 81 |  |  | //
 | 
      
         | 82 |  |  | //
 | 
      
         | 83 |  |  |  
 | 
      
         | 84 |  |  |  
 | 
      
         | 85 |  |  | `include "timescale.v"
 | 
      
         | 86 |  |  |  
 | 
      
         | 87 |  |  |  
 | 
      
         | 88 |  |  | module eth_rxstatem (MRxClk, Reset, MRxDV, ByteCntEq0, ByteCntGreat2, Transmitting, MRxDEq5, MRxDEqD,
 | 
      
         | 89 |  |  |                      IFGCounterEq24, ByteCntMaxFrame, StateData, StateIdle, StatePreamble, StateSFD,
 | 
      
         | 90 |  |  |                      StateDrop
 | 
      
         | 91 |  |  |                     );
 | 
      
         | 92 |  |  |  
 | 
      
         | 93 |  |  | input         MRxClk;
 | 
      
         | 94 |  |  | input         Reset;
 | 
      
         | 95 |  |  | input         MRxDV;
 | 
      
         | 96 |  |  | input         ByteCntEq0;
 | 
      
         | 97 |  |  | input         ByteCntGreat2;
 | 
      
         | 98 |  |  | input         MRxDEq5;
 | 
      
         | 99 |  |  | input         Transmitting;
 | 
      
         | 100 |  |  | input         MRxDEqD;
 | 
      
         | 101 |  |  | input         IFGCounterEq24;
 | 
      
         | 102 |  |  | input         ByteCntMaxFrame;
 | 
      
         | 103 |  |  |  
 | 
      
         | 104 |  |  | output [1:0]  StateData;
 | 
      
         | 105 |  |  | output        StateIdle;
 | 
      
         | 106 |  |  | output        StateDrop;
 | 
      
         | 107 |  |  | output        StatePreamble;
 | 
      
         | 108 |  |  | output        StateSFD;
 | 
      
         | 109 |  |  |  
 | 
      
         | 110 |  |  | reg           StateData0;
 | 
      
         | 111 |  |  | reg           StateData1;
 | 
      
         | 112 |  |  | reg           StateIdle;
 | 
      
         | 113 |  |  | reg           StateDrop;
 | 
      
         | 114 |  |  | reg           StatePreamble;
 | 
      
         | 115 |  |  | reg           StateSFD;
 | 
      
         | 116 |  |  |  
 | 
      
         | 117 |  |  | wire          StartIdle;
 | 
      
         | 118 |  |  | wire          StartDrop;
 | 
      
         | 119 |  |  | wire          StartData0;
 | 
      
         | 120 |  |  | wire          StartData1;
 | 
      
         | 121 |  |  | wire          StartPreamble;
 | 
      
         | 122 |  |  | wire          StartSFD;
 | 
      
         | 123 |  |  |  
 | 
      
         | 124 |  |  |  
 | 
      
         | 125 |  |  | // Defining the next state
 | 
      
         | 126 |  |  | assign StartIdle = ~MRxDV & (StateDrop | StatePreamble | StateSFD | (|StateData));
 | 
      
         | 127 |  |  |  
 | 
      
         | 128 |  |  | assign StartPreamble = MRxDV & ~MRxDEq5 & (StateIdle & ~Transmitting);
 | 
      
         | 129 |  |  |  
 | 
      
         | 130 |  |  | assign StartSFD = MRxDV & MRxDEq5 & (StateIdle & ~Transmitting | StatePreamble);
 | 
      
         | 131 |  |  |  
 | 
      
         | 132 |  |  | assign StartData0 = MRxDV & (StateSFD & MRxDEqD & IFGCounterEq24 | StateData1);
 | 
      
         | 133 |  |  |  
 | 
      
         | 134 |  |  | assign StartData1 = MRxDV & StateData0 & (~ByteCntMaxFrame);
 | 
      
         | 135 |  |  |  
 | 
      
         | 136 | 439 | julius | assign StartDrop = MRxDV & (StateIdle & Transmitting | StateSFD & ~IFGCounterEq24 &
 | 
      
         | 137 |  |  |                             MRxDEqD |  StateData0 &  ByteCntMaxFrame);
 | 
      
         | 138 | 6 | julius |  
 | 
      
         | 139 |  |  | // Rx State Machine
 | 
      
         | 140 |  |  | always @ (posedge MRxClk or posedge Reset)
 | 
      
         | 141 |  |  | begin
 | 
      
         | 142 |  |  |   if(Reset)
 | 
      
         | 143 |  |  |     begin
 | 
      
         | 144 | 403 | julius |       StateIdle     <=  1'b0;
 | 
      
         | 145 |  |  |       StateDrop     <=  1'b1;
 | 
      
         | 146 |  |  |       StatePreamble <=  1'b0;
 | 
      
         | 147 |  |  |       StateSFD      <=  1'b0;
 | 
      
         | 148 |  |  |       StateData0    <=  1'b0;
 | 
      
         | 149 |  |  |       StateData1    <=  1'b0;
 | 
      
         | 150 | 6 | julius |     end
 | 
      
         | 151 |  |  |   else
 | 
      
         | 152 |  |  |     begin
 | 
      
         | 153 |  |  |       if(StartPreamble | StartSFD | StartDrop)
 | 
      
         | 154 | 403 | julius |         StateIdle <=  1'b0;
 | 
      
         | 155 | 6 | julius |       else
 | 
      
         | 156 |  |  |       if(StartIdle)
 | 
      
         | 157 | 403 | julius |         StateIdle <=  1'b1;
 | 
      
         | 158 | 6 | julius |  
 | 
      
         | 159 |  |  |       if(StartIdle)
 | 
      
         | 160 | 403 | julius |         StateDrop <=  1'b0;
 | 
      
         | 161 | 6 | julius |       else
 | 
      
         | 162 |  |  |       if(StartDrop)
 | 
      
         | 163 | 403 | julius |         StateDrop <=  1'b1;
 | 
      
         | 164 | 6 | julius |  
 | 
      
         | 165 |  |  |       if(StartSFD | StartIdle | StartDrop)
 | 
      
         | 166 | 403 | julius |         StatePreamble <=  1'b0;
 | 
      
         | 167 | 6 | julius |       else
 | 
      
         | 168 |  |  |       if(StartPreamble)
 | 
      
         | 169 | 403 | julius |         StatePreamble <=  1'b1;
 | 
      
         | 170 | 6 | julius |  
 | 
      
         | 171 |  |  |       if(StartPreamble | StartIdle | StartData0 | StartDrop)
 | 
      
         | 172 | 403 | julius |         StateSFD <=  1'b0;
 | 
      
         | 173 | 6 | julius |       else
 | 
      
         | 174 |  |  |       if(StartSFD)
 | 
      
         | 175 | 403 | julius |         StateSFD <=  1'b1;
 | 
      
         | 176 | 6 | julius |  
 | 
      
         | 177 |  |  |       if(StartIdle | StartData1 | StartDrop)
 | 
      
         | 178 | 403 | julius |         StateData0 <=  1'b0;
 | 
      
         | 179 | 6 | julius |       else
 | 
      
         | 180 |  |  |       if(StartData0)
 | 
      
         | 181 | 403 | julius |         StateData0 <=  1'b1;
 | 
      
         | 182 | 6 | julius |  
 | 
      
         | 183 |  |  |       if(StartIdle | StartData0 | StartDrop)
 | 
      
         | 184 | 403 | julius |         StateData1 <=  1'b0;
 | 
      
         | 185 | 6 | julius |       else
 | 
      
         | 186 |  |  |       if(StartData1)
 | 
      
         | 187 | 403 | julius |         StateData1 <=  1'b1;
 | 
      
         | 188 | 6 | julius |     end
 | 
      
         | 189 |  |  | end
 | 
      
         | 190 |  |  |  
 | 
      
         | 191 |  |  | assign StateData[1:0] = {StateData1, StateData0};
 | 
      
         | 192 |  |  |  
 | 
      
         | 193 |  |  | endmodule
 |