hpm_linv2_drv.h

Go to the documentation of this file.

/*
 * Copyright (c) 2022 HPMicro
 *
 * SPDX-License-Identifier: BSD-3-Clause
 *
 */
 
#ifndef HPM_LINV2_DRV_H
#define HPM_LINV2_DRV_H
 
#include <math.h>
#include "hpm_common.h"
#include "hpm_linv2_regs.h"
#include "hpm_soc_feature.h"
 
#define LIN_ID_DATA_LEN_SHIFT 4U
#define LIN_ID_DATA_LEN_MASK  0x30U
#define LIN_ID_DATA_LEN_GET(x) (((uint8_t)(x) & LIN_ID_DATA_LEN_MASK) >> LIN_ID_DATA_LEN_SHIFT)
 
typedef enum {
    id_data_length_2bytes,
    id_data_length_2bytes_2, 
    id_data_length_4bytes,
    id_data_length_8bytes
} lin_id_data_length_t;
 
typedef enum  {
    bus_inactivity_time_4s,
    bus_inactivity_time_6s,
    bus_inactivity_time_8s,
    bus_inactivity_time_10s
} lin_bus_inactivity_time_t;
 
typedef enum {
    wakeup_repeat_time_180ms,
    wakeup_repeat_time_200ms,
    wakeup_repeat_time_220ms,
    wakeup_repeat_time_240ms
} lin_wakeup_repeat_time_t;
 
typedef struct {
    uint32_t src_freq_in_hz;        
    uint32_t baudrate;              
} lin_timing_t;
 
typedef struct {
    uint8_t id;                     
    uint8_t *data_buff;             
    bool data_length_from_id;       
    uint8_t data_length;            
    bool enhanced_checksum;         
    bool transmit;                  
    /* bool start; */               
} lin_trans_config_t;
 
