vt8231.c 30 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * vt8231.c - Part of lm_sensors, Linux kernel modules
  4. * for hardware monitoring
  5. *
  6. * Copyright (c) 2005 Roger Lucas <vt8231@hiddenengine.co.uk>
  7. * Copyright (c) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com>
  8. * Aaron M. Marsh <amarsh@sdf.lonestar.org>
  9. */
  10. /*
  11. * Supports VIA VT8231 South Bridge embedded sensors
  12. */
  13. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  14. #include <linux/module.h>
  15. #include <linux/init.h>
  16. #include <linux/slab.h>
  17. #include <linux/pci.h>
  18. #include <linux/jiffies.h>
  19. #include <linux/platform_device.h>
  20. #include <linux/hwmon.h>
  21. #include <linux/hwmon-sysfs.h>
  22. #include <linux/hwmon-vid.h>
  23. #include <linux/err.h>
  24. #include <linux/mutex.h>
  25. #include <linux/acpi.h>
  26. #include <linux/io.h>
  27. static int force_addr;
  28. module_param(force_addr, int, 0);
  29. MODULE_PARM_DESC(force_addr, "Initialize the base address of the sensors");
  30. static struct platform_device *pdev;
  31. #define VT8231_EXTENT 0x80
  32. #define VT8231_BASE_REG 0x70
  33. #define VT8231_ENABLE_REG 0x74
  34. /*
  35. * The VT8231 registers
  36. *
  37. * The reset value for the input channel configuration is used (Reg 0x4A=0x07)
  38. * which sets the selected inputs marked with '*' below if multiple options are
  39. * possible:
  40. *
  41. * Voltage Mode Temperature Mode
  42. * Sensor Linux Id Linux Id VIA Id
  43. * -------- -------- -------- ------
  44. * CPU Diode N/A temp1 0
  45. * UIC1 in0 temp2 * 1
  46. * UIC2 in1 * temp3 2
  47. * UIC3 in2 * temp4 3
  48. * UIC4 in3 * temp5 4
  49. * UIC5 in4 * temp6 5
  50. * 3.3V in5 N/A
  51. *
  52. * Note that the BIOS may set the configuration register to a different value
  53. * to match the motherboard configuration.
  54. */
  55. /* fans numbered 0-1 */
  56. #define VT8231_REG_FAN_MIN(nr) (0x3b + (nr))
  57. #define VT8231_REG_FAN(nr) (0x29 + (nr))
  58. /* Voltage inputs numbered 0-5 */
  59. static const u8 regvolt[] = { 0x21, 0x22, 0x23, 0x24, 0x25, 0x26 };
  60. static const u8 regvoltmax[] = { 0x3d, 0x2b, 0x2d, 0x2f, 0x31, 0x33 };
  61. static const u8 regvoltmin[] = { 0x3e, 0x2c, 0x2e, 0x30, 0x32, 0x34 };
  62. /*
  63. * Temperatures are numbered 1-6 according to the Linux kernel specification.
  64. *
  65. * In the VIA datasheet, however, the temperatures are numbered from zero.
  66. * Since it is important that this driver can easily be compared to the VIA
  67. * datasheet, we will use the VIA numbering within this driver and map the
  68. * kernel sysfs device name to the VIA number in the sysfs callback.
  69. */
  70. #define VT8231_REG_TEMP_LOW01 0x49
  71. #define VT8231_REG_TEMP_LOW25 0x4d
  72. static const u8 regtemp[] = { 0x1f, 0x21, 0x22, 0x23, 0x24, 0x25 };
  73. static const u8 regtempmax[] = { 0x39, 0x3d, 0x2b, 0x2d, 0x2f, 0x31 };
  74. static const u8 regtempmin[] = { 0x3a, 0x3e, 0x2c, 0x2e, 0x30, 0x32 };
  75. #define TEMP_FROM_REG(reg) (((253 * 4 - (reg)) * 550 + 105) / 210)
  76. #define TEMP_MAXMIN_FROM_REG(reg) (((253 - (reg)) * 2200 + 105) / 210)
  77. #define TEMP_MAXMIN_TO_REG(val) (253 - ((val) * 210 + 1100) / 2200)
  78. #define VT8231_REG_CONFIG 0x40
  79. #define VT8231_REG_ALARM1 0x41
  80. #define VT8231_REG_ALARM2 0x42
  81. #define VT8231_REG_FANDIV 0x47
  82. #define VT8231_REG_UCH_CONFIG 0x4a
  83. #define VT8231_REG_TEMP1_CONFIG 0x4b
  84. #define VT8231_REG_TEMP2_CONFIG 0x4c
  85. /*
  86. * temps 0-5 as numbered in VIA datasheet - see later for mapping to Linux
  87. * numbering
  88. */
  89. #define ISTEMP(i, ch_config) ((i) == 0 ? 1 : \
  90. ((ch_config) >> ((i)+1)) & 0x01)
  91. /* voltages 0-5 */
  92. #define ISVOLT(i, ch_config) ((i) == 5 ? 1 : \
  93. !(((ch_config) >> ((i)+2)) & 0x01))
  94. #define DIV_FROM_REG(val) (1 << (val))
  95. /*
  96. * NB The values returned here are NOT temperatures. The calibration curves
  97. * for the thermistor curves are board-specific and must go in the
  98. * sensors.conf file. Temperature sensors are actually ten bits, but the
  99. * VIA datasheet only considers the 8 MSBs obtained from the regtemp[]
  100. * register. The temperature value returned should have a magnitude of 3,
  101. * so we use the VIA scaling as the "true" scaling and use the remaining 2
  102. * LSBs as fractional precision.
  103. *
  104. * All the on-chip hardware temperature comparisons for the alarms are only
  105. * 8-bits wide, and compare against the 8 MSBs of the temperature. The bits
  106. * in the registers VT8231_REG_TEMP_LOW01 and VT8231_REG_TEMP_LOW25 are
  107. * ignored.
  108. */
  109. /*
  110. ****** FAN RPM CONVERSIONS ********
  111. * This chip saturates back at 0, not at 255 like many the other chips.
  112. * So, 0 means 0 RPM
  113. */
  114. static inline u8 FAN_TO_REG(long rpm, int div)
  115. {
  116. if (rpm <= 0 || rpm > 1310720)
  117. return 0;
  118. return clamp_val(1310720 / (rpm * div), 1, 255);
  119. }
  120. #define FAN_FROM_REG(val, div) ((val) == 0 ? 0 : 1310720 / ((val) * (div)))
  121. struct vt8231_data {
  122. unsigned short addr;
  123. const char *name;
  124. struct mutex update_lock;
  125. struct device *hwmon_dev;
  126. char valid; /* !=0 if following fields are valid */
  127. unsigned long last_updated; /* In jiffies */
  128. u8 in[6]; /* Register value */
  129. u8 in_max[6]; /* Register value */
  130. u8 in_min[6]; /* Register value */
  131. u16 temp[6]; /* Register value 10 bit, right aligned */
  132. u8 temp_max[6]; /* Register value */
  133. u8 temp_min[6]; /* Register value */
  134. u8 fan[2]; /* Register value */
  135. u8 fan_min[2]; /* Register value */
  136. u8 fan_div[2]; /* Register encoding, shifted right */
  137. u16 alarms; /* Register encoding */
  138. u8 uch_config;
  139. };
  140. static struct pci_dev *s_bridge;
  141. static int vt8231_probe(struct platform_device *pdev);
  142. static int vt8231_remove(struct platform_device *pdev);
  143. static struct vt8231_data *vt8231_update_device(struct device *dev);
  144. static void vt8231_init_device(struct vt8231_data *data);
  145. static inline int vt8231_read_value(struct vt8231_data *data, u8 reg)
  146. {
  147. return inb_p(data->addr + reg);
  148. }
  149. static inline void vt8231_write_value(struct vt8231_data *data, u8 reg,
  150. u8 value)
  151. {
  152. outb_p(value, data->addr + reg);
  153. }
  154. /* following are the sysfs callback functions */
  155. static ssize_t in_show(struct device *dev, struct device_attribute *attr,
  156. char *buf)
  157. {
  158. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  159. int nr = sensor_attr->index;
  160. struct vt8231_data *data = vt8231_update_device(dev);
  161. return sprintf(buf, "%d\n", ((data->in[nr] - 3) * 10000) / 958);
  162. }
  163. static ssize_t in_min_show(struct device *dev, struct device_attribute *attr,
  164. char *buf)
  165. {
  166. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  167. int nr = sensor_attr->index;
  168. struct vt8231_data *data = vt8231_update_device(dev);
  169. return sprintf(buf, "%d\n", ((data->in_min[nr] - 3) * 10000) / 958);
  170. }
  171. static ssize_t in_max_show(struct device *dev, struct device_attribute *attr,
  172. char *buf)
  173. {
  174. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  175. int nr = sensor_attr->index;
  176. struct vt8231_data *data = vt8231_update_device(dev);
  177. return sprintf(buf, "%d\n", (((data->in_max[nr] - 3) * 10000) / 958));
  178. }
  179. static ssize_t in_min_store(struct device *dev, struct device_attribute *attr,
  180. const char *buf, size_t count)
  181. {
  182. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  183. int nr = sensor_attr->index;
  184. struct vt8231_data *data = dev_get_drvdata(dev);
  185. unsigned long val;
  186. int err;
  187. err = kstrtoul(buf, 10, &val);
  188. if (err)
  189. return err;
  190. mutex_lock(&data->update_lock);
  191. data->in_min[nr] = clamp_val(((val * 958) / 10000) + 3, 0, 255);
  192. vt8231_write_value(data, regvoltmin[nr], data->in_min[nr]);
  193. mutex_unlock(&data->update_lock);
  194. return count;
  195. }
  196. static ssize_t in_max_store(struct device *dev, struct device_attribute *attr,
  197. const char *buf, size_t count)
  198. {
  199. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  200. int nr = sensor_attr->index;
  201. struct vt8231_data *data = dev_get_drvdata(dev);
  202. unsigned long val;
  203. int err;
  204. err = kstrtoul(buf, 10, &val);
  205. if (err)
  206. return err;
  207. mutex_lock(&data->update_lock);
  208. data->in_max[nr] = clamp_val(((val * 958) / 10000) + 3, 0, 255);
  209. vt8231_write_value(data, regvoltmax[nr], data->in_max[nr]);
  210. mutex_unlock(&data->update_lock);
  211. return count;
  212. }
  213. /* Special case for input 5 as this has 3.3V scaling built into the chip */
  214. static ssize_t in5_input_show(struct device *dev,
  215. struct device_attribute *attr, char *buf)
  216. {
  217. struct vt8231_data *data = vt8231_update_device(dev);
  218. return sprintf(buf, "%d\n",
  219. (((data->in[5] - 3) * 10000 * 54) / (958 * 34)));
  220. }
  221. static ssize_t in5_min_show(struct device *dev, struct device_attribute *attr,
  222. char *buf)
  223. {
  224. struct vt8231_data *data = vt8231_update_device(dev);
  225. return sprintf(buf, "%d\n",
  226. (((data->in_min[5] - 3) * 10000 * 54) / (958 * 34)));
  227. }
  228. static ssize_t in5_max_show(struct device *dev, struct device_attribute *attr,
  229. char *buf)
  230. {
  231. struct vt8231_data *data = vt8231_update_device(dev);
  232. return sprintf(buf, "%d\n",
  233. (((data->in_max[5] - 3) * 10000 * 54) / (958 * 34)));
  234. }
  235. static ssize_t in5_min_store(struct device *dev,
  236. struct device_attribute *attr, const char *buf,
  237. size_t count)
  238. {
  239. struct vt8231_data *data = dev_get_drvdata(dev);
  240. unsigned long val;
  241. int err;
  242. err = kstrtoul(buf, 10, &val);
  243. if (err)
  244. return err;
  245. mutex_lock(&data->update_lock);
  246. data->in_min[5] = clamp_val(((val * 958 * 34) / (10000 * 54)) + 3,
  247. 0, 255);
  248. vt8231_write_value(data, regvoltmin[5], data->in_min[5]);
  249. mutex_unlock(&data->update_lock);
  250. return count;
  251. }
  252. static ssize_t in5_max_store(struct device *dev,
  253. struct device_attribute *attr, const char *buf,
  254. size_t count)
  255. {
  256. struct vt8231_data *data = dev_get_drvdata(dev);
  257. unsigned long val;
  258. int err;
  259. err = kstrtoul(buf, 10, &val);
  260. if (err)
  261. return err;
  262. mutex_lock(&data->update_lock);
  263. data->in_max[5] = clamp_val(((val * 958 * 34) / (10000 * 54)) + 3,
  264. 0, 255);
  265. vt8231_write_value(data, regvoltmax[5], data->in_max[5]);
  266. mutex_unlock(&data->update_lock);
  267. return count;
  268. }
  269. static SENSOR_DEVICE_ATTR_RO(in0_input, in, 0);
  270. static SENSOR_DEVICE_ATTR_RW(in0_min, in_min, 0);
  271. static SENSOR_DEVICE_ATTR_RW(in0_max, in_max, 0);
  272. static SENSOR_DEVICE_ATTR_RO(in1_input, in, 1);
  273. static SENSOR_DEVICE_ATTR_RW(in1_min, in_min, 1);
  274. static SENSOR_DEVICE_ATTR_RW(in1_max, in_max, 1);
  275. static SENSOR_DEVICE_ATTR_RO(in2_input, in, 2);
  276. static SENSOR_DEVICE_ATTR_RW(in2_min, in_min, 2);
  277. static SENSOR_DEVICE_ATTR_RW(in2_max, in_max, 2);
  278. static SENSOR_DEVICE_ATTR_RO(in3_input, in, 3);
  279. static SENSOR_DEVICE_ATTR_RW(in3_min, in_min, 3);
  280. static SENSOR_DEVICE_ATTR_RW(in3_max, in_max, 3);
  281. static SENSOR_DEVICE_ATTR_RO(in4_input, in, 4);
  282. static SENSOR_DEVICE_ATTR_RW(in4_min, in_min, 4);
  283. static SENSOR_DEVICE_ATTR_RW(in4_max, in_max, 4);
  284. static DEVICE_ATTR_RO(in5_input);
  285. static DEVICE_ATTR_RW(in5_min);
  286. static DEVICE_ATTR_RW(in5_max);
  287. /* Temperatures */
  288. static ssize_t temp1_input_show(struct device *dev,
  289. struct device_attribute *attr, char *buf)
  290. {
  291. struct vt8231_data *data = vt8231_update_device(dev);
  292. return sprintf(buf, "%d\n", data->temp[0] * 250);
  293. }
  294. static ssize_t temp1_max_show(struct device *dev, struct device_attribute *attr,
  295. char *buf)
  296. {
  297. struct vt8231_data *data = vt8231_update_device(dev);
  298. return sprintf(buf, "%d\n", data->temp_max[0] * 1000);
  299. }
  300. static ssize_t temp1_max_hyst_show(struct device *dev,
  301. struct device_attribute *attr, char *buf)
  302. {
  303. struct vt8231_data *data = vt8231_update_device(dev);
  304. return sprintf(buf, "%d\n", data->temp_min[0] * 1000);
  305. }
  306. static ssize_t temp1_max_store(struct device *dev,
  307. struct device_attribute *attr, const char *buf,
  308. size_t count)
  309. {
  310. struct vt8231_data *data = dev_get_drvdata(dev);
  311. long val;
  312. int err;
  313. err = kstrtol(buf, 10, &val);
  314. if (err)
  315. return err;
  316. mutex_lock(&data->update_lock);
  317. data->temp_max[0] = clamp_val((val + 500) / 1000, 0, 255);
  318. vt8231_write_value(data, regtempmax[0], data->temp_max[0]);
  319. mutex_unlock(&data->update_lock);
  320. return count;
  321. }
  322. static ssize_t temp1_max_hyst_store(struct device *dev,
  323. struct device_attribute *attr,
  324. const char *buf, size_t count)
  325. {
  326. struct vt8231_data *data = dev_get_drvdata(dev);
  327. long val;
  328. int err;
  329. err = kstrtol(buf, 10, &val);
  330. if (err)
  331. return err;
  332. mutex_lock(&data->update_lock);
  333. data->temp_min[0] = clamp_val((val + 500) / 1000, 0, 255);
  334. vt8231_write_value(data, regtempmin[0], data->temp_min[0]);
  335. mutex_unlock(&data->update_lock);
  336. return count;
  337. }
  338. static ssize_t temp_show(struct device *dev, struct device_attribute *attr,
  339. char *buf)
  340. {
  341. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  342. int nr = sensor_attr->index;
  343. struct vt8231_data *data = vt8231_update_device(dev);
  344. return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[nr]));
  345. }
  346. static ssize_t temp_max_show(struct device *dev,
  347. struct device_attribute *attr, char *buf)
  348. {
  349. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  350. int nr = sensor_attr->index;
  351. struct vt8231_data *data = vt8231_update_device(dev);
  352. return sprintf(buf, "%d\n", TEMP_MAXMIN_FROM_REG(data->temp_max[nr]));
  353. }
  354. static ssize_t temp_min_show(struct device *dev,
  355. struct device_attribute *attr, char *buf)
  356. {
  357. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  358. int nr = sensor_attr->index;
  359. struct vt8231_data *data = vt8231_update_device(dev);
  360. return sprintf(buf, "%d\n", TEMP_MAXMIN_FROM_REG(data->temp_min[nr]));
  361. }
  362. static ssize_t temp_max_store(struct device *dev,
  363. struct device_attribute *attr, const char *buf,
  364. size_t count)
  365. {
  366. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  367. int nr = sensor_attr->index;
  368. struct vt8231_data *data = dev_get_drvdata(dev);
  369. long val;
  370. int err;
  371. err = kstrtol(buf, 10, &val);
  372. if (err)
  373. return err;
  374. mutex_lock(&data->update_lock);
  375. data->temp_max[nr] = clamp_val(TEMP_MAXMIN_TO_REG(val), 0, 255);
  376. vt8231_write_value(data, regtempmax[nr], data->temp_max[nr]);
  377. mutex_unlock(&data->update_lock);
  378. return count;
  379. }
  380. static ssize_t temp_min_store(struct device *dev,
  381. struct device_attribute *attr, const char *buf,
  382. size_t count)
  383. {
  384. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  385. int nr = sensor_attr->index;
  386. struct vt8231_data *data = dev_get_drvdata(dev);
  387. long val;
  388. int err;
  389. err = kstrtol(buf, 10, &val);
  390. if (err)
  391. return err;
  392. mutex_lock(&data->update_lock);
  393. data->temp_min[nr] = clamp_val(TEMP_MAXMIN_TO_REG(val), 0, 255);
  394. vt8231_write_value(data, regtempmin[nr], data->temp_min[nr]);
  395. mutex_unlock(&data->update_lock);
  396. return count;
  397. }
  398. /*
  399. * Note that these map the Linux temperature sensor numbering (1-6) to the VIA
  400. * temperature sensor numbering (0-5)
  401. */
  402. static DEVICE_ATTR_RO(temp1_input);
  403. static DEVICE_ATTR_RW(temp1_max);
  404. static DEVICE_ATTR_RW(temp1_max_hyst);
  405. static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1);
  406. static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);
  407. static SENSOR_DEVICE_ATTR_RW(temp2_max_hyst, temp_min, 1);
  408. static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2);
  409. static SENSOR_DEVICE_ATTR_RW(temp3_max, temp_max, 2);
  410. static SENSOR_DEVICE_ATTR_RW(temp3_max_hyst, temp_min, 2);
  411. static SENSOR_DEVICE_ATTR_RO(temp4_input, temp, 3);
  412. static SENSOR_DEVICE_ATTR_RW(temp4_max, temp_max, 3);
  413. static SENSOR_DEVICE_ATTR_RW(temp4_max_hyst, temp_min, 3);
  414. static SENSOR_DEVICE_ATTR_RO(temp5_input, temp, 4);
  415. static SENSOR_DEVICE_ATTR_RW(temp5_max, temp_max, 4);
  416. static SENSOR_DEVICE_ATTR_RW(temp5_max_hyst, temp_min, 4);
  417. static SENSOR_DEVICE_ATTR_RO(temp6_input, temp, 5);
  418. static SENSOR_DEVICE_ATTR_RW(temp6_max, temp_max, 5);
  419. static SENSOR_DEVICE_ATTR_RW(temp6_max_hyst, temp_min, 5);
  420. /* Fans */
  421. static ssize_t fan_show(struct device *dev, struct device_attribute *attr,
  422. char *buf)
  423. {
  424. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  425. int nr = sensor_attr->index;
  426. struct vt8231_data *data = vt8231_update_device(dev);
  427. return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
  428. DIV_FROM_REG(data->fan_div[nr])));
  429. }
  430. static ssize_t fan_min_show(struct device *dev, struct device_attribute *attr,
  431. char *buf)
  432. {
  433. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  434. int nr = sensor_attr->index;
  435. struct vt8231_data *data = vt8231_update_device(dev);
  436. return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[nr],
  437. DIV_FROM_REG(data->fan_div[nr])));
  438. }
  439. static ssize_t fan_div_show(struct device *dev, struct device_attribute *attr,
  440. char *buf)
  441. {
  442. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  443. int nr = sensor_attr->index;
  444. struct vt8231_data *data = vt8231_update_device(dev);
  445. return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]));
  446. }
  447. static ssize_t fan_min_store(struct device *dev,
  448. struct device_attribute *attr, const char *buf,
  449. size_t count)
  450. {
  451. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  452. int nr = sensor_attr->index;
  453. struct vt8231_data *data = dev_get_drvdata(dev);
  454. unsigned long val;
  455. int err;
  456. err = kstrtoul(buf, 10, &val);
  457. if (err)
  458. return err;
  459. mutex_lock(&data->update_lock);
  460. data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
  461. vt8231_write_value(data, VT8231_REG_FAN_MIN(nr), data->fan_min[nr]);
  462. mutex_unlock(&data->update_lock);
  463. return count;
  464. }
  465. static ssize_t fan_div_store(struct device *dev,
  466. struct device_attribute *attr, const char *buf,
  467. size_t count)
  468. {
  469. struct vt8231_data *data = dev_get_drvdata(dev);
  470. struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
  471. unsigned long val;
  472. int nr = sensor_attr->index;
  473. int old = vt8231_read_value(data, VT8231_REG_FANDIV);
  474. long min = FAN_FROM_REG(data->fan_min[nr],
  475. DIV_FROM_REG(data->fan_div[nr]));
  476. int err;
  477. err = kstrtoul(buf, 10, &val);
  478. if (err)
  479. return err;
  480. mutex_lock(&data->update_lock);
  481. switch (val) {
  482. case 1:
  483. data->fan_div[nr] = 0;
  484. break;
  485. case 2:
  486. data->fan_div[nr] = 1;
  487. break;
  488. case 4:
  489. data->fan_div[nr] = 2;
  490. break;
  491. case 8:
  492. data->fan_div[nr] = 3;
  493. break;
  494. default:
  495. dev_err(dev,
  496. "fan_div value %ld not supported. Choose one of 1, 2, 4 or 8!\n",
  497. val);
  498. mutex_unlock(&data->update_lock);
  499. return -EINVAL;
  500. }
  501. /* Correct the fan minimum speed */
  502. data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
  503. vt8231_write_value(data, VT8231_REG_FAN_MIN(nr), data->fan_min[nr]);
  504. old = (old & 0x0f) | (data->fan_div[1] << 6) | (data->fan_div[0] << 4);
  505. vt8231_write_value(data, VT8231_REG_FANDIV, old);
  506. mutex_unlock(&data->update_lock);
  507. return count;
  508. }
  509. static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0);
  510. static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);
  511. static SENSOR_DEVICE_ATTR_RW(fan1_div, fan_div, 0);
  512. static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1);
  513. static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
  514. static SENSOR_DEVICE_ATTR_RW(fan2_div, fan_div, 1);
  515. /* Alarms */
  516. static ssize_t alarms_show(struct device *dev, struct device_attribute *attr,
  517. char *buf)
  518. {
  519. struct vt8231_data *data = vt8231_update_device(dev);
  520. return sprintf(buf, "%d\n", data->alarms);
  521. }
  522. static DEVICE_ATTR_RO(alarms);
  523. static ssize_t alarm_show(struct device *dev, struct device_attribute *attr,
  524. char *buf)
  525. {
  526. int bitnr = to_sensor_dev_attr(attr)->index;
  527. struct vt8231_data *data = vt8231_update_device(dev);
  528. return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
  529. }
  530. static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm, 4);
  531. static SENSOR_DEVICE_ATTR_RO(temp2_alarm, alarm, 11);
  532. static SENSOR_DEVICE_ATTR_RO(temp3_alarm, alarm, 0);
  533. static SENSOR_DEVICE_ATTR_RO(temp4_alarm, alarm, 1);
  534. static SENSOR_DEVICE_ATTR_RO(temp5_alarm, alarm, 3);
  535. static SENSOR_DEVICE_ATTR_RO(temp6_alarm, alarm, 8);
  536. static SENSOR_DEVICE_ATTR_RO(in0_alarm, alarm, 11);
  537. static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm, 0);
  538. static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm, 1);
  539. static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm, 3);
  540. static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm, 8);
  541. static SENSOR_DEVICE_ATTR_RO(in5_alarm, alarm, 2);
  542. static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm, 6);
  543. static SENSOR_DEVICE_ATTR_RO(fan2_alarm, alarm, 7);
  544. static ssize_t name_show(struct device *dev, struct device_attribute
  545. *devattr, char *buf)
  546. {
  547. struct vt8231_data *data = dev_get_drvdata(dev);
  548. return sprintf(buf, "%s\n", data->name);
  549. }
  550. static DEVICE_ATTR_RO(name);
  551. static struct attribute *vt8231_attributes_temps[6][5] = {
  552. {
  553. &dev_attr_temp1_input.attr,
  554. &dev_attr_temp1_max_hyst.attr,
  555. &dev_attr_temp1_max.attr,
  556. &sensor_dev_attr_temp1_alarm.dev_attr.attr,
  557. NULL
  558. }, {
  559. &sensor_dev_attr_temp2_input.dev_attr.attr,
  560. &sensor_dev_attr_temp2_max_hyst.dev_attr.attr,
  561. &sensor_dev_attr_temp2_max.dev_attr.attr,
  562. &sensor_dev_attr_temp2_alarm.dev_attr.attr,
  563. NULL
  564. }, {
  565. &sensor_dev_attr_temp3_input.dev_attr.attr,
  566. &sensor_dev_attr_temp3_max_hyst.dev_attr.attr,
  567. &sensor_dev_attr_temp3_max.dev_attr.attr,
  568. &sensor_dev_attr_temp3_alarm.dev_attr.attr,
  569. NULL
  570. }, {
  571. &sensor_dev_attr_temp4_input.dev_attr.attr,
  572. &sensor_dev_attr_temp4_max_hyst.dev_attr.attr,
  573. &sensor_dev_attr_temp4_max.dev_attr.attr,
  574. &sensor_dev_attr_temp4_alarm.dev_attr.attr,
  575. NULL
  576. }, {
  577. &sensor_dev_attr_temp5_input.dev_attr.attr,
  578. &sensor_dev_attr_temp5_max_hyst.dev_attr.attr,
  579. &sensor_dev_attr_temp5_max.dev_attr.attr,
  580. &sensor_dev_attr_temp5_alarm.dev_attr.attr,
  581. NULL
  582. }, {
  583. &sensor_dev_attr_temp6_input.dev_attr.attr,
  584. &sensor_dev_attr_temp6_max_hyst.dev_attr.attr,
  585. &sensor_dev_attr_temp6_max.dev_attr.attr,
  586. &sensor_dev_attr_temp6_alarm.dev_attr.attr,
  587. NULL
  588. }
  589. };
  590. static const struct attribute_group vt8231_group_temps[6] = {
  591. { .attrs = vt8231_attributes_temps[0] },
  592. { .attrs = vt8231_attributes_temps[1] },
  593. { .attrs = vt8231_attributes_temps[2] },
  594. { .attrs = vt8231_attributes_temps[3] },
  595. { .attrs = vt8231_attributes_temps[4] },
  596. { .attrs = vt8231_attributes_temps[5] },
  597. };
  598. static struct attribute *vt8231_attributes_volts[6][5] = {
  599. {
  600. &sensor_dev_attr_in0_input.dev_attr.attr,
  601. &sensor_dev_attr_in0_min.dev_attr.attr,
  602. &sensor_dev_attr_in0_max.dev_attr.attr,
  603. &sensor_dev_attr_in0_alarm.dev_attr.attr,
  604. NULL
  605. }, {
  606. &sensor_dev_attr_in1_input.dev_attr.attr,
  607. &sensor_dev_attr_in1_min.dev_attr.attr,
  608. &sensor_dev_attr_in1_max.dev_attr.attr,
  609. &sensor_dev_attr_in1_alarm.dev_attr.attr,
  610. NULL
  611. }, {
  612. &sensor_dev_attr_in2_input.dev_attr.attr,
  613. &sensor_dev_attr_in2_min.dev_attr.attr,
  614. &sensor_dev_attr_in2_max.dev_attr.attr,
  615. &sensor_dev_attr_in2_alarm.dev_attr.attr,
  616. NULL
  617. }, {
  618. &sensor_dev_attr_in3_input.dev_attr.attr,
  619. &sensor_dev_attr_in3_min.dev_attr.attr,
  620. &sensor_dev_attr_in3_max.dev_attr.attr,
  621. &sensor_dev_attr_in3_alarm.dev_attr.attr,
  622. NULL
  623. }, {
  624. &sensor_dev_attr_in4_input.dev_attr.attr,
  625. &sensor_dev_attr_in4_min.dev_attr.attr,
  626. &sensor_dev_attr_in4_max.dev_attr.attr,
  627. &sensor_dev_attr_in4_alarm.dev_attr.attr,
  628. NULL
  629. }, {
  630. &dev_attr_in5_input.attr,
  631. &dev_attr_in5_min.attr,
  632. &dev_attr_in5_max.attr,
  633. &sensor_dev_attr_in5_alarm.dev_attr.attr,
  634. NULL
  635. }
  636. };
  637. static const struct attribute_group vt8231_group_volts[6] = {
  638. { .attrs = vt8231_attributes_volts[0] },
  639. { .attrs = vt8231_attributes_volts[1] },
  640. { .attrs = vt8231_attributes_volts[2] },
  641. { .attrs = vt8231_attributes_volts[3] },
  642. { .attrs = vt8231_attributes_volts[4] },
  643. { .attrs = vt8231_attributes_volts[5] },
  644. };
  645. static struct attribute *vt8231_attributes[] = {
  646. &sensor_dev_attr_fan1_input.dev_attr.attr,
  647. &sensor_dev_attr_fan2_input.dev_attr.attr,
  648. &sensor_dev_attr_fan1_min.dev_attr.attr,
  649. &sensor_dev_attr_fan2_min.dev_attr.attr,
  650. &sensor_dev_attr_fan1_div.dev_attr.attr,
  651. &sensor_dev_attr_fan2_div.dev_attr.attr,
  652. &sensor_dev_attr_fan1_alarm.dev_attr.attr,
  653. &sensor_dev_attr_fan2_alarm.dev_attr.attr,
  654. &dev_attr_alarms.attr,
  655. &dev_attr_name.attr,
  656. NULL
  657. };
  658. static const struct attribute_group vt8231_group = {
  659. .attrs = vt8231_attributes,
  660. };
  661. static struct platform_driver vt8231_driver = {
  662. .driver = {
  663. .name = "vt8231",
  664. },
  665. .probe = vt8231_probe,
  666. .remove = vt8231_remove,
  667. };
  668. static const struct pci_device_id vt8231_pci_ids[] = {
  669. { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8231_4) },
  670. { 0, }
  671. };
  672. MODULE_DEVICE_TABLE(pci, vt8231_pci_ids);
  673. static int vt8231_pci_probe(struct pci_dev *dev,
  674. const struct pci_device_id *id);
  675. static struct pci_driver vt8231_pci_driver = {
  676. .name = "vt8231",
  677. .id_table = vt8231_pci_ids,
  678. .probe = vt8231_pci_probe,
  679. };
  680. static int vt8231_probe(struct platform_device *pdev)
  681. {
  682. struct resource *res;
  683. struct vt8231_data *data;
  684. int err = 0, i;
  685. /* Reserve the ISA region */
  686. res = platform_get_resource(pdev, IORESOURCE_IO, 0);
  687. if (!devm_request_region(&pdev->dev, res->start, VT8231_EXTENT,
  688. vt8231_driver.driver.name)) {
  689. dev_err(&pdev->dev, "Region 0x%lx-0x%lx already in use!\n",
  690. (unsigned long)res->start, (unsigned long)res->end);
  691. return -ENODEV;
  692. }
  693. data = devm_kzalloc(&pdev->dev, sizeof(struct vt8231_data), GFP_KERNEL);
  694. if (!data)
  695. return -ENOMEM;
  696. platform_set_drvdata(pdev, data);
  697. data->addr = res->start;
  698. data->name = "vt8231";
  699. mutex_init(&data->update_lock);
  700. vt8231_init_device(data);
  701. /* Register sysfs hooks */
  702. err = sysfs_create_group(&pdev->dev.kobj, &vt8231_group);
  703. if (err)
  704. return err;
  705. /* Must update device information to find out the config field */
  706. data->uch_config = vt8231_read_value(data, VT8231_REG_UCH_CONFIG);
  707. for (i = 0; i < ARRAY_SIZE(vt8231_group_temps); i++) {
  708. if (ISTEMP(i, data->uch_config)) {
  709. err = sysfs_create_group(&pdev->dev.kobj,
  710. &vt8231_group_temps[i]);
  711. if (err)
  712. goto exit_remove_files;
  713. }
  714. }
  715. for (i = 0; i < ARRAY_SIZE(vt8231_group_volts); i++) {
  716. if (ISVOLT(i, data->uch_config)) {
  717. err = sysfs_create_group(&pdev->dev.kobj,
  718. &vt8231_group_volts[i]);
  719. if (err)
  720. goto exit_remove_files;
  721. }
  722. }
  723. data->hwmon_dev = hwmon_device_register(&pdev->dev);
  724. if (IS_ERR(data->hwmon_dev)) {
  725. err = PTR_ERR(data->hwmon_dev);
  726. goto exit_remove_files;
  727. }
  728. return 0;
  729. exit_remove_files:
  730. for (i = 0; i < ARRAY_SIZE(vt8231_group_volts); i++)
  731. sysfs_remove_group(&pdev->dev.kobj, &vt8231_group_volts[i]);
  732. for (i = 0; i < ARRAY_SIZE(vt8231_group_temps); i++)
  733. sysfs_remove_group(&pdev->dev.kobj, &vt8231_group_temps[i]);
  734. sysfs_remove_group(&pdev->dev.kobj, &vt8231_group);
  735. return err;
  736. }
  737. static int vt8231_remove(struct platform_device *pdev)
  738. {
  739. struct vt8231_data *data = platform_get_drvdata(pdev);
  740. int i;
  741. hwmon_device_unregister(data->hwmon_dev);
  742. for (i = 0; i < ARRAY_SIZE(vt8231_group_volts); i++)
  743. sysfs_remove_group(&pdev->dev.kobj, &vt8231_group_volts[i]);
  744. for (i = 0; i < ARRAY_SIZE(vt8231_group_temps); i++)
  745. sysfs_remove_group(&pdev->dev.kobj, &vt8231_group_temps[i]);
  746. sysfs_remove_group(&pdev->dev.kobj, &vt8231_group);
  747. return 0;
  748. }
  749. static void vt8231_init_device(struct vt8231_data *data)
  750. {
  751. vt8231_write_value(data, VT8231_REG_TEMP1_CONFIG, 0);
  752. vt8231_write_value(data, VT8231_REG_TEMP2_CONFIG, 0);
  753. }
  754. static struct vt8231_data *vt8231_update_device(struct device *dev)
  755. {
  756. struct vt8231_data *data = dev_get_drvdata(dev);
  757. int i;
  758. u16 low;
  759. mutex_lock(&data->update_lock);
  760. if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
  761. || !data->valid) {
  762. for (i = 0; i < 6; i++) {
  763. if (ISVOLT(i, data->uch_config)) {
  764. data->in[i] = vt8231_read_value(data,
  765. regvolt[i]);
  766. data->in_min[i] = vt8231_read_value(data,
  767. regvoltmin[i]);
  768. data->in_max[i] = vt8231_read_value(data,
  769. regvoltmax[i]);
  770. }
  771. }
  772. for (i = 0; i < 2; i++) {
  773. data->fan[i] = vt8231_read_value(data,
  774. VT8231_REG_FAN(i));
  775. data->fan_min[i] = vt8231_read_value(data,
  776. VT8231_REG_FAN_MIN(i));
  777. }
  778. low = vt8231_read_value(data, VT8231_REG_TEMP_LOW01);
  779. low = (low >> 6) | ((low & 0x30) >> 2)
  780. | (vt8231_read_value(data, VT8231_REG_TEMP_LOW25) << 4);
  781. for (i = 0; i < 6; i++) {
  782. if (ISTEMP(i, data->uch_config)) {
  783. data->temp[i] = (vt8231_read_value(data,
  784. regtemp[i]) << 2)
  785. | ((low >> (2 * i)) & 0x03);
  786. data->temp_max[i] = vt8231_read_value(data,
  787. regtempmax[i]);
  788. data->temp_min[i] = vt8231_read_value(data,
  789. regtempmin[i]);
  790. }
  791. }
  792. i = vt8231_read_value(data, VT8231_REG_FANDIV);
  793. data->fan_div[0] = (i >> 4) & 0x03;
  794. data->fan_div[1] = i >> 6;
  795. data->alarms = vt8231_read_value(data, VT8231_REG_ALARM1) |
  796. (vt8231_read_value(data, VT8231_REG_ALARM2) << 8);
  797. /* Set alarm flags correctly */
  798. if (!data->fan[0] && data->fan_min[0])
  799. data->alarms |= 0x40;
  800. else if (data->fan[0] && !data->fan_min[0])
  801. data->alarms &= ~0x40;
  802. if (!data->fan[1] && data->fan_min[1])
  803. data->alarms |= 0x80;
  804. else if (data->fan[1] && !data->fan_min[1])
  805. data->alarms &= ~0x80;
  806. data->last_updated = jiffies;
  807. data->valid = 1;
  808. }
  809. mutex_unlock(&data->update_lock);
  810. return data;
  811. }
  812. static int vt8231_device_add(unsigned short address)
  813. {
  814. struct resource res = {
  815. .start = address,
  816. .end = address + VT8231_EXTENT - 1,
  817. .name = "vt8231",
  818. .flags = IORESOURCE_IO,
  819. };
  820. int err;
  821. err = acpi_check_resource_conflict(&res);
  822. if (err)
  823. goto exit;
  824. pdev = platform_device_alloc("vt8231", address);
  825. if (!pdev) {
  826. err = -ENOMEM;
  827. pr_err("Device allocation failed\n");
  828. goto exit;
  829. }
  830. err = platform_device_add_resources(pdev, &res, 1);
  831. if (err) {
  832. pr_err("Device resource addition failed (%d)\n", err);
  833. goto exit_device_put;
  834. }
  835. err = platform_device_add(pdev);
  836. if (err) {
  837. pr_err("Device addition failed (%d)\n", err);
  838. goto exit_device_put;
  839. }
  840. return 0;
  841. exit_device_put:
  842. platform_device_put(pdev);
  843. exit:
  844. return err;
  845. }
  846. static int vt8231_pci_probe(struct pci_dev *dev,
  847. const struct pci_device_id *id)
  848. {
  849. u16 address, val;
  850. if (force_addr) {
  851. address = force_addr & 0xff00;
  852. dev_warn(&dev->dev, "Forcing ISA address 0x%x\n",
  853. address);
  854. if (PCIBIOS_SUCCESSFUL !=
  855. pci_write_config_word(dev, VT8231_BASE_REG, address | 1))
  856. return -ENODEV;
  857. }
  858. pci_read_config_word(dev, VT8231_BASE_REG, &val);
  859. if (val == (u16)~0)
  860. return -ENODEV;
  861. address = val & ~(VT8231_EXTENT - 1);
  862. if (address == 0) {
  863. dev_err(&dev->dev, "base address not set - upgrade BIOS or use force_addr=0xaddr\n");
  864. return -ENODEV;
  865. }
  866. pci_read_config_word(dev, VT8231_ENABLE_REG, &val);
  867. if (val == (u16)~0)
  868. return -ENODEV;
  869. if (!(val & 0x0001)) {
  870. dev_warn(&dev->dev, "enabling sensors\n");
  871. if (PCIBIOS_SUCCESSFUL !=
  872. pci_write_config_word(dev, VT8231_ENABLE_REG,
  873. val | 0x0001))
  874. return -ENODEV;
  875. }
  876. if (platform_driver_register(&vt8231_driver))
  877. goto exit;
  878. /* Sets global pdev as a side effect */
  879. if (vt8231_device_add(address))
  880. goto exit_unregister;
  881. /*
  882. * Always return failure here. This is to allow other drivers to bind
  883. * to this pci device. We don't really want to have control over the
  884. * pci device, we only wanted to read as few register values from it.
  885. */
  886. /*
  887. * We do, however, mark ourselves as using the PCI device to stop it
  888. * getting unloaded.
  889. */
  890. s_bridge = pci_dev_get(dev);
  891. return -ENODEV;
  892. exit_unregister:
  893. platform_driver_unregister(&vt8231_driver);
  894. exit:
  895. return -ENODEV;
  896. }
  897. static int __init sm_vt8231_init(void)
  898. {
  899. return pci_register_driver(&vt8231_pci_driver);
  900. }
  901. static void __exit sm_vt8231_exit(void)
  902. {
  903. pci_unregister_driver(&vt8231_pci_driver);
  904. if (s_bridge != NULL) {
  905. platform_device_unregister(pdev);
  906. platform_driver_unregister(&vt8231_driver);
  907. pci_dev_put(s_bridge);
  908. s_bridge = NULL;
  909. }
  910. }
  911. MODULE_AUTHOR("Roger Lucas <vt8231@hiddenengine.co.uk>");
  912. MODULE_DESCRIPTION("VT8231 sensors");
  913. MODULE_LICENSE("GPL");
  914. module_init(sm_vt8231_init);
  915. module_exit(sm_vt8231_exit);