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 | */ |
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, value: cmd); |
53 | if (ret) { |
54 | dev_err(&client->dev, "Failed to reset device\n" ); |
55 | return ret; |
56 | } |
57 | usleep_range(min: delay, max: 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 | */ |
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, command: 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 | */ |
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, value: conv); |
113 | if (ret) |
114 | goto err; |
115 | usleep_range(min: delay, max: delay + 1000); |
116 | |
117 | /* Retrieve ADC value */ |
118 | if (rd != MS_SENSORS_NO_READ_CMD) |
119 | ret = i2c_smbus_read_i2c_block_data(client, command: rd, length: 3, values: (u8 *)&buf); |
120 | else |
121 | ret = i2c_master_recv(client, buf: (u8 *)&buf, count: 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 | */ |
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 | */ |
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(adap: client->adapter, msgs: msg, num: 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(value: (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(adap: client->adapter, msgs: msg, num: 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(value: (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 | |
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, buf: config_reg, count: 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 | */ |
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(client: dev_data->client, config_reg: &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(client: dev_data->client, |
299 | MS_SENSORS_CONFIG_REG_WRITE, |
300 | value: 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 | */ |
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(client: dev_data->client, config_reg: &config_reg); |
323 | mutex_unlock(lock: &dev_data->lock); |
324 | if (ret) |
325 | return ret; |
326 | |
327 | return sysfs_emit(buf, fmt: "%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 | */ |
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(client: dev_data->client, config_reg: &config_reg); |
350 | mutex_unlock(lock: &dev_data->lock); |
351 | if (ret) |
352 | return ret; |
353 | |
354 | return sysfs_emit(buf, fmt: "%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 | */ |
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(s: buf, base: 10, res: &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(client: dev_data->client, config_reg: &config_reg); |
385 | if (ret) { |
386 | mutex_unlock(lock: &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(client: dev_data->client, |
394 | MS_SENSORS_CONFIG_REG_WRITE, |
395 | value: config_reg); |
396 | mutex_unlock(lock: &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 | */ |
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(lock: &dev_data->lock); |
431 | if (ret) |
432 | return ret; |
433 | |
434 | if (!ms_sensors_crc_valid(value: 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 | */ |
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(lock: &dev_data->lock); |
472 | if (ret) |
473 | return ret; |
474 | |
475 | if (!ms_sensors_crc_valid(value: 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 | */ |
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 | */ |
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 | */ |
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 | */ |
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(prom: dev_data->prom); |
594 | else |
595 | valid = ms_sensors_tp_crc_valid_112(prom: 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 | */ |
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(lock: &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(lock: &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 | |