mirror of
https://github.com/torvalds/linux
synced 2024-09-28 07:20:56 +00:00
f12482c939
Currently, PMU platform_device reservation relies on some minor abuse
of the platform_device::id field for determining the type of PMU. This
is problematic for device tree based probing, where the ID cannot be
controlled.
This patch removes reliance on the id field, and depends on each PMU's
platform driver to figure out which type it is. As all PMUs handled by
the current platform_driver name "arm-pmu" are CPU PMUs, this
convention is hardcoded. New PMU types can be supported through the use
of {of,platform}_device_id tables
Signed-off-by: Mark Rutland <mark.rutland@arm.com>
Acked-by: Jamie Iles <jamie@jamieiles.com>
Acked-by: Will Deacon <will.deacon@arm.com>
Cc: Rob Herring <rob.herring@calxeda.com>
Cc: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
154 lines
3.1 KiB
C
154 lines
3.1 KiB
C
/*
|
|
* linux/arch/arm/kernel/pmu.c
|
|
*
|
|
* Copyright (C) 2009 picoChip Designs Ltd, Jamie Iles
|
|
* Copyright (C) 2010 ARM Ltd, Will Deacon
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
*/
|
|
|
|
#define pr_fmt(fmt) "PMU: " fmt
|
|
|
|
#include <linux/cpumask.h>
|
|
#include <linux/err.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/platform_device.h>
|
|
|
|
#include <asm/pmu.h>
|
|
|
|
static volatile long pmu_lock;
|
|
|
|
static struct platform_device *pmu_devices[ARM_NUM_PMU_DEVICES];
|
|
|
|
static int __devinit pmu_register(struct platform_device *pdev,
|
|
enum arm_pmu_type type)
|
|
{
|
|
if (type < 0 || type >= ARM_NUM_PMU_DEVICES) {
|
|
pr_warning("received registration request for unknown "
|
|
"device %d\n", type);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (pmu_devices[type])
|
|
pr_warning("registering new PMU device type %d overwrites "
|
|
"previous registration!\n", type);
|
|
else
|
|
pr_info("registered new PMU device of type %d\n",
|
|
type);
|
|
|
|
pmu_devices[type] = pdev;
|
|
return 0;
|
|
}
|
|
|
|
static int __devinit armpmu_device_probe(struct platform_device *pdev)
|
|
{
|
|
return pmu_register(pdev, ARM_PMU_DEVICE_CPU);
|
|
}
|
|
|
|
static struct platform_driver armpmu_driver = {
|
|
.driver = {
|
|
.name = "arm-pmu",
|
|
},
|
|
.probe = armpmu_device_probe,
|
|
};
|
|
|
|
static int __init register_pmu_driver(void)
|
|
{
|
|
return platform_driver_register(&armpmu_driver);
|
|
}
|
|
device_initcall(register_pmu_driver);
|
|
|
|
struct platform_device *
|
|
reserve_pmu(enum arm_pmu_type device)
|
|
{
|
|
struct platform_device *pdev;
|
|
|
|
if (test_and_set_bit_lock(device, &pmu_lock)) {
|
|
pdev = ERR_PTR(-EBUSY);
|
|
} else if (pmu_devices[device] == NULL) {
|
|
clear_bit_unlock(device, &pmu_lock);
|
|
pdev = ERR_PTR(-ENODEV);
|
|
} else {
|
|
pdev = pmu_devices[device];
|
|
}
|
|
|
|
return pdev;
|
|
}
|
|
EXPORT_SYMBOL_GPL(reserve_pmu);
|
|
|
|
int
|
|
release_pmu(enum arm_pmu_type device)
|
|
{
|
|
if (WARN_ON(!pmu_devices[device]))
|
|
return -EINVAL;
|
|
clear_bit_unlock(device, &pmu_lock);
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(release_pmu);
|
|
|
|
static int
|
|
set_irq_affinity(int irq,
|
|
unsigned int cpu)
|
|
{
|
|
#ifdef CONFIG_SMP
|
|
int err = irq_set_affinity(irq, cpumask_of(cpu));
|
|
if (err)
|
|
pr_warning("unable to set irq affinity (irq=%d, cpu=%u)\n",
|
|
irq, cpu);
|
|
return err;
|
|
#else
|
|
return -EINVAL;
|
|
#endif
|
|
}
|
|
|
|
static int
|
|
init_cpu_pmu(void)
|
|
{
|
|
int i, irqs, err = 0;
|
|
struct platform_device *pdev = pmu_devices[ARM_PMU_DEVICE_CPU];
|
|
|
|
if (!pdev)
|
|
return -ENODEV;
|
|
|
|
irqs = pdev->num_resources;
|
|
|
|
/*
|
|
* If we have a single PMU interrupt that we can't shift, assume that
|
|
* we're running on a uniprocessor machine and continue.
|
|
*/
|
|
if (irqs == 1 && !irq_can_set_affinity(platform_get_irq(pdev, 0)))
|
|
return 0;
|
|
|
|
for (i = 0; i < irqs; ++i) {
|
|
err = set_irq_affinity(platform_get_irq(pdev, i), i);
|
|
if (err)
|
|
break;
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
int
|
|
init_pmu(enum arm_pmu_type device)
|
|
{
|
|
int err = 0;
|
|
|
|
switch (device) {
|
|
case ARM_PMU_DEVICE_CPU:
|
|
err = init_cpu_pmu();
|
|
break;
|
|
default:
|
|
pr_warning("attempt to initialise unknown device %d\n",
|
|
device);
|
|
err = -EINVAL;
|
|
}
|
|
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL_GPL(init_pmu);
|