Momentum-Apps/bmi160.c

/**
 * Copyright (C) 2015 - 2016 Bosch Sensortec GmbH
 *
 * 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    bmi160.c
 * @date    24 Nov 2017
 * @version 3.7.4
 * @brief
 *
 */

/*!
 * @defgroup bmi160
 * @brief
 * @{*/

#include "bmi160.h"

/* Below look up table follows the enum bmi160_int_types.
 * Hence any change should match to the enum bmi160_int_types
 */
const uint8_t int_mask_lookup_table[13] = {
		BMI160_INT1_SLOPE_MASK,
		BMI160_INT1_SLOPE_MASK,
		BMI160_INT2_LOW_STEP_DETECT_MASK,
		BMI160_INT1_DOUBLE_TAP_MASK,
		BMI160_INT1_SINGLE_TAP_MASK,
		BMI160_INT1_ORIENT_MASK,
		BMI160_INT1_FLAT_MASK,
		BMI160_INT1_HIGH_G_MASK,
		BMI160_INT1_LOW_G_MASK,
		BMI160_INT1_NO_MOTION_MASK,
		BMI160_INT2_DATA_READY_MASK,
		BMI160_INT2_FIFO_FULL_MASK,
		BMI160_INT2_FIFO_WM_MASK
};

/*********************************************************************/
/* Static function declarations */

/*!
 * @brief This API configures the pins to fire the
 * interrupt signal when it occurs
 *
 * @param[in] int_config  : Structure instance of bmi160_int_settg.
 * @param[in] dev         : Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success / -ve value -> Error.
 */
static int8_t set_intr_pin_config(const struct bmi160_int_settg *int_config,  const struct bmi160_dev *dev);

/*!
 * @brief This API sets the any-motion interrupt of the sensor.
 * This interrupt occurs when accel values exceeds preset threshold
 * for a certain period of time.
 *
 * @param[in] int_config  : Structure instance of bmi160_int_settg.
 * @param[in] dev         : Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success / -ve value -> Error.
 */
static int8_t set_accel_any_motion_int(struct bmi160_int_settg *int_config, struct bmi160_dev *dev);

/*!
 * @brief This API sets tap interrupts.Interrupt is fired when
 * tap movements happen.
 *
 * @param[in] int_config  : Structure instance of bmi160_int_settg.
 * @param[in] dev         : Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success / -ve value -> Error.
 */
static int8_t set_accel_tap_int(struct bmi160_int_settg *int_config, const struct bmi160_dev *dev);

/*!
 * @brief This API sets the data ready interrupt for both accel and gyro.
 * This interrupt occurs when new accel and gyro data come.
 *
 * @param[in] int_config  : Structure instance of bmi160_int_settg.
 * @param[in] dev         : Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success / -ve value -> Error.
 */
static int8_t set_accel_gyro_data_ready_int(const struct bmi160_int_settg *int_config,
						const struct bmi160_dev *dev);

/*!
 * @brief This API sets the significant motion interrupt of the sensor.This
 * interrupt occurs when there is change in user location.
 *
 * @param[in] int_config  : Structure instance of bmi160_int_settg.
 * @param[in] dev         : Structure instance of bmi160_dev.

 *
 * @return Result of API execution status
 * @retval zero -> Success / -ve value -> Error.
 */
static int8_t set_accel_sig_motion_int(struct bmi160_int_settg *int_config, struct bmi160_dev *dev);

/*!
 * @brief This API sets the no motion/slow motion interrupt of the sensor.
 * Slow motion is similar to any motion interrupt.No motion interrupt
 * occurs when slope bet. two accel values falls below preset threshold
 * for preset duration.
 *
 * @param[in] int_config  : Structure instance of bmi160_int_settg.
 * @param[in] dev         : Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success / -ve value -> Error.
 */
static int8_t set_accel_no_motion_int(struct bmi160_int_settg *int_config, const struct bmi160_dev *dev);

/*!
 * @brief This API sets the step detection interrupt.This interrupt
 * occurs when the single step causes accel values to go above
 * preset threshold.
 *
 * @param[in] int_config  : Structure instance of bmi160_int_settg.
 * @param[in] dev         : Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success / -ve value -> Error.
 */
static int8_t set_accel_step_detect_int(struct bmi160_int_settg *int_config, const struct bmi160_dev *dev);

/*!
 * @brief This API sets the orientation interrupt of the sensor.This
 * interrupt occurs when there is orientation change in the sensor
 * with respect to gravitational field vector g.
 *
 * @param[in] int_config  : Structure instance of bmi160_int_settg.
 * @param[in] dev         : Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success / -ve value -> Error.
 */
static int8_t set_accel_orientation_int(struct bmi160_int_settg *int_config, const struct bmi160_dev *dev);

/*!
 * @brief This API sets the flat interrupt of the sensor.This interrupt
 * occurs in case of flat orientation
 *
 * @param[in] int_config  : Structure instance of bmi160_int_settg.
 * @param[in] dev         : Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success / -ve value -> Error.
 */
static int8_t set_accel_flat_detect_int(struct bmi160_int_settg *int_config, const struct bmi160_dev *dev);

/*!
 * @brief This API sets the low-g interrupt of the sensor.This interrupt
 * occurs during free-fall.
 *
 * @param[in] int_config  : Structure instance of bmi160_int_settg.
 * @param[in] dev         : Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success / -ve value -> Error.
 */
static int8_t set_accel_low_g_int(struct bmi160_int_settg *int_config, const struct bmi160_dev *dev);

/*!
 * @brief This API sets the high-g interrupt of the sensor.The interrupt
 * occurs if the absolute value of acceleration data of any enabled axis
 * exceeds the programmed threshold and the sign of the value does not
 * change for a preset duration.
 *
 * @param[in] int_config  : Structure instance of bmi160_int_settg.
 * @param[in] dev         : Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success / -ve value -> Error.
 */
static int8_t set_accel_high_g_int(struct bmi160_int_settg *int_config, const struct bmi160_dev *dev);

/*!
 * @brief This API sets the default configuration parameters of accel & gyro.
 * Also maintain the previous state of configurations.
 *
 * @param[in] dev         : Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success / -ve value -> Error.
 */
static void default_param_settg(struct bmi160_dev *dev);
/*!
 * @brief This API is used to validate the device structure pointer for
 * null conditions.
 *
 * @param[in] dev         : Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success / -ve value -> Error.
 */
static int8_t null_ptr_check(const struct bmi160_dev *dev);

/*!
 * @brief This API set the accel configuration.
 *
 * @param[in] dev         : Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success / -ve value -> Error.
 */
static int8_t set_accel_conf(struct bmi160_dev *dev);

 /*!
 * @brief This API check the accel configuration.
 *
 * @param[in] data        : Pointer to store the updated accel config.
 * @param[in] dev         : Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success / -ve value -> Error.
 */
static int8_t check_accel_config(uint8_t *data, const struct bmi160_dev *dev);

 /*!
  * @brief This API process the accel odr.
  *
  * @param[in] dev         : Structure instance of bmi160_dev.
  *
  * @return Result of API execution status
  * @retval zero -> Success / -ve value -> Error.
  */
static int8_t process_accel_odr(uint8_t *data, const struct bmi160_dev *dev);

 /*!
  * @brief This API process the accel bandwidth.
  *
  * @param[in] dev         : Structure instance of bmi160_dev.
  *
  * @return Result of API execution status
  * @retval zero -> Success / -ve value -> Error.
  */
static int8_t process_accel_bw(uint8_t *data, const struct bmi160_dev *dev);

 /*!
  * @brief This API process the accel range.
  *
  * @param[in] dev         : Structure instance of bmi160_dev.
  *
  * @return Result of API execution status
  * @retval zero -> Success / -ve value -> Error.
  */
static int8_t process_accel_range(uint8_t *data, const struct bmi160_dev *dev);

/*!
 * @brief This API checks the invalid settings for ODR & Bw for Accel and Gyro.
 * @param[in] dev         : Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success / -ve value -> Error.
 */
static int8_t check_invalid_settg(const struct bmi160_dev *dev);

 /*!
 * @brief This API set the gyro configuration.
 *
 * @param[in] dev         : Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success / -ve value -> Error.
 */
static int8_t set_gyro_conf(struct bmi160_dev *dev);

 /*!
 * @brief This API check the gyro configuration.
 *
 * @param[in] data        : Pointer to store the updated gyro config.
 * @param[in] dev         : Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success / -ve value -> Error.
 */
static int8_t check_gyro_config(uint8_t *data, const struct bmi160_dev *dev);

 /*!
  * @brief This API process the gyro odr.
  *
  * @param[in] dev         : Structure instance of bmi160_dev.
  *
  * @return Result of API execution status
  * @retval zero -> Success / -ve value -> Error.
  */
static int8_t process_gyro_odr(uint8_t *data, const struct bmi160_dev *dev);

 /*!
  * @brief This API process the gyro bandwidth.
  *
  * @param[in] dev         : Structure instance of bmi160_dev.
  *
  * @return Result of API execution status
  * @retval zero -> Success / -ve value -> Error.
  */
static int8_t process_gyro_bw(uint8_t *data, const struct bmi160_dev *dev);

 /*!
  * @brief This API process the gyro range.
  *
  * @param[in] dev         : Structure instance of bmi160_dev.
  *
  * @return Result of API execution status
  * @retval zero -> Success / -ve value -> Error.
  */
static int8_t process_gyro_range(uint8_t *data, const struct bmi160_dev *dev);

/*!
 * @brief This API sets the accel power mode.
 *
 * @param[in] dev         : Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success / -ve value -> Error.
 */
static int8_t set_accel_pwr(struct bmi160_dev *dev);

/*!
 * @brief This API process the undersampling setting of Accel.
 *
 * @param[in] dev         : Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success / -ve value -> Error.
 */
static int8_t process_under_sampling(uint8_t *data,
	const struct bmi160_dev *dev);

/*!
 * @brief This API sets the gyro power mode.
 *
 * @param[in] dev         : Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success / -ve value -> Error.
 */
static int8_t set_gyro_pwr(struct bmi160_dev *dev);

/*!
 * @brief This API reads accel data along with sensor time if time is requested
 * by user. Kindly refer the user guide(README.md) for more info.
 *
 * @param[in] len    : len to read no of bytes
 * @param[out] accel    : Structure pointer to store accel data
 * @param[in] dev       : Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t get_accel_data(uint8_t len, struct bmi160_sensor_data *accel, const struct bmi160_dev *dev);

/*!
 * @brief This API reads accel data along with sensor time if time is requested
 * by user. Kindly refer the user guide(README.md) for more info.
 *
 * @param[in] len    : len to read no of bytes
 * @param[out] gyro    : Structure pointer to store accel data
 * @param[in] dev       : Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t get_gyro_data(uint8_t len, struct bmi160_sensor_data *gyro, const struct bmi160_dev *dev);

/*!
 * @brief This API reads accel and gyro data along with sensor time
 * if time is requested by user.
 * Kindly refer the user guide(README.md) for more info.
 *
 * @param[in] len    : len to read no of bytes
 * @param[out] accel    : Structure pointer to store accel data
 * @param[out] gyro    : Structure pointer to store accel data
 * @param[in] dev       : Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t get_accel_gyro_data(uint8_t len, struct bmi160_sensor_data *accel, struct bmi160_sensor_data *gyro,
					const struct bmi160_dev *dev);

/*!
 * @brief This API enables the any-motion interrupt for accel.
 *
 * @param[in] any_motion_int_cfg   : Structure instance of
 *				     bmi160_acc_any_mot_int_cfg.
 * @param[in] dev		   : Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t enable_accel_any_motion_int(const struct bmi160_acc_any_mot_int_cfg *any_motion_int_cfg,
						struct bmi160_dev *dev);

/*!
 * @brief This API disable the sig-motion interrupt.
 *
 * @param[in] dev	: Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t disable_sig_motion_int(const struct bmi160_dev *dev);

/*!
 * @brief This API configure the source of data(filter & pre-filter)
 * for any-motion interrupt.
 *
 * @param[in] any_motion_int_cfg  : Structure instance of
 *				    bmi160_acc_any_mot_int_cfg.
 * @param[in] dev		  : Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t config_any_motion_src(const struct bmi160_acc_any_mot_int_cfg *any_motion_int_cfg,
					const struct bmi160_dev *dev);

/*!
 * @brief This API configure the duration and threshold of
 * any-motion interrupt.
 *
 * @param[in] any_motion_int_cfg  : Structure instance of
 *				    bmi160_acc_any_mot_int_cfg.
 * @param[in] dev		  : Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t config_any_dur_threshold(const struct bmi160_acc_any_mot_int_cfg *any_motion_int_cfg,
					const struct bmi160_dev *dev);

/*!
 * @brief This API configure necessary setting of any-motion interrupt.
 *
 * @param[in] int_config	   : Structure instance of bmi160_int_settg.
 * @param[in] any_motion_int_cfg   : Structure instance of
 *				     bmi160_acc_any_mot_int_cfg.
 * @param[in] dev		   : Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t config_any_motion_int_settg(const struct bmi160_int_settg *int_config,
					const struct bmi160_acc_any_mot_int_cfg *any_motion_int_cfg,
					const struct bmi160_dev *dev);

/*!
 * @brief This API enable the data ready interrupt.
 *
 * @param[in] dev		: Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t enable_data_ready_int(const struct bmi160_dev *dev);

/*!
 * @brief This API enables the no motion/slow motion interrupt.
 *
 * @param[in] no_mot_int_cfg	: Structure instance of
 *				  bmi160_acc_no_motion_int_cfg.
 * @param[in] dev		: Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t enable_no_motion_int(const struct bmi160_acc_no_motion_int_cfg *no_mot_int_cfg,
					const struct bmi160_dev *dev);

/*!
 * @brief This API configure the interrupt PIN setting for
 * no motion/slow motion interrupt.
 *
 * @param[in] int_config	: structure instance of bmi160_int_settg.
 * @param[in] no_mot_int_cfg	: Structure instance of
 *				  bmi160_acc_no_motion_int_cfg.
 * @param[in] dev		: Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t config_no_motion_int_settg(const struct bmi160_int_settg *int_config,
					const struct bmi160_acc_no_motion_int_cfg *no_mot_int_cfg,
					const struct bmi160_dev *dev);

/*!
 * @brief This API configure the source of interrupt for no motion.
 *
 * @param[in] no_mot_int_cfg	: Structure instance of
 *				  bmi160_acc_no_motion_int_cfg.
 * @param[in] dev		: Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t config_no_motion_data_src(const struct bmi160_acc_no_motion_int_cfg *no_mot_int_cfg,
					const struct bmi160_dev *dev);

/*!
 * @brief This API configure the duration and threshold of
 * no motion/slow motion interrupt along with selection of no/slow motion.
 *
 * @param[in] no_mot_int_cfg	: Structure instance of
 *				  bmi160_acc_no_motion_int_cfg.
 * @param[in] dev		: Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t config_no_motion_dur_thr(const struct bmi160_acc_no_motion_int_cfg *no_mot_int_cfg,
					const struct bmi160_dev *dev);

/*!
 * @brief This API enables the sig-motion motion interrupt.
 *
 * @param[in] sig_mot_int_cfg	: Structure instance of
 *				  bmi160_acc_sig_mot_int_cfg.
 * @param[in] dev		: Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t enable_sig_motion_int(const struct bmi160_acc_sig_mot_int_cfg *sig_mot_int_cfg, struct bmi160_dev *dev);

/*!
 * @brief This API configure the interrupt PIN setting for
 * significant motion interrupt.
 *
 * @param[in] int_config	: Structure instance of bmi160_int_settg.
 * @param[in] sig_mot_int_cfg	: Structure instance of
 *				  bmi160_acc_sig_mot_int_cfg.
 * @param[in] dev		: Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t config_sig_motion_int_settg(const struct bmi160_int_settg *int_config,
					const struct bmi160_acc_sig_mot_int_cfg *sig_mot_int_cfg,
					const struct bmi160_dev *dev);

/*!
 * @brief This API configure the source of data(filter & pre-filter)
 * for sig motion interrupt.
 *
 * @param[in] sig_mot_int_cfg	: Structure instance of
 *				  bmi160_acc_sig_mot_int_cfg.
 * @param[in] dev		: Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t config_sig_motion_data_src(const struct bmi160_acc_sig_mot_int_cfg *sig_mot_int_cfg,
					const struct bmi160_dev *dev);

/*!
 * @brief This API configure the threshold, skip and proof time of
 * sig motion interrupt.
 *
 * @param[in] sig_mot_int_cfg	: Structure instance of
 *				  bmi160_acc_sig_mot_int_cfg.
 * @param[in] dev		: Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t config_sig_dur_threshold(const struct bmi160_acc_sig_mot_int_cfg *sig_mot_int_cfg,
					const struct bmi160_dev *dev);

/*!
 * @brief This API enables the step detector interrupt.
 *
 * @param[in] step_detect_int_cfg	: Structure instance of
 *					  bmi160_acc_step_detect_int_cfg.
 * @param[in] dev			: Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t enable_step_detect_int(const struct bmi160_acc_step_detect_int_cfg *step_detect_int_cfg,
					const struct bmi160_dev *dev);

/*!
 * @brief This API configure the step detector parameter.
 *
 * @param[in] step_detect_int_cfg	: Structure instance of
 *					  bmi160_acc_step_detect_int_cfg.
 * @param[in] dev			: Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t config_step_detect(const struct bmi160_acc_step_detect_int_cfg *step_detect_int_cfg,
					const struct bmi160_dev *dev);

/*!
 * @brief This API enables the single/double tap interrupt.
 *
 * @param[in] int_config	: Structure instance of bmi160_int_settg.
 * @param[in] dev		: Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t enable_tap_int(const struct bmi160_int_settg *int_config,
				const struct bmi160_acc_tap_int_cfg *tap_int_cfg,
				const struct bmi160_dev *dev);

/*!
 * @brief This API configure the interrupt PIN setting for
 * tap interrupt.
 *
 * @param[in] int_config	: Structure instance of bmi160_int_settg.
 * @param[in] tap_int_cfg	: Structure instance of bmi160_acc_tap_int_cfg.
 * @param[in] dev		: Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t config_tap_int_settg(const struct bmi160_int_settg *int_config,
					const struct bmi160_acc_tap_int_cfg *tap_int_cfg,
					const struct bmi160_dev *dev);

/*!
 * @brief This API configure the source of data(filter & pre-filter)
 * for tap interrupt.
 *
 * @param[in] tap_int_cfg	: Structure instance of bmi160_acc_tap_int_cfg.
 * @param[in] dev		: Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t config_tap_data_src(const struct bmi160_acc_tap_int_cfg *tap_int_cfg, const struct bmi160_dev *dev);

/*!
 * @brief This API configure the  parameters of tap interrupt.
 * Threshold, quite, shock, and duration.
 *
 * @param[in] int_config	: Structure instance of bmi160_int_settg.
 * @param[in] tap_int_cfg	: Structure instance of bmi160_acc_tap_int_cfg.
 * @param[in] dev		: structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t config_tap_param(const struct bmi160_int_settg *int_config,
				const struct bmi160_acc_tap_int_cfg *tap_int_cfg,
				const struct bmi160_dev *dev);

/*!
 * @brief This API enable the external mode configuration.
 *
 * @param[in] dev	: Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t config_sec_if(const struct bmi160_dev *dev);

/*!
 * @brief This API configure the ODR of the auxiliary sensor.
 *
 * @param[in] dev	: Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t config_aux_odr(const struct bmi160_dev *dev);

/*!
 * @brief This API maps the actual burst read length set by user.
 *
 * @param[in] len	: Pointer to store the read length.
 * @param[in] dev	: Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t map_read_len(uint16_t *len, const struct bmi160_dev *dev);

/*!
 * @brief This API configure the settings of auxiliary sensor.
 *
 * @param[in] dev	: Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t config_aux_settg(const struct bmi160_dev *dev);

/*!
 * @brief This API extract the read data from auxiliary sensor.
 *
 * @param[in] map_len	  : burst read value.
 * @param[in] reg_addr	  : Address of register to read.
 * @param[in] aux_data	  : Pointer to store the read data.
 * @param[in] len	  : length to read the data.
 * @param[in] dev         : Structure instance of bmi160_dev.
 * @note : Refer user guide for detailed info.
 *
 * @return Result of API execution status
 * @retval zero -> Success / -ve value -> Error
 */
static int8_t extract_aux_read(uint16_t map_len, uint8_t reg_addr, uint8_t *aux_data, uint16_t len,
				const struct bmi160_dev *dev);

/*!
 * @brief This API enables the orient interrupt.
 *
 * @param[in] orient_int_cfg : Structure instance of bmi160_acc_orient_int_cfg.
 * @param[in] dev	     : Structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t enable_orient_int(const struct bmi160_acc_orient_int_cfg *orient_int_cfg, const struct bmi160_dev *dev);

/*!
 * @brief This API configure the necessary setting of orientation interrupt.
 *
 * @param[in] orient_int_cfg : Structure instance of bmi160_acc_orient_int_cfg.
 * @param[in] dev	     : structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t config_orient_int_settg(const struct bmi160_acc_orient_int_cfg *orient_int_cfg,
					const struct bmi160_dev *dev);

/*!
 * @brief This API enables the flat interrupt.
 *
 * @param[in] flat_int	: Structure instance of bmi160_acc_flat_detect_int_cfg.
 * @param[in] dev		: structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t enable_flat_int(const struct bmi160_acc_flat_detect_int_cfg *flat_int, const struct bmi160_dev *dev);

/*!
 * @brief This API configure the necessary setting of flat interrupt.
 *
 * @param[in] flat_int	: Structure instance of bmi160_acc_flat_detect_int_cfg.
 * @param[in] dev	: structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t config_flat_int_settg(const struct bmi160_acc_flat_detect_int_cfg *flat_int,
					const struct bmi160_dev *dev);

/*!
 * @brief This API enables the Low-g interrupt.
 *
 * @param[in] low_g_int	: Structure instance of bmi160_acc_low_g_int_cfg.
 * @param[in] dev	: structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t enable_low_g_int(const struct bmi160_acc_low_g_int_cfg *low_g_int, const struct bmi160_dev *dev);

/*!
 * @brief This API configure the source of data(filter & pre-filter) for low-g interrupt.
 *
 * @param[in] low_g_int	: Structure instance of bmi160_acc_low_g_int_cfg.
 * @param[in] dev	: structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t config_low_g_data_src(const struct bmi160_acc_low_g_int_cfg *low_g_int, const struct bmi160_dev *dev);

/*!
 * @brief This API configure the necessary setting of low-g interrupt.
 *
 * @param[in] low_g_int	: Structure instance of bmi160_acc_low_g_int_cfg.
 * @param[in] dev	: structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t config_low_g_int_settg(const struct bmi160_acc_low_g_int_cfg *low_g_int,  const struct bmi160_dev *dev);

/*!
 * @brief This API enables the high-g interrupt.
 *
 * @param[in] high_g_int_cfg : Structure instance of bmi160_acc_high_g_int_cfg.
 * @param[in] dev	     : structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t enable_high_g_int(const struct bmi160_acc_high_g_int_cfg *high_g_int_cfg, const struct bmi160_dev *dev);

/*!
 * @brief This API configure the source of data(filter & pre-filter)
 * for high-g interrupt.
 *
 * @param[in] high_g_int_cfg : Structure instance of bmi160_acc_high_g_int_cfg.
 * @param[in] dev	     : structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t config_high_g_data_src(const struct bmi160_acc_high_g_int_cfg *high_g_int_cfg,
					const struct bmi160_dev *dev);

/*!
 * @brief This API configure the necessary setting of high-g interrupt.
 *
 * @param[in] high_g_int_cfg : Structure instance of bmi160_acc_high_g_int_cfg.
 * @param[in] dev	     : structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t config_high_g_int_settg(const struct bmi160_acc_high_g_int_cfg *high_g_int_cfg,
					const struct bmi160_dev *dev);

/*!
 * @brief This API configure the behavioural setting of interrupt pin.
 *
 * @param[in] int_config	: Structure instance of bmi160_int_settg.
 * @param[in] dev		: structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t config_int_out_ctrl(const struct bmi160_int_settg *int_config,  const struct bmi160_dev *dev);

/*!
 * @brief This API configure the mode(input enable, latch or non-latch) of interrupt pin.
 *
 * @param[in] int_config	: Structure instance of bmi160_int_settg.
 * @param[in] dev		: structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t config_int_latch(const struct bmi160_int_settg *int_config,  const struct bmi160_dev *dev);

/*!
 * @brief This API performs the self test for accelerometer of BMI160
 *
 * @param[in] dev	: structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t perform_accel_self_test(struct bmi160_dev *dev);

/*!
 * @brief This API enables to perform the accel self test by setting proper
 * configurations to facilitate accel self test
 *
 * @param[in] dev	: structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t enable_accel_self_test(struct bmi160_dev *dev);

/*!
 * @brief This API performs accel self test with positive excitation
 *
 * @param[in] accel_pos	: Structure pointer to store accel data
 *                        for positive excitation
 * @param[in] dev	: structure instance of bmi160_dev
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t accel_self_test_positive_excitation(struct bmi160_sensor_data *accel_pos, const struct bmi160_dev *dev);

/*!
 * @brief This API performs accel self test with negative excitation
 *
 * @param[in] accel_neg	: Structure pointer to store accel data
 *                        for negative excitation
 * @param[in] dev	: structure instance of bmi160_dev
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t accel_self_test_negative_excitation(struct bmi160_sensor_data *accel_neg, const struct bmi160_dev *dev);

/*!
 * @brief This API validates the accel self test results
 *
 * @param[in] accel_pos	: Structure pointer to store accel data
 *                        for positive excitation
 * @param[in] accel_neg	: Structure pointer to store accel data
 *                        for negative excitation
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error / +ve value -> Self test fail
 */
