lm83.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483
  1. /*
  2. * lm83.c - Part of lm_sensors, Linux kernel modules for hardware
  3. * monitoring
  4. * Copyright (C) 2003-2006 Jean Delvare <khali@linux-fr.org>
  5. *
  6. * Heavily inspired from the lm78, lm75 and adm1021 drivers. The LM83 is
  7. * a sensor chip made by National Semiconductor. It reports up to four
  8. * temperatures (its own plus up to three external ones) with a 1 deg
  9. * resolution and a 3-4 deg accuracy. Complete datasheet can be obtained
  10. * from National's website at:
  11. * http://www.national.com/pf/LM/LM83.html
  12. * Since the datasheet omits to give the chip stepping code, I give it
  13. * here: 0x03 (at register 0xff).
  14. *
  15. * Also supports the LM82 temp sensor, which is basically a stripped down
  16. * model of the LM83. Datasheet is here:
  17. * http://www.national.com/pf/LM/LM82.html
  18. *
  19. * This program is free software; you can redistribute it and/or modify
  20. * it under the terms of the GNU General Public License as published by
  21. * the Free Software Foundation; either version 2 of the License, or
  22. * (at your option) any later version.
  23. *
  24. * This program is distributed in the hope that it will be useful,
  25. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  26. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  27. * GNU General Public License for more details.
  28. *
  29. * You should have received a copy of the GNU General Public License
  30. * along with this program; if not, write to the Free Software
  31. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  32. */
  33. #include <linux/module.h>
  34. #include <linux/init.h>
  35. #include <linux/slab.h>
  36. #include <linux/jiffies.h>
  37. #include <linux/i2c.h>
  38. #include <linux/hwmon-sysfs.h>
  39. #include <linux/hwmon.h>
  40. #include <linux/err.h>
  41. #include <linux/mutex.h>
  42. #include <linux/sysfs.h>
  43. /*
  44. * Addresses to scan
  45. * Address is selected using 2 three-level pins, resulting in 9 possible
  46. * addresses.
  47. */
  48. static unsigned short normal_i2c[] = { 0x18, 0x19, 0x1a,
  49. 0x29, 0x2a, 0x2b,
  50. 0x4c, 0x4d, 0x4e,
  51. I2C_CLIENT_END };
  52. /*
  53. * Insmod parameters
  54. */
  55. I2C_CLIENT_INSMOD_2(lm83, lm82);
  56. /*
  57. * The LM83 registers
  58. * Manufacturer ID is 0x01 for National Semiconductor.
  59. */
  60. #define LM83_REG_R_MAN_ID 0xFE
  61. #define LM83_REG_R_CHIP_ID 0xFF
  62. #define LM83_REG_R_CONFIG 0x03
  63. #define LM83_REG_W_CONFIG 0x09
  64. #define LM83_REG_R_STATUS1 0x02
  65. #define LM83_REG_R_STATUS2 0x35
  66. #define LM83_REG_R_LOCAL_TEMP 0x00
  67. #define LM83_REG_R_LOCAL_HIGH 0x05
  68. #define LM83_REG_W_LOCAL_HIGH 0x0B
  69. #define LM83_REG_R_REMOTE1_TEMP 0x30
  70. #define LM83_REG_R_REMOTE1_HIGH 0x38
  71. #define LM83_REG_W_REMOTE1_HIGH 0x50
  72. #define LM83_REG_R_REMOTE2_TEMP 0x01
  73. #define LM83_REG_R_REMOTE2_HIGH 0x07
  74. #define LM83_REG_W_REMOTE2_HIGH 0x0D
  75. #define LM83_REG_R_REMOTE3_TEMP 0x31
  76. #define LM83_REG_R_REMOTE3_HIGH 0x3A
  77. #define LM83_REG_W_REMOTE3_HIGH 0x52
  78. #define LM83_REG_R_TCRIT 0x42
  79. #define LM83_REG_W_TCRIT 0x5A
  80. /*
  81. * Conversions and various macros
  82. * The LM83 uses signed 8-bit values with LSB = 1 degree Celsius.
  83. */
  84. #define TEMP_FROM_REG(val) ((val) * 1000)
  85. #define TEMP_TO_REG(val) ((val) <= -128000 ? -128 : \
  86. (val) >= 127000 ? 127 : \
  87. (val) < 0 ? ((val) - 500) / 1000 : \
  88. ((val) + 500) / 1000)
  89. static const u8 LM83_REG_R_TEMP[] = {
  90. LM83_REG_R_LOCAL_TEMP,
  91. LM83_REG_R_REMOTE1_TEMP,
  92. LM83_REG_R_REMOTE2_TEMP,
  93. LM83_REG_R_REMOTE3_TEMP,
  94. LM83_REG_R_LOCAL_HIGH,
  95. LM83_REG_R_REMOTE1_HIGH,
  96. LM83_REG_R_REMOTE2_HIGH,
  97. LM83_REG_R_REMOTE3_HIGH,
  98. LM83_REG_R_TCRIT,
  99. };
  100. static const u8 LM83_REG_W_HIGH[] = {
  101. LM83_REG_W_LOCAL_HIGH,
  102. LM83_REG_W_REMOTE1_HIGH,
  103. LM83_REG_W_REMOTE2_HIGH,
  104. LM83_REG_W_REMOTE3_HIGH,
  105. LM83_REG_W_TCRIT,
  106. };
  107. /*
  108. * Functions declaration
  109. */
  110. static int lm83_attach_adapter(struct i2c_adapter *adapter);
  111. static int lm83_detect(struct i2c_adapter *adapter, int address, int kind);
  112. static int lm83_detach_client(struct i2c_client *client);
  113. static struct lm83_data *lm83_update_device(struct device *dev);
  114. /*
  115. * Driver data (common to all clients)
  116. */
  117. static struct i2c_driver lm83_driver = {
  118. .driver = {
  119. .name = "lm83",
  120. },
  121. .id = I2C_DRIVERID_LM83,
  122. .attach_adapter = lm83_attach_adapter,
  123. .detach_client = lm83_detach_client,
  124. };
  125. /*
  126. * Client data (each client gets its own)
  127. */
  128. struct lm83_data {
  129. struct i2c_client client;
  130. struct class_device *class_dev;
  131. struct mutex update_lock;
  132. char valid; /* zero until following fields are valid */
  133. unsigned long last_updated; /* in jiffies */
  134. /* registers values */
  135. s8 temp[9]; /* 0..3: input 1-4,
  136. 4..7: high limit 1-4,
  137. 8 : critical limit */
  138. u16 alarms; /* bitvector, combined */
  139. };
  140. /*
  141. * Sysfs stuff
  142. */
  143. static ssize_t show_temp(struct device *dev, struct device_attribute *devattr,
  144. char *buf)
  145. {
  146. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  147. struct lm83_data *data = lm83_update_device(dev);
  148. return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[attr->index]));
  149. }
  150. static ssize_t set_temp(struct device *dev, struct device_attribute *devattr,
  151. const char *buf, size_t count)
  152. {
  153. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  154. struct i2c_client *client = to_i2c_client(dev);
  155. struct lm83_data *data = i2c_get_clientdata(client);
  156. long val = simple_strtol(buf, NULL, 10);
  157. int nr = attr->index;
  158. mutex_lock(&data->update_lock);
  159. data->temp[nr] = TEMP_TO_REG(val);
  160. i2c_smbus_write_byte_data(client, LM83_REG_W_HIGH[nr - 4],
  161. data->temp[nr]);
  162. mutex_unlock(&data->update_lock);
  163. return count;
  164. }
  165. static ssize_t show_alarms(struct device *dev, struct device_attribute *dummy,
  166. char *buf)
  167. {
  168. struct lm83_data *data = lm83_update_device(dev);
  169. return sprintf(buf, "%d\n", data->alarms);
  170. }
  171. static ssize_t show_alarm(struct device *dev, struct device_attribute
  172. *devattr, char *buf)
  173. {
  174. struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  175. struct lm83_data *data = lm83_update_device(dev);
  176. int bitnr = attr->index;
  177. return sprintf(buf, "%d\n", (data->alarms >> bitnr) & 1);
  178. }
  179. static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
  180. static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
  181. static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2);
  182. static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp, NULL, 3);
  183. static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp,
  184. set_temp, 4);
  185. static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp,
  186. set_temp, 5);
  187. static SENSOR_DEVICE_ATTR(temp3_max, S_IWUSR | S_IRUGO, show_temp,
  188. set_temp, 6);
  189. static SENSOR_DEVICE_ATTR(temp4_max, S_IWUSR | S_IRUGO, show_temp,
  190. set_temp, 7);
  191. static SENSOR_DEVICE_ATTR(temp1_crit, S_IRUGO, show_temp, NULL, 8);
  192. static SENSOR_DEVICE_ATTR(temp2_crit, S_IRUGO, show_temp, NULL, 8);
  193. static SENSOR_DEVICE_ATTR(temp3_crit, S_IWUSR | S_IRUGO, show_temp,
  194. set_temp, 8);
  195. static SENSOR_DEVICE_ATTR(temp4_crit, S_IRUGO, show_temp, NULL, 8);
  196. /* Individual alarm files */
  197. static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 0);
  198. static SENSOR_DEVICE_ATTR(temp3_crit_alarm, S_IRUGO, show_alarm, NULL, 1);
  199. static SENSOR_DEVICE_ATTR(temp3_input_fault, S_IRUGO, show_alarm, NULL, 2);
  200. static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_alarm, NULL, 4);
  201. static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
  202. static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 8);
  203. static SENSOR_DEVICE_ATTR(temp4_crit_alarm, S_IRUGO, show_alarm, NULL, 9);
  204. static SENSOR_DEVICE_ATTR(temp4_input_fault, S_IRUGO, show_alarm, NULL, 10);
  205. static SENSOR_DEVICE_ATTR(temp4_max_alarm, S_IRUGO, show_alarm, NULL, 12);
  206. static SENSOR_DEVICE_ATTR(temp2_input_fault, S_IRUGO, show_alarm, NULL, 13);
  207. static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 15);
  208. /* Raw alarm file for compatibility */
  209. static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
  210. static struct attribute *lm83_attributes[] = {
  211. &sensor_dev_attr_temp1_input.dev_attr.attr,
  212. &sensor_dev_attr_temp3_input.dev_attr.attr,
  213. &sensor_dev_attr_temp1_max.dev_attr.attr,
  214. &sensor_dev_attr_temp3_max.dev_attr.attr,
  215. &sensor_dev_attr_temp1_crit.dev_attr.attr,
  216. &sensor_dev_attr_temp3_crit.dev_attr.attr,
  217. &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
  218. &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
  219. &sensor_dev_attr_temp3_input_fault.dev_attr.attr,
  220. &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
  221. &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
  222. &dev_attr_alarms.attr,
  223. NULL
  224. };
  225. static const struct attribute_group lm83_group = {
  226. .attrs = lm83_attributes,
  227. };
  228. static struct attribute *lm83_attributes_opt[] = {
  229. &sensor_dev_attr_temp2_input.dev_attr.attr,
  230. &sensor_dev_attr_temp4_input.dev_attr.attr,
  231. &sensor_dev_attr_temp2_max.dev_attr.attr,
  232. &sensor_dev_attr_temp4_max.dev_attr.attr,
  233. &sensor_dev_attr_temp2_crit.dev_attr.attr,
  234. &sensor_dev_attr_temp4_crit.dev_attr.attr,
  235. &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
  236. &sensor_dev_attr_temp4_crit_alarm.dev_attr.attr,
  237. &sensor_dev_attr_temp4_input_fault.dev_attr.attr,
  238. &sensor_dev_attr_temp4_max_alarm.dev_attr.attr,
  239. &sensor_dev_attr_temp2_input_fault.dev_attr.attr,
  240. &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
  241. NULL
  242. };
  243. static const struct attribute_group lm83_group_opt = {
  244. .attrs = lm83_attributes_opt,
  245. };
  246. /*
  247. * Real code
  248. */
  249. static int lm83_attach_adapter(struct i2c_adapter *adapter)
  250. {
  251. if (!(adapter->class & I2C_CLASS_HWMON))
  252. return 0;
  253. return i2c_probe(adapter, &addr_data, lm83_detect);
  254. }
  255. /*
  256. * The following function does more than just detection. If detection
  257. * succeeds, it also registers the new chip.
  258. */
  259. static int lm83_detect(struct i2c_adapter *adapter, int address, int kind)
  260. {
  261. struct i2c_client *new_client;
  262. struct lm83_data *data;
  263. int err = 0;
  264. const char *name = "";
  265. if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
  266. goto exit;
  267. if (!(data = kzalloc(sizeof(struct lm83_data), GFP_KERNEL))) {
  268. err = -ENOMEM;
  269. goto exit;
  270. }
  271. /* The common I2C client data is placed right after the
  272. * LM83-specific data. */
  273. new_client = &data->client;
  274. i2c_set_clientdata(new_client, data);
  275. new_client->addr = address;
  276. new_client->adapter = adapter;
  277. new_client->driver = &lm83_driver;
  278. new_client->flags = 0;
  279. /* Now we do the detection and identification. A negative kind
  280. * means that the driver was loaded with no force parameter
  281. * (default), so we must both detect and identify the chip
  282. * (actually there is only one possible kind of chip for now, LM83).
  283. * A zero kind means that the driver was loaded with the force
  284. * parameter, the detection step shall be skipped. A positive kind
  285. * means that the driver was loaded with the force parameter and a
  286. * given kind of chip is requested, so both the detection and the
  287. * identification steps are skipped. */
  288. /* Default to an LM83 if forced */
  289. if (kind == 0)
  290. kind = lm83;
  291. if (kind < 0) { /* detection */
  292. if (((i2c_smbus_read_byte_data(new_client, LM83_REG_R_STATUS1)
  293. & 0xA8) != 0x00) ||
  294. ((i2c_smbus_read_byte_data(new_client, LM83_REG_R_STATUS2)
  295. & 0x48) != 0x00) ||
  296. ((i2c_smbus_read_byte_data(new_client, LM83_REG_R_CONFIG)
  297. & 0x41) != 0x00)) {
  298. dev_dbg(&adapter->dev,
  299. "LM83 detection failed at 0x%02x.\n", address);
  300. goto exit_free;
  301. }
  302. }
  303. if (kind <= 0) { /* identification */
  304. u8 man_id, chip_id;
  305. man_id = i2c_smbus_read_byte_data(new_client,
  306. LM83_REG_R_MAN_ID);
  307. chip_id = i2c_smbus_read_byte_data(new_client,
  308. LM83_REG_R_CHIP_ID);
  309. if (man_id == 0x01) { /* National Semiconductor */
  310. if (chip_id == 0x03) {
  311. kind = lm83;
  312. } else
  313. if (chip_id == 0x01) {
  314. kind = lm82;
  315. }
  316. }
  317. if (kind <= 0) { /* identification failed */
  318. dev_info(&adapter->dev,
  319. "Unsupported chip (man_id=0x%02X, "
  320. "chip_id=0x%02X).\n", man_id, chip_id);
  321. goto exit_free;
  322. }
  323. }
  324. if (kind == lm83) {
  325. name = "lm83";
  326. } else
  327. if (kind == lm82) {
  328. name = "lm82";
  329. }
  330. /* We can fill in the remaining client fields */
  331. strlcpy(new_client->name, name, I2C_NAME_SIZE);
  332. data->valid = 0;
  333. mutex_init(&data->update_lock);
  334. /* Tell the I2C layer a new client has arrived */
  335. if ((err = i2c_attach_client(new_client)))
  336. goto exit_free;
  337. /*
  338. * Register sysfs hooks
  339. * The LM82 can only monitor one external diode which is
  340. * at the same register as the LM83 temp3 entry - so we
  341. * declare 1 and 3 common, and then 2 and 4 only for the LM83.
  342. */
  343. if ((err = sysfs_create_group(&new_client->dev.kobj, &lm83_group)))
  344. goto exit_detach;
  345. if (kind == lm83) {
  346. if ((err = sysfs_create_group(&new_client->dev.kobj,
  347. &lm83_group_opt)))
  348. goto exit_remove_files;
  349. }
  350. data->class_dev = hwmon_device_register(&new_client->dev);
  351. if (IS_ERR(data->class_dev)) {
  352. err = PTR_ERR(data->class_dev);
  353. goto exit_remove_files;
  354. }
  355. return 0;
  356. exit_remove_files:
  357. sysfs_remove_group(&new_client->dev.kobj, &lm83_group);
  358. sysfs_remove_group(&new_client->dev.kobj, &lm83_group_opt);
  359. exit_detach:
  360. i2c_detach_client(new_client);
  361. exit_free:
  362. kfree(data);
  363. exit:
  364. return err;
  365. }
  366. static int lm83_detach_client(struct i2c_client *client)
  367. {
  368. struct lm83_data *data = i2c_get_clientdata(client);
  369. int err;
  370. hwmon_device_unregister(data->class_dev);
  371. sysfs_remove_group(&client->dev.kobj, &lm83_group);
  372. sysfs_remove_group(&client->dev.kobj, &lm83_group_opt);
  373. if ((err = i2c_detach_client(client)))
  374. return err;
  375. kfree(data);
  376. return 0;
  377. }
  378. static struct lm83_data *lm83_update_device(struct device *dev)
  379. {
  380. struct i2c_client *client = to_i2c_client(dev);
  381. struct lm83_data *data = i2c_get_clientdata(client);
  382. mutex_lock(&data->update_lock);
  383. if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) {
  384. int nr;
  385. dev_dbg(&client->dev, "Updating lm83 data.\n");
  386. for (nr = 0; nr < 9; nr++) {
  387. data->temp[nr] =
  388. i2c_smbus_read_byte_data(client,
  389. LM83_REG_R_TEMP[nr]);
  390. }
  391. data->alarms =
  392. i2c_smbus_read_byte_data(client, LM83_REG_R_STATUS1)
  393. + (i2c_smbus_read_byte_data(client, LM83_REG_R_STATUS2)
  394. << 8);
  395. data->last_updated = jiffies;
  396. data->valid = 1;
  397. }
  398. mutex_unlock(&data->update_lock);
  399. return data;
  400. }
  401. static int __init sensors_lm83_init(void)
  402. {
  403. return i2c_add_driver(&lm83_driver);
  404. }
  405. static void __exit sensors_lm83_exit(void)
  406. {
  407. i2c_del_driver(&lm83_driver);
  408. }
  409. MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
  410. MODULE_DESCRIPTION("LM83 driver");
  411. MODULE_LICENSE("GPL");
  412. module_init(sensors_lm83_init);
  413. module_exit(sensors_lm83_exit);