usb_new_pck_usb.vhdl

实现USB接口功能的VHDL和verilog完整源代码

	return "00";
      when USB_LOG_J =>
	case SpeedType is
	  when USB_FULL_SPEED =>
	    return "10";
	  when USB_LOW_SPEED =>
	    return "01";
	end case; -- SpeedType
      when USB_LOG_K =>
	case SpeedType is
	  when USB_FULL_SPEED =>
	    return "01";
	  when USB_LOW_SPEED =>
	    return "10";
	end case; -- SpeedType
      when USB_LOG_SE1_OR_Z =>
	return "11";
    end case; -- UsbLogInput
  end UsbLog2Dif;

  function StartOfPacket (PrevLogVal: T_UsbLog_enum;
			  CurrLogVal: T_UsbLog_enum)
           return boolean is
  begin
    if ((PrevLogVal = USB_LOG_J) and (CurrLogVal = USB_LOG_K)) then
      return TRUE;
    else
      return FALSE;
    end if;
  end StartOfPacket;

  function EndOfPacket (CurrLogVal: T_UsbLog_enum)
	   return boolean is
  begin
    if (CurrLogVal = USB_LOG_SE0) then
      return TRUE;
    else
      return FALSE;
    end if;
  end EndOfPacket;

  function DecodeNRZI (PrevLogVal: T_UsbLog_enum;
		       CurrLogVal: T_UsbLog_enum)
	   return one_bit is
  begin
    if (((PrevLogVal = USB_LOG_J) and (CurrLogVal = USB_LOG_K)) or
        ((PrevLogVal = USB_LOG_K) and (CurrLogVal = USB_LOG_J))) then
      return LOW;
    elsif (((PrevLogVal = USB_LOG_J) and (CurrLogVal = USB_LOG_J)) or
	   ((PrevLogVal = USB_LOG_K) and (CurrLogVal = USB_LOG_K))) then
      return HIGH;
    else
      assert ((PrevLogVal = USB_LOG_SE0) or (CurrLogVal = USB_LOG_SE0))
	report "Invalid values in DecodeNRZI"
	severity note;
      return LOW;
    end if;
  end DecodeNRZI;

  function EncodeNRZI (PrevLogVal: T_UsbLog_enum;
		       CurrDataVal: one_bit)
	   return T_UsbLog_enum is
    variable Result: T_UsbLog_enum;
  begin
    -- By default we return the PrevLogVal
    Result := PrevLogVal;
    if ((PrevLogVal = USB_LOG_J) and (CurrDataVal = LOW)) then
      Result := USB_LOG_K;
    elsif ((PrevLogVal = USB_LOG_K) and (CurrDataVal = LOW)) then
      Result := USB_LOG_J;
    end if;
    return Result;
  end EncodeNRZI;

  function IncStuffedBitCnt (BitValue: one_bit)
           return boolean is
  begin
    if (BitValue = BITSTUFF_VALUE) then
      return TRUE;
    else
      return FALSE;
    end if;
  end IncStuffedBitCnt;

  function IsStuffedBit (BitValue:    one_bit;
			 BitStuffCnt: S_BitStuff_range)
	   return boolean is
  begin
    if ((BitStuffCnt = BITSTUFF_LENGTH) and
        (BitValue = (not BITSTUFF_VALUE))) then
      return TRUE;
    else
      return FALSE;
    end if;
  end IsStuffedBit;

  function IsBitStuffError (BitValue: one_bit;
			    BitStuffCnt: S_BitStuff_range)
           return boolean is
  begin
    if ((BitValue = BITSTUFF_VALUE) and
        (BitStuffCnt = BITSTUFF_LENGTH)) then
      return TRUE;
    else
      return FALSE;
    end if;
  end IsBitStuffError;

  procedure DeStuff (BitValue:        in one_bit;
		     BitStuffCnt:     in S_BitStuff_range;
		     BitStuffError:  out boolean;
		     StuffedBit:     out boolean;
		     NewBitStuffCnt: out S_BitStuff_range) is
  begin
    BitStuffError  := FALSE;
    StuffedBit     := FALSE;
    if (BitStuffCnt = BITSTUFF_LENGTH) then
      if (BitValue = BITSTUFF_VALUE) then
	-- sequence of BITSTUFF_VALUE too long
	BitStuffError  := TRUE;
	NewBitStuffCnt := BitStuffCnt; -- keep value at max
      else
	-- Stuffed bit found, reset count
	StuffedBit     := TRUE;
	NewBitStuffCnt := 0;
      end if;
    else
      if (BitValue = BITSTUFF_VALUE) then
	NewBitStuffCnt := BitStuffCnt + 1;
      else
	NewBitStuffCnt := 0;
      end if;
    end if;
  end DeStuff;

  -- Procedure Stuff will determine based on the current BitValue
  -- and the current number of bits with BITSTUFF_VALUE whether:
  --   a bitstuff error has to be forced
  --   whether this bit position should be stuffed
  --   and a new BitStuffCnt value
  procedure Stuff (BitValue:        in one_bit;
		   BitStuffCnt:     in S_BitStuff_range;
		   BitStuffError:   in boolean;
		   StuffedBit:     out boolean;
		   NewBitStuffCnt: out S_BitStuff_range) is
  begin
    StuffedBit := FALSE;
    if ((BitStuffCnt = BITSTUFF_LENGTH) or (BitStuffError)) then
      StuffedBit := TRUE;
      NewBitStuffCnt := 0;
    else
      if (BitValue = BITSTUFF_VALUE) then
	NewBitStuffCnt := BitStuffCnt + 1;
      else
	NewBitStuffCnt := 0;
      end if;
    end if;
  end Stuff;

