/********************************************************************************
 * Marvell GPL License Option
 *
 * If you received this File from Marvell, you may opt to use, redistribute and/or
 * modify this File in accordance with the terms and conditions of the General
 * Public License Version 2, June 1991 (the "GPL License"), a copy of which is
 * available along with the File in the license.txt file or by writing to the Free
 * Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 or
 * on the worldwide web at http://www.gnu.org/licenses/gpl.txt.
 *
 * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE ARE EXPRESSLY
 * DISCLAIMED.  The GPL License provides additional details about this warranty
 * disclaimer.
 ******************************************************************************/

//////
/// don't edit! auto-generated by docc: FigoBypassMsg.h
////////////////////////////////////////////////////////////
#ifndef FigoBypassMsg_h
#define FigoBypassMsg_h (){}


#include "ctypes.h"

#pragma pack(1)
#ifdef __cplusplus
  extern "C" {
#endif

#ifndef _DOCC_H_BITOPS_
#define _DOCC_H_BITOPS_ (){}

    #define _bSETMASK_(b)                                      ((b)<32 ? (1<<((b)&31)) : 0)
    #define _NSETMASK_(msb,lsb)                                (_bSETMASK_((msb)+1)-_bSETMASK_(lsb))
    #define _bCLRMASK_(b)                                      (~_bSETMASK_(b))
    #define _NCLRMASK_(msb,lsb)                                (~_NSETMASK_(msb,lsb))
    #define _BFGET_(r,msb,lsb)                                 (_NSETMASK_((msb)-(lsb),0)&((r)>>(lsb)))
    #define _BFSET_(r,msb,lsb,v)                               do{ (r)&=_NCLRMASK_(msb,lsb); (r)|=_NSETMASK_(msb,lsb)&((v)<<(lsb)); }while(0)

#endif


//////
/// 
/// $INTERFACE FigoBypassMsgId                          (4,4)
///     ###
///     * Bypass Message IDs for all FIGOs
///     ###
///     # # ----------------------------------------------------------
///               : CFG                0x0
///               : RF64CFG0           0x1
///               : RF64CFG1           0x2
///               : A64PUSH0           0x3
///               : A64PUSH1           0x4
///               : A64POP             0x5
///               : END                0xFE
///                            ###
///                            * Bypass Message IDs for pCube FIGO
///                            ###
///               : P3CLR              0x20
///               : P3END              0x21
///               : P3RA0              0x22
///               : P3RA1              0x23
///               : P3WA0              0x24
///               : P3WA1              0x25
///               : P3CMD0             0x26
///               : P3CMD1             0x27
///               : P3SEM              0x28
///               : P3CFG              0xFF
///     @ 0x00000 dummy                (P)
///               %unsigned 1  dummy                     
///               %%        31         # Stuffing bits...
///     # # ----------------------------------------------------------
/// $ENDOFINTERFACE  # size:       4B, bits:       1b, padding:     0B
////////////////////////////////////////////////////////////
#ifndef h_FigoBypassMsgId
#define h_FigoBypassMsgId (){}

    #define        FigoBypassMsgId_CFG                         0x0
    #define        FigoBypassMsgId_RF64CFG0                    0x1
    #define        FigoBypassMsgId_RF64CFG1                    0x2
    #define        FigoBypassMsgId_A64PUSH0                    0x3
    #define        FigoBypassMsgId_A64PUSH1                    0x4
    #define        FigoBypassMsgId_A64POP                      0x5
    #define        FigoBypassMsgId_END                         0xFE
    #define        FigoBypassMsgId_P3CLR                       0x20
    #define        FigoBypassMsgId_P3END                       0x21
    #define        FigoBypassMsgId_P3RA0                       0x22
    #define        FigoBypassMsgId_P3RA1                       0x23
    #define        FigoBypassMsgId_P3WA0                       0x24
    #define        FigoBypassMsgId_P3WA1                       0x25
    #define        FigoBypassMsgId_P3CMD0                      0x26
    #define        FigoBypassMsgId_P3CMD1                      0x27
    #define        FigoBypassMsgId_P3SEM                       0x28
    #define        FigoBypassMsgId_P3CFG                       0xFF
    ///////////////////////////////////////////////////////////
    #define     RA_FigoBypassMsgId_dummy                       0x0000

    #define     BA_FigoBypassMsgId_dummy_dummy                 0x0000
    #define     B16FigoBypassMsgId_dummy_dummy                 0x0000
    #define   LSb32FigoBypassMsgId_dummy_dummy                    0
    #define   LSb16FigoBypassMsgId_dummy_dummy                    0
    #define       bFigoBypassMsgId_dummy_dummy                 1
    #define   MSK32FigoBypassMsgId_dummy_dummy                    0x00000001
    ///////////////////////////////////////////////////////////

    typedef struct SIE_FigoBypassMsgId {
    ///////////////////////////////////////////////////////////
    #define   GET32FigoBypassMsgId_dummy_dummy(r32)            _BFGET_(r32, 0, 0)
    #define   SET32FigoBypassMsgId_dummy_dummy(r32,v)          _BFSET_(r32, 0, 0,v)
    #define   GET16FigoBypassMsgId_dummy_dummy(r16)            _BFGET_(r16, 0, 0)
    #define   SET16FigoBypassMsgId_dummy_dummy(r16,v)          _BFSET_(r16, 0, 0,v)

    #define     w32FigoBypassMsgId_dummy                       {\
            UNSG32 udummy_dummy                                :  1;\
            UNSG32 RSVDx0_b1                                   : 31;\
          }
    union { UNSG32 u32FigoBypassMsgId_dummy;
            struct w32FigoBypassMsgId_dummy;
          };
    ///////////////////////////////////////////////////////////
    } SIE_FigoBypassMsgId;

    typedef union  T32FigoBypassMsgId_dummy
          { UNSG32 u32;
            struct w32FigoBypassMsgId_dummy;
                 } T32FigoBypassMsgId_dummy;
    ///////////////////////////////////////////////////////////

    typedef union  TFigoBypassMsgId_dummy
          { UNSG32 u32[1];
            struct {
            struct w32FigoBypassMsgId_dummy;
                   };
                 } TFigoBypassMsgId_dummy;

    ///////////////////////////////////////////////////////////
     SIGN32 FigoBypassMsgId_drvrd(SIE_FigoBypassMsgId *p, UNSG32 base, SIGN32 mem, SIGN32 tst);
     SIGN32 FigoBypassMsgId_drvwr(SIE_FigoBypassMsgId *p, UNSG32 base, SIGN32 mem, SIGN32 tst, UNSG32 *pcmd);
       void FigoBypassMsgId_reset(SIE_FigoBypassMsgId *p);
     SIGN32 FigoBypassMsgId_cmp  (SIE_FigoBypassMsgId *p, SIE_FigoBypassMsgId *pie, char *pfx, void *hLOG, SIGN32 mem, SIGN32 tst);
    #define FigoBypassMsgId_check(p,pie,pfx,hLOG) FigoBypassMsgId_cmp(p,pie,pfx,(void*)(hLOG),0,0)
    #define FigoBypassMsgId_print(p,    pfx,hLOG) FigoBypassMsgId_cmp(p,0,  pfx,(void*)(hLOG),0,0)

