1 /********************************************************
2 *
3 * Warning!
4 * This file was generated automatically.
5 * Please do not edit. Changes should be made in the
6 * appropriate *.tt file.
7 *
8 */
9 using System;
10 using System.Text;
11 using Antmicro.Renode.Logging;
12 using Antmicro.Renode.Peripherals;
13 using Antmicro.Renode.Peripherals.Bus;
14 using Antmicro.Renode.Utilities;
15 
16 namespace Antmicro.Renode.Core.Extensions
17 {
18     public static class ReadWriteExtensions
19     {
ReadWordUsingByte(this IBytePeripheral peripheral, long address)20         public static ushort ReadWordUsingByte(this IBytePeripheral peripheral, long address)
21         {
22             unchecked
23             {
24                 return (ushort)((ushort)peripheral.ReadByte(address)
25                     | (ushort)peripheral.ReadByte(address + 1) << 8
26                 );
27             }
28         }
29 
BuildWordReadUsing(BusAccess.ByteReadMethod read)30         public static BusAccess.WordReadMethod BuildWordReadUsing(BusAccess.ByteReadMethod read)
31         {
32             return address =>
33             {
34                 unchecked
35                 {
36                     return (ushort)((ushort)read(address)
37                         | (ushort)read(address + 1) << 8
38                     );
39                 }
40             };
41         }
42 
WriteWordUsingByte(this IBytePeripheral peripheral, long address, ushort value)43         public static void WriteWordUsingByte(this IBytePeripheral peripheral, long address, ushort value)
44         {
45             unchecked
46             {
47                 peripheral.WriteByte(address + 0, (byte)(value >> 0));
48                 peripheral.WriteByte(address + 1, (byte)(value >> 8));
49             }
50         }
51 
BuildWordWriteUsing(BusAccess.ByteReadMethod read, BusAccess.ByteWriteMethod write)52         public static BusAccess.WordWriteMethod BuildWordWriteUsing(BusAccess.ByteReadMethod read, BusAccess.ByteWriteMethod write)
53         {
54             return (address, value) =>
55             {
56                 unchecked
57                 {
58                     write(address + 0, (byte)(value >> 0));
59                     write(address + 1, (byte)(value >> 8));
60                 }
61             };
62         }
63 
ReadWordUsingByteBigEndian(this IBytePeripheral peripheral, long address)64         public static ushort ReadWordUsingByteBigEndian(this IBytePeripheral peripheral, long address)
65         {
66             unchecked
67             {
68                 return (ushort)((ushort)(peripheral.ReadByte(address + 1))
69                     | (ushort)(peripheral.ReadByte(address + 0)) << 8
70                 );
71             }
72         }
73 
BuildWordReadBigEndianUsing(BusAccess.ByteReadMethod read)74         public static BusAccess.WordReadMethod BuildWordReadBigEndianUsing(BusAccess.ByteReadMethod read)
75         {
76             return address =>
77             {
78                 unchecked
79                 {
80                     return (ushort)((ushort)(read(address + 1))
81                         | (ushort)(read(address + 0)) << 8
82                     );
83                 }
84             };
85         }
86 
WriteWordUsingByteBigEndian(this IBytePeripheral peripheral, long address, ushort value)87         public static void WriteWordUsingByteBigEndian(this IBytePeripheral peripheral, long address, ushort value)
88         {
89             unchecked
90             {
91                 peripheral.WriteByte(address + 0, ((byte)(value >> 8)));
92                 peripheral.WriteByte(address + 1, ((byte)(value >> 0)));
93             }
94         }
95 
BuildWordWriteBigEndianUsing(BusAccess.ByteReadMethod read, BusAccess.ByteWriteMethod write)96         public static BusAccess.WordWriteMethod BuildWordWriteBigEndianUsing(BusAccess.ByteReadMethod read, BusAccess.ByteWriteMethod write)
97         {
98             return (address, value) =>
99             {
100                 unchecked
101                 {
102                     write(address + 0, ((byte)(value >> 8)));
103                     write(address + 1, ((byte)(value >> 0)));
104                 }
105             };
106         }
107 
ReadDoubleWordUsingByte(this IBytePeripheral peripheral, long address)108         public static uint ReadDoubleWordUsingByte(this IBytePeripheral peripheral, long address)
109         {
110             unchecked
111             {
112                 return (uint)((uint)peripheral.ReadByte(address)
113                     | (uint)peripheral.ReadByte(address + 1) << 8
114                     | (uint)peripheral.ReadByte(address + 2) << 16
115                     | (uint)peripheral.ReadByte(address + 3) << 24
116                 );
117             }
118         }
119 
BuildDoubleWordReadUsing(BusAccess.ByteReadMethod read)120         public static BusAccess.DoubleWordReadMethod BuildDoubleWordReadUsing(BusAccess.ByteReadMethod read)
121         {
122             return address =>
123             {
124                 unchecked
125                 {
126                     return (uint)((uint)read(address)
127                         | (uint)read(address + 1) << 8
128                         | (uint)read(address + 2) << 16
129                         | (uint)read(address + 3) << 24
130                     );
131                 }
132             };
133         }
134 
WriteDoubleWordUsingByte(this IBytePeripheral peripheral, long address, uint value)135         public static void WriteDoubleWordUsingByte(this IBytePeripheral peripheral, long address, uint value)
136         {
137             unchecked
138             {
139                 peripheral.WriteByte(address + 0, (byte)(value >> 0));
140                 peripheral.WriteByte(address + 1, (byte)(value >> 8));
141                 peripheral.WriteByte(address + 2, (byte)(value >> 16));
142                 peripheral.WriteByte(address + 3, (byte)(value >> 24));
143             }
144         }
145 
BuildDoubleWordWriteUsing(BusAccess.ByteReadMethod read, BusAccess.ByteWriteMethod write)146         public static BusAccess.DoubleWordWriteMethod BuildDoubleWordWriteUsing(BusAccess.ByteReadMethod read, BusAccess.ByteWriteMethod write)
147         {
148             return (address, value) =>
149             {
150                 unchecked
151                 {
152                     write(address + 0, (byte)(value >> 0));
153                     write(address + 1, (byte)(value >> 8));
154                     write(address + 2, (byte)(value >> 16));
155                     write(address + 3, (byte)(value >> 24));
156                 }
157             };
158         }
159 
ReadDoubleWordUsingByteBigEndian(this IBytePeripheral peripheral, long address)160         public static uint ReadDoubleWordUsingByteBigEndian(this IBytePeripheral peripheral, long address)
161         {
162             unchecked
163             {
164                 return (uint)((uint)(peripheral.ReadByte(address + 3))
165                     | (uint)(peripheral.ReadByte(address + 2)) << 8
166                     | (uint)(peripheral.ReadByte(address + 1)) << 16
167                     | (uint)(peripheral.ReadByte(address + 0)) << 24
168                 );
169             }
170         }
171 
BuildDoubleWordReadBigEndianUsing(BusAccess.ByteReadMethod read)172         public static BusAccess.DoubleWordReadMethod BuildDoubleWordReadBigEndianUsing(BusAccess.ByteReadMethod read)
173         {
174             return address =>
175             {
176                 unchecked
177                 {
178                     return (uint)((uint)(read(address + 3))
179                         | (uint)(read(address + 2)) << 8
180                         | (uint)(read(address + 1)) << 16
181                         | (uint)(read(address + 0)) << 24
182                     );
183                 }
184             };
185         }
186 
WriteDoubleWordUsingByteBigEndian(this IBytePeripheral peripheral, long address, uint value)187         public static void WriteDoubleWordUsingByteBigEndian(this IBytePeripheral peripheral, long address, uint value)
188         {
189             unchecked
190             {
191                 peripheral.WriteByte(address + 0, ((byte)(value >> 24)));
192                 peripheral.WriteByte(address + 1, ((byte)(value >> 16)));
193                 peripheral.WriteByte(address + 2, ((byte)(value >> 8)));
194                 peripheral.WriteByte(address + 3, ((byte)(value >> 0)));
195             }
196         }
197 
BuildDoubleWordWriteBigEndianUsing(BusAccess.ByteReadMethod read, BusAccess.ByteWriteMethod write)198         public static BusAccess.DoubleWordWriteMethod BuildDoubleWordWriteBigEndianUsing(BusAccess.ByteReadMethod read, BusAccess.ByteWriteMethod write)
199         {
200             return (address, value) =>
201             {
202                 unchecked
203                 {
204                     write(address + 0, ((byte)(value >> 24)));
205                     write(address + 1, ((byte)(value >> 16)));
206                     write(address + 2, ((byte)(value >> 8)));
207                     write(address + 3, ((byte)(value >> 0)));
208                 }
209             };
210         }
211 
ReadQuadWordUsingByte(this IBytePeripheral peripheral, long address)212         public static ulong ReadQuadWordUsingByte(this IBytePeripheral peripheral, long address)
213         {
214             unchecked
215             {
216                 return (ulong)((ulong)peripheral.ReadByte(address)
217                     | (ulong)peripheral.ReadByte(address + 1) << 8
218                     | (ulong)peripheral.ReadByte(address + 2) << 16
219                     | (ulong)peripheral.ReadByte(address + 3) << 24
220                     | (ulong)peripheral.ReadByte(address + 4) << 32
221                     | (ulong)peripheral.ReadByte(address + 5) << 40
222                     | (ulong)peripheral.ReadByte(address + 6) << 48
223                     | (ulong)peripheral.ReadByte(address + 7) << 56
224                 );
225             }
226         }
227 
BuildQuadWordReadUsing(BusAccess.ByteReadMethod read)228         public static BusAccess.QuadWordReadMethod BuildQuadWordReadUsing(BusAccess.ByteReadMethod read)
229         {
230             return address =>
231             {
232                 unchecked
233                 {
234                     return (ulong)((ulong)read(address)
235                         | (ulong)read(address + 1) << 8
236                         | (ulong)read(address + 2) << 16
237                         | (ulong)read(address + 3) << 24
238                         | (ulong)read(address + 4) << 32
239                         | (ulong)read(address + 5) << 40
240                         | (ulong)read(address + 6) << 48
241                         | (ulong)read(address + 7) << 56
242                     );
243                 }
244             };
245         }
246 
WriteQuadWordUsingByte(this IBytePeripheral peripheral, long address, ulong value)247         public static void WriteQuadWordUsingByte(this IBytePeripheral peripheral, long address, ulong value)
248         {
249             unchecked
250             {
251                 peripheral.WriteByte(address + 0, (byte)(value >> 0));
252                 peripheral.WriteByte(address + 1, (byte)(value >> 8));
253                 peripheral.WriteByte(address + 2, (byte)(value >> 16));
254                 peripheral.WriteByte(address + 3, (byte)(value >> 24));
255                 peripheral.WriteByte(address + 4, (byte)(value >> 32));
256                 peripheral.WriteByte(address + 5, (byte)(value >> 40));
257                 peripheral.WriteByte(address + 6, (byte)(value >> 48));
258                 peripheral.WriteByte(address + 7, (byte)(value >> 56));
259             }
260         }
261 
BuildQuadWordWriteUsing(BusAccess.ByteReadMethod read, BusAccess.ByteWriteMethod write)262         public static BusAccess.QuadWordWriteMethod BuildQuadWordWriteUsing(BusAccess.ByteReadMethod read, BusAccess.ByteWriteMethod write)
263         {
264             return (address, value) =>
265             {
266                 unchecked
267                 {
268                     write(address + 0, (byte)(value >> 0));
269                     write(address + 1, (byte)(value >> 8));
270                     write(address + 2, (byte)(value >> 16));
271                     write(address + 3, (byte)(value >> 24));
272                     write(address + 4, (byte)(value >> 32));
273                     write(address + 5, (byte)(value >> 40));
274                     write(address + 6, (byte)(value >> 48));
275                     write(address + 7, (byte)(value >> 56));
276                 }
277             };
278         }
279 
ReadQuadWordUsingByteBigEndian(this IBytePeripheral peripheral, long address)280         public static ulong ReadQuadWordUsingByteBigEndian(this IBytePeripheral peripheral, long address)
281         {
282             unchecked
283             {
284                 return (ulong)((ulong)(peripheral.ReadByte(address + 7))
285                     | (ulong)(peripheral.ReadByte(address + 6)) << 8
286                     | (ulong)(peripheral.ReadByte(address + 5)) << 16
287                     | (ulong)(peripheral.ReadByte(address + 4)) << 24
288                     | (ulong)(peripheral.ReadByte(address + 3)) << 32
289                     | (ulong)(peripheral.ReadByte(address + 2)) << 40
290                     | (ulong)(peripheral.ReadByte(address + 1)) << 48
291                     | (ulong)(peripheral.ReadByte(address + 0)) << 56
292                 );
293             }
294         }
295 
BuildQuadWordReadBigEndianUsing(BusAccess.ByteReadMethod read)296         public static BusAccess.QuadWordReadMethod BuildQuadWordReadBigEndianUsing(BusAccess.ByteReadMethod read)
297         {
298             return address =>
299             {
300                 unchecked
301                 {
302                     return (ulong)((ulong)(read(address + 7))
303                         | (ulong)(read(address + 6)) << 8
304                         | (ulong)(read(address + 5)) << 16
305                         | (ulong)(read(address + 4)) << 24
306                         | (ulong)(read(address + 3)) << 32
307                         | (ulong)(read(address + 2)) << 40
308                         | (ulong)(read(address + 1)) << 48
309                         | (ulong)(read(address + 0)) << 56
310                     );
311                 }
312             };
313         }
314 
WriteQuadWordUsingByteBigEndian(this IBytePeripheral peripheral, long address, ulong value)315         public static void WriteQuadWordUsingByteBigEndian(this IBytePeripheral peripheral, long address, ulong value)
316         {
317             unchecked
318             {
319                 peripheral.WriteByte(address + 0, ((byte)(value >> 56)));
320                 peripheral.WriteByte(address + 1, ((byte)(value >> 48)));
321                 peripheral.WriteByte(address + 2, ((byte)(value >> 40)));
322                 peripheral.WriteByte(address + 3, ((byte)(value >> 32)));
323                 peripheral.WriteByte(address + 4, ((byte)(value >> 24)));
324                 peripheral.WriteByte(address + 5, ((byte)(value >> 16)));
325                 peripheral.WriteByte(address + 6, ((byte)(value >> 8)));
326                 peripheral.WriteByte(address + 7, ((byte)(value >> 0)));
327             }
328         }
329 
BuildQuadWordWriteBigEndianUsing(BusAccess.ByteReadMethod read, BusAccess.ByteWriteMethod write)330         public static BusAccess.QuadWordWriteMethod BuildQuadWordWriteBigEndianUsing(BusAccess.ByteReadMethod read, BusAccess.ByteWriteMethod write)
331         {
332             return (address, value) =>
333             {
334                 unchecked
335                 {
336                     write(address + 0, ((byte)(value >> 56)));
337                     write(address + 1, ((byte)(value >> 48)));
338                     write(address + 2, ((byte)(value >> 40)));
339                     write(address + 3, ((byte)(value >> 32)));
340                     write(address + 4, ((byte)(value >> 24)));
341                     write(address + 5, ((byte)(value >> 16)));
342                     write(address + 6, ((byte)(value >> 8)));
343                     write(address + 7, ((byte)(value >> 0)));
344                 }
345             };
346         }
347 
ReadByteUsingWord(this IWordPeripheral peripheral, long address)348         public static byte ReadByteUsingWord(this IWordPeripheral peripheral, long address)
349         {
350             unchecked
351             {
352                 var readAddress = address & (~1);
353                 var offset = (int)(address & 1);
354                 return (byte)(peripheral.ReadWord(readAddress) >> offset * 8);
355             }
356         }
357 
BuildByteReadUsing(BusAccess.WordReadMethod read)358         public static BusAccess.ByteReadMethod BuildByteReadUsing(BusAccess.WordReadMethod read)
359         {
360             return address =>
361             {
362                 unchecked
363                 {
364                     var readAddress = address & (~1);
365                     var offset = (int)(address & 1);
366                     return (byte)(read(readAddress) >> offset * 8);
367                 }
368             };
369         }
370 
WriteByteUsingWord(this IWordPeripheral peripheral, long address, byte value)371         public static void WriteByteUsingWord(this IWordPeripheral peripheral, long address, byte value)
372         {
373             unchecked
374             {
375                 var writeAddress = address & (~1);
376                 var offset = (int)(address & 1);
377                 var oldValue = peripheral.ReadWord(writeAddress) & ~((ushort)0xFF << offset * 8);
378                 peripheral.WriteWord(writeAddress, (ushort)(oldValue | ((ushort)value << 8 * offset)));
379             }
380         }
381 
BuildByteWriteUsing(BusAccess.WordReadMethod read, BusAccess.WordWriteMethod write)382         public static BusAccess.ByteWriteMethod BuildByteWriteUsing(BusAccess.WordReadMethod read, BusAccess.WordWriteMethod write)
383         {
384             return (address, value) =>
385             {
386                 unchecked
387                 {
388                     var writeAddress = address & (~1);
389                     var offset = (int)(address & 1);
390                     var oldValue = read(writeAddress) & ~((ushort)0xFF << offset * 8);
391                     write(writeAddress, (ushort)(oldValue | ((ushort)value << 8 * offset)));
392                 }
393             };
394         }
395 
ReadByteUsingWordBigEndian(this IWordPeripheral peripheral, long address)396         public static byte ReadByteUsingWordBigEndian(this IWordPeripheral peripheral, long address)
397         {
398             unchecked
399             {
400                 var readAddress = address & (~1);
401                 var offset = 1 - (int)(address & 1);
402                 return ((byte)(peripheral.ReadWord(readAddress) >> offset * 8));
403             }
404         }
405 
BuildByteReadBigEndianUsing(BusAccess.WordReadMethod read)406         public static BusAccess.ByteReadMethod BuildByteReadBigEndianUsing(BusAccess.WordReadMethod read)
407         {
408             return address =>
409             {
410                 unchecked
411                 {
412                     var readAddress = address & (~1);
413                     var offset = 1 - (int)(address & 1);
414                     return ((byte)(read(readAddress) >> offset * 8));
415                 }
416             };
417         }
418 
WriteByteUsingWordBigEndian(this IWordPeripheral peripheral, long address, byte value)419         public static void WriteByteUsingWordBigEndian(this IWordPeripheral peripheral, long address, byte value)
420         {
421             unchecked
422             {
423                 var writeAddress = address & (~1);
424                 var offset = 1 - (int)(address & 1);
425                 var oldValue = peripheral.ReadWord(writeAddress) & ~((ushort)0xFF << offset * 8);
426                 peripheral.WriteWord(writeAddress, (ushort)(oldValue | ((ushort)value << 8 * offset)));
427             }
428         }
429 
BuildByteWriteBigEndianUsing(BusAccess.WordReadMethod read, BusAccess.WordWriteMethod write)430         public static BusAccess.ByteWriteMethod BuildByteWriteBigEndianUsing(BusAccess.WordReadMethod read, BusAccess.WordWriteMethod write)
431         {
432             return (address, value) =>
433             {
434                 unchecked
435                 {
436                     var writeAddress = address & (~1);
437                     var offset = 1 - (int)(address & 1);
438                     var oldValue = read(writeAddress) & ~((ushort)0xFF << offset * 8);
439                     write(writeAddress, (ushort)(oldValue | ((ushort)value << 8 * offset)));
440                 }
441             };
442         }
ReadDoubleWordUsingWord(this IWordPeripheral peripheral, long address)443         public static uint ReadDoubleWordUsingWord(this IWordPeripheral peripheral, long address)
444         {
445             unchecked
446             {
447                 return (uint)((uint)peripheral.ReadWord(address)
448                     | (uint)peripheral.ReadWord(address + 2) << 16
449                 );
450             }
451         }
452 
BuildDoubleWordReadUsing(BusAccess.WordReadMethod read)453         public static BusAccess.DoubleWordReadMethod BuildDoubleWordReadUsing(BusAccess.WordReadMethod read)
454         {
455             return address =>
456             {
457                 unchecked
458                 {
459                     return (uint)((uint)read(address)
460                         | (uint)read(address + 2) << 16
461                     );
462                 }
463             };
464         }
465 
WriteDoubleWordUsingWord(this IWordPeripheral peripheral, long address, uint value)466         public static void WriteDoubleWordUsingWord(this IWordPeripheral peripheral, long address, uint value)
467         {
468             unchecked
469             {
470                 peripheral.WriteWord(address + 0, (ushort)(value >> 0));
471                 peripheral.WriteWord(address + 2, (ushort)(value >> 16));
472             }
473         }
474 
BuildDoubleWordWriteUsing(BusAccess.WordReadMethod read, BusAccess.WordWriteMethod write)475         public static BusAccess.DoubleWordWriteMethod BuildDoubleWordWriteUsing(BusAccess.WordReadMethod read, BusAccess.WordWriteMethod write)
476         {
477             return (address, value) =>
478             {
479                 unchecked
480                 {
481                     write(address + 0, (ushort)(value >> 0));
482                     write(address + 2, (ushort)(value >> 16));
483                 }
484             };
485         }
486 
ReadDoubleWordUsingWordBigEndian(this IWordPeripheral peripheral, long address)487         public static uint ReadDoubleWordUsingWordBigEndian(this IWordPeripheral peripheral, long address)
488         {
489             unchecked
490             {
491                 return (uint)((uint)Misc.SwapBytesUShort(peripheral.ReadWord(address + 2))
492                     | (uint)Misc.SwapBytesUShort(peripheral.ReadWord(address + 0)) << 16
493                 );
494             }
495         }
496 
BuildDoubleWordReadBigEndianUsing(BusAccess.WordReadMethod read)497         public static BusAccess.DoubleWordReadMethod BuildDoubleWordReadBigEndianUsing(BusAccess.WordReadMethod read)
498         {
499             return address =>
500             {
501                 unchecked
502                 {
503                     return (uint)((uint)Misc.SwapBytesUShort(read(address + 2))
504                         | (uint)Misc.SwapBytesUShort(read(address + 0)) << 16
505                     );
506                 }
507             };
508         }
509 
WriteDoubleWordUsingWordBigEndian(this IWordPeripheral peripheral, long address, uint value)510         public static void WriteDoubleWordUsingWordBigEndian(this IWordPeripheral peripheral, long address, uint value)
511         {
512             unchecked
513             {
514                 peripheral.WriteWord(address + 0, Misc.SwapBytesUShort((ushort)(value >> 16)));
515                 peripheral.WriteWord(address + 2, Misc.SwapBytesUShort((ushort)(value >> 0)));
516             }
517         }
518 
BuildDoubleWordWriteBigEndianUsing(BusAccess.WordReadMethod read, BusAccess.WordWriteMethod write)519         public static BusAccess.DoubleWordWriteMethod BuildDoubleWordWriteBigEndianUsing(BusAccess.WordReadMethod read, BusAccess.WordWriteMethod write)
520         {
521             return (address, value) =>
522             {
523                 unchecked
524                 {
525                     write(address + 0, Misc.SwapBytesUShort((ushort)(value >> 16)));
526                     write(address + 2, Misc.SwapBytesUShort((ushort)(value >> 0)));
527                 }
528             };
529         }
530 
ReadQuadWordUsingWord(this IWordPeripheral peripheral, long address)531         public static ulong ReadQuadWordUsingWord(this IWordPeripheral peripheral, long address)
532         {
533             unchecked
534             {
535                 return (ulong)((ulong)peripheral.ReadWord(address)
536                     | (ulong)peripheral.ReadWord(address + 2) << 16
537                     | (ulong)peripheral.ReadWord(address + 4) << 32
538                     | (ulong)peripheral.ReadWord(address + 6) << 48
539                 );
540             }
541         }
542 
BuildQuadWordReadUsing(BusAccess.WordReadMethod read)543         public static BusAccess.QuadWordReadMethod BuildQuadWordReadUsing(BusAccess.WordReadMethod read)
544         {
545             return address =>
546             {
547                 unchecked
548                 {
549                     return (ulong)((ulong)read(address)
550                         | (ulong)read(address + 2) << 16
551                         | (ulong)read(address + 4) << 32
552                         | (ulong)read(address + 6) << 48
553                     );
554                 }
555             };
556         }
557 
WriteQuadWordUsingWord(this IWordPeripheral peripheral, long address, ulong value)558         public static void WriteQuadWordUsingWord(this IWordPeripheral peripheral, long address, ulong value)
559         {
560             unchecked
561             {
562                 peripheral.WriteWord(address + 0, (ushort)(value >> 0));
563                 peripheral.WriteWord(address + 2, (ushort)(value >> 16));
564                 peripheral.WriteWord(address + 4, (ushort)(value >> 32));
565                 peripheral.WriteWord(address + 6, (ushort)(value >> 48));
566             }
567         }
568 
BuildQuadWordWriteUsing(BusAccess.WordReadMethod read, BusAccess.WordWriteMethod write)569         public static BusAccess.QuadWordWriteMethod BuildQuadWordWriteUsing(BusAccess.WordReadMethod read, BusAccess.WordWriteMethod write)
570         {
571             return (address, value) =>
572             {
573                 unchecked
574                 {
575                     write(address + 0, (ushort)(value >> 0));
576                     write(address + 2, (ushort)(value >> 16));
577                     write(address + 4, (ushort)(value >> 32));
578                     write(address + 6, (ushort)(value >> 48));
579                 }
580             };
581         }
582 
ReadQuadWordUsingWordBigEndian(this IWordPeripheral peripheral, long address)583         public static ulong ReadQuadWordUsingWordBigEndian(this IWordPeripheral peripheral, long address)
584         {
585             unchecked
586             {
587                 return (ulong)((ulong)Misc.SwapBytesUShort(peripheral.ReadWord(address + 6))
588                     | (ulong)Misc.SwapBytesUShort(peripheral.ReadWord(address + 4)) << 16
589                     | (ulong)Misc.SwapBytesUShort(peripheral.ReadWord(address + 2)) << 32
590                     | (ulong)Misc.SwapBytesUShort(peripheral.ReadWord(address + 0)) << 48
591                 );
592             }
593         }
594 
BuildQuadWordReadBigEndianUsing(BusAccess.WordReadMethod read)595         public static BusAccess.QuadWordReadMethod BuildQuadWordReadBigEndianUsing(BusAccess.WordReadMethod read)
596         {
597             return address =>
598             {
599                 unchecked
600                 {
601                     return (ulong)((ulong)Misc.SwapBytesUShort(read(address + 6))
602                         | (ulong)Misc.SwapBytesUShort(read(address + 4)) << 16
603                         | (ulong)Misc.SwapBytesUShort(read(address + 2)) << 32
604                         | (ulong)Misc.SwapBytesUShort(read(address + 0)) << 48
605                     );
606                 }
607             };
608         }
609 
WriteQuadWordUsingWordBigEndian(this IWordPeripheral peripheral, long address, ulong value)610         public static void WriteQuadWordUsingWordBigEndian(this IWordPeripheral peripheral, long address, ulong value)
611         {
612             unchecked
613             {
614                 peripheral.WriteWord(address + 0, Misc.SwapBytesUShort((ushort)(value >> 48)));
615                 peripheral.WriteWord(address + 2, Misc.SwapBytesUShort((ushort)(value >> 32)));
616                 peripheral.WriteWord(address + 4, Misc.SwapBytesUShort((ushort)(value >> 16)));
617                 peripheral.WriteWord(address + 6, Misc.SwapBytesUShort((ushort)(value >> 0)));
618             }
619         }
620 
BuildQuadWordWriteBigEndianUsing(BusAccess.WordReadMethod read, BusAccess.WordWriteMethod write)621         public static BusAccess.QuadWordWriteMethod BuildQuadWordWriteBigEndianUsing(BusAccess.WordReadMethod read, BusAccess.WordWriteMethod write)
622         {
623             return (address, value) =>
624             {
625                 unchecked
626                 {
627                     write(address + 0, Misc.SwapBytesUShort((ushort)(value >> 48)));
628                     write(address + 2, Misc.SwapBytesUShort((ushort)(value >> 32)));
629                     write(address + 4, Misc.SwapBytesUShort((ushort)(value >> 16)));
630                     write(address + 6, Misc.SwapBytesUShort((ushort)(value >> 0)));
631                 }
632             };
633         }
634 
ReadByteUsingDoubleWord(this IDoubleWordPeripheral peripheral, long address)635         public static byte ReadByteUsingDoubleWord(this IDoubleWordPeripheral peripheral, long address)
636         {
637             unchecked
638             {
639                 var readAddress = address & (~3);
640                 var offset = (int)(address & 3);
641                 return (byte)(peripheral.ReadDoubleWord(readAddress) >> offset * 8);
642             }
643         }
644 
BuildByteReadUsing(BusAccess.DoubleWordReadMethod read)645         public static BusAccess.ByteReadMethod BuildByteReadUsing(BusAccess.DoubleWordReadMethod read)
646         {
647             return address =>
648             {
649                 unchecked
650                 {
651                     var readAddress = address & (~3);
652                     var offset = (int)(address & 3);
653                     return (byte)(read(readAddress) >> offset * 8);
654                 }
655             };
656         }
657 
WriteByteUsingDoubleWord(this IDoubleWordPeripheral peripheral, long address, byte value)658         public static void WriteByteUsingDoubleWord(this IDoubleWordPeripheral peripheral, long address, byte value)
659         {
660             unchecked
661             {
662                 var writeAddress = address & (~3);
663                 var offset = (int)(address & 3);
664                 var oldValue = peripheral.ReadDoubleWord(writeAddress) & ~((uint)0xFF << offset * 8);
665                 peripheral.WriteDoubleWord(writeAddress, (uint)(oldValue | ((uint)value << 8 * offset)));
666             }
667         }
668 
BuildByteWriteUsing(BusAccess.DoubleWordReadMethod read, BusAccess.DoubleWordWriteMethod write)669         public static BusAccess.ByteWriteMethod BuildByteWriteUsing(BusAccess.DoubleWordReadMethod read, BusAccess.DoubleWordWriteMethod write)
670         {
671             return (address, value) =>
672             {
673                 unchecked
674                 {
675                     var writeAddress = address & (~3);
676                     var offset = (int)(address & 3);
677                     var oldValue = read(writeAddress) & ~((uint)0xFF << offset * 8);
678                     write(writeAddress, (uint)(oldValue | ((uint)value << 8 * offset)));
679                 }
680             };
681         }
682 
ReadByteUsingDoubleWordBigEndian(this IDoubleWordPeripheral peripheral, long address)683         public static byte ReadByteUsingDoubleWordBigEndian(this IDoubleWordPeripheral peripheral, long address)
684         {
685             unchecked
686             {
687                 var readAddress = address & (~3);
688                 var offset = 3 - (int)(address & 3);
689                 return ((byte)(peripheral.ReadDoubleWord(readAddress) >> offset * 8));
690             }
691         }
692 
BuildByteReadBigEndianUsing(BusAccess.DoubleWordReadMethod read)693         public static BusAccess.ByteReadMethod BuildByteReadBigEndianUsing(BusAccess.DoubleWordReadMethod read)
694         {
695             return address =>
696             {
697                 unchecked
698                 {
699                     var readAddress = address & (~3);
700                     var offset = 3 - (int)(address & 3);
701                     return ((byte)(read(readAddress) >> offset * 8));
702                 }
703             };
704         }
705 
WriteByteUsingDoubleWordBigEndian(this IDoubleWordPeripheral peripheral, long address, byte value)706         public static void WriteByteUsingDoubleWordBigEndian(this IDoubleWordPeripheral peripheral, long address, byte value)
707         {
708             unchecked
709             {
710                 var writeAddress = address & (~3);
711                 var offset = 3 - (int)(address & 3);
712                 var oldValue = peripheral.ReadDoubleWord(writeAddress) & ~((uint)0xFF << offset * 8);
713                 peripheral.WriteDoubleWord(writeAddress, (uint)(oldValue | ((uint)value << 8 * offset)));
714             }
715         }
716 
BuildByteWriteBigEndianUsing(BusAccess.DoubleWordReadMethod read, BusAccess.DoubleWordWriteMethod write)717         public static BusAccess.ByteWriteMethod BuildByteWriteBigEndianUsing(BusAccess.DoubleWordReadMethod read, BusAccess.DoubleWordWriteMethod write)
718         {
719             return (address, value) =>
720             {
721                 unchecked
722                 {
723                     var writeAddress = address & (~3);
724                     var offset = 3 - (int)(address & 3);
725                     var oldValue = read(writeAddress) & ~((uint)0xFF << offset * 8);
726                     write(writeAddress, (uint)(oldValue | ((uint)value << 8 * offset)));
727                 }
728             };
729         }
ReadWordUsingDoubleWord(this IDoubleWordPeripheral peripheral, long address)730         public static ushort ReadWordUsingDoubleWord(this IDoubleWordPeripheral peripheral, long address)
731         {
732             unchecked
733             {
734                 var readAddress = address & (~3);
735                 var offset = (int)(address & 3);
736                 return (ushort)(peripheral.ReadDoubleWord(readAddress) >> offset * 8);
737             }
738         }
739 
BuildWordReadUsing(BusAccess.DoubleWordReadMethod read)740         public static BusAccess.WordReadMethod BuildWordReadUsing(BusAccess.DoubleWordReadMethod read)
741         {
742             return address =>
743             {
744                 unchecked
745                 {
746                     var readAddress = address & (~3);
747                     var offset = (int)(address & 3);
748                     return (ushort)(read(readAddress) >> offset * 8);
749                 }
750             };
751         }
752 
WriteWordUsingDoubleWord(this IDoubleWordPeripheral peripheral, long address, ushort value)753         public static void WriteWordUsingDoubleWord(this IDoubleWordPeripheral peripheral, long address, ushort value)
754         {
755             unchecked
756             {
757                 var writeAddress = address & (~3);
758                 var offset = (int)(address & 3);
759                 var oldValue = peripheral.ReadDoubleWord(writeAddress) & ~((uint)0xFFFF << offset * 8);
760                 peripheral.WriteDoubleWord(writeAddress, (uint)(oldValue | ((uint)value << 8 * offset)));
761             }
762         }
763 
BuildWordWriteUsing(BusAccess.DoubleWordReadMethod read, BusAccess.DoubleWordWriteMethod write)764         public static BusAccess.WordWriteMethod BuildWordWriteUsing(BusAccess.DoubleWordReadMethod read, BusAccess.DoubleWordWriteMethod write)
765         {
766             return (address, value) =>
767             {
768                 unchecked
769                 {
770                     var writeAddress = address & (~3);
771                     var offset = (int)(address & 3);
772                     var oldValue = read(writeAddress) & ~((uint)0xFFFF << offset * 8);
773                     write(writeAddress, (uint)(oldValue | ((uint)value << 8 * offset)));
774                 }
775             };
776         }
777 
ReadWordUsingDoubleWordBigEndian(this IDoubleWordPeripheral peripheral, long address)778         public static ushort ReadWordUsingDoubleWordBigEndian(this IDoubleWordPeripheral peripheral, long address)
779         {
780             unchecked
781             {
782                 var readAddress = address & (~3);
783                 var offset = 2 - (int)(address & 3);
784                 return Misc.SwapBytesUShort((ushort)(peripheral.ReadDoubleWord(readAddress) >> offset * 8));
785             }
786         }
787 
BuildWordReadBigEndianUsing(BusAccess.DoubleWordReadMethod read)788         public static BusAccess.WordReadMethod BuildWordReadBigEndianUsing(BusAccess.DoubleWordReadMethod read)
789         {
790             return address =>
791             {
792                 unchecked
793                 {
794                     var readAddress = address & (~3);
795                     var offset = 2 - (int)(address & 3);
796                     return Misc.SwapBytesUShort((ushort)(read(readAddress) >> offset * 8));
797                 }
798             };
799         }
800 
WriteWordUsingDoubleWordBigEndian(this IDoubleWordPeripheral peripheral, long address, ushort value)801         public static void WriteWordUsingDoubleWordBigEndian(this IDoubleWordPeripheral peripheral, long address, ushort value)
802         {
803             unchecked
804             {
805                 value = Misc.SwapBytesUShort(value);
806                 var writeAddress = address & (~3);
807                 var offset = 2 - (int)(address & 3);
808                 var oldValue = peripheral.ReadDoubleWord(writeAddress) & ~((uint)0xFFFF << offset * 8);
809                 peripheral.WriteDoubleWord(writeAddress, (uint)(oldValue | ((uint)value << 8 * offset)));
810             }
811         }
812 
BuildWordWriteBigEndianUsing(BusAccess.DoubleWordReadMethod read, BusAccess.DoubleWordWriteMethod write)813         public static BusAccess.WordWriteMethod BuildWordWriteBigEndianUsing(BusAccess.DoubleWordReadMethod read, BusAccess.DoubleWordWriteMethod write)
814         {
815             return (address, value) =>
816             {
817                 unchecked
818                 {
819                     value = Misc.SwapBytesUShort(value);
820                     var writeAddress = address & (~3);
821                     var offset = 2 - (int)(address & 3);
822                     var oldValue = read(writeAddress) & ~((uint)0xFFFF << offset * 8);
823                     write(writeAddress, (uint)(oldValue | ((uint)value << 8 * offset)));
824                 }
825             };
826         }
ReadQuadWordUsingDoubleWord(this IDoubleWordPeripheral peripheral, long address)827         public static ulong ReadQuadWordUsingDoubleWord(this IDoubleWordPeripheral peripheral, long address)
828         {
829             unchecked
830             {
831                 return (ulong)((ulong)peripheral.ReadDoubleWord(address)
832                     | (ulong)peripheral.ReadDoubleWord(address + 4) << 32
833                 );
834             }
835         }
836 
BuildQuadWordReadUsing(BusAccess.DoubleWordReadMethod read)837         public static BusAccess.QuadWordReadMethod BuildQuadWordReadUsing(BusAccess.DoubleWordReadMethod read)
838         {
839             return address =>
840             {
841                 unchecked
842                 {
843                     return (ulong)((ulong)read(address)
844                         | (ulong)read(address + 4) << 32
845                     );
846                 }
847             };
848         }
849 
WriteQuadWordUsingDoubleWord(this IDoubleWordPeripheral peripheral, long address, ulong value)850         public static void WriteQuadWordUsingDoubleWord(this IDoubleWordPeripheral peripheral, long address, ulong value)
851         {
852             unchecked
853             {
854                 peripheral.WriteDoubleWord(address + 0, (uint)(value >> 0));
855                 peripheral.WriteDoubleWord(address + 4, (uint)(value >> 32));
856             }
857         }
858 
BuildQuadWordWriteUsing(BusAccess.DoubleWordReadMethod read, BusAccess.DoubleWordWriteMethod write)859         public static BusAccess.QuadWordWriteMethod BuildQuadWordWriteUsing(BusAccess.DoubleWordReadMethod read, BusAccess.DoubleWordWriteMethod write)
860         {
861             return (address, value) =>
862             {
863                 unchecked
864                 {
865                     write(address + 0, (uint)(value >> 0));
866                     write(address + 4, (uint)(value >> 32));
867                 }
868             };
869         }
870 
ReadQuadWordUsingDoubleWordBigEndian(this IDoubleWordPeripheral peripheral, long address)871         public static ulong ReadQuadWordUsingDoubleWordBigEndian(this IDoubleWordPeripheral peripheral, long address)
872         {
873             unchecked
874             {
875                 return (ulong)((ulong)Misc.SwapBytesUInt(peripheral.ReadDoubleWord(address + 4))
876                     | (ulong)Misc.SwapBytesUInt(peripheral.ReadDoubleWord(address + 0)) << 32
877                 );
878             }
879         }
880 
BuildQuadWordReadBigEndianUsing(BusAccess.DoubleWordReadMethod read)881         public static BusAccess.QuadWordReadMethod BuildQuadWordReadBigEndianUsing(BusAccess.DoubleWordReadMethod read)
882         {
883             return address =>
884             {
885                 unchecked
886                 {
887                     return (ulong)((ulong)Misc.SwapBytesUInt(read(address + 4))
888                         | (ulong)Misc.SwapBytesUInt(read(address + 0)) << 32
889                     );
890                 }
891             };
892         }
893 
WriteQuadWordUsingDoubleWordBigEndian(this IDoubleWordPeripheral peripheral, long address, ulong value)894         public static void WriteQuadWordUsingDoubleWordBigEndian(this IDoubleWordPeripheral peripheral, long address, ulong value)
895         {
896             unchecked
897             {
898                 peripheral.WriteDoubleWord(address + 0, Misc.SwapBytesUInt((uint)(value >> 32)));
899                 peripheral.WriteDoubleWord(address + 4, Misc.SwapBytesUInt((uint)(value >> 0)));
900             }
901         }
902 
BuildQuadWordWriteBigEndianUsing(BusAccess.DoubleWordReadMethod read, BusAccess.DoubleWordWriteMethod write)903         public static BusAccess.QuadWordWriteMethod BuildQuadWordWriteBigEndianUsing(BusAccess.DoubleWordReadMethod read, BusAccess.DoubleWordWriteMethod write)
904         {
905             return (address, value) =>
906             {
907                 unchecked
908                 {
909                     write(address + 0, Misc.SwapBytesUInt((uint)(value >> 32)));
910                     write(address + 4, Misc.SwapBytesUInt((uint)(value >> 0)));
911                 }
912             };
913         }
914 
ReadByteUsingQuadWord(this IQuadWordPeripheral peripheral, long address)915         public static byte ReadByteUsingQuadWord(this IQuadWordPeripheral peripheral, long address)
916         {
917             unchecked
918             {
919                 var readAddress = address & (~7);
920                 var offset = (int)(address & 7);
921                 return (byte)(peripheral.ReadQuadWord(readAddress) >> offset * 8);
922             }
923         }
924 
BuildByteReadUsing(BusAccess.QuadWordReadMethod read)925         public static BusAccess.ByteReadMethod BuildByteReadUsing(BusAccess.QuadWordReadMethod read)
926         {
927             return address =>
928             {
929                 unchecked
930                 {
931                     var readAddress = address & (~7);
932                     var offset = (int)(address & 7);
933                     return (byte)(read(readAddress) >> offset * 8);
934                 }
935             };
936         }
937 
WriteByteUsingQuadWord(this IQuadWordPeripheral peripheral, long address, byte value)938         public static void WriteByteUsingQuadWord(this IQuadWordPeripheral peripheral, long address, byte value)
939         {
940             unchecked
941             {
942                 var writeAddress = address & (~7);
943                 var offset = (int)(address & 7);
944                 var oldValue = peripheral.ReadQuadWord(writeAddress) & ~((ulong)0xFF << offset * 8);
945                 peripheral.WriteQuadWord(writeAddress, (ulong)(oldValue | ((ulong)value << 8 * offset)));
946             }
947         }
948 
BuildByteWriteUsing(BusAccess.QuadWordReadMethod read, BusAccess.QuadWordWriteMethod write)949         public static BusAccess.ByteWriteMethod BuildByteWriteUsing(BusAccess.QuadWordReadMethod read, BusAccess.QuadWordWriteMethod write)
950         {
951             return (address, value) =>
952             {
953                 unchecked
954                 {
955                     var writeAddress = address & (~7);
956                     var offset = (int)(address & 7);
957                     var oldValue = read(writeAddress) & ~((ulong)0xFF << offset * 8);
958                     write(writeAddress, (ulong)(oldValue | ((ulong)value << 8 * offset)));
959                 }
960             };
961         }
962 
ReadByteUsingQuadWordBigEndian(this IQuadWordPeripheral peripheral, long address)963         public static byte ReadByteUsingQuadWordBigEndian(this IQuadWordPeripheral peripheral, long address)
964         {
965             unchecked
966             {
967                 var readAddress = address & (~7);
968                 var offset = 7 - (int)(address & 7);
969                 return ((byte)(peripheral.ReadQuadWord(readAddress) >> offset * 8));
970             }
971         }
972 
BuildByteReadBigEndianUsing(BusAccess.QuadWordReadMethod read)973         public static BusAccess.ByteReadMethod BuildByteReadBigEndianUsing(BusAccess.QuadWordReadMethod read)
974         {
975             return address =>
976             {
977                 unchecked
978                 {
979                     var readAddress = address & (~7);
980                     var offset = 7 - (int)(address & 7);
981                     return ((byte)(read(readAddress) >> offset * 8));
982                 }
983             };
984         }
985 
WriteByteUsingQuadWordBigEndian(this IQuadWordPeripheral peripheral, long address, byte value)986         public static void WriteByteUsingQuadWordBigEndian(this IQuadWordPeripheral peripheral, long address, byte value)
987         {
988             unchecked
989             {
990                 var writeAddress = address & (~7);
991                 var offset = 7 - (int)(address & 7);
992                 var oldValue = peripheral.ReadQuadWord(writeAddress) & ~((ulong)0xFF << offset * 8);
993                 peripheral.WriteQuadWord(writeAddress, (ulong)(oldValue | ((ulong)value << 8 * offset)));
994             }
995         }
996 
BuildByteWriteBigEndianUsing(BusAccess.QuadWordReadMethod read, BusAccess.QuadWordWriteMethod write)997         public static BusAccess.ByteWriteMethod BuildByteWriteBigEndianUsing(BusAccess.QuadWordReadMethod read, BusAccess.QuadWordWriteMethod write)
998         {
999             return (address, value) =>
1000             {
1001                 unchecked
1002                 {
1003                     var writeAddress = address & (~7);
1004                     var offset = 7 - (int)(address & 7);
1005                     var oldValue = read(writeAddress) & ~((ulong)0xFF << offset * 8);
1006                     write(writeAddress, (ulong)(oldValue | ((ulong)value << 8 * offset)));
1007                 }
1008             };
1009         }
ReadWordUsingQuadWord(this IQuadWordPeripheral peripheral, long address)1010         public static ushort ReadWordUsingQuadWord(this IQuadWordPeripheral peripheral, long address)
1011         {
1012             unchecked
1013             {
1014                 var readAddress = address & (~7);
1015                 var offset = (int)(address & 7);
1016                 return (ushort)(peripheral.ReadQuadWord(readAddress) >> offset * 8);
1017             }
1018         }
1019 
BuildWordReadUsing(BusAccess.QuadWordReadMethod read)1020         public static BusAccess.WordReadMethod BuildWordReadUsing(BusAccess.QuadWordReadMethod read)
1021         {
1022             return address =>
1023             {
1024                 unchecked
1025                 {
1026                     var readAddress = address & (~7);
1027                     var offset = (int)(address & 7);
1028                     return (ushort)(read(readAddress) >> offset * 8);
1029                 }
1030             };
1031         }
1032 
WriteWordUsingQuadWord(this IQuadWordPeripheral peripheral, long address, ushort value)1033         public static void WriteWordUsingQuadWord(this IQuadWordPeripheral peripheral, long address, ushort value)
1034         {
1035             unchecked
1036             {
1037                 var writeAddress = address & (~7);
1038                 var offset = (int)(address & 7);
1039                 var oldValue = peripheral.ReadQuadWord(writeAddress) & ~((ulong)0xFFFF << offset * 8);
1040                 peripheral.WriteQuadWord(writeAddress, (ulong)(oldValue | ((ulong)value << 8 * offset)));
1041             }
1042         }
1043 
BuildWordWriteUsing(BusAccess.QuadWordReadMethod read, BusAccess.QuadWordWriteMethod write)1044         public static BusAccess.WordWriteMethod BuildWordWriteUsing(BusAccess.QuadWordReadMethod read, BusAccess.QuadWordWriteMethod write)
1045         {
1046             return (address, value) =>
1047             {
1048                 unchecked
1049                 {
1050                     var writeAddress = address & (~7);
1051                     var offset = (int)(address & 7);
1052                     var oldValue = read(writeAddress) & ~((ulong)0xFFFF << offset * 8);
1053                     write(writeAddress, (ulong)(oldValue | ((ulong)value << 8 * offset)));
1054                 }
1055             };
1056         }
1057 
ReadWordUsingQuadWordBigEndian(this IQuadWordPeripheral peripheral, long address)1058         public static ushort ReadWordUsingQuadWordBigEndian(this IQuadWordPeripheral peripheral, long address)
1059         {
1060             unchecked
1061             {
1062                 var readAddress = address & (~7);
1063                 var offset = 6 - (int)(address & 7);
1064                 return Misc.SwapBytesUShort((ushort)(peripheral.ReadQuadWord(readAddress) >> offset * 8));
1065             }
1066         }
1067 
BuildWordReadBigEndianUsing(BusAccess.QuadWordReadMethod read)1068         public static BusAccess.WordReadMethod BuildWordReadBigEndianUsing(BusAccess.QuadWordReadMethod read)
1069         {
1070             return address =>
1071             {
1072                 unchecked
1073                 {
1074                     var readAddress = address & (~7);
1075                     var offset = 6 - (int)(address & 7);
1076                     return Misc.SwapBytesUShort((ushort)(read(readAddress) >> offset * 8));
1077                 }
1078             };
1079         }
1080 
WriteWordUsingQuadWordBigEndian(this IQuadWordPeripheral peripheral, long address, ushort value)1081         public static void WriteWordUsingQuadWordBigEndian(this IQuadWordPeripheral peripheral, long address, ushort value)
1082         {
1083             unchecked
1084             {
1085                 value = Misc.SwapBytesUShort(value);
1086                 var writeAddress = address & (~7);
1087                 var offset = 6 - (int)(address & 7);
1088                 var oldValue = peripheral.ReadQuadWord(writeAddress) & ~((ulong)0xFFFF << offset * 8);
1089                 peripheral.WriteQuadWord(writeAddress, (ulong)(oldValue | ((ulong)value << 8 * offset)));
1090             }
1091         }
1092 
BuildWordWriteBigEndianUsing(BusAccess.QuadWordReadMethod read, BusAccess.QuadWordWriteMethod write)1093         public static BusAccess.WordWriteMethod BuildWordWriteBigEndianUsing(BusAccess.QuadWordReadMethod read, BusAccess.QuadWordWriteMethod write)
1094         {
1095             return (address, value) =>
1096             {
1097                 unchecked
1098                 {
1099                     value = Misc.SwapBytesUShort(value);
1100                     var writeAddress = address & (~7);
1101                     var offset = 6 - (int)(address & 7);
1102                     var oldValue = read(writeAddress) & ~((ulong)0xFFFF << offset * 8);
1103                     write(writeAddress, (ulong)(oldValue | ((ulong)value << 8 * offset)));
1104                 }
1105             };
1106         }
ReadDoubleWordUsingQuadWord(this IQuadWordPeripheral peripheral, long address)1107         public static uint ReadDoubleWordUsingQuadWord(this IQuadWordPeripheral peripheral, long address)
1108         {
1109             unchecked
1110             {
1111                 var readAddress = address & (~7);
1112                 var offset = (int)(address & 7);
1113                 return (uint)(peripheral.ReadQuadWord(readAddress) >> offset * 8);
1114             }
1115         }
1116 
BuildDoubleWordReadUsing(BusAccess.QuadWordReadMethod read)1117         public static BusAccess.DoubleWordReadMethod BuildDoubleWordReadUsing(BusAccess.QuadWordReadMethod read)
1118         {
1119             return address =>
1120             {
1121                 unchecked
1122                 {
1123                     var readAddress = address & (~7);
1124                     var offset = (int)(address & 7);
1125                     return (uint)(read(readAddress) >> offset * 8);
1126                 }
1127             };
1128         }
1129 
WriteDoubleWordUsingQuadWord(this IQuadWordPeripheral peripheral, long address, uint value)1130         public static void WriteDoubleWordUsingQuadWord(this IQuadWordPeripheral peripheral, long address, uint value)
1131         {
1132             unchecked
1133             {
1134                 var writeAddress = address & (~7);
1135                 var offset = (int)(address & 7);
1136                 var oldValue = peripheral.ReadQuadWord(writeAddress) & ~((ulong)0xFFFFFFFFUL << offset * 8);
1137                 peripheral.WriteQuadWord(writeAddress, (ulong)(oldValue | ((ulong)value << 8 * offset)));
1138             }
1139         }
1140 
BuildDoubleWordWriteUsing(BusAccess.QuadWordReadMethod read, BusAccess.QuadWordWriteMethod write)1141         public static BusAccess.DoubleWordWriteMethod BuildDoubleWordWriteUsing(BusAccess.QuadWordReadMethod read, BusAccess.QuadWordWriteMethod write)
1142         {
1143             return (address, value) =>
1144             {
1145                 unchecked
1146                 {
1147                     var writeAddress = address & (~7);
1148                     var offset = (int)(address & 7);
1149                     var oldValue = read(writeAddress) & ~((ulong)0xFFFFFFFFUL << offset * 8);
1150                     write(writeAddress, (ulong)(oldValue | ((ulong)value << 8 * offset)));
1151                 }
1152             };
1153         }
1154 
ReadDoubleWordUsingQuadWordBigEndian(this IQuadWordPeripheral peripheral, long address)1155         public static uint ReadDoubleWordUsingQuadWordBigEndian(this IQuadWordPeripheral peripheral, long address)
1156         {
1157             unchecked
1158             {
1159                 var readAddress = address & (~7);
1160                 var offset = 4 - (int)(address & 7);
1161                 return Misc.SwapBytesUInt((uint)(peripheral.ReadQuadWord(readAddress) >> offset * 8));
1162             }
1163         }
1164 
BuildDoubleWordReadBigEndianUsing(BusAccess.QuadWordReadMethod read)1165         public static BusAccess.DoubleWordReadMethod BuildDoubleWordReadBigEndianUsing(BusAccess.QuadWordReadMethod read)
1166         {
1167             return address =>
1168             {
1169                 unchecked
1170                 {
1171                     var readAddress = address & (~7);
1172                     var offset = 4 - (int)(address & 7);
1173                     return Misc.SwapBytesUInt((uint)(read(readAddress) >> offset * 8));
1174                 }
1175             };
1176         }
1177 
WriteDoubleWordUsingQuadWordBigEndian(this IQuadWordPeripheral peripheral, long address, uint value)1178         public static void WriteDoubleWordUsingQuadWordBigEndian(this IQuadWordPeripheral peripheral, long address, uint value)
1179         {
1180             unchecked
1181             {
1182                 value = Misc.SwapBytesUInt(value);
1183                 var writeAddress = address & (~7);
1184                 var offset = 4 - (int)(address & 7);
1185                 var oldValue = peripheral.ReadQuadWord(writeAddress) & ~((ulong)0xFFFFFFFFUL << offset * 8);
1186                 peripheral.WriteQuadWord(writeAddress, (ulong)(oldValue | ((ulong)value << 8 * offset)));
1187             }
1188         }
1189 
BuildDoubleWordWriteBigEndianUsing(BusAccess.QuadWordReadMethod read, BusAccess.QuadWordWriteMethod write)1190         public static BusAccess.DoubleWordWriteMethod BuildDoubleWordWriteBigEndianUsing(BusAccess.QuadWordReadMethod read, BusAccess.QuadWordWriteMethod write)
1191         {
1192             return (address, value) =>
1193             {
1194                 unchecked
1195                 {
1196                     value = Misc.SwapBytesUInt(value);
1197                     var writeAddress = address & (~7);
1198                     var offset = 4 - (int)(address & 7);
1199                     var oldValue = read(writeAddress) & ~((ulong)0xFFFFFFFFUL << offset * 8);
1200                     write(writeAddress, (ulong)(oldValue | ((ulong)value << 8 * offset)));
1201                 }
1202             };
1203         }
1204 
ReadWordBigEndian(this IWordPeripheral peripheral, long address)1205         public static ushort ReadWordBigEndian(this IWordPeripheral peripheral, long address)
1206         {
1207             return Misc.SwapBytesUShort(peripheral.ReadWord(address));
1208         }
1209 
WriteWordBigEndian(this IWordPeripheral peripheral, long address, ushort value)1210         public static void WriteWordBigEndian(this IWordPeripheral peripheral, long address, ushort value)
1211         {
1212             peripheral.WriteWord(address, Misc.SwapBytesUShort(value));
1213         }
1214 
1215 
ReadDoubleWordBigEndian(this IDoubleWordPeripheral peripheral, long address)1216         public static uint ReadDoubleWordBigEndian(this IDoubleWordPeripheral peripheral, long address)
1217         {
1218             return Misc.SwapBytesUInt(peripheral.ReadDoubleWord(address));
1219         }
1220 
WriteDoubleWordBigEndian(this IDoubleWordPeripheral peripheral, long address, uint value)1221         public static void WriteDoubleWordBigEndian(this IDoubleWordPeripheral peripheral, long address, uint value)
1222         {
1223             peripheral.WriteDoubleWord(address, Misc.SwapBytesUInt(value));
1224         }
1225 
1226 
ReadQuadWordBigEndian(this IQuadWordPeripheral peripheral, long address)1227         public static ulong ReadQuadWordBigEndian(this IQuadWordPeripheral peripheral, long address)
1228         {
1229             return Misc.SwapBytesULong(peripheral.ReadQuadWord(address));
1230         }
1231 
WriteQuadWordBigEndian(this IQuadWordPeripheral peripheral, long address, ulong value)1232         public static void WriteQuadWordBigEndian(this IQuadWordPeripheral peripheral, long address, ulong value)
1233         {
1234             peripheral.WriteQuadWord(address, Misc.SwapBytesULong(value));
1235         }
1236 
1237 
ReadByteNotTranslated(this IBusPeripheral peripheral, long address)1238         public static byte ReadByteNotTranslated(this IBusPeripheral peripheral, long address)
1239         {
1240             LogNotTranslated(peripheral, SysbusAccessWidth.Byte, address);
1241             return 0;
1242         }
1243 
WriteByteNotTranslated(this IBusPeripheral peripheral, long address, byte value)1244         public static void WriteByteNotTranslated(this IBusPeripheral peripheral, long address, byte value)
1245         {
1246             LogNotTranslated(peripheral, SysbusAccessWidth.Byte, address, value);
1247         }
1248 
ReadWordNotTranslated(this IBusPeripheral peripheral, long address)1249         public static ushort ReadWordNotTranslated(this IBusPeripheral peripheral, long address)
1250         {
1251             LogNotTranslated(peripheral, SysbusAccessWidth.Word, address);
1252             return 0;
1253         }
1254 
WriteWordNotTranslated(this IBusPeripheral peripheral, long address, ushort value)1255         public static void WriteWordNotTranslated(this IBusPeripheral peripheral, long address, ushort value)
1256         {
1257             LogNotTranslated(peripheral, SysbusAccessWidth.Word, address, value);
1258         }
1259 
ReadDoubleWordNotTranslated(this IBusPeripheral peripheral, long address)1260         public static uint ReadDoubleWordNotTranslated(this IBusPeripheral peripheral, long address)
1261         {
1262             LogNotTranslated(peripheral, SysbusAccessWidth.DoubleWord, address);
1263             return 0;
1264         }
1265 
WriteDoubleWordNotTranslated(this IBusPeripheral peripheral, long address, uint value)1266         public static void WriteDoubleWordNotTranslated(this IBusPeripheral peripheral, long address, uint value)
1267         {
1268             LogNotTranslated(peripheral, SysbusAccessWidth.DoubleWord, address, value);
1269         }
1270 
ReadQuadWordNotTranslated(this IBusPeripheral peripheral, long address)1271         public static ulong ReadQuadWordNotTranslated(this IBusPeripheral peripheral, long address)
1272         {
1273             LogNotTranslated(peripheral, SysbusAccessWidth.QuadWord, address);
1274             return 0;
1275         }
1276 
WriteQuadWordNotTranslated(this IBusPeripheral peripheral, long address, ulong value)1277         public static void WriteQuadWordNotTranslated(this IBusPeripheral peripheral, long address, ulong value)
1278         {
1279             LogNotTranslated(peripheral, SysbusAccessWidth.QuadWord, address, value);
1280         }
1281 
LogNotTranslated(IBusPeripheral peripheral, SysbusAccessWidth operationWidth, long address, ulong? value = null)1282         private static void LogNotTranslated(IBusPeripheral peripheral, SysbusAccessWidth operationWidth, long address, ulong? value = null)
1283         {
1284             var strBldr = new StringBuilder();
1285             var isWrite = value.HasValue;
1286             strBldr.AppendFormat("Attempted {0} {1} isn't supported by the peripheral.", operationWidth, isWrite ? "write" : "read");
1287             strBldr.AppendFormat(" Offset 0x{0:X}", address);
1288             if(isWrite)
1289             {
1290                 strBldr.AppendFormat(", value 0x{0:X}", value.Value);
1291             }
1292             strBldr.Append(".");
1293 
1294             peripheral.Log(LogLevel.Warning, peripheral.GetMachine().GetSystemBus(peripheral).DecorateWithCPUNameAndPC(strBldr.ToString()));
1295         }
1296     }
1297 }
1298