ic_specifics.h

Go to the documentation of this file.

 
#ifndef _IC_SPECIFICS_H
#define _IC_SPECIFICS_H
 
/*************************************************************************/
/* INCLUDE FILES                                                         */
/*************************************************************************/
#include <stdint.h>
#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <windows.h>
#include <strsafe.h>
 
 
#define __IC_SPEC_SAFE_SNPRINTF(out_str, ...) \
{ \
    out_str[0] = '\0'; \
    _snprintf_s(out_str, sizeof(out_str), _TRUNCATE, __VA_ARGS__); \
}
 
#define IS_580(dut_ic)  (dut_ic == DUT_IC_DA14580)
 
#define IS_70x(dut_ic)  ((dut_ic == DUT_IC_DA14701) |\
                        (dut_ic == DUT_IC_DA14705) |\
                        (dut_ic == DUT_IC_DA14706) |\
                        (dut_ic == DUT_IC_DA14708))
 
#define IS_701(dut_ic)      (dut_ic == DUT_IC_DA14701)
 
#define IS_705(dut_ic)      (dut_ic == DUT_IC_DA14705)
 
#define IS_706(dut_ic)      (dut_ic == DUT_IC_DA14706)
 
#define IS_708(dut_ic)      (dut_ic == DUT_IC_DA14708)
 
#define DUT_IC_DA14580_STR      "DA14580"
#define DUT_IC_DA14701_STR      "DA14701"
#define DUT_IC_DA14705_STR      "DA14705"
#define DUT_IC_DA14706_STR      "DA14706"
#define DUT_IC_DA14708_STR      "DA14708"
 
#define CFG_FW_PROD_TEST_70x    "st_fw_da1470x.bin"
 
#define CFG_FW_70x_FLASH_PROG   "uartboot_da1470x.bin"
 
#define DUT_IC_SLEEP_THRES_DA1470x  8000
 
#define PULSE_IN_RX_STR "PULSE_IN_RX"
 
#define IC_58x_GPIO_PORT_PIN_TO_ENUM(port, pin) (port * 10 + pin)
 
#define IC_58x_GPIO_ENUM_TO_PORT(enum_val)  ((int)floor((double)enum_val / 10))
 
#define IC_58x_GPIO_ENUM_TO_PIN(enum_val)   (enum_val % 10)
 
#define IC_58x_GPIO_VALID(val) \
    (((val >= IC_58x_P0_0) && (val <= IC_58x_P0_7)) || \
    ((val >= IC_58x_P1_0) && (val <= IC_58x_P1_7)) || \
    ((val >= IC_58x_P2_0) && (val <= IC_58x_P2_9)) || \
    ((val >= IC_58x_P3_0) && (val <= IC_58x_P3_7)) )
 
#define IC_58x_GPIO_W_OPTS_VALID(val) \
    (IC_58x_GPIO_VALID(val) || \
    (val == IC_58x_PULSE_IN_RX))
 
 
#define GPIO_OFFSET_70x_PORT1   0x20
 
#define GPIO_OFFSET_70x_PORT2   0x40
 
#define IC_70x_GPIO_PORT_PIN_TO_ENUM(port, pin) \
        (port * GPIO_OFFSET_70x_PORT1 + pin)
 
#define IC_70x_GPIO_ENUM_TO_PORT(enum_val) \
    ((int)floor((double)enum_val / GPIO_OFFSET_70x_PORT1))
 
#define IC_70x_GPIO_ENUM_TO_PIN(enum_val) \
    (enum_val % GPIO_OFFSET_70x_PORT1)
 
#define IC_70x_GPIO_IS_LED(enum_val) \
    ((enum_val == IC_70x_LED1) || \
    (enum_val == IC_70x_LED2) || \
    (enum_val == IC_70x_LED3))
 
#define IC_70x_GPIO_VALID(val) \
    (((val >= IC_70x_P0_0) && (val <= IC_70x_P0_31)) || \
        ((val >= IC_70x_P1_0) && (val <= IC_70x_P1_31)) || \
        ((val >= IC_70x_P2_0) && (val <= IC_70x_P2_15)))
 
#define IC_70x_GPIO_W_OPTS_VALID(val) \
    (IC_70x_GPIO_VALID(val) || \
    (val == IC_70x_LED1) || \
    (val == IC_70x_LED2) || \
    (val == IC_70x_LED3) || \
    (val == IC_70x_PULSE_IN_RX))
 
