udb 0.1.9 → 0.1.14

data/.data/spec/std/isa/csr/I/pmpcfg10.yaml

@@ -35,23 +35,15 @@ fields:
       ! Name ! Location ! Description
 
       h! L ! 7   ! Locks the entry from further modification. Additionally, when set, PMP checks also apply to M-mode for the entry.
-      h! - ! 6:5 ! _Reserved_ Writes shall be ignored.
+      h! MT ! 6:5 ! When the `Smpmpmt` extension is implemented, MT (Memory Type) is a WARL field that overrides the memory type for accesses that match this PMP entry.  See the `Smpmpmt` extension definition for encodings.  When the `Smpmpmt` extension is not implemented, MT is _Reserved_ Writes shall be ignored.
       h! A ! 4:3
-      a! Address matching mode. One of:
+      a! Address matching mode. Encodings:
 
-          [when="PMP_GRANULARITY < 2"]
           * *OFF* (0) - Null region (disabled)
           * *TOR* (1) - Top of range
           * *NA4* (2) - Naturally aligned four-byte region
           * *NAPOT* (3) - Naturally aligned power of two
 
-          [when="PMP_GRANULARITY >= 2"]
-          * *OFF* (0) - Null region (disabled)
-          * *TOR* (1) - Top of range
-          * *NAPOT* (3) - Naturally aligned power of two
-
-      [when="PMP_GRANULARITY >= 2"]
-      Naturally aligned four-byte region, *NA4* (2), is not valid (not needed when the PMP granularity is larger than 4 bytes).
 
       h! X ! 2 ! When clear, instruction fetches cause an `Access Fault` for the matching region and privilege mode.
       h! W ! 1 ! When clear, stores and AMOs cause an `Access Fault` for the matching region and privilege mode.
@@ -60,23 +52,28 @@ fields:
 
       The combination of R = 0, W = 1 is reserved.
     type(): |
