From b200465cce6b6ab2c119993a3046e1db8c7e44e8 Mon Sep 17 00:00:00 2001
From: Etienne Wodey <wodey@iqo.uni-hannover.de>
Date: Mon, 9 Nov 2020 18:26:17 +0100
Subject: [PATCH] coredevice: adf5355: rename to adf5356

Signed-off-by: Etienne Wodey <wodey@iqo.uni-hannover.de>
---
 artiq/coredevice/adf5355_reg.py             | 742 --------------------
 artiq/coredevice/{adf5355.py => adf5356.py} | 183 ++---
 artiq/coredevice/adf5356_reg.py             | 642 +++++++++++++++++
 3 files changed, 736 insertions(+), 831 deletions(-)
 delete mode 100644 artiq/coredevice/adf5355_reg.py
 rename artiq/coredevice/{adf5355.py => adf5356.py} (69%)
 create mode 100644 artiq/coredevice/adf5356_reg.py

diff --git a/artiq/coredevice/adf5355_reg.py b/artiq/coredevice/adf5355_reg.py
deleted file mode 100644
index 9eb0830df..000000000
--- a/artiq/coredevice/adf5355_reg.py
+++ /dev/null
@@ -1,742 +0,0 @@
-# auto-generated, do not edit
-from artiq.language.core import portable
-from artiq.language.types import TInt32
-from numpy import int32
-
-
-@portable
-def ADF5355_REG0_AUTOCAL_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 21) & 0x1)
-
-
-@portable
-def ADF5355_REG0_AUTOCAL(x: TInt32) -> TInt32:
-    return int32((x & 0x1) << 21)
-
-
-@portable
-def ADF5355_REG0_AUTOCAL_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x1 << 21)) | ((x & 0x1) << 21))
-
-
-@portable
-def ADF5355_REG0_INT_VALUE_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 4) & 0xFFFF)
-
-
-@portable
-def ADF5355_REG0_INT_VALUE(x: TInt32) -> TInt32:
-    return int32((x & 0xFFFF) << 4)
-
-
-@portable
-def ADF5355_REG0_INT_VALUE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0xFFFF << 4)) | ((x & 0xFFFF) << 4))
-
-
-@portable
-def ADF5355_REG0_PRESCALER_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 20) & 0x1)
-
-
-@portable
-def ADF5355_REG0_PRESCALER(x: TInt32) -> TInt32:
-    return int32((x & 0x1) << 20)
-
-
-@portable
-def ADF5355_REG0_PRESCALER_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x1 << 20)) | ((x & 0x1) << 20))
-
-
-@portable
-def ADF5355_REG1_MAIN_FRAC_VALUE_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 4) & 0xFFFFFF)
-
-
-@portable
-def ADF5355_REG1_MAIN_FRAC_VALUE(x: TInt32) -> TInt32:
-    return int32((x & 0xFFFFFF) << 4)
-
-
-@portable
-def ADF5355_REG1_MAIN_FRAC_VALUE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0xFFFFFF << 4)) | ((x & 0xFFFFFF) << 4))
-
-
-@portable
-def ADF5355_REG2_AUX_FRAC_LSB_VALUE_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 18) & 0x3FFF)
-
-
-@portable
-def ADF5355_REG2_AUX_FRAC_LSB_VALUE(x: TInt32) -> TInt32:
-    return int32((x & 0x3FFF) << 18)
-
-
-@portable
-def ADF5355_REG2_AUX_FRAC_LSB_VALUE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x3FFF << 18)) | ((x & 0x3FFF) << 18))
-
-
-@portable
-def ADF5355_REG2_AUX_MOD_LSB_VALUE_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 4) & 0x3FFF)
-
-
-@portable
-def ADF5355_REG2_AUX_MOD_LSB_VALUE(x: TInt32) -> TInt32:
-    return int32((x & 0x3FFF) << 4)
-
-
-@portable
-def ADF5355_REG2_AUX_MOD_LSB_VALUE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x3FFF << 4)) | ((x & 0x3FFF) << 4))
-
-
-@portable
-def ADF5355_REG3_PHASE_ADJUST_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 28) & 0x1)
-
-
-@portable
-def ADF5355_REG3_PHASE_ADJUST(x: TInt32) -> TInt32:
-    return int32((x & 0x1) << 28)
-
-
-@portable
-def ADF5355_REG3_PHASE_ADJUST_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x1 << 28)) | ((x & 0x1) << 28))
-
-
-@portable
-def ADF5355_REG3_PHASE_RESYNC_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 29) & 0x1)
-
-
-@portable
-def ADF5355_REG3_PHASE_RESYNC(x: TInt32) -> TInt32:
-    return int32((x & 0x1) << 29)
-
-
-@portable
-def ADF5355_REG3_PHASE_RESYNC_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x1 << 29)) | ((x & 0x1) << 29))
-
-
-@portable
-def ADF5355_REG3_PHASE_VALUE_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 4) & 0xFFFFFF)
-
-
-@portable
-def ADF5355_REG3_PHASE_VALUE(x: TInt32) -> TInt32:
-    return int32((x & 0xFFFFFF) << 4)
-
-
-@portable
-def ADF5355_REG3_PHASE_VALUE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0xFFFFFF << 4)) | ((x & 0xFFFFFF) << 4))
-
-
-@portable
-def ADF5355_REG3_SD_LOAD_RESET_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 30) & 0x1)
-
-
-@portable
-def ADF5355_REG3_SD_LOAD_RESET(x: TInt32) -> TInt32:
-    return int32((x & 0x1) << 30)
-
-
-@portable
-def ADF5355_REG3_SD_LOAD_RESET_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x1 << 30)) | ((x & 0x1) << 30))
-
-
-@portable
-def ADF5355_REG4_COUNTER_RESET_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 4) & 0x1)
-
-
-@portable
-def ADF5355_REG4_COUNTER_RESET(x: TInt32) -> TInt32:
-    return int32((x & 0x1) << 4)
-
-
-@portable
-def ADF5355_REG4_COUNTER_RESET_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x1 << 4)) | ((x & 0x1) << 4))
-
-
-@portable
-def ADF5355_REG4_CP_THREE_STATE_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 5) & 0x1)
-
-
-@portable
-def ADF5355_REG4_CP_THREE_STATE(x: TInt32) -> TInt32:
-    return int32((x & 0x1) << 5)
-
-
-@portable
-def ADF5355_REG4_CP_THREE_STATE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x1 << 5)) | ((x & 0x1) << 5))
-
-
-@portable
-def ADF5355_REG4_CURRENT_SETTING_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 10) & 0xF)
-
-
-@portable
-def ADF5355_REG4_CURRENT_SETTING(x: TInt32) -> TInt32:
-    return int32((x & 0xF) << 10)
-
-
-@portable
-def ADF5355_REG4_CURRENT_SETTING_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0xF << 10)) | ((x & 0xF) << 10))
-
-
-@portable
-def ADF5355_REG4_DOUBLE_BUFF_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 14) & 0x1)
-
-
-@portable
-def ADF5355_REG4_DOUBLE_BUFF(x: TInt32) -> TInt32:
-    return int32((x & 0x1) << 14)
-
-
-@portable
-def ADF5355_REG4_DOUBLE_BUFF_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x1 << 14)) | ((x & 0x1) << 14))
-
-
-@portable
-def ADF5355_REG4_MUX_LOGIC_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 8) & 0x1)
-
-
-@portable
-def ADF5355_REG4_MUX_LOGIC(x: TInt32) -> TInt32:
-    return int32((x & 0x1) << 8)
-
-
-@portable
-def ADF5355_REG4_MUX_LOGIC_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x1 << 8)) | ((x & 0x1) << 8))
-
-
-@portable
-def ADF5355_REG4_MUXOUT_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 27) & 0x7)
-
-
-@portable
-def ADF5355_REG4_MUXOUT(x: TInt32) -> TInt32:
-    return int32((x & 0x7) << 27)
-
-
-@portable
-def ADF5355_REG4_MUXOUT_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x7 << 27)) | ((x & 0x7) << 27))
-
-
-@portable
-def ADF5355_REG4_PD_POLARITY_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 7) & 0x1)
-
-
-@portable
-def ADF5355_REG4_PD_POLARITY(x: TInt32) -> TInt32:
-    return int32((x & 0x1) << 7)
-
-
-@portable
-def ADF5355_REG4_PD_POLARITY_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x1 << 7)) | ((x & 0x1) << 7))
-
-
-@portable
-def ADF5355_REG4_POWER_DOWN_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 6) & 0x1)
-
-
-@portable
-def ADF5355_REG4_POWER_DOWN(x: TInt32) -> TInt32:
-    return int32((x & 0x1) << 6)
-
-
-@portable
-def ADF5355_REG4_POWER_DOWN_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x1 << 6)) | ((x & 0x1) << 6))
-
-
-@portable
-def ADF5355_REG4_R_COUNTER_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 15) & 0x3FF)
-
-
-@portable
-def ADF5355_REG4_R_COUNTER(x: TInt32) -> TInt32:
-    return int32((x & 0x3FF) << 15)
-
-
-@portable
-def ADF5355_REG4_R_COUNTER_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x3FF << 15)) | ((x & 0x3FF) << 15))
-
-
-@portable
-def ADF5355_REG4_R_DIVIDER_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 25) & 0x1)
-
-
-@portable
-def ADF5355_REG4_R_DIVIDER(x: TInt32) -> TInt32:
-    return int32((x & 0x1) << 25)
-
-
-@portable
-def ADF5355_REG4_R_DIVIDER_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x1 << 25)) | ((x & 0x1) << 25))
-
-
-@portable
-def ADF5355_REG4_R_DOUBLER_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 26) & 0x1)
-
-
-@portable
-def ADF5355_REG4_R_DOUBLER(x: TInt32) -> TInt32:
-    return int32((x & 0x1) << 26)
-
-
-@portable
-def ADF5355_REG4_R_DOUBLER_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x1 << 26)) | ((x & 0x1) << 26))
-
-
-@portable
-def ADF5355_REG4_REF_MODE_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 9) & 0x1)
-
-
-@portable
-def ADF5355_REG4_REF_MODE(x: TInt32) -> TInt32:
-    return int32((x & 0x1) << 9)
-
-
-@portable
-def ADF5355_REG4_REF_MODE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x1 << 9)) | ((x & 0x1) << 9))
-
-
-@portable
-def ADF5355_REG6_BLEED_POLARITY_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 31) & 0x1)
-
-
-@portable
-def ADF5355_REG6_BLEED_POLARITY(x: TInt32) -> TInt32:
-    return int32((x & 0x1) << 31)
-
-
-@portable
-def ADF5355_REG6_BLEED_POLARITY_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x1 << 31)) | ((x & 0x1) << 31))
-
-
-@portable
-def ADF5355_REG6_CP_BLEED_CURRENT_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 13) & 0xFF)
-
-
-@portable
-def ADF5355_REG6_CP_BLEED_CURRENT(x: TInt32) -> TInt32:
-    return int32((x & 0xFF) << 13)
-
-
-@portable
-def ADF5355_REG6_CP_BLEED_CURRENT_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0xFF << 13)) | ((x & 0xFF) << 13))
-
-
-@portable
-def ADF5355_REG6_FB_SELECT_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 24) & 0x1)
-
-
-@portable
-def ADF5355_REG6_FB_SELECT(x: TInt32) -> TInt32:
-    return int32((x & 0x1) << 24)
-
-
-@portable
-def ADF5355_REG6_FB_SELECT_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x1 << 24)) | ((x & 0x1) << 24))
-
-
-@portable
-def ADF5355_REG6_GATE_BLEED_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 30) & 0x1)
-
-
-@portable
-def ADF5355_REG6_GATE_BLEED(x: TInt32) -> TInt32:
-    return int32((x & 0x1) << 30)
-
-
-@portable
-def ADF5355_REG6_GATE_BLEED_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x1 << 30)) | ((x & 0x1) << 30))
-
-
-@portable
-def ADF5355_REG6_MUTE_TILL_LD_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 11) & 0x1)
-
-
-@portable
-def ADF5355_REG6_MUTE_TILL_LD(x: TInt32) -> TInt32:
-    return int32((x & 0x1) << 11)
-
-
-@portable
-def ADF5355_REG6_MUTE_TILL_LD_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x1 << 11)) | ((x & 0x1) << 11))
-
-
-@portable
-def ADF5355_REG6_NEGATIVE_BLEED_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 29) & 0x1)
-
-
-@portable
-def ADF5355_REG6_NEGATIVE_BLEED(x: TInt32) -> TInt32:
-    return int32((x & 0x1) << 29)
-
-
-@portable
-def ADF5355_REG6_NEGATIVE_BLEED_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x1 << 29)) | ((x & 0x1) << 29))
-
-
-@portable
-def ADF5355_REG6_RF_DIVIDER_SELECT_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 21) & 0x7)
-
-
-@portable
-def ADF5355_REG6_RF_DIVIDER_SELECT(x: TInt32) -> TInt32:
-    return int32((x & 0x7) << 21)
-
-
-@portable
-def ADF5355_REG6_RF_DIVIDER_SELECT_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x7 << 21)) | ((x & 0x7) << 21))
-
-
-@portable
-def ADF5355_REG6_RF_OUTPUT_A_ENABLE_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 6) & 0x1)
-
-
-@portable
-def ADF5355_REG6_RF_OUTPUT_A_ENABLE(x: TInt32) -> TInt32:
-    return int32((x & 0x1) << 6)
-
-
-@portable
-def ADF5355_REG6_RF_OUTPUT_A_ENABLE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x1 << 6)) | ((x & 0x1) << 6))
-
-
-@portable
-def ADF5355_REG6_RF_OUTPUT_A_POWER_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 4) & 0x3)
-
-
-@portable
-def ADF5355_REG6_RF_OUTPUT_A_POWER(x: TInt32) -> TInt32:
-    return int32((x & 0x3) << 4)
-
-
-@portable
-def ADF5355_REG6_RF_OUTPUT_A_POWER_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x3 << 4)) | ((x & 0x3) << 4))
-
-
-@portable
-def ADF5355_REG6_RF_OUTPUT_B_ENABLE_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 10) & 0x1)
-
-
-@portable
-def ADF5355_REG6_RF_OUTPUT_B_ENABLE(x: TInt32) -> TInt32:
-    return int32((x & 0x1) << 10)
-
-
-@portable
-def ADF5355_REG6_RF_OUTPUT_B_ENABLE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x1 << 10)) | ((x & 0x1) << 10))
-
-
-@portable
-def ADF5355_REG7_FRAC_N_LD_PRECISION_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 5) & 0x3)
-
-
-@portable
-def ADF5355_REG7_FRAC_N_LD_PRECISION(x: TInt32) -> TInt32:
-    return int32((x & 0x3) << 5)
-
-
-@portable
-def ADF5355_REG7_FRAC_N_LD_PRECISION_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x3 << 5)) | ((x & 0x3) << 5))
-
-
-@portable
-def ADF5355_REG7_LD_CYCLE_COUNT_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 8) & 0x3)
-
-
-@portable
-def ADF5355_REG7_LD_CYCLE_COUNT(x: TInt32) -> TInt32:
-    return int32((x & 0x3) << 8)
-
-
-@portable
-def ADF5355_REG7_LD_CYCLE_COUNT_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x3 << 8)) | ((x & 0x3) << 8))
-
-
-@portable
-def ADF5355_REG7_LD_MODE_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 4) & 0x1)
-
-
-@portable
-def ADF5355_REG7_LD_MODE(x: TInt32) -> TInt32:
-    return int32((x & 0x1) << 4)
-
-
-@portable
-def ADF5355_REG7_LD_MODE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x1 << 4)) | ((x & 0x1) << 4))
-
-
-@portable
-def ADF5355_REG7_LE_SEL_SYNC_EDGE_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 27) & 0x1)
-
-
-@portable
-def ADF5355_REG7_LE_SEL_SYNC_EDGE(x: TInt32) -> TInt32:
-    return int32((x & 0x1) << 27)
-
-
-@portable
-def ADF5355_REG7_LE_SEL_SYNC_EDGE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x1 << 27)) | ((x & 0x1) << 27))
-
-
-@portable
-def ADF5355_REG7_LE_SYNC_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 25) & 0x1)
-
-
-@portable
-def ADF5355_REG7_LE_SYNC(x: TInt32) -> TInt32:
-    return int32((x & 0x1) << 25)
-
-
-@portable
-def ADF5355_REG7_LE_SYNC_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x1 << 25)) | ((x & 0x1) << 25))
-
-
-@portable
-def ADF5355_REG7_LOL_MODE_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 7) & 0x1)
-
-
-@portable
-def ADF5355_REG7_LOL_MODE(x: TInt32) -> TInt32:
-    return int32((x & 0x1) << 7)
-
-
-@portable
-def ADF5355_REG7_LOL_MODE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x1 << 7)) | ((x & 0x1) << 7))
-
-
-@portable
-def ADF5355_REG9_AUTOCAL_TIMEOUT_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 9) & 0x1F)
-
-
-@portable
-def ADF5355_REG9_AUTOCAL_TIMEOUT(x: TInt32) -> TInt32:
-    return int32((x & 0x1F) << 9)
-
-
-@portable
-def ADF5355_REG9_AUTOCAL_TIMEOUT_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x1F << 9)) | ((x & 0x1F) << 9))
-
-
-@portable
-def ADF5355_REG9_SYNTH_LOCK_TIMEOUT_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 4) & 0x1F)
-
-
-@portable
-def ADF5355_REG9_SYNTH_LOCK_TIMEOUT(x: TInt32) -> TInt32:
-    return int32((x & 0x1F) << 4)
-
-
-@portable
-def ADF5355_REG9_SYNTH_LOCK_TIMEOUT_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x1F << 4)) | ((x & 0x1F) << 4))
-
-
-@portable
-def ADF5355_REG9_TIMEOUT_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 14) & 0x3FF)
-
-
-@portable
-def ADF5355_REG9_TIMEOUT(x: TInt32) -> TInt32:
-    return int32((x & 0x3FF) << 14)
-
-
-@portable
-def ADF5355_REG9_TIMEOUT_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x3FF << 14)) | ((x & 0x3FF) << 14))
-
-
-@portable
-def ADF5355_REG9_VCO_BAND_DIVISION_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 24) & 0xFF)
-
-
-@portable
-def ADF5355_REG9_VCO_BAND_DIVISION(x: TInt32) -> TInt32:
-    return int32((x & 0xFF) << 24)
-
-
-@portable
-def ADF5355_REG9_VCO_BAND_DIVISION_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0xFF << 24)) | ((x & 0xFF) << 24))
-
-
-@portable
-def ADF5355_REG10_ADC_CLK_DIV_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 6) & 0xFF)
-
-
-@portable
-def ADF5355_REG10_ADC_CLK_DIV(x: TInt32) -> TInt32:
-    return int32((x & 0xFF) << 6)
-
-
-@portable
-def ADF5355_REG10_ADC_CLK_DIV_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0xFF << 6)) | ((x & 0xFF) << 6))
-
-
-@portable
-def ADF5355_REG10_ADC_CONV_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 5) & 0x1)
-
-
-@portable
-def ADF5355_REG10_ADC_CONV(x: TInt32) -> TInt32:
-    return int32((x & 0x1) << 5)
-
-
-@portable
-def ADF5355_REG10_ADC_CONV_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x1 << 5)) | ((x & 0x1) << 5))
-
-
-@portable
-def ADF5355_REG10_ADC_ENABLE_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 4) & 0x1)
-
-
-@portable
-def ADF5355_REG10_ADC_ENABLE(x: TInt32) -> TInt32:
-    return int32((x & 0x1) << 4)
-
-
-@portable
-def ADF5355_REG10_ADC_ENABLE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x1 << 4)) | ((x & 0x1) << 4))
-
-
-@portable
-def ADF5355_REG11_VCO_BAND_HOLD_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 24) & 0x1)
-
-
-@portable
-def ADF5355_REG11_VCO_BAND_HOLD(x: TInt32) -> TInt32:
-    return int32((x & 0x1) << 24)
-
-
-@portable
-def ADF5355_REG11_VCO_BAND_HOLD_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x1 << 24)) | ((x & 0x1) << 24))
-
-
-@portable
-def ADF5355_REG12_PHASE_RESYNC_CLK_VALUE_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 12) & 0xFFFFF)
-
-
-@portable
-def ADF5355_REG12_PHASE_RESYNC_CLK_VALUE(x: TInt32) -> TInt32:
-    return int32((x & 0xFFFFF) << 12)
-
-
-@portable
-def ADF5355_REG12_PHASE_RESYNC_CLK_VALUE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0xFFFFF << 12)) | ((x & 0xFFFFF) << 12))
-
-
-@portable
-def ADF5355_REG13_AUX_FRAC_MSB_VALUE_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 18) & 0x3FFF)
-
-
-@portable
-def ADF5355_REG13_AUX_FRAC_MSB_VALUE(x: TInt32) -> TInt32:
-    return int32((x & 0x3FFF) << 18)
-
-
-@portable
-def ADF5355_REG13_AUX_FRAC_MSB_VALUE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x3FFF << 18)) | ((x & 0x3FFF) << 18))
-
-
-@portable
-def ADF5355_REG13_AUX_MOD_MSB_VALUE_GET(reg: TInt32) -> TInt32:
-    return int32((reg >> 4) & 0x3FFF)
-
-
-@portable
-def ADF5355_REG13_AUX_MOD_MSB_VALUE(x: TInt32) -> TInt32:
-    return int32((x & 0x3FFF) << 4)
-
-
-@portable
-def ADF5355_REG13_AUX_MOD_MSB_VALUE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
-    return int32((reg & ~(0x3FFF << 4)) | ((x & 0x3FFF) << 4))
-
-
-ADF5355_NUM_REGS = 14
diff --git a/artiq/coredevice/adf5355.py b/artiq/coredevice/adf5356.py
similarity index 69%
rename from artiq/coredevice/adf5355.py
rename to artiq/coredevice/adf5356.py
index 3f862c54b..19ed29a60 100644
--- a/artiq/coredevice/adf5355.py
+++ b/artiq/coredevice/adf5356.py
@@ -4,16 +4,16 @@ on Mirny-style prefixed SPI buses.
 
 # https://github.com/analogdevicesinc/linux/blob/master/Documentation/devicetree/bindings/iio/frequency/adf5355.txt
 # https://github.com/analogdevicesinc/linux/blob/master/drivers/iio/frequency/adf5355.c
