git.sur5r.net Git - u-boot/blob - drivers/power/as3722.c

   1 /*
   2  * Copyright (C) 2014 NVIDIA Corporation
   3  *
   4  * SPDX-License-Identifier: GPL-2.0+
   5  */
   6
   7 #define pr_fmt(fmt) "as3722: " fmt
   8
   9 #include <common.h>
  10 #include <dm.h>
  11 #include <errno.h>
  12 #include <fdtdec.h>
  13 #include <i2c.h>
  14
  15 #include <power/as3722.h>
  16
  17 #define AS3722_SD_VOLTAGE(n) (0x00 + (n))
  18 #define AS3722_GPIO_CONTROL(n) (0x08 + (n))
  19 #define  AS3722_GPIO_CONTROL_MODE_OUTPUT_VDDH (1 << 0)
  20 #define  AS3722_GPIO_CONTROL_MODE_OUTPUT_VDDL (7 << 0)
  21 #define  AS3722_GPIO_CONTROL_INVERT (1 << 7)
  22 #define AS3722_LDO_VOLTAGE(n) (0x10 + (n))
  23 #define AS3722_GPIO_SIGNAL_OUT 0x20
  24 #define AS3722_SD_CONTROL 0x4d
  25 #define AS3722_LDO_CONTROL 0x4e
  26 #define AS3722_ASIC_ID1 0x90
  27 #define  AS3722_DEVICE_ID 0x0c
  28 #define AS3722_ASIC_ID2 0x91
  29
  30 int as3722_read(struct udevice *pmic, u8 reg, u8 *value)
  31 {
  32         int err;
  33
  34         err = dm_i2c_read(pmic, reg, value, 1);
  35         if (err < 0)
  36                 return err;
  37
  38         return 0;
  39 }
  40
  41 int as3722_write(struct udevice *pmic, u8 reg, u8 value)
  42 {
  43         int err;
  44
  45         err = dm_i2c_write(pmic, reg, &value, 1);
  46         if (err < 0)
  47                 return err;
  48
  49         return 0;
  50 }
  51
  52 static int as3722_read_id(struct udevice *pmic, u8 *id, u8 *revision)
  53 {
  54         int err;
  55
  56         err = as3722_read(pmic, AS3722_ASIC_ID1, id);
  57         if (err) {
  58                 error("failed to read ID1 register: %d", err);
  59                 return err;
  60         }
  61
  62         err = as3722_read(pmic, AS3722_ASIC_ID2, revision);
  63         if (err) {
  64                 error("failed to read ID2 register: %d", err);
  65                 return err;
  66         }
  67
  68         return 0;
  69 }
  70
  71 int as3722_sd_enable(struct udevice *pmic, unsigned int sd)
  72 {
  73         u8 value;
  74         int err;
  75
  76         if (sd > 6)
  77                 return -EINVAL;
  78
  79         err = as3722_read(pmic, AS3722_SD_CONTROL, &value);
  80         if (err) {
  81                 error("failed to read SD control register: %d", err);
  82                 return err;
  83         }
  84
  85         value |= 1 << sd;
  86
  87         err = as3722_write(pmic, AS3722_SD_CONTROL, value);
  88         if (err < 0) {
  89                 error("failed to write SD control register: %d", err);
  90                 return err;
  91         }
  92
  93         return 0;
  94 }
  95
  96 int as3722_sd_set_voltage(struct udevice *pmic, unsigned int sd, u8 value)
  97 {
  98         int err;
  99
 100         if (sd > 6)
 101                 return -EINVAL;
 102
 103         err = as3722_write(pmic, AS3722_SD_VOLTAGE(sd), value);
 104         if (err < 0) {
 105                 error("failed to write SD%u voltage register: %d", sd, err);
 106                 return err;
 107         }
 108
 109         return 0;
 110 }
 111
 112 int as3722_ldo_enable(struct udevice *pmic, unsigned int ldo)
 113 {
 114         u8 value;
 115         int err;
 116
 117         if (ldo > 11)
 118                 return -EINVAL;
 119
 120         err = as3722_read(pmic, AS3722_LDO_CONTROL, &value);
 121         if (err) {
 122                 error("failed to read LDO control register: %d", err);
 123                 return err;
 124         }
 125
 126         value |= 1 << ldo;
 127
 128         err = as3722_write(pmic, AS3722_LDO_CONTROL, value);
 129         if (err < 0) {
 130                 error("failed to write LDO control register: %d", err);
 131                 return err;
 132         }
 133
 134         return 0;
 135 }
 136
 137 int as3722_ldo_set_voltage(struct udevice *pmic, unsigned int ldo, u8 value)
 138 {
 139         int err;
 140
 141         if (ldo > 11)
 142                 return -EINVAL;
 143
 144         err = as3722_write(pmic, AS3722_LDO_VOLTAGE(ldo), value);
 145         if (err < 0) {
 146                 error("failed to write LDO%u voltage register: %d", ldo,
 147                       err);
 148                 return err;
 149         }
 150
 151         return 0;
 152 }
 153
 154 int as3722_gpio_configure(struct udevice *pmic, unsigned int gpio,
 155                           unsigned long flags)
 156 {
 157         u8 value = 0;
 158         int err;
 159
 160         if (flags & AS3722_GPIO_OUTPUT_VDDH)
 161                 value |= AS3722_GPIO_CONTROL_MODE_OUTPUT_VDDH;
 162
 163         if (flags & AS3722_GPIO_INVERT)
 164                 value |= AS3722_GPIO_CONTROL_INVERT;
 165
 166         err = as3722_write(pmic, AS3722_GPIO_CONTROL(gpio), value);
 167         if (err) {
 168                 error("failed to configure GPIO#%u: %d", gpio, err);
 169                 return err;
 170         }
 171
 172         return 0;
 173 }
 174
 175 static int as3722_gpio_set(struct udevice *pmic, unsigned int gpio,
 176                            unsigned int level)
 177 {
 178         const char *l;
 179         u8 value;
 180         int err;
 181
 182         if (gpio > 7)
 183                 return -EINVAL;
 184
 185         err = as3722_read(pmic, AS3722_GPIO_SIGNAL_OUT, &value);
 186         if (err < 0) {
 187                 error("failed to read GPIO signal out register: %d", err);
 188                 return err;
 189         }
 190
 191         if (level == 0) {
 192                 value &= ~(1 << gpio);
 193                 l = "low";
 194         } else {
 195                 value |= 1 << gpio;
 196                 l = "high";
 197         }
 198
 199         err = as3722_write(pmic, AS3722_GPIO_SIGNAL_OUT, value);
 200         if (err) {
 201                 error("failed to set GPIO#%u %s: %d", gpio, l, err);
 202                 return err;
 203         }
 204
 205         return 0;
 206 }
 207
 208 int as3722_gpio_direction_output(struct udevice *pmic, unsigned int gpio,
 209                                  unsigned int level)
 210 {
 211         u8 value;
 212         int err;
 213
 214         if (gpio > 7)
 215                 return -EINVAL;
 216
 217         if (level == 0)
 218                 value = AS3722_GPIO_CONTROL_MODE_OUTPUT_VDDL;
 219         else
 220                 value = AS3722_GPIO_CONTROL_MODE_OUTPUT_VDDH;
 221
 222         err = as3722_write(pmic, AS3722_GPIO_CONTROL(gpio), value);
 223         if (err) {
 224                 error("failed to configure GPIO#%u as output: %d", gpio, err);
 225                 return err;
 226         }
 227
 228         err = as3722_gpio_set(pmic, gpio, level);
 229         if (err < 0) {
 230                 error("failed to set GPIO#%u high: %d", gpio, err);
 231                 return err;
 232         }
 233
 234         return 0;
 235 }
 236
 237 /* Temporary function until we get the pmic framework */
 238 int as3722_get(struct udevice **devp)
 239 {
 240         int bus = 0;
 241         int address = 0x40;
 242
 243         return i2c_get_chip_for_busnum(bus, address, 1, devp);
 244 }
 245
 246 int as3722_init(struct udevice **devp)
 247 {
 248         struct udevice *pmic;
 249         u8 id, revision;
 250         const unsigned int bus = 0;
 251         const unsigned int address = 0x40;
 252         int err;
 253
 254         err = i2c_get_chip_for_busnum(bus, address, 1, &pmic);
 255         if (err)
 256                 return err;
 257         err = as3722_read_id(pmic, &id, &revision);
 258         if (err < 0) {
 259                 error("failed to read ID: %d", err);
 260                 return err;
 261         }
 262
 263         if (id != AS3722_DEVICE_ID) {
 264                 error("unknown device");
 265                 return -ENOENT;
 266         }
 267
 268         debug("AS3722 revision %#x found on I2C bus %u, address %#x\n",
 269               revision, bus, address);
 270         if (devp)
 271                 *devp = pmic;
 272
 273         return 0;
 274 }