blob: 75edd0bc98d3c8d61e77a5f4fae9f00f07b00099 [file] [log] [blame]
/* Copyright (c) 2011 Bosch Sensortec GmbH
Copyright (c) 2011 Unixphere
Based on:
BMP085 driver, bmp085.c
Copyright (c) 2010 Christoph Mair <christoph.mair@gmail.com>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/err.h>
#include <linux/regulator/consumer.h>
#include <linux/delay.h>
#include "bmp18x.h"
struct sensor_regulator {
struct regulator *vreg;
const char *name;
u32 min_uV;
u32 max_uV;
};
struct sensor_regulator bmp_vreg[] = {
{NULL, "vdd", 2850000, 2850000},
{NULL, "vddio", 1800000, 1800000},
};
static int bmp18x_config_regulator(struct i2c_client *client, bool on)
{
int rc = 0, i;
int num_vreg = ARRAY_SIZE(bmp_vreg);
if (on) {
for (i = 0; i < num_vreg; i++) {
bmp_vreg[i].vreg = regulator_get(&client->dev,
bmp_vreg[i].name);
if (IS_ERR(bmp_vreg[i].vreg)) {
rc = PTR_ERR(bmp_vreg[i].vreg);
dev_err(&client->dev, "%s:regulator get failed rc=%d\n",
__func__, rc);
bmp_vreg[i].vreg = NULL;
goto error_vdd;
}
if (regulator_count_voltages(bmp_vreg[i].vreg) > 0) {
rc = regulator_set_voltage(bmp_vreg[i].vreg,
bmp_vreg[i].min_uV, bmp_vreg[i].max_uV);
if (rc) {
dev_err(&client->dev, "%s:set_voltage failed rc=%d\n",
__func__, rc);
regulator_put(bmp_vreg[i].vreg);
bmp_vreg[i].vreg = NULL;
goto error_vdd;
}
}
rc = regulator_enable(bmp_vreg[i].vreg);
if (rc) {
dev_err(&client->dev, "%s: regulator_enable failed rc =%d\n",
__func__, rc);
if (regulator_count_voltages(bmp_vreg[i].vreg)
> 0) {
regulator_set_voltage(bmp_vreg[i].vreg,
0, bmp_vreg[i].max_uV);
}
regulator_put(bmp_vreg[i].vreg);
bmp_vreg[i].vreg = NULL;
goto error_vdd;
}
}
return rc;
} else {
i = num_vreg;
}
error_vdd:
while (--i >= 0) {
if (!IS_ERR_OR_NULL(bmp_vreg[i].vreg)) {
if (regulator_count_voltages(
bmp_vreg[i].vreg) > 0) {
regulator_set_voltage(bmp_vreg[i].vreg, 0,
bmp_vreg[i].max_uV);
}
regulator_disable(bmp_vreg[i].vreg);
regulator_put(bmp_vreg[i].vreg);
bmp_vreg[i].vreg = NULL;
}
}
return rc;
}
static int bmp18x_init_hw(struct bmp18x_data_bus *data_bus)
{
int ret = 0;
if (data_bus->client) {
ret = bmp18x_config_regulator(data_bus->client, 1);
/* The minimum start up time of bmp18x is 10ms */
usleep_range(15000, 20000);
}
return ret;
}
static void bmp18x_deinit_hw(struct bmp18x_data_bus *data_bus)
{
if (data_bus->client)
bmp18x_config_regulator(data_bus->client, 0);
}
static int bmp18x_set_power(struct bmp18x_data *data, int on)
{
int rc = 0;
int num_vreg = ARRAY_SIZE(bmp_vreg);
int i;
if (!on && data->power_enabled) {
for (i = 0; i < num_vreg; i++) {
rc = regulator_disable(bmp_vreg[i].vreg);
if (rc) {
dev_err(data->dev, "Regulator vdd disable failed rc=%d\n",
rc);
return rc;
}
}
data->power_enabled = false;
} else if (on && !data->power_enabled) {
for (i = 0; i < num_vreg; i++) {
rc = regulator_enable(bmp_vreg[i].vreg);
if (rc) {
dev_err(data->dev, "Regulator vdd enable failed rc=%d\n",
rc);
return rc;
}
}
/* The minimum start up time of bmp18x is 10ms */
usleep_range(15000, 20000);
data->power_enabled = true;
} else {
dev_warn(data->dev,
"Power on=%d. enabled=%d\n",
on, data->power_enabled);
}
return rc;
}
#ifdef CONFIG_OF
static int bmp18x_parse_dt(struct device *dev,
struct bmp18x_platform_data *pdata)
{
int ret = 0;
u32 val;
ret = of_property_read_u32(dev->of_node, "bosch,chip-id", &val);
if (ret) {
dev_err(dev, "no chip_id from dt\n");
return ret;
}
pdata->chip_id = (u8)val;
ret = of_property_read_u32(dev->of_node, "bosch,oversample", &val);
if (ret) {
dev_err(dev, "no default_oversampling from dt\n");
return ret;
}
pdata->default_oversampling = (u8)val;
ret = of_property_read_u32(dev->of_node, "bosch,period",
&pdata->temp_measurement_period);
if (ret) {
dev_err(dev, "no temp_measurement_period from dt\n");
return ret;
}
pdata->default_sw_oversampling = of_property_read_bool(dev->of_node,
"bosch,sw-oversample");
return 0;
}
#else
static int bmp18x_parse_dt(struct device *dev,
struct bmp18x_platform_data *pdata)
{
return -EINVAL;
}
#endif
static int bmp18x_i2c_read_block(void *client, u8 reg, int len, char *buf)
{
return i2c_smbus_read_i2c_block_data(client, reg, len, buf);
}
static int bmp18x_i2c_read_byte(void *client, u8 reg)
{
return i2c_smbus_read_byte_data(client, reg);
}
static int bmp18x_i2c_write_byte(void *client, u8 reg, u8 value)
{
return i2c_smbus_write_byte_data(client, reg, value);
}
static const struct bmp18x_bus_ops bmp18x_i2c_bus_ops = {
.read_block = bmp18x_i2c_read_block,
.read_byte = bmp18x_i2c_read_byte,
.write_byte = bmp18x_i2c_write_byte
};
static int __devinit bmp18x_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct bmp18x_data_bus data_bus = {
.bops = &bmp18x_i2c_bus_ops,
.client = client
};
struct bmp18x_platform_data *pdata;
int ret;
if (client->dev.of_node) {
pdata = devm_kzalloc(&client->dev,
sizeof(struct bmp18x_platform_data), GFP_KERNEL);
if (!pdata) {
dev_err(&client->dev, "Failed to allocate memory\n");
return -ENOMEM;
}
ret = bmp18x_parse_dt(&client->dev, pdata);
if (ret) {
dev_err(&client->dev, "Failed to parse device tree\n");
return ret;
}
pdata->init_hw = bmp18x_init_hw;
pdata->deinit_hw = bmp18x_deinit_hw;
pdata->set_power = bmp18x_set_power;
client->dev.platform_data = pdata;
}
return bmp18x_probe(&client->dev, &data_bus);
}
static void bmp18x_i2c_shutdown(struct i2c_client *client)
{
bmp18x_disable(&client->dev);
}
static int bmp18x_i2c_remove(struct i2c_client *client)
{
return bmp18x_remove(&client->dev);
}
#ifdef CONFIG_PM
static int bmp18x_i2c_suspend(struct device *dev)
{
int ret = 0;
struct bmp18x_data *data = dev_get_drvdata(dev);
if (data->enable)
ret = bmp18x_disable(dev);
return ret;
}
static int bmp18x_i2c_resume(struct device *dev)
{
int ret = 0;
struct bmp18x_data *data = dev_get_drvdata(dev);
if (data->enable)
ret = bmp18x_enable(dev);
return ret;
}
static const struct dev_pm_ops bmp18x_i2c_pm_ops = {
.suspend = bmp18x_i2c_suspend,
.resume = bmp18x_i2c_resume
};
#endif
static const struct i2c_device_id bmp18x_id[] = {
{ BMP18X_NAME, 0 },
{ }
};
MODULE_DEVICE_TABLE(i2c, bmp18x_id);
static const struct of_device_id bmp18x_of_match[] = {
{ .compatible = "bosch,bmp180", },
{ },
};
static struct i2c_driver bmp18x_i2c_driver = {
.driver = {
.owner = THIS_MODULE,
.name = BMP18X_NAME,
#ifdef CONFIG_PM
.pm = &bmp18x_i2c_pm_ops,
#endif
.of_match_table = bmp18x_of_match,
},
.id_table = bmp18x_id,
.probe = bmp18x_i2c_probe,
.shutdown = bmp18x_i2c_shutdown,
.remove = __devexit_p(bmp18x_i2c_remove)
};
static int __init bmp18x_i2c_init(void)
{
return i2c_add_driver(&bmp18x_i2c_driver);
}
static void __exit bmp18x_i2c_exit(void)
{
i2c_del_driver(&bmp18x_i2c_driver);
}
MODULE_AUTHOR("Eric Andersson <eric.andersson@unixphere.com>");
MODULE_DESCRIPTION("BMP18X I2C bus driver");
MODULE_LICENSE("GPL");
module_init(bmp18x_i2c_init);
module_exit(bmp18x_i2c_exit);