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
);
145 of_node_put(np_pctldev
);
148 * Call pinctrl driver to parse device tree node, and
149 * generate mapping table entries
151 ops
= pctldev
->desc
->pctlops
;
152 if (!ops
->dt_node_to_map
) {
153 dev_err(p
->dev
, "pctldev %s doesn't support DT\n",
154 dev_name(pctldev
->dev
));
157 ret
= ops
->dt_node_to_map(pctldev
, np_config
, &map
, &num_maps
);
161 /* Stash the mapping table chunk away for later use */
162 return dt_remember_or_free_map(p
, statename
, pctldev
, map
, num_maps
);
165 static int dt_remember_dummy_state(struct pinctrl
*p
, const char *statename
)
167 struct pinctrl_map
*map
;
169 map
= kzalloc(sizeof(*map
), GFP_KERNEL
);
171 dev_err(p
->dev
, "failed to alloc struct pinctrl_map\n");
175 /* There is no pctldev for PIN_MAP_TYPE_DUMMY_STATE */
176 map
->type
= PIN_MAP_TYPE_DUMMY_STATE
;
178 return dt_remember_or_free_map(p
, statename
, NULL
, map
, 1);
181 int pinctrl_dt_to_map(struct pinctrl
*p
)
183 struct device_node
*np
= p
->dev
->of_node
;
186 struct property
*prop
;
187 const char *statename
;
191 struct device_node
*np_config
;
193 /* CONFIG_OF enabled, p->dev not instantiated from DT */
195 dev_dbg(p
->dev
, "no of_node; not parsing pinctrl DT\n");
199 /* We may store pointers to property names within the node */
202 /* For each defined state ID */
203 for (state
= 0; ; state
++) {
204 /* Retrieve the pinctrl-* property */
205 propname
= kasprintf(GFP_KERNEL
, "pinctrl-%d", state
);
206 prop
= of_find_property(np
, propname
, &size
);
211 size
/= sizeof(*list
);
213 /* Determine whether pinctrl-names property names the state */
214 ret
= of_property_read_string_index(np
, "pinctrl-names",
217 * If not, statename is just the integer state ID. But rather
218 * than dynamically allocate it and have to free it later,
219 * just point part way into the property name for the string.
222 /* strlen("pinctrl-") == 8 */
223 statename
= prop
->name
+ 8;
226 /* For every referenced pin configuration node in it */
227 for (config
= 0; config
< size
; config
++) {
228 phandle
= be32_to_cpup(list
++);
230 /* Look up the pin configuration node */
231 np_config
= of_find_node_by_phandle(phandle
);
234 "prop %s index %i invalid phandle\n",
241 ret
= dt_to_map_one_config(p
, statename
, np_config
);
242 of_node_put(np_config
);
247 /* No entries in DT? Generate a dummy state table entry */
249 ret
= dt_remember_dummy_state(p
, statename
);
258 pinctrl_dt_free_maps(p
);