-# https://www.analog.com/media/en/technical-documentation/data-sheets/ADF5356.pdf
 # https://www.analog.com/media/en/technical-documentation/data-sheets/ADF5355.pdf
-# https://www.analog.com/media/en/technical-documentation/user-guides/EV-ADF5356SD1Z-UG-1087.pdf
+# https://www.analog.com/media/en/technical-documentation/data-sheets/ADF5355.pdf
+# https://www.analog.com/media/en/technical-documentation/user-guides/EV-ADF5355SD1Z-UG-1087.pdf
 
 
 from artiq.language.core import kernel, portable, delay
 from artiq.language.units import us, GHz, MHz
 from artiq.language.types import TInt32, TInt64
 from artiq.coredevice import spi2 as spi
-from artiq.coredevice.adf5355_reg import *
+from artiq.coredevice.adf5356_reg import *
 
 from numpy import int32, int64, floor, ceil
 
@@ -30,20 +30,20 @@ SPI_CONFIG = (
 )
 
 
-ADF5355_MIN_VCO_FREQ = int64(3.4 * GHz)
-ADF5355_MAX_VCO_FREQ = int64(6.8 * GHz)
-ADF5355_MAX_OUTA_FREQ = ADF5355_MAX_VCO_FREQ
-ADF5355_MIN_OUTA_FREQ = ADF5355_MIN_VCO_FREQ / 64
-ADF5355_MAX_OUTB_FREQ = ADF5355_MAX_VCO_FREQ * 2
-ADF5355_MIN_OUTB_FREQ = ADF5355_MIN_VCO_FREQ * 2
+ADF5356_MIN_VCO_FREQ = int64(3.4 * GHz)
+ADF5356_MAX_VCO_FREQ = int64(6.8 * GHz)
+ADF5356_MAX_OUTA_FREQ = ADF5356_MAX_VCO_FREQ
+ADF5356_MIN_OUTA_FREQ = ADF5356_MIN_VCO_FREQ / 64
+ADF5356_MAX_OUTB_FREQ = ADF5356_MAX_VCO_FREQ * 2
+ADF5356_MIN_OUTB_FREQ = ADF5356_MIN_VCO_FREQ * 2
 
