// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
/*
 * Copyright (C) Fraunhofer-Institut for Photonic Microsystems (IPMS)
 * Maria-Reiche-Str. 2
 * 01109 Dresden
 *
 * This file is licensed under the terms of the GNU General Public
 * License version 2. This program is licensed "as is" without any
 * warranty of any kind, whether express or implied.
 *
 * \file
 * \author  This file was automatically generated by the HAL_gen.py script
 * \date   25/04/2024
 * \brief  Holds functions for a unified read and write access to ip core registers.
 *
 */

#include "can_linux_hal.h"

#define op_verbose 1

static void mx_read_log(uint8_t width, const char* ctx, volatile  void* reg_addr, uint32_t value)
{   
    if( width!=8 && width!=16 && width!=32 ){
        error_msg("Error: Wrong register width\n");
    } else if( width==8 ){
        if( op_verbose ) {
            reg_msg("(%p) %s >> 0x%02X\n", reg_addr, ctx, ((uint8_t)value)); 
		}
    } else if( width==16 ){
        if( op_verbose ) {
            reg_msg("(%p) %s >> 0x%04X\n", reg_addr, ctx, ((uint16_t)value)); 
		}
    } else if( width==32 ){
        if( op_verbose ){
            reg_msg("(%p) %s >> 0x%08X\n", reg_addr, ctx, ((uint32_t)value)); 
        }
    }
}

static void mx_write_log(uint8_t width, const char* ctx, volatile  void* reg_addr, uint32_t value)
{
    if( width!=8 && width!=16 && width!=32 ){
        error_msg("Error: Wrong register width\n");
    } else if( width==8 ){
        if( op_verbose ) {
            reg_msg("(%p) %s << 0x%02X\n", reg_addr, ctx, ((uint8_t)value)); 
		}
    } else if( width==16 ){
        if( op_verbose ) {
            reg_msg("(%p) %s << 0x%04X\n", reg_addr, ctx, ((uint16_t)value)); 
		}
    } else if( width==32 ){
        if( op_verbose ) {
            reg_msg("(%p) %s << 0x%08X\n", reg_addr, ctx, ((uint32_t)value)); 
		}
    }
}

#define HAL_READ_LOGGING(width, ctx, addr, value) \
	{                                         \
        mx_read_log(width, ctx, addr, value); \
	}
#define HAL_WRITE_LOGGING(width, ctx, addr, value) \
	{                                          \
        mx_write_log(width, ctx, addr, value); \
	}

static hal_log_t can_linux_log = HAL_LOG_DEFAULT;
void can_linux_configure_logging(hal_log_t f)
{
	can_linux_log = f;
}

void can_linux_version_read(volatile CAN_CTRL_t *can_linux, uint16_t *VERSION)
{
    *VERSION = can_linux->VERSION;
    HAL_READ_LOGGING(16, "can_linux.VERSION",
                    &can_linux->VERSION, *VERSION);
}

void can_linux_nodecfg_read(volatile CAN_CTRL_t *can_linux,
			    CAN_CTRL_NODECFG_t *NODECFG)
{
    NODECFG->VALUE = can_linux->NODECFG.VALUE;
    HAL_READ_LOGGING(8, "can_linux.NODECFG",
                    &can_linux->NODECFG, NODECFG->VALUE);
}

void can_linux_nodecfg_write(volatile CAN_CTRL_t *can_linux,
			     const CAN_CTRL_NODECFG_t *NODECFG)
{
    HAL_WRITE_LOGGING(8, "can_linux.NODECFG",
                    &can_linux->NODECFG, NODECFG->VALUE);
    can_linux->NODECFG.VALUE = NODECFG->VALUE;
}

void can_linux_tscfg_read(volatile CAN_CTRL_t *can_linux,
			  CAN_CTRL_TSCFG_t *TSCFG)
{
	TSCFG->VALUE = can_linux->TSCFG.VALUE;
	HAL_READ_LOGGING(8, "can_linux.TSCFG", &can_linux->TSCFG,
			 TSCFG->VALUE);
}

void can_linux_tscfg_write(volatile CAN_CTRL_t *can_linux,
			   const CAN_CTRL_TSCFG_t *TSCFG)
{
	HAL_WRITE_LOGGING(8, "can_linux.TSCFG", &can_linux->TSCFG,
			  TSCFG->VALUE);
	can_linux->TSCFG.VALUE = TSCFG->VALUE;
}

void can_linux_ac_time_read(volatile CAN_CTRL_t *can_linux,
			    CAN_CTRL_AC_TIME_t *AC_TIME)
{
	AC_TIME->VALUE = can_linux->AC_TIME.VALUE;
	HAL_READ_LOGGING(32, "can_linux.AC_TIME",
			 &can_linux->AC_TIME, AC_TIME->VALUE);
}

void can_linux_ac_time_write(volatile CAN_CTRL_t *can_linux,
			     const CAN_CTRL_AC_TIME_t *AC_TIME)
{
	HAL_WRITE_LOGGING(32, "can_linux.AC_TIME",
			  &can_linux->AC_TIME, AC_TIME->VALUE);
	can_linux->AC_TIME.VALUE = AC_TIME->VALUE;
}

void can_linux_fd_time_read(volatile CAN_CTRL_t *can_linux,
			    CAN_CTRL_FD_TIME_t *FD_TIME)
{
	FD_TIME->VALUE = can_linux->FD_TIME.VALUE;
	HAL_READ_LOGGING(32, "can_linux.FD_TIME",
			 &can_linux->FD_TIME, FD_TIME->VALUE);
}

void can_linux_fd_time_write(volatile CAN_CTRL_t *can_linux,
			     const CAN_CTRL_FD_TIME_t *FD_TIME)
{
	HAL_WRITE_LOGGING(32, "can_linux.FD_TIME",
			  &can_linux->FD_TIME, FD_TIME->VALUE);
	can_linux->FD_TIME.VALUE = FD_TIME->VALUE;
}

void can_linux_xl_time_read(volatile CAN_CTRL_t *can_linux,
			    CAN_CTRL_XL_TIME_t *XL_TIME)
{
	XL_TIME->VALUE = can_linux->XL_TIME.VALUE;
	HAL_READ_LOGGING(32, "can_linux.XL_TIME",
			 &can_linux->XL_TIME, XL_TIME->VALUE);
}

