1 /** 2 * \file 3 * 4 * \brief Component description for PWM 5 * 6 * Copyright (c) 2019 Microchip Technology Inc. 7 * 8 * \license_start 9 * 10 * \page License 11 * 12 * SPDX-License-Identifier: Apache-2.0 13 * 14 * Licensed under the Apache License, Version 2.0 (the "License"); 15 * you may not use this file except in compliance with the License. 16 * You may obtain a copy of the License at 17 * 18 * http://www.apache.org/licenses/LICENSE-2.0 19 * 20 * Unless required by applicable law or agreed to in writing, software 21 * distributed under the License is distributed on an "AS IS" BASIS, 22 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 23 * See the License for the specific language governing permissions and 24 * limitations under the License. 25 * 26 * \license_stop 27 * 28 */ 29 30 /* file generated from device description version 2019-01-18T21:19:59Z */ 31 #ifndef _SAME70_PWM_COMPONENT_H_ 32 #define _SAME70_PWM_COMPONENT_H_ 33 #define _SAME70_PWM_COMPONENT_ /**< \deprecated Backward compatibility for ASF */ 34 35 /** \addtogroup SAME_SAME70 Pulse Width Modulation Controller 36 * @{ 37 */ 38 /* ========================================================================== */ 39 /** SOFTWARE API DEFINITION FOR PWM */ 40 /* ========================================================================== */ 41 #ifndef COMPONENT_TYPEDEF_STYLE 42 #define COMPONENT_TYPEDEF_STYLE 'R' /**< Defines default style of typedefs for the component header files ('R' = RFO, 'N' = NTO)*/ 43 #endif 44 45 #define PWM_6343 /**< (PWM) Module ID */ 46 #define REV_PWM Y /**< (PWM) Module revision */ 47 48 /* -------- PWM_CMR : (PWM Offset: 0x00) (R/W 32) PWM Channel Mode Register -------- */ 49 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 50 #if COMPONENT_TYPEDEF_STYLE == 'N' 51 typedef union { 52 struct { 53 uint32_t CPRE:4; /**< bit: 0..3 Channel Pre-scaler */ 54 uint32_t :4; /**< bit: 4..7 Reserved */ 55 uint32_t CALG:1; /**< bit: 8 Channel Alignment */ 56 uint32_t CPOL:1; /**< bit: 9 Channel Polarity */ 57 uint32_t CES:1; /**< bit: 10 Counter Event Selection */ 58 uint32_t UPDS:1; /**< bit: 11 Update Selection */ 59 uint32_t DPOLI:1; /**< bit: 12 Disabled Polarity Inverted */ 60 uint32_t TCTS:1; /**< bit: 13 Timer Counter Trigger Selection */ 61 uint32_t :2; /**< bit: 14..15 Reserved */ 62 uint32_t DTE:1; /**< bit: 16 Dead-Time Generator Enable */ 63 uint32_t DTHI:1; /**< bit: 17 Dead-Time PWMHx Output Inverted */ 64 uint32_t DTLI:1; /**< bit: 18 Dead-Time PWMLx Output Inverted */ 65 uint32_t PPM:1; /**< bit: 19 Push-Pull Mode */ 66 uint32_t :12; /**< bit: 20..31 Reserved */ 67 } bit; /**< Structure used for bit access */ 68 uint32_t reg; /**< Type used for register access */ 69 } PWM_CMR_Type; 70 #endif 71 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 72 73 #define PWM_CMR_OFFSET (0x00) /**< (PWM_CMR) PWM Channel Mode Register Offset */ 74 75 #define PWM_CMR_CPRE_Pos 0 /**< (PWM_CMR) Channel Pre-scaler Position */ 76 #define PWM_CMR_CPRE_Msk (_U_(0xF) << PWM_CMR_CPRE_Pos) /**< (PWM_CMR) Channel Pre-scaler Mask */ 77 #define PWM_CMR_CPRE(value) (PWM_CMR_CPRE_Msk & ((value) << PWM_CMR_CPRE_Pos)) 78 #define PWM_CMR_CPRE_MCK_Val _U_(0x0) /**< (PWM_CMR) Peripheral clock */ 79 #define PWM_CMR_CPRE_MCK_DIV_2_Val _U_(0x1) /**< (PWM_CMR) Peripheral clock/2 */ 80 #define PWM_CMR_CPRE_MCK_DIV_4_Val _U_(0x2) /**< (PWM_CMR) Peripheral clock/4 */ 81 #define PWM_CMR_CPRE_MCK_DIV_8_Val _U_(0x3) /**< (PWM_CMR) Peripheral clock/8 */ 82 #define PWM_CMR_CPRE_MCK_DIV_16_Val _U_(0x4) /**< (PWM_CMR) Peripheral clock/16 */ 83 #define PWM_CMR_CPRE_MCK_DIV_32_Val _U_(0x5) /**< (PWM_CMR) Peripheral clock/32 */ 84 #define PWM_CMR_CPRE_MCK_DIV_64_Val _U_(0x6) /**< (PWM_CMR) Peripheral clock/64 */ 85 #define PWM_CMR_CPRE_MCK_DIV_128_Val _U_(0x7) /**< (PWM_CMR) Peripheral clock/128 */ 86 #define PWM_CMR_CPRE_MCK_DIV_256_Val _U_(0x8) /**< (PWM_CMR) Peripheral clock/256 */ 87 #define PWM_CMR_CPRE_MCK_DIV_512_Val _U_(0x9) /**< (PWM_CMR) Peripheral clock/512 */ 88 #define PWM_CMR_CPRE_MCK_DIV_1024_Val _U_(0xA) /**< (PWM_CMR) Peripheral clock/1024 */ 89 #define PWM_CMR_CPRE_CLKA_Val _U_(0xB) /**< (PWM_CMR) Clock A */ 90 #define PWM_CMR_CPRE_CLKB_Val _U_(0xC) /**< (PWM_CMR) Clock B */ 91 #define PWM_CMR_CPRE_MCK (PWM_CMR_CPRE_MCK_Val << PWM_CMR_CPRE_Pos) /**< (PWM_CMR) Peripheral clock Position */ 92 #define PWM_CMR_CPRE_MCK_DIV_2 (PWM_CMR_CPRE_MCK_DIV_2_Val << PWM_CMR_CPRE_Pos) /**< (PWM_CMR) Peripheral clock/2 Position */ 93 #define PWM_CMR_CPRE_MCK_DIV_4 (PWM_CMR_CPRE_MCK_DIV_4_Val << PWM_CMR_CPRE_Pos) /**< (PWM_CMR) Peripheral clock/4 Position */ 94 #define PWM_CMR_CPRE_MCK_DIV_8 (PWM_CMR_CPRE_MCK_DIV_8_Val << PWM_CMR_CPRE_Pos) /**< (PWM_CMR) Peripheral clock/8 Position */ 95 #define PWM_CMR_CPRE_MCK_DIV_16 (PWM_CMR_CPRE_MCK_DIV_16_Val << PWM_CMR_CPRE_Pos) /**< (PWM_CMR) Peripheral clock/16 Position */ 96 #define PWM_CMR_CPRE_MCK_DIV_32 (PWM_CMR_CPRE_MCK_DIV_32_Val << PWM_CMR_CPRE_Pos) /**< (PWM_CMR) Peripheral clock/32 Position */ 97 #define PWM_CMR_CPRE_MCK_DIV_64 (PWM_CMR_CPRE_MCK_DIV_64_Val << PWM_CMR_CPRE_Pos) /**< (PWM_CMR) Peripheral clock/64 Position */ 98 #define PWM_CMR_CPRE_MCK_DIV_128 (PWM_CMR_CPRE_MCK_DIV_128_Val << PWM_CMR_CPRE_Pos) /**< (PWM_CMR) Peripheral clock/128 Position */ 99 #define PWM_CMR_CPRE_MCK_DIV_256 (PWM_CMR_CPRE_MCK_DIV_256_Val << PWM_CMR_CPRE_Pos) /**< (PWM_CMR) Peripheral clock/256 Position */ 100 #define PWM_CMR_CPRE_MCK_DIV_512 (PWM_CMR_CPRE_MCK_DIV_512_Val << PWM_CMR_CPRE_Pos) /**< (PWM_CMR) Peripheral clock/512 Position */ 101 #define PWM_CMR_CPRE_MCK_DIV_1024 (PWM_CMR_CPRE_MCK_DIV_1024_Val << PWM_CMR_CPRE_Pos) /**< (PWM_CMR) Peripheral clock/1024 Position */ 102 #define PWM_CMR_CPRE_CLKA (PWM_CMR_CPRE_CLKA_Val << PWM_CMR_CPRE_Pos) /**< (PWM_CMR) Clock A Position */ 103 #define PWM_CMR_CPRE_CLKB (PWM_CMR_CPRE_CLKB_Val << PWM_CMR_CPRE_Pos) /**< (PWM_CMR) Clock B Position */ 104 #define PWM_CMR_CALG_Pos 8 /**< (PWM_CMR) Channel Alignment Position */ 105 #define PWM_CMR_CALG_Msk (_U_(0x1) << PWM_CMR_CALG_Pos) /**< (PWM_CMR) Channel Alignment Mask */ 106 #define PWM_CMR_CALG PWM_CMR_CALG_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_CMR_CALG_Msk instead */ 107 #define PWM_CMR_CALG_LEFT_ALIGNED_Val _U_(0x0) /**< (PWM_CMR) Left aligned */ 108 #define PWM_CMR_CALG_CENTER_ALIGNED_Val _U_(0x1) /**< (PWM_CMR) Center aligned */ 109 #define PWM_CMR_CALG_LEFT_ALIGNED (PWM_CMR_CALG_LEFT_ALIGNED_Val << PWM_CMR_CALG_Pos) /**< (PWM_CMR) Left aligned Position */ 110 #define PWM_CMR_CALG_CENTER_ALIGNED (PWM_CMR_CALG_CENTER_ALIGNED_Val << PWM_CMR_CALG_Pos) /**< (PWM_CMR) Center aligned Position */ 111 #define PWM_CMR_CPOL_Pos 9 /**< (PWM_CMR) Channel Polarity Position */ 112 #define PWM_CMR_CPOL_Msk (_U_(0x1) << PWM_CMR_CPOL_Pos) /**< (PWM_CMR) Channel Polarity Mask */ 113 #define PWM_CMR_CPOL PWM_CMR_CPOL_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_CMR_CPOL_Msk instead */ 114 #define PWM_CMR_CPOL_LOW_POLARITY_Val _U_(0x0) /**< (PWM_CMR) Waveform starts at low level */ 115 #define PWM_CMR_CPOL_HIGH_POLARITY_Val _U_(0x1) /**< (PWM_CMR) Waveform starts at high level */ 116 #define PWM_CMR_CPOL_LOW_POLARITY (PWM_CMR_CPOL_LOW_POLARITY_Val << PWM_CMR_CPOL_Pos) /**< (PWM_CMR) Waveform starts at low level Position */ 117 #define PWM_CMR_CPOL_HIGH_POLARITY (PWM_CMR_CPOL_HIGH_POLARITY_Val << PWM_CMR_CPOL_Pos) /**< (PWM_CMR) Waveform starts at high level Position */ 118 #define PWM_CMR_CES_Pos 10 /**< (PWM_CMR) Counter Event Selection Position */ 119 #define PWM_CMR_CES_Msk (_U_(0x1) << PWM_CMR_CES_Pos) /**< (PWM_CMR) Counter Event Selection Mask */ 120 #define PWM_CMR_CES PWM_CMR_CES_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_CMR_CES_Msk instead */ 121 #define PWM_CMR_CES_SINGLE_EVENT_Val _U_(0x0) /**< (PWM_CMR) At the end of PWM period */ 122 #define PWM_CMR_CES_DOUBLE_EVENT_Val _U_(0x1) /**< (PWM_CMR) At half of PWM period AND at the end of PWM period */ 123 #define PWM_CMR_CES_SINGLE_EVENT (PWM_CMR_CES_SINGLE_EVENT_Val << PWM_CMR_CES_Pos) /**< (PWM_CMR) At the end of PWM period Position */ 124 #define PWM_CMR_CES_DOUBLE_EVENT (PWM_CMR_CES_DOUBLE_EVENT_Val << PWM_CMR_CES_Pos) /**< (PWM_CMR) At half of PWM period AND at the end of PWM period Position */ 125 #define PWM_CMR_UPDS_Pos 11 /**< (PWM_CMR) Update Selection Position */ 126 #define PWM_CMR_UPDS_Msk (_U_(0x1) << PWM_CMR_UPDS_Pos) /**< (PWM_CMR) Update Selection Mask */ 127 #define PWM_CMR_UPDS PWM_CMR_UPDS_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_CMR_UPDS_Msk instead */ 128 #define PWM_CMR_UPDS_UPDATE_AT_PERIOD_Val _U_(0x0) /**< (PWM_CMR) At the next end of PWM period */ 129 #define PWM_CMR_UPDS_UPDATE_AT_HALF_PERIOD_Val _U_(0x1) /**< (PWM_CMR) At the next end of Half PWM period */ 130 #define PWM_CMR_UPDS_UPDATE_AT_PERIOD (PWM_CMR_UPDS_UPDATE_AT_PERIOD_Val << PWM_CMR_UPDS_Pos) /**< (PWM_CMR) At the next end of PWM period Position */ 131 #define PWM_CMR_UPDS_UPDATE_AT_HALF_PERIOD (PWM_CMR_UPDS_UPDATE_AT_HALF_PERIOD_Val << PWM_CMR_UPDS_Pos) /**< (PWM_CMR) At the next end of Half PWM period Position */ 132 #define PWM_CMR_DPOLI_Pos 12 /**< (PWM_CMR) Disabled Polarity Inverted Position */ 133 #define PWM_CMR_DPOLI_Msk (_U_(0x1) << PWM_CMR_DPOLI_Pos) /**< (PWM_CMR) Disabled Polarity Inverted Mask */ 134 #define PWM_CMR_DPOLI PWM_CMR_DPOLI_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_CMR_DPOLI_Msk instead */ 135 #define PWM_CMR_TCTS_Pos 13 /**< (PWM_CMR) Timer Counter Trigger Selection Position */ 136 #define PWM_CMR_TCTS_Msk (_U_(0x1) << PWM_CMR_TCTS_Pos) /**< (PWM_CMR) Timer Counter Trigger Selection Mask */ 137 #define PWM_CMR_TCTS PWM_CMR_TCTS_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_CMR_TCTS_Msk instead */ 138 #define PWM_CMR_DTE_Pos 16 /**< (PWM_CMR) Dead-Time Generator Enable Position */ 139 #define PWM_CMR_DTE_Msk (_U_(0x1) << PWM_CMR_DTE_Pos) /**< (PWM_CMR) Dead-Time Generator Enable Mask */ 140 #define PWM_CMR_DTE PWM_CMR_DTE_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_CMR_DTE_Msk instead */ 141 #define PWM_CMR_DTHI_Pos 17 /**< (PWM_CMR) Dead-Time PWMHx Output Inverted Position */ 142 #define PWM_CMR_DTHI_Msk (_U_(0x1) << PWM_CMR_DTHI_Pos) /**< (PWM_CMR) Dead-Time PWMHx Output Inverted Mask */ 143 #define PWM_CMR_DTHI PWM_CMR_DTHI_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_CMR_DTHI_Msk instead */ 144 #define PWM_CMR_DTLI_Pos 18 /**< (PWM_CMR) Dead-Time PWMLx Output Inverted Position */ 145 #define PWM_CMR_DTLI_Msk (_U_(0x1) << PWM_CMR_DTLI_Pos) /**< (PWM_CMR) Dead-Time PWMLx Output Inverted Mask */ 146 #define PWM_CMR_DTLI PWM_CMR_DTLI_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_CMR_DTLI_Msk instead */ 147 #define PWM_CMR_PPM_Pos 19 /**< (PWM_CMR) Push-Pull Mode Position */ 148 #define PWM_CMR_PPM_Msk (_U_(0x1) << PWM_CMR_PPM_Pos) /**< (PWM_CMR) Push-Pull Mode Mask */ 149 #define PWM_CMR_PPM PWM_CMR_PPM_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_CMR_PPM_Msk instead */ 150 #define PWM_CMR_MASK _U_(0xF3F0F) /**< \deprecated (PWM_CMR) Register MASK (Use PWM_CMR_Msk instead) */ 151 #define PWM_CMR_Msk _U_(0xF3F0F) /**< (PWM_CMR) Register Mask */ 152 153 154 /* -------- PWM_CDTY : (PWM Offset: 0x04) (R/W 32) PWM Channel Duty Cycle Register -------- */ 155 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 156 #if COMPONENT_TYPEDEF_STYLE == 'N' 157 typedef union { 158 struct { 159 uint32_t CDTY:24; /**< bit: 0..23 Channel Duty-Cycle */ 160 uint32_t :8; /**< bit: 24..31 Reserved */ 161 } bit; /**< Structure used for bit access */ 162 uint32_t reg; /**< Type used for register access */ 163 } PWM_CDTY_Type; 164 #endif 165 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 166 167 #define PWM_CDTY_OFFSET (0x04) /**< (PWM_CDTY) PWM Channel Duty Cycle Register Offset */ 168 169 #define PWM_CDTY_CDTY_Pos 0 /**< (PWM_CDTY) Channel Duty-Cycle Position */ 170 #define PWM_CDTY_CDTY_Msk (_U_(0xFFFFFF) << PWM_CDTY_CDTY_Pos) /**< (PWM_CDTY) Channel Duty-Cycle Mask */ 171 #define PWM_CDTY_CDTY(value) (PWM_CDTY_CDTY_Msk & ((value) << PWM_CDTY_CDTY_Pos)) 172 #define PWM_CDTY_MASK _U_(0xFFFFFF) /**< \deprecated (PWM_CDTY) Register MASK (Use PWM_CDTY_Msk instead) */ 173 #define PWM_CDTY_Msk _U_(0xFFFFFF) /**< (PWM_CDTY) Register Mask */ 174 175 176 /* -------- PWM_CDTYUPD : (PWM Offset: 0x08) (/W 32) PWM Channel Duty Cycle Update Register -------- */ 177 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 178 #if COMPONENT_TYPEDEF_STYLE == 'N' 179 typedef union { 180 struct { 181 uint32_t CDTYUPD:24; /**< bit: 0..23 Channel Duty-Cycle Update */ 182 uint32_t :8; /**< bit: 24..31 Reserved */ 183 } bit; /**< Structure used for bit access */ 184 uint32_t reg; /**< Type used for register access */ 185 } PWM_CDTYUPD_Type; 186 #endif 187 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 188 189 #define PWM_CDTYUPD_OFFSET (0x08) /**< (PWM_CDTYUPD) PWM Channel Duty Cycle Update Register Offset */ 190 191 #define PWM_CDTYUPD_CDTYUPD_Pos 0 /**< (PWM_CDTYUPD) Channel Duty-Cycle Update Position */ 192 #define PWM_CDTYUPD_CDTYUPD_Msk (_U_(0xFFFFFF) << PWM_CDTYUPD_CDTYUPD_Pos) /**< (PWM_CDTYUPD) Channel Duty-Cycle Update Mask */ 193 #define PWM_CDTYUPD_CDTYUPD(value) (PWM_CDTYUPD_CDTYUPD_Msk & ((value) << PWM_CDTYUPD_CDTYUPD_Pos)) 194 #define PWM_CDTYUPD_MASK _U_(0xFFFFFF) /**< \deprecated (PWM_CDTYUPD) Register MASK (Use PWM_CDTYUPD_Msk instead) */ 195 #define PWM_CDTYUPD_Msk _U_(0xFFFFFF) /**< (PWM_CDTYUPD) Register Mask */ 196 197 198 /* -------- PWM_CPRD : (PWM Offset: 0x0c) (R/W 32) PWM Channel Period Register -------- */ 199 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 200 #if COMPONENT_TYPEDEF_STYLE == 'N' 201 typedef union { 202 struct { 203 uint32_t CPRD:24; /**< bit: 0..23 Channel Period */ 204 uint32_t :8; /**< bit: 24..31 Reserved */ 205 } bit; /**< Structure used for bit access */ 206 uint32_t reg; /**< Type used for register access */ 207 } PWM_CPRD_Type; 208 #endif 209 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 210 211 #define PWM_CPRD_OFFSET (0x0C) /**< (PWM_CPRD) PWM Channel Period Register Offset */ 212 213 #define PWM_CPRD_CPRD_Pos 0 /**< (PWM_CPRD) Channel Period Position */ 214 #define PWM_CPRD_CPRD_Msk (_U_(0xFFFFFF) << PWM_CPRD_CPRD_Pos) /**< (PWM_CPRD) Channel Period Mask */ 215 #define PWM_CPRD_CPRD(value) (PWM_CPRD_CPRD_Msk & ((value) << PWM_CPRD_CPRD_Pos)) 216 #define PWM_CPRD_MASK _U_(0xFFFFFF) /**< \deprecated (PWM_CPRD) Register MASK (Use PWM_CPRD_Msk instead) */ 217 #define PWM_CPRD_Msk _U_(0xFFFFFF) /**< (PWM_CPRD) Register Mask */ 218 219 220 /* -------- PWM_CPRDUPD : (PWM Offset: 0x10) (/W 32) PWM Channel Period Update Register -------- */ 221 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 222 #if COMPONENT_TYPEDEF_STYLE == 'N' 223 typedef union { 224 struct { 225 uint32_t CPRDUPD:24; /**< bit: 0..23 Channel Period Update */ 226 uint32_t :8; /**< bit: 24..31 Reserved */ 227 } bit; /**< Structure used for bit access */ 228 uint32_t reg; /**< Type used for register access */ 229 } PWM_CPRDUPD_Type; 230 #endif 231 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 232 233 #define PWM_CPRDUPD_OFFSET (0x10) /**< (PWM_CPRDUPD) PWM Channel Period Update Register Offset */ 234 235 #define PWM_CPRDUPD_CPRDUPD_Pos 0 /**< (PWM_CPRDUPD) Channel Period Update Position */ 236 #define PWM_CPRDUPD_CPRDUPD_Msk (_U_(0xFFFFFF) << PWM_CPRDUPD_CPRDUPD_Pos) /**< (PWM_CPRDUPD) Channel Period Update Mask */ 237 #define PWM_CPRDUPD_CPRDUPD(value) (PWM_CPRDUPD_CPRDUPD_Msk & ((value) << PWM_CPRDUPD_CPRDUPD_Pos)) 238 #define PWM_CPRDUPD_MASK _U_(0xFFFFFF) /**< \deprecated (PWM_CPRDUPD) Register MASK (Use PWM_CPRDUPD_Msk instead) */ 239 #define PWM_CPRDUPD_Msk _U_(0xFFFFFF) /**< (PWM_CPRDUPD) Register Mask */ 240 241 242 /* -------- PWM_CCNT : (PWM Offset: 0x14) (R/ 32) PWM Channel Counter Register -------- */ 243 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 244 #if COMPONENT_TYPEDEF_STYLE == 'N' 245 typedef union { 246 struct { 247 uint32_t CNT:24; /**< bit: 0..23 Channel Counter Register */ 248 uint32_t :8; /**< bit: 24..31 Reserved */ 249 } bit; /**< Structure used for bit access */ 250 uint32_t reg; /**< Type used for register access */ 251 } PWM_CCNT_Type; 252 #endif 253 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 254 255 #define PWM_CCNT_OFFSET (0x14) /**< (PWM_CCNT) PWM Channel Counter Register Offset */ 256 257 #define PWM_CCNT_CNT_Pos 0 /**< (PWM_CCNT) Channel Counter Register Position */ 258 #define PWM_CCNT_CNT_Msk (_U_(0xFFFFFF) << PWM_CCNT_CNT_Pos) /**< (PWM_CCNT) Channel Counter Register Mask */ 259 #define PWM_CCNT_CNT(value) (PWM_CCNT_CNT_Msk & ((value) << PWM_CCNT_CNT_Pos)) 260 #define PWM_CCNT_MASK _U_(0xFFFFFF) /**< \deprecated (PWM_CCNT) Register MASK (Use PWM_CCNT_Msk instead) */ 261 #define PWM_CCNT_Msk _U_(0xFFFFFF) /**< (PWM_CCNT) Register Mask */ 262 263 264 /* -------- PWM_DT : (PWM Offset: 0x18) (R/W 32) PWM Channel Dead Time Register -------- */ 265 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 266 #if COMPONENT_TYPEDEF_STYLE == 'N' 267 typedef union { 268 struct { 269 uint32_t DTH:16; /**< bit: 0..15 Dead-Time Value for PWMHx Output */ 270 uint32_t DTL:16; /**< bit: 16..31 Dead-Time Value for PWMLx Output */ 271 } bit; /**< Structure used for bit access */ 272 uint32_t reg; /**< Type used for register access */ 273 } PWM_DT_Type; 274 #endif 275 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 276 277 #define PWM_DT_OFFSET (0x18) /**< (PWM_DT) PWM Channel Dead Time Register Offset */ 278 279 #define PWM_DT_DTH_Pos 0 /**< (PWM_DT) Dead-Time Value for PWMHx Output Position */ 280 #define PWM_DT_DTH_Msk (_U_(0xFFFF) << PWM_DT_DTH_Pos) /**< (PWM_DT) Dead-Time Value for PWMHx Output Mask */ 281 #define PWM_DT_DTH(value) (PWM_DT_DTH_Msk & ((value) << PWM_DT_DTH_Pos)) 282 #define PWM_DT_DTL_Pos 16 /**< (PWM_DT) Dead-Time Value for PWMLx Output Position */ 283 #define PWM_DT_DTL_Msk (_U_(0xFFFF) << PWM_DT_DTL_Pos) /**< (PWM_DT) Dead-Time Value for PWMLx Output Mask */ 284 #define PWM_DT_DTL(value) (PWM_DT_DTL_Msk & ((value) << PWM_DT_DTL_Pos)) 285 #define PWM_DT_MASK _U_(0xFFFFFFFF) /**< \deprecated (PWM_DT) Register MASK (Use PWM_DT_Msk instead) */ 286 #define PWM_DT_Msk _U_(0xFFFFFFFF) /**< (PWM_DT) Register Mask */ 287 288 289 /* -------- PWM_DTUPD : (PWM Offset: 0x1c) (/W 32) PWM Channel Dead Time Update Register -------- */ 290 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 291 #if COMPONENT_TYPEDEF_STYLE == 'N' 292 typedef union { 293 struct { 294 uint32_t DTHUPD:16; /**< bit: 0..15 Dead-Time Value Update for PWMHx Output */ 295 uint32_t DTLUPD:16; /**< bit: 16..31 Dead-Time Value Update for PWMLx Output */ 296 } bit; /**< Structure used for bit access */ 297 uint32_t reg; /**< Type used for register access */ 298 } PWM_DTUPD_Type; 299 #endif 300 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 301 302 #define PWM_DTUPD_OFFSET (0x1C) /**< (PWM_DTUPD) PWM Channel Dead Time Update Register Offset */ 303 304 #define PWM_DTUPD_DTHUPD_Pos 0 /**< (PWM_DTUPD) Dead-Time Value Update for PWMHx Output Position */ 305 #define PWM_DTUPD_DTHUPD_Msk (_U_(0xFFFF) << PWM_DTUPD_DTHUPD_Pos) /**< (PWM_DTUPD) Dead-Time Value Update for PWMHx Output Mask */ 306 #define PWM_DTUPD_DTHUPD(value) (PWM_DTUPD_DTHUPD_Msk & ((value) << PWM_DTUPD_DTHUPD_Pos)) 307 #define PWM_DTUPD_DTLUPD_Pos 16 /**< (PWM_DTUPD) Dead-Time Value Update for PWMLx Output Position */ 308 #define PWM_DTUPD_DTLUPD_Msk (_U_(0xFFFF) << PWM_DTUPD_DTLUPD_Pos) /**< (PWM_DTUPD) Dead-Time Value Update for PWMLx Output Mask */ 309 #define PWM_DTUPD_DTLUPD(value) (PWM_DTUPD_DTLUPD_Msk & ((value) << PWM_DTUPD_DTLUPD_Pos)) 310 #define PWM_DTUPD_MASK _U_(0xFFFFFFFF) /**< \deprecated (PWM_DTUPD) Register MASK (Use PWM_DTUPD_Msk instead) */ 311 #define PWM_DTUPD_Msk _U_(0xFFFFFFFF) /**< (PWM_DTUPD) Register Mask */ 312 313 314 /* -------- PWM_CMPV : (PWM Offset: 0x00) (R/W 32) PWM Comparison 0 Value Register -------- */ 315 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 316 #if COMPONENT_TYPEDEF_STYLE == 'N' 317 typedef union { 318 struct { 319 uint32_t CV:24; /**< bit: 0..23 Comparison x Value */ 320 uint32_t CVM:1; /**< bit: 24 Comparison x Value Mode */ 321 uint32_t :7; /**< bit: 25..31 Reserved */ 322 } bit; /**< Structure used for bit access */ 323 uint32_t reg; /**< Type used for register access */ 324 } PWM_CMPV_Type; 325 #endif 326 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 327 328 #define PWM_CMPV_OFFSET (0x00) /**< (PWM_CMPV) PWM Comparison 0 Value Register Offset */ 329 330 #define PWM_CMPV_CV_Pos 0 /**< (PWM_CMPV) Comparison x Value Position */ 331 #define PWM_CMPV_CV_Msk (_U_(0xFFFFFF) << PWM_CMPV_CV_Pos) /**< (PWM_CMPV) Comparison x Value Mask */ 332 #define PWM_CMPV_CV(value) (PWM_CMPV_CV_Msk & ((value) << PWM_CMPV_CV_Pos)) 333 #define PWM_CMPV_CVM_Pos 24 /**< (PWM_CMPV) Comparison x Value Mode Position */ 334 #define PWM_CMPV_CVM_Msk (_U_(0x1) << PWM_CMPV_CVM_Pos) /**< (PWM_CMPV) Comparison x Value Mode Mask */ 335 #define PWM_CMPV_CVM PWM_CMPV_CVM_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_CMPV_CVM_Msk instead */ 336 #define PWM_CMPV_CVM_COMPARE_AT_INCREMENT_Val _U_(0x0) /**< (PWM_CMPV) Compare when counter is incrementing */ 337 #define PWM_CMPV_CVM_COMPARE_AT_DECREMENT_Val _U_(0x1) /**< (PWM_CMPV) Compare when counter is decrementing */ 338 #define PWM_CMPV_CVM_COMPARE_AT_INCREMENT (PWM_CMPV_CVM_COMPARE_AT_INCREMENT_Val << PWM_CMPV_CVM_Pos) /**< (PWM_CMPV) Compare when counter is incrementing Position */ 339 #define PWM_CMPV_CVM_COMPARE_AT_DECREMENT (PWM_CMPV_CVM_COMPARE_AT_DECREMENT_Val << PWM_CMPV_CVM_Pos) /**< (PWM_CMPV) Compare when counter is decrementing Position */ 340 #define PWM_CMPV_MASK _U_(0x1FFFFFF) /**< \deprecated (PWM_CMPV) Register MASK (Use PWM_CMPV_Msk instead) */ 341 #define PWM_CMPV_Msk _U_(0x1FFFFFF) /**< (PWM_CMPV) Register Mask */ 342 343 344 /* -------- PWM_CMPVUPD : (PWM Offset: 0x04) (/W 32) PWM Comparison 0 Value Update Register -------- */ 345 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 346 #if COMPONENT_TYPEDEF_STYLE == 'N' 347 typedef union { 348 struct { 349 uint32_t CVUPD:24; /**< bit: 0..23 Comparison x Value Update */ 350 uint32_t CVMUPD:1; /**< bit: 24 Comparison x Value Mode Update */ 351 uint32_t :7; /**< bit: 25..31 Reserved */ 352 } bit; /**< Structure used for bit access */ 353 uint32_t reg; /**< Type used for register access */ 354 } PWM_CMPVUPD_Type; 355 #endif 356 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 357 358 #define PWM_CMPVUPD_OFFSET (0x04) /**< (PWM_CMPVUPD) PWM Comparison 0 Value Update Register Offset */ 359 360 #define PWM_CMPVUPD_CVUPD_Pos 0 /**< (PWM_CMPVUPD) Comparison x Value Update Position */ 361 #define PWM_CMPVUPD_CVUPD_Msk (_U_(0xFFFFFF) << PWM_CMPVUPD_CVUPD_Pos) /**< (PWM_CMPVUPD) Comparison x Value Update Mask */ 362 #define PWM_CMPVUPD_CVUPD(value) (PWM_CMPVUPD_CVUPD_Msk & ((value) << PWM_CMPVUPD_CVUPD_Pos)) 363 #define PWM_CMPVUPD_CVMUPD_Pos 24 /**< (PWM_CMPVUPD) Comparison x Value Mode Update Position */ 364 #define PWM_CMPVUPD_CVMUPD_Msk (_U_(0x1) << PWM_CMPVUPD_CVMUPD_Pos) /**< (PWM_CMPVUPD) Comparison x Value Mode Update Mask */ 365 #define PWM_CMPVUPD_CVMUPD PWM_CMPVUPD_CVMUPD_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_CMPVUPD_CVMUPD_Msk instead */ 366 #define PWM_CMPVUPD_MASK _U_(0x1FFFFFF) /**< \deprecated (PWM_CMPVUPD) Register MASK (Use PWM_CMPVUPD_Msk instead) */ 367 #define PWM_CMPVUPD_Msk _U_(0x1FFFFFF) /**< (PWM_CMPVUPD) Register Mask */ 368 369 370 /* -------- PWM_CMPM : (PWM Offset: 0x08) (R/W 32) PWM Comparison 0 Mode Register -------- */ 371 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 372 #if COMPONENT_TYPEDEF_STYLE == 'N' 373 typedef union { 374 struct { 375 uint32_t CEN:1; /**< bit: 0 Comparison x Enable */ 376 uint32_t :3; /**< bit: 1..3 Reserved */ 377 uint32_t CTR:4; /**< bit: 4..7 Comparison x Trigger */ 378 uint32_t CPR:4; /**< bit: 8..11 Comparison x Period */ 379 uint32_t CPRCNT:4; /**< bit: 12..15 Comparison x Period Counter */ 380 uint32_t CUPR:4; /**< bit: 16..19 Comparison x Update Period */ 381 uint32_t CUPRCNT:4; /**< bit: 20..23 Comparison x Update Period Counter */ 382 uint32_t :8; /**< bit: 24..31 Reserved */ 383 } bit; /**< Structure used for bit access */ 384 uint32_t reg; /**< Type used for register access */ 385 } PWM_CMPM_Type; 386 #endif 387 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 388 389 #define PWM_CMPM_OFFSET (0x08) /**< (PWM_CMPM) PWM Comparison 0 Mode Register Offset */ 390 391 #define PWM_CMPM_CEN_Pos 0 /**< (PWM_CMPM) Comparison x Enable Position */ 392 #define PWM_CMPM_CEN_Msk (_U_(0x1) << PWM_CMPM_CEN_Pos) /**< (PWM_CMPM) Comparison x Enable Mask */ 393 #define PWM_CMPM_CEN PWM_CMPM_CEN_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_CMPM_CEN_Msk instead */ 394 #define PWM_CMPM_CTR_Pos 4 /**< (PWM_CMPM) Comparison x Trigger Position */ 395 #define PWM_CMPM_CTR_Msk (_U_(0xF) << PWM_CMPM_CTR_Pos) /**< (PWM_CMPM) Comparison x Trigger Mask */ 396 #define PWM_CMPM_CTR(value) (PWM_CMPM_CTR_Msk & ((value) << PWM_CMPM_CTR_Pos)) 397 #define PWM_CMPM_CPR_Pos 8 /**< (PWM_CMPM) Comparison x Period Position */ 398 #define PWM_CMPM_CPR_Msk (_U_(0xF) << PWM_CMPM_CPR_Pos) /**< (PWM_CMPM) Comparison x Period Mask */ 399 #define PWM_CMPM_CPR(value) (PWM_CMPM_CPR_Msk & ((value) << PWM_CMPM_CPR_Pos)) 400 #define PWM_CMPM_CPRCNT_Pos 12 /**< (PWM_CMPM) Comparison x Period Counter Position */ 401 #define PWM_CMPM_CPRCNT_Msk (_U_(0xF) << PWM_CMPM_CPRCNT_Pos) /**< (PWM_CMPM) Comparison x Period Counter Mask */ 402 #define PWM_CMPM_CPRCNT(value) (PWM_CMPM_CPRCNT_Msk & ((value) << PWM_CMPM_CPRCNT_Pos)) 403 #define PWM_CMPM_CUPR_Pos 16 /**< (PWM_CMPM) Comparison x Update Period Position */ 404 #define PWM_CMPM_CUPR_Msk (_U_(0xF) << PWM_CMPM_CUPR_Pos) /**< (PWM_CMPM) Comparison x Update Period Mask */ 405 #define PWM_CMPM_CUPR(value) (PWM_CMPM_CUPR_Msk & ((value) << PWM_CMPM_CUPR_Pos)) 406 #define PWM_CMPM_CUPRCNT_Pos 20 /**< (PWM_CMPM) Comparison x Update Period Counter Position */ 407 #define PWM_CMPM_CUPRCNT_Msk (_U_(0xF) << PWM_CMPM_CUPRCNT_Pos) /**< (PWM_CMPM) Comparison x Update Period Counter Mask */ 408 #define PWM_CMPM_CUPRCNT(value) (PWM_CMPM_CUPRCNT_Msk & ((value) << PWM_CMPM_CUPRCNT_Pos)) 409 #define PWM_CMPM_MASK _U_(0xFFFFF1) /**< \deprecated (PWM_CMPM) Register MASK (Use PWM_CMPM_Msk instead) */ 410 #define PWM_CMPM_Msk _U_(0xFFFFF1) /**< (PWM_CMPM) Register Mask */ 411 412 413 /* -------- PWM_CMPMUPD : (PWM Offset: 0x0c) (/W 32) PWM Comparison 0 Mode Update Register -------- */ 414 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 415 #if COMPONENT_TYPEDEF_STYLE == 'N' 416 typedef union { 417 struct { 418 uint32_t CENUPD:1; /**< bit: 0 Comparison x Enable Update */ 419 uint32_t :3; /**< bit: 1..3 Reserved */ 420 uint32_t CTRUPD:4; /**< bit: 4..7 Comparison x Trigger Update */ 421 uint32_t CPRUPD:4; /**< bit: 8..11 Comparison x Period Update */ 422 uint32_t :4; /**< bit: 12..15 Reserved */ 423 uint32_t CUPRUPD:4; /**< bit: 16..19 Comparison x Update Period Update */ 424 uint32_t :12; /**< bit: 20..31 Reserved */ 425 } bit; /**< Structure used for bit access */ 426 uint32_t reg; /**< Type used for register access */ 427 } PWM_CMPMUPD_Type; 428 #endif 429 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 430 431 #define PWM_CMPMUPD_OFFSET (0x0C) /**< (PWM_CMPMUPD) PWM Comparison 0 Mode Update Register Offset */ 432 433 #define PWM_CMPMUPD_CENUPD_Pos 0 /**< (PWM_CMPMUPD) Comparison x Enable Update Position */ 434 #define PWM_CMPMUPD_CENUPD_Msk (_U_(0x1) << PWM_CMPMUPD_CENUPD_Pos) /**< (PWM_CMPMUPD) Comparison x Enable Update Mask */ 435 #define PWM_CMPMUPD_CENUPD PWM_CMPMUPD_CENUPD_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_CMPMUPD_CENUPD_Msk instead */ 436 #define PWM_CMPMUPD_CTRUPD_Pos 4 /**< (PWM_CMPMUPD) Comparison x Trigger Update Position */ 437 #define PWM_CMPMUPD_CTRUPD_Msk (_U_(0xF) << PWM_CMPMUPD_CTRUPD_Pos) /**< (PWM_CMPMUPD) Comparison x Trigger Update Mask */ 438 #define PWM_CMPMUPD_CTRUPD(value) (PWM_CMPMUPD_CTRUPD_Msk & ((value) << PWM_CMPMUPD_CTRUPD_Pos)) 439 #define PWM_CMPMUPD_CPRUPD_Pos 8 /**< (PWM_CMPMUPD) Comparison x Period Update Position */ 440 #define PWM_CMPMUPD_CPRUPD_Msk (_U_(0xF) << PWM_CMPMUPD_CPRUPD_Pos) /**< (PWM_CMPMUPD) Comparison x Period Update Mask */ 441 #define PWM_CMPMUPD_CPRUPD(value) (PWM_CMPMUPD_CPRUPD_Msk & ((value) << PWM_CMPMUPD_CPRUPD_Pos)) 442 #define PWM_CMPMUPD_CUPRUPD_Pos 16 /**< (PWM_CMPMUPD) Comparison x Update Period Update Position */ 443 #define PWM_CMPMUPD_CUPRUPD_Msk (_U_(0xF) << PWM_CMPMUPD_CUPRUPD_Pos) /**< (PWM_CMPMUPD) Comparison x Update Period Update Mask */ 444 #define PWM_CMPMUPD_CUPRUPD(value) (PWM_CMPMUPD_CUPRUPD_Msk & ((value) << PWM_CMPMUPD_CUPRUPD_Pos)) 445 #define PWM_CMPMUPD_MASK _U_(0xF0FF1) /**< \deprecated (PWM_CMPMUPD) Register MASK (Use PWM_CMPMUPD_Msk instead) */ 446 #define PWM_CMPMUPD_Msk _U_(0xF0FF1) /**< (PWM_CMPMUPD) Register Mask */ 447 448 449 /* -------- PWM_CLK : (PWM Offset: 0x00) (R/W 32) PWM Clock Register -------- */ 450 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 451 #if COMPONENT_TYPEDEF_STYLE == 'N' 452 typedef union { 453 struct { 454 uint32_t DIVA:8; /**< bit: 0..7 CLKA Divide Factor */ 455 uint32_t PREA:4; /**< bit: 8..11 CLKA Source Clock Selection */ 456 uint32_t :4; /**< bit: 12..15 Reserved */ 457 uint32_t DIVB:8; /**< bit: 16..23 CLKB Divide Factor */ 458 uint32_t PREB:4; /**< bit: 24..27 CLKB Source Clock Selection */ 459 uint32_t :4; /**< bit: 28..31 Reserved */ 460 } bit; /**< Structure used for bit access */ 461 uint32_t reg; /**< Type used for register access */ 462 } PWM_CLK_Type; 463 #endif 464 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 465 466 #define PWM_CLK_OFFSET (0x00) /**< (PWM_CLK) PWM Clock Register Offset */ 467 468 #define PWM_CLK_DIVA_Pos 0 /**< (PWM_CLK) CLKA Divide Factor Position */ 469 #define PWM_CLK_DIVA_Msk (_U_(0xFF) << PWM_CLK_DIVA_Pos) /**< (PWM_CLK) CLKA Divide Factor Mask */ 470 #define PWM_CLK_DIVA(value) (PWM_CLK_DIVA_Msk & ((value) << PWM_CLK_DIVA_Pos)) 471 #define PWM_CLK_DIVA_CLKA_POFF_Val _U_(0x0) /**< (PWM_CLK) CLKA clock is turned off */ 472 #define PWM_CLK_DIVA_PREA_Val _U_(0x1) /**< (PWM_CLK) CLKA clock is clock selected by PREA */ 473 #define PWM_CLK_DIVA_CLKA_POFF (PWM_CLK_DIVA_CLKA_POFF_Val << PWM_CLK_DIVA_Pos) /**< (PWM_CLK) CLKA clock is turned off Position */ 474 #define PWM_CLK_DIVA_PREA (PWM_CLK_DIVA_PREA_Val << PWM_CLK_DIVA_Pos) /**< (PWM_CLK) CLKA clock is clock selected by PREA Position */ 475 #define PWM_CLK_PREA_Pos 8 /**< (PWM_CLK) CLKA Source Clock Selection Position */ 476 #define PWM_CLK_PREA_Msk (_U_(0xF) << PWM_CLK_PREA_Pos) /**< (PWM_CLK) CLKA Source Clock Selection Mask */ 477 #define PWM_CLK_PREA(value) (PWM_CLK_PREA_Msk & ((value) << PWM_CLK_PREA_Pos)) 478 #define PWM_CLK_PREA_CLK_Val _U_(0x0) /**< (PWM_CLK) Peripheral clock */ 479 #define PWM_CLK_PREA_CLK_DIV2_Val _U_(0x1) /**< (PWM_CLK) Peripheral clock/2 */ 480 #define PWM_CLK_PREA_CLK_DIV4_Val _U_(0x2) /**< (PWM_CLK) Peripheral clock/4 */ 481 #define PWM_CLK_PREA_CLK_DIV8_Val _U_(0x3) /**< (PWM_CLK) Peripheral clock/8 */ 482 #define PWM_CLK_PREA_CLK_DIV16_Val _U_(0x4) /**< (PWM_CLK) Peripheral clock/16 */ 483 #define PWM_CLK_PREA_CLK_DIV32_Val _U_(0x5) /**< (PWM_CLK) Peripheral clock/32 */ 484 #define PWM_CLK_PREA_CLK_DIV64_Val _U_(0x6) /**< (PWM_CLK) Peripheral clock/64 */ 485 #define PWM_CLK_PREA_CLK_DIV128_Val _U_(0x7) /**< (PWM_CLK) Peripheral clock/128 */ 486 #define PWM_CLK_PREA_CLK_DIV256_Val _U_(0x8) /**< (PWM_CLK) Peripheral clock/256 */ 487 #define PWM_CLK_PREA_CLK_DIV512_Val _U_(0x9) /**< (PWM_CLK) Peripheral clock/512 */ 488 #define PWM_CLK_PREA_CLK_DIV1024_Val _U_(0xA) /**< (PWM_CLK) Peripheral clock/1024 */ 489 #define PWM_CLK_PREA_CLK (PWM_CLK_PREA_CLK_Val << PWM_CLK_PREA_Pos) /**< (PWM_CLK) Peripheral clock Position */ 490 #define PWM_CLK_PREA_CLK_DIV2 (PWM_CLK_PREA_CLK_DIV2_Val << PWM_CLK_PREA_Pos) /**< (PWM_CLK) Peripheral clock/2 Position */ 491 #define PWM_CLK_PREA_CLK_DIV4 (PWM_CLK_PREA_CLK_DIV4_Val << PWM_CLK_PREA_Pos) /**< (PWM_CLK) Peripheral clock/4 Position */ 492 #define PWM_CLK_PREA_CLK_DIV8 (PWM_CLK_PREA_CLK_DIV8_Val << PWM_CLK_PREA_Pos) /**< (PWM_CLK) Peripheral clock/8 Position */ 493 #define PWM_CLK_PREA_CLK_DIV16 (PWM_CLK_PREA_CLK_DIV16_Val << PWM_CLK_PREA_Pos) /**< (PWM_CLK) Peripheral clock/16 Position */ 494 #define PWM_CLK_PREA_CLK_DIV32 (PWM_CLK_PREA_CLK_DIV32_Val << PWM_CLK_PREA_Pos) /**< (PWM_CLK) Peripheral clock/32 Position */ 495 #define PWM_CLK_PREA_CLK_DIV64 (PWM_CLK_PREA_CLK_DIV64_Val << PWM_CLK_PREA_Pos) /**< (PWM_CLK) Peripheral clock/64 Position */ 496 #define PWM_CLK_PREA_CLK_DIV128 (PWM_CLK_PREA_CLK_DIV128_Val << PWM_CLK_PREA_Pos) /**< (PWM_CLK) Peripheral clock/128 Position */ 497 #define PWM_CLK_PREA_CLK_DIV256 (PWM_CLK_PREA_CLK_DIV256_Val << PWM_CLK_PREA_Pos) /**< (PWM_CLK) Peripheral clock/256 Position */ 498 #define PWM_CLK_PREA_CLK_DIV512 (PWM_CLK_PREA_CLK_DIV512_Val << PWM_CLK_PREA_Pos) /**< (PWM_CLK) Peripheral clock/512 Position */ 499 #define PWM_CLK_PREA_CLK_DIV1024 (PWM_CLK_PREA_CLK_DIV1024_Val << PWM_CLK_PREA_Pos) /**< (PWM_CLK) Peripheral clock/1024 Position */ 500 #define PWM_CLK_DIVB_Pos 16 /**< (PWM_CLK) CLKB Divide Factor Position */ 501 #define PWM_CLK_DIVB_Msk (_U_(0xFF) << PWM_CLK_DIVB_Pos) /**< (PWM_CLK) CLKB Divide Factor Mask */ 502 #define PWM_CLK_DIVB(value) (PWM_CLK_DIVB_Msk & ((value) << PWM_CLK_DIVB_Pos)) 503 #define PWM_CLK_DIVB_CLKB_POFF_Val _U_(0x0) /**< (PWM_CLK) CLKB clock is turned off */ 504 #define PWM_CLK_DIVB_PREB_Val _U_(0x1) /**< (PWM_CLK) CLKB clock is clock selected by PREB */ 505 #define PWM_CLK_DIVB_CLKB_POFF (PWM_CLK_DIVB_CLKB_POFF_Val << PWM_CLK_DIVB_Pos) /**< (PWM_CLK) CLKB clock is turned off Position */ 506 #define PWM_CLK_DIVB_PREB (PWM_CLK_DIVB_PREB_Val << PWM_CLK_DIVB_Pos) /**< (PWM_CLK) CLKB clock is clock selected by PREB Position */ 507 #define PWM_CLK_PREB_Pos 24 /**< (PWM_CLK) CLKB Source Clock Selection Position */ 508 #define PWM_CLK_PREB_Msk (_U_(0xF) << PWM_CLK_PREB_Pos) /**< (PWM_CLK) CLKB Source Clock Selection Mask */ 509 #define PWM_CLK_PREB(value) (PWM_CLK_PREB_Msk & ((value) << PWM_CLK_PREB_Pos)) 510 #define PWM_CLK_PREB_CLK_Val _U_(0x0) /**< (PWM_CLK) Peripheral clock */ 511 #define PWM_CLK_PREB_CLK_DIV2_Val _U_(0x1) /**< (PWM_CLK) Peripheral clock/2 */ 512 #define PWM_CLK_PREB_CLK_DIV4_Val _U_(0x2) /**< (PWM_CLK) Peripheral clock/4 */ 513 #define PWM_CLK_PREB_CLK_DIV8_Val _U_(0x3) /**< (PWM_CLK) Peripheral clock/8 */ 514 #define PWM_CLK_PREB_CLK_DIV16_Val _U_(0x4) /**< (PWM_CLK) Peripheral clock/16 */ 515 #define PWM_CLK_PREB_CLK_DIV32_Val _U_(0x5) /**< (PWM_CLK) Peripheral clock/32 */ 516 #define PWM_CLK_PREB_CLK_DIV64_Val _U_(0x6) /**< (PWM_CLK) Peripheral clock/64 */ 517 #define PWM_CLK_PREB_CLK_DIV128_Val _U_(0x7) /**< (PWM_CLK) Peripheral clock/128 */ 518 #define PWM_CLK_PREB_CLK_DIV256_Val _U_(0x8) /**< (PWM_CLK) Peripheral clock/256 */ 519 #define PWM_CLK_PREB_CLK_DIV512_Val _U_(0x9) /**< (PWM_CLK) Peripheral clock/512 */ 520 #define PWM_CLK_PREB_CLK_DIV1024_Val _U_(0xA) /**< (PWM_CLK) Peripheral clock/1024 */ 521 #define PWM_CLK_PREB_CLK (PWM_CLK_PREB_CLK_Val << PWM_CLK_PREB_Pos) /**< (PWM_CLK) Peripheral clock Position */ 522 #define PWM_CLK_PREB_CLK_DIV2 (PWM_CLK_PREB_CLK_DIV2_Val << PWM_CLK_PREB_Pos) /**< (PWM_CLK) Peripheral clock/2 Position */ 523 #define PWM_CLK_PREB_CLK_DIV4 (PWM_CLK_PREB_CLK_DIV4_Val << PWM_CLK_PREB_Pos) /**< (PWM_CLK) Peripheral clock/4 Position */ 524 #define PWM_CLK_PREB_CLK_DIV8 (PWM_CLK_PREB_CLK_DIV8_Val << PWM_CLK_PREB_Pos) /**< (PWM_CLK) Peripheral clock/8 Position */ 525 #define PWM_CLK_PREB_CLK_DIV16 (PWM_CLK_PREB_CLK_DIV16_Val << PWM_CLK_PREB_Pos) /**< (PWM_CLK) Peripheral clock/16 Position */ 526 #define PWM_CLK_PREB_CLK_DIV32 (PWM_CLK_PREB_CLK_DIV32_Val << PWM_CLK_PREB_Pos) /**< (PWM_CLK) Peripheral clock/32 Position */ 527 #define PWM_CLK_PREB_CLK_DIV64 (PWM_CLK_PREB_CLK_DIV64_Val << PWM_CLK_PREB_Pos) /**< (PWM_CLK) Peripheral clock/64 Position */ 528 #define PWM_CLK_PREB_CLK_DIV128 (PWM_CLK_PREB_CLK_DIV128_Val << PWM_CLK_PREB_Pos) /**< (PWM_CLK) Peripheral clock/128 Position */ 529 #define PWM_CLK_PREB_CLK_DIV256 (PWM_CLK_PREB_CLK_DIV256_Val << PWM_CLK_PREB_Pos) /**< (PWM_CLK) Peripheral clock/256 Position */ 530 #define PWM_CLK_PREB_CLK_DIV512 (PWM_CLK_PREB_CLK_DIV512_Val << PWM_CLK_PREB_Pos) /**< (PWM_CLK) Peripheral clock/512 Position */ 531 #define PWM_CLK_PREB_CLK_DIV1024 (PWM_CLK_PREB_CLK_DIV1024_Val << PWM_CLK_PREB_Pos) /**< (PWM_CLK) Peripheral clock/1024 Position */ 532 #define PWM_CLK_MASK _U_(0xFFF0FFF) /**< \deprecated (PWM_CLK) Register MASK (Use PWM_CLK_Msk instead) */ 533 #define PWM_CLK_Msk _U_(0xFFF0FFF) /**< (PWM_CLK) Register Mask */ 534 535 536 /* -------- PWM_ENA : (PWM Offset: 0x04) (/W 32) PWM Enable Register -------- */ 537 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 538 #if COMPONENT_TYPEDEF_STYLE == 'N' 539 typedef union { 540 struct { 541 uint32_t CHID0:1; /**< bit: 0 Channel ID */ 542 uint32_t CHID1:1; /**< bit: 1 Channel ID */ 543 uint32_t CHID2:1; /**< bit: 2 Channel ID */ 544 uint32_t CHID3:1; /**< bit: 3 Channel ID */ 545 uint32_t :28; /**< bit: 4..31 Reserved */ 546 } bit; /**< Structure used for bit access */ 547 struct { 548 uint32_t CHID:4; /**< bit: 0..3 Channel ID */ 549 uint32_t :28; /**< bit: 4..31 Reserved */ 550 } vec; /**< Structure used for vec access */ 551 uint32_t reg; /**< Type used for register access */ 552 } PWM_ENA_Type; 553 #endif 554 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 555 556 #define PWM_ENA_OFFSET (0x04) /**< (PWM_ENA) PWM Enable Register Offset */ 557 558 #define PWM_ENA_CHID0_Pos 0 /**< (PWM_ENA) Channel ID Position */ 559 #define PWM_ENA_CHID0_Msk (_U_(0x1) << PWM_ENA_CHID0_Pos) /**< (PWM_ENA) Channel ID Mask */ 560 #define PWM_ENA_CHID0 PWM_ENA_CHID0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ENA_CHID0_Msk instead */ 561 #define PWM_ENA_CHID1_Pos 1 /**< (PWM_ENA) Channel ID Position */ 562 #define PWM_ENA_CHID1_Msk (_U_(0x1) << PWM_ENA_CHID1_Pos) /**< (PWM_ENA) Channel ID Mask */ 563 #define PWM_ENA_CHID1 PWM_ENA_CHID1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ENA_CHID1_Msk instead */ 564 #define PWM_ENA_CHID2_Pos 2 /**< (PWM_ENA) Channel ID Position */ 565 #define PWM_ENA_CHID2_Msk (_U_(0x1) << PWM_ENA_CHID2_Pos) /**< (PWM_ENA) Channel ID Mask */ 566 #define PWM_ENA_CHID2 PWM_ENA_CHID2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ENA_CHID2_Msk instead */ 567 #define PWM_ENA_CHID3_Pos 3 /**< (PWM_ENA) Channel ID Position */ 568 #define PWM_ENA_CHID3_Msk (_U_(0x1) << PWM_ENA_CHID3_Pos) /**< (PWM_ENA) Channel ID Mask */ 569 #define PWM_ENA_CHID3 PWM_ENA_CHID3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ENA_CHID3_Msk instead */ 570 #define PWM_ENA_MASK _U_(0x0F) /**< \deprecated (PWM_ENA) Register MASK (Use PWM_ENA_Msk instead) */ 571 #define PWM_ENA_Msk _U_(0x0F) /**< (PWM_ENA) Register Mask */ 572 573 #define PWM_ENA_CHID_Pos 0 /**< (PWM_ENA Position) Channel ID */ 574 #define PWM_ENA_CHID_Msk (_U_(0xF) << PWM_ENA_CHID_Pos) /**< (PWM_ENA Mask) CHID */ 575 #define PWM_ENA_CHID(value) (PWM_ENA_CHID_Msk & ((value) << PWM_ENA_CHID_Pos)) 576 577 /* -------- PWM_DIS : (PWM Offset: 0x08) (/W 32) PWM Disable Register -------- */ 578 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 579 #if COMPONENT_TYPEDEF_STYLE == 'N' 580 typedef union { 581 struct { 582 uint32_t CHID0:1; /**< bit: 0 Channel ID */ 583 uint32_t CHID1:1; /**< bit: 1 Channel ID */ 584 uint32_t CHID2:1; /**< bit: 2 Channel ID */ 585 uint32_t CHID3:1; /**< bit: 3 Channel ID */ 586 uint32_t :28; /**< bit: 4..31 Reserved */ 587 } bit; /**< Structure used for bit access */ 588 struct { 589 uint32_t CHID:4; /**< bit: 0..3 Channel ID */ 590 uint32_t :28; /**< bit: 4..31 Reserved */ 591 } vec; /**< Structure used for vec access */ 592 uint32_t reg; /**< Type used for register access */ 593 } PWM_DIS_Type; 594 #endif 595 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 596 597 #define PWM_DIS_OFFSET (0x08) /**< (PWM_DIS) PWM Disable Register Offset */ 598 599 #define PWM_DIS_CHID0_Pos 0 /**< (PWM_DIS) Channel ID Position */ 600 #define PWM_DIS_CHID0_Msk (_U_(0x1) << PWM_DIS_CHID0_Pos) /**< (PWM_DIS) Channel ID Mask */ 601 #define PWM_DIS_CHID0 PWM_DIS_CHID0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_DIS_CHID0_Msk instead */ 602 #define PWM_DIS_CHID1_Pos 1 /**< (PWM_DIS) Channel ID Position */ 603 #define PWM_DIS_CHID1_Msk (_U_(0x1) << PWM_DIS_CHID1_Pos) /**< (PWM_DIS) Channel ID Mask */ 604 #define PWM_DIS_CHID1 PWM_DIS_CHID1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_DIS_CHID1_Msk instead */ 605 #define PWM_DIS_CHID2_Pos 2 /**< (PWM_DIS) Channel ID Position */ 606 #define PWM_DIS_CHID2_Msk (_U_(0x1) << PWM_DIS_CHID2_Pos) /**< (PWM_DIS) Channel ID Mask */ 607 #define PWM_DIS_CHID2 PWM_DIS_CHID2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_DIS_CHID2_Msk instead */ 608 #define PWM_DIS_CHID3_Pos 3 /**< (PWM_DIS) Channel ID Position */ 609 #define PWM_DIS_CHID3_Msk (_U_(0x1) << PWM_DIS_CHID3_Pos) /**< (PWM_DIS) Channel ID Mask */ 610 #define PWM_DIS_CHID3 PWM_DIS_CHID3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_DIS_CHID3_Msk instead */ 611 #define PWM_DIS_MASK _U_(0x0F) /**< \deprecated (PWM_DIS) Register MASK (Use PWM_DIS_Msk instead) */ 612 #define PWM_DIS_Msk _U_(0x0F) /**< (PWM_DIS) Register Mask */ 613 614 #define PWM_DIS_CHID_Pos 0 /**< (PWM_DIS Position) Channel ID */ 615 #define PWM_DIS_CHID_Msk (_U_(0xF) << PWM_DIS_CHID_Pos) /**< (PWM_DIS Mask) CHID */ 616 #define PWM_DIS_CHID(value) (PWM_DIS_CHID_Msk & ((value) << PWM_DIS_CHID_Pos)) 617 618 /* -------- PWM_SR : (PWM Offset: 0x0c) (R/ 32) PWM Status Register -------- */ 619 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 620 #if COMPONENT_TYPEDEF_STYLE == 'N' 621 typedef union { 622 struct { 623 uint32_t CHID0:1; /**< bit: 0 Channel ID */ 624 uint32_t CHID1:1; /**< bit: 1 Channel ID */ 625 uint32_t CHID2:1; /**< bit: 2 Channel ID */ 626 uint32_t CHID3:1; /**< bit: 3 Channel ID */ 627 uint32_t :28; /**< bit: 4..31 Reserved */ 628 } bit; /**< Structure used for bit access */ 629 struct { 630 uint32_t CHID:4; /**< bit: 0..3 Channel ID */ 631 uint32_t :28; /**< bit: 4..31 Reserved */ 632 } vec; /**< Structure used for vec access */ 633 uint32_t reg; /**< Type used for register access */ 634 } PWM_SR_Type; 635 #endif 636 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 637 638 #define PWM_SR_OFFSET (0x0C) /**< (PWM_SR) PWM Status Register Offset */ 639 640 #define PWM_SR_CHID0_Pos 0 /**< (PWM_SR) Channel ID Position */ 641 #define PWM_SR_CHID0_Msk (_U_(0x1) << PWM_SR_CHID0_Pos) /**< (PWM_SR) Channel ID Mask */ 642 #define PWM_SR_CHID0 PWM_SR_CHID0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_SR_CHID0_Msk instead */ 643 #define PWM_SR_CHID1_Pos 1 /**< (PWM_SR) Channel ID Position */ 644 #define PWM_SR_CHID1_Msk (_U_(0x1) << PWM_SR_CHID1_Pos) /**< (PWM_SR) Channel ID Mask */ 645 #define PWM_SR_CHID1 PWM_SR_CHID1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_SR_CHID1_Msk instead */ 646 #define PWM_SR_CHID2_Pos 2 /**< (PWM_SR) Channel ID Position */ 647 #define PWM_SR_CHID2_Msk (_U_(0x1) << PWM_SR_CHID2_Pos) /**< (PWM_SR) Channel ID Mask */ 648 #define PWM_SR_CHID2 PWM_SR_CHID2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_SR_CHID2_Msk instead */ 649 #define PWM_SR_CHID3_Pos 3 /**< (PWM_SR) Channel ID Position */ 650 #define PWM_SR_CHID3_Msk (_U_(0x1) << PWM_SR_CHID3_Pos) /**< (PWM_SR) Channel ID Mask */ 651 #define PWM_SR_CHID3 PWM_SR_CHID3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_SR_CHID3_Msk instead */ 652 #define PWM_SR_MASK _U_(0x0F) /**< \deprecated (PWM_SR) Register MASK (Use PWM_SR_Msk instead) */ 653 #define PWM_SR_Msk _U_(0x0F) /**< (PWM_SR) Register Mask */ 654 655 #define PWM_SR_CHID_Pos 0 /**< (PWM_SR Position) Channel ID */ 656 #define PWM_SR_CHID_Msk (_U_(0xF) << PWM_SR_CHID_Pos) /**< (PWM_SR Mask) CHID */ 657 #define PWM_SR_CHID(value) (PWM_SR_CHID_Msk & ((value) << PWM_SR_CHID_Pos)) 658 659 /* -------- PWM_IER1 : (PWM Offset: 0x10) (/W 32) PWM Interrupt Enable Register 1 -------- */ 660 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 661 #if COMPONENT_TYPEDEF_STYLE == 'N' 662 typedef union { 663 struct { 664 uint32_t CHID0:1; /**< bit: 0 Counter Event on Channel 0 Interrupt Enable */ 665 uint32_t CHID1:1; /**< bit: 1 Counter Event on Channel 1 Interrupt Enable */ 666 uint32_t CHID2:1; /**< bit: 2 Counter Event on Channel 2 Interrupt Enable */ 667 uint32_t CHID3:1; /**< bit: 3 Counter Event on Channel 3 Interrupt Enable */ 668 uint32_t :12; /**< bit: 4..15 Reserved */ 669 uint32_t FCHID0:1; /**< bit: 16 Fault Protection Trigger on Channel 0 Interrupt Enable */ 670 uint32_t FCHID1:1; /**< bit: 17 Fault Protection Trigger on Channel 1 Interrupt Enable */ 671 uint32_t FCHID2:1; /**< bit: 18 Fault Protection Trigger on Channel 2 Interrupt Enable */ 672 uint32_t FCHID3:1; /**< bit: 19 Fault Protection Trigger on Channel 3 Interrupt Enable */ 673 uint32_t :12; /**< bit: 20..31 Reserved */ 674 } bit; /**< Structure used for bit access */ 675 struct { 676 uint32_t CHID:4; /**< bit: 0..3 Counter Event on Channel x Interrupt Enable */ 677 uint32_t :12; /**< bit: 4..15 Reserved */ 678 uint32_t FCHID:4; /**< bit: 16..19 Fault Protection Trigger on Channel 3 Interrupt Enable */ 679 uint32_t :12; /**< bit: 20..31 Reserved */ 680 } vec; /**< Structure used for vec access */ 681 uint32_t reg; /**< Type used for register access */ 682 } PWM_IER1_Type; 683 #endif 684 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 685 686 #define PWM_IER1_OFFSET (0x10) /**< (PWM_IER1) PWM Interrupt Enable Register 1 Offset */ 687 688 #define PWM_IER1_CHID0_Pos 0 /**< (PWM_IER1) Counter Event on Channel 0 Interrupt Enable Position */ 689 #define PWM_IER1_CHID0_Msk (_U_(0x1) << PWM_IER1_CHID0_Pos) /**< (PWM_IER1) Counter Event on Channel 0 Interrupt Enable Mask */ 690 #define PWM_IER1_CHID0 PWM_IER1_CHID0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IER1_CHID0_Msk instead */ 691 #define PWM_IER1_CHID1_Pos 1 /**< (PWM_IER1) Counter Event on Channel 1 Interrupt Enable Position */ 692 #define PWM_IER1_CHID1_Msk (_U_(0x1) << PWM_IER1_CHID1_Pos) /**< (PWM_IER1) Counter Event on Channel 1 Interrupt Enable Mask */ 693 #define PWM_IER1_CHID1 PWM_IER1_CHID1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IER1_CHID1_Msk instead */ 694 #define PWM_IER1_CHID2_Pos 2 /**< (PWM_IER1) Counter Event on Channel 2 Interrupt Enable Position */ 695 #define PWM_IER1_CHID2_Msk (_U_(0x1) << PWM_IER1_CHID2_Pos) /**< (PWM_IER1) Counter Event on Channel 2 Interrupt Enable Mask */ 696 #define PWM_IER1_CHID2 PWM_IER1_CHID2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IER1_CHID2_Msk instead */ 697 #define PWM_IER1_CHID3_Pos 3 /**< (PWM_IER1) Counter Event on Channel 3 Interrupt Enable Position */ 698 #define PWM_IER1_CHID3_Msk (_U_(0x1) << PWM_IER1_CHID3_Pos) /**< (PWM_IER1) Counter Event on Channel 3 Interrupt Enable Mask */ 699 #define PWM_IER1_CHID3 PWM_IER1_CHID3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IER1_CHID3_Msk instead */ 700 #define PWM_IER1_FCHID0_Pos 16 /**< (PWM_IER1) Fault Protection Trigger on Channel 0 Interrupt Enable Position */ 701 #define PWM_IER1_FCHID0_Msk (_U_(0x1) << PWM_IER1_FCHID0_Pos) /**< (PWM_IER1) Fault Protection Trigger on Channel 0 Interrupt Enable Mask */ 702 #define PWM_IER1_FCHID0 PWM_IER1_FCHID0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IER1_FCHID0_Msk instead */ 703 #define PWM_IER1_FCHID1_Pos 17 /**< (PWM_IER1) Fault Protection Trigger on Channel 1 Interrupt Enable Position */ 704 #define PWM_IER1_FCHID1_Msk (_U_(0x1) << PWM_IER1_FCHID1_Pos) /**< (PWM_IER1) Fault Protection Trigger on Channel 1 Interrupt Enable Mask */ 705 #define PWM_IER1_FCHID1 PWM_IER1_FCHID1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IER1_FCHID1_Msk instead */ 706 #define PWM_IER1_FCHID2_Pos 18 /**< (PWM_IER1) Fault Protection Trigger on Channel 2 Interrupt Enable Position */ 707 #define PWM_IER1_FCHID2_Msk (_U_(0x1) << PWM_IER1_FCHID2_Pos) /**< (PWM_IER1) Fault Protection Trigger on Channel 2 Interrupt Enable Mask */ 708 #define PWM_IER1_FCHID2 PWM_IER1_FCHID2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IER1_FCHID2_Msk instead */ 709 #define PWM_IER1_FCHID3_Pos 19 /**< (PWM_IER1) Fault Protection Trigger on Channel 3 Interrupt Enable Position */ 710 #define PWM_IER1_FCHID3_Msk (_U_(0x1) << PWM_IER1_FCHID3_Pos) /**< (PWM_IER1) Fault Protection Trigger on Channel 3 Interrupt Enable Mask */ 711 #define PWM_IER1_FCHID3 PWM_IER1_FCHID3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IER1_FCHID3_Msk instead */ 712 #define PWM_IER1_MASK _U_(0xF000F) /**< \deprecated (PWM_IER1) Register MASK (Use PWM_IER1_Msk instead) */ 713 #define PWM_IER1_Msk _U_(0xF000F) /**< (PWM_IER1) Register Mask */ 714 715 #define PWM_IER1_CHID_Pos 0 /**< (PWM_IER1 Position) Counter Event on Channel x Interrupt Enable */ 716 #define PWM_IER1_CHID_Msk (_U_(0xF) << PWM_IER1_CHID_Pos) /**< (PWM_IER1 Mask) CHID */ 717 #define PWM_IER1_CHID(value) (PWM_IER1_CHID_Msk & ((value) << PWM_IER1_CHID_Pos)) 718 #define PWM_IER1_FCHID_Pos 16 /**< (PWM_IER1 Position) Fault Protection Trigger on Channel 3 Interrupt Enable */ 719 #define PWM_IER1_FCHID_Msk (_U_(0xF) << PWM_IER1_FCHID_Pos) /**< (PWM_IER1 Mask) FCHID */ 720 #define PWM_IER1_FCHID(value) (PWM_IER1_FCHID_Msk & ((value) << PWM_IER1_FCHID_Pos)) 721 722 /* -------- PWM_IDR1 : (PWM Offset: 0x14) (/W 32) PWM Interrupt Disable Register 1 -------- */ 723 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 724 #if COMPONENT_TYPEDEF_STYLE == 'N' 725 typedef union { 726 struct { 727 uint32_t CHID0:1; /**< bit: 0 Counter Event on Channel 0 Interrupt Disable */ 728 uint32_t CHID1:1; /**< bit: 1 Counter Event on Channel 1 Interrupt Disable */ 729 uint32_t CHID2:1; /**< bit: 2 Counter Event on Channel 2 Interrupt Disable */ 730 uint32_t CHID3:1; /**< bit: 3 Counter Event on Channel 3 Interrupt Disable */ 731 uint32_t :12; /**< bit: 4..15 Reserved */ 732 uint32_t FCHID0:1; /**< bit: 16 Fault Protection Trigger on Channel 0 Interrupt Disable */ 733 uint32_t FCHID1:1; /**< bit: 17 Fault Protection Trigger on Channel 1 Interrupt Disable */ 734 uint32_t FCHID2:1; /**< bit: 18 Fault Protection Trigger on Channel 2 Interrupt Disable */ 735 uint32_t FCHID3:1; /**< bit: 19 Fault Protection Trigger on Channel 3 Interrupt Disable */ 736 uint32_t :12; /**< bit: 20..31 Reserved */ 737 } bit; /**< Structure used for bit access */ 738 struct { 739 uint32_t CHID:4; /**< bit: 0..3 Counter Event on Channel x Interrupt Disable */ 740 uint32_t :12; /**< bit: 4..15 Reserved */ 741 uint32_t FCHID:4; /**< bit: 16..19 Fault Protection Trigger on Channel 3 Interrupt Disable */ 742 uint32_t :12; /**< bit: 20..31 Reserved */ 743 } vec; /**< Structure used for vec access */ 744 uint32_t reg; /**< Type used for register access */ 745 } PWM_IDR1_Type; 746 #endif 747 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 748 749 #define PWM_IDR1_OFFSET (0x14) /**< (PWM_IDR1) PWM Interrupt Disable Register 1 Offset */ 750 751 #define PWM_IDR1_CHID0_Pos 0 /**< (PWM_IDR1) Counter Event on Channel 0 Interrupt Disable Position */ 752 #define PWM_IDR1_CHID0_Msk (_U_(0x1) << PWM_IDR1_CHID0_Pos) /**< (PWM_IDR1) Counter Event on Channel 0 Interrupt Disable Mask */ 753 #define PWM_IDR1_CHID0 PWM_IDR1_CHID0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IDR1_CHID0_Msk instead */ 754 #define PWM_IDR1_CHID1_Pos 1 /**< (PWM_IDR1) Counter Event on Channel 1 Interrupt Disable Position */ 755 #define PWM_IDR1_CHID1_Msk (_U_(0x1) << PWM_IDR1_CHID1_Pos) /**< (PWM_IDR1) Counter Event on Channel 1 Interrupt Disable Mask */ 756 #define PWM_IDR1_CHID1 PWM_IDR1_CHID1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IDR1_CHID1_Msk instead */ 757 #define PWM_IDR1_CHID2_Pos 2 /**< (PWM_IDR1) Counter Event on Channel 2 Interrupt Disable Position */ 758 #define PWM_IDR1_CHID2_Msk (_U_(0x1) << PWM_IDR1_CHID2_Pos) /**< (PWM_IDR1) Counter Event on Channel 2 Interrupt Disable Mask */ 759 #define PWM_IDR1_CHID2 PWM_IDR1_CHID2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IDR1_CHID2_Msk instead */ 760 #define PWM_IDR1_CHID3_Pos 3 /**< (PWM_IDR1) Counter Event on Channel 3 Interrupt Disable Position */ 761 #define PWM_IDR1_CHID3_Msk (_U_(0x1) << PWM_IDR1_CHID3_Pos) /**< (PWM_IDR1) Counter Event on Channel 3 Interrupt Disable Mask */ 762 #define PWM_IDR1_CHID3 PWM_IDR1_CHID3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IDR1_CHID3_Msk instead */ 763 #define PWM_IDR1_FCHID0_Pos 16 /**< (PWM_IDR1) Fault Protection Trigger on Channel 0 Interrupt Disable Position */ 764 #define PWM_IDR1_FCHID0_Msk (_U_(0x1) << PWM_IDR1_FCHID0_Pos) /**< (PWM_IDR1) Fault Protection Trigger on Channel 0 Interrupt Disable Mask */ 765 #define PWM_IDR1_FCHID0 PWM_IDR1_FCHID0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IDR1_FCHID0_Msk instead */ 766 #define PWM_IDR1_FCHID1_Pos 17 /**< (PWM_IDR1) Fault Protection Trigger on Channel 1 Interrupt Disable Position */ 767 #define PWM_IDR1_FCHID1_Msk (_U_(0x1) << PWM_IDR1_FCHID1_Pos) /**< (PWM_IDR1) Fault Protection Trigger on Channel 1 Interrupt Disable Mask */ 768 #define PWM_IDR1_FCHID1 PWM_IDR1_FCHID1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IDR1_FCHID1_Msk instead */ 769 #define PWM_IDR1_FCHID2_Pos 18 /**< (PWM_IDR1) Fault Protection Trigger on Channel 2 Interrupt Disable Position */ 770 #define PWM_IDR1_FCHID2_Msk (_U_(0x1) << PWM_IDR1_FCHID2_Pos) /**< (PWM_IDR1) Fault Protection Trigger on Channel 2 Interrupt Disable Mask */ 771 #define PWM_IDR1_FCHID2 PWM_IDR1_FCHID2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IDR1_FCHID2_Msk instead */ 772 #define PWM_IDR1_FCHID3_Pos 19 /**< (PWM_IDR1) Fault Protection Trigger on Channel 3 Interrupt Disable Position */ 773 #define PWM_IDR1_FCHID3_Msk (_U_(0x1) << PWM_IDR1_FCHID3_Pos) /**< (PWM_IDR1) Fault Protection Trigger on Channel 3 Interrupt Disable Mask */ 774 #define PWM_IDR1_FCHID3 PWM_IDR1_FCHID3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IDR1_FCHID3_Msk instead */ 775 #define PWM_IDR1_MASK _U_(0xF000F) /**< \deprecated (PWM_IDR1) Register MASK (Use PWM_IDR1_Msk instead) */ 776 #define PWM_IDR1_Msk _U_(0xF000F) /**< (PWM_IDR1) Register Mask */ 777 778 #define PWM_IDR1_CHID_Pos 0 /**< (PWM_IDR1 Position) Counter Event on Channel x Interrupt Disable */ 779 #define PWM_IDR1_CHID_Msk (_U_(0xF) << PWM_IDR1_CHID_Pos) /**< (PWM_IDR1 Mask) CHID */ 780 #define PWM_IDR1_CHID(value) (PWM_IDR1_CHID_Msk & ((value) << PWM_IDR1_CHID_Pos)) 781 #define PWM_IDR1_FCHID_Pos 16 /**< (PWM_IDR1 Position) Fault Protection Trigger on Channel 3 Interrupt Disable */ 782 #define PWM_IDR1_FCHID_Msk (_U_(0xF) << PWM_IDR1_FCHID_Pos) /**< (PWM_IDR1 Mask) FCHID */ 783 #define PWM_IDR1_FCHID(value) (PWM_IDR1_FCHID_Msk & ((value) << PWM_IDR1_FCHID_Pos)) 784 785 /* -------- PWM_IMR1 : (PWM Offset: 0x18) (R/ 32) PWM Interrupt Mask Register 1 -------- */ 786 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 787 #if COMPONENT_TYPEDEF_STYLE == 'N' 788 typedef union { 789 struct { 790 uint32_t CHID0:1; /**< bit: 0 Counter Event on Channel 0 Interrupt Mask */ 791 uint32_t CHID1:1; /**< bit: 1 Counter Event on Channel 1 Interrupt Mask */ 792 uint32_t CHID2:1; /**< bit: 2 Counter Event on Channel 2 Interrupt Mask */ 793 uint32_t CHID3:1; /**< bit: 3 Counter Event on Channel 3 Interrupt Mask */ 794 uint32_t :12; /**< bit: 4..15 Reserved */ 795 uint32_t FCHID0:1; /**< bit: 16 Fault Protection Trigger on Channel 0 Interrupt Mask */ 796 uint32_t FCHID1:1; /**< bit: 17 Fault Protection Trigger on Channel 1 Interrupt Mask */ 797 uint32_t FCHID2:1; /**< bit: 18 Fault Protection Trigger on Channel 2 Interrupt Mask */ 798 uint32_t FCHID3:1; /**< bit: 19 Fault Protection Trigger on Channel 3 Interrupt Mask */ 799 uint32_t :12; /**< bit: 20..31 Reserved */ 800 } bit; /**< Structure used for bit access */ 801 struct { 802 uint32_t CHID:4; /**< bit: 0..3 Counter Event on Channel x Interrupt Mask */ 803 uint32_t :12; /**< bit: 4..15 Reserved */ 804 uint32_t FCHID:4; /**< bit: 16..19 Fault Protection Trigger on Channel 3 Interrupt Mask */ 805 uint32_t :12; /**< bit: 20..31 Reserved */ 806 } vec; /**< Structure used for vec access */ 807 uint32_t reg; /**< Type used for register access */ 808 } PWM_IMR1_Type; 809 #endif 810 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 811 812 #define PWM_IMR1_OFFSET (0x18) /**< (PWM_IMR1) PWM Interrupt Mask Register 1 Offset */ 813 814 #define PWM_IMR1_CHID0_Pos 0 /**< (PWM_IMR1) Counter Event on Channel 0 Interrupt Mask Position */ 815 #define PWM_IMR1_CHID0_Msk (_U_(0x1) << PWM_IMR1_CHID0_Pos) /**< (PWM_IMR1) Counter Event on Channel 0 Interrupt Mask Mask */ 816 #define PWM_IMR1_CHID0 PWM_IMR1_CHID0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IMR1_CHID0_Msk instead */ 817 #define PWM_IMR1_CHID1_Pos 1 /**< (PWM_IMR1) Counter Event on Channel 1 Interrupt Mask Position */ 818 #define PWM_IMR1_CHID1_Msk (_U_(0x1) << PWM_IMR1_CHID1_Pos) /**< (PWM_IMR1) Counter Event on Channel 1 Interrupt Mask Mask */ 819 #define PWM_IMR1_CHID1 PWM_IMR1_CHID1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IMR1_CHID1_Msk instead */ 820 #define PWM_IMR1_CHID2_Pos 2 /**< (PWM_IMR1) Counter Event on Channel 2 Interrupt Mask Position */ 821 #define PWM_IMR1_CHID2_Msk (_U_(0x1) << PWM_IMR1_CHID2_Pos) /**< (PWM_IMR1) Counter Event on Channel 2 Interrupt Mask Mask */ 822 #define PWM_IMR1_CHID2 PWM_IMR1_CHID2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IMR1_CHID2_Msk instead */ 823 #define PWM_IMR1_CHID3_Pos 3 /**< (PWM_IMR1) Counter Event on Channel 3 Interrupt Mask Position */ 824 #define PWM_IMR1_CHID3_Msk (_U_(0x1) << PWM_IMR1_CHID3_Pos) /**< (PWM_IMR1) Counter Event on Channel 3 Interrupt Mask Mask */ 825 #define PWM_IMR1_CHID3 PWM_IMR1_CHID3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IMR1_CHID3_Msk instead */ 826 #define PWM_IMR1_FCHID0_Pos 16 /**< (PWM_IMR1) Fault Protection Trigger on Channel 0 Interrupt Mask Position */ 827 #define PWM_IMR1_FCHID0_Msk (_U_(0x1) << PWM_IMR1_FCHID0_Pos) /**< (PWM_IMR1) Fault Protection Trigger on Channel 0 Interrupt Mask Mask */ 828 #define PWM_IMR1_FCHID0 PWM_IMR1_FCHID0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IMR1_FCHID0_Msk instead */ 829 #define PWM_IMR1_FCHID1_Pos 17 /**< (PWM_IMR1) Fault Protection Trigger on Channel 1 Interrupt Mask Position */ 830 #define PWM_IMR1_FCHID1_Msk (_U_(0x1) << PWM_IMR1_FCHID1_Pos) /**< (PWM_IMR1) Fault Protection Trigger on Channel 1 Interrupt Mask Mask */ 831 #define PWM_IMR1_FCHID1 PWM_IMR1_FCHID1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IMR1_FCHID1_Msk instead */ 832 #define PWM_IMR1_FCHID2_Pos 18 /**< (PWM_IMR1) Fault Protection Trigger on Channel 2 Interrupt Mask Position */ 833 #define PWM_IMR1_FCHID2_Msk (_U_(0x1) << PWM_IMR1_FCHID2_Pos) /**< (PWM_IMR1) Fault Protection Trigger on Channel 2 Interrupt Mask Mask */ 834 #define PWM_IMR1_FCHID2 PWM_IMR1_FCHID2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IMR1_FCHID2_Msk instead */ 835 #define PWM_IMR1_FCHID3_Pos 19 /**< (PWM_IMR1) Fault Protection Trigger on Channel 3 Interrupt Mask Position */ 836 #define PWM_IMR1_FCHID3_Msk (_U_(0x1) << PWM_IMR1_FCHID3_Pos) /**< (PWM_IMR1) Fault Protection Trigger on Channel 3 Interrupt Mask Mask */ 837 #define PWM_IMR1_FCHID3 PWM_IMR1_FCHID3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IMR1_FCHID3_Msk instead */ 838 #define PWM_IMR1_MASK _U_(0xF000F) /**< \deprecated (PWM_IMR1) Register MASK (Use PWM_IMR1_Msk instead) */ 839 #define PWM_IMR1_Msk _U_(0xF000F) /**< (PWM_IMR1) Register Mask */ 840 841 #define PWM_IMR1_CHID_Pos 0 /**< (PWM_IMR1 Position) Counter Event on Channel x Interrupt Mask */ 842 #define PWM_IMR1_CHID_Msk (_U_(0xF) << PWM_IMR1_CHID_Pos) /**< (PWM_IMR1 Mask) CHID */ 843 #define PWM_IMR1_CHID(value) (PWM_IMR1_CHID_Msk & ((value) << PWM_IMR1_CHID_Pos)) 844 #define PWM_IMR1_FCHID_Pos 16 /**< (PWM_IMR1 Position) Fault Protection Trigger on Channel 3 Interrupt Mask */ 845 #define PWM_IMR1_FCHID_Msk (_U_(0xF) << PWM_IMR1_FCHID_Pos) /**< (PWM_IMR1 Mask) FCHID */ 846 #define PWM_IMR1_FCHID(value) (PWM_IMR1_FCHID_Msk & ((value) << PWM_IMR1_FCHID_Pos)) 847 848 /* -------- PWM_ISR1 : (PWM Offset: 0x1c) (R/ 32) PWM Interrupt Status Register 1 -------- */ 849 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 850 #if COMPONENT_TYPEDEF_STYLE == 'N' 851 typedef union { 852 struct { 853 uint32_t CHID0:1; /**< bit: 0 Counter Event on Channel 0 */ 854 uint32_t CHID1:1; /**< bit: 1 Counter Event on Channel 1 */ 855 uint32_t CHID2:1; /**< bit: 2 Counter Event on Channel 2 */ 856 uint32_t CHID3:1; /**< bit: 3 Counter Event on Channel 3 */ 857 uint32_t :12; /**< bit: 4..15 Reserved */ 858 uint32_t FCHID0:1; /**< bit: 16 Fault Protection Trigger on Channel 0 */ 859 uint32_t FCHID1:1; /**< bit: 17 Fault Protection Trigger on Channel 1 */ 860 uint32_t FCHID2:1; /**< bit: 18 Fault Protection Trigger on Channel 2 */ 861 uint32_t FCHID3:1; /**< bit: 19 Fault Protection Trigger on Channel 3 */ 862 uint32_t :12; /**< bit: 20..31 Reserved */ 863 } bit; /**< Structure used for bit access */ 864 struct { 865 uint32_t CHID:4; /**< bit: 0..3 Counter Event on Channel x */ 866 uint32_t :12; /**< bit: 4..15 Reserved */ 867 uint32_t FCHID:4; /**< bit: 16..19 Fault Protection Trigger on Channel 3 */ 868 uint32_t :12; /**< bit: 20..31 Reserved */ 869 } vec; /**< Structure used for vec access */ 870 uint32_t reg; /**< Type used for register access */ 871 } PWM_ISR1_Type; 872 #endif 873 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 874 875 #define PWM_ISR1_OFFSET (0x1C) /**< (PWM_ISR1) PWM Interrupt Status Register 1 Offset */ 876 877 #define PWM_ISR1_CHID0_Pos 0 /**< (PWM_ISR1) Counter Event on Channel 0 Position */ 878 #define PWM_ISR1_CHID0_Msk (_U_(0x1) << PWM_ISR1_CHID0_Pos) /**< (PWM_ISR1) Counter Event on Channel 0 Mask */ 879 #define PWM_ISR1_CHID0 PWM_ISR1_CHID0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ISR1_CHID0_Msk instead */ 880 #define PWM_ISR1_CHID1_Pos 1 /**< (PWM_ISR1) Counter Event on Channel 1 Position */ 881 #define PWM_ISR1_CHID1_Msk (_U_(0x1) << PWM_ISR1_CHID1_Pos) /**< (PWM_ISR1) Counter Event on Channel 1 Mask */ 882 #define PWM_ISR1_CHID1 PWM_ISR1_CHID1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ISR1_CHID1_Msk instead */ 883 #define PWM_ISR1_CHID2_Pos 2 /**< (PWM_ISR1) Counter Event on Channel 2 Position */ 884 #define PWM_ISR1_CHID2_Msk (_U_(0x1) << PWM_ISR1_CHID2_Pos) /**< (PWM_ISR1) Counter Event on Channel 2 Mask */ 885 #define PWM_ISR1_CHID2 PWM_ISR1_CHID2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ISR1_CHID2_Msk instead */ 886 #define PWM_ISR1_CHID3_Pos 3 /**< (PWM_ISR1) Counter Event on Channel 3 Position */ 887 #define PWM_ISR1_CHID3_Msk (_U_(0x1) << PWM_ISR1_CHID3_Pos) /**< (PWM_ISR1) Counter Event on Channel 3 Mask */ 888 #define PWM_ISR1_CHID3 PWM_ISR1_CHID3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ISR1_CHID3_Msk instead */ 889 #define PWM_ISR1_FCHID0_Pos 16 /**< (PWM_ISR1) Fault Protection Trigger on Channel 0 Position */ 890 #define PWM_ISR1_FCHID0_Msk (_U_(0x1) << PWM_ISR1_FCHID0_Pos) /**< (PWM_ISR1) Fault Protection Trigger on Channel 0 Mask */ 891 #define PWM_ISR1_FCHID0 PWM_ISR1_FCHID0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ISR1_FCHID0_Msk instead */ 892 #define PWM_ISR1_FCHID1_Pos 17 /**< (PWM_ISR1) Fault Protection Trigger on Channel 1 Position */ 893 #define PWM_ISR1_FCHID1_Msk (_U_(0x1) << PWM_ISR1_FCHID1_Pos) /**< (PWM_ISR1) Fault Protection Trigger on Channel 1 Mask */ 894 #define PWM_ISR1_FCHID1 PWM_ISR1_FCHID1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ISR1_FCHID1_Msk instead */ 895 #define PWM_ISR1_FCHID2_Pos 18 /**< (PWM_ISR1) Fault Protection Trigger on Channel 2 Position */ 896 #define PWM_ISR1_FCHID2_Msk (_U_(0x1) << PWM_ISR1_FCHID2_Pos) /**< (PWM_ISR1) Fault Protection Trigger on Channel 2 Mask */ 897 #define PWM_ISR1_FCHID2 PWM_ISR1_FCHID2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ISR1_FCHID2_Msk instead */ 898 #define PWM_ISR1_FCHID3_Pos 19 /**< (PWM_ISR1) Fault Protection Trigger on Channel 3 Position */ 899 #define PWM_ISR1_FCHID3_Msk (_U_(0x1) << PWM_ISR1_FCHID3_Pos) /**< (PWM_ISR1) Fault Protection Trigger on Channel 3 Mask */ 900 #define PWM_ISR1_FCHID3 PWM_ISR1_FCHID3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ISR1_FCHID3_Msk instead */ 901 #define PWM_ISR1_MASK _U_(0xF000F) /**< \deprecated (PWM_ISR1) Register MASK (Use PWM_ISR1_Msk instead) */ 902 #define PWM_ISR1_Msk _U_(0xF000F) /**< (PWM_ISR1) Register Mask */ 903 904 #define PWM_ISR1_CHID_Pos 0 /**< (PWM_ISR1 Position) Counter Event on Channel x */ 905 #define PWM_ISR1_CHID_Msk (_U_(0xF) << PWM_ISR1_CHID_Pos) /**< (PWM_ISR1 Mask) CHID */ 906 #define PWM_ISR1_CHID(value) (PWM_ISR1_CHID_Msk & ((value) << PWM_ISR1_CHID_Pos)) 907 #define PWM_ISR1_FCHID_Pos 16 /**< (PWM_ISR1 Position) Fault Protection Trigger on Channel 3 */ 908 #define PWM_ISR1_FCHID_Msk (_U_(0xF) << PWM_ISR1_FCHID_Pos) /**< (PWM_ISR1 Mask) FCHID */ 909 #define PWM_ISR1_FCHID(value) (PWM_ISR1_FCHID_Msk & ((value) << PWM_ISR1_FCHID_Pos)) 910 911 /* -------- PWM_SCM : (PWM Offset: 0x20) (R/W 32) PWM Sync Channels Mode Register -------- */ 912 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 913 #if COMPONENT_TYPEDEF_STYLE == 'N' 914 typedef union { 915 struct { 916 uint32_t SYNC0:1; /**< bit: 0 Synchronous Channel 0 */ 917 uint32_t SYNC1:1; /**< bit: 1 Synchronous Channel 1 */ 918 uint32_t SYNC2:1; /**< bit: 2 Synchronous Channel 2 */ 919 uint32_t SYNC3:1; /**< bit: 3 Synchronous Channel 3 */ 920 uint32_t :12; /**< bit: 4..15 Reserved */ 921 uint32_t UPDM:2; /**< bit: 16..17 Synchronous Channels Update Mode */ 922 uint32_t :2; /**< bit: 18..19 Reserved */ 923 uint32_t PTRM:1; /**< bit: 20 DMA Controller Transfer Request Mode */ 924 uint32_t PTRCS:3; /**< bit: 21..23 DMA Controller Transfer Request Comparison Selection */ 925 uint32_t :8; /**< bit: 24..31 Reserved */ 926 } bit; /**< Structure used for bit access */ 927 struct { 928 uint32_t SYNC:4; /**< bit: 0..3 Synchronous Channel x */ 929 uint32_t :28; /**< bit: 4..31 Reserved */ 930 } vec; /**< Structure used for vec access */ 931 uint32_t reg; /**< Type used for register access */ 932 } PWM_SCM_Type; 933 #endif 934 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 935 936 #define PWM_SCM_OFFSET (0x20) /**< (PWM_SCM) PWM Sync Channels Mode Register Offset */ 937 938 #define PWM_SCM_SYNC0_Pos 0 /**< (PWM_SCM) Synchronous Channel 0 Position */ 939 #define PWM_SCM_SYNC0_Msk (_U_(0x1) << PWM_SCM_SYNC0_Pos) /**< (PWM_SCM) Synchronous Channel 0 Mask */ 940 #define PWM_SCM_SYNC0 PWM_SCM_SYNC0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_SCM_SYNC0_Msk instead */ 941 #define PWM_SCM_SYNC1_Pos 1 /**< (PWM_SCM) Synchronous Channel 1 Position */ 942 #define PWM_SCM_SYNC1_Msk (_U_(0x1) << PWM_SCM_SYNC1_Pos) /**< (PWM_SCM) Synchronous Channel 1 Mask */ 943 #define PWM_SCM_SYNC1 PWM_SCM_SYNC1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_SCM_SYNC1_Msk instead */ 944 #define PWM_SCM_SYNC2_Pos 2 /**< (PWM_SCM) Synchronous Channel 2 Position */ 945 #define PWM_SCM_SYNC2_Msk (_U_(0x1) << PWM_SCM_SYNC2_Pos) /**< (PWM_SCM) Synchronous Channel 2 Mask */ 946 #define PWM_SCM_SYNC2 PWM_SCM_SYNC2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_SCM_SYNC2_Msk instead */ 947 #define PWM_SCM_SYNC3_Pos 3 /**< (PWM_SCM) Synchronous Channel 3 Position */ 948 #define PWM_SCM_SYNC3_Msk (_U_(0x1) << PWM_SCM_SYNC3_Pos) /**< (PWM_SCM) Synchronous Channel 3 Mask */ 949 #define PWM_SCM_SYNC3 PWM_SCM_SYNC3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_SCM_SYNC3_Msk instead */ 950 #define PWM_SCM_UPDM_Pos 16 /**< (PWM_SCM) Synchronous Channels Update Mode Position */ 951 #define PWM_SCM_UPDM_Msk (_U_(0x3) << PWM_SCM_UPDM_Pos) /**< (PWM_SCM) Synchronous Channels Update Mode Mask */ 952 #define PWM_SCM_UPDM(value) (PWM_SCM_UPDM_Msk & ((value) << PWM_SCM_UPDM_Pos)) 953 #define PWM_SCM_UPDM_MODE0_Val _U_(0x0) /**< (PWM_SCM) Manual write of double buffer registers and manual update of synchronous channels */ 954 #define PWM_SCM_UPDM_MODE1_Val _U_(0x1) /**< (PWM_SCM) Manual write of double buffer registers and automatic update of synchronous channels */ 955 #define PWM_SCM_UPDM_MODE2_Val _U_(0x2) /**< (PWM_SCM) Automatic write of duty-cycle update registers by the DMA Controller and automatic update of synchronous channels */ 956 #define PWM_SCM_UPDM_MODE0 (PWM_SCM_UPDM_MODE0_Val << PWM_SCM_UPDM_Pos) /**< (PWM_SCM) Manual write of double buffer registers and manual update of synchronous channels Position */ 957 #define PWM_SCM_UPDM_MODE1 (PWM_SCM_UPDM_MODE1_Val << PWM_SCM_UPDM_Pos) /**< (PWM_SCM) Manual write of double buffer registers and automatic update of synchronous channels Position */ 958 #define PWM_SCM_UPDM_MODE2 (PWM_SCM_UPDM_MODE2_Val << PWM_SCM_UPDM_Pos) /**< (PWM_SCM) Automatic write of duty-cycle update registers by the DMA Controller and automatic update of synchronous channels Position */ 959 #define PWM_SCM_PTRM_Pos 20 /**< (PWM_SCM) DMA Controller Transfer Request Mode Position */ 960 #define PWM_SCM_PTRM_Msk (_U_(0x1) << PWM_SCM_PTRM_Pos) /**< (PWM_SCM) DMA Controller Transfer Request Mode Mask */ 961 #define PWM_SCM_PTRM PWM_SCM_PTRM_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_SCM_PTRM_Msk instead */ 962 #define PWM_SCM_PTRCS_Pos 21 /**< (PWM_SCM) DMA Controller Transfer Request Comparison Selection Position */ 963 #define PWM_SCM_PTRCS_Msk (_U_(0x7) << PWM_SCM_PTRCS_Pos) /**< (PWM_SCM) DMA Controller Transfer Request Comparison Selection Mask */ 964 #define PWM_SCM_PTRCS(value) (PWM_SCM_PTRCS_Msk & ((value) << PWM_SCM_PTRCS_Pos)) 965 #define PWM_SCM_MASK _U_(0xF3000F) /**< \deprecated (PWM_SCM) Register MASK (Use PWM_SCM_Msk instead) */ 966 #define PWM_SCM_Msk _U_(0xF3000F) /**< (PWM_SCM) Register Mask */ 967 968 #define PWM_SCM_SYNC_Pos 0 /**< (PWM_SCM Position) Synchronous Channel x */ 969 #define PWM_SCM_SYNC_Msk (_U_(0xF) << PWM_SCM_SYNC_Pos) /**< (PWM_SCM Mask) SYNC */ 970 #define PWM_SCM_SYNC(value) (PWM_SCM_SYNC_Msk & ((value) << PWM_SCM_SYNC_Pos)) 971 972 /* -------- PWM_DMAR : (PWM Offset: 0x24) (/W 32) PWM DMA Register -------- */ 973 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 974 #if COMPONENT_TYPEDEF_STYLE == 'N' 975 typedef union { 976 struct { 977 uint32_t DMADUTY:24; /**< bit: 0..23 Duty-Cycle Holding Register for DMA Access */ 978 uint32_t :8; /**< bit: 24..31 Reserved */ 979 } bit; /**< Structure used for bit access */ 980 uint32_t reg; /**< Type used for register access */ 981 } PWM_DMAR_Type; 982 #endif 983 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 984 985 #define PWM_DMAR_OFFSET (0x24) /**< (PWM_DMAR) PWM DMA Register Offset */ 986 987 #define PWM_DMAR_DMADUTY_Pos 0 /**< (PWM_DMAR) Duty-Cycle Holding Register for DMA Access Position */ 988 #define PWM_DMAR_DMADUTY_Msk (_U_(0xFFFFFF) << PWM_DMAR_DMADUTY_Pos) /**< (PWM_DMAR) Duty-Cycle Holding Register for DMA Access Mask */ 989 #define PWM_DMAR_DMADUTY(value) (PWM_DMAR_DMADUTY_Msk & ((value) << PWM_DMAR_DMADUTY_Pos)) 990 #define PWM_DMAR_MASK _U_(0xFFFFFF) /**< \deprecated (PWM_DMAR) Register MASK (Use PWM_DMAR_Msk instead) */ 991 #define PWM_DMAR_Msk _U_(0xFFFFFF) /**< (PWM_DMAR) Register Mask */ 992 993 994 /* -------- PWM_SCUC : (PWM Offset: 0x28) (R/W 32) PWM Sync Channels Update Control Register -------- */ 995 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 996 #if COMPONENT_TYPEDEF_STYLE == 'N' 997 typedef union { 998 struct { 999 uint32_t UPDULOCK:1; /**< bit: 0 Synchronous Channels Update Unlock */ 1000 uint32_t :31; /**< bit: 1..31 Reserved */ 1001 } bit; /**< Structure used for bit access */ 1002 uint32_t reg; /**< Type used for register access */ 1003 } PWM_SCUC_Type; 1004 #endif 1005 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 1006 1007 #define PWM_SCUC_OFFSET (0x28) /**< (PWM_SCUC) PWM Sync Channels Update Control Register Offset */ 1008 1009 #define PWM_SCUC_UPDULOCK_Pos 0 /**< (PWM_SCUC) Synchronous Channels Update Unlock Position */ 1010 #define PWM_SCUC_UPDULOCK_Msk (_U_(0x1) << PWM_SCUC_UPDULOCK_Pos) /**< (PWM_SCUC) Synchronous Channels Update Unlock Mask */ 1011 #define PWM_SCUC_UPDULOCK PWM_SCUC_UPDULOCK_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_SCUC_UPDULOCK_Msk instead */ 1012 #define PWM_SCUC_MASK _U_(0x01) /**< \deprecated (PWM_SCUC) Register MASK (Use PWM_SCUC_Msk instead) */ 1013 #define PWM_SCUC_Msk _U_(0x01) /**< (PWM_SCUC) Register Mask */ 1014 1015 1016 /* -------- PWM_SCUP : (PWM Offset: 0x2c) (R/W 32) PWM Sync Channels Update Period Register -------- */ 1017 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 1018 #if COMPONENT_TYPEDEF_STYLE == 'N' 1019 typedef union { 1020 struct { 1021 uint32_t UPR:4; /**< bit: 0..3 Update Period */ 1022 uint32_t UPRCNT:4; /**< bit: 4..7 Update Period Counter */ 1023 uint32_t :24; /**< bit: 8..31 Reserved */ 1024 } bit; /**< Structure used for bit access */ 1025 uint32_t reg; /**< Type used for register access */ 1026 } PWM_SCUP_Type; 1027 #endif 1028 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 1029 1030 #define PWM_SCUP_OFFSET (0x2C) /**< (PWM_SCUP) PWM Sync Channels Update Period Register Offset */ 1031 1032 #define PWM_SCUP_UPR_Pos 0 /**< (PWM_SCUP) Update Period Position */ 1033 #define PWM_SCUP_UPR_Msk (_U_(0xF) << PWM_SCUP_UPR_Pos) /**< (PWM_SCUP) Update Period Mask */ 1034 #define PWM_SCUP_UPR(value) (PWM_SCUP_UPR_Msk & ((value) << PWM_SCUP_UPR_Pos)) 1035 #define PWM_SCUP_UPRCNT_Pos 4 /**< (PWM_SCUP) Update Period Counter Position */ 1036 #define PWM_SCUP_UPRCNT_Msk (_U_(0xF) << PWM_SCUP_UPRCNT_Pos) /**< (PWM_SCUP) Update Period Counter Mask */ 1037 #define PWM_SCUP_UPRCNT(value) (PWM_SCUP_UPRCNT_Msk & ((value) << PWM_SCUP_UPRCNT_Pos)) 1038 #define PWM_SCUP_MASK _U_(0xFF) /**< \deprecated (PWM_SCUP) Register MASK (Use PWM_SCUP_Msk instead) */ 1039 #define PWM_SCUP_Msk _U_(0xFF) /**< (PWM_SCUP) Register Mask */ 1040 1041 1042 /* -------- PWM_SCUPUPD : (PWM Offset: 0x30) (/W 32) PWM Sync Channels Update Period Update Register -------- */ 1043 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 1044 #if COMPONENT_TYPEDEF_STYLE == 'N' 1045 typedef union { 1046 struct { 1047 uint32_t UPRUPD:4; /**< bit: 0..3 Update Period Update */ 1048 uint32_t :28; /**< bit: 4..31 Reserved */ 1049 } bit; /**< Structure used for bit access */ 1050 uint32_t reg; /**< Type used for register access */ 1051 } PWM_SCUPUPD_Type; 1052 #endif 1053 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 1054 1055 #define PWM_SCUPUPD_OFFSET (0x30) /**< (PWM_SCUPUPD) PWM Sync Channels Update Period Update Register Offset */ 1056 1057 #define PWM_SCUPUPD_UPRUPD_Pos 0 /**< (PWM_SCUPUPD) Update Period Update Position */ 1058 #define PWM_SCUPUPD_UPRUPD_Msk (_U_(0xF) << PWM_SCUPUPD_UPRUPD_Pos) /**< (PWM_SCUPUPD) Update Period Update Mask */ 1059 #define PWM_SCUPUPD_UPRUPD(value) (PWM_SCUPUPD_UPRUPD_Msk & ((value) << PWM_SCUPUPD_UPRUPD_Pos)) 1060 #define PWM_SCUPUPD_MASK _U_(0x0F) /**< \deprecated (PWM_SCUPUPD) Register MASK (Use PWM_SCUPUPD_Msk instead) */ 1061 #define PWM_SCUPUPD_Msk _U_(0x0F) /**< (PWM_SCUPUPD) Register Mask */ 1062 1063 1064 /* -------- PWM_IER2 : (PWM Offset: 0x34) (/W 32) PWM Interrupt Enable Register 2 -------- */ 1065 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 1066 #if COMPONENT_TYPEDEF_STYLE == 'N' 1067 typedef union { 1068 struct { 1069 uint32_t WRDY:1; /**< bit: 0 Write Ready for Synchronous Channels Update Interrupt Enable */ 1070 uint32_t :2; /**< bit: 1..2 Reserved */ 1071 uint32_t UNRE:1; /**< bit: 3 Synchronous Channels Update Underrun Error Interrupt Enable */ 1072 uint32_t :4; /**< bit: 4..7 Reserved */ 1073 uint32_t CMPM0:1; /**< bit: 8 Comparison 0 Match Interrupt Enable */ 1074 uint32_t CMPM1:1; /**< bit: 9 Comparison 1 Match Interrupt Enable */ 1075 uint32_t CMPM2:1; /**< bit: 10 Comparison 2 Match Interrupt Enable */ 1076 uint32_t CMPM3:1; /**< bit: 11 Comparison 3 Match Interrupt Enable */ 1077 uint32_t CMPM4:1; /**< bit: 12 Comparison 4 Match Interrupt Enable */ 1078 uint32_t CMPM5:1; /**< bit: 13 Comparison 5 Match Interrupt Enable */ 1079 uint32_t CMPM6:1; /**< bit: 14 Comparison 6 Match Interrupt Enable */ 1080 uint32_t CMPM7:1; /**< bit: 15 Comparison 7 Match Interrupt Enable */ 1081 uint32_t CMPU0:1; /**< bit: 16 Comparison 0 Update Interrupt Enable */ 1082 uint32_t CMPU1:1; /**< bit: 17 Comparison 1 Update Interrupt Enable */ 1083 uint32_t CMPU2:1; /**< bit: 18 Comparison 2 Update Interrupt Enable */ 1084 uint32_t CMPU3:1; /**< bit: 19 Comparison 3 Update Interrupt Enable */ 1085 uint32_t CMPU4:1; /**< bit: 20 Comparison 4 Update Interrupt Enable */ 1086 uint32_t CMPU5:1; /**< bit: 21 Comparison 5 Update Interrupt Enable */ 1087 uint32_t CMPU6:1; /**< bit: 22 Comparison 6 Update Interrupt Enable */ 1088 uint32_t CMPU7:1; /**< bit: 23 Comparison 7 Update Interrupt Enable */ 1089 uint32_t :8; /**< bit: 24..31 Reserved */ 1090 } bit; /**< Structure used for bit access */ 1091 struct { 1092 uint32_t :8; /**< bit: 0..7 Reserved */ 1093 uint32_t CMPM:8; /**< bit: 8..15 Comparison x Match Interrupt Enable */ 1094 uint32_t CMPU:8; /**< bit: 16..23 Comparison 7 Update Interrupt Enable */ 1095 uint32_t :8; /**< bit: 24..31 Reserved */ 1096 } vec; /**< Structure used for vec access */ 1097 uint32_t reg; /**< Type used for register access */ 1098 } PWM_IER2_Type; 1099 #endif 1100 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 1101 1102 #define PWM_IER2_OFFSET (0x34) /**< (PWM_IER2) PWM Interrupt Enable Register 2 Offset */ 1103 1104 #define PWM_IER2_WRDY_Pos 0 /**< (PWM_IER2) Write Ready for Synchronous Channels Update Interrupt Enable Position */ 1105 #define PWM_IER2_WRDY_Msk (_U_(0x1) << PWM_IER2_WRDY_Pos) /**< (PWM_IER2) Write Ready for Synchronous Channels Update Interrupt Enable Mask */ 1106 #define PWM_IER2_WRDY PWM_IER2_WRDY_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IER2_WRDY_Msk instead */ 1107 #define PWM_IER2_UNRE_Pos 3 /**< (PWM_IER2) Synchronous Channels Update Underrun Error Interrupt Enable Position */ 1108 #define PWM_IER2_UNRE_Msk (_U_(0x1) << PWM_IER2_UNRE_Pos) /**< (PWM_IER2) Synchronous Channels Update Underrun Error Interrupt Enable Mask */ 1109 #define PWM_IER2_UNRE PWM_IER2_UNRE_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IER2_UNRE_Msk instead */ 1110 #define PWM_IER2_CMPM0_Pos 8 /**< (PWM_IER2) Comparison 0 Match Interrupt Enable Position */ 1111 #define PWM_IER2_CMPM0_Msk (_U_(0x1) << PWM_IER2_CMPM0_Pos) /**< (PWM_IER2) Comparison 0 Match Interrupt Enable Mask */ 1112 #define PWM_IER2_CMPM0 PWM_IER2_CMPM0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IER2_CMPM0_Msk instead */ 1113 #define PWM_IER2_CMPM1_Pos 9 /**< (PWM_IER2) Comparison 1 Match Interrupt Enable Position */ 1114 #define PWM_IER2_CMPM1_Msk (_U_(0x1) << PWM_IER2_CMPM1_Pos) /**< (PWM_IER2) Comparison 1 Match Interrupt Enable Mask */ 1115 #define PWM_IER2_CMPM1 PWM_IER2_CMPM1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IER2_CMPM1_Msk instead */ 1116 #define PWM_IER2_CMPM2_Pos 10 /**< (PWM_IER2) Comparison 2 Match Interrupt Enable Position */ 1117 #define PWM_IER2_CMPM2_Msk (_U_(0x1) << PWM_IER2_CMPM2_Pos) /**< (PWM_IER2) Comparison 2 Match Interrupt Enable Mask */ 1118 #define PWM_IER2_CMPM2 PWM_IER2_CMPM2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IER2_CMPM2_Msk instead */ 1119 #define PWM_IER2_CMPM3_Pos 11 /**< (PWM_IER2) Comparison 3 Match Interrupt Enable Position */ 1120 #define PWM_IER2_CMPM3_Msk (_U_(0x1) << PWM_IER2_CMPM3_Pos) /**< (PWM_IER2) Comparison 3 Match Interrupt Enable Mask */ 1121 #define PWM_IER2_CMPM3 PWM_IER2_CMPM3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IER2_CMPM3_Msk instead */ 1122 #define PWM_IER2_CMPM4_Pos 12 /**< (PWM_IER2) Comparison 4 Match Interrupt Enable Position */ 1123 #define PWM_IER2_CMPM4_Msk (_U_(0x1) << PWM_IER2_CMPM4_Pos) /**< (PWM_IER2) Comparison 4 Match Interrupt Enable Mask */ 1124 #define PWM_IER2_CMPM4 PWM_IER2_CMPM4_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IER2_CMPM4_Msk instead */ 1125 #define PWM_IER2_CMPM5_Pos 13 /**< (PWM_IER2) Comparison 5 Match Interrupt Enable Position */ 1126 #define PWM_IER2_CMPM5_Msk (_U_(0x1) << PWM_IER2_CMPM5_Pos) /**< (PWM_IER2) Comparison 5 Match Interrupt Enable Mask */ 1127 #define PWM_IER2_CMPM5 PWM_IER2_CMPM5_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IER2_CMPM5_Msk instead */ 1128 #define PWM_IER2_CMPM6_Pos 14 /**< (PWM_IER2) Comparison 6 Match Interrupt Enable Position */ 1129 #define PWM_IER2_CMPM6_Msk (_U_(0x1) << PWM_IER2_CMPM6_Pos) /**< (PWM_IER2) Comparison 6 Match Interrupt Enable Mask */ 1130 #define PWM_IER2_CMPM6 PWM_IER2_CMPM6_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IER2_CMPM6_Msk instead */ 1131 #define PWM_IER2_CMPM7_Pos 15 /**< (PWM_IER2) Comparison 7 Match Interrupt Enable Position */ 1132 #define PWM_IER2_CMPM7_Msk (_U_(0x1) << PWM_IER2_CMPM7_Pos) /**< (PWM_IER2) Comparison 7 Match Interrupt Enable Mask */ 1133 #define PWM_IER2_CMPM7 PWM_IER2_CMPM7_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IER2_CMPM7_Msk instead */ 1134 #define PWM_IER2_CMPU0_Pos 16 /**< (PWM_IER2) Comparison 0 Update Interrupt Enable Position */ 1135 #define PWM_IER2_CMPU0_Msk (_U_(0x1) << PWM_IER2_CMPU0_Pos) /**< (PWM_IER2) Comparison 0 Update Interrupt Enable Mask */ 1136 #define PWM_IER2_CMPU0 PWM_IER2_CMPU0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IER2_CMPU0_Msk instead */ 1137 #define PWM_IER2_CMPU1_Pos 17 /**< (PWM_IER2) Comparison 1 Update Interrupt Enable Position */ 1138 #define PWM_IER2_CMPU1_Msk (_U_(0x1) << PWM_IER2_CMPU1_Pos) /**< (PWM_IER2) Comparison 1 Update Interrupt Enable Mask */ 1139 #define PWM_IER2_CMPU1 PWM_IER2_CMPU1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IER2_CMPU1_Msk instead */ 1140 #define PWM_IER2_CMPU2_Pos 18 /**< (PWM_IER2) Comparison 2 Update Interrupt Enable Position */ 1141 #define PWM_IER2_CMPU2_Msk (_U_(0x1) << PWM_IER2_CMPU2_Pos) /**< (PWM_IER2) Comparison 2 Update Interrupt Enable Mask */ 1142 #define PWM_IER2_CMPU2 PWM_IER2_CMPU2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IER2_CMPU2_Msk instead */ 1143 #define PWM_IER2_CMPU3_Pos 19 /**< (PWM_IER2) Comparison 3 Update Interrupt Enable Position */ 1144 #define PWM_IER2_CMPU3_Msk (_U_(0x1) << PWM_IER2_CMPU3_Pos) /**< (PWM_IER2) Comparison 3 Update Interrupt Enable Mask */ 1145 #define PWM_IER2_CMPU3 PWM_IER2_CMPU3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IER2_CMPU3_Msk instead */ 1146 #define PWM_IER2_CMPU4_Pos 20 /**< (PWM_IER2) Comparison 4 Update Interrupt Enable Position */ 1147 #define PWM_IER2_CMPU4_Msk (_U_(0x1) << PWM_IER2_CMPU4_Pos) /**< (PWM_IER2) Comparison 4 Update Interrupt Enable Mask */ 1148 #define PWM_IER2_CMPU4 PWM_IER2_CMPU4_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IER2_CMPU4_Msk instead */ 1149 #define PWM_IER2_CMPU5_Pos 21 /**< (PWM_IER2) Comparison 5 Update Interrupt Enable Position */ 1150 #define PWM_IER2_CMPU5_Msk (_U_(0x1) << PWM_IER2_CMPU5_Pos) /**< (PWM_IER2) Comparison 5 Update Interrupt Enable Mask */ 1151 #define PWM_IER2_CMPU5 PWM_IER2_CMPU5_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IER2_CMPU5_Msk instead */ 1152 #define PWM_IER2_CMPU6_Pos 22 /**< (PWM_IER2) Comparison 6 Update Interrupt Enable Position */ 1153 #define PWM_IER2_CMPU6_Msk (_U_(0x1) << PWM_IER2_CMPU6_Pos) /**< (PWM_IER2) Comparison 6 Update Interrupt Enable Mask */ 1154 #define PWM_IER2_CMPU6 PWM_IER2_CMPU6_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IER2_CMPU6_Msk instead */ 1155 #define PWM_IER2_CMPU7_Pos 23 /**< (PWM_IER2) Comparison 7 Update Interrupt Enable Position */ 1156 #define PWM_IER2_CMPU7_Msk (_U_(0x1) << PWM_IER2_CMPU7_Pos) /**< (PWM_IER2) Comparison 7 Update Interrupt Enable Mask */ 1157 #define PWM_IER2_CMPU7 PWM_IER2_CMPU7_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IER2_CMPU7_Msk instead */ 1158 #define PWM_IER2_MASK _U_(0xFFFF09) /**< \deprecated (PWM_IER2) Register MASK (Use PWM_IER2_Msk instead) */ 1159 #define PWM_IER2_Msk _U_(0xFFFF09) /**< (PWM_IER2) Register Mask */ 1160 1161 #define PWM_IER2_CMPM_Pos 8 /**< (PWM_IER2 Position) Comparison x Match Interrupt Enable */ 1162 #define PWM_IER2_CMPM_Msk (_U_(0xFF) << PWM_IER2_CMPM_Pos) /**< (PWM_IER2 Mask) CMPM */ 1163 #define PWM_IER2_CMPM(value) (PWM_IER2_CMPM_Msk & ((value) << PWM_IER2_CMPM_Pos)) 1164 #define PWM_IER2_CMPU_Pos 16 /**< (PWM_IER2 Position) Comparison 7 Update Interrupt Enable */ 1165 #define PWM_IER2_CMPU_Msk (_U_(0xFF) << PWM_IER2_CMPU_Pos) /**< (PWM_IER2 Mask) CMPU */ 1166 #define PWM_IER2_CMPU(value) (PWM_IER2_CMPU_Msk & ((value) << PWM_IER2_CMPU_Pos)) 1167 1168 /* -------- PWM_IDR2 : (PWM Offset: 0x38) (/W 32) PWM Interrupt Disable Register 2 -------- */ 1169 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 1170 #if COMPONENT_TYPEDEF_STYLE == 'N' 1171 typedef union { 1172 struct { 1173 uint32_t WRDY:1; /**< bit: 0 Write Ready for Synchronous Channels Update Interrupt Disable */ 1174 uint32_t :2; /**< bit: 1..2 Reserved */ 1175 uint32_t UNRE:1; /**< bit: 3 Synchronous Channels Update Underrun Error Interrupt Disable */ 1176 uint32_t :4; /**< bit: 4..7 Reserved */ 1177 uint32_t CMPM0:1; /**< bit: 8 Comparison 0 Match Interrupt Disable */ 1178 uint32_t CMPM1:1; /**< bit: 9 Comparison 1 Match Interrupt Disable */ 1179 uint32_t CMPM2:1; /**< bit: 10 Comparison 2 Match Interrupt Disable */ 1180 uint32_t CMPM3:1; /**< bit: 11 Comparison 3 Match Interrupt Disable */ 1181 uint32_t CMPM4:1; /**< bit: 12 Comparison 4 Match Interrupt Disable */ 1182 uint32_t CMPM5:1; /**< bit: 13 Comparison 5 Match Interrupt Disable */ 1183 uint32_t CMPM6:1; /**< bit: 14 Comparison 6 Match Interrupt Disable */ 1184 uint32_t CMPM7:1; /**< bit: 15 Comparison 7 Match Interrupt Disable */ 1185 uint32_t CMPU0:1; /**< bit: 16 Comparison 0 Update Interrupt Disable */ 1186 uint32_t CMPU1:1; /**< bit: 17 Comparison 1 Update Interrupt Disable */ 1187 uint32_t CMPU2:1; /**< bit: 18 Comparison 2 Update Interrupt Disable */ 1188 uint32_t CMPU3:1; /**< bit: 19 Comparison 3 Update Interrupt Disable */ 1189 uint32_t CMPU4:1; /**< bit: 20 Comparison 4 Update Interrupt Disable */ 1190 uint32_t CMPU5:1; /**< bit: 21 Comparison 5 Update Interrupt Disable */ 1191 uint32_t CMPU6:1; /**< bit: 22 Comparison 6 Update Interrupt Disable */ 1192 uint32_t CMPU7:1; /**< bit: 23 Comparison 7 Update Interrupt Disable */ 1193 uint32_t :8; /**< bit: 24..31 Reserved */ 1194 } bit; /**< Structure used for bit access */ 1195 struct { 1196 uint32_t :8; /**< bit: 0..7 Reserved */ 1197 uint32_t CMPM:8; /**< bit: 8..15 Comparison x Match Interrupt Disable */ 1198 uint32_t CMPU:8; /**< bit: 16..23 Comparison 7 Update Interrupt Disable */ 1199 uint32_t :8; /**< bit: 24..31 Reserved */ 1200 } vec; /**< Structure used for vec access */ 1201 uint32_t reg; /**< Type used for register access */ 1202 } PWM_IDR2_Type; 1203 #endif 1204 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 1205 1206 #define PWM_IDR2_OFFSET (0x38) /**< (PWM_IDR2) PWM Interrupt Disable Register 2 Offset */ 1207 1208 #define PWM_IDR2_WRDY_Pos 0 /**< (PWM_IDR2) Write Ready for Synchronous Channels Update Interrupt Disable Position */ 1209 #define PWM_IDR2_WRDY_Msk (_U_(0x1) << PWM_IDR2_WRDY_Pos) /**< (PWM_IDR2) Write Ready for Synchronous Channels Update Interrupt Disable Mask */ 1210 #define PWM_IDR2_WRDY PWM_IDR2_WRDY_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IDR2_WRDY_Msk instead */ 1211 #define PWM_IDR2_UNRE_Pos 3 /**< (PWM_IDR2) Synchronous Channels Update Underrun Error Interrupt Disable Position */ 1212 #define PWM_IDR2_UNRE_Msk (_U_(0x1) << PWM_IDR2_UNRE_Pos) /**< (PWM_IDR2) Synchronous Channels Update Underrun Error Interrupt Disable Mask */ 1213 #define PWM_IDR2_UNRE PWM_IDR2_UNRE_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IDR2_UNRE_Msk instead */ 1214 #define PWM_IDR2_CMPM0_Pos 8 /**< (PWM_IDR2) Comparison 0 Match Interrupt Disable Position */ 1215 #define PWM_IDR2_CMPM0_Msk (_U_(0x1) << PWM_IDR2_CMPM0_Pos) /**< (PWM_IDR2) Comparison 0 Match Interrupt Disable Mask */ 1216 #define PWM_IDR2_CMPM0 PWM_IDR2_CMPM0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IDR2_CMPM0_Msk instead */ 1217 #define PWM_IDR2_CMPM1_Pos 9 /**< (PWM_IDR2) Comparison 1 Match Interrupt Disable Position */ 1218 #define PWM_IDR2_CMPM1_Msk (_U_(0x1) << PWM_IDR2_CMPM1_Pos) /**< (PWM_IDR2) Comparison 1 Match Interrupt Disable Mask */ 1219 #define PWM_IDR2_CMPM1 PWM_IDR2_CMPM1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IDR2_CMPM1_Msk instead */ 1220 #define PWM_IDR2_CMPM2_Pos 10 /**< (PWM_IDR2) Comparison 2 Match Interrupt Disable Position */ 1221 #define PWM_IDR2_CMPM2_Msk (_U_(0x1) << PWM_IDR2_CMPM2_Pos) /**< (PWM_IDR2) Comparison 2 Match Interrupt Disable Mask */ 1222 #define PWM_IDR2_CMPM2 PWM_IDR2_CMPM2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IDR2_CMPM2_Msk instead */ 1223 #define PWM_IDR2_CMPM3_Pos 11 /**< (PWM_IDR2) Comparison 3 Match Interrupt Disable Position */ 1224 #define PWM_IDR2_CMPM3_Msk (_U_(0x1) << PWM_IDR2_CMPM3_Pos) /**< (PWM_IDR2) Comparison 3 Match Interrupt Disable Mask */ 1225 #define PWM_IDR2_CMPM3 PWM_IDR2_CMPM3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IDR2_CMPM3_Msk instead */ 1226 #define PWM_IDR2_CMPM4_Pos 12 /**< (PWM_IDR2) Comparison 4 Match Interrupt Disable Position */ 1227 #define PWM_IDR2_CMPM4_Msk (_U_(0x1) << PWM_IDR2_CMPM4_Pos) /**< (PWM_IDR2) Comparison 4 Match Interrupt Disable Mask */ 1228 #define PWM_IDR2_CMPM4 PWM_IDR2_CMPM4_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IDR2_CMPM4_Msk instead */ 1229 #define PWM_IDR2_CMPM5_Pos 13 /**< (PWM_IDR2) Comparison 5 Match Interrupt Disable Position */ 1230 #define PWM_IDR2_CMPM5_Msk (_U_(0x1) << PWM_IDR2_CMPM5_Pos) /**< (PWM_IDR2) Comparison 5 Match Interrupt Disable Mask */ 1231 #define PWM_IDR2_CMPM5 PWM_IDR2_CMPM5_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IDR2_CMPM5_Msk instead */ 1232 #define PWM_IDR2_CMPM6_Pos 14 /**< (PWM_IDR2) Comparison 6 Match Interrupt Disable Position */ 1233 #define PWM_IDR2_CMPM6_Msk (_U_(0x1) << PWM_IDR2_CMPM6_Pos) /**< (PWM_IDR2) Comparison 6 Match Interrupt Disable Mask */ 1234 #define PWM_IDR2_CMPM6 PWM_IDR2_CMPM6_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IDR2_CMPM6_Msk instead */ 1235 #define PWM_IDR2_CMPM7_Pos 15 /**< (PWM_IDR2) Comparison 7 Match Interrupt Disable Position */ 1236 #define PWM_IDR2_CMPM7_Msk (_U_(0x1) << PWM_IDR2_CMPM7_Pos) /**< (PWM_IDR2) Comparison 7 Match Interrupt Disable Mask */ 1237 #define PWM_IDR2_CMPM7 PWM_IDR2_CMPM7_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IDR2_CMPM7_Msk instead */ 1238 #define PWM_IDR2_CMPU0_Pos 16 /**< (PWM_IDR2) Comparison 0 Update Interrupt Disable Position */ 1239 #define PWM_IDR2_CMPU0_Msk (_U_(0x1) << PWM_IDR2_CMPU0_Pos) /**< (PWM_IDR2) Comparison 0 Update Interrupt Disable Mask */ 1240 #define PWM_IDR2_CMPU0 PWM_IDR2_CMPU0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IDR2_CMPU0_Msk instead */ 1241 #define PWM_IDR2_CMPU1_Pos 17 /**< (PWM_IDR2) Comparison 1 Update Interrupt Disable Position */ 1242 #define PWM_IDR2_CMPU1_Msk (_U_(0x1) << PWM_IDR2_CMPU1_Pos) /**< (PWM_IDR2) Comparison 1 Update Interrupt Disable Mask */ 1243 #define PWM_IDR2_CMPU1 PWM_IDR2_CMPU1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IDR2_CMPU1_Msk instead */ 1244 #define PWM_IDR2_CMPU2_Pos 18 /**< (PWM_IDR2) Comparison 2 Update Interrupt Disable Position */ 1245 #define PWM_IDR2_CMPU2_Msk (_U_(0x1) << PWM_IDR2_CMPU2_Pos) /**< (PWM_IDR2) Comparison 2 Update Interrupt Disable Mask */ 1246 #define PWM_IDR2_CMPU2 PWM_IDR2_CMPU2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IDR2_CMPU2_Msk instead */ 1247 #define PWM_IDR2_CMPU3_Pos 19 /**< (PWM_IDR2) Comparison 3 Update Interrupt Disable Position */ 1248 #define PWM_IDR2_CMPU3_Msk (_U_(0x1) << PWM_IDR2_CMPU3_Pos) /**< (PWM_IDR2) Comparison 3 Update Interrupt Disable Mask */ 1249 #define PWM_IDR2_CMPU3 PWM_IDR2_CMPU3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IDR2_CMPU3_Msk instead */ 1250 #define PWM_IDR2_CMPU4_Pos 20 /**< (PWM_IDR2) Comparison 4 Update Interrupt Disable Position */ 1251 #define PWM_IDR2_CMPU4_Msk (_U_(0x1) << PWM_IDR2_CMPU4_Pos) /**< (PWM_IDR2) Comparison 4 Update Interrupt Disable Mask */ 1252 #define PWM_IDR2_CMPU4 PWM_IDR2_CMPU4_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IDR2_CMPU4_Msk instead */ 1253 #define PWM_IDR2_CMPU5_Pos 21 /**< (PWM_IDR2) Comparison 5 Update Interrupt Disable Position */ 1254 #define PWM_IDR2_CMPU5_Msk (_U_(0x1) << PWM_IDR2_CMPU5_Pos) /**< (PWM_IDR2) Comparison 5 Update Interrupt Disable Mask */ 1255 #define PWM_IDR2_CMPU5 PWM_IDR2_CMPU5_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IDR2_CMPU5_Msk instead */ 1256 #define PWM_IDR2_CMPU6_Pos 22 /**< (PWM_IDR2) Comparison 6 Update Interrupt Disable Position */ 1257 #define PWM_IDR2_CMPU6_Msk (_U_(0x1) << PWM_IDR2_CMPU6_Pos) /**< (PWM_IDR2) Comparison 6 Update Interrupt Disable Mask */ 1258 #define PWM_IDR2_CMPU6 PWM_IDR2_CMPU6_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IDR2_CMPU6_Msk instead */ 1259 #define PWM_IDR2_CMPU7_Pos 23 /**< (PWM_IDR2) Comparison 7 Update Interrupt Disable Position */ 1260 #define PWM_IDR2_CMPU7_Msk (_U_(0x1) << PWM_IDR2_CMPU7_Pos) /**< (PWM_IDR2) Comparison 7 Update Interrupt Disable Mask */ 1261 #define PWM_IDR2_CMPU7 PWM_IDR2_CMPU7_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IDR2_CMPU7_Msk instead */ 1262 #define PWM_IDR2_MASK _U_(0xFFFF09) /**< \deprecated (PWM_IDR2) Register MASK (Use PWM_IDR2_Msk instead) */ 1263 #define PWM_IDR2_Msk _U_(0xFFFF09) /**< (PWM_IDR2) Register Mask */ 1264 1265 #define PWM_IDR2_CMPM_Pos 8 /**< (PWM_IDR2 Position) Comparison x Match Interrupt Disable */ 1266 #define PWM_IDR2_CMPM_Msk (_U_(0xFF) << PWM_IDR2_CMPM_Pos) /**< (PWM_IDR2 Mask) CMPM */ 1267 #define PWM_IDR2_CMPM(value) (PWM_IDR2_CMPM_Msk & ((value) << PWM_IDR2_CMPM_Pos)) 1268 #define PWM_IDR2_CMPU_Pos 16 /**< (PWM_IDR2 Position) Comparison 7 Update Interrupt Disable */ 1269 #define PWM_IDR2_CMPU_Msk (_U_(0xFF) << PWM_IDR2_CMPU_Pos) /**< (PWM_IDR2 Mask) CMPU */ 1270 #define PWM_IDR2_CMPU(value) (PWM_IDR2_CMPU_Msk & ((value) << PWM_IDR2_CMPU_Pos)) 1271 1272 /* -------- PWM_IMR2 : (PWM Offset: 0x3c) (R/ 32) PWM Interrupt Mask Register 2 -------- */ 1273 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 1274 #if COMPONENT_TYPEDEF_STYLE == 'N' 1275 typedef union { 1276 struct { 1277 uint32_t WRDY:1; /**< bit: 0 Write Ready for Synchronous Channels Update Interrupt Mask */ 1278 uint32_t :2; /**< bit: 1..2 Reserved */ 1279 uint32_t UNRE:1; /**< bit: 3 Synchronous Channels Update Underrun Error Interrupt Mask */ 1280 uint32_t :4; /**< bit: 4..7 Reserved */ 1281 uint32_t CMPM0:1; /**< bit: 8 Comparison 0 Match Interrupt Mask */ 1282 uint32_t CMPM1:1; /**< bit: 9 Comparison 1 Match Interrupt Mask */ 1283 uint32_t CMPM2:1; /**< bit: 10 Comparison 2 Match Interrupt Mask */ 1284 uint32_t CMPM3:1; /**< bit: 11 Comparison 3 Match Interrupt Mask */ 1285 uint32_t CMPM4:1; /**< bit: 12 Comparison 4 Match Interrupt Mask */ 1286 uint32_t CMPM5:1; /**< bit: 13 Comparison 5 Match Interrupt Mask */ 1287 uint32_t CMPM6:1; /**< bit: 14 Comparison 6 Match Interrupt Mask */ 1288 uint32_t CMPM7:1; /**< bit: 15 Comparison 7 Match Interrupt Mask */ 1289 uint32_t CMPU0:1; /**< bit: 16 Comparison 0 Update Interrupt Mask */ 1290 uint32_t CMPU1:1; /**< bit: 17 Comparison 1 Update Interrupt Mask */ 1291 uint32_t CMPU2:1; /**< bit: 18 Comparison 2 Update Interrupt Mask */ 1292 uint32_t CMPU3:1; /**< bit: 19 Comparison 3 Update Interrupt Mask */ 1293 uint32_t CMPU4:1; /**< bit: 20 Comparison 4 Update Interrupt Mask */ 1294 uint32_t CMPU5:1; /**< bit: 21 Comparison 5 Update Interrupt Mask */ 1295 uint32_t CMPU6:1; /**< bit: 22 Comparison 6 Update Interrupt Mask */ 1296 uint32_t CMPU7:1; /**< bit: 23 Comparison 7 Update Interrupt Mask */ 1297 uint32_t :8; /**< bit: 24..31 Reserved */ 1298 } bit; /**< Structure used for bit access */ 1299 struct { 1300 uint32_t :8; /**< bit: 0..7 Reserved */ 1301 uint32_t CMPM:8; /**< bit: 8..15 Comparison x Match Interrupt Mask */ 1302 uint32_t CMPU:8; /**< bit: 16..23 Comparison 7 Update Interrupt Mask */ 1303 uint32_t :8; /**< bit: 24..31 Reserved */ 1304 } vec; /**< Structure used for vec access */ 1305 uint32_t reg; /**< Type used for register access */ 1306 } PWM_IMR2_Type; 1307 #endif 1308 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 1309 1310 #define PWM_IMR2_OFFSET (0x3C) /**< (PWM_IMR2) PWM Interrupt Mask Register 2 Offset */ 1311 1312 #define PWM_IMR2_WRDY_Pos 0 /**< (PWM_IMR2) Write Ready for Synchronous Channels Update Interrupt Mask Position */ 1313 #define PWM_IMR2_WRDY_Msk (_U_(0x1) << PWM_IMR2_WRDY_Pos) /**< (PWM_IMR2) Write Ready for Synchronous Channels Update Interrupt Mask Mask */ 1314 #define PWM_IMR2_WRDY PWM_IMR2_WRDY_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IMR2_WRDY_Msk instead */ 1315 #define PWM_IMR2_UNRE_Pos 3 /**< (PWM_IMR2) Synchronous Channels Update Underrun Error Interrupt Mask Position */ 1316 #define PWM_IMR2_UNRE_Msk (_U_(0x1) << PWM_IMR2_UNRE_Pos) /**< (PWM_IMR2) Synchronous Channels Update Underrun Error Interrupt Mask Mask */ 1317 #define PWM_IMR2_UNRE PWM_IMR2_UNRE_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IMR2_UNRE_Msk instead */ 1318 #define PWM_IMR2_CMPM0_Pos 8 /**< (PWM_IMR2) Comparison 0 Match Interrupt Mask Position */ 1319 #define PWM_IMR2_CMPM0_Msk (_U_(0x1) << PWM_IMR2_CMPM0_Pos) /**< (PWM_IMR2) Comparison 0 Match Interrupt Mask Mask */ 1320 #define PWM_IMR2_CMPM0 PWM_IMR2_CMPM0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IMR2_CMPM0_Msk instead */ 1321 #define PWM_IMR2_CMPM1_Pos 9 /**< (PWM_IMR2) Comparison 1 Match Interrupt Mask Position */ 1322 #define PWM_IMR2_CMPM1_Msk (_U_(0x1) << PWM_IMR2_CMPM1_Pos) /**< (PWM_IMR2) Comparison 1 Match Interrupt Mask Mask */ 1323 #define PWM_IMR2_CMPM1 PWM_IMR2_CMPM1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IMR2_CMPM1_Msk instead */ 1324 #define PWM_IMR2_CMPM2_Pos 10 /**< (PWM_IMR2) Comparison 2 Match Interrupt Mask Position */ 1325 #define PWM_IMR2_CMPM2_Msk (_U_(0x1) << PWM_IMR2_CMPM2_Pos) /**< (PWM_IMR2) Comparison 2 Match Interrupt Mask Mask */ 1326 #define PWM_IMR2_CMPM2 PWM_IMR2_CMPM2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IMR2_CMPM2_Msk instead */ 1327 #define PWM_IMR2_CMPM3_Pos 11 /**< (PWM_IMR2) Comparison 3 Match Interrupt Mask Position */ 1328 #define PWM_IMR2_CMPM3_Msk (_U_(0x1) << PWM_IMR2_CMPM3_Pos) /**< (PWM_IMR2) Comparison 3 Match Interrupt Mask Mask */ 1329 #define PWM_IMR2_CMPM3 PWM_IMR2_CMPM3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IMR2_CMPM3_Msk instead */ 1330 #define PWM_IMR2_CMPM4_Pos 12 /**< (PWM_IMR2) Comparison 4 Match Interrupt Mask Position */ 1331 #define PWM_IMR2_CMPM4_Msk (_U_(0x1) << PWM_IMR2_CMPM4_Pos) /**< (PWM_IMR2) Comparison 4 Match Interrupt Mask Mask */ 1332 #define PWM_IMR2_CMPM4 PWM_IMR2_CMPM4_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IMR2_CMPM4_Msk instead */ 1333 #define PWM_IMR2_CMPM5_Pos 13 /**< (PWM_IMR2) Comparison 5 Match Interrupt Mask Position */ 1334 #define PWM_IMR2_CMPM5_Msk (_U_(0x1) << PWM_IMR2_CMPM5_Pos) /**< (PWM_IMR2) Comparison 5 Match Interrupt Mask Mask */ 1335 #define PWM_IMR2_CMPM5 PWM_IMR2_CMPM5_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IMR2_CMPM5_Msk instead */ 1336 #define PWM_IMR2_CMPM6_Pos 14 /**< (PWM_IMR2) Comparison 6 Match Interrupt Mask Position */ 1337 #define PWM_IMR2_CMPM6_Msk (_U_(0x1) << PWM_IMR2_CMPM6_Pos) /**< (PWM_IMR2) Comparison 6 Match Interrupt Mask Mask */ 1338 #define PWM_IMR2_CMPM6 PWM_IMR2_CMPM6_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IMR2_CMPM6_Msk instead */ 1339 #define PWM_IMR2_CMPM7_Pos 15 /**< (PWM_IMR2) Comparison 7 Match Interrupt Mask Position */ 1340 #define PWM_IMR2_CMPM7_Msk (_U_(0x1) << PWM_IMR2_CMPM7_Pos) /**< (PWM_IMR2) Comparison 7 Match Interrupt Mask Mask */ 1341 #define PWM_IMR2_CMPM7 PWM_IMR2_CMPM7_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IMR2_CMPM7_Msk instead */ 1342 #define PWM_IMR2_CMPU0_Pos 16 /**< (PWM_IMR2) Comparison 0 Update Interrupt Mask Position */ 1343 #define PWM_IMR2_CMPU0_Msk (_U_(0x1) << PWM_IMR2_CMPU0_Pos) /**< (PWM_IMR2) Comparison 0 Update Interrupt Mask Mask */ 1344 #define PWM_IMR2_CMPU0 PWM_IMR2_CMPU0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IMR2_CMPU0_Msk instead */ 1345 #define PWM_IMR2_CMPU1_Pos 17 /**< (PWM_IMR2) Comparison 1 Update Interrupt Mask Position */ 1346 #define PWM_IMR2_CMPU1_Msk (_U_(0x1) << PWM_IMR2_CMPU1_Pos) /**< (PWM_IMR2) Comparison 1 Update Interrupt Mask Mask */ 1347 #define PWM_IMR2_CMPU1 PWM_IMR2_CMPU1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IMR2_CMPU1_Msk instead */ 1348 #define PWM_IMR2_CMPU2_Pos 18 /**< (PWM_IMR2) Comparison 2 Update Interrupt Mask Position */ 1349 #define PWM_IMR2_CMPU2_Msk (_U_(0x1) << PWM_IMR2_CMPU2_Pos) /**< (PWM_IMR2) Comparison 2 Update Interrupt Mask Mask */ 1350 #define PWM_IMR2_CMPU2 PWM_IMR2_CMPU2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IMR2_CMPU2_Msk instead */ 1351 #define PWM_IMR2_CMPU3_Pos 19 /**< (PWM_IMR2) Comparison 3 Update Interrupt Mask Position */ 1352 #define PWM_IMR2_CMPU3_Msk (_U_(0x1) << PWM_IMR2_CMPU3_Pos) /**< (PWM_IMR2) Comparison 3 Update Interrupt Mask Mask */ 1353 #define PWM_IMR2_CMPU3 PWM_IMR2_CMPU3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IMR2_CMPU3_Msk instead */ 1354 #define PWM_IMR2_CMPU4_Pos 20 /**< (PWM_IMR2) Comparison 4 Update Interrupt Mask Position */ 1355 #define PWM_IMR2_CMPU4_Msk (_U_(0x1) << PWM_IMR2_CMPU4_Pos) /**< (PWM_IMR2) Comparison 4 Update Interrupt Mask Mask */ 1356 #define PWM_IMR2_CMPU4 PWM_IMR2_CMPU4_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IMR2_CMPU4_Msk instead */ 1357 #define PWM_IMR2_CMPU5_Pos 21 /**< (PWM_IMR2) Comparison 5 Update Interrupt Mask Position */ 1358 #define PWM_IMR2_CMPU5_Msk (_U_(0x1) << PWM_IMR2_CMPU5_Pos) /**< (PWM_IMR2) Comparison 5 Update Interrupt Mask Mask */ 1359 #define PWM_IMR2_CMPU5 PWM_IMR2_CMPU5_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IMR2_CMPU5_Msk instead */ 1360 #define PWM_IMR2_CMPU6_Pos 22 /**< (PWM_IMR2) Comparison 6 Update Interrupt Mask Position */ 1361 #define PWM_IMR2_CMPU6_Msk (_U_(0x1) << PWM_IMR2_CMPU6_Pos) /**< (PWM_IMR2) Comparison 6 Update Interrupt Mask Mask */ 1362 #define PWM_IMR2_CMPU6 PWM_IMR2_CMPU6_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IMR2_CMPU6_Msk instead */ 1363 #define PWM_IMR2_CMPU7_Pos 23 /**< (PWM_IMR2) Comparison 7 Update Interrupt Mask Position */ 1364 #define PWM_IMR2_CMPU7_Msk (_U_(0x1) << PWM_IMR2_CMPU7_Pos) /**< (PWM_IMR2) Comparison 7 Update Interrupt Mask Mask */ 1365 #define PWM_IMR2_CMPU7 PWM_IMR2_CMPU7_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_IMR2_CMPU7_Msk instead */ 1366 #define PWM_IMR2_MASK _U_(0xFFFF09) /**< \deprecated (PWM_IMR2) Register MASK (Use PWM_IMR2_Msk instead) */ 1367 #define PWM_IMR2_Msk _U_(0xFFFF09) /**< (PWM_IMR2) Register Mask */ 1368 1369 #define PWM_IMR2_CMPM_Pos 8 /**< (PWM_IMR2 Position) Comparison x Match Interrupt Mask */ 1370 #define PWM_IMR2_CMPM_Msk (_U_(0xFF) << PWM_IMR2_CMPM_Pos) /**< (PWM_IMR2 Mask) CMPM */ 1371 #define PWM_IMR2_CMPM(value) (PWM_IMR2_CMPM_Msk & ((value) << PWM_IMR2_CMPM_Pos)) 1372 #define PWM_IMR2_CMPU_Pos 16 /**< (PWM_IMR2 Position) Comparison 7 Update Interrupt Mask */ 1373 #define PWM_IMR2_CMPU_Msk (_U_(0xFF) << PWM_IMR2_CMPU_Pos) /**< (PWM_IMR2 Mask) CMPU */ 1374 #define PWM_IMR2_CMPU(value) (PWM_IMR2_CMPU_Msk & ((value) << PWM_IMR2_CMPU_Pos)) 1375 1376 /* -------- PWM_ISR2 : (PWM Offset: 0x40) (R/ 32) PWM Interrupt Status Register 2 -------- */ 1377 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 1378 #if COMPONENT_TYPEDEF_STYLE == 'N' 1379 typedef union { 1380 struct { 1381 uint32_t WRDY:1; /**< bit: 0 Write Ready for Synchronous Channels Update */ 1382 uint32_t :2; /**< bit: 1..2 Reserved */ 1383 uint32_t UNRE:1; /**< bit: 3 Synchronous Channels Update Underrun Error */ 1384 uint32_t :4; /**< bit: 4..7 Reserved */ 1385 uint32_t CMPM0:1; /**< bit: 8 Comparison 0 Match */ 1386 uint32_t CMPM1:1; /**< bit: 9 Comparison 1 Match */ 1387 uint32_t CMPM2:1; /**< bit: 10 Comparison 2 Match */ 1388 uint32_t CMPM3:1; /**< bit: 11 Comparison 3 Match */ 1389 uint32_t CMPM4:1; /**< bit: 12 Comparison 4 Match */ 1390 uint32_t CMPM5:1; /**< bit: 13 Comparison 5 Match */ 1391 uint32_t CMPM6:1; /**< bit: 14 Comparison 6 Match */ 1392 uint32_t CMPM7:1; /**< bit: 15 Comparison 7 Match */ 1393 uint32_t CMPU0:1; /**< bit: 16 Comparison 0 Update */ 1394 uint32_t CMPU1:1; /**< bit: 17 Comparison 1 Update */ 1395 uint32_t CMPU2:1; /**< bit: 18 Comparison 2 Update */ 1396 uint32_t CMPU3:1; /**< bit: 19 Comparison 3 Update */ 1397 uint32_t CMPU4:1; /**< bit: 20 Comparison 4 Update */ 1398 uint32_t CMPU5:1; /**< bit: 21 Comparison 5 Update */ 1399 uint32_t CMPU6:1; /**< bit: 22 Comparison 6 Update */ 1400 uint32_t CMPU7:1; /**< bit: 23 Comparison 7 Update */ 1401 uint32_t :8; /**< bit: 24..31 Reserved */ 1402 } bit; /**< Structure used for bit access */ 1403 struct { 1404 uint32_t :8; /**< bit: 0..7 Reserved */ 1405 uint32_t CMPM:8; /**< bit: 8..15 Comparison x Match */ 1406 uint32_t CMPU:8; /**< bit: 16..23 Comparison 7 Update */ 1407 uint32_t :8; /**< bit: 24..31 Reserved */ 1408 } vec; /**< Structure used for vec access */ 1409 uint32_t reg; /**< Type used for register access */ 1410 } PWM_ISR2_Type; 1411 #endif 1412 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 1413 1414 #define PWM_ISR2_OFFSET (0x40) /**< (PWM_ISR2) PWM Interrupt Status Register 2 Offset */ 1415 1416 #define PWM_ISR2_WRDY_Pos 0 /**< (PWM_ISR2) Write Ready for Synchronous Channels Update Position */ 1417 #define PWM_ISR2_WRDY_Msk (_U_(0x1) << PWM_ISR2_WRDY_Pos) /**< (PWM_ISR2) Write Ready for Synchronous Channels Update Mask */ 1418 #define PWM_ISR2_WRDY PWM_ISR2_WRDY_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ISR2_WRDY_Msk instead */ 1419 #define PWM_ISR2_UNRE_Pos 3 /**< (PWM_ISR2) Synchronous Channels Update Underrun Error Position */ 1420 #define PWM_ISR2_UNRE_Msk (_U_(0x1) << PWM_ISR2_UNRE_Pos) /**< (PWM_ISR2) Synchronous Channels Update Underrun Error Mask */ 1421 #define PWM_ISR2_UNRE PWM_ISR2_UNRE_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ISR2_UNRE_Msk instead */ 1422 #define PWM_ISR2_CMPM0_Pos 8 /**< (PWM_ISR2) Comparison 0 Match Position */ 1423 #define PWM_ISR2_CMPM0_Msk (_U_(0x1) << PWM_ISR2_CMPM0_Pos) /**< (PWM_ISR2) Comparison 0 Match Mask */ 1424 #define PWM_ISR2_CMPM0 PWM_ISR2_CMPM0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ISR2_CMPM0_Msk instead */ 1425 #define PWM_ISR2_CMPM1_Pos 9 /**< (PWM_ISR2) Comparison 1 Match Position */ 1426 #define PWM_ISR2_CMPM1_Msk (_U_(0x1) << PWM_ISR2_CMPM1_Pos) /**< (PWM_ISR2) Comparison 1 Match Mask */ 1427 #define PWM_ISR2_CMPM1 PWM_ISR2_CMPM1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ISR2_CMPM1_Msk instead */ 1428 #define PWM_ISR2_CMPM2_Pos 10 /**< (PWM_ISR2) Comparison 2 Match Position */ 1429 #define PWM_ISR2_CMPM2_Msk (_U_(0x1) << PWM_ISR2_CMPM2_Pos) /**< (PWM_ISR2) Comparison 2 Match Mask */ 1430 #define PWM_ISR2_CMPM2 PWM_ISR2_CMPM2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ISR2_CMPM2_Msk instead */ 1431 #define PWM_ISR2_CMPM3_Pos 11 /**< (PWM_ISR2) Comparison 3 Match Position */ 1432 #define PWM_ISR2_CMPM3_Msk (_U_(0x1) << PWM_ISR2_CMPM3_Pos) /**< (PWM_ISR2) Comparison 3 Match Mask */ 1433 #define PWM_ISR2_CMPM3 PWM_ISR2_CMPM3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ISR2_CMPM3_Msk instead */ 1434 #define PWM_ISR2_CMPM4_Pos 12 /**< (PWM_ISR2) Comparison 4 Match Position */ 1435 #define PWM_ISR2_CMPM4_Msk (_U_(0x1) << PWM_ISR2_CMPM4_Pos) /**< (PWM_ISR2) Comparison 4 Match Mask */ 1436 #define PWM_ISR2_CMPM4 PWM_ISR2_CMPM4_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ISR2_CMPM4_Msk instead */ 1437 #define PWM_ISR2_CMPM5_Pos 13 /**< (PWM_ISR2) Comparison 5 Match Position */ 1438 #define PWM_ISR2_CMPM5_Msk (_U_(0x1) << PWM_ISR2_CMPM5_Pos) /**< (PWM_ISR2) Comparison 5 Match Mask */ 1439 #define PWM_ISR2_CMPM5 PWM_ISR2_CMPM5_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ISR2_CMPM5_Msk instead */ 1440 #define PWM_ISR2_CMPM6_Pos 14 /**< (PWM_ISR2) Comparison 6 Match Position */ 1441 #define PWM_ISR2_CMPM6_Msk (_U_(0x1) << PWM_ISR2_CMPM6_Pos) /**< (PWM_ISR2) Comparison 6 Match Mask */ 1442 #define PWM_ISR2_CMPM6 PWM_ISR2_CMPM6_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ISR2_CMPM6_Msk instead */ 1443 #define PWM_ISR2_CMPM7_Pos 15 /**< (PWM_ISR2) Comparison 7 Match Position */ 1444 #define PWM_ISR2_CMPM7_Msk (_U_(0x1) << PWM_ISR2_CMPM7_Pos) /**< (PWM_ISR2) Comparison 7 Match Mask */ 1445 #define PWM_ISR2_CMPM7 PWM_ISR2_CMPM7_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ISR2_CMPM7_Msk instead */ 1446 #define PWM_ISR2_CMPU0_Pos 16 /**< (PWM_ISR2) Comparison 0 Update Position */ 1447 #define PWM_ISR2_CMPU0_Msk (_U_(0x1) << PWM_ISR2_CMPU0_Pos) /**< (PWM_ISR2) Comparison 0 Update Mask */ 1448 #define PWM_ISR2_CMPU0 PWM_ISR2_CMPU0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ISR2_CMPU0_Msk instead */ 1449 #define PWM_ISR2_CMPU1_Pos 17 /**< (PWM_ISR2) Comparison 1 Update Position */ 1450 #define PWM_ISR2_CMPU1_Msk (_U_(0x1) << PWM_ISR2_CMPU1_Pos) /**< (PWM_ISR2) Comparison 1 Update Mask */ 1451 #define PWM_ISR2_CMPU1 PWM_ISR2_CMPU1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ISR2_CMPU1_Msk instead */ 1452 #define PWM_ISR2_CMPU2_Pos 18 /**< (PWM_ISR2) Comparison 2 Update Position */ 1453 #define PWM_ISR2_CMPU2_Msk (_U_(0x1) << PWM_ISR2_CMPU2_Pos) /**< (PWM_ISR2) Comparison 2 Update Mask */ 1454 #define PWM_ISR2_CMPU2 PWM_ISR2_CMPU2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ISR2_CMPU2_Msk instead */ 1455 #define PWM_ISR2_CMPU3_Pos 19 /**< (PWM_ISR2) Comparison 3 Update Position */ 1456 #define PWM_ISR2_CMPU3_Msk (_U_(0x1) << PWM_ISR2_CMPU3_Pos) /**< (PWM_ISR2) Comparison 3 Update Mask */ 1457 #define PWM_ISR2_CMPU3 PWM_ISR2_CMPU3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ISR2_CMPU3_Msk instead */ 1458 #define PWM_ISR2_CMPU4_Pos 20 /**< (PWM_ISR2) Comparison 4 Update Position */ 1459 #define PWM_ISR2_CMPU4_Msk (_U_(0x1) << PWM_ISR2_CMPU4_Pos) /**< (PWM_ISR2) Comparison 4 Update Mask */ 1460 #define PWM_ISR2_CMPU4 PWM_ISR2_CMPU4_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ISR2_CMPU4_Msk instead */ 1461 #define PWM_ISR2_CMPU5_Pos 21 /**< (PWM_ISR2) Comparison 5 Update Position */ 1462 #define PWM_ISR2_CMPU5_Msk (_U_(0x1) << PWM_ISR2_CMPU5_Pos) /**< (PWM_ISR2) Comparison 5 Update Mask */ 1463 #define PWM_ISR2_CMPU5 PWM_ISR2_CMPU5_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ISR2_CMPU5_Msk instead */ 1464 #define PWM_ISR2_CMPU6_Pos 22 /**< (PWM_ISR2) Comparison 6 Update Position */ 1465 #define PWM_ISR2_CMPU6_Msk (_U_(0x1) << PWM_ISR2_CMPU6_Pos) /**< (PWM_ISR2) Comparison 6 Update Mask */ 1466 #define PWM_ISR2_CMPU6 PWM_ISR2_CMPU6_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ISR2_CMPU6_Msk instead */ 1467 #define PWM_ISR2_CMPU7_Pos 23 /**< (PWM_ISR2) Comparison 7 Update Position */ 1468 #define PWM_ISR2_CMPU7_Msk (_U_(0x1) << PWM_ISR2_CMPU7_Pos) /**< (PWM_ISR2) Comparison 7 Update Mask */ 1469 #define PWM_ISR2_CMPU7 PWM_ISR2_CMPU7_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ISR2_CMPU7_Msk instead */ 1470 #define PWM_ISR2_MASK _U_(0xFFFF09) /**< \deprecated (PWM_ISR2) Register MASK (Use PWM_ISR2_Msk instead) */ 1471 #define PWM_ISR2_Msk _U_(0xFFFF09) /**< (PWM_ISR2) Register Mask */ 1472 1473 #define PWM_ISR2_CMPM_Pos 8 /**< (PWM_ISR2 Position) Comparison x Match */ 1474 #define PWM_ISR2_CMPM_Msk (_U_(0xFF) << PWM_ISR2_CMPM_Pos) /**< (PWM_ISR2 Mask) CMPM */ 1475 #define PWM_ISR2_CMPM(value) (PWM_ISR2_CMPM_Msk & ((value) << PWM_ISR2_CMPM_Pos)) 1476 #define PWM_ISR2_CMPU_Pos 16 /**< (PWM_ISR2 Position) Comparison 7 Update */ 1477 #define PWM_ISR2_CMPU_Msk (_U_(0xFF) << PWM_ISR2_CMPU_Pos) /**< (PWM_ISR2 Mask) CMPU */ 1478 #define PWM_ISR2_CMPU(value) (PWM_ISR2_CMPU_Msk & ((value) << PWM_ISR2_CMPU_Pos)) 1479 1480 /* -------- PWM_OOV : (PWM Offset: 0x44) (R/W 32) PWM Output Override Value Register -------- */ 1481 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 1482 #if COMPONENT_TYPEDEF_STYLE == 'N' 1483 typedef union { 1484 struct { 1485 uint32_t OOVH0:1; /**< bit: 0 Output Override Value for PWMH output of the channel 0 */ 1486 uint32_t OOVH1:1; /**< bit: 1 Output Override Value for PWMH output of the channel 1 */ 1487 uint32_t OOVH2:1; /**< bit: 2 Output Override Value for PWMH output of the channel 2 */ 1488 uint32_t OOVH3:1; /**< bit: 3 Output Override Value for PWMH output of the channel 3 */ 1489 uint32_t :12; /**< bit: 4..15 Reserved */ 1490 uint32_t OOVL0:1; /**< bit: 16 Output Override Value for PWML output of the channel 0 */ 1491 uint32_t OOVL1:1; /**< bit: 17 Output Override Value for PWML output of the channel 1 */ 1492 uint32_t OOVL2:1; /**< bit: 18 Output Override Value for PWML output of the channel 2 */ 1493 uint32_t OOVL3:1; /**< bit: 19 Output Override Value for PWML output of the channel 3 */ 1494 uint32_t :12; /**< bit: 20..31 Reserved */ 1495 } bit; /**< Structure used for bit access */ 1496 struct { 1497 uint32_t OOVH:4; /**< bit: 0..3 Output Override Value for PWMH output of the channel x */ 1498 uint32_t :12; /**< bit: 4..15 Reserved */ 1499 uint32_t OOVL:4; /**< bit: 16..19 Output Override Value for PWML output of the channel 3 */ 1500 uint32_t :12; /**< bit: 20..31 Reserved */ 1501 } vec; /**< Structure used for vec access */ 1502 uint32_t reg; /**< Type used for register access */ 1503 } PWM_OOV_Type; 1504 #endif 1505 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 1506 1507 #define PWM_OOV_OFFSET (0x44) /**< (PWM_OOV) PWM Output Override Value Register Offset */ 1508 1509 #define PWM_OOV_OOVH0_Pos 0 /**< (PWM_OOV) Output Override Value for PWMH output of the channel 0 Position */ 1510 #define PWM_OOV_OOVH0_Msk (_U_(0x1) << PWM_OOV_OOVH0_Pos) /**< (PWM_OOV) Output Override Value for PWMH output of the channel 0 Mask */ 1511 #define PWM_OOV_OOVH0 PWM_OOV_OOVH0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OOV_OOVH0_Msk instead */ 1512 #define PWM_OOV_OOVH1_Pos 1 /**< (PWM_OOV) Output Override Value for PWMH output of the channel 1 Position */ 1513 #define PWM_OOV_OOVH1_Msk (_U_(0x1) << PWM_OOV_OOVH1_Pos) /**< (PWM_OOV) Output Override Value for PWMH output of the channel 1 Mask */ 1514 #define PWM_OOV_OOVH1 PWM_OOV_OOVH1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OOV_OOVH1_Msk instead */ 1515 #define PWM_OOV_OOVH2_Pos 2 /**< (PWM_OOV) Output Override Value for PWMH output of the channel 2 Position */ 1516 #define PWM_OOV_OOVH2_Msk (_U_(0x1) << PWM_OOV_OOVH2_Pos) /**< (PWM_OOV) Output Override Value for PWMH output of the channel 2 Mask */ 1517 #define PWM_OOV_OOVH2 PWM_OOV_OOVH2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OOV_OOVH2_Msk instead */ 1518 #define PWM_OOV_OOVH3_Pos 3 /**< (PWM_OOV) Output Override Value for PWMH output of the channel 3 Position */ 1519 #define PWM_OOV_OOVH3_Msk (_U_(0x1) << PWM_OOV_OOVH3_Pos) /**< (PWM_OOV) Output Override Value for PWMH output of the channel 3 Mask */ 1520 #define PWM_OOV_OOVH3 PWM_OOV_OOVH3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OOV_OOVH3_Msk instead */ 1521 #define PWM_OOV_OOVL0_Pos 16 /**< (PWM_OOV) Output Override Value for PWML output of the channel 0 Position */ 1522 #define PWM_OOV_OOVL0_Msk (_U_(0x1) << PWM_OOV_OOVL0_Pos) /**< (PWM_OOV) Output Override Value for PWML output of the channel 0 Mask */ 1523 #define PWM_OOV_OOVL0 PWM_OOV_OOVL0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OOV_OOVL0_Msk instead */ 1524 #define PWM_OOV_OOVL1_Pos 17 /**< (PWM_OOV) Output Override Value for PWML output of the channel 1 Position */ 1525 #define PWM_OOV_OOVL1_Msk (_U_(0x1) << PWM_OOV_OOVL1_Pos) /**< (PWM_OOV) Output Override Value for PWML output of the channel 1 Mask */ 1526 #define PWM_OOV_OOVL1 PWM_OOV_OOVL1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OOV_OOVL1_Msk instead */ 1527 #define PWM_OOV_OOVL2_Pos 18 /**< (PWM_OOV) Output Override Value for PWML output of the channel 2 Position */ 1528 #define PWM_OOV_OOVL2_Msk (_U_(0x1) << PWM_OOV_OOVL2_Pos) /**< (PWM_OOV) Output Override Value for PWML output of the channel 2 Mask */ 1529 #define PWM_OOV_OOVL2 PWM_OOV_OOVL2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OOV_OOVL2_Msk instead */ 1530 #define PWM_OOV_OOVL3_Pos 19 /**< (PWM_OOV) Output Override Value for PWML output of the channel 3 Position */ 1531 #define PWM_OOV_OOVL3_Msk (_U_(0x1) << PWM_OOV_OOVL3_Pos) /**< (PWM_OOV) Output Override Value for PWML output of the channel 3 Mask */ 1532 #define PWM_OOV_OOVL3 PWM_OOV_OOVL3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OOV_OOVL3_Msk instead */ 1533 #define PWM_OOV_MASK _U_(0xF000F) /**< \deprecated (PWM_OOV) Register MASK (Use PWM_OOV_Msk instead) */ 1534 #define PWM_OOV_Msk _U_(0xF000F) /**< (PWM_OOV) Register Mask */ 1535 1536 #define PWM_OOV_OOVH_Pos 0 /**< (PWM_OOV Position) Output Override Value for PWMH output of the channel x */ 1537 #define PWM_OOV_OOVH_Msk (_U_(0xF) << PWM_OOV_OOVH_Pos) /**< (PWM_OOV Mask) OOVH */ 1538 #define PWM_OOV_OOVH(value) (PWM_OOV_OOVH_Msk & ((value) << PWM_OOV_OOVH_Pos)) 1539 #define PWM_OOV_OOVL_Pos 16 /**< (PWM_OOV Position) Output Override Value for PWML output of the channel 3 */ 1540 #define PWM_OOV_OOVL_Msk (_U_(0xF) << PWM_OOV_OOVL_Pos) /**< (PWM_OOV Mask) OOVL */ 1541 #define PWM_OOV_OOVL(value) (PWM_OOV_OOVL_Msk & ((value) << PWM_OOV_OOVL_Pos)) 1542 1543 /* -------- PWM_OS : (PWM Offset: 0x48) (R/W 32) PWM Output Selection Register -------- */ 1544 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 1545 #if COMPONENT_TYPEDEF_STYLE == 'N' 1546 typedef union { 1547 struct { 1548 uint32_t OSH0:1; /**< bit: 0 Output Selection for PWMH output of the channel 0 */ 1549 uint32_t OSH1:1; /**< bit: 1 Output Selection for PWMH output of the channel 1 */ 1550 uint32_t OSH2:1; /**< bit: 2 Output Selection for PWMH output of the channel 2 */ 1551 uint32_t OSH3:1; /**< bit: 3 Output Selection for PWMH output of the channel 3 */ 1552 uint32_t :12; /**< bit: 4..15 Reserved */ 1553 uint32_t OSL0:1; /**< bit: 16 Output Selection for PWML output of the channel 0 */ 1554 uint32_t OSL1:1; /**< bit: 17 Output Selection for PWML output of the channel 1 */ 1555 uint32_t OSL2:1; /**< bit: 18 Output Selection for PWML output of the channel 2 */ 1556 uint32_t OSL3:1; /**< bit: 19 Output Selection for PWML output of the channel 3 */ 1557 uint32_t :12; /**< bit: 20..31 Reserved */ 1558 } bit; /**< Structure used for bit access */ 1559 struct { 1560 uint32_t OSH:4; /**< bit: 0..3 Output Selection for PWMH output of the channel x */ 1561 uint32_t :12; /**< bit: 4..15 Reserved */ 1562 uint32_t OSL:4; /**< bit: 16..19 Output Selection for PWML output of the channel 3 */ 1563 uint32_t :12; /**< bit: 20..31 Reserved */ 1564 } vec; /**< Structure used for vec access */ 1565 uint32_t reg; /**< Type used for register access */ 1566 } PWM_OS_Type; 1567 #endif 1568 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 1569 1570 #define PWM_OS_OFFSET (0x48) /**< (PWM_OS) PWM Output Selection Register Offset */ 1571 1572 #define PWM_OS_OSH0_Pos 0 /**< (PWM_OS) Output Selection for PWMH output of the channel 0 Position */ 1573 #define PWM_OS_OSH0_Msk (_U_(0x1) << PWM_OS_OSH0_Pos) /**< (PWM_OS) Output Selection for PWMH output of the channel 0 Mask */ 1574 #define PWM_OS_OSH0 PWM_OS_OSH0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OS_OSH0_Msk instead */ 1575 #define PWM_OS_OSH1_Pos 1 /**< (PWM_OS) Output Selection for PWMH output of the channel 1 Position */ 1576 #define PWM_OS_OSH1_Msk (_U_(0x1) << PWM_OS_OSH1_Pos) /**< (PWM_OS) Output Selection for PWMH output of the channel 1 Mask */ 1577 #define PWM_OS_OSH1 PWM_OS_OSH1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OS_OSH1_Msk instead */ 1578 #define PWM_OS_OSH2_Pos 2 /**< (PWM_OS) Output Selection for PWMH output of the channel 2 Position */ 1579 #define PWM_OS_OSH2_Msk (_U_(0x1) << PWM_OS_OSH2_Pos) /**< (PWM_OS) Output Selection for PWMH output of the channel 2 Mask */ 1580 #define PWM_OS_OSH2 PWM_OS_OSH2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OS_OSH2_Msk instead */ 1581 #define PWM_OS_OSH3_Pos 3 /**< (PWM_OS) Output Selection for PWMH output of the channel 3 Position */ 1582 #define PWM_OS_OSH3_Msk (_U_(0x1) << PWM_OS_OSH3_Pos) /**< (PWM_OS) Output Selection for PWMH output of the channel 3 Mask */ 1583 #define PWM_OS_OSH3 PWM_OS_OSH3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OS_OSH3_Msk instead */ 1584 #define PWM_OS_OSL0_Pos 16 /**< (PWM_OS) Output Selection for PWML output of the channel 0 Position */ 1585 #define PWM_OS_OSL0_Msk (_U_(0x1) << PWM_OS_OSL0_Pos) /**< (PWM_OS) Output Selection for PWML output of the channel 0 Mask */ 1586 #define PWM_OS_OSL0 PWM_OS_OSL0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OS_OSL0_Msk instead */ 1587 #define PWM_OS_OSL1_Pos 17 /**< (PWM_OS) Output Selection for PWML output of the channel 1 Position */ 1588 #define PWM_OS_OSL1_Msk (_U_(0x1) << PWM_OS_OSL1_Pos) /**< (PWM_OS) Output Selection for PWML output of the channel 1 Mask */ 1589 #define PWM_OS_OSL1 PWM_OS_OSL1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OS_OSL1_Msk instead */ 1590 #define PWM_OS_OSL2_Pos 18 /**< (PWM_OS) Output Selection for PWML output of the channel 2 Position */ 1591 #define PWM_OS_OSL2_Msk (_U_(0x1) << PWM_OS_OSL2_Pos) /**< (PWM_OS) Output Selection for PWML output of the channel 2 Mask */ 1592 #define PWM_OS_OSL2 PWM_OS_OSL2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OS_OSL2_Msk instead */ 1593 #define PWM_OS_OSL3_Pos 19 /**< (PWM_OS) Output Selection for PWML output of the channel 3 Position */ 1594 #define PWM_OS_OSL3_Msk (_U_(0x1) << PWM_OS_OSL3_Pos) /**< (PWM_OS) Output Selection for PWML output of the channel 3 Mask */ 1595 #define PWM_OS_OSL3 PWM_OS_OSL3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OS_OSL3_Msk instead */ 1596 #define PWM_OS_MASK _U_(0xF000F) /**< \deprecated (PWM_OS) Register MASK (Use PWM_OS_Msk instead) */ 1597 #define PWM_OS_Msk _U_(0xF000F) /**< (PWM_OS) Register Mask */ 1598 1599 #define PWM_OS_OSH_Pos 0 /**< (PWM_OS Position) Output Selection for PWMH output of the channel x */ 1600 #define PWM_OS_OSH_Msk (_U_(0xF) << PWM_OS_OSH_Pos) /**< (PWM_OS Mask) OSH */ 1601 #define PWM_OS_OSH(value) (PWM_OS_OSH_Msk & ((value) << PWM_OS_OSH_Pos)) 1602 #define PWM_OS_OSL_Pos 16 /**< (PWM_OS Position) Output Selection for PWML output of the channel 3 */ 1603 #define PWM_OS_OSL_Msk (_U_(0xF) << PWM_OS_OSL_Pos) /**< (PWM_OS Mask) OSL */ 1604 #define PWM_OS_OSL(value) (PWM_OS_OSL_Msk & ((value) << PWM_OS_OSL_Pos)) 1605 1606 /* -------- PWM_OSS : (PWM Offset: 0x4c) (/W 32) PWM Output Selection Set Register -------- */ 1607 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 1608 #if COMPONENT_TYPEDEF_STYLE == 'N' 1609 typedef union { 1610 struct { 1611 uint32_t OSSH0:1; /**< bit: 0 Output Selection Set for PWMH output of the channel 0 */ 1612 uint32_t OSSH1:1; /**< bit: 1 Output Selection Set for PWMH output of the channel 1 */ 1613 uint32_t OSSH2:1; /**< bit: 2 Output Selection Set for PWMH output of the channel 2 */ 1614 uint32_t OSSH3:1; /**< bit: 3 Output Selection Set for PWMH output of the channel 3 */ 1615 uint32_t :12; /**< bit: 4..15 Reserved */ 1616 uint32_t OSSL0:1; /**< bit: 16 Output Selection Set for PWML output of the channel 0 */ 1617 uint32_t OSSL1:1; /**< bit: 17 Output Selection Set for PWML output of the channel 1 */ 1618 uint32_t OSSL2:1; /**< bit: 18 Output Selection Set for PWML output of the channel 2 */ 1619 uint32_t OSSL3:1; /**< bit: 19 Output Selection Set for PWML output of the channel 3 */ 1620 uint32_t :12; /**< bit: 20..31 Reserved */ 1621 } bit; /**< Structure used for bit access */ 1622 struct { 1623 uint32_t OSSH:4; /**< bit: 0..3 Output Selection Set for PWMH output of the channel x */ 1624 uint32_t :12; /**< bit: 4..15 Reserved */ 1625 uint32_t OSSL:4; /**< bit: 16..19 Output Selection Set for PWML output of the channel 3 */ 1626 uint32_t :12; /**< bit: 20..31 Reserved */ 1627 } vec; /**< Structure used for vec access */ 1628 uint32_t reg; /**< Type used for register access */ 1629 } PWM_OSS_Type; 1630 #endif 1631 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 1632 1633 #define PWM_OSS_OFFSET (0x4C) /**< (PWM_OSS) PWM Output Selection Set Register Offset */ 1634 1635 #define PWM_OSS_OSSH0_Pos 0 /**< (PWM_OSS) Output Selection Set for PWMH output of the channel 0 Position */ 1636 #define PWM_OSS_OSSH0_Msk (_U_(0x1) << PWM_OSS_OSSH0_Pos) /**< (PWM_OSS) Output Selection Set for PWMH output of the channel 0 Mask */ 1637 #define PWM_OSS_OSSH0 PWM_OSS_OSSH0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSS_OSSH0_Msk instead */ 1638 #define PWM_OSS_OSSH1_Pos 1 /**< (PWM_OSS) Output Selection Set for PWMH output of the channel 1 Position */ 1639 #define PWM_OSS_OSSH1_Msk (_U_(0x1) << PWM_OSS_OSSH1_Pos) /**< (PWM_OSS) Output Selection Set for PWMH output of the channel 1 Mask */ 1640 #define PWM_OSS_OSSH1 PWM_OSS_OSSH1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSS_OSSH1_Msk instead */ 1641 #define PWM_OSS_OSSH2_Pos 2 /**< (PWM_OSS) Output Selection Set for PWMH output of the channel 2 Position */ 1642 #define PWM_OSS_OSSH2_Msk (_U_(0x1) << PWM_OSS_OSSH2_Pos) /**< (PWM_OSS) Output Selection Set for PWMH output of the channel 2 Mask */ 1643 #define PWM_OSS_OSSH2 PWM_OSS_OSSH2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSS_OSSH2_Msk instead */ 1644 #define PWM_OSS_OSSH3_Pos 3 /**< (PWM_OSS) Output Selection Set for PWMH output of the channel 3 Position */ 1645 #define PWM_OSS_OSSH3_Msk (_U_(0x1) << PWM_OSS_OSSH3_Pos) /**< (PWM_OSS) Output Selection Set for PWMH output of the channel 3 Mask */ 1646 #define PWM_OSS_OSSH3 PWM_OSS_OSSH3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSS_OSSH3_Msk instead */ 1647 #define PWM_OSS_OSSL0_Pos 16 /**< (PWM_OSS) Output Selection Set for PWML output of the channel 0 Position */ 1648 #define PWM_OSS_OSSL0_Msk (_U_(0x1) << PWM_OSS_OSSL0_Pos) /**< (PWM_OSS) Output Selection Set for PWML output of the channel 0 Mask */ 1649 #define PWM_OSS_OSSL0 PWM_OSS_OSSL0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSS_OSSL0_Msk instead */ 1650 #define PWM_OSS_OSSL1_Pos 17 /**< (PWM_OSS) Output Selection Set for PWML output of the channel 1 Position */ 1651 #define PWM_OSS_OSSL1_Msk (_U_(0x1) << PWM_OSS_OSSL1_Pos) /**< (PWM_OSS) Output Selection Set for PWML output of the channel 1 Mask */ 1652 #define PWM_OSS_OSSL1 PWM_OSS_OSSL1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSS_OSSL1_Msk instead */ 1653 #define PWM_OSS_OSSL2_Pos 18 /**< (PWM_OSS) Output Selection Set for PWML output of the channel 2 Position */ 1654 #define PWM_OSS_OSSL2_Msk (_U_(0x1) << PWM_OSS_OSSL2_Pos) /**< (PWM_OSS) Output Selection Set for PWML output of the channel 2 Mask */ 1655 #define PWM_OSS_OSSL2 PWM_OSS_OSSL2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSS_OSSL2_Msk instead */ 1656 #define PWM_OSS_OSSL3_Pos 19 /**< (PWM_OSS) Output Selection Set for PWML output of the channel 3 Position */ 1657 #define PWM_OSS_OSSL3_Msk (_U_(0x1) << PWM_OSS_OSSL3_Pos) /**< (PWM_OSS) Output Selection Set for PWML output of the channel 3 Mask */ 1658 #define PWM_OSS_OSSL3 PWM_OSS_OSSL3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSS_OSSL3_Msk instead */ 1659 #define PWM_OSS_MASK _U_(0xF000F) /**< \deprecated (PWM_OSS) Register MASK (Use PWM_OSS_Msk instead) */ 1660 #define PWM_OSS_Msk _U_(0xF000F) /**< (PWM_OSS) Register Mask */ 1661 1662 #define PWM_OSS_OSSH_Pos 0 /**< (PWM_OSS Position) Output Selection Set for PWMH output of the channel x */ 1663 #define PWM_OSS_OSSH_Msk (_U_(0xF) << PWM_OSS_OSSH_Pos) /**< (PWM_OSS Mask) OSSH */ 1664 #define PWM_OSS_OSSH(value) (PWM_OSS_OSSH_Msk & ((value) << PWM_OSS_OSSH_Pos)) 1665 #define PWM_OSS_OSSL_Pos 16 /**< (PWM_OSS Position) Output Selection Set for PWML output of the channel 3 */ 1666 #define PWM_OSS_OSSL_Msk (_U_(0xF) << PWM_OSS_OSSL_Pos) /**< (PWM_OSS Mask) OSSL */ 1667 #define PWM_OSS_OSSL(value) (PWM_OSS_OSSL_Msk & ((value) << PWM_OSS_OSSL_Pos)) 1668 1669 /* -------- PWM_OSC : (PWM Offset: 0x50) (/W 32) PWM Output Selection Clear Register -------- */ 1670 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 1671 #if COMPONENT_TYPEDEF_STYLE == 'N' 1672 typedef union { 1673 struct { 1674 uint32_t OSCH0:1; /**< bit: 0 Output Selection Clear for PWMH output of the channel 0 */ 1675 uint32_t OSCH1:1; /**< bit: 1 Output Selection Clear for PWMH output of the channel 1 */ 1676 uint32_t OSCH2:1; /**< bit: 2 Output Selection Clear for PWMH output of the channel 2 */ 1677 uint32_t OSCH3:1; /**< bit: 3 Output Selection Clear for PWMH output of the channel 3 */ 1678 uint32_t :12; /**< bit: 4..15 Reserved */ 1679 uint32_t OSCL0:1; /**< bit: 16 Output Selection Clear for PWML output of the channel 0 */ 1680 uint32_t OSCL1:1; /**< bit: 17 Output Selection Clear for PWML output of the channel 1 */ 1681 uint32_t OSCL2:1; /**< bit: 18 Output Selection Clear for PWML output of the channel 2 */ 1682 uint32_t OSCL3:1; /**< bit: 19 Output Selection Clear for PWML output of the channel 3 */ 1683 uint32_t :12; /**< bit: 20..31 Reserved */ 1684 } bit; /**< Structure used for bit access */ 1685 struct { 1686 uint32_t OSCH:4; /**< bit: 0..3 Output Selection Clear for PWMH output of the channel x */ 1687 uint32_t :12; /**< bit: 4..15 Reserved */ 1688 uint32_t OSCL:4; /**< bit: 16..19 Output Selection Clear for PWML output of the channel 3 */ 1689 uint32_t :12; /**< bit: 20..31 Reserved */ 1690 } vec; /**< Structure used for vec access */ 1691 uint32_t reg; /**< Type used for register access */ 1692 } PWM_OSC_Type; 1693 #endif 1694 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 1695 1696 #define PWM_OSC_OFFSET (0x50) /**< (PWM_OSC) PWM Output Selection Clear Register Offset */ 1697 1698 #define PWM_OSC_OSCH0_Pos 0 /**< (PWM_OSC) Output Selection Clear for PWMH output of the channel 0 Position */ 1699 #define PWM_OSC_OSCH0_Msk (_U_(0x1) << PWM_OSC_OSCH0_Pos) /**< (PWM_OSC) Output Selection Clear for PWMH output of the channel 0 Mask */ 1700 #define PWM_OSC_OSCH0 PWM_OSC_OSCH0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSC_OSCH0_Msk instead */ 1701 #define PWM_OSC_OSCH1_Pos 1 /**< (PWM_OSC) Output Selection Clear for PWMH output of the channel 1 Position */ 1702 #define PWM_OSC_OSCH1_Msk (_U_(0x1) << PWM_OSC_OSCH1_Pos) /**< (PWM_OSC) Output Selection Clear for PWMH output of the channel 1 Mask */ 1703 #define PWM_OSC_OSCH1 PWM_OSC_OSCH1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSC_OSCH1_Msk instead */ 1704 #define PWM_OSC_OSCH2_Pos 2 /**< (PWM_OSC) Output Selection Clear for PWMH output of the channel 2 Position */ 1705 #define PWM_OSC_OSCH2_Msk (_U_(0x1) << PWM_OSC_OSCH2_Pos) /**< (PWM_OSC) Output Selection Clear for PWMH output of the channel 2 Mask */ 1706 #define PWM_OSC_OSCH2 PWM_OSC_OSCH2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSC_OSCH2_Msk instead */ 1707 #define PWM_OSC_OSCH3_Pos 3 /**< (PWM_OSC) Output Selection Clear for PWMH output of the channel 3 Position */ 1708 #define PWM_OSC_OSCH3_Msk (_U_(0x1) << PWM_OSC_OSCH3_Pos) /**< (PWM_OSC) Output Selection Clear for PWMH output of the channel 3 Mask */ 1709 #define PWM_OSC_OSCH3 PWM_OSC_OSCH3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSC_OSCH3_Msk instead */ 1710 #define PWM_OSC_OSCL0_Pos 16 /**< (PWM_OSC) Output Selection Clear for PWML output of the channel 0 Position */ 1711 #define PWM_OSC_OSCL0_Msk (_U_(0x1) << PWM_OSC_OSCL0_Pos) /**< (PWM_OSC) Output Selection Clear for PWML output of the channel 0 Mask */ 1712 #define PWM_OSC_OSCL0 PWM_OSC_OSCL0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSC_OSCL0_Msk instead */ 1713 #define PWM_OSC_OSCL1_Pos 17 /**< (PWM_OSC) Output Selection Clear for PWML output of the channel 1 Position */ 1714 #define PWM_OSC_OSCL1_Msk (_U_(0x1) << PWM_OSC_OSCL1_Pos) /**< (PWM_OSC) Output Selection Clear for PWML output of the channel 1 Mask */ 1715 #define PWM_OSC_OSCL1 PWM_OSC_OSCL1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSC_OSCL1_Msk instead */ 1716 #define PWM_OSC_OSCL2_Pos 18 /**< (PWM_OSC) Output Selection Clear for PWML output of the channel 2 Position */ 1717 #define PWM_OSC_OSCL2_Msk (_U_(0x1) << PWM_OSC_OSCL2_Pos) /**< (PWM_OSC) Output Selection Clear for PWML output of the channel 2 Mask */ 1718 #define PWM_OSC_OSCL2 PWM_OSC_OSCL2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSC_OSCL2_Msk instead */ 1719 #define PWM_OSC_OSCL3_Pos 19 /**< (PWM_OSC) Output Selection Clear for PWML output of the channel 3 Position */ 1720 #define PWM_OSC_OSCL3_Msk (_U_(0x1) << PWM_OSC_OSCL3_Pos) /**< (PWM_OSC) Output Selection Clear for PWML output of the channel 3 Mask */ 1721 #define PWM_OSC_OSCL3 PWM_OSC_OSCL3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSC_OSCL3_Msk instead */ 1722 #define PWM_OSC_MASK _U_(0xF000F) /**< \deprecated (PWM_OSC) Register MASK (Use PWM_OSC_Msk instead) */ 1723 #define PWM_OSC_Msk _U_(0xF000F) /**< (PWM_OSC) Register Mask */ 1724 1725 #define PWM_OSC_OSCH_Pos 0 /**< (PWM_OSC Position) Output Selection Clear for PWMH output of the channel x */ 1726 #define PWM_OSC_OSCH_Msk (_U_(0xF) << PWM_OSC_OSCH_Pos) /**< (PWM_OSC Mask) OSCH */ 1727 #define PWM_OSC_OSCH(value) (PWM_OSC_OSCH_Msk & ((value) << PWM_OSC_OSCH_Pos)) 1728 #define PWM_OSC_OSCL_Pos 16 /**< (PWM_OSC Position) Output Selection Clear for PWML output of the channel 3 */ 1729 #define PWM_OSC_OSCL_Msk (_U_(0xF) << PWM_OSC_OSCL_Pos) /**< (PWM_OSC Mask) OSCL */ 1730 #define PWM_OSC_OSCL(value) (PWM_OSC_OSCL_Msk & ((value) << PWM_OSC_OSCL_Pos)) 1731 1732 /* -------- PWM_OSSUPD : (PWM Offset: 0x54) (/W 32) PWM Output Selection Set Update Register -------- */ 1733 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 1734 #if COMPONENT_TYPEDEF_STYLE == 'N' 1735 typedef union { 1736 struct { 1737 uint32_t OSSUPH0:1; /**< bit: 0 Output Selection Set for PWMH output of the channel 0 */ 1738 uint32_t OSSUPH1:1; /**< bit: 1 Output Selection Set for PWMH output of the channel 1 */ 1739 uint32_t OSSUPH2:1; /**< bit: 2 Output Selection Set for PWMH output of the channel 2 */ 1740 uint32_t OSSUPH3:1; /**< bit: 3 Output Selection Set for PWMH output of the channel 3 */ 1741 uint32_t :12; /**< bit: 4..15 Reserved */ 1742 uint32_t OSSUPL0:1; /**< bit: 16 Output Selection Set for PWML output of the channel 0 */ 1743 uint32_t OSSUPL1:1; /**< bit: 17 Output Selection Set for PWML output of the channel 1 */ 1744 uint32_t OSSUPL2:1; /**< bit: 18 Output Selection Set for PWML output of the channel 2 */ 1745 uint32_t OSSUPL3:1; /**< bit: 19 Output Selection Set for PWML output of the channel 3 */ 1746 uint32_t :12; /**< bit: 20..31 Reserved */ 1747 } bit; /**< Structure used for bit access */ 1748 struct { 1749 uint32_t OSSUPH:4; /**< bit: 0..3 Output Selection Set for PWMH output of the channel x */ 1750 uint32_t :12; /**< bit: 4..15 Reserved */ 1751 uint32_t OSSUPL:4; /**< bit: 16..19 Output Selection Set for PWML output of the channel 3 */ 1752 uint32_t :12; /**< bit: 20..31 Reserved */ 1753 } vec; /**< Structure used for vec access */ 1754 uint32_t reg; /**< Type used for register access */ 1755 } PWM_OSSUPD_Type; 1756 #endif 1757 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 1758 1759 #define PWM_OSSUPD_OFFSET (0x54) /**< (PWM_OSSUPD) PWM Output Selection Set Update Register Offset */ 1760 1761 #define PWM_OSSUPD_OSSUPH0_Pos 0 /**< (PWM_OSSUPD) Output Selection Set for PWMH output of the channel 0 Position */ 1762 #define PWM_OSSUPD_OSSUPH0_Msk (_U_(0x1) << PWM_OSSUPD_OSSUPH0_Pos) /**< (PWM_OSSUPD) Output Selection Set for PWMH output of the channel 0 Mask */ 1763 #define PWM_OSSUPD_OSSUPH0 PWM_OSSUPD_OSSUPH0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSSUPD_OSSUPH0_Msk instead */ 1764 #define PWM_OSSUPD_OSSUPH1_Pos 1 /**< (PWM_OSSUPD) Output Selection Set for PWMH output of the channel 1 Position */ 1765 #define PWM_OSSUPD_OSSUPH1_Msk (_U_(0x1) << PWM_OSSUPD_OSSUPH1_Pos) /**< (PWM_OSSUPD) Output Selection Set for PWMH output of the channel 1 Mask */ 1766 #define PWM_OSSUPD_OSSUPH1 PWM_OSSUPD_OSSUPH1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSSUPD_OSSUPH1_Msk instead */ 1767 #define PWM_OSSUPD_OSSUPH2_Pos 2 /**< (PWM_OSSUPD) Output Selection Set for PWMH output of the channel 2 Position */ 1768 #define PWM_OSSUPD_OSSUPH2_Msk (_U_(0x1) << PWM_OSSUPD_OSSUPH2_Pos) /**< (PWM_OSSUPD) Output Selection Set for PWMH output of the channel 2 Mask */ 1769 #define PWM_OSSUPD_OSSUPH2 PWM_OSSUPD_OSSUPH2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSSUPD_OSSUPH2_Msk instead */ 1770 #define PWM_OSSUPD_OSSUPH3_Pos 3 /**< (PWM_OSSUPD) Output Selection Set for PWMH output of the channel 3 Position */ 1771 #define PWM_OSSUPD_OSSUPH3_Msk (_U_(0x1) << PWM_OSSUPD_OSSUPH3_Pos) /**< (PWM_OSSUPD) Output Selection Set for PWMH output of the channel 3 Mask */ 1772 #define PWM_OSSUPD_OSSUPH3 PWM_OSSUPD_OSSUPH3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSSUPD_OSSUPH3_Msk instead */ 1773 #define PWM_OSSUPD_OSSUPL0_Pos 16 /**< (PWM_OSSUPD) Output Selection Set for PWML output of the channel 0 Position */ 1774 #define PWM_OSSUPD_OSSUPL0_Msk (_U_(0x1) << PWM_OSSUPD_OSSUPL0_Pos) /**< (PWM_OSSUPD) Output Selection Set for PWML output of the channel 0 Mask */ 1775 #define PWM_OSSUPD_OSSUPL0 PWM_OSSUPD_OSSUPL0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSSUPD_OSSUPL0_Msk instead */ 1776 #define PWM_OSSUPD_OSSUPL1_Pos 17 /**< (PWM_OSSUPD) Output Selection Set for PWML output of the channel 1 Position */ 1777 #define PWM_OSSUPD_OSSUPL1_Msk (_U_(0x1) << PWM_OSSUPD_OSSUPL1_Pos) /**< (PWM_OSSUPD) Output Selection Set for PWML output of the channel 1 Mask */ 1778 #define PWM_OSSUPD_OSSUPL1 PWM_OSSUPD_OSSUPL1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSSUPD_OSSUPL1_Msk instead */ 1779 #define PWM_OSSUPD_OSSUPL2_Pos 18 /**< (PWM_OSSUPD) Output Selection Set for PWML output of the channel 2 Position */ 1780 #define PWM_OSSUPD_OSSUPL2_Msk (_U_(0x1) << PWM_OSSUPD_OSSUPL2_Pos) /**< (PWM_OSSUPD) Output Selection Set for PWML output of the channel 2 Mask */ 1781 #define PWM_OSSUPD_OSSUPL2 PWM_OSSUPD_OSSUPL2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSSUPD_OSSUPL2_Msk instead */ 1782 #define PWM_OSSUPD_OSSUPL3_Pos 19 /**< (PWM_OSSUPD) Output Selection Set for PWML output of the channel 3 Position */ 1783 #define PWM_OSSUPD_OSSUPL3_Msk (_U_(0x1) << PWM_OSSUPD_OSSUPL3_Pos) /**< (PWM_OSSUPD) Output Selection Set for PWML output of the channel 3 Mask */ 1784 #define PWM_OSSUPD_OSSUPL3 PWM_OSSUPD_OSSUPL3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSSUPD_OSSUPL3_Msk instead */ 1785 #define PWM_OSSUPD_MASK _U_(0xF000F) /**< \deprecated (PWM_OSSUPD) Register MASK (Use PWM_OSSUPD_Msk instead) */ 1786 #define PWM_OSSUPD_Msk _U_(0xF000F) /**< (PWM_OSSUPD) Register Mask */ 1787 1788 #define PWM_OSSUPD_OSSUPH_Pos 0 /**< (PWM_OSSUPD Position) Output Selection Set for PWMH output of the channel x */ 1789 #define PWM_OSSUPD_OSSUPH_Msk (_U_(0xF) << PWM_OSSUPD_OSSUPH_Pos) /**< (PWM_OSSUPD Mask) OSSUPH */ 1790 #define PWM_OSSUPD_OSSUPH(value) (PWM_OSSUPD_OSSUPH_Msk & ((value) << PWM_OSSUPD_OSSUPH_Pos)) 1791 #define PWM_OSSUPD_OSSUPL_Pos 16 /**< (PWM_OSSUPD Position) Output Selection Set for PWML output of the channel 3 */ 1792 #define PWM_OSSUPD_OSSUPL_Msk (_U_(0xF) << PWM_OSSUPD_OSSUPL_Pos) /**< (PWM_OSSUPD Mask) OSSUPL */ 1793 #define PWM_OSSUPD_OSSUPL(value) (PWM_OSSUPD_OSSUPL_Msk & ((value) << PWM_OSSUPD_OSSUPL_Pos)) 1794 1795 /* -------- PWM_OSCUPD : (PWM Offset: 0x58) (/W 32) PWM Output Selection Clear Update Register -------- */ 1796 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 1797 #if COMPONENT_TYPEDEF_STYLE == 'N' 1798 typedef union { 1799 struct { 1800 uint32_t OSCUPH0:1; /**< bit: 0 Output Selection Clear for PWMH output of the channel 0 */ 1801 uint32_t OSCUPH1:1; /**< bit: 1 Output Selection Clear for PWMH output of the channel 1 */ 1802 uint32_t OSCUPH2:1; /**< bit: 2 Output Selection Clear for PWMH output of the channel 2 */ 1803 uint32_t OSCUPH3:1; /**< bit: 3 Output Selection Clear for PWMH output of the channel 3 */ 1804 uint32_t :12; /**< bit: 4..15 Reserved */ 1805 uint32_t OSCUPL0:1; /**< bit: 16 Output Selection Clear for PWML output of the channel 0 */ 1806 uint32_t OSCUPL1:1; /**< bit: 17 Output Selection Clear for PWML output of the channel 1 */ 1807 uint32_t OSCUPL2:1; /**< bit: 18 Output Selection Clear for PWML output of the channel 2 */ 1808 uint32_t OSCUPL3:1; /**< bit: 19 Output Selection Clear for PWML output of the channel 3 */ 1809 uint32_t :12; /**< bit: 20..31 Reserved */ 1810 } bit; /**< Structure used for bit access */ 1811 struct { 1812 uint32_t OSCUPH:4; /**< bit: 0..3 Output Selection Clear for PWMH output of the channel x */ 1813 uint32_t :12; /**< bit: 4..15 Reserved */ 1814 uint32_t OSCUPL:4; /**< bit: 16..19 Output Selection Clear for PWML output of the channel 3 */ 1815 uint32_t :12; /**< bit: 20..31 Reserved */ 1816 } vec; /**< Structure used for vec access */ 1817 uint32_t reg; /**< Type used for register access */ 1818 } PWM_OSCUPD_Type; 1819 #endif 1820 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 1821 1822 #define PWM_OSCUPD_OFFSET (0x58) /**< (PWM_OSCUPD) PWM Output Selection Clear Update Register Offset */ 1823 1824 #define PWM_OSCUPD_OSCUPH0_Pos 0 /**< (PWM_OSCUPD) Output Selection Clear for PWMH output of the channel 0 Position */ 1825 #define PWM_OSCUPD_OSCUPH0_Msk (_U_(0x1) << PWM_OSCUPD_OSCUPH0_Pos) /**< (PWM_OSCUPD) Output Selection Clear for PWMH output of the channel 0 Mask */ 1826 #define PWM_OSCUPD_OSCUPH0 PWM_OSCUPD_OSCUPH0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSCUPD_OSCUPH0_Msk instead */ 1827 #define PWM_OSCUPD_OSCUPH1_Pos 1 /**< (PWM_OSCUPD) Output Selection Clear for PWMH output of the channel 1 Position */ 1828 #define PWM_OSCUPD_OSCUPH1_Msk (_U_(0x1) << PWM_OSCUPD_OSCUPH1_Pos) /**< (PWM_OSCUPD) Output Selection Clear for PWMH output of the channel 1 Mask */ 1829 #define PWM_OSCUPD_OSCUPH1 PWM_OSCUPD_OSCUPH1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSCUPD_OSCUPH1_Msk instead */ 1830 #define PWM_OSCUPD_OSCUPH2_Pos 2 /**< (PWM_OSCUPD) Output Selection Clear for PWMH output of the channel 2 Position */ 1831 #define PWM_OSCUPD_OSCUPH2_Msk (_U_(0x1) << PWM_OSCUPD_OSCUPH2_Pos) /**< (PWM_OSCUPD) Output Selection Clear for PWMH output of the channel 2 Mask */ 1832 #define PWM_OSCUPD_OSCUPH2 PWM_OSCUPD_OSCUPH2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSCUPD_OSCUPH2_Msk instead */ 1833 #define PWM_OSCUPD_OSCUPH3_Pos 3 /**< (PWM_OSCUPD) Output Selection Clear for PWMH output of the channel 3 Position */ 1834 #define PWM_OSCUPD_OSCUPH3_Msk (_U_(0x1) << PWM_OSCUPD_OSCUPH3_Pos) /**< (PWM_OSCUPD) Output Selection Clear for PWMH output of the channel 3 Mask */ 1835 #define PWM_OSCUPD_OSCUPH3 PWM_OSCUPD_OSCUPH3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSCUPD_OSCUPH3_Msk instead */ 1836 #define PWM_OSCUPD_OSCUPL0_Pos 16 /**< (PWM_OSCUPD) Output Selection Clear for PWML output of the channel 0 Position */ 1837 #define PWM_OSCUPD_OSCUPL0_Msk (_U_(0x1) << PWM_OSCUPD_OSCUPL0_Pos) /**< (PWM_OSCUPD) Output Selection Clear for PWML output of the channel 0 Mask */ 1838 #define PWM_OSCUPD_OSCUPL0 PWM_OSCUPD_OSCUPL0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSCUPD_OSCUPL0_Msk instead */ 1839 #define PWM_OSCUPD_OSCUPL1_Pos 17 /**< (PWM_OSCUPD) Output Selection Clear for PWML output of the channel 1 Position */ 1840 #define PWM_OSCUPD_OSCUPL1_Msk (_U_(0x1) << PWM_OSCUPD_OSCUPL1_Pos) /**< (PWM_OSCUPD) Output Selection Clear for PWML output of the channel 1 Mask */ 1841 #define PWM_OSCUPD_OSCUPL1 PWM_OSCUPD_OSCUPL1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSCUPD_OSCUPL1_Msk instead */ 1842 #define PWM_OSCUPD_OSCUPL2_Pos 18 /**< (PWM_OSCUPD) Output Selection Clear for PWML output of the channel 2 Position */ 1843 #define PWM_OSCUPD_OSCUPL2_Msk (_U_(0x1) << PWM_OSCUPD_OSCUPL2_Pos) /**< (PWM_OSCUPD) Output Selection Clear for PWML output of the channel 2 Mask */ 1844 #define PWM_OSCUPD_OSCUPL2 PWM_OSCUPD_OSCUPL2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSCUPD_OSCUPL2_Msk instead */ 1845 #define PWM_OSCUPD_OSCUPL3_Pos 19 /**< (PWM_OSCUPD) Output Selection Clear for PWML output of the channel 3 Position */ 1846 #define PWM_OSCUPD_OSCUPL3_Msk (_U_(0x1) << PWM_OSCUPD_OSCUPL3_Pos) /**< (PWM_OSCUPD) Output Selection Clear for PWML output of the channel 3 Mask */ 1847 #define PWM_OSCUPD_OSCUPL3 PWM_OSCUPD_OSCUPL3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_OSCUPD_OSCUPL3_Msk instead */ 1848 #define PWM_OSCUPD_MASK _U_(0xF000F) /**< \deprecated (PWM_OSCUPD) Register MASK (Use PWM_OSCUPD_Msk instead) */ 1849 #define PWM_OSCUPD_Msk _U_(0xF000F) /**< (PWM_OSCUPD) Register Mask */ 1850 1851 #define PWM_OSCUPD_OSCUPH_Pos 0 /**< (PWM_OSCUPD Position) Output Selection Clear for PWMH output of the channel x */ 1852 #define PWM_OSCUPD_OSCUPH_Msk (_U_(0xF) << PWM_OSCUPD_OSCUPH_Pos) /**< (PWM_OSCUPD Mask) OSCUPH */ 1853 #define PWM_OSCUPD_OSCUPH(value) (PWM_OSCUPD_OSCUPH_Msk & ((value) << PWM_OSCUPD_OSCUPH_Pos)) 1854 #define PWM_OSCUPD_OSCUPL_Pos 16 /**< (PWM_OSCUPD Position) Output Selection Clear for PWML output of the channel 3 */ 1855 #define PWM_OSCUPD_OSCUPL_Msk (_U_(0xF) << PWM_OSCUPD_OSCUPL_Pos) /**< (PWM_OSCUPD Mask) OSCUPL */ 1856 #define PWM_OSCUPD_OSCUPL(value) (PWM_OSCUPD_OSCUPL_Msk & ((value) << PWM_OSCUPD_OSCUPL_Pos)) 1857 1858 /* -------- PWM_FMR : (PWM Offset: 0x5c) (R/W 32) PWM Fault Mode Register -------- */ 1859 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 1860 #if COMPONENT_TYPEDEF_STYLE == 'N' 1861 typedef union { 1862 struct { 1863 uint32_t FPOL:8; /**< bit: 0..7 Fault Polarity */ 1864 uint32_t FMOD:8; /**< bit: 8..15 Fault Activation Mode */ 1865 uint32_t FFIL:8; /**< bit: 16..23 Fault Filtering */ 1866 uint32_t :8; /**< bit: 24..31 Reserved */ 1867 } bit; /**< Structure used for bit access */ 1868 uint32_t reg; /**< Type used for register access */ 1869 } PWM_FMR_Type; 1870 #endif 1871 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 1872 1873 #define PWM_FMR_OFFSET (0x5C) /**< (PWM_FMR) PWM Fault Mode Register Offset */ 1874 1875 #define PWM_FMR_FPOL_Pos 0 /**< (PWM_FMR) Fault Polarity Position */ 1876 #define PWM_FMR_FPOL_Msk (_U_(0xFF) << PWM_FMR_FPOL_Pos) /**< (PWM_FMR) Fault Polarity Mask */ 1877 #define PWM_FMR_FPOL(value) (PWM_FMR_FPOL_Msk & ((value) << PWM_FMR_FPOL_Pos)) 1878 #define PWM_FMR_FMOD_Pos 8 /**< (PWM_FMR) Fault Activation Mode Position */ 1879 #define PWM_FMR_FMOD_Msk (_U_(0xFF) << PWM_FMR_FMOD_Pos) /**< (PWM_FMR) Fault Activation Mode Mask */ 1880 #define PWM_FMR_FMOD(value) (PWM_FMR_FMOD_Msk & ((value) << PWM_FMR_FMOD_Pos)) 1881 #define PWM_FMR_FFIL_Pos 16 /**< (PWM_FMR) Fault Filtering Position */ 1882 #define PWM_FMR_FFIL_Msk (_U_(0xFF) << PWM_FMR_FFIL_Pos) /**< (PWM_FMR) Fault Filtering Mask */ 1883 #define PWM_FMR_FFIL(value) (PWM_FMR_FFIL_Msk & ((value) << PWM_FMR_FFIL_Pos)) 1884 #define PWM_FMR_MASK _U_(0xFFFFFF) /**< \deprecated (PWM_FMR) Register MASK (Use PWM_FMR_Msk instead) */ 1885 #define PWM_FMR_Msk _U_(0xFFFFFF) /**< (PWM_FMR) Register Mask */ 1886 1887 1888 /* -------- PWM_FSR : (PWM Offset: 0x60) (R/ 32) PWM Fault Status Register -------- */ 1889 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 1890 #if COMPONENT_TYPEDEF_STYLE == 'N' 1891 typedef union { 1892 struct { 1893 uint32_t FIV:8; /**< bit: 0..7 Fault Input Value */ 1894 uint32_t FS:8; /**< bit: 8..15 Fault Status */ 1895 uint32_t :16; /**< bit: 16..31 Reserved */ 1896 } bit; /**< Structure used for bit access */ 1897 uint32_t reg; /**< Type used for register access */ 1898 } PWM_FSR_Type; 1899 #endif 1900 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 1901 1902 #define PWM_FSR_OFFSET (0x60) /**< (PWM_FSR) PWM Fault Status Register Offset */ 1903 1904 #define PWM_FSR_FIV_Pos 0 /**< (PWM_FSR) Fault Input Value Position */ 1905 #define PWM_FSR_FIV_Msk (_U_(0xFF) << PWM_FSR_FIV_Pos) /**< (PWM_FSR) Fault Input Value Mask */ 1906 #define PWM_FSR_FIV(value) (PWM_FSR_FIV_Msk & ((value) << PWM_FSR_FIV_Pos)) 1907 #define PWM_FSR_FS_Pos 8 /**< (PWM_FSR) Fault Status Position */ 1908 #define PWM_FSR_FS_Msk (_U_(0xFF) << PWM_FSR_FS_Pos) /**< (PWM_FSR) Fault Status Mask */ 1909 #define PWM_FSR_FS(value) (PWM_FSR_FS_Msk & ((value) << PWM_FSR_FS_Pos)) 1910 #define PWM_FSR_MASK _U_(0xFFFF) /**< \deprecated (PWM_FSR) Register MASK (Use PWM_FSR_Msk instead) */ 1911 #define PWM_FSR_Msk _U_(0xFFFF) /**< (PWM_FSR) Register Mask */ 1912 1913 1914 /* -------- PWM_FCR : (PWM Offset: 0x64) (/W 32) PWM Fault Clear Register -------- */ 1915 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 1916 #if COMPONENT_TYPEDEF_STYLE == 'N' 1917 typedef union { 1918 struct { 1919 uint32_t FCLR:8; /**< bit: 0..7 Fault Clear */ 1920 uint32_t :24; /**< bit: 8..31 Reserved */ 1921 } bit; /**< Structure used for bit access */ 1922 uint32_t reg; /**< Type used for register access */ 1923 } PWM_FCR_Type; 1924 #endif 1925 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 1926 1927 #define PWM_FCR_OFFSET (0x64) /**< (PWM_FCR) PWM Fault Clear Register Offset */ 1928 1929 #define PWM_FCR_FCLR_Pos 0 /**< (PWM_FCR) Fault Clear Position */ 1930 #define PWM_FCR_FCLR_Msk (_U_(0xFF) << PWM_FCR_FCLR_Pos) /**< (PWM_FCR) Fault Clear Mask */ 1931 #define PWM_FCR_FCLR(value) (PWM_FCR_FCLR_Msk & ((value) << PWM_FCR_FCLR_Pos)) 1932 #define PWM_FCR_MASK _U_(0xFF) /**< \deprecated (PWM_FCR) Register MASK (Use PWM_FCR_Msk instead) */ 1933 #define PWM_FCR_Msk _U_(0xFF) /**< (PWM_FCR) Register Mask */ 1934 1935 1936 /* -------- PWM_FPV1 : (PWM Offset: 0x68) (R/W 32) PWM Fault Protection Value Register 1 -------- */ 1937 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 1938 #if COMPONENT_TYPEDEF_STYLE == 'N' 1939 typedef union { 1940 struct { 1941 uint32_t FPVH0:1; /**< bit: 0 Fault Protection Value for PWMH output on channel 0 */ 1942 uint32_t FPVH1:1; /**< bit: 1 Fault Protection Value for PWMH output on channel 1 */ 1943 uint32_t FPVH2:1; /**< bit: 2 Fault Protection Value for PWMH output on channel 2 */ 1944 uint32_t FPVH3:1; /**< bit: 3 Fault Protection Value for PWMH output on channel 3 */ 1945 uint32_t :12; /**< bit: 4..15 Reserved */ 1946 uint32_t FPVL0:1; /**< bit: 16 Fault Protection Value for PWML output on channel 0 */ 1947 uint32_t FPVL1:1; /**< bit: 17 Fault Protection Value for PWML output on channel 1 */ 1948 uint32_t FPVL2:1; /**< bit: 18 Fault Protection Value for PWML output on channel 2 */ 1949 uint32_t FPVL3:1; /**< bit: 19 Fault Protection Value for PWML output on channel 3 */ 1950 uint32_t :12; /**< bit: 20..31 Reserved */ 1951 } bit; /**< Structure used for bit access */ 1952 struct { 1953 uint32_t FPVH:4; /**< bit: 0..3 Fault Protection Value for PWMH output on channel x */ 1954 uint32_t :12; /**< bit: 4..15 Reserved */ 1955 uint32_t FPVL:4; /**< bit: 16..19 Fault Protection Value for PWML output on channel 3 */ 1956 uint32_t :12; /**< bit: 20..31 Reserved */ 1957 } vec; /**< Structure used for vec access */ 1958 uint32_t reg; /**< Type used for register access */ 1959 } PWM_FPV1_Type; 1960 #endif 1961 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 1962 1963 #define PWM_FPV1_OFFSET (0x68) /**< (PWM_FPV1) PWM Fault Protection Value Register 1 Offset */ 1964 1965 #define PWM_FPV1_FPVH0_Pos 0 /**< (PWM_FPV1) Fault Protection Value for PWMH output on channel 0 Position */ 1966 #define PWM_FPV1_FPVH0_Msk (_U_(0x1) << PWM_FPV1_FPVH0_Pos) /**< (PWM_FPV1) Fault Protection Value for PWMH output on channel 0 Mask */ 1967 #define PWM_FPV1_FPVH0 PWM_FPV1_FPVH0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_FPV1_FPVH0_Msk instead */ 1968 #define PWM_FPV1_FPVH1_Pos 1 /**< (PWM_FPV1) Fault Protection Value for PWMH output on channel 1 Position */ 1969 #define PWM_FPV1_FPVH1_Msk (_U_(0x1) << PWM_FPV1_FPVH1_Pos) /**< (PWM_FPV1) Fault Protection Value for PWMH output on channel 1 Mask */ 1970 #define PWM_FPV1_FPVH1 PWM_FPV1_FPVH1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_FPV1_FPVH1_Msk instead */ 1971 #define PWM_FPV1_FPVH2_Pos 2 /**< (PWM_FPV1) Fault Protection Value for PWMH output on channel 2 Position */ 1972 #define PWM_FPV1_FPVH2_Msk (_U_(0x1) << PWM_FPV1_FPVH2_Pos) /**< (PWM_FPV1) Fault Protection Value for PWMH output on channel 2 Mask */ 1973 #define PWM_FPV1_FPVH2 PWM_FPV1_FPVH2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_FPV1_FPVH2_Msk instead */ 1974 #define PWM_FPV1_FPVH3_Pos 3 /**< (PWM_FPV1) Fault Protection Value for PWMH output on channel 3 Position */ 1975 #define PWM_FPV1_FPVH3_Msk (_U_(0x1) << PWM_FPV1_FPVH3_Pos) /**< (PWM_FPV1) Fault Protection Value for PWMH output on channel 3 Mask */ 1976 #define PWM_FPV1_FPVH3 PWM_FPV1_FPVH3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_FPV1_FPVH3_Msk instead */ 1977 #define PWM_FPV1_FPVL0_Pos 16 /**< (PWM_FPV1) Fault Protection Value for PWML output on channel 0 Position */ 1978 #define PWM_FPV1_FPVL0_Msk (_U_(0x1) << PWM_FPV1_FPVL0_Pos) /**< (PWM_FPV1) Fault Protection Value for PWML output on channel 0 Mask */ 1979 #define PWM_FPV1_FPVL0 PWM_FPV1_FPVL0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_FPV1_FPVL0_Msk instead */ 1980 #define PWM_FPV1_FPVL1_Pos 17 /**< (PWM_FPV1) Fault Protection Value for PWML output on channel 1 Position */ 1981 #define PWM_FPV1_FPVL1_Msk (_U_(0x1) << PWM_FPV1_FPVL1_Pos) /**< (PWM_FPV1) Fault Protection Value for PWML output on channel 1 Mask */ 1982 #define PWM_FPV1_FPVL1 PWM_FPV1_FPVL1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_FPV1_FPVL1_Msk instead */ 1983 #define PWM_FPV1_FPVL2_Pos 18 /**< (PWM_FPV1) Fault Protection Value for PWML output on channel 2 Position */ 1984 #define PWM_FPV1_FPVL2_Msk (_U_(0x1) << PWM_FPV1_FPVL2_Pos) /**< (PWM_FPV1) Fault Protection Value for PWML output on channel 2 Mask */ 1985 #define PWM_FPV1_FPVL2 PWM_FPV1_FPVL2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_FPV1_FPVL2_Msk instead */ 1986 #define PWM_FPV1_FPVL3_Pos 19 /**< (PWM_FPV1) Fault Protection Value for PWML output on channel 3 Position */ 1987 #define PWM_FPV1_FPVL3_Msk (_U_(0x1) << PWM_FPV1_FPVL3_Pos) /**< (PWM_FPV1) Fault Protection Value for PWML output on channel 3 Mask */ 1988 #define PWM_FPV1_FPVL3 PWM_FPV1_FPVL3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_FPV1_FPVL3_Msk instead */ 1989 #define PWM_FPV1_MASK _U_(0xF000F) /**< \deprecated (PWM_FPV1) Register MASK (Use PWM_FPV1_Msk instead) */ 1990 #define PWM_FPV1_Msk _U_(0xF000F) /**< (PWM_FPV1) Register Mask */ 1991 1992 #define PWM_FPV1_FPVH_Pos 0 /**< (PWM_FPV1 Position) Fault Protection Value for PWMH output on channel x */ 1993 #define PWM_FPV1_FPVH_Msk (_U_(0xF) << PWM_FPV1_FPVH_Pos) /**< (PWM_FPV1 Mask) FPVH */ 1994 #define PWM_FPV1_FPVH(value) (PWM_FPV1_FPVH_Msk & ((value) << PWM_FPV1_FPVH_Pos)) 1995 #define PWM_FPV1_FPVL_Pos 16 /**< (PWM_FPV1 Position) Fault Protection Value for PWML output on channel 3 */ 1996 #define PWM_FPV1_FPVL_Msk (_U_(0xF) << PWM_FPV1_FPVL_Pos) /**< (PWM_FPV1 Mask) FPVL */ 1997 #define PWM_FPV1_FPVL(value) (PWM_FPV1_FPVL_Msk & ((value) << PWM_FPV1_FPVL_Pos)) 1998 1999 /* -------- PWM_FPE : (PWM Offset: 0x6c) (R/W 32) PWM Fault Protection Enable Register -------- */ 2000 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 2001 #if COMPONENT_TYPEDEF_STYLE == 'N' 2002 typedef union { 2003 struct { 2004 uint32_t FPE0:8; /**< bit: 0..7 Fault Protection Enable for channel 0 */ 2005 uint32_t FPE1:8; /**< bit: 8..15 Fault Protection Enable for channel 1 */ 2006 uint32_t FPE2:8; /**< bit: 16..23 Fault Protection Enable for channel 2 */ 2007 uint32_t FPE3:8; /**< bit: 24..31 Fault Protection Enable for channel 3 */ 2008 } bit; /**< Structure used for bit access */ 2009 uint32_t reg; /**< Type used for register access */ 2010 } PWM_FPE_Type; 2011 #endif 2012 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 2013 2014 #define PWM_FPE_OFFSET (0x6C) /**< (PWM_FPE) PWM Fault Protection Enable Register Offset */ 2015 2016 #define PWM_FPE_FPE0_Pos 0 /**< (PWM_FPE) Fault Protection Enable for channel 0 Position */ 2017 #define PWM_FPE_FPE0_Msk (_U_(0xFF) << PWM_FPE_FPE0_Pos) /**< (PWM_FPE) Fault Protection Enable for channel 0 Mask */ 2018 #define PWM_FPE_FPE0(value) (PWM_FPE_FPE0_Msk & ((value) << PWM_FPE_FPE0_Pos)) 2019 #define PWM_FPE_FPE1_Pos 8 /**< (PWM_FPE) Fault Protection Enable for channel 1 Position */ 2020 #define PWM_FPE_FPE1_Msk (_U_(0xFF) << PWM_FPE_FPE1_Pos) /**< (PWM_FPE) Fault Protection Enable for channel 1 Mask */ 2021 #define PWM_FPE_FPE1(value) (PWM_FPE_FPE1_Msk & ((value) << PWM_FPE_FPE1_Pos)) 2022 #define PWM_FPE_FPE2_Pos 16 /**< (PWM_FPE) Fault Protection Enable for channel 2 Position */ 2023 #define PWM_FPE_FPE2_Msk (_U_(0xFF) << PWM_FPE_FPE2_Pos) /**< (PWM_FPE) Fault Protection Enable for channel 2 Mask */ 2024 #define PWM_FPE_FPE2(value) (PWM_FPE_FPE2_Msk & ((value) << PWM_FPE_FPE2_Pos)) 2025 #define PWM_FPE_FPE3_Pos 24 /**< (PWM_FPE) Fault Protection Enable for channel 3 Position */ 2026 #define PWM_FPE_FPE3_Msk (_U_(0xFF) << PWM_FPE_FPE3_Pos) /**< (PWM_FPE) Fault Protection Enable for channel 3 Mask */ 2027 #define PWM_FPE_FPE3(value) (PWM_FPE_FPE3_Msk & ((value) << PWM_FPE_FPE3_Pos)) 2028 #define PWM_FPE_MASK _U_(0xFFFFFFFF) /**< \deprecated (PWM_FPE) Register MASK (Use PWM_FPE_Msk instead) */ 2029 #define PWM_FPE_Msk _U_(0xFFFFFFFF) /**< (PWM_FPE) Register Mask */ 2030 2031 2032 /* -------- PWM_ELMR : (PWM Offset: 0x7c) (R/W 32) PWM Event Line 0 Mode Register 0 -------- */ 2033 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 2034 #if COMPONENT_TYPEDEF_STYLE == 'N' 2035 typedef union { 2036 struct { 2037 uint32_t CSEL0:1; /**< bit: 0 Comparison 0 Selection */ 2038 uint32_t CSEL1:1; /**< bit: 1 Comparison 1 Selection */ 2039 uint32_t CSEL2:1; /**< bit: 2 Comparison 2 Selection */ 2040 uint32_t CSEL3:1; /**< bit: 3 Comparison 3 Selection */ 2041 uint32_t CSEL4:1; /**< bit: 4 Comparison 4 Selection */ 2042 uint32_t CSEL5:1; /**< bit: 5 Comparison 5 Selection */ 2043 uint32_t CSEL6:1; /**< bit: 6 Comparison 6 Selection */ 2044 uint32_t CSEL7:1; /**< bit: 7 Comparison 7 Selection */ 2045 uint32_t :24; /**< bit: 8..31 Reserved */ 2046 } bit; /**< Structure used for bit access */ 2047 struct { 2048 uint32_t CSEL:8; /**< bit: 0..7 Comparison 7 Selection */ 2049 uint32_t :24; /**< bit: 8..31 Reserved */ 2050 } vec; /**< Structure used for vec access */ 2051 uint32_t reg; /**< Type used for register access */ 2052 } PWM_ELMR_Type; 2053 #endif 2054 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 2055 2056 #define PWM_ELMR_OFFSET (0x7C) /**< (PWM_ELMR) PWM Event Line 0 Mode Register 0 Offset */ 2057 2058 #define PWM_ELMR_CSEL0_Pos 0 /**< (PWM_ELMR) Comparison 0 Selection Position */ 2059 #define PWM_ELMR_CSEL0_Msk (_U_(0x1) << PWM_ELMR_CSEL0_Pos) /**< (PWM_ELMR) Comparison 0 Selection Mask */ 2060 #define PWM_ELMR_CSEL0 PWM_ELMR_CSEL0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ELMR_CSEL0_Msk instead */ 2061 #define PWM_ELMR_CSEL1_Pos 1 /**< (PWM_ELMR) Comparison 1 Selection Position */ 2062 #define PWM_ELMR_CSEL1_Msk (_U_(0x1) << PWM_ELMR_CSEL1_Pos) /**< (PWM_ELMR) Comparison 1 Selection Mask */ 2063 #define PWM_ELMR_CSEL1 PWM_ELMR_CSEL1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ELMR_CSEL1_Msk instead */ 2064 #define PWM_ELMR_CSEL2_Pos 2 /**< (PWM_ELMR) Comparison 2 Selection Position */ 2065 #define PWM_ELMR_CSEL2_Msk (_U_(0x1) << PWM_ELMR_CSEL2_Pos) /**< (PWM_ELMR) Comparison 2 Selection Mask */ 2066 #define PWM_ELMR_CSEL2 PWM_ELMR_CSEL2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ELMR_CSEL2_Msk instead */ 2067 #define PWM_ELMR_CSEL3_Pos 3 /**< (PWM_ELMR) Comparison 3 Selection Position */ 2068 #define PWM_ELMR_CSEL3_Msk (_U_(0x1) << PWM_ELMR_CSEL3_Pos) /**< (PWM_ELMR) Comparison 3 Selection Mask */ 2069 #define PWM_ELMR_CSEL3 PWM_ELMR_CSEL3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ELMR_CSEL3_Msk instead */ 2070 #define PWM_ELMR_CSEL4_Pos 4 /**< (PWM_ELMR) Comparison 4 Selection Position */ 2071 #define PWM_ELMR_CSEL4_Msk (_U_(0x1) << PWM_ELMR_CSEL4_Pos) /**< (PWM_ELMR) Comparison 4 Selection Mask */ 2072 #define PWM_ELMR_CSEL4 PWM_ELMR_CSEL4_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ELMR_CSEL4_Msk instead */ 2073 #define PWM_ELMR_CSEL5_Pos 5 /**< (PWM_ELMR) Comparison 5 Selection Position */ 2074 #define PWM_ELMR_CSEL5_Msk (_U_(0x1) << PWM_ELMR_CSEL5_Pos) /**< (PWM_ELMR) Comparison 5 Selection Mask */ 2075 #define PWM_ELMR_CSEL5 PWM_ELMR_CSEL5_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ELMR_CSEL5_Msk instead */ 2076 #define PWM_ELMR_CSEL6_Pos 6 /**< (PWM_ELMR) Comparison 6 Selection Position */ 2077 #define PWM_ELMR_CSEL6_Msk (_U_(0x1) << PWM_ELMR_CSEL6_Pos) /**< (PWM_ELMR) Comparison 6 Selection Mask */ 2078 #define PWM_ELMR_CSEL6 PWM_ELMR_CSEL6_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ELMR_CSEL6_Msk instead */ 2079 #define PWM_ELMR_CSEL7_Pos 7 /**< (PWM_ELMR) Comparison 7 Selection Position */ 2080 #define PWM_ELMR_CSEL7_Msk (_U_(0x1) << PWM_ELMR_CSEL7_Pos) /**< (PWM_ELMR) Comparison 7 Selection Mask */ 2081 #define PWM_ELMR_CSEL7 PWM_ELMR_CSEL7_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ELMR_CSEL7_Msk instead */ 2082 #define PWM_ELMR_MASK _U_(0xFF) /**< \deprecated (PWM_ELMR) Register MASK (Use PWM_ELMR_Msk instead) */ 2083 #define PWM_ELMR_Msk _U_(0xFF) /**< (PWM_ELMR) Register Mask */ 2084 2085 #define PWM_ELMR_CSEL_Pos 0 /**< (PWM_ELMR Position) Comparison 7 Selection */ 2086 #define PWM_ELMR_CSEL_Msk (_U_(0xFF) << PWM_ELMR_CSEL_Pos) /**< (PWM_ELMR Mask) CSEL */ 2087 #define PWM_ELMR_CSEL(value) (PWM_ELMR_CSEL_Msk & ((value) << PWM_ELMR_CSEL_Pos)) 2088 2089 /* -------- PWM_SSPR : (PWM Offset: 0xa0) (R/W 32) PWM Spread Spectrum Register -------- */ 2090 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 2091 #if COMPONENT_TYPEDEF_STYLE == 'N' 2092 typedef union { 2093 struct { 2094 uint32_t SPRD:24; /**< bit: 0..23 Spread Spectrum Limit Value */ 2095 uint32_t SPRDM:1; /**< bit: 24 Spread Spectrum Counter Mode */ 2096 uint32_t :7; /**< bit: 25..31 Reserved */ 2097 } bit; /**< Structure used for bit access */ 2098 uint32_t reg; /**< Type used for register access */ 2099 } PWM_SSPR_Type; 2100 #endif 2101 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 2102 2103 #define PWM_SSPR_OFFSET (0xA0) /**< (PWM_SSPR) PWM Spread Spectrum Register Offset */ 2104 2105 #define PWM_SSPR_SPRD_Pos 0 /**< (PWM_SSPR) Spread Spectrum Limit Value Position */ 2106 #define PWM_SSPR_SPRD_Msk (_U_(0xFFFFFF) << PWM_SSPR_SPRD_Pos) /**< (PWM_SSPR) Spread Spectrum Limit Value Mask */ 2107 #define PWM_SSPR_SPRD(value) (PWM_SSPR_SPRD_Msk & ((value) << PWM_SSPR_SPRD_Pos)) 2108 #define PWM_SSPR_SPRDM_Pos 24 /**< (PWM_SSPR) Spread Spectrum Counter Mode Position */ 2109 #define PWM_SSPR_SPRDM_Msk (_U_(0x1) << PWM_SSPR_SPRDM_Pos) /**< (PWM_SSPR) Spread Spectrum Counter Mode Mask */ 2110 #define PWM_SSPR_SPRDM PWM_SSPR_SPRDM_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_SSPR_SPRDM_Msk instead */ 2111 #define PWM_SSPR_MASK _U_(0x1FFFFFF) /**< \deprecated (PWM_SSPR) Register MASK (Use PWM_SSPR_Msk instead) */ 2112 #define PWM_SSPR_Msk _U_(0x1FFFFFF) /**< (PWM_SSPR) Register Mask */ 2113 2114 2115 /* -------- PWM_SSPUP : (PWM Offset: 0xa4) (/W 32) PWM Spread Spectrum Update Register -------- */ 2116 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 2117 #if COMPONENT_TYPEDEF_STYLE == 'N' 2118 typedef union { 2119 struct { 2120 uint32_t SPRDUP:24; /**< bit: 0..23 Spread Spectrum Limit Value Update */ 2121 uint32_t :8; /**< bit: 24..31 Reserved */ 2122 } bit; /**< Structure used for bit access */ 2123 uint32_t reg; /**< Type used for register access */ 2124 } PWM_SSPUP_Type; 2125 #endif 2126 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 2127 2128 #define PWM_SSPUP_OFFSET (0xA4) /**< (PWM_SSPUP) PWM Spread Spectrum Update Register Offset */ 2129 2130 #define PWM_SSPUP_SPRDUP_Pos 0 /**< (PWM_SSPUP) Spread Spectrum Limit Value Update Position */ 2131 #define PWM_SSPUP_SPRDUP_Msk (_U_(0xFFFFFF) << PWM_SSPUP_SPRDUP_Pos) /**< (PWM_SSPUP) Spread Spectrum Limit Value Update Mask */ 2132 #define PWM_SSPUP_SPRDUP(value) (PWM_SSPUP_SPRDUP_Msk & ((value) << PWM_SSPUP_SPRDUP_Pos)) 2133 #define PWM_SSPUP_MASK _U_(0xFFFFFF) /**< \deprecated (PWM_SSPUP) Register MASK (Use PWM_SSPUP_Msk instead) */ 2134 #define PWM_SSPUP_Msk _U_(0xFFFFFF) /**< (PWM_SSPUP) Register Mask */ 2135 2136 2137 /* -------- PWM_SMMR : (PWM Offset: 0xb0) (R/W 32) PWM Stepper Motor Mode Register -------- */ 2138 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 2139 #if COMPONENT_TYPEDEF_STYLE == 'N' 2140 typedef union { 2141 struct { 2142 uint32_t GCEN0:1; /**< bit: 0 Gray Count ENable */ 2143 uint32_t GCEN1:1; /**< bit: 1 Gray Count ENable */ 2144 uint32_t :14; /**< bit: 2..15 Reserved */ 2145 uint32_t DOWN0:1; /**< bit: 16 DOWN Count */ 2146 uint32_t DOWN1:1; /**< bit: 17 DOWN Count */ 2147 uint32_t :14; /**< bit: 18..31 Reserved */ 2148 } bit; /**< Structure used for bit access */ 2149 struct { 2150 uint32_t GCEN:2; /**< bit: 0..1 Gray Count ENable */ 2151 uint32_t :14; /**< bit: 2..15 Reserved */ 2152 uint32_t DOWN:2; /**< bit: 16..17 DOWN Count */ 2153 uint32_t :14; /**< bit: 18..31 Reserved */ 2154 } vec; /**< Structure used for vec access */ 2155 uint32_t reg; /**< Type used for register access */ 2156 } PWM_SMMR_Type; 2157 #endif 2158 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 2159 2160 #define PWM_SMMR_OFFSET (0xB0) /**< (PWM_SMMR) PWM Stepper Motor Mode Register Offset */ 2161 2162 #define PWM_SMMR_GCEN0_Pos 0 /**< (PWM_SMMR) Gray Count ENable Position */ 2163 #define PWM_SMMR_GCEN0_Msk (_U_(0x1) << PWM_SMMR_GCEN0_Pos) /**< (PWM_SMMR) Gray Count ENable Mask */ 2164 #define PWM_SMMR_GCEN0 PWM_SMMR_GCEN0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_SMMR_GCEN0_Msk instead */ 2165 #define PWM_SMMR_GCEN1_Pos 1 /**< (PWM_SMMR) Gray Count ENable Position */ 2166 #define PWM_SMMR_GCEN1_Msk (_U_(0x1) << PWM_SMMR_GCEN1_Pos) /**< (PWM_SMMR) Gray Count ENable Mask */ 2167 #define PWM_SMMR_GCEN1 PWM_SMMR_GCEN1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_SMMR_GCEN1_Msk instead */ 2168 #define PWM_SMMR_DOWN0_Pos 16 /**< (PWM_SMMR) DOWN Count Position */ 2169 #define PWM_SMMR_DOWN0_Msk (_U_(0x1) << PWM_SMMR_DOWN0_Pos) /**< (PWM_SMMR) DOWN Count Mask */ 2170 #define PWM_SMMR_DOWN0 PWM_SMMR_DOWN0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_SMMR_DOWN0_Msk instead */ 2171 #define PWM_SMMR_DOWN1_Pos 17 /**< (PWM_SMMR) DOWN Count Position */ 2172 #define PWM_SMMR_DOWN1_Msk (_U_(0x1) << PWM_SMMR_DOWN1_Pos) /**< (PWM_SMMR) DOWN Count Mask */ 2173 #define PWM_SMMR_DOWN1 PWM_SMMR_DOWN1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_SMMR_DOWN1_Msk instead */ 2174 #define PWM_SMMR_MASK _U_(0x30003) /**< \deprecated (PWM_SMMR) Register MASK (Use PWM_SMMR_Msk instead) */ 2175 #define PWM_SMMR_Msk _U_(0x30003) /**< (PWM_SMMR) Register Mask */ 2176 2177 #define PWM_SMMR_GCEN_Pos 0 /**< (PWM_SMMR Position) Gray Count ENable */ 2178 #define PWM_SMMR_GCEN_Msk (_U_(0x3) << PWM_SMMR_GCEN_Pos) /**< (PWM_SMMR Mask) GCEN */ 2179 #define PWM_SMMR_GCEN(value) (PWM_SMMR_GCEN_Msk & ((value) << PWM_SMMR_GCEN_Pos)) 2180 #define PWM_SMMR_DOWN_Pos 16 /**< (PWM_SMMR Position) DOWN Count */ 2181 #define PWM_SMMR_DOWN_Msk (_U_(0x3) << PWM_SMMR_DOWN_Pos) /**< (PWM_SMMR Mask) DOWN */ 2182 #define PWM_SMMR_DOWN(value) (PWM_SMMR_DOWN_Msk & ((value) << PWM_SMMR_DOWN_Pos)) 2183 2184 /* -------- PWM_FPV2 : (PWM Offset: 0xc0) (R/W 32) PWM Fault Protection Value 2 Register -------- */ 2185 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 2186 #if COMPONENT_TYPEDEF_STYLE == 'N' 2187 typedef union { 2188 struct { 2189 uint32_t FPZH0:1; /**< bit: 0 Fault Protection to Hi-Z for PWMH output on channel 0 */ 2190 uint32_t FPZH1:1; /**< bit: 1 Fault Protection to Hi-Z for PWMH output on channel 1 */ 2191 uint32_t FPZH2:1; /**< bit: 2 Fault Protection to Hi-Z for PWMH output on channel 2 */ 2192 uint32_t FPZH3:1; /**< bit: 3 Fault Protection to Hi-Z for PWMH output on channel 3 */ 2193 uint32_t :12; /**< bit: 4..15 Reserved */ 2194 uint32_t FPZL0:1; /**< bit: 16 Fault Protection to Hi-Z for PWML output on channel 0 */ 2195 uint32_t FPZL1:1; /**< bit: 17 Fault Protection to Hi-Z for PWML output on channel 1 */ 2196 uint32_t FPZL2:1; /**< bit: 18 Fault Protection to Hi-Z for PWML output on channel 2 */ 2197 uint32_t FPZL3:1; /**< bit: 19 Fault Protection to Hi-Z for PWML output on channel 3 */ 2198 uint32_t :12; /**< bit: 20..31 Reserved */ 2199 } bit; /**< Structure used for bit access */ 2200 struct { 2201 uint32_t FPZH:4; /**< bit: 0..3 Fault Protection to Hi-Z for PWMH output on channel x */ 2202 uint32_t :12; /**< bit: 4..15 Reserved */ 2203 uint32_t FPZL:4; /**< bit: 16..19 Fault Protection to Hi-Z for PWML output on channel 3 */ 2204 uint32_t :12; /**< bit: 20..31 Reserved */ 2205 } vec; /**< Structure used for vec access */ 2206 uint32_t reg; /**< Type used for register access */ 2207 } PWM_FPV2_Type; 2208 #endif 2209 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 2210 2211 #define PWM_FPV2_OFFSET (0xC0) /**< (PWM_FPV2) PWM Fault Protection Value 2 Register Offset */ 2212 2213 #define PWM_FPV2_FPZH0_Pos 0 /**< (PWM_FPV2) Fault Protection to Hi-Z for PWMH output on channel 0 Position */ 2214 #define PWM_FPV2_FPZH0_Msk (_U_(0x1) << PWM_FPV2_FPZH0_Pos) /**< (PWM_FPV2) Fault Protection to Hi-Z for PWMH output on channel 0 Mask */ 2215 #define PWM_FPV2_FPZH0 PWM_FPV2_FPZH0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_FPV2_FPZH0_Msk instead */ 2216 #define PWM_FPV2_FPZH1_Pos 1 /**< (PWM_FPV2) Fault Protection to Hi-Z for PWMH output on channel 1 Position */ 2217 #define PWM_FPV2_FPZH1_Msk (_U_(0x1) << PWM_FPV2_FPZH1_Pos) /**< (PWM_FPV2) Fault Protection to Hi-Z for PWMH output on channel 1 Mask */ 2218 #define PWM_FPV2_FPZH1 PWM_FPV2_FPZH1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_FPV2_FPZH1_Msk instead */ 2219 #define PWM_FPV2_FPZH2_Pos 2 /**< (PWM_FPV2) Fault Protection to Hi-Z for PWMH output on channel 2 Position */ 2220 #define PWM_FPV2_FPZH2_Msk (_U_(0x1) << PWM_FPV2_FPZH2_Pos) /**< (PWM_FPV2) Fault Protection to Hi-Z for PWMH output on channel 2 Mask */ 2221 #define PWM_FPV2_FPZH2 PWM_FPV2_FPZH2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_FPV2_FPZH2_Msk instead */ 2222 #define PWM_FPV2_FPZH3_Pos 3 /**< (PWM_FPV2) Fault Protection to Hi-Z for PWMH output on channel 3 Position */ 2223 #define PWM_FPV2_FPZH3_Msk (_U_(0x1) << PWM_FPV2_FPZH3_Pos) /**< (PWM_FPV2) Fault Protection to Hi-Z for PWMH output on channel 3 Mask */ 2224 #define PWM_FPV2_FPZH3 PWM_FPV2_FPZH3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_FPV2_FPZH3_Msk instead */ 2225 #define PWM_FPV2_FPZL0_Pos 16 /**< (PWM_FPV2) Fault Protection to Hi-Z for PWML output on channel 0 Position */ 2226 #define PWM_FPV2_FPZL0_Msk (_U_(0x1) << PWM_FPV2_FPZL0_Pos) /**< (PWM_FPV2) Fault Protection to Hi-Z for PWML output on channel 0 Mask */ 2227 #define PWM_FPV2_FPZL0 PWM_FPV2_FPZL0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_FPV2_FPZL0_Msk instead */ 2228 #define PWM_FPV2_FPZL1_Pos 17 /**< (PWM_FPV2) Fault Protection to Hi-Z for PWML output on channel 1 Position */ 2229 #define PWM_FPV2_FPZL1_Msk (_U_(0x1) << PWM_FPV2_FPZL1_Pos) /**< (PWM_FPV2) Fault Protection to Hi-Z for PWML output on channel 1 Mask */ 2230 #define PWM_FPV2_FPZL1 PWM_FPV2_FPZL1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_FPV2_FPZL1_Msk instead */ 2231 #define PWM_FPV2_FPZL2_Pos 18 /**< (PWM_FPV2) Fault Protection to Hi-Z for PWML output on channel 2 Position */ 2232 #define PWM_FPV2_FPZL2_Msk (_U_(0x1) << PWM_FPV2_FPZL2_Pos) /**< (PWM_FPV2) Fault Protection to Hi-Z for PWML output on channel 2 Mask */ 2233 #define PWM_FPV2_FPZL2 PWM_FPV2_FPZL2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_FPV2_FPZL2_Msk instead */ 2234 #define PWM_FPV2_FPZL3_Pos 19 /**< (PWM_FPV2) Fault Protection to Hi-Z for PWML output on channel 3 Position */ 2235 #define PWM_FPV2_FPZL3_Msk (_U_(0x1) << PWM_FPV2_FPZL3_Pos) /**< (PWM_FPV2) Fault Protection to Hi-Z for PWML output on channel 3 Mask */ 2236 #define PWM_FPV2_FPZL3 PWM_FPV2_FPZL3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_FPV2_FPZL3_Msk instead */ 2237 #define PWM_FPV2_MASK _U_(0xF000F) /**< \deprecated (PWM_FPV2) Register MASK (Use PWM_FPV2_Msk instead) */ 2238 #define PWM_FPV2_Msk _U_(0xF000F) /**< (PWM_FPV2) Register Mask */ 2239 2240 #define PWM_FPV2_FPZH_Pos 0 /**< (PWM_FPV2 Position) Fault Protection to Hi-Z for PWMH output on channel x */ 2241 #define PWM_FPV2_FPZH_Msk (_U_(0xF) << PWM_FPV2_FPZH_Pos) /**< (PWM_FPV2 Mask) FPZH */ 2242 #define PWM_FPV2_FPZH(value) (PWM_FPV2_FPZH_Msk & ((value) << PWM_FPV2_FPZH_Pos)) 2243 #define PWM_FPV2_FPZL_Pos 16 /**< (PWM_FPV2 Position) Fault Protection to Hi-Z for PWML output on channel 3 */ 2244 #define PWM_FPV2_FPZL_Msk (_U_(0xF) << PWM_FPV2_FPZL_Pos) /**< (PWM_FPV2 Mask) FPZL */ 2245 #define PWM_FPV2_FPZL(value) (PWM_FPV2_FPZL_Msk & ((value) << PWM_FPV2_FPZL_Pos)) 2246 2247 /* -------- PWM_WPCR : (PWM Offset: 0xe4) (/W 32) PWM Write Protection Control Register -------- */ 2248 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 2249 #if COMPONENT_TYPEDEF_STYLE == 'N' 2250 typedef union { 2251 struct { 2252 uint32_t WPCMD:2; /**< bit: 0..1 Write Protection Command */ 2253 uint32_t WPRG0:1; /**< bit: 2 Write Protection Register Group 0 */ 2254 uint32_t WPRG1:1; /**< bit: 3 Write Protection Register Group 1 */ 2255 uint32_t WPRG2:1; /**< bit: 4 Write Protection Register Group 2 */ 2256 uint32_t WPRG3:1; /**< bit: 5 Write Protection Register Group 3 */ 2257 uint32_t WPRG4:1; /**< bit: 6 Write Protection Register Group 4 */ 2258 uint32_t WPRG5:1; /**< bit: 7 Write Protection Register Group 5 */ 2259 uint32_t WPKEY:24; /**< bit: 8..31 Write Protection Key */ 2260 } bit; /**< Structure used for bit access */ 2261 struct { 2262 uint32_t :2; /**< bit: 0..1 Reserved */ 2263 uint32_t WPRG:6; /**< bit: 2..7 Write Protection Register Group x */ 2264 uint32_t :24; /**< bit: 8..31 Reserved */ 2265 } vec; /**< Structure used for vec access */ 2266 uint32_t reg; /**< Type used for register access */ 2267 } PWM_WPCR_Type; 2268 #endif 2269 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 2270 2271 #define PWM_WPCR_OFFSET (0xE4) /**< (PWM_WPCR) PWM Write Protection Control Register Offset */ 2272 2273 #define PWM_WPCR_WPCMD_Pos 0 /**< (PWM_WPCR) Write Protection Command Position */ 2274 #define PWM_WPCR_WPCMD_Msk (_U_(0x3) << PWM_WPCR_WPCMD_Pos) /**< (PWM_WPCR) Write Protection Command Mask */ 2275 #define PWM_WPCR_WPCMD(value) (PWM_WPCR_WPCMD_Msk & ((value) << PWM_WPCR_WPCMD_Pos)) 2276 #define PWM_WPCR_WPCMD_DISABLE_SW_PROT_Val _U_(0x0) /**< (PWM_WPCR) Disables the software write protection of the register groups of which the bit WPRGx is at '1'. */ 2277 #define PWM_WPCR_WPCMD_ENABLE_SW_PROT_Val _U_(0x1) /**< (PWM_WPCR) Enables the software write protection of the register groups of which the bit WPRGx is at '1'. */ 2278 #define PWM_WPCR_WPCMD_ENABLE_HW_PROT_Val _U_(0x2) /**< (PWM_WPCR) Enables the hardware write protection of the register groups of which the bit WPRGx is at '1'. Only a hardware reset of the PWM controller can disable the hardware write protection. Moreover, to meet security requirements, the PIO lines associated with the PWM can not be configured through the PIO interface. */ 2279 #define PWM_WPCR_WPCMD_DISABLE_SW_PROT (PWM_WPCR_WPCMD_DISABLE_SW_PROT_Val << PWM_WPCR_WPCMD_Pos) /**< (PWM_WPCR) Disables the software write protection of the register groups of which the bit WPRGx is at '1'. Position */ 2280 #define PWM_WPCR_WPCMD_ENABLE_SW_PROT (PWM_WPCR_WPCMD_ENABLE_SW_PROT_Val << PWM_WPCR_WPCMD_Pos) /**< (PWM_WPCR) Enables the software write protection of the register groups of which the bit WPRGx is at '1'. Position */ 2281 #define PWM_WPCR_WPCMD_ENABLE_HW_PROT (PWM_WPCR_WPCMD_ENABLE_HW_PROT_Val << PWM_WPCR_WPCMD_Pos) /**< (PWM_WPCR) Enables the hardware write protection of the register groups of which the bit WPRGx is at '1'. Only a hardware reset of the PWM controller can disable the hardware write protection. Moreover, to meet security requirements, the PIO lines associated with the PWM can not be configured through the PIO interface. Position */ 2282 #define PWM_WPCR_WPRG0_Pos 2 /**< (PWM_WPCR) Write Protection Register Group 0 Position */ 2283 #define PWM_WPCR_WPRG0_Msk (_U_(0x1) << PWM_WPCR_WPRG0_Pos) /**< (PWM_WPCR) Write Protection Register Group 0 Mask */ 2284 #define PWM_WPCR_WPRG0 PWM_WPCR_WPRG0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_WPCR_WPRG0_Msk instead */ 2285 #define PWM_WPCR_WPRG1_Pos 3 /**< (PWM_WPCR) Write Protection Register Group 1 Position */ 2286 #define PWM_WPCR_WPRG1_Msk (_U_(0x1) << PWM_WPCR_WPRG1_Pos) /**< (PWM_WPCR) Write Protection Register Group 1 Mask */ 2287 #define PWM_WPCR_WPRG1 PWM_WPCR_WPRG1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_WPCR_WPRG1_Msk instead */ 2288 #define PWM_WPCR_WPRG2_Pos 4 /**< (PWM_WPCR) Write Protection Register Group 2 Position */ 2289 #define PWM_WPCR_WPRG2_Msk (_U_(0x1) << PWM_WPCR_WPRG2_Pos) /**< (PWM_WPCR) Write Protection Register Group 2 Mask */ 2290 #define PWM_WPCR_WPRG2 PWM_WPCR_WPRG2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_WPCR_WPRG2_Msk instead */ 2291 #define PWM_WPCR_WPRG3_Pos 5 /**< (PWM_WPCR) Write Protection Register Group 3 Position */ 2292 #define PWM_WPCR_WPRG3_Msk (_U_(0x1) << PWM_WPCR_WPRG3_Pos) /**< (PWM_WPCR) Write Protection Register Group 3 Mask */ 2293 #define PWM_WPCR_WPRG3 PWM_WPCR_WPRG3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_WPCR_WPRG3_Msk instead */ 2294 #define PWM_WPCR_WPRG4_Pos 6 /**< (PWM_WPCR) Write Protection Register Group 4 Position */ 2295 #define PWM_WPCR_WPRG4_Msk (_U_(0x1) << PWM_WPCR_WPRG4_Pos) /**< (PWM_WPCR) Write Protection Register Group 4 Mask */ 2296 #define PWM_WPCR_WPRG4 PWM_WPCR_WPRG4_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_WPCR_WPRG4_Msk instead */ 2297 #define PWM_WPCR_WPRG5_Pos 7 /**< (PWM_WPCR) Write Protection Register Group 5 Position */ 2298 #define PWM_WPCR_WPRG5_Msk (_U_(0x1) << PWM_WPCR_WPRG5_Pos) /**< (PWM_WPCR) Write Protection Register Group 5 Mask */ 2299 #define PWM_WPCR_WPRG5 PWM_WPCR_WPRG5_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_WPCR_WPRG5_Msk instead */ 2300 #define PWM_WPCR_WPKEY_Pos 8 /**< (PWM_WPCR) Write Protection Key Position */ 2301 #define PWM_WPCR_WPKEY_Msk (_U_(0xFFFFFF) << PWM_WPCR_WPKEY_Pos) /**< (PWM_WPCR) Write Protection Key Mask */ 2302 #define PWM_WPCR_WPKEY(value) (PWM_WPCR_WPKEY_Msk & ((value) << PWM_WPCR_WPKEY_Pos)) 2303 #define PWM_WPCR_WPKEY_PASSWD_Val _U_(0x50574D) /**< (PWM_WPCR) Writing any other value in this field aborts the write operation of the WPCMD field.Always reads as 0 */ 2304 #define PWM_WPCR_WPKEY_PASSWD (PWM_WPCR_WPKEY_PASSWD_Val << PWM_WPCR_WPKEY_Pos) /**< (PWM_WPCR) Writing any other value in this field aborts the write operation of the WPCMD field.Always reads as 0 Position */ 2305 #define PWM_WPCR_MASK _U_(0xFFFFFFFF) /**< \deprecated (PWM_WPCR) Register MASK (Use PWM_WPCR_Msk instead) */ 2306 #define PWM_WPCR_Msk _U_(0xFFFFFFFF) /**< (PWM_WPCR) Register Mask */ 2307 2308 #define PWM_WPCR_WPRG_Pos 2 /**< (PWM_WPCR Position) Write Protection Register Group x */ 2309 #define PWM_WPCR_WPRG_Msk (_U_(0x3F) << PWM_WPCR_WPRG_Pos) /**< (PWM_WPCR Mask) WPRG */ 2310 #define PWM_WPCR_WPRG(value) (PWM_WPCR_WPRG_Msk & ((value) << PWM_WPCR_WPRG_Pos)) 2311 2312 /* -------- PWM_WPSR : (PWM Offset: 0xe8) (R/ 32) PWM Write Protection Status Register -------- */ 2313 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 2314 #if COMPONENT_TYPEDEF_STYLE == 'N' 2315 typedef union { 2316 struct { 2317 uint32_t WPSWS0:1; /**< bit: 0 Write Protect SW Status */ 2318 uint32_t WPSWS1:1; /**< bit: 1 Write Protect SW Status */ 2319 uint32_t WPSWS2:1; /**< bit: 2 Write Protect SW Status */ 2320 uint32_t WPSWS3:1; /**< bit: 3 Write Protect SW Status */ 2321 uint32_t WPSWS4:1; /**< bit: 4 Write Protect SW Status */ 2322 uint32_t WPSWS5:1; /**< bit: 5 Write Protect SW Status */ 2323 uint32_t :1; /**< bit: 6 Reserved */ 2324 uint32_t WPVS:1; /**< bit: 7 Write Protect Violation Status */ 2325 uint32_t WPHWS0:1; /**< bit: 8 Write Protect HW Status */ 2326 uint32_t WPHWS1:1; /**< bit: 9 Write Protect HW Status */ 2327 uint32_t WPHWS2:1; /**< bit: 10 Write Protect HW Status */ 2328 uint32_t WPHWS3:1; /**< bit: 11 Write Protect HW Status */ 2329 uint32_t WPHWS4:1; /**< bit: 12 Write Protect HW Status */ 2330 uint32_t WPHWS5:1; /**< bit: 13 Write Protect HW Status */ 2331 uint32_t :2; /**< bit: 14..15 Reserved */ 2332 uint32_t WPVSRC:16; /**< bit: 16..31 Write Protect Violation Source */ 2333 } bit; /**< Structure used for bit access */ 2334 struct { 2335 uint32_t WPSWS:6; /**< bit: 0..5 Write Protect SW Status */ 2336 uint32_t :2; /**< bit: 6..7 Reserved */ 2337 uint32_t WPHWS:6; /**< bit: 8..13 Write Protect HW Status */ 2338 uint32_t :18; /**< bit: 14..31 Reserved */ 2339 } vec; /**< Structure used for vec access */ 2340 uint32_t reg; /**< Type used for register access */ 2341 } PWM_WPSR_Type; 2342 #endif 2343 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 2344 2345 #define PWM_WPSR_OFFSET (0xE8) /**< (PWM_WPSR) PWM Write Protection Status Register Offset */ 2346 2347 #define PWM_WPSR_WPSWS0_Pos 0 /**< (PWM_WPSR) Write Protect SW Status Position */ 2348 #define PWM_WPSR_WPSWS0_Msk (_U_(0x1) << PWM_WPSR_WPSWS0_Pos) /**< (PWM_WPSR) Write Protect SW Status Mask */ 2349 #define PWM_WPSR_WPSWS0 PWM_WPSR_WPSWS0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_WPSR_WPSWS0_Msk instead */ 2350 #define PWM_WPSR_WPSWS1_Pos 1 /**< (PWM_WPSR) Write Protect SW Status Position */ 2351 #define PWM_WPSR_WPSWS1_Msk (_U_(0x1) << PWM_WPSR_WPSWS1_Pos) /**< (PWM_WPSR) Write Protect SW Status Mask */ 2352 #define PWM_WPSR_WPSWS1 PWM_WPSR_WPSWS1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_WPSR_WPSWS1_Msk instead */ 2353 #define PWM_WPSR_WPSWS2_Pos 2 /**< (PWM_WPSR) Write Protect SW Status Position */ 2354 #define PWM_WPSR_WPSWS2_Msk (_U_(0x1) << PWM_WPSR_WPSWS2_Pos) /**< (PWM_WPSR) Write Protect SW Status Mask */ 2355 #define PWM_WPSR_WPSWS2 PWM_WPSR_WPSWS2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_WPSR_WPSWS2_Msk instead */ 2356 #define PWM_WPSR_WPSWS3_Pos 3 /**< (PWM_WPSR) Write Protect SW Status Position */ 2357 #define PWM_WPSR_WPSWS3_Msk (_U_(0x1) << PWM_WPSR_WPSWS3_Pos) /**< (PWM_WPSR) Write Protect SW Status Mask */ 2358 #define PWM_WPSR_WPSWS3 PWM_WPSR_WPSWS3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_WPSR_WPSWS3_Msk instead */ 2359 #define PWM_WPSR_WPSWS4_Pos 4 /**< (PWM_WPSR) Write Protect SW Status Position */ 2360 #define PWM_WPSR_WPSWS4_Msk (_U_(0x1) << PWM_WPSR_WPSWS4_Pos) /**< (PWM_WPSR) Write Protect SW Status Mask */ 2361 #define PWM_WPSR_WPSWS4 PWM_WPSR_WPSWS4_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_WPSR_WPSWS4_Msk instead */ 2362 #define PWM_WPSR_WPSWS5_Pos 5 /**< (PWM_WPSR) Write Protect SW Status Position */ 2363 #define PWM_WPSR_WPSWS5_Msk (_U_(0x1) << PWM_WPSR_WPSWS5_Pos) /**< (PWM_WPSR) Write Protect SW Status Mask */ 2364 #define PWM_WPSR_WPSWS5 PWM_WPSR_WPSWS5_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_WPSR_WPSWS5_Msk instead */ 2365 #define PWM_WPSR_WPVS_Pos 7 /**< (PWM_WPSR) Write Protect Violation Status Position */ 2366 #define PWM_WPSR_WPVS_Msk (_U_(0x1) << PWM_WPSR_WPVS_Pos) /**< (PWM_WPSR) Write Protect Violation Status Mask */ 2367 #define PWM_WPSR_WPVS PWM_WPSR_WPVS_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_WPSR_WPVS_Msk instead */ 2368 #define PWM_WPSR_WPHWS0_Pos 8 /**< (PWM_WPSR) Write Protect HW Status Position */ 2369 #define PWM_WPSR_WPHWS0_Msk (_U_(0x1) << PWM_WPSR_WPHWS0_Pos) /**< (PWM_WPSR) Write Protect HW Status Mask */ 2370 #define PWM_WPSR_WPHWS0 PWM_WPSR_WPHWS0_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_WPSR_WPHWS0_Msk instead */ 2371 #define PWM_WPSR_WPHWS1_Pos 9 /**< (PWM_WPSR) Write Protect HW Status Position */ 2372 #define PWM_WPSR_WPHWS1_Msk (_U_(0x1) << PWM_WPSR_WPHWS1_Pos) /**< (PWM_WPSR) Write Protect HW Status Mask */ 2373 #define PWM_WPSR_WPHWS1 PWM_WPSR_WPHWS1_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_WPSR_WPHWS1_Msk instead */ 2374 #define PWM_WPSR_WPHWS2_Pos 10 /**< (PWM_WPSR) Write Protect HW Status Position */ 2375 #define PWM_WPSR_WPHWS2_Msk (_U_(0x1) << PWM_WPSR_WPHWS2_Pos) /**< (PWM_WPSR) Write Protect HW Status Mask */ 2376 #define PWM_WPSR_WPHWS2 PWM_WPSR_WPHWS2_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_WPSR_WPHWS2_Msk instead */ 2377 #define PWM_WPSR_WPHWS3_Pos 11 /**< (PWM_WPSR) Write Protect HW Status Position */ 2378 #define PWM_WPSR_WPHWS3_Msk (_U_(0x1) << PWM_WPSR_WPHWS3_Pos) /**< (PWM_WPSR) Write Protect HW Status Mask */ 2379 #define PWM_WPSR_WPHWS3 PWM_WPSR_WPHWS3_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_WPSR_WPHWS3_Msk instead */ 2380 #define PWM_WPSR_WPHWS4_Pos 12 /**< (PWM_WPSR) Write Protect HW Status Position */ 2381 #define PWM_WPSR_WPHWS4_Msk (_U_(0x1) << PWM_WPSR_WPHWS4_Pos) /**< (PWM_WPSR) Write Protect HW Status Mask */ 2382 #define PWM_WPSR_WPHWS4 PWM_WPSR_WPHWS4_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_WPSR_WPHWS4_Msk instead */ 2383 #define PWM_WPSR_WPHWS5_Pos 13 /**< (PWM_WPSR) Write Protect HW Status Position */ 2384 #define PWM_WPSR_WPHWS5_Msk (_U_(0x1) << PWM_WPSR_WPHWS5_Pos) /**< (PWM_WPSR) Write Protect HW Status Mask */ 2385 #define PWM_WPSR_WPHWS5 PWM_WPSR_WPHWS5_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_WPSR_WPHWS5_Msk instead */ 2386 #define PWM_WPSR_WPVSRC_Pos 16 /**< (PWM_WPSR) Write Protect Violation Source Position */ 2387 #define PWM_WPSR_WPVSRC_Msk (_U_(0xFFFF) << PWM_WPSR_WPVSRC_Pos) /**< (PWM_WPSR) Write Protect Violation Source Mask */ 2388 #define PWM_WPSR_WPVSRC(value) (PWM_WPSR_WPVSRC_Msk & ((value) << PWM_WPSR_WPVSRC_Pos)) 2389 #define PWM_WPSR_MASK _U_(0xFFFF3FBF) /**< \deprecated (PWM_WPSR) Register MASK (Use PWM_WPSR_Msk instead) */ 2390 #define PWM_WPSR_Msk _U_(0xFFFF3FBF) /**< (PWM_WPSR) Register Mask */ 2391 2392 #define PWM_WPSR_WPSWS_Pos 0 /**< (PWM_WPSR Position) Write Protect SW Status */ 2393 #define PWM_WPSR_WPSWS_Msk (_U_(0x3F) << PWM_WPSR_WPSWS_Pos) /**< (PWM_WPSR Mask) WPSWS */ 2394 #define PWM_WPSR_WPSWS(value) (PWM_WPSR_WPSWS_Msk & ((value) << PWM_WPSR_WPSWS_Pos)) 2395 #define PWM_WPSR_WPHWS_Pos 8 /**< (PWM_WPSR Position) Write Protect HW Status */ 2396 #define PWM_WPSR_WPHWS_Msk (_U_(0x3F) << PWM_WPSR_WPHWS_Pos) /**< (PWM_WPSR Mask) WPHWS */ 2397 #define PWM_WPSR_WPHWS(value) (PWM_WPSR_WPHWS_Msk & ((value) << PWM_WPSR_WPHWS_Pos)) 2398 2399 /* -------- PWM_CMUPD0 : (PWM Offset: 0x400) (/W 32) PWM Channel Mode Update Register (ch_num = 0) -------- */ 2400 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 2401 #if COMPONENT_TYPEDEF_STYLE == 'N' 2402 typedef union { 2403 struct { 2404 uint32_t :9; /**< bit: 0..8 Reserved */ 2405 uint32_t CPOLUP:1; /**< bit: 9 Channel Polarity Update */ 2406 uint32_t :3; /**< bit: 10..12 Reserved */ 2407 uint32_t CPOLINVUP:1; /**< bit: 13 Channel Polarity Inversion Update */ 2408 uint32_t :18; /**< bit: 14..31 Reserved */ 2409 } bit; /**< Structure used for bit access */ 2410 uint32_t reg; /**< Type used for register access */ 2411 } PWM_CMUPD0_Type; 2412 #endif 2413 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 2414 2415 #define PWM_CMUPD0_OFFSET (0x400) /**< (PWM_CMUPD0) PWM Channel Mode Update Register (ch_num = 0) Offset */ 2416 2417 #define PWM_CMUPD0_CPOLUP_Pos 9 /**< (PWM_CMUPD0) Channel Polarity Update Position */ 2418 #define PWM_CMUPD0_CPOLUP_Msk (_U_(0x1) << PWM_CMUPD0_CPOLUP_Pos) /**< (PWM_CMUPD0) Channel Polarity Update Mask */ 2419 #define PWM_CMUPD0_CPOLUP PWM_CMUPD0_CPOLUP_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_CMUPD0_CPOLUP_Msk instead */ 2420 #define PWM_CMUPD0_CPOLINVUP_Pos 13 /**< (PWM_CMUPD0) Channel Polarity Inversion Update Position */ 2421 #define PWM_CMUPD0_CPOLINVUP_Msk (_U_(0x1) << PWM_CMUPD0_CPOLINVUP_Pos) /**< (PWM_CMUPD0) Channel Polarity Inversion Update Mask */ 2422 #define PWM_CMUPD0_CPOLINVUP PWM_CMUPD0_CPOLINVUP_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_CMUPD0_CPOLINVUP_Msk instead */ 2423 #define PWM_CMUPD0_MASK _U_(0x2200) /**< \deprecated (PWM_CMUPD0) Register MASK (Use PWM_CMUPD0_Msk instead) */ 2424 #define PWM_CMUPD0_Msk _U_(0x2200) /**< (PWM_CMUPD0) Register Mask */ 2425 2426 2427 /* -------- PWM_CMUPD1 : (PWM Offset: 0x420) (/W 32) PWM Channel Mode Update Register (ch_num = 1) -------- */ 2428 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 2429 #if COMPONENT_TYPEDEF_STYLE == 'N' 2430 typedef union { 2431 struct { 2432 uint32_t :9; /**< bit: 0..8 Reserved */ 2433 uint32_t CPOLUP:1; /**< bit: 9 Channel Polarity Update */ 2434 uint32_t :3; /**< bit: 10..12 Reserved */ 2435 uint32_t CPOLINVUP:1; /**< bit: 13 Channel Polarity Inversion Update */ 2436 uint32_t :18; /**< bit: 14..31 Reserved */ 2437 } bit; /**< Structure used for bit access */ 2438 uint32_t reg; /**< Type used for register access */ 2439 } PWM_CMUPD1_Type; 2440 #endif 2441 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 2442 2443 #define PWM_CMUPD1_OFFSET (0x420) /**< (PWM_CMUPD1) PWM Channel Mode Update Register (ch_num = 1) Offset */ 2444 2445 #define PWM_CMUPD1_CPOLUP_Pos 9 /**< (PWM_CMUPD1) Channel Polarity Update Position */ 2446 #define PWM_CMUPD1_CPOLUP_Msk (_U_(0x1) << PWM_CMUPD1_CPOLUP_Pos) /**< (PWM_CMUPD1) Channel Polarity Update Mask */ 2447 #define PWM_CMUPD1_CPOLUP PWM_CMUPD1_CPOLUP_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_CMUPD1_CPOLUP_Msk instead */ 2448 #define PWM_CMUPD1_CPOLINVUP_Pos 13 /**< (PWM_CMUPD1) Channel Polarity Inversion Update Position */ 2449 #define PWM_CMUPD1_CPOLINVUP_Msk (_U_(0x1) << PWM_CMUPD1_CPOLINVUP_Pos) /**< (PWM_CMUPD1) Channel Polarity Inversion Update Mask */ 2450 #define PWM_CMUPD1_CPOLINVUP PWM_CMUPD1_CPOLINVUP_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_CMUPD1_CPOLINVUP_Msk instead */ 2451 #define PWM_CMUPD1_MASK _U_(0x2200) /**< \deprecated (PWM_CMUPD1) Register MASK (Use PWM_CMUPD1_Msk instead) */ 2452 #define PWM_CMUPD1_Msk _U_(0x2200) /**< (PWM_CMUPD1) Register Mask */ 2453 2454 2455 /* -------- PWM_ETRG1 : (PWM Offset: 0x42c) (R/W 32) PWM External Trigger Register (trg_num = 1) -------- */ 2456 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 2457 #if COMPONENT_TYPEDEF_STYLE == 'N' 2458 typedef union { 2459 struct { 2460 uint32_t MAXCNT:24; /**< bit: 0..23 Maximum Counter value */ 2461 uint32_t TRGMODE:2; /**< bit: 24..25 External Trigger Mode */ 2462 uint32_t :2; /**< bit: 26..27 Reserved */ 2463 uint32_t TRGEDGE:1; /**< bit: 28 Edge Selection */ 2464 uint32_t TRGFILT:1; /**< bit: 29 Filtered input */ 2465 uint32_t TRGSRC:1; /**< bit: 30 Trigger Source */ 2466 uint32_t RFEN:1; /**< bit: 31 Recoverable Fault Enable */ 2467 } bit; /**< Structure used for bit access */ 2468 uint32_t reg; /**< Type used for register access */ 2469 } PWM_ETRG1_Type; 2470 #endif 2471 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 2472 2473 #define PWM_ETRG1_OFFSET (0x42C) /**< (PWM_ETRG1) PWM External Trigger Register (trg_num = 1) Offset */ 2474 2475 #define PWM_ETRG1_MAXCNT_Pos 0 /**< (PWM_ETRG1) Maximum Counter value Position */ 2476 #define PWM_ETRG1_MAXCNT_Msk (_U_(0xFFFFFF) << PWM_ETRG1_MAXCNT_Pos) /**< (PWM_ETRG1) Maximum Counter value Mask */ 2477 #define PWM_ETRG1_MAXCNT(value) (PWM_ETRG1_MAXCNT_Msk & ((value) << PWM_ETRG1_MAXCNT_Pos)) 2478 #define PWM_ETRG1_TRGMODE_Pos 24 /**< (PWM_ETRG1) External Trigger Mode Position */ 2479 #define PWM_ETRG1_TRGMODE_Msk (_U_(0x3) << PWM_ETRG1_TRGMODE_Pos) /**< (PWM_ETRG1) External Trigger Mode Mask */ 2480 #define PWM_ETRG1_TRGMODE(value) (PWM_ETRG1_TRGMODE_Msk & ((value) << PWM_ETRG1_TRGMODE_Pos)) 2481 #define PWM_ETRG1_TRGMODE_OFF_Val _U_(0x0) /**< (PWM_ETRG1) External trigger is not enabled. */ 2482 #define PWM_ETRG1_TRGMODE_MODE1_Val _U_(0x1) /**< (PWM_ETRG1) External PWM Reset Mode */ 2483 #define PWM_ETRG1_TRGMODE_MODE2_Val _U_(0x2) /**< (PWM_ETRG1) External PWM Start Mode */ 2484 #define PWM_ETRG1_TRGMODE_MODE3_Val _U_(0x3) /**< (PWM_ETRG1) Cycle-by-cycle Duty Mode */ 2485 #define PWM_ETRG1_TRGMODE_OFF (PWM_ETRG1_TRGMODE_OFF_Val << PWM_ETRG1_TRGMODE_Pos) /**< (PWM_ETRG1) External trigger is not enabled. Position */ 2486 #define PWM_ETRG1_TRGMODE_MODE1 (PWM_ETRG1_TRGMODE_MODE1_Val << PWM_ETRG1_TRGMODE_Pos) /**< (PWM_ETRG1) External PWM Reset Mode Position */ 2487 #define PWM_ETRG1_TRGMODE_MODE2 (PWM_ETRG1_TRGMODE_MODE2_Val << PWM_ETRG1_TRGMODE_Pos) /**< (PWM_ETRG1) External PWM Start Mode Position */ 2488 #define PWM_ETRG1_TRGMODE_MODE3 (PWM_ETRG1_TRGMODE_MODE3_Val << PWM_ETRG1_TRGMODE_Pos) /**< (PWM_ETRG1) Cycle-by-cycle Duty Mode Position */ 2489 #define PWM_ETRG1_TRGEDGE_Pos 28 /**< (PWM_ETRG1) Edge Selection Position */ 2490 #define PWM_ETRG1_TRGEDGE_Msk (_U_(0x1) << PWM_ETRG1_TRGEDGE_Pos) /**< (PWM_ETRG1) Edge Selection Mask */ 2491 #define PWM_ETRG1_TRGEDGE PWM_ETRG1_TRGEDGE_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ETRG1_TRGEDGE_Msk instead */ 2492 #define PWM_ETRG1_TRGEDGE_FALLING_ZERO_Val _U_(0x0) /**< (PWM_ETRG1) TRGMODE = 1: TRGINx event detection on falling edge.TRGMODE = 2, 3: TRGINx active level is 0 */ 2493 #define PWM_ETRG1_TRGEDGE_RISING_ONE_Val _U_(0x1) /**< (PWM_ETRG1) TRGMODE = 1: TRGINx event detection on rising edge.TRGMODE = 2, 3: TRGINx active level is 1 */ 2494 #define PWM_ETRG1_TRGEDGE_FALLING_ZERO (PWM_ETRG1_TRGEDGE_FALLING_ZERO_Val << PWM_ETRG1_TRGEDGE_Pos) /**< (PWM_ETRG1) TRGMODE = 1: TRGINx event detection on falling edge.TRGMODE = 2, 3: TRGINx active level is 0 Position */ 2495 #define PWM_ETRG1_TRGEDGE_RISING_ONE (PWM_ETRG1_TRGEDGE_RISING_ONE_Val << PWM_ETRG1_TRGEDGE_Pos) /**< (PWM_ETRG1) TRGMODE = 1: TRGINx event detection on rising edge.TRGMODE = 2, 3: TRGINx active level is 1 Position */ 2496 #define PWM_ETRG1_TRGFILT_Pos 29 /**< (PWM_ETRG1) Filtered input Position */ 2497 #define PWM_ETRG1_TRGFILT_Msk (_U_(0x1) << PWM_ETRG1_TRGFILT_Pos) /**< (PWM_ETRG1) Filtered input Mask */ 2498 #define PWM_ETRG1_TRGFILT PWM_ETRG1_TRGFILT_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ETRG1_TRGFILT_Msk instead */ 2499 #define PWM_ETRG1_TRGSRC_Pos 30 /**< (PWM_ETRG1) Trigger Source Position */ 2500 #define PWM_ETRG1_TRGSRC_Msk (_U_(0x1) << PWM_ETRG1_TRGSRC_Pos) /**< (PWM_ETRG1) Trigger Source Mask */ 2501 #define PWM_ETRG1_TRGSRC PWM_ETRG1_TRGSRC_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ETRG1_TRGSRC_Msk instead */ 2502 #define PWM_ETRG1_RFEN_Pos 31 /**< (PWM_ETRG1) Recoverable Fault Enable Position */ 2503 #define PWM_ETRG1_RFEN_Msk (_U_(0x1) << PWM_ETRG1_RFEN_Pos) /**< (PWM_ETRG1) Recoverable Fault Enable Mask */ 2504 #define PWM_ETRG1_RFEN PWM_ETRG1_RFEN_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ETRG1_RFEN_Msk instead */ 2505 #define PWM_ETRG1_MASK _U_(0xF3FFFFFF) /**< \deprecated (PWM_ETRG1) Register MASK (Use PWM_ETRG1_Msk instead) */ 2506 #define PWM_ETRG1_Msk _U_(0xF3FFFFFF) /**< (PWM_ETRG1) Register Mask */ 2507 2508 2509 /* -------- PWM_LEBR1 : (PWM Offset: 0x430) (R/W 32) PWM Leading-Edge Blanking Register (trg_num = 1) -------- */ 2510 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 2511 #if COMPONENT_TYPEDEF_STYLE == 'N' 2512 typedef union { 2513 struct { 2514 uint32_t LEBDELAY:7; /**< bit: 0..6 Leading-Edge Blanking Delay for TRGINx */ 2515 uint32_t :9; /**< bit: 7..15 Reserved */ 2516 uint32_t PWMLFEN:1; /**< bit: 16 PWML Falling Edge Enable */ 2517 uint32_t PWMLREN:1; /**< bit: 17 PWML Rising Edge Enable */ 2518 uint32_t PWMHFEN:1; /**< bit: 18 PWMH Falling Edge Enable */ 2519 uint32_t PWMHREN:1; /**< bit: 19 PWMH Rising Edge Enable */ 2520 uint32_t :12; /**< bit: 20..31 Reserved */ 2521 } bit; /**< Structure used for bit access */ 2522 uint32_t reg; /**< Type used for register access */ 2523 } PWM_LEBR1_Type; 2524 #endif 2525 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 2526 2527 #define PWM_LEBR1_OFFSET (0x430) /**< (PWM_LEBR1) PWM Leading-Edge Blanking Register (trg_num = 1) Offset */ 2528 2529 #define PWM_LEBR1_LEBDELAY_Pos 0 /**< (PWM_LEBR1) Leading-Edge Blanking Delay for TRGINx Position */ 2530 #define PWM_LEBR1_LEBDELAY_Msk (_U_(0x7F) << PWM_LEBR1_LEBDELAY_Pos) /**< (PWM_LEBR1) Leading-Edge Blanking Delay for TRGINx Mask */ 2531 #define PWM_LEBR1_LEBDELAY(value) (PWM_LEBR1_LEBDELAY_Msk & ((value) << PWM_LEBR1_LEBDELAY_Pos)) 2532 #define PWM_LEBR1_PWMLFEN_Pos 16 /**< (PWM_LEBR1) PWML Falling Edge Enable Position */ 2533 #define PWM_LEBR1_PWMLFEN_Msk (_U_(0x1) << PWM_LEBR1_PWMLFEN_Pos) /**< (PWM_LEBR1) PWML Falling Edge Enable Mask */ 2534 #define PWM_LEBR1_PWMLFEN PWM_LEBR1_PWMLFEN_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_LEBR1_PWMLFEN_Msk instead */ 2535 #define PWM_LEBR1_PWMLREN_Pos 17 /**< (PWM_LEBR1) PWML Rising Edge Enable Position */ 2536 #define PWM_LEBR1_PWMLREN_Msk (_U_(0x1) << PWM_LEBR1_PWMLREN_Pos) /**< (PWM_LEBR1) PWML Rising Edge Enable Mask */ 2537 #define PWM_LEBR1_PWMLREN PWM_LEBR1_PWMLREN_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_LEBR1_PWMLREN_Msk instead */ 2538 #define PWM_LEBR1_PWMHFEN_Pos 18 /**< (PWM_LEBR1) PWMH Falling Edge Enable Position */ 2539 #define PWM_LEBR1_PWMHFEN_Msk (_U_(0x1) << PWM_LEBR1_PWMHFEN_Pos) /**< (PWM_LEBR1) PWMH Falling Edge Enable Mask */ 2540 #define PWM_LEBR1_PWMHFEN PWM_LEBR1_PWMHFEN_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_LEBR1_PWMHFEN_Msk instead */ 2541 #define PWM_LEBR1_PWMHREN_Pos 19 /**< (PWM_LEBR1) PWMH Rising Edge Enable Position */ 2542 #define PWM_LEBR1_PWMHREN_Msk (_U_(0x1) << PWM_LEBR1_PWMHREN_Pos) /**< (PWM_LEBR1) PWMH Rising Edge Enable Mask */ 2543 #define PWM_LEBR1_PWMHREN PWM_LEBR1_PWMHREN_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_LEBR1_PWMHREN_Msk instead */ 2544 #define PWM_LEBR1_MASK _U_(0xF007F) /**< \deprecated (PWM_LEBR1) Register MASK (Use PWM_LEBR1_Msk instead) */ 2545 #define PWM_LEBR1_Msk _U_(0xF007F) /**< (PWM_LEBR1) Register Mask */ 2546 2547 2548 /* -------- PWM_CMUPD2 : (PWM Offset: 0x440) (/W 32) PWM Channel Mode Update Register (ch_num = 2) -------- */ 2549 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 2550 #if COMPONENT_TYPEDEF_STYLE == 'N' 2551 typedef union { 2552 struct { 2553 uint32_t :9; /**< bit: 0..8 Reserved */ 2554 uint32_t CPOLUP:1; /**< bit: 9 Channel Polarity Update */ 2555 uint32_t :3; /**< bit: 10..12 Reserved */ 2556 uint32_t CPOLINVUP:1; /**< bit: 13 Channel Polarity Inversion Update */ 2557 uint32_t :18; /**< bit: 14..31 Reserved */ 2558 } bit; /**< Structure used for bit access */ 2559 uint32_t reg; /**< Type used for register access */ 2560 } PWM_CMUPD2_Type; 2561 #endif 2562 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 2563 2564 #define PWM_CMUPD2_OFFSET (0x440) /**< (PWM_CMUPD2) PWM Channel Mode Update Register (ch_num = 2) Offset */ 2565 2566 #define PWM_CMUPD2_CPOLUP_Pos 9 /**< (PWM_CMUPD2) Channel Polarity Update Position */ 2567 #define PWM_CMUPD2_CPOLUP_Msk (_U_(0x1) << PWM_CMUPD2_CPOLUP_Pos) /**< (PWM_CMUPD2) Channel Polarity Update Mask */ 2568 #define PWM_CMUPD2_CPOLUP PWM_CMUPD2_CPOLUP_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_CMUPD2_CPOLUP_Msk instead */ 2569 #define PWM_CMUPD2_CPOLINVUP_Pos 13 /**< (PWM_CMUPD2) Channel Polarity Inversion Update Position */ 2570 #define PWM_CMUPD2_CPOLINVUP_Msk (_U_(0x1) << PWM_CMUPD2_CPOLINVUP_Pos) /**< (PWM_CMUPD2) Channel Polarity Inversion Update Mask */ 2571 #define PWM_CMUPD2_CPOLINVUP PWM_CMUPD2_CPOLINVUP_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_CMUPD2_CPOLINVUP_Msk instead */ 2572 #define PWM_CMUPD2_MASK _U_(0x2200) /**< \deprecated (PWM_CMUPD2) Register MASK (Use PWM_CMUPD2_Msk instead) */ 2573 #define PWM_CMUPD2_Msk _U_(0x2200) /**< (PWM_CMUPD2) Register Mask */ 2574 2575 2576 /* -------- PWM_ETRG2 : (PWM Offset: 0x44c) (R/W 32) PWM External Trigger Register (trg_num = 2) -------- */ 2577 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 2578 #if COMPONENT_TYPEDEF_STYLE == 'N' 2579 typedef union { 2580 struct { 2581 uint32_t MAXCNT:24; /**< bit: 0..23 Maximum Counter value */ 2582 uint32_t TRGMODE:2; /**< bit: 24..25 External Trigger Mode */ 2583 uint32_t :2; /**< bit: 26..27 Reserved */ 2584 uint32_t TRGEDGE:1; /**< bit: 28 Edge Selection */ 2585 uint32_t TRGFILT:1; /**< bit: 29 Filtered input */ 2586 uint32_t TRGSRC:1; /**< bit: 30 Trigger Source */ 2587 uint32_t RFEN:1; /**< bit: 31 Recoverable Fault Enable */ 2588 } bit; /**< Structure used for bit access */ 2589 uint32_t reg; /**< Type used for register access */ 2590 } PWM_ETRG2_Type; 2591 #endif 2592 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 2593 2594 #define PWM_ETRG2_OFFSET (0x44C) /**< (PWM_ETRG2) PWM External Trigger Register (trg_num = 2) Offset */ 2595 2596 #define PWM_ETRG2_MAXCNT_Pos 0 /**< (PWM_ETRG2) Maximum Counter value Position */ 2597 #define PWM_ETRG2_MAXCNT_Msk (_U_(0xFFFFFF) << PWM_ETRG2_MAXCNT_Pos) /**< (PWM_ETRG2) Maximum Counter value Mask */ 2598 #define PWM_ETRG2_MAXCNT(value) (PWM_ETRG2_MAXCNT_Msk & ((value) << PWM_ETRG2_MAXCNT_Pos)) 2599 #define PWM_ETRG2_TRGMODE_Pos 24 /**< (PWM_ETRG2) External Trigger Mode Position */ 2600 #define PWM_ETRG2_TRGMODE_Msk (_U_(0x3) << PWM_ETRG2_TRGMODE_Pos) /**< (PWM_ETRG2) External Trigger Mode Mask */ 2601 #define PWM_ETRG2_TRGMODE(value) (PWM_ETRG2_TRGMODE_Msk & ((value) << PWM_ETRG2_TRGMODE_Pos)) 2602 #define PWM_ETRG2_TRGMODE_OFF_Val _U_(0x0) /**< (PWM_ETRG2) External trigger is not enabled. */ 2603 #define PWM_ETRG2_TRGMODE_MODE1_Val _U_(0x1) /**< (PWM_ETRG2) External PWM Reset Mode */ 2604 #define PWM_ETRG2_TRGMODE_MODE2_Val _U_(0x2) /**< (PWM_ETRG2) External PWM Start Mode */ 2605 #define PWM_ETRG2_TRGMODE_MODE3_Val _U_(0x3) /**< (PWM_ETRG2) Cycle-by-cycle Duty Mode */ 2606 #define PWM_ETRG2_TRGMODE_OFF (PWM_ETRG2_TRGMODE_OFF_Val << PWM_ETRG2_TRGMODE_Pos) /**< (PWM_ETRG2) External trigger is not enabled. Position */ 2607 #define PWM_ETRG2_TRGMODE_MODE1 (PWM_ETRG2_TRGMODE_MODE1_Val << PWM_ETRG2_TRGMODE_Pos) /**< (PWM_ETRG2) External PWM Reset Mode Position */ 2608 #define PWM_ETRG2_TRGMODE_MODE2 (PWM_ETRG2_TRGMODE_MODE2_Val << PWM_ETRG2_TRGMODE_Pos) /**< (PWM_ETRG2) External PWM Start Mode Position */ 2609 #define PWM_ETRG2_TRGMODE_MODE3 (PWM_ETRG2_TRGMODE_MODE3_Val << PWM_ETRG2_TRGMODE_Pos) /**< (PWM_ETRG2) Cycle-by-cycle Duty Mode Position */ 2610 #define PWM_ETRG2_TRGEDGE_Pos 28 /**< (PWM_ETRG2) Edge Selection Position */ 2611 #define PWM_ETRG2_TRGEDGE_Msk (_U_(0x1) << PWM_ETRG2_TRGEDGE_Pos) /**< (PWM_ETRG2) Edge Selection Mask */ 2612 #define PWM_ETRG2_TRGEDGE PWM_ETRG2_TRGEDGE_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ETRG2_TRGEDGE_Msk instead */ 2613 #define PWM_ETRG2_TRGEDGE_FALLING_ZERO_Val _U_(0x0) /**< (PWM_ETRG2) TRGMODE = 1: TRGINx event detection on falling edge.TRGMODE = 2, 3: TRGINx active level is 0 */ 2614 #define PWM_ETRG2_TRGEDGE_RISING_ONE_Val _U_(0x1) /**< (PWM_ETRG2) TRGMODE = 1: TRGINx event detection on rising edge.TRGMODE = 2, 3: TRGINx active level is 1 */ 2615 #define PWM_ETRG2_TRGEDGE_FALLING_ZERO (PWM_ETRG2_TRGEDGE_FALLING_ZERO_Val << PWM_ETRG2_TRGEDGE_Pos) /**< (PWM_ETRG2) TRGMODE = 1: TRGINx event detection on falling edge.TRGMODE = 2, 3: TRGINx active level is 0 Position */ 2616 #define PWM_ETRG2_TRGEDGE_RISING_ONE (PWM_ETRG2_TRGEDGE_RISING_ONE_Val << PWM_ETRG2_TRGEDGE_Pos) /**< (PWM_ETRG2) TRGMODE = 1: TRGINx event detection on rising edge.TRGMODE = 2, 3: TRGINx active level is 1 Position */ 2617 #define PWM_ETRG2_TRGFILT_Pos 29 /**< (PWM_ETRG2) Filtered input Position */ 2618 #define PWM_ETRG2_TRGFILT_Msk (_U_(0x1) << PWM_ETRG2_TRGFILT_Pos) /**< (PWM_ETRG2) Filtered input Mask */ 2619 #define PWM_ETRG2_TRGFILT PWM_ETRG2_TRGFILT_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ETRG2_TRGFILT_Msk instead */ 2620 #define PWM_ETRG2_TRGSRC_Pos 30 /**< (PWM_ETRG2) Trigger Source Position */ 2621 #define PWM_ETRG2_TRGSRC_Msk (_U_(0x1) << PWM_ETRG2_TRGSRC_Pos) /**< (PWM_ETRG2) Trigger Source Mask */ 2622 #define PWM_ETRG2_TRGSRC PWM_ETRG2_TRGSRC_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ETRG2_TRGSRC_Msk instead */ 2623 #define PWM_ETRG2_RFEN_Pos 31 /**< (PWM_ETRG2) Recoverable Fault Enable Position */ 2624 #define PWM_ETRG2_RFEN_Msk (_U_(0x1) << PWM_ETRG2_RFEN_Pos) /**< (PWM_ETRG2) Recoverable Fault Enable Mask */ 2625 #define PWM_ETRG2_RFEN PWM_ETRG2_RFEN_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_ETRG2_RFEN_Msk instead */ 2626 #define PWM_ETRG2_MASK _U_(0xF3FFFFFF) /**< \deprecated (PWM_ETRG2) Register MASK (Use PWM_ETRG2_Msk instead) */ 2627 #define PWM_ETRG2_Msk _U_(0xF3FFFFFF) /**< (PWM_ETRG2) Register Mask */ 2628 2629 2630 /* -------- PWM_LEBR2 : (PWM Offset: 0x450) (R/W 32) PWM Leading-Edge Blanking Register (trg_num = 2) -------- */ 2631 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 2632 #if COMPONENT_TYPEDEF_STYLE == 'N' 2633 typedef union { 2634 struct { 2635 uint32_t LEBDELAY:7; /**< bit: 0..6 Leading-Edge Blanking Delay for TRGINx */ 2636 uint32_t :9; /**< bit: 7..15 Reserved */ 2637 uint32_t PWMLFEN:1; /**< bit: 16 PWML Falling Edge Enable */ 2638 uint32_t PWMLREN:1; /**< bit: 17 PWML Rising Edge Enable */ 2639 uint32_t PWMHFEN:1; /**< bit: 18 PWMH Falling Edge Enable */ 2640 uint32_t PWMHREN:1; /**< bit: 19 PWMH Rising Edge Enable */ 2641 uint32_t :12; /**< bit: 20..31 Reserved */ 2642 } bit; /**< Structure used for bit access */ 2643 uint32_t reg; /**< Type used for register access */ 2644 } PWM_LEBR2_Type; 2645 #endif 2646 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 2647 2648 #define PWM_LEBR2_OFFSET (0x450) /**< (PWM_LEBR2) PWM Leading-Edge Blanking Register (trg_num = 2) Offset */ 2649 2650 #define PWM_LEBR2_LEBDELAY_Pos 0 /**< (PWM_LEBR2) Leading-Edge Blanking Delay for TRGINx Position */ 2651 #define PWM_LEBR2_LEBDELAY_Msk (_U_(0x7F) << PWM_LEBR2_LEBDELAY_Pos) /**< (PWM_LEBR2) Leading-Edge Blanking Delay for TRGINx Mask */ 2652 #define PWM_LEBR2_LEBDELAY(value) (PWM_LEBR2_LEBDELAY_Msk & ((value) << PWM_LEBR2_LEBDELAY_Pos)) 2653 #define PWM_LEBR2_PWMLFEN_Pos 16 /**< (PWM_LEBR2) PWML Falling Edge Enable Position */ 2654 #define PWM_LEBR2_PWMLFEN_Msk (_U_(0x1) << PWM_LEBR2_PWMLFEN_Pos) /**< (PWM_LEBR2) PWML Falling Edge Enable Mask */ 2655 #define PWM_LEBR2_PWMLFEN PWM_LEBR2_PWMLFEN_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_LEBR2_PWMLFEN_Msk instead */ 2656 #define PWM_LEBR2_PWMLREN_Pos 17 /**< (PWM_LEBR2) PWML Rising Edge Enable Position */ 2657 #define PWM_LEBR2_PWMLREN_Msk (_U_(0x1) << PWM_LEBR2_PWMLREN_Pos) /**< (PWM_LEBR2) PWML Rising Edge Enable Mask */ 2658 #define PWM_LEBR2_PWMLREN PWM_LEBR2_PWMLREN_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_LEBR2_PWMLREN_Msk instead */ 2659 #define PWM_LEBR2_PWMHFEN_Pos 18 /**< (PWM_LEBR2) PWMH Falling Edge Enable Position */ 2660 #define PWM_LEBR2_PWMHFEN_Msk (_U_(0x1) << PWM_LEBR2_PWMHFEN_Pos) /**< (PWM_LEBR2) PWMH Falling Edge Enable Mask */ 2661 #define PWM_LEBR2_PWMHFEN PWM_LEBR2_PWMHFEN_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_LEBR2_PWMHFEN_Msk instead */ 2662 #define PWM_LEBR2_PWMHREN_Pos 19 /**< (PWM_LEBR2) PWMH Rising Edge Enable Position */ 2663 #define PWM_LEBR2_PWMHREN_Msk (_U_(0x1) << PWM_LEBR2_PWMHREN_Pos) /**< (PWM_LEBR2) PWMH Rising Edge Enable Mask */ 2664 #define PWM_LEBR2_PWMHREN PWM_LEBR2_PWMHREN_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_LEBR2_PWMHREN_Msk instead */ 2665 #define PWM_LEBR2_MASK _U_(0xF007F) /**< \deprecated (PWM_LEBR2) Register MASK (Use PWM_LEBR2_Msk instead) */ 2666 #define PWM_LEBR2_Msk _U_(0xF007F) /**< (PWM_LEBR2) Register Mask */ 2667 2668 2669 /* -------- PWM_CMUPD3 : (PWM Offset: 0x460) (/W 32) PWM Channel Mode Update Register (ch_num = 3) -------- */ 2670 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 2671 #if COMPONENT_TYPEDEF_STYLE == 'N' 2672 typedef union { 2673 struct { 2674 uint32_t :9; /**< bit: 0..8 Reserved */ 2675 uint32_t CPOLUP:1; /**< bit: 9 Channel Polarity Update */ 2676 uint32_t :3; /**< bit: 10..12 Reserved */ 2677 uint32_t CPOLINVUP:1; /**< bit: 13 Channel Polarity Inversion Update */ 2678 uint32_t :18; /**< bit: 14..31 Reserved */ 2679 } bit; /**< Structure used for bit access */ 2680 uint32_t reg; /**< Type used for register access */ 2681 } PWM_CMUPD3_Type; 2682 #endif 2683 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 2684 2685 #define PWM_CMUPD3_OFFSET (0x460) /**< (PWM_CMUPD3) PWM Channel Mode Update Register (ch_num = 3) Offset */ 2686 2687 #define PWM_CMUPD3_CPOLUP_Pos 9 /**< (PWM_CMUPD3) Channel Polarity Update Position */ 2688 #define PWM_CMUPD3_CPOLUP_Msk (_U_(0x1) << PWM_CMUPD3_CPOLUP_Pos) /**< (PWM_CMUPD3) Channel Polarity Update Mask */ 2689 #define PWM_CMUPD3_CPOLUP PWM_CMUPD3_CPOLUP_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_CMUPD3_CPOLUP_Msk instead */ 2690 #define PWM_CMUPD3_CPOLINVUP_Pos 13 /**< (PWM_CMUPD3) Channel Polarity Inversion Update Position */ 2691 #define PWM_CMUPD3_CPOLINVUP_Msk (_U_(0x1) << PWM_CMUPD3_CPOLINVUP_Pos) /**< (PWM_CMUPD3) Channel Polarity Inversion Update Mask */ 2692 #define PWM_CMUPD3_CPOLINVUP PWM_CMUPD3_CPOLINVUP_Msk /**< \deprecated Old style mask definition for 1 bit bitfield. Use PWM_CMUPD3_CPOLINVUP_Msk instead */ 2693 #define PWM_CMUPD3_MASK _U_(0x2200) /**< \deprecated (PWM_CMUPD3) Register MASK (Use PWM_CMUPD3_Msk instead) */ 2694 #define PWM_CMUPD3_Msk _U_(0x2200) /**< (PWM_CMUPD3) Register Mask */ 2695 2696 2697 #if !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) 2698 #if COMPONENT_TYPEDEF_STYLE == 'R' 2699 /** \brief PWM_CH_NUM hardware registers */ 2700 typedef struct { 2701 __IO uint32_t PWM_CMR; /**< (PWM_CH_NUM Offset: 0x00) PWM Channel Mode Register */ 2702 __IO uint32_t PWM_CDTY; /**< (PWM_CH_NUM Offset: 0x04) PWM Channel Duty Cycle Register */ 2703 __O uint32_t PWM_CDTYUPD; /**< (PWM_CH_NUM Offset: 0x08) PWM Channel Duty Cycle Update Register */ 2704 __IO uint32_t PWM_CPRD; /**< (PWM_CH_NUM Offset: 0x0C) PWM Channel Period Register */ 2705 __O uint32_t PWM_CPRDUPD; /**< (PWM_CH_NUM Offset: 0x10) PWM Channel Period Update Register */ 2706 __I uint32_t PWM_CCNT; /**< (PWM_CH_NUM Offset: 0x14) PWM Channel Counter Register */ 2707 __IO uint32_t PWM_DT; /**< (PWM_CH_NUM Offset: 0x18) PWM Channel Dead Time Register */ 2708 __O uint32_t PWM_DTUPD; /**< (PWM_CH_NUM Offset: 0x1C) PWM Channel Dead Time Update Register */ 2709 } PwmChNum; 2710 2711 /** \brief PWM_CMP hardware registers */ 2712 typedef struct { 2713 __IO uint32_t PWM_CMPV; /**< (PWM_CMP Offset: 0x00) PWM Comparison 0 Value Register */ 2714 __O uint32_t PWM_CMPVUPD; /**< (PWM_CMP Offset: 0x04) PWM Comparison 0 Value Update Register */ 2715 __IO uint32_t PWM_CMPM; /**< (PWM_CMP Offset: 0x08) PWM Comparison 0 Mode Register */ 2716 __O uint32_t PWM_CMPMUPD; /**< (PWM_CMP Offset: 0x0C) PWM Comparison 0 Mode Update Register */ 2717 } PwmCmp; 2718 2719 #define PWMCMP_NUMBER 8 2720 #define PWMCHNUM_NUMBER 4 2721 /** \brief PWM hardware registers */ 2722 typedef struct { 2723 __IO uint32_t PWM_CLK; /**< (PWM Offset: 0x00) PWM Clock Register */ 2724 __O uint32_t PWM_ENA; /**< (PWM Offset: 0x04) PWM Enable Register */ 2725 __O uint32_t PWM_DIS; /**< (PWM Offset: 0x08) PWM Disable Register */ 2726 __I uint32_t PWM_SR; /**< (PWM Offset: 0x0C) PWM Status Register */ 2727 __O uint32_t PWM_IER1; /**< (PWM Offset: 0x10) PWM Interrupt Enable Register 1 */ 2728 __O uint32_t PWM_IDR1; /**< (PWM Offset: 0x14) PWM Interrupt Disable Register 1 */ 2729 __I uint32_t PWM_IMR1; /**< (PWM Offset: 0x18) PWM Interrupt Mask Register 1 */ 2730 __I uint32_t PWM_ISR1; /**< (PWM Offset: 0x1C) PWM Interrupt Status Register 1 */ 2731 __IO uint32_t PWM_SCM; /**< (PWM Offset: 0x20) PWM Sync Channels Mode Register */ 2732 __O uint32_t PWM_DMAR; /**< (PWM Offset: 0x24) PWM DMA Register */ 2733 __IO uint32_t PWM_SCUC; /**< (PWM Offset: 0x28) PWM Sync Channels Update Control Register */ 2734 __IO uint32_t PWM_SCUP; /**< (PWM Offset: 0x2C) PWM Sync Channels Update Period Register */ 2735 __O uint32_t PWM_SCUPUPD; /**< (PWM Offset: 0x30) PWM Sync Channels Update Period Update Register */ 2736 __O uint32_t PWM_IER2; /**< (PWM Offset: 0x34) PWM Interrupt Enable Register 2 */ 2737 __O uint32_t PWM_IDR2; /**< (PWM Offset: 0x38) PWM Interrupt Disable Register 2 */ 2738 __I uint32_t PWM_IMR2; /**< (PWM Offset: 0x3C) PWM Interrupt Mask Register 2 */ 2739 __I uint32_t PWM_ISR2; /**< (PWM Offset: 0x40) PWM Interrupt Status Register 2 */ 2740 __IO uint32_t PWM_OOV; /**< (PWM Offset: 0x44) PWM Output Override Value Register */ 2741 __IO uint32_t PWM_OS; /**< (PWM Offset: 0x48) PWM Output Selection Register */ 2742 __O uint32_t PWM_OSS; /**< (PWM Offset: 0x4C) PWM Output Selection Set Register */ 2743 __O uint32_t PWM_OSC; /**< (PWM Offset: 0x50) PWM Output Selection Clear Register */ 2744 __O uint32_t PWM_OSSUPD; /**< (PWM Offset: 0x54) PWM Output Selection Set Update Register */ 2745 __O uint32_t PWM_OSCUPD; /**< (PWM Offset: 0x58) PWM Output Selection Clear Update Register */ 2746 __IO uint32_t PWM_FMR; /**< (PWM Offset: 0x5C) PWM Fault Mode Register */ 2747 __I uint32_t PWM_FSR; /**< (PWM Offset: 0x60) PWM Fault Status Register */ 2748 __O uint32_t PWM_FCR; /**< (PWM Offset: 0x64) PWM Fault Clear Register */ 2749 __IO uint32_t PWM_FPV1; /**< (PWM Offset: 0x68) PWM Fault Protection Value Register 1 */ 2750 __IO uint32_t PWM_FPE; /**< (PWM Offset: 0x6C) PWM Fault Protection Enable Register */ 2751 __I uint8_t Reserved1[12]; 2752 __IO uint32_t PWM_ELMR[2]; /**< (PWM Offset: 0x7C) PWM Event Line 0 Mode Register 0 */ 2753 __I uint8_t Reserved2[28]; 2754 __IO uint32_t PWM_SSPR; /**< (PWM Offset: 0xA0) PWM Spread Spectrum Register */ 2755 __O uint32_t PWM_SSPUP; /**< (PWM Offset: 0xA4) PWM Spread Spectrum Update Register */ 2756 __I uint8_t Reserved3[8]; 2757 __IO uint32_t PWM_SMMR; /**< (PWM Offset: 0xB0) PWM Stepper Motor Mode Register */ 2758 __I uint8_t Reserved4[12]; 2759 __IO uint32_t PWM_FPV2; /**< (PWM Offset: 0xC0) PWM Fault Protection Value 2 Register */ 2760 __I uint8_t Reserved5[32]; 2761 __O uint32_t PWM_WPCR; /**< (PWM Offset: 0xE4) PWM Write Protection Control Register */ 2762 __I uint32_t PWM_WPSR; /**< (PWM Offset: 0xE8) PWM Write Protection Status Register */ 2763 __I uint8_t Reserved6[68]; 2764 PwmCmp PWM_CMP[PWMCMP_NUMBER]; /**< Offset: 0x130 PWM Comparison 0 Value Register */ 2765 __I uint8_t Reserved7[80]; 2766 PwmChNum PWM_CH_NUM[PWMCHNUM_NUMBER]; /**< Offset: 0x200 PWM Channel Mode Register */ 2767 __I uint8_t Reserved8[384]; 2768 __O uint32_t PWM_CMUPD0; /**< (PWM Offset: 0x400) PWM Channel Mode Update Register (ch_num = 0) */ 2769 __I uint8_t Reserved9[28]; 2770 __O uint32_t PWM_CMUPD1; /**< (PWM Offset: 0x420) PWM Channel Mode Update Register (ch_num = 1) */ 2771 __I uint8_t Reserved10[8]; 2772 __IO uint32_t PWM_ETRG1; /**< (PWM Offset: 0x42C) PWM External Trigger Register (trg_num = 1) */ 2773 __IO uint32_t PWM_LEBR1; /**< (PWM Offset: 0x430) PWM Leading-Edge Blanking Register (trg_num = 1) */ 2774 __I uint8_t Reserved11[12]; 2775 __O uint32_t PWM_CMUPD2; /**< (PWM Offset: 0x440) PWM Channel Mode Update Register (ch_num = 2) */ 2776 __I uint8_t Reserved12[8]; 2777 __IO uint32_t PWM_ETRG2; /**< (PWM Offset: 0x44C) PWM External Trigger Register (trg_num = 2) */ 2778 __IO uint32_t PWM_LEBR2; /**< (PWM Offset: 0x450) PWM Leading-Edge Blanking Register (trg_num = 2) */ 2779 __I uint8_t Reserved13[12]; 2780 __O uint32_t PWM_CMUPD3; /**< (PWM Offset: 0x460) PWM Channel Mode Update Register (ch_num = 3) */ 2781 } Pwm; 2782 2783 #elif COMPONENT_TYPEDEF_STYLE == 'N' 2784 /** \brief PWM_CH_NUM hardware registers */ 2785 typedef struct { 2786 __IO PWM_CMR_Type PWM_CMR; /**< Offset: 0x00 (R/W 32) PWM Channel Mode Register */ 2787 __IO PWM_CDTY_Type PWM_CDTY; /**< Offset: 0x04 (R/W 32) PWM Channel Duty Cycle Register */ 2788 __O PWM_CDTYUPD_Type PWM_CDTYUPD; /**< Offset: 0x08 ( /W 32) PWM Channel Duty Cycle Update Register */ 2789 __IO PWM_CPRD_Type PWM_CPRD; /**< Offset: 0x0C (R/W 32) PWM Channel Period Register */ 2790 __O PWM_CPRDUPD_Type PWM_CPRDUPD; /**< Offset: 0x10 ( /W 32) PWM Channel Period Update Register */ 2791 __I PWM_CCNT_Type PWM_CCNT; /**< Offset: 0x14 (R/ 32) PWM Channel Counter Register */ 2792 __IO PWM_DT_Type PWM_DT; /**< Offset: 0x18 (R/W 32) PWM Channel Dead Time Register */ 2793 __O PWM_DTUPD_Type PWM_DTUPD; /**< Offset: 0x1C ( /W 32) PWM Channel Dead Time Update Register */ 2794 } PwmChNum; 2795 2796 /** \brief PWM_CMP hardware registers */ 2797 typedef struct { 2798 __IO PWM_CMPV_Type PWM_CMPV; /**< Offset: 0x00 (R/W 32) PWM Comparison 0 Value Register */ 2799 __O PWM_CMPVUPD_Type PWM_CMPVUPD; /**< Offset: 0x04 ( /W 32) PWM Comparison 0 Value Update Register */ 2800 __IO PWM_CMPM_Type PWM_CMPM; /**< Offset: 0x08 (R/W 32) PWM Comparison 0 Mode Register */ 2801 __O PWM_CMPMUPD_Type PWM_CMPMUPD; /**< Offset: 0x0C ( /W 32) PWM Comparison 0 Mode Update Register */ 2802 } PwmCmp; 2803 2804 /** \brief PWM hardware registers */ 2805 typedef struct { 2806 __IO PWM_CLK_Type PWM_CLK; /**< Offset: 0x00 (R/W 32) PWM Clock Register */ 2807 __O PWM_ENA_Type PWM_ENA; /**< Offset: 0x04 ( /W 32) PWM Enable Register */ 2808 __O PWM_DIS_Type PWM_DIS; /**< Offset: 0x08 ( /W 32) PWM Disable Register */ 2809 __I PWM_SR_Type PWM_SR; /**< Offset: 0x0C (R/ 32) PWM Status Register */ 2810 __O PWM_IER1_Type PWM_IER1; /**< Offset: 0x10 ( /W 32) PWM Interrupt Enable Register 1 */ 2811 __O PWM_IDR1_Type PWM_IDR1; /**< Offset: 0x14 ( /W 32) PWM Interrupt Disable Register 1 */ 2812 __I PWM_IMR1_Type PWM_IMR1; /**< Offset: 0x18 (R/ 32) PWM Interrupt Mask Register 1 */ 2813 __I PWM_ISR1_Type PWM_ISR1; /**< Offset: 0x1C (R/ 32) PWM Interrupt Status Register 1 */ 2814 __IO PWM_SCM_Type PWM_SCM; /**< Offset: 0x20 (R/W 32) PWM Sync Channels Mode Register */ 2815 __O PWM_DMAR_Type PWM_DMAR; /**< Offset: 0x24 ( /W 32) PWM DMA Register */ 2816 __IO PWM_SCUC_Type PWM_SCUC; /**< Offset: 0x28 (R/W 32) PWM Sync Channels Update Control Register */ 2817 __IO PWM_SCUP_Type PWM_SCUP; /**< Offset: 0x2C (R/W 32) PWM Sync Channels Update Period Register */ 2818 __O PWM_SCUPUPD_Type PWM_SCUPUPD; /**< Offset: 0x30 ( /W 32) PWM Sync Channels Update Period Update Register */ 2819 __O PWM_IER2_Type PWM_IER2; /**< Offset: 0x34 ( /W 32) PWM Interrupt Enable Register 2 */ 2820 __O PWM_IDR2_Type PWM_IDR2; /**< Offset: 0x38 ( /W 32) PWM Interrupt Disable Register 2 */ 2821 __I PWM_IMR2_Type PWM_IMR2; /**< Offset: 0x3C (R/ 32) PWM Interrupt Mask Register 2 */ 2822 __I PWM_ISR2_Type PWM_ISR2; /**< Offset: 0x40 (R/ 32) PWM Interrupt Status Register 2 */ 2823 __IO PWM_OOV_Type PWM_OOV; /**< Offset: 0x44 (R/W 32) PWM Output Override Value Register */ 2824 __IO PWM_OS_Type PWM_OS; /**< Offset: 0x48 (R/W 32) PWM Output Selection Register */ 2825 __O PWM_OSS_Type PWM_OSS; /**< Offset: 0x4C ( /W 32) PWM Output Selection Set Register */ 2826 __O PWM_OSC_Type PWM_OSC; /**< Offset: 0x50 ( /W 32) PWM Output Selection Clear Register */ 2827 __O PWM_OSSUPD_Type PWM_OSSUPD; /**< Offset: 0x54 ( /W 32) PWM Output Selection Set Update Register */ 2828 __O PWM_OSCUPD_Type PWM_OSCUPD; /**< Offset: 0x58 ( /W 32) PWM Output Selection Clear Update Register */ 2829 __IO PWM_FMR_Type PWM_FMR; /**< Offset: 0x5C (R/W 32) PWM Fault Mode Register */ 2830 __I PWM_FSR_Type PWM_FSR; /**< Offset: 0x60 (R/ 32) PWM Fault Status Register */ 2831 __O PWM_FCR_Type PWM_FCR; /**< Offset: 0x64 ( /W 32) PWM Fault Clear Register */ 2832 __IO PWM_FPV1_Type PWM_FPV1; /**< Offset: 0x68 (R/W 32) PWM Fault Protection Value Register 1 */ 2833 __IO PWM_FPE_Type PWM_FPE; /**< Offset: 0x6C (R/W 32) PWM Fault Protection Enable Register */ 2834 __I uint8_t Reserved1[12]; 2835 __IO PWM_ELMR_Type PWM_ELMR[2]; /**< Offset: 0x7C (R/W 32) PWM Event Line 0 Mode Register 0 */ 2836 __I uint8_t Reserved2[28]; 2837 __IO PWM_SSPR_Type PWM_SSPR; /**< Offset: 0xA0 (R/W 32) PWM Spread Spectrum Register */ 2838 __O PWM_SSPUP_Type PWM_SSPUP; /**< Offset: 0xA4 ( /W 32) PWM Spread Spectrum Update Register */ 2839 __I uint8_t Reserved3[8]; 2840 __IO PWM_SMMR_Type PWM_SMMR; /**< Offset: 0xB0 (R/W 32) PWM Stepper Motor Mode Register */ 2841 __I uint8_t Reserved4[12]; 2842 __IO PWM_FPV2_Type PWM_FPV2; /**< Offset: 0xC0 (R/W 32) PWM Fault Protection Value 2 Register */ 2843 __I uint8_t Reserved5[32]; 2844 __O PWM_WPCR_Type PWM_WPCR; /**< Offset: 0xE4 ( /W 32) PWM Write Protection Control Register */ 2845 __I PWM_WPSR_Type PWM_WPSR; /**< Offset: 0xE8 (R/ 32) PWM Write Protection Status Register */ 2846 __I uint8_t Reserved6[68]; 2847 PwmCmp PWM_CMP[8]; /**< Offset: 0x130 PWM Comparison 0 Value Register */ 2848 __I uint8_t Reserved7[80]; 2849 PwmChNum PWM_CH_NUM[4]; /**< Offset: 0x200 PWM Channel Mode Register */ 2850 __I uint8_t Reserved8[384]; 2851 __O PWM_CMUPD0_Type PWM_CMUPD0; /**< Offset: 0x400 ( /W 32) PWM Channel Mode Update Register (ch_num = 0) */ 2852 __I uint8_t Reserved9[28]; 2853 __O PWM_CMUPD1_Type PWM_CMUPD1; /**< Offset: 0x420 ( /W 32) PWM Channel Mode Update Register (ch_num = 1) */ 2854 __I uint8_t Reserved10[8]; 2855 __IO PWM_ETRG1_Type PWM_ETRG1; /**< Offset: 0x42C (R/W 32) PWM External Trigger Register (trg_num = 1) */ 2856 __IO PWM_LEBR1_Type PWM_LEBR1; /**< Offset: 0x430 (R/W 32) PWM Leading-Edge Blanking Register (trg_num = 1) */ 2857 __I uint8_t Reserved11[12]; 2858 __O PWM_CMUPD2_Type PWM_CMUPD2; /**< Offset: 0x440 ( /W 32) PWM Channel Mode Update Register (ch_num = 2) */ 2859 __I uint8_t Reserved12[8]; 2860 __IO PWM_ETRG2_Type PWM_ETRG2; /**< Offset: 0x44C (R/W 32) PWM External Trigger Register (trg_num = 2) */ 2861 __IO PWM_LEBR2_Type PWM_LEBR2; /**< Offset: 0x450 (R/W 32) PWM Leading-Edge Blanking Register (trg_num = 2) */ 2862 __I uint8_t Reserved13[12]; 2863 __O PWM_CMUPD3_Type PWM_CMUPD3; /**< Offset: 0x460 ( /W 32) PWM Channel Mode Update Register (ch_num = 3) */ 2864 } Pwm; 2865 2866 #else /* COMPONENT_TYPEDEF_STYLE */ 2867 #error Unknown component typedef style 2868 #endif /* COMPONENT_TYPEDEF_STYLE */ 2869 2870 #endif /* !(defined(__ASSEMBLER__) || defined(__IAR_SYSTEMS_ASM__)) */ 2871 /** @} end of Pulse Width Modulation Controller */ 2872 2873 #endif /* _SAME70_PWM_COMPONENT_H_ */ 2874