#define IC_GPIO_ENUM_TO_PORT(dut_ic, val) \
    ((uint8_t) (IS_70x(dut_ic) ? IC_70x_GPIO_ENUM_TO_PORT(val) : \
    0xFF)) // Invalid DUT IC
 
#define IC_GPIO_ENUM_TO_PIN(dut_ic, val) \
        ( (uint8_t) (IS_70x(dut_ic) ? IC_70x_GPIO_ENUM_TO_PIN(val) : \
        0xFF)) // Invalid DUT IC
typedef enum __ic_spec_status
{
    IC_SPEC_SUCCESS = 0,
    IC_SPEC_ERROR,
    IC_SPEC_INTERNAL_ERROR,
}_ic_spec_status;
 
typedef enum __dut_ic
{
    DUT_IC_DA14580 = 0, 
    DUT_IC_DA14701,     
    DUT_IC_DA14705,     
    DUT_IC_DA14706,     
    DUT_IC_DA14708,     
    INVALID_DUT_IC,     
}_dut_ic;
 
typedef enum __gpio_gen
{
    IC_GEN = 0x00, // Dummy entry
}_gpio_gen;
 
typedef enum __gpio_58x
{
    IC_58x_P0_0 = 00, IC_58x_P0_1, IC_58x_P0_2, IC_58x_P0_3,
    IC_58x_P0_4, IC_58x_P0_5, IC_58x_P0_6, IC_58x_P0_7,
 
    IC_58x_P1_0 = 10, IC_58x_P1_1, IC_58x_P1_2, IC_58x_P1_3,
    IC_58x_P1_4, IC_58x_P1_5, IC_58x_P1_6, IC_58x_P1_7,
 
    IC_58x_P2_0 = 20, IC_58x_P2_1, IC_58x_P2_2, IC_58x_P2_3,
    IC_58x_P2_4, IC_58x_P2_5, IC_58x_P2_6, IC_58x_P2_7,
    IC_58x_P2_8, IC_58x_P2_9,
 
    IC_58x_P3_0 = 30, IC_58x_P3_1, IC_58x_P3_2, IC_58x_P3_3,
    IC_58x_P3_4, IC_58x_P3_5, IC_58x_P3_6, IC_58x_P3_7,
 
    IC_58x_INVALID_XTAL_GPIO = 48,
    IC_58x_PULSE_IN_RX = 0xFE,
}_gpio_58x;
 
typedef enum __gpio_70x
{
    IC_70x_P0_0 = 00, IC_70x_P0_1, IC_70x_P0_2, IC_70x_P0_3,
    IC_70x_P0_4, IC_70x_P0_5, IC_70x_P0_6, IC_70x_P0_7,
    IC_70x_P0_8, IC_70x_P0_9, IC_70x_P0_10, IC_70x_P0_11,
    IC_70x_P0_12, IC_70x_P0_13, IC_70x_P0_14, IC_70x_P0_15,
    IC_70x_P0_16, IC_70x_P0_17, IC_70x_P0_18, IC_70x_P0_19,
    IC_70x_P0_20, IC_70x_P0_21, IC_70x_P0_22, IC_70x_P0_23,
    IC_70x_P0_24, IC_70x_P0_25, IC_70x_P0_26, IC_70x_P0_27,
    IC_70x_P0_28, IC_70x_P0_29, IC_70x_P0_30, IC_70x_P0_31,
 
    IC_70x_P1_0, IC_70x_P1_1, IC_70x_P1_2, IC_70x_P1_3,
    IC_70x_P1_4, IC_70x_P1_5, IC_70x_P1_6, IC_70x_P1_7,
    IC_70x_P1_8, IC_70x_P1_9, IC_70x_P1_10, IC_70x_P1_11,
    IC_70x_P1_12, IC_70x_P1_13, IC_70x_P1_14, IC_70x_P1_15,
    IC_70x_P1_16, IC_70x_P1_17, IC_70x_P1_18, IC_70x_P1_19,
    IC_70x_P1_20, IC_70x_P1_21, IC_70x_P1_22, IC_70x_P1_23,
    IC_70x_P1_24, IC_70x_P1_25, IC_70x_P1_26, IC_70x_P1_27,
    IC_70x_P1_28, IC_70x_P1_29, IC_70x_P1_30, IC_70x_P1_31,
 
    IC_70x_P2_0, IC_70x_P2_1, IC_70x_P2_2, IC_70x_P2_3,
    IC_70x_P2_4, IC_70x_P2_5, IC_70x_P2_6, IC_70x_P2_7,
    IC_70x_P2_8, IC_70x_P2_9, IC_70x_P2_10, IC_70x_P2_11,
    IC_70x_P2_12, IC_70x_P2_13, IC_70x_P2_14, IC_70x_P2_15,
 
    IC_70x_LED1 = 0xF1, IC_70x_LED2 = 0xF2, IC_70x_LED3 = 0xF3,
    IC_70x_PULSE_IN_RX = 0xFE,
}_gpio_70x;
 