void can_linux_xl_time_write(volatile CAN_CTRL_t *can_linux,
			     const CAN_CTRL_XL_TIME_t *XL_TIME)
{
	HAL_WRITE_LOGGING(32, "can_linux.XL_TIME",
			  &can_linux->XL_TIME, XL_TIME->VALUE);
	can_linux->XL_TIME.VALUE = XL_TIME->VALUE;
}

void can_linux_presc_read(volatile CAN_CTRL_t *can_linux,
			  CAN_CTRL_PRESC_t *PRESC)
{
	PRESC->VALUE = can_linux->PRESC.VALUE;
	HAL_READ_LOGGING(8, "can_linux.PRESC", &can_linux->PRESC,
			 PRESC->VALUE);
}

void can_linux_presc_write(volatile CAN_CTRL_t *can_linux,
			   const CAN_CTRL_PRESC_t *PRESC)
{
	HAL_WRITE_LOGGING(8, "can_linux.PRESC", &can_linux->PRESC,
			  PRESC->VALUE);
	can_linux->PRESC.VALUE = PRESC->VALUE;
}

void can_linux_fd_tdc_read(volatile CAN_CTRL_t *can_linux, uint8_t *FD_TDC)
{
	*FD_TDC = can_linux->FD_TDC;
	HAL_READ_LOGGING(8, "can_linux.FD_TDC", &can_linux->FD_TDC,
			 *FD_TDC);
}

void can_linux_fd_tdc_write(volatile CAN_CTRL_t *can_linux,
			    const uint8_t *FD_TDC)
{
	HAL_WRITE_LOGGING(8, "can_linux.FD_TDC", &can_linux->FD_TDC,
			  *FD_TDC);
	can_linux->FD_TDC = *FD_TDC;
}

void can_linux_xl_tdc_read(volatile CAN_CTRL_t *can_linux, uint8_t *XL_TDC)
{
	*XL_TDC = can_linux->XL_TDC;
	HAL_READ_LOGGING(8, "can_linux.XL_TDC", &can_linux->XL_TDC,
			 *XL_TDC);
}

void can_linux_xl_tdc_write(volatile CAN_CTRL_t *can_linux,
			    const uint8_t *XL_TDC)
{
	HAL_WRITE_LOGGING(8, "can_linux.XL_TDC", &can_linux->XL_TDC,
			  *XL_TDC);
	can_linux->XL_TDC = *XL_TDC;
}

void can_linux_relim_read(volatile CAN_CTRL_t *can_linux,
			  CAN_CTRL_RELIM_t *RELIM)
{
	RELIM->VALUE = can_linux->RELIM.VALUE;
	HAL_READ_LOGGING(8, "can_linux.RELIM", &can_linux->RELIM,
			 RELIM->VALUE);
}

void can_linux_relim_write(volatile CAN_CTRL_t *can_linux,
			   const CAN_CTRL_RELIM_t *RELIM)
{
	HAL_WRITE_LOGGING(8, "can_linux.RELIM", &can_linux->RELIM,
			  RELIM->VALUE);
	can_linux->RELIM.VALUE = RELIM->VALUE;
}

void can_linux_intf_read(volatile CAN_CTRL_t *can_linux, CAN_CTRL_INTF_t *INTF)
{
	INTF->VALUE = can_linux->INTF.VALUE;
	HAL_READ_LOGGING(32, "can_linux.INTF", &can_linux->INTF,
			 INTF->VALUE);
}

void can_linux_intf_write(volatile CAN_CTRL_t *can_linux,
			  const CAN_CTRL_INTF_t *INTF)
{
	HAL_WRITE_LOGGING(32, "can_linux.INTF", &can_linux->INTF,
			  INTF->VALUE);
	can_linux->INTF.VALUE = INTF->VALUE;
}

void can_linux_inte_read(volatile CAN_CTRL_t *can_linux, CAN_CTRL_INTE_t *INTE)
{
	INTE->VALUE = can_linux->INTE.VALUE;
	HAL_READ_LOGGING(32, "can_linux.INTE", &can_linux->INTE,
			 INTE->VALUE);
}

void can_linux_inte_write(volatile CAN_CTRL_t *can_linux,
			  const CAN_CTRL_INTE_t *INTE)
{
	HAL_WRITE_LOGGING(32, "can_linux.INTE", &can_linux->INTE,
			  INTE->VALUE);
	can_linux->INTE.VALUE = INTE->VALUE;
}

void can_linux_tstat_1_read(volatile CAN_CTRL_t *can_linux,
			    CAN_CTRL_TSTAT_1_t *TSTAT_1)
{
	TSTAT_1->VALUE = can_linux->TSTAT_1.VALUE;
	HAL_READ_LOGGING(16, "can_linux.TSTAT_1",
			 &can_linux->TSTAT_1, TSTAT_1->VALUE);
}

void can_linux_tstat_2_read(volatile CAN_CTRL_t *can_linux,
			    CAN_CTRL_TSTAT_2_t *TSTAT_2)
{
	TSTAT_2->VALUE = can_linux->TSTAT_2.VALUE;
	HAL_READ_LOGGING(16, "can_linux.TSTAT_2",
			 &can_linux->TSTAT_2, TSTAT_2->VALUE);
}

void can_linux_tts_read(volatile CAN_CTRL_t *can_linux, uint32_t idx,
			uint32_t *TTS)
{
	*TTS = can_linux->TTS[idx];
	HAL_READ_LOGGING(8, "can_linux.TTS", &can_linux->TTS, *TTS);
}

void can_linux_cfg_stat_read(volatile CAN_CTRL_t *can_linux,
			     CAN_CTRL_CFG_STAT_t *CFG_STAT)
{
	CFG_STAT->VALUE = can_linux->CFG_STAT.VALUE;
	HAL_READ_LOGGING(8, "can_linux.CFG_STAT",
			 &can_linux->CFG_STAT, CFG_STAT->VALUE);
}

void can_linux_cfg_stat_write(volatile CAN_CTRL_t *can_linux,
			      const CAN_CTRL_CFG_STAT_t *CFG_STAT)
{
	HAL_WRITE_LOGGING(8, "can_linux.CFG_STAT",
			  &can_linux->CFG_STAT, CFG_STAT->VALUE);
	can_linux->CFG_STAT.VALUE = CFG_STAT->VALUE;
}

void can_linux_tcmd_read(volatile CAN_CTRL_t *can_linux, CAN_CTRL_TCMD_t *TCMD)
{
	TCMD->VALUE = can_linux->TCMD.VALUE;
	HAL_READ_LOGGING(8, "can_linux.TCMD", &can_linux->TCMD,
			 TCMD->VALUE);
}

