summaryrefslogtreecommitdiff
path: root/arch/arm/mach-msm/include/mach/iommu_hw-8xxx.h
blob: c2c3da9444f48293f397dd23180119d28556ba2e (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
/* Copyright (c) 2010, Code Aurora Forum. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 and
 * only version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */

#ifndef __ARCH_ARM_MACH_MSM_IOMMU_HW_8XXX_H
#define __ARCH_ARM_MACH_MSM_IOMMU_HW_8XXX_H

#define CTX_SHIFT 12

#define GET_GLOBAL_REG(reg, base) (readl((base) + (reg)))
#define GET_CTX_REG(reg, base, ctx) \
				(readl((base) + (reg) + ((ctx) << CTX_SHIFT)))

#define SET_GLOBAL_REG(reg, base, val)	writel((val), ((base) + (reg)))

#define SET_CTX_REG(reg, base, ctx, val) \
			writel((val), ((base) + (reg) + ((ctx) << CTX_SHIFT)))

/* Wrappers for numbered registers */
#define SET_GLOBAL_REG_N(b, n, r, v) SET_GLOBAL_REG(b, ((r) + (n << 2)), (v))
#define GET_GLOBAL_REG_N(b, n, r)    GET_GLOBAL_REG(b, ((r) + (n << 2)))

/* Field wrappers */
#define GET_GLOBAL_FIELD(b, r, F)    GET_FIELD(((b) + (r)), F##_MASK, F##_SHIFT)
#define GET_CONTEXT_FIELD(b, c, r, F)	\
	GET_FIELD(((b) + (r) + ((c) << CTX_SHIFT)), F##_MASK, F##_SHIFT)

#define SET_GLOBAL_FIELD(b, r, F, v) \
	SET_FIELD(((b) + (r)), F##_MASK, F##_SHIFT, (v))
#define SET_CONTEXT_FIELD(b, c, r, F, v)	\
	SET_FIELD(((b) + (r) + ((c) << CTX_SHIFT)), F##_MASK, F##_SHIFT, (v))

#define GET_FIELD(addr, mask, shift)  ((readl(addr) >> (shift)) & (mask))

#define SET_FIELD(addr, mask, shift, v) \
do { \
	int t = readl(addr); \
	writel((t & ~((mask) << (shift))) + (((v) & (mask)) << (shift)), addr);\
} while (0)


#define NUM_FL_PTE	4096
#define NUM_SL_PTE	256
#define NUM_TEX_CLASS	8

/* First-level page table bits */
#define FL_BASE_MASK		0xFFFFFC00
#define FL_TYPE_TABLE		(1 << 0)
#define FL_TYPE_SECT		(2 << 0)
#define FL_SUPERSECTION		(1 << 18)
#define FL_AP_WRITE		(1 << 10)
#define FL_AP_READ		(1 << 11)
#define FL_SHARED		(1 << 16)
#define FL_BUFFERABLE		(1 << 2)
#define FL_CACHEABLE		(1 << 3)
#define FL_TEX0			(1 << 12)
#define FL_OFFSET(va)		(((va) & 0xFFF00000) >> 20)

/* Second-level page table bits */
#define SL_BASE_MASK_LARGE	0xFFFF0000
#define SL_BASE_MASK_SMALL	0xFFFFF000
#define SL_TYPE_LARGE		(1 << 0)
#define SL_TYPE_SMALL		(2 << 0)
#define SL_AP0			(1 << 4)
#define SL_AP1			(2 << 4)
#define SL_SHARED		(1 << 10)
#define SL_BUFFERABLE		(1 << 2)
#define SL_CACHEABLE		(1 << 3)
#define SL_TEX0			(1 << 6)
#define SL_OFFSET(va)		(((va) & 0xFF000) >> 12)

/* Memory type and cache policy attributes */
#define MT_SO			0
#define MT_DEV			1
#define MT_NORMAL		2
#define CP_NONCACHED		0
#define CP_WB_WA		1
#define CP_WT			2
#define CP_WB_NWA		3

/* Global register setters / getters */
#define SET_M2VCBR_N(b, N, v)	 SET_GLOBAL_REG_N(M2VCBR_N, N, (b), (v))
#define SET_CBACR_N(b, N, v)	 SET_GLOBAL_REG_N(CBACR_N, N, (b), (v))
#define SET_TLBRSW(b, v)	 SET_GLOBAL_REG(TLBRSW, (b), (v))
#define SET_TLBTR0(b, v)	 SET_GLOBAL_REG(TLBTR0, (b), (v))
#define SET_TLBTR1(b, v)	 SET_GLOBAL_REG(TLBTR1, (b), (v))
#define SET_TLBTR2(b, v)	 SET_GLOBAL_REG(TLBTR2, (b), (v))
#define SET_TESTBUSCR(b, v)	 SET_GLOBAL_REG(TESTBUSCR, (b), (v))
#define SET_GLOBAL_TLBIALL(b, v) SET_GLOBAL_REG(GLOBAL_TLBIALL, (b), (v))
#define SET_TLBIVMID(b, v)	 SET_GLOBAL_REG(TLBIVMID, (b), (v))
#define SET_CR(b, v)		 SET_GLOBAL_REG(CR, (b), (v))
#define SET_EAR(b, v)		 SET_GLOBAL_REG(EAR, (b), (v))
#define SET_ESR(b, v)		 SET_GLOBAL_REG(ESR, (b), (v))
#define SET_ESRRESTORE(b, v)	 SET_GLOBAL_REG(ESRRESTORE, (b), (v))
#define SET_ESYNR0(b, v)	 SET_GLOBAL_REG(ESYNR0, (b), (v))
#define SET_ESYNR1(b, v)	 SET_GLOBAL_REG(ESYNR1, (b), (v))
#define SET_RPU_ACR(b, v)	 SET_GLOBAL_REG(RPU_ACR, (b), (v))

#define GET_M2VCBR_N(b, N)	 GET_GLOBAL_REG_N(M2VCBR_N, N, (b))
#define GET_CBACR_N(b, N)	 GET_GLOBAL_REG_N(CBACR_N, N, (b))
#define GET_TLBTR0(b)		 GET_GLOBAL_REG(TLBTR0, (b))
#define GET_TLBTR1(b)		 GET_GLOBAL_REG(TLBTR1, (b))
#define GET_TLBTR2(b)		 GET_GLOBAL_REG(TLBTR2, (b))
#define GET_TESTBUSCR(b)	 GET_GLOBAL_REG(TESTBUSCR, (b))
#define GET_GLOBAL_TLBIALL(b)	 GET_GLOBAL_REG(GLOBAL_TLBIALL, (b))
#define GET_TLBIVMID(b)		 GET_GLOBAL_REG(TLBIVMID, (b))
#define GET_CR(b)		 GET_GLOBAL_REG(CR, (b))
#define GET_EAR(b)		 GET_GLOBAL_REG(EAR, (b))
#define GET_ESR(b)		 GET_GLOBAL_REG(ESR, (b))
#define GET_ESRRESTORE(b)	 GET_GLOBAL_REG(ESRRESTORE, (b))
#define GET_ESYNR0(b)		 GET_GLOBAL_REG(ESYNR0, (b))
#define GET_ESYNR1(b)		 GET_GLOBAL_REG(ESYNR1, (b))
#define GET_REV(b)		 GET_GLOBAL_REG(REV, (b))
#define GET_IDR(b)		 GET_GLOBAL_REG(IDR, (b))
#define GET_RPU_ACR(b)		 GET_GLOBAL_REG(RPU_ACR, (b))


/* Context register setters/getters */
#define SET_SCTLR(b, c, v)	 SET_CTX_REG(SCTLR, (b), (c), (v))
#define SET_ACTLR(b, c, v)	 SET_CTX_REG(ACTLR, (b), (c), (v))
#define SET_CONTEXTIDR(b, c, v)	 SET_CTX_REG(CONTEXTIDR, (b), (c), (v))
#define SET_TTBR0(b, c, v)	 SET_CTX_REG(TTBR0, (b), (c), (v))
#define SET_TTBR1(b, c, v)	 SET_CTX_REG(TTBR1, (b), (c), (v))
#define SET_TTBCR(b, c, v)	 SET_CTX_REG(TTBCR, (b), (c), (v))
#define SET_PAR(b, c, v)	 SET_CTX_REG(PAR, (b), (c), (v))
#define SET_FSR(b, c, v)	 SET_CTX_REG(FSR, (b), (c), (v))
#define SET_FSRRESTORE(b, c, v)	 SET_CTX_REG(FSRRESTORE, (b), (c), (v))
#define SET_FAR(b, c, v)	 SET_CTX_REG(FAR, (b), (c), (v))
#define SET_FSYNR0(b, c, v)	 SET_CTX_REG(FSYNR0, (b), (c), (v))
#define SET_FSYNR1(b, c, v)	 SET_CTX_REG(FSYNR1, (b), (c), (v))
#define SET_PRRR(b, c, v)	 SET_CTX_REG(PRRR, (b), (c), (v))
#define SET_NMRR(b, c, v)	 SET_CTX_REG(NMRR, (b), (c), (v))
#define SET_TLBLKCR(b, c, v)	 SET_CTX_REG(TLBLCKR, (b), (c), (v))
#define SET_V2PSR(b, c, v)	 SET_CTX_REG(V2PSR, (b), (c), (v))
#define SET_TLBFLPTER(b, c, v)	 SET_CTX_REG(TLBFLPTER, (b), (c), (v))
#define SET_TLBSLPTER(b, c, v)	 SET_CTX_REG(TLBSLPTER, (b), (c), (v))
#define SET_BFBCR(b, c, v)	 SET_CTX_REG(BFBCR, (b), (c), (v))
#define SET_CTX_TLBIALL(b, c, v) SET_CTX_REG(CTX_TLBIALL, (b), (c), (v))
#define SET_TLBIASID(b, c, v)	 SET_CTX_REG(TLBIASID, (b), (c), (v))
#define SET_TLBIVA(b, c, v)	 SET_CTX_REG(TLBIVA, (b), (c), (v))
#define SET_TLBIVAA(b, c, v)	 SET_CTX_REG(TLBIVAA, (b), (c), (v))
#define SET_V2PPR(b, c, v)	 SET_CTX_REG(V2PPR, (b), (c), (v))
#define SET_V2PPW(b, c, v)	 SET_CTX_REG(V2PPW, (b), (c), (v))
#define SET_V2PUR(b, c, v)	 SET_CTX_REG(V2PUR, (b), (c), (v))
#define SET_V2PUW(b, c, v)	 SET_CTX_REG(V2PUW, (b), (c), (v))
#define SET_RESUME(b, c, v)	 SET_CTX_REG(RESUME, (b), (c), (v))

#define GET_SCTLR(b, c)		 GET_CTX_REG(SCTLR, (b), (c))
#define GET_ACTLR(b, c)		 GET_CTX_REG(ACTLR, (b), (c))
#define GET_CONTEXTIDR(b, c)	 GET_CTX_REG(CONTEXTIDR, (b), (c))
#define GET_TTBR0(b, c)		 GET_CTX_REG(TTBR0, (b), (c))
#define GET_TTBR1(b, c)		 GET_CTX_REG(TTBR1, (b), (c))
#define GET_TTBCR(b, c)		 GET_CTX_REG(TTBCR, (b), (c))
#define GET_PAR(b, c)		 GET_CTX_REG(PAR, (b), (c))
#define GET_FSR(b, c)		 GET_CTX_REG(FSR, (b), (c))
#define GET_FSRRESTORE(b, c)	 GET_CTX_REG(FSRRESTORE, (b), (c))
#define GET_FAR(b, c)		 GET_CTX_REG(FAR, (b), (c))
#define GET_FSYNR0(b, c)	 GET_CTX_REG(FSYNR0, (b), (c))
#define GET_FSYNR1(b, c)	 GET_CTX_REG(FSYNR1, (b), (c))
#define GET_PRRR(b, c)		 GET_CTX_REG(PRRR, (b), (c))
#define GET_NMRR(b, c)		 GET_CTX_REG(NMRR, (b), (c))
#define GET_TLBLCKR(b, c)	 GET_CTX_REG(TLBLCKR, (b), (c))
#define GET_V2PSR(b, c)		 GET_CTX_REG(V2PSR, (b), (c))
#define GET_TLBFLPTER(b, c)	 GET_CTX_REG(TLBFLPTER, (b), (c))
#define GET_TLBSLPTER(b, c)	 GET_CTX_REG(TLBSLPTER, (b), (c))
#define GET_BFBCR(b, c)		 GET_CTX_REG(BFBCR, (b), (c))
#define GET_CTX_TLBIALL(b, c)	 GET_CTX_REG(CTX_TLBIALL, (b), (c))
#define GET_TLBIASID(b, c)	 GET_CTX_REG(TLBIASID, (b), (c))
#define GET_TLBIVA(b, c)	 GET_CTX_REG(TLBIVA, (b), (c))
#define GET_TLBIVAA(b, c)	 GET_CTX_REG(TLBIVAA, (b), (c))
#define GET_V2PPR(b, c)		 GET_CTX_REG(V2PPR, (b), (c))
#define GET_V2PPW(b, c)		 GET_CTX_REG(V2PPW, (b), (c))
#define GET_V2PUR(b, c)		 GET_CTX_REG(V2PUR, (b), (c))
#define GET_V2PUW(b, c)		 GET_CTX_REG(V2PUW, (b), (c))
#define GET_RESUME(b, c)	 GET_CTX_REG(RESUME, (b), (c))


/* Global field setters / getters */
/* Global Field Setters: */
/* CBACR_N */
#define SET_RWVMID(b, n, v)   SET_GLOBAL_FIELD(b, (n<<2)|(CBACR_N), RWVMID, v)
#define SET_RWE(b, n, v)      SET_GLOBAL_FIELD(b, (n<<2)|(CBACR_N), RWE, v)
#define SET_RWGE(b, n, v)     SET_GLOBAL_FIELD(b, (n<<2)|(CBACR_N), RWGE, v)
#define SET_CBVMID(b, n, v)   SET_GLOBAL_FIELD(b, (n<<2)|(CBACR_N), CBVMID, v)
#define SET_IRPTNDX(b, n, v)  SET_GLOBAL_FIELD(b, (n<<2)|(CBACR_N), IRPTNDX, v)


/* M2VCBR_N */
#define SET_VMID(b, n, v)     SET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), VMID, v)
#define SET_CBNDX(b, n, v)    SET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), CBNDX, v)
#define SET_BYPASSD(b, n, v)  SET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BYPASSD, v)
#define SET_BPRCOSH(b, n, v)  SET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPRCOSH, v)
#define SET_BPRCISH(b, n, v)  SET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPRCISH, v)
#define SET_BPRCNSH(b, n, v)  SET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPRCNSH, v)
#define SET_BPSHCFG(b, n, v)  SET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPSHCFG, v)
#define SET_NSCFG(b, n, v)    SET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), NSCFG, v)
#define SET_BPMTCFG(b, n, v)  SET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPMTCFG, v)
#define SET_BPMEMTYPE(b, n, v) \
	SET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPMEMTYPE, v)


/* CR */
#define SET_RPUE(b, v)		 SET_GLOBAL_FIELD(b, CR, RPUE, v)
#define SET_RPUERE(b, v)	 SET_GLOBAL_FIELD(b, CR, RPUERE, v)
#define SET_RPUEIE(b, v)	 SET_GLOBAL_FIELD(b, CR, RPUEIE, v)
#define SET_DCDEE(b, v)		 SET_GLOBAL_FIELD(b, CR, DCDEE, v)
#define SET_CLIENTPD(b, v)       SET_GLOBAL_FIELD(b, CR, CLIENTPD, v)
#define SET_STALLD(b, v)	 SET_GLOBAL_FIELD(b, CR, STALLD, v)
#define SET_TLBLKCRWE(b, v)      SET_GLOBAL_FIELD(b, CR, TLBLKCRWE, v)
#define SET_CR_TLBIALLCFG(b, v)  SET_GLOBAL_FIELD(b, CR, CR_TLBIALLCFG, v)
#define SET_TLBIVMIDCFG(b, v)    SET_GLOBAL_FIELD(b, CR, TLBIVMIDCFG, v)
#define SET_CR_HUME(b, v)        SET_GLOBAL_FIELD(b, CR, CR_HUME, v)


/* ESR */
#define SET_CFG(b, v)		 SET_GLOBAL_FIELD(b, ESR, CFG, v)
#define SET_BYPASS(b, v)	 SET_GLOBAL_FIELD(b, ESR, BYPASS, v)
#define SET_ESR_MULTI(b, v)      SET_GLOBAL_FIELD(b, ESR, ESR_MULTI, v)


/* ESYNR0 */
#define SET_ESYNR0_AMID(b, v)    SET_GLOBAL_FIELD(b, ESYNR0, ESYNR0_AMID, v)
#define SET_ESYNR0_APID(b, v)    SET_GLOBAL_FIELD(b, ESYNR0, ESYNR0_APID, v)
#define SET_ESYNR0_ABID(b, v)    SET_GLOBAL_FIELD(b, ESYNR0, ESYNR0_ABID, v)
#define SET_ESYNR0_AVMID(b, v)   SET_GLOBAL_FIELD(b, ESYNR0, ESYNR0_AVMID, v)
#define SET_ESYNR0_ATID(b, v)    SET_GLOBAL_FIELD(b, ESYNR0, ESYNR0_ATID, v)


/* ESYNR1 */
#define SET_ESYNR1_AMEMTYPE(b, v) \
			SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AMEMTYPE, v)
#define SET_ESYNR1_ASHARED(b, v)  SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_ASHARED, v)
#define SET_ESYNR1_AINNERSHARED(b, v) \
			SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AINNERSHARED, v)
#define SET_ESYNR1_APRIV(b, v)   SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_APRIV, v)
#define SET_ESYNR1_APROTNS(b, v) SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_APROTNS, v)
#define SET_ESYNR1_AINST(b, v)   SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AINST, v)
#define SET_ESYNR1_AWRITE(b, v)  SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AWRITE, v)
#define SET_ESYNR1_ABURST(b, v)  SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_ABURST, v)
#define SET_ESYNR1_ALEN(b, v)    SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_ALEN, v)
#define SET_ESYNR1_ASIZE(b, v)   SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_ASIZE, v)
#define SET_ESYNR1_ALOCK(b, v)   SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_ALOCK, v)
#define SET_ESYNR1_AOOO(b, v)    SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AOOO, v)
#define SET_ESYNR1_AFULL(b, v)   SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AFULL, v)
#define SET_ESYNR1_AC(b, v)      SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AC, v)
#define SET_ESYNR1_DCD(b, v)     SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_DCD, v)


/* TESTBUSCR */
#define SET_TBE(b, v)		 SET_GLOBAL_FIELD(b, TESTBUSCR, TBE, v)
#define SET_SPDMBE(b, v)	 SET_GLOBAL_FIELD(b, TESTBUSCR, SPDMBE, v)
#define SET_WGSEL(b, v)		 SET_GLOBAL_FIELD(b, TESTBUSCR, WGSEL, v)
#define SET_TBLSEL(b, v)	 SET_GLOBAL_FIELD(b, TESTBUSCR, TBLSEL, v)
#define SET_TBHSEL(b, v)	 SET_GLOBAL_FIELD(b, TESTBUSCR, TBHSEL, v)
#define SET_SPDM0SEL(b, v)       SET_GLOBAL_FIELD(b, TESTBUSCR, SPDM0SEL, v)
#define SET_SPDM1SEL(b, v)       SET_GLOBAL_FIELD(b, TESTBUSCR, SPDM1SEL, v)
#define SET_SPDM2SEL(b, v)       SET_GLOBAL_FIELD(b, TESTBUSCR, SPDM2SEL, v)
#define SET_SPDM3SEL(b, v)       SET_GLOBAL_FIELD(b, TESTBUSCR, SPDM3SEL, v)


/* TLBIVMID */
#define SET_TLBIVMID_VMID(b, v)  SET_GLOBAL_FIELD(b, TLBIVMID, TLBIVMID_VMID, v)


/* TLBRSW */
#define SET_TLBRSW_INDEX(b, v)   SET_GLOBAL_FIELD(b, TLBRSW, TLBRSW_INDEX, v)
#define SET_TLBBFBS(b, v)	 SET_GLOBAL_FIELD(b, TLBRSW, TLBBFBS, v)


/* TLBTR0 */
#define SET_PR(b, v)		 SET_GLOBAL_FIELD(b, TLBTR0, PR, v)
#define SET_PW(b, v)		 SET_GLOBAL_FIELD(b, TLBTR0, PW, v)
#define SET_UR(b, v)		 SET_GLOBAL_FIELD(b, TLBTR0, UR, v)
#define SET_UW(b, v)		 SET_GLOBAL_FIELD(b, TLBTR0, UW, v)
#define SET_XN(b, v)		 SET_GLOBAL_FIELD(b, TLBTR0, XN, v)
#define SET_NSDESC(b, v)	 SET_GLOBAL_FIELD(b, TLBTR0, NSDESC, v)
#define SET_ISH(b, v)		 SET_GLOBAL_FIELD(b, TLBTR0, ISH, v)
#define SET_SH(b, v)		 SET_GLOBAL_FIELD(b, TLBTR0, SH, v)
#define SET_MT(b, v)		 SET_GLOBAL_FIELD(b, TLBTR0, MT, v)
#define SET_DPSIZR(b, v)	 SET_GLOBAL_FIELD(b, TLBTR0, DPSIZR, v)
#define SET_DPSIZC(b, v)	 SET_GLOBAL_FIELD(b, TLBTR0, DPSIZC, v)


/* TLBTR1 */
#define SET_TLBTR1_VMID(b, v)    SET_GLOBAL_FIELD(b, TLBTR1, TLBTR1_VMID, v)
#define SET_TLBTR1_PA(b, v)      SET_GLOBAL_FIELD(b, TLBTR1, TLBTR1_PA, v)


/* TLBTR2 */
#define SET_TLBTR2_ASID(b, v)    SET_GLOBAL_FIELD(b, TLBTR2, TLBTR2_ASID, v)
#define SET_TLBTR2_V(b, v)       SET_GLOBAL_FIELD(b, TLBTR2, TLBTR2_V, v)
#define SET_TLBTR2_NSTID(b, v)   SET_GLOBAL_FIELD(b, TLBTR2, TLBTR2_NSTID, v)
#define SET_TLBTR2_NV(b, v)      SET_GLOBAL_FIELD(b, TLBTR2, TLBTR2_NV, v)
#define SET_TLBTR2_VA(b, v)      SET_GLOBAL_FIELD(b, TLBTR2, TLBTR2_VA, v)


/* Global Field Getters */
/* CBACR_N */
#define GET_RWVMID(b, n)	 GET_GLOBAL_FIELD(b, (n<<2)|(CBACR_N), RWVMID)
#define GET_RWE(b, n)		 GET_GLOBAL_FIELD(b, (n<<2)|(CBACR_N), RWE)
#define GET_RWGE(b, n)		 GET_GLOBAL_FIELD(b, (n<<2)|(CBACR_N), RWGE)
#define GET_CBVMID(b, n)	 GET_GLOBAL_FIELD(b, (n<<2)|(CBACR_N), CBVMID)
#define GET_IRPTNDX(b, n)	 GET_GLOBAL_FIELD(b, (n<<2)|(CBACR_N), IRPTNDX)


/* M2VCBR_N */
#define GET_VMID(b, n)       GET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), VMID)
#define GET_CBNDX(b, n)      GET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), CBNDX)
#define GET_BYPASSD(b, n)    GET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BYPASSD)
#define GET_BPRCOSH(b, n)    GET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPRCOSH)
#define GET_BPRCISH(b, n)    GET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPRCISH)
#define GET_BPRCNSH(b, n)    GET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPRCNSH)
#define GET_BPSHCFG(b, n)    GET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPSHCFG)
#define GET_NSCFG(b, n)      GET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), NSCFG)
#define GET_BPMTCFG(b, n)    GET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPMTCFG)
#define GET_BPMEMTYPE(b, n)  GET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPMEMTYPE)


/* CR */
#define GET_RPUE(b)		 GET_GLOBAL_FIELD(b, CR, RPUE)
#define GET_RPUERE(b)		 GET_GLOBAL_FIELD(b, CR, RPUERE)
#define GET_RPUEIE(b)		 GET_GLOBAL_FIELD(b, CR, RPUEIE)
#define GET_DCDEE(b)		 GET_GLOBAL_FIELD(b, CR, DCDEE)
#define GET_CLIENTPD(b)		 GET_GLOBAL_FIELD(b, CR, CLIENTPD)
#define GET_STALLD(b)		 GET_GLOBAL_FIELD(b, CR, STALLD)
#define GET_TLBLKCRWE(b)	 GET_GLOBAL_FIELD(b, CR, TLBLKCRWE)
#define GET_CR_TLBIALLCFG(b)	 GET_GLOBAL_FIELD(b, CR, CR_TLBIALLCFG)
#define GET_TLBIVMIDCFG(b)	 GET_GLOBAL_FIELD(b, CR, TLBIVMIDCFG)
#define GET_CR_HUME(b)		 GET_GLOBAL_FIELD(b, CR, CR_HUME)


/* ESR */
#define GET_CFG(b)		 GET_GLOBAL_FIELD(b, ESR, CFG)
#define GET_BYPASS(b)		 GET_GLOBAL_FIELD(b, ESR, BYPASS)
#define GET_ESR_MULTI(b)	 GET_GLOBAL_FIELD(b, ESR, ESR_MULTI)


/* ESYNR0 */
#define GET_ESYNR0_AMID(b)	 GET_GLOBAL_FIELD(b, ESYNR0, ESYNR0_AMID)
#define GET_ESYNR0_APID(b)	 GET_GLOBAL_FIELD(b, ESYNR0, ESYNR0_APID)
#define GET_ESYNR0_ABID(b)	 GET_GLOBAL_FIELD(b, ESYNR0, ESYNR0_ABID)
#define GET_ESYNR0_AVMID(b)	 GET_GLOBAL_FIELD(b, ESYNR0, ESYNR0_AVMID)
#define GET_ESYNR0_ATID(b)	 GET_GLOBAL_FIELD(b, ESYNR0, ESYNR0_ATID)


/* ESYNR1 */
#define GET_ESYNR1_AMEMTYPE(b)   GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AMEMTYPE)
#define GET_ESYNR1_ASHARED(b)    GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_ASHARED)
#define GET_ESYNR1_AINNERSHARED(b) \
			GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AINNERSHARED)