-- File>>> Pid.fnc.vhd
--
-- Generated by: AccessVHDL
----
---- Copyright(c) 1995 by Easics NV. All rights reserved.
----
----   This source file is proprietary and confidential information
----   of Easics NV and may be used and disclosed only as authorized
----   in a consulting and/or subcontracting agreement where the
----   source code is part of the statement of work specified in
----   the agreement, or if Easics NV has given it's written consent
----   to such use or disclosure.
----   This source file remains the sole property of
----        Easics NV, Kapeldreef 60, B-3001 Leuven, Belgium.
----
-- Current user: Jan Zegers			08/95 tijdel. NO ITCL
-- Current date: Tue Aug 22 16:44:25 1995
--

  function GetPidInvVal (BusData: S_Pid_DATAWIDTH_bits)
           return S_Pid_InvVal_bits is
    variable Result: S_Pid_InvVal_bits;
  begin
    Result := BusData (S_Pid_InvVal_busrange);
    return Result;
  end GetPidInvVal;

  function PutPidInvVal (BusData: S_Pid_DATAWIDTH_bits;
                         InvVal: S_Pid_InvVal_bits)
           return S_Pid_DATAWIDTH_bits is
    variable Result: S_Pid_DATAWIDTH_bits;
  begin
    Result := BusData;
    Result (S_Pid_InvVal_busrange) := InvVal;
    return Result;
  end PutPidInvVal;

  function GetPidVal (BusData: S_Pid_DATAWIDTH_bits)
           return S_Pid_Val_bits is
    variable Result: S_Pid_Val_bits;
  begin
    Result := BusData (S_Pid_Val_busrange);
    return Result;
  end GetPidVal;

  function PutPidVal (BusData: S_Pid_DATAWIDTH_bits;
                      Val: S_Pid_Val_bits)
           return S_Pid_DATAWIDTH_bits is
    variable Result: S_Pid_DATAWIDTH_bits;
  begin
    Result := BusData;
    Result (S_Pid_Val_busrange) := Val;
    return Result;
  end PutPidVal;

