pc87360.c 46 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460
  1. /*
  2. * pc87360.c - Part of lm_sensors, Linux kernel modules
  3. * for hardware monitoring
  4. * Copyright (C) 2004 Jean Delvare <khali@linux-fr.org>
  5. *
  6. * Copied from smsc47m1.c:
  7. * Copyright (C) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com>
  8. *
  9. * This program is free software; you can redistribute it and/or modify
  10. * it under the terms of the GNU General Public License as published by
  11. * the Free Software Foundation; either version 2 of the License, or
  12. * (at your option) any later version.
  13. *
  14. * This program is distributed in the hope that it will be useful,
  15. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17. * GNU General Public License for more details.
  18. *
  19. * You should have received a copy of the GNU General Public License
  20. * along with this program; if not, write to the Free Software
  21. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22. *
  23. * Supports the following chips:
  24. *
  25. * Chip #vin #fan #pwm #temp devid
  26. * PC87360 - 2 2 - 0xE1
  27. * PC87363 - 2 2 - 0xE8
  28. * PC87364 - 3 3 - 0xE4
  29. * PC87365 11 3 3 2 0xE5
  30. * PC87366 11 3 3 3-4 0xE9
  31. *
  32. * This driver assumes that no more than one chip is present, and one of
  33. * the standard Super-I/O addresses is used (0x2E/0x2F or 0x4E/0x4F).
  34. */
  35. #include <linux/module.h>
  36. #include <linux/init.h>
  37. #include <linux/slab.h>
  38. #include <linux/jiffies.h>
  39. #include <linux/i2c.h>
  40. #include <linux/i2c-isa.h>
  41. #include <linux/hwmon.h>
  42. #include <linux/hwmon-sysfs.h>
  43. #include <linux/hwmon-vid.h>
  44. #include <linux/err.h>
  45. #include <linux/mutex.h>
  46. #include <asm/io.h>
  47. static u8 devid;
  48. static unsigned short address;
  49. static unsigned short extra_isa[3];
  50. static u8 confreg[4];
  51. enum chips { any_chip, pc87360, pc87363, pc87364, pc87365, pc87366 };
  52. static int init = 1;
  53. module_param(init, int, 0);
  54. MODULE_PARM_DESC(init,
  55. "Chip initialization level:\n"
  56. " 0: None\n"
  57. "*1: Forcibly enable internal voltage and temperature channels, except in9\n"
  58. " 2: Forcibly enable all voltage and temperature channels, except in9\n"
  59. " 3: Forcibly enable all voltage and temperature channels, including in9");
  60. /*
  61. * Super-I/O registers and operations
  62. */
  63. #define DEV 0x07 /* Register: Logical device select */
  64. #define DEVID 0x20 /* Register: Device ID */
  65. #define ACT 0x30 /* Register: Device activation */
  66. #define BASE 0x60 /* Register: Base address */
  67. #define FSCM 0x09 /* Logical device: fans */
  68. #define VLM 0x0d /* Logical device: voltages */
  69. #define TMS 0x0e /* Logical device: temperatures */
  70. static const u8 logdev[3] = { FSCM, VLM, TMS };
  71. #define LD_FAN 0
  72. #define LD_IN 1
  73. #define LD_TEMP 2
  74. static inline void superio_outb(int sioaddr, int reg, int val)
  75. {
  76. outb(reg, sioaddr);
  77. outb(val, sioaddr+1);
  78. }
  79. static inline int superio_inb(int sioaddr, int reg)
  80. {
  81. outb(reg, sioaddr);
  82. return inb(sioaddr+1);
  83. }
  84. static inline void superio_exit(int sioaddr)
  85. {
  86. outb(0x02, sioaddr);
  87. outb(0x02, sioaddr+1);
  88. }
  89. /*
  90. * Logical devices
  91. */
  92. #define PC87360_EXTENT 0x10
  93. #define PC87365_REG_BANK 0x09
  94. #define NO_BANK 0xff
  95. /*
  96. * Fan registers and conversions
  97. */
  98. /* nr has to be 0 or 1 (PC87360/87363) or 2 (PC87364/87365/87366) */
  99. #define PC87360_REG_PRESCALE(nr) (0x00 + 2 * (nr))
  100. #define PC87360_REG_PWM(nr) (0x01 + 2 * (nr))
  101. #define PC87360_REG_FAN_MIN(nr) (0x06 + 3 * (nr))
  102. #define PC87360_REG_FAN(nr) (0x07 + 3 * (nr))
  103. #define PC87360_REG_FAN_STATUS(nr) (0x08 + 3 * (nr))
  104. #define FAN_FROM_REG(val,div) ((val) == 0 ? 0: \
  105. 480000 / ((val)*(div)))
  106. #define FAN_TO_REG(val,div) ((val) <= 100 ? 0 : \
  107. 480000 / ((val)*(div)))
  108. #define FAN_DIV_FROM_REG(val) (1 << ((val >> 5) & 0x03))
  109. #define FAN_STATUS_FROM_REG(val) ((val) & 0x07)
  110. #define FAN_CONFIG_MONITOR(val,nr) (((val) >> (2 + nr * 3)) & 1)
  111. #define FAN_CONFIG_CONTROL(val,nr) (((val) >> (3 + nr * 3)) & 1)
  112. #define FAN_CONFIG_INVERT(val,nr) (((val) >> (4 + nr * 3)) & 1)
  113. #define PWM_FROM_REG(val,inv) ((inv) ? 255 - (val) : (val))
  114. static inline u8 PWM_TO_REG(int val, int inv)
  115. {
  116. if (inv)
  117. val = 255 - val;
  118. if (val < 0)
  119. return 0;
  120. if (val > 255)
  121. return 255;
  122. return val;
  123. }
  124. /*
  125. * Voltage registers and conversions
  126. */
  127. #define PC87365_REG_IN_CONVRATE 0x07
  128. #define PC87365_REG_IN_CONFIG 0x08
  129. #define PC87365_REG_IN 0x0B
  130. #define PC87365_REG_IN_MIN 0x0D
  131. #define PC87365_REG_IN_MAX 0x0C
  132. #define PC87365_REG_IN_STATUS 0x0A
  133. #define PC87365_REG_IN_ALARMS1 0x00
  134. #define PC87365_REG_IN_ALARMS2 0x01
  135. #define PC87365_REG_VID 0x06
  136. #define IN_FROM_REG(val,ref) (((val) * (ref) + 128) / 256)
  137. #define IN_TO_REG(val,ref) ((val) < 0 ? 0 : \
  138. (val)*256 >= (ref)*255 ? 255: \
  139. ((val) * 256 + (ref)/2) / (ref))
  140. /*
  141. * Temperature registers and conversions
  142. */
  143. #define PC87365_REG_TEMP_CONFIG 0x08
  144. #define PC87365_REG_TEMP 0x0B
  145. #define PC87365_REG_TEMP_MIN 0x0D
  146. #define PC87365_REG_TEMP_MAX 0x0C
  147. #define PC87365_REG_TEMP_CRIT 0x0E
  148. #define PC87365_REG_TEMP_STATUS 0x0A
  149. #define PC87365_REG_TEMP_ALARMS 0x00
  150. #define TEMP_FROM_REG(val) ((val) * 1000)
  151. #define TEMP_TO_REG(val) ((val) < -55000 ? -55 : \
  152. (val) > 127000 ? 127 : \
  153. (val) < 0 ? ((val) - 500) / 1000 : \
  154. ((val) + 500) / 1000)
  155. /*
  156. * Client data (each client gets its own)
  157. */
  158. struct pc87360_data {
  159. struct i2c_client client;
  160. struct class_device *class_dev;
  161. struct mutex lock;
  162. struct mutex update_lock;
  163. char valid; /* !=0 if following fields are valid */
  164. unsigned long last_updated; /* In jiffies */
  165. int address[3];
  166. u8 fannr, innr, tempnr;
  167. u8 fan[3]; /* Register value */
  168. u8 fan_min[3]; /* Register value */
  169. u8 fan_status[3]; /* Register value */
  170. u8 pwm[3]; /* Register value */
  171. u16 fan_conf; /* Configuration register values, combined */
  172. u16 in_vref; /* 1 mV/bit */
  173. u8 in[14]; /* Register value */
  174. u8 in_min[14]; /* Register value */
  175. u8 in_max[14]; /* Register value */
  176. u8 in_crit[3]; /* Register value */
  177. u8 in_status[14]; /* Register value */
  178. u16 in_alarms; /* Register values, combined, masked */
  179. u8 vid_conf; /* Configuration register value */
  180. u8 vrm;
  181. u8 vid; /* Register value */
  182. s8 temp[3]; /* Register value */
  183. s8 temp_min[3]; /* Register value */
  184. s8 temp_max[3]; /* Register value */
  185. s8 temp_crit[3]; /* Register value */
  186. u8 temp_status[3]; /* Register value */
  187. u8 temp_alarms; /* Register value, masked */
  188. };
  189. /*
  190. * Functions declaration
  191. */
  192. static int pc87360_detect(struct i2c_adapter *adapter);
  193. static int pc87360_detach_client(struct i2c_client *client);
  194. static int pc87360_read_value(struct pc87360_data *data, u8 ldi, u8 bank,
  195. u8 reg);
  196. static void pc87360_write_value(struct pc87360_data *data, u8 ldi, u8 bank,
  197. u8 reg, u8 value);
  198. static void pc87360_init_client(struct i2c_client *client, int use_thermistors);
  199. static struct pc87360_data *pc87360_update_device(struct device *dev);
  200. /*
  201. * Driver data (common to all clients)
  202. */
  203. static struct i2c_driver pc87360_driver = {
  204. .driver = {
  205. .owner = THIS_MODULE,
  206. .name = "pc87360",
  207. },
  208. .attach_adapter = pc87360_detect,
  209. .detach_client = pc87360_detach_client,
  210. };
  211. /*
  212. * Sysfs stuff
  213. */
  214. static ssize_t show_fan_input(struct device *dev, struct device_attribute *devattr, char *buf)
  215. {
  216. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  217. struct pc87360_data *data = pc87360_update_device(dev);
  218. return sprintf(buf, "%u\n", FAN_FROM_REG(data->fan[attr->index],
  219. FAN_DIV_FROM_REG(data->fan_status[attr->index])));
  220. }
  221. static ssize_t show_fan_min(struct device *dev, struct device_attribute *devattr, char *buf)
  222. {
  223. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  224. struct pc87360_data *data = pc87360_update_device(dev);
  225. return sprintf(buf, "%u\n", FAN_FROM_REG(data->fan_min[attr->index],
  226. FAN_DIV_FROM_REG(data->fan_status[attr->index])));
  227. }
  228. static ssize_t show_fan_div(struct device *dev, struct device_attribute *devattr, char *buf)
  229. {
  230. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  231. struct pc87360_data *data = pc87360_update_device(dev);
  232. return sprintf(buf, "%u\n",
  233. FAN_DIV_FROM_REG(data->fan_status[attr->index]));
  234. }
  235. static ssize_t show_fan_status(struct device *dev, struct device_attribute *devattr, char *buf)
  236. {
  237. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  238. struct pc87360_data *data = pc87360_update_device(dev);
  239. return sprintf(buf, "%u\n",
  240. FAN_STATUS_FROM_REG(data->fan_status[attr->index]));
  241. }
  242. static ssize_t set_fan_min(struct device *dev, struct device_attribute *devattr, const char *buf,
  243. size_t count)
  244. {
  245. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  246. struct i2c_client *client = to_i2c_client(dev);
  247. struct pc87360_data *data = i2c_get_clientdata(client);
  248. long fan_min = simple_strtol(buf, NULL, 10);
  249. mutex_lock(&data->update_lock);
  250. fan_min = FAN_TO_REG(fan_min, FAN_DIV_FROM_REG(data->fan_status[attr->index]));
  251. /* If it wouldn't fit, change clock divisor */
  252. while (fan_min > 255
  253. && (data->fan_status[attr->index] & 0x60) != 0x60) {
  254. fan_min >>= 1;
  255. data->fan[attr->index] >>= 1;
  256. data->fan_status[attr->index] += 0x20;
  257. }
  258. data->fan_min[attr->index] = fan_min > 255 ? 255 : fan_min;
  259. pc87360_write_value(data, LD_FAN, NO_BANK, PC87360_REG_FAN_MIN(attr->index),
  260. data->fan_min[attr->index]);
  261. /* Write new divider, preserve alarm bits */
  262. pc87360_write_value(data, LD_FAN, NO_BANK, PC87360_REG_FAN_STATUS(attr->index),
  263. data->fan_status[attr->index] & 0xF9);
  264. mutex_unlock(&data->update_lock);
  265. return count;
  266. }
  267. static struct sensor_device_attribute fan_input[] = {
  268. SENSOR_ATTR(fan1_input, S_IRUGO, show_fan_input, NULL, 0),
  269. SENSOR_ATTR(fan2_input, S_IRUGO, show_fan_input, NULL, 1),
  270. SENSOR_ATTR(fan3_input, S_IRUGO, show_fan_input, NULL, 2),
  271. };
  272. static struct sensor_device_attribute fan_status[] = {
  273. SENSOR_ATTR(fan1_status, S_IRUGO, show_fan_status, NULL, 0),
  274. SENSOR_ATTR(fan2_status, S_IRUGO, show_fan_status, NULL, 1),
  275. SENSOR_ATTR(fan3_status, S_IRUGO, show_fan_status, NULL, 2),
  276. };
  277. static struct sensor_device_attribute fan_div[] = {
  278. SENSOR_ATTR(fan1_div, S_IRUGO, show_fan_div, NULL, 0),
  279. SENSOR_ATTR(fan2_div, S_IRUGO, show_fan_div, NULL, 1),
  280. SENSOR_ATTR(fan3_div, S_IRUGO, show_fan_div, NULL, 2),
  281. };
  282. static struct sensor_device_attribute fan_min[] = {
  283. SENSOR_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min, set_fan_min, 0),
  284. SENSOR_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min, set_fan_min, 1),
  285. SENSOR_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min, set_fan_min, 2),
  286. };
  287. #define FAN_UNIT_ATTRS(X) \
  288. &fan_input[X].dev_attr.attr, \
  289. &fan_status[X].dev_attr.attr, \
  290. &fan_div[X].dev_attr.attr, \
  291. &fan_min[X].dev_attr.attr
  292. static ssize_t show_pwm(struct device *dev, struct device_attribute *devattr, char *buf)
  293. {
  294. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  295. struct pc87360_data *data = pc87360_update_device(dev);
  296. return sprintf(buf, "%u\n",
  297. PWM_FROM_REG(data->pwm[attr->index],
  298. FAN_CONFIG_INVERT(data->fan_conf,
  299. attr->index)));
  300. }
  301. static ssize_t set_pwm(struct device *dev, struct device_attribute *devattr, const char *buf,
  302. size_t count)
  303. {
  304. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  305. struct i2c_client *client = to_i2c_client(dev);
  306. struct pc87360_data *data = i2c_get_clientdata(client);
  307. long val = simple_strtol(buf, NULL, 10);
  308. mutex_lock(&data->update_lock);
  309. data->pwm[attr->index] = PWM_TO_REG(val,
  310. FAN_CONFIG_INVERT(data->fan_conf, attr->index));
  311. pc87360_write_value(data, LD_FAN, NO_BANK, PC87360_REG_PWM(attr->index),
  312. data->pwm[attr->index]);
  313. mutex_unlock(&data->update_lock);
  314. return count;
  315. }
  316. static struct sensor_device_attribute pwm[] = {
  317. SENSOR_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 0),
  318. SENSOR_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 1),
  319. SENSOR_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 2),
  320. };
  321. static struct attribute * pc8736x_fan_attr_array[] = {
  322. FAN_UNIT_ATTRS(0),
  323. FAN_UNIT_ATTRS(1),
  324. FAN_UNIT_ATTRS(2),
  325. &pwm[0].dev_attr.attr,
  326. &pwm[1].dev_attr.attr,
  327. &pwm[2].dev_attr.attr,
  328. NULL
  329. };
  330. static const struct attribute_group pc8736x_fan_group = {
  331. .attrs = pc8736x_fan_attr_array,
  332. };
  333. static ssize_t show_in_input(struct device *dev, struct device_attribute *devattr, char *buf)
  334. {
  335. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  336. struct pc87360_data *data = pc87360_update_device(dev);
  337. return sprintf(buf, "%u\n", IN_FROM_REG(data->in[attr->index],
  338. data->in_vref));
  339. }
  340. static ssize_t show_in_min(struct device *dev, struct device_attribute *devattr, char *buf)
  341. {
  342. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  343. struct pc87360_data *data = pc87360_update_device(dev);
  344. return sprintf(buf, "%u\n", IN_FROM_REG(data->in_min[attr->index],
  345. data->in_vref));
  346. }
  347. static ssize_t show_in_max(struct device *dev, struct device_attribute *devattr, char *buf)
  348. {
  349. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  350. struct pc87360_data *data = pc87360_update_device(dev);
  351. return sprintf(buf, "%u\n", IN_FROM_REG(data->in_max[attr->index],
  352. data->in_vref));
  353. }
  354. static ssize_t show_in_status(struct device *dev, struct device_attribute *devattr, char *buf)
  355. {
  356. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  357. struct pc87360_data *data = pc87360_update_device(dev);
  358. return sprintf(buf, "%u\n", data->in_status[attr->index]);
  359. }
  360. static ssize_t set_in_min(struct device *dev, struct device_attribute *devattr, const char *buf,
  361. size_t count)
  362. {
  363. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  364. struct i2c_client *client = to_i2c_client(dev);
  365. struct pc87360_data *data = i2c_get_clientdata(client);
  366. long val = simple_strtol(buf, NULL, 10);
  367. mutex_lock(&data->update_lock);
  368. data->in_min[attr->index] = IN_TO_REG(val, data->in_vref);
  369. pc87360_write_value(data, LD_IN, attr->index, PC87365_REG_IN_MIN,
  370. data->in_min[attr->index]);
  371. mutex_unlock(&data->update_lock);
  372. return count;
  373. }
  374. static ssize_t set_in_max(struct device *dev, struct device_attribute *devattr, const char *buf,
  375. size_t count)
  376. {
  377. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  378. struct i2c_client *client = to_i2c_client(dev);
  379. struct pc87360_data *data = i2c_get_clientdata(client);
  380. long val = simple_strtol(buf, NULL, 10);
  381. mutex_lock(&data->update_lock);
  382. data->in_max[attr->index] = IN_TO_REG(val,
  383. data->in_vref);
  384. pc87360_write_value(data, LD_IN, attr->index, PC87365_REG_IN_MAX,
  385. data->in_max[attr->index]);
  386. mutex_unlock(&data->update_lock);
  387. return count;
  388. }
  389. static struct sensor_device_attribute in_input[] = {
  390. SENSOR_ATTR(in0_input, S_IRUGO, show_in_input, NULL, 0),
  391. SENSOR_ATTR(in1_input, S_IRUGO, show_in_input, NULL, 1),
  392. SENSOR_ATTR(in2_input, S_IRUGO, show_in_input, NULL, 2),
  393. SENSOR_ATTR(in3_input, S_IRUGO, show_in_input, NULL, 3),
  394. SENSOR_ATTR(in4_input, S_IRUGO, show_in_input, NULL, 4),
  395. SENSOR_ATTR(in5_input, S_IRUGO, show_in_input, NULL, 5),
  396. SENSOR_ATTR(in6_input, S_IRUGO, show_in_input, NULL, 6),
  397. SENSOR_ATTR(in7_input, S_IRUGO, show_in_input, NULL, 7),
  398. SENSOR_ATTR(in8_input, S_IRUGO, show_in_input, NULL, 8),
  399. SENSOR_ATTR(in9_input, S_IRUGO, show_in_input, NULL, 9),
  400. SENSOR_ATTR(in10_input, S_IRUGO, show_in_input, NULL, 10),
  401. };
  402. static struct sensor_device_attribute in_status[] = {
  403. SENSOR_ATTR(in0_status, S_IRUGO, show_in_status, NULL, 0),
  404. SENSOR_ATTR(in1_status, S_IRUGO, show_in_status, NULL, 1),
  405. SENSOR_ATTR(in2_status, S_IRUGO, show_in_status, NULL, 2),
  406. SENSOR_ATTR(in3_status, S_IRUGO, show_in_status, NULL, 3),
  407. SENSOR_ATTR(in4_status, S_IRUGO, show_in_status, NULL, 4),
  408. SENSOR_ATTR(in5_status, S_IRUGO, show_in_status, NULL, 5),
  409. SENSOR_ATTR(in6_status, S_IRUGO, show_in_status, NULL, 6),
  410. SENSOR_ATTR(in7_status, S_IRUGO, show_in_status, NULL, 7),
  411. SENSOR_ATTR(in8_status, S_IRUGO, show_in_status, NULL, 8),
  412. SENSOR_ATTR(in9_status, S_IRUGO, show_in_status, NULL, 9),
  413. SENSOR_ATTR(in10_status, S_IRUGO, show_in_status, NULL, 10),
  414. };
  415. static struct sensor_device_attribute in_min[] = {
  416. SENSOR_ATTR(in0_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 0),
  417. SENSOR_ATTR(in1_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 1),
  418. SENSOR_ATTR(in2_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 2),
  419. SENSOR_ATTR(in3_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 3),
  420. SENSOR_ATTR(in4_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 4),
  421. SENSOR_ATTR(in5_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 5),
  422. SENSOR_ATTR(in6_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 6),
  423. SENSOR_ATTR(in7_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 7),
  424. SENSOR_ATTR(in8_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 8),
  425. SENSOR_ATTR(in9_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 9),
  426. SENSOR_ATTR(in10_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 10),
  427. };
  428. static struct sensor_device_attribute in_max[] = {
  429. SENSOR_ATTR(in0_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 0),
  430. SENSOR_ATTR(in1_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 1),
  431. SENSOR_ATTR(in2_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 2),
  432. SENSOR_ATTR(in3_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 3),
  433. SENSOR_ATTR(in4_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 4),
  434. SENSOR_ATTR(in5_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 5),
  435. SENSOR_ATTR(in6_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 6),
  436. SENSOR_ATTR(in7_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 7),
  437. SENSOR_ATTR(in8_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 8),
  438. SENSOR_ATTR(in9_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 9),
  439. SENSOR_ATTR(in10_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 10),
  440. };
  441. #define VIN_UNIT_ATTRS(X) \
  442. &in_input[X].dev_attr.attr, \
  443. &in_status[X].dev_attr.attr, \
  444. &in_min[X].dev_attr.attr, \
  445. &in_max[X].dev_attr.attr
  446. static ssize_t show_vid(struct device *dev, struct device_attribute *attr, char *buf)
  447. {
  448. struct pc87360_data *data = pc87360_update_device(dev);
  449. return sprintf(buf, "%u\n", vid_from_reg(data->vid, data->vrm));
  450. }
  451. static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
  452. static ssize_t show_vrm(struct device *dev, struct device_attribute *attr, char *buf)
  453. {
  454. struct pc87360_data *data = pc87360_update_device(dev);
  455. return sprintf(buf, "%u\n", data->vrm);
  456. }
  457. static ssize_t set_vrm(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
  458. {
  459. struct i2c_client *client = to_i2c_client(dev);
  460. struct pc87360_data *data = i2c_get_clientdata(client);
  461. data->vrm = simple_strtoul(buf, NULL, 10);
  462. return count;
  463. }
  464. static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm, set_vrm);
  465. static ssize_t show_in_alarms(struct device *dev, struct device_attribute *attr, char *buf)
  466. {
  467. struct pc87360_data *data = pc87360_update_device(dev);
  468. return sprintf(buf, "%u\n", data->in_alarms);
  469. }
  470. static DEVICE_ATTR(alarms_in, S_IRUGO, show_in_alarms, NULL);
  471. static struct attribute *pc8736x_vin_attr_array[] = {
  472. VIN_UNIT_ATTRS(0),
  473. VIN_UNIT_ATTRS(1),
  474. VIN_UNIT_ATTRS(2),
  475. VIN_UNIT_ATTRS(3),
  476. VIN_UNIT_ATTRS(4),
  477. VIN_UNIT_ATTRS(5),
  478. VIN_UNIT_ATTRS(6),
  479. VIN_UNIT_ATTRS(7),
  480. VIN_UNIT_ATTRS(8),
  481. VIN_UNIT_ATTRS(9),
  482. VIN_UNIT_ATTRS(10),
  483. &dev_attr_cpu0_vid.attr,
  484. &dev_attr_vrm.attr,
  485. &dev_attr_alarms_in.attr,
  486. NULL
  487. };
  488. static const struct attribute_group pc8736x_vin_group = {
  489. .attrs = pc8736x_vin_attr_array,
  490. };
  491. static ssize_t show_therm_input(struct device *dev, struct device_attribute *devattr, char *buf)
  492. {
  493. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  494. struct pc87360_data *data = pc87360_update_device(dev);
  495. return sprintf(buf, "%u\n", IN_FROM_REG(data->in[attr->index],
  496. data->in_vref));
  497. }
  498. static ssize_t show_therm_min(struct device *dev, struct device_attribute *devattr, char *buf)
  499. {
  500. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  501. struct pc87360_data *data = pc87360_update_device(dev);
  502. return sprintf(buf, "%u\n", IN_FROM_REG(data->in_min[attr->index],
  503. data->in_vref));
  504. }
  505. static ssize_t show_therm_max(struct device *dev, struct device_attribute *devattr, char *buf)
  506. {
  507. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  508. struct pc87360_data *data = pc87360_update_device(dev);
  509. return sprintf(buf, "%u\n", IN_FROM_REG(data->in_max[attr->index],
  510. data->in_vref));
  511. }
  512. static ssize_t show_therm_crit(struct device *dev, struct device_attribute *devattr, char *buf)
  513. {
  514. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  515. struct pc87360_data *data = pc87360_update_device(dev);
  516. return sprintf(buf, "%u\n", IN_FROM_REG(data->in_crit[attr->index-11],
  517. data->in_vref));
  518. }
  519. static ssize_t show_therm_status(struct device *dev, struct device_attribute *devattr, char *buf)
  520. {
  521. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  522. struct pc87360_data *data = pc87360_update_device(dev);
  523. return sprintf(buf, "%u\n", data->in_status[attr->index]);
  524. }
  525. static ssize_t set_therm_min(struct device *dev, struct device_attribute *devattr, const char *buf,
  526. size_t count)
  527. {
  528. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  529. struct i2c_client *client = to_i2c_client(dev);
  530. struct pc87360_data *data = i2c_get_clientdata(client);
  531. long val = simple_strtol(buf, NULL, 10);
  532. mutex_lock(&data->update_lock);
  533. data->in_min[attr->index] = IN_TO_REG(val, data->in_vref);
  534. pc87360_write_value(data, LD_IN, attr->index, PC87365_REG_TEMP_MIN,
  535. data->in_min[attr->index]);
  536. mutex_unlock(&data->update_lock);
  537. return count;
  538. }
  539. static ssize_t set_therm_max(struct device *dev, struct device_attribute *devattr, const char *buf,
  540. size_t count)
  541. {
  542. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  543. struct i2c_client *client = to_i2c_client(dev);
  544. struct pc87360_data *data = i2c_get_clientdata(client);
  545. long val = simple_strtol(buf, NULL, 10);
  546. mutex_lock(&data->update_lock);
  547. data->in_max[attr->index] = IN_TO_REG(val, data->in_vref);
  548. pc87360_write_value(data, LD_IN, attr->index, PC87365_REG_TEMP_MAX,
  549. data->in_max[attr->index]);
  550. mutex_unlock(&data->update_lock);
  551. return count;
  552. }
  553. static ssize_t set_therm_crit(struct device *dev, struct device_attribute *devattr, const char *buf,
  554. size_t count)
  555. {
  556. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  557. struct i2c_client *client = to_i2c_client(dev);
  558. struct pc87360_data *data = i2c_get_clientdata(client);
  559. long val = simple_strtol(buf, NULL, 10);
  560. mutex_lock(&data->update_lock);
  561. data->in_crit[attr->index-11] = IN_TO_REG(val, data->in_vref);
  562. pc87360_write_value(data, LD_IN, attr->index, PC87365_REG_TEMP_CRIT,
  563. data->in_crit[attr->index-11]);
  564. mutex_unlock(&data->update_lock);
  565. return count;
  566. }
  567. /* the +11 term below reflects the fact that VLM units 11,12,13 are
  568. used in the chip to measure voltage across the thermistors
  569. */
  570. static struct sensor_device_attribute therm_input[] = {
  571. SENSOR_ATTR(temp4_input, S_IRUGO, show_therm_input, NULL, 0+11),
  572. SENSOR_ATTR(temp5_input, S_IRUGO, show_therm_input, NULL, 1+11),
  573. SENSOR_ATTR(temp6_input, S_IRUGO, show_therm_input, NULL, 2+11),
  574. };
  575. static struct sensor_device_attribute therm_status[] = {
  576. SENSOR_ATTR(temp4_status, S_IRUGO, show_therm_status, NULL, 0+11),
  577. SENSOR_ATTR(temp5_status, S_IRUGO, show_therm_status, NULL, 1+11),
  578. SENSOR_ATTR(temp6_status, S_IRUGO, show_therm_status, NULL, 2+11),
  579. };
  580. static struct sensor_device_attribute therm_min[] = {
  581. SENSOR_ATTR(temp4_min, S_IRUGO | S_IWUSR,
  582. show_therm_min, set_therm_min, 0+11),
  583. SENSOR_ATTR(temp5_min, S_IRUGO | S_IWUSR,
  584. show_therm_min, set_therm_min, 1+11),
  585. SENSOR_ATTR(temp6_min, S_IRUGO | S_IWUSR,
  586. show_therm_min, set_therm_min, 2+11),
  587. };
  588. static struct sensor_device_attribute therm_max[] = {
  589. SENSOR_ATTR(temp4_max, S_IRUGO | S_IWUSR,
  590. show_therm_max, set_therm_max, 0+11),
  591. SENSOR_ATTR(temp5_max, S_IRUGO | S_IWUSR,
  592. show_therm_max, set_therm_max, 1+11),
  593. SENSOR_ATTR(temp6_max, S_IRUGO | S_IWUSR,
  594. show_therm_max, set_therm_max, 2+11),
  595. };
  596. static struct sensor_device_attribute therm_crit[] = {
  597. SENSOR_ATTR(temp4_crit, S_IRUGO | S_IWUSR,
  598. show_therm_crit, set_therm_crit, 0+11),
  599. SENSOR_ATTR(temp5_crit, S_IRUGO | S_IWUSR,
  600. show_therm_crit, set_therm_crit, 1+11),
  601. SENSOR_ATTR(temp6_crit, S_IRUGO | S_IWUSR,
  602. show_therm_crit, set_therm_crit, 2+11),
  603. };
  604. #define THERM_UNIT_ATTRS(X) \
  605. &therm_input[X].dev_attr.attr, \
  606. &therm_status[X].dev_attr.attr, \
  607. &therm_min[X].dev_attr.attr, \
  608. &therm_max[X].dev_attr.attr, \
  609. &therm_crit[X].dev_attr.attr
  610. static struct attribute * pc8736x_therm_attr_array[] = {
  611. THERM_UNIT_ATTRS(0),
  612. THERM_UNIT_ATTRS(1),
  613. THERM_UNIT_ATTRS(2),
  614. NULL
  615. };
  616. static const struct attribute_group pc8736x_therm_group = {
  617. .attrs = pc8736x_therm_attr_array,
  618. };
  619. static ssize_t show_temp_input(struct device *dev, struct device_attribute *devattr, char *buf)
  620. {
  621. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  622. struct pc87360_data *data = pc87360_update_device(dev);
  623. return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[attr->index]));
  624. }
  625. static ssize_t show_temp_min(struct device *dev, struct device_attribute *devattr, char *buf)
  626. {
  627. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  628. struct pc87360_data *data = pc87360_update_device(dev);
  629. return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[attr->index]));
  630. }
  631. static ssize_t show_temp_max(struct device *dev, struct device_attribute *devattr, char *buf)
  632. {
  633. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  634. struct pc87360_data *data = pc87360_update_device(dev);
  635. return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[attr->index]));
  636. }
  637. static ssize_t show_temp_crit(struct device *dev, struct device_attribute *devattr, char *buf)
  638. {
  639. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  640. struct pc87360_data *data = pc87360_update_device(dev);
  641. return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_crit[attr->index]));
  642. }
  643. static ssize_t show_temp_status(struct device *dev, struct device_attribute *devattr, char *buf)
  644. {
  645. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  646. struct pc87360_data *data = pc87360_update_device(dev);
  647. return sprintf(buf, "%d\n", data->temp_status[attr->index]);
  648. }
  649. static ssize_t set_temp_min(struct device *dev, struct device_attribute *devattr, const char *buf,
  650. size_t count)
  651. {
  652. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  653. struct i2c_client *client = to_i2c_client(dev);
  654. struct pc87360_data *data = i2c_get_clientdata(client);
  655. long val = simple_strtol(buf, NULL, 10);
  656. mutex_lock(&data->update_lock);
  657. data->temp_min[attr->index] = TEMP_TO_REG(val);
  658. pc87360_write_value(data, LD_TEMP, attr->index, PC87365_REG_TEMP_MIN,
  659. data->temp_min[attr->index]);
  660. mutex_unlock(&data->update_lock);
  661. return count;
  662. }
  663. static ssize_t set_temp_max(struct device *dev, struct device_attribute *devattr, const char *buf,
  664. size_t count)
  665. {
  666. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  667. struct i2c_client *client = to_i2c_client(dev);
  668. struct pc87360_data *data = i2c_get_clientdata(client);
  669. long val = simple_strtol(buf, NULL, 10);
  670. mutex_lock(&data->update_lock);
  671. data->temp_max[attr->index] = TEMP_TO_REG(val);
  672. pc87360_write_value(data, LD_TEMP, attr->index, PC87365_REG_TEMP_MAX,
  673. data->temp_max[attr->index]);
  674. mutex_unlock(&data->update_lock);
  675. return count;
  676. }
  677. static ssize_t set_temp_crit(struct device *dev, struct device_attribute *devattr, const char *buf,
  678. size_t count)
  679. {
  680. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  681. struct i2c_client *client = to_i2c_client(dev);
  682. struct pc87360_data *data = i2c_get_clientdata(client);
  683. long val = simple_strtol(buf, NULL, 10);
  684. mutex_lock(&data->update_lock);
  685. data->temp_crit[attr->index] = TEMP_TO_REG(val);
  686. pc87360_write_value(data, LD_TEMP, attr->index, PC87365_REG_TEMP_CRIT,
  687. data->temp_crit[attr->index]);
  688. mutex_unlock(&data->update_lock);
  689. return count;
  690. }
  691. static struct sensor_device_attribute temp_input[] = {
  692. SENSOR_ATTR(temp1_input, S_IRUGO, show_temp_input, NULL, 0),
  693. SENSOR_ATTR(temp2_input, S_IRUGO, show_temp_input, NULL, 1),
  694. SENSOR_ATTR(temp3_input, S_IRUGO, show_temp_input, NULL, 2),
  695. };
  696. static struct sensor_device_attribute temp_status[] = {
  697. SENSOR_ATTR(temp1_status, S_IRUGO, show_temp_status, NULL, 0),
  698. SENSOR_ATTR(temp2_status, S_IRUGO, show_temp_status, NULL, 1),
  699. SENSOR_ATTR(temp3_status, S_IRUGO, show_temp_status, NULL, 2),
  700. };
  701. static struct sensor_device_attribute temp_min[] = {
  702. SENSOR_ATTR(temp1_min, S_IRUGO | S_IWUSR,
  703. show_temp_min, set_temp_min, 0),
  704. SENSOR_ATTR(temp2_min, S_IRUGO | S_IWUSR,
  705. show_temp_min, set_temp_min, 1),
  706. SENSOR_ATTR(temp3_min, S_IRUGO | S_IWUSR,
  707. show_temp_min, set_temp_min, 2),
  708. };
  709. static struct sensor_device_attribute temp_max[] = {
  710. SENSOR_ATTR(temp1_max, S_IRUGO | S_IWUSR,
  711. show_temp_max, set_temp_max, 0),
  712. SENSOR_ATTR(temp2_max, S_IRUGO | S_IWUSR,
  713. show_temp_max, set_temp_max, 1),
  714. SENSOR_ATTR(temp3_max, S_IRUGO | S_IWUSR,
  715. show_temp_max, set_temp_max, 2),
  716. };
  717. static struct sensor_device_attribute temp_crit[] = {
  718. SENSOR_ATTR(temp1_crit, S_IRUGO | S_IWUSR,
  719. show_temp_crit, set_temp_crit, 0),
  720. SENSOR_ATTR(temp2_crit, S_IRUGO | S_IWUSR,
  721. show_temp_crit, set_temp_crit, 1),
  722. SENSOR_ATTR(temp3_crit, S_IRUGO | S_IWUSR,
  723. show_temp_crit, set_temp_crit, 2),
  724. };
  725. static ssize_t show_temp_alarms(struct device *dev, struct device_attribute *attr, char *buf)
  726. {
  727. struct pc87360_data *data = pc87360_update_device(dev);
  728. return sprintf(buf, "%u\n", data->temp_alarms);
  729. }
  730. static DEVICE_ATTR(alarms_temp, S_IRUGO, show_temp_alarms, NULL);
  731. #define TEMP_UNIT_ATTRS(X) \
  732. &temp_input[X].dev_attr.attr, \
  733. &temp_status[X].dev_attr.attr, \
  734. &temp_min[X].dev_attr.attr, \
  735. &temp_max[X].dev_attr.attr, \
  736. &temp_crit[X].dev_attr.attr
  737. static struct attribute * pc8736x_temp_attr_array[] = {
  738. TEMP_UNIT_ATTRS(0),
  739. TEMP_UNIT_ATTRS(1),
  740. TEMP_UNIT_ATTRS(2),
  741. /* include the few miscellaneous atts here */
  742. &dev_attr_alarms_temp.attr,
  743. NULL
  744. };
  745. static const struct attribute_group pc8736x_temp_group = {
  746. .attrs = pc8736x_temp_attr_array,
  747. };
  748. /*
  749. * Device detection, registration and update
  750. */
  751. static int __init pc87360_find(int sioaddr, u8 *devid, unsigned short *addresses)
  752. {
  753. u16 val;
  754. int i;
  755. int nrdev; /* logical device count */
  756. /* No superio_enter */
  757. /* Identify device */
  758. val = superio_inb(sioaddr, DEVID);
  759. switch (val) {
  760. case 0xE1: /* PC87360 */
  761. case 0xE8: /* PC87363 */
  762. case 0xE4: /* PC87364 */
  763. nrdev = 1;
  764. break;
  765. case 0xE5: /* PC87365 */
  766. case 0xE9: /* PC87366 */
  767. nrdev = 3;
  768. break;
  769. default:
  770. superio_exit(sioaddr);
  771. return -ENODEV;
  772. }
  773. /* Remember the device id */
  774. *devid = val;
  775. for (i = 0; i < nrdev; i++) {
  776. /* select logical device */
  777. superio_outb(sioaddr, DEV, logdev[i]);
  778. val = superio_inb(sioaddr, ACT);
  779. if (!(val & 0x01)) {
  780. printk(KERN_INFO "pc87360: Device 0x%02x not "
  781. "activated\n", logdev[i]);
  782. continue;
  783. }
  784. val = (superio_inb(sioaddr, BASE) << 8)
  785. | superio_inb(sioaddr, BASE + 1);
  786. if (!val) {
  787. printk(KERN_INFO "pc87360: Base address not set for "
  788. "device 0x%02x\n", logdev[i]);
  789. continue;
  790. }
  791. addresses[i] = val;
  792. if (i==0) { /* Fans */
  793. confreg[0] = superio_inb(sioaddr, 0xF0);
  794. confreg[1] = superio_inb(sioaddr, 0xF1);
  795. #ifdef DEBUG
  796. printk(KERN_DEBUG "pc87360: Fan 1: mon=%d "
  797. "ctrl=%d inv=%d\n", (confreg[0]>>2)&1,
  798. (confreg[0]>>3)&1, (confreg[0]>>4)&1);
  799. printk(KERN_DEBUG "pc87360: Fan 2: mon=%d "
  800. "ctrl=%d inv=%d\n", (confreg[0]>>5)&1,
  801. (confreg[0]>>6)&1, (confreg[0]>>7)&1);
  802. printk(KERN_DEBUG "pc87360: Fan 3: mon=%d "
  803. "ctrl=%d inv=%d\n", confreg[1]&1,
  804. (confreg[1]>>1)&1, (confreg[1]>>2)&1);
  805. #endif
  806. } else if (i==1) { /* Voltages */
  807. /* Are we using thermistors? */
  808. if (*devid == 0xE9) { /* PC87366 */
  809. /* These registers are not logical-device
  810. specific, just that we won't need them if
  811. we don't use the VLM device */
  812. confreg[2] = superio_inb(sioaddr, 0x2B);
  813. confreg[3] = superio_inb(sioaddr, 0x25);
  814. if (confreg[2] & 0x40) {
  815. printk(KERN_INFO "pc87360: Using "
  816. "thermistors for temperature "
  817. "monitoring\n");
  818. }
  819. if (confreg[3] & 0xE0) {
  820. printk(KERN_INFO "pc87360: VID "
  821. "inputs routed (mode %u)\n",
  822. confreg[3] >> 5);
  823. }
  824. }
  825. }
  826. }
  827. superio_exit(sioaddr);
  828. return 0;
  829. }
  830. static int pc87360_detect(struct i2c_adapter *adapter)
  831. {
  832. int i;
  833. struct i2c_client *client;
  834. struct pc87360_data *data;
  835. int err = 0;
  836. const char *name = "pc87360";
  837. int use_thermistors = 0;
  838. struct device *dev;
  839. if (!(data = kzalloc(sizeof(struct pc87360_data), GFP_KERNEL)))
  840. return -ENOMEM;
  841. client = &data->client;
  842. dev = &client->dev;
  843. i2c_set_clientdata(client, data);
  844. client->addr = address;
  845. mutex_init(&data->lock);
  846. client->adapter = adapter;
  847. client->driver = &pc87360_driver;
  848. client->flags = 0;
  849. data->fannr = 2;
  850. data->innr = 0;
  851. data->tempnr = 0;
  852. switch (devid) {
  853. case 0xe8:
  854. name = "pc87363";
  855. break;
  856. case 0xe4:
  857. name = "pc87364";
  858. data->fannr = 3;
  859. break;
  860. case 0xe5:
  861. name = "pc87365";
  862. data->fannr = extra_isa[0] ? 3 : 0;
  863. data->innr = extra_isa[1] ? 11 : 0;
  864. data->tempnr = extra_isa[2] ? 2 : 0;
  865. break;
  866. case 0xe9:
  867. name = "pc87366";
  868. data->fannr = extra_isa[0] ? 3 : 0;
  869. data->innr = extra_isa[1] ? 14 : 0;
  870. data->tempnr = extra_isa[2] ? 3 : 0;
  871. break;
  872. }
  873. strlcpy(client->name, name, sizeof(client->name));
  874. data->valid = 0;
  875. mutex_init(&data->update_lock);
  876. for (i = 0; i < 3; i++) {
  877. if (((data->address[i] = extra_isa[i]))
  878. && !request_region(extra_isa[i], PC87360_EXTENT,
  879. pc87360_driver.driver.name)) {
  880. dev_err(&client->dev, "Region 0x%x-0x%x already "
  881. "in use!\n", extra_isa[i],
  882. extra_isa[i]+PC87360_EXTENT-1);
  883. for (i--; i >= 0; i--)
  884. release_region(extra_isa[i], PC87360_EXTENT);
  885. err = -EBUSY;
  886. goto ERROR1;
  887. }
  888. }
  889. /* Retrieve the fans configuration from Super-I/O space */
  890. if (data->fannr)
  891. data->fan_conf = confreg[0] | (confreg[1] << 8);
  892. if ((err = i2c_attach_client(client)))
  893. goto ERROR2;
  894. /* Use the correct reference voltage
  895. Unless both the VLM and the TMS logical devices agree to
  896. use an external Vref, the internal one is used. */
  897. if (data->innr) {
  898. i = pc87360_read_value(data, LD_IN, NO_BANK,
  899. PC87365_REG_IN_CONFIG);
  900. if (data->tempnr) {
  901. i &= pc87360_read_value(data, LD_TEMP, NO_BANK,
  902. PC87365_REG_TEMP_CONFIG);
  903. }
  904. data->in_vref = (i&0x02) ? 3025 : 2966;
  905. dev_dbg(&client->dev, "Using %s reference voltage\n",
  906. (i&0x02) ? "external" : "internal");
  907. data->vid_conf = confreg[3];
  908. data->vrm = vid_which_vrm();
  909. }
  910. /* Fan clock dividers may be needed before any data is read */
  911. for (i = 0; i < data->fannr; i++) {
  912. if (FAN_CONFIG_MONITOR(data->fan_conf, i))
  913. data->fan_status[i] = pc87360_read_value(data,
  914. LD_FAN, NO_BANK,
  915. PC87360_REG_FAN_STATUS(i));
  916. }
  917. if (init > 0) {
  918. if (devid == 0xe9 && data->address[1]) /* PC87366 */
  919. use_thermistors = confreg[2] & 0x40;
  920. pc87360_init_client(client, use_thermistors);
  921. }
  922. /* Register all-or-nothing sysfs groups */
  923. if (data->innr &&
  924. (err = sysfs_create_group(&client->dev.kobj,
  925. &pc8736x_vin_group)))
  926. goto ERROR3;
  927. if (data->innr == 14 &&
  928. (err = sysfs_create_group(&client->dev.kobj,
  929. &pc8736x_therm_group)))
  930. goto ERROR3;
  931. /* create device attr-files for varying sysfs groups */
  932. if (data->tempnr) {
  933. for (i = 0; i < data->tempnr; i++) {
  934. if ((err = device_create_file(dev,
  935. &temp_input[i].dev_attr))
  936. || (err = device_create_file(dev,
  937. &temp_min[i].dev_attr))
  938. || (err = device_create_file(dev,
  939. &temp_max[i].dev_attr))
  940. || (err = device_create_file(dev,
  941. &temp_crit[i].dev_attr))
  942. || (err = device_create_file(dev,
  943. &temp_status[i].dev_attr)))
  944. goto ERROR3;
  945. }
  946. if ((err = device_create_file(dev, &dev_attr_alarms_temp)))
  947. goto ERROR3;
  948. }
  949. for (i = 0; i < data->fannr; i++) {
  950. if (FAN_CONFIG_MONITOR(data->fan_conf, i)
  951. && ((err = device_create_file(dev,
  952. &fan_input[i].dev_attr))
  953. || (err = device_create_file(dev,
  954. &fan_min[i].dev_attr))
  955. || (err = device_create_file(dev,
  956. &fan_div[i].dev_attr))
  957. || (err = device_create_file(dev,
  958. &fan_status[i].dev_attr))))
  959. goto ERROR3;
  960. if (FAN_CONFIG_CONTROL(data->fan_conf, i)
  961. && (err = device_create_file(dev, &pwm[i].dev_attr)))
  962. goto ERROR3;
  963. }
  964. data->class_dev = hwmon_device_register(&client->dev);
  965. if (IS_ERR(data->class_dev)) {
  966. err = PTR_ERR(data->class_dev);
  967. goto ERROR3;
  968. }
  969. return 0;
  970. ERROR3:
  971. /* can still remove groups whose members were added individually */
  972. sysfs_remove_group(&client->dev.kobj, &pc8736x_temp_group);
  973. sysfs_remove_group(&client->dev.kobj, &pc8736x_fan_group);
  974. sysfs_remove_group(&client->dev.kobj, &pc8736x_therm_group);
  975. sysfs_remove_group(&client->dev.kobj, &pc8736x_vin_group);
  976. i2c_detach_client(client);
  977. ERROR2:
  978. for (i = 0; i < 3; i++) {
  979. if (data->address[i]) {
  980. release_region(data->address[i], PC87360_EXTENT);
  981. }
  982. }
  983. ERROR1:
  984. kfree(data);
  985. return err;
  986. }
  987. static int pc87360_detach_client(struct i2c_client *client)
  988. {
  989. struct pc87360_data *data = i2c_get_clientdata(client);
  990. int i;
  991. hwmon_device_unregister(data->class_dev);
  992. sysfs_remove_group(&client->dev.kobj, &pc8736x_temp_group);
  993. sysfs_remove_group(&client->dev.kobj, &pc8736x_fan_group);
  994. sysfs_remove_group(&client->dev.kobj, &pc8736x_therm_group);
  995. sysfs_remove_group(&client->dev.kobj, &pc8736x_vin_group);
  996. if ((i = i2c_detach_client(client)))
  997. return i;
  998. for (i = 0; i < 3; i++) {
  999. if (data->address[i]) {
  1000. release_region(data->address[i], PC87360_EXTENT);
  1001. }
  1002. }
  1003. kfree(data);
  1004. return 0;
  1005. }
  1006. /* ldi is the logical device index
  1007. bank is for voltages and temperatures only */
  1008. static int pc87360_read_value(struct pc87360_data *data, u8 ldi, u8 bank,
  1009. u8 reg)
  1010. {
  1011. int res;
  1012. mutex_lock(&(data->lock));
  1013. if (bank != NO_BANK)
  1014. outb_p(bank, data->address[ldi] + PC87365_REG_BANK);
  1015. res = inb_p(data->address[ldi] + reg);
  1016. mutex_unlock(&(data->lock));
  1017. return res;
  1018. }
  1019. static void pc87360_write_value(struct pc87360_data *data, u8 ldi, u8 bank,
  1020. u8 reg, u8 value)
  1021. {
  1022. mutex_lock(&(data->lock));
  1023. if (bank != NO_BANK)
  1024. outb_p(bank, data->address[ldi] + PC87365_REG_BANK);
  1025. outb_p(value, data->address[ldi] + reg);
  1026. mutex_unlock(&(data->lock));
  1027. }
  1028. static void pc87360_init_client(struct i2c_client *client, int use_thermistors)
  1029. {
  1030. struct pc87360_data *data = i2c_get_clientdata(client);
  1031. int i, nr;
  1032. const u8 init_in[14] = { 2, 2, 2, 2, 2, 2, 2, 1, 1, 3, 1, 2, 2, 2 };
  1033. const u8 init_temp[3] = { 2, 2, 1 };
  1034. u8 reg;
  1035. if (init >= 2 && data->innr) {
  1036. reg = pc87360_read_value(data, LD_IN, NO_BANK,
  1037. PC87365_REG_IN_CONVRATE);
  1038. dev_info(&client->dev, "VLM conversion set to "
  1039. "1s period, 160us delay\n");
  1040. pc87360_write_value(data, LD_IN, NO_BANK,
  1041. PC87365_REG_IN_CONVRATE,
  1042. (reg & 0xC0) | 0x11);
  1043. }
  1044. nr = data->innr < 11 ? data->innr : 11;
  1045. for (i = 0; i < nr; i++) {
  1046. if (init >= init_in[i]) {
  1047. /* Forcibly enable voltage channel */
  1048. reg = pc87360_read_value(data, LD_IN, i,
  1049. PC87365_REG_IN_STATUS);
  1050. if (!(reg & 0x01)) {
  1051. dev_dbg(&client->dev, "Forcibly "
  1052. "enabling in%d\n", i);
  1053. pc87360_write_value(data, LD_IN, i,
  1054. PC87365_REG_IN_STATUS,
  1055. (reg & 0x68) | 0x87);
  1056. }
  1057. }
  1058. }
  1059. /* We can't blindly trust the Super-I/O space configuration bit,
  1060. most BIOS won't set it properly */
  1061. for (i = 11; i < data->innr; i++) {
  1062. reg = pc87360_read_value(data, LD_IN, i,
  1063. PC87365_REG_TEMP_STATUS);
  1064. use_thermistors = use_thermistors || (reg & 0x01);
  1065. }
  1066. i = use_thermistors ? 2 : 0;
  1067. for (; i < data->tempnr; i++) {
  1068. if (init >= init_temp[i]) {
  1069. /* Forcibly enable temperature channel */
  1070. reg = pc87360_read_value(data, LD_TEMP, i,
  1071. PC87365_REG_TEMP_STATUS);
  1072. if (!(reg & 0x01)) {
  1073. dev_dbg(&client->dev, "Forcibly "
  1074. "enabling temp%d\n", i+1);
  1075. pc87360_write_value(data, LD_TEMP, i,
  1076. PC87365_REG_TEMP_STATUS,
  1077. 0xCF);
  1078. }
  1079. }
  1080. }
  1081. if (use_thermistors) {
  1082. for (i = 11; i < data->innr; i++) {
  1083. if (init >= init_in[i]) {
  1084. /* The pin may already be used by thermal
  1085. diodes */
  1086. reg = pc87360_read_value(data, LD_TEMP,
  1087. (i-11)/2, PC87365_REG_TEMP_STATUS);
  1088. if (reg & 0x01) {
  1089. dev_dbg(&client->dev, "Skipping "
  1090. "temp%d, pin already in use "
  1091. "by temp%d\n", i-7, (i-11)/2);
  1092. continue;
  1093. }
  1094. /* Forcibly enable thermistor channel */
  1095. reg = pc87360_read_value(data, LD_IN, i,
  1096. PC87365_REG_IN_STATUS);
  1097. if (!(reg & 0x01)) {
  1098. dev_dbg(&client->dev, "Forcibly "
  1099. "enabling temp%d\n", i-7);
  1100. pc87360_write_value(data, LD_IN, i,
  1101. PC87365_REG_TEMP_STATUS,
  1102. (reg & 0x60) | 0x8F);
  1103. }
  1104. }
  1105. }
  1106. }
  1107. if (data->innr) {
  1108. reg = pc87360_read_value(data, LD_IN, NO_BANK,
  1109. PC87365_REG_IN_CONFIG);
  1110. if (reg & 0x01) {
  1111. dev_dbg(&client->dev, "Forcibly "
  1112. "enabling monitoring (VLM)\n");
  1113. pc87360_write_value(data, LD_IN, NO_BANK,
  1114. PC87365_REG_IN_CONFIG,
  1115. reg & 0xFE);
  1116. }
  1117. }
  1118. if (data->tempnr) {
  1119. reg = pc87360_read_value(data, LD_TEMP, NO_BANK,
  1120. PC87365_REG_TEMP_CONFIG);
  1121. if (reg & 0x01) {
  1122. dev_dbg(&client->dev, "Forcibly enabling "
  1123. "monitoring (TMS)\n");
  1124. pc87360_write_value(data, LD_TEMP, NO_BANK,
  1125. PC87365_REG_TEMP_CONFIG,
  1126. reg & 0xFE);
  1127. }
  1128. if (init >= 2) {
  1129. /* Chip config as documented by National Semi. */
  1130. pc87360_write_value(data, LD_TEMP, 0xF, 0xA, 0x08);
  1131. /* We voluntarily omit the bank here, in case the
  1132. sequence itself matters. It shouldn't be a problem,
  1133. since nobody else is supposed to access the
  1134. device at that point. */
  1135. pc87360_write_value(data, LD_TEMP, NO_BANK, 0xB, 0x04);
  1136. pc87360_write_value(data, LD_TEMP, NO_BANK, 0xC, 0x35);
  1137. pc87360_write_value(data, LD_TEMP, NO_BANK, 0xD, 0x05);
  1138. pc87360_write_value(data, LD_TEMP, NO_BANK, 0xE, 0x05);
  1139. }
  1140. }
  1141. }
  1142. static void pc87360_autodiv(struct i2c_client *client, int nr)
  1143. {
  1144. struct pc87360_data *data = i2c_get_clientdata(client);
  1145. u8 old_min = data->fan_min[nr];
  1146. /* Increase clock divider if needed and possible */
  1147. if ((data->fan_status[nr] & 0x04) /* overflow flag */
  1148. || (data->fan[nr] >= 224)) { /* next to overflow */
  1149. if ((data->fan_status[nr] & 0x60) != 0x60) {
  1150. data->fan_status[nr] += 0x20;
  1151. data->fan_min[nr] >>= 1;
  1152. data->fan[nr] >>= 1;
  1153. dev_dbg(&client->dev, "Increasing "
  1154. "clock divider to %d for fan %d\n",
  1155. FAN_DIV_FROM_REG(data->fan_status[nr]), nr+1);
  1156. }
  1157. } else {
  1158. /* Decrease clock divider if possible */
  1159. while (!(data->fan_min[nr] & 0x80) /* min "nails" divider */
  1160. && data->fan[nr] < 85 /* bad accuracy */
  1161. && (data->fan_status[nr] & 0x60) != 0x00) {
  1162. data->fan_status[nr] -= 0x20;
  1163. data->fan_min[nr] <<= 1;
  1164. data->fan[nr] <<= 1;
  1165. dev_dbg(&client->dev, "Decreasing "
  1166. "clock divider to %d for fan %d\n",
  1167. FAN_DIV_FROM_REG(data->fan_status[nr]),
  1168. nr+1);
  1169. }
  1170. }
  1171. /* Write new fan min if it changed */
  1172. if (old_min != data->fan_min[nr]) {
  1173. pc87360_write_value(data, LD_FAN, NO_BANK,
  1174. PC87360_REG_FAN_MIN(nr),
  1175. data->fan_min[nr]);
  1176. }
  1177. }
  1178. static struct pc87360_data *pc87360_update_device(struct device *dev)
  1179. {
  1180. struct i2c_client *client = to_i2c_client(dev);
  1181. struct pc87360_data *data = i2c_get_clientdata(client);
  1182. u8 i;
  1183. mutex_lock(&data->update_lock);
  1184. if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) {
  1185. dev_dbg(&client->dev, "Data update\n");
  1186. /* Fans */
  1187. for (i = 0; i < data->fannr; i++) {
  1188. if (FAN_CONFIG_MONITOR(data->fan_conf, i)) {
  1189. data->fan_status[i] =
  1190. pc87360_read_value(data, LD_FAN,
  1191. NO_BANK, PC87360_REG_FAN_STATUS(i));
  1192. data->fan[i] = pc87360_read_value(data, LD_FAN,
  1193. NO_BANK, PC87360_REG_FAN(i));
  1194. data->fan_min[i] = pc87360_read_value(data,
  1195. LD_FAN, NO_BANK,
  1196. PC87360_REG_FAN_MIN(i));
  1197. /* Change clock divider if needed */
  1198. pc87360_autodiv(client, i);
  1199. /* Clear bits and write new divider */
  1200. pc87360_write_value(data, LD_FAN, NO_BANK,
  1201. PC87360_REG_FAN_STATUS(i),
  1202. data->fan_status[i]);
  1203. }
  1204. if (FAN_CONFIG_CONTROL(data->fan_conf, i))
  1205. data->pwm[i] = pc87360_read_value(data, LD_FAN,
  1206. NO_BANK, PC87360_REG_PWM(i));
  1207. }
  1208. /* Voltages */
  1209. for (i = 0; i < data->innr; i++) {
  1210. data->in_status[i] = pc87360_read_value(data, LD_IN, i,
  1211. PC87365_REG_IN_STATUS);
  1212. /* Clear bits */
  1213. pc87360_write_value(data, LD_IN, i,
  1214. PC87365_REG_IN_STATUS,
  1215. data->in_status[i]);
  1216. if ((data->in_status[i] & 0x81) == 0x81) {
  1217. data->in[i] = pc87360_read_value(data, LD_IN,
  1218. i, PC87365_REG_IN);
  1219. }
  1220. if (data->in_status[i] & 0x01) {
  1221. data->in_min[i] = pc87360_read_value(data,
  1222. LD_IN, i,
  1223. PC87365_REG_IN_MIN);
  1224. data->in_max[i] = pc87360_read_value(data,
  1225. LD_IN, i,
  1226. PC87365_REG_IN_MAX);
  1227. if (i >= 11)
  1228. data->in_crit[i-11] =
  1229. pc87360_read_value(data, LD_IN,
  1230. i, PC87365_REG_TEMP_CRIT);
  1231. }
  1232. }
  1233. if (data->innr) {
  1234. data->in_alarms = pc87360_read_value(data, LD_IN,
  1235. NO_BANK, PC87365_REG_IN_ALARMS1)
  1236. | ((pc87360_read_value(data, LD_IN,
  1237. NO_BANK, PC87365_REG_IN_ALARMS2)
  1238. & 0x07) << 8);
  1239. data->vid = (data->vid_conf & 0xE0) ?
  1240. pc87360_read_value(data, LD_IN,
  1241. NO_BANK, PC87365_REG_VID) : 0x1F;
  1242. }
  1243. /* Temperatures */
  1244. for (i = 0; i < data->tempnr; i++) {
  1245. data->temp_status[i] = pc87360_read_value(data,
  1246. LD_TEMP, i,
  1247. PC87365_REG_TEMP_STATUS);
  1248. /* Clear bits */
  1249. pc87360_write_value(data, LD_TEMP, i,
  1250. PC87365_REG_TEMP_STATUS,
  1251. data->temp_status[i]);
  1252. if ((data->temp_status[i] & 0x81) == 0x81) {
  1253. data->temp[i] = pc87360_read_value(data,
  1254. LD_TEMP, i,
  1255. PC87365_REG_TEMP);
  1256. }
  1257. if (data->temp_status[i] & 0x01) {
  1258. data->temp_min[i] = pc87360_read_value(data,
  1259. LD_TEMP, i,
  1260. PC87365_REG_TEMP_MIN);
  1261. data->temp_max[i] = pc87360_read_value(data,
  1262. LD_TEMP, i,
  1263. PC87365_REG_TEMP_MAX);
  1264. data->temp_crit[i] = pc87360_read_value(data,
  1265. LD_TEMP, i,
  1266. PC87365_REG_TEMP_CRIT);
  1267. }
  1268. }
  1269. if (data->tempnr) {
  1270. data->temp_alarms = pc87360_read_value(data, LD_TEMP,
  1271. NO_BANK, PC87365_REG_TEMP_ALARMS)
  1272. & 0x3F;
  1273. }
  1274. data->last_updated = jiffies;
  1275. data->valid = 1;
  1276. }
  1277. mutex_unlock(&data->update_lock);
  1278. return data;
  1279. }
  1280. static int __init pc87360_init(void)
  1281. {
  1282. int i;
  1283. if (pc87360_find(0x2e, &devid, extra_isa)
  1284. && pc87360_find(0x4e, &devid, extra_isa)) {
  1285. printk(KERN_WARNING "pc87360: PC8736x not detected, "
  1286. "module not inserted.\n");
  1287. return -ENODEV;
  1288. }
  1289. /* Arbitrarily pick one of the addresses */
  1290. for (i = 0; i < 3; i++) {
  1291. if (extra_isa[i] != 0x0000) {
  1292. address = extra_isa[i];
  1293. break;
  1294. }
  1295. }
  1296. if (address == 0x0000) {
  1297. printk(KERN_WARNING "pc87360: No active logical device, "
  1298. "module not inserted.\n");
  1299. return -ENODEV;
  1300. }
  1301. return i2c_isa_add_driver(&pc87360_driver);
  1302. }
  1303. static void __exit pc87360_exit(void)
  1304. {
  1305. i2c_isa_del_driver(&pc87360_driver);
  1306. }
  1307. MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
  1308. MODULE_DESCRIPTION("PC8736x hardware monitor");
  1309. MODULE_LICENSE("GPL");
  1310. module_init(pc87360_init);
  1311. module_exit(pc87360_exit);