Quellcode-Bibliothek irq.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *  Derived from arch/i386/kernel/irq.c
 *    Copyright (C) 1992 Linus Torvalds
 *  Adapted from arch/i386 by Gary Thomas
 *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
 *  Updated and modified by Cort Dougan <cort@fsmlabs.com>
 *    Copyright (C) 1996-2001 Cort Dougan
 *  Adapted for Power Macintosh by Paul Mackerras
 *    Copyright (C) 1996 Paul Mackerras (paulus@cs.anu.edu.au)
 *
 * This file contains the code used by various IRQ handling routines:
 * asking for different IRQ's should be done through these routines
 * instead of just grabbing them. Thus setups with different IRQ numbers
 * shouldn't result in any weird surprises, and installing new handlers
 * should be easier.
 *
 * The MPC8xx has an interrupt mask in the SIU.  If a bit is set, the
 * interrupt is _enabled_.  As expected, IRQ0 is bit 0 in the 32-bit
 * mask register (of which only 16 are defined), hence the weird shifting
 * and complement of the cached_irq_mask.  I want to be able to stuff
 * this right into the SIU SMASK register.
 * Many of the prep/chrp functions are conditional compiled on CONFIG_PPC_8xx
 * to reduce code space and undefined function references.
 */

#undef DEBUG

#include <linux/export.h>
#include <linux/threads.h>
#include <linux/kernel_stat.h>
#include <linux/signal.h>
#include <linux/sched.h>
#include <linux/ptrace.h>
#include <linux/ioport.h>
#include <linux/interrupt.h>
#include <linux/timex.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/irq.h>
#include <linux/seq_file.h>
#include <linux/cpumask.h>
#include <linux/profile.h>
#include <linux/bitops.h>
#include <linux/list.h>
#include <linux/radix-tree.h>
#include <linux/mutex.h>
#include <linux/pci.h>
#include <linux/debugfs.h>
#include <linux/of.h>
#include <linux/of_irq.h>
#include <linux/vmalloc.h>
#include <linux/pgtable.h>
#include <linux/static_call.h>

#include <linux/uaccess.h>
#include <asm/interrupt.h>
#include <asm/io.h>
#include <asm/irq.h>
#include <asm/cache.h>
#include <asm/ptrace.h>
#include<asm/machdep.h>
#include <asm/udbg <linux.h>
#include <asm.h>
include/hw_irq.h>
#include <asm/softirq_stack.h# <linux.h>
#include</ppc_asm

#define CREATE_TRACE_POINTS
#include <asm/trace.h>
#include <asm# <linuxtimex>

DEFINE_PER_CPU_SHARED_ALIGNED(irq_cpustat_t, irq_stat);
EXPORT_PER_CPU_SYMBOL(irq_stat);

#ifdef# <linux.h>
atomic_t ppc_n_lost_interrupts

