1 /* 2 * ACPI GSI IRQ layer 3 * 4 * Copyright (C) 2015 ARM Ltd. 5 * Author: Lorenzo Pieralisi <lorenzo.pieralisi@arm.com> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 */ 11 #include <linux/acpi.h> 12 #include <linux/irq.h> 13 #include <linux/irqdomain.h> 14 #include <linux/of.h> 15 16 enum acpi_irq_model_id acpi_irq_model; 17 18 static struct fwnode_handle *acpi_gsi_domain_id; 19 20 /** 21 * acpi_gsi_to_irq() - Retrieve the linux irq number for a given GSI 22 * @gsi: GSI IRQ number to map 23 * @irq: pointer where linux IRQ number is stored 24 * 25 * irq location updated with irq value [>0 on success, 0 on failure] 26 * 27 * Returns: 0 on success 28 * -EINVAL on failure 29 */ 30 int acpi_gsi_to_irq(u32 gsi, unsigned int *irq) 31 { 32 struct irq_domain *d = irq_find_matching_fwnode(acpi_gsi_domain_id, 33 DOMAIN_BUS_ANY); 34 35 *irq = irq_find_mapping(d, gsi); 36 /* 37 * *irq == 0 means no mapping, that should 38 * be reported as a failure 39 */ 40 return (*irq > 0) ? 0 : -EINVAL; 41 } 42 EXPORT_SYMBOL_GPL(acpi_gsi_to_irq); 43 44 /** 45 * acpi_register_gsi() - Map a GSI to a linux IRQ number 46 * @dev: device for which IRQ has to be mapped 47 * @gsi: GSI IRQ number 48 * @trigger: trigger type of the GSI number to be mapped 49 * @polarity: polarity of the GSI to be mapped 50 * 51 * Returns: a valid linux IRQ number on success 52 * -EINVAL on failure 53 */ 54 int acpi_register_gsi(struct device *dev, u32 gsi, int trigger, 55 int polarity) 56 { 57 struct irq_fwspec fwspec; 58 59 if (WARN_ON(!acpi_gsi_domain_id)) { 60 pr_warn("GSI: No registered irqchip, giving up\n"); 61 return -EINVAL; 62 } 63 64 fwspec.fwnode = acpi_gsi_domain_id; 65 fwspec.param[0] = gsi; 66 fwspec.param[1] = acpi_dev_get_irq_type(trigger, polarity); 67 fwspec.param_count = 2; 68 69 return irq_create_fwspec_mapping(&fwspec); 70 } 71 EXPORT_SYMBOL_GPL(acpi_register_gsi); 72 73 /** 74 * acpi_unregister_gsi() - Free a GSI<->linux IRQ number mapping 75 * @gsi: GSI IRQ number 76 */ 77 void acpi_unregister_gsi(u32 gsi) 78 { 79 struct irq_domain *d = irq_find_matching_fwnode(acpi_gsi_domain_id, 80 DOMAIN_BUS_ANY); 81 int irq = irq_find_mapping(d, gsi); 82 83 irq_dispose_mapping(irq); 84 } 85 EXPORT_SYMBOL_GPL(acpi_unregister_gsi); 86 87 /** 88 * acpi_get_irq_source_fwhandle() - Retrieve fwhandle from IRQ resource source. 89 * @source: acpi_resource_source to use for the lookup. 90 * 91 * Description: 92 * Retrieve the fwhandle of the device referenced by the given IRQ resource 93 * source. 94 * 95 * Return: 96 * The referenced device fwhandle or NULL on failure 97 */ 98 static struct fwnode_handle * 99 acpi_get_irq_source_fwhandle(const struct acpi_resource_source *source) 100 { 101 struct fwnode_handle *result; 102 struct acpi_device *device; 103 acpi_handle handle; 104 acpi_status status; 105 106 if (!source->string_length) 107 return acpi_gsi_domain_id; 108 109 status = acpi_get_handle(NULL, source->string_ptr, &handle); 110 if (WARN_ON(ACPI_FAILURE(status))) 111 return NULL; 112 113 device = acpi_bus_get_acpi_device(handle); 114 if (WARN_ON(!device)) 115 return NULL; 116 117 result = &device->fwnode; 118 acpi_bus_put_acpi_device(device); 119 return result; 120 } 121 122 /* 123 * Context for the resource walk used to lookup IRQ resources. 124 * Contains a return code, the lookup index, and references to the flags 125 * and fwspec where the result is returned. 126 */ 127 struct acpi_irq_parse_one_ctx { 128 int rc; 129 unsigned int index; 130 unsigned long *res_flags; 131 struct irq_fwspec *fwspec; 132 }; 133 134 /** 135 * acpi_irq_parse_one_match - Handle a matching IRQ resource. 136 * @fwnode: matching fwnode 137 * @hwirq: hardware IRQ number 138 * @triggering: triggering attributes of hwirq 139 * @polarity: polarity attributes of hwirq 140 * @polarity: polarity attributes of hwirq 141 * @shareable: shareable attributes of hwirq 142 * @ctx: acpi_irq_parse_one_ctx updated by this function 143 * 144 * Description: 145 * Handle a matching IRQ resource by populating the given ctx with 146 * the information passed. 147 */ 148 static inline void acpi_irq_parse_one_match(struct fwnode_handle *fwnode, 149 u32 hwirq, u8 triggering, 150 u8 polarity, u8 shareable, 151 struct acpi_irq_parse_one_ctx *ctx) 152 { 153 if (!fwnode) 154 return; 155 ctx->rc = 0; 156 *ctx->res_flags = acpi_dev_irq_flags(triggering, polarity, shareable); 157 ctx->fwspec->fwnode = fwnode; 158 ctx->fwspec->param[0] = hwirq; 159 ctx->fwspec->param[1] = acpi_dev_get_irq_type(triggering, polarity); 160 ctx->fwspec->param_count = 2; 161 } 162 163 /** 164 * acpi_irq_parse_one_cb - Handle the given resource. 165 * @ares: resource to handle 166 * @context: context for the walk 167 * 168 * Description: 169 * This is called by acpi_walk_resources passing each resource returned by 170 * the _CRS method. We only inspect IRQ resources. Since IRQ resources 171 * might contain multiple interrupts we check if the index is within this 172 * one's interrupt array, otherwise we subtract the current resource IRQ 173 * count from the lookup index to prepare for the next resource. 174 * Once a match is found we call acpi_irq_parse_one_match to populate 175 * the result and end the walk by returning AE_CTRL_TERMINATE. 176 * 177 * Return: 178 * AE_OK if the walk should continue, AE_CTRL_TERMINATE if a matching 179 * IRQ resource was found. 180 */ 181 static acpi_status acpi_irq_parse_one_cb(struct acpi_resource *ares, 182 void *context) 183 { 184 struct acpi_irq_parse_one_ctx *ctx = context; 185 struct acpi_resource_irq *irq; 186 struct acpi_resource_extended_irq *eirq; 187 struct fwnode_handle *fwnode; 188 189 switch (ares->type) { 190 case ACPI_RESOURCE_TYPE_IRQ: 191 irq = &ares->data.irq; 192 if (ctx->index >= irq->interrupt_count) { 193 ctx->index -= irq->interrupt_count; 194 return AE_OK; 195 } 196 fwnode = acpi_gsi_domain_id; 197 acpi_irq_parse_one_match(fwnode, irq->interrupts[ctx->index], 198 irq->triggering, irq->polarity, 199 irq->shareable, ctx); 200 return AE_CTRL_TERMINATE; 201 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ: 202 eirq = &ares->data.extended_irq; 203 if (eirq->producer_consumer == ACPI_PRODUCER) 204 return AE_OK; 205 if (ctx->index >= eirq->interrupt_count) { 206 ctx->index -= eirq->interrupt_count; 207 return AE_OK; 208 } 209 fwnode = acpi_get_irq_source_fwhandle(&eirq->resource_source); 210 acpi_irq_parse_one_match(fwnode, eirq->interrupts[ctx->index], 211 eirq->triggering, eirq->polarity, 212 eirq->shareable, ctx); 213 return AE_CTRL_TERMINATE; 214 } 215 216 return AE_OK; 217 } 218 219 /** 220 * acpi_irq_parse_one - Resolve an interrupt for a device 221 * @handle: the device whose interrupt is to be resolved 222 * @index: index of the interrupt to resolve 223 * @fwspec: structure irq_fwspec filled by this function 224 * @flags: resource flags filled by this function 225 * 226 * Description: 227 * Resolves an interrupt for a device by walking its CRS resources to find 228 * the appropriate ACPI IRQ resource and populating the given struct irq_fwspec 229 * and flags. 230 * 231 * Return: 232 * The result stored in ctx.rc by the callback, or the default -EINVAL value 233 * if an error occurs. 234 */ 235 static int acpi_irq_parse_one(acpi_handle handle, unsigned int index, 236 struct irq_fwspec *fwspec, unsigned long *flags) 237 { 238 struct acpi_irq_parse_one_ctx ctx = { -EINVAL, index, flags, fwspec }; 239 240 acpi_walk_resources(handle, METHOD_NAME__CRS, acpi_irq_parse_one_cb, &ctx); 241 return ctx.rc; 242 } 243 244 /** 245 * acpi_irq_get - Lookup an ACPI IRQ resource and use it to initialize resource. 246 * @handle: ACPI device handle 247 * @index: ACPI IRQ resource index to lookup 248 * @res: Linux IRQ resource to initialize 249 * 250 * Description: 251 * Look for the ACPI IRQ resource with the given index and use it to initialize 252 * the given Linux IRQ resource. 253 * 254 * Return: 255 * 0 on success 256 * -EINVAL if an error occurs 257 * -EPROBE_DEFER if the IRQ lookup/conversion failed 258 */ 259 int acpi_irq_get(acpi_handle handle, unsigned int index, struct resource *res) 260 { 261 struct irq_fwspec fwspec; 262 struct irq_domain *domain; 263 unsigned long flags; 264 int rc; 265 266 rc = acpi_irq_parse_one(handle, index, &fwspec, &flags); 267 if (rc) 268 return rc; 269 270 domain = irq_find_matching_fwnode(fwspec.fwnode, DOMAIN_BUS_ANY); 271 if (!domain) 272 return -EPROBE_DEFER; 273 274 rc = irq_create_fwspec_mapping(&fwspec); 275 if (rc <= 0) 276 return -EINVAL; 277 278 res->start = rc; 279 res->end = rc; 280 res->flags = flags; 281 282 return 0; 283 } 284 EXPORT_SYMBOL_GPL(acpi_irq_get); 285 286 /** 287 * acpi_set_irq_model - Setup the GSI irqdomain information 288 * @model: the value assigned to acpi_irq_model 289 * @fwnode: the irq_domain identifier for mapping and looking up 290 * GSI interrupts 291 */ 292 void __init acpi_set_irq_model(enum acpi_irq_model_id model, 293 struct fwnode_handle *fwnode) 294 { 295 acpi_irq_model = model; 296 acpi_gsi_domain_id = fwnode; 297 } 298