static int8_t validate_accel_self_test(const struct bmi160_sensor_data *accel_pos,
					const struct bmi160_sensor_data *accel_neg);

/*!
 * @brief This API performs the self test for gyroscope of BMI160
 *
 * @param[in] dev	: structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t perform_gyro_self_test(const struct bmi160_dev *dev);

/*!
 * @brief This API enables the self test bit to trigger self test for gyro
 *
 * @param[in] dev	: structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t enable_gyro_self_test(const struct bmi160_dev *dev);

/*!
 * @brief This API validates the self test results of gyro
 *
 * @param[in] dev	: structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t validate_gyro_self_test(const struct bmi160_dev *dev);

/*!
 *  @brief This API sets FIFO full interrupt of the sensor.This interrupt
 *  occurs when the FIFO is full and the next full data sample would cause
 *  a FIFO overflow, which may delete the old samples.
 *
 * @param[in] int_config	: Structure instance of bmi160_int_settg.
 * @param[in] dev		: structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t set_fifo_full_int(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev);

/*!
 * @brief This enable the FIFO full interrupt engine.
 *
 * @param[in] int_config	: Structure instance of bmi160_int_settg.
 * @param[in] dev		: structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t enable_fifo_full_int(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev);

/*!
 *  @brief This API sets FIFO watermark interrupt of the sensor.The FIFO
 *  watermark interrupt is fired, when the FIFO fill level is above a fifo
 *  watermark.
 *
 * @param[in] int_config	: Structure instance of bmi160_int_settg.
 * @param[in] dev		: structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t set_fifo_watermark_int(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev);

/*!
 * @brief This enable the FIFO watermark interrupt engine.
 *
 * @param[in] int_config	: Structure instance of bmi160_int_settg.
 * @param[in] dev		: structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static int8_t enable_fifo_wtm_int(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev);

/*!
 * @brief This API is used to reset the FIFO related configurations
 *  in the fifo_frame structure.
 *
 * @param[in] dev		: structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static void reset_fifo_data_structure(const struct bmi160_dev *dev);

/*!
 *  @brief This API is used to read number of bytes filled
 *  currently in FIFO buffer.
 *
 *  @param[in] bytes_to_read  : Number of bytes available in FIFO at the
 *                              instant which is obtained from FIFO counter.
 *  @param[in] dev            : Structure instance of bmi160_dev.
 *
 *  @return Result of API execution status
 *  @retval zero -> Success / -ve value -> Error.
 *  @retval Any non zero value -> Fail
 *
 */
static int8_t get_fifo_byte_counter(uint16_t *bytes_to_read, struct bmi160_dev const *dev);

/*!
 *  @brief This API is used to compute the number of bytes of accel FIFO data
 *  which is to be parsed in header-less mode
 *
 *  @param[out] data_index        : The start index for parsing data
 *  @param[out] data_read_length  : Number of bytes to be parsed
 *  @param[in]  acc_frame_count   : Number of accelerometer frames to be read
 *  @param[in]  dev               : Structure instance of bmi160_dev.
 *
 */
static void get_accel_len_to_parse(uint16_t *data_index, uint16_t *data_read_length, const uint8_t *acc_frame_count,
					const struct bmi160_dev *dev);

/*!
 *  @brief This API is used to parse the accelerometer data from the
 *  FIFO data in both header mode and header-less mode.
 *  It updates the idx value which is used to store the index of
 *  the current data byte which is parsed.
 *
 *  @param[in,out] acc		: structure instance of sensor data
 *  @param[in,out] idx		: Index value of number of bytes parsed
 *  @param[in,out] acc_idx	: Index value of accelerometer data
 *                                (x,y,z axes) frames parsed
 *  @param[in] frame_info       : It consists of either fifo_data_enable
 *                                parameter in header-less mode or
 *                                frame header data in header mode
 *  @param[in] dev		: structure instance of bmi160_dev.
 *
 *  @return Result of API execution status
 *  @retval zero -> Success  / -ve value -> Error
 */
static void unpack_accel_frame(struct bmi160_sensor_data *acc, uint16_t *idx, uint8_t *acc_idx, uint8_t frame_info,
				const struct bmi160_dev *dev);

/*!
 *  @brief This API is used to parse the accelerometer data from the
 *  FIFO data and store it in the instance of the structure bmi160_sensor_data.
 *
 * @param[in,out] accel_data	    : structure instance of sensor data
 * @param[in,out] data_start_index  : Index value of number of bytes parsed
 * @param[in] dev		    : structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static void unpack_accel_data(struct bmi160_sensor_data *accel_data, uint16_t data_start_index,
				const struct bmi160_dev *dev);

/*!
 *  @brief This API is used to parse the accelerometer data from the
 *  FIFO data in header mode.
 *
 *  @param[in,out] accel_data	 : Structure instance of sensor data
 *  @param[in,out] accel_length  : Number of accelerometer frames
 *  @param[in] dev               : Structure instance of bmi160_dev.
 *
 *  @return Result of API execution status
 *  @retval zero -> Success  / -ve value -> Error
 */
static void extract_accel_header_mode(struct bmi160_sensor_data *accel_data, uint8_t *accel_length,
					const struct bmi160_dev *dev);

/*!
 *  @brief This API computes the number of bytes of gyro FIFO data
 *  which is to be parsed in header-less mode
 *
 *  @param[out] data_index       : The start index for parsing data
 *  @param[out] data_read_length : No of bytes to be parsed from FIFO buffer
 *  @param[in] gyro_frame_count  : Number of Gyro data frames to be read
 *  @param[in] dev               : Structure instance of bmi160_dev.
 */
static void get_gyro_len_to_parse(uint16_t *data_index, uint16_t *data_read_length, const uint8_t *gyro_frame_count,
					const struct bmi160_dev *dev);

/*!
 *  @brief This API is used to parse the gyroscope's data from the
 *  FIFO data in both header mode and header-less mode.
 *  It updates the idx value which is used to store the index of
 *  the current data byte which is parsed.
 *
 *  @param[in,out] gyro		: structure instance of sensor data
 *  @param[in,out] idx		: Index value of number of bytes parsed
 *  @param[in,out] gyro_idx	: Index value of gyro data
 *                                (x,y,z axes) frames parsed
 *  @param[in] frame_info       : It consists of either fifo_data_enable
 *                                parameter in header-less mode or
 *                                frame header data in header mode
 *  @param[in] dev		: structure instance of bmi160_dev.
 *
 *  @return Result of API execution status
 *  @retval zero -> Success  / -ve value -> Error
 */
static void unpack_gyro_frame(struct bmi160_sensor_data *gyro, uint16_t *idx, uint8_t *gyro_idx, uint8_t frame_info,
				const struct bmi160_dev *dev);


/*!
 *  @brief This API is used to parse the gyro data from the
 *  FIFO data and store it in the instance of the structure bmi160_sensor_data.
 *
 *  @param[in,out] gyro_data         : structure instance of sensor data
 *  @param[in,out] data_start_index  : Index value of number of bytes parsed
 *  @param[in] dev		     : structure instance of bmi160_dev.
 *
 *  @return Result of API execution status
 *  @retval zero -> Success  / -ve value -> Error
 */
static void unpack_gyro_data(struct bmi160_sensor_data *gyro_data, uint16_t data_start_index,
				const struct bmi160_dev *dev);

/*!
 *  @brief This API is used to parse the gyro data from the
 *  FIFO data in header mode.
 *
 *  @param[in,out] gyro_data	 : Structure instance of sensor data
 *  @param[in,out] gyro_length   : Number of gyro frames
 *  @param[in] dev               : Structure instance of bmi160_dev.
 *
 *  @return Result of API execution status
 *  @retval zero -> Success  / -ve value -> Error
 */
static void extract_gyro_header_mode(struct bmi160_sensor_data *gyro_data, uint8_t *gyro_length,
					const struct bmi160_dev *dev);

/*!
 *  @brief This API computes the number of bytes of aux FIFO data
 *  which is to be parsed in header-less mode
 *
 *  @param[out] data_index       : The start index for parsing data
 *  @param[out] data_read_length : No of bytes to be parsed from FIFO buffer
 *  @param[in] aux_frame_count   : Number of Aux data frames to be read
 *  @param[in] dev               : Structure instance of bmi160_dev.
 */
static void get_aux_len_to_parse(uint16_t *data_index, uint16_t *data_read_length, const uint8_t *aux_frame_count,
					const struct bmi160_dev *dev);

/*!
 *  @brief This API is used to parse the aux's data from the
 *  FIFO data in both header mode and header-less mode.
 *  It updates the idx value which is used to store the index of
 *  the current data byte which is parsed
 *
 *  @param[in,out] aux_data	: structure instance of sensor data
 *  @param[in,out] idx		: Index value of number of bytes parsed
 *  @param[in,out] aux_index	: Index value of gyro data
 *                                (x,y,z axes) frames parsed
 *  @param[in] frame_info       : It consists of either fifo_data_enable
 *                                parameter in header-less mode or
 *                                frame header data in header mode
 *  @param[in] dev		: structure instance of bmi160_dev.
 *
 *  @return Result of API execution status
 *  @retval zero -> Success  / -ve value -> Error
 */
static void unpack_aux_frame(struct bmi160_aux_data *aux_data, uint16_t *idx, uint8_t *aux_index, uint8_t frame_info,
				const struct bmi160_dev *dev);

/*!
 *  @brief This API is used to parse the aux data from the
 *  FIFO data and store it in the instance of the structure bmi160_aux_data.
 *
 * @param[in,out] aux_data	    : structure instance of sensor data
 * @param[in,out] data_start_index  : Index value of number of bytes parsed
 * @param[in] dev		    : structure instance of bmi160_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success  / -ve value -> Error
 */
static void unpack_aux_data(struct bmi160_aux_data *aux_data, uint16_t data_start_index,
				const struct bmi160_dev *dev);

/*!
 *  @brief This API is used to parse the aux data from the
 *  FIFO data in header mode.
 *
 *  @param[in,out] aux_data     : Structure instance of sensor data
 *  @param[in,out] aux_length   : Number of aux frames
 *  @param[in] dev              : Structure instance of bmi160_dev.
 *
 *  @return Result of API execution status
 *  @retval zero -> Success  / -ve value -> Error
 */
static void extract_aux_header_mode(struct bmi160_aux_data *aux_data, uint8_t *aux_length,
					const struct bmi160_dev *dev);

/*!
 *  @brief This API checks the presence of non-valid frames in the read fifo data.
 *
 *  @param[in,out] data_index	 : The index of the current data to
 *                                be parsed from fifo data
 *  @param[in] dev               : Structure instance of bmi160_dev.
 *
 *  @return Result of API execution status
 *  @retval zero -> Success  / -ve value -> Error
 */
static void check_frame_validity(uint16_t *data_index, const struct bmi160_dev *dev);

/*!
 *  @brief This API is used to move the data index ahead of the
 *  current_frame_length parameter when unnecessary FIFO data appears while
 *  extracting the user specified data.
 *
 *  @param[in,out] data_index       : Index of the FIFO data which
 *                                  is to be moved ahead of the
 *                                  current_frame_length
 *  @param[in] current_frame_length : Number of bytes in a particular frame
 *  @param[in] dev                  : Structure instance of bmi160_dev.
 *
 *  @return Result of API execution status
 *  @retval zero -> Success  / -ve value -> Error
 */
static void move_next_frame(uint16_t *data_index, uint8_t current_frame_length, const struct bmi160_dev *dev);

/*!
 *  @brief This API is used to parse and store the sensor time from the
 *  FIFO data in the structure instance dev.
 *
 *  @param[in,out] data_index : Index of the FIFO data which
 *                              has the sensor time.
 *  @param[in] dev            : Structure instance of bmi160_dev.
 *
 *  @return Result of API execution status
 *  @retval zero -> Success  / -ve value -> Error
 */
static void unpack_sensortime_frame(uint16_t *data_index, const struct bmi160_dev *dev);

/*!
 *  @brief This API is used to parse and store the skipped_frame_count from
 *  the FIFO data in the structure instance dev.
 *
 *  @param[in,out] data_index   : Index of the FIFO data which
 *                                    has the skipped frame count.
 *  @param[in] dev              : Structure instance of bmi160_dev.
 *
 *  @return Result of API execution status
 *  @retval zero -> Success  / -ve value -> Error
 */
static void unpack_skipped_frame(uint16_t *data_index, const struct bmi160_dev *dev);

/*!
 *  @brief This API is used to get the FOC status from the sensor
 *
 *  @param[in,out] foc_status   : Result of FOC status.
 *  @param[in] dev              : Structure instance of bmi160_dev.
 *
 *  @return Result of API execution status
 *  @retval zero -> Success  / -ve value -> Error
 */
static int8_t get_foc_status(uint8_t *foc_status, struct bmi160_dev const *dev);

/*!
 *  @brief This API is used to configure the offset enable bits in the sensor
 *
 *  @param[in,out] foc_conf   : Structure instance of bmi160_foc_conf which
 *                                   has the FOC and offset configurations
 *  @param[in] dev            : Structure instance of bmi160_dev.
 *
 *  @return Result of API execution status
 *  @retval zero -> Success  / -ve value -> Error
 */
static int8_t configure_offset_enable(const struct bmi160_foc_conf *foc_conf, struct bmi160_dev const *dev);

/*!
 *  @brief This API is used to trigger the FOC in the sensor
 *
 *  @param[in,out] offset     : Structure instance of bmi160_offsets which
 *                              reads and stores the offset values after FOC
 *  @param[in] dev            : Structure instance of bmi160_dev.
 *
 *  @return Result of API execution status
 *  @retval zero -> Success  / -ve value -> Error
 */
static int8_t trigger_foc(struct bmi160_offsets *offset, struct bmi160_dev const *dev);

/*!
 *  @brief This API is used to map/unmap the Dataready(Accel & Gyro), FIFO full
 *  and FIFO watermark interrupt
 *
 *  @param[in] int_config     : Structure instance of bmi160_int_settg which
 *                              stores the interrupt type and interrupt channel
 *				configurations to map/unmap the interrupt pins
 *  @param[in] dev            : Structure instance of bmi160_dev.
 *
 *  @return Result of API execution status
 *  @retval zero -> Success  / -ve value -> Error
 */
static int8_t map_hardware_interrupt(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev);

/*!
 *  @brief This API is used to map/unmap the Any/Sig motion, Step det/Low-g,
 *  Double tap, Single tap, Orientation, Flat, High-G, Nomotion interrupt pins.
 *
 *  @param[in] int_config     : Structure instance of bmi160_int_settg which
 *                              stores the interrupt type and interrupt channel
 *				configurations to map/unmap the interrupt pins
 *  @param[in] dev            : Structure instance of bmi160_dev.
 *
 *  @return Result of API execution status
 *  @retval zero -> Success  / -ve value -> Error
 */
static int8_t map_feature_interrupt(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev);
/*********************** User function definitions ****************************/
/*!
 * @brief This API reads the data from the given register address
 * of sensor.
 */
int8_t bmi160_get_regs(uint8_t reg_addr, uint8_t *data, uint16_t len, const struct bmi160_dev *dev)
{
	int8_t rslt = BMI160_OK;
	/* Null-pointer check */
	if ((dev == NULL) || (dev->read == NULL)) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		/* Configuring reg_addr for SPI Interface */
		if (dev->interface == BMI160_SPI_INTF)
			reg_addr = (reg_addr | BMI160_SPI_RD_MASK);

		rslt = dev->read(dev->id, reg_addr, data, len);
		/* Kindly refer section 3.2.4 of data-sheet*/
		dev->delay_ms(1);
		if (rslt != BMI160_OK)
			rslt = BMI160_E_COM_FAIL;
	}

	return rslt;
}

/*!
 * @brief This API writes the given data to the register address
 * of sensor.
 */
int8_t bmi160_set_regs(uint8_t reg_addr, uint8_t *data, uint16_t len, const struct bmi160_dev *dev)
{
	int8_t rslt = BMI160_OK;
	uint8_t count = 0;
	/* Null-pointer check */
	if ((dev == NULL) || (dev->write == NULL)) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		/* Configuring reg_addr for SPI Interface */
		if (dev->interface == BMI160_SPI_INTF)
			reg_addr = (reg_addr & BMI160_SPI_WR_MASK);

		if ((dev->prev_accel_cfg.power == BMI160_ACCEL_NORMAL_MODE) ||
			(dev->prev_gyro_cfg.power == BMI160_GYRO_NORMAL_MODE)) {

			rslt = dev->write(dev->id, reg_addr, data, len);
			/* Kindly refer section 3.2.4 of data-sheet*/
			dev->delay_ms(1);
		} else {
			/*Burst write is not allowed in
			suspend & low power mode */
			for (; count < len; count++) {
				rslt = dev->write(dev->id, reg_addr, &data[count], 1);
				reg_addr++;
				/* Kindly refer section 3.2.4 of data-sheet*/
				dev->delay_ms(1);
			}
		}

		if (rslt != BMI160_OK)
			rslt = BMI160_E_COM_FAIL;
	}

	return rslt;
}

/*!
 *  @brief This API is the entry point for sensor.It performs
 *  the selection of I2C/SPI read mechanism according to the
 *  selected interface and reads the chip-id of bmi160 sensor.
 */
int8_t bmi160_init(struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data;
	uint8_t try = 3;

	/* Assign chip id as zero */
	dev->chip_id = 0;

	/* Null-pointer check */
	rslt = null_ptr_check(dev);

	/* Dummy read of 0x7F register to enable SPI Interface
	 if SPI is used */
	if ((rslt == BMI160_OK) && (dev->interface == BMI160_SPI_INTF))
		rslt = bmi160_get_regs(BMI160_SPI_COMM_TEST_ADDR, &data, 1, dev);

	if (rslt == BMI160_OK) {

		while ((try--) && (dev->chip_id != BMI160_CHIP_ID)) {
			/* Read chip_id */
			rslt = bmi160_get_regs(BMI160_CHIP_ID_ADDR, &dev->chip_id, 1, dev);
		}

		if ((rslt == BMI160_OK) && (dev->chip_id == BMI160_CHIP_ID)) {
			dev->any_sig_sel = BMI160_BOTH_ANY_SIG_MOTION_DISABLED;
			/* Soft reset */
			rslt = bmi160_soft_reset(dev);
		} else {
			rslt = BMI160_E_DEV_NOT_FOUND;
		}
	}

	return rslt;
}

/*!
 * @brief This API resets and restarts the device.
 * All register values are overwritten with default parameters.
 */
int8_t bmi160_soft_reset(struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data = BMI160_SOFT_RESET_CMD;

	/* Null-pointer check */
	if ((dev == NULL) || (dev->delay_ms == NULL)) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		 /* Reset the device */
		rslt = bmi160_set_regs(BMI160_COMMAND_REG_ADDR, &data, 1, dev);
		dev->delay_ms(BMI160_SOFT_RESET_DELAY_MS);
		if ((rslt == BMI160_OK) && (dev->interface == BMI160_SPI_INTF)) {
			/* Dummy read of 0x7F register to enable SPI Interface
			if SPI is used */
			rslt = bmi160_get_regs(BMI160_SPI_COMM_TEST_ADDR, &data, 1, dev);
		}
		if (rslt == BMI160_OK) {
			/* Update the default parameters */
			default_param_settg(dev);
		}
	}

	return rslt;
}

/*!
 * @brief This API configures the power mode, range and bandwidth
 * of sensor.
 */
int8_t bmi160_set_sens_conf(struct bmi160_dev *dev)
{
	int8_t rslt = BMI160_OK;

	/* Null-pointer check */
	if ((dev == NULL) || (dev->delay_ms == NULL)) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		rslt = set_accel_conf(dev);
		if (rslt == BMI160_OK) {
			rslt = set_gyro_conf(dev);
			if (rslt == BMI160_OK) {
				/* write power mode for accel and gyro */
				rslt = bmi160_set_power_mode(dev);
				if (rslt == BMI160_OK)
					rslt = check_invalid_settg(dev);
			}
		}
	}

	return rslt;
}

/*!
 * @brief This API sets the power mode of the sensor.
 */
int8_t bmi160_set_power_mode(struct bmi160_dev *dev)
{
	int8_t rslt = 0;

	/* Null-pointer check */
	if ((dev == NULL) || (dev->delay_ms == NULL)) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		rslt = set_accel_pwr(dev);
		if (rslt == BMI160_OK)
			rslt = set_gyro_pwr(dev);
	}

	return rslt;

}

/*!
 * @brief This API reads sensor data, stores it in
 * the bmi160_sensor_data structure pointer passed by the user.
 */
int8_t bmi160_get_sensor_data(uint8_t select_sensor, struct bmi160_sensor_data *accel, struct bmi160_sensor_data *gyro,
				const struct bmi160_dev *dev)
{
	int8_t rslt = BMI160_OK;
	uint8_t time_sel;
	uint8_t sen_sel;
	uint8_t len = 0;

	/*Extract the sensor  and time select information*/
	sen_sel = select_sensor & BMI160_SEN_SEL_MASK;
	time_sel = ((sen_sel & BMI160_TIME_SEL) >> 2);
	sen_sel = sen_sel & (BMI160_ACCEL_SEL | BMI160_GYRO_SEL);
	if (time_sel == 1)
		len = 3;

	/* Null-pointer check */
	if (dev != NULL) {
		switch (sen_sel) {
		case BMI160_ACCEL_ONLY:
			/* Null-pointer check */
			if (accel == NULL)
				rslt = BMI160_E_NULL_PTR;
			else
				rslt = get_accel_data(len, accel, dev);
			break;
		case BMI160_GYRO_ONLY:
			/* Null-pointer check */
			if (gyro == NULL)
				rslt = BMI160_E_NULL_PTR;
			else
				rslt = get_gyro_data(len, gyro, dev);
			break;
		case BMI160_BOTH_ACCEL_AND_GYRO:
			/* Null-pointer check */
			if ((gyro == NULL) || (accel == NULL))
				rslt = BMI160_E_NULL_PTR;
			else
				rslt = get_accel_gyro_data(len, accel, gyro, dev);
			break;
		default:
			rslt = BMI160_E_INVALID_INPUT;
			break;
		}
	} else {
		rslt = BMI160_E_NULL_PTR;
	}

	return rslt;

}

/*!
 * @brief This API configures the necessary interrupt based on
 *  the user settings in the bmi160_int_settg structure instance.
 */
