Code cleanups.
[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/slab.h>
23 #include <linux/delay.h>
24
25
26 #define BMP085_I2C_ADDRESS              0x77
27 #define BMP085_CHIP_ID                  0x55
28
29 #define BMP085_CALIBRATION_DATA_START   0xAA
30 #define BMP085_CALIBRATION_DATA_LENGTH  22
31 #define BMP085_CHIP_ID_REG              0xD0
32 #define BMP085_VERSION_REG              0xD1
33 #define BMP085_CTRL_REG                 0xF4
34 #define BMP085_TEMP_MEASUREMENT         0x2E
35 #define BMP085_PRESSURE_MEASUREMENT     0x34
36 #define BMP085_CONVERSION_REGISTER_MSB  0xF6
37 #define BMP085_CONVERSION_REGISTER_LSB  0xF7
38 #define BMP085_CONVERSION_REGISTER_XLSB 0xF8
39 #define BMP085_TEMP_CONVERSION_TIME     5
40
41 #define BMP085_MIN_TEMP                 -400    /* tenth of a degree celsius */
42 #define BMP085_MAX_TEMP                 850
43 #define BMP085_MIN_PRESSURE             30000   /* pascal (millibar) */
44 #define BMP085_MAX_PRESSURE             110000
45 #define BMP085_INPUT_POLL_INTERVAL      1000    /* ms */
46
47 #define BMP085_CLIENT_NAME              "bmp085"
48
49
50 static const unsigned short normal_i2c[] = { BMP085_I2C_ADDRESS,
51                                                         I2C_CLIENT_END };
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 void bmp085_init_client(struct i2c_client *client);
75
76
77 static s32 bmp085_read_calibration_data(struct i2c_client *client)
78 {
79         u16 tmp[BMP085_CALIBRATION_DATA_LENGTH];
80         struct bmp085_data *data = i2c_get_clientdata(client);
81         struct bmp085_calibration_data *cali = &(data->calibration);
82         s32 status = i2c_smbus_read_i2c_block_data(client,
83                                 BMP085_CALIBRATION_DATA_START,
84                                 BMP085_CALIBRATION_DATA_LENGTH, (u8*)tmp);
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 status;
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, "Error while requesting"
111                                                 " 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, "Error while requesting"
120                                 " temperature measurement (II): %d\n", status);
121                 goto exit;
122         }
123         data->raw_temperature = be16_to_cpu(tmp);
124         data->last_temp_measurement = jiffies;
125
126 exit:
127         mutex_unlock(&data->lock);
128         return status;
129 }
130
131 static s32 bmp085_update_raw_pressure(struct bmp085_data *data)
132 {
133         u32 tmp = 0;
134         s32 status;
135
136         mutex_lock(&data->lock);
137         status = i2c_smbus_write_byte_data(data->client, BMP085_CTRL_REG,
138                 BMP085_PRESSURE_MEASUREMENT + (data->oversampling_setting<<6));
139         if (status != 0) {
140                 dev_err(&data->client->dev, "Error while requesting"
141                                                 "pressure measurement.\n");
142                 goto exit;
143         }
144
145         /* wait for the end of conversion */
146         msleep(2+(3 << data->oversampling_setting<<1));
147
148         /* copy data into a u32 (4 bytes), but leave skip the first byte. */
149         status = i2c_smbus_read_i2c_block_data(
150                                         data->client, 0xF6, 3, ((u8*)&tmp)+1);
151         if (status != 3) {
152                 dev_err(&data->client->dev, "Error while reading"
153                                 "pressure measurement results: %d\n", status);
154                 goto exit;
155         }
156         data->raw_pressure = be32_to_cpu((tmp));
157         data->raw_pressure >>= (8-data->oversampling_setting);
158
159 exit:
160         mutex_unlock(&data->lock);
161         return status;
162 }
163
164
165 /*
166  * This function starts the temperature measurement and returns the value
167  * in tenth of a degree celsius.
168  */
169 static s32 bmp085_get_temperature(struct bmp085_data *data)
170 {
171         struct bmp085_calibration_data *cali = &data->calibration;
172         long x1, x2;
173
174         bmp085_update_raw_temperature(data);
175
176         x1 = ((data->raw_temperature - cali->AC6) * cali->AC5) >> 15;
177         x2 = (cali->MC << 11) / (x1 + cali->MD);
178         data->b6 = x1 + x2 - 4000;
179         return (x1+x2+8) >> 4;
180 }
181
182 /*
183  * This function starts the pressure measurement and returns the value
184  * in millibar. Since the pressure depends on the ambient temperature,
185  * a temperature measurement is executed if the last known value is older
186  * than one second.
187  */
188 static s32 bmp085_get_pressure(struct bmp085_data *data)
189 {
190         struct bmp085_calibration_data *cali = &data->calibration;
191         s32 x1, x2, x3, b3;
192         u32 b4, b7;
193         s32 p;
194
195         /* alt least every second force an update of the ambient temperature */
196         if (data->last_temp_measurement + 1*HZ < jiffies)
197                 bmp085_get_temperature(data);
198
199         bmp085_update_raw_pressure(data);
200
201         x1 = (data->b6 * data->b6) >> 12;
202         x1 *= cali->B2;
203         x1 >>= 11;
204
205         x2 = cali->AC2 * data->b6;
206         x2 >>= 11;
207
208         x3 = x1 + x2;
209
210         b3 = (((((s32)cali->AC1) * 4 + x3) << data->oversampling_setting) + 2);
211         b3 >>= 2;
212
213         x1 = (cali->AC3 * data->b6) >> 13;
214         x2 = (cali->B1 * ((data->b6 * data->b6) >> 12)) >> 16;
215         x3 = (x1 + x2 + 2) >> 2;
216         b4 = (cali->AC4 * (u32)(x3 + 32768)) >> 15;
217
218         b7 = ((u32)data->raw_pressure - b3) *
219                                         (50000 >> data->oversampling_setting);
220         p = ((b7 < 0x80000000) ? ((b7 << 1) / b4) : ((b7 / b4) * 2));
221
222         x1 = p >> 8;
223         x1 *= x1;
224         x1 = (x1 * 3038) >> 16;
225         x2 = (-7357 * p) >> 16;
226         p += (x1 + x2 + 3791) >> 4;
227         return p;
228 }
229
230 /*
231  * This function sets the chip-internal oversampling. Valid values are 0..3.
232  * The chip will use 2^oversampling samples for interlan averaging.
233  * This influences the measurement time and the accuracy; larger values
234  * increase both. The datasheet gives on overview on how measurement time,
235  * accuracy and noise correlate.
236  */
237 static void bmp085_set_oversampling(struct bmp085_data *data,
238                                                 unsigned char oversampling)
239 {
240         if (oversampling > 3)
241                 oversampling = 3;
242         data->oversampling_setting = oversampling;
243 }
244
245 /*
246  * Returns the currently selected oversampling. Range: 0..3
247  */
248 static unsigned char bmp085_get_oversampling(struct bmp085_data *data)
249 {
250         return data->oversampling_setting;
251 }
252
253 /* sysfs callbacks */
254 static ssize_t set_oversampling(struct device *dev,
255                                 struct device_attribute *attr,
256                                 const char *buf, size_t count)
257 {
258         struct i2c_client *client = to_i2c_client(dev);
259         struct bmp085_data *data = i2c_get_clientdata(client);
260         unsigned long oversampling;
261         int success = strict_strtoul(buf, 10, &oversampling);
262         printk(KERN_INFO "str: %s, d: %lu, suc: %d\n", buf, oversampling, success);
263         if (success == 0) {
264                 printk(KERN_INFO "pla");
265                 bmp085_set_oversampling(data, oversampling);
266                 return count;
267         }
268         printk(KERN_INFO "plapla");
269         return success;
270 }
271
272 static ssize_t show_oversampling(struct device *dev,
273                                  struct device_attribute *attr, char *buf)
274 {
275         struct i2c_client *client = to_i2c_client(dev);
276         struct bmp085_data *data = i2c_get_clientdata(client);
277         return sprintf(buf, "%u\n", bmp085_get_oversampling(data));
278 }
279 static DEVICE_ATTR(oversampling, S_IWUSR | S_IRUGO,
280                                         show_oversampling, set_oversampling);
281
282
283 static ssize_t show_temperature(struct device *dev,
284                                 struct device_attribute *attr, char *buf)
285 {
286         struct i2c_client *client = to_i2c_client(dev);
287         struct bmp085_data *data = i2c_get_clientdata(client);
288         return sprintf(buf, "%d\n", bmp085_get_temperature(data));
289 }
290 static DEVICE_ATTR(temp0_input, S_IRUGO, show_temperature, NULL);
291
292
293 static ssize_t show_pressure(struct device *dev,
294                              struct device_attribute *attr, char *buf)
295 {
296         struct i2c_client *client = to_i2c_client(dev);
297         struct bmp085_data *data = i2c_get_clientdata(client);
298         return sprintf(buf, "%d\n", bmp085_get_pressure(data));
299 }
300 static DEVICE_ATTR(pressure0_input, S_IRUGO, show_pressure, NULL);
301
302
303 static struct attribute *bmp085_attributes[] = {
304         &dev_attr_temp0_input.attr,
305         &dev_attr_pressure0_input.attr,
306         &dev_attr_oversampling.attr,
307         NULL
308 };
309
310 static const struct attribute_group bmp085_attr_group = {
311         .attrs = bmp085_attributes,
312 };
313
314 static int bmp085_detect(struct i2c_client *client,
315                           struct i2c_board_info *info)
316 {
317         if (client->addr != BMP085_I2C_ADDRESS)
318                 return -ENODEV;
319
320         if (i2c_smbus_read_byte_data(client, BMP085_CHIP_ID_REG) != BMP085_CHIP_ID)
321                 return -ENODEV;
322
323         return 0;
324 }
325
326 static int bmp085_probe(struct i2c_client *client,
327                          const struct i2c_device_id *id)
328 {
329         struct bmp085_data *data;
330         int err = 0;
331
332         data = kzalloc(sizeof(struct bmp085_data), GFP_KERNEL);
333         if (!data) {
334                 err = -ENOMEM;
335                 goto exit;
336         }
337
338         /* default settings after POR */
339         data->oversampling_setting = 0x00;
340
341         i2c_set_clientdata(client, data);
342
343         /* Initialize the BMP085 chip */
344         bmp085_init_client(client);
345
346         /* Register sysfs hooks */
347         err = sysfs_create_group(&client->dev.kobj, &bmp085_attr_group);
348         if (err)
349                 goto exit_free;
350
351         dev_info(&data->client->dev, "succesfully initialized bmp085!\n");
352         goto exit;
353
354 exit_free:
355         kfree(data);
356 exit:
357         return err;
358 }
359
360 static int bmp085_remove(struct i2c_client *client)
361 {
362         sysfs_remove_group(&client->dev.kobj, &bmp085_attr_group);
363         kfree(i2c_get_clientdata(client));
364         return 0;
365 }
366
367 /* Called when we have found a new HMC5843. */
368 static void bmp085_init_client(struct i2c_client *client)
369 {
370         unsigned char version;
371         struct bmp085_data *data = i2c_get_clientdata(client);
372         data->client = client;
373         bmp085_read_calibration_data(client);
374         version = i2c_smbus_read_byte_data(client, BMP085_VERSION_REG);
375         data->last_temp_measurement = 0;
376         data->oversampling_setting = 3;
377         mutex_init(&data->lock);
378         dev_info(&data->client->dev, "BMP085 ver. %d.%d initialized\n",
379                         (version & 0x0F), (version & 0xF0) >> 4);
380 }
381
382 static const struct i2c_device_id bmp085_id[] = {
383         { "bmp085", 0 },
384         { }
385 };
386
387 static struct i2c_driver bmp085_driver = {
388         .driver = {
389                 .owner = THIS_MODULE,
390                 .name   = "bmp085"
391         },
392         .id_table       = bmp085_id,
393         .probe          = bmp085_probe,
394         .remove         = bmp085_remove,
395
396         .class          = I2C_CLASS_HWMON,
397         .detect         = bmp085_detect,
398         .address_list   = normal_i2c
399 };
400
401 static int __init bmp085_init(void)
402 {
403         return i2c_add_driver(&bmp085_driver);
404 }
405
406 static void __exit bmp085_exit(void)
407 {
408         i2c_del_driver(&bmp085_driver);
409 }
410
411
412 MODULE_AUTHOR("Christoph Mair <christoph.mair@gmail.com");
413 MODULE_DESCRIPTION("BMP085 driver");
414 MODULE_LICENSE("GPL");
415
416 module_init(bmp085_init);
417 module_exit(bmp085_exit);