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 pr_fmt(fmt) "sh_pfc " KBUILD_MODNAME ": " fmt
12 #include <linux/init.h>
13 #include <linux/module.h>
14 #include <linux/sh_pfc.h>
15 #include <linux/err.h>
16 #include <linux/slab.h>
17 #include <linux/spinlock.h>
18 #include <linux/platform_device.h>
19 #include <linux/pinctrl/consumer.h>
20 #include <linux/pinctrl/pinctrl.h>
21 #include <linux/pinctrl/pinconf.h>
22 #include <linux/pinctrl/pinmux.h>
23 #include <linux/pinctrl/pinconf-generic.h>
25 struct sh_pfc_pinctrl {
26 struct pinctrl_dev *pctl;
29 struct pinmux_gpio **functions;
30 unsigned int nr_functions;
32 struct pinctrl_pin_desc *pads;
38 static struct sh_pfc_pinctrl *sh_pfc_pmx;
41 * No group support yet
43 static int sh_pfc_get_noop_count(struct pinctrl_dev *pctldev)
48 static const char *sh_pfc_get_noop_name(struct pinctrl_dev *pctldev,
54 static int sh_pfc_get_group_pins(struct pinctrl_dev *pctldev, unsigned group,
55 const unsigned **pins, unsigned *num_pins)
60 static struct pinctrl_ops sh_pfc_pinctrl_ops = {
61 .get_groups_count = sh_pfc_get_noop_count,
62 .get_group_name = sh_pfc_get_noop_name,
63 .get_group_pins = sh_pfc_get_group_pins,
66 static int sh_pfc_get_functions_count(struct pinctrl_dev *pctldev)
68 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
70 return pmx->nr_functions;
73 static const char *sh_pfc_get_function_name(struct pinctrl_dev *pctldev,
76 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
78 return pmx->functions[selector]->name;
81 static int sh_pfc_get_function_groups(struct pinctrl_dev *pctldev, unsigned func,
82 const char * const **groups,
83 unsigned * const num_groups)
85 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
87 *groups = &pmx->functions[func]->name;
93 static int sh_pfc_noop_enable(struct pinctrl_dev *pctldev, unsigned func,
99 static void sh_pfc_noop_disable(struct pinctrl_dev *pctldev, unsigned func,
104 static inline int sh_pfc_config_function(struct sh_pfc *pfc, unsigned offset)
106 if (sh_pfc_config_gpio(pfc, offset,
107 PINMUX_TYPE_FUNCTION,
108 GPIO_CFG_DRYRUN) != 0)
111 if (sh_pfc_config_gpio(pfc, offset,
112 PINMUX_TYPE_FUNCTION,
119 static int sh_pfc_gpio_request_enable(struct pinctrl_dev *pctldev,
120 struct pinctrl_gpio_range *range,
123 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
124 struct sh_pfc *pfc = pmx->pfc;
126 int ret, pinmux_type;
128 spin_lock_irqsave(&pfc->lock, flags);
130 pinmux_type = pfc->gpios[offset].flags & PINMUX_FLAG_TYPE;
132 switch (pinmux_type) {
133 case PINMUX_TYPE_FUNCTION:
134 pr_notice_once("Use of GPIO API for function requests is "
135 "deprecated, convert to pinctrl\n");
137 ret = sh_pfc_config_function(pfc, offset);
138 if (unlikely(ret < 0))
142 case PINMUX_TYPE_GPIO:
145 pr_err("Unsupported mux type (%d), bailing...\n", pinmux_type);
152 spin_unlock_irqrestore(&pfc->lock, flags);
157 static void sh_pfc_gpio_disable_free(struct pinctrl_dev *pctldev,
158 struct pinctrl_gpio_range *range,
161 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
162 struct sh_pfc *pfc = pmx->pfc;
166 spin_lock_irqsave(&pfc->lock, flags);
168 pinmux_type = pfc->gpios[offset].flags & PINMUX_FLAG_TYPE;
170 sh_pfc_config_gpio(pfc, offset, pinmux_type, GPIO_CFG_FREE);
172 spin_unlock_irqrestore(&pfc->lock, flags);
175 static int sh_pfc_gpio_set_direction(struct pinctrl_dev *pctldev,
176 struct pinctrl_gpio_range *range,
177 unsigned offset, bool input)
179 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
180 struct sh_pfc *pfc = pmx->pfc;
182 int pinmux_type, new_pinmux_type;
185 new_pinmux_type = input ? PINMUX_TYPE_INPUT : PINMUX_TYPE_OUTPUT;
187 spin_lock_irqsave(&pfc->lock, flags);
189 pinmux_type = pfc->gpios[offset].flags & PINMUX_FLAG_TYPE;
191 switch (pinmux_type) {
192 case PINMUX_TYPE_GPIO:
194 case PINMUX_TYPE_OUTPUT:
195 case PINMUX_TYPE_INPUT:
196 case PINMUX_TYPE_INPUT_PULLUP:
197 case PINMUX_TYPE_INPUT_PULLDOWN:
198 sh_pfc_config_gpio(pfc, offset, pinmux_type, GPIO_CFG_FREE);
204 if (sh_pfc_config_gpio(pfc, offset,
206 GPIO_CFG_DRYRUN) != 0)
209 if (sh_pfc_config_gpio(pfc, offset,
214 pfc->gpios[offset].flags &= ~PINMUX_FLAG_TYPE;
215 pfc->gpios[offset].flags |= new_pinmux_type;
220 spin_unlock_irqrestore(&pfc->lock, flags);
225 static struct pinmux_ops sh_pfc_pinmux_ops = {
226 .get_functions_count = sh_pfc_get_functions_count,
227 .get_function_name = sh_pfc_get_function_name,
228 .get_function_groups = sh_pfc_get_function_groups,
229 .enable = sh_pfc_noop_enable,
230 .disable = sh_pfc_noop_disable,
231 .gpio_request_enable = sh_pfc_gpio_request_enable,
232 .gpio_disable_free = sh_pfc_gpio_disable_free,
233 .gpio_set_direction = sh_pfc_gpio_set_direction,
236 static int sh_pfc_pinconf_get(struct pinctrl_dev *pctldev, unsigned pin,
237 unsigned long *config)
239 enum pin_config_param param = (enum pin_config_param)(*config);
249 static int sh_pfc_pinconf_set(struct pinctrl_dev *pctldev, unsigned pin,
250 unsigned long config)
255 static struct pinconf_ops sh_pfc_pinconf_ops = {
257 .pin_config_get = sh_pfc_pinconf_get,
258 .pin_config_set = sh_pfc_pinconf_set,
261 static struct pinctrl_gpio_range sh_pfc_gpio_range = {
262 .name = KBUILD_MODNAME,
266 static struct pinctrl_desc sh_pfc_pinctrl_desc = {
267 .name = KBUILD_MODNAME,
268 .owner = THIS_MODULE,
269 .pctlops = &sh_pfc_pinctrl_ops,
270 .pmxops = &sh_pfc_pinmux_ops,
271 .confops = &sh_pfc_pinconf_ops,
274 int sh_pfc_register_pinctrl(struct sh_pfc *pfc)
276 sh_pfc_pmx = kzalloc(sizeof(struct sh_pfc_pinctrl), GFP_KERNEL);
277 if (unlikely(!sh_pfc_pmx))
280 spin_lock_init(&sh_pfc_pmx->lock);
282 sh_pfc_pmx->pfc = pfc;
287 static inline void __devinit sh_pfc_map_one_gpio(struct sh_pfc *pfc,
288 struct sh_pfc_pinctrl *pmx,
289 struct pinmux_gpio *gpio,
292 struct pinmux_data_reg *dummy;
296 gpio->flags &= ~PINMUX_FLAG_TYPE;
298 if (sh_pfc_get_data_reg(pfc, offset, &dummy, &bit) == 0)
299 gpio->flags |= PINMUX_TYPE_GPIO;
301 gpio->flags |= PINMUX_TYPE_FUNCTION;
303 spin_lock_irqsave(&pmx->lock, flags);
305 spin_unlock_irqrestore(&pmx->lock, flags);
309 /* pinmux ranges -> pinctrl pin descs */
310 static int __devinit sh_pfc_map_gpios(struct sh_pfc *pfc,
311 struct sh_pfc_pinctrl *pmx)
316 pmx->nr_pads = pfc->last_gpio - pfc->first_gpio + 1;
318 pmx->pads = kmalloc(sizeof(struct pinctrl_pin_desc) * pmx->nr_pads,
320 if (unlikely(!pmx->pads)) {
325 spin_lock_irqsave(&pfc->lock, flags);
328 * We don't necessarily have a 1:1 mapping between pin and linux
329 * GPIO number, as the latter maps to the associated enum_id.
330 * Care needs to be taken to translate back to pin space when
331 * dealing with any pin configurations.
333 for (i = 0; i < pmx->nr_pads; i++) {
334 struct pinctrl_pin_desc *pin = pmx->pads + i;
335 struct pinmux_gpio *gpio = pfc->gpios + i;
337 pin->number = pfc->first_gpio + i;
338 pin->name = gpio->name;
340 sh_pfc_map_one_gpio(pfc, pmx, gpio, i);
343 spin_unlock_irqrestore(&pfc->lock, flags);
345 sh_pfc_pinctrl_desc.pins = pmx->pads;
346 sh_pfc_pinctrl_desc.npins = pmx->nr_pads;
351 static int __devinit sh_pfc_map_functions(struct sh_pfc *pfc,
352 struct sh_pfc_pinctrl *pmx)
357 pmx->functions = kzalloc(pmx->nr_functions * sizeof(void *),
359 if (unlikely(!pmx->functions))
362 spin_lock_irqsave(&pmx->lock, flags);
364 for (i = fn = 0; i < pmx->nr_pads; i++) {
365 struct pinmux_gpio *gpio = pfc->gpios + i;
367 if ((gpio->flags & PINMUX_FLAG_TYPE) == PINMUX_TYPE_FUNCTION)
368 pmx->functions[fn++] = gpio;
371 spin_unlock_irqrestore(&pmx->lock, flags);
376 static int __devinit sh_pfc_pinctrl_probe(struct platform_device *pdev)
381 if (unlikely(!sh_pfc_pmx))
384 pfc = sh_pfc_pmx->pfc;
386 ret = sh_pfc_map_gpios(pfc, sh_pfc_pmx);
387 if (unlikely(ret != 0))
390 ret = sh_pfc_map_functions(pfc, sh_pfc_pmx);
391 if (unlikely(ret != 0))
394 sh_pfc_pmx->pctl = pinctrl_register(&sh_pfc_pinctrl_desc, &pdev->dev,
396 if (IS_ERR(sh_pfc_pmx->pctl)) {
397 ret = PTR_ERR(sh_pfc_pmx->pctl);
401 sh_pfc_gpio_range.npins = pfc->last_gpio - pfc->first_gpio + 1;
402 sh_pfc_gpio_range.base = pfc->first_gpio;
403 sh_pfc_gpio_range.pin_base = pfc->first_gpio;
405 pinctrl_add_gpio_range(sh_pfc_pmx->pctl, &sh_pfc_gpio_range);
407 platform_set_drvdata(pdev, sh_pfc_pmx);
412 kfree(sh_pfc_pmx->functions);
414 kfree(sh_pfc_pmx->pads);
420 static int __devexit sh_pfc_pinctrl_remove(struct platform_device *pdev)
422 struct sh_pfc_pinctrl *pmx = platform_get_drvdata(pdev);
424 pinctrl_remove_gpio_range(pmx->pctl, &sh_pfc_gpio_range);
425 pinctrl_unregister(pmx->pctl);
427 platform_set_drvdata(pdev, NULL);
429 kfree(sh_pfc_pmx->functions);
430 kfree(sh_pfc_pmx->pads);
436 static struct platform_driver sh_pfc_pinctrl_driver = {
437 .probe = sh_pfc_pinctrl_probe,
438 .remove = __devexit_p(sh_pfc_pinctrl_remove),
440 .name = KBUILD_MODNAME,
441 .owner = THIS_MODULE,
445 static struct platform_device sh_pfc_pinctrl_device = {
446 .name = KBUILD_MODNAME,
450 static int __init sh_pfc_pinctrl_init(void)
454 rc = platform_driver_register(&sh_pfc_pinctrl_driver);
456 rc = platform_device_register(&sh_pfc_pinctrl_device);
458 platform_driver_unregister(&sh_pfc_pinctrl_driver);
464 static void __exit sh_pfc_pinctrl_exit(void)
466 platform_driver_unregister(&sh_pfc_pinctrl_driver);
469 subsys_initcall(sh_pfc_pinctrl_init);
470 module_exit(sh_pfc_pinctrl_exit);