int8_t bmi160_set_int_config(struct bmi160_int_settg *int_config, struct bmi160_dev *dev)
{
	int8_t rslt = BMI160_OK;

	switch (int_config->int_type) {
	case BMI160_ACC_ANY_MOTION_INT:
		/*Any-motion  interrupt*/
		rslt = set_accel_any_motion_int(int_config, dev);
		break;
	case BMI160_ACC_SIG_MOTION_INT:
		/* Significant motion interrupt */
		rslt = set_accel_sig_motion_int(int_config, dev);
		break;
	case BMI160_ACC_SLOW_NO_MOTION_INT:
		/* Slow or no motion interrupt */
		rslt = set_accel_no_motion_int(int_config, dev);
		break;
	case BMI160_ACC_DOUBLE_TAP_INT:
	case BMI160_ACC_SINGLE_TAP_INT:
		 /* Double tap and single tap Interrupt */
		rslt = set_accel_tap_int(int_config, dev);
		break;
	case BMI160_STEP_DETECT_INT:
		/* Step detector interrupt */
		rslt = set_accel_step_detect_int(int_config, dev);
		break;
	case BMI160_ACC_ORIENT_INT:
		/* Orientation interrupt */
		rslt = set_accel_orientation_int(int_config, dev);
		break;
	case BMI160_ACC_FLAT_INT:
		/* Flat detection interrupt */
		rslt = set_accel_flat_detect_int(int_config, dev);
		break;
	case BMI160_ACC_LOW_G_INT:
		 /* Low-g interrupt */
		rslt = set_accel_low_g_int(int_config, dev);
		break;
	case BMI160_ACC_HIGH_G_INT:
		/* High-g interrupt */
		rslt = set_accel_high_g_int(int_config, dev);
		break;
	case BMI160_ACC_GYRO_DATA_RDY_INT:
		/* Data ready interrupt */
		rslt = set_accel_gyro_data_ready_int(int_config, dev);
		break;
	case BMI160_ACC_GYRO_FIFO_FULL_INT:
		 /* Fifo full interrupt */
		rslt = set_fifo_full_int(int_config, dev);
		break;
	case BMI160_ACC_GYRO_FIFO_WATERMARK_INT:
		 /* Fifo water-mark interrupt */
		rslt = set_fifo_watermark_int(int_config, dev);
		break;
	case BMI160_FIFO_TAG_INT_PIN:
		/* Fifo tagging feature support */
		/* Configure Interrupt pins */
		rslt = set_intr_pin_config(int_config, dev);
		break;
	default:
		break;
	}
	return rslt;
}

/*!
 * @brief This API enables or disable the step counter feature.
 * 1 - enable step counter (0 - disable)
 */
int8_t bmi160_set_step_counter(uint8_t step_cnt_enable, const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data = 0;

	/* Null-pointer check */
	rslt = null_ptr_check(dev);

	if (rslt != BMI160_OK) {
		rslt = BMI160_E_NULL_PTR;
	} else {

		rslt = bmi160_get_regs(BMI160_INT_STEP_CONFIG_1_ADDR, &data, 1, dev);
		if (rslt == BMI160_OK) {
			if (step_cnt_enable == BMI160_ENABLE)
				data |= (uint8_t)(step_cnt_enable << 3);
			else
				data &= ~BMI160_STEP_COUNT_EN_BIT_MASK;
			rslt = bmi160_set_regs(BMI160_INT_STEP_CONFIG_1_ADDR, &data, 1, dev);
		}
	}

	return rslt;
}

/*!
 * @brief This API reads the step counter value.
 */
int8_t bmi160_read_step_counter(uint16_t *step_val, const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data[2] = {0, 0};
	uint16_t msb = 0;
	uint8_t lsb = 0;

	/* Null-pointer check */
	rslt = null_ptr_check(dev);

	if (rslt != BMI160_OK) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		rslt = bmi160_get_regs(BMI160_INT_STEP_CNT_0_ADDR, data, 2, dev);
		if (rslt == BMI160_OK) {
			lsb = data[0];
			msb = data[1] << 8;
			*step_val = msb | lsb;
		}
	}

	return rslt;
}

/*!
 * @brief This API reads the mention no of byte of data from the given
 * register address of auxiliary sensor.
 */
int8_t bmi160_aux_read(uint8_t reg_addr, uint8_t *aux_data, uint16_t len, const struct bmi160_dev *dev)
{
	int8_t rslt = BMI160_OK;
	uint16_t map_len = 0;

	/* Null-pointer check */
	if ((dev == NULL) || (dev->read == NULL)) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		if (dev->aux_cfg.aux_sensor_enable == BMI160_ENABLE) {
			rslt = map_read_len(&map_len, dev);
			if (rslt == BMI160_OK)
				rslt = extract_aux_read(map_len, reg_addr, aux_data, len, dev);
		} else {
			rslt = BMI160_E_INVALID_INPUT;
		}
	}

	return rslt;
}

/*!
 * @brief This API writes the mention no of byte of data to the given
 * register address of auxiliary sensor.
 */
int8_t bmi160_aux_write(uint8_t reg_addr, uint8_t *aux_data, uint16_t len, const struct bmi160_dev *dev)
{
	int8_t rslt = BMI160_OK;
	uint8_t count = 0;

	/* Null-pointer check */
	if ((dev == NULL) || (dev->write == NULL)) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		for (; count < len; count++) {
			/* set data to write */
			rslt = bmi160_set_regs(BMI160_AUX_IF_4_ADDR, aux_data, 1, dev);
			dev->delay_ms(BMI160_AUX_COM_DELAY);
			if (rslt == BMI160_OK) {
				/* set address to write */
				rslt = bmi160_set_regs(BMI160_AUX_IF_3_ADDR, &reg_addr, 1, dev);
				dev->delay_ms(BMI160_AUX_COM_DELAY);
				if (rslt == BMI160_OK && (count < len - 1)) {
					aux_data++;
					reg_addr++;
				}
			}
		}
	}

	return rslt;
}

/*!
 * @brief This API initialize the auxiliary sensor
 * in order to access it.
 */
int8_t bmi160_aux_init(const struct bmi160_dev *dev)
{
	int8_t rslt;

	/* Null-pointer check */
	rslt = null_ptr_check(dev);

	if (rslt != BMI160_OK) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		if (dev->aux_cfg.aux_sensor_enable == BMI160_ENABLE) {
			/* Configures the auxiliary sensor interface settings */
			rslt = config_aux_settg(dev);
		} else {
			rslt = BMI160_E_INVALID_INPUT;
		}
	}

	return rslt;
}

/*!
 * @brief This API is used to setup the auxiliary sensor of bmi160 in auto mode
 * Thus enabling the auto update of 8 bytes of data from auxiliary sensor
 * to BMI160 register address 0x04 to 0x0B
 */
int8_t bmi160_set_aux_auto_mode(uint8_t *data_addr, struct bmi160_dev *dev)
{
	int8_t rslt;
	/* Null-pointer check */
	rslt = null_ptr_check(dev);

	if (rslt != BMI160_OK) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		if (dev->aux_cfg.aux_sensor_enable == BMI160_ENABLE) {
			/* Write the aux. address to read in 0x4D of BMI160*/
			rslt = bmi160_set_regs(BMI160_AUX_IF_2_ADDR, data_addr, 1, dev);
			dev->delay_ms(BMI160_AUX_COM_DELAY);
			if (rslt == BMI160_OK) {
				/* Configure the polling ODR for
				auxiliary sensor */
					rslt = config_aux_odr(dev);

				if (rslt == BMI160_OK) {
					/* Disable the aux. manual mode, i.e aux.
					 * sensor is in auto-mode (data-mode) */
					dev->aux_cfg.manual_enable = BMI160_DISABLE;
					rslt = bmi160_config_aux_mode(dev);

					/*  Auxiliary sensor data is obtained
					 * in auto mode from this point */
				}
			}
		} else {
			rslt = BMI160_E_INVALID_INPUT;
		}
	}

	return rslt;
}

/*!
 * @brief This API configures the 0x4C register and settings like
 * Auxiliary sensor manual enable/ disable and aux burst read length.
 */
int8_t bmi160_config_aux_mode(const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t aux_if[2] = {(uint8_t)(dev->aux_cfg.aux_i2c_addr * 2), 0};

	rslt = bmi160_get_regs(BMI160_AUX_IF_1_ADDR, &aux_if[1], 1, dev);
	if (rslt == BMI160_OK) {
		/* update the Auxiliary interface to manual/auto mode */
		aux_if[1] = BMI160_SET_BITS(aux_if[1], BMI160_MANUAL_MODE_EN, dev->aux_cfg.manual_enable);
		/* update the burst read length defined by user */
		aux_if[1] = BMI160_SET_BITS_POS_0(aux_if[1], BMI160_AUX_READ_BURST, dev->aux_cfg.aux_rd_burst_len);
		/* Set the secondary interface address and manual mode
		 * along with burst read length */
		rslt = bmi160_set_regs(BMI160_AUX_IF_0_ADDR, &aux_if[0], 2, dev);
		dev->delay_ms(BMI160_AUX_COM_DELAY);
	}

	return rslt;
}

/*!
 * @brief This API is used to read the raw uncompensated auxiliary sensor
 * data of 8 bytes from BMI160 register address 0x04 to 0x0B
 */
int8_t bmi160_read_aux_data_auto_mode(uint8_t *aux_data, const struct bmi160_dev *dev)
{
	int8_t rslt;

	/* Null-pointer check */
	rslt = null_ptr_check(dev);

	if (rslt != BMI160_OK) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		if ((dev->aux_cfg.aux_sensor_enable == BMI160_ENABLE) &&
			(dev->aux_cfg.manual_enable == BMI160_DISABLE)) {
			/* Read the aux. sensor's raw data */
			rslt = bmi160_get_regs(BMI160_AUX_DATA_ADDR, aux_data, 8, dev);
		} else {
			rslt = BMI160_E_INVALID_INPUT;
		}
	}

	return rslt;
}

/*!
 * @brief This is used to perform self test of accel/gyro of the BMI160 sensor
 */
int8_t bmi160_perform_self_test(uint8_t select_sensor, struct bmi160_dev *dev)
{
	int8_t rslt;
	int8_t self_test_rslt = 0;

	/* Null-pointer check */
	rslt = null_ptr_check(dev);

	if (rslt != BMI160_OK) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		/* Proceed if null check is fine */
		switch (select_sensor) {
		case BMI160_ACCEL_ONLY:
			rslt = perform_accel_self_test(dev);
			break;

		case BMI160_GYRO_ONLY:
			/* Set the power mode as normal mode */
			dev->gyro_cfg.power = BMI160_GYRO_NORMAL_MODE;
			rslt = bmi160_set_power_mode(dev);
			/* Perform gyro self test */
			if (rslt == BMI160_OK) {
				/* Perform gyro self test */
				rslt = perform_gyro_self_test(dev);
			}
			break;

		default:
			rslt = BMI160_E_INVALID_INPUT;
			break;
		}

		/* Check to ensure bus error does not occur */
		if (rslt >= BMI160_OK) {
			/* Store the status of self test result */
			self_test_rslt = rslt;
			/* Perform soft reset */
			rslt = bmi160_soft_reset(dev);
		}
		/* Check to ensure bus operations are success */
		if (rslt == BMI160_OK) {
			/* Restore self_test_rslt as return value */
			rslt = self_test_rslt;
		}

	}

	return rslt;
}



/*!
 * @brief This API reads the data from fifo buffer.
 */
int8_t bmi160_get_fifo_data(struct bmi160_dev const *dev)
{
	int8_t rslt = 0;
	uint16_t bytes_to_read = 0;
	uint16_t user_fifo_len = 0;
	uint8_t addr = BMI160_FIFO_DATA_ADDR;

	/* check the bmi160 structure as NULL*/
	if ((dev == NULL) || (dev->fifo->data == NULL)) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		reset_fifo_data_structure(dev);
		/* get current FIFO fill-level*/
		rslt = get_fifo_byte_counter(&bytes_to_read, dev);
		if (rslt == BMI160_OK) {
			user_fifo_len = dev->fifo->length;

			if (dev->fifo->length > bytes_to_read) {
				/* Handling the case where user requests
				more data than available in FIFO */
				dev->fifo->length = bytes_to_read;
			}

			if ((dev->fifo->fifo_time_enable == BMI160_FIFO_TIME_ENABLE)
				&& (bytes_to_read + BMI160_FIFO_BYTES_OVERREAD <= user_fifo_len)) {
				/* Handling case of sensor time availability*/
				dev->fifo->length = dev->fifo->length + BMI160_FIFO_BYTES_OVERREAD;
			}

			if (dev->interface == BMI160_SPI_INTF) {
				/* SPI read mask */
				addr = addr | BMI160_SPI_RD_MASK;
			}

			/* read only the filled bytes in the FIFO Buffer */
			rslt = dev->read(dev->id, addr, dev->fifo->data, dev->fifo->length);
		}
	}

	return rslt;
}

/*!
 *  @brief This API writes fifo_flush command to command register.This
 *  action clears all data in the Fifo without changing fifo configuration
 *  settings
 */
int8_t bmi160_set_fifo_flush(const struct bmi160_dev *dev)
{
	int8_t rslt = 0;
	uint8_t data =  BMI160_FIFO_FLUSH_VALUE;
	uint8_t reg_addr = BMI160_COMMAND_REG_ADDR;

	/* Check the bmi160_dev structure for NULL address*/
	if (dev == NULL)
		rslt = BMI160_E_NULL_PTR;
	else
		rslt = bmi160_set_regs(reg_addr, &data, BMI160_ONE, dev);

	return rslt;
}

/*!
 * @brief This API sets the FIFO configuration in the sensor.
 */
int8_t bmi160_set_fifo_config(uint8_t config, uint8_t enable, struct bmi160_dev const *dev)
{
	int8_t rslt = 0;
	uint8_t data =  0;
	uint8_t reg_addr = BMI160_FIFO_CONFIG_1_ADDR;
	uint8_t fifo_config = config & BMI160_FIFO_CONFIG_1_MASK;

	/* Check the bmi160_dev structure for NULL address*/
	if (dev == NULL) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		rslt = bmi160_get_regs(reg_addr, &data, BMI160_ONE, dev);

		if (rslt == BMI160_OK) {

			if (fifo_config > 0) {

				if (enable == BMI160_ENABLE)
					data = data | fifo_config;
				else
					data = data & (~fifo_config);
			}
			/* write fifo frame content configuration*/
			rslt = bmi160_set_regs(reg_addr, &data, BMI160_ONE, dev);
			if (rslt == BMI160_OK) {
				/* read fifo frame content configuration*/
				rslt = bmi160_get_regs(reg_addr, &data, BMI160_ONE, dev);
				if (rslt == BMI160_OK) {
					/* extract fifo header enabled status */
					dev->fifo->fifo_header_enable = data & BMI160_FIFO_HEAD_ENABLE;
					/* extract accel/gyr/aux. data enabled status */
					dev->fifo->fifo_data_enable = data & BMI160_FIFO_M_G_A_ENABLE;
					/* extract fifo sensor time enabled status */
					dev->fifo->fifo_time_enable = data & BMI160_FIFO_TIME_ENABLE;
				}
			}
		}
	}

	return rslt;
}

/*! @brief This API is used to configure the down sampling ratios of
 *  the accel and gyro data for FIFO.Also, it configures filtered or
 *  pre-filtered data for accel and gyro.
 *
 */
int8_t bmi160_set_fifo_down(uint8_t fifo_down, const struct bmi160_dev *dev)
{
	int8_t rslt = 0;
	uint8_t data =  0;
	uint8_t reg_addr = BMI160_FIFO_DOWN_ADDR;

	/* Check the bmi160_dev structure for NULL address*/
	if (dev == NULL) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		rslt = bmi160_get_regs(reg_addr, &data, BMI160_ONE, dev);

		 if (rslt == BMI160_OK) {
			data = data | fifo_down;
			rslt = bmi160_set_regs(reg_addr, &data, BMI160_ONE, dev);
		 }
	}

	return rslt;

}

/*!
 *  @brief This API sets the FIFO watermark level in the sensor.
 *
 */
int8_t bmi160_set_fifo_wm(uint8_t fifo_wm, const struct bmi160_dev *dev)
{
	int8_t rslt = 0;
	uint8_t data =  fifo_wm;
	uint8_t reg_addr = BMI160_FIFO_CONFIG_0_ADDR;

	/* Check the bmi160_dev structure for NULL address*/
	if (dev == NULL)
		rslt = BMI160_E_NULL_PTR;
	else
		rslt = bmi160_set_regs(reg_addr, &data, BMI160_ONE, dev);

	return rslt;

}

/*!
 *  @brief This API parses and extracts the accelerometer frames from
 *  FIFO data read by the "bmi160_get_fifo_data" API and stores it in
 *  the "accel_data" structure instance.
 */
int8_t bmi160_extract_accel(struct bmi160_sensor_data *accel_data, uint8_t *accel_length, struct bmi160_dev const *dev)
{
	int8_t rslt = 0;
	uint16_t data_index = 0;
	uint16_t data_read_length = 0;
	uint8_t accel_index = 0;
	uint8_t fifo_data_enable = 0;

	if (dev == NULL || dev->fifo == NULL || dev->fifo->data == NULL) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		/* Parsing the FIFO data in header-less mode */
		if (dev->fifo->fifo_header_enable == 0) {
			/* Number of bytes to be parsed from FIFO */
			get_accel_len_to_parse(&data_index, &data_read_length, accel_length, dev);
			for (; data_index < data_read_length; ) {
				/*Check for the availability of next two bytes of FIFO data */
				check_frame_validity(&data_index, dev);
				fifo_data_enable = dev->fifo->fifo_data_enable;
				unpack_accel_frame(accel_data, &data_index, &accel_index, fifo_data_enable, dev);
			}
			/* update number of accel data read*/
			*accel_length = accel_index;
			/*update the accel byte index*/
			dev->fifo->accel_byte_start_idx = data_index;
		} else {
			/* Parsing the FIFO data in header mode */
			extract_accel_header_mode(accel_data, accel_length, dev);
		}
	}

	return rslt;
}

/*!
 *  @brief This API parses and extracts the gyro frames from
 *  FIFO data read by the "bmi160_get_fifo_data" API and stores it in
 *  the "gyro_data" structure instance.
 */
int8_t bmi160_extract_gyro(struct bmi160_sensor_data *gyro_data, uint8_t *gyro_length, struct bmi160_dev const *dev)
{
	int8_t rslt = 0;
	uint16_t data_index = 0;
	uint16_t data_read_length = 0;
	uint8_t gyro_index = 0;
	uint8_t fifo_data_enable = 0;

	if (dev == NULL || dev->fifo->data == NULL) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		/* Parsing the FIFO data in header-less mode */
		if (dev->fifo->fifo_header_enable == 0) {
			/* Number of bytes to be parsed from FIFO */
			get_gyro_len_to_parse(&data_index, &data_read_length, gyro_length, dev);
			for (; data_index < data_read_length ;) {
				/*Check for the availability of next two bytes of FIFO data */
				check_frame_validity(&data_index, dev);
				fifo_data_enable = dev->fifo->fifo_data_enable;
				unpack_gyro_frame(gyro_data, &data_index, &gyro_index, fifo_data_enable, dev);
			}
			/* update number of gyro data read */
			*gyro_length = gyro_index;
			/* update the gyro byte index */
			dev->fifo->gyro_byte_start_idx = data_index;
		} else {
			/* Parsing the FIFO data in header mode */
			extract_gyro_header_mode(gyro_data, gyro_length, dev);
		}
	}

	return rslt;
}

/*!
 *  @brief This API parses and extracts the aux frames from
 *  FIFO data read by the "bmi160_get_fifo_data" API and stores it in
 *  the "aux_data" structure instance.
 */
int8_t bmi160_extract_aux(struct bmi160_aux_data *aux_data, uint8_t *aux_len, struct bmi160_dev const *dev)
{
	int8_t rslt = 0;
	uint16_t data_index = 0;
	uint16_t data_read_length = 0;
	uint8_t aux_index = 0;
	uint8_t fifo_data_enable = 0;

	if ((dev == NULL) || (dev->fifo->data == NULL) || (aux_data == NULL)) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		/* Parsing the FIFO data in header-less mode */
		if (dev->fifo->fifo_header_enable == 0) {
			/* Number of bytes to be parsed from FIFO */
			get_aux_len_to_parse(&data_index, &data_read_length, aux_len, dev);
			for (; data_index < data_read_length ;) {
				/* Check for the availability of next two
				 * bytes of FIFO data */
				check_frame_validity(&data_index, dev);
				fifo_data_enable = dev->fifo->fifo_data_enable;
				unpack_aux_frame(aux_data, &data_index, &aux_index, fifo_data_enable, dev);
			}
			/* update number of aux data read */
			*aux_len = aux_index;
			/* update the aux byte index */
			dev->fifo->aux_byte_start_idx = data_index;
		} else {
			/* Parsing the FIFO data in header mode */
			extract_aux_header_mode(aux_data, aux_len, dev);
		}
	}

	return rslt;
}

/*!
 *  @brief This API starts the FOC of accel and gyro
 *
 *  @note FOC should not be used in low-power mode of sensor
 *
 *  @note Accel FOC targets values of +1g , 0g , -1g
 *  Gyro FOC always targets value of 0 dps
 */
int8_t bmi160_start_foc(const struct bmi160_foc_conf *foc_conf, struct bmi160_offsets *offset,
				struct bmi160_dev const *dev)
{
	int8_t rslt;
	uint8_t data;

	/* Null-pointer check */
	rslt = null_ptr_check(dev);

	if (rslt != BMI160_OK) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		/* Set the offset enable bits */
		rslt = configure_offset_enable(foc_conf, dev);
		if (rslt == BMI160_OK) {
			/* Read the FOC config from the sensor */
			rslt = bmi160_get_regs(BMI160_FOC_CONF_ADDR, &data, 1, dev);

			/* Set the FOC config for gyro */
			data = BMI160_SET_BITS(data, BMI160_GYRO_FOC_EN, foc_conf->foc_gyr_en);

			/* Set the FOC config for accel xyz axes */
			data = BMI160_SET_BITS(data, BMI160_ACCEL_FOC_X_CONF, foc_conf->foc_acc_x);
			data = BMI160_SET_BITS(data, BMI160_ACCEL_FOC_Y_CONF, foc_conf->foc_acc_y);
			data = BMI160_SET_BITS_POS_0(data, BMI160_ACCEL_FOC_Z_CONF, foc_conf->foc_acc_z);

			if (rslt == BMI160_OK) {
				/* Set the FOC config in the sensor */
				rslt = bmi160_set_regs(BMI160_FOC_CONF_ADDR, &data, 1, dev);
				if (rslt == BMI160_OK) {
					/* Procedure to trigger
					 * FOC and check status */
					rslt = trigger_foc(offset, dev);
				}
			}
		}
	}

	return rslt;
}

/*!
 *  @brief This API reads and stores the offset values of accel and gyro
 */
int8_t bmi160_get_offsets(struct bmi160_offsets *offset, const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data[7];
	uint8_t lsb, msb;
	int16_t offset_msb, offset_lsb;
	int16_t offset_data;


	/* Null-pointer check */
	rslt = null_ptr_check(dev);

	if (rslt != BMI160_OK) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		/* Read the FOC config from the sensor */
		rslt = bmi160_get_regs(BMI160_OFFSET_ADDR, data, 7, dev);

		/* Accel offsets */
		offset->off_acc_x = (int8_t)data[0];
		offset->off_acc_y = (int8_t)data[1];
		offset->off_acc_z = (int8_t)data[2];

		/* Gyro x-axis offset */
		lsb = data[3];
		msb = BMI160_GET_BITS_POS_0(data[6], BMI160_GYRO_OFFSET_X);
		offset_msb = (int16_t)(msb << 14);
		offset_lsb = lsb << 6;
		offset_data = offset_msb | offset_lsb;
		/* Divide by 64 to get the Right shift by 6 value */
		offset->off_gyro_x = (int16_t)(offset_data / 64);

		/* Gyro y-axis offset */
		lsb = data[4];
		msb = BMI160_GET_BITS(data[6], BMI160_GYRO_OFFSET_Y);
		offset_msb = (int16_t)(msb << 14);
		offset_lsb = lsb << 6;
		offset_data = offset_msb | offset_lsb;
		/* Divide by 64 to get the Right shift by 6 value */
		offset->off_gyro_y = (int16_t)(offset_data / 64);

		/* Gyro z-axis offset */
		lsb = data[5];
		msb = BMI160_GET_BITS(data[6], BMI160_GYRO_OFFSET_Z);
		offset_msb = (int16_t)(msb << 14);
		offset_lsb = lsb << 6;
		offset_data = offset_msb | offset_lsb;
		/* Divide by 64 to get the Right shift by 6 value */
		offset->off_gyro_z = (int16_t)(offset_data / 64);
	}

	return rslt;
}

/*!
 *  @brief This API writes the offset values of accel and gyro to
 *  the sensor but these values will be reset on POR or soft reset.
 */
int8_t bmi160_set_offsets(const struct bmi160_foc_conf *foc_conf, const struct bmi160_offsets *offset,
				struct bmi160_dev const *dev)
{
	int8_t rslt;
	uint8_t data[7];
	uint8_t x_msb, y_msb, z_msb;


	/* Null-pointer check */
	rslt = null_ptr_check(dev);

	if (rslt != BMI160_OK) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		/* Update the accel offset */
		data[0] = (uint8_t)offset->off_acc_x;
		data[1] = (uint8_t)offset->off_acc_y;
		data[2] = (uint8_t)offset->off_acc_z;

