Forked from
card10 / firmware
1842 commits behind the upstream repository.
-
rahix authoredSigned-off-by:
Rahix <rahix@rahix.de>rahix authoredSigned-off-by:Rahix <rahix@rahix.de>
bhy.c 157.62 KiB
/*
****************************************************************************
* Copyright (C) 2015 - 2016 Bosch Sensortec GmbH
*
* File : bhy.c
*
* Date : 2016/01/22
*
* Revision : 1.0.4 $
*
* Usage: Sensor Driver for BHY sensor
*
****************************************************************************
* 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 the copyright holder nor the names of the
* 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 EXPRESS 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 COPYRIGHT HOLDER
* 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
*
* The information provided is believed to be accurate and reliable.
* The copyright holder assumes no responsibility
* for the consequences of use
* of such information nor for any infringement of patents or
* other rights of third parties which may result from its use.
* No license is granted by implication or otherwise under any patent or
* patent rights of the copyright holder.
*
**************************************************************************/
/*! file <BHY >
brief <Sensor driver for BHY> */
#include "bhy.h"
/* static structure for bhy */
static struct bhy_t *p_bhy;
/* contain the saved parameters data*/
static struct parameter_read_buffer_t read_buffer;
/* contain the load parameters data*/
static struct parameter_write_buffer_t write_buffer;
/* Assign the sensor status bank*/
struct sensor_status_bank_t sensor_status_bank;
/*!
* @brief
* This function is used for initialize
* bus read and bus write functions
* and device address
* product id is read in the register 0x90 bit from 0 to 7 *
* @param bhy : structure pointer
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
* @note
* While changing the parameter of the bhy_t
* consider the following point:
* Changing the reference value of the parameter
* will changes the local copy or local reference
* make sure your changes will not
* affect the reference value of the parameter
* (Better case don't change the reference value of the parameter)
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_init(struct bhy_t *bhy)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u8 v_data_u8 = BHY_INIT_VALUE;
/* assign bhy ptr */
p_bhy = bhy;
com_rslt =
p_bhy->BHY_BUS_READ_FUNC(p_bhy->device_addr,
BHY_I2C_REG_PRODUCT_ID_ADDR,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
/* read product Id */
p_bhy->product_id = v_data_u8;
return com_rslt;
}
/*!
* @brief
* This API write the data to
* the given register
*
*
* @param v_addr_u8 -> Address of the register
* @param v_data_u8 -> The data from the register
* @param v_len_u8 -> no of bytes to read
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_write_reg(u8 v_addr_u8,
u8 *v_data_u8, u16 v_len_u16)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
/* check the p_bhy structure as NULL*/
if (BHY_NULL_PTR == p_bhy) {
com_rslt = BHY_NULL;
} else {
/* write data from register*/
com_rslt =
p_bhy->BHY_BUS_WRITE_FUNC(p_bhy->device_addr,
v_addr_u8, v_data_u8, v_len_u16);
}
return com_rslt;
}
/*!
* @brief
* This API reads the data from
* the given register
* *
* @param v_addr_u8 -> Address of the register
* @param v_data_u8 -> The data from the register
* @param v_len_u8 -> no of bytes to read
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_read_reg(u8 v_addr_u8,
u8 *v_data_u8, u16 v_len_u16)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
/* check the p_bhy structure as NULL*/
if (BHY_NULL_PTR == p_bhy) {
com_rslt = BHY_NULL;
} else {
/* Read data from register*/
com_rslt =
p_bhy->BHY_BUS_READ_FUNC(p_bhy->device_addr,
v_addr_u8, v_data_u8, v_len_u16);
}
return com_rslt;
}
/*!
* @brief API used to get the FIFO flush from the register 0x32
* bit 0 to 7
*
*
* @param v_fifo_flush_u8 : The value of fifo flush
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_get_fifo_flush(u8 *v_fifo_flush_u8)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u8 v_data_u8 = BHY_INIT_VALUE;
if (BHY_NULL_PTR == p_bhy) {
com_rslt = BHY_NULL;
} else {
com_rslt =
p_bhy->BHY_BUS_READ_FUNC(p_bhy->device_addr,
BHY_I2C_REG_FIFO_FLUSH__REG,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
*v_fifo_flush_u8 = BHY_GET_BITSLICE(v_data_u8,
BHY_I2C_REG_FIFO_FLUSH);
}
return com_rslt;
}
/*!
* @brief API used to set the FIFO flush from the register 0x32
* bit 0 to 7
*
*
* @param v_fifo_flush_u8 : The value of fifo flush
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*/BHY_RETURN_FUNCTION_TYPE bhy_set_fifo_flush(u8 v_fifo_flush_u8)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u8 v_data_u8 = BHY_INIT_VALUE;
if (BHY_NULL_PTR == p_bhy) {
com_rslt = BHY_NULL;
} else {
com_rslt =
p_bhy->BHY_BUS_READ_FUNC(p_bhy->device_addr,
BHY_I2C_REG_FIFO_FLUSH__REG,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
if (BHY_SUCCESS == com_rslt) {
v_data_u8 = BHY_SET_BITSLICE(v_data_u8,
BHY_I2C_REG_FIFO_FLUSH,
v_fifo_flush_u8);
com_rslt += p_bhy->BHY_BUS_WRITE_FUNC
(p_bhy->device_addr,
BHY_I2C_REG_FIFO_FLUSH__REG,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
}
}
return com_rslt;
}
/*!
* @brief API used to get the chip control from the register 0x34
* bit 0 to 7
* @note Chip control used to provide the control fundamental
* behaviour of the chip
*
* @param v_chipcontrol_u8 : The value of chip control
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_get_chip_control(u8 *v_chipcontrol_u8)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u8 v_data_u8 = BHY_INIT_VALUE;
/* check the p_bhy structure as NULL*/
if (BHY_NULL_PTR == p_bhy) {
com_rslt = BHY_NULL;
} else {
/* read the chip control status*/
com_rslt =
p_bhy->BHY_BUS_READ_FUNC(p_bhy->device_addr,
BHY_I2C_REG_CHIP_CONTROL__REG,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
*v_chipcontrol_u8 = BHY_GET_BITSLICE(v_data_u8,
BHY_I2C_REG_CHIP_CONTROL);
}
return com_rslt;
}
/*!
* @brief API used to set the chip control from the register 0x34
* bit 0 to 7
* @note Chip control used to provide the control fundamental
* behaviour of the chip
*
* @param v_chipcontrol_u8 : The value of chip control
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error *
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_set_chip_control(u8 v_chipcontrol_u8)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u8 v_data_u8 = BHY_INIT_VALUE;
/* check the p_bhy structure as NULL*/
if (BHY_NULL_PTR == p_bhy) {
com_rslt = BHY_NULL;
} else {
com_rslt =
p_bhy->BHY_BUS_READ_FUNC(p_bhy->device_addr,
BHY_I2C_REG_CHIP_CONTROL__REG,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
if (BHY_SUCCESS == com_rslt) {
v_data_u8 = BHY_SET_BITSLICE(v_data_u8,
BHY_I2C_REG_CHIP_CONTROL,
v_chipcontrol_u8);
com_rslt += p_bhy->BHY_BUS_WRITE_FUNC
(p_bhy->device_addr,
BHY_I2C_REG_CHIP_CONTROL__REG,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
}
}
return com_rslt;
}
/*!
* @brief API used to get the host status from the register 0x35
* bit 0 to 7
*
*
* @param v_algo_standby_u8 : The value of algorithm standby duration
* @param v_algo_id_u8 : The value of algorithm id
* @param v_host_interface_id_u8 : The value of host interface id
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_get_host_status(
u8 *v_algo_standby_u8, u8 *v_algo_id_u8,
u8 *v_host_interface_id_u8)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u8 v_data_u8 = BHY_INIT_VALUE;
/* check the p_bhy pointer as NULL*/
if (BHY_NULL_PTR == p_bhy) {
com_rslt = BHY_NULL;
} else {
/* read the host status*/
com_rslt =
p_bhy->BHY_BUS_READ_FUNC(p_bhy->device_addr,
BHY_I2C_REG_HOST_STATUS__REG,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
/* read the host algo status*/
*v_algo_standby_u8 = BHY_GET_BITSLICE(v_data_u8,
BHY_I2C_REG_HOST_STATUS_ALGO_STANDBY);
/* read the host algo id */
*v_algo_id_u8 = BHY_GET_BITSLICE(v_data_u8,
BHY_I2C_REG_BHY_HOST_STATUS_ALGO_ID);
/* host interface id */
*v_host_interface_id_u8 = BHY_GET_BITSLICE(v_data_u8,
BHY_I2C_REG_BHY_HOST_INTERFACE_ID); }
return com_rslt;
}
/*!
* @brief API used to get the interrupt status from the register 0x36
* bit 0 to 7
*
*
* @param v_host_int_u8 :
* The value of host interrupt status
* @param v_wakeup_water_mark_u8 :
* The value of wakeup watermark status
* @param v_wakeup_latency_u8 :
* The value of wakeup latency status
* @param v_wakeup_immediate_u8 :
* The value of wakeup immediate status
* @param v_non_wakeup_water_mark_u8 :
* The value of non wakeup watermark status
* @param v_non_wakeup_latency_u8 :
* The value of non wakeup latency status
* @param v_non_wakeup_immediate_u8 :
* The value of non wakeup immediate
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_get_interrupt_status(
u8 *v_host_int_u8,
u8 *v_wakeup_water_mark_u8, u8 *v_wakeup_latency_u8,
u8 *v_wakeup_immediate_u8, u8 *v_non_wakeup_water_mark_u8,
u8 *v_non_wakeup_latency_u8, u8 *v_non_wakeup_immediate_u8)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u8 v_data_u8 = BHY_INIT_VALUE;
/* check the p_bhy pointer as NULL*/
if (BHY_NULL_PTR == p_bhy) {
com_rslt = BHY_NULL;
} else {
/* read the interrupt status*/
com_rslt =
p_bhy->BHY_BUS_READ_FUNC(p_bhy->device_addr,
BHY_I2C_REG_INT_STATUS__REG,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
/* read the host interrupt status*/
*v_host_int_u8 = BHY_GET_BITSLICE(v_data_u8,
BHY_I2C_REG_BHY_INT_STATUS_HOST_INTR);
/* read the wakeup watermark interrupt status*/
*v_wakeup_water_mark_u8 = BHY_GET_BITSLICE(v_data_u8,
BHY_I2C_REG_BHY_INT_STATUS_WAKEUP_WM);
/* read the wakeup latency interrupt status*/
*v_wakeup_latency_u8 = BHY_GET_BITSLICE(v_data_u8,
BHY_I2C_REG_BHY_INT_STATUS_WAKEUP_LATENCY);
/* read the wakeup immediate interrupt status*/
*v_wakeup_immediate_u8 = BHY_GET_BITSLICE(v_data_u8,
BHY_I2C_REG_BHY_INT_STATUS_WAKEUP_IMMEDIATE);
/* read the non wakeup watermark interrupt status*/
*v_non_wakeup_water_mark_u8 = BHY_GET_BITSLICE(v_data_u8,
BHY_I2C_REG_BHY_INT_STATUS_NON_WAKEUP_WM);
/* read the non wakeup latency interrupt status*/
*v_non_wakeup_latency_u8 = BHY_GET_BITSLICE(v_data_u8,
BHY_I2C_REG_INT_STATUS_NON_WAKEUP_LATENCY);
/* read the non wakeup immediate status*/
*v_non_wakeup_immediate_u8 = BHY_GET_BITSLICE(v_data_u8,
BHY_I2C_REG_INT_STATUS_NON_WAKEUP_IMMEDIATE); }
return com_rslt;
}
/*!
* @brief API used to get the chip status from the register 0x37
* bit 0 to 7
*
*
*
* @param v_eeprom_detected_u8 : The value of eeprom
* detected status
* @param v_ee_upload_done_u8 : The value of ee_upload
* done status
* @param v_ee_upload_error_u8 : The value of ee_upload
* done error
* @param v_firmware_idle_u8 : The value of firmware error status
* @param v_no_eeprom_u8 : The value of no eeprom status
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_get_chip_status(
u8 *v_eeprom_detected_u8,
u8 *v_ee_upload_done_u8, u8 *v_ee_upload_error_u8,
u8 *v_firmware_idle_u8, u8 *v_no_eeprom_u8)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u8 v_data_u8 = BHY_INIT_VALUE;
/* check the p_bhy pointer as NULL*/
if (BHY_NULL_PTR == p_bhy) {
com_rslt = BHY_NULL;
} else {
/* read the chip status*/
com_rslt =
p_bhy->BHY_BUS_READ_FUNC(p_bhy->device_addr,
BHY_I2C_REG_CHIP_STATUS__REG,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
/* read eeprom detected status*/
*v_eeprom_detected_u8 = BHY_GET_BITSLICE(v_data_u8,
BHY_I2C_REG_CHIP_STATUS_EEPROM_DETECTED);
/* read eeprom upload done status*/
*v_ee_upload_done_u8 = BHY_GET_BITSLICE(v_data_u8,
BHY_I2C_REG_CHIP_STATUS_EE_UPLOAD_DONE);
/* read eeprom upload error status*/
*v_ee_upload_error_u8 = BHY_GET_BITSLICE(v_data_u8,
BHY_I2C_REG_CHIP_STATUS_EE_UPLOAD_ERROR);
/* read firmware idle status*/
*v_firmware_idle_u8 = BHY_GET_BITSLICE(v_data_u8,
BHY_I2C_REG_CHIP_STATUS_FIRMWARE_IDLE);
/* read no eeprom detected status*/
*v_no_eeprom_u8 = BHY_GET_BITSLICE(v_data_u8,
BHY_I2C_REG_CHIP_STATUS_NO_EEPROM);
}
return com_rslt;
}
/*!
* @brief API used to get the bytes remaining from the register 0x38
* and 0x39 bit 0 to 7
*
*
* @param v_bytes_remaining_u16 : The value of bytes remaining
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error *
* @note This indicates how many bytes are available in the FIFO buffer
*
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_read_bytes_remaining(u16 *v_bytes_remaining_u16)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
/* Array contains the bytes reaming of FIFO lSB and MSB data
v_data_u8[LSB_ZERO] - LSB
v_data_u8[MSB_ONE] - MSB*/
u8 v_data_u8[BHY_BYTES_REMAINING_SIZE] = {BHY_INIT_VALUE,
BHY_INIT_VALUE};
/* check the p_bhy pointer as NULL*/
if (BHY_NULL_PTR == p_bhy) {
com_rslt = BHY_NULL;
} else {
/* read bytes remaining data */
com_rslt =
p_bhy->BHY_BUS_READ_FUNC(p_bhy->device_addr,
BHY_I2C_REG_BYTES_REMAINING_LSB_ADDR,
v_data_u8, BHY_BYTES_REMAINING_LENGTH);
/* get the bytes remaining data*/
*v_bytes_remaining_u16 = (u16)
((v_data_u8[BHY_BYTES_REMAINING_MSB]
<< BHY_SHIFT_BIT_POSITION_BY_08_BITS)
| (v_data_u8[BHY_BYTES_REMAINING_LSB]));
}
return com_rslt;
}
/*!
* @brief API used to get the parameter
* acknowledgement from the register 0x3A
* bit 0 to 7
*
*
* @param v_parameter_acknowledge_u8:
* The value of parameter acknowledgement
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_get_parameter_acknowledge(
u8 *v_parameter_acknowledge_u8)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u8 v_data_u8 = BHY_INIT_VALUE;
/* check the p_bhy pointer as NULL*/
if (BHY_NULL_PTR == p_bhy) {
com_rslt = BHY_NULL;
} else {
/* read the parameter acknowledgement*/
com_rslt =
p_bhy->BHY_BUS_READ_FUNC(p_bhy->device_addr,
BHY_I2C_REG_PARAMETER_ACKNOWLEDGE_ADDR,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
*v_parameter_acknowledge_u8 = v_data_u8;
}
return com_rslt;
}
/*!
* @brief API used to get the parameter * page select from the register 0x54
* bit 0 to 7
*
*
* @param v_page_select_u8 : The value of parameter page selection
* page information | value
* ------------------------|----------
* BHY_PAGE_SELECT_PARAMETER_PAGE | 0
* BHY_PAGE_SELECT_PARAMETER_SIZE | 1
*
* @param v_parameter_page_u8 : The value of page selection
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_get_parameter_page_select(
u8 v_page_select_u8, u8 *v_parameter_page_u8)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u8 v_data_u8 = BHY_INIT_VALUE;
/* check the p_bhy pointer as NULL*/
if (BHY_NULL_PTR == p_bhy) {
com_rslt = BHY_NULL;
} else {
/* read the parameter page information*/
com_rslt =
p_bhy->BHY_BUS_READ_FUNC(p_bhy->device_addr,
BHY_I2C_REG_PARAMETER_PAGE_SELECT__REG,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
switch (v_page_select_u8) {
case BHY_PAGE_SELECT_PARAMETER_PAGE:
*v_parameter_page_u8 = BHY_GET_BITSLICE(v_data_u8,
BHY_I2C_REG_PARAMETER_PAGE_SELECT_PARAMETER_PAGE);
break;
case BHY_PAGE_SELECT_PARAMETER_SIZE:
*v_parameter_page_u8
= BHY_GET_BITSLICE(v_data_u8,
BHY_I2C_REG_PARAMETER_PAGE_SELECT_PARAMETER_SIZE);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
}
return com_rslt;
}
/*!
* @brief API used to set the parameter
* page select from the register 0x54
* bit 0 to 7
*
*
* @param v_page_select_u8 : The value of parameter page selection
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_set_parameter_page_select(u8 v_page_select_u8)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u8 v_data_u8 = BHY_INIT_VALUE;
/* check the p_bhy pointer as NULL*/
if (BHY_NULL_PTR == p_bhy) {
com_rslt = BHY_NULL;
} else {
v_data_u8 = v_page_select_u8;
/* read the parameter page information*/
com_rslt = p_bhy->BHY_BUS_WRITE_FUNC
(p_bhy->device_addr,
BHY_I2C_REG_PARAMETER_PAGE_SELECT__REG,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
}
return com_rslt;
}
/*!
* @brief API used to get the host interface control
* from the register 0x55
* bit 0 to 7
*
*
*
* @param v_algo_standby_req_u8 : The value of algorithm standby
* request
* @param v_abort_transfer_u8 : The value of abort transfer
* @param v_update_transfer_cnt_u8 : The value of update
* transfer count
* @param v_wakeup_fifo_intr_disable_u8 :
* The value of wakeup fifo host
* interrupt disable
* @param v_ned_coordinates_u8 : The value of NED coordinates
* @param v_ap_suspend_u8 : The value of AP suspended
* @param v_sensor_selftest_u8 : The value of sensor self test
* @param v_non_wakeup_fifo_intr_disable_u8:
* The value of non wakeup fifo host
* interrupt disable
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_get_host_interface_control(
u8 *v_algo_standby_req_u8,
u8 *v_abort_transfer_u8, u8 *v_update_transfer_cnt_u8,
u8 *v_wakeup_fifo_intr_disable_u8, u8 *v_ned_coordinates_u8,
u8 *v_ap_suspend_u8, u8 *v_sensor_selftest_u8,
u8 *v_non_wakeup_fifo_intr_disable_u8)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u8 v_data_u8 = BHY_INIT_VALUE;
/* check the p_bhy pointer as NULL*/
if (BHY_NULL_PTR == p_bhy) {
com_rslt = BHY_NULL;
} else {
/* read the host interrupt status*/
com_rslt =
p_bhy->BHY_BUS_READ_FUNC(p_bhy->device_addr,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_ADDR,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
/* read algorithm standby request status*/
*v_algo_standby_req_u8 = BHY_GET_BITSLICE(v_data_u8,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_ALGO_STABDY_REQUEST); /* read host interrupt control status*/
*v_abort_transfer_u8 = BHY_GET_BITSLICE(v_data_u8,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_ABORT_TRANSFER);
/* read update transfer control status*/
*v_update_transfer_cnt_u8 = BHY_GET_BITSLICE(v_data_u8,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_TRANSFER_COUNT);
/* read wakeup fifo host interrupt disable status*/
*v_wakeup_fifo_intr_disable_u8 = BHY_GET_BITSLICE(v_data_u8,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_WAKEUP_FIFO_DISABLE);
/* read ned coordinates status*/
*v_ned_coordinates_u8 = BHY_GET_BITSLICE(v_data_u8,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_NED_COORDINATE);
/* read AP suspended status*/
*v_ap_suspend_u8 = BHY_GET_BITSLICE(v_data_u8,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_AP_SUSPEND);
/* read self test status*/
*v_sensor_selftest_u8 = BHY_GET_BITSLICE(v_data_u8,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_SELFTEST);
/* read non wakeup fifo host interrupt disable status*/
*v_non_wakeup_fifo_intr_disable_u8 =
BHY_GET_BITSLICE(v_data_u8,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_NON_WAKEUP_FIFO_DISABLE);
}
return com_rslt;
}
/*!
* @brief API used to set the host interface control
* from the register 0x55
* bit 0 to 7
*
*
* @param v_host_interface_select_u8 : The value of host interface selection
* host interface | value
* -----------------------------------|----------
* BHY_HOST_ALGO_STANDBY_REQUEST | 0
* BHY_HOST_ABORT_TRANSFER | 1
* BHY_HOST_UPDATE_TRANSFER_COUNT | 2
* BHY_HOST_WAKEUP_FIFO_DISABLE | 3
* BHY_HOST_NED_COORDINATE | 4
* BHY_HOST_AP_SUSPEND | 5
* BHY_HOST_SELFTEST | 6
* BHY_HOST_NON_WAKEUP_FIFO_DISABLE | 7
*
* @param v_host_interface_status_u8 : The value of host interface
* Data | status
* -----------------| -----------
* 0 | DISABLE
* 1 | ENABLE
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_set_host_interface_control(
u8 v_host_interface_select_u8, u8 v_host_interface_status_u8)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u8 v_data_u8 = BHY_INIT_VALUE;
/* check the p_bhy pointer as NULL*/
if (BHY_NULL_PTR == p_bhy) {
com_rslt = BHY_NULL;
} else {
switch (v_host_interface_select_u8) {
case BHY_HOST_ALGO_STANDBY_REQUEST:
/* write algorithm standby request status*/
com_rslt =
p_bhy->BHY_BUS_READ_FUNC(p_bhy->device_addr,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_ALGO_STABDY_REQUEST__REG, &v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
if (BHY_SUCCESS == com_rslt) {
v_data_u8 = BHY_SET_BITSLICE(v_data_u8,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_ALGO_STABDY_REQUEST,
v_host_interface_status_u8);
com_rslt += p_bhy->BHY_BUS_WRITE_FUNC
(p_bhy->device_addr,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_ALGO_STABDY_REQUEST__REG,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
}
break;
case BHY_HOST_ABORT_TRANSFER:
/* write host interrupt control status*/
com_rslt =
p_bhy->BHY_BUS_READ_FUNC(p_bhy->device_addr,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_ABORT_TRANSFER__REG,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
if (BHY_SUCCESS == com_rslt) {
v_data_u8 = BHY_SET_BITSLICE(v_data_u8,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_ABORT_TRANSFER,
v_host_interface_status_u8);
com_rslt += p_bhy->BHY_BUS_WRITE_FUNC
(p_bhy->device_addr,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_ABORT_TRANSFER__REG,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
}
break;
case BHY_HOST_UPDATE_TRANSFER_COUNT:
/* write update transfer control status*/
com_rslt =
p_bhy->BHY_BUS_READ_FUNC(p_bhy->device_addr,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_TRANSFER_COUNT__REG,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
if (BHY_SUCCESS == com_rslt) {
v_data_u8 = BHY_SET_BITSLICE(v_data_u8,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_TRANSFER_COUNT,
v_host_interface_status_u8);
com_rslt += p_bhy->BHY_BUS_WRITE_FUNC
(p_bhy->device_addr,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_TRANSFER_COUNT__REG,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
}
break;
case BHY_HOST_WAKEUP_FIFO_DISABLE:
/* write wakeup fifo host interrupt disable status*/
com_rslt =
p_bhy->BHY_BUS_READ_FUNC(p_bhy->device_addr,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_WAKEUP_FIFO_DISABLE__REG,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
if (BHY_SUCCESS == com_rslt) {
v_data_u8 = BHY_SET_BITSLICE(v_data_u8,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_WAKEUP_FIFO_DISABLE,
v_host_interface_status_u8);
com_rslt += p_bhy->BHY_BUS_WRITE_FUNC
(p_bhy->device_addr,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_WAKEUP_FIFO_DISABLE__REG,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
}
break;
case BHY_HOST_NED_COORDINATE:
/* write ned coordinates status*/
com_rslt =
p_bhy->BHY_BUS_READ_FUNC(p_bhy->device_addr,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_NED_COORDINATE__REG,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
if (BHY_SUCCESS == com_rslt) {
v_data_u8 = BHY_SET_BITSLICE(v_data_u8,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_NED_COORDINATE,
v_host_interface_status_u8);
com_rslt += p_bhy->BHY_BUS_WRITE_FUNC (p_bhy->device_addr,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_NED_COORDINATE__REG,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
}
break;
case BHY_HOST_AP_SUSPEND:
/* write AP suspended status*/
com_rslt =
p_bhy->BHY_BUS_READ_FUNC(p_bhy->device_addr,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_AP_SUSPEND__REG,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
if (BHY_SUCCESS == com_rslt) {
v_data_u8 = BHY_SET_BITSLICE(v_data_u8,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_AP_SUSPEND,
v_host_interface_status_u8);
com_rslt += p_bhy->BHY_BUS_WRITE_FUNC
(p_bhy->device_addr,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_AP_SUSPEND__REG,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
}
break;
case BHY_HOST_SELFTEST:
/* write self test status*/
com_rslt =
p_bhy->BHY_BUS_READ_FUNC(p_bhy->device_addr,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_SELFTEST__REG,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
if (BHY_SUCCESS == com_rslt) {
v_data_u8 = BHY_SET_BITSLICE(v_data_u8,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_SELFTEST,
v_host_interface_status_u8);
com_rslt += p_bhy->BHY_BUS_WRITE_FUNC
(p_bhy->device_addr,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_SELFTEST__REG,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
}
break;
case BHY_HOST_NON_WAKEUP_FIFO_DISABLE:
/* write non wakeup fifo host interrupt disable status*/
com_rslt =
p_bhy->BHY_BUS_READ_FUNC(p_bhy->device_addr,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_NON_WAKEUP_FIFO_DISABLE__REG,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
if (BHY_SUCCESS == com_rslt) {
v_data_u8 = BHY_SET_BITSLICE(v_data_u8,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_NON_WAKEUP_FIFO_DISABLE,
v_host_interface_status_u8);
com_rslt += p_bhy->BHY_BUS_WRITE_FUNC
(p_bhy->device_addr,
BHY_I2C_REG_HOST_INTERFACE_CONTROL_NON_WAKEUP_FIFO_DISABLE__REG,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
}
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
}
return com_rslt;
}
/*!
* @brief API used to get the parameter
* request from the register 0x64
* bit 0 to 7
*
*
* @param v_parameter_request_u8 : The value of parameter request
*
* @return results of bus communication function
* @retval 0 -> Success * @retval -1 -> Error
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_get_parameter_request(
u8 *v_parameter_request_u8)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u8 v_data_u8 = BHY_INIT_VALUE;
/* check the p_bhy pointer as NULL*/
if (BHY_NULL_PTR == p_bhy) {
com_rslt = BHY_NULL;
} else {
/* read the load parameter request rate*/
com_rslt =
p_bhy->BHY_BUS_READ_FUNC(p_bhy->device_addr,
BHY_I2C_REG_PARAMETER_REQUEST_ADDR,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
*v_parameter_request_u8 = v_data_u8;
}
return com_rslt;
}
/*!
* @brief API used to get the parameter
* request from the register 0x64
* bit 0 to 7
*
*
* @param v_parameter_request_u8 : The value of parameter request
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_set_parameter_request(
u8 v_parameter_request_u8)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u8 v_data_u8 = BHY_INIT_VALUE;
/* check the p_bhy pointer as NULL*/
if (BHY_NULL_PTR == p_bhy) {
com_rslt = BHY_NULL;
} else {
/* write load parameter request*/
v_data_u8 = v_parameter_request_u8;
com_rslt = p_bhy->BHY_BUS_WRITE_FUNC
(p_bhy->device_addr,
BHY_I2C_REG_LOAD_PARAMETER_REQUEST__REG,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
}
return com_rslt;
}
/*!
* @brief API used to get the host IRQ time stamp
* request from the register 0x6C to 0x6F
* bit 0 to 7
*
*
* @param v_host_irq_timestamp_u32 : The value of host irq time stamp
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/BHY_RETURN_FUNCTION_TYPE bhy_get_host_irq_timestamp(
u32 *v_host_irq_timestamp_u32)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u8 v_data_u8[BHY_HOST_IRQ_TIMESTAMP_SIZE] = {BHY_INIT_VALUE,
BHY_INIT_VALUE, BHY_INIT_VALUE, BHY_INIT_VALUE};
/* check the p_bhy pointer as NULL*/
if (BHY_NULL_PTR == p_bhy) {
com_rslt = BHY_NULL;
} else {
/* read the load parameter request rate*/
com_rslt =
p_bhy->BHY_BUS_READ_FUNC(p_bhy->device_addr,
BHY_BHY_HOST_IRQ_TIMESTAMP_ADDR,
v_data_u8, BHY_HOST_IRQ_TIMESTAMP_SIZE);
*v_host_irq_timestamp_u32 =
(u32)((v_data_u8[BHY_HOST_IRQ_TIMESTAMP_MSB_DATA]
<< BHY_SHIFT_BIT_POSITION_BY_24_BITS)
|(v_data_u8[BHY_HOST_IRQ_TIMESTAMP_XXLSB_DATA]
<< BHY_SHIFT_BIT_POSITION_BY_16_BITS)
|(v_data_u8[BHY_HOST_IRQ_TIMESTAMP_XLSB_DATA]
<< BHY_SHIFT_BIT_POSITION_BY_08_BITS)
| (v_data_u8[BHY_HOST_IRQ_TIMESTAMP_LSB_DATA]));
}
return com_rslt;
}
/*!
* @brief API used to get the ROM version
* request from the register 0x70 to 0x71
* bit 0 to 7
*
*
* @param v_rom_version_u16 : The value ROM version
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_get_rom_version(u16 *v_rom_version_u16)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u8 v_data_u8[BHY_ROM_VERSION_SIZE] = {BHY_INIT_VALUE,
BHY_INIT_VALUE};
/* check the p_bhy pointer as NULL*/
if (BHY_NULL_PTR == p_bhy) {
com_rslt = BHY_NULL;
} else {
/* read the load parameter request rate*/
com_rslt =
p_bhy->BHY_BUS_READ_FUNC(p_bhy->device_addr,
BHY_ROM_VERSION_ADDR,
v_data_u8, BHY_ROM_VERSION_SIZE);
*v_rom_version_u16 =
(u16)((v_data_u8[BHY_ROM_VERSION_MSB_DATA]
<< BHY_SHIFT_BIT_POSITION_BY_08_BITS)
| (v_data_u8[BHY_ROM_VERSION_LSB_DATA]));
}
return com_rslt;
}
/*!
* @brief API used to get the RAM version
* request from the register 0x72 to 0x73
* bit 0 to 7
*
*
* @param v_ram_version_u16 : The value RAM version *
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_get_ram_version(
u16 *v_ram_version_u16)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u8 v_data_u8[BHY_RAM_VERSION_SIZE] = {BHY_INIT_VALUE,
BHY_INIT_VALUE};
/* check the p_bhy pointer as NULL*/
if (BHY_NULL_PTR == p_bhy) {
com_rslt = BHY_NULL;
} else {
/* read the load parameter request rate*/
com_rslt =
p_bhy->BHY_BUS_READ_FUNC(p_bhy->device_addr,
BHY_RAM_VERSION_ADDR,
v_data_u8, BHY_RAM_VERSION_SIZE);
*v_ram_version_u16 =
(u16)((v_data_u8[BHY_RAM_VERSION_MSB_DATA]
<< BHY_SHIFT_BIT_POSITION_BY_08_BITS)
| (v_data_u8[BHY_RAM_VERSION_LSB_DATA]));
}
return com_rslt;
}
/*!
* @brief API used to get the product id
* request from the register 0x90
* bit 0 to 7
*
*
* @param v_product_id_u8 : The value of product id
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_get_product_id(u8 *v_product_id_u8)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u8 v_data_u8 = BHY_INIT_VALUE;
/* check the p_bhy pointer as NULL*/
if (BHY_NULL_PTR == p_bhy) {
com_rslt = BHY_NULL;
} else {
/* read the load parameter request rate*/
com_rslt =
p_bhy->BHY_BUS_READ_FUNC(p_bhy->device_addr,
BHY_I2C_REG_PRODUCT_ID_ADDR,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
*v_product_id_u8 = v_data_u8;
}
return com_rslt;
}
/*!
* @brief API used to get the revision id
* request from the register 0x91
* bit 0 to 7
*
*
* @param v_revision_id_u8 : The value of revision id
* * @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_get_revision_id(u8 *v_revision_id_u8)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u8 v_data_u8 = BHY_INIT_VALUE;
/* check the p_bhy pointer as NULL*/
if (BHY_NULL_PTR == p_bhy) {
com_rslt = BHY_NULL;
} else {
/* read the load parameter request rate*/
com_rslt =
p_bhy->BHY_BUS_READ_FUNC(p_bhy->device_addr,
BHY_I2C_REG_REVISION_ID_ADDR,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
*v_revision_id_u8 = v_data_u8;
}
return com_rslt;
}
/*!
* @brief API used to get the CRC host
* request from the register 0x91
* bit 0 to 7
*
*
* @param v_crc_host_u32 : The value of CRC host
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_get_crc_host(u32 *v_crc_host_u32)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
/* Array contains the sensor time it is 32 bit data
a_data_u8[0] - crc HOST
a_data_u8[1] - crc HOST
a_data_u8[2] - crc HOST
a_data_u8[3] - crc HOST
*/
u8 a_data_u8[BHY_CRC_HOST_SIZE] = {BHY_INIT_VALUE,
BHY_INIT_VALUE, BHY_INIT_VALUE, BHY_INIT_VALUE};
/* check the p_bhy pointer as NULL*/
if (BHY_NULL_PTR == p_bhy) {
com_rslt = BHY_NULL;
} else {
com_rslt =
p_bhy->BHY_BUS_READ_FUNC(p_bhy->device_addr,
BHY_I2C_REG_CRC_HOST_ADDR,
a_data_u8, BHY_CRC_HOST_LENGTH);
*v_crc_host_u32 = (u32)
(((u32)a_data_u8[BHY_CRC_HOST_MSB]
<< BHY_SHIFT_BIT_POSITION_BY_24_BITS) |
((u32)a_data_u8[BHY_CRC_HOST_XXLSB]
<< BHY_SHIFT_BIT_POSITION_BY_16_BITS)
|(a_data_u8[BHY_CRC_HOST_XLSB]
<< BHY_SHIFT_BIT_POSITION_BY_08_BITS)
| (a_data_u8[BHY_CRC_HOST_LSB]));
}
return com_rslt;
}
/*! * @brief API used to set the reset
* request from the register 0x9B
* bit 0 to 7
*
*
* @param v_reset_request_u8 : The value of parameter request
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_set_reset_request(u8 v_reset_request_u8)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u8 v_data_u8 = BHY_INIT_VALUE;
/* check the p_bhy pointer as NULL*/
if (BHY_NULL_PTR == p_bhy) {
com_rslt = BHY_NULL;
} else {
v_data_u8 = v_reset_request_u8;
/* write load parameter request*/
com_rslt = p_bhy->BHY_BUS_WRITE_FUNC
(p_bhy->device_addr,
BHY_I2C_REG_RESET_REQUEST__REG,
&v_data_u8, BHY_GEN_READ_WRITE_LENGTH);
}
return com_rslt;
}
/*!
* @brief API used to flash the ram patch
*
*
* @param memory : The value of data from the
* ram patch.
* @param v_file_length_u32 : Length of the patch data
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_initialize(u8 *memory, u32 v_file_length_u32)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u8 v_upload_addr = BHY_UPLOAD_DATA;
u8 v_chip_control_u8 = BHY_CHIP_CTRL_ENABLE_1;
u32 v_crc_from_memory_u32 = BHY_INIT_VALUE;
u32 v_length_to_process_u32 = BHY_INIT_VALUE;
u32 v_crc_host_u32 = BHY_INIT_VALUE;
u32 write_data = BHY_INIT_VALUE;
u8 data_from_mem[BHY_SIGNATURE_MEM_LEN];
u8 data_byte[BHY_RAM_WRITE_LENGTH];
u32 read_index_u8 = BHY_INIT_VALUE;
s32 reverse_index_s32 = BHY_INIT_VALUE;
u32 bytes_to_write_u8 = BHY_RAM_WRITE_LENGTH;
u32 read_bytes_index = BHY_INIT_VALUE;
u32 write_index_u32 = BHY_INIT_VALUE;
u32 write_ram_index = BHY_INIT_VALUE;
u32 index_mem = BHY_INIT_VALUE;
u32 write_length = BHY_INIT_VALUE;
u32 data_to_process = BHY_INIT_VALUE;
u8 init_array_data = BHY_INIT_VALUE;
/* initialize the array*/
for (init_array_data = 0; init_array_data < BHY_SIGNATURE_MEM_LEN; init_array_data++)
{ data_from_mem[init_array_data] = BHY_INIT_VALUE;
}
for (init_array_data = BHY_INIT_VALUE; init_array_data < BHY_RAM_WRITE_LENGTH; init_array_data++)
{
data_byte[init_array_data] = BHY_INIT_VALUE;
}
/* check the p_bhy pointer as NULL*/
if (BHY_NULL_PTR == p_bhy)
{
com_rslt = BHY_NULL;
}
else
{
/* Assign the memory data into the local array*/
for (read_index_u8 = BHY_INIT_VALUE; read_index_u8 <= BHY_SIGNATURE_LENGTH; read_index_u8++)
{
data_from_mem[read_index_u8] = *(memory+read_index_u8);
}
/* Verify the signature of the data*/
if ((data_from_mem[BHY_SIGNATURE_1] == BHY_IMAGE_SIGNATURE1)
&& (data_from_mem[BHY_SIGNATURE_2] == BHY_IMAGE_SIGNATURE2))
{
com_rslt = BHY_SUCCESS;
}
else
{
com_rslt = BHY_ERROR;
}
/* read the CRC data from memory */
v_crc_from_memory_u32 = (u32)
(((u32)data_from_mem[BHY_CRC_HOST_FILE_MSB]
<< BHY_SHIFT_BIT_POSITION_BY_24_BITS) |
((u32)data_from_mem[BHY_CRC_HOST_FILE_XXLSB]
<< BHY_SHIFT_BIT_POSITION_BY_16_BITS)
|(data_from_mem[BHY_CRC_HOST_FILE_XLSB]
<< BHY_SHIFT_BIT_POSITION_BY_08_BITS)
| (data_from_mem[BHY_CRC_HOST_FILE_LSB]));
/* Remove the first 16 bytes*/
data_to_process = v_file_length_u32 - BHY_SIGNATURE_LENGTH;
/* data to write for length calculation*/
v_length_to_process_u32 = (data_to_process / BHY_RAM_WRITE_LENGTH);
read_index_u8 = BHY_SIGNATURE_LENGTH;
read_bytes_index = BHY_INIT_READ_BYTES;
for (write_index_u32 = BHY_INIT_VALUE; write_index_u32 < v_length_to_process_u32;)
{
/* reverse the data*/
if (read_index_u8 <= read_bytes_index && read_bytes_index <= data_to_process)
{
for (reverse_index_s32 = bytes_to_write_u8 - BHY_INIT_BYTE_MINUS_ONE;
reverse_index_s32 >= BHY_INIT_VALUE;)
{
data_byte[reverse_index_s32] = *(memory + read_index_u8);
read_index_u8++;
reverse_index_s32--;
}
}
/* write the data into the register*/
read_bytes_index = read_bytes_index + BHY_RAM_WRITE_LENGTH;
reverse_index_s32 = BHY_INIT_VALUE;
for (write_ram_index = BHY_INIT_VALUE; write_ram_index <= BHY_CHECK_BYTE;)
{
*(memory + index_mem) = data_byte[write_ram_index];
index_mem++;
write_ram_index++;
}
write_index_u32++;
}
/* set the reset as 0x01*/
com_rslt = bhy_set_reset_request(BHY_RESET_ENABLE); com_rslt += bhy_write_reg(BHY_I2C_REG_CHIP_CONTROL_ADDR,
&v_chip_control_u8, BHY_GEN_READ_WRITE_LENGTH);
/* set the upload data*/
com_rslt += bhy_write_reg(BHY_I2C_REG_UPLOAD_0_ADDR,
&v_upload_addr, BHY_GEN_READ_WRITE_LENGTH);
com_rslt += bhy_write_reg(BHY_I2C_REG_UPLOAD_1_ADDR,
&v_upload_addr, BHY_GEN_READ_WRITE_LENGTH);
/* write the chip control register as 0x02*/
write_length =
data_to_process / BHY_RAM_WRITE_LENGTH_API;
read_index_u8 = BHY_INIT_VALUE;
/* write the memory of data */
if (com_rslt == BHY_SUCCESS) {
for (read_index_u8 = BHY_INIT_VALUE; read_index_u8 < write_length; read_index_u8++)
{
com_rslt += bhy_write_reg(BHY_I2C_REG_UPLOAD_DATA_ADDR, \
(u8 *)(memory + write_data), \
BHY_RAM_WRITE_LENGTH_API);
write_data = write_data + BHY_RAM_WRITE_LENGTH_API;
}
}
/* Check the CRC success*/
com_rslt = bhy_get_crc_host(&v_crc_host_u32);
if (v_crc_from_memory_u32 == v_crc_host_u32)
{
com_rslt = BHY_SUCCESS;
}
else
{
com_rslt = BHY_ERROR;
}
/* disable upload mode*/
v_chip_control_u8 = BHY_CHIP_CTRL_ENABLE_2;
/* write the chip control register as 0x02*/
com_rslt += bhy_write_reg(BHY_I2C_REG_CHIP_CONTROL_ADDR, &v_chip_control_u8, BHY_GEN_READ_WRITE_LENGTH);
}
return com_rslt;
}
BHY_RETURN_FUNCTION_TYPE bhy_initialize_from_rom( const u8 *memory, const u32 v_file_length_u32)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u8 v_upload_addr = BHY_UPLOAD_DATA;
u8 v_chip_control_u8 = BHY_CHIP_CTRL_ENABLE_1;
u32 v_crc_from_memory_u32 = BHY_INIT_VALUE;
u32 v_crc_host_u32 = BHY_INIT_VALUE;
u32 write_data = BHY_INIT_VALUE;
u8 data_from_mem[BHY_SIGNATURE_MEM_LEN];
u8 data_byte[BHY_RAM_WRITE_LENGTH_API];
u32 read_index_u8 = BHY_INIT_VALUE;
u32 reverse_index_u32 = BHY_INIT_VALUE;
u32 reverse_block_index_u32 = BHY_INIT_VALUE;
u32 write_length = BHY_INIT_VALUE;
u32 data_to_process = BHY_INIT_VALUE;
u32 packet_length = BHY_INIT_VALUE;;
u16 signature_flag = 0;
u16 rom_version = 0;
u8 rom_ver_exp = 0;
u8 i = BHY_INIT_VALUE;
/* initialize the array*/
for (i=0; i < BHY_SIGNATURE_MEM_LEN; i++)
{
data_from_mem[i] = BHY_INIT_VALUE;
}
for (i = BHY_INIT_VALUE; i < BHY_RAM_WRITE_LENGTH; i++)
{
data_byte[i] = BHY_INIT_VALUE;
}
/* check the p_bhy pointer as NULL*/ if (BHY_NULL_PTR == p_bhy)
{
com_rslt = BHY_NULL;
}
else
{
/* Assign the memory data into the local array*/
for (read_index_u8 = BHY_INIT_VALUE;read_index_u8 <= BHY_SIGNATURE_LENGTH; read_index_u8++)
{
data_from_mem[read_index_u8] = *(memory+read_index_u8);
}
/* Verify the signature of the data*/
if ((data_from_mem[BHY_SIGNATURE_1] == BHY_IMAGE_SIGNATURE1)
&& (data_from_mem[BHY_SIGNATURE_2] == BHY_IMAGE_SIGNATURE2))
{
com_rslt = BHY_SUCCESS;
}
else
{
com_rslt = BHY_ERROR;
goto bhy_init_from_rom_return;
}
/* Verify the signature of the data*/
signature_flag = data_from_mem[BHY_SIG_FLAG_1_POS] + ((u16)data_from_mem[BHY_SIG_FLAG_2_POS]<<8);
rom_ver_exp = BHY_GET_ROMVEREXP (signature_flag);
bhy_get_rom_version(&rom_version);
if(BHY_ROM_VER_DI01 == rom_ver_exp)
{
if(BHY_ROM_VERSION_DI01 == rom_version)
{
com_rslt = BHY_SUCCESS;
}
else
{
com_rslt = BHY_RAMPATCH_NOT_MATCH;
goto bhy_init_from_rom_return;
}
}
else if(BHY_ROM_VER_DI03 == rom_ver_exp)
{
if(BHY_ROM_VERSION_DI03 == rom_version)
{
com_rslt = BHY_SUCCESS;
}
else
{
com_rslt = BHY_RAMPATCH_NOT_MATCH;
goto bhy_init_from_rom_return;
}
}
else
{
com_rslt = BHY_RAMPATCH_NOT_SUPPORT;
goto bhy_init_from_rom_return;
}
/* read the CRC data from memory */
v_crc_from_memory_u32 = (u32)
(((u32)data_from_mem[BHY_CRC_HOST_FILE_MSB]
<< BHY_SHIFT_BIT_POSITION_BY_24_BITS) |
((u32)data_from_mem[BHY_CRC_HOST_FILE_XXLSB]
<< BHY_SHIFT_BIT_POSITION_BY_16_BITS)
|(data_from_mem[BHY_CRC_HOST_FILE_XLSB]
<< BHY_SHIFT_BIT_POSITION_BY_08_BITS)
| (data_from_mem[BHY_CRC_HOST_FILE_LSB]));
/* Remove the first 16 bytes*/
data_to_process = v_file_length_u32 - BHY_SIGNATURE_LENGTH;
/* set the reset as 0x01*/
com_rslt = bhy_set_reset_request(BHY_RESET_ENABLE);
com_rslt += bhy_write_reg(BHY_I2C_REG_CHIP_CONTROL_ADDR, &v_chip_control_u8, BHY_GEN_READ_WRITE_LENGTH); /* set the upload data*/
com_rslt += bhy_write_reg(BHY_I2C_REG_UPLOAD_0_ADDR, &v_upload_addr, BHY_GEN_READ_WRITE_LENGTH);
com_rslt += bhy_write_reg(BHY_I2C_REG_UPLOAD_1_ADDR, &v_upload_addr, BHY_GEN_READ_WRITE_LENGTH);
/* write the chip control register as 0x02*/
write_length = data_to_process / BHY_RAM_WRITE_LENGTH_API;
read_index_u8 = BHY_INIT_VALUE;
/* write the memory of data */
/*skips first 16 bytes*/
write_data += 16;
if (com_rslt == BHY_SUCCESS)
{
for (read_index_u8 = BHY_INIT_VALUE; read_index_u8 <= write_length; read_index_u8++)
{
packet_length = (read_index_u8 == write_length) ?
(data_to_process % BHY_RAM_WRITE_LENGTH_API) / BHY_RAM_WRITE_LENGTH :
BHY_RAM_WRITE_LENGTH_API / BHY_RAM_WRITE_LENGTH;
/*reverse the data*/
for (reverse_block_index_u32 = 1; reverse_block_index_u32 <=packet_length ;reverse_block_index_u32++)
{
for (reverse_index_u32 = 0; reverse_index_u32 <BHY_RAM_WRITE_LENGTH; reverse_index_u32++)
{
data_byte[reverse_index_u32+((reverse_block_index_u32-1)*BHY_RAM_WRITE_LENGTH)] =
*(memory + write_data + BHY_RAM_WRITE_LENGTH * reverse_block_index_u32 - (reverse_index_u32+1));
}
}
if(packet_length != 0)
com_rslt += bhy_write_reg(BHY_I2C_REG_UPLOAD_DATA_ADDR,data_byte,packet_length * BHY_RAM_WRITE_LENGTH);
write_data = write_data + (packet_length * BHY_RAM_WRITE_LENGTH);
}
}
/* Check the CRC success*/
com_rslt = bhy_get_crc_host(&v_crc_host_u32);
if (v_crc_from_memory_u32 == v_crc_host_u32)
{
com_rslt = BHY_SUCCESS;
}
else
{
com_rslt = BHY_CRC_ERROR;
goto bhy_init_from_rom_return;
}
/* disable upload mode*/
v_chip_control_u8 = BHY_CHIP_CTRL_ENABLE_2;
/* write the chip control register as 0x02*/
com_rslt += bhy_write_reg(BHY_I2C_REG_CHIP_CONTROL_ADDR,&v_chip_control_u8, BHY_GEN_READ_WRITE_LENGTH);
}
bhy_init_from_rom_return:
return com_rslt;
}
/*!
* @brief API used assign the data of meta event byte 0 data
*
* @param v_meta_event_data_u8: The value of meta event byte0
*
*/
static void bhy_assign_meta_event_byte0(u8 v_meta_event_data_u8)
{
write_buffer.write_parameter_byte1 = v_meta_event_data_u8;
write_buffer.write_parameter_byte2 = read_buffer.parameter_2;
write_buffer.write_parameter_byte3 = read_buffer.parameter_3;
write_buffer.write_parameter_byte4 = read_buffer.parameter_4;
write_buffer.write_parameter_byte5 = read_buffer.parameter_5;
write_buffer.write_parameter_byte6 = read_buffer.parameter_6;
write_buffer.write_parameter_byte7 = read_buffer.parameter_7;
write_buffer.write_parameter_byte8 = read_buffer.parameter_8;}
/*!
* @brief API used assign the data of meta event byte 1 data
*
* @param v_meta_event_data_u8: The value of meta event byte1
*
*/
static void bhy_assign_meta_event_byte1(u8 v_meta_event_data_u8)
{
write_buffer.write_parameter_byte1 = read_buffer.parameter_1;
write_buffer.write_parameter_byte2 = v_meta_event_data_u8;
write_buffer.write_parameter_byte3 = read_buffer.parameter_3;
write_buffer.write_parameter_byte4 = read_buffer.parameter_4;
write_buffer.write_parameter_byte5 = read_buffer.parameter_5;
write_buffer.write_parameter_byte6 = read_buffer.parameter_6;
write_buffer.write_parameter_byte7 = read_buffer.parameter_7;
write_buffer.write_parameter_byte8 = read_buffer.parameter_8;
}
/*!
* @brief API used assign the data of meta event byte 2 data
*
* @param v_meta_event_data_u8: The value of meta event byte2
*
*/
static void bhy_assign_meta_event_byte2(u8 v_meta_event_data_u8)
{
write_buffer.write_parameter_byte1 = read_buffer.parameter_1;
write_buffer.write_parameter_byte2 = read_buffer.parameter_2;
write_buffer.write_parameter_byte3 = v_meta_event_data_u8;
write_buffer.write_parameter_byte4 = read_buffer.parameter_4;
write_buffer.write_parameter_byte5 = read_buffer.parameter_5;
write_buffer.write_parameter_byte6 = read_buffer.parameter_6;
write_buffer.write_parameter_byte7 = read_buffer.parameter_7;
write_buffer.write_parameter_byte8 = read_buffer.parameter_8;
}
/*!
* @brief API used assign the data of meta event byte 3 data
*
* @param v_meta_event_data_u8: The value of meta event byte3
*
*/
static void bhy_assign_meta_event_byte3(u8 v_meta_event_data_u8)
{
write_buffer.write_parameter_byte1 = read_buffer.parameter_1;
write_buffer.write_parameter_byte2 = read_buffer.parameter_2;
write_buffer.write_parameter_byte3 = read_buffer.parameter_3;
write_buffer.write_parameter_byte4 = v_meta_event_data_u8;
write_buffer.write_parameter_byte5 = read_buffer.parameter_5;
write_buffer.write_parameter_byte6 = read_buffer.parameter_6;
write_buffer.write_parameter_byte7 = read_buffer.parameter_7;
write_buffer.write_parameter_byte8 = read_buffer.parameter_8;
}
/*!
* @brief API used assign the data of meta event byte 4 data
*
* @param v_meta_event_data_u8: The value of meta event byte4
*
*/
static void bhy_assign_meta_event_byte4(u8 v_meta_event_data_u8)
{
write_buffer.write_parameter_byte1 = read_buffer.parameter_1;
write_buffer.write_parameter_byte2 = read_buffer.parameter_2;
write_buffer.write_parameter_byte3 = read_buffer.parameter_3;
write_buffer.write_parameter_byte4 = read_buffer.parameter_4;
write_buffer.write_parameter_byte5 = v_meta_event_data_u8;
write_buffer.write_parameter_byte6 = read_buffer.parameter_6;
write_buffer.write_parameter_byte7 = read_buffer.parameter_7;
write_buffer.write_parameter_byte8 = read_buffer.parameter_8;
}
/*!* @brief API used assign the data of meta event byte 5 data
*
* @param v_meta_event_data_u8: The value of meta event byte5
*
*/
static void bhy_assign_meta_event_byte5(u8 v_meta_event_data_u8)
{
write_buffer.write_parameter_byte1 = read_buffer.parameter_1;
write_buffer.write_parameter_byte2 = read_buffer.parameter_2;
write_buffer.write_parameter_byte3 = read_buffer.parameter_3;
write_buffer.write_parameter_byte4 = read_buffer.parameter_4;
write_buffer.write_parameter_byte5 = read_buffer.parameter_6;
write_buffer.write_parameter_byte6 = v_meta_event_data_u8;
write_buffer.write_parameter_byte7 = read_buffer.parameter_7;
write_buffer.write_parameter_byte8 = read_buffer.parameter_8;
}
/*!
* @brief API used assign the data of meta event byte 6 data
*
* @param v_meta_event_data_u8: The value of meta event byte6
*
*/
static void bhy_assign_meta_event_byte6(u8 v_meta_event_data_u8)
{
write_buffer.write_parameter_byte1 = read_buffer.parameter_1;
write_buffer.write_parameter_byte2 = read_buffer.parameter_2;
write_buffer.write_parameter_byte3 = read_buffer.parameter_3;
write_buffer.write_parameter_byte4 = read_buffer.parameter_4;
write_buffer.write_parameter_byte5 = read_buffer.parameter_6;
write_buffer.write_parameter_byte6 = read_buffer.parameter_6;
write_buffer.write_parameter_byte7 = v_meta_event_data_u8;
write_buffer.write_parameter_byte8 = read_buffer.parameter_8;
}
/*!
* @brief API used assign the data of meta event byte 7 data
*
* @param v_meta_event_data_u8: The value of meta event byte7
*
*/
static void bhy_assign_meta_event_byte7(u8 v_meta_event_data_u8)
{
write_buffer.write_parameter_byte1 = read_buffer.parameter_1;
write_buffer.write_parameter_byte2 = read_buffer.parameter_2;
write_buffer.write_parameter_byte3 = read_buffer.parameter_3;
write_buffer.write_parameter_byte4 = read_buffer.parameter_4;
write_buffer.write_parameter_byte5 = read_buffer.parameter_6;
write_buffer.write_parameter_byte6 = read_buffer.parameter_6;
write_buffer.write_parameter_byte7 = read_buffer.parameter_7;
write_buffer.write_parameter_byte8 = v_meta_event_data_u8;
}
/*!
* @brief API used to set the meta event for
* non wakeup FIFO control from
* system page-1 parameter 1
*
*
* @param v_meta_event_u8 : The value of meta event selection
* meta event | value
* --------------------------|---------------
* BHY_META_EVENT_1 | 1
* BHY_META_EVENT_2 | 2
* BHY_META_EVENT_3 | 3
* BHY_META_EVENT_4 | 4
* BHY_META_EVENT_5 | 5
* BHY_META_EVENT_6 | 6
* BHY_META_EVENT_7 | 7
* BHY_META_EVENT_8 | 8
* BHY_META_EVENT_9 | 9
* BHY_META_EVENT_10 | 10
* BHY_META_EVENT_11 | 11 * BHY_META_EVENT_12 | 12
* BHY_META_EVENT_13 | 13
* BHY_META_EVENT_14 | 14
* BHY_META_EVENT_15 | 15
* BHY_META_EVENT_16 | 16
* BHY_META_EVENT_17 | 17
* BHY_META_EVENT_18 | 18
* BHY_META_EVENT_19 | 19
* BHY_META_EVENT_20 | 20
* BHY_META_EVENT_21 | 21
* BHY_META_EVENT_22 | 22
* BHY_META_EVENT_23 | 23
* BHY_META_EVENT_24 | 24
* BHY_META_EVENT_25 | 25
* BHY_META_EVENT_26 | 26
* BHY_META_EVENT_27 | 27
* BHY_META_EVENT_28 | 28
* BHY_META_EVENT_29 | 29
* BHY_META_EVENT_30 | 30
* BHY_META_EVENT_31 | 31
* BHY_META_EVENT_32 | 32
*
* @param v_event_type_u8 : The value of
* interrupt or event selection
* value | Event
* -------------------------|----------------
* BHY_META_EVENT_INTR_ENABLE | 0
* BHY_META_EVENT_ENABLE | 1
*
* @param v_input_data_u8 : The value of meta event
* @note Value for write each event in a bit
* value | Event or Interrupt
* ---------------|----------------------
* 0 | DISABLE EVENT
* 1 | ENABLE EVENT
*
* @param v_meta_parameter_request_u8: The value of parameter
* for wakeup or non wakeup fifo
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_set_meta_event(
u8 v_meta_event_u8,
u8 v_input_data_u8, u8 v_event_type_u8,
u8 v_meta_parameter_request_u8)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u8 v_meta_bytes_u8 = BHY_INIT_VALUE;
/* read the stored meta events using saved parameter bytes*/
com_rslt = bhy_read_parameter_bytes(
BHY_PAGE_1, v_meta_parameter_request_u8);
if (BHY_SUCCESS == com_rslt) {
/* switch for selecting the different meta events*/
switch (v_meta_event_u8) {
/* case for meta event one*/
case BHY_META_EVENT_1:
/* switch for selecting interrupt or event*/
switch (v_event_type_u8) {
/* case for event enable*/
case BHY_META_EVENT_ENABLE:
/* set the meta event 1, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_1 & (~(1 << 1)))|(v_input_data_u8 << 1)); bhy_assign_meta_event_byte0(v_meta_bytes_u8);
break;
/* case for interrupt enable*/
case BHY_META_INTR_ENABLE:
/* set the meta event 1, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_1&(~(1 << 0)))| v_input_data_u8);
bhy_assign_meta_event_byte0(v_meta_bytes_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
/* case for meta event 2*/
case BHY_META_EVENT_2:
/* case for interrupt or event enable*/
switch (v_event_type_u8) {
case BHY_META_EVENT_ENABLE:
/* set the meta event 2, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_1 & (~(1 << 3)))|(v_input_data_u8 << 3));
bhy_assign_meta_event_byte0(v_meta_bytes_u8);
break;
case BHY_META_INTR_ENABLE:
/* set the meta event 2, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_1 & (~(1 << 2)))|(v_input_data_u8 << 2));
bhy_assign_meta_event_byte0(v_meta_bytes_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
/* case for meta event 3*/
case BHY_META_EVENT_3:
switch (v_event_type_u8) {
/* case for event or interrupt enable*/
case BHY_META_EVENT_ENABLE:
/* set the meta event 3, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_1 & (~(1 << 5)))|(v_input_data_u8 << 5));
bhy_assign_meta_event_byte0(v_meta_bytes_u8);
break;
case BHY_META_INTR_ENABLE:
/* set the meta event 3, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_1 & (~(1 << 4)))|(v_input_data_u8 << 4));
bhy_assign_meta_event_byte0(v_meta_bytes_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
/* case for meta event four*/
case BHY_META_EVENT_4:
switch (v_event_type_u8) {
case BHY_META_EVENT_ENABLE:
/* set the meta event 4, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_1 & (~(1 << 7)))|(v_input_data_u8 << 7));
bhy_assign_meta_event_byte0(v_meta_bytes_u8);
break;
case BHY_META_INTR_ENABLE:
/* set the meta event 4, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_1 & (~(1 << 6)))|(v_input_data_u8 << 6));
bhy_assign_meta_event_byte0(v_meta_bytes_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_5: switch (v_event_type_u8) {
case BHY_META_EVENT_ENABLE:
/* set the meta event 5, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_2 & (~(1 << 1)))|(v_input_data_u8 << 1));
bhy_assign_meta_event_byte1(v_meta_bytes_u8);
break;
case BHY_META_INTR_ENABLE:
/* set the meta event 5, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_2 & (~(1 << 0)))|(v_input_data_u8 << 0));
bhy_assign_meta_event_byte1(v_meta_bytes_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_6:
switch (v_event_type_u8) {
case BHY_META_EVENT_ENABLE:
/* set the meta event 6, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_2 & (~(1 << 3)))|(v_input_data_u8 << 3));
bhy_assign_meta_event_byte1(v_meta_bytes_u8);
break;
case BHY_META_INTR_ENABLE:
/* set the meta event 6, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_2 & (~(1 << 2)))|(v_input_data_u8 << 2));
bhy_assign_meta_event_byte1(v_meta_bytes_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_7:
switch (v_event_type_u8) {
case BHY_META_EVENT_ENABLE:
/* set the meta event 7, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_2 & (~(1 << 5)))|(v_input_data_u8 << 5));
bhy_assign_meta_event_byte1(v_meta_bytes_u8);
break;
case BHY_META_INTR_ENABLE:
/* set the meta event 7, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_2 & (~(1 << 4)))|(v_input_data_u8 << 4));
bhy_assign_meta_event_byte1(v_meta_bytes_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_8:
switch (v_event_type_u8) {
case BHY_META_EVENT_ENABLE:
/* set the meta event 8, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_2 & (~(1 << 7)))|(v_input_data_u8 << 7));
bhy_assign_meta_event_byte1(v_meta_bytes_u8);
break;
case BHY_META_INTR_ENABLE:
/* set the meta event 8, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_2 & (~(1 << 6)))|(v_input_data_u8 << 6));
bhy_assign_meta_event_byte1(v_meta_bytes_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_9:
switch (v_event_type_u8) {
case BHY_META_EVENT_ENABLE: /* set the meta event 9, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_3 & (~(1 << 1)))|(v_input_data_u8 << 1));
bhy_assign_meta_event_byte2(v_meta_bytes_u8);
break;
case BHY_META_INTR_ENABLE:
/* set the meta event 9, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_3 & (~(1 << 0)))|(v_input_data_u8 << 0));
bhy_assign_meta_event_byte2(v_meta_bytes_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_10:
switch (v_event_type_u8) {
case BHY_META_EVENT_ENABLE:
/* set the meta event 10, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_3 & (~(1 << 3)))|(v_input_data_u8 << 3));
bhy_assign_meta_event_byte2(v_meta_bytes_u8);
break;
case BHY_META_INTR_ENABLE:
/* set the meta event 10, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_3 & (~(1 << 2)))|(v_input_data_u8 << 2));
bhy_assign_meta_event_byte2(v_meta_bytes_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_11:
switch (v_event_type_u8) {
case BHY_META_EVENT_ENABLE:
/* set the meta event 11, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_3 & (~(1 << 5)))|(v_input_data_u8 << 5));
bhy_assign_meta_event_byte2(v_meta_bytes_u8);
break;
case BHY_META_INTR_ENABLE:
/* set the meta event 11, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_3 & (~(1 << 4)))|(v_input_data_u8 << 4));
bhy_assign_meta_event_byte2(v_meta_bytes_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_12:
switch (v_event_type_u8) {
case BHY_META_EVENT_ENABLE:
/* set the meta event 12, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_3 & (~(1 << 7)))|(v_input_data_u8 << 7));
bhy_assign_meta_event_byte2(v_meta_bytes_u8);
break;
case BHY_META_INTR_ENABLE:
/* set the meta event 12, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_3 & (~(1 << 6)))|(v_input_data_u8 << 6));
bhy_assign_meta_event_byte2(v_meta_bytes_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_13:
/* set the meta event 13, event enable*/
switch (v_event_type_u8) {
case BHY_META_EVENT_ENABLE:
v_meta_bytes_u8 = ((read_buffer.parameter_4 & (~(1 << 1)))|(v_input_data_u8 << 1)); bhy_assign_meta_event_byte3(v_meta_bytes_u8);
break;
case BHY_META_INTR_ENABLE:
/* set the meta event 13, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_4 & (~(1 << 0)))|(v_input_data_u8 << 0));
bhy_assign_meta_event_byte3(v_meta_bytes_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_14:
switch (v_event_type_u8) {
case BHY_META_EVENT_ENABLE:
/* set the meta event 14, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_4 & (~(1 << 3)))|(v_input_data_u8 << 3));
bhy_assign_meta_event_byte3(v_meta_bytes_u8);
break;
case BHY_META_INTR_ENABLE:
/* set the meta event 14, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_4 & (~(1 << 2)))|(v_input_data_u8 << 2));
bhy_assign_meta_event_byte3(v_meta_bytes_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_15:
switch (v_event_type_u8) {
case BHY_META_EVENT_ENABLE:
/* set the meta event 15, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_4 & (~(1 << 5)))|(v_input_data_u8 << 5));
bhy_assign_meta_event_byte3(v_meta_bytes_u8);
break;
case BHY_META_INTR_ENABLE:
/* set the meta event 15, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_4 & (~(1 << 4)))|(v_input_data_u8 << 4));
bhy_assign_meta_event_byte3(v_meta_bytes_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_16:
switch (v_event_type_u8) {
case BHY_META_EVENT_ENABLE:
/* set the meta event 16, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_4 & (~(1 << 7)))|(v_input_data_u8 << 7));
bhy_assign_meta_event_byte3(v_meta_bytes_u8);
break;
case BHY_META_INTR_ENABLE:
/* set the meta event 16, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_4 & (~(1 << 6)))|(v_input_data_u8 << 6));
bhy_assign_meta_event_byte3(v_meta_bytes_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_17:
switch (v_event_type_u8) {
case BHY_META_EVENT_ENABLE:
/* set the meta event 17, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_5 & (~(1 << 1)))|(v_input_data_u8 << 1));
bhy_assign_meta_event_byte4(v_meta_bytes_u8);
break; case BHY_META_INTR_ENABLE:
/* set the meta event 17, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_5 & (~(1 << 0)))|(v_input_data_u8 << 0));
bhy_assign_meta_event_byte4(v_meta_bytes_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_18:
switch (v_event_type_u8) {
case BHY_META_EVENT_ENABLE:
/* set the meta event 18, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_5 & (~(1 << 3)))|(v_input_data_u8 << 3));
bhy_assign_meta_event_byte4(v_meta_bytes_u8);
break;
case BHY_META_INTR_ENABLE:
/* set the meta event 18, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_5 & (~(1 << 2)))|(v_input_data_u8 << 2));
bhy_assign_meta_event_byte4(v_meta_bytes_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_19:
switch (v_event_type_u8) {
case BHY_META_EVENT_ENABLE:
/* set the meta event 19, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_5 & (~(1 << 5)))|(v_input_data_u8 << 5));
bhy_assign_meta_event_byte4(v_meta_bytes_u8);
break;
case BHY_META_INTR_ENABLE:
/* set the meta event 19, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_5 & (~(1 << 4)))|(v_input_data_u8 << 4));
bhy_assign_meta_event_byte4(v_meta_bytes_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_20:
switch (v_event_type_u8) {
case BHY_META_EVENT_ENABLE:
/* set the meta event 20, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_5 & (~(1 << 7)))|(v_input_data_u8 << 7));
bhy_assign_meta_event_byte4(v_meta_bytes_u8);
break;
case BHY_META_INTR_ENABLE:
/* set the meta event 20, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_5 & (~(1 << 6)))|(v_input_data_u8 << 6));
bhy_assign_meta_event_byte4(v_meta_bytes_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_21:
switch (v_event_type_u8) {
case BHY_META_EVENT_ENABLE:
/* set the meta event 21, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_6 & (~(1 << 1)))|(v_input_data_u8 << 1));
bhy_assign_meta_event_byte5(v_meta_bytes_u8);
break;
case BHY_META_INTR_ENABLE:
/* set the meta event 21, interrupt enable*/ v_meta_bytes_u8 = ((read_buffer.parameter_6 & (~(1 << 0)))|(v_input_data_u8 << 0));
bhy_assign_meta_event_byte5(v_meta_bytes_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_22:
switch (v_event_type_u8) {
case BHY_META_EVENT_ENABLE:
/* set the meta event 22, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_6 & (~(1 << 3)))|(v_input_data_u8 << 3));
bhy_assign_meta_event_byte5(v_meta_bytes_u8);
break;
case BHY_META_INTR_ENABLE:
/* set the meta event 22, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_6 & (~(1 << 2)))|(v_input_data_u8 << 2));
bhy_assign_meta_event_byte5(v_meta_bytes_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_23:
switch (v_event_type_u8) {
case BHY_META_EVENT_ENABLE:
/* set the meta event 23, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_6 & (~(1 << 5)))|(v_input_data_u8 << 5));
bhy_assign_meta_event_byte5(v_meta_bytes_u8);
break;
case BHY_META_INTR_ENABLE:
/* set the meta event 23, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_6 & (~(1 << 4)))|(v_input_data_u8 << 4));
bhy_assign_meta_event_byte5(v_meta_bytes_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_24:
switch (v_event_type_u8) {
case BHY_META_EVENT_ENABLE:
/* set the meta event 24, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_6 & (~(1 << 7)))|(v_input_data_u8 << 7));
bhy_assign_meta_event_byte5(v_meta_bytes_u8);
break;
case BHY_META_INTR_ENABLE:
/* set the meta event 24, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_6 & (~(1 << 6)))|(v_input_data_u8 << 6));
bhy_assign_meta_event_byte5(v_meta_bytes_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_25:
switch (v_event_type_u8) {
case BHY_META_EVENT_ENABLE:
/* set the meta event 25, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_7 & (~(1 << 1)))|(v_input_data_u8 << 1));
bhy_assign_meta_event_byte6(v_meta_bytes_u8);
break;
case BHY_META_INTR_ENABLE:
/* set the meta event 25, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_7 & (~(1 << 0)))|(v_input_data_u8 << 0));
bhy_assign_meta_event_byte6(v_meta_bytes_u8); break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_26:
switch (v_event_type_u8) {
case BHY_META_EVENT_ENABLE:
/* set the meta event 26, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_7 & (~(1 << 3)))|(v_input_data_u8 << 3));
bhy_assign_meta_event_byte6(v_meta_bytes_u8);
break;
case BHY_META_INTR_ENABLE:
/* set the meta event 26, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_7 & (~(1 << 2)))|(v_input_data_u8 << 2));
bhy_assign_meta_event_byte6(v_meta_bytes_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_27:
switch (v_event_type_u8) {
case BHY_META_EVENT_ENABLE:
/* set the meta event 27, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_7 & (~(1 << 5)))|(v_input_data_u8 << 5));
bhy_assign_meta_event_byte6(v_meta_bytes_u8);
break;
case BHY_META_INTR_ENABLE:
/* set the meta event 27, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_7 & (~(1 << 4)))|(v_input_data_u8 << 4));
bhy_assign_meta_event_byte6(v_meta_bytes_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_28:
switch (v_event_type_u8) {
case BHY_META_EVENT_ENABLE:
/* set the meta event 28, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_7 & (~(1 << 7)))|(v_input_data_u8 << 7));
bhy_assign_meta_event_byte6(v_meta_bytes_u8);
break;
case BHY_META_INTR_ENABLE:
/* set the meta event 28, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_7 & (~(1 << 6)))|(v_input_data_u8 << 6));
bhy_assign_meta_event_byte6(v_meta_bytes_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_29:
switch (v_event_type_u8) {
case BHY_META_EVENT_ENABLE:
/* set the meta event 29, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_8 & (~(1 << 1)))|(v_input_data_u8 << 1));
bhy_assign_meta_event_byte7(v_meta_bytes_u8);
break;
case BHY_META_INTR_ENABLE:
/* set the meta event 29, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_8 & (~(1 << 0)))|(v_input_data_u8 << 0));
bhy_assign_meta_event_byte7(v_meta_bytes_u8);
break;
default: com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_30:
switch (v_event_type_u8) {
case BHY_META_EVENT_ENABLE:
/* set the meta event 30, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_8 & (~(1 << 3)))|(v_input_data_u8 << 3));
bhy_assign_meta_event_byte7(v_meta_bytes_u8);
break;
case BHY_META_INTR_ENABLE:
/* set the meta event 30, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_8 & (~(1 << 2)))|(v_input_data_u8 << 2));
bhy_assign_meta_event_byte7(v_meta_bytes_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_31:
switch (v_event_type_u8) {
case BHY_META_EVENT_ENABLE:
/* set the meta event 31, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_8 & (~(1 << 5)))|(v_input_data_u8 << 5));
bhy_assign_meta_event_byte7(v_meta_bytes_u8);
break;
case BHY_META_INTR_ENABLE:
/* set the meta event 31, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_8 & (~(1 << 4)))|(v_input_data_u8 << 4));
bhy_assign_meta_event_byte7(v_meta_bytes_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_32:
switch (v_event_type_u8) {
case BHY_META_EVENT_ENABLE:
/* set the meta event 32, event enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_8 & (~(1 << 7)))|(v_input_data_u8 << 7));
bhy_assign_meta_event_byte7(v_meta_bytes_u8);
break;
case BHY_META_INTR_ENABLE:
/* set the meta event 32, interrupt enable*/
v_meta_bytes_u8 = ((read_buffer.parameter_8 & (~(1 << 6)))|(v_input_data_u8 << 6));
bhy_assign_meta_event_byte7(v_meta_bytes_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
}
/* write the meta event values to the meta event bytes*/
com_rslt += bhy_write_parameter_bytes(
BHY_PAGE_1, (v_meta_parameter_request_u8+0x80));
return com_rslt;
}
/*!
* @brief API used to get the meta event control from
* system page-1 parameter 1
* * @param v_meta_event_u8 : The value of meta event selection
* meta event | value
* --------------------------|---------------
* BHY_META_EVENT_1 | 1
* BHY_META_EVENT_2 | 2
* BHY_META_EVENT_3 | 3
* BHY_META_EVENT_4 | 4
* BHY_META_EVENT_5 | 5
* BHY_META_EVENT_6 | 6
* BHY_META_EVENT_7 | 7
* BHY_META_EVENT_8 | 8
* BHY_META_EVENT_9 | 9
* BHY_META_EVENT_10 | 10
* BHY_META_EVENT_11 | 11
* BHY_META_EVENT_12 | 12
* BHY_META_EVENT_13 | 13
* BHY_META_EVENT_14 | 14
* BHY_META_EVENT_15 | 15
* BHY_META_EVENT_16 | 16
* BHY_META_EVENT_17 | 17
* BHY_META_EVENT_18 | 18
* BHY_META_EVENT_19 | 19
* BHY_META_EVENT_20 | 20
* BHY_META_EVENT_21 | 21
* BHY_META_EVENT_22 | 22
* BHY_META_EVENT_23 | 23
* BHY_META_EVENT_24 | 24
* BHY_META_EVENT_25 | 25
* BHY_META_EVENT_26 | 26
* BHY_META_EVENT_27 | 27
* BHY_META_EVENT_28 | 28
* BHY_META_EVENT_29 | 29
* BHY_META_EVENT_30 | 30
* BHY_META_EVENT_31 | 31
* BHY_META_EVENT_32 | 32
*
* @param meta_intr :
* The value of meta event interrupt selection
*
* @param meta_event :
* The value of meta event event selection
*
* @param v_event_type_u8 : The value of
* interrupt or event selection
* value | Event
* -------------------------|----------------
* BHY_META_EVENT_INTR_ENABLE | 0
* BHY_META_EVENT_ENABLE | 1
*
* @param v_meta_parameter_request_u8: The value of parameter request
* for wakeup or non wakeup fifo
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_get_meta_event(
u8 v_meta_event_u8, u8 v_event_type_u8,
u8* meta_event_intr,
u8* meta_event_event,
u8 v_meta_parameter_request_u8)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u8 v_meta_event_byte_0_u8 = BHY_INIT_VALUE;
u8 v_meta_event_byte_1_u8 = BHY_INIT_VALUE;
u8 v_meta_event_byte_2_u8 = BHY_INIT_VALUE;u8 v_meta_event_byte_3_u8 = BHY_INIT_VALUE;
u8 v_meta_event_byte_4_u8 = BHY_INIT_VALUE;
u8 v_meta_event_byte_5_u8 = BHY_INIT_VALUE;
u8 v_meta_event_byte_6_u8 = BHY_INIT_VALUE;
u8 v_meta_event_byte_7_u8 = BHY_INIT_VALUE;
/* check the p_bhy pointer as NULL*/
if (BHY_NULL_PTR == p_bhy) {
com_rslt = BHY_NULL;
} else {
/* input as page 1 and parameter 1 for system page*/
com_rslt = bhy_read_parameter_bytes(
BHY_PAGE_1, v_meta_parameter_request_u8);
v_meta_event_byte_0_u8 = read_buffer.parameter_1;
v_meta_event_byte_1_u8 = read_buffer.parameter_2;
v_meta_event_byte_2_u8 = read_buffer.parameter_3;
v_meta_event_byte_3_u8 = read_buffer.parameter_4;
v_meta_event_byte_4_u8 = read_buffer.parameter_5;
v_meta_event_byte_5_u8 = read_buffer.parameter_6;
v_meta_event_byte_6_u8 = read_buffer.parameter_7;
v_meta_event_byte_7_u8 = read_buffer.parameter_8;
switch (v_meta_event_u8) {
case BHY_META_EVENT_1:
switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
(v_meta_event_byte_0_u8 &
BHY_META_EVENT1_INTR_ENABLE);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_0_u8 &
BHY_META_EVENT1_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_01_BIT);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_2:
switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
((v_meta_event_byte_0_u8 &
BHY_META_EVENT2_INTR_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_02_BITS);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_0_u8 &
BHY_META_EVENT2_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_03_BITS);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_3:
switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
((v_meta_event_byte_0_u8 &
BHY_META_EVENT3_INTR_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_04_BITS);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_0_u8 &
BHY_META_EVENT3_EVENT_ENABLE) >> BHY_SHIFT_BIT_POSITION_BY_05_BITS);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_4:
switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
((v_meta_event_byte_0_u8 &
BHY_META_EVENT4_INTR_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_06_BITS);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_0_u8 &
BHY_META_EVENT4_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_07_BITS);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_5:
switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
(v_meta_event_byte_1_u8 &
BHY_META_EVENT5_INTR_ENABLE);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_1_u8 &
BHY_META_EVENT5_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_01_BIT);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_6:
switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
((v_meta_event_byte_1_u8 &
BHY_META_EVENT6_INTR_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_02_BITS);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_1_u8 &
BHY_META_EVENT6_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_03_BITS);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_7:
switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
((v_meta_event_byte_1_u8 &
BHY_META_EVENT7_INTR_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_04_BITS); break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_1_u8 &
BHY_META_EVENT7_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_05_BITS);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_8:
switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
((v_meta_event_byte_1_u8 &
BHY_META_EVENT8_INTR_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_06_BITS);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_1_u8 &
BHY_META_EVENT8_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_07_BITS);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_9:
switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
(v_meta_event_byte_2_u8 &
BHY_META_EVENT9_INTR_ENABLE);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_2_u8 &
BHY_META_EVENT9_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_01_BIT);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_10:
switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
((v_meta_event_byte_2_u8 &
BHY_META_EVENT10_INTR_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_02_BITS);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_2_u8 &
BHY_META_EVENT10_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_03_BITS);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_11:
switch (v_event_type_u8) { case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
((v_meta_event_byte_2_u8 &
BHY_META_EVENT11_INTR_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_04_BITS);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_2_u8 &
BHY_META_EVENT11_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_05_BITS);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_12:
switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
((v_meta_event_byte_2_u8 &
BHY_META_EVENT12_INTR_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_06_BITS);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_2_u8 &
BHY_META_EVENT12_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_07_BITS);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_13:
switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
(v_meta_event_byte_3_u8 &
BHY_META_EVENT13_INTR_ENABLE);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_3_u8 &
BHY_META_EVENT13_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_01_BIT);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_14:
switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
((v_meta_event_byte_3_u8 &
BHY_META_EVENT14_INTR_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_02_BITS);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_3_u8 &
BHY_META_EVENT14_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_03_BITS);
break;
default:
com_rslt = BHY_OUT_OF_RANGE; break;
}
break;
case BHY_META_EVENT_15:
switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
((v_meta_event_byte_3_u8 &
BHY_META_EVENT15_INTR_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_04_BITS);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_3_u8 &
BHY_META_EVENT15_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_05_BITS);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_16:
switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
((v_meta_event_byte_3_u8 &
BHY_META_EVENT16_INTR_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_06_BITS);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_3_u8 &
BHY_META_EVENT16_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_07_BITS);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_17:
switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
(v_meta_event_byte_4_u8 &
BHY_META_EVENT17_INTR_ENABLE);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_4_u8 &
BHY_META_EVENT17_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_01_BIT);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_18:
switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
((v_meta_event_byte_4_u8 &
BHY_META_EVENT18_INTR_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_02_BITS);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_4_u8 & BHY_META_EVENT18_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_03_BITS);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_19:
switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
((v_meta_event_byte_4_u8 &
BHY_META_EVENT19_INTR_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_04_BITS);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_4_u8 &
BHY_META_EVENT19_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_05_BITS);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_20:
switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
((v_meta_event_byte_4_u8 &
BHY_META_EVENT20_INTR_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_06_BITS);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_4_u8 &
BHY_META_EVENT20_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_07_BITS);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_21:
switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
(v_meta_event_byte_5_u8 &
BHY_META_EVENT21_INTR_ENABLE);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_5_u8 &
BHY_META_EVENT21_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_01_BIT);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_22:
switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
((v_meta_event_byte_5_u8 &
BHY_META_EVENT22_INTR_ENABLE) >> BHY_SHIFT_BIT_POSITION_BY_02_BITS);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_5_u8 &
BHY_META_EVENT22_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_03_BITS);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_23:
switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
((v_meta_event_byte_5_u8 &
BHY_META_EVENT23_INTR_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_04_BITS);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_5_u8 &
BHY_META_EVENT23_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_05_BITS);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_24:
switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
((v_meta_event_byte_5_u8 &
BHY_META_EVENT24_INTR_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_06_BITS);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_5_u8 &
BHY_META_EVENT24_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_07_BITS);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_25:
switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
(v_meta_event_byte_6_u8 &
BHY_META_EVENT25_INTR_ENABLE);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_6_u8 &
BHY_META_EVENT25_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_01_BIT);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_26: switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
((v_meta_event_byte_6_u8 &
BHY_META_EVENT26_INTR_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_02_BITS);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_6_u8 &
BHY_META_EVENT26_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_03_BITS);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_27:
switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
((v_meta_event_byte_6_u8 &
BHY_META_EVENT27_INTR_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_04_BITS);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_6_u8 &
BHY_META_EVENT27_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_05_BITS);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_28:
switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
((v_meta_event_byte_6_u8 &
BHY_META_EVENT28_INTR_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_06_BITS);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_6_u8 &
BHY_META_EVENT28_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_07_BITS);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_29:
switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
(v_meta_event_byte_7_u8 &
BHY_META_EVENT29_INTR_ENABLE);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_7_u8 &
BHY_META_EVENT29_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_01_BIT);
break;
default: com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_30:
switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
((v_meta_event_byte_7_u8 &
BHY_META_EVENT30_INTR_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_02_BITS);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_7_u8 &
BHY_META_EVENT30_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_03_BITS);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_31:
switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
((v_meta_event_byte_7_u8 &
BHY_META_EVENT31_INTR_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_04_BITS);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_7_u8 &
BHY_META_EVENT31_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_05_BITS);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
case BHY_META_EVENT_32:
switch (v_event_type_u8) {
case BHY_META_INTR_ENABLE:
*meta_event_intr = (u8)
((v_meta_event_byte_7_u8 &
BHY_META_EVENT32_INTR_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_06_BITS);
break;
case BHY_META_EVENT_ENABLE:
*meta_event_event = (u8)
((v_meta_event_byte_7_u8 &
BHY_META_EVENT32_EVENT_ENABLE)
>> BHY_SHIFT_BIT_POSITION_BY_07_BITS);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
}
return com_rslt;
}
/*!
* @brief API used to get the fifo water mark from * system page-1 parameter 2
*
*
* @param v_parameter_u8 :
* The value of fifo water mark wakeup or non-wakeup selection
* water mark | value
* --------------------------|---------------
* FIFO_WM_WAKEUP | 0
* FIFO_WM_NON_WAKEUP | 1
*
* @param v_fifo_water_mark_u16: The value of fifo water mark
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_get_fifo_water_mark(u8 v_parameter_u8, u16 *v_fifo_water_mark_u16)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u8 v_fifo_wm_wakeup_lsb_u8 = BHY_INIT_VALUE;
u8 v_fifo_wm_wakeup_msb_u8 = BHY_INIT_VALUE;
u8 v_fifo_wm_non_wakeup_lsb_u8 = BHY_INIT_VALUE;
u8 v_fifo_wm_non_wakeup_msb_u8 = BHY_INIT_VALUE;
/* input as page 1 and parameter 2 for system page*/
com_rslt = bhy_read_parameter_bytes( BHY_PAGE_1, BHY_PARAMETER_REQUEST_READ_PARAMETER_2);
if (BHY_SUCCESS == com_rslt)
{
switch (v_parameter_u8)
{
case BHY_FIFO_WATER_MARK_WAKEUP:
/* fifo wakeup water mark*/
v_fifo_wm_wakeup_lsb_u8 = read_buffer.parameter_1;
v_fifo_wm_wakeup_msb_u8 = read_buffer.parameter_2;
*v_fifo_water_mark_u16 = (u16)((v_fifo_wm_wakeup_msb_u8 << BHY_SHIFT_BIT_POSITION_BY_08_BITS)\
|(v_fifo_wm_wakeup_lsb_u8));
break;
case BHY_FIFO_WATER_MARK_NON_WAKEUP:
/* fifo non wakeup water mark*/
v_fifo_wm_non_wakeup_lsb_u8 = read_buffer.parameter_5;
v_fifo_wm_non_wakeup_msb_u8 = read_buffer.parameter_6;
*v_fifo_water_mark_u16 = (u16)((v_fifo_wm_non_wakeup_msb_u8<< BHY_SHIFT_BIT_POSITION_BY_08_BITS)\
|(v_fifo_wm_non_wakeup_lsb_u8));
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
}
return com_rslt;
}
/*!
* @brief API used to set the fifo water mark from
* system page-1 parameter 2
*
*
* @param v_parameter_u8 :
* The value of fifo water mark wakeup or non-wakeup selection
* water mark | value
* --------------------------|---------------
* FIFO_WM_WAKEUP | 0
* FIFO_WM_NON_WAKEUP | 1
*
* @param v_fifo_water_mark_u16: The value of fifo water mark
*
*
* @return results of bus communication function * @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_set_fifo_water_mark(u8 v_parameter_u8, u16 v_fifo_water_mark_u16)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u8 v_fifo_wm_lsb_u8 = BHY_INIT_VALUE;
u8 v_fifo_wm_msb_u8 = BHY_INIT_VALUE;
/* read the fifo water mark using saved parameter bytes*/
com_rslt = bhy_read_parameter_bytes( BHY_PAGE_1, BHY_PARAMETER_REQUEST_READ_PARAMETER_2);
if (BHY_SUCCESS == com_rslt)
{
v_fifo_wm_lsb_u8 = (u8)(v_fifo_water_mark_u16 & BHY_MASK_LSB_DATA);
v_fifo_wm_msb_u8 = (u8)((v_fifo_water_mark_u16 & BHY_MASK_MSB_DATA)>> BHY_SHIFT_BIT_POSITION_BY_08_BITS);
switch (v_parameter_u8)
{
/* fifo wakeup water mark*/
case BHY_FIFO_WATER_MARK_WAKEUP:
write_buffer.write_parameter_byte1 = v_fifo_wm_lsb_u8;
write_buffer.write_parameter_byte2 = v_fifo_wm_msb_u8;
write_buffer.write_parameter_byte5 = read_buffer.parameter_5;
write_buffer.write_parameter_byte6 = read_buffer.parameter_6;
break;
/* fifo non wakeup water mark*/
case BHY_FIFO_WATER_MARK_NON_WAKEUP:
write_buffer.write_parameter_byte1 = read_buffer.parameter_1;
write_buffer.write_parameter_byte2 = read_buffer.parameter_2;
write_buffer.write_parameter_byte5 = v_fifo_wm_lsb_u8;
write_buffer.write_parameter_byte6 = v_fifo_wm_msb_u8;
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
}
com_rslt += bhy_write_parameter_bytes(
BHY_PAGE_1, BHY_PARAMETER_REQUEST_WRITE_PARAMETER_2);
return com_rslt;
}
/*!
* @brief API used to get the fifo size from
* system page-1 parameter 2
* @note wakeup - bytes from 2 and 3
* @note non wakeup - bytes from 6 and 7
*
*
* @param v_fifo_size_select_u8 :
* The value of fifo size mark wakeup or non-wakeup selection
* water mark | value
* --------------------------|---------------
* BHY_FIFO_SIZE_WAKEUP | 0
* BHY_FIFO_SIZE_NON_WAKEUP | 1
*
* @param v_fifo_size_u16 : The value of fifo size
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_get_fifo_size(
u8 v_fifo_size_select_u8, u16 *v_fifo_size_u16)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES; u8 v_fifo_size_wakeup_lsb_u8 = BHY_INIT_VALUE;
u8 v_fifo_size_wakeup_msb_u8 = BHY_INIT_VALUE;
u8 v_fifo_size_non_wakeup_lsb_u8 = BHY_INIT_VALUE;
u8 v_fifo_size_non_wakeup_msb_u8 = BHY_INIT_VALUE;
/* check the p_bhy pointer as NULL*/
if (BHY_NULL_PTR == p_bhy) {
com_rslt = BHY_NULL;
} else {
/* input as page 1 and parameter 2 for system page*/
com_rslt = bhy_read_parameter_bytes(
BHY_PAGE_1, BHY_PARAMETER_REQUEST_READ_PARAMETER_2);
if (BHY_SUCCESS == com_rslt) {
switch (v_fifo_size_select_u8) {
case BHY_FIFO_SIZE_WAKEUP:
/* fifo size in wakeup*/
v_fifo_size_wakeup_lsb_u8 =
read_buffer.parameter_3;
v_fifo_size_wakeup_msb_u8 =
read_buffer.parameter_4;
*v_fifo_size_u16 =
(u16)((v_fifo_size_wakeup_msb_u8
<< BHY_SHIFT_BIT_POSITION_BY_08_BITS)
|(v_fifo_size_wakeup_lsb_u8));
break;
case BHY_FIFO_SIZE_NON_WAKEUP:
/* fifo size in non wakeup*/
v_fifo_size_non_wakeup_lsb_u8 =
read_buffer.parameter_7;
v_fifo_size_non_wakeup_msb_u8 =
read_buffer.parameter_8;
*v_fifo_size_u16 =
(u16)((v_fifo_size_non_wakeup_msb_u8
<< BHY_SHIFT_BIT_POSITION_BY_08_BITS)
|(v_fifo_size_non_wakeup_lsb_u8));
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
}
}
return com_rslt;
}
/*!
* @brief API used to assign the sensor status bank data
*
*
* @param v_sensor_status_u8 :
* The value for saved parameter data
*
*
* @return Nothing
*
*
*/
static void bhy_assign_sensor_status_bank(u8 v_sensor_status_u8)
{
/* Assign the sensor status bank*/
/* data available*/
sensor_status_bank.data_available = (u8)
(v_sensor_status_u8
& BHY_SENSOR_BANK_STATUS_DATA_AVAILABLE);
/* i2c nack*/
sensor_status_bank.i2c_nack = (u8)
((v_sensor_status_u8
& BHY_SENSOR_BANK_STATUS_I2C_NACK)
>> BHY_SHIFT_BIT_POSITION_BY_01_BIT);
/* device id error*/
sensor_status_bank.device_id_error = (u8)
((v_sensor_status_u8 & BHY_SENSOR_BANK_STATUS_DEVICE_ID_ERROR)
>> BHY_SHIFT_BIT_POSITION_BY_02_BITS);
/* transient error*/
sensor_status_bank.transient_error = (u8)
((v_sensor_status_u8
& BHY_SENSOR_BANK_STATUS_TRANSIENT_ERROR)
>> BHY_SHIFT_BIT_POSITION_BY_03_BITS);
/* data lost*/
sensor_status_bank.data_lost = (u8)
((v_sensor_status_u8
& BHY_SENSOR_BANK_STATUS_DATA_LOST)
>> BHY_SHIFT_BIT_POSITION_BY_04_BITS);
/* sensor power mode*/
sensor_status_bank.sensor_power_mode = (u8)
((v_sensor_status_u8
& BHY_SENSOR_BANK_STATUS_POWER_MODE)
>> BHY_SHIFT_BIT_POSITION_BY_05_BITS);
}
/*!
* @brief API used to get the sensor status bank from
* system page-1 parameter 3 to 6
* @note Sensor status bank 0 : parameter 3 contains 1 to 16 sensor type
* @note Sensor status bank 1 : parameter 4 contains 17 to 32 sensor type
* @note Sensor status bank 2 : parameter 5 contains 33 to 48 sensor type
* @note Sensor status bank 3 : parameter 6 contains 49 to 64 sensor type
*
*
* @param v_sensor_type_u8 :
* The value of sensor status bank sensor type selection
* v_sensor_type_u8 | value
* -----------------------------------|---------------
* BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_1 | 0
* BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_2 | 1
* BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_3 | 3
* BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_4 | 4
* BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_5 | 5
* BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_6 | 6
* BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_7 | 7
* BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_8 | 8
* BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_9 | 9
* BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_10 | 10
* BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_11 | 11
* BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_12 | 12
* BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_13 | 13
* BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_14 | 14
* BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_15 | 15
* BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_16 | 16
*
*
* @param v_sensor_status_parameter_u8 :
* The value of sensor status bank parameter selection
* parameter | value
* -------------------------------|-----------------
* BHY_PARAMETER_REQUEST_READ_PARAMETER_3 | 0x03
* BHY_PARAMETER_REQUEST_READ_PARAMETER_4 | 0x04
* BHY_PARAMETER_REQUEST_READ_PARAMETER_5 | 0x05
* BHY_PARAMETER_REQUEST_READ_PARAMETER_6 | 0x06
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_get_sensor_status_bank(
u8 v_sensor_status_parameter_u8, u8 v_sensor_type_u8)
{
/* variable used for return the status of communication result*/ BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u8 v_data_u8 = BHY_INIT_VALUE;
/* input as page 1 and parameter
3(4 or 5 or 6)for system page*/
com_rslt = bhy_read_parameter_bytes(
BHY_PAGE_1, v_sensor_status_parameter_u8);
if (BHY_SUCCESS == com_rslt) {
switch (v_sensor_type_u8) {
case BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_1:
/* sensor status of data available*/
v_data_u8 = read_buffer.parameter_1;
bhy_assign_sensor_status_bank(v_data_u8);
break;
case BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_2:
/* sensor status of data available*/
v_data_u8 = read_buffer.parameter_2;
bhy_assign_sensor_status_bank(v_data_u8);
break;
case BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_3:
/* sensor status of data available*/
v_data_u8 = read_buffer.parameter_3;
bhy_assign_sensor_status_bank(v_data_u8);
break;
case BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_4:
/* sensor status of data available*/
v_data_u8 = read_buffer.parameter_4;
bhy_assign_sensor_status_bank(v_data_u8);
break;
case BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_5:
/* sensor status of data available*/
v_data_u8 = read_buffer.parameter_5;
bhy_assign_sensor_status_bank(v_data_u8);
break;
case BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_6:
/* sensor status of data available*/
v_data_u8 = read_buffer.parameter_6;
bhy_assign_sensor_status_bank(v_data_u8);
break;
case BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_7:
/* sensor status of data available*/
v_data_u8 = read_buffer.parameter_7;
bhy_assign_sensor_status_bank(v_data_u8);
break;
case BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_8:
/* sensor status of data available*/
v_data_u8 = read_buffer.parameter_8;
bhy_assign_sensor_status_bank(v_data_u8);
break;
case BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_9:
/* sensor status of data available*/
v_data_u8 = read_buffer.parameter_9;
bhy_assign_sensor_status_bank(v_data_u8);
break;
case BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_10:
/* sensor status of data available*/
v_data_u8 = read_buffer.parameter_10;
bhy_assign_sensor_status_bank(v_data_u8);
break;
case BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_11:
/* sensor status of data available*/
v_data_u8 = read_buffer.parameter_11;
bhy_assign_sensor_status_bank(v_data_u8);
break;
case BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_12:
/* sensor status of data available*/
v_data_u8 = read_buffer.parameter_12;
bhy_assign_sensor_status_bank(v_data_u8);
break;
case BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_13:
/* sensor status of data available*/ v_data_u8 = read_buffer.parameter_13;
bhy_assign_sensor_status_bank(v_data_u8);
break;
case BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_14:
/* sensor status of data available*/
v_data_u8 = read_buffer.parameter_14;
bhy_assign_sensor_status_bank(v_data_u8);
break;
case BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_15:
/* sensor status of data available*/
v_data_u8 = read_buffer.parameter_15;
bhy_assign_sensor_status_bank(v_data_u8);
break;
case BHY_SENSOR_STATUS_BANK_SENSOR_TYPE_16:
/* sensor status of data available*/
v_data_u8 = read_buffer.parameter_16;
bhy_assign_sensor_status_bank(v_data_u8);
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
}
return com_rslt;
}
/*!
* @brief API used to get the host IRQ time
* stamp and current time stamp from
* system page-1 parameter 30
* Host IRQ time stamp bytes 0 to 3
* Current time stamp bytes 4 to 7
*
*
* @param v_time_stamp_selection_u8 :
* The value of Host IRQ or current time stamp selection
* time stamp | value
* --------------------------|---------------
* BHY_HOST_IRQ_TIMESTAMP | 0
* BHY_CURRENT_TIME_STAMP | 1
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
* @param v_time_stamp_u32 :
* The value of Host IRQ or current time stamp
*
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_get_time_stamp(
u8 v_time_stamp_selection_u8, u32 *v_time_stamp_u32)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u16 v_lsb_time_u16 = BHY_INIT_VALUE;
u16 v_msb_time_u16 = BHY_INIT_VALUE;
/* input as page 1 and parameter 30 for system page*/
com_rslt = bhy_read_parameter_bytes(
BHY_PAGE_1, BHY_PARAMETER_REQUEST_READ_PARAMETER_30);
if (BHY_SUCCESS == com_rslt) {
switch (v_time_stamp_selection_u8) {
case BHY_HOST_IRQ_TIMESTAMP:
/* host IRQ time stamp*/
/* IRQ time stamp lsb data*/
v_lsb_time_u16 = (u16)((read_buffer.parameter_2
<< BHY_SHIFT_BIT_POSITION_BY_08_BITS)
| (read_buffer.parameter_1));
/* IRQ time stamp msb data*/
v_msb_time_u16 = (u16)((read_buffer.parameter_4 << BHY_SHIFT_BIT_POSITION_BY_08_BITS)
| (read_buffer.parameter_3));
/* return IRQ time stamp*/
*v_time_stamp_u32 = (u32)(((u32)v_msb_time_u16
<< BHY_SHIFT_BIT_POSITION_BY_16_BITS)
| (v_lsb_time_u16));
break;
case BHY_CURRENT_TIME_STAMP:
/* current time stamp*/
/* current time stamp lsb data*/
v_lsb_time_u16 = (u16)((read_buffer.parameter_6
<< BHY_SHIFT_BIT_POSITION_BY_08_BITS)
| (read_buffer.parameter_5));
/* current time stamp msb data*/
v_msb_time_u16 = (u16)((read_buffer.parameter_8
<< BHY_SHIFT_BIT_POSITION_BY_08_BITS)
| (read_buffer.parameter_7));
/* return current time stamp*/
*v_time_stamp_u32 = (u32)(((u32)v_msb_time_u16
<< BHY_SHIFT_BIT_POSITION_BY_16_BITS)
| (v_lsb_time_u16));
break;
default:
com_rslt = BHY_OUT_OF_RANGE;
break;
}
}
return com_rslt;
}
/*!
* @brief API used to get the physical sensor status
* system page-1 parameter 31
* @note Accel sample rate byte 0 and 1
* @note Accel dynamic range byte 2 and 3
* @note Accel flags byte 4
* @note Gyro sample rate byte 5 and 6
* @note Gyro dynamic range byte 7 and 8
* @note Gyro flags byte 9
* @note Mag sample rate byte 10 and 11
* @note Mag dynamic range byte 12 and 13
* @note Mag flags byte 14
*
* @param accel_status : contains the accel physical status
* @param gyro_status : contains the gyro physical status
* @param mag_status : contains the mag physical status
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_get_physical_sensor_status(
struct accel_physical_status_t *accel_status,
struct gyro_physical_status_t *gyro_status,
struct mag_physical_status_t *mag_status)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
/* input as page 1 and parameter 31 for system page*/
com_rslt = bhy_read_parameter_bytes(
BHY_PAGE_1, BHY_PARAMETER_REQUEST_READ_PARAMETER_31);
/* accel physical status*/
/* accl sample rate*/
accel_status->accel_sample_rate = (u16)((read_buffer.parameter_2
<< BHY_SHIFT_BIT_POSITION_BY_08_BITS) | (read_buffer.parameter_1));
/* accel dynamic range*/
accel_status->accel_dynamic_range = (u16)((read_buffer.parameter_4
<< BHY_SHIFT_BIT_POSITION_BY_08_BITS) | (read_buffer.parameter_3)); /* accel flag*/
accel_status->accel_flag = read_buffer.parameter_5;
/* gyro physical status*/
/* gyro sample rate*/
gyro_status->gyro_sample_rate = (u16)((read_buffer.parameter_7
<< BHY_SHIFT_BIT_POSITION_BY_08_BITS) | (read_buffer.parameter_6));
/* accel dynamic range*/
gyro_status->gyro_dynamic_range = (u16)((read_buffer.parameter_9
<< BHY_SHIFT_BIT_POSITION_BY_08_BITS) | (read_buffer.parameter_8));
/* accel flag*/
gyro_status->gyro_flag = (u8)(read_buffer.parameter_10);
/* mag physical status*/
/* mag sample rate*/
mag_status->mag_sample_rate = (u16)((read_buffer.parameter_12
<< BHY_SHIFT_BIT_POSITION_BY_08_BITS) | (read_buffer.parameter_11));
/* mag dynamic range*/
mag_status->mag_dynamic_range = (u16)((read_buffer.parameter_14
<< BHY_SHIFT_BIT_POSITION_BY_08_BITS) | (read_buffer.parameter_13));
/* accel flag*/
mag_status->mag_flag = (u8)(read_buffer.parameter_15);
return com_rslt;
}
/*!
* @brief API used to get the non wakeup sensor information,
* Sensor page-3 parameter 1 to 31
*
* @param v_parameter_request_u8 :
* Value desired parameter to read non wakeup sensor information
* param_request | value | Virtual sensor
* ----------------------------------|-------|----------------
* BHY_PARAMETER_REQUEST_READ_PARAMETER_1 | 0x01 | Accelerometer
* BHY_PARAMETER_REQUEST_READ_PARAMETER_2 | 0x02 | Magnetometer
* BHY_PARAMETER_REQUEST_READ_PARAMETER_3 | 0x03 | Orientation
* BHY_PARAMETER_REQUEST_READ_PARAMETER_4 | 0x04 | Gyroscope
* BHY_PARAMETER_REQUEST_READ_PARAMETER_5 | 0x05 | Light
* BHY_PARAMETER_REQUEST_READ_PARAMETER_6 | 0x06 | Barometer
* BHY_PARAMETER_REQUEST_READ_PARAMETER_7 | 0x87 | Temperature
* BHY_PARAMETER_REQUEST_READ_PARAMETER_8 | 0x88 | Proximity
* BHY_PARAMETER_REQUEST_READ_PARAMETER_9 | 0x89 | Gravity
* BHY_PARAMETER_REQUEST_READ_PARAMETER_10 | 0x8A | Liner accel
* BHY_PARAMETER_REQUEST_READ_PARAMETER_11 | 0x8B | Rotation vector
* BHY_PARAMETER_REQUEST_READ_PARAMETER_12 | 0x8C | Humidity
* BHY_PARAMETER_REQUEST_READ_PARAMETER_13 | 0x8D | Ambient Temperature
* BHY_PARAMETER_REQUEST_READ_PARAMETER_14 | 0x8E | Uncalibrated Mag
* BHY_PARAMETER_REQUEST_READ_PARAMETER_15 | 0x8F | Game rotation Vector
* BHY_PARAMETER_REQUEST_READ_PARAMETER_16 | 0x90 | Uncalibrated Gyro
* BHY_PARAMETER_REQUEST_READ_PARAMETER_17 | 0x91 | Signification Motion
* BHY_PARAMETER_REQUEST_READ_PARAMETER_18 | 0x92 | Step detector
* BHY_PARAMETER_REQUEST_READ_PARAMETER_19 | 0x93 | Step Counter
* BHY_PARAMETER_REQUEST_READ_PARAMETER_20 | 0x94 | Geomagnetic
* BHY_PARAMETER_REQUEST_READ_PARAMETER_21 | 0x95 | Heart Rate
* BHY_PARAMETER_REQUEST_READ_PARAMETER_22 | 0x96 | Tilt Detector
* BHY_PARAMETER_REQUEST_READ_PARAMETER_23 | 0x97 | Wakeup Gesture
* BHY_PARAMETER_REQUEST_READ_PARAMETER_24 | 0x98 | Glance Gesture
* BHY_PARAMETER_REQUEST_READ_PARAMETER_25 | 0x99 | Pickup Gesture
* BHY_PARAMETER_REQUEST_READ_PARAMETER_31 | 0x9F | Activity
*
* @param sensor_information :
* holds the value of non wakeup sensor information
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_get_non_wakeup_sensor_information(u8 v_parameter_request_u8,
struct sensor_information_non_wakeup_t *sensor_information)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
/* input as page 3 and parameter request for sensor page*/
com_rslt = bhy_read_parameter_bytes(
BHY_PAGE_3, v_parameter_request_u8);
/* sensor type information */
sensor_information->non_wakeup_sensor_type
= (u8)(read_buffer.parameter_1);
/* driver id information */
sensor_information->non_wakeup_driver_id =
(u8)(read_buffer.parameter_2);
/* driver version information */
sensor_information->non_wakeup_driver_version =
(u8)(read_buffer.parameter_3);
/* power information */
sensor_information->non_wakeup_power =
(u8)(read_buffer.parameter_4);
/* maximum range information */
sensor_information->non_wakeup_max_range = (u16)
((read_buffer.parameter_6 << BHY_SHIFT_BIT_POSITION_BY_08_BITS)
| (read_buffer.parameter_5));
/* resolution information */
sensor_information->non_wakeup_resolution = (u16)
((read_buffer.parameter_8 << BHY_SHIFT_BIT_POSITION_BY_08_BITS)
| (read_buffer.parameter_7));
/* maximum rate information */
sensor_information->non_wakeup_max_rate = (u16)
((read_buffer.parameter_10 << BHY_SHIFT_BIT_POSITION_BY_08_BITS)
| (read_buffer.parameter_9));
/* fifo reserved information */
sensor_information->non_wakeup_fifo_reserved = (u16)
((read_buffer.parameter_12 << BHY_SHIFT_BIT_POSITION_BY_08_BITS)
| (read_buffer.parameter_11));
/* fifo max information */
sensor_information->non_wakeup_fifo_max = (u16)
((read_buffer.parameter_14 << BHY_SHIFT_BIT_POSITION_BY_08_BITS)
| (read_buffer.parameter_13));
/* event size information */
sensor_information->non_wakeup_event_size = read_buffer.parameter_15;
/* minimum rate information */
sensor_information->non_wakeup_min_rate = read_buffer.parameter_16;
return com_rslt;
}
/*!
* @brief API used to get the wakeup sensor information,
* Sensor page-3 parameter 32 to 63
*
* @param v_parameter_request_u8 :
* Value desired parameter to read non wakeup sensor information
* param_request | value | Virtual sensor
* ----------------------------------|-------|----------------
* BHY_PARAMETER_REQUEST_READ_PARAMETER_33 | 0xA1 | Accelerometer
* BHY_PARAMETER_REQUEST_READ_PARAMETER_34 | 0xA2 | Magnetometer
* BHY_PARAMETER_REQUEST_READ_PARAMETER_35 | 0xA3 | Orientation
* BHY_PARAMETER_REQUEST_READ_PARAMETER_36 | 0xA4 | Gyroscope
* BHY_PARAMETER_REQUEST_READ_PARAMETER_37 | 0xA5 | Light
* BHY_PARAMETER_REQUEST_READ_PARAMETER_38 | 0xA6 | Barometer
* BHY_PARAMETER_REQUEST_READ_PARAMETER_39 | 0xA7 | Temperature
* BHY_PARAMETER_REQUEST_READ_PARAMETER_40 | 0xA8 | Proximity
* BHY_PARAMETER_REQUEST_READ_PARAMETER_41 | 0xA9 | Gravity
* BHY_PARAMETER_REQUEST_READ_PARAMETER_42 | 0xAA | Liner accel
* BHY_PARAMETER_REQUEST_READ_PARAMETER_43 | 0xAB | Rotation vector
* BHY_PARAMETER_REQUEST_READ_PARAMETER_44 | 0xAC | Humidity
* BHY_PARAMETER_REQUEST_READ_PARAMETER_45 | 0xAD | Ambient Temperature
* BHY_PARAMETER_REQUEST_READ_PARAMETER_46 | 0xAE | Uncalibrated Mag
* BHY_PARAMETER_REQUEST_READ_PARAMETER_47 | 0xAF | Game rotation Vector * BHY_PARAMETER_REQUEST_READ_PARAMETER_48 | 0xB0 | Uncalibrated Gyro
* BHY_PARAMETER_REQUEST_READ_PARAMETER_49 | 0xB1 | Signification Motion
* BHY_PARAMETER_REQUEST_READ_PARAMETER_50 | 0xB2 | Step detector
* BHY_PARAMETER_REQUEST_READ_PARAMETER_51 | 0xB3 | Step Counter
* BHY_PARAMETER_REQUEST_READ_PARAMETER_52 | 0xB4 | Geomagnetic
* BHY_PARAMETER_REQUEST_READ_PARAMETER_53 | 0xB5 | Heart Rate
* BHY_PARAMETER_REQUEST_READ_PARAMETER_54 | 0xB6 | Tilt Detector
* BHY_PARAMETER_REQUEST_READ_PARAMETER_55 | 0xB7 | Wakeup Gesture
* BHY_PARAMETER_REQUEST_READ_PARAMETER_56 | 0xB8 | Glance Gesture
* BHY_PARAMETER_REQUEST_READ_PARAMETER_57 | 0xB9 | Pickup Gesture
* BHY_PARAMETER_REQUEST_READ_PARAMETER_63 | 0xBF | Activity
*
* @param sensor_information :
* holds the value of non wakeup sensor information
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_get_wakeup_sensor_information(
u8 v_parameter_request_u8,
struct sensor_information_wakeup_t *sensor_information)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
/* input as page 3 and parameter request for sensor page*/
com_rslt = bhy_read_parameter_bytes(
BHY_PAGE_3, v_parameter_request_u8);
/* sensor type information */
sensor_information->wakeup_sensor_type =
(u8)(read_buffer.parameter_1);
/* driver id information */
sensor_information->wakeup_driver_id =
(u8)(read_buffer.parameter_2);
/* driver version information */
sensor_information->wakeup_driver_version =
(u8)(read_buffer.parameter_3);
/* power information */
sensor_information->wakeup_power =
(u8)(read_buffer.parameter_4);
/* maximum range information */
sensor_information->wakeup_max_range = (u16)
((read_buffer.parameter_6 << BHY_SHIFT_BIT_POSITION_BY_08_BITS)
| (read_buffer.parameter_5));
/* resolution information */
sensor_information->wakeup_resolution = (u16)
((read_buffer.parameter_8 << BHY_SHIFT_BIT_POSITION_BY_08_BITS)
| (read_buffer.parameter_7));
/* maximum rate information */
sensor_information->wakeup_max_rate = (u16)
((read_buffer.parameter_10 << BHY_SHIFT_BIT_POSITION_BY_08_BITS)
| (read_buffer.parameter_9));
/* fifo reserved information */
sensor_information->wakeup_fifo_reserved = (u16)
((read_buffer.parameter_12 << BHY_SHIFT_BIT_POSITION_BY_08_BITS)
| (read_buffer.parameter_11));
/* fifo max information */
sensor_information->wakeup_fifo_max = (u16)
((read_buffer.parameter_14 << BHY_SHIFT_BIT_POSITION_BY_08_BITS)
| (read_buffer.parameter_13));
/* event size information */
sensor_information->wakeup_event_size = read_buffer.parameter_15;
/* minimum rate information */
sensor_information->wakeup_min_rate = read_buffer.parameter_16;
return com_rslt;}
/*!
* @brief API used to set the sensor non wakeup configuration
* Sensor page-3 parameter 65 to 89
*
* @param sensor_configuration : contains the non wakeup sensor configuration
*
* @param v_parameter_request_u8: value of selected parameter request
* param_request | value | Virtual sensor
* ----------------------------------|-------|----------------
* BHY_PARAMETER_REQUEST_READ_PARAMETER_65 | 0xC1 | Accelerometer
* BHY_PARAMETER_REQUEST_READ_PARAMETER_66 | 0xC2 | Magnetometer
* BHY_PARAMETER_REQUEST_READ_PARAMETER_67 | 0xC3 | Orientation
* BHY_PARAMETER_REQUEST_READ_PARAMETER_68 | 0xC4 | Gyroscope
* BHY_PARAMETER_REQUEST_READ_PARAMETER_69 | 0xC5 | Light
* BHY_PARAMETER_REQUEST_READ_PARAMETER_70 | 0xC6 | Barometer
* BHY_PARAMETER_REQUEST_READ_PARAMETER_71 | 0xC7 | Temperature
* BHY_PARAMETER_REQUEST_READ_PARAMETER_72 | 0xC8 | Proximity
* BHY_PARAMETER_REQUEST_READ_PARAMETER_73 | 0xC9 | Gravity
* BHY_PARAMETER_REQUEST_READ_PARAMETER_74 | 0xCA | Liner accel
* BHY_PARAMETER_REQUEST_READ_PARAMETER_75 | 0xCB | Rotation vector
* BHY_PARAMETER_REQUEST_READ_PARAMETER_76 | 0xCC | Humidity
* BHY_PARAMETER_REQUEST_READ_PARAMETER_77 | 0xCD | Ambient Temperature
* BHY_PARAMETER_REQUEST_READ_PARAMETER_78 | 0xCE | Uncalibrated Mag
* BHY_PARAMETER_REQUEST_READ_PARAMETER_79 | 0xCF | Game rotation Vector
* BHY_PARAMETER_REQUEST_READ_PARAMETER_80 | 0xD0 | Uncalibrated Gyro
* BHY_PARAMETER_REQUEST_READ_PARAMETER_81 | 0xD1 | Signification Motion
* BHY_PARAMETER_REQUEST_READ_PARAMETER_82 | 0xD2 | Step detector
* BHY_PARAMETER_REQUEST_READ_PARAMETER_83 | 0xD3 | Step Counter
* BHY_PARAMETER_REQUEST_READ_PARAMETER_84 | 0xD4 | Geomagnetic
* BHY_PARAMETER_REQUEST_READ_PARAMETER_85 | 0xD5 | Heart Rate
* BHY_PARAMETER_REQUEST_READ_PARAMETER_86 | 0xD6 | Tilt Detector
* BHY_PARAMETER_REQUEST_READ_PARAMETER_87 | 0xD7 | Wakeup Gesture
* BHY_PARAMETER_REQUEST_READ_PARAMETER_88 | 0xD8 | Glance Gesture
* BHY_PARAMETER_REQUEST_READ_PARAMETER_89 | 0xD9 | Pickup Gesture
* BHY_PARAMETER_REQUEST_READ_PARAMETER_95 | 0xDF | Activity
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_set_non_wakeup_sensor_configuration(
struct sensor_configuration_non_wakeup_t *sensor_configuration,
u8 v_parameter_request_u8)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
/* write sample rate*/
write_buffer.write_parameter_byte1 = (u8)(
sensor_configuration->non_wakeup_sample_rate & BHY_MASK_LSB_DATA);
write_buffer.write_parameter_byte2 = (u8)(
(sensor_configuration->non_wakeup_sample_rate
& BHY_MASK_MSB_DATA) >> BHY_SHIFT_BIT_POSITION_BY_08_BITS);
/* write maximum report latency*/
write_buffer.write_parameter_byte3 = (u8)(
sensor_configuration->non_wakeup_max_report_latency
& BHY_MASK_LSB_DATA);
write_buffer.write_parameter_byte4 = (u8)(
(sensor_configuration->non_wakeup_max_report_latency
& BHY_MASK_MSB_DATA) >> BHY_SHIFT_BIT_POSITION_BY_08_BITS);
/* write sensitivity*/
write_buffer.write_parameter_byte5 = (u8)(
sensor_configuration->non_wakeup_change_sensitivity
& BHY_MASK_LSB_DATA);
write_buffer.write_parameter_byte6 = (u8)(
(sensor_configuration->non_wakeup_change_sensitivity
& BHY_MASK_MSB_DATA) >> BHY_SHIFT_BIT_POSITION_BY_08_BITS); /* write dynamic range*/
write_buffer.write_parameter_byte7 = (u8)(
sensor_configuration->non_wakeup_dynamic_range & BHY_MASK_LSB_DATA);
write_buffer.write_parameter_byte8 = (u8)(
(sensor_configuration->non_wakeup_dynamic_range
& BHY_MASK_MSB_DATA) >> BHY_SHIFT_BIT_POSITION_BY_08_BITS);
/* load the parameter of non wakeup sensor configuration*/
com_rslt = bhy_write_parameter_bytes(
BHY_PAGE_3, v_parameter_request_u8);
return com_rslt;
}
/*!
* @brief API used to get the sensor non wakeup configuration
* Sensor page-3 parameter 65 to 89
*
* @param v_sample_rate_u16 :
* contains the non wakeup sample rate data
* @param v_max_report_latency_u16:
* contains the non wakeup max report latency
* @param v_change_sensitivity_u16:
* contains the non wakeup sensitivity
* @param v_dynamic_range_u16:
* contains the non wakeup dynamic range
*
* @param v_parameter_request_u8: value of selected parameter request
* param_request | value | Virtual sensor
* ----------------------------------|-------|----------------
* BHY_PARAMETER_REQUEST_READ_PARAMETER_65 | 0xC1 | Accelerometer
* BHY_PARAMETER_REQUEST_READ_PARAMETER_66 | 0xC2 | Magnetometer
* BHY_PARAMETER_REQUEST_READ_PARAMETER_67 | 0xC3 | Orientation
* BHY_PARAMETER_REQUEST_READ_PARAMETER_68 | 0xC4 | Gyroscope
* BHY_PARAMETER_REQUEST_READ_PARAMETER_69 | 0xC5 | Light
* BHY_PARAMETER_REQUEST_READ_PARAMETER_70 | 0xC6 | Barometer
* BHY_PARAMETER_REQUEST_READ_PARAMETER_71 | 0xC7 | Temperature
* BHY_PARAMETER_REQUEST_READ_PARAMETER_72 | 0xC8 | Proximity
* BHY_PARAMETER_REQUEST_READ_PARAMETER_73 | 0xC9 | Gravity
* BHY_PARAMETER_REQUEST_READ_PARAMETER_74 | 0xCA | Liner accel
* BHY_PARAMETER_REQUEST_READ_PARAMETER_75 | 0xCB | Rotation vector
* BHY_PARAMETER_REQUEST_READ_PARAMETER_76 | 0xCC | Humidity
* BHY_PARAMETER_REQUEST_READ_PARAMETER_77 | 0xCD | Ambient Temperature
* BHY_PARAMETER_REQUEST_READ_PARAMETER_78 | 0xCE | Uncalibrated Mag
* BHY_PARAMETER_REQUEST_READ_PARAMETER_79 | 0xCF | Game rotation Vector
* BHY_PARAMETER_REQUEST_READ_PARAMETER_80 | 0xD0 | Uncalibrated Gyro
* BHY_PARAMETER_REQUEST_READ_PARAMETER_81 | 0xD1 | Signification Motion
* BHY_PARAMETER_REQUEST_READ_PARAMETER_82 | 0xD2 | Step detector
* BHY_PARAMETER_REQUEST_READ_PARAMETER_83 | 0xD3 | Step Counter
* BHY_PARAMETER_REQUEST_READ_PARAMETER_84 | 0xD4 | Geomagnetic
* BHY_PARAMETER_REQUEST_READ_PARAMETER_85 | 0xD5 | Heart Rate
* BHY_PARAMETER_REQUEST_READ_PARAMETER_86 | 0xD6 | Tilt Detector
* BHY_PARAMETER_REQUEST_READ_PARAMETER_87 | 0xD7 | Wakeup Gesture
* BHY_PARAMETER_REQUEST_READ_PARAMETER_88 | 0xD8 | Glance Gesture
* BHY_PARAMETER_REQUEST_READ_PARAMETER_89 | 0xD9 | Pickup Gesture
* BHY_PARAMETER_REQUEST_READ_PARAMETER_95 | 0xDF | Activity
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_get_non_wakeup_sensor_configuration(
u8 v_parameter_request_u8,
u16 *v_sample_rate_u16, u16 *v_max_report_latency_u16,
u16 *v_change_sensitivity_u16, u16 *v_dynamic_range_u16)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
/* input as page 3 and parameter request for sensor page*/ com_rslt = bhy_read_parameter_bytes(
BHY_PAGE_3, v_parameter_request_u8);
/* sample rate information */
*v_sample_rate_u16 = (u16)
((read_buffer.parameter_2 << BHY_SHIFT_BIT_POSITION_BY_08_BITS)
| (read_buffer.parameter_1));
/* max report latency information */
*v_max_report_latency_u16 = (u16)
((read_buffer.parameter_4 << BHY_SHIFT_BIT_POSITION_BY_08_BITS)
| (read_buffer.parameter_3));
/* sensitivity information */
*v_change_sensitivity_u16 = (u16)
((read_buffer.parameter_6 << BHY_SHIFT_BIT_POSITION_BY_08_BITS)
| (read_buffer.parameter_5));
/* dynamic range information */
*v_dynamic_range_u16 = (u16)
((read_buffer.parameter_8 << BHY_SHIFT_BIT_POSITION_BY_08_BITS)
| (read_buffer.parameter_7));
return com_rslt;
}
/*!
* @brief API used to set the sensor wakeup configuration
* Sensor page-3 parameter 65 to 89
*
* @param sensor_configuration : contains the wakeup sensor configuration
*
* @param v_parameter_request_u8: value of selected parameter request
* param_request | value | Virtual sensor
* -----------------------------------|-------|----------------
* BHY_PARAMETER_REQUEST_READ_PARAMETER_97 | 0xE1 | Accelerometer
* BHY_PARAMETER_REQUEST_READ_PARAMETER_98 | 0xE2 | Magnetometer
* BHY_PARAMETER_REQUEST_READ_PARAMETER_99 | 0xE3 | Orientation
* BHY_PARAMETER_REQUEST_READ_PARAMETER_100 | 0xE4 | Gyroscope
* BHY_PARAMETER_REQUEST_READ_PARAMETER_101 | 0xE5 | Light
* BHY_PARAMETER_REQUEST_READ_PARAMETER_102 | 0xE6 | Barometer
* BHY_PARAMETER_REQUEST_READ_PARAMETER_103 | 0xE7 | Temperature
* BHY_PARAMETER_REQUEST_READ_PARAMETER_104 | 0xE8 | Proximity
* BHY_PARAMETER_REQUEST_READ_PARAMETER_105 | 0xE9 | Gravity
* BHY_PARAMETER_REQUEST_READ_PARAMETER_106 | 0xEA | Liner accel
* BHY_PARAMETER_REQUEST_READ_PARAMETER_107 | 0xEB | Rotation vector
* BHY_PARAMETER_REQUEST_READ_PARAMETER_108 | 0xEC | Humidity
* BHY_PARAMETER_REQUEST_READ_PARAMETER_109 | 0xED | Ambient Temperature
* BHY_PARAMETER_REQUEST_READ_PARAMETER_110 | 0xEE | Uncalibrated Mag
* BHY_PARAMETER_REQUEST_READ_PARAMETER_111 | 0xEF | Game rotation Vector
* BHY_PARAMETER_REQUEST_READ_PARAMETER_112 | 0xF0 | Uncalibrated Gyro
* BHY_PARAMETER_REQUEST_READ_PARAMETER_113 | 0xF1 | Signification Motion
* BHY_PARAMETER_REQUEST_READ_PARAMETER_114 | 0xF2 | Step detector
* BHY_PARAMETER_REQUEST_READ_PARAMETER_115 | 0xF3 | Step Counter
* BHY_PARAMETER_REQUEST_READ_PARAMETER_116 | 0xF4 | Geomagnetic
* BHY_PARAMETER_REQUEST_READ_PARAMETER_117 | 0xF5 | Heart Rate
* BHY_PARAMETER_REQUEST_READ_PARAMETER_118 | 0xF6 | Tilt Detector
* BHY_PARAMETER_REQUEST_READ_PARAMETER_119 | 0xF7 | Wakeup Gesture
* BHY_PARAMETER_REQUEST_READ_PARAMETER_120 | 0xF8 | Glance Gesture
* BHY_PARAMETER_REQUEST_READ_PARAMETER_121 | 0xF9 | Pickup Gesture
* BHY_PARAMETER_REQUEST_READ_PARAMETER_127 | 0xFF | Activity
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_set_wakeup_sensor_configuration(
struct sensor_configuration_wakeup_t *sensor_configuration,
u8 v_parameter_request_u8)
{
/* variable used for return the status of communication result*/ BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
/* write sample rate*/
write_buffer.write_parameter_byte1 = (u8)(
sensor_configuration->wakeup_sample_rate & BHY_MASK_LSB_DATA);
write_buffer.write_parameter_byte2 = (u8)(
(sensor_configuration->wakeup_sample_rate
& BHY_MASK_MSB_DATA) >> BHY_SHIFT_BIT_POSITION_BY_08_BITS);
/* write maximum report latency*/
write_buffer.write_parameter_byte3 = (u8)(
sensor_configuration->wakeup_max_report_latency & BHY_MASK_LSB_DATA);
write_buffer.write_parameter_byte4 = (u8)(
(sensor_configuration->wakeup_max_report_latency
& BHY_MASK_MSB_DATA) >> BHY_SHIFT_BIT_POSITION_BY_08_BITS);
/* write change sensitivity*/
write_buffer.write_parameter_byte5 = (u8)(
sensor_configuration->wakeup_change_sensitivity & BHY_MASK_LSB_DATA);
write_buffer.write_parameter_byte6 = (u8)(
(sensor_configuration->wakeup_change_sensitivity
& BHY_MASK_MSB_DATA) >> BHY_SHIFT_BIT_POSITION_BY_08_BITS);
/* write dynamic range*/
write_buffer.write_parameter_byte7 = (u8)(
sensor_configuration->wakeup_dynamic_range & BHY_MASK_LSB_DATA);
write_buffer.write_parameter_byte8 = (u8)(
(sensor_configuration->wakeup_dynamic_range
& BHY_MASK_MSB_DATA) >> BHY_SHIFT_BIT_POSITION_BY_08_BITS);
/* load the parameter of non wakeup sensor configuration*/
com_rslt = bhy_write_parameter_bytes(
BHY_PAGE_3, v_parameter_request_u8);
return com_rslt;
}
/*!
* @brief API used to get the sensor wakeup configuration
* Sensor page-3 parameter 65 to 89
*
* @param v_sample_rate_u16 : contains the wakeup sample rate data
* @param v_max_report_latency_u16: contains the wakeup max report latency
* @param v_change_sensitivity_u16: contains the wakeup sensitivity
* @param v_dynamic_range_u16: contains the wakeup dynamic range
*
* @param v_parameter_request_u8: value of selected parameter request
* param_request | value | Virtual sensor
* -----------------------------------|-------|----------------
* BHY_PARAMETER_REQUEST_READ_PARAMETER_97 | 0xE1 | Accelerometer
* BHY_PARAMETER_REQUEST_READ_PARAMETER_98 | 0xE2 | Magnetometer
* BHY_PARAMETER_REQUEST_READ_PARAMETER_99 | 0xE3 | Orientation
* BHY_PARAMETER_REQUEST_READ_PARAMETER_100 | 0xE4 | Gyroscope
* BHY_PARAMETER_REQUEST_READ_PARAMETER_101 | 0xE5 | Light
* BHY_PARAMETER_REQUEST_READ_PARAMETER_102 | 0xE6 | Barometer
* BHY_PARAMETER_REQUEST_READ_PARAMETER_103 | 0xE7 | Temperature
* BHY_PARAMETER_REQUEST_READ_PARAMETER_104 | 0xE8 | Proximity
* BHY_PARAMETER_REQUEST_READ_PARAMETER_105 | 0xE9 | Gravity
* BHY_PARAMETER_REQUEST_READ_PARAMETER_106 | 0xEA | Liner accel
* BHY_PARAMETER_REQUEST_READ_PARAMETER_107 | 0xEB | Rotation vector
* BHY_PARAMETER_REQUEST_READ_PARAMETER_108 | 0xEC | Humidity
* BHY_PARAMETER_REQUEST_READ_PARAMETER_109 | 0xED | Ambient Temperature
* BHY_PARAMETER_REQUEST_READ_PARAMETER_110 | 0xEE | Uncalibrated Mag
* BHY_PARAMETER_REQUEST_READ_PARAMETER_111 | 0xEF | Game rotation Vector
* BHY_PARAMETER_REQUEST_READ_PARAMETER_112 | 0xF0 | Uncalibrated Gyro
* BHY_PARAMETER_REQUEST_READ_PARAMETER_113 | 0xF1 | Signification Motion
* BHY_PARAMETER_REQUEST_READ_PARAMETER_114 | 0xF2 | Step detector
* BHY_PARAMETER_REQUEST_READ_PARAMETER_115 | 0xF3 | Step Counter
* BHY_PARAMETER_REQUEST_READ_PARAMETER_116 | 0xF4 | Geomagnetic
* BHY_PARAMETER_REQUEST_READ_PARAMETER_117 | 0xF5 | Heart Rate
* BHY_PARAMETER_REQUEST_READ_PARAMETER_118 | 0xF6 | Tilt Detector
* BHY_PARAMETER_REQUEST_READ_PARAMETER_119 | 0xF7 | Wakeup Gesture
* BHY_PARAMETER_REQUEST_READ_PARAMETER_120 | 0xF8 | Glance Gesture
* BHY_PARAMETER_REQUEST_READ_PARAMETER_121 | 0xF9 | Pickup Gesture
* BHY_PARAMETER_REQUEST_READ_PARAMETER_127 | 0xFF | Activity
* *
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_get_wakeup_sensor_configuration(
u8 v_parameter_request_u8,
u16 *v_sample_rate_u16, u16 *v_max_report_latency_u16,
u16 *v_change_sensitivity_u16, u16 *v_dynamic_range_u16)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
/* input as page 3 and parameter request for sensor page*/
com_rslt = bhy_read_parameter_bytes(
BHY_PAGE_3, v_parameter_request_u8);
/* sample rate information */
*v_sample_rate_u16 = (u16)
((read_buffer.parameter_2 << BHY_SHIFT_BIT_POSITION_BY_08_BITS)
| (read_buffer.parameter_1));
/* max report latency information */
*v_max_report_latency_u16 = (u16)
((read_buffer.parameter_4 << BHY_SHIFT_BIT_POSITION_BY_08_BITS)
| (read_buffer.parameter_3));
/* sensitivity information */
*v_change_sensitivity_u16 = (u16)
((read_buffer.parameter_6 << BHY_SHIFT_BIT_POSITION_BY_08_BITS)
| (read_buffer.parameter_5));
/* dynamic range information */
*v_dynamic_range_u16 = (u16)
((read_buffer.parameter_8 << BHY_SHIFT_BIT_POSITION_BY_08_BITS)
| (read_buffer.parameter_7));
return com_rslt;
}
/*!
* @brief API used to get the soft pass through
* Sensor page-15 parameter 0 to 7
*
* @param soft_pass_through :
* contains the value of soft pass through
*
* @param v_parameter_request_u8: value of selected parameter request
* parameter | value
* ------------------------------------|--------------------
* BHY_PARAMETER_REQUEST_WRITE_PARAMETER_1 | 0x01
* BHY_PARAMETER_REQUEST_WRITE_PARAMETER_2 | 0x02
* BHY_PARAMETER_REQUEST_WRITE_PARAMETER_3 | 0x03
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_get_soft_pass_through(
struct soft_pass_through_read_t *soft_pass_through,
u8 v_parameter_request_u8)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
/* input as page 3 and parameter request for sensor page*/
com_rslt = bhy_read_parameter_bytes(
BHY_PAGE_15, v_parameter_request_u8);
/* i2c slave address information */
soft_pass_through->i2c_slave_address = (u8)(read_buffer.parameter_1);
/* start register information */
soft_pass_through->start_register =
(u8)(read_buffer.parameter_2);
/* read length information */
soft_pass_through->read_length =
(u8)(read_buffer.parameter_3);
/* completion status information */
soft_pass_through->completion_status =
(u8)(read_buffer.parameter_4);
/* return register value 1 information */
soft_pass_through->reg_value_byte1 =
(u8)(read_buffer.parameter_5);
/* return register value 2 information */
soft_pass_through->reg_value_byte2 =
(u8)(read_buffer.parameter_6);
/* return register value 3 information */
soft_pass_through->reg_value_byte3 =
(u8)(read_buffer.parameter_7);
/* return register value 4 information */
soft_pass_through->reg_value_byte4 =
(u8)(read_buffer.parameter_8);
return com_rslt;
}
/*!
* @brief API used to set the soft pass through
* Sensor page-15 parameter 0 to 7
*
* @param soft_pass_through :
* contains the value of soft pass through
*
* @param v_parameter_request_u8: value of selected parameter request
* parameter | value
* ------------------------------------|--------------------
* BHY_PARAMETER_REQUEST_WRITE_PARAMETER_1 | 0x01
* BHY_PARAMETER_REQUEST_WRITE_PARAMETER_2 | 0x02
* BHY_PARAMETER_REQUEST_WRITE_PARAMETER_3 | 0x03
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_set_soft_pass_through(
struct soft_pass_through_write_t *soft_pass_through,
u8 v_parameter_request_u8)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
/* i2c slave address information */
write_buffer.write_parameter_byte1 =
soft_pass_through->i2c_slave_address;
/* start register information */
write_buffer.write_parameter_byte2 =
soft_pass_through->start_register;
/* write length information */
write_buffer.write_parameter_byte3 =
soft_pass_through->write_length;
/* completion status information */
write_buffer.write_parameter_byte4 =
soft_pass_through->completion_status;
/* return register value 1 information */
write_buffer.write_parameter_byte5 =
soft_pass_through->reg_value_byte1;
/* return register value 2 information */
write_buffer.write_parameter_byte6 =
soft_pass_through->reg_value_byte2; /* return register value 3 information */
write_buffer.write_parameter_byte7 =
soft_pass_through->reg_value_byte3;
/* return register value 4 information */
write_buffer.write_parameter_byte8 =
soft_pass_through->reg_value_byte4;
/* load the parameter of soft
pass through sensor configuration*/
com_rslt = bhy_write_parameter_bytes(
BHY_PAGE_15, v_parameter_request_u8);
return com_rslt;
}
/*!
* @brief API used to get the data from the parameter
* I2C page register from 0x3B to 0x4A
*
*
* @param v_page_select_u8 : This input value for set the desired page
* @param v_parameter_request_u8 :
* This input value for set the desired parameter
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_read_parameter_bytes(
u8 v_page_select_u8, u8 v_parameter_request_u8)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u8 v_parameter_ack_u8 = BHY_INIT_VALUE;
u8 init_array_data = BHY_INIT_VALUE;
u8 a_read_data_u8[BHY_READ_BUFFER_SIZE];
u8 v_parameter_ack_check_u8 = BHY_INIT_VALUE;
for (; init_array_data < BHY_READ_BUFFER_SIZE; init_array_data++)
a_read_data_u8[init_array_data] = BHY_INIT_VALUE;
/* select the page*/
com_rslt = bhy_set_parameter_page_select(v_page_select_u8);
/* select the parameter*/
com_rslt += bhy_set_parameter_request(v_parameter_request_u8);
/* read the values*/
for (v_parameter_ack_check_u8 = BHY_INIT_VALUE;
v_parameter_ack_check_u8 < BHY_PARAMETER_ACK_LENGTH;
v_parameter_ack_check_u8++) {
/* read acknowledgement*/
com_rslt = bhy_get_parameter_acknowledge(&v_parameter_ack_u8);
if (v_parameter_ack_u8 == v_parameter_request_u8) {
break;
} else if (v_parameter_ack_u8 == BHY_PARAMETER_ACK_CHECK) {
p_bhy->delay_msec(BHY_PARAMETER_ACK_DELAY);
com_rslt = BHY_ERROR;
} else {
/* device not ready yet */
p_bhy->delay_msec(1);
}
}
com_rslt =
p_bhy->BHY_BUS_READ_FUNC(p_bhy->device_addr,
BHY_I2C_REG_PARAMETER_READ_BUFFER_ZERO,
a_read_data_u8, BHY_READ_BUFFER_LENGTH);
read_buffer.parameter_1 =
a_read_data_u8[BHY_READ_BUFFER_1_REG];
read_buffer.parameter_2 =
a_read_data_u8[BHY_READ_BUFFER_2_REG];
read_buffer.parameter_3 =
a_read_data_u8[BHY_READ_BUFFER_3_REG]; read_buffer.parameter_4 =
a_read_data_u8[BHY_READ_BUFFER_4_REG];
read_buffer.parameter_5 =
a_read_data_u8[BHY_READ_BUFFER_5_REG];
read_buffer.parameter_6 =
a_read_data_u8[BHY_READ_BUFFER_6_REG];
read_buffer.parameter_7 =
a_read_data_u8[BHY_READ_BUFFER_7_REG];
read_buffer.parameter_8 =
a_read_data_u8[BHY_READ_BUFFER_8_REG];
read_buffer.parameter_9 =
a_read_data_u8[BHY_READ_BUFFER_9_REG];
read_buffer.parameter_10 =
a_read_data_u8[BHY_READ_BUFFER_10_REG];
read_buffer.parameter_11 =
a_read_data_u8[BHY_READ_BUFFER_11_REG];
read_buffer.parameter_12 =
a_read_data_u8[BHY_READ_BUFFER_12_REG];
read_buffer.parameter_13 =
a_read_data_u8[BHY_READ_BUFFER_13_REG];
read_buffer.parameter_14 =
a_read_data_u8[BHY_READ_BUFFER_14_REG];
read_buffer.parameter_15 =
a_read_data_u8[BHY_READ_BUFFER_15_REG];
read_buffer.parameter_16 =
a_read_data_u8[BHY_READ_BUFFER_16_REG];
return com_rslt;
}
/*!
* @brief API used to set the data from the parameter
* I2C page register from 0x5C to 0x63
*
*
* @param v_page_select_u8 : This input value for set the desired page
* @param v_parameter_request_u8 :
* This input value for set the desired parameter
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BHY_RETURN_FUNCTION_TYPE bhy_write_parameter_bytes(
u8 v_page_select_u8, u8 v_parameter_request_u8)
{
/* variable used for return the status of communication result*/
BHY_RETURN_FUNCTION_TYPE com_rslt = BHY_COMM_RES;
u8 v_parameter_ack_u8 = BHY_INIT_VALUE;
u8 v_parameter_ack_check_u8 = BHY_INIT_VALUE;
u8 v_write_parameter_byte_u8[BHY_WRITE_BUFFER_SIZE];
u8 init_array_data = BHY_INIT_VALUE;
for (; init_array_data < BHY_WRITE_BUFFER_SIZE; init_array_data++)
v_write_parameter_byte_u8[init_array_data] = BHY_INIT_VALUE;
/* check the p_bhy structure as NULL*/
if (p_bhy == BHY_NULL) {
return BHY_NULL;
} else {
/* Assign the load parameters*/
v_write_parameter_byte_u8[BHY_WRITE_BUFFER_1_REG]
= write_buffer.write_parameter_byte1;
v_write_parameter_byte_u8[BHY_WRITE_BUFFER_2_REG]
= write_buffer.write_parameter_byte2;
v_write_parameter_byte_u8[BHY_WRITE_BUFFER_3_REG]
= write_buffer.write_parameter_byte3;
v_write_parameter_byte_u8[BHY_WRITE_BUFFER_4_REG]
= write_buffer.write_parameter_byte4;
v_write_parameter_byte_u8[BHY_WRITE_BUFFER_5_REG] = write_buffer.write_parameter_byte5;
v_write_parameter_byte_u8[BHY_WRITE_BUFFER_6_REG]
= write_buffer.write_parameter_byte6;
v_write_parameter_byte_u8[BHY_WRITE_BUFFER_7_REG]
= write_buffer.write_parameter_byte7;
v_write_parameter_byte_u8[BHY_WRITE_BUFFER_8_REG]
= write_buffer.write_parameter_byte8;
/* write values to the load address*/
com_rslt = p_bhy->BHY_BUS_WRITE_FUNC
(p_bhy->device_addr,
BHY_I2C_REG_PARAMETER_WRITE_BUFFER_ZERO,
&v_write_parameter_byte_u8[BHY_WRITE_BUFFER_1_REG],
BHY_WRITE_BUFFER_SIZE);
/* select the page*/
com_rslt += bhy_set_parameter_page_select(v_page_select_u8);
/* select the parameter*/
com_rslt += bhy_set_parameter_request(v_parameter_request_u8);
for (v_parameter_ack_check_u8 = BHY_INIT_VALUE;
v_parameter_ack_check_u8 < BHY_PARAMETER_ACK_LENGTH;
v_parameter_ack_check_u8++) {
/* read the acknowledgement*/
com_rslt += bhy_get_parameter_acknowledge(
&v_parameter_ack_u8);
if (v_parameter_ack_u8 == v_parameter_request_u8) {
com_rslt += BHY_SUCCESS;
break;
} else if (v_parameter_ack_u8
== BHY_PARAMETER_ACK_CHECK) {
p_bhy->delay_msec(BHY_PARAMETER_ACK_DELAY);
com_rslt += BHY_ERROR;
} else {
/* device not ready yet */
p_bhy->delay_msec(1);
}
}
}
return com_rslt;
}