hpm_lin_drv.h

Go to the documentation of this file.

/*
 * Copyright (c) 2022 HPMicro
 *
 * SPDX-License-Identifier: BSD-3-Clause
 *
 */
 
#ifndef HPM_LIN_DRV_H
#define HPM_LIN_DRV_H
 
#include <math.h>
#include "hpm_common.h"
#include "hpm_lin_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 uint8_t lin_get_status(LIN_Type *ptr)
{
    return ptr->STATE;
}
 
static inline void lin_reset_interrupt(LIN_Type *ptr)
{
    ptr->CONTROL |= LIN_CONTROL_RESET_INT_MASK;
}
 
static inline void lin_reset_error(LIN_Type *ptr)
{
    ptr->CONTROL |= LIN_CONTROL_RESET_ERROR_MASK;
}
 
static inline void lin_wakeup(LIN_Type *ptr)
{
    ptr->CONTROL |= LIN_CONTROL_WAKEUP_REQ_MASK;
}
 
static inline void lin_sleep(LIN_Type *ptr)
{
    ptr->CONTROL |= LIN_CONTROL_SLEEP_MASK;
}
 
static inline void lin_slave_stop(LIN_Type *ptr)
{
    ptr->CONTROL |= LIN_CONTROL_STOP_MASK;
}
 
static inline void lin_slave_ack(LIN_Type *ptr)
{
    ptr->CONTROL |= LIN_CONTROL_DATA_ACK_MASK;
}
 
static inline void lin_slave_set_bus_inactivity_time(LIN_Type *ptr, lin_bus_inactivity_time_t time)
{
    ptr->TV |= LIN_TV_BUS_INACTIVITY_TIME_SET(time);
}
 
static inline void lin_slave_set_wakeup_repeat_time(LIN_Type *ptr, lin_wakeup_repeat_time_t time)
{
    ptr->TV |= LIN_TV_WUP_REPEAT_TIME_SET(time);
}
 
static inline void lin_set_mode(LIN_Type *ptr, bool master)
{
    if (master) {
        ptr->TV |= LIN_TV_MASTER_MODE_MASK;
    } else {
        ptr->TV &= ~LIN_TV_MASTER_MODE_MASK;
    }
}
 
static inline uint8_t lin_get_data_byte(LIN_Type *ptr, uint8_t index)
{
    return ptr->DATABYTE[index];
}
 
static inline void lin_write_data_byte(LIN_Type *ptr, uint8_t index, uint8_t data)
{
    ptr->DATABYTE[index] = data;
}
 
static inline bool lin_is_active(LIN_Type *ptr)
{
    return ((ptr->STATE & LIN_STATE_LIN_ACTIVE_MASK) == LIN_STATE_LIN_ACTIVE_MASK) ? true : false;
}
 
static inline bool lin_is_complete(LIN_Type *ptr)
{
    return ((ptr->STATE & LIN_STATE_COMPLETE_MASK) == LIN_STATE_COMPLETE_MASK) ? true : false;
}
 
static inline uint8_t lin_get_id(LIN_Type *ptr)
{
    return ptr->ID;
}
 
hpm_stat_t lin_master_configure_timing(LIN_Type *ptr, lin_timing_t *timing);
 
hpm_stat_t lin_slave_configure_timing(LIN_Type *ptr, uint32_t src_freq_in_hz);
 
void lin_master_transfer(LIN_Type *ptr, lin_trans_config_t *config);
 
void lin_slave_transfer(LIN_Type *ptr, lin_trans_config_t *config);
 
uint8_t lin_get_data_length(LIN_Type *ptr);
 
hpm_stat_t lin_master_sent(LIN_Type *ptr, lin_trans_config_t *config);
 
hpm_stat_t lin_master_receive(LIN_Type *ptr, lin_trans_config_t *config);
 
hpm_stat_t lin_slave_sent(LIN_Type *ptr, lin_trans_config_t *config);
 
hpm_stat_t lin_slave_receive(LIN_Type *ptr, lin_trans_config_t *config);
 
#ifdef __cplusplus
}
#endif
 
#endif /* HPM_LIN_DRV_H */