		/* Update the LSB of gyro offset */
		data[3] = BMI160_GET_LSB(offset->off_gyro_x);
		data[4] = BMI160_GET_LSB(offset->off_gyro_y);
		data[5] = BMI160_GET_LSB(offset->off_gyro_z);

		/* Update the MSB of gyro offset */
		x_msb = BMI160_GET_BITS(offset->off_gyro_x, BMI160_GYRO_OFFSET);
		y_msb = BMI160_GET_BITS(offset->off_gyro_y, BMI160_GYRO_OFFSET);
		z_msb = BMI160_GET_BITS(offset->off_gyro_z, BMI160_GYRO_OFFSET);
		data[6] = (uint8_t)(z_msb << 4 | y_msb << 2 | x_msb);

		/* Set the offset enable/disable for gyro and accel */
		data[6] = BMI160_SET_BITS(data[6], BMI160_GYRO_OFFSET_EN, foc_conf->gyro_off_en);
		data[6] = BMI160_SET_BITS(data[6], BMI160_ACCEL_OFFSET_EN, foc_conf->acc_off_en);

		/* Set the offset config and values in the sensor */
		rslt = bmi160_set_regs(BMI160_OFFSET_ADDR, data, 7, dev);
	}

	return rslt;
}

/*!
 *  @brief This API writes the image registers values to NVM which is
 *  stored even after POR or soft reset
 */
int8_t bmi160_update_nvm(struct bmi160_dev const *dev)
{
	int8_t rslt;
	uint8_t data;
	uint8_t cmd = BMI160_NVM_BACKUP_EN;

	/* Read the nvm_prog_en configuration */
	rslt = bmi160_get_regs(BMI160_CONF_ADDR, &data, 1, dev);
	if (rslt == BMI160_OK) {
		data = BMI160_SET_BITS(data, BMI160_NVM_UPDATE, 1);
		/* Set the nvm_prog_en bit in the sensor */
		rslt = bmi160_set_regs(BMI160_CONF_ADDR, &data, 1, dev);
		if (rslt == BMI160_OK) {
			/* Update NVM */
			rslt = bmi160_set_regs(BMI160_COMMAND_REG_ADDR, &cmd, 1, dev);
			if (rslt == BMI160_OK) {
				/* Check for NVM ready status */
				rslt = bmi160_get_regs(BMI160_STATUS_ADDR, &data, 1, dev);
				if (rslt == BMI160_OK) {
					data = BMI160_GET_BITS(data, BMI160_NVM_STATUS);
					if (data != BMI160_ENABLE) {
						/* Delay to update NVM */
						dev->delay_ms(25);
					}
				}
			}
		}
	}

	return rslt;
}

/*!
 *  @brief This API gets the interrupt status from the sensor.
 */
int8_t bmi160_get_int_status(enum bmi160_int_status_sel int_status_sel,
				union bmi160_int_status *int_status, struct bmi160_dev const *dev)
{
	int8_t rslt = 0;

	/* To get the status of all interrupts */
	if (int_status_sel == BMI160_INT_STATUS_ALL) {
		rslt = bmi160_get_regs(BMI160_INT_STATUS_ADDR, &int_status->data[0], 4, dev);
	} else {
		if (int_status_sel & BMI160_INT_STATUS_0)
			rslt = bmi160_get_regs(BMI160_INT_STATUS_ADDR, &int_status->data[0], 1, dev);
		if (int_status_sel & BMI160_INT_STATUS_1)
			rslt = bmi160_get_regs(BMI160_INT_STATUS_ADDR + 1, &int_status->data[1], 1, dev);
		if (int_status_sel & BMI160_INT_STATUS_2)
			rslt = bmi160_get_regs(BMI160_INT_STATUS_ADDR + 2, &int_status->data[2], 1, dev);
		if (int_status_sel & BMI160_INT_STATUS_3)
			rslt = bmi160_get_regs(BMI160_INT_STATUS_ADDR + 3, &int_status->data[3], 1, dev);
	}

	return rslt;
}

/*********************** Local function definitions ***************************/

/*!
 * @brief This API sets the any-motion interrupt of the sensor.
 * This interrupt occurs when accel values exceeds preset threshold
 * for a certain period of time.
 */
static int8_t set_accel_any_motion_int(struct bmi160_int_settg *int_config, struct bmi160_dev *dev)
{
	int8_t rslt;

	/* Null-pointer check */
	rslt = null_ptr_check(dev);

	if ((rslt != BMI160_OK) || (int_config == NULL)) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		/* updating the interrupt structure to local structure */
		struct bmi160_acc_any_mot_int_cfg *any_motion_int_cfg = &(int_config->int_type_cfg.acc_any_motion_int);

		rslt = enable_accel_any_motion_int(any_motion_int_cfg, dev);
		if (rslt == BMI160_OK)
			rslt = config_any_motion_int_settg(int_config, any_motion_int_cfg, dev);
	}

	return rslt;
}

/*!
 * @brief This API sets tap interrupts.Interrupt is fired when
 * tap movements happen.
 */
static int8_t set_accel_tap_int(struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
	int8_t rslt;

	/* Null-pointer check */
	rslt = null_ptr_check(dev);

	if ((rslt != BMI160_OK) || (int_config == NULL)) {
		rslt = BMI160_E_NULL_PTR;
	} else {

		/* updating the interrupt structure to local structure */
		struct bmi160_acc_tap_int_cfg *tap_int_cfg = &(int_config->int_type_cfg.acc_tap_int);

		rslt = enable_tap_int(int_config, tap_int_cfg, dev);
		if (rslt == BMI160_OK) {
			/* Configure Interrupt pins */
			rslt = set_intr_pin_config(int_config, dev);
			if (rslt == BMI160_OK)
				rslt = config_tap_int_settg(int_config, tap_int_cfg, dev);
		}
	}
	return rslt;
}

/*!
 * @brief This API sets the data ready interrupt for both accel and gyro.
 * This interrupt occurs when new accel and gyro data comes.
 */
static int8_t set_accel_gyro_data_ready_int(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
	int8_t rslt;

	/* Null-pointer check */
	rslt = null_ptr_check(dev);

	if ((rslt != BMI160_OK) || (int_config == NULL)) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		rslt = enable_data_ready_int(dev);

		if (rslt == BMI160_OK) {
			/* Configure Interrupt pins */
			rslt = set_intr_pin_config(int_config, dev);

			if (rslt == BMI160_OK)
				rslt = map_hardware_interrupt(int_config, dev);
		}
	}

	return rslt;
}

/*!
 * @brief This API sets the significant motion interrupt of the sensor.This
 * interrupt occurs when there is change in user location.
 */
static int8_t set_accel_sig_motion_int(struct bmi160_int_settg *int_config, struct bmi160_dev *dev)
{
	int8_t rslt;

	/* Null-pointer check */
	rslt = null_ptr_check(dev);

	if ((rslt != BMI160_OK) || (int_config == NULL)) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		/* updating the interrupt structure to local structure */
		struct bmi160_acc_sig_mot_int_cfg *sig_mot_int_cfg = &(int_config->int_type_cfg.acc_sig_motion_int);

		rslt = enable_sig_motion_int(sig_mot_int_cfg, dev);
		if (rslt == BMI160_OK)
			rslt = config_sig_motion_int_settg(int_config, sig_mot_int_cfg, dev);
	}

	return rslt;
}

/*!
 * @brief This API sets the no motion/slow motion interrupt of the sensor.
 * Slow motion is similar to any motion interrupt.No motion interrupt
 * occurs when slope bet. two accel values falls below preset threshold
 * for preset duration.
 */
static int8_t set_accel_no_motion_int(struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
	int8_t rslt;

	/* Null-pointer check */
	rslt = null_ptr_check(dev);

	if ((rslt != BMI160_OK) || (int_config == NULL)) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		/* updating the interrupt structure to local structure */
		struct bmi160_acc_no_motion_int_cfg *no_mot_int_cfg = &(int_config->int_type_cfg.acc_no_motion_int);

		rslt = enable_no_motion_int(no_mot_int_cfg, dev);
		if (rslt == BMI160_OK)
			/* Configure the INT PIN settings*/
			rslt = config_no_motion_int_settg(int_config, no_mot_int_cfg, dev);
	}

	return rslt;
}

/*!
 * @brief This API sets the step detection interrupt.This interrupt
 * occurs when the single step causes accel values to go above
 * preset threshold.
 */
static int8_t set_accel_step_detect_int(struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
	int8_t rslt;

	/* Null-pointer check */
	rslt = null_ptr_check(dev);

	if ((rslt != BMI160_OK) || (int_config == NULL)) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		/* updating the interrupt structure to local structure */
		struct bmi160_acc_step_detect_int_cfg *step_detect_int_cfg =
								&(int_config->int_type_cfg.acc_step_detect_int);

		rslt = enable_step_detect_int(step_detect_int_cfg, dev);
		if (rslt == BMI160_OK) {
			/* Configure Interrupt pins */
			rslt = set_intr_pin_config(int_config, dev);
			if (rslt == BMI160_OK) {
				rslt = map_feature_interrupt(int_config, dev);
				if (rslt == BMI160_OK)
					rslt = config_step_detect(step_detect_int_cfg, dev);
			}
		}
	}
	return rslt;
}

/*!
 * @brief This API sets the orientation interrupt of the sensor.This
 * interrupt occurs when there is orientation change in the sensor
 * with respect to gravitational field vector g.
 */
static int8_t set_accel_orientation_int(struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
	int8_t rslt;

	/* Null-pointer check */
	rslt = null_ptr_check(dev);

	if ((rslt != BMI160_OK) || (int_config == NULL)) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		/* updating the interrupt structure to local structure */
		struct bmi160_acc_orient_int_cfg *orient_int_cfg = &(int_config->int_type_cfg.acc_orient_int);

		rslt = enable_orient_int(orient_int_cfg, dev);
		if (rslt == BMI160_OK) {
			/* Configure Interrupt pins */
			rslt = set_intr_pin_config(int_config, dev);
			if (rslt == BMI160_OK) {
				/* map INT pin to orient interrupt */
				rslt = map_feature_interrupt(int_config, dev);
				if (rslt == BMI160_OK)
					/* configure the
					 * orientation setting*/
					rslt = config_orient_int_settg(orient_int_cfg, dev);
			}
		}
	}

	return rslt;
}

/*!
 * @brief This API sets the flat interrupt of the sensor.This interrupt
 * occurs in case of flat orientation
 */
static int8_t set_accel_flat_detect_int(struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
	int8_t rslt;

	/* Null-pointer check */
	rslt = null_ptr_check(dev);

	if ((rslt != BMI160_OK) || (int_config == NULL)) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		/* updating the interrupt structure to local structure */
		struct bmi160_acc_flat_detect_int_cfg *flat_detect_int = &(int_config->int_type_cfg.acc_flat_int);

		/* enable the flat interrupt */
		rslt = enable_flat_int(flat_detect_int, dev);
		if (rslt == BMI160_OK) {
			/* Configure Interrupt pins */
			rslt = set_intr_pin_config(int_config, dev);
			if (rslt == BMI160_OK) {
				/* map INT pin to flat interrupt */
				rslt = map_feature_interrupt(int_config, dev);
				if (rslt == BMI160_OK)
					/* configure the flat setting*/
					rslt = config_flat_int_settg(flat_detect_int, dev);
			}
		}
	}

	return rslt;
}

/*!
 * @brief This API sets the low-g interrupt of the sensor.This interrupt
 * occurs during free-fall.
 */
static int8_t set_accel_low_g_int(struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
	int8_t rslt;

	/* Null-pointer check */
	rslt = null_ptr_check(dev);

	if ((rslt != BMI160_OK) || (int_config == NULL)) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		/* updating the interrupt structure to local structure */
		struct bmi160_acc_low_g_int_cfg *low_g_int = &(int_config->int_type_cfg.acc_low_g_int);

		/* Enable the low-g interrupt*/
		rslt = enable_low_g_int (low_g_int, dev);
		if (rslt == BMI160_OK) {
			/* Configure Interrupt pins */
			rslt = set_intr_pin_config(int_config, dev);
			if (rslt == BMI160_OK) {
				/* Map INT pin to low-g interrupt */
				rslt = map_feature_interrupt(int_config, dev);
				if (rslt == BMI160_OK) {
					/* configure the data source
					 * for low-g interrupt*/
					rslt = config_low_g_data_src(low_g_int, dev);
					if (rslt == BMI160_OK)
						rslt = config_low_g_int_settg(low_g_int, dev);
				}
			}
		}
	}

	return rslt;
}

/*!
 * @brief This API sets the high-g interrupt of the sensor.The interrupt
 * occurs if the absolute value of acceleration data of any enabled axis
 * exceeds the programmed threshold and the sign of the value does not
 * change for a preset duration.
 */
static int8_t set_accel_high_g_int(struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
	int8_t rslt;

	/* Null-pointer check */
	rslt = null_ptr_check(dev);

	if ((rslt != BMI160_OK) || (int_config == NULL)) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		/* updating the interrupt structure to local structure */
		struct bmi160_acc_high_g_int_cfg *high_g_int_cfg = &(int_config->int_type_cfg.acc_high_g_int);

		/* Enable the high-g interrupt */
		rslt = enable_high_g_int(high_g_int_cfg, dev);
		if (rslt == BMI160_OK) {
			/* Configure Interrupt pins */
			rslt = set_intr_pin_config(int_config, dev);
			if (rslt == BMI160_OK) {
				/* Map INT pin to high-g interrupt */
				rslt = map_feature_interrupt(int_config, dev);
				if (rslt == BMI160_OK) {
					/* configure the data source
					* for high-g interrupt*/
					rslt = config_high_g_data_src(high_g_int_cfg, dev);
					if (rslt == BMI160_OK)
						rslt = config_high_g_int_settg(high_g_int_cfg, dev);
				}
			}
		}
	}

	return rslt;
}

/*!
 * @brief This API configures the pins to fire the
 * interrupt signal when it occurs.
 */
static int8_t set_intr_pin_config(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
	int8_t rslt;

	/* configure the behavioural settings of interrupt pin */
	rslt = config_int_out_ctrl(int_config, dev);
	if (rslt == BMI160_OK)
		rslt = config_int_latch(int_config, dev);

	return rslt;
}

/*!
 * @brief This internal API is used to validate the device structure pointer for
 * null conditions.
 */
static int8_t null_ptr_check(const struct bmi160_dev *dev)
{
	int8_t rslt;

	if ((dev == NULL) || (dev->read == NULL) || (dev->write == NULL) || (dev->delay_ms == NULL)) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		/* Device structure is fine */
		rslt = BMI160_OK;
	}

	return rslt;
}

/*!
 * @brief This API sets the default configuration parameters of accel & gyro.
 * Also maintain the previous state of configurations.
 */
static void default_param_settg(struct bmi160_dev *dev)
{
	/* Initializing accel and gyro params with
	* default values */
	dev->accel_cfg.bw = BMI160_ACCEL_BW_NORMAL_AVG4;
	dev->accel_cfg.odr = BMI160_ACCEL_ODR_100HZ;
	dev->accel_cfg.power = BMI160_ACCEL_SUSPEND_MODE;
	dev->accel_cfg.range = BMI160_ACCEL_RANGE_2G;
	dev->gyro_cfg.bw = BMI160_GYRO_BW_NORMAL_MODE;
	dev->gyro_cfg.odr = BMI160_GYRO_ODR_100HZ;
	dev->gyro_cfg.power = BMI160_GYRO_SUSPEND_MODE;
	dev->gyro_cfg.range = BMI160_GYRO_RANGE_2000_DPS;

	/* To maintain the previous state of accel configuration */
	dev->prev_accel_cfg = dev->accel_cfg;
	/* To maintain the previous state of gyro configuration */
	dev->prev_gyro_cfg = dev->gyro_cfg;
}

/*!
 * @brief This API set the accel configuration.
 */
static int8_t set_accel_conf(struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data[2]  = {0};

	rslt = check_accel_config(data, dev);
	if (rslt == BMI160_OK) {
		/* Write output data rate and bandwidth */
		rslt = bmi160_set_regs(BMI160_ACCEL_CONFIG_ADDR, &data[0], 1, dev);
		if (rslt == BMI160_OK) {
			dev->prev_accel_cfg.odr = dev->accel_cfg.odr;
			dev->prev_accel_cfg.bw = dev->accel_cfg.bw;
			dev->delay_ms(BMI160_ONE_MS_DELAY);
			/* write accel range */
			rslt = bmi160_set_regs(BMI160_ACCEL_RANGE_ADDR, &data[1], 1, dev);
			if (rslt == BMI160_OK)
				dev->prev_accel_cfg.range = dev->accel_cfg.range;
		}
	}

	return rslt;
}

/*!
* @brief This API check the accel configuration.
*/
static int8_t check_accel_config(uint8_t *data, const struct bmi160_dev *dev)
{
	int8_t rslt;

	/* read accel Output data rate and bandwidth */
	rslt = bmi160_get_regs(BMI160_ACCEL_CONFIG_ADDR, data, 2, dev);
	if (rslt == BMI160_OK) {
		rslt = process_accel_odr(&data[0], dev);
		if (rslt == BMI160_OK) {
			rslt = process_accel_bw(&data[0], dev);
			if (rslt == BMI160_OK)
				rslt = process_accel_range(&data[1], dev);
		}
	}

	return rslt;
}

/*!
 * @brief This API process the accel odr.
 */
static int8_t process_accel_odr(uint8_t *data, const struct bmi160_dev *dev)
{
	int8_t rslt = 0;
	uint8_t temp = 0;
	uint8_t odr = 0;

	if (dev->accel_cfg.odr <= BMI160_ACCEL_ODR_MAX) {
		if (dev->accel_cfg.odr != dev->prev_accel_cfg.odr) {
			odr = (uint8_t)dev->accel_cfg.odr;
			temp = *data & ~BMI160_ACCEL_ODR_MASK;
			/* Adding output data rate */
			*data = temp | (odr & BMI160_ACCEL_ODR_MASK);
		}
	} else {
		rslt = BMI160_E_OUT_OF_RANGE;
	}

	return rslt;
}

/*!
 * @brief This API process the accel bandwidth.
 */
static int8_t process_accel_bw(uint8_t *data, const struct bmi160_dev *dev)
{
	int8_t rslt = 0;
	uint8_t temp = 0;
	uint8_t bw = 0;

	if (dev->accel_cfg.bw <= BMI160_ACCEL_BW_MAX) {
		if (dev->accel_cfg.bw != dev->prev_accel_cfg.bw) {
			bw = (uint8_t)dev->accel_cfg.bw;
			temp = *data & ~BMI160_ACCEL_BW_MASK;
			/* Adding bandwidth */
			*data = temp | ((bw << 4) & BMI160_ACCEL_ODR_MASK);
		}
	} else {
		rslt = BMI160_E_OUT_OF_RANGE;
	}

	return rslt;
}

/*!
 * @brief This API process the accel range.
 */
static int8_t process_accel_range(uint8_t *data, const struct bmi160_dev *dev)
{
	int8_t rslt = 0;
	uint8_t temp = 0;
	uint8_t range = 0;

	if (dev->accel_cfg.range <= BMI160_ACCEL_RANGE_MAX) {
		if (dev->accel_cfg.range != dev->prev_accel_cfg.range) {
			range = (uint8_t)dev->accel_cfg.range;
			temp = *data & ~BMI160_ACCEL_RANGE_MASK;
			/* Adding range */
			*data = temp | (range & BMI160_ACCEL_RANGE_MASK);
		}
	} else {
		rslt = BMI160_E_OUT_OF_RANGE;
	}

	return rslt;
}

/*!
 * @brief This API checks the invalid settings for ODR & Bw for
 * Accel and Gyro.
 */
static int8_t check_invalid_settg(const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data = 0;

	/* read the error reg */
	rslt = bmi160_get_regs(BMI160_ERROR_REG_ADDR, &data, 1, dev);

	data = data >> 1;
	data = data & BMI160_ERR_REG_MASK;
	if (data == 1)
		rslt = BMI160_E_ACCEL_ODR_BW_INVALID;
	else if (data == 2)
		rslt = BMI160_E_GYRO_ODR_BW_INVALID;
	else if (data == 3)
		rslt = BMI160_E_LWP_PRE_FLTR_INT_INVALID;
	else if (data == 7)
		rslt = BMI160_E_LWP_PRE_FLTR_INVALID;

	return rslt;
}

static int8_t set_gyro_conf(struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data[2] = {0};

	rslt = check_gyro_config(data, dev);
	if (rslt == BMI160_OK) {
		/* Write output data rate and bandwidth */
		rslt = bmi160_set_regs(BMI160_GYRO_CONFIG_ADDR, &data[0], 1, dev);
		if (rslt == BMI160_OK) {
			dev->prev_gyro_cfg.odr = dev->gyro_cfg.odr;
			dev->prev_gyro_cfg.bw = dev->gyro_cfg.bw;
			dev->delay_ms(BMI160_ONE_MS_DELAY);
			/* Write gyro range */
			rslt = bmi160_set_regs(BMI160_GYRO_RANGE_ADDR, &data[1], 1, dev);
			if (rslt == BMI160_OK)
				dev->prev_gyro_cfg.range = dev->gyro_cfg.range;
		}
	}

	return rslt;
}

/*!
* @brief This API check the gyro configuration.
*/
static int8_t check_gyro_config(uint8_t *data, const struct bmi160_dev *dev)
{
	int8_t rslt;

	/* read gyro Output data rate and bandwidth */
	rslt = bmi160_get_regs(BMI160_GYRO_CONFIG_ADDR, data, 2, dev);
	if (rslt == BMI160_OK) {
		rslt = process_gyro_odr(&data[0], dev);
		if (rslt == BMI160_OK) {
			rslt = process_gyro_bw(&data[0], dev);
			if (rslt == BMI160_OK)
				rslt = process_gyro_range(&data[1], dev);
		}
	}

	return rslt;

}

/*!
 * @brief This API process the gyro odr.
 */
static int8_t process_gyro_odr(uint8_t *data, const struct bmi160_dev *dev)
{
	int8_t rslt = 0;
	uint8_t temp = 0;
	uint8_t odr = 0;

	if (dev->gyro_cfg.odr <= BMI160_GYRO_ODR_MAX) {
		if (dev->gyro_cfg.odr != dev->prev_gyro_cfg.odr) {
			odr = (uint8_t)dev->gyro_cfg.odr;
			temp = (*data & ~BMI160_GYRO_ODR_MASK);
			/* Adding output data rate */
			*data = temp | (odr & BMI160_GYRO_ODR_MASK);
		}
	} else {
		rslt = BMI160_E_OUT_OF_RANGE;
	}

	return rslt;
}

/*!
 * @brief This API process the gyro bandwidth.
 */
static int8_t process_gyro_bw(uint8_t *data, const struct bmi160_dev *dev)
{
	int8_t rslt = 0;
	uint8_t temp = 0;
	uint8_t bw = 0;

	if (dev->gyro_cfg.bw <= BMI160_GYRO_BW_MAX) {
		bw = (uint8_t)dev->gyro_cfg.bw;
		temp = *data & ~BMI160_GYRO_BW_MASK;
		/* Adding bandwidth */
		*data = temp | ((bw << 4) & BMI160_GYRO_BW_MASK);
	} else {
		rslt = BMI160_E_OUT_OF_RANGE;
	}

	return rslt;
}

/*!
 * @brief This API process the gyro range.
 */
static int8_t process_gyro_range(uint8_t *data, const struct bmi160_dev *dev)
{
	int8_t rslt = 0;
	uint8_t temp = 0;
	uint8_t range = 0;

	if (dev->gyro_cfg.range <= BMI160_GYRO_RANGE_MAX) {
		if (dev->gyro_cfg.range != dev->prev_gyro_cfg.range) {
			range = (uint8_t)dev->gyro_cfg.range;
			temp = *data & ~BMI160_GYRO_RANGE_MSK;
			/* Adding range */
			*data = temp | (range & BMI160_GYRO_RANGE_MSK);
		}
	} else {
		rslt = BMI160_E_OUT_OF_RANGE;
	}

	return rslt;
}

/*!
 * @brief This API sets the accel power.
 */
static int8_t set_accel_pwr(struct bmi160_dev *dev)
{
	int8_t rslt = 0;
	uint8_t data = 0;

	if ((dev->accel_cfg.power >= BMI160_ACCEL_SUSPEND_MODE) &&
		(dev->accel_cfg.power <= BMI160_ACCEL_LOWPOWER_MODE)) {
		if (dev->accel_cfg.power != dev->prev_accel_cfg.power) {
			rslt = process_under_sampling(&data, dev);
			if (rslt == BMI160_OK) {
				/* Write accel power */
				rslt = bmi160_set_regs(BMI160_COMMAND_REG_ADDR, &dev->accel_cfg.power, 1, dev);
				/* Add delay of 5 ms */
				if (dev->prev_accel_cfg.power == BMI160_ACCEL_SUSPEND_MODE)
					dev->delay_ms(BMI160_ACCEL_DELAY_MS);
				dev->prev_accel_cfg.power = dev->accel_cfg.power;
			}
		}
	} else {
		rslt = BMI160_E_OUT_OF_RANGE;
	}

	return rslt;
}

