1/*
  2 * SMP Support
  3 *
  4 * Copyright (C) 1999 VA Linux Systems
  5 * Copyright (C) 1999 Walt Drummond <drummond@valinux.com>
  6 * (c) Copyright 2001-2003, 2005 Hewlett-Packard Development Company, L.P.
  7 *	David Mosberger-Tang <davidm@hpl.hp.com>
  8 *	Bjorn Helgaas <bjorn.helgaas@hp.com>
  9 */
 10#ifndef _ASM_IA64_SMP_H
 11#define _ASM_IA64_SMP_H
 12
 13#include <linux/init.h>
 14#include <linux/threads.h>
 15#include <linux/kernel.h>
 16#include <linux/cpumask.h>
 17#include <linux/bitops.h>
 18#include <linux/irqreturn.h>
 19
 20#include <asm/io.h>
 21#include <asm/param.h>
 22#include <asm/processor.h>
 23#include <asm/ptrace.h>
 24
 25static inline unsigned int
 26ia64_get_lid (void)
 27{
 28	union {
 29		struct {
 30			unsigned long reserved : 16;
 31			unsigned long eid : 8;
 32			unsigned long id : 8;
 33			unsigned long ignored : 32;
 34		} f;
 35		unsigned long bits;
 36	} lid;
 37
 38	lid.bits = ia64_getreg(_IA64_REG_CR_LID);
 39	return lid.f.id << 8 | lid.f.eid;
 40}
 41
 42#define hard_smp_processor_id()		ia64_get_lid()
 43
 44#ifdef CONFIG_SMP
 45
 46#define XTP_OFFSET		0x1e0008
 47
 48#define SMP_IRQ_REDIRECTION	(1 << 0)
 49#define SMP_IPI_REDIRECTION	(1 << 1)
 50
 51#define raw_smp_processor_id() (current_thread_info()->cpu)
 52
 53extern struct smp_boot_data {
 54	int cpu_count;
 55	int cpu_phys_id[NR_CPUS];
 56} smp_boot_data __initdata;
 57
 58extern char no_int_routing;
 59
 60extern cpumask_t cpu_core_map[NR_CPUS];
 61DECLARE_PER_CPU_SHARED_ALIGNED(cpumask_t, cpu_sibling_map);
 62extern int smp_num_siblings;
 63extern void __iomem *ipi_base_addr;
 64extern unsigned char smp_int_redirect;
 65
 66extern volatile int ia64_cpu_to_sapicid[];
 67#define cpu_physical_id(i)	ia64_cpu_to_sapicid[i]
 68
 69extern unsigned long ap_wakeup_vector;
 70
 71/*
 72 * Function to map hard smp processor id to logical id.  Slow, so don't use this in
 73 * performance-critical code.
 74 */
 75static inline int
 76cpu_logical_id (int cpuid)
 77{
 78	int i;
 79
 80	for (i = 0; i < NR_CPUS; ++i)
 81		if (cpu_physical_id(i) == cpuid)
 82			break;
 83	return i;
 84}
 85
 86/*
 87 * XTP control functions:
 88 *	min_xtp   : route all interrupts to this CPU
 89 *	normal_xtp: nominal XTP value
 90 *	max_xtp   : never deliver interrupts to this CPU.
 91 */
 92
 93static inline void
 94min_xtp (void)
 95{
 96	if (smp_int_redirect & SMP_IRQ_REDIRECTION)
 97		writeb(0x00, ipi_base_addr + XTP_OFFSET); /* XTP to min */
 98}
 99