#define GET_ESYNR1_APRIV(b)      GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_APRIV)
#define GET_ESYNR1_APROTNS(b)	 GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_APROTNS)
#define GET_ESYNR1_AINST(b)	 GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AINST)
#define GET_ESYNR1_AWRITE(b)	 GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AWRITE)
#define GET_ESYNR1_ABURST(b)	 GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_ABURST)
#define GET_ESYNR1_ALEN(b)	 GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_ALEN)
#define GET_ESYNR1_ASIZE(b)	 GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_ASIZE)
#define GET_ESYNR1_ALOCK(b)	 GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_ALOCK)
#define GET_ESYNR1_AOOO(b)	 GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AOOO)
#define GET_ESYNR1_AFULL(b)	 GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AFULL)
#define GET_ESYNR1_AC(b)	 GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AC)
#define GET_ESYNR1_DCD(b)	 GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_DCD)


/* IDR */
#define GET_NM2VCBMT(b)		 GET_GLOBAL_FIELD(b, IDR, NM2VCBMT)
#define GET_HTW(b)		 GET_GLOBAL_FIELD(b, IDR, HTW)
#define GET_HUM(b)		 GET_GLOBAL_FIELD(b, IDR, HUM)
#define GET_TLBSIZE(b)		 GET_GLOBAL_FIELD(b, IDR, TLBSIZE)
#define GET_NCB(b)		 GET_GLOBAL_FIELD(b, IDR, NCB)
#define GET_NIRPT(b)		 GET_GLOBAL_FIELD(b, IDR, NIRPT)


