////////////////////////////////////////////////////////////////////////
//
//  sh7046f.h: SH2 7046F memory-mapped registers
//      version 1.3 (May 6, 2010)
//
//  (c) Hideki Kozima (xkozima@myu.ac.jp), subject to GPLv2
//

#ifndef SH7046_H
#define SH7046_H

typedef  unsigned int    uint;
typedef  unsigned short  ushort;
typedef  unsigned char   uchar;

struct st_sci {                                 //  struct SCI   
            union {                             //  SMR          
                uchar BYTE;                     //   Byte Access 
                struct {                        //   Bit  Access 
                    uchar CA  :1;               //     C/A       
                    uchar CHR :1;               //     CHR       
                    uchar PE  :1;               //     PE        
                    uchar OE  :1;               //     O/E       
                    uchar STOP:1;               //     STOP      
                    uchar MP  :1;               //     MP        
                    uchar CKS :2;               //     CKS       
                } BIT;                          //               
            } SMR;                              //               
            uchar BRR;                          //  BRR          
            union {                             //  SCR          
                uchar BYTE;                     //   Byte Access 
                struct {                        //   Bit  Access 
                    uchar TIE :1;               //     TIE       
                    uchar RIE :1;               //     RIE       
                    uchar TE  :1;               //     TE        
                    uchar RE  :1;               //     RE        
                    uchar MPIE:1;               //     MPIE      
                    uchar TEIE:1;               //     TEIE      
                    uchar CKE :2;               //     CKE       
                } BIT;                          //               
            } SCR;                              //               
            uchar TDR;                          //  TDR          
            union {                             //  SSR          
                uchar BYTE;                     //   Byte Access 
                struct {                        //   Bit  Access 
                    uchar TDRE:1;               //     TDRE      
                    uchar RDRF:1;               //     RDRF      
                    uchar ORER:1;               //     ORER      
                    uchar FER :1;               //     FER       
                    uchar PER :1;               //     PER       
                    uchar TEND:1;               //     TEND      
                    uchar MPB :1;               //     MPB       
                    uchar MPBT:1;               //     MPBT      
                } BIT;                          //               
            } SSR;                              //               
            uchar RDR;                          //  RDR          
            union {                             //  SDCR         
                uchar BYTE;                     //   Byte Access 
                struct {                        //   Bit  Access 
                    uchar     :4;               //               
                    uchar DIR :1;               //     DIR       
                    uchar     :3;               //               
                } BIT;                          //               
            } SDCR;                             //               
};                                              //               
struct st_mtu {                                 //  struct MTU   
            union {                             //  TSTR         
                uchar BYTE;                     //   Byte Access 
                struct {                        //   Bit  Access 
                    uchar CST4:1;               //     CST4      
                    uchar CST3:1;               //     CST3      
                    uchar     :3;               //               
                    uchar CST2:1;               //     CST2      
                    uchar CST1:1;               //     CST1      
                    uchar CST0:1;               //     CST0      
                } BIT;                          //               
            } TSTR;                             //               
            union {                             //  TSYR         
                uchar BYTE;                     //   Byte Access 
                struct {                        //   Bit  Access 
                    uchar SYNC4:1;              //     SYNC4     
                    uchar SYNC3:1;              //     SYNC3     
                    uchar      :3;              //               
                    uchar SYNC2:1;              //     SYNC2     
                    uchar SYNC1:1;              //     SYNC1     
                    uchar SYNC0:1;              //     SYNC0     
                } BIT;                          //               
            } TSYR;                             //               
};                                              //               
struct st_mtu0 {                                //  struct MTU0  
            union {                             //  TCR          
                uchar BYTE;                     //   Byte Access 
                struct {                        //   Bit  Access 
                    uchar CCLR:3;               //     CCLR      
                    uchar CKEG:2;               //     CKEG      
                    uchar TPSC:3;               //     TPSC      
                } BIT;                          //               
            } TCR;                              //               
            union {                             //  TMDR         
                uchar BYTE;                     //   Byte Access 
                struct {                        //   Bit  Access 
                    uchar    :2;                //               
                    uchar BFB:1;                //     BFB       
                    uchar BFA:1;                //     BFA       
                    uchar MD :4;                //     MD        
                } BIT;                          //               
            } TMDR;                             //               
            union {                             //  TIOR         
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     TIORH     
                    uchar L;                    //     TIORL     
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar IOB:4;                //     IOB       
                    uchar IOA:4;                //     IOA       
                    uchar IOD:4;                //     IOD       
                    uchar IOC:4;                //     IOC       
                } BIT;                          //               
            } TIOR;                             //               
            union {                             //  TIER         
                uchar BYTE;                     //   Byte Access 
                struct {                        //   Bit  Access 
                    uchar TTGE :1;              //     TTGE      
                    uchar      :1;              //               
                    uchar TCIEU:1;              //     TCIEU     
                    uchar TCIEV:1;              //     TCIEV     
                    uchar TGIED:1;              //     TGIED     
                    uchar TGIEC:1;              //     TGIEC     
                    uchar TGIEB:1;              //     TGIEB     
                    uchar TGIEA:1;              //     TGIEA     
                } BIT;                          //               
            } TIER;                             //               
            union {                             //  TSR          
                uchar BYTE;                     //   Byte Access 
                struct {                        //   Bit  Access 
                    uchar TCFD:1;               //     TCFD      
                    uchar     :1;               //               
                    uchar TCFU:1;               //     TCFU      
                    uchar TCFV:1;               //     TCFV      
                    uchar TGFD:1;               //     TGFD      
                    uchar TGFC:1;               //     TGFC      
                    uchar TGFB:1;               //     TGFB      
                    uchar TGFA:1;               //     TGFA      
                } BIT;                          //               
            } TSR;                              //               
            ushort TCNT;                        //  TCNT         
            ushort TGRA;                        //  TGRA         
            ushort TGRB;                        //  TGRB         
            ushort TGRC;                        //  TGRC         
            ushort TGRD;                        //  TGRD         
};                                              //               
struct st_mtu34 {                               //  struct MTU34 
            union {                             //  TCR_3        
                uchar BYTE;                     //   Byte Access 
                struct {                        //   Bit  Access 
                    uchar CCLR:3;               //     CCLR      
                    uchar CKEG:2;               //     CKEG      
                    uchar TPSC:3;               //     TPSC      
                } BIT;                          //               
            } TCR_3;                            //               
            union {                             //  TCR_4        
                uchar BYTE;                     //   Byte Access 
                struct {                        //   Bit  Access 
                    uchar CCLR:3;               //     CCLR      
                    uchar CKEG:2;               //     CKEG      
                    uchar TPSC:3;               //     TPSC      
                } BIT;                          //               
            } TCR_4;                            //               
            union {                             //  TMDR_3       
                uchar BYTE;                     //   Byte Access 
                struct {                        //   Bit  Access 
                    uchar    :2;                //               
                    uchar BFB:1;                //     BFB       
                    uchar BFA:1;                //     BFA       
                    uchar MD :4;                //     MD        
                } BIT;                          //               
            } TMDR_3;                           //               
            union {                             //  TMDR_4       
                uchar BYTE;                     //   Byte Access 
                struct {                        //   Bit  Access 
                    uchar    :2;                //               
                    uchar BFB:1;                //     BFB       
                    uchar BFA:1;                //     BFA       
                    uchar MD :4;                //     MD        
                } BIT;                          //               
            } TMDR_4;                           //               
            union {                             //  TIOR_3       
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     TIORH     
                    uchar L;                    //     TIORL     
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar IOB:4;                //     IOB       
                    uchar IOA:4;                //     IOA       
                    uchar IOD:4;                //     IOD       
                    uchar IOC:4;                //     IOC       
                } BIT;                          //               
            } TIOR_3;                           //               
            union {                             //  TIOR_4       
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     TIORH     
                    uchar L;                    //     TIORL     
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar IOB:4;                //     IOB       
                    uchar IOA:4;                //     IOA       
                    uchar IOD:4;                //     IOD       
                    uchar IOC:4;                //     IOC       
                } BIT;                          //               
            } TIOR_4;                           //               
            union {                             //  TIER_3       
                uchar BYTE;                     //   Byte Access 
                struct {                        //   Bit  Access 
                    uchar TTGE :1;              //     TTGE      
                    uchar      :1;              //               
                    uchar TCIEU:1;              //     TCIEU     
                    uchar TCIEV:1;              //     TCIEV     
                    uchar TGIED:1;              //     TGIED     
                    uchar TGIEC:1;              //     TGIEC     
                    uchar TGIEB:1;              //     TGIEB     
                    uchar TGIEA:1;              //     TGIEA     
                } BIT;                          //               
            } TIER_3;                           //               
            union {                             //  TIER_4       
                uchar BYTE;                     //   Byte Access 
                struct {                        //   Bit  Access 
                    uchar TTGE :1;              //     TTGE      
                    uchar      :1;              //               
                    uchar TCIEU:1;              //     TCIEU     
                    uchar TCIEV:1;              //     TCIEV     
                    uchar TGIED:1;              //     TGIED     
                    uchar TGIEC:1;              //     TGIEC     
                    uchar TGIEB:1;              //     TGIEB     
                    uchar TGIEA:1;              //     TGIEA     
                } BIT;                          //               
            } TIER_4;                           //               
            union {                             //  TOER         
                uchar BYTE;                     //   Byte Access 
                struct {                        //   Bit  Access 
                    uchar     :2;               //               
                    uchar OE4D:1;               //     OE4D      
                    uchar OE4C:1;               //     OE4C      
                    uchar OE3D:1;               //     OE3D      
                    uchar OE4B:1;               //     OE4B      
                    uchar OE4A:1;               //     OE4A      
                    uchar OE3B:1;               //     OE3BA     
                } BIT;                          //               
            } TOER;                             //               
            union {                             //  TOCR         
                uchar BYTE;                     //   Byte Access 
                struct {                        //   Bit  Access 
                    uchar     :1;               //               
                    uchar PSYE:1;               //     PSYE      
                    uchar     :4;               //               
                    uchar OLSN:1;               //     OLSN      
                    uchar OLSP:1;               //     OLSP      
                } BIT;                          //               
            } TOCR;                             //               
            char wk1[1];                        //               
            union {                             //  TGCR         
                uchar BYTE;                     //   Byte Access 
                struct {                        //   Bit  Access 
                    uchar     :1;               //               
                    uchar BDC :1;               //     BDC       
                    uchar N   :1;               //     N         
                    uchar P   :1;               //     P         
                    uchar FB  :1;               //     FB        
                    uchar WF  :1;               //     WF        
                    uchar VF  :1;               //     VF        
                    uchar UF  :1;               //     UF        
                } BIT;                          //               
            } TGCR;                             //               
            char wk2[2];                        //               
            ushort   TCNT_3;                    //  TCNT_3       
            ushort   TCNT_4;                    //  TCNT_4       
            ushort   TCDR;                      //  TCDR         
            ushort   TDDR;                      //  TDDR         
            ushort   TGRA_3;                    //  TGRA_3       
            ushort   TGRB_3;                    //  TGRB_3       
            ushort   TGRA_4;                    //  TGRA_4       
            ushort   TGRB_4;                    //  TGRB_4       
            ushort   TCNTS;                     //  TCNTS        
            ushort   TCBR;                      //  TCBR         
            ushort   TGRC_3;                    //  TGRC_3       
            ushort   TGRD_3;                    //  TGRD_3       
            ushort   TGRC_4;                    //  TGRC_4       
            ushort   TGRD_4;                    //  TGRD_4       
            union {                             //  TSR_3        
                uchar BYTE;                     //   Byte Access 
                struct {                        //   Bit  Access 
                    uchar TCFD:1;               //     TCFD      
                    uchar     :1;               //               
                    uchar TCFU:1;               //     TCFU      
                    uchar TCFV:1;               //     TCFV      
                    uchar TGFD:1;               //     TGFD      
                    uchar TGFC:1;               //     TGFC      
                    uchar TGFB:1;               //     TGFB      
                    uchar TGFA:1;               //     TGFA      
                } BIT;                          //               
            } TSR_3;                            //               
            union {                             //  TSR_4        
                uchar BYTE;                     //   Byte Access 
                struct {                        //   Bit  Access 
                    uchar TCFD:1;               //     TCFD      
                    uchar     :1;               //               
                    uchar TCFU:1;               //     TCFU      
                    uchar TCFV:1;               //     TCFV      
                    uchar TGFD:1;               //     TGFD      
                    uchar TGFC:1;               //     TGFC      
                    uchar TGFB:1;               //     TGFB      
                    uchar TGFA:1;               //     TGFA      
                } BIT;                          //               
            } TSR_4;                            //               
};                                              //               
struct st_intc {                                //  struct INTC  
            union {                             //  IPRA         
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar UU:4;                 //     IRQ0      
                    uchar UL:4;                 //     IRQ1      
                    uchar LU:4;                 //     IRQ2      
                    uchar LL:4;                 //     IRQ3      
                } BIT;                          //               
            } IPRA;                             //               
            char wk1[4];                        //               
            union {                             //  IPRD         
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar UU:4;                 //     MTU0      
                    uchar UL:4;                 //     MTU0      
                    uchar LU:4;                 //     MTU1      
                    uchar LL:4;                 //     MTU1      
                } BIT;                          //               
            } IPRD;                             //               
            union {                             //  IPRE         
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar UU:4;                 //     MTU2      
                    uchar UL:4;                 //     MTU2      
                    uchar LU:4;                 //     MTU3      
                    uchar LL:4;                 //     MTU3      
                } BIT;                          //               
            } IPRE;                             //               
            union {                             //  IPRF         
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar UU:4;                 //     MTU4      
                    uchar UL:4;                 //     MTU4      
                    uchar   :8;                 //               
                } BIT;                          //               
            } IPRF;                             //               
            union {                             //  IPRG         
                ushort WORD;                    //   Word Access 
                struct {                        //   Bit  Access 
                    uchar UU:4;                 //     A/D       
                    uchar UL:4;                 //     DTC       
                    uchar LU:4;                 //     CMT0      
                    uchar LL:4;                 //     CMT1      
                } BIT;                          //               
            } IPRG;                             //               
            union {                             //  IPRH         
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar UU:4;                 //     WDT       
                    uchar UL:4;                 //     I/O(MTU)  
                    uchar   :8;                 //               
                } BIT;                          //               
            } IPRH;                             //               
            union {                             //  ICR1         
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar NMIL :1;              //     NMIL      
                    uchar      :6;              //               
                    uchar NMIE :1;              //     NMIE      
                    uchar IRQ0S:1;              //     IRQ0S     
                    uchar IRQ1S:1;              //     IRQ1S     
                    uchar IRQ2S:1;              //     IRQ2S     
                    uchar IRQ3S:1;              //     IRQ3S     
                    uchar      :4;              //               
                } BIT;                          //               
            } ICR1;                             //               
            union {                             //  ISR          
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar      :8;              //               
                    uchar IRQ0F:1;              //     IRQ0F     
                    uchar IRQ1F:1;              //     IRQ1F     
                    uchar IRQ2F:1;              //     IRQ2F     
                    uchar IRQ3F:1;              //     IRQ3F     
                    uchar      :4;              //               
                } BIT;                          //               
            } ISR;                              //               
            union {                             //  IPRI         
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar UU:4;                 //     SCI2      
                    uchar UL:4;                 //     SCI3      
                    uchar LU:4;                 //     SCI4      
                    uchar LL:4;                 //     MMT       
                } BIT;                          //               
            } IPRI;                             //               
            union {                             //  IPRJ         
                ushort WORD;                    //   Word Access 
                struct {                        //   Bit  Access 
                    uchar UU:4;                 //     A/D2      
                    uchar   :4;                 //               
                    uchar   :8;                 //               
                } BIT;                          //               
            } IPRJ;                             //               
            union {                             //  IPRK         
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar UU:4;                 //     I/O(MMT)  
                    uchar   :4;                 //               
                    uchar LU:4;                 //     HCAN2     
                    uchar   :4;                 //               
                } BIT;                          //               
            } IPRK;                             //               
            char wk2[4];                        //               
            union {                             //  ICR2         
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar IRQ0ES:2;             //     IRQ0ES    
                    uchar IRQ1ES:2;             //     IRQ1ES    
                    uchar IRQ2ES:2;             //     IRQ2ES    
                    uchar IRQ3ES:2;             //     IRQ3ES    
                    uchar       :8;             //               
                } BIT;                          //               
            } ICR2;                             //               
};                                              //               
struct st_pa {                                  //  struct PA    
            union {                             //  PADR         
                ushort WORD;                    //   Long Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low       
                    uchar L;                    //     Low       
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar B15:1;                //     Bit 15    
                    uchar B14:1;                //     Bit 14    
                    uchar B13:1;                //     Bit 13    
                    uchar B12:1;                //     Bit 12    
                    uchar B11:1;                //     Bit 11    
                    uchar B10:1;                //     Bit 10    
                    uchar B9 :1;                //     Bit  9    
                    uchar B8 :1;                //     Bit  8    
                    uchar B7 :1;                //     Bit  7    
                    uchar B6 :1;                //     Bit  6    
                    uchar B5 :1;                //     Bit  5    
                    uchar B4 :1;                //     Bit  4    
                    uchar B3 :1;                //     Bit  3    
                    uchar B2 :1;                //     Bit  2    
                    uchar B1 :1;                //     Bit  1    
                    uchar B0 :1;                //     Bit  0    
                } BIT;                          //               
            } DR;                               //               
};                                              //               
struct st_pb {                                  //  struct PB    
            union {                             //  PBDR         
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     High      
                    uchar L;                    //     Low       
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar   :8;                 //               
                    uchar   :2;                 //               
                    uchar B5:1;                 //     Bit 5     
                    uchar B4:1;                 //     Bit 4     
                    uchar B3:1;                 //     Bit 3     
                    uchar B2:1;                 //     Bit 2     
                    uchar B1:1;                 //     Bit 1     
                    uchar B0:1;                 //     Bit 0     
                } BIT;                          //               
            } DR;                               //               
};                                              //               
struct st_pd {                                  //  struct PD    
            union {                             //  PDDR         
                ushort WORD;                    //   Long Access 
                struct {                        //   Word Access 
                    uchar H;                    //     High      
                    uchar L;                    //     Low       
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar    :7;                //               
                    uchar B8 :1;                //     Bit  8    
                    uchar B7 :1;                //     Bit  7    
                    uchar B6 :1;                //     Bit  6    
                    uchar B5 :1;                //     Bit  5    
                    uchar B4 :1;                //     Bit  4    
                    uchar B3 :1;                //     Bit  3    
                    uchar B2 :1;                //     Bit  2    
                    uchar B1 :1;                //     Bit  1    
                    uchar B0 :1;                //     Bit  0    
                } BIT;                          //               
            } DR;                               //               
};                                              //               
struct st_pe {                                  //  struct PE    
            union {                             //  PEDRL        
                ushort WORD;                    //   Long Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar B15:1;                //     Bit 15    
                    uchar B14:1;                //     Bit 14    
                    uchar B13:1;                //     Bit 13    
                    uchar B12:1;                //     Bit 12    
                    uchar B11:1;                //     Bit 11    
                    uchar B10:1;                //     Bit 10    
                    uchar B9 :1;                //     Bit  9    
                    uchar B8 :1;                //     Bit  8    
                    uchar B7 :1;                //     Bit  7    
                    uchar B6 :1;                //     Bit  6    
                    uchar B5 :1;                //     Bit  5    
                    uchar B4 :1;                //     Bit  4    
                    uchar B3 :1;                //     Bit  3    
                    uchar B2 :1;                //     Bit  2    
                    uchar B1 :1;                //     Bit  1    
                    uchar B0 :1;                //     Bit  0    
                } BIT;                          //               
            } DRL;                              //               
            char wk1[12];                       //               
            union {                             //  PEDRH        
                ushort WORD;                    //   Long Access 
                struct {                        //   Word Access 
                    uchar H;                    //     High      
                    uchar L;                    //     Low       
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar    :8;                //               
                    uchar    :2;                //               
                    uchar B21:1;                //     Bit 21    
                    uchar B20:1;                //     Bit 20    
                    uchar B19:1;                //     Bit 19    
                    uchar B18:1;                //     Bit 18    
                    uchar B17:1;                //     Bit 17    
                    uchar B16:1;                //     Bit 16    
                } BIT;                          //               
            } DRH;                              //               
};                                              //               
struct st_pf {                                  //  struct PF    
            union {                             //  PADR         
                ushort WORD;                    //   Long Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar B15:1;                //     Bit 15    
                    uchar B14:1;                //     Bit 14    
                    uchar B13:1;                //     Bit 13    
                    uchar B12:1;                //     Bit 12    
                    uchar B11:1;                //     Bit 11    
                    uchar B10:1;                //     Bit 10    
                    uchar B9 :1;                //     Bit  9    
                    uchar B8 :1;                //     Bit  8    
                    uchar B7 :1;                //     Bit  7    
                    uchar B6 :1;                //     Bit  6    
                    uchar B5 :1;                //     Bit  5    
                    uchar B4 :1;                //     Bit  4    
                    uchar B3 :1;                //     Bit  3    
                    uchar B2 :1;                //     Bit  2    
                    uchar B1 :1;                //     Bit  1    
                    uchar B0 :1;                //     Bit  0    
                } BIT;                          //               
            } DR;                               //               
};                                              //               
struct st_pfc {                                 //  struct PFC   
            union {                             //  PAIORL       
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar B15:1;                //     Bit 15    
                    uchar B14:1;                //     Bit 14    
                    uchar B13:1;                //     Bit 13    
                    uchar B12:1;                //     Bit 12    
                    uchar B11:1;                //     Bit 11    
                    uchar B10:1;                //     Bit 10    
                    uchar B9 :1;                //     Bit  9    
                    uchar B8 :1;                //     Bit  8    
                    uchar B7 :1;                //     Bit  7    
                    uchar B6 :1;                //     Bit  6    
                    uchar B5 :1;                //     Bit  5    
                    uchar B4 :1;                //     Bit  4    
                    uchar B3 :1;                //     Bit  3    
                    uchar B2 :1;                //     Bit  2    
                    uchar B1 :1;                //     Bit  1    
                    uchar B0 :1;                //     Bit  0    
                } BIT;                          //               
            } PAIORL;                           //               
            char wk1[2];                        //               
            union {                             //  PACRL3       
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar MD15:1;               //     PA15MD    
                    uchar MD14:1;               //     PA14MD    
                    uchar MD13:1;               //     PA13MD    
                    uchar MD12:1;               //     PA12MD    
                    uchar MD11:1;               //     PA11MD    
                    uchar MD10:1;               //     PA10MD    
                    uchar MD9 :1;               //     PA9MD     
                    uchar MD8 :1;               //     PA8MD     
                    uchar MD7 :1;               //     PA7MD     
                    uchar MD6 :1;               //     PA6MD     
                    uchar MD5 :1;               //     PA5MD     
                    uchar MD4 :1;               //     PA4MD     
                    uchar MD3 :1;               //     PA3MD     
                    uchar MD2 :1;               //     PA2MD     
                    uchar MD1 :1;               //     PA1MD     
                    uchar MD0 :1;               //     PA0MD     
                } BIT;                          //               
            } PACRL3;                           //               
            union {                             //  PACRL1       
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar MD15:2;               //     PA15MD    
                    uchar MD14:2;               //     PA14MD    
                    uchar MD13:2;               //     PA13MD    
                    uchar MD12:2;               //     PA12MD    
                    uchar MD11:2;               //     PA11MD    
                    uchar MD10:2;               //     PA10MD    
                    uchar MD9 :2;               //     PA9MD     
                    uchar MD8 :2;               //     PA8MD     
                } BIT;                          //               
            } PACRL1;                           //               
            union {                             //  PACRL2       
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar MD7:2;                //     PA7MD     
                    uchar MD6:2;                //     PA6MD     
                    uchar MD5:2;                //     PA5MD     
                    uchar MD4:2;                //     PA4MD     
                    uchar MD3:2;                //     PA3MD     
                    uchar MD2:2;                //     PA2MD     
                    uchar MD1:2;                //     PA1MD     
                    uchar MD0:2;                //     PA0MD     
                } BIT;                          //               
            } PACRL2;                           //               
            char wk2[4];                        //               
            union {                             //  PBIOR        
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar   :8;                 //               
                    uchar   :2;                 //               
                    uchar B5:1;                 //     Bit 5     
                    uchar B4:1;                 //     Bit 4     
                    uchar B3:1;                 //     Bit 3     
                    uchar B2:1;                 //     Bit 2     
                    uchar B1:1;                 //     Bit 1     
                    uchar B0:1;                 //     Bit 0     
                } BIT;                          //               
            } PBIOR;                            //               
            char wk3[2];                        //               
            union {                             //  PBCR1        
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar    :2;                //               
                    uchar MD5:1;                //     PB5MD     
                    uchar MD4:1;                //     PB4MD     
                    uchar MD3:1;                //     PB3MD     
                    uchar MD2:1;                //     PB2MD     
                    uchar MD1:1;                //     PB1MD     
                    uchar    :1;                //               
                    uchar    :8;                //               
                } BIT;                          //               
            } PBCR1;                            //               
            union {                             //  PBCR2        
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar    :4;                //               
                    uchar MD5:2;                //     PB5MD     
                    uchar MD4:2;                //     PB4MD     
                    uchar MD3:2;                //     PB3MD     
                    uchar MD2:2;                //     PB2MD     
                    uchar MD1:2;                //     PB1MD     
                    uchar MD0:2;                //     PB0MD     
                } BIT;                          //               
            } PBCR2;                            //               
            char wk4[10];                       //               
            union {                             //  PDIORL       
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar    :7;                //               
                    uchar B8 :1;                //     Bit  8    
                    uchar B7 :1;                //     Bit  7    
                    uchar B6 :1;                //     Bit  6    
                    uchar B5 :1;                //     Bit  5    
                    uchar B4 :1;                //     Bit  4    
                    uchar B3 :1;                //     Bit  3    
                    uchar B2 :1;                //     Bit  2    
                    uchar B1 :1;                //     Bit  1    
                    uchar B0 :1;                //     Bit  0    
                } BIT;                          //               
            } PDIORL;                           //               
            char wk5[4];                        //               
            union {                             //  PDCRL1       
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar     :7;               //               
                    uchar MD8 :1;               //     PD8MD     
                    uchar MD7 :1;               //     PD7MD     
                    uchar MD6 :1;               //     PD6MD     
                    uchar MD5 :1;               //     PD5MD     
                    uchar MD4 :1;               //     PD4MD     
                    uchar MD3 :1;               //     PD3MD     
                    uchar MD2 :1;               //     PD2MD     
                    uchar MD1 :1;               //     PD1MD     
                    uchar MD0 :1;               //     PD0MD     
                } BIT;                          //               
            } PDCRL1;                           //               
            union {                             //  PDCRL2       
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar     :7;               //               
                    uchar MD8 :1;               //     PD8MD     
                    uchar MD7 :1;               //     PD7MD     
                    uchar MD6 :1;               //     PD6MD     
                    uchar MD5 :1;               //     PD5MD     
                    uchar MD4 :1;               //     PD4MD     
                    uchar MD3 :1;               //     PD3MD     
                    uchar MD2 :1;               //     PD2MD     
                    uchar MD1 :1;               //     PD1MD     
                    uchar MD0 :1;               //     PD0MD     
                } BIT;                          //               
            } PDCRL2;                           //               
            char  wk6[4];                       //               
            union {                             //  PEIORL       
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar B15:1;                //     Bit 15    
                    uchar B14:1;                //     Bit 14    
                    uchar B13:1;                //     Bit 13    
                    uchar B12:1;                //     Bit 12    
                    uchar B11:1;                //     Bit 11    
                    uchar B10:1;                //     Bit 10    
                    uchar B9 :1;                //     Bit  9    
                    uchar B8 :1;                //     Bit  8    
                    uchar B7 :1;                //     Bit  7    
                    uchar B6 :1;                //     Bit  6    
                    uchar B5 :1;                //     Bit  5    
                    uchar B4 :1;                //     Bit  4    
                    uchar B3 :1;                //     Bit  3    
                    uchar B2 :1;                //     Bit  2    
                    uchar B1 :1;                //     Bit  1    
                    uchar B0 :1;                //     Bit  0    
                } BIT;                          //               
            } PEIORL;                           //               
            union {                             //  PEIORH       
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar     :8;               //               
                    uchar     :2;               //               
                    uchar B21 :1;               //     Bit  21   
                    uchar B20 :1;               //     Bit  20   
                    uchar B19 :1;               //     Bit  19   
                    uchar B18 :1;               //     Bit  18   
                    uchar B17 :1;               //     Bit  17   
                    uchar B16 :1;               //     Bit  16    
                } BIT;                          //               
            } PEIORH;                           //               
            union {                             //  PECRL1       
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar MD15:2;               //     PE15MD    
                    uchar MD14:2;               //     PE14MD    
                    uchar MD13:2;               //     PE13MD    
                    uchar MD12:2;               //     PE12MD    
                    uchar MD11:2;               //     PE11MD    
                    uchar MD10:2;               //     PE10MD    
                    uchar MD9 :2;               //     PE9MD     
                    uchar MD8 :2;               //     PE8MD     
                } BIT;                          //               
            } PECRL1;                           //               
            union {                             //  PECRL2       
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar MD7 :2;               //     PE7MD     
                    uchar MD6 :2;               //     PE6MD     
                    uchar MD5 :2;               //     PE5MD     
                    uchar MD4 :2;               //     PE4MD     
                    uchar MD3 :2;               //     PE3MD     
                    uchar MD2 :2;               //     PE2MD     
                    uchar MD1 :2;               //     PE1MD     
                    uchar MD0 :2;               //     PE0MD     
                } BIT;                          //               
            } PECRL2;                           //               
            union {                             //  PECRH        
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar     :4;               //               
                    uchar B21 :2;               //     PE21MD    
                    uchar B20 :2;               //     PE20MD    
                    uchar B19 :2;               //     PE19MD    
                    uchar B18 :2;               //     PE18MD    
                    uchar B17 :2;               //     PE17MD    
                    uchar B16 :2;               //     PE16MD    
                } BIT;                          //               
            } PECRH;                            //               
};                                              //               
struct st_cmt {                                 //  struct CMT   
            union {                             //  CMSTR        
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar     :8;               //               
                    uchar     :6;               //               
                    uchar STR1:1;               //     STR1      
                    uchar STR0:1;               //     STR0      
                } BIT;                          //               
            } CMSTR;                            //               
};                                              //               
struct st_cmt0 {                                //  struct CMT0  
            union {                             //  CMCSR        
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Byte Access 
                    uchar     :8;               //               
                    uchar CMF :1;               //     CMF       
                    uchar CMIE:1;               //     CMIE      
                    uchar     :4;               //               
                    uchar CKS :2;               //     CKS       
                } BIT;                          //               
            } CMCSR;                            //               
            ushort   CMCNT;                     //  CMCNT        
            ushort   CMCOR;                     //  CMCOR        
};                                              //               
struct st_ad  {                                 //  A/D Conv     
            ushort  ADDR[20];                   //  0-7: dummy   
            char wk1[56];                       //               
            uchar  ADCSR_0;                     //  ADCSR_0      
            uchar  ADCSR_1;                     //  ADCSR_1      
            uchar  ADCSR_2;                     //  ADCSR_2      
            char wk2[5];                        //               
            uchar  ADCR_0;                      //  ADCR_0       
            uchar  ADCR_1;                      //  ADCR_1       
            uchar  ADCR_2;                      //  ADCR_2       
};                                              //               
struct st_ubc {                                 //  struct UBC   
            void *UBAR;                         //  UBAR         
            uint UBAMR;                         //  UBAMR        
            union {                             //  UBBR         
                ushort WORD;                    //   Word Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar   :8;                 //               
                    uchar CP:2;                 //     CP        
                    uchar ID:2;                 //     ID        
                    uchar RW:2;                 //     RW        
                    uchar SZ:2;                 //     SZ        
                } BIT;                          //               
            } UBBR;                             //               
};                                              //               
union  un_wdt {                                 //  union WDT    
            union {                             //   TCSR        
                union {                         //    W(rite)    
                    ushort WORD;                //     WORD      
                    ushort dummyW;              //     wr:0xa5XX 
                } W;                            //               
                union {                         //    R(ead)     
                    uchar  BYTE;                //     BYTE      
                    uchar  dummyB;              //               
                    ushort dummyW;              //               
                } R;                            //               
            } TCSR;                             //               
            union {                             //   TCNT        
                union {                         //    W(rite)    
                    ushort WORD;                //     WORD      
                    ushort dummyW;              //     wr:0x5aXX 
                } W;                            //               
                union {                         //    R(ead)     
                    uchar  dummyB;              //     BYTE      
                    uchar  BYTE;                //               
                    ushort dummyW;              //               
                } R;                            //               
                ushort  dummyW;                 //               
            } TCNT;                             //               
            union {                             //   BSTCSR      
                union {                         //    W(write)   
                    ushort dummyW;              //     WORD      
                    ushort WORD;                //     wr:0x5aXX 
                } W;                            //     cl:0xa500 
                union {                         //    R(ead)     
                    uchar  dummyB;              //     BYTE      
                    uchar  BYTE;                //               
                    ushort dummyW;              //               
                } R;                            //               
            } RSTCSR;                           //               
};                                              //               
struct un_mstcr {                               //  struct MSTCR 
            union {                             //  MSTCR1       
                ushort WORD;                    //   Byte Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar        :4;            //               
                    uchar MSTOP27:1;            //   RAM         
                    uchar MSTOP26:1;            //   ROM         
                    uchar MSTOP25:1;            //   DTC         
                    uchar MSTOP24:1;            //   DTC         
                    uchar        :2;            //               
                    uchar        :1;            //               
                    uchar        :1;            //   
                    uchar MSTOP19:1;            //   SCI3        
                    uchar MSTOP18:1;            //   SCI2        
                    uchar        :2;            //               
                } BIT;                          //               
            } MSTCR1;                           //               
            union {                             //  MSTCR2       
                ushort WORD;                    //   Byte Access 
                struct {                        //   Byte Access 
                    uchar H;                    //     Low ,High 
                    uchar L;                    //     Low ,Low  
                } BYTE;                         //               
                struct {                        //   Bit  Access 
                    uchar        :1;            //               
                    uchar MSTOP14:1;            //   MMT         
                    uchar MSTOP13:1;            //   MTU         
                    uchar MSTOP12:1;            //   CMT         
                    uchar        :2;            //               
                    uchar MSTOP9 :1;            //   HCAN2       
                    uchar        :1;            //               
                    uchar        :1;            //               
                    uchar MSTOP6 :1;            //   A/D2        
                    uchar MSTOP5 :1;            //   A/D1        
                    uchar MSTOP4 :1;            //   A/D0        
                    uchar MSTOP3 :1;            //   AUD         
                    uchar MSTOP2 :1;            //   H-UDI       
                    uchar        :1;            //               
                    uchar MSTOP0 :1;            //   UBC         
                } BIT;                          //               
            } MSTCR2;                           //               
};                                              //               
struct st_flash {                               //  struct FLASH
            union {                             //  FLMCR1  
                uchar BYTE;                     //    Byte Access
                struct {                        //    Bit  Access
                    uchar FWE:1;                //     FWE
                    uchar SWE:1;                //     SWE
                    uchar ESU:1;                //     ESU
                    uchar PSU:1;                //     PSU
                    uchar EV :1;                //     EV
                    uchar PV :1;                //     PV
                    uchar E  :1;                //     E
                    uchar P  :1;                //     P
                } BIT;                          //
            } FLMCR1;                           //
            union {                             //  FLMCR2
                uchar BYTE;                     //   Byte Access
                struct {                        //   Bit  Access
                    uchar FLER:1;               //    FLER
                    uchar     :7;               //
                } BIT;                          //  
            } FLMCR2;                           //
            union {                             //  EBR1
                uchar BYTE;                     //   Byte Access
                struct {                        //   Bit  Access
                    uchar EB7:1;                //    EB7
                    uchar EB6:1;                //    EB6
                    uchar EB5:1;                //    EB5
                    uchar EB4:1;                //    EB4
                    uchar EB3:1;                //    EB3
                    uchar EB2:1;                //    EB2
                    uchar EB1:1;                //    EB1
                    uchar EB0:1;                //    EB0
                } BIT;                          //
            } EBR1;                             //
            union {                             //  EBR2
                uchar BYTE;                     //   Byte Access
                struct {                        //   Bit  Access
                    uchar     :4;               //    
                    uchar EB11:1;               //    EB11
                    uchar EB10:1;               //    EB10
                    uchar EB9 :1;               //    EB9
                    uchar EB8 :1;               //    EB8
                } BIT;                          //
            } EBR2;                             //
};                                              //

