1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Measurements Specialties driver common i2c functions
4 *
5 * Copyright (c) 2015 Measurement-Specialties
6 */
7
8 #include <linux/module.h>
9 #include <linux/iio/iio.h>
10 #include <linux/device.h>
11 #include <linux/delay.h>
12
13 #include "ms_sensors_i2c.h"
14
15 /* Conversion times in us */
16 static const u16 ms_sensors_ht_t_conversion_time[] = { 50000, 25000,
17 13000, 7000 };
18 static const u16 ms_sensors_ht_h_conversion_time[] = { 16000, 5000,
19 3000, 8000 };
20 static const u16 ms_sensors_tp_conversion_time[] = { 500, 1100, 2100,
21 4100, 8220, 16440 };
22
23 #define MS_SENSORS_SERIAL_READ_MSB 0xFA0F
24 #define MS_SENSORS_SERIAL_READ_LSB 0xFCC9
25 #define MS_SENSORS_CONFIG_REG_WRITE 0xE6
26 #define MS_SENSORS_CONFIG_REG_READ 0xE7
27 #define MS_SENSORS_HT_T_CONVERSION_START 0xF3
28 #define MS_SENSORS_HT_H_CONVERSION_START 0xF5
29
30 #define MS_SENSORS_TP_PROM_READ 0xA0
31 #define MS_SENSORS_TP_T_CONVERSION_START 0x50
32 #define MS_SENSORS_TP_P_CONVERSION_START 0x40
33 #define MS_SENSORS_TP_ADC_READ 0x00
34
35 #define MS_SENSORS_NO_READ_CMD 0xFF
36
37 /**
38 * ms_sensors_reset() - Reset function
39 * @cli: pointer to device client
40 * @cmd: reset cmd. Depends on device in use
41 * @delay: usleep minimal delay after reset command is issued
42 *
43 * Generic I2C reset function for Measurement Specialties devices.
44 *
45 * Return: 0 on success, negative errno otherwise.
46 */
ms_sensors_reset(void * cli,u8 cmd,unsigned int delay)47 int ms_sensors_reset(void *cli, u8 cmd, unsigned int delay)
48 {
49 int ret;
50 struct i2c_client *client = cli;
51
52 ret = i2c_smbus_write_byte(client, cmd);
53 if (ret) {
54 dev_err(&client->dev, "Failed to reset device\n");
55 return ret;
56 }
57 usleep_range(delay, delay + 1000);
58
59 return 0;
60 }
61 EXPORT_SYMBOL_NS(ms_sensors_reset, "IIO_MEAS_SPEC_SENSORS");
62
63 /**
64 * ms_sensors_read_prom_word() - PROM word read function
65 * @cli: pointer to device client
66 * @cmd: PROM read cmd. Depends on device and prom id
67 * @word: pointer to word destination value
68 *
69 * Generic i2c prom word read function for Measurement Specialties devices.
70 *
71 * Return: 0 on success, negative errno otherwise.
72 */
ms_sensors_read_prom_word(void * cli,int cmd,u16 * word)73 int ms_sensors_read_prom_word(void *cli, int cmd, u16 *word)
74 {
75 int ret;
76 struct i2c_client *client = cli;
77
78 ret = i2c_smbus_read_word_swapped(client, cmd);
79 if (ret < 0) {
80 dev_err(&client->dev, "Failed to read prom word\n");
81 return ret;
82 }
83 *word = ret;
84
85 return 0;
86 }
87 EXPORT_SYMBOL_NS(ms_sensors_read_prom_word, "IIO_MEAS_SPEC_SENSORS");
88
89 /**
90 * ms_sensors_convert_and_read() - ADC conversion & read function
91 * @cli: pointer to device client
92 * @conv: ADC conversion command. Depends on device in use
93 * @rd: ADC read command. Depends on device in use
94 * @delay: usleep minimal delay after conversion command is issued
95 * @adc: pointer to ADC destination value
96 *
97 * Generic ADC conversion & read function for Measurement Specialties
98 * devices.
99 * The function will issue conversion command, sleep appopriate delay, and
100 * issue command to read ADC.
101 *
102 * Return: 0 on success, negative errno otherwise.
103 */
ms_sensors_convert_and_read(void * cli,u8 conv,u8 rd,unsigned int delay,u32 * adc)104 int ms_sensors_convert_and_read(void *cli, u8 conv, u8 rd,
105 unsigned int delay, u32 *adc)
106 {
107 int ret;
108 __be32 buf = 0;
109 struct i2c_client *client = cli;
110
111 /* Trigger conversion */
112 ret = i2c_smbus_write_byte(client, conv);
113 if (ret)
114 goto err;
115 usleep_range(delay, delay + 1000);
116
117 /* Retrieve ADC value */
118 if (rd != MS_SENSORS_NO_READ_CMD)
119 ret = i2c_smbus_read_i2c_block_data(client, rd, 3, (u8 *)&buf);
120 else
121 ret = i2c_master_recv(client, (u8 *)&buf, 3);
122 if (ret < 0)
123 goto err;
124
125 dev_dbg(&client->dev, "ADC raw value : %x\n", be32_to_cpu(buf) >> 8);
126 *adc = be32_to_cpu(buf) >> 8;
127
128 return 0;
129 err:
130 dev_err(&client->dev, "Unable to make sensor adc conversion\n");
131 return ret;
132 }
133 EXPORT_SYMBOL_NS(ms_sensors_convert_and_read, "IIO_MEAS_SPEC_SENSORS");
134
135 /**
136 * ms_sensors_crc_valid() - CRC check function
137 * @value: input and CRC compare value
138 *
139 * Cyclic Redundancy Check function used in TSYS02D, HTU21, MS8607.
140 * This function performs a x^8 + x^5 + x^4 + 1 polynomial CRC.
141 * The argument contains CRC value in LSB byte while the bytes 1 and 2
142 * are used for CRC computation.
143 *
144 * Return: 1 if CRC is valid, 0 otherwise.
145 */
ms_sensors_crc_valid(u32 value)146 static bool ms_sensors_crc_valid(u32 value)
147 {
148 u32 polynom = 0x988000; /* x^8 + x^5 + x^4 + 1 */
149 u32 msb = 0x800000;
150 u32 mask = 0xFF8000;
151 u32 result = value & 0xFFFF00;
152 u8 crc = value & 0xFF;
153
154 while (msb != 0x80) {
155 if (result & msb)
156 result = ((result ^ polynom) & mask)
157 | (result & ~mask);
158 msb >>= 1;
159 mask >>= 1;
160 polynom >>= 1;
161 }
162
163 return result == crc;
164 }
165
166 /**
167 * ms_sensors_read_serial() - Serial number read function
168 * @client: pointer to i2c client
169 * @sn: pointer to 64-bits destination value
170 *
171 * Generic i2c serial number read function for Measurement Specialties devices.
172 * This function is used for TSYS02d, HTU21, MS8607 chipset.
173 * Refer to datasheet:
174 * http://www.meas-spec.com/downloads/HTU2X_Serial_Number_Reading.pdf
175 *
176 * Sensor raw MSB serial number format is the following :
177 * [ SNB3, CRC, SNB2, CRC, SNB1, CRC, SNB0, CRC]
178 * Sensor raw LSB serial number format is the following :
179 * [ X, X, SNC1, SNC0, CRC, SNA1, SNA0, CRC]
180 * The resulting serial number is following :
181 * [ SNA1, SNA0, SNB3, SNB2, SNB1, SNB0, SNC1, SNC0]
182 *
183 * Return: 0 on success, negative errno otherwise.
184 */
ms_sensors_read_serial(struct i2c_client * client,u64 * sn)185 int ms_sensors_read_serial(struct i2c_client *client, u64 *sn)
186 {
187 u8 i;
188 __be64 rcv_buf = 0;
189 u64 rcv_val;
190 __be16 send_buf;
191 int ret;
192
193 struct i2c_msg msg[2] = {
194 {
195 .addr = client->addr,
196 .flags = client->flags,
197 .len = 2,
198 .buf = (__u8 *)&send_buf,
199 },
200 {
201 .addr = client->addr,
202 .flags = client->flags | I2C_M_RD,
203 .buf = (__u8 *)&rcv_buf,
204 },
205 };
206
207 /* Read MSB part of serial number */
208 send_buf = cpu_to_be16(MS_SENSORS_SERIAL_READ_MSB);
209 msg[1].len = 8;
210 ret = i2c_transfer(client->adapter, msg, 2);
211 if (ret < 0) {
212 dev_err(&client->dev, "Unable to read device serial number");
213 return ret;
214 }
215
216 rcv_val = be64_to_cpu(rcv_buf);
217 dev_dbg(&client->dev, "Serial MSB raw : %llx\n", rcv_val);
218
219 for (i = 0; i < 64; i += 16) {
220 if (!ms_sensors_crc_valid((rcv_val >> i) & 0xFFFF))
221 return -ENODEV;
222 }
223
224 *sn = (((rcv_val >> 32) & 0xFF000000) |
225 ((rcv_val >> 24) & 0x00FF0000) |
226 ((rcv_val >> 16) & 0x0000FF00) |
227 ((rcv_val >> 8) & 0x000000FF)) << 16;
228
229 /* Read LSB part of serial number */
230 send_buf = cpu_to_be16(MS_SENSORS_SERIAL_READ_LSB);
231 msg[1].len = 6;
232 rcv_buf = 0;
233 ret = i2c_transfer(client->adapter, msg, 2);
234 if (ret < 0) {
235 dev_err(&client->dev, "Unable to read device serial number");
236 return ret;
237 }
238
239 rcv_val = be64_to_cpu(rcv_buf) >> 16;
240 dev_dbg(&client->dev, "Serial MSB raw : %llx\n", rcv_val);
241
242 for (i = 0; i < 48; i += 24) {
243 if (!ms_sensors_crc_valid((rcv_val >> i) & 0xFFFFFF))
244 return -ENODEV;
245 }
246
247 *sn |= (rcv_val & 0xFFFF00) << 40 | (rcv_val >> 32);
248
249 return 0;
250 }
251 EXPORT_SYMBOL_NS(ms_sensors_read_serial, "IIO_MEAS_SPEC_SENSORS");
252
ms_sensors_read_config_reg(struct i2c_client * client,u8 * config_reg)253 static int ms_sensors_read_config_reg(struct i2c_client *client,
254 u8 *config_reg)
255 {
256 int ret;
257
258 ret = i2c_smbus_write_byte(client, MS_SENSORS_CONFIG_REG_READ);
259 if (ret) {
260 dev_err(&client->dev, "Unable to read config register");
261 return ret;
262 }
263
264 ret = i2c_master_recv(client, config_reg, 1);
265 if (ret < 0) {
266 dev_err(&client->dev, "Unable to read config register");
267 return ret;
268 }
269 dev_dbg(&client->dev, "Config register :%x\n", *config_reg);
270
271 return 0;
272 }
273
274 /**
275 * ms_sensors_write_resolution() - Set resolution function
276 * @dev_data: pointer to temperature/humidity device data
277 * @i: resolution index to set
278 *
279 * This function will program the appropriate resolution based on the index
280 * provided when user space will set samp_freq channel.
281 * This function is used for TSYS02D, HTU21 and MS8607 chipsets.
282 *
283 * Return: 0 on success, negative errno otherwise.
284 */
ms_sensors_write_resolution(struct ms_ht_dev * dev_data,u8 i)285 ssize_t ms_sensors_write_resolution(struct ms_ht_dev *dev_data,
286 u8 i)
287 {
288 u8 config_reg;
289 int ret;
290
291 ret = ms_sensors_read_config_reg(dev_data->client, &config_reg);
292 if (ret)
293 return ret;
294
295 config_reg &= 0x7E;
296 config_reg |= ((i & 1) << 7) + ((i & 2) >> 1);
297
298 return i2c_smbus_write_byte_data(dev_data->client,
299 MS_SENSORS_CONFIG_REG_WRITE,
300 config_reg);
301 }
302 EXPORT_SYMBOL_NS(ms_sensors_write_resolution, "IIO_MEAS_SPEC_SENSORS");
303
304 /**
305 * ms_sensors_show_battery_low() - Show device battery low indicator
306 * @dev_data: pointer to temperature/humidity device data
307 * @buf: pointer to char buffer to write result
308 *
309 * This function will read battery indicator value in the device and
310 * return 1 if the device voltage is below 2.25V.
311 * This function is used for TSYS02D, HTU21 and MS8607 chipsets.
312 *
313 * Return: length of sprintf on success, negative errno otherwise.
314 */
ms_sensors_show_battery_low(struct ms_ht_dev * dev_data,char * buf)315 ssize_t ms_sensors_show_battery_low(struct ms_ht_dev *dev_data,
316 char *buf)
317 {
318 int ret;
319 u8 config_reg;
320
321 mutex_lock(&dev_data->lock);
322 ret = ms_sensors_read_config_reg(dev_data->client, &config_reg);
323 mutex_unlock(&dev_data->lock);
324 if (ret)
325 return ret;
326
327 return sysfs_emit(buf, "%d\n", (config_reg & 0x40) >> 6);
328 }
329 EXPORT_SYMBOL_NS(ms_sensors_show_battery_low, "IIO_MEAS_SPEC_SENSORS");
330
331 /**
332 * ms_sensors_show_heater() - Show device heater
333 * @dev_data: pointer to temperature/humidity device data
334 * @buf: pointer to char buffer to write result
335 *
336 * This function will read heater enable value in the device and
337 * return 1 if the heater is enabled.
338 * This function is used for HTU21 and MS8607 chipsets.
339 *
340 * Return: length of sprintf on success, negative errno otherwise.
341 */
ms_sensors_show_heater(struct ms_ht_dev * dev_data,char * buf)342 ssize_t ms_sensors_show_heater(struct ms_ht_dev *dev_data,
343 char *buf)
344 {
345 u8 config_reg;
346 int ret;
347
348 mutex_lock(&dev_data->lock);
349 ret = ms_sensors_read_config_reg(dev_data->client, &config_reg);
350 mutex_unlock(&dev_data->lock);
351 if (ret)
352 return ret;
353
354 return sysfs_emit(buf, "%d\n", (config_reg & 0x4) >> 2);
355 }
356 EXPORT_SYMBOL_NS(ms_sensors_show_heater, "IIO_MEAS_SPEC_SENSORS");
357
358 /**
359 * ms_sensors_write_heater() - Write device heater
360 * @dev_data: pointer to temperature/humidity device data
361 * @buf: pointer to char buffer from user space
362 * @len: length of buf
363 *
364 * This function will write 1 or 0 value in the device
365 * to enable or disable heater.
366 * This function is used for HTU21 and MS8607 chipsets.
367 *
368 * Return: length of buffer, negative errno otherwise.
369 */
ms_sensors_write_heater(struct ms_ht_dev * dev_data,const char * buf,size_t len)370 ssize_t ms_sensors_write_heater(struct ms_ht_dev *dev_data,
371 const char *buf, size_t len)
372 {
373 u8 val, config_reg;
374 int ret;
375
376 ret = kstrtou8(buf, 10, &val);
377 if (ret)
378 return ret;
379
380 if (val > 1)
381 return -EINVAL;
382
383 mutex_lock(&dev_data->lock);
384 ret = ms_sensors_read_config_reg(dev_data->client, &config_reg);
385 if (ret) {
386 mutex_unlock(&dev_data->lock);
387 return ret;
388 }
389
390 config_reg &= 0xFB;
391 config_reg |= val << 2;
392
393 ret = i2c_smbus_write_byte_data(dev_data->client,
394 MS_SENSORS_CONFIG_REG_WRITE,
395 config_reg);
396 mutex_unlock(&dev_data->lock);
397 if (ret) {
398 dev_err(&dev_data->client->dev, "Unable to write config register\n");
399 return ret;
400 }
401
402 return len;
403 }
404 EXPORT_SYMBOL_NS(ms_sensors_write_heater, "IIO_MEAS_SPEC_SENSORS");
405
406 /**
407 * ms_sensors_ht_read_temperature() - Read temperature
408 * @dev_data: pointer to temperature/humidity device data
409 * @temperature:pointer to temperature destination value
410 *
411 * This function will get temperature ADC value from the device,
412 * check the CRC and compute the temperature value.
413 * This function is used for TSYS02D, HTU21 and MS8607 chipsets.
414 *
415 * Return: 0 on success, negative errno otherwise.
416 */
ms_sensors_ht_read_temperature(struct ms_ht_dev * dev_data,s32 * temperature)417 int ms_sensors_ht_read_temperature(struct ms_ht_dev *dev_data,
418 s32 *temperature)
419 {
420 int ret;
421 u32 adc;
422 u16 delay;
423
424 mutex_lock(&dev_data->lock);
425 delay = ms_sensors_ht_t_conversion_time[dev_data->res_index];
426 ret = ms_sensors_convert_and_read(dev_data->client,
427 MS_SENSORS_HT_T_CONVERSION_START,
428 MS_SENSORS_NO_READ_CMD,
429 delay, &adc);
430 mutex_unlock(&dev_data->lock);
431 if (ret)
432 return ret;
433
434 if (!ms_sensors_crc_valid(adc)) {
435 dev_err(&dev_data->client->dev,
436 "Temperature read crc check error\n");
437 return -ENODEV;
438 }
439
440 /* Temperature algorithm */
441 *temperature = (((s64)(adc >> 8) * 175720) >> 16) - 46850;
442
443 return 0;
444 }
445 EXPORT_SYMBOL_NS(ms_sensors_ht_read_temperature, "IIO_MEAS_SPEC_SENSORS");
446
447 /**
448 * ms_sensors_ht_read_humidity() - Read humidity
449 * @dev_data: pointer to temperature/humidity device data
450 * @humidity: pointer to humidity destination value
451 *
452 * This function will get humidity ADC value from the device,
453 * check the CRC and compute the temperature value.
454 * This function is used for HTU21 and MS8607 chipsets.
455 *
456 * Return: 0 on success, negative errno otherwise.
457 */
ms_sensors_ht_read_humidity(struct ms_ht_dev * dev_data,u32 * humidity)458 int ms_sensors_ht_read_humidity(struct ms_ht_dev *dev_data,
459 u32 *humidity)
460 {
461 int ret;
462 u32 adc;
463 u16 delay;
464
465 mutex_lock(&dev_data->lock);
466 delay = ms_sensors_ht_h_conversion_time[dev_data->res_index];
467 ret = ms_sensors_convert_and_read(dev_data->client,
468 MS_SENSORS_HT_H_CONVERSION_START,
469 MS_SENSORS_NO_READ_CMD,
470 delay, &adc);
471 mutex_unlock(&dev_data->lock);
472 if (ret)
473 return ret;
474
475 if (!ms_sensors_crc_valid(adc)) {
476 dev_err(&dev_data->client->dev,
477 "Humidity read crc check error\n");
478 return -ENODEV;
479 }
480
481 /* Humidity algorithm */
482 *humidity = (((s32)(adc >> 8) * 12500) >> 16) * 10 - 6000;
483 if (*humidity >= 100000)
484 *humidity = 100000;
485
486 return 0;
487 }
488 EXPORT_SYMBOL_NS(ms_sensors_ht_read_humidity, "IIO_MEAS_SPEC_SENSORS");
489
490 /**
491 * ms_sensors_tp_crc4() - Calculate PROM CRC for
492 * Temperature and pressure devices.
493 * This function is only used when reading PROM coefficients
494 *
495 * @prom: pointer to PROM coefficients array
496 *
497 * Return: CRC.
498 */
ms_sensors_tp_crc4(u16 * prom)499 static u8 ms_sensors_tp_crc4(u16 *prom)
500 {
501 unsigned int cnt, n_bit;
502 u16 n_rem = 0x0000;
503
504 for (cnt = 0; cnt < MS_SENSORS_TP_PROM_WORDS_NB * 2; cnt++) {
505 if (cnt % 2 == 1)
506 n_rem ^= prom[cnt >> 1] & 0x00FF;
507 else
508 n_rem ^= prom[cnt >> 1] >> 8;
509
510 for (n_bit = 8; n_bit > 0; n_bit--) {
511 if (n_rem & 0x8000)
512 n_rem = (n_rem << 1) ^ 0x3000;
513 else
514 n_rem <<= 1;
515 }
516 }
517
518 return n_rem >> 12;
519 }
520
521 /**
522 * ms_sensors_tp_crc_valid_112() - CRC check function for
523 * Temperature and pressure devices for 112bit PROM.
524 * This function is only used when reading PROM coefficients
525 *
526 * @prom: pointer to PROM coefficients array
527 *
528 * Return: True if CRC is ok.
529 */
ms_sensors_tp_crc_valid_112(u16 * prom)530 static bool ms_sensors_tp_crc_valid_112(u16 *prom)
531 {
532 u16 w0 = prom[0], crc_read = (w0 & 0xF000) >> 12;
533 u8 crc;
534
535 prom[0] &= 0x0FFF; /* Clear the CRC computation part */
536 prom[MS_SENSORS_TP_PROM_WORDS_NB - 1] = 0;
537
538 crc = ms_sensors_tp_crc4(prom);
539
540 prom[0] = w0;
541
542 return crc == crc_read;
543 }
544
545 /**
546 * ms_sensors_tp_crc_valid_128() - CRC check function for
547 * Temperature and pressure devices for 128bit PROM.
548 * This function is only used when reading PROM coefficients
549 *
550 * @prom: pointer to PROM coefficients array
551 *
552 * Return: True if CRC is ok.
553 */
ms_sensors_tp_crc_valid_128(u16 * prom)554 static bool ms_sensors_tp_crc_valid_128(u16 *prom)
555 {
556 u16 w7 = prom[7], crc_read = w7 & 0x000F;
557 u8 crc;
558
559 prom[7] &= 0xFF00; /* Clear the CRC and LSB part */
560
561 crc = ms_sensors_tp_crc4(prom);
562
563 prom[7] = w7;
564
565 return crc == crc_read;
566 }
567
568 /**
569 * ms_sensors_tp_read_prom() - prom coeff read function
570 * @dev_data: pointer to temperature/pressure device data
571 *
572 * This function will read prom coefficients and check CRC.
573 * This function is used for MS5637 and MS8607 chipsets.
574 *
575 * Return: 0 on success, negative errno otherwise.
576 */
ms_sensors_tp_read_prom(struct ms_tp_dev * dev_data)577 int ms_sensors_tp_read_prom(struct ms_tp_dev *dev_data)
578 {
579 int i, ret;
580 bool valid;
581
582 for (i = 0; i < dev_data->hw->prom_len; i++) {
583 ret = ms_sensors_read_prom_word(
584 dev_data->client,
585 MS_SENSORS_TP_PROM_READ + (i << 1),
586 &dev_data->prom[i]);
587
588 if (ret)
589 return ret;
590 }
591
592 if (dev_data->hw->prom_len == 8)
593 valid = ms_sensors_tp_crc_valid_128(dev_data->prom);
594 else
595 valid = ms_sensors_tp_crc_valid_112(dev_data->prom);
596
597 if (!valid) {
598 dev_err(&dev_data->client->dev,
599 "Calibration coefficients crc check error\n");
600 return -ENODEV;
601 }
602
603 return 0;
604 }
605 EXPORT_SYMBOL_NS(ms_sensors_tp_read_prom, "IIO_MEAS_SPEC_SENSORS");
606
607 /**
608 * ms_sensors_read_temp_and_pressure() - read temp and pressure
609 * @dev_data: pointer to temperature/pressure device data
610 * @temperature:pointer to temperature destination value
611 * @pressure: pointer to pressure destination value
612 *
613 * This function will read ADC and compute pressure and temperature value.
614 * This function is used for MS5637 and MS8607 chipsets.
615 *
616 * Return: 0 on success, negative errno otherwise.
617 */
ms_sensors_read_temp_and_pressure(struct ms_tp_dev * dev_data,int * temperature,unsigned int * pressure)618 int ms_sensors_read_temp_and_pressure(struct ms_tp_dev *dev_data,
619 int *temperature,
620 unsigned int *pressure)
621 {
622 int ret;
623 u32 t_adc, p_adc;
624 s32 dt, temp;
625 s64 off, sens, t2, off2, sens2;
626 u16 *prom = dev_data->prom, delay;
627
628 mutex_lock(&dev_data->lock);
629 delay = ms_sensors_tp_conversion_time[dev_data->res_index];
630
631 ret = ms_sensors_convert_and_read(
632 dev_data->client,
633 MS_SENSORS_TP_T_CONVERSION_START +
634 dev_data->res_index * 2,
635 MS_SENSORS_TP_ADC_READ,
636 delay, &t_adc);
637 if (ret) {
638 mutex_unlock(&dev_data->lock);
639 return ret;
640 }
641
642 ret = ms_sensors_convert_and_read(
643 dev_data->client,
644 MS_SENSORS_TP_P_CONVERSION_START +
645 dev_data->res_index * 2,
646 MS_SENSORS_TP_ADC_READ,
647 delay, &p_adc);
648 mutex_unlock(&dev_data->lock);
649 if (ret)
650 return ret;
651
652 dt = (s32)t_adc - (prom[5] << 8);
653
654 /* Actual temperature = 2000 + dT * TEMPSENS */
655 temp = 2000 + (((s64)dt * prom[6]) >> 23);
656
657 /* Second order temperature compensation */
658 if (temp < 2000) {
659 s64 tmp = (s64)temp - 2000;
660
661 t2 = (3 * ((s64)dt * (s64)dt)) >> 33;
662 off2 = (61 * tmp * tmp) >> 4;
663 sens2 = (29 * tmp * tmp) >> 4;
664
665 if (temp < -1500) {
666 s64 tmp = (s64)temp + 1500;
667
668 off2 += 17 * tmp * tmp;
669 sens2 += 9 * tmp * tmp;
670 }
671 } else {
672 t2 = (5 * ((s64)dt * (s64)dt)) >> 38;
673 off2 = 0;
674 sens2 = 0;
675 }
676
677 /* OFF = OFF_T1 + TCO * dT */
678 off = (((s64)prom[2]) << 17) + ((((s64)prom[4]) * (s64)dt) >> 6);
679 off -= off2;
680
681 /* Sensitivity at actual temperature = SENS_T1 + TCS * dT */
682 sens = (((s64)prom[1]) << 16) + (((s64)prom[3] * dt) >> 7);
683 sens -= sens2;
684
685 /* Temperature compensated pressure = D1 * SENS - OFF */
686 *temperature = (temp - t2) * 10;
687 *pressure = (u32)(((((s64)p_adc * sens) >> 21) - off) >> 15);
688
689 return 0;
690 }
691 EXPORT_SYMBOL_NS(ms_sensors_read_temp_and_pressure, "IIO_MEAS_SPEC_SENSORS");
692
693 MODULE_DESCRIPTION("Measurement-Specialties common i2c driver");
694 MODULE_AUTHOR("William Markezana <william.markezana@meas-spec.com>");
695 MODULE_AUTHOR("Ludovic Tancerel <ludovic.tancerel@maplehightech.com>");
696 MODULE_LICENSE("GPL v2");
697
698