typedef enum __vbat_rst_mode
{
    VBAT_ONLY = 0,      
    VBAT_ON_RST,        
    VBAT_AS_RST,        
    INVALID_VBAT_MODE,
}_vbat_rst_mode;
 
typedef union __ic_gpio
{
    _gpio_gen   gpio_gen;   
    _gpio_58x   gpio_58x;   
    _gpio_70x   gpio_70x;   
}_ic_gpio;
__inline bool is_ic_supported(_dut_ic dut_ic)
{
    int i = 0;
    for (i = 0; i < INVALID_DUT_IC; i++)
    {
        if (dut_ic == DUT_IC_DA14580)
        {
            return false;
        }
        else if (dut_ic == i)
        {
            return true;
        }
    }
    return false;
}
 
__inline _ic_spec_status get_dut_ic_str(_dut_ic dut_ic, char *str)
{
    _ic_spec_status ret = IC_SPEC_SUCCESS;
 
    if (!str)
    {
        return IC_SPEC_ERROR;
    }
 
    switch (dut_ic)
    {
    case DUT_IC_DA14701:
        strcpy_s(str, sizeof(DUT_IC_DA14701_STR), DUT_IC_DA14701_STR);
        break;
    case DUT_IC_DA14705:
        strcpy_s(str, sizeof(DUT_IC_DA14705_STR), DUT_IC_DA14705_STR);
        break;
    case DUT_IC_DA14706:
        strcpy_s(str, sizeof(DUT_IC_DA14706_STR), DUT_IC_DA14706_STR);
        break;
    case DUT_IC_DA14708:
        strcpy_s(str, sizeof(DUT_IC_DA14708_STR), DUT_IC_DA14708_STR);
        break;
    default:
        ret = IC_SPEC_ERROR;
        break;
    }
    return ret;
}
 
__inline _ic_spec_status get_dut_ic_enum(_dut_ic *dut_ic, char *str)
{
    _ic_spec_status ret = IC_SPEC_SUCCESS;
 
    if (!str) return IC_SPEC_ERROR;
 
    if (!strcmp(str, DUT_IC_DA14580_STR))
    {
        *dut_ic = DUT_IC_DA14580;
    }
    else if (!strcmp(str, DUT_IC_DA14701_STR))
    {
        *dut_ic = DUT_IC_DA14701;
    }
    else if (!strcmp(str, DUT_IC_DA14705_STR))
    {
        *dut_ic = DUT_IC_DA14705;
    }
    else if (!strcmp(str, DUT_IC_DA14706_STR))
    {
        *dut_ic = DUT_IC_DA14706;
    }
    else if (!strcmp(str, DUT_IC_DA14708_STR))
    {
        *dut_ic = DUT_IC_DA14708;
    }
    else
    {
        ret = IC_SPEC_ERROR;
    }
 
    return ret;
}
 
__inline _ic_spec_status get_dut_ic_prod_test_fw(_dut_ic dut_ic,
    char *file_name)
{
    _ic_spec_status ret = IC_SPEC_SUCCESS;
 
    if (!file_name)
    {
        return IC_SPEC_ERROR;
    }
 
    switch (dut_ic)
    {
    case DUT_IC_DA14701:
    case DUT_IC_DA14705:
    case DUT_IC_DA14706:
    case DUT_IC_DA14708:
        strcpy_s(file_name, sizeof(CFG_FW_PROD_TEST_70x),
            CFG_FW_PROD_TEST_70x);
        break;
    default:
        ret = IC_SPEC_ERROR;
        break;
    }
    return ret;
}
 
