1 //
2 // Copyright (c) 2010-2025 Antmicro
3 // Copyright (c) 2022-2025 Silicon Labs
4 //
5 // This file is licensed under the MIT License.
6 // Full license text is available in 'licenses/MIT.txt'.
7 //
8 
9 /*  WARNING: Auto-Generated Peripheral  -  DO NOT EDIT
10     TIMER, Generated on : 2024-07-31 13:49:55.938358
11     TIMER, ID Version : 60defe53b8f54da2ae4c36177458d623.1 */
12 
13 /* Here is the template for your defined by hand class. Don't forget to add your eventual constructor with extra parameter.
14 
15 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
16 using System;
17 using System.IO;
18 using System.Collections.Generic;
19 using Antmicro.Renode.Core;
20 using Antmicro.Renode.Core.Structure.Registers;
21 using Antmicro.Renode.Logging;
22 using Antmicro.Renode.Exceptions;
23 using Antmicro.Renode.Peripherals.CPU;
24 using Antmicro.Renode.Peripherals.Bus;
25 
26 namespace Antmicro.Renode.Peripherals.Timers
27 {
28     public partial class EFR32xG2_TIMER_1
29     {
30         public EFR32xG2_TIMER_1(Machine machine) : base(machine)
31         {
32             EFR32xG2_TIMER_1_constructor();
33         }
34     }
35 }
36 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
37 
38 using System;
39 using System.IO;
40 using System.Collections.Generic;
41 using Antmicro.Renode.Core;
42 using Antmicro.Renode.Core.Structure.Registers;
43 using Antmicro.Renode.Logging;
44 using Antmicro.Renode.Exceptions;
45 using Antmicro.Renode.Peripherals.Bus;
46 using Antmicro.Renode.Peripherals.Miscellaneous.SiLabs;
47 
48 namespace Antmicro.Renode.Peripherals.Timers
49 {
50     public partial class EFR32xG2_TIMER_1 : BasicDoubleWordPeripheral, IKnownSize
51     {
EFR32xG2_TIMER_1(Machine machine)52         public EFR32xG2_TIMER_1(Machine machine) : base(machine)
53         {
54             Define_Registers();
55             EFR32xG2_TIMER_1_Constructor();
56         }
57 
Define_Registers()58         private void Define_Registers()
59         {
60             var registersMap = new Dictionary<long, DoubleWordRegister>
61             {
62                 {(long)Registers.Ipversion, GenerateIpversionRegister()},
63                 {(long)Registers.Cfg, GenerateCfgRegister()},
64                 {(long)Registers.Ctrl, GenerateCtrlRegister()},
65                 {(long)Registers.Cmd, GenerateCmdRegister()},
66                 {(long)Registers.Status, GenerateStatusRegister()},
67                 {(long)Registers.If, GenerateIfRegister()},
68                 {(long)Registers.Ien, GenerateIenRegister()},
69                 {(long)Registers.Top, GenerateTopRegister()},
70                 {(long)Registers.Topb, GenerateTopbRegister()},
71                 {(long)Registers.Cnt, GenerateCntRegister()},
72                 {(long)Registers.Lock, GenerateLockRegister()},
73                 {(long)Registers.En, GenerateEnRegister()},
74                 {(long)Registers.Cc0_Cfg, GenerateCc0_cfgRegister()},
75                 {(long)Registers.Cc0_Ctrl, GenerateCc0_ctrlRegister()},
76                 {(long)Registers.Cc0_Oc, GenerateCc0_ocRegister()},
77                 {(long)Registers.Cc0_Ocb, GenerateCc0_ocbRegister()},
78                 {(long)Registers.Cc0_Icf, GenerateCc0_icfRegister()},
79                 {(long)Registers.Cc0_Icof, GenerateCc0_icofRegister()},
80                 {(long)Registers.Cc1_Cfg, GenerateCc1_cfgRegister()},
81                 {(long)Registers.Cc1_Ctrl, GenerateCc1_ctrlRegister()},
82                 {(long)Registers.Cc1_Oc, GenerateCc1_ocRegister()},
83                 {(long)Registers.Cc1_Ocb, GenerateCc1_ocbRegister()},
84                 {(long)Registers.Cc1_Icf, GenerateCc1_icfRegister()},
85                 {(long)Registers.Cc1_Icof, GenerateCc1_icofRegister()},
86                 {(long)Registers.Cc2_Cfg, GenerateCc2_cfgRegister()},
87                 {(long)Registers.Cc2_Ctrl, GenerateCc2_ctrlRegister()},
88                 {(long)Registers.Cc2_Oc, GenerateCc2_ocRegister()},
89                 {(long)Registers.Cc2_Ocb, GenerateCc2_ocbRegister()},
90                 {(long)Registers.Cc2_Icf, GenerateCc2_icfRegister()},
91                 {(long)Registers.Cc2_Icof, GenerateCc2_icofRegister()},
92                 {(long)Registers.DtCfg, GenerateDtcfgRegister()},
93                 {(long)Registers.DtTimecfg, GenerateDttimecfgRegister()},
94                 {(long)Registers.DtFcfg, GenerateDtfcfgRegister()},
95                 {(long)Registers.DtCtrl, GenerateDtctrlRegister()},
96                 {(long)Registers.DtOgen, GenerateDtogenRegister()},
97                 {(long)Registers.DtFault, GenerateDtfaultRegister()},
98                 {(long)Registers.DtFaultc, GenerateDtfaultcRegister()},
99                 {(long)Registers.DtLock, GenerateDtlockRegister()},
100             };
101             registers = new DoubleWordRegisterCollection(this, registersMap);
102         }
103 
Reset()104         public override void Reset()
105         {
106             base.Reset();
107             TIMER_Reset();
108         }
109 
110         protected enum CFG_MODE
111         {
112             UP = 0, // Up-count mode
113             DOWN = 1, // Down-count mode
114             UPDOWN = 2, // Up/down-count mode
115             QDEC = 3, // Quadrature decoder mode
116         }
117 
118         protected enum CFG_SYNC
119         {
120             DISABLE = 0, // Timer operation is unaffected by other timers.
121             ENABLE = 1, // Timer may be started, stopped and re-loaded from other timer instances.
122         }
123 
124         protected enum CFG_QDM
125         {
126             X2 = 0, // X2 mode selected
127             X4 = 1, // X4 mode selected
128         }
129 
130         protected enum CFG_DEBUGRUN
131         {
132             HALT = 0, // Timer is halted in debug mode
133             RUN = 1, // Timer is running in debug mode
134         }
135 
136         protected enum CFG_CLKSEL
137         {
138             PRESCEM01GRPACLK = 0, // Prescaled EM01GRPACLK
139             CC1 = 1, // Compare/Capture Channel 1 Input
140             TIMEROUF = 2, // Timer is clocked by underflow(down-count) or overflow(up-count) in the lower numbered neighbor Timer
141         }
142 
143         protected enum CFG_RETIMEEN
144         {
145             DISABLE = 0, // PWM outputs are not re-timed.
146             ENABLE = 1, // PWM outputs are re-timed.
147         }
148 
149         protected enum CFG_DISSYNCOUT
150         {
151             EN = 0, // Timer can start/stop/reload other timers with SYNC bit set
152             DIS = 1, // Timer cannot start/stop/reload other timers with SYNC bit set
153         }
154 
155         protected enum CFG_PRESC
156         {
157             DIV1 = 0, // No prescaling
158             DIV2 = 1, // Prescale by 2
159             DIV4 = 3, // Prescale by 4
160             DIV8 = 7, // Prescale by 8
161             DIV16 = 15, // Prescale by 16
162             DIV32 = 31, // Prescale by 32
163             DIV64 = 63, // Prescale by 64
164             DIV128 = 127, // Prescale by 128
165             DIV256 = 255, // Prescale by 256
166             DIV512 = 511, // Prescale by 512
167             DIV1024 = 1023, // Prescale by 1024
168         }
169 
170         protected enum CTRL_RISEA
171         {
172             NONE = 0, // No action
173             START = 1, // Start counter without reload
174             STOP = 2, // Stop counter without reload
175             RELOADSTART = 3, // Reload and start counter
176         }
177 
178         protected enum CTRL_FALLA
179         {
180             NONE = 0, // No action
181             START = 1, // Start counter without reload
182             STOP = 2, // Stop counter without reload
183             RELOADSTART = 3, // Reload and start counter
184         }
185 
186         protected enum STATUS_DIR
187         {
188             UP = 0, // Counting up
189             DOWN = 1, // Counting down
190         }
191 
192         protected enum STATUS_TIMERLOCKSTATUS
193         {
194             UNLOCKED = 0, // TIMER registers are unlocked
195             LOCKED = 1, // TIMER registers are locked
196         }
197 
198         protected enum STATUS_DTILOCKSTATUS
199         {
200             UNLOCKED = 0, // DTI registers are unlocked
201             LOCKED = 1, // DTI registers are locked
202         }
203 
204         protected enum STATUS_CCPOL0
205         {
206             LOWRISE = 0, // CCx polarity low level/rising edge
207             HIGHFALL = 1, // CCx polarity high level/falling edge
208         }
209 
210         protected enum STATUS_CCPOL1
211         {
212             LOWRISE = 0, // CCx polarity low level/rising edge
213             HIGHFALL = 1, // CCx polarity high level/falling edge
214         }
215 
216         protected enum STATUS_CCPOL2
217         {
218             LOWRISE = 0, // CCx polarity low level/rising edge
219             HIGHFALL = 1, // CCx polarity high level/falling edge
220         }
221 
222         protected enum CC_CFG_MODE
223         {
224             OFF = 0, // Compare/Capture channel turned off
225             INPUTCAPTURE = 1, // Input Capture
226             OUTPUTCOMPARE = 2, // Output Compare
227             PWM = 3, // Pulse-Width Modulation
228         }
229 
230         protected enum CC_CFG_INSEL
231         {
232             PIN = 0, // TIMERnCCx pin is selected
233             PRSSYNC = 1, // Synchornous PRS selected
234             PRSASYNCLEVEL = 2, // Asynchronous Level PRS selected
235             PRSASYNCPULSE = 3, // Asynchronous Pulse PRS selected
236         }
237 
238         protected enum CC_CFG_PRSCONF
239         {
240             PULSE = 0, // Each CC event will generate a one EM01GRPACLK cycle high pulse
241             LEVEL = 1, // The PRS channel will follow CC out
242         }
243 
244         protected enum CC_CFG_FILT
245         {
246             DISABLE = 0, // Digital Filter Disabled
247             ENABLE = 1, // Digital Filter Enabled
248         }
249 
250         protected enum CC_CTRL_CMOA
251         {
252             NONE = 0, // No action on compare match
253             TOGGLE = 1, // Toggle output on compare match
254             CLEAR = 2, // Clear output on compare match
255             SET = 3, // Set output on compare match
256         }
257 
258         protected enum CC_CTRL_COFOA
259         {
260             NONE = 0, // No action on counter overflow
261             TOGGLE = 1, // Toggle output on counter overflow
262             CLEAR = 2, // Clear output on counter overflow
263             SET = 3, // Set output on counter overflow
264         }
265 
266         protected enum CC_CTRL_CUFOA
267         {
268             NONE = 0, // No action on counter underflow
269             TOGGLE = 1, // Toggle output on counter underflow
270             CLEAR = 2, // Clear output on counter underflow
271             SET = 3, // Set output on counter underflow
272         }
273 
274         protected enum CC_CTRL_ICEDGE
275         {
276             RISING = 0, // Rising edges detected
277             FALLING = 1, // Falling edges detected
278             BOTH = 2, // Both edges detected
279             NONE = 3, // No edge detection, signal is left as it is
280         }
281 
282         protected enum CC_CTRL_ICEVCTRL
283         {
284             EVERYEDGE = 0, // PRS output pulse and interrupt flag set on every capture
285             EVERYSECONDEDGE = 1, // PRS output pulse and interrupt flag set on every second capture
286             RISING = 2, // PRS output pulse and interrupt flag set on rising edge only (if ICEDGE = BOTH)
287             FALLING = 3, // PRS output pulse and interrupt flag set on falling edge only (if ICEDGE = BOTH)
288         }
289 
290         protected enum DTCFG_DTDAS
291         {
292             NORESTART = 0, // No DTI restart on debugger exit
293             RESTART = 1, // DTI restart on debugger exit
294         }
295 
296         protected enum DTFCFG_DTFA
297         {
298             NONE = 0, // No action on fault
299             INACTIVE = 1, // Set outputs inactive
300             CLEAR = 2, // Clear outputs
301             TRISTATE = 3, // Tristate outputs
302         }
303 
304         protected enum DTLOCK_DTILOCKKEY
305         {
306             UNLOCK = 52864, // Write to unlock TIMER DTI registers
307         }
308 
309         // Ipversion - Offset : 0x0
GenerateIpversionRegister()310         protected DoubleWordRegister  GenerateIpversionRegister() => new DoubleWordRegister(this, 0x1)
311 
312             .WithValueField(0, 32, out ipversion_ipversion_field, FieldMode.Read,
313                     valueProviderCallback: (_) => {
314                         Ipversion_Ipversion_ValueProvider(_);
315                         return ipversion_ipversion_field.Value;
316                     },
317 
318                     readCallback: (_, __) => Ipversion_Ipversion_Read(_, __),
319                     name: "Ipversion")
320             .WithReadCallback((_, __) => Ipversion_Read(_, __))
321             .WithWriteCallback((_, __) => Ipversion_Write(_, __));
322 
323         // Cfg - Offset : 0x4
GenerateCfgRegister()324         protected DoubleWordRegister  GenerateCfgRegister() => new DoubleWordRegister(this, 0x0)
325             .WithEnumField<DoubleWordRegister, CFG_MODE>(0, 2, out cfg_mode_field,
326                     valueProviderCallback: (_) => {
327                         Cfg_Mode_ValueProvider(_);
328                         return cfg_mode_field.Value;
329                     },
330                     writeCallback: (_, __) => {
331                         WriteWSTATIC();
332                         Cfg_Mode_Write(_, __);
333                     },
334 
335                     readCallback: (_, __) => Cfg_Mode_Read(_, __),
336                     name: "Mode")
337             .WithReservedBits(2, 1)
338             .WithEnumField<DoubleWordRegister, CFG_SYNC>(3, 1, out cfg_sync_bit,
339                     valueProviderCallback: (_) => {
340                         Cfg_Sync_ValueProvider(_);
341                         return cfg_sync_bit.Value;
342                     },
343                     writeCallback: (_, __) => {
344                         WriteWSTATIC();
345                         Cfg_Sync_Write(_, __);
346                     },
347 
348                     readCallback: (_, __) => Cfg_Sync_Read(_, __),
349                     name: "Sync")
350             .WithFlag(4, out cfg_osmen_bit,
351                     valueProviderCallback: (_) => {
352                         Cfg_Osmen_ValueProvider(_);
353                         return cfg_osmen_bit.Value;
354                     },
355                     writeCallback: (_, __) => {
356                         WriteWSTATIC();
357                         Cfg_Osmen_Write(_, __);
358                     },
359 
360                     readCallback: (_, __) => Cfg_Osmen_Read(_, __),
361                     name: "Osmen")
362             .WithEnumField<DoubleWordRegister, CFG_QDM>(5, 1, out cfg_qdm_bit,
363                     valueProviderCallback: (_) => {
364                         Cfg_Qdm_ValueProvider(_);
365                         return cfg_qdm_bit.Value;
366                     },
367                     writeCallback: (_, __) => {
368                         WriteWSTATIC();
369                         Cfg_Qdm_Write(_, __);
370                     },
371 
372                     readCallback: (_, __) => Cfg_Qdm_Read(_, __),
373                     name: "Qdm")
374             .WithEnumField<DoubleWordRegister, CFG_DEBUGRUN>(6, 1, out cfg_debugrun_bit,
375                     valueProviderCallback: (_) => {
376                         Cfg_Debugrun_ValueProvider(_);
377                         return cfg_debugrun_bit.Value;
378                     },
379                     writeCallback: (_, __) => {
380                         WriteWSTATIC();
381                         Cfg_Debugrun_Write(_, __);
382                     },
383 
384                     readCallback: (_, __) => Cfg_Debugrun_Read(_, __),
385                     name: "Debugrun")
386             .WithFlag(7, out cfg_dmaclract_bit,
387                     valueProviderCallback: (_) => {
388                         Cfg_Dmaclract_ValueProvider(_);
389                         return cfg_dmaclract_bit.Value;
390                     },
391                     writeCallback: (_, __) => {
392                         WriteWSTATIC();
393                         Cfg_Dmaclract_Write(_, __);
394                     },
395 
396                     readCallback: (_, __) => Cfg_Dmaclract_Read(_, __),
397                     name: "Dmaclract")
398             .WithEnumField<DoubleWordRegister, CFG_CLKSEL>(8, 2, out cfg_clksel_field,
399                     valueProviderCallback: (_) => {
400                         Cfg_Clksel_ValueProvider(_);
401                         return cfg_clksel_field.Value;
402                     },
403                     writeCallback: (_, __) => {
404                         WriteWSTATIC();
405                         Cfg_Clksel_Write(_, __);
406                     },
407 
408                     readCallback: (_, __) => Cfg_Clksel_Read(_, __),
409                     name: "Clksel")
410             .WithEnumField<DoubleWordRegister, CFG_RETIMEEN>(10, 1, out cfg_retimeen_bit,
411                     valueProviderCallback: (_) => {
412                         Cfg_Retimeen_ValueProvider(_);
413                         return cfg_retimeen_bit.Value;
414                     },
415                     writeCallback: (_, __) => {
416                         WriteWSTATIC();
417                         Cfg_Retimeen_Write(_, __);
418                     },
419 
420                     readCallback: (_, __) => Cfg_Retimeen_Read(_, __),
421                     name: "Retimeen")
422             .WithEnumField<DoubleWordRegister, CFG_DISSYNCOUT>(11, 1, out cfg_dissyncout_bit,
423                     valueProviderCallback: (_) => {
424                         Cfg_Dissyncout_ValueProvider(_);
425                         return cfg_dissyncout_bit.Value;
426                     },
427                     writeCallback: (_, __) => {
428                         WriteWSTATIC();
429                         Cfg_Dissyncout_Write(_, __);
430                     },
431 
432                     readCallback: (_, __) => Cfg_Dissyncout_Read(_, __),
433                     name: "Dissyncout")
434             .WithFlag(12, out cfg_retimesel_bit,
435                     valueProviderCallback: (_) => {
436                         Cfg_Retimesel_ValueProvider(_);
437                         return cfg_retimesel_bit.Value;
438                     },
439                     writeCallback: (_, __) => {
440                         WriteWSTATIC();
441                         Cfg_Retimesel_Write(_, __);
442                     },
443 
444                     readCallback: (_, __) => Cfg_Retimesel_Read(_, __),
445                     name: "Retimesel")
446             .WithReservedBits(13, 3)
447             .WithFlag(16, out cfg_ati_bit,
448                     valueProviderCallback: (_) => {
449                         Cfg_Ati_ValueProvider(_);
450                         return cfg_ati_bit.Value;
451                     },
452                     writeCallback: (_, __) => {
453                         WriteWSTATIC();
454                         Cfg_Ati_Write(_, __);
455                     },
456 
457                     readCallback: (_, __) => Cfg_Ati_Read(_, __),
458                     name: "Ati")
459             .WithFlag(17, out cfg_rsscoist_bit,
460                     valueProviderCallback: (_) => {
461                         Cfg_Rsscoist_ValueProvider(_);
462                         return cfg_rsscoist_bit.Value;
463                     },
464                     writeCallback: (_, __) => {
465                         WriteWSTATIC();
466                         Cfg_Rsscoist_Write(_, __);
467                     },
468 
469                     readCallback: (_, __) => Cfg_Rsscoist_Read(_, __),
470                     name: "Rsscoist")
471             .WithEnumField<DoubleWordRegister, CFG_PRESC>(18, 10, out cfg_presc_field,
472                     valueProviderCallback: (_) => {
473                         Cfg_Presc_ValueProvider(_);
474                         return cfg_presc_field.Value;
475                     },
476                     writeCallback: (_, __) => {
477                         WriteWSTATIC();
478                         Cfg_Presc_Write(_, __);
479                     },
480 
481                     readCallback: (_, __) => Cfg_Presc_Read(_, __),
482                     name: "Presc")
483             .WithReservedBits(28, 4)
484             .WithReadCallback((_, __) => Cfg_Read(_, __))
485             .WithWriteCallback((_, __) => Cfg_Write_WithHook(_, __));
486 
487         // Ctrl - Offset : 0x8
GenerateCtrlRegister()488         protected DoubleWordRegister  GenerateCtrlRegister() => new DoubleWordRegister(this, 0x0)
489             .WithEnumField<DoubleWordRegister, CTRL_RISEA>(0, 2, out ctrl_risea_field,
490                     valueProviderCallback: (_) => {
491                         Ctrl_Risea_ValueProvider(_);
492                         return ctrl_risea_field.Value;
493                     },
494                     writeCallback: (_, __) => {
495                         WriteWSYNC();
496                         Ctrl_Risea_Write(_, __);
497                     },
498 
499                     readCallback: (_, __) => Ctrl_Risea_Read(_, __),
500                     name: "Risea")
501             .WithEnumField<DoubleWordRegister, CTRL_FALLA>(2, 2, out ctrl_falla_field,
502                     valueProviderCallback: (_) => {
503                         Ctrl_Falla_ValueProvider(_);
504                         return ctrl_falla_field.Value;
505                     },
506                     writeCallback: (_, __) => {
507                         WriteWSYNC();
508                         Ctrl_Falla_Write(_, __);
509                     },
510 
511                     readCallback: (_, __) => Ctrl_Falla_Read(_, __),
512                     name: "Falla")
513             .WithFlag(4, out ctrl_x2cnt_bit,
514                     valueProviderCallback: (_) => {
515                         Ctrl_X2cnt_ValueProvider(_);
516                         return ctrl_x2cnt_bit.Value;
517                     },
518                     writeCallback: (_, __) => {
519                         WriteWSYNC();
520                         Ctrl_X2cnt_Write(_, __);
521                     },
522 
523                     readCallback: (_, __) => Ctrl_X2cnt_Read(_, __),
524                     name: "X2cnt")
525             .WithReservedBits(5, 27)
526             .WithReadCallback((_, __) => Ctrl_Read(_, __))
527             .WithWriteCallback((_, __) => Ctrl_Write_WithHook(_, __));
528 
529         // Cmd - Offset : 0xC
GenerateCmdRegister()530         protected DoubleWordRegister  GenerateCmdRegister() => new DoubleWordRegister(this, 0x0)
531             .WithFlag(0, out cmd_start_bit, FieldMode.Write,
532                     writeCallback: (_, __) => {
533                         WriteWSYNC();
534                         Cmd_Start_Write(_, __);
535                     },
536                     name: "Start")
537             .WithFlag(1, out cmd_stop_bit, FieldMode.Write,
538                     writeCallback: (_, __) => {
539                         WriteWSYNC();
540                         Cmd_Stop_Write(_, __);
541                     },
542                     name: "Stop")
543             .WithReservedBits(2, 30)
544             .WithReadCallback((_, __) => Cmd_Read(_, __))
545             .WithWriteCallback((_, __) => Cmd_Write_WithHook(_, __));
546 
547         // Status - Offset : 0x10
GenerateStatusRegister()548         protected DoubleWordRegister  GenerateStatusRegister() => new DoubleWordRegister(this, 0x0)
549             .WithFlag(0, out status_running_bit, FieldMode.Read,
550                     valueProviderCallback: (_) => {
551                         Status_Running_ValueProvider(_);
552                         return status_running_bit.Value;
553                     },
554 
555                     readCallback: (_, __) => Status_Running_Read(_, __),
556                     name: "Running")
557             .WithEnumField<DoubleWordRegister, STATUS_DIR>(1, 1, out status_dir_bit, FieldMode.Read,
558                     valueProviderCallback: (_) => {
559                         Status_Dir_ValueProvider(_);
560                         return status_dir_bit.Value;
561                     },
562 
563                     readCallback: (_, __) => Status_Dir_Read(_, __),
564                     name: "Dir")
565             .WithFlag(2, out status_topbv_bit, FieldMode.Read,
566                     valueProviderCallback: (_) => {
567                         Status_Topbv_ValueProvider(_);
568                         return status_topbv_bit.Value;
569                     },
570 
571                     readCallback: (_, __) => Status_Topbv_Read(_, __),
572                     name: "Topbv")
573             .WithReservedBits(3, 1)
574             .WithEnumField<DoubleWordRegister, STATUS_TIMERLOCKSTATUS>(4, 1, out status_timerlockstatus_bit, FieldMode.Read,
575                     valueProviderCallback: (_) => {
576                         Status_Timerlockstatus_ValueProvider(_);
577                         return status_timerlockstatus_bit.Value;
578                     },
579 
580                     readCallback: (_, __) => Status_Timerlockstatus_Read(_, __),
581                     name: "Timerlockstatus")
582             .WithEnumField<DoubleWordRegister, STATUS_DTILOCKSTATUS>(5, 1, out status_dtilockstatus_bit, FieldMode.Read,
583                     valueProviderCallback: (_) => {
584                         Status_Dtilockstatus_ValueProvider(_);
585                         return status_dtilockstatus_bit.Value;
586                     },
587 
588                     readCallback: (_, __) => Status_Dtilockstatus_Read(_, __),
589                     name: "Dtilockstatus")
590             .WithFlag(6, out status_syncbusy_bit, FieldMode.Read,
591                     valueProviderCallback: (_) => {
592                         Status_Syncbusy_ValueProvider(_);
593                         return status_syncbusy_bit.Value;
594                     },
595 
596                     readCallback: (_, __) => Status_Syncbusy_Read(_, __),
597                     name: "Syncbusy")
598             .WithReservedBits(7, 1)
599             .WithFlag(8, out status_ocbv0_bit, FieldMode.Read,
600                     valueProviderCallback: (_) => {
601                         Status_Ocbv0_ValueProvider(_);
602                         return status_ocbv0_bit.Value;
603                     },
604 
605                     readCallback: (_, __) => Status_Ocbv0_Read(_, __),
606                     name: "Ocbv0")
607             .WithFlag(9, out status_ocbv1_bit, FieldMode.Read,
608                     valueProviderCallback: (_) => {
609                         Status_Ocbv1_ValueProvider(_);
610                         return status_ocbv1_bit.Value;
611                     },
612 
613                     readCallback: (_, __) => Status_Ocbv1_Read(_, __),
614                     name: "Ocbv1")
615             .WithFlag(10, out status_ocbv2_bit, FieldMode.Read,
616                     valueProviderCallback: (_) => {
617                         Status_Ocbv2_ValueProvider(_);
618                         return status_ocbv2_bit.Value;
619                     },
620 
621                     readCallback: (_, __) => Status_Ocbv2_Read(_, __),
622                     name: "Ocbv2")
623             .WithReservedBits(11, 5)
624             .WithFlag(16, out status_icfempty0_bit, FieldMode.Read,
625                     valueProviderCallback: (_) => {
626                         Status_Icfempty0_ValueProvider(_);
627                         return status_icfempty0_bit.Value;
628                     },
629 
630                     readCallback: (_, __) => Status_Icfempty0_Read(_, __),
631                     name: "Icfempty0")
632             .WithFlag(17, out status_icfempty1_bit, FieldMode.Read,
633                     valueProviderCallback: (_) => {
634                         Status_Icfempty1_ValueProvider(_);
635                         return status_icfempty1_bit.Value;
636                     },
637 
638                     readCallback: (_, __) => Status_Icfempty1_Read(_, __),
639                     name: "Icfempty1")
640             .WithFlag(18, out status_icfempty2_bit, FieldMode.Read,
641                     valueProviderCallback: (_) => {
642                         Status_Icfempty2_ValueProvider(_);
643                         return status_icfempty2_bit.Value;
644                     },
645 
646                     readCallback: (_, __) => Status_Icfempty2_Read(_, __),
647                     name: "Icfempty2")
648             .WithReservedBits(19, 5)
649             .WithEnumField<DoubleWordRegister, STATUS_CCPOL0>(24, 1, out status_ccpol0_bit, FieldMode.Read,
650                     valueProviderCallback: (_) => {
651                         Status_Ccpol0_ValueProvider(_);
652                         return status_ccpol0_bit.Value;
653                     },
654 
655                     readCallback: (_, __) => Status_Ccpol0_Read(_, __),
656                     name: "Ccpol0")
657             .WithEnumField<DoubleWordRegister, STATUS_CCPOL1>(25, 1, out status_ccpol1_bit, FieldMode.Read,
658                     valueProviderCallback: (_) => {
659                         Status_Ccpol1_ValueProvider(_);
660                         return status_ccpol1_bit.Value;
661                     },
662 
663                     readCallback: (_, __) => Status_Ccpol1_Read(_, __),
664                     name: "Ccpol1")
665             .WithEnumField<DoubleWordRegister, STATUS_CCPOL2>(26, 1, out status_ccpol2_bit, FieldMode.Read,
666                     valueProviderCallback: (_) => {
667                         Status_Ccpol2_ValueProvider(_);
668                         return status_ccpol2_bit.Value;
669                     },
670 
671                     readCallback: (_, __) => Status_Ccpol2_Read(_, __),
672                     name: "Ccpol2")
673             .WithReservedBits(27, 5)
674             .WithReadCallback((_, __) => Status_Read(_, __))
675             .WithWriteCallback((_, __) => Status_Write(_, __));
676 
677         // If - Offset : 0x14
GenerateIfRegister()678         protected DoubleWordRegister  GenerateIfRegister() => new DoubleWordRegister(this, 0x0)
679             .WithFlag(0, out if_of_bit,
680                     valueProviderCallback: (_) => {
681                         If_Of_ValueProvider(_);
682                         return if_of_bit.Value;
683                     },
684 
685                     writeCallback: (_, __) => If_Of_Write(_, __),
686 
687                     readCallback: (_, __) => If_Of_Read(_, __),
688                     name: "Of")
689             .WithFlag(1, out if_uf_bit,
690                     valueProviderCallback: (_) => {
691                         If_Uf_ValueProvider(_);
692                         return if_uf_bit.Value;
693                     },
694 
695                     writeCallback: (_, __) => If_Uf_Write(_, __),
696 
697                     readCallback: (_, __) => If_Uf_Read(_, __),
698                     name: "Uf")
699             .WithFlag(2, out if_dirchg_bit,
700                     valueProviderCallback: (_) => {
701                         If_Dirchg_ValueProvider(_);
702                         return if_dirchg_bit.Value;
703                     },
704 
705                     writeCallback: (_, __) => If_Dirchg_Write(_, __),
706 
707                     readCallback: (_, __) => If_Dirchg_Read(_, __),
708                     name: "Dirchg")
709             .WithReservedBits(3, 1)
710             .WithFlag(4, out if_cc0_bit,
711                     valueProviderCallback: (_) => {
712                         If_Cc0_ValueProvider(_);
713                         return if_cc0_bit.Value;
714                     },
715 
716                     writeCallback: (_, __) => If_Cc0_Write(_, __),
717 
718                     readCallback: (_, __) => If_Cc0_Read(_, __),
719                     name: "Cc0")
720             .WithFlag(5, out if_cc1_bit,
721                     valueProviderCallback: (_) => {
722                         If_Cc1_ValueProvider(_);
723                         return if_cc1_bit.Value;
724                     },
725 
726                     writeCallback: (_, __) => If_Cc1_Write(_, __),
727 
728                     readCallback: (_, __) => If_Cc1_Read(_, __),
729                     name: "Cc1")
730             .WithFlag(6, out if_cc2_bit,
731                     valueProviderCallback: (_) => {
732                         If_Cc2_ValueProvider(_);
733                         return if_cc2_bit.Value;
734                     },
735 
736                     writeCallback: (_, __) => If_Cc2_Write(_, __),
737 
738                     readCallback: (_, __) => If_Cc2_Read(_, __),
739                     name: "Cc2")
740             .WithReservedBits(7, 9)
741             .WithFlag(16, out if_icfwlfull0_bit,
742                     valueProviderCallback: (_) => {
743                         If_Icfwlfull0_ValueProvider(_);
744                         return if_icfwlfull0_bit.Value;
745                     },
746 
747                     writeCallback: (_, __) => If_Icfwlfull0_Write(_, __),
748 
749                     readCallback: (_, __) => If_Icfwlfull0_Read(_, __),
750                     name: "Icfwlfull0")
751             .WithFlag(17, out if_icfwlfull1_bit,
752                     valueProviderCallback: (_) => {
753                         If_Icfwlfull1_ValueProvider(_);
754                         return if_icfwlfull1_bit.Value;
755                     },
756 
757                     writeCallback: (_, __) => If_Icfwlfull1_Write(_, __),
758 
759                     readCallback: (_, __) => If_Icfwlfull1_Read(_, __),
760                     name: "Icfwlfull1")
761             .WithFlag(18, out if_icfwlfull2_bit,
762                     valueProviderCallback: (_) => {
763                         If_Icfwlfull2_ValueProvider(_);
764                         return if_icfwlfull2_bit.Value;
765                     },
766 
767                     writeCallback: (_, __) => If_Icfwlfull2_Write(_, __),
768 
769                     readCallback: (_, __) => If_Icfwlfull2_Read(_, __),
770                     name: "Icfwlfull2")
771             .WithReservedBits(19, 1)
772             .WithFlag(20, out if_icfof0_bit,
773                     valueProviderCallback: (_) => {
774                         If_Icfof0_ValueProvider(_);
775                         return if_icfof0_bit.Value;
776                     },
777 
778                     writeCallback: (_, __) => If_Icfof0_Write(_, __),
779 
780                     readCallback: (_, __) => If_Icfof0_Read(_, __),
781                     name: "Icfof0")
782             .WithFlag(21, out if_icfof1_bit,
783                     valueProviderCallback: (_) => {
784                         If_Icfof1_ValueProvider(_);
785                         return if_icfof1_bit.Value;
786                     },
787 
788                     writeCallback: (_, __) => If_Icfof1_Write(_, __),
789 
790                     readCallback: (_, __) => If_Icfof1_Read(_, __),
791                     name: "Icfof1")
792             .WithFlag(22, out if_icfof2_bit,
793                     valueProviderCallback: (_) => {
794                         If_Icfof2_ValueProvider(_);
795                         return if_icfof2_bit.Value;
796                     },
797 
798                     writeCallback: (_, __) => If_Icfof2_Write(_, __),
799 
800                     readCallback: (_, __) => If_Icfof2_Read(_, __),
801                     name: "Icfof2")
802             .WithReservedBits(23, 1)
803             .WithFlag(24, out if_icfuf0_bit,
804                     valueProviderCallback: (_) => {
805                         If_Icfuf0_ValueProvider(_);
806                         return if_icfuf0_bit.Value;
807                     },
808 
809                     writeCallback: (_, __) => If_Icfuf0_Write(_, __),
810 
811                     readCallback: (_, __) => If_Icfuf0_Read(_, __),
812                     name: "Icfuf0")
813             .WithFlag(25, out if_icfuf1_bit,
814                     valueProviderCallback: (_) => {
815                         If_Icfuf1_ValueProvider(_);
816                         return if_icfuf1_bit.Value;
817                     },
818 
819                     writeCallback: (_, __) => If_Icfuf1_Write(_, __),
820 
821                     readCallback: (_, __) => If_Icfuf1_Read(_, __),
822                     name: "Icfuf1")
823             .WithFlag(26, out if_icfuf2_bit,
824                     valueProviderCallback: (_) => {
825                         If_Icfuf2_ValueProvider(_);
826                         return if_icfuf2_bit.Value;
827                     },
828 
829                     writeCallback: (_, __) => If_Icfuf2_Write(_, __),
830 
831                     readCallback: (_, __) => If_Icfuf2_Read(_, __),
832                     name: "Icfuf2")
833             .WithReservedBits(27, 5)
834             .WithReadCallback((_, __) => If_Read(_, __))
835             .WithWriteCallback((_, __) => If_Write(_, __));
836 
837         // Ien - Offset : 0x18
GenerateIenRegister()838         protected DoubleWordRegister  GenerateIenRegister() => new DoubleWordRegister(this, 0x0)
839             .WithFlag(0, out ien_of_bit,
840                     valueProviderCallback: (_) => {
841                         Ien_Of_ValueProvider(_);
842                         return ien_of_bit.Value;
843                     },
844 
845                     writeCallback: (_, __) => Ien_Of_Write(_, __),
846 
847                     readCallback: (_, __) => Ien_Of_Read(_, __),
848                     name: "Of")
849             .WithFlag(1, out ien_uf_bit,
850                     valueProviderCallback: (_) => {
851                         Ien_Uf_ValueProvider(_);
852                         return ien_uf_bit.Value;
853                     },
854 
855                     writeCallback: (_, __) => Ien_Uf_Write(_, __),
856 
857                     readCallback: (_, __) => Ien_Uf_Read(_, __),
858                     name: "Uf")
859             .WithFlag(2, out ien_dirchg_bit,
860                     valueProviderCallback: (_) => {
861                         Ien_Dirchg_ValueProvider(_);
862                         return ien_dirchg_bit.Value;
863                     },
864 
865                     writeCallback: (_, __) => Ien_Dirchg_Write(_, __),
866 
867                     readCallback: (_, __) => Ien_Dirchg_Read(_, __),
868                     name: "Dirchg")
869             .WithReservedBits(3, 1)
870             .WithFlag(4, out ien_cc0_bit,
871                     valueProviderCallback: (_) => {
872                         Ien_Cc0_ValueProvider(_);
873                         return ien_cc0_bit.Value;
874                     },
875 
876                     writeCallback: (_, __) => Ien_Cc0_Write(_, __),
877 
878                     readCallback: (_, __) => Ien_Cc0_Read(_, __),
879                     name: "Cc0")
880             .WithFlag(5, out ien_cc1_bit,
881                     valueProviderCallback: (_) => {
882                         Ien_Cc1_ValueProvider(_);
883                         return ien_cc1_bit.Value;
884                     },
885 
886                     writeCallback: (_, __) => Ien_Cc1_Write(_, __),
887 
888                     readCallback: (_, __) => Ien_Cc1_Read(_, __),
889                     name: "Cc1")
890             .WithFlag(6, out ien_cc2_bit,
891                     valueProviderCallback: (_) => {
892                         Ien_Cc2_ValueProvider(_);
893                         return ien_cc2_bit.Value;
894                     },
895 
896                     writeCallback: (_, __) => Ien_Cc2_Write(_, __),
897 
898                     readCallback: (_, __) => Ien_Cc2_Read(_, __),
899                     name: "Cc2")
900             .WithReservedBits(7, 9)
901             .WithFlag(16, out ien_icfwlfull0_bit,
902                     valueProviderCallback: (_) => {
903                         Ien_Icfwlfull0_ValueProvider(_);
904                         return ien_icfwlfull0_bit.Value;
905                     },
906 
907                     writeCallback: (_, __) => Ien_Icfwlfull0_Write(_, __),
908 
909                     readCallback: (_, __) => Ien_Icfwlfull0_Read(_, __),
910                     name: "Icfwlfull0")
911             .WithFlag(17, out ien_icfwlfull1_bit,
912                     valueProviderCallback: (_) => {
913                         Ien_Icfwlfull1_ValueProvider(_);
914                         return ien_icfwlfull1_bit.Value;
915                     },
916 
917                     writeCallback: (_, __) => Ien_Icfwlfull1_Write(_, __),
918 
919                     readCallback: (_, __) => Ien_Icfwlfull1_Read(_, __),
920                     name: "Icfwlfull1")
921             .WithFlag(18, out ien_icfwlfull2_bit,
922                     valueProviderCallback: (_) => {
923                         Ien_Icfwlfull2_ValueProvider(_);
924                         return ien_icfwlfull2_bit.Value;
925                     },
926 
927                     writeCallback: (_, __) => Ien_Icfwlfull2_Write(_, __),
928 
929                     readCallback: (_, __) => Ien_Icfwlfull2_Read(_, __),
930                     name: "Icfwlfull2")
931             .WithReservedBits(19, 1)
932             .WithFlag(20, out ien_icfof0_bit,
933                     valueProviderCallback: (_) => {
934                         Ien_Icfof0_ValueProvider(_);
935                         return ien_icfof0_bit.Value;
936                     },
937 
938                     writeCallback: (_, __) => Ien_Icfof0_Write(_, __),
939 
940                     readCallback: (_, __) => Ien_Icfof0_Read(_, __),
941                     name: "Icfof0")
942             .WithFlag(21, out ien_icfof1_bit,
943                     valueProviderCallback: (_) => {
944                         Ien_Icfof1_ValueProvider(_);
945                         return ien_icfof1_bit.Value;
946                     },
947 
948                     writeCallback: (_, __) => Ien_Icfof1_Write(_, __),
949 
950                     readCallback: (_, __) => Ien_Icfof1_Read(_, __),
951                     name: "Icfof1")
952             .WithFlag(22, out ien_icfof2_bit,
953                     valueProviderCallback: (_) => {
954                         Ien_Icfof2_ValueProvider(_);
955                         return ien_icfof2_bit.Value;
956                     },
957 
958                     writeCallback: (_, __) => Ien_Icfof2_Write(_, __),
959 
960                     readCallback: (_, __) => Ien_Icfof2_Read(_, __),
961                     name: "Icfof2")
962             .WithReservedBits(23, 1)
963             .WithFlag(24, out ien_icfuf0_bit,
964                     valueProviderCallback: (_) => {
965                         Ien_Icfuf0_ValueProvider(_);
966                         return ien_icfuf0_bit.Value;
967                     },
968 
969                     writeCallback: (_, __) => Ien_Icfuf0_Write(_, __),
970 
971                     readCallback: (_, __) => Ien_Icfuf0_Read(_, __),
972                     name: "Icfuf0")
973             .WithFlag(25, out ien_icfuf1_bit,
974                     valueProviderCallback: (_) => {
975                         Ien_Icfuf1_ValueProvider(_);
976                         return ien_icfuf1_bit.Value;
977                     },
978 
979                     writeCallback: (_, __) => Ien_Icfuf1_Write(_, __),
980 
981                     readCallback: (_, __) => Ien_Icfuf1_Read(_, __),
982                     name: "Icfuf1")
983             .WithFlag(26, out ien_icfuf2_bit,
984                     valueProviderCallback: (_) => {
985                         Ien_Icfuf2_ValueProvider(_);
986                         return ien_icfuf2_bit.Value;
987                     },
988 
989                     writeCallback: (_, __) => Ien_Icfuf2_Write(_, __),
990 
991                     readCallback: (_, __) => Ien_Icfuf2_Read(_, __),
992                     name: "Icfuf2")
993             .WithReservedBits(27, 5)
994             .WithReadCallback((_, __) => Ien_Read(_, __))
995             .WithWriteCallback((_, __) => Ien_Write(_, __));
996 
997         // Top - Offset : 0x1C
GenerateTopRegister()998         protected DoubleWordRegister  GenerateTopRegister() => new DoubleWordRegister(this, 0xFFFF)
999 
1000             .WithValueField(0, 32, out top_top_field,
1001                     valueProviderCallback: (_) => {
1002                         Top_Top_ValueProvider(_);
1003                         return top_top_field.Value;
1004                     },
1005                     writeCallback: (_, __) => {
1006                         WriteRWSYNC();
1007                         Top_Top_Write(_, __);
1008                     },
1009 
1010                     readCallback: (_, __) => Top_Top_Read(_, __),
1011                     name: "Top")
1012             .WithReadCallback((_, __) => Top_Read(_, __))
1013             .WithWriteCallback((_, __) => Top_Write(_, __));
1014 
1015         // Topb - Offset : 0x20
GenerateTopbRegister()1016         protected DoubleWordRegister  GenerateTopbRegister() => new DoubleWordRegister(this, 0x0)
1017 
1018             .WithValueField(0, 32, out topb_topb_field,
1019                     valueProviderCallback: (_) => {
1020                         Topb_Topb_ValueProvider(_);
1021                         return topb_topb_field.Value;
1022                     },
1023                     writeCallback: (_, __) => {
1024                         WriteWSYNC();
1025                         Topb_Topb_Write(_, __);
1026                     },
1027 
1028                     readCallback: (_, __) => Topb_Topb_Read(_, __),
1029                     name: "Topb")
1030             .WithReadCallback((_, __) => Topb_Read(_, __))
1031             .WithWriteCallback((_, __) => Topb_Write(_, __));
1032 
1033         // Cnt - Offset : 0x24
GenerateCntRegister()1034         protected DoubleWordRegister  GenerateCntRegister() => new DoubleWordRegister(this, 0x0)
1035 
1036             .WithValueField(0, 32, out cnt_cnt_field,
1037                     valueProviderCallback: (_) => {
1038                         Cnt_Cnt_ValueProvider(_);
1039                         return cnt_cnt_field.Value;
1040                     },
1041                     writeCallback: (_, __) => {
1042                         WriteRWSYNC();
1043                         Cnt_Cnt_Write(_, __);
1044                     },
1045 
1046                     readCallback: (_, __) => Cnt_Cnt_Read(_, __),
1047                     name: "Cnt")
1048             .WithReadCallback((_, __) => Cnt_Read(_, __))
1049             .WithWriteCallback((_, __) => Cnt_Write(_, __));
1050 
1051         // Lock - Offset : 0x2C
GenerateLockRegister()1052         protected DoubleWordRegister  GenerateLockRegister() => new DoubleWordRegister(this, 0x0)
1053 
1054             .WithValueField(0, 16, out lock_lockkey_field, FieldMode.Write,
1055 
1056                     writeCallback: (_, __) => Lock_Lockkey_Write(_, __),
1057                     name: "Lockkey")
1058             .WithReservedBits(16, 16)
1059             .WithReadCallback((_, __) => Lock_Read(_, __))
1060             .WithWriteCallback((_, __) => Lock_Write(_, __));
1061 
1062         // En - Offset : 0x30
GenerateEnRegister()1063         protected DoubleWordRegister  GenerateEnRegister() => new DoubleWordRegister(this, 0x0)
1064             .WithFlag(0, out en_en_bit,
1065                     valueProviderCallback: (_) => {
1066                         En_En_ValueProvider(_);
1067                         return en_en_bit.Value;
1068                     },
1069 
1070                     writeCallback: (_, __) => En_En_Write(_, __),
1071 
1072                     readCallback: (_, __) => En_En_Read(_, __),
1073                     name: "En")
1074             .WithFlag(1, out en_disabling_bit, FieldMode.Read,
1075                     valueProviderCallback: (_) => {
1076                         En_Disabling_ValueProvider(_);
1077                         return en_disabling_bit.Value;
1078                     },
1079 
1080                     readCallback: (_, __) => En_Disabling_Read(_, __),
1081                     name: "Disabling")
1082             .WithReservedBits(2, 30)
1083             .WithReadCallback((_, __) => En_Read(_, __))
1084             .WithWriteCallback((_, __) => En_Write(_, __));
1085 
1086         // Cc0_Cfg - Offset : 0x60
GenerateCc0_cfgRegister()1087         protected DoubleWordRegister  GenerateCc0_cfgRegister() => new DoubleWordRegister(this, 0x0)
1088             .WithEnumField<DoubleWordRegister, CC_CFG_MODE>(0, 2, out cc_cfg_mode_field[0],
1089                     valueProviderCallback: (_) => {
1090                         Cc_Cfg_Mode_ValueProvider(0, _);
1091                         return cc_cfg_mode_field[0].Value;
1092                     },
1093                     writeCallback: (_, __) => {
1094                         WriteWSTATIC();
1095                         Cc_Cfg_Mode_Write(0, _, __);
1096                     },
1097 
1098                     readCallback: (_, __) => Cc_Cfg_Mode_Read(0,_, __),
1099                     name: "Mode")
1100             .WithReservedBits(2, 2)
1101             .WithFlag(4, out cc_cfg_coist_bit[0],
1102                     valueProviderCallback: (_) => {
1103                         Cc_Cfg_Coist_ValueProvider(0, _);
1104                         return cc_cfg_coist_bit[0].Value;
1105                     },
1106                     writeCallback: (_, __) => {
1107                         WriteWSTATIC();
1108                         Cc_Cfg_Coist_Write(0, _, __);
1109                     },
1110 
1111                     readCallback: (_, __) => Cc_Cfg_Coist_Read(0,_, __),
1112                     name: "Coist")
1113             .WithReservedBits(5, 12)
1114             .WithEnumField<DoubleWordRegister, CC_CFG_INSEL>(17, 2, out cc_cfg_insel_field[0],
1115                     valueProviderCallback: (_) => {
1116                         Cc_Cfg_Insel_ValueProvider(0, _);
1117                         return cc_cfg_insel_field[0].Value;
1118                     },
1119                     writeCallback: (_, __) => {
1120                         WriteWSTATIC();
1121                         Cc_Cfg_Insel_Write(0, _, __);
1122                     },
1123 
1124                     readCallback: (_, __) => Cc_Cfg_Insel_Read(0,_, __),
1125                     name: "Insel")
1126             .WithEnumField<DoubleWordRegister, CC_CFG_PRSCONF>(19, 1, out cc_cfg_prsconf_bit[0],
1127                     valueProviderCallback: (_) => {
1128                         Cc_Cfg_Prsconf_ValueProvider(0, _);
1129                         return cc_cfg_prsconf_bit[0].Value;
1130                     },
1131                     writeCallback: (_, __) => {
1132                         WriteWSTATIC();
1133                         Cc_Cfg_Prsconf_Write(0, _, __);
1134                     },
1135 
1136                     readCallback: (_, __) => Cc_Cfg_Prsconf_Read(0,_, __),
1137                 name: "Prsconf")
1138             .WithEnumField<DoubleWordRegister, CC_CFG_FILT>(20, 1, out cc_cfg_filt_bit[0],
1139                     valueProviderCallback: (_) => {
1140                         Cc_Cfg_Filt_ValueProvider(0, _);
1141                         return cc_cfg_filt_bit[0].Value;
1142                     },
1143                     writeCallback: (_, __) => {
1144                         WriteWSTATIC();
1145                         Cc_Cfg_Filt_Write(0, _, __);
1146                     },
1147 
1148                     readCallback: (_, __) => Cc_Cfg_Filt_Read(0,_, __),
1149                 name: "Filt")
1150             .WithFlag(21, out cc_cfg_icfwl_bit[0],
1151                     valueProviderCallback: (_) => {
1152                         Cc_Cfg_Icfwl_ValueProvider(0, _);
1153                         return cc_cfg_icfwl_bit[0].Value;
1154                     },
1155                     writeCallback: (_, __) => {
1156                         WriteWSTATIC();
1157                         Cc_Cfg_Icfwl_Write(0, _, __);
1158                     },
1159 
1160                     readCallback: (_, __) => Cc_Cfg_Icfwl_Read(0,_, __),
1161                     name: "Icfwl")
1162             .WithReservedBits(22, 10)
1163             .WithReadCallback((_, __) => Cc_Cfg_Read(0, _, __))
1164             .WithWriteCallback((_, __) => Cc_Cfg_Write(0, _, __));
1165 
1166         // Cc0_Ctrl - Offset : 0x64
GenerateCc0_ctrlRegister()1167         protected DoubleWordRegister  GenerateCc0_ctrlRegister() => new DoubleWordRegister(this, 0x0)
1168             .WithReservedBits(0, 2)
1169             .WithFlag(2, out cc_ctrl_outinv_bit[0],
1170                     valueProviderCallback: (_) => {
1171                         Cc_Ctrl_Outinv_ValueProvider(0, _);
1172                         return cc_ctrl_outinv_bit[0].Value;
1173                     },
1174                     writeCallback: (_, __) => {
1175                         WriteWSYNC();
1176                         Cc_Ctrl_Outinv_Write(0, _, __);
1177                     },
1178 
1179                     readCallback: (_, __) => Cc_Ctrl_Outinv_Read(0,_, __),
1180                     name: "Outinv")
1181             .WithReservedBits(3, 5)
1182             .WithEnumField<DoubleWordRegister, CC_CTRL_CMOA>(8, 2, out cc_ctrl_cmoa_field[0],
1183                     valueProviderCallback: (_) => {
1184                         Cc_Ctrl_Cmoa_ValueProvider(0, _);
1185                         return cc_ctrl_cmoa_field[0].Value;
1186                     },
1187                     writeCallback: (_, __) => {
1188                         WriteWSYNC();
1189                         Cc_Ctrl_Cmoa_Write(0, _, __);
1190                     },
1191 
1192                     readCallback: (_, __) => Cc_Ctrl_Cmoa_Read(0,_, __),
1193                     name: "Cmoa")
1194             .WithEnumField<DoubleWordRegister, CC_CTRL_COFOA>(10, 2, out cc_ctrl_cofoa_field[0],
1195                     valueProviderCallback: (_) => {
1196                         Cc_Ctrl_Cofoa_ValueProvider(0, _);
1197                         return cc_ctrl_cofoa_field[0].Value;
1198                     },
1199                     writeCallback: (_, __) => {
1200                         WriteWSYNC();
1201                         Cc_Ctrl_Cofoa_Write(0, _, __);
1202                     },
1203 
1204                     readCallback: (_, __) => Cc_Ctrl_Cofoa_Read(0,_, __),
1205                     name: "Cofoa")
1206             .WithEnumField<DoubleWordRegister, CC_CTRL_CUFOA>(12, 2, out cc_ctrl_cufoa_field[0],
1207                     valueProviderCallback: (_) => {
1208                         Cc_Ctrl_Cufoa_ValueProvider(0, _);
1209                         return cc_ctrl_cufoa_field[0].Value;
1210                     },
1211                     writeCallback: (_, __) => {
1212                         WriteWSYNC();
1213                         Cc_Ctrl_Cufoa_Write(0, _, __);
1214                     },
1215 
1216                     readCallback: (_, __) => Cc_Ctrl_Cufoa_Read(0,_, __),
1217                     name: "Cufoa")
1218             .WithReservedBits(14, 10)
1219             .WithEnumField<DoubleWordRegister, CC_CTRL_ICEDGE>(24, 2, out cc_ctrl_icedge_field[0],
1220                     valueProviderCallback: (_) => {
1221                         Cc_Ctrl_Icedge_ValueProvider(0, _);
1222                         return cc_ctrl_icedge_field[0].Value;
1223                     },
1224                     writeCallback: (_, __) => {
1225                         WriteWSYNC();
1226                         Cc_Ctrl_Icedge_Write(0, _, __);
1227                     },
1228 
1229                     readCallback: (_, __) => Cc_Ctrl_Icedge_Read(0,_, __),
1230                     name: "Icedge")
1231             .WithEnumField<DoubleWordRegister, CC_CTRL_ICEVCTRL>(26, 2, out cc_ctrl_icevctrl_field[0],
1232                     valueProviderCallback: (_) => {
1233                         Cc_Ctrl_Icevctrl_ValueProvider(0, _);
1234                         return cc_ctrl_icevctrl_field[0].Value;
1235                     },
1236                     writeCallback: (_, __) => {
1237                         WriteWSYNC();
1238                         Cc_Ctrl_Icevctrl_Write(0, _, __);
1239                     },
1240 
1241                     readCallback: (_, __) => Cc_Ctrl_Icevctrl_Read(0,_, __),
1242                     name: "Icevctrl")
1243             .WithReservedBits(28, 4)
1244             .WithReadCallback((_, __) => Cc_Ctrl_Read(0, _, __))
1245             .WithWriteCallback((_, __) => Cc_Ctrl_Write(0, _, __));
1246 
1247         // Cc0_Oc - Offset : 0x68
GenerateCc0_ocRegister()1248         protected DoubleWordRegister  GenerateCc0_ocRegister() => new DoubleWordRegister(this, 0x0)
1249             .WithValueField(0, 32, out cc_oc_oc_field[0],
1250                     valueProviderCallback: (_) => {
1251                         Cc_Oc_Oc_ValueProvider(0, _);
1252                         return cc_oc_oc_field[0].Value;
1253                     },
1254                     writeCallback: (_, __) => {
1255                         WriteRWSYNC();
1256                         Cc_Oc_Oc_Write(0, _, __);
1257                     },
1258 
1259                     readCallback: (_, __) => Cc_Oc_Oc_Read(0,_, __),
1260                     name: "Oc")
1261             .WithReadCallback((_, __) => Cc_Oc_Read(0, _, __))
1262             .WithWriteCallback((_, __) => Cc_Oc_Write(0, _, __));
1263 
1264         // Cc0_Ocb - Offset : 0x70
GenerateCc0_ocbRegister()1265         protected DoubleWordRegister  GenerateCc0_ocbRegister() => new DoubleWordRegister(this, 0x0)
1266             .WithValueField(0, 32, out cc_ocb_ocb_field[0],
1267                     valueProviderCallback: (_) => {
1268                         Cc_Ocb_Ocb_ValueProvider(0, _);
1269                         return cc_ocb_ocb_field[0].Value;
1270                     },
1271                     writeCallback: (_, __) => {
1272                         WriteWSYNC();
1273                         Cc_Ocb_Ocb_Write(0, _, __);
1274                     },
1275 
1276                     readCallback: (_, __) => Cc_Ocb_Ocb_Read(0,_, __),
1277                     name: "Ocb")
1278             .WithReadCallback((_, __) => Cc_Ocb_Read(0, _, __))
1279             .WithWriteCallback((_, __) => Cc_Ocb_Write(0, _, __));
1280 
1281         // Cc0_Icf - Offset : 0x74
GenerateCc0_icfRegister()1282         protected DoubleWordRegister  GenerateCc0_icfRegister() => new DoubleWordRegister(this, 0x0)
1283             .WithValueField(0, 32, out cc_icf_icf_field[0], FieldMode.Read,
1284                     valueProviderCallback: (_) => {
1285                         Cc_Icf_Icf_ValueProvider(0, _);
1286                         return ReadRFIFO();
1287                     },
1288 
1289                     readCallback: (_, __) => Cc_Icf_Icf_Read(0,_, __),
1290                     name: "Icf")
1291             .WithReadCallback((_, __) => Cc_Icf_Read(0, _, __))
1292             .WithWriteCallback((_, __) => Cc_Icf_Write(0, _, __));
1293 
1294         // Cc0_Icof - Offset : 0x78
GenerateCc0_icofRegister()1295         protected DoubleWordRegister  GenerateCc0_icofRegister() => new DoubleWordRegister(this, 0x0)
1296             .WithValueField(0, 32, out cc_icof_icof_field[0], FieldMode.Read,
1297                     valueProviderCallback: (_) => {
1298                         Cc_Icof_Icof_ValueProvider(0, _);
1299                         return cc_icof_icof_field[0].Value;
1300                     },
1301 
1302                     readCallback: (_, __) => Cc_Icof_Icof_Read(0,_, __),
1303                     name: "Icof")
1304             .WithReadCallback((_, __) => Cc_Icof_Read(0, _, __))
1305             .WithWriteCallback((_, __) => Cc_Icof_Write(0, _, __));
1306 
1307         // Cc1_Cfg - Offset : 0x80
GenerateCc1_cfgRegister()1308         protected DoubleWordRegister  GenerateCc1_cfgRegister() => new DoubleWordRegister(this, 0x0)
1309             .WithEnumField<DoubleWordRegister, CC_CFG_MODE>(0, 2, out cc_cfg_mode_field[1],
1310                     valueProviderCallback: (_) => {
1311                         Cc_Cfg_Mode_ValueProvider(1, _);
1312                         return cc_cfg_mode_field[1].Value;
1313                     },
1314                     writeCallback: (_, __) => {
1315                         WriteWSTATIC();
1316                         Cc_Cfg_Mode_Write(1, _, __);
1317                     },
1318 
1319                     readCallback: (_, __) => Cc_Cfg_Mode_Read(1,_, __),
1320                     name: "Mode")
1321             .WithReservedBits(2, 2)
1322             .WithFlag(4, out cc_cfg_coist_bit[1],
1323                     valueProviderCallback: (_) => {
1324                         Cc_Cfg_Coist_ValueProvider(1, _);
1325                         return cc_cfg_coist_bit[1].Value;
1326                     },
1327                     writeCallback: (_, __) => {
1328                         WriteWSTATIC();
1329                         Cc_Cfg_Coist_Write(1, _, __);
1330                     },
1331 
1332                     readCallback: (_, __) => Cc_Cfg_Coist_Read(1,_, __),
1333                     name: "Coist")
1334             .WithReservedBits(5, 12)
1335             .WithEnumField<DoubleWordRegister, CC_CFG_INSEL>(17, 2, out cc_cfg_insel_field[1],
1336                     valueProviderCallback: (_) => {
1337                         Cc_Cfg_Insel_ValueProvider(1, _);
1338                         return cc_cfg_insel_field[1].Value;
1339                     },
1340                     writeCallback: (_, __) => {
1341                         WriteWSTATIC();
1342                         Cc_Cfg_Insel_Write(1, _, __);
1343                     },
1344 
1345                     readCallback: (_, __) => Cc_Cfg_Insel_Read(1,_, __),
1346                     name: "Insel")
1347             .WithEnumField<DoubleWordRegister, CC_CFG_PRSCONF>(19, 1, out cc_cfg_prsconf_bit[1],
1348                     valueProviderCallback: (_) => {
1349                         Cc_Cfg_Prsconf_ValueProvider(1, _);
1350                         return cc_cfg_prsconf_bit[1].Value;
1351                     },
1352                     writeCallback: (_, __) => {
1353                         WriteWSTATIC();
1354                         Cc_Cfg_Prsconf_Write(1, _, __);
1355                     },
1356 
1357                     readCallback: (_, __) => Cc_Cfg_Prsconf_Read(1,_, __),
1358                 name: "Prsconf")
1359             .WithEnumField<DoubleWordRegister, CC_CFG_FILT>(20, 1, out cc_cfg_filt_bit[1],
1360                     valueProviderCallback: (_) => {
1361                         Cc_Cfg_Filt_ValueProvider(1, _);
1362                         return cc_cfg_filt_bit[1].Value;
1363                     },
1364                     writeCallback: (_, __) => {
1365                         WriteWSTATIC();
1366                         Cc_Cfg_Filt_Write(1, _, __);
1367                     },
1368 
1369                     readCallback: (_, __) => Cc_Cfg_Filt_Read(1,_, __),
1370                 name: "Filt")
1371             .WithFlag(21, out cc_cfg_icfwl_bit[1],
1372                     valueProviderCallback: (_) => {
1373                         Cc_Cfg_Icfwl_ValueProvider(1, _);
1374                         return cc_cfg_icfwl_bit[1].Value;
1375                     },
1376                     writeCallback: (_, __) => {
1377                         WriteWSTATIC();
1378                         Cc_Cfg_Icfwl_Write(1, _, __);
1379                     },
1380 
1381                     readCallback: (_, __) => Cc_Cfg_Icfwl_Read(1,_, __),
1382                     name: "Icfwl")
1383             .WithReservedBits(22, 10)
1384             .WithReadCallback((_, __) => Cc_Cfg_Read(1, _, __))
1385             .WithWriteCallback((_, __) => Cc_Cfg_Write(1, _, __));
1386 
1387         // Cc1_Ctrl - Offset : 0x84
GenerateCc1_ctrlRegister()1388         protected DoubleWordRegister  GenerateCc1_ctrlRegister() => new DoubleWordRegister(this, 0x0)
1389             .WithReservedBits(0, 2)
1390             .WithFlag(2, out cc_ctrl_outinv_bit[1],
1391                     valueProviderCallback: (_) => {
1392                         Cc_Ctrl_Outinv_ValueProvider(1, _);
1393                         return cc_ctrl_outinv_bit[1].Value;
1394                     },
1395                     writeCallback: (_, __) => {
1396                         WriteWSYNC();
1397                         Cc_Ctrl_Outinv_Write(1, _, __);
1398                     },
1399 
1400                     readCallback: (_, __) => Cc_Ctrl_Outinv_Read(1,_, __),
1401                     name: "Outinv")
1402             .WithReservedBits(3, 5)
1403             .WithEnumField<DoubleWordRegister, CC_CTRL_CMOA>(8, 2, out cc_ctrl_cmoa_field[1],
1404                     valueProviderCallback: (_) => {
1405                         Cc_Ctrl_Cmoa_ValueProvider(1, _);
1406                         return cc_ctrl_cmoa_field[1].Value;
1407                     },
1408                     writeCallback: (_, __) => {
1409                         WriteWSYNC();
1410                         Cc_Ctrl_Cmoa_Write(1, _, __);
1411                     },
1412 
1413                     readCallback: (_, __) => Cc_Ctrl_Cmoa_Read(1,_, __),
1414                     name: "Cmoa")
1415             .WithEnumField<DoubleWordRegister, CC_CTRL_COFOA>(10, 2, out cc_ctrl_cofoa_field[1],
1416                     valueProviderCallback: (_) => {
1417                         Cc_Ctrl_Cofoa_ValueProvider(1, _);
1418                         return cc_ctrl_cofoa_field[1].Value;
1419                     },
1420                     writeCallback: (_, __) => {
1421                         WriteWSYNC();
1422                         Cc_Ctrl_Cofoa_Write(1, _, __);
1423                     },
1424 
1425                     readCallback: (_, __) => Cc_Ctrl_Cofoa_Read(1,_, __),
1426                     name: "Cofoa")
1427             .WithEnumField<DoubleWordRegister, CC_CTRL_CUFOA>(12, 2, out cc_ctrl_cufoa_field[1],
1428                     valueProviderCallback: (_) => {
1429                         Cc_Ctrl_Cufoa_ValueProvider(1, _);
1430                         return cc_ctrl_cufoa_field[1].Value;
1431                     },
1432                     writeCallback: (_, __) => {
1433                         WriteWSYNC();
1434                         Cc_Ctrl_Cufoa_Write(1, _, __);
1435                     },
1436 
1437                     readCallback: (_, __) => Cc_Ctrl_Cufoa_Read(1,_, __),
1438                     name: "Cufoa")
1439             .WithReservedBits(14, 10)
1440             .WithEnumField<DoubleWordRegister, CC_CTRL_ICEDGE>(24, 2, out cc_ctrl_icedge_field[1],
1441                     valueProviderCallback: (_) => {
1442                         Cc_Ctrl_Icedge_ValueProvider(1, _);
1443                         return cc_ctrl_icedge_field[1].Value;
1444                     },
1445                     writeCallback: (_, __) => {
1446                         WriteWSYNC();
1447                         Cc_Ctrl_Icedge_Write(1, _, __);
1448                     },
1449 
1450                     readCallback: (_, __) => Cc_Ctrl_Icedge_Read(1,_, __),
1451                     name: "Icedge")
1452             .WithEnumField<DoubleWordRegister, CC_CTRL_ICEVCTRL>(26, 2, out cc_ctrl_icevctrl_field[1],
1453                     valueProviderCallback: (_) => {
1454                         Cc_Ctrl_Icevctrl_ValueProvider(1, _);
1455                         return cc_ctrl_icevctrl_field[1].Value;
1456                     },
1457                     writeCallback: (_, __) => {
1458                         WriteWSYNC();
1459                         Cc_Ctrl_Icevctrl_Write(1, _, __);
1460                     },
1461 
1462                     readCallback: (_, __) => Cc_Ctrl_Icevctrl_Read(1,_, __),
1463                     name: "Icevctrl")
1464             .WithReservedBits(28, 4)
1465             .WithReadCallback((_, __) => Cc_Ctrl_Read(1, _, __))
1466             .WithWriteCallback((_, __) => Cc_Ctrl_Write(1, _, __));
1467 
1468         // Cc1_Oc - Offset : 0x88
GenerateCc1_ocRegister()1469         protected DoubleWordRegister  GenerateCc1_ocRegister() => new DoubleWordRegister(this, 0x0)
1470             .WithValueField(0, 32, out cc_oc_oc_field[1],
1471                     valueProviderCallback: (_) => {
1472                         Cc_Oc_Oc_ValueProvider(1, _);
1473                         return cc_oc_oc_field[1].Value;
1474                     },
1475                     writeCallback: (_, __) => {
1476                         WriteRWSYNC();
1477                         Cc_Oc_Oc_Write(1, _, __);
1478                     },
1479 
1480                     readCallback: (_, __) => Cc_Oc_Oc_Read(1,_, __),
1481                     name: "Oc")
1482             .WithReadCallback((_, __) => Cc_Oc_Read(1, _, __))
1483             .WithWriteCallback((_, __) => Cc_Oc_Write(1, _, __));
1484 
1485         // Cc1_Ocb - Offset : 0x90
GenerateCc1_ocbRegister()1486         protected DoubleWordRegister  GenerateCc1_ocbRegister() => new DoubleWordRegister(this, 0x0)
1487             .WithValueField(0, 32, out cc_ocb_ocb_field[1],
1488                     valueProviderCallback: (_) => {
1489                         Cc_Ocb_Ocb_ValueProvider(1, _);
1490                         return cc_ocb_ocb_field[1].Value;
1491                     },
1492                     writeCallback: (_, __) => {
1493                         WriteWSYNC();
1494                         Cc_Ocb_Ocb_Write(1, _, __);
1495                     },
1496 
1497                     readCallback: (_, __) => Cc_Ocb_Ocb_Read(1,_, __),
1498                     name: "Ocb")
1499             .WithReadCallback((_, __) => Cc_Ocb_Read(1, _, __))
1500             .WithWriteCallback((_, __) => Cc_Ocb_Write(1, _, __));
1501 
1502         // Cc1_Icf - Offset : 0x94
GenerateCc1_icfRegister()1503         protected DoubleWordRegister  GenerateCc1_icfRegister() => new DoubleWordRegister(this, 0x0)
1504             .WithValueField(0, 32, out cc_icf_icf_field[1], FieldMode.Read,
1505                     valueProviderCallback: (_) => {
1506                         Cc_Icf_Icf_ValueProvider(1, _);
1507                         return ReadRFIFO();
1508                     },
1509 
1510                     readCallback: (_, __) => Cc_Icf_Icf_Read(1,_, __),
1511                     name: "Icf")
1512             .WithReadCallback((_, __) => Cc_Icf_Read(1, _, __))
1513             .WithWriteCallback((_, __) => Cc_Icf_Write(1, _, __));
1514 
1515         // Cc1_Icof - Offset : 0x98
GenerateCc1_icofRegister()1516         protected DoubleWordRegister  GenerateCc1_icofRegister() => new DoubleWordRegister(this, 0x0)
1517             .WithValueField(0, 32, out cc_icof_icof_field[1], FieldMode.Read,
1518                     valueProviderCallback: (_) => {
1519                         Cc_Icof_Icof_ValueProvider(1, _);
1520                         return cc_icof_icof_field[1].Value;
1521                     },
1522 
1523                     readCallback: (_, __) => Cc_Icof_Icof_Read(1,_, __),
1524                     name: "Icof")
1525             .WithReadCallback((_, __) => Cc_Icof_Read(1, _, __))
1526             .WithWriteCallback((_, __) => Cc_Icof_Write(1, _, __));
1527 
1528         // Cc2_Cfg - Offset : 0xA0
GenerateCc2_cfgRegister()1529         protected DoubleWordRegister  GenerateCc2_cfgRegister() => new DoubleWordRegister(this, 0x0)
1530             .WithEnumField<DoubleWordRegister, CC_CFG_MODE>(0, 2, out cc_cfg_mode_field[2],
1531                     valueProviderCallback: (_) => {
1532                         Cc_Cfg_Mode_ValueProvider(2, _);
1533                         return cc_cfg_mode_field[2].Value;
1534                     },
1535                     writeCallback: (_, __) => {
1536                         WriteWSTATIC();
1537                         Cc_Cfg_Mode_Write(2, _, __);
1538                     },
1539 
1540                     readCallback: (_, __) => Cc_Cfg_Mode_Read(2,_, __),
1541                     name: "Mode")
1542             .WithReservedBits(2, 2)
1543             .WithFlag(4, out cc_cfg_coist_bit[2],
1544                     valueProviderCallback: (_) => {
1545                         Cc_Cfg_Coist_ValueProvider(2, _);
1546                         return cc_cfg_coist_bit[2].Value;
1547                     },
1548                     writeCallback: (_, __) => {
1549                         WriteWSTATIC();
1550                         Cc_Cfg_Coist_Write(2, _, __);
1551                     },
1552 
1553                     readCallback: (_, __) => Cc_Cfg_Coist_Read(2,_, __),
1554                     name: "Coist")
1555             .WithReservedBits(5, 12)
1556             .WithEnumField<DoubleWordRegister, CC_CFG_INSEL>(17, 2, out cc_cfg_insel_field[2],
1557                     valueProviderCallback: (_) => {
1558                         Cc_Cfg_Insel_ValueProvider(2, _);
1559                         return cc_cfg_insel_field[2].Value;
1560                     },
1561                     writeCallback: (_, __) => {
1562                         WriteWSTATIC();
1563                         Cc_Cfg_Insel_Write(2, _, __);
1564                     },
1565 
1566                     readCallback: (_, __) => Cc_Cfg_Insel_Read(2,_, __),
1567                     name: "Insel")
1568             .WithEnumField<DoubleWordRegister, CC_CFG_PRSCONF>(19, 1, out cc_cfg_prsconf_bit[2],
1569                     valueProviderCallback: (_) => {
1570                         Cc_Cfg_Prsconf_ValueProvider(2, _);
1571                         return cc_cfg_prsconf_bit[2].Value;
1572                     },
1573                     writeCallback: (_, __) => {
1574                         WriteWSTATIC();
1575                         Cc_Cfg_Prsconf_Write(2, _, __);
1576                     },
1577 
1578                     readCallback: (_, __) => Cc_Cfg_Prsconf_Read(2,_, __),
1579                 name: "Prsconf")
1580             .WithEnumField<DoubleWordRegister, CC_CFG_FILT>(20, 1, out cc_cfg_filt_bit[2],
1581                     valueProviderCallback: (_) => {
1582                         Cc_Cfg_Filt_ValueProvider(2, _);
1583                         return cc_cfg_filt_bit[2].Value;
1584                     },
1585                     writeCallback: (_, __) => {
1586                         WriteWSTATIC();
1587                         Cc_Cfg_Filt_Write(2, _, __);
1588                     },
1589 
1590                     readCallback: (_, __) => Cc_Cfg_Filt_Read(2,_, __),
1591                 name: "Filt")
1592             .WithFlag(21, out cc_cfg_icfwl_bit[2],
1593                     valueProviderCallback: (_) => {
1594                         Cc_Cfg_Icfwl_ValueProvider(2, _);
1595                         return cc_cfg_icfwl_bit[2].Value;
1596                     },
1597                     writeCallback: (_, __) => {
1598                         WriteWSTATIC();
1599                         Cc_Cfg_Icfwl_Write(2, _, __);
1600                     },
1601 
1602                     readCallback: (_, __) => Cc_Cfg_Icfwl_Read(2,_, __),
1603                     name: "Icfwl")
1604             .WithReservedBits(22, 10)
1605             .WithReadCallback((_, __) => Cc_Cfg_Read(2, _, __))
1606             .WithWriteCallback((_, __) => Cc_Cfg_Write(2, _, __));
1607 
1608         // Cc2_Ctrl - Offset : 0xA4
GenerateCc2_ctrlRegister()1609         protected DoubleWordRegister  GenerateCc2_ctrlRegister() => new DoubleWordRegister(this, 0x0)
1610             .WithReservedBits(0, 2)
1611             .WithFlag(2, out cc_ctrl_outinv_bit[2],
1612                     valueProviderCallback: (_) => {
1613                         Cc_Ctrl_Outinv_ValueProvider(2, _);
1614                         return cc_ctrl_outinv_bit[2].Value;
1615                     },
1616                     writeCallback: (_, __) => {
1617                         WriteWSYNC();
1618                         Cc_Ctrl_Outinv_Write(2, _, __);
1619                     },
1620 
1621                     readCallback: (_, __) => Cc_Ctrl_Outinv_Read(2,_, __),
1622                     name: "Outinv")
1623             .WithReservedBits(3, 5)
1624             .WithEnumField<DoubleWordRegister, CC_CTRL_CMOA>(8, 2, out cc_ctrl_cmoa_field[2],
1625                     valueProviderCallback: (_) => {
1626                         Cc_Ctrl_Cmoa_ValueProvider(2, _);
1627                         return cc_ctrl_cmoa_field[2].Value;
1628                     },
1629                     writeCallback: (_, __) => {
1630                         WriteWSYNC();
1631                         Cc_Ctrl_Cmoa_Write(2, _, __);
1632                     },
1633 
1634                     readCallback: (_, __) => Cc_Ctrl_Cmoa_Read(2,_, __),
1635                     name: "Cmoa")
1636             .WithEnumField<DoubleWordRegister, CC_CTRL_COFOA>(10, 2, out cc_ctrl_cofoa_field[2],
1637                     valueProviderCallback: (_) => {
1638                         Cc_Ctrl_Cofoa_ValueProvider(2, _);
1639                         return cc_ctrl_cofoa_field[2].Value;
1640                     },
1641                     writeCallback: (_, __) => {
1642                         WriteWSYNC();
1643                         Cc_Ctrl_Cofoa_Write(2, _, __);
1644                     },
1645 
1646                     readCallback: (_, __) => Cc_Ctrl_Cofoa_Read(2,_, __),
1647                     name: "Cofoa")
1648             .WithEnumField<DoubleWordRegister, CC_CTRL_CUFOA>(12, 2, out cc_ctrl_cufoa_field[2],
1649                     valueProviderCallback: (_) => {
1650                         Cc_Ctrl_Cufoa_ValueProvider(2, _);
1651                         return cc_ctrl_cufoa_field[2].Value;
1652                     },
1653                     writeCallback: (_, __) => {
1654                         WriteWSYNC();
1655                         Cc_Ctrl_Cufoa_Write(2, _, __);
1656                     },
1657 
1658                     readCallback: (_, __) => Cc_Ctrl_Cufoa_Read(2,_, __),
1659                     name: "Cufoa")
1660             .WithReservedBits(14, 10)
1661             .WithEnumField<DoubleWordRegister, CC_CTRL_ICEDGE>(24, 2, out cc_ctrl_icedge_field[2],
1662                     valueProviderCallback: (_) => {
1663                         Cc_Ctrl_Icedge_ValueProvider(2, _);
1664                         return cc_ctrl_icedge_field[2].Value;
1665                     },
1666                     writeCallback: (_, __) => {
1667                         WriteWSYNC();
1668                         Cc_Ctrl_Icedge_Write(2, _, __);
1669                     },
1670 
1671                     readCallback: (_, __) => Cc_Ctrl_Icedge_Read(2,_, __),
1672                     name: "Icedge")
1673             .WithEnumField<DoubleWordRegister, CC_CTRL_ICEVCTRL>(26, 2, out cc_ctrl_icevctrl_field[2],
1674                     valueProviderCallback: (_) => {
1675                         Cc_Ctrl_Icevctrl_ValueProvider(2, _);
1676                         return cc_ctrl_icevctrl_field[2].Value;
1677                     },
1678                     writeCallback: (_, __) => {
1679                         WriteWSYNC();
1680                         Cc_Ctrl_Icevctrl_Write(2, _, __);
1681                     },
1682 
1683                     readCallback: (_, __) => Cc_Ctrl_Icevctrl_Read(2,_, __),
1684                     name: "Icevctrl")
1685             .WithReservedBits(28, 4)
1686             .WithReadCallback((_, __) => Cc_Ctrl_Read(2, _, __))
1687             .WithWriteCallback((_, __) => Cc_Ctrl_Write(2, _, __));
1688 
1689         // Cc2_Oc - Offset : 0xA8
GenerateCc2_ocRegister()1690         protected DoubleWordRegister  GenerateCc2_ocRegister() => new DoubleWordRegister(this, 0x0)
1691             .WithValueField(0, 32, out cc_oc_oc_field[2],
1692                     valueProviderCallback: (_) => {
1693                         Cc_Oc_Oc_ValueProvider(2, _);
1694                         return cc_oc_oc_field[2].Value;
1695                     },
1696                     writeCallback: (_, __) => {
1697                         WriteRWSYNC();
1698                         Cc_Oc_Oc_Write(2, _, __);
1699                     },
1700 
1701                     readCallback: (_, __) => Cc_Oc_Oc_Read(2,_, __),
1702                     name: "Oc")
1703             .WithReadCallback((_, __) => Cc_Oc_Read(2, _, __))
1704             .WithWriteCallback((_, __) => Cc_Oc_Write(2, _, __));
1705 
1706         // Cc2_Ocb - Offset : 0xB0
GenerateCc2_ocbRegister()1707         protected DoubleWordRegister  GenerateCc2_ocbRegister() => new DoubleWordRegister(this, 0x0)
1708             .WithValueField(0, 32, out cc_ocb_ocb_field[2],
1709                     valueProviderCallback: (_) => {
1710                         Cc_Ocb_Ocb_ValueProvider(2, _);
1711                         return cc_ocb_ocb_field[2].Value;
1712                     },
1713                     writeCallback: (_, __) => {
1714                         WriteWSYNC();
1715                         Cc_Ocb_Ocb_Write(2, _, __);
1716                     },
1717 
1718                     readCallback: (_, __) => Cc_Ocb_Ocb_Read(2,_, __),
1719                     name: "Ocb")
1720             .WithReadCallback((_, __) => Cc_Ocb_Read(2, _, __))
1721             .WithWriteCallback((_, __) => Cc_Ocb_Write(2, _, __));
1722 
1723         // Cc2_Icf - Offset : 0xB4
GenerateCc2_icfRegister()1724         protected DoubleWordRegister  GenerateCc2_icfRegister() => new DoubleWordRegister(this, 0x0)
1725             .WithValueField(0, 32, out cc_icf_icf_field[2], FieldMode.Read,
1726                     valueProviderCallback: (_) => {
1727                         Cc_Icf_Icf_ValueProvider(2, _);
1728                         return ReadRFIFO();
1729                     },
1730 
1731                     readCallback: (_, __) => Cc_Icf_Icf_Read(2,_, __),
1732                     name: "Icf")
1733             .WithReadCallback((_, __) => Cc_Icf_Read(2, _, __))
1734             .WithWriteCallback((_, __) => Cc_Icf_Write(2, _, __));
1735 
1736         // Cc2_Icof - Offset : 0xB8
GenerateCc2_icofRegister()1737         protected DoubleWordRegister  GenerateCc2_icofRegister() => new DoubleWordRegister(this, 0x0)
1738             .WithValueField(0, 32, out cc_icof_icof_field[2], FieldMode.Read,
1739                     valueProviderCallback: (_) => {
1740                         Cc_Icof_Icof_ValueProvider(2, _);
1741                         return cc_icof_icof_field[2].Value;
1742                     },
1743 
1744                     readCallback: (_, __) => Cc_Icof_Icof_Read(2,_, __),
1745                     name: "Icof")
1746             .WithReadCallback((_, __) => Cc_Icof_Read(2, _, __))
1747             .WithWriteCallback((_, __) => Cc_Icof_Write(2, _, __));
1748 
1749         // DtCfg - Offset : 0xE0
GenerateDtcfgRegister()1750         protected DoubleWordRegister  GenerateDtcfgRegister() => new DoubleWordRegister(this, 0x0)
1751             .WithFlag(0, out dtcfg_dten_bit,
1752                     valueProviderCallback: (_) => {
1753                         DtCfg_Dten_ValueProvider(_);
1754                         return dtcfg_dten_bit.Value;
1755                     },
1756                     writeCallback: (_, __) => {
1757                         WriteWSTATIC();
1758                         DtCfg_Dten_Write(_, __);
1759                     },
1760 
1761                     readCallback: (_, __) => DtCfg_Dten_Read(_, __),
1762                     name: "Dten")
1763             .WithEnumField<DoubleWordRegister, DTCFG_DTDAS>(1, 1, out dtcfg_dtdas_bit,
1764                     valueProviderCallback: (_) => {
1765                         DtCfg_Dtdas_ValueProvider(_);
1766                         return dtcfg_dtdas_bit.Value;
1767                     },
1768                     writeCallback: (_, __) => {
1769                         WriteWSTATIC();
1770                         DtCfg_Dtdas_Write(_, __);
1771                     },
1772 
1773                     readCallback: (_, __) => DtCfg_Dtdas_Read(_, __),
1774                     name: "Dtdas")
1775             .WithReservedBits(2, 7)
1776             .WithFlag(9, out dtcfg_dtar_bit,
1777                     valueProviderCallback: (_) => {
1778                         DtCfg_Dtar_ValueProvider(_);
1779                         return dtcfg_dtar_bit.Value;
1780                     },
1781                     writeCallback: (_, __) => {
1782                         WriteWSTATIC();
1783                         DtCfg_Dtar_Write(_, __);
1784                     },
1785 
1786                     readCallback: (_, __) => DtCfg_Dtar_Read(_, __),
1787                     name: "Dtar")
1788             .WithFlag(10, out dtcfg_dtfats_bit,
1789                     valueProviderCallback: (_) => {
1790                         DtCfg_Dtfats_ValueProvider(_);
1791                         return dtcfg_dtfats_bit.Value;
1792                     },
1793                     writeCallback: (_, __) => {
1794                         WriteWSTATIC();
1795                         DtCfg_Dtfats_Write(_, __);
1796                     },
1797 
1798                     readCallback: (_, __) => DtCfg_Dtfats_Read(_, __),
1799                     name: "Dtfats")
1800             .WithFlag(11, out dtcfg_dtprsen_bit,
1801                     valueProviderCallback: (_) => {
1802                         DtCfg_Dtprsen_ValueProvider(_);
1803                         return dtcfg_dtprsen_bit.Value;
1804                     },
1805                     writeCallback: (_, __) => {
1806                         WriteWSTATIC();
1807                         DtCfg_Dtprsen_Write(_, __);
1808                     },
1809 
1810                     readCallback: (_, __) => DtCfg_Dtprsen_Read(_, __),
1811                     name: "Dtprsen")
1812             .WithReservedBits(12, 20)
1813             .WithReadCallback((_, __) => DtCfg_Read(_, __))
1814             .WithWriteCallback((_, __) => DtCfg_Write(_, __));
1815 
1816         // DtTimecfg - Offset : 0xE4
GenerateDttimecfgRegister()1817         protected DoubleWordRegister  GenerateDttimecfgRegister() => new DoubleWordRegister(this, 0x0)
1818 
1819             .WithValueField(0, 10, out dttimecfg_dtpresc_field,
1820                     valueProviderCallback: (_) => {
1821                         DtTimecfg_Dtpresc_ValueProvider(_);
1822                         return dttimecfg_dtpresc_field.Value;
1823                     },
1824                     writeCallback: (_, __) => {
1825                         WriteWSTATIC();
1826                         DtTimecfg_Dtpresc_Write(_, __);
1827                     },
1828 
1829                     readCallback: (_, __) => DtTimecfg_Dtpresc_Read(_, __),
1830                     name: "Dtpresc")
1831 
1832             .WithValueField(10, 6, out dttimecfg_dtriset_field,
1833                     valueProviderCallback: (_) => {
1834                         DtTimecfg_Dtriset_ValueProvider(_);
1835                         return dttimecfg_dtriset_field.Value;
1836                     },
1837                     writeCallback: (_, __) => {
1838                         WriteWSTATIC();
1839                         DtTimecfg_Dtriset_Write(_, __);
1840                     },
1841 
1842                     readCallback: (_, __) => DtTimecfg_Dtriset_Read(_, __),
1843                     name: "Dtriset")
1844 
1845             .WithValueField(16, 6, out dttimecfg_dtfallt_field,
1846                     valueProviderCallback: (_) => {
1847                         DtTimecfg_Dtfallt_ValueProvider(_);
1848                         return dttimecfg_dtfallt_field.Value;
1849                     },
1850                     writeCallback: (_, __) => {
1851                         WriteWSTATIC();
1852                         DtTimecfg_Dtfallt_Write(_, __);
1853                     },
1854 
1855                     readCallback: (_, __) => DtTimecfg_Dtfallt_Read(_, __),
1856                     name: "Dtfallt")
1857             .WithReservedBits(22, 10)
1858             .WithReadCallback((_, __) => DtTimecfg_Read(_, __))
1859             .WithWriteCallback((_, __) => DtTimecfg_Write(_, __));
1860 
1861         // DtFcfg - Offset : 0xE8
GenerateDtfcfgRegister()1862         protected DoubleWordRegister  GenerateDtfcfgRegister() => new DoubleWordRegister(this, 0x0)
1863             .WithReservedBits(0, 16)
1864             .WithEnumField<DoubleWordRegister, DTFCFG_DTFA>(16, 2, out dtfcfg_dtfa_field,
1865                     valueProviderCallback: (_) => {
1866                         DtFcfg_Dtfa_ValueProvider(_);
1867                         return dtfcfg_dtfa_field.Value;
1868                     },
1869                     writeCallback: (_, __) => {
1870                         WriteWSTATIC();
1871                         DtFcfg_Dtfa_Write(_, __);
1872                     },
1873 
1874                     readCallback: (_, __) => DtFcfg_Dtfa_Read(_, __),
1875                     name: "Dtfa")
1876             .WithReservedBits(18, 6)
1877             .WithFlag(24, out dtfcfg_dtprs0fen_bit,
1878                     valueProviderCallback: (_) => {
1879                         DtFcfg_Dtprs0fen_ValueProvider(_);
1880                         return dtfcfg_dtprs0fen_bit.Value;
1881                     },
1882                     writeCallback: (_, __) => {
1883                         WriteWSTATIC();
1884                         DtFcfg_Dtprs0fen_Write(_, __);
1885                     },
1886 
1887                     readCallback: (_, __) => DtFcfg_Dtprs0fen_Read(_, __),
1888                     name: "Dtprs0fen")
1889             .WithFlag(25, out dtfcfg_dtprs1fen_bit,
1890                     valueProviderCallback: (_) => {
1891                         DtFcfg_Dtprs1fen_ValueProvider(_);
1892                         return dtfcfg_dtprs1fen_bit.Value;
1893                     },
1894                     writeCallback: (_, __) => {
1895                         WriteWSTATIC();
1896                         DtFcfg_Dtprs1fen_Write(_, __);
1897                     },
1898 
1899                     readCallback: (_, __) => DtFcfg_Dtprs1fen_Read(_, __),
1900                     name: "Dtprs1fen")
1901             .WithFlag(26, out dtfcfg_dtdbgfen_bit,
1902                     valueProviderCallback: (_) => {
1903                         DtFcfg_Dtdbgfen_ValueProvider(_);
1904                         return dtfcfg_dtdbgfen_bit.Value;
1905                     },
1906                     writeCallback: (_, __) => {
1907                         WriteWSTATIC();
1908                         DtFcfg_Dtdbgfen_Write(_, __);
1909                     },
1910 
1911                     readCallback: (_, __) => DtFcfg_Dtdbgfen_Read(_, __),
1912                     name: "Dtdbgfen")
1913             .WithFlag(27, out dtfcfg_dtlockupfen_bit,
1914                     valueProviderCallback: (_) => {
1915                         DtFcfg_Dtlockupfen_ValueProvider(_);
1916                         return dtfcfg_dtlockupfen_bit.Value;
1917                     },
1918                     writeCallback: (_, __) => {
1919                         WriteWSTATIC();
1920                         DtFcfg_Dtlockupfen_Write(_, __);
1921                     },
1922 
1923                     readCallback: (_, __) => DtFcfg_Dtlockupfen_Read(_, __),
1924                     name: "Dtlockupfen")
1925             .WithFlag(28, out dtfcfg_dtem23fen_bit,
1926                     valueProviderCallback: (_) => {
1927                         DtFcfg_Dtem23fen_ValueProvider(_);
1928                         return dtfcfg_dtem23fen_bit.Value;
1929                     },
1930                     writeCallback: (_, __) => {
1931                         WriteWSTATIC();
1932                         DtFcfg_Dtem23fen_Write(_, __);
1933                     },
1934 
1935                     readCallback: (_, __) => DtFcfg_Dtem23fen_Read(_, __),
1936                     name: "Dtem23fen")
1937             .WithReservedBits(29, 3)
1938             .WithReadCallback((_, __) => DtFcfg_Read(_, __))
1939             .WithWriteCallback((_, __) => DtFcfg_Write(_, __));
1940 
1941         // DtCtrl - Offset : 0xEC
GenerateDtctrlRegister()1942         protected DoubleWordRegister  GenerateDtctrlRegister() => new DoubleWordRegister(this, 0x0)
1943             .WithFlag(0, out dtctrl_dtcinv_bit,
1944                     valueProviderCallback: (_) => {
1945                         DtCtrl_Dtcinv_ValueProvider(_);
1946                         return dtctrl_dtcinv_bit.Value;
1947                     },
1948                     writeCallback: (_, __) => {
1949                         WriteWSYNC();
1950                         DtCtrl_Dtcinv_Write(_, __);
1951                     },
1952 
1953                     readCallback: (_, __) => DtCtrl_Dtcinv_Read(_, __),
1954                     name: "Dtcinv")
1955             .WithFlag(1, out dtctrl_dtipol_bit,
1956                     valueProviderCallback: (_) => {
1957                         DtCtrl_Dtipol_ValueProvider(_);
1958                         return dtctrl_dtipol_bit.Value;
1959                     },
1960                     writeCallback: (_, __) => {
1961                         WriteWSYNC();
1962                         DtCtrl_Dtipol_Write(_, __);
1963                     },
1964 
1965                     readCallback: (_, __) => DtCtrl_Dtipol_Read(_, __),
1966                     name: "Dtipol")
1967             .WithReservedBits(2, 30)
1968             .WithReadCallback((_, __) => DtCtrl_Read(_, __))
1969             .WithWriteCallback((_, __) => DtCtrl_Write(_, __));
1970 
1971         // DtOgen - Offset : 0xF0
GenerateDtogenRegister()1972         protected DoubleWordRegister  GenerateDtogenRegister() => new DoubleWordRegister(this, 0x0)
1973             .WithFlag(0, out dtogen_dtogcc0en_bit,
1974                     valueProviderCallback: (_) => {
1975                         DtOgen_Dtogcc0en_ValueProvider(_);
1976                         return dtogen_dtogcc0en_bit.Value;
1977                     },
1978                     writeCallback: (_, __) => {
1979                         WriteWSYNC();
1980                         DtOgen_Dtogcc0en_Write(_, __);
1981                     },
1982 
1983                     readCallback: (_, __) => DtOgen_Dtogcc0en_Read(_, __),
1984                     name: "Dtogcc0en")
1985             .WithFlag(1, out dtogen_dtogcc1en_bit,
1986                     valueProviderCallback: (_) => {
1987                         DtOgen_Dtogcc1en_ValueProvider(_);
1988                         return dtogen_dtogcc1en_bit.Value;
1989                     },
1990                     writeCallback: (_, __) => {
1991                         WriteWSYNC();
1992                         DtOgen_Dtogcc1en_Write(_, __);
1993                     },
1994 
1995                     readCallback: (_, __) => DtOgen_Dtogcc1en_Read(_, __),
1996                     name: "Dtogcc1en")
1997             .WithFlag(2, out dtogen_dtogcc2en_bit,
1998                     valueProviderCallback: (_) => {
1999                         DtOgen_Dtogcc2en_ValueProvider(_);
2000                         return dtogen_dtogcc2en_bit.Value;
2001                     },
2002                     writeCallback: (_, __) => {
2003                         WriteWSYNC();
2004                         DtOgen_Dtogcc2en_Write(_, __);
2005                     },
2006 
2007                     readCallback: (_, __) => DtOgen_Dtogcc2en_Read(_, __),
2008                     name: "Dtogcc2en")
2009             .WithFlag(3, out dtogen_dtogcdti0en_bit,
2010                     valueProviderCallback: (_) => {
2011                         DtOgen_Dtogcdti0en_ValueProvider(_);
2012                         return dtogen_dtogcdti0en_bit.Value;
2013                     },
2014                     writeCallback: (_, __) => {
2015                         WriteWSYNC();
2016                         DtOgen_Dtogcdti0en_Write(_, __);
2017                     },
2018 
2019                     readCallback: (_, __) => DtOgen_Dtogcdti0en_Read(_, __),
2020                     name: "Dtogcdti0en")
2021             .WithFlag(4, out dtogen_dtogcdti1en_bit,
2022                     valueProviderCallback: (_) => {
2023                         DtOgen_Dtogcdti1en_ValueProvider(_);
2024                         return dtogen_dtogcdti1en_bit.Value;
2025                     },
2026                     writeCallback: (_, __) => {
2027                         WriteWSYNC();
2028                         DtOgen_Dtogcdti1en_Write(_, __);
2029                     },
2030 
2031                     readCallback: (_, __) => DtOgen_Dtogcdti1en_Read(_, __),
2032                     name: "Dtogcdti1en")
2033             .WithFlag(5, out dtogen_dtogcdti2en_bit,
2034                     valueProviderCallback: (_) => {
2035                         DtOgen_Dtogcdti2en_ValueProvider(_);
2036                         return dtogen_dtogcdti2en_bit.Value;
2037                     },
2038                     writeCallback: (_, __) => {
2039                         WriteWSYNC();
2040                         DtOgen_Dtogcdti2en_Write(_, __);
2041                     },
2042 
2043                     readCallback: (_, __) => DtOgen_Dtogcdti2en_Read(_, __),
2044                     name: "Dtogcdti2en")
2045             .WithReservedBits(6, 26)
2046             .WithReadCallback((_, __) => DtOgen_Read(_, __))
2047             .WithWriteCallback((_, __) => DtOgen_Write(_, __));
2048 
2049         // DtFault - Offset : 0xF4
GenerateDtfaultRegister()2050         protected DoubleWordRegister  GenerateDtfaultRegister() => new DoubleWordRegister(this, 0x0)
2051             .WithFlag(0, out dtfault_dtprs0f_bit, FieldMode.Read,
2052                     valueProviderCallback: (_) => {
2053                         DtFault_Dtprs0f_ValueProvider(_);
2054                         return dtfault_dtprs0f_bit.Value;
2055                     },
2056 
2057                     readCallback: (_, __) => DtFault_Dtprs0f_Read(_, __),
2058                     name: "Dtprs0f")
2059             .WithFlag(1, out dtfault_dtprs1f_bit, FieldMode.Read,
2060                     valueProviderCallback: (_) => {
2061                         DtFault_Dtprs1f_ValueProvider(_);
2062                         return dtfault_dtprs1f_bit.Value;
2063                     },
2064 
2065                     readCallback: (_, __) => DtFault_Dtprs1f_Read(_, __),
2066                     name: "Dtprs1f")
2067             .WithFlag(2, out dtfault_dtdbgf_bit, FieldMode.Read,
2068                     valueProviderCallback: (_) => {
2069                         DtFault_Dtdbgf_ValueProvider(_);
2070                         return dtfault_dtdbgf_bit.Value;
2071                     },
2072 
2073                     readCallback: (_, __) => DtFault_Dtdbgf_Read(_, __),
2074                     name: "Dtdbgf")
2075             .WithFlag(3, out dtfault_dtlockupf_bit, FieldMode.Read,
2076                     valueProviderCallback: (_) => {
2077                         DtFault_Dtlockupf_ValueProvider(_);
2078                         return dtfault_dtlockupf_bit.Value;
2079                     },
2080 
2081                     readCallback: (_, __) => DtFault_Dtlockupf_Read(_, __),
2082                     name: "Dtlockupf")
2083             .WithFlag(4, out dtfault_dtem23f_bit, FieldMode.Read,
2084                     valueProviderCallback: (_) => {
2085                         DtFault_Dtem23f_ValueProvider(_);
2086                         return dtfault_dtem23f_bit.Value;
2087                     },
2088 
2089                     readCallback: (_, __) => DtFault_Dtem23f_Read(_, __),
2090                     name: "Dtem23f")
2091             .WithReservedBits(5, 27)
2092             .WithReadCallback((_, __) => DtFault_Read(_, __))
2093             .WithWriteCallback((_, __) => DtFault_Write(_, __));
2094 
2095         // DtFaultc - Offset : 0xF8
GenerateDtfaultcRegister()2096         protected DoubleWordRegister  GenerateDtfaultcRegister() => new DoubleWordRegister(this, 0x0)
2097             .WithFlag(0, out dtfaultc_dtprs0fc_bit, FieldMode.Write,
2098                     writeCallback: (_, __) => {
2099                         WriteWSYNC();
2100                         DtFaultc_Dtprs0fc_Write(_, __);
2101                     },
2102                     name: "Dtprs0fc")
2103             .WithFlag(1, out dtfaultc_dtprs1fc_bit, FieldMode.Write,
2104                     writeCallback: (_, __) => {
2105                         WriteWSYNC();
2106                         DtFaultc_Dtprs1fc_Write(_, __);
2107                     },
2108                     name: "Dtprs1fc")
2109             .WithFlag(2, out dtfaultc_dtdbgfc_bit, FieldMode.Write,
2110                     writeCallback: (_, __) => {
2111                         WriteWSYNC();
2112                         DtFaultc_Dtdbgfc_Write(_, __);
2113                     },
2114                     name: "Dtdbgfc")
2115             .WithFlag(3, out dtfaultc_dtlockupfc_bit, FieldMode.Write,
2116                     writeCallback: (_, __) => {
2117                         WriteWSYNC();
2118                         DtFaultc_Dtlockupfc_Write(_, __);
2119                     },
2120                     name: "Dtlockupfc")
2121             .WithFlag(4, out dtfaultc_dtem23fc_bit, FieldMode.Write,
2122                     writeCallback: (_, __) => {
2123                         WriteWSYNC();
2124                         DtFaultc_Dtem23fc_Write(_, __);
2125                     },
2126                     name: "Dtem23fc")
2127             .WithReservedBits(5, 27)
2128             .WithReadCallback((_, __) => DtFaultc_Read(_, __))
2129             .WithWriteCallback((_, __) => DtFaultc_Write(_, __));
2130 
2131         // DtLock - Offset : 0xFC
GenerateDtlockRegister()2132         protected DoubleWordRegister  GenerateDtlockRegister() => new DoubleWordRegister(this, 0x0)
2133             .WithEnumField<DoubleWordRegister, DTLOCK_DTILOCKKEY>(0, 16, out dtlock_dtilockkey_field, FieldMode.Write,
2134 
2135                     writeCallback: (_, __) => DtLock_Dtilockkey_Write(_, __),
2136                     name: "Dtilockkey")
2137             .WithReservedBits(16, 16)
2138             .WithReadCallback((_, __) => DtLock_Read(_, __))
2139             .WithWriteCallback((_, __) => DtLock_Write(_, __));
2140 
2141 
ReadWFIFO()2142         private uint ReadWFIFO()
2143         {
2144             this.Log(LogLevel.Warning, "Reading from a WFIFO Field, value returned will always be 0");
2145             return 0x0;
2146         }
2147 
ReadLFWSYNC()2148         private uint ReadLFWSYNC()
2149         {
2150             this.Log(LogLevel.Warning, "Reading from a LFWSYNC/HVLFWSYNC Field, value returned will always be 0");
2151             return 0x0;
2152         }
2153 
ReadRFIFO()2154         private uint ReadRFIFO()
2155         {
2156             this.Log(LogLevel.Warning, "Reading from a RFIFO Field, value returned will always be 0");
2157             return 0x0;
2158         }
2159 
2160 
WriteWSTATIC()2161         private void WriteWSTATIC()
2162         {
2163             if(Enabled)
2164             {
2165                 this.Log(LogLevel.Error, "Trying to write to a WSTATIC register while peripheral is enabled EN = {0}", Enabled);
2166             }
2167         }
2168 
WriteWSYNC()2169         private void WriteWSYNC()
2170         {
2171             if(!Enabled)
2172             {
2173                 this.Log(LogLevel.Error, "Trying to write to a WSYNC register while peripheral is disabled EN = {0}", Enabled);
2174             }
2175         }
2176 
WriteRWSYNC()2177         private void WriteRWSYNC()
2178         {
2179             if(!Enabled)
2180             {
2181                 this.Log(LogLevel.Error, "Trying to write to a RWSYNC register while peripheral is disabled EN = {0}", Enabled);
2182             }
2183         }
2184 
2185 
2186         // Ipversion - Offset : 0x0
2187 
2188         protected IValueRegisterField ipversion_ipversion_field;
Ipversion_Ipversion_Read(ulong a, ulong b)2189         partial void Ipversion_Ipversion_Read(ulong a, ulong b);
Ipversion_Ipversion_ValueProvider(ulong a)2190         partial void Ipversion_Ipversion_ValueProvider(ulong a);
Ipversion_Write(uint a, uint b)2191         partial void Ipversion_Write(uint a, uint b);
Ipversion_Read(uint a, uint b)2192         partial void Ipversion_Read(uint a, uint b);
2193 
2194         // Cfg - Offset : 0x4
2195 
2196         protected IEnumRegisterField<CFG_MODE> cfg_mode_field;
Cfg_Mode_Write(CFG_MODE a, CFG_MODE b)2197         partial void Cfg_Mode_Write(CFG_MODE a, CFG_MODE b);
Cfg_Mode_Read(CFG_MODE a, CFG_MODE b)2198         partial void Cfg_Mode_Read(CFG_MODE a, CFG_MODE b);
Cfg_Mode_ValueProvider(CFG_MODE a)2199         partial void Cfg_Mode_ValueProvider(CFG_MODE a);
2200 
2201         protected IEnumRegisterField<CFG_SYNC> cfg_sync_bit;
Cfg_Sync_Write(CFG_SYNC a, CFG_SYNC b)2202         partial void Cfg_Sync_Write(CFG_SYNC a, CFG_SYNC b);
Cfg_Sync_Read(CFG_SYNC a, CFG_SYNC b)2203         partial void Cfg_Sync_Read(CFG_SYNC a, CFG_SYNC b);
Cfg_Sync_ValueProvider(CFG_SYNC a)2204         partial void Cfg_Sync_ValueProvider(CFG_SYNC a);
2205 
2206         protected IFlagRegisterField cfg_osmen_bit;
Cfg_Osmen_Write(bool a, bool b)2207         partial void Cfg_Osmen_Write(bool a, bool b);
Cfg_Osmen_Read(bool a, bool b)2208         partial void Cfg_Osmen_Read(bool a, bool b);
Cfg_Osmen_ValueProvider(bool a)2209         partial void Cfg_Osmen_ValueProvider(bool a);
2210 
2211         protected IEnumRegisterField<CFG_QDM> cfg_qdm_bit;
Cfg_Qdm_Write(CFG_QDM a, CFG_QDM b)2212         partial void Cfg_Qdm_Write(CFG_QDM a, CFG_QDM b);
Cfg_Qdm_Read(CFG_QDM a, CFG_QDM b)2213         partial void Cfg_Qdm_Read(CFG_QDM a, CFG_QDM b);
Cfg_Qdm_ValueProvider(CFG_QDM a)2214         partial void Cfg_Qdm_ValueProvider(CFG_QDM a);
2215 
2216         protected IEnumRegisterField<CFG_DEBUGRUN> cfg_debugrun_bit;
Cfg_Debugrun_Write(CFG_DEBUGRUN a, CFG_DEBUGRUN b)2217         partial void Cfg_Debugrun_Write(CFG_DEBUGRUN a, CFG_DEBUGRUN b);
Cfg_Debugrun_Read(CFG_DEBUGRUN a, CFG_DEBUGRUN b)2218         partial void Cfg_Debugrun_Read(CFG_DEBUGRUN a, CFG_DEBUGRUN b);
Cfg_Debugrun_ValueProvider(CFG_DEBUGRUN a)2219         partial void Cfg_Debugrun_ValueProvider(CFG_DEBUGRUN a);
2220 
2221         protected IFlagRegisterField cfg_dmaclract_bit;
Cfg_Dmaclract_Write(bool a, bool b)2222         partial void Cfg_Dmaclract_Write(bool a, bool b);
Cfg_Dmaclract_Read(bool a, bool b)2223         partial void Cfg_Dmaclract_Read(bool a, bool b);
Cfg_Dmaclract_ValueProvider(bool a)2224         partial void Cfg_Dmaclract_ValueProvider(bool a);
2225 
2226         protected IEnumRegisterField<CFG_CLKSEL> cfg_clksel_field;
Cfg_Clksel_Write(CFG_CLKSEL a, CFG_CLKSEL b)2227         partial void Cfg_Clksel_Write(CFG_CLKSEL a, CFG_CLKSEL b);
Cfg_Clksel_Read(CFG_CLKSEL a, CFG_CLKSEL b)2228         partial void Cfg_Clksel_Read(CFG_CLKSEL a, CFG_CLKSEL b);
Cfg_Clksel_ValueProvider(CFG_CLKSEL a)2229         partial void Cfg_Clksel_ValueProvider(CFG_CLKSEL a);
2230 
2231         protected IEnumRegisterField<CFG_RETIMEEN> cfg_retimeen_bit;
Cfg_Retimeen_Write(CFG_RETIMEEN a, CFG_RETIMEEN b)2232         partial void Cfg_Retimeen_Write(CFG_RETIMEEN a, CFG_RETIMEEN b);
Cfg_Retimeen_Read(CFG_RETIMEEN a, CFG_RETIMEEN b)2233         partial void Cfg_Retimeen_Read(CFG_RETIMEEN a, CFG_RETIMEEN b);
Cfg_Retimeen_ValueProvider(CFG_RETIMEEN a)2234         partial void Cfg_Retimeen_ValueProvider(CFG_RETIMEEN a);
2235 
2236         protected IEnumRegisterField<CFG_DISSYNCOUT> cfg_dissyncout_bit;
Cfg_Dissyncout_Write(CFG_DISSYNCOUT a, CFG_DISSYNCOUT b)2237         partial void Cfg_Dissyncout_Write(CFG_DISSYNCOUT a, CFG_DISSYNCOUT b);
Cfg_Dissyncout_Read(CFG_DISSYNCOUT a, CFG_DISSYNCOUT b)2238         partial void Cfg_Dissyncout_Read(CFG_DISSYNCOUT a, CFG_DISSYNCOUT b);
Cfg_Dissyncout_ValueProvider(CFG_DISSYNCOUT a)2239         partial void Cfg_Dissyncout_ValueProvider(CFG_DISSYNCOUT a);
2240 
2241         protected IFlagRegisterField cfg_retimesel_bit;
Cfg_Retimesel_Write(bool a, bool b)2242         partial void Cfg_Retimesel_Write(bool a, bool b);
Cfg_Retimesel_Read(bool a, bool b)2243         partial void Cfg_Retimesel_Read(bool a, bool b);
Cfg_Retimesel_ValueProvider(bool a)2244         partial void Cfg_Retimesel_ValueProvider(bool a);
2245 
2246         protected IFlagRegisterField cfg_ati_bit;
Cfg_Ati_Write(bool a, bool b)2247         partial void Cfg_Ati_Write(bool a, bool b);
Cfg_Ati_Read(bool a, bool b)2248         partial void Cfg_Ati_Read(bool a, bool b);
Cfg_Ati_ValueProvider(bool a)2249         partial void Cfg_Ati_ValueProvider(bool a);
2250 
2251         protected IFlagRegisterField cfg_rsscoist_bit;
Cfg_Rsscoist_Write(bool a, bool b)2252         partial void Cfg_Rsscoist_Write(bool a, bool b);
Cfg_Rsscoist_Read(bool a, bool b)2253         partial void Cfg_Rsscoist_Read(bool a, bool b);
Cfg_Rsscoist_ValueProvider(bool a)2254         partial void Cfg_Rsscoist_ValueProvider(bool a);
2255 
2256         protected IEnumRegisterField<CFG_PRESC> cfg_presc_field;
Cfg_Presc_Write(CFG_PRESC a, CFG_PRESC b)2257         partial void Cfg_Presc_Write(CFG_PRESC a, CFG_PRESC b);
Cfg_Presc_Read(CFG_PRESC a, CFG_PRESC b)2258         partial void Cfg_Presc_Read(CFG_PRESC a, CFG_PRESC b);
Cfg_Presc_ValueProvider(CFG_PRESC a)2259         partial void Cfg_Presc_ValueProvider(CFG_PRESC a);
Cfg_Write_WithHook(uint a, uint b)2260         protected void Cfg_Write_WithHook(uint a, uint b)
2261         {
2262             if (status_timerlockstatus_bit.Value == STATUS_TIMERLOCKSTATUS.LOCKED)
2263             {
2264                 this.Log(LogLevel.Error, "Cfg: Write access to a locked register");
2265             }
2266             Cfg_Write(a, b);
2267         }
Cfg_Write(uint a, uint b)2268         partial void Cfg_Write(uint a, uint b);
Cfg_Read(uint a, uint b)2269         partial void Cfg_Read(uint a, uint b);
2270 
2271         // Ctrl - Offset : 0x8
2272 
2273         protected IEnumRegisterField<CTRL_RISEA> ctrl_risea_field;
Ctrl_Risea_Write(CTRL_RISEA a, CTRL_RISEA b)2274         partial void Ctrl_Risea_Write(CTRL_RISEA a, CTRL_RISEA b);
Ctrl_Risea_Read(CTRL_RISEA a, CTRL_RISEA b)2275         partial void Ctrl_Risea_Read(CTRL_RISEA a, CTRL_RISEA b);
Ctrl_Risea_ValueProvider(CTRL_RISEA a)2276         partial void Ctrl_Risea_ValueProvider(CTRL_RISEA a);
2277 
2278         protected IEnumRegisterField<CTRL_FALLA> ctrl_falla_field;
Ctrl_Falla_Write(CTRL_FALLA a, CTRL_FALLA b)2279         partial void Ctrl_Falla_Write(CTRL_FALLA a, CTRL_FALLA b);
Ctrl_Falla_Read(CTRL_FALLA a, CTRL_FALLA b)2280         partial void Ctrl_Falla_Read(CTRL_FALLA a, CTRL_FALLA b);
Ctrl_Falla_ValueProvider(CTRL_FALLA a)2281         partial void Ctrl_Falla_ValueProvider(CTRL_FALLA a);
2282 
2283         protected IFlagRegisterField ctrl_x2cnt_bit;
Ctrl_X2cnt_Write(bool a, bool b)2284         partial void Ctrl_X2cnt_Write(bool a, bool b);
Ctrl_X2cnt_Read(bool a, bool b)2285         partial void Ctrl_X2cnt_Read(bool a, bool b);
Ctrl_X2cnt_ValueProvider(bool a)2286         partial void Ctrl_X2cnt_ValueProvider(bool a);
Ctrl_Write_WithHook(uint a, uint b)2287         protected void Ctrl_Write_WithHook(uint a, uint b)
2288         {
2289             if (status_timerlockstatus_bit.Value == STATUS_TIMERLOCKSTATUS.LOCKED)
2290             {
2291                 this.Log(LogLevel.Error, "Ctrl: Write access to a locked register");
2292             }
2293             Ctrl_Write(a, b);
2294         }
Ctrl_Write(uint a, uint b)2295         partial void Ctrl_Write(uint a, uint b);
Ctrl_Read(uint a, uint b)2296         partial void Ctrl_Read(uint a, uint b);
2297 
2298         // Cmd - Offset : 0xC
2299 
2300         protected IFlagRegisterField cmd_start_bit;
Cmd_Start_Write(bool a, bool b)2301         partial void Cmd_Start_Write(bool a, bool b);
Cmd_Start_ValueProvider(bool a)2302         partial void Cmd_Start_ValueProvider(bool a);
2303 
2304         protected IFlagRegisterField cmd_stop_bit;
Cmd_Stop_Write(bool a, bool b)2305         partial void Cmd_Stop_Write(bool a, bool b);
Cmd_Stop_ValueProvider(bool a)2306         partial void Cmd_Stop_ValueProvider(bool a);
Cmd_Write_WithHook(uint a, uint b)2307         protected void Cmd_Write_WithHook(uint a, uint b)
2308         {
2309             if (status_timerlockstatus_bit.Value == STATUS_TIMERLOCKSTATUS.LOCKED)
2310             {
2311                 this.Log(LogLevel.Error, "Cmd: Write access to a locked register");
2312             }
2313             Cmd_Write(a, b);
2314         }
Cmd_Write(uint a, uint b)2315         partial void Cmd_Write(uint a, uint b);
Cmd_Read(uint a, uint b)2316         partial void Cmd_Read(uint a, uint b);
2317 
2318         // Status - Offset : 0x10
2319 
2320         protected IFlagRegisterField status_running_bit;
Status_Running_Read(bool a, bool b)2321         partial void Status_Running_Read(bool a, bool b);
Status_Running_ValueProvider(bool a)2322         partial void Status_Running_ValueProvider(bool a);
2323 
2324         protected IEnumRegisterField<STATUS_DIR> status_dir_bit;
Status_Dir_Read(STATUS_DIR a, STATUS_DIR b)2325         partial void Status_Dir_Read(STATUS_DIR a, STATUS_DIR b);
Status_Dir_ValueProvider(STATUS_DIR a)2326         partial void Status_Dir_ValueProvider(STATUS_DIR a);
2327 
2328         protected IFlagRegisterField status_topbv_bit;
Status_Topbv_Read(bool a, bool b)2329         partial void Status_Topbv_Read(bool a, bool b);
Status_Topbv_ValueProvider(bool a)2330         partial void Status_Topbv_ValueProvider(bool a);
2331 
2332         protected IEnumRegisterField<STATUS_TIMERLOCKSTATUS> status_timerlockstatus_bit;
Status_Timerlockstatus_Read(STATUS_TIMERLOCKSTATUS a, STATUS_TIMERLOCKSTATUS b)2333         partial void Status_Timerlockstatus_Read(STATUS_TIMERLOCKSTATUS a, STATUS_TIMERLOCKSTATUS b);
Status_Timerlockstatus_ValueProvider(STATUS_TIMERLOCKSTATUS a)2334         partial void Status_Timerlockstatus_ValueProvider(STATUS_TIMERLOCKSTATUS a);
2335 
2336         protected IEnumRegisterField<STATUS_DTILOCKSTATUS> status_dtilockstatus_bit;
Status_Dtilockstatus_Read(STATUS_DTILOCKSTATUS a, STATUS_DTILOCKSTATUS b)2337         partial void Status_Dtilockstatus_Read(STATUS_DTILOCKSTATUS a, STATUS_DTILOCKSTATUS b);
Status_Dtilockstatus_ValueProvider(STATUS_DTILOCKSTATUS a)2338         partial void Status_Dtilockstatus_ValueProvider(STATUS_DTILOCKSTATUS a);
2339 
2340         protected IFlagRegisterField status_syncbusy_bit;
Status_Syncbusy_Read(bool a, bool b)2341         partial void Status_Syncbusy_Read(bool a, bool b);
Status_Syncbusy_ValueProvider(bool a)2342         partial void Status_Syncbusy_ValueProvider(bool a);
2343 
2344         protected IFlagRegisterField status_ocbv0_bit;
Status_Ocbv0_Read(bool a, bool b)2345         partial void Status_Ocbv0_Read(bool a, bool b);
Status_Ocbv0_ValueProvider(bool a)2346         partial void Status_Ocbv0_ValueProvider(bool a);
2347 
2348         protected IFlagRegisterField status_ocbv1_bit;
Status_Ocbv1_Read(bool a, bool b)2349         partial void Status_Ocbv1_Read(bool a, bool b);
Status_Ocbv1_ValueProvider(bool a)2350         partial void Status_Ocbv1_ValueProvider(bool a);
2351 
2352         protected IFlagRegisterField status_ocbv2_bit;
Status_Ocbv2_Read(bool a, bool b)2353         partial void Status_Ocbv2_Read(bool a, bool b);
Status_Ocbv2_ValueProvider(bool a)2354         partial void Status_Ocbv2_ValueProvider(bool a);
2355 
2356         protected IFlagRegisterField status_icfempty0_bit;
Status_Icfempty0_Read(bool a, bool b)2357         partial void Status_Icfempty0_Read(bool a, bool b);
Status_Icfempty0_ValueProvider(bool a)2358         partial void Status_Icfempty0_ValueProvider(bool a);
2359 
2360         protected IFlagRegisterField status_icfempty1_bit;
Status_Icfempty1_Read(bool a, bool b)2361         partial void Status_Icfempty1_Read(bool a, bool b);
Status_Icfempty1_ValueProvider(bool a)2362         partial void Status_Icfempty1_ValueProvider(bool a);
2363 
2364         protected IFlagRegisterField status_icfempty2_bit;
Status_Icfempty2_Read(bool a, bool b)2365         partial void Status_Icfempty2_Read(bool a, bool b);
Status_Icfempty2_ValueProvider(bool a)2366         partial void Status_Icfempty2_ValueProvider(bool a);
2367 
2368         protected IEnumRegisterField<STATUS_CCPOL0> status_ccpol0_bit;
Status_Ccpol0_Read(STATUS_CCPOL0 a, STATUS_CCPOL0 b)2369         partial void Status_Ccpol0_Read(STATUS_CCPOL0 a, STATUS_CCPOL0 b);
Status_Ccpol0_ValueProvider(STATUS_CCPOL0 a)2370         partial void Status_Ccpol0_ValueProvider(STATUS_CCPOL0 a);
2371 
2372         protected IEnumRegisterField<STATUS_CCPOL1> status_ccpol1_bit;
Status_Ccpol1_Read(STATUS_CCPOL1 a, STATUS_CCPOL1 b)2373         partial void Status_Ccpol1_Read(STATUS_CCPOL1 a, STATUS_CCPOL1 b);
Status_Ccpol1_ValueProvider(STATUS_CCPOL1 a)2374         partial void Status_Ccpol1_ValueProvider(STATUS_CCPOL1 a);
2375 
2376         protected IEnumRegisterField<STATUS_CCPOL2> status_ccpol2_bit;
Status_Ccpol2_Read(STATUS_CCPOL2 a, STATUS_CCPOL2 b)2377         partial void Status_Ccpol2_Read(STATUS_CCPOL2 a, STATUS_CCPOL2 b);
Status_Ccpol2_ValueProvider(STATUS_CCPOL2 a)2378         partial void Status_Ccpol2_ValueProvider(STATUS_CCPOL2 a);
Status_Write(uint a, uint b)2379         partial void Status_Write(uint a, uint b);
Status_Read(uint a, uint b)2380         partial void Status_Read(uint a, uint b);
2381 
2382         // If - Offset : 0x14
2383 
2384         protected IFlagRegisterField if_of_bit;
If_Of_Write(bool a, bool b)2385         partial void If_Of_Write(bool a, bool b);
If_Of_Read(bool a, bool b)2386         partial void If_Of_Read(bool a, bool b);
If_Of_ValueProvider(bool a)2387         partial void If_Of_ValueProvider(bool a);
2388 
2389         protected IFlagRegisterField if_uf_bit;
If_Uf_Write(bool a, bool b)2390         partial void If_Uf_Write(bool a, bool b);
If_Uf_Read(bool a, bool b)2391         partial void If_Uf_Read(bool a, bool b);
If_Uf_ValueProvider(bool a)2392         partial void If_Uf_ValueProvider(bool a);
2393 
2394         protected IFlagRegisterField if_dirchg_bit;
If_Dirchg_Write(bool a, bool b)2395         partial void If_Dirchg_Write(bool a, bool b);
If_Dirchg_Read(bool a, bool b)2396         partial void If_Dirchg_Read(bool a, bool b);
If_Dirchg_ValueProvider(bool a)2397         partial void If_Dirchg_ValueProvider(bool a);
2398 
2399         protected IFlagRegisterField if_cc0_bit;
If_Cc0_Write(bool a, bool b)2400         partial void If_Cc0_Write(bool a, bool b);
If_Cc0_Read(bool a, bool b)2401         partial void If_Cc0_Read(bool a, bool b);
If_Cc0_ValueProvider(bool a)2402         partial void If_Cc0_ValueProvider(bool a);
2403 
2404         protected IFlagRegisterField if_cc1_bit;
If_Cc1_Write(bool a, bool b)2405         partial void If_Cc1_Write(bool a, bool b);
If_Cc1_Read(bool a, bool b)2406         partial void If_Cc1_Read(bool a, bool b);
If_Cc1_ValueProvider(bool a)2407         partial void If_Cc1_ValueProvider(bool a);
2408 
2409         protected IFlagRegisterField if_cc2_bit;
If_Cc2_Write(bool a, bool b)2410         partial void If_Cc2_Write(bool a, bool b);
If_Cc2_Read(bool a, bool b)2411         partial void If_Cc2_Read(bool a, bool b);
If_Cc2_ValueProvider(bool a)2412         partial void If_Cc2_ValueProvider(bool a);
2413 
2414         protected IFlagRegisterField if_icfwlfull0_bit;
If_Icfwlfull0_Write(bool a, bool b)2415         partial void If_Icfwlfull0_Write(bool a, bool b);
If_Icfwlfull0_Read(bool a, bool b)2416         partial void If_Icfwlfull0_Read(bool a, bool b);
If_Icfwlfull0_ValueProvider(bool a)2417         partial void If_Icfwlfull0_ValueProvider(bool a);
2418 
2419         protected IFlagRegisterField if_icfwlfull1_bit;
If_Icfwlfull1_Write(bool a, bool b)2420         partial void If_Icfwlfull1_Write(bool a, bool b);
If_Icfwlfull1_Read(bool a, bool b)2421         partial void If_Icfwlfull1_Read(bool a, bool b);
If_Icfwlfull1_ValueProvider(bool a)2422         partial void If_Icfwlfull1_ValueProvider(bool a);
2423 
2424         protected IFlagRegisterField if_icfwlfull2_bit;
If_Icfwlfull2_Write(bool a, bool b)2425         partial void If_Icfwlfull2_Write(bool a, bool b);
If_Icfwlfull2_Read(bool a, bool b)2426         partial void If_Icfwlfull2_Read(bool a, bool b);
If_Icfwlfull2_ValueProvider(bool a)2427         partial void If_Icfwlfull2_ValueProvider(bool a);
2428 
2429         protected IFlagRegisterField if_icfof0_bit;
If_Icfof0_Write(bool a, bool b)2430         partial void If_Icfof0_Write(bool a, bool b);
If_Icfof0_Read(bool a, bool b)2431         partial void If_Icfof0_Read(bool a, bool b);
If_Icfof0_ValueProvider(bool a)2432         partial void If_Icfof0_ValueProvider(bool a);
2433 
2434         protected IFlagRegisterField if_icfof1_bit;
If_Icfof1_Write(bool a, bool b)2435         partial void If_Icfof1_Write(bool a, bool b);
If_Icfof1_Read(bool a, bool b)2436         partial void If_Icfof1_Read(bool a, bool b);
If_Icfof1_ValueProvider(bool a)2437         partial void If_Icfof1_ValueProvider(bool a);
2438 
2439         protected IFlagRegisterField if_icfof2_bit;
If_Icfof2_Write(bool a, bool b)2440         partial void If_Icfof2_Write(bool a, bool b);
If_Icfof2_Read(bool a, bool b)2441         partial void If_Icfof2_Read(bool a, bool b);
If_Icfof2_ValueProvider(bool a)2442         partial void If_Icfof2_ValueProvider(bool a);
2443 
2444         protected IFlagRegisterField if_icfuf0_bit;
If_Icfuf0_Write(bool a, bool b)2445         partial void If_Icfuf0_Write(bool a, bool b);
If_Icfuf0_Read(bool a, bool b)2446         partial void If_Icfuf0_Read(bool a, bool b);
If_Icfuf0_ValueProvider(bool a)2447         partial void If_Icfuf0_ValueProvider(bool a);
2448 
2449         protected IFlagRegisterField if_icfuf1_bit;
If_Icfuf1_Write(bool a, bool b)2450         partial void If_Icfuf1_Write(bool a, bool b);
If_Icfuf1_Read(bool a, bool b)2451         partial void If_Icfuf1_Read(bool a, bool b);
If_Icfuf1_ValueProvider(bool a)2452         partial void If_Icfuf1_ValueProvider(bool a);
2453 
2454         protected IFlagRegisterField if_icfuf2_bit;
If_Icfuf2_Write(bool a, bool b)2455         partial void If_Icfuf2_Write(bool a, bool b);
If_Icfuf2_Read(bool a, bool b)2456         partial void If_Icfuf2_Read(bool a, bool b);
If_Icfuf2_ValueProvider(bool a)2457         partial void If_Icfuf2_ValueProvider(bool a);
If_Write(uint a, uint b)2458         partial void If_Write(uint a, uint b);
If_Read(uint a, uint b)2459         partial void If_Read(uint a, uint b);
2460 
2461         // Ien - Offset : 0x18
2462 
2463         protected IFlagRegisterField ien_of_bit;
Ien_Of_Write(bool a, bool b)2464         partial void Ien_Of_Write(bool a, bool b);
Ien_Of_Read(bool a, bool b)2465         partial void Ien_Of_Read(bool a, bool b);
Ien_Of_ValueProvider(bool a)2466         partial void Ien_Of_ValueProvider(bool a);
2467 
2468         protected IFlagRegisterField ien_uf_bit;
Ien_Uf_Write(bool a, bool b)2469         partial void Ien_Uf_Write(bool a, bool b);
Ien_Uf_Read(bool a, bool b)2470         partial void Ien_Uf_Read(bool a, bool b);
Ien_Uf_ValueProvider(bool a)2471         partial void Ien_Uf_ValueProvider(bool a);
2472 
2473         protected IFlagRegisterField ien_dirchg_bit;
Ien_Dirchg_Write(bool a, bool b)2474         partial void Ien_Dirchg_Write(bool a, bool b);
Ien_Dirchg_Read(bool a, bool b)2475         partial void Ien_Dirchg_Read(bool a, bool b);
Ien_Dirchg_ValueProvider(bool a)2476         partial void Ien_Dirchg_ValueProvider(bool a);
2477 
2478         protected IFlagRegisterField ien_cc0_bit;
Ien_Cc0_Write(bool a, bool b)2479         partial void Ien_Cc0_Write(bool a, bool b);
Ien_Cc0_Read(bool a, bool b)2480         partial void Ien_Cc0_Read(bool a, bool b);
Ien_Cc0_ValueProvider(bool a)2481         partial void Ien_Cc0_ValueProvider(bool a);
2482 
2483         protected IFlagRegisterField ien_cc1_bit;
Ien_Cc1_Write(bool a, bool b)2484         partial void Ien_Cc1_Write(bool a, bool b);
Ien_Cc1_Read(bool a, bool b)2485         partial void Ien_Cc1_Read(bool a, bool b);
Ien_Cc1_ValueProvider(bool a)2486         partial void Ien_Cc1_ValueProvider(bool a);
2487 
2488         protected IFlagRegisterField ien_cc2_bit;
Ien_Cc2_Write(bool a, bool b)2489         partial void Ien_Cc2_Write(bool a, bool b);
Ien_Cc2_Read(bool a, bool b)2490         partial void Ien_Cc2_Read(bool a, bool b);
Ien_Cc2_ValueProvider(bool a)2491         partial void Ien_Cc2_ValueProvider(bool a);
2492 
2493         protected IFlagRegisterField ien_icfwlfull0_bit;
Ien_Icfwlfull0_Write(bool a, bool b)2494         partial void Ien_Icfwlfull0_Write(bool a, bool b);
Ien_Icfwlfull0_Read(bool a, bool b)2495         partial void Ien_Icfwlfull0_Read(bool a, bool b);
Ien_Icfwlfull0_ValueProvider(bool a)2496         partial void Ien_Icfwlfull0_ValueProvider(bool a);
2497 
2498         protected IFlagRegisterField ien_icfwlfull1_bit;
Ien_Icfwlfull1_Write(bool a, bool b)2499         partial void Ien_Icfwlfull1_Write(bool a, bool b);
Ien_Icfwlfull1_Read(bool a, bool b)2500         partial void Ien_Icfwlfull1_Read(bool a, bool b);
Ien_Icfwlfull1_ValueProvider(bool a)2501         partial void Ien_Icfwlfull1_ValueProvider(bool a);
2502 
2503         protected IFlagRegisterField ien_icfwlfull2_bit;
Ien_Icfwlfull2_Write(bool a, bool b)2504         partial void Ien_Icfwlfull2_Write(bool a, bool b);
Ien_Icfwlfull2_Read(bool a, bool b)2505         partial void Ien_Icfwlfull2_Read(bool a, bool b);
Ien_Icfwlfull2_ValueProvider(bool a)2506         partial void Ien_Icfwlfull2_ValueProvider(bool a);
2507 
2508         protected IFlagRegisterField ien_icfof0_bit;
Ien_Icfof0_Write(bool a, bool b)2509         partial void Ien_Icfof0_Write(bool a, bool b);
Ien_Icfof0_Read(bool a, bool b)2510         partial void Ien_Icfof0_Read(bool a, bool b);
Ien_Icfof0_ValueProvider(bool a)2511         partial void Ien_Icfof0_ValueProvider(bool a);
2512 
2513         protected IFlagRegisterField ien_icfof1_bit;
Ien_Icfof1_Write(bool a, bool b)2514         partial void Ien_Icfof1_Write(bool a, bool b);
Ien_Icfof1_Read(bool a, bool b)2515         partial void Ien_Icfof1_Read(bool a, bool b);
Ien_Icfof1_ValueProvider(bool a)2516         partial void Ien_Icfof1_ValueProvider(bool a);
2517 
2518         protected IFlagRegisterField ien_icfof2_bit;
Ien_Icfof2_Write(bool a, bool b)2519         partial void Ien_Icfof2_Write(bool a, bool b);
Ien_Icfof2_Read(bool a, bool b)2520         partial void Ien_Icfof2_Read(bool a, bool b);
Ien_Icfof2_ValueProvider(bool a)2521         partial void Ien_Icfof2_ValueProvider(bool a);
2522 
2523         protected IFlagRegisterField ien_icfuf0_bit;
Ien_Icfuf0_Write(bool a, bool b)2524         partial void Ien_Icfuf0_Write(bool a, bool b);
Ien_Icfuf0_Read(bool a, bool b)2525         partial void Ien_Icfuf0_Read(bool a, bool b);
Ien_Icfuf0_ValueProvider(bool a)2526         partial void Ien_Icfuf0_ValueProvider(bool a);
2527 
2528         protected IFlagRegisterField ien_icfuf1_bit;
Ien_Icfuf1_Write(bool a, bool b)2529         partial void Ien_Icfuf1_Write(bool a, bool b);
Ien_Icfuf1_Read(bool a, bool b)2530         partial void Ien_Icfuf1_Read(bool a, bool b);
Ien_Icfuf1_ValueProvider(bool a)2531         partial void Ien_Icfuf1_ValueProvider(bool a);
2532 
2533         protected IFlagRegisterField ien_icfuf2_bit;
Ien_Icfuf2_Write(bool a, bool b)2534         partial void Ien_Icfuf2_Write(bool a, bool b);
Ien_Icfuf2_Read(bool a, bool b)2535         partial void Ien_Icfuf2_Read(bool a, bool b);
Ien_Icfuf2_ValueProvider(bool a)2536         partial void Ien_Icfuf2_ValueProvider(bool a);
Ien_Write(uint a, uint b)2537         partial void Ien_Write(uint a, uint b);
Ien_Read(uint a, uint b)2538         partial void Ien_Read(uint a, uint b);
2539 
2540         // Top - Offset : 0x1C
2541 
2542         protected IValueRegisterField top_top_field;
Top_Top_Write(ulong a, ulong b)2543         partial void Top_Top_Write(ulong a, ulong b);
Top_Top_Read(ulong a, ulong b)2544         partial void Top_Top_Read(ulong a, ulong b);
Top_Top_ValueProvider(ulong a)2545         partial void Top_Top_ValueProvider(ulong a);
Top_Write(uint a, uint b)2546         partial void Top_Write(uint a, uint b);
Top_Read(uint a, uint b)2547         partial void Top_Read(uint a, uint b);
2548 
2549         // Topb - Offset : 0x20
2550 
2551         protected IValueRegisterField topb_topb_field;
Topb_Topb_Write(ulong a, ulong b)2552         partial void Topb_Topb_Write(ulong a, ulong b);
Topb_Topb_Read(ulong a, ulong b)2553         partial void Topb_Topb_Read(ulong a, ulong b);
Topb_Topb_ValueProvider(ulong a)2554         partial void Topb_Topb_ValueProvider(ulong a);
Topb_Write(uint a, uint b)2555         partial void Topb_Write(uint a, uint b);
Topb_Read(uint a, uint b)2556         partial void Topb_Read(uint a, uint b);
2557 
2558         // Cnt - Offset : 0x24
2559 
2560         protected IValueRegisterField cnt_cnt_field;
Cnt_Cnt_Write(ulong a, ulong b)2561         partial void Cnt_Cnt_Write(ulong a, ulong b);
Cnt_Cnt_Read(ulong a, ulong b)2562         partial void Cnt_Cnt_Read(ulong a, ulong b);
Cnt_Cnt_ValueProvider(ulong a)2563         partial void Cnt_Cnt_ValueProvider(ulong a);
Cnt_Write(uint a, uint b)2564         partial void Cnt_Write(uint a, uint b);
Cnt_Read(uint a, uint b)2565         partial void Cnt_Read(uint a, uint b);
2566 
2567         // Lock - Offset : 0x2C
2568 
2569         protected IValueRegisterField lock_lockkey_field;
Lock_Lockkey_Write(ulong a, ulong b)2570         partial void Lock_Lockkey_Write(ulong a, ulong b);
Lock_Lockkey_ValueProvider(ulong a)2571         partial void Lock_Lockkey_ValueProvider(ulong a);
Lock_Write(uint a, uint b)2572         partial void Lock_Write(uint a, uint b);
Lock_Read(uint a, uint b)2573         partial void Lock_Read(uint a, uint b);
2574 
2575         // En - Offset : 0x30
2576 
2577         protected IFlagRegisterField en_en_bit;
En_En_Write(bool a, bool b)2578         partial void En_En_Write(bool a, bool b);
En_En_Read(bool a, bool b)2579         partial void En_En_Read(bool a, bool b);
En_En_ValueProvider(bool a)2580         partial void En_En_ValueProvider(bool a);
2581 
2582         protected IFlagRegisterField en_disabling_bit;
En_Disabling_Read(bool a, bool b)2583         partial void En_Disabling_Read(bool a, bool b);
En_Disabling_ValueProvider(bool a)2584         partial void En_Disabling_ValueProvider(bool a);
En_Write(uint a, uint b)2585         partial void En_Write(uint a, uint b);
En_Read(uint a, uint b)2586         partial void En_Read(uint a, uint b);
2587 
2588         // Cc0_Cfg - Offset : 0x60
2589 
2590     protected IEnumRegisterField<CC_CFG_MODE>[] cc_cfg_mode_field = new IEnumRegisterField<CC_CFG_MODE>[3];
Cc_Cfg_Mode_Write(ulong index, CC_CFG_MODE a, CC_CFG_MODE b)2591         partial void Cc_Cfg_Mode_Write(ulong index, CC_CFG_MODE a, CC_CFG_MODE b);
Cc_Cfg_Mode_Read(ulong index, CC_CFG_MODE a, CC_CFG_MODE b)2592         partial void Cc_Cfg_Mode_Read(ulong index, CC_CFG_MODE a, CC_CFG_MODE b);
Cc_Cfg_Mode_ValueProvider(ulong index, CC_CFG_MODE a)2593         partial void Cc_Cfg_Mode_ValueProvider(ulong index, CC_CFG_MODE a);
2594 
2595         protected IFlagRegisterField[] cc_cfg_coist_bit = new IFlagRegisterField[3]; //test3
Cc_Cfg_Coist_Write(ulong index, bool a, bool b)2596         partial void Cc_Cfg_Coist_Write(ulong index, bool a, bool b);
Cc_Cfg_Coist_Read(ulong index, bool a, bool b)2597         partial void Cc_Cfg_Coist_Read(ulong index, bool a, bool b);
Cc_Cfg_Coist_ValueProvider(ulong index, bool a)2598         partial void Cc_Cfg_Coist_ValueProvider(ulong index, bool a);
2599 
2600     protected IEnumRegisterField<CC_CFG_INSEL>[] cc_cfg_insel_field = new IEnumRegisterField<CC_CFG_INSEL>[3];
Cc_Cfg_Insel_Write(ulong index, CC_CFG_INSEL a, CC_CFG_INSEL b)2601         partial void Cc_Cfg_Insel_Write(ulong index, CC_CFG_INSEL a, CC_CFG_INSEL b);
Cc_Cfg_Insel_Read(ulong index, CC_CFG_INSEL a, CC_CFG_INSEL b)2602         partial void Cc_Cfg_Insel_Read(ulong index, CC_CFG_INSEL a, CC_CFG_INSEL b);
Cc_Cfg_Insel_ValueProvider(ulong index, CC_CFG_INSEL a)2603         partial void Cc_Cfg_Insel_ValueProvider(ulong index, CC_CFG_INSEL a);
2604 
2605     protected IEnumRegisterField<CC_CFG_PRSCONF>[] cc_cfg_prsconf_bit = new IEnumRegisterField<CC_CFG_PRSCONF>[3];
Cc_Cfg_Prsconf_Write(ulong index, CC_CFG_PRSCONF a, CC_CFG_PRSCONF b)2606         partial void Cc_Cfg_Prsconf_Write(ulong index, CC_CFG_PRSCONF a, CC_CFG_PRSCONF b);
Cc_Cfg_Prsconf_Read(ulong index, CC_CFG_PRSCONF a, CC_CFG_PRSCONF b)2607         partial void Cc_Cfg_Prsconf_Read(ulong index, CC_CFG_PRSCONF a, CC_CFG_PRSCONF b);
Cc_Cfg_Prsconf_ValueProvider(ulong index, CC_CFG_PRSCONF a)2608         partial void Cc_Cfg_Prsconf_ValueProvider(ulong index, CC_CFG_PRSCONF a);
2609 
2610     protected IEnumRegisterField<CC_CFG_FILT>[] cc_cfg_filt_bit = new IEnumRegisterField<CC_CFG_FILT>[3];
Cc_Cfg_Filt_Write(ulong index, CC_CFG_FILT a, CC_CFG_FILT b)2611         partial void Cc_Cfg_Filt_Write(ulong index, CC_CFG_FILT a, CC_CFG_FILT b);
Cc_Cfg_Filt_Read(ulong index, CC_CFG_FILT a, CC_CFG_FILT b)2612         partial void Cc_Cfg_Filt_Read(ulong index, CC_CFG_FILT a, CC_CFG_FILT b);
Cc_Cfg_Filt_ValueProvider(ulong index, CC_CFG_FILT a)2613         partial void Cc_Cfg_Filt_ValueProvider(ulong index, CC_CFG_FILT a);
2614 
2615         protected IFlagRegisterField[] cc_cfg_icfwl_bit = new IFlagRegisterField[3]; //test3
Cc_Cfg_Icfwl_Write(ulong index, bool a, bool b)2616         partial void Cc_Cfg_Icfwl_Write(ulong index, bool a, bool b);
Cc_Cfg_Icfwl_Read(ulong index, bool a, bool b)2617         partial void Cc_Cfg_Icfwl_Read(ulong index, bool a, bool b);
Cc_Cfg_Icfwl_ValueProvider(ulong index, bool a)2618         partial void Cc_Cfg_Icfwl_ValueProvider(ulong index, bool a);
Cc_Cfg_Write(ulong index, uint a, uint b)2619         partial void Cc_Cfg_Write(ulong index, uint a, uint b);
Cc_Cfg_Read(ulong index, uint a, uint b)2620         partial void Cc_Cfg_Read(ulong index, uint a, uint b);
2621 
2622         // Cc0_Ctrl - Offset : 0x64
2623 
2624         protected IFlagRegisterField[] cc_ctrl_outinv_bit = new IFlagRegisterField[3]; //test3
Cc_Ctrl_Outinv_Write(ulong index, bool a, bool b)2625         partial void Cc_Ctrl_Outinv_Write(ulong index, bool a, bool b);
Cc_Ctrl_Outinv_Read(ulong index, bool a, bool b)2626         partial void Cc_Ctrl_Outinv_Read(ulong index, bool a, bool b);
Cc_Ctrl_Outinv_ValueProvider(ulong index, bool a)2627         partial void Cc_Ctrl_Outinv_ValueProvider(ulong index, bool a);
2628 
2629     protected IEnumRegisterField<CC_CTRL_CMOA>[] cc_ctrl_cmoa_field = new IEnumRegisterField<CC_CTRL_CMOA>[3];
Cc_Ctrl_Cmoa_Write(ulong index, CC_CTRL_CMOA a, CC_CTRL_CMOA b)2630         partial void Cc_Ctrl_Cmoa_Write(ulong index, CC_CTRL_CMOA a, CC_CTRL_CMOA b);
Cc_Ctrl_Cmoa_Read(ulong index, CC_CTRL_CMOA a, CC_CTRL_CMOA b)2631         partial void Cc_Ctrl_Cmoa_Read(ulong index, CC_CTRL_CMOA a, CC_CTRL_CMOA b);
Cc_Ctrl_Cmoa_ValueProvider(ulong index, CC_CTRL_CMOA a)2632         partial void Cc_Ctrl_Cmoa_ValueProvider(ulong index, CC_CTRL_CMOA a);
2633 
2634     protected IEnumRegisterField<CC_CTRL_COFOA>[] cc_ctrl_cofoa_field = new IEnumRegisterField<CC_CTRL_COFOA>[3];
Cc_Ctrl_Cofoa_Write(ulong index, CC_CTRL_COFOA a, CC_CTRL_COFOA b)2635         partial void Cc_Ctrl_Cofoa_Write(ulong index, CC_CTRL_COFOA a, CC_CTRL_COFOA b);
Cc_Ctrl_Cofoa_Read(ulong index, CC_CTRL_COFOA a, CC_CTRL_COFOA b)2636         partial void Cc_Ctrl_Cofoa_Read(ulong index, CC_CTRL_COFOA a, CC_CTRL_COFOA b);
Cc_Ctrl_Cofoa_ValueProvider(ulong index, CC_CTRL_COFOA a)2637         partial void Cc_Ctrl_Cofoa_ValueProvider(ulong index, CC_CTRL_COFOA a);
2638 
2639     protected IEnumRegisterField<CC_CTRL_CUFOA>[] cc_ctrl_cufoa_field = new IEnumRegisterField<CC_CTRL_CUFOA>[3];
Cc_Ctrl_Cufoa_Write(ulong index, CC_CTRL_CUFOA a, CC_CTRL_CUFOA b)2640         partial void Cc_Ctrl_Cufoa_Write(ulong index, CC_CTRL_CUFOA a, CC_CTRL_CUFOA b);
Cc_Ctrl_Cufoa_Read(ulong index, CC_CTRL_CUFOA a, CC_CTRL_CUFOA b)2641         partial void Cc_Ctrl_Cufoa_Read(ulong index, CC_CTRL_CUFOA a, CC_CTRL_CUFOA b);
Cc_Ctrl_Cufoa_ValueProvider(ulong index, CC_CTRL_CUFOA a)2642         partial void Cc_Ctrl_Cufoa_ValueProvider(ulong index, CC_CTRL_CUFOA a);
2643 
2644     protected IEnumRegisterField<CC_CTRL_ICEDGE>[] cc_ctrl_icedge_field = new IEnumRegisterField<CC_CTRL_ICEDGE>[3];
Cc_Ctrl_Icedge_Write(ulong index, CC_CTRL_ICEDGE a, CC_CTRL_ICEDGE b)2645         partial void Cc_Ctrl_Icedge_Write(ulong index, CC_CTRL_ICEDGE a, CC_CTRL_ICEDGE b);
Cc_Ctrl_Icedge_Read(ulong index, CC_CTRL_ICEDGE a, CC_CTRL_ICEDGE b)2646         partial void Cc_Ctrl_Icedge_Read(ulong index, CC_CTRL_ICEDGE a, CC_CTRL_ICEDGE b);
Cc_Ctrl_Icedge_ValueProvider(ulong index, CC_CTRL_ICEDGE a)2647         partial void Cc_Ctrl_Icedge_ValueProvider(ulong index, CC_CTRL_ICEDGE a);
2648 
2649     protected IEnumRegisterField<CC_CTRL_ICEVCTRL>[] cc_ctrl_icevctrl_field = new IEnumRegisterField<CC_CTRL_ICEVCTRL>[3];
Cc_Ctrl_Icevctrl_Write(ulong index, CC_CTRL_ICEVCTRL a, CC_CTRL_ICEVCTRL b)2650         partial void Cc_Ctrl_Icevctrl_Write(ulong index, CC_CTRL_ICEVCTRL a, CC_CTRL_ICEVCTRL b);
Cc_Ctrl_Icevctrl_Read(ulong index, CC_CTRL_ICEVCTRL a, CC_CTRL_ICEVCTRL b)2651         partial void Cc_Ctrl_Icevctrl_Read(ulong index, CC_CTRL_ICEVCTRL a, CC_CTRL_ICEVCTRL b);
Cc_Ctrl_Icevctrl_ValueProvider(ulong index, CC_CTRL_ICEVCTRL a)2652         partial void Cc_Ctrl_Icevctrl_ValueProvider(ulong index, CC_CTRL_ICEVCTRL a);
Cc_Ctrl_Write(ulong index, uint a, uint b)2653         partial void Cc_Ctrl_Write(ulong index, uint a, uint b);
Cc_Ctrl_Read(ulong index, uint a, uint b)2654         partial void Cc_Ctrl_Read(ulong index, uint a, uint b);
2655 
2656         // Cc0_Oc - Offset : 0x68
2657 
2658 
2659         protected IValueRegisterField[] cc_oc_oc_field = new IValueRegisterField[3];
Cc_Oc_Oc_Write(ulong index, ulong a, ulong b)2660         partial void Cc_Oc_Oc_Write(ulong index, ulong a, ulong b);
Cc_Oc_Oc_Read(ulong index, ulong a, ulong b)2661         partial void Cc_Oc_Oc_Read(ulong index, ulong a, ulong b);
Cc_Oc_Oc_ValueProvider(ulong index, ulong a)2662         partial void Cc_Oc_Oc_ValueProvider(ulong index, ulong a);
Cc_Oc_Write(ulong index, uint a, uint b)2663         partial void Cc_Oc_Write(ulong index, uint a, uint b);
Cc_Oc_Read(ulong index, uint a, uint b)2664         partial void Cc_Oc_Read(ulong index, uint a, uint b);
2665 
2666         // Cc0_Ocb - Offset : 0x70
2667 
2668 
2669         protected IValueRegisterField[] cc_ocb_ocb_field = new IValueRegisterField[3];
Cc_Ocb_Ocb_Write(ulong index, ulong a, ulong b)2670         partial void Cc_Ocb_Ocb_Write(ulong index, ulong a, ulong b);
Cc_Ocb_Ocb_Read(ulong index, ulong a, ulong b)2671         partial void Cc_Ocb_Ocb_Read(ulong index, ulong a, ulong b);
Cc_Ocb_Ocb_ValueProvider(ulong index, ulong a)2672         partial void Cc_Ocb_Ocb_ValueProvider(ulong index, ulong a);
Cc_Ocb_Write(ulong index, uint a, uint b)2673         partial void Cc_Ocb_Write(ulong index, uint a, uint b);
Cc_Ocb_Read(ulong index, uint a, uint b)2674         partial void Cc_Ocb_Read(ulong index, uint a, uint b);
2675 
2676         // Cc0_Icf - Offset : 0x74
2677 
2678 
2679         protected IValueRegisterField[] cc_icf_icf_field = new IValueRegisterField[3];
Cc_Icf_Icf_Read(ulong index, ulong a, ulong b)2680         partial void Cc_Icf_Icf_Read(ulong index, ulong a, ulong b);
Cc_Icf_Icf_ValueProvider(ulong index, ulong a)2681         partial void Cc_Icf_Icf_ValueProvider(ulong index, ulong a);
Cc_Icf_Write(ulong index, uint a, uint b)2682         partial void Cc_Icf_Write(ulong index, uint a, uint b);
Cc_Icf_Read(ulong index, uint a, uint b)2683         partial void Cc_Icf_Read(ulong index, uint a, uint b);
2684 
2685         // Cc0_Icof - Offset : 0x78
2686 
2687 
2688         protected IValueRegisterField[] cc_icof_icof_field = new IValueRegisterField[3];
Cc_Icof_Icof_Read(ulong index, ulong a, ulong b)2689         partial void Cc_Icof_Icof_Read(ulong index, ulong a, ulong b);
Cc_Icof_Icof_ValueProvider(ulong index, ulong a)2690         partial void Cc_Icof_Icof_ValueProvider(ulong index, ulong a);
Cc_Icof_Write(ulong index, uint a, uint b)2691         partial void Cc_Icof_Write(ulong index, uint a, uint b);
Cc_Icof_Read(ulong index, uint a, uint b)2692         partial void Cc_Icof_Read(ulong index, uint a, uint b);
2693 
2694 
2695 
2696 
2697 
2698 
2699 
2700 
2701 
2702 
2703 
2704 
2705 
2706 
2707 
2708 
2709 
2710 
2711 
2712 
2713 
2714 
2715 
2716 
2717 
2718 
2719 
2720 
2721 
2722 
2723 
2724 
2725 
2726 
2727 
2728 
2729 
2730 
2731 
2732 
2733 
2734 
2735 
2736 
2737 
2738 
2739 
2740 
2741 
2742 
2743 
2744 
2745 
2746 
2747 
2748 
2749 
2750 
2751 
2752 
2753 
2754 
2755 
2756 
2757 
2758 
2759 
2760 
2761 
2762 
2763 
2764         // DtCfg - Offset : 0xE0
2765 
2766         protected IFlagRegisterField dtcfg_dten_bit;
DtCfg_Dten_Write(bool a, bool b)2767         partial void DtCfg_Dten_Write(bool a, bool b);
DtCfg_Dten_Read(bool a, bool b)2768         partial void DtCfg_Dten_Read(bool a, bool b);
DtCfg_Dten_ValueProvider(bool a)2769         partial void DtCfg_Dten_ValueProvider(bool a);
2770 
2771         protected IEnumRegisterField<DTCFG_DTDAS> dtcfg_dtdas_bit;
DtCfg_Dtdas_Write(DTCFG_DTDAS a, DTCFG_DTDAS b)2772         partial void DtCfg_Dtdas_Write(DTCFG_DTDAS a, DTCFG_DTDAS b);
DtCfg_Dtdas_Read(DTCFG_DTDAS a, DTCFG_DTDAS b)2773         partial void DtCfg_Dtdas_Read(DTCFG_DTDAS a, DTCFG_DTDAS b);
DtCfg_Dtdas_ValueProvider(DTCFG_DTDAS a)2774         partial void DtCfg_Dtdas_ValueProvider(DTCFG_DTDAS a);
2775 
2776         protected IFlagRegisterField dtcfg_dtar_bit;
DtCfg_Dtar_Write(bool a, bool b)2777         partial void DtCfg_Dtar_Write(bool a, bool b);
DtCfg_Dtar_Read(bool a, bool b)2778         partial void DtCfg_Dtar_Read(bool a, bool b);
DtCfg_Dtar_ValueProvider(bool a)2779         partial void DtCfg_Dtar_ValueProvider(bool a);
2780 
2781         protected IFlagRegisterField dtcfg_dtfats_bit;
DtCfg_Dtfats_Write(bool a, bool b)2782         partial void DtCfg_Dtfats_Write(bool a, bool b);
DtCfg_Dtfats_Read(bool a, bool b)2783         partial void DtCfg_Dtfats_Read(bool a, bool b);
DtCfg_Dtfats_ValueProvider(bool a)2784         partial void DtCfg_Dtfats_ValueProvider(bool a);
2785 
2786         protected IFlagRegisterField dtcfg_dtprsen_bit;
DtCfg_Dtprsen_Write(bool a, bool b)2787         partial void DtCfg_Dtprsen_Write(bool a, bool b);
DtCfg_Dtprsen_Read(bool a, bool b)2788         partial void DtCfg_Dtprsen_Read(bool a, bool b);
DtCfg_Dtprsen_ValueProvider(bool a)2789         partial void DtCfg_Dtprsen_ValueProvider(bool a);
DtCfg_Write(uint a, uint b)2790         partial void DtCfg_Write(uint a, uint b);
DtCfg_Read(uint a, uint b)2791         partial void DtCfg_Read(uint a, uint b);
2792 
2793         // DtTimecfg - Offset : 0xE4
2794 
2795         protected IValueRegisterField dttimecfg_dtpresc_field;
DtTimecfg_Dtpresc_Write(ulong a, ulong b)2796         partial void DtTimecfg_Dtpresc_Write(ulong a, ulong b);
DtTimecfg_Dtpresc_Read(ulong a, ulong b)2797         partial void DtTimecfg_Dtpresc_Read(ulong a, ulong b);
DtTimecfg_Dtpresc_ValueProvider(ulong a)2798         partial void DtTimecfg_Dtpresc_ValueProvider(ulong a);
2799 
2800         protected IValueRegisterField dttimecfg_dtriset_field;
DtTimecfg_Dtriset_Write(ulong a, ulong b)2801         partial void DtTimecfg_Dtriset_Write(ulong a, ulong b);
DtTimecfg_Dtriset_Read(ulong a, ulong b)2802         partial void DtTimecfg_Dtriset_Read(ulong a, ulong b);
DtTimecfg_Dtriset_ValueProvider(ulong a)2803         partial void DtTimecfg_Dtriset_ValueProvider(ulong a);
2804 
2805         protected IValueRegisterField dttimecfg_dtfallt_field;
DtTimecfg_Dtfallt_Write(ulong a, ulong b)2806         partial void DtTimecfg_Dtfallt_Write(ulong a, ulong b);
DtTimecfg_Dtfallt_Read(ulong a, ulong b)2807         partial void DtTimecfg_Dtfallt_Read(ulong a, ulong b);
DtTimecfg_Dtfallt_ValueProvider(ulong a)2808         partial void DtTimecfg_Dtfallt_ValueProvider(ulong a);
DtTimecfg_Write(uint a, uint b)2809         partial void DtTimecfg_Write(uint a, uint b);
DtTimecfg_Read(uint a, uint b)2810         partial void DtTimecfg_Read(uint a, uint b);
2811 
2812         // DtFcfg - Offset : 0xE8
2813 
2814         protected IEnumRegisterField<DTFCFG_DTFA> dtfcfg_dtfa_field;
DtFcfg_Dtfa_Write(DTFCFG_DTFA a, DTFCFG_DTFA b)2815         partial void DtFcfg_Dtfa_Write(DTFCFG_DTFA a, DTFCFG_DTFA b);
DtFcfg_Dtfa_Read(DTFCFG_DTFA a, DTFCFG_DTFA b)2816         partial void DtFcfg_Dtfa_Read(DTFCFG_DTFA a, DTFCFG_DTFA b);
DtFcfg_Dtfa_ValueProvider(DTFCFG_DTFA a)2817         partial void DtFcfg_Dtfa_ValueProvider(DTFCFG_DTFA a);
2818 
2819         protected IFlagRegisterField dtfcfg_dtprs0fen_bit;
DtFcfg_Dtprs0fen_Write(bool a, bool b)2820         partial void DtFcfg_Dtprs0fen_Write(bool a, bool b);
DtFcfg_Dtprs0fen_Read(bool a, bool b)2821         partial void DtFcfg_Dtprs0fen_Read(bool a, bool b);
DtFcfg_Dtprs0fen_ValueProvider(bool a)2822         partial void DtFcfg_Dtprs0fen_ValueProvider(bool a);
2823 
2824         protected IFlagRegisterField dtfcfg_dtprs1fen_bit;
DtFcfg_Dtprs1fen_Write(bool a, bool b)2825         partial void DtFcfg_Dtprs1fen_Write(bool a, bool b);
DtFcfg_Dtprs1fen_Read(bool a, bool b)2826         partial void DtFcfg_Dtprs1fen_Read(bool a, bool b);
DtFcfg_Dtprs1fen_ValueProvider(bool a)2827         partial void DtFcfg_Dtprs1fen_ValueProvider(bool a);
2828 
2829         protected IFlagRegisterField dtfcfg_dtdbgfen_bit;
DtFcfg_Dtdbgfen_Write(bool a, bool b)2830         partial void DtFcfg_Dtdbgfen_Write(bool a, bool b);
DtFcfg_Dtdbgfen_Read(bool a, bool b)2831         partial void DtFcfg_Dtdbgfen_Read(bool a, bool b);
DtFcfg_Dtdbgfen_ValueProvider(bool a)2832         partial void DtFcfg_Dtdbgfen_ValueProvider(bool a);
2833 
2834         protected IFlagRegisterField dtfcfg_dtlockupfen_bit;
DtFcfg_Dtlockupfen_Write(bool a, bool b)2835         partial void DtFcfg_Dtlockupfen_Write(bool a, bool b);
DtFcfg_Dtlockupfen_Read(bool a, bool b)2836         partial void DtFcfg_Dtlockupfen_Read(bool a, bool b);
DtFcfg_Dtlockupfen_ValueProvider(bool a)2837         partial void DtFcfg_Dtlockupfen_ValueProvider(bool a);
2838 
2839         protected IFlagRegisterField dtfcfg_dtem23fen_bit;
DtFcfg_Dtem23fen_Write(bool a, bool b)2840         partial void DtFcfg_Dtem23fen_Write(bool a, bool b);
DtFcfg_Dtem23fen_Read(bool a, bool b)2841         partial void DtFcfg_Dtem23fen_Read(bool a, bool b);
DtFcfg_Dtem23fen_ValueProvider(bool a)2842         partial void DtFcfg_Dtem23fen_ValueProvider(bool a);
DtFcfg_Write(uint a, uint b)2843         partial void DtFcfg_Write(uint a, uint b);
DtFcfg_Read(uint a, uint b)2844         partial void DtFcfg_Read(uint a, uint b);
2845 
2846         // DtCtrl - Offset : 0xEC
2847 
2848         protected IFlagRegisterField dtctrl_dtcinv_bit;
DtCtrl_Dtcinv_Write(bool a, bool b)2849         partial void DtCtrl_Dtcinv_Write(bool a, bool b);
DtCtrl_Dtcinv_Read(bool a, bool b)2850         partial void DtCtrl_Dtcinv_Read(bool a, bool b);
DtCtrl_Dtcinv_ValueProvider(bool a)2851         partial void DtCtrl_Dtcinv_ValueProvider(bool a);
2852 
2853         protected IFlagRegisterField dtctrl_dtipol_bit;
DtCtrl_Dtipol_Write(bool a, bool b)2854         partial void DtCtrl_Dtipol_Write(bool a, bool b);
DtCtrl_Dtipol_Read(bool a, bool b)2855         partial void DtCtrl_Dtipol_Read(bool a, bool b);
DtCtrl_Dtipol_ValueProvider(bool a)2856         partial void DtCtrl_Dtipol_ValueProvider(bool a);
DtCtrl_Write(uint a, uint b)2857         partial void DtCtrl_Write(uint a, uint b);
DtCtrl_Read(uint a, uint b)2858         partial void DtCtrl_Read(uint a, uint b);
2859 
2860         // DtOgen - Offset : 0xF0
2861 
2862         protected IFlagRegisterField dtogen_dtogcc0en_bit;
DtOgen_Dtogcc0en_Write(bool a, bool b)2863         partial void DtOgen_Dtogcc0en_Write(bool a, bool b);
DtOgen_Dtogcc0en_Read(bool a, bool b)2864         partial void DtOgen_Dtogcc0en_Read(bool a, bool b);
DtOgen_Dtogcc0en_ValueProvider(bool a)2865         partial void DtOgen_Dtogcc0en_ValueProvider(bool a);
2866 
2867         protected IFlagRegisterField dtogen_dtogcc1en_bit;
DtOgen_Dtogcc1en_Write(bool a, bool b)2868         partial void DtOgen_Dtogcc1en_Write(bool a, bool b);
DtOgen_Dtogcc1en_Read(bool a, bool b)2869         partial void DtOgen_Dtogcc1en_Read(bool a, bool b);
DtOgen_Dtogcc1en_ValueProvider(bool a)2870         partial void DtOgen_Dtogcc1en_ValueProvider(bool a);
2871 
2872         protected IFlagRegisterField dtogen_dtogcc2en_bit;
DtOgen_Dtogcc2en_Write(bool a, bool b)2873         partial void DtOgen_Dtogcc2en_Write(bool a, bool b);
DtOgen_Dtogcc2en_Read(bool a, bool b)2874         partial void DtOgen_Dtogcc2en_Read(bool a, bool b);
DtOgen_Dtogcc2en_ValueProvider(bool a)2875         partial void DtOgen_Dtogcc2en_ValueProvider(bool a);
2876 
2877         protected IFlagRegisterField dtogen_dtogcdti0en_bit;
DtOgen_Dtogcdti0en_Write(bool a, bool b)2878         partial void DtOgen_Dtogcdti0en_Write(bool a, bool b);
DtOgen_Dtogcdti0en_Read(bool a, bool b)2879         partial void DtOgen_Dtogcdti0en_Read(bool a, bool b);
DtOgen_Dtogcdti0en_ValueProvider(bool a)2880         partial void DtOgen_Dtogcdti0en_ValueProvider(bool a);
2881 
2882         protected IFlagRegisterField dtogen_dtogcdti1en_bit;
DtOgen_Dtogcdti1en_Write(bool a, bool b)2883         partial void DtOgen_Dtogcdti1en_Write(bool a, bool b);
DtOgen_Dtogcdti1en_Read(bool a, bool b)2884         partial void DtOgen_Dtogcdti1en_Read(bool a, bool b);
DtOgen_Dtogcdti1en_ValueProvider(bool a)2885         partial void DtOgen_Dtogcdti1en_ValueProvider(bool a);
2886 
2887         protected IFlagRegisterField dtogen_dtogcdti2en_bit;
DtOgen_Dtogcdti2en_Write(bool a, bool b)2888         partial void DtOgen_Dtogcdti2en_Write(bool a, bool b);
DtOgen_Dtogcdti2en_Read(bool a, bool b)2889         partial void DtOgen_Dtogcdti2en_Read(bool a, bool b);
DtOgen_Dtogcdti2en_ValueProvider(bool a)2890         partial void DtOgen_Dtogcdti2en_ValueProvider(bool a);
DtOgen_Write(uint a, uint b)2891         partial void DtOgen_Write(uint a, uint b);
DtOgen_Read(uint a, uint b)2892         partial void DtOgen_Read(uint a, uint b);
2893 
2894         // DtFault - Offset : 0xF4
2895 
2896         protected IFlagRegisterField dtfault_dtprs0f_bit;
DtFault_Dtprs0f_Read(bool a, bool b)2897         partial void DtFault_Dtprs0f_Read(bool a, bool b);
DtFault_Dtprs0f_ValueProvider(bool a)2898         partial void DtFault_Dtprs0f_ValueProvider(bool a);
2899 
2900         protected IFlagRegisterField dtfault_dtprs1f_bit;
DtFault_Dtprs1f_Read(bool a, bool b)2901         partial void DtFault_Dtprs1f_Read(bool a, bool b);
DtFault_Dtprs1f_ValueProvider(bool a)2902         partial void DtFault_Dtprs1f_ValueProvider(bool a);
2903 
2904         protected IFlagRegisterField dtfault_dtdbgf_bit;
DtFault_Dtdbgf_Read(bool a, bool b)2905         partial void DtFault_Dtdbgf_Read(bool a, bool b);
DtFault_Dtdbgf_ValueProvider(bool a)2906         partial void DtFault_Dtdbgf_ValueProvider(bool a);
2907 
2908         protected IFlagRegisterField dtfault_dtlockupf_bit;
DtFault_Dtlockupf_Read(bool a, bool b)2909         partial void DtFault_Dtlockupf_Read(bool a, bool b);
DtFault_Dtlockupf_ValueProvider(bool a)2910         partial void DtFault_Dtlockupf_ValueProvider(bool a);
2911 
2912         protected IFlagRegisterField dtfault_dtem23f_bit;
DtFault_Dtem23f_Read(bool a, bool b)2913         partial void DtFault_Dtem23f_Read(bool a, bool b);
DtFault_Dtem23f_ValueProvider(bool a)2914         partial void DtFault_Dtem23f_ValueProvider(bool a);
DtFault_Write(uint a, uint b)2915         partial void DtFault_Write(uint a, uint b);
DtFault_Read(uint a, uint b)2916         partial void DtFault_Read(uint a, uint b);
2917 
2918         // DtFaultc - Offset : 0xF8
2919 
2920         protected IFlagRegisterField dtfaultc_dtprs0fc_bit;
DtFaultc_Dtprs0fc_Write(bool a, bool b)2921         partial void DtFaultc_Dtprs0fc_Write(bool a, bool b);
DtFaultc_Dtprs0fc_ValueProvider(bool a)2922         partial void DtFaultc_Dtprs0fc_ValueProvider(bool a);
2923 
2924         protected IFlagRegisterField dtfaultc_dtprs1fc_bit;
DtFaultc_Dtprs1fc_Write(bool a, bool b)2925         partial void DtFaultc_Dtprs1fc_Write(bool a, bool b);
DtFaultc_Dtprs1fc_ValueProvider(bool a)2926         partial void DtFaultc_Dtprs1fc_ValueProvider(bool a);
2927 
2928         protected IFlagRegisterField dtfaultc_dtdbgfc_bit;
DtFaultc_Dtdbgfc_Write(bool a, bool b)2929         partial void DtFaultc_Dtdbgfc_Write(bool a, bool b);
DtFaultc_Dtdbgfc_ValueProvider(bool a)2930         partial void DtFaultc_Dtdbgfc_ValueProvider(bool a);
2931 
2932         protected IFlagRegisterField dtfaultc_dtlockupfc_bit;
DtFaultc_Dtlockupfc_Write(bool a, bool b)2933         partial void DtFaultc_Dtlockupfc_Write(bool a, bool b);
DtFaultc_Dtlockupfc_ValueProvider(bool a)2934         partial void DtFaultc_Dtlockupfc_ValueProvider(bool a);
2935 
2936         protected IFlagRegisterField dtfaultc_dtem23fc_bit;
DtFaultc_Dtem23fc_Write(bool a, bool b)2937         partial void DtFaultc_Dtem23fc_Write(bool a, bool b);
DtFaultc_Dtem23fc_ValueProvider(bool a)2938         partial void DtFaultc_Dtem23fc_ValueProvider(bool a);
DtFaultc_Write(uint a, uint b)2939         partial void DtFaultc_Write(uint a, uint b);
DtFaultc_Read(uint a, uint b)2940         partial void DtFaultc_Read(uint a, uint b);
2941 
2942         // DtLock - Offset : 0xFC
2943 
2944         protected IEnumRegisterField<DTLOCK_DTILOCKKEY> dtlock_dtilockkey_field;
DtLock_Dtilockkey_Write(DTLOCK_DTILOCKKEY a, DTLOCK_DTILOCKKEY b)2945         partial void DtLock_Dtilockkey_Write(DTLOCK_DTILOCKKEY a, DTLOCK_DTILOCKKEY b);
DtLock_Dtilockkey_ValueProvider(DTLOCK_DTILOCKKEY a)2946         partial void DtLock_Dtilockkey_ValueProvider(DTLOCK_DTILOCKKEY a);
DtLock_Write(uint a, uint b)2947         partial void DtLock_Write(uint a, uint b);
DtLock_Read(uint a, uint b)2948         partial void DtLock_Read(uint a, uint b);
TIMER_Reset()2949         partial void TIMER_Reset();
2950 
EFR32xG2_TIMER_1_Constructor()2951         partial void EFR32xG2_TIMER_1_Constructor();
2952 
2953         public bool Enabled
2954         {
2955             get
2956             {
2957                 return en_en_bit.Value;
2958             }
2959             set
2960             {
2961                 en_en_bit.Value = value;
2962             }
2963         }
2964 
2965         private ICMU_EFR32xG2 _cmu;
2966         private ICMU_EFR32xG2 cmu
2967         {
2968             get
2969             {
2970                 if (Object.ReferenceEquals(_cmu, null))
2971                 {
2972                     foreach(var cmu in machine.GetPeripheralsOfType<ICMU_EFR32xG2>())
2973                     {
2974                         _cmu = cmu;
2975                     }
2976                 }
2977                 return _cmu;
2978             }
2979             set
2980             {
2981                 _cmu = value;
2982             }
2983         }
2984 
ReadDoubleWord(long offset)2985         public override uint ReadDoubleWord(long offset)
2986         {
2987             long temp = offset & 0x0FFF;
2988             switch(offset & 0x3000){
2989                 case 0x0000:
2990                     return registers.Read(offset);
2991                 default:
2992                     this.Log(LogLevel.Warning, "Reading from Set/Clr/Tgl is not supported.");
2993                     return registers.Read(temp);
2994             }
2995         }
2996 
WriteDoubleWord(long address, uint value)2997         public override void WriteDoubleWord(long address, uint value)
2998         {
2999             long temp = address & 0x0FFF;
3000             switch(address & 0x3000){
3001                 case 0x0000:
3002                     registers.Write(address, value);
3003                     break;
3004                 case 0x1000:
3005                     registers.Write(temp, registers.Read(temp) | value);
3006                     break;
3007                 case 0x2000:
3008                     registers.Write(temp, registers.Read(temp) & ~value);
3009                     break;
3010                 case 0x3000:
3011                     registers.Write(temp, registers.Read(temp) ^ value);
3012                     break;
3013                 default:
3014                     this.Log(LogLevel.Error, "writing doubleWord to non existing offset {0:X}, case : {1:X}", address, address & 0x3000);
3015                     break;
3016             }
3017         }
3018 
3019         protected enum Registers
3020         {
3021             Ipversion = 0x0,
3022             Cfg = 0x4,
3023             Ctrl = 0x8,
3024             Cmd = 0xC,
3025             Status = 0x10,
3026             If = 0x14,
3027             Ien = 0x18,
3028             Top = 0x1C,
3029             Topb = 0x20,
3030             Cnt = 0x24,
3031             Lock = 0x2C,
3032             En = 0x30,
3033             Cc0_Cfg = 0x60,
3034             Cc0_Ctrl = 0x64,
3035             Cc0_Oc = 0x68,
3036             Cc0_Ocb = 0x70,
3037             Cc0_Icf = 0x74,
3038             Cc0_Icof = 0x78,
3039             Cc1_Cfg = 0x80,
3040             Cc1_Ctrl = 0x84,
3041             Cc1_Oc = 0x88,
3042             Cc1_Ocb = 0x90,
3043             Cc1_Icf = 0x94,
3044             Cc1_Icof = 0x98,
3045             Cc2_Cfg = 0xA0,
3046             Cc2_Ctrl = 0xA4,
3047             Cc2_Oc = 0xA8,
3048             Cc2_Ocb = 0xB0,
3049             Cc2_Icf = 0xB4,
3050             Cc2_Icof = 0xB8,
3051             DtCfg = 0xE0,
3052             DtTimecfg = 0xE4,
3053             DtFcfg = 0xE8,
3054             DtCtrl = 0xEC,
3055             DtOgen = 0xF0,
3056             DtFault = 0xF4,
3057             DtFaultc = 0xF8,
3058             DtLock = 0xFC,
3059 
3060             Ipversion_SET = 0x1000,
3061             Cfg_SET = 0x1004,
3062             Ctrl_SET = 0x1008,
3063             Cmd_SET = 0x100C,
3064             Status_SET = 0x1010,
3065             If_SET = 0x1014,
3066             Ien_SET = 0x1018,
3067             Top_SET = 0x101C,
3068             Topb_SET = 0x1020,
3069             Cnt_SET = 0x1024,
3070             Lock_SET = 0x102C,
3071             En_SET = 0x1030,
3072             Cc0_Cfg_SET = 0x1060,
3073             Cc0_Ctrl_SET = 0x1064,
3074             Cc0_Oc_SET = 0x1068,
3075             Cc0_Ocb_SET = 0x1070,
3076             Cc0_Icf_SET = 0x1074,
3077             Cc0_Icof_SET = 0x1078,
3078             Cc1_Cfg_SET = 0x1080,
3079             Cc1_Ctrl_SET = 0x1084,
3080             Cc1_Oc_SET = 0x1088,
3081             Cc1_Ocb_SET = 0x1090,
3082             Cc1_Icf_SET = 0x1094,
3083             Cc1_Icof_SET = 0x1098,
3084             Cc2_Cfg_SET = 0x10A0,
3085             Cc2_Ctrl_SET = 0x10A4,
3086             Cc2_Oc_SET = 0x10A8,
3087             Cc2_Ocb_SET = 0x10B0,
3088             Cc2_Icf_SET = 0x10B4,
3089             Cc2_Icof_SET = 0x10B8,
3090             DtCfg_SET = 0x10E0,
3091             DtTimecfg_SET = 0x10E4,
3092             DtFcfg_SET = 0x10E8,
3093             DtCtrl_SET = 0x10EC,
3094             DtOgen_SET = 0x10F0,
3095             DtFault_SET = 0x10F4,
3096             DtFaultc_SET = 0x10F8,
3097             DtLock_SET = 0x10FC,
3098 
3099             Ipversion_CLR = 0x2000,
3100             Cfg_CLR = 0x2004,
3101             Ctrl_CLR = 0x2008,
3102             Cmd_CLR = 0x200C,
3103             Status_CLR = 0x2010,
3104             If_CLR = 0x2014,
3105             Ien_CLR = 0x2018,
3106             Top_CLR = 0x201C,
3107             Topb_CLR = 0x2020,
3108             Cnt_CLR = 0x2024,
3109             Lock_CLR = 0x202C,
3110             En_CLR = 0x2030,
3111             Cc0_Cfg_CLR = 0x2060,
3112             Cc0_Ctrl_CLR = 0x2064,
3113             Cc0_Oc_CLR = 0x2068,
3114             Cc0_Ocb_CLR = 0x2070,
3115             Cc0_Icf_CLR = 0x2074,
3116             Cc0_Icof_CLR = 0x2078,
3117             Cc1_Cfg_CLR = 0x2080,
3118             Cc1_Ctrl_CLR = 0x2084,
3119             Cc1_Oc_CLR = 0x2088,
3120             Cc1_Ocb_CLR = 0x2090,
3121             Cc1_Icf_CLR = 0x2094,
3122             Cc1_Icof_CLR = 0x2098,
3123             Cc2_Cfg_CLR = 0x20A0,
3124             Cc2_Ctrl_CLR = 0x20A4,
3125             Cc2_Oc_CLR = 0x20A8,
3126             Cc2_Ocb_CLR = 0x20B0,
3127             Cc2_Icf_CLR = 0x20B4,
3128             Cc2_Icof_CLR = 0x20B8,
3129             DtCfg_CLR = 0x20E0,
3130             DtTimecfg_CLR = 0x20E4,
3131             DtFcfg_CLR = 0x20E8,
3132             DtCtrl_CLR = 0x20EC,
3133             DtOgen_CLR = 0x20F0,
3134             DtFault_CLR = 0x20F4,
3135             DtFaultc_CLR = 0x20F8,
3136             DtLock_CLR = 0x20FC,
3137 
3138             Ipversion_TGL = 0x3000,
3139             Cfg_TGL = 0x3004,
3140             Ctrl_TGL = 0x3008,
3141             Cmd_TGL = 0x300C,
3142             Status_TGL = 0x3010,
3143             If_TGL = 0x3014,
3144             Ien_TGL = 0x3018,
3145             Top_TGL = 0x301C,
3146             Topb_TGL = 0x3020,
3147             Cnt_TGL = 0x3024,
3148             Lock_TGL = 0x302C,
3149             En_TGL = 0x3030,
3150             Cc0_Cfg_TGL = 0x3060,
3151             Cc0_Ctrl_TGL = 0x3064,
3152             Cc0_Oc_TGL = 0x3068,
3153             Cc0_Ocb_TGL = 0x3070,
3154             Cc0_Icf_TGL = 0x3074,
3155             Cc0_Icof_TGL = 0x3078,
3156             Cc1_Cfg_TGL = 0x3080,
3157             Cc1_Ctrl_TGL = 0x3084,
3158             Cc1_Oc_TGL = 0x3088,
3159             Cc1_Ocb_TGL = 0x3090,
3160             Cc1_Icf_TGL = 0x3094,
3161             Cc1_Icof_TGL = 0x3098,
3162             Cc2_Cfg_TGL = 0x30A0,
3163             Cc2_Ctrl_TGL = 0x30A4,
3164             Cc2_Oc_TGL = 0x30A8,
3165             Cc2_Ocb_TGL = 0x30B0,
3166             Cc2_Icf_TGL = 0x30B4,
3167             Cc2_Icof_TGL = 0x30B8,
3168             DtCfg_TGL = 0x30E0,
3169             DtTimecfg_TGL = 0x30E4,
3170             DtFcfg_TGL = 0x30E8,
3171             DtCtrl_TGL = 0x30EC,
3172             DtOgen_TGL = 0x30F0,
3173             DtFault_TGL = 0x30F4,
3174             DtFaultc_TGL = 0x30F8,
3175             DtLock_TGL = 0x30FC,
3176         }
3177 
3178         public long Size => 0x4000;
3179 
3180         protected DoubleWordRegisterCollection registers;
3181     }
3182 }