ESP32_OSC_IMU/lib/bmm150/bmm150.cpp

/**\mainpage
 * 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		bmm150.c
 * Date		12 Sep 2017
 * Version	1.0.0
 *
 */

 /*! @file bmm150.c
     @brief Sensor driver for BMM150 sensor */
#include "bmm150.h"

/************************** Internal macros *******************************/
/* Sensor ODR, Repetition and axes enable/disable settings */
#define MODE_SETTING_SEL		UINT16_C(0x000F)
/* Interrupt pin settings like polarity,latch and int_pin enable */
#define INTERRUPT_PIN_SETTING_SEL	UINT16_C(0x01F0)
/* Settings to enable/disable interrupts */
#define INTERRUPT_CONFIG_SEL		UINT16_C(0x1E00)
/* Interrupt settings for configuring threshold values */
#define INTERRUPT_THRESHOLD_CONFIG_SEL	UINT16_C(0x6000)

/********************** Static function declarations ************************/
/*!
 * @brief This internal API is used to validate the device pointer for
 * null conditions.
 *
 * @param[in] dev : Structure instance of bmm150_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success / +ve value -> Warning / -ve value -> Error
 */
static int8_t null_ptr_check(const struct bmm150_dev *dev);

/*!
 * @brief This internal API sets/resets the power control bit of 0x4B register.
 *
 * @param[in] pwrcntrl_bit : Variable used to select/deselect the suspend mode.
 * @param[in,out] dev      : Structure instance of bmm150_dev
 *
 * pwrcntrl_bit     |  power mode
 * -----------------|-------------------------
 * 0x00             |    Suspend mode
 * 0x01             |    Sleep/Active modes
 *
 * @return Result of API execution status
 * @retval zero -> Success / +ve value -> Warning / -ve value -> Error.
 */
static int8_t set_power_control_bit(uint8_t pwrcntrl_bit, struct bmm150_dev *dev);

/*!
 * @brief This internal API reads the trim registers of the sensor and stores
 * the trim values in the "trim_data" of device structure.
 *
 * @param[in,out] dev      : Structure instance of bmm150_dev
 *
 * @return Result of API execution status
 * @retval zero -> Success / +ve value -> Warning / -ve value -> Error.
 */
static int8_t read_trim_registers(struct bmm150_dev *dev);

/*!
 * @brief This internal API writes the op_mode value in the Opmode bits
 * (bits 1 and 2) of 0x4C register.
 *
 *  op_mode    |  Power mode
 * ------------|-----------------------
 *   0x00      |   BMM150_NORMAL_MODE
 *   0x01      |   BMM150_FORCED_MODE
 *   0x03      |   BMM150_SLEEP_MODE
 *
 * @param[in,out] dev      : Structure instance of bmm150_dev
 *
 * @return Result of API execution status
 * @retval zero -> Success / +ve value -> Warning / -ve value -> Error.
 */
static int8_t write_op_mode(uint8_t op_mode, const struct bmm150_dev *dev);

/*!
 * @brief This internal API sets the device from suspend to sleep mode
 * by setting the power control bit to '1' of 0x4B register
 *
 * @param[in,out] dev      : Structure instance of bmm150_dev
 *
 * @return Result of API execution status
 * @retval zero -> Success / +ve value -> Warning / -ve value -> Error.
 */
static int8_t suspend_to_sleep_mode(struct bmm150_dev *dev);

/*!
 * @brief This internal API sets the xy repetition value in the 0x51 register.
 *
 * @param[in,out] dev      : Structure instance of bmm150_dev
 *
 *  dev->settings.xy_rep    |  nXY(XY Repetitions)
 * -------------------------|-----------------------
 *   0x00                   |   1
 *   0x01                   |   3
 *   0x02                   |   5
 *    .                     |   .
 *    .                     |   .
 *   0xFF                   |   511
 *
 * @note number of XY Repetitions nXY  = 1+2(dev->settings.xy_rep)
 *
 * @return Result of API execution status
 * @retval zero -> Success / +ve value -> Warning / -ve value -> Error.
 */
static int8_t set_xy_rep(const struct bmm150_dev *dev);

/*!
 * @brief This internal API sets the z repetition value in the 0x52 register.
 *
 * @param[in,out] dev      : Structure instance of bmm150_dev
 *
 *  dev->settings.z_rep     |  nZ(Z Repetitions)
 * -------------------------|-----------------------
 *   0x00                   |   1
 *   0x01                   |   2
 *   0x02                   |   3
 *    .                     |   .
 *    .                     |   .
 *   0xFF                   |   256
 *
 * @note number of Z Repetitions nZ  = 1+(dev->settings.z_rep)
 *
 * @return Result of API execution status
 * @retval zero -> Success / +ve value -> Warning / -ve value -> Error.
 */
static int8_t set_z_rep(const struct bmm150_dev *dev);

/*!
 * @brief This internal API is used to set the output data rate of the sensor
 *
 * @param[in] dev       : Structure instance of bmm150_dev.
 *
 *  dev->settings.data_rate |   Data rate (ODR)
 * -------------------------|-----------------------
 *   0x00                   |  BMM150_DATA_RATE_10HZ
 *   0x01                   |  BMM150_DATA_RATE_02HZ
 *   0x02                   |  BMM150_DATA_RATE_06HZ
 *   0x03                   |  BMM150_DATA_RATE_08HZ
 *   0x04                   |  BMM150_DATA_RATE_15HZ
 *   0x05                   |  BMM150_DATA_RATE_20HZ
 *   0x06                   |  BMM150_DATA_RATE_25HZ
 *   0x07                   |  BMM150_DATA_RATE_30HZ
 *
 * @return Result of API execution status
 * @retval zero -> Success / +ve value -> Warning / -ve value -> Error
 */
static int8_t set_odr(const struct bmm150_dev *dev);

/*!
 * @brief This internal API sets the preset mode ODR and repetition settings.
 * @param[in] dev      : Structure instance of bmm150_dev
 *
 *  API settings            |  Representation
 * -------------------------|------------------------------
 * dev->settings.data_rate  | Output Data Rate (ODR)
 * dev->settings.xy_rep     | XY repetition value
 * dev->settings.z_rep      | Z-repetition value
 *
 *
 * @return Result of API execution status
 * @retval zero -> Success / +ve value -> Warning / -ve value -> Error.
 */
static int8_t set_odr_xyz_rep(const struct bmm150_dev *dev);

/*!
 * @brief This internal API is used to enable or disable the magnetic
 * measurement of x,y,z axes based on the value of xyz_axes_control.
 *
 * @param[in] dev        : Structure instance of bmm150_dev.
 *
 *  dev->settings.xyz_axes_control | Measurement axes/channel
 *  -------------------------------|--------------------------
 *	Bit 0                      | X - Channel
 *	Bit 1                      | Y - Channel
 *	Bit 2                      | Z - Channel
 *
 * @note Setting 1 - Disables Channel measurement
 * @note Setting 0 - Enables Channel measurement
 *
 * dev->settings.xyz_axes_control | Measurement axes Enabled/disabled
 * -------------------------------|------------------------------------
 *  0x01                          | Disables X axis (Y,Z axes enabled)
 *  0x02                          | Disables Y axis (X,Z axes enabled)
 *  0x04                          | Disables Z axis (X,Y axes enabled)
 *  0x07                          | Disables all X,Y,Z axes measurement
 *
 * @return Result of API execution status
 * @retval zero -> Success / +ve value -> Warning / -ve value -> Error
 */
static int8_t set_control_measurement_xyz(const struct bmm150_dev *dev);

/*!
 * @brief This internal API is used to identify the settings which the user
 * wants to modify in the sensor.
 *
 * @param[in] sub_settings : Contains the settings subset to identify particular
 * group of settings which the user is interested to change.
 * @param[in] settings : Contains the user specified settings.
 *
 * @return Indicates whether user is interested to modify the settings which
 * are related to sub_settings.
 * @retval True -> User wants to modify this group of settings
 * @retval False -> User does not want to modify this group of settings
 */
static uint8_t are_settings_changed(uint16_t sub_settings, uint16_t settings);

/*!
 * @brief This API sets the ODR , measurement axes control ,
 * repetition values of xy,z.
 *
 * @param[in] desired_settings : Contains the settings which user wants to
 * change.
 * @param[in] dev : Structure instance of bmm150_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success / +ve value -> Warning / -ve value -> Error
 */
static int8_t mode_settings(uint16_t desired_settings, const struct bmm150_dev *dev);
/*!
 * @brief This internal API is used to parse and store the sensor
 * settings in the device structure
 *
 * @param[in] reg_data   : Pointer of an array consisting all sensor
 *                         setting data from 0x4B to 0x52 registers.
 * @param[in] dev        : Structure instance of bmm150_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success / +ve value -> Warning / -ve value -> Error
 */
static void parse_setting(const uint8_t *reg_data, struct bmm150_dev *dev);

/*!
 * @brief This API is used to enable the interrupts and map them to the
 * corresponding interrupt pins and specify the pin characteristics like the
 * polarity , latch settings for the interrupt pins.
 *
 * @note The other interrupts can be latched or non-latched but,
 * Data ready interrupt is always cleared after reading out the data
 *
 * @param[in] desired_settings : Contains the settings which user wants to
 *                               change.
 * @param[in] dev              : Structure instance of bmm150_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success / +ve value -> Warning / -ve value -> Error
 */
static int8_t interrupt_pin_settings(uint16_t desired_settings, const struct bmm150_dev *dev);

