text:  /*
   *************************************************************************
   *
   * Copyright (c) 2009 Marvell International, Ltd. All Rights Reserved
   *
   *                       Marvell Confidential
   *************************************************************************
   *************************************************************************
   * \file : ScCSC_regmasks.h
   *
   * NOTE: This file generated by RegBuild
   *
   * Generated on Friday, 07/10/09 at 02:17:17 PM PDT
   * using RegBuild 1.4
   *
   *************************************************************************
   */
  
  #ifndef _SCCSC_REGMASKS_H_
  #define _SCCSC_REGMASKS_H_
  
  //====================================================================
  //
  //Register File: SubCube Color Space Conversion (ScCSC)
  /** \brief Top-level register file for ScCSC*/
  //
  //====================================================================
  
  //====================================================================
  //Register: ScCSC STATUS REG (STATUS)
  /** \brief ScCSC Status Register*/
  //====================================================================
  
  #define  SCCSC_STATUS_RESERVED1_MASK 0xffffff00
  #define  SCCSC_STATUS_RESERVED1_SHIFT 8
  #define  SCCSC_STATUS_RESERVED1_MASK_SHIFT(reg) (((reg) & SCCSC_STATUS_RESERVED1_MASK) >> SCCSC_STATUS_RESERVED1_SHIFT)
  #define  SCCSC_STATUS_RESERVED1_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_STATUS_RESERVED1_MASK) | ((val) << SCCSC_STATUS_RESERVED1_SHIFT))
  
  #define  SCCSC_STATUS_DMABUSY7_MASK 0x80
  #define  SCCSC_STATUS_DMABUSY7_SHIFT 7
  #define  SCCSC_STATUS_DMABUSY7_MASK_SHIFT(reg) (((reg) & SCCSC_STATUS_DMABUSY7_MASK) >> SCCSC_STATUS_DMABUSY7_SHIFT)
  #define  SCCSC_STATUS_DMABUSY7_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_STATUS_DMABUSY7_MASK) | ((val) << SCCSC_STATUS_DMABUSY7_SHIFT))
  
  #define  SCCSC_STATUS_DMABUSY6_MASK 0x40
  #define  SCCSC_STATUS_DMABUSY6_SHIFT 6
  #define  SCCSC_STATUS_DMABUSY6_MASK_SHIFT(reg) (((reg) & SCCSC_STATUS_DMABUSY6_MASK) >> SCCSC_STATUS_DMABUSY6_SHIFT)
  #define  SCCSC_STATUS_DMABUSY6_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_STATUS_DMABUSY6_MASK) | ((val) << SCCSC_STATUS_DMABUSY6_SHIFT))
  
  #define  SCCSC_STATUS_DMABUSY5_MASK 0x20
  #define  SCCSC_STATUS_DMABUSY5_SHIFT 5
  #define  SCCSC_STATUS_DMABUSY5_MASK_SHIFT(reg) (((reg) & SCCSC_STATUS_DMABUSY5_MASK) >> SCCSC_STATUS_DMABUSY5_SHIFT)
  #define  SCCSC_STATUS_DMABUSY5_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_STATUS_DMABUSY5_MASK) | ((val) << SCCSC_STATUS_DMABUSY5_SHIFT))
  
  #define  SCCSC_STATUS_DMABUSY4_MASK 0x10
  #define  SCCSC_STATUS_DMABUSY4_SHIFT 4
  #define  SCCSC_STATUS_DMABUSY4_MASK_SHIFT(reg) (((reg) & SCCSC_STATUS_DMABUSY4_MASK) >> SCCSC_STATUS_DMABUSY4_SHIFT)
  #define  SCCSC_STATUS_DMABUSY4_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_STATUS_DMABUSY4_MASK) | ((val) << SCCSC_STATUS_DMABUSY4_SHIFT))
  
  #define  SCCSC_STATUS_DMABUSY3_MASK 0x8
  #define  SCCSC_STATUS_DMABUSY3_SHIFT 3
  #define  SCCSC_STATUS_DMABUSY3_MASK_SHIFT(reg) (((reg) & SCCSC_STATUS_DMABUSY3_MASK) >> SCCSC_STATUS_DMABUSY3_SHIFT)
  #define  SCCSC_STATUS_DMABUSY3_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_STATUS_DMABUSY3_MASK) | ((val) << SCCSC_STATUS_DMABUSY3_SHIFT))
  
  #define  SCCSC_STATUS_DMABUSY2_MASK 0x4
  #define  SCCSC_STATUS_DMABUSY2_SHIFT 2
  #define  SCCSC_STATUS_DMABUSY2_MASK_SHIFT(reg) (((reg) & SCCSC_STATUS_DMABUSY2_MASK) >> SCCSC_STATUS_DMABUSY2_SHIFT)
  #define  SCCSC_STATUS_DMABUSY2_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_STATUS_DMABUSY2_MASK) | ((val) << SCCSC_STATUS_DMABUSY2_SHIFT))
  
  #define  SCCSC_STATUS_DMABUSY1_MASK 0x2
  #define  SCCSC_STATUS_DMABUSY1_SHIFT 1
  #define  SCCSC_STATUS_DMABUSY1_MASK_SHIFT(reg) (((reg) & SCCSC_STATUS_DMABUSY1_MASK) >> SCCSC_STATUS_DMABUSY1_SHIFT)
  #define  SCCSC_STATUS_DMABUSY1_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_STATUS_DMABUSY1_MASK) | ((val) << SCCSC_STATUS_DMABUSY1_SHIFT))
  
  #define  SCCSC_STATUS_DMABUSY0_MASK 0x1
  #define  SCCSC_STATUS_DMABUSY0_SHIFT 0
  #define  SCCSC_STATUS_DMABUSY0_MASK_SHIFT(reg) (((reg) & SCCSC_STATUS_DMABUSY0_MASK) >> SCCSC_STATUS_DMABUSY0_SHIFT)
  #define  SCCSC_STATUS_DMABUSY0_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_STATUS_DMABUSY0_MASK) | ((val) << SCCSC_STATUS_DMABUSY0_SHIFT))
  
  //====================================================================
  //Register: ScCSC CONTROL REG (CNTRL)
  /** \brief ScCSC Control Register*/
  //====================================================================
  
  #define  SCCSC_CNTRL_BYPASSALL_MASK 0x80000000
  #define  SCCSC_CNTRL_BYPASSALL_SHIFT 31
  #define  SCCSC_CNTRL_BYPASSALL_MASK_SHIFT(reg) (((reg) & SCCSC_CNTRL_BYPASSALL_MASK) >> SCCSC_CNTRL_BYPASSALL_SHIFT)
  #define  SCCSC_CNTRL_BYPASSALL_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_CNTRL_BYPASSALL_MASK) | ((val) << SCCSC_CNTRL_BYPASSALL_SHIFT))
  
  #define  SCCSC_CNTRL_RESERVED1_MASK 0x60000000
  #define  SCCSC_CNTRL_RESERVED1_SHIFT 29
  #define  SCCSC_CNTRL_RESERVED1_MASK_SHIFT(reg) (((reg) & SCCSC_CNTRL_RESERVED1_MASK) >> SCCSC_CNTRL_RESERVED1_SHIFT)
  #define  SCCSC_CNTRL_RESERVED1_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_CNTRL_RESERVED1_MASK) | ((val) << SCCSC_CNTRL_RESERVED1_SHIFT))
  
  #define  SCCSC_CNTRL_CPUACCESS_MASK 0x10000000
  #define  SCCSC_CNTRL_CPUACCESS_SHIFT 28
  #define  SCCSC_CNTRL_CPUACCESS_MASK_SHIFT(reg) (((reg) & SCCSC_CNTRL_CPUACCESS_MASK) >> SCCSC_CNTRL_CPUACCESS_SHIFT)
  #define  SCCSC_CNTRL_CPUACCESS_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_CNTRL_CPUACCESS_MASK) | ((val) << SCCSC_CNTRL_CPUACCESS_SHIFT))
  
  #define  SCCSC_CNTRL_RESERVED2_MASK 0xc000000
  #define  SCCSC_CNTRL_RESERVED2_SHIFT 26
  #define  SCCSC_CNTRL_RESERVED2_MASK_SHIFT(reg) (((reg) & SCCSC_CNTRL_RESERVED2_MASK) >> SCCSC_CNTRL_RESERVED2_SHIFT)
  #define  SCCSC_CNTRL_RESERVED2_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_CNTRL_RESERVED2_MASK) | ((val) << SCCSC_CNTRL_RESERVED2_SHIFT))
  
  #define  SCCSC_CNTRL_IALG_MASK 0x3000000
  #define  SCCSC_CNTRL_IALG_SHIFT 24
  #define  SCCSC_CNTRL_IALG_MASK_SHIFT(reg) (((reg) & SCCSC_CNTRL_IALG_MASK) >> SCCSC_CNTRL_IALG_SHIFT)
  #define  SCCSC_CNTRL_IALG_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_CNTRL_IALG_MASK) | ((val) << SCCSC_CNTRL_IALG_SHIFT))
  
  #define  SCCSC_CNTRL_RESERVED3_MASK 0x800000
  #define  SCCSC_CNTRL_RESERVED3_SHIFT 23
  #define  SCCSC_CNTRL_RESERVED3_MASK_SHIFT(reg) (((reg) & SCCSC_CNTRL_RESERVED3_MASK) >> SCCSC_CNTRL_RESERVED3_SHIFT)
  #define  SCCSC_CNTRL_RESERVED3_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_CNTRL_RESERVED3_MASK) | ((val) << SCCSC_CNTRL_RESERVED3_SHIFT))
  
  #define  SCCSC_CNTRL_NGE_MASK 0x400000
  #define  SCCSC_CNTRL_NGE_SHIFT 22
  #define  SCCSC_CNTRL_NGE_MASK_SHIFT(reg) (((reg) & SCCSC_CNTRL_NGE_MASK) >> SCCSC_CNTRL_NGE_SHIFT)
  #define  SCCSC_CNTRL_NGE_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_CNTRL_NGE_MASK) | ((val) << SCCSC_CNTRL_NGE_SHIFT))
  
  #define  SCCSC_CNTRL_WME_MASK 0x200000
  #define  SCCSC_CNTRL_WME_SHIFT 21
  #define  SCCSC_CNTRL_WME_MASK_SHIFT(reg) (((reg) & SCCSC_CNTRL_WME_MASK) >> SCCSC_CNTRL_WME_SHIFT)
  #define  SCCSC_CNTRL_WME_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_CNTRL_WME_MASK) | ((val) << SCCSC_CNTRL_WME_SHIFT))
  
  #define  SCCSC_CNTRL_KME_MASK 0x180000
  #define  SCCSC_CNTRL_KME_SHIFT 19
  #define  SCCSC_CNTRL_KME_MASK_SHIFT(reg) (((reg) & SCCSC_CNTRL_KME_MASK) >> SCCSC_CNTRL_KME_SHIFT)
  #define  SCCSC_CNTRL_KME_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_CNTRL_KME_MASK) | ((val) << SCCSC_CNTRL_KME_SHIFT))
  
  #define  SCCSC_CNTRL_RESERVED4_MASK 0x40000
  #define  SCCSC_CNTRL_RESERVED4_SHIFT 18
  #define  SCCSC_CNTRL_RESERVED4_MASK_SHIFT(reg) (((reg) & SCCSC_CNTRL_RESERVED4_MASK) >> SCCSC_CNTRL_RESERVED4_SHIFT)
  #define  SCCSC_CNTRL_RESERVED4_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_CNTRL_RESERVED4_MASK) | ((val) << SCCSC_CNTRL_RESERVED4_SHIFT))
  
  #define  SCCSC_CNTRL_LUTSEL_MASK 0x20000
  #define  SCCSC_CNTRL_LUTSEL_SHIFT 17
  #define  SCCSC_CNTRL_LUTSEL_MASK_SHIFT(reg) (((reg) & SCCSC_CNTRL_LUTSEL_MASK) >> SCCSC_CNTRL_LUTSEL_SHIFT)
  #define  SCCSC_CNTRL_LUTSEL_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_CNTRL_LUTSEL_MASK) | ((val) << SCCSC_CNTRL_LUTSEL_SHIFT))
  
  #define  SCCSC_CNTRL_SBAND_EN_MASK 0x10000
  #define  SCCSC_CNTRL_SBAND_EN_SHIFT 16
  #define  SCCSC_CNTRL_SBAND_EN_MASK_SHIFT(reg) (((reg) & SCCSC_CNTRL_SBAND_EN_MASK) >> SCCSC_CNTRL_SBAND_EN_SHIFT)
  #define  SCCSC_CNTRL_SBAND_EN_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_CNTRL_SBAND_EN_MASK) | ((val) << SCCSC_CNTRL_SBAND_EN_SHIFT))
  
  #define  SCCSC_CNTRL_SBAND_VALUE_MASK 0xff00
  #define  SCCSC_CNTRL_SBAND_VALUE_SHIFT 8
  #define  SCCSC_CNTRL_SBAND_VALUE_MASK_SHIFT(reg) (((reg) & SCCSC_CNTRL_SBAND_VALUE_MASK) >> SCCSC_CNTRL_SBAND_VALUE_SHIFT)
  #define  SCCSC_CNTRL_SBAND_VALUE_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_CNTRL_SBAND_VALUE_MASK) | ((val) << SCCSC_CNTRL_SBAND_VALUE_SHIFT))
  
  #define  SCCSC_CNTRL_SBAND_MASK_MASK 0xff
  #define  SCCSC_CNTRL_SBAND_MASK_SHIFT 0
  #define  SCCSC_CNTRL_SBAND_MASK_MASK_SHIFT(reg) (((reg) & SCCSC_CNTRL_SBAND_MASK_MASK) >> SCCSC_CNTRL_SBAND_MASK_SHIFT)
  #define  SCCSC_CNTRL_SBAND_MASK_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_CNTRL_SBAND_MASK_MASK) | ((val) << SCCSC_CNTRL_SBAND_MASK_SHIFT))
  
  //====================================================================
  //Register: Cache Miss Counters Clear (MCClr)
  /** \brief Write only register for clearing the Cache Pixel and Index Miss counters*/
  //====================================================================
  
  #define  SCCSC_MCCLR_RESERVED1_MASK 0xfffffffe
  #define  SCCSC_MCCLR_RESERVED1_SHIFT 1
  #define  SCCSC_MCCLR_RESERVED1_MASK_SHIFT(reg) (((reg) & SCCSC_MCCLR_RESERVED1_MASK) >> SCCSC_MCCLR_RESERVED1_SHIFT)
  #define  SCCSC_MCCLR_RESERVED1_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_MCCLR_RESERVED1_MASK) | ((val) << SCCSC_MCCLR_RESERVED1_SHIFT))
  
  #define  SCCSC_MCCLR_CLR_MASK 0x1
  #define  SCCSC_MCCLR_CLR_SHIFT 0
  #define  SCCSC_MCCLR_CLR_MASK_SHIFT(reg) (((reg) & SCCSC_MCCLR_CLR_MASK) >> SCCSC_MCCLR_CLR_SHIFT)
  #define  SCCSC_MCCLR_CLR_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_MCCLR_CLR_MASK) | ((val) << SCCSC_MCCLR_CLR_SHIFT))
  
  //====================================================================
  //Register: Cache Latency Counter Clear (LCClr)
  /** \brief Write only register for clearing the Cache Latency counter.*/
  //====================================================================
  
  #define  SCCSC_LCCLR_RESERVED1_MASK 0xfffffffe
  #define  SCCSC_LCCLR_RESERVED1_SHIFT 1
  #define  SCCSC_LCCLR_RESERVED1_MASK_SHIFT(reg) (((reg) & SCCSC_LCCLR_RESERVED1_MASK) >> SCCSC_LCCLR_RESERVED1_SHIFT)
  #define  SCCSC_LCCLR_RESERVED1_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_LCCLR_RESERVED1_MASK) | ((val) << SCCSC_LCCLR_RESERVED1_SHIFT))
  
  #define  SCCSC_LCCLR_CLR_MASK 0x1
  #define  SCCSC_LCCLR_CLR_SHIFT 0
  #define  SCCSC_LCCLR_CLR_MASK_SHIFT(reg) (((reg) & SCCSC_LCCLR_CLR_MASK) >> SCCSC_LCCLR_CLR_SHIFT)
  #define  SCCSC_LCCLR_CLR_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_LCCLR_CLR_MASK) | ((val) << SCCSC_LCCLR_CLR_SHIFT))
  
  //====================================================================
  //Register: INVALIDATE All Caches Register (CACHE_INVLD)
  /** \brief Write only register that invalidates all Cache tags.*/
  //====================================================================
  
  #define  SCCSC_CACHE_INVLD_RESERVED1_MASK 0xfffffffe
  #define  SCCSC_CACHE_INVLD_RESERVED1_SHIFT 1
  #define  SCCSC_CACHE_INVLD_RESERVED1_MASK_SHIFT(reg) (((reg) & SCCSC_CACHE_INVLD_RESERVED1_MASK) >> SCCSC_CACHE_INVLD_RESERVED1_SHIFT)
  #define  SCCSC_CACHE_INVLD_RESERVED1_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_CACHE_INVLD_RESERVED1_MASK) | ((val) << SCCSC_CACHE_INVLD_RESERVED1_SHIFT))
  
  #define  SCCSC_CACHE_INVLD_INVLD_MASK 0x1
  #define  SCCSC_CACHE_INVLD_INVLD_SHIFT 0
  #define  SCCSC_CACHE_INVLD_INVLD_MASK_SHIFT(reg) (((reg) & SCCSC_CACHE_INVLD_INVLD_MASK) >> SCCSC_CACHE_INVLD_INVLD_SHIFT)
  #define  SCCSC_CACHE_INVLD_INVLD_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_CACHE_INVLD_INVLD_MASK) | ((val) << SCCSC_CACHE_INVLD_INVLD_SHIFT))
  
  //====================================================================
  //Register: Cache Control Register (CACHE_CNTRL)
  /** \brief Caching Control Functions*/
  //====================================================================
  
  #define  SCCSC_CACHE_CNTRL_RESERVED1_MASK 0xffe00000
  #define  SCCSC_CACHE_CNTRL_RESERVED1_SHIFT 21
  #define  SCCSC_CACHE_CNTRL_RESERVED1_MASK_SHIFT(reg) (((reg) & SCCSC_CACHE_CNTRL_RESERVED1_MASK) >> SCCSC_CACHE_CNTRL_RESERVED1_SHIFT)
  #define  SCCSC_CACHE_CNTRL_RESERVED1_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_CACHE_CNTRL_RESERVED1_MASK) | ((val) << SCCSC_CACHE_CNTRL_RESERVED1_SHIFT))
  
  #define  SCCSC_CACHE_CNTRL_LUTSIZE_MASK 0x100000
  #define  SCCSC_CACHE_CNTRL_LUTSIZE_SHIFT 20
  #define  SCCSC_CACHE_CNTRL_LUTSIZE_MASK_SHIFT(reg) (((reg) & SCCSC_CACHE_CNTRL_LUTSIZE_MASK) >> SCCSC_CACHE_CNTRL_LUTSIZE_SHIFT)
  #define  SCCSC_CACHE_CNTRL_LUTSIZE_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_CACHE_CNTRL_LUTSIZE_MASK) | ((val) << SCCSC_CACHE_CNTRL_LUTSIZE_SHIFT))
  
  #define  SCCSC_CACHE_CNTRL_RESERVED2_MASK 0xe0000
  #define  SCCSC_CACHE_CNTRL_RESERVED2_SHIFT 17
  #define  SCCSC_CACHE_CNTRL_RESERVED2_MASK_SHIFT(reg) (((reg) & SCCSC_CACHE_CNTRL_RESERVED2_MASK) >> SCCSC_CACHE_CNTRL_RESERVED2_SHIFT)
  #define  SCCSC_CACHE_CNTRL_RESERVED2_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_CACHE_CNTRL_RESERVED2_MASK) | ((val) << SCCSC_CACHE_CNTRL_RESERVED2_SHIFT))
  
  #define  SCCSC_CACHE_CNTRL_HC_MASK 0x10000
  #define  SCCSC_CACHE_CNTRL_HC_SHIFT 16
  #define  SCCSC_CACHE_CNTRL_HC_MASK_SHIFT(reg) (((reg) & SCCSC_CACHE_CNTRL_HC_MASK) >> SCCSC_CACHE_CNTRL_HC_SHIFT)
  #define  SCCSC_CACHE_CNTRL_HC_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_CACHE_CNTRL_HC_MASK) | ((val) << SCCSC_CACHE_CNTRL_HC_SHIFT))
  
  #define  SCCSC_CACHE_CNTRL_RESERVED3_MASK 0xfe00
  #define  SCCSC_CACHE_CNTRL_RESERVED3_SHIFT 9
  #define  SCCSC_CACHE_CNTRL_RESERVED3_MASK_SHIFT(reg) (((reg) & SCCSC_CACHE_CNTRL_RESERVED3_MASK) >> SCCSC_CACHE_CNTRL_RESERVED3_SHIFT)
  #define  SCCSC_CACHE_CNTRL_RESERVED3_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_CACHE_CNTRL_RESERVED3_MASK) | ((val) << SCCSC_CACHE_CNTRL_RESERVED3_SHIFT))
  
  #define  SCCSC_CACHE_CNTRL_MCE_MASK 0x100
  #define  SCCSC_CACHE_CNTRL_MCE_SHIFT 8
  #define  SCCSC_CACHE_CNTRL_MCE_MASK_SHIFT(reg) (((reg) & SCCSC_CACHE_CNTRL_MCE_MASK) >> SCCSC_CACHE_CNTRL_MCE_SHIFT)
  #define  SCCSC_CACHE_CNTRL_MCE_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_CACHE_CNTRL_MCE_MASK) | ((val) << SCCSC_CACHE_CNTRL_MCE_SHIFT))
  
  #define  SCCSC_CACHE_CNTRL_RESERVED4_MASK 0xf0
  #define  SCCSC_CACHE_CNTRL_RESERVED4_SHIFT 4
  #define  SCCSC_CACHE_CNTRL_RESERVED4_MASK_SHIFT(reg) (((reg) & SCCSC_CACHE_CNTRL_RESERVED4_MASK) >> SCCSC_CACHE_CNTRL_RESERVED4_SHIFT)
  #define  SCCSC_CACHE_CNTRL_RESERVED4_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_CACHE_CNTRL_RESERVED4_MASK) | ((val) << SCCSC_CACHE_CNTRL_RESERVED4_SHIFT))
  
  #define  SCCSC_CACHE_CNTRL_LCE_MASK 0x8
  #define  SCCSC_CACHE_CNTRL_LCE_SHIFT 3
  #define  SCCSC_CACHE_CNTRL_LCE_MASK_SHIFT(reg) (((reg) & SCCSC_CACHE_CNTRL_LCE_MASK) >> SCCSC_CACHE_CNTRL_LCE_SHIFT)
  #define  SCCSC_CACHE_CNTRL_LCE_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_CACHE_CNTRL_LCE_MASK) | ((val) << SCCSC_CACHE_CNTRL_LCE_SHIFT))
  
  #define  SCCSC_CACHE_CNTRL_RESERVED5_MASK 0x7
  #define  SCCSC_CACHE_CNTRL_RESERVED5_SHIFT 0
  #define  SCCSC_CACHE_CNTRL_RESERVED5_MASK_SHIFT(reg) (((reg) & SCCSC_CACHE_CNTRL_RESERVED5_MASK) >> SCCSC_CACHE_CNTRL_RESERVED5_SHIFT)
  #define  SCCSC_CACHE_CNTRL_RESERVED5_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_CACHE_CNTRL_RESERVED5_MASK) | ((val) << SCCSC_CACHE_CNTRL_RESERVED5_SHIFT))
  
  //====================================================================
  //Register: Cache Index Miss counter (IDX_MISS_COUNTER)
  /** \brief Cache Index Miss count*/
  //====================================================================
  
  #define  SCCSC_IDX_MISS_COUNTER_CNT_MASK 0xffffffff
  #define  SCCSC_IDX_MISS_COUNTER_CNT_SHIFT 0
  #define  SCCSC_IDX_MISS_COUNTER_CNT_MASK_SHIFT(reg) (((reg) & SCCSC_IDX_MISS_COUNTER_CNT_MASK) >> SCCSC_IDX_MISS_COUNTER_CNT_SHIFT)
  #define  SCCSC_IDX_MISS_COUNTER_CNT_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_IDX_MISS_COUNTER_CNT_MASK) | ((val) << SCCSC_IDX_MISS_COUNTER_CNT_SHIFT))
  
  //====================================================================
  //Register: Cache PIXEL Miss counter (PIXEL_MISS_COUNTER)
  /** \brief Cache Pixel Miss count*/
  //====================================================================
  
  #define  SCCSC_PIXEL_MISS_COUNTER_CNT_MASK 0xffffffff
  #define  SCCSC_PIXEL_MISS_COUNTER_CNT_SHIFT 0
  #define  SCCSC_PIXEL_MISS_COUNTER_CNT_MASK_SHIFT(reg) (((reg) & SCCSC_PIXEL_MISS_COUNTER_CNT_MASK) >> SCCSC_PIXEL_MISS_COUNTER_CNT_SHIFT)
  #define  SCCSC_PIXEL_MISS_COUNTER_CNT_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_PIXEL_MISS_COUNTER_CNT_MASK) | ((val) << SCCSC_PIXEL_MISS_COUNTER_CNT_SHIFT))
  
  //====================================================================
  //Register: Cache Latency counter (LATENCY_COUNTER)
  /** \brief Cache latency counter*/
  //====================================================================
  
  #define  SCCSC_LATENCY_COUNTER_CNT_MASK 0xffffffff
  #define  SCCSC_LATENCY_COUNTER_CNT_SHIFT 0
  #define  SCCSC_LATENCY_COUNTER_CNT_MASK_SHIFT(reg) (((reg) & SCCSC_LATENCY_COUNTER_CNT_MASK) >> SCCSC_LATENCY_COUNTER_CNT_SHIFT)
  #define  SCCSC_LATENCY_COUNTER_CNT_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_LATENCY_COUNTER_CNT_MASK) | ((val) << SCCSC_LATENCY_COUNTER_CNT_SHIFT))
  
  //====================================================================
  //Register: Cached LUT Base Address (BASE_ADDR)
  /** \brief Cached LUT Base Address in system memory*/
  //====================================================================
  
  #define  SCCSC_BASE_ADDR_ADDR_MASK 0xfffffff8
  #define  SCCSC_BASE_ADDR_ADDR_SHIFT 3
  #define  SCCSC_BASE_ADDR_ADDR_MASK_SHIFT(reg) (((reg) & SCCSC_BASE_ADDR_ADDR_MASK) >> SCCSC_BASE_ADDR_ADDR_SHIFT)
  #define  SCCSC_BASE_ADDR_ADDR_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_BASE_ADDR_ADDR_MASK) | ((val) << SCCSC_BASE_ADDR_ADDR_SHIFT))
  
  #define  SCCSC_BASE_ADDR_RESERVED1_MASK 0x7
  #define  SCCSC_BASE_ADDR_RESERVED1_SHIFT 0
  #define  SCCSC_BASE_ADDR_RESERVED1_MASK_SHIFT(reg) (((reg) & SCCSC_BASE_ADDR_RESERVED1_MASK) >> SCCSC_BASE_ADDR_RESERVED1_SHIFT)
  #define  SCCSC_BASE_ADDR_RESERVED1_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_BASE_ADDR_RESERVED1_MASK) | ((val) << SCCSC_BASE_ADDR_RESERVED1_SHIFT))
  
  //====================================================================
  //Register: White Threshold settings (WT)
  /** \brief Input White Threshold settings.
  If white mapping is enabled (WME=1) and the incoming pixel exceeds all input channel White thresholds, the pre-defined WHITE RESPONSE (WR register) will be output.*/
  //====================================================================
  
  #define  SCCSC_WT_RESERVED1_MASK 0xc0000000
  #define  SCCSC_WT_RESERVED1_SHIFT 30
  #define  SCCSC_WT_RESERVED1_MASK_SHIFT(reg) (((reg) & SCCSC_WT_RESERVED1_MASK) >> SCCSC_WT_RESERVED1_SHIFT)
  #define  SCCSC_WT_RESERVED1_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_WT_RESERVED1_MASK) | ((val) << SCCSC_WT_RESERVED1_SHIFT))
  
  #define  SCCSC_WT_CH0_WT_MASK 0x3ff00000
  #define  SCCSC_WT_CH0_WT_SHIFT 20
  #define  SCCSC_WT_CH0_WT_MASK_SHIFT(reg) (((reg) & SCCSC_WT_CH0_WT_MASK) >> SCCSC_WT_CH0_WT_SHIFT)
  #define  SCCSC_WT_CH0_WT_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_WT_CH0_WT_MASK) | ((val) << SCCSC_WT_CH0_WT_SHIFT))
  
  #define  SCCSC_WT_CH1_WT_MASK 0xffc00
  #define  SCCSC_WT_CH1_WT_SHIFT 10
  #define  SCCSC_WT_CH1_WT_MASK_SHIFT(reg) (((reg) & SCCSC_WT_CH1_WT_MASK) >> SCCSC_WT_CH1_WT_SHIFT)
  #define  SCCSC_WT_CH1_WT_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_WT_CH1_WT_MASK) | ((val) << SCCSC_WT_CH1_WT_SHIFT))
  
  #define  SCCSC_WT_CH2_WT_MASK 0x3ff
  #define  SCCSC_WT_CH2_WT_SHIFT 0
  #define  SCCSC_WT_CH2_WT_MASK_SHIFT(reg) (((reg) & SCCSC_WT_CH2_WT_MASK) >> SCCSC_WT_CH2_WT_SHIFT)
  #define  SCCSC_WT_CH2_WT_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_WT_CH2_WT_MASK) | ((val) << SCCSC_WT_CH2_WT_SHIFT))
  
  //====================================================================
  //Register: White Response reg 0  (WR_REG0)
  /** \brief White pixel response values for output channels 0 - 2.*/
  //====================================================================
  
  #define  SCCSC_WR_REG0_RESERVED1_MASK 0xc0000000
  #define  SCCSC_WR_REG0_RESERVED1_SHIFT 30
  #define  SCCSC_WR_REG0_RESERVED1_MASK_SHIFT(reg) (((reg) & SCCSC_WR_REG0_RESERVED1_MASK) >> SCCSC_WR_REG0_RESERVED1_SHIFT)
  #define  SCCSC_WR_REG0_RESERVED1_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_WR_REG0_RESERVED1_MASK) | ((val) << SCCSC_WR_REG0_RESERVED1_SHIFT))
  
  #define  SCCSC_WR_REG0_CH0_WR_MASK 0x3ff00000
  #define  SCCSC_WR_REG0_CH0_WR_SHIFT 20
  #define  SCCSC_WR_REG0_CH0_WR_MASK_SHIFT(reg) (((reg) & SCCSC_WR_REG0_CH0_WR_MASK) >> SCCSC_WR_REG0_CH0_WR_SHIFT)
  #define  SCCSC_WR_REG0_CH0_WR_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_WR_REG0_CH0_WR_MASK) | ((val) << SCCSC_WR_REG0_CH0_WR_SHIFT))
  
  #define  SCCSC_WR_REG0_CH1_WR_MASK 0xffc00
  #define  SCCSC_WR_REG0_CH1_WR_SHIFT 10
  #define  SCCSC_WR_REG0_CH1_WR_MASK_SHIFT(reg) (((reg) & SCCSC_WR_REG0_CH1_WR_MASK) >> SCCSC_WR_REG0_CH1_WR_SHIFT)
  #define  SCCSC_WR_REG0_CH1_WR_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_WR_REG0_CH1_WR_MASK) | ((val) << SCCSC_WR_REG0_CH1_WR_SHIFT))
  
  #define  SCCSC_WR_REG0_CH2_WR_MASK 0x3ff
  #define  SCCSC_WR_REG0_CH2_WR_SHIFT 0
  #define  SCCSC_WR_REG0_CH2_WR_MASK_SHIFT(reg) (((reg) & SCCSC_WR_REG0_CH2_WR_MASK) >> SCCSC_WR_REG0_CH2_WR_SHIFT)
  #define  SCCSC_WR_REG0_CH2_WR_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_WR_REG0_CH2_WR_MASK) | ((val) << SCCSC_WR_REG0_CH2_WR_SHIFT))
  
  //====================================================================
  //Register: White Response reg 1  (WR_REG1)
  /** \brief White pixel response values for output channels 3 - 5.*/
  //====================================================================
  
  #define  SCCSC_WR_REG1_RESERVED1_MASK 0xc0000000
  #define  SCCSC_WR_REG1_RESERVED1_SHIFT 30
  #define  SCCSC_WR_REG1_RESERVED1_MASK_SHIFT(reg) (((reg) & SCCSC_WR_REG1_RESERVED1_MASK) >> SCCSC_WR_REG1_RESERVED1_SHIFT)
  #define  SCCSC_WR_REG1_RESERVED1_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_WR_REG1_RESERVED1_MASK) | ((val) << SCCSC_WR_REG1_RESERVED1_SHIFT))
  
  #define  SCCSC_WR_REG1_CH3_WR_MASK 0x3ff00000
  #define  SCCSC_WR_REG1_CH3_WR_SHIFT 20
  #define  SCCSC_WR_REG1_CH3_WR_MASK_SHIFT(reg) (((reg) & SCCSC_WR_REG1_CH3_WR_MASK) >> SCCSC_WR_REG1_CH3_WR_SHIFT)
  #define  SCCSC_WR_REG1_CH3_WR_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_WR_REG1_CH3_WR_MASK) | ((val) << SCCSC_WR_REG1_CH3_WR_SHIFT))
  
  #define  SCCSC_WR_REG1_CH4_WR_MASK 0xffc00
  #define  SCCSC_WR_REG1_CH4_WR_SHIFT 10
  #define  SCCSC_WR_REG1_CH4_WR_MASK_SHIFT(reg) (((reg) & SCCSC_WR_REG1_CH4_WR_MASK) >> SCCSC_WR_REG1_CH4_WR_SHIFT)
  #define  SCCSC_WR_REG1_CH4_WR_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_WR_REG1_CH4_WR_MASK) | ((val) << SCCSC_WR_REG1_CH4_WR_SHIFT))
  
  #define  SCCSC_WR_REG1_CH5_WR_MASK 0x3ff
  #define  SCCSC_WR_REG1_CH5_WR_SHIFT 0
  #define  SCCSC_WR_REG1_CH5_WR_MASK_SHIFT(reg) (((reg) & SCCSC_WR_REG1_CH5_WR_MASK) >> SCCSC_WR_REG1_CH5_WR_SHIFT)
  #define  SCCSC_WR_REG1_CH5_WR_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_WR_REG1_CH5_WR_MASK) | ((val) << SCCSC_WR_REG1_CH5_WR_SHIFT))
  
  //====================================================================
  //Register: White Response reg 2  (WR_REG2)
  /** \brief White pixel response values for output channels 6 - 7.*/
  //====================================================================
  
  #define  SCCSC_WR_REG2_RESERVED1_MASK 0xfff00000
  #define  SCCSC_WR_REG2_RESERVED1_SHIFT 20
  #define  SCCSC_WR_REG2_RESERVED1_MASK_SHIFT(reg) (((reg) & SCCSC_WR_REG2_RESERVED1_MASK) >> SCCSC_WR_REG2_RESERVED1_SHIFT)
  #define  SCCSC_WR_REG2_RESERVED1_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_WR_REG2_RESERVED1_MASK) | ((val) << SCCSC_WR_REG2_RESERVED1_SHIFT))
  
  #define  SCCSC_WR_REG2_CH6_WR_MASK 0xffc00
  #define  SCCSC_WR_REG2_CH6_WR_SHIFT 10
  #define  SCCSC_WR_REG2_CH6_WR_MASK_SHIFT(reg) (((reg) & SCCSC_WR_REG2_CH6_WR_MASK) >> SCCSC_WR_REG2_CH6_WR_SHIFT)
  #define  SCCSC_WR_REG2_CH6_WR_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_WR_REG2_CH6_WR_MASK) | ((val) << SCCSC_WR_REG2_CH6_WR_SHIFT))
  
  #define  SCCSC_WR_REG2_CH7_WR_MASK 0x3ff
  #define  SCCSC_WR_REG2_CH7_WR_SHIFT 0
  #define  SCCSC_WR_REG2_CH7_WR_MASK_SHIFT(reg) (((reg) & SCCSC_WR_REG2_CH7_WR_MASK) >> SCCSC_WR_REG2_CH7_WR_SHIFT)
  #define  SCCSC_WR_REG2_CH7_WR_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_WR_REG2_CH7_WR_MASK) | ((val) << SCCSC_WR_REG2_CH7_WR_SHIFT))
  
  //====================================================================
  //Register: Black Response Reg 0  (KR_REG0)
  /** \brief Black pixel response values for output channels 0 - 2.*/
  //====================================================================
  
  #define  SCCSC_KR_REG0_RESERVED1_MASK 0xc0000000
  #define  SCCSC_KR_REG0_RESERVED1_SHIFT 30
  #define  SCCSC_KR_REG0_RESERVED1_MASK_SHIFT(reg) (((reg) & SCCSC_KR_REG0_RESERVED1_MASK) >> SCCSC_KR_REG0_RESERVED1_SHIFT)
  #define  SCCSC_KR_REG0_RESERVED1_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_KR_REG0_RESERVED1_MASK) | ((val) << SCCSC_KR_REG0_RESERVED1_SHIFT))
  
  #define  SCCSC_KR_REG0_CH0_KR_MASK 0x3ff00000
  #define  SCCSC_KR_REG0_CH0_KR_SHIFT 20
  #define  SCCSC_KR_REG0_CH0_KR_MASK_SHIFT(reg) (((reg) & SCCSC_KR_REG0_CH0_KR_MASK) >> SCCSC_KR_REG0_CH0_KR_SHIFT)
  #define  SCCSC_KR_REG0_CH0_KR_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_KR_REG0_CH0_KR_MASK) | ((val) << SCCSC_KR_REG0_CH0_KR_SHIFT))
  
  #define  SCCSC_KR_REG0_CH1_KR_MASK 0xffc00
  #define  SCCSC_KR_REG0_CH1_KR_SHIFT 10
  #define  SCCSC_KR_REG0_CH1_KR_MASK_SHIFT(reg) (((reg) & SCCSC_KR_REG0_CH1_KR_MASK) >> SCCSC_KR_REG0_CH1_KR_SHIFT)
  #define  SCCSC_KR_REG0_CH1_KR_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_KR_REG0_CH1_KR_MASK) | ((val) << SCCSC_KR_REG0_CH1_KR_SHIFT))
  
  #define  SCCSC_KR_REG0_CH2_KR_MASK 0x3ff
  #define  SCCSC_KR_REG0_CH2_KR_SHIFT 0
  #define  SCCSC_KR_REG0_CH2_KR_MASK_SHIFT(reg) (((reg) & SCCSC_KR_REG0_CH2_KR_MASK) >> SCCSC_KR_REG0_CH2_KR_SHIFT)
  #define  SCCSC_KR_REG0_CH2_KR_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_KR_REG0_CH2_KR_MASK) | ((val) << SCCSC_KR_REG0_CH2_KR_SHIFT))
  
  //====================================================================
  //Register: Black Response Reg 1  (KR_REG1)
  /** \brief Black pixel response values for output channels 3 - 5.*/
  //====================================================================
  
  #define  SCCSC_KR_REG1_RESERVED1_MASK 0xc0000000
  #define  SCCSC_KR_REG1_RESERVED1_SHIFT 30
  #define  SCCSC_KR_REG1_RESERVED1_MASK_SHIFT(reg) (((reg) & SCCSC_KR_REG1_RESERVED1_MASK) >> SCCSC_KR_REG1_RESERVED1_SHIFT)
  #define  SCCSC_KR_REG1_RESERVED1_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_KR_REG1_RESERVED1_MASK) | ((val) << SCCSC_KR_REG1_RESERVED1_SHIFT))
  
  #define  SCCSC_KR_REG1_CH3_KR_MASK 0x3ff00000
  #define  SCCSC_KR_REG1_CH3_KR_SHIFT 20
  #define  SCCSC_KR_REG1_CH3_KR_MASK_SHIFT(reg) (((reg) & SCCSC_KR_REG1_CH3_KR_MASK) >> SCCSC_KR_REG1_CH3_KR_SHIFT)
  #define  SCCSC_KR_REG1_CH3_KR_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_KR_REG1_CH3_KR_MASK) | ((val) << SCCSC_KR_REG1_CH3_KR_SHIFT))
  
  #define  SCCSC_KR_REG1_CH4_KR_MASK 0xffc00
  #define  SCCSC_KR_REG1_CH4_KR_SHIFT 10
  #define  SCCSC_KR_REG1_CH4_KR_MASK_SHIFT(reg) (((reg) & SCCSC_KR_REG1_CH4_KR_MASK) >> SCCSC_KR_REG1_CH4_KR_SHIFT)
  #define  SCCSC_KR_REG1_CH4_KR_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_KR_REG1_CH4_KR_MASK) | ((val) << SCCSC_KR_REG1_CH4_KR_SHIFT))
  
  #define  SCCSC_KR_REG1_CH5_KR_MASK 0x3ff
  #define  SCCSC_KR_REG1_CH5_KR_SHIFT 0
  #define  SCCSC_KR_REG1_CH5_KR_MASK_SHIFT(reg) (((reg) & SCCSC_KR_REG1_CH5_KR_MASK) >> SCCSC_KR_REG1_CH5_KR_SHIFT)
  #define  SCCSC_KR_REG1_CH5_KR_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_KR_REG1_CH5_KR_MASK) | ((val) << SCCSC_KR_REG1_CH5_KR_SHIFT))
  
  //====================================================================
  //Register: Black Response Reg 2  (KR_REG2)
  /** \brief Black pixel response values for output channels 6 - 7.*/
  //====================================================================
  
  #define  SCCSC_KR_REG2_RESERVED1_MASK 0xfff00000
  #define  SCCSC_KR_REG2_RESERVED1_SHIFT 20
  #define  SCCSC_KR_REG2_RESERVED1_MASK_SHIFT(reg) (((reg) & SCCSC_KR_REG2_RESERVED1_MASK) >> SCCSC_KR_REG2_RESERVED1_SHIFT)
  #define  SCCSC_KR_REG2_RESERVED1_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_KR_REG2_RESERVED1_MASK) | ((val) << SCCSC_KR_REG2_RESERVED1_SHIFT))
  
  #define  SCCSC_KR_REG2_CH6_KR_MASK 0xffc00
  #define  SCCSC_KR_REG2_CH6_KR_SHIFT 10
  #define  SCCSC_KR_REG2_CH6_KR_MASK_SHIFT(reg) (((reg) & SCCSC_KR_REG2_CH6_KR_MASK) >> SCCSC_KR_REG2_CH6_KR_SHIFT)
  #define  SCCSC_KR_REG2_CH6_KR_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_KR_REG2_CH6_KR_MASK) | ((val) << SCCSC_KR_REG2_CH6_KR_SHIFT))
  
  #define  SCCSC_KR_REG2_CH7_KR_MASK 0x3ff
  #define  SCCSC_KR_REG2_CH7_KR_SHIFT 0
  #define  SCCSC_KR_REG2_CH7_KR_MASK_SHIFT(reg) (((reg) & SCCSC_KR_REG2_CH7_KR_MASK) >> SCCSC_KR_REG2_CH7_KR_SHIFT)
  #define  SCCSC_KR_REG2_CH7_KR_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_KR_REG2_CH7_KR_MASK) | ((val) << SCCSC_KR_REG2_CH7_KR_SHIFT))
  
  //====================================================================
  //Register: SRAM Address  (RAR)
  /** \brief Write Only RAM address and control for CPU Access to the 8 iLUT and 8 Cache RAMS
  Register is ignored unless CPUAccess bit of the CNTRL register is asserted.*/
  //====================================================================
  
  #define  SCCSC_RAR_AUTOINC_MASK 0x80000000
  #define  SCCSC_RAR_AUTOINC_SHIFT 31
  #define  SCCSC_RAR_AUTOINC_MASK_SHIFT(reg) (((reg) & SCCSC_RAR_AUTOINC_MASK) >> SCCSC_RAR_AUTOINC_SHIFT)
  #define  SCCSC_RAR_AUTOINC_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_RAR_AUTOINC_MASK) | ((val) << SCCSC_RAR_AUTOINC_SHIFT))
  
  #define  SCCSC_RAR_RESERVED1_MASK 0x7ffe0000
  #define  SCCSC_RAR_RESERVED1_SHIFT 17
  #define  SCCSC_RAR_RESERVED1_MASK_SHIFT(reg) (((reg) & SCCSC_RAR_RESERVED1_MASK) >> SCCSC_RAR_RESERVED1_SHIFT)
  #define  SCCSC_RAR_RESERVED1_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_RAR_RESERVED1_MASK) | ((val) << SCCSC_RAR_RESERVED1_SHIFT))
  
  #define  SCCSC_RAR_RNW_MASK 0x10000
  #define  SCCSC_RAR_RNW_SHIFT 16
  #define  SCCSC_RAR_RNW_MASK_SHIFT(reg) (((reg) & SCCSC_RAR_RNW_MASK) >> SCCSC_RAR_RNW_SHIFT)
  #define  SCCSC_RAR_RNW_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_RAR_RNW_MASK) | ((val) << SCCSC_RAR_RNW_SHIFT))
  
  #define  SCCSC_RAR_RESERVED2_MASK 0xc000
  #define  SCCSC_RAR_RESERVED2_SHIFT 14
  #define  SCCSC_RAR_RESERVED2_MASK_SHIFT(reg) (((reg) & SCCSC_RAR_RESERVED2_MASK) >> SCCSC_RAR_RESERVED2_SHIFT)
  #define  SCCSC_RAR_RESERVED2_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_RAR_RESERVED2_MASK) | ((val) << SCCSC_RAR_RESERVED2_SHIFT))
  
  #define  SCCSC_RAR_ADDR_MASK 0x3fff
  #define  SCCSC_RAR_ADDR_SHIFT 0
  #define  SCCSC_RAR_ADDR_MASK_SHIFT(reg) (((reg) & SCCSC_RAR_ADDR_MASK) >> SCCSC_RAR_ADDR_SHIFT)
  #define  SCCSC_RAR_ADDR_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_RAR_ADDR_MASK) | ((val) << SCCSC_RAR_ADDR_SHIFT))
  
  //====================================================================
  //Register: RAM Data Write 0 (RDW0)
  /** \brief CPU Access Write data[31:0] to RAMs*/
  //====================================================================
  
  #define  SCCSC_RDW0_DATA_MASK 0xffffffff
  #define  SCCSC_RDW0_DATA_SHIFT 0
  #define  SCCSC_RDW0_DATA_MASK_SHIFT(reg) (((reg) & SCCSC_RDW0_DATA_MASK) >> SCCSC_RDW0_DATA_SHIFT)
  #define  SCCSC_RDW0_DATA_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_RDW0_DATA_MASK) | ((val) << SCCSC_RDW0_DATA_SHIFT))
  
  //====================================================================
  //Register: RAM Data Write 1 (RDW1)
  /** \brief CPU Access Write data[63:32] to RAMs*/
  //====================================================================
  
  #define  SCCSC_RDW1_DATA_MASK 0xffffffff
  #define  SCCSC_RDW1_DATA_SHIFT 0
  #define  SCCSC_RDW1_DATA_MASK_SHIFT(reg) (((reg) & SCCSC_RDW1_DATA_MASK) >> SCCSC_RDW1_DATA_SHIFT)
  #define  SCCSC_RDW1_DATA_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_RDW1_DATA_MASK) | ((val) << SCCSC_RDW1_DATA_SHIFT))
  
  //====================================================================
  //Register: RAM Data Write 2 (RDW2)
  /** \brief CPU Access Write data[79:64] to RAMs. Currently only used for cache RAMS bits[67:64]*/
  //====================================================================
  
  #define  SCCSC_RDW2_RESERVED1_MASK 0xffff0000
  #define  SCCSC_RDW2_RESERVED1_SHIFT 16
  #define  SCCSC_RDW2_RESERVED1_MASK_SHIFT(reg) (((reg) & SCCSC_RDW2_RESERVED1_MASK) >> SCCSC_RDW2_RESERVED1_SHIFT)
  #define  SCCSC_RDW2_RESERVED1_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_RDW2_RESERVED1_MASK) | ((val) << SCCSC_RDW2_RESERVED1_SHIFT))
  
  #define  SCCSC_RDW2_DATA_MASK 0xffff
  #define  SCCSC_RDW2_DATA_SHIFT 0
  #define  SCCSC_RDW2_DATA_MASK_SHIFT(reg) (((reg) & SCCSC_RDW2_DATA_MASK) >> SCCSC_RDW2_DATA_SHIFT)
  #define  SCCSC_RDW2_DATA_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_RDW2_DATA_MASK) | ((val) << SCCSC_RDW2_DATA_SHIFT))
  
  //====================================================================
  //Register: RAM Data Read 0 (RDR0)
  /** \brief CPU Access Read data[31:0] from RAMs*/
  //====================================================================
  
  #define  SCCSC_RDR0_DATA_MASK 0xffffffff
  #define  SCCSC_RDR0_DATA_SHIFT 0
  #define  SCCSC_RDR0_DATA_MASK_SHIFT(reg) (((reg) & SCCSC_RDR0_DATA_MASK) >> SCCSC_RDR0_DATA_SHIFT)
  #define  SCCSC_RDR0_DATA_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_RDR0_DATA_MASK) | ((val) << SCCSC_RDR0_DATA_SHIFT))
  
  //====================================================================
  //Register: RAM Data Read 1 (RDR1)
  /** \brief CPU Access Read data[63:32] from RAMs*/
  //====================================================================
  
  #define  SCCSC_RDR1_DATA_MASK 0xffffffff
  #define  SCCSC_RDR1_DATA_SHIFT 0
  #define  SCCSC_RDR1_DATA_MASK_SHIFT(reg) (((reg) & SCCSC_RDR1_DATA_MASK) >> SCCSC_RDR1_DATA_SHIFT)
  #define  SCCSC_RDR1_DATA_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_RDR1_DATA_MASK) | ((val) << SCCSC_RDR1_DATA_SHIFT))
  
  //====================================================================
  //Register: RAM Data Read 2 (RDR2)
  /** \brief CPU Access Read data[79:64] from RAMs. Currently only used for cache RAMS bits[67:64].*/
  //====================================================================
  
  #define  SCCSC_RDR2_RESERVED1_MASK 0xffff0000
  #define  SCCSC_RDR2_RESERVED1_SHIFT 16
  #define  SCCSC_RDR2_RESERVED1_MASK_SHIFT(reg) (((reg) & SCCSC_RDR2_RESERVED1_MASK) >> SCCSC_RDR2_RESERVED1_SHIFT)
  #define  SCCSC_RDR2_RESERVED1_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_RDR2_RESERVED1_MASK) | ((val) << SCCSC_RDR2_RESERVED1_SHIFT))
  
  #define  SCCSC_RDR2_DATA_MASK 0xffff
  #define  SCCSC_RDR2_DATA_SHIFT 0
  #define  SCCSC_RDR2_DATA_MASK_SHIFT(reg) (((reg) & SCCSC_RDR2_DATA_MASK) >> SCCSC_RDR2_DATA_SHIFT)
  #define  SCCSC_RDR2_DATA_REPLACE_VAL(reg,val) (((reg) & ~SCCSC_RDR2_DATA_MASK) | ((val) << SCCSC_RDR2_DATA_SHIFT))
  
  #endif // SCCSC
  