]>
git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/pinctrl/aspeed/pinctrl-aspeed.c
2 * Copyright (C) 2016 IBM Corp.
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
10 #include <linux/mfd/syscon.h>
11 #include <linux/platform_device.h>
12 #include <linux/slab.h>
13 #include <linux/string.h>
15 #include "pinctrl-aspeed.h"
17 static const char *const aspeed_pinmux_ips
[] = {
18 [ASPEED_IP_SCU
] = "SCU",
19 [ASPEED_IP_GFX
] = "GFX",
20 [ASPEED_IP_LPC
] = "LPC",
23 int aspeed_pinctrl_get_groups_count(struct pinctrl_dev
*pctldev
)
25 struct aspeed_pinctrl_data
*pdata
= pinctrl_dev_get_drvdata(pctldev
);
27 return pdata
->ngroups
;
30 const char *aspeed_pinctrl_get_group_name(struct pinctrl_dev
*pctldev
,
33 struct aspeed_pinctrl_data
*pdata
= pinctrl_dev_get_drvdata(pctldev
);
35 return pdata
->groups
[group
].name
;
38 int aspeed_pinctrl_get_group_pins(struct pinctrl_dev
*pctldev
,
39 unsigned int group
, const unsigned int **pins
,
42 struct aspeed_pinctrl_data
*pdata
= pinctrl_dev_get_drvdata(pctldev
);
44 *pins
= &pdata
->groups
[group
].pins
[0];
45 *npins
= pdata
->groups
[group
].npins
;
50 void aspeed_pinctrl_pin_dbg_show(struct pinctrl_dev
*pctldev
,
51 struct seq_file
*s
, unsigned int offset
)
53 seq_printf(s
, " %s", dev_name(pctldev
->dev
));
56 int aspeed_pinmux_get_fn_count(struct pinctrl_dev
*pctldev
)
58 struct aspeed_pinctrl_data
*pdata
= pinctrl_dev_get_drvdata(pctldev
);
60 return pdata
->nfunctions
;
63 const char *aspeed_pinmux_get_fn_name(struct pinctrl_dev
*pctldev
,
64 unsigned int function
)
66 struct aspeed_pinctrl_data
*pdata
= pinctrl_dev_get_drvdata(pctldev
);
68 return pdata
->functions
[function
].name
;
71 int aspeed_pinmux_get_fn_groups(struct pinctrl_dev
*pctldev
,
72 unsigned int function
,
73 const char * const **groups
,
74 unsigned int * const num_groups
)
76 struct aspeed_pinctrl_data
*pdata
= pinctrl_dev_get_drvdata(pctldev
);
78 *groups
= pdata
->functions
[function
].groups
;
79 *num_groups
= pdata
->functions
[function
].ngroups
;
84 static inline void aspeed_sig_desc_print_val(
85 const struct aspeed_sig_desc
*desc
, bool enable
, u32 rv
)
87 pr_debug("Want %s%X[0x%08X]=0x%X, got 0x%X from 0x%08X\n",
88 aspeed_pinmux_ips
[desc
->ip
], desc
->reg
,
89 desc
->mask
, enable
? desc
->enable
: desc
->disable
,
90 (rv
& desc
->mask
) >> __ffs(desc
->mask
), rv
);
94 * Query the enabled or disabled state of a signal descriptor
96 * @desc: The signal descriptor of interest
97 * @enabled: True to query the enabled state, false to query disabled state
98 * @regmap: The IP block's regmap instance
100 * Return: 1 if the descriptor's bitfield is configured to the state
101 * selected by @enabled, 0 if not, and less than zero if an unrecoverable
104 * Evaluation of descriptor state is non-trivial in that it is not a binary
105 * outcome: The bitfields can be greater than one bit in size and thus can take
106 * a value that is neither the enabled nor disabled state recorded in the
107 * descriptor (typically this means a different function to the one of interest
108 * is enabled). Thus we must explicitly test for either condition as required.
110 static int aspeed_sig_desc_eval(const struct aspeed_sig_desc
*desc
,
111 bool enabled
, struct regmap
*map
)
120 ret
= regmap_read(map
, desc
->reg
, &raw
);
124 aspeed_sig_desc_print_val(desc
, enabled
, raw
);
125 want
= enabled
? desc
->enable
: desc
->disable
;
127 return ((raw
& desc
->mask
) >> __ffs(desc
->mask
)) == want
;
131 * Query the enabled or disabled state for a mux function's signal on a pin
133 * @expr: An expression controlling the signal for a mux function on a pin
134 * @enabled: True to query the enabled state, false to query disabled state
135 * @maps: The list of regmap instances
137 * Return: 1 if the expression composed by @enabled evaluates true, 0 if not,
138 * and less than zero if an unrecoverable failure occurred.
140 * A mux function is enabled or disabled if the function's signal expression
141 * for each pin in the function's pin group evaluates true for the desired
142 * state. An signal expression evaluates true if all of its associated signal
143 * descriptors evaluate true for the desired state.
145 * If an expression's state is described by more than one bit, either through
146 * multi-bit bitfields in a single signal descriptor or through multiple signal
147 * descriptors of a single bit then it is possible for the expression to be in
148 * neither the enabled nor disabled state. Thus we must explicitly test for
149 * either condition as required.
151 static int aspeed_sig_expr_eval(const struct aspeed_sig_expr
*expr
,
152 bool enabled
, struct regmap
* const *maps
)
157 for (i
= 0; i
< expr
->ndescs
; i
++) {
158 const struct aspeed_sig_desc
*desc
= &expr
->descs
[i
];
160 ret
= aspeed_sig_desc_eval(desc
, enabled
, maps
[desc
->ip
]);
169 * Configure a pin's signal by applying an expression's descriptor state for
170 * all descriptors in the expression.
172 * @expr: The expression associated with the function whose signal is to be
174 * @enable: true to enable an function's signal through a pin's signal
175 * expression, false to disable the function's signal
176 * @maps: The list of regmap instances for pinmux register access.
178 * Return: 0 if the expression is configured as requested and a negative error
181 static int aspeed_sig_expr_set(const struct aspeed_sig_expr
*expr
,
182 bool enable
, struct regmap
* const *maps
)
187 for (i
= 0; i
< expr
->ndescs
; i
++) {
188 const struct aspeed_sig_desc
*desc
= &expr
->descs
[i
];
189 u32 pattern
= enable
? desc
->enable
: desc
->disable
;
190 u32 val
= (pattern
<< __ffs(desc
->mask
));
196 * Strap registers are configured in hardware or by early-boot
197 * firmware. Treat them as read-only despite that we can write
198 * them. This may mean that certain functions cannot be
199 * deconfigured and is the reason we re-evaluate after writing
200 * all descriptor bits.
202 if ((desc
->reg
== HW_STRAP1
|| desc
->reg
== HW_STRAP2
) &&
203 desc
->ip
== ASPEED_IP_SCU
)
206 ret
= regmap_update_bits(maps
[desc
->ip
], desc
->reg
,
213 ret
= aspeed_sig_expr_eval(expr
, enable
, maps
);
223 static int aspeed_sig_expr_enable(const struct aspeed_sig_expr
*expr
,
224 struct regmap
* const *maps
)
228 ret
= aspeed_sig_expr_eval(expr
, true, maps
);
233 return aspeed_sig_expr_set(expr
, true, maps
);
238 static int aspeed_sig_expr_disable(const struct aspeed_sig_expr
*expr
,
239 struct regmap
* const *maps
)
243 ret
= aspeed_sig_expr_eval(expr
, true, maps
);
248 return aspeed_sig_expr_set(expr
, false, maps
);
254 * Disable a signal on a pin by disabling all provided signal expressions.
256 * @exprs: The list of signal expressions (from a priority level on a pin)
257 * @maps: The list of regmap instances for pinmux register access.
259 * Return: 0 if all expressions are disabled, otherwise a negative error code
261 static int aspeed_disable_sig(const struct aspeed_sig_expr
**exprs
,
262 struct regmap
* const *maps
)
269 while (*exprs
&& !ret
) {
270 ret
= aspeed_sig_expr_disable(*exprs
, maps
);
278 * Search for the signal expression needed to enable the pin's signal for the
279 * requested function.
281 * @exprs: List of signal expressions (haystack)
282 * @name: The name of the requested function (needle)
284 * Return: A pointer to the signal expression whose function tag matches the
285 * provided name, otherwise NULL.
288 static const struct aspeed_sig_expr
*aspeed_find_expr_by_name(
289 const struct aspeed_sig_expr
**exprs
, const char *name
)
292 if (strcmp((*exprs
)->function
, name
) == 0)
300 static char *get_defined_attribute(const struct aspeed_pin_desc
*pdesc
,
302 const struct aspeed_sig_expr
*))
306 const struct aspeed_sig_expr
***prios
, **funcs
, *expr
;
308 prios
= pdesc
->prios
;
310 while ((funcs
= *prios
)) {
311 while ((expr
= *funcs
)) {
312 const char *str
= get(expr
);
313 size_t delta
= strlen(str
) + 2;
316 expanded
= krealloc(found
, len
+ delta
+ 1, GFP_KERNEL
);
339 found
[len
- 2] = '\0';
344 static const char *aspeed_sig_expr_function(const struct aspeed_sig_expr
*expr
)
346 return expr
->function
;
349 static char *get_defined_functions(const struct aspeed_pin_desc
*pdesc
)
351 return get_defined_attribute(pdesc
, aspeed_sig_expr_function
);
354 static const char *aspeed_sig_expr_signal(const struct aspeed_sig_expr
*expr
)
359 static char *get_defined_signals(const struct aspeed_pin_desc
*pdesc
)
361 return get_defined_attribute(pdesc
, aspeed_sig_expr_signal
);
364 int aspeed_pinmux_set_mux(struct pinctrl_dev
*pctldev
, unsigned int function
,
369 const struct aspeed_pinctrl_data
*pdata
=
370 pinctrl_dev_get_drvdata(pctldev
);
371 const struct aspeed_pin_group
*pgroup
= &pdata
->groups
[group
];
372 const struct aspeed_pin_function
*pfunc
=
373 &pdata
->functions
[function
];
375 for (i
= 0; i
< pgroup
->npins
; i
++) {
376 int pin
= pgroup
->pins
[i
];
377 const struct aspeed_pin_desc
*pdesc
= pdata
->pins
[pin
].drv_data
;
378 const struct aspeed_sig_expr
*expr
= NULL
;
379 const struct aspeed_sig_expr
**funcs
;
380 const struct aspeed_sig_expr
***prios
;
382 pr_debug("Muxing pin %d for %s\n", pin
, pfunc
->name
);
387 prios
= pdesc
->prios
;
392 /* Disable functions at a higher priority than that requested */
393 while ((funcs
= *prios
)) {
394 expr
= aspeed_find_expr_by_name(funcs
, pfunc
->name
);
399 ret
= aspeed_disable_sig(funcs
, pdata
->maps
);
407 char *functions
= get_defined_functions(pdesc
);
408 char *signals
= get_defined_signals(pdesc
);
410 pr_warn("No function %s found on pin %s (%d). Found signal(s) %s for function(s) %s\n",
411 pfunc
->name
, pdesc
->name
, pin
, signals
,
419 ret
= aspeed_sig_expr_enable(expr
, pdata
->maps
);
427 static bool aspeed_expr_is_gpio(const struct aspeed_sig_expr
*expr
)
430 * The signal type is GPIO if the signal name has "GPIO" as a prefix.
431 * strncmp (rather than strcmp) is used to implement the prefix
434 * expr->signal might look like "GPIOT3" in the GPIO case.
436 return strncmp(expr
->signal
, "GPIO", 4) == 0;
439 static bool aspeed_gpio_in_exprs(const struct aspeed_sig_expr
**exprs
)
445 if (aspeed_expr_is_gpio(*exprs
))
453 int aspeed_gpio_request_enable(struct pinctrl_dev
*pctldev
,
454 struct pinctrl_gpio_range
*range
,
458 const struct aspeed_pinctrl_data
*pdata
=
459 pinctrl_dev_get_drvdata(pctldev
);
460 const struct aspeed_pin_desc
*pdesc
= pdata
->pins
[offset
].drv_data
;
461 const struct aspeed_sig_expr
***prios
, **funcs
, *expr
;
466 prios
= pdesc
->prios
;
471 /* Disable any functions of higher priority than GPIO */
472 while ((funcs
= *prios
)) {
473 if (aspeed_gpio_in_exprs(funcs
))
476 ret
= aspeed_disable_sig(funcs
, pdata
->maps
);
484 char *signals
= get_defined_signals(pdesc
);
486 pr_warn("No GPIO signal type found on pin %s (%d). Found: %s\n",
487 pdesc
->name
, offset
, signals
);
496 * Disabling all higher-priority expressions is enough to enable the
497 * lowest-priority signal type. As such it has no associated
504 * If GPIO is not the lowest priority signal type, assume there is only
505 * one expression defined to enable the GPIO function
507 return aspeed_sig_expr_enable(expr
, pdata
->maps
);
510 int aspeed_pinctrl_probe(struct platform_device
*pdev
,
511 struct pinctrl_desc
*pdesc
,
512 struct aspeed_pinctrl_data
*pdata
)
514 struct device
*parent
;
515 struct pinctrl_dev
*pctl
;
517 parent
= pdev
->dev
.parent
;
519 dev_err(&pdev
->dev
, "No parent for syscon pincontroller\n");
523 pdata
->maps
[ASPEED_IP_SCU
] = syscon_node_to_regmap(parent
->of_node
);
524 if (IS_ERR(pdata
->maps
[ASPEED_IP_SCU
])) {
525 dev_err(&pdev
->dev
, "No regmap for syscon pincontroller parent\n");
526 return PTR_ERR(pdata
->maps
[ASPEED_IP_SCU
]);
529 pctl
= pinctrl_register(pdesc
, &pdev
->dev
, pdata
);
532 dev_err(&pdev
->dev
, "Failed to register pinctrl\n");
533 return PTR_ERR(pctl
);
536 platform_set_drvdata(pdev
, pdata
);