drivers/staging/bcm/Adapter.h

   1 /***********************************
   2 *       Adapter.h
   3 ************************************/
   4 #ifndef __ADAPTER_H__
   5 #define __ADAPTER_H__
   6
   7 #define MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES 256
   8 #include "Debug.h"
   9
  10 struct bcm_leader {
  11         USHORT  Vcid;
  12         USHORT  PLength;
  13         UCHAR   Status;
  14         UCHAR   Unused[3];
  15 } __packed;
  16
  17 struct bcm_packettosend {
  18         struct bcm_leader Leader;
  19         UCHAR   ucPayload;
  20 } __packed;
  21
  22 struct bcm_control_packet {
  23         PVOID   ControlBuff;
  24         UINT    ControlBuffLen;
  25         struct bcm_control_packet *next;
  26 } __packed;
  27
  28 struct bcm_link_request {
  29         struct bcm_leader Leader;
  30         UCHAR   szData[4];
  31 } __packed;
  32
  33 #define MAX_IP_RANGE_LENGTH 4
  34 #define MAX_PORT_RANGE 4
  35 #define MAX_PROTOCOL_LENGTH   32
  36 #define IPV6_ADDRESS_SIZEINBYTES 0x10
  37
  38 union u_ip_address {
  39         struct {
  40                 /* Source Ip Address Range */
  41                 ULONG ulIpv4Addr[MAX_IP_RANGE_LENGTH];
  42                  /* Source Ip Mask Address Range */
  43                 ULONG ulIpv4Mask[MAX_IP_RANGE_LENGTH];
  44         };
  45         struct {
  46                 /* Source Ip Address Range */
  47                 ULONG ulIpv6Addr[MAX_IP_RANGE_LENGTH * 4];
  48                 /* Source Ip Mask Address Range */
  49                 ULONG ulIpv6Mask[MAX_IP_RANGE_LENGTH * 4];
  50         };
  51         struct {
  52                 UCHAR ucIpv4Address[MAX_IP_RANGE_LENGTH * IP_LENGTH_OF_ADDRESS];
  53                 UCHAR ucIpv4Mask[MAX_IP_RANGE_LENGTH * IP_LENGTH_OF_ADDRESS];
  54         };
  55         struct {
  56                 UCHAR ucIpv6Address[MAX_IP_RANGE_LENGTH * IPV6_ADDRESS_SIZEINBYTES];
  57                 UCHAR ucIpv6Mask[MAX_IP_RANGE_LENGTH * IPV6_ADDRESS_SIZEINBYTES];
  58         };
  59 };
  60
  61 struct bcm_hdr_suppression_contextinfo {
  62         /* Intermediate buffer to accumulate pkt Header for PHS */
  63         UCHAR ucaHdrSuppressionInBuf[MAX_PHS_LENGTHS];
  64         /* Intermediate buffer containing pkt Header after PHS */
  65         UCHAR ucaHdrSuppressionOutBuf[MAX_PHS_LENGTHS + PHSI_LEN];
  66 };
  67
  68 struct bcm_classifier_rule {
  69         ULONG           ulSFID;
  70         UCHAR           ucReserved[2];
  71         B_UINT16        uiClassifierRuleIndex;
  72         bool            bUsed;
  73         USHORT          usVCID_Value;
  74         /* This field detemines the Classifier Priority */
  75         B_UINT8         u8ClassifierRulePriority;
  76         union u_ip_address      stSrcIpAddress;
  77         UCHAR           ucIPSourceAddressLength; /* Ip Source Address Length */
  78
  79         union u_ip_address      stDestIpAddress;
  80         /* Ip Destination Address Length */
  81         UCHAR           ucIPDestinationAddressLength;
  82         UCHAR           ucIPTypeOfServiceLength; /* Type of service Length */
  83         UCHAR           ucTosLow; /* Tos Low */
  84         UCHAR           ucTosHigh; /* Tos High */
  85         UCHAR           ucTosMask; /* Tos Mask */
  86
  87         UCHAR           ucProtocolLength; /* protocol Length */
  88         UCHAR           ucProtocol[MAX_PROTOCOL_LENGTH]; /* protocol Length */
  89         USHORT          usSrcPortRangeLo[MAX_PORT_RANGE];
  90         USHORT          usSrcPortRangeHi[MAX_PORT_RANGE];
  91         UCHAR           ucSrcPortRangeLength;
  92
  93         USHORT          usDestPortRangeLo[MAX_PORT_RANGE];
  94         USHORT          usDestPortRangeHi[MAX_PORT_RANGE];
  95         UCHAR           ucDestPortRangeLength;
  96
  97         bool            bProtocolValid;
  98         bool            bTOSValid;
  99         bool            bDestIpValid;
 100         bool            bSrcIpValid;
 101
 102         /* For IPv6 Addressing */
 103         UCHAR           ucDirection;
 104         bool            bIpv6Protocol;
 105         UINT32          u32PHSRuleID;
 106         struct bcm_phs_rule sPhsRule;
 107         UCHAR           u8AssociatedPHSI;
 108
 109         /* Classification fields for ETH CS */
 110         UCHAR           ucEthCSSrcMACLen;
 111         UCHAR           au8EThCSSrcMAC[MAC_ADDRESS_SIZE];
 112         UCHAR           au8EThCSSrcMACMask[MAC_ADDRESS_SIZE];
 113         UCHAR           ucEthCSDestMACLen;
 114         UCHAR           au8EThCSDestMAC[MAC_ADDRESS_SIZE];
 115         UCHAR           au8EThCSDestMACMask[MAC_ADDRESS_SIZE];
 116         UCHAR           ucEtherTypeLen;
 117         UCHAR           au8EthCSEtherType[NUM_ETHERTYPE_BYTES];
 118         UCHAR           usUserPriority[2];
 119         USHORT          usVLANID;
 120         USHORT          usValidityBitMap;
 121 };
 122
 123 struct bcm_fragmented_packet_info {
 124         bool                    bUsed;
 125         ULONG                   ulSrcIpAddress;
 126         USHORT                  usIpIdentification;
 127         struct bcm_classifier_rule *pstMatchedClassifierEntry;
 128         bool                    bOutOfOrderFragment;
 129 };
 130
 131 struct bcm_packet_info {
 132         /* classification extension Rule */
 133         ULONG           ulSFID;
 134         USHORT          usVCID_Value;
 135         UINT            uiThreshold;
 136         /* This field determines the priority of the SF Queues */
 137         B_UINT8         u8TrafficPriority;
 138
 139         bool            bValid;
 140         bool            bActive;
 141         bool            bActivateRequestSent;
 142
 143         B_UINT8         u8QueueType; /* BE or rtPS */
 144
 145         /* maximum size of the bucket for the queue */
 146         UINT            uiMaxBucketSize;
 147         UINT            uiCurrentQueueDepthOnTarget;
 148         UINT            uiCurrentBytesOnHost;
 149         UINT            uiCurrentPacketsOnHost;
 150         UINT            uiDroppedCountBytes;
 151         UINT            uiDroppedCountPackets;
 152         UINT            uiSentBytes;
 153         UINT            uiSentPackets;
 154         UINT            uiCurrentDrainRate;
 155         UINT            uiThisPeriodSentBytes;
 156         LARGE_INTEGER   liDrainCalculated;
 157         UINT            uiCurrentTokenCount;
 158         LARGE_INTEGER   liLastUpdateTokenAt;
 159         UINT            uiMaxAllowedRate;
 160         UINT            NumOfPacketsSent;
 161         UCHAR           ucDirection;
 162         USHORT          usCID;
 163         struct bcm_mibs_parameters stMibsExtServiceFlowTable;
 164         UINT            uiCurrentRxRate;
 165         UINT            uiThisPeriodRxBytes;
 166         UINT            uiTotalRxBytes;
 167         UINT            uiTotalTxBytes;
 168         UINT            uiPendedLast;
 169         UCHAR           ucIpVersion;
 170
 171         union {
 172                 struct {
 173                         struct sk_buff *FirstTxQueue;
 174                         struct sk_buff *LastTxQueue;
 175                 };
 176                 struct {
 177                         struct sk_buff *ControlHead;
 178                         struct sk_buff *ControlTail;
 179                 };
 180         };
 181
 182         bool            bProtocolValid;
 183         bool            bTOSValid;
 184         bool            bDestIpValid;
 185         bool            bSrcIpValid;
 186
 187         bool            bActiveSet;
 188         bool            bAdmittedSet;
 189         bool            bAuthorizedSet;
 190         bool            bClassifierPriority;
 191         UCHAR           ucServiceClassName[MAX_CLASS_NAME_LENGTH];
 192         bool            bHeaderSuppressionEnabled;
 193         spinlock_t      SFQueueLock;
 194         void            *pstSFIndication;
 195         struct timeval  stLastUpdateTokenAt;
 196         atomic_t        uiPerSFTxResourceCount;
 197         UINT            uiMaxLatency;
 198         UCHAR           bIPCSSupport;
 199         UCHAR           bEthCSSupport;
 200 };
 201
 202 struct bcm_tarang_data {
 203         struct bcm_tarang_data  *next;
 204         struct bcm_mini_adapter *Adapter;
 205         struct sk_buff          *RxAppControlHead;
 206         struct sk_buff          *RxAppControlTail;
 207         int                     AppCtrlQueueLen;
 208         bool                    MacTracingEnabled;
 209         bool                    bApplicationToExit;
 210         struct bcm_mibs_dropped_cntrl_msg stDroppedAppCntrlMsgs;
 211         ULONG                   RxCntrlMsgBitMask;
 212 };
 213
 214 struct bcm_targetdsx_buffer {
 215         ULONG           ulTargetDsxBuffer;
 216         B_UINT16        tid;
 217         bool            valid;
 218 };
 219
 220 typedef int (*FP_FLASH_WRITE)(struct bcm_mini_adapter *, UINT, PVOID);
 221
 222 typedef int (*FP_FLASH_WRITE_STATUS)(struct bcm_mini_adapter *, UINT, PVOID);
 223
 224 /*
 225  * Driver adapter data structure
 226  */
 227 struct bcm_mini_adapter {
 228         struct bcm_mini_adapter *next;
 229         struct net_device       *dev;
 230         u32                     msg_enable;
 231         CHAR                    *caDsxReqResp;
 232         atomic_t                ApplicationRunning;
 233         bool                    AppCtrlQueueOverFlow;
 234         atomic_t                CurrentApplicationCount;
 235         atomic_t                RegisteredApplicationCount;
 236         bool                    LinkUpStatus;
 237         bool                    TimerActive;
 238         u32                     StatisticsPointer;
 239         struct sk_buff          *RxControlHead;
 240         struct sk_buff          *RxControlTail;
 241         struct semaphore        RxAppControlQueuelock;
 242         struct semaphore        fw_download_sema;
 243         struct bcm_tarang_data  *pTarangs;
 244         spinlock_t              control_queue_lock;
 245         wait_queue_head_t       process_read_wait_queue;
 246
 247         /* the pointer to the first packet we have queued in send
 248          * deserialized miniport support variables
 249          */
 250         atomic_t                TotalPacketCount;
 251         atomic_t                TxPktAvail;
 252
 253         /* this to keep track of the Tx and Rx MailBox Registers. */
 254         atomic_t                CurrNumFreeTxDesc;
 255         /* to keep track the no of byte received */
 256         USHORT                  PrevNumRecvDescs;
 257         USHORT                  CurrNumRecvDescs;
 258         UINT                    u32TotalDSD;
 259         struct bcm_packet_info  PackInfo[NO_OF_QUEUES];
 260         struct bcm_classifier_rule astClassifierTable[MAX_CLASSIFIERS];
 261         bool                    TransferMode;
 262
 263         /*************** qos ******************/
 264         bool                    bETHCSEnabled;
 265         ULONG                   BEBucketSize;
 266         ULONG                   rtPSBucketSize;
 267         UCHAR                   LinkStatus;
 268         bool                    AutoLinkUp;
 269         bool                    AutoSyncup;
 270
 271         int                     major;
 272         int                     minor;
 273         wait_queue_head_t       tx_packet_wait_queue;
 274         wait_queue_head_t       process_rx_cntrlpkt;
 275         atomic_t                process_waiting;
 276         bool                    fw_download_done;
 277
 278         char                    *txctlpacket[MAX_CNTRL_PKTS];
 279         atomic_t                cntrlpktCnt;
 280         atomic_t                index_app_read_cntrlpkt;
 281         atomic_t                index_wr_txcntrlpkt;
 282         atomic_t                index_rd_txcntrlpkt;
 283         UINT                    index_datpkt;
 284         struct semaphore        rdmwrmsync;
 285
 286         struct bcm_targetdsx_buffer     astTargetDsxBuffer[MAX_TARGET_DSX_BUFFERS];
 287         ULONG                   ulFreeTargetBufferCnt;
 288         ULONG                   ulCurrentTargetBuffer;
 289         ULONG                   ulTotalTargetBuffersAvailable;
 290         unsigned long           chip_id;
 291         wait_queue_head_t       lowpower_mode_wait_queue;
 292         bool                    bFlashBoot;
 293         bool                    bBinDownloaded;
 294         bool                    bCfgDownloaded;
 295         bool                    bSyncUpRequestSent;
 296         USHORT                  usBestEffortQueueIndex;
 297         wait_queue_head_t       ioctl_fw_dnld_wait_queue;
 298         bool                    waiting_to_fw_download_done;
 299         pid_t                   fw_download_process_pid;
 300         struct bcm_target_params *pstargetparams;
 301         bool                    device_removed;
 302         bool                    DeviceAccess;
 303         bool                    bIsAutoCorrectEnabled;
 304         bool                    bDDRInitDone;
 305         int                     DDRSetting;
 306         ULONG                   ulPowerSaveMode;
 307         spinlock_t              txtransmitlock;
 308         B_UINT8                 txtransmit_running;
 309         /* Thread for control packet handling */
 310         struct task_struct      *control_packet_handler;
 311         /* thread for transmitting packets. */
 312         struct task_struct      *transmit_packet_thread;
 313
 314         /* LED Related Structures */
 315         struct bcm_led_info     LEDInfo;
 316
 317         /* Driver State for LED Blinking */
 318         enum bcm_led_events     DriverState;
 319         /* Interface Specific */
 320         PVOID                   pvInterfaceAdapter;
 321         int (*bcm_file_download)(PVOID,
 322                                 struct file *,
 323                                 unsigned int);
 324         int (*bcm_file_readback_from_chip)(PVOID,
 325                                         struct file *,
 326                                         unsigned int);
 327         int (*interface_rdm)(PVOID,
 328                         UINT,
 329                         PVOID,
 330                         int);
 331         int (*interface_wrm)(PVOID,
 332                         UINT,
 333                         PVOID,
 334                         int);
 335         int (*interface_transmit)(PVOID, PVOID , UINT);
 336         bool                    IdleMode;
 337         bool                    bDregRequestSentInIdleMode;
 338         bool                    bTriedToWakeUpFromlowPowerMode;
 339         bool                    bShutStatus;
 340         bool                    bWakeUpDevice;
 341         unsigned int            usIdleModePattern;
 342         /* BOOLEAN                      bTriedToWakeUpFromShutdown; */
 343         bool                    bLinkDownRequested;
 344         int                     downloadDDR;
 345         struct bcm_phs_extension stBCMPhsContext;
 346         struct bcm_hdr_suppression_contextinfo stPhsTxContextInfo;
 347         uint8_t                 ucaPHSPktRestoreBuf[2048];
 348         uint8_t                 bPHSEnabled;
 349         bool                    AutoFirmDld;
 350         bool                    bMipsConfig;
 351         bool                    bDPLLConfig;
 352         UINT32                  aTxPktSizeHist[MIBS_MAX_HIST_ENTRIES];
 353         UINT32                  aRxPktSizeHist[MIBS_MAX_HIST_ENTRIES];
 354         struct bcm_fragmented_packet_info
 355                 astFragmentedPktClassifierTable[MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES];
 356         atomic_t                uiMBupdate;
 357         UINT32                  PmuMode;
 358         enum bcm_nvm_type       eNVMType;
 359         UINT                    uiSectorSize;
 360         UINT                    uiSectorSizeInCFG;
 361         bool                    bSectorSizeOverride;
 362         bool                    bStatusWrite;
 363         UINT                    uiNVMDSDSize;
 364         UINT                    uiVendorExtnFlag;
 365         /* it will always represent chosen DSD at any point of time.
 366          * Generally it is Active DSD but in case of NVM RD/WR it
 367          * might be different.
 368          */
 369         UINT                    ulFlashCalStart;
 370         ULONG                   ulFlashControlSectionStart;
 371         ULONG                   ulFlashWriteSize;
 372         ULONG                   ulFlashID;
 373         FP_FLASH_WRITE          fpFlashWrite;
 374         FP_FLASH_WRITE_STATUS   fpFlashWriteWithStatusCheck;
 375
 376         struct semaphore        NVMRdmWrmLock;
 377         struct device           *pstCreatedClassDevice;
 378
 379         /*      BOOLEAN                         InterfaceUpStatus; */
 380         struct bcm_flash2x_cs_info *psFlash2xCSInfo;
 381         struct bcm_flash_cs_info *psFlashCSInfo;
 382         struct bcm_flash2x_vendor_info *psFlash2xVendorInfo;
 383         UINT                    uiFlashBaseAdd; /* Flash start address */
 384         /* Active ISO offset chosen before f/w download */
 385         UINT                    uiActiveISOOffset;
 386         enum bcm_flash2x_section_val eActiveISO; /* Active ISO section val */
 387         /* Active DSD val chosen before f/w download */
 388         enum bcm_flash2x_section_val eActiveDSD;
 389         /* For accessing Active DSD chosen before f/w download */
 390         UINT                    uiActiveDSDOffsetAtFwDld;
 391         UINT                    uiFlashLayoutMajorVersion;
 392         UINT                    uiFlashLayoutMinorVersion;
 393         bool                    bAllDSDWriteAllow;
 394         bool                    bSigCorrupted;
 395         /* this should be set who so ever want to change the Headers.
 396          * after Write it should be reset immediately.
 397          */
 398         bool                    bHeaderChangeAllowed;
 399         int                     SelectedChip;
 400         bool                    bEndPointHalted;
 401         /* while bFlashRawRead will be true, Driver
 402          * ignore map lay out and consider flash as of without any map.
 403          */
 404         bool                    bFlashRawRead;
 405         bool                    bPreparingForLowPowerMode;
 406         bool                    bDoSuspend;
 407         UINT                    syscfgBefFwDld;
 408         bool                    StopAllXaction;
 409         /* Used to Support extended CAPI requirements from */
 410         UINT32                  liTimeSinceLastNetEntry;
 411         struct semaphore        LowPowerModeSync;
 412         ULONG                   liDrainCalculated;
 413         UINT                    gpioBitMap;
 414         struct bcm_debug_state  stDebugState;
 415 };
 416
 417 #define GET_BCM_ADAPTER(net_dev) netdev_priv(net_dev)
 418
 419 struct bcm_eth_header {
 420         UCHAR   au8DestinationAddress[6];
 421         UCHAR   au8SourceAddress[6];
 422         USHORT  u16Etype;
 423 } __packed;
 424
 425 struct bcm_firmware_info {
 426         void    __user *pvMappedFirmwareAddress;
 427         ULONG   u32FirmwareLength;
 428         ULONG   u32StartingAddress;
 429 } __packed;
 430
 431 /* holds the value of net_device structure.. */
 432 extern struct net_device *gblpnetdev;
 433
 434 struct bcm_ddr_setting {
 435         UINT ulRegAddress;
 436         UINT ulRegValue;
 437 };
 438 int InitAdapter(struct bcm_mini_adapter *psAdapter);
 439
 440 /* =====================================================================
 441  * Beceem vendor request codes for EP0
 442  * =====================================================================
 443  */
 444
 445 #define BCM_REQUEST_READ        0x2
 446 #define BCM_REQUEST_WRITE       0x1
 447 #define EP2_MPS_REG             0x0F0110A0
 448 #define EP2_MPS                 0x40
 449
 450 #define EP2_CFG_REG     0x0F0110A8
 451 #define EP2_CFG_INT     0x27
 452 #define EP2_CFG_BULK    0x25
 453
 454 #define EP4_MPS_REG     0x0F0110F0
 455 #define EP4_MPS         0x8C
 456
 457 #define EP4_CFG_REG     0x0F0110F8
 458
 459 #define ISO_MPS_REG     0x0F0110C8
 460 #define ISO_MPS         0x00000000
 461
 462 #define EP1 0
 463 #define EP2 1
 464 #define EP3 2
 465 #define EP4 3
 466 #define EP5 4
 467 #define EP6 5
 468
 469 enum bcm_einterface_setting {
 470         DEFAULT_SETTING_0  = 0,
 471         ALTERNATE_SETTING_1 = 1,
 472 };
 473
 474 #endif  /* __ADAPTER_H__ */