[mirror_ubuntu-zesty-kernel.git] / arch / powerpc / kernel / sysfs.c

#include <linux/sysdev.h>
#include <linux/cpu.h>
#include <linux/smp.h>
#include <linux/percpu.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/module.h>
#include <linux/nodemask.h>
#include <linux/cpumask.h>
#include <linux/notifier.h>

#include <asm/current.h>
#include <asm/processor.h>
#include <asm/cputable.h>
#include <asm/firmware.h>
#include <asm/hvcall.h>
#include <asm/prom.h>
#include <asm/machdep.h>
#include <asm/smp.h>
#include <asm/pmc.h>

#include "cacheinfo.h"

#ifdef CONFIG_PPC64
#include <asm/paca.h>
#include <asm/lppaca.h>
#endif

static DEFINE_PER_CPU(struct cpu, cpu_devices);

/*
 * SMT snooze delay stuff, 64-bit only for now
 */

#ifdef CONFIG_PPC64

/* Time in microseconds we delay before sleeping in the idle loop */
DEFINE_PER_CPU(unsigned long, smt_snooze_delay) = { 100 };

static ssize_t store_smt_snooze_delay(struct sys_device *dev,
				      struct sysdev_attribute *attr,
				      const char *buf,
				      size_t count)
{
	struct cpu *cpu = container_of(dev, struct cpu, sysdev);
	ssize_t ret;
	unsigned long snooze;

	ret = sscanf(buf, "%lu", &snooze);
	if (ret != 1)
		return -EINVAL;

	per_cpu(smt_snooze_delay, cpu->sysdev.id) = snooze;

	return count;
}

static ssize_t show_smt_snooze_delay(struct sys_device *dev,
				     struct sysdev_attribute *attr,
				     char *buf)
{
	struct cpu *cpu = container_of(dev, struct cpu, sysdev);

	return sprintf(buf, "%lu\n", per_cpu(smt_snooze_delay, cpu->sysdev.id));
}

static SYSDEV_ATTR(smt_snooze_delay, 0644, show_smt_snooze_delay,
		   store_smt_snooze_delay);

static int __init setup_smt_snooze_delay(char *str)
{
	unsigned int cpu;
	int snooze;

	if (!cpu_has_feature(CPU_FTR_SMT))
		return 1;

	if (get_option(&str, &snooze)) {
		for_each_possible_cpu(cpu)
			per_cpu(smt_snooze_delay, cpu) = snooze;
	}

	return 1;
}
__setup("smt-snooze-delay=", setup_smt_snooze_delay);

#endif /* CONFIG_PPC64 */

/*
 * Enabling PMCs will slow partition context switch times so we only do
 * it the first time we write to the PMCs.
 */

static DEFINE_PER_CPU(char, pmcs_enabled);

void ppc_enable_pmcs(void)
{
	ppc_set_pmu_inuse(1);

	/* Only need to enable them once */
	if (__get_cpu_var(pmcs_enabled))
		return;

	__get_cpu_var(pmcs_enabled) = 1;

	if (ppc_md.enable_pmcs)
		ppc_md.enable_pmcs();
}
EXPORT_SYMBOL(ppc_enable_pmcs);