/*!
 * @brief This API is used to enable data overrun , overflow interrupts and
 * enable/disable high/low threshold interrupts for x,y,z axis based on the
 * threshold values set by the user in the High threshold (0x50) and
 * Low threshold (0x4F) registers.
 *
 * @param[in] desired_settings : Contains the settings which user wants to
 *                               change.
 * @param[in] dev              : Structure instance of bmm150_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success / +ve value -> Warning / -ve value -> Error
 */
static int8_t interrupt_config(uint16_t desired_settings, const struct bmm150_dev *dev);

/*!
 * @brief This API is used to write the user specified High/Low threshold value
 * as a reference to generate the high/low threshold interrupt.
 *
 * @param[in] desired_settings : Contains the settings which user wants to
 *                               change.
 * @param[in] dev              : Structure instance of bmm150_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success / +ve value -> Warning / -ve value -> Error
 */
static int8_t interrupt_threshold_settings(uint16_t desired_settings, const struct bmm150_dev *dev);

#ifdef BMM150_USE_FLOATING_POINT
/*!
 * @brief This internal API is used to obtain the compensated
 * magnetometer X axis data in float.
 *
 * @param[in] mag_data_x     : The value of raw X data
 * @param[in] data_rhall     : The value of raw RHALL data
 * @param[in] dev            : Structure instance of bmm150_dev.
 *
 * @return Result of compensated X data value in float
 */
static float compensate_x(int16_t mag_data_x, uint16_t data_rhall, const struct bmm150_dev *dev);

/*!
 * @brief This internal API is used to obtain the compensated
 * magnetometer Y axis data in float.
 *
 * @param[in] mag_data_y     : The value of raw Y data
 * @param[in] data_rhall     : The value of raw RHALL data
 * @param[in] dev            : Structure instance of bmm150_dev.
 *
 * @return Result of compensated Y data value in float
 */
static float compensate_y(int16_t mag_data_y, uint16_t data_rhall, const struct bmm150_dev *dev);

/*!
 * @brief This internal API is used to obtain the compensated
 * magnetometer Z axis data in float.
 *
 * @param[in] mag_data_z     : The value of raw Z data
 * @param[in] data_rhall     : The value of raw RHALL data
 * @param[in] dev            : Structure instance of bmm150_dev.
 *
 * @return Result of compensated Z data value in float
 */
static float compensate_z(int16_t mag_data_z, uint16_t data_rhall, const struct bmm150_dev *dev);

#else

/*!
 * @brief This internal API is used to obtain the compensated
 * magnetometer X axis data in int16_t.
 *
 * @param[in] mag_data_x     : The value of raw X data
 * @param[in] data_rhall     : The value of raw RHALL data
 * @param[in] dev            : Structure instance of bmm150_dev.
 *
 * @return Result of compensated X data value in int16_t format
 */
static int16_t compensate_x(int16_t mag_data_x, uint16_t data_rhall, const struct bmm150_dev *dev);

/*!
 * @brief This internal API is used to obtain the compensated
 * magnetometer Y axis data in int16_t.
 *
 * @param[in] mag_data_y     : The value of raw Y data
 * @param[in] data_rhall     : The value of raw RHALL data
 * @param[in] dev            : Structure instance of bmm150_dev.
 *
 * @return Result of compensated Y data value in int16_t format
 */
static int16_t compensate_y(int16_t mag_data_y, uint16_t data_rhall, const struct bmm150_dev *dev);

/*!
 * @brief This internal API is used to obtain the compensated
 * magnetometer Z axis data in int16_t.
 *
 * @param[in] mag_data_z     : The value of raw Z data
 * @param[in] data_rhall     : The value of raw RHALL data
 * @param[in] dev            : Structure instance of bmm150_dev.
 *
 * @return Result of compensated Z data value in int16_t format
 */
static int16_t compensate_z(int16_t mag_data_z, uint16_t data_rhall, const struct bmm150_dev *dev);

#endif

/*!
 * @brief This internal API is used to perform the normal self test
 * of the sensor and return the self test result as return value
 *
 * @param[in] dev          : Structure instance of bmm150_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success / +ve value -> Warning / -ve value -> Error
 */
static int8_t perform_normal_self_test(const struct bmm150_dev *dev);

/*!
 * @brief This internal API is used to enable the normal self test by setting
 * the Self Test bit (bit0) of the 0x4C register,
 * which triggers the start of self test
 *
 * @param[out] self_test_enable : The value of self test bit0 in 0x4C register
 * @param[in] dev               : Structure instance of bmm150_dev.
 *
 * @return Result of API execution status
 * @retval zero -> Success / +ve value -> Warning / -ve value -> Error
 */
static int8_t enable_normal_self_test(uint8_t *self_test_enable, const struct bmm150_dev *dev);

/*!
 * @brief This internal API is used to validate the results of normal self test
 * by using the self test status available in the bit0 of registers 0x42,0x44
 * and 0x46.
 *
 * @param[in] dev       : Structure instance of bmm150_dev
 *
 * @return Result of API execution status
 * @retval zero -> Success / +ve value -> Warning / -ve value -> Error
 */
static int8_t validate_normal_self_test(const struct bmm150_dev *dev);

/*!
 * @brief This internal API is used to perform advanced self test for Z axis
 *
 * @param[in] dev     : Structure instance of bmm150_dev
 *
 * @return Result of API execution status
 * @retval zero -> Success / +ve value -> Warning / -ve value -> Error
 *
 * Return value         | Status of self-test
 *----------------------|---------------------------
 *      0               | BMM150_OK
 *      8               | BMM150_W_ADV_SELF_TEST_FAIL
 */
static int8_t perform_adv_self_test(struct bmm150_dev *dev);

/*!
 * @brief This internal API is used to set the desired power mode ,
 * axes control and repetition settings for advanced self test
 *
 * @param[in] dev   :  Structure instance of bmm150_dev
 *
 * @return Result of API execution status
 * @retval zero -> Success / +ve value -> Warning / -ve value -> Error
 */
static int8_t adv_self_test_settings(struct bmm150_dev *dev);

/*!
 * @brief This internal API is used to set the positive or negative value of
 * self-test current and obtain the corresponding magnetometer z axis data
 *
 * @param[in] self_test_current  : Self test current either positive/negative
 * @param[out] data_z            : Z-axis Magnetometer data
 * @param[in] dev                : Structure instance of bmm150_dev
 *
 * self_test_current       | Self-test current Direction
 *-------------------------|------------------------------
 *     0x03                | BMM150_ENABLE_POSITIVE_CURRENT
 *     0x02                | BMM150_ENABLE_NEGATIVE_CURRENT
 *
 * @return Result of API execution status
 * @retval zero -> Success / +ve value -> Warning / -ve value -> Error
 */
static int8_t adv_self_test_measurement(uint8_t self_test_current, int16_t *data_z, struct bmm150_dev *dev);

/*!
 * @brief This internal API is used to get the difference between the
 * Z axis mag data obtained by positive and negative self-test current
 * and validate whether the advanced self test is done successfully or not.
 *
 * @param[in] positive_data_z   : Z-axis Mag data by positive self-test current
 * @param[in] negative_data_z  : Z-axis Mag data by negative self-test current
 *
 *
 * @return Result of API execution status
 * @retval zero -> Success / +ve value -> Warning / -ve value -> Error
 *
 *  Return value        | Status of self-test
 *----------------------|---------------------------
 *      0               | BMM150_OK
 *      8               | BMM150_W_ADV_SELF_TEST_FAIL
 */
static int8_t validate_adv_self_test(int16_t positive_data_z, int16_t negative_data_z);

/*!
 * @brief This internal API is used to set the self test current value in
 * the Adv. ST bits (bit6 and bit7) of 0x4C register
 *
 * @param[in] self_test_current  : Self test current value (+ve/-ve)
 * @param[in] dev                : Structure instance of bmm150_dev
 *
 * self_test_current       | Self-test current Direction
 *-------------------------|------------------------------
 *     0x00                | BMM150_DISABLE_SELF_TEST_CURRENT
 *     0x02                | BMM150_ENABLE_NEGATIVE_CURRENT
 *     0x03                | BMM150_ENABLE_POSITIVE_CURRENT
 *
 * @return Result of API execution status
 * @retval zero -> Success / +ve value -> Warning / -ve value -> Error
 */
static int8_t set_adv_self_test_current(uint8_t self_test_current, const struct bmm150_dev *dev);

/********************** Global function definitions ************************/
/*!
 *  @brief This API is the entry point, Call this API before using other APIs.
 *  This API reads the chip-id of the sensor which is the first step to
 *  verify the sensor and updates the trim parameters of the sensor.
 */
int8_t bmm150_init(struct bmm150_dev *dev)
{
	int8_t rslt;
	uint8_t chip_id = 0;

	/* Check for null pointer in the device structure*/
	rslt = null_ptr_check(dev);
	/* Proceed if null check is fine */
	if (rslt ==  BMM150_OK) {
		/* Power up the sensor from suspend to sleep mode */
		rslt = set_power_control_bit(BMM150_POWER_CNTRL_ENABLE, dev);
		/* Start-up time delay of 3ms*/
		dev->delay_ms(BMM150_START_UP_TIME);
		if (rslt ==  BMM150_OK) {
			/* Chip ID of the sensor is read */
			rslt = bmm150_get_regs(BMM150_CHIP_ID_ADDR, &chip_id, 1, dev);
			/* Proceed if everything is fine until now */
			if (rslt ==  BMM150_OK) {
				/* Check for chip id validity */
				if (chip_id == BMM150_CHIP_ID) {
					dev->chip_id = chip_id;
					/* Function to update trim values */
					rslt = read_trim_registers(dev);
				} else {
					rslt = BMM150_E_DEV_NOT_FOUND;
				}
			}
		}
	}

	return rslt;
}

