ltc2978.c 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Hardware monitoring driver for LTC2978 and compatible chips.
  4. *
  5. * Copyright (c) 2011 Ericsson AB.
  6. * Copyright (c) 2013, 2014, 2015 Guenter Roeck
  7. * Copyright (c) 2015 Linear Technology
  8. * Copyright (c) 2018 Analog Devices Inc.
  9. */
  10. #include <linux/delay.h>
  11. #include <linux/jiffies.h>
  12. #include <linux/kernel.h>
  13. #include <linux/module.h>
  14. #include <linux/init.h>
  15. #include <linux/err.h>
  16. #include <linux/slab.h>
  17. #include <linux/i2c.h>
  18. #include <linux/regulator/driver.h>
  19. #include "pmbus.h"
  20. enum chips {
  21. /* Managers */
  22. ltc2972, ltc2974, ltc2975, ltc2977, ltc2978, ltc2979, ltc2980,
  23. /* Controllers */
  24. ltc3880, ltc3882, ltc3883, ltc3884, ltc3886, ltc3887, ltc3889, ltc7880,
  25. /* Modules */
  26. ltm2987, ltm4664, ltm4675, ltm4676, ltm4677, ltm4678, ltm4680, ltm4686,
  27. ltm4700,
  28. };
  29. /* Common for all chips */
  30. #define LTC2978_MFR_VOUT_PEAK 0xdd
  31. #define LTC2978_MFR_VIN_PEAK 0xde
  32. #define LTC2978_MFR_TEMPERATURE_PEAK 0xdf
  33. #define LTC2978_MFR_SPECIAL_ID 0xe7 /* Undocumented on LTC3882 */
  34. #define LTC2978_MFR_COMMON 0xef
  35. /* LTC2974, LTC2975, LCT2977, LTC2980, LTC2978, and LTM2987 */
  36. #define LTC2978_MFR_VOUT_MIN 0xfb
  37. #define LTC2978_MFR_VIN_MIN 0xfc
  38. #define LTC2978_MFR_TEMPERATURE_MIN 0xfd
  39. /* LTC2974, LTC2975 */
  40. #define LTC2974_MFR_IOUT_PEAK 0xd7
  41. #define LTC2974_MFR_IOUT_MIN 0xd8
  42. /* LTC3880, LTC3882, LTC3883, LTC3887, LTM4675, and LTM4676 */
  43. #define LTC3880_MFR_IOUT_PEAK 0xd7
  44. #define LTC3880_MFR_CLEAR_PEAKS 0xe3
  45. #define LTC3880_MFR_TEMPERATURE2_PEAK 0xf4
  46. /* LTC3883, LTC3884, LTC3886, LTC3889 and LTC7880 only */
  47. #define LTC3883_MFR_IIN_PEAK 0xe1
  48. /* LTC2975 only */
  49. #define LTC2975_MFR_IIN_PEAK 0xc4
  50. #define LTC2975_MFR_IIN_MIN 0xc5
  51. #define LTC2975_MFR_PIN_PEAK 0xc6
  52. #define LTC2975_MFR_PIN_MIN 0xc7
  53. #define LTC2978_ID_MASK 0xfff0
  54. #define LTC2972_ID 0x0310
  55. #define LTC2974_ID 0x0210
  56. #define LTC2975_ID 0x0220
  57. #define LTC2977_ID 0x0130
  58. #define LTC2978_ID_REV1 0x0110 /* Early revision */
  59. #define LTC2978_ID_REV2 0x0120
  60. #define LTC2979_ID_A 0x8060
  61. #define LTC2979_ID_B 0x8070
  62. #define LTC2980_ID_A 0x8030 /* A/B for two die IDs */
  63. #define LTC2980_ID_B 0x8040
  64. #define LTC3880_ID 0x4020
  65. #define LTC3882_ID 0x4200
  66. #define LTC3882_ID_D1 0x4240 /* Dash 1 */
  67. #define LTC3883_ID 0x4300
  68. #define LTC3884_ID 0x4C00
  69. #define LTC3886_ID 0x4600
  70. #define LTC3887_ID 0x4700
  71. #define LTM2987_ID_A 0x8010 /* A/B for two die IDs */
  72. #define LTM2987_ID_B 0x8020
  73. #define LTC3889_ID 0x4900
  74. #define LTC7880_ID 0x49E0
  75. #define LTM4664_ID 0x4120
  76. #define LTM4675_ID 0x47a0
  77. #define LTM4676_ID_REV1 0x4400
  78. #define LTM4676_ID_REV2 0x4480
  79. #define LTM4676A_ID 0x47e0
  80. #define LTM4677_ID_REV1 0x47B0
  81. #define LTM4677_ID_REV2 0x47D0
  82. #define LTM4678_ID_REV1 0x4100
  83. #define LTM4678_ID_REV2 0x4110
  84. #define LTM4680_ID 0x4140
  85. #define LTM4686_ID 0x4770
  86. #define LTM4700_ID 0x4130
  87. #define LTC2972_NUM_PAGES 2
  88. #define LTC2974_NUM_PAGES 4
  89. #define LTC2978_NUM_PAGES 8
  90. #define LTC3880_NUM_PAGES 2
  91. #define LTC3883_NUM_PAGES 1
  92. #define LTC_POLL_TIMEOUT 100 /* in milli-seconds */
  93. #define LTC_NOT_BUSY BIT(6)
  94. #define LTC_NOT_PENDING BIT(5)
  95. /*
  96. * LTC2978 clears peak data whenever the CLEAR_FAULTS command is executed, which
  97. * happens pretty much each time chip data is updated. Raw peak data therefore
  98. * does not provide much value. To be able to provide useful peak data, keep an
  99. * internal cache of measured peak data, which is only cleared if an explicit
  100. * "clear peak" command is executed for the sensor in question.
  101. */
  102. struct ltc2978_data {
  103. enum chips id;
  104. u16 vin_min, vin_max;
  105. u16 temp_min[LTC2974_NUM_PAGES], temp_max[LTC2974_NUM_PAGES];
  106. u16 vout_min[LTC2978_NUM_PAGES], vout_max[LTC2978_NUM_PAGES];
  107. u16 iout_min[LTC2974_NUM_PAGES], iout_max[LTC2974_NUM_PAGES];
  108. u16 iin_min, iin_max;
  109. u16 pin_min, pin_max;
  110. u16 temp2_max;
  111. struct pmbus_driver_info info;
  112. u32 features;
  113. };
  114. #define to_ltc2978_data(x) container_of(x, struct ltc2978_data, info)
  115. #define FEAT_CLEAR_PEAKS BIT(0)
  116. #define FEAT_NEEDS_POLLING BIT(1)
  117. #define has_clear_peaks(d) ((d)->features & FEAT_CLEAR_PEAKS)
  118. #define needs_polling(d) ((d)->features & FEAT_NEEDS_POLLING)
  119. static int ltc_wait_ready(struct i2c_client *client)
  120. {
  121. unsigned long timeout = jiffies + msecs_to_jiffies(LTC_POLL_TIMEOUT);
  122. const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
  123. struct ltc2978_data *data = to_ltc2978_data(info);
  124. int status;
  125. u8 mask;
  126. if (!needs_polling(data))
  127. return 0;
  128. /*
  129. * LTC3883 does not support LTC_NOT_PENDING, even though
  130. * the datasheet claims that it does.
  131. */
  132. mask = LTC_NOT_BUSY;
  133. if (data->id != ltc3883)
  134. mask |= LTC_NOT_PENDING;
  135. do {
  136. status = pmbus_read_byte_data(client, 0, LTC2978_MFR_COMMON);
  137. if (status == -EBADMSG || status == -ENXIO) {
  138. /* PEC error or NACK: chip may be busy, try again */
  139. usleep_range(50, 100);
  140. continue;
  141. }
  142. if (status < 0)
  143. return status;
  144. if ((status & mask) == mask)
  145. return 0;
  146. usleep_range(50, 100);
  147. } while (time_before(jiffies, timeout));
  148. return -ETIMEDOUT;
  149. }
  150. static int ltc_read_word_data(struct i2c_client *client, int page, int phase,
  151. int reg)
  152. {
  153. int ret;
  154. ret = ltc_wait_ready(client);
  155. if (ret < 0)
  156. return ret;
  157. return pmbus_read_word_data(client, page, 0xff, reg);
  158. }
  159. static int ltc_read_byte_data(struct i2c_client *client, int page, int reg)
  160. {
  161. int ret;
  162. ret = ltc_wait_ready(client);
  163. if (ret < 0)
  164. return ret;
  165. return pmbus_read_byte_data(client, page, reg);
  166. }
  167. static int ltc_write_byte_data(struct i2c_client *client, int page, int reg, u8 value)
  168. {
  169. int ret;
  170. ret = ltc_wait_ready(client);
  171. if (ret < 0)
  172. return ret;
  173. return pmbus_write_byte_data(client, page, reg, value);
  174. }
  175. static int ltc_write_byte(struct i2c_client *client, int page, u8 byte)
  176. {
  177. int ret;
  178. ret = ltc_wait_ready(client);
  179. if (ret < 0)
  180. return ret;
  181. return pmbus_write_byte(client, page, byte);
  182. }
  183. static inline int lin11_to_val(int data)
  184. {
  185. s16 e = ((s16)data) >> 11;
  186. s32 m = (((s16)(data << 5)) >> 5);
  187. /*
  188. * mantissa is 10 bit + sign, exponent adds up to 15 bit.
  189. * Add 6 bit to exponent for maximum accuracy (10 + 15 + 6 = 31).
  190. */
  191. e += 6;
  192. return (e < 0 ? m >> -e : m << e);
  193. }
  194. static int ltc_get_max(struct ltc2978_data *data, struct i2c_client *client,
  195. int page, int reg, u16 *pmax)
  196. {
  197. int ret;
  198. ret = ltc_read_word_data(client, page, 0xff, reg);
  199. if (ret >= 0) {
  200. if (lin11_to_val(ret) > lin11_to_val(*pmax))
  201. *pmax = ret;
  202. ret = *pmax;
  203. }
  204. return ret;
  205. }
  206. static int ltc_get_min(struct ltc2978_data *data, struct i2c_client *client,
  207. int page, int reg, u16 *pmin)
  208. {
  209. int ret;
  210. ret = ltc_read_word_data(client, page, 0xff, reg);
  211. if (ret >= 0) {
  212. if (lin11_to_val(ret) < lin11_to_val(*pmin))
  213. *pmin = ret;
  214. ret = *pmin;
  215. }
  216. return ret;
  217. }
  218. static int ltc2978_read_word_data_common(struct i2c_client *client, int page,
  219. int reg)
  220. {
  221. const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
  222. struct ltc2978_data *data = to_ltc2978_data(info);
  223. int ret;
  224. switch (reg) {
  225. case PMBUS_VIRT_READ_VIN_MAX:
  226. ret = ltc_get_max(data, client, page, LTC2978_MFR_VIN_PEAK,
  227. &data->vin_max);
  228. break;
  229. case PMBUS_VIRT_READ_VOUT_MAX:
  230. ret = ltc_read_word_data(client, page, 0xff,
  231. LTC2978_MFR_VOUT_PEAK);
  232. if (ret >= 0) {
  233. /*
  234. * VOUT is 16 bit unsigned with fixed exponent,
  235. * so we can compare it directly
  236. */
  237. if (ret > data->vout_max[page])
  238. data->vout_max[page] = ret;
  239. ret = data->vout_max[page];
  240. }
  241. break;
  242. case PMBUS_VIRT_READ_TEMP_MAX:
  243. ret = ltc_get_max(data, client, page,
  244. LTC2978_MFR_TEMPERATURE_PEAK,
  245. &data->temp_max[page]);
  246. break;
  247. case PMBUS_VIRT_RESET_VOUT_HISTORY:
  248. case PMBUS_VIRT_RESET_VIN_HISTORY:
  249. case PMBUS_VIRT_RESET_TEMP_HISTORY:
  250. ret = 0;
  251. break;
  252. default:
  253. ret = ltc_wait_ready(client);
  254. if (ret < 0)
  255. return ret;
  256. ret = -ENODATA;
  257. break;
  258. }
  259. return ret;
  260. }
  261. static int ltc2978_read_word_data(struct i2c_client *client, int page,
  262. int phase, int reg)
  263. {
  264. const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
  265. struct ltc2978_data *data = to_ltc2978_data(info);
  266. int ret;
  267. switch (reg) {
  268. case PMBUS_VIRT_READ_VIN_MIN:
  269. ret = ltc_get_min(data, client, page, LTC2978_MFR_VIN_MIN,
  270. &data->vin_min);
  271. break;
  272. case PMBUS_VIRT_READ_VOUT_MIN:
  273. ret = ltc_read_word_data(client, page, phase,
  274. LTC2978_MFR_VOUT_MIN);
  275. if (ret >= 0) {
  276. /*
  277. * VOUT_MIN is known to not be supported on some lots
  278. * of LTC2978 revision 1, and will return the maximum
  279. * possible voltage if read. If VOUT_MAX is valid and
  280. * lower than the reading of VOUT_MIN, use it instead.
  281. */
  282. if (data->vout_max[page] && ret > data->vout_max[page])
  283. ret = data->vout_max[page];
  284. if (ret < data->vout_min[page])
  285. data->vout_min[page] = ret;
  286. ret = data->vout_min[page];
  287. }
  288. break;
  289. case PMBUS_VIRT_READ_TEMP_MIN:
  290. ret = ltc_get_min(data, client, page,
  291. LTC2978_MFR_TEMPERATURE_MIN,
  292. &data->temp_min[page]);
  293. break;
  294. case PMBUS_VIRT_READ_IOUT_MAX:
  295. case PMBUS_VIRT_RESET_IOUT_HISTORY:
  296. case PMBUS_VIRT_READ_TEMP2_MAX:
  297. case PMBUS_VIRT_RESET_TEMP2_HISTORY:
  298. ret = -ENXIO;
  299. break;
  300. default:
  301. ret = ltc2978_read_word_data_common(client, page, reg);
  302. break;
  303. }
  304. return ret;
  305. }
  306. static int ltc2974_read_word_data(struct i2c_client *client, int page,
  307. int phase, int reg)
  308. {
  309. const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
  310. struct ltc2978_data *data = to_ltc2978_data(info);
  311. int ret;
  312. switch (reg) {
  313. case PMBUS_VIRT_READ_IOUT_MAX:
  314. ret = ltc_get_max(data, client, page, LTC2974_MFR_IOUT_PEAK,
  315. &data->iout_max[page]);
  316. break;
  317. case PMBUS_VIRT_READ_IOUT_MIN:
  318. ret = ltc_get_min(data, client, page, LTC2974_MFR_IOUT_MIN,
  319. &data->iout_min[page]);
  320. break;
  321. case PMBUS_VIRT_RESET_IOUT_HISTORY:
  322. ret = 0;
  323. break;
  324. default:
  325. ret = ltc2978_read_word_data(client, page, phase, reg);
  326. break;
  327. }
  328. return ret;
  329. }
  330. static int ltc2975_read_word_data(struct i2c_client *client, int page,
  331. int phase, int reg)
  332. {
  333. const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
  334. struct ltc2978_data *data = to_ltc2978_data(info);
  335. int ret;
  336. switch (reg) {
  337. case PMBUS_VIRT_READ_IIN_MAX:
  338. ret = ltc_get_max(data, client, page, LTC2975_MFR_IIN_PEAK,
  339. &data->iin_max);
  340. break;
  341. case PMBUS_VIRT_READ_IIN_MIN:
  342. ret = ltc_get_min(data, client, page, LTC2975_MFR_IIN_MIN,
  343. &data->iin_min);
  344. break;
  345. case PMBUS_VIRT_READ_PIN_MAX:
  346. ret = ltc_get_max(data, client, page, LTC2975_MFR_PIN_PEAK,
  347. &data->pin_max);
  348. break;
  349. case PMBUS_VIRT_READ_PIN_MIN:
  350. ret = ltc_get_min(data, client, page, LTC2975_MFR_PIN_MIN,
  351. &data->pin_min);
  352. break;
  353. case PMBUS_VIRT_RESET_IIN_HISTORY:
  354. case PMBUS_VIRT_RESET_PIN_HISTORY:
  355. ret = 0;
  356. break;
  357. default:
  358. ret = ltc2978_read_word_data(client, page, phase, reg);
  359. break;
  360. }
  361. return ret;
  362. }
  363. static int ltc3880_read_word_data(struct i2c_client *client, int page,
  364. int phase, int reg)
  365. {
  366. const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
  367. struct ltc2978_data *data = to_ltc2978_data(info);
  368. int ret;
  369. switch (reg) {
  370. case PMBUS_VIRT_READ_IOUT_MAX:
  371. ret = ltc_get_max(data, client, page, LTC3880_MFR_IOUT_PEAK,
  372. &data->iout_max[page]);
  373. break;
  374. case PMBUS_VIRT_READ_TEMP2_MAX:
  375. ret = ltc_get_max(data, client, page,
  376. LTC3880_MFR_TEMPERATURE2_PEAK,
  377. &data->temp2_max);
  378. break;
  379. case PMBUS_VIRT_READ_VIN_MIN:
  380. case PMBUS_VIRT_READ_VOUT_MIN:
  381. case PMBUS_VIRT_READ_TEMP_MIN:
  382. ret = -ENXIO;
  383. break;
  384. case PMBUS_VIRT_RESET_IOUT_HISTORY:
  385. case PMBUS_VIRT_RESET_TEMP2_HISTORY:
  386. ret = 0;
  387. break;
  388. default:
  389. ret = ltc2978_read_word_data_common(client, page, reg);
  390. break;
  391. }
  392. return ret;
  393. }
  394. static int ltc3883_read_word_data(struct i2c_client *client, int page,
  395. int phase, int reg)
  396. {
  397. const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
  398. struct ltc2978_data *data = to_ltc2978_data(info);
  399. int ret;
  400. switch (reg) {
  401. case PMBUS_VIRT_READ_IIN_MAX:
  402. ret = ltc_get_max(data, client, page, LTC3883_MFR_IIN_PEAK,
  403. &data->iin_max);
  404. break;
  405. case PMBUS_VIRT_RESET_IIN_HISTORY:
  406. ret = 0;
  407. break;
  408. default:
  409. ret = ltc3880_read_word_data(client, page, phase, reg);
  410. break;
  411. }
  412. return ret;
  413. }
  414. static int ltc2978_clear_peaks(struct ltc2978_data *data,
  415. struct i2c_client *client, int page)
  416. {
  417. int ret;
  418. if (has_clear_peaks(data))
  419. ret = ltc_write_byte(client, 0, LTC3880_MFR_CLEAR_PEAKS);
  420. else
  421. ret = ltc_write_byte(client, page, PMBUS_CLEAR_FAULTS);
  422. return ret;
  423. }
  424. static int ltc2978_write_word_data(struct i2c_client *client, int page,
  425. int reg, u16 word)
  426. {
  427. const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
  428. struct ltc2978_data *data = to_ltc2978_data(info);
  429. int ret;
  430. switch (reg) {
  431. case PMBUS_VIRT_RESET_IIN_HISTORY:
  432. data->iin_max = 0x7c00;
  433. data->iin_min = 0x7bff;
  434. ret = ltc2978_clear_peaks(data, client, 0);
  435. break;
  436. case PMBUS_VIRT_RESET_PIN_HISTORY:
  437. data->pin_max = 0x7c00;
  438. data->pin_min = 0x7bff;
  439. ret = ltc2978_clear_peaks(data, client, 0);
  440. break;
  441. case PMBUS_VIRT_RESET_IOUT_HISTORY:
  442. data->iout_max[page] = 0x7c00;
  443. data->iout_min[page] = 0xfbff;
  444. ret = ltc2978_clear_peaks(data, client, page);
  445. break;
  446. case PMBUS_VIRT_RESET_TEMP2_HISTORY:
  447. data->temp2_max = 0x7c00;
  448. ret = ltc2978_clear_peaks(data, client, page);
  449. break;
  450. case PMBUS_VIRT_RESET_VOUT_HISTORY:
  451. data->vout_min[page] = 0xffff;
  452. data->vout_max[page] = 0;
  453. ret = ltc2978_clear_peaks(data, client, page);
  454. break;
  455. case PMBUS_VIRT_RESET_VIN_HISTORY:
  456. data->vin_min = 0x7bff;
  457. data->vin_max = 0x7c00;
  458. ret = ltc2978_clear_peaks(data, client, page);
  459. break;
  460. case PMBUS_VIRT_RESET_TEMP_HISTORY:
  461. data->temp_min[page] = 0x7bff;
  462. data->temp_max[page] = 0x7c00;
  463. ret = ltc2978_clear_peaks(data, client, page);
  464. break;
  465. default:
  466. ret = ltc_wait_ready(client);
  467. if (ret < 0)
  468. return ret;
  469. ret = -ENODATA;
  470. break;
  471. }
  472. return ret;
  473. }
  474. static const struct i2c_device_id ltc2978_id[] = {
  475. {"ltc2972", ltc2972},
  476. {"ltc2974", ltc2974},
  477. {"ltc2975", ltc2975},
  478. {"ltc2977", ltc2977},
  479. {"ltc2978", ltc2978},
  480. {"ltc2979", ltc2979},
  481. {"ltc2980", ltc2980},
  482. {"ltc3880", ltc3880},
  483. {"ltc3882", ltc3882},
  484. {"ltc3883", ltc3883},
  485. {"ltc3884", ltc3884},
  486. {"ltc3886", ltc3886},
  487. {"ltc3887", ltc3887},
  488. {"ltc3889", ltc3889},
  489. {"ltc7880", ltc7880},
  490. {"ltm2987", ltm2987},
  491. {"ltm4664", ltm4664},
  492. {"ltm4675", ltm4675},
  493. {"ltm4676", ltm4676},
  494. {"ltm4677", ltm4677},
  495. {"ltm4678", ltm4678},
  496. {"ltm4680", ltm4680},
  497. {"ltm4686", ltm4686},
  498. {"ltm4700", ltm4700},
  499. {}
  500. };
  501. MODULE_DEVICE_TABLE(i2c, ltc2978_id);
  502. #if IS_ENABLED(CONFIG_SENSORS_LTC2978_REGULATOR)
  503. #define LTC2978_ADC_RES 0xFFFF
  504. #define LTC2978_N_ADC 122
  505. #define LTC2978_MAX_UV (LTC2978_ADC_RES * LTC2978_N_ADC)
  506. #define LTC2978_UV_STEP 1000
  507. #define LTC2978_N_VOLTAGES ((LTC2978_MAX_UV / LTC2978_UV_STEP) + 1)
  508. static const struct regulator_desc ltc2978_reg_desc[] = {
  509. PMBUS_REGULATOR_STEP("vout", 0, LTC2978_N_VOLTAGES, LTC2978_UV_STEP),
  510. PMBUS_REGULATOR_STEP("vout", 1, LTC2978_N_VOLTAGES, LTC2978_UV_STEP),
  511. PMBUS_REGULATOR_STEP("vout", 2, LTC2978_N_VOLTAGES, LTC2978_UV_STEP),
  512. PMBUS_REGULATOR_STEP("vout", 3, LTC2978_N_VOLTAGES, LTC2978_UV_STEP),
  513. PMBUS_REGULATOR_STEP("vout", 4, LTC2978_N_VOLTAGES, LTC2978_UV_STEP),
  514. PMBUS_REGULATOR_STEP("vout", 5, LTC2978_N_VOLTAGES, LTC2978_UV_STEP),
  515. PMBUS_REGULATOR_STEP("vout", 6, LTC2978_N_VOLTAGES, LTC2978_UV_STEP),
  516. PMBUS_REGULATOR_STEP("vout", 7, LTC2978_N_VOLTAGES, LTC2978_UV_STEP),
  517. };
  518. static const struct regulator_desc ltc2978_reg_desc_default[] = {
  519. PMBUS_REGULATOR("vout", 0),
  520. PMBUS_REGULATOR("vout", 1),
  521. PMBUS_REGULATOR("vout", 2),
  522. PMBUS_REGULATOR("vout", 3),
  523. PMBUS_REGULATOR("vout", 4),
  524. PMBUS_REGULATOR("vout", 5),
  525. PMBUS_REGULATOR("vout", 6),
  526. PMBUS_REGULATOR("vout", 7),
  527. };
  528. #endif /* CONFIG_SENSORS_LTC2978_REGULATOR */
  529. static int ltc2978_get_id(struct i2c_client *client)
  530. {
  531. int chip_id;
  532. chip_id = i2c_smbus_read_word_data(client, LTC2978_MFR_SPECIAL_ID);
  533. if (chip_id < 0) {
  534. const struct i2c_device_id *id;
  535. u8 buf[I2C_SMBUS_BLOCK_MAX];
  536. int ret;
  537. if (!i2c_check_functionality(client->adapter,
  538. I2C_FUNC_SMBUS_READ_BLOCK_DATA))
  539. return -ENODEV;
  540. ret = i2c_smbus_read_block_data(client, PMBUS_MFR_ID, buf);
  541. if (ret < 0)
  542. return ret;
  543. if (ret < 3 || strncmp(buf, "LTC", 3))
  544. return -ENODEV;
  545. ret = i2c_smbus_read_block_data(client, PMBUS_MFR_MODEL, buf);
  546. if (ret < 0)
  547. return ret;
  548. for (id = &ltc2978_id[0]; strlen(id->name); id++) {
  549. if (!strncasecmp(id->name, buf, strlen(id->name)))
  550. return (int)id->driver_data;
  551. }
  552. return -ENODEV;
  553. }
  554. chip_id &= LTC2978_ID_MASK;
  555. if (chip_id == LTC2972_ID)
  556. return ltc2972;
  557. else if (chip_id == LTC2974_ID)
  558. return ltc2974;
  559. else if (chip_id == LTC2975_ID)
  560. return ltc2975;
  561. else if (chip_id == LTC2977_ID)
  562. return ltc2977;
  563. else if (chip_id == LTC2978_ID_REV1 || chip_id == LTC2978_ID_REV2)
  564. return ltc2978;
  565. else if (chip_id == LTC2979_ID_A || chip_id == LTC2979_ID_B)
  566. return ltc2979;
  567. else if (chip_id == LTC2980_ID_A || chip_id == LTC2980_ID_B)
  568. return ltc2980;
  569. else if (chip_id == LTC3880_ID)
  570. return ltc3880;
  571. else if (chip_id == LTC3882_ID || chip_id == LTC3882_ID_D1)
  572. return ltc3882;
  573. else if (chip_id == LTC3883_ID)
  574. return ltc3883;
  575. else if (chip_id == LTC3884_ID)
  576. return ltc3884;
  577. else if (chip_id == LTC3886_ID)
  578. return ltc3886;
  579. else if (chip_id == LTC3887_ID)
  580. return ltc3887;
  581. else if (chip_id == LTC3889_ID)
  582. return ltc3889;
  583. else if (chip_id == LTC7880_ID)
  584. return ltc7880;
  585. else if (chip_id == LTM2987_ID_A || chip_id == LTM2987_ID_B)
  586. return ltm2987;
  587. else if (chip_id == LTM4664_ID)
  588. return ltm4664;
  589. else if (chip_id == LTM4675_ID)
  590. return ltm4675;
  591. else if (chip_id == LTM4676_ID_REV1 || chip_id == LTM4676_ID_REV2 ||
  592. chip_id == LTM4676A_ID)
  593. return ltm4676;
  594. else if (chip_id == LTM4677_ID_REV1 || chip_id == LTM4677_ID_REV2)
  595. return ltm4677;
  596. else if (chip_id == LTM4678_ID_REV1 || chip_id == LTM4678_ID_REV2)
  597. return ltm4678;
  598. else if (chip_id == LTM4680_ID)
  599. return ltm4680;
  600. else if (chip_id == LTM4686_ID)
  601. return ltm4686;
  602. else if (chip_id == LTM4700_ID)
  603. return ltm4700;
  604. dev_err(&client->dev, "Unsupported chip ID 0x%x\n", chip_id);
  605. return -ENODEV;
  606. }
  607. static int ltc2978_probe(struct i2c_client *client)
  608. {
  609. int i, chip_id;
  610. struct ltc2978_data *data;
  611. struct pmbus_driver_info *info;
  612. const struct i2c_device_id *id;
  613. if (!i2c_check_functionality(client->adapter,
  614. I2C_FUNC_SMBUS_READ_WORD_DATA))
  615. return -ENODEV;
  616. data = devm_kzalloc(&client->dev, sizeof(struct ltc2978_data),
  617. GFP_KERNEL);
  618. if (!data)
  619. return -ENOMEM;
  620. chip_id = ltc2978_get_id(client);
  621. if (chip_id < 0)
  622. return chip_id;
  623. data->id = chip_id;
  624. id = i2c_match_id(ltc2978_id, client);
  625. if (data->id != id->driver_data)
  626. dev_warn(&client->dev,
  627. "Device mismatch: Configured %s (%d), detected %d\n",
  628. id->name,
  629. (int) id->driver_data,
  630. chip_id);
  631. info = &data->info;
  632. info->write_word_data = ltc2978_write_word_data;
  633. info->write_byte = ltc_write_byte;
  634. info->write_byte_data = ltc_write_byte_data;
  635. info->read_word_data = ltc_read_word_data;
  636. info->read_byte_data = ltc_read_byte_data;
  637. data->vin_min = 0x7bff;
  638. data->vin_max = 0x7c00;
  639. for (i = 0; i < ARRAY_SIZE(data->vout_min); i++)
  640. data->vout_min[i] = 0xffff;
  641. for (i = 0; i < ARRAY_SIZE(data->iout_min); i++)
  642. data->iout_min[i] = 0xfbff;
  643. for (i = 0; i < ARRAY_SIZE(data->iout_max); i++)
  644. data->iout_max[i] = 0x7c00;
  645. for (i = 0; i < ARRAY_SIZE(data->temp_min); i++)
  646. data->temp_min[i] = 0x7bff;
  647. for (i = 0; i < ARRAY_SIZE(data->temp_max); i++)
  648. data->temp_max[i] = 0x7c00;
  649. data->temp2_max = 0x7c00;
  650. switch (data->id) {
  651. case ltc2972:
  652. info->read_word_data = ltc2975_read_word_data;
  653. info->pages = LTC2972_NUM_PAGES;
  654. info->func[0] = PMBUS_HAVE_IIN | PMBUS_HAVE_PIN
  655. | PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
  656. | PMBUS_HAVE_TEMP2;
  657. for (i = 0; i < info->pages; i++) {
  658. info->func[i] |= PMBUS_HAVE_VOUT
  659. | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_POUT
  660. | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP
  661. | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT;
  662. }
  663. break;
  664. case ltc2974:
  665. info->read_word_data = ltc2974_read_word_data;
  666. info->pages = LTC2974_NUM_PAGES;
  667. info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
  668. | PMBUS_HAVE_TEMP2;
  669. for (i = 0; i < info->pages; i++) {
  670. info->func[i] |= PMBUS_HAVE_VOUT
  671. | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_POUT
  672. | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP
  673. | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT;
  674. }
  675. break;
  676. case ltc2975:
  677. info->read_word_data = ltc2975_read_word_data;
  678. info->pages = LTC2974_NUM_PAGES;
  679. info->func[0] = PMBUS_HAVE_IIN | PMBUS_HAVE_PIN
  680. | PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
  681. | PMBUS_HAVE_TEMP2;
  682. for (i = 0; i < info->pages; i++) {
  683. info->func[i] |= PMBUS_HAVE_VOUT
  684. | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_POUT
  685. | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP
  686. | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT;
  687. }
  688. break;
  689. case ltc2977:
  690. case ltc2978:
  691. case ltc2979:
  692. case ltc2980:
  693. case ltm2987:
  694. info->read_word_data = ltc2978_read_word_data;
  695. info->pages = LTC2978_NUM_PAGES;
  696. info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
  697. | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
  698. | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
  699. for (i = 1; i < LTC2978_NUM_PAGES; i++) {
  700. info->func[i] = PMBUS_HAVE_VOUT
  701. | PMBUS_HAVE_STATUS_VOUT;
  702. }
  703. break;
  704. case ltc3880:
  705. case ltc3887:
  706. case ltm4675:
  707. case ltm4676:
  708. case ltm4677:
  709. case ltm4686:
  710. data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING;
  711. info->read_word_data = ltc3880_read_word_data;
  712. info->pages = LTC3880_NUM_PAGES;
  713. info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN
  714. | PMBUS_HAVE_STATUS_INPUT
  715. | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
  716. | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
  717. | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
  718. | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
  719. info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
  720. | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
  721. | PMBUS_HAVE_POUT
  722. | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
  723. break;
  724. case ltc3882:
  725. data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING;
  726. info->read_word_data = ltc3880_read_word_data;
  727. info->pages = LTC3880_NUM_PAGES;
  728. info->func[0] = PMBUS_HAVE_VIN
  729. | PMBUS_HAVE_STATUS_INPUT
  730. | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
  731. | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
  732. | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
  733. | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
  734. info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
  735. | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
  736. | PMBUS_HAVE_POUT
  737. | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
  738. break;
  739. case ltc3883:
  740. data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING;
  741. info->read_word_data = ltc3883_read_word_data;
  742. info->pages = LTC3883_NUM_PAGES;
  743. info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN
  744. | PMBUS_HAVE_STATUS_INPUT
  745. | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
  746. | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
  747. | PMBUS_HAVE_PIN | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
  748. | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
  749. break;
  750. case ltc3884:
  751. case ltc3886:
  752. case ltc3889:
  753. case ltc7880:
  754. case ltm4664:
  755. case ltm4678:
  756. case ltm4680:
  757. case ltm4700:
  758. data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING;
  759. info->read_word_data = ltc3883_read_word_data;
  760. info->pages = LTC3880_NUM_PAGES;
  761. info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN
  762. | PMBUS_HAVE_STATUS_INPUT
  763. | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
  764. | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
  765. | PMBUS_HAVE_PIN | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
  766. | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
  767. info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
  768. | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
  769. | PMBUS_HAVE_POUT
  770. | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
  771. break;
  772. default:
  773. return -ENODEV;
  774. }
  775. #if IS_ENABLED(CONFIG_SENSORS_LTC2978_REGULATOR)
  776. info->num_regulators = info->pages;
  777. switch (data->id) {
  778. case ltc2972:
  779. case ltc2974:
  780. case ltc2975:
  781. case ltc2977:
  782. case ltc2978:
  783. case ltc2979:
  784. case ltc2980:
  785. case ltm2987:
  786. info->reg_desc = ltc2978_reg_desc;
  787. if (info->num_regulators > ARRAY_SIZE(ltc2978_reg_desc)) {
  788. dev_warn(&client->dev, "num_regulators too large!");
  789. info->num_regulators = ARRAY_SIZE(ltc2978_reg_desc);
  790. }
  791. break;
  792. default:
  793. info->reg_desc = ltc2978_reg_desc_default;
  794. if (info->num_regulators > ARRAY_SIZE(ltc2978_reg_desc_default)) {
  795. dev_warn(&client->dev, "num_regulators too large!");
  796. info->num_regulators =
  797. ARRAY_SIZE(ltc2978_reg_desc_default);
  798. }
  799. break;
  800. }
  801. #endif
  802. return pmbus_do_probe(client, info);
  803. }
  804. #ifdef CONFIG_OF
  805. static const struct of_device_id ltc2978_of_match[] = {
  806. { .compatible = "lltc,ltc2972" },
  807. { .compatible = "lltc,ltc2974" },
  808. { .compatible = "lltc,ltc2975" },
  809. { .compatible = "lltc,ltc2977" },
  810. { .compatible = "lltc,ltc2978" },
  811. { .compatible = "lltc,ltc2979" },
  812. { .compatible = "lltc,ltc2980" },
  813. { .compatible = "lltc,ltc3880" },
  814. { .compatible = "lltc,ltc3882" },
  815. { .compatible = "lltc,ltc3883" },
  816. { .compatible = "lltc,ltc3884" },
  817. { .compatible = "lltc,ltc3886" },
  818. { .compatible = "lltc,ltc3887" },
  819. { .compatible = "lltc,ltc3889" },
  820. { .compatible = "lltc,ltc7880" },
  821. { .compatible = "lltc,ltm2987" },
  822. { .compatible = "lltc,ltm4664" },
  823. { .compatible = "lltc,ltm4675" },
  824. { .compatible = "lltc,ltm4676" },
  825. { .compatible = "lltc,ltm4677" },
  826. { .compatible = "lltc,ltm4678" },
  827. { .compatible = "lltc,ltm4680" },
  828. { .compatible = "lltc,ltm4686" },
  829. { .compatible = "lltc,ltm4700" },
  830. { }
  831. };
  832. MODULE_DEVICE_TABLE(of, ltc2978_of_match);
  833. #endif
  834. static struct i2c_driver ltc2978_driver = {
  835. .driver = {
  836. .name = "ltc2978",
  837. .of_match_table = of_match_ptr(ltc2978_of_match),
  838. },
  839. .probe_new = ltc2978_probe,
  840. .id_table = ltc2978_id,
  841. };
  842. module_i2c_driver(ltc2978_driver);
  843. MODULE_AUTHOR("Guenter Roeck");
  844. MODULE_DESCRIPTION("PMBus driver for LTC2978 and compatible chips");
  845. MODULE_LICENSE("GPL");
  846. MODULE_IMPORT_NS(PMBUS);