amc6821.c 26 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * amc6821.c - Part of lm_sensors, Linux kernel modules for hardware
  4. * monitoring
  5. * Copyright (C) 2009 T. Mertelj <tomaz.mertelj@guest.arnes.si>
  6. *
  7. * Based on max6650.c:
  8. * Copyright (C) 2007 Hans J. Koch <hjk@hansjkoch.de>
  9. */
  10. #include <linux/kernel.h> /* Needed for KERN_INFO */
  11. #include <linux/module.h>
  12. #include <linux/init.h>
  13. #include <linux/slab.h>
  14. #include <linux/jiffies.h>
  15. #include <linux/i2c.h>
  16. #include <linux/hwmon.h>
  17. #include <linux/hwmon-sysfs.h>
  18. #include <linux/err.h>
  19. #include <linux/mutex.h>
  20. /*
  21. * Addresses to scan.
  22. */
  23. static const unsigned short normal_i2c[] = {0x18, 0x19, 0x1a, 0x2c, 0x2d, 0x2e,
  24. 0x4c, 0x4d, 0x4e, I2C_CLIENT_END};
  25. /*
  26. * Insmod parameters
  27. */
  28. static int pwminv; /*Inverted PWM output. */
  29. module_param(pwminv, int, 0444);
  30. static int init = 1; /*Power-on initialization.*/
  31. module_param(init, int, 0444);
  32. enum chips { amc6821 };
  33. #define AMC6821_REG_DEV_ID 0x3D
  34. #define AMC6821_REG_COMP_ID 0x3E
  35. #define AMC6821_REG_CONF1 0x00
  36. #define AMC6821_REG_CONF2 0x01
  37. #define AMC6821_REG_CONF3 0x3F
  38. #define AMC6821_REG_CONF4 0x04
  39. #define AMC6821_REG_STAT1 0x02
  40. #define AMC6821_REG_STAT2 0x03
  41. #define AMC6821_REG_TDATA_LOW 0x08
  42. #define AMC6821_REG_TDATA_HI 0x09
  43. #define AMC6821_REG_LTEMP_HI 0x0A
  44. #define AMC6821_REG_RTEMP_HI 0x0B
  45. #define AMC6821_REG_LTEMP_LIMIT_MIN 0x15
  46. #define AMC6821_REG_LTEMP_LIMIT_MAX 0x14
  47. #define AMC6821_REG_RTEMP_LIMIT_MIN 0x19
  48. #define AMC6821_REG_RTEMP_LIMIT_MAX 0x18
  49. #define AMC6821_REG_LTEMP_CRIT 0x1B
  50. #define AMC6821_REG_RTEMP_CRIT 0x1D
  51. #define AMC6821_REG_PSV_TEMP 0x1C
  52. #define AMC6821_REG_DCY 0x22
  53. #define AMC6821_REG_LTEMP_FAN_CTRL 0x24
  54. #define AMC6821_REG_RTEMP_FAN_CTRL 0x25
  55. #define AMC6821_REG_DCY_LOW_TEMP 0x21
  56. #define AMC6821_REG_TACH_LLIMITL 0x10
  57. #define AMC6821_REG_TACH_LLIMITH 0x11
  58. #define AMC6821_REG_TACH_HLIMITL 0x12
  59. #define AMC6821_REG_TACH_HLIMITH 0x13
  60. #define AMC6821_CONF1_START 0x01
  61. #define AMC6821_CONF1_FAN_INT_EN 0x02
  62. #define AMC6821_CONF1_FANIE 0x04
  63. #define AMC6821_CONF1_PWMINV 0x08
  64. #define AMC6821_CONF1_FAN_FAULT_EN 0x10
  65. #define AMC6821_CONF1_FDRC0 0x20
  66. #define AMC6821_CONF1_FDRC1 0x40
  67. #define AMC6821_CONF1_THERMOVIE 0x80
  68. #define AMC6821_CONF2_PWM_EN 0x01
  69. #define AMC6821_CONF2_TACH_MODE 0x02
  70. #define AMC6821_CONF2_TACH_EN 0x04
  71. #define AMC6821_CONF2_RTFIE 0x08
  72. #define AMC6821_CONF2_LTOIE 0x10
  73. #define AMC6821_CONF2_RTOIE 0x20
  74. #define AMC6821_CONF2_PSVIE 0x40
  75. #define AMC6821_CONF2_RST 0x80
  76. #define AMC6821_CONF3_THERM_FAN_EN 0x80
  77. #define AMC6821_CONF3_REV_MASK 0x0F
  78. #define AMC6821_CONF4_OVREN 0x10
  79. #define AMC6821_CONF4_TACH_FAST 0x20
  80. #define AMC6821_CONF4_PSPR 0x40
  81. #define AMC6821_CONF4_MODE 0x80
  82. #define AMC6821_STAT1_RPM_ALARM 0x01
  83. #define AMC6821_STAT1_FANS 0x02
  84. #define AMC6821_STAT1_RTH 0x04
  85. #define AMC6821_STAT1_RTL 0x08
  86. #define AMC6821_STAT1_R_THERM 0x10
  87. #define AMC6821_STAT1_RTF 0x20
  88. #define AMC6821_STAT1_LTH 0x40
  89. #define AMC6821_STAT1_LTL 0x80
  90. #define AMC6821_STAT2_RTC 0x08
  91. #define AMC6821_STAT2_LTC 0x10
  92. #define AMC6821_STAT2_LPSV 0x20
  93. #define AMC6821_STAT2_L_THERM 0x40
  94. #define AMC6821_STAT2_THERM_IN 0x80
  95. enum {IDX_TEMP1_INPUT = 0, IDX_TEMP1_MIN, IDX_TEMP1_MAX,
  96. IDX_TEMP1_CRIT, IDX_TEMP2_INPUT, IDX_TEMP2_MIN,
  97. IDX_TEMP2_MAX, IDX_TEMP2_CRIT,
  98. TEMP_IDX_LEN, };
  99. static const u8 temp_reg[] = {AMC6821_REG_LTEMP_HI,
  100. AMC6821_REG_LTEMP_LIMIT_MIN,
  101. AMC6821_REG_LTEMP_LIMIT_MAX,
  102. AMC6821_REG_LTEMP_CRIT,
  103. AMC6821_REG_RTEMP_HI,
  104. AMC6821_REG_RTEMP_LIMIT_MIN,
  105. AMC6821_REG_RTEMP_LIMIT_MAX,
  106. AMC6821_REG_RTEMP_CRIT, };
  107. enum {IDX_FAN1_INPUT = 0, IDX_FAN1_MIN, IDX_FAN1_MAX,
  108. FAN1_IDX_LEN, };
  109. static const u8 fan_reg_low[] = {AMC6821_REG_TDATA_LOW,
  110. AMC6821_REG_TACH_LLIMITL,
  111. AMC6821_REG_TACH_HLIMITL, };
  112. static const u8 fan_reg_hi[] = {AMC6821_REG_TDATA_HI,
  113. AMC6821_REG_TACH_LLIMITH,
  114. AMC6821_REG_TACH_HLIMITH, };
  115. /*
  116. * Client data (each client gets its own)
  117. */
  118. struct amc6821_data {
  119. struct i2c_client *client;
  120. struct mutex update_lock;
  121. char valid; /* zero until following fields are valid */
  122. unsigned long last_updated; /* in jiffies */
  123. /* register values */
  124. int temp[TEMP_IDX_LEN];
  125. u16 fan[FAN1_IDX_LEN];
  126. u8 fan1_div;
  127. u8 pwm1;
  128. u8 temp1_auto_point_temp[3];
  129. u8 temp2_auto_point_temp[3];
  130. u8 pwm1_auto_point_pwm[3];
  131. u8 pwm1_enable;
  132. u8 pwm1_auto_channels_temp;
  133. u8 stat1;
  134. u8 stat2;
  135. };
  136. static struct amc6821_data *amc6821_update_device(struct device *dev)
  137. {
  138. struct amc6821_data *data = dev_get_drvdata(dev);
  139. struct i2c_client *client = data->client;
  140. int timeout = HZ;
  141. u8 reg;
  142. int i;
  143. mutex_lock(&data->update_lock);
  144. if (time_after(jiffies, data->last_updated + timeout) ||
  145. !data->valid) {
  146. for (i = 0; i < TEMP_IDX_LEN; i++)
  147. data->temp[i] = (int8_t)i2c_smbus_read_byte_data(
  148. client, temp_reg[i]);
  149. data->stat1 = i2c_smbus_read_byte_data(client,
  150. AMC6821_REG_STAT1);
  151. data->stat2 = i2c_smbus_read_byte_data(client,
  152. AMC6821_REG_STAT2);
  153. data->pwm1 = i2c_smbus_read_byte_data(client,
  154. AMC6821_REG_DCY);
  155. for (i = 0; i < FAN1_IDX_LEN; i++) {
  156. data->fan[i] = i2c_smbus_read_byte_data(
  157. client,
  158. fan_reg_low[i]);
  159. data->fan[i] += i2c_smbus_read_byte_data(
  160. client,
  161. fan_reg_hi[i]) << 8;
  162. }
  163. data->fan1_div = i2c_smbus_read_byte_data(client,
  164. AMC6821_REG_CONF4);
  165. data->fan1_div = data->fan1_div & AMC6821_CONF4_PSPR ? 4 : 2;
  166. data->pwm1_auto_point_pwm[0] = 0;
  167. data->pwm1_auto_point_pwm[2] = 255;
  168. data->pwm1_auto_point_pwm[1] = i2c_smbus_read_byte_data(client,
  169. AMC6821_REG_DCY_LOW_TEMP);
  170. data->temp1_auto_point_temp[0] =
  171. i2c_smbus_read_byte_data(client,
  172. AMC6821_REG_PSV_TEMP);
  173. data->temp2_auto_point_temp[0] =
  174. data->temp1_auto_point_temp[0];
  175. reg = i2c_smbus_read_byte_data(client,
  176. AMC6821_REG_LTEMP_FAN_CTRL);
  177. data->temp1_auto_point_temp[1] = (reg & 0xF8) >> 1;
  178. reg &= 0x07;
  179. reg = 0x20 >> reg;
  180. if (reg > 0)
  181. data->temp1_auto_point_temp[2] =
  182. data->temp1_auto_point_temp[1] +
  183. (data->pwm1_auto_point_pwm[2] -
  184. data->pwm1_auto_point_pwm[1]) / reg;
  185. else
  186. data->temp1_auto_point_temp[2] = 255;
  187. reg = i2c_smbus_read_byte_data(client,
  188. AMC6821_REG_RTEMP_FAN_CTRL);
  189. data->temp2_auto_point_temp[1] = (reg & 0xF8) >> 1;
  190. reg &= 0x07;
  191. reg = 0x20 >> reg;
  192. if (reg > 0)
  193. data->temp2_auto_point_temp[2] =
  194. data->temp2_auto_point_temp[1] +
  195. (data->pwm1_auto_point_pwm[2] -
  196. data->pwm1_auto_point_pwm[1]) / reg;
  197. else
  198. data->temp2_auto_point_temp[2] = 255;
  199. reg = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF1);
  200. reg = (reg >> 5) & 0x3;
  201. switch (reg) {
  202. case 0: /*open loop: software sets pwm1*/
  203. data->pwm1_auto_channels_temp = 0;
  204. data->pwm1_enable = 1;
  205. break;
  206. case 2: /*closed loop: remote T (temp2)*/
  207. data->pwm1_auto_channels_temp = 2;
  208. data->pwm1_enable = 2;
  209. break;
  210. case 3: /*closed loop: local and remote T (temp2)*/
  211. data->pwm1_auto_channels_temp = 3;
  212. data->pwm1_enable = 3;
  213. break;
  214. case 1: /*
  215. * semi-open loop: software sets rpm, chip controls
  216. * pwm1, currently not implemented
  217. */
  218. data->pwm1_auto_channels_temp = 0;
  219. data->pwm1_enable = 0;
  220. break;
  221. }
  222. data->last_updated = jiffies;
  223. data->valid = 1;
  224. }
  225. mutex_unlock(&data->update_lock);
  226. return data;
  227. }
  228. static ssize_t temp_show(struct device *dev, struct device_attribute *devattr,
  229. char *buf)
  230. {
  231. struct amc6821_data *data = amc6821_update_device(dev);
  232. int ix = to_sensor_dev_attr(devattr)->index;
  233. return sprintf(buf, "%d\n", data->temp[ix] * 1000);
  234. }
  235. static ssize_t temp_store(struct device *dev, struct device_attribute *attr,
  236. const char *buf, size_t count)
  237. {
  238. struct amc6821_data *data = dev_get_drvdata(dev);
  239. struct i2c_client *client = data->client;
  240. int ix = to_sensor_dev_attr(attr)->index;
  241. long val;
  242. int ret = kstrtol(buf, 10, &val);
  243. if (ret)
  244. return ret;
  245. val = clamp_val(val / 1000, -128, 127);
  246. mutex_lock(&data->update_lock);
  247. data->temp[ix] = val;
  248. if (i2c_smbus_write_byte_data(client, temp_reg[ix], data->temp[ix])) {
  249. dev_err(&client->dev, "Register write error, aborting.\n");
  250. count = -EIO;
  251. }
  252. mutex_unlock(&data->update_lock);
  253. return count;
  254. }
  255. static ssize_t temp_alarm_show(struct device *dev,
  256. struct device_attribute *devattr, char *buf)
  257. {
  258. struct amc6821_data *data = amc6821_update_device(dev);
  259. int ix = to_sensor_dev_attr(devattr)->index;
  260. u8 flag;
  261. switch (ix) {
  262. case IDX_TEMP1_MIN:
  263. flag = data->stat1 & AMC6821_STAT1_LTL;
  264. break;
  265. case IDX_TEMP1_MAX:
  266. flag = data->stat1 & AMC6821_STAT1_LTH;
  267. break;
  268. case IDX_TEMP1_CRIT:
  269. flag = data->stat2 & AMC6821_STAT2_LTC;
  270. break;
  271. case IDX_TEMP2_MIN:
  272. flag = data->stat1 & AMC6821_STAT1_RTL;
  273. break;
  274. case IDX_TEMP2_MAX:
  275. flag = data->stat1 & AMC6821_STAT1_RTH;
  276. break;
  277. case IDX_TEMP2_CRIT:
  278. flag = data->stat2 & AMC6821_STAT2_RTC;
  279. break;
  280. default:
  281. dev_dbg(dev, "Unknown attr->index (%d).\n", ix);
  282. return -EINVAL;
  283. }
  284. if (flag)
  285. return sprintf(buf, "1");
  286. else
  287. return sprintf(buf, "0");
  288. }
  289. static ssize_t temp2_fault_show(struct device *dev,
  290. struct device_attribute *devattr, char *buf)
  291. {
  292. struct amc6821_data *data = amc6821_update_device(dev);
  293. if (data->stat1 & AMC6821_STAT1_RTF)
  294. return sprintf(buf, "1");
  295. else
  296. return sprintf(buf, "0");
  297. }
  298. static ssize_t pwm1_show(struct device *dev, struct device_attribute *devattr,
  299. char *buf)
  300. {
  301. struct amc6821_data *data = amc6821_update_device(dev);
  302. return sprintf(buf, "%d\n", data->pwm1);
  303. }
  304. static ssize_t pwm1_store(struct device *dev,
  305. struct device_attribute *devattr, const char *buf,
  306. size_t count)
  307. {
  308. struct amc6821_data *data = dev_get_drvdata(dev);
  309. struct i2c_client *client = data->client;
  310. long val;
  311. int ret = kstrtol(buf, 10, &val);
  312. if (ret)
  313. return ret;
  314. mutex_lock(&data->update_lock);
  315. data->pwm1 = clamp_val(val , 0, 255);
  316. i2c_smbus_write_byte_data(client, AMC6821_REG_DCY, data->pwm1);
  317. mutex_unlock(&data->update_lock);
  318. return count;
  319. }
  320. static ssize_t pwm1_enable_show(struct device *dev,
  321. struct device_attribute *devattr, char *buf)
  322. {
  323. struct amc6821_data *data = amc6821_update_device(dev);
  324. return sprintf(buf, "%d\n", data->pwm1_enable);
  325. }
  326. static ssize_t pwm1_enable_store(struct device *dev,
  327. struct device_attribute *attr,
  328. const char *buf, size_t count)
  329. {
  330. struct amc6821_data *data = dev_get_drvdata(dev);
  331. struct i2c_client *client = data->client;
  332. long val;
  333. int config = kstrtol(buf, 10, &val);
  334. if (config)
  335. return config;
  336. mutex_lock(&data->update_lock);
  337. config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF1);
  338. if (config < 0) {
  339. dev_err(&client->dev,
  340. "Error reading configuration register, aborting.\n");
  341. count = config;
  342. goto unlock;
  343. }
  344. switch (val) {
  345. case 1:
  346. config &= ~AMC6821_CONF1_FDRC0;
  347. config &= ~AMC6821_CONF1_FDRC1;
  348. break;
  349. case 2:
  350. config &= ~AMC6821_CONF1_FDRC0;
  351. config |= AMC6821_CONF1_FDRC1;
  352. break;
  353. case 3:
  354. config |= AMC6821_CONF1_FDRC0;
  355. config |= AMC6821_CONF1_FDRC1;
  356. break;
  357. default:
  358. count = -EINVAL;
  359. goto unlock;
  360. }
  361. if (i2c_smbus_write_byte_data(client, AMC6821_REG_CONF1, config)) {
  362. dev_err(&client->dev,
  363. "Configuration register write error, aborting.\n");
  364. count = -EIO;
  365. }
  366. unlock:
  367. mutex_unlock(&data->update_lock);
  368. return count;
  369. }
  370. static ssize_t pwm1_auto_channels_temp_show(struct device *dev,
  371. struct device_attribute *devattr,
  372. char *buf)
  373. {
  374. struct amc6821_data *data = amc6821_update_device(dev);
  375. return sprintf(buf, "%d\n", data->pwm1_auto_channels_temp);
  376. }
  377. static ssize_t temp_auto_point_temp_show(struct device *dev,
  378. struct device_attribute *devattr,
  379. char *buf)
  380. {
  381. int ix = to_sensor_dev_attr_2(devattr)->index;
  382. int nr = to_sensor_dev_attr_2(devattr)->nr;
  383. struct amc6821_data *data = amc6821_update_device(dev);
  384. switch (nr) {
  385. case 1:
  386. return sprintf(buf, "%d\n",
  387. data->temp1_auto_point_temp[ix] * 1000);
  388. case 2:
  389. return sprintf(buf, "%d\n",
  390. data->temp2_auto_point_temp[ix] * 1000);
  391. default:
  392. dev_dbg(dev, "Unknown attr->nr (%d).\n", nr);
  393. return -EINVAL;
  394. }
  395. }
  396. static ssize_t pwm1_auto_point_pwm_show(struct device *dev,
  397. struct device_attribute *devattr,
  398. char *buf)
  399. {
  400. int ix = to_sensor_dev_attr(devattr)->index;
  401. struct amc6821_data *data = amc6821_update_device(dev);
  402. return sprintf(buf, "%d\n", data->pwm1_auto_point_pwm[ix]);
  403. }
  404. static inline ssize_t set_slope_register(struct i2c_client *client,
  405. u8 reg,
  406. u8 dpwm,
  407. u8 *ptemp)
  408. {
  409. int dt;
  410. u8 tmp;
  411. dt = ptemp[2]-ptemp[1];
  412. for (tmp = 4; tmp > 0; tmp--) {
  413. if (dt * (0x20 >> tmp) >= dpwm)
  414. break;
  415. }
  416. tmp |= (ptemp[1] & 0x7C) << 1;
  417. if (i2c_smbus_write_byte_data(client,
  418. reg, tmp)) {
  419. dev_err(&client->dev, "Register write error, aborting.\n");
  420. return -EIO;
  421. }
  422. return 0;
  423. }
  424. static ssize_t temp_auto_point_temp_store(struct device *dev,
  425. struct device_attribute *attr,
  426. const char *buf, size_t count)
  427. {
  428. struct amc6821_data *data = amc6821_update_device(dev);
  429. struct i2c_client *client = data->client;
  430. int ix = to_sensor_dev_attr_2(attr)->index;
  431. int nr = to_sensor_dev_attr_2(attr)->nr;
  432. u8 *ptemp;
  433. u8 reg;
  434. int dpwm;
  435. long val;
  436. int ret = kstrtol(buf, 10, &val);
  437. if (ret)
  438. return ret;
  439. switch (nr) {
  440. case 1:
  441. ptemp = data->temp1_auto_point_temp;
  442. reg = AMC6821_REG_LTEMP_FAN_CTRL;
  443. break;
  444. case 2:
  445. ptemp = data->temp2_auto_point_temp;
  446. reg = AMC6821_REG_RTEMP_FAN_CTRL;
  447. break;
  448. default:
  449. dev_dbg(dev, "Unknown attr->nr (%d).\n", nr);
  450. return -EINVAL;
  451. }
  452. mutex_lock(&data->update_lock);
  453. data->valid = 0;
  454. switch (ix) {
  455. case 0:
  456. ptemp[0] = clamp_val(val / 1000, 0,
  457. data->temp1_auto_point_temp[1]);
  458. ptemp[0] = clamp_val(ptemp[0], 0,
  459. data->temp2_auto_point_temp[1]);
  460. ptemp[0] = clamp_val(ptemp[0], 0, 63);
  461. if (i2c_smbus_write_byte_data(
  462. client,
  463. AMC6821_REG_PSV_TEMP,
  464. ptemp[0])) {
  465. dev_err(&client->dev,
  466. "Register write error, aborting.\n");
  467. count = -EIO;
  468. }
  469. goto EXIT;
  470. case 1:
  471. ptemp[1] = clamp_val(val / 1000, (ptemp[0] & 0x7C) + 4, 124);
  472. ptemp[1] &= 0x7C;
  473. ptemp[2] = clamp_val(ptemp[2], ptemp[1] + 1, 255);
  474. break;
  475. case 2:
  476. ptemp[2] = clamp_val(val / 1000, ptemp[1]+1, 255);
  477. break;
  478. default:
  479. dev_dbg(dev, "Unknown attr->index (%d).\n", ix);
  480. count = -EINVAL;
  481. goto EXIT;
  482. }
  483. dpwm = data->pwm1_auto_point_pwm[2] - data->pwm1_auto_point_pwm[1];
  484. if (set_slope_register(client, reg, dpwm, ptemp))
  485. count = -EIO;
  486. EXIT:
  487. mutex_unlock(&data->update_lock);
  488. return count;
  489. }
  490. static ssize_t pwm1_auto_point_pwm_store(struct device *dev,
  491. struct device_attribute *attr,
  492. const char *buf, size_t count)
  493. {
  494. struct amc6821_data *data = dev_get_drvdata(dev);
  495. struct i2c_client *client = data->client;
  496. int dpwm;
  497. long val;
  498. int ret = kstrtol(buf, 10, &val);
  499. if (ret)
  500. return ret;
  501. mutex_lock(&data->update_lock);
  502. data->pwm1_auto_point_pwm[1] = clamp_val(val, 0, 254);
  503. if (i2c_smbus_write_byte_data(client, AMC6821_REG_DCY_LOW_TEMP,
  504. data->pwm1_auto_point_pwm[1])) {
  505. dev_err(&client->dev, "Register write error, aborting.\n");
  506. count = -EIO;
  507. goto EXIT;
  508. }
  509. dpwm = data->pwm1_auto_point_pwm[2] - data->pwm1_auto_point_pwm[1];
  510. if (set_slope_register(client, AMC6821_REG_LTEMP_FAN_CTRL, dpwm,
  511. data->temp1_auto_point_temp)) {
  512. count = -EIO;
  513. goto EXIT;
  514. }
  515. if (set_slope_register(client, AMC6821_REG_RTEMP_FAN_CTRL, dpwm,
  516. data->temp2_auto_point_temp)) {
  517. count = -EIO;
  518. goto EXIT;
  519. }
  520. EXIT:
  521. data->valid = 0;
  522. mutex_unlock(&data->update_lock);
  523. return count;
  524. }
  525. static ssize_t fan_show(struct device *dev, struct device_attribute *devattr,
  526. char *buf)
  527. {
  528. struct amc6821_data *data = amc6821_update_device(dev);
  529. int ix = to_sensor_dev_attr(devattr)->index;
  530. if (0 == data->fan[ix])
  531. return sprintf(buf, "0");
  532. return sprintf(buf, "%d\n", (int)(6000000 / data->fan[ix]));
  533. }
  534. static ssize_t fan1_fault_show(struct device *dev,
  535. struct device_attribute *devattr, char *buf)
  536. {
  537. struct amc6821_data *data = amc6821_update_device(dev);
  538. if (data->stat1 & AMC6821_STAT1_FANS)
  539. return sprintf(buf, "1");
  540. else
  541. return sprintf(buf, "0");
  542. }
  543. static ssize_t fan_store(struct device *dev, struct device_attribute *attr,
  544. const char *buf, size_t count)
  545. {
  546. struct amc6821_data *data = dev_get_drvdata(dev);
  547. struct i2c_client *client = data->client;
  548. long val;
  549. int ix = to_sensor_dev_attr(attr)->index;
  550. int ret = kstrtol(buf, 10, &val);
  551. if (ret)
  552. return ret;
  553. val = 1 > val ? 0xFFFF : 6000000/val;
  554. mutex_lock(&data->update_lock);
  555. data->fan[ix] = (u16) clamp_val(val, 1, 0xFFFF);
  556. if (i2c_smbus_write_byte_data(client, fan_reg_low[ix],
  557. data->fan[ix] & 0xFF)) {
  558. dev_err(&client->dev, "Register write error, aborting.\n");
  559. count = -EIO;
  560. goto EXIT;
  561. }
  562. if (i2c_smbus_write_byte_data(client,
  563. fan_reg_hi[ix], data->fan[ix] >> 8)) {
  564. dev_err(&client->dev, "Register write error, aborting.\n");
  565. count = -EIO;
  566. }
  567. EXIT:
  568. mutex_unlock(&data->update_lock);
  569. return count;
  570. }
  571. static ssize_t fan1_div_show(struct device *dev,
  572. struct device_attribute *devattr, char *buf)
  573. {
  574. struct amc6821_data *data = amc6821_update_device(dev);
  575. return sprintf(buf, "%d\n", data->fan1_div);
  576. }
  577. static ssize_t fan1_div_store(struct device *dev,
  578. struct device_attribute *attr, const char *buf,
  579. size_t count)
  580. {
  581. struct amc6821_data *data = dev_get_drvdata(dev);
  582. struct i2c_client *client = data->client;
  583. long val;
  584. int config = kstrtol(buf, 10, &val);
  585. if (config)
  586. return config;
  587. mutex_lock(&data->update_lock);
  588. config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF4);
  589. if (config < 0) {
  590. dev_err(&client->dev,
  591. "Error reading configuration register, aborting.\n");
  592. count = config;
  593. goto EXIT;
  594. }
  595. switch (val) {
  596. case 2:
  597. config &= ~AMC6821_CONF4_PSPR;
  598. data->fan1_div = 2;
  599. break;
  600. case 4:
  601. config |= AMC6821_CONF4_PSPR;
  602. data->fan1_div = 4;
  603. break;
  604. default:
  605. count = -EINVAL;
  606. goto EXIT;
  607. }
  608. if (i2c_smbus_write_byte_data(client, AMC6821_REG_CONF4, config)) {
  609. dev_err(&client->dev,
  610. "Configuration register write error, aborting.\n");
  611. count = -EIO;
  612. }
  613. EXIT:
  614. mutex_unlock(&data->update_lock);
  615. return count;
  616. }
  617. static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, IDX_TEMP1_INPUT);
  618. static SENSOR_DEVICE_ATTR_RW(temp1_min, temp, IDX_TEMP1_MIN);
  619. static SENSOR_DEVICE_ATTR_RW(temp1_max, temp, IDX_TEMP1_MAX);
  620. static SENSOR_DEVICE_ATTR_RW(temp1_crit, temp, IDX_TEMP1_CRIT);
  621. static SENSOR_DEVICE_ATTR_RO(temp1_min_alarm, temp_alarm, IDX_TEMP1_MIN);
  622. static SENSOR_DEVICE_ATTR_RO(temp1_max_alarm, temp_alarm, IDX_TEMP1_MAX);
  623. static SENSOR_DEVICE_ATTR_RO(temp1_crit_alarm, temp_alarm, IDX_TEMP1_CRIT);
  624. static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, IDX_TEMP2_INPUT);
  625. static SENSOR_DEVICE_ATTR_RW(temp2_min, temp, IDX_TEMP2_MIN);
  626. static SENSOR_DEVICE_ATTR_RW(temp2_max, temp, IDX_TEMP2_MAX);
  627. static SENSOR_DEVICE_ATTR_RW(temp2_crit, temp, IDX_TEMP2_CRIT);
  628. static SENSOR_DEVICE_ATTR_RO(temp2_fault, temp2_fault, 0);
  629. static SENSOR_DEVICE_ATTR_RO(temp2_min_alarm, temp_alarm, IDX_TEMP2_MIN);
  630. static SENSOR_DEVICE_ATTR_RO(temp2_max_alarm, temp_alarm, IDX_TEMP2_MAX);
  631. static SENSOR_DEVICE_ATTR_RO(temp2_crit_alarm, temp_alarm, IDX_TEMP2_CRIT);
  632. static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, IDX_FAN1_INPUT);
  633. static SENSOR_DEVICE_ATTR_RW(fan1_min, fan, IDX_FAN1_MIN);
  634. static SENSOR_DEVICE_ATTR_RW(fan1_max, fan, IDX_FAN1_MAX);
  635. static SENSOR_DEVICE_ATTR_RO(fan1_fault, fan1_fault, 0);
  636. static SENSOR_DEVICE_ATTR_RW(fan1_div, fan1_div, 0);
  637. static SENSOR_DEVICE_ATTR_RW(pwm1, pwm1, 0);
  638. static SENSOR_DEVICE_ATTR_RW(pwm1_enable, pwm1_enable, 0);
  639. static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point1_pwm, pwm1_auto_point_pwm, 0);
  640. static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point2_pwm, pwm1_auto_point_pwm, 1);
  641. static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point3_pwm, pwm1_auto_point_pwm, 2);
  642. static SENSOR_DEVICE_ATTR_RO(pwm1_auto_channels_temp, pwm1_auto_channels_temp,
  643. 0);
  644. static SENSOR_DEVICE_ATTR_2_RO(temp1_auto_point1_temp, temp_auto_point_temp,
  645. 1, 0);
  646. static SENSOR_DEVICE_ATTR_2_RW(temp1_auto_point2_temp, temp_auto_point_temp,
  647. 1, 1);
  648. static SENSOR_DEVICE_ATTR_2_RW(temp1_auto_point3_temp, temp_auto_point_temp,
  649. 1, 2);
  650. static SENSOR_DEVICE_ATTR_2_RW(temp2_auto_point1_temp, temp_auto_point_temp,
  651. 2, 0);
  652. static SENSOR_DEVICE_ATTR_2_RW(temp2_auto_point2_temp, temp_auto_point_temp,
  653. 2, 1);
  654. static SENSOR_DEVICE_ATTR_2_RW(temp2_auto_point3_temp, temp_auto_point_temp,
  655. 2, 2);
  656. static struct attribute *amc6821_attrs[] = {
  657. &sensor_dev_attr_temp1_input.dev_attr.attr,
  658. &sensor_dev_attr_temp1_min.dev_attr.attr,
  659. &sensor_dev_attr_temp1_max.dev_attr.attr,
  660. &sensor_dev_attr_temp1_crit.dev_attr.attr,
  661. &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
  662. &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
  663. &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
  664. &sensor_dev_attr_temp2_input.dev_attr.attr,
  665. &sensor_dev_attr_temp2_min.dev_attr.attr,
  666. &sensor_dev_attr_temp2_max.dev_attr.attr,
  667. &sensor_dev_attr_temp2_crit.dev_attr.attr,
  668. &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
  669. &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
  670. &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
  671. &sensor_dev_attr_temp2_fault.dev_attr.attr,
  672. &sensor_dev_attr_fan1_input.dev_attr.attr,
  673. &sensor_dev_attr_fan1_min.dev_attr.attr,
  674. &sensor_dev_attr_fan1_max.dev_attr.attr,
  675. &sensor_dev_attr_fan1_fault.dev_attr.attr,
  676. &sensor_dev_attr_fan1_div.dev_attr.attr,
  677. &sensor_dev_attr_pwm1.dev_attr.attr,
  678. &sensor_dev_attr_pwm1_enable.dev_attr.attr,
  679. &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,
  680. &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
  681. &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
  682. &sensor_dev_attr_pwm1_auto_point3_pwm.dev_attr.attr,
  683. &sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr,
  684. &sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr,
  685. &sensor_dev_attr_temp1_auto_point3_temp.dev_attr.attr,
  686. &sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr,
  687. &sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr,
  688. &sensor_dev_attr_temp2_auto_point3_temp.dev_attr.attr,
  689. NULL
  690. };
  691. ATTRIBUTE_GROUPS(amc6821);
  692. /* Return 0 if detection is successful, -ENODEV otherwise */
  693. static int amc6821_detect(
  694. struct i2c_client *client,
  695. struct i2c_board_info *info)
  696. {
  697. struct i2c_adapter *adapter = client->adapter;
  698. int address = client->addr;
  699. int dev_id, comp_id;
  700. dev_dbg(&adapter->dev, "amc6821_detect called.\n");
  701. if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
  702. dev_dbg(&adapter->dev,
  703. "amc6821: I2C bus doesn't support byte mode, "
  704. "skipping.\n");
  705. return -ENODEV;
  706. }
  707. dev_id = i2c_smbus_read_byte_data(client, AMC6821_REG_DEV_ID);
  708. comp_id = i2c_smbus_read_byte_data(client, AMC6821_REG_COMP_ID);
  709. if (dev_id != 0x21 || comp_id != 0x49) {
  710. dev_dbg(&adapter->dev,
  711. "amc6821: detection failed at 0x%02x.\n",
  712. address);
  713. return -ENODEV;
  714. }
  715. /*
  716. * Bit 7 of the address register is ignored, so we can check the
  717. * ID registers again
  718. */
  719. dev_id = i2c_smbus_read_byte_data(client, 0x80 | AMC6821_REG_DEV_ID);
  720. comp_id = i2c_smbus_read_byte_data(client, 0x80 | AMC6821_REG_COMP_ID);
  721. if (dev_id != 0x21 || comp_id != 0x49) {
  722. dev_dbg(&adapter->dev,
  723. "amc6821: detection failed at 0x%02x.\n",
  724. address);
  725. return -ENODEV;
  726. }
  727. dev_info(&adapter->dev, "amc6821: chip found at 0x%02x.\n", address);
  728. strlcpy(info->type, "amc6821", I2C_NAME_SIZE);
  729. return 0;
  730. }
  731. static int amc6821_init_client(struct i2c_client *client)
  732. {
  733. int config;
  734. int err = -EIO;
  735. if (init) {
  736. config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF4);
  737. if (config < 0) {
  738. dev_err(&client->dev,
  739. "Error reading configuration register, aborting.\n");
  740. return err;
  741. }
  742. config |= AMC6821_CONF4_MODE;
  743. if (i2c_smbus_write_byte_data(client, AMC6821_REG_CONF4,
  744. config)) {
  745. dev_err(&client->dev,
  746. "Configuration register write error, aborting.\n");
  747. return err;
  748. }
  749. config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF3);
  750. if (config < 0) {
  751. dev_err(&client->dev,
  752. "Error reading configuration register, aborting.\n");
  753. return err;
  754. }
  755. dev_info(&client->dev, "Revision %d\n", config & 0x0f);
  756. config &= ~AMC6821_CONF3_THERM_FAN_EN;
  757. if (i2c_smbus_write_byte_data(client, AMC6821_REG_CONF3,
  758. config)) {
  759. dev_err(&client->dev,
  760. "Configuration register write error, aborting.\n");
  761. return err;
  762. }
  763. config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF2);
  764. if (config < 0) {
  765. dev_err(&client->dev,
  766. "Error reading configuration register, aborting.\n");
  767. return err;
  768. }
  769. config &= ~AMC6821_CONF2_RTFIE;
  770. config &= ~AMC6821_CONF2_LTOIE;
  771. config &= ~AMC6821_CONF2_RTOIE;
  772. if (i2c_smbus_write_byte_data(client,
  773. AMC6821_REG_CONF2, config)) {
  774. dev_err(&client->dev,
  775. "Configuration register write error, aborting.\n");
  776. return err;
  777. }
  778. config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF1);
  779. if (config < 0) {
  780. dev_err(&client->dev,
  781. "Error reading configuration register, aborting.\n");
  782. return err;
  783. }
  784. config &= ~AMC6821_CONF1_THERMOVIE;
  785. config &= ~AMC6821_CONF1_FANIE;
  786. config |= AMC6821_CONF1_START;
  787. if (pwminv)
  788. config |= AMC6821_CONF1_PWMINV;
  789. else
  790. config &= ~AMC6821_CONF1_PWMINV;
  791. if (i2c_smbus_write_byte_data(
  792. client, AMC6821_REG_CONF1, config)) {
  793. dev_err(&client->dev,
  794. "Configuration register write error, aborting.\n");
  795. return err;
  796. }
  797. }
  798. return 0;
  799. }
  800. static int amc6821_probe(struct i2c_client *client)
  801. {
  802. struct device *dev = &client->dev;
  803. struct amc6821_data *data;
  804. struct device *hwmon_dev;
  805. int err;
  806. data = devm_kzalloc(dev, sizeof(struct amc6821_data), GFP_KERNEL);
  807. if (!data)
  808. return -ENOMEM;
  809. data->client = client;
  810. mutex_init(&data->update_lock);
  811. /*
  812. * Initialize the amc6821 chip
  813. */
  814. err = amc6821_init_client(client);
  815. if (err)
  816. return err;
  817. hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
  818. data,
  819. amc6821_groups);
  820. return PTR_ERR_OR_ZERO(hwmon_dev);
  821. }
  822. static const struct i2c_device_id amc6821_id[] = {
  823. { "amc6821", amc6821 },
  824. { }
  825. };
  826. MODULE_DEVICE_TABLE(i2c, amc6821_id);
  827. static struct i2c_driver amc6821_driver = {
  828. .class = I2C_CLASS_HWMON,
  829. .driver = {
  830. .name = "amc6821",
  831. },
  832. .probe_new = amc6821_probe,
  833. .id_table = amc6821_id,
  834. .detect = amc6821_detect,
  835. .address_list = normal_i2c,
  836. };
  837. module_i2c_driver(amc6821_driver);
  838. MODULE_LICENSE("GPL");
  839. MODULE_AUTHOR("T. Mertelj <tomaz.mertelj@guest.arnes.si>");
  840. MODULE_DESCRIPTION("Texas Instruments amc6821 hwmon driver");