/*!
 * @brief This API writes the given data to the register address
 * of the sensor.
 */
int8_t bmm150_set_regs(uint8_t reg_addr, uint8_t *reg_data, uint8_t len, const struct bmm150_dev *dev)
{
	int8_t rslt;

	/* Check for null pointer in the device structure*/
	rslt = null_ptr_check(dev);
	/* Proceed if null check is fine */
	if ((rslt ==  BMM150_OK) && (reg_data != NULL) && (len != 0)) {
		/* Write the data to the reg_addr */
		/* SPI write requires to set The MSB of reg_addr as 0
		but in default the MSB is always 0 */
		rslt = dev->write(dev->dev_id, reg_addr, reg_data, len);
	} else {
		rslt = BMM150_E_NULL_PTR;
	}

	return rslt;
}

/*!
 * @brief This API reads the data from the given register address of the sensor.
 */
int8_t bmm150_get_regs(uint8_t reg_addr, uint8_t *reg_data, uint8_t len, const struct bmm150_dev *dev)
{
	int8_t rslt;

	/* Check for null pointer in the device structure*/
	rslt = null_ptr_check(dev);
	/* Proceed if null check is fine */
	if ((rslt ==  BMM150_OK) && (reg_data != NULL)) {
		if (dev->intf != BMM150_I2C_INTF) {
			/* If interface selected is SPI */
			reg_addr = reg_addr | 0x80;
		}
		/* Read the data from the reg_addr */
		rslt = dev->read(dev->dev_id, reg_addr, reg_data, len);
	} else {
		rslt = BMM150_E_NULL_PTR;
	}

	return rslt;
}

/*!
 * @brief This API is used to perform soft-reset of the sensor
 * where all the registers are reset to their default values except 0x4B.
 */
int8_t bmm150_soft_reset(const struct bmm150_dev *dev)
{
	int8_t rslt;
	uint8_t reg_data;

	/* Check for null pointer in the device structure*/
	rslt = null_ptr_check(dev);
	/* Proceed if null check is fine */
	if (rslt ==  BMM150_OK) {
		rslt = bmm150_get_regs(BMM150_POWER_CONTROL_ADDR, &reg_data, 1, dev);
		if (rslt ==  BMM150_OK) {
			reg_data = reg_data | BMM150_SET_SOFT_RESET;
			rslt = bmm150_set_regs(BMM150_POWER_CONTROL_ADDR, &reg_data, 1, dev);
			dev->delay_ms(BMM150_SOFT_RESET_DELAY);
		}
	}

	return rslt;
}

/*!
 * @brief This API is used to set the power mode of the sensor.
 */
int8_t bmm150_set_op_mode(struct bmm150_dev *dev)
{
	int8_t rslt;

	uint8_t pwr_mode = dev->settings.pwr_mode;

	/* Check for null pointer in the device structure*/
	rslt = null_ptr_check(dev);
	/* Proceed if null check is fine */
	if (rslt ==  BMM150_OK) {
		/* Select the power mode to set */
		switch (pwr_mode) {
		case BMM150_NORMAL_MODE:
			/* If the sensor is in suspend mode
			put the device to sleep mode */
			rslt = suspend_to_sleep_mode(dev);
			if (rslt == BMM150_OK) {
				/* write the op mode */
				rslt = write_op_mode(pwr_mode, dev);
			}
			break;
		case BMM150_FORCED_MODE:
			/* If the sensor is in suspend mode
			put the device to sleep mode */
			rslt = suspend_to_sleep_mode(dev);
			if (rslt == BMM150_OK) {
				/* write the op mode */
				rslt = write_op_mode(pwr_mode, dev);
			}
			break;
		case BMM150_SLEEP_MODE:
			/* If the sensor is in suspend mode
			put the device to sleep mode */
			rslt = suspend_to_sleep_mode(dev);
			if (rslt == BMM150_OK) {
				/* write the op mode */
				rslt = write_op_mode(pwr_mode, dev);
			}
			break;
		case BMM150_SUSPEND_MODE:
			/* Set the power control bit to zero */
			rslt = set_power_control_bit(BMM150_POWER_CNTRL_DISABLE, dev);
			break;
		default:
			rslt = BMM150_E_INVALID_CONFIG;
			break;
		}
	}

	return rslt;
}

/*!
 * @brief This API is used to get the power mode of the sensor.
 */
int8_t bmm150_get_op_mode(uint8_t *op_mode, const struct bmm150_dev *dev)
{
	int8_t rslt;
	uint8_t reg_data;

	/* Check for null pointer in the device structure*/
	rslt = null_ptr_check(dev);

	/* Proceed if null check is fine */
	if (rslt ==  BMM150_OK) {
		if (dev->settings.pwr_cntrl_bit == BMM150_POWER_CNTRL_DISABLE) {
			/* Power mode set is suspend mode*/
			*op_mode = BMM150_SUSPEND_MODE;
		} else {
			/*Power mode set is stored in the op_mode */
			rslt = bmm150_get_regs(BMM150_OP_MODE_ADDR, &reg_data, 1, dev);
			*op_mode = BMM150_GET_BITS(reg_data, BMM150_OP_MODE);
		}
	}

	return rslt;
}

/*!
 * @brief This API is used to set the preset mode of the sensor.
 */
int8_t bmm150_set_presetmode(struct bmm150_dev *dev)
{
	int8_t rslt;
	uint8_t preset_mode;

	/* Check for null pointer in the device structure*/
	rslt = null_ptr_check(dev);
	/* Proceed if null check is fine */
	if (rslt ==  BMM150_OK) {
		preset_mode = dev->settings.preset_mode;
		switch (preset_mode) {
		case BMM150_PRESETMODE_LOWPOWER:
			/* Set the data rate x,y,z repetition
			for Low Power mode */
			dev->settings.data_rate = BMM150_DATA_RATE_10HZ;
			dev->settings.xy_rep = BMM150_LOWPOWER_REPXY;
			dev->settings.z_rep = BMM150_LOWPOWER_REPZ;
			rslt = set_odr_xyz_rep(dev);
			break;
		case BMM150_PRESETMODE_REGULAR:
			/* Set the data rate x,y,z repetition
			for Regular mode */
			dev->settings.data_rate = BMM150_DATA_RATE_10HZ;
			dev->settings.xy_rep = BMM150_REGULAR_REPXY;
			dev->settings.z_rep = BMM150_REGULAR_REPZ;
			rslt = set_odr_xyz_rep(dev);
			break;
		case BMM150_PRESETMODE_HIGHACCURACY:
			/* Set the data rate x,y,z repetition
			for High Accuracy mode */
			dev->settings.data_rate = BMM150_DATA_RATE_20HZ;
			dev->settings.xy_rep = BMM150_HIGHACCURACY_REPXY;
			dev->settings.z_rep = BMM150_HIGHACCURACY_REPZ;
			rslt = set_odr_xyz_rep(dev);
			break;
		case BMM150_PRESETMODE_ENHANCED:
			/* Set the data rate x,y,z repetition
			for Enhanced Accuracy mode */
			dev->settings.data_rate = BMM150_DATA_RATE_10HZ;
			dev->settings.xy_rep = BMM150_ENHANCED_REPXY;
			dev->settings.z_rep = BMM150_ENHANCED_REPZ;
			rslt = set_odr_xyz_rep(dev);
			break;
		default:
			rslt = BMM150_E_INVALID_CONFIG;
			break;
		}
	}

	return rslt;
}

/*!
 * @brief This API sets the sensor settings based on the desired_settings
 * and the dev structure configuration
 */
int8_t bmm150_set_sensor_settings(uint16_t desired_settings, const struct bmm150_dev *dev)
{
	int8_t rslt;

	/* Check for null pointer in the device structure*/
	rslt = null_ptr_check(dev);
	/* Proceed if null check is fine */
	if (rslt ==  BMM150_OK) {
		if (are_settings_changed(MODE_SETTING_SEL, desired_settings)) {
			/* ODR, Control measurement, XY,Z repetition values*/
			rslt = mode_settings(desired_settings, dev);
		}
		if ((!rslt) && are_settings_changed(INTERRUPT_PIN_SETTING_SEL, desired_settings)) {
			/* Interrupt pin settings */
			rslt = interrupt_pin_settings(desired_settings, dev);
		}
		if ((!rslt) && are_settings_changed(INTERRUPT_CONFIG_SEL, desired_settings)) {
			/* Interrupt configuration settings */
			rslt = interrupt_config(desired_settings, dev);
		}
		if ((!rslt) && are_settings_changed(INTERRUPT_THRESHOLD_CONFIG_SEL, desired_settings)) {
			/* Interrupt threshold settings */
			rslt = interrupt_threshold_settings(desired_settings, dev);
		}

	}

	return rslt;
}

/*!
 * @brief This API gets the sensor settings and updates the dev structure
 */
int8_t bmm150_get_sensor_settings(struct bmm150_dev *dev)
{
	int8_t rslt;
	uint8_t setting[BMM150_SETTING_DATA_LEN] = {0};

	/* Check for null pointer in the device structure*/
	rslt = null_ptr_check(dev);
	/* Proceed if null check is fine */
	if (rslt ==  BMM150_OK) {
		/*Read the entire sensor settings */
		rslt = bmm150_get_regs(BMM150_POWER_CONTROL_ADDR, setting, BMM150_SETTING_DATA_LEN, dev);
		if (rslt ==  BMM150_OK) {
			/*Parse and store the settings */
			parse_setting(setting, dev);
		}
	}

	return rslt;
}

