Vala bindings and examples added. Minor clean-up in header file
[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
26 #define BMP085_I2C_ADDRESS              0x77
27
28 #define BMP085_CALIBRATION_DATA_START   0xAA
29 #define BMP085_CALIBRATION_DATA_LENGTH  22
30
31 #define BMP085_CHIP_ID_REG              0xD0
32 #define BMP085_VERSION_REG              0xD1
33
34 #define BMP085_CHIP_ID                  0x55 /* 85 */
35 #define BMP085_CLIENT_NAME              "bmp085"
36
37
38 /* Addresses to scan: 0x77 */
39 static const unsigned short normal_i2c[] = { BMP085_I2C_ADDRESS,
40                                                         I2C_CLIENT_END };
41
42 struct bmp085_calibration_data {
43         s16 AC1, AC2, AC3;
44         u16 AC4, AC5, AC6;
45         s16 B1, B2;
46         s16 MB, MC, MD;
47 };
48
49
50 /* Each client has this additional data */
51 struct bmp085_data {
52         struct i2c_client *client;
53         unsigned char version;
54         struct bmp085_calibration_data calibration;
55         unsigned long raw_temperature;
56         unsigned long raw_pressure;
57         unsigned char oversampling_setting;
58         unsigned long next_temp_measurement;
59         long b6; /* calculated temperature correction coefficient */
60 };
61
62
63 static void bmp085_init_client(struct i2c_client *client);
64
65
66 static s32 bmp085_read_calibration_data(struct i2c_client *client)
67 {
68         u8 tmp[BMP085_CALIBRATION_DATA_LENGTH];
69         struct bmp085_data *data = i2c_get_clientdata(client);
70         struct bmp085_calibration_data *cali = &(data->calibration);
71         s32 status = i2c_smbus_read_i2c_block_data(client,
72                                         BMP085_CALIBRATION_DATA_START,
73                                         BMP085_CALIBRATION_DATA_LENGTH, tmp);
74
75         cali->AC1 =  (tmp[0] << 8) | tmp[1];
76         cali->AC2 =  (tmp[2] << 8) | tmp[3];
77         cali->AC3 =  (tmp[4] << 8) | tmp[5];
78         cali->AC4 =  (tmp[6] << 8) | tmp[7];
79         cali->AC5 =  (tmp[8] << 8) | tmp[9];
80         cali->AC6 = (tmp[10] << 8) | tmp[11];
81         cali->B1 =  (tmp[12] << 8) | tmp[13];
82         cali->B2 =  (tmp[14] << 8) | tmp[15];
83         cali->MB =  (tmp[16] << 8) | tmp[17];
84         cali->MC =  (tmp[18] << 8) | tmp[19];
85         cali->MD =  (tmp[20] << 8) | tmp[21];
86         return status;
87 }
88
89
90 static s32 bmp085_update_raw_temperature(struct bmp085_data *data)
91 {
92         u8 tmp[2];
93         s32 status = i2c_smbus_write_byte_data(data->client, 0xF4, 0x2E);
94         if (status != 0) {
95                 printk(KERN_INFO "bmp085: Error while requesting"
96                                                 " temperature measurement.\n");
97                 return status;
98         }
99         msleep(5);
100
101         status = i2c_smbus_read_i2c_block_data(data->client, 0xF6, sizeof(tmp), tmp);
102         if (status != sizeof(tmp)) {
103                 printk(KERN_INFO "bmp085: Error while requesting temperature"
104                                         " measurement (II): %d\n", status);
105                 return status;
106         }
107         data->raw_temperature = (tmp[0] << 8) + tmp[1];
108         data->next_temp_measurement = jiffies+1*HZ;
109         return status;
110 }
111
112 static s32 bmp085_update_raw_pressure(struct bmp085_data *data)
113 {
114         u8 tmp[3];
115         s32 status = 0;
116
117         status = i2c_smbus_write_byte_data(data->client, 0xF4, 0x34 + (data->oversampling_setting<<6));
118         if (status != 0) {
119                 printk(KERN_INFO "bmp085: Error while requesting pressure measurement.\n");
120                 return status;
121         }
122         msleep(2+(3 << data->oversampling_setting<<1)); /* wait for the end of conversion */
123
124         status = i2c_smbus_read_i2c_block_data(data->client, 0xF6, sizeof(tmp), tmp);
125         if (status != sizeof(tmp)) {
126                 printk(KERN_INFO "bmp085: Error while requesting pressure measurement (II): %d\n", status);
127                 return status;
128         }
129         /* swap positions to correct the MSB/LSB positions */
130         data->raw_pressure = (tmp[0] << 16) | (tmp[1] << 8) | tmp[2];
131         data->raw_pressure = data->raw_pressure >> (8-data->oversampling_setting);
132         return status;
133 }
134
135
136 static s32 bmp085_get_temperature(struct bmp085_data *data)
137 {
138         struct bmp085_calibration_data *cali = &data->calibration;
139         long x1, x2;
140
141         if (data->next_temp_measurement < jiffies) {
142                 bmp085_update_raw_temperature(data);
143         }
144
145         x1 = ((data->raw_temperature - cali->AC6) * cali->AC5) >> 15;
146         x2 = (cali->MC << 11) / (x1 + cali->MD);
147         data->b6 = x1 + x2 - 4000;
148 //      printf("got raw temp: %ld; AC5: %d, AC6: %d, MC: %d, MD: %d\n", data->raw_temperature, cali->AC5, cali->AC6, cali->MC, cali->MD);
149         return ((x1+x2+8) >> 4);
150 }
151
152
153 static s32 bmp085_get_pressure(struct bmp085_data *data)
154 {
155         struct bmp085_calibration_data *cali = &data->calibration;
156         long x1, x2, x3, b3;
157         unsigned long b4, b7;
158         long p;
159
160         if (data->next_temp_measurement < jiffies) {
161                 bmp085_get_temperature(data);
162         }
163         bmp085_update_raw_pressure(data);
164
165 //      printf("raw_pressure: %ud, B6: %ld\n", data->raw_pressure, data->b6);
166
167         x1 = (data->b6 * data->b6) >> 12;
168         x1 *= cali->B2;
169         x1 >>= 11;
170
171         x2 = cali->AC2 * data->b6;
172         x2 >>= 11;
173
174         x3 = x1 + x2;
175
176         b3 = (((((long)cali->AC1) * 4 + x3) << data->oversampling_setting) + 2) >> 2;
177
178 //      printf("x1: %ld, x2: %ld, x3: %ld, b3: %ld\n", x1, x2, x3, b3);
179         x1 = (cali->AC3 * data->b6) >> 13;
180         x2 = (cali->B1 * ((data->b6 * data->b6) >> 12)) >> 16;
181         x3 = (x1 + x2 + 2) >> 2;
182         b4 = (cali->AC4 * (unsigned long)(x3 + 32768)) >> 15;
183
184 //      printf("x1: %ld, x2: %ld, x3: %ld, b4: %ld\n", x1, x2, x3, b4);
185         b7 = ((unsigned long)data->raw_pressure - b3) * (50000 >> data->oversampling_setting);
186         p = ((b7 < 0x80000000) ? ((b7 << 1) / b4) : ((b7 / b4) * 2));
187
188         x1 = p >> 8;
189         x1 *= x1;
190         x1 = (x1 * 3038) >> 16;
191         x2 = (-7357 * p) >> 16;
192         p += (x1 + x2 + 3791) >> 4;
193         return p;
194 }
195
196
197 static void bmp085_set_oversampling(struct bmp085_data *data, unsigned char oversampling)
198 {
199         if (oversampling> 3) {
200                 oversampling = 3;
201         }
202         data->oversampling_setting = oversampling;
203 }
204
205
206 static unsigned char bmp085_get_oversampling(struct bmp085_data *data)
207 {
208         return data->oversampling_setting;
209 }
210
211
212
213
214
215
216
217 /* sysfs callbacks */
218 static ssize_t set_oversampling(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
219 {
220         struct i2c_client *client = to_i2c_client(dev);
221         struct bmp085_data *data = i2c_get_clientdata(client);
222         bmp085_set_oversampling(data, simple_strtoul(buf, NULL, 10));
223         return count;
224 }
225
226 static ssize_t show_oversampling(struct device *dev, struct device_attribute *attr, char *buf)
227 {
228         struct i2c_client *client = to_i2c_client(dev);
229         struct bmp085_data *data = i2c_get_clientdata(client);
230         return sprintf(buf, "%u\n", bmp085_get_oversampling(data));
231 }
232 static DEVICE_ATTR(oversampling, S_IWUSR | S_IRUGO, show_oversampling, set_oversampling);
233
234
235 static ssize_t show_temperature(struct device *dev, struct device_attribute *attr, char *buf)
236 {
237         struct i2c_client *client = to_i2c_client(dev);
238         struct bmp085_data *data = i2c_get_clientdata(client);
239         return sprintf(buf, "%d\n", bmp085_get_temperature(data));
240 }
241 static DEVICE_ATTR(temperature, S_IRUGO, show_temperature, NULL);
242
243
244 static ssize_t show_pressure(struct device *dev, struct device_attribute *attr, char *buf)
245 {
246         struct i2c_client *client = to_i2c_client(dev);
247         struct bmp085_data *data = i2c_get_clientdata(client);
248         return sprintf(buf, "%d\n", bmp085_get_pressure(data));
249 }
250 static DEVICE_ATTR(pressure, S_IRUGO, show_pressure, NULL);
251
252
253 static struct attribute *bmp085_attributes[] = {
254         &dev_attr_temperature.attr,
255         &dev_attr_pressure.attr,
256         &dev_attr_oversampling.attr,
257         NULL
258 };
259
260 static const struct attribute_group bmp085_attr_group = {
261         .attrs = bmp085_attributes,
262 };
263
264
265 static int bmp085_probe(struct i2c_client *client,
266                          const struct i2c_device_id *id)
267 {
268         struct bmp085_data *data;
269         int err = 0;
270
271         if (client->addr != BMP085_I2C_ADDRESS)
272                 goto exit;
273
274         if (i2c_smbus_read_byte_data(client, BMP085_CHIP_ID_REG) != BMP085_CHIP_ID)
275                 goto exit;
276
277         data = kzalloc(sizeof(struct bmp085_data), GFP_KERNEL);
278         if (!data) {
279                 err = -ENOMEM;
280                 goto exit;
281         }
282
283         /* default settings after POR */
284         data->oversampling_setting = 0x00;
285
286         i2c_set_clientdata(client, data);
287
288         /* Initialize the BMP085 chip */
289         bmp085_init_client(client);
290
291         /* Register sysfs hooks */
292         err = sysfs_create_group(&client->dev.kobj, &bmp085_attr_group);
293         if (err)
294                 goto exit_free;
295
296         printk(KERN_INFO "succesfully initialized bmp085!\n");
297         return 0;
298
299       exit_free:
300         kfree(data);
301       exit:
302         return err;
303 }
304
305 static int bmp085_remove(struct i2c_client *client)
306 {
307         printk(KERN_INFO "bmp085 remove!\n");
308         sysfs_remove_group(&client->dev.kobj, &bmp085_attr_group);
309         kfree(i2c_get_clientdata(client));
310         return 0;
311 }
312
313 /* Called when we have found a new HMC5843. */
314 static void bmp085_init_client(struct i2c_client *client)
315 {
316         struct bmp085_data *data = i2c_get_clientdata(client);
317         bmp085_read_calibration_data(client);
318         data->version = i2c_smbus_read_byte_data(client, BMP085_VERSION_REG);
319         data->next_temp_measurement = 0;
320         data->oversampling_setting = 3;
321         printk(KERN_INFO "BMP085 ver. %d.%d initialized\n", (data->version & 0x0F), (data->version & 0xF0) >> 4);
322 }
323
324 static const struct i2c_device_id bmp085_id[] = {
325         { "bmp085", 0 },
326         { }
327 };
328
329 static struct i2c_driver bmp085_driver = {
330         .driver = {
331                 .name   = "bmp085",
332                 .owner = THIS_MODULE
333         },
334         .probe          = bmp085_probe,
335         .remove         = bmp085_remove,
336         .id_table       = bmp085_id
337
338 //      .detect         = bmp085_detect
339 };
340
341 static int __init bmp085_init(void)
342 {
343         printk(KERN_INFO "init!\n");
344         return i2c_add_driver(&bmp085_driver);
345 }
346
347 static void __exit bmp085_exit(void)
348 {
349         printk(KERN_INFO "exit!\n");
350         i2c_del_driver(&bmp085_driver);
351 }
352
353
354 MODULE_AUTHOR("Christoph Mair <christoph.mair@gmail.com");
355 MODULE_DESCRIPTION("BMP085 driver");
356 MODULE_LICENSE("GPL");
357
358 module_init(bmp085_init);
359 module_exit(bmp085_exit);