From dcb9f3612093712593a56c8104199d4e3db5590c Mon Sep 17 00:00:00 2001
From: Zack Buhman <zack@buhman.org>
Date: Mon, 1 Jan 2024 23:43:06 +0800
Subject: [PATCH] sh7091_bits.ods: partial

Notably missing is:

- BSC (PDTRA / PCTRA)

This also updates a handful of files to use the new sh7091_bits.hpp.
---
 cache.cpp                               |  34 -
 common.mk                               |  14 +-
 example/heart.cpp                       |   2 +-
 example/serial_transfer.cpp             |  14 +-
 holly/core.cpp                          |  13 +-
 holly/core_bits.hpp                     |  98 +--
 holly.hpp => holly/holly.hpp            |   0
 holly/ta_fifo_polygon_converter.cpp     |  40 +-
 regs/gen/core_bits.py                   |  64 +-
 regs/gen/sh7091.py                      |  10 +-
 regs/sh7091_bits.csv                    | 293 +++++++++
 regs/sh7091_bits.ods                    | Bin 0 -> 20874 bytes
 runtime.cpp                             |   2 +-
 serial_load.cpp                         |   9 +-
 sh7091/cache.cpp                        |  36 ++
 cache.hpp => sh7091/cache.hpp           |   0
 imask.hpp => sh7091/imask.hpp           |   0
 serial.cpp => sh7091/serial.cpp         |   0
 serial.hpp => sh7091/serial.hpp         |   0
 sh7091.hpp => sh7091/sh7091.hpp         |   4 +-
 sh7091/sh7091_bits.hpp                  | 822 ++++++++++++++++++++++++
 storequeue.cpp => sh7091/storequeue.cpp |   0
 storequeue.hpp => sh7091/storequeue.hpp |   0
 sh7091_bits.hpp                         | 101 ---
 vga.cpp                                 |  14 +-
 25 files changed, 1320 insertions(+), 250 deletions(-)
 delete mode 100644 cache.cpp
 rename holly.hpp => holly/holly.hpp (100%)
 create mode 100644 regs/sh7091_bits.csv
 create mode 100644 regs/sh7091_bits.ods
 create mode 100644 sh7091/cache.cpp
 rename cache.hpp => sh7091/cache.hpp (100%)
 rename imask.hpp => sh7091/imask.hpp (100%)
 rename serial.cpp => sh7091/serial.cpp (100%)
 rename serial.hpp => sh7091/serial.hpp (100%)
 rename sh7091.hpp => sh7091/sh7091.hpp (99%)
 create mode 100644 sh7091/sh7091_bits.hpp
 rename storequeue.cpp => sh7091/storequeue.cpp (100%)
 rename storequeue.hpp => sh7091/storequeue.hpp (100%)
 delete mode 100644 sh7091_bits.hpp

diff --git a/cache.cpp b/cache.cpp
deleted file mode 100644
index 8dea9e6..0000000
--- a/cache.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "type.hpp"
-#include "sh7091.hpp"
-#include "sh7091_bits.hpp"
-
-#include "cache.hpp"
-
-extern volatile reg32 sh7091_ic_a[256][(1 << 5) / 4] __asm("sh7091_ic_a");
-extern volatile reg32 sh7091_oc_a[512][(1 << 5) / 4] __asm("sh7091_oc_a");
-
-namespace cache {
-
-void init()
-{
-  for (int i = 0; i < 256; i++) {
-    sh7091_ic_a[i][0] = 0;
-  }
-
-  for (int i = 0; i < 512; i++) {
-    sh7091_oc_a[i][0] = 0;
-  }
-
-  sh7091.CCN.CCR = CCR__ICI // instruction cache invalidate
-                 | CCR__ICE // instruction cache enable
-                 | CCR__OCI // operand cache invalidate
-                 | CCR__OCE // operand cache enable
-              // | CCR__CB  // enable copy-back mode for the P1 area
-                 ;
-
-  sh7091.CCN.MMUCR = 0;
-
-  asm volatile ("nop;nop;nop;nop;nop;nop;nop;nop;");
-}
-
-}
diff --git a/common.mk b/common.mk
index 5a0d1f9..8b853bc 100644
--- a/common.mk
+++ b/common.mk
@@ -55,7 +55,7 @@ IP_OBJ = \
 START_OBJ = \
 	start.o \
 	runtime.o \
-	cache.o
+	sh7091/cache.o
 
 %.bin.o: %.bin
 	$(BUILD_BINARY_O)
@@ -139,12 +139,24 @@ maple/maple_bus_commands.hpp: regs/maple_bus_commands.csv regs/gen/maple_bus_com
 maple/maple_bus_bits.hpp: regs/maple_bus_bits.csv regs/gen/core_bits.py
 	python regs/gen/core_bits.py $< > $@
 
+holly/core_bits.hpp: regs/core_bits.csv regs/gen/core_bits.py
+	python regs/gen/core_bits.py $< > $@
+
+holly/holly.hpp: regs/holly.csv regs/gen/holly.py
+	python regs/gen/holly.py $< > $@
+
 holly/ta_global_parameter.hpp: regs/global_parameter_format.csv regs/gen/ta_parameter_format.py
 	python regs/gen/ta_parameter_format.py $< ta_global_parameter > $@
 
 holly/ta_vertex_parameter.hpp: regs/vertex_parameter_format.csv regs/gen/ta_parameter_format.py
 	python regs/gen/ta_parameter_format.py $< ta_vertex_parameter > $@
 
+sh7091/sh7091.hpp: regs/sh7091.csv regs/gen/sh7091.py
+	python regs/gen/sh7091.py $< > $@
+
+sh7091/sh7091_bits.hpp: regs/sh7091_bits.csv regs/gen/core_bits.py
+	python regs/gen/core_bits.py $< > $@
+
 clean:
 	find -P \
 		-regextype posix-egrep \
diff --git a/example/heart.cpp b/example/heart.cpp
index 22c33e5..97a55af 100644
--- a/example/heart.cpp
+++ b/example/heart.cpp
@@ -4,7 +4,7 @@
 #include "vga.hpp"
 
 #include "holly/texture_memory_alloc.hpp"
-#include "holly.hpp"
+#include "holly/holly.hpp"
 #include "holly/core.hpp"
 #include "holly/core_bits.hpp"
 #include "holly/ta_fifo_polygon_converter.hpp"
diff --git a/example/serial_transfer.cpp b/example/serial_transfer.cpp
index 760d74d..1c9b375 100644
--- a/example/serial_transfer.cpp
+++ b/example/serial_transfer.cpp
@@ -1,9 +1,9 @@
 #include <cstdint>
 
-#include "sh7091.hpp"
-#include "sh7091_bits.hpp"
+#include "sh7091/sh7091.hpp"
+#include "sh7091/sh7091_bits.hpp"
+#include "sh7091/cache.hpp"
 
-#include "cache.hpp"
 #include "serial_load.hpp"
 
 extern uint32_t __bss_link_start __asm("__bss_link_start");
