drivers/power/pmic/pmic-uclass.c

   1 /*
   2  * Copyright (C) 2014-2015 Samsung Electronics
   3  * Przemyslaw Marczak <p.marczak@samsung.com>
   4  *
   5  * SPDX-License-Identifier:     GPL-2.0+
   6  */
   7
   8 #include <common.h>
   9 #include <fdtdec.h>
  10 #include <errno.h>
  11 #include <dm.h>
  12 #include <dm/lists.h>
  13 #include <dm/device-internal.h>
  14 #include <dm/uclass-internal.h>
  15 #include <power/pmic.h>
  16 #include <linux/ctype.h>
  17
  18 DECLARE_GLOBAL_DATA_PTR;
  19
  20 static ulong str_get_num(const char *ptr, const char *maxptr)
  21 {
  22         if (!ptr || !maxptr)
  23                 return 0;
  24
  25         while (!isdigit(*ptr) && ptr++ < maxptr);
  26
  27         return simple_strtoul(ptr, NULL, 0);
  28 }
  29
  30 int pmic_bind_children(struct udevice *pmic, int offset,
  31                        const struct pmic_child_info *child_info)
  32 {
  33         const struct pmic_child_info *info;
  34         const void *blob = gd->fdt_blob;
  35         struct driver *drv;
  36         struct udevice *child;
  37         const char *node_name;
  38         int node_name_len;
  39         int bind_count = 0;
  40         int node;
  41         int prefix_len;
  42         int ret;
  43
  44         debug("%s for '%s' at node offset: %d\n", __func__, pmic->name,
  45               pmic->of_offset);
  46
  47         for (node = fdt_first_subnode(blob, offset);
  48              node > 0;
  49              node = fdt_next_subnode(blob, node)) {
  50                 node_name = fdt_get_name(blob, node, &node_name_len);
  51
  52                 debug("* Found child node: '%s' at offset:%d\n", node_name,
  53                                                                  node);
  54
  55                 child = NULL;
  56                 for (info = child_info; info->prefix && info->driver; info++) {
  57                         prefix_len = strlen(info->prefix);
  58                         if (strncasecmp(info->prefix, node_name, prefix_len))
  59                                 continue;
  60
  61                         debug("  - compatible prefix: '%s'\n", info->prefix);
  62
  63                         drv = lists_driver_lookup_name(info->driver);
  64                         if (!drv) {
  65                                 debug("  - driver: '%s' not found!\n",
  66                                       info->driver);
  67                                 continue;
  68                         }
  69
  70                         debug("  - found child driver: '%s'\n", drv->name);
  71
  72                         ret = device_bind(pmic, drv, node_name, NULL,
  73                                           node, &child);
  74                         if (ret) {
  75                                 debug("  - child binding error: %d\n", ret);
  76                                 continue;
  77                         }
  78
  79                         debug("  - bound child device: '%s'\n", child->name);
  80
  81                         child->driver_data = str_get_num(node_name +
  82                                                          prefix_len,
  83                                                          node_name +
  84                                                          node_name_len);
  85
  86                         debug("  - set 'child->driver_data': %lu\n",
  87                               child->driver_data);
  88                         break;
  89                 }
  90
  91                 if (child)
  92                         bind_count++;
  93                 else
  94                         debug("  - compatible prefix not found\n");
  95         }
  96
  97         debug("Bound: %d childs for PMIC: '%s'\n", bind_count, pmic->name);
  98         return bind_count;
  99 }
 100
 101 int pmic_get(const char *name, struct udevice **devp)
 102 {
 103         return uclass_get_device_by_name(UCLASS_PMIC, name, devp);
 104 }
 105
 106 int pmic_reg_count(struct udevice *dev)
 107 {
 108         const struct dm_pmic_ops *ops = dev_get_driver_ops(dev);
 109
 110         if (!ops || !ops->reg_count)
 111                 return -ENOSYS;
 112
 113         return ops->reg_count(dev);
 114 }
 115
 116 int pmic_read(struct udevice *dev, uint reg, uint8_t *buffer, int len)
 117 {
 118         const struct dm_pmic_ops *ops = dev_get_driver_ops(dev);
 119
 120         if (!buffer)
 121                 return -EFAULT;
 122
 123         if (!ops || !ops->read)
 124                 return -ENOSYS;
 125
 126         return ops->read(dev, reg, buffer, len);
 127 }
 128
 129 int pmic_write(struct udevice *dev, uint reg, const uint8_t *buffer, int len)
 130 {
 131         const struct dm_pmic_ops *ops = dev_get_driver_ops(dev);
 132
 133         if (!buffer)
 134                 return -EFAULT;
 135
 136         if (!ops || !ops->write)
 137                 return -ENOSYS;
 138
 139         return ops->write(dev, reg, buffer, len);
 140 }
 141
 142 UCLASS_DRIVER(pmic) = {
 143         .id             = UCLASS_PMIC,
 144         .name           = "pmic",
 145 };