/*!
 * @brief This API is used to read the magnetometer data from registers
 * 0x42 to 0x49 and update the dev structure with the
 * compensated mag data in micro-tesla.
 */
int8_t bmm150_read_mag_data(struct bmm150_dev *dev)
{
	int8_t rslt;
	int16_t msb_data;
	uint8_t reg_data[BMM150_XYZR_DATA_LEN] = {0};
	struct bmm150_raw_mag_data raw_mag_data;

	/* Check for null pointer in the device structure*/
	rslt = null_ptr_check(dev);
	/* Proceed if null check is fine */
	if (rslt ==  BMM150_OK) {
		/*Read the mag data registers */
		rslt = bmm150_get_regs(BMM150_DATA_X_LSB, reg_data, BMM150_XYZR_DATA_LEN, dev);
		if (rslt ==  BMM150_OK) {
			/* Mag X axis data */
			reg_data[0] = BMM150_GET_BITS(reg_data[0], BMM150_DATA_X);
			/* Shift the MSB data to left by 5 bits */
			/* Multiply by 32 to get the shift left by 5 value */
			msb_data = ((int16_t)((int8_t)reg_data[1])) * 32;
			/* Raw mag X axis data */
			raw_mag_data.raw_datax = (int16_t)(msb_data | reg_data[0]);
			/* Mag Y axis data */
			reg_data[2] = BMM150_GET_BITS(reg_data[2], BMM150_DATA_Y);
			/* Shift the MSB data to left by 5 bits */
			/* Multiply by 32 to get the shift left by 5 value */
			msb_data = ((int16_t)((int8_t)reg_data[3])) * 32;
			/* Raw mag Y axis data */
			raw_mag_data.raw_datay = (int16_t)(msb_data | reg_data[2]);
			/* Mag Z axis data */
			reg_data[4] = BMM150_GET_BITS(reg_data[4], BMM150_DATA_Z);
			/* Shift the MSB data to left by 7 bits */
			/* Multiply by 128 to get the shift left by 7 value */
			msb_data = ((int16_t)((int8_t)reg_data[5])) * 128;
			/* Raw mag Z axis data */
			raw_mag_data.raw_dataz = (int16_t)(msb_data | reg_data[4]);
			/* Mag R-HALL data */
			reg_data[6] = BMM150_GET_BITS(reg_data[6], BMM150_DATA_RHALL);
			raw_mag_data.raw_data_r = (uint16_t)(((uint16_t)reg_data[7] << 6) | reg_data[6]);
			/* Compensated Mag X data in int16_t format */
			dev->data.x = compensate_x(raw_mag_data.raw_datax, raw_mag_data.raw_data_r, dev);
			/* Compensated Mag Y data in int16_t format */
			dev->data.y = compensate_y(raw_mag_data.raw_datay, raw_mag_data.raw_data_r, dev);
			/* Compensated Mag Z data in int16_t format */
			dev->data.z = compensate_z(raw_mag_data.raw_dataz, raw_mag_data.raw_data_r, dev);
		}
	}

	return rslt;
}

/*!
 * @brief This API is used to perform the complete self test
 * (both normal and advanced) for the BMM150 sensor
 */
int8_t bmm150_perform_self_test(uint8_t self_test_mode, struct bmm150_dev *dev)
{
	int8_t rslt;
	int8_t self_test_rslt = 0;

	/* Check for null pointer in the device structure*/
	rslt = null_ptr_check(dev);
	/* Proceed if null check is fine */
	if (rslt ==  BMM150_OK) {
		switch (self_test_mode) {
		case BMM150_NORMAL_SELF_TEST:
			/* Set the sensor in sleep mode */
			dev->settings.pwr_mode = BMM150_SLEEP_MODE;
			rslt = bmm150_set_op_mode(dev);
			if (rslt == BMM150_OK) {
				/* Perform the normal self test */
				rslt = perform_normal_self_test(dev);
			}
			break;

		case BMM150_ADVANCED_SELF_TEST:
			/* Perform the advanced self test */
			rslt = perform_adv_self_test(dev);
			/* Check to ensure bus error does not occur */
			if (rslt >=  BMM150_OK) {
				/* Store the status of self test result */
				self_test_rslt = rslt;
				/* Perform soft reset */
				rslt = bmm150_soft_reset(dev);
			}
			/* Check to ensure bus operations are success */
			if (rslt == BMM150_OK) {
				/* Restore self_test_rslt as return value */
				rslt = self_test_rslt;
			}
			break;
		default:
			rslt = BMM150_E_INVALID_CONFIG;
			break;
		}
	}

	return rslt;
}

/*!
 * @brief This API is used to get the status flags of all interrupt
 * which is used to check for the assertion of interrupts
 */
int8_t bmm150_get_interrupt_status(struct bmm150_dev *dev)
{
	int8_t rslt;
	uint8_t interrupt_status;
	uint8_t data_ready_status;

	/* Check for null pointer in the device structure*/
	rslt = null_ptr_check(dev);
	/* Proceed if null check is fine */
	if (rslt ==  BMM150_OK) {
		/* Read the data ready status from the register 0x48 */
		rslt = bmm150_get_regs(BMM150_DATA_READY_STATUS, &data_ready_status, 1, dev);
		if (rslt == BMM150_OK) {
			/* Read the interrupt status from the register 0x50 */
			rslt = bmm150_get_regs(BMM150_INTERRUPT_STATUS, &interrupt_status, 1, dev);
			if (rslt == BMM150_OK) {
				/* Mask and store the data ready status bit*/
				data_ready_status = BMM150_GET_BITS_POS_0(data_ready_status, BMM150_DRDY_STATUS);
				/* store the entire interrupt status in dev */
				dev->int_status = (data_ready_status << 8) | interrupt_status;
			}
		}
	}

	return rslt;
}

/****************************************************************************/
/**\name	BMM150 as Auxiliary Mag                                     */

/*!
 * @brief This API is used to compensate the raw mag data
 */
int8_t bmm150_aux_mag_data(uint8_t *aux_data, struct bmm150_dev *dev)
{
	int8_t rslt;
	int16_t msb_data;
	struct bmm150_raw_mag_data raw_mag_data;

	/* Check for null pointer in the device structure*/
	rslt = null_ptr_check(dev);
	/* Proceed if null check is fine */
	if ((rslt ==  BMM150_OK) && (aux_data != NULL)) {
		/* Mag X axis data */
		aux_data[0] = BMM150_GET_BITS(aux_data[0], BMM150_DATA_X);
		/* Shift the MSB data to left by 5 bits */
		/* Multiply by 32 to get the shift left by 5 value */
		msb_data = ((int16_t)((int8_t)aux_data[1])) * 32;
		/* Raw mag X axis data */
		raw_mag_data.raw_datax = (int16_t)(msb_data | aux_data[0]);
		/* Mag Y axis data */
		aux_data[2] = BMM150_GET_BITS(aux_data[2], BMM150_DATA_Y);
		/* Shift the MSB data to left by 5 bits */
		/* Multiply by 32 to get the shift left by 5 value */
		msb_data = ((int16_t)((int8_t)aux_data[3])) * 32;
		/* Raw mag Y axis data */
		raw_mag_data.raw_datay = (int16_t)(msb_data | aux_data[2]);
		/* Mag Z axis data */
		aux_data[4] = BMM150_GET_BITS(aux_data[4], BMM150_DATA_Z);
		/* Shift the MSB data to left by 7 bits */
		/* Multiply by 128 to get the shift left by 7 value */
		msb_data = ((int16_t)((int8_t)aux_data[5])) * 128;
		/* Raw mag Z axis data */
		raw_mag_data.raw_dataz = (int16_t)(msb_data | aux_data[4]);
		/* Mag R-HALL data */
		aux_data[6] = BMM150_GET_BITS(aux_data[6], BMM150_DATA_RHALL);
		raw_mag_data.raw_data_r = (uint16_t)(((uint16_t)aux_data[7] << 6) | aux_data[6]);
		/* Compensated Mag X data in int16_t format */
		dev->data.x = compensate_x(raw_mag_data.raw_datax, raw_mag_data.raw_data_r, dev);
		/* Compensated Mag Y data in int16_t format */
		dev->data.y = compensate_y(raw_mag_data.raw_datay, raw_mag_data.raw_data_r, dev);
		/* Compensated Mag Z data in int16_t format */
		dev->data.z = compensate_z(raw_mag_data.raw_dataz, raw_mag_data.raw_data_r, dev);
	}

	return rslt;
}

/****************************************************************************/
/**\name	INTERNAL APIs                                               */

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

	if ((dev == NULL) || (dev->read == NULL) || (dev->write == NULL) || (dev->delay_ms == NULL)) {
		/* Device structure pointer is not valid */
		rslt = BMM150_E_NULL_PTR;
	} else {
		/* Device structure is fine */
		rslt = BMM150_OK;
	}

	return rslt;
}

/*!
 * @brief This internal API sets/resets the power control bit of 0x4B register.
 */
