drivers/power/tps6586x.c

   1 /*
   2  * Copyright (c) 2011 The Chromium OS Authors.
   3  * (C) Copyright 2010,2011 NVIDIA Corporation <www.nvidia.com>
   4  *
   5  * SPDX-License-Identifier:     GPL-2.0+
   6  */
   7
   8 #include <common.h>
   9 #include <tps6586x.h>
  10 #include <asm/io.h>
  11 #include <i2c.h>
  12
  13 static int bus_num;             /* I2C bus we are on */
  14 #define I2C_ADDRESS             0x34    /* chip requires this address */
  15 static char inited;             /* 1 if we have been inited */
  16
  17 enum {
  18         /* Registers that we access */
  19         SUPPLY_CONTROL1         = 0x20,
  20         SUPPLY_CONTROL2,
  21         SM1_VOLTAGE_V1          = 0x23,
  22         SM1_VOLTAGE_V2,
  23         SM0_VOLTAGE_V1          = 0x26,
  24         SM0_VOLTAGE_V2,
  25         PFM_MODE                = 0x47,
  26
  27         /* Bits in the supply control registers */
  28         CTRL_SM1_RAMP           = 0x01,
  29         CTRL_SM1_SUPPLY2        = 0x02,
  30         CTRL_SM0_RAMP           = 0x04,
  31         CTRL_SM0_SUPPLY2        = 0x08,
  32 };
  33
  34 #define MAX_I2C_RETRY   3
  35 static int tps6586x_read(int reg)
  36 {
  37         int     i;
  38         uchar   data;
  39         int     retval = -1;
  40         int     old_bus_num;
  41
  42         old_bus_num = i2c_get_bus_num();
  43         i2c_set_bus_num(bus_num);
  44
  45         for (i = 0; i < MAX_I2C_RETRY; ++i) {
  46                 if (!i2c_read(I2C_ADDRESS, reg, 1, &data, 1)) {
  47                         retval = (int)data;
  48                         goto exit;
  49                 }
  50
  51                 /* i2c access failed, retry */
  52                 udelay(100);
  53         }
  54
  55 exit:
  56         i2c_set_bus_num(old_bus_num);
  57         debug("pmu_read %x=%x\n", reg, retval);
  58         if (retval < 0)
  59                 debug("%s: failed to read register %#x: %d\n", __func__, reg,
  60                       retval);
  61         return retval;
  62 }
  63
  64 static int tps6586x_write(int reg, uchar *data, uint len)
  65 {
  66         int     i;
  67         int     retval = -1;
  68         int     old_bus_num;
  69
  70         old_bus_num = i2c_get_bus_num();
  71         i2c_set_bus_num(bus_num);
  72
  73         for (i = 0; i < MAX_I2C_RETRY; ++i) {
  74                 if (!i2c_write(I2C_ADDRESS, reg, 1, data, len)) {
  75                         retval = 0;
  76                         goto exit;
  77                 }
  78
  79                 /* i2c access failed, retry */
  80                 udelay(100);
  81         }
  82
  83 exit:
  84         i2c_set_bus_num(old_bus_num);
  85         debug("pmu_write %x=%x: ", reg, retval);
  86         for (i = 0; i < len; i++)
  87                 debug("%x ", data[i]);
  88         if (retval)
  89                 debug("%s: failed to write register %#x\n", __func__, reg);
  90         return retval;
  91 }
  92
  93 /*
  94  * Get current voltage of SM0 and SM1
  95  *
  96  * @param sm0   Place to put SM0 voltage
  97  * @param sm1   Place to put SM1 voltage
  98  * @return 0 if ok, -1 on error
  99  */
 100 static int read_voltages(int *sm0, int *sm1)
 101 {
 102         int ctrl1, ctrl2;
 103         int is_v2;
 104
 105         /*
 106          * Each vdd has two supply sources, ie, v1 and v2.
 107          * The supply control reg1 and reg2 determine the current selection.
 108          */
 109         ctrl1 = tps6586x_read(SUPPLY_CONTROL1);
 110         ctrl2 = tps6586x_read(SUPPLY_CONTROL2);
 111         if (ctrl1 == -1 || ctrl2 == -1)
 112                 return -1;
 113
 114         /* Figure out whether V1 or V2 is selected */
 115         is_v2 = (ctrl1 | ctrl2) & CTRL_SM0_SUPPLY2;
 116         *sm0 = tps6586x_read(is_v2 ? SM0_VOLTAGE_V2 : SM0_VOLTAGE_V1);
 117         *sm1 = tps6586x_read(is_v2 ? SM1_VOLTAGE_V2 : SM1_VOLTAGE_V1);
 118         if (*sm0 == -1 || *sm1 == -1)
 119                 return -1;
 120
 121         return 0;
 122 }
 123
 124 static int set_voltage(int reg, int data, int rate)
 125 {
 126         uchar control_bit;
 127         uchar buff[3];
 128
 129         control_bit = (reg == SM0_VOLTAGE_V1 ? CTRL_SM0_RAMP : CTRL_SM1_RAMP);
 130
 131         /*
 132          * Only one supply is needed in u-boot. set both v1 and v2 to
 133          * same value.
 134          *
 135          * When both v1 and v2 are set to same value, we just need to set
 136          * control1 reg to trigger the supply selection.
 137          */
 138         buff[0] = buff[1] = (uchar)data;
 139         buff[2] = rate;
 140
 141         /* write v1, v2 and rate, then trigger */
 142         if (tps6586x_write(reg, buff, 3) ||
 143             tps6586x_write(SUPPLY_CONTROL1, &control_bit, 1))
 144                 return -1;
 145
 146         return 0;
 147 }
 148
 149 static int calculate_next_voltage(int voltage, int target, int step)
 150 {
 151         int diff = voltage < target ? step : -step;
 152
 153         if (abs(target - voltage) > step)
 154                 voltage += diff;
 155         else
 156                 voltage = target;
 157
 158         return voltage;
 159 }
 160
 161 int tps6586x_set_pwm_mode(int mask)
 162 {
 163         uchar val;
 164         int ret;
 165
 166         assert(inited);
 167         ret = tps6586x_read(PFM_MODE);
 168         if (ret != -1) {
 169                 val = (uchar)ret;
 170                 val |= mask;
 171
 172                 ret = tps6586x_write(PFM_MODE, &val, 1);
 173         }
 174
 175         if (ret == -1)
 176                 debug("%s: Failed to read/write PWM mode reg\n", __func__);
 177
 178         return ret;
 179 }
 180
 181 int tps6586x_adjust_sm0_sm1(int sm0_target, int sm1_target, int step, int rate,
 182                             int min_sm0_over_sm1)
 183 {
 184         int sm0, sm1;
 185         int bad;
 186
 187         assert(inited);
 188
 189         /* get current voltage settings */
 190         if (read_voltages(&sm0, &sm1)) {
 191                 debug("%s: Cannot read voltage settings\n", __func__);
 192                 return -1;
 193         }
 194
 195         /*
 196          * if vdd_core < vdd_cpu + rel
 197          *    skip
 198          *
 199          * This condition may happen when system reboots due to kernel crash.
 200          */
 201         if (min_sm0_over_sm1 != -1 && sm0 < sm1 + min_sm0_over_sm1) {
 202                 debug("%s: SM0 is %d, SM1 is %d, but min_sm0_over_sm1 is %d\n",
 203                       __func__, sm0, sm1, min_sm0_over_sm1);
 204                 return -1;
 205         }
 206
 207         /*
 208          * Since vdd_core and vdd_cpu may both stand at either greater or less
 209          * than their nominal voltage, the adjustment may go either directions.
 210          *
 211          * Make sure vdd_core is always higher than vdd_cpu with certain margin.
 212          * So, find out which vdd to adjust first in each step.
 213          *
 214          * case 1: both sm0 and sm1 need to move up
 215          *              adjust sm0 before sm1
 216          *
 217          * case 2: both sm0 and sm1 need to move down
 218          *              adjust sm1 before sm0
 219          *
 220          * case 3: sm0 moves down and sm1 moves up
 221          *              adjusting either one first is fine.
 222          *
 223          * Adjust vdd_core and vdd_cpu one step at a time until they reach
 224          * their nominal values.
 225          */
 226         bad = 0;
 227         while (!bad && (sm0 != sm0_target || sm1 != sm1_target)) {
 228                 int adjust_sm0_late = 0; /* flag to adjust vdd_core later */
 229
 230                 debug("%d-%d   %d-%d   ", sm0, sm0_target, sm1, sm1_target);
 231
 232                 if (sm0 != sm0_target) {
 233                         /*
 234                          * if case 1 and case 3, set new sm0 first.
 235                          * otherwise, hold down until new sm1 is set.
 236                          */
 237                         sm0 = calculate_next_voltage(sm0, sm0_target, step);
 238                         if (sm1 < sm1_target)
 239                                 bad |= set_voltage(SM0_VOLTAGE_V1, sm0, rate);
 240                         else
 241                                 adjust_sm0_late = 1;
 242                 }
 243
 244                 if (sm1 != sm1_target) {
 245                         sm1 = calculate_next_voltage(sm1, sm1_target, step);
 246                         bad |= set_voltage(SM1_VOLTAGE_V1, sm1, rate);
 247                 }
 248
 249                 if (adjust_sm0_late)
 250                         bad |= set_voltage(SM0_VOLTAGE_V1, sm0, rate);
 251                 debug("%d\n", adjust_sm0_late);
 252         }
 253         debug("%d-%d   %d-%d   done\n", sm0, sm0_target, sm1, sm1_target);
 254
 255         return bad ? -1 : 0;
 256 }
 257
 258 int tps6586x_init(int bus)
 259 {
 260         bus_num = bus;
 261         inited = 1;
 262
 263         return 0;
 264 }