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