1 // SPDX-License-Identifier: GPL-2.0
3 * MSI framework for platform devices
5 * Copyright (C) 2015 ARM Limited, All Rights Reserved.
6 * Author: Marc Zyngier <marc.zyngier@arm.com>
9 #include <linux/device.h>
10 #include <linux/idr.h>
11 #include <linux/irq.h>
12 #include <linux/irqdomain.h>
13 #include <linux/msi.h>
14 #include <linux/slab.h>
16 #define DEV_ID_SHIFT 21
17 #define MAX_DEV_MSIS (1 << (32 - DEV_ID_SHIFT))
20 * Internal data structure containing a (made up, but unique) devid
21 * and the callback to write the MSI message.
23 struct platform_msi_priv_data {
26 const struct attribute_group **msi_irq_groups;
28 irq_write_msi_msg_t write_msg;
32 /* The devid allocator */
33 static DEFINE_IDA(platform_msi_devid_ida);
35 #ifdef GENERIC_MSI_DOMAIN_OPS
37 * Convert an msi_desc to a globaly unique identifier (per-device
38 * devid + msi_desc position in the msi_list).
40 static irq_hw_number_t platform_msi_calc_hwirq(struct msi_desc *desc)
44 devid = desc->platform.msi_priv_data->devid;
46 return (devid << (32 - DEV_ID_SHIFT)) | desc->platform.msi_index;
49 static void platform_msi_set_desc(msi_alloc_info_t *arg, struct msi_desc *desc)
52 arg->hwirq = platform_msi_calc_hwirq(desc);
55 static int platform_msi_init(struct irq_domain *domain,
56 struct msi_domain_info *info,
57 unsigned int virq, irq_hw_number_t hwirq,
58 msi_alloc_info_t *arg)
60 return irq_domain_set_hwirq_and_chip(domain, virq, hwirq,
61 info->chip, info->chip_data);
64 static void platform_msi_set_proxy_dev(msi_alloc_info_t *arg)
66 arg->flags |= MSI_ALLOC_FLAGS_PROXY_DEVICE;
69 #define platform_msi_set_desc NULL
70 #define platform_msi_init NULL
71 #define platform_msi_set_proxy_dev(x) do {} while(0)
74 static void platform_msi_update_dom_ops(struct msi_domain_info *info)
76 struct msi_domain_ops *ops = info->ops;
80 if (ops->msi_init == NULL)
81 ops->msi_init = platform_msi_init;
82 if (ops->set_desc == NULL)
83 ops->set_desc = platform_msi_set_desc;
86 static void platform_msi_write_msg(struct irq_data *data, struct msi_msg *msg)
88 struct msi_desc *desc = irq_data_get_msi_desc(data);
89 struct platform_msi_priv_data *priv_data;
91 priv_data = desc->platform.msi_priv_data;
93 priv_data->write_msg(desc, msg);
96 static void platform_msi_update_chip_ops(struct msi_domain_info *info)
98 struct irq_chip *chip = info->chip;
102 chip->irq_mask = irq_chip_mask_parent;
103 if (!chip->irq_unmask)
104 chip->irq_unmask = irq_chip_unmask_parent;
106 chip->irq_eoi = irq_chip_eoi_parent;
107 if (!chip->irq_set_affinity)
108 chip->irq_set_affinity = msi_domain_set_affinity;
109 if (!chip->irq_write_msi_msg)
110 chip->irq_write_msi_msg = platform_msi_write_msg;
111 if (WARN_ON((info->flags & MSI_FLAG_LEVEL_CAPABLE) &&
112 !(chip->flags & IRQCHIP_SUPPORTS_LEVEL_MSI)))
113 info->flags &= ~MSI_FLAG_LEVEL_CAPABLE;
116 static void platform_msi_free_descs(struct device *dev, int base, int nvec)
118 struct msi_desc *desc, *tmp;
120 list_for_each_entry_safe(desc, tmp, dev_to_msi_list(dev), list) {
121 if (desc->platform.msi_index >= base &&
122 desc->platform.msi_index < (base + nvec)) {
123 list_del(&desc->list);
124 free_msi_entry(desc);
129 static int platform_msi_alloc_descs_with_irq(struct device *dev, int virq,
131 struct platform_msi_priv_data *data)
134 struct msi_desc *desc;
137 if (!list_empty(dev_to_msi_list(dev))) {
138 desc = list_last_entry(dev_to_msi_list(dev),
139 struct msi_desc, list);
140 base = desc->platform.msi_index + 1;
143 for (i = 0; i < nvec; i++) {
144 desc = alloc_msi_entry(dev, 1, NULL);
148 desc->platform.msi_priv_data = data;
149 desc->platform.msi_index = base + i;
150 desc->irq = virq ? virq + i : 0;
152 list_add_tail(&desc->list, dev_to_msi_list(dev));
156 /* Clean up the mess */
157 platform_msi_free_descs(dev, base, nvec);
165 static int platform_msi_alloc_descs(struct device *dev, int nvec,
166 struct platform_msi_priv_data *data)
169 return platform_msi_alloc_descs_with_irq(dev, 0, nvec, data);
173 * platform_msi_create_irq_domain - Create a platform MSI interrupt domain
174 * @fwnode: Optional fwnode of the interrupt controller
175 * @info: MSI domain info
176 * @parent: Parent irq domain
178 * Updates the domain and chip ops and creates a platform MSI
182 * A domain pointer or NULL in case of failure.
184 struct irq_domain *platform_msi_create_irq_domain(struct fwnode_handle *fwnode,
185 struct msi_domain_info *info,
186 struct irq_domain *parent)
188 struct irq_domain *domain;
190 if (info->flags & MSI_FLAG_USE_DEF_DOM_OPS)
191 platform_msi_update_dom_ops(info);
192 if (info->flags & MSI_FLAG_USE_DEF_CHIP_OPS)
193 platform_msi_update_chip_ops(info);
195 domain = msi_create_irq_domain(fwnode, info, parent);
197 irq_domain_update_bus_token(domain, DOMAIN_BUS_PLATFORM_MSI);
202 static struct platform_msi_priv_data *
203 platform_msi_alloc_priv_data(struct device *dev, unsigned int nvec,
204 irq_write_msi_msg_t write_msi_msg)
206 struct platform_msi_priv_data *datap;
210 * Limit the number of interrupts to 2048 per device. Should we
211 * need to bump this up, DEV_ID_SHIFT should be adjusted
212 * accordingly (which would impact the max number of MSI
215 if (!dev->msi.domain || !write_msi_msg || !nvec || nvec > MAX_DEV_MSIS)
216 return ERR_PTR(-EINVAL);
218 if (dev->msi.domain->bus_token != DOMAIN_BUS_PLATFORM_MSI) {
219 dev_err(dev, "Incompatible msi_domain, giving up\n");
220 return ERR_PTR(-EINVAL);
223 err = msi_setup_device_data(dev);
227 /* Already had a helping of MSI? Greed... */
228 if (!list_empty(dev_to_msi_list(dev)))
229 return ERR_PTR(-EBUSY);
231 datap = kzalloc(sizeof(*datap), GFP_KERNEL);
233 return ERR_PTR(-ENOMEM);
235 datap->devid = ida_simple_get(&platform_msi_devid_ida,
236 0, 1 << DEV_ID_SHIFT, GFP_KERNEL);
237 if (datap->devid < 0) {
243 datap->write_msg = write_msi_msg;
249 static void platform_msi_free_priv_data(struct platform_msi_priv_data *data)
251 ida_simple_remove(&platform_msi_devid_ida, data->devid);
256 * platform_msi_domain_alloc_irqs - Allocate MSI interrupts for @dev
257 * @dev: The device for which to allocate interrupts
258 * @nvec: The number of interrupts to allocate
259 * @write_msi_msg: Callback to write an interrupt message for @dev
262 * Zero for success, or an error code in case of failure
264 int platform_msi_domain_alloc_irqs(struct device *dev, unsigned int nvec,
265 irq_write_msi_msg_t write_msi_msg)
267 struct platform_msi_priv_data *priv_data;
270 priv_data = platform_msi_alloc_priv_data(dev, nvec, write_msi_msg);
271 if (IS_ERR(priv_data))
272 return PTR_ERR(priv_data);
274 err = platform_msi_alloc_descs(dev, nvec, priv_data);
276 goto out_free_priv_data;
278 err = msi_domain_alloc_irqs(dev->msi.domain, dev, nvec);
282 priv_data->msi_irq_groups = msi_populate_sysfs(dev);
283 if (IS_ERR(priv_data->msi_irq_groups)) {
284 err = PTR_ERR(priv_data->msi_irq_groups);
291 msi_domain_free_irqs(dev->msi.domain, dev);
293 platform_msi_free_descs(dev, 0, nvec);
295 platform_msi_free_priv_data(priv_data);
299 EXPORT_SYMBOL_GPL(platform_msi_domain_alloc_irqs);
302 * platform_msi_domain_free_irqs - Free MSI interrupts for @dev
303 * @dev: The device for which to free interrupts
305 void platform_msi_domain_free_irqs(struct device *dev)
307 if (!list_empty(dev_to_msi_list(dev))) {
308 struct msi_desc *desc;
310 desc = first_msi_entry(dev);
311 msi_destroy_sysfs(dev, desc->platform.msi_priv_data->msi_irq_groups);
312 platform_msi_free_priv_data(desc->platform.msi_priv_data);
315 msi_domain_free_irqs(dev->msi.domain, dev);
316 platform_msi_free_descs(dev, 0, MAX_DEV_MSIS);
318 EXPORT_SYMBOL_GPL(platform_msi_domain_free_irqs);
321 * platform_msi_get_host_data - Query the private data associated with
322 * a platform-msi domain
323 * @domain: The platform-msi domain
325 * Returns the private data provided when calling
326 * platform_msi_create_device_domain.
328 void *platform_msi_get_host_data(struct irq_domain *domain)
330 struct platform_msi_priv_data *data = domain->host_data;
331 return data->host_data;
335 * __platform_msi_create_device_domain - Create a platform-msi domain
337 * @dev: The device generating the MSIs
338 * @nvec: The number of MSIs that need to be allocated
339 * @is_tree: flag to indicate tree hierarchy
340 * @write_msi_msg: Callback to write an interrupt message for @dev
341 * @ops: The hierarchy domain operations to use
342 * @host_data: Private data associated to this domain
344 * Returns an irqdomain for @nvec interrupts
347 __platform_msi_create_device_domain(struct device *dev,
350 irq_write_msi_msg_t write_msi_msg,
351 const struct irq_domain_ops *ops,
354 struct platform_msi_priv_data *data;
355 struct irq_domain *domain;
358 data = platform_msi_alloc_priv_data(dev, nvec, write_msi_msg);
362 data->host_data = host_data;
363 domain = irq_domain_create_hierarchy(dev->msi.domain, 0,
365 dev->fwnode, ops, data);
369 platform_msi_set_proxy_dev(&data->arg);
370 err = msi_domain_prepare_irqs(domain->parent, dev, nvec, &data->arg);
377 irq_domain_remove(domain);
379 platform_msi_free_priv_data(data);
384 * platform_msi_domain_free - Free interrupts associated with a platform-msi
387 * @domain: The platform-msi domain
388 * @virq: The base irq from which to perform the free operation
389 * @nvec: How many interrupts to free from @virq
391 void platform_msi_domain_free(struct irq_domain *domain, unsigned int virq,
394 struct platform_msi_priv_data *data = domain->host_data;
395 struct msi_desc *desc, *tmp;
396 for_each_msi_entry_safe(desc, tmp, data->dev) {
397 if (WARN_ON(!desc->irq || desc->nvec_used != 1))
399 if (!(desc->irq >= virq && desc->irq < (virq + nvec)))
402 irq_domain_free_irqs_common(domain, desc->irq, 1);
403 list_del(&desc->list);
404 free_msi_entry(desc);
409 * platform_msi_domain_alloc - Allocate interrupts associated with
410 * a platform-msi domain
412 * @domain: The platform-msi domain
413 * @virq: The base irq from which to perform the allocate operation
414 * @nr_irqs: How many interrupts to free from @virq
416 * Return 0 on success, or an error code on failure. Must be called
417 * with irq_domain_mutex held (which can only be done as part of a
418 * top-level interrupt allocation).
420 int platform_msi_domain_alloc(struct irq_domain *domain, unsigned int virq,
421 unsigned int nr_irqs)
423 struct platform_msi_priv_data *data = domain->host_data;
426 err = platform_msi_alloc_descs_with_irq(data->dev, virq, nr_irqs, data);
430 err = msi_domain_populate_irqs(domain->parent, data->dev,
431 virq, nr_irqs, &data->arg);
433 platform_msi_domain_free(domain, virq, nr_irqs);