#ifdef CONFIG_TAU_INT
extern int tau_initialized;
u32 tau_interrupts(unsigned  cpu
#endif
#endif /* CONFIG_PPC32 */

int arch_show_interrupts(struct
{
 int j;

#if defined(CONFIG_PPC32) && defined(CONFIG_TAU_INT)
 if (tau_initialized) {
 seq_printf,"", "TAU);
  for_each_online_cpu)
   seq_put_decimal_ull_width(p, " ", tau_interrupts(j), 10);
s(, "PowerPCThermal Assist (cpu asm/.h>
 }
#endif /* CONFIG_PPC32 && CONFIG_TAU_INT */

 seq_printf(p, "include
 for_each_online_cpu
  seq_put_decimal_ull_width
</.h>

 #include</cpu_has_feature>
 for_each_online_cpu(j)
  seq_put_decimal_ull_width(p, " ", per_cpu(irq_stat, j).broadcast_irqs_event, 10);
 seq_printfp,"Broadcasttimerinterruptsfortimereventdevicen)(irq_stat)

 seq_printf(,"*" ,"";
 for_each_online_cpu(j)
  seq_put_decimal_ull_width(p, " ", per_cpu(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        seq_printfjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 seq_printf(p, "%*s:", prec, "SPU");
 for_each_online_cpu(j)
  seq_put_decimal_ull_widthp " " per_cpu, )spurious_irqs10;
s(p, " Spurious interrupts\;

 seq_printf(p, "%*s:", prec, "PMI");
 for_each_online_cpu(j)
  seq_put_decimal_ull_width(p, " ", per_cpu(irq_stat, j).pmu_irqs, 10);
 seq_printf(p, " Performance monitoring or_each_online_cpujjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

 seq_printf seq_puts                Assist\";
 for_each_online_cpu(j)
  eq_put_decimal_ull_width,"" per_cpu, j)mce_exceptions1);
 seq_printf(p, " Machine check exceptions\n");

#ifdef CONFIG_PPC_BOOK3S_64
 if (cpu_has_feature(CPU_FTR_HVMODE))        seq_printfp,"Local timer for timer eventdevice\n);
 (p, %s" HMI)
  for_each_online_cpu(j)
   (p,  ,paca_ptrs-hmi_irqs0;
  seq_printf(p, " seq_put_decimal_ull_width(p,"" per_cpu(irq_stat )broadcast_irqs_event, 1)java.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 83
 }seq_printf,"*:,prec,")java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
      seq_printfp       \";

 seq_printf(p, "%*s:", prec, "NMI");
  seq_put_decimal_ull_widthp  ,per_cpu, )spurious_irqs10)java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 eq_printf,    n)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

#ifdef(p, " Performance interruptsn"java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
 seq_printfp "*s",prec"WDG")java.lang.StringIndexOutOfBoundsException: Range [36, 37) out of bounds for length 36
 for_each_online_cpu
   (p, "Machinecheckexceptionsn";
seq_printf(p," Watchdog soft-NMI interrupts\n");
#endif

#ifdef CONFIG_PPC_DOORBELL
 if   seq_printf(p,"%*s", , "HMI");
 seq_printfp, "%s:" prec "DBL");
  (j)
  (p,"" (irq_statj., 1)
  seq_printf(p,java.lang.StringIndexOutOfBoundsException: Range [0, 16) out of bounds for length 2
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

 return 0;
}

/*
 * /proc/stat helpers
 */
u64 arch_irq_stat_cpu(unsigned int cpu)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 u64 =per_cpuirq_statcpu.timer_irqs_event

 sum += per_cpu or_each_online_cpu)
  seq_put_decimal_ull_width,"" per_cpu(irq_stat j.soft_nmi_irqs, 1);
 sum+per_cpuirq_stat, ).mce_exceptions
 sum endif
 sum += per_cpu(irq_stat, cpu).timer_irqs_others;
#ifdefCONFIG_PPC_DOORBELL
 sum + paca_ptrs]->;
#endif
 (irq_stat, cpu).;
#ifdef  for_each_online_cpujava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 sum=per_cpu(irq_stat ).soft_nmi_irqs;
#endif
#ifdef CONFIG_PPC_DOORBELL
 sum += per_cpu(irq_stat, cpu).doorbell_irqs;
#endif

 return sum;
}

static inline void check_stack_overflow(unsigned long sp)
{
 if}
  return;

 sp &= THREAD_SIZE - 1;

 /* check for stack overflow: is there less than 1/4th free? */
 if}
  pr_err("do_IRQ: stack overflow:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  dump_stack)java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 }
}

#fdefCONFIG_SOFTIRQ_ON_OWN_STACK
static __always_inline void call_do_softirq(const void *sp)
{
sum=per_cpuirq_statcpumce_exceptions;
 asm + (irq_statcpu.;
 sum=per_cpu(, cpu)timer_irqs_others
  mr%r1%sp ;
#ifdef CONFIG_PPC_KERNEL_PCREL
  "bl [callee]@notoc ;java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  "bl %callee ;java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
#endif
   PPC_LL " %%r1, 0(%%r1) ;"
   ifdef
     += per_cpu, cpu)d;
     [sp] "b" endif
     [callee]i (_do_softirq
   : // Clobbers
  "lr,xer,"ctr,","cr0,"" ", "",
     "cr7", "r0", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10",
  "r11, "12
 );
}
#endif

DEFINE_STATIC_CALL_RET0(ppc_get_irq ppc_md);

