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