#define SYSFS_PMCSETUP(NAME, ADDRESS) \
static void read_##NAME(void *val) \
{ \
	*(unsigned long *)val = mfspr(ADDRESS);	\
} \
static void write_##NAME(void *val) \
{ \
	ppc_enable_pmcs(); \
	mtspr(ADDRESS, *(unsigned long *)val);	\
} \
static ssize_t show_##NAME(struct sys_device *dev, \
			struct sysdev_attribute *attr, \
			char *buf) \
{ \
	struct cpu *cpu = container_of(dev, struct cpu, sysdev); \
	unsigned long val; \
	smp_call_function_single(cpu->sysdev.id, read_##NAME, &val, 1);	\
	return sprintf(buf, "%lx\n", val); \
} \
static ssize_t __used \
	store_##NAME(struct sys_device *dev, struct sysdev_attribute *attr, \
			const char *buf, size_t count) \
{ \
	struct cpu *cpu = container_of(dev, struct cpu, sysdev); \
	unsigned long val; \
	int ret = sscanf(buf, "%lx", &val); \
	if (ret != 1) \
		return -EINVAL; \
	smp_call_function_single(cpu->sysdev.id, write_##NAME, &val, 1); \
	return count; \
}


/* Let's define all possible registers, we'll only hook up the ones
 * that are implemented on the current processor
 */

#if defined(CONFIG_PPC64)
#define HAS_PPC_PMC_CLASSIC	1
#define HAS_PPC_PMC_IBM		1
#define HAS_PPC_PMC_PA6T	1
#elif defined(CONFIG_6xx)
#define HAS_PPC_PMC_CLASSIC	1
#define HAS_PPC_PMC_IBM		1
#define HAS_PPC_PMC_G4		1
#endif


#ifdef HAS_PPC_PMC_CLASSIC
SYSFS_PMCSETUP(mmcr0, SPRN_MMCR0);
SYSFS_PMCSETUP(mmcr1, SPRN_MMCR1);
SYSFS_PMCSETUP(pmc1, SPRN_PMC1);
SYSFS_PMCSETUP(pmc2, SPRN_PMC2);
SYSFS_PMCSETUP(pmc3, SPRN_PMC3);
SYSFS_PMCSETUP(pmc4, SPRN_PMC4);
SYSFS_PMCSETUP(pmc5, SPRN_PMC5);
SYSFS_PMCSETUP(pmc6, SPRN_PMC6);

#ifdef HAS_PPC_PMC_G4
SYSFS_PMCSETUP(mmcr2, SPRN_MMCR2);
#endif

#ifdef CONFIG_PPC64
SYSFS_PMCSETUP(pmc7, SPRN_PMC7);
SYSFS_PMCSETUP(pmc8, SPRN_PMC8);

SYSFS_PMCSETUP(mmcra, SPRN_MMCRA);
SYSFS_PMCSETUP(purr, SPRN_PURR);
SYSFS_PMCSETUP(spurr, SPRN_SPURR);
SYSFS_PMCSETUP(dscr, SPRN_DSCR);

static SYSDEV_ATTR(mmcra, 0600, show_mmcra, store_mmcra);
static SYSDEV_ATTR(spurr, 0600, show_spurr, NULL);
static SYSDEV_ATTR(dscr, 0600, show_dscr, store_dscr);
static SYSDEV_ATTR(purr, 0600, show_purr, store_purr);
#endif /* CONFIG_PPC64 */

#ifdef HAS_PPC_PMC_PA6T
SYSFS_PMCSETUP(pa6t_pmc0, SPRN_PA6T_PMC0);
SYSFS_PMCSETUP(pa6t_pmc1, SPRN_PA6T_PMC1);
SYSFS_PMCSETUP(pa6t_pmc2, SPRN_PA6T_PMC2);
SYSFS_PMCSETUP(pa6t_pmc3, SPRN_PA6T_PMC3);
SYSFS_PMCSETUP(pa6t_pmc4, SPRN_PA6T_PMC4);
SYSFS_PMCSETUP(pa6t_pmc5, SPRN_PA6T_PMC5);
#ifdef CONFIG_DEBUG_KERNEL
SYSFS_PMCSETUP(hid0, SPRN_HID0);
SYSFS_PMCSETUP(hid1, SPRN_HID1);
SYSFS_PMCSETUP(hid4, SPRN_HID4);
SYSFS_PMCSETUP(hid5, SPRN_HID5);
SYSFS_PMCSETUP(ima0, SPRN_PA6T_IMA0);
SYSFS_PMCSETUP(ima1, SPRN_PA6T_IMA1);
SYSFS_PMCSETUP(ima2, SPRN_PA6T_IMA2);
SYSFS_PMCSETUP(ima3, SPRN_PA6T_IMA3);
SYSFS_PMCSETUP(ima4, SPRN_PA6T_IMA4);
SYSFS_PMCSETUP(ima5, SPRN_PA6T_IMA5);
SYSFS_PMCSETUP(ima6, SPRN_PA6T_IMA6);
SYSFS_PMCSETUP(ima7, SPRN_PA6T_IMA7);
SYSFS_PMCSETUP(ima8, SPRN_PA6T_IMA8);
SYSFS_PMCSETUP(ima9, SPRN_PA6T_IMA9);
SYSFS_PMCSETUP(imaat, SPRN_PA6T_IMAAT);
SYSFS_PMCSETUP(btcr, SPRN_PA6T_BTCR);
SYSFS_PMCSETUP(pccr, SPRN_PA6T_PCCR);
SYSFS_PMCSETUP(rpccr, SPRN_PA6T_RPCCR);
SYSFS_PMCSETUP(der, SPRN_PA6T_DER);
SYSFS_PMCSETUP(mer, SPRN_PA6T_MER);
SYSFS_PMCSETUP(ber, SPRN_PA6T_BER);
SYSFS_PMCSETUP(ier, SPRN_PA6T_IER);
SYSFS_PMCSETUP(sier, SPRN_PA6T_SIER);
SYSFS_PMCSETUP(siar, SPRN_PA6T_SIAR);
SYSFS_PMCSETUP(tsr0, SPRN_PA6T_TSR0);
SYSFS_PMCSETUP(tsr1, SPRN_PA6T_TSR1);
SYSFS_PMCSETUP(tsr2, SPRN_PA6T_TSR2);
SYSFS_PMCSETUP(tsr3, SPRN_PA6T_TSR3);
#endif /* CONFIG_DEBUG_KERNEL */
#endif /* HAS_PPC_PMC_PA6T */

#ifdef HAS_PPC_PMC_IBM
static struct sysdev_attribute ibm_common_attrs[] = {
	_SYSDEV_ATTR(mmcr0, 0600, show_mmcr0, store_mmcr0),
	_SYSDEV_ATTR(mmcr1, 0600, show_mmcr1, store_mmcr1),
};
#endif /* HAS_PPC_PMC_G4 */

#ifdef HAS_PPC_PMC_G4
static struct sysdev_attribute g4_common_attrs[] = {
	_SYSDEV_ATTR(mmcr0, 0600, show_mmcr0, store_mmcr0),
	_SYSDEV_ATTR(mmcr1, 0600, show_mmcr1, store_mmcr1),
	_SYSDEV_ATTR(mmcr2, 0600, show_mmcr2, store_mmcr2),
};
#endif /* HAS_PPC_PMC_G4 */

static struct sysdev_attribute classic_pmc_attrs[] = {
	_SYSDEV_ATTR(pmc1, 0600, show_pmc1, store_pmc1),
	_SYSDEV_ATTR(pmc2, 0600, show_pmc2, store_pmc2),
	_SYSDEV_ATTR(pmc3, 0600, show_pmc3, store_pmc3),
	_SYSDEV_ATTR(pmc4, 0600, show_pmc4, store_pmc4),
	_SYSDEV_ATTR(pmc5, 0600, show_pmc5, store_pmc5),
	_SYSDEV_ATTR(pmc6, 0600, show_pmc6, store_pmc6),
#ifdef CONFIG_PPC64
	_SYSDEV_ATTR(pmc7, 0600, show_pmc7, store_pmc7),
	_SYSDEV_ATTR(pmc8, 0600, show_pmc8, store_pmc8),
#endif
};

#ifdef HAS_PPC_PMC_PA6T
static struct sysdev_attribute pa6t_attrs[] = {
	_SYSDEV_ATTR(mmcr0, 0600, show_mmcr0, store_mmcr0),
	_SYSDEV_ATTR(mmcr1, 0600, show_mmcr1, store_mmcr1),
	_SYSDEV_ATTR(pmc0, 0600, show_pa6t_pmc0, store_pa6t_pmc0),
	_SYSDEV_ATTR(pmc1, 0600, show_pa6t_pmc1, store_pa6t_pmc1),
	_SYSDEV_ATTR(pmc2, 0600, show_pa6t_pmc2, store_pa6t_pmc2),
	_SYSDEV_ATTR(pmc3, 0600, show_pa6t_pmc3, store_pa6t_pmc3),
	_SYSDEV_ATTR(pmc4, 0600, show_pa6t_pmc4, store_pa6t_pmc4),
	_SYSDEV_ATTR(pmc5, 0600, show_pa6t_pmc5, store_pa6t_pmc5),
#ifdef CONFIG_DEBUG_KERNEL
	_SYSDEV_ATTR(hid0, 0600, show_hid0, store_hid0),
	_SYSDEV_ATTR(hid1, 0600, show_hid1, store_hid1),
	_SYSDEV_ATTR(hid4, 0600, show_hid4, store_hid4),
	_SYSDEV_ATTR(hid5, 0600, show_hid5, store_hid5),
	_SYSDEV_ATTR(ima0, 0600, show_ima0, store_ima0),
	_SYSDEV_ATTR(ima1, 0600, show_ima1, store_ima1),
	_SYSDEV_ATTR(ima2, 0600, show_ima2, store_ima2),
	_SYSDEV_ATTR(ima3, 0600, show_ima3, store_ima3),
	_SYSDEV_ATTR(ima4, 0600, show_ima4, store_ima4),
	_SYSDEV_ATTR(ima5, 0600, show_ima5, store_ima5),
	_SYSDEV_ATTR(ima6, 0600, show_ima6, store_ima6),
	_SYSDEV_ATTR(ima7, 0600, show_ima7, store_ima7),
	_SYSDEV_ATTR(ima8, 0600, show_ima8, store_ima8),
	_SYSDEV_ATTR(ima9, 0600, show_ima9, store_ima9),
	_SYSDEV_ATTR(imaat, 0600, show_imaat, store_imaat),
	_SYSDEV_ATTR(btcr, 0600, show_btcr, store_btcr),
	_SYSDEV_ATTR(pccr, 0600, show_pccr, store_pccr),
	_SYSDEV_ATTR(rpccr, 0600, show_rpccr, store_rpccr),
	_SYSDEV_ATTR(der, 0600, show_der, store_der),
	_SYSDEV_ATTR(mer, 0600, show_mer, store_mer),
	_SYSDEV_ATTR(ber, 0600, show_ber, store_ber),
	_SYSDEV_ATTR(ier, 0600, show_ier, store_ier),
	_SYSDEV_ATTR(sier, 0600, show_sier, store_sier),
	_SYSDEV_ATTR(siar, 0600, show_siar, store_siar),
	_SYSDEV_ATTR(tsr0, 0600, show_tsr0, store_tsr0),
	_SYSDEV_ATTR(tsr1, 0600, show_tsr1, store_tsr1),
	_SYSDEV_ATTR(tsr2, 0600, show_tsr2, store_tsr2),
	_SYSDEV_ATTR(tsr3, 0600, show_tsr3, store_tsr3),
#endif /* CONFIG_DEBUG_KERNEL */
};
#endif /* HAS_PPC_PMC_PA6T */
#endif /* HAS_PPC_PMC_CLASSIC */

static void __cpuinit register_cpu_online(unsigned int cpu)
{
	struct cpu *c = &per_cpu(cpu_devices, cpu);
	struct sys_device *s = &c->sysdev;
	struct sysdev_attribute *attrs, *pmc_attrs;
	int i, nattrs;

#ifdef CONFIG_PPC64
	if (!firmware_has_feature(FW_FEATURE_ISERIES) &&
			cpu_has_feature(CPU_FTR_SMT))
		sysdev_create_file(s, &attr_smt_snooze_delay);
#endif

	/* PMC stuff */
	switch (cur_cpu_spec->pmc_type) {
#ifdef HAS_PPC_PMC_IBM
	case PPC_PMC_IBM:
		attrs = ibm_common_attrs;
		nattrs = sizeof(ibm_common_attrs) / sizeof(struct sysdev_attribute);
		pmc_attrs = classic_pmc_attrs;
		break;
#endif /* HAS_PPC_PMC_IBM */
#ifdef HAS_PPC_PMC_G4
	case PPC_PMC_G4:
		attrs = g4_common_attrs;
		nattrs = sizeof(g4_common_attrs) / sizeof(struct sysdev_attribute);
		pmc_attrs = classic_pmc_attrs;
		break;
#endif /* HAS_PPC_PMC_G4 */
#ifdef HAS_PPC_PMC_PA6T
	case PPC_PMC_PA6T:
		/* PA Semi starts counting at PMC0 */
		attrs = pa6t_attrs;
		nattrs = sizeof(pa6t_attrs) / sizeof(struct sysdev_attribute);
		pmc_attrs = NULL;
		break;
#endif /* HAS_PPC_PMC_PA6T */
	default:
		attrs = NULL;
		nattrs = 0;
		pmc_attrs = NULL;
	}

	for (i = 0; i < nattrs; i++)
		sysdev_create_file(s, &attrs[i]);

	if (pmc_attrs)
		for (i = 0; i < cur_cpu_spec->num_pmcs; i++)
			sysdev_create_file(s, &pmc_attrs[i]);

#ifdef CONFIG_PPC64
	if (cpu_has_feature(CPU_FTR_MMCRA))
		sysdev_create_file(s, &attr_mmcra);

	if (cpu_has_feature(CPU_FTR_PURR))
		sysdev_create_file(s, &attr_purr);

	if (cpu_has_feature(CPU_FTR_SPURR))
		sysdev_create_file(s, &attr_spurr);

	if (cpu_has_feature(CPU_FTR_DSCR))
		sysdev_create_file(s, &attr_dscr);
#endif /* CONFIG_PPC64 */

	cacheinfo_cpu_online(cpu);
}

#ifdef CONFIG_HOTPLUG_CPU
static void unregister_cpu_online(unsigned int cpu)
{
	struct cpu *c = &per_cpu(cpu_devices, cpu);
	struct sys_device *s = &c->sysdev;
	struct sysdev_attribute *attrs, *pmc_attrs;
	int i, nattrs;

	BUG_ON(!c->hotpluggable);

#ifdef CONFIG_PPC64
	if (!firmware_has_feature(FW_FEATURE_ISERIES) &&
			cpu_has_feature(CPU_FTR_SMT))
		sysdev_remove_file(s, &attr_smt_snooze_delay);
#endif

	/* PMC stuff */
	switch (cur_cpu_spec->pmc_type) {
#ifdef HAS_PPC_PMC_IBM
	case PPC_PMC_IBM:
		attrs = ibm_common_attrs;
		nattrs = sizeof(ibm_common_attrs) / sizeof(struct sysdev_attribute);
		pmc_attrs = classic_pmc_attrs;
		break;
#endif /* HAS_PPC_PMC_IBM */
#ifdef HAS_PPC_PMC_G4
	case PPC_PMC_G4:
		attrs = g4_common_attrs;
		nattrs = sizeof(g4_common_attrs) / sizeof(struct sysdev_attribute);
		pmc_attrs = classic_pmc_attrs;
		break;
#endif /* HAS_PPC_PMC_G4 */
#ifdef HAS_PPC_PMC_PA6T
	case PPC_PMC_PA6T:
		/* PA Semi starts counting at PMC0 */
		attrs = pa6t_attrs;
		nattrs = sizeof(pa6t_attrs) / sizeof(struct sysdev_attribute);
		pmc_attrs = NULL;
		break;
#endif /* HAS_PPC_PMC_PA6T */
	default:
		attrs = NULL;
		nattrs = 0;
		pmc_attrs = NULL;
	}

	for (i = 0; i < nattrs; i++)
		sysdev_remove_file(s, &attrs[i]);

	if (pmc_attrs)
		for (i = 0; i < cur_cpu_spec->num_pmcs; i++)
			sysdev_remove_file(s, &pmc_attrs[i]);

#ifdef CONFIG_PPC64
	if (cpu_has_feature(CPU_FTR_MMCRA))
		sysdev_remove_file(s, &attr_mmcra);

	if (cpu_has_feature(CPU_FTR_PURR))
		sysdev_remove_file(s, &attr_purr);

	if (cpu_has_feature(CPU_FTR_SPURR))
		sysdev_remove_file(s, &attr_spurr);

	if (cpu_has_feature(CPU_FTR_DSCR))
		sysdev_remove_file(s, &attr_dscr);
#endif /* CONFIG_PPC64 */

	cacheinfo_cpu_offline(cpu);
}

#ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
ssize_t arch_cpu_probe(const char *buf, size_t count)
{
	if (ppc_md.cpu_probe)
		return ppc_md.cpu_probe(buf, count);

	return -EINVAL;
}

ssize_t arch_cpu_release(const char *buf, size_t count)
{
	if (ppc_md.cpu_release)
		return ppc_md.cpu_release(buf, count);

	return -EINVAL;
}
#endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */

#endif /* CONFIG_HOTPLUG_CPU */

static int __cpuinit sysfs_cpu_notify(struct notifier_block *self,
				      unsigned long action, void *hcpu)
{
	unsigned int cpu = (unsigned int)(long)hcpu;

	switch (action) {
	case CPU_ONLINE:
	case CPU_ONLINE_FROZEN:
		register_cpu_online(cpu);
		break;
#ifdef CONFIG_HOTPLUG_CPU
	case CPU_DEAD:
	case CPU_DEAD_FROZEN:
		unregister_cpu_online(cpu);
		break;
#endif
	}
	return NOTIFY_OK;
}

static struct notifier_block __cpuinitdata sysfs_cpu_nb = {
	.notifier_call	= sysfs_cpu_notify,
};

static DEFINE_MUTEX(cpu_mutex);

int cpu_add_sysdev_attr(struct sysdev_attribute *attr)
{
	int cpu;

	mutex_lock(&cpu_mutex);

	for_each_possible_cpu(cpu) {
		sysdev_create_file(get_cpu_sysdev(cpu), attr);
	}

	mutex_unlock(&cpu_mutex);
	return 0;
}
EXPORT_SYMBOL_GPL(cpu_add_sysdev_attr);

int cpu_add_sysdev_attr_group(struct attribute_group *attrs)
{
	int cpu;
	struct sys_device *sysdev;
	int ret;

	mutex_lock(&cpu_mutex);

	for_each_possible_cpu(cpu) {
		sysdev = get_cpu_sysdev(cpu);
		ret = sysfs_create_group(&sysdev->kobj, attrs);
		WARN_ON(ret != 0);
	}

	mutex_unlock(&cpu_mutex);
	return 0;
}
EXPORT_SYMBOL_GPL(cpu_add_sysdev_attr_group);


void cpu_remove_sysdev_attr(struct sysdev_attribute *attr)
{
	int cpu;

	mutex_lock(&cpu_mutex);

	for_each_possible_cpu(cpu) {
		sysdev_remove_file(get_cpu_sysdev(cpu), attr);
	}

	mutex_unlock(&cpu_mutex);
}
EXPORT_SYMBOL_GPL(cpu_remove_sysdev_attr);

void cpu_remove_sysdev_attr_group(struct attribute_group *attrs)
{
	int cpu;
	struct sys_device *sysdev;

	mutex_lock(&cpu_mutex);

	for_each_possible_cpu(cpu) {
		sysdev = get_cpu_sysdev(cpu);
		sysfs_remove_group(&sysdev->kobj, attrs);
	}

	mutex_unlock(&cpu_mutex);
}
EXPORT_SYMBOL_GPL(cpu_remove_sysdev_attr_group);


/* NUMA stuff */

#ifdef CONFIG_NUMA
static void register_nodes(void)
{
	int i;

	for (i = 0; i < MAX_NUMNODES; i++)
		register_one_node(i);
}

int sysfs_add_device_to_node(struct sys_device *dev, int nid)
{
	struct node *node = &node_devices[nid];
	return sysfs_create_link(&node->sysdev.kobj, &dev->kobj,
			kobject_name(&dev->kobj));
}
EXPORT_SYMBOL_GPL(sysfs_add_device_to_node);

void sysfs_remove_device_from_node(struct sys_device *dev, int nid)
{
	struct node *node = &node_devices[nid];
	sysfs_remove_link(&node->sysdev.kobj, kobject_name(&dev->kobj));
}
EXPORT_SYMBOL_GPL(sysfs_remove_device_from_node);

#else
static void register_nodes(void)
{
	return;
}

#endif

/* Only valid if CPU is present. */
static ssize_t show_physical_id(struct sys_device *dev,
				struct sysdev_attribute *attr, char *buf)
{
	struct cpu *cpu = container_of(dev, struct cpu, sysdev);

	return sprintf(buf, "%d\n", get_hard_smp_processor_id(cpu->sysdev.id));
}
static SYSDEV_ATTR(physical_id, 0444, show_physical_id, NULL);

static int __init topology_init(void)
{
	int cpu;

	register_nodes();
	register_cpu_notifier(&sysfs_cpu_nb);

	for_each_possible_cpu(cpu) {
		struct cpu *c = &per_cpu(cpu_devices, cpu);

		/*
		 * For now, we just see if the system supports making
		 * the RTAS calls for CPU hotplug.  But, there may be a
		 * more comprehensive way to do this for an individual
		 * CPU.  For instance, the boot cpu might never be valid
		 * for hotplugging.
		 */
		if (ppc_md.cpu_die)
			c->hotpluggable = 1;

		if (cpu_online(cpu) || c->hotpluggable) {
			register_cpu(c, cpu);

			sysdev_create_file(&c->sysdev, &attr_physical_id);
		}

		if (cpu_online(cpu))
			register_cpu_online(cpu);
	}

	return 0;
}
subsys_initcall(topology_init);
Commit	Line	Data
1da177e4 LT	1	#include <linux/sysdev.h>
	2	#include <linux/cpu.h>
	3	#include <linux/smp.h>
	4	#include <linux/percpu.h>
	5	#include <linux/init.h>
	6	#include <linux/sched.h>
	7	#include <linux/module.h>
	8	#include <linux/nodemask.h>
	9	#include <linux/cpumask.h>
	10	#include <linux/notifier.h>
	11
	12	#include <asm/current.h>
	13	#include <asm/processor.h>
	14	#include <asm/cputable.h>
1ababe11	15	#include <asm/firmware.h>
1da177e4 LT	16	#include <asm/hvcall.h>
1da177e4 LT	17	#include <asm/prom.h>
1da177e4	18	#include <asm/machdep.h>
2249ca9d	19	#include <asm/smp.h>
a6dbf93a	20	#include <asm/pmc.h>
1da177e4	21
93197a36 NL	22	#include "cacheinfo.h"
93197a36 NL	23
b950bdd0 BH	24	#ifdef CONFIG_PPC64
	25	#include <asm/paca.h>
	26	#include <asm/lppaca.h>
	27	#endif
	28
1da177e4 LT	29	static DEFINE_PER_CPU(struct cpu, cpu_devices);
1da177e4 LT	30
b950bdd0 BH	31	/*
	32	* SMT snooze delay stuff, 64-bit only for now
	33	*/
	34
	35	#ifdef CONFIG_PPC64
1da177e4	36
0ddd3e7d AB	37	/* Time in microseconds we delay before sleeping in the idle loop */
0ddd3e7d AB	38	DEFINE_PER_CPU(unsigned long, smt_snooze_delay) = { 100 };
1da177e4	39
4a0b2b4d AK	40	static ssize_t store_smt_snooze_delay(struct sys_device *dev,
	41	struct sysdev_attribute *attr,
	42	const char *buf,
1da177e4 LT	43	size_t count)
	44	{
	45	struct cpu *cpu = container_of(dev, struct cpu, sysdev);
	46	ssize_t ret;
	47	unsigned long snooze;
	48
	49	ret = sscanf(buf, "%lu", &snooze);
	50	if (ret != 1)
	51	return -EINVAL;
	52
	53	per_cpu(smt_snooze_delay, cpu->sysdev.id) = snooze;
	54
	55	return count;
	56	}
	57
4a0b2b4d AK	58	static ssize_t show_smt_snooze_delay(struct sys_device *dev,
	59	struct sysdev_attribute *attr,
	60	char *buf)
1da177e4 LT	61	{
	62	struct cpu *cpu = container_of(dev, struct cpu, sysdev);
	63
	64	return sprintf(buf, "%lu\n", per_cpu(smt_snooze_delay, cpu->sysdev.id));
	65	}
	66
	67	static SYSDEV_ATTR(smt_snooze_delay, 0644, show_smt_snooze_delay,
	68	store_smt_snooze_delay);
	69
1da177e4 LT	70	static int __init setup_smt_snooze_delay(char *str)
	71	{
	72	unsigned int cpu;
	73	int snooze;
	74
	75	if (!cpu_has_feature(CPU_FTR_SMT))
	76	return 1;
	77
1da177e4	78	if (get_option(&str, &snooze)) {
0e551954	79	for_each_possible_cpu(cpu)
1da177e4 LT	80	per_cpu(smt_snooze_delay, cpu) = snooze;
	81	}
	82
	83	return 1;
	84	}
	85	__setup("smt-snooze-delay=", setup_smt_snooze_delay);
	86
b950bdd0	87	#endif /* CONFIG_PPC64 */
180a3362	88
1da177e4 LT	89	/*
	90	* Enabling PMCs will slow partition context switch times so we only do
	91	* it the first time we write to the PMCs.
	92	*/
	93
	94	static DEFINE_PER_CPU(char, pmcs_enabled);
	95
b950bdd0	96	void ppc_enable_pmcs(void)
1da177e4	97	{
a6dbf93a PM	98	ppc_set_pmu_inuse(1);
a6dbf93a PM	99
1da177e4 LT	100	/* Only need to enable them once */
	101	if (__get_cpu_var(pmcs_enabled))
	102	return;
	103
	104	__get_cpu_var(pmcs_enabled) = 1;
	105
180a3362 ME	106	if (ppc_md.enable_pmcs)
180a3362 ME	107	ppc_md.enable_pmcs();
1da177e4	108	}
b950bdd0	109	EXPORT_SYMBOL(ppc_enable_pmcs);
1da177e4	110
1da177e4	111	#define SYSFS_PMCSETUP(NAME, ADDRESS) \
9a371934	112	static void read_##NAME(void *val) \
1da177e4	113	{ \
ec78c8ac	114	(unsigned long )val = mfspr(ADDRESS); \
1da177e4	115	} \
ec78c8ac	116	static void write_##NAME(void *val) \
1da177e4	117	{ \
b950bdd0	118	ppc_enable_pmcs(); \
9a371934	119	mtspr(ADDRESS, (unsigned long )val); \
1da177e4	120	} \
4a0b2b4d AK	121	static ssize_t show_##NAME(struct sys_device *dev, \
	122	struct sysdev_attribute *attr, \
	123	char *buf) \
