fg_max17042.c 6.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (C) 2012 Samsung Electronics
  4. * Lukasz Majewski <l.majewski@samsung.com>
  5. */
  6. #include <common.h>
  7. #include <log.h>
  8. #include <linux/delay.h>
  9. #include <power/pmic.h>
  10. #include <power/max17042_fg.h>
  11. #include <i2c.h>
  12. #include <power/max8997_pmic.h>
  13. #include <power/power_chrg.h>
  14. #include <power/battery.h>
  15. #include <power/fg_battery_cell_params.h>
  16. #include <errno.h>
  17. static int fg_write_regs(struct pmic *p, u8 addr, u16 *data, int num)
  18. {
  19. int ret = 0;
  20. int i;
  21. for (i = 0; i < num; i++, addr++) {
  22. ret = pmic_reg_write(p, addr, *(data + i));
  23. if (ret)
  24. return ret;
  25. }
  26. return 0;
  27. }
  28. static int fg_read_regs(struct pmic *p, u8 addr, u16 *data, int num)
  29. {
  30. unsigned int dat;
  31. int ret = 0;
  32. int i;
  33. for (i = 0; i < num; i++, addr++) {
  34. ret = pmic_reg_read(p, addr, &dat);
  35. if (ret)
  36. return ret;
  37. *(data + i) = (u16)dat;
  38. }
  39. return 0;
  40. }
  41. static int fg_write_and_verify(struct pmic *p, u8 addr, u16 data)
  42. {
  43. unsigned int val = data;
  44. int ret = 0;
  45. ret |= pmic_reg_write(p, addr, val);
  46. ret |= pmic_reg_read(p, addr, &val);
  47. if (ret)
  48. return ret;
  49. if (((u16) val) == data)
  50. return 0;
  51. return -1;
  52. }
  53. static void por_fuelgauge_init(struct pmic *p)
  54. {
  55. u16 r_data0[16], r_data1[16], r_data2[16];
  56. u32 rewrite_count = 5;
  57. u32 check_count;
  58. u32 lock_count;
  59. u32 i = 0;
  60. u32 val;
  61. s32 ret = 0;
  62. char *status_msg;
  63. /* Delay 500 ms */
  64. mdelay(500);
  65. /* Initilize Configuration */
  66. pmic_reg_write(p, MAX17042_CONFIG, 0x2310);
  67. rewrite_model:
  68. check_count = 5;
  69. lock_count = 5;
  70. if (!rewrite_count--) {
  71. status_msg = "init failed!";
  72. goto error;
  73. }
  74. /* Unlock Model Access */
  75. pmic_reg_write(p, MAX17042_MLOCKReg1, MODEL_UNLOCK1);
  76. pmic_reg_write(p, MAX17042_MLOCKReg2, MODEL_UNLOCK2);
  77. /* Write/Read/Verify the Custom Model */
  78. ret = fg_write_regs(p, MAX17042_MODEL1, cell_character0,
  79. ARRAY_SIZE(cell_character0));
  80. if (ret)
  81. goto rewrite_model;
  82. ret = fg_write_regs(p, MAX17042_MODEL2, cell_character1,
  83. ARRAY_SIZE(cell_character1));
  84. if (ret)
  85. goto rewrite_model;
  86. ret = fg_write_regs(p, MAX17042_MODEL3, cell_character2,
  87. ARRAY_SIZE(cell_character2));
  88. if (ret)
  89. goto rewrite_model;
  90. check_model:
  91. if (!check_count--) {
  92. if (rewrite_count)
  93. goto rewrite_model;
  94. else
  95. status_msg = "check failed!";
  96. goto error;
  97. }
  98. ret = fg_read_regs(p, MAX17042_MODEL1, r_data0, ARRAY_SIZE(r_data0));
  99. if (ret)
  100. goto check_model;
  101. ret = fg_read_regs(p, MAX17042_MODEL2, r_data1, ARRAY_SIZE(r_data1));
  102. if (ret)
  103. goto check_model;
  104. ret = fg_read_regs(p, MAX17042_MODEL3, r_data2, ARRAY_SIZE(r_data2));
  105. if (ret)
  106. goto check_model;
  107. for (i = 0; i < 16; i++) {
  108. if ((cell_character0[i] != r_data0[i])
  109. || (cell_character1[i] != r_data1[i])
  110. || (cell_character2[i] != r_data2[i]))
  111. goto rewrite_model;
  112. }
  113. lock_model:
  114. if (!lock_count--) {
  115. if (rewrite_count)
  116. goto rewrite_model;
  117. else
  118. status_msg = "lock failed!";
  119. goto error;
  120. }
  121. /* Lock model access */
  122. pmic_reg_write(p, MAX17042_MLOCKReg1, MODEL_LOCK1);
  123. pmic_reg_write(p, MAX17042_MLOCKReg2, MODEL_LOCK2);
  124. /* Verify the model access is locked */
  125. ret = fg_read_regs(p, MAX17042_MODEL1, r_data0, ARRAY_SIZE(r_data0));
  126. if (ret)
  127. goto lock_model;
  128. ret = fg_read_regs(p, MAX17042_MODEL2, r_data1, ARRAY_SIZE(r_data1));
  129. if (ret)
  130. goto lock_model;
  131. ret = fg_read_regs(p, MAX17042_MODEL3, r_data2, ARRAY_SIZE(r_data2));
  132. if (ret)
  133. goto lock_model;
  134. for (i = 0; i < ARRAY_SIZE(r_data0); i++) {
  135. /* Check if model locked */
  136. if (r_data0[i] || r_data1[i] || r_data2[i])
  137. goto lock_model;
  138. }
  139. /* Write Custom Parameters */
  140. fg_write_and_verify(p, MAX17042_RCOMP0, RCOMP0);
  141. fg_write_and_verify(p, MAX17042_TEMPCO, TempCo);
  142. /* Delay at least 350mS */
  143. mdelay(350);
  144. /* Initialization Complete */
  145. pmic_reg_read(p, MAX17042_STATUS, &val);
  146. /* Write and Verify Status with POR bit Cleared */
  147. fg_write_and_verify(p, MAX17042_STATUS, val & ~MAX17042_POR);
  148. /* Delay at least 350 ms */
  149. mdelay(350);
  150. status_msg = "OK!";
  151. error:
  152. debug("%s: model init status: %s\n", p->name, status_msg);
  153. return;
  154. }
  155. static int power_update_battery(struct pmic *p, struct pmic *bat)
  156. {
  157. struct power_battery *pb = bat->pbat;
  158. unsigned int val;
  159. int ret = 0;
  160. if (pmic_probe(p)) {
  161. puts("Can't find max17042 fuel gauge\n");
  162. return -ENODEV;
  163. }
  164. ret |= pmic_reg_read(p, MAX17042_VFSOC, &val);
  165. pb->bat->state_of_chrg = (val >> 8);
  166. pmic_reg_read(p, MAX17042_VCELL, &val);
  167. debug("vfsoc: 0x%x\n", val);
  168. pb->bat->voltage_uV = ((val & 0xFFUL) >> 3) + ((val & 0xFF00) >> 3);
  169. pb->bat->voltage_uV = (pb->bat->voltage_uV * 625);
  170. pmic_reg_read(p, 0x05, &val);
  171. pb->bat->capacity = val >> 2;
  172. return ret;
  173. }
  174. static int power_check_battery(struct pmic *p, struct pmic *bat)
  175. {
  176. struct power_battery *pb = bat->pbat;
  177. unsigned int val;
  178. int ret = 0;
  179. if (pmic_probe(p)) {
  180. puts("Can't find max17042 fuel gauge\n");
  181. return -ENODEV;
  182. }
  183. ret |= pmic_reg_read(p, MAX17042_STATUS, &val);
  184. debug("fg status: 0x%x\n", val);
  185. if (val & MAX17042_POR)
  186. por_fuelgauge_init(p);
  187. ret |= pmic_reg_read(p, MAX17042_VERSION, &val);
  188. pb->bat->version = val;
  189. power_update_battery(p, bat);
  190. debug("fg ver: 0x%x\n", pb->bat->version);
  191. printf("BAT: state_of_charge(SOC):%d%%\n",
  192. pb->bat->state_of_chrg);
  193. printf(" voltage: %d.%6.6d [V] (expected to be %d [mAh])\n",
  194. pb->bat->voltage_uV / 1000000,
  195. pb->bat->voltage_uV % 1000000,
  196. pb->bat->capacity);
  197. if (pb->bat->voltage_uV > 3850000)
  198. pb->bat->state = EXT_SOURCE;
  199. else if (pb->bat->voltage_uV < 3600000 || pb->bat->state_of_chrg < 5)
  200. pb->bat->state = CHARGE;
  201. else
  202. pb->bat->state = NORMAL;
  203. return ret;
  204. }
  205. static struct power_fg power_fg_ops = {
  206. .fg_battery_check = power_check_battery,
  207. .fg_battery_update = power_update_battery,
  208. };
  209. int power_fg_init(unsigned char bus)
  210. {
  211. static const char name[] = "MAX17042_FG";
  212. struct pmic *p = pmic_alloc();
  213. if (!p) {
  214. printf("%s: POWER allocation error!\n", __func__);
  215. return -ENOMEM;
  216. }
  217. debug("Board Fuel Gauge init\n");
  218. p->name = name;
  219. p->interface = PMIC_I2C;
  220. p->number_of_regs = FG_NUM_OF_REGS;
  221. p->hw.i2c.addr = MAX17042_I2C_ADDR;
  222. p->hw.i2c.tx_num = 2;
  223. p->sensor_byte_order = PMIC_SENSOR_BYTE_ORDER_BIG;
  224. p->bus = bus;
  225. p->fg = &power_fg_ops;
  226. return 0;
  227. }