2 * Cell Broadband Engine Performance Monitor
4 * (C) Copyright IBM Corporation 2001,2006
7 * David Erb (djerb@us.ibm.com)
8 * Kevin Corry (kevcorry@us.ibm.com)
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2, or (at your option)
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 #include <linux/types.h>
27 #include <asm/machdep.h>
32 #include "interrupt.h"
35 * When writing to write-only mmio addresses, save a shadow copy. All of the
36 * registers are 32-bit, but stored in the upper-half of a 64-bit field in
40 #define WRITE_WO_MMIO(reg, x) \
43 struct cbe_pmd_regs __iomem *pmd_regs; \
44 struct cbe_pmd_shadow_regs *shadow_regs; \
45 pmd_regs = cbe_get_cpu_pmd_regs(cpu); \
46 shadow_regs = cbe_get_cpu_pmd_shadow_regs(cpu); \
47 out_be64(&(pmd_regs->reg), (((u64)_x) << 32)); \
48 shadow_regs->reg = _x; \
51 #define READ_SHADOW_REG(val, reg) \
53 struct cbe_pmd_shadow_regs *shadow_regs; \
54 shadow_regs = cbe_get_cpu_pmd_shadow_regs(cpu); \
55 (val) = shadow_regs->reg; \
58 #define READ_MMIO_UPPER32(val, reg) \
60 struct cbe_pmd_regs __iomem *pmd_regs; \
61 pmd_regs = cbe_get_cpu_pmd_regs(cpu); \
62 (val) = (u32)(in_be64(&pmd_regs->reg) >> 32); \
66 * Physical counter registers.
67 * Each physical counter can act as one 32-bit counter or two 16-bit counters.
70 u32
cbe_read_phys_ctr(u32 cpu
, u32 phys_ctr
)
72 u32 val_in_latch
, val
= 0;
74 if (phys_ctr
< NR_PHYS_CTRS
) {
75 READ_SHADOW_REG(val_in_latch
, counter_value_in_latch
);
77 /* Read the latch or the actual counter, whichever is newer. */
78 if (val_in_latch
& (1 << phys_ctr
)) {
79 READ_SHADOW_REG(val
, pm_ctr
[phys_ctr
]);
81 READ_MMIO_UPPER32(val
, pm_ctr
[phys_ctr
]);
87 EXPORT_SYMBOL_GPL(cbe_read_phys_ctr
);
89 void cbe_write_phys_ctr(u32 cpu
, u32 phys_ctr
, u32 val
)
91 struct cbe_pmd_shadow_regs
*shadow_regs
;
94 if (phys_ctr
< NR_PHYS_CTRS
) {
95 /* Writing to a counter only writes to a hardware latch.
96 * The new value is not propagated to the actual counter
97 * until the performance monitor is enabled.
99 WRITE_WO_MMIO(pm_ctr
[phys_ctr
], val
);
101 pm_ctrl
= cbe_read_pm(cpu
, pm_control
);
102 if (pm_ctrl
& CBE_PM_ENABLE_PERF_MON
) {
103 /* The counters are already active, so we need to
104 * rewrite the pm_control register to "re-enable"
107 cbe_write_pm(cpu
, pm_control
, pm_ctrl
);
109 shadow_regs
= cbe_get_cpu_pmd_shadow_regs(cpu
);
110 shadow_regs
->counter_value_in_latch
|= (1 << phys_ctr
);
114 EXPORT_SYMBOL_GPL(cbe_write_phys_ctr
);
117 * "Logical" counter registers.
118 * These will read/write 16-bits or 32-bits depending on the
119 * current size of the counter. Counters 4 - 7 are always 16-bit.
122 u32
cbe_read_ctr(u32 cpu
, u32 ctr
)
125 u32 phys_ctr
= ctr
& (NR_PHYS_CTRS
- 1);
127 val
= cbe_read_phys_ctr(cpu
, phys_ctr
);
129 if (cbe_get_ctr_size(cpu
, phys_ctr
) == 16)
130 val
= (ctr
< NR_PHYS_CTRS
) ? (val
>> 16) : (val
& 0xffff);
134 EXPORT_SYMBOL_GPL(cbe_read_ctr
);
136 void cbe_write_ctr(u32 cpu
, u32 ctr
, u32 val
)
141 phys_ctr
= ctr
& (NR_PHYS_CTRS
- 1);
143 if (cbe_get_ctr_size(cpu
, phys_ctr
) == 16) {
144 phys_val
= cbe_read_phys_ctr(cpu
, phys_ctr
);
146 if (ctr
< NR_PHYS_CTRS
)
147 val
= (val
<< 16) | (phys_val
& 0xffff);
149 val
= (val
& 0xffff) | (phys_val
& 0xffff0000);
152 cbe_write_phys_ctr(cpu
, phys_ctr
, val
);
154 EXPORT_SYMBOL_GPL(cbe_write_ctr
);
157 * Counter-control registers.
158 * Each "logical" counter has a corresponding control register.
161 u32
cbe_read_pm07_control(u32 cpu
, u32 ctr
)
163 u32 pm07_control
= 0;
166 READ_SHADOW_REG(pm07_control
, pm07_control
[ctr
]);
170 EXPORT_SYMBOL_GPL(cbe_read_pm07_control
);
172 void cbe_write_pm07_control(u32 cpu
, u32 ctr
, u32 val
)
175 WRITE_WO_MMIO(pm07_control
[ctr
], val
);
177 EXPORT_SYMBOL_GPL(cbe_write_pm07_control
);
180 * Other PMU control registers. Most of these are write-only.
183 u32
cbe_read_pm(u32 cpu
, enum pm_reg_name reg
)
189 READ_SHADOW_REG(val
, group_control
);
192 case debug_bus_control
:
193 READ_SHADOW_REG(val
, debug_bus_control
);
197 READ_MMIO_UPPER32(val
, trace_address
);
201 READ_SHADOW_REG(val
, ext_tr_timer
);
205 READ_MMIO_UPPER32(val
, pm_status
);
209 READ_SHADOW_REG(val
, pm_control
);
213 READ_SHADOW_REG(val
, pm_interval
);
217 READ_SHADOW_REG(val
, pm_start_stop
);
223 EXPORT_SYMBOL_GPL(cbe_read_pm
);
225 void cbe_write_pm(u32 cpu
, enum pm_reg_name reg
, u32 val
)
229 WRITE_WO_MMIO(group_control
, val
);
232 case debug_bus_control
:
233 WRITE_WO_MMIO(debug_bus_control
, val
);
237 WRITE_WO_MMIO(trace_address
, val
);
241 WRITE_WO_MMIO(ext_tr_timer
, val
);
245 WRITE_WO_MMIO(pm_status
, val
);
249 WRITE_WO_MMIO(pm_control
, val
);
253 WRITE_WO_MMIO(pm_interval
, val
);
257 WRITE_WO_MMIO(pm_start_stop
, val
);
261 EXPORT_SYMBOL_GPL(cbe_write_pm
);
264 * Get/set the size of a physical counter to either 16 or 32 bits.
267 u32
cbe_get_ctr_size(u32 cpu
, u32 phys_ctr
)
269 u32 pm_ctrl
, size
= 0;
271 if (phys_ctr
< NR_PHYS_CTRS
) {
272 pm_ctrl
= cbe_read_pm(cpu
, pm_control
);
273 size
= (pm_ctrl
& CBE_PM_16BIT_CTR(phys_ctr
)) ? 16 : 32;
278 EXPORT_SYMBOL_GPL(cbe_get_ctr_size
);
280 void cbe_set_ctr_size(u32 cpu
, u32 phys_ctr
, u32 ctr_size
)
284 if (phys_ctr
< NR_PHYS_CTRS
) {
285 pm_ctrl
= cbe_read_pm(cpu
, pm_control
);
288 pm_ctrl
|= CBE_PM_16BIT_CTR(phys_ctr
);
292 pm_ctrl
&= ~CBE_PM_16BIT_CTR(phys_ctr
);
295 cbe_write_pm(cpu
, pm_control
, pm_ctrl
);
298 EXPORT_SYMBOL_GPL(cbe_set_ctr_size
);
301 * Enable/disable the entire performance monitoring unit.
302 * When we enable the PMU, all pending writes to counters get committed.
305 void cbe_enable_pm(u32 cpu
)
307 struct cbe_pmd_shadow_regs
*shadow_regs
;
310 shadow_regs
= cbe_get_cpu_pmd_shadow_regs(cpu
);
311 shadow_regs
->counter_value_in_latch
= 0;
313 pm_ctrl
= cbe_read_pm(cpu
, pm_control
) | CBE_PM_ENABLE_PERF_MON
;
314 cbe_write_pm(cpu
, pm_control
, pm_ctrl
);
316 EXPORT_SYMBOL_GPL(cbe_enable_pm
);
318 void cbe_disable_pm(u32 cpu
)
321 pm_ctrl
= cbe_read_pm(cpu
, pm_control
) & ~CBE_PM_ENABLE_PERF_MON
;
322 cbe_write_pm(cpu
, pm_control
, pm_ctrl
);
324 EXPORT_SYMBOL_GPL(cbe_disable_pm
);
327 * Reading from the trace_buffer.
328 * The trace buffer is two 64-bit registers. Reading from
329 * the second half automatically increments the trace_address.
332 void cbe_read_trace_buffer(u32 cpu
, u64
*buf
)
334 struct cbe_pmd_regs __iomem
*pmd_regs
= cbe_get_cpu_pmd_regs(cpu
);
336 *buf
++ = in_be64(&pmd_regs
->trace_buffer_0_63
);
337 *buf
++ = in_be64(&pmd_regs
->trace_buffer_64_127
);
339 EXPORT_SYMBOL_GPL(cbe_read_trace_buffer
);