# `BMI323.Registers`

Raw 16-bit register accessors for the BMI323.

Each function reads or writes a single 16-bit register. Reads return the raw
little-endian bytes (LSB first); writes accept the same format. Higher-level
helpers in `BMI323` interpret those bytes as signed integers, scaled physical
quantities, or named bit-fields.

Burst reads (multiple consecutive registers in one I²C transaction) are not
declared here; use `Wafer.Chip.read_register/3` directly with the desired
start address and byte count, or one of the burst-aware helpers in `BMI323`.

Register addresses, access modes and bit layouts are taken from
*BMI323 Datasheet BST-BMI323-DS000-12* §6.1, *Register Map Overview*.

# `read_acc_conf`

```elixir
@spec read_acc_conf(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `acc_conf` register.

## Example

    iex> read_acc_conf(conn)
    {:ok, <<0, 0>>}

# `read_acc_data_x`

```elixir
@spec read_acc_data_x(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `acc_data_x` register.

## Example

    iex> read_acc_data_x(conn)
    {:ok, <<0, 0>>}

# `read_acc_data_y`

```elixir
@spec read_acc_data_y(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `acc_data_y` register.

## Example

    iex> read_acc_data_y(conn)
    {:ok, <<0, 0>>}

# `read_acc_data_z`

```elixir
@spec read_acc_data_z(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `acc_data_z` register.

## Example

    iex> read_acc_data_z(conn)
    {:ok, <<0, 0>>}

# `read_acc_dp_dgain_x`

```elixir
@spec read_acc_dp_dgain_x(Wafer.Conn.t()) ::
  {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `acc_dp_dgain_x` register.

## Example

    iex> read_acc_dp_dgain_x(conn)
    {:ok, <<0, 0>>}

# `read_acc_dp_dgain_y`

```elixir
@spec read_acc_dp_dgain_y(Wafer.Conn.t()) ::
  {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `acc_dp_dgain_y` register.

## Example

    iex> read_acc_dp_dgain_y(conn)
    {:ok, <<0, 0>>}

# `read_acc_dp_dgain_z`

```elixir
@spec read_acc_dp_dgain_z(Wafer.Conn.t()) ::
  {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `acc_dp_dgain_z` register.

## Example

    iex> read_acc_dp_dgain_z(conn)
    {:ok, <<0, 0>>}

# `read_acc_dp_off_x`

```elixir
@spec read_acc_dp_off_x(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `acc_dp_off_x` register.

## Example

    iex> read_acc_dp_off_x(conn)
    {:ok, <<0, 0>>}

# `read_acc_dp_off_y`

```elixir
@spec read_acc_dp_off_y(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `acc_dp_off_y` register.

## Example

    iex> read_acc_dp_off_y(conn)
    {:ok, <<0, 0>>}

# `read_acc_dp_off_z`

```elixir
@spec read_acc_dp_off_z(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `acc_dp_off_z` register.

## Example

    iex> read_acc_dp_off_z(conn)
    {:ok, <<0, 0>>}

# `read_alt_acc_conf`

```elixir
@spec read_alt_acc_conf(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `alt_acc_conf` register.

## Example

    iex> read_alt_acc_conf(conn)
    {:ok, <<0, 0>>}

# `read_alt_conf`

```elixir
@spec read_alt_conf(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `alt_conf` register.

## Example

    iex> read_alt_conf(conn)
    {:ok, <<0, 0>>}

# `read_alt_gyr_conf`

```elixir
@spec read_alt_gyr_conf(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `alt_gyr_conf` register.

## Example

    iex> read_alt_gyr_conf(conn)
    {:ok, <<0, 0>>}

# `read_alt_status`

```elixir
@spec read_alt_status(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `alt_status` register.

## Example

    iex> read_alt_status(conn)
    {:ok, <<0, 0>>}

# `read_cfg_res`

```elixir
@spec read_cfg_res(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `cfg_res` register.

## Example

    iex> read_cfg_res(conn)
    {:ok, <<0, 0>>}

# `read_chip_id`

```elixir
@spec read_chip_id(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `chip_id` register.

## Example

    iex> read_chip_id(conn)
    {:ok, <<0, 0>>}

# `read_err_reg`

```elixir
@spec read_err_reg(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `err_reg` register.

## Example

    iex> read_err_reg(conn)
    {:ok, <<0, 0>>}

# `read_feature_ctrl`

```elixir
@spec read_feature_ctrl(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `feature_ctrl` register.

## Example

    iex> read_feature_ctrl(conn)
    {:ok, <<0, 0>>}

# `read_feature_data_addr`

```elixir
@spec read_feature_data_addr(Wafer.Conn.t()) ::
  {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `feature_data_addr` register.

## Example

    iex> read_feature_data_addr(conn)
    {:ok, <<0, 0>>}

# `read_feature_data_status`

```elixir
@spec read_feature_data_status(Wafer.Conn.t()) ::
  {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `feature_data_status` register.

## Example

    iex> read_feature_data_status(conn)
    {:ok, <<0, 0>>}

# `read_feature_data_tx`

```elixir
@spec read_feature_data_tx(Wafer.Conn.t()) ::
  {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `feature_data_tx` register.

## Example

    iex> read_feature_data_tx(conn)
    {:ok, <<0, 0>>}

# `read_feature_engine_status`

```elixir
@spec read_feature_engine_status(Wafer.Conn.t()) ::
  {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `feature_engine_status` register.

## Example

    iex> read_feature_engine_status(conn)
    {:ok, <<0, 0>>}

# `read_feature_event_ext`

```elixir
@spec read_feature_event_ext(Wafer.Conn.t()) ::
  {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `feature_event_ext` register.

## Example

    iex> read_feature_event_ext(conn)
    {:ok, <<0, 0>>}

# `read_feature_io_0`

```elixir
@spec read_feature_io_0(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `feature_io_0` register.

## Example

    iex> read_feature_io_0(conn)
    {:ok, <<0, 0>>}

# `read_feature_io_1`

```elixir
@spec read_feature_io_1(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `feature_io_1` register.

## Example

    iex> read_feature_io_1(conn)
    {:ok, <<0, 0>>}

# `read_feature_io_2`

```elixir
@spec read_feature_io_2(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `feature_io_2` register.

## Example

    iex> read_feature_io_2(conn)
    {:ok, <<0, 0>>}

# `read_feature_io_3`

```elixir
@spec read_feature_io_3(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `feature_io_3` register.

## Example

    iex> read_feature_io_3(conn)
    {:ok, <<0, 0>>}

# `read_feature_io_status`

```elixir
@spec read_feature_io_status(Wafer.Conn.t()) ::
  {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `feature_io_status` register.

## Example

    iex> read_feature_io_status(conn)
    {:ok, <<0, 0>>}

# `read_fifo_conf`

```elixir
@spec read_fifo_conf(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `fifo_conf` register.

## Example

    iex> read_fifo_conf(conn)
    {:ok, <<0, 0>>}

# `read_fifo_data`

```elixir
@spec read_fifo_data(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `fifo_data` register.

## Example

    iex> read_fifo_data(conn)
    {:ok, <<0, 0>>}

# `read_fifo_fill_level`

```elixir
@spec read_fifo_fill_level(Wafer.Conn.t()) ::
  {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `fifo_fill_level` register.

## Example

    iex> read_fifo_fill_level(conn)
    {:ok, <<0, 0>>}

# `read_fifo_watermark`

```elixir
@spec read_fifo_watermark(Wafer.Conn.t()) ::
  {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `fifo_watermark` register.

## Example

    iex> read_fifo_watermark(conn)
    {:ok, <<0, 0>>}

# `read_gyr_conf`

```elixir
@spec read_gyr_conf(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `gyr_conf` register.

## Example

    iex> read_gyr_conf(conn)
    {:ok, <<0, 0>>}

# `read_gyr_data_x`

```elixir
@spec read_gyr_data_x(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `gyr_data_x` register.

## Example

    iex> read_gyr_data_x(conn)
    {:ok, <<0, 0>>}

# `read_gyr_data_y`

```elixir
@spec read_gyr_data_y(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `gyr_data_y` register.

## Example

    iex> read_gyr_data_y(conn)
    {:ok, <<0, 0>>}

# `read_gyr_data_z`

```elixir
@spec read_gyr_data_z(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `gyr_data_z` register.

## Example

    iex> read_gyr_data_z(conn)
    {:ok, <<0, 0>>}

# `read_gyr_dp_dgain_x`

```elixir
@spec read_gyr_dp_dgain_x(Wafer.Conn.t()) ::
  {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `gyr_dp_dgain_x` register.

## Example

    iex> read_gyr_dp_dgain_x(conn)
    {:ok, <<0, 0>>}

# `read_gyr_dp_dgain_y`

```elixir
@spec read_gyr_dp_dgain_y(Wafer.Conn.t()) ::
  {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `gyr_dp_dgain_y` register.

## Example

    iex> read_gyr_dp_dgain_y(conn)
    {:ok, <<0, 0>>}

# `read_gyr_dp_dgain_z`

```elixir
@spec read_gyr_dp_dgain_z(Wafer.Conn.t()) ::
  {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `gyr_dp_dgain_z` register.

## Example

    iex> read_gyr_dp_dgain_z(conn)
    {:ok, <<0, 0>>}

# `read_gyr_dp_off_x`

```elixir
@spec read_gyr_dp_off_x(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `gyr_dp_off_x` register.

## Example

    iex> read_gyr_dp_off_x(conn)
    {:ok, <<0, 0>>}

# `read_gyr_dp_off_y`

```elixir
@spec read_gyr_dp_off_y(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `gyr_dp_off_y` register.

## Example

    iex> read_gyr_dp_off_y(conn)
    {:ok, <<0, 0>>}

# `read_gyr_dp_off_z`

```elixir
@spec read_gyr_dp_off_z(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `gyr_dp_off_z` register.

## Example

    iex> read_gyr_dp_off_z(conn)
    {:ok, <<0, 0>>}

# `read_i3c_tc_sync_odr`

```elixir
@spec read_i3c_tc_sync_odr(Wafer.Conn.t()) ::
  {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `i3c_tc_sync_odr` register.

## Example

    iex> read_i3c_tc_sync_odr(conn)
    {:ok, <<0, 0>>}

# `read_i3c_tc_sync_tph`

```elixir
@spec read_i3c_tc_sync_tph(Wafer.Conn.t()) ::
  {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `i3c_tc_sync_tph` register.

## Example

    iex> read_i3c_tc_sync_tph(conn)
    {:ok, <<0, 0>>}

# `read_i3c_tc_sync_tu`

```elixir
@spec read_i3c_tc_sync_tu(Wafer.Conn.t()) ::
  {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `i3c_tc_sync_tu` register.

## Example

    iex> read_i3c_tc_sync_tu(conn)
    {:ok, <<0, 0>>}

# `read_int_conf`

```elixir
@spec read_int_conf(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `int_conf` register.

## Example

    iex> read_int_conf(conn)
    {:ok, <<0, 0>>}

# `read_int_map_1`

```elixir
@spec read_int_map_1(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `int_map_1` register.

## Example

    iex> read_int_map_1(conn)
    {:ok, <<0, 0>>}

# `read_int_map_2`

```elixir
@spec read_int_map_2(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `int_map_2` register.

## Example

    iex> read_int_map_2(conn)
    {:ok, <<0, 0>>}

# `read_int_status_ibi`

```elixir
@spec read_int_status_ibi(Wafer.Conn.t()) ::
  {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `int_status_ibi` register.

## Example

    iex> read_int_status_ibi(conn)
    {:ok, <<0, 0>>}

# `read_int_status_int1`

```elixir
@spec read_int_status_int1(Wafer.Conn.t()) ::
  {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `int_status_int1` register.

## Example

    iex> read_int_status_int1(conn)
    {:ok, <<0, 0>>}

# `read_int_status_int2`

```elixir
@spec read_int_status_int2(Wafer.Conn.t()) ::
  {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `int_status_int2` register.

## Example

    iex> read_int_status_int2(conn)
    {:ok, <<0, 0>>}

# `read_io_i2c_if`

```elixir
@spec read_io_i2c_if(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `io_i2c_if` register.

## Example

    iex> read_io_i2c_if(conn)
    {:ok, <<0, 0>>}

# `read_io_int_ctrl`

```elixir
@spec read_io_int_ctrl(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `io_int_ctrl` register.

## Example

    iex> read_io_int_ctrl(conn)
    {:ok, <<0, 0>>}

# `read_io_odr_deviation`

```elixir
@spec read_io_odr_deviation(Wafer.Conn.t()) ::
  {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `io_odr_deviation` register.

## Example

    iex> read_io_odr_deviation(conn)
    {:ok, <<0, 0>>}

# `read_io_pad_strength`

```elixir
@spec read_io_pad_strength(Wafer.Conn.t()) ::
  {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `io_pad_strength` register.

## Example

    iex> read_io_pad_strength(conn)
    {:ok, <<0, 0>>}

# `read_io_pdn_ctrl`

```elixir
@spec read_io_pdn_ctrl(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `io_pdn_ctrl` register.

## Example

    iex> read_io_pdn_ctrl(conn)
    {:ok, <<0, 0>>}

# `read_io_spi_if`

```elixir
@spec read_io_spi_if(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `io_spi_if` register.

## Example

    iex> read_io_spi_if(conn)
    {:ok, <<0, 0>>}

# `read_sat_flags`

```elixir
@spec read_sat_flags(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `sat_flags` register.

## Example

    iex> read_sat_flags(conn)
    {:ok, <<0, 0>>}

# `read_sensor_time_0`

```elixir
@spec read_sensor_time_0(Wafer.Conn.t()) ::
  {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `sensor_time_0` register.

## Example

    iex> read_sensor_time_0(conn)
    {:ok, <<0, 0>>}

# `read_sensor_time_1`

```elixir
@spec read_sensor_time_1(Wafer.Conn.t()) ::
  {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `sensor_time_1` register.

## Example

    iex> read_sensor_time_1(conn)
    {:ok, <<0, 0>>}

# `read_status`

```elixir
@spec read_status(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `status` register.

## Example

    iex> read_status(conn)
    {:ok, <<0, 0>>}

# `read_temp_data`

```elixir
@spec read_temp_data(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()}
```

Read the contents of the `temp_data` register.

## Example

    iex> read_temp_data(conn)
    {:ok, <<0, 0>>}

# `swap_acc_conf`

```elixir
@spec swap_acc_conf(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `acc_conf` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_acc_conf(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_acc_dp_dgain_x`

```elixir
@spec swap_acc_dp_dgain_x(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `acc_dp_dgain_x` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_acc_dp_dgain_x(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_acc_dp_dgain_y`

```elixir
@spec swap_acc_dp_dgain_y(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `acc_dp_dgain_y` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_acc_dp_dgain_y(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_acc_dp_dgain_z`

```elixir
@spec swap_acc_dp_dgain_z(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `acc_dp_dgain_z` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_acc_dp_dgain_z(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_acc_dp_off_x`

```elixir
@spec swap_acc_dp_off_x(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `acc_dp_off_x` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_acc_dp_off_x(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_acc_dp_off_y`

```elixir
@spec swap_acc_dp_off_y(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `acc_dp_off_y` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_acc_dp_off_y(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_acc_dp_off_z`

```elixir
@spec swap_acc_dp_off_z(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `acc_dp_off_z` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_acc_dp_off_z(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_alt_acc_conf`

```elixir
@spec swap_alt_acc_conf(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `alt_acc_conf` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_alt_acc_conf(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_alt_conf`

```elixir
@spec swap_alt_conf(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `alt_conf` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_alt_conf(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_alt_gyr_conf`

```elixir
@spec swap_alt_gyr_conf(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `alt_gyr_conf` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_alt_gyr_conf(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_cfg_res`

```elixir
@spec swap_cfg_res(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `cfg_res` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_cfg_res(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_feature_ctrl`

```elixir
@spec swap_feature_ctrl(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `feature_ctrl` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_feature_ctrl(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_feature_data_addr`

```elixir
@spec swap_feature_data_addr(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `feature_data_addr` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_feature_data_addr(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_feature_data_tx`

```elixir
@spec swap_feature_data_tx(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `feature_data_tx` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_feature_data_tx(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_feature_io_0`

```elixir
@spec swap_feature_io_0(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `feature_io_0` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_feature_io_0(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_feature_io_1`

```elixir
@spec swap_feature_io_1(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `feature_io_1` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_feature_io_1(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_feature_io_2`

```elixir
@spec swap_feature_io_2(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `feature_io_2` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_feature_io_2(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_feature_io_3`

```elixir
@spec swap_feature_io_3(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `feature_io_3` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_feature_io_3(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_feature_io_status`

```elixir
@spec swap_feature_io_status(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `feature_io_status` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_feature_io_status(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_fifo_conf`

```elixir
@spec swap_fifo_conf(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `fifo_conf` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_fifo_conf(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_fifo_watermark`

```elixir
@spec swap_fifo_watermark(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `fifo_watermark` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_fifo_watermark(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_gyr_conf`

```elixir
@spec swap_gyr_conf(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `gyr_conf` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_gyr_conf(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_gyr_dp_dgain_x`

```elixir
@spec swap_gyr_dp_dgain_x(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `gyr_dp_dgain_x` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_gyr_dp_dgain_x(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_gyr_dp_dgain_y`

```elixir
@spec swap_gyr_dp_dgain_y(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `gyr_dp_dgain_y` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_gyr_dp_dgain_y(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_gyr_dp_dgain_z`

```elixir
@spec swap_gyr_dp_dgain_z(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `gyr_dp_dgain_z` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_gyr_dp_dgain_z(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_gyr_dp_off_x`

```elixir
@spec swap_gyr_dp_off_x(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `gyr_dp_off_x` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_gyr_dp_off_x(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_gyr_dp_off_y`

```elixir
@spec swap_gyr_dp_off_y(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `gyr_dp_off_y` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_gyr_dp_off_y(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_gyr_dp_off_z`

```elixir
@spec swap_gyr_dp_off_z(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `gyr_dp_off_z` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_gyr_dp_off_z(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_i3c_tc_sync_odr`

```elixir
@spec swap_i3c_tc_sync_odr(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `i3c_tc_sync_odr` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_i3c_tc_sync_odr(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_i3c_tc_sync_tph`

```elixir
@spec swap_i3c_tc_sync_tph(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `i3c_tc_sync_tph` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_i3c_tc_sync_tph(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_i3c_tc_sync_tu`

```elixir
@spec swap_i3c_tc_sync_tu(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `i3c_tc_sync_tu` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_i3c_tc_sync_tu(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_int_conf`

```elixir
@spec swap_int_conf(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `int_conf` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_int_conf(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_int_map_1`

```elixir
@spec swap_int_map_1(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `int_map_1` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_int_map_1(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_int_map_2`

```elixir
@spec swap_int_map_2(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `int_map_2` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_int_map_2(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_io_i2c_if`

```elixir
@spec swap_io_i2c_if(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `io_i2c_if` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_io_i2c_if(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_io_int_ctrl`

```elixir
@spec swap_io_int_ctrl(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `io_int_ctrl` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_io_int_ctrl(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_io_pad_strength`

```elixir
@spec swap_io_pad_strength(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `io_pad_strength` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_io_pad_strength(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_io_pdn_ctrl`

```elixir
@spec swap_io_pdn_ctrl(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `io_pdn_ctrl` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_io_pdn_ctrl(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `swap_io_spi_if`

```elixir
@spec swap_io_spi_if(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Swap the contents of the `io_spi_if` register.

Reads the contents of the register, then replaces it, returning the
previous contents.  Some drivers may implement this atomically.

## Example

    iex> swap_io_spi_if(conn, <<0, 0>>)
    {:ok, <<0, 0>>, _conn}

# `update_acc_conf`

```elixir
@spec update_acc_conf(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `acc_conf` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_acc_conf(conn, transform)
    {:ok, _conn}

# `update_acc_dp_dgain_x`

```elixir
@spec update_acc_dp_dgain_x(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `acc_dp_dgain_x` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_acc_dp_dgain_x(conn, transform)
    {:ok, _conn}

# `update_acc_dp_dgain_y`

```elixir
@spec update_acc_dp_dgain_y(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `acc_dp_dgain_y` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_acc_dp_dgain_y(conn, transform)
    {:ok, _conn}

# `update_acc_dp_dgain_z`

```elixir
@spec update_acc_dp_dgain_z(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `acc_dp_dgain_z` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_acc_dp_dgain_z(conn, transform)
    {:ok, _conn}

# `update_acc_dp_off_x`

```elixir
@spec update_acc_dp_off_x(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `acc_dp_off_x` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_acc_dp_off_x(conn, transform)
    {:ok, _conn}

# `update_acc_dp_off_y`

```elixir
@spec update_acc_dp_off_y(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `acc_dp_off_y` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_acc_dp_off_y(conn, transform)
    {:ok, _conn}

# `update_acc_dp_off_z`

```elixir
@spec update_acc_dp_off_z(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `acc_dp_off_z` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_acc_dp_off_z(conn, transform)
    {:ok, _conn}

# `update_alt_acc_conf`

```elixir
@spec update_alt_acc_conf(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `alt_acc_conf` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_alt_acc_conf(conn, transform)
    {:ok, _conn}

# `update_alt_conf`

```elixir
@spec update_alt_conf(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `alt_conf` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_alt_conf(conn, transform)
    {:ok, _conn}

# `update_alt_gyr_conf`

```elixir
@spec update_alt_gyr_conf(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `alt_gyr_conf` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_alt_gyr_conf(conn, transform)
    {:ok, _conn}

# `update_cfg_res`

```elixir
@spec update_cfg_res(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `cfg_res` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_cfg_res(conn, transform)
    {:ok, _conn}

# `update_feature_ctrl`

```elixir
@spec update_feature_ctrl(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `feature_ctrl` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_feature_ctrl(conn, transform)
    {:ok, _conn}

# `update_feature_data_addr`

```elixir
@spec update_feature_data_addr(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `feature_data_addr` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_feature_data_addr(conn, transform)
    {:ok, _conn}

# `update_feature_data_tx`

```elixir
@spec update_feature_data_tx(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `feature_data_tx` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_feature_data_tx(conn, transform)
    {:ok, _conn}

# `update_feature_io_0`

```elixir
@spec update_feature_io_0(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `feature_io_0` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_feature_io_0(conn, transform)
    {:ok, _conn}

# `update_feature_io_1`

```elixir
@spec update_feature_io_1(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `feature_io_1` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_feature_io_1(conn, transform)
    {:ok, _conn}

# `update_feature_io_2`

```elixir
@spec update_feature_io_2(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `feature_io_2` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_feature_io_2(conn, transform)
    {:ok, _conn}

# `update_feature_io_3`

```elixir
@spec update_feature_io_3(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `feature_io_3` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_feature_io_3(conn, transform)
    {:ok, _conn}

# `update_feature_io_status`

```elixir
@spec update_feature_io_status(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `feature_io_status` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_feature_io_status(conn, transform)
    {:ok, _conn}

# `update_fifo_conf`

```elixir
@spec update_fifo_conf(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `fifo_conf` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_fifo_conf(conn, transform)
    {:ok, _conn}

# `update_fifo_watermark`

```elixir
@spec update_fifo_watermark(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `fifo_watermark` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_fifo_watermark(conn, transform)
    {:ok, _conn}

# `update_gyr_conf`

```elixir
@spec update_gyr_conf(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `gyr_conf` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_gyr_conf(conn, transform)
    {:ok, _conn}

# `update_gyr_dp_dgain_x`

```elixir
@spec update_gyr_dp_dgain_x(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `gyr_dp_dgain_x` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_gyr_dp_dgain_x(conn, transform)
    {:ok, _conn}

# `update_gyr_dp_dgain_y`

```elixir
@spec update_gyr_dp_dgain_y(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `gyr_dp_dgain_y` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_gyr_dp_dgain_y(conn, transform)
    {:ok, _conn}

# `update_gyr_dp_dgain_z`

```elixir
@spec update_gyr_dp_dgain_z(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `gyr_dp_dgain_z` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_gyr_dp_dgain_z(conn, transform)
    {:ok, _conn}

# `update_gyr_dp_off_x`

```elixir
@spec update_gyr_dp_off_x(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `gyr_dp_off_x` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_gyr_dp_off_x(conn, transform)
    {:ok, _conn}

# `update_gyr_dp_off_y`

```elixir
@spec update_gyr_dp_off_y(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `gyr_dp_off_y` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_gyr_dp_off_y(conn, transform)
    {:ok, _conn}

# `update_gyr_dp_off_z`

```elixir
@spec update_gyr_dp_off_z(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `gyr_dp_off_z` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_gyr_dp_off_z(conn, transform)
    {:ok, _conn}

# `update_i3c_tc_sync_odr`

```elixir
@spec update_i3c_tc_sync_odr(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `i3c_tc_sync_odr` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_i3c_tc_sync_odr(conn, transform)
    {:ok, _conn}

# `update_i3c_tc_sync_tph`

```elixir
@spec update_i3c_tc_sync_tph(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `i3c_tc_sync_tph` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_i3c_tc_sync_tph(conn, transform)
    {:ok, _conn}

# `update_i3c_tc_sync_tu`

```elixir
@spec update_i3c_tc_sync_tu(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `i3c_tc_sync_tu` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_i3c_tc_sync_tu(conn, transform)
    {:ok, _conn}

# `update_int_conf`

```elixir
@spec update_int_conf(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `int_conf` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_int_conf(conn, transform)
    {:ok, _conn}

# `update_int_map_1`

```elixir
@spec update_int_map_1(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `int_map_1` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_int_map_1(conn, transform)
    {:ok, _conn}

# `update_int_map_2`

```elixir
@spec update_int_map_2(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `int_map_2` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_int_map_2(conn, transform)
    {:ok, _conn}

# `update_io_i2c_if`

```elixir
@spec update_io_i2c_if(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `io_i2c_if` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_io_i2c_if(conn, transform)
    {:ok, _conn}

# `update_io_int_ctrl`

```elixir
@spec update_io_int_ctrl(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `io_int_ctrl` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_io_int_ctrl(conn, transform)
    {:ok, _conn}

# `update_io_pad_strength`

```elixir
@spec update_io_pad_strength(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `io_pad_strength` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_io_pad_strength(conn, transform)
    {:ok, _conn}

# `update_io_pdn_ctrl`

```elixir
@spec update_io_pdn_ctrl(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `io_pdn_ctrl` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_io_pdn_ctrl(conn, transform)
    {:ok, _conn}

# `update_io_spi_if`

```elixir
@spec update_io_spi_if(Wafer.Conn.t(), (&lt;&lt;_::_*16&gt;&gt; -&gt; &lt;&lt;_::_*16&gt;&gt;)) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Update the contents of the `io_spi_if` register using a
transformation function.

## Example

    iex> transform = fn <<data::size(16)>> -> <<(data * 2)::size(16)>> end
    ...> update_io_spi_if(conn, transform)
    {:ok, _conn}

# `write_acc_conf`

```elixir
@spec write_acc_conf(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `acc_conf` register.

## Example

    iex> write_acc_conf(conn, <<0, 0>>)
    {:ok, _conn}

# `write_acc_dp_dgain_x`

```elixir
@spec write_acc_dp_dgain_x(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `acc_dp_dgain_x` register.

## Example

    iex> write_acc_dp_dgain_x(conn, <<0, 0>>)
    {:ok, _conn}

# `write_acc_dp_dgain_y`

```elixir
@spec write_acc_dp_dgain_y(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `acc_dp_dgain_y` register.

## Example

    iex> write_acc_dp_dgain_y(conn, <<0, 0>>)
    {:ok, _conn}

# `write_acc_dp_dgain_z`

```elixir
@spec write_acc_dp_dgain_z(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `acc_dp_dgain_z` register.

## Example

    iex> write_acc_dp_dgain_z(conn, <<0, 0>>)
    {:ok, _conn}

# `write_acc_dp_off_x`

```elixir
@spec write_acc_dp_off_x(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `acc_dp_off_x` register.

## Example

    iex> write_acc_dp_off_x(conn, <<0, 0>>)
    {:ok, _conn}

# `write_acc_dp_off_y`

```elixir
@spec write_acc_dp_off_y(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `acc_dp_off_y` register.

## Example

    iex> write_acc_dp_off_y(conn, <<0, 0>>)
    {:ok, _conn}

# `write_acc_dp_off_z`

```elixir
@spec write_acc_dp_off_z(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `acc_dp_off_z` register.

## Example

    iex> write_acc_dp_off_z(conn, <<0, 0>>)
    {:ok, _conn}

# `write_alt_acc_conf`

```elixir
@spec write_alt_acc_conf(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `alt_acc_conf` register.

## Example

    iex> write_alt_acc_conf(conn, <<0, 0>>)
    {:ok, _conn}

# `write_alt_conf`

```elixir
@spec write_alt_conf(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `alt_conf` register.

## Example

    iex> write_alt_conf(conn, <<0, 0>>)
    {:ok, _conn}

# `write_alt_gyr_conf`

```elixir
@spec write_alt_gyr_conf(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `alt_gyr_conf` register.

## Example

    iex> write_alt_gyr_conf(conn, <<0, 0>>)
    {:ok, _conn}

# `write_cfg_res`

```elixir
@spec write_cfg_res(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `cfg_res` register.

## Example

    iex> write_cfg_res(conn, <<0, 0>>)
    {:ok, _conn}

# `write_cmd`

```elixir
@spec write_cmd(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `cmd` register.

## Example

    iex> write_cmd(conn, <<0, 0>>)
    {:ok, _conn}

# `write_feature_ctrl`

```elixir
@spec write_feature_ctrl(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `feature_ctrl` register.

## Example

    iex> write_feature_ctrl(conn, <<0, 0>>)
    {:ok, _conn}

# `write_feature_data_addr`

```elixir
@spec write_feature_data_addr(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `feature_data_addr` register.

## Example

    iex> write_feature_data_addr(conn, <<0, 0>>)
    {:ok, _conn}

# `write_feature_data_tx`

```elixir
@spec write_feature_data_tx(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `feature_data_tx` register.

## Example

    iex> write_feature_data_tx(conn, <<0, 0>>)
    {:ok, _conn}

# `write_feature_io_0`

```elixir
@spec write_feature_io_0(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `feature_io_0` register.

## Example

    iex> write_feature_io_0(conn, <<0, 0>>)
    {:ok, _conn}

# `write_feature_io_1`

```elixir
@spec write_feature_io_1(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `feature_io_1` register.

## Example

    iex> write_feature_io_1(conn, <<0, 0>>)
    {:ok, _conn}

# `write_feature_io_2`

```elixir
@spec write_feature_io_2(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `feature_io_2` register.

## Example

    iex> write_feature_io_2(conn, <<0, 0>>)
    {:ok, _conn}

# `write_feature_io_3`

```elixir
@spec write_feature_io_3(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `feature_io_3` register.

## Example

    iex> write_feature_io_3(conn, <<0, 0>>)
    {:ok, _conn}

# `write_feature_io_status`

```elixir
@spec write_feature_io_status(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `feature_io_status` register.

## Example

    iex> write_feature_io_status(conn, <<0, 0>>)
    {:ok, _conn}

# `write_fifo_conf`

```elixir
@spec write_fifo_conf(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `fifo_conf` register.

## Example

    iex> write_fifo_conf(conn, <<0, 0>>)
    {:ok, _conn}

# `write_fifo_ctrl`

```elixir
@spec write_fifo_ctrl(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `fifo_ctrl` register.

## Example

    iex> write_fifo_ctrl(conn, <<0, 0>>)
    {:ok, _conn}

# `write_fifo_watermark`

```elixir
@spec write_fifo_watermark(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `fifo_watermark` register.

## Example

    iex> write_fifo_watermark(conn, <<0, 0>>)
    {:ok, _conn}

# `write_gyr_conf`

```elixir
@spec write_gyr_conf(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `gyr_conf` register.

## Example

    iex> write_gyr_conf(conn, <<0, 0>>)
    {:ok, _conn}

# `write_gyr_dp_dgain_x`

```elixir
@spec write_gyr_dp_dgain_x(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `gyr_dp_dgain_x` register.

## Example

    iex> write_gyr_dp_dgain_x(conn, <<0, 0>>)
    {:ok, _conn}

# `write_gyr_dp_dgain_y`

```elixir
@spec write_gyr_dp_dgain_y(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `gyr_dp_dgain_y` register.

## Example

    iex> write_gyr_dp_dgain_y(conn, <<0, 0>>)
    {:ok, _conn}

# `write_gyr_dp_dgain_z`

```elixir
@spec write_gyr_dp_dgain_z(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `gyr_dp_dgain_z` register.

## Example

    iex> write_gyr_dp_dgain_z(conn, <<0, 0>>)
    {:ok, _conn}

# `write_gyr_dp_off_x`

```elixir
@spec write_gyr_dp_off_x(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `gyr_dp_off_x` register.

## Example

    iex> write_gyr_dp_off_x(conn, <<0, 0>>)
    {:ok, _conn}

# `write_gyr_dp_off_y`

```elixir
@spec write_gyr_dp_off_y(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `gyr_dp_off_y` register.

## Example

    iex> write_gyr_dp_off_y(conn, <<0, 0>>)
    {:ok, _conn}

# `write_gyr_dp_off_z`

```elixir
@spec write_gyr_dp_off_z(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `gyr_dp_off_z` register.

## Example

    iex> write_gyr_dp_off_z(conn, <<0, 0>>)
    {:ok, _conn}

# `write_i3c_tc_sync_odr`

```elixir
@spec write_i3c_tc_sync_odr(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `i3c_tc_sync_odr` register.

## Example

    iex> write_i3c_tc_sync_odr(conn, <<0, 0>>)
    {:ok, _conn}

# `write_i3c_tc_sync_tph`

```elixir
@spec write_i3c_tc_sync_tph(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `i3c_tc_sync_tph` register.

## Example

    iex> write_i3c_tc_sync_tph(conn, <<0, 0>>)
    {:ok, _conn}

# `write_i3c_tc_sync_tu`

```elixir
@spec write_i3c_tc_sync_tu(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `i3c_tc_sync_tu` register.

## Example

    iex> write_i3c_tc_sync_tu(conn, <<0, 0>>)
    {:ok, _conn}

# `write_int_conf`

```elixir
@spec write_int_conf(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `int_conf` register.

## Example

    iex> write_int_conf(conn, <<0, 0>>)
    {:ok, _conn}

# `write_int_map_1`

```elixir
@spec write_int_map_1(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `int_map_1` register.

## Example

    iex> write_int_map_1(conn, <<0, 0>>)
    {:ok, _conn}

# `write_int_map_2`

```elixir
@spec write_int_map_2(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `int_map_2` register.

## Example

    iex> write_int_map_2(conn, <<0, 0>>)
    {:ok, _conn}

# `write_io_i2c_if`

```elixir
@spec write_io_i2c_if(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `io_i2c_if` register.

## Example

    iex> write_io_i2c_if(conn, <<0, 0>>)
    {:ok, _conn}

# `write_io_int_ctrl`

```elixir
@spec write_io_int_ctrl(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `io_int_ctrl` register.

## Example

    iex> write_io_int_ctrl(conn, <<0, 0>>)
    {:ok, _conn}

# `write_io_pad_strength`

```elixir
@spec write_io_pad_strength(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `io_pad_strength` register.

## Example

    iex> write_io_pad_strength(conn, <<0, 0>>)
    {:ok, _conn}

# `write_io_pdn_ctrl`

```elixir
@spec write_io_pdn_ctrl(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `io_pdn_ctrl` register.

## Example

    iex> write_io_pdn_ctrl(conn, <<0, 0>>)
    {:ok, _conn}

# `write_io_spi_if`

```elixir
@spec write_io_spi_if(Wafer.Conn.t(), data :: binary()) ::
  {:ok, Wafer.Conn.t()} | {:error, reason :: any()}
```

Write new contents to the `io_spi_if` register.

## Example

    iex> write_io_spi_if(conn, <<0, 0>>)
    {:ok, _conn}

---

*Consult [api-reference.md](api-reference.md) for complete listing*