max127.c 7.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Hardware monitoring driver for MAX127.
  4. *
  5. * Copyright (c) 2020 Facebook Inc.
  6. */
  7. #include <linux/err.h>
  8. #include <linux/hwmon.h>
  9. #include <linux/i2c.h>
  10. #include <linux/init.h>
  11. #include <linux/module.h>
  12. /*
  13. * MAX127 Control Byte. Refer to MAX127 datasheet, Table 1 "Control-Byte
  14. * Format" for details.
  15. */
  16. #define MAX127_CTRL_START BIT(7)
  17. #define MAX127_CTRL_SEL_SHIFT 4
  18. #define MAX127_CTRL_RNG BIT(3)
  19. #define MAX127_CTRL_BIP BIT(2)
  20. #define MAX127_CTRL_PD1 BIT(1)
  21. #define MAX127_CTRL_PD0 BIT(0)
  22. #define MAX127_NUM_CHANNELS 8
  23. #define MAX127_SET_CHANNEL(ch) (((ch) & 7) << MAX127_CTRL_SEL_SHIFT)
  24. /*
  25. * MAX127 channel input ranges. Refer to MAX127 datasheet, Table 3 "Range
  26. * and Polarity Selection" for details.
  27. */
  28. #define MAX127_FULL_RANGE 10000 /* 10V */
  29. #define MAX127_HALF_RANGE 5000 /* 5V */
  30. /*
  31. * MAX127 returns 2 bytes at read:
  32. * - the first byte contains data[11:4].
  33. * - the second byte contains data[3:0] (MSB) and 4 dummy 0s (LSB).
  34. * Refer to MAX127 datasheet, "Read a Conversion (Read Cycle)" section
  35. * for details.
  36. */
  37. #define MAX127_DATA_LEN 2
  38. #define MAX127_DATA_SHIFT 4
  39. #define MAX127_SIGN_BIT BIT(11)
  40. struct max127_data {
  41. struct mutex lock;
  42. struct i2c_client *client;
  43. u8 ctrl_byte[MAX127_NUM_CHANNELS];
  44. };
  45. static int max127_select_channel(struct i2c_client *client, u8 ctrl_byte)
  46. {
  47. int status;
  48. struct i2c_msg msg = {
  49. .addr = client->addr,
  50. .flags = 0,
  51. .len = sizeof(ctrl_byte),
  52. .buf = &ctrl_byte,
  53. };
  54. status = i2c_transfer(client->adapter, &msg, 1);
  55. if (status < 0)
  56. return status;
  57. if (status != 1)
  58. return -EIO;
  59. return 0;
  60. }
  61. static int max127_read_channel(struct i2c_client *client, long *val)
  62. {
  63. int status;
  64. u8 i2c_data[MAX127_DATA_LEN];
  65. struct i2c_msg msg = {
  66. .addr = client->addr,
  67. .flags = I2C_M_RD,
  68. .len = sizeof(i2c_data),
  69. .buf = i2c_data,
  70. };
  71. status = i2c_transfer(client->adapter, &msg, 1);
  72. if (status < 0)
  73. return status;
  74. if (status != 1)
  75. return -EIO;
  76. *val = (i2c_data[1] >> MAX127_DATA_SHIFT) |
  77. ((u16)i2c_data[0] << MAX127_DATA_SHIFT);
  78. return 0;
  79. }
  80. static long max127_process_raw(u8 ctrl_byte, long raw)
  81. {
  82. long scale, weight;
  83. /*
  84. * MAX127's data coding is binary in unipolar mode with 1 LSB =
  85. * (Full-Scale/4096) and two’s complement binary in bipolar mode
  86. * with 1 LSB = [(2 x |FS|)/4096].
  87. * Refer to MAX127 datasheet, "Transfer Function" section for
  88. * details.
  89. */
  90. scale = (ctrl_byte & MAX127_CTRL_RNG) ? MAX127_FULL_RANGE :
  91. MAX127_HALF_RANGE;
  92. if (ctrl_byte & MAX127_CTRL_BIP) {
  93. weight = (raw & MAX127_SIGN_BIT);
  94. raw &= ~MAX127_SIGN_BIT;
  95. raw -= weight;
  96. raw *= 2;
  97. }
  98. return raw * scale / 4096;
  99. }
  100. static int max127_read_input(struct max127_data *data, int channel, long *val)
  101. {
  102. long raw;
  103. int status;
  104. struct i2c_client *client = data->client;
  105. u8 ctrl_byte = data->ctrl_byte[channel];
  106. mutex_lock(&data->lock);
  107. status = max127_select_channel(client, ctrl_byte);
  108. if (status)
  109. goto exit;
  110. status = max127_read_channel(client, &raw);
  111. if (status)
  112. goto exit;
  113. *val = max127_process_raw(ctrl_byte, raw);
  114. exit:
  115. mutex_unlock(&data->lock);
  116. return status;
  117. }
  118. static int max127_read_min(struct max127_data *data, int channel, long *val)
  119. {
  120. u8 rng_bip = (data->ctrl_byte[channel] >> 2) & 3;
  121. static const int min_input_map[4] = {
  122. 0, /* RNG=0, BIP=0 */
  123. -MAX127_HALF_RANGE, /* RNG=0, BIP=1 */
  124. 0, /* RNG=1, BIP=0 */
  125. -MAX127_FULL_RANGE, /* RNG=1, BIP=1 */
  126. };
  127. *val = min_input_map[rng_bip];
  128. return 0;
  129. }
  130. static int max127_read_max(struct max127_data *data, int channel, long *val)
  131. {
  132. u8 rng_bip = (data->ctrl_byte[channel] >> 2) & 3;
  133. static const int max_input_map[4] = {
  134. MAX127_HALF_RANGE, /* RNG=0, BIP=0 */
  135. MAX127_HALF_RANGE, /* RNG=0, BIP=1 */
  136. MAX127_FULL_RANGE, /* RNG=1, BIP=0 */
  137. MAX127_FULL_RANGE, /* RNG=1, BIP=1 */
  138. };
  139. *val = max_input_map[rng_bip];
  140. return 0;
  141. }
  142. static int max127_write_min(struct max127_data *data, int channel, long val)
  143. {
  144. u8 ctrl;
  145. mutex_lock(&data->lock);
  146. ctrl = data->ctrl_byte[channel];
  147. if (val <= -MAX127_FULL_RANGE) {
  148. ctrl |= (MAX127_CTRL_RNG | MAX127_CTRL_BIP);
  149. } else if (val < 0) {
  150. ctrl |= MAX127_CTRL_BIP;
  151. ctrl &= ~MAX127_CTRL_RNG;
  152. } else {
  153. ctrl &= ~MAX127_CTRL_BIP;
  154. }
  155. data->ctrl_byte[channel] = ctrl;
  156. mutex_unlock(&data->lock);
  157. return 0;
  158. }
  159. static int max127_write_max(struct max127_data *data, int channel, long val)
  160. {
  161. mutex_lock(&data->lock);
  162. if (val >= MAX127_FULL_RANGE)
  163. data->ctrl_byte[channel] |= MAX127_CTRL_RNG;
  164. else
  165. data->ctrl_byte[channel] &= ~MAX127_CTRL_RNG;
  166. mutex_unlock(&data->lock);
  167. return 0;
  168. }
  169. static umode_t max127_is_visible(const void *_data,
  170. enum hwmon_sensor_types type,
  171. u32 attr, int channel)
  172. {
  173. if (type == hwmon_in) {
  174. switch (attr) {
  175. case hwmon_in_input:
  176. return 0444;
  177. case hwmon_in_min:
  178. case hwmon_in_max:
  179. return 0644;
  180. default:
  181. break;
  182. }
  183. }
  184. return 0;
  185. }
  186. static int max127_read(struct device *dev, enum hwmon_sensor_types type,
  187. u32 attr, int channel, long *val)
  188. {
  189. int status;
  190. struct max127_data *data = dev_get_drvdata(dev);
  191. if (type != hwmon_in)
  192. return -EOPNOTSUPP;
  193. switch (attr) {
  194. case hwmon_in_input:
  195. status = max127_read_input(data, channel, val);
  196. break;
  197. case hwmon_in_min:
  198. status = max127_read_min(data, channel, val);
  199. break;
  200. case hwmon_in_max:
  201. status = max127_read_max(data, channel, val);
  202. break;
  203. default:
  204. status = -EOPNOTSUPP;
  205. break;
  206. }
  207. return status;
  208. }
  209. static int max127_write(struct device *dev, enum hwmon_sensor_types type,
  210. u32 attr, int channel, long val)
  211. {
  212. int status;
  213. struct max127_data *data = dev_get_drvdata(dev);
  214. if (type != hwmon_in)
  215. return -EOPNOTSUPP;
  216. switch (attr) {
  217. case hwmon_in_min:
  218. status = max127_write_min(data, channel, val);
  219. break;
  220. case hwmon_in_max:
  221. status = max127_write_max(data, channel, val);
  222. break;
  223. default:
  224. status = -EOPNOTSUPP;
  225. break;
  226. }
  227. return status;
  228. }
  229. static const struct hwmon_ops max127_hwmon_ops = {
  230. .is_visible = max127_is_visible,
  231. .read = max127_read,
  232. .write = max127_write,
  233. };
  234. static const struct hwmon_channel_info *max127_info[] = {
  235. HWMON_CHANNEL_INFO(in,
  236. HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX,
  237. HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX,
  238. HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX,
  239. HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX,
  240. HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX,
  241. HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX,
  242. HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX,
  243. HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX),
  244. NULL,
  245. };
  246. static const struct hwmon_chip_info max127_chip_info = {
  247. .ops = &max127_hwmon_ops,
  248. .info = max127_info,
  249. };
  250. static int max127_probe(struct i2c_client *client,
  251. const struct i2c_device_id *id)
  252. {
  253. int i;
  254. struct device *hwmon_dev;
  255. struct max127_data *data;
  256. struct device *dev = &client->dev;
  257. data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
  258. if (!data)
  259. return -ENOMEM;
  260. data->client = client;
  261. mutex_init(&data->lock);
  262. for (i = 0; i < ARRAY_SIZE(data->ctrl_byte); i++)
  263. data->ctrl_byte[i] = (MAX127_CTRL_START |
  264. MAX127_SET_CHANNEL(i));
  265. hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
  266. data,
  267. &max127_chip_info,
  268. NULL);
  269. return PTR_ERR_OR_ZERO(hwmon_dev);
  270. }
  271. static const struct i2c_device_id max127_id[] = {
  272. { "max127", 0 },
  273. { }
  274. };
  275. MODULE_DEVICE_TABLE(i2c, max127_id);
  276. static struct i2c_driver max127_driver = {
  277. .class = I2C_CLASS_HWMON,
  278. .driver = {
  279. .name = "max127",
  280. },
  281. .probe = max127_probe,
  282. .id_table = max127_id,
  283. };
  284. module_i2c_driver(max127_driver);
  285. MODULE_LICENSE("GPL");
  286. MODULE_AUTHOR("Mike Choi <[email protected]>");
  287. MODULE_AUTHOR("Tao Ren <[email protected]>");
  288. MODULE_DESCRIPTION("MAX127 Hardware Monitoring driver");