void can_linux_tcmd_write(volatile CAN_CTRL_t *can_linux,
			  const CAN_CTRL_TCMD_t *TCMD)
{
	HAL_WRITE_LOGGING(8, "can_linux.TCMD", &can_linux->TCMD,
			  TCMD->VALUE);
	can_linux->TCMD.VALUE = TCMD->VALUE;
}

void can_linux_tctrl_read(volatile CAN_CTRL_t *can_linux,
			  CAN_CTRL_TCTRL_t *TCTRL)
{
	TCTRL->VALUE = can_linux->TCTRL.VALUE;
	HAL_READ_LOGGING(8, "can_linux.TCTRL", &can_linux->TCTRL,
			 TCTRL->VALUE);
}

void can_linux_tctrl_write(volatile CAN_CTRL_t *can_linux,
			   const CAN_CTRL_TCTRL_t *TCTRL)
{
	HAL_WRITE_LOGGING(8, "can_linux.TCTRL", &can_linux->TCTRL,
			  TCTRL->VALUE);
	can_linux->TCTRL.VALUE = TCTRL->VALUE;
}

void can_linux_rctrl_read(volatile CAN_CTRL_t *can_linux,
			  CAN_CTRL_RCTRL_t *RCTRL)
{
	RCTRL->VALUE = can_linux->RCTRL.VALUE;
	HAL_READ_LOGGING(8, "can_linux.RCTRL", &can_linux->RCTRL,
			 RCTRL->VALUE);
}

void can_linux_rctrl_write(volatile CAN_CTRL_t *can_linux,
			   const CAN_CTRL_RCTRL_t *RCTRL)
{
	HAL_WRITE_LOGGING(8, "can_linux.RCTRL", &can_linux->RCTRL,
			  RCTRL->VALUE);
	can_linux->RCTRL.VALUE = RCTRL->VALUE;
}

void can_linux_limit_read(volatile CAN_CTRL_t *can_linux,
			  CAN_CTRL_LIMIT_t *LIMIT)
{
	LIMIT->VALUE = can_linux->LIMIT.VALUE;
	HAL_READ_LOGGING(8, "can_linux.LIMIT", &can_linux->LIMIT,
			 LIMIT->VALUE);
}

void can_linux_limit_write(volatile CAN_CTRL_t *can_linux,
			   const CAN_CTRL_LIMIT_t *LIMIT)
{
	HAL_WRITE_LOGGING(8, "can_linux.LIMIT", &can_linux->LIMIT,
			  LIMIT->VALUE);
	can_linux->LIMIT.VALUE = LIMIT->VALUE;
}

void can_linux_ealcap_read(volatile CAN_CTRL_t *can_linux,
			   CAN_CTRL_EALCAP_t *EALCAP)
{
	EALCAP->VALUE = can_linux->EALCAP.VALUE;
	HAL_READ_LOGGING(8, "can_linux.EALCAP", &can_linux->EALCAP,
			 EALCAP->VALUE);
}

void can_linux_recnt_read(volatile CAN_CTRL_t *can_linux, uint8_t *RECNT)
{
	*RECNT = can_linux->RECNT;
	HAL_READ_LOGGING(8, "can_linux.RECNT", &can_linux->RECNT,
			 *RECNT);
}

void can_linux_tecnt_read(volatile CAN_CTRL_t *can_linux, uint8_t *TECNT)
{
	*TECNT = can_linux->TECNT;
	HAL_READ_LOGGING(8, "can_linux.TECNT", &can_linux->TECNT,
			 *TECNT);
}

void can_linux_ref_msg_read(volatile CAN_CTRL_t *can_linux,
			    CAN_CTRL_REF_MSG_t *REF_MSG)
{
	REF_MSG->VALUE = can_linux->REF_MSG.VALUE;
	HAL_READ_LOGGING(32, "can_linux.REF_MSG",
			 &can_linux->REF_MSG, REF_MSG->VALUE);
}

void can_linux_ref_msg_write(volatile CAN_CTRL_t *can_linux,
			     const CAN_CTRL_REF_MSG_t *REF_MSG)
{
	HAL_WRITE_LOGGING(32, "can_linux.REF_MSG",
			  &can_linux->REF_MSG, REF_MSG->VALUE);
	can_linux->REF_MSG.VALUE = REF_MSG->VALUE;
}

void can_linux_trigcfg_0_read(volatile CAN_CTRL_t *can_linux,
			      CAN_CTRL_TRIGCFG_0_t *TRIGCFG_0)
{
	TRIGCFG_0->VALUE = can_linux->TRIGCFG_0.VALUE;
	HAL_READ_LOGGING(8, "can_linux.TRIGCFG_0",
			 &can_linux->TRIGCFG_0, TRIGCFG_0->VALUE);
}

void can_linux_trigcfg_0_write(volatile CAN_CTRL_t *can_linux,
			       const CAN_CTRL_TRIGCFG_0_t *TRIGCFG_0)
{
	HAL_WRITE_LOGGING(8, "can_linux.TRIGCFG_0",
			  &can_linux->TRIGCFG_0, TRIGCFG_0->VALUE);
	can_linux->TRIGCFG_0.VALUE = TRIGCFG_0->VALUE;
}

void can_linux_trigcfg_1_read(volatile CAN_CTRL_t *can_linux,
			      CAN_CTRL_TRIGCFG_1_t *TRIGCFG_1)
{
	TRIGCFG_1->VALUE = can_linux->TRIGCFG_1.VALUE;
	HAL_READ_LOGGING(8, "can_linux.TRIGCFG_1",
			 &can_linux->TRIGCFG_1, TRIGCFG_1->VALUE);
}

void can_linux_trigcfg_1_write(volatile CAN_CTRL_t *can_linux,
			       const CAN_CTRL_TRIGCFG_1_t *TRIGCFG_1)
{
	HAL_WRITE_LOGGING(8, "can_linux.TRIGCFG_1",
			  &can_linux->TRIGCFG_1, TRIGCFG_1->VALUE);
	can_linux->TRIGCFG_1.VALUE = TRIGCFG_1->VALUE;
}

void can_linux_tbslot_read(volatile CAN_CTRL_t *can_linux,
			   CAN_CTRL_TBSLOT_t *TBSLOT)
{
	TBSLOT->VALUE = can_linux->TBSLOT.VALUE;
	HAL_READ_LOGGING(8, "can_linux.TBSLOT", &can_linux->TBSLOT,
			 TBSLOT->VALUE);
}

