tmp513.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Driver for Texas Instruments TMP512, TMP513 power monitor chips
  4. *
  5. * TMP513:
  6. * Thermal/Power Management with Triple Remote and
  7. * Local Temperature Sensor and Current Shunt Monitor
  8. * Datasheet: https://www.ti.com/lit/gpn/tmp513
  9. *
  10. * TMP512:
  11. * Thermal/Power Management with Dual Remote
  12. * and Local Temperature Sensor and Current Shunt Monitor
  13. * Datasheet: https://www.ti.com/lit/gpn/tmp512
  14. *
  15. * Copyright (C) 2019 Eric Tremblay <[email protected]>
  16. *
  17. * This program is free software; you can redistribute it and/or modify
  18. * it under the terms of the GNU General Public License as published by
  19. * the Free Software Foundation; version 2 of the License.
  20. */
  21. #include <linux/err.h>
  22. #include <linux/hwmon.h>
  23. #include <linux/i2c.h>
  24. #include <linux/init.h>
  25. #include <linux/kernel.h>
  26. #include <linux/module.h>
  27. #include <linux/regmap.h>
  28. #include <linux/slab.h>
  29. #include <linux/util_macros.h>
  30. // Common register definition
  31. #define TMP51X_SHUNT_CONFIG 0x00
  32. #define TMP51X_TEMP_CONFIG 0x01
  33. #define TMP51X_STATUS 0x02
  34. #define TMP51X_SMBUS_ALERT 0x03
  35. #define TMP51X_SHUNT_CURRENT_RESULT 0x04
  36. #define TMP51X_BUS_VOLTAGE_RESULT 0x05
  37. #define TMP51X_POWER_RESULT 0x06
  38. #define TMP51X_BUS_CURRENT_RESULT 0x07
  39. #define TMP51X_LOCAL_TEMP_RESULT 0x08
  40. #define TMP51X_REMOTE_TEMP_RESULT_1 0x09
  41. #define TMP51X_REMOTE_TEMP_RESULT_2 0x0A
  42. #define TMP51X_SHUNT_CURRENT_H_LIMIT 0x0C
  43. #define TMP51X_SHUNT_CURRENT_L_LIMIT 0x0D
  44. #define TMP51X_BUS_VOLTAGE_H_LIMIT 0x0E
  45. #define TMP51X_BUS_VOLTAGE_L_LIMIT 0x0F
  46. #define TMP51X_POWER_LIMIT 0x10
  47. #define TMP51X_LOCAL_TEMP_LIMIT 0x11
  48. #define TMP51X_REMOTE_TEMP_LIMIT_1 0x12
  49. #define TMP51X_REMOTE_TEMP_LIMIT_2 0x13
  50. #define TMP51X_SHUNT_CALIBRATION 0x15
  51. #define TMP51X_N_FACTOR_AND_HYST_1 0x16
  52. #define TMP51X_N_FACTOR_2 0x17
  53. #define TMP51X_MAN_ID_REG 0xFE
  54. #define TMP51X_DEVICE_ID_REG 0xFF
  55. // TMP513 specific register definition
  56. #define TMP513_REMOTE_TEMP_RESULT_3 0x0B
  57. #define TMP513_REMOTE_TEMP_LIMIT_3 0x14
  58. #define TMP513_N_FACTOR_3 0x18
  59. // Common attrs, and NULL
  60. #define TMP51X_MANUFACTURER_ID 0x55FF
  61. #define TMP512_DEVICE_ID 0x22FF
  62. #define TMP513_DEVICE_ID 0x23FF
  63. // Default config
  64. #define TMP51X_SHUNT_CONFIG_DEFAULT 0x399F
  65. #define TMP51X_SHUNT_VALUE_DEFAULT 1000
  66. #define TMP51X_VBUS_RANGE_DEFAULT TMP51X_VBUS_RANGE_32V
  67. #define TMP51X_PGA_DEFAULT 8
  68. #define TMP51X_MAX_REGISTER_ADDR 0xFF
  69. #define TMP512_TEMP_CONFIG_DEFAULT 0xBF80
  70. #define TMP513_TEMP_CONFIG_DEFAULT 0xFF80
  71. // Mask and shift
  72. #define CURRENT_SENSE_VOLTAGE_320_MASK 0x1800
  73. #define CURRENT_SENSE_VOLTAGE_160_MASK 0x1000
  74. #define CURRENT_SENSE_VOLTAGE_80_MASK 0x0800
  75. #define CURRENT_SENSE_VOLTAGE_40_MASK 0
  76. #define TMP51X_BUS_VOLTAGE_MASK 0x2000
  77. #define TMP51X_NFACTOR_MASK 0xFF00
  78. #define TMP51X_HYST_MASK 0x00FF
  79. #define TMP51X_BUS_VOLTAGE_SHIFT 3
  80. #define TMP51X_TEMP_SHIFT 3
  81. // Alarms
  82. #define TMP51X_SHUNT_CURRENT_H_LIMIT_POS 15
  83. #define TMP51X_SHUNT_CURRENT_L_LIMIT_POS 14
  84. #define TMP51X_BUS_VOLTAGE_H_LIMIT_POS 13
  85. #define TMP51X_BUS_VOLTAGE_L_LIMIT_POS 12
  86. #define TMP51X_POWER_LIMIT_POS 11
  87. #define TMP51X_LOCAL_TEMP_LIMIT_POS 10
  88. #define TMP51X_REMOTE_TEMP_LIMIT_1_POS 9
  89. #define TMP51X_REMOTE_TEMP_LIMIT_2_POS 8
  90. #define TMP513_REMOTE_TEMP_LIMIT_3_POS 7
  91. #define TMP51X_VBUS_RANGE_32V 32000000
  92. #define TMP51X_VBUS_RANGE_16V 16000000
  93. // Max and Min value
  94. #define MAX_BUS_VOLTAGE_32_LIMIT 32764
  95. #define MAX_BUS_VOLTAGE_16_LIMIT 16382
  96. // Max possible value is -256 to +256 but datasheet indicated -40 to 125.
  97. #define MAX_TEMP_LIMIT 125000
  98. #define MIN_TEMP_LIMIT -40000
  99. #define MAX_TEMP_HYST 127500
  100. static const u8 TMP51X_TEMP_INPUT[4] = {
  101. TMP51X_LOCAL_TEMP_RESULT,
  102. TMP51X_REMOTE_TEMP_RESULT_1,
  103. TMP51X_REMOTE_TEMP_RESULT_2,
  104. TMP513_REMOTE_TEMP_RESULT_3
  105. };
  106. static const u8 TMP51X_TEMP_CRIT[4] = {
  107. TMP51X_LOCAL_TEMP_LIMIT,
  108. TMP51X_REMOTE_TEMP_LIMIT_1,
  109. TMP51X_REMOTE_TEMP_LIMIT_2,
  110. TMP513_REMOTE_TEMP_LIMIT_3
  111. };
  112. static const u8 TMP51X_TEMP_CRIT_ALARM[4] = {
  113. TMP51X_LOCAL_TEMP_LIMIT_POS,
  114. TMP51X_REMOTE_TEMP_LIMIT_1_POS,
  115. TMP51X_REMOTE_TEMP_LIMIT_2_POS,
  116. TMP513_REMOTE_TEMP_LIMIT_3_POS
  117. };
  118. static const u8 TMP51X_TEMP_CRIT_HYST[4] = {
  119. TMP51X_N_FACTOR_AND_HYST_1,
  120. TMP51X_N_FACTOR_AND_HYST_1,
  121. TMP51X_N_FACTOR_AND_HYST_1,
  122. TMP51X_N_FACTOR_AND_HYST_1
  123. };
  124. static const u8 TMP51X_CURR_INPUT[2] = {
  125. TMP51X_SHUNT_CURRENT_RESULT,
  126. TMP51X_BUS_CURRENT_RESULT
  127. };
  128. static struct regmap_config tmp51x_regmap_config = {
  129. .reg_bits = 8,
  130. .val_bits = 16,
  131. .max_register = TMP51X_MAX_REGISTER_ADDR,
  132. };
  133. enum tmp51x_ids {
  134. tmp512, tmp513
  135. };
  136. struct tmp51x_data {
  137. u16 shunt_config;
  138. u16 pga_gain;
  139. u32 vbus_range_uvolt;
  140. u16 temp_config;
  141. u32 nfactor[3];
  142. u32 shunt_uohms;
  143. u32 curr_lsb_ua;
  144. u32 pwr_lsb_uw;
  145. enum tmp51x_ids id;
  146. struct regmap *regmap;
  147. };
  148. // Set the shift based on the gain 8=4, 4=3, 2=2, 1=1
  149. static inline u8 tmp51x_get_pga_shift(struct tmp51x_data *data)
  150. {
  151. return 5 - ffs(data->pga_gain);
  152. }
  153. static int tmp51x_get_value(struct tmp51x_data *data, u8 reg, u8 pos,
  154. unsigned int regval, long *val)
  155. {
  156. switch (reg) {
  157. case TMP51X_STATUS:
  158. *val = (regval >> pos) & 1;
  159. break;
  160. case TMP51X_SHUNT_CURRENT_RESULT:
  161. case TMP51X_SHUNT_CURRENT_H_LIMIT:
  162. case TMP51X_SHUNT_CURRENT_L_LIMIT:
  163. /*
  164. * The valus is read in voltage in the chip but reported as
  165. * current to the user.
  166. * 2's complement number shifted by one to four depending
  167. * on the pga gain setting. 1lsb = 10uV
  168. */
  169. *val = sign_extend32(regval, 17 - tmp51x_get_pga_shift(data));
  170. *val = DIV_ROUND_CLOSEST(*val * 10000, data->shunt_uohms);
  171. break;
  172. case TMP51X_BUS_VOLTAGE_RESULT:
  173. case TMP51X_BUS_VOLTAGE_H_LIMIT:
  174. case TMP51X_BUS_VOLTAGE_L_LIMIT:
  175. // 1lsb = 4mV
  176. *val = (regval >> TMP51X_BUS_VOLTAGE_SHIFT) * 4;
  177. break;
  178. case TMP51X_POWER_RESULT:
  179. case TMP51X_POWER_LIMIT:
  180. // Power = (current * BusVoltage) / 5000
  181. *val = regval * data->pwr_lsb_uw;
  182. break;
  183. case TMP51X_BUS_CURRENT_RESULT:
  184. // Current = (ShuntVoltage * CalibrationRegister) / 4096
  185. *val = sign_extend32(regval, 16) * data->curr_lsb_ua;
  186. *val = DIV_ROUND_CLOSEST(*val, 1000);
  187. break;
  188. case TMP51X_LOCAL_TEMP_RESULT:
  189. case TMP51X_REMOTE_TEMP_RESULT_1:
  190. case TMP51X_REMOTE_TEMP_RESULT_2:
  191. case TMP513_REMOTE_TEMP_RESULT_3:
  192. case TMP51X_LOCAL_TEMP_LIMIT:
  193. case TMP51X_REMOTE_TEMP_LIMIT_1:
  194. case TMP51X_REMOTE_TEMP_LIMIT_2:
  195. case TMP513_REMOTE_TEMP_LIMIT_3:
  196. // 1lsb = 0.0625 degrees centigrade
  197. *val = sign_extend32(regval, 16) >> TMP51X_TEMP_SHIFT;
  198. *val = DIV_ROUND_CLOSEST(*val * 625, 10);
  199. break;
  200. case TMP51X_N_FACTOR_AND_HYST_1:
  201. // 1lsb = 0.5 degrees centigrade
  202. *val = (regval & TMP51X_HYST_MASK) * 500;
  203. break;
  204. default:
  205. // Programmer goofed
  206. WARN_ON_ONCE(1);
  207. *val = 0;
  208. return -EOPNOTSUPP;
  209. }
  210. return 0;
  211. }
  212. static int tmp51x_set_value(struct tmp51x_data *data, u8 reg, long val)
  213. {
  214. int regval, max_val;
  215. u32 mask = 0;
  216. switch (reg) {
  217. case TMP51X_SHUNT_CURRENT_H_LIMIT:
  218. case TMP51X_SHUNT_CURRENT_L_LIMIT:
  219. /*
  220. * The user enter current value and we convert it to
  221. * voltage. 1lsb = 10uV
  222. */
  223. val = DIV_ROUND_CLOSEST(val * data->shunt_uohms, 10000);
  224. max_val = U16_MAX >> tmp51x_get_pga_shift(data);
  225. regval = clamp_val(val, -max_val, max_val);
  226. break;
  227. case TMP51X_BUS_VOLTAGE_H_LIMIT:
  228. case TMP51X_BUS_VOLTAGE_L_LIMIT:
  229. // 1lsb = 4mV
  230. max_val = (data->vbus_range_uvolt == TMP51X_VBUS_RANGE_32V) ?
  231. MAX_BUS_VOLTAGE_32_LIMIT : MAX_BUS_VOLTAGE_16_LIMIT;
  232. val = clamp_val(DIV_ROUND_CLOSEST(val, 4), 0, max_val);
  233. regval = val << TMP51X_BUS_VOLTAGE_SHIFT;
  234. break;
  235. case TMP51X_POWER_LIMIT:
  236. regval = clamp_val(DIV_ROUND_CLOSEST(val, data->pwr_lsb_uw), 0,
  237. U16_MAX);
  238. break;
  239. case TMP51X_LOCAL_TEMP_LIMIT:
  240. case TMP51X_REMOTE_TEMP_LIMIT_1:
  241. case TMP51X_REMOTE_TEMP_LIMIT_2:
  242. case TMP513_REMOTE_TEMP_LIMIT_3:
  243. // 1lsb = 0.0625 degrees centigrade
  244. val = clamp_val(val, MIN_TEMP_LIMIT, MAX_TEMP_LIMIT);
  245. regval = DIV_ROUND_CLOSEST(val * 10, 625) << TMP51X_TEMP_SHIFT;
  246. break;
  247. case TMP51X_N_FACTOR_AND_HYST_1:
  248. // 1lsb = 0.5 degrees centigrade
  249. val = clamp_val(val, 0, MAX_TEMP_HYST);
  250. regval = DIV_ROUND_CLOSEST(val, 500);
  251. mask = TMP51X_HYST_MASK;
  252. break;
  253. default:
  254. // Programmer goofed
  255. WARN_ON_ONCE(1);
  256. return -EOPNOTSUPP;
  257. }
  258. if (mask == 0)
  259. return regmap_write(data->regmap, reg, regval);
  260. else
  261. return regmap_update_bits(data->regmap, reg, mask, regval);
  262. }
  263. static u8 tmp51x_get_reg(enum hwmon_sensor_types type, u32 attr, int channel)
  264. {
  265. switch (type) {
  266. case hwmon_temp:
  267. switch (attr) {
  268. case hwmon_temp_input:
  269. return TMP51X_TEMP_INPUT[channel];
  270. case hwmon_temp_crit_alarm:
  271. return TMP51X_STATUS;
  272. case hwmon_temp_crit:
  273. return TMP51X_TEMP_CRIT[channel];
  274. case hwmon_temp_crit_hyst:
  275. return TMP51X_TEMP_CRIT_HYST[channel];
  276. }
  277. break;
  278. case hwmon_in:
  279. switch (attr) {
  280. case hwmon_in_input:
  281. return TMP51X_BUS_VOLTAGE_RESULT;
  282. case hwmon_in_lcrit_alarm:
  283. case hwmon_in_crit_alarm:
  284. return TMP51X_STATUS;
  285. case hwmon_in_lcrit:
  286. return TMP51X_BUS_VOLTAGE_L_LIMIT;
  287. case hwmon_in_crit:
  288. return TMP51X_BUS_VOLTAGE_H_LIMIT;
  289. }
  290. break;
  291. case hwmon_curr:
  292. switch (attr) {
  293. case hwmon_curr_input:
  294. return TMP51X_CURR_INPUT[channel];
  295. case hwmon_curr_lcrit_alarm:
  296. case hwmon_curr_crit_alarm:
  297. return TMP51X_STATUS;
  298. case hwmon_curr_lcrit:
  299. return TMP51X_SHUNT_CURRENT_L_LIMIT;
  300. case hwmon_curr_crit:
  301. return TMP51X_SHUNT_CURRENT_H_LIMIT;
  302. }
  303. break;
  304. case hwmon_power:
  305. switch (attr) {
  306. case hwmon_power_input:
  307. return TMP51X_POWER_RESULT;
  308. case hwmon_power_crit_alarm:
  309. return TMP51X_STATUS;
  310. case hwmon_power_crit:
  311. return TMP51X_POWER_LIMIT;
  312. }
  313. break;
  314. default:
  315. break;
  316. }
  317. return 0;
  318. }
  319. static u8 tmp51x_get_status_pos(enum hwmon_sensor_types type, u32 attr,
  320. int channel)
  321. {
  322. switch (type) {
  323. case hwmon_temp:
  324. switch (attr) {
  325. case hwmon_temp_crit_alarm:
  326. return TMP51X_TEMP_CRIT_ALARM[channel];
  327. }
  328. break;
  329. case hwmon_in:
  330. switch (attr) {
  331. case hwmon_in_lcrit_alarm:
  332. return TMP51X_BUS_VOLTAGE_L_LIMIT_POS;
  333. case hwmon_in_crit_alarm:
  334. return TMP51X_BUS_VOLTAGE_H_LIMIT_POS;
  335. }
  336. break;
  337. case hwmon_curr:
  338. switch (attr) {
  339. case hwmon_curr_lcrit_alarm:
  340. return TMP51X_SHUNT_CURRENT_L_LIMIT_POS;
  341. case hwmon_curr_crit_alarm:
  342. return TMP51X_SHUNT_CURRENT_H_LIMIT_POS;
  343. }
  344. break;
  345. case hwmon_power:
  346. switch (attr) {
  347. case hwmon_power_crit_alarm:
  348. return TMP51X_POWER_LIMIT_POS;
  349. }
  350. break;
  351. default:
  352. break;
  353. }
  354. return 0;
  355. }
  356. static int tmp51x_read(struct device *dev, enum hwmon_sensor_types type,
  357. u32 attr, int channel, long *val)
  358. {
  359. struct tmp51x_data *data = dev_get_drvdata(dev);
  360. int ret;
  361. u32 regval;
  362. u8 pos = 0, reg = 0;
  363. reg = tmp51x_get_reg(type, attr, channel);
  364. if (reg == 0)
  365. return -EOPNOTSUPP;
  366. if (reg == TMP51X_STATUS)
  367. pos = tmp51x_get_status_pos(type, attr, channel);
  368. ret = regmap_read(data->regmap, reg, &regval);
  369. if (ret < 0)
  370. return ret;
  371. return tmp51x_get_value(data, reg, pos, regval, val);
  372. }
  373. static int tmp51x_write(struct device *dev, enum hwmon_sensor_types type,
  374. u32 attr, int channel, long val)
  375. {
  376. u8 reg = 0;
  377. reg = tmp51x_get_reg(type, attr, channel);
  378. if (reg == 0)
  379. return -EOPNOTSUPP;
  380. return tmp51x_set_value(dev_get_drvdata(dev), reg, val);
  381. }
  382. static umode_t tmp51x_is_visible(const void *_data,
  383. enum hwmon_sensor_types type, u32 attr,
  384. int channel)
  385. {
  386. const struct tmp51x_data *data = _data;
  387. switch (type) {
  388. case hwmon_temp:
  389. if (data->id == tmp512 && channel == 3)
  390. return 0;
  391. switch (attr) {
  392. case hwmon_temp_input:
  393. case hwmon_temp_crit_alarm:
  394. return 0444;
  395. case hwmon_temp_crit:
  396. return 0644;
  397. case hwmon_temp_crit_hyst:
  398. if (channel == 0)
  399. return 0644;
  400. return 0444;
  401. }
  402. break;
  403. case hwmon_in:
  404. switch (attr) {
  405. case hwmon_in_input:
  406. case hwmon_in_lcrit_alarm:
  407. case hwmon_in_crit_alarm:
  408. return 0444;
  409. case hwmon_in_lcrit:
  410. case hwmon_in_crit:
  411. return 0644;
  412. }
  413. break;
  414. case hwmon_curr:
  415. if (!data->shunt_uohms)
  416. return 0;
  417. switch (attr) {
  418. case hwmon_curr_input:
  419. case hwmon_curr_lcrit_alarm:
  420. case hwmon_curr_crit_alarm:
  421. return 0444;
  422. case hwmon_curr_lcrit:
  423. case hwmon_curr_crit:
  424. return 0644;
  425. }
  426. break;
  427. case hwmon_power:
  428. if (!data->shunt_uohms)
  429. return 0;
  430. switch (attr) {
  431. case hwmon_power_input:
  432. case hwmon_power_crit_alarm:
  433. return 0444;
  434. case hwmon_power_crit:
  435. return 0644;
  436. }
  437. break;
  438. default:
  439. break;
  440. }
  441. return 0;
  442. }
  443. static const struct hwmon_channel_info *tmp51x_info[] = {
  444. HWMON_CHANNEL_INFO(temp,
  445. HWMON_T_INPUT | HWMON_T_CRIT | HWMON_T_CRIT_ALARM |
  446. HWMON_T_CRIT_HYST,
  447. HWMON_T_INPUT | HWMON_T_CRIT | HWMON_T_CRIT_ALARM |
  448. HWMON_T_CRIT_HYST,
  449. HWMON_T_INPUT | HWMON_T_CRIT | HWMON_T_CRIT_ALARM |
  450. HWMON_T_CRIT_HYST,
  451. HWMON_T_INPUT | HWMON_T_CRIT | HWMON_T_CRIT_ALARM |
  452. HWMON_T_CRIT_HYST),
  453. HWMON_CHANNEL_INFO(in,
  454. HWMON_I_INPUT | HWMON_I_LCRIT | HWMON_I_LCRIT_ALARM |
  455. HWMON_I_CRIT | HWMON_I_CRIT_ALARM),
  456. HWMON_CHANNEL_INFO(curr,
  457. HWMON_C_INPUT | HWMON_C_LCRIT | HWMON_C_LCRIT_ALARM |
  458. HWMON_C_CRIT | HWMON_C_CRIT_ALARM,
  459. HWMON_C_INPUT),
  460. HWMON_CHANNEL_INFO(power,
  461. HWMON_P_INPUT | HWMON_P_CRIT | HWMON_P_CRIT_ALARM),
  462. NULL
  463. };
  464. static const struct hwmon_ops tmp51x_hwmon_ops = {
  465. .is_visible = tmp51x_is_visible,
  466. .read = tmp51x_read,
  467. .write = tmp51x_write,
  468. };
  469. static const struct hwmon_chip_info tmp51x_chip_info = {
  470. .ops = &tmp51x_hwmon_ops,
  471. .info = tmp51x_info,
  472. };
  473. /*
  474. * Calibrate the tmp51x following the datasheet method
  475. */
  476. static int tmp51x_calibrate(struct tmp51x_data *data)
  477. {
  478. int vshunt_max = data->pga_gain * 40;
  479. u64 max_curr_ma;
  480. u32 div;
  481. /*
  482. * If shunt_uohms is equal to 0, the calibration should be set to 0.
  483. * The consequence will be that the current and power measurement engine
  484. * of the sensor will not work. Temperature and voltage sensing will
  485. * continue to work.
  486. */
  487. if (data->shunt_uohms == 0)
  488. return regmap_write(data->regmap, TMP51X_SHUNT_CALIBRATION, 0);
  489. max_curr_ma = DIV_ROUND_CLOSEST_ULL(vshunt_max * 1000 * 1000,
  490. data->shunt_uohms);
  491. /*
  492. * Calculate the minimal bit resolution for the current and the power.
  493. * Those values will be used during register interpretation.
  494. */
  495. data->curr_lsb_ua = DIV_ROUND_CLOSEST_ULL(max_curr_ma * 1000, 32767);
  496. data->pwr_lsb_uw = 20 * data->curr_lsb_ua;
  497. div = DIV_ROUND_CLOSEST_ULL(data->curr_lsb_ua * data->shunt_uohms,
  498. 1000 * 1000);
  499. return regmap_write(data->regmap, TMP51X_SHUNT_CALIBRATION,
  500. DIV_ROUND_CLOSEST(40960, div));
  501. }
  502. /*
  503. * Initialize the configuration and calibration registers.
  504. */
  505. static int tmp51x_init(struct tmp51x_data *data)
  506. {
  507. unsigned int regval;
  508. int ret = regmap_write(data->regmap, TMP51X_SHUNT_CONFIG,
  509. data->shunt_config);
  510. if (ret < 0)
  511. return ret;
  512. ret = regmap_write(data->regmap, TMP51X_TEMP_CONFIG, data->temp_config);
  513. if (ret < 0)
  514. return ret;
  515. // nFactor configuration
  516. ret = regmap_update_bits(data->regmap, TMP51X_N_FACTOR_AND_HYST_1,
  517. TMP51X_NFACTOR_MASK, data->nfactor[0] << 8);
  518. if (ret < 0)
  519. return ret;
  520. ret = regmap_write(data->regmap, TMP51X_N_FACTOR_2,
  521. data->nfactor[1] << 8);
  522. if (ret < 0)
  523. return ret;
  524. if (data->id == tmp513) {
  525. ret = regmap_write(data->regmap, TMP513_N_FACTOR_3,
  526. data->nfactor[2] << 8);
  527. if (ret < 0)
  528. return ret;
  529. }
  530. ret = tmp51x_calibrate(data);
  531. if (ret < 0)
  532. return ret;
  533. // Read the status register before using as the datasheet propose
  534. return regmap_read(data->regmap, TMP51X_STATUS, &regval);
  535. }
  536. static const struct i2c_device_id tmp51x_id[] = {
  537. { "tmp512", tmp512 },
  538. { "tmp513", tmp513 },
  539. { }
  540. };
  541. MODULE_DEVICE_TABLE(i2c, tmp51x_id);
  542. static const struct of_device_id tmp51x_of_match[] = {
  543. {
  544. .compatible = "ti,tmp512",
  545. .data = (void *)tmp512
  546. },
  547. {
  548. .compatible = "ti,tmp513",
  549. .data = (void *)tmp513
  550. },
  551. { },
  552. };
  553. MODULE_DEVICE_TABLE(of, tmp51x_of_match);
  554. static int tmp51x_vbus_range_to_reg(struct device *dev,
  555. struct tmp51x_data *data)
  556. {
  557. if (data->vbus_range_uvolt == TMP51X_VBUS_RANGE_32V) {
  558. data->shunt_config |= TMP51X_BUS_VOLTAGE_MASK;
  559. } else if (data->vbus_range_uvolt == TMP51X_VBUS_RANGE_16V) {
  560. data->shunt_config &= ~TMP51X_BUS_VOLTAGE_MASK;
  561. } else {
  562. dev_err(dev, "ti,bus-range-microvolt is invalid: %u\n",
  563. data->vbus_range_uvolt);
  564. return -EINVAL;
  565. }
  566. return 0;
  567. }
  568. static int tmp51x_pga_gain_to_reg(struct device *dev, struct tmp51x_data *data)
  569. {
  570. if (data->pga_gain == 8) {
  571. data->shunt_config |= CURRENT_SENSE_VOLTAGE_320_MASK;
  572. } else if (data->pga_gain == 4) {
  573. data->shunt_config |= CURRENT_SENSE_VOLTAGE_160_MASK;
  574. } else if (data->pga_gain == 2) {
  575. data->shunt_config |= CURRENT_SENSE_VOLTAGE_80_MASK;
  576. } else if (data->pga_gain == 1) {
  577. data->shunt_config |= CURRENT_SENSE_VOLTAGE_40_MASK;
  578. } else {
  579. dev_err(dev, "ti,pga-gain is invalid: %u\n", data->pga_gain);
  580. return -EINVAL;
  581. }
  582. return 0;
  583. }
  584. static int tmp51x_read_properties(struct device *dev, struct tmp51x_data *data)
  585. {
  586. int ret;
  587. u32 nfactor[3];
  588. u32 val;
  589. ret = device_property_read_u32(dev, "shunt-resistor-micro-ohms", &val);
  590. data->shunt_uohms = (ret >= 0) ? val : TMP51X_SHUNT_VALUE_DEFAULT;
  591. ret = device_property_read_u32(dev, "ti,bus-range-microvolt", &val);
  592. data->vbus_range_uvolt = (ret >= 0) ? val : TMP51X_VBUS_RANGE_DEFAULT;
  593. ret = tmp51x_vbus_range_to_reg(dev, data);
  594. if (ret < 0)
  595. return ret;
  596. ret = device_property_read_u32(dev, "ti,pga-gain", &val);
  597. data->pga_gain = (ret >= 0) ? val : TMP51X_PGA_DEFAULT;
  598. ret = tmp51x_pga_gain_to_reg(dev, data);
  599. if (ret < 0)
  600. return ret;
  601. ret = device_property_read_u32_array(dev, "ti,nfactor", nfactor,
  602. (data->id == tmp513) ? 3 : 2);
  603. if (ret >= 0)
  604. memcpy(data->nfactor, nfactor, (data->id == tmp513) ? 3 : 2);
  605. // Check if shunt value is compatible with pga-gain
  606. if (data->shunt_uohms > data->pga_gain * 40 * 1000 * 1000) {
  607. dev_err(dev, "shunt-resistor: %u too big for pga_gain: %u\n",
  608. data->shunt_uohms, data->pga_gain);
  609. return -EINVAL;
  610. }
  611. return 0;
  612. }
  613. static void tmp51x_use_default(struct tmp51x_data *data)
  614. {
  615. data->vbus_range_uvolt = TMP51X_VBUS_RANGE_DEFAULT;
  616. data->pga_gain = TMP51X_PGA_DEFAULT;
  617. data->shunt_uohms = TMP51X_SHUNT_VALUE_DEFAULT;
  618. }
  619. static int tmp51x_configure(struct device *dev, struct tmp51x_data *data)
  620. {
  621. data->shunt_config = TMP51X_SHUNT_CONFIG_DEFAULT;
  622. data->temp_config = (data->id == tmp513) ?
  623. TMP513_TEMP_CONFIG_DEFAULT : TMP512_TEMP_CONFIG_DEFAULT;
  624. if (dev->of_node)
  625. return tmp51x_read_properties(dev, data);
  626. tmp51x_use_default(data);
  627. return 0;
  628. }
  629. static int tmp51x_probe(struct i2c_client *client)
  630. {
  631. struct device *dev = &client->dev;
  632. struct tmp51x_data *data;
  633. struct device *hwmon_dev;
  634. int ret;
  635. data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
  636. if (!data)
  637. return -ENOMEM;
  638. if (client->dev.of_node)
  639. data->id = (enum tmp51x_ids)device_get_match_data(&client->dev);
  640. else
  641. data->id = i2c_match_id(tmp51x_id, client)->driver_data;
  642. ret = tmp51x_configure(dev, data);
  643. if (ret < 0) {
  644. dev_err(dev, "error configuring the device: %d\n", ret);
  645. return ret;
  646. }
  647. data->regmap = devm_regmap_init_i2c(client, &tmp51x_regmap_config);
  648. if (IS_ERR(data->regmap)) {
  649. dev_err(dev, "failed to allocate register map\n");
  650. return PTR_ERR(data->regmap);
  651. }
  652. ret = tmp51x_init(data);
  653. if (ret < 0) {
  654. dev_err(dev, "error configuring the device: %d\n", ret);
  655. return -ENODEV;
  656. }
  657. hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
  658. data,
  659. &tmp51x_chip_info,
  660. NULL);
  661. if (IS_ERR(hwmon_dev))
  662. return PTR_ERR(hwmon_dev);
  663. dev_dbg(dev, "power monitor %s\n", client->name);
  664. return 0;
  665. }
  666. static struct i2c_driver tmp51x_driver = {
  667. .driver = {
  668. .name = "tmp51x",
  669. .of_match_table = tmp51x_of_match,
  670. },
  671. .probe_new = tmp51x_probe,
  672. .id_table = tmp51x_id,
  673. };
  674. module_i2c_driver(tmp51x_driver);
  675. MODULE_AUTHOR("Eric Tremblay <[email protected]>");
  676. MODULE_DESCRIPTION("tmp51x driver");
  677. MODULE_LICENSE("GPL");