-ADF5355_MAX_FREQ_PFD = int32(125.0 * MHz)
-ADF5355_MODULUS1 = int32(16777216)
-ADF5355_MAX_MODULUS2 = int32(16383)  # FIXME: ADF5356 has 28 bits MOD2
-ADF5355_MAX_R_CNT = int32(1023)
+ADF5356_MAX_FREQ_PFD = int32(125.0 * MHz)
+ADF5356_MODULUS1 = int32(1 << 24)
+ADF5356_MAX_MODULUS2 = int32(1 << 28)  # FIXME: ADF5356 has 28 bits MOD2
+ADF5356_MAX_R_CNT = int32(1023)
 
 
-class ADF5355:
+class ADF5356:
     """Analog Devices AD[45]35[56] family of GHz PLLs.
 
     :param cpld_device: Mirny CPLD device name
@@ -87,14 +87,14 @@ class ADF5355:
         """
         if not blind:
             # MUXOUT = VDD
-            self.write(ADF5355_REG4_MUXOUT(1) | 4)
+            self.write(ADF5356_REG4_MUXOUT(1) | 4)
             delay(5000 * us)
             if not self.read_muxout():
                 raise ValueError("MUXOUT not high")
             delay(1000 * us)
 
             # MUXOUT = DGND
-            self.write(ADF5355_REG4_MUXOUT(2) | 4)
+            self.write(ADF5356_REG4_MUXOUT(2) | 4)
             delay(5000 * us)
             if self.read_muxout():
                 raise ValueError("MUXOUT not low")
