arch/arc/kernel/mcip.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * ARC ARConnect (MultiCore IP) support (formerly known as MCIP)
   4  *
   5  * Copyright (C) 2013 Synopsys, Inc. (www.synopsys.com)
   6  */
   7
   8 #include <linux/smp.h>
   9 #include <linux/irq.h>
  10 #include <linux/irqchip/chained_irq.h>
  11 #include <linux/spinlock.h>
  12 #include <soc/arc/mcip.h>
  13 #include <asm/irqflags-arcv2.h>
  14 #include <asm/setup.h>
  15
  16 static DEFINE_RAW_SPINLOCK(mcip_lock);
  17
  18 #ifdef CONFIG_SMP
  19
  20 static char smp_cpuinfo_buf[128];
  21
  22 /*
  23  * Set mask to halt GFRC if any online core in SMP cluster is halted.
  24  * Only works for ARC HS v3.0+, on earlier versions has no effect.
  25  */
  26 static void mcip_update_gfrc_halt_mask(int cpu)
  27 {
  28         struct bcr_generic gfrc;
  29         unsigned long flags;
  30         u32 gfrc_halt_mask;
  31
  32         READ_BCR(ARC_REG_GFRC_BUILD, gfrc);
  33
  34         /*
  35          * CMD_GFRC_SET_CORE and CMD_GFRC_READ_CORE commands were added in
  36          * GFRC 0x3 version.
  37          */
  38         if (gfrc.ver < 0x3)
  39                 return;
  40
  41         raw_spin_lock_irqsave(&mcip_lock, flags);
  42
  43         __mcip_cmd(CMD_GFRC_READ_CORE, 0);
  44         gfrc_halt_mask = read_aux_reg(ARC_REG_MCIP_READBACK);
  45         gfrc_halt_mask |= BIT(cpu);
  46         __mcip_cmd_data(CMD_GFRC_SET_CORE, 0, gfrc_halt_mask);
  47
  48         raw_spin_unlock_irqrestore(&mcip_lock, flags);
  49 }
  50
  51 static void mcip_update_debug_halt_mask(int cpu)
  52 {
  53         u32 mcip_mask = 0;
  54         unsigned long flags;
  55
  56         raw_spin_lock_irqsave(&mcip_lock, flags);
  57
  58         /*
  59          * mcip_mask is same for CMD_DEBUG_SET_SELECT and CMD_DEBUG_SET_MASK
  60          * commands. So read it once instead of reading both CMD_DEBUG_READ_MASK
  61          * and CMD_DEBUG_READ_SELECT.
  62          */
  63         __mcip_cmd(CMD_DEBUG_READ_SELECT, 0);
  64         mcip_mask = read_aux_reg(ARC_REG_MCIP_READBACK);
  65
  66         mcip_mask |= BIT(cpu);
  67
  68         __mcip_cmd_data(CMD_DEBUG_SET_SELECT, 0, mcip_mask);
  69         /*
  70          * Parameter specified halt cause:
  71          * STATUS32[H]/actionpoint/breakpoint/self-halt
  72          * We choose all of them (0xF).
  73          */
  74         __mcip_cmd_data(CMD_DEBUG_SET_MASK, 0xF, mcip_mask);
  75
  76         raw_spin_unlock_irqrestore(&mcip_lock, flags);
  77 }
  78
  79 static void mcip_setup_per_cpu(int cpu)
  80 {
  81         struct mcip_bcr mp;
  82
  83         READ_BCR(ARC_REG_MCIP_BCR, mp);
  84
  85         smp_ipi_irq_setup(cpu, IPI_IRQ);
  86         smp_ipi_irq_setup(cpu, SOFTIRQ_IRQ);
  87
  88         /* Update GFRC halt mask as new CPU came online */
  89         if (mp.gfrc)
  90                 mcip_update_gfrc_halt_mask(cpu);
  91
  92         /* Update MCIP debug mask as new CPU came online */
  93         if (mp.dbg)
  94                 mcip_update_debug_halt_mask(cpu);
  95 }
  96
  97 static void mcip_ipi_send(int cpu)
  98 {
  99         unsigned long flags;
 100         int ipi_was_pending;
 101
 102         /* ARConnect can only send IPI to others */
 103         if (unlikely(cpu == raw_smp_processor_id())) {
 104                 arc_softirq_trigger(SOFTIRQ_IRQ);
 105                 return;
 106         }
 107
 108         raw_spin_lock_irqsave(&mcip_lock, flags);
 109
 110         /*
 111          * If receiver already has a pending interrupt, elide sending this one.
 112          * Linux cross core calling works well with concurrent IPIs
 113          * coalesced into one
 114          * see arch/arc/kernel/smp.c: ipi_send_msg_one()
 115          */
 116         __mcip_cmd(CMD_INTRPT_READ_STATUS, cpu);
 117         ipi_was_pending = read_aux_reg(ARC_REG_MCIP_READBACK);
 118         if (!ipi_was_pending)
 119                 __mcip_cmd(CMD_INTRPT_GENERATE_IRQ, cpu);
 120
 121         raw_spin_unlock_irqrestore(&mcip_lock, flags);
 122 }
 123
 124 static void mcip_ipi_clear(int irq)
 125 {
 126         unsigned int cpu, c;
 127         unsigned long flags;
 128
 129         if (unlikely(irq == SOFTIRQ_IRQ)) {
 130                 arc_softirq_clear(irq);
 131                 return;
 132         }
 133
 134         raw_spin_lock_irqsave(&mcip_lock, flags);
 135
 136         /* Who sent the IPI */
 137         __mcip_cmd(CMD_INTRPT_CHECK_SOURCE, 0);
 138
 139         cpu = read_aux_reg(ARC_REG_MCIP_READBACK);      /* 1,2,4,8... */
 140
 141         /*
 142          * In rare case, multiple concurrent IPIs sent to same target can
 143          * possibly be coalesced by MCIP into 1 asserted IRQ, so @cpus can be
 144          * "vectored" (multiple bits sets) as opposed to typical single bit
 145          */
 146         do {
 147                 c = __ffs(cpu);                 /* 0,1,2,3 */
 148                 __mcip_cmd(CMD_INTRPT_GENERATE_ACK, c);
 149                 cpu &= ~(1U << c);
 150         } while (cpu);
 151
 152         raw_spin_unlock_irqrestore(&mcip_lock, flags);
 153 }
 154
 155 static void mcip_probe_n_setup(void)
 156 {
 157         struct mcip_bcr mp;
 158
 159         READ_BCR(ARC_REG_MCIP_BCR, mp);
 160
 161         sprintf(smp_cpuinfo_buf,
 162                 "Extn [SMP]\t: ARConnect (v%d): %d cores with %s%s%s%s\n",
 163                 mp.ver, mp.num_cores,
 164                 IS_AVAIL1(mp.ipi, "IPI "),
 165                 IS_AVAIL1(mp.idu, "IDU "),
 166                 IS_AVAIL1(mp.dbg, "DEBUG "),
 167                 IS_AVAIL1(mp.gfrc, "GFRC"));
 168 }
 169
 170 struct plat_smp_ops plat_smp_ops = {
 171         .info           = smp_cpuinfo_buf,
 172         .init_early_smp = mcip_probe_n_setup,
 173         .init_per_cpu   = mcip_setup_per_cpu,
 174         .ipi_send       = mcip_ipi_send,
 175         .ipi_clear      = mcip_ipi_clear,
 176 };
 177
 178 #endif
 179
 180 /***************************************************************************
 181  * ARCv2 Interrupt Distribution Unit (IDU)
 182  *
 183  * Connects external "COMMON" IRQs to core intc, providing:
 184  *  -dynamic routing (IRQ affinity)
 185  *  -load balancing (Round Robin interrupt distribution)
 186  *  -1:N distribution
 187  *
 188  * It physically resides in the MCIP hw block
 189  */
 190
 191 #include <linux/irqchip.h>
 192 #include <linux/of.h>
 193 #include <linux/of_irq.h>
 194
 195 /*
 196  * Set the DEST for @cmn_irq to @cpu_mask (1 bit per core)
 197  */
 198 static void idu_set_dest(unsigned int cmn_irq, unsigned int cpu_mask)
 199 {
 200         __mcip_cmd_data(CMD_IDU_SET_DEST, cmn_irq, cpu_mask);
 201 }
 202
 203 static void idu_set_mode(unsigned int cmn_irq, bool set_lvl, unsigned int lvl,
 204                          bool set_distr, unsigned int distr)
 205 {
 206         union {
 207                 unsigned int word;
 208                 struct {
 209                         unsigned int distr:2, pad:2, lvl:1, pad2:27;
 210                 };
 211         } data;
 212
 213         data.word = __mcip_cmd_read(CMD_IDU_READ_MODE, cmn_irq);
 214         if (set_distr)
 215                 data.distr = distr;
 216         if (set_lvl)
 217                 data.lvl = lvl;
 218         __mcip_cmd_data(CMD_IDU_SET_MODE, cmn_irq, data.word);
 219 }
 220
 221 static void idu_irq_mask_raw(irq_hw_number_t hwirq)
 222 {
 223         unsigned long flags;
 224
 225         raw_spin_lock_irqsave(&mcip_lock, flags);
 226         __mcip_cmd_data(CMD_IDU_SET_MASK, hwirq, 1);
 227         raw_spin_unlock_irqrestore(&mcip_lock, flags);
 228 }
 229
 230 static void idu_irq_mask(struct irq_data *data)
 231 {
 232         idu_irq_mask_raw(data->hwirq);
 233 }
 234
 235 static void idu_irq_unmask(struct irq_data *data)
 236 {
 237         unsigned long flags;
 238
 239         raw_spin_lock_irqsave(&mcip_lock, flags);
 240         __mcip_cmd_data(CMD_IDU_SET_MASK, data->hwirq, 0);
 241         raw_spin_unlock_irqrestore(&mcip_lock, flags);
 242 }
 243
 244 static void idu_irq_ack(struct irq_data *data)
 245 {
 246         unsigned long flags;
 247
 248         raw_spin_lock_irqsave(&mcip_lock, flags);
 249         __mcip_cmd(CMD_IDU_ACK_CIRQ, data->hwirq);
 250         raw_spin_unlock_irqrestore(&mcip_lock, flags);
 251 }
 252
 253 static void idu_irq_mask_ack(struct irq_data *data)
 254 {
 255         unsigned long flags;
 256
 257         raw_spin_lock_irqsave(&mcip_lock, flags);
 258         __mcip_cmd_data(CMD_IDU_SET_MASK, data->hwirq, 1);
 259         __mcip_cmd(CMD_IDU_ACK_CIRQ, data->hwirq);
 260         raw_spin_unlock_irqrestore(&mcip_lock, flags);
 261 }
 262
 263 static int
 264 idu_irq_set_affinity(struct irq_data *data, const struct cpumask *cpumask,
 265                      bool force)
 266 {
 267         unsigned long flags;
 268         cpumask_t online;
 269         unsigned int destination_bits;
 270         unsigned int distribution_mode;
 271
 272         /* errout if no online cpu per @cpumask */
 273         if (!cpumask_and(&online, cpumask, cpu_online_mask))
 274                 return -EINVAL;
 275
 276         raw_spin_lock_irqsave(&mcip_lock, flags);
 277
 278         destination_bits = cpumask_bits(&online)[0];
 279         idu_set_dest(data->hwirq, destination_bits);
 280
 281         if (ffs(destination_bits) == fls(destination_bits))
 282                 distribution_mode = IDU_M_DISTRI_DEST;
 283         else
 284                 distribution_mode = IDU_M_DISTRI_RR;
 285
 286         idu_set_mode(data->hwirq, false, 0, true, distribution_mode);
 287
 288         raw_spin_unlock_irqrestore(&mcip_lock, flags);
 289
 290         return IRQ_SET_MASK_OK;
 291 }
 292
 293 static int idu_irq_set_type(struct irq_data *data, u32 type)
 294 {
 295         unsigned long flags;
 296
 297         /*
 298          * ARCv2 IDU HW does not support inverse polarity, so these are the
 299          * only interrupt types supported.
 300          */
 301         if (type & ~(IRQ_TYPE_EDGE_RISING | IRQ_TYPE_LEVEL_HIGH))
 302                 return -EINVAL;
 303
 304         raw_spin_lock_irqsave(&mcip_lock, flags);
 305
 306         idu_set_mode(data->hwirq, true,
 307                      type & IRQ_TYPE_EDGE_RISING ? IDU_M_TRIG_EDGE :
 308                                                    IDU_M_TRIG_LEVEL,
 309                      false, 0);
 310
 311         raw_spin_unlock_irqrestore(&mcip_lock, flags);
 312
 313         return 0;
 314 }
 315
 316 static void idu_irq_enable(struct irq_data *data)
 317 {
 318         /*
 319          * By default send all common interrupts to all available online CPUs.
 320          * The affinity of common interrupts in IDU must be set manually since
 321          * in some cases the kernel will not call irq_set_affinity() by itself:
 322          *   1. When the kernel is not configured with support of SMP.
 323          *   2. When the kernel is configured with support of SMP but upper
 324          *      interrupt controllers does not support setting of the affinity
 325          *      and cannot propagate it to IDU.
 326          */
 327         idu_irq_set_affinity(data, cpu_online_mask, false);
 328         idu_irq_unmask(data);
 329 }
 330
 331 static struct irq_chip idu_irq_chip = {
 332         .name                   = "MCIP IDU Intc",
 333         .irq_mask               = idu_irq_mask,
 334         .irq_unmask             = idu_irq_unmask,
 335         .irq_ack                = idu_irq_ack,
 336         .irq_mask_ack           = idu_irq_mask_ack,
 337         .irq_enable             = idu_irq_enable,
 338         .irq_set_type           = idu_irq_set_type,
 339 #ifdef CONFIG_SMP
 340         .irq_set_affinity       = idu_irq_set_affinity,
 341 #endif
 342
 343 };
 344
 345 static void idu_cascade_isr(struct irq_desc *desc)
 346 {
 347         struct irq_domain *idu_domain = irq_desc_get_handler_data(desc);
 348         struct irq_chip *core_chip = irq_desc_get_chip(desc);
 349         irq_hw_number_t core_hwirq = irqd_to_hwirq(irq_desc_get_irq_data(desc));
 350         irq_hw_number_t idu_hwirq = core_hwirq - FIRST_EXT_IRQ;
 351
 352         chained_irq_enter(core_chip, desc);
 353         generic_handle_domain_irq(idu_domain, idu_hwirq);
 354         chained_irq_exit(core_chip, desc);
 355 }
 356
 357 static int idu_irq_map(struct irq_domain *d, unsigned int virq, irq_hw_number_t hwirq)
 358 {
 359         irq_set_chip_and_handler(virq, &idu_irq_chip, handle_level_irq);
 360         irq_set_status_flags(virq, IRQ_MOVE_PCNTXT);
 361
 362         return 0;
 363 }
 364
 365 static const struct irq_domain_ops idu_irq_ops = {
 366         .xlate  = irq_domain_xlate_onetwocell,
 367         .map    = idu_irq_map,
 368 };
 369
 370 /*
 371  * [16, 23]: Statically assigned always private-per-core (Timers, WDT, IPI)
 372  * [24, 23+C]: If C > 0 then "C" common IRQs
 373  * [24+C, N]: Not statically assigned, private-per-core
 374  */
 375
 376
 377 static int __init
 378 idu_of_init(struct device_node *intc, struct device_node *parent)
 379 {
 380         struct irq_domain *domain;
 381         int nr_irqs;
 382         int i, virq;
 383         struct mcip_bcr mp;
 384         struct mcip_idu_bcr idu_bcr;
 385
 386         READ_BCR(ARC_REG_MCIP_BCR, mp);
 387
 388         if (!mp.idu)
 389                 panic("IDU not detected, but DeviceTree using it");
 390
 391         READ_BCR(ARC_REG_MCIP_IDU_BCR, idu_bcr);
 392         nr_irqs = mcip_idu_bcr_to_nr_irqs(idu_bcr);
 393
 394         pr_info("MCIP: IDU supports %u common irqs\n", nr_irqs);
 395
 396         domain = irq_domain_add_linear(intc, nr_irqs, &idu_irq_ops, NULL);
 397
 398         /* Parent interrupts (core-intc) are already mapped */
 399
 400         for (i = 0; i < nr_irqs; i++) {
 401                 /* Mask all common interrupts by default */
 402                 idu_irq_mask_raw(i);
 403
 404                 /*
 405                  * Return parent uplink IRQs (towards core intc) 24,25,.....
 406                  * this step has been done before already
 407                  * however we need it to get the parent virq and set IDU handler
 408                  * as first level isr
 409                  */
 410                 virq = irq_create_mapping(NULL, i + FIRST_EXT_IRQ);
 411                 BUG_ON(!virq);
 412                 irq_set_chained_handler_and_data(virq, idu_cascade_isr, domain);
 413         }
 414
 415         __mcip_cmd(CMD_IDU_ENABLE, 0);
 416
 417         return 0;
 418 }
 419 IRQCHIP_DECLARE(arcv2_idu_intc, "snps,archs-idu-intc", idu_of_init);