/* REV */
#define GET_MAJOR(b)		 GET_GLOBAL_FIELD(b, REV, MAJOR)
#define GET_MINOR(b)		 GET_GLOBAL_FIELD(b, REV, MINOR)


/* TESTBUSCR */
#define GET_TBE(b)		 GET_GLOBAL_FIELD(b, TESTBUSCR, TBE)
#define GET_SPDMBE(b)		 GET_GLOBAL_FIELD(b, TESTBUSCR, SPDMBE)
#define GET_WGSEL(b)		 GET_GLOBAL_FIELD(b, TESTBUSCR, WGSEL)
#define GET_TBLSEL(b)		 GET_GLOBAL_FIELD(b, TESTBUSCR, TBLSEL)
#define GET_TBHSEL(b)		 GET_GLOBAL_FIELD(b, TESTBUSCR, TBHSEL)
#define GET_SPDM0SEL(b)		 GET_GLOBAL_FIELD(b, TESTBUSCR, SPDM0SEL)
#define GET_SPDM1SEL(b)		 GET_GLOBAL_FIELD(b, TESTBUSCR, SPDM1SEL)
#define GET_SPDM2SEL(b)		 GET_GLOBAL_FIELD(b, TESTBUSCR, SPDM2SEL)
#define GET_SPDM3SEL(b)		 GET_GLOBAL_FIELD(b, TESTBUSCR, SPDM3SEL)


/* TLBIVMID */
#define GET_TLBIVMID_VMID(b)	 GET_GLOBAL_FIELD(b, TLBIVMID, TLBIVMID_VMID)


/* TLBTR0 */
#define GET_PR(b)		 GET_GLOBAL_FIELD(b, TLBTR0, PR)
#define GET_PW(b)		 GET_GLOBAL_FIELD(b, TLBTR0, PW)
#define GET_UR(b)		 GET_GLOBAL_FIELD(b, TLBTR0, UR)
#define GET_UW(b)		 GET_GLOBAL_FIELD(b, TLBTR0, UW)
#define GET_XN(b)		 GET_GLOBAL_FIELD(b, TLBTR0, XN)
#define GET_NSDESC(b)		 GET_GLOBAL_FIELD(b, TLBTR0, NSDESC)
#define GET_ISH(b)		 GET_GLOBAL_FIELD(b, TLBTR0, ISH)
#define GET_SH(b)		 GET_GLOBAL_FIELD(b, TLBTR0, SH)
#define GET_MT(b)		 GET_GLOBAL_FIELD(b, TLBTR0, MT)
#define GET_DPSIZR(b)		 GET_GLOBAL_FIELD(b, TLBTR0, DPSIZR)
#define GET_DPSIZC(b)		 GET_GLOBAL_FIELD(b, TLBTR0, DPSIZC)


/* TLBTR1 */
#define GET_TLBTR1_VMID(b)	 GET_GLOBAL_FIELD(b, TLBTR1, TLBTR1_VMID)
#define GET_TLBTR1_PA(b)	 GET_GLOBAL_FIELD(b, TLBTR1, TLBTR1_PA)


/* TLBTR2 */
#define GET_TLBTR2_ASID(b)	 GET_GLOBAL_FIELD(b, TLBTR2, TLBTR2_ASID)
#define GET_TLBTR2_V(b)		 GET_GLOBAL_FIELD(b, TLBTR2, TLBTR2_V)
#define GET_TLBTR2_NSTID(b)	 GET_GLOBAL_FIELD(b, TLBTR2, TLBTR2_NSTID)
#define GET_TLBTR2_NV(b)	 GET_GLOBAL_FIELD(b, TLBTR2, TLBTR2_NV)
#define GET_TLBTR2_VA(b)	 GET_GLOBAL_FIELD(b, TLBTR2, TLBTR2_VA)


/* Context Register setters / getters */
/* Context Register setters */
/* ACTLR */
#define SET_CFERE(b, c, v)	 SET_CONTEXT_FIELD(b, c, ACTLR, CFERE, v)
#define SET_CFEIE(b, c, v)	 SET_CONTEXT_FIELD(b, c, ACTLR, CFEIE, v)
#define SET_PTSHCFG(b, c, v)	 SET_CONTEXT_FIELD(b, c, ACTLR, PTSHCFG, v)
#define SET_RCOSH(b, c, v)	 SET_CONTEXT_FIELD(b, c, ACTLR, RCOSH, v)
#define SET_RCISH(b, c, v)	 SET_CONTEXT_FIELD(b, c, ACTLR, RCISH, v)
#define SET_RCNSH(b, c, v)	 SET_CONTEXT_FIELD(b, c, ACTLR, RCNSH, v)
#define SET_PRIVCFG(b, c, v)	 SET_CONTEXT_FIELD(b, c, ACTLR, PRIVCFG, v)
#define SET_DNA(b, c, v)	 SET_CONTEXT_FIELD(b, c, ACTLR, DNA, v)
#define SET_DNLV2PA(b, c, v)	 SET_CONTEXT_FIELD(b, c, ACTLR, DNLV2PA, v)
#define SET_TLBMCFG(b, c, v)	 SET_CONTEXT_FIELD(b, c, ACTLR, TLBMCFG, v)
#define SET_CFCFG(b, c, v)	 SET_CONTEXT_FIELD(b, c, ACTLR, CFCFG, v)
#define SET_TIPCF(b, c, v)	 SET_CONTEXT_FIELD(b, c, ACTLR, TIPCF, v)
#define SET_V2PCFG(b, c, v)	 SET_CONTEXT_FIELD(b, c, ACTLR, V2PCFG, v)
#define SET_HUME(b, c, v)	 SET_CONTEXT_FIELD(b, c, ACTLR, HUME, v)
#define SET_PTMTCFG(b, c, v)	 SET_CONTEXT_FIELD(b, c, ACTLR, PTMTCFG, v)
#define SET_PTMEMTYPE(b, c, v)	 SET_CONTEXT_FIELD(b, c, ACTLR, PTMEMTYPE, v)


/* BFBCR */
#define SET_BFBDFE(b, c, v)	 SET_CONTEXT_FIELD(b, c, BFBCR, BFBDFE, v)
#define SET_BFBSFE(b, c, v)	 SET_CONTEXT_FIELD(b, c, BFBCR, BFBSFE, v)
#define SET_SFVS(b, c, v)	 SET_CONTEXT_FIELD(b, c, BFBCR, SFVS, v)
#define SET_FLVIC(b, c, v)	 SET_CONTEXT_FIELD(b, c, BFBCR, FLVIC, v)
#define SET_SLVIC(b, c, v)	 SET_CONTEXT_FIELD(b, c, BFBCR, SLVIC, v)


/* CONTEXTIDR */
#define SET_CONTEXTIDR_ASID(b, c, v)   \
		SET_CONTEXT_FIELD(b, c, CONTEXTIDR, CONTEXTIDR_ASID, v)
#define SET_CONTEXTIDR_PROCID(b, c, v) \
		SET_CONTEXT_FIELD(b, c, CONTEXTIDR, PROCID, v)


/* FSR */
#define SET_TF(b, c, v)		 SET_CONTEXT_FIELD(b, c, FSR, TF, v)
#define SET_AFF(b, c, v)	 SET_CONTEXT_FIELD(b, c, FSR, AFF, v)
#define SET_APF(b, c, v)	 SET_CONTEXT_FIELD(b, c, FSR, APF, v)
#define SET_TLBMF(b, c, v)	 SET_CONTEXT_FIELD(b, c, FSR, TLBMF, v)
#define SET_HTWDEEF(b, c, v)	 SET_CONTEXT_FIELD(b, c, FSR, HTWDEEF, v)
#define SET_HTWSEEF(b, c, v)	 SET_CONTEXT_FIELD(b, c, FSR, HTWSEEF, v)
#define SET_MHF(b, c, v)	 SET_CONTEXT_FIELD(b, c, FSR, MHF, v)
#define SET_SL(b, c, v)		 SET_CONTEXT_FIELD(b, c, FSR, SL, v)
#define SET_SS(b, c, v)		 SET_CONTEXT_FIELD(b, c, FSR, SS, v)
#define SET_MULTI(b, c, v)	 SET_CONTEXT_FIELD(b, c, FSR, MULTI, v)


/* FSYNR0 */
#define SET_AMID(b, c, v)	 SET_CONTEXT_FIELD(b, c, FSYNR0, AMID, v)
#define SET_APID(b, c, v)	 SET_CONTEXT_FIELD(b, c, FSYNR0, APID, v)
#define SET_ABID(b, c, v)	 SET_CONTEXT_FIELD(b, c, FSYNR0, ABID, v)
#define SET_ATID(b, c, v)	 SET_CONTEXT_FIELD(b, c, FSYNR0, ATID, v)


/* FSYNR1 */
#define SET_AMEMTYPE(b, c, v)	 SET_CONTEXT_FIELD(b, c, FSYNR1, AMEMTYPE, v)
#define SET_ASHARED(b, c, v)	 SET_CONTEXT_FIELD(b, c, FSYNR1, ASHARED, v)
#define SET_AINNERSHARED(b, c, v)  \
				SET_CONTEXT_FIELD(b, c, FSYNR1, AINNERSHARED, v)
#define SET_APRIV(b, c, v)	 SET_CONTEXT_FIELD(b, c, FSYNR1, APRIV, v)
#define SET_APROTNS(b, c, v)	 SET_CONTEXT_FIELD(b, c, FSYNR1, APROTNS, v)
#define SET_AINST(b, c, v)	 SET_CONTEXT_FIELD(b, c, FSYNR1, AINST, v)
#define SET_AWRITE(b, c, v)	 SET_CONTEXT_FIELD(b, c, FSYNR1, AWRITE, v)
#define SET_ABURST(b, c, v)	 SET_CONTEXT_FIELD(b, c, FSYNR1, ABURST, v)
#define SET_ALEN(b, c, v)	 SET_CONTEXT_FIELD(b, c, FSYNR1, ALEN, v)
#define SET_FSYNR1_ASIZE(b, c, v) \
				SET_CONTEXT_FIELD(b, c, FSYNR1, FSYNR1_ASIZE, v)
#define SET_ALOCK(b, c, v)	 SET_CONTEXT_FIELD(b, c, FSYNR1, ALOCK, v)
#define SET_AFULL(b, c, v)	 SET_CONTEXT_FIELD(b, c, FSYNR1, AFULL, v)


/* NMRR */
#define SET_ICPC0(b, c, v)	 SET_CONTEXT_FIELD(b, c, NMRR, ICPC0, v)
#define SET_ICPC1(b, c, v)	 SET_CONTEXT_FIELD(b, c, NMRR, ICPC1, v)
#define SET_ICPC2(b, c, v)	 SET_CONTEXT_FIELD(b, c, NMRR, ICPC2, v)
#define SET_ICPC3(b, c, v)	 SET_CONTEXT_FIELD(b, c, NMRR, ICPC3, v)
#define SET_ICPC4(b, c, v)	 SET_CONTEXT_FIELD(b, c, NMRR, ICPC4, v)
#define SET_ICPC5(b, c, v)	 SET_CONTEXT_FIELD(b, c, NMRR, ICPC5, v)
#define SET_ICPC6(b, c, v)	 SET_CONTEXT_FIELD(b, c, NMRR, ICPC6, v)
#define SET_ICPC7(b, c, v)	 SET_CONTEXT_FIELD(b, c, NMRR, ICPC7, v)
#define SET_OCPC0(b, c, v)	 SET_CONTEXT_FIELD(b, c, NMRR, OCPC0, v)
#define SET_OCPC1(b, c, v)	 SET_CONTEXT_FIELD(b, c, NMRR, OCPC1, v)
#define SET_OCPC2(b, c, v)	 SET_CONTEXT_FIELD(b, c, NMRR, OCPC2, v)
#define SET_OCPC3(b, c, v)	 SET_CONTEXT_FIELD(b, c, NMRR, OCPC3, v)
#define SET_OCPC4(b, c, v)	 SET_CONTEXT_FIELD(b, c, NMRR, OCPC4, v)
#define SET_OCPC5(b, c, v)	 SET_CONTEXT_FIELD(b, c, NMRR, OCPC5, v)
#define SET_OCPC6(b, c, v)	 SET_CONTEXT_FIELD(b, c, NMRR, OCPC6, v)
#define SET_OCPC7(b, c, v)	 SET_CONTEXT_FIELD(b, c, NMRR, OCPC7, v)


/* PAR */
#define SET_FAULT(b, c, v)	 SET_CONTEXT_FIELD(b, c, PAR, FAULT, v)

#define SET_FAULT_TF(b, c, v)	 SET_CONTEXT_FIELD(b, c, PAR, FAULT_TF, v)
#define SET_FAULT_AFF(b, c, v)	 SET_CONTEXT_FIELD(b, c, PAR, FAULT_AFF, v)
#define SET_FAULT_APF(b, c, v)	 SET_CONTEXT_FIELD(b, c, PAR, FAULT_APF, v)
#define SET_FAULT_TLBMF(b, c, v) SET_CONTEXT_FIELD(b, c, PAR, FAULT_TLBMF, v)
#define SET_FAULT_HTWDEEF(b, c, v) \
				SET_CONTEXT_FIELD(b, c, PAR, FAULT_HTWDEEF, v)
#define SET_FAULT_HTWSEEF(b, c, v) \
				SET_CONTEXT_FIELD(b, c, PAR, FAULT_HTWSEEF, v)
#define SET_FAULT_MHF(b, c, v)	 SET_CONTEXT_FIELD(b, c, PAR, FAULT_MHF, v)
#define SET_FAULT_SL(b, c, v)	 SET_CONTEXT_FIELD(b, c, PAR, FAULT_SL, v)
#define SET_FAULT_SS(b, c, v)	 SET_CONTEXT_FIELD(b, c, PAR, FAULT_SS, v)

