gl520sm.c 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * gl520sm.c - Part of lm_sensors, Linux kernel modules for hardware
  4. * monitoring
  5. * Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl>,
  6. * Kyösti Mälkki <kmalkki@cc.hut.fi>
  7. * Copyright (c) 2005 Maarten Deprez <maartendeprez@users.sourceforge.net>
  8. */
  9. #include <linux/module.h>
  10. #include <linux/init.h>
  11. #include <linux/slab.h>
  12. #include <linux/jiffies.h>
  13. #include <linux/i2c.h>
  14. #include <linux/hwmon.h>
  15. #include <linux/hwmon-sysfs.h>
  16. #include <linux/hwmon-vid.h>
  17. #include <linux/err.h>
  18. #include <linux/mutex.h>
  19. #include <linux/sysfs.h>
  20. /* Type of the extra sensor */
  21. static unsigned short extra_sensor_type;
  22. module_param(extra_sensor_type, ushort, 0);
  23. MODULE_PARM_DESC(extra_sensor_type, "Type of extra sensor (0=autodetect, 1=temperature, 2=voltage)");
  24. /* Addresses to scan */
  25. static const unsigned short normal_i2c[] = { 0x2c, 0x2d, I2C_CLIENT_END };
  26. /*
  27. * Many GL520 constants specified below
  28. * One of the inputs can be configured as either temp or voltage.
  29. * That's why _TEMP2 and _IN4 access the same register
  30. */
  31. /* The GL520 registers */
  32. #define GL520_REG_CHIP_ID 0x00
  33. #define GL520_REG_REVISION 0x01
  34. #define GL520_REG_CONF 0x03
  35. #define GL520_REG_MASK 0x11
  36. #define GL520_REG_VID_INPUT 0x02
  37. static const u8 GL520_REG_IN_INPUT[] = { 0x15, 0x14, 0x13, 0x0d, 0x0e };
  38. static const u8 GL520_REG_IN_LIMIT[] = { 0x0c, 0x09, 0x0a, 0x0b };
  39. static const u8 GL520_REG_IN_MIN[] = { 0x0c, 0x09, 0x0a, 0x0b, 0x18 };
  40. static const u8 GL520_REG_IN_MAX[] = { 0x0c, 0x09, 0x0a, 0x0b, 0x17 };
  41. static const u8 GL520_REG_TEMP_INPUT[] = { 0x04, 0x0e };
  42. static const u8 GL520_REG_TEMP_MAX[] = { 0x05, 0x17 };
  43. static const u8 GL520_REG_TEMP_MAX_HYST[] = { 0x06, 0x18 };
  44. #define GL520_REG_FAN_INPUT 0x07
  45. #define GL520_REG_FAN_MIN 0x08
  46. #define GL520_REG_FAN_DIV 0x0f
  47. #define GL520_REG_FAN_OFF GL520_REG_FAN_DIV
  48. #define GL520_REG_ALARMS 0x12
  49. #define GL520_REG_BEEP_MASK 0x10
  50. #define GL520_REG_BEEP_ENABLE GL520_REG_CONF
  51. /* Client data */
  52. struct gl520_data {
  53. struct i2c_client *client;
  54. const struct attribute_group *groups[3];
  55. struct mutex update_lock;
  56. char valid; /* zero until the following fields are valid */
  57. unsigned long last_updated; /* in jiffies */
  58. u8 vid;
  59. u8 vrm;
  60. u8 in_input[5]; /* [0] = VVD */
  61. u8 in_min[5]; /* [0] = VDD */
  62. u8 in_max[5]; /* [0] = VDD */
  63. u8 fan_input[2];
  64. u8 fan_min[2];
  65. u8 fan_div[2];
  66. u8 fan_off;
  67. u8 temp_input[2];
  68. u8 temp_max[2];
  69. u8 temp_max_hyst[2];
  70. u8 alarms;
  71. u8 beep_enable;
  72. u8 beep_mask;
  73. u8 alarm_mask;
  74. u8 two_temps;
  75. };
  76. /*
  77. * Registers 0x07 to 0x0c are word-sized, others are byte-sized
  78. * GL520 uses a high-byte first convention
  79. */
  80. static int gl520_read_value(struct i2c_client *client, u8 reg)
  81. {
  82. if ((reg >= 0x07) && (reg <= 0x0c))
  83. return i2c_smbus_read_word_swapped(client, reg);
  84. else
  85. return i2c_smbus_read_byte_data(client, reg);
  86. }
  87. static int gl520_write_value(struct i2c_client *client, u8 reg, u16 value)
  88. {
  89. if ((reg >= 0x07) && (reg <= 0x0c))
  90. return i2c_smbus_write_word_swapped(client, reg, value);
  91. else
  92. return i2c_smbus_write_byte_data(client, reg, value);
  93. }
  94. static struct gl520_data *gl520_update_device(struct device *dev)
  95. {
  96. struct gl520_data *data = dev_get_drvdata(dev);
  97. struct i2c_client *client = data->client;
  98. int val, i;
  99. mutex_lock(&data->update_lock);
  100. if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
  101. dev_dbg(&client->dev, "Starting gl520sm update\n");
  102. data->alarms = gl520_read_value(client, GL520_REG_ALARMS);
  103. data->beep_mask = gl520_read_value(client, GL520_REG_BEEP_MASK);
  104. data->vid = gl520_read_value(client,
  105. GL520_REG_VID_INPUT) & 0x1f;
  106. for (i = 0; i < 4; i++) {
  107. data->in_input[i] = gl520_read_value(client,
  108. GL520_REG_IN_INPUT[i]);
  109. val = gl520_read_value(client, GL520_REG_IN_LIMIT[i]);
  110. data->in_min[i] = val & 0xff;
  111. data->in_max[i] = (val >> 8) & 0xff;
  112. }
  113. val = gl520_read_value(client, GL520_REG_FAN_INPUT);
  114. data->fan_input[0] = (val >> 8) & 0xff;
  115. data->fan_input[1] = val & 0xff;
  116. val = gl520_read_value(client, GL520_REG_FAN_MIN);
  117. data->fan_min[0] = (val >> 8) & 0xff;
  118. data->fan_min[1] = val & 0xff;
  119. data->temp_input[0] = gl520_read_value(client,
  120. GL520_REG_TEMP_INPUT[0]);
  121. data->temp_max[0] = gl520_read_value(client,
  122. GL520_REG_TEMP_MAX[0]);
  123. data->temp_max_hyst[0] = gl520_read_value(client,
  124. GL520_REG_TEMP_MAX_HYST[0]);
  125. val = gl520_read_value(client, GL520_REG_FAN_DIV);
  126. data->fan_div[0] = (val >> 6) & 0x03;
  127. data->fan_div[1] = (val >> 4) & 0x03;
  128. data->fan_off = (val >> 2) & 0x01;
  129. data->alarms &= data->alarm_mask;
  130. val = gl520_read_value(client, GL520_REG_CONF);
  131. data->beep_enable = !((val >> 2) & 1);
  132. /* Temp1 and Vin4 are the same input */
  133. if (data->two_temps) {
  134. data->temp_input[1] = gl520_read_value(client,
  135. GL520_REG_TEMP_INPUT[1]);
  136. data->temp_max[1] = gl520_read_value(client,
  137. GL520_REG_TEMP_MAX[1]);
  138. data->temp_max_hyst[1] = gl520_read_value(client,
  139. GL520_REG_TEMP_MAX_HYST[1]);
  140. } else {
  141. data->in_input[4] = gl520_read_value(client,
  142. GL520_REG_IN_INPUT[4]);
  143. data->in_min[4] = gl520_read_value(client,
  144. GL520_REG_IN_MIN[4]);
  145. data->in_max[4] = gl520_read_value(client,
  146. GL520_REG_IN_MAX[4]);
  147. }
  148. data->last_updated = jiffies;
  149. data->valid = 1;
  150. }
  151. mutex_unlock(&data->update_lock);
  152. return data;
  153. }
  154. /*
  155. * Sysfs stuff
  156. */
  157. static ssize_t cpu0_vid_show(struct device *dev,
  158. struct device_attribute *attr, char *buf)
  159. {
  160. struct gl520_data *data = gl520_update_device(dev);
  161. return sprintf(buf, "%u\n", vid_from_reg(data->vid, data->vrm));
  162. }
  163. static DEVICE_ATTR_RO(cpu0_vid);
  164. #define VDD_FROM_REG(val) DIV_ROUND_CLOSEST((val) * 95, 4)
  165. #define VDD_CLAMP(val) clamp_val(val, 0, 255 * 95 / 4)
  166. #define VDD_TO_REG(val) DIV_ROUND_CLOSEST(VDD_CLAMP(val) * 4, 95)
  167. #define IN_FROM_REG(val) ((val) * 19)
  168. #define IN_CLAMP(val) clamp_val(val, 0, 255 * 19)
  169. #define IN_TO_REG(val) DIV_ROUND_CLOSEST(IN_CLAMP(val), 19)
  170. static ssize_t in_input_show(struct device *dev,
  171. struct device_attribute *attr, char *buf)
  172. {
  173. int n = to_sensor_dev_attr(attr)->index;
  174. struct gl520_data *data = gl520_update_device(dev);
  175. u8 r = data->in_input[n];
  176. if (n == 0)
  177. return sprintf(buf, "%d\n", VDD_FROM_REG(r));
  178. else
  179. return sprintf(buf, "%d\n", IN_FROM_REG(r));
  180. }
  181. static ssize_t in_min_show(struct device *dev, struct device_attribute *attr,
  182. char *buf)
  183. {
  184. int n = to_sensor_dev_attr(attr)->index;
  185. struct gl520_data *data = gl520_update_device(dev);
  186. u8 r = data->in_min[n];
  187. if (n == 0)
  188. return sprintf(buf, "%d\n", VDD_FROM_REG(r));
  189. else
  190. return sprintf(buf, "%d\n", IN_FROM_REG(r));
  191. }
  192. static ssize_t in_max_show(struct device *dev, struct device_attribute *attr,
  193. char *buf)
  194. {
  195. int n = to_sensor_dev_attr(attr)->index;
  196. struct gl520_data *data = gl520_update_device(dev);
  197. u8 r = data->in_max[n];
  198. if (n == 0)
  199. return sprintf(buf, "%d\n", VDD_FROM_REG(r));
  200. else
  201. return sprintf(buf, "%d\n", IN_FROM_REG(r));
  202. }
  203. static ssize_t in_min_store(struct device *dev, struct device_attribute *attr,
  204. const char *buf, size_t count)
  205. {
  206. struct gl520_data *data = dev_get_drvdata(dev);
  207. struct i2c_client *client = data->client;
  208. int n = to_sensor_dev_attr(attr)->index;
  209. u8 r;
  210. long v;
  211. int err;
  212. err = kstrtol(buf, 10, &v);
  213. if (err)
  214. return err;
  215. mutex_lock(&data->update_lock);
  216. if (n == 0)
  217. r = VDD_TO_REG(v);
  218. else
  219. r = IN_TO_REG(v);
  220. data->in_min[n] = r;
  221. if (n < 4)
  222. gl520_write_value(client, GL520_REG_IN_MIN[n],
  223. (gl520_read_value(client, GL520_REG_IN_MIN[n])
  224. & ~0xff) | r);
  225. else
  226. gl520_write_value(client, GL520_REG_IN_MIN[n], r);
  227. mutex_unlock(&data->update_lock);
  228. return count;
  229. }
  230. static ssize_t in_max_store(struct device *dev, struct device_attribute *attr,
  231. const char *buf, size_t count)
  232. {
  233. struct gl520_data *data = dev_get_drvdata(dev);
  234. struct i2c_client *client = data->client;
  235. int n = to_sensor_dev_attr(attr)->index;
  236. u8 r;
  237. long v;
  238. int err;
  239. err = kstrtol(buf, 10, &v);
  240. if (err)
  241. return err;
  242. if (n == 0)
  243. r = VDD_TO_REG(v);
  244. else
  245. r = IN_TO_REG(v);
  246. mutex_lock(&data->update_lock);
  247. data->in_max[n] = r;
  248. if (n < 4)
  249. gl520_write_value(client, GL520_REG_IN_MAX[n],
  250. (gl520_read_value(client, GL520_REG_IN_MAX[n])
  251. & ~0xff00) | (r << 8));
  252. else
  253. gl520_write_value(client, GL520_REG_IN_MAX[n], r);
  254. mutex_unlock(&data->update_lock);
  255. return count;
  256. }
  257. static SENSOR_DEVICE_ATTR_RO(in0_input, in_input, 0);
  258. static SENSOR_DEVICE_ATTR_RO(in1_input, in_input, 1);
  259. static SENSOR_DEVICE_ATTR_RO(in2_input, in_input, 2);
  260. static SENSOR_DEVICE_ATTR_RO(in3_input, in_input, 3);
  261. static SENSOR_DEVICE_ATTR_RO(in4_input, in_input, 4);
  262. static SENSOR_DEVICE_ATTR_RW(in0_min, in_min, 0);
  263. static SENSOR_DEVICE_ATTR_RW(in1_min, in_min, 1);
  264. static SENSOR_DEVICE_ATTR_RW(in2_min, in_min, 2);
  265. static SENSOR_DEVICE_ATTR_RW(in3_min, in_min, 3);
  266. static SENSOR_DEVICE_ATTR_RW(in4_min, in_min, 4);
  267. static SENSOR_DEVICE_ATTR_RW(in0_max, in_max, 0);
  268. static SENSOR_DEVICE_ATTR_RW(in1_max, in_max, 1);
  269. static SENSOR_DEVICE_ATTR_RW(in2_max, in_max, 2);
  270. static SENSOR_DEVICE_ATTR_RW(in3_max, in_max, 3);
  271. static SENSOR_DEVICE_ATTR_RW(in4_max, in_max, 4);
  272. #define DIV_FROM_REG(val) (1 << (val))
  273. #define FAN_FROM_REG(val, div) ((val) == 0 ? 0 : (480000 / ((val) << (div))))
  274. #define FAN_BASE(div) (480000 >> (div))
  275. #define FAN_CLAMP(val, div) clamp_val(val, FAN_BASE(div) / 255, \
  276. FAN_BASE(div))
  277. #define FAN_TO_REG(val, div) ((val) == 0 ? 0 : \
  278. DIV_ROUND_CLOSEST(480000, \
  279. FAN_CLAMP(val, div) << (div)))
  280. static ssize_t fan_input_show(struct device *dev,
  281. struct device_attribute *attr, char *buf)
  282. {
  283. int n = to_sensor_dev_attr(attr)->index;
  284. struct gl520_data *data = gl520_update_device(dev);
  285. return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_input[n],
  286. data->fan_div[n]));
  287. }
  288. static ssize_t fan_min_show(struct device *dev, struct device_attribute *attr,
  289. char *buf)
  290. {
  291. int n = to_sensor_dev_attr(attr)->index;
  292. struct gl520_data *data = gl520_update_device(dev);
  293. return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[n],
  294. data->fan_div[n]));
  295. }
  296. static ssize_t fan_div_show(struct device *dev, struct device_attribute *attr,
  297. char *buf)
  298. {
  299. int n = to_sensor_dev_attr(attr)->index;
  300. struct gl520_data *data = gl520_update_device(dev);
  301. return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[n]));
  302. }
  303. static ssize_t fan1_off_show(struct device *dev,
  304. struct device_attribute *attr, char *buf)
  305. {
  306. struct gl520_data *data = gl520_update_device(dev);
  307. return sprintf(buf, "%d\n", data->fan_off);
  308. }
  309. static ssize_t fan_min_store(struct device *dev,
  310. struct device_attribute *attr, const char *buf,
  311. size_t count)
  312. {
  313. struct gl520_data *data = dev_get_drvdata(dev);
  314. struct i2c_client *client = data->client;
  315. int n = to_sensor_dev_attr(attr)->index;
  316. u8 r;
  317. unsigned long v;
  318. int err;
  319. err = kstrtoul(buf, 10, &v);
  320. if (err)
  321. return err;
  322. mutex_lock(&data->update_lock);
  323. r = FAN_TO_REG(v, data->fan_div[n]);
  324. data->fan_min[n] = r;
  325. if (n == 0)
  326. gl520_write_value(client, GL520_REG_FAN_MIN,
  327. (gl520_read_value(client, GL520_REG_FAN_MIN)
  328. & ~0xff00) | (r << 8));
  329. else
  330. gl520_write_value(client, GL520_REG_FAN_MIN,
  331. (gl520_read_value(client, GL520_REG_FAN_MIN)
  332. & ~0xff) | r);
  333. data->beep_mask = gl520_read_value(client, GL520_REG_BEEP_MASK);
  334. if (data->fan_min[n] == 0)
  335. data->alarm_mask &= (n == 0) ? ~0x20 : ~0x40;
  336. else
  337. data->alarm_mask |= (n == 0) ? 0x20 : 0x40;
  338. data->beep_mask &= data->alarm_mask;
  339. gl520_write_value(client, GL520_REG_BEEP_MASK, data->beep_mask);
  340. mutex_unlock(&data->update_lock);
  341. return count;
  342. }
  343. static ssize_t fan_div_store(struct device *dev,
  344. struct device_attribute *attr, const char *buf,
  345. size_t count)
  346. {
  347. struct gl520_data *data = dev_get_drvdata(dev);
  348. struct i2c_client *client = data->client;
  349. int n = to_sensor_dev_attr(attr)->index;
  350. u8 r;
  351. unsigned long v;
  352. int err;
  353. err = kstrtoul(buf, 10, &v);
  354. if (err)
  355. return err;
  356. switch (v) {
  357. case 1:
  358. r = 0;
  359. break;
  360. case 2:
  361. r = 1;
  362. break;
  363. case 4:
  364. r = 2;
  365. break;
  366. case 8:
  367. r = 3;
  368. break;
  369. default:
  370. dev_err(&client->dev,
  371. "fan_div value %ld not supported. Choose one of 1, 2, 4 or 8!\n", v);
  372. return -EINVAL;
  373. }
  374. mutex_lock(&data->update_lock);
  375. data->fan_div[n] = r;
  376. if (n == 0)
  377. gl520_write_value(client, GL520_REG_FAN_DIV,
  378. (gl520_read_value(client, GL520_REG_FAN_DIV)
  379. & ~0xc0) | (r << 6));
  380. else
  381. gl520_write_value(client, GL520_REG_FAN_DIV,
  382. (gl520_read_value(client, GL520_REG_FAN_DIV)
  383. & ~0x30) | (r << 4));
  384. mutex_unlock(&data->update_lock);
  385. return count;
  386. }
  387. static ssize_t fan1_off_store(struct device *dev,
  388. struct device_attribute *attr, const char *buf,
  389. size_t count)
  390. {
  391. struct gl520_data *data = dev_get_drvdata(dev);
  392. struct i2c_client *client = data->client;
  393. u8 r;
  394. unsigned long v;
  395. int err;
  396. err = kstrtoul(buf, 10, &v);
  397. if (err)
  398. return err;
  399. r = (v ? 1 : 0);
  400. mutex_lock(&data->update_lock);
  401. data->fan_off = r;
  402. gl520_write_value(client, GL520_REG_FAN_OFF,
  403. (gl520_read_value(client, GL520_REG_FAN_OFF)
  404. & ~0x0c) | (r << 2));
  405. mutex_unlock(&data->update_lock);
  406. return count;
  407. }
  408. static SENSOR_DEVICE_ATTR_RO(fan1_input, fan_input, 0);
  409. static SENSOR_DEVICE_ATTR_RO(fan2_input, fan_input, 1);
  410. static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);
  411. static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
  412. static SENSOR_DEVICE_ATTR_RW(fan1_div, fan_div, 0);
  413. static SENSOR_DEVICE_ATTR_RW(fan2_div, fan_div, 1);
  414. static DEVICE_ATTR_RW(fan1_off);
  415. #define TEMP_FROM_REG(val) (((val) - 130) * 1000)
  416. #define TEMP_CLAMP(val) clamp_val(val, -130000, 125000)
  417. #define TEMP_TO_REG(val) (DIV_ROUND_CLOSEST(TEMP_CLAMP(val), 1000) + 130)
  418. static ssize_t temp_input_show(struct device *dev,
  419. struct device_attribute *attr, char *buf)
  420. {
  421. int n = to_sensor_dev_attr(attr)->index;
  422. struct gl520_data *data = gl520_update_device(dev);
  423. return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_input[n]));
  424. }
  425. static ssize_t temp_max_show(struct device *dev,
  426. struct device_attribute *attr, char *buf)
  427. {
  428. int n = to_sensor_dev_attr(attr)->index;
  429. struct gl520_data *data = gl520_update_device(dev);
  430. return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[n]));
  431. }
  432. static ssize_t temp_max_hyst_show(struct device *dev,
  433. struct device_attribute *attr, char *buf)
  434. {
  435. int n = to_sensor_dev_attr(attr)->index;
  436. struct gl520_data *data = gl520_update_device(dev);
  437. return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max_hyst[n]));
  438. }
  439. static ssize_t temp_max_store(struct device *dev,
  440. struct device_attribute *attr, const char *buf,
  441. size_t count)
  442. {
  443. struct gl520_data *data = dev_get_drvdata(dev);
  444. struct i2c_client *client = data->client;
  445. int n = to_sensor_dev_attr(attr)->index;
  446. long v;
  447. int err;
  448. err = kstrtol(buf, 10, &v);
  449. if (err)
  450. return err;
  451. mutex_lock(&data->update_lock);
  452. data->temp_max[n] = TEMP_TO_REG(v);
  453. gl520_write_value(client, GL520_REG_TEMP_MAX[n], data->temp_max[n]);
  454. mutex_unlock(&data->update_lock);
  455. return count;
  456. }
  457. static ssize_t temp_max_hyst_store(struct device *dev,
  458. struct device_attribute *attr,
  459. const char *buf, size_t count)
  460. {
  461. struct gl520_data *data = dev_get_drvdata(dev);
  462. struct i2c_client *client = data->client;
  463. int n = to_sensor_dev_attr(attr)->index;
  464. long v;
  465. int err;
  466. err = kstrtol(buf, 10, &v);
  467. if (err)
  468. return err;
  469. mutex_lock(&data->update_lock);
  470. data->temp_max_hyst[n] = TEMP_TO_REG(v);
  471. gl520_write_value(client, GL520_REG_TEMP_MAX_HYST[n],
  472. data->temp_max_hyst[n]);
  473. mutex_unlock(&data->update_lock);
  474. return count;
  475. }
  476. static SENSOR_DEVICE_ATTR_RO(temp1_input, temp_input, 0);
  477. static SENSOR_DEVICE_ATTR_RO(temp2_input, temp_input, 1);
  478. static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0);
  479. static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);
  480. static SENSOR_DEVICE_ATTR_RW(temp1_max_hyst, temp_max_hyst, 0);
  481. static SENSOR_DEVICE_ATTR_RW(temp2_max_hyst, temp_max_hyst, 1);
  482. static ssize_t alarms_show(struct device *dev, struct device_attribute *attr,
  483. char *buf)
  484. {
  485. struct gl520_data *data = gl520_update_device(dev);
  486. return sprintf(buf, "%d\n", data->alarms);
  487. }
  488. static ssize_t beep_enable_show(struct device *dev,
  489. struct device_attribute *attr, char *buf)
  490. {
  491. struct gl520_data *data = gl520_update_device(dev);
  492. return sprintf(buf, "%d\n", data->beep_enable);
  493. }
  494. static ssize_t beep_mask_show(struct device *dev,
  495. struct device_attribute *attr, char *buf)
  496. {
  497. struct gl520_data *data = gl520_update_device(dev);
  498. return sprintf(buf, "%d\n", data->beep_mask);
  499. }
  500. static ssize_t beep_enable_store(struct device *dev,
  501. struct device_attribute *attr,
  502. const char *buf, size_t count)
  503. {
  504. struct gl520_data *data = dev_get_drvdata(dev);
  505. struct i2c_client *client = data->client;
  506. u8 r;
  507. unsigned long v;
  508. int err;
  509. err = kstrtoul(buf, 10, &v);
  510. if (err)
  511. return err;
  512. r = (v ? 0 : 1);
  513. mutex_lock(&data->update_lock);
  514. data->beep_enable = !r;
  515. gl520_write_value(client, GL520_REG_BEEP_ENABLE,
  516. (gl520_read_value(client, GL520_REG_BEEP_ENABLE)
  517. & ~0x04) | (r << 2));
  518. mutex_unlock(&data->update_lock);
  519. return count;
  520. }
  521. static ssize_t beep_mask_store(struct device *dev,
  522. struct device_attribute *attr, const char *buf,
  523. size_t count)
  524. {
  525. struct gl520_data *data = dev_get_drvdata(dev);
  526. struct i2c_client *client = data->client;
  527. unsigned long r;
  528. int err;
  529. err = kstrtoul(buf, 10, &r);
  530. if (err)
  531. return err;
  532. mutex_lock(&data->update_lock);
  533. r &= data->alarm_mask;
  534. data->beep_mask = r;
  535. gl520_write_value(client, GL520_REG_BEEP_MASK, r);
  536. mutex_unlock(&data->update_lock);
  537. return count;
  538. }
  539. static DEVICE_ATTR_RO(alarms);
  540. static DEVICE_ATTR_RW(beep_enable);
  541. static DEVICE_ATTR_RW(beep_mask);
  542. static ssize_t alarm_show(struct device *dev, struct device_attribute *attr,
  543. char *buf)
  544. {
  545. int bit_nr = to_sensor_dev_attr(attr)->index;
  546. struct gl520_data *data = gl520_update_device(dev);
  547. return sprintf(buf, "%d\n", (data->alarms >> bit_nr) & 1);
  548. }
  549. static SENSOR_DEVICE_ATTR_RO(in0_alarm, alarm, 0);
  550. static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm, 1);
  551. static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm, 2);
  552. static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm, 3);
  553. static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm, 4);
  554. static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm, 5);
  555. static SENSOR_DEVICE_ATTR_RO(fan2_alarm, alarm, 6);
  556. static SENSOR_DEVICE_ATTR_RO(temp2_alarm, alarm, 7);
  557. static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm, 7);
  558. static ssize_t beep_show(struct device *dev, struct device_attribute *attr,
  559. char *buf)
  560. {
  561. int bitnr = to_sensor_dev_attr(attr)->index;
  562. struct gl520_data *data = gl520_update_device(dev);
  563. return sprintf(buf, "%d\n", (data->beep_mask >> bitnr) & 1);
  564. }
  565. static ssize_t beep_store(struct device *dev, struct device_attribute *attr,
  566. const char *buf, size_t count)
  567. {
  568. struct gl520_data *data = dev_get_drvdata(dev);
  569. struct i2c_client *client = data->client;
  570. int bitnr = to_sensor_dev_attr(attr)->index;
  571. unsigned long bit;
  572. int err;
  573. err = kstrtoul(buf, 10, &bit);
  574. if (err)
  575. return err;
  576. if (bit & ~1)
  577. return -EINVAL;
  578. mutex_lock(&data->update_lock);
  579. data->beep_mask = gl520_read_value(client, GL520_REG_BEEP_MASK);
  580. if (bit)
  581. data->beep_mask |= (1 << bitnr);
  582. else
  583. data->beep_mask &= ~(1 << bitnr);
  584. gl520_write_value(client, GL520_REG_BEEP_MASK, data->beep_mask);
  585. mutex_unlock(&data->update_lock);
  586. return count;
  587. }
  588. static SENSOR_DEVICE_ATTR_RW(in0_beep, beep, 0);
  589. static SENSOR_DEVICE_ATTR_RW(in1_beep, beep, 1);
  590. static SENSOR_DEVICE_ATTR_RW(in2_beep, beep, 2);
  591. static SENSOR_DEVICE_ATTR_RW(in3_beep, beep, 3);
  592. static SENSOR_DEVICE_ATTR_RW(temp1_beep, beep, 4);
  593. static SENSOR_DEVICE_ATTR_RW(fan1_beep, beep, 5);
  594. static SENSOR_DEVICE_ATTR_RW(fan2_beep, beep, 6);
  595. static SENSOR_DEVICE_ATTR_RW(temp2_beep, beep, 7);
  596. static SENSOR_DEVICE_ATTR_RW(in4_beep, beep, 7);
  597. static struct attribute *gl520_attributes[] = {
  598. &dev_attr_cpu0_vid.attr,
  599. &sensor_dev_attr_in0_input.dev_attr.attr,
  600. &sensor_dev_attr_in0_min.dev_attr.attr,
  601. &sensor_dev_attr_in0_max.dev_attr.attr,
  602. &sensor_dev_attr_in0_alarm.dev_attr.attr,
  603. &sensor_dev_attr_in0_beep.dev_attr.attr,
  604. &sensor_dev_attr_in1_input.dev_attr.attr,
  605. &sensor_dev_attr_in1_min.dev_attr.attr,
  606. &sensor_dev_attr_in1_max.dev_attr.attr,
  607. &sensor_dev_attr_in1_alarm.dev_attr.attr,
  608. &sensor_dev_attr_in1_beep.dev_attr.attr,
  609. &sensor_dev_attr_in2_input.dev_attr.attr,
  610. &sensor_dev_attr_in2_min.dev_attr.attr,
  611. &sensor_dev_attr_in2_max.dev_attr.attr,
  612. &sensor_dev_attr_in2_alarm.dev_attr.attr,
  613. &sensor_dev_attr_in2_beep.dev_attr.attr,
  614. &sensor_dev_attr_in3_input.dev_attr.attr,
  615. &sensor_dev_attr_in3_min.dev_attr.attr,
  616. &sensor_dev_attr_in3_max.dev_attr.attr,
  617. &sensor_dev_attr_in3_alarm.dev_attr.attr,
  618. &sensor_dev_attr_in3_beep.dev_attr.attr,
  619. &sensor_dev_attr_fan1_input.dev_attr.attr,
  620. &sensor_dev_attr_fan1_min.dev_attr.attr,
  621. &sensor_dev_attr_fan1_div.dev_attr.attr,
  622. &sensor_dev_attr_fan1_alarm.dev_attr.attr,
  623. &sensor_dev_attr_fan1_beep.dev_attr.attr,
  624. &dev_attr_fan1_off.attr,
  625. &sensor_dev_attr_fan2_input.dev_attr.attr,
  626. &sensor_dev_attr_fan2_min.dev_attr.attr,
  627. &sensor_dev_attr_fan2_div.dev_attr.attr,
  628. &sensor_dev_attr_fan2_alarm.dev_attr.attr,
  629. &sensor_dev_attr_fan2_beep.dev_attr.attr,
  630. &sensor_dev_attr_temp1_input.dev_attr.attr,
  631. &sensor_dev_attr_temp1_max.dev_attr.attr,
  632. &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
  633. &sensor_dev_attr_temp1_alarm.dev_attr.attr,
  634. &sensor_dev_attr_temp1_beep.dev_attr.attr,
  635. &dev_attr_alarms.attr,
  636. &dev_attr_beep_enable.attr,
  637. &dev_attr_beep_mask.attr,
  638. NULL
  639. };
  640. static const struct attribute_group gl520_group = {
  641. .attrs = gl520_attributes,
  642. };
  643. static struct attribute *gl520_attributes_in4[] = {
  644. &sensor_dev_attr_in4_input.dev_attr.attr,
  645. &sensor_dev_attr_in4_min.dev_attr.attr,
  646. &sensor_dev_attr_in4_max.dev_attr.attr,
  647. &sensor_dev_attr_in4_alarm.dev_attr.attr,
  648. &sensor_dev_attr_in4_beep.dev_attr.attr,
  649. NULL
  650. };
  651. static struct attribute *gl520_attributes_temp2[] = {
  652. &sensor_dev_attr_temp2_input.dev_attr.attr,
  653. &sensor_dev_attr_temp2_max.dev_attr.attr,
  654. &sensor_dev_attr_temp2_max_hyst.dev_attr.attr,
  655. &sensor_dev_attr_temp2_alarm.dev_attr.attr,
  656. &sensor_dev_attr_temp2_beep.dev_attr.attr,
  657. NULL
  658. };
  659. static const struct attribute_group gl520_group_in4 = {
  660. .attrs = gl520_attributes_in4,
  661. };
  662. static const struct attribute_group gl520_group_temp2 = {
  663. .attrs = gl520_attributes_temp2,
  664. };
  665. /*
  666. * Real code
  667. */
  668. /* Return 0 if detection is successful, -ENODEV otherwise */
  669. static int gl520_detect(struct i2c_client *client, struct i2c_board_info *info)
  670. {
  671. struct i2c_adapter *adapter = client->adapter;
  672. if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
  673. I2C_FUNC_SMBUS_WORD_DATA))
  674. return -ENODEV;
  675. /* Determine the chip type. */
  676. if ((gl520_read_value(client, GL520_REG_CHIP_ID) != 0x20) ||
  677. ((gl520_read_value(client, GL520_REG_REVISION) & 0x7f) != 0x00) ||
  678. ((gl520_read_value(client, GL520_REG_CONF) & 0x80) != 0x00)) {
  679. dev_dbg(&client->dev, "Unknown chip type, skipping\n");
  680. return -ENODEV;
  681. }
  682. strlcpy(info->type, "gl520sm", I2C_NAME_SIZE);
  683. return 0;
  684. }
  685. /* Called when we have found a new GL520SM. */
  686. static void gl520_init_client(struct i2c_client *client)
  687. {
  688. struct gl520_data *data = i2c_get_clientdata(client);
  689. u8 oldconf, conf;
  690. conf = oldconf = gl520_read_value(client, GL520_REG_CONF);
  691. data->alarm_mask = 0xff;
  692. data->vrm = vid_which_vrm();
  693. if (extra_sensor_type == 1)
  694. conf &= ~0x10;
  695. else if (extra_sensor_type == 2)
  696. conf |= 0x10;
  697. data->two_temps = !(conf & 0x10);
  698. /* If IRQ# is disabled, we can safely force comparator mode */
  699. if (!(conf & 0x20))
  700. conf &= 0xf7;
  701. /* Enable monitoring if needed */
  702. conf |= 0x40;
  703. if (conf != oldconf)
  704. gl520_write_value(client, GL520_REG_CONF, conf);
  705. gl520_update_device(&(client->dev));
  706. if (data->fan_min[0] == 0)
  707. data->alarm_mask &= ~0x20;
  708. if (data->fan_min[1] == 0)
  709. data->alarm_mask &= ~0x40;
  710. data->beep_mask &= data->alarm_mask;
  711. gl520_write_value(client, GL520_REG_BEEP_MASK, data->beep_mask);
  712. }
  713. static int gl520_probe(struct i2c_client *client)
  714. {
  715. struct device *dev = &client->dev;
  716. struct device *hwmon_dev;
  717. struct gl520_data *data;
  718. data = devm_kzalloc(dev, sizeof(struct gl520_data), GFP_KERNEL);
  719. if (!data)
  720. return -ENOMEM;
  721. i2c_set_clientdata(client, data);
  722. mutex_init(&data->update_lock);
  723. data->client = client;
  724. /* Initialize the GL520SM chip */
  725. gl520_init_client(client);
  726. /* sysfs hooks */
  727. data->groups[0] = &gl520_group;
  728. if (data->two_temps)
  729. data->groups[1] = &gl520_group_temp2;
  730. else
  731. data->groups[1] = &gl520_group_in4;
  732. hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
  733. data, data->groups);
  734. return PTR_ERR_OR_ZERO(hwmon_dev);
  735. }
  736. static const struct i2c_device_id gl520_id[] = {
  737. { "gl520sm", 0 },
  738. { }
  739. };
  740. MODULE_DEVICE_TABLE(i2c, gl520_id);
  741. static struct i2c_driver gl520_driver = {
  742. .class = I2C_CLASS_HWMON,
  743. .driver = {
  744. .name = "gl520sm",
  745. },
  746. .probe_new = gl520_probe,
  747. .id_table = gl520_id,
  748. .detect = gl520_detect,
  749. .address_list = normal_i2c,
  750. };
  751. module_i2c_driver(gl520_driver);
  752. MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, "
  753. "Kyösti Mälkki <kmalkki@cc.hut.fi>, "
  754. "Maarten Deprez <maartendeprez@users.sourceforge.net>");
  755. MODULE_DESCRIPTION("GL520SM driver");
  756. MODULE_LICENSE("GPL");