smsc47m192.c 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * smsc47m192.c - Support for hardware monitoring block of
  4. * SMSC LPC47M192 and compatible Super I/O chips
  5. *
  6. * Copyright (C) 2006 Hartmut Rick <linux@rick.claranet.de>
  7. *
  8. * Derived from lm78.c and other chip drivers.
  9. */
  10. #include <linux/module.h>
  11. #include <linux/init.h>
  12. #include <linux/slab.h>
  13. #include <linux/jiffies.h>
  14. #include <linux/i2c.h>
  15. #include <linux/hwmon.h>
  16. #include <linux/hwmon-sysfs.h>
  17. #include <linux/hwmon-vid.h>
  18. #include <linux/err.h>
  19. #include <linux/sysfs.h>
  20. #include <linux/mutex.h>
  21. /* Addresses to scan */
  22. static const unsigned short normal_i2c[] = { 0x2c, 0x2d, I2C_CLIENT_END };
  23. /* SMSC47M192 registers */
  24. #define SMSC47M192_REG_IN(nr) ((nr) < 6 ? (0x20 + (nr)) : \
  25. (0x50 + (nr) - 6))
  26. #define SMSC47M192_REG_IN_MAX(nr) ((nr) < 6 ? (0x2b + (nr) * 2) : \
  27. (0x54 + (((nr) - 6) * 2)))
  28. #define SMSC47M192_REG_IN_MIN(nr) ((nr) < 6 ? (0x2c + (nr) * 2) : \
  29. (0x55 + (((nr) - 6) * 2)))
  30. static u8 SMSC47M192_REG_TEMP[3] = { 0x27, 0x26, 0x52 };
  31. static u8 SMSC47M192_REG_TEMP_MAX[3] = { 0x39, 0x37, 0x58 };
  32. static u8 SMSC47M192_REG_TEMP_MIN[3] = { 0x3A, 0x38, 0x59 };
  33. #define SMSC47M192_REG_TEMP_OFFSET(nr) ((nr) == 2 ? 0x1e : 0x1f)
  34. #define SMSC47M192_REG_ALARM1 0x41
  35. #define SMSC47M192_REG_ALARM2 0x42
  36. #define SMSC47M192_REG_VID 0x47
  37. #define SMSC47M192_REG_VID4 0x49
  38. #define SMSC47M192_REG_CONFIG 0x40
  39. #define SMSC47M192_REG_SFR 0x4f
  40. #define SMSC47M192_REG_COMPANY_ID 0x3e
  41. #define SMSC47M192_REG_VERSION 0x3f
  42. /* generalised scaling with integer rounding */
  43. static inline int SCALE(long val, int mul, int div)
  44. {
  45. if (val < 0)
  46. return (val * mul - div / 2) / div;
  47. else
  48. return (val * mul + div / 2) / div;
  49. }
  50. /* Conversions */
  51. /* smsc47m192 internally scales voltage measurements */
  52. static const u16 nom_mv[] = { 2500, 2250, 3300, 5000, 12000, 3300, 1500, 1800 };
  53. static inline unsigned int IN_FROM_REG(u8 reg, int n)
  54. {
  55. return SCALE(reg, nom_mv[n], 192);
  56. }
  57. static inline u8 IN_TO_REG(unsigned long val, int n)
  58. {
  59. val = clamp_val(val, 0, nom_mv[n] * 255 / 192);
  60. return SCALE(val, 192, nom_mv[n]);
  61. }
  62. /*
  63. * TEMP: 0.001 degC units (-128C to +127C)
  64. * REG: 1C/bit, two's complement
  65. */
  66. static inline s8 TEMP_TO_REG(long val)
  67. {
  68. return SCALE(clamp_val(val, -128000, 127000), 1, 1000);
  69. }
  70. static inline int TEMP_FROM_REG(s8 val)
  71. {
  72. return val * 1000;
  73. }
  74. struct smsc47m192_data {
  75. struct i2c_client *client;
  76. const struct attribute_group *groups[3];
  77. struct mutex update_lock;
  78. char valid; /* !=0 if following fields are valid */
  79. unsigned long last_updated; /* In jiffies */
  80. u8 in[8]; /* Register value */
  81. u8 in_max[8]; /* Register value */
  82. u8 in_min[8]; /* Register value */
  83. s8 temp[3]; /* Register value */
  84. s8 temp_max[3]; /* Register value */
  85. s8 temp_min[3]; /* Register value */
  86. s8 temp_offset[3]; /* Register value */
  87. u16 alarms; /* Register encoding, combined */
  88. u8 vid; /* Register encoding, combined */
  89. u8 vrm;
  90. };
  91. static struct smsc47m192_data *smsc47m192_update_device(struct device *dev)
  92. {
  93. struct smsc47m192_data *data = dev_get_drvdata(dev);
  94. struct i2c_client *client = data->client;
  95. int i, config;
  96. mutex_lock(&data->update_lock);
  97. if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
  98. || !data->valid) {
  99. u8 sfr = i2c_smbus_read_byte_data(client, SMSC47M192_REG_SFR);
  100. dev_dbg(&client->dev, "Starting smsc47m192 update\n");
  101. for (i = 0; i <= 7; i++) {
  102. data->in[i] = i2c_smbus_read_byte_data(client,
  103. SMSC47M192_REG_IN(i));
  104. data->in_min[i] = i2c_smbus_read_byte_data(client,
  105. SMSC47M192_REG_IN_MIN(i));
  106. data->in_max[i] = i2c_smbus_read_byte_data(client,
  107. SMSC47M192_REG_IN_MAX(i));
  108. }
  109. for (i = 0; i < 3; i++) {
  110. data->temp[i] = i2c_smbus_read_byte_data(client,
  111. SMSC47M192_REG_TEMP[i]);
  112. data->temp_max[i] = i2c_smbus_read_byte_data(client,
  113. SMSC47M192_REG_TEMP_MAX[i]);
  114. data->temp_min[i] = i2c_smbus_read_byte_data(client,
  115. SMSC47M192_REG_TEMP_MIN[i]);
  116. }
  117. for (i = 1; i < 3; i++)
  118. data->temp_offset[i] = i2c_smbus_read_byte_data(client,
  119. SMSC47M192_REG_TEMP_OFFSET(i));
  120. /*
  121. * first offset is temp_offset[0] if SFR bit 4 is set,
  122. * temp_offset[1] otherwise
  123. */
  124. if (sfr & 0x10) {
  125. data->temp_offset[0] = data->temp_offset[1];
  126. data->temp_offset[1] = 0;
  127. } else
  128. data->temp_offset[0] = 0;
  129. data->vid = i2c_smbus_read_byte_data(client, SMSC47M192_REG_VID)
  130. & 0x0f;
  131. config = i2c_smbus_read_byte_data(client,
  132. SMSC47M192_REG_CONFIG);
  133. if (config & 0x20)
  134. data->vid |= (i2c_smbus_read_byte_data(client,
  135. SMSC47M192_REG_VID4) & 0x01) << 4;
  136. data->alarms = i2c_smbus_read_byte_data(client,
  137. SMSC47M192_REG_ALARM1) |
  138. (i2c_smbus_read_byte_data(client,
  139. SMSC47M192_REG_ALARM2) << 8);
  140. data->last_updated = jiffies;
  141. data->valid = 1;
  142. }
  143. mutex_unlock(&data->update_lock);
  144. return data;
  145. }
  146. /* Voltages */
  147. static ssize_t in_show(struct device *dev, struct device_attribute *attr,
  148. char *buf)
  149. {
  150. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  151. int nr = sensor_attr->index;
  152. struct smsc47m192_data *data = smsc47m192_update_device(dev);
  153. return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr], nr));
  154. }
  155. static ssize_t in_min_show(struct device *dev, struct device_attribute *attr,
  156. char *buf)
  157. {
  158. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  159. int nr = sensor_attr->index;
  160. struct smsc47m192_data *data = smsc47m192_update_device(dev);
  161. return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr], nr));
  162. }
  163. static ssize_t in_max_show(struct device *dev, struct device_attribute *attr,
  164. char *buf)
  165. {
  166. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  167. int nr = sensor_attr->index;
  168. struct smsc47m192_data *data = smsc47m192_update_device(dev);
  169. return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr], nr));
  170. }
  171. static ssize_t in_min_store(struct device *dev, struct device_attribute *attr,
  172. const char *buf, size_t count)
  173. {
  174. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  175. int nr = sensor_attr->index;
  176. struct smsc47m192_data *data = dev_get_drvdata(dev);
  177. struct i2c_client *client = data->client;
  178. unsigned long val;
  179. int err;
  180. err = kstrtoul(buf, 10, &val);
  181. if (err)
  182. return err;
  183. mutex_lock(&data->update_lock);
  184. data->in_min[nr] = IN_TO_REG(val, nr);
  185. i2c_smbus_write_byte_data(client, SMSC47M192_REG_IN_MIN(nr),
  186. data->in_min[nr]);
  187. mutex_unlock(&data->update_lock);
  188. return count;
  189. }
  190. static ssize_t in_max_store(struct device *dev, struct device_attribute *attr,
  191. const char *buf, size_t count)
  192. {
  193. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  194. int nr = sensor_attr->index;
  195. struct smsc47m192_data *data = dev_get_drvdata(dev);
  196. struct i2c_client *client = data->client;
  197. unsigned long val;
  198. int err;
  199. err = kstrtoul(buf, 10, &val);
  200. if (err)
  201. return err;
  202. mutex_lock(&data->update_lock);
  203. data->in_max[nr] = IN_TO_REG(val, nr);
  204. i2c_smbus_write_byte_data(client, SMSC47M192_REG_IN_MAX(nr),
  205. data->in_max[nr]);
  206. mutex_unlock(&data->update_lock);
  207. return count;
  208. }
  209. static SENSOR_DEVICE_ATTR_RO(in0_input, in, 0);
  210. static SENSOR_DEVICE_ATTR_RW(in0_min, in_min, 0);
  211. static SENSOR_DEVICE_ATTR_RW(in0_max, in_max, 0);
  212. static SENSOR_DEVICE_ATTR_RO(in1_input, in, 1);
  213. static SENSOR_DEVICE_ATTR_RW(in1_min, in_min, 1);
  214. static SENSOR_DEVICE_ATTR_RW(in1_max, in_max, 1);
  215. static SENSOR_DEVICE_ATTR_RO(in2_input, in, 2);
  216. static SENSOR_DEVICE_ATTR_RW(in2_min, in_min, 2);
  217. static SENSOR_DEVICE_ATTR_RW(in2_max, in_max, 2);
  218. static SENSOR_DEVICE_ATTR_RO(in3_input, in, 3);
  219. static SENSOR_DEVICE_ATTR_RW(in3_min, in_min, 3);
  220. static SENSOR_DEVICE_ATTR_RW(in3_max, in_max, 3);
  221. static SENSOR_DEVICE_ATTR_RO(in4_input, in, 4);
  222. static SENSOR_DEVICE_ATTR_RW(in4_min, in_min, 4);
  223. static SENSOR_DEVICE_ATTR_RW(in4_max, in_max, 4);
  224. static SENSOR_DEVICE_ATTR_RO(in5_input, in, 5);
  225. static SENSOR_DEVICE_ATTR_RW(in5_min, in_min, 5);
  226. static SENSOR_DEVICE_ATTR_RW(in5_max, in_max, 5);
  227. static SENSOR_DEVICE_ATTR_RO(in6_input, in, 6);
  228. static SENSOR_DEVICE_ATTR_RW(in6_min, in_min, 6);
  229. static SENSOR_DEVICE_ATTR_RW(in6_max, in_max, 6);
  230. static SENSOR_DEVICE_ATTR_RO(in7_input, in, 7);
  231. static SENSOR_DEVICE_ATTR_RW(in7_min, in_min, 7);
  232. static SENSOR_DEVICE_ATTR_RW(in7_max, in_max, 7);
  233. /* Temperatures */
  234. static ssize_t temp_show(struct device *dev, struct device_attribute *attr,
  235. char *buf)
  236. {
  237. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  238. int nr = sensor_attr->index;
  239. struct smsc47m192_data *data = smsc47m192_update_device(dev);
  240. return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[nr]));
  241. }
  242. static ssize_t temp_min_show(struct device *dev,
  243. struct device_attribute *attr, char *buf)
  244. {
  245. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  246. int nr = sensor_attr->index;
  247. struct smsc47m192_data *data = smsc47m192_update_device(dev);
  248. return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr]));
  249. }
  250. static ssize_t temp_max_show(struct device *dev,
  251. struct device_attribute *attr, char *buf)
  252. {
  253. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  254. int nr = sensor_attr->index;
  255. struct smsc47m192_data *data = smsc47m192_update_device(dev);
  256. return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr]));
  257. }
  258. static ssize_t temp_min_store(struct device *dev,
  259. struct device_attribute *attr, const char *buf,
  260. size_t count)
  261. {
  262. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  263. int nr = sensor_attr->index;
  264. struct smsc47m192_data *data = dev_get_drvdata(dev);
  265. struct i2c_client *client = data->client;
  266. long val;
  267. int err;
  268. err = kstrtol(buf, 10, &val);
  269. if (err)
  270. return err;
  271. mutex_lock(&data->update_lock);
  272. data->temp_min[nr] = TEMP_TO_REG(val);
  273. i2c_smbus_write_byte_data(client, SMSC47M192_REG_TEMP_MIN[nr],
  274. data->temp_min[nr]);
  275. mutex_unlock(&data->update_lock);
  276. return count;
  277. }
  278. static ssize_t temp_max_store(struct device *dev,
  279. struct device_attribute *attr, const char *buf,
  280. size_t count)
  281. {
  282. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  283. int nr = sensor_attr->index;
  284. struct smsc47m192_data *data = dev_get_drvdata(dev);
  285. struct i2c_client *client = data->client;
  286. long val;
  287. int err;
  288. err = kstrtol(buf, 10, &val);
  289. if (err)
  290. return err;
  291. mutex_lock(&data->update_lock);
  292. data->temp_max[nr] = TEMP_TO_REG(val);
  293. i2c_smbus_write_byte_data(client, SMSC47M192_REG_TEMP_MAX[nr],
  294. data->temp_max[nr]);
  295. mutex_unlock(&data->update_lock);
  296. return count;
  297. }
  298. static ssize_t temp_offset_show(struct device *dev,
  299. struct device_attribute *attr, char *buf)
  300. {
  301. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  302. int nr = sensor_attr->index;
  303. struct smsc47m192_data *data = smsc47m192_update_device(dev);
  304. return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_offset[nr]));
  305. }
  306. static ssize_t temp_offset_store(struct device *dev,
  307. struct device_attribute *attr,
  308. const char *buf, size_t count)
  309. {
  310. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  311. int nr = sensor_attr->index;
  312. struct smsc47m192_data *data = dev_get_drvdata(dev);
  313. struct i2c_client *client = data->client;
  314. u8 sfr = i2c_smbus_read_byte_data(client, SMSC47M192_REG_SFR);
  315. long val;
  316. int err;
  317. err = kstrtol(buf, 10, &val);
  318. if (err)
  319. return err;
  320. mutex_lock(&data->update_lock);
  321. data->temp_offset[nr] = TEMP_TO_REG(val);
  322. if (nr > 1)
  323. i2c_smbus_write_byte_data(client,
  324. SMSC47M192_REG_TEMP_OFFSET(nr), data->temp_offset[nr]);
  325. else if (data->temp_offset[nr] != 0) {
  326. /*
  327. * offset[0] and offset[1] share the same register,
  328. * SFR bit 4 activates offset[0]
  329. */
  330. i2c_smbus_write_byte_data(client, SMSC47M192_REG_SFR,
  331. (sfr & 0xef) | (nr == 0 ? 0x10 : 0));
  332. data->temp_offset[1-nr] = 0;
  333. i2c_smbus_write_byte_data(client,
  334. SMSC47M192_REG_TEMP_OFFSET(nr), data->temp_offset[nr]);
  335. } else if ((sfr & 0x10) == (nr == 0 ? 0x10 : 0))
  336. i2c_smbus_write_byte_data(client,
  337. SMSC47M192_REG_TEMP_OFFSET(nr), 0);
  338. mutex_unlock(&data->update_lock);
  339. return count;
  340. }
  341. static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0);
  342. static SENSOR_DEVICE_ATTR_RW(temp1_min, temp_min, 0);
  343. static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0);
  344. static SENSOR_DEVICE_ATTR_RW(temp1_offset, temp_offset, 0);
  345. static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1);
  346. static SENSOR_DEVICE_ATTR_RW(temp2_min, temp_min, 1);
  347. static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);
  348. static SENSOR_DEVICE_ATTR_RW(temp2_offset, temp_offset, 1);
  349. static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2);
  350. static SENSOR_DEVICE_ATTR_RW(temp3_min, temp_min, 2);
  351. static SENSOR_DEVICE_ATTR_RW(temp3_max, temp_max, 2);
  352. static SENSOR_DEVICE_ATTR_RW(temp3_offset, temp_offset, 2);
  353. /* VID */
  354. static ssize_t cpu0_vid_show(struct device *dev,
  355. struct device_attribute *attr, char *buf)
  356. {
  357. struct smsc47m192_data *data = smsc47m192_update_device(dev);
  358. return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
  359. }
  360. static DEVICE_ATTR_RO(cpu0_vid);
  361. static ssize_t vrm_show(struct device *dev, struct device_attribute *attr,
  362. char *buf)
  363. {
  364. struct smsc47m192_data *data = dev_get_drvdata(dev);
  365. return sprintf(buf, "%d\n", data->vrm);
  366. }
  367. static ssize_t vrm_store(struct device *dev, struct device_attribute *attr,
  368. const char *buf, size_t count)
  369. {
  370. struct smsc47m192_data *data = dev_get_drvdata(dev);
  371. unsigned long val;
  372. int err;
  373. err = kstrtoul(buf, 10, &val);
  374. if (err)
  375. return err;
  376. if (val > 255)
  377. return -EINVAL;
  378. data->vrm = val;
  379. return count;
  380. }
  381. static DEVICE_ATTR_RW(vrm);
  382. /* Alarms */
  383. static ssize_t alarm_show(struct device *dev, struct device_attribute *attr,
  384. char *buf)
  385. {
  386. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  387. int nr = sensor_attr->index;
  388. struct smsc47m192_data *data = smsc47m192_update_device(dev);
  389. return sprintf(buf, "%u\n", (data->alarms & nr) ? 1 : 0);
  390. }
  391. static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm, 0x0010);
  392. static SENSOR_DEVICE_ATTR_RO(temp2_alarm, alarm, 0x0020);
  393. static SENSOR_DEVICE_ATTR_RO(temp3_alarm, alarm, 0x0040);
  394. static SENSOR_DEVICE_ATTR_RO(temp2_fault, alarm, 0x4000);
  395. static SENSOR_DEVICE_ATTR_RO(temp3_fault, alarm, 0x8000);
  396. static SENSOR_DEVICE_ATTR_RO(in0_alarm, alarm, 0x0001);
  397. static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm, 0x0002);
  398. static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm, 0x0004);
  399. static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm, 0x0008);
  400. static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm, 0x0100);
  401. static SENSOR_DEVICE_ATTR_RO(in5_alarm, alarm, 0x0200);
  402. static SENSOR_DEVICE_ATTR_RO(in6_alarm, alarm, 0x0400);
  403. static SENSOR_DEVICE_ATTR_RO(in7_alarm, alarm, 0x0800);
  404. static struct attribute *smsc47m192_attributes[] = {
  405. &sensor_dev_attr_in0_input.dev_attr.attr,
  406. &sensor_dev_attr_in0_min.dev_attr.attr,
  407. &sensor_dev_attr_in0_max.dev_attr.attr,
  408. &sensor_dev_attr_in0_alarm.dev_attr.attr,
  409. &sensor_dev_attr_in1_input.dev_attr.attr,
  410. &sensor_dev_attr_in1_min.dev_attr.attr,
  411. &sensor_dev_attr_in1_max.dev_attr.attr,
  412. &sensor_dev_attr_in1_alarm.dev_attr.attr,
  413. &sensor_dev_attr_in2_input.dev_attr.attr,
  414. &sensor_dev_attr_in2_min.dev_attr.attr,
  415. &sensor_dev_attr_in2_max.dev_attr.attr,
  416. &sensor_dev_attr_in2_alarm.dev_attr.attr,
  417. &sensor_dev_attr_in3_input.dev_attr.attr,
  418. &sensor_dev_attr_in3_min.dev_attr.attr,
  419. &sensor_dev_attr_in3_max.dev_attr.attr,
  420. &sensor_dev_attr_in3_alarm.dev_attr.attr,
  421. &sensor_dev_attr_in5_input.dev_attr.attr,
  422. &sensor_dev_attr_in5_min.dev_attr.attr,
  423. &sensor_dev_attr_in5_max.dev_attr.attr,
  424. &sensor_dev_attr_in5_alarm.dev_attr.attr,
  425. &sensor_dev_attr_in6_input.dev_attr.attr,
  426. &sensor_dev_attr_in6_min.dev_attr.attr,
  427. &sensor_dev_attr_in6_max.dev_attr.attr,
  428. &sensor_dev_attr_in6_alarm.dev_attr.attr,
  429. &sensor_dev_attr_in7_input.dev_attr.attr,
  430. &sensor_dev_attr_in7_min.dev_attr.attr,
  431. &sensor_dev_attr_in7_max.dev_attr.attr,
  432. &sensor_dev_attr_in7_alarm.dev_attr.attr,
  433. &sensor_dev_attr_temp1_input.dev_attr.attr,
  434. &sensor_dev_attr_temp1_max.dev_attr.attr,
  435. &sensor_dev_attr_temp1_min.dev_attr.attr,
  436. &sensor_dev_attr_temp1_offset.dev_attr.attr,
  437. &sensor_dev_attr_temp1_alarm.dev_attr.attr,
  438. &sensor_dev_attr_temp2_input.dev_attr.attr,
  439. &sensor_dev_attr_temp2_max.dev_attr.attr,
  440. &sensor_dev_attr_temp2_min.dev_attr.attr,
  441. &sensor_dev_attr_temp2_offset.dev_attr.attr,
  442. &sensor_dev_attr_temp2_alarm.dev_attr.attr,
  443. &sensor_dev_attr_temp2_fault.dev_attr.attr,
  444. &sensor_dev_attr_temp3_input.dev_attr.attr,
  445. &sensor_dev_attr_temp3_max.dev_attr.attr,
  446. &sensor_dev_attr_temp3_min.dev_attr.attr,
  447. &sensor_dev_attr_temp3_offset.dev_attr.attr,
  448. &sensor_dev_attr_temp3_alarm.dev_attr.attr,
  449. &sensor_dev_attr_temp3_fault.dev_attr.attr,
  450. &dev_attr_cpu0_vid.attr,
  451. &dev_attr_vrm.attr,
  452. NULL
  453. };
  454. static const struct attribute_group smsc47m192_group = {
  455. .attrs = smsc47m192_attributes,
  456. };
  457. static struct attribute *smsc47m192_attributes_in4[] = {
  458. &sensor_dev_attr_in4_input.dev_attr.attr,
  459. &sensor_dev_attr_in4_min.dev_attr.attr,
  460. &sensor_dev_attr_in4_max.dev_attr.attr,
  461. &sensor_dev_attr_in4_alarm.dev_attr.attr,
  462. NULL
  463. };
  464. static const struct attribute_group smsc47m192_group_in4 = {
  465. .attrs = smsc47m192_attributes_in4,
  466. };
  467. static void smsc47m192_init_client(struct i2c_client *client)
  468. {
  469. int i;
  470. u8 config = i2c_smbus_read_byte_data(client, SMSC47M192_REG_CONFIG);
  471. u8 sfr = i2c_smbus_read_byte_data(client, SMSC47M192_REG_SFR);
  472. /* select cycle mode (pause 1 sec between updates) */
  473. i2c_smbus_write_byte_data(client, SMSC47M192_REG_SFR,
  474. (sfr & 0xfd) | 0x02);
  475. if (!(config & 0x01)) {
  476. /* initialize alarm limits */
  477. for (i = 0; i < 8; i++) {
  478. i2c_smbus_write_byte_data(client,
  479. SMSC47M192_REG_IN_MIN(i), 0);
  480. i2c_smbus_write_byte_data(client,
  481. SMSC47M192_REG_IN_MAX(i), 0xff);
  482. }
  483. for (i = 0; i < 3; i++) {
  484. i2c_smbus_write_byte_data(client,
  485. SMSC47M192_REG_TEMP_MIN[i], 0x80);
  486. i2c_smbus_write_byte_data(client,
  487. SMSC47M192_REG_TEMP_MAX[i], 0x7f);
  488. }
  489. /* start monitoring */
  490. i2c_smbus_write_byte_data(client, SMSC47M192_REG_CONFIG,
  491. (config & 0xf7) | 0x01);
  492. }
  493. }
  494. /* Return 0 if detection is successful, -ENODEV otherwise */
  495. static int smsc47m192_detect(struct i2c_client *client,
  496. struct i2c_board_info *info)
  497. {
  498. struct i2c_adapter *adapter = client->adapter;
  499. int version;
  500. if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
  501. return -ENODEV;
  502. /* Detection criteria from sensors_detect script */
  503. version = i2c_smbus_read_byte_data(client, SMSC47M192_REG_VERSION);
  504. if (i2c_smbus_read_byte_data(client,
  505. SMSC47M192_REG_COMPANY_ID) == 0x55
  506. && (version & 0xf0) == 0x20
  507. && (i2c_smbus_read_byte_data(client,
  508. SMSC47M192_REG_VID) & 0x70) == 0x00
  509. && (i2c_smbus_read_byte_data(client,
  510. SMSC47M192_REG_VID4) & 0xfe) == 0x80) {
  511. dev_info(&adapter->dev,
  512. "found SMSC47M192 or compatible, "
  513. "version 2, stepping A%d\n", version & 0x0f);
  514. } else {
  515. dev_dbg(&adapter->dev,
  516. "SMSC47M192 detection failed at 0x%02x\n",
  517. client->addr);
  518. return -ENODEV;
  519. }
  520. strlcpy(info->type, "smsc47m192", I2C_NAME_SIZE);
  521. return 0;
  522. }
  523. static int smsc47m192_probe(struct i2c_client *client)
  524. {
  525. struct device *dev = &client->dev;
  526. struct device *hwmon_dev;
  527. struct smsc47m192_data *data;
  528. int config;
  529. data = devm_kzalloc(dev, sizeof(struct smsc47m192_data), GFP_KERNEL);
  530. if (!data)
  531. return -ENOMEM;
  532. data->client = client;
  533. data->vrm = vid_which_vrm();
  534. mutex_init(&data->update_lock);
  535. /* Initialize the SMSC47M192 chip */
  536. smsc47m192_init_client(client);
  537. /* sysfs hooks */
  538. data->groups[0] = &smsc47m192_group;
  539. /* Pin 110 is either in4 (+12V) or VID4 */
  540. config = i2c_smbus_read_byte_data(client, SMSC47M192_REG_CONFIG);
  541. if (!(config & 0x20))
  542. data->groups[1] = &smsc47m192_group_in4;
  543. hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
  544. data, data->groups);
  545. return PTR_ERR_OR_ZERO(hwmon_dev);
  546. }
  547. static const struct i2c_device_id smsc47m192_id[] = {
  548. { "smsc47m192", 0 },
  549. { }
  550. };
  551. MODULE_DEVICE_TABLE(i2c, smsc47m192_id);
  552. static struct i2c_driver smsc47m192_driver = {
  553. .class = I2C_CLASS_HWMON,
  554. .driver = {
  555. .name = "smsc47m192",
  556. },
  557. .probe_new = smsc47m192_probe,
  558. .id_table = smsc47m192_id,
  559. .detect = smsc47m192_detect,
  560. .address_list = normal_i2c,
  561. };
  562. module_i2c_driver(smsc47m192_driver);
  563. MODULE_AUTHOR("Hartmut Rick <linux@rick.claranet.de>");
  564. MODULE_DESCRIPTION("SMSC47M192 driver");
  565. MODULE_LICENSE("GPL");