#define SET_NOFAULT_SS(b, c, v)	 SET_CONTEXT_FIELD(b, c, PAR, NOFAULT_SS, v)
#define SET_NOFAULT_MT(b, c, v)	 SET_CONTEXT_FIELD(b, c, PAR, NOFAULT_MT, v)
#define SET_NOFAULT_SH(b, c, v)	 SET_CONTEXT_FIELD(b, c, PAR, NOFAULT_SH, v)
#define SET_NOFAULT_NS(b, c, v)	 SET_CONTEXT_FIELD(b, c, PAR, NOFAULT_NS, v)
#define SET_NOFAULT_NOS(b, c, v) SET_CONTEXT_FIELD(b, c, PAR, NOFAULT_NOS, v)
#define SET_NPFAULT_PA(b, c, v)	 SET_CONTEXT_FIELD(b, c, PAR, NPFAULT_PA, v)


/* PRRR */
#define SET_MTC0(b, c, v)	 SET_CONTEXT_FIELD(b, c, PRRR, MTC0, v)
#define SET_MTC1(b, c, v)	 SET_CONTEXT_FIELD(b, c, PRRR, MTC1, v)
#define SET_MTC2(b, c, v)	 SET_CONTEXT_FIELD(b, c, PRRR, MTC2, v)
#define SET_MTC3(b, c, v)	 SET_CONTEXT_FIELD(b, c, PRRR, MTC3, v)
#define SET_MTC4(b, c, v)	 SET_CONTEXT_FIELD(b, c, PRRR, MTC4, v)
#define SET_MTC5(b, c, v)	 SET_CONTEXT_FIELD(b, c, PRRR, MTC5, v)
#define SET_MTC6(b, c, v)	 SET_CONTEXT_FIELD(b, c, PRRR, MTC6, v)
#define SET_MTC7(b, c, v)	 SET_CONTEXT_FIELD(b, c, PRRR, MTC7, v)
#define SET_SHDSH0(b, c, v)	 SET_CONTEXT_FIELD(b, c, PRRR, SHDSH0, v)
#define SET_SHDSH1(b, c, v)	 SET_CONTEXT_FIELD(b, c, PRRR, SHDSH1, v)
#define SET_SHNMSH0(b, c, v)	 SET_CONTEXT_FIELD(b, c, PRRR, SHNMSH0, v)
#define SET_SHNMSH1(b, c, v)     SET_CONTEXT_FIELD(b, c, PRRR, SHNMSH1, v)
#define SET_NOS0(b, c, v)	 SET_CONTEXT_FIELD(b, c, PRRR, NOS0, v)
#define SET_NOS1(b, c, v)	 SET_CONTEXT_FIELD(b, c, PRRR, NOS1, v)
#define SET_NOS2(b, c, v)	 SET_CONTEXT_FIELD(b, c, PRRR, NOS2, v)
#define SET_NOS3(b, c, v)	 SET_CONTEXT_FIELD(b, c, PRRR, NOS3, v)
#define SET_NOS4(b, c, v)	 SET_CONTEXT_FIELD(b, c, PRRR, NOS4, v)
#define SET_NOS5(b, c, v)	 SET_CONTEXT_FIELD(b, c, PRRR, NOS5, v)
#define SET_NOS6(b, c, v)	 SET_CONTEXT_FIELD(b, c, PRRR, NOS6, v)
#define SET_NOS7(b, c, v)	 SET_CONTEXT_FIELD(b, c, PRRR, NOS7, v)


/* RESUME */
#define SET_TNR(b, c, v)	 SET_CONTEXT_FIELD(b, c, RESUME, TNR, v)


/* SCTLR */
#define SET_M(b, c, v)		 SET_CONTEXT_FIELD(b, c, SCTLR, M, v)
#define SET_TRE(b, c, v)	 SET_CONTEXT_FIELD(b, c, SCTLR, TRE, v)
#define SET_AFE(b, c, v)	 SET_CONTEXT_FIELD(b, c, SCTLR, AFE, v)
#define SET_HAF(b, c, v)	 SET_CONTEXT_FIELD(b, c, SCTLR, HAF, v)
#define SET_BE(b, c, v)		 SET_CONTEXT_FIELD(b, c, SCTLR, BE, v)
#define SET_AFFD(b, c, v)	 SET_CONTEXT_FIELD(b, c, SCTLR, AFFD, v)


/* TLBLKCR */
#define SET_LKE(b, c, v)	   SET_CONTEXT_FIELD(b, c, TLBLKCR, LKE, v)
#define SET_TLBLKCR_TLBIALLCFG(b, c, v) \
			SET_CONTEXT_FIELD(b, c, TLBLKCR, TLBLCKR_TLBIALLCFG, v)
#define SET_TLBIASIDCFG(b, c, v) \
			SET_CONTEXT_FIELD(b, c, TLBLKCR, TLBIASIDCFG, v)
#define SET_TLBIVAACFG(b, c, v)	SET_CONTEXT_FIELD(b, c, TLBLKCR, TLBIVAACFG, v)
#define SET_FLOOR(b, c, v)	SET_CONTEXT_FIELD(b, c, TLBLKCR, FLOOR, v)
#define SET_VICTIM(b, c, v)	SET_CONTEXT_FIELD(b, c, TLBLKCR, VICTIM, v)


/* TTBCR */
#define SET_N(b, c, v)	         SET_CONTEXT_FIELD(b, c, TTBCR, N, v)
#define SET_PD0(b, c, v)	 SET_CONTEXT_FIELD(b, c, TTBCR, PD0, v)
#define SET_PD1(b, c, v)	 SET_CONTEXT_FIELD(b, c, TTBCR, PD1, v)


/* TTBR0 */
#define SET_TTBR0_IRGNH(b, c, v) SET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_IRGNH, v)
#define SET_TTBR0_SH(b, c, v)	 SET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_SH, v)
#define SET_TTBR0_ORGN(b, c, v)	 SET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_ORGN, v)
#define SET_TTBR0_NOS(b, c, v)	 SET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_NOS, v)
#define SET_TTBR0_IRGNL(b, c, v) SET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_IRGNL, v)
#define SET_TTBR0_PA(b, c, v)	 SET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_PA, v)


/* TTBR1 */
#define SET_TTBR1_IRGNH(b, c, v) SET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_IRGNH, v)
#define SET_TTBR1_SH(b, c, v)	 SET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_SH, v)
#define SET_TTBR1_ORGN(b, c, v)	 SET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_ORGN, v)
#define SET_TTBR1_NOS(b, c, v)	 SET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_NOS, v)
#define SET_TTBR1_IRGNL(b, c, v) SET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_IRGNL, v)
#define SET_TTBR1_PA(b, c, v)	 SET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_PA, v)


/* V2PSR */
#define SET_HIT(b, c, v)	 SET_CONTEXT_FIELD(b, c, V2PSR, HIT, v)
#define SET_INDEX(b, c, v)	 SET_CONTEXT_FIELD(b, c, V2PSR, INDEX, v)


/* V2Pxx UW UR PW PR */
#define SET_V2PUW_INDEX(b, c, v) SET_CONTEXT_FIELD(b, c, V2PUW, V2Pxx_INDEX, v)
#define SET_V2PUW_VA(b, c, v)	 SET_CONTEXT_FIELD(b, c, V2PUW, V2Pxx_VA, v)

#define SET_V2PUR_INDEX(b, c, v) SET_CONTEXT_FIELD(b, c, V2PUR, V2Pxx_INDEX, v)
#define SET_V2PUR_VA(b, c, v)	 SET_CONTEXT_FIELD(b, c, V2PUR, V2Pxx_VA, v)

#define SET_V2PPW_INDEX(b, c, v) SET_CONTEXT_FIELD(b, c, V2PPW, V2Pxx_INDEX, v)
#define SET_V2PPW_VA(b, c, v)	 SET_CONTEXT_FIELD(b, c, V2PPW, V2Pxx_VA, v)

#define SET_V2PPR_INDEX(b, c, v) SET_CONTEXT_FIELD(b, c, V2PPR, V2Pxx_INDEX, v)
#define SET_V2PPR_VA(b, c, v)	 SET_CONTEXT_FIELD(b, c, V2PPR, V2Pxx_VA, v)


/* Context Register getters */
/* ACTLR */
#define GET_CFERE(b, c)	        GET_CONTEXT_FIELD(b, c, ACTLR, CFERE)
#define GET_CFEIE(b, c)	        GET_CONTEXT_FIELD(b, c, ACTLR, CFEIE)
#define GET_PTSHCFG(b, c)       GET_CONTEXT_FIELD(b, c, ACTLR, PTSHCFG)
#define GET_RCOSH(b, c)	        GET_CONTEXT_FIELD(b, c, ACTLR, RCOSH)
#define GET_RCISH(b, c)	        GET_CONTEXT_FIELD(b, c, ACTLR, RCISH)
#define GET_RCNSH(b, c)	        GET_CONTEXT_FIELD(b, c, ACTLR, RCNSH)
#define GET_PRIVCFG(b, c)       GET_CONTEXT_FIELD(b, c, ACTLR, PRIVCFG)
#define GET_DNA(b, c)	        GET_CONTEXT_FIELD(b, c, ACTLR, DNA)
#define GET_DNLV2PA(b, c)       GET_CONTEXT_FIELD(b, c, ACTLR, DNLV2PA)
#define GET_TLBMCFG(b, c)       GET_CONTEXT_FIELD(b, c, ACTLR, TLBMCFG)
#define GET_CFCFG(b, c)	        GET_CONTEXT_FIELD(b, c, ACTLR, CFCFG)
#define GET_TIPCF(b, c)	        GET_CONTEXT_FIELD(b, c, ACTLR, TIPCF)
#define GET_V2PCFG(b, c)        GET_CONTEXT_FIELD(b, c, ACTLR, V2PCFG)
#define GET_HUME(b, c)	        GET_CONTEXT_FIELD(b, c, ACTLR, HUME)
#define GET_PTMTCFG(b, c)       GET_CONTEXT_FIELD(b, c, ACTLR, PTMTCFG)
#define GET_PTMEMTYPE(b, c)     GET_CONTEXT_FIELD(b, c, ACTLR, PTMEMTYPE)

/* BFBCR */
#define GET_BFBDFE(b, c)	GET_CONTEXT_FIELD(b, c, BFBCR, BFBDFE)
#define GET_BFBSFE(b, c)	GET_CONTEXT_FIELD(b, c, BFBCR, BFBSFE)
#define GET_SFVS(b, c)		GET_CONTEXT_FIELD(b, c, BFBCR, SFVS)
#define GET_FLVIC(b, c)		GET_CONTEXT_FIELD(b, c, BFBCR, FLVIC)
#define GET_SLVIC(b, c)		GET_CONTEXT_FIELD(b, c, BFBCR, SLVIC)


/* CONTEXTIDR */
#define GET_CONTEXTIDR_ASID(b, c) \
			GET_CONTEXT_FIELD(b, c, CONTEXTIDR, CONTEXTIDR_ASID)
#define GET_CONTEXTIDR_PROCID(b, c) GET_CONTEXT_FIELD(b, c, CONTEXTIDR, PROCID)


/* FSR */
#define GET_TF(b, c)		GET_CONTEXT_FIELD(b, c, FSR, TF)
#define GET_AFF(b, c)		GET_CONTEXT_FIELD(b, c, FSR, AFF)
#define GET_APF(b, c)		GET_CONTEXT_FIELD(b, c, FSR, APF)
#define GET_TLBMF(b, c)		GET_CONTEXT_FIELD(b, c, FSR, TLBMF)
#define GET_HTWDEEF(b, c)	GET_CONTEXT_FIELD(b, c, FSR, HTWDEEF)
#define GET_HTWSEEF(b, c)	GET_CONTEXT_FIELD(b, c, FSR, HTWSEEF)
#define GET_MHF(b, c)		GET_CONTEXT_FIELD(b, c, FSR, MHF)
#define GET_SL(b, c)		GET_CONTEXT_FIELD(b, c, FSR, SL)
#define GET_SS(b, c)		GET_CONTEXT_FIELD(b, c, FSR, SS)
#define GET_MULTI(b, c)		GET_CONTEXT_FIELD(b, c, FSR, MULTI)


/* FSYNR0 */
#define GET_AMID(b, c)		GET_CONTEXT_FIELD(b, c, FSYNR0, AMID)
#define GET_APID(b, c)		GET_CONTEXT_FIELD(b, c, FSYNR0, APID)
#define GET_ABID(b, c)		GET_CONTEXT_FIELD(b, c, FSYNR0, ABID)
#define GET_ATID(b, c)		GET_CONTEXT_FIELD(b, c, FSYNR0, ATID)


/* FSYNR1 */
#define GET_AMEMTYPE(b, c)	GET_CONTEXT_FIELD(b, c, FSYNR1, AMEMTYPE)
#define GET_ASHARED(b, c)	GET_CONTEXT_FIELD(b, c, FSYNR1, ASHARED)
#define GET_AINNERSHARED(b, c)  GET_CONTEXT_FIELD(b, c, FSYNR1, AINNERSHARED)
#define GET_APRIV(b, c)		GET_CONTEXT_FIELD(b, c, FSYNR1, APRIV)
#define GET_APROTNS(b, c)	GET_CONTEXT_FIELD(b, c, FSYNR1, APROTNS)
#define GET_AINST(b, c)		GET_CONTEXT_FIELD(b, c, FSYNR1, AINST)
#define GET_AWRITE(b, c)	GET_CONTEXT_FIELD(b, c, FSYNR1, AWRITE)
#define GET_ABURST(b, c)	GET_CONTEXT_FIELD(b, c, FSYNR1, ABURST)
#define GET_ALEN(b, c)		GET_CONTEXT_FIELD(b, c, FSYNR1, ALEN)
#define GET_FSYNR1_ASIZE(b, c)	GET_CONTEXT_FIELD(b, c, FSYNR1, FSYNR1_ASIZE)
#define GET_ALOCK(b, c)		GET_CONTEXT_FIELD(b, c, FSYNR1, ALOCK)
#define GET_AFULL(b, c)		GET_CONTEXT_FIELD(b, c, FSYNR1, AFULL)