static int8_t set_power_control_bit(uint8_t pwrcntrl_bit, struct bmm150_dev *dev)
{
	int8_t rslt;
	uint8_t reg_data = 0;

	/* Check for null pointer in the device structure*/
	rslt = null_ptr_check(dev);
	/* Proceed if null check is fine */
	if (rslt ==  BMM150_OK) {
		/* Power control register 0x4B is read */
		rslt = bmm150_get_regs(BMM150_POWER_CONTROL_ADDR, &reg_data, 1, dev);
		/* Proceed if everything is fine until now */
		if (rslt ==  BMM150_OK) {
			/* Sets the value of power control bit */
			reg_data = BMM150_SET_BITS_POS_0(reg_data, BMM150_PWR_CNTRL, pwrcntrl_bit);
			rslt = bmm150_set_regs(BMM150_POWER_CONTROL_ADDR, &reg_data, 1, dev);
			if (rslt ==  BMM150_OK) {
				/*Store the power control bit
				value in dev structure*/
				dev->settings.pwr_cntrl_bit = pwrcntrl_bit;
			}
		}
	}

	return rslt;
}

/*!
 * @brief This internal API reads the trim registers of the sensor and stores
 * the trim values in the "trim_data" of device structure.
 */
static int8_t read_trim_registers(struct bmm150_dev *dev)
{
	int8_t rslt;
	uint8_t trim_x1y1[2] = {0};
	uint8_t trim_xyz_data[4] = {0};
	uint8_t trim_xy1xy2[10] = {0};
	uint16_t temp_msb = 0;

	/* Trim register value is read */
	rslt = bmm150_get_regs(BMM150_DIG_X1, trim_x1y1, 2, dev);
	if (rslt ==  BMM150_OK) {
		rslt = bmm150_get_regs(BMM150_DIG_Z4_LSB, trim_xyz_data, 4, dev);
		if (rslt ==  BMM150_OK) {
			rslt = bmm150_get_regs(BMM150_DIG_Z2_LSB, trim_xy1xy2, 10, dev);
			if (rslt ==  BMM150_OK) {
				/* Trim data which is read is updated
				in the device structure */
				dev->trim_data.dig_x1 = (int8_t)trim_x1y1[0];
				dev->trim_data.dig_y1 = (int8_t)trim_x1y1[1];
				dev->trim_data.dig_x2 = (int8_t)trim_xyz_data[2];
				dev->trim_data.dig_y2 = (int8_t)trim_xyz_data[3];
				temp_msb = ((uint16_t)trim_xy1xy2[3]) << 8;
				dev->trim_data.dig_z1 = (uint16_t)(temp_msb | trim_xy1xy2[2]);
				temp_msb = ((uint16_t)trim_xy1xy2[1]) << 8;
				dev->trim_data.dig_z2 = (int16_t)(temp_msb | trim_xy1xy2[0]);
				temp_msb = ((uint16_t)trim_xy1xy2[7]) << 8;
				dev->trim_data.dig_z3 = (int16_t)(temp_msb | trim_xy1xy2[6]);
				temp_msb = ((uint16_t)trim_xyz_data[1]) << 8;
				dev->trim_data.dig_z4 = (int16_t)(temp_msb | trim_xyz_data[0]);
				dev->trim_data.dig_xy1 = trim_xy1xy2[9];
				dev->trim_data.dig_xy2 = (int8_t)trim_xy1xy2[8];
				temp_msb = ((uint16_t)(trim_xy1xy2[5] & 0x7F)) << 8;
				dev->trim_data.dig_xyz1 = (uint16_t)(temp_msb | trim_xy1xy2[4]);
			}
		}
	}


	return rslt;
}

/*!
 * @brief This internal API writes the op_mode value in the Opmode bits
 * (bits 1 and 2) of 0x4C register.
 */
static int8_t write_op_mode(uint8_t op_mode, const struct bmm150_dev *dev)
{
	int8_t rslt;
	uint8_t reg_data;

	/* Check for null pointer in the device structure*/
	rslt = null_ptr_check(dev);
	/* Proceed if null check is fine */
	if (rslt ==  BMM150_OK) {
		/* Read the 0x4C register */
		rslt = bmm150_get_regs(BMM150_OP_MODE_ADDR, &reg_data, 1, dev);
		if (rslt ==  BMM150_OK) {
			/* Set the op_mode value in Opmode bits of 0x4C */
			reg_data = BMM150_SET_BITS(reg_data, BMM150_OP_MODE, op_mode);
			rslt = bmm150_set_regs(BMM150_OP_MODE_ADDR, &reg_data, 1, dev);
		}
	}

	return rslt;
}

/*!
 * @brief This internal API sets the device from suspend to sleep mode
 * by setting the power control bit to '1' of 0x4B register
 */
static int8_t suspend_to_sleep_mode(struct bmm150_dev *dev)
{
	int8_t rslt;

	/* Check for null pointer in the device structure*/
	rslt = null_ptr_check(dev);
	/* Proceed if null check is fine */
	if (rslt ==  BMM150_OK) {
		if (dev->settings.pwr_cntrl_bit == BMM150_POWER_CNTRL_DISABLE) {
			rslt = set_power_control_bit(BMM150_POWER_CNTRL_ENABLE, dev);
			/* Start-up time delay of 3ms*/
			dev->delay_ms(BMM150_START_UP_TIME);
		}
	}

	return rslt;
}

/*!
 * @brief This internal API sets the xy repetition value in the 0x51 register.
 */
static int8_t set_xy_rep(const struct bmm150_dev *dev)
{
	int8_t rslt;
	uint8_t rep_xy;

	/* Check for null pointer in the device structure*/
	rslt = null_ptr_check(dev);
	/* Proceed if null check is fine */
	if (rslt ==  BMM150_OK) {
		/* set the xy repetition */
		rep_xy = dev->settings.xy_rep;
		rslt = bmm150_set_regs(BMM150_REP_XY_ADDR, &rep_xy, 1, dev);
	}

	return rslt;
}

/*!
 * @brief This internal API sets the z repetition value in the 0x52 register.
 */
static int8_t set_z_rep(const struct bmm150_dev *dev)
{
	int8_t rslt;
	uint8_t rep_z;

	/* Check for null pointer in the device structure*/
	rslt = null_ptr_check(dev);
	/* Proceed if null check is fine */
	if (rslt ==  BMM150_OK) {
		/* set the z repetition */
		rep_z = dev->settings.z_rep;
		rslt = bmm150_set_regs(BMM150_REP_Z_ADDR, &rep_z, 1, dev);
	}

	return rslt;
}

/*!
 * @brief This internal API is used to set the output data rate of the sensor.
*/
static int8_t set_odr(const struct bmm150_dev *dev)
{
	int8_t rslt;
	uint8_t reg_data;

	/* Check for null pointer in the device structure*/
	rslt = null_ptr_check(dev);
	/* Proceed if null check is fine */
	if (rslt ==  BMM150_OK) {
		/*Read the 0x4C register */
		rslt = bmm150_get_regs(BMM150_OP_MODE_ADDR, &reg_data, 1, dev);
		if (rslt ==  BMM150_OK) {
			/*Set the ODR value */
			reg_data = BMM150_SET_BITS(reg_data, BMM150_ODR, dev->settings.data_rate);
			rslt = bmm150_set_regs(BMM150_OP_MODE_ADDR, &reg_data, 1, dev);
		}
	}

	return rslt;
}

/*!
 * @brief This internal API sets the preset mode ODR and repetition settings.
 */
static int8_t set_odr_xyz_rep(const struct bmm150_dev *dev)
{
	int8_t rslt;

	/* Set the ODR */
	rslt = set_odr(dev);
	if (rslt ==  BMM150_OK) {
		/* Set the XY-repetitions number */
		rslt = set_xy_rep(dev);
		if (rslt ==  BMM150_OK) {
			/* Set the Z-repetitions number */
			rslt = set_z_rep(dev);
		}
	}

	return rslt;
}

/*!
 * @brief This internal API is used to enable or disable the magnetic
 * measurement of x,y,z axes based on the value of xyz_axes_control.
 */
static int8_t set_control_measurement_xyz(const struct bmm150_dev *dev)
{
	int8_t rslt;
	uint8_t reg_data;

	/* Check for null pointer in the device structure*/
	rslt = null_ptr_check(dev);
	/* Proceed if null check is fine */
	if (rslt ==  BMM150_OK) {
		rslt = bmm150_get_regs(BMM150_AXES_ENABLE_ADDR, &reg_data, 1, dev);
		if (rslt ==  BMM150_OK) {
			/* Set the axes to be enabled/disabled*/
			reg_data = BMM150_SET_BITS(reg_data, BMM150_CONTROL_MEASURE, dev->settings.xyz_axes_control);
			rslt = bmm150_set_regs(BMM150_AXES_ENABLE_ADDR, &reg_data, 1, dev);
		}
	}

	return rslt;
}

/*!
 * @brief This internal API is used to identify the settings which the user
 * wants to modify in the sensor.
 */
static uint8_t are_settings_changed(uint16_t sub_settings, uint16_t desired_settings)
{
	uint8_t settings_changed = FALSE;

	if (sub_settings & desired_settings) {
		/* User wants to modify this particular settings */
		settings_changed = TRUE;
	} else {
		/* User don't want to modify this particular settings */
		settings_changed = FALSE;
	}

	return settings_changed;
}

/*!
 * @brief This API sets the ODR , measurement axes control ,
 * repetition values of xy,z.
 */
static int8_t mode_settings(uint16_t desired_settings, const struct bmm150_dev *dev)
{
	int8_t rslt = BMM150_E_INVALID_CONFIG;

	if (desired_settings & BMM150_DATA_RATE_SEL) {
		/* Sets the ODR */
		rslt = set_odr(dev);
	}
	if (desired_settings & BMM150_CONTROL_MEASURE_SEL) {
		/* Enables/Disables the control measurement axes */
		rslt = set_control_measurement_xyz(dev);
	}
	if (desired_settings & BMM150_XY_REP_SEL) {
		/* Sets the XY repetition */
		rslt = set_xy_rep(dev);
	}
	if (desired_settings & BMM150_Z_REP_SEL) {
		/* Sets the Z repetition */
		rslt = set_z_rep(dev);
	}

	return rslt;
}

