kernel/drivers/irqchip/irq-gic-v2m.c

   1 /*
   2  * ARM GIC v2m MSI(-X) support
   3  * Support for Message Signaled Interrupts for systems that
   4  * implement ARM Generic Interrupt Controller: GICv2m.
   5  *
   6  * Copyright (C) 2014 Advanced Micro Devices, Inc.
   7  * Authors: Suravee Suthikulpanit <suravee.suthikulpanit@amd.com>
   8  *          Harish Kasiviswanathan <harish.kasiviswanathan@amd.com>
   9  *          Brandon Anderson <brandon.anderson@amd.com>
  10  *
  11  * This program is free software; you can redistribute it and/or modify it
  12  * under the terms of the GNU General Public License version 2 as published
  13  * by the Free Software Foundation.
  14  */
  15
  16 #define pr_fmt(fmt) "GICv2m: " fmt
  17
  18 #include <linux/irq.h>
  19 #include <linux/irqdomain.h>
  20 #include <linux/kernel.h>
  21 #include <linux/of_address.h>
  22 #include <linux/of_pci.h>
  23 #include <linux/slab.h>
  24 #include <linux/spinlock.h>
  25
  26 /*
  27 * MSI_TYPER:
  28 *     [31:26] Reserved
  29 *     [25:16] lowest SPI assigned to MSI
  30 *     [15:10] Reserved
  31 *     [9:0]   Numer of SPIs assigned to MSI
  32 */
  33 #define V2M_MSI_TYPER                  0x008
  34 #define V2M_MSI_TYPER_BASE_SHIFT       16
  35 #define V2M_MSI_TYPER_BASE_MASK        0x3FF
  36 #define V2M_MSI_TYPER_NUM_MASK         0x3FF
  37 #define V2M_MSI_SETSPI_NS              0x040
  38 #define V2M_MIN_SPI                    32
  39 #define V2M_MAX_SPI                    1019
  40
  41 #define V2M_MSI_TYPER_BASE_SPI(x)      \
  42                (((x) >> V2M_MSI_TYPER_BASE_SHIFT) & V2M_MSI_TYPER_BASE_MASK)
  43
  44 #define V2M_MSI_TYPER_NUM_SPI(x)       ((x) & V2M_MSI_TYPER_NUM_MASK)
  45
  46 struct v2m_data {
  47         spinlock_t msi_cnt_lock;
  48         struct msi_controller mchip;
  49         struct resource res;    /* GICv2m resource */
  50         void __iomem *base;     /* GICv2m virt address */
  51         u32 spi_start;          /* The SPI number that MSIs start */
  52         u32 nr_spis;            /* The number of SPIs for MSIs */
  53         unsigned long *bm;      /* MSI vector bitmap */
  54         struct irq_domain *domain;
  55 };
  56
  57 static void gicv2m_mask_msi_irq(struct irq_data *d)
  58 {
  59         pci_msi_mask_irq(d);
  60         irq_chip_mask_parent(d);
  61 }
  62
  63 static void gicv2m_unmask_msi_irq(struct irq_data *d)
  64 {
  65         pci_msi_unmask_irq(d);
  66         irq_chip_unmask_parent(d);
  67 }
  68
  69 static struct irq_chip gicv2m_msi_irq_chip = {
  70         .name                   = "MSI",
  71         .irq_mask               = gicv2m_mask_msi_irq,
  72         .irq_unmask             = gicv2m_unmask_msi_irq,
  73         .irq_eoi                = irq_chip_eoi_parent,
  74         .irq_write_msi_msg      = pci_msi_domain_write_msg,
  75 };
  76
  77 static struct msi_domain_info gicv2m_msi_domain_info = {
  78         .flags  = (MSI_FLAG_USE_DEF_DOM_OPS | MSI_FLAG_USE_DEF_CHIP_OPS |
  79                    MSI_FLAG_PCI_MSIX),
  80         .chip   = &gicv2m_msi_irq_chip,
  81 };
  82
  83 static int gicv2m_set_affinity(struct irq_data *irq_data,
  84                                const struct cpumask *mask, bool force)
  85 {
  86         int ret;
  87
  88         ret = irq_chip_set_affinity_parent(irq_data, mask, force);
  89         if (ret == IRQ_SET_MASK_OK)
  90                 ret = IRQ_SET_MASK_OK_DONE;
  91
  92         return ret;
  93 }
  94
  95 static void gicv2m_compose_msi_msg(struct irq_data *data, struct msi_msg *msg)
  96 {
  97         struct v2m_data *v2m = irq_data_get_irq_chip_data(data);
  98         phys_addr_t addr = v2m->res.start + V2M_MSI_SETSPI_NS;
  99
 100         msg->address_hi = (u32) (addr >> 32);
 101         msg->address_lo = (u32) (addr);
 102         msg->data = data->hwirq;
 103 }
 104
 105 static struct irq_chip gicv2m_irq_chip = {
 106         .name                   = "GICv2m",
 107         .irq_mask               = irq_chip_mask_parent,
 108         .irq_unmask             = irq_chip_unmask_parent,
 109         .irq_eoi                = irq_chip_eoi_parent,
 110         .irq_set_affinity       = gicv2m_set_affinity,
 111         .irq_compose_msi_msg    = gicv2m_compose_msi_msg,
 112 };
 113
 114 static int gicv2m_irq_gic_domain_alloc(struct irq_domain *domain,
 115                                        unsigned int virq,
 116                                        irq_hw_number_t hwirq)
 117 {
 118         struct of_phandle_args args;
 119         struct irq_data *d;
 120         int err;
 121
 122         args.np = domain->parent->of_node;
 123         args.args_count = 3;
 124         args.args[0] = 0;
 125         args.args[1] = hwirq - 32;
 126         args.args[2] = IRQ_TYPE_EDGE_RISING;
 127
 128         err = irq_domain_alloc_irqs_parent(domain, virq, 1, &args);
 129         if (err)
 130                 return err;
 131
 132         /* Configure the interrupt line to be edge */
 133         d = irq_domain_get_irq_data(domain->parent, virq);
 134         d->chip->irq_set_type(d, IRQ_TYPE_EDGE_RISING);
 135         return 0;
 136 }
 137
 138 static void gicv2m_unalloc_msi(struct v2m_data *v2m, unsigned int hwirq)
 139 {
 140         int pos;
 141
 142         pos = hwirq - v2m->spi_start;
 143         if (pos < 0 || pos >= v2m->nr_spis) {
 144                 pr_err("Failed to teardown msi. Invalid hwirq %d\n", hwirq);
 145                 return;
 146         }
 147
 148         spin_lock(&v2m->msi_cnt_lock);
 149         __clear_bit(pos, v2m->bm);
 150         spin_unlock(&v2m->msi_cnt_lock);
 151 }
 152
 153 static int gicv2m_irq_domain_alloc(struct irq_domain *domain, unsigned int virq,
 154                                    unsigned int nr_irqs, void *args)
 155 {
 156         struct v2m_data *v2m = domain->host_data;
 157         int hwirq, offset, err = 0;
 158
 159         spin_lock(&v2m->msi_cnt_lock);
 160         offset = find_first_zero_bit(v2m->bm, v2m->nr_spis);
 161         if (offset < v2m->nr_spis)
 162                 __set_bit(offset, v2m->bm);
 163         else
 164                 err = -ENOSPC;
 165         spin_unlock(&v2m->msi_cnt_lock);
 166
 167         if (err)
 168                 return err;
 169
 170         hwirq = v2m->spi_start + offset;
 171
 172         err = gicv2m_irq_gic_domain_alloc(domain, virq, hwirq);
 173         if (err) {
 174                 gicv2m_unalloc_msi(v2m, hwirq);
 175                 return err;
 176         }
 177
 178         irq_domain_set_hwirq_and_chip(domain, virq, hwirq,
 179                                       &gicv2m_irq_chip, v2m);
 180
 181         return 0;
 182 }
 183
 184 static void gicv2m_irq_domain_free(struct irq_domain *domain,
 185                                    unsigned int virq, unsigned int nr_irqs)
 186 {
 187         struct irq_data *d = irq_domain_get_irq_data(domain, virq);
 188         struct v2m_data *v2m = irq_data_get_irq_chip_data(d);
 189
 190         BUG_ON(nr_irqs != 1);
 191         gicv2m_unalloc_msi(v2m, d->hwirq);
 192         irq_domain_free_irqs_parent(domain, virq, nr_irqs);
 193 }
 194
 195 static const struct irq_domain_ops gicv2m_domain_ops = {
 196         .alloc                  = gicv2m_irq_domain_alloc,
 197         .free                   = gicv2m_irq_domain_free,
 198 };
 199
 200 static bool is_msi_spi_valid(u32 base, u32 num)
 201 {
 202         if (base < V2M_MIN_SPI) {
 203                 pr_err("Invalid MSI base SPI (base:%u)\n", base);
 204                 return false;
 205         }
 206
 207         if ((num == 0) || (base + num > V2M_MAX_SPI)) {
 208                 pr_err("Number of SPIs (%u) exceed maximum (%u)\n",
 209                        num, V2M_MAX_SPI - V2M_MIN_SPI + 1);
 210                 return false;
 211         }
 212
 213         return true;
 214 }
 215
 216 static int __init gicv2m_init_one(struct device_node *node,
 217                                   struct irq_domain *parent)
 218 {
 219         int ret;
 220         struct v2m_data *v2m;
 221
 222         v2m = kzalloc(sizeof(struct v2m_data), GFP_KERNEL);
 223         if (!v2m) {
 224                 pr_err("Failed to allocate struct v2m_data.\n");
 225                 return -ENOMEM;
 226         }
 227
 228         ret = of_address_to_resource(node, 0, &v2m->res);
 229         if (ret) {
 230                 pr_err("Failed to allocate v2m resource.\n");
 231                 goto err_free_v2m;
 232         }
 233
 234         v2m->base = ioremap(v2m->res.start, resource_size(&v2m->res));
 235         if (!v2m->base) {
 236                 pr_err("Failed to map GICv2m resource\n");
 237                 ret = -ENOMEM;
 238                 goto err_free_v2m;
 239         }
 240
 241         if (!of_property_read_u32(node, "arm,msi-base-spi", &v2m->spi_start) &&
 242             !of_property_read_u32(node, "arm,msi-num-spis", &v2m->nr_spis)) {
 243                 pr_info("Overriding V2M MSI_TYPER (base:%u, num:%u)\n",
 244                         v2m->spi_start, v2m->nr_spis);
 245         } else {
 246                 u32 typer = readl_relaxed(v2m->base + V2M_MSI_TYPER);
 247
 248                 v2m->spi_start = V2M_MSI_TYPER_BASE_SPI(typer);
 249                 v2m->nr_spis = V2M_MSI_TYPER_NUM_SPI(typer);
 250         }
 251
 252         if (!is_msi_spi_valid(v2m->spi_start, v2m->nr_spis)) {
 253                 ret = -EINVAL;
 254                 goto err_iounmap;
 255         }
 256
 257         v2m->bm = kzalloc(sizeof(long) * BITS_TO_LONGS(v2m->nr_spis),
 258                           GFP_KERNEL);
 259         if (!v2m->bm) {
 260                 ret = -ENOMEM;
 261                 goto err_iounmap;
 262         }
 263
 264         v2m->domain = irq_domain_add_tree(NULL, &gicv2m_domain_ops, v2m);
 265         if (!v2m->domain) {
 266                 pr_err("Failed to create GICv2m domain\n");
 267                 ret = -ENOMEM;
 268                 goto err_free_bm;
 269         }
 270
 271         v2m->domain->parent = parent;
 272         v2m->mchip.of_node = node;
 273         v2m->mchip.domain = pci_msi_create_irq_domain(node,
 274                                                       &gicv2m_msi_domain_info,
 275                                                       v2m->domain);
 276         if (!v2m->mchip.domain) {
 277                 pr_err("Failed to create MSI domain\n");
 278                 ret = -ENOMEM;
 279                 goto err_free_domains;
 280         }
 281
 282         spin_lock_init(&v2m->msi_cnt_lock);
 283
 284         ret = of_pci_msi_chip_add(&v2m->mchip);
 285         if (ret) {
 286                 pr_err("Failed to add msi_chip.\n");
 287                 goto err_free_domains;
 288         }
 289
 290         pr_info("Node %s: range[%#lx:%#lx], SPI[%d:%d]\n", node->name,
 291                 (unsigned long)v2m->res.start, (unsigned long)v2m->res.end,
 292                 v2m->spi_start, (v2m->spi_start + v2m->nr_spis));
 293
 294         return 0;
 295
 296 err_free_domains:
 297         if (v2m->mchip.domain)
 298                 irq_domain_remove(v2m->mchip.domain);
 299         if (v2m->domain)
 300                 irq_domain_remove(v2m->domain);
 301 err_free_bm:
 302         kfree(v2m->bm);
 303 err_iounmap:
 304         iounmap(v2m->base);
 305 err_free_v2m:
 306         kfree(v2m);
 307         return ret;
 308 }
 309
 310 static struct of_device_id gicv2m_device_id[] = {
 311         {       .compatible     = "arm,gic-v2m-frame",  },
 312         {},
 313 };
 314
 315 int __init gicv2m_of_init(struct device_node *node, struct irq_domain *parent)
 316 {
 317         int ret = 0;
 318         struct device_node *child;
 319
 320         for (child = of_find_matching_node(node, gicv2m_device_id); child;
 321              child = of_find_matching_node(child, gicv2m_device_id)) {
 322                 if (!of_find_property(child, "msi-controller", NULL))
 323                         continue;
 324
 325                 ret = gicv2m_init_one(child, parent);
 326                 if (ret) {
 327                         of_node_put(node);
 328                         break;
 329                 }
 330         }
 331
 332         return ret;
 333 }