adt7462.c 53 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * A hwmon driver for the Analog Devices ADT7462
  4. * Copyright (C) 2008 IBM
  5. *
  6. * Author: Darrick J. Wong <darrick.wong@oracle.com>
  7. */
  8. #include <linux/module.h>
  9. #include <linux/jiffies.h>
  10. #include <linux/i2c.h>
  11. #include <linux/hwmon.h>
  12. #include <linux/hwmon-sysfs.h>
  13. #include <linux/err.h>
  14. #include <linux/mutex.h>
  15. #include <linux/log2.h>
  16. #include <linux/slab.h>
  17. /* Addresses to scan */
  18. static const unsigned short normal_i2c[] = { 0x58, 0x5C, I2C_CLIENT_END };
  19. /* ADT7462 registers */
  20. #define ADT7462_REG_DEVICE 0x3D
  21. #define ADT7462_REG_VENDOR 0x3E
  22. #define ADT7462_REG_REVISION 0x3F
  23. #define ADT7462_REG_MIN_TEMP_BASE_ADDR 0x44
  24. #define ADT7462_REG_MIN_TEMP_MAX_ADDR 0x47
  25. #define ADT7462_REG_MAX_TEMP_BASE_ADDR 0x48
  26. #define ADT7462_REG_MAX_TEMP_MAX_ADDR 0x4B
  27. #define ADT7462_REG_TEMP_BASE_ADDR 0x88
  28. #define ADT7462_REG_TEMP_MAX_ADDR 0x8F
  29. #define ADT7462_REG_FAN_BASE_ADDR 0x98
  30. #define ADT7462_REG_FAN_MAX_ADDR 0x9F
  31. #define ADT7462_REG_FAN2_BASE_ADDR 0xA2
  32. #define ADT7462_REG_FAN2_MAX_ADDR 0xA9
  33. #define ADT7462_REG_FAN_ENABLE 0x07
  34. #define ADT7462_REG_FAN_MIN_BASE_ADDR 0x78
  35. #define ADT7462_REG_FAN_MIN_MAX_ADDR 0x7F
  36. #define ADT7462_REG_CFG2 0x02
  37. #define ADT7462_FSPD_MASK 0x20
  38. #define ADT7462_REG_PWM_BASE_ADDR 0xAA
  39. #define ADT7462_REG_PWM_MAX_ADDR 0xAD
  40. #define ADT7462_REG_PWM_MIN_BASE_ADDR 0x28
  41. #define ADT7462_REG_PWM_MIN_MAX_ADDR 0x2B
  42. #define ADT7462_REG_PWM_MAX 0x2C
  43. #define ADT7462_REG_PWM_TEMP_MIN_BASE_ADDR 0x5C
  44. #define ADT7462_REG_PWM_TEMP_MIN_MAX_ADDR 0x5F
  45. #define ADT7462_REG_PWM_TEMP_RANGE_BASE_ADDR 0x60
  46. #define ADT7462_REG_PWM_TEMP_RANGE_MAX_ADDR 0x63
  47. #define ADT7462_PWM_HYST_MASK 0x0F
  48. #define ADT7462_PWM_RANGE_MASK 0xF0
  49. #define ADT7462_PWM_RANGE_SHIFT 4
  50. #define ADT7462_REG_PWM_CFG_BASE_ADDR 0x21
  51. #define ADT7462_REG_PWM_CFG_MAX_ADDR 0x24
  52. #define ADT7462_PWM_CHANNEL_MASK 0xE0
  53. #define ADT7462_PWM_CHANNEL_SHIFT 5
  54. #define ADT7462_REG_PIN_CFG_BASE_ADDR 0x10
  55. #define ADT7462_REG_PIN_CFG_MAX_ADDR 0x13
  56. #define ADT7462_PIN7_INPUT 0x01 /* cfg0 */
  57. #define ADT7462_DIODE3_INPUT 0x20
  58. #define ADT7462_DIODE1_INPUT 0x40
  59. #define ADT7462_VID_INPUT 0x80
  60. #define ADT7462_PIN22_INPUT 0x04 /* cfg1 */
  61. #define ADT7462_PIN21_INPUT 0x08
  62. #define ADT7462_PIN19_INPUT 0x10
  63. #define ADT7462_PIN15_INPUT 0x20
  64. #define ADT7462_PIN13_INPUT 0x40
  65. #define ADT7462_PIN8_INPUT 0x80
  66. #define ADT7462_PIN23_MASK 0x03
  67. #define ADT7462_PIN23_SHIFT 0
  68. #define ADT7462_PIN26_MASK 0x0C /* cfg2 */
  69. #define ADT7462_PIN26_SHIFT 2
  70. #define ADT7462_PIN25_MASK 0x30
  71. #define ADT7462_PIN25_SHIFT 4
  72. #define ADT7462_PIN24_MASK 0xC0
  73. #define ADT7462_PIN24_SHIFT 6
  74. #define ADT7462_PIN26_VOLT_INPUT 0x08
  75. #define ADT7462_PIN25_VOLT_INPUT 0x20
  76. #define ADT7462_PIN28_SHIFT 4 /* cfg3 */
  77. #define ADT7462_PIN28_VOLT 0x5
  78. #define ADT7462_REG_ALARM1 0xB8
  79. #define ADT7462_LT_ALARM 0x02
  80. #define ADT7462_R1T_ALARM 0x04
  81. #define ADT7462_R2T_ALARM 0x08
  82. #define ADT7462_R3T_ALARM 0x10
  83. #define ADT7462_REG_ALARM2 0xBB
  84. #define ADT7462_V0_ALARM 0x01
  85. #define ADT7462_V1_ALARM 0x02
  86. #define ADT7462_V2_ALARM 0x04
  87. #define ADT7462_V3_ALARM 0x08
  88. #define ADT7462_V4_ALARM 0x10
  89. #define ADT7462_V5_ALARM 0x20
  90. #define ADT7462_V6_ALARM 0x40
  91. #define ADT7462_V7_ALARM 0x80
  92. #define ADT7462_REG_ALARM3 0xBC
  93. #define ADT7462_V8_ALARM 0x08
  94. #define ADT7462_V9_ALARM 0x10
  95. #define ADT7462_V10_ALARM 0x20
  96. #define ADT7462_V11_ALARM 0x40
  97. #define ADT7462_V12_ALARM 0x80
  98. #define ADT7462_REG_ALARM4 0xBD
  99. #define ADT7462_F0_ALARM 0x01
  100. #define ADT7462_F1_ALARM 0x02
  101. #define ADT7462_F2_ALARM 0x04
  102. #define ADT7462_F3_ALARM 0x08
  103. #define ADT7462_F4_ALARM 0x10
  104. #define ADT7462_F5_ALARM 0x20
  105. #define ADT7462_F6_ALARM 0x40
  106. #define ADT7462_F7_ALARM 0x80
  107. #define ADT7462_ALARM1 0x0000
  108. #define ADT7462_ALARM2 0x0100
  109. #define ADT7462_ALARM3 0x0200
  110. #define ADT7462_ALARM4 0x0300
  111. #define ADT7462_ALARM_REG_SHIFT 8
  112. #define ADT7462_ALARM_FLAG_MASK 0x0F
  113. #define ADT7462_TEMP_COUNT 4
  114. #define ADT7462_TEMP_REG(x) (ADT7462_REG_TEMP_BASE_ADDR + ((x) * 2))
  115. #define ADT7462_TEMP_MIN_REG(x) (ADT7462_REG_MIN_TEMP_BASE_ADDR + (x))
  116. #define ADT7462_TEMP_MAX_REG(x) (ADT7462_REG_MAX_TEMP_BASE_ADDR + (x))
  117. #define TEMP_FRAC_OFFSET 6
  118. #define ADT7462_FAN_COUNT 8
  119. #define ADT7462_REG_FAN_MIN(x) (ADT7462_REG_FAN_MIN_BASE_ADDR + (x))
  120. #define ADT7462_PWM_COUNT 4
  121. #define ADT7462_REG_PWM(x) (ADT7462_REG_PWM_BASE_ADDR + (x))
  122. #define ADT7462_REG_PWM_MIN(x) (ADT7462_REG_PWM_MIN_BASE_ADDR + (x))
  123. #define ADT7462_REG_PWM_TMIN(x) \
  124. (ADT7462_REG_PWM_TEMP_MIN_BASE_ADDR + (x))
  125. #define ADT7462_REG_PWM_TRANGE(x) \
  126. (ADT7462_REG_PWM_TEMP_RANGE_BASE_ADDR + (x))
  127. #define ADT7462_PIN_CFG_REG_COUNT 4
  128. #define ADT7462_REG_PIN_CFG(x) (ADT7462_REG_PIN_CFG_BASE_ADDR + (x))
  129. #define ADT7462_REG_PWM_CFG(x) (ADT7462_REG_PWM_CFG_BASE_ADDR + (x))
  130. #define ADT7462_ALARM_REG_COUNT 4
  131. /*
  132. * The chip can measure 13 different voltage sources:
  133. *
  134. * 1. +12V1 (pin 7)
  135. * 2. Vccp1/+2.5V/+1.8V/+1.5V (pin 23)
  136. * 3. +12V3 (pin 22)
  137. * 4. +5V (pin 21)
  138. * 5. +1.25V/+0.9V (pin 19)
  139. * 6. +2.5V/+1.8V (pin 15)
  140. * 7. +3.3v (pin 13)
  141. * 8. +12V2 (pin 8)
  142. * 9. Vbatt/FSB_Vtt (pin 26)
  143. * A. +3.3V/+1.2V1 (pin 25)
  144. * B. Vccp2/+2.5V/+1.8V/+1.5V (pin 24)
  145. * C. +1.5V ICH (only if BOTH pin 28/29 are set to +1.5V)
  146. * D. +1.5V 3GPIO (only if BOTH pin 28/29 are set to +1.5V)
  147. *
  148. * Each of these 13 has a factor to convert raw to voltage. Even better,
  149. * the pins can be connected to other sensors (tach/gpio/hot/etc), which
  150. * makes the bookkeeping tricky.
  151. *
  152. * Some, but not all, of these voltages have low/high limits.
  153. */
  154. #define ADT7462_VOLT_COUNT 13
  155. #define ADT7462_VENDOR 0x41
  156. #define ADT7462_DEVICE 0x62
  157. /* datasheet only mentions a revision 4 */
  158. #define ADT7462_REVISION 0x04
  159. /* How often do we reread sensors values? (In jiffies) */
  160. #define SENSOR_REFRESH_INTERVAL (2 * HZ)
  161. /* How often do we reread sensor limit values? (In jiffies) */
  162. #define LIMIT_REFRESH_INTERVAL (60 * HZ)
  163. /* datasheet says to divide this number by the fan reading to get fan rpm */
  164. #define FAN_PERIOD_TO_RPM(x) ((90000 * 60) / (x))
  165. #define FAN_RPM_TO_PERIOD FAN_PERIOD_TO_RPM
  166. #define FAN_PERIOD_INVALID 65535
  167. #define FAN_DATA_VALID(x) ((x) && (x) != FAN_PERIOD_INVALID)
  168. #define MASK_AND_SHIFT(value, prefix) \
  169. (((value) & prefix##_MASK) >> prefix##_SHIFT)
  170. struct adt7462_data {
  171. struct i2c_client *client;
  172. struct mutex lock;
  173. char sensors_valid;
  174. char limits_valid;
  175. unsigned long sensors_last_updated; /* In jiffies */
  176. unsigned long limits_last_updated; /* In jiffies */
  177. u8 temp[ADT7462_TEMP_COUNT];
  178. /* bits 6-7 are quarter pieces of temp */
  179. u8 temp_frac[ADT7462_TEMP_COUNT];
  180. u8 temp_min[ADT7462_TEMP_COUNT];
  181. u8 temp_max[ADT7462_TEMP_COUNT];
  182. u16 fan[ADT7462_FAN_COUNT];
  183. u8 fan_enabled;
  184. u8 fan_min[ADT7462_FAN_COUNT];
  185. u8 cfg2;
  186. u8 pwm[ADT7462_PWM_COUNT];
  187. u8 pin_cfg[ADT7462_PIN_CFG_REG_COUNT];
  188. u8 voltages[ADT7462_VOLT_COUNT];
  189. u8 volt_max[ADT7462_VOLT_COUNT];
  190. u8 volt_min[ADT7462_VOLT_COUNT];
  191. u8 pwm_min[ADT7462_PWM_COUNT];
  192. u8 pwm_tmin[ADT7462_PWM_COUNT];
  193. u8 pwm_trange[ADT7462_PWM_COUNT];
  194. u8 pwm_max; /* only one per chip */
  195. u8 pwm_cfg[ADT7462_PWM_COUNT];
  196. u8 alarms[ADT7462_ALARM_REG_COUNT];
  197. };
  198. /*
  199. * 16-bit registers on the ADT7462 are low-byte first. The data sheet says
  200. * that the low byte must be read before the high byte.
  201. */
  202. static inline int adt7462_read_word_data(struct i2c_client *client, u8 reg)
  203. {
  204. u16 foo;
  205. foo = i2c_smbus_read_byte_data(client, reg);
  206. foo |= ((u16)i2c_smbus_read_byte_data(client, reg + 1) << 8);
  207. return foo;
  208. }
  209. /* For some reason these registers are not contiguous. */
  210. static int ADT7462_REG_FAN(int fan)
  211. {
  212. if (fan < 4)
  213. return ADT7462_REG_FAN_BASE_ADDR + (2 * fan);
  214. return ADT7462_REG_FAN2_BASE_ADDR + (2 * (fan - 4));
  215. }
  216. /* Voltage registers are scattered everywhere */
  217. static int ADT7462_REG_VOLT_MAX(struct adt7462_data *data, int which)
  218. {
  219. switch (which) {
  220. case 0:
  221. if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
  222. return 0x7C;
  223. break;
  224. case 1:
  225. return 0x69;
  226. case 2:
  227. if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
  228. return 0x7F;
  229. break;
  230. case 3:
  231. if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
  232. return 0x7E;
  233. break;
  234. case 4:
  235. if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT))
  236. return 0x4B;
  237. break;
  238. case 5:
  239. if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT))
  240. return 0x49;
  241. break;
  242. case 6:
  243. if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
  244. return 0x68;
  245. break;
  246. case 7:
  247. if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
  248. return 0x7D;
  249. break;
  250. case 8:
  251. if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT))
  252. return 0x6C;
  253. break;
  254. case 9:
  255. if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT))
  256. return 0x6B;
  257. break;
  258. case 10:
  259. return 0x6A;
  260. case 11:
  261. if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
  262. ADT7462_PIN28_VOLT &&
  263. !(data->pin_cfg[0] & ADT7462_VID_INPUT))
  264. return 0x50;
  265. break;
  266. case 12:
  267. if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
  268. ADT7462_PIN28_VOLT &&
  269. !(data->pin_cfg[0] & ADT7462_VID_INPUT))
  270. return 0x4C;
  271. break;
  272. }
  273. return 0;
  274. }
  275. static int ADT7462_REG_VOLT_MIN(struct adt7462_data *data, int which)
  276. {
  277. switch (which) {
  278. case 0:
  279. if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
  280. return 0x6D;
  281. break;
  282. case 1:
  283. return 0x72;
  284. case 2:
  285. if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
  286. return 0x6F;
  287. break;
  288. case 3:
  289. if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
  290. return 0x71;
  291. break;
  292. case 4:
  293. if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT))
  294. return 0x47;
  295. break;
  296. case 5:
  297. if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT))
  298. return 0x45;
  299. break;
  300. case 6:
  301. if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
  302. return 0x70;
  303. break;
  304. case 7:
  305. if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
  306. return 0x6E;
  307. break;
  308. case 8:
  309. if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT))
  310. return 0x75;
  311. break;
  312. case 9:
  313. if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT))
  314. return 0x74;
  315. break;
  316. case 10:
  317. return 0x73;
  318. case 11:
  319. if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
  320. ADT7462_PIN28_VOLT &&
  321. !(data->pin_cfg[0] & ADT7462_VID_INPUT))
  322. return 0x76;
  323. break;
  324. case 12:
  325. if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
  326. ADT7462_PIN28_VOLT &&
  327. !(data->pin_cfg[0] & ADT7462_VID_INPUT))
  328. return 0x77;
  329. break;
  330. }
  331. return 0;
  332. }
  333. static int ADT7462_REG_VOLT(struct adt7462_data *data, int which)
  334. {
  335. switch (which) {
  336. case 0:
  337. if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
  338. return 0xA3;
  339. break;
  340. case 1:
  341. return 0x90;
  342. case 2:
  343. if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
  344. return 0xA9;
  345. break;
  346. case 3:
  347. if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
  348. return 0xA7;
  349. break;
  350. case 4:
  351. if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT))
  352. return 0x8F;
  353. break;
  354. case 5:
  355. if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT))
  356. return 0x8B;
  357. break;
  358. case 6:
  359. if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
  360. return 0x96;
  361. break;
  362. case 7:
  363. if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
  364. return 0xA5;
  365. break;
  366. case 8:
  367. if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT))
  368. return 0x93;
  369. break;
  370. case 9:
  371. if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT))
  372. return 0x92;
  373. break;
  374. case 10:
  375. return 0x91;
  376. case 11:
  377. if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
  378. ADT7462_PIN28_VOLT &&
  379. !(data->pin_cfg[0] & ADT7462_VID_INPUT))
  380. return 0x94;
  381. break;
  382. case 12:
  383. if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
  384. ADT7462_PIN28_VOLT &&
  385. !(data->pin_cfg[0] & ADT7462_VID_INPUT))
  386. return 0x95;
  387. break;
  388. }
  389. return 0;
  390. }
  391. /* Provide labels for sysfs */
  392. static const char *voltage_label(struct adt7462_data *data, int which)
  393. {
  394. switch (which) {
  395. case 0:
  396. if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
  397. return "+12V1";
  398. break;
  399. case 1:
  400. switch (MASK_AND_SHIFT(data->pin_cfg[1], ADT7462_PIN23)) {
  401. case 0:
  402. return "Vccp1";
  403. case 1:
  404. return "+2.5V";
  405. case 2:
  406. return "+1.8V";
  407. case 3:
  408. return "+1.5V";
  409. }
  410. fallthrough;
  411. case 2:
  412. if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
  413. return "+12V3";
  414. break;
  415. case 3:
  416. if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
  417. return "+5V";
  418. break;
  419. case 4:
  420. if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) {
  421. if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
  422. return "+0.9V";
  423. return "+1.25V";
  424. }
  425. break;
  426. case 5:
  427. if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) {
  428. if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
  429. return "+1.8V";
  430. return "+2.5V";
  431. }
  432. break;
  433. case 6:
  434. if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
  435. return "+3.3V";
  436. break;
  437. case 7:
  438. if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
  439. return "+12V2";
  440. break;
  441. case 8:
  442. switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN26)) {
  443. case 0:
  444. return "Vbatt";
  445. case 1:
  446. return "FSB_Vtt";
  447. }
  448. break;
  449. case 9:
  450. switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN25)) {
  451. case 0:
  452. return "+3.3V";
  453. case 1:
  454. return "+1.2V1";
  455. }
  456. break;
  457. case 10:
  458. switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN24)) {
  459. case 0:
  460. return "Vccp2";
  461. case 1:
  462. return "+2.5V";
  463. case 2:
  464. return "+1.8V";
  465. case 3:
  466. return "+1.5";
  467. }
  468. fallthrough;
  469. case 11:
  470. if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
  471. ADT7462_PIN28_VOLT &&
  472. !(data->pin_cfg[0] & ADT7462_VID_INPUT))
  473. return "+1.5V ICH";
  474. break;
  475. case 12:
  476. if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
  477. ADT7462_PIN28_VOLT &&
  478. !(data->pin_cfg[0] & ADT7462_VID_INPUT))
  479. return "+1.5V 3GPIO";
  480. break;
  481. }
  482. return "N/A";
  483. }
  484. /* Multipliers are actually in uV, not mV. */
  485. static int voltage_multiplier(struct adt7462_data *data, int which)
  486. {
  487. switch (which) {
  488. case 0:
  489. if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
  490. return 62500;
  491. break;
  492. case 1:
  493. switch (MASK_AND_SHIFT(data->pin_cfg[1], ADT7462_PIN23)) {
  494. case 0:
  495. if (data->pin_cfg[0] & ADT7462_VID_INPUT)
  496. return 12500;
  497. return 6250;
  498. case 1:
  499. return 13000;
  500. case 2:
  501. return 9400;
  502. case 3:
  503. return 7800;
  504. }
  505. fallthrough;
  506. case 2:
  507. if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
  508. return 62500;
  509. break;
  510. case 3:
  511. if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
  512. return 26000;
  513. break;
  514. case 4:
  515. if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) {
  516. if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
  517. return 4690;
  518. return 6500;
  519. }
  520. break;
  521. case 5:
  522. if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) {
  523. if (data->pin_cfg[1] & ADT7462_PIN15_INPUT)
  524. return 9400;
  525. return 13000;
  526. }
  527. break;
  528. case 6:
  529. if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
  530. return 17200;
  531. break;
  532. case 7:
  533. if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
  534. return 62500;
  535. break;
  536. case 8:
  537. switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN26)) {
  538. case 0:
  539. return 15600;
  540. case 1:
  541. return 6250;
  542. }
  543. break;
  544. case 9:
  545. switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN25)) {
  546. case 0:
  547. return 17200;
  548. case 1:
  549. return 6250;
  550. }
  551. break;
  552. case 10:
  553. switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN24)) {
  554. case 0:
  555. return 6250;
  556. case 1:
  557. return 13000;
  558. case 2:
  559. return 9400;
  560. case 3:
  561. return 7800;
  562. }
  563. fallthrough;
  564. case 11:
  565. case 12:
  566. if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
  567. ADT7462_PIN28_VOLT &&
  568. !(data->pin_cfg[0] & ADT7462_VID_INPUT))
  569. return 7800;
  570. }
  571. return 0;
  572. }
  573. static int temp_enabled(struct adt7462_data *data, int which)
  574. {
  575. switch (which) {
  576. case 0:
  577. case 2:
  578. return 1;
  579. case 1:
  580. if (data->pin_cfg[0] & ADT7462_DIODE1_INPUT)
  581. return 1;
  582. break;
  583. case 3:
  584. if (data->pin_cfg[0] & ADT7462_DIODE3_INPUT)
  585. return 1;
  586. break;
  587. }
  588. return 0;
  589. }
  590. static const char *temp_label(struct adt7462_data *data, int which)
  591. {
  592. switch (which) {
  593. case 0:
  594. return "local";
  595. case 1:
  596. if (data->pin_cfg[0] & ADT7462_DIODE1_INPUT)
  597. return "remote1";
  598. break;
  599. case 2:
  600. return "remote2";
  601. case 3:
  602. if (data->pin_cfg[0] & ADT7462_DIODE3_INPUT)
  603. return "remote3";
  604. break;
  605. }
  606. return "N/A";
  607. }
  608. /* Map Trange register values to mC */
  609. #define NUM_TRANGE_VALUES 16
  610. static const int trange_values[NUM_TRANGE_VALUES] = {
  611. 2000,
  612. 2500,
  613. 3300,
  614. 4000,
  615. 5000,
  616. 6700,
  617. 8000,
  618. 10000,
  619. 13300,
  620. 16000,
  621. 20000,
  622. 26700,
  623. 32000,
  624. 40000,
  625. 53300,
  626. 80000
  627. };
  628. static int find_trange_value(int trange)
  629. {
  630. int i;
  631. for (i = 0; i < NUM_TRANGE_VALUES; i++)
  632. if (trange_values[i] == trange)
  633. return i;
  634. return -EINVAL;
  635. }
  636. static struct adt7462_data *adt7462_update_device(struct device *dev)
  637. {
  638. struct adt7462_data *data = dev_get_drvdata(dev);
  639. struct i2c_client *client = data->client;
  640. unsigned long local_jiffies = jiffies;
  641. int i;
  642. mutex_lock(&data->lock);
  643. if (time_before(local_jiffies, data->sensors_last_updated +
  644. SENSOR_REFRESH_INTERVAL)
  645. && data->sensors_valid)
  646. goto no_sensor_update;
  647. for (i = 0; i < ADT7462_TEMP_COUNT; i++) {
  648. /*
  649. * Reading the fractional register locks the integral
  650. * register until both have been read.
  651. */
  652. data->temp_frac[i] = i2c_smbus_read_byte_data(client,
  653. ADT7462_TEMP_REG(i));
  654. data->temp[i] = i2c_smbus_read_byte_data(client,
  655. ADT7462_TEMP_REG(i) + 1);
  656. }
  657. for (i = 0; i < ADT7462_FAN_COUNT; i++)
  658. data->fan[i] = adt7462_read_word_data(client,
  659. ADT7462_REG_FAN(i));
  660. data->fan_enabled = i2c_smbus_read_byte_data(client,
  661. ADT7462_REG_FAN_ENABLE);
  662. for (i = 0; i < ADT7462_PWM_COUNT; i++)
  663. data->pwm[i] = i2c_smbus_read_byte_data(client,
  664. ADT7462_REG_PWM(i));
  665. for (i = 0; i < ADT7462_PIN_CFG_REG_COUNT; i++)
  666. data->pin_cfg[i] = i2c_smbus_read_byte_data(client,
  667. ADT7462_REG_PIN_CFG(i));
  668. for (i = 0; i < ADT7462_VOLT_COUNT; i++) {
  669. int reg = ADT7462_REG_VOLT(data, i);
  670. if (!reg)
  671. data->voltages[i] = 0;
  672. else
  673. data->voltages[i] = i2c_smbus_read_byte_data(client,
  674. reg);
  675. }
  676. data->alarms[0] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM1);
  677. data->alarms[1] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM2);
  678. data->alarms[2] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM3);
  679. data->alarms[3] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM4);
  680. data->sensors_last_updated = local_jiffies;
  681. data->sensors_valid = 1;
  682. no_sensor_update:
  683. if (time_before(local_jiffies, data->limits_last_updated +
  684. LIMIT_REFRESH_INTERVAL)
  685. && data->limits_valid)
  686. goto out;
  687. for (i = 0; i < ADT7462_TEMP_COUNT; i++) {
  688. data->temp_min[i] = i2c_smbus_read_byte_data(client,
  689. ADT7462_TEMP_MIN_REG(i));
  690. data->temp_max[i] = i2c_smbus_read_byte_data(client,
  691. ADT7462_TEMP_MAX_REG(i));
  692. }
  693. for (i = 0; i < ADT7462_FAN_COUNT; i++)
  694. data->fan_min[i] = i2c_smbus_read_byte_data(client,
  695. ADT7462_REG_FAN_MIN(i));
  696. for (i = 0; i < ADT7462_VOLT_COUNT; i++) {
  697. int reg = ADT7462_REG_VOLT_MAX(data, i);
  698. data->volt_max[i] =
  699. (reg ? i2c_smbus_read_byte_data(client, reg) : 0);
  700. reg = ADT7462_REG_VOLT_MIN(data, i);
  701. data->volt_min[i] =
  702. (reg ? i2c_smbus_read_byte_data(client, reg) : 0);
  703. }
  704. for (i = 0; i < ADT7462_PWM_COUNT; i++) {
  705. data->pwm_min[i] = i2c_smbus_read_byte_data(client,
  706. ADT7462_REG_PWM_MIN(i));
  707. data->pwm_tmin[i] = i2c_smbus_read_byte_data(client,
  708. ADT7462_REG_PWM_TMIN(i));
  709. data->pwm_trange[i] = i2c_smbus_read_byte_data(client,
  710. ADT7462_REG_PWM_TRANGE(i));
  711. data->pwm_cfg[i] = i2c_smbus_read_byte_data(client,
  712. ADT7462_REG_PWM_CFG(i));
  713. }
  714. data->pwm_max = i2c_smbus_read_byte_data(client, ADT7462_REG_PWM_MAX);
  715. data->cfg2 = i2c_smbus_read_byte_data(client, ADT7462_REG_CFG2);
  716. data->limits_last_updated = local_jiffies;
  717. data->limits_valid = 1;
  718. out:
  719. mutex_unlock(&data->lock);
  720. return data;
  721. }
  722. static ssize_t temp_min_show(struct device *dev,
  723. struct device_attribute *devattr, char *buf)
  724. {
  725. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  726. struct adt7462_data *data = adt7462_update_device(dev);
  727. if (!temp_enabled(data, attr->index))
  728. return sprintf(buf, "0\n");
  729. return sprintf(buf, "%d\n", 1000 * (data->temp_min[attr->index] - 64));
  730. }
  731. static ssize_t temp_min_store(struct device *dev,
  732. struct device_attribute *devattr,
  733. const char *buf, size_t count)
  734. {
  735. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  736. struct adt7462_data *data = dev_get_drvdata(dev);
  737. struct i2c_client *client = data->client;
  738. long temp;
  739. if (kstrtol(buf, 10, &temp) || !temp_enabled(data, attr->index))
  740. return -EINVAL;
  741. temp = clamp_val(temp, -64000, 191000);
  742. temp = DIV_ROUND_CLOSEST(temp, 1000) + 64;
  743. mutex_lock(&data->lock);
  744. data->temp_min[attr->index] = temp;
  745. i2c_smbus_write_byte_data(client, ADT7462_TEMP_MIN_REG(attr->index),
  746. temp);
  747. mutex_unlock(&data->lock);
  748. return count;
  749. }
  750. static ssize_t temp_max_show(struct device *dev,
  751. struct device_attribute *devattr, char *buf)
  752. {
  753. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  754. struct adt7462_data *data = adt7462_update_device(dev);
  755. if (!temp_enabled(data, attr->index))
  756. return sprintf(buf, "0\n");
  757. return sprintf(buf, "%d\n", 1000 * (data->temp_max[attr->index] - 64));
  758. }
  759. static ssize_t temp_max_store(struct device *dev,
  760. struct device_attribute *devattr,
  761. const char *buf, size_t count)
  762. {
  763. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  764. struct adt7462_data *data = dev_get_drvdata(dev);
  765. struct i2c_client *client = data->client;
  766. long temp;
  767. if (kstrtol(buf, 10, &temp) || !temp_enabled(data, attr->index))
  768. return -EINVAL;
  769. temp = clamp_val(temp, -64000, 191000);
  770. temp = DIV_ROUND_CLOSEST(temp, 1000) + 64;
  771. mutex_lock(&data->lock);
  772. data->temp_max[attr->index] = temp;
  773. i2c_smbus_write_byte_data(client, ADT7462_TEMP_MAX_REG(attr->index),
  774. temp);
  775. mutex_unlock(&data->lock);
  776. return count;
  777. }
  778. static ssize_t temp_show(struct device *dev, struct device_attribute *devattr,
  779. char *buf)
  780. {
  781. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  782. struct adt7462_data *data = adt7462_update_device(dev);
  783. u8 frac = data->temp_frac[attr->index] >> TEMP_FRAC_OFFSET;
  784. if (!temp_enabled(data, attr->index))
  785. return sprintf(buf, "0\n");
  786. return sprintf(buf, "%d\n", 1000 * (data->temp[attr->index] - 64) +
  787. 250 * frac);
  788. }
  789. static ssize_t temp_label_show(struct device *dev,
  790. struct device_attribute *devattr, char *buf)
  791. {
  792. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  793. struct adt7462_data *data = adt7462_update_device(dev);
  794. return sprintf(buf, "%s\n", temp_label(data, attr->index));
  795. }
  796. static ssize_t volt_max_show(struct device *dev,
  797. struct device_attribute *devattr, char *buf)
  798. {
  799. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  800. struct adt7462_data *data = adt7462_update_device(dev);
  801. int x = voltage_multiplier(data, attr->index);
  802. x *= data->volt_max[attr->index];
  803. x /= 1000; /* convert from uV to mV */
  804. return sprintf(buf, "%d\n", x);
  805. }
  806. static ssize_t volt_max_store(struct device *dev,
  807. struct device_attribute *devattr,
  808. const char *buf, size_t count)
  809. {
  810. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  811. struct adt7462_data *data = dev_get_drvdata(dev);
  812. struct i2c_client *client = data->client;
  813. int x = voltage_multiplier(data, attr->index);
  814. long temp;
  815. if (kstrtol(buf, 10, &temp) || !x)
  816. return -EINVAL;
  817. temp = clamp_val(temp, 0, 255 * x / 1000);
  818. temp *= 1000; /* convert mV to uV */
  819. temp = DIV_ROUND_CLOSEST(temp, x);
  820. mutex_lock(&data->lock);
  821. data->volt_max[attr->index] = temp;
  822. i2c_smbus_write_byte_data(client,
  823. ADT7462_REG_VOLT_MAX(data, attr->index),
  824. temp);
  825. mutex_unlock(&data->lock);
  826. return count;
  827. }
  828. static ssize_t volt_min_show(struct device *dev,
  829. struct device_attribute *devattr, char *buf)
  830. {
  831. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  832. struct adt7462_data *data = adt7462_update_device(dev);
  833. int x = voltage_multiplier(data, attr->index);
  834. x *= data->volt_min[attr->index];
  835. x /= 1000; /* convert from uV to mV */
  836. return sprintf(buf, "%d\n", x);
  837. }
  838. static ssize_t volt_min_store(struct device *dev,
  839. struct device_attribute *devattr,
  840. const char *buf, size_t count)
  841. {
  842. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  843. struct adt7462_data *data = dev_get_drvdata(dev);
  844. struct i2c_client *client = data->client;
  845. int x = voltage_multiplier(data, attr->index);
  846. long temp;
  847. if (kstrtol(buf, 10, &temp) || !x)
  848. return -EINVAL;
  849. temp = clamp_val(temp, 0, 255 * x / 1000);
  850. temp *= 1000; /* convert mV to uV */
  851. temp = DIV_ROUND_CLOSEST(temp, x);
  852. mutex_lock(&data->lock);
  853. data->volt_min[attr->index] = temp;
  854. i2c_smbus_write_byte_data(client,
  855. ADT7462_REG_VOLT_MIN(data, attr->index),
  856. temp);
  857. mutex_unlock(&data->lock);
  858. return count;
  859. }
  860. static ssize_t voltage_show(struct device *dev,
  861. struct device_attribute *devattr, char *buf)
  862. {
  863. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  864. struct adt7462_data *data = adt7462_update_device(dev);
  865. int x = voltage_multiplier(data, attr->index);
  866. x *= data->voltages[attr->index];
  867. x /= 1000; /* convert from uV to mV */
  868. return sprintf(buf, "%d\n", x);
  869. }
  870. static ssize_t voltage_label_show(struct device *dev,
  871. struct device_attribute *devattr, char *buf)
  872. {
  873. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  874. struct adt7462_data *data = adt7462_update_device(dev);
  875. return sprintf(buf, "%s\n", voltage_label(data, attr->index));
  876. }
  877. static ssize_t alarm_show(struct device *dev,
  878. struct device_attribute *devattr, char *buf)
  879. {
  880. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  881. struct adt7462_data *data = adt7462_update_device(dev);
  882. int reg = attr->index >> ADT7462_ALARM_REG_SHIFT;
  883. int mask = attr->index & ADT7462_ALARM_FLAG_MASK;
  884. if (data->alarms[reg] & mask)
  885. return sprintf(buf, "1\n");
  886. else
  887. return sprintf(buf, "0\n");
  888. }
  889. static int fan_enabled(struct adt7462_data *data, int fan)
  890. {
  891. return data->fan_enabled & (1 << fan);
  892. }
  893. static ssize_t fan_min_show(struct device *dev,
  894. struct device_attribute *devattr, char *buf)
  895. {
  896. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  897. struct adt7462_data *data = adt7462_update_device(dev);
  898. u16 temp;
  899. /* Only the MSB of the min fan period is stored... */
  900. temp = data->fan_min[attr->index];
  901. temp <<= 8;
  902. if (!fan_enabled(data, attr->index) ||
  903. !FAN_DATA_VALID(temp))
  904. return sprintf(buf, "0\n");
  905. return sprintf(buf, "%d\n", FAN_PERIOD_TO_RPM(temp));
  906. }
  907. static ssize_t fan_min_store(struct device *dev,
  908. struct device_attribute *devattr,
  909. const char *buf, size_t count)
  910. {
  911. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  912. struct adt7462_data *data = dev_get_drvdata(dev);
  913. struct i2c_client *client = data->client;
  914. long temp;
  915. if (kstrtol(buf, 10, &temp) || !temp ||
  916. !fan_enabled(data, attr->index))
  917. return -EINVAL;
  918. temp = FAN_RPM_TO_PERIOD(temp);
  919. temp >>= 8;
  920. temp = clamp_val(temp, 1, 255);
  921. mutex_lock(&data->lock);
  922. data->fan_min[attr->index] = temp;
  923. i2c_smbus_write_byte_data(client, ADT7462_REG_FAN_MIN(attr->index),
  924. temp);
  925. mutex_unlock(&data->lock);
  926. return count;
  927. }
  928. static ssize_t fan_show(struct device *dev, struct device_attribute *devattr,
  929. char *buf)
  930. {
  931. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  932. struct adt7462_data *data = adt7462_update_device(dev);
  933. if (!fan_enabled(data, attr->index) ||
  934. !FAN_DATA_VALID(data->fan[attr->index]))
  935. return sprintf(buf, "0\n");
  936. return sprintf(buf, "%d\n",
  937. FAN_PERIOD_TO_RPM(data->fan[attr->index]));
  938. }
  939. static ssize_t force_pwm_max_show(struct device *dev,
  940. struct device_attribute *devattr, char *buf)
  941. {
  942. struct adt7462_data *data = adt7462_update_device(dev);
  943. return sprintf(buf, "%d\n", (data->cfg2 & ADT7462_FSPD_MASK ? 1 : 0));
  944. }
  945. static ssize_t force_pwm_max_store(struct device *dev,
  946. struct device_attribute *devattr,
  947. const char *buf, size_t count)
  948. {
  949. struct adt7462_data *data = dev_get_drvdata(dev);
  950. struct i2c_client *client = data->client;
  951. long temp;
  952. u8 reg;
  953. if (kstrtol(buf, 10, &temp))
  954. return -EINVAL;
  955. mutex_lock(&data->lock);
  956. reg = i2c_smbus_read_byte_data(client, ADT7462_REG_CFG2);
  957. if (temp)
  958. reg |= ADT7462_FSPD_MASK;
  959. else
  960. reg &= ~ADT7462_FSPD_MASK;
  961. data->cfg2 = reg;
  962. i2c_smbus_write_byte_data(client, ADT7462_REG_CFG2, reg);
  963. mutex_unlock(&data->lock);
  964. return count;
  965. }
  966. static ssize_t pwm_show(struct device *dev, struct device_attribute *devattr,
  967. char *buf)
  968. {
  969. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  970. struct adt7462_data *data = adt7462_update_device(dev);
  971. return sprintf(buf, "%d\n", data->pwm[attr->index]);
  972. }
  973. static ssize_t pwm_store(struct device *dev, struct device_attribute *devattr,
  974. const char *buf, size_t count)
  975. {
  976. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  977. struct adt7462_data *data = dev_get_drvdata(dev);
  978. struct i2c_client *client = data->client;
  979. long temp;
  980. if (kstrtol(buf, 10, &temp))
  981. return -EINVAL;
  982. temp = clamp_val(temp, 0, 255);
  983. mutex_lock(&data->lock);
  984. data->pwm[attr->index] = temp;
  985. i2c_smbus_write_byte_data(client, ADT7462_REG_PWM(attr->index), temp);
  986. mutex_unlock(&data->lock);
  987. return count;
  988. }
  989. static ssize_t pwm_max_show(struct device *dev,
  990. struct device_attribute *devattr, char *buf)
  991. {
  992. struct adt7462_data *data = adt7462_update_device(dev);
  993. return sprintf(buf, "%d\n", data->pwm_max);
  994. }
  995. static ssize_t pwm_max_store(struct device *dev,
  996. struct device_attribute *devattr,
  997. const char *buf, size_t count)
  998. {
  999. struct adt7462_data *data = dev_get_drvdata(dev);
  1000. struct i2c_client *client = data->client;
  1001. long temp;
  1002. if (kstrtol(buf, 10, &temp))
  1003. return -EINVAL;
  1004. temp = clamp_val(temp, 0, 255);
  1005. mutex_lock(&data->lock);
  1006. data->pwm_max = temp;
  1007. i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_MAX, temp);
  1008. mutex_unlock(&data->lock);
  1009. return count;
  1010. }
  1011. static ssize_t pwm_min_show(struct device *dev,
  1012. struct device_attribute *devattr, char *buf)
  1013. {
  1014. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1015. struct adt7462_data *data = adt7462_update_device(dev);
  1016. return sprintf(buf, "%d\n", data->pwm_min[attr->index]);
  1017. }
  1018. static ssize_t pwm_min_store(struct device *dev,
  1019. struct device_attribute *devattr,
  1020. const char *buf, size_t count)
  1021. {
  1022. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1023. struct adt7462_data *data = dev_get_drvdata(dev);
  1024. struct i2c_client *client = data->client;
  1025. long temp;
  1026. if (kstrtol(buf, 10, &temp))
  1027. return -EINVAL;
  1028. temp = clamp_val(temp, 0, 255);
  1029. mutex_lock(&data->lock);
  1030. data->pwm_min[attr->index] = temp;
  1031. i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_MIN(attr->index),
  1032. temp);
  1033. mutex_unlock(&data->lock);
  1034. return count;
  1035. }
  1036. static ssize_t pwm_hyst_show(struct device *dev,
  1037. struct device_attribute *devattr, char *buf)
  1038. {
  1039. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1040. struct adt7462_data *data = adt7462_update_device(dev);
  1041. return sprintf(buf, "%d\n", 1000 *
  1042. (data->pwm_trange[attr->index] & ADT7462_PWM_HYST_MASK));
  1043. }
  1044. static ssize_t pwm_hyst_store(struct device *dev,
  1045. struct device_attribute *devattr,
  1046. const char *buf, size_t count)
  1047. {
  1048. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1049. struct adt7462_data *data = dev_get_drvdata(dev);
  1050. struct i2c_client *client = data->client;
  1051. long temp;
  1052. if (kstrtol(buf, 10, &temp))
  1053. return -EINVAL;
  1054. temp = clamp_val(temp, 0, 15000);
  1055. temp = DIV_ROUND_CLOSEST(temp, 1000);
  1056. /* package things up */
  1057. temp &= ADT7462_PWM_HYST_MASK;
  1058. temp |= data->pwm_trange[attr->index] & ADT7462_PWM_RANGE_MASK;
  1059. mutex_lock(&data->lock);
  1060. data->pwm_trange[attr->index] = temp;
  1061. i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TRANGE(attr->index),
  1062. temp);
  1063. mutex_unlock(&data->lock);
  1064. return count;
  1065. }
  1066. static ssize_t pwm_tmax_show(struct device *dev,
  1067. struct device_attribute *devattr, char *buf)
  1068. {
  1069. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1070. struct adt7462_data *data = adt7462_update_device(dev);
  1071. /* tmax = tmin + trange */
  1072. int trange = trange_values[data->pwm_trange[attr->index] >>
  1073. ADT7462_PWM_RANGE_SHIFT];
  1074. int tmin = (data->pwm_tmin[attr->index] - 64) * 1000;
  1075. return sprintf(buf, "%d\n", tmin + trange);
  1076. }
  1077. static ssize_t pwm_tmax_store(struct device *dev,
  1078. struct device_attribute *devattr,
  1079. const char *buf, size_t count)
  1080. {
  1081. int temp;
  1082. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1083. struct adt7462_data *data = dev_get_drvdata(dev);
  1084. struct i2c_client *client = data->client;
  1085. int tmin, trange_value;
  1086. long trange;
  1087. if (kstrtol(buf, 10, &trange))
  1088. return -EINVAL;
  1089. /* trange = tmax - tmin */
  1090. tmin = (data->pwm_tmin[attr->index] - 64) * 1000;
  1091. trange_value = find_trange_value(trange - tmin);
  1092. if (trange_value < 0)
  1093. return trange_value;
  1094. temp = trange_value << ADT7462_PWM_RANGE_SHIFT;
  1095. temp |= data->pwm_trange[attr->index] & ADT7462_PWM_HYST_MASK;
  1096. mutex_lock(&data->lock);
  1097. data->pwm_trange[attr->index] = temp;
  1098. i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TRANGE(attr->index),
  1099. temp);
  1100. mutex_unlock(&data->lock);
  1101. return count;
  1102. }
  1103. static ssize_t pwm_tmin_show(struct device *dev,
  1104. struct device_attribute *devattr, char *buf)
  1105. {
  1106. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1107. struct adt7462_data *data = adt7462_update_device(dev);
  1108. return sprintf(buf, "%d\n", 1000 * (data->pwm_tmin[attr->index] - 64));
  1109. }
  1110. static ssize_t pwm_tmin_store(struct device *dev,
  1111. struct device_attribute *devattr,
  1112. const char *buf, size_t count)
  1113. {
  1114. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1115. struct adt7462_data *data = dev_get_drvdata(dev);
  1116. struct i2c_client *client = data->client;
  1117. long temp;
  1118. if (kstrtol(buf, 10, &temp))
  1119. return -EINVAL;
  1120. temp = clamp_val(temp, -64000, 191000);
  1121. temp = DIV_ROUND_CLOSEST(temp, 1000) + 64;
  1122. mutex_lock(&data->lock);
  1123. data->pwm_tmin[attr->index] = temp;
  1124. i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TMIN(attr->index),
  1125. temp);
  1126. mutex_unlock(&data->lock);
  1127. return count;
  1128. }
  1129. static ssize_t pwm_auto_show(struct device *dev,
  1130. struct device_attribute *devattr, char *buf)
  1131. {
  1132. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1133. struct adt7462_data *data = adt7462_update_device(dev);
  1134. int cfg = data->pwm_cfg[attr->index] >> ADT7462_PWM_CHANNEL_SHIFT;
  1135. switch (cfg) {
  1136. case 4: /* off */
  1137. return sprintf(buf, "0\n");
  1138. case 7: /* manual */
  1139. return sprintf(buf, "1\n");
  1140. default: /* automatic */
  1141. return sprintf(buf, "2\n");
  1142. }
  1143. }
  1144. static void set_pwm_channel(struct i2c_client *client,
  1145. struct adt7462_data *data,
  1146. int which,
  1147. int value)
  1148. {
  1149. int temp = data->pwm_cfg[which] & ~ADT7462_PWM_CHANNEL_MASK;
  1150. temp |= value << ADT7462_PWM_CHANNEL_SHIFT;
  1151. mutex_lock(&data->lock);
  1152. data->pwm_cfg[which] = temp;
  1153. i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_CFG(which), temp);
  1154. mutex_unlock(&data->lock);
  1155. }
  1156. static ssize_t pwm_auto_store(struct device *dev,
  1157. struct device_attribute *devattr,
  1158. const char *buf, size_t count)
  1159. {
  1160. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1161. struct adt7462_data *data = dev_get_drvdata(dev);
  1162. struct i2c_client *client = data->client;
  1163. long temp;
  1164. if (kstrtol(buf, 10, &temp))
  1165. return -EINVAL;
  1166. switch (temp) {
  1167. case 0: /* off */
  1168. set_pwm_channel(client, data, attr->index, 4);
  1169. return count;
  1170. case 1: /* manual */
  1171. set_pwm_channel(client, data, attr->index, 7);
  1172. return count;
  1173. default:
  1174. return -EINVAL;
  1175. }
  1176. }
  1177. static ssize_t pwm_auto_temp_show(struct device *dev,
  1178. struct device_attribute *devattr, char *buf)
  1179. {
  1180. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1181. struct adt7462_data *data = adt7462_update_device(dev);
  1182. int channel = data->pwm_cfg[attr->index] >> ADT7462_PWM_CHANNEL_SHIFT;
  1183. switch (channel) {
  1184. case 0: /* temp[1234] only */
  1185. case 1:
  1186. case 2:
  1187. case 3:
  1188. return sprintf(buf, "%d\n", (1 << channel));
  1189. case 5: /* temp1 & temp4 */
  1190. return sprintf(buf, "9\n");
  1191. case 6:
  1192. return sprintf(buf, "15\n");
  1193. default:
  1194. return sprintf(buf, "0\n");
  1195. }
  1196. }
  1197. static int cvt_auto_temp(int input)
  1198. {
  1199. if (input == 0xF)
  1200. return 6;
  1201. if (input == 0x9)
  1202. return 5;
  1203. if (input < 1 || !is_power_of_2(input))
  1204. return -EINVAL;
  1205. return ilog2(input);
  1206. }
  1207. static ssize_t pwm_auto_temp_store(struct device *dev,
  1208. struct device_attribute *devattr,
  1209. const char *buf, size_t count)
  1210. {
  1211. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1212. struct adt7462_data *data = dev_get_drvdata(dev);
  1213. struct i2c_client *client = data->client;
  1214. long temp;
  1215. if (kstrtol(buf, 10, &temp))
  1216. return -EINVAL;
  1217. temp = cvt_auto_temp(temp);
  1218. if (temp < 0)
  1219. return temp;
  1220. set_pwm_channel(client, data, attr->index, temp);
  1221. return count;
  1222. }
  1223. static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0);
  1224. static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);
  1225. static SENSOR_DEVICE_ATTR_RW(temp3_max, temp_max, 2);
  1226. static SENSOR_DEVICE_ATTR_RW(temp4_max, temp_max, 3);
  1227. static SENSOR_DEVICE_ATTR_RW(temp1_min, temp_min, 0);
  1228. static SENSOR_DEVICE_ATTR_RW(temp2_min, temp_min, 1);
  1229. static SENSOR_DEVICE_ATTR_RW(temp3_min, temp_min, 2);
  1230. static SENSOR_DEVICE_ATTR_RW(temp4_min, temp_min, 3);
  1231. static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0);
  1232. static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1);
  1233. static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2);
  1234. static SENSOR_DEVICE_ATTR_RO(temp4_input, temp, 3);
  1235. static SENSOR_DEVICE_ATTR_RO(temp1_label, temp_label, 0);
  1236. static SENSOR_DEVICE_ATTR_RO(temp2_label, temp_label, 1);
  1237. static SENSOR_DEVICE_ATTR_RO(temp3_label, temp_label, 2);
  1238. static SENSOR_DEVICE_ATTR_RO(temp4_label, temp_label, 3);
  1239. static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm,
  1240. ADT7462_ALARM1 | ADT7462_LT_ALARM);
  1241. static SENSOR_DEVICE_ATTR_RO(temp2_alarm, alarm,
  1242. ADT7462_ALARM1 | ADT7462_R1T_ALARM);
  1243. static SENSOR_DEVICE_ATTR_RO(temp3_alarm, alarm,
  1244. ADT7462_ALARM1 | ADT7462_R2T_ALARM);
  1245. static SENSOR_DEVICE_ATTR_RO(temp4_alarm, alarm,
  1246. ADT7462_ALARM1 | ADT7462_R3T_ALARM);
  1247. static SENSOR_DEVICE_ATTR_RW(in1_max, volt_max, 0);
  1248. static SENSOR_DEVICE_ATTR_RW(in2_max, volt_max, 1);
  1249. static SENSOR_DEVICE_ATTR_RW(in3_max, volt_max, 2);
  1250. static SENSOR_DEVICE_ATTR_RW(in4_max, volt_max, 3);
  1251. static SENSOR_DEVICE_ATTR_RW(in5_max, volt_max, 4);
  1252. static SENSOR_DEVICE_ATTR_RW(in6_max, volt_max, 5);
  1253. static SENSOR_DEVICE_ATTR_RW(in7_max, volt_max, 6);
  1254. static SENSOR_DEVICE_ATTR_RW(in8_max, volt_max, 7);
  1255. static SENSOR_DEVICE_ATTR_RW(in9_max, volt_max, 8);
  1256. static SENSOR_DEVICE_ATTR_RW(in10_max, volt_max, 9);
  1257. static SENSOR_DEVICE_ATTR_RW(in11_max, volt_max, 10);
  1258. static SENSOR_DEVICE_ATTR_RW(in12_max, volt_max, 11);
  1259. static SENSOR_DEVICE_ATTR_RW(in13_max, volt_max, 12);
  1260. static SENSOR_DEVICE_ATTR_RW(in1_min, volt_min, 0);
  1261. static SENSOR_DEVICE_ATTR_RW(in2_min, volt_min, 1);
  1262. static SENSOR_DEVICE_ATTR_RW(in3_min, volt_min, 2);
  1263. static SENSOR_DEVICE_ATTR_RW(in4_min, volt_min, 3);
  1264. static SENSOR_DEVICE_ATTR_RW(in5_min, volt_min, 4);
  1265. static SENSOR_DEVICE_ATTR_RW(in6_min, volt_min, 5);
  1266. static SENSOR_DEVICE_ATTR_RW(in7_min, volt_min, 6);
  1267. static SENSOR_DEVICE_ATTR_RW(in8_min, volt_min, 7);
  1268. static SENSOR_DEVICE_ATTR_RW(in9_min, volt_min, 8);
  1269. static SENSOR_DEVICE_ATTR_RW(in10_min, volt_min, 9);
  1270. static SENSOR_DEVICE_ATTR_RW(in11_min, volt_min, 10);
  1271. static SENSOR_DEVICE_ATTR_RW(in12_min, volt_min, 11);
  1272. static SENSOR_DEVICE_ATTR_RW(in13_min, volt_min, 12);
  1273. static SENSOR_DEVICE_ATTR_RO(in1_input, voltage, 0);
  1274. static SENSOR_DEVICE_ATTR_RO(in2_input, voltage, 1);
  1275. static SENSOR_DEVICE_ATTR_RO(in3_input, voltage, 2);
  1276. static SENSOR_DEVICE_ATTR_RO(in4_input, voltage, 3);
  1277. static SENSOR_DEVICE_ATTR_RO(in5_input, voltage, 4);
  1278. static SENSOR_DEVICE_ATTR_RO(in6_input, voltage, 5);
  1279. static SENSOR_DEVICE_ATTR_RO(in7_input, voltage, 6);
  1280. static SENSOR_DEVICE_ATTR_RO(in8_input, voltage, 7);
  1281. static SENSOR_DEVICE_ATTR_RO(in9_input, voltage, 8);
  1282. static SENSOR_DEVICE_ATTR_RO(in10_input, voltage, 9);
  1283. static SENSOR_DEVICE_ATTR_RO(in11_input, voltage, 10);
  1284. static SENSOR_DEVICE_ATTR_RO(in12_input, voltage, 11);
  1285. static SENSOR_DEVICE_ATTR_RO(in13_input, voltage, 12);
  1286. static SENSOR_DEVICE_ATTR_RO(in1_label, voltage_label, 0);
  1287. static SENSOR_DEVICE_ATTR_RO(in2_label, voltage_label, 1);
  1288. static SENSOR_DEVICE_ATTR_RO(in3_label, voltage_label, 2);
  1289. static SENSOR_DEVICE_ATTR_RO(in4_label, voltage_label, 3);
  1290. static SENSOR_DEVICE_ATTR_RO(in5_label, voltage_label, 4);
  1291. static SENSOR_DEVICE_ATTR_RO(in6_label, voltage_label, 5);
  1292. static SENSOR_DEVICE_ATTR_RO(in7_label, voltage_label, 6);
  1293. static SENSOR_DEVICE_ATTR_RO(in8_label, voltage_label, 7);
  1294. static SENSOR_DEVICE_ATTR_RO(in9_label, voltage_label, 8);
  1295. static SENSOR_DEVICE_ATTR_RO(in10_label, voltage_label, 9);
  1296. static SENSOR_DEVICE_ATTR_RO(in11_label, voltage_label, 10);
  1297. static SENSOR_DEVICE_ATTR_RO(in12_label, voltage_label, 11);
  1298. static SENSOR_DEVICE_ATTR_RO(in13_label, voltage_label, 12);
  1299. static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm,
  1300. ADT7462_ALARM2 | ADT7462_V0_ALARM);
  1301. static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm,
  1302. ADT7462_ALARM2 | ADT7462_V7_ALARM);
  1303. static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm,
  1304. ADT7462_ALARM2 | ADT7462_V2_ALARM);
  1305. static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm,
  1306. ADT7462_ALARM2 | ADT7462_V6_ALARM);
  1307. static SENSOR_DEVICE_ATTR_RO(in5_alarm, alarm,
  1308. ADT7462_ALARM2 | ADT7462_V5_ALARM);
  1309. static SENSOR_DEVICE_ATTR_RO(in6_alarm, alarm,
  1310. ADT7462_ALARM2 | ADT7462_V4_ALARM);
  1311. static SENSOR_DEVICE_ATTR_RO(in7_alarm, alarm,
  1312. ADT7462_ALARM2 | ADT7462_V3_ALARM);
  1313. static SENSOR_DEVICE_ATTR_RO(in8_alarm, alarm,
  1314. ADT7462_ALARM2 | ADT7462_V1_ALARM);
  1315. static SENSOR_DEVICE_ATTR_RO(in9_alarm, alarm,
  1316. ADT7462_ALARM3 | ADT7462_V10_ALARM);
  1317. static SENSOR_DEVICE_ATTR_RO(in10_alarm, alarm,
  1318. ADT7462_ALARM3 | ADT7462_V9_ALARM);
  1319. static SENSOR_DEVICE_ATTR_RO(in11_alarm, alarm,
  1320. ADT7462_ALARM3 | ADT7462_V8_ALARM);
  1321. static SENSOR_DEVICE_ATTR_RO(in12_alarm, alarm,
  1322. ADT7462_ALARM3 | ADT7462_V11_ALARM);
  1323. static SENSOR_DEVICE_ATTR_RO(in13_alarm, alarm,
  1324. ADT7462_ALARM3 | ADT7462_V12_ALARM);
  1325. static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);
  1326. static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
  1327. static SENSOR_DEVICE_ATTR_RW(fan3_min, fan_min, 2);
  1328. static SENSOR_DEVICE_ATTR_RW(fan4_min, fan_min, 3);
  1329. static SENSOR_DEVICE_ATTR_RW(fan5_min, fan_min, 4);
  1330. static SENSOR_DEVICE_ATTR_RW(fan6_min, fan_min, 5);
  1331. static SENSOR_DEVICE_ATTR_RW(fan7_min, fan_min, 6);
  1332. static SENSOR_DEVICE_ATTR_RW(fan8_min, fan_min, 7);
  1333. static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0);
  1334. static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1);
  1335. static SENSOR_DEVICE_ATTR_RO(fan3_input, fan, 2);
  1336. static SENSOR_DEVICE_ATTR_RO(fan4_input, fan, 3);
  1337. static SENSOR_DEVICE_ATTR_RO(fan5_input, fan, 4);
  1338. static SENSOR_DEVICE_ATTR_RO(fan6_input, fan, 5);
  1339. static SENSOR_DEVICE_ATTR_RO(fan7_input, fan, 6);
  1340. static SENSOR_DEVICE_ATTR_RO(fan8_input, fan, 7);
  1341. static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm,
  1342. ADT7462_ALARM4 | ADT7462_F0_ALARM);
  1343. static SENSOR_DEVICE_ATTR_RO(fan2_alarm, alarm,
  1344. ADT7462_ALARM4 | ADT7462_F1_ALARM);
  1345. static SENSOR_DEVICE_ATTR_RO(fan3_alarm, alarm,
  1346. ADT7462_ALARM4 | ADT7462_F2_ALARM);
  1347. static SENSOR_DEVICE_ATTR_RO(fan4_alarm, alarm,
  1348. ADT7462_ALARM4 | ADT7462_F3_ALARM);
  1349. static SENSOR_DEVICE_ATTR_RO(fan5_alarm, alarm,
  1350. ADT7462_ALARM4 | ADT7462_F4_ALARM);
  1351. static SENSOR_DEVICE_ATTR_RO(fan6_alarm, alarm,
  1352. ADT7462_ALARM4 | ADT7462_F5_ALARM);
  1353. static SENSOR_DEVICE_ATTR_RO(fan7_alarm, alarm,
  1354. ADT7462_ALARM4 | ADT7462_F6_ALARM);
  1355. static SENSOR_DEVICE_ATTR_RO(fan8_alarm, alarm,
  1356. ADT7462_ALARM4 | ADT7462_F7_ALARM);
  1357. static SENSOR_DEVICE_ATTR_RW(force_pwm_max, force_pwm_max, 0);
  1358. static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);
  1359. static SENSOR_DEVICE_ATTR_RW(pwm2, pwm, 1);
  1360. static SENSOR_DEVICE_ATTR_RW(pwm3, pwm, 2);
  1361. static SENSOR_DEVICE_ATTR_RW(pwm4, pwm, 3);
  1362. static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point1_pwm, pwm_min, 0);
  1363. static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point1_pwm, pwm_min, 1);
  1364. static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point1_pwm, pwm_min, 2);
  1365. static SENSOR_DEVICE_ATTR_RW(pwm4_auto_point1_pwm, pwm_min, 3);
  1366. static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point2_pwm, pwm_max, 0);
  1367. static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point2_pwm, pwm_max, 1);
  1368. static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point2_pwm, pwm_max, 2);
  1369. static SENSOR_DEVICE_ATTR_RW(pwm4_auto_point2_pwm, pwm_max, 3);
  1370. static SENSOR_DEVICE_ATTR_RW(temp1_auto_point1_hyst, pwm_hyst, 0);
  1371. static SENSOR_DEVICE_ATTR_RW(temp2_auto_point1_hyst, pwm_hyst, 1);
  1372. static SENSOR_DEVICE_ATTR_RW(temp3_auto_point1_hyst, pwm_hyst, 2);
  1373. static SENSOR_DEVICE_ATTR_RW(temp4_auto_point1_hyst, pwm_hyst, 3);
  1374. static SENSOR_DEVICE_ATTR_RW(temp1_auto_point2_hyst, pwm_hyst, 0);
  1375. static SENSOR_DEVICE_ATTR_RW(temp2_auto_point2_hyst, pwm_hyst, 1);
  1376. static SENSOR_DEVICE_ATTR_RW(temp3_auto_point2_hyst, pwm_hyst, 2);
  1377. static SENSOR_DEVICE_ATTR_RW(temp4_auto_point2_hyst, pwm_hyst, 3);
  1378. static SENSOR_DEVICE_ATTR_RW(temp1_auto_point1_temp, pwm_tmin, 0);
  1379. static SENSOR_DEVICE_ATTR_RW(temp2_auto_point1_temp, pwm_tmin, 1);
  1380. static SENSOR_DEVICE_ATTR_RW(temp3_auto_point1_temp, pwm_tmin, 2);
  1381. static SENSOR_DEVICE_ATTR_RW(temp4_auto_point1_temp, pwm_tmin, 3);
  1382. static SENSOR_DEVICE_ATTR_RW(temp1_auto_point2_temp, pwm_tmax, 0);
  1383. static SENSOR_DEVICE_ATTR_RW(temp2_auto_point2_temp, pwm_tmax, 1);
  1384. static SENSOR_DEVICE_ATTR_RW(temp3_auto_point2_temp, pwm_tmax, 2);
  1385. static SENSOR_DEVICE_ATTR_RW(temp4_auto_point2_temp, pwm_tmax, 3);
  1386. static SENSOR_DEVICE_ATTR_RW(pwm1_enable, pwm_auto, 0);
  1387. static SENSOR_DEVICE_ATTR_RW(pwm2_enable, pwm_auto, 1);
  1388. static SENSOR_DEVICE_ATTR_RW(pwm3_enable, pwm_auto, 2);
  1389. static SENSOR_DEVICE_ATTR_RW(pwm4_enable, pwm_auto, 3);
  1390. static SENSOR_DEVICE_ATTR_RW(pwm1_auto_channels_temp, pwm_auto_temp, 0);
  1391. static SENSOR_DEVICE_ATTR_RW(pwm2_auto_channels_temp, pwm_auto_temp, 1);
  1392. static SENSOR_DEVICE_ATTR_RW(pwm3_auto_channels_temp, pwm_auto_temp, 2);
  1393. static SENSOR_DEVICE_ATTR_RW(pwm4_auto_channels_temp, pwm_auto_temp, 3);
  1394. static struct attribute *adt7462_attrs[] = {
  1395. &sensor_dev_attr_temp1_max.dev_attr.attr,
  1396. &sensor_dev_attr_temp2_max.dev_attr.attr,
  1397. &sensor_dev_attr_temp3_max.dev_attr.attr,
  1398. &sensor_dev_attr_temp4_max.dev_attr.attr,
  1399. &sensor_dev_attr_temp1_min.dev_attr.attr,
  1400. &sensor_dev_attr_temp2_min.dev_attr.attr,
  1401. &sensor_dev_attr_temp3_min.dev_attr.attr,
  1402. &sensor_dev_attr_temp4_min.dev_attr.attr,
  1403. &sensor_dev_attr_temp1_input.dev_attr.attr,
  1404. &sensor_dev_attr_temp2_input.dev_attr.attr,
  1405. &sensor_dev_attr_temp3_input.dev_attr.attr,
  1406. &sensor_dev_attr_temp4_input.dev_attr.attr,
  1407. &sensor_dev_attr_temp1_label.dev_attr.attr,
  1408. &sensor_dev_attr_temp2_label.dev_attr.attr,
  1409. &sensor_dev_attr_temp3_label.dev_attr.attr,
  1410. &sensor_dev_attr_temp4_label.dev_attr.attr,
  1411. &sensor_dev_attr_temp1_alarm.dev_attr.attr,
  1412. &sensor_dev_attr_temp2_alarm.dev_attr.attr,
  1413. &sensor_dev_attr_temp3_alarm.dev_attr.attr,
  1414. &sensor_dev_attr_temp4_alarm.dev_attr.attr,
  1415. &sensor_dev_attr_in1_max.dev_attr.attr,
  1416. &sensor_dev_attr_in2_max.dev_attr.attr,
  1417. &sensor_dev_attr_in3_max.dev_attr.attr,
  1418. &sensor_dev_attr_in4_max.dev_attr.attr,
  1419. &sensor_dev_attr_in5_max.dev_attr.attr,
  1420. &sensor_dev_attr_in6_max.dev_attr.attr,
  1421. &sensor_dev_attr_in7_max.dev_attr.attr,
  1422. &sensor_dev_attr_in8_max.dev_attr.attr,
  1423. &sensor_dev_attr_in9_max.dev_attr.attr,
  1424. &sensor_dev_attr_in10_max.dev_attr.attr,
  1425. &sensor_dev_attr_in11_max.dev_attr.attr,
  1426. &sensor_dev_attr_in12_max.dev_attr.attr,
  1427. &sensor_dev_attr_in13_max.dev_attr.attr,
  1428. &sensor_dev_attr_in1_min.dev_attr.attr,
  1429. &sensor_dev_attr_in2_min.dev_attr.attr,
  1430. &sensor_dev_attr_in3_min.dev_attr.attr,
  1431. &sensor_dev_attr_in4_min.dev_attr.attr,
  1432. &sensor_dev_attr_in5_min.dev_attr.attr,
  1433. &sensor_dev_attr_in6_min.dev_attr.attr,
  1434. &sensor_dev_attr_in7_min.dev_attr.attr,
  1435. &sensor_dev_attr_in8_min.dev_attr.attr,
  1436. &sensor_dev_attr_in9_min.dev_attr.attr,
  1437. &sensor_dev_attr_in10_min.dev_attr.attr,
  1438. &sensor_dev_attr_in11_min.dev_attr.attr,
  1439. &sensor_dev_attr_in12_min.dev_attr.attr,
  1440. &sensor_dev_attr_in13_min.dev_attr.attr,
  1441. &sensor_dev_attr_in1_input.dev_attr.attr,
  1442. &sensor_dev_attr_in2_input.dev_attr.attr,
  1443. &sensor_dev_attr_in3_input.dev_attr.attr,
  1444. &sensor_dev_attr_in4_input.dev_attr.attr,
  1445. &sensor_dev_attr_in5_input.dev_attr.attr,
  1446. &sensor_dev_attr_in6_input.dev_attr.attr,
  1447. &sensor_dev_attr_in7_input.dev_attr.attr,
  1448. &sensor_dev_attr_in8_input.dev_attr.attr,
  1449. &sensor_dev_attr_in9_input.dev_attr.attr,
  1450. &sensor_dev_attr_in10_input.dev_attr.attr,
  1451. &sensor_dev_attr_in11_input.dev_attr.attr,
  1452. &sensor_dev_attr_in12_input.dev_attr.attr,
  1453. &sensor_dev_attr_in13_input.dev_attr.attr,
  1454. &sensor_dev_attr_in1_label.dev_attr.attr,
  1455. &sensor_dev_attr_in2_label.dev_attr.attr,
  1456. &sensor_dev_attr_in3_label.dev_attr.attr,
  1457. &sensor_dev_attr_in4_label.dev_attr.attr,
  1458. &sensor_dev_attr_in5_label.dev_attr.attr,
  1459. &sensor_dev_attr_in6_label.dev_attr.attr,
  1460. &sensor_dev_attr_in7_label.dev_attr.attr,
  1461. &sensor_dev_attr_in8_label.dev_attr.attr,
  1462. &sensor_dev_attr_in9_label.dev_attr.attr,
  1463. &sensor_dev_attr_in10_label.dev_attr.attr,
  1464. &sensor_dev_attr_in11_label.dev_attr.attr,
  1465. &sensor_dev_attr_in12_label.dev_attr.attr,
  1466. &sensor_dev_attr_in13_label.dev_attr.attr,
  1467. &sensor_dev_attr_in1_alarm.dev_attr.attr,
  1468. &sensor_dev_attr_in2_alarm.dev_attr.attr,
  1469. &sensor_dev_attr_in3_alarm.dev_attr.attr,
  1470. &sensor_dev_attr_in4_alarm.dev_attr.attr,
  1471. &sensor_dev_attr_in5_alarm.dev_attr.attr,
  1472. &sensor_dev_attr_in6_alarm.dev_attr.attr,
  1473. &sensor_dev_attr_in7_alarm.dev_attr.attr,
  1474. &sensor_dev_attr_in8_alarm.dev_attr.attr,
  1475. &sensor_dev_attr_in9_alarm.dev_attr.attr,
  1476. &sensor_dev_attr_in10_alarm.dev_attr.attr,
  1477. &sensor_dev_attr_in11_alarm.dev_attr.attr,
  1478. &sensor_dev_attr_in12_alarm.dev_attr.attr,
  1479. &sensor_dev_attr_in13_alarm.dev_attr.attr,
  1480. &sensor_dev_attr_fan1_min.dev_attr.attr,
  1481. &sensor_dev_attr_fan2_min.dev_attr.attr,
  1482. &sensor_dev_attr_fan3_min.dev_attr.attr,
  1483. &sensor_dev_attr_fan4_min.dev_attr.attr,
  1484. &sensor_dev_attr_fan5_min.dev_attr.attr,
  1485. &sensor_dev_attr_fan6_min.dev_attr.attr,
  1486. &sensor_dev_attr_fan7_min.dev_attr.attr,
  1487. &sensor_dev_attr_fan8_min.dev_attr.attr,
  1488. &sensor_dev_attr_fan1_input.dev_attr.attr,
  1489. &sensor_dev_attr_fan2_input.dev_attr.attr,
  1490. &sensor_dev_attr_fan3_input.dev_attr.attr,
  1491. &sensor_dev_attr_fan4_input.dev_attr.attr,
  1492. &sensor_dev_attr_fan5_input.dev_attr.attr,
  1493. &sensor_dev_attr_fan6_input.dev_attr.attr,
  1494. &sensor_dev_attr_fan7_input.dev_attr.attr,
  1495. &sensor_dev_attr_fan8_input.dev_attr.attr,
  1496. &sensor_dev_attr_fan1_alarm.dev_attr.attr,
  1497. &sensor_dev_attr_fan2_alarm.dev_attr.attr,
  1498. &sensor_dev_attr_fan3_alarm.dev_attr.attr,
  1499. &sensor_dev_attr_fan4_alarm.dev_attr.attr,
  1500. &sensor_dev_attr_fan5_alarm.dev_attr.attr,
  1501. &sensor_dev_attr_fan6_alarm.dev_attr.attr,
  1502. &sensor_dev_attr_fan7_alarm.dev_attr.attr,
  1503. &sensor_dev_attr_fan8_alarm.dev_attr.attr,
  1504. &sensor_dev_attr_force_pwm_max.dev_attr.attr,
  1505. &sensor_dev_attr_pwm1.dev_attr.attr,
  1506. &sensor_dev_attr_pwm2.dev_attr.attr,
  1507. &sensor_dev_attr_pwm3.dev_attr.attr,
  1508. &sensor_dev_attr_pwm4.dev_attr.attr,
  1509. &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
  1510. &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
  1511. &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
  1512. &sensor_dev_attr_pwm4_auto_point1_pwm.dev_attr.attr,
  1513. &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
  1514. &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
  1515. &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
  1516. &sensor_dev_attr_pwm4_auto_point2_pwm.dev_attr.attr,
  1517. &sensor_dev_attr_temp1_auto_point1_hyst.dev_attr.attr,
  1518. &sensor_dev_attr_temp2_auto_point1_hyst.dev_attr.attr,
  1519. &sensor_dev_attr_temp3_auto_point1_hyst.dev_attr.attr,
  1520. &sensor_dev_attr_temp4_auto_point1_hyst.dev_attr.attr,
  1521. &sensor_dev_attr_temp1_auto_point2_hyst.dev_attr.attr,
  1522. &sensor_dev_attr_temp2_auto_point2_hyst.dev_attr.attr,
  1523. &sensor_dev_attr_temp3_auto_point2_hyst.dev_attr.attr,
  1524. &sensor_dev_attr_temp4_auto_point2_hyst.dev_attr.attr,
  1525. &sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr,
  1526. &sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr,
  1527. &sensor_dev_attr_temp3_auto_point1_temp.dev_attr.attr,
  1528. &sensor_dev_attr_temp4_auto_point1_temp.dev_attr.attr,
  1529. &sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr,
  1530. &sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr,
  1531. &sensor_dev_attr_temp3_auto_point2_temp.dev_attr.attr,
  1532. &sensor_dev_attr_temp4_auto_point2_temp.dev_attr.attr,
  1533. &sensor_dev_attr_pwm1_enable.dev_attr.attr,
  1534. &sensor_dev_attr_pwm2_enable.dev_attr.attr,
  1535. &sensor_dev_attr_pwm3_enable.dev_attr.attr,
  1536. &sensor_dev_attr_pwm4_enable.dev_attr.attr,
  1537. &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,
  1538. &sensor_dev_attr_pwm2_auto_channels_temp.dev_attr.attr,
  1539. &sensor_dev_attr_pwm3_auto_channels_temp.dev_attr.attr,
  1540. &sensor_dev_attr_pwm4_auto_channels_temp.dev_attr.attr,
  1541. NULL
  1542. };
  1543. ATTRIBUTE_GROUPS(adt7462);
  1544. /* Return 0 if detection is successful, -ENODEV otherwise */
  1545. static int adt7462_detect(struct i2c_client *client,
  1546. struct i2c_board_info *info)
  1547. {
  1548. struct i2c_adapter *adapter = client->adapter;
  1549. int vendor, device, revision;
  1550. if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
  1551. return -ENODEV;
  1552. vendor = i2c_smbus_read_byte_data(client, ADT7462_REG_VENDOR);
  1553. if (vendor != ADT7462_VENDOR)
  1554. return -ENODEV;
  1555. device = i2c_smbus_read_byte_data(client, ADT7462_REG_DEVICE);
  1556. if (device != ADT7462_DEVICE)
  1557. return -ENODEV;
  1558. revision = i2c_smbus_read_byte_data(client, ADT7462_REG_REVISION);
  1559. if (revision != ADT7462_REVISION)
  1560. return -ENODEV;
  1561. strlcpy(info->type, "adt7462", I2C_NAME_SIZE);
  1562. return 0;
  1563. }
  1564. static int adt7462_probe(struct i2c_client *client)
  1565. {
  1566. struct device *dev = &client->dev;
  1567. struct adt7462_data *data;
  1568. struct device *hwmon_dev;
  1569. data = devm_kzalloc(dev, sizeof(struct adt7462_data), GFP_KERNEL);
  1570. if (!data)
  1571. return -ENOMEM;
  1572. data->client = client;
  1573. mutex_init(&data->lock);
  1574. dev_info(&client->dev, "%s chip found\n", client->name);
  1575. hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
  1576. data,
  1577. adt7462_groups);
  1578. return PTR_ERR_OR_ZERO(hwmon_dev);
  1579. }
  1580. static const struct i2c_device_id adt7462_id[] = {
  1581. { "adt7462", 0 },
  1582. { }
  1583. };
  1584. MODULE_DEVICE_TABLE(i2c, adt7462_id);
  1585. static struct i2c_driver adt7462_driver = {
  1586. .class = I2C_CLASS_HWMON,
  1587. .driver = {
  1588. .name = "adt7462",
  1589. },
  1590. .probe_new = adt7462_probe,
  1591. .id_table = adt7462_id,
  1592. .detect = adt7462_detect,
  1593. .address_list = normal_i2c,
  1594. };
  1595. module_i2c_driver(adt7462_driver);
  1596. MODULE_AUTHOR("Darrick J. Wong <darrick.wong@oracle.com>");
  1597. MODULE_DESCRIPTION("ADT7462 driver");
  1598. MODULE_LICENSE("GPL");