From d7c90be4603f5cc4364a6bb648393f924f0a6f1f Mon Sep 17 00:00:00 2001 From: Tony Månsson Date: Tue, 22 Mar 2011 14:23:03 +0100 Subject: Adding l3g4200d Gyroscope --- drivers/hwmon/Kconfig | 11 + drivers/hwmon/Makefile | 1 + drivers/hwmon/l3g4200d.c | 644 +++++++++++++++++++++++++++++++++++++++++++++++ include/linux/l3g4200d.h | 27 ++ 4 files changed, 683 insertions(+) create mode 100644 drivers/hwmon/l3g4200d.c create mode 100644 include/linux/l3g4200d.h diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig index 8deedc1b984..324f9b084d0 100644 --- a/drivers/hwmon/Kconfig +++ b/drivers/hwmon/Kconfig @@ -687,6 +687,17 @@ config SENSORS_LTC4151 This driver can also be built as a module. If so, the module will be called ltc4151. +config SENSORS_L3G4200D + tristate "ST L3G4200D 3-axis gyroscope" + depends on I2C + default n + help + If you say yes here you get support for 3-axis gyroscope device + L3g4200D. + + This driver can also be built as a module. If so, the module + will be called l3g4200d. + config SENSORS_LTC4215 tristate "Linear Technology LTC4215" depends on I2C && EXPERIMENTAL diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile index 6d3f11f7181..6e9aa4dccc4 100644 --- a/drivers/hwmon/Makefile +++ b/drivers/hwmon/Makefile @@ -84,6 +84,7 @@ obj-$(CONFIG_SENSORS_LM93) += lm93.o obj-$(CONFIG_SENSORS_LM95241) += lm95241.o obj-$(CONFIG_SENSORS_LM95245) += lm95245.o obj-$(CONFIG_SENSORS_LTC4151) += ltc4151.o +obj-$(CONFIG_SENSORS_L3G4200D) += l3g4200d.o obj-$(CONFIG_SENSORS_LTC4215) += ltc4215.o obj-$(CONFIG_SENSORS_LTC4245) += ltc4245.o obj-$(CONFIG_SENSORS_LTC4261) += ltc4261.o diff --git a/drivers/hwmon/l3g4200d.c b/drivers/hwmon/l3g4200d.c new file mode 100644 index 00000000000..718abbb748b --- /dev/null +++ b/drivers/hwmon/l3g4200d.c @@ -0,0 +1,644 @@ +/* + * ST L3G4200D 3-Axis Gyroscope Driver + * + * Copyright (C) ST-Ericsson SA 2011 + * Author: Chethan Krishna N for ST-Ericsson + * Licence terms: GNU General Public Licence (GPL) version 2 + */ + +#include +#include +#include +#include +#include +#include + +#include +#include + +/* l3g4200d gyroscope registers */ + +#define WHO_AM_I 0x0F + +#define CTRL_REG1 0x20 /* CTRL REG1 */ +#define CTRL_REG2 0x21 /* CTRL REG2 */ +#define CTRL_REG3 0x22 /* CTRL_REG3 */ +#define CTRL_REG4 0x23 /* CTRL_REG4 */ +#define CTRL_REG5 0x24 /* CTRL_REG5 */ + +#define AXISDATA_REG 0x28 + +/** Registers Contents */ + +#define WHOAMI_L3G4200D 0x00D3 /* Expected content for WAI register*/ + +/* CTRL_REG1 */ +#define PM_OFF 0x00 +#define PM_ON 0x01 +#define ENABLE_ALL_AXES 0x07 +#define BW00 0x00 +#define BW01 0x10 +#define BW10 0x20 +#define BW11 0x30 +#define ODR00 0x00 /* ODR = 100Hz */ +#define ODR01 0x40 /* ODR = 200Hz */ +#define ODR10 0x80 /* ODR = 400Hz */ +#define ODR11 0xC0 /* ODR = 800Hz */ +#define L3G4200D_PM_BIT 3 +#define L3G4200D_PM_MASK (0x01 << L3G4200D_PM_BIT) +#define L3G4200D_ODR_BIT 4 +#define L3G4200D_ODR_MASK (0x0F << L3G4200D_ODR_BIT) +#define L3G4200D_ODR_MIN_VAL 0x00 +#define L3G4200D_ODR_MAX_VAL 0x0F + +/* CTRL_REG4 */ +#define FS250 0x00 +#define FS500 0x01 +#define FS2000 0x03 +#define BDU_ENABLE 0x80 +#define L3G4200D_FS_BIT 6 +#define L3G4200D_FS_MASK (0x3 << L3G4200D_FS_BIT) + +/* multiple byte transfer enable */ +#define MULTIPLE_I2C_TR 0x80 + +/* device status defines */ +#define DEVICE_OFF 0 +#define DEVICE_ON 1 +#define DEVICE_SUSPENDED 2 + +/* + * L3G4200D gyroscope data + * brief structure containing gyroscope values for yaw, pitch and roll in + * signed short + */ + +struct l3g4200d_gyro_values { + short x; /* x-axis angular rate data. */ + short y; /* y-axis angluar rate data. */ + short z; /* z-axis angular rate data. */ +}; + +struct l3g4200d_data { + struct i2c_client *client; + struct mutex lock; + struct l3g4200d_gyro_values data; + struct l3g4200d_gyr_platform_data pdata; + struct regulator *regulator; + unsigned char powermode; + unsigned char odr; + unsigned char range; + int device_status; +}; + +static int l3g4200d_write(struct l3g4200d_data *ddata, u8 reg, + u8 val, char *msg) +{ + int ret = i2c_smbus_write_byte_data(ddata->client, reg, val); + if (ret < 0) + dev_err(&ddata->client->dev, + "i2c_smbus_write_byte_data failed error %d\ + Register (%s)\n", ret, msg); + return ret; +} + +static int l3g4200d_read(struct l3g4200d_data *ddata, u8 reg, char *msg) +{ + int ret = i2c_smbus_read_byte_data(ddata->client, reg); + if (ret < 0) + dev_err(&ddata->client->dev, + "i2c_smbus_read_byte_data failed error %d\ + Register (%s)\n", ret, msg); + return ret; +} + +static int l3g4200d_readdata(struct l3g4200d_data *ddata) +{ + unsigned char gyro_data[6]; + short data[3]; + int ret; + + ret = i2c_smbus_read_i2c_block_data(ddata->client, + AXISDATA_REG | MULTIPLE_I2C_TR, 6, gyro_data); + if (ret < 0) { + dev_err(&ddata->client->dev, + "i2c_smbus_read_byte_data failed error %d\ + Register AXISDATA_REG\n", ret); + return ret; + } + + data[0] = (short) (((gyro_data[1]) << 8) | gyro_data[0]); + data[1] = (short) (((gyro_data[3]) << 8) | gyro_data[2]); + data[2] = (short) (((gyro_data[5]) << 8) | gyro_data[4]); + + data[ddata->pdata.axis_map_x] = ddata->pdata.negative_x ? + -data[ddata->pdata.axis_map_x] : data[ddata->pdata.axis_map_x]; + data[ddata->pdata.axis_map_y] = ddata->pdata.negative_y ? + -data[ddata->pdata.axis_map_y] : data[ddata->pdata.axis_map_y]; + data[ddata->pdata.axis_map_z] = ddata->pdata.negative_z ? + -data[ddata->pdata.axis_map_z] : data[ddata->pdata.axis_map_z]; + + ddata->data.x = data[ddata->pdata.axis_map_x]; + ddata->data.y = data[ddata->pdata.axis_map_y]; + ddata->data.z = data[ddata->pdata.axis_map_z]; + + return ret; +} + +static ssize_t l3g4200d_show_gyrodata(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct platform_device *pdev = to_platform_device(dev); + struct l3g4200d_data *ddata = platform_get_drvdata(pdev); + int ret = 0; + + mutex_lock(&ddata->lock); + + if (ddata->powermode == PM_OFF || + ddata->device_status == DEVICE_SUSPENDED) { + mutex_unlock(&ddata->lock); + return ret; + } + + ret = l3g4200d_readdata(ddata); + + if (ret < 0) { + mutex_unlock(&ddata->lock); + return ret; + } + + mutex_unlock(&ddata->lock); + + return sprintf(buf, "%8x:%8x:%8x\n", ddata->data.x, ddata->data.y, + ddata->data.z); +} + +static ssize_t l3g4200d_show_range(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct platform_device *pdev = to_platform_device(dev); + struct l3g4200d_data *ddata = platform_get_drvdata(pdev); + + return sprintf(buf, "%d\n", ddata->range); +} + +static ssize_t l3g4200d_store_range(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct platform_device *pdev = to_platform_device(dev); + struct l3g4200d_data *ddata = platform_get_drvdata(pdev); + long received_value; + unsigned char value; + int error; + + error = strict_strtol(buf, 0, &received_value); + if (error) + return error; + + /* check if the received range is in valid range */ + if (received_value < FS250 || received_value > FS2000) + return -EINVAL; + + mutex_lock(&ddata->lock); + + if (ddata->powermode == PM_OFF) { + dev_info(&ddata->client->dev, + "The device is switched off, turn it ON using powermode\n"); + mutex_unlock(&ddata->lock); + return count; + } + + /* enable the BDU bit */ + value = BDU_ENABLE; + value |= ((received_value << L3G4200D_FS_BIT) & L3G4200D_FS_MASK); + + ddata->range = received_value; + + error = l3g4200d_write(ddata, CTRL_REG4, value, "CTRL_REG4"); + if (error < 0) { + mutex_unlock(&ddata->lock); + return error; + } + + mutex_unlock(&ddata->lock); + return count; +} + +static ssize_t l3g4200d_show_datarate(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct platform_device *pdev = to_platform_device(dev); + struct l3g4200d_data *ddata = platform_get_drvdata(pdev); + + return sprintf(buf, "%d\n", ddata->odr >> L3G4200D_ODR_BIT); +} + +static ssize_t l3g4200d_store_datarate(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct platform_device *pdev = to_platform_device(dev); + struct l3g4200d_data *ddata = platform_get_drvdata(pdev); + long received_value; + unsigned char value; + int error; + + error = strict_strtol(buf, 0, &received_value); + if (error) + return error; + + /* check if the received output datarate value is in valid range */ + if (received_value < L3G4200D_ODR_MIN_VAL || + received_value > L3G4200D_ODR_MAX_VAL) + return -EINVAL; + + mutex_lock(&ddata->lock); + + if (ddata->powermode == PM_OFF) { + dev_info(&ddata->client->dev, + "The device is switched off, turn it ON using powermode\n"); + mutex_unlock(&ddata->lock); + return count; + } + + /* + * read the current contents of CTRL_REG1 + * retain any bits set other than the odr bits + */ + error = l3g4200d_read(ddata, CTRL_REG1, "CTRL_REG1"); + + if (error < 0) { + mutex_unlock(&ddata->lock); + return error; + } else + value = error; + + value &= ~L3G4200D_ODR_MASK; + value |= ((received_value << L3G4200D_ODR_BIT) & L3G4200D_ODR_MASK); + + ddata->odr = received_value << L3G4200D_ODR_BIT; + + error = l3g4200d_write(ddata, CTRL_REG1, value, "CTRL_REG1"); + if (error < 0) { + mutex_unlock(&ddata->lock); + return error; + } + + mutex_unlock(&ddata->lock); + return count; +} + +static ssize_t l3g4200d_show_powermode(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct platform_device *pdev = to_platform_device(dev); + struct l3g4200d_data *ddata = platform_get_drvdata(pdev); + + return sprintf(buf, "%d\n", ddata->powermode); +} + +static ssize_t l3g4200d_store_powermode(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct platform_device *pdev = to_platform_device(dev); + struct l3g4200d_data *ddata = platform_get_drvdata(pdev); + long received_value; + unsigned char value; + int error; + + error = strict_strtol(buf, 0, &received_value); + if (error) + return error; + + /* check if the received power mode is either 0 or 1 */ + if (received_value < PM_OFF || received_value > PM_ON) + return -EINVAL; + + mutex_lock(&ddata->lock); + + if (ddata->device_status == DEVICE_SUSPENDED && + received_value == PM_OFF) { + ddata->powermode = received_value; + mutex_unlock(&ddata->lock); + return 0; + } + + /* if sent value is same as current value do nothing */ + if (ddata->powermode == received_value) { + mutex_unlock(&ddata->lock); + return 0; + } + + /* turn on the power suppliy if it was turned off previously */ + if (ddata->regulator && ddata->powermode == PM_OFF + && (ddata->device_status == DEVICE_OFF + || ddata->device_status == DEVICE_SUSPENDED)) { + regulator_enable(ddata->regulator); + ddata->device_status = DEVICE_ON; + } + + /* + * read the current contents of CTRL_REG1 + * retain any bits set other than the power bit + */ + error = l3g4200d_read(ddata, CTRL_REG1, "CTRL_REG1"); + + if (error < 0) { + if (ddata->regulator && ddata->device_status == DEVICE_ON) { + regulator_disable(ddata->regulator); + ddata->device_status = DEVICE_OFF; + } + mutex_unlock(&ddata->lock); + return error; + } else + value = error; + + value &= ~L3G4200D_PM_MASK; + value |= ((received_value << L3G4200D_PM_BIT) & L3G4200D_PM_MASK); + + ddata->powermode = received_value; + + error = l3g4200d_write(ddata, CTRL_REG1, value, "CTRL_REG1"); + if (error < 0) { + if (ddata->regulator && ddata->device_status == DEVICE_ON) { + regulator_disable(ddata->regulator); + ddata->device_status = DEVICE_OFF; + } + mutex_unlock(&ddata->lock); + return error; + } + + if (received_value == PM_OFF) { + /* set the other configuration values to defaults */ + ddata->odr = ODR00 | BW00; + ddata->range = FS250; + + /* turn off the power supply */ + if (ddata->regulator && ddata->device_status == DEVICE_ON) { + regulator_disable(ddata->regulator); + ddata->device_status = DEVICE_OFF; + } + } + mutex_unlock(&ddata->lock); + return count; +} + +static DEVICE_ATTR(gyrodata, S_IRUGO, l3g4200d_show_gyrodata, NULL); + +static DEVICE_ATTR(range, S_IRUGO | S_IWUGO, + l3g4200d_show_range, l3g4200d_store_range); + +static DEVICE_ATTR(datarate, S_IRUGO | S_IWUGO, + l3g4200d_show_datarate, l3g4200d_store_datarate); + +static DEVICE_ATTR(powermode, S_IRUGO | S_IWUGO, + l3g4200d_show_powermode, l3g4200d_store_powermode); + +static struct attribute *l3g4200d_attributes[] = { + &dev_attr_gyrodata.attr, + &dev_attr_range.attr, + &dev_attr_datarate.attr, + &dev_attr_powermode.attr, + NULL +}; + +static const struct attribute_group l3g4200d_attr_group = { + .attrs = l3g4200d_attributes, +}; + +static int __devinit l3g4200d_probe(struct i2c_client *client, + const struct i2c_device_id *devid) +{ + int ret = -1; + struct l3g4200d_data *ddata = NULL; + + if (!i2c_check_functionality(client->adapter, + I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_READ_I2C_BLOCK)) + goto exit; + + ddata = kzalloc(sizeof(struct l3g4200d_data), GFP_KERNEL); + if (ddata == NULL) { + ret = -ENOMEM; + goto error_op_failed; + } + + ddata->client = client; + i2c_set_clientdata(client, ddata); + + memcpy(&ddata->pdata, client->dev.platform_data, sizeof(ddata->pdata)); + /* store default values in the data structure */ + ddata->odr = ODR00 | BW00; + ddata->range = FS250; + ddata->powermode = PM_OFF; + ddata->device_status = DEVICE_OFF; + + dev_set_name(&client->dev, ddata->pdata.name_gyr); + + ddata->regulator = regulator_get(&client->dev, "v-gyro"); + if (IS_ERR(ddata->regulator)) { + dev_err(&client->dev, "failed to get regulator\n"); + ret = PTR_ERR(ddata->regulator); + ddata->regulator = NULL; + } + + if (ddata->regulator) { + regulator_enable(ddata->regulator); + ddata->device_status = DEVICE_ON; + } + + ret = l3g4200d_read(ddata, WHO_AM_I, "WHO_AM_I"); + if (ret < 0) + goto exit_free_regulator; + + if (ret == WHOAMI_L3G4200D) + dev_info(&client->dev, "3-Axis Gyroscope device identification: %d\n", ret); + else + dev_info(&client->dev, "Gyroscope identification did not match\n"); + + mutex_init(&ddata->lock); + + ret = sysfs_create_group(&client->dev.kobj, &l3g4200d_attr_group); + if (ret) + goto exit_free_regulator; + + /* + * turn off the supplies until somebody turns on the device + * using l3g4200d_store_powermode + */ + if (ddata->device_status == DEVICE_ON && ddata->regulator) { + regulator_disable(ddata->regulator); + ddata->device_status = DEVICE_OFF; + } + + return ret; + +exit_free_regulator: + if (ddata->device_status == DEVICE_ON && ddata->regulator) { + regulator_disable(ddata->regulator); + regulator_put(ddata->regulator); + ddata->device_status = DEVICE_OFF; + } +error_op_failed: + kfree(ddata); +exit: + dev_err(&client->dev, "probe function failed %x\n", ret); + return ret; +} + +static int __devexit l3g4200d_remove(struct i2c_client *client) +{ + struct l3g4200d_data *ddata; + ddata = i2c_get_clientdata(client); + sysfs_remove_group(&client->dev.kobj, &l3g4200d_attr_group); + + /* safer to turn off the device */ + if (ddata->powermode != PM_OFF) { + l3g4200d_write(ddata, CTRL_REG1, PM_OFF, "CONTROL"); + if (ddata->regulator && ddata->device_status == DEVICE_ON) { + regulator_disable(ddata->regulator); + regulator_put(ddata->regulator); + ddata->device_status = DEVICE_OFF; + } + } + + i2c_set_clientdata(client, NULL); + kfree(ddata); + + return 0; +} + +static int l3g4200d_do_suspend(struct l3g4200d_data *ddata) +{ + int ret; + + mutex_lock(&ddata->lock); + + if (ddata->powermode == PM_OFF) { + mutex_unlock(&ddata->lock); + return 0; + } + + ret = l3g4200d_write(ddata, CTRL_REG1, PM_OFF, "CONTROL"); + + /* turn off the power when suspending the device */ + if (ddata->regulator) + regulator_disable(ddata->regulator); + + ddata->device_status = DEVICE_SUSPENDED; + + mutex_unlock(&ddata->lock); + return ret; +} + +static int l3g4200d_do_resume(struct l3g4200d_data *ddata) +{ + unsigned char range_value; + unsigned char shifted_powermode = (ddata->powermode << L3G4200D_PM_BIT); + unsigned char shifted_odr = (ddata->odr << L3G4200D_ODR_BIT); + unsigned context = ((shifted_powermode | shifted_odr) | ENABLE_ALL_AXES); + int ret = 0; + + mutex_lock(&ddata->lock); + + if (ddata->device_status == DEVICE_ON) + goto fail; + + /* in correct mode, no need to change it */ + if (ddata->powermode == PM_OFF) { + ddata->device_status = DEVICE_OFF; + goto fail; + } else { + ddata->device_status = DEVICE_ON; + } + + /* turn on the power when resuming the device */ + if (ddata->regulator) + regulator_enable(ddata->regulator); + + ret = l3g4200d_write(ddata, CTRL_REG1, context, "CONTROL"); + if (ret < 0) + goto fail; + + range_value = ddata->range; + range_value <<= L3G4200D_FS_BIT; + range_value |= BDU_ENABLE; + + ret = l3g4200d_write(ddata, CTRL_REG4, range_value, "RANGE"); + +fail: + mutex_unlock(&ddata->lock); + return ret; +} + +#ifdef CONFIG_PM +static int l3g4200d_suspend(struct device *dev) +{ + struct l3g4200d_data *ddata; + int ret; + + ddata = dev_get_drvdata(dev); + + ret = l3g4200d_do_suspend(ddata); + + return ret; +} + +static int l3g4200d_resume(struct device *dev) +{ + struct l3g4200d_data *ddata; + int ret; + + ddata = dev_get_drvdata(dev); + + ret = l3g4200d_do_resume(ddata); + if (ret < 0) + dev_err(&ddata->client->dev, + "Error while resuming the device\n"); + + return ret; +} + +static const struct dev_pm_ops l3g4200d_dev_pm_ops = { + .suspend = l3g4200d_suspend, + .resume = l3g4200d_resume, +}; +#endif + +static const struct i2c_device_id l3g4200d_id[] = { + {"l3g4200d", 0 }, + { }, +}; + +static struct i2c_driver l3g4200d_driver = { + .driver = { + .name = "l3g4200d", +#ifdef CONFIG_PM + .pm = &l3g4200d_dev_pm_ops, +#endif + }, + .probe = l3g4200d_probe, + .remove = l3g4200d_remove, + .id_table = l3g4200d_id, +}; + +static int __init l3g4200d_init(void) +{ + return i2c_add_driver(&l3g4200d_driver); +} + +static void __exit l3g4200d_exit(void) +{ + i2c_del_driver(&l3g4200d_driver); +} + +module_init(l3g4200d_init); +module_exit(l3g4200d_exit); + +MODULE_DESCRIPTION("l3g4200d digital gyroscope driver"); +MODULE_AUTHOR("Chethan Krishna N"); +MODULE_LICENSE("GPL"); diff --git a/include/linux/l3g4200d.h b/include/linux/l3g4200d.h new file mode 100644 index 00000000000..28459601e4f --- /dev/null +++ b/include/linux/l3g4200d.h @@ -0,0 +1,27 @@ +/* + * ST L3G4200D 3-Axis Gyroscope header file + * + * Copyright (C) ST-Ericsson SA 2011 + * Author: Chethan Krishna N for ST-Ericsson + * Licence terms: GNU General Public Licence (GPL) version 2 + */ + +#ifndef __L3G4200D_H__ +#define __L3G4200D_H__ + +#ifdef __KERNEL__ +struct l3g4200d_gyr_platform_data { + const char *name_gyr; + + u8 axis_map_x; + u8 axis_map_y; + u8 axis_map_z; + + u8 negative_x; + u8 negative_y; + u8 negative_z; +}; + +#endif /* __KERNEL__ */ + +#endif /* __L3G4200D_H__ */ -- cgit v1.2.3