thmc50.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * thmc50.c - Part of lm_sensors, Linux kernel modules for hardware
  4. * monitoring
  5. * Copyright (C) 2007 Krzysztof Helt <[email protected]>
  6. * Based on 2.4 driver by Frodo Looijaard <[email protected]> and
  7. * Philip Edelbrock <[email protected]>
  8. */
  9. #include <linux/module.h>
  10. #include <linux/init.h>
  11. #include <linux/slab.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. #include <linux/jiffies.h>
  18. MODULE_LICENSE("GPL");
  19. /* Addresses to scan */
  20. static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
  21. /* Insmod parameters */
  22. enum chips { thmc50, adm1022 };
  23. static unsigned short adm1022_temp3[16];
  24. static unsigned int adm1022_temp3_num;
  25. module_param_array(adm1022_temp3, ushort, &adm1022_temp3_num, 0);
  26. MODULE_PARM_DESC(adm1022_temp3,
  27. "List of adapter,address pairs to enable 3rd temperature (ADM1022 only)");
  28. /* Many THMC50 constants specified below */
  29. /* The THMC50 registers */
  30. #define THMC50_REG_CONF 0x40
  31. #define THMC50_REG_COMPANY_ID 0x3E
  32. #define THMC50_REG_DIE_CODE 0x3F
  33. #define THMC50_REG_ANALOG_OUT 0x19
  34. /*
  35. * The mirror status register cannot be used as
  36. * reading it does not clear alarms.
  37. */
  38. #define THMC50_REG_INTR 0x41
  39. static const u8 THMC50_REG_TEMP[] = { 0x27, 0x26, 0x20 };
  40. static const u8 THMC50_REG_TEMP_MIN[] = { 0x3A, 0x38, 0x2C };
  41. static const u8 THMC50_REG_TEMP_MAX[] = { 0x39, 0x37, 0x2B };
  42. static const u8 THMC50_REG_TEMP_CRITICAL[] = { 0x13, 0x14, 0x14 };
  43. static const u8 THMC50_REG_TEMP_DEFAULT[] = { 0x17, 0x18, 0x18 };
  44. #define THMC50_REG_CONF_nFANOFF 0x20
  45. #define THMC50_REG_CONF_PROGRAMMED 0x08
  46. /* Each client has this additional data */
  47. struct thmc50_data {
  48. struct i2c_client *client;
  49. const struct attribute_group *groups[3];
  50. struct mutex update_lock;
  51. enum chips type;
  52. unsigned long last_updated; /* In jiffies */
  53. char has_temp3; /* !=0 if it is ADM1022 in temp3 mode */
  54. bool valid; /* true if following fields are valid */
  55. /* Register values */
  56. s8 temp_input[3];
  57. s8 temp_max[3];
  58. s8 temp_min[3];
  59. s8 temp_critical[3];
  60. u8 analog_out;
  61. u8 alarms;
  62. };
  63. static struct thmc50_data *thmc50_update_device(struct device *dev)
  64. {
  65. struct thmc50_data *data = dev_get_drvdata(dev);
  66. struct i2c_client *client = data->client;
  67. int timeout = HZ / 5 + (data->type == thmc50 ? HZ : 0);
  68. mutex_lock(&data->update_lock);
  69. if (time_after(jiffies, data->last_updated + timeout)
  70. || !data->valid) {
  71. int temps = data->has_temp3 ? 3 : 2;
  72. int i;
  73. int prog = i2c_smbus_read_byte_data(client, THMC50_REG_CONF);
  74. prog &= THMC50_REG_CONF_PROGRAMMED;
  75. for (i = 0; i < temps; i++) {
  76. data->temp_input[i] = i2c_smbus_read_byte_data(client,
  77. THMC50_REG_TEMP[i]);
  78. data->temp_max[i] = i2c_smbus_read_byte_data(client,
  79. THMC50_REG_TEMP_MAX[i]);
  80. data->temp_min[i] = i2c_smbus_read_byte_data(client,
  81. THMC50_REG_TEMP_MIN[i]);
  82. data->temp_critical[i] =
  83. i2c_smbus_read_byte_data(client,
  84. prog ? THMC50_REG_TEMP_CRITICAL[i]
  85. : THMC50_REG_TEMP_DEFAULT[i]);
  86. }
  87. data->analog_out =
  88. i2c_smbus_read_byte_data(client, THMC50_REG_ANALOG_OUT);
  89. data->alarms =
  90. i2c_smbus_read_byte_data(client, THMC50_REG_INTR);
  91. data->last_updated = jiffies;
  92. data->valid = true;
  93. }
  94. mutex_unlock(&data->update_lock);
  95. return data;
  96. }
  97. static ssize_t analog_out_show(struct device *dev,
  98. struct device_attribute *attr, char *buf)
  99. {
  100. struct thmc50_data *data = thmc50_update_device(dev);
  101. return sprintf(buf, "%d\n", data->analog_out);
  102. }
  103. static ssize_t analog_out_store(struct device *dev,
  104. struct device_attribute *attr,
  105. const char *buf, size_t count)
  106. {
  107. struct thmc50_data *data = dev_get_drvdata(dev);
  108. struct i2c_client *client = data->client;
  109. int config;
  110. unsigned long tmp;
  111. int err;
  112. err = kstrtoul(buf, 10, &tmp);
  113. if (err)
  114. return err;
  115. mutex_lock(&data->update_lock);
  116. data->analog_out = clamp_val(tmp, 0, 255);
  117. i2c_smbus_write_byte_data(client, THMC50_REG_ANALOG_OUT,
  118. data->analog_out);
  119. config = i2c_smbus_read_byte_data(client, THMC50_REG_CONF);
  120. if (data->analog_out == 0)
  121. config &= ~THMC50_REG_CONF_nFANOFF;
  122. else
  123. config |= THMC50_REG_CONF_nFANOFF;
  124. i2c_smbus_write_byte_data(client, THMC50_REG_CONF, config);
  125. mutex_unlock(&data->update_lock);
  126. return count;
  127. }
  128. /* There is only one PWM mode = DC */
  129. static ssize_t pwm_mode_show(struct device *dev,
  130. struct device_attribute *attr, char *buf)
  131. {
  132. return sprintf(buf, "0\n");
  133. }
  134. /* Temperatures */
  135. static ssize_t temp_show(struct device *dev, struct device_attribute *attr,
  136. char *buf)
  137. {
  138. int nr = to_sensor_dev_attr(attr)->index;
  139. struct thmc50_data *data = thmc50_update_device(dev);
  140. return sprintf(buf, "%d\n", data->temp_input[nr] * 1000);
  141. }
  142. static ssize_t temp_min_show(struct device *dev,
  143. struct device_attribute *attr, char *buf)
  144. {
  145. int nr = to_sensor_dev_attr(attr)->index;
  146. struct thmc50_data *data = thmc50_update_device(dev);
  147. return sprintf(buf, "%d\n", data->temp_min[nr] * 1000);
  148. }
  149. static ssize_t temp_min_store(struct device *dev,
  150. struct device_attribute *attr, const char *buf,
  151. size_t count)
  152. {
  153. int nr = to_sensor_dev_attr(attr)->index;
  154. struct thmc50_data *data = dev_get_drvdata(dev);
  155. struct i2c_client *client = data->client;
  156. long val;
  157. int err;
  158. err = kstrtol(buf, 10, &val);
  159. if (err)
  160. return err;
  161. mutex_lock(&data->update_lock);
  162. data->temp_min[nr] = clamp_val(val / 1000, -128, 127);
  163. i2c_smbus_write_byte_data(client, THMC50_REG_TEMP_MIN[nr],
  164. data->temp_min[nr]);
  165. mutex_unlock(&data->update_lock);
  166. return count;
  167. }
  168. static ssize_t temp_max_show(struct device *dev,
  169. struct device_attribute *attr, char *buf)
  170. {
  171. int nr = to_sensor_dev_attr(attr)->index;
  172. struct thmc50_data *data = thmc50_update_device(dev);
  173. return sprintf(buf, "%d\n", data->temp_max[nr] * 1000);
  174. }
  175. static ssize_t temp_max_store(struct device *dev,
  176. struct device_attribute *attr, const char *buf,
  177. size_t count)
  178. {
  179. int nr = to_sensor_dev_attr(attr)->index;
  180. struct thmc50_data *data = dev_get_drvdata(dev);
  181. struct i2c_client *client = data->client;
  182. long val;
  183. int err;
  184. err = kstrtol(buf, 10, &val);
  185. if (err)
  186. return err;
  187. mutex_lock(&data->update_lock);
  188. data->temp_max[nr] = clamp_val(val / 1000, -128, 127);
  189. i2c_smbus_write_byte_data(client, THMC50_REG_TEMP_MAX[nr],
  190. data->temp_max[nr]);
  191. mutex_unlock(&data->update_lock);
  192. return count;
  193. }
  194. static ssize_t temp_critical_show(struct device *dev,
  195. struct device_attribute *attr, char *buf)
  196. {
  197. int nr = to_sensor_dev_attr(attr)->index;
  198. struct thmc50_data *data = thmc50_update_device(dev);
  199. return sprintf(buf, "%d\n", data->temp_critical[nr] * 1000);
  200. }
  201. static ssize_t alarm_show(struct device *dev, struct device_attribute *attr,
  202. char *buf)
  203. {
  204. int index = to_sensor_dev_attr(attr)->index;
  205. struct thmc50_data *data = thmc50_update_device(dev);
  206. return sprintf(buf, "%u\n", (data->alarms >> index) & 1);
  207. }
  208. static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0);
  209. static SENSOR_DEVICE_ATTR_RW(temp1_min, temp_min, 0);
  210. static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0);
  211. static SENSOR_DEVICE_ATTR_RO(temp1_crit, temp_critical, 0);
  212. static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1);
  213. static SENSOR_DEVICE_ATTR_RW(temp2_min, temp_min, 1);
  214. static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);
  215. static SENSOR_DEVICE_ATTR_RO(temp2_crit, temp_critical, 1);
  216. static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2);
  217. static SENSOR_DEVICE_ATTR_RW(temp3_min, temp_min, 2);
  218. static SENSOR_DEVICE_ATTR_RW(temp3_max, temp_max, 2);
  219. static SENSOR_DEVICE_ATTR_RO(temp3_crit, temp_critical, 2);
  220. static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm, 0);
  221. static SENSOR_DEVICE_ATTR_RO(temp2_alarm, alarm, 5);
  222. static SENSOR_DEVICE_ATTR_RO(temp3_alarm, alarm, 1);
  223. static SENSOR_DEVICE_ATTR_RO(temp2_fault, alarm, 7);
  224. static SENSOR_DEVICE_ATTR_RO(temp3_fault, alarm, 2);
  225. static SENSOR_DEVICE_ATTR_RW(pwm1, analog_out, 0);
  226. static SENSOR_DEVICE_ATTR_RO(pwm1_mode, pwm_mode, 0);
  227. static struct attribute *thmc50_attributes[] = {
  228. &sensor_dev_attr_temp1_max.dev_attr.attr,
  229. &sensor_dev_attr_temp1_min.dev_attr.attr,
  230. &sensor_dev_attr_temp1_input.dev_attr.attr,
  231. &sensor_dev_attr_temp1_crit.dev_attr.attr,
  232. &sensor_dev_attr_temp1_alarm.dev_attr.attr,
  233. &sensor_dev_attr_temp2_max.dev_attr.attr,
  234. &sensor_dev_attr_temp2_min.dev_attr.attr,
  235. &sensor_dev_attr_temp2_input.dev_attr.attr,
  236. &sensor_dev_attr_temp2_crit.dev_attr.attr,
  237. &sensor_dev_attr_temp2_alarm.dev_attr.attr,
  238. &sensor_dev_attr_temp2_fault.dev_attr.attr,
  239. &sensor_dev_attr_pwm1.dev_attr.attr,
  240. &sensor_dev_attr_pwm1_mode.dev_attr.attr,
  241. NULL
  242. };
  243. static const struct attribute_group thmc50_group = {
  244. .attrs = thmc50_attributes,
  245. };
  246. /* for ADM1022 3rd temperature mode */
  247. static struct attribute *temp3_attributes[] = {
  248. &sensor_dev_attr_temp3_max.dev_attr.attr,
  249. &sensor_dev_attr_temp3_min.dev_attr.attr,
  250. &sensor_dev_attr_temp3_input.dev_attr.attr,
  251. &sensor_dev_attr_temp3_crit.dev_attr.attr,
  252. &sensor_dev_attr_temp3_alarm.dev_attr.attr,
  253. &sensor_dev_attr_temp3_fault.dev_attr.attr,
  254. NULL
  255. };
  256. static const struct attribute_group temp3_group = {
  257. .attrs = temp3_attributes,
  258. };
  259. /* Return 0 if detection is successful, -ENODEV otherwise */
  260. static int thmc50_detect(struct i2c_client *client,
  261. struct i2c_board_info *info)
  262. {
  263. unsigned company;
  264. unsigned revision;
  265. unsigned config;
  266. struct i2c_adapter *adapter = client->adapter;
  267. const char *type_name;
  268. if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
  269. pr_debug("thmc50: detect failed, smbus byte data not supported!\n");
  270. return -ENODEV;
  271. }
  272. pr_debug("thmc50: Probing for THMC50 at 0x%2X on bus %d\n",
  273. client->addr, i2c_adapter_id(client->adapter));
  274. company = i2c_smbus_read_byte_data(client, THMC50_REG_COMPANY_ID);
  275. revision = i2c_smbus_read_byte_data(client, THMC50_REG_DIE_CODE);
  276. config = i2c_smbus_read_byte_data(client, THMC50_REG_CONF);
  277. if (revision < 0xc0 || (config & 0x10))
  278. return -ENODEV;
  279. if (company == 0x41) {
  280. int id = i2c_adapter_id(client->adapter);
  281. int i;
  282. type_name = "adm1022";
  283. for (i = 0; i + 1 < adm1022_temp3_num; i += 2)
  284. if (adm1022_temp3[i] == id &&
  285. adm1022_temp3[i + 1] == client->addr) {
  286. /* enable 2nd remote temp */
  287. config |= (1 << 7);
  288. i2c_smbus_write_byte_data(client,
  289. THMC50_REG_CONF,
  290. config);
  291. break;
  292. }
  293. } else if (company == 0x49) {
  294. type_name = "thmc50";
  295. } else {
  296. pr_debug("thmc50: Detection of THMC50/ADM1022 failed\n");
  297. return -ENODEV;
  298. }
  299. pr_debug("thmc50: Detected %s (version %x, revision %x)\n",
  300. type_name, (revision >> 4) - 0xc, revision & 0xf);
  301. strscpy(info->type, type_name, I2C_NAME_SIZE);
  302. return 0;
  303. }
  304. static void thmc50_init_client(struct thmc50_data *data)
  305. {
  306. struct i2c_client *client = data->client;
  307. int config;
  308. data->analog_out = i2c_smbus_read_byte_data(client,
  309. THMC50_REG_ANALOG_OUT);
  310. /* set up to at least 1 */
  311. if (data->analog_out == 0) {
  312. data->analog_out = 1;
  313. i2c_smbus_write_byte_data(client, THMC50_REG_ANALOG_OUT,
  314. data->analog_out);
  315. }
  316. config = i2c_smbus_read_byte_data(client, THMC50_REG_CONF);
  317. config |= 0x1; /* start the chip if it is in standby mode */
  318. if (data->type == adm1022 && (config & (1 << 7)))
  319. data->has_temp3 = 1;
  320. i2c_smbus_write_byte_data(client, THMC50_REG_CONF, config);
  321. }
  322. static const struct i2c_device_id thmc50_id[];
  323. static int thmc50_probe(struct i2c_client *client)
  324. {
  325. struct device *dev = &client->dev;
  326. struct thmc50_data *data;
  327. struct device *hwmon_dev;
  328. int idx = 0;
  329. data = devm_kzalloc(dev, sizeof(struct thmc50_data), GFP_KERNEL);
  330. if (!data)
  331. return -ENOMEM;
  332. data->client = client;
  333. data->type = i2c_match_id(thmc50_id, client)->driver_data;
  334. mutex_init(&data->update_lock);
  335. thmc50_init_client(data);
  336. /* sysfs hooks */
  337. data->groups[idx++] = &thmc50_group;
  338. /* Register additional ADM1022 sysfs hooks */
  339. if (data->has_temp3)
  340. data->groups[idx++] = &temp3_group;
  341. hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
  342. data, data->groups);
  343. return PTR_ERR_OR_ZERO(hwmon_dev);
  344. }
  345. static const struct i2c_device_id thmc50_id[] = {
  346. { "adm1022", adm1022 },
  347. { "thmc50", thmc50 },
  348. { }
  349. };
  350. MODULE_DEVICE_TABLE(i2c, thmc50_id);
  351. static struct i2c_driver thmc50_driver = {
  352. .class = I2C_CLASS_HWMON,
  353. .driver = {
  354. .name = "thmc50",
  355. },
  356. .probe_new = thmc50_probe,
  357. .id_table = thmc50_id,
  358. .detect = thmc50_detect,
  359. .address_list = normal_i2c,
  360. };
  361. module_i2c_driver(thmc50_driver);
  362. MODULE_AUTHOR("Krzysztof Helt <[email protected]>");
  363. MODULE_DESCRIPTION("THMC50 driver");