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/slab.h>
51 #include <linux/of.h>
52 #include "bmp085.h"
53 #include <linux/interrupt.h>
54 #include <linux/completion.h>
55 #include <linux/gpio.h>
56
57 #define BMP085_CHIP_ID 0x55
58 #define BMP085_CALIBRATION_DATA_START 0xAA
59 #define BMP085_CALIBRATION_DATA_LENGTH 11 /* 16 bit values */
60 #define BMP085_CHIP_ID_REG 0xD0
61 #define BMP085_CTRL_REG 0xF4
62 #define BMP085_TEMP_MEASUREMENT 0x2E
63 #define BMP085_PRESSURE_MEASUREMENT 0x34
64 #define BMP085_CONVERSION_REGISTER_MSB 0xF6
65 #define BMP085_CONVERSION_REGISTER_LSB 0xF7
66 #define BMP085_CONVERSION_REGISTER_XLSB 0xF8
67 #define BMP085_TEMP_CONVERSION_TIME 5
68
69 struct bmp085_calibration_data {
70 s16 AC1, AC2, AC3;
71 u16 AC4, AC5, AC6;
72 s16 B1, B2;
73 s16 MB, MC, MD;
74 };
75
76 struct bmp085_data {
77 struct device *dev;
78 struct regmap *regmap;
79 struct mutex lock;
80 struct bmp085_calibration_data calibration;
81 u8 oversampling_setting;
82 u32 raw_temperature;
83 u32 raw_pressure;
84 u32 temp_measurement_period;
85 unsigned long last_temp_measurement;
86 u8 chip_id;
87 s32 b6; /* calculated temperature correction coefficient */
88 int irq;
89 struct completion done;
90 };
91
bmp085_eoc_isr(int irq,void * devid)92 static irqreturn_t bmp085_eoc_isr(int irq, void *devid)
93 {
94 struct bmp085_data *data = devid;
95
96 complete(&data->done);
97
98 return IRQ_HANDLED;
99 }
100
bmp085_read_calibration_data(struct bmp085_data * data)101 static s32 bmp085_read_calibration_data(struct bmp085_data *data)
102 {
103 u16 tmp[BMP085_CALIBRATION_DATA_LENGTH];
104 struct bmp085_calibration_data *cali = &(data->calibration);
105 s32 status = regmap_bulk_read(data->regmap,
106 BMP085_CALIBRATION_DATA_START, (u8 *)tmp,
107 (BMP085_CALIBRATION_DATA_LENGTH << 1));
108 if (status < 0)
109 return status;
110
111 cali->AC1 = be16_to_cpu(tmp[0]);
112 cali->AC2 = be16_to_cpu(tmp[1]);
113 cali->AC3 = be16_to_cpu(tmp[2]);
114 cali->AC4 = be16_to_cpu(tmp[3]);
115 cali->AC5 = be16_to_cpu(tmp[4]);
116 cali->AC6 = be16_to_cpu(tmp[5]);
117 cali->B1 = be16_to_cpu(tmp[6]);
118 cali->B2 = be16_to_cpu(tmp[7]);
119 cali->MB = be16_to_cpu(tmp[8]);
120 cali->MC = be16_to_cpu(tmp[9]);
121 cali->MD = be16_to_cpu(tmp[10]);
122 return 0;
123 }
124
bmp085_update_raw_temperature(struct bmp085_data * data)125 static s32 bmp085_update_raw_temperature(struct bmp085_data *data)
126 {
127 u16 tmp;
128 s32 status;
129
130 mutex_lock(&data->lock);
131
132 init_completion(&data->done);
133
134 status = regmap_write(data->regmap, BMP085_CTRL_REG,
135 BMP085_TEMP_MEASUREMENT);
136 if (status < 0) {
137 dev_err(data->dev,
138 "Error while requesting temperature measurement.\n");
139 goto exit;
140 }
141 wait_for_completion_timeout(&data->done, 1 + msecs_to_jiffies(
142 BMP085_TEMP_CONVERSION_TIME));
143
144 status = regmap_bulk_read(data->regmap, BMP085_CONVERSION_REGISTER_MSB,
145 &tmp, sizeof(tmp));
146 if (status < 0) {
147 dev_err(data->dev,
148 "Error while reading temperature measurement result\n");
149 goto exit;
150 }
151 data->raw_temperature = be16_to_cpu(tmp);
152 data->last_temp_measurement = jiffies;
153 status = 0; /* everything ok, return 0 */
154
155 exit:
156 mutex_unlock(&data->lock);
157 return status;
158 }
159
bmp085_update_raw_pressure(struct bmp085_data * data)160 static s32 bmp085_update_raw_pressure(struct bmp085_data *data)
161 {
162 u32 tmp = 0;
163 s32 status;
164
165 mutex_lock(&data->lock);
166
167 init_completion(&data->done);
168
169 status = regmap_write(data->regmap, BMP085_CTRL_REG,
170 BMP085_PRESSURE_MEASUREMENT +
171 (data->oversampling_setting << 6));
172 if (status < 0) {
173 dev_err(data->dev,
174 "Error while requesting pressure measurement.\n");
175 goto exit;
176 }
177
178 /* wait for the end of conversion */
179 wait_for_completion_timeout(&data->done, 1 + msecs_to_jiffies(
180 2+(3 << data->oversampling_setting)));
181 /* copy data into a u32 (4 bytes), but skip the first byte. */
182 status = regmap_bulk_read(data->regmap, BMP085_CONVERSION_REGISTER_MSB,
183 ((u8 *)&tmp)+1, 3);
184 if (status < 0) {
185 dev_err(data->dev,
186 "Error while reading pressure measurement results\n");
187 goto exit;
188 }
189 data->raw_pressure = be32_to_cpu((tmp));
190 data->raw_pressure >>= (8-data->oversampling_setting);
191 status = 0; /* everything ok, return 0 */
192
193 exit:
194 mutex_unlock(&data->lock);
195 return status;
196 }
197
198 /*
199 * This function starts the temperature measurement and returns the value
200 * in tenth of a degree celsius.
201 */
bmp085_get_temperature(struct bmp085_data * data,int * temperature)202 static s32 bmp085_get_temperature(struct bmp085_data *data, int *temperature)
203 {
204 struct bmp085_calibration_data *cali = &data->calibration;
205 long x1, x2;
206 int status;
207
208 status = bmp085_update_raw_temperature(data);
209 if (status < 0)
210 goto exit;
211
212 x1 = ((data->raw_temperature - cali->AC6) * cali->AC5) >> 15;
213 x2 = (cali->MC << 11) / (x1 + cali->MD);
214 data->b6 = x1 + x2 - 4000;
215 /* if NULL just update b6. Used for pressure only measurements */
216 if (temperature != NULL)
217 *temperature = (x1+x2+8) >> 4;
218
219 exit:
220 return status;
221 }
222
223 /*
224 * This function starts the pressure measurement and returns the value
225 * in millibar. Since the pressure depends on the ambient temperature,
226 * a temperature measurement is executed according to the given temperature
227 * measurement period (default is 1 sec boundary). This period could vary
228 * and needs to be adjusted according to the sensor environment, i.e. if big
229 * temperature variations then the temperature needs to be read out often.
230 */
bmp085_get_pressure(struct bmp085_data * data,int * pressure)231 static s32 bmp085_get_pressure(struct bmp085_data *data, int *pressure)
232 {
233 struct bmp085_calibration_data *cali = &data->calibration;
234 s32 x1, x2, x3, b3;
235 u32 b4, b7;
236 s32 p;
237 int status;
238
239 /* alt least every second force an update of the ambient temperature */
240 if ((data->last_temp_measurement == 0) ||
241 time_is_before_jiffies(data->last_temp_measurement + 1*HZ)) {
242 status = bmp085_get_temperature(data, NULL);
243 if (status < 0)
244 return status;
245 }
246
247 status = bmp085_update_raw_pressure(data);
248 if (status < 0)
249 return status;
250
251 x1 = (data->b6 * data->b6) >> 12;
252 x1 *= cali->B2;
253 x1 >>= 11;
254
255 x2 = cali->AC2 * data->b6;
256 x2 >>= 11;
257
258 x3 = x1 + x2;
259
260 b3 = (((((s32)cali->AC1) * 4 + x3) << data->oversampling_setting) + 2);
261 b3 >>= 2;
262
263 x1 = (cali->AC3 * data->b6) >> 13;
264 x2 = (cali->B1 * ((data->b6 * data->b6) >> 12)) >> 16;
265 x3 = (x1 + x2 + 2) >> 2;
266 b4 = (cali->AC4 * (u32)(x3 + 32768)) >> 15;
267
268 b7 = ((u32)data->raw_pressure - b3) *
269 (50000 >> data->oversampling_setting);
270 p = ((b7 < 0x80000000) ? ((b7 << 1) / b4) : ((b7 / b4) * 2));
271
272 x1 = p >> 8;
273 x1 *= x1;
274 x1 = (x1 * 3038) >> 16;
275 x2 = (-7357 * p) >> 16;
276 p += (x1 + x2 + 3791) >> 4;
277
278 *pressure = p;
279
280 return 0;
281 }
282
283 /*
284 * This function sets the chip-internal oversampling. Valid values are 0..3.
285 * The chip will use 2^oversampling samples for internal averaging.
286 * This influences the measurement time and the accuracy; larger values
287 * increase both. The datasheet gives an overview on how measurement time,
288 * accuracy and noise correlate.
289 */
bmp085_set_oversampling(struct bmp085_data * data,unsigned char oversampling)290 static void bmp085_set_oversampling(struct bmp085_data *data,
291 unsigned char oversampling)
292 {
293 if (oversampling > 3)
294 oversampling = 3;
295 data->oversampling_setting = oversampling;
296 }
297
298 /*
299 * Returns the currently selected oversampling. Range: 0..3
300 */
bmp085_get_oversampling(struct bmp085_data * data)301 static unsigned char bmp085_get_oversampling(struct bmp085_data *data)
302 {
303 return data->oversampling_setting;
304 }
305
306 /* sysfs callbacks */
set_oversampling(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)307 static ssize_t set_oversampling(struct device *dev,
308 struct device_attribute *attr,
309 const char *buf, size_t count)
310 {
311 struct bmp085_data *data = dev_get_drvdata(dev);
312 unsigned long oversampling;
313 int err = kstrtoul(buf, 10, &oversampling);
314
315 if (err == 0) {
316 mutex_lock(&data->lock);
317 bmp085_set_oversampling(data, oversampling);
318 mutex_unlock(&data->lock);
319 return count;
320 }
321
322 return err;
323 }
324
show_oversampling(struct device * dev,struct device_attribute * attr,char * buf)325 static ssize_t show_oversampling(struct device *dev,
326 struct device_attribute *attr, char *buf)
327 {
328 struct bmp085_data *data = dev_get_drvdata(dev);
329
330 return sprintf(buf, "%u\n", bmp085_get_oversampling(data));
331 }
332 static DEVICE_ATTR(oversampling, S_IWUSR | S_IRUGO,
333 show_oversampling, set_oversampling);
334
335
show_temperature(struct device * dev,struct device_attribute * attr,char * buf)336 static ssize_t show_temperature(struct device *dev,
337 struct device_attribute *attr, char *buf)
338 {
339 int temperature;
340 int status;
341 struct bmp085_data *data = dev_get_drvdata(dev);
342
343 status = bmp085_get_temperature(data, &temperature);
344 if (status < 0)
345 return status;
346 else
347 return sprintf(buf, "%d\n", temperature);
348 }
349 static DEVICE_ATTR(temp0_input, S_IRUGO, show_temperature, NULL);
350
351
show_pressure(struct device * dev,struct device_attribute * attr,char * buf)352 static ssize_t show_pressure(struct device *dev,
353 struct device_attribute *attr, char *buf)
354 {
355 int pressure;
356 int status;
357 struct bmp085_data *data = dev_get_drvdata(dev);
358
359 status = bmp085_get_pressure(data, &pressure);
360 if (status < 0)
361 return status;
362 else
363 return sprintf(buf, "%d\n", pressure);
364 }
365 static DEVICE_ATTR(pressure0_input, S_IRUGO, show_pressure, NULL);
366
367
368 static struct attribute *bmp085_attributes[] = {
369 &dev_attr_temp0_input.attr,
370 &dev_attr_pressure0_input.attr,
371 &dev_attr_oversampling.attr,
372 NULL
373 };
374
375 static const struct attribute_group bmp085_attr_group = {
376 .attrs = bmp085_attributes,
377 };
378
bmp085_detect(struct device * dev)379 int bmp085_detect(struct device *dev)
380 {
381 struct bmp085_data *data = dev_get_drvdata(dev);
382 unsigned int id;
383 int ret;
384
385 ret = regmap_read(data->regmap, BMP085_CHIP_ID_REG, &id);
386 if (ret < 0)
387 return ret;
388
389 if (id != data->chip_id)
390 return -ENODEV;
391
392 return 0;
393 }
394 EXPORT_SYMBOL_GPL(bmp085_detect);
395
bmp085_get_of_properties(struct bmp085_data * data)396 static void bmp085_get_of_properties(struct bmp085_data *data)
397 {
398 #ifdef CONFIG_OF
399 struct device_node *np = data->dev->of_node;
400 u32 prop;
401
402 if (!np)
403 return;
404
405 if (!of_property_read_u32(np, "chip-id", &prop))
406 data->chip_id = prop & 0xff;
407
408 if (!of_property_read_u32(np, "temp-measurement-period", &prop))
409 data->temp_measurement_period = (prop/100)*HZ;
410
411 if (!of_property_read_u32(np, "default-oversampling", &prop))
412 data->oversampling_setting = prop & 0xff;
413 #endif
414 }
415
bmp085_init_client(struct bmp085_data * data)416 static int bmp085_init_client(struct bmp085_data *data)
417 {
418 int status = bmp085_read_calibration_data(data);
419
420 if (status < 0)
421 return status;
422
423 /* default settings */
424 data->chip_id = BMP085_CHIP_ID;
425 data->last_temp_measurement = 0;
426 data->temp_measurement_period = 1*HZ;
427 data->oversampling_setting = 3;
428
429 bmp085_get_of_properties(data);
430
431 mutex_init(&data->lock);
432
433 return 0;
434 }
435
436 struct regmap_config bmp085_regmap_config = {
437 .reg_bits = 8,
438 .val_bits = 8
439 };
440 EXPORT_SYMBOL_GPL(bmp085_regmap_config);
441
bmp085_probe(struct device * dev,struct regmap * regmap,int irq)442 int bmp085_probe(struct device *dev, struct regmap *regmap, int irq)
443 {
444 struct bmp085_data *data;
445 int err = 0;
446
447 data = kzalloc(sizeof(struct bmp085_data), GFP_KERNEL);
448 if (!data) {
449 err = -ENOMEM;
450 goto exit;
451 }
452
453 dev_set_drvdata(dev, data);
454 data->dev = dev;
455 data->regmap = regmap;
456 data->irq = irq;
457
458 if (data->irq > 0) {
459 err = devm_request_irq(dev, data->irq, bmp085_eoc_isr,
460 IRQF_TRIGGER_RISING, "bmp085",
461 data);
462 if (err < 0)
463 goto exit_free;
464 }
465
466 /* Initialize the BMP085 chip */
467 err = bmp085_init_client(data);
468 if (err < 0)
469 goto exit_free;
470
471 err = bmp085_detect(dev);
472 if (err < 0) {
473 dev_err(dev, "%s: chip_id failed!\n", BMP085_NAME);
474 goto exit_free;
475 }
476
477 /* Register sysfs hooks */
478 err = sysfs_create_group(&dev->kobj, &bmp085_attr_group);
479 if (err)
480 goto exit_free;
481
482 dev_info(dev, "Successfully initialized %s!\n", BMP085_NAME);
483
484 return 0;
485
486 exit_free:
487 kfree(data);
488 exit:
489 return err;
490 }
491 EXPORT_SYMBOL_GPL(bmp085_probe);
492
bmp085_remove(struct device * dev)493 int bmp085_remove(struct device *dev)
494 {
495 struct bmp085_data *data = dev_get_drvdata(dev);
496
497 sysfs_remove_group(&data->dev->kobj, &bmp085_attr_group);
498 kfree(data);
499
500 return 0;
501 }
502 EXPORT_SYMBOL_GPL(bmp085_remove);
503
504 MODULE_AUTHOR("Christoph Mair <christoph.mair@gmail.com>");
505 MODULE_DESCRIPTION("BMP085 driver");
506 MODULE_LICENSE("GPL");
507