asb100.c 27 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * asb100.c - Part of lm_sensors, Linux kernel modules for hardware
  4. * monitoring
  5. *
  6. * Copyright (C) 2004 Mark M. Hoffman <[email protected]>
  7. *
  8. * (derived from w83781d.c)
  9. *
  10. * Copyright (C) 1998 - 2003 Frodo Looijaard <[email protected]>,
  11. * Philip Edelbrock <[email protected]>, and
  12. * Mark Studebaker <[email protected]>
  13. */
  14. /*
  15. * This driver supports the hardware sensor chips: Asus ASB100 and
  16. * ASB100-A "BACH".
  17. *
  18. * ASB100-A supports pwm1, while plain ASB100 does not. There is no known
  19. * way for the driver to tell which one is there.
  20. *
  21. * Chip #vin #fanin #pwm #temp wchipid vendid i2c ISA
  22. * asb100 7 3 1 4 0x31 0x0694 yes no
  23. */
  24. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  25. #include <linux/module.h>
  26. #include <linux/slab.h>
  27. #include <linux/i2c.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/init.h>
  33. #include <linux/jiffies.h>
  34. #include <linux/mutex.h>
  35. #include "lm75.h"
  36. /* I2C addresses to scan */
  37. static const unsigned short normal_i2c[] = { 0x2d, I2C_CLIENT_END };
  38. static unsigned short force_subclients[4];
  39. module_param_array(force_subclients, short, NULL, 0);
  40. MODULE_PARM_DESC(force_subclients,
  41. "List of subclient addresses: {bus, clientaddr, subclientaddr1, subclientaddr2}");
  42. /* Voltage IN registers 0-6 */
  43. #define ASB100_REG_IN(nr) (0x20 + (nr))
  44. #define ASB100_REG_IN_MAX(nr) (0x2b + (nr * 2))
  45. #define ASB100_REG_IN_MIN(nr) (0x2c + (nr * 2))
  46. /* FAN IN registers 1-3 */
  47. #define ASB100_REG_FAN(nr) (0x28 + (nr))
  48. #define ASB100_REG_FAN_MIN(nr) (0x3b + (nr))
  49. /* TEMPERATURE registers 1-4 */
  50. static const u16 asb100_reg_temp[] = {0, 0x27, 0x150, 0x250, 0x17};
  51. static const u16 asb100_reg_temp_max[] = {0, 0x39, 0x155, 0x255, 0x18};
  52. static const u16 asb100_reg_temp_hyst[] = {0, 0x3a, 0x153, 0x253, 0x19};
  53. #define ASB100_REG_TEMP(nr) (asb100_reg_temp[nr])
  54. #define ASB100_REG_TEMP_MAX(nr) (asb100_reg_temp_max[nr])
  55. #define ASB100_REG_TEMP_HYST(nr) (asb100_reg_temp_hyst[nr])
  56. #define ASB100_REG_TEMP2_CONFIG 0x0152
  57. #define ASB100_REG_TEMP3_CONFIG 0x0252
  58. #define ASB100_REG_CONFIG 0x40
  59. #define ASB100_REG_ALARM1 0x41
  60. #define ASB100_REG_ALARM2 0x42
  61. #define ASB100_REG_SMIM1 0x43
  62. #define ASB100_REG_SMIM2 0x44
  63. #define ASB100_REG_VID_FANDIV 0x47
  64. #define ASB100_REG_I2C_ADDR 0x48
  65. #define ASB100_REG_CHIPID 0x49
  66. #define ASB100_REG_I2C_SUBADDR 0x4a
  67. #define ASB100_REG_PIN 0x4b
  68. #define ASB100_REG_IRQ 0x4c
  69. #define ASB100_REG_BANK 0x4e
  70. #define ASB100_REG_CHIPMAN 0x4f
  71. #define ASB100_REG_WCHIPID 0x58
  72. /* bit 7 -> enable, bits 0-3 -> duty cycle */
  73. #define ASB100_REG_PWM1 0x59
  74. /*
  75. * CONVERSIONS
  76. * Rounding and limit checking is only done on the TO_REG variants.
  77. */
  78. /* These constants are a guess, consistent w/ w83781d */
  79. #define ASB100_IN_MIN 0
  80. #define ASB100_IN_MAX 4080
  81. /*
  82. * IN: 1/1000 V (0V to 4.08V)
  83. * REG: 16mV/bit
  84. */
  85. static u8 IN_TO_REG(unsigned val)
  86. {
  87. unsigned nval = clamp_val(val, ASB100_IN_MIN, ASB100_IN_MAX);
  88. return (nval + 8) / 16;
  89. }
  90. static unsigned IN_FROM_REG(u8 reg)
  91. {
  92. return reg * 16;
  93. }
  94. static u8 FAN_TO_REG(long rpm, int div)
  95. {
  96. if (rpm == -1)
  97. return 0;
  98. if (rpm == 0)
  99. return 255;
  100. rpm = clamp_val(rpm, 1, 1000000);
  101. return clamp_val((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
  102. }
  103. static int FAN_FROM_REG(u8 val, int div)
  104. {
  105. return val == 0 ? -1 : val == 255 ? 0 : 1350000 / (val * div);
  106. }
  107. /* These constants are a guess, consistent w/ w83781d */
  108. #define ASB100_TEMP_MIN -128000
  109. #define ASB100_TEMP_MAX 127000
  110. /*
  111. * TEMP: 0.001C/bit (-128C to +127C)
  112. * REG: 1C/bit, two's complement
  113. */
  114. static u8 TEMP_TO_REG(long temp)
  115. {
  116. int ntemp = clamp_val(temp, ASB100_TEMP_MIN, ASB100_TEMP_MAX);
  117. ntemp += (ntemp < 0 ? -500 : 500);
  118. return (u8)(ntemp / 1000);
  119. }
  120. static int TEMP_FROM_REG(u8 reg)
  121. {
  122. return (s8)reg * 1000;
  123. }
  124. /*
  125. * PWM: 0 - 255 per sensors documentation
  126. * REG: (6.25% duty cycle per bit)
  127. */
  128. static u8 ASB100_PWM_TO_REG(int pwm)
  129. {
  130. pwm = clamp_val(pwm, 0, 255);
  131. return (u8)(pwm / 16);
  132. }
  133. static int ASB100_PWM_FROM_REG(u8 reg)
  134. {
  135. return reg * 16;
  136. }
  137. #define DIV_FROM_REG(val) (1 << (val))
  138. /*
  139. * FAN DIV: 1, 2, 4, or 8 (defaults to 2)
  140. * REG: 0, 1, 2, or 3 (respectively) (defaults to 1)
  141. */
  142. static u8 DIV_TO_REG(long val)
  143. {
  144. return val == 8 ? 3 : val == 4 ? 2 : val == 1 ? 0 : 1;
  145. }
  146. /*
  147. * For each registered client, we need to keep some data in memory. That
  148. * data is pointed to by client->data. The structure itself is
  149. * dynamically allocated, at the same time the client itself is allocated.
  150. */
  151. struct asb100_data {
  152. struct device *hwmon_dev;
  153. struct mutex lock;
  154. struct mutex update_lock;
  155. unsigned long last_updated; /* In jiffies */
  156. /* array of 2 pointers to subclients */
  157. struct i2c_client *lm75[2];
  158. bool valid; /* true if following fields are valid */
  159. u8 in[7]; /* Register value */
  160. u8 in_max[7]; /* Register value */
  161. u8 in_min[7]; /* Register value */
  162. u8 fan[3]; /* Register value */
  163. u8 fan_min[3]; /* Register value */
  164. u16 temp[4]; /* Register value (0 and 3 are u8 only) */
  165. u16 temp_max[4]; /* Register value (0 and 3 are u8 only) */
  166. u16 temp_hyst[4]; /* Register value (0 and 3 are u8 only) */
  167. u8 fan_div[3]; /* Register encoding, right justified */
  168. u8 pwm; /* Register encoding */
  169. u8 vid; /* Register encoding, combined */
  170. u32 alarms; /* Register encoding, combined */
  171. u8 vrm;
  172. };
  173. static int asb100_read_value(struct i2c_client *client, u16 reg);
  174. static void asb100_write_value(struct i2c_client *client, u16 reg, u16 val);
  175. static int asb100_probe(struct i2c_client *client);
  176. static int asb100_detect(struct i2c_client *client,
  177. struct i2c_board_info *info);
  178. static void asb100_remove(struct i2c_client *client);
  179. static struct asb100_data *asb100_update_device(struct device *dev);
  180. static void asb100_init_client(struct i2c_client *client);
  181. static const struct i2c_device_id asb100_id[] = {
  182. { "asb100", 0 },
  183. { }
  184. };
  185. MODULE_DEVICE_TABLE(i2c, asb100_id);
  186. static struct i2c_driver asb100_driver = {
  187. .class = I2C_CLASS_HWMON,
  188. .driver = {
  189. .name = "asb100",
  190. },
  191. .probe_new = asb100_probe,
  192. .remove = asb100_remove,
  193. .id_table = asb100_id,
  194. .detect = asb100_detect,
  195. .address_list = normal_i2c,
  196. };
  197. /* 7 Voltages */
  198. #define show_in_reg(reg) \
  199. static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
  200. char *buf) \
  201. { \
  202. int nr = to_sensor_dev_attr(attr)->index; \
  203. struct asb100_data *data = asb100_update_device(dev); \
  204. return sprintf(buf, "%d\n", IN_FROM_REG(data->reg[nr])); \
  205. }
  206. show_in_reg(in)
  207. show_in_reg(in_min)
  208. show_in_reg(in_max)
  209. #define set_in_reg(REG, reg) \
  210. static ssize_t set_in_##reg(struct device *dev, struct device_attribute *attr, \
  211. const char *buf, size_t count) \
  212. { \
  213. int nr = to_sensor_dev_attr(attr)->index; \
  214. struct i2c_client *client = to_i2c_client(dev); \
  215. struct asb100_data *data = i2c_get_clientdata(client); \
  216. unsigned long val; \
  217. int err = kstrtoul(buf, 10, &val); \
  218. if (err) \
  219. return err; \
  220. mutex_lock(&data->update_lock); \
  221. data->in_##reg[nr] = IN_TO_REG(val); \
  222. asb100_write_value(client, ASB100_REG_IN_##REG(nr), \
  223. data->in_##reg[nr]); \
  224. mutex_unlock(&data->update_lock); \
  225. return count; \
  226. }
  227. set_in_reg(MIN, min)
  228. set_in_reg(MAX, max)
  229. #define sysfs_in(offset) \
  230. static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
  231. show_in, NULL, offset); \
  232. static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
  233. show_in_min, set_in_min, offset); \
  234. static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
  235. show_in_max, set_in_max, offset)
  236. sysfs_in(0);
  237. sysfs_in(1);
  238. sysfs_in(2);
  239. sysfs_in(3);
  240. sysfs_in(4);
  241. sysfs_in(5);
  242. sysfs_in(6);
  243. /* 3 Fans */
  244. static ssize_t show_fan(struct device *dev, struct device_attribute *attr,
  245. char *buf)
  246. {
  247. int nr = to_sensor_dev_attr(attr)->index;
  248. struct asb100_data *data = asb100_update_device(dev);
  249. return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
  250. DIV_FROM_REG(data->fan_div[nr])));
  251. }
  252. static ssize_t show_fan_min(struct device *dev, struct device_attribute *attr,
  253. char *buf)
  254. {
  255. int nr = to_sensor_dev_attr(attr)->index;
  256. struct asb100_data *data = asb100_update_device(dev);
  257. return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[nr],
  258. DIV_FROM_REG(data->fan_div[nr])));
  259. }
  260. static ssize_t show_fan_div(struct device *dev, struct device_attribute *attr,
  261. char *buf)
  262. {
  263. int nr = to_sensor_dev_attr(attr)->index;
  264. struct asb100_data *data = asb100_update_device(dev);
  265. return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]));
  266. }
  267. static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
  268. const char *buf, size_t count)
  269. {
  270. int nr = to_sensor_dev_attr(attr)->index;
  271. struct i2c_client *client = to_i2c_client(dev);
  272. struct asb100_data *data = i2c_get_clientdata(client);
  273. unsigned long val;
  274. int err;
  275. err = kstrtoul(buf, 10, &val);
  276. if (err)
  277. return err;
  278. mutex_lock(&data->update_lock);
  279. data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
  280. asb100_write_value(client, ASB100_REG_FAN_MIN(nr), data->fan_min[nr]);
  281. mutex_unlock(&data->update_lock);
  282. return count;
  283. }
  284. /*
  285. * Note: we save and restore the fan minimum here, because its value is
  286. * determined in part by the fan divisor. This follows the principle of
  287. * least surprise; the user doesn't expect the fan minimum to change just
  288. * because the divisor changed.
  289. */
  290. static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
  291. const char *buf, size_t count)
  292. {
  293. int nr = to_sensor_dev_attr(attr)->index;
  294. struct i2c_client *client = to_i2c_client(dev);
  295. struct asb100_data *data = i2c_get_clientdata(client);
  296. unsigned long min;
  297. int reg;
  298. unsigned long val;
  299. int err;
  300. err = kstrtoul(buf, 10, &val);
  301. if (err)
  302. return err;
  303. mutex_lock(&data->update_lock);
  304. min = FAN_FROM_REG(data->fan_min[nr],
  305. DIV_FROM_REG(data->fan_div[nr]));
  306. data->fan_div[nr] = DIV_TO_REG(val);
  307. switch (nr) {
  308. case 0: /* fan 1 */
  309. reg = asb100_read_value(client, ASB100_REG_VID_FANDIV);
  310. reg = (reg & 0xcf) | (data->fan_div[0] << 4);
  311. asb100_write_value(client, ASB100_REG_VID_FANDIV, reg);
  312. break;
  313. case 1: /* fan 2 */
  314. reg = asb100_read_value(client, ASB100_REG_VID_FANDIV);
  315. reg = (reg & 0x3f) | (data->fan_div[1] << 6);
  316. asb100_write_value(client, ASB100_REG_VID_FANDIV, reg);
  317. break;
  318. case 2: /* fan 3 */
  319. reg = asb100_read_value(client, ASB100_REG_PIN);
  320. reg = (reg & 0x3f) | (data->fan_div[2] << 6);
  321. asb100_write_value(client, ASB100_REG_PIN, reg);
  322. break;
  323. }
  324. data->fan_min[nr] =
  325. FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
  326. asb100_write_value(client, ASB100_REG_FAN_MIN(nr), data->fan_min[nr]);
  327. mutex_unlock(&data->update_lock);
  328. return count;
  329. }
  330. #define sysfs_fan(offset) \
  331. static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
  332. show_fan, NULL, offset - 1); \
  333. static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
  334. show_fan_min, set_fan_min, offset - 1); \
  335. static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
  336. show_fan_div, set_fan_div, offset - 1)
  337. sysfs_fan(1);
  338. sysfs_fan(2);
  339. sysfs_fan(3);
  340. /* 4 Temp. Sensors */
  341. static int sprintf_temp_from_reg(u16 reg, char *buf, int nr)
  342. {
  343. int ret = 0;
  344. switch (nr) {
  345. case 1: case 2:
  346. ret = sprintf(buf, "%d\n", LM75_TEMP_FROM_REG(reg));
  347. break;
  348. case 0: case 3: default:
  349. ret = sprintf(buf, "%d\n", TEMP_FROM_REG(reg));
  350. break;
  351. }
  352. return ret;
  353. }
  354. #define show_temp_reg(reg) \
  355. static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
  356. char *buf) \
  357. { \
  358. int nr = to_sensor_dev_attr(attr)->index; \
  359. struct asb100_data *data = asb100_update_device(dev); \
  360. return sprintf_temp_from_reg(data->reg[nr], buf, nr); \
  361. }
  362. show_temp_reg(temp);
  363. show_temp_reg(temp_max);
  364. show_temp_reg(temp_hyst);
  365. #define set_temp_reg(REG, reg) \
  366. static ssize_t set_##reg(struct device *dev, struct device_attribute *attr, \
  367. const char *buf, size_t count) \
  368. { \
  369. int nr = to_sensor_dev_attr(attr)->index; \
  370. struct i2c_client *client = to_i2c_client(dev); \
  371. struct asb100_data *data = i2c_get_clientdata(client); \
  372. long val; \
  373. int err = kstrtol(buf, 10, &val); \
  374. if (err) \
  375. return err; \
  376. mutex_lock(&data->update_lock); \
  377. switch (nr) { \
  378. case 1: case 2: \
  379. data->reg[nr] = LM75_TEMP_TO_REG(val); \
  380. break; \
  381. case 0: case 3: default: \
  382. data->reg[nr] = TEMP_TO_REG(val); \
  383. break; \
  384. } \
  385. asb100_write_value(client, ASB100_REG_TEMP_##REG(nr+1), \
  386. data->reg[nr]); \
  387. mutex_unlock(&data->update_lock); \
  388. return count; \
  389. }
  390. set_temp_reg(MAX, temp_max);
  391. set_temp_reg(HYST, temp_hyst);
  392. #define sysfs_temp(num) \
  393. static SENSOR_DEVICE_ATTR(temp##num##_input, S_IRUGO, \
  394. show_temp, NULL, num - 1); \
  395. static SENSOR_DEVICE_ATTR(temp##num##_max, S_IRUGO | S_IWUSR, \
  396. show_temp_max, set_temp_max, num - 1); \
  397. static SENSOR_DEVICE_ATTR(temp##num##_max_hyst, S_IRUGO | S_IWUSR, \
  398. show_temp_hyst, set_temp_hyst, num - 1)
  399. sysfs_temp(1);
  400. sysfs_temp(2);
  401. sysfs_temp(3);
  402. sysfs_temp(4);
  403. /* VID */
  404. static ssize_t cpu0_vid_show(struct device *dev,
  405. struct device_attribute *attr, char *buf)
  406. {
  407. struct asb100_data *data = asb100_update_device(dev);
  408. return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
  409. }
  410. static DEVICE_ATTR_RO(cpu0_vid);
  411. /* VRM */
  412. static ssize_t vrm_show(struct device *dev, struct device_attribute *attr,
  413. char *buf)
  414. {
  415. struct asb100_data *data = dev_get_drvdata(dev);
  416. return sprintf(buf, "%d\n", data->vrm);
  417. }
  418. static ssize_t vrm_store(struct device *dev, struct device_attribute *attr,
  419. const char *buf, size_t count)
  420. {
  421. struct asb100_data *data = dev_get_drvdata(dev);
  422. unsigned long val;
  423. int err;
  424. err = kstrtoul(buf, 10, &val);
  425. if (err)
  426. return err;
  427. if (val > 255)
  428. return -EINVAL;
  429. data->vrm = val;
  430. return count;
  431. }
  432. /* Alarms */
  433. static DEVICE_ATTR_RW(vrm);
  434. static ssize_t alarms_show(struct device *dev, struct device_attribute *attr,
  435. char *buf)
  436. {
  437. struct asb100_data *data = asb100_update_device(dev);
  438. return sprintf(buf, "%u\n", data->alarms);
  439. }
  440. static DEVICE_ATTR_RO(alarms);
  441. static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
  442. char *buf)
  443. {
  444. int bitnr = to_sensor_dev_attr(attr)->index;
  445. struct asb100_data *data = asb100_update_device(dev);
  446. return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
  447. }
  448. static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
  449. static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
  450. static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
  451. static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
  452. static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8);
  453. static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6);
  454. static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7);
  455. static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11);
  456. static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4);
  457. static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5);
  458. static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 13);
  459. /* 1 PWM */
  460. static ssize_t pwm1_show(struct device *dev, struct device_attribute *attr,
  461. char *buf)
  462. {
  463. struct asb100_data *data = asb100_update_device(dev);
  464. return sprintf(buf, "%d\n", ASB100_PWM_FROM_REG(data->pwm & 0x0f));
  465. }
  466. static ssize_t pwm1_store(struct device *dev, struct device_attribute *attr,
  467. const char *buf, size_t count)
  468. {
  469. struct i2c_client *client = to_i2c_client(dev);
  470. struct asb100_data *data = i2c_get_clientdata(client);
  471. unsigned long val;
  472. int err;
  473. err = kstrtoul(buf, 10, &val);
  474. if (err)
  475. return err;
  476. mutex_lock(&data->update_lock);
  477. data->pwm &= 0x80; /* keep the enable bit */
  478. data->pwm |= (0x0f & ASB100_PWM_TO_REG(val));
  479. asb100_write_value(client, ASB100_REG_PWM1, data->pwm);
  480. mutex_unlock(&data->update_lock);
  481. return count;
  482. }
  483. static ssize_t pwm1_enable_show(struct device *dev,
  484. struct device_attribute *attr, char *buf)
  485. {
  486. struct asb100_data *data = asb100_update_device(dev);
  487. return sprintf(buf, "%d\n", (data->pwm & 0x80) ? 1 : 0);
  488. }
  489. static ssize_t pwm1_enable_store(struct device *dev,
  490. struct device_attribute *attr,
  491. const char *buf, size_t count)
  492. {
  493. struct i2c_client *client = to_i2c_client(dev);
  494. struct asb100_data *data = i2c_get_clientdata(client);
  495. unsigned long val;
  496. int err;
  497. err = kstrtoul(buf, 10, &val);
  498. if (err)
  499. return err;
  500. mutex_lock(&data->update_lock);
  501. data->pwm &= 0x0f; /* keep the duty cycle bits */
  502. data->pwm |= (val ? 0x80 : 0x00);
  503. asb100_write_value(client, ASB100_REG_PWM1, data->pwm);
  504. mutex_unlock(&data->update_lock);
  505. return count;
  506. }
  507. static DEVICE_ATTR_RW(pwm1);
  508. static DEVICE_ATTR_RW(pwm1_enable);
  509. static struct attribute *asb100_attributes[] = {
  510. &sensor_dev_attr_in0_input.dev_attr.attr,
  511. &sensor_dev_attr_in0_min.dev_attr.attr,
  512. &sensor_dev_attr_in0_max.dev_attr.attr,
  513. &sensor_dev_attr_in1_input.dev_attr.attr,
  514. &sensor_dev_attr_in1_min.dev_attr.attr,
  515. &sensor_dev_attr_in1_max.dev_attr.attr,
  516. &sensor_dev_attr_in2_input.dev_attr.attr,
  517. &sensor_dev_attr_in2_min.dev_attr.attr,
  518. &sensor_dev_attr_in2_max.dev_attr.attr,
  519. &sensor_dev_attr_in3_input.dev_attr.attr,
  520. &sensor_dev_attr_in3_min.dev_attr.attr,
  521. &sensor_dev_attr_in3_max.dev_attr.attr,
  522. &sensor_dev_attr_in4_input.dev_attr.attr,
  523. &sensor_dev_attr_in4_min.dev_attr.attr,
  524. &sensor_dev_attr_in4_max.dev_attr.attr,
  525. &sensor_dev_attr_in5_input.dev_attr.attr,
  526. &sensor_dev_attr_in5_min.dev_attr.attr,
  527. &sensor_dev_attr_in5_max.dev_attr.attr,
  528. &sensor_dev_attr_in6_input.dev_attr.attr,
  529. &sensor_dev_attr_in6_min.dev_attr.attr,
  530. &sensor_dev_attr_in6_max.dev_attr.attr,
  531. &sensor_dev_attr_fan1_input.dev_attr.attr,
  532. &sensor_dev_attr_fan1_min.dev_attr.attr,
  533. &sensor_dev_attr_fan1_div.dev_attr.attr,
  534. &sensor_dev_attr_fan2_input.dev_attr.attr,
  535. &sensor_dev_attr_fan2_min.dev_attr.attr,
  536. &sensor_dev_attr_fan2_div.dev_attr.attr,
  537. &sensor_dev_attr_fan3_input.dev_attr.attr,
  538. &sensor_dev_attr_fan3_min.dev_attr.attr,
  539. &sensor_dev_attr_fan3_div.dev_attr.attr,
  540. &sensor_dev_attr_temp1_input.dev_attr.attr,
  541. &sensor_dev_attr_temp1_max.dev_attr.attr,
  542. &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
  543. &sensor_dev_attr_temp2_input.dev_attr.attr,
  544. &sensor_dev_attr_temp2_max.dev_attr.attr,
  545. &sensor_dev_attr_temp2_max_hyst.dev_attr.attr,
  546. &sensor_dev_attr_temp3_input.dev_attr.attr,
  547. &sensor_dev_attr_temp3_max.dev_attr.attr,
  548. &sensor_dev_attr_temp3_max_hyst.dev_attr.attr,
  549. &sensor_dev_attr_temp4_input.dev_attr.attr,
  550. &sensor_dev_attr_temp4_max.dev_attr.attr,
  551. &sensor_dev_attr_temp4_max_hyst.dev_attr.attr,
  552. &sensor_dev_attr_in0_alarm.dev_attr.attr,
  553. &sensor_dev_attr_in1_alarm.dev_attr.attr,
  554. &sensor_dev_attr_in2_alarm.dev_attr.attr,
  555. &sensor_dev_attr_in3_alarm.dev_attr.attr,
  556. &sensor_dev_attr_in4_alarm.dev_attr.attr,
  557. &sensor_dev_attr_fan1_alarm.dev_attr.attr,
  558. &sensor_dev_attr_fan2_alarm.dev_attr.attr,
  559. &sensor_dev_attr_fan3_alarm.dev_attr.attr,
  560. &sensor_dev_attr_temp1_alarm.dev_attr.attr,
  561. &sensor_dev_attr_temp2_alarm.dev_attr.attr,
  562. &sensor_dev_attr_temp3_alarm.dev_attr.attr,
  563. &dev_attr_cpu0_vid.attr,
  564. &dev_attr_vrm.attr,
  565. &dev_attr_alarms.attr,
  566. &dev_attr_pwm1.attr,
  567. &dev_attr_pwm1_enable.attr,
  568. NULL
  569. };
  570. static const struct attribute_group asb100_group = {
  571. .attrs = asb100_attributes,
  572. };
  573. static int asb100_detect_subclients(struct i2c_client *client)
  574. {
  575. int i, id, err;
  576. int address = client->addr;
  577. unsigned short sc_addr[2];
  578. struct asb100_data *data = i2c_get_clientdata(client);
  579. struct i2c_adapter *adapter = client->adapter;
  580. id = i2c_adapter_id(adapter);
  581. if (force_subclients[0] == id && force_subclients[1] == address) {
  582. for (i = 2; i <= 3; i++) {
  583. if (force_subclients[i] < 0x48 ||
  584. force_subclients[i] > 0x4f) {
  585. dev_err(&client->dev,
  586. "invalid subclient address %d; must be 0x48-0x4f\n",
  587. force_subclients[i]);
  588. err = -ENODEV;
  589. goto ERROR_SC_2;
  590. }
  591. }
  592. asb100_write_value(client, ASB100_REG_I2C_SUBADDR,
  593. (force_subclients[2] & 0x07) |
  594. ((force_subclients[3] & 0x07) << 4));
  595. sc_addr[0] = force_subclients[2];
  596. sc_addr[1] = force_subclients[3];
  597. } else {
  598. int val = asb100_read_value(client, ASB100_REG_I2C_SUBADDR);
  599. sc_addr[0] = 0x48 + (val & 0x07);
  600. sc_addr[1] = 0x48 + ((val >> 4) & 0x07);
  601. }
  602. if (sc_addr[0] == sc_addr[1]) {
  603. dev_err(&client->dev,
  604. "duplicate addresses 0x%x for subclients\n",
  605. sc_addr[0]);
  606. err = -ENODEV;
  607. goto ERROR_SC_2;
  608. }
  609. data->lm75[0] = i2c_new_dummy_device(adapter, sc_addr[0]);
  610. if (IS_ERR(data->lm75[0])) {
  611. dev_err(&client->dev,
  612. "subclient %d registration at address 0x%x failed.\n",
  613. 1, sc_addr[0]);
  614. err = PTR_ERR(data->lm75[0]);
  615. goto ERROR_SC_2;
  616. }
  617. data->lm75[1] = i2c_new_dummy_device(adapter, sc_addr[1]);
  618. if (IS_ERR(data->lm75[1])) {
  619. dev_err(&client->dev,
  620. "subclient %d registration at address 0x%x failed.\n",
  621. 2, sc_addr[1]);
  622. err = PTR_ERR(data->lm75[1]);
  623. goto ERROR_SC_3;
  624. }
  625. return 0;
  626. /* Undo inits in case of errors */
  627. ERROR_SC_3:
  628. i2c_unregister_device(data->lm75[0]);
  629. ERROR_SC_2:
  630. return err;
  631. }
  632. /* Return 0 if detection is successful, -ENODEV otherwise */
  633. static int asb100_detect(struct i2c_client *client,
  634. struct i2c_board_info *info)
  635. {
  636. struct i2c_adapter *adapter = client->adapter;
  637. int val1, val2;
  638. if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
  639. pr_debug("detect failed, smbus byte data not supported!\n");
  640. return -ENODEV;
  641. }
  642. val1 = i2c_smbus_read_byte_data(client, ASB100_REG_BANK);
  643. val2 = i2c_smbus_read_byte_data(client, ASB100_REG_CHIPMAN);
  644. /* If we're in bank 0 */
  645. if ((!(val1 & 0x07)) &&
  646. /* Check for ASB100 ID (low byte) */
  647. (((!(val1 & 0x80)) && (val2 != 0x94)) ||
  648. /* Check for ASB100 ID (high byte ) */
  649. ((val1 & 0x80) && (val2 != 0x06)))) {
  650. pr_debug("detect failed, bad chip id 0x%02x!\n", val2);
  651. return -ENODEV;
  652. }
  653. /* Put it now into bank 0 and Vendor ID High Byte */
  654. i2c_smbus_write_byte_data(client, ASB100_REG_BANK,
  655. (i2c_smbus_read_byte_data(client, ASB100_REG_BANK) & 0x78)
  656. | 0x80);
  657. /* Determine the chip type. */
  658. val1 = i2c_smbus_read_byte_data(client, ASB100_REG_WCHIPID);
  659. val2 = i2c_smbus_read_byte_data(client, ASB100_REG_CHIPMAN);
  660. if (val1 != 0x31 || val2 != 0x06)
  661. return -ENODEV;
  662. strscpy(info->type, "asb100", I2C_NAME_SIZE);
  663. return 0;
  664. }
  665. static int asb100_probe(struct i2c_client *client)
  666. {
  667. int err;
  668. struct asb100_data *data;
  669. data = devm_kzalloc(&client->dev, sizeof(struct asb100_data),
  670. GFP_KERNEL);
  671. if (!data)
  672. return -ENOMEM;
  673. i2c_set_clientdata(client, data);
  674. mutex_init(&data->lock);
  675. mutex_init(&data->update_lock);
  676. /* Attach secondary lm75 clients */
  677. err = asb100_detect_subclients(client);
  678. if (err)
  679. return err;
  680. /* Initialize the chip */
  681. asb100_init_client(client);
  682. /* A few vars need to be filled upon startup */
  683. data->fan_min[0] = asb100_read_value(client, ASB100_REG_FAN_MIN(0));
  684. data->fan_min[1] = asb100_read_value(client, ASB100_REG_FAN_MIN(1));
  685. data->fan_min[2] = asb100_read_value(client, ASB100_REG_FAN_MIN(2));
  686. /* Register sysfs hooks */
  687. err = sysfs_create_group(&client->dev.kobj, &asb100_group);
  688. if (err)
  689. goto ERROR3;
  690. data->hwmon_dev = hwmon_device_register(&client->dev);
  691. if (IS_ERR(data->hwmon_dev)) {
  692. err = PTR_ERR(data->hwmon_dev);
  693. goto ERROR4;
  694. }
  695. return 0;
  696. ERROR4:
  697. sysfs_remove_group(&client->dev.kobj, &asb100_group);
  698. ERROR3:
  699. i2c_unregister_device(data->lm75[1]);
  700. i2c_unregister_device(data->lm75[0]);
  701. return err;
  702. }
  703. static void asb100_remove(struct i2c_client *client)
  704. {
  705. struct asb100_data *data = i2c_get_clientdata(client);
  706. hwmon_device_unregister(data->hwmon_dev);
  707. sysfs_remove_group(&client->dev.kobj, &asb100_group);
  708. i2c_unregister_device(data->lm75[1]);
  709. i2c_unregister_device(data->lm75[0]);
  710. }
  711. /*
  712. * The SMBus locks itself, usually, but nothing may access the chip between
  713. * bank switches.
  714. */
  715. static int asb100_read_value(struct i2c_client *client, u16 reg)
  716. {
  717. struct asb100_data *data = i2c_get_clientdata(client);
  718. struct i2c_client *cl;
  719. int res, bank;
  720. mutex_lock(&data->lock);
  721. bank = (reg >> 8) & 0x0f;
  722. if (bank > 2)
  723. /* switch banks */
  724. i2c_smbus_write_byte_data(client, ASB100_REG_BANK, bank);
  725. if (bank == 0 || bank > 2) {
  726. res = i2c_smbus_read_byte_data(client, reg & 0xff);
  727. } else {
  728. /* switch to subclient */
  729. cl = data->lm75[bank - 1];
  730. /* convert from ISA to LM75 I2C addresses */
  731. switch (reg & 0xff) {
  732. case 0x50: /* TEMP */
  733. res = i2c_smbus_read_word_swapped(cl, 0);
  734. break;
  735. case 0x52: /* CONFIG */
  736. res = i2c_smbus_read_byte_data(cl, 1);
  737. break;
  738. case 0x53: /* HYST */
  739. res = i2c_smbus_read_word_swapped(cl, 2);
  740. break;
  741. case 0x55: /* MAX */
  742. default:
  743. res = i2c_smbus_read_word_swapped(cl, 3);
  744. break;
  745. }
  746. }
  747. if (bank > 2)
  748. i2c_smbus_write_byte_data(client, ASB100_REG_BANK, 0);
  749. mutex_unlock(&data->lock);
  750. return res;
  751. }
  752. static void asb100_write_value(struct i2c_client *client, u16 reg, u16 value)
  753. {
  754. struct asb100_data *data = i2c_get_clientdata(client);
  755. struct i2c_client *cl;
  756. int bank;
  757. mutex_lock(&data->lock);
  758. bank = (reg >> 8) & 0x0f;
  759. if (bank > 2)
  760. /* switch banks */
  761. i2c_smbus_write_byte_data(client, ASB100_REG_BANK, bank);
  762. if (bank == 0 || bank > 2) {
  763. i2c_smbus_write_byte_data(client, reg & 0xff, value & 0xff);
  764. } else {
  765. /* switch to subclient */
  766. cl = data->lm75[bank - 1];
  767. /* convert from ISA to LM75 I2C addresses */
  768. switch (reg & 0xff) {
  769. case 0x52: /* CONFIG */
  770. i2c_smbus_write_byte_data(cl, 1, value & 0xff);
  771. break;
  772. case 0x53: /* HYST */
  773. i2c_smbus_write_word_swapped(cl, 2, value);
  774. break;
  775. case 0x55: /* MAX */
  776. i2c_smbus_write_word_swapped(cl, 3, value);
  777. break;
  778. }
  779. }
  780. if (bank > 2)
  781. i2c_smbus_write_byte_data(client, ASB100_REG_BANK, 0);
  782. mutex_unlock(&data->lock);
  783. }
  784. static void asb100_init_client(struct i2c_client *client)
  785. {
  786. struct asb100_data *data = i2c_get_clientdata(client);
  787. data->vrm = vid_which_vrm();
  788. /* Start monitoring */
  789. asb100_write_value(client, ASB100_REG_CONFIG,
  790. (asb100_read_value(client, ASB100_REG_CONFIG) & 0xf7) | 0x01);
  791. }
  792. static struct asb100_data *asb100_update_device(struct device *dev)
  793. {
  794. struct i2c_client *client = to_i2c_client(dev);
  795. struct asb100_data *data = i2c_get_clientdata(client);
  796. int i;
  797. mutex_lock(&data->update_lock);
  798. if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
  799. || !data->valid) {
  800. dev_dbg(&client->dev, "starting device update...\n");
  801. /* 7 voltage inputs */
  802. for (i = 0; i < 7; i++) {
  803. data->in[i] = asb100_read_value(client,
  804. ASB100_REG_IN(i));
  805. data->in_min[i] = asb100_read_value(client,
  806. ASB100_REG_IN_MIN(i));
  807. data->in_max[i] = asb100_read_value(client,
  808. ASB100_REG_IN_MAX(i));
  809. }
  810. /* 3 fan inputs */
  811. for (i = 0; i < 3; i++) {
  812. data->fan[i] = asb100_read_value(client,
  813. ASB100_REG_FAN(i));
  814. data->fan_min[i] = asb100_read_value(client,
  815. ASB100_REG_FAN_MIN(i));
  816. }
  817. /* 4 temperature inputs */
  818. for (i = 1; i <= 4; i++) {
  819. data->temp[i-1] = asb100_read_value(client,
  820. ASB100_REG_TEMP(i));
  821. data->temp_max[i-1] = asb100_read_value(client,
  822. ASB100_REG_TEMP_MAX(i));
  823. data->temp_hyst[i-1] = asb100_read_value(client,
  824. ASB100_REG_TEMP_HYST(i));
  825. }
  826. /* VID and fan divisors */
  827. i = asb100_read_value(client, ASB100_REG_VID_FANDIV);
  828. data->vid = i & 0x0f;
  829. data->vid |= (asb100_read_value(client,
  830. ASB100_REG_CHIPID) & 0x01) << 4;
  831. data->fan_div[0] = (i >> 4) & 0x03;
  832. data->fan_div[1] = (i >> 6) & 0x03;
  833. data->fan_div[2] = (asb100_read_value(client,
  834. ASB100_REG_PIN) >> 6) & 0x03;
  835. /* PWM */
  836. data->pwm = asb100_read_value(client, ASB100_REG_PWM1);
  837. /* alarms */
  838. data->alarms = asb100_read_value(client, ASB100_REG_ALARM1) +
  839. (asb100_read_value(client, ASB100_REG_ALARM2) << 8);
  840. data->last_updated = jiffies;
  841. data->valid = true;
  842. dev_dbg(&client->dev, "... device update complete\n");
  843. }
  844. mutex_unlock(&data->update_lock);
  845. return data;
  846. }
  847. module_i2c_driver(asb100_driver);
  848. MODULE_AUTHOR("Mark M. Hoffman <[email protected]>");
  849. MODULE_DESCRIPTION("ASB100 Bach driver");
  850. MODULE_LICENSE("GPL");