#endif
//////
/// ENDOFINTERFACE: FigoBypassMsgId
////////////////////////////////////////////////////////////

//////
/// 
/// $INTERFACE BypassMsgCfg            biu              (4,4)
///     # # ----------------------------------------------------------
///     @ 0x00000                      (P)
///               %unsigned 32 data                      
///                                    ###
///                                    * 32-bit data
///                                    ###
///               %unsigned 24 addr                      
///                                    ###
///                                    * 24-bit address
///                                    ###
///               %unsigned 8  id                        
///                                    ###
///                                    * Message ID
///                                    ###
///     # # ----------------------------------------------------------
/// $ENDOFINTERFACE  # size:       8B, bits:      64b, padding:     0B
////////////////////////////////////////////////////////////
#ifndef h_BypassMsgCfg
#define h_BypassMsgCfg (){}

    #define     BA_BypassMsgCfg_data                           0x0000
    #define     B16BypassMsgCfg_data                           0x0000
    #define   LSb32BypassMsgCfg_data                              0
    #define   LSb16BypassMsgCfg_data                              0
    #define       bBypassMsgCfg_data                           32
    #define   MSK32BypassMsgCfg_data                              0xFFFFFFFF

    #define     BA_BypassMsgCfg_addr                           0x0004
    #define     B16BypassMsgCfg_addr                           0x0004
    #define   LSb32BypassMsgCfg_addr                              0
    #define   LSb16BypassMsgCfg_addr                              0
    #define       bBypassMsgCfg_addr                           24
    #define   MSK32BypassMsgCfg_addr                              0x00FFFFFF

    #define     BA_BypassMsgCfg_id                             0x0007
    #define     B16BypassMsgCfg_id                             0x0006
    #define   LSb32BypassMsgCfg_id                                24
    #define   LSb16BypassMsgCfg_id                                8
    #define       bBypassMsgCfg_id                             8
    #define   MSK32BypassMsgCfg_id                                0xFF000000
    ///////////////////////////////////////////////////////////

    typedef struct SIE_BypassMsgCfg {
    ///////////////////////////////////////////////////////////
    #define   GET32BypassMsgCfg_data(r32)                      _BFGET_(r32,31, 0)
    #define   SET32BypassMsgCfg_data(r32,v)                    _BFSET_(r32,31, 0,v)

            UNSG32 u_data                                      : 32;
    ///////////////////////////////////////////////////////////

    #define   GET32BypassMsgCfg_addr(r32)                      _BFGET_(r32,23, 0)
    #define   SET32BypassMsgCfg_addr(r32,v)                    _BFSET_(r32,23, 0,v)

    #define   GET32BypassMsgCfg_id(r32)                        _BFGET_(r32,31,24)
    #define   SET32BypassMsgCfg_id(r32,v)                      _BFSET_(r32,31,24,v)
    #define   GET16BypassMsgCfg_id(r16)                        _BFGET_(r16,15, 8)
    #define   SET16BypassMsgCfg_id(r16,v)                      _BFSET_(r16,15, 8,v)

            UNSG32 u_addr                                      : 24;
            UNSG32 u_id                                        :  8;
    ///////////////////////////////////////////////////////////
    } SIE_BypassMsgCfg;

    ///////////////////////////////////////////////////////////
     SIGN32 BypassMsgCfg_drvrd(SIE_BypassMsgCfg *p, UNSG32 base, SIGN32 mem, SIGN32 tst);
     SIGN32 BypassMsgCfg_drvwr(SIE_BypassMsgCfg *p, UNSG32 base, SIGN32 mem, SIGN32 tst, UNSG32 *pcmd);
       void BypassMsgCfg_reset(SIE_BypassMsgCfg *p);
     SIGN32 BypassMsgCfg_cmp  (SIE_BypassMsgCfg *p, SIE_BypassMsgCfg *pie, char *pfx, void *hLOG, SIGN32 mem, SIGN32 tst);
    #define BypassMsgCfg_check(p,pie,pfx,hLOG) BypassMsgCfg_cmp(p,pie,pfx,(void*)(hLOG),0,0)
    #define BypassMsgCfg_print(p,    pfx,hLOG) BypassMsgCfg_cmp(p,0,  pfx,(void*)(hLOG),0,0)

#endif
//////
/// ENDOFINTERFACE: BypassMsgCfg
////////////////////////////////////////////////////////////

