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