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