1da177e4 LT	124	{ \
1da177e4 LT	125	struct cpu *cpu = container_of(dev, struct cpu, sysdev); \
9a371934 RR	126	unsigned long val; \
9a371934 RR	127	smp_call_function_single(cpu->sysdev.id, read_##NAME, &val, 1); \
1da177e4 LT	128	return sprintf(buf, "%lx\n", val); \
1da177e4 LT	129	} \
3ff6eecc	130	static ssize_t __used \
4a0b2b4d AK	131	store_##NAME(struct sys_device dev, struct sysdev_attribute attr, \
4a0b2b4d AK	132	const char *buf, size_t count) \
1da177e4 LT	133	{ \
	134	struct cpu *cpu = container_of(dev, struct cpu, sysdev); \
	135	unsigned long val; \
	136	int ret = sscanf(buf, "%lx", &val); \
	137	if (ret != 1) \
	138	return -EINVAL; \
9a371934	139	smp_call_function_single(cpu->sysdev.id, write_##NAME, &val, 1); \
1da177e4 LT	140	return count; \
	141	}
	142
6529c13d OJ	143
	144	/* Let's define all possible registers, we'll only hook up the ones
	145	* that are implemented on the current processor
	146	*/
	147
33a7f122	148	#if defined(CONFIG_PPC64)
b950bdd0 BH	149	#define HAS_PPC_PMC_CLASSIC 1
	150	#define HAS_PPC_PMC_IBM 1
	151	#define HAS_PPC_PMC_PA6T 1
33a7f122	152	#elif defined(CONFIG_6xx)
b950bdd0 BH	153	#define HAS_PPC_PMC_CLASSIC 1
	154	#define HAS_PPC_PMC_IBM 1
	155	#define HAS_PPC_PMC_G4 1
	156	#endif
	157
	158
	159	#ifdef HAS_PPC_PMC_CLASSIC
1da177e4 LT	160	SYSFS_PMCSETUP(mmcr0, SPRN_MMCR0);
1da177e4 LT	161	SYSFS_PMCSETUP(mmcr1, SPRN_MMCR1);
1da177e4 LT	162	SYSFS_PMCSETUP(pmc1, SPRN_PMC1);
	163	SYSFS_PMCSETUP(pmc2, SPRN_PMC2);
	164	SYSFS_PMCSETUP(pmc3, SPRN_PMC3);
	165	SYSFS_PMCSETUP(pmc4, SPRN_PMC4);
	166	SYSFS_PMCSETUP(pmc5, SPRN_PMC5);
	167	SYSFS_PMCSETUP(pmc6, SPRN_PMC6);
b950bdd0 BH	168
	169	#ifdef HAS_PPC_PMC_G4
	170	SYSFS_PMCSETUP(mmcr2, SPRN_MMCR2);
	171	#endif
	172
	173	#ifdef CONFIG_PPC64
1da177e4 LT	174	SYSFS_PMCSETUP(pmc7, SPRN_PMC7);
1da177e4 LT	175	SYSFS_PMCSETUP(pmc8, SPRN_PMC8);
b950bdd0 BH	176
b950bdd0 BH	177	SYSFS_PMCSETUP(mmcra, SPRN_MMCRA);
1da177e4	178	SYSFS_PMCSETUP(purr, SPRN_PURR);
f050982a	179	SYSFS_PMCSETUP(spurr, SPRN_SPURR);
4c198557	180	SYSFS_PMCSETUP(dscr, SPRN_DSCR);
1da177e4	181
b950bdd0 BH	182	static SYSDEV_ATTR(mmcra, 0600, show_mmcra, store_mmcra);
	183	static SYSDEV_ATTR(spurr, 0600, show_spurr, NULL);
	184	static SYSDEV_ATTR(dscr, 0600, show_dscr, store_dscr);
	185	static SYSDEV_ATTR(purr, 0600, show_purr, store_purr);
	186	#endif /* CONFIG_PPC64 */
	187
	188	#ifdef HAS_PPC_PMC_PA6T
25fc530e OJ	189	SYSFS_PMCSETUP(pa6t_pmc0, SPRN_PA6T_PMC0);
	190	SYSFS_PMCSETUP(pa6t_pmc1, SPRN_PA6T_PMC1);
	191	SYSFS_PMCSETUP(pa6t_pmc2, SPRN_PA6T_PMC2);
	192	SYSFS_PMCSETUP(pa6t_pmc3, SPRN_PA6T_PMC3);
	193	SYSFS_PMCSETUP(pa6t_pmc4, SPRN_PA6T_PMC4);
	194	SYSFS_PMCSETUP(pa6t_pmc5, SPRN_PA6T_PMC5);
2e1957fd OJ	195	#ifdef CONFIG_DEBUG_KERNEL
	196	SYSFS_PMCSETUP(hid0, SPRN_HID0);
	197	SYSFS_PMCSETUP(hid1, SPRN_HID1);
	198	SYSFS_PMCSETUP(hid4, SPRN_HID4);
	199	SYSFS_PMCSETUP(hid5, SPRN_HID5);
	200	SYSFS_PMCSETUP(ima0, SPRN_PA6T_IMA0);
	201	SYSFS_PMCSETUP(ima1, SPRN_PA6T_IMA1);
	202	SYSFS_PMCSETUP(ima2, SPRN_PA6T_IMA2);
	203	SYSFS_PMCSETUP(ima3, SPRN_PA6T_IMA3);
	204	SYSFS_PMCSETUP(ima4, SPRN_PA6T_IMA4);
	205	SYSFS_PMCSETUP(ima5, SPRN_PA6T_IMA5);
	206	SYSFS_PMCSETUP(ima6, SPRN_PA6T_IMA6);
	207	SYSFS_PMCSETUP(ima7, SPRN_PA6T_IMA7);
	208	SYSFS_PMCSETUP(ima8, SPRN_PA6T_IMA8);
	209	SYSFS_PMCSETUP(ima9, SPRN_PA6T_IMA9);
	210	SYSFS_PMCSETUP(imaat, SPRN_PA6T_IMAAT);
	211	SYSFS_PMCSETUP(btcr, SPRN_PA6T_BTCR);
	212	SYSFS_PMCSETUP(pccr, SPRN_PA6T_PCCR);
	213	SYSFS_PMCSETUP(rpccr, SPRN_PA6T_RPCCR);
	214	SYSFS_PMCSETUP(der, SPRN_PA6T_DER);
	215	SYSFS_PMCSETUP(mer, SPRN_PA6T_MER);
	216	SYSFS_PMCSETUP(ber, SPRN_PA6T_BER);
	217	SYSFS_PMCSETUP(ier, SPRN_PA6T_IER);
	218	SYSFS_PMCSETUP(sier, SPRN_PA6T_SIER);
	219	SYSFS_PMCSETUP(siar, SPRN_PA6T_SIAR);
	220	SYSFS_PMCSETUP(tsr0, SPRN_PA6T_TSR0);
	221	SYSFS_PMCSETUP(tsr1, SPRN_PA6T_TSR1);
	222	SYSFS_PMCSETUP(tsr2, SPRN_PA6T_TSR2);
	223	SYSFS_PMCSETUP(tsr3, SPRN_PA6T_TSR3);
	224	#endif /* CONFIG_DEBUG_KERNEL */
b950bdd0	225	#endif /* HAS_PPC_PMC_PA6T */
6529c13d	226
b950bdd0	227	#ifdef HAS_PPC_PMC_IBM
6529c13d OJ	228	static struct sysdev_attribute ibm_common_attrs[] = {
	229	_SYSDEV_ATTR(mmcr0, 0600, show_mmcr0, store_mmcr0),
	230	_SYSDEV_ATTR(mmcr1, 0600, show_mmcr1, store_mmcr1),
	231	};
b950bdd0 BH	232	#endif /* HAS_PPC_PMC_G4 */
	233
	234	#ifdef HAS_PPC_PMC_G4
	235	static struct sysdev_attribute g4_common_attrs[] = {
	236	_SYSDEV_ATTR(mmcr0, 0600, show_mmcr0, store_mmcr0),
	237	_SYSDEV_ATTR(mmcr1, 0600, show_mmcr1, store_mmcr1),
	238	_SYSDEV_ATTR(mmcr2, 0600, show_mmcr2, store_mmcr2),
	239	};
	240	#endif /* HAS_PPC_PMC_G4 */
6529c13d	241
b950bdd0	242	static struct sysdev_attribute classic_pmc_attrs[] = {
6529c13d OJ	243	_SYSDEV_ATTR(pmc1, 0600, show_pmc1, store_pmc1),
	244	_SYSDEV_ATTR(pmc2, 0600, show_pmc2, store_pmc2),
	245	_SYSDEV_ATTR(pmc3, 0600, show_pmc3, store_pmc3),
	246	_SYSDEV_ATTR(pmc4, 0600, show_pmc4, store_pmc4),
	247	_SYSDEV_ATTR(pmc5, 0600, show_pmc5, store_pmc5),
	248	_SYSDEV_ATTR(pmc6, 0600, show_pmc6, store_pmc6),
b950bdd0	249	#ifdef CONFIG_PPC64
6529c13d OJ	250	_SYSDEV_ATTR(pmc7, 0600, show_pmc7, store_pmc7),
6529c13d OJ	251	_SYSDEV_ATTR(pmc8, 0600, show_pmc8, store_pmc8),
b950bdd0	252	#endif
6529c13d OJ	253	};
6529c13d OJ	254
b950bdd0	255	#ifdef HAS_PPC_PMC_PA6T
6529c13d OJ	256	static struct sysdev_attribute pa6t_attrs[] = {
	257	_SYSDEV_ATTR(mmcr0, 0600, show_mmcr0, store_mmcr0),
	258	_SYSDEV_ATTR(mmcr1, 0600, show_mmcr1, store_mmcr1),
	259	_SYSDEV_ATTR(pmc0, 0600, show_pa6t_pmc0, store_pa6t_pmc0),
	260	_SYSDEV_ATTR(pmc1, 0600, show_pa6t_pmc1, store_pa6t_pmc1),
	261	_SYSDEV_ATTR(pmc2, 0600, show_pa6t_pmc2, store_pa6t_pmc2),
	262	_SYSDEV_ATTR(pmc3, 0600, show_pa6t_pmc3, store_pa6t_pmc3),
	263	_SYSDEV_ATTR(pmc4, 0600, show_pa6t_pmc4, store_pa6t_pmc4),
	264	_SYSDEV_ATTR(pmc5, 0600, show_pa6t_pmc5, store_pa6t_pmc5),
2e1957fd OJ	265	#ifdef CONFIG_DEBUG_KERNEL
	266	_SYSDEV_ATTR(hid0, 0600, show_hid0, store_hid0),
	267	_SYSDEV_ATTR(hid1, 0600, show_hid1, store_hid1),
	268	_SYSDEV_ATTR(hid4, 0600, show_hid4, store_hid4),
	269	_SYSDEV_ATTR(hid5, 0600, show_hid5, store_hid5),
	270	_SYSDEV_ATTR(ima0, 0600, show_ima0, store_ima0),
	271	_SYSDEV_ATTR(ima1, 0600, show_ima1, store_ima1),
	272	_SYSDEV_ATTR(ima2, 0600, show_ima2, store_ima2),
	273	_SYSDEV_ATTR(ima3, 0600, show_ima3, store_ima3),
	274	_SYSDEV_ATTR(ima4, 0600, show_ima4, store_ima4),
	275	_SYSDEV_ATTR(ima5, 0600, show_ima5, store_ima5),
	276	_SYSDEV_ATTR(ima6, 0600, show_ima6, store_ima6),
	277	_SYSDEV_ATTR(ima7, 0600, show_ima7, store_ima7),
	278	_SYSDEV_ATTR(ima8, 0600, show_ima8, store_ima8),
	279	_SYSDEV_ATTR(ima9, 0600, show_ima9, store_ima9),
	280	_SYSDEV_ATTR(imaat, 0600, show_imaat, store_imaat),
	281	_SYSDEV_ATTR(btcr, 0600, show_btcr, store_btcr),
	282	_SYSDEV_ATTR(pccr, 0600, show_pccr, store_pccr),
	283	_SYSDEV_ATTR(rpccr, 0600, show_rpccr, store_rpccr),
	284	_SYSDEV_ATTR(der, 0600, show_der, store_der),
	285	_SYSDEV_ATTR(mer, 0600, show_mer, store_mer),
	286	_SYSDEV_ATTR(ber, 0600, show_ber, store_ber),
	287	_SYSDEV_ATTR(ier, 0600, show_ier, store_ier),
	288	_SYSDEV_ATTR(sier, 0600, show_sier, store_sier),
	289	_SYSDEV_ATTR(siar, 0600, show_siar, store_siar),
	290	_SYSDEV_ATTR(tsr0, 0600, show_tsr0, store_tsr0),
	291	_SYSDEV_ATTR(tsr1, 0600, show_tsr1, store_tsr1),
	292	_SYSDEV_ATTR(tsr2, 0600, show_tsr2, store_tsr2),
	293	_SYSDEV_ATTR(tsr3, 0600, show_tsr3, store_tsr3),
	294	#endif /* CONFIG_DEBUG_KERNEL */
6529c13d	295	};
b950bdd0 BH	296	#endif /* HAS_PPC_PMC_PA6T */
b950bdd0 BH	297	#endif /* HAS_PPC_PMC_CLASSIC */
6529c13d	298
9ba1984e	299	static void __cpuinit register_cpu_online(unsigned int cpu)
1da177e4 LT	300	{
	301	struct cpu *c = &per_cpu(cpu_devices, cpu);
	302	struct sys_device *s = &c->sysdev;
6529c13d OJ	303	struct sysdev_attribute attrs, pmc_attrs;
6529c13d OJ	304	int i, nattrs;
1da177e4	305
b950bdd0	306	#ifdef CONFIG_PPC64
ad5cb17f SR	307	if (!firmware_has_feature(FW_FEATURE_ISERIES) &&
ad5cb17f SR	308	cpu_has_feature(CPU_FTR_SMT))
1da177e4	309	sysdev_create_file(s, &attr_smt_snooze_delay);
b950bdd0	310	#endif
1da177e4 LT	311
1da177e4 LT	312	/* PMC stuff */
6529c13d	313	switch (cur_cpu_spec->pmc_type) {
b950bdd0	314	#ifdef HAS_PPC_PMC_IBM
6529c13d OJ	315	case PPC_PMC_IBM:
	316	attrs = ibm_common_attrs;
	317	nattrs = sizeof(ibm_common_attrs) / sizeof(struct sysdev_attribute);
b950bdd0	318	pmc_attrs = classic_pmc_attrs;
6529c13d	319	break;
b950bdd0 BH	320	#endif /* HAS_PPC_PMC_IBM */
	321	#ifdef HAS_PPC_PMC_G4
	322	case PPC_PMC_G4:
	323	attrs = g4_common_attrs;
	324	nattrs = sizeof(g4_common_attrs) / sizeof(struct sysdev_attribute);
	325	pmc_attrs = classic_pmc_attrs;
	326	break;
	327	#endif /* HAS_PPC_PMC_G4 */
	328	#ifdef HAS_PPC_PMC_PA6T
6529c13d OJ	329	case PPC_PMC_PA6T:
	330	/* PA Semi starts counting at PMC0 */
	331	attrs = pa6t_attrs;
	332	nattrs = sizeof(pa6t_attrs) / sizeof(struct sysdev_attribute);
	333	pmc_attrs = NULL;
	334	break;
b950bdd0	335	#endif /* HAS_PPC_PMC_PA6T */
6529c13d OJ	336	default:
	337	attrs = NULL;
	338	nattrs = 0;
	339	pmc_attrs = NULL;
	340	}
	341
	342	for (i = 0; i < nattrs; i++)
	343	sysdev_create_file(s, &attrs[i]);
1da177e4	344
6529c13d OJ	345	if (pmc_attrs)
	346	for (i = 0; i < cur_cpu_spec->num_pmcs; i++)
	347	sysdev_create_file(s, &pmc_attrs[i]);
1da177e4	348
b950bdd0	349	#ifdef CONFIG_PPC64
1da177e4 LT	350	if (cpu_has_feature(CPU_FTR_MMCRA))
	351	sysdev_create_file(s, &attr_mmcra);
	352
afd05423	353	if (cpu_has_feature(CPU_FTR_PURR))
1da177e4	354	sysdev_create_file(s, &attr_purr);
4c198557	355
f050982a AB	356	if (cpu_has_feature(CPU_FTR_SPURR))
	357	sysdev_create_file(s, &attr_spurr);
	358
4c198557 AB	359	if (cpu_has_feature(CPU_FTR_DSCR))
4c198557 AB	360	sysdev_create_file(s, &attr_dscr);
b950bdd0	361	#endif /* CONFIG_PPC64 */
124c27d3	362
93197a36	363	cacheinfo_cpu_online(cpu);
1da177e4 LT	364	}
	365
	366	#ifdef CONFIG_HOTPLUG_CPU
	367	static void unregister_cpu_online(unsigned int cpu)
	368	{
	369	struct cpu *c = &per_cpu(cpu_devices, cpu);
	370	struct sys_device *s = &c->sysdev;
6529c13d OJ	371	struct sysdev_attribute attrs, pmc_attrs;
6529c13d OJ	372	int i, nattrs;
1da177e4	373
72486f1f	374	BUG_ON(!c->hotpluggable);
1da177e4	375
a1e0eb10	376	#ifdef CONFIG_PPC64
ad5cb17f SR	377	if (!firmware_has_feature(FW_FEATURE_ISERIES) &&
ad5cb17f SR	378	cpu_has_feature(CPU_FTR_SMT))
1da177e4	379	sysdev_remove_file(s, &attr_smt_snooze_delay);
a1e0eb10	380	#endif
1da177e4 LT	381
1da177e4 LT	382	/* PMC stuff */
6529c13d	383	switch (cur_cpu_spec->pmc_type) {
b950bdd0	384	#ifdef HAS_PPC_PMC_IBM
6529c13d OJ	385	case PPC_PMC_IBM:
	386	attrs = ibm_common_attrs;
	387	nattrs = sizeof(ibm_common_attrs) / sizeof(struct sysdev_attribute);
b950bdd0 BH	388	pmc_attrs = classic_pmc_attrs;
	389	break;
	390	#endif /* HAS_PPC_PMC_IBM */
	391	#ifdef HAS_PPC_PMC_G4
	392	case PPC_PMC_G4:
	393	attrs = g4_common_attrs;
	394	nattrs = sizeof(g4_common_attrs) / sizeof(struct sysdev_attribute);
	395	pmc_attrs = classic_pmc_attrs;
6529c13d	396	break;
b950bdd0 BH	397	#endif /* HAS_PPC_PMC_G4 */
b950bdd0 BH	398	#ifdef HAS_PPC_PMC_PA6T
6529c13d OJ	399	case PPC_PMC_PA6T:
	400	/* PA Semi starts counting at PMC0 */
	401	attrs = pa6t_attrs;
	402	nattrs = sizeof(pa6t_attrs) / sizeof(struct sysdev_attribute);
	403	pmc_attrs = NULL;
	404	break;
b950bdd0	405	#endif /* HAS_PPC_PMC_PA6T */
6529c13d OJ	406	default:
	407	attrs = NULL;
	408	nattrs = 0;
	409	pmc_attrs = NULL;
	410	}
1da177e4	411
6529c13d OJ	412	for (i = 0; i < nattrs; i++)
	413	sysdev_remove_file(s, &attrs[i]);
	414
	415	if (pmc_attrs)
	416	for (i = 0; i < cur_cpu_spec->num_pmcs; i++)
	417	sysdev_remove_file(s, &pmc_attrs[i]);
1da177e4	418
b950bdd0	419	#ifdef CONFIG_PPC64
1da177e4 LT	420	if (cpu_has_feature(CPU_FTR_MMCRA))
	421	sysdev_remove_file(s, &attr_mmcra);
	422
afd05423	423	if (cpu_has_feature(CPU_FTR_PURR))
1da177e4	424	sysdev_remove_file(s, &attr_purr);
4c198557	425
f050982a AB	426	if (cpu_has_feature(CPU_FTR_SPURR))
	427	sysdev_remove_file(s, &attr_spurr);
	428
4c198557 AB	429	if (cpu_has_feature(CPU_FTR_DSCR))
4c198557 AB	430	sysdev_remove_file(s, &attr_dscr);
b950bdd0	431	#endif /* CONFIG_PPC64 */
124c27d3	432
93197a36	433	cacheinfo_cpu_offline(cpu);
1da177e4	434	}
12633e80 NF	435
	436	#ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
	437	ssize_t arch_cpu_probe(const char *buf, size_t count)
	438	{
	439	if (ppc_md.cpu_probe)
	440	return ppc_md.cpu_probe(buf, count);
	441
	442	return -EINVAL;
	443	}
	444
	445	ssize_t arch_cpu_release(const char *buf, size_t count)
	446	{
	447	if (ppc_md.cpu_release)
	448	return ppc_md.cpu_release(buf, count);
	449
	450	return -EINVAL;
	451	}
	452	#endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */
	453
1da177e4 LT	454	#endif /* CONFIG_HOTPLUG_CPU */
1da177e4 LT	455
8c78f307	456	static int __cpuinit sysfs_cpu_notify(struct notifier_block *self,
1da177e4 LT	457	unsigned long action, void *hcpu)
	458	{
	459	unsigned int cpu = (unsigned int)(long)hcpu;
	460
	461	switch (action) {
	462	case CPU_ONLINE:
8bb78442	463	case CPU_ONLINE_FROZEN:
1da177e4 LT	464	register_cpu_online(cpu);
	465	break;
	466	#ifdef CONFIG_HOTPLUG_CPU
	467	case CPU_DEAD:
8bb78442	468	case CPU_DEAD_FROZEN:
1da177e4 LT	469	unregister_cpu_online(cpu);
	470	break;
	471	#endif
	472	}
	473	return NOTIFY_OK;
	474	}
	475
8c78f307	476	static struct notifier_block __cpuinitdata sysfs_cpu_nb = {
1da177e4 LT	477	.notifier_call = sysfs_cpu_notify,
	478	};
	479
0344c6c5 CK	480	static DEFINE_MUTEX(cpu_mutex);
	481
	482	int cpu_add_sysdev_attr(struct sysdev_attribute *attr)
	483	{
	484	int cpu;
	485
	486	mutex_lock(&cpu_mutex);
	487
	488	for_each_possible_cpu(cpu) {
	489	sysdev_create_file(get_cpu_sysdev(cpu), attr);
	490	}
	491
	492	mutex_unlock(&cpu_mutex);
	493	return 0;
	494	}
	495	EXPORT_SYMBOL_GPL(cpu_add_sysdev_attr);
	496
	497	int cpu_add_sysdev_attr_group(struct attribute_group *attrs)
	498	{
	499	int cpu;
	500	struct sys_device *sysdev;
6bcc4c01	501	int ret;
0344c6c5 CK	502
	503	mutex_lock(&cpu_mutex);
	504
	505	for_each_possible_cpu(cpu) {
	506	sysdev = get_cpu_sysdev(cpu);
6bcc4c01 OJ	507	ret = sysfs_create_group(&sysdev->kobj, attrs);
6bcc4c01 OJ	508	WARN_ON(ret != 0);
0344c6c5 CK	509	}
	510
	511	mutex_unlock(&cpu_mutex);
	512	return 0;
	513	}
	514	EXPORT_SYMBOL_GPL(cpu_add_sysdev_attr_group);
	515
	516
	517	void cpu_remove_sysdev_attr(struct sysdev_attribute *attr)
	518	{
	519	int cpu;
	520
	521	mutex_lock(&cpu_mutex);
	522
	523	for_each_possible_cpu(cpu) {
	524	sysdev_remove_file(get_cpu_sysdev(cpu), attr);
	525	}
	526
	527	mutex_unlock(&cpu_mutex);
	528	}
	529	EXPORT_SYMBOL_GPL(cpu_remove_sysdev_attr);
	530
	531	void cpu_remove_sysdev_attr_group(struct attribute_group *attrs)
	532	{
	533	int cpu;
	534	struct sys_device *sysdev;
	535
	536	mutex_lock(&cpu_mutex);
	537
	538	for_each_possible_cpu(cpu) {
	539	sysdev = get_cpu_sysdev(cpu);
	540	sysfs_remove_group(&sysdev->kobj, attrs);
	541	}
	542
	543	mutex_unlock(&cpu_mutex);
	544	}
	545	EXPORT_SYMBOL_GPL(cpu_remove_sysdev_attr_group);
	546
	547
1da177e4 LT	548	/* NUMA stuff */
	549
	550	#ifdef CONFIG_NUMA
1da177e4 LT	551	static void register_nodes(void)
	552	{
	553	int i;
	554
0fc44159 YG	555	for (i = 0; i < MAX_NUMNODES; i++)
0fc44159 YG	556	register_one_node(i);
1da177e4	557	}
953039c8 JK	558
	559	int sysfs_add_device_to_node(struct sys_device *dev, int nid)
	560	{
	561	struct node *node = &node_devices[nid];
	562	return sysfs_create_link(&node->sysdev.kobj, &dev->kobj,
	563	kobject_name(&dev->kobj));
	564	}
12654f77	565	EXPORT_SYMBOL_GPL(sysfs_add_device_to_node);
953039c8 JK	566
	567	void sysfs_remove_device_from_node(struct sys_device *dev, int nid)
	568	{
	569	struct node *node = &node_devices[nid];
	570	sysfs_remove_link(&node->sysdev.kobj, kobject_name(&dev->kobj));
	571	}
12654f77	572	EXPORT_SYMBOL_GPL(sysfs_remove_device_from_node);
953039c8	573
1da177e4 LT	574	#else
	575	static void register_nodes(void)
	576	{
	577	return;
	578	}
953039c8	579
1da177e4 LT	580	#endif
	581
	582	/* Only valid if CPU is present. */
00bf6e90 SR	583	static ssize_t show_physical_id(struct sys_device *dev,
00bf6e90 SR	584	struct sysdev_attribute attr, char buf)
1da177e4 LT	585	{
	586	struct cpu *cpu = container_of(dev, struct cpu, sysdev);
	587
	588	return sprintf(buf, "%d\n", get_hard_smp_processor_id(cpu->sysdev.id));
	589	}
	590	static SYSDEV_ATTR(physical_id, 0444, show_physical_id, NULL);
	591
	592	static int __init topology_init(void)
	593	{
	594	int cpu;
1da177e4 LT	595
1da177e4 LT	596	register_nodes();
1da177e4 LT	597	register_cpu_notifier(&sysfs_cpu_nb);
1da177e4 LT	598
0e551954	599	for_each_possible_cpu(cpu) {
1da177e4 LT	600	struct cpu *c = &per_cpu(cpu_devices, cpu);
1da177e4 LT	601
1da177e4 LT	602	/*
	603	* For now, we just see if the system supports making
	604	* the RTAS calls for CPU hotplug. But, there may be a
	605	* more comprehensive way to do this for an individual
	606	* CPU. For instance, the boot cpu might never be valid
	607	* for hotplugging.
	608	*/
72486f1f SS	609	if (ppc_md.cpu_die)
72486f1f SS	610	c->hotpluggable = 1;
1da177e4	611
72486f1f	612	if (cpu_online(cpu) \|\| c->hotpluggable) {
76b67ed9	613	register_cpu(c, cpu);
1da177e4 LT	614
	615	sysdev_create_file(&c->sysdev, &attr_physical_id);
	616	}
	617
	618	if (cpu_online(cpu))
	619	register_cpu_online(cpu);
	620	}
	621
	622	return 0;
	623	}
e9e77ce8	624	subsys_initcall(topology_init);