/*!
 * @brief This API process the undersampling setting of Accel.
 */
static int8_t process_under_sampling(uint8_t *data, const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t temp = 0;
	uint8_t pre_filter = 0;

	rslt = bmi160_get_regs(BMI160_ACCEL_CONFIG_ADDR, data, 1, dev);
	if (rslt == BMI160_OK) {
		if (dev->accel_cfg.power == BMI160_ACCEL_LOWPOWER_MODE) {
			temp = *data & ~BMI160_ACCEL_UNDERSAMPLING_MASK;
			/* Set under-sampling parameter */
			*data = temp | ((1 << 7) & BMI160_ACCEL_UNDERSAMPLING_MASK);
			/* Write data */
			rslt = bmi160_set_regs(BMI160_ACCEL_CONFIG_ADDR, data, 1, dev);
			/* disable the pre-filter data in
			 * low power mode */
			if (rslt == BMI160_OK)
				/* Disable the Pre-filter data*/
				rslt = bmi160_set_regs(BMI160_INT_DATA_0_ADDR, &pre_filter, 2, dev);
		} else {
			if (*data & BMI160_ACCEL_UNDERSAMPLING_MASK) {

				temp = *data & ~BMI160_ACCEL_UNDERSAMPLING_MASK;
				/* disable under-sampling parameter
				if already enabled */
				*data = temp;
				/* Write data */
				rslt = bmi160_set_regs(BMI160_ACCEL_CONFIG_ADDR, data, 1, dev);
			}
		}
	}

	return rslt;
}

/*!
 * @brief This API sets the gyro power mode.
 */
static int8_t set_gyro_pwr(struct bmi160_dev *dev)
{
	int8_t rslt = 0;

	if ((dev->gyro_cfg.power == BMI160_GYRO_SUSPEND_MODE) || (dev->gyro_cfg.power == BMI160_GYRO_NORMAL_MODE)
		|| (dev->gyro_cfg.power == BMI160_GYRO_FASTSTARTUP_MODE)) {

		if (dev->gyro_cfg.power != dev->prev_gyro_cfg.power) {

			/* Write gyro power */
			rslt = bmi160_set_regs(BMI160_COMMAND_REG_ADDR, &dev->gyro_cfg.power, 1, dev);
			if (dev->prev_gyro_cfg.power ==
				BMI160_GYRO_SUSPEND_MODE) {
				/* Delay of 81 ms */
				dev->delay_ms(BMI160_GYRO_DELAY_MS);
			} else if ((dev->prev_gyro_cfg.power == BMI160_GYRO_FASTSTARTUP_MODE)
				&& (dev->gyro_cfg.power == BMI160_GYRO_NORMAL_MODE)) {
				/* This delay is required for transition from
				fast-startup mode to normal mode */
				dev->delay_ms(10);
			} else {
				/* do nothing */
			}
			dev->prev_gyro_cfg.power = dev->gyro_cfg.power;
		}
	} else {
		rslt = BMI160_E_OUT_OF_RANGE;
	}

	return rslt;
}

/*!
 * @brief This API reads accel data along with sensor time if time is requested
 * by user. Kindly refer the user guide(README.md) for more info.
 */
static int8_t get_accel_data(uint8_t len, struct bmi160_sensor_data *accel, const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t idx = 0;
	uint8_t data_array[9] = {0};
	uint8_t time_0 = 0;
	uint16_t time_1 = 0;
	uint32_t time_2 = 0;
	uint8_t lsb;
	uint8_t msb;
	int16_t msblsb;

	/* read accel sensor data along with time if requested */
	rslt = bmi160_get_regs(BMI160_ACCEL_DATA_ADDR, data_array, 6 + len, dev);
	if (rslt == BMI160_OK) {

		/* Accel Data */
		lsb = data_array[idx++];
		msb = data_array[idx++];
		msblsb = (int16_t)((msb << 8) | lsb);
		accel->x = msblsb; /* Data in X axis */

		lsb = data_array[idx++];
		msb = data_array[idx++];
		msblsb = (int16_t)((msb << 8) | lsb);
		accel->y = msblsb; /* Data in Y axis */

		lsb = data_array[idx++];
		msb = data_array[idx++];
		msblsb = (int16_t)((msb << 8) | lsb);
		accel->z = msblsb; /* Data in Z axis */

		if (len == 3) {
			time_0 = data_array[idx++];
			time_1 = (uint16_t)(data_array[idx++] << 8);
			time_2 = (uint32_t)(data_array[idx++] << 16);
			accel->sensortime = (uint32_t)(time_2 | time_1 | time_0);
		} else {
			accel->sensortime = 0;
		}
	} else {
		rslt = BMI160_E_COM_FAIL;
	}

	return rslt;
}

/*!
 * @brief This API reads accel data along with sensor time if time is requested
 * by user. Kindly refer the user guide(README.md) for more info.
 */
static int8_t get_gyro_data(uint8_t len, struct bmi160_sensor_data *gyro, const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t idx = 0;
	uint8_t data_array[15] = {0};
	uint8_t time_0 = 0;
	uint16_t time_1 = 0;
	uint32_t time_2 = 0;
	uint8_t lsb;
	uint8_t msb;
	int16_t msblsb;

	if (len == 0) {
		/* read gyro data only */
		rslt = bmi160_get_regs(BMI160_GYRO_DATA_ADDR, data_array, 6, dev);
		if (rslt == BMI160_OK) {
			/* Gyro Data */
			lsb = data_array[idx++];
			msb = data_array[idx++];
			msblsb = (int16_t)((msb << 8) | lsb);
			gyro->x = msblsb; /* Data in X axis */

			lsb = data_array[idx++];
			msb = data_array[idx++];
			msblsb = (int16_t)((msb << 8) | lsb);
			gyro->y = msblsb; /* Data in Y axis */

			lsb = data_array[idx++];
			msb = data_array[idx++];
			msblsb = (int16_t)((msb << 8) | lsb);
			gyro->z = msblsb; /* Data in Z axis */
			gyro->sensortime = 0;

		} else {
			rslt = BMI160_E_COM_FAIL;
		}
	} else {
		/* read gyro sensor data along with time */
		rslt = bmi160_get_regs(BMI160_GYRO_DATA_ADDR, data_array, 12 + len, dev);
		if (rslt == BMI160_OK) {
			/* Gyro Data */
			lsb = data_array[idx++];
			msb = data_array[idx++];
			msblsb = (int16_t)((msb << 8) | lsb);
			gyro->x = msblsb; /* gyro X axis data */

			lsb = data_array[idx++];
			msb = data_array[idx++];
			msblsb = (int16_t)((msb << 8) | lsb);
			gyro->y = msblsb; /* gyro Y axis data */

			lsb = data_array[idx++];
			msb = data_array[idx++];
			msblsb = (int16_t)((msb << 8) | lsb);
			gyro->z = msblsb; /* gyro Z axis data */

			idx = idx + 6;
			time_0 = data_array[idx++];
			time_1 = (uint16_t)(data_array[idx++] << 8);
			time_2 = (uint32_t)(data_array[idx++] << 16);
			gyro->sensortime = (uint32_t)(time_2 | time_1 | time_0);

		} else {
			rslt = BMI160_E_COM_FAIL;
		}
	}

	return rslt;
}

/*!
 * @brief This API reads accel and gyro data along with sensor time
 * if time is requested by user.
 *  Kindly refer the user guide(README.md) for more info.
 */
static int8_t get_accel_gyro_data(uint8_t len, struct bmi160_sensor_data *accel, struct bmi160_sensor_data *gyro,
					const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t idx = 0;
	uint8_t data_array[15] = {0};
	uint8_t time_0 = 0;
	uint16_t time_1 = 0;
	uint32_t time_2 = 0;
	uint8_t lsb;
	uint8_t msb;
	int16_t msblsb;

	/* read both accel and gyro sensor data
	 * along with time if requested */
	rslt = bmi160_get_regs(BMI160_GYRO_DATA_ADDR, data_array, 12 + len, dev);
	if (rslt == BMI160_OK) {
		/* Gyro Data */
		lsb = data_array[idx++];
		msb = data_array[idx++];
		msblsb = (int16_t)((msb << 8) | lsb);
		gyro->x = msblsb; /* gyro X axis data */

		lsb = data_array[idx++];
		msb = data_array[idx++];
		msblsb = (int16_t)((msb << 8) | lsb);
		gyro->y = msblsb; /* gyro Y axis data */

		lsb = data_array[idx++];
		msb = data_array[idx++];
		msblsb = (int16_t)((msb << 8) | lsb);
		gyro->z = msblsb; /* gyro Z axis data */

		/* Accel Data */
		lsb = data_array[idx++];
		msb = data_array[idx++];
		msblsb = (int16_t)((msb << 8) | lsb);
		accel->x = (int16_t)msblsb; /* accel X axis data */

		lsb = data_array[idx++];
		msb = data_array[idx++];
		msblsb = (int16_t)((msb << 8) | lsb);
		accel->y = (int16_t)msblsb; /* accel Y axis data */

		lsb = data_array[idx++];
		msb = data_array[idx++];
		msblsb = (int16_t)((msb << 8) | lsb);
		accel->z = (int16_t)msblsb; /* accel Z axis data */

		if (len == 3) {
			time_0 = data_array[idx++];
			time_1 = (uint16_t)(data_array[idx++] << 8);
			time_2 = (uint32_t)(data_array[idx++] << 16);
			accel->sensortime = (uint32_t)(time_2 | time_1 | time_0);
			gyro->sensortime = (uint32_t)(time_2 | time_1 | time_0);
		} else {
			accel->sensortime = 0;
			gyro->sensortime = 0;
		}
	} else {
		rslt = BMI160_E_COM_FAIL;
	}

	return rslt;
}

/*!
 * @brief This API enables the any-motion interrupt for accel.
 */
static int8_t enable_accel_any_motion_int(const struct bmi160_acc_any_mot_int_cfg *any_motion_int_cfg,
						struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data = 0;
	uint8_t temp = 0;

	/* Enable any motion x, any motion y, any motion z
	in Int Enable 0 register */
	rslt = bmi160_get_regs(BMI160_INT_ENABLE_0_ADDR, &data, 1, dev);
	if (rslt == BMI160_OK) {

		if (any_motion_int_cfg->anymotion_en == BMI160_ENABLE) {
			temp = data & ~BMI160_ANY_MOTION_X_INT_EN_MASK;
			/* Adding Any_motion x axis */
			data = temp | (any_motion_int_cfg->anymotion_x & BMI160_ANY_MOTION_X_INT_EN_MASK);


			temp = data & ~BMI160_ANY_MOTION_Y_INT_EN_MASK;
			/* Adding Any_motion y axis */
			data = temp | ((any_motion_int_cfg->anymotion_y << 1) & BMI160_ANY_MOTION_Y_INT_EN_MASK);


			temp = data & ~BMI160_ANY_MOTION_Z_INT_EN_MASK;
			/* Adding Any_motion z axis */
			data = temp | ((any_motion_int_cfg->anymotion_z << 2) & BMI160_ANY_MOTION_Z_INT_EN_MASK);

			/* any-motion feature selected*/
			dev->any_sig_sel = BMI160_ANY_MOTION_ENABLED;
		} else {
			data = data & ~BMI160_ANY_MOTION_ALL_INT_EN_MASK;
			/* neither any-motion feature nor sig-motion selected */
			dev->any_sig_sel = BMI160_BOTH_ANY_SIG_MOTION_DISABLED;
		}

		/* write data to Int Enable 0 register */
		rslt = bmi160_set_regs(BMI160_INT_ENABLE_0_ADDR, &data, 1, dev);
	}

	return rslt;
}

/*!
 * @brief This API disable the sig-motion interrupt.
 */
static int8_t disable_sig_motion_int(const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data = 0;
	uint8_t temp = 0;

	/* Disabling Significant motion interrupt if enabled */
	rslt = bmi160_get_regs(BMI160_INT_MOTION_3_ADDR, &data, 1, dev);
	if (rslt == BMI160_OK) {
		temp = (data & BMI160_SIG_MOTION_SEL_MASK);
		if (temp) {
			temp = data & ~BMI160_SIG_MOTION_SEL_MASK;
			data = temp;
			/* Write data to register */
			rslt = bmi160_set_regs(BMI160_INT_MOTION_3_ADDR, &data, 1, dev);
		}
	}
	return rslt;
}

/*!
 *  @brief This API is used to map/unmap the Any/Sig motion, Step det/Low-g,
 *  Double tap, Single tap, Orientation, Flat, High-G, Nomotion interrupt pins.
 */
static int8_t map_feature_interrupt(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data[3] = {0, 0, 0};
	uint8_t temp[3] = {0, 0, 0};

	rslt = bmi160_get_regs(BMI160_INT_MAP_0_ADDR, data, 3, dev);

	if (rslt == BMI160_OK) {
		temp[0] = data[0] & ~int_mask_lookup_table[int_config->int_type];
		temp[2] = data[2] & ~int_mask_lookup_table[int_config->int_type];

		switch (int_config->int_channel) {
		case BMI160_INT_CHANNEL_NONE:
			data[0] = temp[0];
			data[2] = temp[2];
			break;
		case BMI160_INT_CHANNEL_1:
			data[0] = temp[0] | int_mask_lookup_table[int_config->int_type];
			data[2] = temp[2];
			break;
		case BMI160_INT_CHANNEL_2:
			data[2] = temp[2] | int_mask_lookup_table[int_config->int_type];
			data[0] = temp[0];
			break;
		case BMI160_INT_CHANNEL_BOTH:
			data[0] = temp[0] | int_mask_lookup_table[int_config->int_type];
			data[2] = temp[2] | int_mask_lookup_table[int_config->int_type];
			break;
		default:
			rslt = BMI160_E_OUT_OF_RANGE;
		}
		if (rslt == BMI160_OK)
			rslt = bmi160_set_regs(BMI160_INT_MAP_0_ADDR, data, 3, dev);
	}

	return rslt;
}

/*!
 *  @brief This API is used to map/unmap the Dataready(Accel & Gyro), FIFO full
 *  and FIFO watermark interrupt.
 */
static int8_t map_hardware_interrupt(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data = 0;
	uint8_t temp = 0;

	rslt = bmi160_get_regs(BMI160_INT_MAP_1_ADDR, &data, 1, dev);

	if (rslt == BMI160_OK) {
		temp = data & ~int_mask_lookup_table[int_config->int_type];
		temp = temp & ~((uint8_t)(int_mask_lookup_table[int_config->int_type] << 4));
		switch (int_config->int_channel) {
		case BMI160_INT_CHANNEL_NONE:
			data = temp;
			break;
		case BMI160_INT_CHANNEL_1:
			data = temp | (uint8_t)((int_mask_lookup_table[int_config->int_type]) << 4);
			break;
		case BMI160_INT_CHANNEL_2:
			data = temp | int_mask_lookup_table[int_config->int_type];
			break;
		case BMI160_INT_CHANNEL_BOTH:
			data = temp | int_mask_lookup_table[int_config->int_type];
			data = data | (uint8_t)((int_mask_lookup_table[int_config->int_type]) << 4);
			break;
		default:
			rslt = BMI160_E_OUT_OF_RANGE;
		}
		if (rslt == BMI160_OK)
			rslt = bmi160_set_regs(BMI160_INT_MAP_1_ADDR, &data, 1, dev);
	}

	return rslt;
}

/*!
 * @brief This API configure the source of data(filter & pre-filter)
 * for any-motion interrupt.
 */
static int8_t config_any_motion_src(const struct bmi160_acc_any_mot_int_cfg *any_motion_int_cfg,
					const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data = 0;
	uint8_t temp = 0;

	/* Configure Int data 1 register to add source of interrupt */
	rslt = bmi160_get_regs(BMI160_INT_DATA_1_ADDR, &data, 1, dev);
	if (rslt == BMI160_OK) {
		temp = data & ~BMI160_MOTION_SRC_INT_MASK;
		data = temp | ((any_motion_int_cfg->anymotion_data_src << 7) & BMI160_MOTION_SRC_INT_MASK);
		/* Write data to DATA 1 address */
		rslt = bmi160_set_regs(BMI160_INT_DATA_1_ADDR, &data, 1, dev);
	}

	return rslt;
}

/*!
 * @brief This API configure the duration and threshold of
 * any-motion interrupt.
 */
static int8_t config_any_dur_threshold(const struct bmi160_acc_any_mot_int_cfg *any_motion_int_cfg,
					const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data = 0;
	uint8_t temp = 0;
	uint8_t data_array[2] = {0};
	uint8_t dur;

	/* Configure Int Motion 0 register */
	rslt = bmi160_get_regs(BMI160_INT_MOTION_0_ADDR, &data, 1, dev);
	if (rslt == BMI160_OK) {
		/* slope duration */
		dur = (uint8_t)any_motion_int_cfg->anymotion_dur;
		temp = data & ~BMI160_SLOPE_INT_DUR_MASK;
		data = temp | (dur & BMI160_MOTION_SRC_INT_MASK);
		data_array[0] = data;
		/* add slope threshold */
		data_array[1] = any_motion_int_cfg->anymotion_thr;

		/* INT MOTION 0 and INT MOTION 1 address lie consecutively,
		hence writing data to respective registers at one go */
		/* Writing to Int_motion 0 and
		Int_motion 1 Address simultaneously */
		rslt = bmi160_set_regs(BMI160_INT_MOTION_0_ADDR, data_array, 2, dev);
	}

	return rslt;
}

/*!
 * @brief This API configure necessary setting of any-motion interrupt.
 */
static int8_t config_any_motion_int_settg(const struct bmi160_int_settg *int_config,
					const struct bmi160_acc_any_mot_int_cfg *any_motion_int_cfg,
					const struct bmi160_dev *dev)
{
	int8_t rslt;
	/* Configure Interrupt pins */
	rslt = set_intr_pin_config(int_config, dev);
	if (rslt == BMI160_OK) {
		rslt = disable_sig_motion_int(dev);
		if (rslt == BMI160_OK) {
			rslt = map_feature_interrupt(int_config, dev);
			if (rslt == BMI160_OK) {
				rslt = config_any_motion_src(any_motion_int_cfg, dev);
				if (rslt == BMI160_OK)
					rslt = config_any_dur_threshold(any_motion_int_cfg, dev);
			}
		}
	}

	return rslt;
}

/*!
 * @brief This API enable the data ready interrupt.
 */
static int8_t enable_data_ready_int(const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data = 0;
	uint8_t temp = 0;

	/* Enable data ready interrupt in Int Enable 1 register */
	rslt = bmi160_get_regs(BMI160_INT_ENABLE_1_ADDR, &data, 1, dev);
	if (rslt == BMI160_OK) {
		temp = data & ~BMI160_DATA_RDY_INT_EN_MASK;
		data = temp | ((1 << 4) & BMI160_DATA_RDY_INT_EN_MASK);
		/* Writing data to INT ENABLE 1 Address */
		rslt = bmi160_set_regs(BMI160_INT_ENABLE_1_ADDR, &data, 1, dev);
	}

	return rslt;
}

/*!
 * @brief This API enables the no motion/slow motion interrupt.
 */
static int8_t enable_no_motion_int(const struct bmi160_acc_no_motion_int_cfg *no_mot_int_cfg,
					const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data = 0;
	uint8_t temp = 0;
	/* Enable no motion x, no motion y, no motion z
	in Int Enable 2 register */
	rslt = bmi160_get_regs(BMI160_INT_ENABLE_2_ADDR, &data, 1, dev);
	if (rslt == BMI160_OK) {
		if (no_mot_int_cfg->no_motion_x == 1) {
			temp = data & ~BMI160_NO_MOTION_X_INT_EN_MASK;
			/* Adding No_motion x axis */
			data = temp | (1 & BMI160_NO_MOTION_X_INT_EN_MASK);
		}
		if (no_mot_int_cfg->no_motion_y == 1) {
			temp = data & ~BMI160_NO_MOTION_Y_INT_EN_MASK;
			/* Adding No_motion x axis */
			data = temp | ((1 << 1) & BMI160_NO_MOTION_Y_INT_EN_MASK);
		}
		if (no_mot_int_cfg->no_motion_z == 1) {
			temp = data & ~BMI160_NO_MOTION_Z_INT_EN_MASK;
			/* Adding No_motion x axis */
			data = temp | ((1 << 2) & BMI160_NO_MOTION_Z_INT_EN_MASK);
		}
		/* write data to Int Enable 2 register */
		rslt = bmi160_set_regs(BMI160_INT_ENABLE_2_ADDR, &data, 1, dev);
	}

	return rslt;
}

/*!
 * @brief This API configure the interrupt PIN setting for
 * no motion/slow motion interrupt.
 */
static int8_t config_no_motion_int_settg(const struct bmi160_int_settg *int_config,
					const struct bmi160_acc_no_motion_int_cfg *no_mot_int_cfg,
					const struct bmi160_dev *dev)
{
	int8_t rslt;

	/* Configure Interrupt pins */
	rslt = set_intr_pin_config(int_config, dev);
	if (rslt == BMI160_OK) {
		rslt = map_feature_interrupt(int_config, dev);
		if (rslt == BMI160_OK) {
			rslt = config_no_motion_data_src(no_mot_int_cfg, dev);
			if (rslt == BMI160_OK)
				rslt = config_no_motion_dur_thr(no_mot_int_cfg, dev);
		}
	}

	return rslt;
}


/*!
 * @brief This API configure the source of interrupt for no motion.
 */
static int8_t config_no_motion_data_src(const struct bmi160_acc_no_motion_int_cfg *no_mot_int_cfg,
					const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data = 0;
	uint8_t temp = 0;

	/* Configure Int data 1 register to add source of interrupt */
	rslt = bmi160_get_regs(BMI160_INT_DATA_1_ADDR, &data, 1, dev);
	if (rslt == BMI160_OK) {
		temp = data & ~BMI160_MOTION_SRC_INT_MASK;
		data = temp | ((no_mot_int_cfg->no_motion_src << 7) & BMI160_MOTION_SRC_INT_MASK);
		/* Write data to DATA 1 address */
		rslt = bmi160_set_regs(BMI160_INT_DATA_1_ADDR, &data, 1, dev);
	}

	return rslt;
}

/*!
 * @brief This API configure the duration and threshold of
 * no motion/slow motion interrupt along with selection of no/slow motion.
 */
static int8_t config_no_motion_dur_thr(const struct bmi160_acc_no_motion_int_cfg *no_mot_int_cfg,
					const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data = 0;
	uint8_t temp = 0;
	uint8_t temp_1 = 0;
	uint8_t reg_addr;
	uint8_t data_array[2] = {0};

	/* Configuring INT_MOTION register */
	reg_addr = BMI160_INT_MOTION_0_ADDR;
	rslt = bmi160_get_regs(reg_addr, &data, 1, dev);
	if (rslt == BMI160_OK) {
		temp = data & ~BMI160_NO_MOTION_INT_DUR_MASK;
		/* Adding no_motion duration */
		data = temp | ((no_mot_int_cfg->no_motion_dur << 2) & BMI160_NO_MOTION_INT_DUR_MASK);
		/* Write data to NO_MOTION 0 address */
		rslt = bmi160_set_regs(reg_addr, &data, 1, dev);
		if (rslt == BMI160_OK) {
			reg_addr = BMI160_INT_MOTION_3_ADDR;
			rslt = bmi160_get_regs(reg_addr, &data, 1, dev);
			if (rslt == BMI160_OK) {
				temp = data & ~BMI160_NO_MOTION_SEL_BIT_MASK;
				/* Adding no_motion_sel bit */
				temp_1 = (no_mot_int_cfg->no_motion_sel & BMI160_NO_MOTION_SEL_BIT_MASK);
				data = (temp | temp_1);
				data_array[1] = data;
				/* Adding no motion threshold */
				data_array[0] = no_mot_int_cfg->no_motion_thres;
				reg_addr = BMI160_INT_MOTION_2_ADDR;
				/* writing data to INT_MOTION 2 and INT_MOTION 3
				 * address simultaneously */
				rslt = bmi160_set_regs(reg_addr, data_array, 2, dev);
			}
		}
	}

	return rslt;
}

