drivers/power/pmic/pmic-uclass.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2014-2015 Samsung Electronics
   4  * Przemyslaw Marczak <p.marczak@samsung.com>
   5  */
   6
   7 #define LOG_CATEGORY UCLASS_PMIC
   8
   9 #include <common.h>
  10 #include <fdtdec.h>
  11 #include <errno.h>
  12 #include <dm.h>
  13 #include <log.h>
  14 #include <vsprintf.h>
  15 #include <dm/lists.h>
  16 #include <dm/device-internal.h>
  17 #include <dm/uclass-internal.h>
  18 #include <power/pmic.h>
  19 #include <linux/ctype.h>
  20
  21 #if CONFIG_IS_ENABLED(PMIC_CHILDREN)
  22 int pmic_bind_children(struct udevice *pmic, ofnode parent,
  23                        const struct pmic_child_info *child_info)
  24 {
  25         const struct pmic_child_info *info;
  26         struct driver *drv;
  27         struct udevice *child;
  28         const char *node_name;
  29         const char *reg_name;
  30         int bind_count = 0;
  31         ofnode node;
  32         int prefix_len;
  33         int ret;
  34
  35         debug("%s for '%s' at node offset: %d\n", __func__, pmic->name,
  36               dev_of_offset(pmic));
  37
  38         ofnode_for_each_subnode(node, parent) {
  39                 node_name = ofnode_get_name(node);
  40
  41                 debug("* Found child node: '%s'\n", node_name);
  42                 if (!ofnode_is_enabled(node)) {
  43                         debug("  - ignoring disabled device\n");
  44                         continue;
  45                 }
  46
  47                 child = NULL;
  48                 for (info = child_info; info->prefix && info->driver; info++) {
  49                         debug("  - compatible prefix: '%s'\n", info->prefix);
  50
  51                         prefix_len = strlen(info->prefix);
  52                         if (strncmp(info->prefix, node_name, prefix_len)) {
  53                                 reg_name = ofnode_read_string(node,
  54                                                               "regulator-name");
  55                                 if (!reg_name)
  56                                         continue;
  57                                 if (strncmp(info->prefix, reg_name, prefix_len))
  58                                         continue;
  59                         }
  60
  61                         drv = lists_driver_lookup_name(info->driver);
  62                         if (!drv) {
  63                                 debug("  - driver: '%s' not found!\n",
  64                                       info->driver);
  65                                 continue;
  66                         }
  67
  68                         debug("  - found child driver: '%s'\n", drv->name);
  69
  70                         ret = device_bind_with_driver_data(pmic, drv, node_name,
  71                                                            0, node, &child);
  72                         if (ret) {
  73                                 debug("  - child binding error: %d\n", ret);
  74                                 continue;
  75                         }
  76
  77                         debug("  - bound child device: '%s'\n", child->name);
  78
  79                         child->driver_data = trailing_strtol(node_name);
  80
  81                         debug("  - set 'child->driver_data': %lu\n",
  82                               child->driver_data);
  83                         break;
  84                 }
  85
  86                 if (child)
  87                         bind_count++;
  88                 else
  89                         debug("  - compatible prefix not found\n");
  90         }
  91
  92         debug("Bound: %d children for PMIC: '%s'\n", bind_count, pmic->name);
  93         return bind_count;
  94 }
  95 #endif
  96
  97 int pmic_get(const char *name, struct udevice **devp)
  98 {
  99         return uclass_get_device_by_name(UCLASS_PMIC, name, devp);
 100 }
 101
 102 int pmic_reg_count(struct udevice *dev)
 103 {
 104         const struct dm_pmic_ops *ops = dev_get_driver_ops(dev);
 105
 106         if (!ops || !ops->reg_count)
 107                 return -ENOSYS;
 108
 109         return ops->reg_count(dev);
 110 }
 111
 112 int pmic_read(struct udevice *dev, uint reg, uint8_t *buffer, int len)
 113 {
 114         const struct dm_pmic_ops *ops = dev_get_driver_ops(dev);
 115
 116         if (!buffer)
 117                 return -EFAULT;
 118
 119         if (!ops || !ops->read)
 120                 return -ENOSYS;
 121
 122         return ops->read(dev, reg, buffer, len);
 123 }
 124
 125 int pmic_write(struct udevice *dev, uint reg, const uint8_t *buffer, int len)
 126 {
 127         const struct dm_pmic_ops *ops = dev_get_driver_ops(dev);
 128
 129         if (!buffer)
 130                 return -EFAULT;
 131
 132         if (!ops || !ops->write)
 133                 return -ENOSYS;
 134
 135         return ops->write(dev, reg, buffer, len);
 136 }
 137
 138 int pmic_reg_read(struct udevice *dev, uint reg)
 139 {
 140         struct uc_pmic_priv *priv = dev_get_uclass_priv(dev);
 141         u32 val = 0;
 142         int ret;
 143
 144         if (priv->trans_len < 1 || priv->trans_len > sizeof(val)) {
 145                 debug("Wrong transmission size [%d]\n", priv->trans_len);
 146                 return -EINVAL;
 147         }
 148
 149         debug("%s: reg=%x priv->trans_len:%d", __func__, reg, priv->trans_len);
 150         ret = pmic_read(dev, reg, (uint8_t *)&val, priv->trans_len);
 151         debug(", value=%x, ret=%d\n", val, ret);
 152
 153         return ret ? ret : val;
 154 }
 155
 156 int pmic_reg_write(struct udevice *dev, uint reg, uint value)
 157 {
 158         struct uc_pmic_priv *priv = dev_get_uclass_priv(dev);
 159         int ret;
 160
 161         if (priv->trans_len < 1 || priv->trans_len > sizeof(value)) {
 162                 debug("Wrong transmission size [%d]\n", priv->trans_len);
 163                 return -EINVAL;
 164         }
 165
 166         debug("%s: reg=%x, value=%x priv->trans_len:%d", __func__, reg, value,
 167               priv->trans_len);
 168         ret = pmic_write(dev, reg, (uint8_t *)&value, priv->trans_len);
 169         debug(", ret=%d\n", ret);
 170
 171         return ret;
 172 }
 173
 174 int pmic_clrsetbits(struct udevice *dev, uint reg, uint clr, uint set)
 175 {
 176         struct uc_pmic_priv *priv = dev_get_uclass_priv(dev);
 177         u32 val = 0;
 178         int ret;
 179
 180         if (priv->trans_len < 1 || priv->trans_len > sizeof(val)) {
 181                 debug("Wrong transmission size [%d]\n", priv->trans_len);
 182                 return -EINVAL;
 183         }
 184
 185         ret = pmic_read(dev, reg, (uint8_t *)&val, priv->trans_len);
 186         if (ret < 0)
 187                 return ret;
 188
 189         val = (val & ~clr) | set;
 190         return pmic_write(dev, reg, (uint8_t *)&val, priv->trans_len);
 191 }
 192
 193 static int pmic_pre_probe(struct udevice *dev)
 194 {
 195         struct uc_pmic_priv *pmic_priv = dev_get_uclass_priv(dev);
 196
 197         pmic_priv->trans_len = 1;
 198         return 0;
 199 }
 200
 201 UCLASS_DRIVER(pmic) = {
 202         .id             = UCLASS_PMIC,
 203         .name           = "pmic",
 204         .pre_probe      = pmic_pre_probe,
 205         .per_device_auto        = sizeof(struct uc_pmic_priv),
 206 };