/*!
 * @brief This internal API is used to parse and store the sensor
 * settings in the device structure
 */
static void parse_setting(const uint8_t *reg_data, struct bmm150_dev *dev)
{
	/* Parse all the w/r registers and update the
	current sensor settings in the dev structure*/
	dev->settings.z_rep = reg_data[7];
	dev->settings.xy_rep = reg_data[6];
	dev->settings.int_settings.high_threshold = reg_data[5];
	dev->settings.int_settings.low_threshold = reg_data[4];
	dev->settings.xyz_axes_control = BMM150_GET_BITS(reg_data[3], BMM150_CONTROL_MEASURE);
	dev->settings.int_settings.drdy_pin_en = BMM150_GET_BITS(reg_data[3], BMM150_DRDY_EN);
	dev->settings.int_settings.int_pin_en = BMM150_GET_BITS(reg_data[3], BMM150_INT_PIN_EN);
	dev->settings.int_settings.drdy_polarity = BMM150_GET_BITS(reg_data[3], BMM150_DRDY_POLARITY);
	dev->settings.int_settings.int_latch = BMM150_GET_BITS(reg_data[3], BMM150_INT_LATCH);
	dev->settings.int_settings.int_polarity = BMM150_GET_BITS_POS_0(reg_data[3], BMM150_INT_POLARITY);
	dev->settings.int_settings.data_overrun_en = BMM150_GET_BITS(reg_data[2], BMM150_DATA_OVERRUN_INT);
	dev->settings.int_settings.overflow_int_en = BMM150_GET_BITS(reg_data[2], BMM150_OVERFLOW_INT);
	dev->settings.int_settings.high_int_en = BMM150_GET_BITS(reg_data[2], BMM150_HIGH_THRESHOLD_INT);
	dev->settings.int_settings.low_int_en = BMM150_GET_BITS_POS_0(reg_data[2], BMM150_LOW_THRESHOLD_INT);
	dev->settings.data_rate = BMM150_GET_BITS(reg_data[1], BMM150_ODR);
}

/*!
 * @brief This API is used to enable the interrupts and map them to the
 * corresponding interrupt pins and specify the pin characteristics like the
 * polarity , latch settings for the interrupt pins.
 */
static int8_t interrupt_pin_settings(uint16_t desired_settings, const struct bmm150_dev *dev)
{
	int8_t rslt;
	uint8_t reg_data;
	struct bmm150_int_ctrl_settings int_settings;

	rslt = bmm150_get_regs(BMM150_AXES_ENABLE_ADDR, &reg_data, 1, dev);

	if (rslt == BMM150_OK) {
		int_settings = dev->settings.int_settings;

		if (desired_settings & BMM150_DRDY_PIN_EN_SEL) {
			/* Enables the Data ready interrupt and
			maps it to the DRDY pin of the sensor  */
			reg_data = BMM150_SET_BITS(reg_data, BMM150_DRDY_EN, int_settings.drdy_pin_en);
		}
		if (desired_settings & BMM150_INT_PIN_EN_SEL) {
			/* Sets interrupt pin enable */
			reg_data = BMM150_SET_BITS(reg_data, BMM150_INT_PIN_EN, int_settings.int_pin_en);
		}
		if (desired_settings & BMM150_DRDY_POLARITY_SEL) {
			/* Sets Data ready pin's polarity */
			reg_data = BMM150_SET_BITS(reg_data, BMM150_DRDY_POLARITY, int_settings.drdy_polarity);
		}
		if (desired_settings & BMM150_INT_LATCH_SEL) {
			/* Sets Interrupt in latched or non-latched mode */
			reg_data = BMM150_SET_BITS(reg_data, BMM150_INT_LATCH, int_settings.int_latch);
		}
		if (desired_settings & BMM150_INT_POLARITY_SEL) {
			/* Sets Interrupt pin's polarity */
			reg_data = BMM150_SET_BITS_POS_0(reg_data, BMM150_INT_POLARITY, int_settings.int_polarity);
		}

		/* Set the interrupt configurations in the 0x4E register */
		rslt = bmm150_set_regs(BMM150_AXES_ENABLE_ADDR, &reg_data, 1, dev);
	}

	return rslt;
}

/*!
 * @brief This API is used to enable data overrun , overflow interrupts and
 * enable/disable high/low threshold interrupts for x,y,z axis based on the
 * threshold values set by the user in the High threshold (0x50) and
 * Low threshold (0x4F) registers.
 */
static int8_t interrupt_config(uint16_t desired_settings, const struct bmm150_dev *dev)
{
	int8_t rslt;
	uint8_t reg_data;
	struct bmm150_int_ctrl_settings int_settings;

	rslt = bmm150_get_regs(BMM150_INT_CONFIG_ADDR, &reg_data, 1, dev);

	if (rslt == BMM150_OK) {
		int_settings = dev->settings.int_settings;

		if (desired_settings & BMM150_DATA_OVERRUN_INT_SEL) {
			/* Sets Data overrun interrupt */
			reg_data = BMM150_SET_BITS(reg_data, BMM150_DATA_OVERRUN_INT, int_settings.data_overrun_en);
		}
		if (desired_settings & BMM150_OVERFLOW_INT_SEL) {
			/* Sets Data overflow interrupt */
			reg_data = BMM150_SET_BITS(reg_data, BMM150_OVERFLOW_INT, int_settings.overflow_int_en);
		}
		if (desired_settings & BMM150_HIGH_THRESHOLD_INT_SEL) {
			/* Sets high threshold interrupt */
			reg_data = BMM150_SET_BITS(reg_data, BMM150_HIGH_THRESHOLD_INT, int_settings.high_int_en);
		}
		if (desired_settings & BMM150_LOW_THRESHOLD_INT_SEL) {
			/* Sets low threshold interrupt */
			reg_data = BMM150_SET_BITS_POS_0(reg_data, BMM150_LOW_THRESHOLD_INT, int_settings.low_int_en);
		}

		/* Set the interrupt configurations in the 0x4D register */
		rslt = bmm150_set_regs(BMM150_INT_CONFIG_ADDR, &reg_data, 1, dev);
	}

	return rslt;
}

/*!
 * @brief This API is used to write the user specified High/Low threshold value
 * as a reference to generate the high/low threshold interrupt.
 */
static int8_t interrupt_threshold_settings(uint16_t desired_settings, const struct bmm150_dev *dev)
{
	int8_t rslt = BMM150_E_INVALID_CONFIG;
	uint8_t reg_data;

	if (desired_settings & BMM150_LOW_THRESHOLD_SETTING_SEL) {
		/* Sets the Low threshold value to trigger interrupt */
		reg_data = dev->settings.int_settings.low_threshold;
		rslt = bmm150_set_regs(BMM150_LOW_THRESHOLD_ADDR, &reg_data, 1, dev);
	}

	if (desired_settings & BMM150_HIGH_THRESHOLD_SETTING_SEL) {
		/* Sets the High threshold value to trigger interrupt */
		reg_data = dev->settings.int_settings.high_threshold;
		rslt = bmm150_set_regs(BMM150_HIGH_THRESHOLD_ADDR, &reg_data, 1, dev);
	}

	return rslt;

}

#ifdef BMM150_USE_FLOATING_POINT
/*!
 * @brief This internal API is used to obtain the compensated
 * magnetometer x axis data(micro-tesla) in float.
 */
static float compensate_x(int16_t mag_data_x, uint16_t data_rhall, const struct bmm150_dev *dev)
{
	float retval = 0;
	float process_comp_x0;
	float process_comp_x1;
	float process_comp_x2;
	float process_comp_x3;
	float process_comp_x4;

	/* Overflow condition check */
	if ((mag_data_x != BMM150_XYAXES_FLIP_OVERFLOW_ADCVAL) &&
		(data_rhall != 0) && (dev->trim_data.dig_xyz1 != 0)) {
			/*Processing compensation equations*/
			process_comp_x0 = (((float)dev->trim_data.dig_xyz1) * 16384.0f / data_rhall);
			retval = (process_comp_x0 - 16384.0f);
			process_comp_x1 = ((float)dev->trim_data.dig_xy2) * (retval * retval / 268435456.0f);
			process_comp_x2 = process_comp_x1 + retval * ((float)dev->trim_data.dig_xy1) / 16384.0f;
			process_comp_x3 = ((float)dev->trim_data.dig_x2) + 160.0f;
			process_comp_x4 = mag_data_x * ((process_comp_x2 + 256.0f) * process_comp_x3);
			retval = ((process_comp_x4 / 8192.0f) + (((float)dev->trim_data.dig_x1) * 8.0f)) / 16.0f;
	} else {
		/* overflow, set output to 0.0f */
		retval = BMM150_OVERFLOW_OUTPUT_FLOAT;
	}

	return retval;
}

/*!
 * @brief This internal API is used to obtain the compensated
 * magnetometer y axis data(micro-tesla) in float.
 */
