2 * SuperH Pin Function Controller pinmux support.
4 * Copyright (C) 2012 Paul Mundt
6 * This file is subject to the terms and conditions of the GNU General Public
7 * License. See the file "COPYING" in the main directory of this archive
10 #define DRV_NAME "pinctrl-sh_pfc"
12 #define pr_fmt(fmt) DRV_NAME " " KBUILD_MODNAME ": " fmt
14 #include <linux/init.h>
15 #include <linux/module.h>
16 #include <linux/sh_pfc.h>
17 #include <linux/err.h>
18 #include <linux/slab.h>
19 #include <linux/spinlock.h>
20 #include <linux/platform_device.h>
21 #include <linux/pinctrl/consumer.h>
22 #include <linux/pinctrl/pinctrl.h>
23 #include <linux/pinctrl/pinconf.h>
24 #include <linux/pinctrl/pinmux.h>
25 #include <linux/pinctrl/pinconf-generic.h>
27 struct sh_pfc_pinctrl {
28 struct pinctrl_dev *pctl;
31 struct pinmux_gpio **functions;
32 unsigned int nr_functions;
34 struct pinctrl_pin_desc *pads;
40 static struct sh_pfc_pinctrl *sh_pfc_pmx;
42 static int sh_pfc_get_groups_count(struct pinctrl_dev *pctldev)
44 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
49 static const char *sh_pfc_get_group_name(struct pinctrl_dev *pctldev,
52 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
54 return pmx->pads[selector].name;
57 static int sh_pfc_get_group_pins(struct pinctrl_dev *pctldev, unsigned group,
58 const unsigned **pins, unsigned *num_pins)
60 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
62 *pins = &pmx->pads[group].number;
68 static void sh_pfc_pin_dbg_show(struct pinctrl_dev *pctldev, struct seq_file *s,
71 seq_printf(s, "%s", DRV_NAME);
74 static struct pinctrl_ops sh_pfc_pinctrl_ops = {
75 .get_groups_count = sh_pfc_get_groups_count,
76 .get_group_name = sh_pfc_get_group_name,
77 .get_group_pins = sh_pfc_get_group_pins,
78 .pin_dbg_show = sh_pfc_pin_dbg_show,
81 static int sh_pfc_get_functions_count(struct pinctrl_dev *pctldev)
83 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
85 return pmx->nr_functions;
88 static const char *sh_pfc_get_function_name(struct pinctrl_dev *pctldev,
91 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
93 return pmx->functions[selector]->name;
96 static int sh_pfc_get_function_groups(struct pinctrl_dev *pctldev, unsigned func,
97 const char * const **groups,
98 unsigned * const num_groups)
100 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
102 *groups = &pmx->functions[func]->name;
108 static int sh_pfc_noop_enable(struct pinctrl_dev *pctldev, unsigned func,
114 static void sh_pfc_noop_disable(struct pinctrl_dev *pctldev, unsigned func,
119 static inline int sh_pfc_config_function(struct sh_pfc *pfc, unsigned offset)
121 if (sh_pfc_config_gpio(pfc, offset,
122 PINMUX_TYPE_FUNCTION,
123 GPIO_CFG_DRYRUN) != 0)
126 if (sh_pfc_config_gpio(pfc, offset,
127 PINMUX_TYPE_FUNCTION,
134 static int sh_pfc_reconfig_pin(struct sh_pfc *pfc, unsigned offset,
141 spin_lock_irqsave(&pfc->lock, flags);
143 pinmux_type = pfc->gpios[offset].flags & PINMUX_FLAG_TYPE;
146 * See if the present config needs to first be de-configured.
148 switch (pinmux_type) {
149 case PINMUX_TYPE_GPIO:
151 case PINMUX_TYPE_OUTPUT:
152 case PINMUX_TYPE_INPUT:
153 case PINMUX_TYPE_INPUT_PULLUP:
154 case PINMUX_TYPE_INPUT_PULLDOWN:
155 sh_pfc_config_gpio(pfc, offset, pinmux_type, GPIO_CFG_FREE);
164 if (sh_pfc_config_gpio(pfc, offset, new_type,
165 GPIO_CFG_DRYRUN) != 0)
171 if (sh_pfc_config_gpio(pfc, offset, new_type,
175 pfc->gpios[offset].flags &= ~PINMUX_FLAG_TYPE;
176 pfc->gpios[offset].flags |= new_type;
181 spin_unlock_irqrestore(&pfc->lock, flags);
187 static int sh_pfc_gpio_request_enable(struct pinctrl_dev *pctldev,
188 struct pinctrl_gpio_range *range,
191 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
192 struct sh_pfc *pfc = pmx->pfc;
194 int ret, pinmux_type;
196 spin_lock_irqsave(&pfc->lock, flags);
198 pinmux_type = pfc->gpios[offset].flags & PINMUX_FLAG_TYPE;
200 switch (pinmux_type) {
201 case PINMUX_TYPE_FUNCTION:
202 pr_notice_once("Use of GPIO API for function requests is "
203 "deprecated, convert to pinctrl\n");
205 ret = sh_pfc_config_function(pfc, offset);
206 if (unlikely(ret < 0))
210 case PINMUX_TYPE_GPIO:
211 case PINMUX_TYPE_INPUT:
212 case PINMUX_TYPE_OUTPUT:
215 pr_err("Unsupported mux type (%d), bailing...\n", pinmux_type);
223 spin_unlock_irqrestore(&pfc->lock, flags);
228 static void sh_pfc_gpio_disable_free(struct pinctrl_dev *pctldev,
229 struct pinctrl_gpio_range *range,
232 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
233 struct sh_pfc *pfc = pmx->pfc;
237 spin_lock_irqsave(&pfc->lock, flags);
239 pinmux_type = pfc->gpios[offset].flags & PINMUX_FLAG_TYPE;
241 sh_pfc_config_gpio(pfc, offset, pinmux_type, GPIO_CFG_FREE);
243 spin_unlock_irqrestore(&pfc->lock, flags);
246 static int sh_pfc_gpio_set_direction(struct pinctrl_dev *pctldev,
247 struct pinctrl_gpio_range *range,
248 unsigned offset, bool input)
250 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
251 int type = input ? PINMUX_TYPE_INPUT : PINMUX_TYPE_OUTPUT;
253 return sh_pfc_reconfig_pin(pmx->pfc, offset, type);
256 static struct pinmux_ops sh_pfc_pinmux_ops = {
257 .get_functions_count = sh_pfc_get_functions_count,
258 .get_function_name = sh_pfc_get_function_name,
259 .get_function_groups = sh_pfc_get_function_groups,
260 .enable = sh_pfc_noop_enable,
261 .disable = sh_pfc_noop_disable,
262 .gpio_request_enable = sh_pfc_gpio_request_enable,
263 .gpio_disable_free = sh_pfc_gpio_disable_free,
264 .gpio_set_direction = sh_pfc_gpio_set_direction,
267 static int sh_pfc_pinconf_get(struct pinctrl_dev *pctldev, unsigned pin,
268 unsigned long *config)
270 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
271 struct sh_pfc *pfc = pmx->pfc;
273 *config = pfc->gpios[pin].flags & PINMUX_FLAG_TYPE;
278 static int sh_pfc_pinconf_set(struct pinctrl_dev *pctldev, unsigned pin,
279 unsigned long config)
281 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
283 /* Validate the new type */
284 if (config >= PINMUX_FLAG_TYPE)
287 return sh_pfc_reconfig_pin(pmx->pfc, pin, config);
290 static void sh_pfc_pinconf_dbg_show(struct pinctrl_dev *pctldev,
291 struct seq_file *s, unsigned pin)
293 const char *pinmux_type_str[] = {
294 [PINMUX_TYPE_NONE] = "none",
295 [PINMUX_TYPE_FUNCTION] = "function",
296 [PINMUX_TYPE_GPIO] = "gpio",
297 [PINMUX_TYPE_OUTPUT] = "output",
298 [PINMUX_TYPE_INPUT] = "input",
299 [PINMUX_TYPE_INPUT_PULLUP] = "input bias pull up",
300 [PINMUX_TYPE_INPUT_PULLDOWN] = "input bias pull down",
302 unsigned long config;
305 rc = sh_pfc_pinconf_get(pctldev, pin, &config);
306 if (unlikely(rc != 0))
309 seq_printf(s, " %s", pinmux_type_str[config]);
312 static struct pinconf_ops sh_pfc_pinconf_ops = {
313 .pin_config_get = sh_pfc_pinconf_get,
314 .pin_config_set = sh_pfc_pinconf_set,
315 .pin_config_dbg_show = sh_pfc_pinconf_dbg_show,
318 static struct pinctrl_gpio_range sh_pfc_gpio_range = {
323 static struct pinctrl_desc sh_pfc_pinctrl_desc = {
325 .owner = THIS_MODULE,
326 .pctlops = &sh_pfc_pinctrl_ops,
327 .pmxops = &sh_pfc_pinmux_ops,
328 .confops = &sh_pfc_pinconf_ops,
331 static inline void __devinit sh_pfc_map_one_gpio(struct sh_pfc *pfc,
332 struct sh_pfc_pinctrl *pmx,
333 struct pinmux_gpio *gpio,
336 struct pinmux_data_reg *dummy;
340 gpio->flags &= ~PINMUX_FLAG_TYPE;
342 if (sh_pfc_get_data_reg(pfc, offset, &dummy, &bit) == 0)
343 gpio->flags |= PINMUX_TYPE_GPIO;
345 gpio->flags |= PINMUX_TYPE_FUNCTION;
347 spin_lock_irqsave(&pmx->lock, flags);
349 spin_unlock_irqrestore(&pmx->lock, flags);
353 /* pinmux ranges -> pinctrl pin descs */
354 static int __devinit sh_pfc_map_gpios(struct sh_pfc *pfc,
355 struct sh_pfc_pinctrl *pmx)
360 pmx->nr_pads = pfc->last_gpio - pfc->first_gpio + 1;
362 pmx->pads = kmalloc(sizeof(struct pinctrl_pin_desc) * pmx->nr_pads,
364 if (unlikely(!pmx->pads)) {
369 spin_lock_irqsave(&pfc->lock, flags);
372 * We don't necessarily have a 1:1 mapping between pin and linux
373 * GPIO number, as the latter maps to the associated enum_id.
374 * Care needs to be taken to translate back to pin space when
375 * dealing with any pin configurations.
377 for (i = 0; i < pmx->nr_pads; i++) {
378 struct pinctrl_pin_desc *pin = pmx->pads + i;
379 struct pinmux_gpio *gpio = pfc->gpios + i;
381 pin->number = pfc->first_gpio + i;
382 pin->name = gpio->name;
385 if (unlikely(!gpio->enum_id))
388 sh_pfc_map_one_gpio(pfc, pmx, gpio, i);
391 spin_unlock_irqrestore(&pfc->lock, flags);
393 sh_pfc_pinctrl_desc.pins = pmx->pads;
394 sh_pfc_pinctrl_desc.npins = pmx->nr_pads;
399 static int __devinit sh_pfc_map_functions(struct sh_pfc *pfc,
400 struct sh_pfc_pinctrl *pmx)
405 pmx->functions = kzalloc(pmx->nr_functions * sizeof(void *),
407 if (unlikely(!pmx->functions))
410 spin_lock_irqsave(&pmx->lock, flags);
412 for (i = fn = 0; i < pmx->nr_pads; i++) {
413 struct pinmux_gpio *gpio = pfc->gpios + i;
415 if ((gpio->flags & PINMUX_FLAG_TYPE) == PINMUX_TYPE_FUNCTION)
416 pmx->functions[fn++] = gpio;
419 spin_unlock_irqrestore(&pmx->lock, flags);
424 static int __devinit sh_pfc_pinctrl_probe(struct platform_device *pdev)
429 if (unlikely(!sh_pfc_pmx))
432 pfc = sh_pfc_pmx->pfc;
434 ret = sh_pfc_map_gpios(pfc, sh_pfc_pmx);
435 if (unlikely(ret != 0))
438 ret = sh_pfc_map_functions(pfc, sh_pfc_pmx);
439 if (unlikely(ret != 0))
442 sh_pfc_pmx->pctl = pinctrl_register(&sh_pfc_pinctrl_desc, &pdev->dev,
444 if (IS_ERR(sh_pfc_pmx->pctl)) {
445 ret = PTR_ERR(sh_pfc_pmx->pctl);
449 sh_pfc_gpio_range.npins = pfc->last_gpio - pfc->first_gpio + 1;
450 sh_pfc_gpio_range.base = pfc->first_gpio;
451 sh_pfc_gpio_range.pin_base = pfc->first_gpio;
453 pinctrl_add_gpio_range(sh_pfc_pmx->pctl, &sh_pfc_gpio_range);
455 platform_set_drvdata(pdev, sh_pfc_pmx);
460 kfree(sh_pfc_pmx->functions);
462 kfree(sh_pfc_pmx->pads);
468 static int __devexit sh_pfc_pinctrl_remove(struct platform_device *pdev)
470 struct sh_pfc_pinctrl *pmx = platform_get_drvdata(pdev);
472 pinctrl_unregister(pmx->pctl);
474 platform_set_drvdata(pdev, NULL);
476 kfree(sh_pfc_pmx->functions);
477 kfree(sh_pfc_pmx->pads);
483 static struct platform_driver sh_pfc_pinctrl_driver = {
484 .probe = sh_pfc_pinctrl_probe,
485 .remove = __devexit_p(sh_pfc_pinctrl_remove),
488 .owner = THIS_MODULE,
492 static struct platform_device sh_pfc_pinctrl_device = {
497 static int sh_pfc_pinctrl_init(void)
501 rc = platform_driver_register(&sh_pfc_pinctrl_driver);
503 rc = platform_device_register(&sh_pfc_pinctrl_device);
505 platform_driver_unregister(&sh_pfc_pinctrl_driver);
511 int sh_pfc_register_pinctrl(struct sh_pfc *pfc)
513 sh_pfc_pmx = kzalloc(sizeof(struct sh_pfc_pinctrl), GFP_KERNEL);
514 if (unlikely(!sh_pfc_pmx))
517 spin_lock_init(&sh_pfc_pmx->lock);
519 sh_pfc_pmx->pfc = pfc;
521 return sh_pfc_pinctrl_init();
523 EXPORT_SYMBOL_GPL(sh_pfc_register_pinctrl);
525 static void __exit sh_pfc_pinctrl_exit(void)
527 platform_driver_unregister(&sh_pfc_pinctrl_driver);
529 module_exit(sh_pfc_pinctrl_exit);