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