475 lines
12 KiB
C
475 lines
12 KiB
C
/***********************************
|
|
* Adapter.h
|
|
************************************/
|
|
#ifndef __ADAPTER_H__
|
|
#define __ADAPTER_H__
|
|
|
|
#define MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES 256
|
|
#include "Debug.h"
|
|
|
|
struct bcm_leader {
|
|
USHORT Vcid;
|
|
USHORT PLength;
|
|
UCHAR Status;
|
|
UCHAR Unused[3];
|
|
} __packed;
|
|
|
|
struct bcm_packettosend {
|
|
struct bcm_leader Leader;
|
|
UCHAR ucPayload;
|
|
} __packed;
|
|
|
|
struct bcm_control_packet {
|
|
PVOID ControlBuff;
|
|
UINT ControlBuffLen;
|
|
struct bcm_control_packet *next;
|
|
} __packed;
|
|
|
|
struct bcm_link_request {
|
|
struct bcm_leader Leader;
|
|
UCHAR szData[4];
|
|
} __packed;
|
|
|
|
#define MAX_IP_RANGE_LENGTH 4
|
|
#define MAX_PORT_RANGE 4
|
|
#define MAX_PROTOCOL_LENGTH 32
|
|
#define IPV6_ADDRESS_SIZEINBYTES 0x10
|
|
|
|
union u_ip_address {
|
|
struct {
|
|
/* Source Ip Address Range */
|
|
ULONG ulIpv4Addr[MAX_IP_RANGE_LENGTH];
|
|
/* Source Ip Mask Address Range */
|
|
ULONG ulIpv4Mask[MAX_IP_RANGE_LENGTH];
|
|
};
|
|
struct {
|
|
/* Source Ip Address Range */
|
|
ULONG ulIpv6Addr[MAX_IP_RANGE_LENGTH * 4];
|
|
/* Source Ip Mask Address Range */
|
|
ULONG ulIpv6Mask[MAX_IP_RANGE_LENGTH * 4];
|
|
};
|
|
struct {
|
|
UCHAR ucIpv4Address[MAX_IP_RANGE_LENGTH * IP_LENGTH_OF_ADDRESS];
|
|
UCHAR ucIpv4Mask[MAX_IP_RANGE_LENGTH * IP_LENGTH_OF_ADDRESS];
|
|
};
|
|
struct {
|
|
UCHAR ucIpv6Address[MAX_IP_RANGE_LENGTH * IPV6_ADDRESS_SIZEINBYTES];
|
|
UCHAR ucIpv6Mask[MAX_IP_RANGE_LENGTH * IPV6_ADDRESS_SIZEINBYTES];
|
|
};
|
|
};
|
|
|
|
struct bcm_hdr_suppression_contextinfo {
|
|
/* Intermediate buffer to accumulate pkt Header for PHS */
|
|
UCHAR ucaHdrSuppressionInBuf[MAX_PHS_LENGTHS];
|
|
/* Intermediate buffer containing pkt Header after PHS */
|
|
UCHAR ucaHdrSuppressionOutBuf[MAX_PHS_LENGTHS + PHSI_LEN];
|
|
};
|
|
|
|
struct bcm_classifier_rule {
|
|
ULONG ulSFID;
|
|
UCHAR ucReserved[2];
|
|
B_UINT16 uiClassifierRuleIndex;
|
|
bool bUsed;
|
|
USHORT usVCID_Value;
|
|
/* This field detemines the Classifier Priority */
|
|
B_UINT8 u8ClassifierRulePriority;
|
|
union u_ip_address stSrcIpAddress;
|
|
UCHAR ucIPSourceAddressLength; /* Ip Source Address Length */
|
|
|
|
union u_ip_address stDestIpAddress;
|
|
/* Ip Destination Address Length */
|
|
UCHAR ucIPDestinationAddressLength;
|
|
UCHAR ucIPTypeOfServiceLength; /* Type of service Length */
|
|
UCHAR ucTosLow; /* Tos Low */
|
|
UCHAR ucTosHigh; /* Tos High */
|
|
UCHAR ucTosMask; /* Tos Mask */
|
|
|
|
UCHAR ucProtocolLength; /* protocol Length */
|
|
UCHAR ucProtocol[MAX_PROTOCOL_LENGTH]; /* protocol Length */
|
|
USHORT usSrcPortRangeLo[MAX_PORT_RANGE];
|
|
USHORT usSrcPortRangeHi[MAX_PORT_RANGE];
|
|
UCHAR ucSrcPortRangeLength;
|
|
|
|
USHORT usDestPortRangeLo[MAX_PORT_RANGE];
|
|
USHORT usDestPortRangeHi[MAX_PORT_RANGE];
|
|
UCHAR ucDestPortRangeLength;
|
|
|
|
bool bProtocolValid;
|
|
bool bTOSValid;
|
|
bool bDestIpValid;
|
|
bool bSrcIpValid;
|
|
|
|
/* For IPv6 Addressing */
|
|
UCHAR ucDirection;
|
|
bool bIpv6Protocol;
|
|
UINT32 u32PHSRuleID;
|
|
struct bcm_phs_rule sPhsRule;
|
|
UCHAR u8AssociatedPHSI;
|
|
|
|
/* Classification fields for ETH CS */
|
|
UCHAR ucEthCSSrcMACLen;
|
|
UCHAR au8EThCSSrcMAC[MAC_ADDRESS_SIZE];
|
|
UCHAR au8EThCSSrcMACMask[MAC_ADDRESS_SIZE];
|
|
UCHAR ucEthCSDestMACLen;
|
|
UCHAR au8EThCSDestMAC[MAC_ADDRESS_SIZE];
|
|
UCHAR au8EThCSDestMACMask[MAC_ADDRESS_SIZE];
|
|
UCHAR ucEtherTypeLen;
|
|
UCHAR au8EthCSEtherType[NUM_ETHERTYPE_BYTES];
|
|
UCHAR usUserPriority[2];
|
|
USHORT usVLANID;
|
|
USHORT usValidityBitMap;
|
|
};
|
|
|
|
struct bcm_fragmented_packet_info {
|
|
bool bUsed;
|
|
ULONG ulSrcIpAddress;
|
|
USHORT usIpIdentification;
|
|
struct bcm_classifier_rule *pstMatchedClassifierEntry;
|
|
bool bOutOfOrderFragment;
|
|
};
|
|
|
|
struct bcm_packet_info {
|
|
/* classification extension Rule */
|
|
ULONG ulSFID;
|
|
USHORT usVCID_Value;
|
|
UINT uiThreshold;
|
|
/* This field determines the priority of the SF Queues */
|
|
B_UINT8 u8TrafficPriority;
|
|
|
|
bool bValid;
|
|
bool bActive;
|
|
bool bActivateRequestSent;
|
|
|
|
B_UINT8 u8QueueType; /* BE or rtPS */
|
|
|
|
/* maximum size of the bucket for the queue */
|
|
UINT uiMaxBucketSize;
|
|
UINT uiCurrentQueueDepthOnTarget;
|
|
UINT uiCurrentBytesOnHost;
|
|
UINT uiCurrentPacketsOnHost;
|
|
UINT uiDroppedCountBytes;
|
|
UINT uiDroppedCountPackets;
|
|
UINT uiSentBytes;
|
|
UINT uiSentPackets;
|
|
UINT uiCurrentDrainRate;
|
|
UINT uiThisPeriodSentBytes;
|
|
LARGE_INTEGER liDrainCalculated;
|
|
UINT uiCurrentTokenCount;
|
|
LARGE_INTEGER liLastUpdateTokenAt;
|
|
UINT uiMaxAllowedRate;
|
|
UINT NumOfPacketsSent;
|
|
UCHAR ucDirection;
|
|
USHORT usCID;
|
|
struct bcm_mibs_parameters stMibsExtServiceFlowTable;
|
|
UINT uiCurrentRxRate;
|
|
UINT uiThisPeriodRxBytes;
|
|
UINT uiTotalRxBytes;
|
|
UINT uiTotalTxBytes;
|
|
UINT uiPendedLast;
|
|
UCHAR ucIpVersion;
|
|
|
|
union {
|
|
struct {
|
|
struct sk_buff *FirstTxQueue;
|
|
struct sk_buff *LastTxQueue;
|
|
};
|
|
struct {
|
|
struct sk_buff *ControlHead;
|
|
struct sk_buff *ControlTail;
|
|
};
|
|
};
|
|
|
|
bool bProtocolValid;
|
|
bool bTOSValid;
|
|
bool bDestIpValid;
|
|
bool bSrcIpValid;
|
|
|
|
bool bActiveSet;
|
|
bool bAdmittedSet;
|
|
bool bAuthorizedSet;
|
|
bool bClassifierPriority;
|
|
UCHAR ucServiceClassName[MAX_CLASS_NAME_LENGTH];
|
|
bool bHeaderSuppressionEnabled;
|
|
spinlock_t SFQueueLock;
|
|
void *pstSFIndication;
|
|
struct timeval stLastUpdateTokenAt;
|
|
atomic_t uiPerSFTxResourceCount;
|
|
UINT uiMaxLatency;
|
|
UCHAR bIPCSSupport;
|
|
UCHAR bEthCSSupport;
|
|
};
|
|
|
|
struct bcm_tarang_data {
|
|
struct bcm_tarang_data *next;
|
|
struct bcm_mini_adapter *Adapter;
|
|
struct sk_buff *RxAppControlHead;
|
|
struct sk_buff *RxAppControlTail;
|
|
int AppCtrlQueueLen;
|
|
bool MacTracingEnabled;
|
|
bool bApplicationToExit;
|
|
struct bcm_mibs_dropped_cntrl_msg stDroppedAppCntrlMsgs;
|
|
ULONG RxCntrlMsgBitMask;
|
|
};
|
|
|
|
struct bcm_targetdsx_buffer {
|
|
ULONG ulTargetDsxBuffer;
|
|
B_UINT16 tid;
|
|
bool valid;
|
|
};
|
|
|
|
typedef int (*FP_FLASH_WRITE)(struct bcm_mini_adapter *, UINT, PVOID);
|
|
|
|
typedef int (*FP_FLASH_WRITE_STATUS)(struct bcm_mini_adapter *, UINT, PVOID);
|
|
|
|
/*
|
|
* Driver adapter data structure
|
|
*/
|
|
struct bcm_mini_adapter {
|
|
struct bcm_mini_adapter *next;
|
|
struct net_device *dev;
|
|
u32 msg_enable;
|
|
CHAR *caDsxReqResp;
|
|
atomic_t ApplicationRunning;
|
|
bool AppCtrlQueueOverFlow;
|
|
atomic_t CurrentApplicationCount;
|
|
atomic_t RegisteredApplicationCount;
|
|
bool LinkUpStatus;
|
|
bool TimerActive;
|
|
u32 StatisticsPointer;
|
|
struct sk_buff *RxControlHead;
|
|
struct sk_buff *RxControlTail;
|
|
struct semaphore RxAppControlQueuelock;
|
|
struct semaphore fw_download_sema;
|
|
struct bcm_tarang_data *pTarangs;
|
|
spinlock_t control_queue_lock;
|
|
wait_queue_head_t process_read_wait_queue;
|
|
|
|
/* the pointer to the first packet we have queued in send
|
|
* deserialized miniport support variables
|
|
*/
|
|
atomic_t TotalPacketCount;
|
|
atomic_t TxPktAvail;
|
|
|
|
/* this to keep track of the Tx and Rx MailBox Registers. */
|
|
atomic_t CurrNumFreeTxDesc;
|
|
/* to keep track the no of byte received */
|
|
USHORT PrevNumRecvDescs;
|
|
USHORT CurrNumRecvDescs;
|
|
UINT u32TotalDSD;
|
|
struct bcm_packet_info PackInfo[NO_OF_QUEUES];
|
|
struct bcm_classifier_rule astClassifierTable[MAX_CLASSIFIERS];
|
|
bool TransferMode;
|
|
|
|
/*************** qos ******************/
|
|
bool bETHCSEnabled;
|
|
ULONG BEBucketSize;
|
|
ULONG rtPSBucketSize;
|
|
UCHAR LinkStatus;
|
|
bool AutoLinkUp;
|
|
bool AutoSyncup;
|
|
|
|
int major;
|
|
int minor;
|
|
wait_queue_head_t tx_packet_wait_queue;
|
|
wait_queue_head_t process_rx_cntrlpkt;
|
|
atomic_t process_waiting;
|
|
bool fw_download_done;
|
|
|
|
char *txctlpacket[MAX_CNTRL_PKTS];
|
|
atomic_t cntrlpktCnt;
|
|
atomic_t index_app_read_cntrlpkt;
|
|
atomic_t index_wr_txcntrlpkt;
|
|
atomic_t index_rd_txcntrlpkt;
|
|
UINT index_datpkt;
|
|
struct semaphore rdmwrmsync;
|
|
|
|
struct bcm_targetdsx_buffer astTargetDsxBuffer[MAX_TARGET_DSX_BUFFERS];
|
|
ULONG ulFreeTargetBufferCnt;
|
|
ULONG ulCurrentTargetBuffer;
|
|
ULONG ulTotalTargetBuffersAvailable;
|
|
unsigned long chip_id;
|
|
wait_queue_head_t lowpower_mode_wait_queue;
|
|
bool bFlashBoot;
|
|
bool bBinDownloaded;
|
|
bool bCfgDownloaded;
|
|
bool bSyncUpRequestSent;
|
|
USHORT usBestEffortQueueIndex;
|
|
wait_queue_head_t ioctl_fw_dnld_wait_queue;
|
|
bool waiting_to_fw_download_done;
|
|
pid_t fw_download_process_pid;
|
|
struct bcm_target_params *pstargetparams;
|
|
bool device_removed;
|
|
bool DeviceAccess;
|
|
bool bIsAutoCorrectEnabled;
|
|
bool bDDRInitDone;
|
|
int DDRSetting;
|
|
ULONG ulPowerSaveMode;
|
|
spinlock_t txtransmitlock;
|
|
B_UINT8 txtransmit_running;
|
|
/* Thread for control packet handling */
|
|
struct task_struct *control_packet_handler;
|
|
/* thread for transmitting packets. */
|
|
struct task_struct *transmit_packet_thread;
|
|
|
|
/* LED Related Structures */
|
|
struct bcm_led_info LEDInfo;
|
|
|
|
/* Driver State for LED Blinking */
|
|
enum bcm_led_events DriverState;
|
|
/* Interface Specific */
|
|
PVOID pvInterfaceAdapter;
|
|
int (*bcm_file_download)(PVOID,
|
|
struct file *,
|
|
unsigned int);
|
|
int (*bcm_file_readback_from_chip)(PVOID,
|
|
struct file *,
|
|
unsigned int);
|
|
int (*interface_rdm)(PVOID,
|
|
UINT,
|
|
PVOID,
|
|
int);
|
|
int (*interface_wrm)(PVOID,
|
|
UINT,
|
|
PVOID,
|
|
int);
|
|
int (*interface_transmit)(PVOID, PVOID , UINT);
|
|
bool IdleMode;
|
|
bool bDregRequestSentInIdleMode;
|
|
bool bTriedToWakeUpFromlowPowerMode;
|
|
bool bShutStatus;
|
|
bool bWakeUpDevice;
|
|
unsigned int usIdleModePattern;
|
|
/* BOOLEAN bTriedToWakeUpFromShutdown; */
|
|
bool bLinkDownRequested;
|
|
int downloadDDR;
|
|
struct bcm_phs_extension stBCMPhsContext;
|
|
struct bcm_hdr_suppression_contextinfo stPhsTxContextInfo;
|
|
uint8_t ucaPHSPktRestoreBuf[2048];
|
|
uint8_t bPHSEnabled;
|
|
bool AutoFirmDld;
|
|
bool bMipsConfig;
|
|
bool bDPLLConfig;
|
|
UINT32 aTxPktSizeHist[MIBS_MAX_HIST_ENTRIES];
|
|
UINT32 aRxPktSizeHist[MIBS_MAX_HIST_ENTRIES];
|
|
struct bcm_fragmented_packet_info
|
|
astFragmentedPktClassifierTable[MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES];
|
|
atomic_t uiMBupdate;
|
|
UINT32 PmuMode;
|
|
enum bcm_nvm_type eNVMType;
|
|
UINT uiSectorSize;
|
|
UINT uiSectorSizeInCFG;
|
|
bool bSectorSizeOverride;
|
|
bool bStatusWrite;
|
|
UINT uiNVMDSDSize;
|
|
UINT uiVendorExtnFlag;
|
|
/* it will always represent chosen DSD at any point of time.
|
|
* Generally it is Active DSD but in case of NVM RD/WR it
|
|
* might be different.
|
|
*/
|
|
UINT ulFlashCalStart;
|
|
ULONG ulFlashControlSectionStart;
|
|
ULONG ulFlashWriteSize;
|
|
ULONG ulFlashID;
|
|
FP_FLASH_WRITE fpFlashWrite;
|
|
FP_FLASH_WRITE_STATUS fpFlashWriteWithStatusCheck;
|
|
|
|
struct semaphore NVMRdmWrmLock;
|
|
struct device *pstCreatedClassDevice;
|
|
|
|
/* BOOLEAN InterfaceUpStatus; */
|
|
struct bcm_flash2x_cs_info *psFlash2xCSInfo;
|
|
struct bcm_flash_cs_info *psFlashCSInfo;
|
|
struct bcm_flash2x_vendor_info *psFlash2xVendorInfo;
|
|
UINT uiFlashBaseAdd; /* Flash start address */
|
|
/* Active ISO offset chosen before f/w download */
|
|
UINT uiActiveISOOffset;
|
|
enum bcm_flash2x_section_val eActiveISO; /* Active ISO section val */
|
|
/* Active DSD val chosen before f/w download */
|
|
enum bcm_flash2x_section_val eActiveDSD;
|
|
/* For accessing Active DSD chosen before f/w download */
|
|
UINT uiActiveDSDOffsetAtFwDld;
|
|
UINT uiFlashLayoutMajorVersion;
|
|
UINT uiFlashLayoutMinorVersion;
|
|
bool bAllDSDWriteAllow;
|
|
bool bSigCorrupted;
|
|
/* this should be set who so ever want to change the Headers.
|
|
* after Write it should be reset immediately.
|
|
*/
|
|
bool bHeaderChangeAllowed;
|
|
int SelectedChip;
|
|
bool bEndPointHalted;
|
|
/* while bFlashRawRead will be true, Driver
|
|
* ignore map lay out and consider flash as of without any map.
|
|
*/
|
|
bool bFlashRawRead;
|
|
bool bPreparingForLowPowerMode;
|
|
bool bDoSuspend;
|
|
UINT syscfgBefFwDld;
|
|
bool StopAllXaction;
|
|
/* Used to Support extended CAPI requirements from */
|
|
UINT32 liTimeSinceLastNetEntry;
|
|
struct semaphore LowPowerModeSync;
|
|
ULONG liDrainCalculated;
|
|
UINT gpioBitMap;
|
|
struct bcm_debug_state stDebugState;
|
|
};
|
|
|
|
#define GET_BCM_ADAPTER(net_dev) netdev_priv(net_dev)
|
|
|
|
struct bcm_eth_header {
|
|
UCHAR au8DestinationAddress[6];
|
|
UCHAR au8SourceAddress[6];
|
|
USHORT u16Etype;
|
|
} __packed;
|
|
|
|
struct bcm_firmware_info {
|
|
void __user *pvMappedFirmwareAddress;
|
|
ULONG u32FirmwareLength;
|
|
ULONG u32StartingAddress;
|
|
} __packed;
|
|
|
|
/* holds the value of net_device structure.. */
|
|
extern struct net_device *gblpnetdev;
|
|
|
|
struct bcm_ddr_setting {
|
|
UINT ulRegAddress;
|
|
UINT ulRegValue;
|
|
};
|
|
int InitAdapter(struct bcm_mini_adapter *psAdapter);
|
|
|
|
/* =====================================================================
|
|
* Beceem vendor request codes for EP0
|
|
* =====================================================================
|
|
*/
|
|
|
|
#define BCM_REQUEST_READ 0x2
|
|
#define BCM_REQUEST_WRITE 0x1
|
|
#define EP2_MPS_REG 0x0F0110A0
|
|
#define EP2_MPS 0x40
|
|
|
|
#define EP2_CFG_REG 0x0F0110A8
|
|
#define EP2_CFG_INT 0x27
|
|
#define EP2_CFG_BULK 0x25
|
|
|
|
#define EP4_MPS_REG 0x0F0110F0
|
|
#define EP4_MPS 0x8C
|
|
|
|
#define EP4_CFG_REG 0x0F0110F8
|
|
|
|
#define ISO_MPS_REG 0x0F0110C8
|
|
#define ISO_MPS 0x00000000
|
|
|
|
#define EP1 0
|
|
#define EP2 1
|
|
#define EP3 2
|
|
#define EP4 3
|
|
#define EP5 4
|
|
#define EP6 5
|
|
|
|
enum bcm_einterface_setting {
|
|
DEFAULT_SETTING_0 = 0,
|
|
ALTERNATE_SETTING_1 = 1,
|
|
};
|
|
|
|
#endif /* __ADAPTER_H__ */
|