drivers/sensor/sensor_lis3dh.c

/*
 * Copyright (c) 2016 Intel Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <i2c.h>
#include <init.h>
#include <sensor.h>

#include "sensor_lis3dh.h"

static int lis3dh_i2c_read(struct lis3dh_data *drv_data,
			   uint8_t cmd, uint8_t *buff,
			   int buff_len)
{
	struct i2c_msg msgs[2] = {
		{
			.buf = &cmd,
			.len = 1,
			.flags = I2C_MSG_WRITE | I2C_MSG_RESTART,
		},
		{
			.buf = buff,
			.len = buff_len,
			.flags = I2C_MSG_READ | I2C_MSG_STOP,
		},
	};

	return i2c_transfer(drv_data->i2c, msgs, 2, LIS3DH_I2C_ADDRESS);
}

static inline int lis3dh_reg_burst_read(struct lis3dh_data *drv_data,
				 uint8_t reg, uint8_t *buff,
				 int buff_len)
{
	reg = reg | LIS3DH_AUTOINCREMENT_ADDR;
	return lis3dh_i2c_read(drv_data, reg, buff, buff_len);
}

static inline int lis3dh_reg_read(struct lis3dh_data *drv_data,
		    uint8_t reg, uint8_t *val)
{
	return lis3dh_reg_burst_read(drv_data, reg, val, 1);
}

int lis3dh_reg_write(struct lis3dh_data *drv_data,
		     uint8_t reg, uint8_t val)
{
	uint8_t tx_buf[2] = {reg, val};

	return i2c_write(drv_data->i2c, tx_buf, sizeof(tx_buf),
			 LIS3DH_I2C_ADDRESS);
}

static int lis3dh_channel_get(struct device *dev,
			      enum sensor_channel chan,
			      struct sensor_value *val)
{
	struct lis3dh_data *drv_data = dev->driver_data;
	int64_t raw_val;

	if (chan == SENSOR_CHAN_ACCEL_X) {
		raw_val = drv_data->x_sample;
	} else if (chan == SENSOR_CHAN_ACCEL_Y) {
		raw_val = drv_data->y_sample;
	} else if (chan == SENSOR_CHAN_ACCEL_Z) {
		raw_val = drv_data->z_sample;
	} else {
		return -ENOTSUP;
	}

	/* val = raw_val * LIS3DH_ACCEL_SCALE / (1000 * (2^16 - 1)) */
	val->type = SENSOR_TYPE_INT_PLUS_MICRO;
	raw_val = raw_val * LIS3DH_ACCEL_SCALE;
	val->val1 = raw_val / (1000 * 0xFFFF);
	val->val2 = (raw_val % (1000 * 0xFFFF)) * 1000000 / (1000 * 0xFFFF);

	/* normalize val to make sure val->val2 is positive */
	if (val->val2 < 0) {
		val->val1 -= 1;
		val->val2 += 1000000;
	}

	return 0;
}

int lis3dh_sample_fetch(struct device *dev)
{
	struct lis3dh_data *drv_data = dev->driver_data;
	uint8_t buf[6];
	int rc;

	/*
	 * since all accel data register addresses are consecutive,
	 * a burst read can be used to read all the samples
	 */
	rc = lis3dh_reg_burst_read(drv_data, LIS3DH_REG_ACCEL_X_LSB, buf, 6);
	if (rc != 0) {
		DBG("Could not read accel axis data\n");
		return -EIO;
	}

	drv_data->x_sample = (buf[1] << 8) | buf[0];
	drv_data->y_sample = (buf[3] << 8) | buf[2];
	drv_data->z_sample = (buf[5] << 8) | buf[4];

	return 0;
}

static struct sensor_driver_api lis3dh_driver_api = {
#if CONFIG_LIS3DH_TRIGGER
	.trigger_set = lis3dh_trigger_set,
#endif
	.sample_fetch = lis3dh_sample_fetch,
	.channel_get = lis3dh_channel_get,
};

int lis3dh_init(struct device *dev)
{
	struct lis3dh_data *drv_data = dev->driver_data;
	int rc;

	dev->driver_api = &lis3dh_driver_api;

	drv_data->i2c = device_get_binding(CONFIG_LIS3DH_I2C_MASTER_DEV_NAME);
	if (drv_data->i2c == NULL) {
		DBG("Could not get pointer to %s device\n",
		    CONFIG_LIS3DH_I2C_MASTER_DEV_NAME);
		return -EINVAL;
	}

	/* enable accel measurements and set power mode and data rate */
	rc = lis3dh_reg_write(drv_data, LIS3DH_REG_CTRL1, LIS3DH_ACCEL_EN_BITS |
			      LIS3DH_LP_EN_BIT | LIS3DH_ODR_BITS);
	if (rc != 0) {
		DBG("Failed to configure chip.\n");
	}

	/* set full scale range */
	rc = lis3dh_reg_write(drv_data, LIS3DH_REG_CTRL4, LIS3DH_FS_BITS);
	if (rc != 0) {
		DBG("Failed to set full scale range.\n");
		return -EIO;
	}

#ifdef CONFIG_LIS3DH_TRIGGER
	rc = lis3dh_init_interrupt(dev);
	if (rc != 0) {
		DBG("Failed to initialize interrupts.\n");
		return -EIO;
	}
#endif

	return 0;
}

struct lis3dh_data lis3dh_driver;

DEVICE_INIT(lis3dh, CONFIG_LIS3DH_NAME, lis3dh_init, &lis3dh_driver,
	    NULL, SECONDARY, CONFIG_LIS3DH_INIT_PRIORITY);