//////
/// 
/// $INTERFACE BypassMsgRF64Cfg0       biu              (4,4)
///     # # ----------------------------------------------------------
///     @ 0x00000                      (P)
///               %unsigned 32 lo32                      
///                                    ###
///                                    * Low 32-bit data
///                                    ###
///               %unsigned 24 rsvd                      
///                                    ###
///                                    * Reserved
///                                    ###
///               %unsigned 8  id                        
///                                    ###
///                                    * Message ID
///                                    ###
///     # # ----------------------------------------------------------
/// $ENDOFINTERFACE  # size:       8B, bits:      64b, padding:     0B
////////////////////////////////////////////////////////////
#ifndef h_BypassMsgRF64Cfg0
#define h_BypassMsgRF64Cfg0 (){}

    #define     BA_BypassMsgRF64Cfg0_lo32                      0x0000
    #define     B16BypassMsgRF64Cfg0_lo32                      0x0000
    #define   LSb32BypassMsgRF64Cfg0_lo32                         0
    #define   LSb16BypassMsgRF64Cfg0_lo32                         0
    #define       bBypassMsgRF64Cfg0_lo32                      32
    #define   MSK32BypassMsgRF64Cfg0_lo32                         0xFFFFFFFF

    #define     BA_BypassMsgRF64Cfg0_rsvd                      0x0004
    #define     B16BypassMsgRF64Cfg0_rsvd                      0x0004
    #define   LSb32BypassMsgRF64Cfg0_rsvd                         0
    #define   LSb16BypassMsgRF64Cfg0_rsvd                         0
    #define       bBypassMsgRF64Cfg0_rsvd                      24
    #define   MSK32BypassMsgRF64Cfg0_rsvd                         0x00FFFFFF

    #define     BA_BypassMsgRF64Cfg0_id                        0x0007
    #define     B16BypassMsgRF64Cfg0_id                        0x0006
    #define   LSb32BypassMsgRF64Cfg0_id                           24
    #define   LSb16BypassMsgRF64Cfg0_id                           8
    #define       bBypassMsgRF64Cfg0_id                        8
    #define   MSK32BypassMsgRF64Cfg0_id                           0xFF000000
    ///////////////////////////////////////////////////////////

    typedef struct SIE_BypassMsgRF64Cfg0 {
    ///////////////////////////////////////////////////////////
    #define   GET32BypassMsgRF64Cfg0_lo32(r32)                 _BFGET_(r32,31, 0)
    #define   SET32BypassMsgRF64Cfg0_lo32(r32,v)               _BFSET_(r32,31, 0,v)

            UNSG32 u_lo32                                      : 32;
    ///////////////////////////////////////////////////////////

    #define   GET32BypassMsgRF64Cfg0_rsvd(r32)                 _BFGET_(r32,23, 0)
    #define   SET32BypassMsgRF64Cfg0_rsvd(r32,v)               _BFSET_(r32,23, 0,v)

    #define   GET32BypassMsgRF64Cfg0_id(r32)                   _BFGET_(r32,31,24)
    #define   SET32BypassMsgRF64Cfg0_id(r32,v)                 _BFSET_(r32,31,24,v)
    #define   GET16BypassMsgRF64Cfg0_id(r16)                   _BFGET_(r16,15, 8)
    #define   SET16BypassMsgRF64Cfg0_id(r16,v)                 _BFSET_(r16,15, 8,v)

            UNSG32 u_rsvd                                      : 24;
            UNSG32 u_id                                        :  8;
    ///////////////////////////////////////////////////////////
    } SIE_BypassMsgRF64Cfg0;

    ///////////////////////////////////////////////////////////
     SIGN32 BypassMsgRF64Cfg0_drvrd(SIE_BypassMsgRF64Cfg0 *p, UNSG32 base, SIGN32 mem, SIGN32 tst);
     SIGN32 BypassMsgRF64Cfg0_drvwr(SIE_BypassMsgRF64Cfg0 *p, UNSG32 base, SIGN32 mem, SIGN32 tst, UNSG32 *pcmd);
       void BypassMsgRF64Cfg0_reset(SIE_BypassMsgRF64Cfg0 *p);
     SIGN32 BypassMsgRF64Cfg0_cmp  (SIE_BypassMsgRF64Cfg0 *p, SIE_BypassMsgRF64Cfg0 *pie, char *pfx, void *hLOG, SIGN32 mem, SIGN32 tst);
    #define BypassMsgRF64Cfg0_check(p,pie,pfx,hLOG) BypassMsgRF64Cfg0_cmp(p,pie,pfx,(void*)(hLOG),0,0)
    #define BypassMsgRF64Cfg0_print(p,    pfx,hLOG) BypassMsgRF64Cfg0_cmp(p,0,  pfx,(void*)(hLOG),0,0)

#endif
//////
/// ENDOFINTERFACE: BypassMsgRF64Cfg0
////////////////////////////////////////////////////////////