static float compensate_y(int16_t mag_data_y, uint16_t data_rhall, const struct bmm150_dev *dev)
{
	float retval = 0;
	float process_comp_y0;
	float process_comp_y1;
	float process_comp_y2;
	float process_comp_y3;
	float process_comp_y4;

	/* Overflow condition check */
	if ((mag_data_y != BMM150_XYAXES_FLIP_OVERFLOW_ADCVAL)
		&& (data_rhall != 0) && (dev->trim_data.dig_xyz1 != 0)) {
			/*Processing compensation equations*/
			process_comp_y0 = ((float)dev->trim_data.dig_xyz1) * 16384.0f / data_rhall;
			retval = process_comp_y0 - 16384.0f;
			process_comp_y1 = ((float)dev->trim_data.dig_xy2) * (retval * retval / 268435456.0f);
			process_comp_y2 = process_comp_y1 + retval * ((float)dev->trim_data.dig_xy1) / 16384.0f;
			process_comp_y3 = ((float)dev->trim_data.dig_y2) + 160.0f;
			process_comp_y4 = mag_data_y * (((process_comp_y2) + 256.0f) * process_comp_y3);
			retval = ((process_comp_y4 / 8192.0f) + (((float)dev->trim_data.dig_y1) * 8.0f)) / 16.0f;
	} else {
		/* overflow, set output to 0.0f */
		retval = BMM150_OVERFLOW_OUTPUT_FLOAT;
	}

	return retval;
}

/*!
 * @brief This internal API is used to obtain the compensated
 * magnetometer z axis data(micro-tesla) in float.
 */
static float compensate_z(int16_t mag_data_z, uint16_t data_rhall, const struct bmm150_dev *dev)
{
	float retval = 0;
	float process_comp_z0;
	float process_comp_z1;
	float process_comp_z2;
	float process_comp_z3;
	float process_comp_z4;
	float process_comp_z5;

	 /* Overflow condition check */
	if ((mag_data_z != BMM150_ZAXIS_HALL_OVERFLOW_ADCVAL) &&
		(dev->trim_data.dig_z2 != 0) && (dev->trim_data.dig_z1 != 0)
		&& (dev->trim_data.dig_xyz1 != 0) && (data_rhall != 0)) {
			/* Processing compensation equations */
			process_comp_z0 = ((float)mag_data_z) - ((float)dev->trim_data.dig_z4);
			process_comp_z1 = ((float)data_rhall) - ((float)dev->trim_data.dig_xyz1);
			process_comp_z2 = (((float)dev->trim_data.dig_z3) * process_comp_z1);
			process_comp_z3 = ((float)dev->trim_data.dig_z1) * ((float)data_rhall) / 32768.0f;
			process_comp_z4 = ((float)dev->trim_data.dig_z2) + process_comp_z3;
			process_comp_z5 = (process_comp_z0 * 131072.0f) - process_comp_z2;
			retval = (process_comp_z5 / ((process_comp_z4) * 4.0f)) / 16.0f;
	} else {
		/* overflow, set output to 0.0f */
		retval = BMM150_OVERFLOW_OUTPUT_FLOAT;
	}

	return retval;
}

#else

/*!
 * @brief This internal API is used to obtain the compensated
 * magnetometer X axis data(micro-tesla) in int16_t.
 */
static int16_t compensate_x(int16_t mag_data_x, uint16_t data_rhall, const struct bmm150_dev *dev)
{
	int16_t retval;
	uint16_t process_comp_x0 = 0;
	int32_t process_comp_x1;
	uint16_t process_comp_x2;
	int32_t process_comp_x3;
	int32_t process_comp_x4;
	int32_t process_comp_x5;
	int32_t process_comp_x6;
	int32_t process_comp_x7;
	int32_t process_comp_x8;
	int32_t process_comp_x9;
	int32_t process_comp_x10;

	/* Overflow condition check */
	if (mag_data_x != BMM150_XYAXES_FLIP_OVERFLOW_ADCVAL) {
		if (data_rhall != 0) {
			/* Availability of valid data*/
			process_comp_x0 = data_rhall;
		} else if (dev->trim_data.dig_xyz1 != 0) {
			process_comp_x0 = dev->trim_data.dig_xyz1;
		} else {
			process_comp_x0 = 0;
		}
		if (process_comp_x0 != 0) {
			/* Processing compensation equations*/
			process_comp_x1 = ((int32_t)dev->trim_data.dig_xyz1) * 16384;
			process_comp_x2 = ((uint16_t)(process_comp_x1 / process_comp_x0)) - ((uint16_t)0x4000);
			retval = ((int16_t)process_comp_x2);
			process_comp_x3 = (((int32_t)retval) * ((int32_t)retval));
			process_comp_x4 = (((int32_t)dev->trim_data.dig_xy2) * (process_comp_x3 / 128));
			process_comp_x5 = (int32_t)(((int16_t)dev->trim_data.dig_xy1) * 128);
			process_comp_x6 = ((int32_t)retval) * process_comp_x5;
			process_comp_x7 = (((process_comp_x4 + process_comp_x6) / 512) + ((int32_t)0x100000));
			process_comp_x8 = ((int32_t)(((int16_t)dev->trim_data.dig_x2) + ((int16_t)0xA0)));
			process_comp_x9 = ((process_comp_x7 * process_comp_x8) / 4096);
			process_comp_x10 = ((int32_t)mag_data_x) * process_comp_x9;
			retval = ((int16_t)(process_comp_x10 / 8192));
			retval = (retval + (((int16_t)dev->trim_data.dig_x1) * 8)) / 16;
		} else {
			retval = BMM150_OVERFLOW_OUTPUT;
		}
	} else {
		/* Overflow condition */
		retval = BMM150_OVERFLOW_OUTPUT;
	}

	return retval;
}

/*!
 * @brief This internal API is used to obtain the compensated
 * magnetometer Y axis data(micro-tesla) in int16_t.
 */
static int16_t compensate_y(int16_t mag_data_y, uint16_t data_rhall, const struct bmm150_dev *dev)
{
	int16_t retval;
	uint16_t process_comp_y0 = 0;
	int32_t process_comp_y1;
	uint16_t process_comp_y2;
	int32_t process_comp_y3;
	int32_t process_comp_y4;
	int32_t process_comp_y5;
	int32_t process_comp_y6;
	int32_t process_comp_y7;
	int32_t process_comp_y8;
	int32_t process_comp_y9;

	/* Overflow condition check */
	if (mag_data_y != BMM150_XYAXES_FLIP_OVERFLOW_ADCVAL) {
		if (data_rhall != 0) {
			/* Availability of valid data*/
			process_comp_y0 = data_rhall;
		} else if (dev->trim_data.dig_xyz1 != 0) {
			process_comp_y0 = dev->trim_data.dig_xyz1;
		} else {
			process_comp_y0 = 0;
		}
		if (process_comp_y0 != 0) {
			/*Processing compensation equations*/
			process_comp_y1 = (((int32_t)dev->trim_data.dig_xyz1) * 16384) / process_comp_y0;
			process_comp_y2 = ((uint16_t)process_comp_y1) - ((uint16_t)0x4000);
			retval = ((int16_t)process_comp_y2);
			process_comp_y3 = ((int32_t) retval) * ((int32_t)retval);
			process_comp_y4 = ((int32_t)dev->trim_data.dig_xy2) * (process_comp_y3 / 128);
			process_comp_y5 = ((int32_t)(((int16_t)dev->trim_data.dig_xy1) * 128));
			process_comp_y6 = ((process_comp_y4 + (((int32_t)retval) * process_comp_y5)) / 512);
			process_comp_y7 = ((int32_t)(((int16_t)dev->trim_data.dig_y2) + ((int16_t)0xA0)));
			process_comp_y8 = (((process_comp_y6 + ((int32_t)0x100000)) * process_comp_y7) / 4096);
			process_comp_y9 = (((int32_t)mag_data_y) * process_comp_y8);
			retval = (int16_t)(process_comp_y9 / 8192);
			retval = (retval + (((int16_t)dev->trim_data.dig_y1) * 8)) / 16;
		} else {
			retval = BMM150_OVERFLOW_OUTPUT;
		}
	} else {
		/* Overflow condition*/
		retval = BMM150_OVERFLOW_OUTPUT;
	}

	return retval;
}

/*!
 * @brief This internal API is used to obtain the compensated
 * magnetometer Z axis data(micro-tesla) in int16_t.
 */
static int16_t compensate_z(int16_t mag_data_z, uint16_t data_rhall, const struct bmm150_dev *dev)
{
	int32_t retval;
	int16_t process_comp_z0;
	int32_t process_comp_z1;
	int32_t process_comp_z2;
	int32_t process_comp_z3;
	int16_t process_comp_z4;

	if (mag_data_z != BMM150_ZAXIS_HALL_OVERFLOW_ADCVAL) {
		if ((dev->trim_data.dig_z2 != 0) && (dev->trim_data.dig_z1 != 0)
		&& (data_rhall != 0) && (dev->trim_data.dig_xyz1 != 0)) {
			/*Processing compensation equations*/
			process_comp_z0 = ((int16_t)data_rhall) - ((int16_t) dev->trim_data.dig_xyz1);
			process_comp_z1 = (((int32_t)dev->trim_data.dig_z3) * ((int32_t)(process_comp_z0))) / 4;
			process_comp_z2 = (((int32_t)(mag_data_z - dev->trim_data.dig_z4)) * 32768);
			process_comp_z3 = ((int32_t)dev->trim_data.dig_z1) * (((int16_t)data_rhall) * 2);
			process_comp_z4 = (int16_t)((process_comp_z3 + (32768)) / 65536);
			retval = ((process_comp_z2 - process_comp_z1) / (dev->trim_data.dig_z2 + process_comp_z4));

			/* saturate result to +/- 2 micro-tesla */
			if (retval > BMM150_POSITIVE_SATURATION_Z) {
				retval =  BMM150_POSITIVE_SATURATION_Z;
			} else {
				if (retval < BMM150_NEGATIVE_SATURATION_Z)
					retval = BMM150_NEGATIVE_SATURATION_Z;
			}
			/* Conversion of LSB to micro-tesla*/
			retval = retval / 16;
		} else {
			retval = BMM150_OVERFLOW_OUTPUT;

		}
	} else {
		/* Overflow condition*/
		retval = BMM150_OVERFLOW_OUTPUT;
	}

	return (int16_t)retval;
}

