//***************************************************************************** // (C) Automotive Lighting Reutlingen GmbH // Tuebinger Strasse 123, 72762 Reutlingen, Germany // // Automotive Lighting Reutlingen GmbH owns all the rights to this work. // This work shall not be copied, reproduced, used, modified, transferred // or its information shall not be disclosed without the prior written // authorization of Automotive Lighting Reutlingen GmbH. //***************************************************************************** //----------------------------------------------------------------------------- /// \file CddLed_TPS92520.cpp /// /// \brief /// /// \descr /// /// \author Alex Mertic (f98865c) /// mailTo:alexandru-laurentiu.mertic(at)marelli.com //----------------------------------------------------------------------------- //============================================================================= // includes //============================================================================= #include #include #include volatile uint8 spi_buck_chips = 0; //============================================================================= // macros //============================================================================= #define SPI_BUCK_1_14_READ_FRAME(addr) ((uint16)(addr) << 9U) #define SPI_BUCK_1_14_WRITE_FRAME(addr, regval) (((uint16)((uint16)(addr) << 9U) | (uint16)(regval)) | (uint16)((uint16)1U << 15U)) //============================================================================= // functions //============================================================================= //----------------------------------------------------------------------------- // \brief cdd::led::TPS92520::init // // \descr This function will initialize the TPS92520 drv registers. // // \param bRegValType specifies if specifc initialization has to be performed // on the driver or the default values are used(no init) // // \return void //----------------------------------------------------------------------------- void cdd::led::tps92520::init() { uint8 index; //index for each register uint8 index1; //index for registers uint16 dummy; for (index = 0; index < CDDLED_TPS92520_INITREGNR; index++) { for (index1 = 0; index1 < spi_buck_chips; index1++) { cdd::led::tps92520::read_write_reg((te_cdd_led_id)index1, cdd_led_TPS92520_init[index].rw, cdd_led_TPS92520_init[index].addr, (uint8 *)&cdd_led_TPS92520_init[index].data, &dummy); } } } //----------------------------------------------------------------------------- // \brief read_write_reg // // \descr This function is responsible writing and reading the buck registers // // \param led_id - Buck ID configured in CddLed_Cfg.h // spi_request - type of request Read - 0, Write - 1 // puc_addr - pointer to buck reg addr // puc_tx_data - pointer to data to be sent ovet SPI, discarded if read request // pun_rx_data - pinter to received data over SPI // // \return ucRet - error code //----------------------------------------------------------------------------- uint8 cdd::led::tps92520::read_write_reg(te_cdd_led_id led_id, te_cdd_led_spi_req_type spi_request, uint8 puc_addr, uint8 *puc_tx_data, uint16 *pun_rx_data) { uint8 ret = 0; uint8 index = 0; uint16 un_spi_tx_data[CDDLED_TPS92520_DRVNR] = { 0 }; uint16 un_spi_rx_data[CDDLED_TPS92520_DRVNR] = { 0 }; if (cdd_led_TPS92520_config[led_id].spi_topology == e_cdd_led_spi_star) { uint16 unSpiTx; if (spi_request == e_cdd_led_read_reg) { unSpiTx = SPI_BUCK_1_14_READ_FRAME(puc_addr); ret = Spi_Transmit(e_active_config_BUCK, &unSpiTx, pun_rx_data, 1U); } else { unSpiTx = SPI_BUCK_1_14_WRITE_FRAME(puc_addr, *puc_tx_data); ret = Spi_Transmit(e_active_config_BUCK, &unSpiTx, pun_rx_data, 1U); } } else if (cdd_led_TPS92520_config[led_id].spi_topology == e_cdd_led_spi_daisy) { //fill all entries with read status3 register request. for (index = 0U; index < spi_buck_chips; index++) { un_spi_tx_data[index] = 0x0B00U; } //Prepare SPI frame uint8 dataIdx = (uint8)((uint8)(spi_buck_chips - led_id) - 1U); un_spi_tx_data[dataIdx] = spi_request == e_cdd_led_read_reg ? SPI_BUCK_1_14_READ_FRAME(puc_addr) : SPI_BUCK_1_14_WRITE_FRAME(puc_addr, *puc_tx_data); //Calculate parity bit. spi_set_parity_bit(&un_spi_tx_data[dataIdx], 8U); // PRQA S 303 1 // correct usage (comes from the definition of SCB) ret = Spi_Transmit(e_active_config_BUCK, &un_spi_tx_data[0U], &un_spi_rx_data[0U], spi_buck_chips); //fill all registers with read status3 register request. for (index = 0U; index < spi_buck_chips; index++) { un_spi_tx_data[index] = 0x0B00U; } // PRQA S 303 1 // correct usage (comes from the definition of SCB) ret = Spi_Transmit(e_active_config_BUCK, &un_spi_tx_data[0U], &un_spi_rx_data[0U], spi_buck_chips); *pun_rx_data = un_spi_rx_data[dataIdx]; } else { ret = 0xff; } return ret; } //----------------------------------------------------------------------------- // \brief read_write_reg_all // // \descr This function is responsible writing and reading all the BUCK registers // // \param spi_request - type of request Read - 0, Write - 1 // puc_addr - pointer to BUCK reg addr // puc_tx_data - pointer to data to be sent ovet SPI, discarded if read request // pun_rx_data - pinter to received data over SPI // // \return ucRet - error code //----------------------------------------------------------------------------- uint8 cdd::led::tps92520::read_write_reg_all(te_cdd_led_id led_id, te_cdd_led_spi_req_type spi_request, uint8 *puc_tx_data, uint16 *pun_rx_data, uint16* response_len) { uint8 ret = 1; if (spi_request == e_cdd_led_read_reg) { for (uint8 i = 0; i < sizeof(reg_map_TPS92520) / sizeof(reg_map_TPS92520[0]); ++i) { if (reg_map_TPS92520[i].read_write == reg_read_only || reg_map_TPS92520[i].read_write == reg_read_write) { ret &= read_write_reg(led_id, e_cdd_led_read_reg, reg_map_TPS92520[i].reg_addr, (uint8 *)(puc_tx_data + (i * sizeof(*puc_tx_data))), (uint16 *)(pun_rx_data + (i * sizeof(*pun_rx_data)))); *response_len += 1; } } } if (spi_request == e_cdd_led_write_reg) { for (uint8 i = 0; i < sizeof(reg_map_TPS92520) / sizeof(reg_map_TPS92520[0]); ++i) { if (reg_map_TPS92520[i].read_write == reg_write_only || reg_map_TPS92520[i].read_write == reg_read_write) { ret &= read_write_reg(led_id, e_cdd_led_write_reg, reg_map_TPS92520[i].reg_addr, (uint8 *)(puc_tx_data + (i * sizeof(*puc_tx_data))), (uint16 *)(pun_rx_data + (i * sizeof(*pun_rx_data)))); } } } return ret; } //----------------------------------------------------------------------------- // \brief set_params // // \descr This function writes the following Buck registers: CHxTON, CHxIADJ(H/L) // // \param BuckLedID - LED channel id (eg. buck 3 channel 1 = 3 * 2 + 1) // CHxTON - Buck register @ 0x11 for BuckLedID % 2 == 0 (channel 0), // - Buck register @ 0x12 for BuckLedID % 2 == 1 (channel 1) // CHxIADJ - Buck registers 0x08, 0x09 for BuckLedID % 2 == 0 (channel 0), // - Buck registers 0x0A, 0x0B for BuckLedID % 2 == 1 (channel 1) // \return ucRet - error code //----------------------------------------------------------------------------- uint8 cdd::led::tps92520::set_params(uint8 BuckLedID, uint8 CHxTON, uint16 CHxIADJ) { uint8 ucRet = 0xff; uint8 addr = 0; uint8 data = 0; uint16 dummy[10]; if (BuckLedID <= 2 * spi_buck_chips) { ucRet = 0; // Write CHxTON; addr = BuckLedID % 2 == 0 ? tREG_Buck_TPS92520_CH1TON_ADDR : tREG_Buck_TPS92520_CH2TON_ADDR; data = CHxTON & 0x2F; cdd::led::tps92520::read_write_reg((te_cdd_led_id) (BuckLedID / 2), e_cdd_led_write_reg, addr, &data, dummy); // Write CHxIADJL; addr = BuckLedID % 2 == 0 ? tREG_Buck_TPS92520_CH1IADJL_ADDR : tREG_Buck_TPS92520_CH2IADJL_ADDR; data = (uint8)CHxIADJ & 0x03; cdd::led::tps92520::read_write_reg((te_cdd_led_id)(BuckLedID / 2), e_cdd_led_write_reg, addr, &data, dummy); // Write CHxIADJH; addr = BuckLedID % 2 == 0 ? tREG_Buck_TPS92520_CH1IADJH_ADDR : tREG_Buck_TPS92520_CH2IADJH_ADDR; data = (uint8)(CHxIADJ >> 2U); cdd::led::tps92520::read_write_reg((te_cdd_led_id)(BuckLedID / 2), e_cdd_led_write_reg, addr, &data, dummy); } return ucRet; }