w83792d.c 55 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669
  1. /*
  2. w83792d.c - Part of lm_sensors, Linux kernel modules for hardware
  3. monitoring
  4. Copyright (C) 2004, 2005 Winbond Electronics Corp.
  5. Chunhao Huang <DZShen@Winbond.com.tw>,
  6. Rudolf Marek <r.marek@assembler.cz>
  7. This program is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2 of the License, or
  10. (at your option) any later version.
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14. GNU General Public License for more details.
  15. You should have received a copy of the GNU General Public License
  16. along with this program; if not, write to the Free Software
  17. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18. Note:
  19. 1. This driver is only for 2.6 kernel, 2.4 kernel need a different driver.
  20. 2. This driver is only for Winbond W83792D C version device, there
  21. are also some motherboards with B version W83792D device. The
  22. calculation method to in6-in7(measured value, limits) is a little
  23. different between C and B version. C or B version can be identified
  24. by CR[0x49h].
  25. */
  26. /*
  27. Supports following chips:
  28. Chip #vin #fanin #pwm #temp wchipid vendid i2c ISA
  29. w83792d 9 7 7 3 0x7a 0x5ca3 yes no
  30. */
  31. #include <linux/module.h>
  32. #include <linux/init.h>
  33. #include <linux/slab.h>
  34. #include <linux/i2c.h>
  35. #include <linux/hwmon.h>
  36. #include <linux/hwmon-sysfs.h>
  37. #include <linux/err.h>
  38. #include <linux/mutex.h>
  39. #include <linux/sysfs.h>
  40. /* Addresses to scan */
  41. static unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f, I2C_CLIENT_END };
  42. /* Insmod parameters */
  43. I2C_CLIENT_INSMOD_1(w83792d);
  44. I2C_CLIENT_MODULE_PARM(force_subclients, "List of subclient addresses: "
  45. "{bus, clientaddr, subclientaddr1, subclientaddr2}");
  46. static int init;
  47. module_param(init, bool, 0);
  48. MODULE_PARM_DESC(init, "Set to one to force chip initialization");
  49. /* The W83792D registers */
  50. static const u8 W83792D_REG_IN[9] = {
  51. 0x20, /* Vcore A in DataSheet */
  52. 0x21, /* Vcore B in DataSheet */
  53. 0x22, /* VIN0 in DataSheet */
  54. 0x23, /* VIN1 in DataSheet */
  55. 0x24, /* VIN2 in DataSheet */
  56. 0x25, /* VIN3 in DataSheet */
  57. 0x26, /* 5VCC in DataSheet */
  58. 0xB0, /* 5VSB in DataSheet */
  59. 0xB1 /* VBAT in DataSheet */
  60. };
  61. #define W83792D_REG_LOW_BITS1 0x3E /* Low Bits I in DataSheet */
  62. #define W83792D_REG_LOW_BITS2 0x3F /* Low Bits II in DataSheet */
  63. static const u8 W83792D_REG_IN_MAX[9] = {
  64. 0x2B, /* Vcore A High Limit in DataSheet */
  65. 0x2D, /* Vcore B High Limit in DataSheet */
  66. 0x2F, /* VIN0 High Limit in DataSheet */
  67. 0x31, /* VIN1 High Limit in DataSheet */
  68. 0x33, /* VIN2 High Limit in DataSheet */
  69. 0x35, /* VIN3 High Limit in DataSheet */
  70. 0x37, /* 5VCC High Limit in DataSheet */
  71. 0xB4, /* 5VSB High Limit in DataSheet */
  72. 0xB6 /* VBAT High Limit in DataSheet */
  73. };
  74. static const u8 W83792D_REG_IN_MIN[9] = {
  75. 0x2C, /* Vcore A Low Limit in DataSheet */
  76. 0x2E, /* Vcore B Low Limit in DataSheet */
  77. 0x30, /* VIN0 Low Limit in DataSheet */
  78. 0x32, /* VIN1 Low Limit in DataSheet */
  79. 0x34, /* VIN2 Low Limit in DataSheet */
  80. 0x36, /* VIN3 Low Limit in DataSheet */
  81. 0x38, /* 5VCC Low Limit in DataSheet */
  82. 0xB5, /* 5VSB Low Limit in DataSheet */
  83. 0xB7 /* VBAT Low Limit in DataSheet */
  84. };
  85. static const u8 W83792D_REG_FAN[7] = {
  86. 0x28, /* FAN 1 Count in DataSheet */
  87. 0x29, /* FAN 2 Count in DataSheet */
  88. 0x2A, /* FAN 3 Count in DataSheet */
  89. 0xB8, /* FAN 4 Count in DataSheet */
  90. 0xB9, /* FAN 5 Count in DataSheet */
  91. 0xBA, /* FAN 6 Count in DataSheet */
  92. 0xBE /* FAN 7 Count in DataSheet */
  93. };
  94. static const u8 W83792D_REG_FAN_MIN[7] = {
  95. 0x3B, /* FAN 1 Count Low Limit in DataSheet */
  96. 0x3C, /* FAN 2 Count Low Limit in DataSheet */
  97. 0x3D, /* FAN 3 Count Low Limit in DataSheet */
  98. 0xBB, /* FAN 4 Count Low Limit in DataSheet */
  99. 0xBC, /* FAN 5 Count Low Limit in DataSheet */
  100. 0xBD, /* FAN 6 Count Low Limit in DataSheet */
  101. 0xBF /* FAN 7 Count Low Limit in DataSheet */
  102. };
  103. #define W83792D_REG_FAN_CFG 0x84 /* FAN Configuration in DataSheet */
  104. static const u8 W83792D_REG_FAN_DIV[4] = {
  105. 0x47, /* contains FAN2 and FAN1 Divisor */
  106. 0x5B, /* contains FAN4 and FAN3 Divisor */
  107. 0x5C, /* contains FAN6 and FAN5 Divisor */
  108. 0x9E /* contains FAN7 Divisor. */
  109. };
  110. static const u8 W83792D_REG_PWM[7] = {
  111. 0x81, /* FAN 1 Duty Cycle, be used to control */
  112. 0x83, /* FAN 2 Duty Cycle, be used to control */
  113. 0x94, /* FAN 3 Duty Cycle, be used to control */
  114. 0xA3, /* FAN 4 Duty Cycle, be used to control */
  115. 0xA4, /* FAN 5 Duty Cycle, be used to control */
  116. 0xA5, /* FAN 6 Duty Cycle, be used to control */
  117. 0xA6 /* FAN 7 Duty Cycle, be used to control */
  118. };
  119. #define W83792D_REG_BANK 0x4E
  120. #define W83792D_REG_TEMP2_CONFIG 0xC2
  121. #define W83792D_REG_TEMP3_CONFIG 0xCA
  122. static const u8 W83792D_REG_TEMP1[3] = {
  123. 0x27, /* TEMP 1 in DataSheet */
  124. 0x39, /* TEMP 1 Over in DataSheet */
  125. 0x3A, /* TEMP 1 Hyst in DataSheet */
  126. };
  127. static const u8 W83792D_REG_TEMP_ADD[2][6] = {
  128. { 0xC0, /* TEMP 2 in DataSheet */
  129. 0xC1, /* TEMP 2(0.5 deg) in DataSheet */
  130. 0xC5, /* TEMP 2 Over High part in DataSheet */
  131. 0xC6, /* TEMP 2 Over Low part in DataSheet */
  132. 0xC3, /* TEMP 2 Thyst High part in DataSheet */
  133. 0xC4 }, /* TEMP 2 Thyst Low part in DataSheet */
  134. { 0xC8, /* TEMP 3 in DataSheet */
  135. 0xC9, /* TEMP 3(0.5 deg) in DataSheet */
  136. 0xCD, /* TEMP 3 Over High part in DataSheet */
  137. 0xCE, /* TEMP 3 Over Low part in DataSheet */
  138. 0xCB, /* TEMP 3 Thyst High part in DataSheet */
  139. 0xCC } /* TEMP 3 Thyst Low part in DataSheet */
  140. };
  141. static const u8 W83792D_REG_THERMAL[3] = {
  142. 0x85, /* SmartFanI: Fan1 target value */
  143. 0x86, /* SmartFanI: Fan2 target value */
  144. 0x96 /* SmartFanI: Fan3 target value */
  145. };
  146. static const u8 W83792D_REG_TOLERANCE[3] = {
  147. 0x87, /* (bit3-0)SmartFan Fan1 tolerance */
  148. 0x87, /* (bit7-4)SmartFan Fan2 tolerance */
  149. 0x97 /* (bit3-0)SmartFan Fan3 tolerance */
  150. };
  151. static const u8 W83792D_REG_POINTS[3][4] = {
  152. { 0x85, /* SmartFanII: Fan1 temp point 1 */
  153. 0xE3, /* SmartFanII: Fan1 temp point 2 */
  154. 0xE4, /* SmartFanII: Fan1 temp point 3 */
  155. 0xE5 }, /* SmartFanII: Fan1 temp point 4 */
  156. { 0x86, /* SmartFanII: Fan2 temp point 1 */
  157. 0xE6, /* SmartFanII: Fan2 temp point 2 */
  158. 0xE7, /* SmartFanII: Fan2 temp point 3 */
  159. 0xE8 }, /* SmartFanII: Fan2 temp point 4 */
  160. { 0x96, /* SmartFanII: Fan3 temp point 1 */
  161. 0xE9, /* SmartFanII: Fan3 temp point 2 */
  162. 0xEA, /* SmartFanII: Fan3 temp point 3 */
  163. 0xEB } /* SmartFanII: Fan3 temp point 4 */
  164. };
  165. static const u8 W83792D_REG_LEVELS[3][4] = {
  166. { 0x88, /* (bit3-0) SmartFanII: Fan1 Non-Stop */
  167. 0x88, /* (bit7-4) SmartFanII: Fan1 Level 1 */
  168. 0xE0, /* (bit7-4) SmartFanII: Fan1 Level 2 */
  169. 0xE0 }, /* (bit3-0) SmartFanII: Fan1 Level 3 */
  170. { 0x89, /* (bit3-0) SmartFanII: Fan2 Non-Stop */
  171. 0x89, /* (bit7-4) SmartFanII: Fan2 Level 1 */
  172. 0xE1, /* (bit7-4) SmartFanII: Fan2 Level 2 */
  173. 0xE1 }, /* (bit3-0) SmartFanII: Fan2 Level 3 */
  174. { 0x98, /* (bit3-0) SmartFanII: Fan3 Non-Stop */
  175. 0x98, /* (bit7-4) SmartFanII: Fan3 Level 1 */
  176. 0xE2, /* (bit7-4) SmartFanII: Fan3 Level 2 */
  177. 0xE2 } /* (bit3-0) SmartFanII: Fan3 Level 3 */
  178. };
  179. #define W83792D_REG_GPIO_EN 0x1A
  180. #define W83792D_REG_CONFIG 0x40
  181. #define W83792D_REG_VID_FANDIV 0x47
  182. #define W83792D_REG_CHIPID 0x49
  183. #define W83792D_REG_WCHIPID 0x58
  184. #define W83792D_REG_CHIPMAN 0x4F
  185. #define W83792D_REG_PIN 0x4B
  186. #define W83792D_REG_I2C_SUBADDR 0x4A
  187. #define W83792D_REG_ALARM1 0xA9 /* realtime status register1 */
  188. #define W83792D_REG_ALARM2 0xAA /* realtime status register2 */
  189. #define W83792D_REG_ALARM3 0xAB /* realtime status register3 */
  190. #define W83792D_REG_CHASSIS 0x42 /* Bit 5: Case Open status bit */
  191. #define W83792D_REG_CHASSIS_CLR 0x44 /* Bit 7: Case Open CLR_CHS/Reset bit */
  192. /* control in0/in1 's limit modifiability */
  193. #define W83792D_REG_VID_IN_B 0x17
  194. #define W83792D_REG_VBAT 0x5D
  195. #define W83792D_REG_I2C_ADDR 0x48
  196. /* Conversions. Rounding and limit checking is only done on the TO_REG
  197. variants. Note that you should be a bit careful with which arguments
  198. these macros are called: arguments may be evaluated more than once.
  199. Fixing this is just not worth it. */
  200. #define IN_FROM_REG(nr,val) (((nr)<=1)?(val*2): \
  201. ((((nr)==6)||((nr)==7))?(val*6):(val*4)))
  202. #define IN_TO_REG(nr,val) (((nr)<=1)?(val/2): \
  203. ((((nr)==6)||((nr)==7))?(val/6):(val/4)))
  204. static inline u8
  205. FAN_TO_REG(long rpm, int div)
  206. {
  207. if (rpm == 0)
  208. return 255;
  209. rpm = SENSORS_LIMIT(rpm, 1, 1000000);
  210. return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
  211. }
  212. #define FAN_FROM_REG(val,div) ((val) == 0 ? -1 : \
  213. ((val) == 255 ? 0 : \
  214. 1350000 / ((val) * (div))))
  215. /* for temp1 */
  216. #define TEMP1_TO_REG(val) (SENSORS_LIMIT(((val) < 0 ? (val)+0x100*1000 \
  217. : (val)) / 1000, 0, 0xff))
  218. #define TEMP1_FROM_REG(val) (((val) & 0x80 ? (val)-0x100 : (val)) * 1000)
  219. /* for temp2 and temp3, because they need addtional resolution */
  220. #define TEMP_ADD_FROM_REG(val1, val2) \
  221. ((((val1) & 0x80 ? (val1)-0x100 \
  222. : (val1)) * 1000) + ((val2 & 0x80) ? 500 : 0))
  223. #define TEMP_ADD_TO_REG_HIGH(val) \
  224. (SENSORS_LIMIT(((val) < 0 ? (val)+0x100*1000 \
  225. : (val)) / 1000, 0, 0xff))
  226. #define TEMP_ADD_TO_REG_LOW(val) ((val%1000) ? 0x80 : 0x00)
  227. #define DIV_FROM_REG(val) (1 << (val))
  228. static inline u8
  229. DIV_TO_REG(long val)
  230. {
  231. int i;
  232. val = SENSORS_LIMIT(val, 1, 128) >> 1;
  233. for (i = 0; i < 7; i++) {
  234. if (val == 0)
  235. break;
  236. val >>= 1;
  237. }
  238. return ((u8) i);
  239. }
  240. struct w83792d_data {
  241. struct i2c_client client;
  242. struct class_device *class_dev;
  243. enum chips type;
  244. struct mutex update_lock;
  245. char valid; /* !=0 if following fields are valid */
  246. unsigned long last_updated; /* In jiffies */
  247. /* array of 2 pointers to subclients */
  248. struct i2c_client *lm75[2];
  249. u8 in[9]; /* Register value */
  250. u8 in_max[9]; /* Register value */
  251. u8 in_min[9]; /* Register value */
  252. u16 low_bits; /* Additional resolution to voltage in6-0 */
  253. u8 fan[7]; /* Register value */
  254. u8 fan_min[7]; /* Register value */
  255. u8 temp1[3]; /* current, over, thyst */
  256. u8 temp_add[2][6]; /* Register value */
  257. u8 fan_div[7]; /* Register encoding, shifted right */
  258. u8 pwm[7]; /* We only consider the first 3 set of pwm,
  259. although 792 chip has 7 set of pwm. */
  260. u8 pwmenable[3];
  261. u32 alarms; /* realtime status register encoding,combined */
  262. u8 chassis; /* Chassis status */
  263. u8 chassis_clear; /* CLR_CHS, clear chassis intrusion detection */
  264. u8 thermal_cruise[3]; /* Smart FanI: Fan1,2,3 target value */
  265. u8 tolerance[3]; /* Fan1,2,3 tolerance(Smart Fan I/II) */
  266. u8 sf2_points[3][4]; /* Smart FanII: Fan1,2,3 temperature points */
  267. u8 sf2_levels[3][4]; /* Smart FanII: Fan1,2,3 duty cycle levels */
  268. };
  269. static int w83792d_attach_adapter(struct i2c_adapter *adapter);
  270. static int w83792d_detect(struct i2c_adapter *adapter, int address, int kind);
  271. static int w83792d_detach_client(struct i2c_client *client);
  272. static struct w83792d_data *w83792d_update_device(struct device *dev);
  273. #ifdef DEBUG
  274. static void w83792d_print_debug(struct w83792d_data *data, struct device *dev);
  275. #endif
  276. static void w83792d_init_client(struct i2c_client *client);
  277. static struct i2c_driver w83792d_driver = {
  278. .driver = {
  279. .name = "w83792d",
  280. },
  281. .attach_adapter = w83792d_attach_adapter,
  282. .detach_client = w83792d_detach_client,
  283. };
  284. static inline long in_count_from_reg(int nr, struct w83792d_data *data)
  285. {
  286. /* in7 and in8 do not have low bits, but the formula still works */
  287. return ((data->in[nr] << 2) | ((data->low_bits >> (2 * nr)) & 0x03));
  288. }
  289. /* The SMBus locks itself. The Winbond W83792D chip has a bank register,
  290. but the driver only accesses registers in bank 0, so we don't have
  291. to switch banks and lock access between switches. */
  292. static inline int w83792d_read_value(struct i2c_client *client, u8 reg)
  293. {
  294. return i2c_smbus_read_byte_data(client, reg);
  295. }
  296. static inline int
  297. w83792d_write_value(struct i2c_client *client, u8 reg, u8 value)
  298. {
  299. return i2c_smbus_write_byte_data(client, reg, value);
  300. }
  301. /* following are the sysfs callback functions */
  302. static ssize_t show_in(struct device *dev, struct device_attribute *attr,
  303. char *buf)
  304. {
  305. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  306. int nr = sensor_attr->index;
  307. struct w83792d_data *data = w83792d_update_device(dev);
  308. return sprintf(buf,"%ld\n", IN_FROM_REG(nr,(in_count_from_reg(nr, data))));
  309. }
  310. #define show_in_reg(reg) \
  311. static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
  312. char *buf) \
  313. { \
  314. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
  315. int nr = sensor_attr->index; \
  316. struct w83792d_data *data = w83792d_update_device(dev); \
  317. return sprintf(buf,"%ld\n", (long)(IN_FROM_REG(nr, (data->reg[nr])*4))); \
  318. }
  319. show_in_reg(in_min);
  320. show_in_reg(in_max);
  321. #define store_in_reg(REG, reg) \
  322. static ssize_t store_in_##reg (struct device *dev, \
  323. struct device_attribute *attr, \
  324. const char *buf, size_t count) \
  325. { \
  326. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
  327. int nr = sensor_attr->index; \
  328. struct i2c_client *client = to_i2c_client(dev); \
  329. struct w83792d_data *data = i2c_get_clientdata(client); \
  330. u32 val; \
  331. \
  332. val = simple_strtoul(buf, NULL, 10); \
  333. mutex_lock(&data->update_lock); \
  334. data->in_##reg[nr] = SENSORS_LIMIT(IN_TO_REG(nr, val)/4, 0, 255); \
  335. w83792d_write_value(client, W83792D_REG_IN_##REG[nr], data->in_##reg[nr]); \
  336. mutex_unlock(&data->update_lock); \
  337. \
  338. return count; \
  339. }
  340. store_in_reg(MIN, min);
  341. store_in_reg(MAX, max);
  342. #define show_fan_reg(reg) \
  343. static ssize_t show_##reg (struct device *dev, struct device_attribute *attr, \
  344. char *buf) \
  345. { \
  346. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
  347. int nr = sensor_attr->index - 1; \
  348. struct w83792d_data *data = w83792d_update_device(dev); \
  349. return sprintf(buf,"%d\n", \
  350. FAN_FROM_REG(data->reg[nr], DIV_FROM_REG(data->fan_div[nr]))); \
  351. }
  352. show_fan_reg(fan);
  353. show_fan_reg(fan_min);
  354. static ssize_t
  355. store_fan_min(struct device *dev, struct device_attribute *attr,
  356. const char *buf, size_t count)
  357. {
  358. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  359. int nr = sensor_attr->index - 1;
  360. struct i2c_client *client = to_i2c_client(dev);
  361. struct w83792d_data *data = i2c_get_clientdata(client);
  362. u32 val;
  363. val = simple_strtoul(buf, NULL, 10);
  364. mutex_lock(&data->update_lock);
  365. data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
  366. w83792d_write_value(client, W83792D_REG_FAN_MIN[nr],
  367. data->fan_min[nr]);
  368. mutex_unlock(&data->update_lock);
  369. return count;
  370. }
  371. static ssize_t
  372. show_fan_div(struct device *dev, struct device_attribute *attr,
  373. char *buf)
  374. {
  375. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  376. int nr = sensor_attr->index;
  377. struct w83792d_data *data = w83792d_update_device(dev);
  378. return sprintf(buf, "%u\n", DIV_FROM_REG(data->fan_div[nr - 1]));
  379. }
  380. /* Note: we save and restore the fan minimum here, because its value is
  381. determined in part by the fan divisor. This follows the principle of
  382. least surprise; the user doesn't expect the fan minimum to change just
  383. because the divisor changed. */
  384. static ssize_t
  385. store_fan_div(struct device *dev, struct device_attribute *attr,
  386. const char *buf, size_t count)
  387. {
  388. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  389. int nr = sensor_attr->index - 1;
  390. struct i2c_client *client = to_i2c_client(dev);
  391. struct w83792d_data *data = i2c_get_clientdata(client);
  392. unsigned long min;
  393. /*u8 reg;*/
  394. u8 fan_div_reg = 0;
  395. u8 tmp_fan_div;
  396. /* Save fan_min */
  397. mutex_lock(&data->update_lock);
  398. min = FAN_FROM_REG(data->fan_min[nr],
  399. DIV_FROM_REG(data->fan_div[nr]));
  400. data->fan_div[nr] = DIV_TO_REG(simple_strtoul(buf, NULL, 10));
  401. fan_div_reg = w83792d_read_value(client, W83792D_REG_FAN_DIV[nr >> 1]);
  402. fan_div_reg &= (nr & 0x01) ? 0x8f : 0xf8;
  403. tmp_fan_div = (nr & 0x01) ? (((data->fan_div[nr]) << 4) & 0x70)
  404. : ((data->fan_div[nr]) & 0x07);
  405. w83792d_write_value(client, W83792D_REG_FAN_DIV[nr >> 1],
  406. fan_div_reg | tmp_fan_div);
  407. /* Restore fan_min */
  408. data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
  409. w83792d_write_value(client, W83792D_REG_FAN_MIN[nr], data->fan_min[nr]);
  410. mutex_unlock(&data->update_lock);
  411. return count;
  412. }
  413. /* read/write the temperature1, includes measured value and limits */
  414. static ssize_t show_temp1(struct device *dev, struct device_attribute *attr,
  415. char *buf)
  416. {
  417. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  418. int nr = sensor_attr->index;
  419. struct w83792d_data *data = w83792d_update_device(dev);
  420. return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp1[nr]));
  421. }
  422. static ssize_t store_temp1(struct device *dev, struct device_attribute *attr,
  423. const char *buf, size_t count)
  424. {
  425. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  426. int nr = sensor_attr->index;
  427. struct i2c_client *client = to_i2c_client(dev);
  428. struct w83792d_data *data = i2c_get_clientdata(client);
  429. s32 val;
  430. val = simple_strtol(buf, NULL, 10);
  431. mutex_lock(&data->update_lock);
  432. data->temp1[nr] = TEMP1_TO_REG(val);
  433. w83792d_write_value(client, W83792D_REG_TEMP1[nr],
  434. data->temp1[nr]);
  435. mutex_unlock(&data->update_lock);
  436. return count;
  437. }
  438. /* read/write the temperature2-3, includes measured value and limits */
  439. static ssize_t show_temp23(struct device *dev, struct device_attribute *attr,
  440. char *buf)
  441. {
  442. struct sensor_device_attribute_2 *sensor_attr = to_sensor_dev_attr_2(attr);
  443. int nr = sensor_attr->nr;
  444. int index = sensor_attr->index;
  445. struct w83792d_data *data = w83792d_update_device(dev);
  446. return sprintf(buf,"%ld\n",
  447. (long)TEMP_ADD_FROM_REG(data->temp_add[nr][index],
  448. data->temp_add[nr][index+1]));
  449. }
  450. static ssize_t store_temp23(struct device *dev, struct device_attribute *attr,
  451. const char *buf, size_t count)
  452. {
  453. struct sensor_device_attribute_2 *sensor_attr = to_sensor_dev_attr_2(attr);
  454. int nr = sensor_attr->nr;
  455. int index = sensor_attr->index;
  456. struct i2c_client *client = to_i2c_client(dev);
  457. struct w83792d_data *data = i2c_get_clientdata(client);
  458. s32 val;
  459. val = simple_strtol(buf, NULL, 10);
  460. mutex_lock(&data->update_lock);
  461. data->temp_add[nr][index] = TEMP_ADD_TO_REG_HIGH(val);
  462. data->temp_add[nr][index+1] = TEMP_ADD_TO_REG_LOW(val);
  463. w83792d_write_value(client, W83792D_REG_TEMP_ADD[nr][index],
  464. data->temp_add[nr][index]);
  465. w83792d_write_value(client, W83792D_REG_TEMP_ADD[nr][index+1],
  466. data->temp_add[nr][index+1]);
  467. mutex_unlock(&data->update_lock);
  468. return count;
  469. }
  470. /* get reatime status of all sensors items: voltage, temp, fan */
  471. static ssize_t
  472. show_alarms_reg(struct device *dev, struct device_attribute *attr, char *buf)
  473. {
  474. struct w83792d_data *data = w83792d_update_device(dev);
  475. return sprintf(buf, "%d\n", data->alarms);
  476. }
  477. static ssize_t
  478. show_pwm(struct device *dev, struct device_attribute *attr,
  479. char *buf)
  480. {
  481. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  482. int nr = sensor_attr->index;
  483. struct w83792d_data *data = w83792d_update_device(dev);
  484. return sprintf(buf, "%d\n", (data->pwm[nr] & 0x0f) << 4);
  485. }
  486. static ssize_t
  487. show_pwmenable(struct device *dev, struct device_attribute *attr,
  488. char *buf)
  489. {
  490. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  491. int nr = sensor_attr->index - 1;
  492. struct w83792d_data *data = w83792d_update_device(dev);
  493. long pwm_enable_tmp = 1;
  494. switch (data->pwmenable[nr]) {
  495. case 0:
  496. pwm_enable_tmp = 1; /* manual mode */
  497. break;
  498. case 1:
  499. pwm_enable_tmp = 3; /*thermal cruise/Smart Fan I */
  500. break;
  501. case 2:
  502. pwm_enable_tmp = 2; /* Smart Fan II */
  503. break;
  504. }
  505. return sprintf(buf, "%ld\n", pwm_enable_tmp);
  506. }
  507. static ssize_t
  508. store_pwm(struct device *dev, struct device_attribute *attr,
  509. const char *buf, size_t count)
  510. {
  511. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  512. int nr = sensor_attr->index;
  513. struct i2c_client *client = to_i2c_client(dev);
  514. struct w83792d_data *data = i2c_get_clientdata(client);
  515. u8 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 0, 255) >> 4;
  516. mutex_lock(&data->update_lock);
  517. val |= w83792d_read_value(client, W83792D_REG_PWM[nr]) & 0xf0;
  518. data->pwm[nr] = val;
  519. w83792d_write_value(client, W83792D_REG_PWM[nr], data->pwm[nr]);
  520. mutex_unlock(&data->update_lock);
  521. return count;
  522. }
  523. static ssize_t
  524. store_pwmenable(struct device *dev, struct device_attribute *attr,
  525. const char *buf, size_t count)
  526. {
  527. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  528. int nr = sensor_attr->index - 1;
  529. struct i2c_client *client = to_i2c_client(dev);
  530. struct w83792d_data *data = i2c_get_clientdata(client);
  531. u32 val;
  532. u8 fan_cfg_tmp, cfg1_tmp, cfg2_tmp, cfg3_tmp, cfg4_tmp;
  533. val = simple_strtoul(buf, NULL, 10);
  534. if (val < 1 || val > 3)
  535. return -EINVAL;
  536. mutex_lock(&data->update_lock);
  537. switch (val) {
  538. case 1:
  539. data->pwmenable[nr] = 0; /* manual mode */
  540. break;
  541. case 2:
  542. data->pwmenable[nr] = 2; /* Smart Fan II */
  543. break;
  544. case 3:
  545. data->pwmenable[nr] = 1; /* thermal cruise/Smart Fan I */
  546. break;
  547. }
  548. cfg1_tmp = data->pwmenable[0];
  549. cfg2_tmp = (data->pwmenable[1]) << 2;
  550. cfg3_tmp = (data->pwmenable[2]) << 4;
  551. cfg4_tmp = w83792d_read_value(client,W83792D_REG_FAN_CFG) & 0xc0;
  552. fan_cfg_tmp = ((cfg4_tmp | cfg3_tmp) | cfg2_tmp) | cfg1_tmp;
  553. w83792d_write_value(client, W83792D_REG_FAN_CFG, fan_cfg_tmp);
  554. mutex_unlock(&data->update_lock);
  555. return count;
  556. }
  557. static ssize_t
  558. show_pwm_mode(struct device *dev, struct device_attribute *attr,
  559. char *buf)
  560. {
  561. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  562. int nr = sensor_attr->index;
  563. struct w83792d_data *data = w83792d_update_device(dev);
  564. return sprintf(buf, "%d\n", data->pwm[nr] >> 7);
  565. }
  566. static ssize_t
  567. store_pwm_mode(struct device *dev, struct device_attribute *attr,
  568. const char *buf, size_t count)
  569. {
  570. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  571. int nr = sensor_attr->index;
  572. struct i2c_client *client = to_i2c_client(dev);
  573. struct w83792d_data *data = i2c_get_clientdata(client);
  574. u32 val;
  575. val = simple_strtoul(buf, NULL, 10);
  576. if (val != 0 && val != 1)
  577. return -EINVAL;
  578. mutex_lock(&data->update_lock);
  579. data->pwm[nr] = w83792d_read_value(client, W83792D_REG_PWM[nr]);
  580. if (val) { /* PWM mode */
  581. data->pwm[nr] |= 0x80;
  582. } else { /* DC mode */
  583. data->pwm[nr] &= 0x7f;
  584. }
  585. w83792d_write_value(client, W83792D_REG_PWM[nr], data->pwm[nr]);
  586. mutex_unlock(&data->update_lock);
  587. return count;
  588. }
  589. static ssize_t
  590. show_regs_chassis(struct device *dev, struct device_attribute *attr,
  591. char *buf)
  592. {
  593. struct w83792d_data *data = w83792d_update_device(dev);
  594. return sprintf(buf, "%d\n", data->chassis);
  595. }
  596. static ssize_t
  597. show_chassis_clear(struct device *dev, struct device_attribute *attr, char *buf)
  598. {
  599. struct w83792d_data *data = w83792d_update_device(dev);
  600. return sprintf(buf, "%d\n", data->chassis_clear);
  601. }
  602. static ssize_t
  603. store_chassis_clear(struct device *dev, struct device_attribute *attr,
  604. const char *buf, size_t count)
  605. {
  606. struct i2c_client *client = to_i2c_client(dev);
  607. struct w83792d_data *data = i2c_get_clientdata(client);
  608. u32 val;
  609. u8 temp1 = 0, temp2 = 0;
  610. val = simple_strtoul(buf, NULL, 10);
  611. mutex_lock(&data->update_lock);
  612. data->chassis_clear = SENSORS_LIMIT(val, 0 ,1);
  613. temp1 = ((data->chassis_clear) << 7) & 0x80;
  614. temp2 = w83792d_read_value(client,
  615. W83792D_REG_CHASSIS_CLR) & 0x7f;
  616. w83792d_write_value(client, W83792D_REG_CHASSIS_CLR, temp1 | temp2);
  617. mutex_unlock(&data->update_lock);
  618. return count;
  619. }
  620. /* For Smart Fan I / Thermal Cruise */
  621. static ssize_t
  622. show_thermal_cruise(struct device *dev, struct device_attribute *attr,
  623. char *buf)
  624. {
  625. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  626. int nr = sensor_attr->index;
  627. struct w83792d_data *data = w83792d_update_device(dev);
  628. return sprintf(buf, "%ld\n", (long)data->thermal_cruise[nr-1]);
  629. }
  630. static ssize_t
  631. store_thermal_cruise(struct device *dev, struct device_attribute *attr,
  632. const char *buf, size_t count)
  633. {
  634. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  635. int nr = sensor_attr->index - 1;
  636. struct i2c_client *client = to_i2c_client(dev);
  637. struct w83792d_data *data = i2c_get_clientdata(client);
  638. u32 val;
  639. u8 target_tmp=0, target_mask=0;
  640. val = simple_strtoul(buf, NULL, 10);
  641. target_tmp = val;
  642. target_tmp = target_tmp & 0x7f;
  643. mutex_lock(&data->update_lock);
  644. target_mask = w83792d_read_value(client, W83792D_REG_THERMAL[nr]) & 0x80;
  645. data->thermal_cruise[nr] = SENSORS_LIMIT(target_tmp, 0, 255);
  646. w83792d_write_value(client, W83792D_REG_THERMAL[nr],
  647. (data->thermal_cruise[nr]) | target_mask);
  648. mutex_unlock(&data->update_lock);
  649. return count;
  650. }
  651. /* For Smart Fan I/Thermal Cruise and Smart Fan II */
  652. static ssize_t
  653. show_tolerance(struct device *dev, struct device_attribute *attr,
  654. char *buf)
  655. {
  656. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  657. int nr = sensor_attr->index;
  658. struct w83792d_data *data = w83792d_update_device(dev);
  659. return sprintf(buf, "%ld\n", (long)data->tolerance[nr-1]);
  660. }
  661. static ssize_t
  662. store_tolerance(struct device *dev, struct device_attribute *attr,
  663. const char *buf, size_t count)
  664. {
  665. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  666. int nr = sensor_attr->index - 1;
  667. struct i2c_client *client = to_i2c_client(dev);
  668. struct w83792d_data *data = i2c_get_clientdata(client);
  669. u32 val;
  670. u8 tol_tmp, tol_mask;
  671. val = simple_strtoul(buf, NULL, 10);
  672. mutex_lock(&data->update_lock);
  673. tol_mask = w83792d_read_value(client,
  674. W83792D_REG_TOLERANCE[nr]) & ((nr == 1) ? 0x0f : 0xf0);
  675. tol_tmp = SENSORS_LIMIT(val, 0, 15);
  676. tol_tmp &= 0x0f;
  677. data->tolerance[nr] = tol_tmp;
  678. if (nr == 1) {
  679. tol_tmp <<= 4;
  680. }
  681. w83792d_write_value(client, W83792D_REG_TOLERANCE[nr],
  682. tol_mask | tol_tmp);
  683. mutex_unlock(&data->update_lock);
  684. return count;
  685. }
  686. /* For Smart Fan II */
  687. static ssize_t
  688. show_sf2_point(struct device *dev, struct device_attribute *attr,
  689. char *buf)
  690. {
  691. struct sensor_device_attribute_2 *sensor_attr = to_sensor_dev_attr_2(attr);
  692. int nr = sensor_attr->nr;
  693. int index = sensor_attr->index;
  694. struct w83792d_data *data = w83792d_update_device(dev);
  695. return sprintf(buf, "%ld\n", (long)data->sf2_points[index-1][nr-1]);
  696. }
  697. static ssize_t
  698. store_sf2_point(struct device *dev, struct device_attribute *attr,
  699. const char *buf, size_t count)
  700. {
  701. struct sensor_device_attribute_2 *sensor_attr = to_sensor_dev_attr_2(attr);
  702. int nr = sensor_attr->nr - 1;
  703. int index = sensor_attr->index - 1;
  704. struct i2c_client *client = to_i2c_client(dev);
  705. struct w83792d_data *data = i2c_get_clientdata(client);
  706. u32 val;
  707. u8 mask_tmp = 0;
  708. val = simple_strtoul(buf, NULL, 10);
  709. mutex_lock(&data->update_lock);
  710. data->sf2_points[index][nr] = SENSORS_LIMIT(val, 0, 127);
  711. mask_tmp = w83792d_read_value(client,
  712. W83792D_REG_POINTS[index][nr]) & 0x80;
  713. w83792d_write_value(client, W83792D_REG_POINTS[index][nr],
  714. mask_tmp|data->sf2_points[index][nr]);
  715. mutex_unlock(&data->update_lock);
  716. return count;
  717. }
  718. static ssize_t
  719. show_sf2_level(struct device *dev, struct device_attribute *attr,
  720. char *buf)
  721. {
  722. struct sensor_device_attribute_2 *sensor_attr = to_sensor_dev_attr_2(attr);
  723. int nr = sensor_attr->nr;
  724. int index = sensor_attr->index;
  725. struct w83792d_data *data = w83792d_update_device(dev);
  726. return sprintf(buf, "%d\n",
  727. (((data->sf2_levels[index-1][nr]) * 100) / 15));
  728. }
  729. static ssize_t
  730. store_sf2_level(struct device *dev, struct device_attribute *attr,
  731. const char *buf, size_t count)
  732. {
  733. struct sensor_device_attribute_2 *sensor_attr = to_sensor_dev_attr_2(attr);
  734. int nr = sensor_attr->nr;
  735. int index = sensor_attr->index - 1;
  736. struct i2c_client *client = to_i2c_client(dev);
  737. struct w83792d_data *data = i2c_get_clientdata(client);
  738. u32 val;
  739. u8 mask_tmp=0, level_tmp=0;
  740. val = simple_strtoul(buf, NULL, 10);
  741. mutex_lock(&data->update_lock);
  742. data->sf2_levels[index][nr] = SENSORS_LIMIT((val * 15) / 100, 0, 15);
  743. mask_tmp = w83792d_read_value(client, W83792D_REG_LEVELS[index][nr])
  744. & ((nr==3) ? 0xf0 : 0x0f);
  745. if (nr==3) {
  746. level_tmp = data->sf2_levels[index][nr];
  747. } else {
  748. level_tmp = data->sf2_levels[index][nr] << 4;
  749. }
  750. w83792d_write_value(client, W83792D_REG_LEVELS[index][nr], level_tmp | mask_tmp);
  751. mutex_unlock(&data->update_lock);
  752. return count;
  753. }
  754. /* This function is called when:
  755. * w83792d_driver is inserted (when this module is loaded), for each
  756. available adapter
  757. * when a new adapter is inserted (and w83792d_driver is still present) */
  758. static int
  759. w83792d_attach_adapter(struct i2c_adapter *adapter)
  760. {
  761. if (!(adapter->class & I2C_CLASS_HWMON))
  762. return 0;
  763. return i2c_probe(adapter, &addr_data, w83792d_detect);
  764. }
  765. static int
  766. w83792d_create_subclient(struct i2c_adapter *adapter,
  767. struct i2c_client *new_client, int addr,
  768. struct i2c_client **sub_cli)
  769. {
  770. int err;
  771. struct i2c_client *sub_client;
  772. (*sub_cli) = sub_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
  773. if (!(sub_client)) {
  774. return -ENOMEM;
  775. }
  776. sub_client->addr = 0x48 + addr;
  777. i2c_set_clientdata(sub_client, NULL);
  778. sub_client->adapter = adapter;
  779. sub_client->driver = &w83792d_driver;
  780. sub_client->flags = 0;
  781. strlcpy(sub_client->name, "w83792d subclient", I2C_NAME_SIZE);
  782. if ((err = i2c_attach_client(sub_client))) {
  783. dev_err(&new_client->dev, "subclient registration "
  784. "at address 0x%x failed\n", sub_client->addr);
  785. kfree(sub_client);
  786. return err;
  787. }
  788. return 0;
  789. }
  790. static int
  791. w83792d_detect_subclients(struct i2c_adapter *adapter, int address, int kind,
  792. struct i2c_client *new_client)
  793. {
  794. int i, id, err;
  795. u8 val;
  796. struct w83792d_data *data = i2c_get_clientdata(new_client);
  797. id = i2c_adapter_id(adapter);
  798. if (force_subclients[0] == id && force_subclients[1] == address) {
  799. for (i = 2; i <= 3; i++) {
  800. if (force_subclients[i] < 0x48 ||
  801. force_subclients[i] > 0x4f) {
  802. dev_err(&new_client->dev, "invalid subclient "
  803. "address %d; must be 0x48-0x4f\n",
  804. force_subclients[i]);
  805. err = -ENODEV;
  806. goto ERROR_SC_0;
  807. }
  808. }
  809. w83792d_write_value(new_client, W83792D_REG_I2C_SUBADDR,
  810. (force_subclients[2] & 0x07) |
  811. ((force_subclients[3] & 0x07) << 4));
  812. }
  813. val = w83792d_read_value(new_client, W83792D_REG_I2C_SUBADDR);
  814. if (!(val & 0x08)) {
  815. err = w83792d_create_subclient(adapter, new_client, val & 0x7,
  816. &data->lm75[0]);
  817. if (err < 0)
  818. goto ERROR_SC_0;
  819. }
  820. if (!(val & 0x80)) {
  821. if ((data->lm75[0] != NULL) &&
  822. ((val & 0x7) == ((val >> 4) & 0x7))) {
  823. dev_err(&new_client->dev, "duplicate addresses 0x%x, "
  824. "use force_subclient\n", data->lm75[0]->addr);
  825. err = -ENODEV;
  826. goto ERROR_SC_1;
  827. }
  828. err = w83792d_create_subclient(adapter, new_client,
  829. (val >> 4) & 0x7, &data->lm75[1]);
  830. if (err < 0)
  831. goto ERROR_SC_1;
  832. }
  833. return 0;
  834. /* Undo inits in case of errors */
  835. ERROR_SC_1:
  836. if (data->lm75[0] != NULL) {
  837. i2c_detach_client(data->lm75[0]);
  838. kfree(data->lm75[0]);
  839. }
  840. ERROR_SC_0:
  841. return err;
  842. }
  843. static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, show_in, NULL, 0);
  844. static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_in, NULL, 1);
  845. static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_in, NULL, 2);
  846. static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_in, NULL, 3);
  847. static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, show_in, NULL, 4);
  848. static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, show_in, NULL, 5);
  849. static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, show_in, NULL, 6);
  850. static SENSOR_DEVICE_ATTR(in7_input, S_IRUGO, show_in, NULL, 7);
  851. static SENSOR_DEVICE_ATTR(in8_input, S_IRUGO, show_in, NULL, 8);
  852. static SENSOR_DEVICE_ATTR(in0_min, S_IWUSR | S_IRUGO,
  853. show_in_min, store_in_min, 0);
  854. static SENSOR_DEVICE_ATTR(in1_min, S_IWUSR | S_IRUGO,
  855. show_in_min, store_in_min, 1);
  856. static SENSOR_DEVICE_ATTR(in2_min, S_IWUSR | S_IRUGO,
  857. show_in_min, store_in_min, 2);
  858. static SENSOR_DEVICE_ATTR(in3_min, S_IWUSR | S_IRUGO,
  859. show_in_min, store_in_min, 3);
  860. static SENSOR_DEVICE_ATTR(in4_min, S_IWUSR | S_IRUGO,
  861. show_in_min, store_in_min, 4);
  862. static SENSOR_DEVICE_ATTR(in5_min, S_IWUSR | S_IRUGO,
  863. show_in_min, store_in_min, 5);
  864. static SENSOR_DEVICE_ATTR(in6_min, S_IWUSR | S_IRUGO,
  865. show_in_min, store_in_min, 6);
  866. static SENSOR_DEVICE_ATTR(in7_min, S_IWUSR | S_IRUGO,
  867. show_in_min, store_in_min, 7);
  868. static SENSOR_DEVICE_ATTR(in8_min, S_IWUSR | S_IRUGO,
  869. show_in_min, store_in_min, 8);
  870. static SENSOR_DEVICE_ATTR(in0_max, S_IWUSR | S_IRUGO,
  871. show_in_max, store_in_max, 0);
  872. static SENSOR_DEVICE_ATTR(in1_max, S_IWUSR | S_IRUGO,
  873. show_in_max, store_in_max, 1);
  874. static SENSOR_DEVICE_ATTR(in2_max, S_IWUSR | S_IRUGO,
  875. show_in_max, store_in_max, 2);
  876. static SENSOR_DEVICE_ATTR(in3_max, S_IWUSR | S_IRUGO,
  877. show_in_max, store_in_max, 3);
  878. static SENSOR_DEVICE_ATTR(in4_max, S_IWUSR | S_IRUGO,
  879. show_in_max, store_in_max, 4);
  880. static SENSOR_DEVICE_ATTR(in5_max, S_IWUSR | S_IRUGO,
  881. show_in_max, store_in_max, 5);
  882. static SENSOR_DEVICE_ATTR(in6_max, S_IWUSR | S_IRUGO,
  883. show_in_max, store_in_max, 6);
  884. static SENSOR_DEVICE_ATTR(in7_max, S_IWUSR | S_IRUGO,
  885. show_in_max, store_in_max, 7);
  886. static SENSOR_DEVICE_ATTR(in8_max, S_IWUSR | S_IRUGO,
  887. show_in_max, store_in_max, 8);
  888. static SENSOR_DEVICE_ATTR_2(temp1_input, S_IRUGO, show_temp1, NULL, 0, 0);
  889. static SENSOR_DEVICE_ATTR_2(temp2_input, S_IRUGO, show_temp23, NULL, 0, 0);
  890. static SENSOR_DEVICE_ATTR_2(temp3_input, S_IRUGO, show_temp23, NULL, 1, 0);
  891. static SENSOR_DEVICE_ATTR_2(temp1_max, S_IRUGO | S_IWUSR,
  892. show_temp1, store_temp1, 0, 1);
  893. static SENSOR_DEVICE_ATTR_2(temp2_max, S_IRUGO | S_IWUSR, show_temp23,
  894. store_temp23, 0, 2);
  895. static SENSOR_DEVICE_ATTR_2(temp3_max, S_IRUGO | S_IWUSR, show_temp23,
  896. store_temp23, 1, 2);
  897. static SENSOR_DEVICE_ATTR_2(temp1_max_hyst, S_IRUGO | S_IWUSR,
  898. show_temp1, store_temp1, 0, 2);
  899. static SENSOR_DEVICE_ATTR_2(temp2_max_hyst, S_IRUGO | S_IWUSR,
  900. show_temp23, store_temp23, 0, 4);
  901. static SENSOR_DEVICE_ATTR_2(temp3_max_hyst, S_IRUGO | S_IWUSR,
  902. show_temp23, store_temp23, 1, 4);
  903. static DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL);
  904. static DEVICE_ATTR(chassis, S_IRUGO, show_regs_chassis, NULL);
  905. static DEVICE_ATTR(chassis_clear, S_IRUGO | S_IWUSR,
  906. show_chassis_clear, store_chassis_clear);
  907. static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 0);
  908. static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 1);
  909. static SENSOR_DEVICE_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 2);
  910. static SENSOR_DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO,
  911. show_pwmenable, store_pwmenable, 1);
  912. static SENSOR_DEVICE_ATTR(pwm2_enable, S_IWUSR | S_IRUGO,
  913. show_pwmenable, store_pwmenable, 2);
  914. static SENSOR_DEVICE_ATTR(pwm3_enable, S_IWUSR | S_IRUGO,
  915. show_pwmenable, store_pwmenable, 3);
  916. static SENSOR_DEVICE_ATTR(pwm1_mode, S_IWUSR | S_IRUGO,
  917. show_pwm_mode, store_pwm_mode, 0);
  918. static SENSOR_DEVICE_ATTR(pwm2_mode, S_IWUSR | S_IRUGO,
  919. show_pwm_mode, store_pwm_mode, 1);
  920. static SENSOR_DEVICE_ATTR(pwm3_mode, S_IWUSR | S_IRUGO,
  921. show_pwm_mode, store_pwm_mode, 2);
  922. static SENSOR_DEVICE_ATTR(tolerance1, S_IWUSR | S_IRUGO,
  923. show_tolerance, store_tolerance, 1);
  924. static SENSOR_DEVICE_ATTR(tolerance2, S_IWUSR | S_IRUGO,
  925. show_tolerance, store_tolerance, 2);
  926. static SENSOR_DEVICE_ATTR(tolerance3, S_IWUSR | S_IRUGO,
  927. show_tolerance, store_tolerance, 3);
  928. static SENSOR_DEVICE_ATTR(thermal_cruise1, S_IWUSR | S_IRUGO,
  929. show_thermal_cruise, store_thermal_cruise, 1);
  930. static SENSOR_DEVICE_ATTR(thermal_cruise2, S_IWUSR | S_IRUGO,
  931. show_thermal_cruise, store_thermal_cruise, 2);
  932. static SENSOR_DEVICE_ATTR(thermal_cruise3, S_IWUSR | S_IRUGO,
  933. show_thermal_cruise, store_thermal_cruise, 3);
  934. static SENSOR_DEVICE_ATTR_2(sf2_point1_fan1, S_IRUGO | S_IWUSR,
  935. show_sf2_point, store_sf2_point, 1, 1);
  936. static SENSOR_DEVICE_ATTR_2(sf2_point2_fan1, S_IRUGO | S_IWUSR,
  937. show_sf2_point, store_sf2_point, 2, 1);
  938. static SENSOR_DEVICE_ATTR_2(sf2_point3_fan1, S_IRUGO | S_IWUSR,
  939. show_sf2_point, store_sf2_point, 3, 1);
  940. static SENSOR_DEVICE_ATTR_2(sf2_point4_fan1, S_IRUGO | S_IWUSR,
  941. show_sf2_point, store_sf2_point, 4, 1);
  942. static SENSOR_DEVICE_ATTR_2(sf2_point1_fan2, S_IRUGO | S_IWUSR,
  943. show_sf2_point, store_sf2_point, 1, 2);
  944. static SENSOR_DEVICE_ATTR_2(sf2_point2_fan2, S_IRUGO | S_IWUSR,
  945. show_sf2_point, store_sf2_point, 2, 2);
  946. static SENSOR_DEVICE_ATTR_2(sf2_point3_fan2, S_IRUGO | S_IWUSR,
  947. show_sf2_point, store_sf2_point, 3, 2);
  948. static SENSOR_DEVICE_ATTR_2(sf2_point4_fan2, S_IRUGO | S_IWUSR,
  949. show_sf2_point, store_sf2_point, 4, 2);
  950. static SENSOR_DEVICE_ATTR_2(sf2_point1_fan3, S_IRUGO | S_IWUSR,
  951. show_sf2_point, store_sf2_point, 1, 3);
  952. static SENSOR_DEVICE_ATTR_2(sf2_point2_fan3, S_IRUGO | S_IWUSR,
  953. show_sf2_point, store_sf2_point, 2, 3);
  954. static SENSOR_DEVICE_ATTR_2(sf2_point3_fan3, S_IRUGO | S_IWUSR,
  955. show_sf2_point, store_sf2_point, 3, 3);
  956. static SENSOR_DEVICE_ATTR_2(sf2_point4_fan3, S_IRUGO | S_IWUSR,
  957. show_sf2_point, store_sf2_point, 4, 3);
  958. static SENSOR_DEVICE_ATTR_2(sf2_level1_fan1, S_IRUGO | S_IWUSR,
  959. show_sf2_level, store_sf2_level, 1, 1);
  960. static SENSOR_DEVICE_ATTR_2(sf2_level2_fan1, S_IRUGO | S_IWUSR,
  961. show_sf2_level, store_sf2_level, 2, 1);
  962. static SENSOR_DEVICE_ATTR_2(sf2_level3_fan1, S_IRUGO | S_IWUSR,
  963. show_sf2_level, store_sf2_level, 3, 1);
  964. static SENSOR_DEVICE_ATTR_2(sf2_level1_fan2, S_IRUGO | S_IWUSR,
  965. show_sf2_level, store_sf2_level, 1, 2);
  966. static SENSOR_DEVICE_ATTR_2(sf2_level2_fan2, S_IRUGO | S_IWUSR,
  967. show_sf2_level, store_sf2_level, 2, 2);
  968. static SENSOR_DEVICE_ATTR_2(sf2_level3_fan2, S_IRUGO | S_IWUSR,
  969. show_sf2_level, store_sf2_level, 3, 2);
  970. static SENSOR_DEVICE_ATTR_2(sf2_level1_fan3, S_IRUGO | S_IWUSR,
  971. show_sf2_level, store_sf2_level, 1, 3);
  972. static SENSOR_DEVICE_ATTR_2(sf2_level2_fan3, S_IRUGO | S_IWUSR,
  973. show_sf2_level, store_sf2_level, 2, 3);
  974. static SENSOR_DEVICE_ATTR_2(sf2_level3_fan3, S_IRUGO | S_IWUSR,
  975. show_sf2_level, store_sf2_level, 3, 3);
  976. static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 1);
  977. static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 2);
  978. static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 3);
  979. static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 4);
  980. static SENSOR_DEVICE_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 5);
  981. static SENSOR_DEVICE_ATTR(fan6_input, S_IRUGO, show_fan, NULL, 6);
  982. static SENSOR_DEVICE_ATTR(fan7_input, S_IRUGO, show_fan, NULL, 7);
  983. static SENSOR_DEVICE_ATTR(fan1_min, S_IWUSR | S_IRUGO,
  984. show_fan_min, store_fan_min, 1);
  985. static SENSOR_DEVICE_ATTR(fan2_min, S_IWUSR | S_IRUGO,
  986. show_fan_min, store_fan_min, 2);
  987. static SENSOR_DEVICE_ATTR(fan3_min, S_IWUSR | S_IRUGO,
  988. show_fan_min, store_fan_min, 3);
  989. static SENSOR_DEVICE_ATTR(fan4_min, S_IWUSR | S_IRUGO,
  990. show_fan_min, store_fan_min, 4);
  991. static SENSOR_DEVICE_ATTR(fan5_min, S_IWUSR | S_IRUGO,
  992. show_fan_min, store_fan_min, 5);
  993. static SENSOR_DEVICE_ATTR(fan6_min, S_IWUSR | S_IRUGO,
  994. show_fan_min, store_fan_min, 6);
  995. static SENSOR_DEVICE_ATTR(fan7_min, S_IWUSR | S_IRUGO,
  996. show_fan_min, store_fan_min, 7);
  997. static SENSOR_DEVICE_ATTR(fan1_div, S_IWUSR | S_IRUGO,
  998. show_fan_div, store_fan_div, 1);
  999. static SENSOR_DEVICE_ATTR(fan2_div, S_IWUSR | S_IRUGO,
  1000. show_fan_div, store_fan_div, 2);
  1001. static SENSOR_DEVICE_ATTR(fan3_div, S_IWUSR | S_IRUGO,
  1002. show_fan_div, store_fan_div, 3);
  1003. static SENSOR_DEVICE_ATTR(fan4_div, S_IWUSR | S_IRUGO,
  1004. show_fan_div, store_fan_div, 4);
  1005. static SENSOR_DEVICE_ATTR(fan5_div, S_IWUSR | S_IRUGO,
  1006. show_fan_div, store_fan_div, 5);
  1007. static SENSOR_DEVICE_ATTR(fan6_div, S_IWUSR | S_IRUGO,
  1008. show_fan_div, store_fan_div, 6);
  1009. static SENSOR_DEVICE_ATTR(fan7_div, S_IWUSR | S_IRUGO,
  1010. show_fan_div, store_fan_div, 7);
  1011. static struct attribute *w83792d_attributes_fan[4][4] = {
  1012. {
  1013. &sensor_dev_attr_fan4_input.dev_attr.attr,
  1014. &sensor_dev_attr_fan4_min.dev_attr.attr,
  1015. &sensor_dev_attr_fan4_div.dev_attr.attr,
  1016. NULL
  1017. }, {
  1018. &sensor_dev_attr_fan5_input.dev_attr.attr,
  1019. &sensor_dev_attr_fan5_min.dev_attr.attr,
  1020. &sensor_dev_attr_fan5_div.dev_attr.attr,
  1021. NULL
  1022. }, {
  1023. &sensor_dev_attr_fan6_input.dev_attr.attr,
  1024. &sensor_dev_attr_fan6_min.dev_attr.attr,
  1025. &sensor_dev_attr_fan6_div.dev_attr.attr,
  1026. NULL
  1027. }, {
  1028. &sensor_dev_attr_fan7_input.dev_attr.attr,
  1029. &sensor_dev_attr_fan7_min.dev_attr.attr,
  1030. &sensor_dev_attr_fan7_div.dev_attr.attr,
  1031. NULL
  1032. }
  1033. };
  1034. static const struct attribute_group w83792d_group_fan[4] = {
  1035. { .attrs = w83792d_attributes_fan[0] },
  1036. { .attrs = w83792d_attributes_fan[1] },
  1037. { .attrs = w83792d_attributes_fan[2] },
  1038. { .attrs = w83792d_attributes_fan[3] },
  1039. };
  1040. static struct attribute *w83792d_attributes[] = {
  1041. &sensor_dev_attr_in0_input.dev_attr.attr,
  1042. &sensor_dev_attr_in0_max.dev_attr.attr,
  1043. &sensor_dev_attr_in0_min.dev_attr.attr,
  1044. &sensor_dev_attr_in1_input.dev_attr.attr,
  1045. &sensor_dev_attr_in1_max.dev_attr.attr,
  1046. &sensor_dev_attr_in1_min.dev_attr.attr,
  1047. &sensor_dev_attr_in2_input.dev_attr.attr,
  1048. &sensor_dev_attr_in2_max.dev_attr.attr,
  1049. &sensor_dev_attr_in2_min.dev_attr.attr,
  1050. &sensor_dev_attr_in3_input.dev_attr.attr,
  1051. &sensor_dev_attr_in3_max.dev_attr.attr,
  1052. &sensor_dev_attr_in3_min.dev_attr.attr,
  1053. &sensor_dev_attr_in4_input.dev_attr.attr,
  1054. &sensor_dev_attr_in4_max.dev_attr.attr,
  1055. &sensor_dev_attr_in4_min.dev_attr.attr,
  1056. &sensor_dev_attr_in5_input.dev_attr.attr,
  1057. &sensor_dev_attr_in5_max.dev_attr.attr,
  1058. &sensor_dev_attr_in5_min.dev_attr.attr,
  1059. &sensor_dev_attr_in6_input.dev_attr.attr,
  1060. &sensor_dev_attr_in6_max.dev_attr.attr,
  1061. &sensor_dev_attr_in6_min.dev_attr.attr,
  1062. &sensor_dev_attr_in7_input.dev_attr.attr,
  1063. &sensor_dev_attr_in7_max.dev_attr.attr,
  1064. &sensor_dev_attr_in7_min.dev_attr.attr,
  1065. &sensor_dev_attr_in8_input.dev_attr.attr,
  1066. &sensor_dev_attr_in8_max.dev_attr.attr,
  1067. &sensor_dev_attr_in8_min.dev_attr.attr,
  1068. &sensor_dev_attr_temp1_input.dev_attr.attr,
  1069. &sensor_dev_attr_temp1_max.dev_attr.attr,
  1070. &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
  1071. &sensor_dev_attr_temp2_input.dev_attr.attr,
  1072. &sensor_dev_attr_temp2_max.dev_attr.attr,
  1073. &sensor_dev_attr_temp2_max_hyst.dev_attr.attr,
  1074. &sensor_dev_attr_temp3_input.dev_attr.attr,
  1075. &sensor_dev_attr_temp3_max.dev_attr.attr,
  1076. &sensor_dev_attr_temp3_max_hyst.dev_attr.attr,
  1077. &sensor_dev_attr_pwm1.dev_attr.attr,
  1078. &sensor_dev_attr_pwm1_mode.dev_attr.attr,
  1079. &sensor_dev_attr_pwm1_enable.dev_attr.attr,
  1080. &sensor_dev_attr_pwm2.dev_attr.attr,
  1081. &sensor_dev_attr_pwm2_mode.dev_attr.attr,
  1082. &sensor_dev_attr_pwm2_enable.dev_attr.attr,
  1083. &sensor_dev_attr_pwm3.dev_attr.attr,
  1084. &sensor_dev_attr_pwm3_mode.dev_attr.attr,
  1085. &sensor_dev_attr_pwm3_enable.dev_attr.attr,
  1086. &dev_attr_alarms.attr,
  1087. &dev_attr_chassis.attr,
  1088. &dev_attr_chassis_clear.attr,
  1089. &sensor_dev_attr_tolerance1.dev_attr.attr,
  1090. &sensor_dev_attr_thermal_cruise1.dev_attr.attr,
  1091. &sensor_dev_attr_tolerance2.dev_attr.attr,
  1092. &sensor_dev_attr_thermal_cruise2.dev_attr.attr,
  1093. &sensor_dev_attr_tolerance3.dev_attr.attr,
  1094. &sensor_dev_attr_thermal_cruise3.dev_attr.attr,
  1095. &sensor_dev_attr_sf2_point1_fan1.dev_attr.attr,
  1096. &sensor_dev_attr_sf2_point2_fan1.dev_attr.attr,
  1097. &sensor_dev_attr_sf2_point3_fan1.dev_attr.attr,
  1098. &sensor_dev_attr_sf2_point4_fan1.dev_attr.attr,
  1099. &sensor_dev_attr_sf2_point1_fan2.dev_attr.attr,
  1100. &sensor_dev_attr_sf2_point2_fan2.dev_attr.attr,
  1101. &sensor_dev_attr_sf2_point3_fan2.dev_attr.attr,
  1102. &sensor_dev_attr_sf2_point4_fan2.dev_attr.attr,
  1103. &sensor_dev_attr_sf2_point1_fan3.dev_attr.attr,
  1104. &sensor_dev_attr_sf2_point2_fan3.dev_attr.attr,
  1105. &sensor_dev_attr_sf2_point3_fan3.dev_attr.attr,
  1106. &sensor_dev_attr_sf2_point4_fan3.dev_attr.attr,
  1107. &sensor_dev_attr_sf2_level1_fan1.dev_attr.attr,
  1108. &sensor_dev_attr_sf2_level2_fan1.dev_attr.attr,
  1109. &sensor_dev_attr_sf2_level3_fan1.dev_attr.attr,
  1110. &sensor_dev_attr_sf2_level1_fan2.dev_attr.attr,
  1111. &sensor_dev_attr_sf2_level2_fan2.dev_attr.attr,
  1112. &sensor_dev_attr_sf2_level3_fan2.dev_attr.attr,
  1113. &sensor_dev_attr_sf2_level1_fan3.dev_attr.attr,
  1114. &sensor_dev_attr_sf2_level2_fan3.dev_attr.attr,
  1115. &sensor_dev_attr_sf2_level3_fan3.dev_attr.attr,
  1116. &sensor_dev_attr_fan1_input.dev_attr.attr,
  1117. &sensor_dev_attr_fan1_min.dev_attr.attr,
  1118. &sensor_dev_attr_fan1_div.dev_attr.attr,
  1119. &sensor_dev_attr_fan2_input.dev_attr.attr,
  1120. &sensor_dev_attr_fan2_min.dev_attr.attr,
  1121. &sensor_dev_attr_fan2_div.dev_attr.attr,
  1122. &sensor_dev_attr_fan3_input.dev_attr.attr,
  1123. &sensor_dev_attr_fan3_min.dev_attr.attr,
  1124. &sensor_dev_attr_fan3_div.dev_attr.attr,
  1125. NULL
  1126. };
  1127. static const struct attribute_group w83792d_group = {
  1128. .attrs = w83792d_attributes,
  1129. };
  1130. static int
  1131. w83792d_detect(struct i2c_adapter *adapter, int address, int kind)
  1132. {
  1133. int i = 0, val1 = 0, val2;
  1134. struct i2c_client *client;
  1135. struct device *dev;
  1136. struct w83792d_data *data;
  1137. int err = 0;
  1138. const char *client_name = "";
  1139. if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
  1140. goto ERROR0;
  1141. }
  1142. /* OK. For now, we presume we have a valid client. We now create the
  1143. client structure, even though we cannot fill it completely yet.
  1144. But it allows us to access w83792d_{read,write}_value. */
  1145. if (!(data = kzalloc(sizeof(struct w83792d_data), GFP_KERNEL))) {
  1146. err = -ENOMEM;
  1147. goto ERROR0;
  1148. }
  1149. client = &data->client;
  1150. dev = &client->dev;
  1151. i2c_set_clientdata(client, data);
  1152. client->addr = address;
  1153. client->adapter = adapter;
  1154. client->driver = &w83792d_driver;
  1155. client->flags = 0;
  1156. /* Now, we do the remaining detection. */
  1157. /* The w83792d may be stuck in some other bank than bank 0. This may
  1158. make reading other information impossible. Specify a force=... or
  1159. force_*=... parameter, and the Winbond will be reset to the right
  1160. bank. */
  1161. if (kind < 0) {
  1162. if (w83792d_read_value(client, W83792D_REG_CONFIG) & 0x80) {
  1163. dev_dbg(dev, "Detection failed at step 1\n");
  1164. goto ERROR1;
  1165. }
  1166. val1 = w83792d_read_value(client, W83792D_REG_BANK);
  1167. val2 = w83792d_read_value(client, W83792D_REG_CHIPMAN);
  1168. /* Check for Winbond ID if in bank 0 */
  1169. if (!(val1 & 0x07)) { /* is Bank0 */
  1170. if (((!(val1 & 0x80)) && (val2 != 0xa3)) ||
  1171. ((val1 & 0x80) && (val2 != 0x5c))) {
  1172. dev_dbg(dev, "Detection failed at step 2\n");
  1173. goto ERROR1;
  1174. }
  1175. }
  1176. /* If Winbond chip, address of chip and W83792D_REG_I2C_ADDR
  1177. should match */
  1178. if (w83792d_read_value(client,
  1179. W83792D_REG_I2C_ADDR) != address) {
  1180. dev_dbg(dev, "Detection failed at step 3\n");
  1181. goto ERROR1;
  1182. }
  1183. }
  1184. /* We have either had a force parameter, or we have already detected the
  1185. Winbond. Put it now into bank 0 and Vendor ID High Byte */
  1186. w83792d_write_value(client,
  1187. W83792D_REG_BANK,
  1188. (w83792d_read_value(client,
  1189. W83792D_REG_BANK) & 0x78) | 0x80);
  1190. /* Determine the chip type. */
  1191. if (kind <= 0) {
  1192. /* get vendor ID */
  1193. val2 = w83792d_read_value(client, W83792D_REG_CHIPMAN);
  1194. if (val2 != 0x5c) { /* the vendor is NOT Winbond */
  1195. goto ERROR1;
  1196. }
  1197. val1 = w83792d_read_value(client, W83792D_REG_WCHIPID);
  1198. if (val1 == 0x7a) {
  1199. kind = w83792d;
  1200. } else {
  1201. if (kind == 0)
  1202. dev_warn(dev,
  1203. "w83792d: Ignoring 'force' parameter for"
  1204. " unknown chip at adapter %d, address"
  1205. " 0x%02x\n", i2c_adapter_id(adapter),
  1206. address);
  1207. goto ERROR1;
  1208. }
  1209. }
  1210. if (kind == w83792d) {
  1211. client_name = "w83792d";
  1212. } else {
  1213. dev_err(dev, "w83792d: Internal error: unknown"
  1214. " kind (%d)?!?", kind);
  1215. goto ERROR1;
  1216. }
  1217. /* Fill in the remaining client fields and put into the global list */
  1218. strlcpy(client->name, client_name, I2C_NAME_SIZE);
  1219. data->type = kind;
  1220. data->valid = 0;
  1221. mutex_init(&data->update_lock);
  1222. /* Tell the I2C layer a new client has arrived */
  1223. if ((err = i2c_attach_client(client)))
  1224. goto ERROR1;
  1225. if ((err = w83792d_detect_subclients(adapter, address,
  1226. kind, client)))
  1227. goto ERROR2;
  1228. /* Initialize the chip */
  1229. w83792d_init_client(client);
  1230. /* A few vars need to be filled upon startup */
  1231. for (i = 0; i < 7; i++) {
  1232. data->fan_min[i] = w83792d_read_value(client,
  1233. W83792D_REG_FAN_MIN[i]);
  1234. }
  1235. /* Register sysfs hooks */
  1236. if ((err = sysfs_create_group(&dev->kobj, &w83792d_group)))
  1237. goto ERROR3;
  1238. /* Read GPIO enable register to check if pins for fan 4,5 are used as
  1239. GPIO */
  1240. val1 = w83792d_read_value(client, W83792D_REG_GPIO_EN);
  1241. if (!(val1 & 0x40))
  1242. if ((err = sysfs_create_group(&dev->kobj,
  1243. &w83792d_group_fan[0])))
  1244. goto exit_remove_files;
  1245. if (!(val1 & 0x20))
  1246. if ((err = sysfs_create_group(&dev->kobj,
  1247. &w83792d_group_fan[1])))
  1248. goto exit_remove_files;
  1249. val1 = w83792d_read_value(client, W83792D_REG_PIN);
  1250. if (val1 & 0x40)
  1251. if ((err = sysfs_create_group(&dev->kobj,
  1252. &w83792d_group_fan[2])))
  1253. goto exit_remove_files;
  1254. if (val1 & 0x04)
  1255. if ((err = sysfs_create_group(&dev->kobj,
  1256. &w83792d_group_fan[3])))
  1257. goto exit_remove_files;
  1258. data->class_dev = hwmon_device_register(dev);
  1259. if (IS_ERR(data->class_dev)) {
  1260. err = PTR_ERR(data->class_dev);
  1261. goto exit_remove_files;
  1262. }
  1263. return 0;
  1264. exit_remove_files:
  1265. sysfs_remove_group(&dev->kobj, &w83792d_group);
  1266. for (i = 0; i < ARRAY_SIZE(w83792d_group_fan); i++)
  1267. sysfs_remove_group(&dev->kobj, &w83792d_group_fan[i]);
  1268. ERROR3:
  1269. if (data->lm75[0] != NULL) {
  1270. i2c_detach_client(data->lm75[0]);
  1271. kfree(data->lm75[0]);
  1272. }
  1273. if (data->lm75[1] != NULL) {
  1274. i2c_detach_client(data->lm75[1]);
  1275. kfree(data->lm75[1]);
  1276. }
  1277. ERROR2:
  1278. i2c_detach_client(client);
  1279. ERROR1:
  1280. kfree(data);
  1281. ERROR0:
  1282. return err;
  1283. }
  1284. static int
  1285. w83792d_detach_client(struct i2c_client *client)
  1286. {
  1287. struct w83792d_data *data = i2c_get_clientdata(client);
  1288. int err, i;
  1289. /* main client */
  1290. if (data) {
  1291. hwmon_device_unregister(data->class_dev);
  1292. sysfs_remove_group(&client->dev.kobj, &w83792d_group);
  1293. for (i = 0; i < ARRAY_SIZE(w83792d_group_fan); i++)
  1294. sysfs_remove_group(&client->dev.kobj,
  1295. &w83792d_group_fan[i]);
  1296. }
  1297. if ((err = i2c_detach_client(client)))
  1298. return err;
  1299. /* main client */
  1300. if (data)
  1301. kfree(data);
  1302. /* subclient */
  1303. else
  1304. kfree(client);
  1305. return 0;
  1306. }
  1307. static void
  1308. w83792d_init_client(struct i2c_client *client)
  1309. {
  1310. u8 temp2_cfg, temp3_cfg, vid_in_b;
  1311. if (init) {
  1312. w83792d_write_value(client, W83792D_REG_CONFIG, 0x80);
  1313. }
  1314. /* Clear the bit6 of W83792D_REG_VID_IN_B(set it into 0):
  1315. W83792D_REG_VID_IN_B bit6 = 0: the high/low limit of
  1316. vin0/vin1 can be modified by user;
  1317. W83792D_REG_VID_IN_B bit6 = 1: the high/low limit of
  1318. vin0/vin1 auto-updated, can NOT be modified by user. */
  1319. vid_in_b = w83792d_read_value(client, W83792D_REG_VID_IN_B);
  1320. w83792d_write_value(client, W83792D_REG_VID_IN_B,
  1321. vid_in_b & 0xbf);
  1322. temp2_cfg = w83792d_read_value(client, W83792D_REG_TEMP2_CONFIG);
  1323. temp3_cfg = w83792d_read_value(client, W83792D_REG_TEMP3_CONFIG);
  1324. w83792d_write_value(client, W83792D_REG_TEMP2_CONFIG,
  1325. temp2_cfg & 0xe6);
  1326. w83792d_write_value(client, W83792D_REG_TEMP3_CONFIG,
  1327. temp3_cfg & 0xe6);
  1328. /* Start monitoring */
  1329. w83792d_write_value(client, W83792D_REG_CONFIG,
  1330. (w83792d_read_value(client,
  1331. W83792D_REG_CONFIG) & 0xf7)
  1332. | 0x01);
  1333. }
  1334. static struct w83792d_data *w83792d_update_device(struct device *dev)
  1335. {
  1336. struct i2c_client *client = to_i2c_client(dev);
  1337. struct w83792d_data *data = i2c_get_clientdata(client);
  1338. int i, j;
  1339. u8 reg_array_tmp[4], reg_tmp;
  1340. mutex_lock(&data->update_lock);
  1341. if (time_after
  1342. (jiffies - data->last_updated, (unsigned long) (HZ * 3))
  1343. || time_before(jiffies, data->last_updated) || !data->valid) {
  1344. dev_dbg(dev, "Starting device update\n");
  1345. /* Update the voltages measured value and limits */
  1346. for (i = 0; i < 9; i++) {
  1347. data->in[i] = w83792d_read_value(client,
  1348. W83792D_REG_IN[i]);
  1349. data->in_max[i] = w83792d_read_value(client,
  1350. W83792D_REG_IN_MAX[i]);
  1351. data->in_min[i] = w83792d_read_value(client,
  1352. W83792D_REG_IN_MIN[i]);
  1353. }
  1354. data->low_bits = w83792d_read_value(client,
  1355. W83792D_REG_LOW_BITS1) +
  1356. (w83792d_read_value(client,
  1357. W83792D_REG_LOW_BITS2) << 8);
  1358. for (i = 0; i < 7; i++) {
  1359. /* Update the Fan measured value and limits */
  1360. data->fan[i] = w83792d_read_value(client,
  1361. W83792D_REG_FAN[i]);
  1362. data->fan_min[i] = w83792d_read_value(client,
  1363. W83792D_REG_FAN_MIN[i]);
  1364. /* Update the PWM/DC Value and PWM/DC flag */
  1365. data->pwm[i] = w83792d_read_value(client,
  1366. W83792D_REG_PWM[i]);
  1367. }
  1368. reg_tmp = w83792d_read_value(client, W83792D_REG_FAN_CFG);
  1369. data->pwmenable[0] = reg_tmp & 0x03;
  1370. data->pwmenable[1] = (reg_tmp>>2) & 0x03;
  1371. data->pwmenable[2] = (reg_tmp>>4) & 0x03;
  1372. for (i = 0; i < 3; i++) {
  1373. data->temp1[i] = w83792d_read_value(client,
  1374. W83792D_REG_TEMP1[i]);
  1375. }
  1376. for (i = 0; i < 2; i++) {
  1377. for (j = 0; j < 6; j++) {
  1378. data->temp_add[i][j] = w83792d_read_value(
  1379. client,W83792D_REG_TEMP_ADD[i][j]);
  1380. }
  1381. }
  1382. /* Update the Fan Divisor */
  1383. for (i = 0; i < 4; i++) {
  1384. reg_array_tmp[i] = w83792d_read_value(client,
  1385. W83792D_REG_FAN_DIV[i]);
  1386. }
  1387. data->fan_div[0] = reg_array_tmp[0] & 0x07;
  1388. data->fan_div[1] = (reg_array_tmp[0] >> 4) & 0x07;
  1389. data->fan_div[2] = reg_array_tmp[1] & 0x07;
  1390. data->fan_div[3] = (reg_array_tmp[1] >> 4) & 0x07;
  1391. data->fan_div[4] = reg_array_tmp[2] & 0x07;
  1392. data->fan_div[5] = (reg_array_tmp[2] >> 4) & 0x07;
  1393. data->fan_div[6] = reg_array_tmp[3] & 0x07;
  1394. /* Update the realtime status */
  1395. data->alarms = w83792d_read_value(client, W83792D_REG_ALARM1) +
  1396. (w83792d_read_value(client, W83792D_REG_ALARM2) << 8) +
  1397. (w83792d_read_value(client, W83792D_REG_ALARM3) << 16);
  1398. /* Update CaseOpen status and it's CLR_CHS. */
  1399. data->chassis = (w83792d_read_value(client,
  1400. W83792D_REG_CHASSIS) >> 5) & 0x01;
  1401. data->chassis_clear = (w83792d_read_value(client,
  1402. W83792D_REG_CHASSIS_CLR) >> 7) & 0x01;
  1403. /* Update Thermal Cruise/Smart Fan I target value */
  1404. for (i = 0; i < 3; i++) {
  1405. data->thermal_cruise[i] =
  1406. w83792d_read_value(client,
  1407. W83792D_REG_THERMAL[i]) & 0x7f;
  1408. }
  1409. /* Update Smart Fan I/II tolerance */
  1410. reg_tmp = w83792d_read_value(client, W83792D_REG_TOLERANCE[0]);
  1411. data->tolerance[0] = reg_tmp & 0x0f;
  1412. data->tolerance[1] = (reg_tmp >> 4) & 0x0f;
  1413. data->tolerance[2] = w83792d_read_value(client,
  1414. W83792D_REG_TOLERANCE[2]) & 0x0f;
  1415. /* Update Smart Fan II temperature points */
  1416. for (i = 0; i < 3; i++) {
  1417. for (j = 0; j < 4; j++) {
  1418. data->sf2_points[i][j] = w83792d_read_value(
  1419. client,W83792D_REG_POINTS[i][j]) & 0x7f;
  1420. }
  1421. }
  1422. /* Update Smart Fan II duty cycle levels */
  1423. for (i = 0; i < 3; i++) {
  1424. reg_tmp = w83792d_read_value(client,
  1425. W83792D_REG_LEVELS[i][0]);
  1426. data->sf2_levels[i][0] = reg_tmp & 0x0f;
  1427. data->sf2_levels[i][1] = (reg_tmp >> 4) & 0x0f;
  1428. reg_tmp = w83792d_read_value(client,
  1429. W83792D_REG_LEVELS[i][2]);
  1430. data->sf2_levels[i][2] = (reg_tmp >> 4) & 0x0f;
  1431. data->sf2_levels[i][3] = reg_tmp & 0x0f;
  1432. }
  1433. data->last_updated = jiffies;
  1434. data->valid = 1;
  1435. }
  1436. mutex_unlock(&data->update_lock);
  1437. #ifdef DEBUG
  1438. w83792d_print_debug(data, dev);
  1439. #endif
  1440. return data;
  1441. }
  1442. #ifdef DEBUG
  1443. static void w83792d_print_debug(struct w83792d_data *data, struct device *dev)
  1444. {
  1445. int i=0, j=0;
  1446. dev_dbg(dev, "==========The following is the debug message...========\n");
  1447. dev_dbg(dev, "9 set of Voltages: =====>\n");
  1448. for (i=0; i<9; i++) {
  1449. dev_dbg(dev, "vin[%d] is: 0x%x\n", i, data->in[i]);
  1450. dev_dbg(dev, "vin[%d] max is: 0x%x\n", i, data->in_max[i]);
  1451. dev_dbg(dev, "vin[%d] min is: 0x%x\n", i, data->in_min[i]);
  1452. }
  1453. dev_dbg(dev, "Low Bit1 is: 0x%x\n", data->low_bits & 0xff);
  1454. dev_dbg(dev, "Low Bit2 is: 0x%x\n", data->low_bits >> 8);
  1455. dev_dbg(dev, "7 set of Fan Counts and Duty Cycles: =====>\n");
  1456. for (i=0; i<7; i++) {
  1457. dev_dbg(dev, "fan[%d] is: 0x%x\n", i, data->fan[i]);
  1458. dev_dbg(dev, "fan[%d] min is: 0x%x\n", i, data->fan_min[i]);
  1459. dev_dbg(dev, "pwm[%d] is: 0x%x\n", i, data->pwm[i]);
  1460. }
  1461. dev_dbg(dev, "3 set of Temperatures: =====>\n");
  1462. for (i=0; i<3; i++) {
  1463. dev_dbg(dev, "temp1[%d] is: 0x%x\n", i, data->temp1[i]);
  1464. }
  1465. for (i=0; i<2; i++) {
  1466. for (j=0; j<6; j++) {
  1467. dev_dbg(dev, "temp_add[%d][%d] is: 0x%x\n", i, j,
  1468. data->temp_add[i][j]);
  1469. }
  1470. }
  1471. for (i=0; i<7; i++) {
  1472. dev_dbg(dev, "fan_div[%d] is: 0x%x\n", i, data->fan_div[i]);
  1473. }
  1474. dev_dbg(dev, "==========End of the debug message...==================\n");
  1475. dev_dbg(dev, "\n");
  1476. }
  1477. #endif
  1478. static int __init
  1479. sensors_w83792d_init(void)
  1480. {
  1481. return i2c_add_driver(&w83792d_driver);
  1482. }
  1483. static void __exit
  1484. sensors_w83792d_exit(void)
  1485. {
  1486. i2c_del_driver(&w83792d_driver);
  1487. }
  1488. MODULE_AUTHOR("Chunhao Huang @ Winbond <DZShen@Winbond.com.tw>");
  1489. MODULE_DESCRIPTION("W83792AD/D driver for linux-2.6");
  1490. MODULE_LICENSE("GPL");
  1491. module_init(sensors_w83792d_init);
  1492. module_exit(sensors_w83792d_exit);