/*!
 * @brief This API enables the sig-motion motion interrupt.
 */
static int8_t enable_sig_motion_int(const struct bmi160_acc_sig_mot_int_cfg *sig_mot_int_cfg, struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data = 0;
	uint8_t temp = 0;

	/* For significant motion,enable any motion x,any motion y,
	 * any motion z in Int Enable 0 register */
	rslt = bmi160_get_regs(BMI160_INT_ENABLE_0_ADDR, &data, 1, dev);
	if (rslt == BMI160_OK) {
		if (sig_mot_int_cfg->sig_en == BMI160_ENABLE) {
			temp = data & ~BMI160_SIG_MOTION_INT_EN_MASK;
			data = temp | (7 & BMI160_SIG_MOTION_INT_EN_MASK);
			/* sig-motion feature selected*/
			dev->any_sig_sel = BMI160_SIG_MOTION_ENABLED;
		} else {
			data = data & ~BMI160_SIG_MOTION_INT_EN_MASK;
			/* neither any-motion feature nor sig-motion selected */
			dev->any_sig_sel = BMI160_BOTH_ANY_SIG_MOTION_DISABLED;
		}
		/* write data to Int Enable 0 register */
		rslt = bmi160_set_regs(BMI160_INT_ENABLE_0_ADDR, &data, 1, dev);
	}
	return rslt;
}

/*!
 * @brief This API configure the interrupt PIN setting for
 * significant motion interrupt.
 */
static int8_t config_sig_motion_int_settg(const struct bmi160_int_settg *int_config,
					const struct bmi160_acc_sig_mot_int_cfg *sig_mot_int_cfg,
					const struct bmi160_dev *dev)
{
	int8_t rslt;

	/* Configure Interrupt pins */
	rslt = set_intr_pin_config(int_config, dev);
	if (rslt == BMI160_OK) {
		rslt = map_feature_interrupt(int_config, dev);
		if (rslt == BMI160_OK) {
			rslt = config_sig_motion_data_src(sig_mot_int_cfg, dev);
			if (rslt == BMI160_OK)
				rslt = config_sig_dur_threshold(sig_mot_int_cfg, dev);
		}
	}

	return rslt;
}

/*!
 * @brief This API configure the source of data(filter & pre-filter)
 * for sig motion interrupt.
 */
static int8_t config_sig_motion_data_src(const struct bmi160_acc_sig_mot_int_cfg *sig_mot_int_cfg,
					const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data = 0;
	uint8_t temp = 0;

	/* Configure Int data 1 register to add source of interrupt */
	rslt = bmi160_get_regs(BMI160_INT_DATA_1_ADDR, &data, 1, dev);
	if (rslt == BMI160_OK) {
		temp = data & ~BMI160_MOTION_SRC_INT_MASK;
		data = temp | ((sig_mot_int_cfg->sig_data_src << 7) & BMI160_MOTION_SRC_INT_MASK);
		/* Write data to DATA 1 address */
		rslt = bmi160_set_regs(BMI160_INT_DATA_1_ADDR, &data, 1, dev);
	}

	return rslt;
}

/*!
 * @brief This API configure the threshold, skip and proof time of
 * sig motion interrupt.
 */
static int8_t config_sig_dur_threshold(const struct bmi160_acc_sig_mot_int_cfg *sig_mot_int_cfg,
					const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data;
	uint8_t temp = 0;

	/* Configuring INT_MOTION registers */
	/* Write significant motion threshold.
	 * This threshold is same as any motion threshold */
	data = sig_mot_int_cfg->sig_mot_thres;
	/* Write data to INT_MOTION 1 address */
	rslt = bmi160_set_regs(BMI160_INT_MOTION_1_ADDR, &data, 1, dev);
	if (rslt == BMI160_OK) {
		rslt = bmi160_get_regs(BMI160_INT_MOTION_3_ADDR, &data, 1, dev);
		if (rslt == BMI160_OK) {
			temp = data & ~BMI160_SIG_MOTION_SKIP_MASK;
			/* adding skip time of sig_motion interrupt*/
			data = temp | ((sig_mot_int_cfg->sig_mot_skip << 2) & BMI160_SIG_MOTION_SKIP_MASK);
			temp = data & ~BMI160_SIG_MOTION_PROOF_MASK;
			 /* adding proof time of sig_motion interrupt */
			data = temp | ((sig_mot_int_cfg->sig_mot_proof << 4) & BMI160_SIG_MOTION_PROOF_MASK);
			/* configure the int_sig_mot_sel bit to select
			 * significant motion interrupt */
			temp = data & ~BMI160_SIG_MOTION_SEL_MASK;
			data = temp | ((sig_mot_int_cfg->sig_en << 1) & BMI160_SIG_MOTION_SEL_MASK);

			rslt = bmi160_set_regs(BMI160_INT_MOTION_3_ADDR, &data, 1, dev);
		}
	}
	return rslt;
}

/*!
 * @brief This API enables the step detector interrupt.
 */
static int8_t enable_step_detect_int(const struct bmi160_acc_step_detect_int_cfg *step_detect_int_cfg,
					const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data = 0;
	uint8_t temp = 0;

	/* Enable data ready interrupt in Int Enable 2 register */
	rslt = bmi160_get_regs(BMI160_INT_ENABLE_2_ADDR, &data, 1, dev);
	if (rslt == BMI160_OK) {
		temp = data & ~BMI160_STEP_DETECT_INT_EN_MASK;
		data = temp | ((step_detect_int_cfg->step_detector_en << 3) & BMI160_STEP_DETECT_INT_EN_MASK);
		/* Writing data to INT ENABLE 2 Address */
		rslt = bmi160_set_regs(BMI160_INT_ENABLE_2_ADDR, &data, 1, dev);
	}
	return rslt;
}

/*!
 * @brief This API configure the step detector parameter.
 */
static int8_t config_step_detect(const struct bmi160_acc_step_detect_int_cfg *step_detect_int_cfg,
				const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t temp = 0;
	uint8_t data_array[2] = {0};


	if (step_detect_int_cfg->step_detector_mode == BMI160_STEP_DETECT_NORMAL) {
		/* Normal mode setting */
		data_array[0] = 0x15;
		data_array[1] = 0x03;
	} else if (step_detect_int_cfg->step_detector_mode == BMI160_STEP_DETECT_SENSITIVE) {
		/* Sensitive mode setting */
		data_array[0] = 0x2D;
		data_array[1] = 0x00;
	} else if (step_detect_int_cfg->step_detector_mode == BMI160_STEP_DETECT_ROBUST) {
		/* Robust mode setting */
		data_array[0] = 0x1D;
		data_array[1] = 0x07;
	} else if (step_detect_int_cfg->step_detector_mode == BMI160_STEP_DETECT_USER_DEFINE) {
		/* Non recommended User defined setting */
		/* Configuring STEP_CONFIG register */
		rslt = bmi160_get_regs(BMI160_INT_STEP_CONFIG_0_ADDR, &data_array[0], 2, dev);

		if (rslt == BMI160_OK) {
			temp = data_array[0] & ~BMI160_STEP_DETECT_MIN_THRES_MASK;
			/* Adding min_threshold */
			data_array[0] = temp | ((step_detect_int_cfg->min_threshold << 3)
					& BMI160_STEP_DETECT_MIN_THRES_MASK);

			temp = data_array[0] & ~BMI160_STEP_DETECT_STEPTIME_MIN_MASK;
			/* Adding steptime_min */
			data_array[0] = temp | ((step_detect_int_cfg->steptime_min)
					& BMI160_STEP_DETECT_STEPTIME_MIN_MASK);

			temp = data_array[1] & ~BMI160_STEP_MIN_BUF_MASK;
			/* Adding steptime_min */
			data_array[1] = temp | ((step_detect_int_cfg->step_min_buf) & BMI160_STEP_MIN_BUF_MASK);

		}
	}

	/* Write data to STEP_CONFIG register */
	rslt = bmi160_set_regs(BMI160_INT_STEP_CONFIG_0_ADDR, data_array, 2, dev);

	return rslt;
}

/*!
 * @brief This API enables the single/double tap interrupt.
 */
static int8_t enable_tap_int(const struct bmi160_int_settg *int_config,
				const struct bmi160_acc_tap_int_cfg *tap_int_cfg,
				const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data = 0;
	uint8_t temp = 0;

	/* Enable single tap or double tap interrupt in Int Enable 0 register */
	rslt = bmi160_get_regs(BMI160_INT_ENABLE_0_ADDR, &data, 1, dev);
	if (rslt == BMI160_OK) {
		if (int_config->int_type == BMI160_ACC_SINGLE_TAP_INT) {
			temp = data & ~BMI160_SINGLE_TAP_INT_EN_MASK;
			data = temp | ((tap_int_cfg->tap_en << 5) & BMI160_SINGLE_TAP_INT_EN_MASK);
		} else {
			temp = data & ~BMI160_DOUBLE_TAP_INT_EN_MASK;
			data = temp | ((tap_int_cfg->tap_en << 4) & BMI160_DOUBLE_TAP_INT_EN_MASK);
		}
		/* Write to Enable 0 Address */
		rslt = bmi160_set_regs(BMI160_INT_ENABLE_0_ADDR, &data, 1, dev);
	}
	return rslt;
}

/*!
 * @brief This API configure the interrupt PIN setting for
 * tap interrupt.
 */
static int8_t config_tap_int_settg(const struct bmi160_int_settg *int_config,
					const struct bmi160_acc_tap_int_cfg *tap_int_cfg,
					const struct bmi160_dev *dev)
{
	int8_t rslt;

	/* Configure Interrupt pins */
	rslt = set_intr_pin_config(int_config, dev);
	if (rslt == BMI160_OK) {
		rslt = map_feature_interrupt(int_config, dev);
		if (rslt == BMI160_OK) {
			rslt = config_tap_data_src(tap_int_cfg, dev);
			if (rslt == BMI160_OK)
				rslt = config_tap_param(int_config, tap_int_cfg, dev);
		}
	}

	return rslt;
}

/*!
 * @brief This API configure the source of data(filter & pre-filter)
 * for tap interrupt.
 */
static int8_t config_tap_data_src(const struct bmi160_acc_tap_int_cfg *tap_int_cfg, const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data = 0;
	uint8_t temp = 0;

	/* Configure Int data 0 register to add source of interrupt */
	rslt = bmi160_get_regs(BMI160_INT_DATA_0_ADDR, &data, 1, dev);
	if (rslt == BMI160_OK) {
		temp = data & ~BMI160_TAP_SRC_INT_MASK;
		data = temp | ((tap_int_cfg->tap_data_src << 3) & BMI160_TAP_SRC_INT_MASK);
		/* Write data to Data 0 address */
		rslt = bmi160_set_regs(BMI160_INT_DATA_0_ADDR, &data, 1, dev);
	}

	return rslt;
}

/*!
 * @brief This API configure the  parameters of tap interrupt.
 * Threshold, quite, shock, and duration.
 */
static int8_t config_tap_param(const struct bmi160_int_settg *int_config,
				const struct bmi160_acc_tap_int_cfg *tap_int_cfg,
				const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t temp = 0;
	uint8_t data = 0;
	uint8_t data_array[2] = {0};
	uint8_t count = 0;
	uint8_t dur, shock, quiet, thres;

	/* Configure tap 0 register for tap shock,tap quiet duration
	 * in case of single tap interrupt */
	rslt = bmi160_get_regs(BMI160_INT_TAP_0_ADDR, data_array, 2, dev);
	if (rslt == BMI160_OK) {
		data = data_array[count];

		if (int_config->int_type == BMI160_ACC_DOUBLE_TAP_INT) {
			dur  = (uint8_t)tap_int_cfg->tap_dur;
			temp = (data & ~BMI160_TAP_DUR_MASK);
			/* Add tap duration data in case of
			 * double tap interrupt */
			data = temp | (dur & BMI160_TAP_DUR_MASK);
		}

		shock = (uint8_t)tap_int_cfg->tap_shock;
		temp = data & ~BMI160_TAP_SHOCK_DUR_MASK;
		data = temp | ((shock << 6) & BMI160_TAP_SHOCK_DUR_MASK);

		quiet = (uint8_t)tap_int_cfg->tap_quiet;
		temp = data & ~BMI160_TAP_QUIET_DUR_MASK;
		data = temp | ((quiet << 7) & BMI160_TAP_QUIET_DUR_MASK);

		data_array[count++] = data;

		data = data_array[count];
		thres = (uint8_t)tap_int_cfg->tap_thr;
		temp = data & ~BMI160_TAP_THRES_MASK;
		data = temp | (thres & BMI160_TAP_THRES_MASK);

		data_array[count++] = data;
		/* TAP 0 and TAP 1 address lie consecutively,
		hence writing data to respective registers at one go */
		/* Writing to Tap 0 and Tap 1 Address simultaneously */
		rslt = bmi160_set_regs(BMI160_INT_TAP_0_ADDR, data_array, count, dev);
	}

	return rslt;
}

/*!
 * @brief This API configure the secondary interface.
 */
static int8_t config_sec_if(const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t if_conf = 0;
	uint8_t cmd = BMI160_AUX_NORMAL_MODE;

	/* set the aux power mode to normal*/
	rslt = bmi160_set_regs(BMI160_COMMAND_REG_ADDR, &cmd, 1, dev);
	if (rslt == BMI160_OK) {
		dev->delay_ms(60);
		rslt = bmi160_get_regs(BMI160_IF_CONF_ADDR, &if_conf, 1, dev);
		if_conf |= (uint8_t)(1 << 5);
		if (rslt == BMI160_OK)
			/*enable the secondary interface also*/
			rslt = bmi160_set_regs(BMI160_IF_CONF_ADDR, &if_conf, 1, dev);
	}

	return rslt;
}

/*!
 * @brief This API configure the ODR of the auxiliary sensor.
 */
static int8_t config_aux_odr(const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t aux_odr;

	rslt = bmi160_get_regs(BMI160_AUX_ODR_ADDR, &aux_odr, 1, dev);
	if (rslt == BMI160_OK) {
		aux_odr = (uint8_t)(dev->aux_cfg.aux_odr);
		/* Set the secondary interface ODR
		   i.e polling rate of secondary sensor */
		rslt = bmi160_set_regs(BMI160_AUX_ODR_ADDR, &aux_odr, 1, dev);
		dev->delay_ms(BMI160_AUX_COM_DELAY);
	}

	return rslt;
}

/*!
 * @brief This API maps the actual burst read length set by user.
 */
static int8_t map_read_len(uint16_t *len, const struct bmi160_dev *dev)
{
	int8_t rslt = BMI160_OK;

	switch (dev->aux_cfg.aux_rd_burst_len) {

	case BMI160_AUX_READ_LEN_0:
		*len = 1;
		break;
	case BMI160_AUX_READ_LEN_1:
		*len = 2;
		break;
	case BMI160_AUX_READ_LEN_2:
		*len = 6;
		break;
	case BMI160_AUX_READ_LEN_3:
		*len = 8;
		break;
	default:
		rslt = BMI160_E_INVALID_INPUT;
		break;
	}

	return rslt;
}

/*!
 * @brief This API configure the settings of auxiliary sensor.
 */
static int8_t config_aux_settg(const struct bmi160_dev *dev)
{
	int8_t rslt;

	rslt = config_sec_if(dev);
	if (rslt == BMI160_OK) {
		/* Configures the auxiliary interface settings */
		rslt = bmi160_config_aux_mode(dev);
	}

	return rslt;
}

/*!
 * @brief This API extract the read data from auxiliary sensor.
 */
static int8_t extract_aux_read(uint16_t map_len, uint8_t reg_addr, uint8_t *aux_data, uint16_t len,
											const struct bmi160_dev *dev)
{
	int8_t rslt = BMI160_OK;
	uint8_t data[8] = {0,};
	uint8_t read_addr = BMI160_AUX_DATA_ADDR;
	uint8_t count = 0;
	uint8_t read_count;
	uint8_t read_len = (uint8_t)map_len;

	for (; count < len;) {
		/* set address to read */
		rslt = bmi160_set_regs(BMI160_AUX_IF_2_ADDR, &reg_addr, 1, dev);
		dev->delay_ms(BMI160_AUX_COM_DELAY);
		if (rslt == BMI160_OK) {
			rslt = bmi160_get_regs(read_addr, data, map_len, dev);
			if (rslt == BMI160_OK) {
				read_count = 0;
				/* if read len is less the burst read len
				 * mention by user*/
				if (len < map_len) {
					read_len = (uint8_t)len;
				} else {
					if ((len - count) < map_len)
						read_len = (uint8_t)(len - count);
				}

				for (; read_count < read_len; read_count++)
					aux_data[count + read_count] = data[read_count];

				reg_addr += (uint8_t)map_len;
				count += (uint8_t)map_len;
			} else {
				rslt = BMI160_E_COM_FAIL;
				break;
			}
		}
	}

	return rslt;
}

/*!
 * @brief This API enables the orient interrupt.
 */
static int8_t enable_orient_int(const struct bmi160_acc_orient_int_cfg *orient_int_cfg, const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data = 0;
	uint8_t temp = 0;

	/* Enable data ready interrupt in Int Enable 0 register */
	rslt = bmi160_get_regs(BMI160_INT_ENABLE_0_ADDR, &data, 1, dev);
	if (rslt == BMI160_OK) {
		temp = data & ~BMI160_ORIENT_INT_EN_MASK;
		data = temp | ((orient_int_cfg->orient_en << 6) & BMI160_ORIENT_INT_EN_MASK);
		/* write data to Int Enable 0 register */
		rslt = bmi160_set_regs(BMI160_INT_ENABLE_0_ADDR, &data, 1, dev);
	}

	return rslt;
}


/*!
 * @brief This API configure the necessary setting of orientation interrupt.
 */
static int8_t config_orient_int_settg(const struct bmi160_acc_orient_int_cfg *orient_int_cfg,
					const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data = 0;
	uint8_t temp = 0;
	uint8_t data_array[2] = {0, 0};

	/* Configuring INT_ORIENT registers */
	rslt = bmi160_get_regs(BMI160_INT_ORIENT_0_ADDR, data_array, 2, dev);
	if (rslt == BMI160_OK) {
		data = data_array[0];
		temp = data & ~BMI160_ORIENT_MODE_MASK;
		/* Adding Orientation mode */
		data = temp | ((orient_int_cfg->orient_mode) & BMI160_ORIENT_MODE_MASK);
		temp = data & ~BMI160_ORIENT_BLOCK_MASK;
		/* Adding Orientation blocking */
		data = temp | ((orient_int_cfg->orient_blocking << 2) & BMI160_ORIENT_BLOCK_MASK);
		temp = data & ~BMI160_ORIENT_HYST_MASK;
		 /* Adding Orientation hysteresis */
		data = temp | ((orient_int_cfg->orient_hyst << 4) & BMI160_ORIENT_HYST_MASK);
		data_array[0] = data;

		data = data_array[1];
		temp = data & ~BMI160_ORIENT_THETA_MASK;
		/* Adding Orientation threshold */
		data = temp | ((orient_int_cfg->orient_theta) & BMI160_ORIENT_THETA_MASK);
		temp = data & ~BMI160_ORIENT_UD_ENABLE;
		/* Adding Orient_ud_en */
		data = temp | ((orient_int_cfg->orient_ud_en << 6) & BMI160_ORIENT_UD_ENABLE);
		temp = data & ~BMI160_AXES_EN_MASK;
		/* Adding axes_en */
		data = temp | ((orient_int_cfg->axes_ex << 7) & BMI160_AXES_EN_MASK);
		data_array[1] = data;
		/* Writing data to INT_ORIENT 0 and INT_ORIENT 1
		 * registers simultaneously */
		rslt = bmi160_set_regs(BMI160_INT_ORIENT_0_ADDR, data_array, 2, dev);
	}

	return rslt;
}

/*!
 * @brief This API enables the flat interrupt.
 */
static int8_t enable_flat_int(const struct bmi160_acc_flat_detect_int_cfg *flat_int, const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data = 0;
	uint8_t temp = 0;

	/* Enable flat interrupt in Int Enable 0 register */
	rslt = bmi160_get_regs(BMI160_INT_ENABLE_0_ADDR, &data, 1, dev);
	if (rslt == BMI160_OK) {
		temp = data & ~BMI160_FLAT_INT_EN_MASK;
		data = temp | ((flat_int->flat_en << 7) & BMI160_FLAT_INT_EN_MASK);
		/* write data to Int Enable 0 register */
		rslt = bmi160_set_regs(BMI160_INT_ENABLE_0_ADDR, &data, 1, dev);
	}

	return rslt;
}


/*!
 * @brief This API configure the necessary setting of flat interrupt.
 */
static int8_t config_flat_int_settg(const struct bmi160_acc_flat_detect_int_cfg *flat_int, const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data = 0;
	uint8_t temp = 0;
	uint8_t data_array[2] = {0, 0};

	/* Configuring INT_FLAT register */
	rslt = bmi160_get_regs(BMI160_INT_FLAT_0_ADDR, data_array, 2, dev);
	if (rslt == BMI160_OK) {
		data = data_array[0];
		temp = data & ~BMI160_FLAT_THRES_MASK;
		/* Adding flat theta */
		data = temp | ((flat_int->flat_theta) & BMI160_FLAT_THRES_MASK);
		data_array[0] = data;

		data = data_array[1];
		temp = data & ~BMI160_FLAT_HOLD_TIME_MASK;
		/* Adding flat hold time */
		data = temp | ((flat_int->flat_hold_time << 4) & BMI160_FLAT_HOLD_TIME_MASK);
		temp = data & ~BMI160_FLAT_HYST_MASK;
		/* Adding flat hysteresis */
		data = temp | ((flat_int->flat_hy) & BMI160_FLAT_HYST_MASK);
		data_array[1] = data;
		/* Writing data to INT_FLAT 0 and INT_FLAT 1
		 * registers simultaneously */
		rslt = bmi160_set_regs(BMI160_INT_FLAT_0_ADDR, data_array, 2, dev);
	}

	return rslt;
}

/*!
 * @brief This API enables the Low-g interrupt.
 */
static int8_t enable_low_g_int(const struct bmi160_acc_low_g_int_cfg *low_g_int, const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data = 0;
	uint8_t temp = 0;

	/* Enable low-g interrupt in Int Enable 1 register */
	rslt = bmi160_get_regs(BMI160_INT_ENABLE_1_ADDR, &data, 1, dev);
	if (rslt == BMI160_OK) {
		temp = data & ~BMI160_LOW_G_INT_EN_MASK;
		data = temp | ((low_g_int->low_en << 3) & BMI160_LOW_G_INT_EN_MASK);
		/* write data to Int Enable 0 register */
		rslt = bmi160_set_regs(BMI160_INT_ENABLE_1_ADDR, &data, 1, dev);
	}

	return rslt;
}

/*!
 * @brief This API configure the source of data(filter & pre-filter)
 * for low-g interrupt.
 */
static int8_t config_low_g_data_src(const struct bmi160_acc_low_g_int_cfg *low_g_int, const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data = 0;
	uint8_t temp = 0;

	/* Configure Int data 0 register to add source of interrupt */
	rslt = bmi160_get_regs(BMI160_INT_DATA_0_ADDR, &data, 1, dev);
	if (rslt == BMI160_OK) {
		temp = data & ~BMI160_LOW_HIGH_SRC_INT_MASK;
		data = temp | ((low_g_int->low_data_src << 7) & BMI160_LOW_HIGH_SRC_INT_MASK);
		/* Write data to Data 0 address */
		rslt = bmi160_set_regs(BMI160_INT_DATA_0_ADDR, &data, 1, dev);
	}

	return rslt;
}

/*!
 * @brief This API configure the necessary setting of low-g interrupt.
 */
static int8_t config_low_g_int_settg(const struct bmi160_acc_low_g_int_cfg *low_g_int,  const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t temp = 0;
	uint8_t data_array[3] = {0, 0, 0};

	/* Configuring INT_LOWHIGH register for low-g interrupt */
	rslt = bmi160_get_regs(BMI160_INT_LOWHIGH_2_ADDR, &data_array[2], 1, dev);

	if (rslt == BMI160_OK) {
		temp = data_array[2] & ~BMI160_LOW_G_HYST_MASK;
		/* Adding low-g hysteresis */
		data_array[2] = temp | (low_g_int->low_hyst & BMI160_LOW_G_HYST_MASK);
		temp = data_array[2] & ~BMI160_LOW_G_LOW_MODE_MASK;
		/* Adding low-mode */
		data_array[2] = temp | ((low_g_int->low_mode << 2) & BMI160_LOW_G_LOW_MODE_MASK);

		/* Adding low-g threshold */
		data_array[1] = low_g_int->low_thres;
		/* Adding low-g interrupt delay */
		data_array[0] = low_g_int->low_dur;
		/* Writing data to INT_LOWHIGH 0,1,2 registers simultaneously*/
		rslt = bmi160_set_regs(BMI160_INT_LOWHIGH_0_ADDR, data_array, 3, dev);
	}

	return rslt;
}

