2010-02-02 22:25:44 +03:00
# undef DEBUG
/*
* ARM performance counter support .
*
* Copyright ( C ) 2009 picoChip Designs , Ltd . , Jamie Iles
2010-11-13 22:04:32 +03:00
* Copyright ( C ) 2010 ARM Ltd . , Will Deacon < will . deacon @ arm . com >
2010-01-26 20:51:05 +03:00
*
2010-02-02 22:25:44 +03:00
* This code is based on the sparc64 perf event code , which is in turn based
2014-09-29 20:15:32 +04:00
* on the x86 code .
2010-02-02 22:25:44 +03:00
*/
# define pr_fmt(fmt) "hw perfevents: " fmt
# include <linux/kernel.h>
2010-04-29 20:13:24 +04:00
# include <linux/platform_device.h>
2012-05-31 22:05:20 +04:00
# include <linux/pm_runtime.h>
2014-02-08 01:01:19 +04:00
# include <linux/irq.h>
# include <linux/irqdesc.h>
2010-02-02 22:25:44 +03:00
# include <asm/irq_regs.h>
# include <asm/pmu.h>
static int
2011-04-28 18:47:10 +04:00
armpmu_map_cache_event ( const unsigned ( * cache_map )
[ PERF_COUNT_HW_CACHE_MAX ]
[ PERF_COUNT_HW_CACHE_OP_MAX ]
[ PERF_COUNT_HW_CACHE_RESULT_MAX ] ,
u64 config )
2010-02-02 22:25:44 +03:00
{
unsigned int cache_type , cache_op , cache_result , ret ;
cache_type = ( config > > 0 ) & 0xff ;
if ( cache_type > = PERF_COUNT_HW_CACHE_MAX )
return - EINVAL ;
cache_op = ( config > > 8 ) & 0xff ;
if ( cache_op > = PERF_COUNT_HW_CACHE_OP_MAX )
return - EINVAL ;
cache_result = ( config > > 16 ) & 0xff ;
if ( cache_result > = PERF_COUNT_HW_CACHE_RESULT_MAX )
return - EINVAL ;
2011-04-28 18:47:10 +04:00
ret = ( int ) ( * cache_map ) [ cache_type ] [ cache_op ] [ cache_result ] ;
2010-02-02 22:25:44 +03:00
if ( ret = = CACHE_OP_UNSUPPORTED )
return - ENOENT ;
return ret ;
}
2010-11-13 20:13:56 +03:00
static int
2012-07-29 15:36:28 +04:00
armpmu_map_hw_event ( const unsigned ( * event_map ) [ PERF_COUNT_HW_MAX ] , u64 config )
2010-11-13 20:13:56 +03:00
{
2013-08-08 21:41:59 +04:00
int mapping ;
if ( config > = PERF_COUNT_HW_MAX )
return - EINVAL ;
mapping = ( * event_map ) [ config ] ;
2011-04-28 18:47:10 +04:00
return mapping = = HW_OP_UNSUPPORTED ? - ENOENT : mapping ;
2010-11-13 20:13:56 +03:00
}
static int
2011-04-28 18:47:10 +04:00
armpmu_map_raw_event ( u32 raw_event_mask , u64 config )
2010-11-13 20:13:56 +03:00
{
2011-04-28 18:47:10 +04:00
return ( int ) ( config & raw_event_mask ) ;
}
2012-07-29 15:36:28 +04:00
int
armpmu_map_event ( struct perf_event * event ,
const unsigned ( * event_map ) [ PERF_COUNT_HW_MAX ] ,
const unsigned ( * cache_map )
[ PERF_COUNT_HW_CACHE_MAX ]
[ PERF_COUNT_HW_CACHE_OP_MAX ]
[ PERF_COUNT_HW_CACHE_RESULT_MAX ] ,
u32 raw_event_mask )
2011-04-28 18:47:10 +04:00
{
u64 config = event - > attr . config ;
2012-09-12 13:53:23 +04:00
int type = event - > attr . type ;
2011-04-28 18:47:10 +04:00
2012-09-12 13:53:23 +04:00
if ( type = = event - > pmu - > type )
return armpmu_map_raw_event ( raw_event_mask , config ) ;
switch ( type ) {
2011-04-28 18:47:10 +04:00
case PERF_TYPE_HARDWARE :
2012-07-29 15:36:28 +04:00
return armpmu_map_hw_event ( event_map , config ) ;
2011-04-28 18:47:10 +04:00
case PERF_TYPE_HW_CACHE :
return armpmu_map_cache_event ( cache_map , config ) ;
case PERF_TYPE_RAW :
return armpmu_map_raw_event ( raw_event_mask , config ) ;
}
return - ENOENT ;
2010-11-13 20:13:56 +03:00
}
2012-07-30 15:00:02 +04:00
int armpmu_event_set_period ( struct perf_event * event )
2010-02-02 22:25:44 +03:00
{
2011-04-28 19:27:54 +04:00
struct arm_pmu * armpmu = to_arm_pmu ( event - > pmu ) ;
2012-07-30 15:00:02 +04:00
struct hw_perf_event * hwc = & event - > hw ;
2010-05-21 16:43:08 +04:00
s64 left = local64_read ( & hwc - > period_left ) ;
2010-02-02 22:25:44 +03:00
s64 period = hwc - > sample_period ;
int ret = 0 ;
if ( unlikely ( left < = - period ) ) {
left = period ;
2010-05-21 16:43:08 +04:00
local64_set ( & hwc - > period_left , left ) ;
2010-02-02 22:25:44 +03:00
hwc - > last_period = period ;
ret = 1 ;
}
if ( unlikely ( left < = 0 ) ) {
left + = period ;
2010-05-21 16:43:08 +04:00
local64_set ( & hwc - > period_left , left ) ;
2010-02-02 22:25:44 +03:00
hwc - > last_period = period ;
ret = 1 ;
}
2015-01-05 17:58:54 +03:00
/*
* Limit the maximum period to prevent the counter value
* from overtaking the one we are about to program . In
* effect we are reducing max_period to account for
* interrupt latency ( and we are being very conservative ) .
*/
if ( left > ( armpmu - > max_period > > 1 ) )
left = armpmu - > max_period > > 1 ;
2010-02-02 22:25:44 +03:00
2010-05-21 16:43:08 +04:00
local64_set ( & hwc - > prev_count , ( u64 ) - left ) ;
2010-02-02 22:25:44 +03:00
2012-07-30 15:00:02 +04:00
armpmu - > write_counter ( event , ( u64 ) ( - left ) & 0xffffffff ) ;
2010-02-02 22:25:44 +03:00
perf_event_update_userpage ( event ) ;
return ret ;
}
2012-07-30 15:00:02 +04:00
u64 armpmu_event_update ( struct perf_event * event )
2010-02-02 22:25:44 +03:00
{
2011-04-28 19:27:54 +04:00
struct arm_pmu * armpmu = to_arm_pmu ( event - > pmu ) ;
2012-07-30 15:00:02 +04:00
struct hw_perf_event * hwc = & event - > hw ;
2011-03-25 19:12:37 +03:00
u64 delta , prev_raw_count , new_raw_count ;
2010-02-02 22:25:44 +03:00
again :
2010-05-21 16:43:08 +04:00
prev_raw_count = local64_read ( & hwc - > prev_count ) ;
2012-07-30 15:00:02 +04:00
new_raw_count = armpmu - > read_counter ( event ) ;
2010-02-02 22:25:44 +03:00
2010-05-21 16:43:08 +04:00
if ( local64_cmpxchg ( & hwc - > prev_count , prev_raw_count ,
2010-02-02 22:25:44 +03:00
new_raw_count ) ! = prev_raw_count )
goto again ;
2012-03-06 20:33:17 +04:00
delta = ( new_raw_count - prev_raw_count ) & armpmu - > max_period ;
2010-02-02 22:25:44 +03:00
2010-05-21 16:43:08 +04:00
local64_add ( delta , & event - > count ) ;
local64_sub ( delta , & hwc - > period_left ) ;
2010-02-02 22:25:44 +03:00
return new_raw_count ;
}
static void
perf: Rework the PMU methods
Replace pmu::{enable,disable,start,stop,unthrottle} with
pmu::{add,del,start,stop}, all of which take a flags argument.
The new interface extends the capability to stop a counter while
keeping it scheduled on the PMU. We replace the throttled state with
the generic stopped state.
This also allows us to efficiently stop/start counters over certain
code paths (like IRQ handlers).
It also allows scheduling a counter without it starting, allowing for
a generic frozen state (useful for rotating stopped counters).
The stopped state is implemented in two different ways, depending on
how the architecture implemented the throttled state:
1) We disable the counter:
a) the pmu has per-counter enable bits, we flip that
b) we program a NOP event, preserving the counter state
2) We store the counter state and ignore all read/overflow events
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: paulus <paulus@samba.org>
Cc: stephane eranian <eranian@googlemail.com>
Cc: Robert Richter <robert.richter@amd.com>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Paul Mundt <lethal@linux-sh.org>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Cyrill Gorcunov <gorcunov@gmail.com>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Yanmin <yanmin_zhang@linux.intel.com>
Cc: Deng-Cheng Zhu <dengcheng.zhu@gmail.com>
Cc: David Miller <davem@davemloft.net>
Cc: Michael Cree <mcree@orcon.net.nz>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2010-06-16 16:37:10 +04:00
armpmu_read ( struct perf_event * event )
2010-02-02 22:25:44 +03:00
{
2012-07-30 15:00:02 +04:00
armpmu_event_update ( event ) ;
2010-02-02 22:25:44 +03:00
}
static void
perf: Rework the PMU methods
Replace pmu::{enable,disable,start,stop,unthrottle} with
pmu::{add,del,start,stop}, all of which take a flags argument.
The new interface extends the capability to stop a counter while
keeping it scheduled on the PMU. We replace the throttled state with
the generic stopped state.
This also allows us to efficiently stop/start counters over certain
code paths (like IRQ handlers).
It also allows scheduling a counter without it starting, allowing for
a generic frozen state (useful for rotating stopped counters).
The stopped state is implemented in two different ways, depending on
how the architecture implemented the throttled state:
1) We disable the counter:
a) the pmu has per-counter enable bits, we flip that
b) we program a NOP event, preserving the counter state
2) We store the counter state and ignore all read/overflow events
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: paulus <paulus@samba.org>
Cc: stephane eranian <eranian@googlemail.com>
Cc: Robert Richter <robert.richter@amd.com>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Paul Mundt <lethal@linux-sh.org>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Cyrill Gorcunov <gorcunov@gmail.com>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Yanmin <yanmin_zhang@linux.intel.com>
Cc: Deng-Cheng Zhu <dengcheng.zhu@gmail.com>
Cc: David Miller <davem@davemloft.net>
Cc: Michael Cree <mcree@orcon.net.nz>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2010-06-16 16:37:10 +04:00
armpmu_stop ( struct perf_event * event , int flags )
2010-02-02 22:25:44 +03:00
{
2011-04-28 19:27:54 +04:00
struct arm_pmu * armpmu = to_arm_pmu ( event - > pmu ) ;
2010-02-02 22:25:44 +03:00
struct hw_perf_event * hwc = & event - > hw ;
perf: Rework the PMU methods
Replace pmu::{enable,disable,start,stop,unthrottle} with
pmu::{add,del,start,stop}, all of which take a flags argument.
The new interface extends the capability to stop a counter while
keeping it scheduled on the PMU. We replace the throttled state with
the generic stopped state.
This also allows us to efficiently stop/start counters over certain
code paths (like IRQ handlers).
It also allows scheduling a counter without it starting, allowing for
a generic frozen state (useful for rotating stopped counters).
The stopped state is implemented in two different ways, depending on
how the architecture implemented the throttled state:
1) We disable the counter:
a) the pmu has per-counter enable bits, we flip that
b) we program a NOP event, preserving the counter state
2) We store the counter state and ignore all read/overflow events
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: paulus <paulus@samba.org>
Cc: stephane eranian <eranian@googlemail.com>
Cc: Robert Richter <robert.richter@amd.com>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Paul Mundt <lethal@linux-sh.org>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Cyrill Gorcunov <gorcunov@gmail.com>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Yanmin <yanmin_zhang@linux.intel.com>
Cc: Deng-Cheng Zhu <dengcheng.zhu@gmail.com>
Cc: David Miller <davem@davemloft.net>
Cc: Michael Cree <mcree@orcon.net.nz>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2010-06-16 16:37:10 +04:00
/*
* ARM pmu always has to update the counter , so ignore
* PERF_EF_UPDATE , see comments in armpmu_start ( ) .
*/
if ( ! ( hwc - > state & PERF_HES_STOPPED ) ) {
2012-07-30 15:00:02 +04:00
armpmu - > disable ( event ) ;
armpmu_event_update ( event ) ;
perf: Rework the PMU methods
Replace pmu::{enable,disable,start,stop,unthrottle} with
pmu::{add,del,start,stop}, all of which take a flags argument.
The new interface extends the capability to stop a counter while
keeping it scheduled on the PMU. We replace the throttled state with
the generic stopped state.
This also allows us to efficiently stop/start counters over certain
code paths (like IRQ handlers).
It also allows scheduling a counter without it starting, allowing for
a generic frozen state (useful for rotating stopped counters).
The stopped state is implemented in two different ways, depending on
how the architecture implemented the throttled state:
1) We disable the counter:
a) the pmu has per-counter enable bits, we flip that
b) we program a NOP event, preserving the counter state
2) We store the counter state and ignore all read/overflow events
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: paulus <paulus@samba.org>
Cc: stephane eranian <eranian@googlemail.com>
Cc: Robert Richter <robert.richter@amd.com>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Paul Mundt <lethal@linux-sh.org>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Cyrill Gorcunov <gorcunov@gmail.com>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Yanmin <yanmin_zhang@linux.intel.com>
Cc: Deng-Cheng Zhu <dengcheng.zhu@gmail.com>
Cc: David Miller <davem@davemloft.net>
Cc: Michael Cree <mcree@orcon.net.nz>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2010-06-16 16:37:10 +04:00
hwc - > state | = PERF_HES_STOPPED | PERF_HES_UPTODATE ;
}
2010-02-02 22:25:44 +03:00
}
2012-07-30 15:00:02 +04:00
static void armpmu_start ( struct perf_event * event , int flags )
2010-02-02 22:25:44 +03:00
{
2011-04-28 19:27:54 +04:00
struct arm_pmu * armpmu = to_arm_pmu ( event - > pmu ) ;
2010-02-02 22:25:44 +03:00
struct hw_perf_event * hwc = & event - > hw ;
perf: Rework the PMU methods
Replace pmu::{enable,disable,start,stop,unthrottle} with
pmu::{add,del,start,stop}, all of which take a flags argument.
The new interface extends the capability to stop a counter while
keeping it scheduled on the PMU. We replace the throttled state with
the generic stopped state.
This also allows us to efficiently stop/start counters over certain
code paths (like IRQ handlers).
It also allows scheduling a counter without it starting, allowing for
a generic frozen state (useful for rotating stopped counters).
The stopped state is implemented in two different ways, depending on
how the architecture implemented the throttled state:
1) We disable the counter:
a) the pmu has per-counter enable bits, we flip that
b) we program a NOP event, preserving the counter state
2) We store the counter state and ignore all read/overflow events
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: paulus <paulus@samba.org>
Cc: stephane eranian <eranian@googlemail.com>
Cc: Robert Richter <robert.richter@amd.com>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Paul Mundt <lethal@linux-sh.org>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Cyrill Gorcunov <gorcunov@gmail.com>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Yanmin <yanmin_zhang@linux.intel.com>
Cc: Deng-Cheng Zhu <dengcheng.zhu@gmail.com>
Cc: David Miller <davem@davemloft.net>
Cc: Michael Cree <mcree@orcon.net.nz>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2010-06-16 16:37:10 +04:00
/*
* ARM pmu always has to reprogram the period , so ignore
* PERF_EF_RELOAD , see the comment below .
*/
if ( flags & PERF_EF_RELOAD )
WARN_ON_ONCE ( ! ( hwc - > state & PERF_HES_UPTODATE ) ) ;
hwc - > state = 0 ;
2010-02-02 22:25:44 +03:00
/*
* Set the period again . Some counters can ' t be stopped , so when we
perf: Rework the PMU methods
Replace pmu::{enable,disable,start,stop,unthrottle} with
pmu::{add,del,start,stop}, all of which take a flags argument.
The new interface extends the capability to stop a counter while
keeping it scheduled on the PMU. We replace the throttled state with
the generic stopped state.
This also allows us to efficiently stop/start counters over certain
code paths (like IRQ handlers).
It also allows scheduling a counter without it starting, allowing for
a generic frozen state (useful for rotating stopped counters).
The stopped state is implemented in two different ways, depending on
how the architecture implemented the throttled state:
1) We disable the counter:
a) the pmu has per-counter enable bits, we flip that
b) we program a NOP event, preserving the counter state
2) We store the counter state and ignore all read/overflow events
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: paulus <paulus@samba.org>
Cc: stephane eranian <eranian@googlemail.com>
Cc: Robert Richter <robert.richter@amd.com>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Paul Mundt <lethal@linux-sh.org>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Cyrill Gorcunov <gorcunov@gmail.com>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Yanmin <yanmin_zhang@linux.intel.com>
Cc: Deng-Cheng Zhu <dengcheng.zhu@gmail.com>
Cc: David Miller <davem@davemloft.net>
Cc: Michael Cree <mcree@orcon.net.nz>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2010-06-16 16:37:10 +04:00
* were stopped we simply disabled the IRQ source and the counter
2010-02-02 22:25:44 +03:00
* may have been left counting . If we don ' t do this step then we may
* get an interrupt too soon or * way * too late if the overflow has
* happened since disabling .
*/
2012-07-30 15:00:02 +04:00
armpmu_event_set_period ( event ) ;
armpmu - > enable ( event ) ;
2010-02-02 22:25:44 +03:00
}
perf: Rework the PMU methods
Replace pmu::{enable,disable,start,stop,unthrottle} with
pmu::{add,del,start,stop}, all of which take a flags argument.
The new interface extends the capability to stop a counter while
keeping it scheduled on the PMU. We replace the throttled state with
the generic stopped state.
This also allows us to efficiently stop/start counters over certain
code paths (like IRQ handlers).
It also allows scheduling a counter without it starting, allowing for
a generic frozen state (useful for rotating stopped counters).
The stopped state is implemented in two different ways, depending on
how the architecture implemented the throttled state:
1) We disable the counter:
a) the pmu has per-counter enable bits, we flip that
b) we program a NOP event, preserving the counter state
2) We store the counter state and ignore all read/overflow events
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: paulus <paulus@samba.org>
Cc: stephane eranian <eranian@googlemail.com>
Cc: Robert Richter <robert.richter@amd.com>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Paul Mundt <lethal@linux-sh.org>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Cyrill Gorcunov <gorcunov@gmail.com>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Yanmin <yanmin_zhang@linux.intel.com>
Cc: Deng-Cheng Zhu <dengcheng.zhu@gmail.com>
Cc: David Miller <davem@davemloft.net>
Cc: Michael Cree <mcree@orcon.net.nz>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2010-06-16 16:37:10 +04:00
static void
armpmu_del ( struct perf_event * event , int flags )
{
2011-04-28 19:27:54 +04:00
struct arm_pmu * armpmu = to_arm_pmu ( event - > pmu ) ;
2014-05-13 22:36:31 +04:00
struct pmu_hw_events * hw_events = this_cpu_ptr ( armpmu - > hw_events ) ;
perf: Rework the PMU methods
Replace pmu::{enable,disable,start,stop,unthrottle} with
pmu::{add,del,start,stop}, all of which take a flags argument.
The new interface extends the capability to stop a counter while
keeping it scheduled on the PMU. We replace the throttled state with
the generic stopped state.
This also allows us to efficiently stop/start counters over certain
code paths (like IRQ handlers).
It also allows scheduling a counter without it starting, allowing for
a generic frozen state (useful for rotating stopped counters).
The stopped state is implemented in two different ways, depending on
how the architecture implemented the throttled state:
1) We disable the counter:
a) the pmu has per-counter enable bits, we flip that
b) we program a NOP event, preserving the counter state
2) We store the counter state and ignore all read/overflow events
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: paulus <paulus@samba.org>
Cc: stephane eranian <eranian@googlemail.com>
Cc: Robert Richter <robert.richter@amd.com>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Paul Mundt <lethal@linux-sh.org>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Cyrill Gorcunov <gorcunov@gmail.com>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Yanmin <yanmin_zhang@linux.intel.com>
Cc: Deng-Cheng Zhu <dengcheng.zhu@gmail.com>
Cc: David Miller <davem@davemloft.net>
Cc: Michael Cree <mcree@orcon.net.nz>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2010-06-16 16:37:10 +04:00
struct hw_perf_event * hwc = & event - > hw ;
int idx = hwc - > idx ;
armpmu_stop ( event , PERF_EF_UPDATE ) ;
2011-05-17 14:20:11 +04:00
hw_events - > events [ idx ] = NULL ;
clear_bit ( idx , hw_events - > used_mask ) ;
2014-02-08 01:01:22 +04:00
if ( armpmu - > clear_event_idx )
armpmu - > clear_event_idx ( hw_events , event ) ;
perf: Rework the PMU methods
Replace pmu::{enable,disable,start,stop,unthrottle} with
pmu::{add,del,start,stop}, all of which take a flags argument.
The new interface extends the capability to stop a counter while
keeping it scheduled on the PMU. We replace the throttled state with
the generic stopped state.
This also allows us to efficiently stop/start counters over certain
code paths (like IRQ handlers).
It also allows scheduling a counter without it starting, allowing for
a generic frozen state (useful for rotating stopped counters).
The stopped state is implemented in two different ways, depending on
how the architecture implemented the throttled state:
1) We disable the counter:
a) the pmu has per-counter enable bits, we flip that
b) we program a NOP event, preserving the counter state
2) We store the counter state and ignore all read/overflow events
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: paulus <paulus@samba.org>
Cc: stephane eranian <eranian@googlemail.com>
Cc: Robert Richter <robert.richter@amd.com>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Paul Mundt <lethal@linux-sh.org>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Cyrill Gorcunov <gorcunov@gmail.com>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Yanmin <yanmin_zhang@linux.intel.com>
Cc: Deng-Cheng Zhu <dengcheng.zhu@gmail.com>
Cc: David Miller <davem@davemloft.net>
Cc: Michael Cree <mcree@orcon.net.nz>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2010-06-16 16:37:10 +04:00
perf_event_update_userpage ( event ) ;
}
2010-02-02 22:25:44 +03:00
static int
perf: Rework the PMU methods
Replace pmu::{enable,disable,start,stop,unthrottle} with
pmu::{add,del,start,stop}, all of which take a flags argument.
The new interface extends the capability to stop a counter while
keeping it scheduled on the PMU. We replace the throttled state with
the generic stopped state.
This also allows us to efficiently stop/start counters over certain
code paths (like IRQ handlers).
It also allows scheduling a counter without it starting, allowing for
a generic frozen state (useful for rotating stopped counters).
The stopped state is implemented in two different ways, depending on
how the architecture implemented the throttled state:
1) We disable the counter:
a) the pmu has per-counter enable bits, we flip that
b) we program a NOP event, preserving the counter state
2) We store the counter state and ignore all read/overflow events
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: paulus <paulus@samba.org>
Cc: stephane eranian <eranian@googlemail.com>
Cc: Robert Richter <robert.richter@amd.com>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Paul Mundt <lethal@linux-sh.org>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Cyrill Gorcunov <gorcunov@gmail.com>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Yanmin <yanmin_zhang@linux.intel.com>
Cc: Deng-Cheng Zhu <dengcheng.zhu@gmail.com>
Cc: David Miller <davem@davemloft.net>
Cc: Michael Cree <mcree@orcon.net.nz>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2010-06-16 16:37:10 +04:00
armpmu_add ( struct perf_event * event , int flags )
2010-02-02 22:25:44 +03:00
{
2011-04-28 19:27:54 +04:00
struct arm_pmu * armpmu = to_arm_pmu ( event - > pmu ) ;
2014-05-13 22:36:31 +04:00
struct pmu_hw_events * hw_events = this_cpu_ptr ( armpmu - > hw_events ) ;
2010-02-02 22:25:44 +03:00
struct hw_perf_event * hwc = & event - > hw ;
int idx ;
int err = 0 ;
2010-06-14 10:49:00 +04:00
perf_pmu_disable ( event - > pmu ) ;
2010-06-11 19:32:03 +04:00
2010-02-02 22:25:44 +03:00
/* If we don't have a space for the counter then finish early. */
2012-07-30 15:00:02 +04:00
idx = armpmu - > get_event_idx ( hw_events , event ) ;
2010-02-02 22:25:44 +03:00
if ( idx < 0 ) {
err = idx ;
goto out ;
}
/*
* If there is an event in the counter we are going to use then make
* sure it is disabled .
*/
event - > hw . idx = idx ;
2012-07-30 15:00:02 +04:00
armpmu - > disable ( event ) ;
2011-05-17 14:20:11 +04:00
hw_events - > events [ idx ] = event ;
2010-02-02 22:25:44 +03:00
perf: Rework the PMU methods
Replace pmu::{enable,disable,start,stop,unthrottle} with
pmu::{add,del,start,stop}, all of which take a flags argument.
The new interface extends the capability to stop a counter while
keeping it scheduled on the PMU. We replace the throttled state with
the generic stopped state.
This also allows us to efficiently stop/start counters over certain
code paths (like IRQ handlers).
It also allows scheduling a counter without it starting, allowing for
a generic frozen state (useful for rotating stopped counters).
The stopped state is implemented in two different ways, depending on
how the architecture implemented the throttled state:
1) We disable the counter:
a) the pmu has per-counter enable bits, we flip that
b) we program a NOP event, preserving the counter state
2) We store the counter state and ignore all read/overflow events
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: paulus <paulus@samba.org>
Cc: stephane eranian <eranian@googlemail.com>
Cc: Robert Richter <robert.richter@amd.com>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Paul Mundt <lethal@linux-sh.org>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Cyrill Gorcunov <gorcunov@gmail.com>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Yanmin <yanmin_zhang@linux.intel.com>
Cc: Deng-Cheng Zhu <dengcheng.zhu@gmail.com>
Cc: David Miller <davem@davemloft.net>
Cc: Michael Cree <mcree@orcon.net.nz>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2010-06-16 16:37:10 +04:00
hwc - > state = PERF_HES_STOPPED | PERF_HES_UPTODATE ;
if ( flags & PERF_EF_START )
armpmu_start ( event , PERF_EF_RELOAD ) ;
2010-02-02 22:25:44 +03:00
/* Propagate our changes to the userspace mapping. */
perf_event_update_userpage ( event ) ;
out :
2010-06-14 10:49:00 +04:00
perf_pmu_enable ( event - > pmu ) ;
2010-02-02 22:25:44 +03:00
return err ;
}
static int
2015-03-17 21:14:58 +03:00
validate_event ( struct pmu * pmu , struct pmu_hw_events * hw_events ,
struct perf_event * event )
2010-02-02 22:25:44 +03:00
{
2015-03-17 21:14:58 +03:00
struct arm_pmu * armpmu ;
2010-02-02 22:25:44 +03:00
2013-08-08 02:39:41 +04:00
if ( is_software_event ( event ) )
return 1 ;
2015-03-17 21:14:58 +03:00
/*
* Reject groups spanning multiple HW PMUs ( e . g . CPU + CCI ) . The
* core perf code won ' t check that the pmu - > ctx = = leader - > ctx
* until after pmu - > event_init ( event ) .
*/
if ( event - > pmu ! = pmu )
return 0 ;
2013-10-09 16:51:29 +04:00
if ( event - > state < PERF_EVENT_STATE_OFF )
2013-04-12 22:04:19 +04:00
return 1 ;
if ( event - > state = = PERF_EVENT_STATE_OFF & & ! event - > attr . enable_on_exec )
2010-09-02 12:32:08 +04:00
return 1 ;
2010-02-02 22:25:44 +03:00
2015-03-17 21:14:58 +03:00
armpmu = to_arm_pmu ( event - > pmu ) ;
2012-07-30 15:00:02 +04:00
return armpmu - > get_event_idx ( hw_events , event ) > = 0 ;
2010-02-02 22:25:44 +03:00
}
static int
validate_group ( struct perf_event * event )
{
struct perf_event * sibling , * leader = event - > group_leader ;
2011-05-17 14:20:11 +04:00
struct pmu_hw_events fake_pmu ;
2010-02-02 22:25:44 +03:00
2011-11-17 19:05:14 +04:00
/*
* Initialise the fake PMU . We only need to populate the
* used_mask for the purposes of validation .
*/
2014-05-13 22:08:19 +04:00
memset ( & fake_pmu . used_mask , 0 , sizeof ( fake_pmu . used_mask ) ) ;
2010-02-02 22:25:44 +03:00
2015-03-17 21:14:58 +03:00
if ( ! validate_event ( event - > pmu , & fake_pmu , leader ) )
2011-11-09 20:56:37 +04:00
return - EINVAL ;
2010-02-02 22:25:44 +03:00
list_for_each_entry ( sibling , & leader - > sibling_list , group_entry ) {
2015-03-17 21:14:58 +03:00
if ( ! validate_event ( event - > pmu , & fake_pmu , sibling ) )
2011-11-09 20:56:37 +04:00
return - EINVAL ;
2010-02-02 22:25:44 +03:00
}
2015-03-17 21:14:58 +03:00
if ( ! validate_event ( event - > pmu , & fake_pmu , event ) )
2011-11-09 20:56:37 +04:00
return - EINVAL ;
2010-02-02 22:25:44 +03:00
return 0 ;
}
2012-07-31 13:34:25 +04:00
static irqreturn_t armpmu_dispatch_irq ( int irq , void * dev )
2011-02-08 06:54:36 +03:00
{
2014-02-08 01:01:19 +04:00
struct arm_pmu * armpmu ;
struct platform_device * plat_device ;
struct arm_pmu_platdata * plat ;
2014-02-11 22:08:41 +04:00
int ret ;
u64 start_clock , finish_clock ;
2014-02-08 01:01:19 +04:00
2014-05-13 22:46:10 +04:00
/*
* we request the IRQ with a ( possibly percpu ) struct arm_pmu * * , but
* the handlers expect a struct arm_pmu * . The percpu_irq framework will
* do any necessary shifting , we just need to perform the first
* dereference .
*/
armpmu = * ( void * * ) dev ;
2014-02-08 01:01:19 +04:00
plat_device = armpmu - > plat_device ;
plat = dev_get_platdata ( & plat_device - > dev ) ;
2011-02-08 06:54:36 +03:00
2014-02-11 22:08:41 +04:00
start_clock = sched_clock ( ) ;
2012-07-31 13:34:25 +04:00
if ( plat & & plat - > handle_irq )
2014-05-13 22:46:10 +04:00
ret = plat - > handle_irq ( irq , armpmu , armpmu - > handle_irq ) ;
2012-07-31 13:34:25 +04:00
else
2014-05-13 22:46:10 +04:00
ret = armpmu - > handle_irq ( irq , armpmu ) ;
2014-02-11 22:08:41 +04:00
finish_clock = sched_clock ( ) ;
perf_sample_event_took ( finish_clock - start_clock ) ;
return ret ;
2011-02-08 06:54:36 +03:00
}
2011-07-27 18:18:59 +04:00
static void
2011-04-28 19:27:54 +04:00
armpmu_release_hardware ( struct arm_pmu * armpmu )
2011-07-27 18:18:59 +04:00
{
2012-07-30 15:00:02 +04:00
armpmu - > free_irq ( armpmu ) ;
2012-07-31 13:34:25 +04:00
pm_runtime_put_sync ( & armpmu - > plat_device - > dev ) ;
2011-07-27 18:18:59 +04:00
}
2010-02-02 22:25:44 +03:00
static int
2011-04-28 19:27:54 +04:00
armpmu_reserve_hardware ( struct arm_pmu * armpmu )
2010-02-02 22:25:44 +03:00
{
2012-07-31 13:34:25 +04:00
int err ;
2011-05-04 12:23:15 +04:00
struct platform_device * pmu_device = armpmu - > plat_device ;
2010-02-02 22:25:44 +03:00
2011-11-22 22:01:46 +04:00
if ( ! pmu_device )
return - ENODEV ;
2012-05-31 22:05:20 +04:00
pm_runtime_get_sync ( & pmu_device - > dev ) ;
2012-07-30 15:00:02 +04:00
err = armpmu - > request_irq ( armpmu , armpmu_dispatch_irq ) ;
2012-07-31 13:34:25 +04:00
if ( err ) {
armpmu_release_hardware ( armpmu ) ;
return err ;
2010-04-29 20:13:24 +04:00
}
2010-02-02 22:25:44 +03:00
2011-07-27 18:18:59 +04:00
return 0 ;
2010-02-02 22:25:44 +03:00
}
static void
hw_perf_event_destroy ( struct perf_event * event )
{
2011-04-28 19:27:54 +04:00
struct arm_pmu * armpmu = to_arm_pmu ( event - > pmu ) ;
2011-04-27 14:20:11 +04:00
atomic_t * active_events = & armpmu - > active_events ;
struct mutex * pmu_reserve_mutex = & armpmu - > reserve_mutex ;
if ( atomic_dec_and_mutex_lock ( active_events , pmu_reserve_mutex ) ) {
2011-04-28 19:27:54 +04:00
armpmu_release_hardware ( armpmu ) ;
2011-04-27 14:20:11 +04:00
mutex_unlock ( pmu_reserve_mutex ) ;
2010-02-02 22:25:44 +03:00
}
}
2011-07-19 14:57:30 +04:00
static int
event_requires_mode_exclusion ( struct perf_event_attr * attr )
{
return attr - > exclude_idle | | attr - > exclude_user | |
attr - > exclude_kernel | | attr - > exclude_hv ;
}
2010-02-02 22:25:44 +03:00
static int
__hw_perf_event_init ( struct perf_event * event )
{
2011-04-28 19:27:54 +04:00
struct arm_pmu * armpmu = to_arm_pmu ( event - > pmu ) ;
2010-02-02 22:25:44 +03:00
struct hw_perf_event * hwc = & event - > hw ;
2013-01-18 20:10:06 +04:00
int mapping ;
2010-02-02 22:25:44 +03:00
2011-04-28 18:47:10 +04:00
mapping = armpmu - > map_event ( event ) ;
2010-02-02 22:25:44 +03:00
if ( mapping < 0 ) {
pr_debug ( " event %x:%llx not supported \n " , event - > attr . type ,
event - > attr . config ) ;
return mapping ;
}
2011-07-19 14:57:30 +04:00
/*
* We don ' t assign an index until we actually place the event onto
* hardware . Use - 1 to signify that we haven ' t decided where to put it
* yet . For SMP systems , each core has it ' s own PMU so we can ' t do any
* clever allocation or constraints checking at this point .
*/
hwc - > idx = - 1 ;
hwc - > config_base = 0 ;
hwc - > config = 0 ;
hwc - > event_base = 0 ;
2010-02-02 22:25:44 +03:00
/*
* Check whether we need to exclude the counter from certain modes .
*/
2011-07-19 14:57:30 +04:00
if ( ( ! armpmu - > set_event_filter | |
armpmu - > set_event_filter ( hwc , & event - > attr ) ) & &
event_requires_mode_exclusion ( & event - > attr ) ) {
2010-02-02 22:25:44 +03:00
pr_debug ( " ARM performance counters do not support "
" mode exclusion \n " ) ;
2012-07-04 21:15:42 +04:00
return - EOPNOTSUPP ;
2010-02-02 22:25:44 +03:00
}
/*
2011-07-19 14:57:30 +04:00
* Store the event encoding into the config_base field .
2010-02-02 22:25:44 +03:00
*/
2011-07-19 14:57:30 +04:00
hwc - > config_base | = ( unsigned long ) mapping ;
2010-02-02 22:25:44 +03:00
2014-05-17 01:15:49 +04:00
if ( ! is_sampling_event ( event ) ) {
2012-03-06 20:33:17 +04:00
/*
* For non - sampling runs , limit the sample_period to half
* of the counter width . That way , the new counter value
* is far less likely to overtake the previous one unless
* you have some serious IRQ latency issues .
*/
hwc - > sample_period = armpmu - > max_period > > 1 ;
2010-02-02 22:25:44 +03:00
hwc - > last_period = hwc - > sample_period ;
2010-05-21 16:43:08 +04:00
local64_set ( & hwc - > period_left , hwc - > sample_period ) ;
2010-02-02 22:25:44 +03:00
}
if ( event - > group_leader ! = event ) {
2013-02-28 20:51:29 +04:00
if ( validate_group ( event ) ! = 0 )
2010-02-02 22:25:44 +03:00
return - EINVAL ;
}
2013-01-18 20:10:06 +04:00
return 0 ;
2010-02-02 22:25:44 +03:00
}
2010-06-11 15:35:08 +04:00
static int armpmu_event_init ( struct perf_event * event )
2010-02-02 22:25:44 +03:00
{
2011-04-28 19:27:54 +04:00
struct arm_pmu * armpmu = to_arm_pmu ( event - > pmu ) ;
2010-02-02 22:25:44 +03:00
int err = 0 ;
2011-04-27 14:20:11 +04:00
atomic_t * active_events = & armpmu - > active_events ;
2010-02-02 22:25:44 +03:00
2012-02-10 02:20:59 +04:00
/* does not support taken branch sampling */
if ( has_branch_stack ( event ) )
return - EOPNOTSUPP ;
2011-04-28 18:47:10 +04:00
if ( armpmu - > map_event ( event ) = = - ENOENT )
2010-06-11 15:35:08 +04:00
return - ENOENT ;
2010-02-02 22:25:44 +03:00
event - > destroy = hw_perf_event_destroy ;
2011-04-27 14:20:11 +04:00
if ( ! atomic_inc_not_zero ( active_events ) ) {
mutex_lock ( & armpmu - > reserve_mutex ) ;
if ( atomic_read ( active_events ) = = 0 )
2011-04-28 19:27:54 +04:00
err = armpmu_reserve_hardware ( armpmu ) ;
2010-02-02 22:25:44 +03:00
if ( ! err )
2011-04-27 14:20:11 +04:00
atomic_inc ( active_events ) ;
mutex_unlock ( & armpmu - > reserve_mutex ) ;
2010-02-02 22:25:44 +03:00
}
if ( err )
2010-06-11 15:35:08 +04:00
return err ;
2010-02-02 22:25:44 +03:00
err = __hw_perf_event_init ( event ) ;
if ( err )
hw_perf_event_destroy ( event ) ;
2010-06-11 15:35:08 +04:00
return err ;
2010-02-02 22:25:44 +03:00
}
perf: Rework the PMU methods
Replace pmu::{enable,disable,start,stop,unthrottle} with
pmu::{add,del,start,stop}, all of which take a flags argument.
The new interface extends the capability to stop a counter while
keeping it scheduled on the PMU. We replace the throttled state with
the generic stopped state.
This also allows us to efficiently stop/start counters over certain
code paths (like IRQ handlers).
It also allows scheduling a counter without it starting, allowing for
a generic frozen state (useful for rotating stopped counters).
The stopped state is implemented in two different ways, depending on
how the architecture implemented the throttled state:
1) We disable the counter:
a) the pmu has per-counter enable bits, we flip that
b) we program a NOP event, preserving the counter state
2) We store the counter state and ignore all read/overflow events
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: paulus <paulus@samba.org>
Cc: stephane eranian <eranian@googlemail.com>
Cc: Robert Richter <robert.richter@amd.com>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Paul Mundt <lethal@linux-sh.org>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Cyrill Gorcunov <gorcunov@gmail.com>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Yanmin <yanmin_zhang@linux.intel.com>
Cc: Deng-Cheng Zhu <dengcheng.zhu@gmail.com>
Cc: David Miller <davem@davemloft.net>
Cc: Michael Cree <mcree@orcon.net.nz>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2010-06-16 16:37:10 +04:00
static void armpmu_enable ( struct pmu * pmu )
2010-02-02 22:25:44 +03:00
{
2011-05-17 14:20:11 +04:00
struct arm_pmu * armpmu = to_arm_pmu ( pmu ) ;
2014-05-13 22:36:31 +04:00
struct pmu_hw_events * hw_events = this_cpu_ptr ( armpmu - > hw_events ) ;
2011-08-23 14:59:49 +04:00
int enabled = bitmap_weight ( hw_events - > used_mask , armpmu - > num_events ) ;
2010-02-02 22:25:44 +03:00
2011-07-01 17:38:12 +04:00
if ( enabled )
2012-07-30 15:00:02 +04:00
armpmu - > start ( armpmu ) ;
2010-02-02 22:25:44 +03:00
}
perf: Rework the PMU methods
Replace pmu::{enable,disable,start,stop,unthrottle} with
pmu::{add,del,start,stop}, all of which take a flags argument.
The new interface extends the capability to stop a counter while
keeping it scheduled on the PMU. We replace the throttled state with
the generic stopped state.
This also allows us to efficiently stop/start counters over certain
code paths (like IRQ handlers).
It also allows scheduling a counter without it starting, allowing for
a generic frozen state (useful for rotating stopped counters).
The stopped state is implemented in two different ways, depending on
how the architecture implemented the throttled state:
1) We disable the counter:
a) the pmu has per-counter enable bits, we flip that
b) we program a NOP event, preserving the counter state
2) We store the counter state and ignore all read/overflow events
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: paulus <paulus@samba.org>
Cc: stephane eranian <eranian@googlemail.com>
Cc: Robert Richter <robert.richter@amd.com>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Paul Mundt <lethal@linux-sh.org>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Cyrill Gorcunov <gorcunov@gmail.com>
Cc: Lin Ming <ming.m.lin@intel.com>
Cc: Yanmin <yanmin_zhang@linux.intel.com>
Cc: Deng-Cheng Zhu <dengcheng.zhu@gmail.com>
Cc: David Miller <davem@davemloft.net>
Cc: Michael Cree <mcree@orcon.net.nz>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2010-06-16 16:37:10 +04:00
static void armpmu_disable ( struct pmu * pmu )
2010-02-02 22:25:44 +03:00
{
2011-04-28 19:27:54 +04:00
struct arm_pmu * armpmu = to_arm_pmu ( pmu ) ;
2012-07-30 15:00:02 +04:00
armpmu - > stop ( armpmu ) ;
2010-02-02 22:25:44 +03:00
}
2014-12-13 02:42:49 +03:00
# ifdef CONFIG_PM
2012-05-31 22:05:20 +04:00
static int armpmu_runtime_resume ( struct device * dev )
{
struct arm_pmu_platdata * plat = dev_get_platdata ( dev ) ;
if ( plat & & plat - > runtime_resume )
return plat - > runtime_resume ( dev ) ;
return 0 ;
}
static int armpmu_runtime_suspend ( struct device * dev )
{
struct arm_pmu_platdata * plat = dev_get_platdata ( dev ) ;
if ( plat & & plat - > runtime_suspend )
return plat - > runtime_suspend ( dev ) ;
return 0 ;
}
# endif
2012-07-29 15:36:28 +04:00
const struct dev_pm_ops armpmu_dev_pm_ops = {
SET_RUNTIME_PM_OPS ( armpmu_runtime_suspend , armpmu_runtime_resume , NULL )
} ;
2013-03-05 06:54:06 +04:00
static void armpmu_init ( struct arm_pmu * armpmu )
2011-04-27 14:20:11 +04:00
{
atomic_set ( & armpmu - > active_events , 0 ) ;
mutex_init ( & armpmu - > reserve_mutex ) ;
2011-04-28 19:27:54 +04:00
armpmu - > pmu = ( struct pmu ) {
. pmu_enable = armpmu_enable ,
. pmu_disable = armpmu_disable ,
. event_init = armpmu_event_init ,
. add = armpmu_add ,
. del = armpmu_del ,
. start = armpmu_start ,
. stop = armpmu_stop ,
. read = armpmu_read ,
} ;
}
2012-09-21 17:23:47 +04:00
int armpmu_register ( struct arm_pmu * armpmu , int type )
2011-04-28 19:27:54 +04:00
{
armpmu_init ( armpmu ) ;
2012-10-26 00:23:18 +04:00
pm_runtime_enable ( & armpmu - > plat_device - > dev ) ;
2012-07-28 20:42:22 +04:00
pr_info ( " enabled with %s PMU driver, %d counters available \n " ,
armpmu - > name , armpmu - > num_events ) ;
2012-09-21 17:23:47 +04:00
return perf_pmu_register ( & armpmu - > pmu , armpmu - > name , type ) ;
2011-04-27 14:20:11 +04:00
}