arch/powerpc/include/asm/hw_irq.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * Copyright (C) 1999 Cort Dougan <cort@cs.nmt.edu>
   4  */
   5 #ifndef _ASM_POWERPC_HW_IRQ_H
   6 #define _ASM_POWERPC_HW_IRQ_H
   7
   8 #ifdef __KERNEL__
   9
  10 #include <linux/errno.h>
  11 #include <linux/compiler.h>
  12 #include <asm/ptrace.h>
  13 #include <asm/processor.h>
  14
  15 #ifdef CONFIG_PPC64
  16
  17 /*
  18  * PACA flags in paca->irq_happened.
  19  *
  20  * This bits are set when interrupts occur while soft-disabled
  21  * and allow a proper replay.
  22  *
  23  * The PACA_IRQ_HARD_DIS is set whenever we hard disable. It is almost
  24  * always in synch with the MSR[EE] state, except:
  25  * - A window in interrupt entry, where hardware disables MSR[EE] and that
  26  *   must be "reconciled" with the soft mask state.
  27  * - NMI interrupts that hit in awkward places, until they fix the state.
  28  * - When local irqs are being enabled and state is being fixed up.
  29  * - When returning from an interrupt there are some windows where this
  30  *   can become out of synch, but gets fixed before the RFI or before
  31  *   executing the next user instruction (see arch/powerpc/kernel/interrupt.c).
  32  */
  33 #define PACA_IRQ_HARD_DIS       0x01
  34 #define PACA_IRQ_DBELL          0x02
  35 #define PACA_IRQ_EE             0x04
  36 #define PACA_IRQ_DEC            0x08 /* Or FIT */
  37 #define PACA_IRQ_HMI            0x10
  38 #define PACA_IRQ_PMI            0x20
  39
  40 /*
  41  * Some soft-masked interrupts must be hard masked until they are replayed
  42  * (e.g., because the soft-masked handler does not clear the exception).
  43  */
  44 #ifdef CONFIG_PPC_BOOK3S
  45 #define PACA_IRQ_MUST_HARD_MASK (PACA_IRQ_EE|PACA_IRQ_PMI)
  46 #else
  47 #define PACA_IRQ_MUST_HARD_MASK (PACA_IRQ_EE)
  48 #endif
  49
  50 #endif /* CONFIG_PPC64 */
  51
  52 /*
  53  * flags for paca->irq_soft_mask
  54  */
  55 #define IRQS_ENABLED            0
  56 #define IRQS_DISABLED           1 /* local_irq_disable() interrupts */
  57 #define IRQS_PMI_DISABLED       2
  58 #define IRQS_ALL_DISABLED       (IRQS_DISABLED | IRQS_PMI_DISABLED)
  59
  60 #ifndef __ASSEMBLY__
  61
  62 static inline void __hard_irq_enable(void)
  63 {
  64         if (IS_ENABLED(CONFIG_BOOKE) || IS_ENABLED(CONFIG_40x))
  65                 wrtee(MSR_EE);
  66         else if (IS_ENABLED(CONFIG_PPC_8xx))
  67                 wrtspr(SPRN_EIE);
  68         else if (IS_ENABLED(CONFIG_PPC_BOOK3S_64))
  69                 __mtmsrd(MSR_EE | MSR_RI, 1);
  70         else
  71                 mtmsr(mfmsr() | MSR_EE);
  72 }
  73
  74 static inline void __hard_irq_disable(void)
  75 {
  76         if (IS_ENABLED(CONFIG_BOOKE) || IS_ENABLED(CONFIG_40x))
  77                 wrtee(0);
  78         else if (IS_ENABLED(CONFIG_PPC_8xx))
  79                 wrtspr(SPRN_EID);
  80         else if (IS_ENABLED(CONFIG_PPC_BOOK3S_64))
  81                 __mtmsrd(MSR_RI, 1);
  82         else
  83                 mtmsr(mfmsr() & ~MSR_EE);
  84 }
  85
  86 static inline void __hard_EE_RI_disable(void)
  87 {
  88         if (IS_ENABLED(CONFIG_BOOKE) || IS_ENABLED(CONFIG_40x))
  89                 wrtee(0);
  90         else if (IS_ENABLED(CONFIG_PPC_8xx))
  91                 wrtspr(SPRN_NRI);
  92         else if (IS_ENABLED(CONFIG_PPC_BOOK3S_64))
  93                 __mtmsrd(0, 1);
  94         else
  95                 mtmsr(mfmsr() & ~(MSR_EE | MSR_RI));
  96 }
  97
  98 static inline void __hard_RI_enable(void)
  99 {
 100         if (IS_ENABLED(CONFIG_BOOKE) || IS_ENABLED(CONFIG_40x))
 101                 return;
 102
 103         if (IS_ENABLED(CONFIG_PPC_8xx))
 104                 wrtspr(SPRN_EID);
 105         else if (IS_ENABLED(CONFIG_PPC_BOOK3S_64))
 106                 __mtmsrd(MSR_RI, 1);
 107         else
 108                 mtmsr(mfmsr() | MSR_RI);
 109 }
 110
 111 #ifdef CONFIG_PPC64
 112 #include <asm/paca.h>
 113
 114 static inline notrace unsigned long irq_soft_mask_return(void)
 115 {
 116         unsigned long flags;
 117
 118         asm volatile(
 119                 "lbz %0,%1(13)"
 120                 : "=r" (flags)
 121                 : "i" (offsetof(struct paca_struct, irq_soft_mask)));
 122
 123         return flags;
 124 }
 125
 126 /*
 127  * The "memory" clobber acts as both a compiler barrier
 128  * for the critical section and as a clobber because
 129  * we changed paca->irq_soft_mask
 130  */
 131 static inline notrace void irq_soft_mask_set(unsigned long mask)
 132 {
 133 #ifdef CONFIG_PPC_IRQ_SOFT_MASK_DEBUG
 134         /*
 135          * The irq mask must always include the STD bit if any are set.
 136          *
 137          * and interrupts don't get replayed until the standard
 138          * interrupt (local_irq_disable()) is unmasked.
 139          *
 140          * Other masks must only provide additional masking beyond
 141          * the standard, and they are also not replayed until the
 142          * standard interrupt becomes unmasked.
 143          *
 144          * This could be changed, but it will require partial
 145          * unmasks to be replayed, among other things. For now, take
 146          * the simple approach.
 147          */
 148         WARN_ON(mask && !(mask & IRQS_DISABLED));
 149 #endif
 150
 151         asm volatile(
 152                 "stb %0,%1(13)"
 153                 :
 154                 : "r" (mask),
 155                   "i" (offsetof(struct paca_struct, irq_soft_mask))
 156                 : "memory");
 157 }
 158
 159 static inline notrace unsigned long irq_soft_mask_set_return(unsigned long mask)
 160 {
 161         unsigned long flags;
 162
 163 #ifdef CONFIG_PPC_IRQ_SOFT_MASK_DEBUG
 164         WARN_ON(mask && !(mask & IRQS_DISABLED));
 165 #endif
 166
 167         asm volatile(
 168                 "lbz %0,%1(13); stb %2,%1(13)"
 169                 : "=&r" (flags)
 170                 : "i" (offsetof(struct paca_struct, irq_soft_mask)),
 171                   "r" (mask)
 172                 : "memory");
 173
 174         return flags;
 175 }
 176
 177 static inline notrace unsigned long irq_soft_mask_or_return(unsigned long mask)
 178 {
 179         unsigned long flags, tmp;
 180
 181         asm volatile(
 182                 "lbz %0,%2(13); or %1,%0,%3; stb %1,%2(13)"
 183                 : "=&r" (flags), "=r" (tmp)
 184                 : "i" (offsetof(struct paca_struct, irq_soft_mask)),
 185                   "r" (mask)
 186                 : "memory");
 187
 188 #ifdef CONFIG_PPC_IRQ_SOFT_MASK_DEBUG
 189         WARN_ON((mask | flags) && !((mask | flags) & IRQS_DISABLED));
 190 #endif
 191
 192         return flags;
 193 }
 194
 195 static inline unsigned long arch_local_save_flags(void)
 196 {
 197         return irq_soft_mask_return();
 198 }
 199
 200 static inline void arch_local_irq_disable(void)
 201 {
 202         irq_soft_mask_set(IRQS_DISABLED);
 203 }
 204
 205 extern void arch_local_irq_restore(unsigned long);
 206
 207 static inline void arch_local_irq_enable(void)
 208 {
 209         arch_local_irq_restore(IRQS_ENABLED);
 210 }
 211
 212 static inline unsigned long arch_local_irq_save(void)
 213 {
 214         return irq_soft_mask_set_return(IRQS_DISABLED);
 215 }
 216
 217 static inline bool arch_irqs_disabled_flags(unsigned long flags)
 218 {
 219         return flags & IRQS_DISABLED;
 220 }
 221
 222 static inline bool arch_irqs_disabled(void)
 223 {
 224         return arch_irqs_disabled_flags(arch_local_save_flags());
 225 }
 226
 227 static inline void set_pmi_irq_pending(void)
 228 {
 229         /*
 230          * Invoked from PMU callback functions to set PMI bit in the paca.
 231          * This has to be called with irq's disabled (via hard_irq_disable()).
 232          */
 233         if (IS_ENABLED(CONFIG_PPC_IRQ_SOFT_MASK_DEBUG))
 234                 WARN_ON_ONCE(mfmsr() & MSR_EE);
 235
 236         get_paca()->irq_happened |= PACA_IRQ_PMI;
 237 }
 238
 239 static inline void clear_pmi_irq_pending(void)
 240 {
 241         /*
 242          * Invoked from PMU callback functions to clear the pending PMI bit
 243          * in the paca.
 244          */
 245         if (IS_ENABLED(CONFIG_PPC_IRQ_SOFT_MASK_DEBUG))
 246                 WARN_ON_ONCE(mfmsr() & MSR_EE);
 247
 248         get_paca()->irq_happened &= ~PACA_IRQ_PMI;
 249 }
 250
 251 static inline bool pmi_irq_pending(void)
 252 {
 253         /*
 254          * Invoked from PMU callback functions to check if there is a pending
 255          * PMI bit in the paca.
 256          */
 257         if (get_paca()->irq_happened & PACA_IRQ_PMI)
 258                 return true;
 259
 260         return false;
 261 }
 262
 263 #ifdef CONFIG_PPC_BOOK3S
 264 /*
 265  * To support disabling and enabling of irq with PMI, set of
 266  * new powerpc_local_irq_pmu_save() and powerpc_local_irq_restore()
 267  * functions are added. These macros are implemented using generic
 268  * linux local_irq_* code from include/linux/irqflags.h.
 269  */
 270 #define raw_local_irq_pmu_save(flags)                                   \
 271         do {                                                            \
 272                 typecheck(unsigned long, flags);                        \
 273                 flags = irq_soft_mask_or_return(IRQS_DISABLED | \
 274                                 IRQS_PMI_DISABLED);                     \
 275         } while(0)
 276
 277 #define raw_local_irq_pmu_restore(flags)                                \
 278         do {                                                            \
 279                 typecheck(unsigned long, flags);                        \
 280                 arch_local_irq_restore(flags);                          \
 281         } while(0)
 282
 283 #ifdef CONFIG_TRACE_IRQFLAGS
 284 #define powerpc_local_irq_pmu_save(flags)                       \
 285          do {                                                   \
 286                 raw_local_irq_pmu_save(flags);                  \
 287                 if (!raw_irqs_disabled_flags(flags))            \
 288                         trace_hardirqs_off();                   \
 289         } while(0)
 290 #define powerpc_local_irq_pmu_restore(flags)                    \
 291         do {                                                    \
 292                 if (!raw_irqs_disabled_flags(flags))            \
 293                         trace_hardirqs_on();                    \
 294                 raw_local_irq_pmu_restore(flags);               \
 295         } while(0)
 296 #else
 297 #define powerpc_local_irq_pmu_save(flags)                       \
 298         do {                                                    \
 299                 raw_local_irq_pmu_save(flags);                  \
 300         } while(0)
 301 #define powerpc_local_irq_pmu_restore(flags)                    \
 302         do {                                                    \
 303                 raw_local_irq_pmu_restore(flags);               \
 304         } while (0)
 305 #endif  /* CONFIG_TRACE_IRQFLAGS */
 306
 307 #endif /* CONFIG_PPC_BOOK3S */
 308
 309 #define hard_irq_disable()      do {                                    \
 310         unsigned long flags;                                            \
 311         __hard_irq_disable();                                           \
 312         flags = irq_soft_mask_set_return(IRQS_ALL_DISABLED);            \
 313         local_paca->irq_happened |= PACA_IRQ_HARD_DIS;                  \
 314         if (!arch_irqs_disabled_flags(flags)) {                         \
 315                 asm ("stdx %%r1, 0, %1 ;"                               \
 316                      : "=m" (local_paca->saved_r1)                      \
 317                      : "b" (&local_paca->saved_r1));                    \
 318                 trace_hardirqs_off();                                   \
 319         }                                                               \
 320 } while(0)
 321
 322 static inline bool __lazy_irq_pending(u8 irq_happened)
 323 {
 324         return !!(irq_happened & ~PACA_IRQ_HARD_DIS);
 325 }
 326
 327 /*
 328  * Check if a lazy IRQ is pending. Should be called with IRQs hard disabled.
 329  */
 330 static inline bool lazy_irq_pending(void)
 331 {
 332         return __lazy_irq_pending(get_paca()->irq_happened);
 333 }
 334
 335 /*
 336  * Check if a lazy IRQ is pending, with no debugging checks.
 337  * Should be called with IRQs hard disabled.
 338  * For use in RI disabled code or other constrained situations.
 339  */
 340 static inline bool lazy_irq_pending_nocheck(void)
 341 {
 342         return __lazy_irq_pending(local_paca->irq_happened);
 343 }
 344
 345 /*
 346  * This is called by asynchronous interrupts to conditionally
 347  * re-enable hard interrupts after having cleared the source
 348  * of the interrupt. They are kept disabled if there is a different
 349  * soft-masked interrupt pending that requires hard masking.
 350  */
 351 static inline void may_hard_irq_enable(void)
 352 {
 353         if (!(get_paca()->irq_happened & PACA_IRQ_MUST_HARD_MASK)) {
 354                 get_paca()->irq_happened &= ~PACA_IRQ_HARD_DIS;
 355                 __hard_irq_enable();
 356         }
 357 }
 358
 359 static inline bool arch_irq_disabled_regs(struct pt_regs *regs)
 360 {
 361         return (regs->softe & IRQS_DISABLED);
 362 }
 363
 364 extern bool prep_irq_for_idle(void);
 365 extern bool prep_irq_for_idle_irqsoff(void);
 366 extern void irq_set_pending_from_srr1(unsigned long srr1);
 367
 368 #define fini_irq_for_idle_irqsoff() trace_hardirqs_off();
 369
 370 extern void force_external_irq_replay(void);
 371
 372 static inline void irq_soft_mask_regs_set_state(struct pt_regs *regs, unsigned long val)
 373 {
 374         regs->softe = val;
 375 }
 376 #else /* CONFIG_PPC64 */
 377
 378 static inline notrace unsigned long irq_soft_mask_return(void)
 379 {
 380         return 0;
 381 }
 382
 383 static inline unsigned long arch_local_save_flags(void)
 384 {
 385         return mfmsr();
 386 }
 387
 388 static inline void arch_local_irq_restore(unsigned long flags)
 389 {
 390         if (IS_ENABLED(CONFIG_BOOKE))
 391                 wrtee(flags);
 392         else
 393                 mtmsr(flags);
 394 }
 395
 396 static inline unsigned long arch_local_irq_save(void)
 397 {
 398         unsigned long flags = arch_local_save_flags();
 399
 400         if (IS_ENABLED(CONFIG_BOOKE))
 401                 wrtee(0);
 402         else if (IS_ENABLED(CONFIG_PPC_8xx))
 403                 wrtspr(SPRN_EID);
 404         else
 405                 mtmsr(flags & ~MSR_EE);
 406
 407         return flags;
 408 }
 409
 410 static inline void arch_local_irq_disable(void)
 411 {
 412         __hard_irq_disable();
 413 }
 414
 415 static inline void arch_local_irq_enable(void)
 416 {
 417         __hard_irq_enable();
 418 }
 419
 420 static inline bool arch_irqs_disabled_flags(unsigned long flags)
 421 {
 422         return (flags & MSR_EE) == 0;
 423 }
 424
 425 static inline bool arch_irqs_disabled(void)
 426 {
 427         return arch_irqs_disabled_flags(arch_local_save_flags());
 428 }
 429
 430 #define hard_irq_disable()              arch_local_irq_disable()
 431
 432 static inline bool arch_irq_disabled_regs(struct pt_regs *regs)
 433 {
 434         return !(regs->msr & MSR_EE);
 435 }
 436
 437 static inline bool may_hard_irq_enable(void)
 438 {
 439         return false;
 440 }
 441
 442 static inline void do_hard_irq_enable(void)
 443 {
 444         BUILD_BUG();
 445 }
 446
 447 static inline void clear_pmi_irq_pending(void) { }
 448 static inline void set_pmi_irq_pending(void) { }
 449 static inline bool pmi_irq_pending(void) { return false; }
 450
 451 static inline void irq_soft_mask_regs_set_state(struct pt_regs *regs, unsigned long val)
 452 {
 453 }
 454 #endif /* CONFIG_PPC64 */
 455
 456 #define ARCH_IRQ_INIT_FLAGS     IRQ_NOREQUEST
 457
 458 #endif  /* __ASSEMBLY__ */
 459 #endif  /* __KERNEL__ */
 460 #endif  /* _ASM_POWERPC_HW_IRQ_H */