sch5636.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /***************************************************************************
  3. * Copyright (C) 2011-2012 Hans de Goede <[email protected]> *
  4. * *
  5. ***************************************************************************/
  6. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  7. #include <linux/module.h>
  8. #include <linux/mod_devicetable.h>
  9. #include <linux/init.h>
  10. #include <linux/slab.h>
  11. #include <linux/jiffies.h>
  12. #include <linux/platform_device.h>
  13. #include <linux/hwmon.h>
  14. #include <linux/hwmon-sysfs.h>
  15. #include <linux/err.h>
  16. #include <linux/mutex.h>
  17. #include "sch56xx-common.h"
  18. #define DRVNAME "sch5636"
  19. #define DEVNAME "theseus" /* We only support one model for now */
  20. #define SCH5636_REG_FUJITSU_ID 0x780
  21. #define SCH5636_REG_FUJITSU_REV 0x783
  22. #define SCH5636_NO_INS 5
  23. #define SCH5636_NO_TEMPS 16
  24. #define SCH5636_NO_FANS 8
  25. static const u16 SCH5636_REG_IN_VAL[SCH5636_NO_INS] = {
  26. 0x22, 0x23, 0x24, 0x25, 0x189 };
  27. static const u16 SCH5636_REG_IN_FACTORS[SCH5636_NO_INS] = {
  28. 4400, 1500, 4000, 4400, 16000 };
  29. static const char * const SCH5636_IN_LABELS[SCH5636_NO_INS] = {
  30. "3.3V", "VREF", "VBAT", "3.3AUX", "12V" };
  31. static const u16 SCH5636_REG_TEMP_VAL[SCH5636_NO_TEMPS] = {
  32. 0x2B, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x180, 0x181,
  33. 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C };
  34. #define SCH5636_REG_TEMP_CTRL(i) (0x790 + (i))
  35. #define SCH5636_TEMP_WORKING 0x01
  36. #define SCH5636_TEMP_ALARM 0x02
  37. #define SCH5636_TEMP_DEACTIVATED 0x80
  38. static const u16 SCH5636_REG_FAN_VAL[SCH5636_NO_FANS] = {
  39. 0x2C, 0x2E, 0x30, 0x32, 0x62, 0x64, 0x66, 0x68 };
  40. #define SCH5636_REG_FAN_CTRL(i) (0x880 + (i))
  41. /* FAULT in datasheet, but acts as an alarm */
  42. #define SCH5636_FAN_ALARM 0x04
  43. #define SCH5636_FAN_NOT_PRESENT 0x08
  44. #define SCH5636_FAN_DEACTIVATED 0x80
  45. struct sch5636_data {
  46. unsigned short addr;
  47. struct device *hwmon_dev;
  48. struct mutex update_lock;
  49. bool valid; /* true if following fields are valid */
  50. unsigned long last_updated; /* In jiffies */
  51. u8 in[SCH5636_NO_INS];
  52. u8 temp_val[SCH5636_NO_TEMPS];
  53. u8 temp_ctrl[SCH5636_NO_TEMPS];
  54. u16 fan_val[SCH5636_NO_FANS];
  55. u8 fan_ctrl[SCH5636_NO_FANS];
  56. };
  57. static struct sch5636_data *sch5636_update_device(struct device *dev)
  58. {
  59. struct sch5636_data *data = dev_get_drvdata(dev);
  60. struct sch5636_data *ret = data;
  61. int i, val;
  62. mutex_lock(&data->update_lock);
  63. /* Cache the values for 1 second */
  64. if (data->valid && !time_after(jiffies, data->last_updated + HZ))
  65. goto abort;
  66. for (i = 0; i < SCH5636_NO_INS; i++) {
  67. val = sch56xx_read_virtual_reg(data->addr,
  68. SCH5636_REG_IN_VAL[i]);
  69. if (unlikely(val < 0)) {
  70. ret = ERR_PTR(val);
  71. goto abort;
  72. }
  73. data->in[i] = val;
  74. }
  75. for (i = 0; i < SCH5636_NO_TEMPS; i++) {
  76. if (data->temp_ctrl[i] & SCH5636_TEMP_DEACTIVATED)
  77. continue;
  78. val = sch56xx_read_virtual_reg(data->addr,
  79. SCH5636_REG_TEMP_VAL[i]);
  80. if (unlikely(val < 0)) {
  81. ret = ERR_PTR(val);
  82. goto abort;
  83. }
  84. data->temp_val[i] = val;
  85. val = sch56xx_read_virtual_reg(data->addr,
  86. SCH5636_REG_TEMP_CTRL(i));
  87. if (unlikely(val < 0)) {
  88. ret = ERR_PTR(val);
  89. goto abort;
  90. }
  91. data->temp_ctrl[i] = val;
  92. /* Alarms need to be explicitly write-cleared */
  93. if (val & SCH5636_TEMP_ALARM) {
  94. sch56xx_write_virtual_reg(data->addr,
  95. SCH5636_REG_TEMP_CTRL(i), val);
  96. }
  97. }
  98. for (i = 0; i < SCH5636_NO_FANS; i++) {
  99. if (data->fan_ctrl[i] & SCH5636_FAN_DEACTIVATED)
  100. continue;
  101. val = sch56xx_read_virtual_reg16(data->addr,
  102. SCH5636_REG_FAN_VAL[i]);
  103. if (unlikely(val < 0)) {
  104. ret = ERR_PTR(val);
  105. goto abort;
  106. }
  107. data->fan_val[i] = val;
  108. val = sch56xx_read_virtual_reg(data->addr,
  109. SCH5636_REG_FAN_CTRL(i));
  110. if (unlikely(val < 0)) {
  111. ret = ERR_PTR(val);
  112. goto abort;
  113. }
  114. data->fan_ctrl[i] = val;
  115. /* Alarms need to be explicitly write-cleared */
  116. if (val & SCH5636_FAN_ALARM) {
  117. sch56xx_write_virtual_reg(data->addr,
  118. SCH5636_REG_FAN_CTRL(i), val);
  119. }
  120. }
  121. data->last_updated = jiffies;
  122. data->valid = true;
  123. abort:
  124. mutex_unlock(&data->update_lock);
  125. return ret;
  126. }
  127. static int reg_to_rpm(u16 reg)
  128. {
  129. if (reg == 0)
  130. return -EIO;
  131. if (reg == 0xffff)
  132. return 0;
  133. return 5400540 / reg;
  134. }
  135. static ssize_t name_show(struct device *dev, struct device_attribute *devattr,
  136. char *buf)
  137. {
  138. return sysfs_emit(buf, "%s\n", DEVNAME);
  139. }
  140. static ssize_t in_value_show(struct device *dev,
  141. struct device_attribute *devattr, char *buf)
  142. {
  143. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  144. struct sch5636_data *data = sch5636_update_device(dev);
  145. int val;
  146. if (IS_ERR(data))
  147. return PTR_ERR(data);
  148. val = DIV_ROUND_CLOSEST(
  149. data->in[attr->index] * SCH5636_REG_IN_FACTORS[attr->index],
  150. 255);
  151. return sysfs_emit(buf, "%d\n", val);
  152. }
  153. static ssize_t in_label_show(struct device *dev,
  154. struct device_attribute *devattr, char *buf)
  155. {
  156. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  157. return sysfs_emit(buf, "%s\n",
  158. SCH5636_IN_LABELS[attr->index]);
  159. }
  160. static ssize_t temp_value_show(struct device *dev,
  161. struct device_attribute *devattr, char *buf)
  162. {
  163. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  164. struct sch5636_data *data = sch5636_update_device(dev);
  165. int val;
  166. if (IS_ERR(data))
  167. return PTR_ERR(data);
  168. val = (data->temp_val[attr->index] - 64) * 1000;
  169. return sysfs_emit(buf, "%d\n", val);
  170. }
  171. static ssize_t temp_fault_show(struct device *dev,
  172. struct device_attribute *devattr, char *buf)
  173. {
  174. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  175. struct sch5636_data *data = sch5636_update_device(dev);
  176. int val;
  177. if (IS_ERR(data))
  178. return PTR_ERR(data);
  179. val = (data->temp_ctrl[attr->index] & SCH5636_TEMP_WORKING) ? 0 : 1;
  180. return sysfs_emit(buf, "%d\n", val);
  181. }
  182. static ssize_t temp_alarm_show(struct device *dev,
  183. struct device_attribute *devattr, char *buf)
  184. {
  185. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  186. struct sch5636_data *data = sch5636_update_device(dev);
  187. int val;
  188. if (IS_ERR(data))
  189. return PTR_ERR(data);
  190. val = (data->temp_ctrl[attr->index] & SCH5636_TEMP_ALARM) ? 1 : 0;
  191. return sysfs_emit(buf, "%d\n", val);
  192. }
  193. static ssize_t fan_value_show(struct device *dev,
  194. struct device_attribute *devattr, char *buf)
  195. {
  196. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  197. struct sch5636_data *data = sch5636_update_device(dev);
  198. int val;
  199. if (IS_ERR(data))
  200. return PTR_ERR(data);
  201. val = reg_to_rpm(data->fan_val[attr->index]);
  202. if (val < 0)
  203. return val;
  204. return sysfs_emit(buf, "%d\n", val);
  205. }
  206. static ssize_t fan_fault_show(struct device *dev,
  207. struct device_attribute *devattr, char *buf)
  208. {
  209. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  210. struct sch5636_data *data = sch5636_update_device(dev);
  211. int val;
  212. if (IS_ERR(data))
  213. return PTR_ERR(data);
  214. val = (data->fan_ctrl[attr->index] & SCH5636_FAN_NOT_PRESENT) ? 1 : 0;
  215. return sysfs_emit(buf, "%d\n", val);
  216. }
  217. static ssize_t fan_alarm_show(struct device *dev,
  218. struct device_attribute *devattr, char *buf)
  219. {
  220. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  221. struct sch5636_data *data = sch5636_update_device(dev);
  222. int val;
  223. if (IS_ERR(data))
  224. return PTR_ERR(data);
  225. val = (data->fan_ctrl[attr->index] & SCH5636_FAN_ALARM) ? 1 : 0;
  226. return sysfs_emit(buf, "%d\n", val);
  227. }
  228. static struct sensor_device_attribute sch5636_attr[] = {
  229. SENSOR_ATTR_RO(name, name, 0),
  230. SENSOR_ATTR_RO(in0_input, in_value, 0),
  231. SENSOR_ATTR_RO(in0_label, in_label, 0),
  232. SENSOR_ATTR_RO(in1_input, in_value, 1),
  233. SENSOR_ATTR_RO(in1_label, in_label, 1),
  234. SENSOR_ATTR_RO(in2_input, in_value, 2),
  235. SENSOR_ATTR_RO(in2_label, in_label, 2),
  236. SENSOR_ATTR_RO(in3_input, in_value, 3),
  237. SENSOR_ATTR_RO(in3_label, in_label, 3),
  238. SENSOR_ATTR_RO(in4_input, in_value, 4),
  239. SENSOR_ATTR_RO(in4_label, in_label, 4),
  240. };
  241. static struct sensor_device_attribute sch5636_temp_attr[] = {
  242. SENSOR_ATTR_RO(temp1_input, temp_value, 0),
  243. SENSOR_ATTR_RO(temp1_fault, temp_fault, 0),
  244. SENSOR_ATTR_RO(temp1_alarm, temp_alarm, 0),
  245. SENSOR_ATTR_RO(temp2_input, temp_value, 1),
  246. SENSOR_ATTR_RO(temp2_fault, temp_fault, 1),
  247. SENSOR_ATTR_RO(temp2_alarm, temp_alarm, 1),
  248. SENSOR_ATTR_RO(temp3_input, temp_value, 2),
  249. SENSOR_ATTR_RO(temp3_fault, temp_fault, 2),
  250. SENSOR_ATTR_RO(temp3_alarm, temp_alarm, 2),
  251. SENSOR_ATTR_RO(temp4_input, temp_value, 3),
  252. SENSOR_ATTR_RO(temp4_fault, temp_fault, 3),
  253. SENSOR_ATTR_RO(temp4_alarm, temp_alarm, 3),
  254. SENSOR_ATTR_RO(temp5_input, temp_value, 4),
  255. SENSOR_ATTR_RO(temp5_fault, temp_fault, 4),
  256. SENSOR_ATTR_RO(temp5_alarm, temp_alarm, 4),
  257. SENSOR_ATTR_RO(temp6_input, temp_value, 5),
  258. SENSOR_ATTR_RO(temp6_fault, temp_fault, 5),
  259. SENSOR_ATTR_RO(temp6_alarm, temp_alarm, 5),
  260. SENSOR_ATTR_RO(temp7_input, temp_value, 6),
  261. SENSOR_ATTR_RO(temp7_fault, temp_fault, 6),
  262. SENSOR_ATTR_RO(temp7_alarm, temp_alarm, 6),
  263. SENSOR_ATTR_RO(temp8_input, temp_value, 7),
  264. SENSOR_ATTR_RO(temp8_fault, temp_fault, 7),
  265. SENSOR_ATTR_RO(temp8_alarm, temp_alarm, 7),
  266. SENSOR_ATTR_RO(temp9_input, temp_value, 8),
  267. SENSOR_ATTR_RO(temp9_fault, temp_fault, 8),
  268. SENSOR_ATTR_RO(temp9_alarm, temp_alarm, 8),
  269. SENSOR_ATTR_RO(temp10_input, temp_value, 9),
  270. SENSOR_ATTR_RO(temp10_fault, temp_fault, 9),
  271. SENSOR_ATTR_RO(temp10_alarm, temp_alarm, 9),
  272. SENSOR_ATTR_RO(temp11_input, temp_value, 10),
  273. SENSOR_ATTR_RO(temp11_fault, temp_fault, 10),
  274. SENSOR_ATTR_RO(temp11_alarm, temp_alarm, 10),
  275. SENSOR_ATTR_RO(temp12_input, temp_value, 11),
  276. SENSOR_ATTR_RO(temp12_fault, temp_fault, 11),
  277. SENSOR_ATTR_RO(temp12_alarm, temp_alarm, 11),
  278. SENSOR_ATTR_RO(temp13_input, temp_value, 12),
  279. SENSOR_ATTR_RO(temp13_fault, temp_fault, 12),
  280. SENSOR_ATTR_RO(temp13_alarm, temp_alarm, 12),
  281. SENSOR_ATTR_RO(temp14_input, temp_value, 13),
  282. SENSOR_ATTR_RO(temp14_fault, temp_fault, 13),
  283. SENSOR_ATTR_RO(temp14_alarm, temp_alarm, 13),
  284. SENSOR_ATTR_RO(temp15_input, temp_value, 14),
  285. SENSOR_ATTR_RO(temp15_fault, temp_fault, 14),
  286. SENSOR_ATTR_RO(temp15_alarm, temp_alarm, 14),
  287. SENSOR_ATTR_RO(temp16_input, temp_value, 15),
  288. SENSOR_ATTR_RO(temp16_fault, temp_fault, 15),
  289. SENSOR_ATTR_RO(temp16_alarm, temp_alarm, 15),
  290. };
  291. static struct sensor_device_attribute sch5636_fan_attr[] = {
  292. SENSOR_ATTR_RO(fan1_input, fan_value, 0),
  293. SENSOR_ATTR_RO(fan1_fault, fan_fault, 0),
  294. SENSOR_ATTR_RO(fan1_alarm, fan_alarm, 0),
  295. SENSOR_ATTR_RO(fan2_input, fan_value, 1),
  296. SENSOR_ATTR_RO(fan2_fault, fan_fault, 1),
  297. SENSOR_ATTR_RO(fan2_alarm, fan_alarm, 1),
  298. SENSOR_ATTR_RO(fan3_input, fan_value, 2),
  299. SENSOR_ATTR_RO(fan3_fault, fan_fault, 2),
  300. SENSOR_ATTR_RO(fan3_alarm, fan_alarm, 2),
  301. SENSOR_ATTR_RO(fan4_input, fan_value, 3),
  302. SENSOR_ATTR_RO(fan4_fault, fan_fault, 3),
  303. SENSOR_ATTR_RO(fan4_alarm, fan_alarm, 3),
  304. SENSOR_ATTR_RO(fan5_input, fan_value, 4),
  305. SENSOR_ATTR_RO(fan5_fault, fan_fault, 4),
  306. SENSOR_ATTR_RO(fan5_alarm, fan_alarm, 4),
  307. SENSOR_ATTR_RO(fan6_input, fan_value, 5),
  308. SENSOR_ATTR_RO(fan6_fault, fan_fault, 5),
  309. SENSOR_ATTR_RO(fan6_alarm, fan_alarm, 5),
  310. SENSOR_ATTR_RO(fan7_input, fan_value, 6),
  311. SENSOR_ATTR_RO(fan7_fault, fan_fault, 6),
  312. SENSOR_ATTR_RO(fan7_alarm, fan_alarm, 6),
  313. SENSOR_ATTR_RO(fan8_input, fan_value, 7),
  314. SENSOR_ATTR_RO(fan8_fault, fan_fault, 7),
  315. SENSOR_ATTR_RO(fan8_alarm, fan_alarm, 7),
  316. };
  317. static int sch5636_remove(struct platform_device *pdev)
  318. {
  319. struct sch5636_data *data = platform_get_drvdata(pdev);
  320. int i;
  321. if (data->hwmon_dev)
  322. hwmon_device_unregister(data->hwmon_dev);
  323. for (i = 0; i < ARRAY_SIZE(sch5636_attr); i++)
  324. device_remove_file(&pdev->dev, &sch5636_attr[i].dev_attr);
  325. for (i = 0; i < SCH5636_NO_TEMPS * 3; i++)
  326. device_remove_file(&pdev->dev,
  327. &sch5636_temp_attr[i].dev_attr);
  328. for (i = 0; i < SCH5636_NO_FANS * 3; i++)
  329. device_remove_file(&pdev->dev,
  330. &sch5636_fan_attr[i].dev_attr);
  331. return 0;
  332. }
  333. static int sch5636_probe(struct platform_device *pdev)
  334. {
  335. struct sch5636_data *data;
  336. int i, err, val, revision[2];
  337. char id[4];
  338. data = devm_kzalloc(&pdev->dev, sizeof(struct sch5636_data),
  339. GFP_KERNEL);
  340. if (!data)
  341. return -ENOMEM;
  342. data->addr = platform_get_resource(pdev, IORESOURCE_IO, 0)->start;
  343. mutex_init(&data->update_lock);
  344. platform_set_drvdata(pdev, data);
  345. for (i = 0; i < 3; i++) {
  346. val = sch56xx_read_virtual_reg(data->addr,
  347. SCH5636_REG_FUJITSU_ID + i);
  348. if (val < 0) {
  349. pr_err("Could not read Fujitsu id byte at %#x\n",
  350. SCH5636_REG_FUJITSU_ID + i);
  351. err = val;
  352. goto error;
  353. }
  354. id[i] = val;
  355. }
  356. id[i] = '\0';
  357. if (strcmp(id, "THS")) {
  358. pr_err("Unknown Fujitsu id: %02x%02x%02x\n",
  359. id[0], id[1], id[2]);
  360. err = -ENODEV;
  361. goto error;
  362. }
  363. for (i = 0; i < 2; i++) {
  364. val = sch56xx_read_virtual_reg(data->addr,
  365. SCH5636_REG_FUJITSU_REV + i);
  366. if (val < 0) {
  367. err = val;
  368. goto error;
  369. }
  370. revision[i] = val;
  371. }
  372. pr_info("Found %s chip at %#hx, revision: %d.%02d\n", DEVNAME,
  373. data->addr, revision[0], revision[1]);
  374. /* Read all temp + fan ctrl registers to determine which are active */
  375. for (i = 0; i < SCH5636_NO_TEMPS; i++) {
  376. val = sch56xx_read_virtual_reg(data->addr,
  377. SCH5636_REG_TEMP_CTRL(i));
  378. if (unlikely(val < 0)) {
  379. err = val;
  380. goto error;
  381. }
  382. data->temp_ctrl[i] = val;
  383. }
  384. for (i = 0; i < SCH5636_NO_FANS; i++) {
  385. val = sch56xx_read_virtual_reg(data->addr,
  386. SCH5636_REG_FAN_CTRL(i));
  387. if (unlikely(val < 0)) {
  388. err = val;
  389. goto error;
  390. }
  391. data->fan_ctrl[i] = val;
  392. }
  393. for (i = 0; i < ARRAY_SIZE(sch5636_attr); i++) {
  394. err = device_create_file(&pdev->dev,
  395. &sch5636_attr[i].dev_attr);
  396. if (err)
  397. goto error;
  398. }
  399. for (i = 0; i < (SCH5636_NO_TEMPS * 3); i++) {
  400. if (data->temp_ctrl[i/3] & SCH5636_TEMP_DEACTIVATED)
  401. continue;
  402. err = device_create_file(&pdev->dev,
  403. &sch5636_temp_attr[i].dev_attr);
  404. if (err)
  405. goto error;
  406. }
  407. for (i = 0; i < (SCH5636_NO_FANS * 3); i++) {
  408. if (data->fan_ctrl[i/3] & SCH5636_FAN_DEACTIVATED)
  409. continue;
  410. err = device_create_file(&pdev->dev,
  411. &sch5636_fan_attr[i].dev_attr);
  412. if (err)
  413. goto error;
  414. }
  415. data->hwmon_dev = hwmon_device_register(&pdev->dev);
  416. if (IS_ERR(data->hwmon_dev)) {
  417. err = PTR_ERR(data->hwmon_dev);
  418. data->hwmon_dev = NULL;
  419. goto error;
  420. }
  421. /* Note failing to register the watchdog is not a fatal error */
  422. sch56xx_watchdog_register(&pdev->dev, data->addr, (revision[0] << 8) | revision[1],
  423. &data->update_lock, 0);
  424. return 0;
  425. error:
  426. sch5636_remove(pdev);
  427. return err;
  428. }
  429. static const struct platform_device_id sch5636_device_id[] = {
  430. {
  431. .name = "sch5636",
  432. },
  433. { }
  434. };
  435. MODULE_DEVICE_TABLE(platform, sch5636_device_id);
  436. static struct platform_driver sch5636_driver = {
  437. .driver = {
  438. .name = DRVNAME,
  439. },
  440. .probe = sch5636_probe,
  441. .remove = sch5636_remove,
  442. .id_table = sch5636_device_id,
  443. };
  444. module_platform_driver(sch5636_driver);
  445. MODULE_DESCRIPTION("SMSC SCH5636 Hardware Monitoring Driver");
  446. MODULE_AUTHOR("Hans de Goede <[email protected]>");
  447. MODULE_LICENSE("GPL");