void can_linux_tbslot_write(volatile CAN_CTRL_t *can_linux,
			    const CAN_CTRL_TBSLOT_t *TBSLOT)
{
	HAL_WRITE_LOGGING(8, "can_linux.TBSLOT", &can_linux->TBSLOT,
			  TBSLOT->VALUE);
	can_linux->TBSLOT.VALUE = TBSLOT->VALUE;
}

void can_linux_ttcfg_read(volatile CAN_CTRL_t *can_linux,
			  CAN_CTRL_TTCFG_t *TTCFG)
{
	TTCFG->VALUE = can_linux->TTCFG.VALUE;
	HAL_READ_LOGGING(8, "can_linux.TTCFG", &can_linux->TTCFG,
			 TTCFG->VALUE);
}

void can_linux_ttcfg_write(volatile CAN_CTRL_t *can_linux,
			   const CAN_CTRL_TTCFG_t *TTCFG)
{
	HAL_WRITE_LOGGING(8, "can_linux.TTCFG", &can_linux->TTCFG,
			  TTCFG->VALUE);
	can_linux->TTCFG.VALUE = TTCFG->VALUE;
}

void can_linux_tt_trig_read(volatile CAN_CTRL_t *can_linux, uint16_t *TT_TRIG)
{
	*TT_TRIG = can_linux->TT_TRIG;
	HAL_READ_LOGGING(16, "can_linux.TT_TRIG",
			 &can_linux->TT_TRIG, *TT_TRIG);
}

void can_linux_tt_trig_write(volatile CAN_CTRL_t *can_linux,
			     const uint16_t *TT_TRIG)
{
	HAL_WRITE_LOGGING(16, "can_linux.TT_TRIG",
			  &can_linux->TT_TRIG, *TT_TRIG);
	can_linux->TT_TRIG = *TT_TRIG;
}

void can_linux_tt_wtrig_read(volatile CAN_CTRL_t *can_linux, uint16_t *TT_WTRIG)
{
	*TT_WTRIG = can_linux->TT_WTRIG;
	HAL_READ_LOGGING(16, "can_linux.TT_WTRIG",
			 &can_linux->TT_WTRIG, *TT_WTRIG);
}

void can_linux_tt_wtrig_write(volatile CAN_CTRL_t *can_linux,
			      const uint16_t *TT_WTRIG)
{
	HAL_WRITE_LOGGING(16, "can_linux.TT_WTRIG",
			  &can_linux->TT_WTRIG, *TT_WTRIG);
	can_linux->TT_WTRIG = *TT_WTRIG;
}

void can_linux_fscfg_read(volatile CAN_CTRL_t *can_linux,
			  CAN_CTRL_FSCFG_t *FSCFG)
{
	FSCFG->VALUE = can_linux->FSCFG.VALUE;
	HAL_READ_LOGGING(8, "can_linux.FSCFG", &can_linux->FSCFG,
			 FSCFG->VALUE);
}

void can_linux_fscfg_write(volatile CAN_CTRL_t *can_linux,
			   const CAN_CTRL_FSCFG_t *FSCFG)
{
	HAL_WRITE_LOGGING(8, "can_linux.FSCFG", &can_linux->FSCFG,
			  FSCFG->VALUE);
	can_linux->FSCFG.VALUE = FSCFG->VALUE;
}

void can_linux_mem_stat_read(volatile CAN_CTRL_t *can_linux,
			     CAN_CTRL_MEM_STAT_t *MEM_STAT)
{
	MEM_STAT->VALUE = can_linux->MEM_STAT.VALUE;
	HAL_READ_LOGGING(8, "can_linux.MEM_STAT",
			 &can_linux->MEM_STAT, MEM_STAT->VALUE);
}

void can_linux_mem_stat_write(volatile CAN_CTRL_t *can_linux,
			      const CAN_CTRL_MEM_STAT_t *MEM_STAT)
{
	HAL_WRITE_LOGGING(8, "can_linux.MEM_STAT",
			  &can_linux->MEM_STAT, MEM_STAT->VALUE);
	can_linux->MEM_STAT.VALUE = MEM_STAT->VALUE;
}

void can_linux_mem_es_0_read(volatile CAN_CTRL_t *can_linux,
			     CAN_CTRL_MEM_ES_0_t *MEM_ES_0)
{
	MEM_ES_0->VALUE = can_linux->MEM_ES_0.VALUE;
	HAL_READ_LOGGING(8, "can_linux.MEM_ES_0",
			 &can_linux->MEM_ES_0, MEM_ES_0->VALUE);
}

void can_linux_mem_es_0_write(volatile CAN_CTRL_t *can_linux,
			      const CAN_CTRL_MEM_ES_0_t *MEM_ES_0)
{
	HAL_WRITE_LOGGING(8, "can_linux.MEM_ES_0",
			  &can_linux->MEM_ES_0, MEM_ES_0->VALUE);
	can_linux->MEM_ES_0.VALUE = MEM_ES_0->VALUE;
}

void can_linux_mem_es_1_read(volatile CAN_CTRL_t *can_linux,
			     CAN_CTRL_MEM_ES_1_t *MEM_ES_1)
{
	MEM_ES_1->VALUE = can_linux->MEM_ES_1.VALUE;
	HAL_READ_LOGGING(8, "can_linux.MEM_ES_1",
			 &can_linux->MEM_ES_1, MEM_ES_1->VALUE);
}

void can_linux_mem_es_1_write(volatile CAN_CTRL_t *can_linux,
			      const CAN_CTRL_MEM_ES_1_t *MEM_ES_1)
{
	HAL_WRITE_LOGGING(8, "can_linux.MEM_ES_1",
			  &can_linux->MEM_ES_1, MEM_ES_1->VALUE);
	can_linux->MEM_ES_1.VALUE = MEM_ES_1->VALUE;
}

void can_linux_mem_es_2_read(volatile CAN_CTRL_t *can_linux,
			     CAN_CTRL_MEM_ES_2_t *MEM_ES_2)
{
	MEM_ES_2->VALUE = can_linux->MEM_ES_2.VALUE;
	HAL_READ_LOGGING(8, "can_linux.MEM_ES_2",
			 &can_linux->MEM_ES_2, MEM_ES_2->VALUE);
}

void can_linux_mem_es_2_write(volatile CAN_CTRL_t *can_linux,
			      const CAN_CTRL_MEM_ES_2_t *MEM_ES_2)
{
	HAL_WRITE_LOGGING(8, "can_linux.MEM_ES_2",
			  &can_linux->MEM_ES_2, MEM_ES_2->VALUE);
	can_linux->MEM_ES_2.VALUE = MEM_ES_2->VALUE;
}

