1 /** 2 * \file 3 * 4 * \brief Component description for MCLK 5 * 6 * Copyright (c) 2016 Atmel Corporation, 7 * a wholly owned subsidiary of Microchip Technology Inc. 8 * 9 * \asf_license_start 10 * 11 * \page License 12 * 13 * Licensed under the Apache License, Version 2.0 (the "License"); 14 * you may not use this file except in compliance with the License. 15 * You may obtain a copy of the Licence at 16 * 17 * http://www.apache.org/licenses/LICENSE-2.0 18 * 19 * Unless required by applicable law or agreed to in writing, software 20 * distributed under the License is distributed on an "AS IS" BASIS, 21 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 22 * See the License for the specific language governing permissions and 23 * limitations under the License. 24 * 25 * \asf_license_stop 26 * 27 */ 28 29 #ifndef _SAML21_MCLK_COMPONENT_ 30 #define _SAML21_MCLK_COMPONENT_ 31 32 /* ========================================================================== */ 33 /** SOFTWARE API DEFINITION FOR MCLK */ 34 /* ========================================================================== */ 35 /** \addtogroup SAML21_MCLK Main Clock */ 36 /*@{*/ 37 38 #define MCLK_U2234 39 #define REV_MCLK 0x101 40 41 /* -------- MCLK_CTRLA : (MCLK Offset: 0x00) (R/W 8) Control A -------- */ 42 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) 43 typedef union { 44 uint8_t reg; /*!< Type used for register access */ 45 } MCLK_CTRLA_Type; 46 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ 47 48 #define MCLK_CTRLA_OFFSET 0x00 /**< \brief (MCLK_CTRLA offset) Control A */ 49 #define MCLK_CTRLA_RESETVALUE _U(0x00) /**< \brief (MCLK_CTRLA reset_value) Control A */ 50 #define MCLK_CTRLA_MASK _U(0x00) /**< \brief (MCLK_CTRLA) MASK Register */ 51 52 /* -------- MCLK_INTENCLR : (MCLK Offset: 0x01) (R/W 8) Interrupt Enable Clear -------- */ 53 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) 54 typedef union { 55 struct { 56 uint8_t CKRDY:1; /*!< bit: 0 Clock Ready Interrupt Enable */ 57 uint8_t :7; /*!< bit: 1.. 7 Reserved */ 58 } bit; /*!< Structure used for bit access */ 59 uint8_t reg; /*!< Type used for register access */ 60 } MCLK_INTENCLR_Type; 61 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ 62 63 #define MCLK_INTENCLR_OFFSET 0x01 /**< \brief (MCLK_INTENCLR offset) Interrupt Enable Clear */ 64 #define MCLK_INTENCLR_RESETVALUE _U(0x00) /**< \brief (MCLK_INTENCLR reset_value) Interrupt Enable Clear */ 65 66 #define MCLK_INTENCLR_CKRDY_Pos 0 /**< \brief (MCLK_INTENCLR) Clock Ready Interrupt Enable */ 67 #define MCLK_INTENCLR_CKRDY (_U(0x1) << MCLK_INTENCLR_CKRDY_Pos) 68 #define MCLK_INTENCLR_MASK _U(0x01) /**< \brief (MCLK_INTENCLR) MASK Register */ 69 70 /* -------- MCLK_INTENSET : (MCLK Offset: 0x02) (R/W 8) Interrupt Enable Set -------- */ 71 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) 72 typedef union { 73 struct { 74 uint8_t CKRDY:1; /*!< bit: 0 Clock Ready Interrupt Enable */ 75 uint8_t :7; /*!< bit: 1.. 7 Reserved */ 76 } bit; /*!< Structure used for bit access */ 77 uint8_t reg; /*!< Type used for register access */ 78 } MCLK_INTENSET_Type; 79 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ 80 81 #define MCLK_INTENSET_OFFSET 0x02 /**< \brief (MCLK_INTENSET offset) Interrupt Enable Set */ 82 #define MCLK_INTENSET_RESETVALUE _U(0x00) /**< \brief (MCLK_INTENSET reset_value) Interrupt Enable Set */ 83 84 #define MCLK_INTENSET_CKRDY_Pos 0 /**< \brief (MCLK_INTENSET) Clock Ready Interrupt Enable */ 85 #define MCLK_INTENSET_CKRDY (_U(0x1) << MCLK_INTENSET_CKRDY_Pos) 86 #define MCLK_INTENSET_MASK _U(0x01) /**< \brief (MCLK_INTENSET) MASK Register */ 87 88 /* -------- MCLK_INTFLAG : (MCLK Offset: 0x03) (R/W 8) Interrupt Flag Status and Clear -------- */ 89 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) 90 typedef union { // __I to avoid read-modify-write on write-to-clear register 91 struct { 92 __I uint8_t CKRDY:1; /*!< bit: 0 Clock Ready */ 93 __I uint8_t :7; /*!< bit: 1.. 7 Reserved */ 94 } bit; /*!< Structure used for bit access */ 95 uint8_t reg; /*!< Type used for register access */ 96 } MCLK_INTFLAG_Type; 97 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ 98 99 #define MCLK_INTFLAG_OFFSET 0x03 /**< \brief (MCLK_INTFLAG offset) Interrupt Flag Status and Clear */ 100 #define MCLK_INTFLAG_RESETVALUE _U(0x01) /**< \brief (MCLK_INTFLAG reset_value) Interrupt Flag Status and Clear */ 101 102 #define MCLK_INTFLAG_CKRDY_Pos 0 /**< \brief (MCLK_INTFLAG) Clock Ready */ 103 #define MCLK_INTFLAG_CKRDY (_U(0x1) << MCLK_INTFLAG_CKRDY_Pos) 104 #define MCLK_INTFLAG_MASK _U(0x01) /**< \brief (MCLK_INTFLAG) MASK Register */ 105 106 /* -------- MCLK_CPUDIV : (MCLK Offset: 0x04) (R/W 8) CPU Clock Division -------- */ 107 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) 108 typedef union { 109 struct { 110 uint8_t CPUDIV:8; /*!< bit: 0.. 7 CPU Clock Division Factor */ 111 } bit; /*!< Structure used for bit access */ 112 uint8_t reg; /*!< Type used for register access */ 113 } MCLK_CPUDIV_Type; 114 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ 115 116 #define MCLK_CPUDIV_OFFSET 0x04 /**< \brief (MCLK_CPUDIV offset) CPU Clock Division */ 117 #define MCLK_CPUDIV_RESETVALUE _U(0x01) /**< \brief (MCLK_CPUDIV reset_value) CPU Clock Division */ 118 119 #define MCLK_CPUDIV_CPUDIV_Pos 0 /**< \brief (MCLK_CPUDIV) CPU Clock Division Factor */ 120 #define MCLK_CPUDIV_CPUDIV_Msk (_U(0xFF) << MCLK_CPUDIV_CPUDIV_Pos) 121 #define MCLK_CPUDIV_CPUDIV(value) (MCLK_CPUDIV_CPUDIV_Msk & ((value) << MCLK_CPUDIV_CPUDIV_Pos)) 122 #define MCLK_CPUDIV_CPUDIV_DIV1_Val _U(0x1) /**< \brief (MCLK_CPUDIV) Divide by 1 */ 123 #define MCLK_CPUDIV_CPUDIV_DIV2_Val _U(0x2) /**< \brief (MCLK_CPUDIV) Divide by 2 */ 124 #define MCLK_CPUDIV_CPUDIV_DIV4_Val _U(0x4) /**< \brief (MCLK_CPUDIV) Divide by 4 */ 125 #define MCLK_CPUDIV_CPUDIV_DIV8_Val _U(0x8) /**< \brief (MCLK_CPUDIV) Divide by 8 */ 126 #define MCLK_CPUDIV_CPUDIV_DIV16_Val _U(0x10) /**< \brief (MCLK_CPUDIV) Divide by 16 */ 127 #define MCLK_CPUDIV_CPUDIV_DIV32_Val _U(0x20) /**< \brief (MCLK_CPUDIV) Divide by 32 */ 128 #define MCLK_CPUDIV_CPUDIV_DIV64_Val _U(0x40) /**< \brief (MCLK_CPUDIV) Divide by 64 */ 129 #define MCLK_CPUDIV_CPUDIV_DIV128_Val _U(0x80) /**< \brief (MCLK_CPUDIV) Divide by 128 */ 130 #define MCLK_CPUDIV_CPUDIV_DIV1 (MCLK_CPUDIV_CPUDIV_DIV1_Val << MCLK_CPUDIV_CPUDIV_Pos) 131 #define MCLK_CPUDIV_CPUDIV_DIV2 (MCLK_CPUDIV_CPUDIV_DIV2_Val << MCLK_CPUDIV_CPUDIV_Pos) 132 #define MCLK_CPUDIV_CPUDIV_DIV4 (MCLK_CPUDIV_CPUDIV_DIV4_Val << MCLK_CPUDIV_CPUDIV_Pos) 133 #define MCLK_CPUDIV_CPUDIV_DIV8 (MCLK_CPUDIV_CPUDIV_DIV8_Val << MCLK_CPUDIV_CPUDIV_Pos) 134 #define MCLK_CPUDIV_CPUDIV_DIV16 (MCLK_CPUDIV_CPUDIV_DIV16_Val << MCLK_CPUDIV_CPUDIV_Pos) 135 #define MCLK_CPUDIV_CPUDIV_DIV32 (MCLK_CPUDIV_CPUDIV_DIV32_Val << MCLK_CPUDIV_CPUDIV_Pos) 136 #define MCLK_CPUDIV_CPUDIV_DIV64 (MCLK_CPUDIV_CPUDIV_DIV64_Val << MCLK_CPUDIV_CPUDIV_Pos) 137 #define MCLK_CPUDIV_CPUDIV_DIV128 (MCLK_CPUDIV_CPUDIV_DIV128_Val << MCLK_CPUDIV_CPUDIV_Pos) 138 #define MCLK_CPUDIV_MASK _U(0xFF) /**< \brief (MCLK_CPUDIV) MASK Register */ 139 140 /* -------- MCLK_LPDIV : (MCLK Offset: 0x05) (R/W 8) Low-Power Clock Division -------- */ 141 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) 142 typedef union { 143 struct { 144 uint8_t LPDIV:8; /*!< bit: 0.. 7 Low-Power Clock Division Factor */ 145 } bit; /*!< Structure used for bit access */ 146 uint8_t reg; /*!< Type used for register access */ 147 } MCLK_LPDIV_Type; 148 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ 149 150 #define MCLK_LPDIV_OFFSET 0x05 /**< \brief (MCLK_LPDIV offset) Low-Power Clock Division */ 151 #define MCLK_LPDIV_RESETVALUE _U(0x01) /**< \brief (MCLK_LPDIV reset_value) Low-Power Clock Division */ 152 153 #define MCLK_LPDIV_LPDIV_Pos 0 /**< \brief (MCLK_LPDIV) Low-Power Clock Division Factor */ 154 #define MCLK_LPDIV_LPDIV_Msk (_U(0xFF) << MCLK_LPDIV_LPDIV_Pos) 155 #define MCLK_LPDIV_LPDIV(value) (MCLK_LPDIV_LPDIV_Msk & ((value) << MCLK_LPDIV_LPDIV_Pos)) 156 #define MCLK_LPDIV_LPDIV_DIV1_Val _U(0x1) /**< \brief (MCLK_LPDIV) Divide by 1 */ 157 #define MCLK_LPDIV_LPDIV_DIV2_Val _U(0x2) /**< \brief (MCLK_LPDIV) Divide by 2 */ 158 #define MCLK_LPDIV_LPDIV_DIV4_Val _U(0x4) /**< \brief (MCLK_LPDIV) Divide by 4 */ 159 #define MCLK_LPDIV_LPDIV_DIV8_Val _U(0x8) /**< \brief (MCLK_LPDIV) Divide by 8 */ 160 #define MCLK_LPDIV_LPDIV_DIV16_Val _U(0x10) /**< \brief (MCLK_LPDIV) Divide by 16 */ 161 #define MCLK_LPDIV_LPDIV_DIV32_Val _U(0x20) /**< \brief (MCLK_LPDIV) Divide by 32 */ 162 #define MCLK_LPDIV_LPDIV_DIV64_Val _U(0x40) /**< \brief (MCLK_LPDIV) Divide by 64 */ 163 #define MCLK_LPDIV_LPDIV_DIV128_Val _U(0x80) /**< \brief (MCLK_LPDIV) Divide by 128 */ 164 #define MCLK_LPDIV_LPDIV_DIV1 (MCLK_LPDIV_LPDIV_DIV1_Val << MCLK_LPDIV_LPDIV_Pos) 165 #define MCLK_LPDIV_LPDIV_DIV2 (MCLK_LPDIV_LPDIV_DIV2_Val << MCLK_LPDIV_LPDIV_Pos) 166 #define MCLK_LPDIV_LPDIV_DIV4 (MCLK_LPDIV_LPDIV_DIV4_Val << MCLK_LPDIV_LPDIV_Pos) 167 #define MCLK_LPDIV_LPDIV_DIV8 (MCLK_LPDIV_LPDIV_DIV8_Val << MCLK_LPDIV_LPDIV_Pos) 168 #define MCLK_LPDIV_LPDIV_DIV16 (MCLK_LPDIV_LPDIV_DIV16_Val << MCLK_LPDIV_LPDIV_Pos) 169 #define MCLK_LPDIV_LPDIV_DIV32 (MCLK_LPDIV_LPDIV_DIV32_Val << MCLK_LPDIV_LPDIV_Pos) 170 #define MCLK_LPDIV_LPDIV_DIV64 (MCLK_LPDIV_LPDIV_DIV64_Val << MCLK_LPDIV_LPDIV_Pos) 171 #define MCLK_LPDIV_LPDIV_DIV128 (MCLK_LPDIV_LPDIV_DIV128_Val << MCLK_LPDIV_LPDIV_Pos) 172 #define MCLK_LPDIV_MASK _U(0xFF) /**< \brief (MCLK_LPDIV) MASK Register */ 173 174 /* -------- MCLK_BUPDIV : (MCLK Offset: 0x06) (R/W 8) Backup Clock Division -------- */ 175 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) 176 typedef union { 177 struct { 178 uint8_t BUPDIV:8; /*!< bit: 0.. 7 Backup Clock Division Factor */ 179 } bit; /*!< Structure used for bit access */ 180 uint8_t reg; /*!< Type used for register access */ 181 } MCLK_BUPDIV_Type; 182 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ 183 184 #define MCLK_BUPDIV_OFFSET 0x06 /**< \brief (MCLK_BUPDIV offset) Backup Clock Division */ 185 #define MCLK_BUPDIV_RESETVALUE _U(0x01) /**< \brief (MCLK_BUPDIV reset_value) Backup Clock Division */ 186 187 #define MCLK_BUPDIV_BUPDIV_Pos 0 /**< \brief (MCLK_BUPDIV) Backup Clock Division Factor */ 188 #define MCLK_BUPDIV_BUPDIV_Msk (_U(0xFF) << MCLK_BUPDIV_BUPDIV_Pos) 189 #define MCLK_BUPDIV_BUPDIV(value) (MCLK_BUPDIV_BUPDIV_Msk & ((value) << MCLK_BUPDIV_BUPDIV_Pos)) 190 #define MCLK_BUPDIV_BUPDIV_DIV1_Val _U(0x1) /**< \brief (MCLK_BUPDIV) Divide by 1 */ 191 #define MCLK_BUPDIV_BUPDIV_DIV2_Val _U(0x2) /**< \brief (MCLK_BUPDIV) Divide by 2 */ 192 #define MCLK_BUPDIV_BUPDIV_DIV4_Val _U(0x4) /**< \brief (MCLK_BUPDIV) Divide by 4 */ 193 #define MCLK_BUPDIV_BUPDIV_DIV8_Val _U(0x8) /**< \brief (MCLK_BUPDIV) Divide by 8 */ 194 #define MCLK_BUPDIV_BUPDIV_DIV16_Val _U(0x10) /**< \brief (MCLK_BUPDIV) Divide by 16 */ 195 #define MCLK_BUPDIV_BUPDIV_DIV32_Val _U(0x20) /**< \brief (MCLK_BUPDIV) Divide by 32 */ 196 #define MCLK_BUPDIV_BUPDIV_DIV64_Val _U(0x40) /**< \brief (MCLK_BUPDIV) Divide by 64 */ 197 #define MCLK_BUPDIV_BUPDIV_DIV128_Val _U(0x80) /**< \brief (MCLK_BUPDIV) Divide by 128 */ 198 #define MCLK_BUPDIV_BUPDIV_DIV1 (MCLK_BUPDIV_BUPDIV_DIV1_Val << MCLK_BUPDIV_BUPDIV_Pos) 199 #define MCLK_BUPDIV_BUPDIV_DIV2 (MCLK_BUPDIV_BUPDIV_DIV2_Val << MCLK_BUPDIV_BUPDIV_Pos) 200 #define MCLK_BUPDIV_BUPDIV_DIV4 (MCLK_BUPDIV_BUPDIV_DIV4_Val << MCLK_BUPDIV_BUPDIV_Pos) 201 #define MCLK_BUPDIV_BUPDIV_DIV8 (MCLK_BUPDIV_BUPDIV_DIV8_Val << MCLK_BUPDIV_BUPDIV_Pos) 202 #define MCLK_BUPDIV_BUPDIV_DIV16 (MCLK_BUPDIV_BUPDIV_DIV16_Val << MCLK_BUPDIV_BUPDIV_Pos) 203 #define MCLK_BUPDIV_BUPDIV_DIV32 (MCLK_BUPDIV_BUPDIV_DIV32_Val << MCLK_BUPDIV_BUPDIV_Pos) 204 #define MCLK_BUPDIV_BUPDIV_DIV64 (MCLK_BUPDIV_BUPDIV_DIV64_Val << MCLK_BUPDIV_BUPDIV_Pos) 205 #define MCLK_BUPDIV_BUPDIV_DIV128 (MCLK_BUPDIV_BUPDIV_DIV128_Val << MCLK_BUPDIV_BUPDIV_Pos) 206 #define MCLK_BUPDIV_MASK _U(0xFF) /**< \brief (MCLK_BUPDIV) MASK Register */ 207 208 /* -------- MCLK_AHBMASK : (MCLK Offset: 0x10) (R/W 32) AHB Mask -------- */ 209 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) 210 typedef union { 211 struct { 212 uint32_t HPB0_:1; /*!< bit: 0 HPB0 AHB Clock Mask */ 213 uint32_t HPB1_:1; /*!< bit: 1 HPB1 AHB Clock Mask */ 214 uint32_t HPB2_:1; /*!< bit: 2 HPB2 AHB Clock Mask */ 215 uint32_t HPB3_:1; /*!< bit: 3 HPB3 AHB Clock Mask */ 216 uint32_t HPB4_:1; /*!< bit: 4 HPB4 AHB Clock Mask */ 217 uint32_t DSU_:1; /*!< bit: 5 DSU AHB Clock Mask */ 218 uint32_t :2; /*!< bit: 6.. 7 Reserved */ 219 uint32_t NVMCTRL_:1; /*!< bit: 8 NVMCTRL AHB Clock Mask */ 220 uint32_t HSRAM_:1; /*!< bit: 9 HSRAM AHB Clock Mask */ 221 uint32_t LPRAM_:1; /*!< bit: 10 LPRAM AHB Clock Mask */ 222 uint32_t DMAC_:1; /*!< bit: 11 DMAC AHB Clock Mask */ 223 uint32_t USB_:1; /*!< bit: 12 USB AHB Clock Mask */ 224 uint32_t :1; /*!< bit: 13 Reserved */ 225 uint32_t PAC_:1; /*!< bit: 14 PAC AHB Clock Mask */ 226 uint32_t NVMCTRL_PICACHU_:1; /*!< bit: 15 NVMCTRL_PICACHU AHB Clock Mask */ 227 uint32_t L2HBRIDGES_H_:1; /*!< bit: 16 L2HBRIDGES_H AHB Clock Mask */ 228 uint32_t H2LBRIDGES_H_:1; /*!< bit: 17 H2LBRIDGES_H AHB Clock Mask */ 229 uint32_t HMCRAMCHS_AHBSETUPKEEPER_:1; /*!< bit: 18 HMCRAMCHS_AHBSETUPKEEPER AHB Clock Mask */ 230 uint32_t HMCRAMCHS_HMATRIXLP2HMCRAMCHSBRIDGE_:1; /*!< bit: 19 HMCRAMCHS_HMATRIXLP2HMCRAMCHSBRIDGE AHB Clock Mask */ 231 uint32_t :12; /*!< bit: 20..31 Reserved */ 232 } bit; /*!< Structure used for bit access */ 233 uint32_t reg; /*!< Type used for register access */ 234 } MCLK_AHBMASK_Type; 235 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ 236 237 #define MCLK_AHBMASK_OFFSET 0x10 /**< \brief (MCLK_AHBMASK offset) AHB Mask */ 238 #define MCLK_AHBMASK_RESETVALUE _U(0x000FFFFF) /**< \brief (MCLK_AHBMASK reset_value) AHB Mask */ 239 240 #define MCLK_AHBMASK_HPB0_Pos 0 /**< \brief (MCLK_AHBMASK) HPB0 AHB Clock Mask */ 241 #define MCLK_AHBMASK_HPB0 (_U(0x1) << MCLK_AHBMASK_HPB0_Pos) 242 #define MCLK_AHBMASK_HPB1_Pos 1 /**< \brief (MCLK_AHBMASK) HPB1 AHB Clock Mask */ 243 #define MCLK_AHBMASK_HPB1 (_U(0x1) << MCLK_AHBMASK_HPB1_Pos) 244 #define MCLK_AHBMASK_HPB2_Pos 2 /**< \brief (MCLK_AHBMASK) HPB2 AHB Clock Mask */ 245 #define MCLK_AHBMASK_HPB2 (_U(0x1) << MCLK_AHBMASK_HPB2_Pos) 246 #define MCLK_AHBMASK_HPB3_Pos 3 /**< \brief (MCLK_AHBMASK) HPB3 AHB Clock Mask */ 247 #define MCLK_AHBMASK_HPB3 (_U(0x1) << MCLK_AHBMASK_HPB3_Pos) 248 #define MCLK_AHBMASK_HPB4_Pos 4 /**< \brief (MCLK_AHBMASK) HPB4 AHB Clock Mask */ 249 #define MCLK_AHBMASK_HPB4 (_U(0x1) << MCLK_AHBMASK_HPB4_Pos) 250 #define MCLK_AHBMASK_DSU_Pos 5 /**< \brief (MCLK_AHBMASK) DSU AHB Clock Mask */ 251 #define MCLK_AHBMASK_DSU (_U(0x1) << MCLK_AHBMASK_DSU_Pos) 252 #define MCLK_AHBMASK_NVMCTRL_Pos 8 /**< \brief (MCLK_AHBMASK) NVMCTRL AHB Clock Mask */ 253 #define MCLK_AHBMASK_NVMCTRL (_U(0x1) << MCLK_AHBMASK_NVMCTRL_Pos) 254 #define MCLK_AHBMASK_HSRAM_Pos 9 /**< \brief (MCLK_AHBMASK) HSRAM AHB Clock Mask */ 255 #define MCLK_AHBMASK_HSRAM (_U(0x1) << MCLK_AHBMASK_HSRAM_Pos) 256 #define MCLK_AHBMASK_LPRAM_Pos 10 /**< \brief (MCLK_AHBMASK) LPRAM AHB Clock Mask */ 257 #define MCLK_AHBMASK_LPRAM (_U(0x1) << MCLK_AHBMASK_LPRAM_Pos) 258 #define MCLK_AHBMASK_DMAC_Pos 11 /**< \brief (MCLK_AHBMASK) DMAC AHB Clock Mask */ 259 #define MCLK_AHBMASK_DMAC (_U(0x1) << MCLK_AHBMASK_DMAC_Pos) 260 #define MCLK_AHBMASK_USB_Pos 12 /**< \brief (MCLK_AHBMASK) USB AHB Clock Mask */ 261 #define MCLK_AHBMASK_USB (_U(0x1) << MCLK_AHBMASK_USB_Pos) 262 #define MCLK_AHBMASK_PAC_Pos 14 /**< \brief (MCLK_AHBMASK) PAC AHB Clock Mask */ 263 #define MCLK_AHBMASK_PAC (_U(0x1) << MCLK_AHBMASK_PAC_Pos) 264 #define MCLK_AHBMASK_NVMCTRL_PICACHU_Pos 15 /**< \brief (MCLK_AHBMASK) NVMCTRL_PICACHU AHB Clock Mask */ 265 #define MCLK_AHBMASK_NVMCTRL_PICACHU (_U(0x1) << MCLK_AHBMASK_NVMCTRL_PICACHU_Pos) 266 #define MCLK_AHBMASK_L2HBRIDGES_H_Pos 16 /**< \brief (MCLK_AHBMASK) L2HBRIDGES_H AHB Clock Mask */ 267 #define MCLK_AHBMASK_L2HBRIDGES_H (_U(0x1) << MCLK_AHBMASK_L2HBRIDGES_H_Pos) 268 #define MCLK_AHBMASK_H2LBRIDGES_H_Pos 17 /**< \brief (MCLK_AHBMASK) H2LBRIDGES_H AHB Clock Mask */ 269 #define MCLK_AHBMASK_H2LBRIDGES_H (_U(0x1) << MCLK_AHBMASK_H2LBRIDGES_H_Pos) 270 #define MCLK_AHBMASK_HMCRAMCHS_AHBSETUPKEEPER_Pos 18 /**< \brief (MCLK_AHBMASK) HMCRAMCHS_AHBSETUPKEEPER AHB Clock Mask */ 271 #define MCLK_AHBMASK_HMCRAMCHS_AHBSETUPKEEPER (_U(0x1) << MCLK_AHBMASK_HMCRAMCHS_AHBSETUPKEEPER_Pos) 272 #define MCLK_AHBMASK_HMCRAMCHS_HMATRIXLP2HMCRAMCHSBRIDGE_Pos 19 /**< \brief (MCLK_AHBMASK) HMCRAMCHS_HMATRIXLP2HMCRAMCHSBRIDGE AHB Clock Mask */ 273 #define MCLK_AHBMASK_HMCRAMCHS_HMATRIXLP2HMCRAMCHSBRIDGE (_U(0x1) << MCLK_AHBMASK_HMCRAMCHS_HMATRIXLP2HMCRAMCHSBRIDGE_Pos) 274 #define MCLK_AHBMASK_MASK _U(0x000FDF3F) /**< \brief (MCLK_AHBMASK) MASK Register */ 275 276 /* -------- MCLK_APBAMASK : (MCLK Offset: 0x14) (R/W 32) APBA Mask -------- */ 277 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) 278 typedef union { 279 struct { 280 uint32_t PM_:1; /*!< bit: 0 PM APB Clock Enable */ 281 uint32_t MCLK_:1; /*!< bit: 1 MCLK APB Clock Enable */ 282 uint32_t RSTC_:1; /*!< bit: 2 RSTC APB Clock Enable */ 283 uint32_t OSCCTRL_:1; /*!< bit: 3 OSCCTRL APB Clock Enable */ 284 uint32_t OSC32KCTRL_:1; /*!< bit: 4 OSC32KCTRL APB Clock Enable */ 285 uint32_t SUPC_:1; /*!< bit: 5 SUPC APB Clock Enable */ 286 uint32_t GCLK_:1; /*!< bit: 6 GCLK APB Clock Enable */ 287 uint32_t WDT_:1; /*!< bit: 7 WDT APB Clock Enable */ 288 uint32_t RTC_:1; /*!< bit: 8 RTC APB Clock Enable */ 289 uint32_t EIC_:1; /*!< bit: 9 EIC APB Clock Enable */ 290 uint32_t PORT_:1; /*!< bit: 10 PORT APB Clock Enable */ 291 uint32_t TAL_:1; /*!< bit: 11 TAL APB Clock Enable */ 292 uint32_t :20; /*!< bit: 12..31 Reserved */ 293 } bit; /*!< Structure used for bit access */ 294 uint32_t reg; /*!< Type used for register access */ 295 } MCLK_APBAMASK_Type; 296 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ 297 298 #define MCLK_APBAMASK_OFFSET 0x14 /**< \brief (MCLK_APBAMASK offset) APBA Mask */ 299 #define MCLK_APBAMASK_RESETVALUE _U(0x00001FFF) /**< \brief (MCLK_APBAMASK reset_value) APBA Mask */ 300 301 #define MCLK_APBAMASK_PM_Pos 0 /**< \brief (MCLK_APBAMASK) PM APB Clock Enable */ 302 #define MCLK_APBAMASK_PM (_U(0x1) << MCLK_APBAMASK_PM_Pos) 303 #define MCLK_APBAMASK_MCLK_Pos 1 /**< \brief (MCLK_APBAMASK) MCLK APB Clock Enable */ 304 #define MCLK_APBAMASK_MCLK (_U(0x1) << MCLK_APBAMASK_MCLK_Pos) 305 #define MCLK_APBAMASK_RSTC_Pos 2 /**< \brief (MCLK_APBAMASK) RSTC APB Clock Enable */ 306 #define MCLK_APBAMASK_RSTC (_U(0x1) << MCLK_APBAMASK_RSTC_Pos) 307 #define MCLK_APBAMASK_OSCCTRL_Pos 3 /**< \brief (MCLK_APBAMASK) OSCCTRL APB Clock Enable */ 308 #define MCLK_APBAMASK_OSCCTRL (_U(0x1) << MCLK_APBAMASK_OSCCTRL_Pos) 309 #define MCLK_APBAMASK_OSC32KCTRL_Pos 4 /**< \brief (MCLK_APBAMASK) OSC32KCTRL APB Clock Enable */ 310 #define MCLK_APBAMASK_OSC32KCTRL (_U(0x1) << MCLK_APBAMASK_OSC32KCTRL_Pos) 311 #define MCLK_APBAMASK_SUPC_Pos 5 /**< \brief (MCLK_APBAMASK) SUPC APB Clock Enable */ 312 #define MCLK_APBAMASK_SUPC (_U(0x1) << MCLK_APBAMASK_SUPC_Pos) 313 #define MCLK_APBAMASK_GCLK_Pos 6 /**< \brief (MCLK_APBAMASK) GCLK APB Clock Enable */ 314 #define MCLK_APBAMASK_GCLK (_U(0x1) << MCLK_APBAMASK_GCLK_Pos) 315 #define MCLK_APBAMASK_WDT_Pos 7 /**< \brief (MCLK_APBAMASK) WDT APB Clock Enable */ 316 #define MCLK_APBAMASK_WDT (_U(0x1) << MCLK_APBAMASK_WDT_Pos) 317 #define MCLK_APBAMASK_RTC_Pos 8 /**< \brief (MCLK_APBAMASK) RTC APB Clock Enable */ 318 #define MCLK_APBAMASK_RTC (_U(0x1) << MCLK_APBAMASK_RTC_Pos) 319 #define MCLK_APBAMASK_EIC_Pos 9 /**< \brief (MCLK_APBAMASK) EIC APB Clock Enable */ 320 #define MCLK_APBAMASK_EIC (_U(0x1) << MCLK_APBAMASK_EIC_Pos) 321 #define MCLK_APBAMASK_PORT_Pos 10 /**< \brief (MCLK_APBAMASK) PORT APB Clock Enable */ 322 #define MCLK_APBAMASK_PORT (_U(0x1) << MCLK_APBAMASK_PORT_Pos) 323 #define MCLK_APBAMASK_TAL_Pos 11 /**< \brief (MCLK_APBAMASK) TAL APB Clock Enable */ 324 #define MCLK_APBAMASK_TAL (_U(0x1) << MCLK_APBAMASK_TAL_Pos) 325 #define MCLK_APBAMASK_MASK _U(0x00000FFF) /**< \brief (MCLK_APBAMASK) MASK Register */ 326 327 /* -------- MCLK_APBBMASK : (MCLK Offset: 0x18) (R/W 32) APBB Mask -------- */ 328 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) 329 typedef union { 330 struct { 331 uint32_t USB_:1; /*!< bit: 0 USB APB Clock Enable */ 332 uint32_t DSU_:1; /*!< bit: 1 DSU APB Clock Enable */ 333 uint32_t NVMCTRL_:1; /*!< bit: 2 NVMCTRL APB Clock Enable */ 334 uint32_t :29; /*!< bit: 3..31 Reserved */ 335 } bit; /*!< Structure used for bit access */ 336 uint32_t reg; /*!< Type used for register access */ 337 } MCLK_APBBMASK_Type; 338 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ 339 340 #define MCLK_APBBMASK_OFFSET 0x18 /**< \brief (MCLK_APBBMASK offset) APBB Mask */ 341 #define MCLK_APBBMASK_RESETVALUE _U(0x00000017) /**< \brief (MCLK_APBBMASK reset_value) APBB Mask */ 342 343 #define MCLK_APBBMASK_USB_Pos 0 /**< \brief (MCLK_APBBMASK) USB APB Clock Enable */ 344 #define MCLK_APBBMASK_USB (_U(0x1) << MCLK_APBBMASK_USB_Pos) 345 #define MCLK_APBBMASK_DSU_Pos 1 /**< \brief (MCLK_APBBMASK) DSU APB Clock Enable */ 346 #define MCLK_APBBMASK_DSU (_U(0x1) << MCLK_APBBMASK_DSU_Pos) 347 #define MCLK_APBBMASK_NVMCTRL_Pos 2 /**< \brief (MCLK_APBBMASK) NVMCTRL APB Clock Enable */ 348 #define MCLK_APBBMASK_NVMCTRL (_U(0x1) << MCLK_APBBMASK_NVMCTRL_Pos) 349 #define MCLK_APBBMASK_MASK _U(0x00000007) /**< \brief (MCLK_APBBMASK) MASK Register */ 350 351 /* -------- MCLK_APBCMASK : (MCLK Offset: 0x1C) (R/W 32) APBC Mask -------- */ 352 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) 353 typedef union { 354 struct { 355 uint32_t SERCOM0_:1; /*!< bit: 0 SERCOM0 APB Clock Enable */ 356 uint32_t SERCOM1_:1; /*!< bit: 1 SERCOM1 APB Clock Enable */ 357 uint32_t SERCOM2_:1; /*!< bit: 2 SERCOM2 APB Clock Enable */ 358 uint32_t SERCOM3_:1; /*!< bit: 3 SERCOM3 APB Clock Enable */ 359 uint32_t SERCOM4_:1; /*!< bit: 4 SERCOM4 APB Clock Enable */ 360 uint32_t TCC0_:1; /*!< bit: 5 TCC0 APB Clock Enable */ 361 uint32_t TCC1_:1; /*!< bit: 6 TCC1 APB Clock Enable */ 362 uint32_t TCC2_:1; /*!< bit: 7 TCC2 APB Clock Enable */ 363 uint32_t TC0_:1; /*!< bit: 8 TC0 APB Clock Enable */ 364 uint32_t TC1_:1; /*!< bit: 9 TC1 APB Clock Enable */ 365 uint32_t TC2_:1; /*!< bit: 10 TC2 APB Clock Enable */ 366 uint32_t TC3_:1; /*!< bit: 11 TC3 APB Clock Enable */ 367 uint32_t DAC_:1; /*!< bit: 12 DAC APB Clock Enable */ 368 uint32_t AES_:1; /*!< bit: 13 AES APB Clock Enable */ 369 uint32_t TRNG_:1; /*!< bit: 14 TRNG APB Clock Enable */ 370 uint32_t :17; /*!< bit: 15..31 Reserved */ 371 } bit; /*!< Structure used for bit access */ 372 uint32_t reg; /*!< Type used for register access */ 373 } MCLK_APBCMASK_Type; 374 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ 375 376 #define MCLK_APBCMASK_OFFSET 0x1C /**< \brief (MCLK_APBCMASK offset) APBC Mask */ 377 #define MCLK_APBCMASK_RESETVALUE _U(0x00007FFF) /**< \brief (MCLK_APBCMASK reset_value) APBC Mask */ 378 379 #define MCLK_APBCMASK_SERCOM0_Pos 0 /**< \brief (MCLK_APBCMASK) SERCOM0 APB Clock Enable */ 380 #define MCLK_APBCMASK_SERCOM0 (_U(0x1) << MCLK_APBCMASK_SERCOM0_Pos) 381 #define MCLK_APBCMASK_SERCOM1_Pos 1 /**< \brief (MCLK_APBCMASK) SERCOM1 APB Clock Enable */ 382 #define MCLK_APBCMASK_SERCOM1 (_U(0x1) << MCLK_APBCMASK_SERCOM1_Pos) 383 #define MCLK_APBCMASK_SERCOM2_Pos 2 /**< \brief (MCLK_APBCMASK) SERCOM2 APB Clock Enable */ 384 #define MCLK_APBCMASK_SERCOM2 (_U(0x1) << MCLK_APBCMASK_SERCOM2_Pos) 385 #define MCLK_APBCMASK_SERCOM3_Pos 3 /**< \brief (MCLK_APBCMASK) SERCOM3 APB Clock Enable */ 386 #define MCLK_APBCMASK_SERCOM3 (_U(0x1) << MCLK_APBCMASK_SERCOM3_Pos) 387 #define MCLK_APBCMASK_SERCOM4_Pos 4 /**< \brief (MCLK_APBCMASK) SERCOM4 APB Clock Enable */ 388 #define MCLK_APBCMASK_SERCOM4 (_U(0x1) << MCLK_APBCMASK_SERCOM4_Pos) 389 #define MCLK_APBCMASK_TCC0_Pos 5 /**< \brief (MCLK_APBCMASK) TCC0 APB Clock Enable */ 390 #define MCLK_APBCMASK_TCC0 (_U(0x1) << MCLK_APBCMASK_TCC0_Pos) 391 #define MCLK_APBCMASK_TCC1_Pos 6 /**< \brief (MCLK_APBCMASK) TCC1 APB Clock Enable */ 392 #define MCLK_APBCMASK_TCC1 (_U(0x1) << MCLK_APBCMASK_TCC1_Pos) 393 #define MCLK_APBCMASK_TCC2_Pos 7 /**< \brief (MCLK_APBCMASK) TCC2 APB Clock Enable */ 394 #define MCLK_APBCMASK_TCC2 (_U(0x1) << MCLK_APBCMASK_TCC2_Pos) 395 #define MCLK_APBCMASK_TC0_Pos 8 /**< \brief (MCLK_APBCMASK) TC0 APB Clock Enable */ 396 #define MCLK_APBCMASK_TC0 (_U(0x1) << MCLK_APBCMASK_TC0_Pos) 397 #define MCLK_APBCMASK_TC1_Pos 9 /**< \brief (MCLK_APBCMASK) TC1 APB Clock Enable */ 398 #define MCLK_APBCMASK_TC1 (_U(0x1) << MCLK_APBCMASK_TC1_Pos) 399 #define MCLK_APBCMASK_TC2_Pos 10 /**< \brief (MCLK_APBCMASK) TC2 APB Clock Enable */ 400 #define MCLK_APBCMASK_TC2 (_U(0x1) << MCLK_APBCMASK_TC2_Pos) 401 #define MCLK_APBCMASK_TC3_Pos 11 /**< \brief (MCLK_APBCMASK) TC3 APB Clock Enable */ 402 #define MCLK_APBCMASK_TC3 (_U(0x1) << MCLK_APBCMASK_TC3_Pos) 403 #define MCLK_APBCMASK_DAC_Pos 12 /**< \brief (MCLK_APBCMASK) DAC APB Clock Enable */ 404 #define MCLK_APBCMASK_DAC (_U(0x1) << MCLK_APBCMASK_DAC_Pos) 405 #define MCLK_APBCMASK_AES_Pos 13 /**< \brief (MCLK_APBCMASK) AES APB Clock Enable */ 406 #define MCLK_APBCMASK_AES (_U(0x1) << MCLK_APBCMASK_AES_Pos) 407 #define MCLK_APBCMASK_TRNG_Pos 14 /**< \brief (MCLK_APBCMASK) TRNG APB Clock Enable */ 408 #define MCLK_APBCMASK_TRNG (_U(0x1) << MCLK_APBCMASK_TRNG_Pos) 409 #define MCLK_APBCMASK_MASK _U(0x00007FFF) /**< \brief (MCLK_APBCMASK) MASK Register */ 410 411 /* -------- MCLK_APBDMASK : (MCLK Offset: 0x20) (R/W 32) APBD Mask -------- */ 412 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) 413 typedef union { 414 struct { 415 uint32_t EVSYS_:1; /*!< bit: 0 EVSYS APB Clock Enable */ 416 uint32_t SERCOM5_:1; /*!< bit: 1 SERCOM5 APB Clock Enable */ 417 uint32_t TC4_:1; /*!< bit: 2 TC4 APB Clock Enable */ 418 uint32_t ADC_:1; /*!< bit: 3 ADC APB Clock Enable */ 419 uint32_t AC_:1; /*!< bit: 4 AC APB Clock Enable */ 420 uint32_t PTC_:1; /*!< bit: 5 PTC APB Clock Enable */ 421 uint32_t OPAMP_:1; /*!< bit: 6 OPAMP APB Clock Enable */ 422 uint32_t CCL_:1; /*!< bit: 7 CCL APB Clock Enable */ 423 uint32_t :24; /*!< bit: 8..31 Reserved */ 424 } bit; /*!< Structure used for bit access */ 425 uint32_t reg; /*!< Type used for register access */ 426 } MCLK_APBDMASK_Type; 427 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ 428 429 #define MCLK_APBDMASK_OFFSET 0x20 /**< \brief (MCLK_APBDMASK offset) APBD Mask */ 430 #define MCLK_APBDMASK_RESETVALUE _U(0x000000FF) /**< \brief (MCLK_APBDMASK reset_value) APBD Mask */ 431 432 #define MCLK_APBDMASK_EVSYS_Pos 0 /**< \brief (MCLK_APBDMASK) EVSYS APB Clock Enable */ 433 #define MCLK_APBDMASK_EVSYS (_U(0x1) << MCLK_APBDMASK_EVSYS_Pos) 434 #define MCLK_APBDMASK_SERCOM5_Pos 1 /**< \brief (MCLK_APBDMASK) SERCOM5 APB Clock Enable */ 435 #define MCLK_APBDMASK_SERCOM5 (_U(0x1) << MCLK_APBDMASK_SERCOM5_Pos) 436 #define MCLK_APBDMASK_TC4_Pos 2 /**< \brief (MCLK_APBDMASK) TC4 APB Clock Enable */ 437 #define MCLK_APBDMASK_TC4 (_U(0x1) << MCLK_APBDMASK_TC4_Pos) 438 #define MCLK_APBDMASK_ADC_Pos 3 /**< \brief (MCLK_APBDMASK) ADC APB Clock Enable */ 439 #define MCLK_APBDMASK_ADC (_U(0x1) << MCLK_APBDMASK_ADC_Pos) 440 #define MCLK_APBDMASK_AC_Pos 4 /**< \brief (MCLK_APBDMASK) AC APB Clock Enable */ 441 #define MCLK_APBDMASK_AC (_U(0x1) << MCLK_APBDMASK_AC_Pos) 442 #define MCLK_APBDMASK_PTC_Pos 5 /**< \brief (MCLK_APBDMASK) PTC APB Clock Enable */ 443 #define MCLK_APBDMASK_PTC (_U(0x1) << MCLK_APBDMASK_PTC_Pos) 444 #define MCLK_APBDMASK_OPAMP_Pos 6 /**< \brief (MCLK_APBDMASK) OPAMP APB Clock Enable */ 445 #define MCLK_APBDMASK_OPAMP (_U(0x1) << MCLK_APBDMASK_OPAMP_Pos) 446 #define MCLK_APBDMASK_CCL_Pos 7 /**< \brief (MCLK_APBDMASK) CCL APB Clock Enable */ 447 #define MCLK_APBDMASK_CCL (_U(0x1) << MCLK_APBDMASK_CCL_Pos) 448 #define MCLK_APBDMASK_MASK _U(0x000000FF) /**< \brief (MCLK_APBDMASK) MASK Register */ 449 450 /* -------- MCLK_APBEMASK : (MCLK Offset: 0x24) (R/W 32) APBE Mask -------- */ 451 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) 452 typedef union { 453 struct { 454 uint32_t PAC_:1; /*!< bit: 0 PAC APB Clock Enable */ 455 uint32_t :31; /*!< bit: 1..31 Reserved */ 456 } bit; /*!< Structure used for bit access */ 457 uint32_t reg; /*!< Type used for register access */ 458 } MCLK_APBEMASK_Type; 459 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ 460 461 #define MCLK_APBEMASK_OFFSET 0x24 /**< \brief (MCLK_APBEMASK offset) APBE Mask */ 462 #define MCLK_APBEMASK_RESETVALUE _U(0x0000000D) /**< \brief (MCLK_APBEMASK reset_value) APBE Mask */ 463 464 #define MCLK_APBEMASK_PAC_Pos 0 /**< \brief (MCLK_APBEMASK) PAC APB Clock Enable */ 465 #define MCLK_APBEMASK_PAC (_U(0x1) << MCLK_APBEMASK_PAC_Pos) 466 #define MCLK_APBEMASK_MASK _U(0x00000001) /**< \brief (MCLK_APBEMASK) MASK Register */ 467 468 /** \brief MCLK hardware registers */ 469 #if !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) 470 typedef struct { 471 __IO MCLK_CTRLA_Type CTRLA; /**< \brief Offset: 0x00 (R/W 8) Control A */ 472 __IO MCLK_INTENCLR_Type INTENCLR; /**< \brief Offset: 0x01 (R/W 8) Interrupt Enable Clear */ 473 __IO MCLK_INTENSET_Type INTENSET; /**< \brief Offset: 0x02 (R/W 8) Interrupt Enable Set */ 474 __IO MCLK_INTFLAG_Type INTFLAG; /**< \brief Offset: 0x03 (R/W 8) Interrupt Flag Status and Clear */ 475 __IO MCLK_CPUDIV_Type CPUDIV; /**< \brief Offset: 0x04 (R/W 8) CPU Clock Division */ 476 __IO MCLK_LPDIV_Type LPDIV; /**< \brief Offset: 0x05 (R/W 8) Low-Power Clock Division */ 477 __IO MCLK_BUPDIV_Type BUPDIV; /**< \brief Offset: 0x06 (R/W 8) Backup Clock Division */ 478 RoReg8 Reserved1[0x9]; 479 __IO MCLK_AHBMASK_Type AHBMASK; /**< \brief Offset: 0x10 (R/W 32) AHB Mask */ 480 __IO MCLK_APBAMASK_Type APBAMASK; /**< \brief Offset: 0x14 (R/W 32) APBA Mask */ 481 __IO MCLK_APBBMASK_Type APBBMASK; /**< \brief Offset: 0x18 (R/W 32) APBB Mask */ 482 __IO MCLK_APBCMASK_Type APBCMASK; /**< \brief Offset: 0x1C (R/W 32) APBC Mask */ 483 __IO MCLK_APBDMASK_Type APBDMASK; /**< \brief Offset: 0x20 (R/W 32) APBD Mask */ 484 __IO MCLK_APBEMASK_Type APBEMASK; /**< \brief Offset: 0x24 (R/W 32) APBE Mask */ 485 } Mclk; 486 #endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */ 487 488 /*@}*/ 489 490 #endif /* _SAML21_MCLK_COMPONENT_ */ 491
