pc87427.c 37 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * pc87427.c - hardware monitoring driver for the
  4. * National Semiconductor PC87427 Super-I/O chip
  5. * Copyright (C) 2006, 2008, 2010 Jean Delvare <jdelvare@suse.de>
  6. *
  7. * Supports the following chips:
  8. *
  9. * Chip #vin #fan #pwm #temp devid
  10. * PC87427 - 8 4 6 0xF2
  11. *
  12. * This driver assumes that no more than one chip is present.
  13. * Only fans are fully supported so far. Temperatures are in read-only
  14. * mode, and voltages aren't supported at all.
  15. */
  16. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  17. #include <linux/module.h>
  18. #include <linux/init.h>
  19. #include <linux/slab.h>
  20. #include <linux/jiffies.h>
  21. #include <linux/platform_device.h>
  22. #include <linux/hwmon.h>
  23. #include <linux/hwmon-sysfs.h>
  24. #include <linux/err.h>
  25. #include <linux/mutex.h>
  26. #include <linux/sysfs.h>
  27. #include <linux/ioport.h>
  28. #include <linux/acpi.h>
  29. #include <linux/io.h>
  30. static unsigned short force_id;
  31. module_param(force_id, ushort, 0);
  32. MODULE_PARM_DESC(force_id, "Override the detected device ID");
  33. static struct platform_device *pdev;
  34. #define DRVNAME "pc87427"
  35. /*
  36. * The lock mutex protects both the I/O accesses (needed because the
  37. * device is using banked registers) and the register cache (needed to keep
  38. * the data in the registers and the cache in sync at any time).
  39. */
  40. struct pc87427_data {
  41. struct device *hwmon_dev;
  42. struct mutex lock;
  43. int address[2];
  44. const char *name;
  45. unsigned long last_updated; /* in jiffies */
  46. u8 fan_enabled; /* bit vector */
  47. u16 fan[8]; /* register values */
  48. u16 fan_min[8]; /* register values */
  49. u8 fan_status[8]; /* register values */
  50. u8 pwm_enabled; /* bit vector */
  51. u8 pwm_auto_ok; /* bit vector */
  52. u8 pwm_enable[4]; /* register values */
  53. u8 pwm[4]; /* register values */
  54. u8 temp_enabled; /* bit vector */
  55. s16 temp[6]; /* register values */
  56. s8 temp_min[6]; /* register values */
  57. s8 temp_max[6]; /* register values */
  58. s8 temp_crit[6]; /* register values */
  59. u8 temp_status[6]; /* register values */
  60. u8 temp_type[6]; /* register values */
  61. };
  62. struct pc87427_sio_data {
  63. unsigned short address[2];
  64. u8 has_fanin;
  65. u8 has_fanout;
  66. };
  67. /*
  68. * Super-I/O registers and operations
  69. */
  70. #define SIOREG_LDSEL 0x07 /* Logical device select */
  71. #define SIOREG_DEVID 0x20 /* Device ID */
  72. #define SIOREG_CF2 0x22 /* Configuration 2 */
  73. #define SIOREG_CF3 0x23 /* Configuration 3 */
  74. #define SIOREG_CF4 0x24 /* Configuration 4 */
  75. #define SIOREG_CF5 0x25 /* Configuration 5 */
  76. #define SIOREG_CFB 0x2B /* Configuration B */
  77. #define SIOREG_CFC 0x2C /* Configuration C */
  78. #define SIOREG_CFD 0x2D /* Configuration D */
  79. #define SIOREG_ACT 0x30 /* Device activation */
  80. #define SIOREG_MAP 0x50 /* I/O or memory mapping */
  81. #define SIOREG_IOBASE 0x60 /* I/O base address */
  82. static const u8 logdev[2] = { 0x09, 0x14 };
  83. static const char *logdev_str[2] = { DRVNAME " FMC", DRVNAME " HMC" };
  84. #define LD_FAN 0
  85. #define LD_IN 1
  86. #define LD_TEMP 1
  87. static inline int superio_enter(int sioaddr)
  88. {
  89. if (!request_muxed_region(sioaddr, 2, DRVNAME))
  90. return -EBUSY;
  91. return 0;
  92. }
  93. static inline void superio_outb(int sioaddr, int reg, int val)
  94. {
  95. outb(reg, sioaddr);
  96. outb(val, sioaddr + 1);
  97. }
  98. static inline int superio_inb(int sioaddr, int reg)
  99. {
  100. outb(reg, sioaddr);
  101. return inb(sioaddr + 1);
  102. }
  103. static inline void superio_exit(int sioaddr)
  104. {
  105. outb(0x02, sioaddr);
  106. outb(0x02, sioaddr + 1);
  107. release_region(sioaddr, 2);
  108. }
  109. /*
  110. * Logical devices
  111. */
  112. #define REGION_LENGTH 32
  113. #define PC87427_REG_BANK 0x0f
  114. #define BANK_FM(nr) (nr)
  115. #define BANK_FT(nr) (0x08 + (nr))
  116. #define BANK_FC(nr) (0x10 + (nr) * 2)
  117. #define BANK_TM(nr) (nr)
  118. #define BANK_VM(nr) (0x08 + (nr))
  119. /*
  120. * I/O access functions
  121. */
  122. /* ldi is the logical device index */
  123. static inline int pc87427_read8(struct pc87427_data *data, u8 ldi, u8 reg)
  124. {
  125. return inb(data->address[ldi] + reg);
  126. }
  127. /* Must be called with data->lock held, except during init */
  128. static inline int pc87427_read8_bank(struct pc87427_data *data, u8 ldi,
  129. u8 bank, u8 reg)
  130. {
  131. outb(bank, data->address[ldi] + PC87427_REG_BANK);
  132. return inb(data->address[ldi] + reg);
  133. }
  134. /* Must be called with data->lock held, except during init */
  135. static inline void pc87427_write8_bank(struct pc87427_data *data, u8 ldi,
  136. u8 bank, u8 reg, u8 value)
  137. {
  138. outb(bank, data->address[ldi] + PC87427_REG_BANK);
  139. outb(value, data->address[ldi] + reg);
  140. }
  141. /*
  142. * Fan registers and conversions
  143. */
  144. /* fan data registers are 16-bit wide */
  145. #define PC87427_REG_FAN 0x12
  146. #define PC87427_REG_FAN_MIN 0x14
  147. #define PC87427_REG_FAN_STATUS 0x10
  148. #define FAN_STATUS_STALL (1 << 3)
  149. #define FAN_STATUS_LOSPD (1 << 1)
  150. #define FAN_STATUS_MONEN (1 << 0)
  151. /*
  152. * Dedicated function to read all registers related to a given fan input.
  153. * This saves us quite a few locks and bank selections.
  154. * Must be called with data->lock held.
  155. * nr is from 0 to 7
  156. */
  157. static void pc87427_readall_fan(struct pc87427_data *data, u8 nr)
  158. {
  159. int iobase = data->address[LD_FAN];
  160. outb(BANK_FM(nr), iobase + PC87427_REG_BANK);
  161. data->fan[nr] = inw(iobase + PC87427_REG_FAN);
  162. data->fan_min[nr] = inw(iobase + PC87427_REG_FAN_MIN);
  163. data->fan_status[nr] = inb(iobase + PC87427_REG_FAN_STATUS);
  164. /* Clear fan alarm bits */
  165. outb(data->fan_status[nr], iobase + PC87427_REG_FAN_STATUS);
  166. }
  167. /*
  168. * The 2 LSB of fan speed registers are used for something different.
  169. * The actual 2 LSB of the measurements are not available.
  170. */
  171. static inline unsigned long fan_from_reg(u16 reg)
  172. {
  173. reg &= 0xfffc;
  174. if (reg == 0x0000 || reg == 0xfffc)
  175. return 0;
  176. return 5400000UL / reg;
  177. }
  178. /* The 2 LSB of the fan speed limit registers are not significant. */
  179. static inline u16 fan_to_reg(unsigned long val)
  180. {
  181. if (val < 83UL)
  182. return 0xffff;
  183. if (val >= 1350000UL)
  184. return 0x0004;
  185. return ((1350000UL + val / 2) / val) << 2;
  186. }
  187. /*
  188. * PWM registers and conversions
  189. */
  190. #define PC87427_REG_PWM_ENABLE 0x10
  191. #define PC87427_REG_PWM_DUTY 0x12
  192. #define PWM_ENABLE_MODE_MASK (7 << 4)
  193. #define PWM_ENABLE_CTLEN (1 << 0)
  194. #define PWM_MODE_MANUAL (0 << 4)
  195. #define PWM_MODE_AUTO (1 << 4)
  196. #define PWM_MODE_OFF (2 << 4)
  197. #define PWM_MODE_ON (7 << 4)
  198. /*
  199. * Dedicated function to read all registers related to a given PWM output.
  200. * This saves us quite a few locks and bank selections.
  201. * Must be called with data->lock held.
  202. * nr is from 0 to 3
  203. */
  204. static void pc87427_readall_pwm(struct pc87427_data *data, u8 nr)
  205. {
  206. int iobase = data->address[LD_FAN];
  207. outb(BANK_FC(nr), iobase + PC87427_REG_BANK);
  208. data->pwm_enable[nr] = inb(iobase + PC87427_REG_PWM_ENABLE);
  209. data->pwm[nr] = inb(iobase + PC87427_REG_PWM_DUTY);
  210. }
  211. static inline int pwm_enable_from_reg(u8 reg)
  212. {
  213. switch (reg & PWM_ENABLE_MODE_MASK) {
  214. case PWM_MODE_ON:
  215. return 0;
  216. case PWM_MODE_MANUAL:
  217. case PWM_MODE_OFF:
  218. return 1;
  219. case PWM_MODE_AUTO:
  220. return 2;
  221. default:
  222. return -EPROTO;
  223. }
  224. }
  225. static inline u8 pwm_enable_to_reg(unsigned long val, u8 pwmval)
  226. {
  227. switch (val) {
  228. default:
  229. return PWM_MODE_ON;
  230. case 1:
  231. return pwmval ? PWM_MODE_MANUAL : PWM_MODE_OFF;
  232. case 2:
  233. return PWM_MODE_AUTO;
  234. }
  235. }
  236. /*
  237. * Temperature registers and conversions
  238. */
  239. #define PC87427_REG_TEMP_STATUS 0x10
  240. #define PC87427_REG_TEMP 0x14
  241. #define PC87427_REG_TEMP_MAX 0x18
  242. #define PC87427_REG_TEMP_MIN 0x19
  243. #define PC87427_REG_TEMP_CRIT 0x1a
  244. #define PC87427_REG_TEMP_TYPE 0x1d
  245. #define TEMP_STATUS_CHANEN (1 << 0)
  246. #define TEMP_STATUS_LOWFLG (1 << 1)
  247. #define TEMP_STATUS_HIGHFLG (1 << 2)
  248. #define TEMP_STATUS_CRITFLG (1 << 3)
  249. #define TEMP_STATUS_SENSERR (1 << 5)
  250. #define TEMP_TYPE_MASK (3 << 5)
  251. #define TEMP_TYPE_THERMISTOR (1 << 5)
  252. #define TEMP_TYPE_REMOTE_DIODE (2 << 5)
  253. #define TEMP_TYPE_LOCAL_DIODE (3 << 5)
  254. /*
  255. * Dedicated function to read all registers related to a given temperature
  256. * input. This saves us quite a few locks and bank selections.
  257. * Must be called with data->lock held.
  258. * nr is from 0 to 5
  259. */
  260. static void pc87427_readall_temp(struct pc87427_data *data, u8 nr)
  261. {
  262. int iobase = data->address[LD_TEMP];
  263. outb(BANK_TM(nr), iobase + PC87427_REG_BANK);
  264. data->temp[nr] = le16_to_cpu(inw(iobase + PC87427_REG_TEMP));
  265. data->temp_max[nr] = inb(iobase + PC87427_REG_TEMP_MAX);
  266. data->temp_min[nr] = inb(iobase + PC87427_REG_TEMP_MIN);
  267. data->temp_crit[nr] = inb(iobase + PC87427_REG_TEMP_CRIT);
  268. data->temp_type[nr] = inb(iobase + PC87427_REG_TEMP_TYPE);
  269. data->temp_status[nr] = inb(iobase + PC87427_REG_TEMP_STATUS);
  270. /* Clear fan alarm bits */
  271. outb(data->temp_status[nr], iobase + PC87427_REG_TEMP_STATUS);
  272. }
  273. static inline unsigned int temp_type_from_reg(u8 reg)
  274. {
  275. switch (reg & TEMP_TYPE_MASK) {
  276. case TEMP_TYPE_THERMISTOR:
  277. return 4;
  278. case TEMP_TYPE_REMOTE_DIODE:
  279. case TEMP_TYPE_LOCAL_DIODE:
  280. return 3;
  281. default:
  282. return 0;
  283. }
  284. }
  285. /*
  286. * We assume 8-bit thermal sensors; 9-bit thermal sensors are possible
  287. * too, but I have no idea how to figure out when they are used.
  288. */
  289. static inline long temp_from_reg(s16 reg)
  290. {
  291. return reg * 1000 / 256;
  292. }
  293. static inline long temp_from_reg8(s8 reg)
  294. {
  295. return reg * 1000;
  296. }
  297. /*
  298. * Data interface
  299. */
  300. static struct pc87427_data *pc87427_update_device(struct device *dev)
  301. {
  302. struct pc87427_data *data = dev_get_drvdata(dev);
  303. int i;
  304. mutex_lock(&data->lock);
  305. if (!time_after(jiffies, data->last_updated + HZ)
  306. && data->last_updated)
  307. goto done;
  308. /* Fans */
  309. for (i = 0; i < 8; i++) {
  310. if (!(data->fan_enabled & (1 << i)))
  311. continue;
  312. pc87427_readall_fan(data, i);
  313. }
  314. /* PWM outputs */
  315. for (i = 0; i < 4; i++) {
  316. if (!(data->pwm_enabled & (1 << i)))
  317. continue;
  318. pc87427_readall_pwm(data, i);
  319. }
  320. /* Temperature channels */
  321. for (i = 0; i < 6; i++) {
  322. if (!(data->temp_enabled & (1 << i)))
  323. continue;
  324. pc87427_readall_temp(data, i);
  325. }
  326. data->last_updated = jiffies;
  327. done:
  328. mutex_unlock(&data->lock);
  329. return data;
  330. }
  331. static ssize_t fan_input_show(struct device *dev,
  332. struct device_attribute *devattr, char *buf)
  333. {
  334. struct pc87427_data *data = pc87427_update_device(dev);
  335. int nr = to_sensor_dev_attr(devattr)->index;
  336. return sprintf(buf, "%lu\n", fan_from_reg(data->fan[nr]));
  337. }
  338. static ssize_t fan_min_show(struct device *dev,
  339. struct device_attribute *devattr, char *buf)
  340. {
  341. struct pc87427_data *data = pc87427_update_device(dev);
  342. int nr = to_sensor_dev_attr(devattr)->index;
  343. return sprintf(buf, "%lu\n", fan_from_reg(data->fan_min[nr]));
  344. }
  345. static ssize_t fan_alarm_show(struct device *dev,
  346. struct device_attribute *devattr, char *buf)
  347. {
  348. struct pc87427_data *data = pc87427_update_device(dev);
  349. int nr = to_sensor_dev_attr(devattr)->index;
  350. return sprintf(buf, "%d\n", !!(data->fan_status[nr]
  351. & FAN_STATUS_LOSPD));
  352. }
  353. static ssize_t fan_fault_show(struct device *dev,
  354. struct device_attribute *devattr, char *buf)
  355. {
  356. struct pc87427_data *data = pc87427_update_device(dev);
  357. int nr = to_sensor_dev_attr(devattr)->index;
  358. return sprintf(buf, "%d\n", !!(data->fan_status[nr]
  359. & FAN_STATUS_STALL));
  360. }
  361. static ssize_t fan_min_store(struct device *dev,
  362. struct device_attribute *devattr,
  363. const char *buf, size_t count)
  364. {
  365. struct pc87427_data *data = dev_get_drvdata(dev);
  366. int nr = to_sensor_dev_attr(devattr)->index;
  367. unsigned long val;
  368. int iobase = data->address[LD_FAN];
  369. if (kstrtoul(buf, 10, &val) < 0)
  370. return -EINVAL;
  371. mutex_lock(&data->lock);
  372. outb(BANK_FM(nr), iobase + PC87427_REG_BANK);
  373. /*
  374. * The low speed limit registers are read-only while monitoring
  375. * is enabled, so we have to disable monitoring, then change the
  376. * limit, and finally enable monitoring again.
  377. */
  378. outb(0, iobase + PC87427_REG_FAN_STATUS);
  379. data->fan_min[nr] = fan_to_reg(val);
  380. outw(data->fan_min[nr], iobase + PC87427_REG_FAN_MIN);
  381. outb(FAN_STATUS_MONEN, iobase + PC87427_REG_FAN_STATUS);
  382. mutex_unlock(&data->lock);
  383. return count;
  384. }
  385. static SENSOR_DEVICE_ATTR_RO(fan1_input, fan_input, 0);
  386. static SENSOR_DEVICE_ATTR_RO(fan2_input, fan_input, 1);
  387. static SENSOR_DEVICE_ATTR_RO(fan3_input, fan_input, 2);
  388. static SENSOR_DEVICE_ATTR_RO(fan4_input, fan_input, 3);
  389. static SENSOR_DEVICE_ATTR_RO(fan5_input, fan_input, 4);
  390. static SENSOR_DEVICE_ATTR_RO(fan6_input, fan_input, 5);
  391. static SENSOR_DEVICE_ATTR_RO(fan7_input, fan_input, 6);
  392. static SENSOR_DEVICE_ATTR_RO(fan8_input, fan_input, 7);
  393. static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);
  394. static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
  395. static SENSOR_DEVICE_ATTR_RW(fan3_min, fan_min, 2);
  396. static SENSOR_DEVICE_ATTR_RW(fan4_min, fan_min, 3);
  397. static SENSOR_DEVICE_ATTR_RW(fan5_min, fan_min, 4);
  398. static SENSOR_DEVICE_ATTR_RW(fan6_min, fan_min, 5);
  399. static SENSOR_DEVICE_ATTR_RW(fan7_min, fan_min, 6);
  400. static SENSOR_DEVICE_ATTR_RW(fan8_min, fan_min, 7);
  401. static SENSOR_DEVICE_ATTR_RO(fan1_alarm, fan_alarm, 0);
  402. static SENSOR_DEVICE_ATTR_RO(fan2_alarm, fan_alarm, 1);
  403. static SENSOR_DEVICE_ATTR_RO(fan3_alarm, fan_alarm, 2);
  404. static SENSOR_DEVICE_ATTR_RO(fan4_alarm, fan_alarm, 3);
  405. static SENSOR_DEVICE_ATTR_RO(fan5_alarm, fan_alarm, 4);
  406. static SENSOR_DEVICE_ATTR_RO(fan6_alarm, fan_alarm, 5);
  407. static SENSOR_DEVICE_ATTR_RO(fan7_alarm, fan_alarm, 6);
  408. static SENSOR_DEVICE_ATTR_RO(fan8_alarm, fan_alarm, 7);
  409. static SENSOR_DEVICE_ATTR_RO(fan1_fault, fan_fault, 0);
  410. static SENSOR_DEVICE_ATTR_RO(fan2_fault, fan_fault, 1);
  411. static SENSOR_DEVICE_ATTR_RO(fan3_fault, fan_fault, 2);
  412. static SENSOR_DEVICE_ATTR_RO(fan4_fault, fan_fault, 3);
  413. static SENSOR_DEVICE_ATTR_RO(fan5_fault, fan_fault, 4);
  414. static SENSOR_DEVICE_ATTR_RO(fan6_fault, fan_fault, 5);
  415. static SENSOR_DEVICE_ATTR_RO(fan7_fault, fan_fault, 6);
  416. static SENSOR_DEVICE_ATTR_RO(fan8_fault, fan_fault, 7);
  417. static struct attribute *pc87427_attributes_fan[8][5] = {
  418. {
  419. &sensor_dev_attr_fan1_input.dev_attr.attr,
  420. &sensor_dev_attr_fan1_min.dev_attr.attr,
  421. &sensor_dev_attr_fan1_alarm.dev_attr.attr,
  422. &sensor_dev_attr_fan1_fault.dev_attr.attr,
  423. NULL
  424. }, {
  425. &sensor_dev_attr_fan2_input.dev_attr.attr,
  426. &sensor_dev_attr_fan2_min.dev_attr.attr,
  427. &sensor_dev_attr_fan2_alarm.dev_attr.attr,
  428. &sensor_dev_attr_fan2_fault.dev_attr.attr,
  429. NULL
  430. }, {
  431. &sensor_dev_attr_fan3_input.dev_attr.attr,
  432. &sensor_dev_attr_fan3_min.dev_attr.attr,
  433. &sensor_dev_attr_fan3_alarm.dev_attr.attr,
  434. &sensor_dev_attr_fan3_fault.dev_attr.attr,
  435. NULL
  436. }, {
  437. &sensor_dev_attr_fan4_input.dev_attr.attr,
  438. &sensor_dev_attr_fan4_min.dev_attr.attr,
  439. &sensor_dev_attr_fan4_alarm.dev_attr.attr,
  440. &sensor_dev_attr_fan4_fault.dev_attr.attr,
  441. NULL
  442. }, {
  443. &sensor_dev_attr_fan5_input.dev_attr.attr,
  444. &sensor_dev_attr_fan5_min.dev_attr.attr,
  445. &sensor_dev_attr_fan5_alarm.dev_attr.attr,
  446. &sensor_dev_attr_fan5_fault.dev_attr.attr,
  447. NULL
  448. }, {
  449. &sensor_dev_attr_fan6_input.dev_attr.attr,
  450. &sensor_dev_attr_fan6_min.dev_attr.attr,
  451. &sensor_dev_attr_fan6_alarm.dev_attr.attr,
  452. &sensor_dev_attr_fan6_fault.dev_attr.attr,
  453. NULL
  454. }, {
  455. &sensor_dev_attr_fan7_input.dev_attr.attr,
  456. &sensor_dev_attr_fan7_min.dev_attr.attr,
  457. &sensor_dev_attr_fan7_alarm.dev_attr.attr,
  458. &sensor_dev_attr_fan7_fault.dev_attr.attr,
  459. NULL
  460. }, {
  461. &sensor_dev_attr_fan8_input.dev_attr.attr,
  462. &sensor_dev_attr_fan8_min.dev_attr.attr,
  463. &sensor_dev_attr_fan8_alarm.dev_attr.attr,
  464. &sensor_dev_attr_fan8_fault.dev_attr.attr,
  465. NULL
  466. }
  467. };
  468. static const struct attribute_group pc87427_group_fan[8] = {
  469. { .attrs = pc87427_attributes_fan[0] },
  470. { .attrs = pc87427_attributes_fan[1] },
  471. { .attrs = pc87427_attributes_fan[2] },
  472. { .attrs = pc87427_attributes_fan[3] },
  473. { .attrs = pc87427_attributes_fan[4] },
  474. { .attrs = pc87427_attributes_fan[5] },
  475. { .attrs = pc87427_attributes_fan[6] },
  476. { .attrs = pc87427_attributes_fan[7] },
  477. };
  478. /*
  479. * Must be called with data->lock held and pc87427_readall_pwm() freshly
  480. * called
  481. */
  482. static void update_pwm_enable(struct pc87427_data *data, int nr, u8 mode)
  483. {
  484. int iobase = data->address[LD_FAN];
  485. data->pwm_enable[nr] &= ~PWM_ENABLE_MODE_MASK;
  486. data->pwm_enable[nr] |= mode;
  487. outb(data->pwm_enable[nr], iobase + PC87427_REG_PWM_ENABLE);
  488. }
  489. static ssize_t pwm_enable_show(struct device *dev,
  490. struct device_attribute *devattr, char *buf)
  491. {
  492. struct pc87427_data *data = pc87427_update_device(dev);
  493. int nr = to_sensor_dev_attr(devattr)->index;
  494. int pwm_enable;
  495. pwm_enable = pwm_enable_from_reg(data->pwm_enable[nr]);
  496. if (pwm_enable < 0)
  497. return pwm_enable;
  498. return sprintf(buf, "%d\n", pwm_enable);
  499. }
  500. static ssize_t pwm_enable_store(struct device *dev,
  501. struct device_attribute *devattr,
  502. const char *buf, size_t count)
  503. {
  504. struct pc87427_data *data = dev_get_drvdata(dev);
  505. int nr = to_sensor_dev_attr(devattr)->index;
  506. unsigned long val;
  507. if (kstrtoul(buf, 10, &val) < 0 || val > 2)
  508. return -EINVAL;
  509. /* Can't go to automatic mode if it isn't configured */
  510. if (val == 2 && !(data->pwm_auto_ok & (1 << nr)))
  511. return -EINVAL;
  512. mutex_lock(&data->lock);
  513. pc87427_readall_pwm(data, nr);
  514. update_pwm_enable(data, nr, pwm_enable_to_reg(val, data->pwm[nr]));
  515. mutex_unlock(&data->lock);
  516. return count;
  517. }
  518. static ssize_t pwm_show(struct device *dev, struct device_attribute *devattr,
  519. char *buf)
  520. {
  521. struct pc87427_data *data = pc87427_update_device(dev);
  522. int nr = to_sensor_dev_attr(devattr)->index;
  523. return sprintf(buf, "%d\n", (int)data->pwm[nr]);
  524. }
  525. static ssize_t pwm_store(struct device *dev, struct device_attribute *devattr,
  526. const char *buf, size_t count)
  527. {
  528. struct pc87427_data *data = dev_get_drvdata(dev);
  529. int nr = to_sensor_dev_attr(devattr)->index;
  530. unsigned long val;
  531. int iobase = data->address[LD_FAN];
  532. u8 mode;
  533. if (kstrtoul(buf, 10, &val) < 0 || val > 0xff)
  534. return -EINVAL;
  535. mutex_lock(&data->lock);
  536. pc87427_readall_pwm(data, nr);
  537. mode = data->pwm_enable[nr] & PWM_ENABLE_MODE_MASK;
  538. if (mode != PWM_MODE_MANUAL && mode != PWM_MODE_OFF) {
  539. dev_notice(dev,
  540. "Can't set PWM%d duty cycle while not in manual mode\n",
  541. nr + 1);
  542. mutex_unlock(&data->lock);
  543. return -EPERM;
  544. }
  545. /* We may have to change the mode */
  546. if (mode == PWM_MODE_MANUAL && val == 0) {
  547. /* Transition from Manual to Off */
  548. update_pwm_enable(data, nr, PWM_MODE_OFF);
  549. mode = PWM_MODE_OFF;
  550. dev_dbg(dev, "Switching PWM%d from %s to %s\n", nr + 1,
  551. "manual", "off");
  552. } else if (mode == PWM_MODE_OFF && val != 0) {
  553. /* Transition from Off to Manual */
  554. update_pwm_enable(data, nr, PWM_MODE_MANUAL);
  555. mode = PWM_MODE_MANUAL;
  556. dev_dbg(dev, "Switching PWM%d from %s to %s\n", nr + 1,
  557. "off", "manual");
  558. }
  559. data->pwm[nr] = val;
  560. if (mode == PWM_MODE_MANUAL)
  561. outb(val, iobase + PC87427_REG_PWM_DUTY);
  562. mutex_unlock(&data->lock);
  563. return count;
  564. }
  565. static SENSOR_DEVICE_ATTR_RW(pwm1_enable, pwm_enable, 0);
  566. static SENSOR_DEVICE_ATTR_RW(pwm2_enable, pwm_enable, 1);
  567. static SENSOR_DEVICE_ATTR_RW(pwm3_enable, pwm_enable, 2);
  568. static SENSOR_DEVICE_ATTR_RW(pwm4_enable, pwm_enable, 3);
  569. static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);
  570. static SENSOR_DEVICE_ATTR_RW(pwm2, pwm, 1);
  571. static SENSOR_DEVICE_ATTR_RW(pwm3, pwm, 2);
  572. static SENSOR_DEVICE_ATTR_RW(pwm4, pwm, 3);
  573. static struct attribute *pc87427_attributes_pwm[4][3] = {
  574. {
  575. &sensor_dev_attr_pwm1_enable.dev_attr.attr,
  576. &sensor_dev_attr_pwm1.dev_attr.attr,
  577. NULL
  578. }, {
  579. &sensor_dev_attr_pwm2_enable.dev_attr.attr,
  580. &sensor_dev_attr_pwm2.dev_attr.attr,
  581. NULL
  582. }, {
  583. &sensor_dev_attr_pwm3_enable.dev_attr.attr,
  584. &sensor_dev_attr_pwm3.dev_attr.attr,
  585. NULL
  586. }, {
  587. &sensor_dev_attr_pwm4_enable.dev_attr.attr,
  588. &sensor_dev_attr_pwm4.dev_attr.attr,
  589. NULL
  590. }
  591. };
  592. static const struct attribute_group pc87427_group_pwm[4] = {
  593. { .attrs = pc87427_attributes_pwm[0] },
  594. { .attrs = pc87427_attributes_pwm[1] },
  595. { .attrs = pc87427_attributes_pwm[2] },
  596. { .attrs = pc87427_attributes_pwm[3] },
  597. };
  598. static ssize_t temp_input_show(struct device *dev,
  599. struct device_attribute *devattr, char *buf)
  600. {
  601. struct pc87427_data *data = pc87427_update_device(dev);
  602. int nr = to_sensor_dev_attr(devattr)->index;
  603. return sprintf(buf, "%ld\n", temp_from_reg(data->temp[nr]));
  604. }
  605. static ssize_t temp_min_show(struct device *dev,
  606. struct device_attribute *devattr, char *buf)
  607. {
  608. struct pc87427_data *data = pc87427_update_device(dev);
  609. int nr = to_sensor_dev_attr(devattr)->index;
  610. return sprintf(buf, "%ld\n", temp_from_reg8(data->temp_min[nr]));
  611. }
  612. static ssize_t temp_max_show(struct device *dev,
  613. struct device_attribute *devattr, char *buf)
  614. {
  615. struct pc87427_data *data = pc87427_update_device(dev);
  616. int nr = to_sensor_dev_attr(devattr)->index;
  617. return sprintf(buf, "%ld\n", temp_from_reg8(data->temp_max[nr]));
  618. }
  619. static ssize_t temp_crit_show(struct device *dev,
  620. struct device_attribute *devattr, char *buf)
  621. {
  622. struct pc87427_data *data = pc87427_update_device(dev);
  623. int nr = to_sensor_dev_attr(devattr)->index;
  624. return sprintf(buf, "%ld\n", temp_from_reg8(data->temp_crit[nr]));
  625. }
  626. static ssize_t temp_type_show(struct device *dev,
  627. struct device_attribute *devattr, char *buf)
  628. {
  629. struct pc87427_data *data = pc87427_update_device(dev);
  630. int nr = to_sensor_dev_attr(devattr)->index;
  631. return sprintf(buf, "%u\n", temp_type_from_reg(data->temp_type[nr]));
  632. }
  633. static ssize_t temp_min_alarm_show(struct device *dev,
  634. struct device_attribute *devattr,
  635. char *buf)
  636. {
  637. struct pc87427_data *data = pc87427_update_device(dev);
  638. int nr = to_sensor_dev_attr(devattr)->index;
  639. return sprintf(buf, "%d\n", !!(data->temp_status[nr]
  640. & TEMP_STATUS_LOWFLG));
  641. }
  642. static ssize_t temp_max_alarm_show(struct device *dev,
  643. struct device_attribute *devattr,
  644. char *buf)
  645. {
  646. struct pc87427_data *data = pc87427_update_device(dev);
  647. int nr = to_sensor_dev_attr(devattr)->index;
  648. return sprintf(buf, "%d\n", !!(data->temp_status[nr]
  649. & TEMP_STATUS_HIGHFLG));
  650. }
  651. static ssize_t temp_crit_alarm_show(struct device *dev,
  652. struct device_attribute *devattr,
  653. char *buf)
  654. {
  655. struct pc87427_data *data = pc87427_update_device(dev);
  656. int nr = to_sensor_dev_attr(devattr)->index;
  657. return sprintf(buf, "%d\n", !!(data->temp_status[nr]
  658. & TEMP_STATUS_CRITFLG));
  659. }
  660. static ssize_t temp_fault_show(struct device *dev,
  661. struct device_attribute *devattr, char *buf)
  662. {
  663. struct pc87427_data *data = pc87427_update_device(dev);
  664. int nr = to_sensor_dev_attr(devattr)->index;
  665. return sprintf(buf, "%d\n", !!(data->temp_status[nr]
  666. & TEMP_STATUS_SENSERR));
  667. }
  668. static SENSOR_DEVICE_ATTR_RO(temp1_input, temp_input, 0);
  669. static SENSOR_DEVICE_ATTR_RO(temp2_input, temp_input, 1);
  670. static SENSOR_DEVICE_ATTR_RO(temp3_input, temp_input, 2);
  671. static SENSOR_DEVICE_ATTR_RO(temp4_input, temp_input, 3);
  672. static SENSOR_DEVICE_ATTR_RO(temp5_input, temp_input, 4);
  673. static SENSOR_DEVICE_ATTR_RO(temp6_input, temp_input, 5);
  674. static SENSOR_DEVICE_ATTR_RO(temp1_min, temp_min, 0);
  675. static SENSOR_DEVICE_ATTR_RO(temp2_min, temp_min, 1);
  676. static SENSOR_DEVICE_ATTR_RO(temp3_min, temp_min, 2);
  677. static SENSOR_DEVICE_ATTR_RO(temp4_min, temp_min, 3);
  678. static SENSOR_DEVICE_ATTR_RO(temp5_min, temp_min, 4);
  679. static SENSOR_DEVICE_ATTR_RO(temp6_min, temp_min, 5);
  680. static SENSOR_DEVICE_ATTR_RO(temp1_max, temp_max, 0);
  681. static SENSOR_DEVICE_ATTR_RO(temp2_max, temp_max, 1);
  682. static SENSOR_DEVICE_ATTR_RO(temp3_max, temp_max, 2);
  683. static SENSOR_DEVICE_ATTR_RO(temp4_max, temp_max, 3);
  684. static SENSOR_DEVICE_ATTR_RO(temp5_max, temp_max, 4);
  685. static SENSOR_DEVICE_ATTR_RO(temp6_max, temp_max, 5);
  686. static SENSOR_DEVICE_ATTR_RO(temp1_crit, temp_crit, 0);
  687. static SENSOR_DEVICE_ATTR_RO(temp2_crit, temp_crit, 1);
  688. static SENSOR_DEVICE_ATTR_RO(temp3_crit, temp_crit, 2);
  689. static SENSOR_DEVICE_ATTR_RO(temp4_crit, temp_crit, 3);
  690. static SENSOR_DEVICE_ATTR_RO(temp5_crit, temp_crit, 4);
  691. static SENSOR_DEVICE_ATTR_RO(temp6_crit, temp_crit, 5);
  692. static SENSOR_DEVICE_ATTR_RO(temp1_type, temp_type, 0);
  693. static SENSOR_DEVICE_ATTR_RO(temp2_type, temp_type, 1);
  694. static SENSOR_DEVICE_ATTR_RO(temp3_type, temp_type, 2);
  695. static SENSOR_DEVICE_ATTR_RO(temp4_type, temp_type, 3);
  696. static SENSOR_DEVICE_ATTR_RO(temp5_type, temp_type, 4);
  697. static SENSOR_DEVICE_ATTR_RO(temp6_type, temp_type, 5);
  698. static SENSOR_DEVICE_ATTR_RO(temp1_min_alarm, temp_min_alarm, 0);
  699. static SENSOR_DEVICE_ATTR_RO(temp2_min_alarm, temp_min_alarm, 1);
  700. static SENSOR_DEVICE_ATTR_RO(temp3_min_alarm, temp_min_alarm, 2);
  701. static SENSOR_DEVICE_ATTR_RO(temp4_min_alarm, temp_min_alarm, 3);
  702. static SENSOR_DEVICE_ATTR_RO(temp5_min_alarm, temp_min_alarm, 4);
  703. static SENSOR_DEVICE_ATTR_RO(temp6_min_alarm, temp_min_alarm, 5);
  704. static SENSOR_DEVICE_ATTR_RO(temp1_max_alarm, temp_max_alarm, 0);
  705. static SENSOR_DEVICE_ATTR_RO(temp2_max_alarm, temp_max_alarm, 1);
  706. static SENSOR_DEVICE_ATTR_RO(temp3_max_alarm, temp_max_alarm, 2);
  707. static SENSOR_DEVICE_ATTR_RO(temp4_max_alarm, temp_max_alarm, 3);
  708. static SENSOR_DEVICE_ATTR_RO(temp5_max_alarm, temp_max_alarm, 4);
  709. static SENSOR_DEVICE_ATTR_RO(temp6_max_alarm, temp_max_alarm, 5);
  710. static SENSOR_DEVICE_ATTR_RO(temp1_crit_alarm, temp_crit_alarm, 0);
  711. static SENSOR_DEVICE_ATTR_RO(temp2_crit_alarm, temp_crit_alarm, 1);
  712. static SENSOR_DEVICE_ATTR_RO(temp3_crit_alarm, temp_crit_alarm, 2);
  713. static SENSOR_DEVICE_ATTR_RO(temp4_crit_alarm, temp_crit_alarm, 3);
  714. static SENSOR_DEVICE_ATTR_RO(temp5_crit_alarm, temp_crit_alarm, 4);
  715. static SENSOR_DEVICE_ATTR_RO(temp6_crit_alarm, temp_crit_alarm, 5);
  716. static SENSOR_DEVICE_ATTR_RO(temp1_fault, temp_fault, 0);
  717. static SENSOR_DEVICE_ATTR_RO(temp2_fault, temp_fault, 1);
  718. static SENSOR_DEVICE_ATTR_RO(temp3_fault, temp_fault, 2);
  719. static SENSOR_DEVICE_ATTR_RO(temp4_fault, temp_fault, 3);
  720. static SENSOR_DEVICE_ATTR_RO(temp5_fault, temp_fault, 4);
  721. static SENSOR_DEVICE_ATTR_RO(temp6_fault, temp_fault, 5);
  722. static struct attribute *pc87427_attributes_temp[6][10] = {
  723. {
  724. &sensor_dev_attr_temp1_input.dev_attr.attr,
  725. &sensor_dev_attr_temp1_min.dev_attr.attr,
  726. &sensor_dev_attr_temp1_max.dev_attr.attr,
  727. &sensor_dev_attr_temp1_crit.dev_attr.attr,
  728. &sensor_dev_attr_temp1_type.dev_attr.attr,
  729. &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
  730. &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
  731. &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
  732. &sensor_dev_attr_temp1_fault.dev_attr.attr,
  733. NULL
  734. }, {
  735. &sensor_dev_attr_temp2_input.dev_attr.attr,
  736. &sensor_dev_attr_temp2_min.dev_attr.attr,
  737. &sensor_dev_attr_temp2_max.dev_attr.attr,
  738. &sensor_dev_attr_temp2_crit.dev_attr.attr,
  739. &sensor_dev_attr_temp2_type.dev_attr.attr,
  740. &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
  741. &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
  742. &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
  743. &sensor_dev_attr_temp2_fault.dev_attr.attr,
  744. NULL
  745. }, {
  746. &sensor_dev_attr_temp3_input.dev_attr.attr,
  747. &sensor_dev_attr_temp3_min.dev_attr.attr,
  748. &sensor_dev_attr_temp3_max.dev_attr.attr,
  749. &sensor_dev_attr_temp3_crit.dev_attr.attr,
  750. &sensor_dev_attr_temp3_type.dev_attr.attr,
  751. &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
  752. &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
  753. &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
  754. &sensor_dev_attr_temp3_fault.dev_attr.attr,
  755. NULL
  756. }, {
  757. &sensor_dev_attr_temp4_input.dev_attr.attr,
  758. &sensor_dev_attr_temp4_min.dev_attr.attr,
  759. &sensor_dev_attr_temp4_max.dev_attr.attr,
  760. &sensor_dev_attr_temp4_crit.dev_attr.attr,
  761. &sensor_dev_attr_temp4_type.dev_attr.attr,
  762. &sensor_dev_attr_temp4_min_alarm.dev_attr.attr,
  763. &sensor_dev_attr_temp4_max_alarm.dev_attr.attr,
  764. &sensor_dev_attr_temp4_crit_alarm.dev_attr.attr,
  765. &sensor_dev_attr_temp4_fault.dev_attr.attr,
  766. NULL
  767. }, {
  768. &sensor_dev_attr_temp5_input.dev_attr.attr,
  769. &sensor_dev_attr_temp5_min.dev_attr.attr,
  770. &sensor_dev_attr_temp5_max.dev_attr.attr,
  771. &sensor_dev_attr_temp5_crit.dev_attr.attr,
  772. &sensor_dev_attr_temp5_type.dev_attr.attr,
  773. &sensor_dev_attr_temp5_min_alarm.dev_attr.attr,
  774. &sensor_dev_attr_temp5_max_alarm.dev_attr.attr,
  775. &sensor_dev_attr_temp5_crit_alarm.dev_attr.attr,
  776. &sensor_dev_attr_temp5_fault.dev_attr.attr,
  777. NULL
  778. }, {
  779. &sensor_dev_attr_temp6_input.dev_attr.attr,
  780. &sensor_dev_attr_temp6_min.dev_attr.attr,
  781. &sensor_dev_attr_temp6_max.dev_attr.attr,
  782. &sensor_dev_attr_temp6_crit.dev_attr.attr,
  783. &sensor_dev_attr_temp6_type.dev_attr.attr,
  784. &sensor_dev_attr_temp6_min_alarm.dev_attr.attr,
  785. &sensor_dev_attr_temp6_max_alarm.dev_attr.attr,
  786. &sensor_dev_attr_temp6_crit_alarm.dev_attr.attr,
  787. &sensor_dev_attr_temp6_fault.dev_attr.attr,
  788. NULL
  789. }
  790. };
  791. static const struct attribute_group pc87427_group_temp[6] = {
  792. { .attrs = pc87427_attributes_temp[0] },
  793. { .attrs = pc87427_attributes_temp[1] },
  794. { .attrs = pc87427_attributes_temp[2] },
  795. { .attrs = pc87427_attributes_temp[3] },
  796. { .attrs = pc87427_attributes_temp[4] },
  797. { .attrs = pc87427_attributes_temp[5] },
  798. };
  799. static ssize_t name_show(struct device *dev, struct device_attribute
  800. *devattr, char *buf)
  801. {
  802. struct pc87427_data *data = dev_get_drvdata(dev);
  803. return sprintf(buf, "%s\n", data->name);
  804. }
  805. static DEVICE_ATTR_RO(name);
  806. /*
  807. * Device detection, attach and detach
  808. */
  809. static int pc87427_request_regions(struct platform_device *pdev,
  810. int count)
  811. {
  812. struct resource *res;
  813. int i;
  814. for (i = 0; i < count; i++) {
  815. res = platform_get_resource(pdev, IORESOURCE_IO, i);
  816. if (!res) {
  817. dev_err(&pdev->dev, "Missing resource #%d\n", i);
  818. return -ENOENT;
  819. }
  820. if (!devm_request_region(&pdev->dev, res->start,
  821. resource_size(res), DRVNAME)) {
  822. dev_err(&pdev->dev,
  823. "Failed to request region 0x%lx-0x%lx\n",
  824. (unsigned long)res->start,
  825. (unsigned long)res->end);
  826. return -EBUSY;
  827. }
  828. }
  829. return 0;
  830. }
  831. static void pc87427_init_device(struct device *dev)
  832. {
  833. struct pc87427_sio_data *sio_data = dev_get_platdata(dev);
  834. struct pc87427_data *data = dev_get_drvdata(dev);
  835. int i;
  836. u8 reg;
  837. /* The FMC module should be ready */
  838. reg = pc87427_read8(data, LD_FAN, PC87427_REG_BANK);
  839. if (!(reg & 0x80))
  840. dev_warn(dev, "%s module not ready!\n", "FMC");
  841. /* Check which fans are enabled */
  842. for (i = 0; i < 8; i++) {
  843. if (!(sio_data->has_fanin & (1 << i))) /* Not wired */
  844. continue;
  845. reg = pc87427_read8_bank(data, LD_FAN, BANK_FM(i),
  846. PC87427_REG_FAN_STATUS);
  847. if (reg & FAN_STATUS_MONEN)
  848. data->fan_enabled |= (1 << i);
  849. }
  850. if (!data->fan_enabled) {
  851. dev_dbg(dev, "Enabling monitoring of all fans\n");
  852. for (i = 0; i < 8; i++) {
  853. if (!(sio_data->has_fanin & (1 << i))) /* Not wired */
  854. continue;
  855. pc87427_write8_bank(data, LD_FAN, BANK_FM(i),
  856. PC87427_REG_FAN_STATUS,
  857. FAN_STATUS_MONEN);
  858. }
  859. data->fan_enabled = sio_data->has_fanin;
  860. }
  861. /* Check which PWM outputs are enabled */
  862. for (i = 0; i < 4; i++) {
  863. if (!(sio_data->has_fanout & (1 << i))) /* Not wired */
  864. continue;
  865. reg = pc87427_read8_bank(data, LD_FAN, BANK_FC(i),
  866. PC87427_REG_PWM_ENABLE);
  867. if (reg & PWM_ENABLE_CTLEN)
  868. data->pwm_enabled |= (1 << i);
  869. /*
  870. * We don't expose an interface to reconfigure the automatic
  871. * fan control mode, so only allow to return to this mode if
  872. * it was originally set.
  873. */
  874. if ((reg & PWM_ENABLE_MODE_MASK) == PWM_MODE_AUTO) {
  875. dev_dbg(dev, "PWM%d is in automatic control mode\n",
  876. i + 1);
  877. data->pwm_auto_ok |= (1 << i);
  878. }
  879. }
  880. /* The HMC module should be ready */
  881. reg = pc87427_read8(data, LD_TEMP, PC87427_REG_BANK);
  882. if (!(reg & 0x80))
  883. dev_warn(dev, "%s module not ready!\n", "HMC");
  884. /* Check which temperature channels are enabled */
  885. for (i = 0; i < 6; i++) {
  886. reg = pc87427_read8_bank(data, LD_TEMP, BANK_TM(i),
  887. PC87427_REG_TEMP_STATUS);
  888. if (reg & TEMP_STATUS_CHANEN)
  889. data->temp_enabled |= (1 << i);
  890. }
  891. }
  892. static void pc87427_remove_files(struct device *dev)
  893. {
  894. struct pc87427_data *data = dev_get_drvdata(dev);
  895. int i;
  896. device_remove_file(dev, &dev_attr_name);
  897. for (i = 0; i < 8; i++) {
  898. if (!(data->fan_enabled & (1 << i)))
  899. continue;
  900. sysfs_remove_group(&dev->kobj, &pc87427_group_fan[i]);
  901. }
  902. for (i = 0; i < 4; i++) {
  903. if (!(data->pwm_enabled & (1 << i)))
  904. continue;
  905. sysfs_remove_group(&dev->kobj, &pc87427_group_pwm[i]);
  906. }
  907. for (i = 0; i < 6; i++) {
  908. if (!(data->temp_enabled & (1 << i)))
  909. continue;
  910. sysfs_remove_group(&dev->kobj, &pc87427_group_temp[i]);
  911. }
  912. }
  913. static int pc87427_probe(struct platform_device *pdev)
  914. {
  915. struct pc87427_sio_data *sio_data = dev_get_platdata(&pdev->dev);
  916. struct pc87427_data *data;
  917. int i, err, res_count;
  918. data = devm_kzalloc(&pdev->dev, sizeof(struct pc87427_data),
  919. GFP_KERNEL);
  920. if (!data)
  921. return -ENOMEM;
  922. data->address[0] = sio_data->address[0];
  923. data->address[1] = sio_data->address[1];
  924. res_count = (data->address[0] != 0) + (data->address[1] != 0);
  925. err = pc87427_request_regions(pdev, res_count);
  926. if (err)
  927. return err;
  928. mutex_init(&data->lock);
  929. data->name = "pc87427";
  930. platform_set_drvdata(pdev, data);
  931. pc87427_init_device(&pdev->dev);
  932. /* Register sysfs hooks */
  933. err = device_create_file(&pdev->dev, &dev_attr_name);
  934. if (err)
  935. return err;
  936. for (i = 0; i < 8; i++) {
  937. if (!(data->fan_enabled & (1 << i)))
  938. continue;
  939. err = sysfs_create_group(&pdev->dev.kobj,
  940. &pc87427_group_fan[i]);
  941. if (err)
  942. goto exit_remove_files;
  943. }
  944. for (i = 0; i < 4; i++) {
  945. if (!(data->pwm_enabled & (1 << i)))
  946. continue;
  947. err = sysfs_create_group(&pdev->dev.kobj,
  948. &pc87427_group_pwm[i]);
  949. if (err)
  950. goto exit_remove_files;
  951. }
  952. for (i = 0; i < 6; i++) {
  953. if (!(data->temp_enabled & (1 << i)))
  954. continue;
  955. err = sysfs_create_group(&pdev->dev.kobj,
  956. &pc87427_group_temp[i]);
  957. if (err)
  958. goto exit_remove_files;
  959. }
  960. data->hwmon_dev = hwmon_device_register(&pdev->dev);
  961. if (IS_ERR(data->hwmon_dev)) {
  962. err = PTR_ERR(data->hwmon_dev);
  963. dev_err(&pdev->dev, "Class registration failed (%d)\n", err);
  964. goto exit_remove_files;
  965. }
  966. return 0;
  967. exit_remove_files:
  968. pc87427_remove_files(&pdev->dev);
  969. return err;
  970. }
  971. static int pc87427_remove(struct platform_device *pdev)
  972. {
  973. struct pc87427_data *data = platform_get_drvdata(pdev);
  974. hwmon_device_unregister(data->hwmon_dev);
  975. pc87427_remove_files(&pdev->dev);
  976. return 0;
  977. }
  978. static struct platform_driver pc87427_driver = {
  979. .driver = {
  980. .name = DRVNAME,
  981. },
  982. .probe = pc87427_probe,
  983. .remove = pc87427_remove,
  984. };
  985. static int __init pc87427_device_add(const struct pc87427_sio_data *sio_data)
  986. {
  987. struct resource res[2] = {
  988. { .flags = IORESOURCE_IO },
  989. { .flags = IORESOURCE_IO },
  990. };
  991. int err, i, res_count;
  992. res_count = 0;
  993. for (i = 0; i < 2; i++) {
  994. if (!sio_data->address[i])
  995. continue;
  996. res[res_count].start = sio_data->address[i];
  997. res[res_count].end = sio_data->address[i] + REGION_LENGTH - 1;
  998. res[res_count].name = logdev_str[i];
  999. err = acpi_check_resource_conflict(&res[res_count]);
  1000. if (err)
  1001. goto exit;
  1002. res_count++;
  1003. }
  1004. pdev = platform_device_alloc(DRVNAME, res[0].start);
  1005. if (!pdev) {
  1006. err = -ENOMEM;
  1007. pr_err("Device allocation failed\n");
  1008. goto exit;
  1009. }
  1010. err = platform_device_add_resources(pdev, res, res_count);
  1011. if (err) {
  1012. pr_err("Device resource addition failed (%d)\n", err);
  1013. goto exit_device_put;
  1014. }
  1015. err = platform_device_add_data(pdev, sio_data,
  1016. sizeof(struct pc87427_sio_data));
  1017. if (err) {
  1018. pr_err("Platform data allocation failed\n");
  1019. goto exit_device_put;
  1020. }
  1021. err = platform_device_add(pdev);
  1022. if (err) {
  1023. pr_err("Device addition failed (%d)\n", err);
  1024. goto exit_device_put;
  1025. }
  1026. return 0;
  1027. exit_device_put:
  1028. platform_device_put(pdev);
  1029. exit:
  1030. return err;
  1031. }
  1032. static int __init pc87427_find(int sioaddr, struct pc87427_sio_data *sio_data)
  1033. {
  1034. u16 val;
  1035. u8 cfg, cfg_b;
  1036. int i, err;
  1037. err = superio_enter(sioaddr);
  1038. if (err)
  1039. return err;
  1040. /* Identify device */
  1041. val = force_id ? force_id : superio_inb(sioaddr, SIOREG_DEVID);
  1042. if (val != 0xf2) { /* PC87427 */
  1043. err = -ENODEV;
  1044. goto exit;
  1045. }
  1046. for (i = 0; i < 2; i++) {
  1047. sio_data->address[i] = 0;
  1048. /* Select logical device */
  1049. superio_outb(sioaddr, SIOREG_LDSEL, logdev[i]);
  1050. val = superio_inb(sioaddr, SIOREG_ACT);
  1051. if (!(val & 0x01)) {
  1052. pr_info("Logical device 0x%02x not activated\n",
  1053. logdev[i]);
  1054. continue;
  1055. }
  1056. val = superio_inb(sioaddr, SIOREG_MAP);
  1057. if (val & 0x01) {
  1058. pr_warn("Logical device 0x%02x is memory-mapped, can't use\n",
  1059. logdev[i]);
  1060. continue;
  1061. }
  1062. val = (superio_inb(sioaddr, SIOREG_IOBASE) << 8)
  1063. | superio_inb(sioaddr, SIOREG_IOBASE + 1);
  1064. if (!val) {
  1065. pr_info("I/O base address not set for logical device 0x%02x\n",
  1066. logdev[i]);
  1067. continue;
  1068. }
  1069. sio_data->address[i] = val;
  1070. }
  1071. /* No point in loading the driver if everything is disabled */
  1072. if (!sio_data->address[0] && !sio_data->address[1]) {
  1073. err = -ENODEV;
  1074. goto exit;
  1075. }
  1076. /* Check which fan inputs are wired */
  1077. sio_data->has_fanin = (1 << 2) | (1 << 3); /* FANIN2, FANIN3 */
  1078. cfg = superio_inb(sioaddr, SIOREG_CF2);
  1079. if (!(cfg & (1 << 3)))
  1080. sio_data->has_fanin |= (1 << 0); /* FANIN0 */
  1081. if (!(cfg & (1 << 2)))
  1082. sio_data->has_fanin |= (1 << 4); /* FANIN4 */
  1083. cfg = superio_inb(sioaddr, SIOREG_CFD);
  1084. if (!(cfg & (1 << 0)))
  1085. sio_data->has_fanin |= (1 << 1); /* FANIN1 */
  1086. cfg = superio_inb(sioaddr, SIOREG_CF4);
  1087. if (!(cfg & (1 << 0)))
  1088. sio_data->has_fanin |= (1 << 7); /* FANIN7 */
  1089. cfg_b = superio_inb(sioaddr, SIOREG_CFB);
  1090. if (!(cfg & (1 << 1)) && (cfg_b & (1 << 3)))
  1091. sio_data->has_fanin |= (1 << 5); /* FANIN5 */
  1092. cfg = superio_inb(sioaddr, SIOREG_CF3);
  1093. if ((cfg & (1 << 3)) && !(cfg_b & (1 << 5)))
  1094. sio_data->has_fanin |= (1 << 6); /* FANIN6 */
  1095. /* Check which fan outputs are wired */
  1096. sio_data->has_fanout = (1 << 0); /* FANOUT0 */
  1097. if (cfg_b & (1 << 0))
  1098. sio_data->has_fanout |= (1 << 3); /* FANOUT3 */
  1099. cfg = superio_inb(sioaddr, SIOREG_CFC);
  1100. if (!(cfg & (1 << 4))) {
  1101. if (cfg_b & (1 << 1))
  1102. sio_data->has_fanout |= (1 << 1); /* FANOUT1 */
  1103. if (cfg_b & (1 << 2))
  1104. sio_data->has_fanout |= (1 << 2); /* FANOUT2 */
  1105. }
  1106. /* FANOUT1 and FANOUT2 can each be routed to 2 different pins */
  1107. cfg = superio_inb(sioaddr, SIOREG_CF5);
  1108. if (cfg & (1 << 6))
  1109. sio_data->has_fanout |= (1 << 1); /* FANOUT1 */
  1110. if (cfg & (1 << 5))
  1111. sio_data->has_fanout |= (1 << 2); /* FANOUT2 */
  1112. exit:
  1113. superio_exit(sioaddr);
  1114. return err;
  1115. }
  1116. static int __init pc87427_init(void)
  1117. {
  1118. int err;
  1119. struct pc87427_sio_data sio_data;
  1120. if (pc87427_find(0x2e, &sio_data)
  1121. && pc87427_find(0x4e, &sio_data))
  1122. return -ENODEV;
  1123. err = platform_driver_register(&pc87427_driver);
  1124. if (err)
  1125. goto exit;
  1126. /* Sets global pdev as a side effect */
  1127. err = pc87427_device_add(&sio_data);
  1128. if (err)
  1129. goto exit_driver;
  1130. return 0;
  1131. exit_driver:
  1132. platform_driver_unregister(&pc87427_driver);
  1133. exit:
  1134. return err;
  1135. }
  1136. static void __exit pc87427_exit(void)
  1137. {
  1138. platform_device_unregister(pdev);
  1139. platform_driver_unregister(&pc87427_driver);
  1140. }
  1141. MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>");
  1142. MODULE_DESCRIPTION("PC87427 hardware monitoring driver");
  1143. MODULE_LICENSE("GPL");
  1144. module_init(pc87427_init);
  1145. module_exit(pc87427_exit);