Merge tag 'irqchip-4.19' of git://git.kernel.org/pub/scm/linux/kernel/git/maz/arm-platforms into irq/core

Pull irqchip updates from Marc Zyngier:

- GICv3 ITS LPI allocation revamp
- GICv3 support for hypervisor-enforced LPI range
- GICv3 ITS conversion to raw spinlock

7 files changed, 234 insertions, 108 deletions

diff --git a/drivers/irqchip/irq-gic-v2m.c b/drivers/irqchip/irq-gic-v2m.c
index 0f52d44b3f69..f5fe0100f9ff 100644
--- a/drivers/irqchip/irq-gic-v2m.c
+++ b/drivers/irqchip/irq-gic-v2m.c
@@ -199,7 +199,7 @@ static int gicv2m_irq_domain_alloc(struct irq_domain *domain, unsigned int virq,
 
 fail:
         irq_domain_free_irqs_parent(domain, virq, nr_irqs);
-        gicv2m_unalloc_msi(v2m, hwirq, get_count_order(nr_irqs));
+        gicv2m_unalloc_msi(v2m, hwirq, nr_irqs);
         return err;
 }
 
diff --git a/drivers/irqchip/irq-gic-v3-its-fsl-mc-msi.c b/drivers/irqchip/irq-gic-v3-its-fsl-mc-msi.c
index 4eca5c763766..606efa64adff 100644
--- a/drivers/irqchip/irq-gic-v3-its-fsl-mc-msi.c
+++ b/drivers/irqchip/irq-gic-v3-its-fsl-mc-msi.c
@@ -45,6 +45,9 @@ static int its_fsl_mc_msi_prepare(struct irq_domain *msi_domain,
          */
         info->scratchpad[0].ul = mc_bus_dev->icid;
         msi_info = msi_get_domain_info(msi_domain->parent);
+
+        /* Allocate at least 32 MSIs, and always as a power of 2 */
+        nvec = max_t(int, 32, roundup_pow_of_two(nvec));
         return msi_info->ops->msi_prepare(msi_domain->parent, dev, nvec, info);
 }
 
