kernel/irq/ipi.c

   1 /*
   2  * linux/kernel/irq/ipi.c
   3  *
   4  * Copyright (C) 2015 Imagination Technologies Ltd
   5  * Author: Qais Yousef <qais.yousef@imgtec.com>
   6  *
   7  * This file contains driver APIs to the IPI subsystem.
   8  */
   9
  10 #define pr_fmt(fmt) "genirq/ipi: " fmt
  11
  12 #include <linux/irqdomain.h>
  13 #include <linux/irq.h>
  14
  15 /**
  16  * irq_reserve_ipi() - Setup an IPI to destination cpumask
  17  * @domain:     IPI domain
  18  * @dest:       cpumask of cpus which can receive the IPI
  19  *
  20  * Allocate a virq that can be used to send IPI to any CPU in dest mask.
  21  *
  22  * On success it'll return linux irq number and error code on failure
  23  */
  24 int irq_reserve_ipi(struct irq_domain *domain,
  25                              const struct cpumask *dest)
  26 {
  27         unsigned int nr_irqs, offset;
  28         struct irq_data *data;
  29         int virq, i;
  30
  31         if (!domain ||!irq_domain_is_ipi(domain)) {
  32                 pr_warn("Reservation on a non IPI domain\n");
  33                 return -EINVAL;
  34         }
  35
  36         if (!cpumask_subset(dest, cpu_possible_mask)) {
  37                 pr_warn("Reservation is not in possible_cpu_mask\n");
  38                 return -EINVAL;
  39         }
  40
  41         nr_irqs = cpumask_weight(dest);
  42         if (!nr_irqs) {
  43                 pr_warn("Reservation for empty destination mask\n");
  44                 return -EINVAL;
  45         }
  46
  47         if (irq_domain_is_ipi_single(domain)) {
  48                 /*
  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.
  53                  */
  54                 nr_irqs = 1;
  55                 offset = 0;
  56         } else {
  57                 unsigned int next;
  58
  59                 /*
  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
  63                  * several IPI ranges.
  64                  */
  65                 offset = cpumask_first(dest);
  66                 /*
  67                  * Find a hole and if found look for another set bit after the
  68                  * hole. For now we don't support this scenario.
  69                  */
  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");
  75                         return -EINVAL;
  76                 }
  77         }
  78
  79         virq = irq_domain_alloc_descs(-1, nr_irqs, 0, NUMA_NO_NODE, NULL);
  80         if (virq <= 0) {
  81                 pr_warn("Can't reserve IPI, failed to alloc descs\n");
  82                 return -ENOMEM;
  83         }
  84
  85         virq = __irq_domain_alloc_irqs(domain, virq, nr_irqs, NUMA_NO_NODE,
  86                                        (void *) dest, true, NULL);
  87
  88         if (virq <= 0) {
  89                 pr_warn("Can't reserve IPI, failed to alloc hw irqs\n");
  90                 goto free_descs;
  91         }
  92
  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);
  98         }
  99         return virq;
 100
 101 free_descs:
 102         irq_free_descs(virq, nr_irqs);
 103         return -EBUSY;
 104 }
 105
 106 /**
 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
 110  *
 111  * The IPIs allocated with irq_reserve_ipi() are retuerned to the system
 112  * destroying all virqs associated with them.
 113  *
 114  * Return 0 on success or error code on failure.
 115  */
 116 int irq_destroy_ipi(unsigned int irq, const struct cpumask *dest)
 117 {
 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;
 122
 123         if (!irq || !data || !ipimask)
 124                 return -EINVAL;
 125
 126         domain = data->domain;
 127         if (WARN_ON(domain == NULL))
 128                 return -EINVAL;
 129
 130         if (!irq_domain_is_ipi(domain)) {
 131                 pr_warn("Trying to destroy a non IPI domain!\n");
 132                 return -EINVAL;
 133         }
 134
 135         if (WARN_ON(!cpumask_subset(dest, ipimask)))
 136                 /*
 137                  * Must be destroying a subset of CPUs to which this IPI
 138                  * was set up to target
 139                  */
 140                 return -EINVAL;
 141
 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);
 145         } else {
 146                 nr_irqs = 1;
 147         }
 148
 149         irq_domain_free_irqs(irq, nr_irqs);
 150         return 0;
 151 }
 152
 153 /**
 154  * ipi_get_hwirq - Get the hwirq associated with an IPI to a cpu
 155  * @irq:        linux irq number
 156  * @cpu:        the target cpu
 157  *
 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.
 160  *
 161  * Returns hwirq value on success and INVALID_HWIRQ on failure.
 162  */
 163 irq_hw_number_t ipi_get_hwirq(unsigned int irq, unsigned int cpu)
 164 {
 165         struct irq_data *data = irq_get_irq_data(irq);
 166         struct cpumask *ipimask = data ? irq_data_get_affinity_mask(data) : NULL;
 167
 168         if (!data || !ipimask || cpu > nr_cpu_ids)
 169                 return INVALID_HWIRQ;
 170
 171         if (!cpumask_test_cpu(cpu, ipimask))
 172                 return INVALID_HWIRQ;
 173
 174         /*
 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.
 179          */
 180         if (irq_domain_is_ipi_per_cpu(data->domain))
 181                 data = irq_get_irq_data(irq + cpu - data->common->ipi_offset);
 182
 183         return data ? irqd_to_hwirq(data) : INVALID_HWIRQ;
 184 }
 185 EXPORT_SYMBOL_GPL(ipi_get_hwirq);
 186
 187 static int ipi_send_verify(struct irq_chip *chip, struct irq_data *data,
 188                            const struct cpumask *dest, unsigned int cpu)
 189 {
 190         struct cpumask *ipimask = irq_data_get_affinity_mask(data);
 191
 192         if (!chip || !ipimask)
 193                 return -EINVAL;
 194
 195         if (!chip->ipi_send_single && !chip->ipi_send_mask)
 196                 return -EINVAL;
 197
 198         if (cpu > nr_cpu_ids)
 199                 return -EINVAL;
 200
 201         if (dest) {
 202                 if (!cpumask_subset(dest, ipimask))
 203                         return -EINVAL;
 204         } else {
 205                 if (!cpumask_test_cpu(cpu, ipimask))
 206                         return -EINVAL;
 207         }
 208         return 0;
 209 }
 210
 211 /**
 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
 215  *              irq_reserve_ipi()
 216  *
 217  * This function is for architecture or core code to speed up IPI sending. Not
 218  * usable from driver code.
 219  *
 220  * Returns zero on success and negative error number on failure.
 221  */
 222 int __ipi_send_single(struct irq_desc *desc, unsigned int cpu)
 223 {
 224         struct irq_data *data = irq_desc_get_irq_data(desc);
 225         struct irq_chip *chip = irq_data_get_irq_chip(data);
 226
 227 #ifdef DEBUG
 228         /*
 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.
 232          */
 233         if (WARN_ON_ONCE(ipi_send_verify(chip, data, NULL, cpu)))
 234                 return -EINVAL;
 235 #endif
 236         if (!chip->ipi_send_single) {
 237                 chip->ipi_send_mask(data, cpumask_of(cpu));
 238                 return 0;
 239         }
 240
 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;
 246
 247                 data = irq_get_irq_data(irq);
 248         }
 249         chip->ipi_send_single(data, cpu);
 250         return 0;
 251 }
 252
 253 /**
 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
 257  *              irq_reserve_ipi()
 258  *
 259  * This function is for architecture or core code to speed up IPI sending. Not
 260  * usable from driver code.
 261  *
 262  * Returns zero on success and negative error number on failure.
 263  */
 264 int __ipi_send_mask(struct irq_desc *desc, const struct cpumask *dest)
 265 {
 266         struct irq_data *data = irq_desc_get_irq_data(desc);
 267         struct irq_chip *chip = irq_data_get_irq_chip(data);
 268         unsigned int cpu;
 269
 270 #ifdef DEBUG
 271         /*
 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.
 275          */
 276         if (WARN_ON_ONCE(ipi_send_verify(chip, data, dest, 0)))
 277                 return -EINVAL;
 278 #endif
 279         if (chip->ipi_send_mask) {
 280                 chip->ipi_send_mask(data, dest);
 281                 return 0;
 282         }
 283
 284         if (irq_domain_is_ipi_per_cpu(data->domain)) {
 285                 unsigned int base = data->irq;
 286
 287                 for_each_cpu(cpu, dest) {
 288                         unsigned irq = base + cpu - data->common->ipi_offset;
 289
 290                         data = irq_get_irq_data(irq);
 291                         chip->ipi_send_single(data, cpu);
 292                 }
 293         } else {
 294                 for_each_cpu(cpu, dest)
 295                         chip->ipi_send_single(data, cpu);
 296         }
 297         return 0;
 298 }
 299
 300 /**
 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
 304  *              irq_reserve_ipi()
 305  *
 306  * Returns zero on success and negative error number on failure.
 307  */
 308 int ipi_send_single(unsigned int virq, unsigned int cpu)
 309 {
 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;
 313
 314         if (WARN_ON_ONCE(ipi_send_verify(chip, data, NULL, cpu)))
 315                 return -EINVAL;
 316
 317         return __ipi_send_single(desc, cpu);
 318 }
 319 EXPORT_SYMBOL_GPL(ipi_send_single);
 320
 321 /**
 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
 325  *              irq_reserve_ipi()
 326  *
 327  * Returns zero on success and negative error number on failure.
 328  */
 329 int ipi_send_mask(unsigned int virq, const struct cpumask *dest)
 330 {
 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;
 334
 335         if (WARN_ON_ONCE(ipi_send_verify(chip, data, dest, 0)))
 336                 return -EINVAL;
 337
 338         return __ipi_send_mask(desc, dest);
 339 }
 340 EXPORT_SYMBOL_GPL(ipi_send_mask);