/* NMRR */
#define GET_ICPC0(b, c)		GET_CONTEXT_FIELD(b, c, NMRR, ICPC0)
#define GET_ICPC1(b, c)		GET_CONTEXT_FIELD(b, c, NMRR, ICPC1)
#define GET_ICPC2(b, c)		GET_CONTEXT_FIELD(b, c, NMRR, ICPC2)
#define GET_ICPC3(b, c)		GET_CONTEXT_FIELD(b, c, NMRR, ICPC3)
#define GET_ICPC4(b, c)		GET_CONTEXT_FIELD(b, c, NMRR, ICPC4)
#define GET_ICPC5(b, c)		GET_CONTEXT_FIELD(b, c, NMRR, ICPC5)
#define GET_ICPC6(b, c)		GET_CONTEXT_FIELD(b, c, NMRR, ICPC6)
#define GET_ICPC7(b, c)		GET_CONTEXT_FIELD(b, c, NMRR, ICPC7)
#define GET_OCPC0(b, c)		GET_CONTEXT_FIELD(b, c, NMRR, OCPC0)
#define GET_OCPC1(b, c)		GET_CONTEXT_FIELD(b, c, NMRR, OCPC1)
#define GET_OCPC2(b, c)		GET_CONTEXT_FIELD(b, c, NMRR, OCPC2)
#define GET_OCPC3(b, c)		GET_CONTEXT_FIELD(b, c, NMRR, OCPC3)
#define GET_OCPC4(b, c)		GET_CONTEXT_FIELD(b, c, NMRR, OCPC4)
#define GET_OCPC5(b, c)		GET_CONTEXT_FIELD(b, c, NMRR, OCPC5)
#define GET_OCPC6(b, c)		GET_CONTEXT_FIELD(b, c, NMRR, OCPC6)
#define GET_OCPC7(b, c)		GET_CONTEXT_FIELD(b, c, NMRR, OCPC7)
#define NMRR_ICP(nmrr, n)	(((nmrr) & (3 << ((n) * 2))) >> ((n) * 2))
#define NMRR_OCP(nmrr, n)	(((nmrr) & (3 << ((n) * 2 + 16))) >> \
								((n) * 2 + 16))

/* PAR */
#define GET_FAULT(b, c)		GET_CONTEXT_FIELD(b, c, PAR, FAULT)

#define GET_FAULT_TF(b, c)	GET_CONTEXT_FIELD(b, c, PAR, FAULT_TF)
#define GET_FAULT_AFF(b, c)	GET_CONTEXT_FIELD(b, c, PAR, FAULT_AFF)
#define GET_FAULT_APF(b, c)	GET_CONTEXT_FIELD(b, c, PAR, FAULT_APF)
#define GET_FAULT_TLBMF(b, c)   GET_CONTEXT_FIELD(b, c, PAR, FAULT_TLBMF)
#define GET_FAULT_HTWDEEF(b, c) GET_CONTEXT_FIELD(b, c, PAR, FAULT_HTWDEEF)
#define GET_FAULT_HTWSEEF(b, c) GET_CONTEXT_FIELD(b, c, PAR, FAULT_HTWSEEF)
#define GET_FAULT_MHF(b, c)	GET_CONTEXT_FIELD(b, c, PAR, FAULT_MHF)
#define GET_FAULT_SL(b, c)	GET_CONTEXT_FIELD(b, c, PAR, FAULT_SL)
#define GET_FAULT_SS(b, c)	GET_CONTEXT_FIELD(b, c, PAR, FAULT_SS)

#define GET_NOFAULT_SS(b, c)	GET_CONTEXT_FIELD(b, c, PAR, PAR_NOFAULT_SS)
#define GET_NOFAULT_MT(b, c)	GET_CONTEXT_FIELD(b, c, PAR, PAR_NOFAULT_MT)
#define GET_NOFAULT_SH(b, c)	GET_CONTEXT_FIELD(b, c, PAR, PAR_NOFAULT_SH)
#define GET_NOFAULT_NS(b, c)	GET_CONTEXT_FIELD(b, c, PAR, PAR_NOFAULT_NS)
#define GET_NOFAULT_NOS(b, c)   GET_CONTEXT_FIELD(b, c, PAR, PAR_NOFAULT_NOS)
#define GET_NPFAULT_PA(b, c)	GET_CONTEXT_FIELD(b, c, PAR, PAR_NPFAULT_PA)


/* PRRR */
#define GET_MTC0(b, c)		GET_CONTEXT_FIELD(b, c, PRRR, MTC0)
#define GET_MTC1(b, c)		GET_CONTEXT_FIELD(b, c, PRRR, MTC1)
#define GET_MTC2(b, c)		GET_CONTEXT_FIELD(b, c, PRRR, MTC2)
#define GET_MTC3(b, c)		GET_CONTEXT_FIELD(b, c, PRRR, MTC3)
#define GET_MTC4(b, c)		GET_CONTEXT_FIELD(b, c, PRRR, MTC4)
#define GET_MTC5(b, c)		GET_CONTEXT_FIELD(b, c, PRRR, MTC5)
#define GET_MTC6(b, c)		GET_CONTEXT_FIELD(b, c, PRRR, MTC6)
#define GET_MTC7(b, c)		GET_CONTEXT_FIELD(b, c, PRRR, MTC7)
#define GET_SHDSH0(b, c)	GET_CONTEXT_FIELD(b, c, PRRR, SHDSH0)
#define GET_SHDSH1(b, c)	GET_CONTEXT_FIELD(b, c, PRRR, SHDSH1)
#define GET_SHNMSH0(b, c)	GET_CONTEXT_FIELD(b, c, PRRR, SHNMSH0)
#define GET_SHNMSH1(b, c)	GET_CONTEXT_FIELD(b, c, PRRR, SHNMSH1)
#define GET_NOS0(b, c)		GET_CONTEXT_FIELD(b, c, PRRR, NOS0)
#define GET_NOS1(b, c)		GET_CONTEXT_FIELD(b, c, PRRR, NOS1)
#define GET_NOS2(b, c)		GET_CONTEXT_FIELD(b, c, PRRR, NOS2)
#define GET_NOS3(b, c)		GET_CONTEXT_FIELD(b, c, PRRR, NOS3)
#define GET_NOS4(b, c)		GET_CONTEXT_FIELD(b, c, PRRR, NOS4)
#define GET_NOS5(b, c)		GET_CONTEXT_FIELD(b, c, PRRR, NOS5)
#define GET_NOS6(b, c)		GET_CONTEXT_FIELD(b, c, PRRR, NOS6)
#define GET_NOS7(b, c)		GET_CONTEXT_FIELD(b, c, PRRR, NOS7)
#define PRRR_NOS(prrr, n)	 ((prrr) & (1 << ((n) + 24)) ? 1 : 0)
#define PRRR_MT(prrr, n)	 ((((prrr) & (3 << ((n) * 2))) >> ((n) * 2)))


/* RESUME */
#define GET_TNR(b, c)		GET_CONTEXT_FIELD(b, c, RESUME, TNR)


/* SCTLR */
#define GET_M(b, c)		GET_CONTEXT_FIELD(b, c, SCTLR, M)
#define GET_TRE(b, c)		GET_CONTEXT_FIELD(b, c, SCTLR, TRE)
#define GET_AFE(b, c)		GET_CONTEXT_FIELD(b, c, SCTLR, AFE)
#define GET_HAF(b, c)		GET_CONTEXT_FIELD(b, c, SCTLR, HAF)
#define GET_BE(b, c)		GET_CONTEXT_FIELD(b, c, SCTLR, BE)
#define GET_AFFD(b, c)		GET_CONTEXT_FIELD(b, c, SCTLR, AFFD)


/* TLBLKCR */
#define GET_LKE(b, c)		GET_CONTEXT_FIELD(b, c, TLBLKCR, LKE)
#define GET_TLBLCKR_TLBIALLCFG(b, c) \
			GET_CONTEXT_FIELD(b, c, TLBLKCR, TLBLCKR_TLBIALLCFG)
#define GET_TLBIASIDCFG(b, c)   GET_CONTEXT_FIELD(b, c, TLBLKCR, TLBIASIDCFG)
#define GET_TLBIVAACFG(b, c)	GET_CONTEXT_FIELD(b, c, TLBLKCR, TLBIVAACFG)
#define GET_FLOOR(b, c)		GET_CONTEXT_FIELD(b, c, TLBLKCR, FLOOR)
#define GET_VICTIM(b, c)	GET_CONTEXT_FIELD(b, c, TLBLKCR, VICTIM)


/* TTBCR */
#define GET_N(b, c)		GET_CONTEXT_FIELD(b, c, TTBCR, N)
#define GET_PD0(b, c)		GET_CONTEXT_FIELD(b, c, TTBCR, PD0)
#define GET_PD1(b, c)		GET_CONTEXT_FIELD(b, c, TTBCR, PD1)


/* TTBR0 */
#define GET_TTBR0_IRGNH(b, c)	GET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_IRGNH)
#define GET_TTBR0_SH(b, c)	GET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_SH)
#define GET_TTBR0_ORGN(b, c)	GET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_ORGN)
#define GET_TTBR0_NOS(b, c)	GET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_NOS)
#define GET_TTBR0_IRGNL(b, c)	GET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_IRGNL)
#define GET_TTBR0_PA(b, c)	GET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_PA)


/* TTBR1 */
#define GET_TTBR1_IRGNH(b, c)	GET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_IRGNH)
#define GET_TTBR1_SH(b, c)	GET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_SH)
#define GET_TTBR1_ORGN(b, c)	GET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_ORGN)
#define GET_TTBR1_NOS(b, c)	GET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_NOS)
#define GET_TTBR1_IRGNL(b, c)	GET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_IRGNL)
#define GET_TTBR1_PA(b, c)	GET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_PA)


/* V2PSR */
#define GET_HIT(b, c)		GET_CONTEXT_FIELD(b, c, V2PSR, HIT)
#define GET_INDEX(b, c)		GET_CONTEXT_FIELD(b, c, V2PSR, INDEX)


/* V2Pxx UW UR PW PR */
#define GET_V2PUW_INDEX(b, c)	GET_CONTEXT_FIELD(b, c, V2PUW, V2Pxx_INDEX)
#define GET_V2PUW_VA(b, c)	GET_CONTEXT_FIELD(b, c, V2PUW, V2Pxx_VA)

#define GET_V2PUR_INDEX(b, c)	GET_CONTEXT_FIELD(b, c, V2PUR, V2Pxx_INDEX)
#define GET_V2PUR_VA(b, c)	GET_CONTEXT_FIELD(b, c, V2PUR, V2Pxx_VA)

#define GET_V2PPW_INDEX(b, c)	GET_CONTEXT_FIELD(b, c, V2PPW, V2Pxx_INDEX)
#define GET_V2PPW_VA(b, c)	GET_CONTEXT_FIELD(b, c, V2PPW, V2Pxx_VA)

#define GET_V2PPR_INDEX(b, c)	GET_CONTEXT_FIELD(b, c, V2PPR, V2Pxx_INDEX)
#define GET_V2PPR_VA(b, c)	GET_CONTEXT_FIELD(b, c, V2PPR, V2Pxx_VA)


/* Global Registers */
#define M2VCBR_N	(0xFF000)
#define CBACR_N		(0xFF800)
#define TLBRSW		(0xFFE00)
#define TLBTR0		(0xFFE80)
#define TLBTR1		(0xFFE84)
#define TLBTR2		(0xFFE88)
#define TESTBUSCR	(0xFFE8C)
#define GLOBAL_TLBIALL	(0xFFF00)
#define TLBIVMID	(0xFFF04)
#define CR		(0xFFF80)
#define EAR		(0xFFF84)
#define ESR		(0xFFF88)
#define ESRRESTORE	(0xFFF8C)
#define ESYNR0		(0xFFF90)
#define ESYNR1		(0xFFF94)
#define REV		(0xFFFF4)
#define IDR		(0xFFFF8)
#define RPU_ACR		(0xFFFFC)


/* Context Bank Registers */
#define SCTLR		(0x000)
#define ACTLR		(0x004)
#define CONTEXTIDR	(0x008)
#define TTBR0		(0x010)
#define TTBR1		(0x014)
#define TTBCR		(0x018)
#define PAR		(0x01C)
#define FSR		(0x020)
#define FSRRESTORE	(0x024)
#define FAR		(0x028)
#define FSYNR0		(0x02C)
#define FSYNR1		(0x030)
#define PRRR		(0x034)
#define NMRR		(0x038)
#define TLBLCKR		(0x03C)
#define V2PSR		(0x040)
#define TLBFLPTER	(0x044)
#define TLBSLPTER	(0x048)
#define BFBCR		(0x04C)
#define CTX_TLBIALL	(0x800)
#define TLBIASID	(0x804)
#define TLBIVA		(0x808)
#define TLBIVAA		(0x80C)
#define V2PPR		(0x810)
#define V2PPW		(0x814)
#define V2PUR		(0x818)
#define V2PUW		(0x81C)
#define RESUME		(0x820)


/* Global Register Fields */
/* CBACRn */
#define RWVMID        (RWVMID_MASK       << RWVMID_SHIFT)
#define RWE           (RWE_MASK          << RWE_SHIFT)
#define RWGE          (RWGE_MASK         << RWGE_SHIFT)
#define CBVMID        (CBVMID_MASK       << CBVMID_SHIFT)
#define IRPTNDX       (IRPTNDX_MASK      << IRPTNDX_SHIFT)


/* CR */
#define RPUE          (RPUE_MASK          << RPUE_SHIFT)
#define RPUERE        (RPUERE_MASK        << RPUERE_SHIFT)
#define RPUEIE        (RPUEIE_MASK        << RPUEIE_SHIFT)
#define DCDEE         (DCDEE_MASK         << DCDEE_SHIFT)
#define CLIENTPD      (CLIENTPD_MASK      << CLIENTPD_SHIFT)
#define STALLD        (STALLD_MASK        << STALLD_SHIFT)
#define TLBLKCRWE     (TLBLKCRWE_MASK     << TLBLKCRWE_SHIFT)
#define CR_TLBIALLCFG (CR_TLBIALLCFG_MASK << CR_TLBIALLCFG_SHIFT)
#define TLBIVMIDCFG   (TLBIVMIDCFG_MASK   << TLBIVMIDCFG_SHIFT)
#define CR_HUME       (CR_HUME_MASK       << CR_HUME_SHIFT)