@@ -125,12 +125,12 @@ class ADF5355:
         """
         freq = int64(round(f))
 
-        if freq > ADF5355_MAX_VCO_FREQ:
+        if freq > ADF5356_MAX_VCO_FREQ:
             raise ValueError("Requested too high frequency")
 
         # select minimal output divider
         rf_div_sel = 0
-        while freq < ADF5355_MIN_VCO_FREQ:
+        while freq < ADF5356_MIN_VCO_FREQ:
             freq <<= 1
             rf_div_sel += 1
 
@@ -138,23 +138,23 @@ class ADF5355:
             raise ValueError("Requested too low frequency")
 
         # choose reference divider that maximizes PFD frequency
-        self.regs[4] = ADF5355_REG4_R_COUNTER_UPDATE(
+        self.regs[4] = ADF5356_REG4_R_COUNTER_UPDATE(
             self.regs[4], self._compute_reference_counter()
         )
         f_pfd = self.f_pfd()
 
         # choose prescaler
         if freq > int64(6e9):
-            self.regs[0] |= ADF5355_REG0_PRESCALER(1)  # 8/9
+            self.regs[0] |= ADF5356_REG0_PRESCALER(1)  # 8/9
             n_min, n_max = 75, 65535
 
             # adjust reference divider to be able to match n_min constraint
             while n_min * f_pfd > freq:
-                r = ADF5355_REG4_R_COUNTER_GET(self.regs[4])
-                self.regs[4] = ADF5355_REG4_R_COUNTER_UPDATE(self.regs[4], r + 1)
+                r = ADF5356_REG4_R_COUNTER_GET(self.regs[4])
+                self.regs[4] = ADF5356_REG4_R_COUNTER_UPDATE(self.regs[4], r + 1)
                 f_pfd = self.f_pfd()
         else:
-            self.regs[0] &= ~ADF5355_REG0_PRESCALER(1)  # 4/5
+            self.regs[0] &= ~ADF5356_REG0_PRESCALER(1)  # 4/5
             n_min, n_max = 23, 32767
 
         # calculate PLL parameters
@@ -166,25 +166,24 @@ class ADF5355:
             raise ValueError("Invalid INT value")
 
         # configure PLL
-        self.regs[0] = ADF5355_REG0_INT_VALUE_UPDATE(self.regs[0], n)
-        self.regs[1] = ADF5355_REG1_MAIN_FRAC_VALUE_UPDATE(self.regs[1], frac1)
-        self.regs[2] = ADF5355_REG2_AUX_FRAC_LSB_VALUE_UPDATE(self.regs[2], frac2_lsb)
-        self.regs[2] = ADF5355_REG2_AUX_MOD_LSB_VALUE_UPDATE(self.regs[2], mod2_lsb)
-        self.regs[13] = ADF5355_REG13_AUX_FRAC_MSB_VALUE_UPDATE(
+        self.regs[0] = ADF5356_REG0_INT_VALUE_UPDATE(self.regs[0], n)
+        self.regs[1] = ADF5356_REG1_MAIN_FRAC_VALUE_UPDATE(self.regs[1], frac1)
+        self.regs[2] = ADF5356_REG2_AUX_FRAC_LSB_VALUE_UPDATE(self.regs[2], frac2_lsb)
+        self.regs[2] = ADF5356_REG2_AUX_MOD_LSB_VALUE_UPDATE(self.regs[2], mod2_lsb)
+        self.regs[13] = ADF5356_REG13_AUX_FRAC_MSB_VALUE_UPDATE(
             self.regs[13], frac2_msb
         )
-        self.regs[13] = ADF5355_REG13_AUX_MOD_MSB_VALUE_UPDATE(self.regs[13], mod2_msb)
+        self.regs[13] = ADF5356_REG13_AUX_MOD_MSB_VALUE_UPDATE(self.regs[13], mod2_msb)
 
-        self.regs[6] = ADF5355_REG6_RF_DIVIDER_SELECT_UPDATE(self.regs[6], rf_div_sel)
-        self.regs[6] = ADF5355_REG6_CP_BLEED_CURRENT_UPDATE(
+        self.regs[6] = ADF5356_REG6_RF_DIVIDER_SELECT_UPDATE(self.regs[6], rf_div_sel)
+        self.regs[6] = ADF5356_REG6_CP_BLEED_CURRENT_UPDATE(
             self.regs[6], int32(floor(24 * f_pfd / (61.44 * MHz)))
         )
-        self.regs[9] = ADF5355_REG9_VCO_BAND_DIVISION_UPDATE(
+        self.regs[9] = ADF5356_REG9_VCO_BAND_DIVISION_UPDATE(
             self.regs[9], int32(ceil(f_pfd / 160e3))
         )
 
         # commit
-        # TODO: frequency update sync
         self.sync()
 
     @kernel
@@ -198,7 +197,7 @@ class ADF5355:
             for i in range(13, 0, -1):
                 self.write(self.regs[i])
             delay(200 * us)
-            self.write(self.regs[0] | ADF5355_REG0_AUTOCAL(1))
+            self.write(self.regs[0] | ADF5356_REG0_AUTOCAL(1))
         else:
             # AUTOCAL AT HALF PFD FREQUENCY
 
@@ -209,27 +208,27 @@ class ADF5355:
 
             self.write(
                 13
-                | ADF5355_REG13_AUX_FRAC_MSB_VALUE(frac2_msb)
-                | ADF5355_REG13_AUX_MOD_MSB_VALUE(mod2_msb)
+                | ADF5356_REG13_AUX_FRAC_MSB_VALUE(frac2_msb)
+                | ADF5356_REG13_AUX_MOD_MSB_VALUE(mod2_msb)
             )
 
             for i in range(12, 4, -1):
                 self.write(self.regs[i])
 
             self.write(
-                ADF5355_REG4_R_COUNTER_UPDATE(self.regs[4], 2 * self.ref_counter())
+                ADF5356_REG4_R_COUNTER_UPDATE(self.regs[4], 2 * self.ref_counter())
             )
 
             self.write(self.regs[3])
             self.write(
                 2
-                | ADF5355_REG2_AUX_MOD_LSB_VALUE(mod2_lsb)
-                | ADF5355_REG2_AUX_FRAC_LSB_VALUE(frac2_lsb)
+                | ADF5356_REG2_AUX_MOD_LSB_VALUE(mod2_lsb)
+                | ADF5356_REG2_AUX_FRAC_LSB_VALUE(frac2_lsb)
             )
-            self.write(1 | ADF5355_REG1_MAIN_FRAC_VALUE(frac1))
+            self.write(1 | ADF5356_REG1_MAIN_FRAC_VALUE(frac1))
 
             delay(200 * us)
-            self.write(ADF5355_REG0_INT_VALUE(n) | ADF5355_REG0_AUTOCAL(1))
+            self.write(ADF5356_REG0_INT_VALUE(n) | ADF5356_REG0_AUTOCAL(1))
 
             # RELOCK AT WANTED PFD FREQUENCY
 
@@ -237,16 +236,16 @@ class ADF5355:
                 self.write(self.regs[i])
 
             # force-disable autocal
-            self.write(self.regs[0] & ~ADF5355_REG0_AUTOCAL(1))
+            self.write(self.regs[0] & ~ADF5356_REG0_AUTOCAL(1))
 
     @portable
     def f_pfd(self) -> TInt64:
         """
         Return the PFD frequency for the cached set of registers.
         """
-        r = ADF5355_REG4_R_COUNTER_GET(self.regs[4])
-        d = ADF5355_REG4_R_DOUBLER_GET(self.regs[4])
-        t = ADF5355_REG4_R_DIVIDER_GET(self.regs[4])
+        r = ADF5356_REG4_R_COUNTER_GET(self.regs[4])
+        d = ADF5356_REG4_R_DOUBLER_GET(self.regs[4])
+        t = ADF5356_REG4_R_DIVIDER_GET(self.regs[4])
         return self._compute_pfd_frequency(r, d, t)
 
     @portable
@@ -259,7 +258,7 @@ class ADF5355:
             * (
                 self.pll_n()
                 + (self.pll_frac1() + self.pll_frac2() / self.pll_mod2())
-                / ADF5355_MODULUS1
+                / ADF5356_MODULUS1
             )
         )
 
@@ -268,14 +267,14 @@ class ADF5355:
         """
         Return the PLL integer value (INT) for the cached set of registers.
         """
-        return ADF5355_REG0_INT_VALUE_GET(self.regs[0])
+        return ADF5356_REG0_INT_VALUE_GET(self.regs[0])
 
     @portable
     def pll_frac1(self) -> TInt32:
         """
         Return the main fractional value (FRAC1) for the cached set of registers.
         """
-        return ADF5355_REG1_MAIN_FRAC_VALUE_GET(self.regs[1])
+        return ADF5356_REG1_MAIN_FRAC_VALUE_GET(self.regs[1])
 
     @portable
     def pll_frac2(self) -> TInt32:
@@ -283,8 +282,8 @@ class ADF5355:
         Return the auxiliary fractional value (FRAC2) for the cached set of registers.
         """
         return (
-            ADF5355_REG13_AUX_FRAC_MSB_VALUE_GET(self.regs[13]) << 14
-        ) | ADF5355_REG2_AUX_FRAC_LSB_VALUE_GET(self.regs[2])
+            ADF5356_REG13_AUX_FRAC_MSB_VALUE_GET(self.regs[13]) << 14
+        ) | ADF5356_REG2_AUX_FRAC_LSB_VALUE_GET(self.regs[2])
 
     @portable
     def pll_mod2(self) -> TInt32:
