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 * Port D and port E GPIO loopback modes are the only exception
203 * as those are commonly used with front-panel buttons to allow
204 * normal operation of the host when the BMC is powered off or
205 * fails to boot. Once the BMC has booted, the loopback mode
206 * must be disabled for the BMC to control host power-on and
209 if (desc
->ip
== ASPEED_IP_SCU
&& desc
->reg
== HW_STRAP1
&&
210 !(desc
->mask
& (BIT(21) | BIT(22))))
213 if (desc
->ip
== ASPEED_IP_SCU
&& desc
->reg
== HW_STRAP2
)
216 ret
= regmap_update_bits(maps
[desc
->ip
], desc
->reg
,
223 ret
= aspeed_sig_expr_eval(expr
, enable
, maps
);
233 static int aspeed_sig_expr_enable(const struct aspeed_sig_expr
*expr
,
234 struct regmap
* const *maps
)
238 ret
= aspeed_sig_expr_eval(expr
, true, maps
);
243 return aspeed_sig_expr_set(expr
, true, maps
);
248 static int aspeed_sig_expr_disable(const struct aspeed_sig_expr
*expr
,
249 struct regmap
* const *maps
)
253 ret
= aspeed_sig_expr_eval(expr
, true, maps
);
258 return aspeed_sig_expr_set(expr
, false, maps
);
264 * Disable a signal on a pin by disabling all provided signal expressions.
266 * @exprs: The list of signal expressions (from a priority level on a pin)
267 * @maps: The list of regmap instances for pinmux register access.
269 * Return: 0 if all expressions are disabled, otherwise a negative error code
271 static int aspeed_disable_sig(const struct aspeed_sig_expr
**exprs
,
272 struct regmap
* const *maps
)
279 while (*exprs
&& !ret
) {
280 ret
= aspeed_sig_expr_disable(*exprs
, maps
);
288 * Search for the signal expression needed to enable the pin's signal for the
289 * requested function.
291 * @exprs: List of signal expressions (haystack)
292 * @name: The name of the requested function (needle)
294 * Return: A pointer to the signal expression whose function tag matches the
295 * provided name, otherwise NULL.
298 static const struct aspeed_sig_expr
*aspeed_find_expr_by_name(
299 const struct aspeed_sig_expr
**exprs
, const char *name
)
302 if (strcmp((*exprs
)->function
, name
) == 0)
310 static char *get_defined_attribute(const struct aspeed_pin_desc
*pdesc
,
312 const struct aspeed_sig_expr
*))
316 const struct aspeed_sig_expr
***prios
, **funcs
, *expr
;
318 prios
= pdesc
->prios
;
320 while ((funcs
= *prios
)) {
321 while ((expr
= *funcs
)) {
322 const char *str
= get(expr
);
323 size_t delta
= strlen(str
) + 2;
326 expanded
= krealloc(found
, len
+ delta
+ 1, GFP_KERNEL
);
349 found
[len
- 2] = '\0';
354 static const char *aspeed_sig_expr_function(const struct aspeed_sig_expr
*expr
)
356 return expr
->function
;
359 static char *get_defined_functions(const struct aspeed_pin_desc
*pdesc
)
361 return get_defined_attribute(pdesc
, aspeed_sig_expr_function
);
364 static const char *aspeed_sig_expr_signal(const struct aspeed_sig_expr
*expr
)
369 static char *get_defined_signals(const struct aspeed_pin_desc
*pdesc
)
371 return get_defined_attribute(pdesc
, aspeed_sig_expr_signal
);
374 int aspeed_pinmux_set_mux(struct pinctrl_dev
*pctldev
, unsigned int function
,
379 const struct aspeed_pinctrl_data
*pdata
=
380 pinctrl_dev_get_drvdata(pctldev
);
381 const struct aspeed_pin_group
*pgroup
= &pdata
->groups
[group
];
382 const struct aspeed_pin_function
*pfunc
=
383 &pdata
->functions
[function
];
385 for (i
= 0; i
< pgroup
->npins
; i
++) {
386 int pin
= pgroup
->pins
[i
];
387 const struct aspeed_pin_desc
*pdesc
= pdata
->pins
[pin
].drv_data
;
388 const struct aspeed_sig_expr
*expr
= NULL
;
389 const struct aspeed_sig_expr
**funcs
;
390 const struct aspeed_sig_expr
***prios
;
392 pr_debug("Muxing pin %d for %s\n", pin
, pfunc
->name
);
397 prios
= pdesc
->prios
;
402 /* Disable functions at a higher priority than that requested */
403 while ((funcs
= *prios
)) {
404 expr
= aspeed_find_expr_by_name(funcs
, pfunc
->name
);
409 ret
= aspeed_disable_sig(funcs
, pdata
->maps
);
417 char *functions
= get_defined_functions(pdesc
);
418 char *signals
= get_defined_signals(pdesc
);
420 pr_warn("No function %s found on pin %s (%d). Found signal(s) %s for function(s) %s\n",
421 pfunc
->name
, pdesc
->name
, pin
, signals
,
429 ret
= aspeed_sig_expr_enable(expr
, pdata
->maps
);
437 static bool aspeed_expr_is_gpio(const struct aspeed_sig_expr
*expr
)
440 * The signal type is GPIO if the signal name has "GPIO" as a prefix.
441 * strncmp (rather than strcmp) is used to implement the prefix
444 * expr->signal might look like "GPIOT3" in the GPIO case.
446 return strncmp(expr
->signal
, "GPIO", 4) == 0;
449 static bool aspeed_gpio_in_exprs(const struct aspeed_sig_expr
**exprs
)
455 if (aspeed_expr_is_gpio(*exprs
))
463 int aspeed_gpio_request_enable(struct pinctrl_dev
*pctldev
,
464 struct pinctrl_gpio_range
*range
,
468 const struct aspeed_pinctrl_data
*pdata
=
469 pinctrl_dev_get_drvdata(pctldev
);
470 const struct aspeed_pin_desc
*pdesc
= pdata
->pins
[offset
].drv_data
;
471 const struct aspeed_sig_expr
***prios
, **funcs
, *expr
;
476 prios
= pdesc
->prios
;
481 /* Disable any functions of higher priority than GPIO */
482 while ((funcs
= *prios
)) {
483 if (aspeed_gpio_in_exprs(funcs
))
486 ret
= aspeed_disable_sig(funcs
, pdata
->maps
);
494 char *signals
= get_defined_signals(pdesc
);
496 pr_warn("No GPIO signal type found on pin %s (%d). Found: %s\n",
497 pdesc
->name
, offset
, signals
);
506 * Disabling all higher-priority expressions is enough to enable the
507 * lowest-priority signal type. As such it has no associated
514 * If GPIO is not the lowest priority signal type, assume there is only
515 * one expression defined to enable the GPIO function
517 return aspeed_sig_expr_enable(expr
, pdata
->maps
);
520 int aspeed_pinctrl_probe(struct platform_device
*pdev
,
521 struct pinctrl_desc
*pdesc
,
522 struct aspeed_pinctrl_data
*pdata
)
524 struct device
*parent
;
525 struct pinctrl_dev
*pctl
;
527 parent
= pdev
->dev
.parent
;
529 dev_err(&pdev
->dev
, "No parent for syscon pincontroller\n");
533 pdata
->maps
[ASPEED_IP_SCU
] = syscon_node_to_regmap(parent
->of_node
);
534 if (IS_ERR(pdata
->maps
[ASPEED_IP_SCU
])) {
535 dev_err(&pdev
->dev
, "No regmap for syscon pincontroller parent\n");
536 return PTR_ERR(pdata
->maps
[ASPEED_IP_SCU
]);
539 pctl
= pinctrl_register(pdesc
, &pdev
->dev
, pdata
);
542 dev_err(&pdev
->dev
, "Failed to register pinctrl\n");
543 return PTR_ERR(pctl
);
546 platform_set_drvdata(pdev
, pdata
);
551 static inline bool pin_in_config_range(unsigned int offset
,
552 const struct aspeed_pin_config
*config
)
554 return offset
>= config
->pins
[0] && offset
<= config
->pins
[1];
557 static inline const struct aspeed_pin_config
*find_pinconf_config(
558 const struct aspeed_pinctrl_data
*pdata
,
560 enum pin_config_param param
)
564 for (i
= 0; i
< pdata
->nconfigs
; i
++) {
565 if (param
== pdata
->configs
[i
].param
&&
566 pin_in_config_range(offset
, &pdata
->configs
[i
]))
567 return &pdata
->configs
[i
];
574 * @param: pinconf configuration parameter
575 * @arg: The supported argument for @param, or -1 if any value is supported
576 * @value: The register value to write to configure @arg for @param
578 * The map is to be used in conjunction with the configuration array supplied
579 * by the driver implementation.
581 struct aspeed_pin_config_map
{
582 enum pin_config_param param
;
587 enum aspeed_pin_config_map_type
{ MAP_TYPE_ARG
, MAP_TYPE_VAL
};
589 /* Aspeed consistently both:
591 * 1. Defines "disable bits" for internal pull-downs
592 * 2. Uses 8mA or 16mA drive strengths
594 static const struct aspeed_pin_config_map pin_config_map
[] = {
595 { PIN_CONFIG_BIAS_PULL_DOWN
, 0, 1 },
596 { PIN_CONFIG_BIAS_PULL_DOWN
, -1, 0 },
597 { PIN_CONFIG_BIAS_DISABLE
, -1, 1 },
598 { PIN_CONFIG_DRIVE_STRENGTH
, 8, 0 },
599 { PIN_CONFIG_DRIVE_STRENGTH
, 16, 1 },
602 static const struct aspeed_pin_config_map
*find_pinconf_map(
603 enum pin_config_param param
,
604 enum aspeed_pin_config_map_type type
,
609 for (i
= 0; i
< ARRAY_SIZE(pin_config_map
); i
++) {
610 const struct aspeed_pin_config_map
*elem
;
613 elem
= &pin_config_map
[i
];
617 match
= (elem
->arg
== -1 || elem
->arg
== value
);
620 match
= (elem
->val
== value
);
624 if (param
== elem
->param
&& match
)
631 int aspeed_pin_config_get(struct pinctrl_dev
*pctldev
, unsigned int offset
,
632 unsigned long *config
)
634 const enum pin_config_param param
= pinconf_to_config_param(*config
);
635 const struct aspeed_pin_config_map
*pmap
;
636 const struct aspeed_pinctrl_data
*pdata
;
637 const struct aspeed_pin_config
*pconf
;
642 pdata
= pinctrl_dev_get_drvdata(pctldev
);
643 pconf
= find_pinconf_config(pdata
, offset
, param
);
647 rc
= regmap_read(pdata
->maps
[ASPEED_IP_SCU
], pconf
->reg
, &val
);
651 pmap
= find_pinconf_map(param
, MAP_TYPE_VAL
,
652 (val
& BIT(pconf
->bit
)) >> pconf
->bit
);
657 if (param
== PIN_CONFIG_DRIVE_STRENGTH
)
658 arg
= (u32
) pmap
->arg
;
659 else if (param
== PIN_CONFIG_BIAS_PULL_DOWN
)
667 *config
= pinconf_to_config_packed(param
, arg
);
672 int aspeed_pin_config_set(struct pinctrl_dev
*pctldev
, unsigned int offset
,
673 unsigned long *configs
, unsigned int num_configs
)
675 const struct aspeed_pinctrl_data
*pdata
;
679 pdata
= pinctrl_dev_get_drvdata(pctldev
);
681 for (i
= 0; i
< num_configs
; i
++) {
682 const struct aspeed_pin_config_map
*pmap
;
683 const struct aspeed_pin_config
*pconf
;
684 enum pin_config_param param
;
688 param
= pinconf_to_config_param(configs
[i
]);
689 arg
= pinconf_to_config_argument(configs
[i
]);
691 pconf
= find_pinconf_config(pdata
, offset
, param
);
695 pmap
= find_pinconf_map(param
, MAP_TYPE_ARG
, arg
);
697 if (unlikely(WARN_ON(!pmap
)))
700 val
= pmap
->val
<< pconf
->bit
;
702 rc
= regmap_update_bits(pdata
->maps
[ASPEED_IP_SCU
], pconf
->reg
,
703 BIT(pconf
->bit
), val
);
708 pr_debug("%s: Set SCU%02X[%d]=%d for param %d(=%d) on pin %d\n",
709 __func__
, pconf
->reg
, pconf
->bit
, pmap
->val
,
716 int aspeed_pin_config_group_get(struct pinctrl_dev
*pctldev
,
717 unsigned int selector
,
718 unsigned long *config
)
720 const unsigned int *pins
;
724 rc
= aspeed_pinctrl_get_group_pins(pctldev
, selector
, &pins
, &npins
);
731 rc
= aspeed_pin_config_get(pctldev
, pins
[0], config
);
736 int aspeed_pin_config_group_set(struct pinctrl_dev
*pctldev
,
737 unsigned int selector
,
738 unsigned long *configs
,
739 unsigned int num_configs
)
741 const unsigned int *pins
;
746 pr_debug("%s: Fetching pins for group selector %d\n",
748 rc
= aspeed_pinctrl_get_group_pins(pctldev
, selector
, &pins
, &npins
);
752 for (i
= 0; i
< npins
; i
++) {
753 rc
= aspeed_pin_config_set(pctldev
, pins
[i
], configs
,