/* ESR */
#define CFG           (CFG_MASK          << CFG_SHIFT)
#define BYPASS        (BYPASS_MASK       << BYPASS_SHIFT)
#define ESR_MULTI     (ESR_MULTI_MASK    << ESR_MULTI_SHIFT)


/* ESYNR0 */
#define ESYNR0_AMID   (ESYNR0_AMID_MASK  << ESYNR0_AMID_SHIFT)
#define ESYNR0_APID   (ESYNR0_APID_MASK  << ESYNR0_APID_SHIFT)
#define ESYNR0_ABID   (ESYNR0_ABID_MASK  << ESYNR0_ABID_SHIFT)
#define ESYNR0_AVMID  (ESYNR0_AVMID_MASK << ESYNR0_AVMID_SHIFT)
#define ESYNR0_ATID   (ESYNR0_ATID_MASK  << ESYNR0_ATID_SHIFT)


/* ESYNR1 */
#define ESYNR1_AMEMTYPE      (ESYNR1_AMEMTYPE_MASK    << ESYNR1_AMEMTYPE_SHIFT)
#define ESYNR1_ASHARED       (ESYNR1_ASHARED_MASK     << ESYNR1_ASHARED_SHIFT)
#define ESYNR1_AINNERSHARED  (ESYNR1_AINNERSHARED_MASK<< \
						ESYNR1_AINNERSHARED_SHIFT)
#define ESYNR1_APRIV         (ESYNR1_APRIV_MASK       << ESYNR1_APRIV_SHIFT)
#define ESYNR1_APROTNS       (ESYNR1_APROTNS_MASK     << ESYNR1_APROTNS_SHIFT)
#define ESYNR1_AINST         (ESYNR1_AINST_MASK       << ESYNR1_AINST_SHIFT)
#define ESYNR1_AWRITE        (ESYNR1_AWRITE_MASK      << ESYNR1_AWRITE_SHIFT)
#define ESYNR1_ABURST        (ESYNR1_ABURST_MASK      << ESYNR1_ABURST_SHIFT)
#define ESYNR1_ALEN          (ESYNR1_ALEN_MASK        << ESYNR1_ALEN_SHIFT)
#define ESYNR1_ASIZE         (ESYNR1_ASIZE_MASK       << ESYNR1_ASIZE_SHIFT)
#define ESYNR1_ALOCK         (ESYNR1_ALOCK_MASK       << ESYNR1_ALOCK_SHIFT)
#define ESYNR1_AOOO          (ESYNR1_AOOO_MASK        << ESYNR1_AOOO_SHIFT)
#define ESYNR1_AFULL         (ESYNR1_AFULL_MASK       << ESYNR1_AFULL_SHIFT)
#define ESYNR1_AC            (ESYNR1_AC_MASK          << ESYNR1_AC_SHIFT)
#define ESYNR1_DCD           (ESYNR1_DCD_MASK         << ESYNR1_DCD_SHIFT)


/* IDR */
#define NM2VCBMT      (NM2VCBMT_MASK     << NM2VCBMT_SHIFT)
#define HTW           (HTW_MASK          << HTW_SHIFT)
#define HUM           (HUM_MASK          << HUM_SHIFT)
#define TLBSIZE       (TLBSIZE_MASK      << TLBSIZE_SHIFT)
#define NCB           (NCB_MASK          << NCB_SHIFT)
#define NIRPT         (NIRPT_MASK        << NIRPT_SHIFT)


/* M2VCBRn */
#define VMID          (VMID_MASK         << VMID_SHIFT)
#define CBNDX         (CBNDX_MASK        << CBNDX_SHIFT)
#define BYPASSD       (BYPASSD_MASK      << BYPASSD_SHIFT)
#define BPRCOSH       (BPRCOSH_MASK      << BPRCOSH_SHIFT)
#define BPRCISH       (BPRCISH_MASK      << BPRCISH_SHIFT)
#define BPRCNSH       (BPRCNSH_MASK      << BPRCNSH_SHIFT)
#define BPSHCFG       (BPSHCFG_MASK      << BPSHCFG_SHIFT)
#define NSCFG         (NSCFG_MASK        << NSCFG_SHIFT)
#define BPMTCFG       (BPMTCFG_MASK      << BPMTCFG_SHIFT)
#define BPMEMTYPE     (BPMEMTYPE_MASK    << BPMEMTYPE_SHIFT)


/* REV */
#define IDR_MINOR     (MINOR_MASK        << MINOR_SHIFT)
#define IDR_MAJOR     (MAJOR_MASK        << MAJOR_SHIFT)


/* TESTBUSCR */
#define TBE           (TBE_MASK          << TBE_SHIFT)
#define SPDMBE        (SPDMBE_MASK       << SPDMBE_SHIFT)
#define WGSEL         (WGSEL_MASK        << WGSEL_SHIFT)
#define TBLSEL        (TBLSEL_MASK       << TBLSEL_SHIFT)
#define TBHSEL        (TBHSEL_MASK       << TBHSEL_SHIFT)
#define SPDM0SEL      (SPDM0SEL_MASK     << SPDM0SEL_SHIFT)
#define SPDM1SEL      (SPDM1SEL_MASK     << SPDM1SEL_SHIFT)
#define SPDM2SEL      (SPDM2SEL_MASK     << SPDM2SEL_SHIFT)
#define SPDM3SEL      (SPDM3SEL_MASK     << SPDM3SEL_SHIFT)


/* TLBIVMID */
#define TLBIVMID_VMID (TLBIVMID_VMID_MASK << TLBIVMID_VMID_SHIFT)


/* TLBRSW */
#define TLBRSW_INDEX  (TLBRSW_INDEX_MASK << TLBRSW_INDEX_SHIFT)
#define TLBBFBS       (TLBBFBS_MASK      << TLBBFBS_SHIFT)


/* TLBTR0 */
#define PR            (PR_MASK           << PR_SHIFT)
#define PW            (PW_MASK           << PW_SHIFT)
#define UR            (UR_MASK           << UR_SHIFT)
#define UW            (UW_MASK           << UW_SHIFT)
#define XN            (XN_MASK           << XN_SHIFT)
#define NSDESC        (NSDESC_MASK       << NSDESC_SHIFT)
#define ISH           (ISH_MASK          << ISH_SHIFT)
#define SH            (SH_MASK           << SH_SHIFT)
#define MT            (MT_MASK           << MT_SHIFT)
#define DPSIZR        (DPSIZR_MASK       << DPSIZR_SHIFT)
#define DPSIZC        (DPSIZC_MASK       << DPSIZC_SHIFT)


/* TLBTR1 */
#define TLBTR1_VMID   (TLBTR1_VMID_MASK  << TLBTR1_VMID_SHIFT)
#define TLBTR1_PA     (TLBTR1_PA_MASK    << TLBTR1_PA_SHIFT)


/* TLBTR2 */
#define TLBTR2_ASID   (TLBTR2_ASID_MASK  << TLBTR2_ASID_SHIFT)
#define TLBTR2_V      (TLBTR2_V_MASK     << TLBTR2_V_SHIFT)
#define TLBTR2_NSTID  (TLBTR2_NSTID_MASK << TLBTR2_NSTID_SHIFT)
#define TLBTR2_NV     (TLBTR2_NV_MASK    << TLBTR2_NV_SHIFT)
#define TLBTR2_VA     (TLBTR2_VA_MASK    << TLBTR2_VA_SHIFT)


/* Context Register Fields */
/* ACTLR */
#define CFERE              (CFERE_MASK              << CFERE_SHIFT)
#define CFEIE              (CFEIE_MASK              << CFEIE_SHIFT)
#define PTSHCFG            (PTSHCFG_MASK            << PTSHCFG_SHIFT)
#define RCOSH              (RCOSH_MASK              << RCOSH_SHIFT)
#define RCISH              (RCISH_MASK              << RCISH_SHIFT)
#define RCNSH              (RCNSH_MASK              << RCNSH_SHIFT)
#define PRIVCFG            (PRIVCFG_MASK            << PRIVCFG_SHIFT)
#define DNA                (DNA_MASK                << DNA_SHIFT)
#define DNLV2PA            (DNLV2PA_MASK            << DNLV2PA_SHIFT)
#define TLBMCFG            (TLBMCFG_MASK            << TLBMCFG_SHIFT)
#define CFCFG              (CFCFG_MASK              << CFCFG_SHIFT)
#define TIPCF              (TIPCF_MASK              << TIPCF_SHIFT)
#define V2PCFG             (V2PCFG_MASK             << V2PCFG_SHIFT)
#define HUME               (HUME_MASK               << HUME_SHIFT)
#define PTMTCFG            (PTMTCFG_MASK            << PTMTCFG_SHIFT)
#define PTMEMTYPE          (PTMEMTYPE_MASK          << PTMEMTYPE_SHIFT)


/* BFBCR */
#define BFBDFE             (BFBDFE_MASK             << BFBDFE_SHIFT)
#define BFBSFE             (BFBSFE_MASK             << BFBSFE_SHIFT)
#define SFVS               (SFVS_MASK               << SFVS_SHIFT)
#define FLVIC              (FLVIC_MASK              << FLVIC_SHIFT)
#define SLVIC              (SLVIC_MASK              << SLVIC_SHIFT)


/* CONTEXTIDR */
#define CONTEXTIDR_ASID    (CONTEXTIDR_ASID_MASK    << CONTEXTIDR_ASID_SHIFT)
#define PROCID             (PROCID_MASK             << PROCID_SHIFT)


/* FSR */
#define TF                 (TF_MASK                 << TF_SHIFT)
#define AFF                (AFF_MASK                << AFF_SHIFT)
#define APF                (APF_MASK                << APF_SHIFT)
#define TLBMF              (TLBMF_MASK              << TLBMF_SHIFT)
#define HTWDEEF            (HTWDEEF_MASK            << HTWDEEF_SHIFT)
#define HTWSEEF            (HTWSEEF_MASK            << HTWSEEF_SHIFT)
#define MHF                (MHF_MASK                << MHF_SHIFT)
#define SL                 (SL_MASK                 << SL_SHIFT)
#define SS                 (SS_MASK                 << SS_SHIFT)
#define MULTI              (MULTI_MASK              << MULTI_SHIFT)


/* FSYNR0 */
#define AMID               (AMID_MASK               << AMID_SHIFT)
#define APID               (APID_MASK               << APID_SHIFT)
#define ABID               (ABID_MASK               << ABID_SHIFT)
#define ATID               (ATID_MASK               << ATID_SHIFT)


/* FSYNR1 */
#define AMEMTYPE           (AMEMTYPE_MASK           << AMEMTYPE_SHIFT)
#define ASHARED            (ASHARED_MASK            << ASHARED_SHIFT)
#define AINNERSHARED       (AINNERSHARED_MASK       << AINNERSHARED_SHIFT)
#define APRIV              (APRIV_MASK              << APRIV_SHIFT)
#define APROTNS            (APROTNS_MASK            << APROTNS_SHIFT)
#define AINST              (AINST_MASK              << AINST_SHIFT)
#define AWRITE             (AWRITE_MASK             << AWRITE_SHIFT)
#define ABURST             (ABURST_MASK             << ABURST_SHIFT)
#define ALEN               (ALEN_MASK               << ALEN_SHIFT)
#define FSYNR1_ASIZE       (FSYNR1_ASIZE_MASK       << FSYNR1_ASIZE_SHIFT)
#define ALOCK              (ALOCK_MASK              << ALOCK_SHIFT)
#define AFULL              (AFULL_MASK              << AFULL_SHIFT)


/* NMRR */
#define ICPC0              (ICPC0_MASK              << ICPC0_SHIFT)
#define ICPC1              (ICPC1_MASK              << ICPC1_SHIFT)
#define ICPC2              (ICPC2_MASK              << ICPC2_SHIFT)
#define ICPC3              (ICPC3_MASK              << ICPC3_SHIFT)
#define ICPC4              (ICPC4_MASK              << ICPC4_SHIFT)
#define ICPC5              (ICPC5_MASK              << ICPC5_SHIFT)
#define ICPC6              (ICPC6_MASK              << ICPC6_SHIFT)
#define ICPC7              (ICPC7_MASK              << ICPC7_SHIFT)
#define OCPC0              (OCPC0_MASK              << OCPC0_SHIFT)
#define OCPC1              (OCPC1_MASK              << OCPC1_SHIFT)
#define OCPC2              (OCPC2_MASK              << OCPC2_SHIFT)
#define OCPC3              (OCPC3_MASK              << OCPC3_SHIFT)
#define OCPC4              (OCPC4_MASK              << OCPC4_SHIFT)
#define OCPC5              (OCPC5_MASK              << OCPC5_SHIFT)
#define OCPC6              (OCPC6_MASK              << OCPC6_SHIFT)
#define OCPC7              (OCPC7_MASK              << OCPC7_SHIFT)


/* PAR */
#define FAULT              (FAULT_MASK              << FAULT_SHIFT)
/* If a fault is present, these are the
same as the fault fields in the FAR */
#define FAULT_TF           (FAULT_TF_MASK           << FAULT_TF_SHIFT)
#define FAULT_AFF          (FAULT_AFF_MASK          << FAULT_AFF_SHIFT)
#define FAULT_APF          (FAULT_APF_MASK          << FAULT_APF_SHIFT)
#define FAULT_TLBMF        (FAULT_TLBMF_MASK        << FAULT_TLBMF_SHIFT)
#define FAULT_HTWDEEF      (FAULT_HTWDEEF_MASK      << FAULT_HTWDEEF_SHIFT)
#define FAULT_HTWSEEF      (FAULT_HTWSEEF_MASK      << FAULT_HTWSEEF_SHIFT)
#define FAULT_MHF          (FAULT_MHF_MASK          << FAULT_MHF_SHIFT)
#define FAULT_SL           (FAULT_SL_MASK           << FAULT_SL_SHIFT)
#define FAULT_SS           (FAULT_SS_MASK           << FAULT_SS_SHIFT)

