max1668.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Copyright (c) 2011 David George <david.george@ska.ac.za>
  4. *
  5. * based on adm1021.c
  6. * some credit to Christoph Scheurer, but largely a rewrite
  7. */
  8. #include <linux/module.h>
  9. #include <linux/init.h>
  10. #include <linux/slab.h>
  11. #include <linux/jiffies.h>
  12. #include <linux/i2c.h>
  13. #include <linux/hwmon.h>
  14. #include <linux/hwmon-sysfs.h>
  15. #include <linux/err.h>
  16. #include <linux/mutex.h>
  17. /* Addresses to scan */
  18. static const unsigned short max1668_addr_list[] = {
  19. 0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b, 0x4c, 0x4d, 0x4e, I2C_CLIENT_END };
  20. /* max1668 registers */
  21. #define MAX1668_REG_TEMP(nr) (nr)
  22. #define MAX1668_REG_STAT1 0x05
  23. #define MAX1668_REG_STAT2 0x06
  24. #define MAX1668_REG_MAN_ID 0xfe
  25. #define MAX1668_REG_DEV_ID 0xff
  26. /* limits */
  27. /* write high limits */
  28. #define MAX1668_REG_LIMH_WR(nr) (0x13 + 2 * (nr))
  29. /* write low limits */
  30. #define MAX1668_REG_LIML_WR(nr) (0x14 + 2 * (nr))
  31. /* read high limits */
  32. #define MAX1668_REG_LIMH_RD(nr) (0x08 + 2 * (nr))
  33. /* read low limits */
  34. #define MAX1668_REG_LIML_RD(nr) (0x09 + 2 * (nr))
  35. /* manufacturer and device ID Constants */
  36. #define MAN_ID_MAXIM 0x4d
  37. #define DEV_ID_MAX1668 0x3
  38. #define DEV_ID_MAX1805 0x5
  39. #define DEV_ID_MAX1989 0xb
  40. /* read only mode module parameter */
  41. static bool read_only;
  42. module_param(read_only, bool, 0);
  43. MODULE_PARM_DESC(read_only, "Don't set any values, read only mode");
  44. enum chips { max1668, max1805, max1989 };
  45. struct max1668_data {
  46. struct i2c_client *client;
  47. const struct attribute_group *groups[3];
  48. enum chips type;
  49. struct mutex update_lock;
  50. char valid; /* !=0 if following fields are valid */
  51. unsigned long last_updated; /* In jiffies */
  52. /* 1x local and 4x remote */
  53. s8 temp_max[5];
  54. s8 temp_min[5];
  55. s8 temp[5];
  56. u16 alarms;
  57. };
  58. static struct max1668_data *max1668_update_device(struct device *dev)
  59. {
  60. struct max1668_data *data = dev_get_drvdata(dev);
  61. struct i2c_client *client = data->client;
  62. struct max1668_data *ret = data;
  63. s32 val;
  64. int i;
  65. mutex_lock(&data->update_lock);
  66. if (data->valid && !time_after(jiffies,
  67. data->last_updated + HZ + HZ / 2))
  68. goto abort;
  69. for (i = 0; i < 5; i++) {
  70. val = i2c_smbus_read_byte_data(client, MAX1668_REG_TEMP(i));
  71. if (unlikely(val < 0)) {
  72. ret = ERR_PTR(val);
  73. goto abort;
  74. }
  75. data->temp[i] = (s8) val;
  76. val = i2c_smbus_read_byte_data(client, MAX1668_REG_LIMH_RD(i));
  77. if (unlikely(val < 0)) {
  78. ret = ERR_PTR(val);
  79. goto abort;
  80. }
  81. data->temp_max[i] = (s8) val;
  82. val = i2c_smbus_read_byte_data(client, MAX1668_REG_LIML_RD(i));
  83. if (unlikely(val < 0)) {
  84. ret = ERR_PTR(val);
  85. goto abort;
  86. }
  87. data->temp_min[i] = (s8) val;
  88. }
  89. val = i2c_smbus_read_byte_data(client, MAX1668_REG_STAT1);
  90. if (unlikely(val < 0)) {
  91. ret = ERR_PTR(val);
  92. goto abort;
  93. }
  94. data->alarms = val << 8;
  95. val = i2c_smbus_read_byte_data(client, MAX1668_REG_STAT2);
  96. if (unlikely(val < 0)) {
  97. ret = ERR_PTR(val);
  98. goto abort;
  99. }
  100. data->alarms |= val;
  101. data->last_updated = jiffies;
  102. data->valid = 1;
  103. abort:
  104. mutex_unlock(&data->update_lock);
  105. return ret;
  106. }
  107. static ssize_t show_temp(struct device *dev,
  108. struct device_attribute *devattr, char *buf)
  109. {
  110. int index = to_sensor_dev_attr(devattr)->index;
  111. struct max1668_data *data = max1668_update_device(dev);
  112. if (IS_ERR(data))
  113. return PTR_ERR(data);
  114. return sprintf(buf, "%d\n", data->temp[index] * 1000);
  115. }
  116. static ssize_t show_temp_max(struct device *dev,
  117. struct device_attribute *devattr, char *buf)
  118. {
  119. int index = to_sensor_dev_attr(devattr)->index;
  120. struct max1668_data *data = max1668_update_device(dev);
  121. if (IS_ERR(data))
  122. return PTR_ERR(data);
  123. return sprintf(buf, "%d\n", data->temp_max[index] * 1000);
  124. }
  125. static ssize_t show_temp_min(struct device *dev,
  126. struct device_attribute *devattr, char *buf)
  127. {
  128. int index = to_sensor_dev_attr(devattr)->index;
  129. struct max1668_data *data = max1668_update_device(dev);
  130. if (IS_ERR(data))
  131. return PTR_ERR(data);
  132. return sprintf(buf, "%d\n", data->temp_min[index] * 1000);
  133. }
  134. static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
  135. char *buf)
  136. {
  137. int index = to_sensor_dev_attr(attr)->index;
  138. struct max1668_data *data = max1668_update_device(dev);
  139. if (IS_ERR(data))
  140. return PTR_ERR(data);
  141. return sprintf(buf, "%u\n", (data->alarms >> index) & 0x1);
  142. }
  143. static ssize_t show_fault(struct device *dev,
  144. struct device_attribute *devattr, char *buf)
  145. {
  146. int index = to_sensor_dev_attr(devattr)->index;
  147. struct max1668_data *data = max1668_update_device(dev);
  148. if (IS_ERR(data))
  149. return PTR_ERR(data);
  150. return sprintf(buf, "%u\n",
  151. (data->alarms & (1 << 12)) && data->temp[index] == 127);
  152. }
  153. static ssize_t set_temp_max(struct device *dev,
  154. struct device_attribute *devattr,
  155. const char *buf, size_t count)
  156. {
  157. int index = to_sensor_dev_attr(devattr)->index;
  158. struct max1668_data *data = dev_get_drvdata(dev);
  159. struct i2c_client *client = data->client;
  160. long temp;
  161. int ret;
  162. ret = kstrtol(buf, 10, &temp);
  163. if (ret < 0)
  164. return ret;
  165. mutex_lock(&data->update_lock);
  166. data->temp_max[index] = clamp_val(temp/1000, -128, 127);
  167. ret = i2c_smbus_write_byte_data(client,
  168. MAX1668_REG_LIMH_WR(index),
  169. data->temp_max[index]);
  170. if (ret < 0)
  171. count = ret;
  172. mutex_unlock(&data->update_lock);
  173. return count;
  174. }
  175. static ssize_t set_temp_min(struct device *dev,
  176. struct device_attribute *devattr,
  177. const char *buf, size_t count)
  178. {
  179. int index = to_sensor_dev_attr(devattr)->index;
  180. struct max1668_data *data = dev_get_drvdata(dev);
  181. struct i2c_client *client = data->client;
  182. long temp;
  183. int ret;
  184. ret = kstrtol(buf, 10, &temp);
  185. if (ret < 0)
  186. return ret;
  187. mutex_lock(&data->update_lock);
  188. data->temp_min[index] = clamp_val(temp/1000, -128, 127);
  189. ret = i2c_smbus_write_byte_data(client,
  190. MAX1668_REG_LIML_WR(index),
  191. data->temp_min[index]);
  192. if (ret < 0)
  193. count = ret;
  194. mutex_unlock(&data->update_lock);
  195. return count;
  196. }
  197. static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
  198. static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO, show_temp_max,
  199. set_temp_max, 0);
  200. static SENSOR_DEVICE_ATTR(temp1_min, S_IRUGO, show_temp_min,
  201. set_temp_min, 0);
  202. static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
  203. static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO, show_temp_max,
  204. set_temp_max, 1);
  205. static SENSOR_DEVICE_ATTR(temp2_min, S_IRUGO, show_temp_min,
  206. set_temp_min, 1);
  207. static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2);
  208. static SENSOR_DEVICE_ATTR(temp3_max, S_IRUGO, show_temp_max,
  209. set_temp_max, 2);
  210. static SENSOR_DEVICE_ATTR(temp3_min, S_IRUGO, show_temp_min,
  211. set_temp_min, 2);
  212. static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp, NULL, 3);
  213. static SENSOR_DEVICE_ATTR(temp4_max, S_IRUGO, show_temp_max,
  214. set_temp_max, 3);
  215. static SENSOR_DEVICE_ATTR(temp4_min, S_IRUGO, show_temp_min,
  216. set_temp_min, 3);
  217. static SENSOR_DEVICE_ATTR(temp5_input, S_IRUGO, show_temp, NULL, 4);
  218. static SENSOR_DEVICE_ATTR(temp5_max, S_IRUGO, show_temp_max,
  219. set_temp_max, 4);
  220. static SENSOR_DEVICE_ATTR(temp5_min, S_IRUGO, show_temp_min,
  221. set_temp_min, 4);
  222. static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 14);
  223. static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 13);
  224. static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 7);
  225. static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 6);
  226. static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_alarm, NULL, 5);
  227. static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_alarm, NULL, 4);
  228. static SENSOR_DEVICE_ATTR(temp4_min_alarm, S_IRUGO, show_alarm, NULL, 3);
  229. static SENSOR_DEVICE_ATTR(temp4_max_alarm, S_IRUGO, show_alarm, NULL, 2);
  230. static SENSOR_DEVICE_ATTR(temp5_min_alarm, S_IRUGO, show_alarm, NULL, 1);
  231. static SENSOR_DEVICE_ATTR(temp5_max_alarm, S_IRUGO, show_alarm, NULL, 0);
  232. static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_fault, NULL, 1);
  233. static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_fault, NULL, 2);
  234. static SENSOR_DEVICE_ATTR(temp4_fault, S_IRUGO, show_fault, NULL, 3);
  235. static SENSOR_DEVICE_ATTR(temp5_fault, S_IRUGO, show_fault, NULL, 4);
  236. /* Attributes common to MAX1668, MAX1989 and MAX1805 */
  237. static struct attribute *max1668_attribute_common[] = {
  238. &sensor_dev_attr_temp1_max.dev_attr.attr,
  239. &sensor_dev_attr_temp1_min.dev_attr.attr,
  240. &sensor_dev_attr_temp1_input.dev_attr.attr,
  241. &sensor_dev_attr_temp2_max.dev_attr.attr,
  242. &sensor_dev_attr_temp2_min.dev_attr.attr,
  243. &sensor_dev_attr_temp2_input.dev_attr.attr,
  244. &sensor_dev_attr_temp3_max.dev_attr.attr,
  245. &sensor_dev_attr_temp3_min.dev_attr.attr,
  246. &sensor_dev_attr_temp3_input.dev_attr.attr,
  247. &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
  248. &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
  249. &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
  250. &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
  251. &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
  252. &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
  253. &sensor_dev_attr_temp2_fault.dev_attr.attr,
  254. &sensor_dev_attr_temp3_fault.dev_attr.attr,
  255. NULL
  256. };
  257. /* Attributes not present on MAX1805 */
  258. static struct attribute *max1668_attribute_unique[] = {
  259. &sensor_dev_attr_temp4_max.dev_attr.attr,
  260. &sensor_dev_attr_temp4_min.dev_attr.attr,
  261. &sensor_dev_attr_temp4_input.dev_attr.attr,
  262. &sensor_dev_attr_temp5_max.dev_attr.attr,
  263. &sensor_dev_attr_temp5_min.dev_attr.attr,
  264. &sensor_dev_attr_temp5_input.dev_attr.attr,
  265. &sensor_dev_attr_temp4_max_alarm.dev_attr.attr,
  266. &sensor_dev_attr_temp4_min_alarm.dev_attr.attr,
  267. &sensor_dev_attr_temp5_max_alarm.dev_attr.attr,
  268. &sensor_dev_attr_temp5_min_alarm.dev_attr.attr,
  269. &sensor_dev_attr_temp4_fault.dev_attr.attr,
  270. &sensor_dev_attr_temp5_fault.dev_attr.attr,
  271. NULL
  272. };
  273. static umode_t max1668_attribute_mode(struct kobject *kobj,
  274. struct attribute *attr, int index)
  275. {
  276. umode_t ret = S_IRUGO;
  277. if (read_only)
  278. return ret;
  279. if (attr == &sensor_dev_attr_temp1_max.dev_attr.attr ||
  280. attr == &sensor_dev_attr_temp2_max.dev_attr.attr ||
  281. attr == &sensor_dev_attr_temp3_max.dev_attr.attr ||
  282. attr == &sensor_dev_attr_temp4_max.dev_attr.attr ||
  283. attr == &sensor_dev_attr_temp5_max.dev_attr.attr ||
  284. attr == &sensor_dev_attr_temp1_min.dev_attr.attr ||
  285. attr == &sensor_dev_attr_temp2_min.dev_attr.attr ||
  286. attr == &sensor_dev_attr_temp3_min.dev_attr.attr ||
  287. attr == &sensor_dev_attr_temp4_min.dev_attr.attr ||
  288. attr == &sensor_dev_attr_temp5_min.dev_attr.attr)
  289. ret |= S_IWUSR;
  290. return ret;
  291. }
  292. static const struct attribute_group max1668_group_common = {
  293. .attrs = max1668_attribute_common,
  294. .is_visible = max1668_attribute_mode
  295. };
  296. static const struct attribute_group max1668_group_unique = {
  297. .attrs = max1668_attribute_unique,
  298. .is_visible = max1668_attribute_mode
  299. };
  300. /* Return 0 if detection is successful, -ENODEV otherwise */
  301. static int max1668_detect(struct i2c_client *client,
  302. struct i2c_board_info *info)
  303. {
  304. struct i2c_adapter *adapter = client->adapter;
  305. const char *type_name;
  306. int man_id, dev_id;
  307. if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
  308. return -ENODEV;
  309. /* Check for unsupported part */
  310. man_id = i2c_smbus_read_byte_data(client, MAX1668_REG_MAN_ID);
  311. if (man_id != MAN_ID_MAXIM)
  312. return -ENODEV;
  313. dev_id = i2c_smbus_read_byte_data(client, MAX1668_REG_DEV_ID);
  314. if (dev_id < 0)
  315. return -ENODEV;
  316. type_name = NULL;
  317. if (dev_id == DEV_ID_MAX1668)
  318. type_name = "max1668";
  319. else if (dev_id == DEV_ID_MAX1805)
  320. type_name = "max1805";
  321. else if (dev_id == DEV_ID_MAX1989)
  322. type_name = "max1989";
  323. if (!type_name)
  324. return -ENODEV;
  325. strlcpy(info->type, type_name, I2C_NAME_SIZE);
  326. return 0;
  327. }
  328. static const struct i2c_device_id max1668_id[];
  329. static int max1668_probe(struct i2c_client *client)
  330. {
  331. struct i2c_adapter *adapter = client->adapter;
  332. struct device *dev = &client->dev;
  333. struct device *hwmon_dev;
  334. struct max1668_data *data;
  335. if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
  336. return -ENODEV;
  337. data = devm_kzalloc(dev, sizeof(struct max1668_data), GFP_KERNEL);
  338. if (!data)
  339. return -ENOMEM;
  340. data->client = client;
  341. data->type = i2c_match_id(max1668_id, client)->driver_data;
  342. mutex_init(&data->update_lock);
  343. /* sysfs hooks */
  344. data->groups[0] = &max1668_group_common;
  345. if (data->type == max1668 || data->type == max1989)
  346. data->groups[1] = &max1668_group_unique;
  347. hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
  348. data, data->groups);
  349. return PTR_ERR_OR_ZERO(hwmon_dev);
  350. }
  351. static const struct i2c_device_id max1668_id[] = {
  352. { "max1668", max1668 },
  353. { "max1805", max1805 },
  354. { "max1989", max1989 },
  355. { }
  356. };
  357. MODULE_DEVICE_TABLE(i2c, max1668_id);
  358. /* This is the driver that will be inserted */
  359. static struct i2c_driver max1668_driver = {
  360. .class = I2C_CLASS_HWMON,
  361. .driver = {
  362. .name = "max1668",
  363. },
  364. .probe_new = max1668_probe,
  365. .id_table = max1668_id,
  366. .detect = max1668_detect,
  367. .address_list = max1668_addr_list,
  368. };
  369. module_i2c_driver(max1668_driver);
  370. MODULE_AUTHOR("David George <david.george@ska.ac.za>");
  371. MODULE_DESCRIPTION("MAX1668 remote temperature sensor driver");
  372. MODULE_LICENSE("GPL");