drivers/staging/vt6655/desc.h

   1 /*
   2  * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
   3  * All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * File: desc.h
  20  *
  21  * Purpose:The header file of descriptor
  22  *
  23  * Revision History:
  24  *
  25  * Author: Tevin Chen
  26  *
  27  * Date: May 21, 1996
  28  *
  29  */
  30
  31 #ifndef __DESC_H__
  32 #define __DESC_H__
  33
  34 #include <linux/types.h>
  35 #include <linux/mm.h>
  36 #include "ttype.h"
  37 #include "tether.h"
  38
  39 /*---------------------  Export Definitions -------------------------*/
  40
  41 #define B_OWNED_BY_CHIP     1           //
  42 #define B_OWNED_BY_HOST     0           //
  43
  44 //
  45 // Bits in the RSR register
  46 //
  47 #define RSR_ADDRBROAD       0x80        // 1000 0000
  48 #define RSR_ADDRMULTI       0x40        // 0100 0000
  49 #define RSR_ADDRUNI         0x00        // 0000 0000
  50 #define RSR_IVLDTYP         0x20        // 0010 0000 , invalid packet type
  51 #define RSR_IVLDLEN         0x10        // 0001 0000 , invalid len (> 2312 byte)
  52 #define RSR_BSSIDOK         0x08        // 0000 1000
  53 #define RSR_CRCOK           0x04        // 0000 0100
  54 #define RSR_BCNSSIDOK       0x02        // 0000 0010
  55 #define RSR_ADDROK          0x01        // 0000 0001
  56
  57 //
  58 // Bits in the new RSR register
  59 //
  60 #define NEWRSR_DECRYPTOK    0x10        // 0001 0000
  61 #define NEWRSR_CFPIND       0x08        // 0000 1000
  62 #define NEWRSR_HWUTSF       0x04        // 0000 0100
  63 #define NEWRSR_BCNHITAID    0x02        // 0000 0010
  64 #define NEWRSR_BCNHITAID0   0x01        // 0000 0001
  65
  66 //
  67 // Bits in the TSR0 register
  68 //
  69 #define TSR0_PWRSTS1_2      0xC0        // 1100 0000
  70 #define TSR0_PWRSTS7        0x20        // 0010 0000
  71 #define TSR0_NCR            0x1F        // 0001 1111
  72
  73 //
  74 // Bits in the TSR1 register
  75 //
  76 #define TSR1_TERR           0x80        // 1000 0000
  77 #define TSR1_PWRSTS4_6      0x70        // 0111 0000
  78 #define TSR1_RETRYTMO       0x08        // 0000 1000
  79 #define TSR1_TMO            0x04        // 0000 0100
  80 #define TSR1_PWRSTS3        0x02        // 0000 0010
  81 #define ACK_DATA            0x01        // 0000 0000
  82
  83 //
  84 // Bits in the TCR register
  85 //
  86 #define EDMSDU              0x04        // 0000 0100 end of sdu
  87 #define TCR_EDP             0x02        // 0000 0010 end of packet
  88 #define TCR_STP             0x01        // 0000 0001 start of packet
  89
  90 // max transmit or receive buffer size
  91 #define CB_MAX_BUF_SIZE     2900U       // max buffer size
  92                                         // NOTE: must be multiple of 4
  93 #define CB_MAX_TX_BUF_SIZE          CB_MAX_BUF_SIZE // max Tx buffer size
  94 #define CB_MAX_RX_BUF_SIZE_NORMAL   CB_MAX_BUF_SIZE // max Rx buffer size when not use Multi-RD
  95
  96 #define CB_BEACON_BUF_SIZE  512U        // default beacon buffer size
  97
  98 #define CB_MAX_RX_DESC      128         // max # of descriptor
  99 #define CB_MIN_RX_DESC      16          // min # of rx descriptor
 100 #define CB_MAX_TX_DESC      64          // max # of descriptor
 101 #define CB_MIN_TX_DESC      16          // min # of tx descriptor
 102
 103 #define CB_MAX_RECEIVED_PACKETS     16  // max # of received packets at one time
 104                                         // limit our receive routine to indicating
 105                                         // this many at a time for 2 reasons:
 106                                         // 1. driver flow control to protocol layer
 107                                         // 2. limit the time used in ISR routine
 108
 109 #define CB_EXTRA_RD_NUM     32          // default # of Extra RD
 110 #define CB_RD_NUM           32          // default # of RD
 111 #define CB_TD_NUM           32          // default # of TD
 112
 113
 114 // max number of physical segments
 115 // in a single NDIS packet. Above this threshold, the packet
 116 // is copied into a single physically contiguous buffer
 117 #define CB_MAX_SEGMENT      4
 118
 119 #define CB_MIN_MAP_REG_NUM  4
 120 #define CB_MAX_MAP_REG_NUM  CB_MAX_TX_DESC
 121
 122 #define CB_PROTOCOL_RESERVED_SECTION    16
 123
 124
 125
 126 // if retrys excess 15 times , tx will abort, and
 127 // if tx fifo underflow, tx will fail
 128 // we should try to resend it
 129 #define CB_MAX_TX_ABORT_RETRY   3
 130
 131 #ifdef __BIG_ENDIAN
 132
 133 // WMAC definition FIFO Control
 134 #define FIFOCTL_AUTO_FB_1   0x0010 // 0001 0000 0000 0000
 135 #define FIFOCTL_AUTO_FB_0   0x0008 // 0000 1000 0000 0000
 136 #define FIFOCTL_GRPACK      0x0004 // 0000 0100 0000 0000
 137 #define FIFOCTL_11GA        0x0003 // 0000 0011 0000 0000
 138 #define FIFOCTL_11GB        0x0002 // 0000 0010 0000 0000
 139 #define FIFOCTL_11B         0x0001 // 0000 0001 0000 0000
 140 #define FIFOCTL_11A         0x0000 // 0000 0000 0000 0000
 141 #define FIFOCTL_RTS         0x8000 // 0000 0000 1000 0000
 142 #define FIFOCTL_ISDMA0      0x4000 // 0000 0000 0100 0000
 143 #define FIFOCTL_GENINT      0x2000 // 0000 0000 0010 0000
 144 #define FIFOCTL_TMOEN       0x1000 // 0000 0000 0001 0000
 145 #define FIFOCTL_LRETRY      0x0800 // 0000 0000 0000 1000
 146 #define FIFOCTL_CRCDIS      0x0400 // 0000 0000 0000 0100
 147 #define FIFOCTL_NEEDACK     0x0200 // 0000 0000 0000 0010
 148 #define FIFOCTL_LHEAD       0x0100 // 0000 0000 0000 0001
 149
 150 //WMAC definition Frag Control
 151 #define FRAGCTL_AES         0x0003 // 0000 0011 0000 0000
 152 #define FRAGCTL_TKIP        0x0002 // 0000 0010 0000 0000
 153 #define FRAGCTL_LEGACY      0x0001 // 0000 0001 0000 0000
 154 #define FRAGCTL_NONENCRYPT  0x0000 // 0000 0000 0000 0000
 155 //#define FRAGCTL_AC3         0x0C00 // 0000 0000 0000 1100
 156 //#define FRAGCTL_AC2         0x0800 // 0000 0000 0000 1000
 157 //#define FRAGCTL_AC1         0x0400 // 0000 0000 0000 0100
 158 //#define FRAGCTL_AC0         0x0000 // 0000 0000 0000 0000
 159 #define FRAGCTL_ENDFRAG     0x0300 // 0000 0000 0000 0011
 160 #define FRAGCTL_MIDFRAG     0x0200 // 0000 0000 0000 0010
 161 #define FRAGCTL_STAFRAG     0x0100 // 0000 0000 0000 0001
 162 #define FRAGCTL_NONFRAG     0x0000 // 0000 0000 0000 0000
 163
 164 #else
 165
 166 #define FIFOCTL_AUTO_FB_1   0x1000 // 0001 0000 0000 0000
 167 #define FIFOCTL_AUTO_FB_0   0x0800 // 0000 1000 0000 0000
 168 #define FIFOCTL_GRPACK      0x0400 // 0000 0100 0000 0000
 169 #define FIFOCTL_11GA        0x0300 // 0000 0011 0000 0000
 170 #define FIFOCTL_11GB        0x0200 // 0000 0010 0000 0000
 171 #define FIFOCTL_11B         0x0100 // 0000 0001 0000 0000
 172 #define FIFOCTL_11A         0x0000 // 0000 0000 0000 0000
 173 #define FIFOCTL_RTS         0x0080 // 0000 0000 1000 0000
 174 #define FIFOCTL_ISDMA0      0x0040 // 0000 0000 0100 0000
 175 #define FIFOCTL_GENINT      0x0020 // 0000 0000 0010 0000
 176 #define FIFOCTL_TMOEN       0x0010 // 0000 0000 0001 0000
 177 #define FIFOCTL_LRETRY      0x0008 // 0000 0000 0000 1000
 178 #define FIFOCTL_CRCDIS      0x0004 // 0000 0000 0000 0100
 179 #define FIFOCTL_NEEDACK     0x0002 // 0000 0000 0000 0010
 180 #define FIFOCTL_LHEAD       0x0001 // 0000 0000 0000 0001
 181
 182 //WMAC definition Frag Control
 183 #define FRAGCTL_AES         0x0300 // 0000 0011 0000 0000
 184 #define FRAGCTL_TKIP        0x0200 // 0000 0010 0000 0000
 185 #define FRAGCTL_LEGACY      0x0100 // 0000 0001 0000 0000
 186 #define FRAGCTL_NONENCRYPT  0x0000 // 0000 0000 0000 0000
 187 //#define FRAGCTL_AC3         0x000C // 0000 0000 0000 1100
 188 //#define FRAGCTL_AC2         0x0008 // 0000 0000 0000 1000
 189 //#define FRAGCTL_AC1         0x0004 // 0000 0000 0000 0100
 190 //#define FRAGCTL_AC0         0x0000 // 0000 0000 0000 0000
 191 #define FRAGCTL_ENDFRAG     0x0003 // 0000 0000 0000 0011
 192 #define FRAGCTL_MIDFRAG     0x0002 // 0000 0000 0000 0010
 193 #define FRAGCTL_STAFRAG     0x0001 // 0000 0000 0000 0001
 194 #define FRAGCTL_NONFRAG     0x0000 // 0000 0000 0000 0000
 195
 196 #endif // #ifdef __BIG_ENDIAN
 197
 198 //#define TYPE_AC0DMA     0
 199 //#define TYPE_TXDMA0     1
 200 #define TYPE_TXDMA0     0
 201 #define TYPE_AC0DMA     1
 202 #define TYPE_ATIMDMA    2
 203 #define TYPE_SYNCDMA    3
 204 #define TYPE_MAXTD      2
 205
 206 #define TYPE_BEACONDMA  4
 207
 208 #define TYPE_RXDMA0     0
 209 #define TYPE_RXDMA1     1
 210 #define TYPE_MAXRD      2
 211
 212
 213
 214 // TD_INFO flags control bit
 215 #define TD_FLAGS_NETIF_SKB               0x01       // check if need release skb
 216 #define TD_FLAGS_PRIV_SKB                0x02       // check if called from private skb(hostap)
 217 #define TD_FLAGS_PS_RETRY                0x04       // check if PS STA frame re-transmit
 218 //#define TD_FLAGS_NETIF_SKB                0x04
 219
 220 /*---------------------  Export Types  ------------------------------*/
 221
 222 // ref_sk_buff is used for mapping the skb structure between pre-built driver-obj & running kernel.
 223 // Since different kernel version (2.4x) may change skb structure, i.e. pre-built driver-obj
 224 // may link to older skb that leads error.
 225
 226 typedef struct tagDEVICE_RD_INFO {
 227     struct sk_buff* skb;
 228     dma_addr_t  skb_dma;
 229     dma_addr_t  curr_desc;
 230 } DEVICE_RD_INFO,   *PDEVICE_RD_INFO;
 231
 232 /*
 233 static inline PDEVICE_RD_INFO alloc_rd_info(void) {
 234     PDEVICE_RD_INFO  ptr;
 235     if ((ptr = kmalloc(sizeof(DEVICE_RD_INFO), GFP_ATOMIC)) == NULL)
 236         return NULL;
 237     else {
 238         memset(ptr,0,sizeof(DEVICE_RD_INFO));
 239         return ptr;
 240     }
 241 }
 242 */
 243
 244 /*
 245 typedef struct tagRDES0 {
 246     WORD    wResCount;
 247     WORD    wf1Owner ;
 248 //    WORD    f15Reserved : 15;
 249 //    WORD    f1Owner : 1;
 250 } __attribute__ ((__packed__))
 251 SRDES0;
 252 */
 253
 254 #ifdef __BIG_ENDIAN
 255
 256 typedef struct tagRDES0 {
 257    volatile WORD    wResCount;
 258         union {
 259                 volatile U16    f15Reserved;
 260                 struct {
 261             volatile U8 f8Reserved1;
 262                         volatile U8 f1Owner:1;
 263                         volatile U8 f7Reserved:7;
 264                 } __attribute__ ((__packed__));
 265         } __attribute__ ((__packed__));
 266 } __attribute__ ((__packed__))
 267 SRDES0, *PSRDES0;
 268
 269 #else
 270
 271 typedef struct tagRDES0 {
 272     WORD    wResCount;
 273     WORD    f15Reserved : 15;
 274     WORD    f1Owner : 1;
 275 } __attribute__ ((__packed__))
 276 SRDES0;
 277
 278
 279 #endif
 280
 281 typedef struct tagRDES1 {
 282     WORD   wReqCount;
 283     WORD   wReserved;
 284 } __attribute__ ((__packed__))
 285 SRDES1;
 286
 287 //
 288 // Rx descriptor
 289 //
 290 typedef struct tagSRxDesc {
 291     volatile SRDES0 m_rd0RD0;
 292     volatile SRDES1 m_rd1RD1;
 293     volatile U32    buff_addr;
 294     volatile U32    next_desc;
 295     struct tagSRxDesc   *next;//4 bytes
 296     volatile PDEVICE_RD_INFO    pRDInfo;//4 bytes
 297     volatile U32    Reserved[2];//8 bytes
 298 } __attribute__ ((__packed__))
 299 SRxDesc, *PSRxDesc;
 300 typedef const SRxDesc *PCSRxDesc;
 301
 302 #ifdef __BIG_ENDIAN
 303
 304 /*
 305 typedef struct tagTDES0 {
 306     volatile    BYTE    byTSR0;
 307     volatile    BYTE    byTSR1;
 308     volatile    WORD    wOwner_Txtime;
 309 //    volatile    WORD    f15Txtime : 15;
 310 //    volatile    WORD    f1Owner:1;
 311 } __attribute__ ((__packed__))
 312 STDES0;
 313 */
 314
 315 typedef struct tagTDES0 {
 316     volatile    BYTE    byTSR0;
 317     volatile    BYTE    byTSR1;
 318         union {
 319                 volatile U16    f15Txtime;
 320                 struct {
 321             volatile U8 f8Reserved1;
 322                         volatile U8 f1Owner:1;
 323                         volatile U8 f7Reserved:7;
 324                 } __attribute__ ((__packed__));
 325         } __attribute__ ((__packed__));
 326 } __attribute__ ((__packed__))
 327 STDES0, PSTDES0;
 328
 329 #else
 330
 331 typedef struct tagTDES0 {
 332     volatile    BYTE    byTSR0;
 333     volatile    BYTE    byTSR1;
 334     volatile    WORD    f15Txtime : 15;
 335     volatile    WORD    f1Owner:1;
 336 } __attribute__ ((__packed__))
 337 STDES0;
 338
 339 #endif
 340
 341
 342 typedef struct tagTDES1 {
 343     volatile    WORD    wReqCount;
 344     volatile    BYTE    byTCR;
 345     volatile    BYTE    byReserved;
 346 } __attribute__ ((__packed__))
 347 STDES1;
 348
 349
 350 typedef struct tagDEVICE_TD_INFO{
 351     struct sk_buff*     skb;
 352     PBYTE               buf;
 353     dma_addr_t          skb_dma;
 354     dma_addr_t          buf_dma;
 355     dma_addr_t          curr_desc;
 356     DWORD               dwReqCount;
 357     DWORD               dwHeaderLength;
 358     BYTE                byFlags;
 359 } DEVICE_TD_INFO,    *PDEVICE_TD_INFO;
 360
 361 /*
 362 static inline PDEVICE_TD_INFO alloc_td_info(void) {
 363     PDEVICE_TD_INFO  ptr;
 364     if ((ptr = kmalloc(sizeof(DEVICE_TD_INFO),GFP_ATOMIC))==NULL)
 365         return NULL;
 366     else {
 367         memset(ptr,0,sizeof(DEVICE_TD_INFO));
 368         return ptr;
 369     }
 370 }
 371 */
 372
 373 //
 374 // transmit descriptor
 375 //
 376 typedef struct tagSTxDesc {
 377     volatile    STDES0  m_td0TD0;
 378     volatile    STDES1  m_td1TD1;
 379     volatile    U32    buff_addr;
 380     volatile    U32    next_desc;
 381     struct tagSTxDesc*  next; //4 bytes
 382     volatile    PDEVICE_TD_INFO pTDInfo;//4 bytes
 383     volatile    U32    Reserved[2];//8 bytes
 384 } __attribute__ ((__packed__))
 385 STxDesc, *PSTxDesc;
 386 typedef const STxDesc *PCSTxDesc;
 387
 388
 389 typedef struct tagSTxSyncDesc {
 390     volatile    STDES0  m_td0TD0;
 391     volatile    STDES1  m_td1TD1;
 392     volatile    DWORD   buff_addr; // pointer to logical buffer
 393     volatile    DWORD   next_desc; // pointer to next logical descriptor
 394     volatile    WORD    m_wFIFOCtl;
 395     volatile    WORD    m_wTimeStamp;
 396     struct tagSTxSyncDesc*  next; //4 bytes
 397     volatile    PDEVICE_TD_INFO pTDInfo;//4 bytes
 398     volatile    DWORD   m_dwReserved2;
 399 } __attribute__ ((__packed__))
 400 STxSyncDesc, *PSTxSyncDesc;
 401 typedef const STxSyncDesc *PCSTxSyncDesc;
 402
 403
 404 //
 405 // RsvTime buffer header
 406 //
 407 typedef struct tagSRrvTime_gRTS {
 408     WORD        wRTSTxRrvTime_ba;
 409     WORD        wRTSTxRrvTime_aa;
 410     WORD        wRTSTxRrvTime_bb;
 411     WORD        wReserved;
 412     WORD        wTxRrvTime_b;
 413     WORD        wTxRrvTime_a;
 414 }__attribute__ ((__packed__))
 415 SRrvTime_gRTS, *PSRrvTime_gRTS;
 416 typedef const SRrvTime_gRTS *PCSRrvTime_gRTS;
 417
 418 typedef struct tagSRrvTime_gCTS {
 419     WORD        wCTSTxRrvTime_ba;
 420     WORD        wReserved;
 421     WORD        wTxRrvTime_b;
 422     WORD        wTxRrvTime_a;
 423 }__attribute__ ((__packed__))
 424 SRrvTime_gCTS, *PSRrvTime_gCTS;
 425 typedef const SRrvTime_gCTS *PCSRrvTime_gCTS;
 426
 427 typedef struct tagSRrvTime_ab {
 428     WORD        wRTSTxRrvTime;
 429     WORD        wTxRrvTime;
 430 }__attribute__ ((__packed__))
 431 SRrvTime_ab, *PSRrvTime_ab;
 432 typedef const SRrvTime_ab *PCSRrvTime_ab;
 433
 434 typedef struct tagSRrvTime_atim {
 435     WORD        wCTSTxRrvTime_ba;
 436     WORD        wTxRrvTime_a;
 437 }__attribute__ ((__packed__))
 438 SRrvTime_atim, *PSRrvTime_atim;
 439 typedef const SRrvTime_atim *PCSRrvTime_atim;
 440
 441 //
 442 // RTS buffer header
 443 //
 444 typedef struct tagSRTSData {
 445     WORD    wFrameControl;
 446     WORD    wDurationID;
 447     BYTE    abyRA[U_ETHER_ADDR_LEN];
 448     BYTE    abyTA[U_ETHER_ADDR_LEN];
 449 }__attribute__ ((__packed__))
 450 SRTSData, *PSRTSData;
 451 typedef const SRTSData *PCSRTSData;
 452
 453 typedef struct tagSRTS_g {
 454     BYTE        bySignalField_b;
 455     BYTE        byServiceField_b;
 456     WORD        wTransmitLength_b;
 457     BYTE        bySignalField_a;
 458     BYTE        byServiceField_a;
 459     WORD        wTransmitLength_a;
 460     WORD        wDuration_ba;
 461     WORD        wDuration_aa;
 462     WORD        wDuration_bb;
 463     WORD        wReserved;
 464     SRTSData    Data;
 465 }__attribute__ ((__packed__))
 466 SRTS_g, *PSRTS_g;
 467 typedef const SRTS_g *PCSRTS_g;
 468
 469
 470 typedef struct tagSRTS_g_FB {
 471     BYTE        bySignalField_b;
 472     BYTE        byServiceField_b;
 473     WORD        wTransmitLength_b;
 474     BYTE        bySignalField_a;
 475     BYTE        byServiceField_a;
 476     WORD        wTransmitLength_a;
 477     WORD        wDuration_ba;
 478     WORD        wDuration_aa;
 479     WORD        wDuration_bb;
 480     WORD        wReserved;
 481     WORD        wRTSDuration_ba_f0;
 482     WORD        wRTSDuration_aa_f0;
 483     WORD        wRTSDuration_ba_f1;
 484     WORD        wRTSDuration_aa_f1;
 485     SRTSData    Data;
 486 }__attribute__ ((__packed__))
 487 SRTS_g_FB, *PSRTS_g_FB;
 488 typedef const SRTS_g_FB *PCSRTS_g_FB;
 489
 490
 491 typedef struct tagSRTS_ab {
 492     BYTE        bySignalField;
 493     BYTE        byServiceField;
 494     WORD        wTransmitLength;
 495     WORD        wDuration;
 496     WORD        wReserved;
 497     SRTSData    Data;
 498 }__attribute__ ((__packed__))
 499 SRTS_ab, *PSRTS_ab;
 500 typedef const SRTS_ab *PCSRTS_ab;
 501
 502
 503 typedef struct tagSRTS_a_FB {
 504     BYTE        bySignalField;
 505     BYTE        byServiceField;
 506     WORD        wTransmitLength;
 507     WORD        wDuration;
 508     WORD        wReserved;
 509     WORD        wRTSDuration_f0;
 510     WORD        wRTSDuration_f1;
 511     SRTSData    Data;
 512 }__attribute__ ((__packed__))
 513 SRTS_a_FB, *PSRTS_a_FB;
 514 typedef const SRTS_a_FB *PCSRTS_a_FB;
 515
 516
 517 //
 518 // CTS buffer header
 519 //
 520 typedef struct tagSCTSData {
 521     WORD    wFrameControl;
 522     WORD    wDurationID;
 523     BYTE    abyRA[U_ETHER_ADDR_LEN];
 524     WORD    wReserved;
 525 }__attribute__ ((__packed__))
 526 SCTSData, *PSCTSData;
 527
 528 typedef struct tagSCTS {
 529     BYTE        bySignalField_b;
 530     BYTE        byServiceField_b;
 531     WORD        wTransmitLength_b;
 532     WORD        wDuration_ba;
 533     WORD        wReserved;
 534     SCTSData    Data;
 535 }__attribute__ ((__packed__))
 536 SCTS, *PSCTS;
 537 typedef const SCTS *PCSCTS;
 538
 539 typedef struct tagSCTS_FB {
 540     BYTE        bySignalField_b;
 541     BYTE        byServiceField_b;
 542     WORD        wTransmitLength_b;
 543     WORD        wDuration_ba;
 544     WORD        wReserved;
 545     WORD        wCTSDuration_ba_f0;
 546     WORD        wCTSDuration_ba_f1;
 547     SCTSData    Data;
 548 }__attribute__ ((__packed__))
 549 SCTS_FB, *PSCTS_FB;
 550 typedef const SCTS_FB *PCSCTS_FB;
 551
 552
 553 //
 554 // Tx FIFO header
 555 //
 556 typedef struct tagSTxBufHead {
 557     DWORD   adwTxKey[4];
 558     WORD    wFIFOCtl;
 559     WORD    wTimeStamp;
 560     WORD    wFragCtl;
 561     BYTE    byTxPower;
 562     BYTE    wReserved;
 563 }__attribute__ ((__packed__))
 564 STxBufHead, *PSTxBufHead;
 565 typedef const STxBufHead *PCSTxBufHead;
 566
 567 typedef struct tagSTxShortBufHead {
 568     WORD    wFIFOCtl;
 569     WORD    wTimeStamp;
 570 }__attribute__ ((__packed__))
 571 STxShortBufHead, *PSTxShortBufHead;
 572 typedef const STxShortBufHead *PCSTxShortBufHead;
 573
 574 //
 575 // Tx data header
 576 //
 577 typedef struct tagSTxDataHead_g {
 578     BYTE    bySignalField_b;
 579     BYTE    byServiceField_b;
 580     WORD    wTransmitLength_b;
 581     BYTE    bySignalField_a;
 582     BYTE    byServiceField_a;
 583     WORD    wTransmitLength_a;
 584     WORD    wDuration_b;
 585     WORD    wDuration_a;
 586     WORD    wTimeStampOff_b;
 587     WORD    wTimeStampOff_a;
 588 }__attribute__ ((__packed__))
 589 STxDataHead_g, *PSTxDataHead_g;
 590 typedef const STxDataHead_g *PCSTxDataHead_g;
 591
 592 typedef struct tagSTxDataHead_g_FB {
 593     BYTE    bySignalField_b;
 594     BYTE    byServiceField_b;
 595     WORD    wTransmitLength_b;
 596     BYTE    bySignalField_a;
 597     BYTE    byServiceField_a;
 598     WORD    wTransmitLength_a;
 599     WORD    wDuration_b;
 600     WORD    wDuration_a;
 601     WORD    wDuration_a_f0;
 602     WORD    wDuration_a_f1;
 603     WORD    wTimeStampOff_b;
 604     WORD    wTimeStampOff_a;
 605 }__attribute__ ((__packed__))
 606 STxDataHead_g_FB, *PSTxDataHead_g_FB;
 607 typedef const STxDataHead_g_FB *PCSTxDataHead_g_FB;
 608
 609
 610 typedef struct tagSTxDataHead_ab {
 611     BYTE    bySignalField;
 612     BYTE    byServiceField;
 613     WORD    wTransmitLength;
 614     WORD    wDuration;
 615     WORD    wTimeStampOff;
 616 }__attribute__ ((__packed__))
 617 STxDataHead_ab, *PSTxDataHead_ab;
 618 typedef const STxDataHead_ab *PCSTxDataHead_ab;
 619
 620
 621 typedef struct tagSTxDataHead_a_FB {
 622     BYTE    bySignalField;
 623     BYTE    byServiceField;
 624     WORD    wTransmitLength;
 625     WORD    wDuration;
 626     WORD    wTimeStampOff;
 627     WORD    wDuration_f0;
 628     WORD    wDuration_f1;
 629 }__attribute__ ((__packed__))
 630 STxDataHead_a_FB, *PSTxDataHead_a_FB;
 631 typedef const STxDataHead_a_FB *PCSTxDataHead_a_FB;
 632
 633 //
 634 // MICHDR data header
 635 //
 636 typedef struct tagSMICHDRHead {
 637     DWORD   adwHDR0[4];
 638     DWORD   adwHDR1[4];
 639     DWORD   adwHDR2[4];
 640 }__attribute__ ((__packed__))
 641 SMICHDRHead, *PSMICHDRHead;
 642 typedef const SMICHDRHead *PCSMICHDRHead;
 643
 644 typedef struct tagSBEACONCtl {
 645     DWORD   BufReady : 1;
 646     DWORD   TSF      : 15;
 647     DWORD   BufLen   : 11;
 648     DWORD   Reserved : 5;
 649 }__attribute__ ((__packed__))
 650 SBEACONCtl;
 651
 652
 653 typedef struct tagSSecretKey {
 654     DWORD   dwLowDword;
 655     BYTE    byHighByte;
 656 }__attribute__ ((__packed__))
 657 SSecretKey;
 658
 659 typedef struct tagSKeyEntry {
 660     BYTE  abyAddrHi[2];
 661     WORD  wKCTL;
 662     BYTE  abyAddrLo[4];
 663     DWORD dwKey0[4];
 664     DWORD dwKey1[4];
 665     DWORD dwKey2[4];
 666     DWORD dwKey3[4];
 667     DWORD dwKey4[4];
 668 }__attribute__ ((__packed__))
 669 SKeyEntry;
 670 /*---------------------  Export Macros ------------------------------*/
 671
 672 /*---------------------  Export Classes  ----------------------------*/
 673
 674 /*---------------------  Export Variables  --------------------------*/
 675
 676 /*---------------------  Export Functions  --------------------------*/
 677
 678
 679
 680
 681 #endif // __DESC_H__
 682