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 <vsprintf.h> 13 #include <dm/lists.h> 14 #include <dm/device-internal.h> 15 #include <dm/uclass-internal.h> 16 #include <dm/of_access.h> 17 #include <power/pmic.h> 18 #include <linux/ctype.h> 19 20 DECLARE_GLOBAL_DATA_PTR; 21 22 #if CONFIG_IS_ENABLED(PMIC_CHILDREN) 23 int pmic_bind_children(struct udevice *pmic, ofnode parent, 24 const struct pmic_child_info *child_info) 25 { 26 const struct pmic_child_info *info; 27 struct driver *drv; 28 struct udevice *child; 29 const char *node_name; 30 const char *reg_name; 31 int bind_count = 0; 32 ofnode node; 33 int prefix_len; 34 int ret; 35 bool enable; 36 37 debug("%s for '%s' at node offset: %d\n", __func__, pmic->name, 38 dev_of_offset(pmic)); 39 40 ofnode_for_each_subnode(node, parent) { 41 node_name = ofnode_get_name(node); 42 43 debug("* Found child node: '%s'\n", node_name); 44 45 if (ofnode_is_np(node)) 46 enable = of_device_is_available(ofnode_to_np(node)); 47 else 48 enable = fdtdec_get_is_enabled(gd->fdt_blob, 49 ofnode_to_offset(node)); 50 if (!enable) { 51 debug("* But '%s' is disabled\n", node_name); 52 continue; 53 } 54 55 child = NULL; 56 for (info = child_info; info->prefix && info->driver; info++) { 57 debug(" - compatible prefix: '%s'\n", info->prefix); 58 59 prefix_len = strlen(info->prefix); 60 if (strncmp(info->prefix, node_name, prefix_len)) { 61 reg_name = ofnode_read_string(node, 62 "regulator-name"); 63 if (!reg_name) 64 continue; 65 if (strncmp(info->prefix, reg_name, prefix_len)) 66 continue; 67 } 68 69 drv = lists_driver_lookup_name(info->driver); 70 if (!drv) { 71 debug(" - driver: '%s' not found!\n", 72 info->driver); 73 continue; 74 } 75 76 debug(" - found child driver: '%s'\n", drv->name); 77 78 ret = device_bind_with_driver_data(pmic, drv, node_name, 79 0, node, &child); 80 if (ret) { 81 debug(" - child binding error: %d\n", ret); 82 continue; 83 } 84 85 debug(" - bound child device: '%s'\n", child->name); 86 87 child->driver_data = trailing_strtol(node_name); 88 89 debug(" - set 'child->driver_data': %lu\n", 90 child->driver_data); 91 break; 92 } 93 94 if (child) 95 bind_count++; 96 else 97 debug(" - compatible prefix not found\n"); 98 } 99 100 debug("Bound: %d children for PMIC: '%s'\n", bind_count, pmic->name); 101 return bind_count; 102 } 103 #endif 104 105 int pmic_get(const char *name, struct udevice **devp) 106 { 107 return uclass_get_device_by_name(UCLASS_PMIC, name, devp); 108 } 109 110 int pmic_reg_count(struct udevice *dev) 111 { 112 const struct dm_pmic_ops *ops = dev_get_driver_ops(dev); 113 114 if (!ops || !ops->reg_count) 115 return -ENOSYS; 116 117 return ops->reg_count(dev); 118 } 119 120 int pmic_read(struct udevice *dev, uint reg, uint8_t *buffer, int len) 121 { 122 const struct dm_pmic_ops *ops = dev_get_driver_ops(dev); 123 124 if (!buffer) 125 return -EFAULT; 126 127 if (!ops || !ops->read) 128 return -ENOSYS; 129 130 return ops->read(dev, reg, buffer, len); 131 } 132 133 int pmic_write(struct udevice *dev, uint reg, const uint8_t *buffer, int len) 134 { 135 const struct dm_pmic_ops *ops = dev_get_driver_ops(dev); 136 137 if (!buffer) 138 return -EFAULT; 139 140 if (!ops || !ops->write) 141 return -ENOSYS; 142 143 return ops->write(dev, reg, buffer, len); 144 } 145 146 int pmic_reg_read(struct udevice *dev, uint reg) 147 { 148 u8 byte; 149 int ret; 150 151 debug("%s: reg=%x", __func__, reg); 152 ret = pmic_read(dev, reg, &byte, 1); 153 debug(", value=%x, ret=%d\n", byte, ret); 154 155 return ret ? ret : byte; 156 } 157 158 int pmic_reg_write(struct udevice *dev, uint reg, uint value) 159 { 160 u8 byte = value; 161 int ret; 162 163 debug("%s: reg=%x, value=%x", __func__, reg, value); 164 ret = pmic_write(dev, reg, &byte, 1); 165 debug(", ret=%d\n", ret); 166 167 return ret; 168 } 169 170 int pmic_clrsetbits(struct udevice *dev, uint reg, uint clr, uint set) 171 { 172 u8 byte; 173 int ret; 174 175 ret = pmic_reg_read(dev, reg); 176 if (ret < 0) 177 return ret; 178 byte = (ret & ~clr) | set; 179 180 return pmic_reg_write(dev, reg, byte); 181 } 182 183 184 int pmic_shutdown(struct udevice *dev) 185 { 186 const struct dm_pmic_ops *ops = dev_get_driver_ops(dev); 187 188 if (!ops || !ops->shutdown) 189 return -ENOSYS; 190 191 return ops->shutdown(dev); 192 } 193 194 UCLASS_DRIVER(pmic) = { 195 .id = UCLASS_PMIC, 196 .name = "pmic", 197 }; 198