@@ -292,24 +291,30 @@ class ADF5355:
         Return the auxiliary modulus value (MOD2) for the cached set of registers.
         """
         return (
-            ADF5355_REG13_AUX_MOD_MSB_VALUE_GET(self.regs[13]) << 14
-        ) | ADF5355_REG2_AUX_MOD_LSB_VALUE_GET(self.regs[2])
+            ADF5356_REG13_AUX_MOD_MSB_VALUE_GET(self.regs[13]) << 14
+        ) | ADF5356_REG2_AUX_MOD_LSB_VALUE_GET(self.regs[2])
 
     @portable
     def ref_counter(self) -> TInt32:
         """
         Return the reference counter value (R) for the cached set of registers.
         """
-        return ADF5355_REG4_R_COUNTER_GET(self.regs[4])
+        return ADF5356_REG4_R_COUNTER_GET(self.regs[4])
+
+    @portable
+    def output_divider(self) -> TInt32:
+        """
+        Return the value of the output A divider.
+        """
+        return 1 << ADF5356_REG6_RF_DIVIDER_SELECT_GET(self.regs[6])
 
     def info(self):
-        output_divider = 1 << ADF5355_REG6_RF_DIVIDER_SELECT_GET(self.regs[6])
-        prescaler = ADF5355_REG0_PRESCALER_GET(self.regs[0])
+        prescaler = ADF5356_REG0_PRESCALER_GET(self.regs[0])
         return {
             # output
-            "f_outA": self.f_vco() / output_divider,
+            "f_outA": self.f_vco() / self.output_divider(),
             "f_outB": self.f_vco() * 2,
-            "output_divider": output_divider,
+            "output_divider": self.output_divider(),
             # PLL parameters
             "f_vco": self.f_vco(),
             "pll_n": self.pll_n(),
@@ -331,13 +336,13 @@ class ADF5355:
         Initialize cached registers with sensible defaults.
         """
         # fill with control bits
-        self.regs = [int32(i) for i in range(ADF5355_NUM_REGS)]
+        self.regs = [int32(i) for i in range(ADF5356_NUM_REGS)]
 
         # REG2
         # ====
 
         # avoid divide-by-zero
-        self.regs[2] |= ADF5355_REG2_AUX_MOD_LSB_VALUE(1)
+        self.regs[2] |= ADF5356_REG2_AUX_MOD_LSB_VALUE(1)
 
         # REG4
         # ====
@@ -345,29 +350,29 @@ class ADF5355:
         # single-ended reference mode is recommended
         # for references up to 250 MHz, even if the signal is differential
         if self.sysclk <= 250 * MHz:
-            self.regs[4] |= ADF5355_REG4_REF_MODE(0)
+            self.regs[4] |= ADF5356_REG4_REF_MODE(0)
         else:
-            self.regs[4] |= ADF5355_REG4_REF_MODE(1)
+            self.regs[4] |= ADF5356_REG4_REF_MODE(1)
 
         # phase detector polarity: positive
-        self.regs[4] |= ADF5355_REG4_PD_POLARITY(1)
+        self.regs[4] |= ADF5356_REG4_PD_POLARITY(1)
 
         # charge pump current: 0.94 mA
-        self.regs[4] |= ADF5355_REG4_CURRENT_SETTING(2)
+        self.regs[4] |= ADF5356_REG4_CURRENT_SETTING(2)
 
         # MUXOUT: digital lock detect
-        self.regs[4] |= ADF5355_REG4_MUX_LOGIC(1)  # 3v3 logic
-        self.regs[4] |= ADF5355_REG4_MUXOUT(6)
+        self.regs[4] |= ADF5356_REG4_MUX_LOGIC(1)  # 3v3 logic
+        self.regs[4] |= ADF5356_REG4_MUXOUT(6)
 
         # setup reference path
         if self.ref_doubler:
-            self.regs[4] |= ADF5355_REG4_R_DOUBLER(1)
+            self.regs[4] |= ADF5356_REG4_R_DOUBLER(1)
 
         if self.ref_divider:
-            self.regs[4] |= ADF5355_REG4_R_DIVIDER(1)
+            self.regs[4] |= ADF5356_REG4_R_DIVIDER(1)
 
         r = self._compute_reference_counter()
-        self.regs[4] |= ADF5355_REG4_R_COUNTER(r)
+        self.regs[4] |= ADF5356_REG4_R_COUNTER(r)
 
         # REG5
         # ====
@@ -382,24 +387,24 @@ class ADF5355:
         self.regs[6] = int32(0x14000006)
 
         # enable negative bleed
-        self.regs[6] |= ADF5355_REG6_NEGATIVE_BLEED(1)
+        self.regs[6] |= ADF5356_REG6_NEGATIVE_BLEED(1)
 
         # charge pump bleed current
-        # self.regs[6] |= ADF5355_REG6_CP_BLEED_CURRENT(
+        # self.regs[6] |= ADF5356_REG6_CP_BLEED_CURRENT(
         #     int32(floor(24 * self.f_pfd / (61.44 * MHz)))
         # )
 
         # direct feedback from VCO to N counter
-        self.regs[6] |= ADF5355_REG6_FB_SELECT(1)
+        self.regs[6] |= ADF5356_REG6_FB_SELECT(1)
 
         # mute until the PLL is locked