void can_linux_mem_es_3_read(volatile CAN_CTRL_t *can_linux,
			     CAN_CTRL_MEM_ES_3_t *MEM_ES_3)
{
	MEM_ES_3->VALUE = can_linux->MEM_ES_3.VALUE;
	HAL_READ_LOGGING(8, "can_linux.MEM_ES_3",
			 &can_linux->MEM_ES_3, MEM_ES_3->VALUE);
}

void can_linux_mem_es_3_write(volatile CAN_CTRL_t *can_linux,
			      const CAN_CTRL_MEM_ES_3_t *MEM_ES_3)
{
	HAL_WRITE_LOGGING(8, "can_linux.MEM_ES_3",
			  &can_linux->MEM_ES_3, MEM_ES_3->VALUE);
	can_linux->MEM_ES_3.VALUE = MEM_ES_3->VALUE;
}

void can_linux_acfctrl_read(volatile CAN_CTRL_t *can_linux,
			    CAN_CTRL_ACFCTRL_t *ACFCTRL)
{
	ACFCTRL->VALUE = can_linux->ACFCTRL.VALUE;
	HAL_READ_LOGGING(8, "can_linux.ACFCTRL",
			 &can_linux->ACFCTRL, ACFCTRL->VALUE);
}

void can_linux_acfctrl_write(volatile CAN_CTRL_t *can_linux,
			     const CAN_CTRL_ACFCTRL_t *ACFCTRL)
{
	HAL_WRITE_LOGGING(8, "can_linux.ACFCTRL",
			  &can_linux->ACFCTRL, ACFCTRL->VALUE);
	can_linux->ACFCTRL.VALUE = ACFCTRL->VALUE;
}

void can_linux_acf_en_0_read(volatile CAN_CTRL_t *can_linux,
			     CAN_CTRL_ACF_EN_0_t *ACF_EN_0)
{
	ACF_EN_0->VALUE = can_linux->ACF_EN_0.VALUE;
	HAL_READ_LOGGING(8, "can_linux.ACF_EN_0",
			 &can_linux->ACF_EN_0, ACF_EN_0->VALUE);
}

void can_linux_acf_en_0_write(volatile CAN_CTRL_t *can_linux,
			      const CAN_CTRL_ACF_EN_0_t *ACF_EN_0)
{
	HAL_WRITE_LOGGING(8, "can_linux.ACF_EN_0",
			  &can_linux->ACF_EN_0, ACF_EN_0->VALUE);
	can_linux->ACF_EN_0.VALUE = ACF_EN_0->VALUE;
}

void can_linux_acf_en_1_read(volatile CAN_CTRL_t *can_linux,
			     CAN_CTRL_ACF_EN_1_t *ACF_EN_1)
{
	ACF_EN_1->VALUE = can_linux->ACF_EN_1.VALUE;
	HAL_READ_LOGGING(8, "can_linux.ACF_EN_1",
			 &can_linux->ACF_EN_1, ACF_EN_1->VALUE);
}

void can_linux_acf_en_1_write(volatile CAN_CTRL_t *can_linux,
			      const CAN_CTRL_ACF_EN_1_t *ACF_EN_1)
{
	HAL_WRITE_LOGGING(8, "can_linux.ACF_EN_1",
			  &can_linux->ACF_EN_1, ACF_EN_1->VALUE);
	can_linux->ACF_EN_1.VALUE = ACF_EN_1->VALUE;
}

void can_linux_acfc_identifier_read(volatile CAN_CTRL_t *can_linux,
				    CAN_CTRL_ACFC_IDENTIFIER_t *ACFC_IDENTIFIER)
{
	ACFC_IDENTIFIER->VALUE = can_linux->ACFC_IDENTIFIER.VALUE;
	HAL_READ_LOGGING(32, "can_linux.ACFC_IDENTIFIER",
			 &can_linux->ACFC_IDENTIFIER, ACFC_IDENTIFIER->VALUE);
}

void can_linux_acfc_identifier_write(
	volatile CAN_CTRL_t *can_linux,
	const CAN_CTRL_ACFC_IDENTIFIER_t *ACFC_IDENTIFIER)
{
	HAL_WRITE_LOGGING(32, "can_linux.ACFC_IDENTIFIER",
			  &can_linux->ACFC_IDENTIFIER, ACFC_IDENTIFIER->VALUE);
	can_linux->ACFC_IDENTIFIER.VALUE = ACFC_IDENTIFIER->VALUE;
}

void can_linux_acfc_format_read(volatile CAN_CTRL_t *can_linux,
				CAN_CTRL_ACFC_FORMAT_t *ACFC_FORMAT)
{
	ACFC_FORMAT->VALUE = can_linux->ACFC_FORMAT.VALUE;
	HAL_READ_LOGGING(32, "can_linux.ACFC_FORMAT",
			 &can_linux->ACFC_FORMAT, ACFC_FORMAT->VALUE);
}

void can_linux_acfc_format_write(volatile CAN_CTRL_t *can_linux,
				 const CAN_CTRL_ACFC_FORMAT_t *ACFC_FORMAT)
{
	HAL_WRITE_LOGGING(32, "can_linux.ACFC_FORMAT",
			  &can_linux->ACFC_FORMAT, ACFC_FORMAT->VALUE);
	can_linux->ACFC_FORMAT.VALUE = ACFC_FORMAT->VALUE;
}

void can_linux_acfc_type_read(volatile CAN_CTRL_t *can_linux,
			      CAN_CTRL_ACFC_TYPE_t *ACFC_TYPE)
{
	ACFC_TYPE->VALUE = can_linux->ACFC_TYPE.VALUE;
	HAL_READ_LOGGING(32, "can_linux.ACFC_TYPE",
			 &can_linux->ACFC_TYPE, ACFC_TYPE->VALUE);
}

void can_linux_acfc_type_write(volatile CAN_CTRL_t *can_linux,
			       const CAN_CTRL_ACFC_TYPE_t *ACFC_TYPE)
{
	HAL_WRITE_LOGGING(32, "can_linux.ACFC_TYPE",
			  &can_linux->ACFC_TYPE, ACFC_TYPE->VALUE);
	can_linux->ACFC_TYPE.VALUE = ACFC_TYPE->VALUE;
}

