nct7802.c 33 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * nct7802 - Driver for Nuvoton NCT7802Y
  4. *
  5. * Copyright (C) 2014 Guenter Roeck <linux@roeck-us.net>
  6. */
  7. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  8. #include <linux/err.h>
  9. #include <linux/i2c.h>
  10. #include <linux/init.h>
  11. #include <linux/hwmon.h>
  12. #include <linux/hwmon-sysfs.h>
  13. #include <linux/jiffies.h>
  14. #include <linux/module.h>
  15. #include <linux/mutex.h>
  16. #include <linux/regmap.h>
  17. #include <linux/slab.h>
  18. #define DRVNAME "nct7802"
  19. static const u8 REG_VOLTAGE[5] = { 0x09, 0x0a, 0x0c, 0x0d, 0x0e };
  20. static const u8 REG_VOLTAGE_LIMIT_LSB[2][5] = {
  21. { 0x46, 0x00, 0x40, 0x42, 0x44 },
  22. { 0x45, 0x00, 0x3f, 0x41, 0x43 },
  23. };
  24. static const u8 REG_VOLTAGE_LIMIT_MSB[5] = { 0x48, 0x00, 0x47, 0x47, 0x48 };
  25. static const u8 REG_VOLTAGE_LIMIT_MSB_SHIFT[2][5] = {
  26. { 0, 0, 4, 0, 4 },
  27. { 2, 0, 6, 2, 6 },
  28. };
  29. #define REG_BANK 0x00
  30. #define REG_TEMP_LSB 0x05
  31. #define REG_TEMP_PECI_LSB 0x08
  32. #define REG_VOLTAGE_LOW 0x0f
  33. #define REG_FANCOUNT_LOW 0x13
  34. #define REG_START 0x21
  35. #define REG_MODE 0x22 /* 7.2.32 Mode Selection Register */
  36. #define REG_PECI_ENABLE 0x23
  37. #define REG_FAN_ENABLE 0x24
  38. #define REG_VMON_ENABLE 0x25
  39. #define REG_PWM(x) (0x60 + (x))
  40. #define REG_SMARTFAN_EN(x) (0x64 + (x) / 2)
  41. #define SMARTFAN_EN_SHIFT(x) ((x) % 2 * 4)
  42. #define REG_VENDOR_ID 0xfd
  43. #define REG_CHIP_ID 0xfe
  44. #define REG_VERSION_ID 0xff
  45. /*
  46. * Data structures and manipulation thereof
  47. */
  48. struct nct7802_data {
  49. struct regmap *regmap;
  50. struct mutex access_lock; /* for multi-byte read and write operations */
  51. u8 in_status;
  52. struct mutex in_alarm_lock;
  53. };
  54. static ssize_t temp_type_show(struct device *dev,
  55. struct device_attribute *attr, char *buf)
  56. {
  57. struct nct7802_data *data = dev_get_drvdata(dev);
  58. struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
  59. unsigned int mode;
  60. int ret;
  61. ret = regmap_read(data->regmap, REG_MODE, &mode);
  62. if (ret < 0)
  63. return ret;
  64. return sprintf(buf, "%u\n", (mode >> (2 * sattr->index) & 3) + 2);
  65. }
  66. static ssize_t temp_type_store(struct device *dev,
  67. struct device_attribute *attr, const char *buf,
  68. size_t count)
  69. {
  70. struct nct7802_data *data = dev_get_drvdata(dev);
  71. struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
  72. unsigned int type;
  73. int err;
  74. err = kstrtouint(buf, 0, &type);
  75. if (err < 0)
  76. return err;
  77. if (sattr->index == 2 && type != 4) /* RD3 */
  78. return -EINVAL;
  79. if (type < 3 || type > 4)
  80. return -EINVAL;
  81. err = regmap_update_bits(data->regmap, REG_MODE,
  82. 3 << 2 * sattr->index, (type - 2) << 2 * sattr->index);
  83. return err ? : count;
  84. }
  85. static ssize_t pwm_mode_show(struct device *dev,
  86. struct device_attribute *attr, char *buf)
  87. {
  88. struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
  89. struct nct7802_data *data = dev_get_drvdata(dev);
  90. unsigned int regval;
  91. int ret;
  92. if (sattr->index > 1)
  93. return sprintf(buf, "1\n");
  94. ret = regmap_read(data->regmap, 0x5E, &regval);
  95. if (ret < 0)
  96. return ret;
  97. return sprintf(buf, "%u\n", !(regval & (1 << sattr->index)));
  98. }
  99. static ssize_t pwm_show(struct device *dev, struct device_attribute *devattr,
  100. char *buf)
  101. {
  102. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  103. struct nct7802_data *data = dev_get_drvdata(dev);
  104. unsigned int val;
  105. int ret;
  106. if (!attr->index)
  107. return sprintf(buf, "255\n");
  108. ret = regmap_read(data->regmap, attr->index, &val);
  109. if (ret < 0)
  110. return ret;
  111. return sprintf(buf, "%d\n", val);
  112. }
  113. static ssize_t pwm_store(struct device *dev, struct device_attribute *devattr,
  114. const char *buf, size_t count)
  115. {
  116. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  117. struct nct7802_data *data = dev_get_drvdata(dev);
  118. int err;
  119. u8 val;
  120. err = kstrtou8(buf, 0, &val);
  121. if (err < 0)
  122. return err;
  123. err = regmap_write(data->regmap, attr->index, val);
  124. return err ? : count;
  125. }
  126. static ssize_t pwm_enable_show(struct device *dev,
  127. struct device_attribute *attr, char *buf)
  128. {
  129. struct nct7802_data *data = dev_get_drvdata(dev);
  130. struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
  131. unsigned int reg, enabled;
  132. int ret;
  133. ret = regmap_read(data->regmap, REG_SMARTFAN_EN(sattr->index), &reg);
  134. if (ret < 0)
  135. return ret;
  136. enabled = reg >> SMARTFAN_EN_SHIFT(sattr->index) & 1;
  137. return sprintf(buf, "%u\n", enabled + 1);
  138. }
  139. static ssize_t pwm_enable_store(struct device *dev,
  140. struct device_attribute *attr,
  141. const char *buf, size_t count)
  142. {
  143. struct nct7802_data *data = dev_get_drvdata(dev);
  144. struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
  145. u8 val;
  146. int ret;
  147. ret = kstrtou8(buf, 0, &val);
  148. if (ret < 0)
  149. return ret;
  150. if (val < 1 || val > 2)
  151. return -EINVAL;
  152. ret = regmap_update_bits(data->regmap, REG_SMARTFAN_EN(sattr->index),
  153. 1 << SMARTFAN_EN_SHIFT(sattr->index),
  154. (val - 1) << SMARTFAN_EN_SHIFT(sattr->index));
  155. return ret ? : count;
  156. }
  157. static int nct7802_read_temp(struct nct7802_data *data,
  158. u8 reg_temp, u8 reg_temp_low, int *temp)
  159. {
  160. unsigned int t1, t2 = 0;
  161. int err;
  162. *temp = 0;
  163. mutex_lock(&data->access_lock);
  164. err = regmap_read(data->regmap, reg_temp, &t1);
  165. if (err < 0)
  166. goto abort;
  167. t1 <<= 8;
  168. if (reg_temp_low) { /* 11 bit data */
  169. err = regmap_read(data->regmap, reg_temp_low, &t2);
  170. if (err < 0)
  171. goto abort;
  172. }
  173. t1 |= t2 & 0xe0;
  174. *temp = (s16)t1 / 32 * 125;
  175. abort:
  176. mutex_unlock(&data->access_lock);
  177. return err;
  178. }
  179. static int nct7802_read_fan(struct nct7802_data *data, u8 reg_fan)
  180. {
  181. unsigned int f1, f2;
  182. int ret;
  183. mutex_lock(&data->access_lock);
  184. ret = regmap_read(data->regmap, reg_fan, &f1);
  185. if (ret < 0)
  186. goto abort;
  187. ret = regmap_read(data->regmap, REG_FANCOUNT_LOW, &f2);
  188. if (ret < 0)
  189. goto abort;
  190. ret = (f1 << 5) | (f2 >> 3);
  191. /* convert fan count to rpm */
  192. if (ret == 0x1fff) /* maximum value, assume fan is stopped */
  193. ret = 0;
  194. else if (ret)
  195. ret = DIV_ROUND_CLOSEST(1350000U, ret);
  196. abort:
  197. mutex_unlock(&data->access_lock);
  198. return ret;
  199. }
  200. static int nct7802_read_fan_min(struct nct7802_data *data, u8 reg_fan_low,
  201. u8 reg_fan_high)
  202. {
  203. unsigned int f1, f2;
  204. int ret;
  205. mutex_lock(&data->access_lock);
  206. ret = regmap_read(data->regmap, reg_fan_low, &f1);
  207. if (ret < 0)
  208. goto abort;
  209. ret = regmap_read(data->regmap, reg_fan_high, &f2);
  210. if (ret < 0)
  211. goto abort;
  212. ret = f1 | ((f2 & 0xf8) << 5);
  213. /* convert fan count to rpm */
  214. if (ret == 0x1fff) /* maximum value, assume no limit */
  215. ret = 0;
  216. else if (ret)
  217. ret = DIV_ROUND_CLOSEST(1350000U, ret);
  218. else
  219. ret = 1350000U;
  220. abort:
  221. mutex_unlock(&data->access_lock);
  222. return ret;
  223. }
  224. static int nct7802_write_fan_min(struct nct7802_data *data, u8 reg_fan_low,
  225. u8 reg_fan_high, unsigned long limit)
  226. {
  227. int err;
  228. if (limit)
  229. limit = DIV_ROUND_CLOSEST(1350000U, limit);
  230. else
  231. limit = 0x1fff;
  232. limit = clamp_val(limit, 0, 0x1fff);
  233. mutex_lock(&data->access_lock);
  234. err = regmap_write(data->regmap, reg_fan_low, limit & 0xff);
  235. if (err < 0)
  236. goto abort;
  237. err = regmap_write(data->regmap, reg_fan_high, (limit & 0x1f00) >> 5);
  238. abort:
  239. mutex_unlock(&data->access_lock);
  240. return err;
  241. }
  242. static u8 nct7802_vmul[] = { 4, 2, 2, 2, 2 };
  243. static int nct7802_read_voltage(struct nct7802_data *data, int nr, int index)
  244. {
  245. unsigned int v1, v2;
  246. int ret;
  247. mutex_lock(&data->access_lock);
  248. if (index == 0) { /* voltage */
  249. ret = regmap_read(data->regmap, REG_VOLTAGE[nr], &v1);
  250. if (ret < 0)
  251. goto abort;
  252. ret = regmap_read(data->regmap, REG_VOLTAGE_LOW, &v2);
  253. if (ret < 0)
  254. goto abort;
  255. ret = ((v1 << 2) | (v2 >> 6)) * nct7802_vmul[nr];
  256. } else { /* limit */
  257. int shift = 8 - REG_VOLTAGE_LIMIT_MSB_SHIFT[index - 1][nr];
  258. ret = regmap_read(data->regmap,
  259. REG_VOLTAGE_LIMIT_LSB[index - 1][nr], &v1);
  260. if (ret < 0)
  261. goto abort;
  262. ret = regmap_read(data->regmap, REG_VOLTAGE_LIMIT_MSB[nr],
  263. &v2);
  264. if (ret < 0)
  265. goto abort;
  266. ret = (v1 | ((v2 << shift) & 0x300)) * nct7802_vmul[nr];
  267. }
  268. abort:
  269. mutex_unlock(&data->access_lock);
  270. return ret;
  271. }
  272. static int nct7802_write_voltage(struct nct7802_data *data, int nr, int index,
  273. unsigned long voltage)
  274. {
  275. int shift = 8 - REG_VOLTAGE_LIMIT_MSB_SHIFT[index - 1][nr];
  276. int err;
  277. voltage = clamp_val(voltage, 0, 0x3ff * nct7802_vmul[nr]);
  278. voltage = DIV_ROUND_CLOSEST(voltage, nct7802_vmul[nr]);
  279. mutex_lock(&data->access_lock);
  280. err = regmap_write(data->regmap,
  281. REG_VOLTAGE_LIMIT_LSB[index - 1][nr],
  282. voltage & 0xff);
  283. if (err < 0)
  284. goto abort;
  285. err = regmap_update_bits(data->regmap, REG_VOLTAGE_LIMIT_MSB[nr],
  286. 0x0300 >> shift, (voltage & 0x0300) >> shift);
  287. abort:
  288. mutex_unlock(&data->access_lock);
  289. return err;
  290. }
  291. static ssize_t in_show(struct device *dev, struct device_attribute *attr,
  292. char *buf)
  293. {
  294. struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
  295. struct nct7802_data *data = dev_get_drvdata(dev);
  296. int voltage;
  297. voltage = nct7802_read_voltage(data, sattr->nr, sattr->index);
  298. if (voltage < 0)
  299. return voltage;
  300. return sprintf(buf, "%d\n", voltage);
  301. }
  302. static ssize_t in_store(struct device *dev, struct device_attribute *attr,
  303. const char *buf, size_t count)
  304. {
  305. struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
  306. struct nct7802_data *data = dev_get_drvdata(dev);
  307. int index = sattr->index;
  308. int nr = sattr->nr;
  309. unsigned long val;
  310. int err;
  311. err = kstrtoul(buf, 10, &val);
  312. if (err < 0)
  313. return err;
  314. err = nct7802_write_voltage(data, nr, index, val);
  315. return err ? : count;
  316. }
  317. static ssize_t in_alarm_show(struct device *dev, struct device_attribute *attr,
  318. char *buf)
  319. {
  320. struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
  321. struct nct7802_data *data = dev_get_drvdata(dev);
  322. int volt, min, max, ret;
  323. unsigned int val;
  324. mutex_lock(&data->in_alarm_lock);
  325. /*
  326. * The SMI Voltage status register is the only register giving a status
  327. * for voltages. A bit is set for each input crossing a threshold, in
  328. * both direction, but the "inside" or "outside" limits info is not
  329. * available. Also this register is cleared on read.
  330. * Note: this is not explicitly spelled out in the datasheet, but
  331. * from experiment.
  332. * To deal with this we use a status cache with one validity bit and
  333. * one status bit for each input. Validity is cleared at startup and
  334. * each time the register reports a change, and the status is processed
  335. * by software based on current input value and limits.
  336. */
  337. ret = regmap_read(data->regmap, 0x1e, &val); /* SMI Voltage status */
  338. if (ret < 0)
  339. goto abort;
  340. /* invalidate cached status for all inputs crossing a threshold */
  341. data->in_status &= ~((val & 0x0f) << 4);
  342. /* if cached status for requested input is invalid, update it */
  343. if (!(data->in_status & (0x10 << sattr->index))) {
  344. ret = nct7802_read_voltage(data, sattr->nr, 0);
  345. if (ret < 0)
  346. goto abort;
  347. volt = ret;
  348. ret = nct7802_read_voltage(data, sattr->nr, 1);
  349. if (ret < 0)
  350. goto abort;
  351. min = ret;
  352. ret = nct7802_read_voltage(data, sattr->nr, 2);
  353. if (ret < 0)
  354. goto abort;
  355. max = ret;
  356. if (volt < min || volt > max)
  357. data->in_status |= (1 << sattr->index);
  358. else
  359. data->in_status &= ~(1 << sattr->index);
  360. data->in_status |= 0x10 << sattr->index;
  361. }
  362. ret = sprintf(buf, "%u\n", !!(data->in_status & (1 << sattr->index)));
  363. abort:
  364. mutex_unlock(&data->in_alarm_lock);
  365. return ret;
  366. }
  367. static ssize_t temp_show(struct device *dev, struct device_attribute *attr,
  368. char *buf)
  369. {
  370. struct nct7802_data *data = dev_get_drvdata(dev);
  371. struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
  372. int err, temp;
  373. err = nct7802_read_temp(data, sattr->nr, sattr->index, &temp);
  374. if (err < 0)
  375. return err;
  376. return sprintf(buf, "%d\n", temp);
  377. }
  378. static ssize_t temp_store(struct device *dev, struct device_attribute *attr,
  379. const char *buf, size_t count)
  380. {
  381. struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
  382. struct nct7802_data *data = dev_get_drvdata(dev);
  383. int nr = sattr->nr;
  384. long val;
  385. int err;
  386. err = kstrtol(buf, 10, &val);
  387. if (err < 0)
  388. return err;
  389. val = DIV_ROUND_CLOSEST(clamp_val(val, -128000, 127000), 1000);
  390. err = regmap_write(data->regmap, nr, val & 0xff);
  391. return err ? : count;
  392. }
  393. static ssize_t fan_show(struct device *dev, struct device_attribute *attr,
  394. char *buf)
  395. {
  396. struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
  397. struct nct7802_data *data = dev_get_drvdata(dev);
  398. int speed;
  399. speed = nct7802_read_fan(data, sattr->index);
  400. if (speed < 0)
  401. return speed;
  402. return sprintf(buf, "%d\n", speed);
  403. }
  404. static ssize_t fan_min_show(struct device *dev, struct device_attribute *attr,
  405. char *buf)
  406. {
  407. struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
  408. struct nct7802_data *data = dev_get_drvdata(dev);
  409. int speed;
  410. speed = nct7802_read_fan_min(data, sattr->nr, sattr->index);
  411. if (speed < 0)
  412. return speed;
  413. return sprintf(buf, "%d\n", speed);
  414. }
  415. static ssize_t fan_min_store(struct device *dev,
  416. struct device_attribute *attr, const char *buf,
  417. size_t count)
  418. {
  419. struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
  420. struct nct7802_data *data = dev_get_drvdata(dev);
  421. unsigned long val;
  422. int err;
  423. err = kstrtoul(buf, 10, &val);
  424. if (err < 0)
  425. return err;
  426. err = nct7802_write_fan_min(data, sattr->nr, sattr->index, val);
  427. return err ? : count;
  428. }
  429. static ssize_t alarm_show(struct device *dev, struct device_attribute *attr,
  430. char *buf)
  431. {
  432. struct nct7802_data *data = dev_get_drvdata(dev);
  433. struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
  434. int bit = sattr->index;
  435. unsigned int val;
  436. int ret;
  437. ret = regmap_read(data->regmap, sattr->nr, &val);
  438. if (ret < 0)
  439. return ret;
  440. return sprintf(buf, "%u\n", !!(val & (1 << bit)));
  441. }
  442. static ssize_t
  443. beep_show(struct device *dev, struct device_attribute *attr, char *buf)
  444. {
  445. struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
  446. struct nct7802_data *data = dev_get_drvdata(dev);
  447. unsigned int regval;
  448. int err;
  449. err = regmap_read(data->regmap, sattr->nr, &regval);
  450. if (err)
  451. return err;
  452. return sprintf(buf, "%u\n", !!(regval & (1 << sattr->index)));
  453. }
  454. static ssize_t
  455. beep_store(struct device *dev, struct device_attribute *attr, const char *buf,
  456. size_t count)
  457. {
  458. struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
  459. struct nct7802_data *data = dev_get_drvdata(dev);
  460. unsigned long val;
  461. int err;
  462. err = kstrtoul(buf, 10, &val);
  463. if (err < 0)
  464. return err;
  465. if (val > 1)
  466. return -EINVAL;
  467. err = regmap_update_bits(data->regmap, sattr->nr, 1 << sattr->index,
  468. val ? 1 << sattr->index : 0);
  469. return err ? : count;
  470. }
  471. static SENSOR_DEVICE_ATTR_RW(temp1_type, temp_type, 0);
  472. static SENSOR_DEVICE_ATTR_2_RO(temp1_input, temp, 0x01, REG_TEMP_LSB);
  473. static SENSOR_DEVICE_ATTR_2_RW(temp1_min, temp, 0x31, 0);
  474. static SENSOR_DEVICE_ATTR_2_RW(temp1_max, temp, 0x30, 0);
  475. static SENSOR_DEVICE_ATTR_2_RW(temp1_crit, temp, 0x3a, 0);
  476. static SENSOR_DEVICE_ATTR_RW(temp2_type, temp_type, 1);
  477. static SENSOR_DEVICE_ATTR_2_RO(temp2_input, temp, 0x02, REG_TEMP_LSB);
  478. static SENSOR_DEVICE_ATTR_2_RW(temp2_min, temp, 0x33, 0);
  479. static SENSOR_DEVICE_ATTR_2_RW(temp2_max, temp, 0x32, 0);
  480. static SENSOR_DEVICE_ATTR_2_RW(temp2_crit, temp, 0x3b, 0);
  481. static SENSOR_DEVICE_ATTR_RW(temp3_type, temp_type, 2);
  482. static SENSOR_DEVICE_ATTR_2_RO(temp3_input, temp, 0x03, REG_TEMP_LSB);
  483. static SENSOR_DEVICE_ATTR_2_RW(temp3_min, temp, 0x35, 0);
  484. static SENSOR_DEVICE_ATTR_2_RW(temp3_max, temp, 0x34, 0);
  485. static SENSOR_DEVICE_ATTR_2_RW(temp3_crit, temp, 0x3c, 0);
  486. static SENSOR_DEVICE_ATTR_2_RO(temp4_input, temp, 0x04, 0);
  487. static SENSOR_DEVICE_ATTR_2_RW(temp4_min, temp, 0x37, 0);
  488. static SENSOR_DEVICE_ATTR_2_RW(temp4_max, temp, 0x36, 0);
  489. static SENSOR_DEVICE_ATTR_2_RW(temp4_crit, temp, 0x3d, 0);
  490. static SENSOR_DEVICE_ATTR_2_RO(temp5_input, temp, 0x06, REG_TEMP_PECI_LSB);
  491. static SENSOR_DEVICE_ATTR_2_RW(temp5_min, temp, 0x39, 0);
  492. static SENSOR_DEVICE_ATTR_2_RW(temp5_max, temp, 0x38, 0);
  493. static SENSOR_DEVICE_ATTR_2_RW(temp5_crit, temp, 0x3e, 0);
  494. static SENSOR_DEVICE_ATTR_2_RO(temp6_input, temp, 0x07, REG_TEMP_PECI_LSB);
  495. static SENSOR_DEVICE_ATTR_2_RO(temp1_min_alarm, alarm, 0x18, 0);
  496. static SENSOR_DEVICE_ATTR_2_RO(temp2_min_alarm, alarm, 0x18, 1);
  497. static SENSOR_DEVICE_ATTR_2_RO(temp3_min_alarm, alarm, 0x18, 2);
  498. static SENSOR_DEVICE_ATTR_2_RO(temp4_min_alarm, alarm, 0x18, 3);
  499. static SENSOR_DEVICE_ATTR_2_RO(temp5_min_alarm, alarm, 0x18, 4);
  500. static SENSOR_DEVICE_ATTR_2_RO(temp1_max_alarm, alarm, 0x19, 0);
  501. static SENSOR_DEVICE_ATTR_2_RO(temp2_max_alarm, alarm, 0x19, 1);
  502. static SENSOR_DEVICE_ATTR_2_RO(temp3_max_alarm, alarm, 0x19, 2);
  503. static SENSOR_DEVICE_ATTR_2_RO(temp4_max_alarm, alarm, 0x19, 3);
  504. static SENSOR_DEVICE_ATTR_2_RO(temp5_max_alarm, alarm, 0x19, 4);
  505. static SENSOR_DEVICE_ATTR_2_RO(temp1_crit_alarm, alarm, 0x1b, 0);
  506. static SENSOR_DEVICE_ATTR_2_RO(temp2_crit_alarm, alarm, 0x1b, 1);
  507. static SENSOR_DEVICE_ATTR_2_RO(temp3_crit_alarm, alarm, 0x1b, 2);
  508. static SENSOR_DEVICE_ATTR_2_RO(temp4_crit_alarm, alarm, 0x1b, 3);
  509. static SENSOR_DEVICE_ATTR_2_RO(temp5_crit_alarm, alarm, 0x1b, 4);
  510. static SENSOR_DEVICE_ATTR_2_RO(temp1_fault, alarm, 0x17, 0);
  511. static SENSOR_DEVICE_ATTR_2_RO(temp2_fault, alarm, 0x17, 1);
  512. static SENSOR_DEVICE_ATTR_2_RO(temp3_fault, alarm, 0x17, 2);
  513. static SENSOR_DEVICE_ATTR_2_RW(temp1_beep, beep, 0x5c, 0);
  514. static SENSOR_DEVICE_ATTR_2_RW(temp2_beep, beep, 0x5c, 1);
  515. static SENSOR_DEVICE_ATTR_2_RW(temp3_beep, beep, 0x5c, 2);
  516. static SENSOR_DEVICE_ATTR_2_RW(temp4_beep, beep, 0x5c, 3);
  517. static SENSOR_DEVICE_ATTR_2_RW(temp5_beep, beep, 0x5c, 4);
  518. static SENSOR_DEVICE_ATTR_2_RW(temp6_beep, beep, 0x5c, 5);
  519. static struct attribute *nct7802_temp_attrs[] = {
  520. &sensor_dev_attr_temp1_type.dev_attr.attr,
  521. &sensor_dev_attr_temp1_input.dev_attr.attr,
  522. &sensor_dev_attr_temp1_min.dev_attr.attr,
  523. &sensor_dev_attr_temp1_max.dev_attr.attr,
  524. &sensor_dev_attr_temp1_crit.dev_attr.attr,
  525. &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
  526. &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
  527. &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
  528. &sensor_dev_attr_temp1_fault.dev_attr.attr,
  529. &sensor_dev_attr_temp1_beep.dev_attr.attr,
  530. &sensor_dev_attr_temp2_type.dev_attr.attr, /* 10 */
  531. &sensor_dev_attr_temp2_input.dev_attr.attr,
  532. &sensor_dev_attr_temp2_min.dev_attr.attr,
  533. &sensor_dev_attr_temp2_max.dev_attr.attr,
  534. &sensor_dev_attr_temp2_crit.dev_attr.attr,
  535. &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
  536. &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
  537. &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
  538. &sensor_dev_attr_temp2_fault.dev_attr.attr,
  539. &sensor_dev_attr_temp2_beep.dev_attr.attr,
  540. &sensor_dev_attr_temp3_type.dev_attr.attr, /* 20 */
  541. &sensor_dev_attr_temp3_input.dev_attr.attr,
  542. &sensor_dev_attr_temp3_min.dev_attr.attr,
  543. &sensor_dev_attr_temp3_max.dev_attr.attr,
  544. &sensor_dev_attr_temp3_crit.dev_attr.attr,
  545. &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
  546. &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
  547. &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
  548. &sensor_dev_attr_temp3_fault.dev_attr.attr,
  549. &sensor_dev_attr_temp3_beep.dev_attr.attr,
  550. &sensor_dev_attr_temp4_input.dev_attr.attr, /* 30 */
  551. &sensor_dev_attr_temp4_min.dev_attr.attr,
  552. &sensor_dev_attr_temp4_max.dev_attr.attr,
  553. &sensor_dev_attr_temp4_crit.dev_attr.attr,
  554. &sensor_dev_attr_temp4_min_alarm.dev_attr.attr,
  555. &sensor_dev_attr_temp4_max_alarm.dev_attr.attr,
  556. &sensor_dev_attr_temp4_crit_alarm.dev_attr.attr,
  557. &sensor_dev_attr_temp4_beep.dev_attr.attr,
  558. &sensor_dev_attr_temp5_input.dev_attr.attr, /* 38 */
  559. &sensor_dev_attr_temp5_min.dev_attr.attr,
  560. &sensor_dev_attr_temp5_max.dev_attr.attr,
  561. &sensor_dev_attr_temp5_crit.dev_attr.attr,
  562. &sensor_dev_attr_temp5_min_alarm.dev_attr.attr,
  563. &sensor_dev_attr_temp5_max_alarm.dev_attr.attr,
  564. &sensor_dev_attr_temp5_crit_alarm.dev_attr.attr,
  565. &sensor_dev_attr_temp5_beep.dev_attr.attr,
  566. &sensor_dev_attr_temp6_input.dev_attr.attr, /* 46 */
  567. &sensor_dev_attr_temp6_beep.dev_attr.attr,
  568. NULL
  569. };
  570. static umode_t nct7802_temp_is_visible(struct kobject *kobj,
  571. struct attribute *attr, int index)
  572. {
  573. struct device *dev = kobj_to_dev(kobj);
  574. struct nct7802_data *data = dev_get_drvdata(dev);
  575. unsigned int reg;
  576. int err;
  577. err = regmap_read(data->regmap, REG_MODE, &reg);
  578. if (err < 0)
  579. return 0;
  580. if (index < 10 &&
  581. (reg & 03) != 0x01 && (reg & 0x03) != 0x02) /* RD1 */
  582. return 0;
  583. if (index >= 10 && index < 20 &&
  584. (reg & 0x0c) != 0x04 && (reg & 0x0c) != 0x08) /* RD2 */
  585. return 0;
  586. if (index >= 20 && index < 30 && (reg & 0x30) != 0x20) /* RD3 */
  587. return 0;
  588. if (index >= 30 && index < 38) /* local */
  589. return attr->mode;
  590. err = regmap_read(data->regmap, REG_PECI_ENABLE, &reg);
  591. if (err < 0)
  592. return 0;
  593. if (index >= 38 && index < 46 && !(reg & 0x01)) /* PECI 0 */
  594. return 0;
  595. if (index >= 0x46 && (!(reg & 0x02))) /* PECI 1 */
  596. return 0;
  597. return attr->mode;
  598. }
  599. static const struct attribute_group nct7802_temp_group = {
  600. .attrs = nct7802_temp_attrs,
  601. .is_visible = nct7802_temp_is_visible,
  602. };
  603. static SENSOR_DEVICE_ATTR_2_RO(in0_input, in, 0, 0);
  604. static SENSOR_DEVICE_ATTR_2_RW(in0_min, in, 0, 1);
  605. static SENSOR_DEVICE_ATTR_2_RW(in0_max, in, 0, 2);
  606. static SENSOR_DEVICE_ATTR_2_RO(in0_alarm, in_alarm, 0, 3);
  607. static SENSOR_DEVICE_ATTR_2_RW(in0_beep, beep, 0x5a, 3);
  608. static SENSOR_DEVICE_ATTR_2_RO(in1_input, in, 1, 0);
  609. static SENSOR_DEVICE_ATTR_2_RO(in2_input, in, 2, 0);
  610. static SENSOR_DEVICE_ATTR_2_RW(in2_min, in, 2, 1);
  611. static SENSOR_DEVICE_ATTR_2_RW(in2_max, in, 2, 2);
  612. static SENSOR_DEVICE_ATTR_2_RO(in2_alarm, in_alarm, 2, 0);
  613. static SENSOR_DEVICE_ATTR_2_RW(in2_beep, beep, 0x5a, 0);
  614. static SENSOR_DEVICE_ATTR_2_RO(in3_input, in, 3, 0);
  615. static SENSOR_DEVICE_ATTR_2_RW(in3_min, in, 3, 1);
  616. static SENSOR_DEVICE_ATTR_2_RW(in3_max, in, 3, 2);
  617. static SENSOR_DEVICE_ATTR_2_RO(in3_alarm, in_alarm, 3, 1);
  618. static SENSOR_DEVICE_ATTR_2_RW(in3_beep, beep, 0x5a, 1);
  619. static SENSOR_DEVICE_ATTR_2_RO(in4_input, in, 4, 0);
  620. static SENSOR_DEVICE_ATTR_2_RW(in4_min, in, 4, 1);
  621. static SENSOR_DEVICE_ATTR_2_RW(in4_max, in, 4, 2);
  622. static SENSOR_DEVICE_ATTR_2_RO(in4_alarm, in_alarm, 4, 2);
  623. static SENSOR_DEVICE_ATTR_2_RW(in4_beep, beep, 0x5a, 2);
  624. static struct attribute *nct7802_in_attrs[] = {
  625. &sensor_dev_attr_in0_input.dev_attr.attr,
  626. &sensor_dev_attr_in0_min.dev_attr.attr,
  627. &sensor_dev_attr_in0_max.dev_attr.attr,
  628. &sensor_dev_attr_in0_alarm.dev_attr.attr,
  629. &sensor_dev_attr_in0_beep.dev_attr.attr,
  630. &sensor_dev_attr_in1_input.dev_attr.attr, /* 5 */
  631. &sensor_dev_attr_in2_input.dev_attr.attr, /* 6 */
  632. &sensor_dev_attr_in2_min.dev_attr.attr,
  633. &sensor_dev_attr_in2_max.dev_attr.attr,
  634. &sensor_dev_attr_in2_alarm.dev_attr.attr,
  635. &sensor_dev_attr_in2_beep.dev_attr.attr,
  636. &sensor_dev_attr_in3_input.dev_attr.attr, /* 11 */
  637. &sensor_dev_attr_in3_min.dev_attr.attr,
  638. &sensor_dev_attr_in3_max.dev_attr.attr,
  639. &sensor_dev_attr_in3_alarm.dev_attr.attr,
  640. &sensor_dev_attr_in3_beep.dev_attr.attr,
  641. &sensor_dev_attr_in4_input.dev_attr.attr, /* 16 */
  642. &sensor_dev_attr_in4_min.dev_attr.attr,
  643. &sensor_dev_attr_in4_max.dev_attr.attr,
  644. &sensor_dev_attr_in4_alarm.dev_attr.attr,
  645. &sensor_dev_attr_in4_beep.dev_attr.attr,
  646. NULL,
  647. };
  648. static umode_t nct7802_in_is_visible(struct kobject *kobj,
  649. struct attribute *attr, int index)
  650. {
  651. struct device *dev = kobj_to_dev(kobj);
  652. struct nct7802_data *data = dev_get_drvdata(dev);
  653. unsigned int reg;
  654. int err;
  655. if (index < 6) /* VCC, VCORE */
  656. return attr->mode;
  657. err = regmap_read(data->regmap, REG_MODE, &reg);
  658. if (err < 0)
  659. return 0;
  660. if (index >= 6 && index < 11 && (reg & 0x03) != 0x03) /* VSEN1 */
  661. return 0;
  662. if (index >= 11 && index < 16 && (reg & 0x0c) != 0x0c) /* VSEN2 */
  663. return 0;
  664. if (index >= 16 && (reg & 0x30) != 0x30) /* VSEN3 */
  665. return 0;
  666. return attr->mode;
  667. }
  668. static const struct attribute_group nct7802_in_group = {
  669. .attrs = nct7802_in_attrs,
  670. .is_visible = nct7802_in_is_visible,
  671. };
  672. static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0x10);
  673. static SENSOR_DEVICE_ATTR_2_RW(fan1_min, fan_min, 0x49, 0x4c);
  674. static SENSOR_DEVICE_ATTR_2_RO(fan1_alarm, alarm, 0x1a, 0);
  675. static SENSOR_DEVICE_ATTR_2_RW(fan1_beep, beep, 0x5b, 0);
  676. static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 0x11);
  677. static SENSOR_DEVICE_ATTR_2_RW(fan2_min, fan_min, 0x4a, 0x4d);
  678. static SENSOR_DEVICE_ATTR_2_RO(fan2_alarm, alarm, 0x1a, 1);
  679. static SENSOR_DEVICE_ATTR_2_RW(fan2_beep, beep, 0x5b, 1);
  680. static SENSOR_DEVICE_ATTR_RO(fan3_input, fan, 0x12);
  681. static SENSOR_DEVICE_ATTR_2_RW(fan3_min, fan_min, 0x4b, 0x4e);
  682. static SENSOR_DEVICE_ATTR_2_RO(fan3_alarm, alarm, 0x1a, 2);
  683. static SENSOR_DEVICE_ATTR_2_RW(fan3_beep, beep, 0x5b, 2);
  684. /* 7.2.89 Fan Control Output Type */
  685. static SENSOR_DEVICE_ATTR_RO(pwm1_mode, pwm_mode, 0);
  686. static SENSOR_DEVICE_ATTR_RO(pwm2_mode, pwm_mode, 1);
  687. static SENSOR_DEVICE_ATTR_RO(pwm3_mode, pwm_mode, 2);
  688. /* 7.2.91... Fan Control Output Value */
  689. static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, REG_PWM(0));
  690. static SENSOR_DEVICE_ATTR_RW(pwm2, pwm, REG_PWM(1));
  691. static SENSOR_DEVICE_ATTR_RW(pwm3, pwm, REG_PWM(2));
  692. /* 7.2.95... Temperature to Fan mapping Relationships Register */
  693. static SENSOR_DEVICE_ATTR_RW(pwm1_enable, pwm_enable, 0);
  694. static SENSOR_DEVICE_ATTR_RW(pwm2_enable, pwm_enable, 1);
  695. static SENSOR_DEVICE_ATTR_RW(pwm3_enable, pwm_enable, 2);
  696. static struct attribute *nct7802_fan_attrs[] = {
  697. &sensor_dev_attr_fan1_input.dev_attr.attr,
  698. &sensor_dev_attr_fan1_min.dev_attr.attr,
  699. &sensor_dev_attr_fan1_alarm.dev_attr.attr,
  700. &sensor_dev_attr_fan1_beep.dev_attr.attr,
  701. &sensor_dev_attr_fan2_input.dev_attr.attr,
  702. &sensor_dev_attr_fan2_min.dev_attr.attr,
  703. &sensor_dev_attr_fan2_alarm.dev_attr.attr,
  704. &sensor_dev_attr_fan2_beep.dev_attr.attr,
  705. &sensor_dev_attr_fan3_input.dev_attr.attr,
  706. &sensor_dev_attr_fan3_min.dev_attr.attr,
  707. &sensor_dev_attr_fan3_alarm.dev_attr.attr,
  708. &sensor_dev_attr_fan3_beep.dev_attr.attr,
  709. NULL
  710. };
  711. static umode_t nct7802_fan_is_visible(struct kobject *kobj,
  712. struct attribute *attr, int index)
  713. {
  714. struct device *dev = kobj_to_dev(kobj);
  715. struct nct7802_data *data = dev_get_drvdata(dev);
  716. int fan = index / 4; /* 4 attributes per fan */
  717. unsigned int reg;
  718. int err;
  719. err = regmap_read(data->regmap, REG_FAN_ENABLE, &reg);
  720. if (err < 0 || !(reg & (1 << fan)))
  721. return 0;
  722. return attr->mode;
  723. }
  724. static const struct attribute_group nct7802_fan_group = {
  725. .attrs = nct7802_fan_attrs,
  726. .is_visible = nct7802_fan_is_visible,
  727. };
  728. static struct attribute *nct7802_pwm_attrs[] = {
  729. &sensor_dev_attr_pwm1_enable.dev_attr.attr,
  730. &sensor_dev_attr_pwm1_mode.dev_attr.attr,
  731. &sensor_dev_attr_pwm1.dev_attr.attr,
  732. &sensor_dev_attr_pwm2_enable.dev_attr.attr,
  733. &sensor_dev_attr_pwm2_mode.dev_attr.attr,
  734. &sensor_dev_attr_pwm2.dev_attr.attr,
  735. &sensor_dev_attr_pwm3_enable.dev_attr.attr,
  736. &sensor_dev_attr_pwm3_mode.dev_attr.attr,
  737. &sensor_dev_attr_pwm3.dev_attr.attr,
  738. NULL
  739. };
  740. static const struct attribute_group nct7802_pwm_group = {
  741. .attrs = nct7802_pwm_attrs,
  742. };
  743. /* 7.2.115... 0x80-0x83, 0x84 Temperature (X-axis) transition */
  744. static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point1_temp, temp, 0x80, 0);
  745. static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point2_temp, temp, 0x81, 0);
  746. static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point3_temp, temp, 0x82, 0);
  747. static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point4_temp, temp, 0x83, 0);
  748. static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point5_temp, temp, 0x84, 0);
  749. /* 7.2.120... 0x85-0x88 PWM (Y-axis) transition */
  750. static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point1_pwm, pwm, 0x85);
  751. static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point2_pwm, pwm, 0x86);
  752. static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point3_pwm, pwm, 0x87);
  753. static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point4_pwm, pwm, 0x88);
  754. static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point5_pwm, pwm, 0);
  755. /* 7.2.124 Table 2 X-axis Transition Point 1 Register */
  756. static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point1_temp, temp, 0x90, 0);
  757. static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point2_temp, temp, 0x91, 0);
  758. static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point3_temp, temp, 0x92, 0);
  759. static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point4_temp, temp, 0x93, 0);
  760. static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point5_temp, temp, 0x94, 0);
  761. /* 7.2.129 Table 2 Y-axis Transition Point 1 Register */
  762. static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point1_pwm, pwm, 0x95);
  763. static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point2_pwm, pwm, 0x96);
  764. static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point3_pwm, pwm, 0x97);
  765. static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point4_pwm, pwm, 0x98);
  766. static SENSOR_DEVICE_ATTR_RO(pwm2_auto_point5_pwm, pwm, 0);
  767. /* 7.2.133 Table 3 X-axis Transition Point 1 Register */
  768. static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point1_temp, temp, 0xA0, 0);
  769. static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point2_temp, temp, 0xA1, 0);
  770. static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point3_temp, temp, 0xA2, 0);
  771. static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point4_temp, temp, 0xA3, 0);
  772. static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point5_temp, temp, 0xA4, 0);
  773. /* 7.2.138 Table 3 Y-axis Transition Point 1 Register */
  774. static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point1_pwm, pwm, 0xA5);
  775. static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point2_pwm, pwm, 0xA6);
  776. static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point3_pwm, pwm, 0xA7);
  777. static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point4_pwm, pwm, 0xA8);
  778. static SENSOR_DEVICE_ATTR_RO(pwm3_auto_point5_pwm, pwm, 0);
  779. static struct attribute *nct7802_auto_point_attrs[] = {
  780. &sensor_dev_attr_pwm1_auto_point1_temp.dev_attr.attr,
  781. &sensor_dev_attr_pwm1_auto_point2_temp.dev_attr.attr,
  782. &sensor_dev_attr_pwm1_auto_point3_temp.dev_attr.attr,
  783. &sensor_dev_attr_pwm1_auto_point4_temp.dev_attr.attr,
  784. &sensor_dev_attr_pwm1_auto_point5_temp.dev_attr.attr,
  785. &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
  786. &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
  787. &sensor_dev_attr_pwm1_auto_point3_pwm.dev_attr.attr,
  788. &sensor_dev_attr_pwm1_auto_point4_pwm.dev_attr.attr,
  789. &sensor_dev_attr_pwm1_auto_point5_pwm.dev_attr.attr,
  790. &sensor_dev_attr_pwm2_auto_point1_temp.dev_attr.attr,
  791. &sensor_dev_attr_pwm2_auto_point2_temp.dev_attr.attr,
  792. &sensor_dev_attr_pwm2_auto_point3_temp.dev_attr.attr,
  793. &sensor_dev_attr_pwm2_auto_point4_temp.dev_attr.attr,
  794. &sensor_dev_attr_pwm2_auto_point5_temp.dev_attr.attr,
  795. &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
  796. &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
  797. &sensor_dev_attr_pwm2_auto_point3_pwm.dev_attr.attr,
  798. &sensor_dev_attr_pwm2_auto_point4_pwm.dev_attr.attr,
  799. &sensor_dev_attr_pwm2_auto_point5_pwm.dev_attr.attr,
  800. &sensor_dev_attr_pwm3_auto_point1_temp.dev_attr.attr,
  801. &sensor_dev_attr_pwm3_auto_point2_temp.dev_attr.attr,
  802. &sensor_dev_attr_pwm3_auto_point3_temp.dev_attr.attr,
  803. &sensor_dev_attr_pwm3_auto_point4_temp.dev_attr.attr,
  804. &sensor_dev_attr_pwm3_auto_point5_temp.dev_attr.attr,
  805. &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
  806. &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
  807. &sensor_dev_attr_pwm3_auto_point3_pwm.dev_attr.attr,
  808. &sensor_dev_attr_pwm3_auto_point4_pwm.dev_attr.attr,
  809. &sensor_dev_attr_pwm3_auto_point5_pwm.dev_attr.attr,
  810. NULL
  811. };
  812. static const struct attribute_group nct7802_auto_point_group = {
  813. .attrs = nct7802_auto_point_attrs,
  814. };
  815. static const struct attribute_group *nct7802_groups[] = {
  816. &nct7802_temp_group,
  817. &nct7802_in_group,
  818. &nct7802_fan_group,
  819. &nct7802_pwm_group,
  820. &nct7802_auto_point_group,
  821. NULL
  822. };
  823. static int nct7802_detect(struct i2c_client *client,
  824. struct i2c_board_info *info)
  825. {
  826. int reg;
  827. /*
  828. * Chip identification registers are only available in bank 0,
  829. * so only attempt chip detection if bank 0 is selected
  830. */
  831. reg = i2c_smbus_read_byte_data(client, REG_BANK);
  832. if (reg != 0x00)
  833. return -ENODEV;
  834. reg = i2c_smbus_read_byte_data(client, REG_VENDOR_ID);
  835. if (reg != 0x50)
  836. return -ENODEV;
  837. reg = i2c_smbus_read_byte_data(client, REG_CHIP_ID);
  838. if (reg != 0xc3)
  839. return -ENODEV;
  840. reg = i2c_smbus_read_byte_data(client, REG_VERSION_ID);
  841. if (reg < 0 || (reg & 0xf0) != 0x20)
  842. return -ENODEV;
  843. /* Also validate lower bits of voltage and temperature registers */
  844. reg = i2c_smbus_read_byte_data(client, REG_TEMP_LSB);
  845. if (reg < 0 || (reg & 0x1f))
  846. return -ENODEV;
  847. reg = i2c_smbus_read_byte_data(client, REG_TEMP_PECI_LSB);
  848. if (reg < 0 || (reg & 0x3f))
  849. return -ENODEV;
  850. reg = i2c_smbus_read_byte_data(client, REG_VOLTAGE_LOW);
  851. if (reg < 0 || (reg & 0x3f))
  852. return -ENODEV;
  853. strlcpy(info->type, "nct7802", I2C_NAME_SIZE);
  854. return 0;
  855. }
  856. static bool nct7802_regmap_is_volatile(struct device *dev, unsigned int reg)
  857. {
  858. return (reg != REG_BANK && reg <= 0x20) ||
  859. (reg >= REG_PWM(0) && reg <= REG_PWM(2));
  860. }
  861. static const struct regmap_config nct7802_regmap_config = {
  862. .reg_bits = 8,
  863. .val_bits = 8,
  864. .cache_type = REGCACHE_RBTREE,
  865. .volatile_reg = nct7802_regmap_is_volatile,
  866. };
  867. static int nct7802_init_chip(struct nct7802_data *data)
  868. {
  869. int err;
  870. /* Enable ADC */
  871. err = regmap_update_bits(data->regmap, REG_START, 0x01, 0x01);
  872. if (err)
  873. return err;
  874. /* Enable local temperature sensor */
  875. err = regmap_update_bits(data->regmap, REG_MODE, 0x40, 0x40);
  876. if (err)
  877. return err;
  878. /* Enable Vcore and VCC voltage monitoring */
  879. return regmap_update_bits(data->regmap, REG_VMON_ENABLE, 0x03, 0x03);
  880. }
  881. static int nct7802_probe(struct i2c_client *client)
  882. {
  883. struct device *dev = &client->dev;
  884. struct nct7802_data *data;
  885. struct device *hwmon_dev;
  886. int ret;
  887. data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
  888. if (data == NULL)
  889. return -ENOMEM;
  890. data->regmap = devm_regmap_init_i2c(client, &nct7802_regmap_config);
  891. if (IS_ERR(data->regmap))
  892. return PTR_ERR(data->regmap);
  893. mutex_init(&data->access_lock);
  894. mutex_init(&data->in_alarm_lock);
  895. ret = nct7802_init_chip(data);
  896. if (ret < 0)
  897. return ret;
  898. hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
  899. data,
  900. nct7802_groups);
  901. return PTR_ERR_OR_ZERO(hwmon_dev);
  902. }
  903. static const unsigned short nct7802_address_list[] = {
  904. 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, I2C_CLIENT_END
  905. };
  906. static const struct i2c_device_id nct7802_idtable[] = {
  907. { "nct7802", 0 },
  908. { }
  909. };
  910. MODULE_DEVICE_TABLE(i2c, nct7802_idtable);
  911. static struct i2c_driver nct7802_driver = {
  912. .class = I2C_CLASS_HWMON,
  913. .driver = {
  914. .name = DRVNAME,
  915. },
  916. .detect = nct7802_detect,
  917. .probe_new = nct7802_probe,
  918. .id_table = nct7802_idtable,
  919. .address_list = nct7802_address_list,
  920. };
  921. module_i2c_driver(nct7802_driver);
  922. MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>");
  923. MODULE_DESCRIPTION("NCT7802Y Hardware Monitoring Driver");
  924. MODULE_LICENSE("GPL v2");