1/*
  2 *  linux/arch/arm/kernel/pmu.c
  3 *
  4 *  Copyright (C) 2009 picoChip Designs Ltd, Jamie Iles
  5 *  Copyright (C) 2010 ARM Ltd, Will Deacon
  6 *
  7 * This program is free software; you can redistribute it and/or modify
  8 * it under the terms of the GNU General Public License version 2 as
  9 * published by the Free Software Foundation.
 10 *
 11 */
 12
 13#define pr_fmt(fmt) "PMU: " fmt
 14
 15#include <linux/cpumask.h>
 16#include <linux/err.h>
 17#include <linux/interrupt.h>
 18#include <linux/kernel.h>
 19#include <linux/module.h>
 20#include <linux/of_device.h>
 21#include <linux/platform_device.h>
 22
 23#include <asm/pmu.h>
 24
 25static volatile long pmu_lock;
 26
 27static struct platform_device *pmu_devices[ARM_NUM_PMU_DEVICES];
 28
 29static int __devinit pmu_register(struct platform_device *pdev,
 30					enum arm_pmu_type type)
 31{
 32	if (type < 0 || type >= ARM_NUM_PMU_DEVICES) {
 33		pr_warning("received registration request for unknown "
 34				"PMU device type %d\n", type);
 35		return -EINVAL;
 36	}
 37
 38	if (pmu_devices[type]) {
 39		pr_warning("rejecting duplicate registration of PMU device "
 40			"type %d.", type);
 41		return -ENOSPC;
 42	}
 43
 44	pr_info("registered new PMU device of type %d\n", type);
 45	pmu_devices[type] = pdev;
 46	return 0;
 47}
 48
 49#define OF_MATCH_PMU(_name, _type) {	\
 50	.compatible = _name,		\
 51	.data = (void *)_type,		\
 52}
 53
 54#define OF_MATCH_CPU(name)	OF_MATCH_PMU(name, ARM_PMU_DEVICE_CPU)
 55
 56static struct of_device_id armpmu_of_device_ids[] = {
 57	OF_MATCH_CPU("arm,cortex-a9-pmu"),
 58	OF_MATCH_CPU("arm,cortex-a8-pmu"),
 59	OF_MATCH_CPU("arm,arm1136-pmu"),
 60	OF_MATCH_CPU("arm,arm1176-pmu"),
 61	{},
 62};
 63
 64#define PLAT_MATCH_PMU(_name, _type) {	\
 65	.name		= _name,	\
 66	.driver_data	= _type,	\
 67}
 68
 69#define PLAT_MATCH_CPU(_name)	PLAT_MATCH_PMU(_name, ARM_PMU_DEVICE_CPU)
 70
 71static struct platform_device_id armpmu_plat_device_ids[] = {
 72	PLAT_MATCH_CPU("arm-pmu"),
 73	{},
 74};
 75
 76enum arm_pmu_type armpmu_device_type(struct platform_device *pdev)
 77{
 78	const struct of_device_id	*of_id;
 79	const struct platform_device_id *pdev_id;
 80
 81	/* provided by of_device_id table */
 82	if (pdev->dev.of_node) {
 83		of_id = of_match_device(armpmu_of_device_ids, &pdev->dev);
 84		BUG_ON(!of_id);
 85		return (enum arm_pmu_type)of_id->data;
 86	}
 87
 88	/* Provided by platform_device_id table */
 89	pdev_id = platform_get_device_id(pdev);
 90	BUG_ON(!pdev_id);
 91	return pdev_id->driver_data;
 92}
 93
 94static int __devinit armpmu_device_probe(struct platform_device *pdev)
 95{
 96	return pmu_register(pdev, armpmu_device_type(pdev));
 97}
 98
 99static struct platform_driver armpmu_driver = {
100	.driver		= {
101		.name	= "arm-pmu",
102		.of_match_table = armpmu_of_device_ids,
103	},
104	.probe		= armpmu_device_probe,
105	.id_table	= armpmu_plat_device_ids,
106};
107
108static int __init register_pmu_driver(void)
109{
110	return platform_driver_register(&armpmu_driver);
111}
112device_initcall(register_pmu_driver);
113
114struct platform_device *
115reserve_pmu(enum arm_pmu_type type)
116{
117	struct platform_device *pdev;
118
119	if (test_and_set_bit_lock(type, &pmu_lock)) {
120		pdev = ERR_PTR(-EBUSY);
121	} else if (pmu_devices[type] == NULL) {
122		clear_bit_unlock(type, &pmu_lock);
123		pdev = ERR_PTR(-ENODEV);
124	} else {
125		pdev = pmu_devices[type];
126	}
127
128	return pdev;
129}
130EXPORT_SYMBOL_GPL(reserve_pmu);
131
132int
133release_pmu(enum arm_pmu_type type)
134{
135	if (WARN_ON(!pmu_devices[type]))
136		return -EINVAL;
137	clear_bit_unlock(type, &pmu_lock);
138	return 0;
139}
140EXPORT_SYMBOL_GPL(release_pmu);
141
142static int
143set_irq_affinity(int irq,
144		 unsigned int cpu)
145{
146#ifdef CONFIG_SMP
147	int err = irq_set_affinity(irq, cpumask_of(cpu));
148	if (err)
149		pr_warning("unable to set irq affinity (irq=%d, cpu=%u)\n",
150			   irq, cpu);
151	return err;
152#else
153	return -EINVAL;
154#endif
155}
156
157static int
158init_cpu_pmu(void)
159{
160	int i, irqs, err = 0;
161	struct platform_device *pdev = pmu_devices[ARM_PMU_DEVICE_CPU];
162
163	if (!pdev)
164		return -ENODEV;
165
166	irqs = pdev->num_resources;
167
168	/*
169	 * If we have a single PMU interrupt that we can't shift, assume that
170	 * we're running on a uniprocessor machine and continue.
171	 */
172	if (irqs == 1 && !irq_can_set_affinity(platform_get_irq(pdev, 0)))
173		return 0;
174
175	for (i = 0; i < irqs; ++i) {
176		err = set_irq_affinity(platform_get_irq(pdev, i), i);
177		if (err)
178			break;
179	}
180
181	return err;
182}
183
184int
185init_pmu(enum arm_pmu_type type)
186{
187	int err = 0;
188
189	switch (type) {
190	case ARM_PMU_DEVICE_CPU:
191		err = init_cpu_pmu();
192		break;
193	default:
194		pr_warning("attempt to initialise PMU of unknown "
195			   "type %d\n", type);
196		err = -EINVAL;
197	}
198
199	return err;
200}
201EXPORT_SYMBOL_GPL(init_pmu);