tamagawa_drv.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2022 Texas Instruments Incorporated
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *    Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 *    Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the
 *    distribution.
 *
 *    Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *  "AS IS" AND ANY EXPgResS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef TAMAGAWA_DRV_H_
#define TAMAGAWA_DRV_H_
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* ========================================================================== */
/*                             Include Files                                  */
/* ========================================================================== */
 
#include <stdio.h>
#include <string.h>
#include <math.h>
 
#include <drivers/pruicss.h>
 
/* ========================================================================== */
/*                           Macros & Typedefs                                */
/* ========================================================================== */
 
#define TAMAGAWA_MULTI_CH0 (1 << 0)
 
#define TAMAGAWA_MULTI_CH1 (1 << 1)
 
#define TAMAGAWA_MULTI_CH2 (1 << 2)
 
#define MAX_CHANNELS (3)
 
#define MAX_EEPROM_ADDRESS (127)
 
#define MAX_EEPROM_WRITE_DATA (255)
 
 
enum data_id
{
    DATA_ID_0,  
    DATA_ID_1,  
    DATA_ID_2,  
    DATA_ID_3,  
    DATA_ID_6,  
    DATA_ID_7,  
    DATA_ID_8,  
    DATA_ID_C,  
    DATA_ID_D,  
    DATA_ID_NUM 
};
 
/* ========================================================================== */
/*                         Structure Declarations                             */
/* ========================================================================== */
 
struct tamagawa_ch_info
{
    volatile uint32_t    pos_word0;          
    volatile uint32_t   pos_word1;          
    volatile uint32_t   pos_word2;          
    volatile uint32_t  cal_crc;             
};
 
struct tamagawa_cmd
{
    volatile uint32_t   word0;
    volatile uint32_t   word1;
};
 
struct tamagawa_config
{
    volatile uint8_t  opmode;
    volatile uint8_t  channel;
    volatile uint8_t  trigger;
    volatile uint8_t  status;
};
 
struct rx_frames_received
{
    uint32_t abs;   
    uint32_t abm;   
    uint8_t  cf;    
    uint8_t  sf;    
    uint8_t  enid;  
    uint8_t  almc;  
    uint8_t  adf;   
    uint8_t  edf;   
    uint8_t  crc;   
};
struct tamagawa_interface
{
    uint8_t ch_mask;   //**< Mask for what channel is required*/
    volatile uint32_t  rx_div_factor;   //**< Rx Divide factor*/
 
    volatile uint32_t  tx_div_factor;   //**< Tx Divide factor*/
 
    volatile uint32_t  oversample_rate; //**< Oversampling rate*/
 
    uint32_t version;  
    uint8_t  data_id;  
    struct rx_frames_received rx_frames_received;      
    uint8_t tx_frames;  
    uint8_t rx_frames;  
};
 
struct config
{
    uint8_t  ch0;   
    uint8_t  ch1;   
    uint8_t  ch2;   
};
 
struct tamagawa_eeprom_interface
{
    volatile uint32_t cmd; 
    volatile uint32_t adf; 
    volatile uint32_t edf; 
    volatile uint32_t crc; 
    volatile uint32_t word0; 
    volatile uint32_t word1; 
    volatile uint32_t word2; 
    uint64_t eeprom_tx_data; 
};
 
 
struct tamagawa_xchg
{
    struct tamagawa_config   config;
    struct tamagawa_cmd      cmd;
    struct tamagawa_ch_info  ch[3];
    struct tamagawa_interface tamagawa_interface;
    struct tamagawa_eeprom_interface tamagawa_eeprom_interface[3];
};
 
struct tamagawa_clk_cfg
{
    uint16_t  rx_div;   
    uint16_t  tx_div;   
    uint16_t  rx_en_cnt;
    uint16_t  rx_div_attr;
};
 
 
struct register_offsets
{
    int32_t ICSS_CFG_PRUx_ED_CH0_CFG0;
    int32_t ICSS_CFG_PRUx_ED_CH1_CFG0;
    int32_t ICSS_CFG_PRUx_ED_CH2_CFG0;
    int32_t ICSS_CFG_PRUx_ED_CH0_CFG1;
    int32_t ICSS_CFG_PRUx_ED_CH1_CFG1;
    int32_t ICSS_CFG_PRUx_ED_CH2_CFG1;
    int32_t ICSS_CFG_GPCFGx;
    int32_t ICSS_CFG_PRUx_ED_RXCFG;
    int32_t ICSS_CFG_PRUx_ED_TXCFG;
};
 
struct tamagawa_priv
{
    int32_t channel;    
    uint16_t rx_en_cnt;
    struct tamagawa_xchg *tamagawa_xchg;    
    void *pruss_cfg;    
    int32_t slice_value;    
    struct register_offsets register_offset_val;    
};
 
/* ========================================================================== */
/*                       Function Declarations                                */
/* ========================================================================== */
 
int32_t tamagawa_command_process(struct tamagawa_priv *priv, int32_t cmd, uint8_t gTamagawa_multi_ch_mask);
 
int32_t tamagawa_command_build(struct tamagawa_priv *priv, int32_t cmd,  uint8_t gTamagawa_multi_ch_mask);
 
void tamagawa_command_send(struct tamagawa_priv *priv);
 
void tamagawa_command_wait(struct tamagawa_priv *priv);
 
 
void tamagawa_config_clock(struct tamagawa_priv *priv, struct tamagawa_clk_cfg *clk_cfg);
 
void tamagawa_config_host_trigger(struct tamagawa_priv *priv);
 
void tamagawa_config_periodic_trigger(struct tamagawa_priv *priv);
 
void tamagawa_config_channel(struct tamagawa_priv *priv, uint32_t ch);
 
void tamagawa_config_multi_channel_mask(struct tamagawa_priv *priv, uint8_t mask);
 
uint8_t tamagawa_multi_channel_detected(struct tamagawa_priv *priv);
 
void tamagawa_multi_channel_set_cur(struct tamagawa_priv *priv, uint32_t ch);
 
 
 
struct tamagawa_priv *tamagawa_init(struct tamagawa_xchg *tamagawa_xchg, void *pruss_cfg, uint32_t slice_value);
 
void tamagawa_update_data_id(struct tamagawa_priv *priv, int32_t cmd);
 
void tamagawa_update_adf(struct tamagawa_priv *priv, uint32_t val, uint32_t ch);
 
void tamagawa_update_edf(struct tamagawa_priv *priv, uint32_t val, uint32_t ch);
 
 
int32_t tamagawa_parse(int32_t cmd, struct tamagawa_priv *priv);
 
int32_t tamagawa_crc_verify(struct tamagawa_priv *priv);
 
void tamagawa_update_crc(struct tamagawa_priv *priv, int32_t cmd, uint32_t ch);
 
void tamagawa_set_baudrate(struct tamagawa_priv *priv, double baudrate);
 
void tamagawa_eeprom_crc_reinit(struct tamagawa_priv *priv);
 
uint32_t tamagawa_reverse_bits(int8_t data);
 
uint64_t tamagawa_prepare_eeprom_tx_data(uint64_t eeprom_tx_data, volatile uint32_t data);
 
void tamagawa_prepare_eeprom_command(struct tamagawa_priv *priv, int32_t cmd, uint32_t ch);
 
#ifdef __cplusplus
}
#endif
 
#endif