/* If NO fault is present, the following fields are in effect */
/* (FAULT remains as before) */
#define PAR_NOFAULT_SS     (PAR_NOFAULT_SS_MASK     << PAR_NOFAULT_SS_SHIFT)
#define PAR_NOFAULT_MT     (PAR_NOFAULT_MT_MASK     << PAR_NOFAULT_MT_SHIFT)
#define PAR_NOFAULT_SH     (PAR_NOFAULT_SH_MASK     << PAR_NOFAULT_SH_SHIFT)
#define PAR_NOFAULT_NS     (PAR_NOFAULT_NS_MASK     << PAR_NOFAULT_NS_SHIFT)
#define PAR_NOFAULT_NOS    (PAR_NOFAULT_NOS_MASK    << PAR_NOFAULT_NOS_SHIFT)
#define PAR_NPFAULT_PA     (PAR_NPFAULT_PA_MASK     << PAR_NPFAULT_PA_SHIFT)


/* PRRR */
#define MTC0               (MTC0_MASK               << MTC0_SHIFT)
#define MTC1               (MTC1_MASK               << MTC1_SHIFT)
#define MTC2               (MTC2_MASK               << MTC2_SHIFT)
#define MTC3               (MTC3_MASK               << MTC3_SHIFT)
#define MTC4               (MTC4_MASK               << MTC4_SHIFT)
#define MTC5               (MTC5_MASK               << MTC5_SHIFT)
#define MTC6               (MTC6_MASK               << MTC6_SHIFT)
#define MTC7               (MTC7_MASK               << MTC7_SHIFT)
#define SHDSH0             (SHDSH0_MASK             << SHDSH0_SHIFT)
#define SHDSH1             (SHDSH1_MASK             << SHDSH1_SHIFT)
#define SHNMSH0            (SHNMSH0_MASK            << SHNMSH0_SHIFT)
#define SHNMSH1            (SHNMSH1_MASK            << SHNMSH1_SHIFT)
#define NOS0               (NOS0_MASK               << NOS0_SHIFT)
#define NOS1               (NOS1_MASK               << NOS1_SHIFT)
#define NOS2               (NOS2_MASK               << NOS2_SHIFT)
#define NOS3               (NOS3_MASK               << NOS3_SHIFT)
#define NOS4               (NOS4_MASK               << NOS4_SHIFT)
#define NOS5               (NOS5_MASK               << NOS5_SHIFT)
#define NOS6               (NOS6_MASK               << NOS6_SHIFT)
#define NOS7               (NOS7_MASK               << NOS7_SHIFT)


/* RESUME */
#define TNR                (TNR_MASK                << TNR_SHIFT)


/* SCTLR */
#define M                  (M_MASK                  << M_SHIFT)
#define TRE                (TRE_MASK                << TRE_SHIFT)
#define AFE                (AFE_MASK                << AFE_SHIFT)
#define HAF                (HAF_MASK                << HAF_SHIFT)
#define BE                 (BE_MASK                 << BE_SHIFT)
#define AFFD               (AFFD_MASK               << AFFD_SHIFT)


/* TLBIASID */
#define TLBIASID_ASID      (TLBIASID_ASID_MASK      << TLBIASID_ASID_SHIFT)


/* TLBIVA */
#define TLBIVA_ASID        (TLBIVA_ASID_MASK        << TLBIVA_ASID_SHIFT)
#define TLBIVA_VA          (TLBIVA_VA_MASK          << TLBIVA_VA_SHIFT)


/* TLBIVAA */
#define TLBIVAA_VA         (TLBIVAA_VA_MASK         << TLBIVAA_VA_SHIFT)


/* TLBLCKR */
#define LKE                (LKE_MASK                << LKE_SHIFT)
#define TLBLCKR_TLBIALLCFG (TLBLCKR_TLBIALLCFG_MASK<<TLBLCKR_TLBIALLCFG_SHIFT)
#define TLBIASIDCFG        (TLBIASIDCFG_MASK        << TLBIASIDCFG_SHIFT)
#define TLBIVAACFG         (TLBIVAACFG_MASK         << TLBIVAACFG_SHIFT)
#define FLOOR              (FLOOR_MASK              << FLOOR_SHIFT)
#define VICTIM             (VICTIM_MASK             << VICTIM_SHIFT)


/* TTBCR */
#define N                  (N_MASK                  << N_SHIFT)
#define PD0                (PD0_MASK                << PD0_SHIFT)
#define PD1                (PD1_MASK                << PD1_SHIFT)


/* TTBR0 */
#define TTBR0_IRGNH        (TTBR0_IRGNH_MASK        << TTBR0_IRGNH_SHIFT)
#define TTBR0_SH           (TTBR0_SH_MASK           << TTBR0_SH_SHIFT)
#define TTBR0_ORGN         (TTBR0_ORGN_MASK         << TTBR0_ORGN_SHIFT)
#define TTBR0_NOS          (TTBR0_NOS_MASK          << TTBR0_NOS_SHIFT)
#define TTBR0_IRGNL        (TTBR0_IRGNL_MASK        << TTBR0_IRGNL_SHIFT)
#define TTBR0_PA           (TTBR0_PA_MASK           << TTBR0_PA_SHIFT)


/* TTBR1 */
#define TTBR1_IRGNH        (TTBR1_IRGNH_MASK        << TTBR1_IRGNH_SHIFT)
#define TTBR1_SH           (TTBR1_SH_MASK           << TTBR1_SH_SHIFT)
#define TTBR1_ORGN         (TTBR1_ORGN_MASK         << TTBR1_ORGN_SHIFT)
#define TTBR1_NOS          (TTBR1_NOS_MASK          << TTBR1_NOS_SHIFT)
#define TTBR1_IRGNL        (TTBR1_IRGNL_MASK        << TTBR1_IRGNL_SHIFT)
#define TTBR1_PA           (TTBR1_PA_MASK           << TTBR1_PA_SHIFT)


/* V2PSR */
#define HIT                (HIT_MASK                << HIT_SHIFT)
#define INDEX              (INDEX_MASK              << INDEX_SHIFT)


/* V2Pxx */
#define V2Pxx_INDEX        (V2Pxx_INDEX_MASK        << V2Pxx_INDEX_SHIFT)
#define V2Pxx_VA           (V2Pxx_VA_MASK           << V2Pxx_VA_SHIFT)


/* Global Register Masks */
/* CBACRn */
#define RWVMID_MASK               0x1F
#define RWE_MASK                  0x01
#define RWGE_MASK                 0x01
#define CBVMID_MASK               0x1F
#define IRPTNDX_MASK              0xFF


/* CR */
#define RPUE_MASK                 0x01
#define RPUERE_MASK               0x01
#define RPUEIE_MASK               0x01
#define DCDEE_MASK                0x01
#define CLIENTPD_MASK             0x01
#define STALLD_MASK               0x01
#define TLBLKCRWE_MASK            0x01
#define CR_TLBIALLCFG_MASK        0x01
#define TLBIVMIDCFG_MASK          0x01
#define CR_HUME_MASK              0x01


/* ESR */
#define CFG_MASK                  0x01
#define BYPASS_MASK               0x01
#define ESR_MULTI_MASK            0x01


/* ESYNR0 */
#define ESYNR0_AMID_MASK          0xFF
#define ESYNR0_APID_MASK          0x1F
#define ESYNR0_ABID_MASK          0x07
#define ESYNR0_AVMID_MASK         0x1F
#define ESYNR0_ATID_MASK          0xFF


/* ESYNR1 */
#define ESYNR1_AMEMTYPE_MASK             0x07
#define ESYNR1_ASHARED_MASK              0x01
#define ESYNR1_AINNERSHARED_MASK         0x01
#define ESYNR1_APRIV_MASK                0x01
#define ESYNR1_APROTNS_MASK              0x01
#define ESYNR1_AINST_MASK                0x01
#define ESYNR1_AWRITE_MASK               0x01
#define ESYNR1_ABURST_MASK               0x01
#define ESYNR1_ALEN_MASK                 0x0F
#define ESYNR1_ASIZE_MASK                0x01
#define ESYNR1_ALOCK_MASK                0x03
#define ESYNR1_AOOO_MASK                 0x01
#define ESYNR1_AFULL_MASK                0x01
#define ESYNR1_AC_MASK                   0x01
#define ESYNR1_DCD_MASK                  0x01


/* IDR */
#define NM2VCBMT_MASK             0x1FF
#define HTW_MASK                  0x01
#define HUM_MASK                  0x01
#define TLBSIZE_MASK              0x0F
#define NCB_MASK                  0xFF
#define NIRPT_MASK                0xFF


/* M2VCBRn */
#define VMID_MASK                 0x1F
#define CBNDX_MASK                0xFF
#define BYPASSD_MASK              0x01
#define BPRCOSH_MASK              0x01
#define BPRCISH_MASK              0x01
#define BPRCNSH_MASK              0x01
#define BPSHCFG_MASK              0x03
#define NSCFG_MASK                0x03
#define BPMTCFG_MASK              0x01
#define BPMEMTYPE_MASK            0x07


/* REV */
#define MINOR_MASK                0x0F
#define MAJOR_MASK                0x0F


/* TESTBUSCR */
#define TBE_MASK                  0x01
#define SPDMBE_MASK               0x01
#define WGSEL_MASK                0x03
#define TBLSEL_MASK               0x03
#define TBHSEL_MASK               0x03
#define SPDM0SEL_MASK             0x0F
#define SPDM1SEL_MASK             0x0F
#define SPDM2SEL_MASK             0x0F
#define SPDM3SEL_MASK             0x0F


/* TLBIMID */
#define TLBIVMID_VMID_MASK        0x1F


/* TLBRSW */
#define TLBRSW_INDEX_MASK         0xFF
#define TLBBFBS_MASK              0x03


/* TLBTR0 */
#define PR_MASK                   0x01
#define PW_MASK                   0x01
#define UR_MASK                   0x01
#define UW_MASK                   0x01
#define XN_MASK                   0x01
#define NSDESC_MASK               0x01
#define ISH_MASK                  0x01
#define SH_MASK                   0x01
#define MT_MASK                   0x07
#define DPSIZR_MASK               0x07
#define DPSIZC_MASK               0x07


/* TLBTR1 */
#define TLBTR1_VMID_MASK          0x1F
#define TLBTR1_PA_MASK            0x000FFFFF


/* TLBTR2 */
#define TLBTR2_ASID_MASK          0xFF
#define TLBTR2_V_MASK             0x01
#define TLBTR2_NSTID_MASK         0x01
#define TLBTR2_NV_MASK            0x01
#define TLBTR2_VA_MASK            0x000FFFFF


/* Global Register Shifts */
/* CBACRn */
#define RWVMID_SHIFT             0
#define RWE_SHIFT                8
#define RWGE_SHIFT               9
#define CBVMID_SHIFT             16
#define IRPTNDX_SHIFT            24


/* CR */
#define RPUE_SHIFT               0
#define RPUERE_SHIFT             1
#define RPUEIE_SHIFT             2
#define DCDEE_SHIFT              3
#define CLIENTPD_SHIFT           4
#define STALLD_SHIFT             5
#define TLBLKCRWE_SHIFT          6
#define CR_TLBIALLCFG_SHIFT      7
#define TLBIVMIDCFG_SHIFT        8
#define CR_HUME_SHIFT            9


/* ESR */
#define CFG_SHIFT                0
#define BYPASS_SHIFT             1
#define ESR_MULTI_SHIFT          31


/* ESYNR0 */
#define ESYNR0_AMID_SHIFT        0
#define ESYNR0_APID_SHIFT        8
#define ESYNR0_ABID_SHIFT        13
#define ESYNR0_AVMID_SHIFT       16
#define ESYNR0_ATID_SHIFT        24


/* ESYNR1 */
#define ESYNR1_AMEMTYPE_SHIFT           0
#define ESYNR1_ASHARED_SHIFT            3
#define ESYNR1_AINNERSHARED_SHIFT       4
#define ESYNR1_APRIV_SHIFT              5
#define ESYNR1_APROTNS_SHIFT            6
#define ESYNR1_AINST_SHIFT              7
#define ESYNR1_AWRITE_SHIFT             8
#define ESYNR1_ABURST_SHIFT             10
#define ESYNR1_ALEN_SHIFT               12
#define ESYNR1_ASIZE_SHIFT              16
#define ESYNR1_ALOCK_SHIFT              20
#define ESYNR1_AOOO_SHIFT               22
#define ESYNR1_AFULL_SHIFT              24
#define ESYNR1_AC_SHIFT                 30
#define ESYNR1_DCD_SHIFT                31


/* IDR */
#define NM2VCBMT_SHIFT           0
#define HTW_SHIFT                9
#define HUM_SHIFT                10
#define TLBSIZE_SHIFT            12
#define NCB_SHIFT                16
#define NIRPT_SHIFT              24


/* M2VCBRn */
#define VMID_SHIFT               0
#define CBNDX_SHIFT              8
#define BYPASSD_SHIFT            16
#define BPRCOSH_SHIFT            17
#define BPRCISH_SHIFT            18
#define BPRCNSH_SHIFT            19
#define BPSHCFG_SHIFT            20
#define NSCFG_SHIFT              22
#define BPMTCFG_SHIFT            24
#define BPMEMTYPE_SHIFT          25


/* REV */
#define MINOR_SHIFT              0
#define MAJOR_SHIFT              4


/* TESTBUSCR */
#define TBE_SHIFT                0
#define SPDMBE_SHIFT             1
#define WGSEL_SHIFT              8
#define TBLSEL_SHIFT             12
#define TBHSEL_SHIFT             14
#define SPDM0SEL_SHIFT           16
#define SPDM1SEL_SHIFT           20
#define SPDM2SEL_SHIFT           24
#define SPDM3SEL_SHIFT           28


/* TLBIMID */
#define TLBIVMID_VMID_SHIFT      0


/* TLBRSW */
#define TLBRSW_INDEX_SHIFT       0
#define TLBBFBS_SHIFT            8


