pinctrl-max7360.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * Copyright 2025 Bootlin
  4 *
  5 * Author: Mathieu Dubois-Briand <mathieu.dubois-briand@bootlin.com>
  6 */
  7
  8#include <linux/array_size.h>
  9#include <linux/dev_printk.h>
 10#include <linux/device.h>
 11#include <linux/device/devres.h>
 12#include <linux/err.h>
 13#include <linux/init.h>
 14#include <linux/mfd/max7360.h>
 15#include <linux/module.h>
 16#include <linux/platform_device.h>
 17#include <linux/regmap.h>
 18#include <linux/stddef.h>
 19
 20#include <linux/pinctrl/pinctrl.h>
 21#include <linux/pinctrl/pinconf-generic.h>
 22#include <linux/pinctrl/pinmux.h>
 23
 24#include "core.h"
 25#include "pinmux.h"
 26
 27struct max7360_pinctrl {
 28	struct pinctrl_dev *pctldev;
 29	struct pinctrl_desc pinctrl_desc;
 30};
 31
 32static const struct pinctrl_pin_desc max7360_pins[] = {
 33	PINCTRL_PIN(0, "PORT0"),
 34	PINCTRL_PIN(1, "PORT1"),
 35	PINCTRL_PIN(2, "PORT2"),
 36	PINCTRL_PIN(3, "PORT3"),
 37	PINCTRL_PIN(4, "PORT4"),
 38	PINCTRL_PIN(5, "PORT5"),
 39	PINCTRL_PIN(6, "PORT6"),
 40	PINCTRL_PIN(7, "PORT7"),
 41};
 42
 43static const unsigned int port0_pins[] = {0};
 44static const unsigned int port1_pins[] = {1};
 45static const unsigned int port2_pins[] = {2};
 46static const unsigned int port3_pins[] = {3};
 47static const unsigned int port4_pins[] = {4};
 48static const unsigned int port5_pins[] = {5};
 49static const unsigned int port6_pins[] = {6};
 50static const unsigned int port7_pins[] = {7};
 51static const unsigned int rotary_pins[] = {6, 7};
 52
 53static const struct pingroup max7360_groups[] = {
 54	PINCTRL_PINGROUP("PORT0", port0_pins, ARRAY_SIZE(port0_pins)),
 55	PINCTRL_PINGROUP("PORT1", port1_pins, ARRAY_SIZE(port1_pins)),
 56	PINCTRL_PINGROUP("PORT2", port2_pins, ARRAY_SIZE(port2_pins)),
 57	PINCTRL_PINGROUP("PORT3", port3_pins, ARRAY_SIZE(port3_pins)),
 58	PINCTRL_PINGROUP("PORT4", port4_pins, ARRAY_SIZE(port4_pins)),
 59	PINCTRL_PINGROUP("PORT5", port5_pins, ARRAY_SIZE(port5_pins)),
 60	PINCTRL_PINGROUP("PORT6", port6_pins, ARRAY_SIZE(port6_pins)),
 61	PINCTRL_PINGROUP("PORT7", port7_pins, ARRAY_SIZE(port7_pins)),
 62	PINCTRL_PINGROUP("ROTARY", rotary_pins, ARRAY_SIZE(rotary_pins)),
 63};
 64
 65static int max7360_pinctrl_get_groups_count(struct pinctrl_dev *pctldev)
 66{
 67	return ARRAY_SIZE(max7360_groups);
 68}
 69
 70static const char *max7360_pinctrl_get_group_name(struct pinctrl_dev *pctldev,
 71						  unsigned int group)
 72{
 73	return max7360_groups[group].name;
 74}
 75
 76static int max7360_pinctrl_get_group_pins(struct pinctrl_dev *pctldev,
 77					  unsigned int group,
 78					  const unsigned int **pins,
 79					  unsigned int *num_pins)
 80{
 81	*pins = max7360_groups[group].pins;
 82	*num_pins = max7360_groups[group].npins;
 83	return 0;
 84}
 85
 86static const struct pinctrl_ops max7360_pinctrl_ops = {
 87	.get_groups_count = max7360_pinctrl_get_groups_count,
 88	.get_group_name = max7360_pinctrl_get_group_name,
 89	.get_group_pins = max7360_pinctrl_get_group_pins,
 90#ifdef CONFIG_OF
 91	.dt_node_to_map = pinconf_generic_dt_node_to_map_pin,
 92	.dt_free_map = pinconf_generic_dt_free_map,
 93#endif
 94};
 95
 96static const char * const simple_groups[] = {
 97	"PORT0", "PORT1", "PORT2", "PORT3",
 98	"PORT4", "PORT5", "PORT6", "PORT7",
 99};
