adm9240.c 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * adm9240.c Part of lm_sensors, Linux kernel modules for hardware
  4. * monitoring
  5. *
  6. * Copyright (C) 1999 Frodo Looijaard <[email protected]>
  7. * Philip Edelbrock <[email protected]>
  8. * Copyright (C) 2003 Michiel Rook <[email protected]>
  9. * Copyright (C) 2005 Grant Coady <[email protected]> with valuable
  10. * guidance from Jean Delvare
  11. *
  12. * Driver supports Analog Devices ADM9240
  13. * Dallas Semiconductor DS1780
  14. * National Semiconductor LM81
  15. *
  16. * ADM9240 is the reference, DS1780 and LM81 are register compatibles
  17. *
  18. * Voltage Six inputs are scaled by chip, VID also reported
  19. * Temperature Chip temperature to 0.5'C, maximum and max_hysteris
  20. * Fans 2 fans, low speed alarm, automatic fan clock divider
  21. * Alarms 16-bit map of active alarms
  22. * Analog Out 0..1250 mV output
  23. *
  24. * Chassis Intrusion: clear CI latch with 'echo 0 > intrusion0_alarm'
  25. *
  26. * Test hardware: Intel SE440BX-2 desktop motherboard --Grant
  27. *
  28. * LM81 extended temp reading not implemented
  29. */
  30. #include <linux/bits.h>
  31. #include <linux/init.h>
  32. #include <linux/module.h>
  33. #include <linux/slab.h>
  34. #include <linux/i2c.h>
  35. #include <linux/hwmon-sysfs.h>
  36. #include <linux/hwmon.h>
  37. #include <linux/hwmon-vid.h>
  38. #include <linux/err.h>
  39. #include <linux/mutex.h>
  40. #include <linux/regmap.h>
  41. /* Addresses to scan */
  42. static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f,
  43. I2C_CLIENT_END };
  44. enum chips { adm9240, ds1780, lm81 };
  45. /* ADM9240 registers */
  46. #define ADM9240_REG_MAN_ID 0x3e
  47. #define ADM9240_REG_DIE_REV 0x3f
  48. #define ADM9240_REG_CONFIG 0x40
  49. #define ADM9240_REG_IN(nr) (0x20 + (nr)) /* 0..5 */
  50. #define ADM9240_REG_IN_MAX(nr) (0x2b + (nr) * 2)
  51. #define ADM9240_REG_IN_MIN(nr) (0x2c + (nr) * 2)
  52. #define ADM9240_REG_FAN(nr) (0x28 + (nr)) /* 0..1 */
  53. #define ADM9240_REG_FAN_MIN(nr) (0x3b + (nr))
  54. #define ADM9240_REG_INT(nr) (0x41 + (nr))
  55. #define ADM9240_REG_INT_MASK(nr) (0x43 + (nr))
  56. #define ADM9240_REG_TEMP 0x27
  57. #define ADM9240_REG_TEMP_MAX(nr) (0x39 + (nr)) /* 0, 1 = high, hyst */
  58. #define ADM9240_REG_ANALOG_OUT 0x19
  59. #define ADM9240_REG_CHASSIS_CLEAR 0x46
  60. #define ADM9240_REG_VID_FAN_DIV 0x47
  61. #define ADM9240_REG_I2C_ADDR 0x48
  62. #define ADM9240_REG_VID4 0x49
  63. #define ADM9240_REG_TEMP_CONF 0x4b
  64. /* generalised scaling with integer rounding */
  65. static inline int SCALE(long val, int mul, int div)
  66. {
  67. if (val < 0)
  68. return (val * mul - div / 2) / div;
  69. else
  70. return (val * mul + div / 2) / div;
  71. }
  72. /* adm9240 internally scales voltage measurements */
  73. static const u16 nom_mv[] = { 2500, 2700, 3300, 5000, 12000, 2700 };
  74. static inline unsigned int IN_FROM_REG(u8 reg, int n)
  75. {
  76. return SCALE(reg, nom_mv[n], 192);
  77. }
  78. static inline u8 IN_TO_REG(unsigned long val, int n)
  79. {
  80. val = clamp_val(val, 0, nom_mv[n] * 255 / 192);
  81. return SCALE(val, 192, nom_mv[n]);
  82. }
  83. /* temperature range: -40..125, 127 disables temperature alarm */
  84. static inline s8 TEMP_TO_REG(long val)
  85. {
  86. val = clamp_val(val, -40000, 127000);
  87. return SCALE(val, 1, 1000);
  88. }
  89. /* two fans, each with low fan speed limit */
  90. static inline unsigned int FAN_FROM_REG(u8 reg, u8 div)
  91. {
  92. if (!reg) /* error */
  93. return -1;
  94. if (reg == 255)
  95. return 0;
  96. return SCALE(1350000, 1, reg * div);
  97. }
  98. /* analog out 0..1250mV */
  99. static inline u8 AOUT_TO_REG(unsigned long val)
  100. {
  101. val = clamp_val(val, 0, 1250);
  102. return SCALE(val, 255, 1250);
  103. }
  104. static inline unsigned int AOUT_FROM_REG(u8 reg)
  105. {
  106. return SCALE(reg, 1250, 255);
  107. }
  108. /* per client data */
  109. struct adm9240_data {
  110. struct device *dev;
  111. struct regmap *regmap;
  112. struct mutex update_lock;
  113. u8 fan_div[2]; /* rw fan1_div, read-only accessor */
  114. u8 vrm; /* -- vrm set on startup, no accessor */
  115. };
  116. /* write new fan div, callers must hold data->update_lock */
  117. static int adm9240_write_fan_div(struct adm9240_data *data, int channel, u8 fan_div)
  118. {
  119. unsigned int reg, old, shift = (channel + 2) * 2;
  120. int err;
  121. err = regmap_read(data->regmap, ADM9240_REG_VID_FAN_DIV, &reg);
  122. if (err < 0)
  123. return err;
  124. old = (reg >> shift) & 3;
  125. reg &= ~(3 << shift);
  126. reg |= (fan_div << shift);
  127. err = regmap_write(data->regmap, ADM9240_REG_VID_FAN_DIV, reg);
  128. if (err < 0)
  129. return err;
  130. dev_dbg(data->dev,
  131. "fan%d clock divider changed from %lu to %lu\n",
  132. channel + 1, BIT(old), BIT(fan_div));
  133. return 0;
  134. }
  135. /*
  136. * set fan speed low limit:
  137. *
  138. * - value is zero: disable fan speed low limit alarm
  139. *
  140. * - value is below fan speed measurement range: enable fan speed low
  141. * limit alarm to be asserted while fan speed too slow to measure
  142. *
  143. * - otherwise: select fan clock divider to suit fan speed low limit,
  144. * measurement code may adjust registers to ensure fan speed reading
  145. */
  146. static int adm9240_fan_min_write(struct adm9240_data *data, int channel, long val)
  147. {
  148. u8 new_div;
  149. u8 fan_min;
  150. int err;
  151. mutex_lock(&data->update_lock);
  152. if (!val) {
  153. fan_min = 255;
  154. new_div = data->fan_div[channel];
  155. dev_dbg(data->dev, "fan%u low limit set disabled\n", channel + 1);
  156. } else if (val < 1350000 / (8 * 254)) {
  157. new_div = 3;
  158. fan_min = 254;
  159. dev_dbg(data->dev, "fan%u low limit set minimum %u\n",
  160. channel + 1, FAN_FROM_REG(254, BIT(new_div)));
  161. } else {
  162. unsigned int new_min = 1350000 / val;
  163. new_div = 0;
  164. while (new_min > 192 && new_div < 3) {
  165. new_div++;
  166. new_min /= 2;
  167. }
  168. if (!new_min) /* keep > 0 */
  169. new_min++;
  170. fan_min = new_min;
  171. dev_dbg(data->dev, "fan%u low limit set fan speed %u\n",
  172. channel + 1, FAN_FROM_REG(new_min, BIT(new_div)));
  173. }
  174. if (new_div != data->fan_div[channel]) {
  175. data->fan_div[channel] = new_div;
  176. adm9240_write_fan_div(data, channel, new_div);
  177. }
  178. err = regmap_write(data->regmap, ADM9240_REG_FAN_MIN(channel), fan_min);
  179. mutex_unlock(&data->update_lock);
  180. return err;
  181. }
  182. static ssize_t cpu0_vid_show(struct device *dev,
  183. struct device_attribute *attr, char *buf)
  184. {
  185. struct adm9240_data *data = dev_get_drvdata(dev);
  186. unsigned int regval;
  187. int err;
  188. u8 vid;
  189. err = regmap_read(data->regmap, ADM9240_REG_VID_FAN_DIV, &regval);
  190. if (err < 0)
  191. return err;
  192. vid = regval & 0x0f;
  193. err = regmap_read(data->regmap, ADM9240_REG_VID4, &regval);
  194. if (err < 0)
  195. return err;
  196. vid |= (regval & 1) << 4;
  197. return sprintf(buf, "%d\n", vid_from_reg(vid, data->vrm));
  198. }
  199. static DEVICE_ATTR_RO(cpu0_vid);
  200. static ssize_t aout_output_show(struct device *dev,
  201. struct device_attribute *attr, char *buf)
  202. {
  203. struct adm9240_data *data = dev_get_drvdata(dev);
  204. unsigned int regval;
  205. int err;
  206. err = regmap_read(data->regmap, ADM9240_REG_ANALOG_OUT, &regval);
  207. if (err)
  208. return err;
  209. return sprintf(buf, "%d\n", AOUT_FROM_REG(regval));
  210. }
  211. static ssize_t aout_output_store(struct device *dev,
  212. struct device_attribute *attr,
  213. const char *buf, size_t count)
  214. {
  215. struct adm9240_data *data = dev_get_drvdata(dev);
  216. long val;
  217. int err;
  218. err = kstrtol(buf, 10, &val);
  219. if (err)
  220. return err;
  221. err = regmap_write(data->regmap, ADM9240_REG_ANALOG_OUT, AOUT_TO_REG(val));
  222. return err < 0 ? err : count;
  223. }
  224. static DEVICE_ATTR_RW(aout_output);
  225. static struct attribute *adm9240_attrs[] = {
  226. &dev_attr_aout_output.attr,
  227. &dev_attr_cpu0_vid.attr,
  228. NULL
  229. };
  230. ATTRIBUTE_GROUPS(adm9240);
  231. /*** sensor chip detect and driver install ***/
  232. /* Return 0 if detection is successful, -ENODEV otherwise */
  233. static int adm9240_detect(struct i2c_client *new_client,
  234. struct i2c_board_info *info)
  235. {
  236. struct i2c_adapter *adapter = new_client->adapter;
  237. const char *name = "";
  238. int address = new_client->addr;
  239. u8 man_id, die_rev;
  240. if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
  241. return -ENODEV;
  242. /* verify chip: reg address should match i2c address */
  243. if (i2c_smbus_read_byte_data(new_client, ADM9240_REG_I2C_ADDR) != address)
  244. return -ENODEV;
  245. /* check known chip manufacturer */
  246. man_id = i2c_smbus_read_byte_data(new_client, ADM9240_REG_MAN_ID);
  247. if (man_id == 0x23)
  248. name = "adm9240";
  249. else if (man_id == 0xda)
  250. name = "ds1780";
  251. else if (man_id == 0x01)
  252. name = "lm81";
  253. else
  254. return -ENODEV;
  255. /* successful detect, print chip info */
  256. die_rev = i2c_smbus_read_byte_data(new_client, ADM9240_REG_DIE_REV);
  257. dev_info(&adapter->dev, "found %s revision %u\n",
  258. man_id == 0x23 ? "ADM9240" :
  259. man_id == 0xda ? "DS1780" : "LM81", die_rev);
  260. strscpy(info->type, name, I2C_NAME_SIZE);
  261. return 0;
  262. }
  263. static int adm9240_init_client(struct adm9240_data *data)
  264. {
  265. unsigned int regval;
  266. u8 conf, mode;
  267. int err;
  268. err = regmap_raw_read(data->regmap, ADM9240_REG_CONFIG, &conf, 1);
  269. if (err < 0)
  270. return err;
  271. err = regmap_raw_read(data->regmap, ADM9240_REG_TEMP_CONF, &mode, 1);
  272. if (err < 0)
  273. return err;
  274. mode &= 3;
  275. data->vrm = vid_which_vrm(); /* need this to report vid as mV */
  276. dev_info(data->dev, "Using VRM: %d.%d\n", data->vrm / 10,
  277. data->vrm % 10);
  278. if (conf & 1) { /* measurement cycle running: report state */
  279. dev_info(data->dev, "status: config 0x%02x mode %u\n",
  280. conf, mode);
  281. } else { /* cold start: open limits before starting chip */
  282. int i;
  283. for (i = 0; i < 6; i++) {
  284. err = regmap_write(data->regmap,
  285. ADM9240_REG_IN_MIN(i), 0);
  286. if (err < 0)
  287. return err;
  288. err = regmap_write(data->regmap,
  289. ADM9240_REG_IN_MAX(i), 255);
  290. if (err < 0)
  291. return err;
  292. }
  293. for (i = 0; i < 2; i++) {
  294. err = regmap_write(data->regmap,
  295. ADM9240_REG_FAN_MIN(i), 255);
  296. if (err < 0)
  297. return err;
  298. }
  299. for (i = 0; i < 2; i++) {
  300. err = regmap_write(data->regmap,
  301. ADM9240_REG_TEMP_MAX(i), 127);
  302. if (err < 0)
  303. return err;
  304. }
  305. /* start measurement cycle */
  306. err = regmap_write(data->regmap, ADM9240_REG_CONFIG, 1);
  307. if (err < 0)
  308. return err;
  309. dev_info(data->dev,
  310. "cold start: config was 0x%02x mode %u\n", conf, mode);
  311. }
  312. /* read fan divs */
  313. err = regmap_read(data->regmap, ADM9240_REG_VID_FAN_DIV, &regval);
  314. if (err < 0)
  315. return err;
  316. data->fan_div[0] = (regval >> 4) & 3;
  317. data->fan_div[1] = (regval >> 6) & 3;
  318. return 0;
  319. }
  320. static int adm9240_chip_read(struct device *dev, u32 attr, long *val)
  321. {
  322. struct adm9240_data *data = dev_get_drvdata(dev);
  323. u8 regs[2];
  324. int err;
  325. switch (attr) {
  326. case hwmon_chip_alarms:
  327. err = regmap_bulk_read(data->regmap, ADM9240_REG_INT(0), &regs, 2);
  328. if (err < 0)
  329. return err;
  330. *val = regs[0] | regs[1] << 8;
  331. break;
  332. default:
  333. return -EOPNOTSUPP;
  334. }
  335. return 0;
  336. }
  337. static int adm9240_intrusion_read(struct device *dev, u32 attr, long *val)
  338. {
  339. struct adm9240_data *data = dev_get_drvdata(dev);
  340. unsigned int regval;
  341. int err;
  342. switch (attr) {
  343. case hwmon_intrusion_alarm:
  344. err = regmap_read(data->regmap, ADM9240_REG_INT(1), &regval);
  345. if (err < 0)
  346. return err;
  347. *val = !!(regval & BIT(4));
  348. break;
  349. default:
  350. return -EOPNOTSUPP;
  351. }
  352. return 0;
  353. }
  354. static int adm9240_intrusion_write(struct device *dev, u32 attr, long val)
  355. {
  356. struct adm9240_data *data = dev_get_drvdata(dev);
  357. int err;
  358. switch (attr) {
  359. case hwmon_intrusion_alarm:
  360. if (val)
  361. return -EINVAL;
  362. err = regmap_write(data->regmap, ADM9240_REG_CHASSIS_CLEAR, 0x80);
  363. if (err < 0)
  364. return err;
  365. dev_dbg(data->dev, "chassis intrusion latch cleared\n");
  366. break;
  367. default:
  368. return -EOPNOTSUPP;
  369. }
  370. return 0;
  371. }
  372. static int adm9240_in_read(struct device *dev, u32 attr, int channel, long *val)
  373. {
  374. struct adm9240_data *data = dev_get_drvdata(dev);
  375. unsigned int regval;
  376. int reg;
  377. int err;
  378. switch (attr) {
  379. case hwmon_in_input:
  380. reg = ADM9240_REG_IN(channel);
  381. break;
  382. case hwmon_in_min:
  383. reg = ADM9240_REG_IN_MIN(channel);
  384. break;
  385. case hwmon_in_max:
  386. reg = ADM9240_REG_IN_MAX(channel);
  387. break;
  388. case hwmon_in_alarm:
  389. if (channel < 4) {
  390. reg = ADM9240_REG_INT(0);
  391. } else {
  392. reg = ADM9240_REG_INT(1);
  393. channel -= 4;
  394. }
  395. err = regmap_read(data->regmap, reg, &regval);
  396. if (err < 0)
  397. return err;
  398. *val = !!(regval & BIT(channel));
  399. return 0;
  400. default:
  401. return -EOPNOTSUPP;
  402. }
  403. err = regmap_read(data->regmap, reg, &regval);
  404. if (err < 0)
  405. return err;
  406. *val = IN_FROM_REG(regval, channel);
  407. return 0;
  408. }
  409. static int adm9240_in_write(struct device *dev, u32 attr, int channel, long val)
  410. {
  411. struct adm9240_data *data = dev_get_drvdata(dev);
  412. int reg;
  413. switch (attr) {
  414. case hwmon_in_min:
  415. reg = ADM9240_REG_IN_MIN(channel);
  416. break;
  417. case hwmon_in_max:
  418. reg = ADM9240_REG_IN_MAX(channel);
  419. break;
  420. default:
  421. return -EOPNOTSUPP;
  422. }
  423. return regmap_write(data->regmap, reg, IN_TO_REG(val, channel));
  424. }
  425. static int adm9240_fan_read(struct device *dev, u32 attr, int channel, long *val)
  426. {
  427. struct adm9240_data *data = dev_get_drvdata(dev);
  428. unsigned int regval;
  429. int err;
  430. switch (attr) {
  431. case hwmon_fan_input:
  432. mutex_lock(&data->update_lock);
  433. err = regmap_read(data->regmap, ADM9240_REG_FAN(channel), &regval);
  434. if (err < 0) {
  435. mutex_unlock(&data->update_lock);
  436. return err;
  437. }
  438. if (regval == 255 && data->fan_div[channel] < 3) {
  439. /* adjust fan clock divider on overflow */
  440. err = adm9240_write_fan_div(data, channel,
  441. ++data->fan_div[channel]);
  442. if (err) {
  443. mutex_unlock(&data->update_lock);
  444. return err;
  445. }
  446. }
  447. *val = FAN_FROM_REG(regval, BIT(data->fan_div[channel]));
  448. mutex_unlock(&data->update_lock);
  449. break;
  450. case hwmon_fan_div:
  451. *val = BIT(data->fan_div[channel]);
  452. break;
  453. case hwmon_fan_min:
  454. err = regmap_read(data->regmap, ADM9240_REG_FAN_MIN(channel), &regval);
  455. if (err < 0)
  456. return err;
  457. *val = FAN_FROM_REG(regval, BIT(data->fan_div[channel]));
  458. break;
  459. case hwmon_fan_alarm:
  460. err = regmap_read(data->regmap, ADM9240_REG_INT(0), &regval);
  461. if (err < 0)
  462. return err;
  463. *val = !!(regval & BIT(channel + 6));
  464. break;
  465. default:
  466. return -EOPNOTSUPP;
  467. }
  468. return 0;
  469. }
  470. static int adm9240_fan_write(struct device *dev, u32 attr, int channel, long val)
  471. {
  472. struct adm9240_data *data = dev_get_drvdata(dev);
  473. int err;
  474. switch (attr) {
  475. case hwmon_fan_min:
  476. err = adm9240_fan_min_write(data, channel, val);
  477. if (err < 0)
  478. return err;
  479. break;
  480. default:
  481. return -EOPNOTSUPP;
  482. }
  483. return 0;
  484. }
  485. static int adm9240_temp_read(struct device *dev, u32 attr, int channel, long *val)
  486. {
  487. struct adm9240_data *data = dev_get_drvdata(dev);
  488. unsigned int regval;
  489. int err, temp;
  490. switch (attr) {
  491. case hwmon_temp_input:
  492. err = regmap_read(data->regmap, ADM9240_REG_TEMP, &regval);
  493. if (err < 0)
  494. return err;
  495. temp = regval << 1;
  496. err = regmap_read(data->regmap, ADM9240_REG_TEMP_CONF, &regval);
  497. if (err < 0)
  498. return err;
  499. temp |= regval >> 7;
  500. *val = sign_extend32(temp, 8) * 500;
  501. break;
  502. case hwmon_temp_max:
  503. err = regmap_read(data->regmap, ADM9240_REG_TEMP_MAX(0), &regval);
  504. if (err < 0)
  505. return err;
  506. *val = (s8)regval * 1000;
  507. break;
  508. case hwmon_temp_max_hyst:
  509. err = regmap_read(data->regmap, ADM9240_REG_TEMP_MAX(1), &regval);
  510. if (err < 0)
  511. return err;
  512. *val = (s8)regval * 1000;
  513. break;
  514. case hwmon_temp_alarm:
  515. err = regmap_read(data->regmap, ADM9240_REG_INT(0), &regval);
  516. if (err < 0)
  517. return err;
  518. *val = !!(regval & BIT(4));
  519. break;
  520. default:
  521. return -EOPNOTSUPP;
  522. }
  523. return 0;
  524. }
  525. static int adm9240_temp_write(struct device *dev, u32 attr, int channel, long val)
  526. {
  527. struct adm9240_data *data = dev_get_drvdata(dev);
  528. int reg;
  529. switch (attr) {
  530. case hwmon_temp_max:
  531. reg = ADM9240_REG_TEMP_MAX(0);
  532. break;
  533. case hwmon_temp_max_hyst:
  534. reg = ADM9240_REG_TEMP_MAX(1);
  535. break;
  536. default:
  537. return -EOPNOTSUPP;
  538. }
  539. return regmap_write(data->regmap, reg, TEMP_TO_REG(val));
  540. }
  541. static int adm9240_read(struct device *dev, enum hwmon_sensor_types type, u32 attr,
  542. int channel, long *val)
  543. {
  544. switch (type) {
  545. case hwmon_chip:
  546. return adm9240_chip_read(dev, attr, val);
  547. case hwmon_intrusion:
  548. return adm9240_intrusion_read(dev, attr, val);
  549. case hwmon_in:
  550. return adm9240_in_read(dev, attr, channel, val);
  551. case hwmon_fan:
  552. return adm9240_fan_read(dev, attr, channel, val);
  553. case hwmon_temp:
  554. return adm9240_temp_read(dev, attr, channel, val);
  555. default:
  556. return -EOPNOTSUPP;
  557. }
  558. }
  559. static int adm9240_write(struct device *dev, enum hwmon_sensor_types type, u32 attr,
  560. int channel, long val)
  561. {
  562. switch (type) {
  563. case hwmon_intrusion:
  564. return adm9240_intrusion_write(dev, attr, val);
  565. case hwmon_in:
  566. return adm9240_in_write(dev, attr, channel, val);
  567. case hwmon_fan:
  568. return adm9240_fan_write(dev, attr, channel, val);
  569. case hwmon_temp:
  570. return adm9240_temp_write(dev, attr, channel, val);
  571. default:
  572. return -EOPNOTSUPP;
  573. }
  574. }
  575. static umode_t adm9240_is_visible(const void *_data, enum hwmon_sensor_types type,
  576. u32 attr, int channel)
  577. {
  578. umode_t mode = 0;
  579. switch (type) {
  580. case hwmon_chip:
  581. switch (attr) {
  582. case hwmon_chip_alarms:
  583. mode = 0444;
  584. break;
  585. default:
  586. break;
  587. }
  588. break;
  589. case hwmon_intrusion:
  590. switch (attr) {
  591. case hwmon_intrusion_alarm:
  592. mode = 0644;
  593. break;
  594. default:
  595. break;
  596. }
  597. break;
  598. case hwmon_temp:
  599. switch (attr) {
  600. case hwmon_temp:
  601. case hwmon_temp_alarm:
  602. mode = 0444;
  603. break;
  604. case hwmon_temp_max:
  605. case hwmon_temp_max_hyst:
  606. mode = 0644;
  607. break;
  608. default:
  609. break;
  610. }
  611. break;
  612. case hwmon_fan:
  613. switch (attr) {
  614. case hwmon_fan_input:
  615. case hwmon_fan_div:
  616. case hwmon_fan_alarm:
  617. mode = 0444;
  618. break;
  619. case hwmon_fan_min:
  620. mode = 0644;
  621. break;
  622. default:
  623. break;
  624. }
  625. break;
  626. case hwmon_in:
  627. switch (attr) {
  628. case hwmon_in_input:
  629. case hwmon_in_alarm:
  630. mode = 0444;
  631. break;
  632. case hwmon_in_min:
  633. case hwmon_in_max:
  634. mode = 0644;
  635. break;
  636. default:
  637. break;
  638. }
  639. break;
  640. default:
  641. break;
  642. }
  643. return mode;
  644. }
  645. static const struct hwmon_ops adm9240_hwmon_ops = {
  646. .is_visible = adm9240_is_visible,
  647. .read = adm9240_read,
  648. .write = adm9240_write,
  649. };
  650. static const struct hwmon_channel_info *adm9240_info[] = {
  651. HWMON_CHANNEL_INFO(chip, HWMON_C_ALARMS),
  652. HWMON_CHANNEL_INFO(intrusion, HWMON_INTRUSION_ALARM),
  653. HWMON_CHANNEL_INFO(temp,
  654. HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MAX_HYST | HWMON_T_ALARM),
  655. HWMON_CHANNEL_INFO(in,
  656. HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX | HWMON_I_ALARM,
  657. HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX | HWMON_I_ALARM,
  658. HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX | HWMON_I_ALARM,
  659. HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX | HWMON_I_ALARM,
  660. HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX | HWMON_I_ALARM,
  661. HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX | HWMON_I_ALARM),
  662. HWMON_CHANNEL_INFO(fan,
  663. HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_DIV | HWMON_F_ALARM,
  664. HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_DIV | HWMON_F_ALARM),
  665. NULL
  666. };
  667. static const struct hwmon_chip_info adm9240_chip_info = {
  668. .ops = &adm9240_hwmon_ops,
  669. .info = adm9240_info,
  670. };
  671. static bool adm9240_volatile_reg(struct device *dev, unsigned int reg)
  672. {
  673. switch (reg) {
  674. case ADM9240_REG_IN(0) ... ADM9240_REG_IN(5):
  675. case ADM9240_REG_FAN(0) ... ADM9240_REG_FAN(1):
  676. case ADM9240_REG_INT(0) ... ADM9240_REG_INT(1):
  677. case ADM9240_REG_TEMP:
  678. case ADM9240_REG_TEMP_CONF:
  679. case ADM9240_REG_VID_FAN_DIV:
  680. case ADM9240_REG_VID4:
  681. case ADM9240_REG_ANALOG_OUT:
  682. return true;
  683. default:
  684. return false;
  685. }
  686. }
  687. static const struct regmap_config adm9240_regmap_config = {
  688. .reg_bits = 8,
  689. .val_bits = 8,
  690. .use_single_read = true,
  691. .use_single_write = true,
  692. .volatile_reg = adm9240_volatile_reg,
  693. };
  694. static int adm9240_probe(struct i2c_client *client)
  695. {
  696. struct device *dev = &client->dev;
  697. struct device *hwmon_dev;
  698. struct adm9240_data *data;
  699. int err;
  700. data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
  701. if (!data)
  702. return -ENOMEM;
  703. data->dev = dev;
  704. mutex_init(&data->update_lock);
  705. data->regmap = devm_regmap_init_i2c(client, &adm9240_regmap_config);
  706. if (IS_ERR(data->regmap))
  707. return PTR_ERR(data->regmap);
  708. err = adm9240_init_client(data);
  709. if (err < 0)
  710. return err;
  711. hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name, data,
  712. &adm9240_chip_info,
  713. adm9240_groups);
  714. return PTR_ERR_OR_ZERO(hwmon_dev);
  715. }
  716. static const struct i2c_device_id adm9240_id[] = {
  717. { "adm9240", adm9240 },
  718. { "ds1780", ds1780 },
  719. { "lm81", lm81 },
  720. { }
  721. };
  722. MODULE_DEVICE_TABLE(i2c, adm9240_id);
  723. static struct i2c_driver adm9240_driver = {
  724. .class = I2C_CLASS_HWMON,
  725. .driver = {
  726. .name = "adm9240",
  727. },
  728. .probe_new = adm9240_probe,
  729. .id_table = adm9240_id,
  730. .detect = adm9240_detect,
  731. .address_list = normal_i2c,
  732. };
  733. module_i2c_driver(adm9240_driver);
  734. MODULE_AUTHOR("Michiel Rook <[email protected]>, "
  735. "Grant Coady <[email protected]> and others");
  736. MODULE_DESCRIPTION("ADM9240/DS1780/LM81 driver");
  737. MODULE_LICENSE("GPL");