src/drivers/power/max77686.c

   1 /*
   2  * Copyright (C) 2012 Samsung Electronics
   3  * Alim Akhtar <alim.akhtar@samsung.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 <smbus.h>
  26 #include <max77686.h>
  27
  28 /* Chip register numbers (not exported from this module) */
  29 enum {
  30         REG_BBAT                = 0x7e,
  31
  32         /* Bits for BBAT */
  33         BBAT_BBCHOSTEN_MASK     = 1 << 0,
  34         BBAT_BBCVS_SHIFT        = 3,
  35         BBAT_BBCVS_MASK         = 3 << BBAT_BBCVS_SHIFT,
  36 };
  37
  38 /*
  39  * Max77686 parameters values
  40  * see max77686.h for parameters details
  41  */
  42 struct max77686_para max77686_param[] = {/*{regnum, vol_addr, vol_bitpos,
  43         vol_bitmask, reg_enaddr, reg_enbitpos, reg_enbitmask, reg_enbiton,
  44         reg_enbitoff, vol_min, vol_div}*/
  45         {PMIC_BUCK1, 0x11, 0x0, 0x3F, 0x10, 0x0, 0x3, 0x3, 0x0, 750, 50000},
  46         {PMIC_BUCK2, 0x14, 0x0, 0xFF, 0x12, 0x4, 0x3, 0x1, 0x0, 600, 12500},
  47         {PMIC_BUCK3, 0x1E, 0x0, 0xFF, 0x1C, 0x4, 0x3, 0x1, 0x0, 600, 12500},
  48         {PMIC_BUCK4, 0x28, 0x0, 0xFF, 0x26, 0x4, 0x3, 0x1, 0x0, 600, 12500},
  49         {PMIC_BUCK5, 0x31, 0x0, 0x3F, 0x30, 0x0, 0x3, 0x3, 0x0, 750, 50000},
  50         {PMIC_BUCK6, 0x33, 0x0, 0x3F, 0x32, 0x0, 0x3, 0x3, 0x0, 750, 50000},
  51         {PMIC_BUCK7, 0x35, 0x0, 0x3F, 0x34, 0x0, 0x3, 0x3, 0x0, 750, 50000},
  52         {PMIC_BUCK8, 0x37, 0x0, 0x3F, 0x36, 0x0, 0x3, 0x3, 0x0, 750, 50000},
  53         {PMIC_BUCK9, 0x39, 0x0, 0x3F, 0x38, 0x0, 0x3, 0x3, 0x0, 750, 50000},
  54         {PMIC_LDO1,  0x40, 0x0, 0x3F, 0x40, 0x6, 0x3, 0x3, 0x0, 800, 25000},
  55         {PMIC_LDO2,  0x41, 0x0, 0x3F, 0x41, 0x6, 0x3, 0x1, 0x0, 800, 25000},
  56         {PMIC_LDO3,  0x42, 0x0, 0x3F, 0x42, 0x6, 0x3, 0x3, 0x0, 800, 50000},
  57         {PMIC_LDO4,  0x43, 0x0, 0x3F, 0x43, 0x6, 0x3, 0x3, 0x0, 800, 50000},
  58         {PMIC_LDO5,  0x44, 0x0, 0x3F, 0x44, 0x6, 0x3, 0x3, 0x0, 800, 50000},
  59         {PMIC_LDO6,  0x45, 0x0, 0x3F, 0x45, 0x6, 0x3, 0x1, 0x0, 800, 25000},
  60         {PMIC_LDO7,  0x46, 0x0, 0x3F, 0x46, 0x6, 0x3, 0x1, 0x0, 800, 25000},
  61         {PMIC_LDO8,  0x47, 0x0, 0x3F, 0x47, 0x6, 0x3, 0x1, 0x0, 800, 25000},
  62         {PMIC_LDO9,  0x48, 0x0, 0x3F, 0x48, 0x6, 0x3, 0x3, 0x0, 800, 50000},
  63         {PMIC_LDO10, 0x49, 0x0, 0x3F, 0x49, 0x6, 0x3, 0x1, 0x0, 800, 50000},
  64         {PMIC_LDO11, 0x4A, 0x0, 0x3F, 0x4A, 0x6, 0x3, 0x1, 0x0, 800, 50000},
  65         {PMIC_LDO12, 0x4B, 0x0, 0x3F, 0x4B, 0x6, 0x3, 0x1, 0x0, 800, 50000},
  66         {PMIC_LDO13, 0x4C, 0x0, 0x3F, 0x4C, 0x6, 0x3, 0x3, 0x0, 800, 50000},
  67         {PMIC_LDO14, 0x4D, 0x0, 0x3F, 0x4D, 0x6, 0x3, 0x1, 0x0, 800, 50000},
  68         {PMIC_LDO15, 0x4E, 0x0, 0x3F, 0x4E, 0x6, 0x3, 0x1, 0x0, 800, 25000},
  69         {PMIC_LDO16, 0x4F, 0x0, 0x3F, 0x4F, 0x6, 0x3, 0x1, 0x0, 800, 50000},
  70         {PMIC_LDO17, 0x50, 0x0, 0x3F, 0x50, 0x6, 0x3, 0x3, 0x0, 800, 50000},
  71         {PMIC_LDO18, 0x51, 0x0, 0x3F, 0x51, 0x6, 0x3, 0x3, 0x0, 800, 50000},
  72         {PMIC_LDO19, 0x52, 0x0, 0x3F, 0x52, 0x6, 0x3, 0x3, 0x0, 800, 50000},
  73         {PMIC_LDO20, 0x53, 0x0, 0x3F, 0x53, 0x6, 0x3, 0x3, 0x0, 800, 50000},
  74         {PMIC_LDO21, 0x54, 0x0, 0x3F, 0x54, 0x6, 0x3, 0x3, 0x0, 800, 50000},
  75         {PMIC_LDO22, 0x55, 0x0, 0x3F, 0x55, 0x6, 0x3, 0x3, 0x0, 800, 50000},
  76         {PMIC_LDO23, 0x56, 0x0, 0x3F, 0x56, 0x6, 0x3, 0x3, 0x0, 800, 50000},
  77         {PMIC_LDO24, 0x57, 0x0, 0x3F, 0x57, 0x6, 0x3, 0x3, 0x0, 800, 50000},
  78         {PMIC_LDO25, 0x58, 0x0, 0x3F, 0x58, 0x6, 0x3, 0x3, 0x0, 800, 50000},
  79         {PMIC_LDO26, 0x59, 0x0, 0x3F, 0x59, 0x6, 0x3, 0x3, 0x0, 800, 50000},
  80         {PMIC_EN32KHZ_CP, 0x0, 0x0, 0x0, 0x7F, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0},
  81 };
  82
  83 /*
  84  * Write a value to a register
  85  *
  86  * @param chip_addr     i2c addr for max77686
  87  * @param reg           reg number to write
  88  * @param val           value to be written
  89  *
  90  */
  91 static inline int max77686_i2c_write(unsigned char chip_addr,
  92                                         unsigned int reg, unsigned char val)
  93 {
  94         return i2c_write(chip_addr, reg, 1, &val, 1);
  95 }
  96
  97 /*
  98  * Read a value from a register
  99  *
 100  * @param chip_addr     i2c addr for max77686
 101  * @param reg           reg number to write
 102  * @param val           value to be written
 103  *
 104  */
 105 static inline int max77686_i2c_read(unsigned char chip_addr,
 106                                         unsigned int reg, unsigned char *val)
 107 {
 108         return i2c_read(chip_addr, reg, 1, val, 1);
 109 }
 110
 111 /*
 112  * Enable the max77686 register
 113  *
 114  * @param reg           register number of buck/ldo to be enabled
 115  * @param enable        enable or disable bit
 116  *
 117  *                      REG_DISABLE = 0,
 118                         needed to set the buck/ldo enable bit OFF
 119  * @return              Return 0 if ok, else -1
 120  */
 121 static int max77686_enablereg(enum max77686_regnum reg, int enable)
 122 {
 123         struct max77686_para *pmic;
 124         unsigned char read_data;
 125         int ret;
 126
 127         pmic = &max77686_param[reg];
 128
 129         ret = max77686_i2c_read(MAX77686_I2C_ADDR, pmic->reg_enaddr,
 130                                 &read_data);
 131         if (ret != 0) {
 132                 debug("max77686 i2c read failed.\n");
 133                 return -1;
 134         }
 135
 136         if (enable == REG_DISABLE) {
 137                 clrbits_8(&read_data,
 138                                 pmic->reg_enbitmask << pmic->reg_enbitpos);
 139         } else {
 140                 clrsetbits_8(&read_data,
 141                                 pmic->reg_enbitmask << pmic->reg_enbitpos,
 142                                 pmic->reg_enbiton << pmic->reg_enbitpos);
 143         }
 144
 145         ret = max77686_i2c_write(MAX77686_I2C_ADDR,
 146                                  pmic->reg_enaddr, read_data);
 147         if (ret != 0) {
 148                 debug("max77686 i2c write failed.\n");
 149                 return -1;
 150         }
 151
 152         return 0;
 153 }
 154
 155 static int max77686_do_volsetting(enum max77686_regnum reg, unsigned int volt,
 156                                   int enable, int volt_units)
 157 {
 158         struct max77686_para *pmic;
 159         unsigned char read_data;
 160         int vol_level = 0;
 161         int ret;
 162
 163         pmic = &max77686_param[reg];
 164
 165         if (pmic->vol_addr == 0) {
 166                 debug("not a voltage register.\n");
 167                 return -1;
 168         }
 169
 170         ret = max77686_i2c_read(MAX77686_I2C_ADDR, pmic->vol_addr, &read_data);
 171         if (ret != 0) {
 172                 debug("max77686 i2c read failed.\n");
 173                 return -1;
 174         }
 175
 176         if (volt_units == MAX77686_UV)
 177                 vol_level = volt - pmic->vol_min * 1000;
 178         else
 179                 vol_level = (volt - pmic->vol_min) * 1000;
 180
 181         if (vol_level < 0) {
 182                 debug("Not a valid voltage level to set\n");
 183                 return -1;
 184         }
 185         vol_level /= pmic->vol_div;
 186
 187         clrsetbits_8(&read_data, pmic->vol_bitmask << pmic->vol_bitpos,
 188                         vol_level << pmic->vol_bitpos);
 189
 190         ret = max77686_i2c_write(MAX77686_I2C_ADDR, pmic->vol_addr, read_data);
 191         if (ret != 0) {
 192                 debug("max77686 i2c write failed.\n");
 193                 return -1;
 194         }
 195
 196         ret = max77686_enablereg(reg, enable);
 197         if (ret != 0) {
 198                 debug("Failed to enable buck/ldo.\n");
 199                 return -1;
 200         }
 201
 202         return 0;
 203 }
 204
 205 int max77686_volsetting(enum max77686_regnum reg, unsigned int volt,
 206                         int enable, int volt_units)
 207 {
 208         int old_bus = i2c_get_bus_num();
 209         int ret;
 210
 211         i2c_set_bus_num(0);
 212         ret = max77686_do_volsetting(reg, volt, enable, volt_units);
 213         i2c_set_bus_num(old_bus);
 214         return ret;
 215 }
 216
 217 int max77686_enable_32khz_cp(void)
 218 {
 219         i2c_set_bus_num(0);
 220         return max77686_enablereg(PMIC_EN32KHZ_CP, REG_ENABLE);
 221 }
 222
 223 int max77686_disable_backup_batt(void)
 224 {
 225         unsigned char val;
 226         int ret;
 227
 228         i2c_set_bus_num(0);
 229         ret = max77686_i2c_read(MAX77686_I2C_ADDR, REG_BBAT, &val);
 230         if (ret) {
 231                 debug("max77686 i2c read failed\n");
 232                 return ret;
 233         }
 234
 235         /* If we already have the correct values, exit */
 236         if ((val & (BBAT_BBCVS_MASK | BBAT_BBCHOSTEN_MASK)) ==
 237                         BBAT_BBCVS_MASK)
 238                 return 0;
 239
 240         /* First disable charging */
 241         val &= ~BBAT_BBCHOSTEN_MASK;
 242         ret = max77686_i2c_write(MAX77686_I2C_ADDR, REG_BBAT, val);
 243         if (ret) {
 244                 debug("max77686 i2c write failed\n");
 245                 return -1;
 246         }
 247
 248         /* Finally select 3.5V to minimize power consumption */
 249         val |= BBAT_BBCVS_MASK;
 250         ret = max77686_i2c_write(MAX77686_I2C_ADDR, REG_BBAT, val);
 251         if (ret) {
 252                 debug("max77686 i2c write failed\n");
 253                 return -1;
 254         }
 255
 256         return 0;
 257 }