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/irq.h>
17 #include <linux/module.h>
19 #include <linux/platform_device.h>
20 #include <linux/pinctrl/machine.h>
21 #include <linux/pinctrl/pinctrl.h>
22 #include <linux/pinctrl/pinmux.h>
23 #include <linux/pinctrl/pinconf.h>
24 #include <linux/pinctrl/pinconf-generic.h>
25 #include <linux/slab.h>
26 #include <linux/spinlock.h>
29 #include "../pinctrl-utils.h"
30 #include "pinctrl-owl.h"
33 * struct owl_pinctrl - pinctrl state of the device
35 * @pctrldev: pinctrl handle
37 * @lock: spinlock to protect registers
39 * @soc: reference to soc_data
40 * @base: pinctrl register base address
41 * @irq_chip: IRQ chip information
42 * @num_irq: number of possible interrupts
43 * @irq: interrupt numbers
47 struct pinctrl_dev *pctrldev;
48 struct gpio_chip chip;
51 const struct owl_pinctrl_soc_data *soc;
53 struct irq_chip irq_chip;
58 static void owl_update_bits(void __iomem *base, u32 mask, u32 val)
62 reg_val = readl_relaxed(base);
64 reg_val = (reg_val & ~mask) | (val & mask);
66 writel_relaxed(reg_val, base);
69 static u32 owl_read_field(struct owl_pinctrl *pctrl, u32 reg,
74 tmp = readl_relaxed(pctrl->base + reg);
75 mask = (1 << width) - 1;
77 return (tmp >> bit) & mask;
80 static void owl_write_field(struct owl_pinctrl *pctrl, u32 reg, u32 arg,
85 mask = (1 << width) - 1;
88 owl_update_bits(pctrl->base + reg, mask, (arg << bit));
91 static int owl_get_groups_count(struct pinctrl_dev *pctrldev)
93 struct owl_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctrldev);
95 return pctrl->soc->ngroups;
98 static const char *owl_get_group_name(struct pinctrl_dev *pctrldev,
101 struct owl_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctrldev);
103 return pctrl->soc->groups[group].name;
106 static int owl_get_group_pins(struct pinctrl_dev *pctrldev,
108 const unsigned int **pins,
109 unsigned int *num_pins)
111 struct owl_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctrldev);
113 *pins = pctrl->soc->groups[group].pads;
114 *num_pins = pctrl->soc->groups[group].npads;
119 static void owl_pin_dbg_show(struct pinctrl_dev *pctrldev,
123 struct owl_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctrldev);
125 seq_printf(s, "%s", dev_name(pctrl->dev));
128 static const struct pinctrl_ops owl_pinctrl_ops = {
129 .get_groups_count = owl_get_groups_count,
130 .get_group_name = owl_get_group_name,
131 .get_group_pins = owl_get_group_pins,
132 .pin_dbg_show = owl_pin_dbg_show,
133 .dt_node_to_map = pinconf_generic_dt_node_to_map_all,
134 .dt_free_map = pinctrl_utils_free_map,
137 static int owl_get_funcs_count(struct pinctrl_dev *pctrldev)
139 struct owl_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctrldev);
141 return pctrl->soc->nfunctions;
144 static const char *owl_get_func_name(struct pinctrl_dev *pctrldev,
145 unsigned int function)
147 struct owl_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctrldev);
149 return pctrl->soc->functions[function].name;
152 static int owl_get_func_groups(struct pinctrl_dev *pctrldev,
153 unsigned int function,
154 const char * const **groups,
155 unsigned int * const num_groups)
157 struct owl_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctrldev);
159 *groups = pctrl->soc->functions[function].groups;
160 *num_groups = pctrl->soc->functions[function].ngroups;
165 static inline int get_group_mfp_mask_val(const struct owl_pingroup *g,
174 for (id = 0; id < g->nfuncs; id++) {
175 if (g->funcs[id] == function)
178 if (WARN_ON(id == g->nfuncs))
181 option_num = (1 << g->mfpctl_width);
185 option_mask = option_num - 1;
186 *mask = (option_mask << g->mfpctl_shift);
187 *val = (id << g->mfpctl_shift);
192 static int owl_set_mux(struct pinctrl_dev *pctrldev,
193 unsigned int function,
196 struct owl_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctrldev);
197 const struct owl_pingroup *g;
201 g = &pctrl->soc->groups[group];
203 if (get_group_mfp_mask_val(g, function, &mask, &val))
206 raw_spin_lock_irqsave(&pctrl->lock, flags);
208 owl_update_bits(pctrl->base + g->mfpctl_reg, mask, val);
210 raw_spin_unlock_irqrestore(&pctrl->lock, flags);
215 static const struct pinmux_ops owl_pinmux_ops = {
216 .get_functions_count = owl_get_funcs_count,
217 .get_function_name = owl_get_func_name,
218 .get_function_groups = owl_get_func_groups,
219 .set_mux = owl_set_mux,
222 static int owl_pad_pinconf_reg(const struct owl_padinfo *info,
229 case PIN_CONFIG_BIAS_BUS_HOLD:
230 case PIN_CONFIG_BIAS_HIGH_IMPEDANCE:
231 case PIN_CONFIG_BIAS_PULL_DOWN:
232 case PIN_CONFIG_BIAS_PULL_UP:
235 *reg = info->pullctl->reg;
236 *bit = info->pullctl->shift;
237 *width = info->pullctl->width;
239 case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
242 *reg = info->st->reg;
243 *bit = info->st->shift;
244 *width = info->st->width;
253 static int owl_pin_config_get(struct pinctrl_dev *pctrldev,
255 unsigned long *config)
258 struct owl_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctrldev);
259 const struct owl_padinfo *info;
260 unsigned int param = pinconf_to_config_param(*config);
261 u32 reg, bit, width, arg;
263 info = &pctrl->soc->padinfo[pin];
265 ret = owl_pad_pinconf_reg(info, param, ®, &bit, &width);
269 arg = owl_read_field(pctrl, reg, bit, width);
271 if (!pctrl->soc->padctl_val2arg)
274 ret = pctrl->soc->padctl_val2arg(info, param, &arg);
278 *config = pinconf_to_config_packed(param, arg);
283 static int owl_pin_config_set(struct pinctrl_dev *pctrldev,
285 unsigned long *configs,
286 unsigned int num_configs)
288 struct owl_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctrldev);
289 const struct owl_padinfo *info;
292 u32 reg, bit, width, arg;
295 info = &pctrl->soc->padinfo[pin];
297 for (i = 0; i < num_configs; i++) {
298 param = pinconf_to_config_param(configs[i]);
299 arg = pinconf_to_config_argument(configs[i]);
301 ret = owl_pad_pinconf_reg(info, param, ®, &bit, &width);
305 if (!pctrl->soc->padctl_arg2val)
308 ret = pctrl->soc->padctl_arg2val(info, param, &arg);
312 raw_spin_lock_irqsave(&pctrl->lock, flags);
314 owl_write_field(pctrl, reg, arg, bit, width);
316 raw_spin_unlock_irqrestore(&pctrl->lock, flags);
322 static int owl_group_pinconf_reg(const struct owl_pingroup *g,
329 case PIN_CONFIG_DRIVE_STRENGTH:
334 *width = g->drv_width;
336 case PIN_CONFIG_SLEW_RATE:
341 *width = g->sr_width;
350 static int owl_group_pinconf_arg2val(const struct owl_pingroup *g,
355 case PIN_CONFIG_DRIVE_STRENGTH:
358 *arg = OWL_PINCONF_DRV_2MA;
361 *arg = OWL_PINCONF_DRV_4MA;
364 *arg = OWL_PINCONF_DRV_8MA;
367 *arg = OWL_PINCONF_DRV_12MA;
373 case PIN_CONFIG_SLEW_RATE:
375 *arg = OWL_PINCONF_SLEW_FAST;
377 *arg = OWL_PINCONF_SLEW_SLOW;
386 static int owl_group_pinconf_val2arg(const struct owl_pingroup *g,
391 case PIN_CONFIG_DRIVE_STRENGTH:
393 case OWL_PINCONF_DRV_2MA:
396 case OWL_PINCONF_DRV_4MA:
399 case OWL_PINCONF_DRV_8MA:
402 case OWL_PINCONF_DRV_12MA:
409 case PIN_CONFIG_SLEW_RATE:
422 static int owl_group_config_get(struct pinctrl_dev *pctrldev,
424 unsigned long *config)
426 const struct owl_pingroup *g;
427 struct owl_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctrldev);
428 unsigned int param = pinconf_to_config_param(*config);
429 u32 reg, bit, width, arg;
432 g = &pctrl->soc->groups[group];
434 ret = owl_group_pinconf_reg(g, param, ®, &bit, &width);
438 arg = owl_read_field(pctrl, reg, bit, width);
440 ret = owl_group_pinconf_val2arg(g, param, &arg);
444 *config = pinconf_to_config_packed(param, arg);
449 static int owl_group_config_set(struct pinctrl_dev *pctrldev,
451 unsigned long *configs,
452 unsigned int num_configs)
454 const struct owl_pingroup *g;
455 struct owl_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctrldev);
458 u32 reg, bit, width, arg;
461 g = &pctrl->soc->groups[group];
463 for (i = 0; i < num_configs; i++) {
464 param = pinconf_to_config_param(configs[i]);
465 arg = pinconf_to_config_argument(configs[i]);
467 ret = owl_group_pinconf_reg(g, param, ®, &bit, &width);
471 ret = owl_group_pinconf_arg2val(g, param, &arg);
475 /* Update register */
476 raw_spin_lock_irqsave(&pctrl->lock, flags);
478 owl_write_field(pctrl, reg, arg, bit, width);
480 raw_spin_unlock_irqrestore(&pctrl->lock, flags);
486 static const struct pinconf_ops owl_pinconf_ops = {
488 .pin_config_get = owl_pin_config_get,
489 .pin_config_set = owl_pin_config_set,
490 .pin_config_group_get = owl_group_config_get,
491 .pin_config_group_set = owl_group_config_set,
494 static struct pinctrl_desc owl_pinctrl_desc = {
495 .pctlops = &owl_pinctrl_ops,
496 .pmxops = &owl_pinmux_ops,
497 .confops = &owl_pinconf_ops,
498 .owner = THIS_MODULE,
501 static const struct owl_gpio_port *
502 owl_gpio_get_port(struct owl_pinctrl *pctrl, unsigned int *pin)
504 unsigned int start = 0, i;
506 for (i = 0; i < pctrl->soc->nports; i++) {
507 const struct owl_gpio_port *port = &pctrl->soc->ports[i];
509 if (*pin >= start && *pin < start + port->pins) {
520 static void owl_gpio_update_reg(void __iomem *base, unsigned int pin, int flag)
524 val = readl_relaxed(base);
531 writel_relaxed(val, base);
534 static int owl_gpio_request(struct gpio_chip *chip, unsigned int offset)
536 struct owl_pinctrl *pctrl = gpiochip_get_data(chip);
537 const struct owl_gpio_port *port;
538 void __iomem *gpio_base;
541 port = owl_gpio_get_port(pctrl, &offset);
542 if (WARN_ON(port == NULL))
545 gpio_base = pctrl->base + port->offset;
548 * GPIOs have higher priority over other modules, so either setting
549 * them as OUT or IN is sufficient
551 raw_spin_lock_irqsave(&pctrl->lock, flags);
552 owl_gpio_update_reg(gpio_base + port->outen, offset, true);
553 raw_spin_unlock_irqrestore(&pctrl->lock, flags);
558 static void owl_gpio_free(struct gpio_chip *chip, unsigned int offset)
560 struct owl_pinctrl *pctrl = gpiochip_get_data(chip);
561 const struct owl_gpio_port *port;
562 void __iomem *gpio_base;
565 port = owl_gpio_get_port(pctrl, &offset);
566 if (WARN_ON(port == NULL))
569 gpio_base = pctrl->base + port->offset;
571 raw_spin_lock_irqsave(&pctrl->lock, flags);
572 /* disable gpio output */
573 owl_gpio_update_reg(gpio_base + port->outen, offset, false);
575 /* disable gpio input */
576 owl_gpio_update_reg(gpio_base + port->inen, offset, false);
577 raw_spin_unlock_irqrestore(&pctrl->lock, flags);
580 static int owl_gpio_get(struct gpio_chip *chip, unsigned int offset)
582 struct owl_pinctrl *pctrl = gpiochip_get_data(chip);
583 const struct owl_gpio_port *port;
584 void __iomem *gpio_base;
588 port = owl_gpio_get_port(pctrl, &offset);
589 if (WARN_ON(port == NULL))
592 gpio_base = pctrl->base + port->offset;
594 raw_spin_lock_irqsave(&pctrl->lock, flags);
595 val = readl_relaxed(gpio_base + port->dat);
596 raw_spin_unlock_irqrestore(&pctrl->lock, flags);
598 return !!(val & BIT(offset));
601 static void owl_gpio_set(struct gpio_chip *chip, unsigned int offset, int value)
603 struct owl_pinctrl *pctrl = gpiochip_get_data(chip);
604 const struct owl_gpio_port *port;
605 void __iomem *gpio_base;
608 port = owl_gpio_get_port(pctrl, &offset);
609 if (WARN_ON(port == NULL))
612 gpio_base = pctrl->base + port->offset;
614 raw_spin_lock_irqsave(&pctrl->lock, flags);
615 owl_gpio_update_reg(gpio_base + port->dat, offset, value);
616 raw_spin_unlock_irqrestore(&pctrl->lock, flags);
619 static int owl_gpio_direction_input(struct gpio_chip *chip, unsigned int offset)
621 struct owl_pinctrl *pctrl = gpiochip_get_data(chip);
622 const struct owl_gpio_port *port;
623 void __iomem *gpio_base;
626 port = owl_gpio_get_port(pctrl, &offset);
627 if (WARN_ON(port == NULL))
630 gpio_base = pctrl->base + port->offset;
632 raw_spin_lock_irqsave(&pctrl->lock, flags);
633 owl_gpio_update_reg(gpio_base + port->outen, offset, false);
634 owl_gpio_update_reg(gpio_base + port->inen, offset, true);
635 raw_spin_unlock_irqrestore(&pctrl->lock, flags);
640 static int owl_gpio_direction_output(struct gpio_chip *chip,
641 unsigned int offset, int value)
643 struct owl_pinctrl *pctrl = gpiochip_get_data(chip);
644 const struct owl_gpio_port *port;
645 void __iomem *gpio_base;
648 port = owl_gpio_get_port(pctrl, &offset);
649 if (WARN_ON(port == NULL))
652 gpio_base = pctrl->base + port->offset;
654 raw_spin_lock_irqsave(&pctrl->lock, flags);
655 owl_gpio_update_reg(gpio_base + port->inen, offset, false);
656 owl_gpio_update_reg(gpio_base + port->outen, offset, true);
657 owl_gpio_update_reg(gpio_base + port->dat, offset, value);
658 raw_spin_unlock_irqrestore(&pctrl->lock, flags);
663 static void irq_set_type(struct owl_pinctrl *pctrl, int gpio, unsigned int type)
665 const struct owl_gpio_port *port;
666 void __iomem *gpio_base;
668 unsigned int offset, value, irq_type = 0;
671 case IRQ_TYPE_EDGE_BOTH:
673 * Since the hardware doesn't support interrupts on both edges,
674 * emulate it in the software by setting the single edge
675 * interrupt and switching to the opposite edge while ACKing
678 if (owl_gpio_get(&pctrl->chip, gpio))
679 irq_type = OWL_GPIO_INT_EDGE_FALLING;
681 irq_type = OWL_GPIO_INT_EDGE_RISING;
684 case IRQ_TYPE_EDGE_RISING:
685 irq_type = OWL_GPIO_INT_EDGE_RISING;
688 case IRQ_TYPE_EDGE_FALLING:
689 irq_type = OWL_GPIO_INT_EDGE_FALLING;
692 case IRQ_TYPE_LEVEL_HIGH:
693 irq_type = OWL_GPIO_INT_LEVEL_HIGH;
696 case IRQ_TYPE_LEVEL_LOW:
697 irq_type = OWL_GPIO_INT_LEVEL_LOW;
704 port = owl_gpio_get_port(pctrl, &gpio);
705 if (WARN_ON(port == NULL))
708 gpio_base = pctrl->base + port->offset;
710 raw_spin_lock_irqsave(&pctrl->lock, flags);
712 offset = (gpio < 16) ? 4 : 0;
713 value = readl_relaxed(gpio_base + port->intc_type + offset);
714 value &= ~(OWL_GPIO_INT_MASK << ((gpio % 16) * 2));
715 value |= irq_type << ((gpio % 16) * 2);
716 writel_relaxed(value, gpio_base + port->intc_type + offset);
718 raw_spin_unlock_irqrestore(&pctrl->lock, flags);
721 static void owl_gpio_irq_mask(struct irq_data *data)
723 struct gpio_chip *gc = irq_data_get_irq_chip_data(data);
724 struct owl_pinctrl *pctrl = gpiochip_get_data(gc);
725 const struct owl_gpio_port *port;
726 void __iomem *gpio_base;
728 unsigned int gpio = data->hwirq;
731 port = owl_gpio_get_port(pctrl, &gpio);
732 if (WARN_ON(port == NULL))
735 gpio_base = pctrl->base + port->offset;
737 raw_spin_lock_irqsave(&pctrl->lock, flags);
739 owl_gpio_update_reg(gpio_base + port->intc_msk, gpio, false);
741 /* disable port interrupt if no interrupt pending bit is active */
742 val = readl_relaxed(gpio_base + port->intc_msk);
744 owl_gpio_update_reg(gpio_base + port->intc_ctl,
745 OWL_GPIO_CTLR_ENABLE + port->shared_ctl_offset * 5, false);
747 raw_spin_unlock_irqrestore(&pctrl->lock, flags);
750 static void owl_gpio_irq_unmask(struct irq_data *data)
752 struct gpio_chip *gc = irq_data_get_irq_chip_data(data);
753 struct owl_pinctrl *pctrl = gpiochip_get_data(gc);
754 const struct owl_gpio_port *port;
755 void __iomem *gpio_base;
757 unsigned int gpio = data->hwirq;
760 port = owl_gpio_get_port(pctrl, &gpio);
761 if (WARN_ON(port == NULL))
764 gpio_base = pctrl->base + port->offset;
765 raw_spin_lock_irqsave(&pctrl->lock, flags);
767 /* enable port interrupt */
768 value = readl_relaxed(gpio_base + port->intc_ctl);
769 value |= ((BIT(OWL_GPIO_CTLR_ENABLE) | BIT(OWL_GPIO_CTLR_SAMPLE_CLK_24M))
770 << port->shared_ctl_offset * 5);
771 writel_relaxed(value, gpio_base + port->intc_ctl);
773 /* enable GPIO interrupt */
774 owl_gpio_update_reg(gpio_base + port->intc_msk, gpio, true);
776 raw_spin_unlock_irqrestore(&pctrl->lock, flags);
779 static void owl_gpio_irq_ack(struct irq_data *data)
781 struct gpio_chip *gc = irq_data_get_irq_chip_data(data);
782 struct owl_pinctrl *pctrl = gpiochip_get_data(gc);
783 const struct owl_gpio_port *port;
784 void __iomem *gpio_base;
786 unsigned int gpio = data->hwirq;
789 * Switch the interrupt edge to the opposite edge of the interrupt
790 * which got triggered for the case of emulating both edges
792 if (irqd_get_trigger_type(data) == IRQ_TYPE_EDGE_BOTH) {
793 if (owl_gpio_get(gc, gpio))
794 irq_set_type(pctrl, gpio, IRQ_TYPE_EDGE_FALLING);
796 irq_set_type(pctrl, gpio, IRQ_TYPE_EDGE_RISING);
799 port = owl_gpio_get_port(pctrl, &gpio);
800 if (WARN_ON(port == NULL))
803 gpio_base = pctrl->base + port->offset;
805 raw_spin_lock_irqsave(&pctrl->lock, flags);
807 owl_gpio_update_reg(gpio_base + port->intc_ctl,
808 OWL_GPIO_CTLR_PENDING + port->shared_ctl_offset * 5, true);
810 raw_spin_unlock_irqrestore(&pctrl->lock, flags);
813 static int owl_gpio_irq_set_type(struct irq_data *data, unsigned int type)
815 struct gpio_chip *gc = irq_data_get_irq_chip_data(data);
816 struct owl_pinctrl *pctrl = gpiochip_get_data(gc);
818 if (type & (IRQ_TYPE_LEVEL_LOW | IRQ_TYPE_LEVEL_HIGH))
819 irq_set_handler_locked(data, handle_level_irq);
821 irq_set_handler_locked(data, handle_edge_irq);
823 irq_set_type(pctrl, data->hwirq, type);
828 static void owl_gpio_irq_handler(struct irq_desc *desc)
830 struct owl_pinctrl *pctrl = irq_desc_get_handler_data(desc);
831 struct irq_chip *chip = irq_desc_get_chip(desc);
832 struct irq_domain *domain = pctrl->chip.irq.domain;
833 unsigned int parent = irq_desc_get_irq(desc);
834 const struct owl_gpio_port *port;
836 unsigned int pin, irq, offset = 0, i;
837 unsigned long pending_irq;
839 chained_irq_enter(chip, desc);
841 for (i = 0; i < pctrl->soc->nports; i++) {
842 port = &pctrl->soc->ports[i];
843 base = pctrl->base + port->offset;
845 /* skip ports that are not associated with this irq */
846 if (parent != pctrl->irq[i])
849 pending_irq = readl_relaxed(base + port->intc_pd);
851 for_each_set_bit(pin, &pending_irq, port->pins) {
852 irq = irq_find_mapping(domain, offset + pin);
853 generic_handle_irq(irq);
855 /* clear pending interrupt */
856 owl_gpio_update_reg(base + port->intc_pd, pin, true);
860 offset += port->pins;
863 chained_irq_exit(chip, desc);
866 static int owl_gpio_init(struct owl_pinctrl *pctrl)
868 struct gpio_chip *chip;
869 struct gpio_irq_chip *gpio_irq;
870 int ret, i, j, offset;
874 chip->ngpio = pctrl->soc->ngpios;
875 chip->label = dev_name(pctrl->dev);
876 chip->parent = pctrl->dev;
877 chip->owner = THIS_MODULE;
878 chip->of_node = pctrl->dev->of_node;
880 pctrl->irq_chip.name = chip->of_node->name;
881 pctrl->irq_chip.irq_ack = owl_gpio_irq_ack;
882 pctrl->irq_chip.irq_mask = owl_gpio_irq_mask;
883 pctrl->irq_chip.irq_unmask = owl_gpio_irq_unmask;
884 pctrl->irq_chip.irq_set_type = owl_gpio_irq_set_type;
886 gpio_irq = &chip->irq;
887 gpio_irq->chip = &pctrl->irq_chip;
888 gpio_irq->handler = handle_simple_irq;
889 gpio_irq->default_type = IRQ_TYPE_NONE;
890 gpio_irq->parent_handler = owl_gpio_irq_handler;
891 gpio_irq->parent_handler_data = pctrl;
892 gpio_irq->num_parents = pctrl->num_irq;
893 gpio_irq->parents = pctrl->irq;
895 gpio_irq->map = devm_kcalloc(pctrl->dev, chip->ngpio,
896 sizeof(*gpio_irq->map), GFP_KERNEL);
900 for (i = 0, offset = 0; i < pctrl->soc->nports; i++) {
901 const struct owl_gpio_port *port = &pctrl->soc->ports[i];
903 for (j = 0; j < port->pins; j++)
904 gpio_irq->map[offset + j] = gpio_irq->parents[i];
906 offset += port->pins;
909 ret = gpiochip_add_data(&pctrl->chip, pctrl);
911 dev_err(pctrl->dev, "failed to register gpiochip\n");
918 int owl_pinctrl_probe(struct platform_device *pdev,
919 struct owl_pinctrl_soc_data *soc_data)
921 struct owl_pinctrl *pctrl;
924 pctrl = devm_kzalloc(&pdev->dev, sizeof(*pctrl), GFP_KERNEL);
928 pctrl->base = devm_platform_ioremap_resource(pdev, 0);
929 if (IS_ERR(pctrl->base))
930 return PTR_ERR(pctrl->base);
932 /* enable GPIO/MFP clock */
933 pctrl->clk = devm_clk_get(&pdev->dev, NULL);
934 if (IS_ERR(pctrl->clk)) {
935 dev_err(&pdev->dev, "no clock defined\n");
936 return PTR_ERR(pctrl->clk);
939 ret = clk_prepare_enable(pctrl->clk);
941 dev_err(&pdev->dev, "clk enable failed\n");
945 raw_spin_lock_init(&pctrl->lock);
947 owl_pinctrl_desc.name = dev_name(&pdev->dev);
948 owl_pinctrl_desc.pins = soc_data->pins;
949 owl_pinctrl_desc.npins = soc_data->npins;
951 pctrl->chip.direction_input = owl_gpio_direction_input;
952 pctrl->chip.direction_output = owl_gpio_direction_output;
953 pctrl->chip.get = owl_gpio_get;
954 pctrl->chip.set = owl_gpio_set;
955 pctrl->chip.request = owl_gpio_request;
956 pctrl->chip.free = owl_gpio_free;
958 pctrl->soc = soc_data;
959 pctrl->dev = &pdev->dev;
961 pctrl->pctrldev = devm_pinctrl_register(&pdev->dev,
962 &owl_pinctrl_desc, pctrl);
963 if (IS_ERR(pctrl->pctrldev)) {
964 dev_err(&pdev->dev, "could not register Actions OWL pinmux driver\n");
965 ret = PTR_ERR(pctrl->pctrldev);
969 ret = platform_irq_count(pdev);
973 pctrl->num_irq = ret;
975 pctrl->irq = devm_kcalloc(&pdev->dev, pctrl->num_irq,
976 sizeof(*pctrl->irq), GFP_KERNEL);
982 for (i = 0; i < pctrl->num_irq ; i++) {
983 ret = platform_get_irq(pdev, i);
989 ret = owl_gpio_init(pctrl);
993 platform_set_drvdata(pdev, pctrl);
998 clk_disable_unprepare(pctrl->clk);