peephole.h

网络驱动开发

// structure of entry of ACR Lookup Table
//   1 word/entry,  512 entries
//
typedef struct     _TBATM155_ACR_LOOKUP_TBL
{
   union
   {
       struct
       {
           USHORT  Cell_Interval:10;
           USHORT  reserved1:6;
       };
       USHORT      data;
   }
        ACRLookupEntry;
}
   TBATM155_ACR_LOOKUP_TBL,
   *PTBATM155_ACR_LOOKUP_TBL;


//
// structure of entry of CBR Schedule Table
//   1 word/entry,  2-4K entries/table, 2 tables
//

typedef struct _TBATM155_CBR_SCHEDULE_ENTRY
{
   union
   {
       struct
       {
           USHORT  VC:12;
           USHORT  reserved1:2;
           USHORT  EOT:1;
           USHORT  Active:1;
       };
       USHORT      data;
   };
}
   TBATM155_CBR_SCHEDULE_ENTRY,
   *PTBATM155_CBR_SCHEDULE_ENTRY;


//
// structure of entry of ABR Value Table
//   4 words/entry,  1 entry/VC
//

typedef    struct  _TBATM155_ABR_VALUE_ENTRY
{
   union       // word 0
   {
       struct
       {
           USHORT  Acr:15;
           USHORT  reserved1:1;
       };
       USHORT      data;
   }
       AbrValueEntryWord0;

   union       // word 1
   {
       struct
       {
           USHORT  Fraction:9;
           USHORT  reserved1:2;
           USHORT  LastRmValid:1;
           USHORT  ForceFRM:1;
           USHORT  AbrValue:1;
           USHORT  FirstTrn:1;
           USHORT  reserved2:1;
       };
       USHORT      data;
   }
       AbrValueEntryWord1;

   union       // word 2
   {
       struct
       {
           USHORT  LastRM:16;
       };
       USHORT      data;
   }
       AbrValueEntryWord2;

   union       // word 3
   {
       struct
       {
           USHORT  NrmCnt:8;
           USHORT  CrmCnt:8;
       };
       USHORT      data;
   }
       AbrValueEntryWord3;
}
   TBATM155_ABR_VALUE_ENTRY,
   *PTBATM155_ABR_VALUE_ENTRY;

typedef    struct  _TBATM155_ABR_PARAM_ENTRY
{
   union       // word 0
   {
       struct
       {
           USHORT  reserved00:5;
           USHORT  Crmx:3;
           USHORT  RDFx:5;
           USHORT  CDFx:3;
           USHORT  reserved01:1;
       };
       USHORT      data;
   }
       AbrParamW0;

   union       // word 1
   {
       struct
       {
           USHORT  AIR:15;
           USHORT  reserved10:1;
       };
       USHORT      data;
   }
       AbrParamW1;

   union       // word 2
   {
       struct
       {
           USHORT  ICR:15;
           USHORT  reserved20:1;
       };
       USHORT      data;
   }
       AbrParamW2;

   union       // word 3
   {
       struct
       {
           USHORT  MCR:15;
           USHORT  reserved30:1;
       };
       USHORT      data;
   }
       AbrParamW3;

   union       // word 4
   {
       struct
       {
           USHORT  PeakCellRate:15;
           USHORT  reserved40:1;
       };
       USHORT      data;
   }
       AbrParamW4;

   union       // word 5
   {
       struct
       {
           USHORT  CI_VC:1;
           USHORT  reserved50:15;
       };
       USHORT      data;
   }
       AbrParamW5;

   union       // word 6
   {
       struct
       {
           USHORT  reserved60:16;
       };
       USHORT      data;
   }
       AbrParamW6;

   union       // word 7
   {
       struct
       {
           USHORT  reserved70:16;
       };
       USHORT      data;
   }
       AbrParamW7;
}
   TBATM155_ABR_PARAM_ENTRY,
   *PTBATM155_ABR_PARAM_ENTRY;


//
// Since Data access is by word in SRM, adjust the entry size of each table
//
#define SIZEOF_RX_FS_ENTRY         2
#define SIZEOF_TX_STATE_ENTRY      (sizeof(TBATM155_TX_STATE_ENTRY) / sizeof(USHORT))
#define SIZEOF_RX_STATE_ENTRY      (sizeof(TBATM155_RX_STATE_ENTRY) / sizeof(USHORT))
#define SIZEOF_TX_SLOT_DESC        (sizeof(TBATM155_TX_SLOT_DESC) / sizeof(USHORT))
#define SIZEOF_ACR_LOOKUP_TBL      (sizeof(TBATM155_ACR_LOOKUP_TBL) / sizeof(USHORT))
#define SIZEOF_CBR_SCHEDULE_ENTRY  (sizeof(TBATM155_CBR_SCHEDULE_ENTRY) / sizeof(USHORT))
#define SIZEOF_ABR_VALUE_ENTRY     (sizeof(TBATM155_ABR_VALUE_ENTRY) / sizeof(USHORT))
#define SIZEOF_ABR_PARAM_ENTRY     (sizeof(TBATM155_ABR_PARAM_ENTRY) / sizeof(USHORT))




//////////////////////////////////////////////////////////////////////////
//																		
//         Definitions of Peripheral Devices
//
//////////////////////////////////////////////////////////////////////////

//
// Address Mapping of Peripheral Devices
//
#define PCI_SUBSYSTEM_ID_OFFSET    0x00L
#define LED_OFFSET                 0x20L
#define MAC_ADDR_ROM_OFFSET        0x40L
#define PHY_DEVICE_OFFSET          0x80L