-        self.regs[6] |= ADF5355_REG6_MUTE_TILL_LD(1)
+        self.regs[6] |= ADF5356_REG6_MUTE_TILL_LD(1)
 
         # enable output A
-        self.regs[6] |= ADF5355_REG6_RF_OUTPUT_A_ENABLE(1)
+        self.regs[6] |= ADF5356_REG6_RF_OUTPUT_A_ENABLE(1)
 
         # set output A power to max power, is adjusted by extra attenuator
-        self.regs[6] |= ADF5355_REG6_RF_OUTPUT_A_POWER(3)  # +5 dBm
+        self.regs[6] |= ADF5356_REG6_RF_OUTPUT_A_POWER(3)  # +5 dBm
 
         # REG7
         # ====
@@ -408,10 +413,10 @@ class ADF5355:
         self.regs[7] = int32(0x10000007)
 
         # sync load-enable to reference
-        self.regs[7] |= ADF5355_REG7_LE_SYNC(1)
+        self.regs[7] |= ADF5356_REG7_LE_SYNC(1)
 
         # frac-N lock-detect precision: 12 ns
-        self.regs[7] |= ADF5355_REG7_FRAC_N_LD_PRECISION(3)
+        self.regs[7] |= ADF5356_REG7_FRAC_N_LD_PRECISION(3)
 
         # REG8
         # ====
@@ -424,9 +429,9 @@ class ADF5355:
 
         # default timeouts (from eval software)
         self.regs[9] |= (
-            ADF5355_REG9_SYNTH_LOCK_TIMEOUT(13)
-            | ADF5355_REG9_AUTOCAL_TIMEOUT(31)
-            | ADF5355_REG9_TIMEOUT(0x67)
+            ADF5356_REG9_SYNTH_LOCK_TIMEOUT(13)
+            | ADF5356_REG9_AUTOCAL_TIMEOUT(31)
+            | ADF5356_REG9_TIMEOUT(0x67)
         )
 
         # REG10
@@ -437,9 +442,9 @@ class ADF5355:
 
         # ADC defaults (from eval software)
         self.regs[10] |= (
-            ADF5355_REG10_ADC_ENABLE(1)
-            | ADF5355_REG10_ADC_CLK_DIV(256)
-            | ADF5355_REG10_ADC_CONV(1)
+            ADF5356_REG10_ADC_ENABLE(1)
+            | ADF5356_REG10_ADC_CLK_DIV(256)
+            | ADF5356_REG10_ADC_CONV(1)
         )
 
         # REG11
@@ -466,10 +471,10 @@ class ADF5355:
         """
         Determine the reference counter R that maximizes the PFD frequency
         """
-        d = ADF5355_REG4_R_DOUBLER_GET(self.regs[4])
-        t = ADF5355_REG4_R_DIVIDER_GET(self.regs[4])
+        d = ADF5356_REG4_R_DOUBLER_GET(self.regs[4])
+        t = ADF5356_REG4_R_DIVIDER_GET(self.regs[4])
         r = 1
-        while self._compute_pfd_frequency(r, d, t) > ADF5355_MAX_FREQ_PFD:
+        while self._compute_pfd_frequency(r, d, t) > ADF5356_MAX_FREQ_PFD:
             r += 1
         return int32(r)
 
@@ -494,8 +499,8 @@ def calculate_pll(f_vco: TInt64, f_pfd: TInt64):
     f_vco = f_pfd * (n + (frac1 + frac2/mod2) / mod1)
 
     where
