feat: add packed register type

Author: micha4w

vendor/lowrisc_opentitan/util/reggen/reg_block.py

@@ -119,13 +119,14 @@ def add_raw(self, where: str, raw: object) -> None:
             'reserved': self._handle_reserved,
             'skipto': self._handle_skipto,
             'window': self._handle_window,
-            'multireg': self._handle_multireg
+            'multireg': self._handle_multireg,
+            'packed': self._handle_packed
         }
 
         entry_type = 'register'
         entry_body = entry  # type: object
 
-        for t in ['reserved', 'skipto', 'window', 'multireg']:
+        for t in ['reserved', 'skipto', 'window', 'multireg', 'packed']:
             t_body = entry.get(t)
             if t_body is not None:
                 # Special entries look like { window: { ... } }, so if we
@@ -207,6 +208,25 @@ def _handle_multireg(self, where: str, body: object) -> None:
         self.entries.append(mr)
         self.offset = mr.next_offset(self._addrsep)
 
+    def _handle_packed(self, where: str, body: object) -> None:
+        reg_bodies = check_list(body, 'packed')
+        local_offset = 0
+        for i, body in enumerate(reg_bodies):
+            reg = Register.from_raw(self._reg_width, self.offset, self._params, body)
+            if i < len(reg_bodies) - 1:
+                reg.doesnt_increment_offset = True
+
+            byte_width = (reg.get_width() + 7) // 8 * 8
+
+            for field in reg.fields:
+                field.bits = field.bits.make_translated(local_offset)
+            
+            local_offset += byte_width
+            self.add_register(reg)
+        
+        if local_offset > self._reg_width:
+            raise ValueError(f'Packed register is larger than regwidth ({local_offset} > {self._reg_width})')
+
     def add_register(self, reg: Register) -> None:
         assert reg.offset == self.offset
 

vendor/lowrisc_opentitan/util/reggen/register.py

@@ -91,7 +91,8 @@ def __init__(self,
                  shadowed: bool,
                  fields: List[Field],
                  update_err_alert: Optional[str],
-                 storage_err_alert: Optional[str]):
+                 storage_err_alert: Optional[str],
+                 doesnt_increment_offset: bool):
         super().__init__(offset)
         self.name = name
         self.desc = desc
@@ -173,6 +174,7 @@ def __init__(self,
 
         self.update_err_alert = update_err_alert
         self.storage_err_alert = storage_err_alert
+        self.doesnt_increment_offset = doesnt_increment_offset
 
     @staticmethod
     def from_raw(reg_width: int,
@@ -261,9 +263,12 @@ def from_raw(reg_width: int,
         return Register(offset, name, desc, swaccess, hwaccess,
                         hwext, hwqe, hwre, regwen,
                         tags, resval, shadowed, fields,
-                        update_err_alert, storage_err_alert)
+                        update_err_alert, storage_err_alert, False)
 
     def next_offset(self, addrsep: int) -> int:
+        if self.doesnt_increment_offset:
+            return self.offset
+
         return self.offset + addrsep
 
     def sw_readable(self) -> bool:
@@ -374,7 +379,7 @@ def make_multi(self,
                         self.swaccess, self.hwaccess,
                         self.hwext, self.hwqe, self.hwre, new_regwen,
                         self.tags, new_resval, self.shadowed, new_fields,
-                        self.update_err_alert, self.storage_err_alert)
+                        self.update_err_alert, self.storage_err_alert, False)
 
     def _asdict(self) -> Dict[str, object]:
         rd = {
@@ -388,6 +393,7 @@ def _asdict(self) -> Dict[str, object]:
             'hwre': str(self.hwre),
             'tags': self.tags,
             'shadowed': str(self.shadowed),
+            'doesnt_increment_offset': str(self.doesnt_increment_offset),
         }
         if self.regwen is not None:
             rd['regwen'] = self.regwen