void can_linux_acfc_acceptance_field_read(volatile CAN_CTRL_t *can_linux,
					  uint32_t *ACFC_ACCEPTANCE_FIELD)
{
	*ACFC_ACCEPTANCE_FIELD = can_linux->ACFC_ACCEPTANCE_FIELD;
	HAL_READ_LOGGING(32, "can_linux.ACFC_ACCEPTANCE_FIELD",
			 &can_linux->ACFC_ACCEPTANCE_FIELD,
			 *ACFC_ACCEPTANCE_FIELD);
}

void can_linux_acfc_acceptance_field_write(
	volatile CAN_CTRL_t *can_linux, const uint32_t *ACFC_ACCEPTANCE_FIELD)
{
	HAL_WRITE_LOGGING(32, "can_linux.ACFC_ACCEPTANCE_FIELD",
			  &can_linux->ACFC_ACCEPTANCE_FIELD,
			  *ACFC_ACCEPTANCE_FIELD);
	can_linux->ACFC_ACCEPTANCE_FIELD = *ACFC_ACCEPTANCE_FIELD;
}

void can_linux_acfm_identifier_read(volatile CAN_CTRL_t *can_linux,
				    CAN_CTRL_ACFM_IDENTIFIER_t *ACFM_IDENTIFIER)
{
	ACFM_IDENTIFIER->VALUE = can_linux->ACFM_IDENTIFIER.VALUE;
	HAL_READ_LOGGING(32, "can_linux.ACFM_IDENTIFIER",
			 &can_linux->ACFM_IDENTIFIER, ACFM_IDENTIFIER->VALUE);
}

void can_linux_acfm_identifier_write(
	volatile CAN_CTRL_t *can_linux,
	const CAN_CTRL_ACFM_IDENTIFIER_t *ACFM_IDENTIFIER)
{
	HAL_WRITE_LOGGING(32, "can_linux.ACFM_IDENTIFIER",
			  &can_linux->ACFM_IDENTIFIER, ACFM_IDENTIFIER->VALUE);
	can_linux->ACFM_IDENTIFIER.VALUE = ACFM_IDENTIFIER->VALUE;
}

void can_linux_acfm_format_read(volatile CAN_CTRL_t *can_linux,
				CAN_CTRL_ACFM_FORMAT_t *ACFM_FORMAT)
{
	ACFM_FORMAT->VALUE = can_linux->ACFM_FORMAT.VALUE;
	HAL_READ_LOGGING(32, "can_linux.ACFM_FORMAT",
			 &can_linux->ACFM_FORMAT, ACFM_FORMAT->VALUE);
}

void can_linux_acfm_format_write(volatile CAN_CTRL_t *can_linux,
				 const CAN_CTRL_ACFM_FORMAT_t *ACFM_FORMAT)
{
	HAL_WRITE_LOGGING(32, "can_linux.ACFM_FORMAT",
			  &can_linux->ACFM_FORMAT, ACFM_FORMAT->VALUE);
	can_linux->ACFM_FORMAT.VALUE = ACFM_FORMAT->VALUE;
}

void can_linux_acfm_type_read(volatile CAN_CTRL_t *can_linux,
			      CAN_CTRL_ACFM_TYPE_t *ACFM_TYPE)
{
	ACFM_TYPE->VALUE = can_linux->ACFM_TYPE.VALUE;
	HAL_READ_LOGGING(32, "can_linux.ACFM_TYPE",
			 &can_linux->ACFM_TYPE, ACFM_TYPE->VALUE);
}

void can_linux_acfm_type_write(volatile CAN_CTRL_t *can_linux,
			       const CAN_CTRL_ACFM_TYPE_t *ACFM_TYPE)
{
	HAL_WRITE_LOGGING(32, "can_linux.ACFM_TYPE",
			  &can_linux->ACFM_TYPE, ACFM_TYPE->VALUE);
	can_linux->ACFM_TYPE.VALUE = ACFM_TYPE->VALUE;
}

void can_linux_acfm_acceptance_field_read(volatile CAN_CTRL_t *can_linux,
					  uint32_t *ACFM_ACCEPTANCE_FIELD)
{
	*ACFM_ACCEPTANCE_FIELD = can_linux->ACFM_ACCEPTANCE_FIELD;
	HAL_READ_LOGGING(32, "can_linux.ACFM_ACCEPTANCE_FIELD",
			 &can_linux->ACFM_ACCEPTANCE_FIELD,
			 *ACFM_ACCEPTANCE_FIELD);
}

void can_linux_acfm_acceptance_field_write(
	volatile CAN_CTRL_t *can_linux, const uint32_t *ACFM_ACCEPTANCE_FIELD)
{
	HAL_WRITE_LOGGING(32, "can_linux.ACFM_ACCEPTANCE_FIELD",
			  &can_linux->ACFM_ACCEPTANCE_FIELD,
			  *ACFM_ACCEPTANCE_FIELD);
	can_linux->ACFM_ACCEPTANCE_FIELD = *ACFM_ACCEPTANCE_FIELD;
}

void can_linux_rbuf_identifier_read(volatile CAN_CTRL_t *can_linux,
				    CAN_CTRL_RBUF_IDENTIFIER_t *RBUF_IDENTIFIER)
{
	RBUF_IDENTIFIER->VALUE = can_linux->RBUF_IDENTIFIER.VALUE;
	HAL_READ_LOGGING(32, "can_linux.RBUF_IDENTIFIER",
			 &can_linux->RBUF_IDENTIFIER, RBUF_IDENTIFIER->VALUE);
}

void can_linux_rbuf_identifier_write(
	volatile CAN_CTRL_t *can_linux,
	const CAN_CTRL_RBUF_IDENTIFIER_t *RBUF_IDENTIFIER)
{
	HAL_WRITE_LOGGING(32, "can_linux.RBUF_IDENTIFIER",
			  &can_linux->RBUF_IDENTIFIER, RBUF_IDENTIFIER->VALUE);
	can_linux->RBUF_IDENTIFIER.VALUE = RBUF_IDENTIFIER->VALUE;
}

void can_linux_rbuf_format_read(volatile CAN_CTRL_t *can_linux,
				CAN_CTRL_RBUF_FORMAT_t *RBUF_FORMAT)
{
	RBUF_FORMAT->VALUE = can_linux->RBUF_FORMAT.VALUE;
	HAL_READ_LOGGING(32, "can_linux.RBUF_FORMAT",
			 &can_linux->RBUF_FORMAT, RBUF_FORMAT->VALUE);
}

