adt7470.c 39 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * A hwmon driver for the Analog Devices ADT7470
  4. * Copyright (C) 2007 IBM
  5. *
  6. * Author: Darrick J. Wong <darrick.wong@oracle.com>
  7. */
  8. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  9. #include <linux/module.h>
  10. #include <linux/jiffies.h>
  11. #include <linux/i2c.h>
  12. #include <linux/hwmon.h>
  13. #include <linux/hwmon-sysfs.h>
  14. #include <linux/err.h>
  15. #include <linux/mutex.h>
  16. #include <linux/delay.h>
  17. #include <linux/log2.h>
  18. #include <linux/kthread.h>
  19. #include <linux/slab.h>
  20. #include <linux/util_macros.h>
  21. /* Addresses to scan */
  22. static const unsigned short normal_i2c[] = { 0x2C, 0x2E, 0x2F, I2C_CLIENT_END };
  23. /* ADT7470 registers */
  24. #define ADT7470_REG_BASE_ADDR 0x20
  25. #define ADT7470_REG_TEMP_BASE_ADDR 0x20
  26. #define ADT7470_REG_TEMP_MAX_ADDR 0x29
  27. #define ADT7470_REG_FAN_BASE_ADDR 0x2A
  28. #define ADT7470_REG_FAN_MAX_ADDR 0x31
  29. #define ADT7470_REG_PWM_BASE_ADDR 0x32
  30. #define ADT7470_REG_PWM_MAX_ADDR 0x35
  31. #define ADT7470_REG_PWM_MAX_BASE_ADDR 0x38
  32. #define ADT7470_REG_PWM_MAX_MAX_ADDR 0x3B
  33. #define ADT7470_REG_CFG 0x40
  34. #define ADT7470_FSPD_MASK 0x04
  35. #define ADT7470_REG_ALARM1 0x41
  36. #define ADT7470_R1T_ALARM 0x01
  37. #define ADT7470_R2T_ALARM 0x02
  38. #define ADT7470_R3T_ALARM 0x04
  39. #define ADT7470_R4T_ALARM 0x08
  40. #define ADT7470_R5T_ALARM 0x10
  41. #define ADT7470_R6T_ALARM 0x20
  42. #define ADT7470_R7T_ALARM 0x40
  43. #define ADT7470_OOL_ALARM 0x80
  44. #define ADT7470_REG_ALARM2 0x42
  45. #define ADT7470_R8T_ALARM 0x01
  46. #define ADT7470_R9T_ALARM 0x02
  47. #define ADT7470_R10T_ALARM 0x04
  48. #define ADT7470_FAN1_ALARM 0x10
  49. #define ADT7470_FAN2_ALARM 0x20
  50. #define ADT7470_FAN3_ALARM 0x40
  51. #define ADT7470_FAN4_ALARM 0x80
  52. #define ADT7470_REG_TEMP_LIMITS_BASE_ADDR 0x44
  53. #define ADT7470_REG_TEMP_LIMITS_MAX_ADDR 0x57
  54. #define ADT7470_REG_FAN_MIN_BASE_ADDR 0x58
  55. #define ADT7470_REG_FAN_MIN_MAX_ADDR 0x5F
  56. #define ADT7470_REG_FAN_MAX_BASE_ADDR 0x60
  57. #define ADT7470_REG_FAN_MAX_MAX_ADDR 0x67
  58. #define ADT7470_REG_PWM_CFG_BASE_ADDR 0x68
  59. #define ADT7470_REG_PWM12_CFG 0x68
  60. #define ADT7470_PWM2_AUTO_MASK 0x40
  61. #define ADT7470_PWM1_AUTO_MASK 0x80
  62. #define ADT7470_PWM_AUTO_MASK 0xC0
  63. #define ADT7470_REG_PWM34_CFG 0x69
  64. #define ADT7470_PWM3_AUTO_MASK 0x40
  65. #define ADT7470_PWM4_AUTO_MASK 0x80
  66. #define ADT7470_REG_PWM_MIN_BASE_ADDR 0x6A
  67. #define ADT7470_REG_PWM_MIN_MAX_ADDR 0x6D
  68. #define ADT7470_REG_PWM_TEMP_MIN_BASE_ADDR 0x6E
  69. #define ADT7470_REG_PWM_TEMP_MIN_MAX_ADDR 0x71
  70. #define ADT7470_REG_CFG_2 0x74
  71. #define ADT7470_REG_ACOUSTICS12 0x75
  72. #define ADT7470_REG_ACOUSTICS34 0x76
  73. #define ADT7470_REG_DEVICE 0x3D
  74. #define ADT7470_REG_VENDOR 0x3E
  75. #define ADT7470_REG_REVISION 0x3F
  76. #define ADT7470_REG_ALARM1_MASK 0x72
  77. #define ADT7470_REG_ALARM2_MASK 0x73
  78. #define ADT7470_REG_PWM_AUTO_TEMP_BASE_ADDR 0x7C
  79. #define ADT7470_REG_PWM_AUTO_TEMP_MAX_ADDR 0x7D
  80. #define ADT7470_REG_MAX_ADDR 0x81
  81. #define ADT7470_TEMP_COUNT 10
  82. #define ADT7470_TEMP_REG(x) (ADT7470_REG_TEMP_BASE_ADDR + (x))
  83. #define ADT7470_TEMP_MIN_REG(x) (ADT7470_REG_TEMP_LIMITS_BASE_ADDR + ((x) * 2))
  84. #define ADT7470_TEMP_MAX_REG(x) (ADT7470_REG_TEMP_LIMITS_BASE_ADDR + \
  85. ((x) * 2) + 1)
  86. #define ADT7470_FAN_COUNT 4
  87. #define ADT7470_REG_FAN(x) (ADT7470_REG_FAN_BASE_ADDR + ((x) * 2))
  88. #define ADT7470_REG_FAN_MIN(x) (ADT7470_REG_FAN_MIN_BASE_ADDR + ((x) * 2))
  89. #define ADT7470_REG_FAN_MAX(x) (ADT7470_REG_FAN_MAX_BASE_ADDR + ((x) * 2))
  90. #define ADT7470_PWM_COUNT 4
  91. #define ADT7470_REG_PWM(x) (ADT7470_REG_PWM_BASE_ADDR + (x))
  92. #define ADT7470_REG_PWM_MAX(x) (ADT7470_REG_PWM_MAX_BASE_ADDR + (x))
  93. #define ADT7470_REG_PWM_MIN(x) (ADT7470_REG_PWM_MIN_BASE_ADDR + (x))
  94. #define ADT7470_REG_PWM_TMIN(x) (ADT7470_REG_PWM_TEMP_MIN_BASE_ADDR + (x))
  95. #define ADT7470_REG_PWM_CFG(x) (ADT7470_REG_PWM_CFG_BASE_ADDR + ((x) / 2))
  96. #define ADT7470_REG_PWM_AUTO_TEMP(x) (ADT7470_REG_PWM_AUTO_TEMP_BASE_ADDR + \
  97. ((x) / 2))
  98. #define ALARM2(x) ((x) << 8)
  99. #define ADT7470_VENDOR 0x41
  100. #define ADT7470_DEVICE 0x70
  101. /* datasheet only mentions a revision 2 */
  102. #define ADT7470_REVISION 0x02
  103. /* "all temps" according to hwmon sysfs interface spec */
  104. #define ADT7470_PWM_ALL_TEMPS 0x3FF
  105. /* How often do we reread sensors values? (In jiffies) */
  106. #define SENSOR_REFRESH_INTERVAL (5 * HZ)
  107. /* How often do we reread sensor limit values? (In jiffies) */
  108. #define LIMIT_REFRESH_INTERVAL (60 * HZ)
  109. /* Wait at least 200ms per sensor for 10 sensors */
  110. #define TEMP_COLLECTION_TIME 2000
  111. /* auto update thing won't fire more than every 2s */
  112. #define AUTO_UPDATE_INTERVAL 2000
  113. /* datasheet says to divide this number by the fan reading to get fan rpm */
  114. #define FAN_PERIOD_TO_RPM(x) ((90000 * 60) / (x))
  115. #define FAN_RPM_TO_PERIOD FAN_PERIOD_TO_RPM
  116. #define FAN_PERIOD_INVALID 65535
  117. #define FAN_DATA_VALID(x) ((x) && (x) != FAN_PERIOD_INVALID)
  118. /* Config registers 1 and 2 include fields for selecting the PWM frequency */
  119. #define ADT7470_CFG_LF 0x40
  120. #define ADT7470_FREQ_MASK 0x70
  121. #define ADT7470_FREQ_SHIFT 4
  122. struct adt7470_data {
  123. struct i2c_client *client;
  124. struct mutex lock;
  125. char sensors_valid;
  126. char limits_valid;
  127. unsigned long sensors_last_updated; /* In jiffies */
  128. unsigned long limits_last_updated; /* In jiffies */
  129. int num_temp_sensors; /* -1 = probe */
  130. int temperatures_probed;
  131. s8 temp[ADT7470_TEMP_COUNT];
  132. s8 temp_min[ADT7470_TEMP_COUNT];
  133. s8 temp_max[ADT7470_TEMP_COUNT];
  134. u16 fan[ADT7470_FAN_COUNT];
  135. u16 fan_min[ADT7470_FAN_COUNT];
  136. u16 fan_max[ADT7470_FAN_COUNT];
  137. u16 alarm;
  138. u16 alarms_mask;
  139. u8 force_pwm_max;
  140. u8 pwm[ADT7470_PWM_COUNT];
  141. u8 pwm_max[ADT7470_PWM_COUNT];
  142. u8 pwm_automatic[ADT7470_PWM_COUNT];
  143. u8 pwm_min[ADT7470_PWM_COUNT];
  144. s8 pwm_tmin[ADT7470_PWM_COUNT];
  145. u8 pwm_auto_temp[ADT7470_PWM_COUNT];
  146. struct task_struct *auto_update;
  147. unsigned int auto_update_interval;
  148. };
  149. /*
  150. * 16-bit registers on the ADT7470 are low-byte first. The data sheet says
  151. * that the low byte must be read before the high byte.
  152. */
  153. static inline int adt7470_read_word_data(struct i2c_client *client, u8 reg)
  154. {
  155. u16 foo;
  156. foo = i2c_smbus_read_byte_data(client, reg);
  157. foo |= ((u16)i2c_smbus_read_byte_data(client, reg + 1) << 8);
  158. return foo;
  159. }
  160. static inline int adt7470_write_word_data(struct i2c_client *client, u8 reg,
  161. u16 value)
  162. {
  163. return i2c_smbus_write_byte_data(client, reg, value & 0xFF)
  164. || i2c_smbus_write_byte_data(client, reg + 1, value >> 8);
  165. }
  166. /* Probe for temperature sensors. Assumes lock is held */
  167. static int adt7470_read_temperatures(struct i2c_client *client,
  168. struct adt7470_data *data)
  169. {
  170. unsigned long res;
  171. int i;
  172. u8 cfg, pwm[4], pwm_cfg[2];
  173. /* save pwm[1-4] config register */
  174. pwm_cfg[0] = i2c_smbus_read_byte_data(client, ADT7470_REG_PWM_CFG(0));
  175. pwm_cfg[1] = i2c_smbus_read_byte_data(client, ADT7470_REG_PWM_CFG(2));
  176. /* set manual pwm to whatever it is set to now */
  177. for (i = 0; i < ADT7470_FAN_COUNT; i++)
  178. pwm[i] = i2c_smbus_read_byte_data(client, ADT7470_REG_PWM(i));
  179. /* put pwm in manual mode */
  180. i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_CFG(0),
  181. pwm_cfg[0] & ~(ADT7470_PWM_AUTO_MASK));
  182. i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_CFG(2),
  183. pwm_cfg[1] & ~(ADT7470_PWM_AUTO_MASK));
  184. /* write pwm control to whatever it was */
  185. for (i = 0; i < ADT7470_FAN_COUNT; i++)
  186. i2c_smbus_write_byte_data(client, ADT7470_REG_PWM(i), pwm[i]);
  187. /* start reading temperature sensors */
  188. cfg = i2c_smbus_read_byte_data(client, ADT7470_REG_CFG);
  189. cfg |= 0x80;
  190. i2c_smbus_write_byte_data(client, ADT7470_REG_CFG, cfg);
  191. /* Delay is 200ms * number of temp sensors. */
  192. res = msleep_interruptible((data->num_temp_sensors >= 0 ?
  193. data->num_temp_sensors * 200 :
  194. TEMP_COLLECTION_TIME));
  195. /* done reading temperature sensors */
  196. cfg = i2c_smbus_read_byte_data(client, ADT7470_REG_CFG);
  197. cfg &= ~0x80;
  198. i2c_smbus_write_byte_data(client, ADT7470_REG_CFG, cfg);
  199. /* restore pwm[1-4] config registers */
  200. i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_CFG(0), pwm_cfg[0]);
  201. i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_CFG(2), pwm_cfg[1]);
  202. if (res) {
  203. pr_err("ha ha, interrupted\n");
  204. return -EAGAIN;
  205. }
  206. /* Only count fans if we have to */
  207. if (data->num_temp_sensors >= 0)
  208. return 0;
  209. for (i = 0; i < ADT7470_TEMP_COUNT; i++) {
  210. data->temp[i] = i2c_smbus_read_byte_data(client,
  211. ADT7470_TEMP_REG(i));
  212. if (data->temp[i])
  213. data->num_temp_sensors = i + 1;
  214. }
  215. data->temperatures_probed = 1;
  216. return 0;
  217. }
  218. static int adt7470_update_thread(void *p)
  219. {
  220. struct i2c_client *client = p;
  221. struct adt7470_data *data = i2c_get_clientdata(client);
  222. while (!kthread_should_stop()) {
  223. mutex_lock(&data->lock);
  224. adt7470_read_temperatures(client, data);
  225. mutex_unlock(&data->lock);
  226. set_current_state(TASK_INTERRUPTIBLE);
  227. if (kthread_should_stop())
  228. break;
  229. schedule_timeout(msecs_to_jiffies(data->auto_update_interval));
  230. }
  231. return 0;
  232. }
  233. static struct adt7470_data *adt7470_update_device(struct device *dev)
  234. {
  235. struct adt7470_data *data = dev_get_drvdata(dev);
  236. struct i2c_client *client = data->client;
  237. unsigned long local_jiffies = jiffies;
  238. u8 cfg;
  239. int i;
  240. int need_sensors = 1;
  241. int need_limits = 1;
  242. /*
  243. * Figure out if we need to update the shadow registers.
  244. * Lockless means that we may occasionally report out of
  245. * date data.
  246. */
  247. if (time_before(local_jiffies, data->sensors_last_updated +
  248. SENSOR_REFRESH_INTERVAL) &&
  249. data->sensors_valid)
  250. need_sensors = 0;
  251. if (time_before(local_jiffies, data->limits_last_updated +
  252. LIMIT_REFRESH_INTERVAL) &&
  253. data->limits_valid)
  254. need_limits = 0;
  255. if (!need_sensors && !need_limits)
  256. return data;
  257. mutex_lock(&data->lock);
  258. if (!need_sensors)
  259. goto no_sensor_update;
  260. if (!data->temperatures_probed)
  261. adt7470_read_temperatures(client, data);
  262. else
  263. for (i = 0; i < ADT7470_TEMP_COUNT; i++)
  264. data->temp[i] = i2c_smbus_read_byte_data(client,
  265. ADT7470_TEMP_REG(i));
  266. for (i = 0; i < ADT7470_FAN_COUNT; i++)
  267. data->fan[i] = adt7470_read_word_data(client,
  268. ADT7470_REG_FAN(i));
  269. for (i = 0; i < ADT7470_PWM_COUNT; i++) {
  270. int reg;
  271. int reg_mask;
  272. data->pwm[i] = i2c_smbus_read_byte_data(client,
  273. ADT7470_REG_PWM(i));
  274. if (i % 2)
  275. reg_mask = ADT7470_PWM2_AUTO_MASK;
  276. else
  277. reg_mask = ADT7470_PWM1_AUTO_MASK;
  278. reg = ADT7470_REG_PWM_CFG(i);
  279. if (i2c_smbus_read_byte_data(client, reg) & reg_mask)
  280. data->pwm_automatic[i] = 1;
  281. else
  282. data->pwm_automatic[i] = 0;
  283. reg = ADT7470_REG_PWM_AUTO_TEMP(i);
  284. cfg = i2c_smbus_read_byte_data(client, reg);
  285. if (!(i % 2))
  286. data->pwm_auto_temp[i] = cfg >> 4;
  287. else
  288. data->pwm_auto_temp[i] = cfg & 0xF;
  289. }
  290. if (i2c_smbus_read_byte_data(client, ADT7470_REG_CFG) &
  291. ADT7470_FSPD_MASK)
  292. data->force_pwm_max = 1;
  293. else
  294. data->force_pwm_max = 0;
  295. data->alarm = i2c_smbus_read_byte_data(client, ADT7470_REG_ALARM1);
  296. if (data->alarm & ADT7470_OOL_ALARM)
  297. data->alarm |= ALARM2(i2c_smbus_read_byte_data(client,
  298. ADT7470_REG_ALARM2));
  299. data->alarms_mask = adt7470_read_word_data(client,
  300. ADT7470_REG_ALARM1_MASK);
  301. data->sensors_last_updated = local_jiffies;
  302. data->sensors_valid = 1;
  303. no_sensor_update:
  304. if (!need_limits)
  305. goto out;
  306. for (i = 0; i < ADT7470_TEMP_COUNT; i++) {
  307. data->temp_min[i] = i2c_smbus_read_byte_data(client,
  308. ADT7470_TEMP_MIN_REG(i));
  309. data->temp_max[i] = i2c_smbus_read_byte_data(client,
  310. ADT7470_TEMP_MAX_REG(i));
  311. }
  312. for (i = 0; i < ADT7470_FAN_COUNT; i++) {
  313. data->fan_min[i] = adt7470_read_word_data(client,
  314. ADT7470_REG_FAN_MIN(i));
  315. data->fan_max[i] = adt7470_read_word_data(client,
  316. ADT7470_REG_FAN_MAX(i));
  317. }
  318. for (i = 0; i < ADT7470_PWM_COUNT; i++) {
  319. data->pwm_max[i] = i2c_smbus_read_byte_data(client,
  320. ADT7470_REG_PWM_MAX(i));
  321. data->pwm_min[i] = i2c_smbus_read_byte_data(client,
  322. ADT7470_REG_PWM_MIN(i));
  323. data->pwm_tmin[i] = i2c_smbus_read_byte_data(client,
  324. ADT7470_REG_PWM_TMIN(i));
  325. }
  326. data->limits_last_updated = local_jiffies;
  327. data->limits_valid = 1;
  328. out:
  329. mutex_unlock(&data->lock);
  330. return data;
  331. }
  332. static ssize_t auto_update_interval_show(struct device *dev,
  333. struct device_attribute *devattr,
  334. char *buf)
  335. {
  336. struct adt7470_data *data = adt7470_update_device(dev);
  337. return sprintf(buf, "%d\n", data->auto_update_interval);
  338. }
  339. static ssize_t auto_update_interval_store(struct device *dev,
  340. struct device_attribute *devattr,
  341. const char *buf, size_t count)
  342. {
  343. struct adt7470_data *data = dev_get_drvdata(dev);
  344. long temp;
  345. if (kstrtol(buf, 10, &temp))
  346. return -EINVAL;
  347. temp = clamp_val(temp, 0, 60000);
  348. mutex_lock(&data->lock);
  349. data->auto_update_interval = temp;
  350. mutex_unlock(&data->lock);
  351. return count;
  352. }
  353. static ssize_t num_temp_sensors_show(struct device *dev,
  354. struct device_attribute *devattr,
  355. char *buf)
  356. {
  357. struct adt7470_data *data = adt7470_update_device(dev);
  358. return sprintf(buf, "%d\n", data->num_temp_sensors);
  359. }
  360. static ssize_t num_temp_sensors_store(struct device *dev,
  361. struct device_attribute *devattr,
  362. const char *buf, size_t count)
  363. {
  364. struct adt7470_data *data = dev_get_drvdata(dev);
  365. long temp;
  366. if (kstrtol(buf, 10, &temp))
  367. return -EINVAL;
  368. temp = clamp_val(temp, -1, 10);
  369. mutex_lock(&data->lock);
  370. data->num_temp_sensors = temp;
  371. if (temp < 0)
  372. data->temperatures_probed = 0;
  373. mutex_unlock(&data->lock);
  374. return count;
  375. }
  376. static ssize_t temp_min_show(struct device *dev,
  377. struct device_attribute *devattr, char *buf)
  378. {
  379. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  380. struct adt7470_data *data = adt7470_update_device(dev);
  381. return sprintf(buf, "%d\n", 1000 * data->temp_min[attr->index]);
  382. }
  383. static ssize_t temp_min_store(struct device *dev,
  384. struct device_attribute *devattr,
  385. const char *buf, size_t count)
  386. {
  387. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  388. struct adt7470_data *data = dev_get_drvdata(dev);
  389. struct i2c_client *client = data->client;
  390. long temp;
  391. if (kstrtol(buf, 10, &temp))
  392. return -EINVAL;
  393. temp = clamp_val(temp, -128000, 127000);
  394. temp = DIV_ROUND_CLOSEST(temp, 1000);
  395. mutex_lock(&data->lock);
  396. data->temp_min[attr->index] = temp;
  397. i2c_smbus_write_byte_data(client, ADT7470_TEMP_MIN_REG(attr->index),
  398. temp);
  399. mutex_unlock(&data->lock);
  400. return count;
  401. }
  402. static ssize_t temp_max_show(struct device *dev,
  403. struct device_attribute *devattr, char *buf)
  404. {
  405. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  406. struct adt7470_data *data = adt7470_update_device(dev);
  407. return sprintf(buf, "%d\n", 1000 * data->temp_max[attr->index]);
  408. }
  409. static ssize_t temp_max_store(struct device *dev,
  410. struct device_attribute *devattr,
  411. const char *buf, size_t count)
  412. {
  413. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  414. struct adt7470_data *data = dev_get_drvdata(dev);
  415. struct i2c_client *client = data->client;
  416. long temp;
  417. if (kstrtol(buf, 10, &temp))
  418. return -EINVAL;
  419. temp = clamp_val(temp, -128000, 127000);
  420. temp = DIV_ROUND_CLOSEST(temp, 1000);
  421. mutex_lock(&data->lock);
  422. data->temp_max[attr->index] = temp;
  423. i2c_smbus_write_byte_data(client, ADT7470_TEMP_MAX_REG(attr->index),
  424. temp);
  425. mutex_unlock(&data->lock);
  426. return count;
  427. }
  428. static ssize_t temp_show(struct device *dev, struct device_attribute *devattr,
  429. char *buf)
  430. {
  431. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  432. struct adt7470_data *data = adt7470_update_device(dev);
  433. return sprintf(buf, "%d\n", 1000 * data->temp[attr->index]);
  434. }
  435. static ssize_t alarm_mask_show(struct device *dev,
  436. struct device_attribute *devattr,
  437. char *buf)
  438. {
  439. struct adt7470_data *data = adt7470_update_device(dev);
  440. return sprintf(buf, "%x\n", data->alarms_mask);
  441. }
  442. static ssize_t alarm_mask_store(struct device *dev,
  443. struct device_attribute *devattr,
  444. const char *buf, size_t count)
  445. {
  446. struct adt7470_data *data = dev_get_drvdata(dev);
  447. long mask;
  448. if (kstrtoul(buf, 0, &mask))
  449. return -EINVAL;
  450. if (mask & ~0xffff)
  451. return -EINVAL;
  452. mutex_lock(&data->lock);
  453. data->alarms_mask = mask;
  454. adt7470_write_word_data(data->client, ADT7470_REG_ALARM1_MASK, mask);
  455. mutex_unlock(&data->lock);
  456. return count;
  457. }
  458. static ssize_t fan_max_show(struct device *dev,
  459. struct device_attribute *devattr, char *buf)
  460. {
  461. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  462. struct adt7470_data *data = adt7470_update_device(dev);
  463. if (FAN_DATA_VALID(data->fan_max[attr->index]))
  464. return sprintf(buf, "%d\n",
  465. FAN_PERIOD_TO_RPM(data->fan_max[attr->index]));
  466. else
  467. return sprintf(buf, "0\n");
  468. }
  469. static ssize_t fan_max_store(struct device *dev,
  470. struct device_attribute *devattr,
  471. const char *buf, size_t count)
  472. {
  473. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  474. struct adt7470_data *data = dev_get_drvdata(dev);
  475. struct i2c_client *client = data->client;
  476. long temp;
  477. if (kstrtol(buf, 10, &temp) || !temp)
  478. return -EINVAL;
  479. temp = FAN_RPM_TO_PERIOD(temp);
  480. temp = clamp_val(temp, 1, 65534);
  481. mutex_lock(&data->lock);
  482. data->fan_max[attr->index] = temp;
  483. adt7470_write_word_data(client, ADT7470_REG_FAN_MAX(attr->index), temp);
  484. mutex_unlock(&data->lock);
  485. return count;
  486. }
  487. static ssize_t fan_min_show(struct device *dev,
  488. struct device_attribute *devattr, char *buf)
  489. {
  490. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  491. struct adt7470_data *data = adt7470_update_device(dev);
  492. if (FAN_DATA_VALID(data->fan_min[attr->index]))
  493. return sprintf(buf, "%d\n",
  494. FAN_PERIOD_TO_RPM(data->fan_min[attr->index]));
  495. else
  496. return sprintf(buf, "0\n");
  497. }
  498. static ssize_t fan_min_store(struct device *dev,
  499. struct device_attribute *devattr,
  500. const char *buf, size_t count)
  501. {
  502. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  503. struct adt7470_data *data = dev_get_drvdata(dev);
  504. struct i2c_client *client = data->client;
  505. long temp;
  506. if (kstrtol(buf, 10, &temp) || !temp)
  507. return -EINVAL;
  508. temp = FAN_RPM_TO_PERIOD(temp);
  509. temp = clamp_val(temp, 1, 65534);
  510. mutex_lock(&data->lock);
  511. data->fan_min[attr->index] = temp;
  512. adt7470_write_word_data(client, ADT7470_REG_FAN_MIN(attr->index), temp);
  513. mutex_unlock(&data->lock);
  514. return count;
  515. }
  516. static ssize_t fan_show(struct device *dev, struct device_attribute *devattr,
  517. char *buf)
  518. {
  519. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  520. struct adt7470_data *data = adt7470_update_device(dev);
  521. if (FAN_DATA_VALID(data->fan[attr->index]))
  522. return sprintf(buf, "%d\n",
  523. FAN_PERIOD_TO_RPM(data->fan[attr->index]));
  524. else
  525. return sprintf(buf, "0\n");
  526. }
  527. static ssize_t force_pwm_max_show(struct device *dev,
  528. struct device_attribute *devattr, char *buf)
  529. {
  530. struct adt7470_data *data = adt7470_update_device(dev);
  531. return sprintf(buf, "%d\n", data->force_pwm_max);
  532. }
  533. static ssize_t force_pwm_max_store(struct device *dev,
  534. struct device_attribute *devattr,
  535. const char *buf, size_t count)
  536. {
  537. struct adt7470_data *data = dev_get_drvdata(dev);
  538. struct i2c_client *client = data->client;
  539. long temp;
  540. u8 reg;
  541. if (kstrtol(buf, 10, &temp))
  542. return -EINVAL;
  543. mutex_lock(&data->lock);
  544. data->force_pwm_max = temp;
  545. reg = i2c_smbus_read_byte_data(client, ADT7470_REG_CFG);
  546. if (temp)
  547. reg |= ADT7470_FSPD_MASK;
  548. else
  549. reg &= ~ADT7470_FSPD_MASK;
  550. i2c_smbus_write_byte_data(client, ADT7470_REG_CFG, reg);
  551. mutex_unlock(&data->lock);
  552. return count;
  553. }
  554. static ssize_t pwm_show(struct device *dev, struct device_attribute *devattr,
  555. char *buf)
  556. {
  557. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  558. struct adt7470_data *data = adt7470_update_device(dev);
  559. return sprintf(buf, "%d\n", data->pwm[attr->index]);
  560. }
  561. static ssize_t pwm_store(struct device *dev, struct device_attribute *devattr,
  562. const char *buf, size_t count)
  563. {
  564. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  565. struct adt7470_data *data = dev_get_drvdata(dev);
  566. struct i2c_client *client = data->client;
  567. long temp;
  568. if (kstrtol(buf, 10, &temp))
  569. return -EINVAL;
  570. temp = clamp_val(temp, 0, 255);
  571. mutex_lock(&data->lock);
  572. data->pwm[attr->index] = temp;
  573. i2c_smbus_write_byte_data(client, ADT7470_REG_PWM(attr->index), temp);
  574. mutex_unlock(&data->lock);
  575. return count;
  576. }
  577. /* These are the valid PWM frequencies to the nearest Hz */
  578. static const int adt7470_freq_map[] = {
  579. 11, 15, 22, 29, 35, 44, 59, 88, 1400, 22500
  580. };
  581. static ssize_t pwm1_freq_show(struct device *dev,
  582. struct device_attribute *devattr, char *buf)
  583. {
  584. struct adt7470_data *data = adt7470_update_device(dev);
  585. unsigned char cfg_reg_1;
  586. unsigned char cfg_reg_2;
  587. int index;
  588. mutex_lock(&data->lock);
  589. cfg_reg_1 = i2c_smbus_read_byte_data(data->client, ADT7470_REG_CFG);
  590. cfg_reg_2 = i2c_smbus_read_byte_data(data->client, ADT7470_REG_CFG_2);
  591. mutex_unlock(&data->lock);
  592. index = (cfg_reg_2 & ADT7470_FREQ_MASK) >> ADT7470_FREQ_SHIFT;
  593. if (!(cfg_reg_1 & ADT7470_CFG_LF))
  594. index += 8;
  595. if (index >= ARRAY_SIZE(adt7470_freq_map))
  596. index = ARRAY_SIZE(adt7470_freq_map) - 1;
  597. return scnprintf(buf, PAGE_SIZE, "%d\n", adt7470_freq_map[index]);
  598. }
  599. static ssize_t pwm1_freq_store(struct device *dev,
  600. struct device_attribute *devattr,
  601. const char *buf, size_t count)
  602. {
  603. struct adt7470_data *data = dev_get_drvdata(dev);
  604. struct i2c_client *client = data->client;
  605. long freq;
  606. int index;
  607. int low_freq = ADT7470_CFG_LF;
  608. unsigned char val;
  609. if (kstrtol(buf, 10, &freq))
  610. return -EINVAL;
  611. /* Round the user value given to the closest available frequency */
  612. index = find_closest(freq, adt7470_freq_map,
  613. ARRAY_SIZE(adt7470_freq_map));
  614. if (index >= 8) {
  615. index -= 8;
  616. low_freq = 0;
  617. }
  618. mutex_lock(&data->lock);
  619. /* Configuration Register 1 */
  620. val = i2c_smbus_read_byte_data(client, ADT7470_REG_CFG);
  621. i2c_smbus_write_byte_data(client, ADT7470_REG_CFG,
  622. (val & ~ADT7470_CFG_LF) | low_freq);
  623. /* Configuration Register 2 */
  624. val = i2c_smbus_read_byte_data(client, ADT7470_REG_CFG_2);
  625. i2c_smbus_write_byte_data(client, ADT7470_REG_CFG_2,
  626. (val & ~ADT7470_FREQ_MASK) | (index << ADT7470_FREQ_SHIFT));
  627. mutex_unlock(&data->lock);
  628. return count;
  629. }
  630. static ssize_t pwm_max_show(struct device *dev,
  631. struct device_attribute *devattr, char *buf)
  632. {
  633. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  634. struct adt7470_data *data = adt7470_update_device(dev);
  635. return sprintf(buf, "%d\n", data->pwm_max[attr->index]);
  636. }
  637. static ssize_t pwm_max_store(struct device *dev,
  638. struct device_attribute *devattr,
  639. const char *buf, size_t count)
  640. {
  641. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  642. struct adt7470_data *data = dev_get_drvdata(dev);
  643. struct i2c_client *client = data->client;
  644. long temp;
  645. if (kstrtol(buf, 10, &temp))
  646. return -EINVAL;
  647. temp = clamp_val(temp, 0, 255);
  648. mutex_lock(&data->lock);
  649. data->pwm_max[attr->index] = temp;
  650. i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_MAX(attr->index),
  651. temp);
  652. mutex_unlock(&data->lock);
  653. return count;
  654. }
  655. static ssize_t pwm_min_show(struct device *dev,
  656. struct device_attribute *devattr, char *buf)
  657. {
  658. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  659. struct adt7470_data *data = adt7470_update_device(dev);
  660. return sprintf(buf, "%d\n", data->pwm_min[attr->index]);
  661. }
  662. static ssize_t pwm_min_store(struct device *dev,
  663. struct device_attribute *devattr,
  664. const char *buf, size_t count)
  665. {
  666. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  667. struct adt7470_data *data = dev_get_drvdata(dev);
  668. struct i2c_client *client = data->client;
  669. long temp;
  670. if (kstrtol(buf, 10, &temp))
  671. return -EINVAL;
  672. temp = clamp_val(temp, 0, 255);
  673. mutex_lock(&data->lock);
  674. data->pwm_min[attr->index] = temp;
  675. i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_MIN(attr->index),
  676. temp);
  677. mutex_unlock(&data->lock);
  678. return count;
  679. }
  680. static ssize_t pwm_tmax_show(struct device *dev,
  681. struct device_attribute *devattr, char *buf)
  682. {
  683. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  684. struct adt7470_data *data = adt7470_update_device(dev);
  685. /* the datasheet says that tmax = tmin + 20C */
  686. return sprintf(buf, "%d\n", 1000 * (20 + data->pwm_tmin[attr->index]));
  687. }
  688. static ssize_t pwm_tmin_show(struct device *dev,
  689. struct device_attribute *devattr, char *buf)
  690. {
  691. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  692. struct adt7470_data *data = adt7470_update_device(dev);
  693. return sprintf(buf, "%d\n", 1000 * data->pwm_tmin[attr->index]);
  694. }
  695. static ssize_t pwm_tmin_store(struct device *dev,
  696. struct device_attribute *devattr,
  697. const char *buf, size_t count)
  698. {
  699. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  700. struct adt7470_data *data = dev_get_drvdata(dev);
  701. struct i2c_client *client = data->client;
  702. long temp;
  703. if (kstrtol(buf, 10, &temp))
  704. return -EINVAL;
  705. temp = clamp_val(temp, -128000, 127000);
  706. temp = DIV_ROUND_CLOSEST(temp, 1000);
  707. mutex_lock(&data->lock);
  708. data->pwm_tmin[attr->index] = temp;
  709. i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_TMIN(attr->index),
  710. temp);
  711. mutex_unlock(&data->lock);
  712. return count;
  713. }
  714. static ssize_t pwm_auto_show(struct device *dev,
  715. struct device_attribute *devattr, char *buf)
  716. {
  717. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  718. struct adt7470_data *data = adt7470_update_device(dev);
  719. return sprintf(buf, "%d\n", 1 + data->pwm_automatic[attr->index]);
  720. }
  721. static ssize_t pwm_auto_store(struct device *dev,
  722. struct device_attribute *devattr,
  723. const char *buf, size_t count)
  724. {
  725. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  726. struct adt7470_data *data = dev_get_drvdata(dev);
  727. struct i2c_client *client = data->client;
  728. int pwm_auto_reg = ADT7470_REG_PWM_CFG(attr->index);
  729. int pwm_auto_reg_mask;
  730. long temp;
  731. u8 reg;
  732. if (kstrtol(buf, 10, &temp))
  733. return -EINVAL;
  734. if (attr->index % 2)
  735. pwm_auto_reg_mask = ADT7470_PWM2_AUTO_MASK;
  736. else
  737. pwm_auto_reg_mask = ADT7470_PWM1_AUTO_MASK;
  738. if (temp != 2 && temp != 1)
  739. return -EINVAL;
  740. temp--;
  741. mutex_lock(&data->lock);
  742. data->pwm_automatic[attr->index] = temp;
  743. reg = i2c_smbus_read_byte_data(client, pwm_auto_reg);
  744. if (temp)
  745. reg |= pwm_auto_reg_mask;
  746. else
  747. reg &= ~pwm_auto_reg_mask;
  748. i2c_smbus_write_byte_data(client, pwm_auto_reg, reg);
  749. mutex_unlock(&data->lock);
  750. return count;
  751. }
  752. static ssize_t pwm_auto_temp_show(struct device *dev,
  753. struct device_attribute *devattr, char *buf)
  754. {
  755. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  756. struct adt7470_data *data = adt7470_update_device(dev);
  757. u8 ctrl = data->pwm_auto_temp[attr->index];
  758. if (ctrl)
  759. return sprintf(buf, "%d\n", 1 << (ctrl - 1));
  760. else
  761. return sprintf(buf, "%d\n", ADT7470_PWM_ALL_TEMPS);
  762. }
  763. static int cvt_auto_temp(int input)
  764. {
  765. if (input == ADT7470_PWM_ALL_TEMPS)
  766. return 0;
  767. if (input < 1 || !is_power_of_2(input))
  768. return -EINVAL;
  769. return ilog2(input) + 1;
  770. }
  771. static ssize_t pwm_auto_temp_store(struct device *dev,
  772. struct device_attribute *devattr,
  773. const char *buf, size_t count)
  774. {
  775. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  776. struct adt7470_data *data = dev_get_drvdata(dev);
  777. struct i2c_client *client = data->client;
  778. int pwm_auto_reg = ADT7470_REG_PWM_AUTO_TEMP(attr->index);
  779. long temp;
  780. u8 reg;
  781. if (kstrtol(buf, 10, &temp))
  782. return -EINVAL;
  783. temp = cvt_auto_temp(temp);
  784. if (temp < 0)
  785. return temp;
  786. mutex_lock(&data->lock);
  787. data->pwm_automatic[attr->index] = temp;
  788. reg = i2c_smbus_read_byte_data(client, pwm_auto_reg);
  789. if (!(attr->index % 2)) {
  790. reg &= 0xF;
  791. reg |= (temp << 4) & 0xF0;
  792. } else {
  793. reg &= 0xF0;
  794. reg |= temp & 0xF;
  795. }
  796. i2c_smbus_write_byte_data(client, pwm_auto_reg, reg);
  797. mutex_unlock(&data->lock);
  798. return count;
  799. }
  800. static ssize_t alarm_show(struct device *dev,
  801. struct device_attribute *devattr, char *buf)
  802. {
  803. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  804. struct adt7470_data *data = adt7470_update_device(dev);
  805. if (data->alarm & attr->index)
  806. return sprintf(buf, "1\n");
  807. else
  808. return sprintf(buf, "0\n");
  809. }
  810. static DEVICE_ATTR_RW(alarm_mask);
  811. static DEVICE_ATTR_RW(num_temp_sensors);
  812. static DEVICE_ATTR_RW(auto_update_interval);
  813. static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0);
  814. static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);
  815. static SENSOR_DEVICE_ATTR_RW(temp3_max, temp_max, 2);
  816. static SENSOR_DEVICE_ATTR_RW(temp4_max, temp_max, 3);
  817. static SENSOR_DEVICE_ATTR_RW(temp5_max, temp_max, 4);
  818. static SENSOR_DEVICE_ATTR_RW(temp6_max, temp_max, 5);
  819. static SENSOR_DEVICE_ATTR_RW(temp7_max, temp_max, 6);
  820. static SENSOR_DEVICE_ATTR_RW(temp8_max, temp_max, 7);
  821. static SENSOR_DEVICE_ATTR_RW(temp9_max, temp_max, 8);
  822. static SENSOR_DEVICE_ATTR_RW(temp10_max, temp_max, 9);
  823. static SENSOR_DEVICE_ATTR_RW(temp1_min, temp_min, 0);
  824. static SENSOR_DEVICE_ATTR_RW(temp2_min, temp_min, 1);
  825. static SENSOR_DEVICE_ATTR_RW(temp3_min, temp_min, 2);
  826. static SENSOR_DEVICE_ATTR_RW(temp4_min, temp_min, 3);
  827. static SENSOR_DEVICE_ATTR_RW(temp5_min, temp_min, 4);
  828. static SENSOR_DEVICE_ATTR_RW(temp6_min, temp_min, 5);
  829. static SENSOR_DEVICE_ATTR_RW(temp7_min, temp_min, 6);
  830. static SENSOR_DEVICE_ATTR_RW(temp8_min, temp_min, 7);
  831. static SENSOR_DEVICE_ATTR_RW(temp9_min, temp_min, 8);
  832. static SENSOR_DEVICE_ATTR_RW(temp10_min, temp_min, 9);
  833. static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0);
  834. static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1);
  835. static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2);
  836. static SENSOR_DEVICE_ATTR_RO(temp4_input, temp, 3);
  837. static SENSOR_DEVICE_ATTR_RO(temp5_input, temp, 4);
  838. static SENSOR_DEVICE_ATTR_RO(temp6_input, temp, 5);
  839. static SENSOR_DEVICE_ATTR_RO(temp7_input, temp, 6);
  840. static SENSOR_DEVICE_ATTR_RO(temp8_input, temp, 7);
  841. static SENSOR_DEVICE_ATTR_RO(temp9_input, temp, 8);
  842. static SENSOR_DEVICE_ATTR_RO(temp10_input, temp, 9);
  843. static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm, ADT7470_R1T_ALARM);
  844. static SENSOR_DEVICE_ATTR_RO(temp2_alarm, alarm, ADT7470_R2T_ALARM);
  845. static SENSOR_DEVICE_ATTR_RO(temp3_alarm, alarm, ADT7470_R3T_ALARM);
  846. static SENSOR_DEVICE_ATTR_RO(temp4_alarm, alarm, ADT7470_R4T_ALARM);
  847. static SENSOR_DEVICE_ATTR_RO(temp5_alarm, alarm, ADT7470_R5T_ALARM);
  848. static SENSOR_DEVICE_ATTR_RO(temp6_alarm, alarm, ADT7470_R6T_ALARM);
  849. static SENSOR_DEVICE_ATTR_RO(temp7_alarm, alarm, ADT7470_R7T_ALARM);
  850. static SENSOR_DEVICE_ATTR_RO(temp8_alarm, alarm, ALARM2(ADT7470_R8T_ALARM));
  851. static SENSOR_DEVICE_ATTR_RO(temp9_alarm, alarm, ALARM2(ADT7470_R9T_ALARM));
  852. static SENSOR_DEVICE_ATTR_RO(temp10_alarm, alarm, ALARM2(ADT7470_R10T_ALARM));
  853. static SENSOR_DEVICE_ATTR_RW(fan1_max, fan_max, 0);
  854. static SENSOR_DEVICE_ATTR_RW(fan2_max, fan_max, 1);
  855. static SENSOR_DEVICE_ATTR_RW(fan3_max, fan_max, 2);
  856. static SENSOR_DEVICE_ATTR_RW(fan4_max, fan_max, 3);
  857. static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);
  858. static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
  859. static SENSOR_DEVICE_ATTR_RW(fan3_min, fan_min, 2);
  860. static SENSOR_DEVICE_ATTR_RW(fan4_min, fan_min, 3);
  861. static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0);
  862. static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1);
  863. static SENSOR_DEVICE_ATTR_RO(fan3_input, fan, 2);
  864. static SENSOR_DEVICE_ATTR_RO(fan4_input, fan, 3);
  865. static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm, ALARM2(ADT7470_FAN1_ALARM));
  866. static SENSOR_DEVICE_ATTR_RO(fan2_alarm, alarm, ALARM2(ADT7470_FAN2_ALARM));
  867. static SENSOR_DEVICE_ATTR_RO(fan3_alarm, alarm, ALARM2(ADT7470_FAN3_ALARM));
  868. static SENSOR_DEVICE_ATTR_RO(fan4_alarm, alarm, ALARM2(ADT7470_FAN4_ALARM));
  869. static SENSOR_DEVICE_ATTR_RW(force_pwm_max, force_pwm_max, 0);
  870. static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);
  871. static SENSOR_DEVICE_ATTR_RW(pwm2, pwm, 1);
  872. static SENSOR_DEVICE_ATTR_RW(pwm3, pwm, 2);
  873. static SENSOR_DEVICE_ATTR_RW(pwm4, pwm, 3);
  874. static DEVICE_ATTR_RW(pwm1_freq);
  875. static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point1_pwm, pwm_min, 0);
  876. static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point1_pwm, pwm_min, 1);
  877. static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point1_pwm, pwm_min, 2);
  878. static SENSOR_DEVICE_ATTR_RW(pwm4_auto_point1_pwm, pwm_min, 3);
  879. static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point2_pwm, pwm_max, 0);
  880. static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point2_pwm, pwm_max, 1);
  881. static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point2_pwm, pwm_max, 2);
  882. static SENSOR_DEVICE_ATTR_RW(pwm4_auto_point2_pwm, pwm_max, 3);
  883. static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point1_temp, pwm_tmin, 0);
  884. static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point1_temp, pwm_tmin, 1);
  885. static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point1_temp, pwm_tmin, 2);
  886. static SENSOR_DEVICE_ATTR_RW(pwm4_auto_point1_temp, pwm_tmin, 3);
  887. static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point2_temp, pwm_tmax, 0);
  888. static SENSOR_DEVICE_ATTR_RO(pwm2_auto_point2_temp, pwm_tmax, 1);
  889. static SENSOR_DEVICE_ATTR_RO(pwm3_auto_point2_temp, pwm_tmax, 2);
  890. static SENSOR_DEVICE_ATTR_RO(pwm4_auto_point2_temp, pwm_tmax, 3);
  891. static SENSOR_DEVICE_ATTR_RW(pwm1_enable, pwm_auto, 0);
  892. static SENSOR_DEVICE_ATTR_RW(pwm2_enable, pwm_auto, 1);
  893. static SENSOR_DEVICE_ATTR_RW(pwm3_enable, pwm_auto, 2);
  894. static SENSOR_DEVICE_ATTR_RW(pwm4_enable, pwm_auto, 3);
  895. static SENSOR_DEVICE_ATTR_RW(pwm1_auto_channels_temp, pwm_auto_temp, 0);
  896. static SENSOR_DEVICE_ATTR_RW(pwm2_auto_channels_temp, pwm_auto_temp, 1);
  897. static SENSOR_DEVICE_ATTR_RW(pwm3_auto_channels_temp, pwm_auto_temp, 2);
  898. static SENSOR_DEVICE_ATTR_RW(pwm4_auto_channels_temp, pwm_auto_temp, 3);
  899. static struct attribute *adt7470_attrs[] = {
  900. &dev_attr_alarm_mask.attr,
  901. &dev_attr_num_temp_sensors.attr,
  902. &dev_attr_auto_update_interval.attr,
  903. &sensor_dev_attr_temp1_max.dev_attr.attr,
  904. &sensor_dev_attr_temp2_max.dev_attr.attr,
  905. &sensor_dev_attr_temp3_max.dev_attr.attr,
  906. &sensor_dev_attr_temp4_max.dev_attr.attr,
  907. &sensor_dev_attr_temp5_max.dev_attr.attr,
  908. &sensor_dev_attr_temp6_max.dev_attr.attr,
  909. &sensor_dev_attr_temp7_max.dev_attr.attr,
  910. &sensor_dev_attr_temp8_max.dev_attr.attr,
  911. &sensor_dev_attr_temp9_max.dev_attr.attr,
  912. &sensor_dev_attr_temp10_max.dev_attr.attr,
  913. &sensor_dev_attr_temp1_min.dev_attr.attr,
  914. &sensor_dev_attr_temp2_min.dev_attr.attr,
  915. &sensor_dev_attr_temp3_min.dev_attr.attr,
  916. &sensor_dev_attr_temp4_min.dev_attr.attr,
  917. &sensor_dev_attr_temp5_min.dev_attr.attr,
  918. &sensor_dev_attr_temp6_min.dev_attr.attr,
  919. &sensor_dev_attr_temp7_min.dev_attr.attr,
  920. &sensor_dev_attr_temp8_min.dev_attr.attr,
  921. &sensor_dev_attr_temp9_min.dev_attr.attr,
  922. &sensor_dev_attr_temp10_min.dev_attr.attr,
  923. &sensor_dev_attr_temp1_input.dev_attr.attr,
  924. &sensor_dev_attr_temp2_input.dev_attr.attr,
  925. &sensor_dev_attr_temp3_input.dev_attr.attr,
  926. &sensor_dev_attr_temp4_input.dev_attr.attr,
  927. &sensor_dev_attr_temp5_input.dev_attr.attr,
  928. &sensor_dev_attr_temp6_input.dev_attr.attr,
  929. &sensor_dev_attr_temp7_input.dev_attr.attr,
  930. &sensor_dev_attr_temp8_input.dev_attr.attr,
  931. &sensor_dev_attr_temp9_input.dev_attr.attr,
  932. &sensor_dev_attr_temp10_input.dev_attr.attr,
  933. &sensor_dev_attr_temp1_alarm.dev_attr.attr,
  934. &sensor_dev_attr_temp2_alarm.dev_attr.attr,
  935. &sensor_dev_attr_temp3_alarm.dev_attr.attr,
  936. &sensor_dev_attr_temp4_alarm.dev_attr.attr,
  937. &sensor_dev_attr_temp5_alarm.dev_attr.attr,
  938. &sensor_dev_attr_temp6_alarm.dev_attr.attr,
  939. &sensor_dev_attr_temp7_alarm.dev_attr.attr,
  940. &sensor_dev_attr_temp8_alarm.dev_attr.attr,
  941. &sensor_dev_attr_temp9_alarm.dev_attr.attr,
  942. &sensor_dev_attr_temp10_alarm.dev_attr.attr,
  943. &sensor_dev_attr_fan1_max.dev_attr.attr,
  944. &sensor_dev_attr_fan2_max.dev_attr.attr,
  945. &sensor_dev_attr_fan3_max.dev_attr.attr,
  946. &sensor_dev_attr_fan4_max.dev_attr.attr,
  947. &sensor_dev_attr_fan1_min.dev_attr.attr,
  948. &sensor_dev_attr_fan2_min.dev_attr.attr,
  949. &sensor_dev_attr_fan3_min.dev_attr.attr,
  950. &sensor_dev_attr_fan4_min.dev_attr.attr,
  951. &sensor_dev_attr_fan1_input.dev_attr.attr,
  952. &sensor_dev_attr_fan2_input.dev_attr.attr,
  953. &sensor_dev_attr_fan3_input.dev_attr.attr,
  954. &sensor_dev_attr_fan4_input.dev_attr.attr,
  955. &sensor_dev_attr_fan1_alarm.dev_attr.attr,
  956. &sensor_dev_attr_fan2_alarm.dev_attr.attr,
  957. &sensor_dev_attr_fan3_alarm.dev_attr.attr,
  958. &sensor_dev_attr_fan4_alarm.dev_attr.attr,
  959. &sensor_dev_attr_force_pwm_max.dev_attr.attr,
  960. &sensor_dev_attr_pwm1.dev_attr.attr,
  961. &dev_attr_pwm1_freq.attr,
  962. &sensor_dev_attr_pwm2.dev_attr.attr,
  963. &sensor_dev_attr_pwm3.dev_attr.attr,
  964. &sensor_dev_attr_pwm4.dev_attr.attr,
  965. &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
  966. &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
  967. &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
  968. &sensor_dev_attr_pwm4_auto_point1_pwm.dev_attr.attr,
  969. &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
  970. &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
  971. &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
  972. &sensor_dev_attr_pwm4_auto_point2_pwm.dev_attr.attr,
  973. &sensor_dev_attr_pwm1_auto_point1_temp.dev_attr.attr,
  974. &sensor_dev_attr_pwm2_auto_point1_temp.dev_attr.attr,
  975. &sensor_dev_attr_pwm3_auto_point1_temp.dev_attr.attr,
  976. &sensor_dev_attr_pwm4_auto_point1_temp.dev_attr.attr,
  977. &sensor_dev_attr_pwm1_auto_point2_temp.dev_attr.attr,
  978. &sensor_dev_attr_pwm2_auto_point2_temp.dev_attr.attr,
  979. &sensor_dev_attr_pwm3_auto_point2_temp.dev_attr.attr,
  980. &sensor_dev_attr_pwm4_auto_point2_temp.dev_attr.attr,
  981. &sensor_dev_attr_pwm1_enable.dev_attr.attr,
  982. &sensor_dev_attr_pwm2_enable.dev_attr.attr,
  983. &sensor_dev_attr_pwm3_enable.dev_attr.attr,
  984. &sensor_dev_attr_pwm4_enable.dev_attr.attr,
  985. &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,
  986. &sensor_dev_attr_pwm2_auto_channels_temp.dev_attr.attr,
  987. &sensor_dev_attr_pwm3_auto_channels_temp.dev_attr.attr,
  988. &sensor_dev_attr_pwm4_auto_channels_temp.dev_attr.attr,
  989. NULL
  990. };
  991. ATTRIBUTE_GROUPS(adt7470);
  992. /* Return 0 if detection is successful, -ENODEV otherwise */
  993. static int adt7470_detect(struct i2c_client *client,
  994. struct i2c_board_info *info)
  995. {
  996. struct i2c_adapter *adapter = client->adapter;
  997. int vendor, device, revision;
  998. if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
  999. return -ENODEV;
  1000. vendor = i2c_smbus_read_byte_data(client, ADT7470_REG_VENDOR);
  1001. if (vendor != ADT7470_VENDOR)
  1002. return -ENODEV;
  1003. device = i2c_smbus_read_byte_data(client, ADT7470_REG_DEVICE);
  1004. if (device != ADT7470_DEVICE)
  1005. return -ENODEV;
  1006. revision = i2c_smbus_read_byte_data(client, ADT7470_REG_REVISION);
  1007. if (revision != ADT7470_REVISION)
  1008. return -ENODEV;
  1009. strlcpy(info->type, "adt7470", I2C_NAME_SIZE);
  1010. return 0;
  1011. }
  1012. static void adt7470_init_client(struct i2c_client *client)
  1013. {
  1014. int reg = i2c_smbus_read_byte_data(client, ADT7470_REG_CFG);
  1015. if (reg < 0) {
  1016. dev_err(&client->dev, "cannot read configuration register\n");
  1017. } else {
  1018. /* start monitoring (and do a self-test) */
  1019. i2c_smbus_write_byte_data(client, ADT7470_REG_CFG, reg | 3);
  1020. }
  1021. }
  1022. static int adt7470_probe(struct i2c_client *client)
  1023. {
  1024. struct device *dev = &client->dev;
  1025. struct adt7470_data *data;
  1026. struct device *hwmon_dev;
  1027. data = devm_kzalloc(dev, sizeof(struct adt7470_data), GFP_KERNEL);
  1028. if (!data)
  1029. return -ENOMEM;
  1030. data->num_temp_sensors = -1;
  1031. data->auto_update_interval = AUTO_UPDATE_INTERVAL;
  1032. i2c_set_clientdata(client, data);
  1033. data->client = client;
  1034. mutex_init(&data->lock);
  1035. dev_info(&client->dev, "%s chip found\n", client->name);
  1036. /* Initialize the ADT7470 chip */
  1037. adt7470_init_client(client);
  1038. /* Register sysfs hooks */
  1039. hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
  1040. data,
  1041. adt7470_groups);
  1042. if (IS_ERR(hwmon_dev))
  1043. return PTR_ERR(hwmon_dev);
  1044. data->auto_update = kthread_run(adt7470_update_thread, client, "%s",
  1045. dev_name(hwmon_dev));
  1046. if (IS_ERR(data->auto_update)) {
  1047. return PTR_ERR(data->auto_update);
  1048. }
  1049. return 0;
  1050. }
  1051. static int adt7470_remove(struct i2c_client *client)
  1052. {
  1053. struct adt7470_data *data = i2c_get_clientdata(client);
  1054. kthread_stop(data->auto_update);
  1055. return 0;
  1056. }
  1057. static const struct i2c_device_id adt7470_id[] = {
  1058. { "adt7470", 0 },
  1059. { }
  1060. };
  1061. MODULE_DEVICE_TABLE(i2c, adt7470_id);
  1062. static struct i2c_driver adt7470_driver = {
  1063. .class = I2C_CLASS_HWMON,
  1064. .driver = {
  1065. .name = "adt7470",
  1066. },
  1067. .probe_new = adt7470_probe,
  1068. .remove = adt7470_remove,
  1069. .id_table = adt7470_id,
  1070. .detect = adt7470_detect,
  1071. .address_list = normal_i2c,
  1072. };
  1073. module_i2c_driver(adt7470_driver);
  1074. MODULE_AUTHOR("Darrick J. Wong <darrick.wong@oracle.com>");
  1075. MODULE_DESCRIPTION("ADT7470 driver");
  1076. MODULE_LICENSE("GPL");