#ifdef __cplusplus
extern "C" {
#endif
 
static inline uint32_t lin_get_control_and_status(LINV2_Type *ptr)
{
    return ptr->CONTROL_STATUS;
}
 
static inline void lin_reset_interrupt(LINV2_Type *ptr)
{
    ptr->CONTROL_STATUS = ((ptr->CONTROL_STATUS) & ~LINV2_CONTROL_STATUS_SLEEP_MASK) | LINV2_CONTROL_STATUS_RESET_INT_MASK;
}
 
static inline void lin_reset_error(LINV2_Type *ptr)
{
    ptr->CONTROL_STATUS = ((ptr->CONTROL_STATUS) & ~LINV2_CONTROL_STATUS_SLEEP_MASK) | LINV2_CONTROL_STATUS_RESET_ERROR_MASK;
}
 
static inline void lin_wakeup(LINV2_Type *ptr)
{
    ptr->CONTROL_STATUS = ((ptr->CONTROL_STATUS) & ~LINV2_CONTROL_STATUS_SLEEP_MASK) | LINV2_CONTROL_STATUS_WAKEUP_REQ_MASK;
}
 
static inline void lin_sleep(LINV2_Type *ptr)
{
    ptr->CONTROL_STATUS |= LINV2_CONTROL_STATUS_SLEEP_MASK;
}
 
static inline void lin_slave_stop(LINV2_Type *ptr)
{
    ptr->CONTROL_STATUS = ((ptr->CONTROL_STATUS) & ~LINV2_CONTROL_STATUS_SLEEP_MASK) | LINV2_CONTROL_STATUS_STOP_MASK;
}
 
static inline void lin_slave_ack(LINV2_Type *ptr)
{
    ptr->CONTROL_STATUS = ((ptr->CONTROL_STATUS) & ~LINV2_CONTROL_STATUS_SLEEP_MASK) | LINV2_CONTROL_STATUS_DATA_ACK_MASK;
}
 
static inline void lin_slave_set_bus_inactivity_time(LINV2_Type *ptr, lin_bus_inactivity_time_t time)
{
    ptr->TIMING_CONTROL = (ptr->TIMING_CONTROL & (~LINV2_TIMING_CONTROL_BUS_INACTIVE_TIME_MASK))
                            | LINV2_TIMING_CONTROL_BUS_INACTIVE_TIME_SET(time);
}
 
static inline void lin_slave_set_wakeup_repeat_time(LINV2_Type *ptr, lin_wakeup_repeat_time_t time)
{
    ptr->TIMING_CONTROL = (ptr->TIMING_CONTROL & (~LINV2_TIMING_CONTROL_WUP_REPEAT_TIME_MASK))
                            | LINV2_TIMING_CONTROL_WUP_REPEAT_TIME_SET(time);
}
 
static inline void lin_set_mode(LINV2_Type *ptr, bool master)
{
    if (master) {
        ptr->TIMING_CONTROL |= LINV2_TIMING_CONTROL_MASTER_MODE_MASK;
    } else {
        ptr->TIMING_CONTROL &= ~LINV2_TIMING_CONTROL_MASTER_MODE_MASK;
    }
}
 
static inline void lin_set_checksum_mode(LINV2_Type *ptr, bool enhance_checksum)
{
    if (enhance_checksum) {
        ptr->DATA_LEN_ID |= LINV2_DATA_LEN_ID_ENH_CHECK_MASK;
    } else {
        ptr->DATA_LEN_ID &= ~LINV2_DATA_LEN_ID_ENH_CHECK_MASK;
    }
}
 
static inline uint8_t lin_get_data_byte(LINV2_Type *ptr, uint8_t index)
{
    return ptr->DATA_BYTE[index];
}
 
static inline void lin_write_data_byte(LINV2_Type *ptr, uint8_t index, uint8_t data)
{
    ptr->DATA_BYTE[index] = data;
}
 
static inline uint8_t lin_get_id(LINV2_Type *ptr)
{
    return (uint8_t)LINV2_DATA_LEN_ID_ID_GET(ptr->DATA_LEN_ID);
}
 
static inline uint8_t lin_get_checksum(LINV2_Type *ptr)
{
    return (uint8_t)LINV2_DATA_LEN_ID_CHECKSUM_GET(ptr->DATA_LEN_ID);
}
 
static inline uint8_t lin_is_active(LINV2_Type *ptr)
{
    return ((ptr->CONTROL_STATUS & LINV2_CONTROL_STATUS_LIN_ACTIVE_MASK) == LINV2_CONTROL_STATUS_LIN_ACTIVE_MASK) ? true : false;
}
 
static inline uint8_t lin_is_complete(LINV2_Type *ptr)
{
    return ((ptr->CONTROL_STATUS & LINV2_CONTROL_STATUS_COMPLETE_MASK) == LINV2_CONTROL_STATUS_COMPLETE_MASK) ? true : false;
}
 
hpm_stat_t lin_master_configure_timing(LINV2_Type *ptr, lin_timing_t *timing);
 
hpm_stat_t lin_slave_configure_timing(LINV2_Type *ptr, uint32_t src_freq_in_hz);
 
void lin_master_transfer(LINV2_Type *ptr, lin_trans_config_t *config);
 
void lin_slave_transfer(LINV2_Type *ptr, lin_trans_config_t *config);
 
uint8_t lin_get_data_length(LINV2_Type *ptr);
 
hpm_stat_t lin_master_sent(LINV2_Type *ptr, lin_trans_config_t *config);
 
hpm_stat_t lin_master_receive(LINV2_Type *ptr, lin_trans_config_t *config);
 
hpm_stat_t lin_slave_sent(LINV2_Type *ptr, lin_trans_config_t *config);
 
hpm_stat_t lin_slave_receive(LINV2_Type *ptr, lin_trans_config_t *config);
 
void lin_slave_dma_transfer(LINV2_Type *ptr, lin_trans_config_t *config);
 
#ifdef __cplusplus
}
#endif
 
#endif /* HPM_LINV2_DRV_H */