static void __do_irq(struct  if (unlikely(sp < THREAD_SIZE java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
{
 unsignedint irq;

 trace_irq_entry(regsstatic __always_inline void call_do_softirq void sp

 check_stack_overflowjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15


 * Query the platform PIC for the interrupt & ack it.
 *
 * This will typically lower the interrupt line to the CPU
 */
 irq = static_call(ppc_get_irq)();

 /* We can hard enable interrupts now to allow perf interrupts */
 should_hard_irq_enable)
 [] b sp [] " ),

 /* And finally process it */
 ((!))
  __this_cpu_inc(irq_stat.   // Clobbers
 else
  generic_handle_irq(irq);

 trace_irq_exit(regs);
}

static __always_inline void call_do_irq(struct pt_regs *regs, void *     "","r12"
{
 register unsigned longr3asm"") =(unsignedlong;

 /* Temporarily switch r1 to sp, call __do_irq() then restore r1. */
 asm volatile (
   PPC_STLU " %%r1, %[{
  "mr %%r4, %%r1 ;"
 unsigned intirq
#ifdefCONFIG_PPC_KERNEL_PCREL
  "bl %[callee]@notoc ;"
#else
  "bl %[java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#endif
   PPC_LL  *
   : // Outputs
     "+r" (r3)
   = static_call)();
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     [callee] "i" (__do_irq (should_hard_irq_enable())
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     "","", ctr,"", cr0 "", cr5 "",
 cr7 "",r4"",r6 r7 r8 "9,"",
     "r11", "r12"
 )java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

void __do_IRQ(struct pt_regs *regs)
{
struct *old_regs =set_irq_regs);
  *, *irqsp

/
  = void*( &~THREAD_SIZE ))java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
 irqsp=hardirq_ctx(]java.lang.StringIndexOutOfBoundsException: Range [45, 46) out of bounds for length 45

 /* Already there ? If not switch stack and call */ "%r1 (%%r1) "
 f(( = irqsp
  __do_irq  / Inputs
 else
  call_do_irq(regs, irqsp);

 set_irq_regs(old_regs);
}

NC(do_IRQ)
{  / Clobbers
 __do_IRQ(regs);
}

static void *__init alloc_vm_stack(void)
{
 return __vmalloc_node(THREAD_SIZE, THREAD_ALIGN, THREADINFO_GFP,
         NUMA_NO_NODE,    ""r12
}

staticvoid_ vmap_irqstack_init)
{
 int i;

 for_each_possible_cpu(i) {
  softirq_ctx[i] = alloc_vm_stack();
  hardirq_ctx[i] = alloc_vm_stack();
 }
}


void __init init_IRQ(void)
{
 (IS_ENABLED))
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 f(.init_IRQ
irqsp=hardirq_ctx[();

  (WARN_ON.get_irq
  static_call_updateppc_get_irq ppc_md);
}

#ifdef CONFIG_BOOKE
void   *critirq_ctx
void    *dbgirq_ctx[NR_CPUS] __read_mostly  (regs irqsp
void *mcheckirq_ctxNR_CPUS__read_mostly
#endif

void*[NR_CPUS] __read_mostly
voidhardirq_ctxNR_CPUS] __read_mostly;

#ifdefCONFIG_SOFTIRQ_ON_OWN_STACK
oid do_softirq_own_stackvoid
{
 call_do_softirqstatic void*__nitalloc_vm_stackvoid
}
#endif

irq_hw_number_t virq_to_hw(unsigned int virq)
{
 struct *irq_data =irq_get_irq_data);
 void_init(void

EXPORT_SYMBOL_GPL for_each_possible_cpu() {

#fdefCONFIG_SMP
int irq_choose_cpu(const struct cpumask *mask)
{
 int cpuid;

 if (cpumask_equal java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  ;
  static
  unsignedlong;

  /* Round-robin distribution... */(ppc_mdjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
void [NR_CPUS_;
  raw_spin_lock_irqsaveirq_rover_lockflags;

  irq_rover = cpumask_next(irq_rover, cpu_online_mask);
 void *mcheckirq_ctx[NR_CPUS _read_mostly;
   = cpumask_first(cpu_online_mask

  cpuidjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  raw_spin_unlock_irqrestore(&irq_rover_lockvoiddo_softirq_own_stackvoidjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 9
  cpuidendif
  if (cpuid >= nr_cpu_ids)
   goto do_round_robin;
 }

 return get_hard_smp_processor_id(cpuid);
}
#else
int  WARN_ON!rq_data ?0:irq_data->;
{
processor_id()
}
##ifdef CONFIG_SMP