1 //
2 // Copyright (c) 2010-2024 Antmicro
3 //
4 // This file is licensed under the MIT License.
5 // Full license text is available in 'licenses/MIT.txt'.
6 //
7 using System;
8 using System.Collections.Generic;
9 using Antmicro.Renode.Core;
10 using Antmicro.Renode.Core.Structure.Registers;
11 using Antmicro.Renode.Logging;
12 using Antmicro.Renode.Peripherals.Bus;
13 using Antmicro.Renode.Peripherals.DMA;
14 
15 namespace Antmicro.Renode.Peripherals.UART
16 {
17     public class SAM_USART : UARTBase, IDoubleWordPeripheral, IProvidesRegisterCollection<DoubleWordRegisterCollection>, IKnownSize,
18         ISamPdcBytePeripheral
19     {
SAM_USART(IMachine machine, bool uartOnlyMode = false, bool enablePdc = false)20         public SAM_USART(IMachine machine, bool uartOnlyMode = false, bool enablePdc = false) : base(machine)
21         {
22             RegistersCollection = new DoubleWordRegisterCollection(this);
23             IRQ = new GPIO();
24             DefineRegisters(uartOnlyMode);
25             pdc = enablePdc ? new SAM_PDC(machine, this, (long)Registers.PdcReceivePointer, UpdateInterrupts) : null;
26             Size = enablePdc ? 0x128 : 0x100;
27             Reset();
28         }
29 
Reset()30         public override void Reset()
31         {
32             base.Reset();
33             RegistersCollection.Reset();
34             pdc?.Reset();
35             UpdateInterrupts();
36         }
37 
ReadDoubleWord(long offset)38         public uint ReadDoubleWord(long offset)
39         {
40             lock(innerLock)
41             {
42                 return RegistersCollection.Read(offset);
43             }
44         }
45 
WriteDoubleWord(long offset, uint value)46         public void WriteDoubleWord(long offset, uint value)
47         {
48             lock(innerLock)
49             {
50                 RegistersCollection.Write(offset, value);
51             }
52         }
53 
DmaByteRead()54         public byte? DmaByteRead() => ReadBuffer();
55         public void DmaByteWrite(byte data) => Transmit(data);
56 
57         public long Size { get; }
58         public GPIO IRQ { get; }
59         public DoubleWordRegisterCollection RegistersCollection { get; }
60 
61         public TransferType DmaReadAccessWidth => TransferType.Byte;
62         public TransferType DmaWriteAccessWidth => TransferType.Byte;
63 
64         public override uint BaudRate => 115200;
65 
66         public override Bits StopBits
67         {
68             get
69             {
70                 switch(numberOfStopBits.Value)
71                 {
72                 case NumberOfStopBitsValues.One:
73                     return Bits.One;
74                 case NumberOfStopBitsValues.Half:
75                     return Bits.Half;
76                 case NumberOfStopBitsValues.Two:
77                     return Bits.Two;
78                 case NumberOfStopBitsValues.OneAndAHalf:
79                     return Bits.OneAndAHalf;
80                 default:
81                     throw new ArgumentException("Invalid number of stop bits");
82                 }
83             }
84         }
85 
86         public override Parity ParityBit
87         {
88             get
89             {
90                 switch(parityType.Value)
91                 {
92                 case ParityTypeValues.Even:
93                     return Parity.Even;
94                 case ParityTypeValues.Odd:
95                     return Parity.Odd;
96                 case ParityTypeValues.Space:
97                     return Parity.Forced0;
98                 case ParityTypeValues.Mark:
99                     return Parity.Forced1;
100                 case ParityTypeValues.No:
101                     return Parity.None;
102                 case ParityTypeValues.Multidrop:
103                 case ParityTypeValues.AlsoMultidrop:
104                     return Parity.Multidrop;
105                 default:
106                     throw new ArgumentException("Invalid parity type");
107                 }
108             }
109         }
110 
CharWritten()111         protected override void CharWritten()
112         {
113             receiverReady.Value = true;
114             UpdateInterrupts();
115         }
116 
QueueEmptied()117         protected override void QueueEmptied()
118         {
119             UpdateInterrupts();
120         }
121 
DefineRegisters(bool uartOnlyMode)122         private void DefineRegisters(bool uartOnlyMode)
123         {
124             // NOTE: Registers are assumed not to be in SPI mode
125             Func<IFlagRegisterField, Action<bool, bool>> writeOneToClearFlag = flag => (_, value) =>
126             {
127                 if(value)
128                 {
129                     flag.Value = false;
130                 }
131             };
132 
133             Registers.Control.Define(this)
134                 .WithReservedBits(0, 2)
135                 .WithFlag(2, out var resetReceiver, FieldMode.Write, name: "RSTRX")
136                 .WithFlag(3, out var resetTransmitter, FieldMode.Write, name: "RSTTX")
137                 .WithFlag(4, out var enableReceiver, FieldMode.Write, name: "RXEN")
138                 .WithFlag(5, out var disableReceiver, FieldMode.Write, name: "RXDIS")
139                 .WithFlag(6, out var enableTransmitter, FieldMode.Write, name: "TXEN")
140                 .WithFlag(7, out var disableTransmitter, FieldMode.Write, name: "TXDIS")
141                 .WithTaggedFlag("RSTSTA", 8)
142                 .If(uartOnlyMode)
143                     .Then(reg => reg
144                         .WithReservedBits(9, 11)
145                     )
146                     .Else(reg => reg
147                         .WithTaggedFlag("STTBRK", 9)
148                         .WithTaggedFlag("STPBRK", 10)
149                         .WithTaggedFlag("STTTO", 11)
150                         .WithTaggedFlag("SENDA", 12)
151                         .WithTaggedFlag("RSTIT", 13)
152                         .WithTaggedFlag("RSTNACK", 14)
153                         .WithTaggedFlag("RETTO", 15)
154                         .WithTaggedFlag("DTREN", 16)
155                         .WithTaggedFlag("DTRDIS", 17)
156                         .WithTaggedFlag("RTSEN", 18)
157                         .WithTaggedFlag("RTSDIS", 19)
158                     )
159                 .WithReservedBits(20, 12)
160                 .WithWriteCallback((_, __) =>
161                 {
162                     if(resetReceiver.Value)
163                     {
164                         /* Clear FIFO */
165                         ClearBuffer();
166                         receiverEnabled = false;
167                     }
168 
169                     /* Determine what to do with the Receiver */
170                     if(disableReceiver.Value)
171                     {
172                         receiverEnabled = false;
173                     }
174                     else if(enableReceiver.Value)
175                     {
176                         receiverEnabled = true;
177                     }
178 
179                     /* Determine what to do with the Transmitter */
180                     if(disableTransmitter.Value || (resetTransmitter.Value && !enableTransmitter.Value))
181                     {
182                         transmitterEnabled = false;
183                     }
184                     else if(enableTransmitter.Value)
185                     {
186                         transmitterEnabled = true;
187                     }
188                     UpdateInterrupts();
189                 })
190             ;
191 
192             Registers.Mode.Define(this)
193                 .If(uartOnlyMode)
194                     .Then(reg => reg
195                         .WithReservedBits(0, 9)
196                     )
197                     .Else(reg => reg
198                         .WithValueField(0, 4, valueProviderCallback: _ => 0, writeCallback: (_, value) =>
199                         {
200                             if(value != 0)
201                             {
202                                 this.Log(LogLevel.Warning, "Trying to configure the device to an unsupported mode!");
203                             }
204                         }, name: "USART_MODE")
205                         .WithTag("USCLKS", 4, 2)
206                         .WithEnumField<DoubleWordRegister, CharacterLength>(6, 2, name: "CHRL")
207                         .WithTaggedFlag("SYNC", 8)
208                     )
209                 .WithEnumField(9, 3, out parityType, name: "PAR")
210                 .If(uartOnlyMode)
211                     .Then(reg => reg
212                         .WithReservedBits(12, 2)
213                     )
214                     .Else(reg => reg
215                         .WithEnumField(12, 2, out numberOfStopBits, name: "NBSTOP")
216                     )
217                 .WithTag("CHMODE", 14, 2)
218                 .If(uartOnlyMode)
219                     .Then(reg => reg
220                         .WithReservedBits(16, 16)
221                     )
222                     .Else(reg => reg
223                         .WithTaggedFlag("MSBF", 16)
224                         .WithTaggedFlag("MODE9", 17)
225                         .WithTaggedFlag("CLKO", 18)
226                         .WithTaggedFlag("OVER", 19)
227                         .WithTaggedFlag("INACK", 20)
228                         .WithTaggedFlag("DSNACK", 21)
229                         .WithTaggedFlag("VAR_SYNC", 22)
230                         .WithTaggedFlag("INVDATA", 23)
231                         .WithTag("MAX_ITERATION", 24, 3)
232                         .WithReservedBits(27, 1)
233                         .WithTaggedFlag("FILTER", 28)
234                         .WithTaggedFlag("MAN", 29)
235                         .WithTaggedFlag("MODSYNC", 30)
236                         .WithTaggedFlag("ONEBIT", 31)
237                     )
238             ;
239 
240             Registers.InterruptEnable.Define(this)
241                 .WithFlag(0, out receiverReadyIrqEnabled, FieldMode.Set, name: "IER_RXRDY")
242                 .WithFlag(1, out transmitterReadyIrqEnabled, FieldMode.Set, name: "IER_TXRDY")
243                 .If(uartOnlyMode)
244                     .Then(reg => reg
245                         .WithReservedBits(2, 1)
246                     )
247                     .Else(reg => reg
248                         .WithTaggedFlag("RXBRK", 2)
249                     )
250                 .WithFlag(3, out endOfRxBufferIrqEnabled, FieldMode.Set, name: "ENDRX")
251                 .WithFlag(4, out endOfTxBufferIrqEnabled, FieldMode.Set, name: "ENDTX")
252                 .WithTaggedFlag("OVRE", 5)
253                 .WithTaggedFlag("FRAME", 6)
254                 .WithTaggedFlag("PARE", 7)
255                 .If(uartOnlyMode)
256                     .Then(reg => reg
257                         .WithReservedBits(8, 1)
258                     )
259                     .Else(reg => reg
260                         .WithTaggedFlag("TIMEOUT", 8)
261                     )
262                 .WithFlag(9, out txEmptyEnabled, FieldMode.Set, name: "TXEMPTY")
263                 .If(uartOnlyMode)
264                     .Then(reg => reg
265                         .WithReservedBits(10, 1)
266                     )
267                     .Else(reg => reg
268                         .WithTaggedFlag("ITER", 10)
269                     )
270                 .WithFlag(11, out txBufferEmptyIrqEnabled, FieldMode.Set, name: "TXBUFE")
271                 .WithFlag(12, out rxBufferFullIrqEnabled, FieldMode.Set, name: "RXBUFF")
272                 .If(uartOnlyMode)
273                     .Then(reg => reg
274                         .WithReservedBits(13, 12)
275                     )
276                     .Else(reg => reg
277                         .WithTaggedFlag("NACK", 13)
278                         .WithReservedBits(14, 2)
279                         .WithTaggedFlag("RIIC", 16)
280                         .WithTaggedFlag("DSRIC", 17)
281                         .WithTaggedFlag("DCDIC", 18)
282                         .WithTaggedFlag("CTSIC", 19)
283                         .WithReservedBits(20, 4)
284                         .WithTaggedFlag("MANE", 24)
285                     )
286                 .WithReservedBits(25, 7)
287                 .WithWriteCallback((_, __) => UpdateInterrupts())
288             ;
289 
290             Registers.InterruptDisable.Define(this)
291                 .WithFlag(0, FieldMode.Write, writeCallback: writeOneToClearFlag(receiverReadyIrqEnabled), name: "IDR_RXRDY")
292                 .WithFlag(1, FieldMode.Write, writeCallback: writeOneToClearFlag(transmitterReadyIrqEnabled), name: "IDR_TXRDY")
293                 .If(uartOnlyMode)
294                     .Then(reg => reg
295                         .WithReservedBits(2, 1)
296                     )
297                     .Else(reg => reg
298                         .WithTaggedFlag("RXBRK", 2)
299                     )
300                 .WithFlag(3, FieldMode.Write, writeCallback: writeOneToClearFlag(endOfRxBufferIrqEnabled), name: "ENDRX")
301                 .WithFlag(4, FieldMode.Write, writeCallback: writeOneToClearFlag(endOfTxBufferIrqEnabled), name: "ENDTX")
302                 .WithTaggedFlag("OVRE", 5)
303                 .WithTaggedFlag("FRAME", 6)
304                 .WithTaggedFlag("PARE", 7)
305                 .If(uartOnlyMode)
306                     .Then(reg => reg
307                         .WithReservedBits(8, 1)
308                     )
309                     .Else(reg => reg
310                         .WithTaggedFlag("TIMEOUT", 8)
311                     )
312                 .WithFlag(9, FieldMode.Write, writeCallback: writeOneToClearFlag(txEmptyEnabled), name: "TXEMPTY")
313                 .If(uartOnlyMode)
314                     .Then(reg => reg
315                         .WithReservedBits(10, 1)
316                     )
317                     .Else(reg => reg
318                         .WithTaggedFlag("ITER", 10)
319                     )
320                 .WithFlag(11, FieldMode.Write, writeCallback: writeOneToClearFlag(txBufferEmptyIrqEnabled), name: "TXBUFE")
321                 .WithFlag(12, FieldMode.Write, writeCallback: writeOneToClearFlag(rxBufferFullIrqEnabled), name: "RXBUFF")
322                 .If(uartOnlyMode)
323                     .Then(reg => reg
324                         .WithReservedBits(13, 12)
325                     )
326                     .Else(reg => reg
327                         .WithTaggedFlag("NACK", 13)
328                         .WithReservedBits(14, 2)
329                         .WithTaggedFlag("RIIC", 16)
330                         .WithTaggedFlag("DSRIC", 17)
331                         .WithTaggedFlag("DCDIC", 18)
332                         .WithTaggedFlag("CTSIC", 19)
333                         .WithReservedBits(20, 4)
334                         .WithTaggedFlag("MANE", 24)
335                     )
336                 .WithReservedBits(25, 7)
337                 .WithWriteCallback((_, __) => UpdateInterrupts())
338             ;
339 
340             Registers.InterruptMask.Define(this)
341                 .WithFlag(0, FieldMode.Read, valueProviderCallback: _ => receiverReadyIrqEnabled.Value, name: "IMR_RXRDY")
342                 .WithFlag(1, FieldMode.Read, valueProviderCallback: _ => transmitterReadyIrqEnabled.Value, name: "IMR_TXRDY")
343                 .If(uartOnlyMode)
344                     .Then(reg => reg
345                         .WithReservedBits(2, 1)
346                     )
347                     .Else(reg => reg
348                         .WithTaggedFlag("RXBRK", 2)
349                     )
350                 .WithFlag(3, FieldMode.Read, valueProviderCallback: _ => endOfRxBufferIrqEnabled.Value, name: "ENDRX")
351                 .WithFlag(4, FieldMode.Read, valueProviderCallback: _ => endOfTxBufferIrqEnabled.Value, name: "ENDTX")
352                 .WithTaggedFlag("OVRE", 5)
353                 .WithTaggedFlag("FRAME", 6)
354                 .If(uartOnlyMode)
355                     .Then(reg => reg
356                         .WithReservedBits(8, 1)
357                     )
358                     .Else(reg => reg
359                         .WithTaggedFlag("TIMEOUT", 8)
360                     )
361                 .WithFlag(9, FieldMode.Read, valueProviderCallback: _ => txEmptyEnabled.Value, name: "TXEMPTY")
362                 .If(uartOnlyMode)
363                     .Then(reg => reg
364                         .WithReservedBits(10, 1)
365                     )
366                     .Else(reg => reg
367                         .WithTaggedFlag("ITER", 10)
368                     )
369                 .WithFlag(11, FieldMode.Read, valueProviderCallback: _ => txBufferEmptyIrqEnabled.Value, name: "TXBUFE")
370                 .WithFlag(12, FieldMode.Read, valueProviderCallback: _ => rxBufferFullIrqEnabled.Value, name: "RXBUFF")
371                 .If(uartOnlyMode)
372                     .Then(reg => reg
373                         .WithReservedBits(13, 12)
374                     )
375                     .Else(reg => reg
376                         .WithTaggedFlag("NACK", 13)
377                         .WithReservedBits(14, 2)
378                         .WithTaggedFlag("RIIC", 16)
379                         .WithTaggedFlag("DSRIC", 17)
380                         .WithTaggedFlag("DCDIC", 18)
381                         .WithTaggedFlag("CTSIC", 19)
382                         .WithReservedBits(20, 4)
383                         .WithTaggedFlag("MANE", 24)
384                     )
385                 .WithReservedBits(25, 7)
386                 .WithWriteCallback((_, __) => UpdateInterrupts())
387             ;
388 
389             Registers.ChannelStatus.Define(this)
390                 .WithFlag(0, out receiverReady, FieldMode.Read, name: "RXRDY")
391                 .WithFlag(1, FieldMode.Read, valueProviderCallback: _ =>
392                 {
393                     return transmitterEnabled;
394                 }, name: "TXRDY")
395                 .If(uartOnlyMode)
396                     .Then(reg => reg
397                         .WithReservedBits(2, 1)
398                     )
399                     .Else(reg => reg
400                         .WithTaggedFlag("RXBRK", 2)
401                     )
402                 .WithFlag(3, FieldMode.Read, valueProviderCallback: _ => pdc?.EndOfRxBuffer ?? false, name: "ENDRX")
403                 .WithFlag(4, FieldMode.Read, valueProviderCallback: _ => pdc?.EndOfTxBuffer ?? false, name: "ENDTX")
404                 .WithTaggedFlag("OVRE", 5)
405                 .WithTaggedFlag("FRAME", 6)
406                 .WithTaggedFlag("PARE", 7)
407                 .If(uartOnlyMode)
408                     .Then(reg => reg
409                         .WithReservedBits(8, 1)
410                     )
411                     .Else(reg => reg
412                         .WithTaggedFlag("TIMEOUT", 8)
413                     )
414                 .WithFlag(9, FieldMode.Read, valueProviderCallback: _ => true, name: "TXEMPTY")
415                 .If(uartOnlyMode)
416                     .Then(reg => reg
417                         .WithReservedBits(10, 1)
418                     )
419                     .Else(reg => reg
420                         .WithTaggedFlag("ITER", 10)
421                     )
422                 .WithFlag(11, FieldMode.Read, valueProviderCallback: _ => pdc?.TxBufferEmpty ?? false, name: "TXBUFE")
423                 .WithFlag(12, FieldMode.Read, valueProviderCallback: _ => pdc?.RxBufferFull ?? false, name: "RXBUFF")
424                 .If(uartOnlyMode)
425                     .Then(reg => reg
426                         .WithReservedBits(13, 12)
427                     )
428                     .Else(reg => reg
429                         .WithTaggedFlag("NACK", 13)
430                         .WithReservedBits(14, 2)
431                         .WithTaggedFlag("RIIC", 16)
432                         .WithTaggedFlag("DSRIC", 17)
433                         .WithTaggedFlag("DCDIC", 18)
434                         .WithTaggedFlag("CTSIC", 19)
435                         .WithTaggedFlag("RI", 20)
436                         .WithTaggedFlag("DSR", 21)
437                         .WithTaggedFlag("DCD", 22)
438                         .WithTaggedFlag("CTS", 23)
439                         .WithTaggedFlag("MANERR", 24)
440                     )
441                 .WithReservedBits(25, 7)
442             ;
443 
444             Registers.ReceiveHolding.Define(this)
445                 .WithValueField(0, 9, FieldMode.Read, valueProviderCallback: _ => ReadBuffer(true) ?? 0x0, name: "RXCHR")
446                 .WithReservedBits(9, 6)
447                 .If(uartOnlyMode)
448                     .Then(reg => reg
449                         .WithReservedBits(15, 1)
450                     )
451                     .Else(reg => reg
452                         .WithTaggedFlag("RXSYNH", 15)
453                     )
454                 .WithReservedBits(16, 16)
455             ;
456 
457             Registers.TransmitHolding.Define(this)
458                 .WithValueField(0, 9, FieldMode.Write, writeCallback: (_, b) => Transmit((byte)b), name: "TXCHR")
459                 .WithReservedBits(9, 6)
460                 .If(uartOnlyMode)
461                     .Then(reg => reg
462                         .WithReservedBits(15, 1)
463                     )
464                     .Else(reg => reg
465                         .WithTaggedFlag("TXSYNH", 15)
466                     )
467                 .WithReservedBits(16, 16)
468             ;
469 
470             Registers.BaudRateGenerator.Define(this)
471                 .WithValueField(0, 16, name: "CD")
472                 .If(uartOnlyMode)
473                     .Then(reg => reg
474                         .WithReservedBits(16, 3)
475                     )
476                     .Else(reg => reg
477                         .WithTag("FP", 16, 3)
478                     )
479                 .WithReservedBits(19, 13)
480             ;
481 
482             if(uartOnlyMode)
483             {
484                 return;
485             }
486 
487             Registers.ReceiveTimeout.Define(this)
488                 .WithTag("TO", 0, 16)
489                 .WithReservedBits(16, 16)
490             ;
491 
492             Registers.TransmitterTimeguard.Define(this)
493                 .WithTag("TG", 0, 8)
494                 .WithReservedBits(8, 24)
495             ;
496 
497             Registers.FIDIRatio.Define(this)
498                 .WithTag("FI_DI_RATIO", 0, 11)
499                 .WithReservedBits(11, 21)
500             ;
501 
502             Registers.NumberOfErrors.Define(this)
503                 .WithTag("NB_ERRORS", 0, 8)
504                 .WithReservedBits(8, 24)
505             ;
506 
507             Registers.IrDAFilter.Define(this)
508                 .WithTag("IRDA_FILTER", 0, 8)
509                 .WithReservedBits(8, 24)
510             ;
511 
512             Registers.ManchesterConfiguration.Define(this)
513                 .WithTag("TX_PL", 0, 4)
514                 .WithReservedBits(4, 4)
515                 .WithTag("TX_PP", 8, 2)
516                 .WithReservedBits(10, 2)
517                 .WithTaggedFlag("TX_MPOL", 12)
518                 .WithReservedBits(13, 3)
519                 .WithTag("RX_PL", 16, 4)
520                 .WithReservedBits(20, 4)
521                 .WithTag("RX_PP", 24, 2)
522                 .WithReservedBits(26, 2)
523                 .WithTaggedFlag("RX_MPOL", 28)
524                 .WithTaggedFlag("ONE", 29)
525                 .WithTaggedFlag("DRIFT", 30)
526                 .WithReservedBits(31, 1)
527             ;
528 
529             Registers.WriteProtectionMode.Define(this)
530                 .WithTaggedFlag("WPEN", 0)
531                 .WithReservedBits(1, 7)
532                 .WithTag("WPKEY", 8, 24)
533             ;
534 
535             Registers.WriteProtectionStatus.Define(this)
536                 .WithTaggedFlag("WPVS", 0)
537                 .WithReservedBits(1, 7)
538                 .WithTag("WPVSRC", 8, 16)
539                 .WithReservedBits(24, 8)
540             ;
541         }
542 
Transmit(byte data)543         private void Transmit(byte data)
544         {
545             if(!transmitterEnabled)
546             {
547                 return;
548             }
549 
550             this.TransmitCharacter((byte)data);
551             UpdateInterrupts();
552         }
553 
ReadBuffer(bool warnEmpty = false)554         private byte? ReadBuffer(bool warnEmpty = false)
555         {
556             if(!receiverEnabled)
557             {
558                 return null;
559             }
560 
561             if(!TryGetCharacter(out var character))
562             {
563                 if(warnEmpty)
564                 {
565                     this.Log(LogLevel.Warning, "Trying to read data from empty receive fifo");
566                 }
567                 return null;
568             }
569             if(Count == 0)
570             {
571                 receiverReady.Value = false;
572             }
573             UpdateInterrupts();
574             return character;
575         }
576 
UpdateInterrupts()577         private void UpdateInterrupts()
578         {
579             var state = false;
580             state |= receiverEnabled && receiverReadyIrqEnabled.Value && receiverReady.Value;
581             state |= transmitterEnabled && transmitterReadyIrqEnabled.Value;
582             state |= transmitterEnabled && txEmptyEnabled.Value;
583             state |= (pdc?.EndOfRxBuffer ?? false) && endOfRxBufferIrqEnabled.Value;
584             state |= (pdc?.EndOfTxBuffer ?? false) && endOfTxBufferIrqEnabled.Value;
585             state |= (pdc?.TxBufferEmpty ?? false) && txBufferEmptyIrqEnabled.Value;
586             state |= (pdc?.RxBufferFull ?? false) && rxBufferFullIrqEnabled.Value;
587             this.DebugLog("IRQ {0}", state ? "set" : "unset");
588             IRQ.Set(state);
589         }
590 
591         private IFlagRegisterField receiverReady;
592 
593         private IFlagRegisterField receiverReadyIrqEnabled;
594         private IFlagRegisterField transmitterReadyIrqEnabled;
595         private IFlagRegisterField endOfRxBufferIrqEnabled;
596         private IFlagRegisterField endOfTxBufferIrqEnabled;
597         private IFlagRegisterField txBufferEmptyIrqEnabled;
598         private IFlagRegisterField rxBufferFullIrqEnabled;
599         private IFlagRegisterField txEmptyEnabled;
600 
601         private IEnumRegisterField<ParityTypeValues> parityType;
602         private IEnumRegisterField<NumberOfStopBitsValues> numberOfStopBits;
603 
604         private bool receiverEnabled;
605         private bool transmitterEnabled;
606 
607         private readonly SAM_PDC pdc;
608 
609         private enum ParityTypeValues
610         {
611             Even = 0,
612             Odd = 1,
613             Space = 2,
614             Mark = 3,
615             No = 4,
616             Multidrop = 7,
617             AlsoMultidrop = 6
618         }
619 
620         private enum NumberOfStopBitsValues
621         {
622             One = 0,
623             Half = 1,
624             Two = 2,
625             OneAndAHalf = 3
626         }
627 
628         private enum CharacterLength
629         {
630             FiveBits = 0,
631             SixBits = 1,
632             SevenBits = 2,
633             EightBits = 3,
634         }
635 
636         private enum Registers
637         {
638             Control = 0x0,
639             Mode = 0x04,
640             InterruptEnable = 0x08,
641             InterruptDisable = 0x0C,
642             InterruptMask = 0x10,
643             ChannelStatus = 0x14,
644             ReceiveHolding = 0x18,
645             TransmitHolding = 0x1C,
646             BaudRateGenerator = 0x20,
647             ReceiveTimeout = 0x24,
648             TransmitterTimeguard = 0x28,
649             FIDIRatio = 0x40,
650             NumberOfErrors = 0x44,
651             IrDAFilter = 0x4C,
652             ManchesterConfiguration = 0x50,
653             LINMode = 0x54,
654             LINIdentifier = 0x58,
655             LINBaudRate = 0x5C,
656             LONMode = 0x60,
657             LONPreamble = 0x64,
658             LONDataLength = 0x68,
659             LONL2HDR = 0x6C,
660             LONBacklog = 0x70,
661             LONBeta1TX = 0x74,
662             LONBeta1RX = 0x78,
663             LONPriority = 0x7C,
664             LONIntermediateTimeAfterTransmission = 0x80,
665             LONIntermediateTimeAfterReception = 0x84,
666             ICDifferentiator = 0x88,
667             WriteProtectionMode = 0xE4,
668             WriteProtectionStatus = 0xE8,
669             PdcReceivePointer = 0x100,
670             PdcReceiveCounter = 0x104,
671             PdcTransmitPointer = 0x108,
672             PdcTransmitCounter = 0x10C,
673             PdcReceiveNextPointer = 0x110,
674             PdcReceiveNextCounter = 0x114,
675             PdcTransmitNextPointer = 0x118,
676             PdcTransmitNextCounter = 0x11C,
677             PdcTransferControl = 0x120,
678             PdcTransferStatus = 0x124,
679         }
680     }
681 }
682