100static inline void
101normal_xtp (void)
102{
103	if (smp_int_redirect & SMP_IRQ_REDIRECTION)
104		writeb(0x08, ipi_base_addr + XTP_OFFSET); /* XTP normal */
105}
106
107static inline void
108max_xtp (void)
109{
110	if (smp_int_redirect & SMP_IRQ_REDIRECTION)
111		writeb(0x0f, ipi_base_addr + XTP_OFFSET); /* Set XTP to max */
112}
113
114/* Upping and downing of CPUs */
115extern int __cpu_disable (void);
116extern void __cpu_die (unsigned int cpu);
117extern void cpu_die (void) __attribute__ ((noreturn));
118extern void __init smp_build_cpu_map(void);
119
120extern void __init init_smp_config (void);
121extern void smp_do_timer (struct pt_regs *regs);
122
123extern irqreturn_t handle_IPI(int irq, void *dev_id);
124extern void smp_send_reschedule (int cpu);
125extern void identify_siblings (struct cpuinfo_ia64 *);
126extern int is_multithreading_enabled(void);
127
128extern void arch_send_call_function_single_ipi(int cpu);
129extern void arch_send_call_function_ipi_mask(const struct cpumask *mask);
130
131#else /* CONFIG_SMP */
132
133#define cpu_logical_id(i)		0
134#define cpu_physical_id(i)		ia64_get_lid()
135
136#endif /* CONFIG_SMP */
137#endif /* _ASM_IA64_SMP_H */

  1/* SPDX-License-Identifier: GPL-2.0 */
  2/*
  3 * SMP Support
  4 *
  5 * Copyright (C) 1999 VA Linux Systems
  6 * Copyright (C) 1999 Walt Drummond <drummond@valinux.com>
  7 * (c) Copyright 2001-2003, 2005 Hewlett-Packard Development Company, L.P.
  8 *	David Mosberger-Tang <davidm@hpl.hp.com>
  9 *	Bjorn Helgaas <bjorn.helgaas@hp.com>
 10 */
 11#ifndef _ASM_IA64_SMP_H
 12#define _ASM_IA64_SMP_H
 13
 14#include <linux/init.h>
 15#include <linux/threads.h>
 16#include <linux/kernel.h>
 17#include <linux/cpumask.h>
 18#include <linux/bitops.h>
 19#include <linux/irqreturn.h>
 20
 21#include <asm/io.h>
 22#include <asm/param.h>
 23#include <asm/processor.h>
 24#include <asm/ptrace.h>
 25
 26static inline unsigned int
 27ia64_get_lid (void)
 28{
 29	union {
 30		struct {
 31			unsigned long reserved : 16;
 32			unsigned long eid : 8;
 33			unsigned long id : 8;
 34			unsigned long ignored : 32;
 35		} f;
 36		unsigned long bits;
 37	} lid;
 38
 39	lid.bits = ia64_getreg(_IA64_REG_CR_LID);
 40	return lid.f.id << 8 | lid.f.eid;
 41}
 42
 43#define hard_smp_processor_id()		ia64_get_lid()
 44
 45#ifdef CONFIG_SMP
 46
 47#define XTP_OFFSET		0x1e0008
 48
 49#define SMP_IRQ_REDIRECTION	(1 << 0)
 50#define SMP_IPI_REDIRECTION	(1 << 1)
 51
 52#define raw_smp_processor_id() (current_thread_info()->cpu)
 53
 54extern struct smp_boot_data {
 55	int cpu_count;
 56	int cpu_phys_id[NR_CPUS];
 57} smp_boot_data __initdata;
 58
 59extern char no_int_routing;
 60
 61extern cpumask_t cpu_core_map[NR_CPUS];
 62DECLARE_PER_CPU_SHARED_ALIGNED(cpumask_t, cpu_sibling_map);
 63extern int smp_num_siblings;
 64extern void __iomem *ipi_base_addr;
 65extern unsigned char smp_int_redirect;
 66
 67extern volatile int ia64_cpu_to_sapicid[];
 68#define cpu_physical_id(i)	ia64_cpu_to_sapicid[i]
 69
 70extern unsigned long ap_wakeup_vector;
 71
 72/*
 73 * Function to map hard smp processor id to logical id.  Slow, so don't use this in
 74 * performance-critical code.
 75 */
 76static inline int
 77cpu_logical_id (int cpuid)
 78{
 79	int i;
 80
 81	for (i = 0; i < NR_CPUS; ++i)
 82		if (cpu_physical_id(i) == cpuid)
 83			break;
 84	return i;
 85}
 86
 87/*
 88 * XTP control functions:
 89 *	min_xtp   : route all interrupts to this CPU
 90 *	normal_xtp: nominal XTP value
 91 *	max_xtp   : never deliver interrupts to this CPU.
 92 */
 93
 94static inline void
 95min_xtp (void)
 96{
 97	if (smp_int_redirect & SMP_IRQ_REDIRECTION)
 98		writeb(0x00, ipi_base_addr + XTP_OFFSET); /* XTP to min */
 99}
100
101static inline void
102normal_xtp (void)
103{
104	if (smp_int_redirect & SMP_IRQ_REDIRECTION)
105		writeb(0x08, ipi_base_addr + XTP_OFFSET); /* XTP normal */
106}
107
108static inline void
109max_xtp (void)
110{
111	if (smp_int_redirect & SMP_IRQ_REDIRECTION)
112		writeb(0x0f, ipi_base_addr + XTP_OFFSET); /* Set XTP to max */
113}
114
115/* Upping and downing of CPUs */
116extern int __cpu_disable (void);
117extern void __cpu_die (unsigned int cpu);
118extern void cpu_die (void) __attribute__ ((noreturn));
119extern void __init smp_build_cpu_map(void);
120
121extern void __init init_smp_config (void);
122extern void smp_do_timer (struct pt_regs *regs);
123
124extern irqreturn_t handle_IPI(int irq, void *dev_id);
125extern void smp_send_reschedule (int cpu);
126extern void identify_siblings (struct cpuinfo_ia64 *);
127extern int is_multithreading_enabled(void);
128
129extern void arch_send_call_function_single_ipi(int cpu);
130extern void arch_send_call_function_ipi_mask(const struct cpumask *mask);
131
132#else /* CONFIG_SMP */
133
134#define cpu_logical_id(i)		0
135#define cpu_physical_id(i)		ia64_get_lid()
136
137#endif /* CONFIG_SMP */
138#endif /* _ASM_IA64_SMP_H */