//////
/// 
/// $INTERFACE BypassMsgRF64Cfg1       biu              (4,4)
///     # # ----------------------------------------------------------
///     @ 0x00000                      (P)
///               %unsigned 32 hi32                      
///                                    ###
///                                    * High 32-bit data
///                                    ###
///               %unsigned 6  addr                      
///                                    ###
///                                    * 6-bit address
///                                    ###
///               %unsigned 18 rsvd                      
///                                    ###
///                                    * Reserved
///                                    ###
///               %unsigned 8  id                        
///                                    ###
///                                    * Message ID
///                                    ###
///     # # ----------------------------------------------------------
/// $ENDOFINTERFACE  # size:       8B, bits:      64b, padding:     0B
////////////////////////////////////////////////////////////
#ifndef h_BypassMsgRF64Cfg1
#define h_BypassMsgRF64Cfg1 (){}

    #define     BA_BypassMsgRF64Cfg1_hi32                      0x0000
    #define     B16BypassMsgRF64Cfg1_hi32                      0x0000
    #define   LSb32BypassMsgRF64Cfg1_hi32                         0
    #define   LSb16BypassMsgRF64Cfg1_hi32                         0
    #define       bBypassMsgRF64Cfg1_hi32                      32
    #define   MSK32BypassMsgRF64Cfg1_hi32                         0xFFFFFFFF

    #define     BA_BypassMsgRF64Cfg1_addr                      0x0004
    #define     B16BypassMsgRF64Cfg1_addr                      0x0004
    #define   LSb32BypassMsgRF64Cfg1_addr                         0
    #define   LSb16BypassMsgRF64Cfg1_addr                         0
    #define       bBypassMsgRF64Cfg1_addr                      6
    #define   MSK32BypassMsgRF64Cfg1_addr                         0x0000003F

    #define     BA_BypassMsgRF64Cfg1_rsvd                      0x0004
    #define     B16BypassMsgRF64Cfg1_rsvd                      0x0004
    #define   LSb32BypassMsgRF64Cfg1_rsvd                         6
    #define   LSb16BypassMsgRF64Cfg1_rsvd                         6
    #define       bBypassMsgRF64Cfg1_rsvd                      18
    #define   MSK32BypassMsgRF64Cfg1_rsvd                         0x00FFFFC0

    #define     BA_BypassMsgRF64Cfg1_id                        0x0007
    #define     B16BypassMsgRF64Cfg1_id                        0x0006
    #define   LSb32BypassMsgRF64Cfg1_id                           24
    #define   LSb16BypassMsgRF64Cfg1_id                           8
    #define       bBypassMsgRF64Cfg1_id                        8
    #define   MSK32BypassMsgRF64Cfg1_id                           0xFF000000
    ///////////////////////////////////////////////////////////

    typedef struct SIE_BypassMsgRF64Cfg1 {
    ///////////////////////////////////////////////////////////
    #define   GET32BypassMsgRF64Cfg1_hi32(r32)                 _BFGET_(r32,31, 0)
    #define   SET32BypassMsgRF64Cfg1_hi32(r32,v)               _BFSET_(r32,31, 0,v)

            UNSG32 u_hi32                                      : 32;
    ///////////////////////////////////////////////////////////

    #define   GET32BypassMsgRF64Cfg1_addr(r32)                 _BFGET_(r32, 5, 0)
    #define   SET32BypassMsgRF64Cfg1_addr(r32,v)               _BFSET_(r32, 5, 0,v)
    #define   GET16BypassMsgRF64Cfg1_addr(r16)                 _BFGET_(r16, 5, 0)
    #define   SET16BypassMsgRF64Cfg1_addr(r16,v)               _BFSET_(r16, 5, 0,v)

    #define   GET32BypassMsgRF64Cfg1_rsvd(r32)                 _BFGET_(r32,23, 6)
    #define   SET32BypassMsgRF64Cfg1_rsvd(r32,v)               _BFSET_(r32,23, 6,v)

    #define   GET32BypassMsgRF64Cfg1_id(r32)                   _BFGET_(r32,31,24)
    #define   SET32BypassMsgRF64Cfg1_id(r32,v)                 _BFSET_(r32,31,24,v)
    #define   GET16BypassMsgRF64Cfg1_id(r16)                   _BFGET_(r16,15, 8)
    #define   SET16BypassMsgRF64Cfg1_id(r16,v)                 _BFSET_(r16,15, 8,v)

            UNSG32 u_addr                                      :  6;
            UNSG32 u_rsvd                                      : 18;
            UNSG32 u_id                                        :  8;
    ///////////////////////////////////////////////////////////
    } SIE_BypassMsgRF64Cfg1;

    ///////////////////////////////////////////////////////////
     SIGN32 BypassMsgRF64Cfg1_drvrd(SIE_BypassMsgRF64Cfg1 *p, UNSG32 base, SIGN32 mem, SIGN32 tst);
     SIGN32 BypassMsgRF64Cfg1_drvwr(SIE_BypassMsgRF64Cfg1 *p, UNSG32 base, SIGN32 mem, SIGN32 tst, UNSG32 *pcmd);
       void BypassMsgRF64Cfg1_reset(SIE_BypassMsgRF64Cfg1 *p);
     SIGN32 BypassMsgRF64Cfg1_cmp  (SIE_BypassMsgRF64Cfg1 *p, SIE_BypassMsgRF64Cfg1 *pie, char *pfx, void *hLOG, SIGN32 mem, SIGN32 tst);
    #define BypassMsgRF64Cfg1_check(p,pie,pfx,hLOG) BypassMsgRF64Cfg1_cmp(p,pie,pfx,(void*)(hLOG),0,0)
    #define BypassMsgRF64Cfg1_print(p,    pfx,hLOG) BypassMsgRF64Cfg1_cmp(p,0,  pfx,(void*)(hLOG),0,0)

#endif
//////
/// ENDOFINTERFACE: BypassMsgRF64Cfg1
////////////////////////////////////////////////////////////

