/drivers/hwmon/w83627ehf.c

https://bitbucket.org/abioy/linux · C · 1711 lines · 1366 code · 196 blank · 149 comment · 164 complexity · 465d09f228b356db88a6459b1f446200 MD5 · raw file 

    

  1. /*
    2. 

  2.     w83627ehf - Driver for the hardware monitoring functionality of
    3. 

  3.                 the Winbond W83627EHF Super-I/O chip
    4. 

  4.     Copyright (C) 2005  Jean Delvare <khali@linux-fr.org>
    5. 

  5.     Copyright (C) 2006  Yuan Mu (Winbond),
    6. 

  6.                         Rudolf Marek <r.marek@assembler.cz>
    7. 

  7.                         David Hubbard <david.c.hubbard@gmail.com>
    8. 

  8. 			Daniel J Blueman <daniel.blueman@gmail.com>
    9. 

    10. 

  10.     Shamelessly ripped from the w83627hf driver
    11. 

  11.     Copyright (C) 2003  Mark Studebaker
    12. 

    13. 

  13.     Thanks to Leon Moonen, Steve Cliffe and Grant Coady for their help
    14. 

  14.     in testing and debugging this driver.
    15. 

    16. 

  16.     This driver also supports the W83627EHG, which is the lead-free
    17. 

  17.     version of the W83627EHF.
    18. 

    19. 

  19.     This program is free software; you can redistribute it and/or modify
    20. 

  20.     it under the terms of the GNU General Public License as published by
    21. 

  21.     the Free Software Foundation; either version 2 of the License, or
    22. 

  22.     (at your option) any later version.
    23. 

    24. 

  24.     This program is distributed in the hope that it will be useful,
    25. 

  25.     but WITHOUT ANY WARRANTY; without even the implied warranty of
    26. 

  26.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    27. 

  27.     GNU General Public License for more details.
    28. 

    29. 

  29.     You should have received a copy of the GNU General Public License
    30. 

  30.     along with this program; if not, write to the Free Software
    31. 

  31.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
    32. 

    33. 

    34. 

  34.     Supports the following chips:
    35. 

    36. 

  36.     Chip        #vin    #fan    #pwm    #temp  chip IDs       man ID
    37. 

  37.     w83627ehf   10      5       4       3      0x8850 0x88    0x5ca3
    38. 

  38.                                                0x8860 0xa1
    39. 

  39.     w83627dhg    9      5       4       3      0xa020 0xc1    0x5ca3
    40. 

  40.     w83627dhg-p  9      5       4       3      0xb070 0xc1    0x5ca3
    41. 

  41.     w83667hg     9      5       3       3      0xa510 0xc1    0x5ca3
    42. 

  42. */
    43. 

  43. 

  44. #include <linux/module.h>
    45. 

  45. #include <linux/init.h>
    46. 

  46. #include <linux/slab.h>
    47. 

  47. #include <linux/jiffies.h>
    48. 

  48. #include <linux/platform_device.h>
    49. 

  49. #include <linux/hwmon.h>
    50. 

  50. #include <linux/hwmon-sysfs.h>
    51. 

  51. #include <linux/hwmon-vid.h>
    52. 

  52. #include <linux/err.h>
    53. 

  53. #include <linux/mutex.h>
    54. 

  54. #include <linux/acpi.h>
    55. 

  55. #include <linux/io.h>
    56. 

  56. #include "lm75.h"
    57. 

  57. 

  58. enum kinds { w83627ehf, w83627dhg, w83627dhg_p, w83667hg };
    59. 

  59. 

  60. /* used to set data->name = w83627ehf_device_names[data->sio_kind] */
    61. 

  61. static const char * w83627ehf_device_names[] = {
    62. 

  62. 	"w83627ehf",
    63. 

  63. 	"w83627dhg",
    64. 

  64. 	"w83627dhg",
    65. 

  65. 	"w83667hg",
    66. 

  66. };
    67. 

  67. 

  68. static unsigned short force_id;
    69. 

  69. module_param(force_id, ushort, 0);
    70. 

  70. MODULE_PARM_DESC(force_id, "Override the detected device ID");
    71. 

  71. 

  72. #define DRVNAME "w83627ehf"
    73. 

  73. 

  74. /*
    75. 

  75.  * Super-I/O constants and functions
    76. 

  76.  */
    77. 

  77. 

  78. #define W83627EHF_LD_HWM	0x0b
    79. 

  79. #define W83667HG_LD_VID 	0x0d
    80. 

  80. 

  81. #define SIO_REG_LDSEL		0x07	/* Logical device select */
    82. 

  82. #define SIO_REG_DEVID		0x20	/* Device ID (2 bytes) */
    83. 

  83. #define SIO_REG_EN_VRM10	0x2C	/* GPIO3, GPIO4 selection */
    84. 

  84. #define SIO_REG_ENABLE		0x30	/* Logical device enable */
    85. 

  85. #define SIO_REG_ADDR		0x60	/* Logical device address (2 bytes) */
    86. 

  86. #define SIO_REG_VID_CTRL	0xF0	/* VID control */
    87. 

  87. #define SIO_REG_VID_DATA	0xF1	/* VID data */
    88. 

  88. 

  89. #define SIO_W83627EHF_ID	0x8850
    90. 

  90. #define SIO_W83627EHG_ID	0x8860
    91. 

  91. #define SIO_W83627DHG_ID	0xa020
    92. 

  92. #define SIO_W83627DHG_P_ID	0xb070
    93. 

  93. #define SIO_W83667HG_ID 	0xa510
    94. 

  94. #define SIO_ID_MASK		0xFFF0
    95. 

  95. 

  96. static inline void
    97. 

  97. superio_outb(int ioreg, int reg, int val)
    98. 

  98. {
    99. 

  99. 	outb(reg, ioreg);
    100. 

  100. 	outb(val, ioreg + 1);
    101. 

  101. }
    102. 

  102. 

  103. static inline int
    104. 

  104. superio_inb(int ioreg, int reg)
    105. 

  105. {
    106. 

  106. 	outb(reg, ioreg);
    107. 

  107. 	return inb(ioreg + 1);
    108. 

  108. }
    109. 

  109. 

  110. static inline void
    111. 

  111. superio_select(int ioreg, int ld)
    112. 

  112. {
    113. 

  113. 	outb(SIO_REG_LDSEL, ioreg);
    114. 

  114. 	outb(ld, ioreg + 1);
    115. 

  115. }
    116. 

  116. 

  117. static inline void
    118. 

  118. superio_enter(int ioreg)
    119. 

  119. {
    120. 

  120. 	outb(0x87, ioreg);
    121. 

  121. 	outb(0x87, ioreg);
    122. 

  122. }
    123. 

  123. 

  124. static inline void
    125. 

  125. superio_exit(int ioreg)
    126. 

  126. {
    127. 

  127. 	outb(0x02, ioreg);
    128. 

  128. 	outb(0x02, ioreg + 1);
    129. 

  129. }
    130. 

  130. 

  131. /*
    132. 

  132.  * ISA constants
    133. 

  133.  */
    134. 

  134. 

  135. #define IOREGION_ALIGNMENT	~7
    136. 

  136. #define IOREGION_OFFSET		5
    137. 

  137. #define IOREGION_LENGTH		2
    138. 

  138. #define ADDR_REG_OFFSET		0
    139. 

  139. #define DATA_REG_OFFSET		1
    140. 

  140. 

  141. #define W83627EHF_REG_BANK		0x4E
    142. 

  142. #define W83627EHF_REG_CONFIG		0x40
    143. 

  143. 

  144. /* Not currently used:
    145. 

  145.  * REG_MAN_ID has the value 0x5ca3 for all supported chips.
    146. 

  146.  * REG_CHIP_ID == 0x88/0xa1/0xc1 depending on chip model.
    147. 

  147.  * REG_MAN_ID is at port 0x4f
    148. 

  148.  * REG_CHIP_ID is at port 0x58 */
    149. 

  149. 

  150. static const u16 W83627EHF_REG_FAN[] = { 0x28, 0x29, 0x2a, 0x3f, 0x553 };
    151. 

  151. static const u16 W83627EHF_REG_FAN_MIN[] = { 0x3b, 0x3c, 0x3d, 0x3e, 0x55c };
    152. 

  152. 

  153. /* The W83627EHF registers for nr=7,8,9 are in bank 5 */
    154. 

  154. #define W83627EHF_REG_IN_MAX(nr)	((nr < 7) ? (0x2b + (nr) * 2) : \
    155. 

  155. 					 (0x554 + (((nr) - 7) * 2)))
    156. 

  156. #define W83627EHF_REG_IN_MIN(nr)	((nr < 7) ? (0x2c + (nr) * 2) : \
    157. 

  157. 					 (0x555 + (((nr) - 7) * 2)))
    158. 

  158. #define W83627EHF_REG_IN(nr)		((nr < 7) ? (0x20 + (nr)) : \
    159. 

  159. 					 (0x550 + (nr) - 7))
    160. 

  160. 

  161. #define W83627EHF_REG_TEMP1		0x27
    162. 

  162. #define W83627EHF_REG_TEMP1_HYST	0x3a
    163. 

  163. #define W83627EHF_REG_TEMP1_OVER	0x39
    164. 

  164. static const u16 W83627EHF_REG_TEMP[] = { 0x150, 0x250 };
    165. 

  165. static const u16 W83627EHF_REG_TEMP_HYST[] = { 0x153, 0x253 };
    166. 

  166. static const u16 W83627EHF_REG_TEMP_OVER[] = { 0x155, 0x255 };
    167. 

  167. static const u16 W83627EHF_REG_TEMP_CONFIG[] = { 0x152, 0x252 };
    168. 

  168. 

  169. /* Fan clock dividers are spread over the following five registers */
    170. 

  170. #define W83627EHF_REG_FANDIV1		0x47
    171. 

  171. #define W83627EHF_REG_FANDIV2		0x4B
    172. 

  172. #define W83627EHF_REG_VBAT		0x5D
    173. 

  173. #define W83627EHF_REG_DIODE		0x59
    174. 

  174. #define W83627EHF_REG_SMI_OVT		0x4C
    175. 

  175. 

  176. #define W83627EHF_REG_ALARM1		0x459
    177. 

  177. #define W83627EHF_REG_ALARM2		0x45A
    178. 

  178. #define W83627EHF_REG_ALARM3		0x45B
    179. 

  179. 

  180. /* SmartFan registers */
    181. 

  181. #define W83627EHF_REG_FAN_STEPUP_TIME 0x0f
    182. 

  182. #define W83627EHF_REG_FAN_STEPDOWN_TIME 0x0e
    183. 

  183. 

  184. /* DC or PWM output fan configuration */
    185. 

  185. static const u8 W83627EHF_REG_PWM_ENABLE[] = {
    186. 

  186. 	0x04,			/* SYS FAN0 output mode and PWM mode */
    187. 

  187. 	0x04,			/* CPU FAN0 output mode and PWM mode */
    188. 

  188. 	0x12,			/* AUX FAN mode */
    189. 

  189. 	0x62,			/* CPU FAN1 mode */
    190. 

  190. };
    191. 

  191. 

  192. static const u8 W83627EHF_PWM_MODE_SHIFT[] = { 0, 1, 0, 6 };
    193. 

  193. static const u8 W83627EHF_PWM_ENABLE_SHIFT[] = { 2, 4, 1, 4 };
    194. 

  194. 

  195. /* FAN Duty Cycle, be used to control */
    196. 

  196. static const u8 W83627EHF_REG_PWM[] = { 0x01, 0x03, 0x11, 0x61 };
    197. 

  197. static const u8 W83627EHF_REG_TARGET[] = { 0x05, 0x06, 0x13, 0x63 };
    198. 

  198. static const u8 W83627EHF_REG_TOLERANCE[] = { 0x07, 0x07, 0x14, 0x62 };
    199. 

  199. 

  200. /* Advanced Fan control, some values are common for all fans */
    201. 

  201. static const u8 W83627EHF_REG_FAN_START_OUTPUT[] = { 0x0a, 0x0b, 0x16, 0x65 };
    202. 

  202. static const u8 W83627EHF_REG_FAN_STOP_OUTPUT[] = { 0x08, 0x09, 0x15, 0x64 };
    203. 

  203. static const u8 W83627EHF_REG_FAN_STOP_TIME[] = { 0x0c, 0x0d, 0x17, 0x66 };
    204. 

  204. static const u8 W83627EHF_REG_FAN_MAX_OUTPUT[] = { 0xff, 0x67, 0xff, 0x69 };
    205. 

  205. static const u8 W83627EHF_REG_FAN_STEP_OUTPUT[] = { 0xff, 0x68, 0xff, 0x6a };
    206. 

  206. 

  207. /*
    208. 

  208.  * Conversions
    209. 

  209.  */
    210. 

  210. 

  211. /* 1 is PWM mode, output in ms */
    212. 

  212. static inline unsigned int step_time_from_reg(u8 reg, u8 mode)
    213. 

  213. {
    214. 

  214. 	return mode ? 100 * reg : 400 * reg;
    215. 

  215. }
    216. 

  216. 

  217. static inline u8 step_time_to_reg(unsigned int msec, u8 mode)
    218. 

  218. {
    219. 

  219. 	return SENSORS_LIMIT((mode ? (msec + 50) / 100 :
    220. 

  220. 						(msec + 200) / 400), 1, 255);
    221. 

  221. }
    222. 

  222. 

  223. static inline unsigned int
    224. 

  224. fan_from_reg(u8 reg, unsigned int div)
    225. 

  225. {
    226. 

  226. 	if (reg == 0 || reg == 255)
    227. 

  227. 		return 0;
    228. 

  228. 	return 1350000U / (reg * div);
    229. 

  229. }
    230. 

  230. 

  231. static inline unsigned int
    232. 

  232. div_from_reg(u8 reg)
    233. 

  233. {
    234. 

  234. 	return 1 << reg;
    235. 

  235. }
    236. 

  236. 

  237. static inline int
    238. 

  238. temp1_from_reg(s8 reg)
    239. 

  239. {
    240. 

  240. 	return reg * 1000;
    241. 

  241. }
    242. 

  242. 

  243. static inline s8
    244. 

  244. temp1_to_reg(long temp, int min, int max)
    245. 

  245. {
    246. 

  246. 	if (temp <= min)
    247. 

  247. 		return min / 1000;
    248. 

  248. 	if (temp >= max)
    249. 

  249. 		return max / 1000;
    250. 

  250. 	if (temp < 0)
    251. 

  251. 		return (temp - 500) / 1000;
    252. 

  252. 	return (temp + 500) / 1000;
    253. 

  253. }
    254. 

  254. 

  255. /* Some of analog inputs have internal scaling (2x), 8mV is ADC LSB */
    256. 

  256. 

  257. static u8 scale_in[10] = { 8, 8, 16, 16, 8, 8, 8, 16, 16, 8 };
    258. 

  258. 

  259. static inline long in_from_reg(u8 reg, u8 nr)
    260. 

  260. {
    261. 

  261. 	return reg * scale_in[nr];
    262. 

  262. }
    263. 

  263. 

  264. static inline u8 in_to_reg(u32 val, u8 nr)
    265. 

  265. {
    266. 

  266. 	return SENSORS_LIMIT(((val + (scale_in[nr] / 2)) / scale_in[nr]), 0, 255);
    267. 

  267. }
    268. 

  268. 

  269. /*
    270. 

  270.  * Data structures and manipulation thereof
    271. 

  271.  */
    272. 

  272. 

  273. struct w83627ehf_data {
    274. 

  274. 	int addr;	/* IO base of hw monitor block */
    275. 

  275. 	const char *name;
    276. 

  276. 

  277. 	struct device *hwmon_dev;
    278. 

  278. 	struct mutex lock;
    279. 

  279. 

  280. 	struct mutex update_lock;
    281. 

  281. 	char valid;		/* !=0 if following fields are valid */
    282. 

  282. 	unsigned long last_updated;	/* In jiffies */
    283. 

  283. 

  284. 	/* Register values */
    285. 

  285. 	u8 in_num;		/* number of in inputs we have */
    286. 

  286. 	u8 in[10];		/* Register value */
    287. 

  287. 	u8 in_max[10];		/* Register value */
    288. 

  288. 	u8 in_min[10];		/* Register value */
    289. 

  289. 	u8 fan[5];
    290. 

  290. 	u8 fan_min[5];
    291. 

  291. 	u8 fan_div[5];
    292. 

  292. 	u8 has_fan;		/* some fan inputs can be disabled */
    293. 

  293. 	u8 temp_type[3];
    294. 

  294. 	s8 temp1;
    295. 

  295. 	s8 temp1_max;
    296. 

  296. 	s8 temp1_max_hyst;
    297. 

  297. 	s16 temp[2];
    298. 

  298. 	s16 temp_max[2];
    299. 

  299. 	s16 temp_max_hyst[2];
    300. 

  300. 	u32 alarms;
    301. 

  301. 

  302. 	u8 pwm_mode[4]; /* 0->DC variable voltage, 1->PWM variable duty cycle */
    303. 

  303. 	u8 pwm_enable[4]; /* 1->manual
    304. 

  304. 			     2->thermal cruise mode (also called SmartFan I)
    305. 

  305. 			     3->fan speed cruise mode
    306. 

  306. 			     4->variable thermal cruise (also called SmartFan III) */
    307. 

  307. 	u8 pwm_num;		/* number of pwm */
    308. 

  308. 	u8 pwm[4];
    309. 

  309. 	u8 target_temp[4];
    310. 

  310. 	u8 tolerance[4];
    311. 

  311. 

  312. 	u8 fan_start_output[4]; /* minimum fan speed when spinning up */
    313. 

  313. 	u8 fan_stop_output[4]; /* minimum fan speed when spinning down */
    314. 

  314. 	u8 fan_stop_time[4]; /* time at minimum before disabling fan */
    315. 

  315. 	u8 fan_max_output[4]; /* maximum fan speed */
    316. 

  316. 	u8 fan_step_output[4]; /* rate of change output value */
    317. 

  317. 

  318. 	u8 vid;
    319. 

  319. 	u8 vrm;
    320. 

  320. 

  321. 	u8 temp3_disable;
    322. 

  322. 	u8 in6_skip;
    323. 

  323. };
    324. 

  324. 

  325. struct w83627ehf_sio_data {
    326. 

  326. 	int sioreg;
    327. 

  327. 	enum kinds kind;
    328. 

  328. };
    329. 

  329. 

  330. static inline int is_word_sized(u16 reg)
    331. 

  331. {
    332. 

  332. 	return (((reg & 0xff00) == 0x100
    333. 

  333. 	      || (reg & 0xff00) == 0x200)
    334. 

  334. 	     && ((reg & 0x00ff) == 0x50
    335. 

  335. 	      || (reg & 0x00ff) == 0x53
    336. 

  336. 	      || (reg & 0x00ff) == 0x55));
    337. 

  337. }
    338. 

  338. 

  339. /* Registers 0x50-0x5f are banked */
    340. 

  340. static inline void w83627ehf_set_bank(struct w83627ehf_data *data, u16 reg)
    341. 

  341. {
    342. 

  342. 	if ((reg & 0x00f0) == 0x50) {
    343. 

  343. 		outb_p(W83627EHF_REG_BANK, data->addr + ADDR_REG_OFFSET);
    344. 

  344. 		outb_p(reg >> 8, data->addr + DATA_REG_OFFSET);
    345. 

  345. 	}
    346. 

  346. }
    347. 

  347. 

  348. /* Not strictly necessary, but play it safe for now */
    349. 

  349. static inline void w83627ehf_reset_bank(struct w83627ehf_data *data, u16 reg)
    350. 

  350. {
    351. 

  351. 	if (reg & 0xff00) {
    352. 

  352. 		outb_p(W83627EHF_REG_BANK, data->addr + ADDR_REG_OFFSET);
    353. 

  353. 		outb_p(0, data->addr + DATA_REG_OFFSET);
    354. 

  354. 	}
    355. 

  355. }
    356. 

  356. 

  357. static u16 w83627ehf_read_value(struct w83627ehf_data *data, u16 reg)
    358. 

  358. {
    359. 

  359. 	int res, word_sized = is_word_sized(reg);
    360. 

  360. 

  361. 	mutex_lock(&data->lock);
    362. 

  362. 

  363. 	w83627ehf_set_bank(data, reg);
    364. 

  364. 	outb_p(reg & 0xff, data->addr + ADDR_REG_OFFSET);
    365. 

  365. 	res = inb_p(data->addr + DATA_REG_OFFSET);
    366. 

  366. 	if (word_sized) {
    367. 

  367. 		outb_p((reg & 0xff) + 1,
    368. 

  368. 		       data->addr + ADDR_REG_OFFSET);
    369. 

  369. 		res = (res << 8) + inb_p(data->addr + DATA_REG_OFFSET);
    370. 

  370. 	}
    371. 

  371. 	w83627ehf_reset_bank(data, reg);
    372. 

  372. 

  373. 	mutex_unlock(&data->lock);
    374. 

  374. 

  375. 	return res;
    376. 

  376. }
    377. 

  377. 

  378. static int w83627ehf_write_value(struct w83627ehf_data *data, u16 reg, u16 value)
    379. 

  379. {
    380. 

  380. 	int word_sized = is_word_sized(reg);
    381. 

  381. 

  382. 	mutex_lock(&data->lock);
    383. 

  383. 

  384. 	w83627ehf_set_bank(data, reg);
    385. 

  385. 	outb_p(reg & 0xff, data->addr + ADDR_REG_OFFSET);
    386. 

  386. 	if (word_sized) {
    387. 

  387. 		outb_p(value >> 8, data->addr + DATA_REG_OFFSET);
    388. 

  388. 		outb_p((reg & 0xff) + 1,
    389. 

  389. 		       data->addr + ADDR_REG_OFFSET);
    390. 

  390. 	}
    391. 

  391. 	outb_p(value & 0xff, data->addr + DATA_REG_OFFSET);
    392. 

  392. 	w83627ehf_reset_bank(data, reg);
    393. 

  393. 

  394. 	mutex_unlock(&data->lock);
    395. 

  395. 	return 0;
    396. 

  396. }
    397. 

  397. 

  398. /* This function assumes that the caller holds data->update_lock */
    399. 

  399. static void w83627ehf_write_fan_div(struct w83627ehf_data *data, int nr)
    400. 

  400. {
    401. 

  401. 	u8 reg;
    402. 

  402. 

  403. 	switch (nr) {
    404. 

  404. 	case 0:
    405. 

  405. 		reg = (w83627ehf_read_value(data, W83627EHF_REG_FANDIV1) & 0xcf)
    406. 

  406. 		    | ((data->fan_div[0] & 0x03) << 4);
    407. 

  407. 		/* fan5 input control bit is write only, compute the value */
    408. 

  408. 		reg |= (data->has_fan & (1 << 4)) ? 1 : 0;
    409. 

  409. 		w83627ehf_write_value(data, W83627EHF_REG_FANDIV1, reg);
    410. 

  410. 		reg = (w83627ehf_read_value(data, W83627EHF_REG_VBAT) & 0xdf)
    411. 

  411. 		    | ((data->fan_div[0] & 0x04) << 3);
    412. 

  412. 		w83627ehf_write_value(data, W83627EHF_REG_VBAT, reg);
    413. 

  413. 		break;
    414. 

  414. 	case 1:
    415. 

  415. 		reg = (w83627ehf_read_value(data, W83627EHF_REG_FANDIV1) & 0x3f)
    416. 

  416. 		    | ((data->fan_div[1] & 0x03) << 6);
    417. 

  417. 		/* fan5 input control bit is write only, compute the value */
    418. 

  418. 		reg |= (data->has_fan & (1 << 4)) ? 1 : 0;
    419. 

  419. 		w83627ehf_write_value(data, W83627EHF_REG_FANDIV1, reg);
    420. 

  420. 		reg = (w83627ehf_read_value(data, W83627EHF_REG_VBAT) & 0xbf)
    421. 

  421. 		    | ((data->fan_div[1] & 0x04) << 4);
    422. 

  422. 		w83627ehf_write_value(data, W83627EHF_REG_VBAT, reg);
    423. 

  423. 		break;
    424. 

  424. 	case 2:
    425. 

  425. 		reg = (w83627ehf_read_value(data, W83627EHF_REG_FANDIV2) & 0x3f)
    426. 

  426. 		    | ((data->fan_div[2] & 0x03) << 6);
    427. 

  427. 		w83627ehf_write_value(data, W83627EHF_REG_FANDIV2, reg);
    428. 

  428. 		reg = (w83627ehf_read_value(data, W83627EHF_REG_VBAT) & 0x7f)
    429. 

  429. 		    | ((data->fan_div[2] & 0x04) << 5);
    430. 

  430. 		w83627ehf_write_value(data, W83627EHF_REG_VBAT, reg);
    431. 

  431. 		break;
    432. 

  432. 	case 3:
    433. 

  433. 		reg = (w83627ehf_read_value(data, W83627EHF_REG_DIODE) & 0xfc)
    434. 

  434. 		    | (data->fan_div[3] & 0x03);
    435. 

  435. 		w83627ehf_write_value(data, W83627EHF_REG_DIODE, reg);
    436. 

  436. 		reg = (w83627ehf_read_value(data, W83627EHF_REG_SMI_OVT) & 0x7f)
    437. 

  437. 		    | ((data->fan_div[3] & 0x04) << 5);
    438. 

  438. 		w83627ehf_write_value(data, W83627EHF_REG_SMI_OVT, reg);
    439. 

  439. 		break;
    440. 

  440. 	case 4:
    441. 

  441. 		reg = (w83627ehf_read_value(data, W83627EHF_REG_DIODE) & 0x73)
    442. 

  442. 		    | ((data->fan_div[4] & 0x03) << 2)
    443. 

  443. 		    | ((data->fan_div[4] & 0x04) << 5);
    444. 

  444. 		w83627ehf_write_value(data, W83627EHF_REG_DIODE, reg);
    445. 

  445. 		break;
    446. 

  446. 	}
    447. 

  447. }
    448. 

  448. 

  449. static void w83627ehf_update_fan_div(struct w83627ehf_data *data)
    450. 

  450. {
    451. 

  451. 	int i;
    452. 

  452. 

  453. 	i = w83627ehf_read_value(data, W83627EHF_REG_FANDIV1);
    454. 

  454. 	data->fan_div[0] = (i >> 4) & 0x03;
    455. 

  455. 	data->fan_div[1] = (i >> 6) & 0x03;
    456. 

  456. 	i = w83627ehf_read_value(data, W83627EHF_REG_FANDIV2);
    457. 

  457. 	data->fan_div[2] = (i >> 6) & 0x03;
    458. 

  458. 	i = w83627ehf_read_value(data, W83627EHF_REG_VBAT);
    459. 

  459. 	data->fan_div[0] |= (i >> 3) & 0x04;
    460. 

  460. 	data->fan_div[1] |= (i >> 4) & 0x04;
    461. 

  461. 	data->fan_div[2] |= (i >> 5) & 0x04;
    462. 

  462. 	if (data->has_fan & ((1 << 3) | (1 << 4))) {
    463. 

  463. 		i = w83627ehf_read_value(data, W83627EHF_REG_DIODE);
    464. 

  464. 		data->fan_div[3] = i & 0x03;
    465. 

  465. 		data->fan_div[4] = ((i >> 2) & 0x03)
    466. 

  466. 				 | ((i >> 5) & 0x04);
    467. 

  467. 	}
    468. 

  468. 	if (data->has_fan & (1 << 3)) {
    469. 

  469. 		i = w83627ehf_read_value(data, W83627EHF_REG_SMI_OVT);
    470. 

  470. 		data->fan_div[3] |= (i >> 5) & 0x04;
    471. 

  471. 	}
    472. 

  472. }
    473. 

  473. 

  474. static struct w83627ehf_data *w83627ehf_update_device(struct device *dev)
    475. 

  475. {
    476. 

  476. 	struct w83627ehf_data *data = dev_get_drvdata(dev);
    477. 

  477. 	int pwmcfg = 0, tolerance = 0; /* shut up the compiler */
    478. 

  478. 	int i;
    479. 

  479. 

  480. 	mutex_lock(&data->update_lock);
    481. 

  481. 

  482. 	if (time_after(jiffies, data->last_updated + HZ + HZ/2)
    483. 

  483. 	 || !data->valid) {
    484. 

  484. 		/* Fan clock dividers */
    485. 

  485. 		w83627ehf_update_fan_div(data);
    486. 

  486. 

  487. 		/* Measured voltages and limits */
    488. 

  488. 		for (i = 0; i < data->in_num; i++) {
    489. 

  489. 			data->in[i] = w83627ehf_read_value(data,
    490. 

  490. 				      W83627EHF_REG_IN(i));
    491. 

  491. 			data->in_min[i] = w83627ehf_read_value(data,
    492. 

  492. 					  W83627EHF_REG_IN_MIN(i));
    493. 

  493. 			data->in_max[i] = w83627ehf_read_value(data,
    494. 

  494. 					  W83627EHF_REG_IN_MAX(i));
    495. 

  495. 		}
    496. 

  496. 

  497. 		/* Measured fan speeds and limits */
    498. 

  498. 		for (i = 0; i < 5; i++) {
    499. 

  499. 			if (!(data->has_fan & (1 << i)))
    500. 

  500. 				continue;
    501. 

  501. 

  502. 			data->fan[i] = w83627ehf_read_value(data,
    503. 

  503. 				       W83627EHF_REG_FAN[i]);
    504. 

  504. 			data->fan_min[i] = w83627ehf_read_value(data,
    505. 

  505. 					   W83627EHF_REG_FAN_MIN[i]);
    506. 

  506. 

  507. 			/* If we failed to measure the fan speed and clock
    508. 

  508. 			   divider can be increased, let's try that for next
    509. 

  509. 			   time */
    510. 

  510. 			if (data->fan[i] == 0xff
    511. 

  511. 			 && data->fan_div[i] < 0x07) {
    512. 

  512. 			 	dev_dbg(dev, "Increasing fan%d "
    513. 

  513. 					"clock divider from %u to %u\n",
    514. 

  514. 					i + 1, div_from_reg(data->fan_div[i]),
    515. 

  515. 					div_from_reg(data->fan_div[i] + 1));
    516. 

  516. 				data->fan_div[i]++;
    517. 

  517. 				w83627ehf_write_fan_div(data, i);
    518. 

  518. 				/* Preserve min limit if possible */
    519. 

  519. 				if (data->fan_min[i] >= 2
    520. 

  520. 				 && data->fan_min[i] != 255)
    521. 

  521. 					w83627ehf_write_value(data,
    522. 

  522. 						W83627EHF_REG_FAN_MIN[i],
    523. 

  523. 						(data->fan_min[i] /= 2));
    524. 

  524. 			}
    525. 

  525. 		}
    526. 

  526. 

  527. 		for (i = 0; i < 4; i++) {
    528. 

  528. 			/* pwmcfg, tolerance mapped for i=0, i=1 to same reg */
    529. 

  529. 			if (i != 1) {
    530. 

  530. 				pwmcfg = w83627ehf_read_value(data,
    531. 

  531. 						W83627EHF_REG_PWM_ENABLE[i]);
    532. 

  532. 				tolerance = w83627ehf_read_value(data,
    533. 

  533. 						W83627EHF_REG_TOLERANCE[i]);
    534. 

  534. 			}
    535. 

  535. 			data->pwm_mode[i] =
    536. 

  536. 				((pwmcfg >> W83627EHF_PWM_MODE_SHIFT[i]) & 1)
    537. 

  537. 				? 0 : 1;
    538. 

  538. 			data->pwm_enable[i] =
    539. 

  539. 					((pwmcfg >> W83627EHF_PWM_ENABLE_SHIFT[i])
    540. 

  540. 						& 3) + 1;
    541. 

  541. 			data->pwm[i] = w83627ehf_read_value(data,
    542. 

  542. 						W83627EHF_REG_PWM[i]);
    543. 

  543. 			data->fan_start_output[i] = w83627ehf_read_value(data,
    544. 

  544. 						W83627EHF_REG_FAN_START_OUTPUT[i]);
    545. 

  545. 			data->fan_stop_output[i] = w83627ehf_read_value(data,
    546. 

  546. 						W83627EHF_REG_FAN_STOP_OUTPUT[i]);
    547. 

  547. 			data->fan_stop_time[i] = w83627ehf_read_value(data,
    548. 

  548. 						W83627EHF_REG_FAN_STOP_TIME[i]);
    549. 

  549. 			data->target_temp[i] =
    550. 

  550. 				w83627ehf_read_value(data,
    551. 

  551. 					W83627EHF_REG_TARGET[i]) &
    552. 

  552. 					(data->pwm_mode[i] == 1 ? 0x7f : 0xff);
    553. 

  553. 			data->tolerance[i] = (tolerance >> (i == 1 ? 4 : 0))
    554. 

  554. 									& 0x0f;
    555. 

  555. 		}
    556. 

  556. 

  557. 		/* Measured temperatures and limits */
    558. 

  558. 		data->temp1 = w83627ehf_read_value(data,
    559. 

  559. 			      W83627EHF_REG_TEMP1);
    560. 

  560. 		data->temp1_max = w83627ehf_read_value(data,
    561. 

  561. 				  W83627EHF_REG_TEMP1_OVER);
    562. 

  562. 		data->temp1_max_hyst = w83627ehf_read_value(data,
    563. 

  563. 				       W83627EHF_REG_TEMP1_HYST);
    564. 

  564. 		for (i = 0; i < 2; i++) {
    565. 

  565. 			data->temp[i] = w83627ehf_read_value(data,
    566. 

  566. 					W83627EHF_REG_TEMP[i]);
    567. 

  567. 			data->temp_max[i] = w83627ehf_read_value(data,
    568. 

  568. 					    W83627EHF_REG_TEMP_OVER[i]);
    569. 

  569. 			data->temp_max_hyst[i] = w83627ehf_read_value(data,
    570. 

  570. 						 W83627EHF_REG_TEMP_HYST[i]);
    571. 

  571. 		}
    572. 

  572. 

  573. 		data->alarms = w83627ehf_read_value(data,
    574. 

  574. 					W83627EHF_REG_ALARM1) |
    575. 

  575. 			       (w83627ehf_read_value(data,
    576. 

  576. 					W83627EHF_REG_ALARM2) << 8) |
    577. 

  577. 			       (w83627ehf_read_value(data,
    578. 

  578. 					W83627EHF_REG_ALARM3) << 16);
    579. 

  579. 

  580. 		data->last_updated = jiffies;
    581. 

  581. 		data->valid = 1;
    582. 

  582. 	}
    583. 

  583. 

  584. 	mutex_unlock(&data->update_lock);
    585. 

  585. 	return data;
    586. 

  586. }
    587. 

  587. 

  588. /*
    589. 

  589.  * Sysfs callback functions
    590. 

  590.  */
    591. 

  591. #define show_in_reg(reg) \
    592. 

  592. static ssize_t \
    593. 

  593. show_##reg(struct device *dev, struct device_attribute *attr, \
    594. 

  594. 	   char *buf) \
    595. 

  595. { \
    596. 

  596. 	struct w83627ehf_data *data = w83627ehf_update_device(dev); \
    597. 

  597. 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
    598. 

  598. 	int nr = sensor_attr->index; \
    599. 

  599. 	return sprintf(buf, "%ld\n", in_from_reg(data->reg[nr], nr)); \
    600. 

  600. }
    601. 

  601. show_in_reg(in)
    602. 

  602. show_in_reg(in_min)
    603. 

  603. show_in_reg(in_max)
    604. 

  604. 

  605. #define store_in_reg(REG, reg) \
    606. 

  606. static ssize_t \
    607. 

  607. store_in_##reg (struct device *dev, struct device_attribute *attr, \
    608. 

  608. 			const char *buf, size_t count) \
    609. 

  609. { \
    610. 

  610. 	struct w83627ehf_data *data = dev_get_drvdata(dev); \
    611. 

  611. 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
    612. 

  612. 	int nr = sensor_attr->index; \
    613. 

  613. 	u32 val = simple_strtoul(buf, NULL, 10); \
    614. 

  614.  \
    615. 

  615. 	mutex_lock(&data->update_lock); \
    616. 

  616. 	data->in_##reg[nr] = in_to_reg(val, nr); \
    617. 

  617. 	w83627ehf_write_value(data, W83627EHF_REG_IN_##REG(nr), \
    618. 

  618. 			      data->in_##reg[nr]); \
    619. 

  619. 	mutex_unlock(&data->update_lock); \
    620. 

  620. 	return count; \
    621. 

  621. }
    622. 

  622. 

  623. store_in_reg(MIN, min)
    624. 

  624. store_in_reg(MAX, max)
    625. 

  625. 

  626. static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, char *buf)
    627. 

  627. {
    628. 

  628. 	struct w83627ehf_data *data = w83627ehf_update_device(dev);
    629. 

  629. 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
    630. 

  630. 	int nr = sensor_attr->index;
    631. 

  631. 	return sprintf(buf, "%u\n", (data->alarms >> nr) & 0x01);
    632. 

  632. }
    633. 

  633. 

  634. static struct sensor_device_attribute sda_in_input[] = {
    635. 

  635. 	SENSOR_ATTR(in0_input, S_IRUGO, show_in, NULL, 0),
    636. 

  636. 	SENSOR_ATTR(in1_input, S_IRUGO, show_in, NULL, 1),
    637. 

  637. 	SENSOR_ATTR(in2_input, S_IRUGO, show_in, NULL, 2),
    638. 

  638. 	SENSOR_ATTR(in3_input, S_IRUGO, show_in, NULL, 3),
    639. 

  639. 	SENSOR_ATTR(in4_input, S_IRUGO, show_in, NULL, 4),
    640. 

  640. 	SENSOR_ATTR(in5_input, S_IRUGO, show_in, NULL, 5),
    641. 

  641. 	SENSOR_ATTR(in6_input, S_IRUGO, show_in, NULL, 6),
    642. 

  642. 	SENSOR_ATTR(in7_input, S_IRUGO, show_in, NULL, 7),
    643. 

  643. 	SENSOR_ATTR(in8_input, S_IRUGO, show_in, NULL, 8),
    644. 

  644. 	SENSOR_ATTR(in9_input, S_IRUGO, show_in, NULL, 9),
    645. 

  645. };
    646. 

  646. 

  647. static struct sensor_device_attribute sda_in_alarm[] = {
    648. 

  648. 	SENSOR_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0),
    649. 

  649. 	SENSOR_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1),
    650. 

  650. 	SENSOR_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2),
    651. 

  651. 	SENSOR_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3),
    652. 

  652. 	SENSOR_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8),
    653. 

  653. 	SENSOR_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 21),
    654. 

  654. 	SENSOR_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 20),
    655. 

  655. 	SENSOR_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 16),
    656. 

  656. 	SENSOR_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 17),
    657. 

  657. 	SENSOR_ATTR(in9_alarm, S_IRUGO, show_alarm, NULL, 19),
    658. 

  658. };
    659. 

  659. 

  660. static struct sensor_device_attribute sda_in_min[] = {
    661. 

  661.        SENSOR_ATTR(in0_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 0),
    662. 

  662.        SENSOR_ATTR(in1_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 1),
    663. 

  663.        SENSOR_ATTR(in2_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 2),
    664. 

  664.        SENSOR_ATTR(in3_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 3),
    665. 

  665.        SENSOR_ATTR(in4_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 4),
    666. 

  666.        SENSOR_ATTR(in5_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 5),
    667. 

  667.        SENSOR_ATTR(in6_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 6),
    668. 

  668.        SENSOR_ATTR(in7_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 7),
    669. 

  669.        SENSOR_ATTR(in8_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 8),
    670. 

  670.        SENSOR_ATTR(in9_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 9),
    671. 

  671. };
    672. 

  672. 

  673. static struct sensor_device_attribute sda_in_max[] = {
    674. 

  674.        SENSOR_ATTR(in0_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 0),
    675. 

  675.        SENSOR_ATTR(in1_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 1),
    676. 

  676.        SENSOR_ATTR(in2_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 2),
    677. 

  677.        SENSOR_ATTR(in3_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 3),
    678. 

  678.        SENSOR_ATTR(in4_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 4),
    679. 

  679.        SENSOR_ATTR(in5_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 5),
    680. 

  680.        SENSOR_ATTR(in6_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 6),
    681. 

  681.        SENSOR_ATTR(in7_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 7),
    682. 

  682.        SENSOR_ATTR(in8_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 8),
    683. 

  683.        SENSOR_ATTR(in9_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 9),
    684. 

  684. };
    685. 

  685. 

  686. #define show_fan_reg(reg) \
    687. 

  687. static ssize_t \
    688. 

  688. show_##reg(struct device *dev, struct device_attribute *attr, \
    689. 

  689. 	   char *buf) \
    690. 

  690. { \
    691. 

  691. 	struct w83627ehf_data *data = w83627ehf_update_device(dev); \
    692. 

  692. 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
    693. 

  693. 	int nr = sensor_attr->index; \
    694. 

  694. 	return sprintf(buf, "%d\n", \
    695. 

  695. 		       fan_from_reg(data->reg[nr], \
    696. 

  696. 				    div_from_reg(data->fan_div[nr]))); \
    697. 

  697. }
    698. 

  698. show_fan_reg(fan);
    699. 

  699. show_fan_reg(fan_min);
    700. 

  700. 

  701. static ssize_t
    702. 

  702. show_fan_div(struct device *dev, struct device_attribute *attr,
    703. 

  703. 	     char *buf)
    704. 

  704. {
    705. 

  705. 	struct w83627ehf_data *data = w83627ehf_update_device(dev);
    706. 

  706. 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
    707. 

  707. 	int nr = sensor_attr->index;
    708. 

  708. 	return sprintf(buf, "%u\n", div_from_reg(data->fan_div[nr]));
    709. 

  709. }
    710. 

  710. 

  711. static ssize_t
    712. 

  712. store_fan_min(struct device *dev, struct device_attribute *attr,
    713. 

  713. 	      const char *buf, size_t count)
    714. 

  714. {
    715. 

  715. 	struct w83627ehf_data *data = dev_get_drvdata(dev);
    716. 

  716. 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
    717. 

  717. 	int nr = sensor_attr->index;
    718. 

  718. 	unsigned int val = simple_strtoul(buf, NULL, 10);
    719. 

  719. 	unsigned int reg;
    720. 

  720. 	u8 new_div;
    721. 

  721. 

  722. 	mutex_lock(&data->update_lock);
    723. 

  723. 	if (!val) {
    724. 

  724. 		/* No min limit, alarm disabled */
    725. 

  725. 		data->fan_min[nr] = 255;
    726. 

  726. 		new_div = data->fan_div[nr]; /* No change */
    727. 

  727. 		dev_info(dev, "fan%u low limit and alarm disabled\n", nr + 1);
    728. 

  728. 	} else if ((reg = 1350000U / val) >= 128 * 255) {
    729. 

  729. 		/* Speed below this value cannot possibly be represented,
    730. 

  730. 		   even with the highest divider (128) */
    731. 

  731. 		data->fan_min[nr] = 254;
    732. 

  732. 		new_div = 7; /* 128 == (1 << 7) */
    733. 

  733. 		dev_warn(dev, "fan%u low limit %u below minimum %u, set to "
    734. 

  734. 			 "minimum\n", nr + 1, val, fan_from_reg(254, 128));
    735. 

  735. 	} else if (!reg) {
    736. 

  736. 		/* Speed above this value cannot possibly be represented,
    737. 

  737. 		   even with the lowest divider (1) */
    738. 

  738. 		data->fan_min[nr] = 1;
    739. 

  739. 		new_div = 0; /* 1 == (1 << 0) */
    740. 

  740. 		dev_warn(dev, "fan%u low limit %u above maximum %u, set to "
    741. 

  741. 			 "maximum\n", nr + 1, val, fan_from_reg(1, 1));
    742. 

  742. 	} else {
    743. 

  743. 		/* Automatically pick the best divider, i.e. the one such
    744. 

  744. 		   that the min limit will correspond to a register value
    745. 

  745. 		   in the 96..192 range */
    746. 

  746. 		new_div = 0;
    747. 

  747. 		while (reg > 192 && new_div < 7) {
    748. 

  748. 			reg >>= 1;
    749. 

  749. 			new_div++;
    750. 

  750. 		}
    751. 

  751. 		data->fan_min[nr] = reg;
    752. 

  752. 	}
    753. 

  753. 

  754. 	/* Write both the fan clock divider (if it changed) and the new
    755. 

  755. 	   fan min (unconditionally) */
    756. 

  756. 	if (new_div != data->fan_div[nr]) {
    757. 

  757. 		/* Preserve the fan speed reading */
    758. 

  758. 		if (data->fan[nr] != 0xff) {
    759. 

  759. 			if (new_div > data->fan_div[nr])
    760. 

  760. 				data->fan[nr] >>= new_div - data->fan_div[nr];
    761. 

  761. 			else if (data->fan[nr] & 0x80)
    762. 

  762. 				data->fan[nr] = 0xff;
    763. 

  763. 			else
    764. 

  764. 				data->fan[nr] <<= data->fan_div[nr] - new_div;
    765. 

  765. 		}
    766. 

  766. 

  767. 		dev_dbg(dev, "fan%u clock divider changed from %u to %u\n",
    768. 

  768. 			nr + 1, div_from_reg(data->fan_div[nr]),
    769. 

  769. 			div_from_reg(new_div));
    770. 

  770. 		data->fan_div[nr] = new_div;
    771. 

  771. 		w83627ehf_write_fan_div(data, nr);
    772. 

  772. 		/* Give the chip time to sample a new speed value */
    773. 

  773. 		data->last_updated = jiffies;
    774. 

  774. 	}
    775. 

  775. 	w83627ehf_write_value(data, W83627EHF_REG_FAN_MIN[nr],
    776. 

  776. 			      data->fan_min[nr]);
    777. 

  777. 	mutex_unlock(&data->update_lock);
    778. 

  778. 

  779. 	return count;
    780. 

  780. }
    781. 

  781. 

  782. static struct sensor_device_attribute sda_fan_input[] = {
    783. 

  783. 	SENSOR_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0),
    784. 

  784. 	SENSOR_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1),
    785. 

  785. 	SENSOR_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2),
    786. 

  786. 	SENSOR_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3),
    787. 

  787. 	SENSOR_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4),
    788. 

  788. };
    789. 

  789. 

  790. static struct sensor_device_attribute sda_fan_alarm[] = {
    791. 

  791. 	SENSOR_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6),
    792. 

  792. 	SENSOR_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7),
    793. 

  793. 	SENSOR_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11),
    794. 

  794. 	SENSOR_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 10),
    795. 

  795. 	SENSOR_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 23),
    796. 

  796. };
    797. 

  797. 

  798. static struct sensor_device_attribute sda_fan_min[] = {
    799. 

  799. 	SENSOR_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min,
    800. 

  800. 		    store_fan_min, 0),
    801. 

  801. 	SENSOR_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min,
    802. 

  802. 		    store_fan_min, 1),
    803. 

  803. 	SENSOR_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min,
    804. 

  804. 		    store_fan_min, 2),
    805. 

  805. 	SENSOR_ATTR(fan4_min, S_IWUSR | S_IRUGO, show_fan_min,
    806. 

  806. 		    store_fan_min, 3),
    807. 

  807. 	SENSOR_ATTR(fan5_min, S_IWUSR | S_IRUGO, show_fan_min,
    808. 

  808. 		    store_fan_min, 4),
    809. 

  809. };
    810. 

  810. 

  811. static struct sensor_device_attribute sda_fan_div[] = {
    812. 

  812. 	SENSOR_ATTR(fan1_div, S_IRUGO, show_fan_div, NULL, 0),
    813. 

  813. 	SENSOR_ATTR(fan2_div, S_IRUGO, show_fan_div, NULL, 1),
    814. 

  814. 	SENSOR_ATTR(fan3_div, S_IRUGO, show_fan_div, NULL, 2),
    815. 

  815. 	SENSOR_ATTR(fan4_div, S_IRUGO, show_fan_div, NULL, 3),
    816. 

  816. 	SENSOR_ATTR(fan5_div, S_IRUGO, show_fan_div, NULL, 4),
    817. 

  817. };
    818. 

  818. 

  819. #define show_temp1_reg(reg) \
    820. 

  820. static ssize_t \
    821. 

  821. show_##reg(struct device *dev, struct device_attribute *attr, \
    822. 

  822. 	   char *buf) \
    823. 

  823. { \
    824. 

  824. 	struct w83627ehf_data *data = w83627ehf_update_device(dev); \
    825. 

  825. 	return sprintf(buf, "%d\n", temp1_from_reg(data->reg)); \
    826. 

  826. }
    827. 

  827. show_temp1_reg(temp1);
    828. 

  828. show_temp1_reg(temp1_max);
    829. 

  829. show_temp1_reg(temp1_max_hyst);
    830. 

  830. 

  831. #define store_temp1_reg(REG, reg) \
    832. 

  832. static ssize_t \
    833. 

  833. store_temp1_##reg(struct device *dev, struct device_attribute *attr, \
    834. 

  834. 		  const char *buf, size_t count) \
    835. 

  835. { \
    836. 

  836. 	struct w83627ehf_data *data = dev_get_drvdata(dev); \
    837. 

  837. 	long val = simple_strtol(buf, NULL, 10); \
    838. 

  838.  \
    839. 

  839. 	mutex_lock(&data->update_lock); \
    840. 

  840. 	data->temp1_##reg = temp1_to_reg(val, -128000, 127000); \
    841. 

  841. 	w83627ehf_write_value(data, W83627EHF_REG_TEMP1_##REG, \
    842. 

  842. 			      data->temp1_##reg); \
    843. 

  843. 	mutex_unlock(&data->update_lock); \
    844. 

  844. 	return count; \
    845. 

  845. }
    846. 

  846. store_temp1_reg(OVER, max);
    847. 

  847. store_temp1_reg(HYST, max_hyst);
    848. 

  848. 

  849. #define show_temp_reg(reg) \
    850. 

  850. static ssize_t \
    851. 

  851. show_##reg(struct device *dev, struct device_attribute *attr, \
    852. 

  852. 	   char *buf) \
    853. 

  853. { \
    854. 

  854. 	struct w83627ehf_data *data = w83627ehf_update_device(dev); \
    855. 

  855. 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
    856. 

  856. 	int nr = sensor_attr->index; \
    857. 

  857. 	return sprintf(buf, "%d\n", \
    858. 

  858. 		       LM75_TEMP_FROM_REG(data->reg[nr])); \
    859. 

  859. }
    860. 

  860. show_temp_reg(temp);
    861. 

  861. show_temp_reg(temp_max);
    862. 

  862. show_temp_reg(temp_max_hyst);
    863. 

  863. 

  864. #define store_temp_reg(REG, reg) \
    865. 

  865. static ssize_t \
    866. 

  866. store_##reg(struct device *dev, struct device_attribute *attr, \
    867. 

  867. 	    const char *buf, size_t count) \
    868. 

  868. { \
    869. 

  869. 	struct w83627ehf_data *data = dev_get_drvdata(dev); \
    870. 

  870. 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
    871. 

  871. 	int nr = sensor_attr->index; \
    872. 

  872. 	long val = simple_strtol(buf, NULL, 10); \
    873. 

  873.  \
    874. 

  874. 	mutex_lock(&data->update_lock); \
    875. 

  875. 	data->reg[nr] = LM75_TEMP_TO_REG(val); \
    876. 

  876. 	w83627ehf_write_value(data, W83627EHF_REG_TEMP_##REG[nr], \
    877. 

  877. 			      data->reg[nr]); \
    878. 

  878. 	mutex_unlock(&data->update_lock); \
    879. 

  879. 	return count; \
    880. 

  880. }
    881. 

  881. store_temp_reg(OVER, temp_max);
    882. 

  882. store_temp_reg(HYST, temp_max_hyst);
    883. 

  883. 

  884. static ssize_t
    885. 

  885. show_temp_type(struct device *dev, struct device_attribute *attr, char *buf)
    886. 

  886. {
    887. 

  887. 	struct w83627ehf_data *data = w83627ehf_update_device(dev);
    888. 

  888. 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
    889. 

  889. 	int nr = sensor_attr->index;
    890. 

  890. 	return sprintf(buf, "%d\n", (int)data->temp_type[nr]);
    891. 

  891. }
    892. 

  892. 

  893. static struct sensor_device_attribute sda_temp_input[] = {
    894. 

  894. 	SENSOR_ATTR(temp1_input, S_IRUGO, show_temp1, NULL, 0),
    895. 

  895. 	SENSOR_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 0),
    896. 

  896. 	SENSOR_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 1),
    897. 

  897. };
    898. 

  898. 

  899. static struct sensor_device_attribute sda_temp_max[] = {
    900. 

  900. 	SENSOR_ATTR(temp1_max, S_IRUGO | S_IWUSR, show_temp1_max,
    901. 

  901. 		    store_temp1_max, 0),
    902. 

  902. 	SENSOR_ATTR(temp2_max, S_IRUGO | S_IWUSR, show_temp_max,
    903. 

  903. 		    store_temp_max, 0),
    904. 

  904. 	SENSOR_ATTR(temp3_max, S_IRUGO | S_IWUSR, show_temp_max,
    905. 

  905. 		    store_temp_max, 1),
    906. 

  906. };
    907. 

  907. 

  908. static struct sensor_device_attribute sda_temp_max_hyst[] = {
    909. 

  909. 	SENSOR_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR, show_temp1_max_hyst,
    910. 

  910. 		    store_temp1_max_hyst, 0),
    911. 

  911. 	SENSOR_ATTR(temp2_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
    912. 

  912. 		    store_temp_max_hyst, 0),
    913. 

  913. 	SENSOR_ATTR(temp3_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
    914. 

  914. 		    store_temp_max_hyst, 1),
    915. 

  915. };
    916. 

  916. 

  917. static struct sensor_device_attribute sda_temp_alarm[] = {
    918. 

  918. 	SENSOR_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4),
    919. 

  919. 	SENSOR_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5),
    920. 

  920. 	SENSOR_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 13),
    921. 

  921. };
    922. 

  922. 

  923. static struct sensor_device_attribute sda_temp_type[] = {
    924. 

  924. 	SENSOR_ATTR(temp1_type, S_IRUGO, show_temp_type, NULL, 0),
    925. 

  925. 	SENSOR_ATTR(temp2_type, S_IRUGO, show_temp_type, NULL, 1),
    926. 

  926. 	SENSOR_ATTR(temp3_type, S_IRUGO, show_temp_type, NULL, 2),
    927. 

  927. };
    928. 

  928. 

  929. #define show_pwm_reg(reg) \
    930. 

  930. static ssize_t show_##reg (struct device *dev, struct device_attribute *attr, \
    931. 

  931. 				char *buf) \
    932. 

  932. { \
    933. 

  933. 	struct w83627ehf_data *data = w83627ehf_update_device(dev); \
    934. 

  934. 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
    935. 

  935. 	int nr = sensor_attr->index; \
    936. 

  936. 	return sprintf(buf, "%d\n", data->reg[nr]); \
    937. 

  937. }
    938. 

  938. 

  939. show_pwm_reg(pwm_mode)
    940. 

  940. show_pwm_reg(pwm_enable)
    941. 

  941. show_pwm_reg(pwm)
    942. 

  942. 

  943. static ssize_t
    944. 

  944. store_pwm_mode(struct device *dev, struct device_attribute *attr,
    945. 

  945. 			const char *buf, size_t count)
    946. 

  946. {
    947. 

  947. 	struct w83627ehf_data *data = dev_get_drvdata(dev);
    948. 

  948. 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
    949. 

  949. 	int nr = sensor_attr->index;
    950. 

  950. 	u32 val = simple_strtoul(buf, NULL, 10);
    951. 

  951. 	u16 reg;
    952. 

  952. 

  953. 	if (val > 1)
    954. 

  954. 		return -EINVAL;
    955. 

  955. 	mutex_lock(&data->update_lock);
    956. 

  956. 	reg = w83627ehf_read_value(data, W83627EHF_REG_PWM_ENABLE[nr]);
    957. 

  957. 	data->pwm_mode[nr] = val;
    958. 

  958. 	reg &= ~(1 << W83627EHF_PWM_MODE_SHIFT[nr]);
    959. 

  959. 	if (!val)
    960. 

  960. 		reg |= 1 << W83627EHF_PWM_MODE_SHIFT[nr];
    961. 

  961. 	w83627ehf_write_value(data, W83627EHF_REG_PWM_ENABLE[nr], reg);
    962. 

  962. 	mutex_unlock(&data->update_lock);
    963. 

  963. 	return count;
    964. 

  964. }
    965. 

  965. 

  966. static ssize_t
    967. 

  967. store_pwm(struct device *dev, struct device_attribute *attr,
    968. 

  968. 			const char *buf, size_t count)
    969. 

  969. {
    970. 

  970. 	struct w83627ehf_data *data = dev_get_drvdata(dev);
    971. 

  971. 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
    972. 

  972. 	int nr = sensor_attr->index;
    973. 

  973. 	u32 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 0, 255);
    974. 

  974. 

  975. 	mutex_lock(&data->update_lock);
    976. 

  976. 	data->pwm[nr] = val;
    977. 

  977. 	w83627ehf_write_value(data, W83627EHF_REG_PWM[nr], val);
    978. 

  978. 	mutex_unlock(&data->update_lock);
    979. 

  979. 	return count;
    980. 

  980. }
    981. 

  981. 

  982. static ssize_t
    983. 

  983. store_pwm_enable(struct device *dev, struct device_attribute *attr,
    984. 

  984. 			const char *buf, size_t count)
    985. 

  985. {
    986. 

  986. 	struct w83627ehf_data *data = dev_get_drvdata(dev);
    987. 

  987. 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
    988. 

  988. 	int nr = sensor_attr->index;
    989. 

  989. 	u32 val = simple_strtoul(buf, NULL, 10);
    990. 

  990. 	u16 reg;
    991. 

  991. 

  992. 	if (!val || (val > 4))
    993. 

  993. 		return -EINVAL;
    994. 

  994. 	mutex_lock(&data->update_lock);
    995. 

  995. 	reg = w83627ehf_read_value(data, W83627EHF_REG_PWM_ENABLE[nr]);
    996. 

  996. 	data->pwm_enable[nr] = val;
    997. 

  997. 	reg &= ~(0x03 << W83627EHF_PWM_ENABLE_SHIFT[nr]);
    998. 

  998. 	reg |= (val - 1) << W83627EHF_PWM_ENABLE_SHIFT[nr];
    999. 

  999. 	w83627ehf_write_value(data, W83627EHF_REG_PWM_ENABLE[nr], reg);
    1000. 

  1000. 	mutex_unlock(&data->update_lock);
    1001. 

  1001. 	return count;
    1002. 

  1002. }
    1003. 

  1003. 

  1004. 

  1005. #define show_tol_temp(reg) \
    1006. 

  1006. static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
    1007. 

  1007. 				char *buf) \
    1008. 

  1008. { \
    1009. 

  1009. 	struct w83627ehf_data *data = w83627ehf_update_device(dev); \
    1010. 

  1010. 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
    1011. 

  1011. 	int nr = sensor_attr->index; \
    1012. 

  1012. 	return sprintf(buf, "%d\n", temp1_from_reg(data->reg[nr])); \
    1013. 

  1013. }
    1014. 

  1014. 

  1015. show_tol_temp(tolerance)
    1016. 

  1016. show_tol_temp(target_temp)
    1017. 

  1017. 

  1018. static ssize_t
    1019. 

  1019. store_target_temp(struct device *dev, struct device_attribute *attr,
    1020. 

  1020. 			const char *buf, size_t count)
    1021. 

  1021. {
    1022. 

  1022. 	struct w83627ehf_data *data = dev_get_drvdata(dev);
    1023. 

  1023. 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
    1024. 

  1024. 	int nr = sensor_attr->index;
    1025. 

  1025. 	u8 val = temp1_to_reg(simple_strtoul(buf, NULL, 10), 0, 127000);
    1026. 

  1026. 

  1027. 	mutex_lock(&data->update_lock);
    1028. 

  1028. 	data->target_temp[nr] = val;
    1029. 

  1029. 	w83627ehf_write_value(data, W83627EHF_REG_TARGET[nr], val);
    1030. 

  1030. 	mutex_unlock(&data->update_lock);
    1031. 

  1031. 	return count;
    1032. 

  1032. }
    1033. 

  1033. 

  1034. static ssize_t
    1035. 

  1035. store_tolerance(struct device *dev, struct device_attribute *attr,
    1036. 

  1036. 			const char *buf, size_t count)
    1037. 

  1037. {
    1038. 

  1038. 	struct w83627ehf_data *data = dev_get_drvdata(dev);
    1039. 

  1039. 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
    1040. 

  1040. 	int nr = sensor_attr->index;
    1041. 

  1041. 	u16 reg;
    1042. 

  1042. 	/* Limit the temp to 0C - 15C */
    1043. 

  1043. 	u8 val = temp1_to_reg(simple_strtoul(buf, NULL, 10), 0, 15000);
    1044. 

  1044. 

  1045. 	mutex_lock(&data->update_lock);
    1046. 

  1046. 	reg = w83627ehf_read_value(data, W83627EHF_REG_TOLERANCE[nr]);
    1047. 

  1047. 	data->tolerance[nr] = val;
    1048. 

  1048. 	if (nr == 1)
    1049. 

  1049. 		reg = (reg & 0x0f) | (val << 4);
    1050. 

  1050. 	else
    1051. 

  1051. 		reg = (reg & 0xf0) | val;
    1052. 

  1052. 	w83627ehf_write_value(data, W83627EHF_REG_TOLERANCE[nr], reg);
    1053. 

  1053. 	mutex_unlock(&data->update_lock);
    1054. 

  1054. 	return count;
    1055. 

  1055. }
    1056. 

  1056. 

  1057. static struct sensor_device_attribute sda_pwm[] = {
    1058. 

  1058. 	SENSOR_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 0),
    1059. 

  1059. 	SENSOR_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 1),
    1060. 

  1060. 	SENSOR_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 2),
    1061. 

  1061. 	SENSOR_ATTR(pwm4, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 3),
    1062. 

  1062. };
    1063. 

  1063. 

  1064. static struct sensor_device_attribute sda_pwm_mode[] = {
    1065. 

  1065. 	SENSOR_ATTR(pwm1_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
    1066. 

  1066. 		    store_pwm_mode, 0),
    1067. 

  1067. 	SENSOR_ATTR(pwm2_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
    1068. 

  1068. 		    store_pwm_mode, 1),
    1069. 

  1069. 	SENSOR_ATTR(pwm3_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
    1070. 

  1070. 		    store_pwm_mode, 2),
    1071. 

  1071. 	SENSOR_ATTR(pwm4_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
    1072. 

  1072. 		    store_pwm_mode, 3),
    1073. 

  1073. };
    1074. 

  1074. 

  1075. static struct sensor_device_attribute sda_pwm_enable[] = {
    1076. 

  1076. 	SENSOR_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
    1077. 

  1077. 		    store_pwm_enable, 0),
    1078. 

  1078. 	SENSOR_ATTR(pwm2_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
    1079. 

  1079. 		    store_pwm_enable, 1),
    1080. 

  1080. 	SENSOR_ATTR(pwm3_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
    1081. 

  1081. 		    store_pwm_enable, 2),
    1082. 

  1082. 	SENSOR_ATTR(pwm4_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
    1083. 

  1083. 		    store_pwm_enable, 3),
    1084. 

  1084. };
    1085. 

  1085. 

  1086. static struct sensor_device_attribute sda_target_temp[] = {
    1087. 

  1087. 	SENSOR_ATTR(pwm1_target, S_IWUSR | S_IRUGO, show_target_temp,
    1088. 

  1088. 		    store_target_temp, 0),
    1089. 

  1089. 	SENSOR_ATTR(pwm2_target, S_IWUSR | S_IRUGO, show_target_temp,
    1090. 

  1090. 		    store_target_temp, 1),
    1091. 

  1091. 	SENSOR_ATTR(pwm3_target, S_IWUSR | S_IRUGO, show_target_temp,
    1092. 

  1092. 		    store_target_temp, 2),
    1093. 

  1093. 	SENSOR_ATTR(pwm4_target, S_IWUSR | S_IRUGO, show_target_temp,
    1094. 

  1094. 		    store_target_temp, 3),
    1095. 

  1095. };
    1096. 

  1096. 

  1097. static struct sensor_device_attribute sda_tolerance[] = {
    1098. 

  1098. 	SENSOR_ATTR(pwm1_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
    1099. 

  1099. 		    store_tolerance, 0),
    1100. 

  1100. 	SENSOR_ATTR(pwm2_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
    1101. 

  1101. 		    store_tolerance, 1),
    1102. 

  1102. 	SENSOR_ATTR(pwm3_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
    1103. 

  1103. 		    store_tolerance, 2),
    1104. 

  1104. 	SENSOR_ATTR(pwm4_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
    1105. 

  1105. 		    store_tolerance, 3),
    1106. 

  1106. };
    1107. 

  1107. 

  1108. /* Smart Fan registers */
    1109. 

  1109. 

  1110. #define fan_functions(reg, REG) \
    1111. 

  1111. static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
    1112. 

  1112. 		       char *buf) \
    1113. 

  1113. { \
    1114. 

  1114. 	struct w83627ehf_data *data = w83627ehf_update_device(dev); \
    1115. 

  1115. 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
    1116. 

  1116. 	int nr = sensor_attr->index; \
    1117. 

  1117. 	return sprintf(buf, "%d\n", data->reg[nr]); \
    1118. 

  1118. }\
    1119. 

  1119. static ssize_t \
    1120. 

  1120. store_##reg(struct device *dev, struct device_attribute *attr, \
    1121. 

  1121. 			    const char *buf, size_t count) \
    1122. 

  1122. {\
    1123. 

  1123. 	struct w83627ehf_data *data = dev_get_drvdata(dev); \
    1124. 

  1124. 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
    1125. 

  1125. 	int nr = sensor_attr->index; \
    1126. 

  1126. 	u32 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 1, 255); \
    1127. 

  1127. 	mutex_lock(&data->update_lock); \
    1128. 

  1128. 	data->reg[nr] = val; \
    1129. 

  1129. 	w83627ehf_write_value(data, W83627EHF_REG_##REG[nr], val); \
    1130. 

  1130. 	mutex_unlock(&data->update_lock); \
    1131. 

  1131. 	return count; \
    1132. 

  1132. }
    1133. 

  1133. 

  1134. fan_functions(fan_start_output, FAN_START_OUTPUT)
    1135. 

  1135. fan_functions(fan_stop_output, FAN_STOP_OUTPUT)
    1136. 

  1136. fan_functions(fan_max_output, FAN_MAX_OUTPUT)
    1137. 

  1137. fan_functions(fan_step_output, FAN_STEP_OUTPUT)
    1138. 

  1138. 

  1139. #define fan_time_functions(reg, REG) \
    1140. 

  1140. static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
    1141. 

  1141. 				char *buf) \
    1142. 

  1142. { \
    1143. 

  1143. 	struct w83627ehf_data *data = w83627ehf_update_device(dev); \
    1144. 

  1144. 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
    1145. 

  1145. 	int nr = sensor_attr->index; \
    1146. 

  1146. 	return sprintf(buf, "%d\n", \
    1147. 

  1147. 			step_time_from_reg(data->reg[nr], data->pwm_mode[nr])); \
    1148. 

  1148. } \
    1149. 

  1149. \
    1150. 

  1150. static ssize_t \
    1151. 

  1151. store_##reg(struct device *dev, struct device_attribute *attr, \
    1152. 

  1152. 			const char *buf, size_t count) \
    1153. 

  1153. { \
    1154. 

  1154. 	struct w83627ehf_data *data = dev_get_drvdata(dev); \
    1155. 

  1155. 	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
    1156. 

  1156. 	int nr = sensor_attr->index; \
    1157. 

  1157. 	u8 val = step_time_to_reg(simple_strtoul(buf, NULL, 10), \
    1158. 

  1158. 					data->pwm_mode[nr]); \
    1159. 

  1159. 	mutex_lock(&data->update_lock); \
    1160. 

  1160. 	data->reg[nr] = val; \
    1161. 

  1161. 	w83627ehf_write_value(data, W83627EHF_REG_##REG[nr], val); \
    1162. 

  1162. 	mutex_unlock(&data->update_lock); \
    1163. 

  1163. 	return count; \
    1164. 

  1164. } \
    1165. 

  1165. 

  1166. fan_time_functions(fan_stop_time, FAN_STOP_TIME)
    1167. 

  1167. 

  1168. static ssize_t show_name(struct device *dev, struct device_attribute *attr,
    1169. 

  1169. 			 char *buf)
    1170. 

  1170. {
    1171. 

  1171. 	struct w83627ehf_data *data = dev_get_drvdata(dev);
    1172. 

  1172. 

  1173. 	return sprintf(buf, "%s\n", data->name);
    1174. 

  1174. }
    1175. 

  1175. static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
    1176. 

  1176. 

  1177. static struct sensor_device_attribute sda_sf3_arrays_fan4[] = {
    1178. 

  1178. 	SENSOR_ATTR(pwm4_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
    1179. 

  1179. 		    store_fan_stop_time, 3),
    1180. 

  1180. 	SENSOR_ATTR(pwm4_start_output, S_IWUSR | S_IRUGO, show_fan_start_output,
    1181. 

  1181. 		    store_fan_start_output, 3),
    1182. 

  1182. 	SENSOR_ATTR(pwm4_stop_output, S_IWUSR | S_IRUGO, show_fan_stop_output,
    1183. 

  1183. 		    store_fan_stop_output, 3),
    1184. 

  1184. 	SENSOR_ATTR(pwm4_max_output, S_IWUSR | S_IRUGO, show_fan_max_output,
    1185. 

  1185. 		    store_fan_max_output, 3),
    1186. 

  1186. 	SENSOR_ATTR(pwm4_step_output, S_IWUSR | S_IRUGO, show_fan_step_output,
    1187. 

  1187. 		    store_fan_step_output, 3),
    1188. 

  1188. };
    1189. 

  1189. 

  1190. static struct sensor_device_attribute sda_sf3_arrays[] = {
    1191. 

  1191. 	SENSOR_ATTR(pwm1_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
    1192. 

  1192. 		    store_fan_stop_time, 0),
    1193. 

  1193. 	SENSOR_ATTR(pwm2_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
    1194. 

  1194. 		    store_fan_stop_time, 1),
    1195. 

  1195. 	SENSOR_ATTR(pwm3_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
    1196. 

  1196. 		    store_fan_stop_time, 2),
    1197. 

  1197. 	SENSOR_ATTR(pwm1_start_output, S_IWUSR | S_IRUGO, show_fan_start_output,
    1198. 

  1198. 		    store_fan_start_output, 0),
    1199. 

  1199. 	SENSOR_ATTR(pwm2_start_output, S_IWUSR | S_IRUGO, show_fan_start_output,
    1200. 

  1200. 		    store_fan_start_output, 1),
    1201. 

  1201. 	SENSOR_ATTR(pwm3_start_output, S_IWUSR | S_IRUGO, show_fan_start_output,
    1202. 

  1202. 		    store_fan_start_output, 2),
    1203. 

  1203. 	SENSOR_ATTR(pwm1_stop_output, S_IWUSR | S_IRUGO, show_fan_stop_output,
    1204. 

  1204. 		    store_fan_stop_output, 0),
    1205. 

  1205. 	SENSOR_ATTR(pwm2_stop_output, S_IWUSR | S_IRUGO, show_fan_stop_output,
    1206. 

  1206. 		    store_fan_stop_output, 1),
    1207. 

  1207. 	SENSOR_ATTR(pwm3_stop_output, S_IWUSR | S_IRUGO, show_fan_stop_output,
    1208. 

  1208. 		    store_fan_stop_output, 2),
    1209. 

  1209. 

  1210. 	/* pwm1 and pwm3 don't support max and step settings */
    1211. 

  1211. 	SENSOR_ATTR(pwm2_max_output, S_IWUSR | S_IRUGO, show_fan_max_output,
    1212. 

  1212. 		    store_fan_max_output, 1),
    1213. 

  1213. 	SENSOR_ATTR(pwm2_step_output, S_IWUSR | S_IRUGO, show_fan_step_output,
    1214. 

  1214. 		    store_fan_step_output, 1),
    1215. 

  1215. };
    1216. 

  1216. 

  1217. static ssize_t
    1218. 

  1218. show_vid(struct device *dev, struct device_attribute *attr, char *buf)
    1219. 

  1219. {
    1220. 

  1220. 	struct w83627ehf_data *data = dev_get_drvdata(dev);
    1221. 

  1221. 	return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
    1222. 

  1222. }
    1223. 

  1223. static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
    1224. 

  1224. 

  1225. /*
    1226. 

  1226.  * Driver and device management
    1227. 

  1227.  */
    1228. 

  1228. 

  1229. static void w83627ehf_device_remove_files(struct device *dev)
    1230. 

  1230. {
    1231. 

  1231. 	/* some entries in the following arrays may not have been used in
    1232. 

  1232. 	 * device_create_file(), but device_remove_file() will ignore them */
    1233. 

  1233. 	int i;
    1234. 

  1234. 	struct w83627ehf_data *data = dev_get_drvdata(dev);
    1235. 

  1235. 

  1236. 	for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays); i++)
    1237. 

  1237. 		device_remove_file(dev, &sda_sf3_arrays[i].dev_attr);
    1238. 

  1238. 	for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays_fan4); i++)
    1239. 

  1239. 		device_remove_file(dev, &sda_sf3_arrays_fan4[i].dev_attr);
    1240. 

  1240. 	for (i = 0; i < data->in_num; i++) {
    1241. 

  1241. 		if ((i == 6) && data->in6_skip)
    1242. 

  1242. 			continue;
    1243. 

  1243. 		device_remove_file(dev, &sda_in_input[i].dev_attr);
    1244. 

  1244. 		device_remove_file(dev, &sda_in_alarm[i].dev_attr);
    1245. 

  1245. 		device_remove_file(dev, &sda_in_min[i].dev_attr);
    1246. 

  1246. 		device_remove_file(dev, &sda_in_max[i].dev_attr);
    1247. 

  1247. 	}
    1248. 

  1248. 	for (i = 0; i < 5; i++) {
    1249. 

  1249. 		device_remove_file(dev, &sda_fan_input[i].dev_attr);
    1250. 

  1250. 		device_remove_file(dev, &sda_fan_alarm[i].dev_attr);
    1251. 

  1251. 		device_remove_file(dev, &sda_fan_div[i].dev_attr);
    1252. 

  1252. 		device_remove_file(dev, &sda_fan_min[i].dev_attr);
    1253. 

  1253. 	}
    1254. 

  1254. 	for (i = 0; i < data->pwm_num; i++) {
    1255. 

  1255. 		device_remove_file(dev, &sda_pwm[i].dev_attr);
    1256. 

  1256. 		device_remove_file(dev, &sda_pwm_mode[i].dev_attr);
    1257. 

  1257. 		device_remove_file(dev, &sda_pwm_enable[i].dev_attr);
    1258. 

  1258. 		device_remove_file(dev, &sda_target_temp[i].dev_attr);
    1259. 

  1259. 		device_remove_file(dev, &sda_tolerance[i].dev_attr);
    1260. 

  1260. 	}
    1261. 

  1261. 	for (i = 0; i < 3; i++) {
    1262. 

  1262. 		if ((i == 2) && data->temp3_disable)
    1263. 

  1263. 			continue;
    1264. 

  1264. 		device_remove_file(dev, &sda_temp_input[i].dev_attr);
    1265. 

  1265. 		device_remove_file(dev, &sda_temp_max[i].dev_attr);
    1266. 

  1266. 		device_remove_file(dev, &sda_temp_max_hyst[i].dev_attr);
    1267. 

  1267. 		device_remove_file(dev, &sda_temp_alarm[i].dev_attr);
    1268. 

  1268. 		device_remove_file(dev, &sda_temp_type[i].dev_attr);
    1269. 

  1269. 	}
    1270. 

  1270. 

  1271. 	device_remove_file(dev, &dev_attr_name);
    1272. 

  1272. 	device_remove_file(dev, &dev_attr_cpu0_vid);
    1273. 

  1273. }
    1274. 

  1274. 

  1275. /* Get the monitoring functions started */
    1276. 

  1276. static inline void __devinit w83627ehf_init_device(struct w83627ehf_data *data)
    1277. 

  1277. {
    1278. 

  1278. 	int i;
    1279. 

  1279. 	u8 tmp, diode;
    1280. 

  1280. 

  1281. 	/* Start monitoring is needed */
    1282. 

  1282. 	tmp = w83627ehf_read_value(data, W83627EHF_REG_CONFIG);
    1283. 

  1283. 	if (!(tmp & 0x01))
    1284. 

  1284. 		w83627ehf_write_value(data, W83627EHF_REG_CONFIG,
    1285. 

  1285. 				      tmp | 0x01);
    1286. 

  1286. 

  1287. 	/* Enable temp2 and temp3 if needed */
    1288. 

  1288. 	for (i = 0; i < 2; i++) {
    1289. 

  1289. 		tmp = w83627ehf_read_value(data,
    1290. 

  1290. 					   W83627EHF_REG_TEMP_CONFIG[i]);
    1291. 

  1291. 		if ((i == 1) && data->temp3_disable)
    1292. 

  1292. 			continue;
    1293. 

  1293. 		if (tmp & 0x01)
    1294. 

  1294. 			w83627ehf_write_value(data,
    1295. 

  1295. 					      W83627EHF_REG_TEMP_CONFIG[i],
    1296. 

  1296. 					      tmp & 0xfe);
    1297. 

  1297. 	}
    1298. 

  1298. 

  1299. 	/* Enable VBAT monitoring if needed */
    1300. 

  1300. 	tmp = w83627ehf_read_value(data, W83627EHF_REG_VBAT);
    1301. 

  1301. 	if (!(tmp & 0x01))
    1302. 

  1302. 		w83627ehf_write_value(data, W83627EHF_REG_VBAT, tmp | 0x01);
    1303. 

  1303. 

  1304. 	/* Get thermal sensor types */
    1305. 

  1305. 	diode = w83627ehf_read_value(data, W83627EHF_REG_DIODE);
    1306. 

  1306. 	for (i = 0; i < 3; i++) {
    1307. 

  1307. 		if ((tmp & (0x02 << i)))
    1308. 

  1308. 			data->temp_type[i] = (diode & (0x10 << i)) ? 1 : 2;
    1309. 

  1309. 		else
    1310. 

  1310. 			data->temp_type[i] = 4; /* thermistor */
    1311. 

  1311. 	}
    1312. 

  1312. }
    1313. 

  1313. 

  1314. static int __devinit w83627ehf_probe(struct platform_device *pdev)
    1315. 

  1315. {
    1316. 

  1316. 	struct device *dev = &pdev->dev;
    1317. 

  1317. 	struct w83627ehf_sio_data *sio_data = dev->platform_data;
    1318. 

  1318. 	struct w83627ehf_data *data;
    1319. 

  1319. 	struct resource *res;
    1320. 

  1320. 	u8 fan4pin, fan5pin, en_vrm10;
    1321. 

  1321. 	int i, err = 0;
    1322. 

  1322. 

  1323. 	res = platform_get_resource(pdev, IORESOURCE_IO, 0);
    1324. 

  1324. 	if (!request_region(res->start, IOREGION_LENGTH, DRVNAME)) {
    1325. 

  1325. 		err = -EBUSY;
    1326. 

  1326. 		dev_err(dev, "Failed to request region 0x%lx-0x%lx\n",
    1327. 

  1327. 			(unsigned long)res->start,
    1328. 

  1328. 			(unsigned long)res->start + IOREGION_LENGTH - 1);
    1329. 

  1329. 		goto exit;
    1330. 

  1330. 	}
    1331. 

  1331. 

  1332. 	if (!(data = kzalloc(sizeof(struct w83627ehf_data), GFP_KERNEL))) {
    1333. 

  1333. 		err = -ENOMEM;
    1334. 

  1334. 		goto exit_release;
    1335. 

  1335. 	}
    1336. 

  1336. 

  1337. 	data->addr = res->start;
    1338. 

  1338. 	mutex_init(&data->lock);
    1339. 

  1339. 	mutex_init(&data->update_lock);
    1340. 

  1340. 	data->name = w83627ehf_device_names[sio_data->kind];
    1341. 

  1341. 	platform_set_drvdata(pdev, data);
    1342. 

  1342. 

  1343. 	/* 627EHG and 627EHF have 10 voltage inputs; 627DHG and 667HG have 9 */
    1344. 

  1344. 	data->in_num = (sio_data->kind == w83627ehf) ? 10 : 9;
    1345. 

  1345. 	/* 667HG has 3 pwms */
    1346. 

  1346. 	data->pwm_num = (sio_data->kind == w83667hg) ? 3 : 4;
    1347. 

  1347. 

  1348. 	/* Check temp3 configuration bit for 667HG */
    1349. 

  1349. 	if (sio_data->kind == w83667hg) {
    1350. 

  1350. 		data->temp3_disable = w83627ehf_read_value(data,
    1351. 

  1351. 					W83627EHF_REG_TEMP_CONFIG[1]) & 0x01;
    1352. 

  1352. 		data->in6_skip = !data->temp3_disable;
    1353. 

  1353. 	}
    1354. 

  1354. 

  1355. 	/* Initialize the chip */
    1356. 

  1356. 	w83627ehf_init_device(data);
    1357. 

  1357. 

  1358. 	data->vrm = vid_which_vrm();
    1359. 

  1359. 	superio_enter(sio_data->sioreg);
    1360. 

  1360. 	/* Read VID value */
    1361. 

  1361. 	if (sio_data->kind == w83667hg) {
    1362. 

  1362. 		/* W83667HG has different pins for VID input and output, so
    1363. 

  1363. 		we can get the VID input values directly at logical device D
    1364. 

  1364. 		0xe3. */
    1365. 

  1365. 		superio_select(sio_data->sioreg, W83667HG_LD_VID);
    1366. 

  1366. 		data->vid = superio_inb(sio_data->sioreg, 0xe3);
    1367. 

  1367. 		err = device_create_file(dev, &dev_attr_cpu0_vid);
    1368. 

  1368. 		if (err)
    1369. 

  1369. 			goto exit_release;
    1370. 

  1370. 	} else {
    1371. 

  1371. 		superio_select(sio_data->sioreg, W83627EHF_LD_HWM);
    1372. 

  1372. 		if (superio_inb(sio_data->sioreg, SIO_REG_VID_CTRL) & 0x80) {
    1373. 

  1373. 			/* Set VID input sensibility if needed. In theory the
    1374. 

  1374. 			   BIOS should have set it, but in practice it's not
    1375. 

  1375. 			   always the case. We only do it for the W83627EHF/EHG
    1376. 

  1376. 			   because the W83627DHG is more complex in this
    1377. 

  1377. 			   respect. */
    1378. 

  1378. 			if (sio_data->kind == w83627ehf) {
    1379. 

  1379. 				en_vrm10 = superio_inb(sio_data->sioreg,
    1380. 

  1380. 						       SIO_REG_EN_VRM10);
    1381. 

  1381. 				if ((en_vrm10 & 0x08) && data->vrm == 90) {
    1382. 

  1382. 					dev_warn(dev, "Setting VID input "
    1383. 

  1383. 						 "voltage to TTL\n");
    1384. 

  1384. 					superio_outb(sio_data->sioreg,
    1385. 

  1385. 						     SIO_REG_EN_VRM10,
    1386. 

  1386. 						     en_vrm10 & ~0x08);
    1387. 

  1387. 				} else if (!(en_vrm10 & 0x08)
    1388. 

  1388. 					   && data->vrm == 100) {
    1389. 

  1389. 					dev_warn(dev, "Setting VID input "
    1390. 

  1390. 						 "voltage to VRM10\n");
    1391. 

  1391. 					superio_outb(sio_data->sioreg,
    1392. 

  1392. 						     SIO_REG_EN_VRM10,
    1393. 

  1393. 						     en_vrm10 | 0x08);
    1394. 

  1394. 				}
    1395. 

  1395. 			}
    1396. 

  1396. 

  1397. 			data->vid = superio_inb(sio_data->sioreg,
    1398. 

  1398. 						SIO_REG_VID_DATA);
    1399. 

  1399. 			if (sio_data->kind == w83627ehf) /* 6 VID pins only */
    1400. 

  1400. 				data->vid &= 0x3f;
    1401. 

  1401. 

  1402. 			err = device_create_file(dev, &dev_attr_cpu0_vid);
    1403. 

  1403. 			if (err)
    1404. 

  1404. 				goto exit_release;
    1405. 

  1405. 		} else {
    1406. 

  1406. 			dev_info(dev, "VID pins in output mode, CPU VID not "
    1407. 

  1407. 				 "available\n");
    1408. 

  1408. 		}
    1409. 

  1409. 	}
    1410. 

  1410. 

  1411. 	/* fan4 and fan5 share some pins with the GPIO and serial flash */
    1412. 

  1412. 	if (sio_data->kind == w83667hg) {
    1413. 

  1413. 		fan5pin = superio_inb(sio_data->sioreg, 0x27) & 0x20;
    1414. 

  1414. 		fan4pin = superio_inb(sio_data->sioreg, 0x27) & 0x40;
    1415. 

  1415. 	} else {
    1416. 

  1416. 		fan5pin = !(superio_inb(sio_data->sioreg, 0x24) & 0x02);
    1417. 

  1417. 		fan4pin = !(superio_inb(sio_data->sioreg, 0x29) & 0x06);
    1418. 

  1418. 	}
    1419. 

  1419. 	superio_exit(sio_data->sioreg);
    1420. 

  1420. 

  1421. 	/* It looks like fan4 and fan5 pins can be alternatively used
    1422. 

  1422. 	   as fan on/off switches, but fan5 control is write only :/
    1423. 

  1423. 	   We assume that if the serial interface is disabled, designers
    1424. 

  1424. 	   connected fan5 as input unless they are emitting log 1, which
    1425. 

  1425. 	   is not the default. */
    1426. 

  1426. 

  1427. 	data->has_fan = 0x07; /* fan1, fan2 and fan3 */
    1428. 

  1428. 	i = w83627ehf_read_value(data, W83627EHF_REG_FANDIV1);
    1429. 

  1429. 	if ((i & (1 << 2)) && fan4pin)
    1430. 

  1430. 		data->has_fan |= (1 << 3);
    1431. 

  1431. 	if (!(i & (1 << 1)) && fan5pin)
    1432. 

  1432. 		data->has_fan |= (1 << 4);
    1433. 

  1433. 

  1434. 	/* Read fan clock dividers immediately */
    1435. 

  1435. 	w83627ehf_update_fan_div(data);
    1436. 

  1436. 

  1437. 	/* Register sysfs hooks */
    1438. 

  1438.   	for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays); i++)
    1439. 

  1439. 		if ((err = device_create_file(dev,
    1440. 

  1440. 			&sda_sf3_arrays[i].dev_attr)))
    1441. 

  1441. 			goto exit_remove;
    1442. 

  1442. 

  1443. 	/* if fan4 is enabled create the sf3 files for it */
    1444. 

  1444. 	if ((data->has_fan & (1 << 3)) && data->pwm_num >= 4)
    1445. 

  1445. 		for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays_fan4); i++) {
    1446. 

  1446. 			if ((err = device_create_file(dev,
    1447. 

  1447. 				&sda_sf3_arrays_fan4[i].dev_attr)))
    1448. 

  1448. 				goto exit_remove;
    1449. 

  1449. 		}
    1450. 

  1450. 

  1451. 	for (i = 0; i < data->in_num; i++) {
    1452. 

  1452. 		if ((i == 6) && data->in6_skip)
    1453. 

  1453. 			continue;
    1454. 

  1454. 		if ((err = device_create_file(dev, &sda_in_input[i].dev_attr))
    1455. 

  1455. 			|| (err = device_create_file(dev,
    1456. 

  1456. 				&sda_in_alarm[i].dev_attr))
    1457. 

  1457. 			|| (err = device_create_file(dev,
    1458. 

  1458. 				&sda_in_min[i].dev_attr))
    1459. 

  1459. 			|| (err = device_create_file(dev,
    1460. 

  1460. 				&sda_in_max[i].dev_attr)))
    1461. 

  1461. 			goto exit_remove;
    1462. 

  1462. 	}
    1463. 

  1463. 

  1464. 	for (i = 0; i < 5; i++) {
    1465. 

  1465. 		if (data->has_fan & (1 << i)) {
    1466. 

  1466. 			if ((err = device_create_file(dev,
    1467. 

  1467. 					&sda_fan_input[i].dev_attr))
    1468. 

  1468. 				|| (err = device_create_file(dev,
    1469. 

  1469. 					&sda_fan_alarm[i].dev_attr))
    1470. 

  1470. 				|| (err = device_create_file(dev,
    1471. 

  1471. 					&sda_fan_div[i].dev_attr))
    1472. 

  1472. 				|| (err = device_create_file(dev,
    1473. 

  1473. 					&sda_fan_min[i].dev_attr)))
    1474. 

  1474. 				goto exit_remove;
    1475. 

  1475. 			if (i < data->pwm_num &&
    1476. 

  1476. 				((err = device_create_file(dev,
    1477. 

  1477. 					&sda_pwm[i].dev_attr))
    1478. 

  1478. 				|| (err = device_create_file(dev,
    1479. 

  1479. 					&sda_pwm_mode[i].dev_attr))
    1480. 

  1480. 				|| (err = device_create_file(dev,
    1481. 

  1481. 					&sda_pwm_enable[i].dev_attr))
    1482. 

  1482. 				|| (err = device_create_file(dev,
    1483. 

  1483. 					&sda_target_temp[i].dev_attr))
    1484. 

  1484. 				|| (err = device_create_file(dev,
    1485. 

  1485. 					&sda_tolerance[i].dev_attr))))
    1486. 

  1486. 				goto exit_remove;
    1487. 

  1487. 		}
    1488. 

  1488. 	}
    1489. 

  1489. 

  1490. 	for (i = 0; i < 3; i++) {
    1491. 

  1491. 		if ((i == 2) && data->temp3_disable)
    1492. 

  1492. 			continue;
    1493. 

  1493. 		if ((err = device_create_file(dev,
    1494. 

  1494. 				&sda_temp_input[i].dev_attr))
    1495. 

  1495. 			|| (err = device_create_file(dev,
    1496. 

  1496. 				&sda_temp_max[i].dev_attr))
    1497. 

  1497. 			|| (err = device_create_file(dev,
    1498. 

  1498. 				&sda_temp_max_hyst[i].dev_attr))
    1499. 

  1499. 			|| (err = device_create_file(dev,
    1500. 

  1500. 				&sda_temp_alarm[i].dev_attr))
    1501. 

  1501. 			|| (err = device_create_file(dev,
    1502. 

  1502. 				&sda_temp_type[i].dev_attr)))
    1503. 

  1503. 			goto exit_remove;
    1504. 

  1504. 	}
    1505. 

  1505. 

  1506. 	err = device_create_file(dev, &dev_attr_name);
    1507. 

  1507. 	if (err)
    1508. 

  1508. 		goto exit_remove;
    1509. 

  1509. 

  1510. 	data->hwmon_dev = hwmon_device_register(dev);
    1511. 

  1511. 	if (IS_ERR(data->hwmon_dev)) {
    1512. 

  1512. 		err = PTR_ERR(data->hwmon_dev);
    1513. 

  1513. 		goto exit_remove;
    1514. 

  1514. 	}
    1515. 

  1515. 

  1516. 	return 0;
    1517. 

  1517. 

  1518. exit_remove:
    1519. 

  1519. 	w83627ehf_device_remove_files(dev);
    1520. 

  1520. 	kfree(data);
    1521. 

  1521. 	platform_set_drvdata(pdev, NULL);
    1522. 

  1522. exit_release:
    1523. 

  1523. 	release_region(res->start, IOREGION_LENGTH);
    1524. 

  1524. exit:
    1525. 

  1525. 	return err;
    1526. 

  1526. }
    1527. 

  1527. 

  1528. static int __devexit w83627ehf_remove(struct platform_device *pdev)
    1529. 

  1529. {
    1530. 

  1530. 	struct w83627ehf_data *data = platform_get_drvdata(pdev);
    1531. 

  1531. 

  1532. 	hwmon_device_unregister(data->hwmon_dev);
    1533. 

  1533. 	w83627ehf_device_remove_files(&pdev->dev);
    1534. 

  1534. 	release_region(data->addr, IOREGION_LENGTH);
    1535. 

  1535. 	platform_set_drvdata(pdev, NULL);
    1536. 

  1536. 	kfree(data);
    1537. 

  1537. 

  1538. 	return 0;
    1539. 

  1539. }
    1540. 

  1540. 

  1541. static struct platform_driver w83627ehf_driver = {
    1542. 

  1542. 	.driver = {
    1543. 

  1543. 		.owner	= THIS_MODULE,
    1544. 

  1544. 		.name	= DRVNAME,
    1545. 

  1545. 	},
    1546. 

  1546. 	.probe		= w83627ehf_probe,
    1547. 

  1547. 	.remove		= __devexit_p(w83627ehf_remove),
    1548. 

  1548. };
    1549. 

  1549. 

  1550. /* w83627ehf_find() looks for a '627 in the Super-I/O config space */
    1551. 

  1551. static int __init w83627ehf_find(int sioaddr, unsigned short *addr,
    1552. 

  1552. 				 struct w83627ehf_sio_data *sio_data)
    1553. 

  1553. {
    1554. 

  1554. 	static const char __initdata sio_name_W83627EHF[] = "W83627EHF";
    1555. 

  1555. 	static const char __initdata sio_name_W83627EHG[] = "W83627EHG";
    1556. 

  1556. 	static const char __initdata sio_name_W83627DHG[] = "W83627DHG";
    1557. 

  1557. 	static const char __initdata sio_name_W83627DHG_P[] = "W83627DHG-P";
    1558. 

  1558. 	static const char __initdata sio_name_W83667HG[] = "W83667HG";
    1559. 

  1559. 

  1560. 	u16 val;
    1561. 

  1561. 	const char *sio_name;
    1562. 

  1562. 

  1563. 	superio_enter(sioaddr);
    1564. 

  1564. 

  1565. 	if (force_id)
    1566. 

  1566. 		val = force_id;
    1567. 

  1567. 	else
    1568. 

  1568. 		val = (superio_inb(sioaddr, SIO_REG_DEVID) << 8)
    1569. 

  1569. 		    | superio_inb(sioaddr, SIO_REG_DEVID + 1);
    1570. 

  1570. 	switch (val & SIO_ID_MASK) {
    1571. 

  1571. 	case SIO_W83627EHF_ID:
    1572. 

  1572. 		sio_data->kind = w83627ehf;
    1573. 

  1573. 		sio_name = sio_name_W83627EHF;
    1574. 

  1574. 		break;
    1575. 

  1575. 	case SIO_W83627EHG_ID:
    1576. 

  1576. 		sio_data->kind = w83627ehf;
    1577. 

  1577. 		sio_name = sio_name_W83627EHG;
    1578. 

  1578. 		break;
    1579. 

  1579. 	case SIO_W83627DHG_ID:
    1580. 

  1580. 		sio_data->kind = w83627dhg;
    1581. 

  1581. 		sio_name = sio_name_W83627DHG;
    1582. 

  1582. 		break;
    1583. 

  1583. 	case SIO_W83627DHG_P_ID:
    1584. 

  1584. 		sio_data->kind = w83627dhg_p;
    1585. 

  1585. 		sio_name = sio_name_W83627DHG_P;
    1586. 

  1586. 		break;
    1587. 

  1587. 	case SIO_W83667HG_ID:
    1588. 

  1588. 		sio_data->kind = w83667hg;
    1589. 

  1589. 		sio_name = sio_name_W83667HG;
    1590. 

  1590. 		break;
    1591. 

  1591. 	default:
    1592. 

  1592. 		if (val != 0xffff)
    1593. 

  1593. 			pr_debug(DRVNAME ": unsupported chip ID: 0x%04x\n",
    1594. 

  1594. 				 val);
    1595. 

  1595. 		superio_exit(sioaddr);
    1596. 

  1596. 		return -ENODEV;
    1597. 

  1597. 	}
    1598. 

  1598. 

  1599. 	/* We have a known chip, find the HWM I/O address */
    1600. 

  1600. 	superio_select(sioaddr, W83627EHF_LD_HWM);
    1601. 

  1601. 	val = (superio_inb(sioaddr, SIO_REG_ADDR) << 8)
    1602. 

  1602. 	    | superio_inb(sioaddr, SIO_REG_ADDR + 1);
    1603. 

  1603. 	*addr = val & IOREGION_ALIGNMENT;
    1604. 

  1604. 	if (*addr == 0) {
    1605. 

  1605. 		printk(KERN_ERR DRVNAME ": Refusing to enable a Super-I/O "
    1606. 

  1606. 		       "device with a base I/O port 0.\n");
    1607. 

  1607. 		superio_exit(sioaddr);
    1608. 

  1608. 		return -ENODEV;
    1609. 

  1609. 	}
    1610. 

  1610. 

  1611. 	/* Activate logical device if needed */
    1612. 

  1612. 	val = superio_inb(sioaddr, SIO_REG_ENABLE);
    1613. 

  1613. 	if (!(val & 0x01)) {
    1614. 

  1614. 		printk(KERN_WARNING DRVNAME ": Forcibly enabling Super-I/O. "
    1615. 

  1615. 		       "Sensor is probably unusable.\n");
    1616. 

  1616. 		superio_outb(sioaddr, SIO_REG_ENABLE, val | 0x01);
    1617. 

  1617. 	}
    1618. 

  1618. 

  1619. 	superio_exit(sioaddr);
    1620. 

  1620. 	pr_info(DRVNAME ": Found %s chip at %#x\n", sio_name, *addr);
    1621. 

  1621. 	sio_data->sioreg = sioaddr;
    1622. 

  1622. 

  1623. 	return 0;
    1624. 

  1624. }
    1625. 

  1625. 

  1626. /* when Super-I/O functions move to a separate file, the Super-I/O
    1627. 

  1627.  * bus will manage the lifetime of the device and this module will only keep
    1628. 

  1628.  * track of the w83627ehf driver. But since we platform_device_alloc(), we
    1629. 

  1629.  * must keep track of the device */
    1630. 

  1630. static struct platform_device *pdev;
    1631. 

  1631. 

  1632. static int __init sensors_w83627ehf_init(void)
    1633. 

  1633. {
    1634. 

  1634. 	int err;
    1635. 

  1635. 	unsigned short address;
    1636. 

  1636. 	struct resource res;
    1637. 

  1637. 	struct w83627ehf_sio_data sio_data;
    1638. 

  1638. 

  1639. 	/* initialize sio_data->kind and sio_data->sioreg.
    1640. 

  1640. 	 *
    1641. 

  1641. 	 * when Super-I/O functions move to a separate file, the Super-I/O
    1642. 

  1642. 	 * driver will probe 0x2e and 0x4e and auto-detect the presence of a
    1643. 

  1643. 	 * w83627ehf hardware monitor, and call probe() */
    1644. 

  1644. 	if (w83627ehf_find(0x2e, &address, &sio_data) &&
    1645. 

  1645. 	    w83627ehf_find(0x4e, &address, &sio_data))
    1646. 

  1646. 		return -ENODEV;
    1647. 

  1647. 

  1648. 	err = platform_driver_register(&w83627ehf_driver);
    1649. 

  1649. 	if (err)
    1650. 

  1650. 		goto exit;
    1651. 

  1651. 

  1652. 	if (!(pdev = platform_device_alloc(DRVNAME, address))) {
    1653. 

  1653. 		err = -ENOMEM;
    1654. 

  1654. 		printk(KERN_ERR DRVNAME ": Device allocation failed\n");
    1655. 

  1655. 		goto exit_unregister;
    1656. 

  1656. 	}
    1657. 

  1657. 

  1658. 	err = platform_device_add_data(pdev, &sio_data,
    1659. 

  1659. 				       sizeof(struct w83627ehf_sio_data));
    1660. 

  1660. 	if (err) {
    1661. 

  1661. 		printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
    1662. 

  1662. 		goto exit_device_put;
    1663. 

  1663. 	}
    1664. 

  1664. 

  1665. 	memset(&res, 0, sizeof(res));
    1666. 

  1666. 	res.name = DRVNAME;
    1667. 

  1667. 	res.start = address + IOREGION_OFFSET;
    1668. 

  1668. 	res.end = address + IOREGION_OFFSET + IOREGION_LENGTH - 1;
    1669. 

  1669. 	res.flags = IORESOURCE_IO;
    1670. 

  1670. 

  1671. 	err = acpi_check_resource_conflict(&res);
    1672. 

  1672. 	if (err)
    1673. 

  1673. 		goto exit_device_put;
    1674. 

  1674. 

  1675. 	err = platform_device_add_resources(pdev, &res, 1);
    1676. 

  1676. 	if (err) {
    1677. 

  1677. 		printk(KERN_ERR DRVNAME ": Device resource addition failed "
    1678. 

  1678. 		       "(%d)\n", err);
    1679. 

  1679. 		goto exit_device_put;
    1680. 

  1680. 	}
    1681. 

  1681. 

  1682. 	/* platform_device_add calls probe() */
    1683. 

  1683. 	err = platform_device_add(pdev);
    1684. 

  1684. 	if (err) {
    1685. 

  1685. 		printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
    1686. 

  1686. 		       err);
    1687. 

  1687. 		goto exit_device_put;
    1688. 

  1688. 	}
    1689. 

  1689. 

  1690. 	return 0;
    1691. 

  1691. 

  1692. exit_device_put:
    1693. 

  1693. 	platform_device_put(pdev);
    1694. 

  1694. exit_unregister:
    1695. 

  1695. 	platform_driver_unregister(&w83627ehf_driver);
    1696. 

  1696. exit:
    1697. 

  1697. 	return err;
    1698. 

  1698. }
    1699. 

  1699. 

  1700. static void __exit sensors_w83627ehf_exit(void)
    1701. 

  1701. {
    1702. 

  1702. 	platform_device_unregister(pdev);
    1703. 

  1703. 	platform_driver_unregister(&w83627ehf_driver);
    1704. 

  1704. }
    1705. 

  1705. 

  1706. MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
    1707. 

  1707. MODULE_DESCRIPTION("W83627EHF driver");
    1708. 

  1708. MODULE_LICENSE("GPL");
    1709. 

  1709. 

  1710. module_init(sensors_w83627ehf_init);
    1711. 

  1711. module_exit(sensors_w83627ehf_exit);
    1712.