Root/drivers/misc/bmp085.c

1/* Copyright (c) 2010 Christoph Mair <christoph.mair@gmail.com>
2 * Copyright (c) 2012 Bosch Sensortec GmbH
3 * Copyright (c) 2012 Unixphere AB
4 *
5 * This driver supports the bmp085 and bmp18x digital barometric pressure
6 * and temperature sensors from Bosch Sensortec. The datasheets
7 * are available from their website:
8 * http://www.bosch-sensortec.com/content/language1/downloads/BST-BMP085-DS000-05.pdf
9 * http://www.bosch-sensortec.com/content/language1/downloads/BST-BMP180-DS000-07.pdf
10 *
11 * A pressure measurement is issued by reading from pressure0_input.
12 * The return value ranges from 30000 to 110000 pascal with a resulution
13 * of 1 pascal (0.01 millibar) which enables measurements from 9000m above
14 * to 500m below sea level.
15 *
16 * The temperature can be read from temp0_input. Values range from
17 * -400 to 850 representing the ambient temperature in degree celsius
18 * multiplied by 10.The resolution is 0.1 celsius.
19 *
20 * Because ambient pressure is temperature dependent, a temperature
21 * measurement will be executed automatically even if the user is reading
22 * from pressure0_input. This happens if the last temperature measurement
23 * has been executed more then one second ago.
24 *
25 * To decrease RMS noise from pressure measurements, the bmp085 can
26 * autonomously calculate the average of up to eight samples. This is
27 * set up by writing to the oversampling sysfs file. Accepted values
28 * are 0, 1, 2 and 3. 2^x when x is the value written to this file
29 * specifies the number of samples used to calculate the ambient pressure.
30 * RMS noise is specified with six pascal (without averaging) and decreases
31 * down to 3 pascal when using an oversampling setting of 3.
32 *
33 * This program is free software; you can redistribute it and/or modify
34 * it under the terms of the GNU General Public License as published by
35 * the Free Software Foundation; either version 2 of the License, or
36 * (at your option) any later version.
37 *
38 * This program is distributed in the hope that it will be useful,
39 * but WITHOUT ANY WARRANTY; without even the implied warranty of
40 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
41 * GNU General Public License for more details.
42 *
43 * You should have received a copy of the GNU General Public License
44 * along with this program; if not, write to the Free Software
45 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
46 */
47
48#include <linux/module.h>
49#include <linux/device.h>
50#include <linux/init.h>
51#include <linux/slab.h>
52#include <linux/delay.h>
53#include <linux/of.h>
54#include "bmp085.h"
55
56#define BMP085_CHIP_ID 0x55
57#define BMP085_CALIBRATION_DATA_START 0xAA
58#define BMP085_CALIBRATION_DATA_LENGTH 11 /* 16 bit values */
59#define BMP085_CHIP_ID_REG 0xD0
60#define BMP085_CTRL_REG 0xF4
61#define BMP085_TEMP_MEASUREMENT 0x2E
62#define BMP085_PRESSURE_MEASUREMENT 0x34
63#define BMP085_CONVERSION_REGISTER_MSB 0xF6
64#define BMP085_CONVERSION_REGISTER_LSB 0xF7
65#define BMP085_CONVERSION_REGISTER_XLSB 0xF8
66#define BMP085_TEMP_CONVERSION_TIME 5
67
68struct bmp085_calibration_data {
69    s16 AC1, AC2, AC3;
70    u16 AC4, AC5, AC6;
71    s16 B1, B2;
72    s16 MB, MC, MD;
73};
74
75struct bmp085_data {
76    struct device *dev;
77    struct regmap *regmap;
78    struct mutex lock;
79    struct bmp085_calibration_data calibration;
80    u8 oversampling_setting;
81    u32 raw_temperature;
82    u32 raw_pressure;
83    u32 temp_measurement_period;
84    unsigned long last_temp_measurement;
85    u8 chip_id;
86    s32 b6; /* calculated temperature correction coefficient */
87};
88
89static s32 bmp085_read_calibration_data(struct bmp085_data *data)
90{
91    u16 tmp[BMP085_CALIBRATION_DATA_LENGTH];
92    struct bmp085_calibration_data *cali = &(data->calibration);
93    s32 status = regmap_bulk_read(data->regmap,
94                BMP085_CALIBRATION_DATA_START, (u8 *)tmp,
95                (BMP085_CALIBRATION_DATA_LENGTH << 1));
96    if (status < 0)
97        return status;
98
99    cali->AC1 = be16_to_cpu(tmp[0]);
100    cali->AC2 = be16_to_cpu(tmp[1]);
101    cali->AC3 = be16_to_cpu(tmp[2]);
102    cali->AC4 = be16_to_cpu(tmp[3]);
103    cali->AC5 = be16_to_cpu(tmp[4]);
104    cali->AC6 = be16_to_cpu(tmp[5]);
105    cali->B1 = be16_to_cpu(tmp[6]);
106    cali->B2 = be16_to_cpu(tmp[7]);
107    cali->MB = be16_to_cpu(tmp[8]);
108    cali->MC = be16_to_cpu(tmp[9]);
109    cali->MD = be16_to_cpu(tmp[10]);
110    return 0;
111}
112
113static s32 bmp085_update_raw_temperature(struct bmp085_data *data)
114{
115    u16 tmp;
116    s32 status;
117
118    mutex_lock(&data->lock);
119    status = regmap_write(data->regmap, BMP085_CTRL_REG,
120                  BMP085_TEMP_MEASUREMENT);
121    if (status < 0) {
122        dev_err(data->dev,
123            "Error while requesting temperature measurement.\n");
124        goto exit;
125    }
126    msleep(BMP085_TEMP_CONVERSION_TIME);
127
128    status = regmap_bulk_read(data->regmap, BMP085_CONVERSION_REGISTER_MSB,
129                 &tmp, sizeof(tmp));
130    if (status < 0) {
131        dev_err(data->dev,
132            "Error while reading temperature measurement result\n");
133        goto exit;
134    }
135    data->raw_temperature = be16_to_cpu(tmp);
136    data->last_temp_measurement = jiffies;
137    status = 0; /* everything ok, return 0 */
138
139exit:
140    mutex_unlock(&data->lock);
141    return status;
142}
143
144static s32 bmp085_update_raw_pressure(struct bmp085_data *data)
145{
146    u32 tmp = 0;
147    s32 status;
148
149    mutex_lock(&data->lock);
150    status = regmap_write(data->regmap, BMP085_CTRL_REG,
151            BMP085_PRESSURE_MEASUREMENT +
152            (data->oversampling_setting << 6));
153    if (status < 0) {
154        dev_err(data->dev,
155            "Error while requesting pressure measurement.\n");
156        goto exit;
157    }
158
159    /* wait for the end of conversion */
160    msleep(2+(3 << data->oversampling_setting));
161
162    /* copy data into a u32 (4 bytes), but skip the first byte. */
163    status = regmap_bulk_read(data->regmap, BMP085_CONVERSION_REGISTER_MSB,
164                 ((u8 *)&tmp)+1, 3);
165    if (status < 0) {
166        dev_err(data->dev,
167            "Error while reading pressure measurement results\n");
168        goto exit;
169    }
170    data->raw_pressure = be32_to_cpu((tmp));
171    data->raw_pressure >>= (8-data->oversampling_setting);
172    status = 0; /* everything ok, return 0 */
173
174exit:
175    mutex_unlock(&data->lock);
176    return status;
177}
178
179/*
180 * This function starts the temperature measurement and returns the value
181 * in tenth of a degree celsius.
182 */
183static s32 bmp085_get_temperature(struct bmp085_data *data, int *temperature)
184{
185    struct bmp085_calibration_data *cali = &data->calibration;
186    long x1, x2;
187    int status;
188
189    status = bmp085_update_raw_temperature(data);
190    if (status < 0)
191        goto exit;
192
193    x1 = ((data->raw_temperature - cali->AC6) * cali->AC5) >> 15;
194    x2 = (cali->MC << 11) / (x1 + cali->MD);
195    data->b6 = x1 + x2 - 4000;
196    /* if NULL just update b6. Used for pressure only measurements */
197    if (temperature != NULL)
198        *temperature = (x1+x2+8) >> 4;
199
200exit:
201    return status;
202}
203
204/*
205 * This function starts the pressure measurement and returns the value
206 * in millibar. Since the pressure depends on the ambient temperature,
207 * a temperature measurement is executed according to the given temperature
208 * measurement period (default is 1 sec boundary). This period could vary
209 * and needs to be adjusted according to the sensor environment, i.e. if big
210 * temperature variations then the temperature needs to be read out often.
211 */
212static s32 bmp085_get_pressure(struct bmp085_data *data, int *pressure)
213{
214    struct bmp085_calibration_data *cali = &data->calibration;
215    s32 x1, x2, x3, b3;
216    u32 b4, b7;
217    s32 p;
218    int status;
219
220    /* alt least every second force an update of the ambient temperature */
221    if ((data->last_temp_measurement == 0) ||
222        time_is_before_jiffies(data->last_temp_measurement + 1*HZ)) {
223        status = bmp085_get_temperature(data, NULL);
224        if (status < 0)
225            return status;
226    }
227
228    status = bmp085_update_raw_pressure(data);
229    if (status < 0)
230        return status;
231
232    x1 = (data->b6 * data->b6) >> 12;
233    x1 *= cali->B2;
234    x1 >>= 11;
235
236    x2 = cali->AC2 * data->b6;
237    x2 >>= 11;
238
239    x3 = x1 + x2;
240
241    b3 = (((((s32)cali->AC1) * 4 + x3) << data->oversampling_setting) + 2);
242    b3 >>= 2;
243
244    x1 = (cali->AC3 * data->b6) >> 13;
245    x2 = (cali->B1 * ((data->b6 * data->b6) >> 12)) >> 16;
246    x3 = (x1 + x2 + 2) >> 2;
247    b4 = (cali->AC4 * (u32)(x3 + 32768)) >> 15;
248
249    b7 = ((u32)data->raw_pressure - b3) *
250                    (50000 >> data->oversampling_setting);
251    p = ((b7 < 0x80000000) ? ((b7 << 1) / b4) : ((b7 / b4) * 2));
252
253    x1 = p >> 8;
254    x1 *= x1;
255    x1 = (x1 * 3038) >> 16;
256    x2 = (-7357 * p) >> 16;
257    p += (x1 + x2 + 3791) >> 4;
258
259    *pressure = p;
260
261    return 0;
262}
263
264/*
265 * This function sets the chip-internal oversampling. Valid values are 0..3.
266 * The chip will use 2^oversampling samples for internal averaging.
267 * This influences the measurement time and the accuracy; larger values
268 * increase both. The datasheet gives an overview on how measurement time,
269 * accuracy and noise correlate.
270 */
271static void bmp085_set_oversampling(struct bmp085_data *data,
272                        unsigned char oversampling)
273{
274    if (oversampling > 3)
275        oversampling = 3;
276    data->oversampling_setting = oversampling;
277}
278
279/*
280 * Returns the currently selected oversampling. Range: 0..3
281 */
282static unsigned char bmp085_get_oversampling(struct bmp085_data *data)
283{
284    return data->oversampling_setting;
285}
286
287/* sysfs callbacks */
288static ssize_t set_oversampling(struct device *dev,
289                struct device_attribute *attr,
290                const char *buf, size_t count)
291{
292    struct bmp085_data *data = dev_get_drvdata(dev);
293    unsigned long oversampling;
294    int err = kstrtoul(buf, 10, &oversampling);
295
296    if (err == 0) {
297        mutex_lock(&data->lock);
298        bmp085_set_oversampling(data, oversampling);
299        mutex_unlock(&data->lock);
300        return count;
301    }
302
303    return err;
304}
305
306static ssize_t show_oversampling(struct device *dev,
307                 struct device_attribute *attr, char *buf)
308{
309    struct bmp085_data *data = dev_get_drvdata(dev);
310
311    return sprintf(buf, "%u\n", bmp085_get_oversampling(data));
312}
313static DEVICE_ATTR(oversampling, S_IWUSR | S_IRUGO,
314                    show_oversampling, set_oversampling);
315
316
317static ssize_t show_temperature(struct device *dev,
318                struct device_attribute *attr, char *buf)
319{
320    int temperature;
321    int status;
322    struct bmp085_data *data = dev_get_drvdata(dev);
323
324    status = bmp085_get_temperature(data, &temperature);
325    if (status < 0)
326        return status;
327    else
328        return sprintf(buf, "%d\n", temperature);
329}
330static DEVICE_ATTR(temp0_input, S_IRUGO, show_temperature, NULL);
331
332
333static ssize_t show_pressure(struct device *dev,
334                 struct device_attribute *attr, char *buf)
335{
336    int pressure;
337    int status;
338    struct bmp085_data *data = dev_get_drvdata(dev);
339
340    status = bmp085_get_pressure(data, &pressure);
341    if (status < 0)
342        return status;
343    else
344        return sprintf(buf, "%d\n", pressure);
345}
346static DEVICE_ATTR(pressure0_input, S_IRUGO, show_pressure, NULL);
347
348
349static struct attribute *bmp085_attributes[] = {
350    &dev_attr_temp0_input.attr,
351    &dev_attr_pressure0_input.attr,
352    &dev_attr_oversampling.attr,
353    NULL
354};
355
356static const struct attribute_group bmp085_attr_group = {
357    .attrs = bmp085_attributes,
358};
359
360int bmp085_detect(struct device *dev)
361{
362    struct bmp085_data *data = dev_get_drvdata(dev);
363    unsigned int id;
364    int ret;
365
366    ret = regmap_read(data->regmap, BMP085_CHIP_ID_REG, &id);
367    if (ret < 0)
368        return ret;
369
370    if (id != data->chip_id)
371        return -ENODEV;
372
373    return 0;
374}
375EXPORT_SYMBOL_GPL(bmp085_detect);
376
377static void __init bmp085_get_of_properties(struct bmp085_data *data)
378{
379#ifdef CONFIG_OF
380    struct device_node *np = data->dev->of_node;
381    u32 prop;
382
383    if (!np)
384        return;
385
386    if (!of_property_read_u32(np, "chip-id", &prop))
387        data->chip_id = prop & 0xff;
388
389    if (!of_property_read_u32(np, "temp-measurement-period", &prop))
390        data->temp_measurement_period = (prop/100)*HZ;
391
392    if (!of_property_read_u32(np, "default-oversampling", &prop))
393        data->oversampling_setting = prop & 0xff;
394#endif
395}
396
397static int bmp085_init_client(struct bmp085_data *data)
398{
399    int status = bmp085_read_calibration_data(data);
400
401    if (status < 0)
402        return status;
403
404    /* default settings */
405    data->chip_id = BMP085_CHIP_ID;
406    data->last_temp_measurement = 0;
407    data->temp_measurement_period = 1*HZ;
408    data->oversampling_setting = 3;
409
410    bmp085_get_of_properties(data);
411
412    mutex_init(&data->lock);
413
414    return 0;
415}
416
417struct regmap_config bmp085_regmap_config = {
418    .reg_bits = 8,
419    .val_bits = 8
420};
421EXPORT_SYMBOL_GPL(bmp085_regmap_config);
422
423__devinit int bmp085_probe(struct device *dev, struct regmap *regmap)
424{
425    struct bmp085_data *data;
426    int err = 0;
427
428    data = kzalloc(sizeof(struct bmp085_data), GFP_KERNEL);
429    if (!data) {
430        err = -ENOMEM;
431        goto exit;
432    }
433
434    dev_set_drvdata(dev, data);
435    data->dev = dev;
436    data->regmap = regmap;
437
438    /* Initialize the BMP085 chip */
439    err = bmp085_init_client(data);
440    if (err < 0)
441        goto exit_free;
442
443    err = bmp085_detect(dev);
444    if (err < 0) {
445        dev_err(dev, "%s: chip_id failed!\n", BMP085_NAME);
446        goto exit_free;
447    }
448
449    /* Register sysfs hooks */
450    err = sysfs_create_group(&dev->kobj, &bmp085_attr_group);
451    if (err)
452        goto exit_free;
453
454    dev_info(dev, "Successfully initialized %s!\n", BMP085_NAME);
455
456    return 0;
457
458exit_free:
459    kfree(data);
460exit:
461    return err;
462}
463EXPORT_SYMBOL_GPL(bmp085_probe);
464
465int bmp085_remove(struct device *dev)
466{
467    struct bmp085_data *data = dev_get_drvdata(dev);
468
469    sysfs_remove_group(&data->dev->kobj, &bmp085_attr_group);
470    kfree(data);
471
472    return 0;
473}
474EXPORT_SYMBOL_GPL(bmp085_remove);
475
476MODULE_AUTHOR("Christoph Mair <christoph.mair@gmail.com>");
477MODULE_DESCRIPTION("BMP085 driver");
478MODULE_LICENSE("GPL");
479

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9



interactive