emc2103.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * emc2103.c - Support for SMSC EMC2103
  4. * Copyright (c) 2010 SMSC
  5. */
  6. #include <linux/module.h>
  7. #include <linux/init.h>
  8. #include <linux/slab.h>
  9. #include <linux/jiffies.h>
  10. #include <linux/i2c.h>
  11. #include <linux/hwmon.h>
  12. #include <linux/hwmon-sysfs.h>
  13. #include <linux/err.h>
  14. #include <linux/mutex.h>
  15. /* Addresses scanned */
  16. static const unsigned short normal_i2c[] = { 0x2E, I2C_CLIENT_END };
  17. static const u8 REG_TEMP[4] = { 0x00, 0x02, 0x04, 0x06 };
  18. static const u8 REG_TEMP_MIN[4] = { 0x3c, 0x38, 0x39, 0x3a };
  19. static const u8 REG_TEMP_MAX[4] = { 0x34, 0x30, 0x31, 0x32 };
  20. #define REG_CONF1 0x20
  21. #define REG_TEMP_MAX_ALARM 0x24
  22. #define REG_TEMP_MIN_ALARM 0x25
  23. #define REG_FAN_CONF1 0x42
  24. #define REG_FAN_TARGET_LO 0x4c
  25. #define REG_FAN_TARGET_HI 0x4d
  26. #define REG_FAN_TACH_HI 0x4e
  27. #define REG_FAN_TACH_LO 0x4f
  28. #define REG_PRODUCT_ID 0xfd
  29. #define REG_MFG_ID 0xfe
  30. /* equation 4 from datasheet: rpm = (3932160 * multipler) / count */
  31. #define FAN_RPM_FACTOR 3932160
  32. /*
  33. * 2103-2 and 2103-4's 3rd temperature sensor can be connected to two diodes
  34. * in anti-parallel mode, and in this configuration both can be read
  35. * independently (so we have 4 temperature inputs). The device can't
  36. * detect if it's connected in this mode, so we have to manually enable
  37. * it. Default is to leave the device in the state it's already in (-1).
  38. * This parameter allows APD mode to be optionally forced on or off
  39. */
  40. static int apd = -1;
  41. module_param(apd, bint, 0);
  42. MODULE_PARM_DESC(apd, "Set to zero to disable anti-parallel diode mode");
  43. struct temperature {
  44. s8 degrees;
  45. u8 fraction; /* 0-7 multiples of 0.125 */
  46. };
  47. struct emc2103_data {
  48. struct i2c_client *client;
  49. const struct attribute_group *groups[4];
  50. struct mutex update_lock;
  51. bool valid; /* registers are valid */
  52. bool fan_rpm_control;
  53. int temp_count; /* num of temp sensors */
  54. unsigned long last_updated; /* in jiffies */
  55. struct temperature temp[4]; /* internal + 3 external */
  56. s8 temp_min[4]; /* no fractional part */
  57. s8 temp_max[4]; /* no fractional part */
  58. u8 temp_min_alarm;
  59. u8 temp_max_alarm;
  60. u8 fan_multiplier;
  61. u16 fan_tach;
  62. u16 fan_target;
  63. };
  64. static int read_u8_from_i2c(struct i2c_client *client, u8 i2c_reg, u8 *output)
  65. {
  66. int status = i2c_smbus_read_byte_data(client, i2c_reg);
  67. if (status < 0) {
  68. dev_warn(&client->dev, "reg 0x%02x, err %d\n",
  69. i2c_reg, status);
  70. } else {
  71. *output = status;
  72. }
  73. return status;
  74. }
  75. static void read_temp_from_i2c(struct i2c_client *client, u8 i2c_reg,
  76. struct temperature *temp)
  77. {
  78. u8 degrees, fractional;
  79. if (read_u8_from_i2c(client, i2c_reg, &degrees) < 0)
  80. return;
  81. if (read_u8_from_i2c(client, i2c_reg + 1, &fractional) < 0)
  82. return;
  83. temp->degrees = degrees;
  84. temp->fraction = (fractional & 0xe0) >> 5;
  85. }
  86. static void read_fan_from_i2c(struct i2c_client *client, u16 *output,
  87. u8 hi_addr, u8 lo_addr)
  88. {
  89. u8 high_byte, lo_byte;
  90. if (read_u8_from_i2c(client, hi_addr, &high_byte) < 0)
  91. return;
  92. if (read_u8_from_i2c(client, lo_addr, &lo_byte) < 0)
  93. return;
  94. *output = ((u16)high_byte << 5) | (lo_byte >> 3);
  95. }
  96. static void write_fan_target_to_i2c(struct i2c_client *client, u16 new_target)
  97. {
  98. u8 high_byte = (new_target & 0x1fe0) >> 5;
  99. u8 low_byte = (new_target & 0x001f) << 3;
  100. i2c_smbus_write_byte_data(client, REG_FAN_TARGET_LO, low_byte);
  101. i2c_smbus_write_byte_data(client, REG_FAN_TARGET_HI, high_byte);
  102. }
  103. static void read_fan_config_from_i2c(struct i2c_client *client)
  104. {
  105. struct emc2103_data *data = i2c_get_clientdata(client);
  106. u8 conf1;
  107. if (read_u8_from_i2c(client, REG_FAN_CONF1, &conf1) < 0)
  108. return;
  109. data->fan_multiplier = 1 << ((conf1 & 0x60) >> 5);
  110. data->fan_rpm_control = (conf1 & 0x80) != 0;
  111. }
  112. static struct emc2103_data *emc2103_update_device(struct device *dev)
  113. {
  114. struct emc2103_data *data = dev_get_drvdata(dev);
  115. struct i2c_client *client = data->client;
  116. mutex_lock(&data->update_lock);
  117. if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
  118. || !data->valid) {
  119. int i;
  120. for (i = 0; i < data->temp_count; i++) {
  121. read_temp_from_i2c(client, REG_TEMP[i], &data->temp[i]);
  122. read_u8_from_i2c(client, REG_TEMP_MIN[i],
  123. &data->temp_min[i]);
  124. read_u8_from_i2c(client, REG_TEMP_MAX[i],
  125. &data->temp_max[i]);
  126. }
  127. read_u8_from_i2c(client, REG_TEMP_MIN_ALARM,
  128. &data->temp_min_alarm);
  129. read_u8_from_i2c(client, REG_TEMP_MAX_ALARM,
  130. &data->temp_max_alarm);
  131. read_fan_from_i2c(client, &data->fan_tach,
  132. REG_FAN_TACH_HI, REG_FAN_TACH_LO);
  133. read_fan_from_i2c(client, &data->fan_target,
  134. REG_FAN_TARGET_HI, REG_FAN_TARGET_LO);
  135. read_fan_config_from_i2c(client);
  136. data->last_updated = jiffies;
  137. data->valid = true;
  138. }
  139. mutex_unlock(&data->update_lock);
  140. return data;
  141. }
  142. static ssize_t
  143. temp_show(struct device *dev, struct device_attribute *da, char *buf)
  144. {
  145. int nr = to_sensor_dev_attr(da)->index;
  146. struct emc2103_data *data = emc2103_update_device(dev);
  147. int millidegrees = data->temp[nr].degrees * 1000
  148. + data->temp[nr].fraction * 125;
  149. return sprintf(buf, "%d\n", millidegrees);
  150. }
  151. static ssize_t
  152. temp_min_show(struct device *dev, struct device_attribute *da, char *buf)
  153. {
  154. int nr = to_sensor_dev_attr(da)->index;
  155. struct emc2103_data *data = emc2103_update_device(dev);
  156. int millidegrees = data->temp_min[nr] * 1000;
  157. return sprintf(buf, "%d\n", millidegrees);
  158. }
  159. static ssize_t
  160. temp_max_show(struct device *dev, struct device_attribute *da, char *buf)
  161. {
  162. int nr = to_sensor_dev_attr(da)->index;
  163. struct emc2103_data *data = emc2103_update_device(dev);
  164. int millidegrees = data->temp_max[nr] * 1000;
  165. return sprintf(buf, "%d\n", millidegrees);
  166. }
  167. static ssize_t
  168. temp_fault_show(struct device *dev, struct device_attribute *da, char *buf)
  169. {
  170. int nr = to_sensor_dev_attr(da)->index;
  171. struct emc2103_data *data = emc2103_update_device(dev);
  172. bool fault = (data->temp[nr].degrees == -128);
  173. return sprintf(buf, "%d\n", fault ? 1 : 0);
  174. }
  175. static ssize_t
  176. temp_min_alarm_show(struct device *dev, struct device_attribute *da,
  177. char *buf)
  178. {
  179. int nr = to_sensor_dev_attr(da)->index;
  180. struct emc2103_data *data = emc2103_update_device(dev);
  181. bool alarm = data->temp_min_alarm & (1 << nr);
  182. return sprintf(buf, "%d\n", alarm ? 1 : 0);
  183. }
  184. static ssize_t
  185. temp_max_alarm_show(struct device *dev, struct device_attribute *da,
  186. char *buf)
  187. {
  188. int nr = to_sensor_dev_attr(da)->index;
  189. struct emc2103_data *data = emc2103_update_device(dev);
  190. bool alarm = data->temp_max_alarm & (1 << nr);
  191. return sprintf(buf, "%d\n", alarm ? 1 : 0);
  192. }
  193. static ssize_t temp_min_store(struct device *dev, struct device_attribute *da,
  194. const char *buf, size_t count)
  195. {
  196. int nr = to_sensor_dev_attr(da)->index;
  197. struct emc2103_data *data = dev_get_drvdata(dev);
  198. struct i2c_client *client = data->client;
  199. long val;
  200. int result = kstrtol(buf, 10, &val);
  201. if (result < 0)
  202. return result;
  203. val = DIV_ROUND_CLOSEST(clamp_val(val, -63000, 127000), 1000);
  204. mutex_lock(&data->update_lock);
  205. data->temp_min[nr] = val;
  206. i2c_smbus_write_byte_data(client, REG_TEMP_MIN[nr], val);
  207. mutex_unlock(&data->update_lock);
  208. return count;
  209. }
  210. static ssize_t temp_max_store(struct device *dev, struct device_attribute *da,
  211. const char *buf, size_t count)
  212. {
  213. int nr = to_sensor_dev_attr(da)->index;
  214. struct emc2103_data *data = dev_get_drvdata(dev);
  215. struct i2c_client *client = data->client;
  216. long val;
  217. int result = kstrtol(buf, 10, &val);
  218. if (result < 0)
  219. return result;
  220. val = DIV_ROUND_CLOSEST(clamp_val(val, -63000, 127000), 1000);
  221. mutex_lock(&data->update_lock);
  222. data->temp_max[nr] = val;
  223. i2c_smbus_write_byte_data(client, REG_TEMP_MAX[nr], val);
  224. mutex_unlock(&data->update_lock);
  225. return count;
  226. }
  227. static ssize_t
  228. fan1_input_show(struct device *dev, struct device_attribute *da, char *buf)
  229. {
  230. struct emc2103_data *data = emc2103_update_device(dev);
  231. int rpm = 0;
  232. if (data->fan_tach != 0)
  233. rpm = (FAN_RPM_FACTOR * data->fan_multiplier) / data->fan_tach;
  234. return sprintf(buf, "%d\n", rpm);
  235. }
  236. static ssize_t
  237. fan1_div_show(struct device *dev, struct device_attribute *da, char *buf)
  238. {
  239. struct emc2103_data *data = emc2103_update_device(dev);
  240. int fan_div = 8 / data->fan_multiplier;
  241. return sprintf(buf, "%d\n", fan_div);
  242. }
  243. /*
  244. * Note: we also update the fan target here, because its value is
  245. * determined in part by the fan clock divider. This follows the principle
  246. * of least surprise; the user doesn't expect the fan target to change just
  247. * because the divider changed.
  248. */
  249. static ssize_t fan1_div_store(struct device *dev, struct device_attribute *da,
  250. const char *buf, size_t count)
  251. {
  252. struct emc2103_data *data = emc2103_update_device(dev);
  253. struct i2c_client *client = data->client;
  254. int new_range_bits, old_div = 8 / data->fan_multiplier;
  255. long new_div;
  256. int status = kstrtol(buf, 10, &new_div);
  257. if (status < 0)
  258. return status;
  259. if (new_div == old_div) /* No change */
  260. return count;
  261. switch (new_div) {
  262. case 1:
  263. new_range_bits = 3;
  264. break;
  265. case 2:
  266. new_range_bits = 2;
  267. break;
  268. case 4:
  269. new_range_bits = 1;
  270. break;
  271. case 8:
  272. new_range_bits = 0;
  273. break;
  274. default:
  275. return -EINVAL;
  276. }
  277. mutex_lock(&data->update_lock);
  278. status = i2c_smbus_read_byte_data(client, REG_FAN_CONF1);
  279. if (status < 0) {
  280. dev_dbg(&client->dev, "reg 0x%02x, err %d\n",
  281. REG_FAN_CONF1, status);
  282. mutex_unlock(&data->update_lock);
  283. return status;
  284. }
  285. status &= 0x9F;
  286. status |= (new_range_bits << 5);
  287. i2c_smbus_write_byte_data(client, REG_FAN_CONF1, status);
  288. data->fan_multiplier = 8 / new_div;
  289. /* update fan target if high byte is not disabled */
  290. if ((data->fan_target & 0x1fe0) != 0x1fe0) {
  291. u16 new_target = (data->fan_target * old_div) / new_div;
  292. data->fan_target = min(new_target, (u16)0x1fff);
  293. write_fan_target_to_i2c(client, data->fan_target);
  294. }
  295. /* invalidate data to force re-read from hardware */
  296. data->valid = false;
  297. mutex_unlock(&data->update_lock);
  298. return count;
  299. }
  300. static ssize_t
  301. fan1_target_show(struct device *dev, struct device_attribute *da, char *buf)
  302. {
  303. struct emc2103_data *data = emc2103_update_device(dev);
  304. int rpm = 0;
  305. /* high byte of 0xff indicates disabled so return 0 */
  306. if ((data->fan_target != 0) && ((data->fan_target & 0x1fe0) != 0x1fe0))
  307. rpm = (FAN_RPM_FACTOR * data->fan_multiplier)
  308. / data->fan_target;
  309. return sprintf(buf, "%d\n", rpm);
  310. }
  311. static ssize_t fan1_target_store(struct device *dev,
  312. struct device_attribute *da, const char *buf,
  313. size_t count)
  314. {
  315. struct emc2103_data *data = emc2103_update_device(dev);
  316. struct i2c_client *client = data->client;
  317. unsigned long rpm_target;
  318. int result = kstrtoul(buf, 10, &rpm_target);
  319. if (result < 0)
  320. return result;
  321. /* Datasheet states 16384 as maximum RPM target (table 3.2) */
  322. rpm_target = clamp_val(rpm_target, 0, 16384);
  323. mutex_lock(&data->update_lock);
  324. if (rpm_target == 0)
  325. data->fan_target = 0x1fff;
  326. else
  327. data->fan_target = clamp_val(
  328. (FAN_RPM_FACTOR * data->fan_multiplier) / rpm_target,
  329. 0, 0x1fff);
  330. write_fan_target_to_i2c(client, data->fan_target);
  331. mutex_unlock(&data->update_lock);
  332. return count;
  333. }
  334. static ssize_t
  335. fan1_fault_show(struct device *dev, struct device_attribute *da, char *buf)
  336. {
  337. struct emc2103_data *data = emc2103_update_device(dev);
  338. bool fault = ((data->fan_tach & 0x1fe0) == 0x1fe0);
  339. return sprintf(buf, "%d\n", fault ? 1 : 0);
  340. }
  341. static ssize_t
  342. pwm1_enable_show(struct device *dev, struct device_attribute *da, char *buf)
  343. {
  344. struct emc2103_data *data = emc2103_update_device(dev);
  345. return sprintf(buf, "%d\n", data->fan_rpm_control ? 3 : 0);
  346. }
  347. static ssize_t pwm1_enable_store(struct device *dev,
  348. struct device_attribute *da, const char *buf,
  349. size_t count)
  350. {
  351. struct emc2103_data *data = dev_get_drvdata(dev);
  352. struct i2c_client *client = data->client;
  353. long new_value;
  354. u8 conf_reg;
  355. int result = kstrtol(buf, 10, &new_value);
  356. if (result < 0)
  357. return result;
  358. mutex_lock(&data->update_lock);
  359. switch (new_value) {
  360. case 0:
  361. data->fan_rpm_control = false;
  362. break;
  363. case 3:
  364. data->fan_rpm_control = true;
  365. break;
  366. default:
  367. count = -EINVAL;
  368. goto err;
  369. }
  370. result = read_u8_from_i2c(client, REG_FAN_CONF1, &conf_reg);
  371. if (result < 0) {
  372. count = result;
  373. goto err;
  374. }
  375. if (data->fan_rpm_control)
  376. conf_reg |= 0x80;
  377. else
  378. conf_reg &= ~0x80;
  379. i2c_smbus_write_byte_data(client, REG_FAN_CONF1, conf_reg);
  380. err:
  381. mutex_unlock(&data->update_lock);
  382. return count;
  383. }
  384. static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0);
  385. static SENSOR_DEVICE_ATTR_RW(temp1_min, temp_min, 0);
  386. static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0);
  387. static SENSOR_DEVICE_ATTR_RO(temp1_fault, temp_fault, 0);
  388. static SENSOR_DEVICE_ATTR_RO(temp1_min_alarm, temp_min_alarm, 0);
  389. static SENSOR_DEVICE_ATTR_RO(temp1_max_alarm, temp_max_alarm, 0);
  390. static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1);
  391. static SENSOR_DEVICE_ATTR_RW(temp2_min, temp_min, 1);
  392. static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);
  393. static SENSOR_DEVICE_ATTR_RO(temp2_fault, temp_fault, 1);
  394. static SENSOR_DEVICE_ATTR_RO(temp2_min_alarm, temp_min_alarm, 1);
  395. static SENSOR_DEVICE_ATTR_RO(temp2_max_alarm, temp_max_alarm, 1);
  396. static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2);
  397. static SENSOR_DEVICE_ATTR_RW(temp3_min, temp_min, 2);
  398. static SENSOR_DEVICE_ATTR_RW(temp3_max, temp_max, 2);
  399. static SENSOR_DEVICE_ATTR_RO(temp3_fault, temp_fault, 2);
  400. static SENSOR_DEVICE_ATTR_RO(temp3_min_alarm, temp_min_alarm, 2);
  401. static SENSOR_DEVICE_ATTR_RO(temp3_max_alarm, temp_max_alarm, 2);
  402. static SENSOR_DEVICE_ATTR_RO(temp4_input, temp, 3);
  403. static SENSOR_DEVICE_ATTR_RW(temp4_min, temp_min, 3);
  404. static SENSOR_DEVICE_ATTR_RW(temp4_max, temp_max, 3);
  405. static SENSOR_DEVICE_ATTR_RO(temp4_fault, temp_fault, 3);
  406. static SENSOR_DEVICE_ATTR_RO(temp4_min_alarm, temp_min_alarm, 3);
  407. static SENSOR_DEVICE_ATTR_RO(temp4_max_alarm, temp_max_alarm, 3);
  408. static DEVICE_ATTR_RO(fan1_input);
  409. static DEVICE_ATTR_RW(fan1_div);
  410. static DEVICE_ATTR_RW(fan1_target);
  411. static DEVICE_ATTR_RO(fan1_fault);
  412. static DEVICE_ATTR_RW(pwm1_enable);
  413. /* sensors present on all models */
  414. static struct attribute *emc2103_attributes[] = {
  415. &sensor_dev_attr_temp1_input.dev_attr.attr,
  416. &sensor_dev_attr_temp1_min.dev_attr.attr,
  417. &sensor_dev_attr_temp1_max.dev_attr.attr,
  418. &sensor_dev_attr_temp1_fault.dev_attr.attr,
  419. &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
  420. &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
  421. &sensor_dev_attr_temp2_input.dev_attr.attr,
  422. &sensor_dev_attr_temp2_min.dev_attr.attr,
  423. &sensor_dev_attr_temp2_max.dev_attr.attr,
  424. &sensor_dev_attr_temp2_fault.dev_attr.attr,
  425. &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
  426. &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
  427. &dev_attr_fan1_input.attr,
  428. &dev_attr_fan1_div.attr,
  429. &dev_attr_fan1_target.attr,
  430. &dev_attr_fan1_fault.attr,
  431. &dev_attr_pwm1_enable.attr,
  432. NULL
  433. };
  434. /* extra temperature sensors only present on 2103-2 and 2103-4 */
  435. static struct attribute *emc2103_attributes_temp3[] = {
  436. &sensor_dev_attr_temp3_input.dev_attr.attr,
  437. &sensor_dev_attr_temp3_min.dev_attr.attr,
  438. &sensor_dev_attr_temp3_max.dev_attr.attr,
  439. &sensor_dev_attr_temp3_fault.dev_attr.attr,
  440. &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
  441. &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
  442. NULL
  443. };
  444. /* extra temperature sensors only present on 2103-2 and 2103-4 in APD mode */
  445. static struct attribute *emc2103_attributes_temp4[] = {
  446. &sensor_dev_attr_temp4_input.dev_attr.attr,
  447. &sensor_dev_attr_temp4_min.dev_attr.attr,
  448. &sensor_dev_attr_temp4_max.dev_attr.attr,
  449. &sensor_dev_attr_temp4_fault.dev_attr.attr,
  450. &sensor_dev_attr_temp4_min_alarm.dev_attr.attr,
  451. &sensor_dev_attr_temp4_max_alarm.dev_attr.attr,
  452. NULL
  453. };
  454. static const struct attribute_group emc2103_group = {
  455. .attrs = emc2103_attributes,
  456. };
  457. static const struct attribute_group emc2103_temp3_group = {
  458. .attrs = emc2103_attributes_temp3,
  459. };
  460. static const struct attribute_group emc2103_temp4_group = {
  461. .attrs = emc2103_attributes_temp4,
  462. };
  463. static int
  464. emc2103_probe(struct i2c_client *client)
  465. {
  466. struct emc2103_data *data;
  467. struct device *hwmon_dev;
  468. int status, idx = 0;
  469. if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
  470. return -EIO;
  471. data = devm_kzalloc(&client->dev, sizeof(struct emc2103_data),
  472. GFP_KERNEL);
  473. if (!data)
  474. return -ENOMEM;
  475. i2c_set_clientdata(client, data);
  476. data->client = client;
  477. mutex_init(&data->update_lock);
  478. /* 2103-2 and 2103-4 have 3 external diodes, 2103-1 has 1 */
  479. status = i2c_smbus_read_byte_data(client, REG_PRODUCT_ID);
  480. if (status == 0x24) {
  481. /* 2103-1 only has 1 external diode */
  482. data->temp_count = 2;
  483. } else {
  484. /* 2103-2 and 2103-4 have 3 or 4 external diodes */
  485. status = i2c_smbus_read_byte_data(client, REG_CONF1);
  486. if (status < 0) {
  487. dev_dbg(&client->dev, "reg 0x%02x, err %d\n", REG_CONF1,
  488. status);
  489. return status;
  490. }
  491. /* detect current state of hardware */
  492. data->temp_count = (status & 0x01) ? 4 : 3;
  493. /* force APD state if module parameter is set */
  494. if (apd == 0) {
  495. /* force APD mode off */
  496. data->temp_count = 3;
  497. status &= ~(0x01);
  498. i2c_smbus_write_byte_data(client, REG_CONF1, status);
  499. } else if (apd == 1) {
  500. /* force APD mode on */
  501. data->temp_count = 4;
  502. status |= 0x01;
  503. i2c_smbus_write_byte_data(client, REG_CONF1, status);
  504. }
  505. }
  506. /* sysfs hooks */
  507. data->groups[idx++] = &emc2103_group;
  508. if (data->temp_count >= 3)
  509. data->groups[idx++] = &emc2103_temp3_group;
  510. if (data->temp_count == 4)
  511. data->groups[idx++] = &emc2103_temp4_group;
  512. hwmon_dev = devm_hwmon_device_register_with_groups(&client->dev,
  513. client->name, data,
  514. data->groups);
  515. if (IS_ERR(hwmon_dev))
  516. return PTR_ERR(hwmon_dev);
  517. dev_info(&client->dev, "%s: sensor '%s'\n",
  518. dev_name(hwmon_dev), client->name);
  519. return 0;
  520. }
  521. static const struct i2c_device_id emc2103_ids[] = {
  522. { "emc2103", 0, },
  523. { /* LIST END */ }
  524. };
  525. MODULE_DEVICE_TABLE(i2c, emc2103_ids);
  526. /* Return 0 if detection is successful, -ENODEV otherwise */
  527. static int
  528. emc2103_detect(struct i2c_client *new_client, struct i2c_board_info *info)
  529. {
  530. struct i2c_adapter *adapter = new_client->adapter;
  531. int manufacturer, product;
  532. if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
  533. return -ENODEV;
  534. manufacturer = i2c_smbus_read_byte_data(new_client, REG_MFG_ID);
  535. if (manufacturer != 0x5D)
  536. return -ENODEV;
  537. product = i2c_smbus_read_byte_data(new_client, REG_PRODUCT_ID);
  538. if ((product != 0x24) && (product != 0x26))
  539. return -ENODEV;
  540. strscpy(info->type, "emc2103", I2C_NAME_SIZE);
  541. return 0;
  542. }
  543. static struct i2c_driver emc2103_driver = {
  544. .class = I2C_CLASS_HWMON,
  545. .driver = {
  546. .name = "emc2103",
  547. },
  548. .probe_new = emc2103_probe,
  549. .id_table = emc2103_ids,
  550. .detect = emc2103_detect,
  551. .address_list = normal_i2c,
  552. };
  553. module_i2c_driver(emc2103_driver);
  554. MODULE_AUTHOR("Steve Glendinning <[email protected]>");
  555. MODULE_DESCRIPTION("SMSC EMC2103 hwmon driver");
  556. MODULE_LICENSE("GPL");