Fix error handling when reading calibration data.
[freerunner-navigation-board:bmp085.git] / kernel / bmp085.c
1 /*  Copyright (c) 2010  Christoph Mair <christoph.mair@gmail.com>
2
3     This program is free software; you can redistribute it and/or modify
4     it under the terms of the GNU General Public License as published by
5     the Free Software Foundation; either version 2 of the License, or
6     (at your option) any later version.
7
8     This program is distributed in the hope that it will be useful,
9     but WITHOUT ANY WARRANTY; without even the implied warranty of
10     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11     GNU General Public License for more details.
12
13     You should have received a copy of the GNU General Public License
14     along with this program; if not, write to the Free Software
15     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
16 */
17
18
19 #include <linux/module.h>
20 #include <linux/init.h>
21 #include <linux/i2c.h>
22 #include <linux/delay.h>
23
24
25 #define BMP085_I2C_ADDRESS              0x77
26 #define BMP085_CHIP_ID                  0x55
27
28 #define BMP085_CALIBRATION_DATA_START   0xAA
29 #define BMP085_CALIBRATION_DATA_LENGTH  11
30 #define BMP085_CHIP_ID_REG              0xD0
31 #define BMP085_VERSION_REG              0xD1
32 #define BMP085_CTRL_REG                 0xF4
33 #define BMP085_TEMP_MEASUREMENT         0x2E
34 #define BMP085_PRESSURE_MEASUREMENT     0x34
35 #define BMP085_CONVERSION_REGISTER_MSB  0xF6
36 #define BMP085_CONVERSION_REGISTER_LSB  0xF7
37 #define BMP085_CONVERSION_REGISTER_XLSB 0xF8
38 #define BMP085_TEMP_CONVERSION_TIME     5
39
40 #define BMP085_MIN_TEMP                 -400    /* tenth of a degree celsius */
41 #define BMP085_MAX_TEMP                 850
42 #define BMP085_MIN_PRESSURE             30000   /* pascal (millibar) */
43 #define BMP085_MAX_PRESSURE             110000
44 #define BMP085_INPUT_POLL_INTERVAL      1000    /* ms */
45
46 #define BMP085_CLIENT_NAME              "bmp085"
47
48
49 static const unsigned short normal_i2c[] = { BMP085_I2C_ADDRESS,
50                                                         I2C_CLIENT_END };
51 I2C_CLIENT_INSMOD_1(bmp085);
52
53 struct bmp085_calibration_data {
54         s16 AC1, AC2, AC3;
55         u16 AC4, AC5, AC6;
56         s16 B1, B2;
57         s16 MB, MC, MD;
58 };
59
60
61 /* Each client has this additional data */
62 struct bmp085_data {
63         struct i2c_client *client;
64         struct mutex lock;
65         struct bmp085_calibration_data calibration;
66         u32 raw_temperature;
67         u32 raw_pressure;
68         unsigned char oversampling_setting;
69         unsigned long last_temp_measurement;
70         s32 b6; /* calculated temperature correction coefficient */
71 };
72
73
74 static s32 bmp085_read_calibration_data(struct i2c_client *client)
75 {
76         u16 tmp[BMP085_CALIBRATION_DATA_LENGTH];
77         struct bmp085_data *data = i2c_get_clientdata(client);
78         struct bmp085_calibration_data *cali = &(data->calibration);
79         s32 status = i2c_smbus_read_i2c_block_data(client,
80                                 BMP085_CALIBRATION_DATA_START,
81                                 BMP085_CALIBRATION_DATA_LENGTH*sizeof(u16),
82                                 (u8 *)tmp);
83         if (status != BMP085_CALIBRATION_DATA_LENGTH*sizeof(u16))
84                 return -EIO;
85
86         cali->AC1 =  be16_to_cpu(tmp[0]);
87         cali->AC2 =  be16_to_cpu(tmp[1]);
88         cali->AC3 =  be16_to_cpu(tmp[2]);
89         cali->AC4 =  be16_to_cpu(tmp[3]);
90         cali->AC5 =  be16_to_cpu(tmp[4]);
91         cali->AC6 = be16_to_cpu(tmp[5]);
92         cali->B1 = be16_to_cpu(tmp[6]);
93         cali->B2 = be16_to_cpu(tmp[7]);
94         cali->MB = be16_to_cpu(tmp[8]);
95         cali->MC = be16_to_cpu(tmp[9]);
96         cali->MD = be16_to_cpu(tmp[10]);
97         return 0;
98 }
99
100
101 static s32 bmp085_update_raw_temperature(struct bmp085_data *data)
102 {
103         u16 tmp;
104         s32 status;
105
106         mutex_lock(&data->lock);
107         status = i2c_smbus_write_byte_data(data->client, BMP085_CTRL_REG,
108                                                 BMP085_TEMP_MEASUREMENT);
109         if (status != 0) {
110                 dev_err(&data->client->dev,
111                         "Error while requesting temperature measurement.\n");
112                 goto exit;
113         }
114         msleep(BMP085_TEMP_CONVERSION_TIME);
115
116         status = i2c_smbus_read_i2c_block_data(data->client,
117                 BMP085_CONVERSION_REGISTER_MSB, sizeof(tmp), (u8 *)&tmp);
118         if (status != sizeof(tmp)) {
119                 dev_err(&data->client->dev,
120                         "Error while reading temperature measurement result\n");
121                 goto exit;
122         }
123         data->raw_temperature = be16_to_cpu(tmp);
124         data->last_temp_measurement = jiffies;
125         status = 0;     /* everything ok, return 0 */
126
127 exit:
128         mutex_unlock(&data->lock);
129         return status;
130 }
131
132 static s32 bmp085_update_raw_pressure(struct bmp085_data *data)
133 {
134         u32 tmp = 0;
135         s32 status;
136
137         mutex_lock(&data->lock);
138         status = i2c_smbus_write_byte_data(data->client, BMP085_CTRL_REG,
139                 BMP085_PRESSURE_MEASUREMENT + (data->oversampling_setting<<6));
140         if (status != 0) {
141                 dev_err(&data->client->dev,
142                         "Error while requesting pressure measurement.\n");
143                 status = -EIO;
144                 goto exit;
145         }
146
147         /* wait for the end of conversion */
148         msleep(2+(3 << data->oversampling_setting<<1));
149
150         /* copy data into a u32 (4 bytes), but skip the first byte. */
151         status = i2c_smbus_read_i2c_block_data(data->client,
152                         BMP085_CONVERSION_REGISTER_MSB, 3, ((u8 *)&tmp)+1);
153         if (status != 3) {
154                 dev_err(&data->client->dev,
155                         "Error while reading pressure measurement results\n");
156                 status = -EIO;
157                 goto exit;
158         }
159         data->raw_pressure = be32_to_cpu((tmp));
160         data->raw_pressure >>= (8-data->oversampling_setting);
161         status = 0;     /* everything ok, return 0 */
162
163 exit:
164         mutex_unlock(&data->lock);
165         return status;
166 }
167
168
169 /*
170  * This function starts the temperature measurement and returns the value
171  * in tenth of a degree celsius.
172  */
173 static s32 bmp085_get_temperature(struct bmp085_data *data, int *temperature)
174 {
175         struct bmp085_calibration_data *cali = &data->calibration;
176         long x1, x2;
177         int status;
178
179         status = bmp085_update_raw_temperature(data);
180         if (status != 0)
181                 goto exit;
182
183         x1 = ((data->raw_temperature - cali->AC6) * cali->AC5) >> 15;
184         x2 = (cali->MC << 11) / (x1 + cali->MD);
185         data->b6 = x1 + x2 - 4000;
186         if (temperature != NULL)                /* in case of NULL just update b6 */
187                 *temperature = (x1+x2+8) >> 4;  /* for pressure only measurement */
188
189 exit:
190         return status;;
191 }
192
193 /*
194  * This function starts the pressure measurement and returns the value
195  * in millibar. Since the pressure depends on the ambient temperature,
196  * a temperature measurement is executed if the last known value is older
197  * than one second.
198  */
199 static s32 bmp085_get_pressure(struct bmp085_data *data, int *pressure)
200 {
201         struct bmp085_calibration_data *cali = &data->calibration;
202         s32 x1, x2, x3, b3;
203         u32 b4, b7;
204         s32 p;
205         int status;
206
207         /* alt least every second force an update of the ambient temperature */
208         if (data->last_temp_measurement + 1*HZ < jiffies) {
209                 status = bmp085_get_temperature(data, NULL);
210                 if (status != 0)
211                         goto exit;
212         }
213
214         status = bmp085_update_raw_pressure(data);
215         if (status != 0)
216                 goto exit;
217
218         x1 = (data->b6 * data->b6) >> 12;
219         x1 *= cali->B2;
220         x1 >>= 11;
221
222         x2 = cali->AC2 * data->b6;
223         x2 >>= 11;
224
225         x3 = x1 + x2;
226
227         b3 = (((((s32)cali->AC1) * 4 + x3) << data->oversampling_setting) + 2);
228         b3 >>= 2;
229
230         x1 = (cali->AC3 * data->b6) >> 13;
231         x2 = (cali->B1 * ((data->b6 * data->b6) >> 12)) >> 16;
232         x3 = (x1 + x2 + 2) >> 2;
233         b4 = (cali->AC4 * (u32)(x3 + 32768)) >> 15;
234
235         b7 = ((u32)data->raw_pressure - b3) *
236                                         (50000 >> data->oversampling_setting);
237         p = ((b7 < 0x80000000) ? ((b7 << 1) / b4) : ((b7 / b4) * 2));
238
239         x1 = p >> 8;
240         x1 *= x1;
241         x1 = (x1 * 3038) >> 16;
242         x2 = (-7357 * p) >> 16;
243         p += (x1 + x2 + 3791) >> 4;
244
245         *pressure = p;
246
247 exit:
248         return status;
249 }
250
251 /*
252  * This function sets the chip-internal oversampling. Valid values are 0..3.
253  * The chip will use 2^oversampling samples for interlan averaging.
254  * This influences the measurement time and the accuracy; larger values
255  * increase both. The datasheet gives on overview on how measurement time,
256  * accuracy and noise correlate.
257  */
258 static void bmp085_set_oversampling(struct bmp085_data *data,
259                                                 unsigned char oversampling)
260 {
261         if (oversampling > 3)
262                 oversampling = 3;
263         data->oversampling_setting = oversampling;
264 }
265
266 /*
267  * Returns the currently selected oversampling. Range: 0..3
268  */
269 static unsigned char bmp085_get_oversampling(struct bmp085_data *data)
270 {
271         return data->oversampling_setting;
272 }
273
274 /* sysfs callbacks */
275 static ssize_t set_oversampling(struct device *dev,
276                                 struct device_attribute *attr,
277                                 const char *buf, size_t count)
278 {
279         struct i2c_client *client = to_i2c_client(dev);
280         struct bmp085_data *data = i2c_get_clientdata(client);
281         unsigned long oversampling;
282         int success = strict_strtoul(buf, 10, &oversampling);
283         if (success == 0) {
284                 bmp085_set_oversampling(data, oversampling);
285                 return count;
286         }
287         return success;
288 }
289
290 static ssize_t show_oversampling(struct device *dev,
291                                  struct device_attribute *attr, char *buf)
292 {
293         struct i2c_client *client = to_i2c_client(dev);
294         struct bmp085_data *data = i2c_get_clientdata(client);
295         return sprintf(buf, "%u\n", bmp085_get_oversampling(data));
296 }
297 static DEVICE_ATTR(oversampling, S_IWUSR | S_IRUGO,
298                                         show_oversampling, set_oversampling);
299
300
301 static ssize_t show_temperature(struct device *dev,
302                                 struct device_attribute *attr, char *buf)
303 {
304         int temperature;
305         int status;
306         struct i2c_client *client = to_i2c_client(dev);
307         struct bmp085_data *data = i2c_get_clientdata(client);
308         status = bmp085_get_temperature(data, &temperature);
309         if (status != 0)
310                 return status;
311         else
312                 return sprintf(buf, "%d\n", temperature);
313 }
314 static DEVICE_ATTR(temp0_input, S_IRUGO, show_temperature, NULL);
315
316
317 static ssize_t show_pressure(struct device *dev,
318                              struct device_attribute *attr, char *buf)
319 {
320         int pressure;
321         int status;
322         struct i2c_client *client = to_i2c_client(dev);
323         struct bmp085_data *data = i2c_get_clientdata(client);
324         status = bmp085_get_pressure(data, &pressure);
325         if (status != 0)
326                 return status;
327         else
328                 return sprintf(buf, "%d\n", pressure);
329 }
330 static DEVICE_ATTR(pressure0_input, S_IRUGO, show_pressure, NULL);
331
332
333 static struct attribute *bmp085_attributes[] = {
334         &dev_attr_temp0_input.attr,
335         &dev_attr_pressure0_input.attr,
336         &dev_attr_oversampling.attr,
337         NULL
338 };
339
340 static const struct attribute_group bmp085_attr_group = {
341         .attrs = bmp085_attributes,
342 };
343
344 static int bmp085_detect(struct i2c_client *client, int kind,
345                           struct i2c_board_info *info)
346 {
347         if (client->addr != BMP085_I2C_ADDRESS)
348                 return -ENODEV;
349
350         if (i2c_smbus_read_byte_data(client, BMP085_CHIP_ID_REG) != BMP085_CHIP_ID)
351                 return -ENODEV;
352
353         strlcpy(info->type, "bmp085", I2C_NAME_SIZE);
354         return 0;
355 }
356
357 static int bmp085_init_client(struct i2c_client *client)
358 {
359         unsigned char version;
360         int status;
361         struct bmp085_data *data = i2c_get_clientdata(client);
362         data->client = client;
363         status = bmp085_read_calibration_data(client);
364         if (status != 0)
365                 goto exit;
366         version = i2c_smbus_read_byte_data(client, BMP085_VERSION_REG);
367         data->last_temp_measurement = 0;
368         data->oversampling_setting = 3;
369         mutex_init(&data->lock);
370         dev_info(&data->client->dev, "BMP085 ver. %d.%d initialized\n",
371                         (version & 0x0F), (version & 0xF0) >> 4);
372
373 exit:
374         return status;
375 }
376
377 static int bmp085_probe(struct i2c_client *client,
378                          const struct i2c_device_id *id)
379 {
380         struct bmp085_data *data;
381         int err = 0;
382
383         data = kzalloc(sizeof(struct bmp085_data), GFP_KERNEL);
384         if (!data) {
385                 err = -ENOMEM;
386                 goto exit;
387         }
388
389         /* default settings after POR */
390         data->oversampling_setting = 0x00;
391
392         i2c_set_clientdata(client, data);
393
394         /* Initialize the BMP085 chip */
395         err = bmp085_init_client(client);
396         if (err != 0)
397                 goto exit_free;
398
399         /* Register sysfs hooks */
400         err = sysfs_create_group(&client->dev.kobj, &bmp085_attr_group);
401         if (err)
402                 goto exit_free;
403
404         dev_info(&data->client->dev, "succesfully initialized bmp085!\n");
405         goto exit;
406
407 exit_free:
408         kfree(data);
409 exit:
410         return err;
411 }
412
413 static int bmp085_remove(struct i2c_client *client)
414 {
415         sysfs_remove_group(&client->dev.kobj, &bmp085_attr_group);
416         kfree(i2c_get_clientdata(client));
417         return 0;
418 }
419
420 static const struct i2c_device_id bmp085_id[] = {
421         { "bmp085", 0 },
422         { }
423 };
424
425 static struct i2c_driver bmp085_driver = {
426         .driver = {
427                 .owner = THIS_MODULE,
428                 .name   = "bmp085"
429         },
430         .id_table       = bmp085_id,
431         .probe          = bmp085_probe,
432         .remove         = bmp085_remove,
433
434         .detect         = bmp085_detect,
435         .address_data   = &addr_data
436 };
437
438 static int __init bmp085_init(void)
439 {
440         return i2c_add_driver(&bmp085_driver);
441 }
442
443 static void __exit bmp085_exit(void)
444 {
445         i2c_del_driver(&bmp085_driver);
446 }
447
448
449 MODULE_AUTHOR("Christoph Mair <christoph.mair@gmail.com");
450 MODULE_DESCRIPTION("BMP085 driver");
451 MODULE_LICENSE("GPL");
452
453 module_init(bmp085_init);
454 module_exit(bmp085_exit);