-- End of Pid.fnc.vhd -------------------------------------------

  -- DecodePidVal returns PID_INVALID for undefined PIDs
  -- otherwise the correct enumerated value
  function DecodePidVal (Pid: S_Pid_Val_bits)
           return T_Pid_enum is
  begin
    case Pid is
      when "0000" =>
        return PID_INVALID;
      when "0001" =>
        return PID_OUT;
      when "0010" =>
        return PID_ACK;
      when "0011" =>
        return PID_DATA0;
      when "0100" =>
        return PID_INVALID; -- PID_RESERVED_1;
      when "0101" =>
        return PID_SOF;
      when "0110" =>
        return PID_INVALID; -- previous to 1.0 was return PID_ERR;
      when "0111" =>
        return PID_INVALID; -- PID_RESERVED_2;
      when "1000" =>
        return PID_INVALID; -- PID_RESERVED_3;
      when "1001" =>
        return PID_IN;
      when "1010" =>
        return PID_NAK;
      when "1011" =>
	return PID_DATA1;
      when "1100" =>
        return PID_PRE;
      when "1101" =>
        return PID_SETUP;
      when "1110" =>
        return PID_STALL;
      when "1111" =>
        return PID_INVALID; -- PID_RESERVED_4;
      when others =>
        return PID_INVALID;
    end case; -- Pid
  end DecodePidVal;

  -- Note that PID_ERR is still converted although in version 1.0
  -- it should be considered as invalid and undefined.
  function EncodePidVal (Pid: T_Pid_enum)
           return S_Pid_Val_bits is
  begin
    case Pid is
      when PID_INVALID =>
        return "0000";
      when PID_OUT =>
        return "0001";
      when PID_ACK =>
        return "0010";
      when PID_DATA0 =>
        return "0011";
      when PID_RESERVED_1 =>
        return "0100";
      when PID_SOF =>
        return "0101";
      when PID_ERR =>
        return "0110";
      when PID_RESERVED_2 =>
        return "0111";
      when PID_RESERVED_3 =>
        return "1000";
      when PID_IN =>
        return "1001";
      when PID_NAK =>
        return "1010";
      when PID_DATA1 =>
        return "1011";
      when PID_PRE =>
        return "1100";
      when PID_SETUP =>
        return "1101";
      when PID_STALL =>
        return "1110";
      when PID_RESERVED_4 =>
        return "1111";
    end case; -- Pid
  end EncodePidVal;

  function DecodePid (Pid: S_Pid_DATAWIDTH_bits)
           return T_Pid_enum is
    variable PidVal: S_Pid_Val_bits;
  begin
    PidVal := Pid(S_Pid_Val_busrange);
    return DecodePidVal(PidVal);
  end DecodePid;

  function EncodePid (Pid: T_Pid_enum)
           return S_Pid_DATAWIDTH_bits is
    variable Result: S_Pid_DATAWIDTH_bits;
    variable PidVal: S_Pid_Val_bits;
  begin
    Result := (others => '0');
    PidVal := EncodePidVal(Pid);
    Result(S_Pid_Val_busrange)    := PidVal;
    Result(S_Pid_InvVal_busrange) := (not PidVal);
    return Result;
  end EncodePid;

  function PidOk (Pid: S_Pid_DATAWIDTH_bits)
           return boolean is
    variable PidVal: S_Pid_Val_bits;
    variable PidInvVal: S_Pid_InvVal_bits;
  begin
    PidVal    := GetPidVal(Pid);
    PidInvVal := GetPidInvVal(Pid);
    if (PidVal = (not PidInvVal)) then
      return TRUE;
    else
      return FALSE;
    end if;
  end PidOk;

  procedure CheckPid (DataWord:   in S_UsbWord_bits;
		      PidType:   out T_Pid_enum;
		      Error:     out boolean;
		      ErrorType: out T_PACKET_ERROR_enum) is
    variable TmpPid: T_Pid_enum;
  begin
    if (PidOk(DataWord)) then
      TmpPid := DecodePid(DataWord);
      case TmpPid is
	when PID_INVALID | PID_RESERVED_1 | PID_RESERVED_2 |
	     PID_RESERVED_3 | PID_RESERVED_4 | PID_ERR =>
	  PidType   := PID_INVALID;
	  Error     := TRUE;
          ErrorType := ERROR_PID_UNKNOWN;
	when others =>
	  PidType  := TmpPid;
          Error    := FALSE;
      end case; -- PidType;
    else
      PidType   := PID_INVALID;
      Error     := TRUE;
      ErrorType := ERROR_PID_ENCODING;
    end if;
  end CheckPid;

  function IsValidPid (PidType: T_Pid_enum)
	   return boolean is
  begin
    case PidType is
      when PID_INVALID | PID_RESERVED_1 | PID_RESERVED_2 |
	   PID_RESERVED_3 | PID_RESERVED_4 | PID_ERR =>
        return FALSE;
      when others =>
	return TRUE;
    end case;
  end IsValidPid;

  function DecodePacket (PacketType: S_Packet_bits)
	   return T_Packet_enum is
  begin
    case PacketType is
      when "00" =>
	return PACKET_SPECIAL;
      when "01" =>
	return PACKET_TOKEN;
      when "10" =>
	return PACKET_HANDSHAKE;
      when "11" =>
	return PACKET_DATA;
      when others =>
	return PACKET_HANDSHAKE;
    end case; -- PacketType