tle9201.cpp

Go to the documentation of this file.

/*
 * tle9201.c
 *
 * TLE9201 H-Bridge with SPI
 *
 * @date Nov 1, 2024
 *
 * @author andreika, (c) 2024
 * @author Andrey Belomutskiy, (c) 2012-2024
 */
 
#include "pch.h"
 
#include "gpio/gpio_ext.h"
#include "gpio/tle9201.h"
 
#if EFI_PROD_CODE && (BOARD_TLE9201_COUNT > 0)
 
/*==========================================================================*/
/* Driver local definitions.                                                */
/*==========================================================================*/
 
#define DRIVER_NAME             "tle9201"
 
#define TLE9201_REG_RD_DIA          0x00    // read diagnosis register
#define TLE9201_REG_RES_DIA         0x80    // reset diagnosis register
#define TLE9201_REG_RD_REV          0x20    // read device revision number
#define TLE9201_REG_RD_CTRL         0x60    // read control register
#define TLE9201_REG_WR_CTRL         0xE0    // write control register
#define TLE9201_REG_WR_CTRL_RD_DIA  0xC0    // write control and read diagnosis
 
#define TLE9201_REV_MAJOR_MASK      0xF0
#define TLE9201_REV_MAJOR           0x20
 
#define TLE9201_DIAG_CL             (1<<4) // over current
#define TLE9201_DIAG_TV             (1<<5) // transmission validation
#define TLE9201_DIAG_OT             (1<<6) // over temperature
#define TLE9201_DIAG_EN             (1<<7) // outputs enabled
#define TLE9201_DIAG_OUT_MASK       0xf // bits 0..3
 
#define TLE9201_GET_VAL(rx)         ((rx) & 0xff)
 
static bool drv_task_ready = false;
 
typedef enum {
    TLE9201_DISABLED = 0,
    TLE9201_READY,
    TLE9201_FAILED
} tle9201_drv_state;
 
/*==========================================================================*/
/* Driver exported variables.                                               */
/*==========================================================================*/
 
/*==========================================================================*/
/* Driver local variables and types.                                        */
/*==========================================================================*/
 
static size_t diagOkCounter = 0;
constexpr size_t DIAG_OK = 0xF;
 
// Output states
static const char *diagDiaOut[16] = { "?", "?", "?",
    "VS Undervoltage", // 0x3
    "?",
    "Short to Bat at OUT1 and OUT2", // 0x5
    "Short to GND at OUT1, short to Bat at OUT2", // 0x6
    "Short to Bat at OUT2", // 0x7
    "?",
    "Short to Bat at OUT1, short to GND at OUT2", // 0x9
    "Short to GND at OUT1 and OUT2", // 0xA
    "Short to GND at OUT2", // 0xB
    DRIVER_NAME " Open Load", // 0xC
    "Short to Bat at OUT1", // 0xD
    "Short to GND at OUT1", // 0xE
    "No failure" // 0xF
};
 
/* OS */
SEMAPHORE_DECL(tle9201_wake, 10 /* or BOARD_TLE9201_COUNT ? */);
static THD_WORKING_AREA(tle9201_thread_1_wa, 256);
 
/* Driver */
struct Tle9201 {
    int init(int i);
 
    int spi_rw(uint16_t tx, uint16_t *rx);
    int read_reg(uint8_t addr, uint8_t *val);
 
    bool get_diag_and_rev(uint8_t *diag, uint8_t *rev);
    void process_diag_and_rev(uint8_t diag, uint8_t rev);
 
    const tle9201_config        *cfg = NULL;
 
    tle9201_drv_state           drv_state;
    int idx;
    int detectedRev = 0;
    uint8_t savedDiag = 0;
    char name[10];
};
 
static Tle9201 chips[BOARD_TLE9201_COUNT];
 
/*==========================================================================*/
/* Driver local functions.                                                  */
/*==========================================================================*/
 
/**
 * @brief TLE9201 send+receive routine.
 */
 
int Tle9201::spi_rw(uint16_t tx, uint16_t *rx) {
    SPIDriver *spi = cfg->spi_bus;
 
    /* Acquire ownership of the bus. */
    spiAcquireBus(spi);
    /* Setup transfer parameters. */
    spiStart(spi, &cfg->spi_config);
    /* Slave Select assertion. */
    spiSelect(spi);
    /* Atomic transfer operations. */
    uint16_t rxd = spiPolledExchange(spi, tx);
    /* Slave Select de-assertion. */
    spiUnselect(spi);
    /* Ownership release. */
    spiReleaseBus(spi);
 
    // return data
    if (rx) {
        *rx = rxd;
    }
 
    return 0;
}
 
int Tle9201::read_reg(uint8_t addr, uint8_t *val) {
    int ret;
 
    ret = spi_rw(addr, nullptr);
    if (ret) {
        return ret;
    }
 
    uint16_t rxd;
    ret = spi_rw(addr, &rxd);
    if (ret) {
        return ret;
    }
 
    if (val) {
        *val = TLE9201_GET_VAL(rxd);
    }
 
    return 0;
}
 
