| /*********************************** |
| * 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 { |
| ULONG ulIpv4Addr[MAX_IP_RANGE_LENGTH]; /* Source Ip Address Range */ |
| ULONG ulIpv4Mask[MAX_IP_RANGE_LENGTH]; /* Source Ip Mask Address Range */ |
| }; |
| struct { |
| ULONG ulIpv6Addr[MAX_IP_RANGE_LENGTH * 4]; /* Source Ip Address Range */ |
| ULONG ulIpv6Mask[MAX_IP_RANGE_LENGTH * 4]; /* Source Ip Mask Address Range */ |
| }; |
| 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 { |
| UCHAR ucaHdrSuppressionInBuf[MAX_PHS_LENGTHS]; /* Intermediate buffer to accumulate pkt Header for PHS */ |
| UCHAR ucaHdrSuppressionOutBuf[MAX_PHS_LENGTHS + PHSI_LEN]; /* Intermediate buffer containing pkt Header after PHS */ |
| }; |
| |
| struct bcm_classifier_rule { |
| ULONG ulSFID; |
| UCHAR ucReserved[2]; |
| B_UINT16 uiClassifierRuleIndex; |
| bool bUsed; |
| USHORT usVCID_Value; |
| B_UINT8 u8ClassifierRulePriority; /* This field detemines the Classifier Priority */ |
| union u_ip_address stSrcIpAddress; |
| UCHAR ucIPSourceAddressLength; /* Ip Source Address Length */ |
| |
| union u_ip_address stDestIpAddress; |
| UCHAR ucIPDestinationAddressLength; /* Ip Destination Address Length */ |
| 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 */ |
| |
| UINT uiMaxBucketSize; /* maximum size of the bucket for the queue */ |
| 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 */ |
| UINT uiActiveISOOffset; /* Active ISO offset chosen before f/w download */ |
| enum bcm_flash2x_section_val eActiveISO; /* Active ISO section val */ |
| enum bcm_flash2x_section_val eActiveDSD; /* Active DSD val chosen before f/w download */ |
| UINT uiActiveDSDOffsetAtFwDld; /* For accessing Active DSD chosen before f/w download */ |
| 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; |
| UINT32 liTimeSinceLastNetEntry; /* Used to Support extended CAPI requirements from */ |
| 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__ */ |