diff --git a/drivers/irqchip/irq-gic-v3-its-pci-msi.c b/drivers/irqchip/irq-gic-v3-its-pci-msi.c
index 25a98de5cfb2..8d6d009d1d58 100644
--- a/drivers/irqchip/irq-gic-v3-its-pci-msi.c
+++ b/drivers/irqchip/irq-gic-v3-its-pci-msi.c
@@ -66,7 +66,7 @@ static int its_pci_msi_prepare(struct irq_domain *domain, struct device *dev,
 {
         struct pci_dev *pdev, *alias_dev;
         struct msi_domain_info *msi_info;
-        int alias_count = 0;
+        int alias_count = 0, minnvec = 1;
 
         if (!dev_is_pci(dev))
                 return -EINVAL;
@@ -86,8 +86,18 @@ static int its_pci_msi_prepare(struct irq_domain *domain, struct device *dev,
         /* ITS specific DeviceID, as the core ITS ignores dev. */
         info->scratchpad[0].ul = pci_msi_domain_get_msi_rid(domain, pdev);
 
-        return msi_info->ops->msi_prepare(domain->parent,
-                                          dev, max(nvec, alias_count), info);
+        /*
+         * Always allocate a power of 2, and special case device 0 for
+         * broken systems where the DevID is not wired (and all devices
+         * appear as DevID 0). For that reason, we generously allocate a
+         * minimum of 32 MSIs for DevID 0. If you want more because all
+         * your devices are aliasing to DevID 0, consider fixing your HW.
+         */
+        nvec = max(nvec, alias_count);
+        if (!info->scratchpad[0].ul)
+                minnvec = 32;
+        nvec = max_t(int, minnvec, roundup_pow_of_two(nvec));
+        return msi_info->ops->msi_prepare(domain->parent, dev, nvec, info);
 }
 
 static struct msi_domain_ops its_pci_msi_ops = {
diff --git a/drivers/irqchip/irq-gic-v3-its-platform-msi.c b/drivers/irqchip/irq-gic-v3-its-platform-msi.c
index 8881a053c173..7b8e87b493fe 100644
--- a/drivers/irqchip/irq-gic-v3-its-platform-msi.c
+++ b/drivers/irqchip/irq-gic-v3-its-platform-msi.c
@@ -73,6 +73,8 @@ static int its_pmsi_prepare(struct irq_domain *domain, struct device *dev,
         /* ITS specific DeviceID, as the core ITS ignores dev. */
         info->scratchpad[0].ul = dev_id;
 
+        /* Allocate at least 32 MSIs, and always as a power of 2 */
+        nvec = max_t(int, 32, roundup_pow_of_two(nvec));
         return msi_info->ops->msi_prepare(domain->parent,
                                           dev, nvec, info);
 }
diff --git a/drivers/irqchip/irq-gic-v3-its.c b/drivers/irqchip/irq-gic-v3-its.c
index 5377d7e2afba..316a57530f6d 100644
--- a/drivers/irqchip/irq-gic-v3-its.c
+++ b/drivers/irqchip/irq-gic-v3-its.c
@@ -23,6 +23,8 @@
 #include <linux/dma-iommu.h>
 #include <linux/interrupt.h>
 #include <linux/irqdomain.h>
+#include <linux/list.h>
+#include <linux/list_sort.h>
 #include <linux/log2.h>
 #include <linux/mm.h>
 #include <linux/msi.h>
@@ -160,7 +162,7 @@ static struct {
 } vpe_proxy;
 
 static LIST_HEAD(its_nodes);
-static DEFINE_SPINLOCK(its_lock);
+static DEFINE_RAW_SPINLOCK(its_lock);
 static struct rdists *gic_rdists;
 static struct irq_domain *its_parent;
 
@@ -182,6 +184,22 @@ static struct its_collection *dev_event_to_col(struct its_device *its_dev,
         return its->collections + its_dev->event_map.col_map[event];
 }
 
+static struct its_collection *valid_col(struct its_collection *col)
+{
+        if (WARN_ON_ONCE(col->target_address & GENMASK_ULL(0, 15)))
+                return NULL;
+
+        return col;
+}
+
+static struct its_vpe *valid_vpe(struct its_node *its, struct its_vpe *vpe)
+{
+        if (valid_col(its->collections + vpe->col_idx))
+                return vpe;
+
+        return NULL;
+}
+
 /*
  * ITS command descriptors - parameters to be encoded in a command
  * block.
@@ -439,7 +457,7 @@ static struct its_collection *its_build_mapti_cmd(struct its_node *its,
 
         its_fixup_cmd(cmd);
 
-        return col;
+        return valid_col(col);
 }
 
 static struct its_collection *its_build_movi_cmd(struct its_node *its,
@@ -458,7 +476,7 @@ static struct its_collection *its_build_movi_cmd(struct its_node *its,
 
         its_fixup_cmd(cmd);
 
-        return col;
+        return valid_col(col);
 }
 
 static struct its_collection *its_build_discard_cmd(struct its_node *its,
@@ -476,7 +494,7 @@ static struct its_collection *its_build_discard_cmd(struct its_node *its,
 
         its_fixup_cmd(cmd);
 
-        return col;
+        return valid_col(col);
 }
 
 static struct its_collection *its_build_inv_cmd(struct its_node *its,
@@ -494,7 +512,7 @@ static struct its_collection *its_build_inv_cmd(struct its_node *its,
 
         its_fixup_cmd(cmd);
 
-        return col;
+        return valid_col(col);
 }
 
 static struct its_collection *its_build_int_cmd(struct its_node *its,
@@ -512,7 +530,7 @@ static struct its_collection *its_build_int_cmd(struct its_node *its,
 
         its_fixup_cmd(cmd);
 
-        return col;
+        return valid_col(col);
 }
 
 static struct its_collection *its_build_clear_cmd(struct its_node *its,
@@ -530,7 +548,7 @@ static struct its_collection *its_build_clear_cmd(struct its_node *its,
 
         its_fixup_cmd(cmd);
 
-        return col;
+        return valid_col(col);
 }
 
 static struct its_collection *its_build_invall_cmd(struct its_node *its,
@@ -554,7 +572,7 @@ static struct its_vpe *its_build_vinvall_cmd(struct its_node *its,
 
         its_fixup_cmd(cmd);
 
-        return desc->its_vinvall_cmd.vpe;
+        return valid_vpe(its, desc->its_vinvall_cmd.vpe);
 }
 
 static struct its_vpe *its_build_vmapp_cmd(struct its_node *its,
@@ -576,7 +594,7 @@ static struct its_vpe *its_build_vmapp_cmd(struct its_node *its,
 
         its_fixup_cmd(cmd);
 
-        return desc->its_vmapp_cmd.vpe;
+        return valid_vpe(its, desc->its_vmapp_cmd.vpe);
 }
 
 static struct its_vpe *its_build_vmapti_cmd(struct its_node *its,
@@ -599,7 +617,7 @@ static struct its_vpe *its_build_vmapti_cmd(struct its_node *its,
 
         its_fixup_cmd(cmd);
 
-        return desc->its_vmapti_cmd.vpe;
+        return valid_vpe(its, desc->its_vmapti_cmd.vpe);
 }
 
 static struct its_vpe *its_build_vmovi_cmd(struct its_node *its,
@@ -622,7 +640,7 @@ static struct its_vpe *its_build_vmovi_cmd(struct its_node *its,
 
         its_fixup_cmd(cmd);
 
-        return desc->its_vmovi_cmd.vpe;
+        return valid_vpe(its, desc->its_vmovi_cmd.vpe);
 }
 
 static struct its_vpe *its_build_vmovp_cmd(struct its_node *its,
@@ -640,7 +658,7 @@ static struct its_vpe *its_build_vmovp_cmd(struct its_node *its,
 
         its_fixup_cmd(cmd);
 
-        return desc->its_vmovp_cmd.vpe;
+        return valid_vpe(its, desc->its_vmovp_cmd.vpe);
 }
 
 static u64 its_cmd_ptr_to_offset(struct its_node *its,
@@ -1405,112 +1423,176 @@ static struct irq_chip its_irq_chip = {
         .irq_set_vcpu_affinity  = its_irq_set_vcpu_affinity,
 };
 
+
 /*
  * How we allocate LPIs:
  *
- * The GIC has id_bits bits for interrupt identifiers. From there, we
- * must subtract 8192 which are reserved for SGIs/PPIs/SPIs. Then, as
- * we allocate LPIs by chunks of 32, we can shift the whole thing by 5
- * bits to the right.
+ * lpi_range_list contains ranges of LPIs that are to available to
+ * allocate from. To allocate LPIs, just pick the first range that
+ * fits the required allocation, and reduce it by the required
+ * amount. Once empty, remove the range from the list.
  *
- * This gives us (((1UL << id_bits) - 8192) >> 5) possible allocations.
+ * To free a range of LPIs, add a free range to the list, sort it and
+ * merge the result if the new range happens to be adjacent to an
+ * already free block.
+ *
+ * The consequence of the above is that allocation is cost is low, but
+ * freeing is expensive. We assumes that freeing rarely occurs.
  */
-#define IRQS_PER_CHUNK_SHIFT    5
-#define IRQS_PER_CHUNK          (1UL << IRQS_PER_CHUNK_SHIFT)
-#define ITS_MAX_LPI_NRBITS      16 /* 64K LPIs */
 
-static unsigned long *lpi_bitmap;
-static u32 lpi_chunks;
-static DEFINE_SPINLOCK(lpi_lock);
+static DEFINE_MUTEX(lpi_range_lock);
+static LIST_HEAD(lpi_range_list);
+
+struct lpi_range {
+        struct list_head        entry;
+        u32                     base_id;
+        u32                     span;
+};
+
+static struct lpi_range *mk_lpi_range(u32 base, u32 span)
+{
+        struct lpi_range *range;
+
+        range = kzalloc(sizeof(*range), GFP_KERNEL);
+        if (range) {
+                INIT_LIST_HEAD(&range->entry);
+                range->base_id = base;
+                range->span = span;
+        }
 
-static int its_lpi_to_chunk(int lpi)
+        return range;
+}
+
+static int lpi_range_cmp(void *priv, struct list_head *a, struct list_head *b)
 {
-        return (lpi - 8192) >> IRQS_PER_CHUNK_SHIFT;
+        struct lpi_range *ra, *rb;
+
+        ra = container_of(a, struct lpi_range, entry);
+        rb = container_of(b, struct lpi_range, entry);
+
+        return rb->base_id - ra->base_id;
 }
 
-static int its_chunk_to_lpi(int chunk)
+static void merge_lpi_ranges(void)
 {
-        return (chunk << IRQS_PER_CHUNK_SHIFT) + 8192;
+        struct lpi_range *range, *tmp;
+
+        list_for_each_entry_safe(range, tmp, &lpi_range_list, entry) {
+                if (!list_is_last(&range->entry, &lpi_range_list) &&
+                    (tmp->base_id == (range->base_id + range->span))) {
+                        tmp->base_id = range->base_id;
+                        tmp->span += range->span;
+                        list_del(&range->entry);
+                        kfree(range);
+                }
+        }
 }
 
-static int __init its_lpi_init(u32 id_bits)
+static int alloc_lpi_range(u32 nr_lpis, u32 *base)
 {
-        lpi_chunks = its_lpi_to_chunk(1UL << id_bits);
+        struct lpi_range *range, *tmp;
+        int err = -ENOSPC;
 
-        lpi_bitmap = kcalloc(BITS_TO_LONGS(lpi_chunks), sizeof(long),
-                             GFP_KERNEL);
-        if (!lpi_bitmap) {
-                lpi_chunks = 0;
-                return -ENOMEM;
+        mutex_lock(&lpi_range_lock);
+
+        list_for_each_entry_safe(range, tmp, &lpi_range_list, entry) {
+                if (range->span >= nr_lpis) {
+                        *base = range->base_id;
+                        range->base_id += nr_lpis;
+                        range->span -= nr_lpis;
+
+                        if (range->span == 0) {
+                                list_del(&range->entry);
+                                kfree(range);
+                        }
+
+                        err = 0;
+                        break;
+                }
         }
 
-        pr_info("ITS: Allocated %d chunks for LPIs\n", (int)lpi_chunks);
-        return 0;
+        mutex_unlock(&lpi_range_lock);
+
+        pr_debug("ITS: alloc %u:%u\n", *base, nr_lpis);
+        return err;
 }
 
-static unsigned long *its_lpi_alloc_chunks(int nr_irqs, int *base, int *nr_ids)
+static int free_lpi_range(u32 base, u32 nr_lpis)
 {
-        unsigned long *bitmap = NULL;
-        int chunk_id;
-        int nr_chunks;
-        int i;
+        struct lpi_range *new;
+        int err = 0;
 
-        nr_chunks = DIV_ROUND_UP(nr_irqs, IRQS_PER_CHUNK);
+        mutex_lock(&lpi_range_lock);
 
-        spin_lock(&lpi_lock);
+        new = mk_lpi_range(base, nr_lpis);
+        if (!new) {
+                err = -ENOMEM;
+                goto out;
+        }
+
+        list_add(&new->entry, &lpi_range_list);
+        list_sort(NULL, &lpi_range_list, lpi_range_cmp);
+        merge_lpi_ranges();
+out:
+        mutex_unlock(&lpi_range_lock);
+        return err;
+}
+
+static int __init its_lpi_init(u32 id_bits)
+{
+        u32 lpis = (1UL << id_bits) - 8192;
+        u32 numlpis;
+        int err;
+
+        numlpis = 1UL << GICD_TYPER_NUM_LPIS(gic_rdists->gicd_typer);
+
+        if (numlpis > 2 && !WARN_ON(numlpis > lpis)) {
+                lpis = numlpis;
+                pr_info("ITS: Using hypervisor restricted LPI range [%u]\n",
+                        lpis);
+        }
+
+        /*
+         * Initializing the allocator is just the same as freeing the
+         * full range of LPIs.
+         */
+        err = free_lpi_range(8192, lpis);
+        pr_debug("ITS: Allocator initialized for %u LPIs\n", lpis);
+        return err;
+}
+
+static unsigned long *its_lpi_alloc(int nr_irqs, u32 *base, int *nr_ids)
+{
+        unsigned long *bitmap = NULL;
+        int err = 0;
 
         do {
-                chunk_id = bitmap_find_next_zero_area(lpi_bitmap, lpi_chunks,
-                                                      0, nr_chunks, 0);
-                if (chunk_id < lpi_chunks)
+                err = alloc_lpi_range(nr_irqs, base);
+                if (!err)
                         break;
 
-                nr_chunks--;
-        } while (nr_chunks > 0);
+                nr_irqs /= 2;
+        } while (nr_irqs > 0);
 
-        if (!nr_chunks)
+        if (err)
                 goto out;
 
-        bitmap = kcalloc(BITS_TO_LONGS(nr_chunks * IRQS_PER_CHUNK),
-                         sizeof(long),
-                         GFP_ATOMIC);
+        bitmap = kcalloc(BITS_TO_LONGS(nr_irqs), sizeof (long), GFP_ATOMIC);
         if (!bitmap)
                 goto out;
 
-        for (i = 0; i < nr_chunks; i++)
-                set_bit(chunk_id + i, lpi_bitmap);
-
-        *base = its_chunk_to_lpi(chunk_id);
-        *nr_ids = nr_chunks * IRQS_PER_CHUNK;
+        *nr_ids = nr_irqs;
 
 out:
-        spin_unlock(&lpi_lock);
-
         if (!bitmap)
                 *base = *nr_ids = 0;
 
         return bitmap;
 }
 
-static void its_lpi_free_chunks(unsigned long *bitmap, int base, int nr_ids)
+static void its_lpi_free(unsigned long *bitmap, u32 base, u32 nr_ids)
 {
-        int lpi;
-
-        spin_lock(&lpi_lock);
-
-        for (lpi = base; lpi < (base + nr_ids); lpi += IRQS_PER_CHUNK) {
-                int chunk = its_lpi_to_chunk(lpi);
-
-                BUG_ON(chunk > lpi_chunks);
-                if (test_bit(chunk, lpi_bitmap)) {
-                        clear_bit(chunk, lpi_bitmap);
-                } else {
-                        pr_err("Bad LPI chunk %d\n", chunk);
-                }
-        }
-
-        spin_unlock(&lpi_lock);
-
+        WARN_ON(free_lpi_range(base, nr_ids));
         kfree(bitmap);
 }
 
@@ -1543,7 +1625,7 @@ static int __init its_alloc_lpi_tables(void)
 {
         phys_addr_t paddr;
 
-        lpi_id_bits = min_t(u32, gic_rdists->id_bits, ITS_MAX_LPI_NRBITS);
+        lpi_id_bits = GICD_TYPER_ID_BITS(gic_rdists->gicd_typer);
         gic_rdists->prop_page = its_allocate_prop_table(GFP_NOWAIT);
         if (!gic_rdists->prop_page) {
                 pr_err("Failed to allocate PROPBASE\n");
@@ -1824,11 +1906,16 @@ static int its_alloc_tables(struct its_node *its)
 
 static int its_alloc_collections(struct its_node *its)
 {
+        int i;
+
         its->collections = kcalloc(nr_cpu_ids, sizeof(*its->collections),
                                    GFP_KERNEL);
         if (!its->collections)
                 return -ENOMEM;
 
+        for (i = 0; i < nr_cpu_ids; i++)
+                its->collections[i].target_address = ~0ULL;
+
         return 0;
 }
 
@@ -1976,12 +2063,12 @@ static void its_cpu_init_collections(void)
 {
         struct its_node *its;
 
-        spin_lock(&its_lock);
+        raw_spin_lock(&its_lock);
 
         list_for_each_entry(its, &its_nodes, entry)
                 its_cpu_init_collection(its);
 
-        spin_unlock(&its_lock);
+        raw_spin_unlock(&its_lock);
 }
 
 static struct its_device *its_find_device(struct its_node *its, u32 dev_id)
@@ -2113,17 +2200,20 @@ static struct its_device *its_create_device(struct its_node *its, u32 dev_id,
         if (!its_alloc_device_table(its, dev_id))
                 return NULL;
 
+        if (WARN_ON(!is_power_of_2(nvecs)))
+                nvecs = roundup_pow_of_two(nvecs);
+
         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
         /*
-         * We allocate at least one chunk worth of LPIs bet device,
-         * and thus that many ITEs. The device may require less though.
+         * Even if the device wants a single LPI, the ITT must be
+         * sized as a power of two (and you need at least one bit...).
          */
-        nr_ites = max(IRQS_PER_CHUNK, roundup_pow_of_two(nvecs));
+        nr_ites = max(2, nvecs);
         sz = nr_ites * its->ite_size;
         sz = max(sz, ITS_ITT_ALIGN) + ITS_ITT_ALIGN - 1;
         itt = kzalloc(sz, GFP_KERNEL);
         if (alloc_lpis) {
-                lpi_map = its_lpi_alloc_chunks(nvecs, &lpi_base, &nr_lpis);
+                lpi_map = its_lpi_alloc(nvecs, &lpi_base, &nr_lpis);
                 if (lpi_map)
                         col_map = kcalloc(nr_lpis, sizeof(*col_map),
                                           GFP_KERNEL);
@@ -2310,7 +2400,14 @@ static int its_irq_domain_activate(struct irq_domain *domain,
                 cpu_mask = cpumask_of_node(its_dev->its->numa_node);
 
         /* Bind the LPI to the first possible CPU */
-        cpu = cpumask_first(cpu_mask);
+        cpu = cpumask_first_and(cpu_mask, cpu_online_mask);
+        if (cpu >= nr_cpu_ids) {
+                if (its_dev->its->flags & ITS_FLAGS_WORKAROUND_CAVIUM_23144)
+                        return -EINVAL;
+
+                cpu = cpumask_first(cpu_online_mask);
+        }
+
         its_dev->event_map.col_map[event] = cpu;
         irq_data_update_effective_affinity(d, cpumask_of(cpu));
 
@@ -2351,9 +2448,9 @@ static void its_irq_domain_free(struct irq_domain *domain, unsigned int virq,
         /* If all interrupts have been freed, start mopping the floor */
         if (bitmap_empty(its_dev->event_map.lpi_map,
                          its_dev->event_map.nr_lpis)) {
-                its_lpi_free_chunks(its_dev->event_map.lpi_map,
-                                    its_dev->event_map.lpi_base,
-                                    its_dev->event_map.nr_lpis);
+                its_lpi_free(its_dev->event_map.lpi_map,
+                             its_dev->event_map.lpi_base,
+                             its_dev->event_map.nr_lpis);
                 kfree(its_dev->event_map.col_map);
 
                 /* Unmap device/itt */
@@ -2752,7 +2849,7 @@ static void its_vpe_irq_domain_free(struct irq_domain *domain,
         }
 
         if (bitmap_empty(vm->db_bitmap, vm->nr_db_lpis)) {
-                its_lpi_free_chunks(vm->db_bitmap, vm->db_lpi_base, vm->nr_db_lpis);
+                its_lpi_free(vm->db_bitmap, vm->db_lpi_base, vm->nr_db_lpis);
                 its_free_prop_table(vm->vprop_page);
         }
 }
@@ -2767,18 +2864,18 @@ static int its_vpe_irq_domain_alloc(struct irq_domain *domain, unsigned int virq
 
         BUG_ON(!vm);
 
-        bitmap = its_lpi_alloc_chunks(nr_irqs, &base, &nr_ids);
+        bitmap = its_lpi_alloc(roundup_pow_of_two(nr_irqs), &base, &nr_ids);
         if (!bitmap)
                 return -ENOMEM;
 
         if (nr_ids < nr_irqs) {
-                its_lpi_free_chunks(bitmap, base, nr_ids);
+                its_lpi_free(bitmap, base, nr_ids);
                 return -ENOMEM;
         }
 
         vprop_page = its_allocate_prop_table(GFP_KERNEL);
         if (!vprop_page) {
-                its_lpi_free_chunks(bitmap, base, nr_ids);
+                its_lpi_free(bitmap, base, nr_ids);
                 return -ENOMEM;
         }
 
@@ -2805,7 +2902,7 @@ static int its_vpe_irq_domain_alloc(struct irq_domain *domain, unsigned int virq
                 if (i > 0)
                         its_vpe_irq_domain_free(domain, virq, i - 1);
 
-                its_lpi_free_chunks(bitmap, base, nr_ids);
+                its_lpi_free(bitmap, base, nr_ids);
                 its_free_prop_table(vprop_page);
         }
 
@@ -3042,7 +3139,7 @@ static int its_save_disable(void)
         struct its_node *its;
         int err = 0;
 
-        spin_lock(&its_lock);
+        raw_spin_lock(&its_lock);
         list_for_each_entry(its, &its_nodes, entry) {
                 void __iomem *base;
 
@@ -3074,7 +3171,7 @@ err:
                         writel_relaxed(its->ctlr_save, base + GITS_CTLR);
                 }
         }
-        spin_unlock(&its_lock);
+        raw_spin_unlock(&its_lock);
 
         return err;
 }
@@ -3084,7 +3181,7 @@ static void its_restore_enable(void)
         struct its_node *its;
         int ret;
 
-        spin_lock(&its_lock);
+        raw_spin_lock(&its_lock);
         list_for_each_entry(its, &its_nodes, entry) {
                 void __iomem *base;
                 int i;
@@ -3136,7 +3233,7 @@ static void its_restore_enable(void)
                     GITS_TYPER_HCC(gic_read_typer(base + GITS_TYPER)))
                         its_cpu_init_collection(its);
         }
-        spin_unlock(&its_lock);
+        raw_spin_unlock(&its_lock);
 }
 
 static struct syscore_ops its_syscore_ops = {
@@ -3370,9 +3467,9 @@ static int __init its_probe_one(struct resource *res,
         if (err)
                 goto out_free_tables;
 
-        spin_lock(&its_lock);
+        raw_spin_lock(&its_lock);
         list_add(&its->entry, &its_nodes);
-        spin_unlock(&its_lock);
+        raw_spin_unlock(&its_lock);
 
         return 0;
 
@@ -3399,6 +3496,16 @@ static int redist_disable_lpis(void)
         u64 timeout = USEC_PER_SEC;
         u64 val;
 
+        /*
+         * If coming via a CPU hotplug event, we don't need to disable
+         * LPIs before trying to re-enable them. They are already
+         * configured and all is well in the world. Detect this case
+         * by checking the allocation of the pending table for the
+         * current CPU.
+         */
+        if (gic_data_rdist()->pend_page)
+                return 0;
+
         if (!gic_rdists_supports_plpis()) {
                 pr_info("CPU%d: LPIs not supported\n", smp_processor_id());
                 return -ENXIO;
diff --git a/drivers/irqchip/irq-gic-v3.c b/drivers/irqchip/irq-gic-v3.c
index 76ea56d779a1..e214181b77b7 100644
--- a/drivers/irqchip/irq-gic-v3.c
+++ b/drivers/irqchip/irq-gic-v3.c
@@ -877,7 +877,7 @@ static struct irq_chip gic_eoimode1_chip = {
         .flags                  = IRQCHIP_SET_TYPE_MASKED,
 };
 
-#define GIC_ID_NR               (1U << gic_data.rdists.id_bits)
+#define GIC_ID_NR       (1U << GICD_TYPER_ID_BITS(gic_data.rdists.gicd_typer))
 
 static int gic_irq_domain_map(struct irq_domain *d, unsigned int irq,
                               irq_hw_number_t hw)
@@ -1091,7 +1091,7 @@ static int __init gic_init_bases(void __iomem *dist_base,
          * The GIC only supports up to 1020 interrupt sources (SGI+PPI+SPI)
          */
         typer = readl_relaxed(gic_data.dist_base + GICD_TYPER);
-        gic_data.rdists.id_bits = GICD_TYPER_ID_BITS(typer);
+        gic_data.rdists.gicd_typer = typer;
         gic_irqs = GICD_TYPER_IRQS(typer);
         if (gic_irqs > 1020)
                 gic_irqs = 1020;
diff --git a/drivers/irqchip/irq-ls-scfg-msi.c b/drivers/irqchip/irq-ls-scfg-msi.c
index 1ec3bfe56693..c671b3212010 100644
--- a/drivers/irqchip/irq-ls-scfg-msi.c
+++ b/drivers/irqchip/irq-ls-scfg-msi.c
@@ -93,8 +93,12 @@ static void ls_scfg_msi_compose_msg(struct irq_data *data, struct msi_msg *msg)
         msg->address_lo = lower_32_bits(msi_data->msiir_addr);
         msg->data = data->hwirq;
 
-        if (msi_affinity_flag)
-                msg->data |= cpumask_first(data->common->affinity);
+        if (msi_affinity_flag) {
+                const struct cpumask *mask;
+
+                mask = irq_data_get_effective_affinity_mask(data);
+                msg->data |= cpumask_first(mask);
+        }
 
         iommu_dma_map_msi_msg(data->irq, msg);
 }
@@ -121,7 +125,7 @@ static int ls_scfg_msi_set_affinity(struct irq_data *irq_data,
                 return -EINVAL;
         }
 
-        cpumask_copy(irq_data->common->affinity, mask);
+        irq_data_update_effective_affinity(irq_data, cpumask_of(cpu));
 
         return IRQ_SET_MASK_OK;
 }