//////
/// 
/// $INTERFACE BypassMsgA64Push0       biu              (4,4)
///     # # ----------------------------------------------------------
///     @ 0x00000                      (P)
///               %unsigned 32 r16x4lo32                 
///                                    ###
///                                    * Low 32-bit of parameter r16x4
///                                    ###
///               %unsigned 16 r16                       
///                                    ###
///                                    * Parameter r16
///                                    ###
///               %unsigned 8  rsvd                      
///                                    ###
///                                    * Reserved
///                                    ###
///               %unsigned 8  id                        
///                                    ###
///                                    * Message ID
///                                    ###
///     # # ----------------------------------------------------------
/// $ENDOFINTERFACE  # size:       8B, bits:      64b, padding:     0B
////////////////////////////////////////////////////////////
#ifndef h_BypassMsgA64Push0
#define h_BypassMsgA64Push0 (){}

    #define     BA_BypassMsgA64Push0_r16x4lo32                 0x0000
    #define     B16BypassMsgA64Push0_r16x4lo32                 0x0000
    #define   LSb32BypassMsgA64Push0_r16x4lo32                    0
    #define   LSb16BypassMsgA64Push0_r16x4lo32                    0
    #define       bBypassMsgA64Push0_r16x4lo32                 32
    #define   MSK32BypassMsgA64Push0_r16x4lo32                    0xFFFFFFFF

    #define     BA_BypassMsgA64Push0_r16                       0x0004
    #define     B16BypassMsgA64Push0_r16                       0x0004
    #define   LSb32BypassMsgA64Push0_r16                          0
    #define   LSb16BypassMsgA64Push0_r16                          0
    #define       bBypassMsgA64Push0_r16                       16
    #define   MSK32BypassMsgA64Push0_r16                          0x0000FFFF

    #define     BA_BypassMsgA64Push0_rsvd                      0x0006
    #define     B16BypassMsgA64Push0_rsvd                      0x0006
    #define   LSb32BypassMsgA64Push0_rsvd                         16
    #define   LSb16BypassMsgA64Push0_rsvd                         0
    #define       bBypassMsgA64Push0_rsvd                      8
    #define   MSK32BypassMsgA64Push0_rsvd                         0x00FF0000

    #define     BA_BypassMsgA64Push0_id                        0x0007
    #define     B16BypassMsgA64Push0_id                        0x0006
    #define   LSb32BypassMsgA64Push0_id                           24
    #define   LSb16BypassMsgA64Push0_id                           8
    #define       bBypassMsgA64Push0_id                        8
    #define   MSK32BypassMsgA64Push0_id                           0xFF000000
    ///////////////////////////////////////////////////////////

    typedef struct SIE_BypassMsgA64Push0 {
    ///////////////////////////////////////////////////////////
    #define   GET32BypassMsgA64Push0_r16x4lo32(r32)            _BFGET_(r32,31, 0)
    #define   SET32BypassMsgA64Push0_r16x4lo32(r32,v)          _BFSET_(r32,31, 0,v)

            UNSG32 u_r16x4lo32                                 : 32;
    ///////////////////////////////////////////////////////////

    #define   GET32BypassMsgA64Push0_r16(r32)                  _BFGET_(r32,15, 0)
    #define   SET32BypassMsgA64Push0_r16(r32,v)                _BFSET_(r32,15, 0,v)
    #define   GET16BypassMsgA64Push0_r16(r16)                  _BFGET_(r16,15, 0)
    #define   SET16BypassMsgA64Push0_r16(r16,v)                _BFSET_(r16,15, 0,v)

    #define   GET32BypassMsgA64Push0_rsvd(r32)                 _BFGET_(r32,23,16)
    #define   SET32BypassMsgA64Push0_rsvd(r32,v)               _BFSET_(r32,23,16,v)
    #define   GET16BypassMsgA64Push0_rsvd(r16)                 _BFGET_(r16, 7, 0)
    #define   SET16BypassMsgA64Push0_rsvd(r16,v)               _BFSET_(r16, 7, 0,v)

    #define   GET32BypassMsgA64Push0_id(r32)                   _BFGET_(r32,31,24)
    #define   SET32BypassMsgA64Push0_id(r32,v)                 _BFSET_(r32,31,24,v)
    #define   GET16BypassMsgA64Push0_id(r16)                   _BFGET_(r16,15, 8)
    #define   SET16BypassMsgA64Push0_id(r16,v)                 _BFSET_(r16,15, 8,v)

            UNSG32 u_r16                                       : 16;
            UNSG32 u_rsvd                                      :  8;
            UNSG32 u_id                                        :  8;
    ///////////////////////////////////////////////////////////
    } SIE_BypassMsgA64Push0;

    ///////////////////////////////////////////////////////////
     SIGN32 BypassMsgA64Push0_drvrd(SIE_BypassMsgA64Push0 *p, UNSG32 base, SIGN32 mem, SIGN32 tst);
     SIGN32 BypassMsgA64Push0_drvwr(SIE_BypassMsgA64Push0 *p, UNSG32 base, SIGN32 mem, SIGN32 tst, UNSG32 *pcmd);
       void BypassMsgA64Push0_reset(SIE_BypassMsgA64Push0 *p);
     SIGN32 BypassMsgA64Push0_cmp  (SIE_BypassMsgA64Push0 *p, SIE_BypassMsgA64Push0 *pie, char *pfx, void *hLOG, SIGN32 mem, SIGN32 tst);
    #define BypassMsgA64Push0_check(p,pie,pfx,hLOG) BypassMsgA64Push0_cmp(p,pie,pfx,(void*)(hLOG),0,0)
    #define BypassMsgA64Push0_print(p,    pfx,hLOG) BypassMsgA64Push0_cmp(p,0,  pfx,(void*)(hLOG),0,0)

#endif
//////
/// ENDOFINTERFACE: BypassMsgA64Push0
////////////////////////////////////////////////////////////

