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 typedef struct _LIST_ENTRY{
  11         struct _LIST_ENTRY      *next;
  12         struct _LIST_ENTRY      *prev;
  13 } LIST_ENTRY, *PLIST_ENTRY;
  14
  15 typedef struct _BCM_LIST_ENTRY {
  16
  17     LIST_ENTRY                  Link;
  18
  19 } BCM_LIST_ENTRY, *PBCM_LIST_ENTRY;
  20
  21 typedef enum _RCB_STATUS
  22 {
  23         DRIVER_PROCESSED=1,
  24         APPLICATION_PROCESSED
  25 } RCB_STATUS, *PRCB_STATUS;
  26
  27 #define fFILLED 1
  28 #define fEMPTY 0
  29
  30 struct _BCM_CB
  31 {
  32         // The network packet that this RCB is receiving
  33         PVOID                           pv_packet;
  34         // Describes the length of the packet .
  35         UINT                ui_packet_length;
  36         // Pointer to the first buffer in the packet (only one buffer for Rx)
  37         PUCHAR                          buffer;
  38         atomic_t                status;
  39         UINT                filled;
  40 } __attribute__((packed));
  41 typedef struct _BCM_CB BCM_CB,*PBCM_CB;
  42
  43 typedef BCM_CB BCM_RCB, *PBCM_RCB;
  44 typedef BCM_CB BCM_TCB, *PBCM_TCB;
  45
  46 struct _LEADER
  47 {
  48         USHORT  Vcid;
  49         USHORT  PLength;
  50         UCHAR   Status;
  51         UCHAR   Unused[3];
  52 }__attribute__((packed));
  53 typedef struct _LEADER LEADER,*PLEADER;
  54
  55 struct _PACKETTOSEND
  56 {
  57         LEADER  Leader;
  58         UCHAR   ucPayload;
  59 }__attribute__((packed));
  60 typedef struct _PACKETTOSEND PACKETTOSEND, *PPACKETTOSEND;
  61
  62
  63 struct _CONTROL_PACKET
  64 {
  65         PVOID   ControlBuff;
  66         UINT    ControlBuffLen;
  67         struct _CONTROL_PACKET* next;
  68 }__attribute__((packed));
  69 typedef struct _CONTROL_PACKET CONTROL_PACKET,*PCONTROL_PACKET;
  70
  71
  72 struct link_request
  73 {
  74         LEADER  Leader;
  75         UCHAR   szData[4];
  76 }__attribute__((packed));
  77 typedef struct link_request LINK_REQUEST, *PLINK_REQUEST;
  78
  79
  80 //classification extension is added
  81 typedef struct _ADD_CONNECTION
  82 {
  83     ULONG               SrcIpAddressCount;
  84     ULONG               SrcIpAddress[MAX_CONNECTIONS];
  85     ULONG               SrcIpMask[MAX_CONNECTIONS];
  86
  87     ULONG               DestIpAddressCount;
  88     ULONG               DestIpAddress[MAX_CONNECTIONS];
  89     ULONG               DestIpMask[MAX_CONNECTIONS];
  90
  91     USHORT              SrcPortBegin;
  92     USHORT              SrcPortEnd;
  93
  94     USHORT              DestPortBegin;
  95     USHORT              DestPortEnd;
  96
  97     UCHAR               SrcTOS;
  98     UCHAR               SrcProtocol;
  99 } ADD_CONNECTION,*PADD_CONNECTION;
 100
 101
 102 typedef struct _CLASSIFICATION_RULE
 103 {
 104         UCHAR           ucIPSrcAddrLen;
 105         UCHAR       ucIPSrcAddr[32];
 106         UCHAR           ucIPDestAddrLen;
 107         UCHAR       ucIPDestAddr[32];
 108         UCHAR           ucSrcPortRangeLen;
 109         UCHAR           ucSrcPortRange[4];
 110         UCHAR           ucDestPortRangeLen;
 111         UCHAR           ucDestPortRange[4];
 112         USHORT          usVcid;
 113 } CLASSIFICATION_RULE,*PCLASSIFICATION_RULE;
 114
 115 typedef struct _CLASSIFICATION_ONLY
 116 {
 117     USHORT              usVcid;
 118     ULONG               DestIpAddress;
 119     ULONG               DestIpMask;
 120     USHORT              usPortLo;
 121     USHORT              usPortHi;
 122     BOOLEAN             bIpVersion;
 123     UCHAR               ucDestinationAddress[16];
 124 } CLASSIFICATION_ONLY, *PCLASSIFICATION_ONLY;
 125
 126
 127 #define MAX_IP_RANGE_LENGTH 4
 128 #define MAX_PORT_RANGE 4
 129 #define MAX_PROTOCOL_LENGTH   32
 130 #define IPV6_ADDRESS_SIZEINBYTES 0x10
 131
 132 typedef union _U_IP_ADDRESS
 133 {
 134     struct
 135         {
 136                 ULONG                           ulIpv4Addr[MAX_IP_RANGE_LENGTH];//Source Ip Address Range
 137                 ULONG               ulIpv4Mask[MAX_IP_RANGE_LENGTH];//Source Ip Mask Address Range
 138         };
 139         struct
 140         {
 141                 ULONG                           ulIpv6Addr[MAX_IP_RANGE_LENGTH * 4];//Source Ip Address Range
 142                 ULONG               ulIpv6Mask[MAX_IP_RANGE_LENGTH * 4];//Source Ip Mask Address Range
 143
 144         };
 145         struct
 146         {
 147                 UCHAR                           ucIpv4Address[MAX_IP_RANGE_LENGTH * IP_LENGTH_OF_ADDRESS];
 148                 UCHAR                           ucIpv4Mask[MAX_IP_RANGE_LENGTH * IP_LENGTH_OF_ADDRESS];
 149         };
 150         struct
 151         {
 152                 UCHAR                           ucIpv6Address[MAX_IP_RANGE_LENGTH * IPV6_ADDRESS_SIZEINBYTES];
 153                 UCHAR                           ucIpv6Mask[MAX_IP_RANGE_LENGTH * IPV6_ADDRESS_SIZEINBYTES];
 154         };
 155 }U_IP_ADDRESS;
 156 struct _packet_info;
 157
 158 typedef struct _S_HDR_SUPRESSION_CONTEXTINFO
 159 {
 160
 161         UCHAR      ucaHdrSupressionInBuf[MAX_PHS_LENGTHS]; //Intermediate buffer to accumulate pkt Header for PHS
 162         UCHAR      ucaHdrSupressionOutBuf[MAX_PHS_LENGTHS + PHSI_LEN]; //Intermediate buffer containing pkt Header after PHS
 163
 164 }S_HDR_SUPRESSION_CONTEXTINFO;
 165
 166
 167 typedef struct _S_CLASSIFIER_RULE
 168 {
 169         ULONG                   ulSFID;
 170         UCHAR           ucReserved[2];
 171         B_UINT16        uiClassifierRuleIndex;
 172         BOOLEAN                 bUsed;
 173         USHORT                  usVCID_Value;
 174         B_UINT8         u8ClassifierRulePriority; //This field detemines the Classifier Priority
 175         U_IP_ADDRESS    stSrcIpAddress;
 176         UCHAR           ucIPSourceAddressLength;//Ip Source Address Length
 177
 178         U_IP_ADDRESS    stDestIpAddress;
 179     UCHAR           ucIPDestinationAddressLength;//Ip Destination Address Length
 180     UCHAR           ucIPTypeOfServiceLength;//Type of service Length
 181     UCHAR           ucTosLow;//Tos Low
 182     UCHAR           ucTosHigh;//Tos High
 183         UCHAR           ucTosMask;//Tos Mask
 184
 185     UCHAR           ucProtocolLength;//protocol Length
 186     UCHAR           ucProtocol[MAX_PROTOCOL_LENGTH];//protocol Length
 187     USHORT                      usSrcPortRangeLo[MAX_PORT_RANGE];
 188         USHORT                  usSrcPortRangeHi[MAX_PORT_RANGE];
 189     UCHAR           ucSrcPortRangeLength;
 190
 191     USHORT                      usDestPortRangeLo[MAX_PORT_RANGE];
 192         USHORT                  usDestPortRangeHi[MAX_PORT_RANGE];
 193     UCHAR           ucDestPortRangeLength;
 194
 195         BOOLEAN                 bProtocolValid;
 196         BOOLEAN                 bTOSValid;
 197         BOOLEAN                 bDestIpValid;
 198         BOOLEAN                 bSrcIpValid;
 199
 200         //For IPv6 Addressing
 201         UCHAR                   ucDirection;
 202         BOOLEAN         bIpv6Protocol;
 203         UINT32          u32PHSRuleID;
 204         S_PHS_RULE          sPhsRule;
 205         UCHAR                   u8AssociatedPHSI;
 206
 207         //Classification fields for ETH CS
 208         UCHAR           ucEthCSSrcMACLen;
 209         UCHAR           au8EThCSSrcMAC[MAC_ADDRESS_SIZE];
 210         UCHAR           au8EThCSSrcMACMask[MAC_ADDRESS_SIZE];
 211         UCHAR           ucEthCSDestMACLen;
 212         UCHAR           au8EThCSDestMAC[MAC_ADDRESS_SIZE];
 213         UCHAR           au8EThCSDestMACMask[MAC_ADDRESS_SIZE];
 214         UCHAR           ucEtherTypeLen;
 215         UCHAR           au8EthCSEtherType[NUM_ETHERTYPE_BYTES];
 216         UCHAR           usUserPriority[2];
 217         USHORT          usVLANID;
 218         USHORT          usValidityBitMap;
 219 }S_CLASSIFIER_RULE;
 220 //typedef struct _S_CLASSIFIER_RULE S_CLASSIFIER_RULE;
 221
 222 typedef struct _S_FRAGMENTED_PACKET_INFO
 223 {
 224         BOOLEAN                         bUsed;
 225         ULONG                   ulSrcIpAddress;
 226         USHORT                          usIpIdentification;
 227         S_CLASSIFIER_RULE       *pstMatchedClassifierEntry;
 228         BOOLEAN                         bOutOfOrderFragment;
 229 }S_FRAGMENTED_PACKET_INFO,*PS_FRAGMENTED_PACKET_INFO;
 230
 231 struct _packet_info
 232 {
 233         //classification extension Rule
 234         ULONG                   ulSFID;
 235         USHORT                  usVCID_Value;
 236         UINT                    uiThreshold;
 237         // This field determines the priority of the SF Queues
 238         B_UINT8         u8TrafficPriority;
 239
 240         BOOLEAN                 bValid;
 241         BOOLEAN         bActive;
 242         BOOLEAN                 bActivateRequestSent;
 243
 244         B_UINT8                 u8QueueType;//BE or rtPS
 245
 246         UINT                    uiMaxBucketSize;//maximum size of the bucket for the queue
 247         UINT                    uiCurrentQueueDepthOnTarget;
 248         UINT                    uiCurrentBytesOnHost;
 249         UINT                    uiCurrentPacketsOnHost;
 250         UINT                    uiDroppedCountBytes;
 251         UINT                    uiDroppedCountPackets;
 252         UINT                    uiSentBytes;
 253         UINT                    uiSentPackets;
 254         UINT                    uiCurrentDrainRate;
 255         UINT                    uiThisPeriodSentBytes;
 256         LARGE_INTEGER   liDrainCalculated;
 257         UINT                    uiCurrentTokenCount;
 258         LARGE_INTEGER   liLastUpdateTokenAt;
 259         UINT                    uiMaxAllowedRate;
 260         UINT                    NumOfPacketsSent;
 261         UCHAR                   ucDirection;
 262         USHORT                  usCID;
 263         S_MIBS_EXTSERVICEFLOW_PARAMETERS        stMibsExtServiceFlowTable;
 264         UINT                    uiCurrentRxRate;
 265         UINT                    uiThisPeriodRxBytes;
 266         UINT                    uiTotalRxBytes;
 267         UINT                    uiTotalTxBytes;
 268         UINT                    uiPendedLast;
 269         UCHAR                   ucIpVersion;
 270
 271         union
 272         {
 273                 struct
 274                 {
 275                         struct sk_buff*    FirstTxQueue;
 276                         struct sk_buff*    LastTxQueue;
 277                 };
 278                 struct
 279                 {
 280                         struct sk_buff*    ControlHead;
 281                         struct sk_buff*    ControlTail;
 282                 };
 283         };
 284         BOOLEAN         bProtocolValid;
 285         BOOLEAN         bTOSValid;
 286         BOOLEAN         bDestIpValid;
 287         BOOLEAN         bSrcIpValid;
 288
 289         BOOLEAN         bActiveSet;
 290         BOOLEAN         bAdmittedSet;
 291         BOOLEAN         bAuthorizedSet;
 292         BOOLEAN         bClassifierPriority;
 293         UCHAR           ucServiceClassName[MAX_CLASS_NAME_LENGTH];
 294         BOOLEAN     bHeaderSuppressionEnabled;
 295         spinlock_t      SFQueueLock;
 296         void            *pstSFIndication;
 297         struct timeval  stLastUpdateTokenAt;
 298         atomic_t        uiPerSFTxResourceCount;
 299         UINT            uiMaxLatency;
 300         UCHAR   bIPCSSupport;
 301         UCHAR   bEthCSSupport;
 302 };
 303 typedef struct _packet_info PacketInfo;
 304
 305
 306 typedef struct _PER_TARANG_DATA
 307 {
 308     struct _PER_TARANG_DATA * next;
 309     struct _MINI_ADAPTER * Adapter;
 310     struct sk_buff*     RxAppControlHead;
 311     struct sk_buff*     RxAppControlTail;
 312     volatile INT        AppCtrlQueueLen;
 313     BOOLEAN             MacTracingEnabled;
 314         BOOLEAN                         bApplicationToExit;
 315         S_MIBS_DROPPED_APP_CNTRL_MESSAGES stDroppedAppCntrlMsgs;
 316         ULONG                           RxCntrlMsgBitMask;
 317 } PER_TARANG_DATA, *PPER_TARANG_DATA;
 318
 319
 320 #ifdef REL_4_1
 321 typedef struct _TARGET_PARAMS
 322 {
 323       B_UINT32 m_u32CfgVersion;
 324
 325       // Scanning Related Params
 326       B_UINT32 m_u32CenterFrequency;
 327       B_UINT32 m_u32BandAScan;
 328       B_UINT32 m_u32BandBScan;
 329       B_UINT32 m_u32BandCScan;
 330
 331       // QoS Params
 332       B_UINT32 m_u32minGrantsize;       // size of minimum grant is 0 or 6
 333       B_UINT32 m_u32PHSEnable;
 334
 335       // HO Params
 336       B_UINT32 m_u32HoEnable;
 337       B_UINT32 m_u32HoReserved1;
 338       B_UINT32 m_u32HoReserved2;
 339
 340         // Power Control Params
 341       B_UINT32 m_u32MimoEnable;
 342       B_UINT32 m_u32SecurityEnable;
 343         /*
 344      * bit 1: 1 Idlemode enable;
 345      * bit 2: 1 Sleepmode Enable
 346      */
 347       B_UINT32 m_u32PowerSavingModesEnable;
 348           /* PowerSaving Mode Options:
 349              bit 0 = 1: CPE mode - to keep pcmcia if alive;
 350              bit 1 = 1: CINR reporing in Idlemode Msg
 351              bit 2 = 1: Default PSC Enable in sleepmode*/
 352       B_UINT32 m_u32PowerSavingModeOptions;
 353
 354       B_UINT32 m_u32ArqEnable;
 355
 356       // From Version #3, the HARQ section renamed as general
 357       B_UINT32 m_u32HarqEnable;
 358        // EEPROM Param Location
 359        B_UINT32  m_u32EEPROMFlag;
 360        /* BINARY TYPE - 4th MSByte:
 361         * Interface Type -  3rd MSByte:
 362         * Vendor Type - 2nd MSByte
 363         */
 364        // Unused - LSByte
 365       B_UINT32   m_u32Customize;
 366       B_UINT32   m_u32ConfigBW;  /* In Hz */
 367       B_UINT32   m_u32ShutDownTimer;
 368
 369
 370       B_UINT32  m_u32RadioParameter;
 371       B_UINT32  m_u32PhyParameter1;
 372       B_UINT32  m_u32PhyParameter2;
 373       B_UINT32  m_u32PhyParameter3;
 374
 375         /* in eval mode only;
 376      * lower 16bits = basic cid for testing;
 377      * then bit 16 is test cqich,
 378      * bit 17  test init rang;
 379      * bit 18 test periodic rang
 380      * bit 19 is test harq ack/nack
 381      */
 382     B_UINT32      m_u32TestOptions;
 383
 384         B_UINT32 m_u32MaxMACDataperDLFrame;
 385         B_UINT32 m_u32MaxMACDataperULFrame;
 386
 387         B_UINT32 m_u32Corr2MacFlags;
 388
 389     //adding driver params.
 390     B_UINT32 HostDrvrConfig1;
 391     B_UINT32 HostDrvrConfig2;
 392     B_UINT32 HostDrvrConfig3;
 393     B_UINT32 HostDrvrConfig4;
 394     B_UINT32 HostDrvrConfig5;
 395     B_UINT32 HostDrvrConfig6;
 396     B_UINT32 m_u32SegmentedPUSCenable;
 397
 398         //      BAMC enable - but 4.x does not support this feature
 399         //      This is added just to sync 4.x and 5.x CFGs
 400         B_UINT32 m_u32BandAMCEnable;
 401 } STARGETPARAMS, *PSTARGETPARAMS;
 402 #endif
 403
 404 typedef struct _STTARGETDSXBUFFER
 405 {
 406     ULONG ulTargetDsxBuffer;
 407     B_UINT16 tid;
 408     BOOLEAN valid;
 409 }STTARGETDSXBUFFER, *PSTTARGETDSXBUFFER;
 410
 411 typedef INT (*FP_FLASH_WRITE)(struct _MINI_ADAPTER*,UINT,PVOID);
 412
 413 typedef INT (*FP_FLASH_WRITE_STATUS)(struct _MINI_ADAPTER*,UINT,PVOID);
 414
 415 /**
 416 Driver adapter data structure
 417 */
 418 struct _MINI_ADAPTER
 419 {
 420         struct _MINI_ADAPTER *next;
 421
 422         CHAR                *caDsxReqResp;
 423         atomic_t                        ApplicationRunning;
 424         volatile INT            CtrlQueueLen;
 425         atomic_t            AppCtrlQueueLen;
 426         BOOLEAN             AppCtrlQueueOverFlow;
 427         atomic_t                        CurrentApplicationCount;
 428         atomic_t                        RegisteredApplicationCount;
 429         BOOLEAN                     TimerActive;
 430         ULONG                           StatisticsPointer;
 431         struct sk_buff          *RxControlHead;
 432         struct sk_buff          *RxControlTail;
 433 //      spinlock_t                      RxControlQueuelock;
 434         struct semaphore        RxAppControlQueuelock;
 435         struct semaphore        fw_download_sema;
 436
 437         PPER_TARANG_DATA    pTarangs;
 438         spinlock_t                      control_queue_lock;
 439         wait_queue_head_t       process_read_wait_queue;
 440         ULONG                   bcm_jiffies;    /* Store Jiffies value */
 441
 442         // the pointer to the first packet we have queued in send
 443         // deserialized miniport support variables
 444         atomic_t                    TotalPacketCount;
 445         atomic_t                    TxPktAvail;
 446
 447         // this to keep track of the Tx and Rx MailBox Registers.
 448         atomic_t                    CurrNumFreeTxDesc;
 449         // to keep track the no of byte recieved
 450         atomic_t                        RxRollOverCount;
 451         USHORT                          PrevNumRecvDescs;
 452         USHORT                          CurrNumRecvDescs;
 453         atomic_t                        GoodRxByteCount;
 454         atomic_t                        GoodRxPktCount;
 455         atomic_t                        BadRxByteCount;
 456         atomic_t                        RxPacketDroppedCount;
 457         atomic_t                        GoodTxByteCount;
 458         atomic_t                        TxTotalPacketCount;
 459         atomic_t                        TxDroppedPacketCount;
 460         ULONG                           LinkUpStatus;
 461         BOOLEAN                     TransferMode;
 462         UINT                            u32TotalDSD;
 463         PacketInfo                  PackInfo[NO_OF_QUEUES];
 464         S_CLASSIFIER_RULE       astClassifierTable[MAX_CLASSIFIERS];
 465
 466         /*************** qos ******************/
 467         UINT                            bETHCSEnabled;
 468
 469         ULONG                       BEBucketSize;
 470         ULONG                       rtPSBucketSize;
 471         UCHAR                       LinkStatus;
 472         BOOLEAN                     AutoLinkUp;
 473         BOOLEAN                     AutoSyncup;
 474
 475         struct net_device       *dev;
 476         int                             major;
 477         int                             minor;
 478         wait_queue_head_t       tx_packet_wait_queue;
 479         wait_queue_head_t       process_rx_cntrlpkt;
 480         atomic_t                        process_waiting;
 481         BOOLEAN                         fw_download_done;
 482
 483         unsigned int            ctrlpkt_present;
 484         BOOLEAN                         packets_given_to_all;
 485         char                            *txctlpacket[MAX_CNTRL_PKTS];
 486         atomic_t                        cntrlpktCnt ;
 487         atomic_t                        index_app_read_cntrlpkt;
 488         atomic_t                        index_wr_txcntrlpkt;
 489         atomic_t                        index_rd_txcntrlpkt;
 490         UINT                            index_datpkt;
 491         struct semaphore        rdmwrmsync;
 492
 493         STTARGETDSXBUFFER       astTargetDsxBuffer[MAX_TARGET_DSX_BUFFERS];
 494         ULONG                           ulFreeTargetBufferCnt;
 495         ULONG                   ulCurrentTargetBuffer;
 496         ULONG                   ulTotalTargetBuffersAvailable;
 497         unsigned int            timeout;
 498         int                             irq;
 499         unsigned long           chip_id;
 500         unsigned int            bFlashBoot;
 501 //      spinlock_t                      sleeper_lock;
 502         atomic_t                        rdm_wrm_access;
 503         atomic_t                        tx_rx_access;
 504         wait_queue_head_t       lowpower_mode_wait_queue;
 505         atomic_t                        bAbortedByHost;
 506         BOOLEAN                         bBinDownloaded;
 507         BOOLEAN                         bCfgDownloaded;
 508         USHORT                          usBestEffortQueueIndex;
 509         BOOLEAN                         bSyncUpRequestSent;
 510 //      struct semaphore        data_packet_queue_lock;
 511         wait_queue_head_t       ioctl_fw_dnld_wait_queue;
 512         BOOLEAN                         waiting_to_fw_download_done;
 513         pid_t                           fw_download_process_pid;
 514         PSTARGETPARAMS          pstargetparams;
 515         BOOLEAN                         device_removed;
 516         BOOLEAN                         DeviceAccess;
 517         INT                                     DDRSetting;
 518         BOOLEAN                         bDDRInitDone;
 519         ULONG                           ulPowerSaveMode;
 520         BOOLEAN                         bIsAutoCorrectEnabled;
 521         spinlock_t                      txtransmitlock;
 522         B_UINT8                         txtransmit_running;
 523         /* Thread for control packet handling */
 524         struct task_struct      *control_packet_handler;
 525         /* thread for transmitting packets. */
 526         struct task_struct      *transmit_packet_thread;
 527
 528         /* LED Related Structures */
 529         LED_INFO_STRUCT         LEDInfo;
 530
 531         /* Driver State for LED Blinking */
 532         LedEventInfo_t          DriverState;
 533         /* Interface Specific */
 534         PVOID                           pvInterfaceAdapter;
 535         int (*bcm_file_download)( PVOID,
 536                         struct file *,
 537                         unsigned int);
 538         int (*bcm_file_readback_from_chip)( PVOID,
 539                         struct file *,
 540                         unsigned int);
 541         INT (*interface_rdm)(PVOID,
 542                         UINT ,
 543                         PVOID ,
 544                         INT);
 545         INT (*interface_wrm)(PVOID,
 546                         UINT ,
 547                         PVOID ,
 548                         INT);
 549         int (*interface_transmit)(PVOID, PVOID , UINT);
 550         BOOLEAN                 IdleMode;
 551         BOOLEAN                 bDregRequestSentInIdleMode;
 552         BOOLEAN                 bTriedToWakeUpFromlowPowerMode;
 553         BOOLEAN                 bShutStatus;
 554         BOOLEAN                 bWakeUpDevice;
 555         unsigned int    usIdleModePattern;
 556         //BOOLEAN                       bTriedToWakeUpFromShutdown;
 557         BOOLEAN                 bLinkDownRequested;
 558         unsigned int    check_for_hang;
 559         int                     downloadDDR;
 560         PHS_DEVICE_EXTENSION stBCMPhsContext;
 561         S_HDR_SUPRESSION_CONTEXTINFO    stPhsTxContextInfo;
 562         uint8_t                 ucaPHSPktRestoreBuf[2048];
 563         uint8_t                 bPHSEnabled;
 564         int                     AutoFirmDld;
 565         BOOLEAN         bMipsConfig;
 566         BOOLEAN         bDPLLConfig;
 567         UINT32                  aTxPktSizeHist[MIBS_MAX_HIST_ENTRIES];
 568         UINT32                  aRxPktSizeHist[MIBS_MAX_HIST_ENTRIES];
 569         S_FRAGMENTED_PACKET_INFO astFragmentedPktClassifierTable[MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES];
 570         atomic_t                uiMBupdate;
 571         UINT32                  PmuMode;
 572         NVM_TYPE                eNVMType;
 573         UINT                    uiSectorSize;
 574         UINT                    uiSectorSizeInCFG;
 575         BOOLEAN                 bSectorSizeOverride;
 576         BOOLEAN                 bStatusWrite;
 577         UINT                    uiNVMDSDSize;
 578         UINT                    uiVendorExtnFlag;
 579          //it will always represent choosed DSD at any point of time.
 580          // Generally it is Active DSD but in case of NVM RD/WR it might be different.
 581         UINT                    ulFlashCalStart;
 582         ULONG                   ulFlashControlSectionStart;
 583         ULONG                   ulFlashWriteSize;
 584         ULONG                   ulFlashID;
 585         FP_FLASH_WRITE          fpFlashWrite;
 586         FP_FLASH_WRITE_STATUS   fpFlashWriteWithStatusCheck;
 587
 588
 589         struct semaphore        NVMRdmWrmLock;
 590
 591         struct device *pstCreatedClassDevice;
 592         BOOLEAN                 bUsbClassDriverRegistered;
 593 //      BOOLEAN                         InterfaceUpStatus;
 594         PFLASH2X_CS_INFO psFlash2xCSInfo;
 595         PFLASH_CS_INFO psFlashCSInfo ;
 596         PFLASH2X_VENDORSPECIFIC_INFO psFlash2xVendorInfo;
 597         UINT uiFlashBaseAdd; //Flash start address
 598         UINT uiActiveISOOffset; //Active ISO offset choosen before f/w download
 599         FLASH2X_SECTION_VAL eActiveISO; //Active ISO section val
 600         FLASH2X_SECTION_VAL eActiveDSD; //Active DSD val choosen before f/w download
 601         UINT uiActiveDSDOffsetAtFwDld;  //For accessing Active DSD choosen before f/w download
 602         UINT uiFlashLayoutMajorVersion ;
 603         UINT uiFlashLayoutMinorVersion;
 604         BOOLEAN bAllDSDWriteAllow ;
 605         BOOLEAN bSigCorrupted ;
 606         //this should be set who so ever want to change the Headers. after Wrtie it should be reset immediately.
 607         BOOLEAN bHeaderChangeAllowed ;
 608         INT SelectedChip ;
 609         BOOLEAN bEndPointHalted;
 610         //while bFlashRawRead will be true, Driver  ignore map lay out and consider flash as of without any map.
 611         BOOLEAN bFlashRawRead;
 612         BOOLEAN                 bPreparingForLowPowerMode ;
 613         BOOLEAN bDoSuspend ;
 614         UINT syscfgBefFwDld ;
 615         BOOLEAN StopAllXaction ;
 616         UINT32  liTimeSinceLastNetEntry; //Used to Support extended CAPI requirements from
 617         struct semaphore        LowPowerModeSync;
 618         ULONG   liDrainCalculated;
 619         UINT gpioBitMap;
 620
 621     S_BCM_DEBUG_STATE stDebugState;
 622
 623 };
 624 typedef struct _MINI_ADAPTER MINI_ADAPTER, *PMINI_ADAPTER;
 625
 626
 627 typedef struct _DEVICE_EXTENSION
 628 {
 629         PMINI_ADAPTER pAdapt;
 630 }DEVICE_EXTENSION,*PDEVICE_EXTENSION;
 631
 632
 633 struct _ETH_HEADER_STRUC {
 634     UCHAR       au8DestinationAddress[6];
 635     UCHAR       au8SourceAddress[6];
 636     USHORT      u16Etype;
 637 }__attribute__((packed));
 638 typedef struct _ETH_HEADER_STRUC ETH_HEADER_STRUC, *PETH_HEADER_STRUC;
 639
 640
 641 typedef struct FirmwareInfo
 642 {
 643         void __user *   pvMappedFirmwareAddress;
 644         ULONG           u32FirmwareLength;
 645         ULONG           u32StartingAddress;
 646 }__attribute__((packed)) FIRMWARE_INFO, *PFIRMWARE_INFO;
 647
 648 // holds the value of net_device structure..
 649 extern struct net_device *gblpnetdev;
 650 typedef struct _cntl_pkt{
 651         PMINI_ADAPTER   Adapter;
 652         PLEADER                 PLeader;
 653 }cntl_pkt;
 654 typedef LINK_REQUEST CONTROL_MESSAGE;
 655
 656 typedef struct _DDR_SETTING
 657 {
 658         ULONG ulRegAddress;
 659         ULONG ulRegValue;
 660 }DDR_SETTING, *PDDR_SETTING;
 661 typedef DDR_SETTING DDR_SET_NODE, *PDDR_SET_NODE;
 662 INT
 663 InitAdapter(PMINI_ADAPTER psAdapter);
 664
 665 // =====================================================================
 666 // Beceem vendor request codes for EP0
 667 // =====================================================================
 668
 669 #define BCM_REQUEST_READ  0x2
 670 #define BCM_REQUEST_WRITE 0x1
 671 #define EP2_MPS_REG  0x0F0110A0
 672 #define EP2_MPS          0x40
 673
 674 #define EP2_CFG_REG  0x0F0110A8
 675 #define EP2_CFG_INT  0x27
 676 #define EP2_CFG_BULK 0x25
 677
 678 #define EP4_MPS_REG  0x0F0110F0
 679 #define EP4_MPS      0x8C
 680
 681 #define EP4_CFG_REG  0x0F0110F8
 682
 683 #define ISO_MPS_REG  0x0F0110C8
 684 #define ISO_MPS      0x00000000
 685
 686
 687 #define EP1 0
 688 #define EP2 1
 689 #define EP3 2
 690 #define EP4 3
 691 #define EP5 4
 692 #define EP6 5
 693
 694
 695 typedef enum eInterface_setting
 696 {
 697         DEFAULT_SETTING_0  = 0,
 698         ALTERNATE_SETTING_1 = 1,
 699 }INTERFACE_SETTING;
 700
 701 #endif  //__ADAPTER_H__
 702