#define SCI2  (*(volatile struct st_sci   *)0xFFFF81C0) //  SCI2  Address
#define SCI3  (*(volatile struct st_sci   *)0xFFFF81D0) //  SCI3  Address
#define MTU   (*(volatile struct st_mtu   *)0xFFFF8240) //  MTU   Address
#define MTU0  (*(volatile struct st_mtu0  *)0xFFFF8260) //  MTU0  Address
#define MTU1  (*(volatile struct st_mtu0  *)0xFFFF8280) //  MTU1  Address
#define MTU2  (*(volatile struct st_mtu0  *)0xFFFF82A0) //  MTU2  Address
#define MTU34 (*(volatile struct st_mtu34 *)0xFFFF8200) //  MTU34 Address
#define INTC  (*(volatile struct st_intc  *)0xFFFF8348) //  INTC  Address
#define PA    (*(volatile struct st_pa    *)0xFFFF8382) //  PA    Address
#define PB    (*(volatile struct st_pb    *)0xFFFF8390) //  PB    Address
#define PD    (*(volatile struct st_pd    *)0xFFFF83A2) //  PD    Address
#define PE    (*(volatile struct st_pe    *)0xFFFF83B0) //  PE    Address
#define PF    (*(volatile struct st_pf    *)0xFFFF83B2) //  PF    Address
#define PFC   (*(volatile struct st_pfc   *)0xFFFF8386) //  PFC   Address
#define CMT   (*(volatile struct st_cmt   *)0xFFFF83D0) //  CMT   Address
#define CMT0  (*(volatile struct st_cmt0  *)0xFFFF83D2) //  CMT0  Address
#define CMT1  (*(volatile struct st_cmt0  *)0xFFFF83D8) //  CMT1  Address
#define AD    (*(volatile struct st_ad    *)0xFFFF8420) //  AD    Address
#define UBC   (*(volatile struct st_ubc   *)0xFFFF8600) //  UBC   Address
#define WDT   (*(volatile union  un_wdt   *)0xFFFF8610) //  WDT   Address
#define MSTCR (*(volatile struct un_mstcr *)0xFFFF861C) //  MSTCR Address
#define FLASH (*(volatile struct st_flash *)0xFFFF8580) //  FLASH Address

#endif

////////////////////////////////////////////////////////////////////////