#endif

/*!
 * @brief This internal API is used to perform the normal self test
 * of the sensor and return the self test result as return value
 */
static int8_t perform_normal_self_test(const struct bmm150_dev *dev)
{
	int8_t rslt;
	uint8_t self_test_bit;

	/* Triggers the start of normal self test */
	rslt = enable_normal_self_test(&self_test_bit, dev);
		/* Check for self test completion status */
		if ((rslt == BMM150_OK) && (self_test_bit == 0)) {
			/* Validates the self test results for all 3 axes */
			rslt = validate_normal_self_test(dev);
		}

	return rslt;
}

/*!
 * @brief This internal API is used to enable the normal self test by setting
 * the Self Test bit (bit0) of the 0x4C register,
 * which triggers the start of self test
 */
static int8_t enable_normal_self_test(uint8_t *self_test_enable, const struct bmm150_dev *dev)
{
	int8_t rslt;
	uint8_t reg_data;
	uint8_t self_test_val;

	/* Read the data from register 0x4C */
	rslt = bmm150_get_regs(BMM150_OP_MODE_ADDR, &reg_data, 1, dev);
	if (rslt == BMM150_OK) {
		/* Set the Self Test bit(bit0) of the 0x4C register */
		self_test_val = 1;
		reg_data = BMM150_SET_BITS_POS_0(reg_data, BMM150_SELF_TEST, self_test_val);
		/* Write the data to 0x4C register to trigger self test */
		rslt = bmm150_set_regs(BMM150_OP_MODE_ADDR, &reg_data, 1, dev);
		dev->delay_ms(BMM150_NORMAL_SELF_TEST_DELAY);
		if (rslt == BMM150_OK) {
			/* Read the data from register 0x4C */
			rslt = bmm150_get_regs(BMM150_OP_MODE_ADDR, &reg_data, 1, dev);
			/* Self Test bit(bit0) is stored in self_test_enable,
			It will be reset to zero after the self test is over */
			*self_test_enable = BMM150_GET_BITS_POS_0(reg_data, BMM150_SELF_TEST);
		}
	}

	return rslt;
}

/*!
 * @brief This internal API is used to validate the results of normal self test
 * by using the self test status available in the bit0 of registers 0x42,0x44
 * and 0x46.
 */
static int8_t validate_normal_self_test(const struct bmm150_dev *dev)
{
	int8_t rslt;
	uint8_t status;
	uint8_t self_test_rslt[5];

	/* Read the data from register 0x42 to 0x46 */
	rslt = bmm150_get_regs(BMM150_DATA_X_LSB, self_test_rslt, BMM150_SELF_TEST_LEN, dev);
	if (rslt == BMM150_OK) {
		/* Parse and get the self test status bits */
		/* X-Self-Test (bit0) of 0x42 register is stored*/
		self_test_rslt[0] = BMM150_GET_BITS_POS_0(self_test_rslt[0], BMM150_SELF_TEST);
		/* Y-Self-Test (bit0) of 0x44 register is stored */
		self_test_rslt[2] = BMM150_GET_BITS_POS_0(self_test_rslt[2], BMM150_SELF_TEST);
		/* Z-Self-Test (bit0) of 0x46 register is stored */
		self_test_rslt[4] = BMM150_GET_BITS_POS_0(self_test_rslt[4], BMM150_SELF_TEST);
		/* Combine the self test status and store it in the first
		3 bits of the status variable for processing*/
		status = (uint8_t)((self_test_rslt[4] << 2) | (self_test_rslt[2] << 1) | self_test_rslt[0]);
		/* Validate status and store Self test result in "rslt" */
		if (status == BMM150_SELF_TEST_STATUS_SUCCESS) {
			/* Self test is success when all status bits are set */
			rslt = BMM150_OK;
		} else {
			if (status == BMM150_SELF_TEST_STATUS_XYZ_FAIL) {
				/* Self test - all axis fail condition */
				rslt = BMM150_W_NORMAL_SELF_TEST_XYZ_FAIL;
			} else {
				/* Self test - some axis fail condition */
				rslt = (int8_t)status;
			}
		}
	}

	return rslt;
}

/*!
 * @brief This internal API is used to perform advanced self test for Z axis
 */
static int8_t perform_adv_self_test(struct bmm150_dev *dev)
{
	int8_t rslt;
	uint8_t self_test_current;
	int16_t positive_data_z;
	int16_t negative_data_z;

	/* Set the desired power mode ,axes control and repetition settings */
	rslt = adv_self_test_settings(dev);
	if (rslt == BMM150_OK) {
		/* Measure the Z axes data with positive self-test current */
		self_test_current = BMM150_ENABLE_POSITIVE_CURRENT;
		rslt = adv_self_test_measurement(self_test_current, &positive_data_z, dev);
		if (rslt == BMM150_OK) {
			/* Measure the Z axes data with
			negative self-test current */
			self_test_current = BMM150_ENABLE_NEGATIVE_CURRENT;
			rslt = adv_self_test_measurement(self_test_current, &negative_data_z, dev);
			if (rslt == BMM150_OK) {
				/* Disable self-test current */
				self_test_current = BMM150_DISABLE_SELF_TEST_CURRENT;
				rslt = set_adv_self_test_current(self_test_current, dev);
				if (rslt == BMM150_OK) {
					/* Validate the advanced self test */
					rslt = validate_adv_self_test(positive_data_z, negative_data_z);
				}
			}
		}
	}

	return rslt;
}

/*!
 * @brief This internal API is used to set the desired power mode ,
 * axes control and repetition settings for advanced self test
 */
static int8_t adv_self_test_settings(struct bmm150_dev *dev)
{
	int8_t rslt;

	/* Set the power mode as sleep mode */
	dev->settings.pwr_mode = BMM150_SLEEP_MODE;
	rslt = bmm150_set_op_mode(dev);
	if (rslt == BMM150_OK) {
		/* Disable XY-axis measurement */
		dev->settings.xyz_axes_control = BMM150_DISABLE_XY_AXIS;
		rslt = set_control_measurement_xyz(dev);
		if (rslt == BMM150_OK) {
			/* Repetition value is set as 0x04 */
			dev->settings.z_rep = BMM150_SELF_TEST_REP_Z;
			rslt = set_z_rep(dev);
		}
	}

	return rslt;
}

/*!
 * @brief This internal API is used to set the positive or negative value of
 * self-test current and obtain the corresponding magnetometer z axis data
 */
static int8_t adv_self_test_measurement(uint8_t self_test_current, int16_t *data_z, struct bmm150_dev *dev)
{
	int8_t rslt;

	/* Set the advanced self test current as positive or
	negative based on the value of parameter "self_test_current" */
	rslt = set_adv_self_test_current(self_test_current, dev);
	if (rslt == BMM150_OK) {
		/* Set the device in forced mode*/
		dev->settings.pwr_mode = BMM150_FORCED_MODE;
		rslt = bmm150_set_op_mode(dev);
		/* Delay to ensure measurement is complete */
		dev->delay_ms(BMM150_ADV_SELF_TEST_DELAY);
		if (rslt == BMM150_OK) {
			/* Read Mag data and store the value of Z axis data */
			rslt = bmm150_read_mag_data(dev);
			if (rslt == BMM150_OK) {
				/* Mag Z axis data is stored */
				*data_z = dev->data.z;
			}
		}
	}

	return rslt;
}

/*!
 * @brief This internal API is used to get the difference between the
 * Z axis mag data obtained by positive and negative self-test current
 * and validate whether the advanced self test is done successfully or not.
 */
static int8_t validate_adv_self_test(int16_t positive_data_z, int16_t negative_data_z)
{
	int32_t adv_self_test_rslt;
	int8_t rslt;

	/* Advanced self test difference between the Z axis mag data
	   obtained by the positive and negative self-test current */
	adv_self_test_rslt = positive_data_z - negative_data_z;
	/* Advanced self test validation */
	/*Value of adv_self_test_rslt should be in between 180-240 micro-tesla*/
	if ((adv_self_test_rslt > 180) && (adv_self_test_rslt < 240)) {
		/* Advanced self test success */
		rslt = BMM150_OK;
	} else {
		/* Advanced self test fail */
		rslt = BMM150_W_ADV_SELF_TEST_FAIL;
	}

	return rslt;
}

/*!
 * @brief This internal API is used to set the self test current value in
 * the Adv. ST bits (bit6 and bit7) of 0x4C register
 */
static int8_t set_adv_self_test_current(uint8_t self_test_current, const struct bmm150_dev *dev)
{
	int8_t rslt;
	uint8_t reg_data;

	/* Read the 0x4C register */
	rslt = bmm150_get_regs(BMM150_OP_MODE_ADDR, &reg_data, 1, dev);
	if (rslt == BMM150_OK) {
		/* Set the self test current value in the Adv. ST bits
		(bit6 and bit7) of 0x4c register */
		reg_data = BMM150_SET_BITS(reg_data, BMM150_ADV_SELF_TEST, self_test_current);
		rslt = bmm150_set_regs(BMM150_OP_MODE_ADDR, &reg_data, 1, dev);
	}

	return rslt;
}