void can_linux_rbuf_format_write(volatile CAN_CTRL_t *can_linux,
				 const CAN_CTRL_RBUF_FORMAT_t *RBUF_FORMAT)
{
	HAL_WRITE_LOGGING(32, "can_linux.RBUF_FORMAT",
			  &can_linux->RBUF_FORMAT, RBUF_FORMAT->VALUE);
	can_linux->RBUF_FORMAT.VALUE = RBUF_FORMAT->VALUE;
}

void can_linux_rbuf_type_read(volatile CAN_CTRL_t *can_linux,
			      CAN_CTRL_RBUF_TYPE_t *RBUF_TYPE)
{
	RBUF_TYPE->VALUE = can_linux->RBUF_TYPE.VALUE;
	HAL_READ_LOGGING(32, "can_linux.RBUF_TYPE",
			 &can_linux->RBUF_TYPE, RBUF_TYPE->VALUE);
}

void can_linux_rbuf_type_write(volatile CAN_CTRL_t *can_linux,
			       const CAN_CTRL_RBUF_TYPE_t *RBUF_TYPE)
{
	HAL_WRITE_LOGGING(32, "can_linux.RBUF_TYPE",
			  &can_linux->RBUF_TYPE, RBUF_TYPE->VALUE);
	can_linux->RBUF_TYPE.VALUE = RBUF_TYPE->VALUE;
}

void can_linux_rbuf_acceptance_field_read(volatile CAN_CTRL_t *can_linux,
					  uint32_t *RBUF_ACCEPTANCE_FIELD)
{
	*RBUF_ACCEPTANCE_FIELD = can_linux->RBUF_ACCEPTANCE_FIELD;
	HAL_READ_LOGGING(32, "can_linux.RBUF_ACCEPTANCE_FIELD",
			 &can_linux->RBUF_ACCEPTANCE_FIELD,
			 *RBUF_ACCEPTANCE_FIELD);
}

void can_linux_rbuf_acceptance_field_write(
	volatile CAN_CTRL_t *can_linux, const uint32_t *RBUF_ACCEPTANCE_FIELD)
{
	HAL_WRITE_LOGGING(32, "can_linux.RBUF_ACCEPTANCE_FIELD",
			  &can_linux->RBUF_ACCEPTANCE_FIELD,
			  *RBUF_ACCEPTANCE_FIELD);
	can_linux->RBUF_ACCEPTANCE_FIELD = *RBUF_ACCEPTANCE_FIELD;
}

void can_linux_rbuf_payload_read(volatile CAN_CTRL_t *can_linux, uint32_t *data,
				 uint32_t num_elem, uint32_t ofs_elem)
{
	for (uint32_t i = 0; i < num_elem; i++) {
		data[i] = can_linux->RBUF_PAYLOAD[i + ofs_elem];
		HAL_READ_LOGGING(32, "can_linux.RBUF_PAYLOAD",
				 &can_linux->RBUF_PAYLOAD, data[i]);
	}
}

void can_linux_rbuf_payload_write(volatile CAN_CTRL_t *can_linux,
				  const uint32_t *data, uint32_t num_elem,
				  uint32_t ofs_elem)
{
	for (uint32_t i = 0; i < num_elem; i++) {
		HAL_WRITE_LOGGING(32, "can_linux.RBUF_PAYLOAD",
				  &can_linux->RBUF_PAYLOAD, data[i]);
		can_linux->RBUF_PAYLOAD[i + ofs_elem] = data[i];
	}
}

void can_linux_rbuf_cia_603_read(volatile CAN_CTRL_t *can_linux, uint32_t *data,
				 uint32_t num_elem, uint32_t ofs_elem)
{
	for (uint32_t i = 0; i < num_elem; i++) {
		data[i] = can_linux->RBUF_CIA_603[i + ofs_elem];
		HAL_READ_LOGGING(32, "can_linux.RBUF_CIA_603",
				 &can_linux->RBUF_CIA_603, data[i]);
	}
}

void can_linux_rbuf_cia_603_write(volatile CAN_CTRL_t *can_linux,
				  const uint32_t *data, uint32_t num_elem,
				  uint32_t ofs_elem)
{
	for (uint32_t i = 0; i < num_elem; i++) {
		HAL_WRITE_LOGGING(32, "can_linux.RBUF_CIA_603",
				  &can_linux->RBUF_CIA_603, data[i]);
		can_linux->RBUF_CIA_603[i + ofs_elem] = data[i];
	}
}

void can_linux_rbuf_ttcan_read(volatile CAN_CTRL_t *can_linux,
			       CAN_CTRL_RBUF_TTCAN_t *RBUF_TTCAN)
{
	RBUF_TTCAN->VALUE = can_linux->RBUF_TTCAN.VALUE;
	HAL_READ_LOGGING(32, "can_linux.RBUF_TTCAN",
			 &can_linux->RBUF_TTCAN, RBUF_TTCAN->VALUE);
}

void can_linux_rbuf_ttcan_write(volatile CAN_CTRL_t *can_linux,
				const CAN_CTRL_RBUF_TTCAN_t *RBUF_TTCAN)
{
	HAL_WRITE_LOGGING(32, "can_linux.RBUF_TTCAN",
			  &can_linux->RBUF_TTCAN, RBUF_TTCAN->VALUE);
	can_linux->RBUF_TTCAN.VALUE = RBUF_TTCAN->VALUE;
}

void can_linux_tbuf_identifier_read(volatile CAN_CTRL_t *can_linux,
				    CAN_CTRL_TBUF_IDENTIFIER_t *TBUF_IDENTIFIER)
{
	TBUF_IDENTIFIER->VALUE = can_linux->TBUF_IDENTIFIER.VALUE;
	HAL_READ_LOGGING(32, "can_linux.TBUF_IDENTIFIER",
			 &can_linux->TBUF_IDENTIFIER, TBUF_IDENTIFIER->VALUE);
}

void can_linux_tbuf_identifier_write(
	volatile CAN_CTRL_t *can_linux,
	const CAN_CTRL_TBUF_IDENTIFIER_t *TBUF_IDENTIFIER)
{
	HAL_WRITE_LOGGING(32, "can_linux.TBUF_IDENTIFIER",
			  &can_linux->TBUF_IDENTIFIER, TBUF_IDENTIFIER->VALUE);
	can_linux->TBUF_IDENTIFIER.VALUE = TBUF_IDENTIFIER->VALUE;
}

