2 * Device tree integration for the pin control subsystem
4 * Copyright (C) 2012 NVIDIA CORPORATION. All rights reserved.
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2, as published by the Free Software Foundation.
10 * This program is distributed in the hope it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 #include <linux/device.h>
21 #include <linux/pinctrl/pinctrl.h>
22 #include <linux/slab.h>
25 #include "devicetree.h"
28 * struct pinctrl_dt_map - mapping table chunk parsed from device tree
29 * @node: list node for struct pinctrl's @dt_maps field
30 * @pctldev: the pin controller that allocated this struct, and will free it
31 * @maps: the mapping table entries
33 struct pinctrl_dt_map
{
34 struct list_head node
;
35 struct pinctrl_dev
*pctldev
;
36 struct pinctrl_map
*map
;
40 static void dt_free_map(struct pinctrl_dev
*pctldev
,
41 struct pinctrl_map
*map
, unsigned num_maps
)
44 struct pinctrl_ops
*ops
= pctldev
->desc
->pctlops
;
45 ops
->dt_free_map(pctldev
, map
, num_maps
);
47 /* There is no pctldev for PIN_MAP_TYPE_DUMMY_STATE */
52 void pinctrl_dt_free_maps(struct pinctrl
*p
)
54 struct pinctrl_dt_map
*dt_map
, *n1
;
56 list_for_each_entry_safe(dt_map
, n1
, &p
->dt_maps
, node
) {
57 pinctrl_unregister_map(dt_map
->map
);
58 list_del(&dt_map
->node
);
59 dt_free_map(dt_map
->pctldev
, dt_map
->map
,
64 of_node_put(p
->dev
->of_node
);
67 static int dt_remember_or_free_map(struct pinctrl
*p
, const char *statename
,
68 struct pinctrl_dev
*pctldev
,
69 struct pinctrl_map
*map
, unsigned num_maps
)
72 struct pinctrl_dt_map
*dt_map
;
74 /* Initialize common mapping table entry fields */
75 for (i
= 0; i
< num_maps
; i
++) {
76 map
[i
].dev_name
= dev_name(p
->dev
);
77 map
[i
].name
= statename
;
79 map
[i
].ctrl_dev_name
= dev_name(pctldev
->dev
);
82 /* Remember the converted mapping table entries */
83 dt_map
= kzalloc(sizeof(*dt_map
), GFP_KERNEL
);
85 dev_err(p
->dev
, "failed to alloc struct pinctrl_dt_map\n");
86 dt_free_map(pctldev
, map
, num_maps
);
90 dt_map
->pctldev
= pctldev
;
92 dt_map
->num_maps
= num_maps
;
93 list_add_tail(&dt_map
->node
, &p
->dt_maps
);
95 return pinctrl_register_map(map
, num_maps
, false, true);
98 static struct pinctrl_dev
*find_pinctrl_by_of_node(struct device_node
*np
)
100 struct pinctrl_dev
*pctldev
;
102 list_for_each_entry(pctldev
, &pinctrldev_list
, node
)
103 if (pctldev
->dev
->of_node
== np
)
109 struct pinctrl_dev
*of_pinctrl_get(struct device_node
*np
)
111 struct pinctrl_dev
*pctldev
;
113 pctldev
= find_pinctrl_by_of_node(np
);
120 static int dt_to_map_one_config(struct pinctrl
*p
, const char *statename
,
121 struct device_node
*np_config
)
123 struct device_node
*np_pctldev
;
124 struct pinctrl_dev
*pctldev
;
125 struct pinctrl_ops
*ops
;
127 struct pinctrl_map
*map
;
130 /* Find the pin controller containing np_config */
131 np_pctldev
= of_node_get(np_config
);
133 np_pctldev
= of_get_next_parent(np_pctldev
);
134 if (!np_pctldev
|| of_node_is_root(np_pctldev
)) {
135 dev_info(p
->dev
, "could not find pctldev for node %s, deferring probe\n",
136 np_config
->full_name
);
137 of_node_put(np_pctldev
);
138 /* OK let's just assume this will appear later then */
139 return -EPROBE_DEFER
;
141 pctldev
= find_pinctrl_by_of_node(np_pctldev
);
144 /* Do not defer probing of hogs (circular loop) */
145 if (np_pctldev
== p
->dev
->of_node
) {
146 of_node_put(np_pctldev
);
150 of_node_put(np_pctldev
);
153 * Call pinctrl driver to parse device tree node, and
154 * generate mapping table entries
156 ops
= pctldev
->desc
->pctlops
;
157 if (!ops
->dt_node_to_map
) {
158 dev_err(p
->dev
, "pctldev %s doesn't support DT\n",
159 dev_name(pctldev
->dev
));
162 ret
= ops
->dt_node_to_map(pctldev
, np_config
, &map
, &num_maps
);
166 /* Stash the mapping table chunk away for later use */
167 return dt_remember_or_free_map(p
, statename
, pctldev
, map
, num_maps
);
170 static int dt_remember_dummy_state(struct pinctrl
*p
, const char *statename
)
172 struct pinctrl_map
*map
;
174 map
= kzalloc(sizeof(*map
), GFP_KERNEL
);
176 dev_err(p
->dev
, "failed to alloc struct pinctrl_map\n");
180 /* There is no pctldev for PIN_MAP_TYPE_DUMMY_STATE */
181 map
->type
= PIN_MAP_TYPE_DUMMY_STATE
;
183 return dt_remember_or_free_map(p
, statename
, NULL
, map
, 1);
186 int pinctrl_dt_to_map(struct pinctrl
*p
)
188 struct device_node
*np
= p
->dev
->of_node
;
191 struct property
*prop
;
192 const char *statename
;
196 struct device_node
*np_config
;
198 /* CONFIG_OF enabled, p->dev not instantiated from DT */
200 dev_dbg(p
->dev
, "no of_node; not parsing pinctrl DT\n");
204 /* We may store pointers to property names within the node */
207 /* For each defined state ID */
208 for (state
= 0; ; state
++) {
209 /* Retrieve the pinctrl-* property */
210 propname
= kasprintf(GFP_KERNEL
, "pinctrl-%d", state
);
211 prop
= of_find_property(np
, propname
, &size
);
216 size
/= sizeof(*list
);
218 /* Determine whether pinctrl-names property names the state */
219 ret
= of_property_read_string_index(np
, "pinctrl-names",
222 * If not, statename is just the integer state ID. But rather
223 * than dynamically allocate it and have to free it later,
224 * just point part way into the property name for the string.
227 /* strlen("pinctrl-") == 8 */
228 statename
= prop
->name
+ 8;
231 /* For every referenced pin configuration node in it */
232 for (config
= 0; config
< size
; config
++) {
233 phandle
= be32_to_cpup(list
++);
235 /* Look up the pin configuration node */
236 np_config
= of_find_node_by_phandle(phandle
);
239 "prop %s index %i invalid phandle\n",
246 ret
= dt_to_map_one_config(p
, statename
, np_config
);
247 of_node_put(np_config
);
252 /* No entries in DT? Generate a dummy state table entry */
254 ret
= dt_remember_dummy_state(p
, statename
);
263 pinctrl_dt_free_maps(p
);