/*!
 * @brief This API enables the high-g interrupt.
 */
static int8_t enable_high_g_int(const struct bmi160_acc_high_g_int_cfg *high_g_int_cfg, const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data = 0;
	uint8_t temp = 0;

	/* Enable low-g interrupt in Int Enable 1 register */
	rslt = bmi160_get_regs(BMI160_INT_ENABLE_1_ADDR, &data, 1, dev);

	if (rslt == BMI160_OK) {

		/* Adding high-g X-axis */
		temp = data & ~BMI160_HIGH_G_X_INT_EN_MASK;
		data = temp | (high_g_int_cfg->high_g_x & BMI160_HIGH_G_X_INT_EN_MASK);

		/* Adding high-g Y-axis */
		temp = data & ~BMI160_HIGH_G_Y_INT_EN_MASK;
		data = temp | ((high_g_int_cfg->high_g_y << 1) & BMI160_HIGH_G_Y_INT_EN_MASK);

		/* Adding high-g Z-axis */
		temp = data & ~BMI160_HIGH_G_Z_INT_EN_MASK;
		data = temp | ((high_g_int_cfg->high_g_z << 2) & BMI160_HIGH_G_Z_INT_EN_MASK);

		/* write data to Int Enable 0 register */
		rslt = bmi160_set_regs(BMI160_INT_ENABLE_1_ADDR, &data, 1, dev);
	}

	return rslt;
}

/*!
 * @brief This API configure the source of data(filter & pre-filter)
 * for high-g interrupt.
 */
static int8_t config_high_g_data_src(const struct bmi160_acc_high_g_int_cfg *high_g_int_cfg,
					const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data = 0;
	uint8_t temp = 0;

	/* Configure Int data 0 register to add source of interrupt */
	rslt = bmi160_get_regs(BMI160_INT_DATA_0_ADDR, &data, 1, dev);
	if (rslt == BMI160_OK) {
		temp = data & ~BMI160_LOW_HIGH_SRC_INT_MASK;
		data = temp | ((high_g_int_cfg->high_data_src << 7) & BMI160_LOW_HIGH_SRC_INT_MASK);
		/* Write data to Data 0 address */
		rslt = bmi160_set_regs(BMI160_INT_DATA_0_ADDR, &data, 1, dev);
	}

	return rslt;
}

/*!
 * @brief This API configure the necessary setting of high-g interrupt.
 */
static int8_t config_high_g_int_settg(const struct bmi160_acc_high_g_int_cfg *high_g_int_cfg,
					const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t temp = 0;
	uint8_t data_array[3] = {0, 0, 0};

	rslt = bmi160_get_regs(BMI160_INT_LOWHIGH_2_ADDR, &data_array[0], 1, dev);
	if (rslt == BMI160_OK) {
		temp = data_array[0] & ~BMI160_HIGH_G_HYST_MASK;
		/* Adding high-g hysteresis */
		data_array[0] = temp | ((high_g_int_cfg->high_hy << 6) & BMI160_HIGH_G_HYST_MASK);
		/* Adding high-g duration */
		data_array[1] = high_g_int_cfg->high_dur;
		/* Adding high-g threshold */
		data_array[2] = high_g_int_cfg->high_thres;
		rslt = bmi160_set_regs(BMI160_INT_LOWHIGH_2_ADDR, data_array, 3, dev);
	}

	return rslt;
}

/*!
 * @brief This API configure the behavioural setting of interrupt pin.
 */
static int8_t config_int_out_ctrl(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t temp = 0;
	uint8_t data = 0;

	/* Configuration of output interrupt signals on pins INT1 and INT2 are
	 * done in BMI160_INT_OUT_CTRL_ADDR register*/
	rslt = bmi160_get_regs(BMI160_INT_OUT_CTRL_ADDR, &data, 1, dev);

	if (rslt == BMI160_OK) {
		/* updating the interrupt pin structure to local structure */
		const struct bmi160_int_pin_settg *intr_pin_sett = &(int_config->int_pin_settg);

		/* Configuring channel 1 */
		if (int_config->int_channel == BMI160_INT_CHANNEL_1) {

			/* Output enable */
			temp = data & ~BMI160_INT1_OUTPUT_EN_MASK;
			data = temp | ((intr_pin_sett->output_en << 3) & BMI160_INT1_OUTPUT_EN_MASK);

			/* Output mode */
			temp = data & ~BMI160_INT1_OUTPUT_MODE_MASK;
			data = temp | ((intr_pin_sett->output_mode << 2) & BMI160_INT1_OUTPUT_MODE_MASK);

			/* Output type */
			temp = data & ~BMI160_INT1_OUTPUT_TYPE_MASK;
			data = temp | ((intr_pin_sett->output_type << 1) & BMI160_INT1_OUTPUT_TYPE_MASK);

			/* edge control */
			temp = data & ~BMI160_INT1_EDGE_CTRL_MASK;
			data = temp | ((intr_pin_sett->edge_ctrl) & BMI160_INT1_EDGE_CTRL_MASK);

		} else {
			/* Configuring channel 2 */
			/* Output enable */
			temp = data & ~BMI160_INT2_OUTPUT_EN_MASK;
			data = temp | ((intr_pin_sett->output_en << 7) & BMI160_INT2_OUTPUT_EN_MASK);

			/* Output mode */
			temp = data & ~BMI160_INT2_OUTPUT_MODE_MASK;
			data = temp | ((intr_pin_sett->output_mode << 6) & BMI160_INT2_OUTPUT_MODE_MASK);

			/* Output type */
			temp = data & ~BMI160_INT2_OUTPUT_TYPE_MASK;
			data = temp | ((intr_pin_sett->output_type << 5) & BMI160_INT2_OUTPUT_TYPE_MASK);

			/* edge control */
			temp = data & ~BMI160_INT2_EDGE_CTRL_MASK;
			data = temp | ((intr_pin_sett->edge_ctrl << 4) & BMI160_INT2_EDGE_CTRL_MASK);
		}

		rslt = bmi160_set_regs(BMI160_INT_OUT_CTRL_ADDR, &data, 1, dev);
	}

	return rslt;
}

/*!
 * @brief This API configure the mode(input enable, latch or non-latch) of interrupt pin.
 */
static int8_t config_int_latch(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t temp = 0;
	uint8_t data = 0;

	/* Configuration of latch on pins INT1 and INT2 are done in
	 * BMI160_INT_LATCH_ADDR register*/
	rslt = bmi160_get_regs(BMI160_INT_LATCH_ADDR, &data, 1, dev);

	if (rslt == BMI160_OK) {
		/* updating the interrupt pin structure to local structure */
		const struct bmi160_int_pin_settg *intr_pin_sett = &(int_config->int_pin_settg);

		if (int_config->int_channel == BMI160_INT_CHANNEL_1) {
			/* Configuring channel 1 */
			/* Input enable */
			temp = data & ~BMI160_INT1_INPUT_EN_MASK;
			data = temp | ((intr_pin_sett->input_en << 4) & BMI160_INT1_INPUT_EN_MASK);
		} else {
			/* Configuring channel 2 */
			/* Input enable */
			temp = data & ~BMI160_INT2_INPUT_EN_MASK;
			data = temp | ((intr_pin_sett->input_en << 5) & BMI160_INT2_INPUT_EN_MASK);
		}

		/* In case of latch interrupt,update the latch duration */
		/* Latching holds the interrupt for the amount of latch
		 * duration time */
		temp = data & ~BMI160_INT_LATCH_MASK;
		data = temp | (intr_pin_sett->latch_dur & BMI160_INT_LATCH_MASK);

		/* OUT_CTRL_INT and LATCH_INT address lie consecutively,
		 * hence writing data to respective registers at one go */
		rslt = bmi160_set_regs(BMI160_INT_LATCH_ADDR, &data, 1, dev);
	}
	return rslt;
}

/*!
 * @brief This API performs the self test for accelerometer of BMI160
 */
static int8_t perform_accel_self_test(struct bmi160_dev *dev)
{
	int8_t rslt;
	struct bmi160_sensor_data accel_pos, accel_neg;

	/* Enable Gyro self test bit */
	rslt = enable_accel_self_test(dev);
	if (rslt == BMI160_OK) {
		/* Perform accel self test with positive excitation */
		rslt = accel_self_test_positive_excitation(&accel_pos, dev);
		if (rslt == BMI160_OK) {
			/* Perform accel self test with negative excitation */
			rslt = accel_self_test_negative_excitation(&accel_neg, dev);
			if (rslt == BMI160_OK) {
				/* Validate the self test result */
				rslt = validate_accel_self_test(&accel_pos, &accel_neg);
			}
		}
	}

	return rslt;
}

/*!
 * @brief This API enables to perform the accel self test by setting proper
 * configurations to facilitate accel self test
 */
static int8_t enable_accel_self_test(struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t reg_data;

	/* Set the Accel power mode as normal mode */
	dev->accel_cfg.power = BMI160_ACCEL_NORMAL_MODE;
	/* Set the sensor range configuration as 8G */
	dev->accel_cfg.range = BMI160_ACCEL_RANGE_8G;
	rslt = bmi160_set_sens_conf(dev);
	if (rslt == BMI160_OK) {
		/* Accel configurations are set to facilitate self test
		 * acc_odr - 1600Hz ; acc_bwp = 2 ; acc_us = 0 */
		reg_data = BMI160_ACCEL_SELF_TEST_CONFIG;
		rslt = bmi160_set_regs(BMI160_ACCEL_CONFIG_ADDR, &reg_data, 1, dev);
	}

	return rslt;
}

/*!
 * @brief This API performs accel self test with positive excitation
 */
static int8_t accel_self_test_positive_excitation(struct bmi160_sensor_data *accel_pos, const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t reg_data;

	/* Enable accel self test with positive self-test excitation
	   and with amplitude of deflection set as high */
	reg_data = BMI160_ACCEL_SELF_TEST_POSITIVE_EN;
	rslt = bmi160_set_regs(BMI160_SELF_TEST_ADDR, &reg_data, 1, dev);
	if (rslt == BMI160_OK) {
		/* Read the data after a delay of 50ms */
		dev->delay_ms(BMI160_ACCEL_SELF_TEST_DELAY);
		rslt = bmi160_get_sensor_data(BMI160_ACCEL_ONLY, accel_pos, NULL, dev);
	}

	return rslt;
}

/*!
 * @brief This API performs accel self test with negative excitation
 */
static int8_t accel_self_test_negative_excitation(struct bmi160_sensor_data *accel_neg, const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t reg_data;

	/* Enable accel self test with negative self-test excitation
	   and with amplitude of deflection set as high */
	reg_data = BMI160_ACCEL_SELF_TEST_NEGATIVE_EN;
	rslt = bmi160_set_regs(BMI160_SELF_TEST_ADDR, &reg_data, 1, dev);
	if (rslt == BMI160_OK) {
		/* Read the data after a delay of 50ms */
		dev->delay_ms(BMI160_ACCEL_SELF_TEST_DELAY);
		rslt = bmi160_get_sensor_data(BMI160_ACCEL_ONLY, accel_neg, NULL, dev);
	}

	return rslt;
}

/*!
 * @brief This API validates the accel self test results
 */
static int8_t validate_accel_self_test(const struct bmi160_sensor_data *accel_pos,
					const struct bmi160_sensor_data *accel_neg)
{
	int8_t rslt;

	/* Validate the results of self test */
	if (((accel_neg->x - accel_pos->x) > BMI160_ACCEL_SELF_TEST_LIMIT)
		&& ((accel_neg->y - accel_pos->y) > BMI160_ACCEL_SELF_TEST_LIMIT)
		&& ((accel_neg->z - accel_pos->z) > BMI160_ACCEL_SELF_TEST_LIMIT)) {
		/* Self test pass condition */
		rslt = BMI160_OK;
	} else {
		rslt = BMI160_W_ACCEl_SELF_TEST_FAIL;
	}

	return rslt;
}

/*!
 * @brief This API performs the self test for gyroscope of BMI160
 */
static int8_t perform_gyro_self_test(const struct bmi160_dev *dev)
{
	int8_t rslt;

	/* Enable Gyro self test bit */
	rslt = enable_gyro_self_test(dev);
	if (rslt == BMI160_OK) {
		/* Validate the gyro self test results */
		rslt = validate_gyro_self_test(dev);
	}

	return rslt;
}

/*!
 * @brief This API enables the self test bit to trigger self test for Gyro
 */
static int8_t enable_gyro_self_test(const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t reg_data;

	/* Enable the Gyro self test bit to trigger the self test */
	rslt = bmi160_get_regs(BMI160_SELF_TEST_ADDR, &reg_data, 1, dev);
	if (rslt == BMI160_OK) {
		reg_data = BMI160_SET_BITS(reg_data, BMI160_GYRO_SELF_TEST, 1);
		rslt = bmi160_set_regs(BMI160_SELF_TEST_ADDR, &reg_data, 1, dev);
		if (rslt == BMI160_OK) {
			/* Delay to enable gyro self test */
			dev->delay_ms(BMI160_GYRO_SELF_TEST_DELAY);
		}
	}

	return rslt;
}

/*!
 * @brief This API validates the self test results of Gyro
 */
static int8_t validate_gyro_self_test(const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t reg_data;

	/* Validate the Gyro self test result */
	rslt = bmi160_get_regs(BMI160_STATUS_ADDR, &reg_data, 1, dev);
	if (rslt == BMI160_OK) {
		reg_data = BMI160_GET_BITS(reg_data, BMI160_GYRO_SELF_TEST_STATUS);
		if (reg_data == BMI160_ENABLE) {
			/* Gyro self test success case */
			rslt = BMI160_OK;
		} else {
			rslt = BMI160_W_GYRO_SELF_TEST_FAIL;
		}
	}

	return rslt;
}

/*!
*  @brief This API sets FIFO full interrupt of the sensor.This interrupt
*  occurs when the FIFO is full and the next full data sample would cause
*  a FIFO overflow, which may delete the old samples.
*/
static int8_t set_fifo_full_int(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
	int8_t rslt = BMI160_OK;

	/* Null-pointer check */
	if ((dev == NULL) || (dev->delay_ms == NULL)) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		/*enable the fifo full interrupt */
		rslt = enable_fifo_full_int(int_config, dev);
		if (rslt == BMI160_OK) {
			/* Configure Interrupt pins */
			rslt = set_intr_pin_config(int_config, dev);
			if (rslt == BMI160_OK)
				rslt = map_hardware_interrupt(int_config, dev);
		}
	}
	return rslt;
}

/*!
 * @brief This enable the FIFO full interrupt engine.
 */
static int8_t enable_fifo_full_int(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data = 0;

	rslt = bmi160_get_regs(BMI160_INT_ENABLE_1_ADDR, &data, 1, dev);

	if (rslt == BMI160_OK) {
		data = BMI160_SET_BITS(data, BMI160_FIFO_FULL_INT, int_config->fifo_full_int_en);
		/* Writing data to INT ENABLE 1 Address */
		rslt = bmi160_set_regs(BMI160_INT_ENABLE_1_ADDR, &data, 1, dev);
	}

	return rslt;
}

/*!
 *  @brief This API sets FIFO watermark interrupt of the sensor.The FIFO
 *  watermark interrupt is fired, when the FIFO fill level is above a fifo
 *  watermark.
 */
static int8_t set_fifo_watermark_int(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
	int8_t rslt = BMI160_OK;

	if ((dev == NULL) || (dev->delay_ms == NULL)) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		/* Enable fifo-watermark interrupt in Int Enable 1 register */
		rslt = enable_fifo_wtm_int(int_config, dev);
		if (rslt == BMI160_OK) {
			/* Configure Interrupt pins */
			rslt = set_intr_pin_config(int_config, dev);
			if (rslt == BMI160_OK)
				rslt = map_hardware_interrupt(int_config, dev);
		}
	}

	return rslt;
}

/*!
 * @brief This enable the FIFO watermark interrupt engine.
 */
static int8_t enable_fifo_wtm_int(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
	int8_t rslt;
	uint8_t data = 0;

	rslt = bmi160_get_regs(BMI160_INT_ENABLE_1_ADDR, &data, 1, dev);

	if (rslt == BMI160_OK) {
		data = BMI160_SET_BITS(data, BMI160_FIFO_WTM_INT, int_config->fifo_WTM_int_en);
		/* Writing data to INT ENABLE 1 Address */
		rslt = bmi160_set_regs(BMI160_INT_ENABLE_1_ADDR, &data, 1, dev);
	}

	return rslt;
}

/*!
 *  @brief This API is used to reset the FIFO related configurations
 *  in the fifo_frame structure.
 */
static void reset_fifo_data_structure(const struct bmi160_dev *dev)
{
	/*Prepare for next FIFO read by resetting FIFO's
	internal data structures*/
	dev->fifo->accel_byte_start_idx = 0;
	dev->fifo->gyro_byte_start_idx = 0;
	dev->fifo->aux_byte_start_idx = 0;
	dev->fifo->sensor_time = 0;
	dev->fifo->skipped_frame_count = 0;
}

/*!
 *  @brief This API is used to read fifo_byte_counter value (i.e)
 *  current fill-level in Fifo buffer.
 */
static int8_t get_fifo_byte_counter(uint16_t *bytes_to_read, struct bmi160_dev const *dev)
{
	int8_t rslt = 0;
	uint8_t data[2];
	uint8_t addr = BMI160_FIFO_LENGTH_ADDR;

	rslt |= bmi160_get_regs(addr, data, 2, dev);
	data[1] = data[1] & BMI160_FIFO_BYTE_COUNTER_MASK;

	/* Available data in FIFO is stored in bytes_to_read*/
	*bytes_to_read = (((uint16_t)data[1] << 8) | ((uint16_t)data[0]));

	return rslt;
}

/*!
 *  @brief This API is used to compute the number of bytes of accel FIFO data
 *  which is to be parsed in header-less mode
 */
static void get_accel_len_to_parse(uint16_t *data_index, uint16_t *data_read_length, const uint8_t *acc_frame_count,
				const struct bmi160_dev *dev)
{
	/* Data start index */
	*data_index = dev->fifo->accel_byte_start_idx;

	if (dev->fifo->fifo_data_enable == BMI160_FIFO_A_ENABLE) {
		*data_read_length = (*acc_frame_count) * BMI160_FIFO_A_LENGTH;
	} else if (dev->fifo->fifo_data_enable == BMI160_FIFO_G_A_ENABLE) {
		*data_read_length = (*acc_frame_count) * BMI160_FIFO_GA_LENGTH;
	} else if (dev->fifo->fifo_data_enable == BMI160_FIFO_M_A_ENABLE) {
		*data_read_length = (*acc_frame_count) * BMI160_FIFO_MA_LENGTH;
	} else if (dev->fifo->fifo_data_enable == BMI160_FIFO_M_G_A_ENABLE) {
		*data_read_length = (*acc_frame_count) * BMI160_FIFO_MGA_LENGTH;
	} else {
		/* When accel is not enabled ,there will be no accel data.
		so we update the data index as complete */
		*data_index = dev->fifo->length;
	}

	if (*data_read_length > dev->fifo->length) {
		/* Handling the case where more data is requested
		than that is available*/
		*data_read_length = dev->fifo->length;
	}

}

/*!
 *  @brief This API is used to parse the accelerometer data from the
 *  FIFO data in both header mode and header-less mode.
 *  It updates the idx value which is used to store the index of
 *  the current data byte which is parsed.
 */
static void unpack_accel_frame(struct bmi160_sensor_data *acc, uint16_t *idx, uint8_t *acc_idx, uint8_t frame_info,
				const struct bmi160_dev *dev)
{
	switch (frame_info) {
	case BMI160_FIFO_HEAD_A:
	case BMI160_FIFO_A_ENABLE:
		/*Partial read, then skip the data*/
		if ((*idx + BMI160_FIFO_A_LENGTH) > dev->fifo->length) {
			/*Update the data index as complete*/
			*idx = dev->fifo->length;
			break;
		}
		/*Unpack the data array into the structure instance "acc" */
		unpack_accel_data(&acc[*acc_idx], *idx, dev);
		/*Move the data index*/
		*idx = *idx + BMI160_FIFO_A_LENGTH;
		(*acc_idx)++;
		break;
	case BMI160_FIFO_HEAD_G_A:
	case BMI160_FIFO_G_A_ENABLE:
		/*Partial read, then skip the data*/
		if ((*idx + BMI160_FIFO_GA_LENGTH) > dev->fifo->length) {
			/*Update the data index as complete*/
			*idx = dev->fifo->length;
			break;
		}
		/*Unpack the data array into structure instance "acc"*/
		unpack_accel_data(&acc[*acc_idx], *idx + BMI160_FIFO_G_LENGTH, dev);
		/*Move the data index*/
		*idx = *idx + BMI160_FIFO_GA_LENGTH;
		(*acc_idx)++;
		break;
	case BMI160_FIFO_HEAD_M_A:
	case BMI160_FIFO_M_A_ENABLE:
		/*Partial read, then skip the data*/
		if ((*idx + BMI160_FIFO_MA_LENGTH) > dev->fifo->length) {
			/*Update the data index as complete*/
			*idx = dev->fifo->length;
			break;
		}
		/*Unpack the data array into structure instance "acc"*/
		unpack_accel_data(&acc[*acc_idx], *idx + BMI160_FIFO_M_LENGTH, dev);
		/*Move the data index*/
		*idx = *idx + BMI160_FIFO_MA_LENGTH;
		(*acc_idx)++;
		break;
	case BMI160_FIFO_HEAD_M_G_A:
	case BMI160_FIFO_M_G_A_ENABLE:
		/*Partial read, then skip the data*/
		if ((*idx + BMI160_FIFO_MGA_LENGTH) > dev->fifo->length) {
			/*Update the data index as complete*/
			*idx = dev->fifo->length;
			break;
		}
		/*Unpack the data array into structure instance "acc"*/
		unpack_accel_data(&acc[*acc_idx], *idx + BMI160_FIFO_MG_LENGTH, dev);
		/*Move the data index*/
		*idx = *idx + BMI160_FIFO_MGA_LENGTH;
		(*acc_idx)++;
		break;
	case BMI160_FIFO_HEAD_M:
	case BMI160_FIFO_M_ENABLE:
		(*idx) = (*idx) + BMI160_FIFO_M_LENGTH;
		break;
	case BMI160_FIFO_HEAD_G:
	case BMI160_FIFO_G_ENABLE:
		(*idx) = (*idx) + BMI160_FIFO_G_LENGTH;
		break;
	case BMI160_FIFO_HEAD_M_G:
	case BMI160_FIFO_M_G_ENABLE:
		(*idx) = (*idx) + BMI160_FIFO_MG_LENGTH;
		break;
	default:
		break;
	}

}

/*!
 *  @brief This API is used to parse the accelerometer data from the
 *  FIFO data and store it in the instance of the structure bmi160_sensor_data.
 */
static void unpack_accel_data(struct bmi160_sensor_data *accel_data, uint16_t data_start_index,
				const struct bmi160_dev *dev)
{
	uint16_t data_lsb;
	uint16_t data_msb;

	/* Accel raw x data */
	data_lsb = dev->fifo->data[data_start_index++];
	data_msb = dev->fifo->data[data_start_index++];
	accel_data->x = (int16_t)((data_msb << 8) | data_lsb);

	/* Accel raw y data */
	data_lsb = dev->fifo->data[data_start_index++];
	data_msb = dev->fifo->data[data_start_index++];
	accel_data->y = (int16_t)((data_msb << 8) | data_lsb);

	/* Accel raw z data */
	data_lsb = dev->fifo->data[data_start_index++];
	data_msb = dev->fifo->data[data_start_index++];
	accel_data->z = (int16_t)((data_msb << 8) | data_lsb);

}

/*!
 *  @brief This API is used to parse the accelerometer data from the
 *  FIFO data in header mode.
 */
