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 <power/pmic.h>
17 #include <linux/ctype.h>
18 
19 DECLARE_GLOBAL_DATA_PTR;
20 
21 int pmic_bind_children(struct udevice *pmic, int offset,
22 		       const struct pmic_child_info *child_info)
23 {
24 	const struct pmic_child_info *info;
25 	const void *blob = gd->fdt_blob;
26 	struct driver *drv;
27 	struct udevice *child;
28 	const char *node_name;
29 	int bind_count = 0;
30 	int node;
31 	int prefix_len;
32 	int ret;
33 
34 	debug("%s for '%s' at node offset: %d\n", __func__, pmic->name,
35 	      pmic->of_offset);
36 
37 	for (node = fdt_first_subnode(blob, offset);
38 	     node > 0;
39 	     node = fdt_next_subnode(blob, node)) {
40 		node_name = fdt_get_name(blob, node, NULL);
41 
42 		debug("* Found child node: '%s' at offset:%d\n", node_name,
43 								 node);
44 
45 		child = NULL;
46 		for (info = child_info; info->prefix && info->driver; info++) {
47 			debug("  - compatible prefix: '%s'\n", info->prefix);
48 
49 			prefix_len = strlen(info->prefix);
50 			if (strncmp(info->prefix, node_name, prefix_len))
51 				continue;
52 
53 			drv = lists_driver_lookup_name(info->driver);
54 			if (!drv) {
55 				debug("  - driver: '%s' not found!\n",
56 				      info->driver);
57 				continue;
58 			}
59 
60 			debug("  - found child driver: '%s'\n", drv->name);
61 
62 			ret = device_bind(pmic, drv, node_name, NULL,
63 					  node, &child);
64 			if (ret) {
65 				debug("  - child binding error: %d\n", ret);
66 				continue;
67 			}
68 
69 			debug("  - bound child device: '%s'\n", child->name);
70 
71 			child->driver_data = trailing_strtol(node_name);
72 
73 			debug("  - set 'child->driver_data': %lu\n",
74 			      child->driver_data);
75 			break;
76 		}
77 
78 		if (child)
79 			bind_count++;
80 		else
81 			debug("  - compatible prefix not found\n");
82 	}
83 
84 	debug("Bound: %d childs for PMIC: '%s'\n", bind_count, pmic->name);
85 	return bind_count;
86 }
87 
88 int pmic_get(const char *name, struct udevice **devp)
89 {
90 	return uclass_get_device_by_name(UCLASS_PMIC, name, devp);
91 }
92 
93 int pmic_reg_count(struct udevice *dev)
94 {
95 	const struct dm_pmic_ops *ops = dev_get_driver_ops(dev);
96 
97 	if (!ops || !ops->reg_count)
98 		return -ENOSYS;
99 
100 	return ops->reg_count(dev);
101 }
102 
103 int pmic_read(struct udevice *dev, uint reg, uint8_t *buffer, int len)
104 {
105 	const struct dm_pmic_ops *ops = dev_get_driver_ops(dev);
106 
107 	if (!buffer)
108 		return -EFAULT;
109 
110 	if (!ops || !ops->read)
111 		return -ENOSYS;
112 
113 	return ops->read(dev, reg, buffer, len);
114 }
115 
116 int pmic_write(struct udevice *dev, uint reg, const 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->write)
124 		return -ENOSYS;
125 
126 	return ops->write(dev, reg, buffer, len);
127 }
128 
129 int pmic_reg_read(struct udevice *dev, uint reg)
130 {
131 	u8 byte;
132 	int ret;
133 
134 	ret = pmic_read(dev, reg, &byte, 1);
135 	debug("%s: reg=%x, value=%x\n", __func__, reg, byte);
136 
137 	return ret ? ret : byte;
138 }
139 
140 int pmic_reg_write(struct udevice *dev, uint reg, uint value)
141 {
142 	u8 byte = value;
143 
144 	debug("%s: reg=%x, value=%x\n", __func__, reg, value);
145 	return pmic_read(dev, reg, &byte, 1);
146 }
147 
148 int pmic_clrsetbits(struct udevice *dev, uint reg, uint clr, uint set)
149 {
150 	u8 byte;
151 	int ret;
152 
153 	ret = pmic_reg_read(dev, reg);
154 	if (ret < 0)
155 		return ret;
156 	byte = (ret & ~clr) | set;
157 
158 	return pmic_reg_write(dev, reg, byte);
159 }
160 
161 UCLASS_DRIVER(pmic) = {
162 	.id		= UCLASS_PMIC,
163 	.name		= "pmic",
164 };
165