/* TLBTR0 */
#define PR_SHIFT                 0
#define PW_SHIFT                 1
#define UR_SHIFT                 2
#define UW_SHIFT                 3
#define XN_SHIFT                 4
#define NSDESC_SHIFT             6
#define ISH_SHIFT                7
#define SH_SHIFT                 8
#define MT_SHIFT                 9
#define DPSIZR_SHIFT             16
#define DPSIZC_SHIFT             20


/* TLBTR1 */
#define TLBTR1_VMID_SHIFT        0
#define TLBTR1_PA_SHIFT          12


/* TLBTR2 */
#define TLBTR2_ASID_SHIFT        0
#define TLBTR2_V_SHIFT           8
#define TLBTR2_NSTID_SHIFT       9
#define TLBTR2_NV_SHIFT          10
#define TLBTR2_VA_SHIFT          12


/* Context Register Masks */
/* ACTLR */
#define CFERE_MASK                       0x01
#define CFEIE_MASK                       0x01
#define PTSHCFG_MASK                     0x03
#define RCOSH_MASK                       0x01
#define RCISH_MASK                       0x01
#define RCNSH_MASK                       0x01
#define PRIVCFG_MASK                     0x03
#define DNA_MASK                         0x01
#define DNLV2PA_MASK                     0x01
#define TLBMCFG_MASK                     0x03
#define CFCFG_MASK                       0x01
#define TIPCF_MASK                       0x01
#define V2PCFG_MASK                      0x03
#define HUME_MASK                        0x01
#define PTMTCFG_MASK                     0x01
#define PTMEMTYPE_MASK                   0x07


/* BFBCR */
#define BFBDFE_MASK                      0x01
#define BFBSFE_MASK                      0x01
#define SFVS_MASK                        0x01
#define FLVIC_MASK                       0x0F
#define SLVIC_MASK                       0x0F


/* CONTEXTIDR */
#define CONTEXTIDR_ASID_MASK             0xFF
#define PROCID_MASK                      0x00FFFFFF


/* FSR */
#define TF_MASK                          0x01
#define AFF_MASK                         0x01
#define APF_MASK                         0x01
#define TLBMF_MASK                       0x01
#define HTWDEEF_MASK                     0x01
#define HTWSEEF_MASK                     0x01
#define MHF_MASK                         0x01
#define SL_MASK                          0x01
#define SS_MASK                          0x01
#define MULTI_MASK                       0x01


/* FSYNR0 */
#define AMID_MASK                        0xFF
#define APID_MASK                        0x1F
#define ABID_MASK                        0x07
#define ATID_MASK                        0xFF


/* FSYNR1 */
#define AMEMTYPE_MASK                    0x07
#define ASHARED_MASK                     0x01
#define AINNERSHARED_MASK                0x01
#define APRIV_MASK                       0x01
#define APROTNS_MASK                     0x01
#define AINST_MASK                       0x01
#define AWRITE_MASK                      0x01
#define ABURST_MASK                      0x01
#define ALEN_MASK                        0x0F
#define FSYNR1_ASIZE_MASK                0x07
#define ALOCK_MASK                       0x03
#define AFULL_MASK                       0x01


/* NMRR */
#define ICPC0_MASK                       0x03
#define ICPC1_MASK                       0x03
#define ICPC2_MASK                       0x03
#define ICPC3_MASK                       0x03
#define ICPC4_MASK                       0x03
#define ICPC5_MASK                       0x03
#define ICPC6_MASK                       0x03
#define ICPC7_MASK                       0x03
#define OCPC0_MASK                       0x03
#define OCPC1_MASK                       0x03
#define OCPC2_MASK                       0x03
#define OCPC3_MASK                       0x03
#define OCPC4_MASK                       0x03
#define OCPC5_MASK                       0x03
#define OCPC6_MASK                       0x03
#define OCPC7_MASK                       0x03


/* PAR */
#define FAULT_MASK                       0x01
/* If a fault is present, these are the
same as the fault fields in the FAR */
#define FAULT_TF_MASK                    0x01
#define FAULT_AFF_MASK                   0x01
#define FAULT_APF_MASK                   0x01
#define FAULT_TLBMF_MASK                 0x01
#define FAULT_HTWDEEF_MASK               0x01
#define FAULT_HTWSEEF_MASK               0x01
#define FAULT_MHF_MASK                   0x01
#define FAULT_SL_MASK                    0x01
#define FAULT_SS_MASK                    0x01

/* If NO fault is present, the following
 * fields are in effect
 * (FAULT remains as before) */
#define PAR_NOFAULT_SS_MASK              0x01
#define PAR_NOFAULT_MT_MASK              0x07
#define PAR_NOFAULT_SH_MASK              0x01
#define PAR_NOFAULT_NS_MASK              0x01
#define PAR_NOFAULT_NOS_MASK             0x01
#define PAR_NPFAULT_PA_MASK              0x000FFFFF


/* PRRR */
#define MTC0_MASK                        0x03
#define MTC1_MASK                        0x03
#define MTC2_MASK                        0x03
#define MTC3_MASK                        0x03
#define MTC4_MASK                        0x03
#define MTC5_MASK                        0x03
#define MTC6_MASK                        0x03
#define MTC7_MASK                        0x03
#define SHDSH0_MASK                      0x01
#define SHDSH1_MASK                      0x01
#define SHNMSH0_MASK                     0x01
#define SHNMSH1_MASK                     0x01
#define NOS0_MASK                        0x01
#define NOS1_MASK                        0x01
#define NOS2_MASK                        0x01
#define NOS3_MASK                        0x01
#define NOS4_MASK                        0x01
#define NOS5_MASK                        0x01
#define NOS6_MASK                        0x01
#define NOS7_MASK                        0x01


/* RESUME */
#define TNR_MASK                         0x01


/* SCTLR */
#define M_MASK                           0x01
#define TRE_MASK                         0x01
#define AFE_MASK                         0x01
#define HAF_MASK                         0x01
#define BE_MASK                          0x01
#define AFFD_MASK                        0x01


/* TLBIASID */
#define TLBIASID_ASID_MASK               0xFF


/* TLBIVA */
#define TLBIVA_ASID_MASK                 0xFF
#define TLBIVA_VA_MASK                   0x000FFFFF


/* TLBIVAA */
#define TLBIVAA_VA_MASK                  0x000FFFFF


/* TLBLCKR */
#define LKE_MASK                         0x01
#define TLBLCKR_TLBIALLCFG_MASK          0x01
#define TLBIASIDCFG_MASK                 0x01
#define TLBIVAACFG_MASK                  0x01
#define FLOOR_MASK                       0xFF
#define VICTIM_MASK                      0xFF


/* TTBCR */
#define N_MASK                           0x07
#define PD0_MASK                         0x01
#define PD1_MASK                         0x01


/* TTBR0 */
#define TTBR0_IRGNH_MASK                 0x01
#define TTBR0_SH_MASK                    0x01
#define TTBR0_ORGN_MASK                  0x03
#define TTBR0_NOS_MASK                   0x01
#define TTBR0_IRGNL_MASK                 0x01
#define TTBR0_PA_MASK                    0x0003FFFF


/* TTBR1 */
#define TTBR1_IRGNH_MASK                 0x01
#define TTBR1_SH_MASK                    0x01
#define TTBR1_ORGN_MASK                  0x03
#define TTBR1_NOS_MASK                   0x01
#define TTBR1_IRGNL_MASK                 0x01
#define TTBR1_PA_MASK                    0x0003FFFF


/* V2PSR */
#define HIT_MASK                         0x01
#define INDEX_MASK                       0xFF


/* V2Pxx */
#define V2Pxx_INDEX_MASK                 0xFF
#define V2Pxx_VA_MASK                    0x000FFFFF


/* Context Register Shifts */
/* ACTLR */
#define CFERE_SHIFT                    0
#define CFEIE_SHIFT                    1
#define PTSHCFG_SHIFT                  2
#define RCOSH_SHIFT                    4
#define RCISH_SHIFT                    5
#define RCNSH_SHIFT                    6
#define PRIVCFG_SHIFT                  8
#define DNA_SHIFT                      10
#define DNLV2PA_SHIFT                  11
#define TLBMCFG_SHIFT                  12
#define CFCFG_SHIFT                    14
#define TIPCF_SHIFT                    15
#define V2PCFG_SHIFT                   16
#define HUME_SHIFT                     18
#define PTMTCFG_SHIFT                  20
#define PTMEMTYPE_SHIFT                21


/* BFBCR */
#define BFBDFE_SHIFT                   0
#define BFBSFE_SHIFT                   1
#define SFVS_SHIFT                     2
#define FLVIC_SHIFT                    4
#define SLVIC_SHIFT                    8


/* CONTEXTIDR */
#define CONTEXTIDR_ASID_SHIFT          0
#define PROCID_SHIFT                   8


/* FSR */
#define TF_SHIFT                       1
#define AFF_SHIFT                      2
#define APF_SHIFT                      3
#define TLBMF_SHIFT                    4
#define HTWDEEF_SHIFT                  5
#define HTWSEEF_SHIFT                  6
#define MHF_SHIFT                      7
#define SL_SHIFT                       16
#define SS_SHIFT                       30
#define MULTI_SHIFT                    31


/* FSYNR0 */
#define AMID_SHIFT                     0
#define APID_SHIFT                     8
#define ABID_SHIFT                     13
#define ATID_SHIFT                     24


/* FSYNR1 */
#define AMEMTYPE_SHIFT                 0
#define ASHARED_SHIFT                  3
#define AINNERSHARED_SHIFT             4
#define APRIV_SHIFT                    5
#define APROTNS_SHIFT                  6
#define AINST_SHIFT                    7
#define AWRITE_SHIFT                   8
#define ABURST_SHIFT                   10
#define ALEN_SHIFT                     12
#define FSYNR1_ASIZE_SHIFT             16
#define ALOCK_SHIFT                    20
#define AFULL_SHIFT                    24


/* NMRR */
#define ICPC0_SHIFT                    0
#define ICPC1_SHIFT                    2
#define ICPC2_SHIFT                    4
#define ICPC3_SHIFT                    6
#define ICPC4_SHIFT                    8
#define ICPC5_SHIFT                    10
#define ICPC6_SHIFT                    12
#define ICPC7_SHIFT                    14
#define OCPC0_SHIFT                    16
#define OCPC1_SHIFT                    18
#define OCPC2_SHIFT                    20
#define OCPC3_SHIFT                    22
#define OCPC4_SHIFT                    24
#define OCPC5_SHIFT                    26
#define OCPC6_SHIFT                    28
#define OCPC7_SHIFT                    30


/* PAR */
#define FAULT_SHIFT                    0
/* If a fault is present, these are the
same as the fault fields in the FAR */
#define FAULT_TF_SHIFT                 1
#define FAULT_AFF_SHIFT                2
#define FAULT_APF_SHIFT                3
#define FAULT_TLBMF_SHIFT              4
#define FAULT_HTWDEEF_SHIFT            5
#define FAULT_HTWSEEF_SHIFT            6
#define FAULT_MHF_SHIFT                7
#define FAULT_SL_SHIFT                 16
#define FAULT_SS_SHIFT                 30

/* If NO fault is present, the following
 * fields are in effect
 * (FAULT remains as before) */
#define PAR_NOFAULT_SS_SHIFT           1
#define PAR_NOFAULT_MT_SHIFT           4
#define PAR_NOFAULT_SH_SHIFT           7
#define PAR_NOFAULT_NS_SHIFT           9
#define PAR_NOFAULT_NOS_SHIFT          10
#define PAR_NPFAULT_PA_SHIFT           12


/* PRRR */
#define MTC0_SHIFT                     0
#define MTC1_SHIFT                     2
#define MTC2_SHIFT                     4
#define MTC3_SHIFT                     6
#define MTC4_SHIFT                     8
#define MTC5_SHIFT                     10
#define MTC6_SHIFT                     12
#define MTC7_SHIFT                     14
#define SHDSH0_SHIFT                   16
#define SHDSH1_SHIFT                   17
#define SHNMSH0_SHIFT                  18
#define SHNMSH1_SHIFT                  19
#define NOS0_SHIFT                     24
#define NOS1_SHIFT                     25
#define NOS2_SHIFT                     26
#define NOS3_SHIFT                     27
#define NOS4_SHIFT                     28
#define NOS5_SHIFT                     29
#define NOS6_SHIFT                     30
#define NOS7_SHIFT                     31


/* RESUME */
#define TNR_SHIFT                      0


/* SCTLR */
#define M_SHIFT                        0
#define TRE_SHIFT                      1
#define AFE_SHIFT                      2
#define HAF_SHIFT                      3
#define BE_SHIFT                       4
#define AFFD_SHIFT                     5


/* TLBIASID */
#define TLBIASID_ASID_SHIFT            0


/* TLBIVA */
#define TLBIVA_ASID_SHIFT              0
#define TLBIVA_VA_SHIFT                12


/* TLBIVAA */
#define TLBIVAA_VA_SHIFT               12


/* TLBLCKR */
#define LKE_SHIFT                      0
#define TLBLCKR_TLBIALLCFG_SHIFT       1
#define TLBIASIDCFG_SHIFT              2
#define TLBIVAACFG_SHIFT               3
#define FLOOR_SHIFT                    8
#define VICTIM_SHIFT                   8


/* TTBCR */
#define N_SHIFT                        3
#define PD0_SHIFT                      4
#define PD1_SHIFT                      5


/* TTBR0 */
#define TTBR0_IRGNH_SHIFT              0
#define TTBR0_SH_SHIFT                 1
#define TTBR0_ORGN_SHIFT               3
#define TTBR0_NOS_SHIFT                5
#define TTBR0_IRGNL_SHIFT              6
#define TTBR0_PA_SHIFT                 14


/* TTBR1 */
#define TTBR1_IRGNH_SHIFT              0
#define TTBR1_SH_SHIFT                 1
#define TTBR1_ORGN_SHIFT               3
#define TTBR1_NOS_SHIFT                5
#define TTBR1_IRGNL_SHIFT              6
#define TTBR1_PA_SHIFT                 14


/* V2PSR */
#define HIT_SHIFT                      0
#define INDEX_SHIFT                    8


/* V2Pxx */
#define V2Pxx_INDEX_SHIFT              0
#define V2Pxx_VA_SHIFT                 12

#endif