//////
/// 
/// $INTERFACE BypassMsgA64Push1       biu              (4,4)
///     # # ----------------------------------------------------------
///     @ 0x00000                      (P)
///               %unsigned 32 r16x4hi32                 
///                                    ###
///                                    * High 32-bit of parameter r16x4
///                                    ###
///               %unsigned 8  c8                        
///                                    ###
///                                    * 8-bit extenstion ID
///                                    ###
///               %unsigned 6  q6                        
///                                    ###
///                                    * 6-bit constant
///                                    ###
///               %unsigned 10 rsvd                      
///                                    ###
///                                    * Reserved
///                                    ###
///               %unsigned 8  id                        
///                                    ###
///                                    * Message ID
///                                    ###
///     # # ----------------------------------------------------------
/// $ENDOFINTERFACE  # size:       8B, bits:      64b, padding:     0B
////////////////////////////////////////////////////////////
#ifndef h_BypassMsgA64Push1
#define h_BypassMsgA64Push1 (){}

    #define     BA_BypassMsgA64Push1_r16x4hi32                 0x0000
    #define     B16BypassMsgA64Push1_r16x4hi32                 0x0000
    #define   LSb32BypassMsgA64Push1_r16x4hi32                    0
    #define   LSb16BypassMsgA64Push1_r16x4hi32                    0
    #define       bBypassMsgA64Push1_r16x4hi32                 32
    #define   MSK32BypassMsgA64Push1_r16x4hi32                    0xFFFFFFFF

    #define     BA_BypassMsgA64Push1_c8                        0x0004
    #define     B16BypassMsgA64Push1_c8                        0x0004
    #define   LSb32BypassMsgA64Push1_c8                           0
    #define   LSb16BypassMsgA64Push1_c8                           0
    #define       bBypassMsgA64Push1_c8                        8
    #define   MSK32BypassMsgA64Push1_c8                           0x000000FF

    #define     BA_BypassMsgA64Push1_q6                        0x0005
    #define     B16BypassMsgA64Push1_q6                        0x0004
    #define   LSb32BypassMsgA64Push1_q6                           8
    #define   LSb16BypassMsgA64Push1_q6                           8
    #define       bBypassMsgA64Push1_q6                        6
    #define   MSK32BypassMsgA64Push1_q6                           0x00003F00

    #define     BA_BypassMsgA64Push1_rsvd                      0x0005
    #define     B16BypassMsgA64Push1_rsvd                      0x0004
    #define   LSb32BypassMsgA64Push1_rsvd                         14
    #define   LSb16BypassMsgA64Push1_rsvd                         14
    #define       bBypassMsgA64Push1_rsvd                      10
    #define   MSK32BypassMsgA64Push1_rsvd                         0x00FFC000

    #define     BA_BypassMsgA64Push1_id                        0x0007
    #define     B16BypassMsgA64Push1_id                        0x0006
    #define   LSb32BypassMsgA64Push1_id                           24
    #define   LSb16BypassMsgA64Push1_id                           8
    #define       bBypassMsgA64Push1_id                        8
    #define   MSK32BypassMsgA64Push1_id                           0xFF000000
    ///////////////////////////////////////////////////////////

    typedef struct SIE_BypassMsgA64Push1 {
    ///////////////////////////////////////////////////////////
    #define   GET32BypassMsgA64Push1_r16x4hi32(r32)            _BFGET_(r32,31, 0)
    #define   SET32BypassMsgA64Push1_r16x4hi32(r32,v)          _BFSET_(r32,31, 0,v)

            UNSG32 u_r16x4hi32                                 : 32;
    ///////////////////////////////////////////////////////////

    #define   GET32BypassMsgA64Push1_c8(r32)                   _BFGET_(r32, 7, 0)
    #define   SET32BypassMsgA64Push1_c8(r32,v)                 _BFSET_(r32, 7, 0,v)
    #define   GET16BypassMsgA64Push1_c8(r16)                   _BFGET_(r16, 7, 0)
    #define   SET16BypassMsgA64Push1_c8(r16,v)                 _BFSET_(r16, 7, 0,v)

    #define   GET32BypassMsgA64Push1_q6(r32)                   _BFGET_(r32,13, 8)
    #define   SET32BypassMsgA64Push1_q6(r32,v)                 _BFSET_(r32,13, 8,v)
    #define   GET16BypassMsgA64Push1_q6(r16)                   _BFGET_(r16,13, 8)
    #define   SET16BypassMsgA64Push1_q6(r16,v)                 _BFSET_(r16,13, 8,v)

    #define   GET32BypassMsgA64Push1_rsvd(r32)                 _BFGET_(r32,23,14)
    #define   SET32BypassMsgA64Push1_rsvd(r32,v)               _BFSET_(r32,23,14,v)

    #define   GET32BypassMsgA64Push1_id(r32)                   _BFGET_(r32,31,24)
    #define   SET32BypassMsgA64Push1_id(r32,v)                 _BFSET_(r32,31,24,v)
    #define   GET16BypassMsgA64Push1_id(r16)                   _BFGET_(r16,15, 8)
    #define   SET16BypassMsgA64Push1_id(r16,v)                 _BFSET_(r16,15, 8,v)

            UNSG32 u_c8                                        :  8;
            UNSG32 u_q6                                        :  6;
            UNSG32 u_rsvd                                      : 10;
            UNSG32 u_id                                        :  8;
    ///////////////////////////////////////////////////////////
    } SIE_BypassMsgA64Push1;

    ///////////////////////////////////////////////////////////
     SIGN32 BypassMsgA64Push1_drvrd(SIE_BypassMsgA64Push1 *p, UNSG32 base, SIGN32 mem, SIGN32 tst);
     SIGN32 BypassMsgA64Push1_drvwr(SIE_BypassMsgA64Push1 *p, UNSG32 base, SIGN32 mem, SIGN32 tst, UNSG32 *pcmd);
       void BypassMsgA64Push1_reset(SIE_BypassMsgA64Push1 *p);
     SIGN32 BypassMsgA64Push1_cmp  (SIE_BypassMsgA64Push1 *p, SIE_BypassMsgA64Push1 *pie, char *pfx, void *hLOG, SIGN32 mem, SIGN32 tst);
    #define BypassMsgA64Push1_check(p,pie,pfx,hLOG) BypassMsgA64Push1_cmp(p,pie,pfx,(void*)(hLOG),0,0)
    #define BypassMsgA64Push1_print(p,    pfx,hLOG) BypassMsgA64Push1_cmp(p,0,  pfx,(void*)(hLOG),0,0)

