drivers/irqchip/irq-loongson-pch-msi.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  Copyright (C) 2020, Jiaxun Yang <jiaxun.yang@flygoat.com>
   4  *  Loongson PCH MSI support
   5  */
   6
   7 #define pr_fmt(fmt) "pch-msi: " fmt
   8
   9 #include <linux/irqchip.h>
  10 #include <linux/msi.h>
  11 #include <linux/of.h>
  12 #include <linux/of_address.h>
  13 #include <linux/of_irq.h>
  14 #include <linux/of_pci.h>
  15 #include <linux/pci.h>
  16 #include <linux/slab.h>
  17
  18 #include "irq-msi-lib.h"
  19 #include "irq-loongson.h"
  20
  21 static int nr_pics;
  22
  23 struct pch_msi_data {
  24         struct mutex    msi_map_lock;
  25         phys_addr_t     doorbell;
  26         u32             irq_first;      /* The vector number that MSIs starts */
  27         u32             num_irqs;       /* The number of vectors for MSIs */
  28         unsigned long   *msi_map;
  29 };
  30
  31 static struct fwnode_handle *pch_msi_handle[MAX_IO_PICS];
  32
  33 static int pch_msi_allocate_hwirq(struct pch_msi_data *priv, int num_req)
  34 {
  35         int first;
  36
  37         mutex_lock(&priv->msi_map_lock);
  38
  39         first = bitmap_find_free_region(priv->msi_map, priv->num_irqs,
  40                                         get_count_order(num_req));
  41         if (first < 0) {
  42                 mutex_unlock(&priv->msi_map_lock);
  43                 return -ENOSPC;
  44         }
  45
  46         mutex_unlock(&priv->msi_map_lock);
  47
  48         return priv->irq_first + first;
  49 }
  50
  51 static void pch_msi_free_hwirq(struct pch_msi_data *priv,
  52                                 int hwirq, int num_req)
  53 {
  54         int first = hwirq - priv->irq_first;
  55
  56         mutex_lock(&priv->msi_map_lock);
  57         bitmap_release_region(priv->msi_map, first, get_count_order(num_req));
  58         mutex_unlock(&priv->msi_map_lock);
  59 }
  60
  61 static void pch_msi_compose_msi_msg(struct irq_data *data,
  62                                         struct msi_msg *msg)
  63 {
  64         struct pch_msi_data *priv = irq_data_get_irq_chip_data(data);
  65
  66         msg->address_hi = upper_32_bits(priv->doorbell);
  67         msg->address_lo = lower_32_bits(priv->doorbell);
  68         msg->data = data->hwirq;
  69 }
  70
  71 static struct irq_chip middle_irq_chip = {
  72         .name                   = "PCH MSI",
  73         .irq_mask               = irq_chip_mask_parent,
  74         .irq_unmask             = irq_chip_unmask_parent,
  75         .irq_ack                = irq_chip_ack_parent,
  76         .irq_set_affinity       = irq_chip_set_affinity_parent,
  77         .irq_compose_msi_msg    = pch_msi_compose_msi_msg,
  78 };
  79
  80 static int pch_msi_parent_domain_alloc(struct irq_domain *domain,
  81                                         unsigned int virq, int hwirq)
  82 {
  83         struct irq_fwspec fwspec;
  84
  85         fwspec.fwnode = domain->parent->fwnode;
  86         fwspec.param_count = 1;
  87         fwspec.param[0] = hwirq;
  88
  89         return irq_domain_alloc_irqs_parent(domain, virq, 1, &fwspec);
  90 }
  91
  92 static int pch_msi_middle_domain_alloc(struct irq_domain *domain,
  93                                            unsigned int virq,
  94                                            unsigned int nr_irqs, void *args)
  95 {
  96         struct pch_msi_data *priv = domain->host_data;
  97         int hwirq, err, i;
  98
  99         hwirq = pch_msi_allocate_hwirq(priv, nr_irqs);
 100         if (hwirq < 0)
 101                 return hwirq;
 102
 103         for (i = 0; i < nr_irqs; i++) {
 104                 err = pch_msi_parent_domain_alloc(domain, virq + i, hwirq + i);
 105                 if (err)
 106                         goto err_hwirq;
 107
 108                 irq_domain_set_hwirq_and_chip(domain, virq + i, hwirq + i,
 109                                               &middle_irq_chip, priv);
 110         }
 111
 112         return 0;
 113
 114 err_hwirq:
 115         pch_msi_free_hwirq(priv, hwirq, nr_irqs);
 116         irq_domain_free_irqs_parent(domain, virq, i);
 117
 118         return err;
 119 }
 120
 121 static void pch_msi_middle_domain_free(struct irq_domain *domain,
 122                                            unsigned int virq,
 123                                            unsigned int nr_irqs)
 124 {
 125         struct irq_data *d = irq_domain_get_irq_data(domain, virq);
 126         struct pch_msi_data *priv = irq_data_get_irq_chip_data(d);
 127
 128         irq_domain_free_irqs_parent(domain, virq, nr_irqs);
 129         pch_msi_free_hwirq(priv, d->hwirq, nr_irqs);
 130 }
 131
 132 static const struct irq_domain_ops pch_msi_middle_domain_ops = {
 133         .alloc  = pch_msi_middle_domain_alloc,
 134         .free   = pch_msi_middle_domain_free,
 135         .select = msi_lib_irq_domain_select,
 136 };
 137
 138 #define PCH_MSI_FLAGS_REQUIRED  (MSI_FLAG_USE_DEF_DOM_OPS |     \
 139                                  MSI_FLAG_USE_DEF_CHIP_OPS |    \
 140                                  MSI_FLAG_PCI_MSI_MASK_PARENT)
 141
 142 #define PCH_MSI_FLAGS_SUPPORTED (MSI_GENERIC_FLAGS_MASK |       \
 143                                  MSI_FLAG_PCI_MSIX      |       \
 144                                  MSI_FLAG_MULTI_PCI_MSI)
 145
 146 static struct msi_parent_ops pch_msi_parent_ops = {
 147         .required_flags         = PCH_MSI_FLAGS_REQUIRED,
 148         .supported_flags        = PCH_MSI_FLAGS_SUPPORTED,
 149         .bus_select_mask        = MATCH_PCI_MSI,
 150         .bus_select_token       = DOMAIN_BUS_NEXUS,
 151         .prefix                 = "PCH-",
 152         .init_dev_msi_info      = msi_lib_init_dev_msi_info,
 153 };
 154
 155 static int pch_msi_init_domains(struct pch_msi_data *priv,
 156                                 struct irq_domain *parent,
 157                                 struct fwnode_handle *domain_handle)
 158 {
 159         struct irq_domain *middle_domain;
 160
 161         middle_domain = irq_domain_create_hierarchy(parent, 0, priv->num_irqs,
 162                                                     domain_handle,
 163                                                     &pch_msi_middle_domain_ops,
 164                                                     priv);
 165         if (!middle_domain) {
 166                 pr_err("Failed to create the MSI middle domain\n");
 167                 return -ENOMEM;
 168         }
 169
 170         irq_domain_update_bus_token(middle_domain, DOMAIN_BUS_NEXUS);
 171
 172         middle_domain->flags |= IRQ_DOMAIN_FLAG_MSI_PARENT;
 173         middle_domain->msi_parent_ops = &pch_msi_parent_ops;
 174
 175         return 0;
 176 }
 177
 178 static int pch_msi_init(phys_addr_t msg_address, int irq_base, int irq_count,
 179                         struct irq_domain *parent_domain, struct fwnode_handle *domain_handle)
 180 {
 181         int ret;
 182         struct pch_msi_data *priv;
 183
 184         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
 185         if (!priv)
 186                 return -ENOMEM;
 187
 188         mutex_init(&priv->msi_map_lock);
 189
 190         priv->doorbell = msg_address;
 191         priv->irq_first = irq_base;
 192         priv->num_irqs = irq_count;
 193
 194         priv->msi_map = bitmap_zalloc(priv->num_irqs, GFP_KERNEL);
 195         if (!priv->msi_map)
 196                 goto err_priv;
 197
 198         pr_debug("Registering %d MSIs, starting at %d\n",
 199                  priv->num_irqs, priv->irq_first);
 200
 201         ret = pch_msi_init_domains(priv, parent_domain, domain_handle);
 202         if (ret)
 203                 goto err_map;
 204
 205         pch_msi_handle[nr_pics++] = domain_handle;
 206         return 0;
 207
 208 err_map:
 209         bitmap_free(priv->msi_map);
 210 err_priv:
 211         kfree(priv);
 212
 213         return -EINVAL;
 214 }
 215
 216 #ifdef CONFIG_OF
 217 static int pch_msi_of_init(struct device_node *node, struct device_node *parent)
 218 {
 219         int err;
 220         int irq_base, irq_count;
 221         struct resource res;
 222         struct irq_domain *parent_domain;
 223
 224         parent_domain = irq_find_host(parent);
 225         if (!parent_domain) {
 226                 pr_err("Failed to find the parent domain\n");
 227                 return -ENXIO;
 228         }
 229
 230         if (of_address_to_resource(node, 0, &res)) {
 231                 pr_err("Failed to allocate resource\n");
 232                 return -EINVAL;
 233         }
 234
 235         if (of_property_read_u32(node, "loongson,msi-base-vec", &irq_base)) {
 236                 pr_err("Unable to parse MSI vec base\n");
 237                 return -EINVAL;
 238         }
 239
 240         if (of_property_read_u32(node, "loongson,msi-num-vecs", &irq_count)) {
 241                 pr_err("Unable to parse MSI vec number\n");
 242                 return -EINVAL;
 243         }
 244
 245         err = pch_msi_init(res.start, irq_base, irq_count, parent_domain, of_node_to_fwnode(node));
 246         if (err < 0)
 247                 return err;
 248
 249         return 0;
 250 }
 251
 252 IRQCHIP_DECLARE(pch_msi, "loongson,pch-msi-1.0", pch_msi_of_init);
 253 #endif
 254
 255 #ifdef CONFIG_ACPI
 256 struct fwnode_handle *get_pch_msi_handle(int pci_segment)
 257 {
 258         if (cpu_has_avecint)
 259                 return pch_msi_handle[0];
 260
 261         for (int i = 0; i < MAX_IO_PICS; i++) {
 262                 if (msi_group[i].pci_segment == pci_segment)
 263                         return pch_msi_handle[i];
 264         }
 265         return pch_msi_handle[0];
 266 }
 267
 268 int __init pch_msi_acpi_init(struct irq_domain *parent, struct acpi_madt_msi_pic *acpi_pchmsi)
 269 {
 270         int ret;
 271         struct fwnode_handle *domain_handle;
 272
 273         domain_handle = irq_domain_alloc_fwnode(&acpi_pchmsi->msg_address);
 274         ret = pch_msi_init(acpi_pchmsi->msg_address, acpi_pchmsi->start,
 275                                 acpi_pchmsi->count, parent, domain_handle);
 276         if (ret < 0)
 277                 irq_domain_free_fwnode(domain_handle);
 278
 279         return ret;
 280 }
 281
 282 int __init pch_msi_acpi_init_avec(struct irq_domain *parent)
 283 {
 284         if (pch_msi_handle[0])
 285                 return 0;
 286
 287         pch_msi_handle[0] = parent->fwnode;
 288         irq_domain_update_bus_token(parent, DOMAIN_BUS_NEXUS);
 289
 290         parent->flags |= IRQ_DOMAIN_FLAG_MSI_PARENT;
 291         parent->msi_parent_ops = &pch_msi_parent_ops;
 292
 293         return 0;
 294 }
 295 #endif