pc87360.c 51 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * pc87360.c - Part of lm_sensors, Linux kernel modules
  4. * for hardware monitoring
  5. * Copyright (C) 2004, 2007 Jean Delvare <[email protected]>
  6. *
  7. * Copied from smsc47m1.c:
  8. * Copyright (C) 2002 Mark D. Studebaker <[email protected]>
  9. *
  10. * Supports the following chips:
  11. *
  12. * Chip #vin #fan #pwm #temp devid
  13. * PC87360 - 2 2 - 0xE1
  14. * PC87363 - 2 2 - 0xE8
  15. * PC87364 - 3 3 - 0xE4
  16. * PC87365 11 3 3 2 0xE5
  17. * PC87366 11 3 3 3-4 0xE9
  18. *
  19. * This driver assumes that no more than one chip is present, and one of
  20. * the standard Super-I/O addresses is used (0x2E/0x2F or 0x4E/0x4F).
  21. */
  22. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  23. #include <linux/module.h>
  24. #include <linux/init.h>
  25. #include <linux/slab.h>
  26. #include <linux/jiffies.h>
  27. #include <linux/platform_device.h>
  28. #include <linux/hwmon.h>
  29. #include <linux/hwmon-sysfs.h>
  30. #include <linux/hwmon-vid.h>
  31. #include <linux/err.h>
  32. #include <linux/mutex.h>
  33. #include <linux/acpi.h>
  34. #include <linux/io.h>
  35. #define DRIVER_NAME "pc87360"
  36. /* (temp & vin) channel conversion status register flags (pdf sec.11.5.12) */
  37. #define CHAN_CNVRTD 0x80 /* new data ready */
  38. #define CHAN_ENA 0x01 /* enabled channel (temp or vin) */
  39. #define CHAN_ALM_ENA 0x10 /* propagate to alarms-reg ?? (chk val!) */
  40. #define CHAN_READY (CHAN_ENA|CHAN_CNVRTD) /* sample ready mask */
  41. #define TEMP_OTS_OE 0x20 /* OTS Output Enable */
  42. #define VIN_RW1C_MASK (CHAN_READY|CHAN_ALM_MAX|CHAN_ALM_MIN) /* 0x87 */
  43. #define TEMP_RW1C_MASK (VIN_RW1C_MASK|TEMP_ALM_CRIT|TEMP_FAULT) /* 0xCF */
  44. static u8 devid;
  45. static struct platform_device *pdev;
  46. static unsigned short extra_isa[3];
  47. static u8 confreg[4];
  48. static int init = 1;
  49. module_param(init, int, 0);
  50. MODULE_PARM_DESC(init,
  51. "Chip initialization level:\n"
  52. " 0: None\n"
  53. "*1: Forcibly enable internal voltage and temperature channels, except in9\n"
  54. " 2: Forcibly enable all voltage and temperature channels, except in9\n"
  55. " 3: Forcibly enable all voltage and temperature channels, including in9");
  56. static unsigned short force_id;
  57. module_param(force_id, ushort, 0);
  58. MODULE_PARM_DESC(force_id, "Override the detected device ID");
  59. /*
  60. * Super-I/O registers and operations
  61. */
  62. #define DEV 0x07 /* Register: Logical device select */
  63. #define DEVID 0x20 /* Register: Device ID */
  64. #define ACT 0x30 /* Register: Device activation */
  65. #define BASE 0x60 /* Register: Base address */
  66. #define FSCM 0x09 /* Logical device: fans */
  67. #define VLM 0x0d /* Logical device: voltages */
  68. #define TMS 0x0e /* Logical device: temperatures */
  69. #define LDNI_MAX 3
  70. static const u8 logdev[LDNI_MAX] = { 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. * Device data
  157. */
  158. struct pc87360_data {
  159. const char *name;
  160. struct device *hwmon_dev;
  161. struct mutex lock;
  162. struct mutex update_lock;
  163. bool valid; /* true 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. * ldi is the logical device index
  191. * bank is for voltages and temperatures only
  192. */
  193. static int pc87360_read_value(struct pc87360_data *data, u8 ldi, u8 bank,
  194. u8 reg)
  195. {
  196. int res;
  197. mutex_lock(&(data->lock));
  198. if (bank != NO_BANK)
  199. outb_p(bank, data->address[ldi] + PC87365_REG_BANK);
  200. res = inb_p(data->address[ldi] + reg);
  201. mutex_unlock(&(data->lock));
  202. return res;
  203. }
  204. static void pc87360_write_value(struct pc87360_data *data, u8 ldi, u8 bank,
  205. u8 reg, u8 value)
  206. {
  207. mutex_lock(&(data->lock));
  208. if (bank != NO_BANK)
  209. outb_p(bank, data->address[ldi] + PC87365_REG_BANK);
  210. outb_p(value, data->address[ldi] + reg);
  211. mutex_unlock(&(data->lock));
  212. }
  213. static void pc87360_autodiv(struct device *dev, int nr)
  214. {
  215. struct pc87360_data *data = dev_get_drvdata(dev);
  216. u8 old_min = data->fan_min[nr];
  217. /* Increase clock divider if needed and possible */
  218. if ((data->fan_status[nr] & 0x04) /* overflow flag */
  219. || (data->fan[nr] >= 224)) { /* next to overflow */
  220. if ((data->fan_status[nr] & 0x60) != 0x60) {
  221. data->fan_status[nr] += 0x20;
  222. data->fan_min[nr] >>= 1;
  223. data->fan[nr] >>= 1;
  224. dev_dbg(dev,
  225. "Increasing clock divider to %d for fan %d\n",
  226. FAN_DIV_FROM_REG(data->fan_status[nr]), nr + 1);
  227. }
  228. } else {
  229. /* Decrease clock divider if possible */
  230. while (!(data->fan_min[nr] & 0x80) /* min "nails" divider */
  231. && data->fan[nr] < 85 /* bad accuracy */
  232. && (data->fan_status[nr] & 0x60) != 0x00) {
  233. data->fan_status[nr] -= 0x20;
  234. data->fan_min[nr] <<= 1;
  235. data->fan[nr] <<= 1;
  236. dev_dbg(dev,
  237. "Decreasing clock divider to %d for fan %d\n",
  238. FAN_DIV_FROM_REG(data->fan_status[nr]),
  239. nr + 1);
  240. }
  241. }
  242. /* Write new fan min if it changed */
  243. if (old_min != data->fan_min[nr]) {
  244. pc87360_write_value(data, LD_FAN, NO_BANK,
  245. PC87360_REG_FAN_MIN(nr),
  246. data->fan_min[nr]);
  247. }
  248. }
  249. static struct pc87360_data *pc87360_update_device(struct device *dev)
  250. {
  251. struct pc87360_data *data = dev_get_drvdata(dev);
  252. u8 i;
  253. mutex_lock(&data->update_lock);
  254. if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) {
  255. dev_dbg(dev, "Data update\n");
  256. /* Fans */
  257. for (i = 0; i < data->fannr; i++) {
  258. if (FAN_CONFIG_MONITOR(data->fan_conf, i)) {
  259. data->fan_status[i] =
  260. pc87360_read_value(data, LD_FAN,
  261. NO_BANK, PC87360_REG_FAN_STATUS(i));
  262. data->fan[i] = pc87360_read_value(data, LD_FAN,
  263. NO_BANK, PC87360_REG_FAN(i));
  264. data->fan_min[i] = pc87360_read_value(data,
  265. LD_FAN, NO_BANK,
  266. PC87360_REG_FAN_MIN(i));
  267. /* Change clock divider if needed */
  268. pc87360_autodiv(dev, i);
  269. /* Clear bits and write new divider */
  270. pc87360_write_value(data, LD_FAN, NO_BANK,
  271. PC87360_REG_FAN_STATUS(i),
  272. data->fan_status[i]);
  273. }
  274. if (FAN_CONFIG_CONTROL(data->fan_conf, i))
  275. data->pwm[i] = pc87360_read_value(data, LD_FAN,
  276. NO_BANK, PC87360_REG_PWM(i));
  277. }
  278. /* Voltages */
  279. for (i = 0; i < data->innr; i++) {
  280. data->in_status[i] = pc87360_read_value(data, LD_IN, i,
  281. PC87365_REG_IN_STATUS);
  282. /* Clear bits */
  283. pc87360_write_value(data, LD_IN, i,
  284. PC87365_REG_IN_STATUS,
  285. data->in_status[i]);
  286. if ((data->in_status[i] & CHAN_READY) == CHAN_READY) {
  287. data->in[i] = pc87360_read_value(data, LD_IN,
  288. i, PC87365_REG_IN);
  289. }
  290. if (data->in_status[i] & CHAN_ENA) {
  291. data->in_min[i] = pc87360_read_value(data,
  292. LD_IN, i,
  293. PC87365_REG_IN_MIN);
  294. data->in_max[i] = pc87360_read_value(data,
  295. LD_IN, i,
  296. PC87365_REG_IN_MAX);
  297. if (i >= 11)
  298. data->in_crit[i-11] =
  299. pc87360_read_value(data, LD_IN,
  300. i, PC87365_REG_TEMP_CRIT);
  301. }
  302. }
  303. if (data->innr) {
  304. data->in_alarms = pc87360_read_value(data, LD_IN,
  305. NO_BANK, PC87365_REG_IN_ALARMS1)
  306. | ((pc87360_read_value(data, LD_IN,
  307. NO_BANK, PC87365_REG_IN_ALARMS2)
  308. & 0x07) << 8);
  309. data->vid = (data->vid_conf & 0xE0) ?
  310. pc87360_read_value(data, LD_IN,
  311. NO_BANK, PC87365_REG_VID) : 0x1F;
  312. }
  313. /* Temperatures */
  314. for (i = 0; i < data->tempnr; i++) {
  315. data->temp_status[i] = pc87360_read_value(data,
  316. LD_TEMP, i,
  317. PC87365_REG_TEMP_STATUS);
  318. /* Clear bits */
  319. pc87360_write_value(data, LD_TEMP, i,
  320. PC87365_REG_TEMP_STATUS,
  321. data->temp_status[i]);
  322. if ((data->temp_status[i] & CHAN_READY) == CHAN_READY) {
  323. data->temp[i] = pc87360_read_value(data,
  324. LD_TEMP, i,
  325. PC87365_REG_TEMP);
  326. }
  327. if (data->temp_status[i] & CHAN_ENA) {
  328. data->temp_min[i] = pc87360_read_value(data,
  329. LD_TEMP, i,
  330. PC87365_REG_TEMP_MIN);
  331. data->temp_max[i] = pc87360_read_value(data,
  332. LD_TEMP, i,
  333. PC87365_REG_TEMP_MAX);
  334. data->temp_crit[i] = pc87360_read_value(data,
  335. LD_TEMP, i,
  336. PC87365_REG_TEMP_CRIT);
  337. }
  338. }
  339. if (data->tempnr) {
  340. data->temp_alarms = pc87360_read_value(data, LD_TEMP,
  341. NO_BANK, PC87365_REG_TEMP_ALARMS)
  342. & 0x3F;
  343. }
  344. data->last_updated = jiffies;
  345. data->valid = true;
  346. }
  347. mutex_unlock(&data->update_lock);
  348. return data;
  349. }
  350. static ssize_t in_input_show(struct device *dev,
  351. struct device_attribute *devattr, char *buf)
  352. {
  353. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  354. struct pc87360_data *data = pc87360_update_device(dev);
  355. return sprintf(buf, "%u\n", IN_FROM_REG(data->in[attr->index],
  356. data->in_vref));
  357. }
  358. static struct sensor_device_attribute in_input[] = {
  359. SENSOR_ATTR_RO(in0_input, in_input, 0),
  360. SENSOR_ATTR_RO(in1_input, in_input, 1),
  361. SENSOR_ATTR_RO(in2_input, in_input, 2),
  362. SENSOR_ATTR_RO(in3_input, in_input, 3),
  363. SENSOR_ATTR_RO(in4_input, in_input, 4),
  364. SENSOR_ATTR_RO(in5_input, in_input, 5),
  365. SENSOR_ATTR_RO(in6_input, in_input, 6),
  366. SENSOR_ATTR_RO(in7_input, in_input, 7),
  367. SENSOR_ATTR_RO(in8_input, in_input, 8),
  368. SENSOR_ATTR_RO(in9_input, in_input, 9),
  369. SENSOR_ATTR_RO(in10_input, in_input, 10),
  370. };
  371. static ssize_t in_status_show(struct device *dev,
  372. struct device_attribute *devattr, char *buf)
  373. {
  374. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  375. struct pc87360_data *data = pc87360_update_device(dev);
  376. return sprintf(buf, "%u\n", data->in_status[attr->index]);
  377. }
  378. static struct sensor_device_attribute in_status[] = {
  379. SENSOR_ATTR_RO(in0_status, in_status, 0),
  380. SENSOR_ATTR_RO(in1_status, in_status, 1),
  381. SENSOR_ATTR_RO(in2_status, in_status, 2),
  382. SENSOR_ATTR_RO(in3_status, in_status, 3),
  383. SENSOR_ATTR_RO(in4_status, in_status, 4),
  384. SENSOR_ATTR_RO(in5_status, in_status, 5),
  385. SENSOR_ATTR_RO(in6_status, in_status, 6),
  386. SENSOR_ATTR_RO(in7_status, in_status, 7),
  387. SENSOR_ATTR_RO(in8_status, in_status, 8),
  388. SENSOR_ATTR_RO(in9_status, in_status, 9),
  389. SENSOR_ATTR_RO(in10_status, in_status, 10),
  390. };
  391. static ssize_t in_min_show(struct device *dev,
  392. struct device_attribute *devattr, char *buf)
  393. {
  394. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  395. struct pc87360_data *data = pc87360_update_device(dev);
  396. return sprintf(buf, "%u\n", IN_FROM_REG(data->in_min[attr->index],
  397. data->in_vref));
  398. }
  399. static ssize_t in_min_store(struct device *dev,
  400. struct device_attribute *devattr, const char *buf,
  401. size_t count)
  402. {
  403. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  404. struct pc87360_data *data = dev_get_drvdata(dev);
  405. long val;
  406. int err;
  407. err = kstrtol(buf, 10, &val);
  408. if (err)
  409. return err;
  410. mutex_lock(&data->update_lock);
  411. data->in_min[attr->index] = IN_TO_REG(val, data->in_vref);
  412. pc87360_write_value(data, LD_IN, attr->index, PC87365_REG_IN_MIN,
  413. data->in_min[attr->index]);
  414. mutex_unlock(&data->update_lock);
  415. return count;
  416. }
  417. static struct sensor_device_attribute in_min[] = {
  418. SENSOR_ATTR_RW(in0_min, in_min, 0),
  419. SENSOR_ATTR_RW(in1_min, in_min, 1),
  420. SENSOR_ATTR_RW(in2_min, in_min, 2),
  421. SENSOR_ATTR_RW(in3_min, in_min, 3),
  422. SENSOR_ATTR_RW(in4_min, in_min, 4),
  423. SENSOR_ATTR_RW(in5_min, in_min, 5),
  424. SENSOR_ATTR_RW(in6_min, in_min, 6),
  425. SENSOR_ATTR_RW(in7_min, in_min, 7),
  426. SENSOR_ATTR_RW(in8_min, in_min, 8),
  427. SENSOR_ATTR_RW(in9_min, in_min, 9),
  428. SENSOR_ATTR_RW(in10_min, in_min, 10),
  429. };
  430. static ssize_t in_max_show(struct device *dev,
  431. struct device_attribute *devattr, char *buf)
  432. {
  433. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  434. struct pc87360_data *data = pc87360_update_device(dev);
  435. return sprintf(buf, "%u\n", IN_FROM_REG(data->in_max[attr->index],
  436. data->in_vref));
  437. }
  438. static ssize_t in_max_store(struct device *dev,
  439. struct device_attribute *devattr, const char *buf,
  440. size_t count)
  441. {
  442. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  443. struct pc87360_data *data = dev_get_drvdata(dev);
  444. long val;
  445. int err;
  446. err = kstrtol(buf, 10, &val);
  447. if (err)
  448. return err;
  449. mutex_lock(&data->update_lock);
  450. data->in_max[attr->index] = IN_TO_REG(val,
  451. data->in_vref);
  452. pc87360_write_value(data, LD_IN, attr->index, PC87365_REG_IN_MAX,
  453. data->in_max[attr->index]);
  454. mutex_unlock(&data->update_lock);
  455. return count;
  456. }
  457. static struct sensor_device_attribute in_max[] = {
  458. SENSOR_ATTR_RW(in0_max, in_max, 0),
  459. SENSOR_ATTR_RW(in1_max, in_max, 1),
  460. SENSOR_ATTR_RW(in2_max, in_max, 2),
  461. SENSOR_ATTR_RW(in3_max, in_max, 3),
  462. SENSOR_ATTR_RW(in4_max, in_max, 4),
  463. SENSOR_ATTR_RW(in5_max, in_max, 5),
  464. SENSOR_ATTR_RW(in6_max, in_max, 6),
  465. SENSOR_ATTR_RW(in7_max, in_max, 7),
  466. SENSOR_ATTR_RW(in8_max, in_max, 8),
  467. SENSOR_ATTR_RW(in9_max, in_max, 9),
  468. SENSOR_ATTR_RW(in10_max, in_max, 10),
  469. };
  470. /* (temp & vin) channel status register alarm bits (pdf sec.11.5.12) */
  471. #define CHAN_ALM_MIN 0x02 /* min limit crossed */
  472. #define CHAN_ALM_MAX 0x04 /* max limit exceeded */
  473. #define TEMP_ALM_CRIT 0x08 /* temp crit exceeded (temp only) */
  474. /*
  475. * show_in_min/max_alarm() reads data from the per-channel status
  476. * register (sec 11.5.12), not the vin event status registers (sec
  477. * 11.5.2) that (legacy) show_in_alarm() resds (via data->in_alarms)
  478. */
  479. static ssize_t in_min_alarm_show(struct device *dev,
  480. struct device_attribute *devattr, char *buf)
  481. {
  482. struct pc87360_data *data = pc87360_update_device(dev);
  483. unsigned nr = to_sensor_dev_attr(devattr)->index;
  484. return sprintf(buf, "%u\n", !!(data->in_status[nr] & CHAN_ALM_MIN));
  485. }
  486. static struct sensor_device_attribute in_min_alarm[] = {
  487. SENSOR_ATTR_RO(in0_min_alarm, in_min_alarm, 0),
  488. SENSOR_ATTR_RO(in1_min_alarm, in_min_alarm, 1),
  489. SENSOR_ATTR_RO(in2_min_alarm, in_min_alarm, 2),
  490. SENSOR_ATTR_RO(in3_min_alarm, in_min_alarm, 3),
  491. SENSOR_ATTR_RO(in4_min_alarm, in_min_alarm, 4),
  492. SENSOR_ATTR_RO(in5_min_alarm, in_min_alarm, 5),
  493. SENSOR_ATTR_RO(in6_min_alarm, in_min_alarm, 6),
  494. SENSOR_ATTR_RO(in7_min_alarm, in_min_alarm, 7),
  495. SENSOR_ATTR_RO(in8_min_alarm, in_min_alarm, 8),
  496. SENSOR_ATTR_RO(in9_min_alarm, in_min_alarm, 9),
  497. SENSOR_ATTR_RO(in10_min_alarm, in_min_alarm, 10),
  498. };
  499. static ssize_t in_max_alarm_show(struct device *dev,
  500. struct device_attribute *devattr, char *buf)
  501. {
  502. struct pc87360_data *data = pc87360_update_device(dev);
  503. unsigned nr = to_sensor_dev_attr(devattr)->index;
  504. return sprintf(buf, "%u\n", !!(data->in_status[nr] & CHAN_ALM_MAX));
  505. }
  506. static struct sensor_device_attribute in_max_alarm[] = {
  507. SENSOR_ATTR_RO(in0_max_alarm, in_max_alarm, 0),
  508. SENSOR_ATTR_RO(in1_max_alarm, in_max_alarm, 1),
  509. SENSOR_ATTR_RO(in2_max_alarm, in_max_alarm, 2),
  510. SENSOR_ATTR_RO(in3_max_alarm, in_max_alarm, 3),
  511. SENSOR_ATTR_RO(in4_max_alarm, in_max_alarm, 4),
  512. SENSOR_ATTR_RO(in5_max_alarm, in_max_alarm, 5),
  513. SENSOR_ATTR_RO(in6_max_alarm, in_max_alarm, 6),
  514. SENSOR_ATTR_RO(in7_max_alarm, in_max_alarm, 7),
  515. SENSOR_ATTR_RO(in8_max_alarm, in_max_alarm, 8),
  516. SENSOR_ATTR_RO(in9_max_alarm, in_max_alarm, 9),
  517. SENSOR_ATTR_RO(in10_max_alarm, in_max_alarm, 10),
  518. };
  519. #define VIN_UNIT_ATTRS(X) \
  520. &in_input[X].dev_attr.attr, \
  521. &in_status[X].dev_attr.attr, \
  522. &in_min[X].dev_attr.attr, \
  523. &in_max[X].dev_attr.attr, \
  524. &in_min_alarm[X].dev_attr.attr, \
  525. &in_max_alarm[X].dev_attr.attr
  526. static ssize_t cpu0_vid_show(struct device *dev,
  527. struct device_attribute *attr, char *buf)
  528. {
  529. struct pc87360_data *data = pc87360_update_device(dev);
  530. return sprintf(buf, "%u\n", vid_from_reg(data->vid, data->vrm));
  531. }
  532. static DEVICE_ATTR_RO(cpu0_vid);
  533. static ssize_t vrm_show(struct device *dev, struct device_attribute *attr,
  534. char *buf)
  535. {
  536. struct pc87360_data *data = dev_get_drvdata(dev);
  537. return sprintf(buf, "%u\n", data->vrm);
  538. }
  539. static ssize_t vrm_store(struct device *dev, struct device_attribute *attr,
  540. const char *buf, size_t count)
  541. {
  542. struct pc87360_data *data = dev_get_drvdata(dev);
  543. unsigned long val;
  544. int err;
  545. err = kstrtoul(buf, 10, &val);
  546. if (err)
  547. return err;
  548. if (val > 255)
  549. return -EINVAL;
  550. data->vrm = val;
  551. return count;
  552. }
  553. static DEVICE_ATTR_RW(vrm);
  554. static ssize_t alarms_in_show(struct device *dev,
  555. struct device_attribute *attr, char *buf)
  556. {
  557. struct pc87360_data *data = pc87360_update_device(dev);
  558. return sprintf(buf, "%u\n", data->in_alarms);
  559. }
  560. static DEVICE_ATTR_RO(alarms_in);
  561. static struct attribute *pc8736x_vin_attr_array[] = {
  562. VIN_UNIT_ATTRS(0),
  563. VIN_UNIT_ATTRS(1),
  564. VIN_UNIT_ATTRS(2),
  565. VIN_UNIT_ATTRS(3),
  566. VIN_UNIT_ATTRS(4),
  567. VIN_UNIT_ATTRS(5),
  568. VIN_UNIT_ATTRS(6),
  569. VIN_UNIT_ATTRS(7),
  570. VIN_UNIT_ATTRS(8),
  571. VIN_UNIT_ATTRS(9),
  572. VIN_UNIT_ATTRS(10),
  573. &dev_attr_cpu0_vid.attr,
  574. &dev_attr_vrm.attr,
  575. &dev_attr_alarms_in.attr,
  576. NULL
  577. };
  578. static const struct attribute_group pc8736x_vin_group = {
  579. .attrs = pc8736x_vin_attr_array,
  580. };
  581. static ssize_t therm_input_show(struct device *dev,
  582. struct device_attribute *devattr, char *buf)
  583. {
  584. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  585. struct pc87360_data *data = pc87360_update_device(dev);
  586. return sprintf(buf, "%u\n", IN_FROM_REG(data->in[attr->index],
  587. data->in_vref));
  588. }
  589. /*
  590. * the +11 term below reflects the fact that VLM units 11,12,13 are
  591. * used in the chip to measure voltage across the thermistors
  592. */
  593. static struct sensor_device_attribute therm_input[] = {
  594. SENSOR_ATTR_RO(temp4_input, therm_input, 0 + 11),
  595. SENSOR_ATTR_RO(temp5_input, therm_input, 1 + 11),
  596. SENSOR_ATTR_RO(temp6_input, therm_input, 2 + 11),
  597. };
  598. static ssize_t therm_status_show(struct device *dev,
  599. struct device_attribute *devattr, char *buf)
  600. {
  601. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  602. struct pc87360_data *data = pc87360_update_device(dev);
  603. return sprintf(buf, "%u\n", data->in_status[attr->index]);
  604. }
  605. static struct sensor_device_attribute therm_status[] = {
  606. SENSOR_ATTR_RO(temp4_status, therm_status, 0 + 11),
  607. SENSOR_ATTR_RO(temp5_status, therm_status, 1 + 11),
  608. SENSOR_ATTR_RO(temp6_status, therm_status, 2 + 11),
  609. };
  610. static ssize_t therm_min_show(struct device *dev,
  611. struct device_attribute *devattr, char *buf)
  612. {
  613. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  614. struct pc87360_data *data = pc87360_update_device(dev);
  615. return sprintf(buf, "%u\n", IN_FROM_REG(data->in_min[attr->index],
  616. data->in_vref));
  617. }
  618. static ssize_t therm_min_store(struct device *dev,
  619. struct device_attribute *devattr,
  620. const char *buf, size_t count)
  621. {
  622. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  623. struct pc87360_data *data = dev_get_drvdata(dev);
  624. long val;
  625. int err;
  626. err = kstrtol(buf, 10, &val);
  627. if (err)
  628. return err;
  629. mutex_lock(&data->update_lock);
  630. data->in_min[attr->index] = IN_TO_REG(val, data->in_vref);
  631. pc87360_write_value(data, LD_IN, attr->index, PC87365_REG_TEMP_MIN,
  632. data->in_min[attr->index]);
  633. mutex_unlock(&data->update_lock);
  634. return count;
  635. }
  636. static struct sensor_device_attribute therm_min[] = {
  637. SENSOR_ATTR_RW(temp4_min, therm_min, 0 + 11),
  638. SENSOR_ATTR_RW(temp5_min, therm_min, 1 + 11),
  639. SENSOR_ATTR_RW(temp6_min, therm_min, 2 + 11),
  640. };
  641. static ssize_t therm_max_show(struct device *dev,
  642. struct device_attribute *devattr, char *buf)
  643. {
  644. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  645. struct pc87360_data *data = pc87360_update_device(dev);
  646. return sprintf(buf, "%u\n", IN_FROM_REG(data->in_max[attr->index],
  647. data->in_vref));
  648. }
  649. static ssize_t therm_max_store(struct device *dev,
  650. struct device_attribute *devattr,
  651. const char *buf, size_t count)
  652. {
  653. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  654. struct pc87360_data *data = dev_get_drvdata(dev);
  655. long val;
  656. int err;
  657. err = kstrtol(buf, 10, &val);
  658. if (err)
  659. return err;
  660. mutex_lock(&data->update_lock);
  661. data->in_max[attr->index] = IN_TO_REG(val, data->in_vref);
  662. pc87360_write_value(data, LD_IN, attr->index, PC87365_REG_TEMP_MAX,
  663. data->in_max[attr->index]);
  664. mutex_unlock(&data->update_lock);
  665. return count;
  666. }
  667. static struct sensor_device_attribute therm_max[] = {
  668. SENSOR_ATTR_RW(temp4_max, therm_max, 0 + 11),
  669. SENSOR_ATTR_RW(temp5_max, therm_max, 1 + 11),
  670. SENSOR_ATTR_RW(temp6_max, therm_max, 2 + 11),
  671. };
  672. static ssize_t therm_crit_show(struct device *dev,
  673. struct device_attribute *devattr, char *buf)
  674. {
  675. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  676. struct pc87360_data *data = pc87360_update_device(dev);
  677. return sprintf(buf, "%u\n", IN_FROM_REG(data->in_crit[attr->index-11],
  678. data->in_vref));
  679. }
  680. static ssize_t therm_crit_store(struct device *dev,
  681. struct device_attribute *devattr,
  682. const char *buf, size_t count)
  683. {
  684. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  685. struct pc87360_data *data = dev_get_drvdata(dev);
  686. long val;
  687. int err;
  688. err = kstrtol(buf, 10, &val);
  689. if (err)
  690. return err;
  691. mutex_lock(&data->update_lock);
  692. data->in_crit[attr->index-11] = IN_TO_REG(val, data->in_vref);
  693. pc87360_write_value(data, LD_IN, attr->index, PC87365_REG_TEMP_CRIT,
  694. data->in_crit[attr->index-11]);
  695. mutex_unlock(&data->update_lock);
  696. return count;
  697. }
  698. static struct sensor_device_attribute therm_crit[] = {
  699. SENSOR_ATTR_RW(temp4_crit, therm_crit, 0 + 11),
  700. SENSOR_ATTR_RW(temp5_crit, therm_crit, 1 + 11),
  701. SENSOR_ATTR_RW(temp6_crit, therm_crit, 2 + 11),
  702. };
  703. /*
  704. * show_therm_min/max_alarm() reads data from the per-channel voltage
  705. * status register (sec 11.5.12)
  706. */
  707. static ssize_t therm_min_alarm_show(struct device *dev,
  708. struct device_attribute *devattr,
  709. char *buf)
  710. {
  711. struct pc87360_data *data = pc87360_update_device(dev);
  712. unsigned nr = to_sensor_dev_attr(devattr)->index;
  713. return sprintf(buf, "%u\n", !!(data->in_status[nr] & CHAN_ALM_MIN));
  714. }
  715. static struct sensor_device_attribute therm_min_alarm[] = {
  716. SENSOR_ATTR_RO(temp4_min_alarm, therm_min_alarm, 0 + 11),
  717. SENSOR_ATTR_RO(temp5_min_alarm, therm_min_alarm, 1 + 11),
  718. SENSOR_ATTR_RO(temp6_min_alarm, therm_min_alarm, 2 + 11),
  719. };
  720. static ssize_t therm_max_alarm_show(struct device *dev,
  721. struct device_attribute *devattr,
  722. char *buf)
  723. {
  724. struct pc87360_data *data = pc87360_update_device(dev);
  725. unsigned nr = to_sensor_dev_attr(devattr)->index;
  726. return sprintf(buf, "%u\n", !!(data->in_status[nr] & CHAN_ALM_MAX));
  727. }
  728. static struct sensor_device_attribute therm_max_alarm[] = {
  729. SENSOR_ATTR_RO(temp4_max_alarm, therm_max_alarm, 0 + 11),
  730. SENSOR_ATTR_RO(temp5_max_alarm, therm_max_alarm, 1 + 11),
  731. SENSOR_ATTR_RO(temp6_max_alarm, therm_max_alarm, 2 + 11),
  732. };
  733. static ssize_t therm_crit_alarm_show(struct device *dev,
  734. struct device_attribute *devattr,
  735. char *buf)
  736. {
  737. struct pc87360_data *data = pc87360_update_device(dev);
  738. unsigned nr = to_sensor_dev_attr(devattr)->index;
  739. return sprintf(buf, "%u\n", !!(data->in_status[nr] & TEMP_ALM_CRIT));
  740. }
  741. static struct sensor_device_attribute therm_crit_alarm[] = {
  742. SENSOR_ATTR_RO(temp4_crit_alarm, therm_crit_alarm, 0 + 11),
  743. SENSOR_ATTR_RO(temp5_crit_alarm, therm_crit_alarm, 1 + 11),
  744. SENSOR_ATTR_RO(temp6_crit_alarm, therm_crit_alarm, 2 + 11),
  745. };
  746. #define THERM_UNIT_ATTRS(X) \
  747. &therm_input[X].dev_attr.attr, \
  748. &therm_status[X].dev_attr.attr, \
  749. &therm_min[X].dev_attr.attr, \
  750. &therm_max[X].dev_attr.attr, \
  751. &therm_crit[X].dev_attr.attr, \
  752. &therm_min_alarm[X].dev_attr.attr, \
  753. &therm_max_alarm[X].dev_attr.attr, \
  754. &therm_crit_alarm[X].dev_attr.attr
  755. static struct attribute *pc8736x_therm_attr_array[] = {
  756. THERM_UNIT_ATTRS(0),
  757. THERM_UNIT_ATTRS(1),
  758. THERM_UNIT_ATTRS(2),
  759. NULL
  760. };
  761. static const struct attribute_group pc8736x_therm_group = {
  762. .attrs = pc8736x_therm_attr_array,
  763. };
  764. static ssize_t temp_input_show(struct device *dev,
  765. struct device_attribute *devattr, char *buf)
  766. {
  767. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  768. struct pc87360_data *data = pc87360_update_device(dev);
  769. return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[attr->index]));
  770. }
  771. static struct sensor_device_attribute temp_input[] = {
  772. SENSOR_ATTR_RO(temp1_input, temp_input, 0),
  773. SENSOR_ATTR_RO(temp2_input, temp_input, 1),
  774. SENSOR_ATTR_RO(temp3_input, temp_input, 2),
  775. };
  776. static ssize_t temp_status_show(struct device *dev,
  777. struct device_attribute *devattr, char *buf)
  778. {
  779. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  780. struct pc87360_data *data = pc87360_update_device(dev);
  781. return sprintf(buf, "%d\n", data->temp_status[attr->index]);
  782. }
  783. static struct sensor_device_attribute temp_status[] = {
  784. SENSOR_ATTR_RO(temp1_status, temp_status, 0),
  785. SENSOR_ATTR_RO(temp2_status, temp_status, 1),
  786. SENSOR_ATTR_RO(temp3_status, temp_status, 2),
  787. };
  788. static ssize_t temp_min_show(struct device *dev,
  789. struct device_attribute *devattr, char *buf)
  790. {
  791. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  792. struct pc87360_data *data = pc87360_update_device(dev);
  793. return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[attr->index]));
  794. }
  795. static ssize_t temp_min_store(struct device *dev,
  796. struct device_attribute *devattr,
  797. const char *buf, size_t count)
  798. {
  799. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  800. struct pc87360_data *data = dev_get_drvdata(dev);
  801. long val;
  802. int err;
  803. err = kstrtol(buf, 10, &val);
  804. if (err)
  805. return err;
  806. mutex_lock(&data->update_lock);
  807. data->temp_min[attr->index] = TEMP_TO_REG(val);
  808. pc87360_write_value(data, LD_TEMP, attr->index, PC87365_REG_TEMP_MIN,
  809. data->temp_min[attr->index]);
  810. mutex_unlock(&data->update_lock);
  811. return count;
  812. }
  813. static struct sensor_device_attribute temp_min[] = {
  814. SENSOR_ATTR_RW(temp1_min, temp_min, 0),
  815. SENSOR_ATTR_RW(temp2_min, temp_min, 1),
  816. SENSOR_ATTR_RW(temp3_min, temp_min, 2),
  817. };
  818. static ssize_t temp_max_show(struct device *dev,
  819. struct device_attribute *devattr, char *buf)
  820. {
  821. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  822. struct pc87360_data *data = pc87360_update_device(dev);
  823. return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[attr->index]));
  824. }
  825. static ssize_t temp_max_store(struct device *dev,
  826. struct device_attribute *devattr,
  827. const char *buf, size_t count)
  828. {
  829. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  830. struct pc87360_data *data = dev_get_drvdata(dev);
  831. long val;
  832. int err;
  833. err = kstrtol(buf, 10, &val);
  834. if (err)
  835. return err;
  836. mutex_lock(&data->update_lock);
  837. data->temp_max[attr->index] = TEMP_TO_REG(val);
  838. pc87360_write_value(data, LD_TEMP, attr->index, PC87365_REG_TEMP_MAX,
  839. data->temp_max[attr->index]);
  840. mutex_unlock(&data->update_lock);
  841. return count;
  842. }
  843. static struct sensor_device_attribute temp_max[] = {
  844. SENSOR_ATTR_RW(temp1_max, temp_max, 0),
  845. SENSOR_ATTR_RW(temp2_max, temp_max, 1),
  846. SENSOR_ATTR_RW(temp3_max, temp_max, 2),
  847. };
  848. static ssize_t temp_crit_show(struct device *dev,
  849. struct device_attribute *devattr, char *buf)
  850. {
  851. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  852. struct pc87360_data *data = pc87360_update_device(dev);
  853. return sprintf(buf, "%d\n",
  854. TEMP_FROM_REG(data->temp_crit[attr->index]));
  855. }
  856. static ssize_t temp_crit_store(struct device *dev,
  857. struct device_attribute *devattr,
  858. const char *buf, size_t count)
  859. {
  860. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  861. struct pc87360_data *data = dev_get_drvdata(dev);
  862. long val;
  863. int err;
  864. err = kstrtol(buf, 10, &val);
  865. if (err)
  866. return err;
  867. mutex_lock(&data->update_lock);
  868. data->temp_crit[attr->index] = TEMP_TO_REG(val);
  869. pc87360_write_value(data, LD_TEMP, attr->index, PC87365_REG_TEMP_CRIT,
  870. data->temp_crit[attr->index]);
  871. mutex_unlock(&data->update_lock);
  872. return count;
  873. }
  874. static struct sensor_device_attribute temp_crit[] = {
  875. SENSOR_ATTR_RW(temp1_crit, temp_crit, 0),
  876. SENSOR_ATTR_RW(temp2_crit, temp_crit, 1),
  877. SENSOR_ATTR_RW(temp3_crit, temp_crit, 2),
  878. };
  879. /*
  880. * temp_min/max_alarm_show() reads data from the per-channel status
  881. * register (sec 12.3.7), not the temp event status registers (sec
  882. * 12.3.2) that show_temp_alarm() reads (via data->temp_alarms)
  883. */
  884. static ssize_t temp_min_alarm_show(struct device *dev,
  885. struct device_attribute *devattr,
  886. char *buf)
  887. {
  888. struct pc87360_data *data = pc87360_update_device(dev);
  889. unsigned nr = to_sensor_dev_attr(devattr)->index;
  890. return sprintf(buf, "%u\n", !!(data->temp_status[nr] & CHAN_ALM_MIN));
  891. }
  892. static struct sensor_device_attribute temp_min_alarm[] = {
  893. SENSOR_ATTR_RO(temp1_min_alarm, temp_min_alarm, 0),
  894. SENSOR_ATTR_RO(temp2_min_alarm, temp_min_alarm, 1),
  895. SENSOR_ATTR_RO(temp3_min_alarm, temp_min_alarm, 2),
  896. };
  897. static ssize_t temp_max_alarm_show(struct device *dev,
  898. struct device_attribute *devattr,
  899. char *buf)
  900. {
  901. struct pc87360_data *data = pc87360_update_device(dev);
  902. unsigned nr = to_sensor_dev_attr(devattr)->index;
  903. return sprintf(buf, "%u\n", !!(data->temp_status[nr] & CHAN_ALM_MAX));
  904. }
  905. static struct sensor_device_attribute temp_max_alarm[] = {
  906. SENSOR_ATTR_RO(temp1_max_alarm, temp_max_alarm, 0),
  907. SENSOR_ATTR_RO(temp2_max_alarm, temp_max_alarm, 1),
  908. SENSOR_ATTR_RO(temp3_max_alarm, temp_max_alarm, 2),
  909. };
  910. static ssize_t temp_crit_alarm_show(struct device *dev,
  911. struct device_attribute *devattr,
  912. char *buf)
  913. {
  914. struct pc87360_data *data = pc87360_update_device(dev);
  915. unsigned nr = to_sensor_dev_attr(devattr)->index;
  916. return sprintf(buf, "%u\n", !!(data->temp_status[nr] & TEMP_ALM_CRIT));
  917. }
  918. static struct sensor_device_attribute temp_crit_alarm[] = {
  919. SENSOR_ATTR_RO(temp1_crit_alarm, temp_crit_alarm, 0),
  920. SENSOR_ATTR_RO(temp2_crit_alarm, temp_crit_alarm, 1),
  921. SENSOR_ATTR_RO(temp3_crit_alarm, temp_crit_alarm, 2),
  922. };
  923. #define TEMP_FAULT 0x40 /* open diode */
  924. static ssize_t temp_fault_show(struct device *dev,
  925. struct device_attribute *devattr, char *buf)
  926. {
  927. struct pc87360_data *data = pc87360_update_device(dev);
  928. unsigned nr = to_sensor_dev_attr(devattr)->index;
  929. return sprintf(buf, "%u\n", !!(data->temp_status[nr] & TEMP_FAULT));
  930. }
  931. static struct sensor_device_attribute temp_fault[] = {
  932. SENSOR_ATTR_RO(temp1_fault, temp_fault, 0),
  933. SENSOR_ATTR_RO(temp2_fault, temp_fault, 1),
  934. SENSOR_ATTR_RO(temp3_fault, temp_fault, 2),
  935. };
  936. #define TEMP_UNIT_ATTRS(X) \
  937. { &temp_input[X].dev_attr.attr, \
  938. &temp_status[X].dev_attr.attr, \
  939. &temp_min[X].dev_attr.attr, \
  940. &temp_max[X].dev_attr.attr, \
  941. &temp_crit[X].dev_attr.attr, \
  942. &temp_min_alarm[X].dev_attr.attr, \
  943. &temp_max_alarm[X].dev_attr.attr, \
  944. &temp_crit_alarm[X].dev_attr.attr, \
  945. &temp_fault[X].dev_attr.attr, \
  946. NULL \
  947. }
  948. static struct attribute *pc8736x_temp_attr[][10] = {
  949. TEMP_UNIT_ATTRS(0),
  950. TEMP_UNIT_ATTRS(1),
  951. TEMP_UNIT_ATTRS(2)
  952. };
  953. static const struct attribute_group pc8736x_temp_attr_group[] = {
  954. { .attrs = pc8736x_temp_attr[0] },
  955. { .attrs = pc8736x_temp_attr[1] },
  956. { .attrs = pc8736x_temp_attr[2] }
  957. };
  958. static ssize_t alarms_temp_show(struct device *dev,
  959. struct device_attribute *attr, char *buf)
  960. {
  961. struct pc87360_data *data = pc87360_update_device(dev);
  962. return sprintf(buf, "%u\n", data->temp_alarms);
  963. }
  964. static DEVICE_ATTR_RO(alarms_temp);
  965. static ssize_t fan_input_show(struct device *dev,
  966. struct device_attribute *devattr, char *buf)
  967. {
  968. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  969. struct pc87360_data *data = pc87360_update_device(dev);
  970. return sprintf(buf, "%u\n", FAN_FROM_REG(data->fan[attr->index],
  971. FAN_DIV_FROM_REG(data->fan_status[attr->index])));
  972. }
  973. static struct sensor_device_attribute fan_input[] = {
  974. SENSOR_ATTR_RO(fan1_input, fan_input, 0),
  975. SENSOR_ATTR_RO(fan2_input, fan_input, 1),
  976. SENSOR_ATTR_RO(fan3_input, fan_input, 2),
  977. };
  978. static ssize_t fan_status_show(struct device *dev,
  979. struct device_attribute *devattr, char *buf)
  980. {
  981. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  982. struct pc87360_data *data = pc87360_update_device(dev);
  983. return sprintf(buf, "%u\n",
  984. FAN_STATUS_FROM_REG(data->fan_status[attr->index]));
  985. }
  986. static struct sensor_device_attribute fan_status[] = {
  987. SENSOR_ATTR_RO(fan1_status, fan_status, 0),
  988. SENSOR_ATTR_RO(fan2_status, fan_status, 1),
  989. SENSOR_ATTR_RO(fan3_status, fan_status, 2),
  990. };
  991. static ssize_t fan_div_show(struct device *dev,
  992. struct device_attribute *devattr, char *buf)
  993. {
  994. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  995. struct pc87360_data *data = pc87360_update_device(dev);
  996. return sprintf(buf, "%u\n",
  997. FAN_DIV_FROM_REG(data->fan_status[attr->index]));
  998. }
  999. static struct sensor_device_attribute fan_div[] = {
  1000. SENSOR_ATTR_RO(fan1_div, fan_div, 0),
  1001. SENSOR_ATTR_RO(fan2_div, fan_div, 1),
  1002. SENSOR_ATTR_RO(fan3_div, fan_div, 2),
  1003. };
  1004. static ssize_t fan_min_show(struct device *dev,
  1005. struct device_attribute *devattr, char *buf)
  1006. {
  1007. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1008. struct pc87360_data *data = pc87360_update_device(dev);
  1009. return sprintf(buf, "%u\n", FAN_FROM_REG(data->fan_min[attr->index],
  1010. FAN_DIV_FROM_REG(data->fan_status[attr->index])));
  1011. }
  1012. static ssize_t fan_min_store(struct device *dev,
  1013. struct device_attribute *devattr,
  1014. const char *buf, size_t count)
  1015. {
  1016. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1017. struct pc87360_data *data = dev_get_drvdata(dev);
  1018. long fan_min;
  1019. int err;
  1020. err = kstrtol(buf, 10, &fan_min);
  1021. if (err)
  1022. return err;
  1023. mutex_lock(&data->update_lock);
  1024. fan_min = FAN_TO_REG(fan_min,
  1025. FAN_DIV_FROM_REG(data->fan_status[attr->index]));
  1026. /* If it wouldn't fit, change clock divisor */
  1027. while (fan_min > 255
  1028. && (data->fan_status[attr->index] & 0x60) != 0x60) {
  1029. fan_min >>= 1;
  1030. data->fan[attr->index] >>= 1;
  1031. data->fan_status[attr->index] += 0x20;
  1032. }
  1033. data->fan_min[attr->index] = fan_min > 255 ? 255 : fan_min;
  1034. pc87360_write_value(data, LD_FAN, NO_BANK,
  1035. PC87360_REG_FAN_MIN(attr->index),
  1036. data->fan_min[attr->index]);
  1037. /* Write new divider, preserve alarm bits */
  1038. pc87360_write_value(data, LD_FAN, NO_BANK,
  1039. PC87360_REG_FAN_STATUS(attr->index),
  1040. data->fan_status[attr->index] & 0xF9);
  1041. mutex_unlock(&data->update_lock);
  1042. return count;
  1043. }
  1044. static struct sensor_device_attribute fan_min[] = {
  1045. SENSOR_ATTR_RW(fan1_min, fan_min, 0),
  1046. SENSOR_ATTR_RW(fan2_min, fan_min, 1),
  1047. SENSOR_ATTR_RW(fan3_min, fan_min, 2),
  1048. };
  1049. #define FAN_UNIT_ATTRS(X) \
  1050. { &fan_input[X].dev_attr.attr, \
  1051. &fan_status[X].dev_attr.attr, \
  1052. &fan_div[X].dev_attr.attr, \
  1053. &fan_min[X].dev_attr.attr, \
  1054. NULL \
  1055. }
  1056. static struct attribute *pc8736x_fan_attr[][5] = {
  1057. FAN_UNIT_ATTRS(0),
  1058. FAN_UNIT_ATTRS(1),
  1059. FAN_UNIT_ATTRS(2)
  1060. };
  1061. static const struct attribute_group pc8736x_fan_attr_group[] = {
  1062. { .attrs = pc8736x_fan_attr[0], },
  1063. { .attrs = pc8736x_fan_attr[1], },
  1064. { .attrs = pc8736x_fan_attr[2], },
  1065. };
  1066. static ssize_t pwm_show(struct device *dev, struct device_attribute *devattr,
  1067. char *buf)
  1068. {
  1069. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1070. struct pc87360_data *data = pc87360_update_device(dev);
  1071. return sprintf(buf, "%u\n",
  1072. PWM_FROM_REG(data->pwm[attr->index],
  1073. FAN_CONFIG_INVERT(data->fan_conf,
  1074. attr->index)));
  1075. }
  1076. static ssize_t pwm_store(struct device *dev, struct device_attribute *devattr,
  1077. const char *buf, size_t count)
  1078. {
  1079. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1080. struct pc87360_data *data = dev_get_drvdata(dev);
  1081. long val;
  1082. int err;
  1083. err = kstrtol(buf, 10, &val);
  1084. if (err)
  1085. return err;
  1086. mutex_lock(&data->update_lock);
  1087. data->pwm[attr->index] = PWM_TO_REG(val,
  1088. FAN_CONFIG_INVERT(data->fan_conf, attr->index));
  1089. pc87360_write_value(data, LD_FAN, NO_BANK, PC87360_REG_PWM(attr->index),
  1090. data->pwm[attr->index]);
  1091. mutex_unlock(&data->update_lock);
  1092. return count;
  1093. }
  1094. static struct sensor_device_attribute pwm[] = {
  1095. SENSOR_ATTR_RW(pwm1, pwm, 0),
  1096. SENSOR_ATTR_RW(pwm2, pwm, 1),
  1097. SENSOR_ATTR_RW(pwm3, pwm, 2),
  1098. };
  1099. static ssize_t name_show(struct device *dev,
  1100. struct device_attribute *devattr, char *buf)
  1101. {
  1102. struct pc87360_data *data = dev_get_drvdata(dev);
  1103. return sprintf(buf, "%s\n", data->name);
  1104. }
  1105. static DEVICE_ATTR_RO(name);
  1106. static void pc87360_remove_files(struct device *dev)
  1107. {
  1108. int i;
  1109. device_remove_file(dev, &dev_attr_name);
  1110. device_remove_file(dev, &dev_attr_alarms_temp);
  1111. for (i = 0; i < ARRAY_SIZE(pc8736x_temp_attr_group); i++)
  1112. sysfs_remove_group(&dev->kobj, &pc8736x_temp_attr_group[i]);
  1113. for (i = 0; i < ARRAY_SIZE(pc8736x_fan_attr_group); i++) {
  1114. sysfs_remove_group(&pdev->dev.kobj, &pc8736x_fan_attr_group[i]);
  1115. device_remove_file(dev, &pwm[i].dev_attr);
  1116. }
  1117. sysfs_remove_group(&dev->kobj, &pc8736x_therm_group);
  1118. sysfs_remove_group(&dev->kobj, &pc8736x_vin_group);
  1119. }
  1120. static void pc87360_init_device(struct platform_device *pdev,
  1121. int use_thermistors)
  1122. {
  1123. struct pc87360_data *data = platform_get_drvdata(pdev);
  1124. int i, nr;
  1125. const u8 init_in[14] = { 2, 2, 2, 2, 2, 2, 2, 1, 1, 3, 1, 2, 2, 2 };
  1126. const u8 init_temp[3] = { 2, 2, 1 };
  1127. u8 reg;
  1128. if (init >= 2 && data->innr) {
  1129. reg = pc87360_read_value(data, LD_IN, NO_BANK,
  1130. PC87365_REG_IN_CONVRATE);
  1131. dev_info(&pdev->dev,
  1132. "VLM conversion set to 1s period, 160us delay\n");
  1133. pc87360_write_value(data, LD_IN, NO_BANK,
  1134. PC87365_REG_IN_CONVRATE,
  1135. (reg & 0xC0) | 0x11);
  1136. }
  1137. nr = data->innr < 11 ? data->innr : 11;
  1138. for (i = 0; i < nr; i++) {
  1139. reg = pc87360_read_value(data, LD_IN, i,
  1140. PC87365_REG_IN_STATUS);
  1141. dev_dbg(&pdev->dev, "bios in%d status:0x%02x\n", i, reg);
  1142. if (init >= init_in[i]) {
  1143. /* Forcibly enable voltage channel */
  1144. if (!(reg & CHAN_ENA)) {
  1145. dev_dbg(&pdev->dev, "Forcibly enabling in%d\n",
  1146. i);
  1147. pc87360_write_value(data, LD_IN, i,
  1148. PC87365_REG_IN_STATUS,
  1149. (reg & 0x68) | 0x87);
  1150. }
  1151. }
  1152. }
  1153. /*
  1154. * We can't blindly trust the Super-I/O space configuration bit,
  1155. * most BIOS won't set it properly
  1156. */
  1157. dev_dbg(&pdev->dev, "bios thermistors:%d\n", use_thermistors);
  1158. for (i = 11; i < data->innr; i++) {
  1159. reg = pc87360_read_value(data, LD_IN, i,
  1160. PC87365_REG_TEMP_STATUS);
  1161. use_thermistors = use_thermistors || (reg & CHAN_ENA);
  1162. /* thermistors are temp[4-6], measured on vin[11-14] */
  1163. dev_dbg(&pdev->dev, "bios temp%d_status:0x%02x\n", i-7, reg);
  1164. }
  1165. dev_dbg(&pdev->dev, "using thermistors:%d\n", use_thermistors);
  1166. i = use_thermistors ? 2 : 0;
  1167. for (; i < data->tempnr; i++) {
  1168. reg = pc87360_read_value(data, LD_TEMP, i,
  1169. PC87365_REG_TEMP_STATUS);
  1170. dev_dbg(&pdev->dev, "bios temp%d_status:0x%02x\n", i + 1, reg);
  1171. if (init >= init_temp[i]) {
  1172. /* Forcibly enable temperature channel */
  1173. if (!(reg & CHAN_ENA)) {
  1174. dev_dbg(&pdev->dev,
  1175. "Forcibly enabling temp%d\n", i + 1);
  1176. pc87360_write_value(data, LD_TEMP, i,
  1177. PC87365_REG_TEMP_STATUS,
  1178. 0xCF);
  1179. }
  1180. }
  1181. }
  1182. if (use_thermistors) {
  1183. for (i = 11; i < data->innr; i++) {
  1184. if (init >= init_in[i]) {
  1185. /*
  1186. * The pin may already be used by thermal
  1187. * diodes
  1188. */
  1189. reg = pc87360_read_value(data, LD_TEMP,
  1190. (i - 11) / 2, PC87365_REG_TEMP_STATUS);
  1191. if (reg & CHAN_ENA) {
  1192. dev_dbg(&pdev->dev,
  1193. "Skipping temp%d, pin already in use by temp%d\n",
  1194. i - 7, (i - 11) / 2);
  1195. continue;
  1196. }
  1197. /* Forcibly enable thermistor channel */
  1198. reg = pc87360_read_value(data, LD_IN, i,
  1199. PC87365_REG_IN_STATUS);
  1200. if (!(reg & CHAN_ENA)) {
  1201. dev_dbg(&pdev->dev,
  1202. "Forcibly enabling temp%d\n",
  1203. i - 7);
  1204. pc87360_write_value(data, LD_IN, i,
  1205. PC87365_REG_TEMP_STATUS,
  1206. (reg & 0x60) | 0x8F);
  1207. }
  1208. }
  1209. }
  1210. }
  1211. if (data->innr) {
  1212. reg = pc87360_read_value(data, LD_IN, NO_BANK,
  1213. PC87365_REG_IN_CONFIG);
  1214. dev_dbg(&pdev->dev, "bios vin-cfg:0x%02x\n", reg);
  1215. if (reg & CHAN_ENA) {
  1216. dev_dbg(&pdev->dev,
  1217. "Forcibly enabling monitoring (VLM)\n");
  1218. pc87360_write_value(data, LD_IN, NO_BANK,
  1219. PC87365_REG_IN_CONFIG,
  1220. reg & 0xFE);
  1221. }
  1222. }
  1223. if (data->tempnr) {
  1224. reg = pc87360_read_value(data, LD_TEMP, NO_BANK,
  1225. PC87365_REG_TEMP_CONFIG);
  1226. dev_dbg(&pdev->dev, "bios temp-cfg:0x%02x\n", reg);
  1227. if (reg & CHAN_ENA) {
  1228. dev_dbg(&pdev->dev,
  1229. "Forcibly enabling monitoring (TMS)\n");
  1230. pc87360_write_value(data, LD_TEMP, NO_BANK,
  1231. PC87365_REG_TEMP_CONFIG,
  1232. reg & 0xFE);
  1233. }
  1234. if (init >= 2) {
  1235. /* Chip config as documented by National Semi. */
  1236. pc87360_write_value(data, LD_TEMP, 0xF, 0xA, 0x08);
  1237. /*
  1238. * We voluntarily omit the bank here, in case the
  1239. * sequence itself matters. It shouldn't be a problem,
  1240. * since nobody else is supposed to access the
  1241. * device at that point.
  1242. */
  1243. pc87360_write_value(data, LD_TEMP, NO_BANK, 0xB, 0x04);
  1244. pc87360_write_value(data, LD_TEMP, NO_BANK, 0xC, 0x35);
  1245. pc87360_write_value(data, LD_TEMP, NO_BANK, 0xD, 0x05);
  1246. pc87360_write_value(data, LD_TEMP, NO_BANK, 0xE, 0x05);
  1247. }
  1248. }
  1249. }
  1250. static int pc87360_probe(struct platform_device *pdev)
  1251. {
  1252. int i;
  1253. struct pc87360_data *data;
  1254. int err = 0;
  1255. const char *name;
  1256. int use_thermistors = 0;
  1257. struct device *dev = &pdev->dev;
  1258. data = devm_kzalloc(dev, sizeof(struct pc87360_data), GFP_KERNEL);
  1259. if (!data)
  1260. return -ENOMEM;
  1261. switch (devid) {
  1262. default:
  1263. name = "pc87360";
  1264. data->fannr = 2;
  1265. break;
  1266. case 0xe8:
  1267. name = "pc87363";
  1268. data->fannr = 2;
  1269. break;
  1270. case 0xe4:
  1271. name = "pc87364";
  1272. data->fannr = 3;
  1273. break;
  1274. case 0xe5:
  1275. name = "pc87365";
  1276. data->fannr = extra_isa[0] ? 3 : 0;
  1277. data->innr = extra_isa[1] ? 11 : 0;
  1278. data->tempnr = extra_isa[2] ? 2 : 0;
  1279. break;
  1280. case 0xe9:
  1281. name = "pc87366";
  1282. data->fannr = extra_isa[0] ? 3 : 0;
  1283. data->innr = extra_isa[1] ? 14 : 0;
  1284. data->tempnr = extra_isa[2] ? 3 : 0;
  1285. break;
  1286. }
  1287. data->name = name;
  1288. mutex_init(&data->lock);
  1289. mutex_init(&data->update_lock);
  1290. platform_set_drvdata(pdev, data);
  1291. for (i = 0; i < LDNI_MAX; i++) {
  1292. data->address[i] = extra_isa[i];
  1293. if (data->address[i]
  1294. && !devm_request_region(dev, extra_isa[i], PC87360_EXTENT,
  1295. DRIVER_NAME)) {
  1296. dev_err(dev,
  1297. "Region 0x%x-0x%x already in use!\n",
  1298. extra_isa[i], extra_isa[i]+PC87360_EXTENT-1);
  1299. return -EBUSY;
  1300. }
  1301. }
  1302. /* Retrieve the fans configuration from Super-I/O space */
  1303. if (data->fannr)
  1304. data->fan_conf = confreg[0] | (confreg[1] << 8);
  1305. /*
  1306. * Use the correct reference voltage
  1307. * Unless both the VLM and the TMS logical devices agree to
  1308. * use an external Vref, the internal one is used.
  1309. */
  1310. if (data->innr) {
  1311. i = pc87360_read_value(data, LD_IN, NO_BANK,
  1312. PC87365_REG_IN_CONFIG);
  1313. if (data->tempnr) {
  1314. i &= pc87360_read_value(data, LD_TEMP, NO_BANK,
  1315. PC87365_REG_TEMP_CONFIG);
  1316. }
  1317. data->in_vref = (i&0x02) ? 3025 : 2966;
  1318. dev_dbg(dev, "Using %s reference voltage\n",
  1319. (i&0x02) ? "external" : "internal");
  1320. data->vid_conf = confreg[3];
  1321. data->vrm = vid_which_vrm();
  1322. }
  1323. /* Fan clock dividers may be needed before any data is read */
  1324. for (i = 0; i < data->fannr; i++) {
  1325. if (FAN_CONFIG_MONITOR(data->fan_conf, i))
  1326. data->fan_status[i] = pc87360_read_value(data,
  1327. LD_FAN, NO_BANK,
  1328. PC87360_REG_FAN_STATUS(i));
  1329. }
  1330. if (init > 0) {
  1331. if (devid == 0xe9 && data->address[1]) /* PC87366 */
  1332. use_thermistors = confreg[2] & 0x40;
  1333. pc87360_init_device(pdev, use_thermistors);
  1334. }
  1335. /* Register all-or-nothing sysfs groups */
  1336. if (data->innr) {
  1337. err = sysfs_create_group(&dev->kobj, &pc8736x_vin_group);
  1338. if (err)
  1339. goto error;
  1340. }
  1341. if (data->innr == 14) {
  1342. err = sysfs_create_group(&dev->kobj, &pc8736x_therm_group);
  1343. if (err)
  1344. goto error;
  1345. }
  1346. /* create device attr-files for varying sysfs groups */
  1347. if (data->tempnr) {
  1348. for (i = 0; i < data->tempnr; i++) {
  1349. err = sysfs_create_group(&dev->kobj,
  1350. &pc8736x_temp_attr_group[i]);
  1351. if (err)
  1352. goto error;
  1353. }
  1354. err = device_create_file(dev, &dev_attr_alarms_temp);
  1355. if (err)
  1356. goto error;
  1357. }
  1358. for (i = 0; i < data->fannr; i++) {
  1359. if (FAN_CONFIG_MONITOR(data->fan_conf, i)) {
  1360. err = sysfs_create_group(&dev->kobj,
  1361. &pc8736x_fan_attr_group[i]);
  1362. if (err)
  1363. goto error;
  1364. }
  1365. if (FAN_CONFIG_CONTROL(data->fan_conf, i)) {
  1366. err = device_create_file(dev, &pwm[i].dev_attr);
  1367. if (err)
  1368. goto error;
  1369. }
  1370. }
  1371. err = device_create_file(dev, &dev_attr_name);
  1372. if (err)
  1373. goto error;
  1374. data->hwmon_dev = hwmon_device_register(dev);
  1375. if (IS_ERR(data->hwmon_dev)) {
  1376. err = PTR_ERR(data->hwmon_dev);
  1377. goto error;
  1378. }
  1379. return 0;
  1380. error:
  1381. pc87360_remove_files(dev);
  1382. return err;
  1383. }
  1384. static int pc87360_remove(struct platform_device *pdev)
  1385. {
  1386. struct pc87360_data *data = platform_get_drvdata(pdev);
  1387. hwmon_device_unregister(data->hwmon_dev);
  1388. pc87360_remove_files(&pdev->dev);
  1389. return 0;
  1390. }
  1391. /*
  1392. * Driver data
  1393. */
  1394. static struct platform_driver pc87360_driver = {
  1395. .driver = {
  1396. .name = DRIVER_NAME,
  1397. },
  1398. .probe = pc87360_probe,
  1399. .remove = pc87360_remove,
  1400. };
  1401. /*
  1402. * Device detection, registration and update
  1403. */
  1404. static int __init pc87360_find(int sioaddr, u8 *devid,
  1405. unsigned short *addresses)
  1406. {
  1407. u16 val;
  1408. int i;
  1409. int nrdev; /* logical device count */
  1410. /* No superio_enter */
  1411. /* Identify device */
  1412. val = force_id ? force_id : superio_inb(sioaddr, DEVID);
  1413. switch (val) {
  1414. case 0xE1: /* PC87360 */
  1415. case 0xE8: /* PC87363 */
  1416. case 0xE4: /* PC87364 */
  1417. nrdev = 1;
  1418. break;
  1419. case 0xE5: /* PC87365 */
  1420. case 0xE9: /* PC87366 */
  1421. nrdev = 3;
  1422. break;
  1423. default:
  1424. superio_exit(sioaddr);
  1425. return -ENODEV;
  1426. }
  1427. /* Remember the device id */
  1428. *devid = val;
  1429. for (i = 0; i < nrdev; i++) {
  1430. /* select logical device */
  1431. superio_outb(sioaddr, DEV, logdev[i]);
  1432. val = superio_inb(sioaddr, ACT);
  1433. if (!(val & 0x01)) {
  1434. pr_info("Device 0x%02x not activated\n", logdev[i]);
  1435. continue;
  1436. }
  1437. val = (superio_inb(sioaddr, BASE) << 8)
  1438. | superio_inb(sioaddr, BASE + 1);
  1439. if (!val) {
  1440. pr_info("Base address not set for device 0x%02x\n",
  1441. logdev[i]);
  1442. continue;
  1443. }
  1444. addresses[i] = val;
  1445. if (i == 0) { /* Fans */
  1446. confreg[0] = superio_inb(sioaddr, 0xF0);
  1447. confreg[1] = superio_inb(sioaddr, 0xF1);
  1448. pr_debug("Fan %d: mon=%d ctrl=%d inv=%d\n", 1,
  1449. (confreg[0] >> 2) & 1, (confreg[0] >> 3) & 1,
  1450. (confreg[0] >> 4) & 1);
  1451. pr_debug("Fan %d: mon=%d ctrl=%d inv=%d\n", 2,
  1452. (confreg[0] >> 5) & 1, (confreg[0] >> 6) & 1,
  1453. (confreg[0] >> 7) & 1);
  1454. pr_debug("Fan %d: mon=%d ctrl=%d inv=%d\n", 3,
  1455. confreg[1] & 1, (confreg[1] >> 1) & 1,
  1456. (confreg[1] >> 2) & 1);
  1457. } else if (i == 1) { /* Voltages */
  1458. /* Are we using thermistors? */
  1459. if (*devid == 0xE9) { /* PC87366 */
  1460. /*
  1461. * These registers are not logical-device
  1462. * specific, just that we won't need them if
  1463. * we don't use the VLM device
  1464. */
  1465. confreg[2] = superio_inb(sioaddr, 0x2B);
  1466. confreg[3] = superio_inb(sioaddr, 0x25);
  1467. if (confreg[2] & 0x40) {
  1468. pr_info("Using thermistors for temperature monitoring\n");
  1469. }
  1470. if (confreg[3] & 0xE0) {
  1471. pr_info("VID inputs routed (mode %u)\n",
  1472. confreg[3] >> 5);
  1473. }
  1474. }
  1475. }
  1476. }
  1477. superio_exit(sioaddr);
  1478. return 0;
  1479. }
  1480. static int __init pc87360_device_add(unsigned short address)
  1481. {
  1482. struct resource res[3];
  1483. int err, i, res_count;
  1484. pdev = platform_device_alloc("pc87360", address);
  1485. if (!pdev) {
  1486. err = -ENOMEM;
  1487. pr_err("Device allocation failed\n");
  1488. goto exit;
  1489. }
  1490. memset(res, 0, 3 * sizeof(struct resource));
  1491. res_count = 0;
  1492. for (i = 0; i < 3; i++) {
  1493. if (!extra_isa[i])
  1494. continue;
  1495. res[res_count].start = extra_isa[i];
  1496. res[res_count].end = extra_isa[i] + PC87360_EXTENT - 1;
  1497. res[res_count].name = "pc87360";
  1498. res[res_count].flags = IORESOURCE_IO;
  1499. err = acpi_check_resource_conflict(&res[res_count]);
  1500. if (err)
  1501. goto exit_device_put;
  1502. res_count++;
  1503. }
  1504. err = platform_device_add_resources(pdev, res, res_count);
  1505. if (err) {
  1506. pr_err("Device resources addition failed (%d)\n", err);
  1507. goto exit_device_put;
  1508. }
  1509. err = platform_device_add(pdev);
  1510. if (err) {
  1511. pr_err("Device addition failed (%d)\n", err);
  1512. goto exit_device_put;
  1513. }
  1514. return 0;
  1515. exit_device_put:
  1516. platform_device_put(pdev);
  1517. exit:
  1518. return err;
  1519. }
  1520. static int __init pc87360_init(void)
  1521. {
  1522. int err, i;
  1523. unsigned short address = 0;
  1524. if (pc87360_find(0x2e, &devid, extra_isa)
  1525. && pc87360_find(0x4e, &devid, extra_isa)) {
  1526. pr_warn("PC8736x not detected, module not inserted\n");
  1527. return -ENODEV;
  1528. }
  1529. /* Arbitrarily pick one of the addresses */
  1530. for (i = 0; i < 3; i++) {
  1531. if (extra_isa[i] != 0x0000) {
  1532. address = extra_isa[i];
  1533. break;
  1534. }
  1535. }
  1536. if (address == 0x0000) {
  1537. pr_warn("No active logical device, module not inserted\n");
  1538. return -ENODEV;
  1539. }
  1540. err = platform_driver_register(&pc87360_driver);
  1541. if (err)
  1542. goto exit;
  1543. /* Sets global pdev as a side effect */
  1544. err = pc87360_device_add(address);
  1545. if (err)
  1546. goto exit_driver;
  1547. return 0;
  1548. exit_driver:
  1549. platform_driver_unregister(&pc87360_driver);
  1550. exit:
  1551. return err;
  1552. }
  1553. static void __exit pc87360_exit(void)
  1554. {
  1555. platform_device_unregister(pdev);
  1556. platform_driver_unregister(&pc87360_driver);
  1557. }
  1558. MODULE_AUTHOR("Jean Delvare <[email protected]>");
  1559. MODULE_DESCRIPTION("PC8736x hardware monitor");
  1560. MODULE_LICENSE("GPL");
  1561. MODULE_ALIAS("platform:" DRIVER_NAME);
  1562. module_init(pc87360_init);
  1563. module_exit(pc87360_exit);