void can_linux_tbuf_format_read(volatile CAN_CTRL_t *can_linux,
				CAN_CTRL_TBUF_FORMAT_t *TBUF_FORMAT)
{
	TBUF_FORMAT->VALUE = can_linux->TBUF_FORMAT.VALUE;
	HAL_READ_LOGGING(32, "can_linux.TBUF_FORMAT",
			 &can_linux->TBUF_FORMAT, TBUF_FORMAT->VALUE);
}

void can_linux_tbuf_format_write(volatile CAN_CTRL_t *can_linux,
				 const CAN_CTRL_TBUF_FORMAT_t *TBUF_FORMAT)
{
	HAL_WRITE_LOGGING(32, "can_linux.TBUF_FORMAT",
			  &can_linux->TBUF_FORMAT, TBUF_FORMAT->VALUE);
	can_linux->TBUF_FORMAT.VALUE = TBUF_FORMAT->VALUE;
}

void can_linux_tbuf_type_read(volatile CAN_CTRL_t *can_linux,
			      CAN_CTRL_TBUF_TYPE_t *TBUF_TYPE)
{
	TBUF_TYPE->VALUE = can_linux->TBUF_TYPE.VALUE;
	HAL_READ_LOGGING(32, "can_linux.TBUF_TYPE",
			 &can_linux->TBUF_TYPE, TBUF_TYPE->VALUE);
}

void can_linux_tbuf_type_write(volatile CAN_CTRL_t *can_linux,
			       const CAN_CTRL_TBUF_TYPE_t *TBUF_TYPE)
{
	HAL_WRITE_LOGGING(32, "can_linux.TBUF_TYPE",
			  &can_linux->TBUF_TYPE, TBUF_TYPE->VALUE);
	can_linux->TBUF_TYPE.VALUE = TBUF_TYPE->VALUE;
}

void can_linux_tbuf_acceptance_field_read(volatile CAN_CTRL_t *can_linux,
					  uint32_t *TBUF_ACCEPTANCE_FIELD)
{
	*TBUF_ACCEPTANCE_FIELD = can_linux->TBUF_ACCEPTANCE_FIELD;
	HAL_READ_LOGGING(32, "can_linux.TBUF_ACCEPTANCE_FIELD",
			 &can_linux->TBUF_ACCEPTANCE_FIELD,
			 *TBUF_ACCEPTANCE_FIELD);
}

void can_linux_tbuf_acceptance_field_write(
	volatile CAN_CTRL_t *can_linux, const uint32_t *TBUF_ACCEPTANCE_FIELD)
{
	HAL_WRITE_LOGGING(32, "can_linux.TBUF_ACCEPTANCE_FIELD",
			  &can_linux->TBUF_ACCEPTANCE_FIELD,
			  *TBUF_ACCEPTANCE_FIELD);
	can_linux->TBUF_ACCEPTANCE_FIELD = *TBUF_ACCEPTANCE_FIELD;
}

void can_linux_tbuf_payload_read(volatile CAN_CTRL_t *can_linux, uint32_t *data,
				 uint32_t num_elem, uint32_t ofs_elem)
{
	for (uint32_t i = 0; i < num_elem; i++) {
		data[i] = can_linux->TBUF_PAYLOAD[i + ofs_elem];
		HAL_READ_LOGGING(32, "can_linux.TBUF_PAYLOAD",
				 &can_linux->TBUF_PAYLOAD, data[i]);
	}
}

void can_linux_tbuf_payload_write(volatile CAN_CTRL_t *can_linux,
				  const uint32_t *data, uint32_t num_elem,
				  uint32_t ofs_elem)
{
	for (uint32_t i = 0; i < num_elem; i++) {
		HAL_WRITE_LOGGING(32, "can_linux.TBUF_PAYLOAD",
				  &can_linux->TBUF_PAYLOAD, data[i]);
		can_linux->TBUF_PAYLOAD[i + ofs_elem] = data[i];
	}
}

void can_linux_pwm_cfg_read(volatile CAN_CTRL_t *can_linux,
			    CAN_CTRL_PWM_CFG_t *PWM_CFG)
{
	PWM_CFG->VALUE = can_linux->PWM_CFG.VALUE;
	HAL_READ_LOGGING(32, "can_linux.PWM_CFG",
			 &can_linux->PWM_CFG, PWM_CFG->VALUE);
}

void can_linux_pwm_cfg_write(volatile CAN_CTRL_t *can_linux,
			     const CAN_CTRL_PWM_CFG_t *PWM_CFG)
{
	HAL_WRITE_LOGGING(32, "can_linux.PWM_CFG",
			  &can_linux->PWM_CFG, PWM_CFG->VALUE);
	can_linux->PWM_CFG.VALUE = PWM_CFG->VALUE;
}

void can_linux_str_cfg_read(volatile CAN_CTRL_t *can_linux,
			    CAN_CTRL_STR_CFG_t *STR_CFG)
{
	STR_CFG->VALUE = can_linux->STR_CFG.VALUE;
	HAL_READ_LOGGING(32, "can_linux.STR_CFG",
			 &can_linux->STR_CFG, STR_CFG->VALUE);
}

void can_linux_str_cfg_write(volatile CAN_CTRL_t *can_linux,
			     const CAN_CTRL_STR_CFG_t *STR_CFG)
{
	HAL_WRITE_LOGGING(32, "can_linux.STR_CFG",
			  &can_linux->STR_CFG, STR_CFG->VALUE);
	can_linux->STR_CFG.VALUE = STR_CFG->VALUE;
}

void can_linux_llcformat_read(volatile CAN_CTRL_t *can_linux,
			      uint32_t *LLCFORMAT)
{
	*LLCFORMAT = can_linux->LLCFORMAT;
	HAL_READ_LOGGING(32, "can_linux.LLCFORMAT",
			 &can_linux->LLCFORMAT, *LLCFORMAT);
}

void can_linux_llcformat_write(volatile CAN_CTRL_t *can_linux,
			       const uint32_t *LLCFORMAT)
{
	HAL_WRITE_LOGGING(32, "can_linux.LLCFORMAT",
			  &can_linux->LLCFORMAT, *LLCFORMAT);
	can_linux->LLCFORMAT = *LLCFORMAT;
}

void can_linux_llcsize_read(volatile CAN_CTRL_t *can_linux,
			    CAN_CTRL_LLCSIZE_t *LLCSIZE)
{
	LLCSIZE->VALUE = can_linux->LLCSIZE.VALUE;
	HAL_READ_LOGGING(32, "can_linux.LLCSIZE",
			 &can_linux->LLCSIZE, LLCSIZE->VALUE);
}
