adm1031.c 32 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * adm1031.c - Part of lm_sensors, Linux kernel modules for hardware
  4. * monitoring
  5. * Based on lm75.c and lm85.c
  6. * Supports adm1030 / adm1031
  7. * Copyright (C) 2004 Alexandre d'Alton <alex@alexdalton.org>
  8. * Reworked by Jean Delvare <jdelvare@suse.de>
  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/err.h>
  18. #include <linux/mutex.h>
  19. /* Following macros takes channel parameter starting from 0 to 2 */
  20. #define ADM1031_REG_FAN_SPEED(nr) (0x08 + (nr))
  21. #define ADM1031_REG_FAN_DIV(nr) (0x20 + (nr))
  22. #define ADM1031_REG_PWM (0x22)
  23. #define ADM1031_REG_FAN_MIN(nr) (0x10 + (nr))
  24. #define ADM1031_REG_FAN_FILTER (0x23)
  25. #define ADM1031_REG_TEMP_OFFSET(nr) (0x0d + (nr))
  26. #define ADM1031_REG_TEMP_MAX(nr) (0x14 + 4 * (nr))
  27. #define ADM1031_REG_TEMP_MIN(nr) (0x15 + 4 * (nr))
  28. #define ADM1031_REG_TEMP_CRIT(nr) (0x16 + 4 * (nr))
  29. #define ADM1031_REG_TEMP(nr) (0x0a + (nr))
  30. #define ADM1031_REG_AUTO_TEMP(nr) (0x24 + (nr))
  31. #define ADM1031_REG_STATUS(nr) (0x2 + (nr))
  32. #define ADM1031_REG_CONF1 0x00
  33. #define ADM1031_REG_CONF2 0x01
  34. #define ADM1031_REG_EXT_TEMP 0x06
  35. #define ADM1031_CONF1_MONITOR_ENABLE 0x01 /* Monitoring enable */
  36. #define ADM1031_CONF1_PWM_INVERT 0x08 /* PWM Invert */
  37. #define ADM1031_CONF1_AUTO_MODE 0x80 /* Auto FAN */
  38. #define ADM1031_CONF2_PWM1_ENABLE 0x01
  39. #define ADM1031_CONF2_PWM2_ENABLE 0x02
  40. #define ADM1031_CONF2_TACH1_ENABLE 0x04
  41. #define ADM1031_CONF2_TACH2_ENABLE 0x08
  42. #define ADM1031_CONF2_TEMP_ENABLE(chan) (0x10 << (chan))
  43. #define ADM1031_UPDATE_RATE_MASK 0x1c
  44. #define ADM1031_UPDATE_RATE_SHIFT 2
  45. /* Addresses to scan */
  46. static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
  47. enum chips { adm1030, adm1031 };
  48. typedef u8 auto_chan_table_t[8][2];
  49. /* Each client has this additional data */
  50. struct adm1031_data {
  51. struct i2c_client *client;
  52. const struct attribute_group *groups[3];
  53. struct mutex update_lock;
  54. int chip_type;
  55. char valid; /* !=0 if following fields are valid */
  56. unsigned long last_updated; /* In jiffies */
  57. unsigned int update_interval; /* In milliseconds */
  58. /*
  59. * The chan_select_table contains the possible configurations for
  60. * auto fan control.
  61. */
  62. const auto_chan_table_t *chan_select_table;
  63. u16 alarm;
  64. u8 conf1;
  65. u8 conf2;
  66. u8 fan[2];
  67. u8 fan_div[2];
  68. u8 fan_min[2];
  69. u8 pwm[2];
  70. u8 old_pwm[2];
  71. s8 temp[3];
  72. u8 ext_temp[3];
  73. u8 auto_temp[3];
  74. u8 auto_temp_min[3];
  75. u8 auto_temp_off[3];
  76. u8 auto_temp_max[3];
  77. s8 temp_offset[3];
  78. s8 temp_min[3];
  79. s8 temp_max[3];
  80. s8 temp_crit[3];
  81. };
  82. static inline u8 adm1031_read_value(struct i2c_client *client, u8 reg)
  83. {
  84. return i2c_smbus_read_byte_data(client, reg);
  85. }
  86. static inline int
  87. adm1031_write_value(struct i2c_client *client, u8 reg, unsigned int value)
  88. {
  89. return i2c_smbus_write_byte_data(client, reg, value);
  90. }
  91. static struct adm1031_data *adm1031_update_device(struct device *dev)
  92. {
  93. struct adm1031_data *data = dev_get_drvdata(dev);
  94. struct i2c_client *client = data->client;
  95. unsigned long next_update;
  96. int chan;
  97. mutex_lock(&data->update_lock);
  98. next_update = data->last_updated
  99. + msecs_to_jiffies(data->update_interval);
  100. if (time_after(jiffies, next_update) || !data->valid) {
  101. dev_dbg(&client->dev, "Starting adm1031 update\n");
  102. for (chan = 0;
  103. chan < ((data->chip_type == adm1031) ? 3 : 2); chan++) {
  104. u8 oldh, newh;
  105. oldh =
  106. adm1031_read_value(client, ADM1031_REG_TEMP(chan));
  107. data->ext_temp[chan] =
  108. adm1031_read_value(client, ADM1031_REG_EXT_TEMP);
  109. newh =
  110. adm1031_read_value(client, ADM1031_REG_TEMP(chan));
  111. if (newh != oldh) {
  112. data->ext_temp[chan] =
  113. adm1031_read_value(client,
  114. ADM1031_REG_EXT_TEMP);
  115. #ifdef DEBUG
  116. oldh =
  117. adm1031_read_value(client,
  118. ADM1031_REG_TEMP(chan));
  119. /* oldh is actually newer */
  120. if (newh != oldh)
  121. dev_warn(&client->dev,
  122. "Remote temperature may be wrong.\n");
  123. #endif
  124. }
  125. data->temp[chan] = newh;
  126. data->temp_offset[chan] =
  127. adm1031_read_value(client,
  128. ADM1031_REG_TEMP_OFFSET(chan));
  129. data->temp_min[chan] =
  130. adm1031_read_value(client,
  131. ADM1031_REG_TEMP_MIN(chan));
  132. data->temp_max[chan] =
  133. adm1031_read_value(client,
  134. ADM1031_REG_TEMP_MAX(chan));
  135. data->temp_crit[chan] =
  136. adm1031_read_value(client,
  137. ADM1031_REG_TEMP_CRIT(chan));
  138. data->auto_temp[chan] =
  139. adm1031_read_value(client,
  140. ADM1031_REG_AUTO_TEMP(chan));
  141. }
  142. data->conf1 = adm1031_read_value(client, ADM1031_REG_CONF1);
  143. data->conf2 = adm1031_read_value(client, ADM1031_REG_CONF2);
  144. data->alarm = adm1031_read_value(client, ADM1031_REG_STATUS(0))
  145. | (adm1031_read_value(client, ADM1031_REG_STATUS(1)) << 8);
  146. if (data->chip_type == adm1030)
  147. data->alarm &= 0xc0ff;
  148. for (chan = 0; chan < (data->chip_type == adm1030 ? 1 : 2);
  149. chan++) {
  150. data->fan_div[chan] =
  151. adm1031_read_value(client,
  152. ADM1031_REG_FAN_DIV(chan));
  153. data->fan_min[chan] =
  154. adm1031_read_value(client,
  155. ADM1031_REG_FAN_MIN(chan));
  156. data->fan[chan] =
  157. adm1031_read_value(client,
  158. ADM1031_REG_FAN_SPEED(chan));
  159. data->pwm[chan] =
  160. (adm1031_read_value(client,
  161. ADM1031_REG_PWM) >> (4 * chan)) & 0x0f;
  162. }
  163. data->last_updated = jiffies;
  164. data->valid = 1;
  165. }
  166. mutex_unlock(&data->update_lock);
  167. return data;
  168. }
  169. #define TEMP_TO_REG(val) (((val) < 0 ? ((val - 500) / 1000) : \
  170. ((val + 500) / 1000)))
  171. #define TEMP_FROM_REG(val) ((val) * 1000)
  172. #define TEMP_FROM_REG_EXT(val, ext) (TEMP_FROM_REG(val) + (ext) * 125)
  173. #define TEMP_OFFSET_TO_REG(val) (TEMP_TO_REG(val) & 0x8f)
  174. #define TEMP_OFFSET_FROM_REG(val) TEMP_FROM_REG((val) < 0 ? \
  175. (val) | 0x70 : (val))
  176. #define FAN_FROM_REG(reg, div) ((reg) ? \
  177. (11250 * 60) / ((reg) * (div)) : 0)
  178. static int FAN_TO_REG(int reg, int div)
  179. {
  180. int tmp;
  181. tmp = FAN_FROM_REG(clamp_val(reg, 0, 65535), div);
  182. return tmp > 255 ? 255 : tmp;
  183. }
  184. #define FAN_DIV_FROM_REG(reg) (1<<(((reg)&0xc0)>>6))
  185. #define PWM_TO_REG(val) (clamp_val((val), 0, 255) >> 4)
  186. #define PWM_FROM_REG(val) ((val) << 4)
  187. #define FAN_CHAN_FROM_REG(reg) (((reg) >> 5) & 7)
  188. #define FAN_CHAN_TO_REG(val, reg) \
  189. (((reg) & 0x1F) | (((val) << 5) & 0xe0))
  190. #define AUTO_TEMP_MIN_TO_REG(val, reg) \
  191. ((((val) / 500) & 0xf8) | ((reg) & 0x7))
  192. #define AUTO_TEMP_RANGE_FROM_REG(reg) (5000 * (1 << ((reg) & 0x7)))
  193. #define AUTO_TEMP_MIN_FROM_REG(reg) (1000 * ((((reg) >> 3) & 0x1f) << 2))
  194. #define AUTO_TEMP_MIN_FROM_REG_DEG(reg) ((((reg) >> 3) & 0x1f) << 2)
  195. #define AUTO_TEMP_OFF_FROM_REG(reg) \
  196. (AUTO_TEMP_MIN_FROM_REG(reg) - 5000)
  197. #define AUTO_TEMP_MAX_FROM_REG(reg) \
  198. (AUTO_TEMP_RANGE_FROM_REG(reg) + \
  199. AUTO_TEMP_MIN_FROM_REG(reg))
  200. static int AUTO_TEMP_MAX_TO_REG(int val, int reg, int pwm)
  201. {
  202. int ret;
  203. int range = val - AUTO_TEMP_MIN_FROM_REG(reg);
  204. range = ((val - AUTO_TEMP_MIN_FROM_REG(reg))*10)/(16 - pwm);
  205. ret = ((reg & 0xf8) |
  206. (range < 10000 ? 0 :
  207. range < 20000 ? 1 :
  208. range < 40000 ? 2 : range < 80000 ? 3 : 4));
  209. return ret;
  210. }
  211. /* FAN auto control */
  212. #define GET_FAN_AUTO_BITFIELD(data, idx) \
  213. (*(data)->chan_select_table)[FAN_CHAN_FROM_REG((data)->conf1)][idx % 2]
  214. /*
  215. * The tables below contains the possible values for the auto fan
  216. * control bitfields. the index in the table is the register value.
  217. * MSb is the auto fan control enable bit, so the four first entries
  218. * in the table disables auto fan control when both bitfields are zero.
  219. */
  220. static const auto_chan_table_t auto_channel_select_table_adm1031 = {
  221. { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
  222. { 2 /* 0b010 */ , 4 /* 0b100 */ },
  223. { 2 /* 0b010 */ , 2 /* 0b010 */ },
  224. { 4 /* 0b100 */ , 4 /* 0b100 */ },
  225. { 7 /* 0b111 */ , 7 /* 0b111 */ },
  226. };
  227. static const auto_chan_table_t auto_channel_select_table_adm1030 = {
  228. { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
  229. { 2 /* 0b10 */ , 0 },
  230. { 0xff /* invalid */ , 0 },
  231. { 0xff /* invalid */ , 0 },
  232. { 3 /* 0b11 */ , 0 },
  233. };
  234. /*
  235. * That function checks if a bitfield is valid and returns the other bitfield
  236. * nearest match if no exact match where found.
  237. */
  238. static int
  239. get_fan_auto_nearest(struct adm1031_data *data, int chan, u8 val, u8 reg)
  240. {
  241. int i;
  242. int first_match = -1, exact_match = -1;
  243. u8 other_reg_val =
  244. (*data->chan_select_table)[FAN_CHAN_FROM_REG(reg)][chan ? 0 : 1];
  245. if (val == 0)
  246. return 0;
  247. for (i = 0; i < 8; i++) {
  248. if ((val == (*data->chan_select_table)[i][chan]) &&
  249. ((*data->chan_select_table)[i][chan ? 0 : 1] ==
  250. other_reg_val)) {
  251. /* We found an exact match */
  252. exact_match = i;
  253. break;
  254. } else if (val == (*data->chan_select_table)[i][chan] &&
  255. first_match == -1) {
  256. /*
  257. * Save the first match in case of an exact match has
  258. * not been found
  259. */
  260. first_match = i;
  261. }
  262. }
  263. if (exact_match >= 0)
  264. return exact_match;
  265. else if (first_match >= 0)
  266. return first_match;
  267. return -EINVAL;
  268. }
  269. static ssize_t fan_auto_channel_show(struct device *dev,
  270. struct device_attribute *attr, char *buf)
  271. {
  272. int nr = to_sensor_dev_attr(attr)->index;
  273. struct adm1031_data *data = adm1031_update_device(dev);
  274. return sprintf(buf, "%d\n", GET_FAN_AUTO_BITFIELD(data, nr));
  275. }
  276. static ssize_t
  277. fan_auto_channel_store(struct device *dev, struct device_attribute *attr,
  278. const char *buf, size_t count)
  279. {
  280. struct adm1031_data *data = dev_get_drvdata(dev);
  281. struct i2c_client *client = data->client;
  282. int nr = to_sensor_dev_attr(attr)->index;
  283. long val;
  284. u8 reg;
  285. int ret;
  286. u8 old_fan_mode;
  287. ret = kstrtol(buf, 10, &val);
  288. if (ret)
  289. return ret;
  290. old_fan_mode = data->conf1;
  291. mutex_lock(&data->update_lock);
  292. ret = get_fan_auto_nearest(data, nr, val, data->conf1);
  293. if (ret < 0) {
  294. mutex_unlock(&data->update_lock);
  295. return ret;
  296. }
  297. reg = ret;
  298. data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1);
  299. if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) ^
  300. (old_fan_mode & ADM1031_CONF1_AUTO_MODE)) {
  301. if (data->conf1 & ADM1031_CONF1_AUTO_MODE) {
  302. /*
  303. * Switch to Auto Fan Mode
  304. * Save PWM registers
  305. * Set PWM registers to 33% Both
  306. */
  307. data->old_pwm[0] = data->pwm[0];
  308. data->old_pwm[1] = data->pwm[1];
  309. adm1031_write_value(client, ADM1031_REG_PWM, 0x55);
  310. } else {
  311. /* Switch to Manual Mode */
  312. data->pwm[0] = data->old_pwm[0];
  313. data->pwm[1] = data->old_pwm[1];
  314. /* Restore PWM registers */
  315. adm1031_write_value(client, ADM1031_REG_PWM,
  316. data->pwm[0] | (data->pwm[1] << 4));
  317. }
  318. }
  319. data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1);
  320. adm1031_write_value(client, ADM1031_REG_CONF1, data->conf1);
  321. mutex_unlock(&data->update_lock);
  322. return count;
  323. }
  324. static SENSOR_DEVICE_ATTR_RW(auto_fan1_channel, fan_auto_channel, 0);
  325. static SENSOR_DEVICE_ATTR_RW(auto_fan2_channel, fan_auto_channel, 1);
  326. /* Auto Temps */
  327. static ssize_t auto_temp_off_show(struct device *dev,
  328. struct device_attribute *attr, char *buf)
  329. {
  330. int nr = to_sensor_dev_attr(attr)->index;
  331. struct adm1031_data *data = adm1031_update_device(dev);
  332. return sprintf(buf, "%d\n",
  333. AUTO_TEMP_OFF_FROM_REG(data->auto_temp[nr]));
  334. }
  335. static ssize_t auto_temp_min_show(struct device *dev,
  336. struct device_attribute *attr, char *buf)
  337. {
  338. int nr = to_sensor_dev_attr(attr)->index;
  339. struct adm1031_data *data = adm1031_update_device(dev);
  340. return sprintf(buf, "%d\n",
  341. AUTO_TEMP_MIN_FROM_REG(data->auto_temp[nr]));
  342. }
  343. static ssize_t
  344. auto_temp_min_store(struct device *dev, struct device_attribute *attr,
  345. const char *buf, size_t count)
  346. {
  347. struct adm1031_data *data = dev_get_drvdata(dev);
  348. struct i2c_client *client = data->client;
  349. int nr = to_sensor_dev_attr(attr)->index;
  350. long val;
  351. int ret;
  352. ret = kstrtol(buf, 10, &val);
  353. if (ret)
  354. return ret;
  355. val = clamp_val(val, 0, 127000);
  356. mutex_lock(&data->update_lock);
  357. data->auto_temp[nr] = AUTO_TEMP_MIN_TO_REG(val, data->auto_temp[nr]);
  358. adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr),
  359. data->auto_temp[nr]);
  360. mutex_unlock(&data->update_lock);
  361. return count;
  362. }
  363. static ssize_t auto_temp_max_show(struct device *dev,
  364. struct device_attribute *attr, char *buf)
  365. {
  366. int nr = to_sensor_dev_attr(attr)->index;
  367. struct adm1031_data *data = adm1031_update_device(dev);
  368. return sprintf(buf, "%d\n",
  369. AUTO_TEMP_MAX_FROM_REG(data->auto_temp[nr]));
  370. }
  371. static ssize_t
  372. auto_temp_max_store(struct device *dev, struct device_attribute *attr,
  373. const char *buf, size_t count)
  374. {
  375. struct adm1031_data *data = dev_get_drvdata(dev);
  376. struct i2c_client *client = data->client;
  377. int nr = to_sensor_dev_attr(attr)->index;
  378. long val;
  379. int ret;
  380. ret = kstrtol(buf, 10, &val);
  381. if (ret)
  382. return ret;
  383. val = clamp_val(val, 0, 127000);
  384. mutex_lock(&data->update_lock);
  385. data->temp_max[nr] = AUTO_TEMP_MAX_TO_REG(val, data->auto_temp[nr],
  386. data->pwm[nr]);
  387. adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr),
  388. data->temp_max[nr]);
  389. mutex_unlock(&data->update_lock);
  390. return count;
  391. }
  392. static SENSOR_DEVICE_ATTR_RO(auto_temp1_off, auto_temp_off, 0);
  393. static SENSOR_DEVICE_ATTR_RW(auto_temp1_min, auto_temp_min, 0);
  394. static SENSOR_DEVICE_ATTR_RW(auto_temp1_max, auto_temp_max, 0);
  395. static SENSOR_DEVICE_ATTR_RO(auto_temp2_off, auto_temp_off, 1);
  396. static SENSOR_DEVICE_ATTR_RW(auto_temp2_min, auto_temp_min, 1);
  397. static SENSOR_DEVICE_ATTR_RW(auto_temp2_max, auto_temp_max, 1);
  398. static SENSOR_DEVICE_ATTR_RO(auto_temp3_off, auto_temp_off, 2);
  399. static SENSOR_DEVICE_ATTR_RW(auto_temp3_min, auto_temp_min, 2);
  400. static SENSOR_DEVICE_ATTR_RW(auto_temp3_max, auto_temp_max, 2);
  401. /* pwm */
  402. static ssize_t pwm_show(struct device *dev, struct device_attribute *attr,
  403. char *buf)
  404. {
  405. int nr = to_sensor_dev_attr(attr)->index;
  406. struct adm1031_data *data = adm1031_update_device(dev);
  407. return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr]));
  408. }
  409. static ssize_t pwm_store(struct device *dev, struct device_attribute *attr,
  410. const char *buf, size_t count)
  411. {
  412. struct adm1031_data *data = dev_get_drvdata(dev);
  413. struct i2c_client *client = data->client;
  414. int nr = to_sensor_dev_attr(attr)->index;
  415. long val;
  416. int ret, reg;
  417. ret = kstrtol(buf, 10, &val);
  418. if (ret)
  419. return ret;
  420. mutex_lock(&data->update_lock);
  421. if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) &&
  422. (((val>>4) & 0xf) != 5)) {
  423. /* In automatic mode, the only PWM accepted is 33% */
  424. mutex_unlock(&data->update_lock);
  425. return -EINVAL;
  426. }
  427. data->pwm[nr] = PWM_TO_REG(val);
  428. reg = adm1031_read_value(client, ADM1031_REG_PWM);
  429. adm1031_write_value(client, ADM1031_REG_PWM,
  430. nr ? ((data->pwm[nr] << 4) & 0xf0) | (reg & 0xf)
  431. : (data->pwm[nr] & 0xf) | (reg & 0xf0));
  432. mutex_unlock(&data->update_lock);
  433. return count;
  434. }
  435. static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);
  436. static SENSOR_DEVICE_ATTR_RW(pwm2, pwm, 1);
  437. static SENSOR_DEVICE_ATTR_RW(auto_fan1_min_pwm, pwm, 0);
  438. static SENSOR_DEVICE_ATTR_RW(auto_fan2_min_pwm, pwm, 1);
  439. /* Fans */
  440. /*
  441. * That function checks the cases where the fan reading is not
  442. * relevant. It is used to provide 0 as fan reading when the fan is
  443. * not supposed to run
  444. */
  445. static int trust_fan_readings(struct adm1031_data *data, int chan)
  446. {
  447. int res = 0;
  448. if (data->conf1 & ADM1031_CONF1_AUTO_MODE) {
  449. switch (data->conf1 & 0x60) {
  450. case 0x00:
  451. /*
  452. * remote temp1 controls fan1,
  453. * remote temp2 controls fan2
  454. */
  455. res = data->temp[chan+1] >=
  456. AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[chan+1]);
  457. break;
  458. case 0x20: /* remote temp1 controls both fans */
  459. res =
  460. data->temp[1] >=
  461. AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1]);
  462. break;
  463. case 0x40: /* remote temp2 controls both fans */
  464. res =
  465. data->temp[2] >=
  466. AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2]);
  467. break;
  468. case 0x60: /* max controls both fans */
  469. res =
  470. data->temp[0] >=
  471. AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[0])
  472. || data->temp[1] >=
  473. AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1])
  474. || (data->chip_type == adm1031
  475. && data->temp[2] >=
  476. AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2]));
  477. break;
  478. }
  479. } else {
  480. res = data->pwm[chan] > 0;
  481. }
  482. return res;
  483. }
  484. static ssize_t fan_show(struct device *dev, struct device_attribute *attr,
  485. char *buf)
  486. {
  487. int nr = to_sensor_dev_attr(attr)->index;
  488. struct adm1031_data *data = adm1031_update_device(dev);
  489. int value;
  490. value = trust_fan_readings(data, nr) ? FAN_FROM_REG(data->fan[nr],
  491. FAN_DIV_FROM_REG(data->fan_div[nr])) : 0;
  492. return sprintf(buf, "%d\n", value);
  493. }
  494. static ssize_t fan_div_show(struct device *dev, struct device_attribute *attr,
  495. char *buf)
  496. {
  497. int nr = to_sensor_dev_attr(attr)->index;
  498. struct adm1031_data *data = adm1031_update_device(dev);
  499. return sprintf(buf, "%d\n", FAN_DIV_FROM_REG(data->fan_div[nr]));
  500. }
  501. static ssize_t fan_min_show(struct device *dev, struct device_attribute *attr,
  502. char *buf)
  503. {
  504. int nr = to_sensor_dev_attr(attr)->index;
  505. struct adm1031_data *data = adm1031_update_device(dev);
  506. return sprintf(buf, "%d\n",
  507. FAN_FROM_REG(data->fan_min[nr],
  508. FAN_DIV_FROM_REG(data->fan_div[nr])));
  509. }
  510. static ssize_t fan_min_store(struct device *dev,
  511. struct device_attribute *attr, const char *buf,
  512. size_t count)
  513. {
  514. struct adm1031_data *data = dev_get_drvdata(dev);
  515. struct i2c_client *client = data->client;
  516. int nr = to_sensor_dev_attr(attr)->index;
  517. long val;
  518. int ret;
  519. ret = kstrtol(buf, 10, &val);
  520. if (ret)
  521. return ret;
  522. mutex_lock(&data->update_lock);
  523. if (val) {
  524. data->fan_min[nr] =
  525. FAN_TO_REG(val, FAN_DIV_FROM_REG(data->fan_div[nr]));
  526. } else {
  527. data->fan_min[nr] = 0xff;
  528. }
  529. adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr), data->fan_min[nr]);
  530. mutex_unlock(&data->update_lock);
  531. return count;
  532. }
  533. static ssize_t fan_div_store(struct device *dev,
  534. struct device_attribute *attr, const char *buf,
  535. size_t count)
  536. {
  537. struct adm1031_data *data = dev_get_drvdata(dev);
  538. struct i2c_client *client = data->client;
  539. int nr = to_sensor_dev_attr(attr)->index;
  540. long val;
  541. u8 tmp;
  542. int old_div;
  543. int new_min;
  544. int ret;
  545. ret = kstrtol(buf, 10, &val);
  546. if (ret)
  547. return ret;
  548. tmp = val == 8 ? 0xc0 :
  549. val == 4 ? 0x80 :
  550. val == 2 ? 0x40 :
  551. val == 1 ? 0x00 :
  552. 0xff;
  553. if (tmp == 0xff)
  554. return -EINVAL;
  555. mutex_lock(&data->update_lock);
  556. /* Get fresh readings */
  557. data->fan_div[nr] = adm1031_read_value(client,
  558. ADM1031_REG_FAN_DIV(nr));
  559. data->fan_min[nr] = adm1031_read_value(client,
  560. ADM1031_REG_FAN_MIN(nr));
  561. /* Write the new clock divider and fan min */
  562. old_div = FAN_DIV_FROM_REG(data->fan_div[nr]);
  563. data->fan_div[nr] = tmp | (0x3f & data->fan_div[nr]);
  564. new_min = data->fan_min[nr] * old_div / val;
  565. data->fan_min[nr] = new_min > 0xff ? 0xff : new_min;
  566. adm1031_write_value(client, ADM1031_REG_FAN_DIV(nr),
  567. data->fan_div[nr]);
  568. adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr),
  569. data->fan_min[nr]);
  570. /* Invalidate the cache: fan speed is no longer valid */
  571. data->valid = 0;
  572. mutex_unlock(&data->update_lock);
  573. return count;
  574. }
  575. static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0);
  576. static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);
  577. static SENSOR_DEVICE_ATTR_RW(fan1_div, fan_div, 0);
  578. static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1);
  579. static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
  580. static SENSOR_DEVICE_ATTR_RW(fan2_div, fan_div, 1);
  581. /* Temps */
  582. static ssize_t temp_show(struct device *dev, struct device_attribute *attr,
  583. char *buf)
  584. {
  585. int nr = to_sensor_dev_attr(attr)->index;
  586. struct adm1031_data *data = adm1031_update_device(dev);
  587. int ext;
  588. ext = nr == 0 ?
  589. ((data->ext_temp[nr] >> 6) & 0x3) * 2 :
  590. (((data->ext_temp[nr] >> ((nr - 1) * 3)) & 7));
  591. return sprintf(buf, "%d\n", TEMP_FROM_REG_EXT(data->temp[nr], ext));
  592. }
  593. static ssize_t temp_offset_show(struct device *dev,
  594. struct device_attribute *attr, char *buf)
  595. {
  596. int nr = to_sensor_dev_attr(attr)->index;
  597. struct adm1031_data *data = adm1031_update_device(dev);
  598. return sprintf(buf, "%d\n",
  599. TEMP_OFFSET_FROM_REG(data->temp_offset[nr]));
  600. }
  601. static ssize_t temp_min_show(struct device *dev,
  602. struct device_attribute *attr, char *buf)
  603. {
  604. int nr = to_sensor_dev_attr(attr)->index;
  605. struct adm1031_data *data = adm1031_update_device(dev);
  606. return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr]));
  607. }
  608. static ssize_t temp_max_show(struct device *dev,
  609. struct device_attribute *attr, char *buf)
  610. {
  611. int nr = to_sensor_dev_attr(attr)->index;
  612. struct adm1031_data *data = adm1031_update_device(dev);
  613. return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr]));
  614. }
  615. static ssize_t temp_crit_show(struct device *dev,
  616. struct device_attribute *attr, char *buf)
  617. {
  618. int nr = to_sensor_dev_attr(attr)->index;
  619. struct adm1031_data *data = adm1031_update_device(dev);
  620. return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_crit[nr]));
  621. }
  622. static ssize_t temp_offset_store(struct device *dev,
  623. struct device_attribute *attr,
  624. const char *buf, size_t count)
  625. {
  626. struct adm1031_data *data = dev_get_drvdata(dev);
  627. struct i2c_client *client = data->client;
  628. int nr = to_sensor_dev_attr(attr)->index;
  629. long val;
  630. int ret;
  631. ret = kstrtol(buf, 10, &val);
  632. if (ret)
  633. return ret;
  634. val = clamp_val(val, -15000, 15000);
  635. mutex_lock(&data->update_lock);
  636. data->temp_offset[nr] = TEMP_OFFSET_TO_REG(val);
  637. adm1031_write_value(client, ADM1031_REG_TEMP_OFFSET(nr),
  638. data->temp_offset[nr]);
  639. mutex_unlock(&data->update_lock);
  640. return count;
  641. }
  642. static ssize_t temp_min_store(struct device *dev,
  643. struct device_attribute *attr, const char *buf,
  644. size_t count)
  645. {
  646. struct adm1031_data *data = dev_get_drvdata(dev);
  647. struct i2c_client *client = data->client;
  648. int nr = to_sensor_dev_attr(attr)->index;
  649. long val;
  650. int ret;
  651. ret = kstrtol(buf, 10, &val);
  652. if (ret)
  653. return ret;
  654. val = clamp_val(val, -55000, 127000);
  655. mutex_lock(&data->update_lock);
  656. data->temp_min[nr] = TEMP_TO_REG(val);
  657. adm1031_write_value(client, ADM1031_REG_TEMP_MIN(nr),
  658. data->temp_min[nr]);
  659. mutex_unlock(&data->update_lock);
  660. return count;
  661. }
  662. static ssize_t temp_max_store(struct device *dev,
  663. struct device_attribute *attr, const char *buf,
  664. size_t count)
  665. {
  666. struct adm1031_data *data = dev_get_drvdata(dev);
  667. struct i2c_client *client = data->client;
  668. int nr = to_sensor_dev_attr(attr)->index;
  669. long val;
  670. int ret;
  671. ret = kstrtol(buf, 10, &val);
  672. if (ret)
  673. return ret;
  674. val = clamp_val(val, -55000, 127000);
  675. mutex_lock(&data->update_lock);
  676. data->temp_max[nr] = TEMP_TO_REG(val);
  677. adm1031_write_value(client, ADM1031_REG_TEMP_MAX(nr),
  678. data->temp_max[nr]);
  679. mutex_unlock(&data->update_lock);
  680. return count;
  681. }
  682. static ssize_t temp_crit_store(struct device *dev,
  683. struct device_attribute *attr, const char *buf,
  684. size_t count)
  685. {
  686. struct adm1031_data *data = dev_get_drvdata(dev);
  687. struct i2c_client *client = data->client;
  688. int nr = to_sensor_dev_attr(attr)->index;
  689. long val;
  690. int ret;
  691. ret = kstrtol(buf, 10, &val);
  692. if (ret)
  693. return ret;
  694. val = clamp_val(val, -55000, 127000);
  695. mutex_lock(&data->update_lock);
  696. data->temp_crit[nr] = TEMP_TO_REG(val);
  697. adm1031_write_value(client, ADM1031_REG_TEMP_CRIT(nr),
  698. data->temp_crit[nr]);
  699. mutex_unlock(&data->update_lock);
  700. return count;
  701. }
  702. static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0);
  703. static SENSOR_DEVICE_ATTR_RW(temp1_offset, temp_offset, 0);
  704. static SENSOR_DEVICE_ATTR_RW(temp1_min, temp_min, 0);
  705. static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0);
  706. static SENSOR_DEVICE_ATTR_RW(temp1_crit, temp_crit, 0);
  707. static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1);
  708. static SENSOR_DEVICE_ATTR_RW(temp2_offset, temp_offset, 1);
  709. static SENSOR_DEVICE_ATTR_RW(temp2_min, temp_min, 1);
  710. static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);
  711. static SENSOR_DEVICE_ATTR_RW(temp2_crit, temp_crit, 1);
  712. static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2);
  713. static SENSOR_DEVICE_ATTR_RW(temp3_offset, temp_offset, 2);
  714. static SENSOR_DEVICE_ATTR_RW(temp3_min, temp_min, 2);
  715. static SENSOR_DEVICE_ATTR_RW(temp3_max, temp_max, 2);
  716. static SENSOR_DEVICE_ATTR_RW(temp3_crit, temp_crit, 2);
  717. /* Alarms */
  718. static ssize_t alarms_show(struct device *dev, struct device_attribute *attr,
  719. char *buf)
  720. {
  721. struct adm1031_data *data = adm1031_update_device(dev);
  722. return sprintf(buf, "%d\n", data->alarm);
  723. }
  724. static DEVICE_ATTR_RO(alarms);
  725. static ssize_t alarm_show(struct device *dev, struct device_attribute *attr,
  726. char *buf)
  727. {
  728. int bitnr = to_sensor_dev_attr(attr)->index;
  729. struct adm1031_data *data = adm1031_update_device(dev);
  730. return sprintf(buf, "%d\n", (data->alarm >> bitnr) & 1);
  731. }
  732. static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm, 0);
  733. static SENSOR_DEVICE_ATTR_RO(fan1_fault, alarm, 1);
  734. static SENSOR_DEVICE_ATTR_RO(temp2_max_alarm, alarm, 2);
  735. static SENSOR_DEVICE_ATTR_RO(temp2_min_alarm, alarm, 3);
  736. static SENSOR_DEVICE_ATTR_RO(temp2_crit_alarm, alarm, 4);
  737. static SENSOR_DEVICE_ATTR_RO(temp2_fault, alarm, 5);
  738. static SENSOR_DEVICE_ATTR_RO(temp1_max_alarm, alarm, 6);
  739. static SENSOR_DEVICE_ATTR_RO(temp1_min_alarm, alarm, 7);
  740. static SENSOR_DEVICE_ATTR_RO(fan2_alarm, alarm, 8);
  741. static SENSOR_DEVICE_ATTR_RO(fan2_fault, alarm, 9);
  742. static SENSOR_DEVICE_ATTR_RO(temp3_max_alarm, alarm, 10);
  743. static SENSOR_DEVICE_ATTR_RO(temp3_min_alarm, alarm, 11);
  744. static SENSOR_DEVICE_ATTR_RO(temp3_crit_alarm, alarm, 12);
  745. static SENSOR_DEVICE_ATTR_RO(temp3_fault, alarm, 13);
  746. static SENSOR_DEVICE_ATTR_RO(temp1_crit_alarm, alarm, 14);
  747. /* Update Interval */
  748. static const unsigned int update_intervals[] = {
  749. 16000, 8000, 4000, 2000, 1000, 500, 250, 125,
  750. };
  751. static ssize_t update_interval_show(struct device *dev,
  752. struct device_attribute *attr, char *buf)
  753. {
  754. struct adm1031_data *data = dev_get_drvdata(dev);
  755. return sprintf(buf, "%u\n", data->update_interval);
  756. }
  757. static ssize_t update_interval_store(struct device *dev,
  758. struct device_attribute *attr,
  759. const char *buf, size_t count)
  760. {
  761. struct adm1031_data *data = dev_get_drvdata(dev);
  762. struct i2c_client *client = data->client;
  763. unsigned long val;
  764. int i, err;
  765. u8 reg;
  766. err = kstrtoul(buf, 10, &val);
  767. if (err)
  768. return err;
  769. /*
  770. * Find the nearest update interval from the table.
  771. * Use it to determine the matching update rate.
  772. */
  773. for (i = 0; i < ARRAY_SIZE(update_intervals) - 1; i++) {
  774. if (val >= update_intervals[i])
  775. break;
  776. }
  777. /* if not found, we point to the last entry (lowest update interval) */
  778. /* set the new update rate while preserving other settings */
  779. reg = adm1031_read_value(client, ADM1031_REG_FAN_FILTER);
  780. reg &= ~ADM1031_UPDATE_RATE_MASK;
  781. reg |= i << ADM1031_UPDATE_RATE_SHIFT;
  782. adm1031_write_value(client, ADM1031_REG_FAN_FILTER, reg);
  783. mutex_lock(&data->update_lock);
  784. data->update_interval = update_intervals[i];
  785. mutex_unlock(&data->update_lock);
  786. return count;
  787. }
  788. static DEVICE_ATTR_RW(update_interval);
  789. static struct attribute *adm1031_attributes[] = {
  790. &sensor_dev_attr_fan1_input.dev_attr.attr,
  791. &sensor_dev_attr_fan1_div.dev_attr.attr,
  792. &sensor_dev_attr_fan1_min.dev_attr.attr,
  793. &sensor_dev_attr_fan1_alarm.dev_attr.attr,
  794. &sensor_dev_attr_fan1_fault.dev_attr.attr,
  795. &sensor_dev_attr_pwm1.dev_attr.attr,
  796. &sensor_dev_attr_auto_fan1_channel.dev_attr.attr,
  797. &sensor_dev_attr_temp1_input.dev_attr.attr,
  798. &sensor_dev_attr_temp1_offset.dev_attr.attr,
  799. &sensor_dev_attr_temp1_min.dev_attr.attr,
  800. &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
  801. &sensor_dev_attr_temp1_max.dev_attr.attr,
  802. &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
  803. &sensor_dev_attr_temp1_crit.dev_attr.attr,
  804. &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
  805. &sensor_dev_attr_temp2_input.dev_attr.attr,
  806. &sensor_dev_attr_temp2_offset.dev_attr.attr,
  807. &sensor_dev_attr_temp2_min.dev_attr.attr,
  808. &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
  809. &sensor_dev_attr_temp2_max.dev_attr.attr,
  810. &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
  811. &sensor_dev_attr_temp2_crit.dev_attr.attr,
  812. &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
  813. &sensor_dev_attr_temp2_fault.dev_attr.attr,
  814. &sensor_dev_attr_auto_temp1_off.dev_attr.attr,
  815. &sensor_dev_attr_auto_temp1_min.dev_attr.attr,
  816. &sensor_dev_attr_auto_temp1_max.dev_attr.attr,
  817. &sensor_dev_attr_auto_temp2_off.dev_attr.attr,
  818. &sensor_dev_attr_auto_temp2_min.dev_attr.attr,
  819. &sensor_dev_attr_auto_temp2_max.dev_attr.attr,
  820. &sensor_dev_attr_auto_fan1_min_pwm.dev_attr.attr,
  821. &dev_attr_update_interval.attr,
  822. &dev_attr_alarms.attr,
  823. NULL
  824. };
  825. static const struct attribute_group adm1031_group = {
  826. .attrs = adm1031_attributes,
  827. };
  828. static struct attribute *adm1031_attributes_opt[] = {
  829. &sensor_dev_attr_fan2_input.dev_attr.attr,
  830. &sensor_dev_attr_fan2_div.dev_attr.attr,
  831. &sensor_dev_attr_fan2_min.dev_attr.attr,
  832. &sensor_dev_attr_fan2_alarm.dev_attr.attr,
  833. &sensor_dev_attr_fan2_fault.dev_attr.attr,
  834. &sensor_dev_attr_pwm2.dev_attr.attr,
  835. &sensor_dev_attr_auto_fan2_channel.dev_attr.attr,
  836. &sensor_dev_attr_temp3_input.dev_attr.attr,
  837. &sensor_dev_attr_temp3_offset.dev_attr.attr,
  838. &sensor_dev_attr_temp3_min.dev_attr.attr,
  839. &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
  840. &sensor_dev_attr_temp3_max.dev_attr.attr,
  841. &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
  842. &sensor_dev_attr_temp3_crit.dev_attr.attr,
  843. &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
  844. &sensor_dev_attr_temp3_fault.dev_attr.attr,
  845. &sensor_dev_attr_auto_temp3_off.dev_attr.attr,
  846. &sensor_dev_attr_auto_temp3_min.dev_attr.attr,
  847. &sensor_dev_attr_auto_temp3_max.dev_attr.attr,
  848. &sensor_dev_attr_auto_fan2_min_pwm.dev_attr.attr,
  849. NULL
  850. };
  851. static const struct attribute_group adm1031_group_opt = {
  852. .attrs = adm1031_attributes_opt,
  853. };
  854. /* Return 0 if detection is successful, -ENODEV otherwise */
  855. static int adm1031_detect(struct i2c_client *client,
  856. struct i2c_board_info *info)
  857. {
  858. struct i2c_adapter *adapter = client->adapter;
  859. const char *name;
  860. int id, co;
  861. if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
  862. return -ENODEV;
  863. id = i2c_smbus_read_byte_data(client, 0x3d);
  864. co = i2c_smbus_read_byte_data(client, 0x3e);
  865. if (!((id == 0x31 || id == 0x30) && co == 0x41))
  866. return -ENODEV;
  867. name = (id == 0x30) ? "adm1030" : "adm1031";
  868. strlcpy(info->type, name, I2C_NAME_SIZE);
  869. return 0;
  870. }
  871. static void adm1031_init_client(struct i2c_client *client)
  872. {
  873. unsigned int read_val;
  874. unsigned int mask;
  875. int i;
  876. struct adm1031_data *data = i2c_get_clientdata(client);
  877. mask = (ADM1031_CONF2_PWM1_ENABLE | ADM1031_CONF2_TACH1_ENABLE);
  878. if (data->chip_type == adm1031) {
  879. mask |= (ADM1031_CONF2_PWM2_ENABLE |
  880. ADM1031_CONF2_TACH2_ENABLE);
  881. }
  882. /* Initialize the ADM1031 chip (enables fan speed reading ) */
  883. read_val = adm1031_read_value(client, ADM1031_REG_CONF2);
  884. if ((read_val | mask) != read_val)
  885. adm1031_write_value(client, ADM1031_REG_CONF2, read_val | mask);
  886. read_val = adm1031_read_value(client, ADM1031_REG_CONF1);
  887. if ((read_val | ADM1031_CONF1_MONITOR_ENABLE) != read_val) {
  888. adm1031_write_value(client, ADM1031_REG_CONF1,
  889. read_val | ADM1031_CONF1_MONITOR_ENABLE);
  890. }
  891. /* Read the chip's update rate */
  892. mask = ADM1031_UPDATE_RATE_MASK;
  893. read_val = adm1031_read_value(client, ADM1031_REG_FAN_FILTER);
  894. i = (read_val & mask) >> ADM1031_UPDATE_RATE_SHIFT;
  895. /* Save it as update interval */
  896. data->update_interval = update_intervals[i];
  897. }
  898. static const struct i2c_device_id adm1031_id[];
  899. static int adm1031_probe(struct i2c_client *client)
  900. {
  901. struct device *dev = &client->dev;
  902. struct device *hwmon_dev;
  903. struct adm1031_data *data;
  904. data = devm_kzalloc(dev, sizeof(struct adm1031_data), GFP_KERNEL);
  905. if (!data)
  906. return -ENOMEM;
  907. i2c_set_clientdata(client, data);
  908. data->client = client;
  909. data->chip_type = i2c_match_id(adm1031_id, client)->driver_data;
  910. mutex_init(&data->update_lock);
  911. if (data->chip_type == adm1030)
  912. data->chan_select_table = &auto_channel_select_table_adm1030;
  913. else
  914. data->chan_select_table = &auto_channel_select_table_adm1031;
  915. /* Initialize the ADM1031 chip */
  916. adm1031_init_client(client);
  917. /* sysfs hooks */
  918. data->groups[0] = &adm1031_group;
  919. if (data->chip_type == adm1031)
  920. data->groups[1] = &adm1031_group_opt;
  921. hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
  922. data, data->groups);
  923. return PTR_ERR_OR_ZERO(hwmon_dev);
  924. }
  925. static const struct i2c_device_id adm1031_id[] = {
  926. { "adm1030", adm1030 },
  927. { "adm1031", adm1031 },
  928. { }
  929. };
  930. MODULE_DEVICE_TABLE(i2c, adm1031_id);
  931. static struct i2c_driver adm1031_driver = {
  932. .class = I2C_CLASS_HWMON,
  933. .driver = {
  934. .name = "adm1031",
  935. },
  936. .probe_new = adm1031_probe,
  937. .id_table = adm1031_id,
  938. .detect = adm1031_detect,
  939. .address_list = normal_i2c,
  940. };
  941. module_i2c_driver(adm1031_driver);
  942. MODULE_AUTHOR("Alexandre d'Alton <alex@alexdalton.org>");
  943. MODULE_DESCRIPTION("ADM1031/ADM1030 driver");
  944. MODULE_LICENSE("GPL");