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