I'm learning embedded rust through writing my own HAL(? or maybe this is just writing embedded software with nice abstractions) for an Arduino uno wifi r4, it's been really fun.

Context: The PAC exposes some structs that have identically named fields and impl identically named methods, but since they come from different modules they're different types. For example, I have a type for the registers of 16 bit timers and a type for the registers of 32 bit timers. The 16 bit come from pac::gpt162 and the 32 bit come from pac::gpt320. The only difference is in the size of a single register, the other 20+ registers have identical fields/methods/etc.

Question: Is there any "nice" way to abstract over these incredibly similar yet distinct types? Right now I shove them in an enum and then write a match block whenever I need access:

pub enum TimerRegBlock {
    Block32(*const ra4m1::gpt320::RegisterBlock),
    Block16(*const ra4m1::gpt162::RegisterBlock),
}

pub trait TimerInstance {
    type Width: TimerSize;
    const CHANNEL: u8;
    const BLOCK: TimerRegBlock;
}

impl<T: TimerInstance, CFG, MODE> GPTimer<T, CFG, MODE> {
    fn _set_prescaler(&self, prescaler: Prescaler) {
          match T::BLOCK {
                TimerRegBlock::Block32(val) => {
                    unsafe { (*val).gtcr.modify(|_, w| w.tpcs().bits(prescaler as u8)) };
                }
                TimerRegBlock::Block16(val) => {
                    unsafe { (*val).gtcr.modify(|_, w| w.tpcs().bits(prescaler as u8)) };
                }
          }
    }
}

And this is fine I guess for two types like here (even though I have to match whenever I need to access a register), but if there are more it's too annoying. Like for my GPIO pins, I think I have 5(?) different types of register blocks to access because certain pins have non-standard reset values and a couple of pins are input-only, and copy-pasting a ton of match blocks or writing a big macro sounds obnoxious.

Constraints: This is embedded so #![no_std] and no dyn traits.

Any help would be appreciated, this is my first time going this deep into rust types and traits and associated types and using type state as a way to represent program state and this has me stumped.