#endif
//////
/// ENDOFINTERFACE: BypassMsgA64Push1
////////////////////////////////////////////////////////////

//////
/// 
/// $INTERFACE BypassMsgA64Pop         biu              (4,4)
///     # # ----------------------------------------------------------
///     @ 0x00000                      (P)
///               %unsigned 16 r16                       
///                                    ###
///                                    * Parameter r16
///                                    ###
///               %unsigned 16 rsvd0                     
///                                    ###
///                                    * Reserved
///                                    ###
///               %unsigned 8  c8                        
///                                    ###
///                                    * 8-bit extension ID
///                                    ###
///               %unsigned 16 rsvd1                     
///                                    ###
///                                    * Reserved
///                                    ###
///               %unsigned 8  id                        
///                                    ###
///                                    * Message ID
///                                    ###
///     # # ----------------------------------------------------------
/// $ENDOFINTERFACE  # size:       8B, bits:      64b, padding:     0B
////////////////////////////////////////////////////////////
#ifndef h_BypassMsgA64Pop
#define h_BypassMsgA64Pop (){}

    #define     BA_BypassMsgA64Pop_r16                         0x0000
    #define     B16BypassMsgA64Pop_r16                         0x0000
    #define   LSb32BypassMsgA64Pop_r16                            0
    #define   LSb16BypassMsgA64Pop_r16                            0
    #define       bBypassMsgA64Pop_r16                         16
    #define   MSK32BypassMsgA64Pop_r16                            0x0000FFFF

    #define     BA_BypassMsgA64Pop_rsvd0                       0x0002
    #define     B16BypassMsgA64Pop_rsvd0                       0x0002
    #define   LSb32BypassMsgA64Pop_rsvd0                          16
    #define   LSb16BypassMsgA64Pop_rsvd0                          0
    #define       bBypassMsgA64Pop_rsvd0                       16
    #define   MSK32BypassMsgA64Pop_rsvd0                          0xFFFF0000

    #define     BA_BypassMsgA64Pop_c8                          0x0004
    #define     B16BypassMsgA64Pop_c8                          0x0004
    #define   LSb32BypassMsgA64Pop_c8                             0
    #define   LSb16BypassMsgA64Pop_c8                             0
    #define       bBypassMsgA64Pop_c8                          8
    #define   MSK32BypassMsgA64Pop_c8                             0x000000FF

    #define     BA_BypassMsgA64Pop_rsvd1                       0x0005
    #define     B16BypassMsgA64Pop_rsvd1                       0x0004
    #define   LSb32BypassMsgA64Pop_rsvd1                          8
    #define   LSb16BypassMsgA64Pop_rsvd1                          8
    #define       bBypassMsgA64Pop_rsvd1                       16
    #define   MSK32BypassMsgA64Pop_rsvd1                          0x00FFFF00

    #define     BA_BypassMsgA64Pop_id                          0x0007
    #define     B16BypassMsgA64Pop_id                          0x0006
    #define   LSb32BypassMsgA64Pop_id                             24
    #define   LSb16BypassMsgA64Pop_id                             8
    #define       bBypassMsgA64Pop_id                          8
    #define   MSK32BypassMsgA64Pop_id                             0xFF000000
    ///////////////////////////////////////////////////////////

    typedef struct SIE_BypassMsgA64Pop {
    ///////////////////////////////////////////////////////////
    #define   GET32BypassMsgA64Pop_r16(r32)                    _BFGET_(r32,15, 0)
    #define   SET32BypassMsgA64Pop_r16(r32,v)                  _BFSET_(r32,15, 0,v)
    #define   GET16BypassMsgA64Pop_r16(r16)                    _BFGET_(r16,15, 0)
    #define   SET16BypassMsgA64Pop_r16(r16,v)                  _BFSET_(r16,15, 0,v)

    #define   GET32BypassMsgA64Pop_rsvd0(r32)                  _BFGET_(r32,31,16)
    #define   SET32BypassMsgA64Pop_rsvd0(r32,v)                _BFSET_(r32,31,16,v)
    #define   GET16BypassMsgA64Pop_rsvd0(r16)                  _BFGET_(r16,15, 0)
    #define   SET16BypassMsgA64Pop_rsvd0(r16,v)                _BFSET_(r16,15, 0,v)

            UNSG32 u_r16                                       : 16;
            UNSG32 u_rsvd0                                     : 16;
    ///////////////////////////////////////////////////////////

    #define   GET32BypassMsgA64Pop_c8(r32)                     _BFGET_(r32, 7, 0)
    #define   SET32BypassMsgA64Pop_c8(r32,v)                   _BFSET_(r32, 7, 0,v)
    #define   GET16BypassMsgA64Pop_c8(r16)                     _BFGET_(r16, 7, 0)
    #define   SET16BypassMsgA64Pop_c8(r16,v)                   _BFSET_(r16, 7, 0,v)

    #define   GET32BypassMsgA64Pop_rsvd1(r32)                  _BFGET_(r32,23, 8)
    #define   SET32BypassMsgA64Pop_rsvd1(r32,v)                _BFSET_(r32,23, 8,v)

    #define   GET32BypassMsgA64Pop_id(r32)                     _BFGET_(r32,31,24)
    #define   SET32BypassMsgA64Pop_id(r32,v)                   _BFSET_(r32,31,24,v)
    #define   GET16BypassMsgA64Pop_id(r16)                     _BFGET_(r16,15, 8)
    #define   SET16BypassMsgA64Pop_id(r16,v)                   _BFSET_(r16,15, 8,v)

            UNSG32 u_c8                                        :  8;
            UNSG32 u_rsvd1                                     : 16;
            UNSG32 u_id                                        :  8;
    ///////////////////////////////////////////////////////////
    } SIE_BypassMsgA64Pop;

    ///////////////////////////////////////////////////////////
     SIGN32 BypassMsgA64Pop_drvrd(SIE_BypassMsgA64Pop *p, UNSG32 base, SIGN32 mem, SIGN32 tst);
     SIGN32 BypassMsgA64Pop_drvwr(SIE_BypassMsgA64Pop *p, UNSG32 base, SIGN32 mem, SIGN32 tst, UNSG32 *pcmd);
       void BypassMsgA64Pop_reset(SIE_BypassMsgA64Pop *p);
     SIGN32 BypassMsgA64Pop_cmp  (SIE_BypassMsgA64Pop *p, SIE_BypassMsgA64Pop *pie, char *pfx, void *hLOG, SIGN32 mem, SIGN32 tst);
    #define BypassMsgA64Pop_check(p,pie,pfx,hLOG) BypassMsgA64Pop_cmp(p,pie,pfx,(void*)(hLOG),0,0)
    #define BypassMsgA64Pop_print(p,    pfx,hLOG) BypassMsgA64Pop_cmp(p,0,  pfx,(void*)(hLOG),0,0)

