drivers/power/regulator/as3722_regulator.c

   1 /*
   2  * Copyright (C) 2017 Google, Inc
   3  * Written by Simon Glass <[email protected]>
   4  *
   5  * Placeholder regulator driver for as3722.
   6  *
   7  * SPDX-License-Identifier:     GPL-2.0+
   8  */
   9
  10 #include <common.h>
  11 #include <dm.h>
  12 #include <errno.h>
  13 #include <power/as3722.h>
  14 #include <power/pmic.h>
  15 #include <power/regulator.h>
  16
  17 static int stepdown_get_value(struct udevice *dev)
  18 {
  19         return -ENOSYS;
  20 }
  21
  22 static int stepdown_set_value(struct udevice *dev, int uvolt)
  23 {
  24         return -ENOSYS;
  25 }
  26
  27 static int stepdown_set_enable(struct udevice *dev, bool enable)
  28 {
  29         struct udevice *pmic = dev_get_parent(dev);
  30         int sd = dev->driver_data;
  31         int ret;
  32
  33         ret = pmic_clrsetbits(pmic, AS3722_SD_CONTROL, 0, 1 << sd);
  34         if (ret < 0) {
  35                 debug("%s: failed to write SD control register: %d", __func__,
  36                       ret);
  37                 return ret;
  38         }
  39
  40         return 0;
  41 }
  42
  43 static int stepdown_get_enable(struct udevice *dev)
  44 {
  45         struct udevice *pmic = dev_get_parent(dev);
  46         int sd = dev->driver_data;
  47         int ret;
  48
  49         ret = pmic_reg_read(pmic, AS3722_SD_CONTROL);
  50         if (ret < 0) {
  51                 debug("%s: failed to read SD control register: %d", __func__,
  52                       ret);
  53                 return ret;
  54         }
  55
  56         return ret & (1 << sd) ? true : false;
  57 }
  58
  59 static int ldo_get_value(struct udevice *dev)
  60 {
  61         return -ENOSYS;
  62 }
  63
  64 static int ldo_set_value(struct udevice *dev, int uvolt)
  65 {
  66         return -ENOSYS;
  67 }
  68
  69 static int ldo_set_enable(struct udevice *dev, bool enable)
  70 {
  71         struct udevice *pmic = dev_get_parent(dev);
  72         int ldo = dev->driver_data;
  73         int ret;
  74
  75         ret = pmic_clrsetbits(pmic, AS3722_LDO_CONTROL, 0, 1 << ldo);
  76         if (ret < 0) {
  77                 debug("%s: failed to write LDO control register: %d", __func__,
  78                       ret);
  79                 return ret;
  80         }
  81
  82         return 0;
  83 }
  84
  85 static int ldo_get_enable(struct udevice *dev)
  86 {
  87         struct udevice *pmic = dev_get_parent(dev);
  88         int ldo = dev->driver_data;
  89         int ret;
  90
  91         ret = pmic_reg_read(pmic, AS3722_LDO_CONTROL);
  92         if (ret < 0) {
  93                 debug("%s: failed to read SD control register: %d", __func__,
  94                       ret);
  95                 return ret;
  96         }
  97
  98         return ret & (1 << ldo) ? true : false;
  99 }
 100
 101 static int as3722_stepdown_probe(struct udevice *dev)
 102 {
 103         struct dm_regulator_uclass_platdata *uc_pdata;
 104
 105         uc_pdata = dev_get_uclass_platdata(dev);
 106
 107         uc_pdata->type = REGULATOR_TYPE_BUCK;
 108
 109         return 0;
 110 }
 111
 112 static int as3722_ldo_probe(struct udevice *dev)
 113 {
 114         struct dm_regulator_uclass_platdata *uc_pdata;
 115
 116         uc_pdata = dev_get_uclass_platdata(dev);
 117
 118         uc_pdata->type = REGULATOR_TYPE_LDO;
 119
 120         return 0;
 121 }
 122
 123 static const struct dm_regulator_ops as3722_stepdown_ops = {
 124         .get_value  = stepdown_get_value,
 125         .set_value  = stepdown_set_value,
 126         .get_enable = stepdown_get_enable,
 127         .set_enable = stepdown_set_enable,
 128 };
 129
 130 static const struct dm_regulator_ops as3722_ldo_ops = {
 131         .get_value  = ldo_get_value,
 132         .set_value  = ldo_set_value,
 133         .get_enable = ldo_get_enable,
 134         .set_enable = ldo_set_enable,
 135 };
 136
 137 U_BOOT_DRIVER(as3722_stepdown) = {
 138         .name = "as3722_stepdown",
 139         .id = UCLASS_REGULATOR,
 140         .ops = &as3722_stepdown_ops,
 141         .probe = as3722_stepdown_probe,
 142 };
 143
 144 U_BOOT_DRIVER(as3722_ldo) = {
 145         .name = "as3722_ldo",
 146         .id = UCLASS_REGULATOR,
 147         .ops = &as3722_ldo_ops,
 148         .probe = as3722_ldo_probe,
 149 };