static void extract_accel_header_mode(struct bmi160_sensor_data *accel_data, uint8_t *accel_length,
					const struct bmi160_dev *dev)
{
	uint8_t frame_header = 0;
	uint16_t data_index;
	uint8_t accel_index = 0;

	for (data_index = dev->fifo->accel_byte_start_idx; data_index < dev->fifo->length;) {
		/* extracting Frame header */
		frame_header = (dev->fifo->data[data_index] & BMI160_FIFO_TAG_INTR_MASK);
		/*Index is moved to next byte where the data is starting*/
		data_index++;

		switch (frame_header) {
		/* Accel frame */
		case BMI160_FIFO_HEAD_A:
		case BMI160_FIFO_HEAD_M_A:
		case BMI160_FIFO_HEAD_G_A:
		case BMI160_FIFO_HEAD_M_G_A:
			unpack_accel_frame(accel_data, &data_index, &accel_index, frame_header, dev);
			break;
		case BMI160_FIFO_HEAD_M:
			move_next_frame(&data_index, BMI160_FIFO_M_LENGTH, dev);
			break;

		case BMI160_FIFO_HEAD_G:
			move_next_frame(&data_index, BMI160_FIFO_G_LENGTH, dev);
			break;
		case BMI160_FIFO_HEAD_M_G:
			move_next_frame(&data_index, BMI160_FIFO_MG_LENGTH, dev);
			break;
			/* Sensor time frame */
		case BMI160_FIFO_HEAD_SENSOR_TIME:
			unpack_sensortime_frame(&data_index, dev);
			break;
			/* Skip frame */
		case BMI160_FIFO_HEAD_SKIP_FRAME:
			unpack_skipped_frame(&data_index, dev);
			break;
			/* Input config frame */
		case BMI160_FIFO_HEAD_INPUT_CONFIG:
			move_next_frame(&data_index, 1, dev);
			break;
		case BMI160_FIFO_HEAD_OVER_READ:
			/* Update the data index as complete in case of Over read */
			data_index = dev->fifo->length;
			break;
		default:
			break;
		}
		if (*accel_length == accel_index) {
			/* Number of frames to read completed */
			break;
		}
	}

	/*Update number of accel data read*/
	*accel_length = accel_index;
	/*Update the accel frame index*/
	dev->fifo->accel_byte_start_idx = data_index;
}

/*!
 *  @brief This API computes the number of bytes of gyro FIFO data
 *  which is to be parsed in header-less mode
 */
static void get_gyro_len_to_parse(uint16_t *data_index, uint16_t *data_read_length, const uint8_t *gyro_frame_count,
					const struct bmi160_dev *dev)
{
	/* Data start index */
	*data_index = dev->fifo->gyro_byte_start_idx;

	if (dev->fifo->fifo_data_enable == BMI160_FIFO_G_ENABLE) {
		*data_read_length = (*gyro_frame_count) * BMI160_FIFO_G_LENGTH;
	} else if (dev->fifo->fifo_data_enable == BMI160_FIFO_G_A_ENABLE) {
		*data_read_length = (*gyro_frame_count) * BMI160_FIFO_GA_LENGTH;
	} else if (dev->fifo->fifo_data_enable == BMI160_FIFO_M_G_ENABLE) {
		*data_read_length = (*gyro_frame_count) * BMI160_FIFO_MG_LENGTH;
	} else if (dev->fifo->fifo_data_enable == BMI160_FIFO_M_G_A_ENABLE) {
		*data_read_length = (*gyro_frame_count) * BMI160_FIFO_MGA_LENGTH;
	} else {
		/* When gyro is not enabled ,there will be no gyro data.
		so we update the data index as complete */
		*data_index = dev->fifo->length;
	}

	if (*data_read_length > dev->fifo->length) {
		/* Handling the case where more data is requested
		than that is available*/
		*data_read_length = dev->fifo->length;
	}

}


/*!
 *  @brief This API is used to parse the gyroscope's data from the
 *  FIFO data in both header mode and header-less mode.
 *  It updates the idx value which is used to store the index of
 *  the current data byte which is parsed.
 */
static void unpack_gyro_frame(struct bmi160_sensor_data *gyro, uint16_t *idx, uint8_t *gyro_idx, uint8_t frame_info,
				const struct bmi160_dev *dev)
{
	switch (frame_info) {

	case BMI160_FIFO_HEAD_G:
	case BMI160_FIFO_G_ENABLE:
		/*Partial read, then skip the data*/
		if ((*idx + BMI160_FIFO_G_LENGTH) > dev->fifo->length) {
			/*Update the data index as complete*/
			*idx = dev->fifo->length;
			break;
		}
		/*Unpack the data array into structure instance "gyro"*/
		unpack_gyro_data(&gyro[*gyro_idx], *idx, dev);
		/*Move the data index*/
		(*idx) = (*idx) + BMI160_FIFO_G_LENGTH;
		(*gyro_idx)++;
		break;

	case BMI160_FIFO_HEAD_G_A:
	case BMI160_FIFO_G_A_ENABLE:
		/*Partial read, then skip the data*/
		if ((*idx + BMI160_FIFO_GA_LENGTH) > dev->fifo->length) {
			/*Update the data index as complete*/
			*idx = dev->fifo->length;
			break;
		}
		/* Unpack the data array into structure instance "gyro" */
		unpack_gyro_data(&gyro[*gyro_idx], *idx, dev);
		/* Move the data index */
		*idx = *idx + BMI160_FIFO_GA_LENGTH;
		(*gyro_idx)++;
		break;

	case BMI160_FIFO_HEAD_M_G_A:
	case BMI160_FIFO_M_G_A_ENABLE:
		/*Partial read, then skip the data*/
		if ((*idx + BMI160_FIFO_MGA_LENGTH) > dev->fifo->length) {
			/*Update the data index as complete*/
			*idx = dev->fifo->length;
			break;
		}
		/*Unpack the data array into structure instance "gyro"*/
		unpack_gyro_data(&gyro[*gyro_idx], *idx + BMI160_FIFO_M_LENGTH, dev);
		/*Move the data index*/
		*idx = *idx + BMI160_FIFO_MGA_LENGTH;
		(*gyro_idx)++;
		break;


	case BMI160_FIFO_HEAD_M_A:
	case BMI160_FIFO_M_A_ENABLE:
		/* Move the data index */
		*idx = *idx + BMI160_FIFO_MA_LENGTH;
		break;

	case BMI160_FIFO_HEAD_M:
	case BMI160_FIFO_M_ENABLE:
		(*idx) = (*idx) + BMI160_FIFO_M_LENGTH;
		break;

	case BMI160_FIFO_HEAD_M_G:
	case BMI160_FIFO_M_G_ENABLE:
		/*Partial read, then skip the data*/
		if ((*idx + BMI160_FIFO_MG_LENGTH) > dev->fifo->length) {
			/*Update the data index as complete*/
			*idx = dev->fifo->length;
			break;
		}
		/*Unpack the data array into structure instance "gyro"*/
		unpack_gyro_data(&gyro[*gyro_idx], *idx + BMI160_FIFO_M_LENGTH, dev);
		/*Move the data index*/
		(*idx) = (*idx) + BMI160_FIFO_MG_LENGTH;
		(*gyro_idx)++;
		break;

	case BMI160_FIFO_HEAD_A:
	case BMI160_FIFO_A_ENABLE:
		/*Move the data index*/
		*idx = *idx + BMI160_FIFO_A_LENGTH;
		break;

	default:
		break;
	}

}

/*!
 *  @brief This API is used to parse the gyro data from the
 *  FIFO data and store it in the instance of the structure bmi160_sensor_data.
 */
static void unpack_gyro_data(struct bmi160_sensor_data *gyro_data, uint16_t data_start_index,
				const struct bmi160_dev *dev)
{
	uint16_t data_lsb;
	uint16_t data_msb;

	/* Gyro raw x data */
	data_lsb = dev->fifo->data[data_start_index++];
	data_msb = dev->fifo->data[data_start_index++];
	gyro_data->x = (int16_t)((data_msb << 8) | data_lsb);

	/* Gyro raw y data */
	data_lsb = dev->fifo->data[data_start_index++];
	data_msb = dev->fifo->data[data_start_index++];
	gyro_data->y = (int16_t)((data_msb << 8) | data_lsb);

	/* Gyro raw z data */
	data_lsb = dev->fifo->data[data_start_index++];
	data_msb = dev->fifo->data[data_start_index++];
	gyro_data->z = (int16_t)((data_msb << 8) | data_lsb);

}

/*!
 *  @brief This API is used to parse the gyro data from the
 *  FIFO data in header mode.
 */
static void extract_gyro_header_mode(struct bmi160_sensor_data *gyro_data, uint8_t *gyro_length,
					const struct bmi160_dev *dev)
{
	uint8_t frame_header = 0;
	uint16_t data_index;
	uint8_t gyro_index = 0;

	for (data_index = dev->fifo->gyro_byte_start_idx; data_index < dev->fifo->length;) {
		/* extracting Frame header */
		frame_header = (dev->fifo->data[data_index] & BMI160_FIFO_TAG_INTR_MASK);
		/*Index is moved to next byte where the data is starting*/
		data_index++;

		switch (frame_header) {
			/* GYRO frame */
		case BMI160_FIFO_HEAD_G:
		case BMI160_FIFO_HEAD_G_A:
		case BMI160_FIFO_HEAD_M_G:
		case BMI160_FIFO_HEAD_M_G_A:
			unpack_gyro_frame(gyro_data, &data_index, &gyro_index, frame_header, dev);
			break;
		case BMI160_FIFO_HEAD_A:
			move_next_frame(&data_index, BMI160_FIFO_A_LENGTH, dev);
			break;
		case BMI160_FIFO_HEAD_M:
			move_next_frame(&data_index, BMI160_FIFO_M_LENGTH, dev);
			break;
		case BMI160_FIFO_HEAD_M_A:
			move_next_frame(&data_index, BMI160_FIFO_M_LENGTH, dev);
			break;
			/* Sensor time frame */
		case BMI160_FIFO_HEAD_SENSOR_TIME:
			unpack_sensortime_frame(&data_index, dev);
			break;
			/* Skip frame */
		case BMI160_FIFO_HEAD_SKIP_FRAME:
			unpack_skipped_frame(&data_index, dev);
			break;
			/* Input config frame */
		case BMI160_FIFO_HEAD_INPUT_CONFIG:
			move_next_frame(&data_index, 1, dev);
			break;
		case BMI160_FIFO_HEAD_OVER_READ:
			/* Update the data index as complete in case of over read */
			data_index = dev->fifo->length;
			break;
		default:
			break;
		}
		if (*gyro_length == gyro_index) {
			/*Number of frames to read completed*/
			break;
		}
	}

	/*Update number of gyro data read*/
	*gyro_length = gyro_index;
	/*Update the gyro frame index*/
	dev->fifo->gyro_byte_start_idx = data_index;
}

/*!
 *  @brief This API computes the number of bytes of aux FIFO data
 *  which is to be parsed in header-less mode
 */
static void get_aux_len_to_parse(uint16_t *data_index, uint16_t *data_read_length, const uint8_t *aux_frame_count,
					const struct bmi160_dev *dev)
{
	/* Data start index */
	*data_index = dev->fifo->gyro_byte_start_idx;

	if (dev->fifo->fifo_data_enable == BMI160_FIFO_M_ENABLE) {
		*data_read_length = (*aux_frame_count) * BMI160_FIFO_M_LENGTH;
	} else if (dev->fifo->fifo_data_enable == BMI160_FIFO_M_A_ENABLE) {
		*data_read_length = (*aux_frame_count) * BMI160_FIFO_MA_LENGTH;
	} else if (dev->fifo->fifo_data_enable == BMI160_FIFO_M_G_ENABLE) {
		*data_read_length = (*aux_frame_count) * BMI160_FIFO_MG_LENGTH;
	} else if (dev->fifo->fifo_data_enable == BMI160_FIFO_M_G_A_ENABLE) {
		*data_read_length = (*aux_frame_count) * BMI160_FIFO_MGA_LENGTH;
	} else {
		/* When aux is not enabled ,there will be no aux data.
		 * so we update the data index as complete */
		*data_index = dev->fifo->length;
	}

	if (*data_read_length > dev->fifo->length) {
		/* Handling the case where more data is requested
		 * than that is available */
		*data_read_length = dev->fifo->length;
	}
}

/*!
 *  @brief This API is used to parse the aux's data from the
 *  FIFO data in both header mode and header-less mode.
 *  It updates the idx value which is used to store the index of
 *  the current data byte which is parsed
 */
static void unpack_aux_frame(struct bmi160_aux_data *aux_data, uint16_t *idx, uint8_t *aux_index, uint8_t frame_info,
				const struct bmi160_dev *dev)
{
	switch (frame_info) {

	case BMI160_FIFO_HEAD_M:
	case BMI160_FIFO_M_ENABLE:
		/* Partial read, then skip the data */
		if ((*idx + BMI160_FIFO_M_LENGTH) > dev->fifo->length) {
			/* Update the data index as complete */
			*idx = dev->fifo->length;
			break;
		}
		/* Unpack the data array into structure instance */
		unpack_aux_data(&aux_data[*aux_index], *idx, dev);
		/* Move the data index */
		*idx = *idx + BMI160_FIFO_M_LENGTH;
		(*aux_index)++;
		break;

	case BMI160_FIFO_HEAD_M_A:
	case BMI160_FIFO_M_A_ENABLE:
		/* Partial read, then skip the data */
		if ((*idx + BMI160_FIFO_MA_LENGTH) > dev->fifo->length) {
			/* Update the data index as complete */
			*idx = dev->fifo->length;
			break;
		}
		/* Unpack the data array into structure instance */
		unpack_aux_data(&aux_data[*aux_index], *idx, dev);
		/* Move the data index */
		*idx = *idx + BMI160_FIFO_MA_LENGTH;
		(*aux_index)++;
		break;


	case BMI160_FIFO_HEAD_M_G:
	case BMI160_FIFO_M_G_ENABLE:
		/* Partial read, then skip the data */
		if ((*idx + BMI160_FIFO_MG_LENGTH) > dev->fifo->length) {
			/* Update the data index as complete */
			*idx = dev->fifo->length;
			break;
		}
		/* Unpack the data array into structure instance */
		unpack_aux_data(&aux_data[*aux_index], *idx, dev);
		/* Move the data index */
		(*idx) = (*idx) + BMI160_FIFO_MG_LENGTH;
		(*aux_index)++;
		break;

	case BMI160_FIFO_HEAD_M_G_A:
	case BMI160_FIFO_M_G_A_ENABLE:
		/*Partial read, then skip the data*/
		if ((*idx + BMI160_FIFO_MGA_LENGTH) > dev->fifo->length) {
			/* Update the data index as complete */
			*idx = dev->fifo->length;
			break;
		}
		/* Unpack the data array into structure instance */
		unpack_aux_data(&aux_data[*aux_index], *idx, dev);
		/*Move the data index*/
		*idx = *idx + BMI160_FIFO_MGA_LENGTH;
		(*aux_index)++;
		break;

	case BMI160_FIFO_HEAD_G:
	case BMI160_FIFO_G_ENABLE:
		/* Move the data index */
		(*idx) = (*idx) + BMI160_FIFO_G_LENGTH;
		break;

	case BMI160_FIFO_HEAD_G_A:
	case BMI160_FIFO_G_A_ENABLE:
		/* Move the data index */
		*idx = *idx + BMI160_FIFO_GA_LENGTH;
		break;

	case BMI160_FIFO_HEAD_A:
	case BMI160_FIFO_A_ENABLE:
		/* Move the data index */
		*idx = *idx + BMI160_FIFO_A_LENGTH;
		break;

	default:
		break;
	}

}

/*!
 *  @brief This API is used to parse the aux data from the
 *  FIFO data and store it in the instance of the structure bmi160_aux_data.
 */
static void unpack_aux_data(struct bmi160_aux_data *aux_data, uint16_t data_start_index,
				const struct bmi160_dev *dev)
{
	/* Aux data bytes */
	aux_data->data[0] = dev->fifo->data[data_start_index++];
	aux_data->data[1] = dev->fifo->data[data_start_index++];
	aux_data->data[2] = dev->fifo->data[data_start_index++];
	aux_data->data[3] = dev->fifo->data[data_start_index++];
	aux_data->data[4] = dev->fifo->data[data_start_index++];
	aux_data->data[5] = dev->fifo->data[data_start_index++];
	aux_data->data[6] = dev->fifo->data[data_start_index++];
	aux_data->data[7] = dev->fifo->data[data_start_index++];
}

/*!
 *  @brief This API is used to parse the aux data from the
 *  FIFO data in header mode.
 */
static void extract_aux_header_mode(struct bmi160_aux_data *aux_data, uint8_t *aux_length,
					const struct bmi160_dev *dev)
{
	uint8_t frame_header = 0;
	uint16_t data_index;
	uint8_t aux_index = 0;

	for (data_index = dev->fifo->aux_byte_start_idx; data_index < dev->fifo->length;) {
		/* extracting Frame header */
		frame_header = (dev->fifo->data[data_index] & BMI160_FIFO_TAG_INTR_MASK);
		/*Index is moved to next byte where the data is starting*/
		data_index++;

		switch (frame_header) {
			/* Aux frame */
		case BMI160_FIFO_HEAD_M:
		case BMI160_FIFO_HEAD_M_A:
		case BMI160_FIFO_HEAD_M_G:
		case BMI160_FIFO_HEAD_M_G_A:
			unpack_aux_frame(aux_data, &data_index, &aux_index, frame_header, dev);
			break;
		case BMI160_FIFO_HEAD_G:
			move_next_frame(&data_index, BMI160_FIFO_G_LENGTH, dev);
			break;
		case BMI160_FIFO_HEAD_G_A:
			move_next_frame(&data_index, BMI160_FIFO_GA_LENGTH, dev);
			break;
		case BMI160_FIFO_HEAD_A:
			move_next_frame(&data_index, BMI160_FIFO_A_LENGTH, dev);
			break;
			/* Sensor time frame */
		case BMI160_FIFO_HEAD_SENSOR_TIME:
			unpack_sensortime_frame(&data_index, dev);
			break;
			/* Skip frame */
		case BMI160_FIFO_HEAD_SKIP_FRAME:
			unpack_skipped_frame(&data_index, dev);
			break;
			/* Input config frame */
		case BMI160_FIFO_HEAD_INPUT_CONFIG:
			move_next_frame(&data_index, 1, dev);
			break;
		case BMI160_FIFO_HEAD_OVER_READ:
			/* Update the data index as complete in case
			 * of over read */
			data_index = dev->fifo->length;
			break;
		default:
			/* Update the data index as complete in case of
			 * getting other headers like 0x00 */
			data_index = dev->fifo->length;
			break;
		}
		if (*aux_length == aux_index) {
			/*Number of frames to read completed*/
			break;
		}
	}

	/* Update number of aux data read */
	*aux_length = aux_index;
	/* Update the aux frame index */
	dev->fifo->aux_byte_start_idx = data_index;
}

/*!
 *  @brief This API checks the presence of non-valid frames in the read fifo data.
 */
static void check_frame_validity(uint16_t *data_index, const struct bmi160_dev *dev)
{
	if ((*data_index + 2) < dev->fifo->length) {
		/* Check if FIFO is empty */
		if ((dev->fifo->data[*data_index] == FIFO_CONFIG_MSB_CHECK)
			&& (dev->fifo->data[*data_index + 1] == FIFO_CONFIG_LSB_CHECK)) {
			/*Update the data index as complete*/
			*data_index = dev->fifo->length;
		}
	}
}

/*!
 *  @brief This API is used to move the data index ahead of the
 *  current_frame_length parameter when unnecessary FIFO data appears while
 *  extracting the user specified data.
 */
static void move_next_frame(uint16_t *data_index, uint8_t current_frame_length, const struct bmi160_dev *dev)
{
	/*Partial read, then move the data index to last data*/
	if ((*data_index + current_frame_length) > dev->fifo->length) {
		/*Update the data index as complete*/
		*data_index = dev->fifo->length;
	} else {
		/*Move the data index to next frame*/
		*data_index = *data_index + current_frame_length;
	}
}

/*!
 *  @brief This API is used to parse and store the sensor time from the
 *  FIFO data in the structure instance dev.
 */
static void unpack_sensortime_frame(uint16_t *data_index, const struct bmi160_dev *dev)
{
	uint32_t sensor_time_byte3 = 0;
	uint16_t sensor_time_byte2 = 0;
	uint8_t sensor_time_byte1 = 0;

	/*Partial read, then move the data index to last data*/
	if ((*data_index + BMI160_SENSOR_TIME_LENGTH) > dev->fifo->length) {
		/*Update the data index as complete*/
		*data_index = dev->fifo->length;
	} else {
		sensor_time_byte3 = dev->fifo->data[(*data_index) + BMI160_SENSOR_TIME_MSB_BYTE] << 16;
		sensor_time_byte2 = dev->fifo->data[(*data_index) + BMI160_SENSOR_TIME_XLSB_BYTE] << 8;
		sensor_time_byte1 = dev->fifo->data[(*data_index)];
		/* Sensor time */
		dev->fifo->sensor_time = (uint32_t)(sensor_time_byte3 | sensor_time_byte2 | sensor_time_byte1);
		*data_index = (*data_index) + BMI160_SENSOR_TIME_LENGTH;
	}
}

/*!
 *  @brief This API is used to parse and store the skipped_frame_count from
 *  the FIFO data in the structure instance dev.
 */
static void unpack_skipped_frame(uint16_t *data_index, const struct bmi160_dev *dev)
{
	/*Partial read, then move the data index to last data*/
	if (*data_index >= dev->fifo->length) {
		/*Update the data index as complete*/
		*data_index = dev->fifo->length;
	} else {
		dev->fifo->skipped_frame_count = dev->fifo->data[*data_index];
		/*Move the data index*/
		*data_index = (*data_index) + 1;
	}
}

/*!
 *  @brief This API is used to get the FOC status from the sensor
 */
static int8_t get_foc_status(uint8_t *foc_status, struct bmi160_dev const *dev)
{
	int8_t rslt;
	uint8_t data;

	/* Read the FOC status from sensor */
	rslt = bmi160_get_regs(BMI160_STATUS_ADDR, &data, 1, dev);
	if (rslt == BMI160_OK) {
		/* Get the foc_status bit */
		*foc_status = BMI160_GET_BITS(data, BMI160_FOC_STATUS);
	}

	return rslt;
}

/*!
 *  @brief This API is used to configure the offset enable bits in the sensor
 */
static int8_t configure_offset_enable(const struct bmi160_foc_conf *foc_conf, struct bmi160_dev const *dev)
{
	int8_t rslt;
	uint8_t data;

	/* Null-pointer check */
	rslt = null_ptr_check(dev);

	if (rslt != BMI160_OK) {
		rslt = BMI160_E_NULL_PTR;
	} else {
		/* Read the FOC config from the sensor */
		rslt = bmi160_get_regs(BMI160_OFFSET_CONF_ADDR, &data, 1, dev);

		if (rslt == BMI160_OK) {
			/* Set the offset enable/disable for gyro */
			data = BMI160_SET_BITS(data, BMI160_GYRO_OFFSET_EN, foc_conf->gyro_off_en);

			/* Set the offset enable/disable for accel */
			data = BMI160_SET_BITS(data, BMI160_ACCEL_OFFSET_EN, foc_conf->acc_off_en);

			/* Set the offset config in the sensor */
			rslt = bmi160_set_regs(BMI160_OFFSET_CONF_ADDR, &data, 1, dev);
		}
	}

	return rslt;
}

static int8_t trigger_foc(struct bmi160_offsets *offset, struct bmi160_dev const *dev)
{
	int8_t rslt;
	uint8_t foc_status;
	uint8_t cmd = BMI160_START_FOC_CMD;
	uint8_t timeout = 0;
	uint8_t data_array[20];

	/* Start the FOC process */
	rslt = bmi160_set_regs(BMI160_COMMAND_REG_ADDR, &cmd, 1, dev);
	if (rslt == BMI160_OK) {
		/* Check the FOC status*/
		rslt = get_foc_status(&foc_status, dev);
		if ((rslt != BMI160_OK) || (foc_status != BMI160_ENABLE)) {
			while ((foc_status != BMI160_ENABLE) && (timeout < 11)) {
				/* Maximum time of 250ms is given in 10
				 * steps of 25ms each */
				dev->delay_ms(25);
				/* Check the FOC status*/
				rslt = get_foc_status(&foc_status, dev);
				timeout++;
			}

			if ((rslt == BMI160_OK) && (foc_status == BMI160_ENABLE)) {
				/* Get offset values from sensor */
				rslt = bmi160_get_offsets(offset, dev);
			} else {
				/* FOC failure case */
				rslt = BMI160_FOC_FAILURE;
			}
		}

		if (rslt == BMI160_OK) {
			/* Read registers 0x04-0x17 */
			rslt = bmi160_get_regs(BMI160_GYRO_DATA_ADDR,
				data_array, 20, dev);
		}
	}


	return rslt;
}

/** @}*/