__inline _ic_spec_status get_dut_ic_mem_prog_fw(_dut_ic dut_ic, char *file_name)
{
    _ic_spec_status ret = IC_SPEC_SUCCESS;
 
    if (!file_name)
    {
        return IC_SPEC_ERROR;
    }
 
    switch (dut_ic)
    {
    case DUT_IC_DA14701:
    case DUT_IC_DA14705:
    case DUT_IC_DA14706:
    case DUT_IC_DA14708:
        strcpy_s(file_name, sizeof(CFG_FW_70x_FLASH_PROG), CFG_FW_70x_FLASH_PROG);
        break;
    default:
        ret = IC_SPEC_ERROR;
        break;
    }
    return ret;
}
 
 
__inline _ic_spec_status check_gpio(_dut_ic dut_ic, _ic_gpio gpio_sel)
{
    _ic_spec_status ret = IC_SPEC_ERROR;
 
    if (IS_580(dut_ic)) // GU
    {
        if (IC_58x_GPIO_W_OPTS_VALID(gpio_sel.gpio_58x))
        {
            ret = IC_SPEC_SUCCESS;
        }
    }
    else if (IS_70x(dut_ic))
    {
        if (IC_70x_GPIO_W_OPTS_VALID(gpio_sel.gpio_70x))
        {
            ret = IC_SPEC_SUCCESS;
        }
    }
    else
    {
        return IC_SPEC_INTERNAL_ERROR;
    }
 
    return ret;
}
 
__inline _ic_spec_status get_gpio_name_str(_dut_ic dut_ic, _ic_gpio gpio,
    char *str)
{
    size_t sze = 5;
 
    if (!str)
    {
        return IC_SPEC_ERROR;
    }
 
    if (IS_580(dut_ic)) // GU
    {
        if (gpio.gpio_58x == IC_58x_PULSE_IN_RX)
        {
            _snprintf_s((char *const)str,
                (const size_t)sizeof(PULSE_IN_RX_STR) + 1, _TRUNCATE,
                (char *const)PULSE_IN_RX_STR);
        }
        else
        {
            const char fmt[] = "P%d_%d";
            uint8_t gpio_port = (uint8_t)IC_58x_GPIO_ENUM_TO_PORT(gpio.gpio_58x);
            uint8_t gpio_pin = (uint8_t)IC_58x_GPIO_ENUM_TO_PIN(gpio.gpio_58x);
 
            sze += (uint8_t)(gpio_pin >= 10);
 
            _snprintf_s((char *const)str, (const size_t)sze, _TRUNCATE,
                (char *const)fmt, (uint8_t)gpio_port, (uint8_t)gpio_pin);
        }
    }
    else if (IS_70x(dut_ic))
    {
        if (gpio.gpio_70x == IC_70x_LED1)
        {
            const char fmt[] = "LED1";
            _snprintf_s((char *const)str, (const size_t)sze,
                _TRUNCATE, (char *const)fmt);
        }
        else if (gpio.gpio_70x == IC_70x_LED2)
        {
            const char fmt[] = "LED2";
            _snprintf_s((char *const)str, (const size_t)sze,
                _TRUNCATE, (char *const)fmt);
        }
        else if (gpio.gpio_70x == IC_70x_LED3)
        {
            const char fmt[] = "LED3";
            _snprintf_s((char *const)str, (const size_t)sze,
                _TRUNCATE, (char *const)fmt);
        }
        else if (gpio.gpio_70x == IC_70x_PULSE_IN_RX)
        {
            _snprintf_s((char *const)str,
                (const size_t)sizeof(PULSE_IN_RX_STR) + 1,
                _TRUNCATE, (char *const)PULSE_IN_RX_STR);
        }
        else
        {
            const char fmt[] = "P0_%d";
            uint8_t gpio_pin = (uint8_t)
                IC_70x_GPIO_ENUM_TO_PIN(gpio.gpio_70x);
 
            sze += (uint8_t)(gpio_pin >= 10);
 
            _snprintf_s((char *const)str, (const size_t)sze,
                _TRUNCATE, (char *const)fmt, (uint8_t)gpio_pin);
        }
    }
    else
    {
        return IC_SPEC_ERROR;
    }
 
    return IC_SPEC_SUCCESS;
}
 
__inline _ic_spec_status check_gpio_is_led(_dut_ic dut_ic, _ic_gpio gpio)
{
    _ic_spec_status ret = IC_SPEC_ERROR;
 
    if (IS_70x(dut_ic))
    {
        if (IC_70x_GPIO_IS_LED(gpio.gpio_70x))
        {
            ret = IC_SPEC_SUCCESS;
        }
    }
    else
    {
        return IC_SPEC_INTERNAL_ERROR;
    }
 
    return ret;
} // @defgroup ic_specific
 
#endif // _IC_SPECIFICS_H