//
//   Define constants for on-board device LED controlled through
//   the peephole interface.
//
#define LED_TXRX_ON_GREEN      0x00000008L          // Tx/Rx data now.
#define LED_TXRX_ON_ORANGE     0x00000004L          // not use now.
#define LED_LNKUP_ON_GREEN     0x00000002L          // signal on cable is OK
#define LED_LNKUP_ON_ORANGE    0x00000001L          // losing signal on cable

#define LEDS_OFF_ALL           0xFFFFFFF0L
#define LED_TXRX_ALL_BITS      (LED_TXRX_ON_GREEN | LED_TXRX_ON_ORANGE)
#define LED_LNKUP_ALL_BITS     (LED_LNKUP_ON_GREEN | LED_LNKUP_ON_ORANGE)

//
// flags to indicate if Meteor is transmitting or receiving data.
//
#define fMETEOR_TX_DATA        0x00000100L
#define fMETEOR_RX_DATA        0x00000200L


//
// Defined constants for on-board serial EEPROM to be access through
// the peephole interface.
//
#define CHIP_SELECT            0x4
#define SERIAL_DATA_CLOCK      0x1
#define SERIAL_DATA_INPUT      0x2
#define SERIAL_DATA_OUTPUT     0x8


//
// Defined constants for 93C46 serial EEPROM.
// These are based on standard 93C46 serial EEPROM chip speciality.
//
#define RD_INSTRUCTION_93C46       0x6
#define WR_INSTRUCTION_93C46       0x5
#define RD_INSTRUCTION_LEN_93C46   0x3
#define WR_INSTRUCTION_LEN_93C46   0x3
#define ADDRESS_LENGTH1_93C46      0x7
#define ADDRESS_LENGTH2_93C46      0x6


extern USHORT AcrLookUpTbl[];


//////////////////////////////////////////////////////////////////////////
//																		
//                     Function Declarations
//
//////////////////////////////////////////////////////////////////////////


NDIS_STATUS
tbAtm155_Ph_Write_WORD(
	IN  PADAPTER_BLOCK		pAdapter,
   IN  ULONG               Dst_and_CntrlCmd,
   IN  USHORT              Data
   );


NDIS_STATUS
tbAtm155_Ph_Read_WORD(
	IN  PADAPTER_BLOCK		pAdapter,
   IN  ULONG               Dst_and_CntrlCmd,
   OUT PUSHORT             pData
   );


NDIS_STATUS
tbAtm155Read_PermanentAddress(
	IN  PADAPTER_BLOCK  pAdapter,
   OUT PUCHAR          pNodeaddress
   );



//////////////////////////////////////////////////////////////////////////
//																		
//      Macros of Access SRAM & devices through Peephole interface.
//
//////////////////////////////////////////////////////////////////////////

//
// macro for accessing SRAM through Peephole interface
//
#define TBATM155_PH_READ_SRAM(pAdapter, Dst, pData, pStatus)                   \
{                                                                              \
       *(pStatus) = tbAtm155_Ph_Read_WORD(                                     \
                       (pAdapter),                                             \
                       ((ULONG)((ULONG_PTR)Dst) | TBATM155_PH_READ_SRAM_CMD),  \
                       (PUSHORT) (pData));                                     \
                                                                               \
       if (NDIS_STATUS_SUCCESS != *(pStatus))                                  \
       {                                                                       \
           DBGPRINT(DBG_COMP_PEEPHOLE, DBG_LEVEL_ERR,                          \
               ("TBATM155_PH_READ_SRAM failed.\n"));                           \
       }                                                                       \
}

#define TBATM155_PH_WRITE_SRAM(pAdapter, Dst, Data, pStatus)                   \
{                                                                              \
       *(pStatus) = tbAtm155_Ph_Write_WORD(                                    \
                       (pAdapter),                                             \
                       ((ULONG)((ULONG_PTR)Dst) | TBATM155_PH_WRITE_SRAM_CMD), \
                       (USHORT) (Data));                                       \
                                                                               \
       if (NDIS_STATUS_SUCCESS != *(pStatus))                                  \
       {                                                                       \
           DBGPRINT(DBG_COMP_PEEPHOLE, DBG_LEVEL_ERR,                          \
               ("TBATM155_PH_WRITE_SRAM failed.\n"));                          \
       }                                                                       \
}


//
// Macros for accessing Devices through Peephole interface
//

#define TBATM155_PH_READ_DEV(pAdapter, Dst, pData, pStatus)                    \
{                                                                              \
       *(pStatus) = tbAtm155_Ph_Read_WORD(                                     \
                       (pAdapter),                                             \
                       ((ULONG)((ULONG_PTR)Dst) | TBATM155_PH_READ_DEV_CMD),   \
                       (PUSHORT) (pData));                                     \
       if (NDIS_STATUS_SUCCESS != *(pStatus))                                  \
       {                                                                       \
           DBGPRINT(DBG_COMP_PEEPHOLE, DBG_LEVEL_ERR,                          \
               ("TBATM155_PH_READ_DEV failed.\n"));                            \
       }                                                                       \
}

#define TBATM155_PH_WRITE_DEV(pAdapter, Dst, Data, pStatus)                    \
{                                                                              \
       *(pStatus) = tbAtm155_Ph_Write_WORD(                                    \
                       (pAdapter),                                             \
                       ((ULONG)((ULONG_PTR)Dst) | TBATM155_PH_WRITE_DEV_CMD),  \
                       (USHORT)(Data));                                        \
       if (NDIS_STATUS_SUCCESS != *(pStatus))                                  \
       {                                                                       \
           DBGPRINT(DBG_COMP_PEEPHOLE, DBG_LEVEL_ERR,                          \
               ("TBATM155_PH_WRITE_DEV failed.\n"));                           \
       }                                                                       \
}

#endif // __PEEPHOLE_H