-        mod1 = 16777216
-        mod2 = 16383
+        mod1 = 2**24
+        mod2 = 2**28
     """
     f_pfd = int64(f_pfd)
     f_vco = int64(f_vco)
@@ -504,13 +509,13 @@ def calculate_pll(f_vco: TInt64, f_pfd: TInt64):
     n, r = int32(f_vco // f_pfd), f_vco % f_pfd
 
     # main fractional part
-    r *= ADF5355_MODULUS1
+    r *= ADF5356_MODULUS1
     frac1, frac2 = int32(r // f_pfd), r % f_pfd
 
     # auxiliary fractional part
     mod2 = f_pfd
 
-    while mod2 > ADF5355_MAX_MODULUS2:
+    while mod2 > ADF5356_MAX_MODULUS2:
         mod2 >>= 1
         frac2 >>= 1
 
diff --git a/artiq/coredevice/adf5356_reg.py b/artiq/coredevice/adf5356_reg.py
new file mode 100644
index 000000000..a61582d1a
--- /dev/null
+++ b/artiq/coredevice/adf5356_reg.py
@@ -0,0 +1,642 @@
+# auto-generated, do not edit
+from artiq.language.core import portable
+from artiq.language.types import TInt32
+from numpy import int32
+
+@portable
+def ADF5356_REG0_AUTOCAL_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 21) & 0x1)
+
+@portable
+def ADF5356_REG0_AUTOCAL(x: TInt32) -> TInt32:
+    return int32((x & 0x1) << 21)
+
+@portable
+def ADF5356_REG0_AUTOCAL_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x1 << 21)) | ((x & 0x1) << 21))
+
+
+@portable
+def ADF5356_REG0_INT_VALUE_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 4) & 0xffff)
+
+@portable
+def ADF5356_REG0_INT_VALUE(x: TInt32) -> TInt32:
+    return int32((x & 0xffff) << 4)
+
+@portable
+def ADF5356_REG0_INT_VALUE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0xffff << 4)) | ((x & 0xffff) << 4))
+
+
+@portable
+def ADF5356_REG0_PRESCALER_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 20) & 0x1)
+
+@portable
+def ADF5356_REG0_PRESCALER(x: TInt32) -> TInt32:
+    return int32((x & 0x1) << 20)
+
+@portable
+def ADF5356_REG0_PRESCALER_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x1 << 20)) | ((x & 0x1) << 20))
+
+
+@portable
+def ADF5356_REG1_MAIN_FRAC_VALUE_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 4) & 0xffffff)
+
+@portable
+def ADF5356_REG1_MAIN_FRAC_VALUE(x: TInt32) -> TInt32:
+    return int32((x & 0xffffff) << 4)
+
+@portable
+def ADF5356_REG1_MAIN_FRAC_VALUE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0xffffff << 4)) | ((x & 0xffffff) << 4))
+
+
+@portable
+def ADF5356_REG2_AUX_FRAC_LSB_VALUE_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 18) & 0x3fff)
+
+@portable
+def ADF5356_REG2_AUX_FRAC_LSB_VALUE(x: TInt32) -> TInt32:
+    return int32((x & 0x3fff) << 18)
+
+@portable
+def ADF5356_REG2_AUX_FRAC_LSB_VALUE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x3fff << 18)) | ((x & 0x3fff) << 18))
+
+
+@portable
+def ADF5356_REG2_AUX_MOD_LSB_VALUE_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 4) & 0x3fff)
+
+@portable
+def ADF5356_REG2_AUX_MOD_LSB_VALUE(x: TInt32) -> TInt32:
+    return int32((x & 0x3fff) << 4)
+
+@portable
+def ADF5356_REG2_AUX_MOD_LSB_VALUE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x3fff << 4)) | ((x & 0x3fff) << 4))
+
+
+@portable
+def ADF5356_REG3_PHASE_ADJUST_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 28) & 0x1)
+
+@portable
+def ADF5356_REG3_PHASE_ADJUST(x: TInt32) -> TInt32:
+    return int32((x & 0x1) << 28)
+
+@portable
+def ADF5356_REG3_PHASE_ADJUST_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x1 << 28)) | ((x & 0x1) << 28))
+
+
+@portable
+def ADF5356_REG3_PHASE_RESYNC_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 29) & 0x1)
+
+@portable
+def ADF5356_REG3_PHASE_RESYNC(x: TInt32) -> TInt32:
+    return int32((x & 0x1) << 29)
+
+@portable
+def ADF5356_REG3_PHASE_RESYNC_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x1 << 29)) | ((x & 0x1) << 29))
+
+
+@portable
+def ADF5356_REG3_PHASE_VALUE_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 4) & 0xffffff)
+
+@portable
+def ADF5356_REG3_PHASE_VALUE(x: TInt32) -> TInt32:
+    return int32((x & 0xffffff) << 4)
+
+@portable
+def ADF5356_REG3_PHASE_VALUE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0xffffff << 4)) | ((x & 0xffffff) << 4))
+
+
+@portable
+def ADF5356_REG3_SD_LOAD_RESET_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 30) & 0x1)
+
+@portable
+def ADF5356_REG3_SD_LOAD_RESET(x: TInt32) -> TInt32:
+    return int32((x & 0x1) << 30)
+
+@portable
+def ADF5356_REG3_SD_LOAD_RESET_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x1 << 30)) | ((x & 0x1) << 30))
+
+
+@portable
+def ADF5356_REG4_COUNTER_RESET_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 4) & 0x1)
+
+@portable
+def ADF5356_REG4_COUNTER_RESET(x: TInt32) -> TInt32:
+    return int32((x & 0x1) << 4)
+
+@portable
+def ADF5356_REG4_COUNTER_RESET_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x1 << 4)) | ((x & 0x1) << 4))
+
+
+@portable
+def ADF5356_REG4_CP_THREE_STATE_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 5) & 0x1)
+
+@portable
+def ADF5356_REG4_CP_THREE_STATE(x: TInt32) -> TInt32:
+    return int32((x & 0x1) << 5)
+
+@portable
+def ADF5356_REG4_CP_THREE_STATE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x1 << 5)) | ((x & 0x1) << 5))
+
+
+@portable
+def ADF5356_REG4_CURRENT_SETTING_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 10) & 0xf)
+
+@portable
+def ADF5356_REG4_CURRENT_SETTING(x: TInt32) -> TInt32:
+    return int32((x & 0xf) << 10)
+
+@portable
+def ADF5356_REG4_CURRENT_SETTING_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0xf << 10)) | ((x & 0xf) << 10))
+
+
+@portable
+def ADF5356_REG4_DOUBLE_BUFF_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 14) & 0x1)
+
+@portable
+def ADF5356_REG4_DOUBLE_BUFF(x: TInt32) -> TInt32:
+    return int32((x & 0x1) << 14)
+
+@portable
+def ADF5356_REG4_DOUBLE_BUFF_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x1 << 14)) | ((x & 0x1) << 14))
+
+
+@portable
+def ADF5356_REG4_MUX_LOGIC_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 8) & 0x1)
+
+@portable
+def ADF5356_REG4_MUX_LOGIC(x: TInt32) -> TInt32:
+    return int32((x & 0x1) << 8)
+
+@portable
+def ADF5356_REG4_MUX_LOGIC_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x1 << 8)) | ((x & 0x1) << 8))
+
+
+@portable
+def ADF5356_REG4_MUXOUT_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 27) & 0x7)
+
+@portable
+def ADF5356_REG4_MUXOUT(x: TInt32) -> TInt32:
+    return int32((x & 0x7) << 27)
+
+@portable
+def ADF5356_REG4_MUXOUT_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x7 << 27)) | ((x & 0x7) << 27))
+
+
+@portable
+def ADF5356_REG4_PD_POLARITY_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 7) & 0x1)
+
+@portable
+def ADF5356_REG4_PD_POLARITY(x: TInt32) -> TInt32:
+    return int32((x & 0x1) << 7)
+
+@portable
+def ADF5356_REG4_PD_POLARITY_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x1 << 7)) | ((x & 0x1) << 7))
+
+
+@portable
+def ADF5356_REG4_POWER_DOWN_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 6) & 0x1)
+
+@portable
+def ADF5356_REG4_POWER_DOWN(x: TInt32) -> TInt32:
+    return int32((x & 0x1) << 6)
+
+@portable
+def ADF5356_REG4_POWER_DOWN_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x1 << 6)) | ((x & 0x1) << 6))
+
+
+@portable
+def ADF5356_REG4_R_COUNTER_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 15) & 0x3ff)
+
+@portable
+def ADF5356_REG4_R_COUNTER(x: TInt32) -> TInt32:
+    return int32((x & 0x3ff) << 15)
+
+@portable
+def ADF5356_REG4_R_COUNTER_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x3ff << 15)) | ((x & 0x3ff) << 15))
+
+
+@portable
+def ADF5356_REG4_R_DIVIDER_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 25) & 0x1)
+
+@portable
+def ADF5356_REG4_R_DIVIDER(x: TInt32) -> TInt32:
+    return int32((x & 0x1) << 25)
+
+@portable
+def ADF5356_REG4_R_DIVIDER_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x1 << 25)) | ((x & 0x1) << 25))
+
+
+@portable
+def ADF5356_REG4_R_DOUBLER_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 26) & 0x1)
+
+@portable
+def ADF5356_REG4_R_DOUBLER(x: TInt32) -> TInt32:
+    return int32((x & 0x1) << 26)
+
+@portable
+def ADF5356_REG4_R_DOUBLER_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x1 << 26)) | ((x & 0x1) << 26))
+
+
+@portable
+def ADF5356_REG4_REF_MODE_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 9) & 0x1)
+
+@portable
+def ADF5356_REG4_REF_MODE(x: TInt32) -> TInt32:
+    return int32((x & 0x1) << 9)
+
+@portable
+def ADF5356_REG4_REF_MODE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x1 << 9)) | ((x & 0x1) << 9))
+
+
+@portable
+def ADF5356_REG6_BLEED_POLARITY_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 31) & 0x1)
+
+@portable
+def ADF5356_REG6_BLEED_POLARITY(x: TInt32) -> TInt32:
+    return int32((x & 0x1) << 31)
+
+@portable
+def ADF5356_REG6_BLEED_POLARITY_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x1 << 31)) | ((x & 0x1) << 31))
+
+
+@portable
+def ADF5356_REG6_CP_BLEED_CURRENT_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 13) & 0xff)
+
+@portable
+def ADF5356_REG6_CP_BLEED_CURRENT(x: TInt32) -> TInt32:
+    return int32((x & 0xff) << 13)
+
+@portable
+def ADF5356_REG6_CP_BLEED_CURRENT_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0xff << 13)) | ((x & 0xff) << 13))
+
+
+@portable
+def ADF5356_REG6_FB_SELECT_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 24) & 0x1)
+
+@portable
+def ADF5356_REG6_FB_SELECT(x: TInt32) -> TInt32:
+    return int32((x & 0x1) << 24)
+
+@portable
+def ADF5356_REG6_FB_SELECT_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x1 << 24)) | ((x & 0x1) << 24))
+
+
+@portable
+def ADF5356_REG6_GATE_BLEED_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 30) & 0x1)
+
+@portable
+def ADF5356_REG6_GATE_BLEED(x: TInt32) -> TInt32:
+    return int32((x & 0x1) << 30)
+
+@portable
+def ADF5356_REG6_GATE_BLEED_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x1 << 30)) | ((x & 0x1) << 30))
+
+
+@portable
+def ADF5356_REG6_MUTE_TILL_LD_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 11) & 0x1)
+
+@portable
+def ADF5356_REG6_MUTE_TILL_LD(x: TInt32) -> TInt32:
+    return int32((x & 0x1) << 11)
+
+@portable
+def ADF5356_REG6_MUTE_TILL_LD_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x1 << 11)) | ((x & 0x1) << 11))
+
+
+@portable
+def ADF5356_REG6_NEGATIVE_BLEED_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 29) & 0x1)
+
+@portable
+def ADF5356_REG6_NEGATIVE_BLEED(x: TInt32) -> TInt32:
+    return int32((x & 0x1) << 29)
+
+@portable
+def ADF5356_REG6_NEGATIVE_BLEED_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x1 << 29)) | ((x & 0x1) << 29))
+
+
+@portable
+def ADF5356_REG6_RF_DIVIDER_SELECT_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 21) & 0x7)
+
+@portable
+def ADF5356_REG6_RF_DIVIDER_SELECT(x: TInt32) -> TInt32:
+    return int32((x & 0x7) << 21)
+
+@portable
+def ADF5356_REG6_RF_DIVIDER_SELECT_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x7 << 21)) | ((x & 0x7) << 21))
+
+
+@portable
+def ADF5356_REG6_RF_OUTPUT_A_ENABLE_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 6) & 0x1)
+
+@portable
+def ADF5356_REG6_RF_OUTPUT_A_ENABLE(x: TInt32) -> TInt32:
+    return int32((x & 0x1) << 6)
+
+@portable
+def ADF5356_REG6_RF_OUTPUT_A_ENABLE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x1 << 6)) | ((x & 0x1) << 6))
+
+
+@portable
+def ADF5356_REG6_RF_OUTPUT_A_POWER_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 4) & 0x3)
+
+@portable
+def ADF5356_REG6_RF_OUTPUT_A_POWER(x: TInt32) -> TInt32:
+    return int32((x & 0x3) << 4)
+
+@portable
+def ADF5356_REG6_RF_OUTPUT_A_POWER_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x3 << 4)) | ((x & 0x3) << 4))
+
+
+@portable
+def ADF5356_REG6_RF_OUTPUT_B_ENABLE_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 10) & 0x1)
+
+@portable
+def ADF5356_REG6_RF_OUTPUT_B_ENABLE(x: TInt32) -> TInt32:
+    return int32((x & 0x1) << 10)
+
+@portable
+def ADF5356_REG6_RF_OUTPUT_B_ENABLE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x1 << 10)) | ((x & 0x1) << 10))
+
+
+@portable
+def ADF5356_REG7_FRAC_N_LD_PRECISION_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 5) & 0x3)
+
+@portable
+def ADF5356_REG7_FRAC_N_LD_PRECISION(x: TInt32) -> TInt32:
+    return int32((x & 0x3) << 5)
+
+@portable
+def ADF5356_REG7_FRAC_N_LD_PRECISION_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x3 << 5)) | ((x & 0x3) << 5))
+
+
+@portable
+def ADF5356_REG7_LD_CYCLE_COUNT_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 8) & 0x3)
+
+@portable
+def ADF5356_REG7_LD_CYCLE_COUNT(x: TInt32) -> TInt32:
+    return int32((x & 0x3) << 8)
+
+@portable
+def ADF5356_REG7_LD_CYCLE_COUNT_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x3 << 8)) | ((x & 0x3) << 8))
+
+
+@portable
+def ADF5356_REG7_LD_MODE_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 4) & 0x1)
+
+@portable
+def ADF5356_REG7_LD_MODE(x: TInt32) -> TInt32:
+    return int32((x & 0x1) << 4)
+
+@portable
+def ADF5356_REG7_LD_MODE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x1 << 4)) | ((x & 0x1) << 4))
+
+
+@portable
+def ADF5356_REG7_LE_SEL_SYNC_EDGE_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 27) & 0x1)
+
+@portable
+def ADF5356_REG7_LE_SEL_SYNC_EDGE(x: TInt32) -> TInt32:
+    return int32((x & 0x1) << 27)
+
+@portable
+def ADF5356_REG7_LE_SEL_SYNC_EDGE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x1 << 27)) | ((x & 0x1) << 27))
+
+
+@portable
+def ADF5356_REG7_LE_SYNC_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 25) & 0x1)
+
+@portable
+def ADF5356_REG7_LE_SYNC(x: TInt32) -> TInt32:
+    return int32((x & 0x1) << 25)
+
+@portable
+def ADF5356_REG7_LE_SYNC_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x1 << 25)) | ((x & 0x1) << 25))
+
+
+@portable
+def ADF5356_REG7_LOL_MODE_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 7) & 0x1)
+
+@portable
+def ADF5356_REG7_LOL_MODE(x: TInt32) -> TInt32:
+    return int32((x & 0x1) << 7)
+
+@portable
+def ADF5356_REG7_LOL_MODE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x1 << 7)) | ((x & 0x1) << 7))
+
+
+@portable
+def ADF5356_REG9_AUTOCAL_TIMEOUT_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 9) & 0x1f)
+
+@portable
+def ADF5356_REG9_AUTOCAL_TIMEOUT(x: TInt32) -> TInt32:
+    return int32((x & 0x1f) << 9)
+
+@portable
+def ADF5356_REG9_AUTOCAL_TIMEOUT_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x1f << 9)) | ((x & 0x1f) << 9))
+
+
+@portable
+def ADF5356_REG9_SYNTH_LOCK_TIMEOUT_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 4) & 0x1f)
+
+@portable
+def ADF5356_REG9_SYNTH_LOCK_TIMEOUT(x: TInt32) -> TInt32:
+    return int32((x & 0x1f) << 4)
+
+@portable
+def ADF5356_REG9_SYNTH_LOCK_TIMEOUT_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x1f << 4)) | ((x & 0x1f) << 4))
+
+
+@portable
+def ADF5356_REG9_TIMEOUT_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 14) & 0x3ff)
+
+@portable
+def ADF5356_REG9_TIMEOUT(x: TInt32) -> TInt32:
+    return int32((x & 0x3ff) << 14)
+
+@portable
+def ADF5356_REG9_TIMEOUT_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x3ff << 14)) | ((x & 0x3ff) << 14))
+
+
+@portable
+def ADF5356_REG9_VCO_BAND_DIVISION_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 24) & 0xff)
+
+@portable
+def ADF5356_REG9_VCO_BAND_DIVISION(x: TInt32) -> TInt32:
+    return int32((x & 0xff) << 24)
+
+@portable
+def ADF5356_REG9_VCO_BAND_DIVISION_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0xff << 24)) | ((x & 0xff) << 24))
+
+
+@portable
+def ADF5356_REG10_ADC_CLK_DIV_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 6) & 0xff)
+
+@portable
+def ADF5356_REG10_ADC_CLK_DIV(x: TInt32) -> TInt32:
+    return int32((x & 0xff) << 6)
+
+@portable
+def ADF5356_REG10_ADC_CLK_DIV_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0xff << 6)) | ((x & 0xff) << 6))
+
+
+@portable
+def ADF5356_REG10_ADC_CONV_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 5) & 0x1)
+
+@portable
+def ADF5356_REG10_ADC_CONV(x: TInt32) -> TInt32:
+    return int32((x & 0x1) << 5)
+
+@portable
+def ADF5356_REG10_ADC_CONV_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x1 << 5)) | ((x & 0x1) << 5))
+
+
+@portable
+def ADF5356_REG10_ADC_ENABLE_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 4) & 0x1)
+
+@portable
+def ADF5356_REG10_ADC_ENABLE(x: TInt32) -> TInt32:
+    return int32((x & 0x1) << 4)
+
+@portable
+def ADF5356_REG10_ADC_ENABLE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x1 << 4)) | ((x & 0x1) << 4))
+
+
+@portable
+def ADF5356_REG11_VCO_BAND_HOLD_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 24) & 0x1)
+
+@portable
+def ADF5356_REG11_VCO_BAND_HOLD(x: TInt32) -> TInt32:
+    return int32((x & 0x1) << 24)
+
+@portable
+def ADF5356_REG11_VCO_BAND_HOLD_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x1 << 24)) | ((x & 0x1) << 24))
+
+
+@portable
+def ADF5356_REG12_PHASE_RESYNC_CLK_VALUE_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 12) & 0xfffff)
+
+@portable
+def ADF5356_REG12_PHASE_RESYNC_CLK_VALUE(x: TInt32) -> TInt32:
+    return int32((x & 0xfffff) << 12)
+
+@portable
+def ADF5356_REG12_PHASE_RESYNC_CLK_VALUE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0xfffff << 12)) | ((x & 0xfffff) << 12))
+
+
+@portable
+def ADF5356_REG13_AUX_FRAC_MSB_VALUE_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 18) & 0x3fff)
+
+@portable
+def ADF5356_REG13_AUX_FRAC_MSB_VALUE(x: TInt32) -> TInt32:
+    return int32((x & 0x3fff) << 18)
+
+@portable
+def ADF5356_REG13_AUX_FRAC_MSB_VALUE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x3fff << 18)) | ((x & 0x3fff) << 18))
+
+
+@portable
+def ADF5356_REG13_AUX_MOD_MSB_VALUE_GET(reg: TInt32) -> TInt32:
+    return int32((reg >> 4) & 0x3fff)
+
+@portable
+def ADF5356_REG13_AUX_MOD_MSB_VALUE(x: TInt32) -> TInt32:
+    return int32((x & 0x3fff) << 4)
+
+@portable
+def ADF5356_REG13_AUX_MOD_MSB_VALUE_UPDATE(reg: TInt32, x: TInt32) -> TInt32:
+    return int32((reg & ~(0x3fff << 4)) | ((x & 0x3fff) << 4))
+
+ADF5356_NUM_REGS = 14