fscher.c 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688
  1. /*
  2. * fscher.c - Part of lm_sensors, Linux kernel modules for hardware
  3. * monitoring
  4. * Copyright (C) 2003, 2004 Reinhard Nissl <rnissl@gmx.de>
  5. *
  6. * This program is free software; you can redistribute it and/or modify
  7. * it under the terms of the GNU General Public License as published by
  8. * the Free Software Foundation; either version 2 of the License, or
  9. * (at your option) any later version.
  10. *
  11. * This program is distributed in the hope that it will be useful,
  12. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14. * GNU General Public License for more details.
  15. *
  16. * You should have received a copy of the GNU General Public License
  17. * along with this program; if not, write to the Free Software
  18. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19. */
  20. /*
  21. * fujitsu siemens hermes chip,
  22. * module based on fscpos.c
  23. * Copyright (C) 2000 Hermann Jung <hej@odn.de>
  24. * Copyright (C) 1998, 1999 Frodo Looijaard <frodol@dds.nl>
  25. * and Philip Edelbrock <phil@netroedge.com>
  26. */
  27. #include <linux/module.h>
  28. #include <linux/init.h>
  29. #include <linux/slab.h>
  30. #include <linux/jiffies.h>
  31. #include <linux/i2c.h>
  32. #include <linux/hwmon.h>
  33. #include <linux/err.h>
  34. #include <linux/mutex.h>
  35. #include <linux/sysfs.h>
  36. /*
  37. * Addresses to scan
  38. */
  39. static unsigned short normal_i2c[] = { 0x73, I2C_CLIENT_END };
  40. /*
  41. * Insmod parameters
  42. */
  43. I2C_CLIENT_INSMOD_1(fscher);
  44. /*
  45. * The FSCHER registers
  46. */
  47. /* chip identification */
  48. #define FSCHER_REG_IDENT_0 0x00
  49. #define FSCHER_REG_IDENT_1 0x01
  50. #define FSCHER_REG_IDENT_2 0x02
  51. #define FSCHER_REG_REVISION 0x03
  52. /* global control and status */
  53. #define FSCHER_REG_EVENT_STATE 0x04
  54. #define FSCHER_REG_CONTROL 0x05
  55. /* watchdog */
  56. #define FSCHER_REG_WDOG_PRESET 0x28
  57. #define FSCHER_REG_WDOG_STATE 0x23
  58. #define FSCHER_REG_WDOG_CONTROL 0x21
  59. /* fan 0 */
  60. #define FSCHER_REG_FAN0_MIN 0x55
  61. #define FSCHER_REG_FAN0_ACT 0x0e
  62. #define FSCHER_REG_FAN0_STATE 0x0d
  63. #define FSCHER_REG_FAN0_RIPPLE 0x0f
  64. /* fan 1 */
  65. #define FSCHER_REG_FAN1_MIN 0x65
  66. #define FSCHER_REG_FAN1_ACT 0x6b
  67. #define FSCHER_REG_FAN1_STATE 0x62
  68. #define FSCHER_REG_FAN1_RIPPLE 0x6f
  69. /* fan 2 */
  70. #define FSCHER_REG_FAN2_MIN 0xb5
  71. #define FSCHER_REG_FAN2_ACT 0xbb
  72. #define FSCHER_REG_FAN2_STATE 0xb2
  73. #define FSCHER_REG_FAN2_RIPPLE 0xbf
  74. /* voltage supervision */
  75. #define FSCHER_REG_VOLT_12 0x45
  76. #define FSCHER_REG_VOLT_5 0x42
  77. #define FSCHER_REG_VOLT_BATT 0x48
  78. /* temperature 0 */
  79. #define FSCHER_REG_TEMP0_ACT 0x64
  80. #define FSCHER_REG_TEMP0_STATE 0x71
  81. /* temperature 1 */
  82. #define FSCHER_REG_TEMP1_ACT 0x32
  83. #define FSCHER_REG_TEMP1_STATE 0x81
  84. /* temperature 2 */
  85. #define FSCHER_REG_TEMP2_ACT 0x35
  86. #define FSCHER_REG_TEMP2_STATE 0x91
  87. /*
  88. * Functions declaration
  89. */
  90. static int fscher_attach_adapter(struct i2c_adapter *adapter);
  91. static int fscher_detect(struct i2c_adapter *adapter, int address, int kind);
  92. static int fscher_detach_client(struct i2c_client *client);
  93. static struct fscher_data *fscher_update_device(struct device *dev);
  94. static void fscher_init_client(struct i2c_client *client);
  95. static int fscher_read_value(struct i2c_client *client, u8 reg);
  96. static int fscher_write_value(struct i2c_client *client, u8 reg, u8 value);
  97. /*
  98. * Driver data (common to all clients)
  99. */
  100. static struct i2c_driver fscher_driver = {
  101. .driver = {
  102. .name = "fscher",
  103. },
  104. .id = I2C_DRIVERID_FSCHER,
  105. .attach_adapter = fscher_attach_adapter,
  106. .detach_client = fscher_detach_client,
  107. };
  108. /*
  109. * Client data (each client gets its own)
  110. */
  111. struct fscher_data {
  112. struct i2c_client client;
  113. struct class_device *class_dev;
  114. struct mutex update_lock;
  115. char valid; /* zero until following fields are valid */
  116. unsigned long last_updated; /* in jiffies */
  117. /* register values */
  118. u8 revision; /* revision of chip */
  119. u8 global_event; /* global event status */
  120. u8 global_control; /* global control register */
  121. u8 watchdog[3]; /* watchdog */
  122. u8 volt[3]; /* 12, 5, battery voltage */
  123. u8 temp_act[3]; /* temperature */
  124. u8 temp_status[3]; /* status of sensor */
  125. u8 fan_act[3]; /* fans revolutions per second */
  126. u8 fan_status[3]; /* fan status */
  127. u8 fan_min[3]; /* fan min value for rps */
  128. u8 fan_ripple[3]; /* divider for rps */
  129. };
  130. /*
  131. * Sysfs stuff
  132. */
  133. #define sysfs_r(kind, sub, offset, reg) \
  134. static ssize_t show_##kind##sub (struct fscher_data *, char *, int); \
  135. static ssize_t show_##kind##offset##sub (struct device *, struct device_attribute *attr, char *); \
  136. static ssize_t show_##kind##offset##sub (struct device *dev, struct device_attribute *attr, char *buf) \
  137. { \
  138. struct fscher_data *data = fscher_update_device(dev); \
  139. return show_##kind##sub(data, buf, (offset)); \
  140. }
  141. #define sysfs_w(kind, sub, offset, reg) \
  142. static ssize_t set_##kind##sub (struct i2c_client *, struct fscher_data *, const char *, size_t, int, int); \
  143. static ssize_t set_##kind##offset##sub (struct device *, struct device_attribute *attr, const char *, size_t); \
  144. static ssize_t set_##kind##offset##sub (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \
  145. { \
  146. struct i2c_client *client = to_i2c_client(dev); \
  147. struct fscher_data *data = i2c_get_clientdata(client); \
  148. return set_##kind##sub(client, data, buf, count, (offset), reg); \
  149. }
  150. #define sysfs_rw_n(kind, sub, offset, reg) \
  151. sysfs_r(kind, sub, offset, reg) \
  152. sysfs_w(kind, sub, offset, reg) \
  153. static DEVICE_ATTR(kind##offset##sub, S_IRUGO | S_IWUSR, show_##kind##offset##sub, set_##kind##offset##sub);
  154. #define sysfs_rw(kind, sub, reg) \
  155. sysfs_r(kind, sub, 0, reg) \
  156. sysfs_w(kind, sub, 0, reg) \
  157. static DEVICE_ATTR(kind##sub, S_IRUGO | S_IWUSR, show_##kind##0##sub, set_##kind##0##sub);
  158. #define sysfs_ro_n(kind, sub, offset, reg) \
  159. sysfs_r(kind, sub, offset, reg) \
  160. static DEVICE_ATTR(kind##offset##sub, S_IRUGO, show_##kind##offset##sub, NULL);
  161. #define sysfs_ro(kind, sub, reg) \
  162. sysfs_r(kind, sub, 0, reg) \
  163. static DEVICE_ATTR(kind, S_IRUGO, show_##kind##0##sub, NULL);
  164. #define sysfs_fan(offset, reg_status, reg_min, reg_ripple, reg_act) \
  165. sysfs_rw_n(pwm, , offset, reg_min) \
  166. sysfs_rw_n(fan, _status, offset, reg_status) \
  167. sysfs_rw_n(fan, _div , offset, reg_ripple) \
  168. sysfs_ro_n(fan, _input , offset, reg_act)
  169. #define sysfs_temp(offset, reg_status, reg_act) \
  170. sysfs_rw_n(temp, _status, offset, reg_status) \
  171. sysfs_ro_n(temp, _input , offset, reg_act)
  172. #define sysfs_in(offset, reg_act) \
  173. sysfs_ro_n(in, _input, offset, reg_act)
  174. #define sysfs_revision(reg_revision) \
  175. sysfs_ro(revision, , reg_revision)
  176. #define sysfs_alarms(reg_events) \
  177. sysfs_ro(alarms, , reg_events)
  178. #define sysfs_control(reg_control) \
  179. sysfs_rw(control, , reg_control)
  180. #define sysfs_watchdog(reg_control, reg_status, reg_preset) \
  181. sysfs_rw(watchdog, _control, reg_control) \
  182. sysfs_rw(watchdog, _status , reg_status) \
  183. sysfs_rw(watchdog, _preset , reg_preset)
  184. sysfs_fan(1, FSCHER_REG_FAN0_STATE, FSCHER_REG_FAN0_MIN,
  185. FSCHER_REG_FAN0_RIPPLE, FSCHER_REG_FAN0_ACT)
  186. sysfs_fan(2, FSCHER_REG_FAN1_STATE, FSCHER_REG_FAN1_MIN,
  187. FSCHER_REG_FAN1_RIPPLE, FSCHER_REG_FAN1_ACT)
  188. sysfs_fan(3, FSCHER_REG_FAN2_STATE, FSCHER_REG_FAN2_MIN,
  189. FSCHER_REG_FAN2_RIPPLE, FSCHER_REG_FAN2_ACT)
  190. sysfs_temp(1, FSCHER_REG_TEMP0_STATE, FSCHER_REG_TEMP0_ACT)
  191. sysfs_temp(2, FSCHER_REG_TEMP1_STATE, FSCHER_REG_TEMP1_ACT)
  192. sysfs_temp(3, FSCHER_REG_TEMP2_STATE, FSCHER_REG_TEMP2_ACT)
  193. sysfs_in(0, FSCHER_REG_VOLT_12)
  194. sysfs_in(1, FSCHER_REG_VOLT_5)
  195. sysfs_in(2, FSCHER_REG_VOLT_BATT)
  196. sysfs_revision(FSCHER_REG_REVISION)
  197. sysfs_alarms(FSCHER_REG_EVENTS)
  198. sysfs_control(FSCHER_REG_CONTROL)
  199. sysfs_watchdog(FSCHER_REG_WDOG_CONTROL, FSCHER_REG_WDOG_STATE, FSCHER_REG_WDOG_PRESET)
  200. static struct attribute *fscher_attributes[] = {
  201. &dev_attr_revision.attr,
  202. &dev_attr_alarms.attr,
  203. &dev_attr_control.attr,
  204. &dev_attr_watchdog_status.attr,
  205. &dev_attr_watchdog_control.attr,
  206. &dev_attr_watchdog_preset.attr,
  207. &dev_attr_in0_input.attr,
  208. &dev_attr_in1_input.attr,
  209. &dev_attr_in2_input.attr,
  210. &dev_attr_fan1_status.attr,
  211. &dev_attr_fan1_div.attr,
  212. &dev_attr_fan1_input.attr,
  213. &dev_attr_pwm1.attr,
  214. &dev_attr_fan2_status.attr,
  215. &dev_attr_fan2_div.attr,
  216. &dev_attr_fan2_input.attr,
  217. &dev_attr_pwm2.attr,
  218. &dev_attr_fan3_status.attr,
  219. &dev_attr_fan3_div.attr,
  220. &dev_attr_fan3_input.attr,
  221. &dev_attr_pwm3.attr,
  222. &dev_attr_temp1_status.attr,
  223. &dev_attr_temp1_input.attr,
  224. &dev_attr_temp2_status.attr,
  225. &dev_attr_temp2_input.attr,
  226. &dev_attr_temp3_status.attr,
  227. &dev_attr_temp3_input.attr,
  228. NULL
  229. };
  230. static const struct attribute_group fscher_group = {
  231. .attrs = fscher_attributes,
  232. };
  233. /*
  234. * Real code
  235. */
  236. static int fscher_attach_adapter(struct i2c_adapter *adapter)
  237. {
  238. if (!(adapter->class & I2C_CLASS_HWMON))
  239. return 0;
  240. return i2c_probe(adapter, &addr_data, fscher_detect);
  241. }
  242. static int fscher_detect(struct i2c_adapter *adapter, int address, int kind)
  243. {
  244. struct i2c_client *new_client;
  245. struct fscher_data *data;
  246. int err = 0;
  247. if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
  248. goto exit;
  249. /* OK. For now, we presume we have a valid client. We now create the
  250. * client structure, even though we cannot fill it completely yet.
  251. * But it allows us to access i2c_smbus_read_byte_data. */
  252. if (!(data = kzalloc(sizeof(struct fscher_data), GFP_KERNEL))) {
  253. err = -ENOMEM;
  254. goto exit;
  255. }
  256. /* The common I2C client data is placed right before the
  257. * Hermes-specific data. */
  258. new_client = &data->client;
  259. i2c_set_clientdata(new_client, data);
  260. new_client->addr = address;
  261. new_client->adapter = adapter;
  262. new_client->driver = &fscher_driver;
  263. new_client->flags = 0;
  264. /* Do the remaining detection unless force or force_fscher parameter */
  265. if (kind < 0) {
  266. if ((i2c_smbus_read_byte_data(new_client,
  267. FSCHER_REG_IDENT_0) != 0x48) /* 'H' */
  268. || (i2c_smbus_read_byte_data(new_client,
  269. FSCHER_REG_IDENT_1) != 0x45) /* 'E' */
  270. || (i2c_smbus_read_byte_data(new_client,
  271. FSCHER_REG_IDENT_2) != 0x52)) /* 'R' */
  272. goto exit_free;
  273. }
  274. /* Fill in the remaining client fields and put it into the
  275. * global list */
  276. strlcpy(new_client->name, "fscher", I2C_NAME_SIZE);
  277. data->valid = 0;
  278. mutex_init(&data->update_lock);
  279. /* Tell the I2C layer a new client has arrived */
  280. if ((err = i2c_attach_client(new_client)))
  281. goto exit_free;
  282. fscher_init_client(new_client);
  283. /* Register sysfs hooks */
  284. if ((err = sysfs_create_group(&new_client->dev.kobj, &fscher_group)))
  285. goto exit_detach;
  286. data->class_dev = hwmon_device_register(&new_client->dev);
  287. if (IS_ERR(data->class_dev)) {
  288. err = PTR_ERR(data->class_dev);
  289. goto exit_remove_files;
  290. }
  291. return 0;
  292. exit_remove_files:
  293. sysfs_remove_group(&new_client->dev.kobj, &fscher_group);
  294. exit_detach:
  295. i2c_detach_client(new_client);
  296. exit_free:
  297. kfree(data);
  298. exit:
  299. return err;
  300. }
  301. static int fscher_detach_client(struct i2c_client *client)
  302. {
  303. struct fscher_data *data = i2c_get_clientdata(client);
  304. int err;
  305. hwmon_device_unregister(data->class_dev);
  306. sysfs_remove_group(&client->dev.kobj, &fscher_group);
  307. if ((err = i2c_detach_client(client)))
  308. return err;
  309. kfree(data);
  310. return 0;
  311. }
  312. static int fscher_read_value(struct i2c_client *client, u8 reg)
  313. {
  314. dev_dbg(&client->dev, "read reg 0x%02x\n", reg);
  315. return i2c_smbus_read_byte_data(client, reg);
  316. }
  317. static int fscher_write_value(struct i2c_client *client, u8 reg, u8 value)
  318. {
  319. dev_dbg(&client->dev, "write reg 0x%02x, val 0x%02x\n",
  320. reg, value);
  321. return i2c_smbus_write_byte_data(client, reg, value);
  322. }
  323. /* Called when we have found a new FSC Hermes. */
  324. static void fscher_init_client(struct i2c_client *client)
  325. {
  326. struct fscher_data *data = i2c_get_clientdata(client);
  327. /* Read revision from chip */
  328. data->revision = fscher_read_value(client, FSCHER_REG_REVISION);
  329. }
  330. static struct fscher_data *fscher_update_device(struct device *dev)
  331. {
  332. struct i2c_client *client = to_i2c_client(dev);
  333. struct fscher_data *data = i2c_get_clientdata(client);
  334. mutex_lock(&data->update_lock);
  335. if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
  336. dev_dbg(&client->dev, "Starting fscher update\n");
  337. data->temp_act[0] = fscher_read_value(client, FSCHER_REG_TEMP0_ACT);
  338. data->temp_act[1] = fscher_read_value(client, FSCHER_REG_TEMP1_ACT);
  339. data->temp_act[2] = fscher_read_value(client, FSCHER_REG_TEMP2_ACT);
  340. data->temp_status[0] = fscher_read_value(client, FSCHER_REG_TEMP0_STATE);
  341. data->temp_status[1] = fscher_read_value(client, FSCHER_REG_TEMP1_STATE);
  342. data->temp_status[2] = fscher_read_value(client, FSCHER_REG_TEMP2_STATE);
  343. data->volt[0] = fscher_read_value(client, FSCHER_REG_VOLT_12);
  344. data->volt[1] = fscher_read_value(client, FSCHER_REG_VOLT_5);
  345. data->volt[2] = fscher_read_value(client, FSCHER_REG_VOLT_BATT);
  346. data->fan_act[0] = fscher_read_value(client, FSCHER_REG_FAN0_ACT);
  347. data->fan_act[1] = fscher_read_value(client, FSCHER_REG_FAN1_ACT);
  348. data->fan_act[2] = fscher_read_value(client, FSCHER_REG_FAN2_ACT);
  349. data->fan_status[0] = fscher_read_value(client, FSCHER_REG_FAN0_STATE);
  350. data->fan_status[1] = fscher_read_value(client, FSCHER_REG_FAN1_STATE);
  351. data->fan_status[2] = fscher_read_value(client, FSCHER_REG_FAN2_STATE);
  352. data->fan_min[0] = fscher_read_value(client, FSCHER_REG_FAN0_MIN);
  353. data->fan_min[1] = fscher_read_value(client, FSCHER_REG_FAN1_MIN);
  354. data->fan_min[2] = fscher_read_value(client, FSCHER_REG_FAN2_MIN);
  355. data->fan_ripple[0] = fscher_read_value(client, FSCHER_REG_FAN0_RIPPLE);
  356. data->fan_ripple[1] = fscher_read_value(client, FSCHER_REG_FAN1_RIPPLE);
  357. data->fan_ripple[2] = fscher_read_value(client, FSCHER_REG_FAN2_RIPPLE);
  358. data->watchdog[0] = fscher_read_value(client, FSCHER_REG_WDOG_PRESET);
  359. data->watchdog[1] = fscher_read_value(client, FSCHER_REG_WDOG_STATE);
  360. data->watchdog[2] = fscher_read_value(client, FSCHER_REG_WDOG_CONTROL);
  361. data->global_event = fscher_read_value(client, FSCHER_REG_EVENT_STATE);
  362. data->last_updated = jiffies;
  363. data->valid = 1;
  364. }
  365. mutex_unlock(&data->update_lock);
  366. return data;
  367. }
  368. #define FAN_INDEX_FROM_NUM(nr) ((nr) - 1)
  369. static ssize_t set_fan_status(struct i2c_client *client, struct fscher_data *data,
  370. const char *buf, size_t count, int nr, int reg)
  371. {
  372. /* bits 0..1, 3..7 reserved => mask with 0x04 */
  373. unsigned long v = simple_strtoul(buf, NULL, 10) & 0x04;
  374. mutex_lock(&data->update_lock);
  375. data->fan_status[FAN_INDEX_FROM_NUM(nr)] &= ~v;
  376. fscher_write_value(client, reg, v);
  377. mutex_unlock(&data->update_lock);
  378. return count;
  379. }
  380. static ssize_t show_fan_status(struct fscher_data *data, char *buf, int nr)
  381. {
  382. /* bits 0..1, 3..7 reserved => mask with 0x04 */
  383. return sprintf(buf, "%u\n", data->fan_status[FAN_INDEX_FROM_NUM(nr)] & 0x04);
  384. }
  385. static ssize_t set_pwm(struct i2c_client *client, struct fscher_data *data,
  386. const char *buf, size_t count, int nr, int reg)
  387. {
  388. unsigned long v = simple_strtoul(buf, NULL, 10);
  389. mutex_lock(&data->update_lock);
  390. data->fan_min[FAN_INDEX_FROM_NUM(nr)] = v > 0xff ? 0xff : v;
  391. fscher_write_value(client, reg, data->fan_min[FAN_INDEX_FROM_NUM(nr)]);
  392. mutex_unlock(&data->update_lock);
  393. return count;
  394. }
  395. static ssize_t show_pwm(struct fscher_data *data, char *buf, int nr)
  396. {
  397. return sprintf(buf, "%u\n", data->fan_min[FAN_INDEX_FROM_NUM(nr)]);
  398. }
  399. static ssize_t set_fan_div(struct i2c_client *client, struct fscher_data *data,
  400. const char *buf, size_t count, int nr, int reg)
  401. {
  402. /* supported values: 2, 4, 8 */
  403. unsigned long v = simple_strtoul(buf, NULL, 10);
  404. switch (v) {
  405. case 2: v = 1; break;
  406. case 4: v = 2; break;
  407. case 8: v = 3; break;
  408. default:
  409. dev_err(&client->dev, "fan_div value %ld not "
  410. "supported. Choose one of 2, 4 or 8!\n", v);
  411. return -EINVAL;
  412. }
  413. mutex_lock(&data->update_lock);
  414. /* bits 2..7 reserved => mask with 0x03 */
  415. data->fan_ripple[FAN_INDEX_FROM_NUM(nr)] &= ~0x03;
  416. data->fan_ripple[FAN_INDEX_FROM_NUM(nr)] |= v;
  417. fscher_write_value(client, reg, data->fan_ripple[FAN_INDEX_FROM_NUM(nr)]);
  418. mutex_unlock(&data->update_lock);
  419. return count;
  420. }
  421. static ssize_t show_fan_div(struct fscher_data *data, char *buf, int nr)
  422. {
  423. /* bits 2..7 reserved => mask with 0x03 */
  424. return sprintf(buf, "%u\n", 1 << (data->fan_ripple[FAN_INDEX_FROM_NUM(nr)] & 0x03));
  425. }
  426. #define RPM_FROM_REG(val) (val*60)
  427. static ssize_t show_fan_input (struct fscher_data *data, char *buf, int nr)
  428. {
  429. return sprintf(buf, "%u\n", RPM_FROM_REG(data->fan_act[FAN_INDEX_FROM_NUM(nr)]));
  430. }
  431. #define TEMP_INDEX_FROM_NUM(nr) ((nr) - 1)
  432. static ssize_t set_temp_status(struct i2c_client *client, struct fscher_data *data,
  433. const char *buf, size_t count, int nr, int reg)
  434. {
  435. /* bits 2..7 reserved, 0 read only => mask with 0x02 */
  436. unsigned long v = simple_strtoul(buf, NULL, 10) & 0x02;
  437. mutex_lock(&data->update_lock);
  438. data->temp_status[TEMP_INDEX_FROM_NUM(nr)] &= ~v;
  439. fscher_write_value(client, reg, v);
  440. mutex_unlock(&data->update_lock);
  441. return count;
  442. }
  443. static ssize_t show_temp_status(struct fscher_data *data, char *buf, int nr)
  444. {
  445. /* bits 2..7 reserved => mask with 0x03 */
  446. return sprintf(buf, "%u\n", data->temp_status[TEMP_INDEX_FROM_NUM(nr)] & 0x03);
  447. }
  448. #define TEMP_FROM_REG(val) (((val) - 128) * 1000)
  449. static ssize_t show_temp_input(struct fscher_data *data, char *buf, int nr)
  450. {
  451. return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_act[TEMP_INDEX_FROM_NUM(nr)]));
  452. }
  453. /*
  454. * The final conversion is specified in sensors.conf, as it depends on
  455. * mainboard specific values. We export the registers contents as
  456. * pseudo-hundredths-of-Volts (range 0V - 2.55V). Not that it makes much
  457. * sense per se, but it minimizes the conversions count and keeps the
  458. * values within a usual range.
  459. */
  460. #define VOLT_FROM_REG(val) ((val) * 10)
  461. static ssize_t show_in_input(struct fscher_data *data, char *buf, int nr)
  462. {
  463. return sprintf(buf, "%u\n", VOLT_FROM_REG(data->volt[nr]));
  464. }
  465. static ssize_t show_revision(struct fscher_data *data, char *buf, int nr)
  466. {
  467. return sprintf(buf, "%u\n", data->revision);
  468. }
  469. static ssize_t show_alarms(struct fscher_data *data, char *buf, int nr)
  470. {
  471. /* bits 2, 5..6 reserved => mask with 0x9b */
  472. return sprintf(buf, "%u\n", data->global_event & 0x9b);
  473. }
  474. static ssize_t set_control(struct i2c_client *client, struct fscher_data *data,
  475. const char *buf, size_t count, int nr, int reg)
  476. {
  477. /* bits 1..7 reserved => mask with 0x01 */
  478. unsigned long v = simple_strtoul(buf, NULL, 10) & 0x01;
  479. mutex_lock(&data->update_lock);
  480. data->global_control &= ~v;
  481. fscher_write_value(client, reg, v);
  482. mutex_unlock(&data->update_lock);
  483. return count;
  484. }
  485. static ssize_t show_control(struct fscher_data *data, char *buf, int nr)
  486. {
  487. /* bits 1..7 reserved => mask with 0x01 */
  488. return sprintf(buf, "%u\n", data->global_control & 0x01);
  489. }
  490. static ssize_t set_watchdog_control(struct i2c_client *client, struct
  491. fscher_data *data, const char *buf, size_t count,
  492. int nr, int reg)
  493. {
  494. /* bits 0..3 reserved => mask with 0xf0 */
  495. unsigned long v = simple_strtoul(buf, NULL, 10) & 0xf0;
  496. mutex_lock(&data->update_lock);
  497. data->watchdog[2] &= ~0xf0;
  498. data->watchdog[2] |= v;
  499. fscher_write_value(client, reg, data->watchdog[2]);
  500. mutex_unlock(&data->update_lock);
  501. return count;
  502. }
  503. static ssize_t show_watchdog_control(struct fscher_data *data, char *buf, int nr)
  504. {
  505. /* bits 0..3 reserved, bit 5 write only => mask with 0xd0 */
  506. return sprintf(buf, "%u\n", data->watchdog[2] & 0xd0);
  507. }
  508. static ssize_t set_watchdog_status(struct i2c_client *client, struct fscher_data *data,
  509. const char *buf, size_t count, int nr, int reg)
  510. {
  511. /* bits 0, 2..7 reserved => mask with 0x02 */
  512. unsigned long v = simple_strtoul(buf, NULL, 10) & 0x02;
  513. mutex_lock(&data->update_lock);
  514. data->watchdog[1] &= ~v;
  515. fscher_write_value(client, reg, v);
  516. mutex_unlock(&data->update_lock);
  517. return count;
  518. }
  519. static ssize_t show_watchdog_status(struct fscher_data *data, char *buf, int nr)
  520. {
  521. /* bits 0, 2..7 reserved => mask with 0x02 */
  522. return sprintf(buf, "%u\n", data->watchdog[1] & 0x02);
  523. }
  524. static ssize_t set_watchdog_preset(struct i2c_client *client, struct fscher_data *data,
  525. const char *buf, size_t count, int nr, int reg)
  526. {
  527. unsigned long v = simple_strtoul(buf, NULL, 10) & 0xff;
  528. mutex_lock(&data->update_lock);
  529. data->watchdog[0] = v;
  530. fscher_write_value(client, reg, data->watchdog[0]);
  531. mutex_unlock(&data->update_lock);
  532. return count;
  533. }
  534. static ssize_t show_watchdog_preset(struct fscher_data *data, char *buf, int nr)
  535. {
  536. return sprintf(buf, "%u\n", data->watchdog[0]);
  537. }
  538. static int __init sensors_fscher_init(void)
  539. {
  540. return i2c_add_driver(&fscher_driver);
  541. }
  542. static void __exit sensors_fscher_exit(void)
  543. {
  544. i2c_del_driver(&fscher_driver);
  545. }
  546. MODULE_AUTHOR("Reinhard Nissl <rnissl@gmx.de>");
  547. MODULE_DESCRIPTION("FSC Hermes driver");
  548. MODULE_LICENSE("GPL");
  549. module_init(sensors_fscher_init);
  550. module_exit(sensors_fscher_exit);