#endif
//////
/// ENDOFINTERFACE: BypassMsgA64Pop
////////////////////////////////////////////////////////////

//////
/// 
/// $INTERFACE BypassMsgEnd            biu              (4,4)
///     # # ----------------------------------------------------------
///     @ 0x00000                      (P)
///               %unsigned 32 rsvd0                     
///                                    ###
///                                    * Reserved
///                                    ###
///               %unsigned 24 rsvd1                     
///                                    ###
///                                    * Reserved
///                                    ###
///               %unsigned 8  id                        
///                                    ###
///                                    * Message ID
///                                    ###
///     # # ----------------------------------------------------------
/// $ENDOFINTERFACE  # size:       8B, bits:      64b, padding:     0B
////////////////////////////////////////////////////////////
#ifndef h_BypassMsgEnd
#define h_BypassMsgEnd (){}

    #define     BA_BypassMsgEnd_rsvd0                          0x0000
    #define     B16BypassMsgEnd_rsvd0                          0x0000
    #define   LSb32BypassMsgEnd_rsvd0                             0
    #define   LSb16BypassMsgEnd_rsvd0                             0
    #define       bBypassMsgEnd_rsvd0                          32
    #define   MSK32BypassMsgEnd_rsvd0                             0xFFFFFFFF

    #define     BA_BypassMsgEnd_rsvd1                          0x0004
    #define     B16BypassMsgEnd_rsvd1                          0x0004
    #define   LSb32BypassMsgEnd_rsvd1                             0
    #define   LSb16BypassMsgEnd_rsvd1                             0
    #define       bBypassMsgEnd_rsvd1                          24
    #define   MSK32BypassMsgEnd_rsvd1                             0x00FFFFFF

    #define     BA_BypassMsgEnd_id                             0x0007
    #define     B16BypassMsgEnd_id                             0x0006
    #define   LSb32BypassMsgEnd_id                                24
    #define   LSb16BypassMsgEnd_id                                8
    #define       bBypassMsgEnd_id                             8
    #define   MSK32BypassMsgEnd_id                                0xFF000000
    ///////////////////////////////////////////////////////////

    typedef struct SIE_BypassMsgEnd {
    ///////////////////////////////////////////////////////////
    #define   GET32BypassMsgEnd_rsvd0(r32)                     _BFGET_(r32,31, 0)
    #define   SET32BypassMsgEnd_rsvd0(r32,v)                   _BFSET_(r32,31, 0,v)

            UNSG32 u_rsvd0                                     : 32;
    ///////////////////////////////////////////////////////////

    #define   GET32BypassMsgEnd_rsvd1(r32)                     _BFGET_(r32,23, 0)
    #define   SET32BypassMsgEnd_rsvd1(r32,v)                   _BFSET_(r32,23, 0,v)

    #define   GET32BypassMsgEnd_id(r32)                        _BFGET_(r32,31,24)
    #define   SET32BypassMsgEnd_id(r32,v)                      _BFSET_(r32,31,24,v)
    #define   GET16BypassMsgEnd_id(r16)                        _BFGET_(r16,15, 8)
    #define   SET16BypassMsgEnd_id(r16,v)                      _BFSET_(r16,15, 8,v)

            UNSG32 u_rsvd1                                     : 24;
            UNSG32 u_id                                        :  8;
    ///////////////////////////////////////////////////////////
    } SIE_BypassMsgEnd;

    ///////////////////////////////////////////////////////////
     SIGN32 BypassMsgEnd_drvrd(SIE_BypassMsgEnd *p, UNSG32 base, SIGN32 mem, SIGN32 tst);
     SIGN32 BypassMsgEnd_drvwr(SIE_BypassMsgEnd *p, UNSG32 base, SIGN32 mem, SIGN32 tst, UNSG32 *pcmd);
       void BypassMsgEnd_reset(SIE_BypassMsgEnd *p);
     SIGN32 BypassMsgEnd_cmp  (SIE_BypassMsgEnd *p, SIE_BypassMsgEnd *pie, char *pfx, void *hLOG, SIGN32 mem, SIGN32 tst);
    #define BypassMsgEnd_check(p,pie,pfx,hLOG) BypassMsgEnd_cmp(p,pie,pfx,(void*)(hLOG),0,0)
    #define BypassMsgEnd_print(p,    pfx,hLOG) BypassMsgEnd_cmp(p,0,  pfx,(void*)(hLOG),0,0)

#endif
//////
/// ENDOFINTERFACE: BypassMsgEnd
////////////////////////////////////////////////////////////


#ifdef __cplusplus
  }
#endif
#pragma  pack()

#endif
//////
/// ENDOFFILE: FigoBypassMsg.h
////////////////////////////////////////////////////////////