2 * linux/drivers/pinctrl/pinctrl-lantiq.c
3 * based on linux/drivers/pinctrl/pinctrl-pxa3xx.c
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * publishhed by the Free Software Foundation.
9 * Copyright (C) 2012 John Crispin <blogic@openwrt.org>
12 #include <linux/module.h>
13 #include <linux/device.h>
15 #include <linux/platform_device.h>
16 #include <linux/slab.h>
19 #include "pinctrl-lantiq.h"
21 static int ltq_get_group_count(struct pinctrl_dev
*pctrldev
)
23 struct ltq_pinmux_info
*info
= pinctrl_dev_get_drvdata(pctrldev
);
24 return info
->num_grps
;
27 static const char *ltq_get_group_name(struct pinctrl_dev
*pctrldev
,
30 struct ltq_pinmux_info
*info
= pinctrl_dev_get_drvdata(pctrldev
);
31 if (selector
>= info
->num_grps
)
33 return info
->grps
[selector
].name
;
36 static int ltq_get_group_pins(struct pinctrl_dev
*pctrldev
,
38 const unsigned **pins
,
41 struct ltq_pinmux_info
*info
= pinctrl_dev_get_drvdata(pctrldev
);
42 if (selector
>= info
->num_grps
)
44 *pins
= info
->grps
[selector
].pins
;
45 *num_pins
= info
->grps
[selector
].npins
;
49 static void ltq_pinctrl_dt_free_map(struct pinctrl_dev
*pctldev
,
50 struct pinctrl_map
*map
, unsigned num_maps
)
54 for (i
= 0; i
< num_maps
; i
++)
55 if (map
[i
].type
== PIN_MAP_TYPE_CONFIGS_PIN
)
56 kfree(map
[i
].data
.configs
.configs
);
60 static void ltq_pinctrl_pin_dbg_show(struct pinctrl_dev
*pctldev
,
64 seq_printf(s
, " %s", dev_name(pctldev
->dev
));
67 static int ltq_pinctrl_dt_subnode_to_map(struct pinctrl_dev
*pctldev
,
68 struct device_node
*np
,
69 struct pinctrl_map
**map
)
71 struct ltq_pinmux_info
*info
= pinctrl_dev_get_drvdata(pctldev
);
72 unsigned long configs
[3];
73 unsigned num_configs
= 0;
74 struct property
*prop
;
75 const char *group
, *pin
;
79 ret
= of_property_read_string(np
, "lantiq,function", &function
);
81 of_property_for_each_string(np
, "lantiq,groups", prop
, group
) {
82 (*map
)->type
= PIN_MAP_TYPE_MUX_GROUP
;
83 (*map
)->name
= function
;
84 (*map
)->data
.mux
.group
= group
;
85 (*map
)->data
.mux
.function
= function
;
88 if (of_find_property(np
, "lantiq,pins", NULL
))
90 "%s mixes pins and groups settings\n",
95 for (i
= 0; i
< info
->num_params
; i
++) {
97 int ret
= of_property_read_u32(np
,
98 info
->params
[i
].property
, &val
);
100 configs
[num_configs
++] =
101 LTQ_PINCONF_PACK(info
->params
[i
].param
,
108 of_property_for_each_string(np
, "lantiq,pins", prop
, pin
) {
109 (*map
)->data
.configs
.configs
= kmemdup(configs
,
110 num_configs
* sizeof(unsigned long),
112 (*map
)->type
= PIN_MAP_TYPE_CONFIGS_PIN
;
114 (*map
)->data
.configs
.group_or_pin
= pin
;
115 (*map
)->data
.configs
.num_configs
= num_configs
;
121 static int ltq_pinctrl_dt_subnode_size(struct device_node
*np
)
125 ret
= of_property_count_strings(np
, "lantiq,groups");
127 ret
= of_property_count_strings(np
, "lantiq,pins");
131 static int ltq_pinctrl_dt_node_to_map(struct pinctrl_dev
*pctldev
,
132 struct device_node
*np_config
,
133 struct pinctrl_map
**map
,
136 struct pinctrl_map
*tmp
;
137 struct device_node
*np
;
141 for_each_child_of_node(np_config
, np
)
142 *num_maps
+= ltq_pinctrl_dt_subnode_size(np
);
143 *map
= kzalloc(*num_maps
* sizeof(struct pinctrl_map
), GFP_KERNEL
);
148 for_each_child_of_node(np_config
, np
) {
149 ret
= ltq_pinctrl_dt_subnode_to_map(pctldev
, np
, &tmp
);
151 ltq_pinctrl_dt_free_map(pctldev
, *map
, *num_maps
);
158 static struct pinctrl_ops ltq_pctrl_ops
= {
159 .get_groups_count
= ltq_get_group_count
,
160 .get_group_name
= ltq_get_group_name
,
161 .get_group_pins
= ltq_get_group_pins
,
162 .pin_dbg_show
= ltq_pinctrl_pin_dbg_show
,
163 .dt_node_to_map
= ltq_pinctrl_dt_node_to_map
,
164 .dt_free_map
= ltq_pinctrl_dt_free_map
,
167 static int ltq_pmx_func_count(struct pinctrl_dev
*pctrldev
)
169 struct ltq_pinmux_info
*info
= pinctrl_dev_get_drvdata(pctrldev
);
171 return info
->num_funcs
;
174 static const char *ltq_pmx_func_name(struct pinctrl_dev
*pctrldev
,
177 struct ltq_pinmux_info
*info
= pinctrl_dev_get_drvdata(pctrldev
);
179 if (selector
>= info
->num_funcs
)
182 return info
->funcs
[selector
].name
;
185 static int ltq_pmx_get_groups(struct pinctrl_dev
*pctrldev
,
187 const char * const **groups
,
188 unsigned * const num_groups
)
190 struct ltq_pinmux_info
*info
= pinctrl_dev_get_drvdata(pctrldev
);
192 *groups
= info
->funcs
[func
].groups
;
193 *num_groups
= info
->funcs
[func
].num_groups
;
198 /* Return function number. If failure, return negative value. */
199 static int match_mux(const struct ltq_mfp_pin
*mfp
, unsigned mux
)
202 for (i
= 0; i
< LTQ_MAX_MUX
; i
++) {
203 if (mfp
->func
[i
] == mux
)
206 if (i
>= LTQ_MAX_MUX
)
211 /* dont assume .mfp is linearly mapped. find the mfp with the correct .pin */
212 static int match_mfp(const struct ltq_pinmux_info
*info
, int pin
)
215 for (i
= 0; i
< info
->num_mfp
; i
++) {
216 if (info
->mfp
[i
].pin
== pin
)
222 /* check whether current pin configuration is valid. Negative for failure */
223 static int match_group_mux(const struct ltq_pin_group
*grp
,
224 const struct ltq_pinmux_info
*info
,
228 for (i
= 0; i
< grp
->npins
; i
++) {
229 pin
= match_mfp(info
, grp
->pins
[i
]);
231 dev_err(info
->dev
, "could not find mfp for pin %d\n",
235 ret
= match_mux(&info
->mfp
[pin
], mux
);
237 dev_err(info
->dev
, "Can't find mux %d on pin%d\n",
245 static int ltq_pmx_enable(struct pinctrl_dev
*pctrldev
,
249 struct ltq_pinmux_info
*info
= pinctrl_dev_get_drvdata(pctrldev
);
250 const struct ltq_pin_group
*pin_grp
= &info
->grps
[group
];
251 int i
, pin
, pin_func
, ret
;
253 if (!pin_grp
->npins
||
254 (match_group_mux(pin_grp
, info
, pin_grp
->mux
) < 0)) {
255 dev_err(info
->dev
, "Failed to set the pin group: %s\n",
256 info
->grps
[group
].name
);
259 for (i
= 0; i
< pin_grp
->npins
; i
++) {
260 pin
= match_mfp(info
, pin_grp
->pins
[i
]);
262 dev_err(info
->dev
, "could not find mfp for pin %d\n",
266 pin_func
= match_mux(&info
->mfp
[pin
], pin_grp
->mux
);
267 ret
= info
->apply_mux(pctrldev
, pin
, pin_func
);
270 "failed to apply mux %d for pin %d\n",
278 static int ltq_pmx_gpio_request_enable(struct pinctrl_dev
*pctrldev
,
279 struct pinctrl_gpio_range
*range
,
282 struct ltq_pinmux_info
*info
= pinctrl_dev_get_drvdata(pctrldev
);
283 int mfp
= match_mfp(info
, pin
+ (range
->id
* 32));
287 dev_err(info
->dev
, "could not find mfp for pin %d\n", pin
);
291 pin_func
= match_mux(&info
->mfp
[mfp
], 0);
293 dev_err(info
->dev
, "No GPIO function on pin%d\n", mfp
);
297 return info
->apply_mux(pctrldev
, mfp
, pin_func
);
300 static struct pinmux_ops ltq_pmx_ops
= {
301 .get_functions_count
= ltq_pmx_func_count
,
302 .get_function_name
= ltq_pmx_func_name
,
303 .get_function_groups
= ltq_pmx_get_groups
,
304 .enable
= ltq_pmx_enable
,
305 .gpio_request_enable
= ltq_pmx_gpio_request_enable
,
309 * allow different socs to register with the generic part of the lanti
312 int ltq_pinctrl_register(struct platform_device
*pdev
,
313 struct ltq_pinmux_info
*info
)
315 struct pinctrl_desc
*desc
;
320 desc
->pctlops
= <q_pctrl_ops
;
321 desc
->pmxops
= <q_pmx_ops
;
322 info
->dev
= &pdev
->dev
;
324 info
->pctrl
= pinctrl_register(desc
, &pdev
->dev
, info
);
326 dev_err(&pdev
->dev
, "failed to register LTQ pinmux driver\n");
329 platform_set_drvdata(pdev
, info
);