Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0 |
| 2 | /* |
Wolfgang Wallner | 12ea858 | 2020-01-22 16:01:44 +0100 | [diff] [blame] | 3 | * Interrupt Timer Subsystem |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 4 | * |
| 5 | * Copyright (C) 2017 Intel Corporation. |
| 6 | * Copyright (C) 2017 Siemens AG |
| 7 | * Copyright 2019 Google LLC |
| 8 | * |
| 9 | * Taken from coreboot itss.c |
| 10 | */ |
| 11 | |
| 12 | #include <common.h> |
| 13 | #include <dm.h> |
| 14 | #include <dt-structs.h> |
| 15 | #include <irq.h> |
Simon Glass | 0f2af88 | 2020-05-10 11:40:05 -0600 | [diff] [blame] | 16 | #include <log.h> |
Simon Glass | 9bc1564 | 2020-02-03 07:36:16 -0700 | [diff] [blame] | 17 | #include <malloc.h> |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 18 | #include <p2sb.h> |
| 19 | #include <spl.h> |
Wolfgang Wallner | 9713216 | 2020-01-22 16:01:45 +0100 | [diff] [blame] | 20 | #include <asm/itss.h> |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 21 | |
Wolfgang Wallner | 3767e7f | 2020-01-22 16:01:47 +0100 | [diff] [blame] | 22 | struct itss_platdata { |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 23 | #if CONFIG_IS_ENABLED(OF_PLATDATA) |
| 24 | /* Put this first since driver model will copy the data here */ |
Wolfgang Wallner | 3767e7f | 2020-01-22 16:01:47 +0100 | [diff] [blame] | 25 | struct dtd_intel_itss dtplat; |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 26 | #endif |
| 27 | }; |
| 28 | |
| 29 | /* struct pmc_route - Routing for PMC to GPIO */ |
| 30 | struct pmc_route { |
| 31 | u32 pmc; |
| 32 | u32 gpio; |
| 33 | }; |
| 34 | |
Wolfgang Wallner | 3767e7f | 2020-01-22 16:01:47 +0100 | [diff] [blame] | 35 | struct itss_priv { |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 36 | struct pmc_route *route; |
| 37 | uint route_count; |
| 38 | u32 irq_snapshot[NUM_IPC_REGS]; |
| 39 | }; |
| 40 | |
Wolfgang Wallner | 3767e7f | 2020-01-22 16:01:47 +0100 | [diff] [blame] | 41 | static int set_polarity(struct udevice *dev, uint irq, bool active_low) |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 42 | { |
| 43 | u32 mask; |
| 44 | uint reg; |
| 45 | |
| 46 | if (irq > ITSS_MAX_IRQ) |
| 47 | return -EINVAL; |
| 48 | |
| 49 | reg = PCR_ITSS_IPC0_CONF + sizeof(u32) * (irq / IRQS_PER_IPC); |
| 50 | mask = 1 << (irq % IRQS_PER_IPC); |
| 51 | |
| 52 | pcr_clrsetbits32(dev, reg, mask, active_low ? mask : 0); |
| 53 | |
| 54 | return 0; |
| 55 | } |
| 56 | |
| 57 | #ifndef CONFIG_TPL_BUILD |
Wolfgang Wallner | 3767e7f | 2020-01-22 16:01:47 +0100 | [diff] [blame] | 58 | static int snapshot_polarities(struct udevice *dev) |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 59 | { |
Wolfgang Wallner | 3767e7f | 2020-01-22 16:01:47 +0100 | [diff] [blame] | 60 | struct itss_priv *priv = dev_get_priv(dev); |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 61 | const int start = GPIO_IRQ_START; |
| 62 | const int end = GPIO_IRQ_END; |
| 63 | int reg_start; |
| 64 | int reg_end; |
| 65 | int i; |
| 66 | |
| 67 | reg_start = start / IRQS_PER_IPC; |
Simon Glass | d89f193 | 2020-07-16 21:22:30 -0600 | [diff] [blame] | 68 | reg_end = DIV_ROUND_UP(end, IRQS_PER_IPC); |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 69 | |
Simon Glass | dd5fa06 | 2020-11-04 09:57:39 -0700 | [diff] [blame] | 70 | log_debug("ITSS IRQ Polarities snapshot %p\n", priv->irq_snapshot); |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 71 | for (i = reg_start; i < reg_end; i++) { |
| 72 | uint reg = PCR_ITSS_IPC0_CONF + sizeof(u32) * i; |
| 73 | |
| 74 | priv->irq_snapshot[i] = pcr_read32(dev, reg); |
Simon Glass | d89f193 | 2020-07-16 21:22:30 -0600 | [diff] [blame] | 75 | log_debug(" - %d, reg %x: irq_snapshot[i] %x\n", i, reg, |
| 76 | priv->irq_snapshot[i]); |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 77 | } |
| 78 | |
Simon Glass | d89f193 | 2020-07-16 21:22:30 -0600 | [diff] [blame] | 79 | /* Save the snapshot for use after relocation */ |
| 80 | gd->start_addr_sp -= sizeof(*priv); |
| 81 | gd->start_addr_sp &= ~0xf; |
| 82 | gd->arch.itss_priv = (void *)gd->start_addr_sp; |
| 83 | memcpy(gd->arch.itss_priv, priv, sizeof(*priv)); |
| 84 | |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 85 | return 0; |
| 86 | } |
| 87 | |
| 88 | static void show_polarities(struct udevice *dev, const char *msg) |
| 89 | { |
| 90 | int i; |
| 91 | |
Simon Glass | dd5fa06 | 2020-11-04 09:57:39 -0700 | [diff] [blame] | 92 | log_debug("ITSS IRQ Polarities %s:\n", msg); |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 93 | for (i = 0; i < NUM_IPC_REGS; i++) { |
| 94 | uint reg = PCR_ITSS_IPC0_CONF + sizeof(u32) * i; |
| 95 | |
Simon Glass | dd5fa06 | 2020-11-04 09:57:39 -0700 | [diff] [blame] | 96 | log_debug("IPC%d: 0x%08x\n", i, pcr_read32(dev, reg)); |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 97 | } |
| 98 | } |
| 99 | |
Wolfgang Wallner | 3767e7f | 2020-01-22 16:01:47 +0100 | [diff] [blame] | 100 | static int restore_polarities(struct udevice *dev) |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 101 | { |
Wolfgang Wallner | 3767e7f | 2020-01-22 16:01:47 +0100 | [diff] [blame] | 102 | struct itss_priv *priv = dev_get_priv(dev); |
Simon Glass | d89f193 | 2020-07-16 21:22:30 -0600 | [diff] [blame] | 103 | struct itss_priv *old_priv; |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 104 | const int start = GPIO_IRQ_START; |
| 105 | const int end = GPIO_IRQ_END; |
| 106 | int reg_start; |
| 107 | int reg_end; |
| 108 | int i; |
| 109 | |
Simon Glass | d89f193 | 2020-07-16 21:22:30 -0600 | [diff] [blame] | 110 | /* Get the snapshot which was stored by the pre-reloc device */ |
| 111 | old_priv = gd->arch.itss_priv; |
| 112 | if (!old_priv) |
| 113 | return log_msg_ret("priv", -EFAULT); |
| 114 | memcpy(priv->irq_snapshot, old_priv->irq_snapshot, |
| 115 | sizeof(priv->irq_snapshot)); |
| 116 | |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 117 | show_polarities(dev, "Before"); |
Simon Glass | dd5fa06 | 2020-11-04 09:57:39 -0700 | [diff] [blame] | 118 | log_debug("priv->irq_snapshot %p\n", priv->irq_snapshot); |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 119 | |
| 120 | reg_start = start / IRQS_PER_IPC; |
Simon Glass | d89f193 | 2020-07-16 21:22:30 -0600 | [diff] [blame] | 121 | reg_end = DIV_ROUND_UP(end, IRQS_PER_IPC); |
| 122 | |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 123 | |
| 124 | for (i = reg_start; i < reg_end; i++) { |
| 125 | u32 mask; |
| 126 | u16 reg; |
| 127 | int irq_start; |
| 128 | int irq_end; |
| 129 | |
| 130 | irq_start = i * IRQS_PER_IPC; |
| 131 | irq_end = min(irq_start + IRQS_PER_IPC - 1, ITSS_MAX_IRQ); |
| 132 | |
| 133 | if (start > irq_end) |
| 134 | continue; |
| 135 | if (end < irq_start) |
| 136 | break; |
| 137 | |
| 138 | /* Track bits within the bounds of of the register */ |
| 139 | irq_start = max(start, irq_start) % IRQS_PER_IPC; |
| 140 | irq_end = min(end, irq_end) % IRQS_PER_IPC; |
| 141 | |
| 142 | /* Create bitmask of the inclusive range of start and end */ |
| 143 | mask = (((1U << irq_end) - 1) | (1U << irq_end)); |
| 144 | mask &= ~((1U << irq_start) - 1); |
| 145 | |
| 146 | reg = PCR_ITSS_IPC0_CONF + sizeof(u32) * i; |
Simon Glass | d89f193 | 2020-07-16 21:22:30 -0600 | [diff] [blame] | 147 | log_debug(" - %d, reg %x: mask %x, irq_snapshot[i] %x\n", |
| 148 | i, reg, mask, priv->irq_snapshot[i]); |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 149 | pcr_clrsetbits32(dev, reg, mask, mask & priv->irq_snapshot[i]); |
| 150 | } |
| 151 | |
| 152 | show_polarities(dev, "After"); |
| 153 | |
| 154 | return 0; |
| 155 | } |
| 156 | #endif |
| 157 | |
Wolfgang Wallner | 3767e7f | 2020-01-22 16:01:47 +0100 | [diff] [blame] | 158 | static int route_pmc_gpio_gpe(struct udevice *dev, uint pmc_gpe_num) |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 159 | { |
Wolfgang Wallner | 3767e7f | 2020-01-22 16:01:47 +0100 | [diff] [blame] | 160 | struct itss_priv *priv = dev_get_priv(dev); |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 161 | struct pmc_route *route; |
| 162 | int i; |
| 163 | |
| 164 | for (i = 0, route = priv->route; i < priv->route_count; i++, route++) { |
| 165 | if (pmc_gpe_num == route->pmc) |
| 166 | return route->gpio; |
| 167 | } |
| 168 | |
| 169 | return -ENOENT; |
| 170 | } |
| 171 | |
Simon Glass | c51a021 | 2020-02-06 09:54:59 -0700 | [diff] [blame] | 172 | static int itss_bind(struct udevice *dev) |
| 173 | { |
| 174 | /* This is not set with of-platdata, so set it manually */ |
| 175 | if (CONFIG_IS_ENABLED(OF_PLATDATA)) |
| 176 | dev->driver_data = X86_IRQT_ITSS; |
| 177 | |
| 178 | return 0; |
| 179 | } |
| 180 | |
Simon Glass | aad29ae | 2020-12-03 16:55:21 -0700 | [diff] [blame] | 181 | static int itss_of_to_plat(struct udevice *dev) |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 182 | { |
Wolfgang Wallner | 3767e7f | 2020-01-22 16:01:47 +0100 | [diff] [blame] | 183 | struct itss_priv *priv = dev_get_priv(dev); |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 184 | int ret; |
| 185 | |
| 186 | #if CONFIG_IS_ENABLED(OF_PLATDATA) |
Simon Glass | fa20e93 | 2020-12-03 16:55:20 -0700 | [diff] [blame] | 187 | struct itss_platdata *plat = dev_get_plat(dev); |
Wolfgang Wallner | 3767e7f | 2020-01-22 16:01:47 +0100 | [diff] [blame] | 188 | struct dtd_intel_itss *dtplat = &plat->dtplat; |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 189 | |
| 190 | /* |
| 191 | * It would be nice to do this in the bind() method, but with |
| 192 | * of-platdata binding happens in the order that DM finds things in the |
| 193 | * linker list (i.e. alphabetical order by driver name). So the GPIO |
| 194 | * device may well be bound before its parent (p2sb), and this call |
| 195 | * will fail if p2sb is not bound yet. |
| 196 | * |
| 197 | * TODO(sjg@chromium.org): Add a parent pointer to child devices in dtoc |
| 198 | */ |
| 199 | ret = p2sb_set_port_id(dev, dtplat->intel_p2sb_port_id); |
| 200 | if (ret) |
| 201 | return log_msg_ret("Could not set port id", ret); |
| 202 | priv->route = (struct pmc_route *)dtplat->intel_pmc_routes; |
| 203 | priv->route_count = ARRAY_SIZE(dtplat->intel_pmc_routes) / |
| 204 | sizeof(struct pmc_route); |
| 205 | #else |
| 206 | int size; |
| 207 | |
| 208 | size = dev_read_size(dev, "intel,pmc-routes"); |
| 209 | if (size < 0) |
| 210 | return size; |
| 211 | priv->route = malloc(size); |
| 212 | if (!priv->route) |
| 213 | return -ENOMEM; |
| 214 | ret = dev_read_u32_array(dev, "intel,pmc-routes", (u32 *)priv->route, |
| 215 | size / sizeof(fdt32_t)); |
| 216 | if (ret) |
| 217 | return log_msg_ret("Cannot read pmc-routes", ret); |
| 218 | priv->route_count = size / sizeof(struct pmc_route); |
| 219 | #endif |
| 220 | |
| 221 | return 0; |
| 222 | } |
| 223 | |
Wolfgang Wallner | 3767e7f | 2020-01-22 16:01:47 +0100 | [diff] [blame] | 224 | static const struct irq_ops itss_ops = { |
| 225 | .route_pmc_gpio_gpe = route_pmc_gpio_gpe, |
| 226 | .set_polarity = set_polarity, |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 227 | #ifndef CONFIG_TPL_BUILD |
Wolfgang Wallner | 3767e7f | 2020-01-22 16:01:47 +0100 | [diff] [blame] | 228 | .snapshot_polarities = snapshot_polarities, |
| 229 | .restore_polarities = restore_polarities, |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 230 | #endif |
| 231 | }; |
| 232 | |
Wolfgang Wallner | 3767e7f | 2020-01-22 16:01:47 +0100 | [diff] [blame] | 233 | static const struct udevice_id itss_ids[] = { |
Simon Glass | 21bb12a | 2020-02-06 09:54:58 -0700 | [diff] [blame] | 234 | { .compatible = "intel,itss", .data = X86_IRQT_ITSS }, |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 235 | { } |
| 236 | }; |
| 237 | |
Simon Glass | a055da8 | 2020-10-05 05:27:01 -0600 | [diff] [blame] | 238 | U_BOOT_DRIVER(intel_itss) = { |
Wolfgang Wallner | 3767e7f | 2020-01-22 16:01:47 +0100 | [diff] [blame] | 239 | .name = "intel_itss", |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 240 | .id = UCLASS_IRQ, |
Wolfgang Wallner | 3767e7f | 2020-01-22 16:01:47 +0100 | [diff] [blame] | 241 | .of_match = itss_ids, |
| 242 | .ops = &itss_ops, |
Simon Glass | c51a021 | 2020-02-06 09:54:59 -0700 | [diff] [blame] | 243 | .bind = itss_bind, |
Simon Glass | aad29ae | 2020-12-03 16:55:21 -0700 | [diff] [blame] | 244 | .of_to_plat = itss_of_to_plat, |
Simon Glass | 71fa5b4 | 2020-12-03 16:55:18 -0700 | [diff] [blame] | 245 | .plat_auto = sizeof(struct itss_platdata), |
Simon Glass | 8a2b47f | 2020-12-03 16:55:17 -0700 | [diff] [blame] | 246 | .priv_auto = sizeof(struct itss_priv), |
Simon Glass | 8c0629b | 2019-12-08 17:40:08 -0700 | [diff] [blame] | 247 | }; |