]>
git.proxmox.com Git - mirror_ubuntu-kernels.git/blob - kernel/irq/ipi.c
2 * linux/kernel/irq/ipi.c
4 * Copyright (C) 2015 Imagination Technologies Ltd
5 * Author: Qais Yousef <qais.yousef@imgtec.com>
7 * This file contains driver APIs to the IPI subsystem.
10 #define pr_fmt(fmt) "genirq/ipi: " fmt
12 #include <linux/irqdomain.h>
13 #include <linux/irq.h>
16 * irq_reserve_ipi() - Setup an IPI to destination cpumask
18 * @dest: cpumask of cpus which can receive the IPI
20 * Allocate a virq that can be used to send IPI to any CPU in dest mask.
22 * On success it'll return linux irq number and error code on failure
24 int irq_reserve_ipi(struct irq_domain
*domain
,
25 const struct cpumask
*dest
)
27 unsigned int nr_irqs
, offset
;
28 struct irq_data
*data
;
31 if (!domain
||!irq_domain_is_ipi(domain
)) {
32 pr_warn("Reservation on a non IPI domain\n");
36 if (!cpumask_subset(dest
, cpu_possible_mask
)) {
37 pr_warn("Reservation is not in possible_cpu_mask\n");
41 nr_irqs
= cpumask_weight(dest
);
43 pr_warn("Reservation for empty destination mask\n");
47 if (irq_domain_is_ipi_single(domain
)) {
49 * If the underlying implementation uses a single HW irq on
50 * all cpus then we only need a single Linux irq number for
51 * it. We have no restrictions vs. the destination mask. The
52 * underlying implementation can deal with holes nicely.
60 * The IPI requires a seperate HW irq on each CPU. We require
61 * that the destination mask is consecutive. If an
62 * implementation needs to support holes, it can reserve
65 offset
= cpumask_first(dest
);
67 * Find a hole and if found look for another set bit after the
68 * hole. For now we don't support this scenario.
70 next
= cpumask_next_zero(offset
, dest
);
71 if (next
< nr_cpu_ids
)
72 next
= cpumask_next(next
, dest
);
73 if (next
< nr_cpu_ids
) {
74 pr_warn("Destination mask has holes\n");
79 virq
= irq_domain_alloc_descs(-1, nr_irqs
, 0, NUMA_NO_NODE
, NULL
);
81 pr_warn("Can't reserve IPI, failed to alloc descs\n");
85 virq
= __irq_domain_alloc_irqs(domain
, virq
, nr_irqs
, NUMA_NO_NODE
,
86 (void *) dest
, true, NULL
);
89 pr_warn("Can't reserve IPI, failed to alloc hw irqs\n");
93 for (i
= 0; i
< nr_irqs
; i
++) {
94 data
= irq_get_irq_data(virq
+ i
);
95 cpumask_copy(data
->common
->affinity
, dest
);
96 data
->common
->ipi_offset
= offset
;
97 irq_set_status_flags(virq
+ i
, IRQ_NO_BALANCING
);
102 irq_free_descs(virq
, nr_irqs
);
107 * irq_destroy_ipi() - unreserve an IPI that was previously allocated
108 * @irq: linux irq number to be destroyed
109 * @dest: cpumask of cpus which should have the IPI removed
111 * The IPIs allocated with irq_reserve_ipi() are retuerned to the system
112 * destroying all virqs associated with them.
114 * Return 0 on success or error code on failure.
116 int irq_destroy_ipi(unsigned int irq
, const struct cpumask
*dest
)
118 struct irq_data
*data
= irq_get_irq_data(irq
);
119 struct cpumask
*ipimask
= data
? irq_data_get_affinity_mask(data
) : NULL
;
120 struct irq_domain
*domain
;
121 unsigned int nr_irqs
;
123 if (!irq
|| !data
|| !ipimask
)
126 domain
= data
->domain
;
127 if (WARN_ON(domain
== NULL
))
130 if (!irq_domain_is_ipi(domain
)) {
131 pr_warn("Trying to destroy a non IPI domain!\n");
135 if (WARN_ON(!cpumask_subset(dest
, ipimask
)))
137 * Must be destroying a subset of CPUs to which this IPI
138 * was set up to target
142 if (irq_domain_is_ipi_per_cpu(domain
)) {
143 irq
= irq
+ cpumask_first(dest
) - data
->common
->ipi_offset
;
144 nr_irqs
= cpumask_weight(dest
);
149 irq_domain_free_irqs(irq
, nr_irqs
);
154 * ipi_get_hwirq - Get the hwirq associated with an IPI to a cpu
155 * @irq: linux irq number
156 * @cpu: the target cpu
158 * When dealing with coprocessors IPI, we need to inform the coprocessor of
159 * the hwirq it needs to use to receive and send IPIs.
161 * Returns hwirq value on success and INVALID_HWIRQ on failure.
163 irq_hw_number_t
ipi_get_hwirq(unsigned int irq
, unsigned int cpu
)
165 struct irq_data
*data
= irq_get_irq_data(irq
);
166 struct cpumask
*ipimask
= data
? irq_data_get_affinity_mask(data
) : NULL
;
168 if (!data
|| !ipimask
|| cpu
>= nr_cpu_ids
)
169 return INVALID_HWIRQ
;
171 if (!cpumask_test_cpu(cpu
, ipimask
))
172 return INVALID_HWIRQ
;
175 * Get the real hardware irq number if the underlying implementation
176 * uses a seperate irq per cpu. If the underlying implementation uses
177 * a single hardware irq for all cpus then the IPI send mechanism
178 * needs to take care of the cpu destinations.
180 if (irq_domain_is_ipi_per_cpu(data
->domain
))
181 data
= irq_get_irq_data(irq
+ cpu
- data
->common
->ipi_offset
);
183 return data
? irqd_to_hwirq(data
) : INVALID_HWIRQ
;
185 EXPORT_SYMBOL_GPL(ipi_get_hwirq
);
187 static int ipi_send_verify(struct irq_chip
*chip
, struct irq_data
*data
,
188 const struct cpumask
*dest
, unsigned int cpu
)
190 struct cpumask
*ipimask
= irq_data_get_affinity_mask(data
);
192 if (!chip
|| !ipimask
)
195 if (!chip
->ipi_send_single
&& !chip
->ipi_send_mask
)
198 if (cpu
>= nr_cpu_ids
)
202 if (!cpumask_subset(dest
, ipimask
))
205 if (!cpumask_test_cpu(cpu
, ipimask
))
212 * __ipi_send_single - send an IPI to a target Linux SMP CPU
213 * @desc: pointer to irq_desc of the IRQ
214 * @cpu: destination CPU, must in the destination mask passed to
217 * This function is for architecture or core code to speed up IPI sending. Not
218 * usable from driver code.
220 * Returns zero on success and negative error number on failure.
222 int __ipi_send_single(struct irq_desc
*desc
, unsigned int cpu
)
224 struct irq_data
*data
= irq_desc_get_irq_data(desc
);
225 struct irq_chip
*chip
= irq_data_get_irq_chip(data
);
229 * Minimise the overhead by omitting the checks for Linux SMP IPIs.
230 * Since the callers should be arch or core code which is generally
231 * trusted, only check for errors when debugging.
233 if (WARN_ON_ONCE(ipi_send_verify(chip
, data
, NULL
, cpu
)))
236 if (!chip
->ipi_send_single
) {
237 chip
->ipi_send_mask(data
, cpumask_of(cpu
));
241 /* FIXME: Store this information in irqdata flags */
242 if (irq_domain_is_ipi_per_cpu(data
->domain
) &&
243 cpu
!= data
->common
->ipi_offset
) {
244 /* use the correct data for that cpu */
245 unsigned irq
= data
->irq
+ cpu
- data
->common
->ipi_offset
;
247 data
= irq_get_irq_data(irq
);
249 chip
->ipi_send_single(data
, cpu
);
254 * ipi_send_mask - send an IPI to target Linux SMP CPU(s)
255 * @desc: pointer to irq_desc of the IRQ
256 * @dest: dest CPU(s), must be a subset of the mask passed to
259 * This function is for architecture or core code to speed up IPI sending. Not
260 * usable from driver code.
262 * Returns zero on success and negative error number on failure.
264 int __ipi_send_mask(struct irq_desc
*desc
, const struct cpumask
*dest
)
266 struct irq_data
*data
= irq_desc_get_irq_data(desc
);
267 struct irq_chip
*chip
= irq_data_get_irq_chip(data
);
272 * Minimise the overhead by omitting the checks for Linux SMP IPIs.
273 * Since the callers should be arch or core code which is generally
274 * trusted, only check for errors when debugging.
276 if (WARN_ON_ONCE(ipi_send_verify(chip
, data
, dest
, 0)))
279 if (chip
->ipi_send_mask
) {
280 chip
->ipi_send_mask(data
, dest
);
284 if (irq_domain_is_ipi_per_cpu(data
->domain
)) {
285 unsigned int base
= data
->irq
;
287 for_each_cpu(cpu
, dest
) {
288 unsigned irq
= base
+ cpu
- data
->common
->ipi_offset
;
290 data
= irq_get_irq_data(irq
);
291 chip
->ipi_send_single(data
, cpu
);
294 for_each_cpu(cpu
, dest
)
295 chip
->ipi_send_single(data
, cpu
);
301 * ipi_send_single - Send an IPI to a single CPU
302 * @virq: linux irq number from irq_reserve_ipi()
303 * @cpu: destination CPU, must in the destination mask passed to
306 * Returns zero on success and negative error number on failure.
308 int ipi_send_single(unsigned int virq
, unsigned int cpu
)
310 struct irq_desc
*desc
= irq_to_desc(virq
);
311 struct irq_data
*data
= desc
? irq_desc_get_irq_data(desc
) : NULL
;
312 struct irq_chip
*chip
= data
? irq_data_get_irq_chip(data
) : NULL
;
314 if (WARN_ON_ONCE(ipi_send_verify(chip
, data
, NULL
, cpu
)))
317 return __ipi_send_single(desc
, cpu
);
319 EXPORT_SYMBOL_GPL(ipi_send_single
);
322 * ipi_send_mask - Send an IPI to target CPU(s)
323 * @virq: linux irq number from irq_reserve_ipi()
324 * @dest: dest CPU(s), must be a subset of the mask passed to
327 * Returns zero on success and negative error number on failure.
329 int ipi_send_mask(unsigned int virq
, const struct cpumask
*dest
)
331 struct irq_desc
*desc
= irq_to_desc(virq
);
332 struct irq_data
*data
= desc
? irq_desc_get_irq_data(desc
) : NULL
;
333 struct irq_chip
*chip
= data
? irq_data_get_irq_chip(data
) : NULL
;
335 if (WARN_ON_ONCE(ipi_send_verify(chip
, data
, dest
, 0)))
338 return __ipi_send_mask(desc
, dest
);
340 EXPORT_SYMBOL_GPL(ipi_send_mask
);