bool Tle9201::get_diag_and_rev(uint8_t *diag, uint8_t *rev) {
    int retDiag = read_reg(TLE9201_REG_RD_DIA, diag);
    int retRev = read_reg(TLE9201_REG_RD_REV, rev);
    return (retDiag == 0 && retRev == 0);
}
 
void Tle9201::process_diag_and_rev(uint8_t diag, uint8_t rev) {
    // react on revision change
    if (rev != detectedRev) {
        if ((rev & TLE9201_REV_MAJOR_MASK) == TLE9201_REV_MAJOR) {
            efiPrintf("%s Detected! (rev=%08x)", name, rev);
        } else {
            efiPrintf("%s ERROR: Unknown revision (%08x)!", name, rev);
        }
 
        detectedRev = rev;
    }
 
    // react on diagnosis byte change
    if (diag != savedDiag) {
        efiPrintf("%s Diag (%08x):", name, diag);
        // this bit should be always 0
        if (diag & TLE9201_DIAG_TV) {
            efiPrintf("* Diag status incorrect!");
        }
        // these bits are 0 if something happened
        if (!(diag & TLE9201_DIAG_CL)) {
            efiPrintf("* Overcurrent shutdown!");
        }
        if (!(diag & TLE9201_DIAG_OT)) {
            efiPrintf("* Overtemperature shutdown!");
        }
        if (!(diag & TLE9201_DIAG_EN)) {
            efiPrintf("* Outputs disabled.");
        }
        size_t statusCode = diag & TLE9201_DIAG_OUT_MASK;
        if (statusCode == DIAG_OK) {
          diagOkCounter++;
        }
        // print the status of the outputs
        efiPrintf("* %s OK=%d", diagDiaOut[statusCode], diagOkCounter);
 
        savedDiag = diag;
    }
}
 
/*==========================================================================*/
/* Driver thread.                                                           */
/*==========================================================================*/
 
static THD_FUNCTION(tle9201_driver_thread, p) {
    bool wasSpiFailure = false;
 
    (void)p;
 
    chRegSetThreadName(DRIVER_NAME);
 
    while (1) {
        chThdSleepMilliseconds(TLE9201_POLL_INTERVAL_MS);
 
static bool isInitialized = false;
 
    if (!isIgnVoltage()) {
      if (isInitialized) {
        efiPrintf("Power loss? Would have to re-init TLE9201?");
        isInitialized = false;
      }
      continue;
    }
 
 
        for (int i = 0; i < BOARD_TLE9201_COUNT; i++) {
            auto chip = &chips[i];
            if ((chip->cfg == NULL) ||
                (chip->drv_state == TLE9201_DISABLED) ||
                (chip->drv_state == TLE9201_FAILED)) {
                continue;
      }
 
            uint8_t diag, rev;
            // get diagnosis and revision bytes
            if (!chip->get_diag_and_rev(&diag, &rev)) {
                if (!wasSpiFailure) {
                    efiPrintf("%s ERROR: SPI failure!", chip->name);
                    wasSpiFailure = true;
                }
            } else {
                wasSpiFailure = false;
            }
 
            chip->process_diag_and_rev(diag, rev);
        }
    }
}
 
/*==========================================================================*/
/* Driver interrupt handlers.                                               */
/*==========================================================================*/
 
/*==========================================================================*/
/* Driver exported functions.                                               */
/*==========================================================================*/
 
int Tle9201::init(int i) {
    drv_state = TLE9201_READY;
    idx = i;
    sprintf(name, "TLE9201[%d]", idx);
 
    if (!drv_task_ready) {
        chThdCreateStatic(tle9201_thread_1_wa, sizeof(tle9201_thread_1_wa),
                          PRIO_GPIOCHIP, tle9201_driver_thread, NULL);
        drv_task_ready = true;
    }
 
    return 0;
}
 
/**
 * @brief TLE9201 driver add.
 * @details Checks for valid config
 */
 
int tle9201_add(unsigned int index, const tle9201_config *cfg) {
    /* no config or no such chip */
    if ((!cfg) || (!cfg->spi_bus) || (index >= BOARD_TLE9201_COUNT)) {
        return -1;
    }
 
    if (index == 0) {
      addConsoleAction("reset_9201", [](){
        auto chip = &chips[0];
        chip->spi_rw(TLE9201_REG_RES_DIA, nullptr);
        efiPrintf(DRIVER_NAME "reset!");
      });
    }
 
    /* check for valid cs.
     * TODO: remove this check? CS can be driven by SPI */
    //if (cfg->spi_config.ssport == NULL)
    //  return -1;
 
    auto& chip = chips[index];
 
    /* already initted? */
    if (chip.cfg != NULL)
        return -1;
 
    chip.cfg = cfg;
    chip.init(index);
 
    return 0;
}
 
#else /* BOARD_TLE9201_COUNT > 0 */
 
int tle9201_add(unsigned int index, const tle9201_config *cfg) {
    (void)index; (void)cfg;
 
    return -1;
}
 
#endif /* BOARD_TLE9201_COUNT */