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