1 /**************************************************************************//** 2 * @file 3 * @brief Device Manager API Definition 4 ****************************************************************************** 5 * # License 6 * <b>Copyright 2024 Silicon Laboratories, Inc. www.silabs.com</b> 7 ****************************************************************************** 8 * 9 * SPDX-License-Identifier: Zlib 10 * 11 * The licensor of this software is Silicon Laboratories Inc. 12 * 13 * This software is provided 'as-is', without any express or implied 14 * warranty. In no event will the authors be held liable for any damages 15 * arising from the use of this software. 16 * 17 * Permission is granted to anyone to use this software for any purpose, 18 * including commercial applications, and to alter it and redistribute it 19 * freely, subject to the following restrictions: 20 * 21 * 1. The origin of this software must not be misrepresented; you must not 22 * claim that you wrote the original software. If you use this software 23 * in a product, an acknowledgment in the product documentation would be 24 * appreciated but is not required. 25 * 2. Altered source versions must be plainly marked as such, and must not be 26 * misrepresented as being the original software. 27 * 3. This notice may not be removed or altered from any source distribution. 28 * 29 *****************************************************************************/ 30 31 #include "sl_device_peripheral.h" 32 #include "sl_device_clock.h" 33 #include "cmsis_compiler.h" 34 35 /***************************************************************************//** 36 * Device Abstraction Peripheral default values. 37 ******************************************************************************/ 38 // Weak definition of peripheral ACMP0. 39 __WEAK const sl_peripheral_val_t sl_peripheral_val_acmp0 = { .base = 0xFFFFFFFF, 40 .clk_branch = SL_CLOCK_BRANCH_INVALID, 41 .bus_clock = SL_BUS_CLOCK_INVALID }; 42 43 // Weak definition of peripheral ACMP1. 44 __WEAK const sl_peripheral_val_t sl_peripheral_val_acmp1 = { .base = 0xFFFFFFFF, 45 .clk_branch = SL_CLOCK_BRANCH_INVALID, 46 .bus_clock = SL_BUS_CLOCK_INVALID }; 47 48 // Weak definition of peripheral ADC0. 49 __WEAK const sl_peripheral_val_t sl_peripheral_val_adc0 = { .base = 0xFFFFFFFF, 50 .clk_branch = SL_CLOCK_BRANCH_INVALID, 51 .bus_clock = SL_BUS_CLOCK_INVALID }; 52 53 // Weak definition of peripheral AES. 54 __WEAK const sl_peripheral_val_t sl_peripheral_val_aes = { .base = 0xFFFFFFFF, 55 .clk_branch = SL_CLOCK_BRANCH_INVALID, 56 .bus_clock = SL_BUS_CLOCK_INVALID }; 57 58 // Weak definition of peripheral AMUXCP0. 59 __WEAK const sl_peripheral_val_t sl_peripheral_val_amuxcp0 = { .base = 0xFFFFFFFF, 60 .clk_branch = SL_CLOCK_BRANCH_INVALID, 61 .bus_clock = SL_BUS_CLOCK_INVALID }; 62 63 // Weak definition of peripheral BUFC. 64 __WEAK const sl_peripheral_val_t sl_peripheral_val_bufc = { .base = 0xFFFFFFFF, 65 .clk_branch = SL_CLOCK_BRANCH_INVALID, 66 .bus_clock = SL_BUS_CLOCK_INVALID }; 67 68 // Weak definition of peripheral BURAM. 69 __WEAK const sl_peripheral_val_t sl_peripheral_val_buram = { .base = 0xFFFFFFFF, 70 .clk_branch = SL_CLOCK_BRANCH_INVALID, 71 .bus_clock = SL_BUS_CLOCK_INVALID }; 72 73 // Weak definition of peripheral BURTC. 74 __WEAK const sl_peripheral_val_t sl_peripheral_val_burtc = { .base = 0xFFFFFFFF, 75 .clk_branch = SL_CLOCK_BRANCH_INVALID, 76 .bus_clock = SL_BUS_CLOCK_INVALID }; 77 78 // Weak definition of peripheral CMU. 79 __WEAK const sl_peripheral_val_t sl_peripheral_val_cmu = { .base = 0xFFFFFFFF, 80 .clk_branch = SL_CLOCK_BRANCH_INVALID, 81 .bus_clock = SL_BUS_CLOCK_INVALID }; 82 83 // Weak definition of peripheral CRYPTOACC. 84 __WEAK const sl_peripheral_val_t sl_peripheral_val_cryptoacc = { .base = 0xFFFFFFFF, 85 .clk_branch = SL_CLOCK_BRANCH_INVALID, 86 .bus_clock = SL_BUS_CLOCK_INVALID }; 87 88 // Weak definition of peripheral DCDC. 89 __WEAK const sl_peripheral_val_t sl_peripheral_val_dcdc = { .base = 0xFFFFFFFF, 90 .clk_branch = SL_CLOCK_BRANCH_INVALID, 91 .bus_clock = SL_BUS_CLOCK_INVALID }; 92 93 // Weak definition of peripheral DEVINFO. 94 __WEAK const sl_peripheral_val_t sl_peripheral_val_devinfo = { .base = 0xFFFFFFFF, 95 .clk_branch = SL_CLOCK_BRANCH_INVALID, 96 .bus_clock = SL_BUS_CLOCK_INVALID }; 97 98 // Weak definition of peripheral DMEM. 99 __WEAK const sl_peripheral_val_t sl_peripheral_val_dmem = { .base = 0xFFFFFFFF, 100 .clk_branch = SL_CLOCK_BRANCH_INVALID, 101 .bus_clock = SL_BUS_CLOCK_INVALID }; 102 103 // Weak definition of peripheral DMEM0. 104 __WEAK const sl_peripheral_val_t sl_peripheral_val_dmem0 = { .base = 0xFFFFFFFF, 105 .clk_branch = SL_CLOCK_BRANCH_INVALID, 106 .bus_clock = SL_BUS_CLOCK_INVALID }; 107 108 // Weak definition of peripheral DMEM1. 109 __WEAK const sl_peripheral_val_t sl_peripheral_val_dmem1 = { .base = 0xFFFFFFFF, 110 .clk_branch = SL_CLOCK_BRANCH_INVALID, 111 .bus_clock = SL_BUS_CLOCK_INVALID }; 112 113 // Weak definition of peripheral DPLL0. 114 __WEAK const sl_peripheral_val_t sl_peripheral_val_dpll0 = { .base = 0xFFFFFFFF, 115 .clk_branch = SL_CLOCK_BRANCH_INVALID, 116 .bus_clock = SL_BUS_CLOCK_INVALID }; 117 118 // Weak definition of peripheral EMU. 119 __WEAK const sl_peripheral_val_t sl_peripheral_val_emu = { .base = 0xFFFFFFFF, 120 .clk_branch = SL_CLOCK_BRANCH_INVALID, 121 .bus_clock = SL_BUS_CLOCK_INVALID }; 122 123 // Weak definition of peripheral ETAMPDET. 124 __WEAK const sl_peripheral_val_t sl_peripheral_val_etampdet = { .base = 0xFFFFFFFF, 125 .clk_branch = SL_CLOCK_BRANCH_INVALID, 126 .bus_clock = SL_BUS_CLOCK_INVALID }; 127 128 // Weak definition of peripheral EUART0. 129 __WEAK const sl_peripheral_val_t sl_peripheral_val_euart0 = { .base = 0xFFFFFFFF, 130 .clk_branch = SL_CLOCK_BRANCH_INVALID, 131 .bus_clock = SL_BUS_CLOCK_INVALID }; 132 133 // Weak definition of peripheral EUSART0. 134 __WEAK const sl_peripheral_val_t sl_peripheral_val_eusart0 = { .base = 0xFFFFFFFF, 135 .clk_branch = SL_CLOCK_BRANCH_INVALID, 136 .bus_clock = SL_BUS_CLOCK_INVALID }; 137 138 // Weak definition of peripheral EUSART1. 139 __WEAK const sl_peripheral_val_t sl_peripheral_val_eusart1 = { .base = 0xFFFFFFFF, 140 .clk_branch = SL_CLOCK_BRANCH_INVALID, 141 .bus_clock = SL_BUS_CLOCK_INVALID }; 142 143 // Weak definition of peripheral EUSART2. 144 __WEAK const sl_peripheral_val_t sl_peripheral_val_eusart2 = { .base = 0xFFFFFFFF, 145 .clk_branch = SL_CLOCK_BRANCH_INVALID, 146 .bus_clock = SL_BUS_CLOCK_INVALID }; 147 148 // Weak definition of peripheral EUSART3. 149 __WEAK const sl_peripheral_val_t sl_peripheral_val_eusart3 = { .base = 0xFFFFFFFF, 150 .clk_branch = SL_CLOCK_BRANCH_INVALID, 151 .bus_clock = SL_BUS_CLOCK_INVALID }; 152 153 // Weak definition of peripheral EUSART4. 154 __WEAK const sl_peripheral_val_t sl_peripheral_val_eusart4 = { .base = 0xFFFFFFFF, 155 .clk_branch = SL_CLOCK_BRANCH_INVALID, 156 .bus_clock = SL_BUS_CLOCK_INVALID }; 157 158 // Weak definition of peripheral FSRCO. 159 __WEAK const sl_peripheral_val_t sl_peripheral_val_fsrco = { .base = 0xFFFFFFFF, 160 .clk_branch = SL_CLOCK_BRANCH_INVALID, 161 .bus_clock = SL_BUS_CLOCK_INVALID }; 162 163 // Weak definition of peripheral GPCRC0. 164 __WEAK const sl_peripheral_val_t sl_peripheral_val_gpcrc0 = { .base = 0xFFFFFFFF, 165 .clk_branch = SL_CLOCK_BRANCH_INVALID, 166 .bus_clock = SL_BUS_CLOCK_INVALID }; 167 168 // Weak definition of peripheral GPIO. 169 __WEAK const sl_peripheral_val_t sl_peripheral_val_gpio = { .base = 0xFFFFFFFF, 170 .clk_branch = SL_CLOCK_BRANCH_INVALID, 171 .bus_clock = SL_BUS_CLOCK_INVALID }; 172 173 // Weak definition of peripheral HFRCO0. 174 __WEAK const sl_peripheral_val_t sl_peripheral_val_hfrco0 = { .base = 0xFFFFFFFF, 175 .clk_branch = SL_CLOCK_BRANCH_INVALID, 176 .bus_clock = SL_BUS_CLOCK_INVALID }; 177 178 // Weak definition of peripheral HFRCOEM23. 179 __WEAK const sl_peripheral_val_t sl_peripheral_val_hfrcoem23 = { .base = 0xFFFFFFFF, 180 .clk_branch = SL_CLOCK_BRANCH_INVALID, 181 .bus_clock = SL_BUS_CLOCK_INVALID }; 182 183 // Weak definition of peripheral HFXO0. 184 __WEAK const sl_peripheral_val_t sl_peripheral_val_hfxo0 = { .base = 0xFFFFFFFF, 185 .clk_branch = SL_CLOCK_BRANCH_INVALID, 186 .bus_clock = SL_BUS_CLOCK_INVALID }; 187 188 // Weak definition of peripheral HOSTMAILBOX. 189 __WEAK const sl_peripheral_val_t sl_peripheral_val_hostmailbox = { .base = 0xFFFFFFFF, 190 .clk_branch = SL_CLOCK_BRANCH_INVALID, 191 .bus_clock = SL_BUS_CLOCK_INVALID }; 192 193 // Weak definition of peripheral HOSTPORTAL. 194 __WEAK const sl_peripheral_val_t sl_peripheral_val_hostportal = { .base = 0xFFFFFFFF, 195 .clk_branch = SL_CLOCK_BRANCH_INVALID, 196 .bus_clock = SL_BUS_CLOCK_INVALID }; 197 198 // Weak definition of peripheral I2C0. 199 __WEAK const sl_peripheral_val_t sl_peripheral_val_i2c0 = { .base = 0xFFFFFFFF, 200 .clk_branch = SL_CLOCK_BRANCH_INVALID, 201 .bus_clock = SL_BUS_CLOCK_INVALID }; 202 203 // Weak definition of peripheral I2C1. 204 __WEAK const sl_peripheral_val_t sl_peripheral_val_i2c1 = { .base = 0xFFFFFFFF, 205 .clk_branch = SL_CLOCK_BRANCH_INVALID, 206 .bus_clock = SL_BUS_CLOCK_INVALID }; 207 208 // Weak definition of peripheral I2C2. 209 __WEAK const sl_peripheral_val_t sl_peripheral_val_i2c2 = { .base = 0xFFFFFFFF, 210 .clk_branch = SL_CLOCK_BRANCH_INVALID, 211 .bus_clock = SL_BUS_CLOCK_INVALID }; 212 213 // Weak definition of peripheral I2C3. 214 __WEAK const sl_peripheral_val_t sl_peripheral_val_i2c3 = { .base = 0xFFFFFFFF, 215 .clk_branch = SL_CLOCK_BRANCH_INVALID, 216 .bus_clock = SL_BUS_CLOCK_INVALID }; 217 218 // Weak definition of peripheral IADC0. 219 __WEAK const sl_peripheral_val_t sl_peripheral_val_iadc0 = { .base = 0xFFFFFFFF, 220 .clk_branch = SL_CLOCK_BRANCH_INVALID, 221 .bus_clock = SL_BUS_CLOCK_INVALID }; 222 223 // Weak definition of peripheral ICACHE0. 224 __WEAK const sl_peripheral_val_t sl_peripheral_val_icache0 = { .base = 0xFFFFFFFF, 225 .clk_branch = SL_CLOCK_BRANCH_INVALID, 226 .bus_clock = SL_BUS_CLOCK_INVALID }; 227 228 // Weak definition of peripheral KEYSCAN. 229 __WEAK const sl_peripheral_val_t sl_peripheral_val_keyscan = { .base = 0xFFFFFFFF, 230 .clk_branch = SL_CLOCK_BRANCH_INVALID, 231 .bus_clock = SL_BUS_CLOCK_INVALID }; 232 233 // Weak definition of peripheral L1ICACHE0. 234 __WEAK const sl_peripheral_val_t sl_peripheral_val_l1icache0 = { .base = 0xFFFFFFFF, 235 .clk_branch = SL_CLOCK_BRANCH_INVALID, 236 .bus_clock = SL_BUS_CLOCK_INVALID }; 237 238 // Weak definition of peripheral L2ICACHE0. 239 __WEAK const sl_peripheral_val_t sl_peripheral_val_l2icache0 = { .base = 0xFFFFFFFF, 240 .clk_branch = SL_CLOCK_BRANCH_INVALID, 241 .bus_clock = SL_BUS_CLOCK_INVALID }; 242 243 // Weak definition of peripheral LCD. 244 __WEAK const sl_peripheral_val_t sl_peripheral_val_lcd = { .base = 0xFFFFFFFF, 245 .clk_branch = SL_CLOCK_BRANCH_INVALID, 246 .bus_clock = SL_BUS_CLOCK_INVALID }; 247 248 // Weak definition of peripheral LCDRF. 249 __WEAK const sl_peripheral_val_t sl_peripheral_val_lcdrf = { .base = 0xFFFFFFFF, 250 .clk_branch = SL_CLOCK_BRANCH_INVALID, 251 .bus_clock = SL_BUS_CLOCK_INVALID }; 252 253 // Weak definition of peripheral LDMA0. 254 __WEAK const sl_peripheral_val_t sl_peripheral_val_ldma0 = { .base = 0xFFFFFFFF, 255 .clk_branch = SL_CLOCK_BRANCH_INVALID, 256 .bus_clock = SL_BUS_CLOCK_INVALID }; 257 258 // Weak definition of peripheral LDMAXBAR0. 259 __WEAK const sl_peripheral_val_t sl_peripheral_val_ldmaxbar0 = { .base = 0xFFFFFFFF, 260 .clk_branch = SL_CLOCK_BRANCH_INVALID, 261 .bus_clock = SL_BUS_CLOCK_INVALID }; 262 263 // Weak definition of peripheral LEDDRV0. 264 __WEAK const sl_peripheral_val_t sl_peripheral_val_leddrv0 = { .base = 0xFFFFFFFF, 265 .clk_branch = SL_CLOCK_BRANCH_INVALID, 266 .bus_clock = SL_BUS_CLOCK_INVALID }; 267 268 // Weak definition of peripheral LESENSE. 269 __WEAK const sl_peripheral_val_t sl_peripheral_val_lesense = { .base = 0xFFFFFFFF, 270 .clk_branch = SL_CLOCK_BRANCH_INVALID, 271 .bus_clock = SL_BUS_CLOCK_INVALID }; 272 273 // Weak definition of peripheral LETIMER0. 274 __WEAK const sl_peripheral_val_t sl_peripheral_val_letimer0 = { .base = 0xFFFFFFFF, 275 .clk_branch = SL_CLOCK_BRANCH_INVALID, 276 .bus_clock = SL_BUS_CLOCK_INVALID }; 277 278 // Weak definition of peripheral LFRCO. 279 __WEAK const sl_peripheral_val_t sl_peripheral_val_lfrco = { .base = 0xFFFFFFFF, 280 .clk_branch = SL_CLOCK_BRANCH_INVALID, 281 .bus_clock = SL_BUS_CLOCK_INVALID }; 282 283 // Weak definition of peripheral LFXO. 284 __WEAK const sl_peripheral_val_t sl_peripheral_val_lfxo = { .base = 0xFFFFFFFF, 285 .clk_branch = SL_CLOCK_BRANCH_INVALID, 286 .bus_clock = SL_BUS_CLOCK_INVALID }; 287 288 // Weak definition of peripheral LPWAES. 289 __WEAK const sl_peripheral_val_t sl_peripheral_val_lpwaes = { .base = 0xFFFFFFFF, 290 .clk_branch = SL_CLOCK_BRANCH_INVALID, 291 .bus_clock = SL_BUS_CLOCK_INVALID }; 292 293 // Weak definition of peripheral LPW0PORTAL. 294 __WEAK const sl_peripheral_val_t sl_peripheral_val_lpw0portal = { .base = 0xFFFFFFFF, 295 .clk_branch = SL_CLOCK_BRANCH_INVALID, 296 .bus_clock = SL_BUS_CLOCK_INVALID }; 297 298 // Weak definition of peripheral LVGD. 299 __WEAK const sl_peripheral_val_t sl_peripheral_val_lvgd = { .base = 0xFFFFFFFF, 300 .clk_branch = SL_CLOCK_BRANCH_INVALID, 301 .bus_clock = SL_BUS_CLOCK_INVALID }; 302 303 // Weak definition of peripheral MPAHBRAM. 304 __WEAK const sl_peripheral_val_t sl_peripheral_val_mpahbram = { .base = 0xFFFFFFFF, 305 .clk_branch = SL_CLOCK_BRANCH_INVALID, 306 .bus_clock = SL_BUS_CLOCK_INVALID }; 307 308 // Weak definition of peripheral MSC. 309 __WEAK const sl_peripheral_val_t sl_peripheral_val_msc = { .base = 0xFFFFFFFF, 310 .clk_branch = SL_CLOCK_BRANCH_INVALID, 311 .bus_clock = SL_BUS_CLOCK_INVALID }; 312 313 // Weak definition of peripheral MVP. 314 __WEAK const sl_peripheral_val_t sl_peripheral_val_mvp = { .base = 0xFFFFFFFF, 315 .clk_branch = SL_CLOCK_BRANCH_INVALID, 316 .bus_clock = SL_BUS_CLOCK_INVALID }; 317 318 // Weak definition of peripheral PCNT0. 319 __WEAK const sl_peripheral_val_t sl_peripheral_val_pcnt0 = { .base = 0xFFFFFFFF, 320 .clk_branch = SL_CLOCK_BRANCH_INVALID, 321 .bus_clock = SL_BUS_CLOCK_INVALID }; 322 323 // Weak definition of peripheral PDM. 324 __WEAK const sl_peripheral_val_t sl_peripheral_val_pdm = { .base = 0xFFFFFFFF, 325 .clk_branch = SL_CLOCK_BRANCH_INVALID, 326 .bus_clock = SL_BUS_CLOCK_INVALID }; 327 328 // Weak definition of peripheral PFMXPPRF. 329 __WEAK const sl_peripheral_val_t sl_peripheral_val_pfmxpprf = { .base = 0xFFFFFFFF, 330 .clk_branch = SL_CLOCK_BRANCH_INVALID, 331 .bus_clock = SL_BUS_CLOCK_INVALID }; 332 333 // Weak definition of peripheral PIXELRZ0. 334 __WEAK const sl_peripheral_val_t sl_peripheral_val_pixelrz0 = { .base = 0xFFFFFFFF, 335 .clk_branch = SL_CLOCK_BRANCH_INVALID, 336 .bus_clock = SL_BUS_CLOCK_INVALID }; 337 338 // Weak definition of peripheral PIXELRZ1. 339 __WEAK const sl_peripheral_val_t sl_peripheral_val_pixelrz1 = { .base = 0xFFFFFFFF, 340 .clk_branch = SL_CLOCK_BRANCH_INVALID, 341 .bus_clock = SL_BUS_CLOCK_INVALID }; 342 343 // Weak definition of peripheral PRORTC. 344 __WEAK const sl_peripheral_val_t sl_peripheral_val_prortc = { .base = 0xFFFFFFFF, 345 .clk_branch = SL_CLOCK_BRANCH_INVALID, 346 .bus_clock = SL_BUS_CLOCK_INVALID }; 347 348 // Weak definition of peripheral PRS. 349 __WEAK const sl_peripheral_val_t sl_peripheral_val_prs = { .base = 0xFFFFFFFF, 350 .clk_branch = SL_CLOCK_BRANCH_INVALID, 351 .bus_clock = SL_BUS_CLOCK_INVALID }; 352 353 // Weak definition of peripheral RADIOAES. 354 __WEAK const sl_peripheral_val_t sl_peripheral_val_radioaes = { .base = 0xFFFFFFFF, 355 .clk_branch = SL_CLOCK_BRANCH_INVALID, 356 .bus_clock = SL_BUS_CLOCK_INVALID }; 357 358 // Weak definition of peripheral RFFPLL0. 359 __WEAK const sl_peripheral_val_t sl_peripheral_val_rffpll0 = { .base = 0xFFFFFFFF, 360 .clk_branch = SL_CLOCK_BRANCH_INVALID, 361 .bus_clock = SL_BUS_CLOCK_INVALID }; 362 363 // Weak definition of peripheral RPA. 364 __WEAK const sl_peripheral_val_t sl_peripheral_val_rpa = { .base = 0xFFFFFFFF, 365 .clk_branch = SL_CLOCK_BRANCH_INVALID, 366 .bus_clock = SL_BUS_CLOCK_INVALID }; 367 368 // Weak definition of peripheral RTCC. 369 __WEAK const sl_peripheral_val_t sl_peripheral_val_rtcc = { .base = 0xFFFFFFFF, 370 .clk_branch = SL_CLOCK_BRANCH_INVALID, 371 .bus_clock = SL_BUS_CLOCK_INVALID }; 372 373 // Weak definition of peripheral SCRATCHPAD. 374 __WEAK const sl_peripheral_val_t sl_peripheral_val_scratchpad = { .base = 0xFFFFFFFF, 375 .clk_branch = SL_CLOCK_BRANCH_INVALID, 376 .bus_clock = SL_BUS_CLOCK_INVALID }; 377 378 // Weak definition of peripheral SEMAILBOX. 379 __WEAK const sl_peripheral_val_t sl_peripheral_val_semailbox = { .base = 0xFFFFFFFF, 380 .clk_branch = SL_CLOCK_BRANCH_INVALID, 381 .bus_clock = SL_BUS_CLOCK_INVALID }; 382 383 // Weak definition of peripheral SEMAPHORE0. 384 __WEAK const sl_peripheral_val_t sl_peripheral_val_semaphore0 = { .base = 0xFFFFFFFF, 385 .clk_branch = SL_CLOCK_BRANCH_INVALID, 386 .bus_clock = SL_BUS_CLOCK_INVALID }; 387 388 // Weak definition of peripheral SEMAPHORE1. 389 __WEAK const sl_peripheral_val_t sl_peripheral_val_semaphore1 = { .base = 0xFFFFFFFF, 390 .clk_branch = SL_CLOCK_BRANCH_INVALID, 391 .bus_clock = SL_BUS_CLOCK_INVALID }; 392 393 // Weak definition of peripheral SEPORTAL. 394 __WEAK const sl_peripheral_val_t sl_peripheral_val_seportal = { .base = 0xFFFFFFFF, 395 .clk_branch = SL_CLOCK_BRANCH_INVALID, 396 .bus_clock = SL_BUS_CLOCK_INVALID }; 397 398 // Weak definition of peripheral SEPUF. 399 __WEAK const sl_peripheral_val_t sl_peripheral_val_sepuf = { .base = 0xFFFFFFFF, 400 .clk_branch = SL_CLOCK_BRANCH_INVALID, 401 .bus_clock = SL_BUS_CLOCK_INVALID }; 402 403 // Weak definition of peripheral SMU. 404 __WEAK const sl_peripheral_val_t sl_peripheral_val_smu = { .base = 0xFFFFFFFF, 405 .clk_branch = SL_CLOCK_BRANCH_INVALID, 406 .bus_clock = SL_BUS_CLOCK_INVALID }; 407 408 // Weak definition of peripheral SOCPLL0. 409 __WEAK const sl_peripheral_val_t sl_peripheral_val_socpll0 = { .base = 0xFFFFFFFF, 410 .clk_branch = SL_CLOCK_BRANCH_INVALID, 411 .bus_clock = SL_BUS_CLOCK_INVALID }; 412 413 // Weak definition of peripheral SYMCRYPTO. 414 __WEAK const sl_peripheral_val_t sl_peripheral_val_symcrypto = { .base = 0xFFFFFFFF, 415 .clk_branch = SL_CLOCK_BRANCH_INVALID, 416 .bus_clock = SL_BUS_CLOCK_INVALID }; 417 418 // Weak definition of peripheral SYSCFG. 419 __WEAK const sl_peripheral_val_t sl_peripheral_val_syscfg = { .base = 0xFFFFFFFF, 420 .clk_branch = SL_CLOCK_BRANCH_INVALID, 421 .bus_clock = SL_BUS_CLOCK_INVALID }; 422 423 // Weak definition of peripheral SYSRTC0. 424 __WEAK const sl_peripheral_val_t sl_peripheral_val_sysrtc0 = { .base = 0xFFFFFFFF, 425 .clk_branch = SL_CLOCK_BRANCH_INVALID, 426 .bus_clock = SL_BUS_CLOCK_INVALID }; 427 428 // Weak definition of peripheral TIMER0. 429 __WEAK const sl_peripheral_val_t sl_peripheral_val_timer0 = { .base = 0xFFFFFFFF, 430 .clk_branch = SL_CLOCK_BRANCH_INVALID, 431 .bus_clock = SL_BUS_CLOCK_INVALID }; 432 433 // Weak definition of peripheral TIMER1. 434 __WEAK const sl_peripheral_val_t sl_peripheral_val_timer1 = { .base = 0xFFFFFFFF, 435 .clk_branch = SL_CLOCK_BRANCH_INVALID, 436 .bus_clock = SL_BUS_CLOCK_INVALID }; 437 438 // Weak definition of peripheral TIMER2. 439 __WEAK const sl_peripheral_val_t sl_peripheral_val_timer2 = { .base = 0xFFFFFFFF, 440 .clk_branch = SL_CLOCK_BRANCH_INVALID, 441 .bus_clock = SL_BUS_CLOCK_INVALID }; 442 443 // Weak definition of peripheral TIMER3. 444 __WEAK const sl_peripheral_val_t sl_peripheral_val_timer3 = { .base = 0xFFFFFFFF, 445 .clk_branch = SL_CLOCK_BRANCH_INVALID, 446 .bus_clock = SL_BUS_CLOCK_INVALID }; 447 448 // Weak definition of peripheral TIMER4. 449 __WEAK const sl_peripheral_val_t sl_peripheral_val_timer4 = { .base = 0xFFFFFFFF, 450 .clk_branch = SL_CLOCK_BRANCH_INVALID, 451 .bus_clock = SL_BUS_CLOCK_INVALID }; 452 453 // Weak definition of peripheral TIMER5. 454 __WEAK const sl_peripheral_val_t sl_peripheral_val_timer5 = { .base = 0xFFFFFFFF, 455 .clk_branch = SL_CLOCK_BRANCH_INVALID, 456 .bus_clock = SL_BUS_CLOCK_INVALID }; 457 458 // Weak definition of peripheral TIMER6. 459 __WEAK const sl_peripheral_val_t sl_peripheral_val_timer6 = { .base = 0xFFFFFFFF, 460 .clk_branch = SL_CLOCK_BRANCH_INVALID, 461 .bus_clock = SL_BUS_CLOCK_INVALID }; 462 463 // Weak definition of peripheral TIMER7. 464 __WEAK const sl_peripheral_val_t sl_peripheral_val_timer7 = { .base = 0xFFFFFFFF, 465 .clk_branch = SL_CLOCK_BRANCH_INVALID, 466 .bus_clock = SL_BUS_CLOCK_INVALID }; 467 468 // Weak definition of peripheral TIMER8. 469 __WEAK const sl_peripheral_val_t sl_peripheral_val_timer8 = { .base = 0xFFFFFFFF, 470 .clk_branch = SL_CLOCK_BRANCH_INVALID, 471 .bus_clock = SL_BUS_CLOCK_INVALID }; 472 473 // Weak definition of peripheral TIMER9. 474 __WEAK const sl_peripheral_val_t sl_peripheral_val_timer9 = { .base = 0xFFFFFFFF, 475 .clk_branch = SL_CLOCK_BRANCH_INVALID, 476 .bus_clock = SL_BUS_CLOCK_INVALID }; 477 478 // Weak definition of peripheral ULFRCO. 479 __WEAK const sl_peripheral_val_t sl_peripheral_val_ulfrco = { .base = 0xFFFFFFFF, 480 .clk_branch = SL_CLOCK_BRANCH_INVALID, 481 .bus_clock = SL_BUS_CLOCK_INVALID }; 482 483 // Weak definition of peripheral USART0. 484 __WEAK const sl_peripheral_val_t sl_peripheral_val_usart0 = { .base = 0xFFFFFFFF, 485 .clk_branch = SL_CLOCK_BRANCH_INVALID, 486 .bus_clock = SL_BUS_CLOCK_INVALID }; 487 488 // Weak definition of peripheral USART1. 489 __WEAK const sl_peripheral_val_t sl_peripheral_val_usart1 = { .base = 0xFFFFFFFF, 490 .clk_branch = SL_CLOCK_BRANCH_INVALID, 491 .bus_clock = SL_BUS_CLOCK_INVALID }; 492 493 // Weak definition of peripheral USART2. 494 __WEAK const sl_peripheral_val_t sl_peripheral_val_usart2 = { .base = 0xFFFFFFFF, 495 .clk_branch = SL_CLOCK_BRANCH_INVALID, 496 .bus_clock = SL_BUS_CLOCK_INVALID }; 497 498 // Weak definition of peripheral USB. 499 __WEAK const sl_peripheral_val_t sl_peripheral_val_usb = { .base = 0xFFFFFFFF, 500 .clk_branch = SL_CLOCK_BRANCH_INVALID, 501 .bus_clock = SL_BUS_CLOCK_INVALID }; 502 503 // Weak definition of peripheral USBAHB. 504 __WEAK const sl_peripheral_val_t sl_peripheral_val_usbahb = { .base = 0xFFFFFFFF, 505 .clk_branch = SL_CLOCK_BRANCH_INVALID, 506 .bus_clock = SL_BUS_CLOCK_INVALID }; 507 508 // Weak definition of peripheral USBPLL0. 509 __WEAK const sl_peripheral_val_t sl_peripheral_val_usbpll0 = { .base = 0xFFFFFFFF, 510 .clk_branch = SL_CLOCK_BRANCH_INVALID, 511 .bus_clock = SL_BUS_CLOCK_INVALID }; 512 513 // Weak definition of peripheral VDAC0. 514 __WEAK const sl_peripheral_val_t sl_peripheral_val_vdac0 = { .base = 0xFFFFFFFF, 515 .clk_branch = SL_CLOCK_BRANCH_INVALID, 516 .bus_clock = SL_BUS_CLOCK_INVALID }; 517 518 // Weak definition of peripheral VDAC1. 519 __WEAK const sl_peripheral_val_t sl_peripheral_val_vdac1 = { .base = 0xFFFFFFFF, 520 .clk_branch = SL_CLOCK_BRANCH_INVALID, 521 .bus_clock = SL_BUS_CLOCK_INVALID }; 522 523 // Weak definition of peripheral WDOG0. 524 __WEAK const sl_peripheral_val_t sl_peripheral_val_wdog0 = { .base = 0xFFFFFFFF, 525 .clk_branch = SL_CLOCK_BRANCH_INVALID, 526 .bus_clock = SL_BUS_CLOCK_INVALID }; 527 528 // Weak definition of peripheral WDOG1. 529 __WEAK const sl_peripheral_val_t sl_peripheral_val_wdog1 = { .base = 0xFFFFFFFF, 530 .clk_branch = SL_CLOCK_BRANCH_INVALID, 531 .bus_clock = SL_BUS_CLOCK_INVALID }; 532 533 #if defined(__ICCARM__) 534 // Disable IAR multiple typedefs declaration warning. 535 #pragma diag_suppress=Pe301 536 #endif 537 538 // External base address getter declaration for ACMP. 539 extern ACMP_TypeDef *sl_device_peripheral_acmp_get_base_addr(const sl_peripheral_t peripheral); 540 541 // External base address getter declaration for ADC. 542 extern ADC_TypeDef *sl_device_peripheral_adc_get_base_addr(const sl_peripheral_t peripheral); 543 544 // External base address getter declaration for AES. 545 extern AES_TypeDef *sl_device_peripheral_aes_get_base_addr(const sl_peripheral_t peripheral); 546 547 // External base address getter declaration for AMUXCP. 548 extern AMUXCP_TypeDef *sl_device_peripheral_amuxcp_get_base_addr(const sl_peripheral_t peripheral); 549 550 // External base address getter declaration for BUFC. 551 extern BUFC_TypeDef *sl_device_peripheral_bufc_get_base_addr(const sl_peripheral_t peripheral); 552 553 // External base address getter declaration for BURAM. 554 extern BURAM_TypeDef *sl_device_peripheral_buram_get_base_addr(const sl_peripheral_t peripheral); 555 556 // External base address getter declaration for BURTC. 557 extern BURTC_TypeDef *sl_device_peripheral_burtc_get_base_addr(const sl_peripheral_t peripheral); 558 559 // External base address getter declaration for CMU. 560 extern CMU_TypeDef *sl_device_peripheral_cmu_get_base_addr(const sl_peripheral_t peripheral); 561 562 // External base address getter declaration for CRYPTOACC. 563 extern CRYPTOACC_TypeDef *sl_device_peripheral_cryptoacc_get_base_addr(const sl_peripheral_t peripheral); 564 565 // External base address getter declaration for CRYPTOACC_PKCTRL. 566 extern CRYPTOACC_PKCTRL_TypeDef *sl_device_peripheral_cryptoacc_pkctrl_get_base_addr(const sl_peripheral_t peripheral); 567 568 // External base address getter declaration for CRYPTOACC_RNGCTRL. 569 extern CRYPTOACC_RNGCTRL_TypeDef *sl_device_peripheral_cryptoacc_rngctrl_get_base_addr(const sl_peripheral_t peripheral); 570 571 // External base address getter declaration for DCDC. 572 extern DCDC_TypeDef *sl_device_peripheral_dcdc_get_base_addr(const sl_peripheral_t peripheral); 573 574 // External base address getter declaration for DEVINFO. 575 extern DEVINFO_TypeDef *sl_device_peripheral_devinfo_get_base_addr(const sl_peripheral_t peripheral); 576 577 // External base address getter declaration for DPLL. 578 extern DPLL_TypeDef *sl_device_peripheral_dpll_get_base_addr(const sl_peripheral_t peripheral); 579 580 // External base address getter declaration for EMU. 581 extern EMU_TypeDef *sl_device_peripheral_emu_get_base_addr(const sl_peripheral_t peripheral); 582 583 // External base address getter declaration for EMU_CFGNS. 584 extern EMU_CFGNS_TypeDef *sl_device_peripheral_emu_cfgns_get_base_addr(const sl_peripheral_t peripheral); 585 586 // External base address getter declaration for ETAMPDET. 587 extern ETAMPDET_TypeDef *sl_device_peripheral_etampdet_get_base_addr(const sl_peripheral_t peripheral); 588 589 // External base address getter declaration for EUSART. 590 extern EUSART_TypeDef *sl_device_peripheral_eusart_get_base_addr(const sl_peripheral_t peripheral); 591 592 // External base address getter declaration for FSRCO. 593 extern FSRCO_TypeDef *sl_device_peripheral_fsrco_get_base_addr(const sl_peripheral_t peripheral); 594 595 // External base address getter declaration for GPCRC. 596 extern GPCRC_TypeDef *sl_device_peripheral_gpcrc_get_base_addr(const sl_peripheral_t peripheral); 597 598 // External base address getter declaration for GPIO. 599 extern GPIO_TypeDef *sl_device_peripheral_gpio_get_base_addr(const sl_peripheral_t peripheral); 600 601 // External base address getter declaration for HFRCO. 602 extern HFRCO_TypeDef *sl_device_peripheral_hfrco_get_base_addr(const sl_peripheral_t peripheral); 603 604 // External base address getter declaration for HFXO. 605 extern HFXO_TypeDef *sl_device_peripheral_hfxo_get_base_addr(const sl_peripheral_t peripheral); 606 607 // External base address getter declaration for HOSTPORTAL. 608 extern HOSTPORTAL_TypeDef *sl_device_peripheral_hostportal_get_base_addr(const sl_peripheral_t peripheral); 609 610 // External base address getter declaration for HYDRARAM. 611 extern HYDRARAM_TypeDef *sl_device_peripheral_hydraram_get_base_addr(const sl_peripheral_t peripheral); 612 613 // External base address getter declaration for I2C. 614 extern I2C_TypeDef *sl_device_peripheral_i2c_get_base_addr(const sl_peripheral_t peripheral); 615 616 // External base address getter declaration for IADC. 617 extern IADC_TypeDef *sl_device_peripheral_iadc_get_base_addr(const sl_peripheral_t peripheral); 618 619 // External base address getter declaration for ICACHE. 620 extern ICACHE_TypeDef *sl_device_peripheral_icache_get_base_addr(const sl_peripheral_t peripheral); 621 622 // External base address getter declaration for KEYSCAN. 623 extern KEYSCAN_TypeDef *sl_device_peripheral_keyscan_get_base_addr(const sl_peripheral_t peripheral); 624 625 // External base address getter declaration for L2CACHE. 626 extern L2CACHE_TypeDef *sl_device_peripheral_l2cache_get_base_addr(const sl_peripheral_t peripheral); 627 628 // External base address getter declaration for LCD. 629 extern LCD_TypeDef *sl_device_peripheral_lcd_get_base_addr(const sl_peripheral_t peripheral); 630 631 // External base address getter declaration for LCDRF. 632 extern LCDRF_TypeDef *sl_device_peripheral_lcdrf_get_base_addr(const sl_peripheral_t peripheral); 633 634 // External base address getter declaration for LDMA. 635 extern LDMA_TypeDef *sl_device_peripheral_ldma_get_base_addr(const sl_peripheral_t peripheral); 636 637 // External base address getter declaration for LDMAXBAR. 638 extern LDMAXBAR_TypeDef *sl_device_peripheral_ldmaxbar_get_base_addr(const sl_peripheral_t peripheral); 639 640 // External base address getter declaration for LEDDRV. 641 extern LEDDRV_TypeDef *sl_device_peripheral_leddrv_get_base_addr(const sl_peripheral_t peripheral); 642 643 // External base address getter declaration for LESENSE. 644 extern LESENSE_TypeDef *sl_device_peripheral_lesense_get_base_addr(const sl_peripheral_t peripheral); 645 646 // External base address getter declaration for LETIMER. 647 extern LETIMER_TypeDef *sl_device_peripheral_letimer_get_base_addr(const sl_peripheral_t peripheral); 648 649 // External base address getter declaration for LFRCO. 650 extern LFRCO_TypeDef *sl_device_peripheral_lfrco_get_base_addr(const sl_peripheral_t peripheral); 651 652 // External base address getter declaration for LFXO. 653 extern LFXO_TypeDef *sl_device_peripheral_lfxo_get_base_addr(const sl_peripheral_t peripheral); 654 655 // External base address getter declaration for LPWAES. 656 extern LPWAES_TypeDef *sl_device_peripheral_lpwaes_get_base_addr(const sl_peripheral_t peripheral); 657 658 // External base address getter declaration for LPW0PORTAL. 659 extern LPW0PORTAL_TypeDef *sl_device_peripheral_lpw0portal_get_base_addr(const sl_peripheral_t peripheral); 660 661 // External base address getter declaration for LVGD. 662 extern LVGD_TypeDef *sl_device_peripheral_lvgd_get_base_addr(const sl_peripheral_t peripheral); 663 664 // External base address getter declaration for MAILBOX. 665 extern MAILBOX_TypeDef *sl_device_peripheral_mailbox_get_base_addr(const sl_peripheral_t peripheral); 666 667 // External base address getter declaration for MPAHBRAM. 668 extern MPAHBRAM_TypeDef *sl_device_peripheral_mpahbram_get_base_addr(const sl_peripheral_t peripheral); 669 670 // External base address getter declaration for MSC. 671 extern MSC_TypeDef *sl_device_peripheral_msc_get_base_addr(const sl_peripheral_t peripheral); 672 673 // External base address getter declaration for MVP. 674 extern MVP_TypeDef *sl_device_peripheral_mvp_get_base_addr(const sl_peripheral_t peripheral); 675 676 // External base address getter declaration for PCNT. 677 extern PCNT_TypeDef *sl_device_peripheral_pcnt_get_base_addr(const sl_peripheral_t peripheral); 678 679 // External base address getter declaration for PDM. 680 extern PDM_TypeDef *sl_device_peripheral_pdm_get_base_addr(const sl_peripheral_t peripheral); 681 682 // External base address getter declaration for PFMXPPRF. 683 extern PFMXPPRF_TypeDef *sl_device_peripheral_pfmxpprf_get_base_addr(const sl_peripheral_t peripheral); 684 685 // External base address getter declaration for PIXELRZ. 686 extern PIXELRZ_TypeDef *sl_device_peripheral_pixelrz_get_base_addr(const sl_peripheral_t peripheral); 687 688 // External base address getter declaration for PRS. 689 extern PRS_TypeDef *sl_device_peripheral_prs_get_base_addr(const sl_peripheral_t peripheral); 690 691 // External base address getter declaration for RFFPLL. 692 extern RFFPLL_TypeDef *sl_device_peripheral_rffpll_get_base_addr(const sl_peripheral_t peripheral); 693 694 // External base address getter declaration for RPA. 695 extern RPA_TypeDef *sl_device_peripheral_rpa_get_base_addr(const sl_peripheral_t peripheral); 696 697 // External base address getter declaration for RTCC. 698 extern RTCC_TypeDef *sl_device_peripheral_rtcc_get_base_addr(const sl_peripheral_t peripheral); 699 700 // External base address getter declaration for SCRATCHPAD. 701 extern SCRATCHPAD_TypeDef *sl_device_peripheral_scratchpad_get_base_addr(const sl_peripheral_t peripheral); 702 703 // External base address getter declaration for SEMAILBOX_AHBHOST. 704 extern SEMAILBOX_AHBHOST_TypeDef *sl_device_peripheral_semailbox_ahbhost_get_base_addr(const sl_peripheral_t peripheral); 705 706 // External base address getter declaration for SEMAILBOX_HOST. 707 extern SEMAILBOX_HOST_TypeDef *sl_device_peripheral_semailbox_host_get_base_addr(const sl_peripheral_t peripheral); 708 709 // External base address getter declaration for SEMAPHORE. 710 extern SEMAPHORE_TypeDef *sl_device_peripheral_semaphore_get_base_addr(const sl_peripheral_t peripheral); 711 712 // External base address getter declaration for SEPORTAL. 713 extern SEPORTAL_TypeDef *sl_device_peripheral_seportal_get_base_addr(const sl_peripheral_t peripheral); 714 715 // External base address getter declaration for SEPUF_APBCFG. 716 extern SEPUF_APBCFG_TypeDef *sl_device_peripheral_sepuf_apbcfg_get_base_addr(const sl_peripheral_t peripheral); 717 718 // External base address getter declaration for SMU. 719 extern SMU_TypeDef *sl_device_peripheral_smu_get_base_addr(const sl_peripheral_t peripheral); 720 721 // External base address getter declaration for SOCPLL. 722 extern SOCPLL_TypeDef *sl_device_peripheral_socpll_get_base_addr(const sl_peripheral_t peripheral); 723 724 // External base address getter declaration for SYMCRYPTO. 725 extern SYMCRYPTO_TypeDef *sl_device_peripheral_symcrypto_get_base_addr(const sl_peripheral_t peripheral); 726 727 // External base address getter declaration for SYSCFG. 728 extern SYSCFG_TypeDef *sl_device_peripheral_syscfg_get_base_addr(const sl_peripheral_t peripheral); 729 730 // External base address getter declaration for SYSCFG_CFGNS. 731 extern SYSCFG_CFGNS_TypeDef *sl_device_peripheral_syscfg_cfgns_get_base_addr(const sl_peripheral_t peripheral); 732 733 // External base address getter declaration for SYSRTC. 734 extern SYSRTC_TypeDef *sl_device_peripheral_sysrtc_get_base_addr(const sl_peripheral_t peripheral); 735 736 // External base address getter declaration for TIMER. 737 extern TIMER_TypeDef *sl_device_peripheral_timer_get_base_addr(const sl_peripheral_t peripheral); 738 739 // External base address getter declaration for ULFRCO. 740 extern ULFRCO_TypeDef *sl_device_peripheral_ulfrco_get_base_addr(const sl_peripheral_t peripheral); 741 742 // External base address getter declaration for USART. 743 extern USART_TypeDef *sl_device_peripheral_usart_get_base_addr(const sl_peripheral_t peripheral); 744 745 // External base address getter declaration for USBAHB_AHBS. 746 extern USBAHB_AHBS_TypeDef *sl_device_peripheral_usbahb_ahbs_get_base_addr(const sl_peripheral_t peripheral); 747 748 // External base address getter declaration for USBPLL. 749 extern USBPLL_TypeDef *sl_device_peripheral_usbpll_get_base_addr(const sl_peripheral_t peripheral); 750 751 // External base address getter declaration for USB_APBS. 752 extern USB_APBS_TypeDef *sl_device_peripheral_usb_apbs_get_base_addr(const sl_peripheral_t peripheral); 753 754 // External base address getter declaration for VDAC. 755 extern VDAC_TypeDef *sl_device_peripheral_vdac_get_base_addr(const sl_peripheral_t peripheral); 756 757 // External base address getter declaration for WDOG. 758 extern WDOG_TypeDef *sl_device_peripheral_wdog_get_base_addr(const sl_peripheral_t peripheral); 759 760 // External clock branch getter declaration. 761 extern sl_clock_branch_t sl_device_peripheral_get_clock_branch(const sl_peripheral_t peripheral); 762 763 // External bus clock getter declaration. 764 extern sl_bus_clock_t sl_device_peripheral_get_bus_clock(const sl_peripheral_t peripheral); 765 766 #if defined(__ICCARM__) 767 // Disable IAR multiple typedefs declaration warning. 768 #pragma diag_default=Pe301 769 #endif 770
