1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27#undef DEBUG
28
29#include <linux/export.h>
30#include <linux/threads.h>
31#include <linux/kernel_stat.h>
32#include <linux/signal.h>
33#include <linux/sched.h>
34#include <linux/ptrace.h>
35#include <linux/ioport.h>
36#include <linux/interrupt.h>
37#include <linux/timex.h>
38#include <linux/init.h>
39#include <linux/slab.h>
40#include <linux/delay.h>
41#include <linux/irq.h>
42#include <linux/seq_file.h>
43#include <linux/cpumask.h>
44#include <linux/profile.h>
45#include <linux/bitops.h>
46#include <linux/list.h>
47#include <linux/radix-tree.h>
48#include <linux/mutex.h>
49#include <linux/pci.h>
50#include <linux/debugfs.h>
51#include <linux/of.h>
52#include <linux/of_irq.h>
53#include <linux/vmalloc.h>
54#include <linux/pgtable.h>
55
56#include <linux/uaccess.h>
57#include <asm/interrupt.h>
58#include <asm/io.h>
59#include <asm/irq.h>
60#include <asm/cache.h>
61#include <asm/prom.h>
62#include <asm/ptrace.h>
63#include <asm/machdep.h>
64#include <asm/udbg.h>
65#include <asm/smp.h>
66#include <asm/livepatch.h>
67#include <asm/asm-prototypes.h>
68#include <asm/hw_irq.h>
69#include <asm/softirq_stack.h>
70
71#ifdef CONFIG_PPC64
72#include <asm/paca.h>
73#include <asm/firmware.h>
74#include <asm/lv1call.h>
75#include <asm/dbell.h>
76#endif
77#define CREATE_TRACE_POINTS
78#include <asm/trace.h>
79#include <asm/cpu_has_feature.h>
80
81DEFINE_PER_CPU_SHARED_ALIGNED(irq_cpustat_t, irq_stat);
82EXPORT_PER_CPU_SYMBOL(irq_stat);
83
84#ifdef CONFIG_PPC32
85atomic_t ppc_n_lost_interrupts;
86
87#ifdef CONFIG_TAU_INT
88extern int tau_initialized;
89u32 tau_interrupts(unsigned long cpu);
90#endif
91#endif
92
93#ifdef CONFIG_PPC64
94
95int distribute_irqs = 1;
96
97static inline notrace unsigned long get_irq_happened(void)
98{
99 unsigned long happened;
100
101 __asm__ __volatile__("lbz %0,%1(13)"
102 : "=r" (happened) : "i" (offsetof(struct paca_struct, irq_happened)));
103
104 return happened;
105}
106
107void replay_soft_interrupts(void)
108{
109 struct pt_regs regs;
110
111
112
113
114
115
116
117
118
119
120
121
122 ppc_save_regs(®s);
123 regs.softe = IRQS_ENABLED;
124 regs.msr |= MSR_EE;
125
126again:
127 if (IS_ENABLED(CONFIG_PPC_IRQ_SOFT_MASK_DEBUG))
128 WARN_ON_ONCE(mfmsr() & MSR_EE);
129
130
131
132
133
134 if (firmware_has_feature(FW_FEATURE_PS3_LV1)) {
135 u64 tmp, tmp2;
136 lv1_get_version_info(&tmp, &tmp2);
137 }
138
139
140
141
142
143
144 if (IS_ENABLED(CONFIG_PPC_BOOK3S) && (local_paca->irq_happened & PACA_IRQ_HMI)) {
145 local_paca->irq_happened &= ~PACA_IRQ_HMI;
146 regs.trap = INTERRUPT_HMI;
147 handle_hmi_exception(®s);
148 if (!(local_paca->irq_happened & PACA_IRQ_HARD_DIS))
149 hard_irq_disable();
150 }
151
152 if (local_paca->irq_happened & PACA_IRQ_DEC) {
153 local_paca->irq_happened &= ~PACA_IRQ_DEC;
154 regs.trap = INTERRUPT_DECREMENTER;
155 timer_interrupt(®s);
156 if (!(local_paca->irq_happened & PACA_IRQ_HARD_DIS))
157 hard_irq_disable();
158 }
159
160 if (local_paca->irq_happened & PACA_IRQ_EE) {
161 local_paca->irq_happened &= ~PACA_IRQ_EE;
162 regs.trap = INTERRUPT_EXTERNAL;
163 do_IRQ(®s);
164 if (!(local_paca->irq_happened & PACA_IRQ_HARD_DIS))
165 hard_irq_disable();
166 }
167
168 if (IS_ENABLED(CONFIG_PPC_DOORBELL) && (local_paca->irq_happened & PACA_IRQ_DBELL)) {
169 local_paca->irq_happened &= ~PACA_IRQ_DBELL;
170 regs.trap = INTERRUPT_DOORBELL;
171 doorbell_exception(®s);
172 if (!(local_paca->irq_happened & PACA_IRQ_HARD_DIS))
173 hard_irq_disable();
174 }
175
176
177 if (IS_ENABLED(CONFIG_PPC_BOOK3S) && (local_paca->irq_happened & PACA_IRQ_PMI)) {
178 local_paca->irq_happened &= ~PACA_IRQ_PMI;
179 regs.trap = INTERRUPT_PERFMON;
180 performance_monitor_exception(®s);
181 if (!(local_paca->irq_happened & PACA_IRQ_HARD_DIS))
182 hard_irq_disable();
183 }
184
185 if (local_paca->irq_happened & ~PACA_IRQ_HARD_DIS) {
186
187
188
189
190 trace_hardirqs_on();
191 trace_hardirqs_off();
192 goto again;
193 }
194}
195
196#if defined(CONFIG_PPC_BOOK3S_64) && defined(CONFIG_PPC_KUAP)
197static inline void replay_soft_interrupts_irqrestore(void)
198{
199 unsigned long kuap_state = get_kuap();
200
201
202
203
204
205
206
207 kuap_assert_locked();
208
209 if (kuap_state != AMR_KUAP_BLOCKED)
210 set_kuap(AMR_KUAP_BLOCKED);
211
212 replay_soft_interrupts();
213
214 if (kuap_state != AMR_KUAP_BLOCKED)
215 set_kuap(kuap_state);
216}
217#else
218#define replay_soft_interrupts_irqrestore() replay_soft_interrupts()
219#endif
220
221#ifdef CONFIG_CC_HAS_ASM_GOTO
222notrace void arch_local_irq_restore(unsigned long mask)
223{
224 unsigned char irq_happened;
225
226
227 if (mask) {
228 irq_soft_mask_set(mask);
229 return;
230 }
231
232 if (IS_ENABLED(CONFIG_PPC_IRQ_SOFT_MASK_DEBUG))
233 WARN_ON_ONCE(in_nmi() || in_hardirq());
234
235
236
237
238
239
240
241
242
243
244
245 asm_volatile_goto(
246"1: \n"
247" lbz 9,%0(13) \n"
248" cmpwi 9,0 \n"
249" bne %l[happened] \n"
250" stb 9,%1(13) \n"
251"2: \n"
252 RESTART_TABLE(1b, 2b, 1b)
253 : : "i" (offsetof(struct paca_struct, irq_happened)),
254 "i" (offsetof(struct paca_struct, irq_soft_mask))
255 : "cr0", "r9"
256 : happened);
257
258 if (IS_ENABLED(CONFIG_PPC_IRQ_SOFT_MASK_DEBUG))
259 WARN_ON_ONCE(!(mfmsr() & MSR_EE));
260
261 return;
262
263happened:
264 irq_happened = get_irq_happened();
265 if (IS_ENABLED(CONFIG_PPC_IRQ_SOFT_MASK_DEBUG))
266 WARN_ON_ONCE(!irq_happened);
267
268 if (irq_happened == PACA_IRQ_HARD_DIS) {
269 if (IS_ENABLED(CONFIG_PPC_IRQ_SOFT_MASK_DEBUG))
270 WARN_ON_ONCE(mfmsr() & MSR_EE);
271 irq_soft_mask_set(IRQS_ENABLED);
272 local_paca->irq_happened = 0;
273 __hard_irq_enable();
274 return;
275 }
276
277
278 if (!(irq_happened & PACA_IRQ_HARD_DIS)) {
279 if (IS_ENABLED(CONFIG_PPC_IRQ_SOFT_MASK_DEBUG)) {
280 if (!(mfmsr() & MSR_EE)) {
281
282
283
284
285
286
287 irq_happened = get_irq_happened();
288 WARN_ON_ONCE(!(irq_happened & PACA_IRQ_HARD_DIS));
289 }
290 }
291 __hard_irq_disable();
292 local_paca->irq_happened |= PACA_IRQ_HARD_DIS;
293 } else {
294 if (IS_ENABLED(CONFIG_PPC_IRQ_SOFT_MASK_DEBUG)) {
295 if (WARN_ON_ONCE(mfmsr() & MSR_EE))
296 __hard_irq_disable();
297 }
298 }
299
300
301
302
303
304
305 preempt_disable();
306 irq_soft_mask_set(IRQS_ALL_DISABLED);
307 trace_hardirqs_off();
308
309 replay_soft_interrupts_irqrestore();
310 local_paca->irq_happened = 0;
311
312 trace_hardirqs_on();
313 irq_soft_mask_set(IRQS_ENABLED);
314 __hard_irq_enable();
315 preempt_enable();
316}
317#else
318notrace void arch_local_irq_restore(unsigned long mask)
319{
320 unsigned char irq_happened;
321
322
323 irq_soft_mask_set(mask);
324 if (mask)
325 return;
326
327 if (IS_ENABLED(CONFIG_PPC_IRQ_SOFT_MASK_DEBUG))
328 WARN_ON_ONCE(in_nmi() || in_hardirq());
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343 irq_happened = get_irq_happened();
344 if (!irq_happened) {
345 if (IS_ENABLED(CONFIG_PPC_IRQ_SOFT_MASK_DEBUG))
346 WARN_ON_ONCE(!(mfmsr() & MSR_EE));
347 return;
348 }
349
350
351 if (!(irq_happened & PACA_IRQ_HARD_DIS)) {
352 if (IS_ENABLED(CONFIG_PPC_IRQ_SOFT_MASK_DEBUG))
353 WARN_ON_ONCE(!(mfmsr() & MSR_EE));
354 __hard_irq_disable();
355 local_paca->irq_happened |= PACA_IRQ_HARD_DIS;
356 } else {
357
358
359
360
361
362
363 if (IS_ENABLED(CONFIG_PPC_IRQ_SOFT_MASK_DEBUG)) {
364 if (WARN_ON_ONCE(mfmsr() & MSR_EE))
365 __hard_irq_disable();
366 }
367
368 if (irq_happened == PACA_IRQ_HARD_DIS) {
369 local_paca->irq_happened = 0;
370 __hard_irq_enable();
371 return;
372 }
373 }
374
375
376
377
378
379
380 preempt_disable();
381 irq_soft_mask_set(IRQS_ALL_DISABLED);
382 trace_hardirqs_off();
383
384 replay_soft_interrupts_irqrestore();
385 local_paca->irq_happened = 0;
386
387 trace_hardirqs_on();
388 irq_soft_mask_set(IRQS_ENABLED);
389 __hard_irq_enable();
390 preempt_enable();
391}
392#endif
393EXPORT_SYMBOL(arch_local_irq_restore);
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410bool prep_irq_for_idle(void)
411{
412
413
414
415
416 __hard_irq_disable();
417 local_paca->irq_happened |= PACA_IRQ_HARD_DIS;
418
419
420
421
422
423 if (lazy_irq_pending())
424 return false;
425
426
427 trace_hardirqs_on();
428
429
430
431
432
433
434
435 local_paca->irq_happened &= ~PACA_IRQ_HARD_DIS;
436 irq_soft_mask_set(IRQS_ENABLED);
437
438
439 return true;
440}
441
442#ifdef CONFIG_PPC_BOOK3S
443
444
445
446
447
448
449bool prep_irq_for_idle_irqsoff(void)
450{
451 WARN_ON(!irqs_disabled());
452
453
454
455
456
457 __hard_irq_disable();
458 local_paca->irq_happened |= PACA_IRQ_HARD_DIS;
459
460
461
462
463
464 if (lazy_irq_pending())
465 return false;
466
467
468 trace_hardirqs_on();
469
470 return true;
471}
472
473
474
475
476
477
478
479
480
481
482
483#define IRQ_SYSTEM_RESET 0xff
484
485static const u8 srr1_to_lazyirq[0x10] = {
486 0, 0, 0,
487 PACA_IRQ_DBELL,
488 IRQ_SYSTEM_RESET,
489 PACA_IRQ_DBELL,
490 PACA_IRQ_DEC,
491 0,
492 PACA_IRQ_EE,
493 PACA_IRQ_EE,
494 PACA_IRQ_HMI,
495 0, 0, 0, 0, 0 };
496
497void replay_system_reset(void)
498{
499 struct pt_regs regs;
500
501 ppc_save_regs(®s);
502 regs.trap = 0x100;
503 get_paca()->in_nmi = 1;
504 system_reset_exception(®s);
505 get_paca()->in_nmi = 0;
506}
507EXPORT_SYMBOL_GPL(replay_system_reset);
508
509void irq_set_pending_from_srr1(unsigned long srr1)
510{
511 unsigned int idx = (srr1 & SRR1_WAKEMASK_P8) >> 18;
512 u8 reason = srr1_to_lazyirq[idx];
513
514
515
516
517
518
519 if (unlikely(reason == IRQ_SYSTEM_RESET)) {
520 replay_system_reset();
521 return;
522 }
523
524 if (reason == PACA_IRQ_DBELL) {
525
526
527
528
529
530
531
532
533
534 ppc_msgclr(PPC_DBELL_MSGTYPE);
535 }
536
537
538
539
540
541
542
543
544
545
546 local_paca->irq_happened |= reason;
547}
548#endif
549
550
551
552
553void force_external_irq_replay(void)
554{
555
556
557
558
559 WARN_ON(!arch_irqs_disabled());
560
561
562
563
564
565
566 __hard_irq_disable();
567 local_paca->irq_happened |= PACA_IRQ_HARD_DIS;
568
569
570 local_paca->irq_happened |= PACA_IRQ_EE;
571}
572
573#endif
574
575int arch_show_interrupts(struct seq_file *p, int prec)
576{
577 int j;
578
579#if defined(CONFIG_PPC32) && defined(CONFIG_TAU_INT)
580 if (tau_initialized) {
581 seq_printf(p, "%*s: ", prec, "TAU");
582 for_each_online_cpu(j)
583 seq_printf(p, "%10u ", tau_interrupts(j));
584 seq_puts(p, " PowerPC Thermal Assist (cpu temp)\n");
585 }
586#endif
587
588 seq_printf(p, "%*s: ", prec, "LOC");
589 for_each_online_cpu(j)
590 seq_printf(p, "%10u ", per_cpu(irq_stat, j).timer_irqs_event);
591 seq_printf(p, " Local timer interrupts for timer event device\n");
592
593 seq_printf(p, "%*s: ", prec, "BCT");
594 for_each_online_cpu(j)
595 seq_printf(p, "%10u ", per_cpu(irq_stat, j).broadcast_irqs_event);
596 seq_printf(p, " Broadcast timer interrupts for timer event device\n");
597
598 seq_printf(p, "%*s: ", prec, "LOC");
599 for_each_online_cpu(j)
600 seq_printf(p, "%10u ", per_cpu(irq_stat, j).timer_irqs_others);
601 seq_printf(p, " Local timer interrupts for others\n");
602
603 seq_printf(p, "%*s: ", prec, "SPU");
604 for_each_online_cpu(j)
605 seq_printf(p, "%10u ", per_cpu(irq_stat, j).spurious_irqs);
606 seq_printf(p, " Spurious interrupts\n");
607
608 seq_printf(p, "%*s: ", prec, "PMI");
609 for_each_online_cpu(j)
610 seq_printf(p, "%10u ", per_cpu(irq_stat, j).pmu_irqs);
611 seq_printf(p, " Performance monitoring interrupts\n");
612
613 seq_printf(p, "%*s: ", prec, "MCE");
614 for_each_online_cpu(j)
615 seq_printf(p, "%10u ", per_cpu(irq_stat, j).mce_exceptions);
616 seq_printf(p, " Machine check exceptions\n");
617
618#ifdef CONFIG_PPC_BOOK3S_64
619 if (cpu_has_feature(CPU_FTR_HVMODE)) {
620 seq_printf(p, "%*s: ", prec, "HMI");
621 for_each_online_cpu(j)
622 seq_printf(p, "%10u ", paca_ptrs[j]->hmi_irqs);
623 seq_printf(p, " Hypervisor Maintenance Interrupts\n");
624 }
625#endif
626
627 seq_printf(p, "%*s: ", prec, "NMI");
628 for_each_online_cpu(j)
629 seq_printf(p, "%10u ", per_cpu(irq_stat, j).sreset_irqs);
630 seq_printf(p, " System Reset interrupts\n");
631
632#ifdef CONFIG_PPC_WATCHDOG
633 seq_printf(p, "%*s: ", prec, "WDG");
634 for_each_online_cpu(j)
635 seq_printf(p, "%10u ", per_cpu(irq_stat, j).soft_nmi_irqs);
636 seq_printf(p, " Watchdog soft-NMI interrupts\n");
637#endif
638
639#ifdef CONFIG_PPC_DOORBELL
640 if (cpu_has_feature(CPU_FTR_DBELL)) {
641 seq_printf(p, "%*s: ", prec, "DBL");
642 for_each_online_cpu(j)
643 seq_printf(p, "%10u ", per_cpu(irq_stat, j).doorbell_irqs);
644 seq_printf(p, " Doorbell interrupts\n");
645 }
646#endif
647
648 return 0;
649}
650
651
652
653
654u64 arch_irq_stat_cpu(unsigned int cpu)
655{
656 u64 sum = per_cpu(irq_stat, cpu).timer_irqs_event;
657
658 sum += per_cpu(irq_stat, cpu).broadcast_irqs_event;
659 sum += per_cpu(irq_stat, cpu).pmu_irqs;
660 sum += per_cpu(irq_stat, cpu).mce_exceptions;
661 sum += per_cpu(irq_stat, cpu).spurious_irqs;
662 sum += per_cpu(irq_stat, cpu).timer_irqs_others;
663#ifdef CONFIG_PPC_BOOK3S_64
664 sum += paca_ptrs[cpu]->hmi_irqs;
665#endif
666 sum += per_cpu(irq_stat, cpu).sreset_irqs;
667#ifdef CONFIG_PPC_WATCHDOG
668 sum += per_cpu(irq_stat, cpu).soft_nmi_irqs;
669#endif
670#ifdef CONFIG_PPC_DOORBELL
671 sum += per_cpu(irq_stat, cpu).doorbell_irqs;
672#endif
673
674 return sum;
675}
676
677static inline void check_stack_overflow(void)
678{
679 long sp;
680
681 if (!IS_ENABLED(CONFIG_DEBUG_STACKOVERFLOW))
682 return;
683
684 sp = current_stack_pointer & (THREAD_SIZE - 1);
685
686
687 if (unlikely(sp < 2048)) {
688 pr_err("do_IRQ: stack overflow: %ld\n", sp);
689 dump_stack();
690 }
691}
692
693static __always_inline void call_do_softirq(const void *sp)
694{
695
696 asm volatile (
697 PPC_STLU " %%r1, %[offset](%[sp]) ;"
698 "mr %%r1, %[sp] ;"
699 "bl %[callee] ;"
700 PPC_LL " %%r1, 0(%%r1) ;"
701 :
702 :
703 [sp] "b" (sp), [offset] "i" (THREAD_SIZE - STACK_FRAME_OVERHEAD),
704 [callee] "i" (__do_softirq)
705 :
706 "lr", "xer", "ctr", "memory", "cr0", "cr1", "cr5", "cr6",
707 "cr7", "r0", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10",
708 "r11", "r12"
709 );
710}
711
712static __always_inline void call_do_irq(struct pt_regs *regs, void *sp)
713{
714 register unsigned long r3 asm("r3") = (unsigned long)regs;
715
716
717 asm volatile (
718 PPC_STLU " %%r1, %[offset](%[sp]) ;"
719 "mr %%r1, %[sp] ;"
720 "bl %[callee] ;"
721 PPC_LL " %%r1, 0(%%r1) ;"
722 :
723 "+r" (r3)
724 :
725 [sp] "b" (sp), [offset] "i" (THREAD_SIZE - STACK_FRAME_OVERHEAD),
726 [callee] "i" (__do_irq)
727 :
728 "lr", "xer", "ctr", "memory", "cr0", "cr1", "cr5", "cr6",
729 "cr7", "r0", "r4", "r5", "r6", "r7", "r8", "r9", "r10",
730 "r11", "r12"
731 );
732}
733
734void __do_irq(struct pt_regs *regs)
735{
736 unsigned int irq;
737
738 trace_irq_entry(regs);
739
740
741
742
743
744
745 irq = ppc_md.get_irq();
746
747
748 may_hard_irq_enable();
749
750
751 if (unlikely(!irq))
752 __this_cpu_inc(irq_stat.spurious_irqs);
753 else
754 generic_handle_irq(irq);
755
756 trace_irq_exit(regs);
757}
758
759void __do_IRQ(struct pt_regs *regs)
760{
761 struct pt_regs *old_regs = set_irq_regs(regs);
762 void *cursp, *irqsp, *sirqsp;
763
764
765 cursp = (void *)(current_stack_pointer & ~(THREAD_SIZE - 1));
766 irqsp = hardirq_ctx[raw_smp_processor_id()];
767 sirqsp = softirq_ctx[raw_smp_processor_id()];
768
769 check_stack_overflow();
770
771
772 if (unlikely(cursp == irqsp || cursp == sirqsp)) {
773 __do_irq(regs);
774 set_irq_regs(old_regs);
775 return;
776 }
777
778 call_do_irq(regs, irqsp);
779
780 set_irq_regs(old_regs);
781}
782
783DEFINE_INTERRUPT_HANDLER_ASYNC(do_IRQ)
784{
785 __do_IRQ(regs);
786}
787
788static void *__init alloc_vm_stack(void)
789{
790 return __vmalloc_node(THREAD_SIZE, THREAD_ALIGN, THREADINFO_GFP,
791 NUMA_NO_NODE, (void *)_RET_IP_);
792}
793
794static void __init vmap_irqstack_init(void)
795{
796 int i;
797
798 for_each_possible_cpu(i) {
799 softirq_ctx[i] = alloc_vm_stack();
800 hardirq_ctx[i] = alloc_vm_stack();
801 }
802}
803
804
805void __init init_IRQ(void)
806{
807 if (IS_ENABLED(CONFIG_VMAP_STACK))
808 vmap_irqstack_init();
809
810 if (ppc_md.init_IRQ)
811 ppc_md.init_IRQ();
812}
813
814#if defined(CONFIG_BOOKE) || defined(CONFIG_40x)
815void *critirq_ctx[NR_CPUS] __read_mostly;
816void *dbgirq_ctx[NR_CPUS] __read_mostly;
817void *mcheckirq_ctx[NR_CPUS] __read_mostly;
818#endif
819
820void *softirq_ctx[NR_CPUS] __read_mostly;
821void *hardirq_ctx[NR_CPUS] __read_mostly;
822
823void do_softirq_own_stack(void)
824{
825 call_do_softirq(softirq_ctx[smp_processor_id()]);
826}
827
828irq_hw_number_t virq_to_hw(unsigned int virq)
829{
830 struct irq_data *irq_data = irq_get_irq_data(virq);
831 return WARN_ON(!irq_data) ? 0 : irq_data->hwirq;
832}
833EXPORT_SYMBOL_GPL(virq_to_hw);
834
835#ifdef CONFIG_SMP
836int irq_choose_cpu(const struct cpumask *mask)
837{
838 int cpuid;
839
840 if (cpumask_equal(mask, cpu_online_mask)) {
841 static int irq_rover;
842 static DEFINE_RAW_SPINLOCK(irq_rover_lock);
843 unsigned long flags;
844
845
846do_round_robin:
847 raw_spin_lock_irqsave(&irq_rover_lock, flags);
848
849 irq_rover = cpumask_next(irq_rover, cpu_online_mask);
850 if (irq_rover >= nr_cpu_ids)
851 irq_rover = cpumask_first(cpu_online_mask);
852
853 cpuid = irq_rover;
854
855 raw_spin_unlock_irqrestore(&irq_rover_lock, flags);
856 } else {
857 cpuid = cpumask_first_and(mask, cpu_online_mask);
858 if (cpuid >= nr_cpu_ids)
859 goto do_round_robin;
860 }
861
862 return get_hard_smp_processor_id(cpuid);
863}
864#else
865int irq_choose_cpu(const struct cpumask *mask)
866{
867 return hard_smp_processor_id();
868}
869#endif
870
871#ifdef CONFIG_PPC64
872static int __init setup_noirqdistrib(char *str)
873{
874 distribute_irqs = 0;
875 return 1;
876}
877
878__setup("noirqdistrib", setup_noirqdistrib);
879#endif
880