100
101static const char * const rotary_groups[] = { "ROTARY" };
102
103#define MAX7360_PINCTRL_FN_GPIO		0
104#define MAX7360_PINCTRL_FN_PWM		1
105#define MAX7360_PINCTRL_FN_ROTARY	2
106static const struct pinfunction max7360_functions[] = {
107	[MAX7360_PINCTRL_FN_GPIO] = PINCTRL_PINFUNCTION("gpio", simple_groups,
108							ARRAY_SIZE(simple_groups)),
109	[MAX7360_PINCTRL_FN_PWM] = PINCTRL_PINFUNCTION("pwm", simple_groups,
110						       ARRAY_SIZE(simple_groups)),
111	[MAX7360_PINCTRL_FN_ROTARY] = PINCTRL_PINFUNCTION("rotary", rotary_groups,
112							  ARRAY_SIZE(rotary_groups)),
113};
114
115static int max7360_get_functions_count(struct pinctrl_dev *pctldev)
116{
117	return ARRAY_SIZE(max7360_functions);
118}
119
120static const char *max7360_get_function_name(struct pinctrl_dev *pctldev, unsigned int selector)
121{
122	return max7360_functions[selector].name;
123}
124
125static int max7360_get_function_groups(struct pinctrl_dev *pctldev, unsigned int selector,
126				       const char * const **groups,
127				       unsigned int * const num_groups)
128{
129	*groups = max7360_functions[selector].groups;
130	*num_groups = max7360_functions[selector].ngroups;
131
132	return 0;
133}
134
135static int max7360_set_mux(struct pinctrl_dev *pctldev, unsigned int selector,
136			   unsigned int group)
137{
138	struct regmap *regmap = dev_get_regmap(pctldev->dev->parent, NULL);
139	int val;
140
141	/*
142	 * GPIO and PWM functions are the same: we only need to handle the
143	 * rotary encoder function, on pins 6 and 7.
144	 */
145	if (max7360_groups[group].pins[0] >= 6) {
146		if (selector == MAX7360_PINCTRL_FN_ROTARY)
147			val = MAX7360_GPIO_CFG_RTR_EN;
148		else
149			val = 0;
150
151		return regmap_write_bits(regmap, MAX7360_REG_GPIOCFG, MAX7360_GPIO_CFG_RTR_EN, val);
152	}
153
154	return 0;
155}
156
157static const struct pinmux_ops max7360_pmxops = {
158	.get_functions_count = max7360_get_functions_count,
159	.get_function_name = max7360_get_function_name,
160	.get_function_groups = max7360_get_function_groups,
161	.set_mux = max7360_set_mux,
162	.strict = true,
163};
164
165static int max7360_pinctrl_probe(struct platform_device *pdev)
166{
167	struct regmap *regmap;
168	struct pinctrl_desc *pd;
169	struct max7360_pinctrl *chip;
170	struct device *dev = &pdev->dev;
171
172	regmap = dev_get_regmap(dev->parent, NULL);
173	if (!regmap)
174		return dev_err_probe(dev, -ENODEV, "Could not get parent regmap\n");
175
176	chip = devm_kzalloc(dev, sizeof(*chip), GFP_KERNEL);
177	if (!chip)
178		return -ENOMEM;
179
180	pd = &chip->pinctrl_desc;
181
182	pd->pctlops = &max7360_pinctrl_ops;
183	pd->pmxops = &max7360_pmxops;
184	pd->name = dev_name(dev);
185	pd->pins = max7360_pins;
186	pd->npins = MAX7360_MAX_GPIO;
187	pd->owner = THIS_MODULE;
188
189	/*
190	 * This MFD sub-device does not have any associated device tree node:
191	 * properties are stored in the device node of the parent (MFD) device
192	 * and this same node is used in phandles of client devices.
193	 * Reuse this device tree node here, as otherwise the pinctrl subsystem
194	 * would be confused by this topology.
195	 */
196	device_set_of_node_from_dev(dev, dev->parent);
197
198	chip->pctldev = devm_pinctrl_register(dev, pd, chip);
199	if (IS_ERR(chip->pctldev))
200		return dev_err_probe(dev, PTR_ERR(chip->pctldev), "can't register controller\n");
201
202	return 0;
203}
204
205static struct platform_driver max7360_pinctrl_driver = {
206	.driver = {
207		.name	= "max7360-pinctrl",
208	},
209	.probe		= max7360_pinctrl_probe,
210};
211module_platform_driver(max7360_pinctrl_driver);
212
213MODULE_DESCRIPTION("MAX7360 pinctrl driver");
214MODULE_AUTHOR("Mathieu Dubois-Briand <mathieu.dubois-briand@bootlin.com>");
215MODULE_LICENSE("GPL");