1 // SPDX-License-Identifier: GPL-2.0+
3 * OWL SoC's Pinctrl driver
5 * Copyright (c) 2014 Actions Semi Inc.
6 * Author: David Liu <liuwei@actions-semi.com>
8 * Copyright (c) 2018 Linaro Ltd.
9 * Author: Manivannan Sadhasivam <manivannan.sadhasivam@linaro.org>
12 #include <linux/clk.h>
13 #include <linux/err.h>
14 #include <linux/gpio/driver.h>
16 #include <linux/module.h>
18 #include <linux/platform_device.h>
19 #include <linux/pinctrl/machine.h>
20 #include <linux/pinctrl/pinctrl.h>
21 #include <linux/pinctrl/pinmux.h>
22 #include <linux/pinctrl/pinconf.h>
23 #include <linux/pinctrl/pinconf-generic.h>
24 #include <linux/slab.h>
25 #include <linux/spinlock.h>
28 #include "../pinctrl-utils.h"
29 #include "pinctrl-owl.h"
32 * struct owl_pinctrl - pinctrl state of the device
34 * @pctrldev: pinctrl handle
36 * @lock: spinlock to protect registers
37 * @soc: reference to soc_data
38 * @base: pinctrl register base address
42 struct pinctrl_dev *pctrldev;
43 struct gpio_chip chip;
46 const struct owl_pinctrl_soc_data *soc;
50 static void owl_update_bits(void __iomem *base, u32 mask, u32 val)
54 reg_val = readl_relaxed(base);
56 reg_val = (reg_val & ~mask) | (val & mask);
58 writel_relaxed(reg_val, base);
61 static u32 owl_read_field(struct owl_pinctrl *pctrl, u32 reg,
66 tmp = readl_relaxed(pctrl->base + reg);
67 mask = (1 << width) - 1;
69 return (tmp >> bit) & mask;
72 static void owl_write_field(struct owl_pinctrl *pctrl, u32 reg, u32 arg,
77 mask = (1 << width) - 1;
80 owl_update_bits(pctrl->base + reg, mask, (arg << bit));
83 static int owl_get_groups_count(struct pinctrl_dev *pctrldev)
85 struct owl_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctrldev);
87 return pctrl->soc->ngroups;
90 static const char *owl_get_group_name(struct pinctrl_dev *pctrldev,
93 struct owl_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctrldev);
95 return pctrl->soc->groups[group].name;
98 static int owl_get_group_pins(struct pinctrl_dev *pctrldev,
100 const unsigned int **pins,
101 unsigned int *num_pins)
103 struct owl_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctrldev);
105 *pins = pctrl->soc->groups[group].pads;
106 *num_pins = pctrl->soc->groups[group].npads;
111 static void owl_pin_dbg_show(struct pinctrl_dev *pctrldev,
115 struct owl_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctrldev);
117 seq_printf(s, "%s", dev_name(pctrl->dev));
120 static struct pinctrl_ops owl_pinctrl_ops = {
121 .get_groups_count = owl_get_groups_count,
122 .get_group_name = owl_get_group_name,
123 .get_group_pins = owl_get_group_pins,
124 .pin_dbg_show = owl_pin_dbg_show,
125 .dt_node_to_map = pinconf_generic_dt_node_to_map_all,
126 .dt_free_map = pinctrl_utils_free_map,
129 static int owl_get_funcs_count(struct pinctrl_dev *pctrldev)
131 struct owl_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctrldev);
133 return pctrl->soc->nfunctions;
136 static const char *owl_get_func_name(struct pinctrl_dev *pctrldev,
137 unsigned int function)
139 struct owl_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctrldev);
141 return pctrl->soc->functions[function].name;
144 static int owl_get_func_groups(struct pinctrl_dev *pctrldev,
145 unsigned int function,
146 const char * const **groups,
147 unsigned int * const num_groups)
149 struct owl_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctrldev);
151 *groups = pctrl->soc->functions[function].groups;
152 *num_groups = pctrl->soc->functions[function].ngroups;
157 static inline int get_group_mfp_mask_val(const struct owl_pingroup *g,
166 for (id = 0; id < g->nfuncs; id++) {
167 if (g->funcs[id] == function)
170 if (WARN_ON(id == g->nfuncs))
173 option_num = (1 << g->mfpctl_width);
177 option_mask = option_num - 1;
178 *mask = (option_mask << g->mfpctl_shift);
179 *val = (id << g->mfpctl_shift);
184 static int owl_set_mux(struct pinctrl_dev *pctrldev,
185 unsigned int function,
188 struct owl_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctrldev);
189 const struct owl_pingroup *g;
193 g = &pctrl->soc->groups[group];
195 if (get_group_mfp_mask_val(g, function, &mask, &val))
198 raw_spin_lock_irqsave(&pctrl->lock, flags);
200 owl_update_bits(pctrl->base + g->mfpctl_reg, mask, val);
202 raw_spin_unlock_irqrestore(&pctrl->lock, flags);
207 static struct pinmux_ops owl_pinmux_ops = {
208 .get_functions_count = owl_get_funcs_count,
209 .get_function_name = owl_get_func_name,
210 .get_function_groups = owl_get_func_groups,
211 .set_mux = owl_set_mux,
214 static int owl_pad_pinconf_reg(const struct owl_padinfo *info,
221 case PIN_CONFIG_BIAS_BUS_HOLD:
222 case PIN_CONFIG_BIAS_HIGH_IMPEDANCE:
223 case PIN_CONFIG_BIAS_PULL_DOWN:
224 case PIN_CONFIG_BIAS_PULL_UP:
227 *reg = info->pullctl->reg;
228 *bit = info->pullctl->shift;
229 *width = info->pullctl->width;
231 case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
234 *reg = info->st->reg;
235 *bit = info->st->shift;
236 *width = info->st->width;
245 static int owl_pad_pinconf_arg2val(const struct owl_padinfo *info,
250 case PIN_CONFIG_BIAS_BUS_HOLD:
251 *arg = OWL_PINCONF_PULL_HOLD;
253 case PIN_CONFIG_BIAS_HIGH_IMPEDANCE:
254 *arg = OWL_PINCONF_PULL_HIZ;
256 case PIN_CONFIG_BIAS_PULL_DOWN:
257 *arg = OWL_PINCONF_PULL_DOWN;
259 case PIN_CONFIG_BIAS_PULL_UP:
260 *arg = OWL_PINCONF_PULL_UP;
262 case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
263 *arg = (*arg >= 1 ? 1 : 0);
272 static int owl_pad_pinconf_val2arg(const struct owl_padinfo *padinfo,
277 case PIN_CONFIG_BIAS_BUS_HOLD:
278 *arg = *arg == OWL_PINCONF_PULL_HOLD;
280 case PIN_CONFIG_BIAS_HIGH_IMPEDANCE:
281 *arg = *arg == OWL_PINCONF_PULL_HIZ;
283 case PIN_CONFIG_BIAS_PULL_DOWN:
284 *arg = *arg == OWL_PINCONF_PULL_DOWN;
286 case PIN_CONFIG_BIAS_PULL_UP:
287 *arg = *arg == OWL_PINCONF_PULL_UP;
289 case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
299 static int owl_pin_config_get(struct pinctrl_dev *pctrldev,
301 unsigned long *config)
304 struct owl_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctrldev);
305 const struct owl_padinfo *info;
306 unsigned int param = pinconf_to_config_param(*config);
307 u32 reg, bit, width, arg;
309 info = &pctrl->soc->padinfo[pin];
311 ret = owl_pad_pinconf_reg(info, param, ®, &bit, &width);
315 arg = owl_read_field(pctrl, reg, bit, width);
317 ret = owl_pad_pinconf_val2arg(info, param, &arg);
321 *config = pinconf_to_config_packed(param, arg);
326 static int owl_pin_config_set(struct pinctrl_dev *pctrldev,
328 unsigned long *configs,
329 unsigned int num_configs)
331 struct owl_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctrldev);
332 const struct owl_padinfo *info;
335 u32 reg, bit, width, arg;
338 info = &pctrl->soc->padinfo[pin];
340 for (i = 0; i < num_configs; i++) {
341 param = pinconf_to_config_param(configs[i]);
342 arg = pinconf_to_config_argument(configs[i]);
344 ret = owl_pad_pinconf_reg(info, param, ®, &bit, &width);
348 ret = owl_pad_pinconf_arg2val(info, param, &arg);
352 raw_spin_lock_irqsave(&pctrl->lock, flags);
354 owl_write_field(pctrl, reg, arg, bit, width);
356 raw_spin_unlock_irqrestore(&pctrl->lock, flags);
362 static int owl_group_pinconf_reg(const struct owl_pingroup *g,
369 case PIN_CONFIG_DRIVE_STRENGTH:
374 *width = g->drv_width;
376 case PIN_CONFIG_SLEW_RATE:
381 *width = g->sr_width;
390 static int owl_group_pinconf_arg2val(const struct owl_pingroup *g,
395 case PIN_CONFIG_DRIVE_STRENGTH:
398 *arg = OWL_PINCONF_DRV_2MA;
401 *arg = OWL_PINCONF_DRV_4MA;
404 *arg = OWL_PINCONF_DRV_8MA;
407 *arg = OWL_PINCONF_DRV_12MA;
413 case PIN_CONFIG_SLEW_RATE:
415 *arg = OWL_PINCONF_SLEW_FAST;
417 *arg = OWL_PINCONF_SLEW_SLOW;
426 static int owl_group_pinconf_val2arg(const struct owl_pingroup *g,
431 case PIN_CONFIG_DRIVE_STRENGTH:
433 case OWL_PINCONF_DRV_2MA:
436 case OWL_PINCONF_DRV_4MA:
439 case OWL_PINCONF_DRV_8MA:
442 case OWL_PINCONF_DRV_12MA:
449 case PIN_CONFIG_SLEW_RATE:
462 static int owl_group_config_get(struct pinctrl_dev *pctrldev,
464 unsigned long *config)
466 const struct owl_pingroup *g;
467 struct owl_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctrldev);
468 unsigned int param = pinconf_to_config_param(*config);
469 u32 reg, bit, width, arg;
472 g = &pctrl->soc->groups[group];
474 ret = owl_group_pinconf_reg(g, param, ®, &bit, &width);
478 arg = owl_read_field(pctrl, reg, bit, width);
480 ret = owl_group_pinconf_val2arg(g, param, &arg);
484 *config = pinconf_to_config_packed(param, arg);
490 static int owl_group_config_set(struct pinctrl_dev *pctrldev,
492 unsigned long *configs,
493 unsigned int num_configs)
495 const struct owl_pingroup *g;
496 struct owl_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctrldev);
499 u32 reg, bit, width, arg;
502 g = &pctrl->soc->groups[group];
504 for (i = 0; i < num_configs; i++) {
505 param = pinconf_to_config_param(configs[i]);
506 arg = pinconf_to_config_argument(configs[i]);
508 ret = owl_group_pinconf_reg(g, param, ®, &bit, &width);
512 ret = owl_group_pinconf_arg2val(g, param, &arg);
516 /* Update register */
517 raw_spin_lock_irqsave(&pctrl->lock, flags);
519 owl_write_field(pctrl, reg, arg, bit, width);
521 raw_spin_unlock_irqrestore(&pctrl->lock, flags);
527 static const struct pinconf_ops owl_pinconf_ops = {
529 .pin_config_get = owl_pin_config_get,
530 .pin_config_set = owl_pin_config_set,
531 .pin_config_group_get = owl_group_config_get,
532 .pin_config_group_set = owl_group_config_set,
535 static struct pinctrl_desc owl_pinctrl_desc = {
536 .pctlops = &owl_pinctrl_ops,
537 .pmxops = &owl_pinmux_ops,
538 .confops = &owl_pinconf_ops,
539 .owner = THIS_MODULE,
542 static const struct owl_gpio_port *
543 owl_gpio_get_port(struct owl_pinctrl *pctrl, unsigned int *pin)
545 unsigned int start = 0, i;
547 for (i = 0; i < pctrl->soc->nports; i++) {
548 const struct owl_gpio_port *port = &pctrl->soc->ports[i];
550 if (*pin >= start && *pin < start + port->pins) {
561 static void owl_gpio_update_reg(void __iomem *base, unsigned int pin, int flag)
565 val = readl_relaxed(base);
572 writel_relaxed(val, base);
575 static int owl_gpio_request(struct gpio_chip *chip, unsigned int offset)
577 struct owl_pinctrl *pctrl = gpiochip_get_data(chip);
578 const struct owl_gpio_port *port;
579 void __iomem *gpio_base;
582 port = owl_gpio_get_port(pctrl, &offset);
583 if (WARN_ON(port == NULL))
586 gpio_base = pctrl->base + port->offset;
589 * GPIOs have higher priority over other modules, so either setting
590 * them as OUT or IN is sufficient
592 raw_spin_lock_irqsave(&pctrl->lock, flags);
593 owl_gpio_update_reg(gpio_base + port->outen, offset, true);
594 raw_spin_unlock_irqrestore(&pctrl->lock, flags);
599 static void owl_gpio_free(struct gpio_chip *chip, unsigned int offset)
601 struct owl_pinctrl *pctrl = gpiochip_get_data(chip);
602 const struct owl_gpio_port *port;
603 void __iomem *gpio_base;
606 port = owl_gpio_get_port(pctrl, &offset);
607 if (WARN_ON(port == NULL))
610 gpio_base = pctrl->base + port->offset;
612 raw_spin_lock_irqsave(&pctrl->lock, flags);
613 /* disable gpio output */
614 owl_gpio_update_reg(gpio_base + port->outen, offset, false);
616 /* disable gpio input */
617 owl_gpio_update_reg(gpio_base + port->inen, offset, false);
618 raw_spin_unlock_irqrestore(&pctrl->lock, flags);
621 static int owl_gpio_get(struct gpio_chip *chip, unsigned int offset)
623 struct owl_pinctrl *pctrl = gpiochip_get_data(chip);
624 const struct owl_gpio_port *port;
625 void __iomem *gpio_base;
629 port = owl_gpio_get_port(pctrl, &offset);
630 if (WARN_ON(port == NULL))
633 gpio_base = pctrl->base + port->offset;
635 raw_spin_lock_irqsave(&pctrl->lock, flags);
636 val = readl_relaxed(gpio_base + port->dat);
637 raw_spin_unlock_irqrestore(&pctrl->lock, flags);
639 return !!(val & BIT(offset));
642 static void owl_gpio_set(struct gpio_chip *chip, unsigned int offset, int value)
644 struct owl_pinctrl *pctrl = gpiochip_get_data(chip);
645 const struct owl_gpio_port *port;
646 void __iomem *gpio_base;
649 port = owl_gpio_get_port(pctrl, &offset);
650 if (WARN_ON(port == NULL))
653 gpio_base = pctrl->base + port->offset;
655 raw_spin_lock_irqsave(&pctrl->lock, flags);
656 owl_gpio_update_reg(gpio_base + port->dat, offset, value);
657 raw_spin_unlock_irqrestore(&pctrl->lock, flags);
660 static int owl_gpio_direction_input(struct gpio_chip *chip, unsigned int offset)
662 struct owl_pinctrl *pctrl = gpiochip_get_data(chip);
663 const struct owl_gpio_port *port;
664 void __iomem *gpio_base;
667 port = owl_gpio_get_port(pctrl, &offset);
668 if (WARN_ON(port == NULL))
671 gpio_base = pctrl->base + port->offset;
673 raw_spin_lock_irqsave(&pctrl->lock, flags);
674 owl_gpio_update_reg(gpio_base + port->outen, offset, false);
675 owl_gpio_update_reg(gpio_base + port->inen, offset, true);
676 raw_spin_unlock_irqrestore(&pctrl->lock, flags);
681 static int owl_gpio_direction_output(struct gpio_chip *chip,
682 unsigned int offset, int value)
684 struct owl_pinctrl *pctrl = gpiochip_get_data(chip);
685 const struct owl_gpio_port *port;
686 void __iomem *gpio_base;
689 port = owl_gpio_get_port(pctrl, &offset);
690 if (WARN_ON(port == NULL))
693 gpio_base = pctrl->base + port->offset;
695 raw_spin_lock_irqsave(&pctrl->lock, flags);
696 owl_gpio_update_reg(gpio_base + port->inen, offset, false);
697 owl_gpio_update_reg(gpio_base + port->outen, offset, true);
698 owl_gpio_update_reg(gpio_base + port->dat, offset, value);
699 raw_spin_unlock_irqrestore(&pctrl->lock, flags);
704 static int owl_gpio_init(struct owl_pinctrl *pctrl)
706 struct gpio_chip *chip;
711 chip->ngpio = pctrl->soc->ngpios;
712 chip->label = dev_name(pctrl->dev);
713 chip->parent = pctrl->dev;
714 chip->owner = THIS_MODULE;
715 chip->of_node = pctrl->dev->of_node;
717 ret = gpiochip_add_data(&pctrl->chip, pctrl);
719 dev_err(pctrl->dev, "failed to register gpiochip\n");
726 int owl_pinctrl_probe(struct platform_device *pdev,
727 struct owl_pinctrl_soc_data *soc_data)
729 struct resource *res;
730 struct owl_pinctrl *pctrl;
733 pctrl = devm_kzalloc(&pdev->dev, sizeof(*pctrl), GFP_KERNEL);
737 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
738 pctrl->base = devm_ioremap_resource(&pdev->dev, res);
739 if (IS_ERR(pctrl->base))
740 return PTR_ERR(pctrl->base);
742 /* enable GPIO/MFP clock */
743 pctrl->clk = devm_clk_get(&pdev->dev, NULL);
744 if (IS_ERR(pctrl->clk)) {
745 dev_err(&pdev->dev, "no clock defined\n");
746 return PTR_ERR(pctrl->clk);
749 ret = clk_prepare_enable(pctrl->clk);
751 dev_err(&pdev->dev, "clk enable failed\n");
755 raw_spin_lock_init(&pctrl->lock);
757 owl_pinctrl_desc.name = dev_name(&pdev->dev);
758 owl_pinctrl_desc.pins = soc_data->pins;
759 owl_pinctrl_desc.npins = soc_data->npins;
761 pctrl->chip.direction_input = owl_gpio_direction_input;
762 pctrl->chip.direction_output = owl_gpio_direction_output;
763 pctrl->chip.get = owl_gpio_get;
764 pctrl->chip.set = owl_gpio_set;
765 pctrl->chip.request = owl_gpio_request;
766 pctrl->chip.free = owl_gpio_free;
768 pctrl->soc = soc_data;
769 pctrl->dev = &pdev->dev;
771 pctrl->pctrldev = devm_pinctrl_register(&pdev->dev,
772 &owl_pinctrl_desc, pctrl);
773 if (IS_ERR(pctrl->pctrldev)) {
774 dev_err(&pdev->dev, "could not register Actions OWL pinmux driver\n");
775 return PTR_ERR(pctrl->pctrldev);
778 ret = owl_gpio_init(pctrl);
782 platform_set_drvdata(pdev, pctrl);