@@ -22,13 +22,15 @@ void main()
   load_init();
 
   while (1) {
-    while ((sh7091.SCIF.SCFSR2 & SCFSR2__TDFE) == 0) {
+    using namespace scif;
+
+    while ((sh7091.SCIF.SCFSR2 & scfsr2::tdfe::bit_mask) == 0) {
       // wait
     }
-    while ((sh7091.SCIF.SCFDR2 & 0b11111) > 0) {
+    while ((scfdr2::receive_data_bytes(sh7091.SCIF.SCFDR2)) > 0) {
       uint8_t c = sh7091.SCIF.SCFRDR2;
       load_recv(c);
     }
-    sh7091.SCIF.SCFSR2 = sh7091.SCIF.SCFSR2 & (~SCFSR2__RDF);
+    sh7091.SCIF.SCFSR2 = sh7091.SCIF.SCFSR2 & (~scfsr2::rdf::bit_mask);
   }
 }
diff --git a/holly/core.cpp b/holly/core.cpp
index 061f914..0ea30c0 100644
--- a/holly/core.cpp
+++ b/holly/core.cpp
@@ -1,13 +1,12 @@
-#include "../float_uint32.hpp"
-#include "core_bits.hpp"
-#include "../holly.hpp"
-#include "../memorymap.hpp"
-#include "../systembus.hpp"
-#include "../systembus_bits.hpp"
+#include "float_uint32.hpp"
+#include "memorymap.hpp"
+#include "systembus.hpp"
+#include "systembus_bits.hpp"
 
 #include "texture_memory_alloc.hpp"
-
+#include "holly.hpp"
 #include "core.hpp"
+#include "core_bits.hpp"
 #include "background.hpp"
 #include "region_array.hpp"
 
diff --git a/holly/core_bits.hpp b/holly/core_bits.hpp
index 81bf1a6..fd22958 100644
--- a/holly/core_bits.hpp
+++ b/holly/core_bits.hpp
@@ -53,24 +53,24 @@ namespace fb_r_ctrl {
   namespace vclk_div {
     constexpr uint32_t pclk_vclk_2 = 0 << 23;
     constexpr uint32_t pclk_vclk_1 = 1 << 23;
-    
+
     constexpr uint32_t bit_mask = 0x1 << 23;
   }
-  
+
   constexpr uint32_t fb_strip_buf_en = 1 << 22;
   constexpr uint32_t fb_stripsize(uint32_t num) { return (num & 0x3e) << 16; }
   constexpr uint32_t fb_chroma_threshold(uint32_t num) { return (num & 0xff) << 8; }
   constexpr uint32_t fb_concat(uint32_t num) { return (num & 0x3) << 4; }
-  
+
   namespace fb_depth {
     constexpr uint32_t _0555_rgb_16bit = 0 << 2;
     constexpr uint32_t _0565_rgb_16bit = 1 << 2;
     constexpr uint32_t _888_rgb_24bit_packed = 2 << 2;
     constexpr uint32_t _0888_rgb_32bit = 3 << 2;
-    
+
     constexpr uint32_t bit_mask = 0x3 << 2;
   }
-  
+
   constexpr uint32_t fb_line_double = 1 << 1;
   constexpr uint32_t fb_enable = 1 << 0;
 }
@@ -79,7 +79,7 @@ namespace fb_w_ctrl {
   constexpr uint32_t fb_alpha_threshold(uint32_t num) { return (num & 0xff) << 16; }
   constexpr uint32_t fb_kval(uint32_t num) { return (num & 0xff) << 8; }
   constexpr uint32_t fb_dither = 1 << 3;
-  
+
   namespace fb_packmode {
     constexpr uint32_t _0555_krgb_16bit = 0 << 0;
     constexpr uint32_t _565_rgb_16bit = 1 << 0;
@@ -88,7 +88,7 @@ namespace fb_w_ctrl {
     constexpr uint32_t _888_rgb_24bit_packed = 4 << 0;
     constexpr uint32_t _0888_krgb_32bit = 5 << 0;
     constexpr uint32_t _8888_argb_32bit = 6 << 0;
-    
+
     constexpr uint32_t bit_mask = 0x7 << 0;
   }
 }
@@ -133,10 +133,10 @@ namespace fpu_shad_scale {
   namespace simple_shadow_enable {
     constexpr uint32_t parameter_selection_volume_mode = 0 << 8;
     constexpr uint32_t intensity_volume_mode = 1 << 8;
-    
+
     constexpr uint32_t bit_mask = 0x1 << 8;
   }
-  
+
   constexpr uint32_t scale_factor_for_shadows(uint32_t num) { return (num & 0xff) << 0; }
 }
 
@@ -148,10 +148,10 @@ namespace fpu_param_cfg {
   namespace region_header_type {
     constexpr uint32_t type_1 = 0 << 21;
     constexpr uint32_t type_2 = 1 << 21;
-    
+
     constexpr uint32_t bit_mask = 0x1 << 21;
   }
-  
+
   constexpr uint32_t tsp_parameter_burst_threshold(uint32_t num) { return (num & 0x3f) << 14; }
   constexpr uint32_t isp_parameter_burst_threshold(uint32_t num) { return (num & 0x3f) << 8; }
   constexpr uint32_t pointer_burst_size(uint32_t num) { return (num & 0xf) << 4; }
@@ -162,21 +162,21 @@ namespace half_offset {
   namespace tsp_texel_sampling_position {
     constexpr uint32_t top_left = 1 << 2;
     constexpr uint32_t center = 1 << 2;
-    
+
     constexpr uint32_t bit_mask = 0x1 << 2;
   }
-  
+
   namespace tsp_pixel_sampling_position {
     constexpr uint32_t top_left = 1 << 1;
     constexpr uint32_t center = 1 << 1;
-    
+
     constexpr uint32_t bit_mask = 0x1 << 1;
   }
-  
+
   namespace fpu_pixel_sampling_position {
     constexpr uint32_t top_left = 1 << 0;
     constexpr uint32_t center = 1 << 0;
-    
+
     constexpr uint32_t bit_mask = 0x1 << 0;
   }
 }
@@ -222,18 +222,18 @@ namespace sdram_arb_cfg {
     constexpr uint32_t isp_pointer_data = 0x9 << 18;
     constexpr uint32_t isp_parameters = 0xa << 18;
     constexpr uint32_t crt_controller = 0xb << 18;
-    
+
     constexpr uint32_t bit_mask = 0xf << 18;
   }
-  
+
   namespace arbiter_priority_control {
     constexpr uint32_t priority_arbitration_only = 0x0 << 16;
     constexpr uint32_t override_value_field = 0x1 << 16;
     constexpr uint32_t round_robin_counter = 0x2 << 16;
-    
+
     constexpr uint32_t bit_mask = 0x3 << 16;
   }
-  
+
   constexpr uint32_t arbiter_crt_page_break_latency_count_value(uint32_t num) { return (num & 0xff) << 8; }
   constexpr uint32_t arbiter_page_break_latency_count_value(uint32_t num) { return (num & 0xff) << 0; }
 }
@@ -289,15 +289,15 @@ namespace spg_trigger_pos {
 
 namespace spg_hblank_int {
   constexpr uint32_t hblank_in_interrupt(uint32_t reg) { return (reg >> 16) & 0x3ff; }
-  
+
   namespace hblank_int_mode {
     constexpr uint32_t output_equal_line_comp_val = 0x0 << 12;
     constexpr uint32_t output_every_line_comp_val = 0x1 << 12;
     constexpr uint32_t output_every_line = 0x2 << 12;
-    
+
     constexpr uint32_t bit_mask = 0x3 << 12;
   }
-  
+
   constexpr uint32_t line_comp_val(uint32_t num) { return (num & 0x3ff) << 0; }
 }
 
@@ -310,41 +310,41 @@ namespace spg_control {
   namespace csync_on_h {
     constexpr uint32_t hsync = 0 << 9;
     constexpr uint32_t csync = 1 << 9;
-    
+
     constexpr uint32_t bit_mask = 0x1 << 9;
   }
-  
+
   namespace sync_direction {
     constexpr uint32_t input = 0 << 8;
     constexpr uint32_t output = 1 << 8;
-    
+
     constexpr uint32_t bit_mask = 0x1 << 8;
   }
-  
+
   constexpr uint32_t pal = 1 << 7;
   constexpr uint32_t ntsc = 1 << 6;
   constexpr uint32_t force_field2 = 1 << 5;
   constexpr uint32_t interlace = 1 << 4;
   constexpr uint32_t spg_lock = 1 << 3;
-  
+
   namespace mcsync_pol {
     constexpr uint32_t active_low = 0 << 2;
     constexpr uint32_t active_high = 1 << 2;
-    
+
     constexpr uint32_t bit_mask = 0x1 << 2;
   }
-  
+
   namespace mvsync_pol {
     constexpr uint32_t active_low = 0 << 1;
     constexpr uint32_t active_high = 1 << 1;
-    
+
     constexpr uint32_t bit_mask = 0x1 << 1;
   }
-  
+
   namespace mhsync_pol {
     constexpr uint32_t active_low = 0 << 0;
     constexpr uint32_t active_high = 1 << 0;
-    
+
     constexpr uint32_t bit_mask = 0x1 << 0;
   }
 }
@@ -375,17 +375,17 @@ namespace text_control {
   namespace code_book_endian {
     constexpr uint32_t little_endian = 0 << 17;
     constexpr uint32_t big_endian = 1 << 17;
-    
+
     constexpr uint32_t bit_mask = 0x1 << 17;
   }
-  
+
   namespace index_endian {
     constexpr uint32_t little_endian = 0 << 16;
     constexpr uint32_t big_endian = 1 << 16;
-    
+
     constexpr uint32_t bit_mask = 0x1 << 16;
   }
-  
+
   constexpr uint32_t bank_bit(uint32_t num) { return (num & 0x1f) << 8; }
   constexpr uint32_t stride(uint32_t num) { return (num & 0x1f) << 0; }
 }
@@ -394,7 +394,7 @@ namespace vo_control {
   constexpr uint32_t pclk_delay_reset = 1 << 21;
   constexpr uint32_t pclk_delay(uint32_t num) { return (num & 0xf) << 16; }
   constexpr uint32_t pixel_double = 1 << 8;
-  
+
   namespace field_mode {
     constexpr uint32_t use_field_flag_from_spg = 0x0 << 4;
     constexpr uint32_t use_inverse_of_field_flag_from_spg = 0x1 << 4;
@@ -405,30 +405,30 @@ namespace vo_control {
     constexpr uint32_t field_1_when_hsync_becomes_active_in_the_middle_of_the_vsync_active_edge = 0x6 << 4;
     constexpr uint32_t field_2_when_hsync_becomes_active_in_the_middle_of_the_vsync_active_edge = 0x7 << 4;
     constexpr uint32_t inverted_at_the_active_edge_of_vsync = 0x8 << 4;
-    
+
     constexpr uint32_t bit_mask = 0xf << 4;
   }
-  
+
   constexpr uint32_t blank_video = 1 << 3;
-  
+
   namespace blank_pol {
     constexpr uint32_t active_low = 0 << 2;
     constexpr uint32_t active_high = 1 << 2;
-    
+
     constexpr uint32_t bit_mask = 0x1 << 2;
   }
-  
+
   namespace vsync_pol {
     constexpr uint32_t active_low = 0 << 1;
     constexpr uint32_t active_high = 1 << 1;
-    
+
     constexpr uint32_t bit_mask = 0x1 << 1;
   }
-  
+
   namespace hsync_pol {
     constexpr uint32_t active_low = 0 << 0;
     constexpr uint32_t active_high = 1 << 0;
-    
+
     constexpr uint32_t bit_mask = 0x1 << 0;
   }
 }
@@ -446,10 +446,10 @@ namespace scaler_ctl {
   namespace field_select {
     constexpr uint32_t field_1 = 0 << 18;
     constexpr uint32_t field_2 = 1 << 18;
-    
+
     constexpr uint32_t bit_mask = 0x1 << 18;
   }
-  
+
   constexpr uint32_t interlace = 1 << 17;
   constexpr uint32_t horizontal_scaling_enable = 1 << 16;
   constexpr uint32_t vertical_scale_factor(uint32_t num) { return (num & 0xffff) << 0; }
@@ -461,7 +461,7 @@ namespace pal_ram_ctrl {
     constexpr uint32_t rgb565 = 1 << 0;
     constexpr uint32_t argb4444 = 2 << 0;
     constexpr uint32_t argb8888 = 3 << 0;
-    
+
     constexpr uint32_t bit_mask = 0x3 << 0;
   }
 }
diff --git a/holly.hpp b/holly/holly.hpp
similarity index 100%
rename from holly.hpp
rename to holly/holly.hpp
diff --git a/holly/ta_fifo_polygon_converter.cpp b/holly/ta_fifo_polygon_converter.cpp
index feab290..eb68ca0 100644
--- a/holly/ta_fifo_polygon_converter.cpp
+++ b/holly/ta_fifo_polygon_converter.cpp
@@ -1,13 +1,13 @@
 #include <cstdint>
 
+#include "systembus.hpp"
+#include "systembus_bits.hpp"
+#include "sh7091/sh7091.hpp"
+#include "sh7091/sh7091_bits.hpp"
+
 #include "core_bits.hpp"
 #include "ta_bits.hpp"
-#include "../holly.hpp"
-#include "../systembus.hpp"
-#include "../systembus_bits.hpp"
-#include "../sh7091.hpp"
-#include "../sh7091_bits.hpp"
-
+#include "holly.hpp"
 #include "texture_memory_alloc.hpp"
 
 #include "ta_fifo_polygon_converter.hpp"
@@ -79,23 +79,25 @@ void ta_polygon_converter_transfer(volatile uint32_t * buf, uint32_t size)
   volatile uint32_t _dummy = sh7091.DMAC.CHCR2;
   (void)_dummy;
 
+  using namespace dmac;
+
   /* start a new CH2-DMA transfer from "system memory" to "TA FIFO polygon converter" */
   sh7091.DMAC.CHCR2 = 0; /* disable DMA channel */
-  sh7091.DMAC.SAR2 = reinterpret_cast<uint32_t>(&buf[0]); /* start address, must be aligned to a CHCHR__TS-sized (32-byte) boundary */
-  sh7091.DMAC.DMATCR2 = DMATCR2__TRANSFER_COUNT(size / 32); /* transfer count, in CHCHR__TS-sized (32-byte) units */
-  sh7091.DMAC.CHCR2 = CHCR2__DM__DESTINATION_ADDRESS_FIXED
-                    | CHCR2__SM__SOURCE_ADDRESS_INCREMENTED
-		    | CHCR2__RS(0b0010) /* external request, single address mode;
-					   external address space → external device */
-                    | CHCR2__TM__BURST_MODE /* transmit mode */
-                    | CHCR2__TS__32_BYTE    /* transfer size */
-                    | CHCR2__DE;            /* DMAC (channel) enable */
+  sh7091.DMAC.SAR2 = reinterpret_cast<uint32_t>(&buf[0]);  /* start address, must be aligned to a CHCHR__TS-sized (32-byte) boundary */
+  sh7091.DMAC.DMATCR2 = dmatcr::transfer_count(size / 32); /* transfer count, in CHCHR__TS-sized (32-byte) units */
+  sh7091.DMAC.CHCR2 = chcr::dm::destination_address_fixed
+                    | chcr::sm::source_address_incremented
+                    | chcr::rs::resource_select(0b0010) /* external request, single address mode;
+					                   external address space → external device */
+                    | chcr::tm::cycle_burst_mode /* transmit mode */
+                    | chcr::ts::_32_byte         /* transfer size */
+                    | chcr::de::channel_operation_enabled;
 
-  sh7091.DMAC.DMAOR = DMAOR__DDT                 /* on-demand data transfer mode */
-                    | DMAOR__PR__CH2_CH0_CH1_CH3 /* priority mode; CH2 > CH0 > CH1 > CH3 */
-                    | DMAOR__DME;                /* DMAC master enable */
+  sh7091.DMAC.DMAOR = dmaor::ddt::on_demand_data_transfer_mode       /* on-demand data transfer mode */
+                    | dmaor::pr::ch2_ch0_ch1_ch3                     /* priority mode; CH2 > CH0 > CH1 > CH3 */
+                    | dmaor::dme::operation_enabled_on_all_channels; /* DMAC master enable */
   system.C2DSTAT = C2DSTAT__ADDRESS(0x10000000); /* CH2-DMA destination address */
-  system.C2DLEN  = CD2LEN__LENGTH(size) ; /* CH2-DMA length (must be a multiple of 32) */
+  system.C2DLEN  = CD2LEN__LENGTH(size);         /* CH2-DMA length (must be a multiple of 32) */
   system.C2DST   = 1;          /* CH2-DMA start (an 'external' request from SH7091's perspective) */
 
   // wait for CH2-DMA completion
diff --git a/regs/gen/core_bits.py b/regs/gen/core_bits.py
index f47db48..f48e345 100644
--- a/regs/gen/core_bits.py
+++ b/regs/gen/core_bits.py
@@ -18,11 +18,19 @@ def parse_bit_number(s):
     assert '-' not in s
     return int(s, 10)
 
+def parse_bit_set(s, split_char):
+    assert len(list(c for c in s if c == split_char)) == 1
+    left, right = map(parse_bit_number, s.split(split_char, maxsplit=1))
+    assert left > right, (left, right)
+    return left, right
+
 def parse_bit_range(s):
     if '-' in s:
-        left, right = map(parse_bit_number, s.split('-', maxsplit=1))
-        assert left > right, (left, right)
+        left, right = parse_bit_set(s, '-')
         return set(range(right, left+1))
+    elif ',' in s:
+        left, right = parse_bit_set(s, ',')
+        return set([right, left])
     else:
         num = parse_bit_number(s)
         return set([num])
@@ -41,7 +49,7 @@ def aggregate_enums(aggregated_rows):
 
     for row in aggregated_rows:
         bits = parse_bit_range(row["bits"])
-        assert row["bit_name"] != ""
+        assert row["bit_name"] != "", row
         if row["enum_name"] == "":
             assert_unique_ordered(bits)
             non_enum.append(row)
@@ -50,7 +58,7 @@ def aggregate_enums(aggregated_rows):
                 assert_unique_ordered(bits)
                 non_enum.append(row["enum_name"])
             else:
-                assert enum_bits[row["enum_name"]] == bits
+                assert enum_bits[row["enum_name"]] == bits, row
 
             enum_bits[row["enum_name"]] = bits
             enum_aggregated[row["enum_name"]].append(row)
@@ -64,6 +72,7 @@ class enum:
 
 @dataclass
 class register:
+    block: Union[None, str]
     name: str
     defs: list[Union[dict, enum]]
 
@@ -79,9 +88,17 @@ def aggregate_all_enums(aggregated):
                 return row_or_string
             else:
                 assert False, (row_or_string, type(row_or_string))
-        out.append(
-            register(register_name,
-                     [resolve(aggregate) for aggregate in non_enum]))
+
+        defs = [resolve(aggregate) for aggregate in non_enum]
+        if 'block' in rows[0]:
+            blocks = set(row['block'] for row in rows)
+            assert len(blocks) == 1, blocks
+            block_name = next(iter(blocks))
+            out.append(
+                register(block_name, register_name, defs))
+        else:
+            out.append(
+                register(None, register_name, defs))
     return out
 
 '''
@@ -107,19 +124,26 @@ def aggregate_all_enums(aggregated):
 '''
 
 def mask_from_bits(bits):
-    mask = 2 ** len(bits) - 1
+    h, l = max(bits), min(bits)
+    mask = 2 ** ((h - l) + 1) - 1
     return mask
 
 def parse_value(value):
     return eval(value)
 
+def escape(bit_name):
+    if bit_name[0] in {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'}:
+        return '_' + bit_name
+    else:
+        return bit_name
+
 def render_read_only(bit_def):
     assert bit_def["value"] == ""
     assert bit_def["mask"] == ""
     bits = parse_bit_range(bit_def["bits"])
     mask_value = mask_from_bits(bits)
     yield (
-        f"constexpr uint32_t {bit_def['bit_name']}(uint32_t reg) {{ "
+        f"constexpr uint32_t {escape(bit_def['bit_name'])}(uint32_t reg) {{ "
         f"return (reg >> {min(bits)}) & {hex(mask_value)};"
         " }"
     )
@@ -145,7 +169,7 @@ def render_mask(bit_def):
     bits = parse_bit_range(bit_def["bits"])
     if mask.startswith("float_"):
         yield (
-            f"constexpr uint32_t {bit_def['bit_name']}(float num) {{ "
+            f"inline uint32_t {escape(bit_def['bit_name'])}(float num) {{ "
             f"return {render_float_mask(mask)};"
             " }"
         )
@@ -155,7 +179,7 @@ def render_mask(bit_def):
         assert mask_value & mask_from_bits(bits) == mask_value, (mask_value, mask_from_bits(bits))
 
         yield (
-            f"constexpr uint32_t {bit_def['bit_name']}(uint32_t num) {{ "
+            f"constexpr uint32_t {escape(bit_def['bit_name'])}(uint32_t num) {{ "
             f"return (num & {hex(mask_value)}) << {min(bits)};"
             " }"
         )
@@ -163,9 +187,9 @@ def render_mask(bit_def):
 def render_value(bit_def):
     assert bit_def["mask"] == ""
     bits = parse_bit_range(bit_def["bits"])
-    assert parse_value(bit_def["value"]) <= mask_from_bits(bits), bit_def["value"]
+    assert parse_value(bit_def["value"]) <= mask_from_bits(bits), (bit_def["value"], mask_from_bits(bits), bits)
     bit_ix = min(bits)
-    yield f"constexpr uint32_t {bit_def['bit_name']} = {bit_def['value']} << {bit_ix};"
+    yield f"constexpr uint32_t {escape(bit_def['bit_name'])} = {bit_def['value']} << {bit_ix};"
 
 def render_defs(bit_def):
     if bit_def["value"] != "":
@@ -212,9 +236,23 @@ def render_register(register):
     yield ""
 
 def render_registers(registers):
+    last_block = None
     for register in registers:
+        if register.block != last_block:
+            assert register.block is not None
+            if last_block is not None:
+                yield '}' # end of previous namespace
+                yield ""
+            yield f'namespace {register.block.lower()} {{'
+        if register.block is None:
+            assert last_block is None
+        last_block = register.block
+
         yield from render_register(register)
 
+    if last_block is not None:
+        yield '}' # end of block namespace
+
 def header():
     yield "#pragma once"
     yield ""
diff --git a/regs/gen/sh7091.py b/regs/gen/sh7091.py
index a3cf7c0..6949b39 100644
--- a/regs/gen/sh7091.py
+++ b/regs/gen/sh7091.py
@@ -45,13 +45,12 @@ def new_writer():
 
     def terminate():
         nonlocal last_block
-        nonlocal first_address
         nonlocal stack
 
         if last_block is not None:
             yield "};"
             for address, name in stack:
-                yield f"static_assert((offsetof (struct {last_block.lower()}_reg, {name})) == {hex(address)});"
+                yield f"static_assert((offsetof (struct {last_block.lower()}_reg, {name})) == {hex(address - first_address)});"
             yield ""
         stack = []
 
@@ -68,15 +67,16 @@ def new_writer():
         _address = int(row["address"], 16)
         assert _offset  <= 0xff
         assert _address <= 0xffff
-        address = (_offset << 16) | (_address << 0)
+        offset_address = (_offset << 16)
+        address = offset_address | (_address << 0)
         size = int(row["size"], 10)
         name = row["name"]
         description = row["description"]
 
         if block != last_block:
             yield from terminate()
-            first_address = 0 # hmm...
-            last_address = 0
+            first_address = offset_address
+            last_address = offset_address
             size_total = 0
             reserved_num = 0
             yield f"struct {block.lower()}_reg {{"
diff --git a/regs/sh7091_bits.csv b/regs/sh7091_bits.csv
new file mode 100644
index 0000000..f165e1c
--- /dev/null
+++ b/regs/sh7091_bits.csv
@@ -0,0 +1,293 @@
+"block","register_name","enum_name","bits","bit_name","value","mask","description"
+"CCN","PTEH",,"31-10","VPN",,,"Virtual Page Number"
+"CCN","PTEH",,"7-0","ASID",,,"Address space identifier"
+,,,,,,,
+"CCN","PTEL",,"28-10","PPN",,,"Physical page number"
+"CCN","PTEL","V","8","invalid","0",,"Validity"
+"CCN","PTEL","V","8","valid","1",,"Validity"
+"CCN","PTEL","SZ","7,4","1_kbyte_page","0b0000",,"Page size"
+"CCN","PTEL","SZ","7,4","4_kbyte_page","0b0001",,"Page size"
+"CCN","PTEL","SZ","7,4","64_kbyte_page","0b1000",,"Page size"
+"CCN","PTEL","SZ","7,4","1_mbyte_page","0b1001",,"Page size"
+"CCN","PTEL","PR","6-5","read_only_in_privileged_mode","0b00",,"Protection key data"
+"CCN","PTEL","PR","6-5","read_write_in_privileged_mode","0b01",,"Protection key data"
+"CCN","PTEL","PR","6-5","read_only_in_privileged_and_user_mode","0b10",,"Protection key data"
+"CCN","PTEL","PR","6-5","read_write_in_privileged_and_user_mode","0b11",,"Protection key data"
+"CCN","PTEL","C","3","not_cacheable","0",,"Cacheability bit"
+"CCN","PTEL","C","3","cacheable","1",,"Cacheability bit"
+"CCN","PTEL","D","2","write_has_not_been_performed","0",,"Dirty bit"
+"CCN","PTEL","D","2","write_has_been_performed","1",,"Dirty bit"
+"CCN","PTEL","SH","1","pages_are_shared_by_processes","0",,"Share status bit"
+"CCN","PTEL","SH","1","pages_are_not_shared_by_processes","1",,"Share status bit"
+"CCN","PTEL","WT","0","copy_back_mode","0",,"Write-through bit"
+"CCN","PTEL","WT","0","write_through_mode","1",,"Write-through bit"
+,,,,,,,
+"CCN","MMUCR",,"31-26","LRUI",,,"Least recently used ITLB"
+"CCN","MMUCR",,"23-18","URB",,,"UTLB replace boundary"
+"CCN","MMUCR",,"15-10","URC",,,"UTLB replace counter"
+"CCN","MMUCR","SQMD","9","user_privileged_access_possible","0",,"Store queue mode bit"
+"CCN","MMUCR","SQMD","9","privileged_access_possible","1",,"Store queue mode bit"
+"CCN","MMUCR","SV","8","multiple_virtual_memory_mode","0",,"Single virtual mode bit"
+"CCN","MMUCR","SV","8","single_virtual_memory_mode","1",,"Single virtual mode bit"
+"CCN","MMUCR","TI","2","invalidate_all_utlb_itlb_bits","1",,"TLB invalidate"
+"CCN","MMUCR","AT","0","mmu_disabled","0",,"Address translation bit"
+"CCN","MMUCR","AT","0","mmu_enabled","1",,"Address translation bit"
+,,,,,,,
+"CCN","BASRA",,"7-0","basa",,"0xff",
+,,,,,,,
+"CCN","BASRB",,"7-0","basa",,"0xff",
+,,,,,,,
+"CCN","CCR","IIX","15","address_bits_12_5_used_for_ic_entry_selection","0",,"IC index enable"
+"CCN","CCR","IIX","15","address_bits_25_and_11_5_used_for_ic_entry_selection","1",,"IC index enable"
+"CCN","CCR","ICI","11","clear_v_bits_of_all_ic_entries","1",,"IC invalidation"
+"CCN","CCR","ICE","8","ic_not_used","0",,"IC enable"
+"CCN","CCR","ICE","8","ic_used","1",,"IC enable"
+"CCN","CCR","OIX","7","address_bits_13_5_used_for_oc_entry_selection","0",,"OC index enable"
+"CCN","CCR","OIX","7","address_bits_25_and_12_5_used_for_oc_entry_selection","1",,"OC index enable"
+"CCN","CCR","ORA","5","16_kbytes_used_as_cache","0",,"OC RAM enable"
+"CCN","CCR","ORA","5","8_kbytes_used_as_cache_8_kbytes_used_as_ram","1",,"OC RAM enable"
+"CCN","CCR","OCI","3","clear_v_and_u_bits_of_all_oc_entries","1",,"OC invalidation"
+"CCN","CCR","CB","2","write_through_mode","0",,"Copy-back enable"
+"CCN","CCR","CB","2","copy_back_mode","1",,"Copy-back enable"
+"CCN","CCR","WT","1","copy_back_mode","0",,"Write-through enable"
+"CCN","CCR","WT","1","write_through_mode","1",,"Write-through enable"
+"CCN","CCR","OCE","0","oc_not_used","0",,"OC enable"
+"CCN","CCR","OCE","0","oc_used","1",,"OC enable"
+,,,,,,,
+"CCN","TRA",,"9-2","imm",,,
+,,,,,,,
+"CCN","EXPEVT",,"11-0","exception_code",,,
+,,,,,,,
+"CCN","INTEVT",,"11-0","exception_code",,,
+,,,,,,,
+"CCN","PTEA","TC","3","area_5_is_used","0",,"Timing control bit"
+"CCN","PTEA","TC","3","area_6_is_used","1",,"Timing control bit"
+"CCN","PTEA","SA","2-0","undefined","0b000",,"Space attribute bits"
+"CCN","PTEA","SA","2-0","variable_size_io_space","0b001",,"Space attribute bits"
+"CCN","PTEA","SA","2-0","8_bit_io_space","0b010",,"Space attribute bits"
+"CCN","PTEA","SA","2-0","16_bit_io_space","0b011",,"Space attribute bits"
+"CCN","PTEA","SA","2-0","8_bit_common_memory_space","0b100",,"Space attribute bits"
+"CCN","PTEA","SA","2-0","16_bit_common_memory_space","0b101",,"Space attribute bits"
+"CCN","PTEA","SA","2-0","8_bit_attribute_memory_space","0b110",,"Space attribute bits"
+"CCN","PTEA","SA","2-0","16_bit_attribute_memory_space","0b111",,"Space attribute bits"
+,,,,,,,
+"CCN","QACR0",,"4-2","area",,"0b111",
+,,,,,,,
+"CCN","QACR1",,"4-2","area",,"0b111",
+,,,,,,,
+"DMAC","DMATCR",,"23-0","transfer_count",,"0xffffff",
+,,,,,,,
+"DMAC","CHCR","SSA","31-29","reserved_in_pcmcia_access","0b000",,
+"DMAC","CHCR","SSA","31-29","dynamic_bus_sizing_io_space","0b001",,
+"DMAC","CHCR","SSA","31-29","8_bit_io_space","0b010",,
+"DMAC","CHCR","SSA","31-29","16_bit_io_space","0b011",,
+"DMAC","CHCR","SSA","31-29","8_bit_common_memory_space","0b100",,
+"DMAC","CHCR","SSA","31-29","16_bit_common_memory_space","0b101",,
+"DMAC","CHCR","SSA","31-29","8_bit_attribute_memory_space","0b110",,
+"DMAC","CHCR","SSA","31-29","16_bit_attribute_memory_space","0b111",,
+"DMAC","CHCR","STC","28","c5_space_wait_cycle_selection","0",,
+"DMAC","CHCR","STC","28","c6_space_wait_cycle_selection","1",,
+"DMAC","CHCR","DSA","27-25","reserved_in_pcmcia_access","0b000",,
+"DMAC","CHCR","DSA","27-25","dynamic_bus_sizing_io_space","0b001",,
+"DMAC","CHCR","DSA","27-25","8_bit_io_space","0b010",,
+"DMAC","CHCR","DSA","27-25","16_bit_io_space","0b011",,
+"DMAC","CHCR","DSA","27-25","8_bit_common_memory_space","0b100",,
+"DMAC","CHCR","DSA","27-25","16_bit_common_memory_space","0b101",,
+"DMAC","CHCR","DSA","27-25","8_bit_attribute_memory_space","0b110",,
+"DMAC","CHCR","DSA","27-25","16_bit_attribute_memory_space","0b111",,
+"DMAC","CHCR","DTC","24","c5_space_wait_cycle_selection","0",,
+"DMAC","CHCR","DTC","24","c6_space_wait_cycle_selection","1",,
+"DMAC","CHCR","DS","19","low_level_detection","0",,
+"DMAC","CHCR","DS","19","falling_edge_detection","1",,
+"DMAC","CHCR","RL","18","drak_is_an_active_high","0",,
+"DMAC","CHCR","RL","18","drak_is_an_active_low","1",,
+"DMAC","CHCR","AM","17","dack_is_output_in_read_cycle","0",,
+"DMAC","CHCR","AM","17","dack_is_output_in_write_cycle","1",,
+"DMAC","CHCR","AL","16","active_high_output","0",,
+"DMAC","CHCR","AL","16","active_low_output","1",,
+"DMAC","CHCR","DM","15-14","destination_address_fixed","0b00",,
+"DMAC","CHCR","DM","15-14","destination_address_incremented","0b01",,
+"DMAC","CHCR","DM","15-14","destination_address_decremented","0b10",,
+"DMAC","CHCR","SM","13-12","source_address_fixed","0b00",,
+"DMAC","CHCR","SM","13-12","source_address_incremented","0b01",,
+"DMAC","CHCR","SM","13-12","source_address_decremented","0b10",,
+"DMAC","CHCR","RS","11-8","resource_select",,"0b1111",
+"DMAC","CHCR","TM","7","cycle_steal_mode","0",,
+"DMAC","CHCR","TM","7","cycle_burst_mode","1",,
+"DMAC","CHCR","TS","6-4","64_bit","0b000",,
+"DMAC","CHCR","TS","6-4","8_bit","0b001",,
+"DMAC","CHCR","TS","6-4","16_bit","0b010",,
+"DMAC","CHCR","TS","6-4","32_bit","0b011",,
+"DMAC","CHCR","TS","6-4","32_byte","0b100",,
+"DMAC","CHCR","IE","2","interrupt_request_not_generated","0",,
+"DMAC","CHCR","IE","2","interrupt_request_generated","1",,
+"DMAC","CHCR","TE","1","transfers_not_completed","0",,
+"DMAC","CHCR","TE","1","transfers_completed","1",,
+"DMAC","CHCR","DE","0","channel_operation_disabled","0",,
+"DMAC","CHCR","DE","0","channel_operation_enabled","1",,
+,,,,,,,
+"DMAC","DMAOR","DDT","15","normal_dma_mode","0",,
+"DMAC","DMAOR","DDT","15","on_demand_data_transfer_mode","1",,
+"DMAC","DMAOR","PR","9-8","ch0_ch1_ch2_ch3","0b00",,
+"DMAC","DMAOR","PR","9-8","ch0_ch2_ch3_ch1","0b01",,
+"DMAC","DMAOR","PR","9-8","ch2_ch0_ch1_ch3","0b10",,
+"DMAC","DMAOR","PR","9-8","round_robin","0b11",,
+"DMAC","DMAOR","AE","2","no_address_error__dma_transfer_enabled","0",,
+"DMAC","DMAOR","AE","2","address_error__dma_transfer_disabled","1",,
+"DMAC","DMAOR","NMIF","1","no_nmi__dma_transfer_enabled","0",,
+"DMAC","DMAOR","NMIF","1","nmi__dma_transfer_disabled","1",,
+"DMAC","DMAOR","DME","0","operation_disabled_on_all_channels","0",,
+"DMAC","DMAOR","DME","0","operation_enabled_on_all_channels","1",,
+,,,,,,,
+"INTC","ICR","NMIL","15","pin_input_level_is_low","0",,
+"INTC","ICR","NMIL","15","pin_input_level_is_high","1",,
+"INTC","ICR","MAI","14","interrupts_enabled_while_nmi_pin_is_low","0",,
+"INTC","ICR","MAI","14","interrupts_disabled_while_nmi_pin_is_low","1",,
+"INTC","ICR","NMIB","9","interrupt_requests_witheld","0",,
+"INTC","ICR","NMIB","9","interrupt_requests_detected","1",,
+"INTC","ICR","NMIE","8","interrupt_on_falling_edge_of_nmi","0",,
+"INTC","ICR","NMIE","8","interrupt_on_rising_edge_of_nmi","1",,
+"INTC","ICR","IRLM","7","level_encoded_interrupt_requests","0",,
+"INTC","ICR","IRLM","7","independent_interrupt_request","1",,
+,,,,,,,
+"INTC","IPRA",,"15-12","TMU0",,"0b1111",
+"INTC","IPRA",,"11-8","TMU1",,"0b1111",
+"INTC","IPRA",,"7-4","TMU2",,"0b1111",
+"INTC","IPRA",,"3-0","RTC",,"0b1111",
+,,,,,,,
+"INTC","IPRB",,"15-12","WDT",,"0b1111",
+"INTC","IPRB",,"11-8","REF",,"0b1111",
+"INTC","IPRB",,"7-4","SCI1",,"0b1111",
+,,,,,,,
+"INTC","IPRC",,"15-12","GPIO",,"0b1111",
+"INTC","IPRC",,"11-8","DMAC",,"0b1111",
+"INTC","IPRC",,"7-4","SCIF",,"0b1111",
+"INTC","IPRC",,"3-0","UDI",,"0b1111",
+,,,,,,,
+"TMU","TOCR","TCOE","0","tclk_is_external_clock_or_input_capture","0",,"Timer Clock Pin Control"
+"TMU","TOCR","TCOE","0","tclk_is_on_chip_rtc","1",,"Timer Clock Pin Control"
+,,,,,,,
+"TMU","TSTR","STR2","2","counter_start","1",,"Counter Start 2"
+"TMU","TSTR","STR1","1","counter_start","1",,"Counter Start 1"
+"TMU","TSTR","STR0","0","counter_start","1",,"Counter Start 0"
+,,,,,,,
+"TMU","TCR0",,"8","UNF","1",,"Underflow Flag"
+"TMU","TCR0",,"5","UNIE","1",,"Underflow Interrupt Control"
+"TMU","TCR0","CKEG","4-3","rising","0b00",,"Clock Edge"
+"TMU","TCR0","CKEG","4-3","falling","0b01",,"Clock Edge"
+"TMU","TCR0","CKEG","4-3","rising_falling","0b10",,"Clock Edge"
+"TMU","TCR0","TPSC","2-0","p_phi_4","0b000",,"Timer Prescaler"
+"TMU","TCR0","TPSC","2-0","p_phi_16","0b001",,"Timer Prescaler"
+"TMU","TCR0","TPSC","2-0","p_phi_64","0b010",,"Timer Prescaler"
+"TMU","TCR0","TPSC","2-0","p_phi_256","0b011",,"Timer Prescaler"
+"TMU","TCR0","TPSC","2-0","p_phi_1024","0b100",,"Timer Prescaler"
+"TMU","TCR0","TPSC","2-0","rtc_output","0b110",,"Timer Prescaler"
+"TMU","TCR0","TPSC","2-0","external","0b111",,"Timer Prescaler"
+,,,,,,,
+"TMU","TCR1",,"8","UNF","1",,"Underflow Flag"
+"TMU","TCR1",,"5","UNIE","1",,"Underflow Interrupt Control"
+"TMU","TCR1","CKEG","4-3","rising","0b00",,"Clock Edge"
+"TMU","TCR1","CKEG","4-3","falling","0b01",,"Clock Edge"
+"TMU","TCR1","CKEG","4-3","rising_falling","0b10",,"Clock Edge"
+"TMU","TCR1","TPSC","2-0","p_phi_4","0b000",,"Timer Prescaler"
+"TMU","TCR1","TPSC","2-0","p_phi_16","0b001",,"Timer Prescaler"
+"TMU","TCR1","TPSC","2-0","p_phi_64","0b010",,"Timer Prescaler"
+"TMU","TCR1","TPSC","2-0","p_phi_256","0b011",,"Timer Prescaler"
+"TMU","TCR1","TPSC","2-0","p_phi_1024","0b100",,"Timer Prescaler"
+"TMU","TCR1","TPSC","2-0","rtc_output","0b110",,"Timer Prescaler"
+"TMU","TCR1","TPSC","2-0","external","0b111",,"Timer Prescaler"
+,,,,,,,
+"TMU","TCR2",,"9","ICPF","1",,"Input Capture Interrupt Flag"
+"TMU","TCR2",,"8","UNF","1",,"Underflow Flag"
+"TMU","TCR2","ICPE","7-6","disabled","0b00",,"Input Capture Control"
+"TMU","TCR2","ICPE","7-6","enabled","0b10",,"Input Capture Control"
+"TMU","TCR2","ICPE","7-6","enabled_with_interrupts","0b11",,"Input Capture Control"
+"TMU","TCR2",,"5","UNIE","1",,"Underflow Interrupt Control"
+"TMU","TCR2","CKEG","4-3","rising","0b00",,"Clock Edge"
+"TMU","TCR2","CKEG","4-3","falling","0b01",,"Clock Edge"
+"TMU","TCR2","CKEG","4-3","rising_falling","0b10",,"Clock Edge"
+"TMU","TCR2","TPSC","2-0","p_phi_4","0b000",,"Timer Prescaler"
+"TMU","TCR2","TPSC","2-0","p_phi_16","0b001",,"Timer Prescaler"
+"TMU","TCR2","TPSC","2-0","p_phi_64","0b010",,"Timer Prescaler"
+"TMU","TCR2","TPSC","2-0","p_phi_256","0b011",,"Timer Prescaler"
+"TMU","TCR2","TPSC","2-0","p_phi_1024","0b100",,"Timer Prescaler"
+"TMU","TCR2","TPSC","2-0","rtc_output","0b110",,"Timer Prescaler"
+"TMU","TCR2","TPSC","2-0","external","0b111",,"Timer Prescaler"
+,,,,,,,
+"SCIF","SCSMR2","CHR","6","8_bit_data","0",,
+"SCIF","SCSMR2","CHR","6","7_bit_data","1",,
+"SCIF","SCSMR2","PE","5","parity_disabled","0",,
+"SCIF","SCSMR2","PE","5","parity_enabled","1",,
+"SCIF","SCSMR2","OE","4","even_parity","0",,
+"SCIF","SCSMR2","OE","4","odd_parity","1",,
+"SCIF","SCSMR2","STOP","3","1_stop_bit","0",,
+"SCIF","SCSMR2","STOP","3","2_stop_bits","1",,
+"SCIF","SCSMR2","CKS","1-0","p_phi_clock","0b00",,
+"SCIF","SCSMR2","CKS","1-0","p_phi_4_clock","0b01",,
+"SCIF","SCSMR2","CKS","1-0","p_phi_16_clock","0b10",,
+"SCIF","SCSMR2","CKS","1-0","p_phi_64_clock","0b11",,
+,,,,,,,
+"SCIF","SCSCR2","TIE","7","transmit_fifo_data_empty_interrupt_disabled","0",,
+"SCIF","SCSCR2","TIE","7","transmit_fifo_data_empty_interrupt_enabled","1",,
+"SCIF","SCSCR2","RIE","6","request_disabled","0",,
+"SCIF","SCSCR2","RIE","6","request_enabled","1",,
+"SCIF","SCSCR2","TE","5","transmission_disabled","0",,
+"SCIF","SCSCR2","TE","5","transmission_enabled","1",,
+"SCIF","SCSCR2","RE","4","reception_disabled","0",,
+"SCIF","SCSCR2","RE","4","reception_enabled","1",,
+"SCIF","SCSCR2","REIE","3","requests_disabled","0",,
+"SCIF","SCSCR2","REIE","3","requests_enabled","1",,
+"SCIF","SCSCR2","CKE1","1","sck2_pin_functions_as_input_pin","0",,
+"SCIF","SCSCR2","CKE1","1","sck2_pin_functions_as_clock_input","1",,
+,,,,,,,
+"SCIF","SCFSR2","PER3_0","15-12","number_of_parity_errors",,,
+"SCIF","SCFSR2","FER3_0","11-8","number_of_framing_errors",,,
+"SCIF","SCFSR2","ER","7","no_framing_error_or_parity_error","0",,
+"SCIF","SCFSR2","ER","7","framing_error_or_parity_error","1",,
+"SCIF","SCFSR2","TEND","6","transmission_in_progress","0",,
+"SCIF","SCFSR2","TEND","6","transmission_has_ended","1",,
+"SCIF","SCFSR2","TDFE","5","transmit_data_bytes_does_exceed_trigger","0",,
+"SCIF","SCFSR2","TDFE","5","transmit_data_bytes_does_not_exceed_trigger","1",,
+"SCIF","SCFSR2","BRK","4","break_not_received","0",,
+"SCIF","SCFSR2","BRK","4","break_received","1",,
+"SCIF","SCFSR2","FER","3","no_framing_error","0",,
+"SCIF","SCFSR2","FER","3","framing_error","1",,
+"SCIF","SCFSR2","PER","2","parity_error","0",,
+"SCIF","SCFSR2","PER","2","no_parity_error","1",,
+"SCIF","SCFSR2","RDF","1","receive_data_bytes_less_than_receive_trigger","0",,
+"SCIF","SCFSR2","RDF","1","receive_data_bytes_greater_than_or_equal_receive_trigger","1",,
+"SCIF","SCFSR2","DR","0","reception_is_in_progress","0",,
+"SCIF","SCFSR2","DR","0","no_further_data_has_arrived","1",,
+,,,,,,,
+"SCIF","SCFCR2","RTRG","7-6","trigger_on_1_byte","0b00",,
+"SCIF","SCFCR2","RTRG","7-6","trigger_on_4_bytes","0b01",,
+"SCIF","SCFCR2","RTRG","7-6","trigger_on_8_bytes","0b10",,
+"SCIF","SCFCR2","RTRG","7-6","trigger_on_14_byte","0b11",,
+"SCIF","SCFCR2","TTRG","5-4","trigger_on_8_bytes","0b00",,
+"SCIF","SCFCR2","TTRG","5-4","trigger_on_4_bytes","0b01",,
+"SCIF","SCFCR2","TTRG","5-4","trigger_on_2_bytes","0b10",,
+"SCIF","SCFCR2","TTRG","5-4","trigger_on_1_bytes","0b11",,
+"SCIF","SCFCR2","MCE","3","modem_signals_disabled","0",,
+"SCIF","SCFCR2","MCE","3","modem_signals_enabled","1",,
+"SCIF","SCFCR2","TFRST","2","reset_operation_disabled","0",,
+"SCIF","SCFCR2","TFRST","2","reset_operation_enabled","1",,
+"SCIF","SCFCR2","RFRST","1","reset_operation_disabled","0",,
+"SCIF","SCFCR2","RFRST","1","reset_operation_enabled","1",,
+"SCIF","SCFCR2","LOOP","0","loopback_test_disabled","0",,
+"SCIF","SCFCR2","LOOP","0","loopback_test_enabled","1",,
+,,,,,,,
+"SCIF","SCFDR2",,"12-8","transmit_data_bytes",,,
+"SCIF","SCFDR2",,"4-0","receive_data_bytes",,,
+,,,,,,,
+"SCIF","SCSPTR2","RTSIO","7","rtsdt_not_output_to_rts2","0",,
+"SCIF","SCSPTR2","RTSIO","7","rtsdt_output_to_rts2","1",,
+"SCIF","SCSPTR2","RTSDT","6","input_output_data_is_low_level","0",,
+"SCIF","SCSPTR2","RTSDT","6","input_output_data_is_high_level","1",,
+"SCIF","SCSPTR2","CTSIO","5","ctsdt_is_not_output_to_cts2","0",,
+"SCIF","SCSPTR2","CTSIO","5","ctsdt_is_output_to_cts2","1",,
+"SCIF","SCSPTR2","CTSDT","4","input_output_data_is_low_level","0",,
+"SCIF","SCSPTR2","CTSDT","4","input_output_data_is_high_level","1",,
+"SCIF","SCSPTR2","SPB2IO","1","spb2dt_is_not_output_to_txd2","0",,
+"SCIF","SCSPTR2","SPB2IO","1","spb2dt_is_output_to_txd2","1",,
+"SCIF","SCSPTR2","SPB2DT","0","input_output_data_is_low_level","0",,
+"SCIF","SCSPTR2","SPB2DT","0","input_output_data_is_high_level","1",,
diff --git a/regs/sh7091_bits.ods b/regs/sh7091_bits.ods
new file mode 100644
index 0000000000000000000000000000000000000000..747ad83c93fdcbe1508907da3dfb821d3bbc5b8c
GIT binary patch
literal 20874
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%0AwEbr=pn;8moZcS)_rM(0%p6Sz
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

literal 0
HcmV?d00001

diff --git a/runtime.cpp b/runtime.cpp
index bdd69a5..6460fe8 100644
--- a/runtime.cpp
+++ b/runtime.cpp
@@ -1,6 +1,6 @@
 #include <cstdint>
 
-#include "cache.hpp"
+#include "sh7091/cache.hpp"
 
 extern uint32_t __bss_link_start __asm("__bss_link_start");
 extern uint32_t __bss_link_end __asm("__bss_link_end");
diff --git a/serial_load.cpp b/serial_load.cpp
index 9e12807..31bda3c 100644
--- a/serial_load.cpp
+++ b/serial_load.cpp
@@ -1,8 +1,8 @@
 #include <cstdint>
 
-#include "sh7091.hpp"
-#include "sh7091_bits.hpp"
-#include "holly.hpp"
+#include "sh7091/sh7091.hpp"
+#include "sh7091/sh7091_bits.hpp"
+#include "holly/holly.hpp"
 
 enum load_command {
   CMD_NONE,
@@ -48,7 +48,8 @@ void debug(const char * s)
 {
   char c;
   while ((c = *s++)) {
-    while ((sh7091.SCIF.SCFSR2 & SCFSR2__TDFE) == 0);
+    using namespace scif;
+    while ((sh7091.SCIF.SCFSR2 & scfsr2::tdfe::bit_mask) == 0);
     sh7091.SCIF.SCFTDR2 = (uint8_t)c;
   }
 }
diff --git a/sh7091/cache.cpp b/sh7091/cache.cpp
new file mode 100644
index 0000000..f223b83
--- /dev/null
+++ b/sh7091/cache.cpp
@@ -0,0 +1,36 @@
+#include "type.hpp"
+#include "sh7091.hpp"
+#include "sh7091_bits.hpp"
+
+#include "cache.hpp"
+
+extern volatile reg32 sh7091_ic_a[256][(1 << 5) / 4] __asm("sh7091_ic_a");
+extern volatile reg32 sh7091_oc_a[512][(1 << 5) / 4] __asm("sh7091_oc_a");
+
+namespace cache {
+
+void init()
+{
+  for (int i = 0; i < 256; i++) {
+    sh7091_ic_a[i][0] = 0;
+  }
+
+  for (int i = 0; i < 512; i++) {
+    sh7091_oc_a[i][0] = 0;
+  }
+
+  using namespace ccn::ccr;
+
+  sh7091.CCN.CCR = ici::clear_v_bits_of_all_ic_entries       // instruction cache invalidate
+                 | ice::ic_used                              // instruction cache enable
+                 | oci::clear_v_and_u_bits_of_all_oc_entries // operand cache invalidate
+                 | oce::oc_used                              // operand cache enable
+              // | cb::copy_back_mode                        // enable copy-back mode for the P1 area
+                 ;
+
+  sh7091.CCN.MMUCR = ccn::mmucr::at::mmu_disabled;
+
+  asm volatile ("nop;nop;nop;nop;nop;nop;nop;nop;");
+}
+
+}
diff --git a/cache.hpp b/sh7091/cache.hpp
similarity index 100%
rename from cache.hpp
rename to sh7091/cache.hpp
diff --git a/imask.hpp b/sh7091/imask.hpp
similarity index 100%
rename from imask.hpp
rename to sh7091/imask.hpp
diff --git a/serial.cpp b/sh7091/serial.cpp
similarity index 100%
rename from serial.cpp
rename to sh7091/serial.cpp
diff --git a/serial.hpp b/sh7091/serial.hpp
similarity index 100%
rename from serial.hpp
rename to sh7091/serial.hpp
diff --git a/sh7091.hpp b/sh7091/sh7091.hpp
similarity index 99%
rename from sh7091.hpp
rename to sh7091/sh7091.hpp
index 0eb68ba..6119f15 100644
--- a/sh7091.hpp
+++ b/sh7091/sh7091.hpp
@@ -90,9 +90,9 @@ struct bsc_reg {
   reg8  _pad7[2];
   reg16 GPIOIC;            /* GPIO interrupt control register */
   reg8  _pad8[1048502];
-  reg8  SDMR2[65536];      /* Synchronous DRAM mode registers */
+  reg32 SDMR2[16384];      /* Synchronous DRAM mode registers */
   reg8  _pad9[196608];
-  reg8  SDMR3[65536];      /* Synchronous DRAM mode registers */
+  reg32 SDMR3[16384];      /* Synchronous DRAM mode registers */
 };
 
 static_assert((offsetof (struct bsc_reg, BCR1)) == 0x0);
diff --git a/sh7091/sh7091_bits.hpp b/sh7091/sh7091_bits.hpp
new file mode 100644
index 0000000..13ff73e
--- /dev/null
+++ b/sh7091/sh7091_bits.hpp
@@ -0,0 +1,822 @@
+#pragma once
+
+#include <cstdint>
+
+#include "../float_uint32.hpp"
+
+namespace ccn {
+  namespace pteh {
+    constexpr uint32_t VPN(uint32_t reg) { return (reg >> 10) & 0x3fffff; }
+    constexpr uint32_t ASID(uint32_t reg) { return (reg >> 0) & 0xff; }
+  }
+
+  namespace ptel {
+    constexpr uint32_t PPN(uint32_t reg) { return (reg >> 10) & 0x7ffff; }
+
+    namespace v {
+      constexpr uint32_t invalid = 0 << 8;
+      constexpr uint32_t valid = 1 << 8;
+
+      constexpr uint32_t bit_mask = 0x1 << 8;
+    }
+
+    namespace sz {
+      constexpr uint32_t _1_kbyte_page = 0b0000 << 4;
+      constexpr uint32_t _4_kbyte_page = 0b0001 << 4;
+      constexpr uint32_t _64_kbyte_page = 0b1000 << 4;
+      constexpr uint32_t _1_mbyte_page = 0b1001 << 4;
+
+      constexpr uint32_t bit_mask = 0xf << 4;
+    }
+
+    namespace pr {
+      constexpr uint32_t read_only_in_privileged_mode = 0b00 << 5;
+      constexpr uint32_t read_write_in_privileged_mode = 0b01 << 5;
+      constexpr uint32_t read_only_in_privileged_and_user_mode = 0b10 << 5;
+      constexpr uint32_t read_write_in_privileged_and_user_mode = 0b11 << 5;
+
+      constexpr uint32_t bit_mask = 0x3 << 5;
+    }
+
+    namespace c {
+      constexpr uint32_t not_cacheable = 0 << 3;
+      constexpr uint32_t cacheable = 1 << 3;
+
+      constexpr uint32_t bit_mask = 0x1 << 3;
+    }
+
+    namespace d {
+      constexpr uint32_t write_has_not_been_performed = 0 << 2;
+      constexpr uint32_t write_has_been_performed = 1 << 2;
+
+      constexpr uint32_t bit_mask = 0x1 << 2;
+    }
+
+    namespace sh {
+      constexpr uint32_t pages_are_shared_by_processes = 0 << 1;
+      constexpr uint32_t pages_are_not_shared_by_processes = 1 << 1;
+
+      constexpr uint32_t bit_mask = 0x1 << 1;
+    }
+
+    namespace wt {
+      constexpr uint32_t copy_back_mode = 0 << 0;
+      constexpr uint32_t write_through_mode = 1 << 0;
+
+      constexpr uint32_t bit_mask = 0x1 << 0;
+    }
+  }
+
+  namespace mmucr {
+    constexpr uint32_t LRUI(uint32_t reg) { return (reg >> 26) & 0x3f; }
+    constexpr uint32_t URB(uint32_t reg) { return (reg >> 18) & 0x3f; }
+    constexpr uint32_t URC(uint32_t reg) { return (reg >> 10) & 0x3f; }
+
+    namespace sqmd {
+      constexpr uint32_t user_privileged_access_possible = 0 << 9;
+      constexpr uint32_t privileged_access_possible = 1 << 9;
+
+      constexpr uint32_t bit_mask = 0x1 << 9;
+    }
+
+    namespace sv {
+      constexpr uint32_t multiple_virtual_memory_mode = 0 << 8;
+      constexpr uint32_t single_virtual_memory_mode = 1 << 8;
+
+      constexpr uint32_t bit_mask = 0x1 << 8;
+    }
+
+    namespace ti {
+      constexpr uint32_t invalidate_all_utlb_itlb_bits = 1 << 2;
+
+      constexpr uint32_t bit_mask = 0x1 << 2;
+    }
+
+    namespace at {
+      constexpr uint32_t mmu_disabled = 0 << 0;
+      constexpr uint32_t mmu_enabled = 1 << 0;
+
+      constexpr uint32_t bit_mask = 0x1 << 0;
+    }
+  }
+
+  namespace basra {
+    constexpr uint32_t basa(uint32_t num) { return (num & 0xff) << 0; }
+  }
+
+  namespace basrb {
+    constexpr uint32_t basa(uint32_t num) { return (num & 0xff) << 0; }
+  }
+
+  namespace ccr {
+    namespace iix {
+      constexpr uint32_t address_bits_12_5_used_for_ic_entry_selection = 0 << 15;
+      constexpr uint32_t address_bits_25_and_11_5_used_for_ic_entry_selection = 1 << 15;
+
+      constexpr uint32_t bit_mask = 0x1 << 15;
+    }
+
+    namespace ici {
+      constexpr uint32_t clear_v_bits_of_all_ic_entries = 1 << 11;
+
+      constexpr uint32_t bit_mask = 0x1 << 11;
+    }
+
+    namespace ice {
+      constexpr uint32_t ic_not_used = 0 << 8;
+      constexpr uint32_t ic_used = 1 << 8;
+
+      constexpr uint32_t bit_mask = 0x1 << 8;
+    }
+
+    namespace oix {
+      constexpr uint32_t address_bits_13_5_used_for_oc_entry_selection = 0 << 7;
+      constexpr uint32_t address_bits_25_and_12_5_used_for_oc_entry_selection = 1 << 7;
+
+      constexpr uint32_t bit_mask = 0x1 << 7;
+    }
+
+    namespace ora {
+      constexpr uint32_t _16_kbytes_used_as_cache = 0 << 5;
+      constexpr uint32_t _8_kbytes_used_as_cache_8_kbytes_used_as_ram = 1 << 5;
+
+      constexpr uint32_t bit_mask = 0x1 << 5;
+    }
+
+    namespace oci {
+      constexpr uint32_t clear_v_and_u_bits_of_all_oc_entries = 1 << 3;
+
+      constexpr uint32_t bit_mask = 0x1 << 3;
+    }
+
+    namespace cb {
+      constexpr uint32_t write_through_mode = 0 << 2;
+      constexpr uint32_t copy_back_mode = 1 << 2;
+
+      constexpr uint32_t bit_mask = 0x1 << 2;
+    }
+
+    namespace wt {
+      constexpr uint32_t copy_back_mode = 0 << 1;
+      constexpr uint32_t write_through_mode = 1 << 1;
+
+      constexpr uint32_t bit_mask = 0x1 << 1;
+    }
+
+    namespace oce {
+      constexpr uint32_t oc_not_used = 0 << 0;
+      constexpr uint32_t oc_used = 1 << 0;
+
+      constexpr uint32_t bit_mask = 0x1 << 0;
+    }
+  }
+
+  namespace tra {
+    constexpr uint32_t imm(uint32_t reg) { return (reg >> 2) & 0xff; }
+  }
+
+  namespace expevt {
+    constexpr uint32_t exception_code(uint32_t reg) { return (reg >> 0) & 0xfff; }
+  }
+
+  namespace intevt {
+    constexpr uint32_t exception_code(uint32_t reg) { return (reg >> 0) & 0xfff; }
+  }
+
+  namespace ptea {
+    namespace tc {
+      constexpr uint32_t area_5_is_used = 0 << 3;
+      constexpr uint32_t area_6_is_used = 1 << 3;
+
+      constexpr uint32_t bit_mask = 0x1 << 3;
+    }
+
+    namespace sa {
+      constexpr uint32_t undefined = 0b000 << 0;
+      constexpr uint32_t variable_size_io_space = 0b001 << 0;
+      constexpr uint32_t _8_bit_io_space = 0b010 << 0;
+      constexpr uint32_t _16_bit_io_space = 0b011 << 0;
+      constexpr uint32_t _8_bit_common_memory_space = 0b100 << 0;
+      constexpr uint32_t _16_bit_common_memory_space = 0b101 << 0;
+      constexpr uint32_t _8_bit_attribute_memory_space = 0b110 << 0;
+      constexpr uint32_t _16_bit_attribute_memory_space = 0b111 << 0;
+
+      constexpr uint32_t bit_mask = 0x7 << 0;
+    }
+  }
+
+  namespace qacr0 {
+    constexpr uint32_t area(uint32_t num) { return (num & 0x7) << 2; }
+  }
+
+  namespace qacr1 {
+    constexpr uint32_t area(uint32_t num) { return (num & 0x7) << 2; }
+  }
+
+}
+
+namespace dmac {
+  namespace dmatcr {
+    constexpr uint32_t transfer_count(uint32_t num) { return (num & 0xffffff) << 0; }
+  }
+
+  namespace chcr {
+    namespace ssa {
+      constexpr uint32_t reserved_in_pcmcia_access = 0b000 << 29;
+      constexpr uint32_t dynamic_bus_sizing_io_space = 0b001 << 29;
+      constexpr uint32_t _8_bit_io_space = 0b010 << 29;
+      constexpr uint32_t _16_bit_io_space = 0b011 << 29;
+      constexpr uint32_t _8_bit_common_memory_space = 0b100 << 29;
+      constexpr uint32_t _16_bit_common_memory_space = 0b101 << 29;
+      constexpr uint32_t _8_bit_attribute_memory_space = 0b110 << 29;
+      constexpr uint32_t _16_bit_attribute_memory_space = 0b111 << 29;
+
+      constexpr uint32_t bit_mask = 0x7 << 29;
+    }
+
+    namespace stc {
+      constexpr uint32_t c5_space_wait_cycle_selection = 0 << 28;
+      constexpr uint32_t c6_space_wait_cycle_selection = 1 << 28;
+
+      constexpr uint32_t bit_mask = 0x1 << 28;
+    }
+
+    namespace dsa {
+      constexpr uint32_t reserved_in_pcmcia_access = 0b000 << 25;
+      constexpr uint32_t dynamic_bus_sizing_io_space = 0b001 << 25;
+      constexpr uint32_t _8_bit_io_space = 0b010 << 25;
+      constexpr uint32_t _16_bit_io_space = 0b011 << 25;
+      constexpr uint32_t _8_bit_common_memory_space = 0b100 << 25;
+      constexpr uint32_t _16_bit_common_memory_space = 0b101 << 25;
+      constexpr uint32_t _8_bit_attribute_memory_space = 0b110 << 25;
+      constexpr uint32_t _16_bit_attribute_memory_space = 0b111 << 25;
+
+      constexpr uint32_t bit_mask = 0x7 << 25;
+    }
+
+    namespace dtc {
+      constexpr uint32_t c5_space_wait_cycle_selection = 0 << 24;
+      constexpr uint32_t c6_space_wait_cycle_selection = 1 << 24;
+
+      constexpr uint32_t bit_mask = 0x1 << 24;
+    }
+
+    namespace ds {
+      constexpr uint32_t low_level_detection = 0 << 19;
+      constexpr uint32_t falling_edge_detection = 1 << 19;
+
+      constexpr uint32_t bit_mask = 0x1 << 19;
+    }
+
+    namespace rl {
+      constexpr uint32_t drak_is_an_active_high = 0 << 18;
+      constexpr uint32_t drak_is_an_active_low = 1 << 18;
+
+      constexpr uint32_t bit_mask = 0x1 << 18;
+    }
+
+    namespace am {
+      constexpr uint32_t dack_is_output_in_read_cycle = 0 << 17;
+      constexpr uint32_t dack_is_output_in_write_cycle = 1 << 17;
+
+      constexpr uint32_t bit_mask = 0x1 << 17;
+    }
+
+    namespace al {
+      constexpr uint32_t active_high_output = 0 << 16;
+      constexpr uint32_t active_low_output = 1 << 16;
+
+      constexpr uint32_t bit_mask = 0x1 << 16;
+    }
+
+    namespace dm {
+      constexpr uint32_t destination_address_fixed = 0b00 << 14;
+      constexpr uint32_t destination_address_incremented = 0b01 << 14;
+      constexpr uint32_t destination_address_decremented = 0b10 << 14;
+
+      constexpr uint32_t bit_mask = 0x3 << 14;
+    }
+
+    namespace sm {
+      constexpr uint32_t source_address_fixed = 0b00 << 12;
+      constexpr uint32_t source_address_incremented = 0b01 << 12;
+      constexpr uint32_t source_address_decremented = 0b10 << 12;
+
+      constexpr uint32_t bit_mask = 0x3 << 12;
+    }
+
+    namespace rs {
+      constexpr uint32_t resource_select(uint32_t num) { return (num & 0xf) << 8; }
+
+      constexpr uint32_t bit_mask = 0xf << 8;
+    }
+
+    namespace tm {
+      constexpr uint32_t cycle_steal_mode = 0 << 7;
+      constexpr uint32_t cycle_burst_mode = 1 << 7;
+
+      constexpr uint32_t bit_mask = 0x1 << 7;
+    }
+
+    namespace ts {
+      constexpr uint32_t _64_bit = 0b000 << 4;
+      constexpr uint32_t _8_bit = 0b001 << 4;
+      constexpr uint32_t _16_bit = 0b010 << 4;
+      constexpr uint32_t _32_bit = 0b011 << 4;
+      constexpr uint32_t _32_byte = 0b100 << 4;
+
+      constexpr uint32_t bit_mask = 0x7 << 4;
+    }
+
+    namespace ie {
+      constexpr uint32_t interrupt_request_not_generated = 0 << 2;
+      constexpr uint32_t interrupt_request_generated = 1 << 2;
+
+      constexpr uint32_t bit_mask = 0x1 << 2;
+    }
+
+    namespace te {
+      constexpr uint32_t transfers_not_completed = 0 << 1;
+      constexpr uint32_t transfers_completed = 1 << 1;
+
+      constexpr uint32_t bit_mask = 0x1 << 1;
+    }
+
+    namespace de {
+      constexpr uint32_t channel_operation_disabled = 0 << 0;
+      constexpr uint32_t channel_operation_enabled = 1 << 0;
+
+      constexpr uint32_t bit_mask = 0x1 << 0;
+    }
+  }
+
+  namespace dmaor {
+    namespace ddt {
+      constexpr uint32_t normal_dma_mode = 0 << 15;
+      constexpr uint32_t on_demand_data_transfer_mode = 1 << 15;
+
+      constexpr uint32_t bit_mask = 0x1 << 15;
+    }
+
+    namespace pr {
+      constexpr uint32_t ch0_ch1_ch2_ch3 = 0b00 << 8;
+      constexpr uint32_t ch0_ch2_ch3_ch1 = 0b01 << 8;
+      constexpr uint32_t ch2_ch0_ch1_ch3 = 0b10 << 8;
+      constexpr uint32_t round_robin = 0b11 << 8;
+
+      constexpr uint32_t bit_mask = 0x3 << 8;
+    }
+
+    namespace ae {
+      constexpr uint32_t no_address_error__dma_transfer_enabled = 0 << 2;
+      constexpr uint32_t address_error__dma_transfer_disabled = 1 << 2;
+
+      constexpr uint32_t bit_mask = 0x1 << 2;
+    }
+
+    namespace nmif {
+      constexpr uint32_t no_nmi__dma_transfer_enabled = 0 << 1;
+      constexpr uint32_t nmi__dma_transfer_disabled = 1 << 1;
+
+      constexpr uint32_t bit_mask = 0x1 << 1;
+    }
+
+    namespace dme {
+      constexpr uint32_t operation_disabled_on_all_channels = 0 << 0;
+      constexpr uint32_t operation_enabled_on_all_channels = 1 << 0;
+
+      constexpr uint32_t bit_mask = 0x1 << 0;
+    }
+  }
+
+}
+
+namespace intc {
+  namespace icr {
+    namespace nmil {
+      constexpr uint32_t pin_input_level_is_low = 0 << 15;
+      constexpr uint32_t pin_input_level_is_high = 1 << 15;
+
+      constexpr uint32_t bit_mask = 0x1 << 15;
+    }
+
+    namespace mai {
+      constexpr uint32_t interrupts_enabled_while_nmi_pin_is_low = 0 << 14;
+      constexpr uint32_t interrupts_disabled_while_nmi_pin_is_low = 1 << 14;
+
+      constexpr uint32_t bit_mask = 0x1 << 14;
+    }
+
+    namespace nmib {
+      constexpr uint32_t interrupt_requests_witheld = 0 << 9;
+      constexpr uint32_t interrupt_requests_detected = 1 << 9;
+
+      constexpr uint32_t bit_mask = 0x1 << 9;
+    }
+
+    namespace nmie {
+      constexpr uint32_t interrupt_on_falling_edge_of_nmi = 0 << 8;
+      constexpr uint32_t interrupt_on_rising_edge_of_nmi = 1 << 8;
+
+      constexpr uint32_t bit_mask = 0x1 << 8;
+    }
+
+    namespace irlm {
+      constexpr uint32_t level_encoded_interrupt_requests = 0 << 7;
+      constexpr uint32_t independent_interrupt_request = 1 << 7;
+
+      constexpr uint32_t bit_mask = 0x1 << 7;
+    }
+  }
+
+  namespace ipra {
+    constexpr uint32_t TMU0(uint32_t num) { return (num & 0xf) << 12; }
+    constexpr uint32_t TMU1(uint32_t num) { return (num & 0xf) << 8; }
+    constexpr uint32_t TMU2(uint32_t num) { return (num & 0xf) << 4; }
+    constexpr uint32_t RTC(uint32_t num) { return (num & 0xf) << 0; }
+  }
+
+  namespace iprb {
+    constexpr uint32_t WDT(uint32_t num) { return (num & 0xf) << 12; }
+    constexpr uint32_t REF(uint32_t num) { return (num & 0xf) << 8; }
+    constexpr uint32_t SCI1(uint32_t num) { return (num & 0xf) << 4; }
+  }
+
+  namespace iprc {
+    constexpr uint32_t GPIO(uint32_t num) { return (num & 0xf) << 12; }
+    constexpr uint32_t DMAC(uint32_t num) { return (num & 0xf) << 8; }
+    constexpr uint32_t SCIF(uint32_t num) { return (num & 0xf) << 4; }
+    constexpr uint32_t UDI(uint32_t num) { return (num & 0xf) << 0; }
+  }
+
+}
+
+namespace tmu {
+  namespace tocr {
+    namespace tcoe {
+      constexpr uint32_t tclk_is_external_clock_or_input_capture = 0 << 0;
+      constexpr uint32_t tclk_is_on_chip_rtc = 1 << 0;
+
+      constexpr uint32_t bit_mask = 0x1 << 0;
+    }
+  }
+
+  namespace tstr {
+    namespace str2 {
+      constexpr uint32_t counter_start = 1 << 2;
+
+      constexpr uint32_t bit_mask = 0x1 << 2;
+    }
+
+    namespace str1 {
+      constexpr uint32_t counter_start = 1 << 1;
+
+      constexpr uint32_t bit_mask = 0x1 << 1;
+    }
+
+    namespace str0 {
+      constexpr uint32_t counter_start = 1 << 0;
+
+      constexpr uint32_t bit_mask = 0x1 << 0;
+    }
+  }
+
+  namespace tcr0 {
+    constexpr uint32_t UNF = 1 << 8;
+    constexpr uint32_t UNIE = 1 << 5;
+
+    namespace ckeg {
+      constexpr uint32_t rising = 0b00 << 3;
+      constexpr uint32_t falling = 0b01 << 3;
+      constexpr uint32_t rising_falling = 0b10 << 3;
+
+      constexpr uint32_t bit_mask = 0x3 << 3;
+    }
+
+    namespace tpsc {
+      constexpr uint32_t p_phi_4 = 0b000 << 0;
+      constexpr uint32_t p_phi_16 = 0b001 << 0;
+      constexpr uint32_t p_phi_64 = 0b010 << 0;
+      constexpr uint32_t p_phi_256 = 0b011 << 0;
+      constexpr uint32_t p_phi_1024 = 0b100 << 0;
+      constexpr uint32_t rtc_output = 0b110 << 0;
+      constexpr uint32_t external = 0b111 << 0;
+
+      constexpr uint32_t bit_mask = 0x7 << 0;
+    }
+  }
+
+  namespace tcr1 {
+    constexpr uint32_t UNF = 1 << 8;
+    constexpr uint32_t UNIE = 1 << 5;
+
+    namespace ckeg {
+      constexpr uint32_t rising = 0b00 << 3;
+      constexpr uint32_t falling = 0b01 << 3;
+      constexpr uint32_t rising_falling = 0b10 << 3;
+
+      constexpr uint32_t bit_mask = 0x3 << 3;
+    }
+
+    namespace tpsc {
+      constexpr uint32_t p_phi_4 = 0b000 << 0;
+      constexpr uint32_t p_phi_16 = 0b001 << 0;
+      constexpr uint32_t p_phi_64 = 0b010 << 0;
+      constexpr uint32_t p_phi_256 = 0b011 << 0;
+      constexpr uint32_t p_phi_1024 = 0b100 << 0;
+      constexpr uint32_t rtc_output = 0b110 << 0;
+      constexpr uint32_t external = 0b111 << 0;
+
+      constexpr uint32_t bit_mask = 0x7 << 0;
+    }
+  }
+
+  namespace tcr2 {
+    constexpr uint32_t ICPF = 1 << 9;
+    constexpr uint32_t UNF = 1 << 8;
+
+    namespace icpe {
+      constexpr uint32_t disabled = 0b00 << 6;
+      constexpr uint32_t enabled = 0b10 << 6;
+      constexpr uint32_t enabled_with_interrupts = 0b11 << 6;
+
+      constexpr uint32_t bit_mask = 0x3 << 6;
+    }
+
+    constexpr uint32_t UNIE = 1 << 5;
+
+    namespace ckeg {
+      constexpr uint32_t rising = 0b00 << 3;
+      constexpr uint32_t falling = 0b01 << 3;
+      constexpr uint32_t rising_falling = 0b10 << 3;
+
+      constexpr uint32_t bit_mask = 0x3 << 3;
+    }
+
+    namespace tpsc {
+      constexpr uint32_t p_phi_4 = 0b000 << 0;
+      constexpr uint32_t p_phi_16 = 0b001 << 0;
+      constexpr uint32_t p_phi_64 = 0b010 << 0;
+      constexpr uint32_t p_phi_256 = 0b011 << 0;
+      constexpr uint32_t p_phi_1024 = 0b100 << 0;
+      constexpr uint32_t rtc_output = 0b110 << 0;
+      constexpr uint32_t external = 0b111 << 0;
+
+      constexpr uint32_t bit_mask = 0x7 << 0;
+    }
+  }
+
+}
+
+namespace scif {
+  namespace scsmr2 {
+    namespace chr {
+      constexpr uint32_t _8_bit_data = 0 << 6;
+      constexpr uint32_t _7_bit_data = 1 << 6;
+
+      constexpr uint32_t bit_mask = 0x1 << 6;
+    }
+
+    namespace pe {
+      constexpr uint32_t parity_disabled = 0 << 5;
+      constexpr uint32_t parity_enabled = 1 << 5;
+
+      constexpr uint32_t bit_mask = 0x1 << 5;
+    }
+
+    namespace oe {
+      constexpr uint32_t even_parity = 0 << 4;
+      constexpr uint32_t odd_parity = 1 << 4;
+
+      constexpr uint32_t bit_mask = 0x1 << 4;
+    }
+
+    namespace stop {
+      constexpr uint32_t _1_stop_bit = 0 << 3;
+      constexpr uint32_t _2_stop_bits = 1 << 3;
+
+      constexpr uint32_t bit_mask = 0x1 << 3;
+    }
+
+    namespace cks {
+      constexpr uint32_t p_phi_clock = 0b00 << 0;
+      constexpr uint32_t p_phi_4_clock = 0b01 << 0;
+      constexpr uint32_t p_phi_16_clock = 0b10 << 0;
+      constexpr uint32_t p_phi_64_clock = 0b11 << 0;
+
+      constexpr uint32_t bit_mask = 0x3 << 0;
+    }
+  }
+
+  namespace scscr2 {
+    namespace tie {
+      constexpr uint32_t transmit_fifo_data_empty_interrupt_disabled = 0 << 7;
+      constexpr uint32_t transmit_fifo_data_empty_interrupt_enabled = 1 << 7;
+
+      constexpr uint32_t bit_mask = 0x1 << 7;
+    }
+
+    namespace rie {
+      constexpr uint32_t request_disabled = 0 << 6;
+      constexpr uint32_t request_enabled = 1 << 6;
+
+      constexpr uint32_t bit_mask = 0x1 << 6;
+    }
+
+    namespace te {
+      constexpr uint32_t transmission_disabled = 0 << 5;
+      constexpr uint32_t transmission_enabled = 1 << 5;
+
+      constexpr uint32_t bit_mask = 0x1 << 5;
+    }
+
+    namespace re {
+      constexpr uint32_t reception_disabled = 0 << 4;
+      constexpr uint32_t reception_enabled = 1 << 4;
+
+      constexpr uint32_t bit_mask = 0x1 << 4;
+    }
+
+    namespace reie {
+      constexpr uint32_t requests_disabled = 0 << 3;
+      constexpr uint32_t requests_enabled = 1 << 3;
+
+      constexpr uint32_t bit_mask = 0x1 << 3;
+    }
+
+    namespace cke1 {
+      constexpr uint32_t sck2_pin_functions_as_input_pin = 0 << 1;
+      constexpr uint32_t sck2_pin_functions_as_clock_input = 1 << 1;
+
+      constexpr uint32_t bit_mask = 0x1 << 1;
+    }
+  }
+
+  namespace scfsr2 {
+    namespace per3_0 {
+      constexpr uint32_t number_of_parity_errors(uint32_t reg) { return (reg >> 12) & 0xf; }
+
+      constexpr uint32_t bit_mask = 0xf << 12;
+    }
+
+    namespace fer3_0 {
+      constexpr uint32_t number_of_framing_errors(uint32_t reg) { return (reg >> 8) & 0xf; }
+
+      constexpr uint32_t bit_mask = 0xf << 8;
+    }
+
+    namespace er {
+      constexpr uint32_t no_framing_error_or_parity_error = 0 << 7;
+      constexpr uint32_t framing_error_or_parity_error = 1 << 7;
+
+      constexpr uint32_t bit_mask = 0x1 << 7;
+    }
+
+    namespace tend {
+      constexpr uint32_t transmission_in_progress = 0 << 6;
+      constexpr uint32_t transmission_has_ended = 1 << 6;
+
+      constexpr uint32_t bit_mask = 0x1 << 6;
+    }
+
+    namespace tdfe {
+      constexpr uint32_t transmit_data_bytes_does_exceed_trigger = 0 << 5;
+      constexpr uint32_t transmit_data_bytes_does_not_exceed_trigger = 1 << 5;
+
+      constexpr uint32_t bit_mask = 0x1 << 5;
+    }
+
+    namespace brk {
+      constexpr uint32_t break_not_received = 0 << 4;
+      constexpr uint32_t break_received = 1 << 4;
+
+      constexpr uint32_t bit_mask = 0x1 << 4;
+    }
+
+    namespace fer {
+      constexpr uint32_t no_framing_error = 0 << 3;
+      constexpr uint32_t framing_error = 1 << 3;
+
+      constexpr uint32_t bit_mask = 0x1 << 3;
+    }
+
+    namespace per {
+      constexpr uint32_t parity_error = 0 << 2;
+      constexpr uint32_t no_parity_error = 1 << 2;
+
+      constexpr uint32_t bit_mask = 0x1 << 2;
+    }
+
+    namespace rdf {
+      constexpr uint32_t receive_data_bytes_less_than_receive_trigger = 0 << 1;
+      constexpr uint32_t receive_data_bytes_greater_than_or_equal_receive_trigger = 1 << 1;
+
+      constexpr uint32_t bit_mask = 0x1 << 1;
+    }
+
+    namespace dr {
+      constexpr uint32_t reception_is_in_progress = 0 << 0;
+      constexpr uint32_t no_further_data_has_arrived = 1 << 0;
+
+      constexpr uint32_t bit_mask = 0x1 << 0;
+    }
+  }
+
+  namespace scfcr2 {
+    namespace rtrg {
+      constexpr uint32_t trigger_on_1_byte = 0b00 << 6;
+      constexpr uint32_t trigger_on_4_bytes = 0b01 << 6;
+      constexpr uint32_t trigger_on_8_bytes = 0b10 << 6;
+      constexpr uint32_t trigger_on_14_byte = 0b11 << 6;
+
+      constexpr uint32_t bit_mask = 0x3 << 6;
+    }
+
+    namespace ttrg {
+      constexpr uint32_t trigger_on_8_bytes = 0b00 << 4;
+      constexpr uint32_t trigger_on_4_bytes = 0b01 << 4;
+      constexpr uint32_t trigger_on_2_bytes = 0b10 << 4;
+      constexpr uint32_t trigger_on_1_bytes = 0b11 << 4;
+
+      constexpr uint32_t bit_mask = 0x3 << 4;
+    }
+
+    namespace mce {
+      constexpr uint32_t modem_signals_disabled = 0 << 3;
+      constexpr uint32_t modem_signals_enabled = 1 << 3;
+
+      constexpr uint32_t bit_mask = 0x1 << 3;
+    }
+
+    namespace tfrst {
+      constexpr uint32_t reset_operation_disabled = 0 << 2;
+      constexpr uint32_t reset_operation_enabled = 1 << 2;
+
+      constexpr uint32_t bit_mask = 0x1 << 2;
+    }
+
+    namespace rfrst {
+      constexpr uint32_t reset_operation_disabled = 0 << 1;
+      constexpr uint32_t reset_operation_enabled = 1 << 1;
+
+      constexpr uint32_t bit_mask = 0x1 << 1;
+    }
+
+    namespace loop {
+      constexpr uint32_t loopback_test_disabled = 0 << 0;
+      constexpr uint32_t loopback_test_enabled = 1 << 0;
+
+      constexpr uint32_t bit_mask = 0x1 << 0;
+    }
+  }
+
+  namespace scfdr2 {
+    constexpr uint32_t transmit_data_bytes(uint32_t reg) { return (reg >> 8) & 0x1f; }
+    constexpr uint32_t receive_data_bytes(uint32_t reg) { return (reg >> 0) & 0x1f; }
+  }
+
+  namespace scsptr2 {
+    namespace rtsio {
+      constexpr uint32_t rtsdt_not_output_to_rts2 = 0 << 7;
+      constexpr uint32_t rtsdt_output_to_rts2 = 1 << 7;
+
+      constexpr uint32_t bit_mask = 0x1 << 7;
+    }
+
+    namespace rtsdt {
+      constexpr uint32_t input_output_data_is_low_level = 0 << 6;
+      constexpr uint32_t input_output_data_is_high_level = 1 << 6;
+
+      constexpr uint32_t bit_mask = 0x1 << 6;
+    }
+
+    namespace ctsio {
+      constexpr uint32_t ctsdt_is_not_output_to_cts2 = 0 << 5;
+      constexpr uint32_t ctsdt_is_output_to_cts2 = 1 << 5;
+
+      constexpr uint32_t bit_mask = 0x1 << 5;
+    }
+
+    namespace ctsdt {
+      constexpr uint32_t input_output_data_is_low_level = 0 << 4;
+      constexpr uint32_t input_output_data_is_high_level = 1 << 4;
+
+      constexpr uint32_t bit_mask = 0x1 << 4;
+    }
+
+    namespace spb2io {
+      constexpr uint32_t spb2dt_is_not_output_to_txd2 = 0 << 1;
+      constexpr uint32_t spb2dt_is_output_to_txd2 = 1 << 1;
+
+      constexpr uint32_t bit_mask = 0x1 << 1;
+    }
+
+    namespace spb2dt {
+      constexpr uint32_t input_output_data_is_low_level = 0 << 0;
+      constexpr uint32_t input_output_data_is_high_level = 1 << 0;
+
+      constexpr uint32_t bit_mask = 0x1 << 0;
+    }
+  }
+
+}
diff --git a/storequeue.cpp b/sh7091/storequeue.cpp
similarity index 100%
rename from storequeue.cpp
rename to sh7091/storequeue.cpp
diff --git a/storequeue.hpp b/sh7091/storequeue.hpp
similarity index 100%
rename from storequeue.hpp
rename to sh7091/storequeue.hpp
diff --git a/sh7091_bits.hpp b/sh7091_bits.hpp
deleted file mode 100644
index e5996c1..0000000
--- a/sh7091_bits.hpp
+++ /dev/null
@@ -1,101 +0,0 @@
-#define CCR__IIX (1 << 15)
-#define CCR__ICI (1 << 11)
-#define CCR__ICE (1 << 8)
-#define CCR__OIX (1 << 7)
-#define CCR__ORA (1 << 5)
-#define CCR__OCI (1 << 4)
-#define CCR__CB  (1 << 2)
-#define CCR__WT  (1 << 1)
-#define CCR__OCE (1 << 0)
-
-#define PDTRA__MASK     (0b11 << 8)
-#define PDTRA__VGA      (0b00 << 8)
-#define PDTRA__RESERVED (0b01 << 8)
-#define PDTRA__RGB      (0b10 << 8)
-#define PDTRA__AV       (0b11 << 8)
-
-#define SCFCR2__TFRST (1 << 2)
-#define SCFCR2__RFRST (1 << 1)
-
-#define SCSCR2__TE (1 << 5)
-#define SCSCR2__RE (1 << 4)
-
-#define SCFSR2__ER   (1 << 7) /* read error */
-#define SCFSR2__TEND (1 << 6) /* transmit end */
-#define SCFSR2__TDFE (1 << 5) /* transmit fifo data empty */
-#define SCFSR2__BRK  (1 << 4) /* break detect */
-#define SCFSR2__FER  (1 << 3) /* framing error */
-#define SCFSR2__PER  (1 << 2) /* parity error */
-#define SCFSR2__RDF  (1 << 1) /* receive FIFO data full */
-#define SCFSR2__DR   (1 << 0) /* receive data ready */
-
-#define DMAOR__DDT (1 << 15) /* on-demand data transfer mode */
-/* priority mode */
-#define DMAOR__PR__CH0_CH1_CH2_CH3 (0b11 << 8)
-#define DMAOR__PR__CH0_CH2_CH3_CH1 (0b01 << 8)
-#define DMAOR__PR__CH2_CH0_CH1_CH3 (0b10 << 8)
-#define DMAOR__PR__ROUND_ROBIN     (0b11 << 8)
-#define DMAOR__AE (1 << 2)  /* address error flag; clear-only */
-#define DMAOR__NMIF (1 << 1) /* non-maskable interrupt flag; clear-only */
-#define DMAOR__DME (1 << 0) /* DMAC master enable */
-
-/* source address space attribute specification */
-#define CHCR2__SSA__RESERVED_IN_PCMCIA_ACCESS    (0b000 << 29)
-#define CHCR2__SSA__DYNAMIC_BUS_SIZING_IO_SPACE  (0b001 << 29)
-#define CHCR2__SSA__8BIT_IO_SPACE                (0b010 << 29)
-#define CHCR2__SSA__16BIT_IO_SPACE               (0b011 << 29)
-#define CHCR2__SSA__8BIT_COMMON_MEMORY_SPACE     (0b100 << 29)
-#define CHCR2__SSA__16BIT_COMMON_MEMORY_SPACE    (0b101 << 29)
-#define CHCR2__SSA__8BIT_ATTRIBUTE_MEMORY_SPACE  (0b110 << 29)
-#define CHCR2__SSA__16BIT_ATTRIBUTE_MEMORY_SPACE (0b111 << 29)
-/* source address wait control select */
-#define CHCR2__STC__C5_SPACE_WAIT_CYCLE_SELECTION (0 << 28)
-#define CHCR2__STC__C6_SPACE_WAIT_CYCLE_SELECTION (1 << 28)
-/* destination address space attribute specification */
-#define CHCR2__DSA__RESERVED_IN_PCMCIA_ACCESS    (0b000 << 25)
-#define CHCR2__DSA__DYNAMIC_BUS_SIZING_IO_SPACE  (0b001 << 25)
-#define CHCR2__DSA__8BIT_IO_SPACE                (0b010 << 25)
-#define CHCR2__DSA__16BIT_IO_SPACE               (0b011 << 25)
-#define CHCR2__DSA__8BIT_COMMON_MEMORY_SPACE     (0b100 << 25)
-#define CHCR2__DSA__16BIT_COMMON_MEMORY_SPACE    (0b101 << 25)
-#define CHCR2__DSA__8BIT_ATTRIBUTE_MEMORY_SPACE  (0b110 << 25)
-#define CHCR2__DSA__16BIT_ATTRIBUTE_MEMORY_SPACE (0b111 << 25)
-/* destination address wait control select */
-#define CHCR2__DTC__C5_SPACE_WAIT_CYCLE_SELECTION (0 << 24)
-#define CHCR2__DTC__C6_SPACE_WAIT_CYCLE_SELECTION (1 << 24)
-/* DREQ select */
-#define CHCR2__DS__LOW_LEVEL_DETECTION    (0 << 19)
-#define CHCR2__DS__FALLING_EDGE_DETECTION (1 << 19)
-/* request check level */
-#define CHCR2__RL__DRAK_IS_AN_ACTIVE_HIGH_OUTPUT (0 << 18)
-#define CHCR2__RL__DRAK_IS_AN_ACTIVE_LOW_OUTPUT  (1 << 18)
-/* acknowledge mode */
-#define CHCR2__AM__DACK_IS_OUTPUT_IN_READ_CYCLE  (0 << 17)
-#define CHCR2__AM__DACK_IS_OUTPUT_IN_WRITE_CYCLE (1 << 17)
-/* acknowledge level */
-#define CHCR2__AL__ACTIVE_HIGH_OUTPUT (0 << 16)
-#define CHCR2__AL__ACTIVE_LOW_OUTPUT  (1 << 16)
-/* destination address mode */
-#define CHCR2__DM__DESTINATION_ADDRESS_FIXED       (0b00 << 14)
-#define CHCR2__DM__DESTINATION_ADDRESS_INCREMENTED (0b01 << 14)
-#define CHCR2__DM__DESTINATION_ADDRESS_DECREMENTED (0b10 << 14)
-/* source address mode */
-#define CHCR2__SM__SOURCE_ADDRESS_FIXED       (0b00 << 12)
-#define CHCR2__SM__SOURCE_ADDRESS_INCREMENTED (0b01 << 12)
-#define CHCR2__SM__SOURCE_ADDRESS_DECREMENTED (0b10 << 12)
-/* resource select */
-#define CHCR2__RS(n) (((n) & 0b1111) << 8)
-/* transmit mode */
-#define CHCR2__TM__CYCLE_STEAL_MODE (0 << 7)
-#define CHCR2__TM__BURST_MODE       (1 << 7)
-/* transmit size */
-#define CHCR2__TS__64_BIT  (0b000 << 4)
-#define CHCR2__TS__8_BIT   (0b001 << 4)
-#define CHCR2__TS__16_BIT  (0b010 << 4)
-#define CHCR2__TS__32_BIT  (0b011 << 4)
-#define CHCR2__TS__32_BYTE (0b100 << 4)
-#define CHCR2__IE  (1 << 2) /* interrupt enable */
-#define CHCR2__TE  (1 << 1) /* transfer end; clear only */
-#define CHCR2__DE  (1 << 0) /* DMAC (channel) enable */
-
-#define DMATCR2__TRANSFER_COUNT(n) (((n) & 0xffffff) << 0)
diff --git a/vga.cpp b/vga.cpp
index 82f4b81..7f4123c 100644
--- a/vga.cpp
+++ b/vga.cpp
@@ -1,8 +1,8 @@
 #include <cstdint>
 
-#include "sh7091.hpp"
-#include "sh7091_bits.hpp"
-#include "holly.hpp"
+#include "sh7091/sh7091.hpp"
+#include "sh7091/sh7091_bits.hpp"
+#include "holly/holly.hpp"
 #include "holly/core_bits.hpp"
 #include "aica.hpp"
 #include "memorymap.hpp"
@@ -10,14 +10,16 @@
 #include "vga.hpp"
 #include "rgb.hpp"
 
+/*
 uint32_t get_cable_type()
 {
-  /* set all pins to input */
+  // set all pins to input
   sh7091.BSC.PCTRA = 0;
 
-  /* get cable type from pins 9 + 8 */
+  // get cable type from pins 9 + 8
   return sh7091.BSC.PDTRA & PDTRA__MASK;
 }
+*/
 
 void vga1()
 {
@@ -117,8 +119,6 @@ void v_sync_out()
 
 void vga()
 {
-  get_cable_type();
-
   holly.SOFTRESET = softreset::sdram_if_soft_reset
 		  | softreset::pipeline_soft_reset
 		  | softreset::ta_soft_reset;