1 #ifndef NRF54H_ERRATAS_H
2 #define NRF54H_ERRATAS_H
3
4 /*
5
6 Copyright (c) 2010 - 2025, Nordic Semiconductor ASA All rights reserved.
7
8 SPDX-License-Identifier: BSD-3-Clause
9
10 Redistribution and use in source and binary forms, with or without
11 modification, are permitted provided that the following conditions are met:
12
13 1. Redistributions of source code must retain the above copyright notice, this
14 list of conditions and the following disclaimer.
15
16 2. Redistributions in binary form must reproduce the above copyright
17 notice, this list of conditions and the following disclaimer in the
18 documentation and/or other materials provided with the distribution.
19
20 3. Neither the name of Nordic Semiconductor ASA nor the names of its
21 contributors may be used to endorse or promote products derived from this
22 software without specific prior written permission.
23
24 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
25 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 IMPLIED WARRANTIES OF MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE
27 ARE DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
28 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
31 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
32 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
33 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34 POSSIBILITY OF SUCH DAMAGE.
35
36 */
37
38 #include <stdint.h>
39 #include <stdbool.h>
40 #include "compiler_abstraction.h"
41
42 static bool nrf54h_errata_6(void) __UNUSED;
43 static bool nrf54h_errata_8(void) __UNUSED;
44 static bool nrf54h_errata_12(void) __UNUSED;
45 static bool nrf54h_errata_13(void) __UNUSED;
46 static bool nrf54h_errata_14(void) __UNUSED;
47 static bool nrf54h_errata_19(void) __UNUSED;
48 static bool nrf54h_errata_20(void) __UNUSED;
49 static bool nrf54h_errata_21(void) __UNUSED;
50 static bool nrf54h_errata_23(void) __UNUSED;
51 static bool nrf54h_errata_25(void) __UNUSED;
52 static bool nrf54h_errata_26(void) __UNUSED;
53 static bool nrf54h_errata_27(void) __UNUSED;
54 static bool nrf54h_errata_31(void) __UNUSED;
55 static bool nrf54h_errata_32(void) __UNUSED;
56 static bool nrf54h_errata_34(void) __UNUSED;
57 static bool nrf54h_errata_35(void) __UNUSED;
58 static bool nrf54h_errata_36(void) __UNUSED;
59 static bool nrf54h_errata_37(void) __UNUSED;
60 static bool nrf54h_errata_39(void) __UNUSED;
61 static bool nrf54h_errata_40(void) __UNUSED;
62 static bool nrf54h_errata_41(void) __UNUSED;
63 static bool nrf54h_errata_42(void) __UNUSED;
64 static bool nrf54h_errata_43(void) __UNUSED;
65 static bool nrf54h_errata_44(void) __UNUSED;
66 static bool nrf54h_errata_45(void) __UNUSED;
67 static bool nrf54h_errata_46(void) __UNUSED;
68 static bool nrf54h_errata_47(void) __UNUSED;
69 static bool nrf54h_errata_50(void) __UNUSED;
70 static bool nrf54h_errata_51(void) __UNUSED;
71 static bool nrf54h_errata_53(void) __UNUSED;
72 static bool nrf54h_errata_55(void) __UNUSED;
73 static bool nrf54h_errata_56(void) __UNUSED;
74 static bool nrf54h_errata_57(void) __UNUSED;
75 static bool nrf54h_errata_58(void) __UNUSED;
76 static bool nrf54h_errata_62(void) __UNUSED;
77 static bool nrf54h_errata_63(void) __UNUSED;
78 static bool nrf54h_errata_64(void) __UNUSED;
79 static bool nrf54h_errata_65(void) __UNUSED;
80 static bool nrf54h_errata_66(void) __UNUSED;
81 static bool nrf54h_errata_67(void) __UNUSED;
82 static bool nrf54h_errata_69(void) __UNUSED;
83 static bool nrf54h_errata_70(void) __UNUSED;
84 static bool nrf54h_errata_71(void) __UNUSED;
85 static bool nrf54h_errata_72(void) __UNUSED;
86 static bool nrf54h_errata_73(void) __UNUSED;
87 static bool nrf54h_errata_74(void) __UNUSED;
88 static bool nrf54h_errata_75(void) __UNUSED;
89 static bool nrf54h_errata_76(void) __UNUSED;
90 static bool nrf54h_errata_77(void) __UNUSED;
91 static bool nrf54h_errata_78(void) __UNUSED;
92 static bool nrf54h_errata_84(void) __UNUSED;
93 static bool nrf54h_errata_92(void) __UNUSED;
94 static bool nrf54h_errata_93(void) __UNUSED;
95 static bool nrf54h_errata_98(void) __UNUSED;
96 static bool nrf54h_errata_102(void) __UNUSED;
97 static bool nrf54h_errata_103(void) __UNUSED;
98 static bool nrf54h_errata_104(void) __UNUSED;
99 static bool nrf54h_errata_105(void) __UNUSED;
100 static bool nrf54h_errata_106(void) __UNUSED;
101 static bool nrf54h_errata_107(void) __UNUSED;
102 static bool nrf54h_errata_109(void) __UNUSED;
103 static bool nrf54h_errata_110(void) __UNUSED;
104 static bool nrf54h_errata_111(void) __UNUSED;
105 static bool nrf54h_errata_112(void) __UNUSED;
106 static bool nrf54h_errata_115(void) __UNUSED;
107 static bool nrf54h_errata_116(void) __UNUSED;
108 static bool nrf54h_errata_117(void) __UNUSED;
109 static bool nrf54h_errata_118(void) __UNUSED;
110 static bool nrf54h_errata_119(void) __UNUSED;
111 static bool nrf54h_errata_120(void) __UNUSED;
112 static bool nrf54h_errata_121(void) __UNUSED;
113 static bool nrf54h_errata_122(void) __UNUSED;
114 static bool nrf54h_errata_123(void) __UNUSED;
115 static bool nrf54h_errata_124(void) __UNUSED;
116 static bool nrf54h_errata_125(void) __UNUSED;
117 static bool nrf54h_errata_126(void) __UNUSED;
118 static bool nrf54h_errata_127(void) __UNUSED;
119 static bool nrf54h_errata_128(void) __UNUSED;
120 static bool nrf54h_errata_129(void) __UNUSED;
121 static bool nrf54h_errata_130(void) __UNUSED;
122 static bool nrf54h_errata_131(void) __UNUSED;
123 static bool nrf54h_errata_132(void) __UNUSED;
124 static bool nrf54h_errata_133(void) __UNUSED;
125 static bool nrf54h_errata_134(void) __UNUSED;
126 static bool nrf54h_errata_135(void) __UNUSED;
127 static bool nrf54h_errata_136(void) __UNUSED;
128 static bool nrf54h_errata_137(void) __UNUSED;
129 static bool nrf54h_errata_138(void) __UNUSED;
130 static bool nrf54h_errata_139(void) __UNUSED;
131 static bool nrf54h_errata_140(void) __UNUSED;
132 static bool nrf54h_errata_141(void) __UNUSED;
133 static bool nrf54h_errata_142(void) __UNUSED;
134 static bool nrf54h_errata_143(void) __UNUSED;
135 static bool nrf54h_errata_145(void) __UNUSED;
136 static bool nrf54h_errata_146(void) __UNUSED;
137 static bool nrf54h_errata_148(void) __UNUSED;
138 static bool nrf54h_errata_149(void) __UNUSED;
139 static bool nrf54h_errata_151(void) __UNUSED;
140 static bool nrf54h_errata_152(void) __UNUSED;
141 static bool nrf54h_errata_153(void) __UNUSED;
142 static bool nrf54h_errata_155(void) __UNUSED;
143 static bool nrf54h_errata_156(void) __UNUSED;
144 static bool nrf54h_errata_157(void) __UNUSED;
145 static bool nrf54h_errata_158(void) __UNUSED;
146 static bool nrf54h_errata_159(void) __UNUSED;
147 static bool nrf54h_errata_160(void) __UNUSED;
148 static bool nrf54h_errata_161(void) __UNUSED;
149 static bool nrf54h_errata_162(void) __UNUSED;
150 static bool nrf54h_errata_163(void) __UNUSED;
151 static bool nrf54h_errata_164(void) __UNUSED;
152 static bool nrf54h_errata_165(void) __UNUSED;
153 static bool nrf54h_errata_166(void) __UNUSED;
154 static bool nrf54h_errata_169(void) __UNUSED;
155 static bool nrf54h_errata_171(void) __UNUSED;
156 static bool nrf54h_errata_172(void) __UNUSED;
157 static bool nrf54h_errata_173(void) __UNUSED;
158 static bool nrf54h_errata_175(void) __UNUSED;
159 static bool nrf54h_errata_177(void) __UNUSED;
160 static bool nrf54h_errata_178(void) __UNUSED;
161 static bool nrf54h_errata_179(void) __UNUSED;
162 static bool nrf54h_errata_182(void) __UNUSED;
163 static bool nrf54h_errata_183(void) __UNUSED;
164 static bool nrf54h_errata_184(void) __UNUSED;
165 static bool nrf54h_errata_185(void) __UNUSED;
166 static bool nrf54h_errata_186(void) __UNUSED;
167 static bool nrf54h_errata_187(void) __UNUSED;
168 static bool nrf54h_errata_188(void) __UNUSED;
169 static bool nrf54h_errata_189(void) __UNUSED;
170 static bool nrf54h_errata_190(void) __UNUSED;
171 static bool nrf54h_errata_191(void) __UNUSED;
172 static bool nrf54h_errata_192(void) __UNUSED;
173 static bool nrf54h_errata_193(void) __UNUSED;
174 static bool nrf54h_errata_194(void) __UNUSED;
175 static bool nrf54h_errata_195(void) __UNUSED;
176 static bool nrf54h_errata_196(void) __UNUSED;
177 static bool nrf54h_errata_198(void) __UNUSED;
178 static bool nrf54h_errata_200(void) __UNUSED;
179 static bool nrf54h_errata_201(void) __UNUSED;
180 static bool nrf54h_errata_202(void) __UNUSED;
181 static bool nrf54h_errata_205(void) __UNUSED;
182 static bool nrf54h_errata_206(void) __UNUSED;
183 static bool nrf54h_errata_207(void) __UNUSED;
184 static bool nrf54h_errata_208(void) __UNUSED;
185 static bool nrf54h_errata_209(void) __UNUSED;
186 static bool nrf54h_errata_210(void) __UNUSED;
187 static bool nrf54h_errata_211(void) __UNUSED;
188 static bool nrf54h_errata_212(void) __UNUSED;
189
190 /* ========= Errata 6 ========= */
191 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
192 #define NRF54H_ERRATA_6_PRESENT 1
193 #else
194 #define NRF54H_ERRATA_6_PRESENT 0
195 #endif
196
197 #ifndef NRF54H_ERRATA_6_ENABLE_WORKAROUND
198 #define NRF54H_ERRATA_6_ENABLE_WORKAROUND NRF54H_ERRATA_6_PRESENT
199 #endif
200
nrf54h_errata_6(void)201 static bool nrf54h_errata_6(void)
202 {
203 #ifndef NRF54H_SERIES
204 return false;
205 #else
206 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
207 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
208 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
209 #endif
210 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
211 if (var1 == 0x16)
212 {
213 switch(var2)
214 {
215 case 0x02ul:
216 return true;
217 default:
218 return true;
219 }
220 }
221 #endif
222 return false;
223 #endif
224 }
225
226 /* ========= Errata 8 ========= */
227 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
228 #define NRF54H_ERRATA_8_PRESENT 1
229 #else
230 #define NRF54H_ERRATA_8_PRESENT 0
231 #endif
232
233 #ifndef NRF54H_ERRATA_8_ENABLE_WORKAROUND
234 #define NRF54H_ERRATA_8_ENABLE_WORKAROUND NRF54H_ERRATA_8_PRESENT
235 #endif
236
nrf54h_errata_8(void)237 static bool nrf54h_errata_8(void)
238 {
239 #ifndef NRF54H_SERIES
240 return false;
241 #else
242 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
243 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
244 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
245 #endif
246 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
247 if (var1 == 0x16)
248 {
249 switch(var2)
250 {
251 case 0x02ul:
252 return true;
253 default:
254 return true;
255 }
256 }
257 #endif
258 return false;
259 #endif
260 }
261
262 /* ========= Errata 12 ========= */
263 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
264 #define NRF54H_ERRATA_12_PRESENT 1
265 #else
266 #define NRF54H_ERRATA_12_PRESENT 0
267 #endif
268
269 #ifndef NRF54H_ERRATA_12_ENABLE_WORKAROUND
270 #define NRF54H_ERRATA_12_ENABLE_WORKAROUND NRF54H_ERRATA_12_PRESENT
271 #endif
272
nrf54h_errata_12(void)273 static bool nrf54h_errata_12(void)
274 {
275 #ifndef NRF54H_SERIES
276 return false;
277 #else
278 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
279 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
280 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
281 #endif
282 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
283 if (var1 == 0x16)
284 {
285 switch(var2)
286 {
287 case 0x02ul:
288 return true;
289 default:
290 return true;
291 }
292 }
293 #endif
294 return false;
295 #endif
296 }
297
298 /* ========= Errata 13 ========= */
299 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
300 #define NRF54H_ERRATA_13_PRESENT 1
301 #else
302 #define NRF54H_ERRATA_13_PRESENT 0
303 #endif
304
305 #ifndef NRF54H_ERRATA_13_ENABLE_WORKAROUND
306 #define NRF54H_ERRATA_13_ENABLE_WORKAROUND NRF54H_ERRATA_13_PRESENT
307 #endif
308
nrf54h_errata_13(void)309 static bool nrf54h_errata_13(void)
310 {
311 #ifndef NRF54H_SERIES
312 return false;
313 #else
314 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
315 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
316 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
317 #endif
318 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
319 if (var1 == 0x16)
320 {
321 switch(var2)
322 {
323 case 0x02ul:
324 return true;
325 default:
326 return true;
327 }
328 }
329 #endif
330 return false;
331 #endif
332 }
333
334 /* ========= Errata 14 ========= */
335 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
336 #define NRF54H_ERRATA_14_PRESENT 1
337 #else
338 #define NRF54H_ERRATA_14_PRESENT 0
339 #endif
340
341 #ifndef NRF54H_ERRATA_14_ENABLE_WORKAROUND
342 #define NRF54H_ERRATA_14_ENABLE_WORKAROUND NRF54H_ERRATA_14_PRESENT
343 #endif
344
nrf54h_errata_14(void)345 static bool nrf54h_errata_14(void)
346 {
347 #ifndef NRF54H_SERIES
348 return false;
349 #else
350 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
351 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
352 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
353 #endif
354 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
355 if (var1 == 0x16)
356 {
357 switch(var2)
358 {
359 case 0x02ul:
360 return true;
361 default:
362 return true;
363 }
364 }
365 #endif
366 return false;
367 #endif
368 }
369
370 /* ========= Errata 19 ========= */
371 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
372 #define NRF54H_ERRATA_19_PRESENT 1
373 #else
374 #define NRF54H_ERRATA_19_PRESENT 0
375 #endif
376
377 #ifndef NRF54H_ERRATA_19_ENABLE_WORKAROUND
378 #define NRF54H_ERRATA_19_ENABLE_WORKAROUND NRF54H_ERRATA_19_PRESENT
379 #endif
380
nrf54h_errata_19(void)381 static bool nrf54h_errata_19(void)
382 {
383 #ifndef NRF54H_SERIES
384 return false;
385 #else
386 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
387 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
388 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
389 #endif
390 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
391 if (var1 == 0x16)
392 {
393 switch(var2)
394 {
395 case 0x02ul:
396 return true;
397 default:
398 return true;
399 }
400 }
401 #endif
402 return false;
403 #endif
404 }
405
406 /* ========= Errata 20 ========= */
407 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
408 #define NRF54H_ERRATA_20_PRESENT 1
409 #else
410 #define NRF54H_ERRATA_20_PRESENT 0
411 #endif
412
413 #ifndef NRF54H_ERRATA_20_ENABLE_WORKAROUND
414 #define NRF54H_ERRATA_20_ENABLE_WORKAROUND NRF54H_ERRATA_20_PRESENT
415 #endif
416
nrf54h_errata_20(void)417 static bool nrf54h_errata_20(void)
418 {
419 #ifndef NRF54H_SERIES
420 return false;
421 #else
422 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
423 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
424 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
425 #endif
426 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
427 if (var1 == 0x16)
428 {
429 switch(var2)
430 {
431 case 0x02ul:
432 return true;
433 default:
434 return true;
435 }
436 }
437 #endif
438 return false;
439 #endif
440 }
441
442 /* ========= Errata 21 ========= */
443 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
444 #define NRF54H_ERRATA_21_PRESENT 1
445 #else
446 #define NRF54H_ERRATA_21_PRESENT 0
447 #endif
448
449 #ifndef NRF54H_ERRATA_21_ENABLE_WORKAROUND
450 #define NRF54H_ERRATA_21_ENABLE_WORKAROUND NRF54H_ERRATA_21_PRESENT
451 #endif
452
nrf54h_errata_21(void)453 static bool nrf54h_errata_21(void)
454 {
455 #ifndef NRF54H_SERIES
456 return false;
457 #else
458 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
459 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
460 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
461 #endif
462 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
463 if (var1 == 0x16)
464 {
465 switch(var2)
466 {
467 case 0x02ul:
468 return true;
469 default:
470 return true;
471 }
472 }
473 #endif
474 return false;
475 #endif
476 }
477
478 /* ========= Errata 23 ========= */
479 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
480 #define NRF54H_ERRATA_23_PRESENT 1
481 #else
482 #define NRF54H_ERRATA_23_PRESENT 0
483 #endif
484
485 #ifndef NRF54H_ERRATA_23_ENABLE_WORKAROUND
486 #define NRF54H_ERRATA_23_ENABLE_WORKAROUND NRF54H_ERRATA_23_PRESENT
487 #endif
488
nrf54h_errata_23(void)489 static bool nrf54h_errata_23(void)
490 {
491 #ifndef NRF54H_SERIES
492 return false;
493 #else
494 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
495 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
496 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
497 #endif
498 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
499 if (var1 == 0x16)
500 {
501 switch(var2)
502 {
503 case 0x02ul:
504 return true;
505 default:
506 return true;
507 }
508 }
509 #endif
510 return false;
511 #endif
512 }
513
514 /* ========= Errata 25 ========= */
515 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
516 #define NRF54H_ERRATA_25_PRESENT 1
517 #else
518 #define NRF54H_ERRATA_25_PRESENT 0
519 #endif
520
521 #ifndef NRF54H_ERRATA_25_ENABLE_WORKAROUND
522 #define NRF54H_ERRATA_25_ENABLE_WORKAROUND NRF54H_ERRATA_25_PRESENT
523 #endif
524
nrf54h_errata_25(void)525 static bool nrf54h_errata_25(void)
526 {
527 #ifndef NRF54H_SERIES
528 return false;
529 #else
530 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
531 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
532 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
533 #endif
534 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
535 if (var1 == 0x16)
536 {
537 switch(var2)
538 {
539 case 0x02ul:
540 return true;
541 default:
542 return true;
543 }
544 }
545 #endif
546 return false;
547 #endif
548 }
549
550 /* ========= Errata 26 ========= */
551 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
552 #define NRF54H_ERRATA_26_PRESENT 1
553 #else
554 #define NRF54H_ERRATA_26_PRESENT 0
555 #endif
556
557 #ifndef NRF54H_ERRATA_26_ENABLE_WORKAROUND
558 #define NRF54H_ERRATA_26_ENABLE_WORKAROUND NRF54H_ERRATA_26_PRESENT
559 #endif
560
nrf54h_errata_26(void)561 static bool nrf54h_errata_26(void)
562 {
563 #ifndef NRF54H_SERIES
564 return false;
565 #else
566 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
567 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
568 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
569 #endif
570 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
571 if (var1 == 0x16)
572 {
573 switch(var2)
574 {
575 case 0x02ul:
576 return true;
577 default:
578 return true;
579 }
580 }
581 #endif
582 return false;
583 #endif
584 }
585
586 /* ========= Errata 27 ========= */
587 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
588 #define NRF54H_ERRATA_27_PRESENT 1
589 #else
590 #define NRF54H_ERRATA_27_PRESENT 0
591 #endif
592
593 #ifndef NRF54H_ERRATA_27_ENABLE_WORKAROUND
594 #define NRF54H_ERRATA_27_ENABLE_WORKAROUND NRF54H_ERRATA_27_PRESENT
595 #endif
596
nrf54h_errata_27(void)597 static bool nrf54h_errata_27(void)
598 {
599 #ifndef NRF54H_SERIES
600 return false;
601 #else
602 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
603 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
604 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
605 #endif
606 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
607 if (var1 == 0x16)
608 {
609 switch(var2)
610 {
611 case 0x02ul:
612 return true;
613 default:
614 return true;
615 }
616 }
617 #endif
618 return false;
619 #endif
620 }
621
622 /* ========= Errata 31 ========= */
623 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
624 #define NRF54H_ERRATA_31_PRESENT 1
625 #else
626 #define NRF54H_ERRATA_31_PRESENT 0
627 #endif
628
629 #ifndef NRF54H_ERRATA_31_ENABLE_WORKAROUND
630 #define NRF54H_ERRATA_31_ENABLE_WORKAROUND NRF54H_ERRATA_31_PRESENT
631 #endif
632
nrf54h_errata_31(void)633 static bool nrf54h_errata_31(void)
634 {
635 #ifndef NRF54H_SERIES
636 return false;
637 #else
638 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
639 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
640 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
641 #endif
642 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
643 if (var1 == 0x16)
644 {
645 switch(var2)
646 {
647 case 0x02ul:
648 return true;
649 default:
650 return true;
651 }
652 }
653 #endif
654 return false;
655 #endif
656 }
657
658 /* ========= Errata 32 ========= */
659 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
660 #define NRF54H_ERRATA_32_PRESENT 1
661 #else
662 #define NRF54H_ERRATA_32_PRESENT 0
663 #endif
664
665 #ifndef NRF54H_ERRATA_32_ENABLE_WORKAROUND
666 #define NRF54H_ERRATA_32_ENABLE_WORKAROUND NRF54H_ERRATA_32_PRESENT
667 #endif
668
nrf54h_errata_32(void)669 static bool nrf54h_errata_32(void)
670 {
671 #ifndef NRF54H_SERIES
672 return false;
673 #else
674 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
675 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
676 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
677 #endif
678 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
679 if (var1 == 0x16)
680 {
681 switch(var2)
682 {
683 case 0x02ul:
684 return true;
685 default:
686 return true;
687 }
688 }
689 #endif
690 return false;
691 #endif
692 }
693
694 /* ========= Errata 34 ========= */
695 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
696 #define NRF54H_ERRATA_34_PRESENT 1
697 #else
698 #define NRF54H_ERRATA_34_PRESENT 0
699 #endif
700
701 #ifndef NRF54H_ERRATA_34_ENABLE_WORKAROUND
702 #define NRF54H_ERRATA_34_ENABLE_WORKAROUND NRF54H_ERRATA_34_PRESENT
703 #endif
704
nrf54h_errata_34(void)705 static bool nrf54h_errata_34(void)
706 {
707 #ifndef NRF54H_SERIES
708 return false;
709 #else
710 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
711 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
712 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
713 #endif
714 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
715 if (var1 == 0x16)
716 {
717 switch(var2)
718 {
719 case 0x02ul:
720 return true;
721 default:
722 return true;
723 }
724 }
725 #endif
726 return false;
727 #endif
728 }
729
730 /* ========= Errata 35 ========= */
731 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
732 #define NRF54H_ERRATA_35_PRESENT 1
733 #else
734 #define NRF54H_ERRATA_35_PRESENT 0
735 #endif
736
737 #ifndef NRF54H_ERRATA_35_ENABLE_WORKAROUND
738 #define NRF54H_ERRATA_35_ENABLE_WORKAROUND NRF54H_ERRATA_35_PRESENT
739 #endif
740
nrf54h_errata_35(void)741 static bool nrf54h_errata_35(void)
742 {
743 #ifndef NRF54H_SERIES
744 return false;
745 #else
746 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
747 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
748 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
749 #endif
750 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
751 if (var1 == 0x16)
752 {
753 switch(var2)
754 {
755 case 0x02ul:
756 return true;
757 default:
758 return true;
759 }
760 }
761 #endif
762 return false;
763 #endif
764 }
765
766 /* ========= Errata 36 ========= */
767 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
768 #define NRF54H_ERRATA_36_PRESENT 1
769 #else
770 #define NRF54H_ERRATA_36_PRESENT 0
771 #endif
772
773 #ifndef NRF54H_ERRATA_36_ENABLE_WORKAROUND
774 #define NRF54H_ERRATA_36_ENABLE_WORKAROUND NRF54H_ERRATA_36_PRESENT
775 #endif
776
nrf54h_errata_36(void)777 static bool nrf54h_errata_36(void)
778 {
779 #ifndef NRF54H_SERIES
780 return false;
781 #else
782 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
783 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
784 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
785 #endif
786 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
787 if (var1 == 0x16)
788 {
789 switch(var2)
790 {
791 case 0x02ul:
792 return true;
793 default:
794 return true;
795 }
796 }
797 #endif
798 return false;
799 #endif
800 }
801
802 /* ========= Errata 37 ========= */
803 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
804 #define NRF54H_ERRATA_37_PRESENT 1
805 #else
806 #define NRF54H_ERRATA_37_PRESENT 0
807 #endif
808
809 #ifndef NRF54H_ERRATA_37_ENABLE_WORKAROUND
810 #define NRF54H_ERRATA_37_ENABLE_WORKAROUND NRF54H_ERRATA_37_PRESENT
811 #endif
812
nrf54h_errata_37(void)813 static bool nrf54h_errata_37(void)
814 {
815 #ifndef NRF54H_SERIES
816 return false;
817 #else
818 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
819 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
820 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
821 #endif
822 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
823 if (var1 == 0x16)
824 {
825 switch(var2)
826 {
827 case 0x02ul:
828 return true;
829 default:
830 return true;
831 }
832 }
833 #endif
834 return false;
835 #endif
836 }
837
838 /* ========= Errata 39 ========= */
839 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
840 #define NRF54H_ERRATA_39_PRESENT 1
841 #else
842 #define NRF54H_ERRATA_39_PRESENT 0
843 #endif
844
845 #ifndef NRF54H_ERRATA_39_ENABLE_WORKAROUND
846 #define NRF54H_ERRATA_39_ENABLE_WORKAROUND NRF54H_ERRATA_39_PRESENT
847 #endif
848
nrf54h_errata_39(void)849 static bool nrf54h_errata_39(void)
850 {
851 #ifndef NRF54H_SERIES
852 return false;
853 #else
854 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
855 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
856 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
857 #endif
858 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
859 if (var1 == 0x16)
860 {
861 switch(var2)
862 {
863 case 0x02ul:
864 return true;
865 default:
866 return true;
867 }
868 }
869 #endif
870 return false;
871 #endif
872 }
873
874 /* ========= Errata 40 ========= */
875 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
876 #define NRF54H_ERRATA_40_PRESENT 1
877 #else
878 #define NRF54H_ERRATA_40_PRESENT 0
879 #endif
880
881 #ifndef NRF54H_ERRATA_40_ENABLE_WORKAROUND
882 #define NRF54H_ERRATA_40_ENABLE_WORKAROUND NRF54H_ERRATA_40_PRESENT
883 #endif
884
nrf54h_errata_40(void)885 static bool nrf54h_errata_40(void)
886 {
887 #ifndef NRF54H_SERIES
888 return false;
889 #else
890 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
891 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
892 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
893 #endif
894 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
895 if (var1 == 0x16)
896 {
897 switch(var2)
898 {
899 case 0x02ul:
900 return true;
901 default:
902 return true;
903 }
904 }
905 #endif
906 return false;
907 #endif
908 }
909
910 /* ========= Errata 41 ========= */
911 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
912 #define NRF54H_ERRATA_41_PRESENT 1
913 #else
914 #define NRF54H_ERRATA_41_PRESENT 0
915 #endif
916
917 #ifndef NRF54H_ERRATA_41_ENABLE_WORKAROUND
918 #define NRF54H_ERRATA_41_ENABLE_WORKAROUND NRF54H_ERRATA_41_PRESENT
919 #endif
920
nrf54h_errata_41(void)921 static bool nrf54h_errata_41(void)
922 {
923 #ifndef NRF54H_SERIES
924 return false;
925 #else
926 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
927 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
928 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
929 #endif
930 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
931 if (var1 == 0x16)
932 {
933 switch(var2)
934 {
935 case 0x02ul:
936 return true;
937 default:
938 return true;
939 }
940 }
941 #endif
942 return false;
943 #endif
944 }
945
946 /* ========= Errata 42 ========= */
947 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
948 #define NRF54H_ERRATA_42_PRESENT 1
949 #else
950 #define NRF54H_ERRATA_42_PRESENT 0
951 #endif
952
953 #ifndef NRF54H_ERRATA_42_ENABLE_WORKAROUND
954 #define NRF54H_ERRATA_42_ENABLE_WORKAROUND NRF54H_ERRATA_42_PRESENT
955 #endif
956
nrf54h_errata_42(void)957 static bool nrf54h_errata_42(void)
958 {
959 #ifndef NRF54H_SERIES
960 return false;
961 #else
962 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
963 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
964 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
965 #endif
966 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
967 if (var1 == 0x16)
968 {
969 switch(var2)
970 {
971 case 0x02ul:
972 return true;
973 default:
974 return true;
975 }
976 }
977 #endif
978 return false;
979 #endif
980 }
981
982 /* ========= Errata 43 ========= */
983 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
984 #define NRF54H_ERRATA_43_PRESENT 1
985 #else
986 #define NRF54H_ERRATA_43_PRESENT 0
987 #endif
988
989 #ifndef NRF54H_ERRATA_43_ENABLE_WORKAROUND
990 #define NRF54H_ERRATA_43_ENABLE_WORKAROUND NRF54H_ERRATA_43_PRESENT
991 #endif
992
nrf54h_errata_43(void)993 static bool nrf54h_errata_43(void)
994 {
995 #ifndef NRF54H_SERIES
996 return false;
997 #else
998 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
999 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
1000 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
1001 #endif
1002 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1003 if (var1 == 0x16)
1004 {
1005 switch(var2)
1006 {
1007 case 0x02ul:
1008 return true;
1009 default:
1010 return true;
1011 }
1012 }
1013 #endif
1014 return false;
1015 #endif
1016 }
1017
1018 /* ========= Errata 44 ========= */
1019 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1020 #define NRF54H_ERRATA_44_PRESENT 1
1021 #else
1022 #define NRF54H_ERRATA_44_PRESENT 0
1023 #endif
1024
1025 #ifndef NRF54H_ERRATA_44_ENABLE_WORKAROUND
1026 #define NRF54H_ERRATA_44_ENABLE_WORKAROUND NRF54H_ERRATA_44_PRESENT
1027 #endif
1028
nrf54h_errata_44(void)1029 static bool nrf54h_errata_44(void)
1030 {
1031 #ifndef NRF54H_SERIES
1032 return false;
1033 #else
1034 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1035 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
1036 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
1037 #endif
1038 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1039 if (var1 == 0x16)
1040 {
1041 switch(var2)
1042 {
1043 case 0x02ul:
1044 return true;
1045 default:
1046 return true;
1047 }
1048 }
1049 #endif
1050 return false;
1051 #endif
1052 }
1053
1054 /* ========= Errata 45 ========= */
1055 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1056 #define NRF54H_ERRATA_45_PRESENT 1
1057 #else
1058 #define NRF54H_ERRATA_45_PRESENT 0
1059 #endif
1060
1061 #ifndef NRF54H_ERRATA_45_ENABLE_WORKAROUND
1062 #define NRF54H_ERRATA_45_ENABLE_WORKAROUND NRF54H_ERRATA_45_PRESENT
1063 #endif
1064
nrf54h_errata_45(void)1065 static bool nrf54h_errata_45(void)
1066 {
1067 #ifndef NRF54H_SERIES
1068 return false;
1069 #else
1070 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1071 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
1072 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
1073 #endif
1074 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1075 if (var1 == 0x16)
1076 {
1077 switch(var2)
1078 {
1079 case 0x02ul:
1080 return true;
1081 default:
1082 return true;
1083 }
1084 }
1085 #endif
1086 return false;
1087 #endif
1088 }
1089
1090 /* ========= Errata 46 ========= */
1091 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1092 #define NRF54H_ERRATA_46_PRESENT 1
1093 #else
1094 #define NRF54H_ERRATA_46_PRESENT 0
1095 #endif
1096
1097 #ifndef NRF54H_ERRATA_46_ENABLE_WORKAROUND
1098 #define NRF54H_ERRATA_46_ENABLE_WORKAROUND NRF54H_ERRATA_46_PRESENT
1099 #endif
1100
nrf54h_errata_46(void)1101 static bool nrf54h_errata_46(void)
1102 {
1103 #ifndef NRF54H_SERIES
1104 return false;
1105 #else
1106 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1107 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
1108 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
1109 #endif
1110 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1111 if (var1 == 0x16)
1112 {
1113 switch(var2)
1114 {
1115 case 0x02ul:
1116 return true;
1117 default:
1118 return true;
1119 }
1120 }
1121 #endif
1122 return false;
1123 #endif
1124 }
1125
1126 /* ========= Errata 47 ========= */
1127 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1128 #define NRF54H_ERRATA_47_PRESENT 1
1129 #else
1130 #define NRF54H_ERRATA_47_PRESENT 0
1131 #endif
1132
1133 #ifndef NRF54H_ERRATA_47_ENABLE_WORKAROUND
1134 #define NRF54H_ERRATA_47_ENABLE_WORKAROUND NRF54H_ERRATA_47_PRESENT
1135 #endif
1136
nrf54h_errata_47(void)1137 static bool nrf54h_errata_47(void)
1138 {
1139 #ifndef NRF54H_SERIES
1140 return false;
1141 #else
1142 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1143 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
1144 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
1145 #endif
1146 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1147 if (var1 == 0x16)
1148 {
1149 switch(var2)
1150 {
1151 case 0x02ul:
1152 return true;
1153 default:
1154 return true;
1155 }
1156 }
1157 #endif
1158 return false;
1159 #endif
1160 }
1161
1162 /* ========= Errata 50 ========= */
1163 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1164 #define NRF54H_ERRATA_50_PRESENT 1
1165 #else
1166 #define NRF54H_ERRATA_50_PRESENT 0
1167 #endif
1168
1169 #ifndef NRF54H_ERRATA_50_ENABLE_WORKAROUND
1170 #define NRF54H_ERRATA_50_ENABLE_WORKAROUND NRF54H_ERRATA_50_PRESENT
1171 #endif
1172
nrf54h_errata_50(void)1173 static bool nrf54h_errata_50(void)
1174 {
1175 #ifndef NRF54H_SERIES
1176 return false;
1177 #else
1178 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1179 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
1180 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
1181 #endif
1182 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1183 if (var1 == 0x16)
1184 {
1185 switch(var2)
1186 {
1187 case 0x02ul:
1188 return true;
1189 default:
1190 return true;
1191 }
1192 }
1193 #endif
1194 return false;
1195 #endif
1196 }
1197
1198 /* ========= Errata 51 ========= */
1199 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1200 #define NRF54H_ERRATA_51_PRESENT 1
1201 #else
1202 #define NRF54H_ERRATA_51_PRESENT 0
1203 #endif
1204
1205 #ifndef NRF54H_ERRATA_51_ENABLE_WORKAROUND
1206 #define NRF54H_ERRATA_51_ENABLE_WORKAROUND NRF54H_ERRATA_51_PRESENT
1207 #endif
1208
nrf54h_errata_51(void)1209 static bool nrf54h_errata_51(void)
1210 {
1211 #ifndef NRF54H_SERIES
1212 return false;
1213 #else
1214 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1215 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
1216 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
1217 #endif
1218 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1219 if (var1 == 0x16)
1220 {
1221 switch(var2)
1222 {
1223 case 0x02ul:
1224 return true;
1225 default:
1226 return true;
1227 }
1228 }
1229 #endif
1230 return false;
1231 #endif
1232 }
1233
1234 /* ========= Errata 53 ========= */
1235 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1236 #define NRF54H_ERRATA_53_PRESENT 1
1237 #else
1238 #define NRF54H_ERRATA_53_PRESENT 0
1239 #endif
1240
1241 #ifndef NRF54H_ERRATA_53_ENABLE_WORKAROUND
1242 #define NRF54H_ERRATA_53_ENABLE_WORKAROUND NRF54H_ERRATA_53_PRESENT
1243 #endif
1244
nrf54h_errata_53(void)1245 static bool nrf54h_errata_53(void)
1246 {
1247 #ifndef NRF54H_SERIES
1248 return false;
1249 #else
1250 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1251 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
1252 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
1253 #endif
1254 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1255 if (var1 == 0x16)
1256 {
1257 switch(var2)
1258 {
1259 case 0x02ul:
1260 return true;
1261 default:
1262 return true;
1263 }
1264 }
1265 #endif
1266 return false;
1267 #endif
1268 }
1269
1270 /* ========= Errata 55 ========= */
1271 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1272 #define NRF54H_ERRATA_55_PRESENT 1
1273 #else
1274 #define NRF54H_ERRATA_55_PRESENT 0
1275 #endif
1276
1277 #ifndef NRF54H_ERRATA_55_ENABLE_WORKAROUND
1278 #define NRF54H_ERRATA_55_ENABLE_WORKAROUND NRF54H_ERRATA_55_PRESENT
1279 #endif
1280
nrf54h_errata_55(void)1281 static bool nrf54h_errata_55(void)
1282 {
1283 #ifndef NRF54H_SERIES
1284 return false;
1285 #else
1286 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1287 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
1288 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
1289 #endif
1290 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1291 if (var1 == 0x16)
1292 {
1293 switch(var2)
1294 {
1295 case 0x02ul:
1296 return true;
1297 default:
1298 return true;
1299 }
1300 }
1301 #endif
1302 return false;
1303 #endif
1304 }
1305
1306 /* ========= Errata 56 ========= */
1307 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1308 #define NRF54H_ERRATA_56_PRESENT 1
1309 #else
1310 #define NRF54H_ERRATA_56_PRESENT 0
1311 #endif
1312
1313 #ifndef NRF54H_ERRATA_56_ENABLE_WORKAROUND
1314 #define NRF54H_ERRATA_56_ENABLE_WORKAROUND NRF54H_ERRATA_56_PRESENT
1315 #endif
1316
nrf54h_errata_56(void)1317 static bool nrf54h_errata_56(void)
1318 {
1319 #ifndef NRF54H_SERIES
1320 return false;
1321 #else
1322 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1323 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
1324 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
1325 #endif
1326 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1327 if (var1 == 0x16)
1328 {
1329 switch(var2)
1330 {
1331 case 0x02ul:
1332 return true;
1333 default:
1334 return true;
1335 }
1336 }
1337 #endif
1338 return false;
1339 #endif
1340 }
1341
1342 /* ========= Errata 57 ========= */
1343 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1344 #define NRF54H_ERRATA_57_PRESENT 1
1345 #else
1346 #define NRF54H_ERRATA_57_PRESENT 0
1347 #endif
1348
1349 #ifndef NRF54H_ERRATA_57_ENABLE_WORKAROUND
1350 #define NRF54H_ERRATA_57_ENABLE_WORKAROUND NRF54H_ERRATA_57_PRESENT
1351 #endif
1352
nrf54h_errata_57(void)1353 static bool nrf54h_errata_57(void)
1354 {
1355 #ifndef NRF54H_SERIES
1356 return false;
1357 #else
1358 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1359 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
1360 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
1361 #endif
1362 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1363 if (var1 == 0x16)
1364 {
1365 switch(var2)
1366 {
1367 case 0x02ul:
1368 return true;
1369 default:
1370 return true;
1371 }
1372 }
1373 #endif
1374 return false;
1375 #endif
1376 }
1377
1378 /* ========= Errata 58 ========= */
1379 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1380 #define NRF54H_ERRATA_58_PRESENT 1
1381 #else
1382 #define NRF54H_ERRATA_58_PRESENT 0
1383 #endif
1384
1385 #ifndef NRF54H_ERRATA_58_ENABLE_WORKAROUND
1386 #define NRF54H_ERRATA_58_ENABLE_WORKAROUND NRF54H_ERRATA_58_PRESENT
1387 #endif
1388
nrf54h_errata_58(void)1389 static bool nrf54h_errata_58(void)
1390 {
1391 #ifndef NRF54H_SERIES
1392 return false;
1393 #else
1394 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1395 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
1396 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
1397 #endif
1398 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1399 if (var1 == 0x16)
1400 {
1401 switch(var2)
1402 {
1403 case 0x02ul:
1404 return true;
1405 default:
1406 return true;
1407 }
1408 }
1409 #endif
1410 return false;
1411 #endif
1412 }
1413
1414 /* ========= Errata 62 ========= */
1415 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1416 #define NRF54H_ERRATA_62_PRESENT 1
1417 #else
1418 #define NRF54H_ERRATA_62_PRESENT 0
1419 #endif
1420
1421 #ifndef NRF54H_ERRATA_62_ENABLE_WORKAROUND
1422 #define NRF54H_ERRATA_62_ENABLE_WORKAROUND NRF54H_ERRATA_62_PRESENT
1423 #endif
1424
nrf54h_errata_62(void)1425 static bool nrf54h_errata_62(void)
1426 {
1427 #ifndef NRF54H_SERIES
1428 return false;
1429 #else
1430 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1431 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
1432 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
1433 #endif
1434 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1435 if (var1 == 0x16)
1436 {
1437 switch(var2)
1438 {
1439 case 0x02ul:
1440 return true;
1441 default:
1442 return true;
1443 }
1444 }
1445 #endif
1446 return false;
1447 #endif
1448 }
1449
1450 /* ========= Errata 63 ========= */
1451 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1452 #define NRF54H_ERRATA_63_PRESENT 1
1453 #else
1454 #define NRF54H_ERRATA_63_PRESENT 0
1455 #endif
1456
1457 #ifndef NRF54H_ERRATA_63_ENABLE_WORKAROUND
1458 #define NRF54H_ERRATA_63_ENABLE_WORKAROUND NRF54H_ERRATA_63_PRESENT
1459 #endif
1460
nrf54h_errata_63(void)1461 static bool nrf54h_errata_63(void)
1462 {
1463 #ifndef NRF54H_SERIES
1464 return false;
1465 #else
1466 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1467 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
1468 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
1469 #endif
1470 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1471 if (var1 == 0x16)
1472 {
1473 switch(var2)
1474 {
1475 case 0x02ul:
1476 return true;
1477 default:
1478 return true;
1479 }
1480 }
1481 #endif
1482 return false;
1483 #endif
1484 }
1485
1486 /* ========= Errata 64 ========= */
1487 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1488 #define NRF54H_ERRATA_64_PRESENT 1
1489 #else
1490 #define NRF54H_ERRATA_64_PRESENT 0
1491 #endif
1492
1493 #ifndef NRF54H_ERRATA_64_ENABLE_WORKAROUND
1494 #define NRF54H_ERRATA_64_ENABLE_WORKAROUND NRF54H_ERRATA_64_PRESENT
1495 #endif
1496
nrf54h_errata_64(void)1497 static bool nrf54h_errata_64(void)
1498 {
1499 #ifndef NRF54H_SERIES
1500 return false;
1501 #else
1502 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1503 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
1504 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
1505 #endif
1506 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1507 if (var1 == 0x16)
1508 {
1509 switch(var2)
1510 {
1511 case 0x02ul:
1512 return true;
1513 default:
1514 return true;
1515 }
1516 }
1517 #endif
1518 return false;
1519 #endif
1520 }
1521
1522 /* ========= Errata 65 ========= */
1523 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1524 #define NRF54H_ERRATA_65_PRESENT 1
1525 #else
1526 #define NRF54H_ERRATA_65_PRESENT 0
1527 #endif
1528
1529 #ifndef NRF54H_ERRATA_65_ENABLE_WORKAROUND
1530 #define NRF54H_ERRATA_65_ENABLE_WORKAROUND NRF54H_ERRATA_65_PRESENT
1531 #endif
1532
nrf54h_errata_65(void)1533 static bool nrf54h_errata_65(void)
1534 {
1535 #ifndef NRF54H_SERIES
1536 return false;
1537 #else
1538 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1539 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
1540 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
1541 #endif
1542 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1543 if (var1 == 0x16)
1544 {
1545 switch(var2)
1546 {
1547 case 0x02ul:
1548 return true;
1549 default:
1550 return true;
1551 }
1552 }
1553 #endif
1554 return false;
1555 #endif
1556 }
1557
1558 /* ========= Errata 66 ========= */
1559 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1560 #define NRF54H_ERRATA_66_PRESENT 1
1561 #else
1562 #define NRF54H_ERRATA_66_PRESENT 0
1563 #endif
1564
1565 #ifndef NRF54H_ERRATA_66_ENABLE_WORKAROUND
1566 #define NRF54H_ERRATA_66_ENABLE_WORKAROUND NRF54H_ERRATA_66_PRESENT
1567 #endif
1568
nrf54h_errata_66(void)1569 static bool nrf54h_errata_66(void)
1570 {
1571 #ifndef NRF54H_SERIES
1572 return false;
1573 #else
1574 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1575 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
1576 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
1577 #endif
1578 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1579 if (var1 == 0x16)
1580 {
1581 switch(var2)
1582 {
1583 case 0x02ul:
1584 return true;
1585 default:
1586 return true;
1587 }
1588 }
1589 #endif
1590 return false;
1591 #endif
1592 }
1593
1594 /* ========= Errata 67 ========= */
1595 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1596 #define NRF54H_ERRATA_67_PRESENT 1
1597 #else
1598 #define NRF54H_ERRATA_67_PRESENT 0
1599 #endif
1600
1601 #ifndef NRF54H_ERRATA_67_ENABLE_WORKAROUND
1602 #define NRF54H_ERRATA_67_ENABLE_WORKAROUND NRF54H_ERRATA_67_PRESENT
1603 #endif
1604
nrf54h_errata_67(void)1605 static bool nrf54h_errata_67(void)
1606 {
1607 #ifndef NRF54H_SERIES
1608 return false;
1609 #else
1610 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1611 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
1612 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
1613 #endif
1614 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1615 if (var1 == 0x16)
1616 {
1617 switch(var2)
1618 {
1619 case 0x02ul:
1620 return true;
1621 default:
1622 return true;
1623 }
1624 }
1625 #endif
1626 return false;
1627 #endif
1628 }
1629
1630 /* ========= Errata 69 ========= */
1631 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1632 #define NRF54H_ERRATA_69_PRESENT 1
1633 #else
1634 #define NRF54H_ERRATA_69_PRESENT 0
1635 #endif
1636
1637 #ifndef NRF54H_ERRATA_69_ENABLE_WORKAROUND
1638 #define NRF54H_ERRATA_69_ENABLE_WORKAROUND NRF54H_ERRATA_69_PRESENT
1639 #endif
1640
nrf54h_errata_69(void)1641 static bool nrf54h_errata_69(void)
1642 {
1643 #ifndef NRF54H_SERIES
1644 return false;
1645 #else
1646 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1647 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
1648 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
1649 #endif
1650 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1651 if (var1 == 0x16)
1652 {
1653 switch(var2)
1654 {
1655 case 0x02ul:
1656 return true;
1657 default:
1658 return true;
1659 }
1660 }
1661 #endif
1662 return false;
1663 #endif
1664 }
1665
1666 /* ========= Errata 70 ========= */
1667 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1668 #define NRF54H_ERRATA_70_PRESENT 1
1669 #else
1670 #define NRF54H_ERRATA_70_PRESENT 0
1671 #endif
1672
1673 #ifndef NRF54H_ERRATA_70_ENABLE_WORKAROUND
1674 #define NRF54H_ERRATA_70_ENABLE_WORKAROUND NRF54H_ERRATA_70_PRESENT
1675 #endif
1676
nrf54h_errata_70(void)1677 static bool nrf54h_errata_70(void)
1678 {
1679 #ifndef NRF54H_SERIES
1680 return false;
1681 #else
1682 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1683 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
1684 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
1685 #endif
1686 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1687 if (var1 == 0x16)
1688 {
1689 switch(var2)
1690 {
1691 case 0x02ul:
1692 return true;
1693 default:
1694 return true;
1695 }
1696 }
1697 #endif
1698 return false;
1699 #endif
1700 }
1701
1702 /* ========= Errata 71 ========= */
1703 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1704 #define NRF54H_ERRATA_71_PRESENT 1
1705 #else
1706 #define NRF54H_ERRATA_71_PRESENT 0
1707 #endif
1708
1709 #ifndef NRF54H_ERRATA_71_ENABLE_WORKAROUND
1710 #define NRF54H_ERRATA_71_ENABLE_WORKAROUND NRF54H_ERRATA_71_PRESENT
1711 #endif
1712
nrf54h_errata_71(void)1713 static bool nrf54h_errata_71(void)
1714 {
1715 #ifndef NRF54H_SERIES
1716 return false;
1717 #else
1718 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1719 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
1720 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
1721 #endif
1722 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1723 if (var1 == 0x16)
1724 {
1725 switch(var2)
1726 {
1727 case 0x02ul:
1728 return true;
1729 default:
1730 return true;
1731 }
1732 }
1733 #endif
1734 return false;
1735 #endif
1736 }
1737
1738 /* ========= Errata 72 ========= */
1739 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1740 #define NRF54H_ERRATA_72_PRESENT 1
1741 #else
1742 #define NRF54H_ERRATA_72_PRESENT 0
1743 #endif
1744
1745 #ifndef NRF54H_ERRATA_72_ENABLE_WORKAROUND
1746 #define NRF54H_ERRATA_72_ENABLE_WORKAROUND NRF54H_ERRATA_72_PRESENT
1747 #endif
1748
nrf54h_errata_72(void)1749 static bool nrf54h_errata_72(void)
1750 {
1751 #ifndef NRF54H_SERIES
1752 return false;
1753 #else
1754 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1755 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
1756 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
1757 #endif
1758 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1759 if (var1 == 0x16)
1760 {
1761 switch(var2)
1762 {
1763 case 0x02ul:
1764 return true;
1765 default:
1766 return true;
1767 }
1768 }
1769 #endif
1770 return false;
1771 #endif
1772 }
1773
1774 /* ========= Errata 73 ========= */
1775 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1776 #define NRF54H_ERRATA_73_PRESENT 1
1777 #else
1778 #define NRF54H_ERRATA_73_PRESENT 0
1779 #endif
1780
1781 #ifndef NRF54H_ERRATA_73_ENABLE_WORKAROUND
1782 #define NRF54H_ERRATA_73_ENABLE_WORKAROUND NRF54H_ERRATA_73_PRESENT
1783 #endif
1784
nrf54h_errata_73(void)1785 static bool nrf54h_errata_73(void)
1786 {
1787 #ifndef NRF54H_SERIES
1788 return false;
1789 #else
1790 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1791 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
1792 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
1793 #endif
1794 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1795 if (var1 == 0x16)
1796 {
1797 switch(var2)
1798 {
1799 case 0x02ul:
1800 return true;
1801 default:
1802 return true;
1803 }
1804 }
1805 #endif
1806 return false;
1807 #endif
1808 }
1809
1810 /* ========= Errata 74 ========= */
1811 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1812 #define NRF54H_ERRATA_74_PRESENT 1
1813 #else
1814 #define NRF54H_ERRATA_74_PRESENT 0
1815 #endif
1816
1817 #ifndef NRF54H_ERRATA_74_ENABLE_WORKAROUND
1818 #define NRF54H_ERRATA_74_ENABLE_WORKAROUND NRF54H_ERRATA_74_PRESENT
1819 #endif
1820
nrf54h_errata_74(void)1821 static bool nrf54h_errata_74(void)
1822 {
1823 #ifndef NRF54H_SERIES
1824 return false;
1825 #else
1826 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1827 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
1828 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
1829 #endif
1830 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1831 if (var1 == 0x16)
1832 {
1833 switch(var2)
1834 {
1835 case 0x02ul:
1836 return true;
1837 default:
1838 return true;
1839 }
1840 }
1841 #endif
1842 return false;
1843 #endif
1844 }
1845
1846 /* ========= Errata 75 ========= */
1847 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1848 #define NRF54H_ERRATA_75_PRESENT 1
1849 #else
1850 #define NRF54H_ERRATA_75_PRESENT 0
1851 #endif
1852
1853 #ifndef NRF54H_ERRATA_75_ENABLE_WORKAROUND
1854 #define NRF54H_ERRATA_75_ENABLE_WORKAROUND NRF54H_ERRATA_75_PRESENT
1855 #endif
1856
nrf54h_errata_75(void)1857 static bool nrf54h_errata_75(void)
1858 {
1859 #ifndef NRF54H_SERIES
1860 return false;
1861 #else
1862 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1863 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
1864 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
1865 #endif
1866 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1867 if (var1 == 0x16)
1868 {
1869 switch(var2)
1870 {
1871 case 0x02ul:
1872 return true;
1873 default:
1874 return true;
1875 }
1876 }
1877 #endif
1878 return false;
1879 #endif
1880 }
1881
1882 /* ========= Errata 76 ========= */
1883 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1884 #define NRF54H_ERRATA_76_PRESENT 1
1885 #else
1886 #define NRF54H_ERRATA_76_PRESENT 0
1887 #endif
1888
1889 #ifndef NRF54H_ERRATA_76_ENABLE_WORKAROUND
1890 #define NRF54H_ERRATA_76_ENABLE_WORKAROUND NRF54H_ERRATA_76_PRESENT
1891 #endif
1892
nrf54h_errata_76(void)1893 static bool nrf54h_errata_76(void)
1894 {
1895 #ifndef NRF54H_SERIES
1896 return false;
1897 #else
1898 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1899 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
1900 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
1901 #endif
1902 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1903 if (var1 == 0x16)
1904 {
1905 switch(var2)
1906 {
1907 case 0x02ul:
1908 return true;
1909 default:
1910 return true;
1911 }
1912 }
1913 #endif
1914 return false;
1915 #endif
1916 }
1917
1918 /* ========= Errata 77 ========= */
1919 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1920 #define NRF54H_ERRATA_77_PRESENT 1
1921 #else
1922 #define NRF54H_ERRATA_77_PRESENT 0
1923 #endif
1924
1925 #ifndef NRF54H_ERRATA_77_ENABLE_WORKAROUND
1926 #define NRF54H_ERRATA_77_ENABLE_WORKAROUND NRF54H_ERRATA_77_PRESENT
1927 #endif
1928
nrf54h_errata_77(void)1929 static bool nrf54h_errata_77(void)
1930 {
1931 #ifndef NRF54H_SERIES
1932 return false;
1933 #else
1934 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1935 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
1936 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
1937 #endif
1938 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1939 if (var1 == 0x16)
1940 {
1941 switch(var2)
1942 {
1943 case 0x02ul:
1944 return true;
1945 default:
1946 return true;
1947 }
1948 }
1949 #endif
1950 return false;
1951 #endif
1952 }
1953
1954 /* ========= Errata 78 ========= */
1955 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1956 #define NRF54H_ERRATA_78_PRESENT 1
1957 #else
1958 #define NRF54H_ERRATA_78_PRESENT 0
1959 #endif
1960
1961 #ifndef NRF54H_ERRATA_78_ENABLE_WORKAROUND
1962 #define NRF54H_ERRATA_78_ENABLE_WORKAROUND NRF54H_ERRATA_78_PRESENT
1963 #endif
1964
nrf54h_errata_78(void)1965 static bool nrf54h_errata_78(void)
1966 {
1967 #ifndef NRF54H_SERIES
1968 return false;
1969 #else
1970 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1971 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
1972 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
1973 #endif
1974 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1975 if (var1 == 0x16)
1976 {
1977 switch(var2)
1978 {
1979 case 0x02ul:
1980 return true;
1981 default:
1982 return true;
1983 }
1984 }
1985 #endif
1986 return false;
1987 #endif
1988 }
1989
1990 /* ========= Errata 84 ========= */
1991 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
1992 #define NRF54H_ERRATA_84_PRESENT 1
1993 #else
1994 #define NRF54H_ERRATA_84_PRESENT 0
1995 #endif
1996
1997 #ifndef NRF54H_ERRATA_84_ENABLE_WORKAROUND
1998 #define NRF54H_ERRATA_84_ENABLE_WORKAROUND NRF54H_ERRATA_84_PRESENT
1999 #endif
2000
nrf54h_errata_84(void)2001 static bool nrf54h_errata_84(void)
2002 {
2003 #ifndef NRF54H_SERIES
2004 return false;
2005 #else
2006 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2007 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
2008 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
2009 #endif
2010 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2011 if (var1 == 0x16)
2012 {
2013 switch(var2)
2014 {
2015 case 0x02ul:
2016 return true;
2017 default:
2018 return true;
2019 }
2020 }
2021 #endif
2022 return false;
2023 #endif
2024 }
2025
2026 /* ========= Errata 92 ========= */
2027 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2028 #define NRF54H_ERRATA_92_PRESENT 1
2029 #else
2030 #define NRF54H_ERRATA_92_PRESENT 0
2031 #endif
2032
2033 #ifndef NRF54H_ERRATA_92_ENABLE_WORKAROUND
2034 #define NRF54H_ERRATA_92_ENABLE_WORKAROUND NRF54H_ERRATA_92_PRESENT
2035 #endif
2036
nrf54h_errata_92(void)2037 static bool nrf54h_errata_92(void)
2038 {
2039 #ifndef NRF54H_SERIES
2040 return false;
2041 #else
2042 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2043 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
2044 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
2045 #endif
2046 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2047 if (var1 == 0x16)
2048 {
2049 switch(var2)
2050 {
2051 case 0x02ul:
2052 return true;
2053 default:
2054 return true;
2055 }
2056 }
2057 #endif
2058 return false;
2059 #endif
2060 }
2061
2062 /* ========= Errata 93 ========= */
2063 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2064 #define NRF54H_ERRATA_93_PRESENT 1
2065 #else
2066 #define NRF54H_ERRATA_93_PRESENT 0
2067 #endif
2068
2069 #ifndef NRF54H_ERRATA_93_ENABLE_WORKAROUND
2070 #define NRF54H_ERRATA_93_ENABLE_WORKAROUND NRF54H_ERRATA_93_PRESENT
2071 #endif
2072
nrf54h_errata_93(void)2073 static bool nrf54h_errata_93(void)
2074 {
2075 #ifndef NRF54H_SERIES
2076 return false;
2077 #else
2078 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2079 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
2080 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
2081 #endif
2082 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2083 if (var1 == 0x16)
2084 {
2085 switch(var2)
2086 {
2087 case 0x02ul:
2088 return true;
2089 default:
2090 return true;
2091 }
2092 }
2093 #endif
2094 return false;
2095 #endif
2096 }
2097
2098 /* ========= Errata 98 ========= */
2099 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2100 #define NRF54H_ERRATA_98_PRESENT 1
2101 #else
2102 #define NRF54H_ERRATA_98_PRESENT 0
2103 #endif
2104
2105 #ifndef NRF54H_ERRATA_98_ENABLE_WORKAROUND
2106 #define NRF54H_ERRATA_98_ENABLE_WORKAROUND NRF54H_ERRATA_98_PRESENT
2107 #endif
2108
nrf54h_errata_98(void)2109 static bool nrf54h_errata_98(void)
2110 {
2111 #ifndef NRF54H_SERIES
2112 return false;
2113 #else
2114 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2115 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
2116 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
2117 #endif
2118 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2119 if (var1 == 0x16)
2120 {
2121 switch(var2)
2122 {
2123 case 0x02ul:
2124 return true;
2125 default:
2126 return true;
2127 }
2128 }
2129 #endif
2130 return false;
2131 #endif
2132 }
2133
2134 /* ========= Errata 102 ========= */
2135 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2136 #define NRF54H_ERRATA_102_PRESENT 1
2137 #else
2138 #define NRF54H_ERRATA_102_PRESENT 0
2139 #endif
2140
2141 #ifndef NRF54H_ERRATA_102_ENABLE_WORKAROUND
2142 #define NRF54H_ERRATA_102_ENABLE_WORKAROUND NRF54H_ERRATA_102_PRESENT
2143 #endif
2144
nrf54h_errata_102(void)2145 static bool nrf54h_errata_102(void)
2146 {
2147 #ifndef NRF54H_SERIES
2148 return false;
2149 #else
2150 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2151 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
2152 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
2153 #endif
2154 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2155 if (var1 == 0x16)
2156 {
2157 switch(var2)
2158 {
2159 case 0x02ul:
2160 return true;
2161 default:
2162 return true;
2163 }
2164 }
2165 #endif
2166 return false;
2167 #endif
2168 }
2169
2170 /* ========= Errata 103 ========= */
2171 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2172 #define NRF54H_ERRATA_103_PRESENT 1
2173 #else
2174 #define NRF54H_ERRATA_103_PRESENT 0
2175 #endif
2176
2177 #ifndef NRF54H_ERRATA_103_ENABLE_WORKAROUND
2178 #define NRF54H_ERRATA_103_ENABLE_WORKAROUND NRF54H_ERRATA_103_PRESENT
2179 #endif
2180
nrf54h_errata_103(void)2181 static bool nrf54h_errata_103(void)
2182 {
2183 #ifndef NRF54H_SERIES
2184 return false;
2185 #else
2186 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2187 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
2188 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
2189 #endif
2190 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2191 if (var1 == 0x16)
2192 {
2193 switch(var2)
2194 {
2195 case 0x02ul:
2196 return true;
2197 default:
2198 return true;
2199 }
2200 }
2201 #endif
2202 return false;
2203 #endif
2204 }
2205
2206 /* ========= Errata 104 ========= */
2207 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2208 #define NRF54H_ERRATA_104_PRESENT 1
2209 #else
2210 #define NRF54H_ERRATA_104_PRESENT 0
2211 #endif
2212
2213 #ifndef NRF54H_ERRATA_104_ENABLE_WORKAROUND
2214 #define NRF54H_ERRATA_104_ENABLE_WORKAROUND NRF54H_ERRATA_104_PRESENT
2215 #endif
2216
nrf54h_errata_104(void)2217 static bool nrf54h_errata_104(void)
2218 {
2219 #ifndef NRF54H_SERIES
2220 return false;
2221 #else
2222 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2223 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
2224 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
2225 #endif
2226 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2227 if (var1 == 0x16)
2228 {
2229 switch(var2)
2230 {
2231 case 0x02ul:
2232 return true;
2233 default:
2234 return true;
2235 }
2236 }
2237 #endif
2238 return false;
2239 #endif
2240 }
2241
2242 /* ========= Errata 105 ========= */
2243 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2244 #define NRF54H_ERRATA_105_PRESENT 1
2245 #else
2246 #define NRF54H_ERRATA_105_PRESENT 0
2247 #endif
2248
2249 #ifndef NRF54H_ERRATA_105_ENABLE_WORKAROUND
2250 #define NRF54H_ERRATA_105_ENABLE_WORKAROUND NRF54H_ERRATA_105_PRESENT
2251 #endif
2252
nrf54h_errata_105(void)2253 static bool nrf54h_errata_105(void)
2254 {
2255 #ifndef NRF54H_SERIES
2256 return false;
2257 #else
2258 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2259 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
2260 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
2261 #endif
2262 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2263 if (var1 == 0x16)
2264 {
2265 switch(var2)
2266 {
2267 case 0x02ul:
2268 return true;
2269 default:
2270 return true;
2271 }
2272 }
2273 #endif
2274 return false;
2275 #endif
2276 }
2277
2278 /* ========= Errata 106 ========= */
2279 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2280 #define NRF54H_ERRATA_106_PRESENT 1
2281 #else
2282 #define NRF54H_ERRATA_106_PRESENT 0
2283 #endif
2284
2285 #ifndef NRF54H_ERRATA_106_ENABLE_WORKAROUND
2286 #define NRF54H_ERRATA_106_ENABLE_WORKAROUND NRF54H_ERRATA_106_PRESENT
2287 #endif
2288
nrf54h_errata_106(void)2289 static bool nrf54h_errata_106(void)
2290 {
2291 #ifndef NRF54H_SERIES
2292 return false;
2293 #else
2294 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2295 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
2296 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
2297 #endif
2298 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2299 if (var1 == 0x16)
2300 {
2301 switch(var2)
2302 {
2303 case 0x02ul:
2304 return true;
2305 default:
2306 return true;
2307 }
2308 }
2309 #endif
2310 return false;
2311 #endif
2312 }
2313
2314 /* ========= Errata 107 ========= */
2315 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2316 #define NRF54H_ERRATA_107_PRESENT 1
2317 #else
2318 #define NRF54H_ERRATA_107_PRESENT 0
2319 #endif
2320
2321 #ifndef NRF54H_ERRATA_107_ENABLE_WORKAROUND
2322 #define NRF54H_ERRATA_107_ENABLE_WORKAROUND NRF54H_ERRATA_107_PRESENT
2323 #endif
2324
nrf54h_errata_107(void)2325 static bool nrf54h_errata_107(void)
2326 {
2327 #ifndef NRF54H_SERIES
2328 return false;
2329 #else
2330 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2331 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
2332 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
2333 #endif
2334 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2335 if (var1 == 0x16)
2336 {
2337 switch(var2)
2338 {
2339 case 0x02ul:
2340 return true;
2341 default:
2342 return true;
2343 }
2344 }
2345 #endif
2346 return false;
2347 #endif
2348 }
2349
2350 /* ========= Errata 109 ========= */
2351 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2352 #define NRF54H_ERRATA_109_PRESENT 1
2353 #else
2354 #define NRF54H_ERRATA_109_PRESENT 0
2355 #endif
2356
2357 #ifndef NRF54H_ERRATA_109_ENABLE_WORKAROUND
2358 #define NRF54H_ERRATA_109_ENABLE_WORKAROUND NRF54H_ERRATA_109_PRESENT
2359 #endif
2360
nrf54h_errata_109(void)2361 static bool nrf54h_errata_109(void)
2362 {
2363 #ifndef NRF54H_SERIES
2364 return false;
2365 #else
2366 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2367 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
2368 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
2369 #endif
2370 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2371 if (var1 == 0x16)
2372 {
2373 switch(var2)
2374 {
2375 case 0x02ul:
2376 return true;
2377 default:
2378 return true;
2379 }
2380 }
2381 #endif
2382 return false;
2383 #endif
2384 }
2385
2386 /* ========= Errata 110 ========= */
2387 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2388 #define NRF54H_ERRATA_110_PRESENT 1
2389 #else
2390 #define NRF54H_ERRATA_110_PRESENT 0
2391 #endif
2392
2393 #ifndef NRF54H_ERRATA_110_ENABLE_WORKAROUND
2394 #define NRF54H_ERRATA_110_ENABLE_WORKAROUND NRF54H_ERRATA_110_PRESENT
2395 #endif
2396
nrf54h_errata_110(void)2397 static bool nrf54h_errata_110(void)
2398 {
2399 #ifndef NRF54H_SERIES
2400 return false;
2401 #else
2402 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2403 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
2404 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
2405 #endif
2406 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2407 if (var1 == 0x16)
2408 {
2409 switch(var2)
2410 {
2411 case 0x02ul:
2412 return true;
2413 default:
2414 return true;
2415 }
2416 }
2417 #endif
2418 return false;
2419 #endif
2420 }
2421
2422 /* ========= Errata 111 ========= */
2423 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2424 #define NRF54H_ERRATA_111_PRESENT 1
2425 #else
2426 #define NRF54H_ERRATA_111_PRESENT 0
2427 #endif
2428
2429 #ifndef NRF54H_ERRATA_111_ENABLE_WORKAROUND
2430 #define NRF54H_ERRATA_111_ENABLE_WORKAROUND NRF54H_ERRATA_111_PRESENT
2431 #endif
2432
nrf54h_errata_111(void)2433 static bool nrf54h_errata_111(void)
2434 {
2435 #ifndef NRF54H_SERIES
2436 return false;
2437 #else
2438 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2439 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
2440 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
2441 #endif
2442 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2443 if (var1 == 0x16)
2444 {
2445 switch(var2)
2446 {
2447 case 0x02ul:
2448 return true;
2449 default:
2450 return true;
2451 }
2452 }
2453 #endif
2454 return false;
2455 #endif
2456 }
2457
2458 /* ========= Errata 112 ========= */
2459 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2460 #define NRF54H_ERRATA_112_PRESENT 1
2461 #else
2462 #define NRF54H_ERRATA_112_PRESENT 0
2463 #endif
2464
2465 #ifndef NRF54H_ERRATA_112_ENABLE_WORKAROUND
2466 #define NRF54H_ERRATA_112_ENABLE_WORKAROUND NRF54H_ERRATA_112_PRESENT
2467 #endif
2468
nrf54h_errata_112(void)2469 static bool nrf54h_errata_112(void)
2470 {
2471 #ifndef NRF54H_SERIES
2472 return false;
2473 #else
2474 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2475 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
2476 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
2477 #endif
2478 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2479 if (var1 == 0x16)
2480 {
2481 switch(var2)
2482 {
2483 case 0x02ul:
2484 return true;
2485 default:
2486 return true;
2487 }
2488 }
2489 #endif
2490 return false;
2491 #endif
2492 }
2493
2494 /* ========= Errata 115 ========= */
2495 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2496 #define NRF54H_ERRATA_115_PRESENT 1
2497 #else
2498 #define NRF54H_ERRATA_115_PRESENT 0
2499 #endif
2500
2501 #ifndef NRF54H_ERRATA_115_ENABLE_WORKAROUND
2502 #define NRF54H_ERRATA_115_ENABLE_WORKAROUND NRF54H_ERRATA_115_PRESENT
2503 #endif
2504
nrf54h_errata_115(void)2505 static bool nrf54h_errata_115(void)
2506 {
2507 #ifndef NRF54H_SERIES
2508 return false;
2509 #else
2510 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2511 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
2512 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
2513 #endif
2514 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2515 if (var1 == 0x16)
2516 {
2517 switch(var2)
2518 {
2519 case 0x02ul:
2520 return true;
2521 default:
2522 return true;
2523 }
2524 }
2525 #endif
2526 return false;
2527 #endif
2528 }
2529
2530 /* ========= Errata 116 ========= */
2531 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2532 #define NRF54H_ERRATA_116_PRESENT 1
2533 #else
2534 #define NRF54H_ERRATA_116_PRESENT 0
2535 #endif
2536
2537 #ifndef NRF54H_ERRATA_116_ENABLE_WORKAROUND
2538 #define NRF54H_ERRATA_116_ENABLE_WORKAROUND NRF54H_ERRATA_116_PRESENT
2539 #endif
2540
nrf54h_errata_116(void)2541 static bool nrf54h_errata_116(void)
2542 {
2543 #ifndef NRF54H_SERIES
2544 return false;
2545 #else
2546 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2547 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
2548 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
2549 #endif
2550 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2551 if (var1 == 0x16)
2552 {
2553 switch(var2)
2554 {
2555 case 0x02ul:
2556 return true;
2557 default:
2558 return true;
2559 }
2560 }
2561 #endif
2562 return false;
2563 #endif
2564 }
2565
2566 /* ========= Errata 117 ========= */
2567 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2568 #define NRF54H_ERRATA_117_PRESENT 1
2569 #else
2570 #define NRF54H_ERRATA_117_PRESENT 0
2571 #endif
2572
2573 #ifndef NRF54H_ERRATA_117_ENABLE_WORKAROUND
2574 #define NRF54H_ERRATA_117_ENABLE_WORKAROUND NRF54H_ERRATA_117_PRESENT
2575 #endif
2576
nrf54h_errata_117(void)2577 static bool nrf54h_errata_117(void)
2578 {
2579 #ifndef NRF54H_SERIES
2580 return false;
2581 #else
2582 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2583 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
2584 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
2585 #endif
2586 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2587 if (var1 == 0x16)
2588 {
2589 switch(var2)
2590 {
2591 case 0x02ul:
2592 return true;
2593 default:
2594 return true;
2595 }
2596 }
2597 #endif
2598 return false;
2599 #endif
2600 }
2601
2602 /* ========= Errata 118 ========= */
2603 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2604 #define NRF54H_ERRATA_118_PRESENT 1
2605 #else
2606 #define NRF54H_ERRATA_118_PRESENT 0
2607 #endif
2608
2609 #ifndef NRF54H_ERRATA_118_ENABLE_WORKAROUND
2610 #define NRF54H_ERRATA_118_ENABLE_WORKAROUND NRF54H_ERRATA_118_PRESENT
2611 #endif
2612
nrf54h_errata_118(void)2613 static bool nrf54h_errata_118(void)
2614 {
2615 #ifndef NRF54H_SERIES
2616 return false;
2617 #else
2618 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2619 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
2620 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
2621 #endif
2622 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2623 if (var1 == 0x16)
2624 {
2625 switch(var2)
2626 {
2627 case 0x02ul:
2628 return true;
2629 default:
2630 return true;
2631 }
2632 }
2633 #endif
2634 return false;
2635 #endif
2636 }
2637
2638 /* ========= Errata 119 ========= */
2639 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2640 #define NRF54H_ERRATA_119_PRESENT 1
2641 #else
2642 #define NRF54H_ERRATA_119_PRESENT 0
2643 #endif
2644
2645 #ifndef NRF54H_ERRATA_119_ENABLE_WORKAROUND
2646 #define NRF54H_ERRATA_119_ENABLE_WORKAROUND NRF54H_ERRATA_119_PRESENT
2647 #endif
2648
nrf54h_errata_119(void)2649 static bool nrf54h_errata_119(void)
2650 {
2651 #ifndef NRF54H_SERIES
2652 return false;
2653 #else
2654 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2655 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
2656 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
2657 #endif
2658 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2659 if (var1 == 0x16)
2660 {
2661 switch(var2)
2662 {
2663 case 0x02ul:
2664 return true;
2665 default:
2666 return true;
2667 }
2668 }
2669 #endif
2670 return false;
2671 #endif
2672 }
2673
2674 /* ========= Errata 120 ========= */
2675 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2676 #define NRF54H_ERRATA_120_PRESENT 1
2677 #else
2678 #define NRF54H_ERRATA_120_PRESENT 0
2679 #endif
2680
2681 #ifndef NRF54H_ERRATA_120_ENABLE_WORKAROUND
2682 #define NRF54H_ERRATA_120_ENABLE_WORKAROUND NRF54H_ERRATA_120_PRESENT
2683 #endif
2684
nrf54h_errata_120(void)2685 static bool nrf54h_errata_120(void)
2686 {
2687 #ifndef NRF54H_SERIES
2688 return false;
2689 #else
2690 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2691 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
2692 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
2693 #endif
2694 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2695 if (var1 == 0x16)
2696 {
2697 switch(var2)
2698 {
2699 case 0x02ul:
2700 return true;
2701 default:
2702 return true;
2703 }
2704 }
2705 #endif
2706 return false;
2707 #endif
2708 }
2709
2710 /* ========= Errata 121 ========= */
2711 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2712 #define NRF54H_ERRATA_121_PRESENT 1
2713 #else
2714 #define NRF54H_ERRATA_121_PRESENT 0
2715 #endif
2716
2717 #ifndef NRF54H_ERRATA_121_ENABLE_WORKAROUND
2718 #define NRF54H_ERRATA_121_ENABLE_WORKAROUND NRF54H_ERRATA_121_PRESENT
2719 #endif
2720
nrf54h_errata_121(void)2721 static bool nrf54h_errata_121(void)
2722 {
2723 #ifndef NRF54H_SERIES
2724 return false;
2725 #else
2726 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2727 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
2728 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
2729 #endif
2730 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2731 if (var1 == 0x16)
2732 {
2733 switch(var2)
2734 {
2735 case 0x02ul:
2736 return true;
2737 default:
2738 return true;
2739 }
2740 }
2741 #endif
2742 return false;
2743 #endif
2744 }
2745
2746 /* ========= Errata 122 ========= */
2747 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2748 #define NRF54H_ERRATA_122_PRESENT 1
2749 #else
2750 #define NRF54H_ERRATA_122_PRESENT 0
2751 #endif
2752
2753 #ifndef NRF54H_ERRATA_122_ENABLE_WORKAROUND
2754 #define NRF54H_ERRATA_122_ENABLE_WORKAROUND NRF54H_ERRATA_122_PRESENT
2755 #endif
2756
nrf54h_errata_122(void)2757 static bool nrf54h_errata_122(void)
2758 {
2759 #ifndef NRF54H_SERIES
2760 return false;
2761 #else
2762 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2763 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
2764 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
2765 #endif
2766 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2767 if (var1 == 0x16)
2768 {
2769 switch(var2)
2770 {
2771 case 0x02ul:
2772 return true;
2773 default:
2774 return true;
2775 }
2776 }
2777 #endif
2778 return false;
2779 #endif
2780 }
2781
2782 /* ========= Errata 123 ========= */
2783 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2784 #define NRF54H_ERRATA_123_PRESENT 1
2785 #else
2786 #define NRF54H_ERRATA_123_PRESENT 0
2787 #endif
2788
2789 #ifndef NRF54H_ERRATA_123_ENABLE_WORKAROUND
2790 #define NRF54H_ERRATA_123_ENABLE_WORKAROUND NRF54H_ERRATA_123_PRESENT
2791 #endif
2792
nrf54h_errata_123(void)2793 static bool nrf54h_errata_123(void)
2794 {
2795 #ifndef NRF54H_SERIES
2796 return false;
2797 #else
2798 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2799 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
2800 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
2801 #endif
2802 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2803 if (var1 == 0x16)
2804 {
2805 switch(var2)
2806 {
2807 case 0x02ul:
2808 return true;
2809 default:
2810 return true;
2811 }
2812 }
2813 #endif
2814 return false;
2815 #endif
2816 }
2817
2818 /* ========= Errata 124 ========= */
2819 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2820 #define NRF54H_ERRATA_124_PRESENT 1
2821 #else
2822 #define NRF54H_ERRATA_124_PRESENT 0
2823 #endif
2824
2825 #ifndef NRF54H_ERRATA_124_ENABLE_WORKAROUND
2826 #define NRF54H_ERRATA_124_ENABLE_WORKAROUND NRF54H_ERRATA_124_PRESENT
2827 #endif
2828
nrf54h_errata_124(void)2829 static bool nrf54h_errata_124(void)
2830 {
2831 #ifndef NRF54H_SERIES
2832 return false;
2833 #else
2834 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2835 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
2836 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
2837 #endif
2838 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2839 if (var1 == 0x16)
2840 {
2841 switch(var2)
2842 {
2843 case 0x02ul:
2844 return true;
2845 default:
2846 return true;
2847 }
2848 }
2849 #endif
2850 return false;
2851 #endif
2852 }
2853
2854 /* ========= Errata 125 ========= */
2855 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2856 #define NRF54H_ERRATA_125_PRESENT 1
2857 #else
2858 #define NRF54H_ERRATA_125_PRESENT 0
2859 #endif
2860
2861 #ifndef NRF54H_ERRATA_125_ENABLE_WORKAROUND
2862 #define NRF54H_ERRATA_125_ENABLE_WORKAROUND NRF54H_ERRATA_125_PRESENT
2863 #endif
2864
nrf54h_errata_125(void)2865 static bool nrf54h_errata_125(void)
2866 {
2867 #ifndef NRF54H_SERIES
2868 return false;
2869 #else
2870 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2871 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
2872 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
2873 #endif
2874 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2875 if (var1 == 0x16)
2876 {
2877 switch(var2)
2878 {
2879 case 0x02ul:
2880 return true;
2881 default:
2882 return true;
2883 }
2884 }
2885 #endif
2886 return false;
2887 #endif
2888 }
2889
2890 /* ========= Errata 126 ========= */
2891 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2892 #define NRF54H_ERRATA_126_PRESENT 1
2893 #else
2894 #define NRF54H_ERRATA_126_PRESENT 0
2895 #endif
2896
2897 #ifndef NRF54H_ERRATA_126_ENABLE_WORKAROUND
2898 #define NRF54H_ERRATA_126_ENABLE_WORKAROUND NRF54H_ERRATA_126_PRESENT
2899 #endif
2900
nrf54h_errata_126(void)2901 static bool nrf54h_errata_126(void)
2902 {
2903 #ifndef NRF54H_SERIES
2904 return false;
2905 #else
2906 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2907 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
2908 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
2909 #endif
2910 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2911 if (var1 == 0x16)
2912 {
2913 switch(var2)
2914 {
2915 case 0x02ul:
2916 return true;
2917 default:
2918 return true;
2919 }
2920 }
2921 #endif
2922 return false;
2923 #endif
2924 }
2925
2926 /* ========= Errata 127 ========= */
2927 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2928 #define NRF54H_ERRATA_127_PRESENT 1
2929 #else
2930 #define NRF54H_ERRATA_127_PRESENT 0
2931 #endif
2932
2933 #ifndef NRF54H_ERRATA_127_ENABLE_WORKAROUND
2934 #define NRF54H_ERRATA_127_ENABLE_WORKAROUND NRF54H_ERRATA_127_PRESENT
2935 #endif
2936
nrf54h_errata_127(void)2937 static bool nrf54h_errata_127(void)
2938 {
2939 #ifndef NRF54H_SERIES
2940 return false;
2941 #else
2942 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2943 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
2944 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
2945 #endif
2946 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2947 if (var1 == 0x16)
2948 {
2949 switch(var2)
2950 {
2951 case 0x02ul:
2952 return true;
2953 default:
2954 return true;
2955 }
2956 }
2957 #endif
2958 return false;
2959 #endif
2960 }
2961
2962 /* ========= Errata 128 ========= */
2963 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2964 #define NRF54H_ERRATA_128_PRESENT 1
2965 #else
2966 #define NRF54H_ERRATA_128_PRESENT 0
2967 #endif
2968
2969 #ifndef NRF54H_ERRATA_128_ENABLE_WORKAROUND
2970 #define NRF54H_ERRATA_128_ENABLE_WORKAROUND NRF54H_ERRATA_128_PRESENT
2971 #endif
2972
nrf54h_errata_128(void)2973 static bool nrf54h_errata_128(void)
2974 {
2975 #ifndef NRF54H_SERIES
2976 return false;
2977 #else
2978 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2979 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
2980 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
2981 #endif
2982 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
2983 if (var1 == 0x16)
2984 {
2985 switch(var2)
2986 {
2987 case 0x02ul:
2988 return true;
2989 default:
2990 return true;
2991 }
2992 }
2993 #endif
2994 return false;
2995 #endif
2996 }
2997
2998 /* ========= Errata 129 ========= */
2999 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3000 #define NRF54H_ERRATA_129_PRESENT 1
3001 #else
3002 #define NRF54H_ERRATA_129_PRESENT 0
3003 #endif
3004
3005 #ifndef NRF54H_ERRATA_129_ENABLE_WORKAROUND
3006 #define NRF54H_ERRATA_129_ENABLE_WORKAROUND NRF54H_ERRATA_129_PRESENT
3007 #endif
3008
nrf54h_errata_129(void)3009 static bool nrf54h_errata_129(void)
3010 {
3011 #ifndef NRF54H_SERIES
3012 return false;
3013 #else
3014 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3015 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
3016 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
3017 #endif
3018 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3019 if (var1 == 0x16)
3020 {
3021 switch(var2)
3022 {
3023 case 0x02ul:
3024 return true;
3025 default:
3026 return true;
3027 }
3028 }
3029 #endif
3030 return false;
3031 #endif
3032 }
3033
3034 /* ========= Errata 130 ========= */
3035 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3036 #define NRF54H_ERRATA_130_PRESENT 1
3037 #else
3038 #define NRF54H_ERRATA_130_PRESENT 0
3039 #endif
3040
3041 #ifndef NRF54H_ERRATA_130_ENABLE_WORKAROUND
3042 #define NRF54H_ERRATA_130_ENABLE_WORKAROUND NRF54H_ERRATA_130_PRESENT
3043 #endif
3044
nrf54h_errata_130(void)3045 static bool nrf54h_errata_130(void)
3046 {
3047 #ifndef NRF54H_SERIES
3048 return false;
3049 #else
3050 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3051 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
3052 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
3053 #endif
3054 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3055 if (var1 == 0x16)
3056 {
3057 switch(var2)
3058 {
3059 case 0x02ul:
3060 return true;
3061 default:
3062 return true;
3063 }
3064 }
3065 #endif
3066 return false;
3067 #endif
3068 }
3069
3070 /* ========= Errata 131 ========= */
3071 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3072 #define NRF54H_ERRATA_131_PRESENT 1
3073 #else
3074 #define NRF54H_ERRATA_131_PRESENT 0
3075 #endif
3076
3077 #ifndef NRF54H_ERRATA_131_ENABLE_WORKAROUND
3078 #define NRF54H_ERRATA_131_ENABLE_WORKAROUND NRF54H_ERRATA_131_PRESENT
3079 #endif
3080
nrf54h_errata_131(void)3081 static bool nrf54h_errata_131(void)
3082 {
3083 #ifndef NRF54H_SERIES
3084 return false;
3085 #else
3086 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3087 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
3088 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
3089 #endif
3090 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3091 if (var1 == 0x16)
3092 {
3093 switch(var2)
3094 {
3095 case 0x02ul:
3096 return true;
3097 default:
3098 return true;
3099 }
3100 }
3101 #endif
3102 return false;
3103 #endif
3104 }
3105
3106 /* ========= Errata 132 ========= */
3107 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3108 #define NRF54H_ERRATA_132_PRESENT 1
3109 #else
3110 #define NRF54H_ERRATA_132_PRESENT 0
3111 #endif
3112
3113 #ifndef NRF54H_ERRATA_132_ENABLE_WORKAROUND
3114 #define NRF54H_ERRATA_132_ENABLE_WORKAROUND NRF54H_ERRATA_132_PRESENT
3115 #endif
3116
nrf54h_errata_132(void)3117 static bool nrf54h_errata_132(void)
3118 {
3119 #ifndef NRF54H_SERIES
3120 return false;
3121 #else
3122 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3123 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
3124 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
3125 #endif
3126 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3127 if (var1 == 0x16)
3128 {
3129 switch(var2)
3130 {
3131 case 0x02ul:
3132 return true;
3133 default:
3134 return true;
3135 }
3136 }
3137 #endif
3138 return false;
3139 #endif
3140 }
3141
3142 /* ========= Errata 133 ========= */
3143 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3144 #define NRF54H_ERRATA_133_PRESENT 1
3145 #else
3146 #define NRF54H_ERRATA_133_PRESENT 0
3147 #endif
3148
3149 #ifndef NRF54H_ERRATA_133_ENABLE_WORKAROUND
3150 #define NRF54H_ERRATA_133_ENABLE_WORKAROUND NRF54H_ERRATA_133_PRESENT
3151 #endif
3152
nrf54h_errata_133(void)3153 static bool nrf54h_errata_133(void)
3154 {
3155 #ifndef NRF54H_SERIES
3156 return false;
3157 #else
3158 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3159 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
3160 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
3161 #endif
3162 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3163 if (var1 == 0x16)
3164 {
3165 switch(var2)
3166 {
3167 case 0x02ul:
3168 return true;
3169 default:
3170 return true;
3171 }
3172 }
3173 #endif
3174 return false;
3175 #endif
3176 }
3177
3178 /* ========= Errata 134 ========= */
3179 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3180 #define NRF54H_ERRATA_134_PRESENT 1
3181 #else
3182 #define NRF54H_ERRATA_134_PRESENT 0
3183 #endif
3184
3185 #ifndef NRF54H_ERRATA_134_ENABLE_WORKAROUND
3186 #define NRF54H_ERRATA_134_ENABLE_WORKAROUND NRF54H_ERRATA_134_PRESENT
3187 #endif
3188
nrf54h_errata_134(void)3189 static bool nrf54h_errata_134(void)
3190 {
3191 #ifndef NRF54H_SERIES
3192 return false;
3193 #else
3194 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3195 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
3196 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
3197 #endif
3198 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3199 if (var1 == 0x16)
3200 {
3201 switch(var2)
3202 {
3203 case 0x02ul:
3204 return true;
3205 default:
3206 return true;
3207 }
3208 }
3209 #endif
3210 return false;
3211 #endif
3212 }
3213
3214 /* ========= Errata 135 ========= */
3215 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3216 #define NRF54H_ERRATA_135_PRESENT 1
3217 #else
3218 #define NRF54H_ERRATA_135_PRESENT 0
3219 #endif
3220
3221 #ifndef NRF54H_ERRATA_135_ENABLE_WORKAROUND
3222 #define NRF54H_ERRATA_135_ENABLE_WORKAROUND NRF54H_ERRATA_135_PRESENT
3223 #endif
3224
nrf54h_errata_135(void)3225 static bool nrf54h_errata_135(void)
3226 {
3227 #ifndef NRF54H_SERIES
3228 return false;
3229 #else
3230 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3231 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
3232 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
3233 #endif
3234 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3235 if (var1 == 0x16)
3236 {
3237 switch(var2)
3238 {
3239 case 0x02ul:
3240 return true;
3241 default:
3242 return true;
3243 }
3244 }
3245 #endif
3246 return false;
3247 #endif
3248 }
3249
3250 /* ========= Errata 136 ========= */
3251 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3252 #define NRF54H_ERRATA_136_PRESENT 1
3253 #else
3254 #define NRF54H_ERRATA_136_PRESENT 0
3255 #endif
3256
3257 #ifndef NRF54H_ERRATA_136_ENABLE_WORKAROUND
3258 #define NRF54H_ERRATA_136_ENABLE_WORKAROUND NRF54H_ERRATA_136_PRESENT
3259 #endif
3260
nrf54h_errata_136(void)3261 static bool nrf54h_errata_136(void)
3262 {
3263 #ifndef NRF54H_SERIES
3264 return false;
3265 #else
3266 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3267 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
3268 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
3269 #endif
3270 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3271 if (var1 == 0x16)
3272 {
3273 switch(var2)
3274 {
3275 case 0x02ul:
3276 return true;
3277 default:
3278 return true;
3279 }
3280 }
3281 #endif
3282 return false;
3283 #endif
3284 }
3285
3286 /* ========= Errata 137 ========= */
3287 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3288 #define NRF54H_ERRATA_137_PRESENT 1
3289 #else
3290 #define NRF54H_ERRATA_137_PRESENT 0
3291 #endif
3292
3293 #ifndef NRF54H_ERRATA_137_ENABLE_WORKAROUND
3294 #define NRF54H_ERRATA_137_ENABLE_WORKAROUND NRF54H_ERRATA_137_PRESENT
3295 #endif
3296
nrf54h_errata_137(void)3297 static bool nrf54h_errata_137(void)
3298 {
3299 #ifndef NRF54H_SERIES
3300 return false;
3301 #else
3302 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3303 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
3304 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
3305 #endif
3306 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3307 if (var1 == 0x16)
3308 {
3309 switch(var2)
3310 {
3311 case 0x02ul:
3312 return true;
3313 default:
3314 return true;
3315 }
3316 }
3317 #endif
3318 return false;
3319 #endif
3320 }
3321
3322 /* ========= Errata 138 ========= */
3323 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3324 #define NRF54H_ERRATA_138_PRESENT 1
3325 #else
3326 #define NRF54H_ERRATA_138_PRESENT 0
3327 #endif
3328
3329 #ifndef NRF54H_ERRATA_138_ENABLE_WORKAROUND
3330 #define NRF54H_ERRATA_138_ENABLE_WORKAROUND NRF54H_ERRATA_138_PRESENT
3331 #endif
3332
nrf54h_errata_138(void)3333 static bool nrf54h_errata_138(void)
3334 {
3335 #ifndef NRF54H_SERIES
3336 return false;
3337 #else
3338 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3339 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
3340 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
3341 #endif
3342 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3343 if (var1 == 0x16)
3344 {
3345 switch(var2)
3346 {
3347 case 0x02ul:
3348 return true;
3349 default:
3350 return true;
3351 }
3352 }
3353 #endif
3354 return false;
3355 #endif
3356 }
3357
3358 /* ========= Errata 139 ========= */
3359 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3360 #define NRF54H_ERRATA_139_PRESENT 1
3361 #else
3362 #define NRF54H_ERRATA_139_PRESENT 0
3363 #endif
3364
3365 #ifndef NRF54H_ERRATA_139_ENABLE_WORKAROUND
3366 #define NRF54H_ERRATA_139_ENABLE_WORKAROUND NRF54H_ERRATA_139_PRESENT
3367 #endif
3368
nrf54h_errata_139(void)3369 static bool nrf54h_errata_139(void)
3370 {
3371 #ifndef NRF54H_SERIES
3372 return false;
3373 #else
3374 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3375 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
3376 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
3377 #endif
3378 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3379 if (var1 == 0x16)
3380 {
3381 switch(var2)
3382 {
3383 case 0x02ul:
3384 return true;
3385 default:
3386 return true;
3387 }
3388 }
3389 #endif
3390 return false;
3391 #endif
3392 }
3393
3394 /* ========= Errata 140 ========= */
3395 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3396 #define NRF54H_ERRATA_140_PRESENT 1
3397 #else
3398 #define NRF54H_ERRATA_140_PRESENT 0
3399 #endif
3400
3401 #ifndef NRF54H_ERRATA_140_ENABLE_WORKAROUND
3402 #define NRF54H_ERRATA_140_ENABLE_WORKAROUND NRF54H_ERRATA_140_PRESENT
3403 #endif
3404
nrf54h_errata_140(void)3405 static bool nrf54h_errata_140(void)
3406 {
3407 #ifndef NRF54H_SERIES
3408 return false;
3409 #else
3410 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3411 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
3412 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
3413 #endif
3414 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3415 if (var1 == 0x16)
3416 {
3417 switch(var2)
3418 {
3419 case 0x02ul:
3420 return true;
3421 default:
3422 return true;
3423 }
3424 }
3425 #endif
3426 return false;
3427 #endif
3428 }
3429
3430 /* ========= Errata 141 ========= */
3431 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3432 #define NRF54H_ERRATA_141_PRESENT 1
3433 #else
3434 #define NRF54H_ERRATA_141_PRESENT 0
3435 #endif
3436
3437 #ifndef NRF54H_ERRATA_141_ENABLE_WORKAROUND
3438 #define NRF54H_ERRATA_141_ENABLE_WORKAROUND NRF54H_ERRATA_141_PRESENT
3439 #endif
3440
nrf54h_errata_141(void)3441 static bool nrf54h_errata_141(void)
3442 {
3443 #ifndef NRF54H_SERIES
3444 return false;
3445 #else
3446 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3447 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
3448 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
3449 #endif
3450 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3451 if (var1 == 0x16)
3452 {
3453 switch(var2)
3454 {
3455 case 0x02ul:
3456 return true;
3457 default:
3458 return true;
3459 }
3460 }
3461 #endif
3462 return false;
3463 #endif
3464 }
3465
3466 /* ========= Errata 142 ========= */
3467 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3468 #define NRF54H_ERRATA_142_PRESENT 1
3469 #else
3470 #define NRF54H_ERRATA_142_PRESENT 0
3471 #endif
3472
3473 #ifndef NRF54H_ERRATA_142_ENABLE_WORKAROUND
3474 #define NRF54H_ERRATA_142_ENABLE_WORKAROUND NRF54H_ERRATA_142_PRESENT
3475 #endif
3476
nrf54h_errata_142(void)3477 static bool nrf54h_errata_142(void)
3478 {
3479 #ifndef NRF54H_SERIES
3480 return false;
3481 #else
3482 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3483 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
3484 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
3485 #endif
3486 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3487 if (var1 == 0x16)
3488 {
3489 switch(var2)
3490 {
3491 case 0x02ul:
3492 return true;
3493 default:
3494 return true;
3495 }
3496 }
3497 #endif
3498 return false;
3499 #endif
3500 }
3501
3502 /* ========= Errata 143 ========= */
3503 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3504 #define NRF54H_ERRATA_143_PRESENT 1
3505 #else
3506 #define NRF54H_ERRATA_143_PRESENT 0
3507 #endif
3508
3509 #ifndef NRF54H_ERRATA_143_ENABLE_WORKAROUND
3510 #define NRF54H_ERRATA_143_ENABLE_WORKAROUND NRF54H_ERRATA_143_PRESENT
3511 #endif
3512
nrf54h_errata_143(void)3513 static bool nrf54h_errata_143(void)
3514 {
3515 #ifndef NRF54H_SERIES
3516 return false;
3517 #else
3518 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3519 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
3520 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
3521 #endif
3522 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3523 if (var1 == 0x16)
3524 {
3525 switch(var2)
3526 {
3527 case 0x02ul:
3528 return true;
3529 default:
3530 return true;
3531 }
3532 }
3533 #endif
3534 return false;
3535 #endif
3536 }
3537
3538 /* ========= Errata 145 ========= */
3539 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3540 #define NRF54H_ERRATA_145_PRESENT 1
3541 #else
3542 #define NRF54H_ERRATA_145_PRESENT 0
3543 #endif
3544
3545 #ifndef NRF54H_ERRATA_145_ENABLE_WORKAROUND
3546 #define NRF54H_ERRATA_145_ENABLE_WORKAROUND NRF54H_ERRATA_145_PRESENT
3547 #endif
3548
nrf54h_errata_145(void)3549 static bool nrf54h_errata_145(void)
3550 {
3551 #ifndef NRF54H_SERIES
3552 return false;
3553 #else
3554 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3555 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
3556 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
3557 #endif
3558 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3559 if (var1 == 0x16)
3560 {
3561 switch(var2)
3562 {
3563 case 0x02ul:
3564 return true;
3565 default:
3566 return true;
3567 }
3568 }
3569 #endif
3570 return false;
3571 #endif
3572 }
3573
3574 /* ========= Errata 146 ========= */
3575 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3576 #define NRF54H_ERRATA_146_PRESENT 1
3577 #else
3578 #define NRF54H_ERRATA_146_PRESENT 0
3579 #endif
3580
3581 #ifndef NRF54H_ERRATA_146_ENABLE_WORKAROUND
3582 #define NRF54H_ERRATA_146_ENABLE_WORKAROUND NRF54H_ERRATA_146_PRESENT
3583 #endif
3584
nrf54h_errata_146(void)3585 static bool nrf54h_errata_146(void)
3586 {
3587 #ifndef NRF54H_SERIES
3588 return false;
3589 #else
3590 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3591 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
3592 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
3593 #endif
3594 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3595 if (var1 == 0x16)
3596 {
3597 switch(var2)
3598 {
3599 case 0x02ul:
3600 return true;
3601 default:
3602 return true;
3603 }
3604 }
3605 #endif
3606 return false;
3607 #endif
3608 }
3609
3610 /* ========= Errata 148 ========= */
3611 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3612 #define NRF54H_ERRATA_148_PRESENT 1
3613 #else
3614 #define NRF54H_ERRATA_148_PRESENT 0
3615 #endif
3616
3617 #ifndef NRF54H_ERRATA_148_ENABLE_WORKAROUND
3618 #define NRF54H_ERRATA_148_ENABLE_WORKAROUND NRF54H_ERRATA_148_PRESENT
3619 #endif
3620
nrf54h_errata_148(void)3621 static bool nrf54h_errata_148(void)
3622 {
3623 #ifndef NRF54H_SERIES
3624 return false;
3625 #else
3626 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3627 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
3628 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
3629 #endif
3630 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3631 if (var1 == 0x16)
3632 {
3633 switch(var2)
3634 {
3635 case 0x02ul:
3636 return true;
3637 default:
3638 return true;
3639 }
3640 }
3641 #endif
3642 return false;
3643 #endif
3644 }
3645
3646 /* ========= Errata 149 ========= */
3647 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3648 #define NRF54H_ERRATA_149_PRESENT 1
3649 #else
3650 #define NRF54H_ERRATA_149_PRESENT 0
3651 #endif
3652
3653 #ifndef NRF54H_ERRATA_149_ENABLE_WORKAROUND
3654 #define NRF54H_ERRATA_149_ENABLE_WORKAROUND NRF54H_ERRATA_149_PRESENT
3655 #endif
3656
nrf54h_errata_149(void)3657 static bool nrf54h_errata_149(void)
3658 {
3659 #ifndef NRF54H_SERIES
3660 return false;
3661 #else
3662 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3663 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
3664 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
3665 #endif
3666 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3667 if (var1 == 0x16)
3668 {
3669 switch(var2)
3670 {
3671 case 0x02ul:
3672 return true;
3673 default:
3674 return true;
3675 }
3676 }
3677 #endif
3678 return false;
3679 #endif
3680 }
3681
3682 /* ========= Errata 151 ========= */
3683 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3684 #define NRF54H_ERRATA_151_PRESENT 1
3685 #else
3686 #define NRF54H_ERRATA_151_PRESENT 0
3687 #endif
3688
3689 #ifndef NRF54H_ERRATA_151_ENABLE_WORKAROUND
3690 #define NRF54H_ERRATA_151_ENABLE_WORKAROUND NRF54H_ERRATA_151_PRESENT
3691 #endif
3692
nrf54h_errata_151(void)3693 static bool nrf54h_errata_151(void)
3694 {
3695 #ifndef NRF54H_SERIES
3696 return false;
3697 #else
3698 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3699 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
3700 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
3701 #endif
3702 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3703 if (var1 == 0x16)
3704 {
3705 switch(var2)
3706 {
3707 case 0x02ul:
3708 return true;
3709 default:
3710 return true;
3711 }
3712 }
3713 #endif
3714 return false;
3715 #endif
3716 }
3717
3718 /* ========= Errata 152 ========= */
3719 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3720 #define NRF54H_ERRATA_152_PRESENT 1
3721 #else
3722 #define NRF54H_ERRATA_152_PRESENT 0
3723 #endif
3724
3725 #ifndef NRF54H_ERRATA_152_ENABLE_WORKAROUND
3726 #define NRF54H_ERRATA_152_ENABLE_WORKAROUND NRF54H_ERRATA_152_PRESENT
3727 #endif
3728
nrf54h_errata_152(void)3729 static bool nrf54h_errata_152(void)
3730 {
3731 #ifndef NRF54H_SERIES
3732 return false;
3733 #else
3734 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3735 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
3736 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
3737 #endif
3738 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3739 if (var1 == 0x16)
3740 {
3741 switch(var2)
3742 {
3743 case 0x02ul:
3744 return true;
3745 default:
3746 return true;
3747 }
3748 }
3749 #endif
3750 return false;
3751 #endif
3752 }
3753
3754 /* ========= Errata 153 ========= */
3755 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3756 #define NRF54H_ERRATA_153_PRESENT 1
3757 #else
3758 #define NRF54H_ERRATA_153_PRESENT 0
3759 #endif
3760
3761 #ifndef NRF54H_ERRATA_153_ENABLE_WORKAROUND
3762 #define NRF54H_ERRATA_153_ENABLE_WORKAROUND NRF54H_ERRATA_153_PRESENT
3763 #endif
3764
nrf54h_errata_153(void)3765 static bool nrf54h_errata_153(void)
3766 {
3767 #ifndef NRF54H_SERIES
3768 return false;
3769 #else
3770 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3771 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
3772 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
3773 #endif
3774 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3775 if (var1 == 0x16)
3776 {
3777 switch(var2)
3778 {
3779 case 0x02ul:
3780 return true;
3781 default:
3782 return true;
3783 }
3784 }
3785 #endif
3786 return false;
3787 #endif
3788 }
3789
3790 /* ========= Errata 155 ========= */
3791 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3792 #define NRF54H_ERRATA_155_PRESENT 1
3793 #else
3794 #define NRF54H_ERRATA_155_PRESENT 0
3795 #endif
3796
3797 #ifndef NRF54H_ERRATA_155_ENABLE_WORKAROUND
3798 #define NRF54H_ERRATA_155_ENABLE_WORKAROUND NRF54H_ERRATA_155_PRESENT
3799 #endif
3800
nrf54h_errata_155(void)3801 static bool nrf54h_errata_155(void)
3802 {
3803 #ifndef NRF54H_SERIES
3804 return false;
3805 #else
3806 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3807 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
3808 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
3809 #endif
3810 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3811 if (var1 == 0x16)
3812 {
3813 switch(var2)
3814 {
3815 case 0x02ul:
3816 return true;
3817 default:
3818 return true;
3819 }
3820 }
3821 #endif
3822 return false;
3823 #endif
3824 }
3825
3826 /* ========= Errata 156 ========= */
3827 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3828 #define NRF54H_ERRATA_156_PRESENT 1
3829 #else
3830 #define NRF54H_ERRATA_156_PRESENT 0
3831 #endif
3832
3833 #ifndef NRF54H_ERRATA_156_ENABLE_WORKAROUND
3834 #define NRF54H_ERRATA_156_ENABLE_WORKAROUND NRF54H_ERRATA_156_PRESENT
3835 #endif
3836
nrf54h_errata_156(void)3837 static bool nrf54h_errata_156(void)
3838 {
3839 #ifndef NRF54H_SERIES
3840 return false;
3841 #else
3842 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3843 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
3844 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
3845 #endif
3846 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3847 if (var1 == 0x16)
3848 {
3849 switch(var2)
3850 {
3851 case 0x02ul:
3852 return true;
3853 default:
3854 return true;
3855 }
3856 }
3857 #endif
3858 return false;
3859 #endif
3860 }
3861
3862 /* ========= Errata 157 ========= */
3863 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3864 #define NRF54H_ERRATA_157_PRESENT 1
3865 #else
3866 #define NRF54H_ERRATA_157_PRESENT 0
3867 #endif
3868
3869 #ifndef NRF54H_ERRATA_157_ENABLE_WORKAROUND
3870 #define NRF54H_ERRATA_157_ENABLE_WORKAROUND NRF54H_ERRATA_157_PRESENT
3871 #endif
3872
nrf54h_errata_157(void)3873 static bool nrf54h_errata_157(void)
3874 {
3875 #ifndef NRF54H_SERIES
3876 return false;
3877 #else
3878 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3879 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
3880 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
3881 #endif
3882 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3883 if (var1 == 0x16)
3884 {
3885 switch(var2)
3886 {
3887 case 0x02ul:
3888 return true;
3889 default:
3890 return true;
3891 }
3892 }
3893 #endif
3894 return false;
3895 #endif
3896 }
3897
3898 /* ========= Errata 158 ========= */
3899 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3900 #define NRF54H_ERRATA_158_PRESENT 1
3901 #else
3902 #define NRF54H_ERRATA_158_PRESENT 0
3903 #endif
3904
3905 #ifndef NRF54H_ERRATA_158_ENABLE_WORKAROUND
3906 #define NRF54H_ERRATA_158_ENABLE_WORKAROUND NRF54H_ERRATA_158_PRESENT
3907 #endif
3908
nrf54h_errata_158(void)3909 static bool nrf54h_errata_158(void)
3910 {
3911 #ifndef NRF54H_SERIES
3912 return false;
3913 #else
3914 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3915 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
3916 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
3917 #endif
3918 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3919 if (var1 == 0x16)
3920 {
3921 switch(var2)
3922 {
3923 case 0x02ul:
3924 return true;
3925 default:
3926 return true;
3927 }
3928 }
3929 #endif
3930 return false;
3931 #endif
3932 }
3933
3934 /* ========= Errata 159 ========= */
3935 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3936 #define NRF54H_ERRATA_159_PRESENT 1
3937 #else
3938 #define NRF54H_ERRATA_159_PRESENT 0
3939 #endif
3940
3941 #ifndef NRF54H_ERRATA_159_ENABLE_WORKAROUND
3942 #define NRF54H_ERRATA_159_ENABLE_WORKAROUND NRF54H_ERRATA_159_PRESENT
3943 #endif
3944
nrf54h_errata_159(void)3945 static bool nrf54h_errata_159(void)
3946 {
3947 #ifndef NRF54H_SERIES
3948 return false;
3949 #else
3950 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3951 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
3952 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
3953 #endif
3954 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3955 if (var1 == 0x16)
3956 {
3957 switch(var2)
3958 {
3959 case 0x02ul:
3960 return true;
3961 default:
3962 return true;
3963 }
3964 }
3965 #endif
3966 return false;
3967 #endif
3968 }
3969
3970 /* ========= Errata 160 ========= */
3971 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3972 #define NRF54H_ERRATA_160_PRESENT 1
3973 #else
3974 #define NRF54H_ERRATA_160_PRESENT 0
3975 #endif
3976
3977 #ifndef NRF54H_ERRATA_160_ENABLE_WORKAROUND
3978 #define NRF54H_ERRATA_160_ENABLE_WORKAROUND NRF54H_ERRATA_160_PRESENT
3979 #endif
3980
nrf54h_errata_160(void)3981 static bool nrf54h_errata_160(void)
3982 {
3983 #ifndef NRF54H_SERIES
3984 return false;
3985 #else
3986 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3987 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
3988 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
3989 #endif
3990 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
3991 if (var1 == 0x16)
3992 {
3993 switch(var2)
3994 {
3995 case 0x02ul:
3996 return true;
3997 default:
3998 return true;
3999 }
4000 }
4001 #endif
4002 return false;
4003 #endif
4004 }
4005
4006 /* ========= Errata 161 ========= */
4007 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4008 #define NRF54H_ERRATA_161_PRESENT 1
4009 #else
4010 #define NRF54H_ERRATA_161_PRESENT 0
4011 #endif
4012
4013 #ifndef NRF54H_ERRATA_161_ENABLE_WORKAROUND
4014 #define NRF54H_ERRATA_161_ENABLE_WORKAROUND NRF54H_ERRATA_161_PRESENT
4015 #endif
4016
nrf54h_errata_161(void)4017 static bool nrf54h_errata_161(void)
4018 {
4019 #ifndef NRF54H_SERIES
4020 return false;
4021 #else
4022 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4023 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
4024 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
4025 #endif
4026 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4027 if (var1 == 0x16)
4028 {
4029 switch(var2)
4030 {
4031 case 0x02ul:
4032 return true;
4033 default:
4034 return true;
4035 }
4036 }
4037 #endif
4038 return false;
4039 #endif
4040 }
4041
4042 /* ========= Errata 162 ========= */
4043 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4044 #define NRF54H_ERRATA_162_PRESENT 1
4045 #else
4046 #define NRF54H_ERRATA_162_PRESENT 0
4047 #endif
4048
4049 #ifndef NRF54H_ERRATA_162_ENABLE_WORKAROUND
4050 #define NRF54H_ERRATA_162_ENABLE_WORKAROUND NRF54H_ERRATA_162_PRESENT
4051 #endif
4052
nrf54h_errata_162(void)4053 static bool nrf54h_errata_162(void)
4054 {
4055 #ifndef NRF54H_SERIES
4056 return false;
4057 #else
4058 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4059 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
4060 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
4061 #endif
4062 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4063 if (var1 == 0x16)
4064 {
4065 switch(var2)
4066 {
4067 case 0x02ul:
4068 return true;
4069 default:
4070 return true;
4071 }
4072 }
4073 #endif
4074 return false;
4075 #endif
4076 }
4077
4078 /* ========= Errata 163 ========= */
4079 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4080 #define NRF54H_ERRATA_163_PRESENT 1
4081 #else
4082 #define NRF54H_ERRATA_163_PRESENT 0
4083 #endif
4084
4085 #ifndef NRF54H_ERRATA_163_ENABLE_WORKAROUND
4086 #define NRF54H_ERRATA_163_ENABLE_WORKAROUND NRF54H_ERRATA_163_PRESENT
4087 #endif
4088
nrf54h_errata_163(void)4089 static bool nrf54h_errata_163(void)
4090 {
4091 #ifndef NRF54H_SERIES
4092 return false;
4093 #else
4094 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4095 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
4096 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
4097 #endif
4098 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4099 if (var1 == 0x16)
4100 {
4101 switch(var2)
4102 {
4103 case 0x02ul:
4104 return true;
4105 default:
4106 return true;
4107 }
4108 }
4109 #endif
4110 return false;
4111 #endif
4112 }
4113
4114 /* ========= Errata 164 ========= */
4115 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4116 #define NRF54H_ERRATA_164_PRESENT 1
4117 #else
4118 #define NRF54H_ERRATA_164_PRESENT 0
4119 #endif
4120
4121 #ifndef NRF54H_ERRATA_164_ENABLE_WORKAROUND
4122 #define NRF54H_ERRATA_164_ENABLE_WORKAROUND NRF54H_ERRATA_164_PRESENT
4123 #endif
4124
nrf54h_errata_164(void)4125 static bool nrf54h_errata_164(void)
4126 {
4127 #ifndef NRF54H_SERIES
4128 return false;
4129 #else
4130 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4131 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
4132 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
4133 #endif
4134 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4135 if (var1 == 0x16)
4136 {
4137 switch(var2)
4138 {
4139 case 0x02ul:
4140 return true;
4141 default:
4142 return true;
4143 }
4144 }
4145 #endif
4146 return false;
4147 #endif
4148 }
4149
4150 /* ========= Errata 165 ========= */
4151 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4152 #define NRF54H_ERRATA_165_PRESENT 1
4153 #else
4154 #define NRF54H_ERRATA_165_PRESENT 0
4155 #endif
4156
4157 #ifndef NRF54H_ERRATA_165_ENABLE_WORKAROUND
4158 #define NRF54H_ERRATA_165_ENABLE_WORKAROUND NRF54H_ERRATA_165_PRESENT
4159 #endif
4160
nrf54h_errata_165(void)4161 static bool nrf54h_errata_165(void)
4162 {
4163 #ifndef NRF54H_SERIES
4164 return false;
4165 #else
4166 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4167 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
4168 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
4169 #endif
4170 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4171 if (var1 == 0x16)
4172 {
4173 switch(var2)
4174 {
4175 case 0x02ul:
4176 return true;
4177 default:
4178 return true;
4179 }
4180 }
4181 #endif
4182 return false;
4183 #endif
4184 }
4185
4186 /* ========= Errata 166 ========= */
4187 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4188 #define NRF54H_ERRATA_166_PRESENT 1
4189 #else
4190 #define NRF54H_ERRATA_166_PRESENT 0
4191 #endif
4192
4193 #ifndef NRF54H_ERRATA_166_ENABLE_WORKAROUND
4194 #define NRF54H_ERRATA_166_ENABLE_WORKAROUND NRF54H_ERRATA_166_PRESENT
4195 #endif
4196
nrf54h_errata_166(void)4197 static bool nrf54h_errata_166(void)
4198 {
4199 #ifndef NRF54H_SERIES
4200 return false;
4201 #else
4202 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4203 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
4204 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
4205 #endif
4206 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4207 if (var1 == 0x16)
4208 {
4209 switch(var2)
4210 {
4211 case 0x02ul:
4212 return true;
4213 default:
4214 return true;
4215 }
4216 }
4217 #endif
4218 return false;
4219 #endif
4220 }
4221
4222 /* ========= Errata 169 ========= */
4223 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4224 #define NRF54H_ERRATA_169_PRESENT 1
4225 #else
4226 #define NRF54H_ERRATA_169_PRESENT 0
4227 #endif
4228
4229 #ifndef NRF54H_ERRATA_169_ENABLE_WORKAROUND
4230 #define NRF54H_ERRATA_169_ENABLE_WORKAROUND NRF54H_ERRATA_169_PRESENT
4231 #endif
4232
nrf54h_errata_169(void)4233 static bool nrf54h_errata_169(void)
4234 {
4235 #ifndef NRF54H_SERIES
4236 return false;
4237 #else
4238 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4239 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
4240 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
4241 #endif
4242 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4243 if (var1 == 0x16)
4244 {
4245 switch(var2)
4246 {
4247 case 0x02ul:
4248 return true;
4249 default:
4250 return true;
4251 }
4252 }
4253 #endif
4254 return false;
4255 #endif
4256 }
4257
4258 /* ========= Errata 171 ========= */
4259 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4260 #define NRF54H_ERRATA_171_PRESENT 1
4261 #else
4262 #define NRF54H_ERRATA_171_PRESENT 0
4263 #endif
4264
4265 #ifndef NRF54H_ERRATA_171_ENABLE_WORKAROUND
4266 #define NRF54H_ERRATA_171_ENABLE_WORKAROUND NRF54H_ERRATA_171_PRESENT
4267 #endif
4268
nrf54h_errata_171(void)4269 static bool nrf54h_errata_171(void)
4270 {
4271 #ifndef NRF54H_SERIES
4272 return false;
4273 #else
4274 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4275 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
4276 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
4277 #endif
4278 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4279 if (var1 == 0x16)
4280 {
4281 switch(var2)
4282 {
4283 case 0x02ul:
4284 return true;
4285 default:
4286 return true;
4287 }
4288 }
4289 #endif
4290 return false;
4291 #endif
4292 }
4293
4294 /* ========= Errata 172 ========= */
4295 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4296 #define NRF54H_ERRATA_172_PRESENT 1
4297 #else
4298 #define NRF54H_ERRATA_172_PRESENT 0
4299 #endif
4300
4301 #ifndef NRF54H_ERRATA_172_ENABLE_WORKAROUND
4302 #define NRF54H_ERRATA_172_ENABLE_WORKAROUND NRF54H_ERRATA_172_PRESENT
4303 #endif
4304
nrf54h_errata_172(void)4305 static bool nrf54h_errata_172(void)
4306 {
4307 #ifndef NRF54H_SERIES
4308 return false;
4309 #else
4310 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4311 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
4312 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
4313 #endif
4314 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4315 if (var1 == 0x16)
4316 {
4317 switch(var2)
4318 {
4319 case 0x02ul:
4320 return true;
4321 default:
4322 return true;
4323 }
4324 }
4325 #endif
4326 return false;
4327 #endif
4328 }
4329
4330 /* ========= Errata 173 ========= */
4331 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4332 #define NRF54H_ERRATA_173_PRESENT 1
4333 #else
4334 #define NRF54H_ERRATA_173_PRESENT 0
4335 #endif
4336
4337 #ifndef NRF54H_ERRATA_173_ENABLE_WORKAROUND
4338 #define NRF54H_ERRATA_173_ENABLE_WORKAROUND NRF54H_ERRATA_173_PRESENT
4339 #endif
4340
nrf54h_errata_173(void)4341 static bool nrf54h_errata_173(void)
4342 {
4343 #ifndef NRF54H_SERIES
4344 return false;
4345 #else
4346 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4347 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
4348 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
4349 #endif
4350 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4351 if (var1 == 0x16)
4352 {
4353 switch(var2)
4354 {
4355 case 0x02ul:
4356 return true;
4357 default:
4358 return true;
4359 }
4360 }
4361 #endif
4362 return false;
4363 #endif
4364 }
4365
4366 /* ========= Errata 175 ========= */
4367 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4368 #define NRF54H_ERRATA_175_PRESENT 1
4369 #else
4370 #define NRF54H_ERRATA_175_PRESENT 0
4371 #endif
4372
4373 #ifndef NRF54H_ERRATA_175_ENABLE_WORKAROUND
4374 #define NRF54H_ERRATA_175_ENABLE_WORKAROUND NRF54H_ERRATA_175_PRESENT
4375 #endif
4376
nrf54h_errata_175(void)4377 static bool nrf54h_errata_175(void)
4378 {
4379 #ifndef NRF54H_SERIES
4380 return false;
4381 #else
4382 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4383 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
4384 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
4385 #endif
4386 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4387 if (var1 == 0x16)
4388 {
4389 switch(var2)
4390 {
4391 case 0x02ul:
4392 return true;
4393 default:
4394 return true;
4395 }
4396 }
4397 #endif
4398 return false;
4399 #endif
4400 }
4401
4402 /* ========= Errata 177 ========= */
4403 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4404 #define NRF54H_ERRATA_177_PRESENT 1
4405 #else
4406 #define NRF54H_ERRATA_177_PRESENT 0
4407 #endif
4408
4409 #ifndef NRF54H_ERRATA_177_ENABLE_WORKAROUND
4410 #define NRF54H_ERRATA_177_ENABLE_WORKAROUND NRF54H_ERRATA_177_PRESENT
4411 #endif
4412
nrf54h_errata_177(void)4413 static bool nrf54h_errata_177(void)
4414 {
4415 #ifndef NRF54H_SERIES
4416 return false;
4417 #else
4418 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4419 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
4420 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
4421 #endif
4422 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4423 if (var1 == 0x16)
4424 {
4425 switch(var2)
4426 {
4427 case 0x02ul:
4428 return true;
4429 default:
4430 return true;
4431 }
4432 }
4433 #endif
4434 return false;
4435 #endif
4436 }
4437
4438 /* ========= Errata 178 ========= */
4439 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4440 #define NRF54H_ERRATA_178_PRESENT 1
4441 #else
4442 #define NRF54H_ERRATA_178_PRESENT 0
4443 #endif
4444
4445 #ifndef NRF54H_ERRATA_178_ENABLE_WORKAROUND
4446 #define NRF54H_ERRATA_178_ENABLE_WORKAROUND NRF54H_ERRATA_178_PRESENT
4447 #endif
4448
nrf54h_errata_178(void)4449 static bool nrf54h_errata_178(void)
4450 {
4451 #ifndef NRF54H_SERIES
4452 return false;
4453 #else
4454 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4455 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
4456 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
4457 #endif
4458 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4459 if (var1 == 0x16)
4460 {
4461 switch(var2)
4462 {
4463 case 0x02ul:
4464 return true;
4465 default:
4466 return true;
4467 }
4468 }
4469 #endif
4470 return false;
4471 #endif
4472 }
4473
4474 /* ========= Errata 179 ========= */
4475 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4476 #define NRF54H_ERRATA_179_PRESENT 1
4477 #else
4478 #define NRF54H_ERRATA_179_PRESENT 0
4479 #endif
4480
4481 #ifndef NRF54H_ERRATA_179_ENABLE_WORKAROUND
4482 #define NRF54H_ERRATA_179_ENABLE_WORKAROUND NRF54H_ERRATA_179_PRESENT
4483 #endif
4484
nrf54h_errata_179(void)4485 static bool nrf54h_errata_179(void)
4486 {
4487 #ifndef NRF54H_SERIES
4488 return false;
4489 #else
4490 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4491 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
4492 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
4493 #endif
4494 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4495 if (var1 == 0x16)
4496 {
4497 switch(var2)
4498 {
4499 case 0x02ul:
4500 return true;
4501 default:
4502 return true;
4503 }
4504 }
4505 #endif
4506 return false;
4507 #endif
4508 }
4509
4510 /* ========= Errata 182 ========= */
4511 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4512 #define NRF54H_ERRATA_182_PRESENT 1
4513 #else
4514 #define NRF54H_ERRATA_182_PRESENT 0
4515 #endif
4516
4517 #ifndef NRF54H_ERRATA_182_ENABLE_WORKAROUND
4518 #define NRF54H_ERRATA_182_ENABLE_WORKAROUND NRF54H_ERRATA_182_PRESENT
4519 #endif
4520
nrf54h_errata_182(void)4521 static bool nrf54h_errata_182(void)
4522 {
4523 #ifndef NRF54H_SERIES
4524 return false;
4525 #else
4526 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4527 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
4528 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
4529 #endif
4530 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4531 if (var1 == 0x16)
4532 {
4533 switch(var2)
4534 {
4535 case 0x02ul:
4536 return true;
4537 default:
4538 return true;
4539 }
4540 }
4541 #endif
4542 return false;
4543 #endif
4544 }
4545
4546 /* ========= Errata 183 ========= */
4547 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4548 #define NRF54H_ERRATA_183_PRESENT 1
4549 #else
4550 #define NRF54H_ERRATA_183_PRESENT 0
4551 #endif
4552
4553 #ifndef NRF54H_ERRATA_183_ENABLE_WORKAROUND
4554 #define NRF54H_ERRATA_183_ENABLE_WORKAROUND NRF54H_ERRATA_183_PRESENT
4555 #endif
4556
nrf54h_errata_183(void)4557 static bool nrf54h_errata_183(void)
4558 {
4559 #ifndef NRF54H_SERIES
4560 return false;
4561 #else
4562 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4563 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
4564 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
4565 #endif
4566 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4567 if (var1 == 0x16)
4568 {
4569 switch(var2)
4570 {
4571 case 0x02ul:
4572 return true;
4573 default:
4574 return true;
4575 }
4576 }
4577 #endif
4578 return false;
4579 #endif
4580 }
4581
4582 /* ========= Errata 184 ========= */
4583 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4584 #define NRF54H_ERRATA_184_PRESENT 1
4585 #else
4586 #define NRF54H_ERRATA_184_PRESENT 0
4587 #endif
4588
4589 #ifndef NRF54H_ERRATA_184_ENABLE_WORKAROUND
4590 #define NRF54H_ERRATA_184_ENABLE_WORKAROUND NRF54H_ERRATA_184_PRESENT
4591 #endif
4592
nrf54h_errata_184(void)4593 static bool nrf54h_errata_184(void)
4594 {
4595 #ifndef NRF54H_SERIES
4596 return false;
4597 #else
4598 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4599 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
4600 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
4601 #endif
4602 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4603 if (var1 == 0x16)
4604 {
4605 switch(var2)
4606 {
4607 case 0x02ul:
4608 return true;
4609 default:
4610 return true;
4611 }
4612 }
4613 #endif
4614 return false;
4615 #endif
4616 }
4617
4618 /* ========= Errata 185 ========= */
4619 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4620 #define NRF54H_ERRATA_185_PRESENT 1
4621 #else
4622 #define NRF54H_ERRATA_185_PRESENT 0
4623 #endif
4624
4625 #ifndef NRF54H_ERRATA_185_ENABLE_WORKAROUND
4626 #define NRF54H_ERRATA_185_ENABLE_WORKAROUND NRF54H_ERRATA_185_PRESENT
4627 #endif
4628
nrf54h_errata_185(void)4629 static bool nrf54h_errata_185(void)
4630 {
4631 #ifndef NRF54H_SERIES
4632 return false;
4633 #else
4634 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4635 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
4636 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
4637 #endif
4638 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4639 if (var1 == 0x16)
4640 {
4641 switch(var2)
4642 {
4643 case 0x02ul:
4644 return true;
4645 default:
4646 return true;
4647 }
4648 }
4649 #endif
4650 return false;
4651 #endif
4652 }
4653
4654 /* ========= Errata 186 ========= */
4655 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4656 #define NRF54H_ERRATA_186_PRESENT 1
4657 #else
4658 #define NRF54H_ERRATA_186_PRESENT 0
4659 #endif
4660
4661 #ifndef NRF54H_ERRATA_186_ENABLE_WORKAROUND
4662 #define NRF54H_ERRATA_186_ENABLE_WORKAROUND NRF54H_ERRATA_186_PRESENT
4663 #endif
4664
nrf54h_errata_186(void)4665 static bool nrf54h_errata_186(void)
4666 {
4667 #ifndef NRF54H_SERIES
4668 return false;
4669 #else
4670 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4671 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
4672 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
4673 #endif
4674 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4675 if (var1 == 0x16)
4676 {
4677 switch(var2)
4678 {
4679 case 0x02ul:
4680 return true;
4681 default:
4682 return true;
4683 }
4684 }
4685 #endif
4686 return false;
4687 #endif
4688 }
4689
4690 /* ========= Errata 187 ========= */
4691 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4692 #define NRF54H_ERRATA_187_PRESENT 1
4693 #else
4694 #define NRF54H_ERRATA_187_PRESENT 0
4695 #endif
4696
4697 #ifndef NRF54H_ERRATA_187_ENABLE_WORKAROUND
4698 #define NRF54H_ERRATA_187_ENABLE_WORKAROUND NRF54H_ERRATA_187_PRESENT
4699 #endif
4700
nrf54h_errata_187(void)4701 static bool nrf54h_errata_187(void)
4702 {
4703 #ifndef NRF54H_SERIES
4704 return false;
4705 #else
4706 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4707 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
4708 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
4709 #endif
4710 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4711 if (var1 == 0x16)
4712 {
4713 switch(var2)
4714 {
4715 case 0x02ul:
4716 return true;
4717 default:
4718 return true;
4719 }
4720 }
4721 #endif
4722 return false;
4723 #endif
4724 }
4725
4726 /* ========= Errata 188 ========= */
4727 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4728 #define NRF54H_ERRATA_188_PRESENT 1
4729 #else
4730 #define NRF54H_ERRATA_188_PRESENT 0
4731 #endif
4732
4733 #ifndef NRF54H_ERRATA_188_ENABLE_WORKAROUND
4734 #define NRF54H_ERRATA_188_ENABLE_WORKAROUND NRF54H_ERRATA_188_PRESENT
4735 #endif
4736
nrf54h_errata_188(void)4737 static bool nrf54h_errata_188(void)
4738 {
4739 #ifndef NRF54H_SERIES
4740 return false;
4741 #else
4742 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4743 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
4744 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
4745 #endif
4746 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4747 if (var1 == 0x16)
4748 {
4749 switch(var2)
4750 {
4751 case 0x02ul:
4752 return true;
4753 default:
4754 return true;
4755 }
4756 }
4757 #endif
4758 return false;
4759 #endif
4760 }
4761
4762 /* ========= Errata 189 ========= */
4763 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4764 #define NRF54H_ERRATA_189_PRESENT 1
4765 #else
4766 #define NRF54H_ERRATA_189_PRESENT 0
4767 #endif
4768
4769 #ifndef NRF54H_ERRATA_189_ENABLE_WORKAROUND
4770 #define NRF54H_ERRATA_189_ENABLE_WORKAROUND NRF54H_ERRATA_189_PRESENT
4771 #endif
4772
nrf54h_errata_189(void)4773 static bool nrf54h_errata_189(void)
4774 {
4775 #ifndef NRF54H_SERIES
4776 return false;
4777 #else
4778 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4779 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
4780 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
4781 #endif
4782 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4783 if (var1 == 0x16)
4784 {
4785 switch(var2)
4786 {
4787 case 0x02ul:
4788 return true;
4789 default:
4790 return true;
4791 }
4792 }
4793 #endif
4794 return false;
4795 #endif
4796 }
4797
4798 /* ========= Errata 190 ========= */
4799 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4800 #define NRF54H_ERRATA_190_PRESENT 1
4801 #else
4802 #define NRF54H_ERRATA_190_PRESENT 0
4803 #endif
4804
4805 #ifndef NRF54H_ERRATA_190_ENABLE_WORKAROUND
4806 #define NRF54H_ERRATA_190_ENABLE_WORKAROUND NRF54H_ERRATA_190_PRESENT
4807 #endif
4808
nrf54h_errata_190(void)4809 static bool nrf54h_errata_190(void)
4810 {
4811 #ifndef NRF54H_SERIES
4812 return false;
4813 #else
4814 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4815 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
4816 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
4817 #endif
4818 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4819 if (var1 == 0x16)
4820 {
4821 switch(var2)
4822 {
4823 case 0x02ul:
4824 return true;
4825 default:
4826 return true;
4827 }
4828 }
4829 #endif
4830 return false;
4831 #endif
4832 }
4833
4834 /* ========= Errata 191 ========= */
4835 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4836 #define NRF54H_ERRATA_191_PRESENT 1
4837 #else
4838 #define NRF54H_ERRATA_191_PRESENT 0
4839 #endif
4840
4841 #ifndef NRF54H_ERRATA_191_ENABLE_WORKAROUND
4842 #define NRF54H_ERRATA_191_ENABLE_WORKAROUND NRF54H_ERRATA_191_PRESENT
4843 #endif
4844
nrf54h_errata_191(void)4845 static bool nrf54h_errata_191(void)
4846 {
4847 #ifndef NRF54H_SERIES
4848 return false;
4849 #else
4850 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4851 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
4852 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
4853 #endif
4854 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4855 if (var1 == 0x16)
4856 {
4857 switch(var2)
4858 {
4859 case 0x02ul:
4860 return true;
4861 default:
4862 return true;
4863 }
4864 }
4865 #endif
4866 return false;
4867 #endif
4868 }
4869
4870 /* ========= Errata 192 ========= */
4871 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4872 #define NRF54H_ERRATA_192_PRESENT 1
4873 #else
4874 #define NRF54H_ERRATA_192_PRESENT 0
4875 #endif
4876
4877 #ifndef NRF54H_ERRATA_192_ENABLE_WORKAROUND
4878 #define NRF54H_ERRATA_192_ENABLE_WORKAROUND NRF54H_ERRATA_192_PRESENT
4879 #endif
4880
nrf54h_errata_192(void)4881 static bool nrf54h_errata_192(void)
4882 {
4883 #ifndef NRF54H_SERIES
4884 return false;
4885 #else
4886 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4887 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
4888 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
4889 #endif
4890 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4891 if (var1 == 0x16)
4892 {
4893 switch(var2)
4894 {
4895 case 0x02ul:
4896 return true;
4897 default:
4898 return true;
4899 }
4900 }
4901 #endif
4902 return false;
4903 #endif
4904 }
4905
4906 /* ========= Errata 193 ========= */
4907 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4908 #define NRF54H_ERRATA_193_PRESENT 1
4909 #else
4910 #define NRF54H_ERRATA_193_PRESENT 0
4911 #endif
4912
4913 #ifndef NRF54H_ERRATA_193_ENABLE_WORKAROUND
4914 #define NRF54H_ERRATA_193_ENABLE_WORKAROUND NRF54H_ERRATA_193_PRESENT
4915 #endif
4916
nrf54h_errata_193(void)4917 static bool nrf54h_errata_193(void)
4918 {
4919 #ifndef NRF54H_SERIES
4920 return false;
4921 #else
4922 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4923 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
4924 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
4925 #endif
4926 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4927 if (var1 == 0x16)
4928 {
4929 switch(var2)
4930 {
4931 case 0x02ul:
4932 return true;
4933 default:
4934 return true;
4935 }
4936 }
4937 #endif
4938 return false;
4939 #endif
4940 }
4941
4942 /* ========= Errata 194 ========= */
4943 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4944 #define NRF54H_ERRATA_194_PRESENT 1
4945 #else
4946 #define NRF54H_ERRATA_194_PRESENT 0
4947 #endif
4948
4949 #ifndef NRF54H_ERRATA_194_ENABLE_WORKAROUND
4950 #define NRF54H_ERRATA_194_ENABLE_WORKAROUND NRF54H_ERRATA_194_PRESENT
4951 #endif
4952
nrf54h_errata_194(void)4953 static bool nrf54h_errata_194(void)
4954 {
4955 #ifndef NRF54H_SERIES
4956 return false;
4957 #else
4958 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4959 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
4960 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
4961 #endif
4962 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4963 if (var1 == 0x16)
4964 {
4965 switch(var2)
4966 {
4967 case 0x02ul:
4968 return true;
4969 default:
4970 return true;
4971 }
4972 }
4973 #endif
4974 return false;
4975 #endif
4976 }
4977
4978 /* ========= Errata 195 ========= */
4979 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4980 #define NRF54H_ERRATA_195_PRESENT 1
4981 #else
4982 #define NRF54H_ERRATA_195_PRESENT 0
4983 #endif
4984
4985 #ifndef NRF54H_ERRATA_195_ENABLE_WORKAROUND
4986 #define NRF54H_ERRATA_195_ENABLE_WORKAROUND NRF54H_ERRATA_195_PRESENT
4987 #endif
4988
nrf54h_errata_195(void)4989 static bool nrf54h_errata_195(void)
4990 {
4991 #ifndef NRF54H_SERIES
4992 return false;
4993 #else
4994 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4995 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
4996 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
4997 #endif
4998 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
4999 if (var1 == 0x16)
5000 {
5001 switch(var2)
5002 {
5003 case 0x02ul:
5004 return true;
5005 default:
5006 return true;
5007 }
5008 }
5009 #endif
5010 return false;
5011 #endif
5012 }
5013
5014 /* ========= Errata 196 ========= */
5015 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5016 #define NRF54H_ERRATA_196_PRESENT 1
5017 #else
5018 #define NRF54H_ERRATA_196_PRESENT 0
5019 #endif
5020
5021 #ifndef NRF54H_ERRATA_196_ENABLE_WORKAROUND
5022 #define NRF54H_ERRATA_196_ENABLE_WORKAROUND NRF54H_ERRATA_196_PRESENT
5023 #endif
5024
nrf54h_errata_196(void)5025 static bool nrf54h_errata_196(void)
5026 {
5027 #ifndef NRF54H_SERIES
5028 return false;
5029 #else
5030 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5031 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
5032 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
5033 #endif
5034 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5035 if (var1 == 0x16)
5036 {
5037 switch(var2)
5038 {
5039 case 0x02ul:
5040 return true;
5041 default:
5042 return true;
5043 }
5044 }
5045 #endif
5046 return false;
5047 #endif
5048 }
5049
5050 /* ========= Errata 198 ========= */
5051 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5052 #define NRF54H_ERRATA_198_PRESENT 1
5053 #else
5054 #define NRF54H_ERRATA_198_PRESENT 0
5055 #endif
5056
5057 #ifndef NRF54H_ERRATA_198_ENABLE_WORKAROUND
5058 #define NRF54H_ERRATA_198_ENABLE_WORKAROUND NRF54H_ERRATA_198_PRESENT
5059 #endif
5060
nrf54h_errata_198(void)5061 static bool nrf54h_errata_198(void)
5062 {
5063 #ifndef NRF54H_SERIES
5064 return false;
5065 #else
5066 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5067 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
5068 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
5069 #endif
5070 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5071 if (var1 == 0x16)
5072 {
5073 switch(var2)
5074 {
5075 case 0x02ul:
5076 return true;
5077 default:
5078 return true;
5079 }
5080 }
5081 #endif
5082 return false;
5083 #endif
5084 }
5085
5086 /* ========= Errata 200 ========= */
5087 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5088 #define NRF54H_ERRATA_200_PRESENT 1
5089 #else
5090 #define NRF54H_ERRATA_200_PRESENT 0
5091 #endif
5092
5093 #ifndef NRF54H_ERRATA_200_ENABLE_WORKAROUND
5094 #define NRF54H_ERRATA_200_ENABLE_WORKAROUND NRF54H_ERRATA_200_PRESENT
5095 #endif
5096
nrf54h_errata_200(void)5097 static bool nrf54h_errata_200(void)
5098 {
5099 #ifndef NRF54H_SERIES
5100 return false;
5101 #else
5102 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5103 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
5104 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
5105 #endif
5106 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5107 if (var1 == 0x16)
5108 {
5109 switch(var2)
5110 {
5111 case 0x02ul:
5112 return true;
5113 default:
5114 return true;
5115 }
5116 }
5117 #endif
5118 return false;
5119 #endif
5120 }
5121
5122 /* ========= Errata 201 ========= */
5123 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5124 #define NRF54H_ERRATA_201_PRESENT 1
5125 #else
5126 #define NRF54H_ERRATA_201_PRESENT 0
5127 #endif
5128
5129 #ifndef NRF54H_ERRATA_201_ENABLE_WORKAROUND
5130 #define NRF54H_ERRATA_201_ENABLE_WORKAROUND NRF54H_ERRATA_201_PRESENT
5131 #endif
5132
nrf54h_errata_201(void)5133 static bool nrf54h_errata_201(void)
5134 {
5135 #ifndef NRF54H_SERIES
5136 return false;
5137 #else
5138 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5139 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
5140 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
5141 #endif
5142 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5143 if (var1 == 0x16)
5144 {
5145 switch(var2)
5146 {
5147 case 0x02ul:
5148 return true;
5149 default:
5150 return true;
5151 }
5152 }
5153 #endif
5154 return false;
5155 #endif
5156 }
5157
5158 /* ========= Errata 202 ========= */
5159 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5160 #define NRF54H_ERRATA_202_PRESENT 1
5161 #else
5162 #define NRF54H_ERRATA_202_PRESENT 0
5163 #endif
5164
5165 #ifndef NRF54H_ERRATA_202_ENABLE_WORKAROUND
5166 #define NRF54H_ERRATA_202_ENABLE_WORKAROUND NRF54H_ERRATA_202_PRESENT
5167 #endif
5168
nrf54h_errata_202(void)5169 static bool nrf54h_errata_202(void)
5170 {
5171 #ifndef NRF54H_SERIES
5172 return false;
5173 #else
5174 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5175 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
5176 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
5177 #endif
5178 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5179 if (var1 == 0x16)
5180 {
5181 switch(var2)
5182 {
5183 case 0x02ul:
5184 return true;
5185 default:
5186 return true;
5187 }
5188 }
5189 #endif
5190 return false;
5191 #endif
5192 }
5193
5194 /* ========= Errata 205 ========= */
5195 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5196 #define NRF54H_ERRATA_205_PRESENT 1
5197 #else
5198 #define NRF54H_ERRATA_205_PRESENT 0
5199 #endif
5200
5201 #ifndef NRF54H_ERRATA_205_ENABLE_WORKAROUND
5202 #define NRF54H_ERRATA_205_ENABLE_WORKAROUND NRF54H_ERRATA_205_PRESENT
5203 #endif
5204
nrf54h_errata_205(void)5205 static bool nrf54h_errata_205(void)
5206 {
5207 #ifndef NRF54H_SERIES
5208 return false;
5209 #else
5210 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5211 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
5212 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
5213 #endif
5214 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5215 if (var1 == 0x16)
5216 {
5217 switch(var2)
5218 {
5219 case 0x02ul:
5220 return true;
5221 default:
5222 return true;
5223 }
5224 }
5225 #endif
5226 return false;
5227 #endif
5228 }
5229
5230 /* ========= Errata 206 ========= */
5231 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5232 #define NRF54H_ERRATA_206_PRESENT 1
5233 #else
5234 #define NRF54H_ERRATA_206_PRESENT 0
5235 #endif
5236
5237 #ifndef NRF54H_ERRATA_206_ENABLE_WORKAROUND
5238 #define NRF54H_ERRATA_206_ENABLE_WORKAROUND NRF54H_ERRATA_206_PRESENT
5239 #endif
5240
nrf54h_errata_206(void)5241 static bool nrf54h_errata_206(void)
5242 {
5243 #ifndef NRF54H_SERIES
5244 return false;
5245 #else
5246 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5247 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
5248 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
5249 #endif
5250 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5251 if (var1 == 0x16)
5252 {
5253 switch(var2)
5254 {
5255 case 0x02ul:
5256 return true;
5257 default:
5258 return true;
5259 }
5260 }
5261 #endif
5262 return false;
5263 #endif
5264 }
5265
5266 /* ========= Errata 207 ========= */
5267 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5268 #define NRF54H_ERRATA_207_PRESENT 1
5269 #else
5270 #define NRF54H_ERRATA_207_PRESENT 0
5271 #endif
5272
5273 #ifndef NRF54H_ERRATA_207_ENABLE_WORKAROUND
5274 #define NRF54H_ERRATA_207_ENABLE_WORKAROUND NRF54H_ERRATA_207_PRESENT
5275 #endif
5276
nrf54h_errata_207(void)5277 static bool nrf54h_errata_207(void)
5278 {
5279 #ifndef NRF54H_SERIES
5280 return false;
5281 #else
5282 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5283 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
5284 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
5285 #endif
5286 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5287 if (var1 == 0x16)
5288 {
5289 switch(var2)
5290 {
5291 case 0x02ul:
5292 return true;
5293 default:
5294 return true;
5295 }
5296 }
5297 #endif
5298 return false;
5299 #endif
5300 }
5301
5302 /* ========= Errata 208 ========= */
5303 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5304 #define NRF54H_ERRATA_208_PRESENT 1
5305 #else
5306 #define NRF54H_ERRATA_208_PRESENT 0
5307 #endif
5308
5309 #ifndef NRF54H_ERRATA_208_ENABLE_WORKAROUND
5310 #define NRF54H_ERRATA_208_ENABLE_WORKAROUND NRF54H_ERRATA_208_PRESENT
5311 #endif
5312
nrf54h_errata_208(void)5313 static bool nrf54h_errata_208(void)
5314 {
5315 #ifndef NRF54H_SERIES
5316 return false;
5317 #else
5318 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5319 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
5320 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
5321 #endif
5322 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5323 if (var1 == 0x16)
5324 {
5325 switch(var2)
5326 {
5327 case 0x02ul:
5328 return true;
5329 default:
5330 return true;
5331 }
5332 }
5333 #endif
5334 return false;
5335 #endif
5336 }
5337
5338 /* ========= Errata 209 ========= */
5339 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5340 #define NRF54H_ERRATA_209_PRESENT 1
5341 #else
5342 #define NRF54H_ERRATA_209_PRESENT 0
5343 #endif
5344
5345 #ifndef NRF54H_ERRATA_209_ENABLE_WORKAROUND
5346 #define NRF54H_ERRATA_209_ENABLE_WORKAROUND NRF54H_ERRATA_209_PRESENT
5347 #endif
5348
nrf54h_errata_209(void)5349 static bool nrf54h_errata_209(void)
5350 {
5351 #ifndef NRF54H_SERIES
5352 return false;
5353 #else
5354 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5355 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
5356 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
5357 #endif
5358 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5359 if (var1 == 0x16)
5360 {
5361 switch(var2)
5362 {
5363 case 0x02ul:
5364 return true;
5365 default:
5366 return true;
5367 }
5368 }
5369 #endif
5370 return false;
5371 #endif
5372 }
5373
5374 /* ========= Errata 210 ========= */
5375 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5376 #define NRF54H_ERRATA_210_PRESENT 1
5377 #else
5378 #define NRF54H_ERRATA_210_PRESENT 0
5379 #endif
5380
5381 #ifndef NRF54H_ERRATA_210_ENABLE_WORKAROUND
5382 #define NRF54H_ERRATA_210_ENABLE_WORKAROUND NRF54H_ERRATA_210_PRESENT
5383 #endif
5384
nrf54h_errata_210(void)5385 static bool nrf54h_errata_210(void)
5386 {
5387 #ifndef NRF54H_SERIES
5388 return false;
5389 #else
5390 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5391 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
5392 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
5393 #endif
5394 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5395 if (var1 == 0x16)
5396 {
5397 switch(var2)
5398 {
5399 case 0x02ul:
5400 return true;
5401 default:
5402 return true;
5403 }
5404 }
5405 #endif
5406 return false;
5407 #endif
5408 }
5409
5410 /* ========= Errata 211 ========= */
5411 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5412 #define NRF54H_ERRATA_211_PRESENT 1
5413 #else
5414 #define NRF54H_ERRATA_211_PRESENT 0
5415 #endif
5416
5417 #ifndef NRF54H_ERRATA_211_ENABLE_WORKAROUND
5418 #define NRF54H_ERRATA_211_ENABLE_WORKAROUND NRF54H_ERRATA_211_PRESENT
5419 #endif
5420
nrf54h_errata_211(void)5421 static bool nrf54h_errata_211(void)
5422 {
5423 #ifndef NRF54H_SERIES
5424 return false;
5425 #else
5426 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5427 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
5428 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
5429 #endif
5430 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5431 if (var1 == 0x16)
5432 {
5433 switch(var2)
5434 {
5435 case 0x02ul:
5436 return true;
5437 default:
5438 return true;
5439 }
5440 }
5441 #endif
5442 return false;
5443 #endif
5444 }
5445
5446 /* ========= Errata 212 ========= */
5447 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5448 #define NRF54H_ERRATA_212_PRESENT 1
5449 #else
5450 #define NRF54H_ERRATA_212_PRESENT 0
5451 #endif
5452
5453 #ifndef NRF54H_ERRATA_212_ENABLE_WORKAROUND
5454 #define NRF54H_ERRATA_212_ENABLE_WORKAROUND NRF54H_ERRATA_212_PRESENT
5455 #endif
5456
nrf54h_errata_212(void)5457 static bool nrf54h_errata_212(void)
5458 {
5459 #ifndef NRF54H_SERIES
5460 return false;
5461 #else
5462 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5463 uint32_t var1 = *(uint32_t *)0x0FFFE000ul;
5464 uint32_t var2 = *(uint32_t *)0x0FFFE004ul;
5465 #endif
5466 #if defined (NRF54H20_XXAA) || defined (DEVELOP_IN_NRF54H20)
5467 if (var1 == 0x16)
5468 {
5469 switch(var2)
5470 {
5471 case 0x02ul:
5472 return true;
5473 default:
5474 return true;
5475 }
5476 }
5477 #endif
5478 return false;
5479 #endif
5480 }
5481
5482 #endif /* NRF54H_ERRATAS_H */
5483