-      if (NUM_PMP_ENTRIES > 40) {
+      if (NUM_USABLE_PMP_ENTRIES > 40) {
         return CsrFieldType::RWR;
       } else {
+        # entry is either not implemented or implemented as read-only zero
         return CsrFieldType::RO;
       }
     reset_value(): |
       return 0;
     sw_write(csr_value): |
-      if ((CSR[pmpcfg10].pmp40cfg & 0x80) == 0) {
-        # entry is not locked
-        if (!(((csr_value.pmp40cfg & 0x1) == 0) && ((csr_value.pmp40cfg & 0x2) == 0x2))) {
-          # not R = 0, W =1, which is reserved
-          if ((PMP_GRANULARITY < 2) ||
-              ((csr_value.pmp40cfg & 0x18) != 0x10)) {
-            # NA4 is not allowed when PMP granularity is larger than 4 bytes
-            return csr_value.pmp40cfg;
+      if (NUM_USABLE_PMP_ENTRIES > 40 && (CSR[pmpcfg10].pmp40cfg & 0x80) == 0) {
+        # entry is usable and not locked
+        Bits<8> new_cfg = csr_value.pmp40cfg;
+        Bits<2> a_mode = (new_cfg & 0x18) >> 3;
+        if (!(((new_cfg & 0x1) == 0) && ((new_cfg & 0x2) == 0x2))) {
+          # not R = 0, W = 1, which is reserved
+          if (((a_mode == 0x1) && !PMP_TOR_SUPPORTED) ||
+              ((a_mode == 0x2) && !PMP_NA4_SUPPORTED) ||
+              ((a_mode == 0x3) && !PMP_NAPOT_SUPPORTED)) {
+            # unsupported address matching mode; keep old value
+            return CSR[pmpcfg10].pmp40cfg;
           }
+          return new_cfg;
         }
       }
       # fall through: keep old value
@@ -93,23 +90,15 @@ fields:
       ! Name ! Location ! Description
 
       h! L ! 15   ! Locks the entry from further modification. Additionally, when set, PMP checks also apply to M-mode for the entry.
-      h! - ! 14:13 ! _Reserved_ Writes shall be ignored.
+      h! MT ! 14:13 ! When the `Smpmpmt` extension is implemented, MT (Memory Type) is a WARL field that overrides the memory type for accesses that match this PMP entry.  See the `Smpmpmt` extension definition for encodings.  When the `Smpmpmt` extension is not implemented, MT is _Reserved_ Writes shall be ignored.
       h! A ! 12:11
-      a! Address matching mode. One of:
+      a! Address matching mode. Encodings:
 
-          [when="PMP_GRANULARITY < 2"]
           * *OFF* (0) - Null region (disabled)
           * *TOR* (1) - Top of range
           * *NA4* (2) - Naturally aligned four-byte region
           * *NAPOT* (3) - Naturally aligned power of two
 
-          [when="PMP_GRANULARITY >= 2"]
-          * *OFF* (0) - Null region (disabled)
-          * *TOR* (1) - Top of range
-          * *NAPOT* (3) - Naturally aligned power of two
-
-      [when="PMP_GRANULARITY >= 2"]
-      Naturally aligned four-byte region, *NA4* (2), is not valid (not needed when the PMP granularity is larger than 4 bytes).
 
       h! X ! 10 ! When clear, instruction fetches cause an `Access Fault` for the matching region and privilege mode.
       h! W ! 9 ! When clear, stores and AMOs cause an `Access Fault` for the matching region and privilege mode.
@@ -118,23 +107,28 @@ fields:
 
       The combination of R = 0, W = 1 is reserved.
     type(): |
-      if (NUM_PMP_ENTRIES > 41) {
+      if (NUM_USABLE_PMP_ENTRIES > 41) {
         return CsrFieldType::RWR;
       } else {
+        # entry is either not implemented or implemented as read-only zero
         return CsrFieldType::RO;
       }
     reset_value(): |
       return 0;
     sw_write(csr_value): |
-      if ((CSR[pmpcfg10].pmp41cfg & 0x80) == 0) {
-        # entry is not locked
-        if (!(((csr_value.pmp41cfg & 0x1) == 0) && ((csr_value.pmp41cfg & 0x2) == 0x2))) {
-          # not R = 0, W =1, which is reserved
-          if ((PMP_GRANULARITY < 2) ||
-              ((csr_value.pmp41cfg & 0x18) != 0x10)) {
-            # NA4 is not allowed when PMP granularity is larger than 4 bytes
-            return csr_value.pmp41cfg;
+      if (NUM_USABLE_PMP_ENTRIES > 41 && (CSR[pmpcfg10].pmp41cfg & 0x80) == 0) {
+        # entry is usable and not locked
+        Bits<8> new_cfg = csr_value.pmp41cfg;
+        Bits<2> a_mode = (new_cfg & 0x18) >> 3;
+        if (!(((new_cfg & 0x1) == 0) && ((new_cfg & 0x2) == 0x2))) {
+          # not R = 0, W = 1, which is reserved
+          if (((a_mode == 0x1) && !PMP_TOR_SUPPORTED) ||
+              ((a_mode == 0x2) && !PMP_NA4_SUPPORTED) ||
+              ((a_mode == 0x3) && !PMP_NAPOT_SUPPORTED)) {
+            # unsupported address matching mode; keep old value
+            return CSR[pmpcfg10].pmp41cfg;
           }
+          return new_cfg;
         }
       }
       # fall through: keep old value
@@ -151,23 +145,15 @@ fields:
       ! Name ! Location ! Description
 
       h! L ! 23   ! Locks the entry from further modification. Additionally, when set, PMP checks also apply to M-mode for the entry.
-      h! - ! 22:21 ! _Reserved_ Writes shall be ignored.
+      h! MT ! 22:21 ! When the `Smpmpmt` extension is implemented, MT (Memory Type) is a WARL field that overrides the memory type for accesses that match this PMP entry.  See the `Smpmpmt` extension definition for encodings.  When the `Smpmpmt` extension is not implemented, MT is _Reserved_ Writes shall be ignored.
       h! A ! 20:19
-      a! Address matching mode. One of:
+      a! Address matching mode. Encodings:
 
-          [when="PMP_GRANULARITY < 2"]
           * *OFF* (0) - Null region (disabled)
           * *TOR* (1) - Top of range
           * *NA4* (2) - Naturally aligned four-byte region
           * *NAPOT* (3) - Naturally aligned power of two
 
-          [when="PMP_GRANULARITY >= 2"]
-          * *OFF* (0) - Null region (disabled)
-          * *TOR* (1) - Top of range
-          * *NAPOT* (3) - Naturally aligned power of two
-
-      [when="PMP_GRANULARITY >= 2"]
-      Naturally aligned four-byte region, *NA4* (2), is not valid (not needed when the PMP granularity is larger than 4 bytes).
 
       h! X ! 18 ! When clear, instruction fetches cause an `Access Fault` for the matching region and privilege mode.
       h! W ! 17 ! When clear, stores and AMOs cause an `Access Fault` for the matching region and privilege mode.
@@ -176,23 +162,28 @@ fields:
 
       The combination of R = 0, W = 1 is reserved.
     type(): |
-      if (NUM_PMP_ENTRIES > 42) {
+      if (NUM_USABLE_PMP_ENTRIES > 42) {
         return CsrFieldType::RWR;
       } else {
+        # entry is either not implemented or implemented as read-only zero
         return CsrFieldType::RO;
       }
     reset_value(): |
       return 0;
     sw_write(csr_value): |
-      if ((CSR[pmpcfg10].pmp42cfg & 0x80) == 0) {
-        # entry is not locked
-        if (!(((csr_value.pmp42cfg & 0x1) == 0) && ((csr_value.pmp42cfg & 0x2) == 0x2))) {
-          # not R = 0, W =1, which is reserved
-          if ((PMP_GRANULARITY < 2) ||
-              ((csr_value.pmp42cfg & 0x18) != 0x10)) {
-            # NA4 is not allowed when PMP granularity is larger than 4 bytes
-            return csr_value.pmp42cfg;
+      if (NUM_USABLE_PMP_ENTRIES > 42 && (CSR[pmpcfg10].pmp42cfg & 0x80) == 0) {
+        # entry is usable and not locked
+        Bits<8> new_cfg = csr_value.pmp42cfg;
+        Bits<2> a_mode = (new_cfg & 0x18) >> 3;
+        if (!(((new_cfg & 0x1) == 0) && ((new_cfg & 0x2) == 0x2))) {
+          # not R = 0, W = 1, which is reserved
+          if (((a_mode == 0x1) && !PMP_TOR_SUPPORTED) ||
+              ((a_mode == 0x2) && !PMP_NA4_SUPPORTED) ||
+              ((a_mode == 0x3) && !PMP_NAPOT_SUPPORTED)) {
+            # unsupported address matching mode; keep old value
+            return CSR[pmpcfg10].pmp42cfg;
           }
+          return new_cfg;
         }
       }
       # fall through: keep old value
@@ -209,23 +200,15 @@ fields:
       ! Name ! Location ! Description
 
       h! L ! 31   ! Locks the entry from further modification. Additionally, when set, PMP checks also apply to M-mode for the entry.
-      h! - ! 30:29 ! _Reserved_ Writes shall be ignored.
+      h! MT ! 30:29 ! When the `Smpmpmt` extension is implemented, MT (Memory Type) is a WARL field that overrides the memory type for accesses that match this PMP entry.  See the `Smpmpmt` extension definition for encodings.  When the `Smpmpmt` extension is not implemented, MT is _Reserved_ Writes shall be ignored.
       h! A ! 28:27
-      a! Address matching mode. One of:
+      a! Address matching mode. Encodings:
 
-          [when="PMP_GRANULARITY < 2"]
           * *OFF* (0) - Null region (disabled)
           * *TOR* (1) - Top of range
           * *NA4* (2) - Naturally aligned four-byte region
           * *NAPOT* (3) - Naturally aligned power of two
 
-          [when="PMP_GRANULARITY >= 2"]
-          * *OFF* (0) - Null region (disabled)
-          * *TOR* (1) - Top of range
-          * *NAPOT* (3) - Naturally aligned power of two
-
-      [when="PMP_GRANULARITY >= 2"]
-      Naturally aligned four-byte region, *NA4* (2), is not valid (not needed when the PMP granularity is larger than 4 bytes).
 
       h! X ! 26 ! When clear, instruction fetches cause an `Access Fault` for the matching region and privilege mode.
       h! W ! 25 ! When clear, stores and AMOs cause an `Access Fault` for the matching region and privilege mode.
@@ -234,23 +217,28 @@ fields:
 
       The combination of R = 0, W = 1 is reserved.
     type(): |
-      if (NUM_PMP_ENTRIES > 43) {
+      if (NUM_USABLE_PMP_ENTRIES > 43) {
         return CsrFieldType::RWR;
       } else {
+        # entry is either not implemented or implemented as read-only zero
         return CsrFieldType::RO;
       }
     reset_value(): |
       return 0;
     sw_write(csr_value): |
-      if ((CSR[pmpcfg10].pmp43cfg & 0x80) == 0) {
-        # entry is not locked
-        if (!(((csr_value.pmp43cfg & 0x1) == 0) && ((csr_value.pmp43cfg & 0x2) == 0x2))) {
-          # not R = 0, W =1, which is reserved
-          if ((PMP_GRANULARITY < 2) ||
-              ((csr_value.pmp43cfg & 0x18) != 0x10)) {
-            # NA4 is not allowed when PMP granularity is larger than 4 bytes
-            return csr_value.pmp43cfg;
+      if (NUM_USABLE_PMP_ENTRIES > 43 && (CSR[pmpcfg10].pmp43cfg & 0x80) == 0) {
+        # entry is usable and not locked
+        Bits<8> new_cfg = csr_value.pmp43cfg;
+        Bits<2> a_mode = (new_cfg & 0x18) >> 3;
+        if (!(((new_cfg & 0x1) == 0) && ((new_cfg & 0x2) == 0x2))) {
+          # not R = 0, W = 1, which is reserved
+          if (((a_mode == 0x1) && !PMP_TOR_SUPPORTED) ||
+              ((a_mode == 0x2) && !PMP_NA4_SUPPORTED) ||
+              ((a_mode == 0x3) && !PMP_NAPOT_SUPPORTED)) {
+            # unsupported address matching mode; keep old value
+            return CSR[pmpcfg10].pmp43cfg;
           }
+          return new_cfg;
         }
       }
       # fall through: keep old value
@@ -269,23 +257,15 @@ fields:
       ! Name ! Location ! Description
 
       h! L ! 39   ! Locks the entry from further modification. Additionally, when set, PMP checks also apply to M-mode for the entry.
-      h! - ! 38:37 ! _Reserved_ Writes shall be ignored.
+      h! MT ! 38:37 ! When the `Smpmpmt` extension is implemented, MT (Memory Type) is a WARL field that overrides the memory type for accesses that match this PMP entry.  See the `Smpmpmt` extension definition for encodings.  When the `Smpmpmt` extension is not implemented, MT is _Reserved_ Writes shall be ignored.
       h! A ! 36:35
-      a! Address matching mode. One of:
+      a! Address matching mode. Encodings:
 
-          [when="PMP_GRANULARITY < 2"]
           * *OFF* (0) - Null region (disabled)
           * *TOR* (1) - Top of range
           * *NA4* (2) - Naturally aligned four-byte region
           * *NAPOT* (3) - Naturally aligned power of two
 
-          [when="PMP_GRANULARITY >= 2"]
-          * *OFF* (0) - Null region (disabled)
-          * *TOR* (1) - Top of range
-          * *NAPOT* (3) - Naturally aligned power of two
-
-      [when="PMP_GRANULARITY >= 2"]
-      Naturally aligned four-byte region, *NA4* (2), is not valid (not needed when the PMP granularity is larger than 4 bytes).
 
       h! X ! 34 ! When clear, instruction fetches cause an `Access Fault` for the matching region and privilege mode.
       h! W ! 33 ! When clear, stores and AMOs cause an `Access Fault` for the matching region and privilege mode.
@@ -294,23 +274,28 @@ fields:
 
       The combination of R = 0, W = 1 is reserved.
     type(): |
-      if (NUM_PMP_ENTRIES > 44) {
+      if (NUM_USABLE_PMP_ENTRIES > 44) {
         return CsrFieldType::RWR;
       } else {
+        # entry is either not implemented or implemented as read-only zero
         return CsrFieldType::RO;
       }
     reset_value(): |
       return 0;
     sw_write(csr_value): |
-      if ((CSR[pmpcfg10].pmp44cfg & 0x80) == 0) {
-        # entry is not locked
-        if (!(((csr_value.pmp44cfg & 0x1) == 0) && ((csr_value.pmp44cfg & 0x2) == 0x2))) {
-          # not R = 0, W =1, which is reserved
-          if ((PMP_GRANULARITY < 2) ||
-              ((csr_value.pmp44cfg & 0x18) != 0x10)) {
-            # NA4 is not allowed when PMP granularity is larger than 4 bytes
-            return csr_value.pmp44cfg;
+      if (NUM_USABLE_PMP_ENTRIES > 44 && (CSR[pmpcfg10].pmp44cfg & 0x80) == 0) {
+        # entry is usable and not locked
+        Bits<8> new_cfg = csr_value.pmp44cfg;
+        Bits<2> a_mode = (new_cfg & 0x18) >> 3;
+        if (!(((new_cfg & 0x1) == 0) && ((new_cfg & 0x2) == 0x2))) {
+          # not R = 0, W = 1, which is reserved
+          if (((a_mode == 0x1) && !PMP_TOR_SUPPORTED) ||
+              ((a_mode == 0x2) && !PMP_NA4_SUPPORTED) ||
+              ((a_mode == 0x3) && !PMP_NAPOT_SUPPORTED)) {
+            # unsupported address matching mode; keep old value
+            return CSR[pmpcfg10].pmp44cfg;
           }
+          return new_cfg;
         }
       }
       # fall through: keep old value
@@ -329,23 +314,15 @@ fields:
       ! Name ! Location ! Description
 
       h! L ! 47   ! Locks the entry from further modification. Additionally, when set, PMP checks also apply to M-mode for the entry.
-      h! - ! 46:45 ! _Reserved_ Writes shall be ignored.
+      h! MT ! 46:45 ! When the `Smpmpmt` extension is implemented, MT (Memory Type) is a WARL field that overrides the memory type for accesses that match this PMP entry.  See the `Smpmpmt` extension definition for encodings.  When the `Smpmpmt` extension is not implemented, MT is _Reserved_ Writes shall be ignored.
       h! A ! 44:43
-      a! Address matching mode. One of:
+      a! Address matching mode. Encodings:
 
-          [when="PMP_GRANULARITY < 2"]
           * *OFF* (0) - Null region (disabled)
           * *TOR* (1) - Top of range
           * *NA4* (2) - Naturally aligned four-byte region
           * *NAPOT* (3) - Naturally aligned power of two
 
-          [when="PMP_GRANULARITY >= 2"]
-          * *OFF* (0) - Null region (disabled)
-          * *TOR* (1) - Top of range
-          * *NAPOT* (3) - Naturally aligned power of two
-
-      [when="PMP_GRANULARITY >= 2"]
-      Naturally aligned four-byte region, *NA4* (2), is not valid (not needed when the PMP granularity is larger than 4 bytes).
 
       h! X ! 42 ! When clear, instruction fetches cause an `Access Fault` for the matching region and privilege mode.
       h! W ! 41 ! When clear, stores and AMOs cause an `Access Fault` for the matching region and privilege mode.
@@ -354,23 +331,28 @@ fields:
 
       The combination of R = 0, W = 1 is reserved.
     type(): |
-      if (NUM_PMP_ENTRIES > 45) {
+      if (NUM_USABLE_PMP_ENTRIES > 45) {
         return CsrFieldType::RWR;
       } else {
+        # entry is either not implemented or implemented as read-only zero
         return CsrFieldType::RO;
       }
     reset_value(): |
       return 0;
     sw_write(csr_value): |
-      if ((xlen() == 64) && (CSR[pmpcfg10].pmp45cfg & 0x80) == 0) {
-        # entry is not locked
-        if (!(((csr_value.pmp45cfg & 0x1) == 0) && ((csr_value.pmp45cfg & 0x2) == 0x2))) {
-          # not R = 0, W =1, which is reserved
-          if ((PMP_GRANULARITY < 2) ||
-              ((csr_value.pmp45cfg & 0x18) != 0x10)) {
-            # NA4 is not allowed when PMP granularity is larger than 4 bytes
-            return csr_value.pmp45cfg;
+      if ((xlen() == 64) && NUM_USABLE_PMP_ENTRIES > 45 && (CSR[pmpcfg10].pmp45cfg & 0x80) == 0) {
+        # entry is usable and not locked
+        Bits<8> new_cfg = csr_value.pmp45cfg;
+        Bits<2> a_mode = (new_cfg & 0x18) >> 3;
+        if (!(((new_cfg & 0x1) == 0) && ((new_cfg & 0x2) == 0x2))) {
+          # not R = 0, W = 1, which is reserved
+          if (((a_mode == 0x1) && !PMP_TOR_SUPPORTED) ||
+              ((a_mode == 0x2) && !PMP_NA4_SUPPORTED) ||
+              ((a_mode == 0x3) && !PMP_NAPOT_SUPPORTED)) {
+            # unsupported address matching mode; keep old value
+            return CSR[pmpcfg10].pmp45cfg;
           }
+          return new_cfg;
         }
       }
       # fall through: keep old value
@@ -389,23 +371,15 @@ fields:
       ! Name ! Location ! Description
 
       h! L ! 55   ! Locks the entry from further modification. Additionally, when set, PMP checks also apply to M-mode for the entry.
-      h! - ! 54:53 ! _Reserved_ Writes shall be ignored.
+      h! MT ! 54:53 ! When the `Smpmpmt` extension is implemented, MT (Memory Type) is a WARL field that overrides the memory type for accesses that match this PMP entry.  See the `Smpmpmt` extension definition for encodings.  When the `Smpmpmt` extension is not implemented, MT is _Reserved_ Writes shall be ignored.
       h! A ! 52:51
-      a! Address matching mode. One of:
+      a! Address matching mode. Encodings:
 
-          [when="PMP_GRANULARITY < 2"]
           * *OFF* (0) - Null region (disabled)
           * *TOR* (1) - Top of range
           * *NA4* (2) - Naturally aligned four-byte region
           * *NAPOT* (3) - Naturally aligned power of two
 
-          [when="PMP_GRANULARITY >= 2"]
-          * *OFF* (0) - Null region (disabled)
-          * *TOR* (1) - Top of range
-          * *NAPOT* (3) - Naturally aligned power of two
-
-      [when="PMP_GRANULARITY >= 2"]
-      Naturally aligned four-byte region, *NA4* (2), is not valid (not needed when the PMP granularity is larger than 4 bytes).
 
       h! X ! 50 ! When clear, instruction fetches cause an `Access Fault` for the matching region and privilege mode.
       h! W ! 49 ! When clear, stores and AMOs cause an `Access Fault` for the matching region and privilege mode.
@@ -414,23 +388,28 @@ fields:
 
       The combination of R = 0, W = 1 is reserved.
     type(): |
-      if (NUM_PMP_ENTRIES > 46) {
+      if (NUM_USABLE_PMP_ENTRIES > 46) {
         return CsrFieldType::RWR;
       } else {
+        # entry is either not implemented or implemented as read-only zero
         return CsrFieldType::RO;
       }
     reset_value(): |
       return 0;
     sw_write(csr_value): |
-      if ((xlen() == 64) && (CSR[pmpcfg10].pmp46cfg & 0x80) == 0) {
-        # entry is not locked
-        if (!(((csr_value.pmp46cfg & 0x1) == 0) && ((csr_value.pmp46cfg & 0x2) == 0x2))) {
-          # not R = 0, W =1, which is reserved
-          if ((PMP_GRANULARITY < 2) ||
-              ((csr_value.pmp46cfg & 0x18) != 0x10)) {
-            # NA4 is not allowed when PMP granularity is larger than 4 bytes
-            return csr_value.pmp46cfg;
+      if ((xlen() == 64) && NUM_USABLE_PMP_ENTRIES > 46 && (CSR[pmpcfg10].pmp46cfg & 0x80) == 0) {
+        # entry is usable and not locked
+        Bits<8> new_cfg = csr_value.pmp46cfg;
+        Bits<2> a_mode = (new_cfg & 0x18) >> 3;
+        if (!(((new_cfg & 0x1) == 0) && ((new_cfg & 0x2) == 0x2))) {
+          # not R = 0, W = 1, which is reserved
+          if (((a_mode == 0x1) && !PMP_TOR_SUPPORTED) ||
+              ((a_mode == 0x2) && !PMP_NA4_SUPPORTED) ||
+              ((a_mode == 0x3) && !PMP_NAPOT_SUPPORTED)) {
+            # unsupported address matching mode; keep old value
+            return CSR[pmpcfg10].pmp46cfg;
           }
+          return new_cfg;
         }
       }
       # fall through: keep old value
@@ -449,23 +428,15 @@ fields:
       ! Name ! Location ! Description
 
       h! L ! 63   ! Locks the entry from further modification. Additionally, when set, PMP checks also apply to M-mode for the entry.
-      h! - ! 62:61 ! _Reserved_ Writes shall be ignored.
+      h! MT ! 62:61 ! When the `Smpmpmt` extension is implemented, MT (Memory Type) is a WARL field that overrides the memory type for accesses that match this PMP entry.  See the `Smpmpmt` extension definition for encodings.  When the `Smpmpmt` extension is not implemented, MT is _Reserved_ Writes shall be ignored.
       h! A ! 60:59
-      a! Address matching mode. One of:
+      a! Address matching mode. Encodings:
 
-          [when="PMP_GRANULARITY < 2"]
           * *OFF* (0) - Null region (disabled)
           * *TOR* (1) - Top of range
           * *NA4* (2) - Naturally aligned four-byte region
           * *NAPOT* (3) - Naturally aligned power of two
 
-          [when="PMP_GRANULARITY >= 2"]
-          * *OFF* (0) - Null region (disabled)
-          * *TOR* (1) - Top of range
-          * *NAPOT* (3) - Naturally aligned power of two
-
-      [when="PMP_GRANULARITY >= 2"]
-      Naturally aligned four-byte region, *NA4* (2), is not valid (not needed when the PMP granularity is larger than 4 bytes).
 
       h! X ! 58 ! When clear, instruction fetches cause an `Access Fault` for the matching region and privilege mode.
       h! W ! 57 ! When clear, stores and AMOs cause an `Access Fault` for the matching region and privilege mode.
@@ -474,23 +445,28 @@ fields:
 
       The combination of R = 0, W = 1 is reserved.
     type(): |
-      if (NUM_PMP_ENTRIES > 47) {
+      if (NUM_USABLE_PMP_ENTRIES > 47) {
         return CsrFieldType::RWR;
       } else {
+        # entry is either not implemented or implemented as read-only zero
         return CsrFieldType::RO;
       }
     reset_value(): |
       return 0;
     sw_write(csr_value): |
-      if ((xlen() == 64) && (CSR[pmpcfg10].pmp47cfg & 0x80) == 0) {
-        # entry is not locked
-        if (!(((csr_value.pmp47cfg & 0x1) == 0) && ((csr_value.pmp47cfg & 0x2) == 0x2))) {
-          # not R = 0, W =1, which is reserved
-          if ((PMP_GRANULARITY < 2) ||
-              ((csr_value.pmp47cfg & 0x18) != 0x10)) {
-            # NA4 is not allowed when PMP granularity is larger than 4 bytes
-            return csr_value.pmp47cfg;
+      if ((xlen() == 64) && NUM_USABLE_PMP_ENTRIES > 47 && (CSR[pmpcfg10].pmp47cfg & 0x80) == 0) {
+        # entry is usable and not locked
+        Bits<8> new_cfg = csr_value.pmp47cfg;
+        Bits<2> a_mode = (new_cfg & 0x18) >> 3;
+        if (!(((new_cfg & 0x1) == 0) && ((new_cfg & 0x2) == 0x2))) {
+          # not R = 0, W = 1, which is reserved
+          if (((a_mode == 0x1) && !PMP_TOR_SUPPORTED) ||
+              ((a_mode == 0x2) && !PMP_NA4_SUPPORTED) ||
+              ((a_mode == 0x3) && !PMP_NAPOT_SUPPORTED)) {
+            # unsupported address matching mode; keep old value
+            return CSR[pmpcfg10].pmp47cfg;
           }
+          return new_cfg;
         }
       }
       # fall through: keep old value