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