gpio: tegra186: Force one interrupt per bank
Subsystems (2)
PATCH 1/2 gpio: tegra186: Force one interrupt per bank
From: Thierry Reding <[email protected]>
Newer chips support up to 8 interrupts per bank, which can be useful to balance the load and decrease latency. However, it also required a very complicated interrupt routing to be set up. To keep things simple for now, ensure that a single interrupt per bank is enforced, even if all possible interrupts are described in device tree.
--- drivers/gpio/gpio-tegra186.c | 68 ++++++++++++++++++++++++++++++++---- 1 file changed, 62 insertions(+), 6 deletions(-)
drivers/gpio/gpio-tegra186.c +62 -6
@@ -81,6 +81,8 @@ struct tegra_gpio {unsigned int *irq;const struct tegra_gpio_soc *soc; +unsigned int num_irqs_per_bank; +unsigned int num_banks;void __iomem *secure;void __iomem *base;
@@ -594,6 +596,28 @@ static void tegra186_gpio_init_route_mapping(struct tegra_gpio *gpio) } } +static unsigned int tegra186_gpio_irqs_per_bank (struct tegra_gpio *gpio) +{ +struct device *dev = gpio->gpio.parent; + +if (gpio->num_irq > gpio->num_banks) { +if (gpio->num_irq % gpio->num_banks !=0 ) + goto error; + } + +if (gpio->num_irq < gpio->num_banks) + goto error; + + gpio->num_irqs_per_bank = gpio->num_irq / gpio->num_banks; + +return 0 ; + +error: +dev_err (dev,"invalid number of interrupts (%u) for %u banks\n" , + gpio->num_irq, gpio->num_banks); +return -EINVAL ; +} +static int tegra186_gpio_probe (struct platform_device *pdev) {unsigned int i, j, offset;
@@ -608,7 +632,17 @@ static int tegra186_gpio_probe(struct platform_device *pdev)return -ENOMEM ; gpio->soc =device_get_match_data (&pdev->dev); + gpio->gpio.label = gpio->soc->name; + gpio->gpio.parent = &pdev->dev; + +/* count the number of banks in the controller */ +for (i =0 ; i < gpio->soc->num_ports; i++) +if (gpio->soc->ports[i].bank > gpio->num_banks) + gpio->num_banks = gpio->soc->ports[i].bank; + + gpio->num_banks++; +/* get register apertures */ gpio->secure =devm_platform_ioremap_resource_byname (pdev,"security" );if (IS_ERR (gpio->secure)) { gpio->secure =devm_platform_ioremap_resource (pdev,0 );
@@ -629,6 +663,10 @@ static int tegra186_gpio_probe(struct platform_device *pdev) gpio->num_irq = err; + err =tegra186_gpio_irqs_per_bank (gpio); +if (err <0 ) +return err; + gpio->irq =devm_kcalloc (&pdev->dev, gpio->num_irq,sizeof (*gpio->irq),GFP_KERNEL );if (!gpio->irq)
@@ -642,9 +680,6 @@ static int tegra186_gpio_probe(struct platform_device *pdev) gpio->irq[i] = err; } - gpio->gpio.label = gpio->soc->name; - gpio->gpio.parent = &pdev->dev; - gpio->gpio.request = gpiochip_generic_request; gpio->gpio.free = gpiochip_generic_free; gpio->gpio.get_direction = tegra186_gpio_get_direction;
@@ -708,7 +743,30 @@ static int tegra186_gpio_probe(struct platform_device *pdev) irq->parent_handler = tegra186_gpio_irq; irq->parent_handler_data = gpio; irq->num_parents = gpio->num_irq; - irq->parents = gpio->irq; + +/* +* To simplify things, use a single interrupt per bank for now. Some +* chips support up to 8 interrupts per bank, which can be useful to +* distribute the load and decrease the processing latency for GPIOs +* but it also requires a more complicated interrupt routing than we +* currently program. +*/ +if (gpio->num_irqs_per_bank >1 ) { + irq->parents =devm_kcalloc (&pdev->dev, gpio->num_banks, +sizeof (*irq->parents),GFP_KERNEL ); +if (!irq->parents) +return -ENOMEM ; + +for (i =0 ; i < gpio->num_banks; i++) + irq->parents[i] = gpio->irq[i * gpio->num_irqs_per_bank]; + + irq->num_parents = gpio->num_banks; + }else { + irq->num_parents = gpio->num_irq; + irq->parents = gpio->irq; + } + +tegra186_gpio_init_route_mapping (gpio); np =of_find_matching_node (NULL , tegra186_pmc_of_match);if (np) {
@@ -719,8 +777,6 @@ static int tegra186_gpio_probe(struct platform_device *pdev)return -EPROBE_DEFER ; } -tegra186_gpio_init_route_mapping (gpio); - irq->map =devm_kcalloc (&pdev->dev, gpio->gpio.ngpio,sizeof (*irq->map),GFP_KERNEL );if (!irq->map)
Signature · 1 line
2.33.0
PATCH 2/2 gpio: tegra186: Support multiple interrupts per bank
From: Thierry Reding <[email protected]>
Tegra194 and later support more than a single interrupt per bank. This is primarily useful for virtualization but can also be helpful for more fine-grained CPU affinity control. To keep things simple for now, route all pins to the first interrupt.
For backwards-compatibility, support old device trees that specify only one interrupt per bank by counting the interrupts at probe time.
--- drivers/gpio/gpio-tegra186.c | 48 ++++++++++++++++++++++++++++++------ 1 file changed, 41 insertions(+), 7 deletions(-)
drivers/gpio/gpio-tegra186.c +41 -7
@@ -69,6 +69,8 @@ struct tegra_gpio_soc {const char *name;unsigned int instance; +unsigned int num_irqs_per_bank; +const struct tegra186_pin_range *pin_ranges;unsigned int num_pin_ranges;const char *pinmux;
@@ -452,7 +454,7 @@ static void tegra186_gpio_irq(struct irq_desc *desc)struct irq_domain *domain = gpio->gpio.irq.domain;struct irq_chip *chip =irq_desc_get_chip (desc);unsigned int parent =irq_desc_get_irq (desc); -unsigned int i, offset =0 ; +unsigned int i, j, offset =0 ;chained_irq_enter (chip, desc);
@@ -465,7 +467,12 @@ static void tegra186_gpio_irq(struct irq_desc *desc) base = gpio->base + port->bank *0x1000 + port->port *0x200 ;/* skip ports that are not associated with this bank */ -if (parent != gpio->irq[port->bank]) +for (j =0 ; j < gpio->num_irqs_per_bank; j++) { +if (parent == gpio->irq[port->bank * gpio->num_irqs_per_bank + j]) +break ; + } + +if (j == gpio->num_irqs_per_bank) goto skip; value =readl (base +TEGRA186_GPIO_INTERRUPT_STATUS (1 ));
@@ -567,6 +574,7 @@ static const struct of_device_id tegra186_pmc_of_match[] = {static void tegra186_gpio_init_route_mapping (struct tegra_gpio *gpio) { +struct device *dev = gpio->gpio.parent;unsigned int i, j;u32 value;
@@ -585,12 +593,30 @@ static void tegra186_gpio_init_route_mapping(struct tegra_gpio *gpio)*/ if ((value &TEGRA186_GPIO_CTL_SCR_SEC_REN ) ==0 && (value &TEGRA186_GPIO_CTL_SCR_SEC_WEN ) ==0 ) { -for (j =0 ; j <8 ; j++) { +/* +* On Tegra194 and later, each pin can be routed to one or more +* interrupts. +*/ +for (j =0 ; j < gpio->num_irqs_per_bank; j++) { +dev_dbg (dev,"programming default interrupt routing for port %s\n" , + port->name); + offset =TEGRA186_GPIO_INT_ROUTE_MAPPING (p, j); - value =readl (base + offset); - value =BIT (port->pins) -1 ; -writel (value, base + offset); +/* +* By default we only want to route GPIO pins to IRQ 0. This works +* only under the assumption that we're running as the host kernel +* and hence all GPIO pins are owned by Linux. +* +* For cases where Linux is the guest OS, the hypervisor will have +* to configure the interrupt routing and pass only the valid +* interrupts via device tree. +*/ +if (j ==0 ) { + value =readl (base + offset); + value =BIT (port->pins) -1 ; +writel (value, base + offset); + } } } }
@@ -610,6 +636,9 @@ static unsigned int tegra186_gpio_irqs_per_bank(struct tegra_gpio *gpio) gpio->num_irqs_per_bank = gpio->num_irq / gpio->num_banks; +if (gpio->num_irqs_per_bank > gpio->soc->num_irqs_per_bank) + goto error; +return 0 ; error:
@@ -766,7 +795,8 @@ static int tegra186_gpio_probe(struct platform_device *pdev) irq->parents = gpio->irq; } -tegra186_gpio_init_route_mapping (gpio); +if (gpio->soc->num_irqs_per_bank >1 ) +tegra186_gpio_init_route_mapping (gpio); np =of_find_matching_node (NULL , tegra186_pmc_of_match);if (np) {
@@ -833,6 +863,7 @@ static const struct tegra_gpio_soc tegra186_main_soc = { .ports = tegra186_main_ports, .name = "tegra186-gpio", .instance = 0, + .num_irqs_per_bank = 1, };#define TEGRA186_AON_GPIO_PORT (_name, _bank, _port, _pins) \
@@ -859,6 +890,7 @@ static const struct tegra_gpio_soc tegra186_aon_soc = { .ports = tegra186_aon_ports, .name = "tegra186-gpio-aon", .instance = 1, + .num_irqs_per_bank = 1, };#define TEGRA194_MAIN_GPIO_PORT (_name, _bank, _port, _pins) \
@@ -910,6 +942,7 @@ static const struct tegra_gpio_soc tegra194_main_soc = { .ports = tegra194_main_ports, .name = "tegra194-gpio", .instance = 0, + .num_irqs_per_bank = 8, .num_pin_ranges = ARRAY_SIZE(tegra194_main_pin_ranges), .pin_ranges = tegra194_main_pin_ranges, .pinmux = "nvidia,tegra194-pinmux",
@@ -936,6 +969,7 @@ static const struct tegra_gpio_soc tegra194_aon_soc = { .ports = tegra194_aon_ports, .name = "tegra194-gpio-aon", .instance = 1, + .num_irqs_per_bank = 8, };static const struct of_device_id tegra186_gpio_of_match[] = {
Signature · 1 line
2.33.0
Re: [PATCH 2/2] gpio: tegra186: Support multiple interrupts per bank
Quoted 11 lines · Thierry Reding
From: Thierry Reding <[email protected]>
Tegra194 and later support more than a single interrupt per bank. This is primarily useful for virtualization but can also be helpful for more fine-grained CPU affinity control. To keep things simple for now, route all pins to the first interrupt.
For backwards-compatibility, support old device trees that specify only one interrupt per bank by counting the interrupts at probe time.
Signed-off-by Thierry Reding <[email protected]>
Yours,
Linus Walleij
Bartosz Golaszewski
AppliedRe: [PATCH 2/2] gpio: tegra186: Support multiple interrupts per bank
In reply to Thierry RedingQuoted 8 lines · Thierry Reding
From: Thierry Reding <[email protected]>
Tegra194 and later support more than a single interrupt per bank. This is primarily useful for virtualization but can also be helpful for more fine-grained CPU affinity control. To keep things simple for now, route all pins to the first interrupt.
Quoted 5 lines
For backwards-compatibility, support old device trees that specify only one interrupt per bank by counting the interrupts at probe time.
Signed-off-by Thierry Reding <[email protected]>---
Applied, thanks!
Bart
Quoted 9 lines · Thierry Reding
From: Thierry Reding <[email protected]>
Newer chips support up to 8 interrupts per bank, which can be useful to balance the load and decrease latency. However, it also required a very complicated interrupt routing to be set up. To keep things simple for now, ensure that a single interrupt per bank is enforced, even if all possible interrupts are described in device tree.
Signed-off-by Thierry Reding <[email protected]>
Yours,
Linus Walleij
Bartosz Golaszewski
AppliedQuoted 11 lines · Thierry Reding
From: Thierry Reding <[email protected]>
Newer chips support up to 8 interrupts per bank, which can be useful to balance the load and decrease latency. However, it also required a very complicated interrupt routing to be set up. To keep things simple for now, ensure that a single interrupt per bank is enforced, even if all possible interrupts are described in device tree.
Signed-off-by Thierry Reding <[email protected]>---
Applied, thanks!
Bart