arch/alpha/kernel/perf_event.c

449

perf_pmu_disable(event->pmu);

arch/alpha/kernel/perf_event.c

474

perf_pmu_enable(event->pmu);

arch/alpha/kernel/perf_event.c

492

perf_pmu_disable(event->pmu);

arch/alpha/kernel/perf_event.c

520

perf_pmu_enable(event->pmu);

arch/alpha/kernel/perf_event.c

716

static void alpha_pmu_enable(struct pmu *pmu)

arch/alpha/kernel/perf_event.c

742

static void alpha_pmu_disable(struct pmu *pmu)

arch/alpha/kernel/perf_event.c

755

static struct pmu pmu = {

arch/alpha/kernel/perf_event.c

886

perf_pmu_register(&pmu, "cpu", PERF_TYPE_RAW);

arch/arc/kernel/perf_event.c

193

struct pmu pmu;

arch/arc/kernel/perf_event.c

390

static void arc_pmu_enable(struct pmu *pmu)

arch/arc/kernel/perf_event.c

398

static void arc_pmu_disable(struct pmu *pmu)

arch/arc/kernel/perf_event.c

570

arc_pmu_disable(&arc_pmu->pmu);

arch/arc/kernel/perf_event.c

609

arc_pmu_enable(&arc_pmu->pmu);

arch/arc/kernel/perf_event.c

788

arc_pmu->pmu = (struct pmu) {

arch/arc/kernel/perf_event.c

820

arc_pmu->pmu.capabilities |= PERF_PMU_CAP_NO_INTERRUPT;

arch/arc/kernel/perf_event.c

826

return perf_pmu_register(&arc_pmu->pmu, "arc_pct", PERF_TYPE_RAW);

arch/arm/include/asm/hw_breakpoint.h

121

struct pmu;

arch/arm/mach-imx/mmdc.c

229

perf_pmu_migrate_context(&pmu_mmdc->pmu, cpu, target);

arch/arm/mach-imx/mmdc.c

236

struct pmu *pmu,

arch/arm/mach-imx/mmdc.c

244

if (event->pmu != pmu)

arch/arm/mach-imx/mmdc.c

258

struct pmu *pmu = event->pmu;

arch/arm/mach-imx/mmdc.c

266

if (!mmdc_pmu_group_event_is_valid(event, pmu, &counter_mask))

arch/arm/mach-imx/mmdc.c

271

if (!mmdc_pmu_group_event_is_valid(sibling, pmu, &counter_mask))

arch/arm/mach-imx/mmdc.c

280

struct mmdc_pmu *pmu_mmdc = to_mmdc_pmu(event->pmu);

arch/arm/mach-imx/mmdc.c

283

if (event->attr.type != event->pmu->type)

arch/arm/mach-imx/mmdc.c

309

struct mmdc_pmu *pmu_mmdc = to_mmdc_pmu(event->pmu);

arch/arm/mach-imx/mmdc.c

327

struct mmdc_pmu *pmu_mmdc = to_mmdc_pmu(event->pmu);

arch/arm/mach-imx/mmdc.c

363

struct mmdc_pmu *pmu_mmdc = to_mmdc_pmu(event->pmu);

arch/arm/mach-imx/mmdc.c

384

struct mmdc_pmu *pmu_mmdc = to_mmdc_pmu(event->pmu);

arch/arm/mach-imx/mmdc.c

400

struct mmdc_pmu *pmu_mmdc = to_mmdc_pmu(event->pmu);

arch/arm/mach-imx/mmdc.c

439

.pmu = (struct pmu) {

arch/arm/mach-imx/mmdc.c

467

perf_pmu_unregister(&pmu_mmdc->pmu);

arch/arm/mach-imx/mmdc.c

520

ret = perf_pmu_register(&(pmu_mmdc->pmu), name, -1);

arch/arm/mach-imx/mmdc.c

60

#define to_mmdc_pmu(p) container_of(p, struct mmdc_pmu, pmu)

arch/arm/mach-imx/mmdc.c

98

struct pmu pmu;

arch/arm/mach-meson/platsmp.c

177

ret = regmap_update_bits(pmu, MESON_CPU_AO_RTI_PWR_A9_CNTL1,

arch/arm/mach-meson/platsmp.c

187

ret = regmap_update_bits(pmu, MESON_CPU_AO_RTI_PWR_A9_CNTL0, BIT(cpu),

arch/arm/mach-meson/platsmp.c

227

ret = regmap_update_bits(pmu, MESON_CPU_AO_RTI_PWR_A9_CNTL0,

arch/arm/mach-meson/platsmp.c

244

ret = regmap_update_bits(pmu, MESON_CPU_AO_RTI_PWR_A9_MEM_PD0,

arch/arm/mach-meson/platsmp.c

252

ret = regmap_update_bits(pmu, MESON_CPU_AO_RTI_PWR_A9_CNTL1,

arch/arm/mach-meson/platsmp.c

261

ret = regmap_read_poll_timeout(pmu, MESON_CPU_AO_RTI_PWR_A9_CNTL1, val,

arch/arm/mach-meson/platsmp.c

270

ret = regmap_update_bits(pmu, MESON_CPU_AO_RTI_PWR_A9_CNTL0, BIT(cpu),

arch/arm/mach-meson/platsmp.c

334

ret = regmap_update_bits(pmu, MESON_CPU_AO_RTI_PWR_A9_CNTL0, BIT(cpu),

arch/arm/mach-meson/platsmp.c

344

ret = regmap_update_bits(pmu, MESON_CPU_AO_RTI_PWR_A9_CNTL1,

arch/arm/mach-meson/platsmp.c

36

static struct regmap *pmu;

arch/arm/mach-meson/platsmp.c

376

ret = regmap_update_bits(pmu, MESON_CPU_AO_RTI_PWR_A9_CNTL0,

arch/arm/mach-meson/platsmp.c

384

ret = regmap_update_bits(pmu, MESON_CPU_AO_RTI_PWR_A9_CNTL0, BIT(cpu),

arch/arm/mach-meson/platsmp.c

394

ret = regmap_update_bits(pmu, MESON_CPU_AO_RTI_PWR_A9_CNTL1,

arch/arm/mach-meson/platsmp.c

402

ret = regmap_update_bits(pmu, MESON_CPU_AO_RTI_PWR_A9_MEM_PD0,

arch/arm/mach-meson/platsmp.c

81

pmu = syscon_regmap_lookup_by_compatible(pmu_compatible);

arch/arm/mach-meson/platsmp.c

82

if (IS_ERR(pmu)) {

arch/arm/mach-rockchip/platsmp.c

120

if (!sram_base_addr || (has_pmu && !pmu)) {

arch/arm/mach-rockchip/platsmp.c

221

pmu = syscon_regmap_lookup_by_phandle(node, "rockchip,pmu");

arch/arm/mach-rockchip/platsmp.c

223

if (!IS_ERR(pmu))

arch/arm/mach-rockchip/platsmp.c

226

pmu = syscon_regmap_lookup_by_compatible("rockchip,rk3066-pmu");

arch/arm/mach-rockchip/platsmp.c

227

if (!IS_ERR(pmu))

arch/arm/mach-rockchip/platsmp.c

231

pmu = NULL;

arch/arm/mach-rockchip/platsmp.c

245

pmu = regmap_init_mmio(NULL, pmu_base, &rockchip_pmu_regmap_config);

arch/arm/mach-rockchip/platsmp.c

246

if (IS_ERR(pmu)) {

arch/arm/mach-rockchip/platsmp.c

247

int ret = PTR_ERR(pmu);

arch/arm/mach-rockchip/platsmp.c

250

pmu = NULL;

arch/arm/mach-rockchip/platsmp.c

35

static struct regmap *pmu;

arch/arm/mach-rockchip/platsmp.c

43

ret = regmap_read(pmu, PMU_PWRDN_ST, &val);

arch/arm/mach-rockchip/platsmp.c

85

ret = regmap_update_bits(pmu, PMU_PWRDN_CON, BIT(pd), val);

arch/arm/mm/cache-l2x0-pmu.c

101

static void l2x0_pmu_disable(struct pmu *pmu)

arch/arm/mm/cache-l2x0-pmu.c

21

static struct pmu *l2x0_pmu;

arch/arm/mm/cache-l2x0-pmu.c

274

struct pmu *pmu = event->pmu;

arch/arm/mm/cache-l2x0-pmu.c

279

if (leader->pmu == pmu)

arch/arm/mm/cache-l2x0-pmu.c

285

if (sibling->pmu == pmu)

arch/arm/mm/cache-l2x0-pmu.c

354

struct pmu *pmu = dev_get_drvdata(dev);

arch/arm/mm/cache-l2x0-pmu.c

359

if (!lattr->pl310_only || strcmp("l2c_310", pmu->name) == 0)

arch/arm/mm/cache-l2x0-pmu.c

516

*l2x0_pmu = (struct pmu) {

arch/arm/mm/cache-l2x0-pmu.c

93

static void l2x0_pmu_enable(struct pmu *pmu)

arch/arm64/include/asm/hw_breakpoint.h

110

struct pmu;

arch/arm64/include/asm/kvm_host.h

897

struct kvm_pmu pmu;

arch/arm64/kvm/hyp/nvhe/switch.c

134

struct kvm_pmu_events *pmu = &vcpu->arch.pmu.events;

arch/arm64/kvm/hyp/nvhe/switch.c

136

if (pmu->events_host)

arch/arm64/kvm/hyp/nvhe/switch.c

137

write_sysreg(pmu->events_host, pmcntenclr_el0);

arch/arm64/kvm/hyp/nvhe/switch.c

139

if (pmu->events_guest)

arch/arm64/kvm/hyp/nvhe/switch.c

140

write_sysreg(pmu->events_guest, pmcntenset_el0);

arch/arm64/kvm/hyp/nvhe/switch.c

142

return (pmu->events_host || pmu->events_guest);

arch/arm64/kvm/hyp/nvhe/switch.c

150

struct kvm_pmu_events *pmu = &vcpu->arch.pmu.events;

arch/arm64/kvm/hyp/nvhe/switch.c

152

if (pmu->events_guest)

arch/arm64/kvm/hyp/nvhe/switch.c

153

write_sysreg(pmu->events_guest, pmcntenclr_el0);

arch/arm64/kvm/hyp/nvhe/switch.c

155

if (pmu->events_host)

arch/arm64/kvm/hyp/nvhe/switch.c

156

write_sysreg(pmu->events_host, pmcntenset_el0);

arch/arm64/kvm/pmu-emul.c

1089

if (arm_pmu->pmu.type == pmu_id) {

arch/arm64/kvm/pmu-emul.c

1130

if (vcpu->arch.pmu.created)

arch/arm64/kvm/pmu-emul.c

1155

vcpu->arch.pmu.irq_num = irq;

arch/arm64/kvm/pmu-emul.c

1249

irq = vcpu->arch.pmu.irq_num;

arch/arm64/kvm/pmu-emul.c

255

struct kvm_pmu *pmu = &vcpu->arch.pmu;

arch/arm64/kvm/pmu-emul.c

258

pmu->pmc[i].idx = i;

arch/arm64/kvm/pmu-emul.c

272

irq_work_sync(&vcpu->arch.pmu.overflow_work);

arch/arm64/kvm/pmu-emul.c

35

return container_of(pmc, struct kvm_vcpu, arch.pmu.pmc[pmc->idx]);

arch/arm64/kvm/pmu-emul.c

398

struct kvm_pmu *pmu = &vcpu->arch.pmu;

arch/arm64/kvm/pmu-emul.c

40

return &vcpu->arch.pmu.pmc[cnt_idx];

arch/arm64/kvm/pmu-emul.c

402

if (pmu->irq_level == overflow)

arch/arm64/kvm/pmu-emul.c

405

pmu->irq_level = overflow;

arch/arm64/kvm/pmu-emul.c

409

pmu->irq_num, overflow, pmu);

arch/arm64/kvm/pmu-emul.c

416

struct kvm_pmu *pmu = &vcpu->arch.pmu;

arch/arm64/kvm/pmu-emul.c

423

return pmu->irq_level != run_level;

arch/arm64/kvm/pmu-emul.c

435

if (vcpu->arch.pmu.irq_level)

arch/arm64/kvm/pmu-emul.c

472

vcpu = container_of(work, struct kvm_vcpu, arch.pmu.overflow_work);

arch/arm64/kvm/pmu-emul.c

542

struct arm_pmu *cpu_pmu = to_arm_pmu(perf_event->pmu);

arch/arm64/kvm/pmu-emul.c

547

cpu_pmu->pmu.stop(perf_event, PERF_EF_UPDATE);

arch/arm64/kvm/pmu-emul.c

571

irq_work_queue(&vcpu->arch.pmu.overflow_work);

arch/arm64/kvm/pmu-emul.c

574

cpu_pmu->pmu.start(perf_event, PERF_EF_RELOAD);

arch/arm64/kvm/pmu-emul.c

667

struct arm_pmu *pmu = kvm->arch.arm_pmu;

arch/arm64/kvm/pmu-emul.c

673

if (unlikely(pmu->map_pmuv3_event))

arch/arm64/kvm/pmu-emul.c

674

return pmu->map_pmuv3_event(eventsel);

arch/arm64/kvm/pmu-emul.c

725

attr.type = arm_pmu->pmu.type;

arch/arm64/kvm/pmu-emul.c

787

void kvm_host_pmu_init(struct arm_pmu *pmu)

arch/arm64/kvm/pmu-emul.c

804

entry->arm_pmu = pmu;

arch/arm64/kvm/pmu-emul.c

811

struct arm_pmu *pmu;

arch/arm64/kvm/pmu-emul.c

835

pmu = entry->arm_pmu;

arch/arm64/kvm/pmu-emul.c

837

if (cpumask_test_cpu(cpu, &pmu->supported_cpus))

arch/arm64/kvm/pmu-emul.c

838

return pmu;

arch/arm64/kvm/pmu-emul.c

844

static u64 __compute_pmceid(struct arm_pmu *pmu, bool pmceid1)

arch/arm64/kvm/pmu-emul.c

848

bitmap_to_arr32(lo, pmu->pmceid_bitmap, ARMV8_PMUV3_MAX_COMMON_EVENTS);

arch/arm64/kvm/pmu-emul.c

849

bitmap_to_arr32(hi, pmu->pmceid_ext_bitmap, ARMV8_PMUV3_MAX_COMMON_EVENTS);

arch/arm64/kvm/pmu-emul.c

854

static u64 compute_pmceid0(struct arm_pmu *pmu)

arch/arm64/kvm/pmu-emul.c

856

u64 val = __compute_pmceid(pmu, 0);

arch/arm64/kvm/pmu-emul.c

865

static u64 compute_pmceid1(struct arm_pmu *pmu)

arch/arm64/kvm/pmu-emul.c

867

u64 val = __compute_pmceid(pmu, 1);

arch/arm64/kvm/pmu-emul.c

926

if (!vcpu->arch.pmu.created)

arch/arm64/kvm/pmu-emul.c

935

int irq = vcpu->arch.pmu.irq_num;

arch/arm64/kvm/pmu-emul.c

967

ret = kvm_vgic_set_owner(vcpu, vcpu->arch.pmu.irq_num,

arch/arm64/kvm/pmu-emul.c

968

&vcpu->arch.pmu);

arch/arm64/kvm/pmu-emul.c

973

init_irq_work(&vcpu->arch.pmu.overflow_work,

arch/arm64/kvm/pmu-emul.c

976

vcpu->arch.pmu.created = true;

arch/arm64/kvm/pmu-emul.c

995

if (vcpu->arch.pmu.irq_num != irq)

arch/arm64/kvm/pmu-emul.c

998

if (vcpu->arch.pmu.irq_num == irq)

arch/arm64/kvm/pmu.c

133

struct kvm_pmu_events *pmu;

arch/arm64/kvm/pmu.c

140

pmu = kvm_get_pmu_events();

arch/arm64/kvm/pmu.c

141

events_guest = pmu->events_guest;

arch/arm64/kvm/pmu.c

142

events_host = pmu->events_host;

arch/arm64/kvm/pmu.c

154

struct kvm_pmu_events *pmu;

arch/arm64/kvm/pmu.c

160

pmu = kvm_get_pmu_events();

arch/arm64/kvm/pmu.c

161

events_guest = pmu->events_guest;

arch/arm64/kvm/pmu.c

162

events_host = pmu->events_host;

arch/arm64/kvm/pmu.c

42

struct kvm_pmu_events *pmu = kvm_get_pmu_events();

arch/arm64/kvm/pmu.c

48

pmu->events_host |= set;

arch/arm64/kvm/pmu.c

50

pmu->events_guest |= set;

arch/arm64/kvm/pmu.c

58

struct kvm_pmu_events *pmu = kvm_get_pmu_events();

arch/arm64/kvm/pmu.c

63

pmu->events_host &= ~clr;

arch/arm64/kvm/pmu.c

64

pmu->events_guest &= ~clr;

arch/csky/kernel/perf_event.c

1010

static void csky_pmu_enable(struct pmu *pmu)

arch/csky/kernel/perf_event.c

1016

static void csky_pmu_disable(struct pmu *pmu)

arch/csky/kernel/perf_event.c

1121

csky_pmu_disable(&csky_pmu.pmu);

arch/csky/kernel/perf_event.c

1145

csky_pmu_enable(&csky_pmu.pmu);

arch/csky/kernel/perf_event.c

1206

csky_pmu.pmu = (struct pmu) {

arch/csky/kernel/perf_event.c

1317

csky_pmu.pmu.capabilities |= PERF_PMU_CAP_NO_INTERRUPT;

arch/csky/kernel/perf_event.c

1330

ret = perf_pmu_register(&csky_pmu.pmu, "cpu", PERF_TYPE_RAW);

arch/csky/kernel/perf_event.c

40

struct pmu pmu;

arch/csky/kernel/perf_event.c

49

#define to_csky_pmu(p) (container_of(p, struct csky_pmu, pmu))

arch/loongarch/kernel/perf_event.c

391

perf_pmu_disable(event->pmu);

arch/loongarch/kernel/perf_event.c

416

perf_pmu_enable(event->pmu);

arch/loongarch/kernel/perf_event.c

446

static void loongarch_pmu_enable(struct pmu *pmu)

arch/loongarch/kernel/perf_event.c

451

static void loongarch_pmu_disable(struct pmu *pmu)

arch/loongarch/kernel/perf_event.c

573

static struct pmu pmu = {

arch/loongarch/kernel/perf_event.c

888

perf_pmu_register(&pmu, "cpu", PERF_TYPE_RAW);

arch/mips/kernel/perf_event_mipsxx.c

2051

perf_pmu_register(&pmu, "cpu", PERF_TYPE_RAW);

arch/mips/kernel/perf_event_mipsxx.c

506

perf_pmu_disable(event->pmu);

arch/mips/kernel/perf_event_mipsxx.c

531

perf_pmu_enable(event->pmu);

arch/mips/kernel/perf_event_mipsxx.c

561

static void mipspmu_enable(struct pmu *pmu)

arch/mips/kernel/perf_event_mipsxx.c

580

static void mipspmu_disable(struct pmu *pmu)

arch/mips/kernel/perf_event_mipsxx.c

689

static struct pmu pmu = {

arch/powerpc/include/asm/hw_breakpoint.h

73

struct pmu;

arch/powerpc/include/asm/hw_breakpoint.h

90

extern struct pmu perf_ops_bp;

arch/powerpc/include/asm/imc-pmu.h

116

struct pmu pmu;

arch/powerpc/include/asm/perf_event_server.h

102

int __init register_power_pmu(struct power_pmu *pmu);

arch/powerpc/perf/8xx-pmu.c

179

static struct pmu mpc8xx_pmu = {

arch/powerpc/perf/core-book3s.c

1302

static void power_pmu_disable(struct pmu *pmu)

arch/powerpc/perf/core-book3s.c

1414

static void power_pmu_enable(struct pmu *pmu)

arch/powerpc/perf/core-book3s.c

1597

if (group->pmu->task_ctx_nr == perf_hw_context) {

arch/powerpc/perf/core-book3s.c

1605

if (event->pmu->task_ctx_nr == perf_hw_context &&

arch/powerpc/perf/core-book3s.c

1631

perf_pmu_disable(event->pmu);

arch/powerpc/perf/core-book3s.c

1691

perf_pmu_enable(event->pmu);

arch/powerpc/perf/core-book3s.c

1706

perf_pmu_disable(event->pmu);

arch/powerpc/perf/core-book3s.c

1746

perf_pmu_enable(event->pmu);

arch/powerpc/perf/core-book3s.c

1771

perf_pmu_disable(event->pmu);

arch/powerpc/perf/core-book3s.c

1783

perf_pmu_enable(event->pmu);

arch/powerpc/perf/core-book3s.c

1798

perf_pmu_disable(event->pmu);

arch/powerpc/perf/core-book3s.c

1805

perf_pmu_enable(event->pmu);

arch/powerpc/perf/core-book3s.c

1818

static void power_pmu_start_txn(struct pmu *pmu, unsigned int txn_flags)

arch/powerpc/perf/core-book3s.c

1828

perf_pmu_disable(pmu);

arch/powerpc/perf/core-book3s.c

1837

static void power_pmu_cancel_txn(struct pmu *pmu)

arch/powerpc/perf/core-book3s.c

1849

perf_pmu_enable(pmu);

arch/powerpc/perf/core-book3s.c

1857

static int power_pmu_commit_txn(struct pmu *pmu)

arch/powerpc/perf/core-book3s.c

1884

perf_pmu_enable(pmu);

arch/powerpc/perf/core-book3s.c

2210

static struct pmu power_pmu = {

arch/powerpc/perf/core-book3s.c

2548

int __init register_power_pmu(struct power_pmu *pmu)

arch/powerpc/perf/core-book3s.c

2553

ppmu = pmu;

arch/powerpc/perf/core-book3s.c

2555

pmu->name);

arch/powerpc/perf/core-book3s.c

423

perf_sched_cb_inc(event->pmu);

arch/powerpc/perf/core-book3s.c

435

perf_sched_cb_dec(event->pmu);

arch/powerpc/perf/core-fsl-emb.c

190

static void fsl_emb_pmu_disable(struct pmu *pmu)

arch/powerpc/perf/core-fsl-emb.c

229

static void fsl_emb_pmu_enable(struct pmu *pmu)

arch/powerpc/perf/core-fsl-emb.c

284

perf_pmu_disable(event->pmu);

arch/powerpc/perf/core-fsl-emb.c

332

perf_pmu_enable(event->pmu);

arch/powerpc/perf/core-fsl-emb.c

342

perf_pmu_disable(event->pmu);

arch/powerpc/perf/core-fsl-emb.c

370

perf_pmu_enable(event->pmu);

arch/powerpc/perf/core-fsl-emb.c

390

perf_pmu_disable(event->pmu);

arch/powerpc/perf/core-fsl-emb.c

400

perf_pmu_enable(event->pmu);

arch/powerpc/perf/core-fsl-emb.c

415

perf_pmu_disable(event->pmu);

arch/powerpc/perf/core-fsl-emb.c

422

perf_pmu_enable(event->pmu);

arch/powerpc/perf/core-fsl-emb.c

573

static struct pmu fsl_emb_pmu = {

arch/powerpc/perf/core-fsl-emb.c

682

int register_fsl_emb_pmu(struct fsl_emb_pmu *pmu)

arch/powerpc/perf/core-fsl-emb.c

687

ppmu = pmu;

arch/powerpc/perf/core-fsl-emb.c

689

pmu->name);

arch/powerpc/perf/hv-24x7.c

1381

if (event->attr.type != event->pmu->type)

arch/powerpc/perf/hv-24x7.c

1530

static void h_24x7_event_start_txn(struct pmu *pmu, unsigned int flags)

arch/powerpc/perf/hv-24x7.c

1572

static int h_24x7_event_commit_txn(struct pmu *pmu)

arch/powerpc/perf/hv-24x7.c

1630

static void h_24x7_event_cancel_txn(struct pmu *pmu)

arch/powerpc/perf/hv-24x7.c

1636

static struct pmu h_24x7_pmu = {

arch/powerpc/perf/hv-gpci.c

779

if (event->attr.type != event->pmu->type)

arch/powerpc/perf/hv-gpci.c

831

static struct pmu h_gpci_pmu = {

arch/powerpc/perf/imc-pmu.c

1000

if (((config & IMC_EVENT_OFFSET_MASK) > pmu->counter_mem_size))

arch/powerpc/perf/imc-pmu.c

1021

event->pmu->task_ctx_nr = perf_sw_context;

arch/powerpc/perf/imc-pmu.c

1028

if (!strncmp(event->pmu->name, "thread_imc", strlen("thread_imc")))

arch/powerpc/perf/imc-pmu.c

1046

static void thread_imc_pmu_start_txn(struct pmu *pmu,

arch/powerpc/perf/imc-pmu.c

105

struct pmu *pmu = dev_get_drvdata(dev);

arch/powerpc/perf/imc-pmu.c

1051

perf_pmu_disable(pmu);

arch/powerpc/perf/imc-pmu.c

1054

static void thread_imc_pmu_cancel_txn(struct pmu *pmu)

arch/powerpc/perf/imc-pmu.c

1056

perf_pmu_enable(pmu);

arch/powerpc/perf/imc-pmu.c

1059

static int thread_imc_pmu_commit_txn(struct pmu *pmu)

arch/powerpc/perf/imc-pmu.c

106

struct imc_pmu *imc_pmu = container_of(pmu, struct imc_pmu, pmu);

arch/powerpc/perf/imc-pmu.c

1061

perf_pmu_enable(pmu);

arch/powerpc/perf/imc-pmu.c

1439

if (event->attr.type != event->pmu->type)

arch/powerpc/perf/imc-pmu.c

1474

event->pmu->task_ctx_nr = perf_sw_context;

arch/powerpc/perf/imc-pmu.c

1480

static int update_pmu_ops(struct imc_pmu *pmu)

arch/powerpc/perf/imc-pmu.c

1482

pmu->pmu.task_ctx_nr = perf_invalid_context;

arch/powerpc/perf/imc-pmu.c

1483

pmu->pmu.add = imc_event_add;

arch/powerpc/perf/imc-pmu.c

1484

pmu->pmu.del = imc_event_stop;

arch/powerpc/perf/imc-pmu.c

1485

pmu->pmu.start = imc_event_start;

arch/powerpc/perf/imc-pmu.c

1486

pmu->pmu.stop = imc_event_stop;

arch/powerpc/perf/imc-pmu.c

1487

pmu->pmu.read = imc_event_update;

arch/powerpc/perf/imc-pmu.c

1488

pmu->pmu.attr_groups = pmu->attr_groups;

arch/powerpc/perf/imc-pmu.c

1489

pmu->pmu.capabilities = PERF_PMU_CAP_NO_EXCLUDE;

arch/powerpc/perf/imc-pmu.c

1490

pmu->attr_groups[IMC_FORMAT_ATTR] = &imc_format_group;

arch/powerpc/perf/imc-pmu.c

1492

switch (pmu->domain) {

arch/powerpc/perf/imc-pmu.c

1494

pmu->pmu.event_init = nest_imc_event_init;

arch/powerpc/perf/imc-pmu.c

1495

pmu->attr_groups[IMC_CPUMASK_ATTR] = &imc_pmu_cpumask_attr_group;

arch/powerpc/perf/imc-pmu.c

1498

pmu->pmu.event_init = core_imc_event_init;

arch/powerpc/perf/imc-pmu.c

1499

pmu->attr_groups[IMC_CPUMASK_ATTR] = &imc_pmu_cpumask_attr_group;

arch/powerpc/perf/imc-pmu.c

1502

pmu->pmu.event_init = thread_imc_event_init;

arch/powerpc/perf/imc-pmu.c

1503

pmu->pmu.add = thread_imc_event_add;

arch/powerpc/perf/imc-pmu.c

1504

pmu->pmu.del = thread_imc_event_del;

arch/powerpc/perf/imc-pmu.c

1505

pmu->pmu.start_txn = thread_imc_pmu_start_txn;

arch/powerpc/perf/imc-pmu.c

1506

pmu->pmu.cancel_txn = thread_imc_pmu_cancel_txn;

arch/powerpc/perf/imc-pmu.c

1507

pmu->pmu.commit_txn = thread_imc_pmu_commit_txn;

arch/powerpc/perf/imc-pmu.c

1510

pmu->pmu.event_init = trace_imc_event_init;

arch/powerpc/perf/imc-pmu.c

1511

pmu->pmu.add = trace_imc_event_add;

arch/powerpc/perf/imc-pmu.c

1512

pmu->pmu.del = trace_imc_event_del;

arch/powerpc/perf/imc-pmu.c

1513

pmu->pmu.start = trace_imc_event_start;

arch/powerpc/perf/imc-pmu.c

1514

pmu->pmu.stop = trace_imc_event_stop;

arch/powerpc/perf/imc-pmu.c

1515

pmu->pmu.read = trace_imc_event_read;

arch/powerpc/perf/imc-pmu.c

1516

pmu->attr_groups[IMC_FORMAT_ATTR] = &trace_imc_format_group;

arch/powerpc/perf/imc-pmu.c

1677

perf_pmu_unregister(&thread_imc_pmu->pmu);

arch/powerpc/perf/imc-pmu.c

1695

pmu_ptr->pmu.name = kasprintf(GFP_KERNEL, "%s%s_imc", "nest_", s);

arch/powerpc/perf/imc-pmu.c

1696

if (!pmu_ptr->pmu.name)

arch/powerpc/perf/imc-pmu.c

1710

pmu_ptr->pmu.name = kasprintf(GFP_KERNEL, "%s%s", s, "_imc");

arch/powerpc/perf/imc-pmu.c

1711

if (!pmu_ptr->pmu.name)

arch/powerpc/perf/imc-pmu.c

1731

pmu_ptr->pmu.name = kasprintf(GFP_KERNEL, "%s%s", s, "_imc");

arch/powerpc/perf/imc-pmu.c

1732

if (!pmu_ptr->pmu.name)

arch/powerpc/perf/imc-pmu.c

1748

pmu_ptr->pmu.name = kasprintf(GFP_KERNEL, "%s%s", s, "_imc");

arch/powerpc/perf/imc-pmu.c

1749

if (!pmu_ptr->pmu.name)

arch/powerpc/perf/imc-pmu.c

1859

ret = perf_pmu_register(&pmu_ptr->pmu, pmu_ptr->pmu.name, -1);

arch/powerpc/perf/imc-pmu.c

1864

pmu_ptr->pmu.name);

arch/powerpc/perf/imc-pmu.c

221

static int update_events_in_group(struct device_node *node, struct imc_pmu *pmu)

arch/powerpc/perf/imc-pmu.c

260

pmu->events = kzalloc_objs(struct imc_events, ct);

arch/powerpc/perf/imc-pmu.c

261

if (!pmu->events) {

arch/powerpc/perf/imc-pmu.c

269

ret = imc_parse_event(np, g_scale, g_unit, prefix, base_reg, &pmu->events[ct]);

arch/powerpc/perf/imc-pmu.c

279

imc_free_events(pmu->events, ct);

arch/powerpc/perf/imc-pmu.c

294

imc_free_events(pmu->events, ct);

arch/powerpc/perf/imc-pmu.c

301

ev_val_str = kasprintf(GFP_KERNEL, "event=0x%x", pmu->events[i].value);

arch/powerpc/perf/imc-pmu.c

304

dev_str = device_str_attr_create(pmu->events[i].name, ev_val_str);

arch/powerpc/perf/imc-pmu.c

309

if (pmu->events[i].scale) {

arch/powerpc/perf/imc-pmu.c

310

ev_scale_str = kasprintf(GFP_KERNEL, "%s.scale", pmu->events[i].name);

arch/powerpc/perf/imc-pmu.c

313

dev_str = device_str_attr_create(ev_scale_str, pmu->events[i].scale);

arch/powerpc/perf/imc-pmu.c

320

if (pmu->events[i].unit) {

arch/powerpc/perf/imc-pmu.c

321

ev_unit_str = kasprintf(GFP_KERNEL, "%s.unit", pmu->events[i].name);

arch/powerpc/perf/imc-pmu.c

324

dev_str = device_str_attr_create(ev_unit_str, pmu->events[i].unit);

arch/powerpc/perf/imc-pmu.c

333

pmu->attr_groups[IMC_EVENT_ATTR] = attr_group;

arch/powerpc/perf/imc-pmu.c

352

perf_pmu_migrate_context(&(*pn)->pmu, old_cpu, new_cpu);

arch/powerpc/perf/imc-pmu.c

516

struct imc_pmu *pmu;

arch/powerpc/perf/imc-pmu.c

520

if (event->attr.type != event->pmu->type)

arch/powerpc/perf/imc-pmu.c

530

pmu = imc_event_to_pmu(event);

arch/powerpc/perf/imc-pmu.c

533

if ((config & IMC_EVENT_OFFSET_MASK) > pmu->counter_mem_size)

arch/powerpc/perf/imc-pmu.c

546

pcni = pmu->mem_info;

arch/powerpc/perf/imc-pmu.c

61

return container_of(event->pmu, struct imc_pmu, pmu);

arch/powerpc/perf/imc-pmu.c

697

if (!core_imc_pmu->pmu.event_init)

arch/powerpc/perf/imc-pmu.c

708

perf_pmu_migrate_context(&core_imc_pmu->pmu, cpu, ncpu);

arch/powerpc/perf/imc-pmu.c

819

struct imc_pmu *pmu;

arch/powerpc/perf/imc-pmu.c

822

if (event->attr.type != event->pmu->type)

arch/powerpc/perf/imc-pmu.c

833

pmu = imc_event_to_pmu(event);

arch/powerpc/perf/imc-pmu.c

836

if (((config & IMC_EVENT_OFFSET_MASK) > pmu->counter_mem_size))

arch/powerpc/perf/imc-pmu.c

984

struct imc_pmu *pmu;

arch/powerpc/perf/imc-pmu.c

986

if (event->attr.type != event->pmu->type)

arch/powerpc/perf/imc-pmu.c

997

pmu = imc_event_to_pmu(event);

arch/powerpc/perf/kvm-hv-pmu.c

183

if (event->attr.type != event->pmu->type)

arch/powerpc/perf/kvm-hv-pmu.c

383

static struct pmu kvmppc_pmu = {

arch/powerpc/perf/vpa-dtl.c

355

if (event->attr.type != event->pmu->type)

arch/powerpc/perf/vpa-dtl.c

559

static struct pmu vpa_dtl_pmu = {

arch/powerpc/perf/vpa-pmu.c

158

static struct pmu vpa_pmu = {

arch/powerpc/perf/vpa-pmu.c

75

if (event->attr.type != event->pmu->type)

arch/powerpc/platforms/powernv/opal-imc.c

167

pr_err("IMC PMU %s Register failed\n", pmu_ptr->pmu.name);

arch/powerpc/platforms/powernv/opal-imc.c

168

kfree(pmu_ptr->pmu.name);

arch/powerpc/platforms/powernv/opal-imc.c

236

struct imc_pmu *pmu;

arch/powerpc/platforms/powernv/opal-imc.c

252

pmu = NULL;

arch/powerpc/platforms/powernv/opal-imc.c

277

pmu = imc_pmu_create(imc_dev, pmu_count, domain);

arch/powerpc/platforms/powernv/opal-imc.c

278

if (pmu != NULL) {

arch/powerpc/platforms/powernv/opal-imc.c

281

export_imc_mode_and_cmd(imc_dev, pmu);

arch/powerpc/platforms/pseries/papr_scm.c

310

#define to_nvdimm_pmu(_pmu) container_of(_pmu, struct nvdimm_pmu, pmu)

arch/powerpc/platforms/pseries/papr_scm.c

372

struct nvdimm_pmu *nd_pmu = to_nvdimm_pmu(event->pmu);

arch/powerpc/platforms/pseries/papr_scm.c

379

if (event->attr.type != event->pmu->type)

arch/powerpc/platforms/pseries/papr_scm.c

405

struct nvdimm_pmu *nd_pmu = to_nvdimm_pmu(event->pmu);

arch/powerpc/platforms/pseries/papr_scm.c

425

struct nvdimm_pmu *nd_pmu = to_nvdimm_pmu(event->pmu);

arch/powerpc/platforms/pseries/papr_scm.c

459

nd_pmu->pmu.task_ctx_nr = perf_invalid_context;

arch/powerpc/platforms/pseries/papr_scm.c

460

nd_pmu->pmu.name = nvdimm_name(p->nvdimm);

arch/powerpc/platforms/pseries/papr_scm.c

461

nd_pmu->pmu.event_init = papr_scm_pmu_event_init;

arch/powerpc/platforms/pseries/papr_scm.c

462

nd_pmu->pmu.read = papr_scm_pmu_read;

arch/powerpc/platforms/pseries/papr_scm.c

463

nd_pmu->pmu.add = papr_scm_pmu_add;

arch/powerpc/platforms/pseries/papr_scm.c

464

nd_pmu->pmu.del = papr_scm_pmu_del;

arch/powerpc/platforms/pseries/papr_scm.c

466

nd_pmu->pmu.capabilities = PERF_PMU_CAP_NO_INTERRUPT |

arch/riscv/include/asm/kvm_vcpu_pmu.h

64

#define pmu_to_vcpu(pmu) (container_of((pmu), struct kvm_vcpu, arch.pmu_context))

arch/riscv/kvm/vcpu_pmu.c

193

static int pmu_get_pmc_index(struct kvm_pmu *pmu, unsigned long eidx,

arch/riscv/kvm/vcpu_pmu.c

203

return kvm_pmu_get_programmable_pmc_index(pmu, eidx, cbase, cmask);

arch/riscv/kvm/vcpu_pmu.c

21

#define kvm_pmu_num_counters(pmu) ((pmu)->num_hw_ctrs + (pmu)->num_fw_ctrs)

arch/riscv/kvm/vcpu_pmu.c

283

struct riscv_pmu *rpmu = to_riscv_pmu(perf_event->pmu);

arch/riscv/kvm/vcpu_pmu.c

293

rpmu->pmu.stop(perf_event, PERF_EF_UPDATE);

arch/riscv/kvm/vcpu_pmu.c

314

rpmu->pmu.start(perf_event, PERF_EF_RELOAD);

arch/s390/kernel/perf_cpum_cf.c

1056

static struct pmu cpumf_pmu = {

arch/s390/kernel/perf_cpum_cf.c

1792

event->attr.type != event->pmu->type)

arch/s390/kernel/perf_cpum_cf.c

1860

static struct pmu cf_diag = {

arch/s390/kernel/perf_cpum_cf.c

673

static void cpumf_pmu_enable(struct pmu *pmu)

arch/s390/kernel/perf_cpum_cf.c

693

static void cpumf_pmu_disable(struct pmu *pmu)

arch/s390/kernel/perf_cpum_cf.c

863

else if (event->pmu->type == type)

arch/s390/kernel/perf_cpum_sf.c

1734

perf_pmu_disable(event->pmu);

arch/s390/kernel/perf_cpum_sf.c

1739

perf_pmu_enable(event->pmu);

arch/s390/kernel/perf_cpum_sf.c

1752

perf_pmu_disable(event->pmu);

arch/s390/kernel/perf_cpum_sf.c

1763

perf_pmu_enable(event->pmu);

arch/s390/kernel/perf_cpum_sf.c

1778

perf_pmu_disable(event->pmu);

arch/s390/kernel/perf_cpum_sf.c

1823

perf_pmu_enable(event->pmu);

arch/s390/kernel/perf_cpum_sf.c

1831

perf_pmu_disable(event->pmu);

arch/s390/kernel/perf_cpum_sf.c

1842

perf_pmu_enable(event->pmu);

arch/s390/kernel/perf_cpum_sf.c

1897

static struct pmu cpumf_sampling = {

arch/s390/kernel/perf_cpum_sf.c

889

static void cpumsf_pmu_enable(struct pmu *pmu)

arch/s390/kernel/perf_cpum_sf.c

939

static void cpumsf_pmu_disable(struct pmu *pmu)

arch/s390/kernel/perf_pai.c

1128

rc = perf_pmu_register(p->pmu, p->pmuname, -1);

arch/s390/kernel/perf_pai.c

1150

.pmu = &paicrypt,

arch/s390/kernel/perf_pai.c

1163

.pmu = &paiext,

arch/s390/kernel/perf_pai.c

354

if (a->type != PERF_TYPE_RAW && event->pmu->type != a->type)

arch/s390/kernel/perf_pai.c

455

perf_sched_cb_inc(event->pmu);

arch/s390/kernel/perf_pai.c

489

pai_pmu[idx].pmu->start(event, PERF_EF_RELOAD);

arch/s390/kernel/perf_pai.c

507

pai_pmu[idx].pmu->read(event);

arch/s390/kernel/perf_pai.c

510

perf_sched_cb_dec(event->pmu);

arch/s390/kernel/perf_pai.c

532

pai_pmu[idx].pmu->stop(event, PERF_EF_UPDATE);

arch/s390/kernel/perf_pai.c

787

static struct pmu paicrypt = {

arch/s390/kernel/perf_pai.c

87

struct pmu *pmu; /* Ptr to supporting PMU */

arch/s390/kernel/perf_pai.c

998

static struct pmu paiext = {

arch/sh/include/asm/hw_breakpoint.h

46

struct pmu;

arch/sh/include/asm/hw_breakpoint.h

70

extern struct pmu perf_ops_bp;

arch/sh/kernel/perf_event.c

251

perf_pmu_disable(event->pmu);

arch/sh/kernel/perf_event.c

271

perf_pmu_enable(event->pmu);

arch/sh/kernel/perf_event.c

307

static void sh_pmu_enable(struct pmu *pmu)

arch/sh/kernel/perf_event.c

315

static void sh_pmu_disable(struct pmu *pmu)

arch/sh/kernel/perf_event.c

323

static struct pmu pmu = {

arch/sh/kernel/perf_event.c

355

pmu.capabilities |= PERF_PMU_CAP_NO_INTERRUPT;

arch/sh/kernel/perf_event.c

359

perf_pmu_register(&pmu, "cpu", PERF_TYPE_RAW);

arch/sparc/include/asm/ptrace.h

58

struct global_pmu_snapshot pmu;

arch/sparc/kernel/perf_event.c

1029

static void sparc_pmu_enable(struct pmu *pmu)

arch/sparc/kernel/perf_event.c

1047

static void sparc_pmu_disable(struct pmu *pmu)

arch/sparc/kernel/perf_event.c

1512

static void sparc_pmu_start_txn(struct pmu *pmu, unsigned int txn_flags)

arch/sparc/kernel/perf_event.c

1522

perf_pmu_disable(pmu);

arch/sparc/kernel/perf_event.c

1530

static void sparc_pmu_cancel_txn(struct pmu *pmu)

arch/sparc/kernel/perf_event.c

1542

perf_pmu_enable(pmu);

arch/sparc/kernel/perf_event.c

1550

static int sparc_pmu_commit_txn(struct pmu *pmu)

arch/sparc/kernel/perf_event.c

1572

perf_pmu_enable(pmu);

arch/sparc/kernel/perf_event.c

1576

static struct pmu pmu = {

arch/sparc/kernel/perf_event.c

1729

perf_pmu_register(&pmu, "cpu", PERF_TYPE_RAW);

arch/sparc/kernel/process_64.c

317

pp = &global_cpu_snapshot[this_cpu].pmu;

arch/sparc/kernel/process_64.c

356

struct global_pmu_snapshot *pp = &global_cpu_snapshot[cpu].pmu;

arch/x86/events/amd/ibs.c

1425

ret = perf_pmu_register(&perf_ibs->pmu, name, -1);

arch/x86/events/amd/ibs.c

1449

perf_ibs_fetch.pmu.attr_groups = fetch_attr_groups;

arch/x86/events/amd/ibs.c

1450

perf_ibs_fetch.pmu.attr_update = fetch_attr_update;

arch/x86/events/amd/ibs.c

1470

perf_ibs_op.pmu.attr_groups = op_attr_groups;

arch/x86/events/amd/ibs.c

1471

perf_ibs_op.pmu.attr_update = op_attr_update;

arch/x86/events/amd/ibs.c

1496

perf_pmu_unregister(&perf_ibs_op.pmu);

arch/x86/events/amd/ibs.c

1500

perf_pmu_unregister(&perf_ibs_fetch.pmu);

arch/x86/events/amd/ibs.c

186

if (perf_ibs_fetch.pmu.type == type)

arch/x86/events/amd/ibs.c

188

if (perf_ibs_op.pmu.type == type)

arch/x86/events/amd/ibs.c

245

event->attr.type = perf_ibs_op.pmu.type;

arch/x86/events/amd/ibs.c

262

if (event->group_leader->pmu == event->pmu)

arch/x86/events/amd/ibs.c

266

if (sibling->pmu == event->pmu)

arch/x86/events/amd/ibs.c

293

if (event->pmu != &perf_ibs->pmu)

arch/x86/events/amd/ibs.c

470

struct perf_ibs *perf_ibs = container_of(event->pmu, struct perf_ibs, pmu);

arch/x86/events/amd/ibs.c

504

struct perf_ibs *perf_ibs = container_of(event->pmu, struct perf_ibs, pmu);

arch/x86/events/amd/ibs.c

557

struct perf_ibs *perf_ibs = container_of(event->pmu, struct perf_ibs, pmu);

arch/x86/events/amd/ibs.c

575

struct perf_ibs *perf_ibs = container_of(event->pmu, struct perf_ibs, pmu);

arch/x86/events/amd/ibs.c

598

perf_ibs = container_of(event->pmu, struct perf_ibs, pmu);

arch/x86/events/amd/ibs.c

786

.pmu = {

arch/x86/events/amd/ibs.c

811

.pmu = {

arch/x86/events/amd/ibs.c

84

struct pmu pmu;

arch/x86/events/amd/iommu.c

157

struct perf_amd_iommu *piommu = container_of(event->pmu, struct perf_amd_iommu, pmu);

arch/x86/events/amd/iommu.c

213

if (event->attr.type != event->pmu->type)

arch/x86/events/amd/iommu.c

236

return (container_of(ev->pmu, struct perf_amd_iommu, pmu))->iommu;

arch/x86/events/amd/iommu.c

371

container_of(event->pmu, struct perf_amd_iommu, pmu);

arch/x86/events/amd/iommu.c

39

struct pmu pmu;

arch/x86/events/amd/iommu.c

408

static const struct pmu iommu_pmu __initconst = {

arch/x86/events/amd/iommu.c

431

perf_iommu->pmu = iommu_pmu;

arch/x86/events/amd/iommu.c

445

ret = perf_pmu_register(&perf_iommu->pmu, perf_iommu->name, -1);

arch/x86/events/amd/lbr.c

354

perf_sched_cb_inc(event->pmu);

arch/x86/events/amd/lbr.c

372

perf_sched_cb_dec(event->pmu);

arch/x86/events/amd/power.c

206

static struct pmu pmu_class = {

arch/x86/events/amd/power.c

34

static struct pmu pmu_class;

arch/x86/events/amd/uncore.c

1014

struct amd_uncore_pmu *pmu;

arch/x86/events/amd/uncore.c

1047

pmu = &uncore->pmus[index];

arch/x86/events/amd/uncore.c

1048

snprintf(pmu->name, sizeof(pmu->name), "amd_umc_%hu", index);

arch/x86/events/amd/uncore.c

1049

pmu->num_counters = group_num_pmcs[gid] / group_num_pmus[gid];

arch/x86/events/amd/uncore.c

1050

pmu->msr_base = MSR_F19H_UMC_PERF_CTL + i * pmu->num_counters * 2;

arch/x86/events/amd/uncore.c

1051

pmu->rdpmc_base = -1;

arch/x86/events/amd/uncore.c

1052

pmu->group = gid;

arch/x86/events/amd/uncore.c

1054

pmu->ctx = alloc_percpu(struct amd_uncore_ctx *);

arch/x86/events/amd/uncore.c

1055

if (!pmu->ctx)

arch/x86/events/amd/uncore.c

1058

pmu->pmu = (struct pmu) {

arch/x86/events/amd/uncore.c

1061

.name = pmu->name,

arch/x86/events/amd/uncore.c

1072

if (perf_pmu_register(&pmu->pmu, pmu->pmu.name, -1)) {

arch/x86/events/amd/uncore.c

1073

free_percpu(pmu->ctx);

arch/x86/events/amd/uncore.c

1074

pmu->ctx = NULL;

arch/x86/events/amd/uncore.c

1078

pr_info("%d %s counters detected\n", pmu->num_counters,

arch/x86/events/amd/uncore.c

1079

pmu->pmu.name);

arch/x86/events/amd/uncore.c

112

event->pmu->read(event);

arch/x86/events/amd/uncore.c

1190

struct amd_uncore_pmu *pmu;

arch/x86/events/amd/uncore.c

1206

pmu = &uncore->pmus[j];

arch/x86/events/amd/uncore.c

1207

if (!pmu->ctx)

arch/x86/events/amd/uncore.c

1210

perf_pmu_unregister(&pmu->pmu);

arch/x86/events/amd/uncore.c

1211

free_percpu(pmu->ctx);

arch/x86/events/amd/uncore.c

1212

pmu->ctx = NULL;

arch/x86/events/amd/uncore.c

165

struct amd_uncore_pmu *pmu = event_to_amd_uncore_pmu(event);

arch/x86/events/amd/uncore.c

166

struct amd_uncore_ctx *ctx = *per_cpu_ptr(pmu->ctx, event->cpu);

arch/x86/events/amd/uncore.c

183

struct amd_uncore_pmu *pmu = event_to_amd_uncore_pmu(event);

arch/x86/events/amd/uncore.c

184

struct amd_uncore_ctx *ctx = *per_cpu_ptr(pmu->ctx, event->cpu);

arch/x86/events/amd/uncore.c

191

event->pmu->read(event);

arch/x86/events/amd/uncore.c

204

struct amd_uncore_pmu *pmu = event_to_amd_uncore_pmu(event);

arch/x86/events/amd/uncore.c

205

struct amd_uncore_ctx *ctx = *per_cpu_ptr(pmu->ctx, event->cpu);

arch/x86/events/amd/uncore.c

212

for (i = 0; i < pmu->num_counters; i++) {

arch/x86/events/amd/uncore.c

221

for (i = 0; i < pmu->num_counters; i++) {

arch/x86/events/amd/uncore.c

234

hwc->config_base = pmu->msr_base + (2 * hwc->idx);

arch/x86/events/amd/uncore.c

235

hwc->event_base = pmu->msr_base + 1 + (2 * hwc->idx);

arch/x86/events/amd/uncore.c

236

hwc->event_base_rdpmc = pmu->rdpmc_base + hwc->idx;

arch/x86/events/amd/uncore.c

239

if (pmu->rdpmc_base < 0)

arch/x86/events/amd/uncore.c

243

event->pmu->start(event, PERF_EF_RELOAD);

arch/x86/events/amd/uncore.c

251

struct amd_uncore_pmu *pmu = event_to_amd_uncore_pmu(event);

arch/x86/events/amd/uncore.c

252

struct amd_uncore_ctx *ctx = *per_cpu_ptr(pmu->ctx, event->cpu);

arch/x86/events/amd/uncore.c

255

event->pmu->stop(event, PERF_EF_UPDATE);

arch/x86/events/amd/uncore.c

257

for (i = 0; i < pmu->num_counters; i++) {

arch/x86/events/amd/uncore.c

269

struct amd_uncore_pmu *pmu;

arch/x86/events/amd/uncore.c

273

if (event->attr.type != event->pmu->type)

arch/x86/events/amd/uncore.c

279

pmu = event_to_amd_uncore_pmu(event);

arch/x86/events/amd/uncore.c

280

ctx = *per_cpu_ptr(pmu->ctx, event->cpu);

arch/x86/events/amd/uncore.c

321

struct pmu *ptr = dev_get_drvdata(dev);

arch/x86/events/amd/uncore.c

322

struct amd_uncore_pmu *pmu = container_of(ptr, struct amd_uncore_pmu, pmu);

arch/x86/events/amd/uncore.c

324

return cpumap_print_to_pagebuf(true, buf, &pmu->active_mask);

arch/x86/events/amd/uncore.c

474

struct amd_uncore_pmu *pmu;

arch/x86/events/amd/uncore.c

482

pmu = &uncore->pmus[i];

arch/x86/events/amd/uncore.c

483

ctx = *per_cpu_ptr(pmu->ctx, cpu);

arch/x86/events/amd/uncore.c

488

cpumask_clear_cpu(cpu, &pmu->active_mask);

arch/x86/events/amd/uncore.c

495

*per_cpu_ptr(pmu->ctx, cpu) = NULL;

arch/x86/events/amd/uncore.c

502

struct amd_uncore_pmu *pmu;

arch/x86/events/amd/uncore.c

512

pmu = &uncore->pmus[i];

arch/x86/events/amd/uncore.c

513

*per_cpu_ptr(pmu->ctx, cpu) = NULL;

arch/x86/events/amd/uncore.c

517

if (gid != pmu->group)

arch/x86/events/amd/uncore.c

525

prev = *per_cpu_ptr(pmu->ctx, j);

arch/x86/events/amd/uncore.c

544

pmu->num_counters,

arch/x86/events/amd/uncore.c

55

struct pmu pmu;

arch/x86/events/amd/uncore.c

554

cpumask_set_cpu(cpu, &pmu->active_mask);

arch/x86/events/amd/uncore.c

558

*per_cpu_ptr(pmu->ctx, cpu) = curr;

arch/x86/events/amd/uncore.c

572

struct amd_uncore_pmu *pmu;

arch/x86/events/amd/uncore.c

579

pmu = &uncore->pmus[i];

arch/x86/events/amd/uncore.c

580

curr = *per_cpu_ptr(pmu->ctx, cpu);

arch/x86/events/amd/uncore.c

586

next = *per_cpu_ptr(pmu->ctx, j);

arch/x86/events/amd/uncore.c

591

perf_pmu_migrate_context(&pmu->pmu, cpu, j);

arch/x86/events/amd/uncore.c

592

cpumask_clear_cpu(cpu, &pmu->active_mask);

arch/x86/events/amd/uncore.c

593

cpumask_set_cpu(j, &pmu->active_mask);

arch/x86/events/amd/uncore.c

717

struct amd_uncore_pmu *pmu;

arch/x86/events/amd/uncore.c

738

pmu = &uncore->pmus[0];

arch/x86/events/amd/uncore.c

739

strscpy(pmu->name, boot_cpu_data.x86 >= 0x17 ? "amd_df" : "amd_nb",

arch/x86/events/amd/uncore.c

740

sizeof(pmu->name));

arch/x86/events/amd/uncore.c

741

pmu->num_counters = num_counters;

arch/x86/events/amd/uncore.c

742

pmu->msr_base = MSR_F15H_NB_PERF_CTL;

arch/x86/events/amd/uncore.c

743

pmu->rdpmc_base = RDPMC_BASE_NB;

arch/x86/events/amd/uncore.c

744

pmu->group = amd_uncore_ctx_gid(uncore, cpu);

arch/x86/events/amd/uncore.c

753

pmu->ctx = alloc_percpu(struct amd_uncore_ctx *);

arch/x86/events/amd/uncore.c

754

if (!pmu->ctx)

arch/x86/events/amd/uncore.c

757

pmu->pmu = (struct pmu) {

arch/x86/events/amd/uncore.c

760

.name = pmu->name,

arch/x86/events/amd/uncore.c

771

if (perf_pmu_register(&pmu->pmu, pmu->pmu.name, -1)) {

arch/x86/events/amd/uncore.c

772

free_percpu(pmu->ctx);

arch/x86/events/amd/uncore.c

773

pmu->ctx = NULL;

arch/x86/events/amd/uncore.c

777

pr_info("%d %s%s counters detected\n", pmu->num_counters,

arch/x86/events/amd/uncore.c

779

pmu->pmu.name);

arch/x86/events/amd/uncore.c

851

struct amd_uncore_pmu *pmu;

arch/x86/events/amd/uncore.c

872

pmu = &uncore->pmus[0];

arch/x86/events/amd/uncore.c

873

strscpy(pmu->name, boot_cpu_data.x86 >= 0x17 ? "amd_l3" : "amd_l2",

arch/x86/events/amd/uncore.c

874

sizeof(pmu->name));

arch/x86/events/amd/uncore.c

875

pmu->num_counters = num_counters;

arch/x86/events/amd/uncore.c

876

pmu->msr_base = MSR_F16H_L2I_PERF_CTL;

arch/x86/events/amd/uncore.c

877

pmu->rdpmc_base = RDPMC_BASE_LLC;

arch/x86/events/amd/uncore.c

878

pmu->group = amd_uncore_ctx_gid(uncore, cpu);

arch/x86/events/amd/uncore.c

888

pmu->ctx = alloc_percpu(struct amd_uncore_ctx *);

arch/x86/events/amd/uncore.c

889

if (!pmu->ctx)

arch/x86/events/amd/uncore.c

892

pmu->pmu = (struct pmu) {

arch/x86/events/amd/uncore.c

896

.name = pmu->name,

arch/x86/events/amd/uncore.c

907

if (perf_pmu_register(&pmu->pmu, pmu->pmu.name, -1)) {

arch/x86/events/amd/uncore.c

908

free_percpu(pmu->ctx);

arch/x86/events/amd/uncore.c

909

pmu->ctx = NULL;

arch/x86/events/amd/uncore.c

913

pr_info("%d %s%s counters detected\n", pmu->num_counters,

arch/x86/events/amd/uncore.c

915

pmu->pmu.name);

arch/x86/events/amd/uncore.c

940

struct amd_uncore_pmu *pmu = event_to_amd_uncore_pmu(event);

arch/x86/events/amd/uncore.c

941

struct amd_uncore_ctx *ctx = *per_cpu_ptr(pmu->ctx, event->cpu);

arch/x86/events/amd/uncore.c

96

return container_of(event->pmu, struct amd_uncore_pmu, pmu);

arch/x86/events/core.c

1082

int gpmax = x86_pmu_max_num_counters(cpuc->pmu);

arch/x86/events/core.c

1165

union perf_capabilities intel_cap = hybrid(cpuc->pmu, intel_cap);

arch/x86/events/core.c

1191

max_count = x86_pmu_num_counters(cpuc->pmu) + x86_pmu_num_counters_fixed(cpuc->pmu);

arch/x86/events/core.c

1308

static void x86_pmu_enable(struct pmu *pmu)

arch/x86/events/core.c

1570

cntr_mask = hybrid(cpuc->pmu, cntr_mask);

arch/x86/events/core.c

1571

fixed_cntr_mask = hybrid(cpuc->pmu, fixed_cntr_mask);

arch/x86/events/core.c

1572

pebs_constraints = hybrid(cpuc->pmu, pebs_constraints);

arch/x86/events/core.c

1613

if (fixed_counter_disabled(idx, cpuc->pmu))

arch/x86/events/core.c

1647

union perf_capabilities intel_cap = hybrid(cpuc->pmu, intel_cap);

arch/x86/events/core.c

173

struct extra_reg *extra_regs = hybrid(event->pmu, extra_regs);

arch/x86/events/core.c

1886

pmu.capabilities |= PERF_PMU_CAP_NO_INTERRUPT;

arch/x86/events/core.c

1941

struct x86_hybrid_pmu *pmu;

arch/x86/events/core.c

1957

pmu = container_of(dev_get_drvdata(dev), struct x86_hybrid_pmu, pmu);

arch/x86/events/core.c

1963

if (x86_pmu.hybrid_pmu[i].pmu_type & pmu->pmu_type) {

arch/x86/events/core.c

2117

void x86_pmu_show_pmu_cap(struct pmu *pmu)

arch/x86/events/core.c

2121

pr_info("... generic counters: %d\n", x86_pmu_num_counters(pmu));

arch/x86/events/core.c

2122

pr_info("... generic bitmap: %016llx\n", hybrid(pmu, cntr_mask64));

arch/x86/events/core.c

2123

pr_info("... fixed-purpose counters: %d\n", x86_pmu_num_counters_fixed(pmu));

arch/x86/events/core.c

2124

pr_info("... fixed-purpose bitmap: %016llx\n", hybrid(pmu, fixed_cntr_mask64));

arch/x86/events/core.c

2127

pr_info("... global_ctrl mask: %016llx\n", hybrid(pmu, intel_ctrl));

arch/x86/events/core.c

2164

if (!check_hw_exists(&pmu, x86_pmu.cntr_mask, x86_pmu.fixed_cntr_mask))

arch/x86/events/core.c

2193

pmu.attr_update = x86_pmu.attr_update;

arch/x86/events/core.c

2233

err = perf_pmu_register(&pmu, "cpu", PERF_TYPE_RAW);

arch/x86/events/core.c

2243

hybrid_pmu->pmu = pmu;

arch/x86/events/core.c

2244

hybrid_pmu->pmu.type = -1;

arch/x86/events/core.c

2245

hybrid_pmu->pmu.attr_update = x86_pmu.attr_update;

arch/x86/events/core.c

2246

hybrid_pmu->pmu.capabilities |= PERF_PMU_CAP_EXTENDED_HW_TYPE;

arch/x86/events/core.c

2248

err = perf_pmu_register(&hybrid_pmu->pmu, hybrid_pmu->name,

arch/x86/events/core.c

2256

perf_pmu_unregister(&x86_pmu.hybrid_pmu[j].pmu);

arch/x86/events/core.c

2293

static void x86_pmu_start_txn(struct pmu *pmu, unsigned int txn_flags)

arch/x86/events/core.c

2303

perf_pmu_disable(pmu);

arch/x86/events/core.c

2314

static void x86_pmu_cancel_txn(struct pmu *pmu)

arch/x86/events/core.c

2334

perf_pmu_enable(pmu);

arch/x86/events/core.c

2344

static int x86_pmu_commit_txn(struct pmu *pmu)

arch/x86/events/core.c

2373

perf_pmu_enable(pmu);

arch/x86/events/core.c

2390

static struct cpu_hw_events *allocate_fake_cpuc(struct pmu *event_pmu)

arch/x86/events/core.c

2409

cpuc->pmu = event_pmu;

arch/x86/events/core.c

2429

fake_cpuc = allocate_fake_cpuc(event->pmu);

arch/x86/events/core.c

2468

struct pmu *pmu = NULL;

arch/x86/events/core.c

2471

pmu = leader->pmu;

arch/x86/events/core.c

2476

if (!pmu)

arch/x86/events/core.c

2477

pmu = sibling->pmu;

arch/x86/events/core.c

2478

else if (pmu != sibling->pmu)

arch/x86/events/core.c

2483

fake_cpuc = allocate_fake_cpuc(event->pmu);

arch/x86/events/core.c

2511

struct x86_hybrid_pmu *pmu = NULL;

arch/x86/events/core.c

2514

if ((event->attr.type != event->pmu->type) &&

arch/x86/events/core.c

2520

pmu = hybrid_pmu(event->pmu);

arch/x86/events/core.c

2521

if (!cpumask_test_cpu(event->cpu, &pmu->supported_cpus))

arch/x86/events/core.c

2560

if (!test_bit(i - INTEL_PMC_IDX_FIXED, hybrid(cpuc->pmu, fixed_cntr_mask)))

arch/x86/events/core.c

268

bool check_hw_exists(struct pmu *pmu, unsigned long *cntr_mask,

arch/x86/events/core.c

2701

struct pmu *pmu = dev_get_drvdata(cdev);

arch/x86/events/core.c

2703

return snprintf(buf, PAGE_SIZE, "%d\n", x86_pmu_max_precise(pmu));

arch/x86/events/core.c

2755

if (!(pmu.capabilities & PERF_PMU_CAP_AUX_OUTPUT))

arch/x86/events/core.c

2764

static bool x86_pmu_filter(struct pmu *pmu, int cpu)

arch/x86/events/core.c

2768

static_call_cond(x86_pmu_filter)(pmu, cpu, &ret);

arch/x86/events/core.c

2773

static struct pmu pmu = {

arch/x86/events/core.c

300

if (fixed_counter_disabled(i, pmu))

arch/x86/events/core.c

3139

cap->mediated = !!(pmu.capabilities & PERF_PMU_CAP_MEDIATED_VPMU);

arch/x86/events/core.c

401

val = hybrid_var(event->pmu, hw_cache_event_ids)[cache_type][cache_op][cache_result];

arch/x86/events/core.c

409

attr->config1 = hybrid_var(event->pmu, hw_cache_extra_regs)[cache_type][cache_op][cache_result];

arch/x86/events/core.c

504

if (attr->type == event->pmu->type)

arch/x86/events/core.c

53

static struct pmu pmu;

arch/x86/events/core.c

561

int x86_pmu_max_precise(struct pmu *pmu)

arch/x86/events/core.c

569

if (hybrid(pmu, arch_pebs_cap).pdists)

arch/x86/events/core.c

57

.pmu = &pmu,

arch/x86/events/core.c

591

int precise = x86_pmu_max_precise(event->pmu);

arch/x86/events/core.c

648

if (event->attr.type == event->pmu->type)

arch/x86/events/core.c

666

if (!(event->pmu->capabilities & PERF_PMU_CAP_EXTENDED_REGS))

arch/x86/events/core.c

745

static void x86_pmu_disable(struct pmu *pmu)

arch/x86/events/core.c

786

if (event->pmu->type == PERF_TYPE_RAW ||

arch/x86/events/core.c

787

event->pmu->capabilities & PERF_PMU_CAP_EXTENDED_HW_TYPE)

arch/x86/events/core.c

793

struct pmu *x86_get_pmu(unsigned int cpu)

arch/x86/events/core.c

801

if (WARN_ON_ONCE(!cpuc->pmu))

arch/x86/events/core.c

802

return &pmu;

arch/x86/events/core.c

804

return cpuc->pmu;

arch/x86/events/intel/bts.c

65

static struct pmu bts_pmu;

arch/x86/events/intel/core.c

2528

u64 intel_ctrl = hybrid(cpuc->pmu, intel_ctrl);

arch/x86/events/intel/core.c

3205

cap = hybrid(cpuc->pmu, arch_pebs_cap);

arch/x86/events/intel/core.c

3270

if (!x86_pmu_has_rdpmc_user_disable(event->pmu))

arch/x86/events/intel/core.c

3421

unsigned long *cntr_mask = hybrid(cpuc->pmu, cntr_mask);

arch/x86/events/intel/core.c

3422

unsigned long *fixed_cntr_mask = hybrid(cpuc->pmu, fixed_cntr_mask);

arch/x86/events/intel/core.c

3438

if (fixed_counter_disabled(idx, cpuc->pmu))

arch/x86/events/intel/core.c

3600

status &= hybrid(cpuc->pmu, intel_ctrl);

arch/x86/events/intel/core.c

3665

bool late_ack = hybrid_bit(cpuc->pmu, late_ack);

arch/x86/events/intel/core.c

3666

bool mid_ack = hybrid_bit(cpuc->pmu, mid_ack);

arch/x86/events/intel/core.c

3768

struct extra_reg *extra_regs = hybrid(cpuc->pmu, extra_regs);

arch/x86/events/intel/core.c

3803

struct extra_reg *extra_regs = hybrid(event->pmu, extra_regs);

arch/x86/events/intel/core.c

3963

struct event_constraint *event_constraints = hybrid(cpuc->pmu, event_constraints);

arch/x86/events/intel/core.c

3975

return &hybrid_var(cpuc->pmu, unconstrained);

arch/x86/events/intel/core.c

4493

return hybrid_pmu(event->pmu)->pmu_type == hybrid_big;

arch/x86/events/intel/core.c

4500

union perf_capabilities *intel_cap = &hybrid(event->pmu, intel_cap);

arch/x86/events/intel/core.c

4584

static inline bool intel_pmu_has_acr(struct pmu *pmu)

arch/x86/events/intel/core.c

4586

return !!hybrid(pmu, acr_cause_mask64);

arch/x86/events/intel/core.c

4602

static inline bool intel_pmu_has_pebs_counter_group(struct pmu *pmu)

arch/x86/events/intel/core.c

4609

caps = hybrid(pmu, arch_pebs_cap).caps;

arch/x86/events/intel/core.c

4619

event->hw.dyn_constraint &= hybrid(event->pmu, acr_cntr_mask64);

arch/x86/events/intel/core.c

4628

event->hw.dyn_constraint &= hybrid(event->pmu, acr_cause_mask64);

arch/x86/events/intel/core.c

4662

struct arch_pebs_cap pebs_cap = hybrid(event->pmu, arch_pebs_cap);

arch/x86/events/intel/core.c

4679

u64 cntr_mask = hybrid(event->pmu, intel_ctrl) &

arch/x86/events/intel/core.c

4775

intel_pmu_has_pebs_counter_group(event->pmu) &&

arch/x86/events/intel/core.c

4780

if (intel_pmu_has_acr(event->pmu) && intel_pmu_is_acr_group(event)) {

arch/x86/events/intel/core.c

4782

struct pmu *pmu = event->pmu;

arch/x86/events/intel/core.c

4848

if (hweight64(cause_mask) > hweight64(hybrid(pmu, acr_cause_mask64)) ||

arch/x86/events/intel/core.c

4849

num > hweight64(hybrid(event->pmu, acr_cntr_mask64)))

arch/x86/events/intel/core.c

5000

u64 intel_ctrl = hybrid(cpuc->pmu, intel_ctrl);

arch/x86/events/intel/core.c

5099

*nr = x86_pmu_max_num_counters(cpuc->pmu);

arch/x86/events/intel/core.c

5306

struct x86_hybrid_pmu *pmu = hybrid_pmu(event->pmu);

arch/x86/events/intel/core.c

5308

if (pmu->pmu_type == hybrid_big)

arch/x86/events/intel/core.c

5310

else if (pmu->pmu_type == hybrid_small)

arch/x86/events/intel/core.c

5383

struct x86_hybrid_pmu *pmu = hybrid_pmu(event->pmu);

arch/x86/events/intel/core.c

5385

if (pmu->pmu_type == hybrid_big)

arch/x86/events/intel/core.c

5387

if (pmu->pmu_type == hybrid_small)

arch/x86/events/intel/core.c

5396

struct x86_hybrid_pmu *pmu = hybrid_pmu(event->pmu);

arch/x86/events/intel/core.c

5398

if (pmu->pmu_type == hybrid_big)

arch/x86/events/intel/core.c

5400

else if (pmu->pmu_type == hybrid_small)

arch/x86/events/intel/core.c

5422

struct x86_hybrid_pmu *pmu = hybrid_pmu(event->pmu);

arch/x86/events/intel/core.c

5424

if (pmu->pmu_type == hybrid_tiny)

arch/x86/events/intel/core.c

5432

struct x86_hybrid_pmu *pmu = hybrid_pmu(event->pmu);

arch/x86/events/intel/core.c

5434

if (pmu->pmu_type == hybrid_tiny)

arch/x86/events/intel/core.c

5795

static void intel_pmu_check_dyn_constr(struct pmu *pmu,

arch/x86/events/intel/core.c

5813

mask = hybrid(pmu, acr_cntr_mask64) & GENMASK_ULL(INTEL_PMC_MAX_GENERIC - 1, 0);

arch/x86/events/intel/core.c

5816

if (hybrid(pmu, acr_cntr_mask64) == hybrid(pmu, acr_cause_mask64))

arch/x86/events/intel/core.c

5818

mask = hybrid(pmu, acr_cause_mask64) & GENMASK_ULL(INTEL_PMC_MAX_GENERIC - 1, 0);

arch/x86/events/intel/core.c

5822

mask = hybrid(pmu, arch_pebs_cap).counters;

arch/x86/events/intel/core.c

5826

mask = hybrid(pmu, arch_pebs_cap).pdists;

arch/x86/events/intel/core.c

5837

static void intel_pmu_check_event_constraints_all(struct pmu *pmu)

arch/x86/events/intel/core.c

5839

struct event_constraint *event_constraints = hybrid(pmu, event_constraints);

arch/x86/events/intel/core.c

5840

struct event_constraint *pebs_constraints = hybrid(pmu, pebs_constraints);

arch/x86/events/intel/core.c

5841

u64 cntr_mask = hybrid(pmu, cntr_mask64);

arch/x86/events/intel/core.c

5842

u64 fixed_cntr_mask = hybrid(pmu, fixed_cntr_mask64);

arch/x86/events/intel/core.c

5843

u64 intel_ctrl = hybrid(pmu, intel_ctrl);

arch/x86/events/intel/core.c

5849

intel_pmu_check_dyn_constr(pmu, event_constraints, cntr_mask);

arch/x86/events/intel/core.c

5852

intel_pmu_check_dyn_constr(pmu, pebs_constraints, cntr_mask);

arch/x86/events/intel/core.c

5867

static inline void __intel_update_pmu_caps(struct pmu *pmu)

arch/x86/events/intel/core.c

5869

struct pmu *dest_pmu = pmu ? pmu : x86_get_pmu(smp_processor_id());

arch/x86/events/intel/core.c

5871

if (hybrid(pmu, arch_pebs_cap).caps & ARCH_PEBS_VECR_XMM)

arch/x86/events/intel/core.c

5875

static inline void __intel_update_large_pebs_flags(struct pmu *pmu)

arch/x86/events/intel/core.c

5877

u64 caps = hybrid(pmu, arch_pebs_cap).caps;

arch/x86/events/intel/core.c

5895

static void update_pmu_cap(struct pmu *pmu)

arch/x86/events/intel/core.c

5907

hybrid(pmu, config_mask) |= ARCH_PERFMON_EVENTSEL_UMASK2;

arch/x86/events/intel/core.c

5909

hybrid(pmu, config_mask) |= ARCH_PERFMON_EVENTSEL_EQ;

arch/x86/events/intel/core.c

5911

hybrid(pmu, config_mask) |= ARCH_PERFMON_EVENTSEL_RDPMC_USER_DISABLE;

arch/x86/events/intel/core.c

5916

hybrid(pmu, cntr_mask64) = eax;

arch/x86/events/intel/core.c

5917

hybrid(pmu, fixed_cntr_mask64) = ebx;

arch/x86/events/intel/core.c

5925

hybrid(pmu, acr_cntr_mask64) = counter_mask(eax, ebx);

arch/x86/events/intel/core.c

5927

hybrid(pmu, acr_cause_mask64) = counter_mask(ecx, edx);

arch/x86/events/intel/core.c

5934

hybrid(pmu, arch_pebs_cap).caps = (u64)ebx << 32;

arch/x86/events/intel/core.c

5940

hybrid(pmu, arch_pebs_cap).counters = pebs_mask;

arch/x86/events/intel/core.c

5941

hybrid(pmu, arch_pebs_cap).pdists = pdists_mask;

arch/x86/events/intel/core.c

5946

__intel_update_pmu_caps(pmu);

arch/x86/events/intel/core.c

5947

__intel_update_large_pebs_flags(pmu);

arch/x86/events/intel/core.c

5956

rdmsrq(MSR_IA32_PERF_CAPABILITIES, hybrid(pmu, intel_cap).capabilities);

arch/x86/events/intel/core.c

5960

static void intel_pmu_check_hybrid_pmus(struct x86_hybrid_pmu *pmu)

arch/x86/events/intel/core.c

5962

intel_pmu_check_counters_mask(&pmu->cntr_mask64, &pmu->fixed_cntr_mask64,

arch/x86/events/intel/core.c

5963

&pmu->intel_ctrl);

arch/x86/events/intel/core.c

5964

pmu->pebs_events_mask = intel_pmu_pebs_mask(pmu->cntr_mask64);

arch/x86/events/intel/core.c

5965

pmu->unconstrained = (struct event_constraint)

arch/x86/events/intel/core.c

5966

__EVENT_CONSTRAINT(0, pmu->cntr_mask64,

arch/x86/events/intel/core.c

5967

0, x86_pmu_num_counters(&pmu->pmu), 0, 0);

arch/x86/events/intel/core.c

5969

if (pmu->intel_cap.perf_metrics)

arch/x86/events/intel/core.c

5970

pmu->intel_ctrl |= GLOBAL_CTRL_EN_PERF_METRICS;

arch/x86/events/intel/core.c

5972

pmu->intel_ctrl &= ~GLOBAL_CTRL_EN_PERF_METRICS;

arch/x86/events/intel/core.c

5974

pmu->pmu.capabilities |= PERF_PMU_CAP_MEDIATED_VPMU;

arch/x86/events/intel/core.c

5976

intel_pmu_check_event_constraints_all(&pmu->pmu);

arch/x86/events/intel/core.c

5978

intel_pmu_check_extra_regs(pmu->extra_regs);

arch/x86/events/intel/core.c

6030

struct x86_hybrid_pmu *pmu = find_hybrid_pmu_for_cpu();

arch/x86/events/intel/core.c

6032

if (WARN_ON_ONCE(!pmu || (pmu->pmu.type == -1))) {

arch/x86/events/intel/core.c

6033

cpuc->pmu = NULL;

arch/x86/events/intel/core.c

6038

if (!cpumask_empty(&pmu->supported_cpus))

arch/x86/events/intel/core.c

6042

update_pmu_cap(&pmu->pmu);

arch/x86/events/intel/core.c

6044

intel_pmu_check_hybrid_pmus(pmu);

arch/x86/events/intel/core.c

6046

if (!check_hw_exists(&pmu->pmu, pmu->cntr_mask, pmu->fixed_cntr_mask))

arch/x86/events/intel/core.c

6049

pr_info("%s PMU driver: ", pmu->name);

arch/x86/events/intel/core.c

6053

x86_pmu_show_pmu_cap(&pmu->pmu);

arch/x86/events/intel/core.c

6056

cpumask_set_cpu(cpu, &pmu->supported_cpus);

arch/x86/events/intel/core.c

6057

cpuc->pmu = &pmu->pmu;

arch/x86/events/intel/core.c

6111

__intel_update_pmu_caps(cpuc->pmu);

arch/x86/events/intel/core.c

6196

if (is_hybrid() && cpuc->pmu)

arch/x86/events/intel/core.c

6197

cpumask_clear_cpu(cpu, &hybrid_pmu(cpuc->pmu)->supported_cpus);

arch/x86/events/intel/core.c

6228

static void intel_pmu_filter(struct pmu *pmu, int cpu, bool *ret)

arch/x86/events/intel/core.c

6230

struct x86_hybrid_pmu *hpmu = hybrid_pmu(pmu);

arch/x86/events/intel/core.c

7191

struct x86_hybrid_pmu *pmu =

arch/x86/events/intel/core.c

7192

container_of(dev_get_drvdata(dev), struct x86_hybrid_pmu, pmu);

arch/x86/events/intel/core.c

7196

return pmu->pmu_type & pmu_attr->pmu_type;

arch/x86/events/intel/core.c

7205

static inline int hybrid_find_supported_cpu(struct x86_hybrid_pmu *pmu)

arch/x86/events/intel/core.c

7207

int cpu = cpumask_first(&pmu->supported_cpus);

arch/x86/events/intel/core.c

7216

struct x86_hybrid_pmu *pmu =

arch/x86/events/intel/core.c

7217

container_of(dev_get_drvdata(dev), struct x86_hybrid_pmu, pmu);

arch/x86/events/intel/core.c

7218

int cpu = hybrid_find_supported_cpu(pmu);

arch/x86/events/intel/core.c

7227

struct x86_hybrid_pmu *pmu =

arch/x86/events/intel/core.c

7228

container_of(dev_get_drvdata(dev), struct x86_hybrid_pmu, pmu);

arch/x86/events/intel/core.c

7231

int cpu = hybrid_find_supported_cpu(pmu);

arch/x86/events/intel/core.c

7233

return (cpu >= 0) && (pmu->pmu_type & pmu_attr->pmu_type) ? attr->mode : 0;

arch/x86/events/intel/core.c

7240

struct x86_hybrid_pmu *pmu =

arch/x86/events/intel/core.c

7241

container_of(dev_get_drvdata(dev), struct x86_hybrid_pmu, pmu);

arch/x86/events/intel/core.c

7248

if (pmu->pmu_type == hybrid_big)

arch/x86/events/intel/core.c

7249

return pmu->intel_cap.perf_metrics ? attr->mode : 0;

arch/x86/events/intel/core.c

7278

struct x86_hybrid_pmu *pmu =

arch/x86/events/intel/core.c

7279

container_of(dev_get_drvdata(dev), struct x86_hybrid_pmu, pmu);

arch/x86/events/intel/core.c

7281

return cpumap_print_to_pagebuf(true, buf, &pmu->supported_cpus);

arch/x86/events/intel/core.c

7390

struct x86_hybrid_pmu *pmu;

arch/x86/events/intel/core.c

7403

pmu = &x86_pmu.hybrid_pmu[idx++];

arch/x86/events/intel/core.c

7404

pmu->pmu_type = intel_hybrid_pmu_type_map[bit].id;

arch/x86/events/intel/core.c

7405

pmu->name = intel_hybrid_pmu_type_map[bit].name;

arch/x86/events/intel/core.c

7407

pmu->cntr_mask64 = x86_pmu.cntr_mask64;

arch/x86/events/intel/core.c

7408

pmu->fixed_cntr_mask64 = x86_pmu.fixed_cntr_mask64;

arch/x86/events/intel/core.c

7409

pmu->pebs_events_mask = intel_pmu_pebs_mask(pmu->cntr_mask64);

arch/x86/events/intel/core.c

7410

pmu->config_mask = X86_RAW_EVENT_MASK;

arch/x86/events/intel/core.c

7411

pmu->unconstrained = (struct event_constraint)

arch/x86/events/intel/core.c

7412

__EVENT_CONSTRAINT(0, pmu->cntr_mask64,

arch/x86/events/intel/core.c

7413

0, x86_pmu_num_counters(&pmu->pmu), 0, 0);

arch/x86/events/intel/core.c

7415

pmu->intel_cap.capabilities = x86_pmu.intel_cap.capabilities;

arch/x86/events/intel/core.c

7416

if (pmu->pmu_type & hybrid_small_tiny) {

arch/x86/events/intel/core.c

7417

pmu->intel_cap.perf_metrics = 0;

arch/x86/events/intel/core.c

7418

pmu->mid_ack = true;

arch/x86/events/intel/core.c

7419

} else if (pmu->pmu_type & hybrid_big) {

arch/x86/events/intel/core.c

7420

pmu->intel_cap.perf_metrics = 1;

arch/x86/events/intel/core.c

7421

pmu->late_ack = true;

arch/x86/events/intel/core.c

7434

static __always_inline void intel_pmu_init_glc(struct pmu *pmu)

arch/x86/events/intel/core.c

7452

memcpy(hybrid_var(pmu, hw_cache_event_ids), glc_hw_cache_event_ids, sizeof(hw_cache_event_ids));

arch/x86/events/intel/core.c

7453

memcpy(hybrid_var(pmu, hw_cache_extra_regs), glc_hw_cache_extra_regs, sizeof(hw_cache_extra_regs));

arch/x86/events/intel/core.c

7454

hybrid(pmu, event_constraints) = intel_glc_event_constraints;

arch/x86/events/intel/core.c

7455

hybrid(pmu, pebs_constraints) = intel_glc_pebs_event_constraints;

arch/x86/events/intel/core.c

7460

static __always_inline void intel_pmu_init_grt(struct pmu *pmu)

arch/x86/events/intel/core.c

7471

memcpy(hybrid_var(pmu, hw_cache_event_ids), glp_hw_cache_event_ids, sizeof(hw_cache_event_ids));

arch/x86/events/intel/core.c

7472

memcpy(hybrid_var(pmu, hw_cache_extra_regs), tnt_hw_cache_extra_regs, sizeof(hw_cache_extra_regs));

arch/x86/events/intel/core.c

7473

hybrid_var(pmu, hw_cache_event_ids)[C(ITLB)][C(OP_READ)][C(RESULT_ACCESS)] = -1;

arch/x86/events/intel/core.c

7474

hybrid(pmu, event_constraints) = intel_grt_event_constraints;

arch/x86/events/intel/core.c

7475

hybrid(pmu, pebs_constraints) = intel_grt_pebs_event_constraints;

arch/x86/events/intel/core.c

7476

hybrid(pmu, extra_regs) = intel_grt_extra_regs;

arch/x86/events/intel/core.c

7481

static __always_inline void intel_pmu_init_lnc(struct pmu *pmu)

arch/x86/events/intel/core.c

7483

intel_pmu_init_glc(pmu);

arch/x86/events/intel/core.c

7484

hybrid(pmu, event_constraints) = intel_lnc_event_constraints;

arch/x86/events/intel/core.c

7485

hybrid(pmu, pebs_constraints) = intel_lnc_pebs_event_constraints;

arch/x86/events/intel/core.c

7486

hybrid(pmu, extra_regs) = intel_lnc_extra_regs;

arch/x86/events/intel/core.c

7489

static __always_inline void intel_pmu_init_pnc(struct pmu *pmu)

arch/x86/events/intel/core.c

7491

intel_pmu_init_glc(pmu);

arch/x86/events/intel/core.c

7494

memcpy(hybrid_var(pmu, hw_cache_event_ids),

arch/x86/events/intel/core.c

7496

memcpy(hybrid_var(pmu, hw_cache_extra_regs),

arch/x86/events/intel/core.c

7498

hybrid(pmu, event_constraints) = intel_pnc_event_constraints;

arch/x86/events/intel/core.c

7499

hybrid(pmu, pebs_constraints) = intel_pnc_pebs_event_constraints;

arch/x86/events/intel/core.c

7500

hybrid(pmu, extra_regs) = intel_pnc_extra_regs;

arch/x86/events/intel/core.c

7503

static __always_inline void intel_pmu_init_skt(struct pmu *pmu)

arch/x86/events/intel/core.c

7505

intel_pmu_init_grt(pmu);

arch/x86/events/intel/core.c

7506

hybrid(pmu, event_constraints) = intel_skt_event_constraints;

arch/x86/events/intel/core.c

7507

hybrid(pmu, extra_regs) = intel_cmt_extra_regs;

arch/x86/events/intel/core.c

7511

static __always_inline void intel_pmu_init_arw(struct pmu *pmu)

arch/x86/events/intel/core.c

7513

intel_pmu_init_grt(pmu);

arch/x86/events/intel/core.c

7516

memcpy(hybrid_var(pmu, hw_cache_extra_regs),

arch/x86/events/intel/core.c

7518

hybrid(pmu, event_constraints) = intel_arw_event_constraints;

arch/x86/events/intel/core.c

7519

hybrid(pmu, pebs_constraints) = intel_arw_pebs_event_constraints;

arch/x86/events/intel/core.c

7520

hybrid(pmu, extra_regs) = intel_arw_extra_regs;

arch/x86/events/intel/core.c

7538

struct x86_hybrid_pmu *pmu;

arch/x86/events/intel/core.c

8227

pmu = &x86_pmu.hybrid_pmu[X86_HYBRID_PMU_CORE_IDX];

arch/x86/events/intel/core.c

8228

intel_pmu_init_glc(&pmu->pmu);

arch/x86/events/intel/core.c

8230

pmu->cntr_mask64 <<= 2;

arch/x86/events/intel/core.c

8231

pmu->cntr_mask64 |= 0x3;

arch/x86/events/intel/core.c

8232

pmu->fixed_cntr_mask64 <<= 1;

arch/x86/events/intel/core.c

8233

pmu->fixed_cntr_mask64 |= 0x1;

arch/x86/events/intel/core.c

8235

pmu->cntr_mask64 = x86_pmu.cntr_mask64;

arch/x86/events/intel/core.c

8236

pmu->fixed_cntr_mask64 = x86_pmu.fixed_cntr_mask64;

arch/x86/events/intel/core.c

8246

if ((x86_pmu_num_counters(&pmu->pmu) > 8) || (x86_pmu_num_counters_fixed(&pmu->pmu) > 4)) {

arch/x86/events/intel/core.c

8247

pmu->cntr_mask64 = x86_pmu.cntr_mask64;

arch/x86/events/intel/core.c

8248

pmu->fixed_cntr_mask64 = x86_pmu.fixed_cntr_mask64;

arch/x86/events/intel/core.c

8251

pmu->pebs_events_mask = intel_pmu_pebs_mask(pmu->cntr_mask64);

arch/x86/events/intel/core.c

8252

pmu->unconstrained = (struct event_constraint)

arch/x86/events/intel/core.c

8253

__EVENT_CONSTRAINT(0, pmu->cntr_mask64,

arch/x86/events/intel/core.c

8254

0, x86_pmu_num_counters(&pmu->pmu), 0, 0);

arch/x86/events/intel/core.c

8256

pmu->extra_regs = intel_glc_extra_regs;

arch/x86/events/intel/core.c

8259

pmu = &x86_pmu.hybrid_pmu[X86_HYBRID_PMU_ATOM_IDX];

arch/x86/events/intel/core.c

8260

intel_pmu_init_grt(&pmu->pmu);

arch/x86/events/intel/core.c

8284

pmu = &x86_pmu.hybrid_pmu[X86_HYBRID_PMU_CORE_IDX];

arch/x86/events/intel/core.c

8285

intel_pmu_init_glc(&pmu->pmu);

arch/x86/events/intel/core.c

8286

pmu->extra_regs = intel_rwc_extra_regs;

arch/x86/events/intel/core.c

8289

pmu = &x86_pmu.hybrid_pmu[X86_HYBRID_PMU_ATOM_IDX];

arch/x86/events/intel/core.c

8290

intel_pmu_init_grt(&pmu->pmu);

arch/x86/events/intel/core.c

8291

pmu->extra_regs = intel_cmt_extra_regs;

arch/x86/events/intel/core.c

8323

pmu = &x86_pmu.hybrid_pmu[X86_HYBRID_PMU_CORE_IDX];

arch/x86/events/intel/core.c

8324

intel_pmu_init_lnc(&pmu->pmu);

arch/x86/events/intel/core.c

8327

pmu = &x86_pmu.hybrid_pmu[X86_HYBRID_PMU_ATOM_IDX];

arch/x86/events/intel/core.c

8328

intel_pmu_init_skt(&pmu->pmu);

arch/x86/events/intel/core.c

8347

pmu = &x86_pmu.hybrid_pmu[X86_HYBRID_PMU_CORE_IDX];

arch/x86/events/intel/core.c

8348

intel_pmu_init_lnc(&pmu->pmu);

arch/x86/events/intel/core.c

8351

pmu = &x86_pmu.hybrid_pmu[X86_HYBRID_PMU_ATOM_IDX];

arch/x86/events/intel/core.c

8352

intel_pmu_init_skt(&pmu->pmu);

arch/x86/events/intel/core.c

8355

pmu = &x86_pmu.hybrid_pmu[X86_HYBRID_PMU_TINY_IDX];

arch/x86/events/intel/core.c

8356

intel_pmu_init_grt(&pmu->pmu);

arch/x86/events/intel/core.c

8357

pmu->extra_regs = intel_cmt_extra_regs;

arch/x86/events/intel/core.c

8381

pmu = &x86_pmu.hybrid_pmu[X86_HYBRID_PMU_CORE_IDX];

arch/x86/events/intel/core.c

8382

intel_pmu_init_pnc(&pmu->pmu);

arch/x86/events/intel/core.c

8385

pmu = &x86_pmu.hybrid_pmu[X86_HYBRID_PMU_ATOM_IDX];

arch/x86/events/intel/core.c

8386

intel_pmu_init_arw(&pmu->pmu);

arch/x86/events/intel/cstate.c

148

static struct pmu cstate_core_pmu;

arch/x86/events/intel/cstate.c

216

static struct pmu cstate_pkg_pmu;

arch/x86/events/intel/cstate.c

260

static struct pmu cstate_module_pmu;

arch/x86/events/intel/cstate.c

283

if (event->attr.type != event->pmu->type)

arch/x86/events/intel/cstate.c

293

if (event->pmu == &cstate_core_pmu) {

arch/x86/events/intel/cstate.c

300

} else if (event->pmu == &cstate_pkg_pmu) {

arch/x86/events/intel/cstate.c

307

} else if (event->pmu == &cstate_module_pmu) {

arch/x86/events/intel/cstate.c

392

static struct pmu cstate_core_pmu = {

arch/x86/events/intel/cstate.c

408

static struct pmu cstate_pkg_pmu = {

arch/x86/events/intel/cstate.c

424

static struct pmu cstate_module_pmu = {

arch/x86/events/intel/ds.c

1554

struct event_constraint *pebs_constraints = hybrid(event->pmu, pebs_constraints);

arch/x86/events/intel/ds.c

1603

int max_pebs_events = intel_pmu_max_num_pebs(cpuc->pmu);

arch/x86/events/intel/ds.c

1611

reserved = max_pebs_events + x86_pmu_max_num_counters_fixed(cpuc->pmu);

arch/x86/events/intel/ds.c

1761

struct pmu *pmu = event->pmu;

arch/x86/events/intel/ds.c

1773

perf_sched_cb_inc(pmu);

arch/x86/events/intel/ds.c

1775

perf_sched_cb_dec(pmu);

arch/x86/events/intel/ds.c

3197

mask = hybrid(cpuc->pmu, pebs_events_mask) |

arch/x86/events/intel/ds.c

3198

(hybrid(cpuc->pmu, fixed_cntr_mask64) << INTEL_PMC_IDX_FIXED);

arch/x86/events/intel/ds.c

3258

mask = hybrid(cpuc->pmu, arch_pebs_cap).counters & cpuc->pebs_enabled;

arch/x86/events/intel/ds.c

461

hybrid_pmu(event->pmu)->pmu_type == hybrid_big);

arch/x86/events/intel/ds.c

464

val = hybrid_var(event->pmu, pebs_data_source)[dse];

arch/x86/events/intel/ds.c

546

val = hybrid_var(event->pmu, pebs_data_source)[status & PERF_PEBS_DATA_SOURCE_MASK];

arch/x86/events/intel/ds.c

574

struct x86_hybrid_pmu *pmu = hybrid_pmu(event->pmu);

arch/x86/events/intel/ds.c

576

if (pmu->pmu_type == hybrid_small)

arch/x86/events/intel/ds.c

584

struct x86_hybrid_pmu *pmu = hybrid_pmu(event->pmu);

arch/x86/events/intel/ds.c

586

if (pmu->pmu_type == hybrid_tiny)

arch/x86/events/intel/ds.c

632

struct x86_hybrid_pmu *pmu = hybrid_pmu(event->pmu);

arch/x86/events/intel/ds.c

634

if (pmu->pmu_type == hybrid_small)

arch/x86/events/intel/ds.c

650

val = hybrid_var(event->pmu, pebs_data_source)[dse.ld_dse];

arch/x86/events/intel/ds.c

700

val = hybrid_var(event->pmu, pebs_data_source)[dse.st_lat_dse];

arch/x86/events/intel/lbr.c

1589

struct pmu *pmu = x86_get_pmu(smp_processor_id());

arch/x86/events/intel/lbr.c

1635

pmu->task_ctx_cache = create_lbr_kmem_cache(size,

arch/x86/events/intel/lbr.c

1639

if (!pmu->task_ctx_cache) {

arch/x86/events/intel/lbr.c

1644

pmu->task_ctx_cache = create_lbr_kmem_cache(size, 0);

arch/x86/events/intel/lbr.c

615

perf_sched_cb_inc(event->pmu);

arch/x86/events/intel/lbr.c

689

perf_sched_cb_dec(event->pmu);

arch/x86/events/intel/pt.c

1799

if (event->attr.type != pt_pmu.pmu.type)

arch/x86/events/intel/pt.c

1828

return event->pmu == &pt_pmu.pmu;

arch/x86/events/intel/pt.c

1867

pt_pmu.pmu.capabilities = PERF_PMU_CAP_AUX_NO_SG;

arch/x86/events/intel/pt.c

1869

pt_pmu.pmu.capabilities = PERF_PMU_CAP_AUX_PREFER_LARGE;

arch/x86/events/intel/pt.c

1871

pt_pmu.pmu.capabilities |= PERF_PMU_CAP_EXCLUSIVE |

arch/x86/events/intel/pt.c

1874

pt_pmu.pmu.attr_groups = pt_attr_groups;

arch/x86/events/intel/pt.c

1875

pt_pmu.pmu.task_ctx_nr = perf_sw_context;

arch/x86/events/intel/pt.c

1876

pt_pmu.pmu.event_init = pt_event_init;

arch/x86/events/intel/pt.c

1877

pt_pmu.pmu.add = pt_event_add;

arch/x86/events/intel/pt.c

1878

pt_pmu.pmu.del = pt_event_del;

arch/x86/events/intel/pt.c

1879

pt_pmu.pmu.start = pt_event_start;

arch/x86/events/intel/pt.c

1880

pt_pmu.pmu.stop = pt_event_stop;

arch/x86/events/intel/pt.c

1881

pt_pmu.pmu.snapshot_aux = pt_event_snapshot_aux;

arch/x86/events/intel/pt.c

1882

pt_pmu.pmu.read = pt_event_read;

arch/x86/events/intel/pt.c

1883

pt_pmu.pmu.setup_aux = pt_buffer_setup_aux;

arch/x86/events/intel/pt.c

1884

pt_pmu.pmu.free_aux = pt_buffer_free_aux;

arch/x86/events/intel/pt.c

1885

pt_pmu.pmu.addr_filters_sync = pt_event_addr_filters_sync;

arch/x86/events/intel/pt.c

1886

pt_pmu.pmu.addr_filters_validate = pt_event_addr_filters_validate;

arch/x86/events/intel/pt.c

1887

pt_pmu.pmu.nr_addr_filters =

arch/x86/events/intel/pt.c

1890

ret = perf_pmu_register(&pt_pmu.pmu, "intel_pt", -1);

arch/x86/events/intel/pt.h

41

struct pmu pmu;

arch/x86/events/intel/uncore.c

1106

struct intel_uncore_pmu *pmu = NULL;

arch/x86/events/intel/uncore.c

1122

pmu = &type->pmus[UNCORE_PCI_DEV_IDX(data)];

arch/x86/events/intel/uncore.c

1128

return pmu;

arch/x86/events/intel/uncore.c

1140

struct intel_uncore_pmu *pmu,

arch/x86/events/intel/uncore.c

1146

if (WARN_ON_ONCE(pmu->boxes[die] != NULL))

arch/x86/events/intel/uncore.c

1156

box->pmu = pmu;

arch/x86/events/intel/uncore.c

1159

pmu->boxes[die] = box;

arch/x86/events/intel/uncore.c

1160

if (atomic_inc_return(&pmu->activeboxes) > 1)

arch/x86/events/intel/uncore.c

1164

ret = uncore_pmu_register(pmu);

arch/x86/events/intel/uncore.c

1166

pmu->boxes[die] = NULL;

arch/x86/events/intel/uncore.c

1179

struct intel_uncore_pmu *pmu = NULL;

arch/x86/events/intel/uncore.c

1204

pmu = uncore_pci_find_dev_pmu(pdev, pci_drv->id_table);

arch/x86/events/intel/uncore.c

1205

if (pmu == NULL)

arch/x86/events/intel/uncore.c

1212

pmu = &type->pmus[UNCORE_PCI_DEV_IDX(id->driver_data)];

arch/x86/events/intel/uncore.c

1215

ret = uncore_pci_pmu_register(pdev, type, pmu, die);

arch/x86/events/intel/uncore.c

1217

pci_set_drvdata(pdev, pmu->boxes[die]);

arch/x86/events/intel/uncore.c

1227

static void uncore_pci_pmu_unregister(struct intel_uncore_pmu *pmu, int die)

arch/x86/events/intel/uncore.c

1229

struct intel_uncore_box *box = pmu->boxes[die];

arch/x86/events/intel/uncore.c

1231

pmu->boxes[die] = NULL;

arch/x86/events/intel/uncore.c

1232

if (atomic_dec_return(&pmu->activeboxes) == 0)

arch/x86/events/intel/uncore.c

1233

uncore_pmu_unregister(pmu);

arch/x86/events/intel/uncore.c

1241

struct intel_uncore_pmu *pmu;

arch/x86/events/intel/uncore.c

1259

pmu = box->pmu;

arch/x86/events/intel/uncore.c

1263

uncore_pci_pmu_unregister(pmu, die);

arch/x86/events/intel/uncore.c

1272

struct intel_uncore_pmu *pmu;

arch/x86/events/intel/uncore.c

1279

pmu = uncore_pci_find_dev_pmu(pdev, ids);

arch/x86/events/intel/uncore.c

1280

if (!pmu)

arch/x86/events/intel/uncore.c

1286

uncore_pci_pmu_unregister(pmu, die);

arch/x86/events/intel/uncore.c

1306

struct intel_uncore_pmu *pmu;

arch/x86/events/intel/uncore.c

1326

pmu = &type->pmus[UNCORE_PCI_DEV_IDX(ids->driver_data)];

arch/x86/events/intel/uncore.c

1331

if (!uncore_pci_pmu_register(pci_sub_dev, type, pmu,

arch/x86/events/intel/uncore.c

1361

struct intel_uncore_pmu *pmu;

arch/x86/events/intel/uncore.c

1376

pmu = &type->pmus[unit->pmu_idx];

arch/x86/events/intel/uncore.c

1377

uncore_pci_pmu_register(pdev, type, pmu, unit->die);

arch/x86/events/intel/uncore.c

139

struct intel_uncore_box *uncore_pmu_to_box(struct intel_uncore_pmu *pmu, int cpu)

arch/x86/events/intel/uncore.c

1457

struct intel_uncore_pmu *pmu = type->pmus;

arch/x86/events/intel/uncore.c

1462

for (i = 0; i < type->num_boxes; i++, pmu++) {

arch/x86/events/intel/uncore.c

1463

box = pmu->boxes[die];

arch/x86/events/intel/uncore.c

1469

if (uncore_die_has_box(type, die, pmu->pmu_idx)) {

arch/x86/events/intel/uncore.c

147

return dieid < uncore_max_dies() ? pmu->boxes[dieid] : NULL;

arch/x86/events/intel/uncore.c

1471

cpumask_set_cpu(new_cpu, &pmu->cpu_mask);

arch/x86/events/intel/uncore.c

1478

cpumask_clear_cpu(old_cpu, &pmu->cpu_mask);

arch/x86/events/intel/uncore.c

1482

if (!uncore_die_has_box(type, die, pmu->pmu_idx))

arch/x86/events/intel/uncore.c

1485

perf_pmu_migrate_context(&pmu->pmu, old_cpu, new_cpu);

arch/x86/events/intel/uncore.c

1487

cpumask_set_cpu(new_cpu, &pmu->cpu_mask);

arch/x86/events/intel/uncore.c

1501

struct intel_uncore_pmu *pmu;

arch/x86/events/intel/uncore.c

1507

pmu = type->pmus;

arch/x86/events/intel/uncore.c

1508

for (i = 0; i < type->num_boxes; i++, pmu++) {

arch/x86/events/intel/uncore.c

1509

box = pmu->boxes[id];

arch/x86/events/intel/uncore.c

1549

struct intel_uncore_pmu *pmu;

arch/x86/events/intel/uncore.c

1556

pmu = type->pmus;

arch/x86/events/intel/uncore.c

1557

for (i = 0; i < type->num_boxes; i++, pmu++) {

arch/x86/events/intel/uncore.c

1558

if (pmu->boxes[die])

arch/x86/events/intel/uncore.c

1563

box->pmu = pmu;

arch/x86/events/intel/uncore.c

1571

box->pmu->boxes[die] = box;

arch/x86/events/intel/uncore.c

1587

struct intel_uncore_pmu *pmu;

arch/x86/events/intel/uncore.c

1597

pmu = type->pmus;

arch/x86/events/intel/uncore.c

1598

for (i = 0; i < type->num_boxes; i++, pmu++) {

arch/x86/events/intel/uncore.c

1599

box = pmu->boxes[id];

arch/x86/events/intel/uncore.c

381

return &box->pmu->pmu == event->pmu;

arch/x86/events/intel/uncore.c

391

max_count = box->pmu->type->num_counters;

arch/x86/events/intel/uncore.c

392

if (box->pmu->type->fixed_ctl)

arch/x86/events/intel/uncore.c

425

struct intel_uncore_type *type = box->pmu->type;

arch/x86/events/intel/uncore.c

450

if (box->pmu->type->ops->put_constraint)

arch/x86/events/intel/uncore.c

451

box->pmu->type->ops->put_constraint(box, event);

arch/x86/events/intel/uncore.c

689

static int uncore_validate_group(struct intel_uncore_pmu *pmu,

arch/x86/events/intel/uncore.c

700

fake_box = uncore_alloc_box(pmu->type, NUMA_NO_NODE);

arch/x86/events/intel/uncore.c

704

fake_box->pmu = pmu;

arch/x86/events/intel/uncore.c

730

struct intel_uncore_pmu *pmu;

arch/x86/events/intel/uncore.c

735

if (event->attr.type != event->pmu->type)

arch/x86/events/intel/uncore.c

738

pmu = uncore_event_to_pmu(event);

arch/x86/events/intel/uncore.c

740

if (!pmu->registered)

arch/x86/events/intel/uncore.c

753

box = uncore_pmu_to_box(pmu, event->cpu);

arch/x86/events/intel/uncore.c

768

if (!pmu->type->fixed_ctl)

arch/x86/events/intel/uncore.c

774

if (pmu->type->single_fixed && pmu->pmu_idx > 0)

arch/x86/events/intel/uncore.c

793

(pmu->type->event_mask | ((u64)pmu->type->event_mask_ext << 32));

arch/x86/events/intel/uncore.c

794

if (pmu->type->ops->hw_config) {

arch/x86/events/intel/uncore.c

795

ret = pmu->type->ops->hw_config(box, event);

arch/x86/events/intel/uncore.c

802

ret = uncore_validate_group(pmu, event);

arch/x86/events/intel/uncore.c

809

static void uncore_pmu_enable(struct pmu *pmu)

arch/x86/events/intel/uncore.c

814

uncore_pmu = container_of(pmu, struct intel_uncore_pmu, pmu);

arch/x86/events/intel/uncore.c

824

static void uncore_pmu_disable(struct pmu *pmu)

arch/x86/events/intel/uncore.c

829

uncore_pmu = container_of(pmu, struct intel_uncore_pmu, pmu);

arch/x86/events/intel/uncore.c

842

struct intel_uncore_pmu *pmu = container_of(dev_get_drvdata(dev), struct intel_uncore_pmu, pmu);

arch/x86/events/intel/uncore.c

844

return cpumap_print_to_pagebuf(true, buf, &pmu->cpu_mask);

arch/x86/events/intel/uncore.c

859

struct intel_uncore_pmu *pmu)

arch/x86/events/intel/uncore.c

862

return intel_uncore_find_discovery_unit_id(type->boxes, -1, pmu->pmu_idx);

arch/x86/events/intel/uncore.c

864

return pmu->pmu_idx;

arch/x86/events/intel/uncore.c

867

void uncore_get_alias_name(char *pmu_name, struct intel_uncore_pmu *pmu)

arch/x86/events/intel/uncore.c

869

struct intel_uncore_type *type = pmu->type;

arch/x86/events/intel/uncore.c

875

type->type_id, uncore_get_box_id(type, pmu));

arch/x86/events/intel/uncore.c

879

static void uncore_get_pmu_name(struct intel_uncore_pmu *pmu)

arch/x86/events/intel/uncore.c

881

struct intel_uncore_type *type = pmu->type;

arch/x86/events/intel/uncore.c

888

uncore_get_alias_name(pmu->name, pmu);

arch/x86/events/intel/uncore.c

894

sprintf(pmu->name, "uncore_%s", type->name);

arch/x86/events/intel/uncore.c

896

sprintf(pmu->name, "uncore");

arch/x86/events/intel/uncore.c

901

sprintf(pmu->name, "uncore_%s_%d", type->name,

arch/x86/events/intel/uncore.c

902

uncore_get_box_id(type, pmu));

arch/x86/events/intel/uncore.c

906

static int uncore_pmu_register(struct intel_uncore_pmu *pmu)

arch/x86/events/intel/uncore.c

910

if (!pmu->type->pmu) {

arch/x86/events/intel/uncore.c

911

pmu->pmu = (struct pmu) {

arch/x86/events/intel/uncore.c

912

.attr_groups = pmu->type->attr_groups,

arch/x86/events/intel/uncore.c

924

.attr_update = pmu->type->attr_update,

arch/x86/events/intel/uncore.c

927

pmu->pmu = *pmu->type->pmu;

arch/x86/events/intel/uncore.c

928

pmu->pmu.attr_groups = pmu->type->attr_groups;

arch/x86/events/intel/uncore.c

929

pmu->pmu.attr_update = pmu->type->attr_update;

arch/x86/events/intel/uncore.c

932

uncore_get_pmu_name(pmu);

arch/x86/events/intel/uncore.c

934

ret = perf_pmu_register(&pmu->pmu, pmu->name, -1);

arch/x86/events/intel/uncore.c

936

pmu->registered = true;

arch/x86/events/intel/uncore.c

940

static void uncore_pmu_unregister(struct intel_uncore_pmu *pmu)

arch/x86/events/intel/uncore.c

942

if (!pmu->registered)

arch/x86/events/intel/uncore.c

944

perf_pmu_unregister(&pmu->pmu);

arch/x86/events/intel/uncore.c

945

pmu->registered = false;

arch/x86/events/intel/uncore.c

948

static void uncore_free_boxes(struct intel_uncore_pmu *pmu)

arch/x86/events/intel/uncore.c

953

kfree(pmu->boxes[die]);

arch/x86/events/intel/uncore.c

954

kfree(pmu->boxes);

arch/x86/events/intel/uncore.c

959

struct intel_uncore_pmu *pmu = type->pmus;

arch/x86/events/intel/uncore.c

968

if (pmu) {

arch/x86/events/intel/uncore.c

969

for (i = 0; i < type->num_boxes; i++, pmu++) {

arch/x86/events/intel/uncore.c

970

uncore_pmu_unregister(pmu);

arch/x86/events/intel/uncore.c

971

uncore_free_boxes(pmu);

arch/x86/events/intel/uncore.h

107

struct pmu *pmu; /* for custom pmu ops */

arch/x86/events/intel/uncore.h

146

struct pmu pmu;

arch/x86/events/intel/uncore.h

175

struct intel_uncore_pmu *pmu;

arch/x86/events/intel/uncore.h

244

return container_of(dev_get_drvdata(dev), struct intel_uncore_pmu, pmu);

arch/x86/events/intel/uncore.h

284

if (offset < box->pmu->type->mmio_map_size)

arch/x86/events/intel/uncore.h

288

offset, box->pmu->type->name);

arch/x86/events/intel/uncore.h

296

return box->pmu->type->box_ctl +

arch/x86/events/intel/uncore.h

297

box->pmu->type->mmio_offset * box->pmu->pmu_idx;

arch/x86/events/intel/uncore.h

302

return box->pmu->type->box_ctl;

arch/x86/events/intel/uncore.h

307

return box->pmu->type->fixed_ctl;

arch/x86/events/intel/uncore.h

312

return box->pmu->type->fixed_ctr;

arch/x86/events/intel/uncore.h

319

return idx * 8 + box->pmu->type->event_ctl;

arch/x86/events/intel/uncore.h

321

return idx * 4 + box->pmu->type->event_ctl;

arch/x86/events/intel/uncore.h

327

return idx * 8 + box->pmu->type->perf_ctr;

arch/x86/events/intel/uncore.h

332

struct intel_uncore_pmu *pmu = box->pmu;

arch/x86/events/intel/uncore.h

333

return pmu->type->msr_offsets ?

arch/x86/events/intel/uncore.h

334

pmu->type->msr_offsets[pmu->pmu_idx] :

arch/x86/events/intel/uncore.h

335

pmu->type->msr_offset * pmu->pmu_idx;

arch/x86/events/intel/uncore.h

340

if (!box->pmu->type->box_ctl)

arch/x86/events/intel/uncore.h

342

return box->pmu->type->box_ctl + uncore_msr_box_offset(box);

arch/x86/events/intel/uncore.h

347

if (!box->pmu->type->fixed_ctl)

arch/x86/events/intel/uncore.h

349

return box->pmu->type->fixed_ctl + uncore_msr_box_offset(box);

arch/x86/events/intel/uncore.h

354

return box->pmu->type->fixed_ctr + uncore_msr_box_offset(box);

arch/x86/events/intel/uncore.h

404

struct intel_uncore_pmu *pmu = box->pmu;

arch/x86/events/intel/uncore.h

406

return pmu->type->freerunning[type].counter_base +

arch/x86/events/intel/uncore.h

407

pmu->type->freerunning[type].counter_offset * idx +

arch/x86/events/intel/uncore.h

408

(pmu->type->freerunning[type].box_offsets ?

arch/x86/events/intel/uncore.h

409

pmu->type->freerunning[type].box_offsets[pmu->pmu_idx] :

arch/x86/events/intel/uncore.h

410

pmu->type->freerunning[type].box_offset * pmu->pmu_idx);

arch/x86/events/intel/uncore.h

418

(box->pmu->type->pair_ctr_ctl ? 2 * idx : idx);

arch/x86/events/intel/uncore.h

420

return box->pmu->type->event_ctl +

arch/x86/events/intel/uncore.h

421

(box->pmu->type->pair_ctr_ctl ? 2 * idx : idx) +

arch/x86/events/intel/uncore.h

431

(box->pmu->type->pair_ctr_ctl ? 2 * idx : idx);

arch/x86/events/intel/uncore.h

433

return box->pmu->type->perf_ctr +

arch/x86/events/intel/uncore.h

434

(box->pmu->type->pair_ctr_ctl ? 2 * idx : idx) +

arch/x86/events/intel/uncore.h

477

return box->pmu->type->perf_ctr_bits;

arch/x86/events/intel/uncore.h

482

return box->pmu->type->fixed_ctr_bits;

arch/x86/events/intel/uncore.h

491

return box->pmu->type->freerunning[type].bits;

arch/x86/events/intel/uncore.h

499

return box->pmu->type->freerunning[type].num_counters;

arch/x86/events/intel/uncore.h

505

return box->pmu->type->num_freerunning_types;

arch/x86/events/intel/uncore.h

520

return box->pmu->type->num_counters;

arch/x86/events/intel/uncore.h

544

box->pmu->type->ops->disable_event(box, event);

arch/x86/events/intel/uncore.h

550

box->pmu->type->ops->enable_event(box, event);

arch/x86/events/intel/uncore.h

556

return box->pmu->type->ops->read_counter(box, event);

arch/x86/events/intel/uncore.h

562

if (box->pmu->type->ops->init_box)

arch/x86/events/intel/uncore.h

563

box->pmu->type->ops->init_box(box);

arch/x86/events/intel/uncore.h

570

if (box->pmu->type->ops->exit_box)

arch/x86/events/intel/uncore.h

571

box->pmu->type->ops->exit_box(box);

arch/x86/events/intel/uncore.h

582

return container_of(event->pmu, struct intel_uncore_pmu, pmu);

arch/x86/events/intel/uncore.h

590

struct intel_uncore_box *uncore_pmu_to_box(struct intel_uncore_pmu *pmu, int cpu);

arch/x86/events/intel/uncore.h

607

void uncore_get_alias_name(char *pmu_name, struct intel_uncore_pmu *pmu);

arch/x86/events/intel/uncore_discovery.c

478

unit = intel_uncore_find_discovery_unit(box->pmu->type->boxes,

arch/x86/events/intel/uncore_discovery.c

479

-1, box->pmu->pmu_idx);

arch/x86/events/intel/uncore_discovery.c

532

if (!box->pmu->type->boxes)

arch/x86/events/intel/uncore_discovery.c

552

hwc->config_base = box_ctl + box->pmu->type->event_ctl + hwc->idx;

arch/x86/events/intel/uncore_discovery.c

553

hwc->event_base = box_ctl + box->pmu->type->perf_ctr + hwc->idx;

arch/x86/events/intel/uncore_discovery.c

633

struct intel_uncore_type *type = box->pmu->type;

arch/x86/events/intel/uncore_discovery.c

636

unit = intel_uncore_find_discovery_unit(type->boxes, box->dieid, box->pmu->pmu_idx);

arch/x86/events/intel/uncore_discovery.c

639

type->type_id, box->pmu->pmu_idx);

arch/x86/events/intel/uncore_nhmex.c

1121

port = idx / 6 + box->pmu->pmu_idx * 4;

arch/x86/events/intel/uncore_nhmex.c

253

else if (box->pmu->type->event_mask & NHMEX_PMON_CTL_EN_BIT0)

arch/x86/events/intel/uncore_nhmex.c

369

if (box->pmu->pmu_idx == 0)

arch/x86/events/intel/uncore_nhmex.c

454

if (box->pmu->pmu_idx == 0)

arch/x86/events/intel/uncore_nhmex.c

769

struct intel_uncore_type *type = box->pmu->type;

arch/x86/events/intel/uncore_nhmex.c

786

msr = er->msr + type->msr_offset * box->pmu->pmu_idx;

arch/x86/events/intel/uncore_nhmex.c

813

if (box->pmu->pmu_idx == 0)

arch/x86/events/intel/uncore_snb.c

1062

static struct pmu snb_uncore_imc_pmu = {

arch/x86/events/intel/uncore_snb.c

1094

.pmu = &snb_uncore_imc_pmu,

arch/x86/events/intel/uncore_snb.c

1548

struct intel_uncore_pmu *pmu = box->pmu;

arch/x86/events/intel/uncore_snb.c

1549

struct intel_uncore_type *type = pmu->type;

arch/x86/events/intel/uncore_snb.c

1566

addr = (resource_size_t)(bar + step * pmu->pmu_idx);

arch/x86/events/intel/uncore_snb.c

1663

if (box->io_addr && (box->pmu->pmu_idx == 1))

arch/x86/events/intel/uncore_snb.c

300

if (box->pmu->pmu_idx == 0) {

arch/x86/events/intel/uncore_snb.c

314

if (box->pmu->pmu_idx == 0)

arch/x86/events/intel/uncore_snb.c

399

if (box->pmu->pmu_idx == 0) {

arch/x86/events/intel/uncore_snb.c

405

if (box->pmu->pmu_idx == 7)

arch/x86/events/intel/uncore_snb.c

417

if (box->pmu->pmu_idx == 0)

arch/x86/events/intel/uncore_snb.c

552

if (box->pmu->pmu_idx == 0)

arch/x86/events/intel/uncore_snb.c

568

if (box->pmu->pmu_idx == 0)

arch/x86/events/intel/uncore_snb.c

579

if (box->pmu->pmu_idx == 0)

arch/x86/events/intel/uncore_snb.c

585

if (box->pmu->pmu_idx == 0)

arch/x86/events/intel/uncore_snb.c

785

if (box->pmu->pmu_idx == 0)

arch/x86/events/intel/uncore_snb.c

886

struct intel_uncore_type *type = box->pmu->type;

arch/x86/events/intel/uncore_snb.c

927

struct intel_uncore_pmu *pmu;

arch/x86/events/intel/uncore_snb.c

933

if (event->attr.type != event->pmu->type)

arch/x86/events/intel/uncore_snb.c

936

pmu = uncore_event_to_pmu(event);

arch/x86/events/intel/uncore_snb.c

938

if (!pmu->registered)

arch/x86/events/intel/uncore_snb.c

960

box = uncore_pmu_to_box(pmu, event->cpu);

arch/x86/events/intel/uncore_snbep.c

1016

SNBEP_CBO_MSR_OFFSET * box->pmu->pmu_idx;

arch/x86/events/intel/uncore_snbep.c

1198

int idx = box->pmu->pmu_idx + SNBEP_PCI_QPI_PORT0_FILTER;

arch/x86/events/intel/uncore_snbep.c

1757

SNBEP_CBO_MSR_OFFSET * box->pmu->pmu_idx;

arch/x86/events/intel/uncore_snbep.c

2185

KNL_CHA_MSR_OFFSET * box->pmu->pmu_idx;

arch/x86/events/intel/uncore_snbep.c

2740

HSWEP_CBO_MSR_OFFSET * box->pmu->pmu_idx;

arch/x86/events/intel/uncore_snbep.c

3581

HSWEP_CBO_MSR_OFFSET * box->pmu->pmu_idx;

arch/x86/events/intel/uncore_snbep.c

3659

static struct intel_uncore_topology *pmu_topology(struct intel_uncore_pmu *pmu, int die)

arch/x86/events/intel/uncore_snbep.c

3663

for (idx = 0; idx < pmu->type->num_boxes; idx++) {

arch/x86/events/intel/uncore_snbep.c

3664

if (pmu->type->topology[die][idx].pmu_idx == pmu->pmu_idx)

arch/x86/events/intel/uncore_snbep.c

3665

return &pmu->type->topology[die][idx];

arch/x86/events/intel/uncore_snbep.c

3675

struct intel_uncore_pmu *pmu = dev_to_uncore_pmu(kobj_to_dev(kobj));

arch/x86/events/intel/uncore_snbep.c

3676

struct intel_uncore_topology *pmut = pmu_topology(pmu, die);

arch/x86/events/intel/uncore_snbep.c

3678

return (pmut && !pmut->iio->pci_bus_no && pmu->pmu_idx != zero_bus_pmu) ? 0 : attr->mode;

arch/x86/events/intel/uncore_snbep.c

3691

struct intel_uncore_pmu *pmu = dev_to_uncore_pmu(dev);

arch/x86/events/intel/uncore_snbep.c

3694

struct intel_uncore_topology *pmut = pmu_topology(pmu, die);

arch/x86/events/intel/uncore_snbep.c

4203

struct intel_uncore_pmu *pmu = dev_to_uncore_pmu(kobj_to_dev(kobj));

arch/x86/events/intel/uncore_snbep.c

4205

return pmu->type->topology[die][pmu->pmu_idx].upi->enabled ? attr->mode : 0;

arch/x86/events/intel/uncore_snbep.c

4211

struct intel_uncore_pmu *pmu = dev_to_uncore_pmu(dev);

arch/x86/events/intel/uncore_snbep.c

4214

struct uncore_upi_topology *upi = pmu->type->topology[die][pmu->pmu_idx].upi;

arch/x86/events/intel/uncore_snbep.c

4565

box->pmu->type->msr_offset * box->pmu->pmu_idx;

arch/x86/events/intel/uncore_snbep.c

5005

struct intel_uncore_type *type = box->pmu->type;

arch/x86/events/intel/uncore_snbep.c

5208

icx_cha_msr_offsets[box->pmu->pmu_idx];

arch/x86/events/intel/uncore_snbep.c

5660

unsigned int box_ctl = box->pmu->type->box_ctl +

arch/x86/events/intel/uncore_snbep.c

5661

box->pmu->type->mmio_offset * (box->pmu->pmu_idx % ICX_NUMBER_IMC_CHN);

arch/x86/events/intel/uncore_snbep.c

5662

int mem_offset = (box->pmu->pmu_idx / ICX_NUMBER_IMC_CHN) * ICX_IMC_MEM_STRIDE +

arch/x86/events/intel/uncore_snbep.c

5724

int mem_offset = box->pmu->pmu_idx * ICX_IMC_MEM_STRIDE +

arch/x86/events/intel/uncore_snbep.c

5793

struct intel_uncore_type *type = box->pmu->type;

arch/x86/events/intel/uncore_snbep.c

5794

int id = intel_uncore_find_discovery_unit_id(type->boxes, -1, box->pmu->pmu_idx);

arch/x86/events/intel/uncore_snbep.c

5837

struct intel_uncore_pmu *pmu = dev_to_uncore_pmu(dev);

arch/x86/events/intel/uncore_snbep.c

5840

uncore_get_alias_name(pmu_name, pmu);

arch/x86/events/intel/uncore_snbep.c

6210

int mem_offset = box->pmu->pmu_idx * ICX_IMC_MEM_STRIDE + SNR_IMC_MMIO_MEM0_OFFSET;

arch/x86/events/intel/uncore_snbep.c

6899

struct intel_uncore_type *type = box->pmu->type;

arch/x86/events/intel/uncore_snbep.c

6902

if (box->pmu->pmu_idx >= type->num_boxes)

arch/x86/events/intel/uncore_snbep.c

6906

mmio_base += dmr_iio_freerunning_box_offsets[box->pmu->pmu_idx];

arch/x86/events/msr.c

210

if (event->attr.type != event->pmu->type)

arch/x86/events/msr.c

293

static struct pmu pmu_msr = {

arch/x86/events/perf_event.h

1035

void (*filter)(struct pmu *pmu, int cpu, bool *ret);

arch/x86/events/perf_event.h

1156

struct pmu *x86_get_pmu(unsigned int cpu);

arch/x86/events/perf_event.h

1237

bool check_hw_exists(struct pmu *pmu, unsigned long *cntr_mask,

arch/x86/events/perf_event.h

1248

int x86_pmu_max_precise(struct pmu *pmu);

arch/x86/events/perf_event.h

1309

void x86_pmu_show_pmu_cap(struct pmu *pmu);

arch/x86/events/perf_event.h

1311

static inline int x86_pmu_num_counters(struct pmu *pmu)

arch/x86/events/perf_event.h

1313

return hweight64(hybrid(pmu, cntr_mask64));

arch/x86/events/perf_event.h

1316

static inline int x86_pmu_max_num_counters(struct pmu *pmu)

arch/x86/events/perf_event.h

1318

return fls64(hybrid(pmu, cntr_mask64));

arch/x86/events/perf_event.h

1321

static inline int x86_pmu_num_counters_fixed(struct pmu *pmu)

arch/x86/events/perf_event.h

1323

return hweight64(hybrid(pmu, fixed_cntr_mask64));

arch/x86/events/perf_event.h

1326

static inline int x86_pmu_max_num_counters_fixed(struct pmu *pmu)

arch/x86/events/perf_event.h

1328

return fls64(hybrid(pmu, fixed_cntr_mask64));

arch/x86/events/perf_event.h

1333

return event->attr.config & hybrid(event->pmu, config_mask);

arch/x86/events/perf_event.h

1336

static inline bool x86_pmu_has_rdpmc_user_disable(struct pmu *pmu)

arch/x86/events/perf_event.h

1338

return !!(hybrid(pmu, config_mask) &

arch/x86/events/perf_event.h

1450

static inline bool fixed_counter_disabled(int i, struct pmu *pmu)

arch/x86/events/perf_event.h

1452

u64 intel_ctrl = hybrid(pmu, intel_ctrl);

arch/x86/events/perf_event.h

1503

perf_sched_cb_inc(event->pmu);

arch/x86/events/perf_event.h

1518

perf_sched_cb_dec(event->pmu);

arch/x86/events/perf_event.h

1850

static inline int intel_pmu_max_num_pebs(struct pmu *pmu)

arch/x86/events/perf_event.h

1853

return fls((u32)hybrid(pmu, pebs_events_mask));

arch/x86/events/perf_event.h

386

struct pmu *pmu;

arch/x86/events/perf_event.h

732

struct pmu pmu;

arch/x86/events/perf_event.h

780

static __always_inline struct x86_hybrid_pmu *hybrid_pmu(struct pmu *pmu)

arch/x86/events/perf_event.h

782

return container_of(pmu, struct x86_hybrid_pmu, pmu);

arch/x86/events/rapl.c

135

struct pmu *pmu;

arch/x86/events/rapl.c

141

struct pmu pmu;

arch/x86/events/rapl.c

204

if (event->pmu->scope == PERF_PMU_SCOPE_CORE)

arch/x86/events/rapl.c

247

static void rapl_start_hrtimer(struct rapl_pmu *pmu)

arch/x86/events/rapl.c

249

hrtimer_start(&pmu->hrtimer, pmu->timer_interval,

arch/x86/events/rapl.c

374

if (event->attr.type != event->pmu->type)

arch/x86/events/rapl.c

388

rapl_pmus = container_of(event->pmu, struct rapl_pmus, pmu);

arch/x86/events/rapl.c

391

rapl_pmus_scope = rapl_pmus->pmu.scope;

arch/x86/events/rapl.c

713

rapl_pmu->pmu = &rapl_pmus->pmu;

arch/x86/events/rapl.c

752

rapl_pmus->pmu.attr_groups = rapl_attr_groups;

arch/x86/events/rapl.c

753

rapl_pmus->pmu.attr_update = rapl_attr_update;

arch/x86/events/rapl.c

754

rapl_pmus->pmu.task_ctx_nr = perf_invalid_context;

arch/x86/events/rapl.c

755

rapl_pmus->pmu.event_init = rapl_pmu_event_init;

arch/x86/events/rapl.c

756

rapl_pmus->pmu.add = rapl_pmu_event_add;

arch/x86/events/rapl.c

757

rapl_pmus->pmu.del = rapl_pmu_event_del;

arch/x86/events/rapl.c

758

rapl_pmus->pmu.start = rapl_pmu_event_start;

arch/x86/events/rapl.c

759

rapl_pmus->pmu.stop = rapl_pmu_event_stop;

arch/x86/events/rapl.c

760

rapl_pmus->pmu.read = rapl_pmu_event_read;

arch/x86/events/rapl.c

761

rapl_pmus->pmu.scope = rapl_pmu_scope;

arch/x86/events/rapl.c

762

rapl_pmus->pmu.module = THIS_MODULE;

arch/x86/events/rapl.c

763

rapl_pmus->pmu.capabilities = PERF_PMU_CAP_NO_EXCLUDE;

arch/x86/events/rapl.c

921

ret = perf_pmu_register(&rapl_pmus_pkg->pmu, "power", -1);

arch/x86/events/rapl.c

938

ret = perf_pmu_register(&rapl_pmus_core->pmu, "power_core", -1);

arch/x86/events/rapl.c

959

perf_pmu_unregister(&rapl_pmus_core->pmu);

arch/x86/events/rapl.c

962

perf_pmu_unregister(&rapl_pmus_pkg->pmu);

arch/x86/include/asm/hw_breakpoint.h

51

struct pmu;

arch/x86/include/asm/hw_breakpoint.h

75

extern struct pmu perf_ops_bp;

arch/x86/include/asm/kvm_host.h

1014

struct kvm_pmu pmu;

arch/x86/kvm/pmu.c

1000

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/pmu.c

1002

memset(pmu, 0, sizeof(*pmu));

arch/x86/kvm/pmu.c

1009

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/pmu.c

1014

pmu->need_cleanup = false;

arch/x86/kvm/pmu.c

1016

bitmap_andnot(bitmask, pmu->all_valid_pmc_idx,

arch/x86/kvm/pmu.c

1017

pmu->pmc_in_use, X86_PMC_IDX_MAX);

arch/x86/kvm/pmu.c

1019

kvm_for_each_pmc(pmu, pmc, i, bitmask) {

arch/x86/kvm/pmu.c

1026

bitmap_zero(pmu->pmc_in_use, X86_PMC_IDX_MAX);

arch/x86/kvm/pmu.c

1106

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/pmu.c

1110

BUILD_BUG_ON(sizeof(pmu->global_ctrl) * BITS_PER_BYTE != X86_PMC_IDX_MAX);

arch/x86/kvm/pmu.c

1115

if (!kvm_pmu_has_perf_global_ctrl(pmu))

arch/x86/kvm/pmu.c

1118

(unsigned long *)&pmu->global_ctrl, X86_PMC_IDX_MAX))

arch/x86/kvm/pmu.c

1122

kvm_for_each_pmc(pmu, pmc, i, bitmap) {

arch/x86/kvm/pmu.c

1303

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/pmu.c

1312

for (i = 0; i < pmu->nr_arch_gp_counters; i++) {

arch/x86/kvm/pmu.c

1313

pmc = &pmu->gp_counters[i];

arch/x86/kvm/pmu.c

1319

for (i = 0; i < pmu->nr_arch_fixed_counters; i++) {

arch/x86/kvm/pmu.c

1320

pmc = &pmu->fixed_counters[i];

arch/x86/kvm/pmu.c

1361

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/pmu.c

1369

for (i = 0; i < pmu->nr_arch_gp_counters; i++) {

arch/x86/kvm/pmu.c

1370

pmc = &pmu->gp_counters[i];

arch/x86/kvm/pmu.c

1379

for (i = 0; i < pmu->nr_arch_fixed_counters; i++) {

arch/x86/kvm/pmu.c

1380

pmc = &pmu->fixed_counters[i];

arch/x86/kvm/pmu.c

175

struct kvm_pmu *pmu = pmc_to_pmu(pmc);

arch/x86/kvm/pmu.c

190

(unsigned long *)&pmu->global_status);

arch/x86/kvm/pmu.c

193

__set_bit(pmc->idx, (unsigned long *)&pmu->global_status);

arch/x86/kvm/pmu.c

254

struct kvm_pmu *pmu = pmc_to_pmu(pmc);

arch/x86/kvm/pmu.c

266

bool pebs = test_bit(pmc->idx, (unsigned long *)&pmu->pebs_enable);

arch/x86/kvm/pmu.c

526

struct kvm_pmu *pmu = pmc_to_pmu(pmc);

arch/x86/kvm/pmu.c

536

pmu->fixed_ctr_ctrl_hw &= ~mask;

arch/x86/kvm/pmu.c

538

pmu->fixed_ctr_ctrl_hw |= pmu->fixed_ctr_ctrl & mask;

arch/x86/kvm/pmu.c

544

struct kvm_pmu *pmu = pmc_to_pmu(pmc);

arch/x86/kvm/pmu.c

550

if (kvm_vcpu_has_mediated_pmu(pmu_to_vcpu(pmu))) {

arch/x86/kvm/pmu.c

568

fixed_ctr_ctrl = fixed_ctrl_field(pmu->fixed_ctr_ctrl,

arch/x86/kvm/pmu.c

587

(eventsel & pmu->raw_event_mask),

arch/x86/kvm/pmu.c

612

void kvm_pmu_recalc_pmc_emulation(struct kvm_pmu *pmu, struct kvm_pmc *pmc)

arch/x86/kvm/pmu.c

614

bitmap_clear(pmu->pmc_counting_instructions, pmc->idx, 1);

arch/x86/kvm/pmu.c

615

bitmap_clear(pmu->pmc_counting_branches, pmc->idx, 1);

arch/x86/kvm/pmu.c

627

bitmap_set(pmu->pmc_counting_instructions, pmc->idx, 1);

arch/x86/kvm/pmu.c

630

bitmap_set(pmu->pmc_counting_branches, pmc->idx, 1);

arch/x86/kvm/pmu.c

637

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/pmu.c

641

bitmap_copy(bitmap, pmu->reprogram_pmi, X86_PMC_IDX_MAX);

arch/x86/kvm/pmu.c

649

atomic64_andnot(*(s64 *)bitmap, &pmu->__reprogram_pmi);

arch/x86/kvm/pmu.c

651

kvm_for_each_pmc(pmu, pmc, bit, bitmap) {

arch/x86/kvm/pmu.c

659

set_bit(pmc->idx, pmu->reprogram_pmi);

arch/x86/kvm/pmu.c

667

if (unlikely(pmu->need_cleanup))

arch/x86/kvm/pmu.c

670

kvm_for_each_pmc(pmu, pmc, bit, bitmap)

arch/x86/kvm/pmu.c

671

kvm_pmu_recalc_pmc_emulation(pmu, pmc);

arch/x86/kvm/pmu.c

726

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/pmu.c

730

if (!pmu->version)

arch/x86/kvm/pmu.c

751

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/pmu.c

761

return pmu->nr_arch_gp_counters != kvm_host_pmu.num_counters_gp ||

arch/x86/kvm/pmu.c

762

pmu->nr_arch_fixed_counters != kvm_host_pmu.num_counters_fixed;

arch/x86/kvm/pmu.c

774

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/pmu.c

784

pmu->counter_bitmask[KVM_PMC_GP] != (BIT_ULL(kvm_host_pmu.bit_width_gp) - 1) ||

arch/x86/kvm/pmu.c

785

pmu->counter_bitmask[KVM_PMC_FIXED] != (BIT_ULL(kvm_host_pmu.bit_width_fixed) - 1);

arch/x86/kvm/pmu.c

813

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/pmu.c

817

__set_bit(pmc->idx, pmu->pmc_in_use);

arch/x86/kvm/pmu.c

822

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/pmu.c

828

msr_info->data = pmu->global_status;

arch/x86/kvm/pmu.c

832

msr_info->data = pmu->global_ctrl;

arch/x86/kvm/pmu.c

848

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/pmu.c

867

if (data & pmu->global_status_rsvd)

arch/x86/kvm/pmu.c

870

pmu->global_status = data;

arch/x86/kvm/pmu.c

873

data &= ~pmu->global_ctrl_rsvd;

arch/x86/kvm/pmu.c

876

if (!kvm_valid_perf_global_ctrl(pmu, data))

arch/x86/kvm/pmu.c

879

if (pmu->global_ctrl != data) {

arch/x86/kvm/pmu.c

880

diff = pmu->global_ctrl ^ data;

arch/x86/kvm/pmu.c

881

pmu->global_ctrl = data;

arch/x86/kvm/pmu.c

882

reprogram_counters(pmu, diff);

arch/x86/kvm/pmu.c

896

if (data & pmu->global_status_rsvd)

arch/x86/kvm/pmu.c

901

pmu->global_status &= ~data;

arch/x86/kvm/pmu.c

905

pmu->global_status |= data & ~pmu->global_status_rsvd;

arch/x86/kvm/pmu.c

917

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/pmu.c

921

pmu->need_cleanup = false;

arch/x86/kvm/pmu.c

923

bitmap_zero(pmu->reprogram_pmi, X86_PMC_IDX_MAX);

arch/x86/kvm/pmu.c

925

kvm_for_each_pmc(pmu, pmc, i, pmu->all_valid_pmc_idx) {

arch/x86/kvm/pmu.c

936

pmu->fixed_ctr_ctrl = pmu->fixed_ctr_ctrl_hw = 0;

arch/x86/kvm/pmu.c

937

pmu->global_ctrl = pmu->global_status = 0;

arch/x86/kvm/pmu.c

949

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/pmu.c

960

pmu->version = 0;

arch/x86/kvm/pmu.c

961

pmu->nr_arch_gp_counters = 0;

arch/x86/kvm/pmu.c

962

pmu->nr_arch_fixed_counters = 0;

arch/x86/kvm/pmu.c

963

pmu->counter_bitmask[KVM_PMC_GP] = 0;

arch/x86/kvm/pmu.c

964

pmu->counter_bitmask[KVM_PMC_FIXED] = 0;

arch/x86/kvm/pmu.c

965

pmu->reserved_bits = 0xffffffff00200000ull;

arch/x86/kvm/pmu.c

966

pmu->raw_event_mask = X86_RAW_EVENT_MASK;

arch/x86/kvm/pmu.c

967

pmu->global_ctrl_rsvd = ~0ull;

arch/x86/kvm/pmu.c

968

pmu->global_status_rsvd = ~0ull;

arch/x86/kvm/pmu.c

969

pmu->fixed_ctr_ctrl_rsvd = ~0ull;

arch/x86/kvm/pmu.c

970

pmu->pebs_enable_rsvd = ~0ull;

arch/x86/kvm/pmu.c

971

pmu->pebs_data_cfg_rsvd = ~0ull;

arch/x86/kvm/pmu.c

972

bitmap_zero(pmu->all_valid_pmc_idx, X86_PMC_IDX_MAX);

arch/x86/kvm/pmu.c

986

if (pmu->nr_arch_gp_counters &&

arch/x86/kvm/pmu.c

987

(kvm_pmu_has_perf_global_ctrl(pmu) || kvm_vcpu_has_mediated_pmu(vcpu)))

arch/x86/kvm/pmu.c

988

pmu->global_ctrl = GENMASK_ULL(pmu->nr_arch_gp_counters - 1, 0);

arch/x86/kvm/pmu.c

991

kvm_pmu_call(write_global_ctrl)(pmu->global_ctrl);

arch/x86/kvm/pmu.c

993

bitmap_set(pmu->all_valid_pmc_idx, 0, pmu->nr_arch_gp_counters);

arch/x86/kvm/pmu.c

994

bitmap_set(pmu->all_valid_pmc_idx, KVM_FIXED_PMC_BASE_IDX,

arch/x86/kvm/pmu.c

995

pmu->nr_arch_fixed_counters);

arch/x86/kvm/pmu.h

10

#define pmu_to_vcpu(pmu) (container_of((pmu), struct kvm_vcpu, arch.pmu))

arch/x86/kvm/pmu.h

100

return &pmu->fixed_counters[idx];

arch/x86/kvm/pmu.h

105

#define kvm_for_each_pmc(pmu, pmc, i, bitmap) \

arch/x86/kvm/pmu.h

107

if (!(pmc = kvm_pmc_idx_to_pmc(pmu, i))) \

arch/x86/kvm/pmu.h

11

#define pmc_to_pmu(pmc) (&(pmc)->vcpu->arch.pmu)

arch/x86/kvm/pmu.h

113

struct kvm_pmu *pmu = pmc_to_pmu(pmc);

arch/x86/kvm/pmu.h

115

return pmu->counter_bitmask[pmc->type];

arch/x86/kvm/pmu.h

146

static inline bool kvm_valid_perf_global_ctrl(struct kvm_pmu *pmu,

arch/x86/kvm/pmu.h

149

return !(pmu->global_ctrl_rsvd & data);

arch/x86/kvm/pmu.h

156

static inline struct kvm_pmc *get_gp_pmc(struct kvm_pmu *pmu, u32 msr,

arch/x86/kvm/pmu.h

159

if (msr >= base && msr < base + pmu->nr_arch_gp_counters) {

arch/x86/kvm/pmu.h

161

pmu->nr_arch_gp_counters);

arch/x86/kvm/pmu.h

163

return &pmu->gp_counters[index];

arch/x86/kvm/pmu.h

170

static inline struct kvm_pmc *get_fixed_pmc(struct kvm_pmu *pmu, u32 msr)

arch/x86/kvm/pmu.h

174

if (msr >= base && msr < base + pmu->nr_arch_fixed_counters) {

arch/x86/kvm/pmu.h

176

pmu->nr_arch_fixed_counters);

arch/x86/kvm/pmu.h

178

return &pmu->fixed_counters[index];

arch/x86/kvm/pmu.h

186

struct kvm_pmu *pmu = pmc_to_pmu(pmc);

arch/x86/kvm/pmu.h

189

return fixed_ctrl_field(pmu->fixed_ctr_ctrl,

arch/x86/kvm/pmu.h

200

void kvm_pmu_recalc_pmc_emulation(struct kvm_pmu *pmu, struct kvm_pmc *pmc);

arch/x86/kvm/pmu.h

210

static inline void reprogram_counters(struct kvm_pmu *pmu, u64 diff)

arch/x86/kvm/pmu.h

218

set_bit(bit, pmu->reprogram_pmi);

arch/x86/kvm/pmu.h

219

kvm_make_request(KVM_REQ_PMU, pmu_to_vcpu(pmu));

arch/x86/kvm/pmu.h

229

struct kvm_pmu *pmu = pmc_to_pmu(pmc);

arch/x86/kvm/pmu.h

231

if (!kvm_pmu_has_perf_global_ctrl(pmu))

arch/x86/kvm/pmu.h

234

return test_bit(pmc->idx, (unsigned long *)&pmu->global_ctrl);

arch/x86/kvm/pmu.h

239

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/pmu.h

242

!bitmap_intersects(pmu->pmc_counting_instructions,

arch/x86/kvm/pmu.h

243

(unsigned long *)&pmu->global_ctrl,

arch/x86/kvm/pmu.h

60

static inline bool kvm_pmu_has_perf_global_ctrl(struct kvm_pmu *pmu)

arch/x86/kvm/pmu.h

71

return pmu->version > 1;

arch/x86/kvm/pmu.h

9

#define vcpu_to_pmu(vcpu) (&(vcpu)->arch.pmu)

arch/x86/kvm/pmu.h

93

static inline struct kvm_pmc *kvm_pmc_idx_to_pmc(struct kvm_pmu *pmu, int idx)

arch/x86/kvm/pmu.h

95

if (idx < pmu->nr_arch_gp_counters)

arch/x86/kvm/pmu.h

96

return &pmu->gp_counters[idx];

arch/x86/kvm/pmu.h

99

if (idx >= 0 && idx < pmu->nr_arch_fixed_counters)

arch/x86/kvm/svm/pmu.c

106

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/svm/pmu.c

110

return pmu->version > 0;

arch/x86/kvm/svm/pmu.c

117

return pmu->version > 1;

arch/x86/kvm/svm/pmu.c

120

msr < MSR_F15H_PERF_CTL0 + 2 * pmu->nr_arch_gp_counters)

arch/x86/kvm/svm/pmu.c

121

return pmu->version > 1;

arch/x86/kvm/svm/pmu.c

130

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/svm/pmu.c

135

pmc = get_gp_pmc_amd(pmu, msr, PMU_TYPE_COUNTER);

arch/x86/kvm/svm/pmu.c

141

pmc = get_gp_pmc_amd(pmu, msr, PMU_TYPE_EVNTSEL);

arch/x86/kvm/svm/pmu.c

152

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/svm/pmu.c

158

pmc = get_gp_pmc_amd(pmu, msr, PMU_TYPE_COUNTER);

arch/x86/kvm/svm/pmu.c

164

pmc = get_gp_pmc_amd(pmu, msr, PMU_TYPE_EVNTSEL);

arch/x86/kvm/svm/pmu.c

166

data &= ~pmu->reserved_bits;

arch/x86/kvm/svm/pmu.c

181

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/svm/pmu.c

184

pmu->version = 1;

arch/x86/kvm/svm/pmu.c

186

pmu->version = 2;

arch/x86/kvm/svm/pmu.c

194

pmu->nr_arch_gp_counters = ebx.split.num_core_pmc;

arch/x86/kvm/svm/pmu.c

196

pmu->nr_arch_gp_counters = AMD64_NUM_COUNTERS_CORE;

arch/x86/kvm/svm/pmu.c

198

pmu->nr_arch_gp_counters = AMD64_NUM_COUNTERS;

arch/x86/kvm/svm/pmu.c

201

pmu->nr_arch_gp_counters = min_t(unsigned int, pmu->nr_arch_gp_counters,

arch/x86/kvm/svm/pmu.c

204

if (pmu->version > 1) {

arch/x86/kvm/svm/pmu.c

205

pmu->global_ctrl_rsvd = ~(BIT_ULL(pmu->nr_arch_gp_counters) - 1);

arch/x86/kvm/svm/pmu.c

206

pmu->global_status_rsvd = pmu->global_ctrl_rsvd;

arch/x86/kvm/svm/pmu.c

209

pmu->counter_bitmask[KVM_PMC_GP] = BIT_ULL(48) - 1;

arch/x86/kvm/svm/pmu.c

210

pmu->reserved_bits = 0xfffffff000280000ull;

arch/x86/kvm/svm/pmu.c

211

pmu->raw_event_mask = AMD64_RAW_EVENT_MASK;

arch/x86/kvm/svm/pmu.c

213

pmu->counter_bitmask[KVM_PMC_FIXED] = 0;

arch/x86/kvm/svm/pmu.c

214

pmu->nr_arch_fixed_counters = 0;

arch/x86/kvm/svm/pmu.c

219

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/svm/pmu.c

225

pmu->gp_counters[i].type = KVM_PMC_GP;

arch/x86/kvm/svm/pmu.c

226

pmu->gp_counters[i].vcpu = vcpu;

arch/x86/kvm/svm/pmu.c

227

pmu->gp_counters[i].idx = i;

arch/x86/kvm/svm/pmu.c

228

pmu->gp_counters[i].current_config = 0;

arch/x86/kvm/svm/pmu.c

239

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/svm/pmu.c

247

wrmsrq(MSR_AMD64_PERF_CNTR_GLOBAL_STATUS_SET, pmu->global_status);

arch/x86/kvm/svm/pmu.c

248

wrmsrq(MSR_AMD64_PERF_CNTR_GLOBAL_CTL, pmu->global_ctrl);

arch/x86/kvm/svm/pmu.c

253

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/svm/pmu.c

256

rdmsrq(MSR_AMD64_PERF_CNTR_GLOBAL_STATUS, pmu->global_status);

arch/x86/kvm/svm/pmu.c

259

if (pmu->global_status)

arch/x86/kvm/svm/pmu.c

260

wrmsrq(MSR_AMD64_PERF_CNTR_GLOBAL_STATUS_CLR, pmu->global_status);

arch/x86/kvm/svm/pmu.c

28

static struct kvm_pmc *amd_pmu_get_pmc(struct kvm_pmu *pmu, int pmc_idx)

arch/x86/kvm/svm/pmu.c

30

unsigned int num_counters = pmu->nr_arch_gp_counters;

arch/x86/kvm/svm/pmu.c

35

return &pmu->gp_counters[array_index_nospec(pmc_idx, num_counters)];

arch/x86/kvm/svm/pmu.c

38

static inline struct kvm_pmc *get_gp_pmc_amd(struct kvm_pmu *pmu, u32 msr,

arch/x86/kvm/svm/pmu.c

41

struct kvm_vcpu *vcpu = pmu_to_vcpu(pmu);

arch/x86/kvm/svm/pmu.c

44

if (!pmu->version)

arch/x86/kvm/svm/pmu.c

73

return amd_pmu_get_pmc(pmu, idx);

arch/x86/kvm/svm/pmu.c

78

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/svm/pmu.c

80

if (idx >= pmu->nr_arch_gp_counters)

arch/x86/kvm/svm/pmu.c

95

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/svm/pmu.c

98

pmc = get_gp_pmc_amd(pmu, msr, PMU_TYPE_COUNTER);

arch/x86/kvm/svm/pmu.c

99

pmc = pmc ? pmc : get_gp_pmc_amd(pmu, msr, PMU_TYPE_EVNTSEL);

arch/x86/kvm/svm/svm.c

737

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/svm/svm.c

744

for (i = 0; i < min(pmu->nr_arch_gp_counters, AMD64_NUM_COUNTERS); i++)

arch/x86/kvm/svm/svm.c

749

for (i = 0; i < pmu->nr_arch_gp_counters; i++)

arch/x86/kvm/vmx/nested.c

641

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/vmx/nested.c

652

for (i = 0; i < pmu->nr_arch_gp_counters; i++) {

arch/x86/kvm/vmx/nested.c

657

for (i = 0; i < pmu->nr_arch_fixed_counters; i++)

arch/x86/kvm/vmx/pmu_intel.c

111

counters = pmu->fixed_counters;

arch/x86/kvm/vmx/pmu_intel.c

112

num_counters = pmu->nr_arch_fixed_counters;

arch/x86/kvm/vmx/pmu_intel.c

113

bitmask = pmu->counter_bitmask[KVM_PMC_FIXED];

arch/x86/kvm/vmx/pmu_intel.c

116

counters = pmu->gp_counters;

arch/x86/kvm/vmx/pmu_intel.c

117

num_counters = pmu->nr_arch_gp_counters;

arch/x86/kvm/vmx/pmu_intel.c

118

bitmask = pmu->counter_bitmask[KVM_PMC_GP];

arch/x86/kvm/vmx/pmu_intel.c

132

static inline struct kvm_pmc *get_fw_gp_pmc(struct kvm_pmu *pmu, u32 msr)

arch/x86/kvm/vmx/pmu_intel.c

134

if (!fw_writes_is_enabled(pmu_to_vcpu(pmu)))

arch/x86/kvm/vmx/pmu_intel.c

137

return get_gp_pmc(pmu, msr, MSR_IA32_PMC0);

arch/x86/kvm/vmx/pmu_intel.c

176

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/vmx/pmu_intel.c

182

return kvm_pmu_has_perf_global_ctrl(pmu);

arch/x86/kvm/vmx/pmu_intel.c

195

ret = get_gp_pmc(pmu, msr, MSR_IA32_PERFCTR0) ||

arch/x86/kvm/vmx/pmu_intel.c

196

get_gp_pmc(pmu, msr, MSR_P6_EVNTSEL0) ||

arch/x86/kvm/vmx/pmu_intel.c

197

get_fixed_pmc(pmu, msr) || get_fw_gp_pmc(pmu, msr) ||

arch/x86/kvm/vmx/pmu_intel.c

207

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/vmx/pmu_intel.c

210

pmc = get_fixed_pmc(pmu, msr);

arch/x86/kvm/vmx/pmu_intel.c

211

pmc = pmc ? pmc : get_gp_pmc(pmu, msr, MSR_P6_EVNTSEL0);

arch/x86/kvm/vmx/pmu_intel.c

212

pmc = pmc ? pmc : get_gp_pmc(pmu, msr, MSR_IA32_PERFCTR0);

arch/x86/kvm/vmx/pmu_intel.c

234

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/vmx/pmu_intel.c

269

__set_bit(INTEL_PMC_IDX_FIXED_VLBR, pmu->pmc_in_use);

arch/x86/kvm/vmx/pmu_intel.c

281

pmu->event_count++;

arch/x86/kvm/vmx/pmu_intel.c

282

__set_bit(INTEL_PMC_IDX_FIXED_VLBR, pmu->pmc_in_use);

arch/x86/kvm/vmx/pmu_intel.c

330

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/vmx/pmu_intel.c

336

msr_info->data = pmu->fixed_ctr_ctrl;

arch/x86/kvm/vmx/pmu_intel.c

339

msr_info->data = pmu->pebs_enable;

arch/x86/kvm/vmx/pmu_intel.c

342

msr_info->data = pmu->ds_area;

arch/x86/kvm/vmx/pmu_intel.c

345

msr_info->data = pmu->pebs_data_cfg;

arch/x86/kvm/vmx/pmu_intel.c

348

if ((pmc = get_gp_pmc(pmu, msr, MSR_IA32_PERFCTR0)) ||

arch/x86/kvm/vmx/pmu_intel.c

349

(pmc = get_gp_pmc(pmu, msr, MSR_IA32_PMC0))) {

arch/x86/kvm/vmx/pmu_intel.c

352

val & pmu->counter_bitmask[KVM_PMC_GP];

arch/x86/kvm/vmx/pmu_intel.c

354

} else if ((pmc = get_fixed_pmc(pmu, msr))) {

arch/x86/kvm/vmx/pmu_intel.c

357

val & pmu->counter_bitmask[KVM_PMC_FIXED];

arch/x86/kvm/vmx/pmu_intel.c

359

} else if ((pmc = get_gp_pmc(pmu, msr, MSR_P6_EVNTSEL0))) {

arch/x86/kvm/vmx/pmu_intel.c

373

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/vmx/pmu_intel.c

381

if (data & pmu->fixed_ctr_ctrl_rsvd)

arch/x86/kvm/vmx/pmu_intel.c

384

if (pmu->fixed_ctr_ctrl != data)

arch/x86/kvm/vmx/pmu_intel.c

385

reprogram_fixed_counters(pmu, data);

arch/x86/kvm/vmx/pmu_intel.c

388

if (data & pmu->pebs_enable_rsvd)

arch/x86/kvm/vmx/pmu_intel.c

391

if (pmu->pebs_enable != data) {

arch/x86/kvm/vmx/pmu_intel.c

392

diff = pmu->pebs_enable ^ data;

arch/x86/kvm/vmx/pmu_intel.c

393

pmu->pebs_enable = data;

arch/x86/kvm/vmx/pmu_intel.c

394

reprogram_counters(pmu, diff);

arch/x86/kvm/vmx/pmu_intel.c

401

pmu->ds_area = data;

arch/x86/kvm/vmx/pmu_intel.c

404

if (data & pmu->pebs_data_cfg_rsvd)

arch/x86/kvm/vmx/pmu_intel.c

407

pmu->pebs_data_cfg = data;

arch/x86/kvm/vmx/pmu_intel.c

410

if ((pmc = get_gp_pmc(pmu, msr, MSR_IA32_PERFCTR0)) ||

arch/x86/kvm/vmx/pmu_intel.c

411

(pmc = get_gp_pmc(pmu, msr, MSR_IA32_PMC0))) {

arch/x86/kvm/vmx/pmu_intel.c

413

(data & ~pmu->counter_bitmask[KVM_PMC_GP]))

arch/x86/kvm/vmx/pmu_intel.c

421

} else if ((pmc = get_fixed_pmc(pmu, msr))) {

arch/x86/kvm/vmx/pmu_intel.c

424

} else if ((pmc = get_gp_pmc(pmu, msr, MSR_P6_EVNTSEL0))) {

arch/x86/kvm/vmx/pmu_intel.c

425

reserved_bits = pmu->reserved_bits;

arch/x86/kvm/vmx/pmu_intel.c

427

(pmu->raw_event_mask & HSW_IN_TX_CHECKPOINTED))

arch/x86/kvm/vmx/pmu_intel.c

482

static void intel_pmu_enable_fixed_counter_bits(struct kvm_pmu *pmu, u64 bits)

arch/x86/kvm/vmx/pmu_intel.c

486

for (i = 0; i < pmu->nr_arch_fixed_counters; i++)

arch/x86/kvm/vmx/pmu_intel.c

487

pmu->fixed_ctr_ctrl_rsvd &= ~intel_fixed_bits_by_idx(i, bits);

arch/x86/kvm/vmx/pmu_intel.c

492

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/vmx/pmu_intel.c

520

pmu->version = eax.split.version_id;

arch/x86/kvm/vmx/pmu_intel.c

521

if (!pmu->version)

arch/x86/kvm/vmx/pmu_intel.c

524

pmu->nr_arch_gp_counters = min_t(int, eax.split.num_counters,

arch/x86/kvm/vmx/pmu_intel.c

528

pmu->counter_bitmask[KVM_PMC_GP] = BIT_ULL(eax.split.bit_width) - 1;

arch/x86/kvm/vmx/pmu_intel.c

531

pmu->available_event_types = ~entry->ebx & (BIT_ULL(eax.split.mask_length) - 1);

arch/x86/kvm/vmx/pmu_intel.c

537

pmu->reserved_bits ^= HSW_IN_TX;

arch/x86/kvm/vmx/pmu_intel.c

538

pmu->raw_event_mask |= (HSW_IN_TX|HSW_IN_TX_CHECKPOINTED);

arch/x86/kvm/vmx/pmu_intel.c

549

bitmap_set(pmu->all_valid_pmc_idx, INTEL_PMC_IDX_FIXED_VLBR, 1);

arch/x86/kvm/vmx/pmu_intel.c

551

if (pmu->version == 1)

arch/x86/kvm/vmx/pmu_intel.c

554

pmu->nr_arch_fixed_counters = min_t(int, edx.split.num_counters_fixed,

arch/x86/kvm/vmx/pmu_intel.c

558

pmu->counter_bitmask[KVM_PMC_FIXED] = BIT_ULL(edx.split.bit_width_fixed) - 1;

arch/x86/kvm/vmx/pmu_intel.c

560

intel_pmu_enable_fixed_counter_bits(pmu, INTEL_FIXED_0_KERNEL |

arch/x86/kvm/vmx/pmu_intel.c

564

counter_rsvd = ~((BIT_ULL(pmu->nr_arch_gp_counters) - 1) |

arch/x86/kvm/vmx/pmu_intel.c

565

((BIT_ULL(pmu->nr_arch_fixed_counters) - 1) << KVM_FIXED_PMC_BASE_IDX));

arch/x86/kvm/vmx/pmu_intel.c

566

pmu->global_ctrl_rsvd = counter_rsvd;

arch/x86/kvm/vmx/pmu_intel.c

57

static void reprogram_fixed_counters(struct kvm_pmu *pmu, u64 data)

arch/x86/kvm/vmx/pmu_intel.c

573

pmu->global_status_rsvd = pmu->global_ctrl_rsvd

arch/x86/kvm/vmx/pmu_intel.c

577

pmu->global_status_rsvd &=

arch/x86/kvm/vmx/pmu_intel.c

582

pmu->pebs_enable_rsvd = counter_rsvd;

arch/x86/kvm/vmx/pmu_intel.c

583

pmu->reserved_bits &= ~ICL_EVENTSEL_ADAPTIVE;

arch/x86/kvm/vmx/pmu_intel.c

584

pmu->pebs_data_cfg_rsvd = ~0xff00000full;

arch/x86/kvm/vmx/pmu_intel.c

585

intel_pmu_enable_fixed_counter_bits(pmu, ICL_FIXED_0_ADAPTIVE);

arch/x86/kvm/vmx/pmu_intel.c

587

pmu->pebs_enable_rsvd = ~(BIT_ULL(pmu->nr_arch_gp_counters) - 1);

arch/x86/kvm/vmx/pmu_intel.c

595

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/vmx/pmu_intel.c

60

u64 old_fixed_ctr_ctrl = pmu->fixed_ctr_ctrl;

arch/x86/kvm/vmx/pmu_intel.c

602

pmu->gp_counters[i].type = KVM_PMC_GP;

arch/x86/kvm/vmx/pmu_intel.c

603

pmu->gp_counters[i].vcpu = vcpu;

arch/x86/kvm/vmx/pmu_intel.c

604

pmu->gp_counters[i].idx = i;

arch/x86/kvm/vmx/pmu_intel.c

605

pmu->gp_counters[i].current_config = 0;

arch/x86/kvm/vmx/pmu_intel.c

609

pmu->fixed_counters[i].type = KVM_PMC_FIXED;

arch/x86/kvm/vmx/pmu_intel.c

610

pmu->fixed_counters[i].vcpu = vcpu;

arch/x86/kvm/vmx/pmu_intel.c

611

pmu->fixed_counters[i].idx = i + KVM_FIXED_PMC_BASE_IDX;

arch/x86/kvm/vmx/pmu_intel.c

612

pmu->fixed_counters[i].current_config = 0;

arch/x86/kvm/vmx/pmu_intel.c

613

pmu->fixed_counters[i].eventsel = intel_get_fixed_pmc_eventsel(i);

arch/x86/kvm/vmx/pmu_intel.c

63

pmu->fixed_ctr_ctrl = data;

arch/x86/kvm/vmx/pmu_intel.c

64

pmu->fixed_ctr_ctrl_hw = data;

arch/x86/kvm/vmx/pmu_intel.c

65

for (i = 0; i < pmu->nr_arch_fixed_counters; i++) {

arch/x86/kvm/vmx/pmu_intel.c

705

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/vmx/pmu_intel.c

715

if (test_bit(INTEL_PMC_IDX_FIXED_VLBR, pmu->pmc_in_use))

arch/x86/kvm/vmx/pmu_intel.c

72

pmc = get_fixed_pmc(pmu, MSR_CORE_PERF_FIXED_CTR0 + i);

arch/x86/kvm/vmx/pmu_intel.c

722

__clear_bit(INTEL_PMC_IDX_FIXED_VLBR, pmu->pmc_in_use);

arch/x86/kvm/vmx/pmu_intel.c

739

void intel_pmu_cross_mapped_check(struct kvm_pmu *pmu)

arch/x86/kvm/vmx/pmu_intel.c

74

__set_bit(KVM_FIXED_PMC_BASE_IDX + i, pmu->pmc_in_use);

arch/x86/kvm/vmx/pmu_intel.c

744

kvm_for_each_pmc(pmu, pmc, bit, (unsigned long *)&pmu->global_ctrl) {

arch/x86/kvm/vmx/pmu_intel.c

755

pmu->host_cross_mapped_mask |= BIT_ULL(hw_idx);

arch/x86/kvm/vmx/pmu_intel.c

791

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/vmx/pmu_intel.c

795

toggle = pmu->global_status ^ global_status;

arch/x86/kvm/vmx/pmu_intel.c

798

if (pmu->global_status & toggle)

arch/x86/kvm/vmx/pmu_intel.c

799

wrmsrq(MSR_CORE_PERF_GLOBAL_STATUS_SET, pmu->global_status & toggle);

arch/x86/kvm/vmx/pmu_intel.c

801

wrmsrq(MSR_CORE_PERF_FIXED_CTR_CTRL, pmu->fixed_ctr_ctrl_hw);

arch/x86/kvm/vmx/pmu_intel.c

806

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/vmx/pmu_intel.c

809

rdmsrq(MSR_CORE_PERF_GLOBAL_STATUS, pmu->global_status);

arch/x86/kvm/vmx/pmu_intel.c

812

if (pmu->global_status)

arch/x86/kvm/vmx/pmu_intel.c

813

wrmsrq(MSR_CORE_PERF_GLOBAL_OVF_CTRL, pmu->global_status);

arch/x86/kvm/vmx/pmu_intel.c

820

if (pmu->fixed_ctr_ctrl_hw)

arch/x86/kvm/vmx/pmu_intel.c

83

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/vmx/pmu_intel.c

98

if (WARN_ON_ONCE(!pmu->version))

arch/x86/kvm/vmx/vmx.c

4292

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/vmx/vmx.c

4314

for (i = 0; i < pmu->nr_arch_gp_counters; i++) {

arch/x86/kvm/vmx/vmx.c

4327

for (i = 0; i < pmu->nr_arch_fixed_counters; i++)

arch/x86/kvm/vmx/vmx.c

7420

struct kvm_pmu *pmu = vcpu_to_pmu(&vmx->vcpu);

arch/x86/kvm/vmx/vmx.c

7425

pmu->host_cross_mapped_mask = 0;

arch/x86/kvm/vmx/vmx.c

7426

if (pmu->pebs_enable & pmu->global_ctrl)

arch/x86/kvm/vmx/vmx.c

7427

intel_pmu_cross_mapped_check(pmu);

arch/x86/kvm/vmx/vmx.c

7430

msrs = perf_guest_get_msrs(&nr_msrs, (void *)pmu);

arch/x86/kvm/vmx/vmx.c

7444

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/vmx/vmx.c

7457

pmu->global_ctrl = vmx->msr_autostore.val[slot].value;

arch/x86/kvm/vmx/vmx.c

7458

vmcs_write64(GUEST_IA32_PERF_GLOBAL_CTRL, pmu->global_ctrl);

arch/x86/kvm/vmx/vmx.c

7462

pmu->global_ctrl = vmcs_read64(GUEST_IA32_PERF_GLOBAL_CTRL);

arch/x86/kvm/vmx/vmx.c

8637

(unsigned long *)&vcpu->arch.pmu.global_status);

arch/x86/kvm/vmx/vmx.h

665

void intel_pmu_cross_mapped_check(struct kvm_pmu *pmu);

arch/x86/kvm/x86.c

5165

struct kvm_pmu *pmu = vcpu_to_pmu(vcpu);

arch/x86/kvm/x86.c

5169

if (vcpu->scheduled_out && pmu->version && pmu->event_count) {

arch/x86/kvm/x86.c

5170

pmu->need_cleanup = true;

arch/x86/xen/pmu.c

211

ctxt = &xenpmu_data->pmu.c.intel;

arch/x86/xen/pmu.c

276

ctxt = &xenpmu_data->pmu.c.amd;

arch/x86/xen/pmu.c

330

ctxt = &xenpmu_data->pmu.c.amd;

arch/x86/xen/pmu.c

356

ctxt = &xenpmu_data->pmu.c.intel;

arch/x86/xen/pmu.c

384

xenpmu_data->pmu.l.lapic_lvtpc = val;

arch/x86/xen/pmu.c

410

if (xenpmu_data->pmu.pmu_flags & PMU_SAMPLE_PV) {

arch/x86/xen/pmu.c

411

if (xenpmu_data->pmu.pmu_flags & PMU_SAMPLE_USER)

arch/x86/xen/pmu.c

413

} else if (xenpmu_data->pmu.r.regs.cpl & 3) {

arch/x86/xen/pmu.c

429

return xenpmu_data->pmu.r.regs.ip;

arch/x86/xen/pmu.c

472

xen_convert_regs(&xenpmu_data->pmu.r.regs, &regs,

arch/x86/xen/pmu.c

473

xenpmu_data->pmu.pmu_flags);

arch/xtensa/kernel/perf_event.c

197

static void xtensa_pmu_enable(struct pmu *pmu)

arch/xtensa/kernel/perf_event.c

202

static void xtensa_pmu_disable(struct pmu *pmu)

arch/xtensa/kernel/perf_event.c

399

static struct pmu xtensa_pmu = {

drivers/bcma/driver_chipcommon_pmu.c

142

if (cc->pmu.rev >= 2)

drivers/bcma/driver_chipcommon_pmu.c

281

cc->pmu.core = bcma_find_core(bus, BCMA_CORE_PMU);

drivers/bcma/driver_chipcommon_pmu.c

282

if (!cc->pmu.core)

drivers/bcma/driver_chipcommon_pmu.c

285

if (!cc->pmu.core)

drivers/bcma/driver_chipcommon_pmu.c

286

cc->pmu.core = cc->core;

drivers/bcma/driver_chipcommon_pmu.c

289

cc->pmu.rev = (pmucap & BCMA_CC_PMU_CAP_REVISION);

drivers/bcma/driver_chipcommon_pmu.c

291

bcma_debug(bus, "Found rev %u PMU (capabilities 0x%08X)\n", cc->pmu.rev,

drivers/bcma/driver_chipcommon_pmu.c

297

if (cc->pmu.rev == 1)

drivers/bcma/driver_chipcommon_pmu.c

345

bus->chipinfo.id, cc->pmu.rev, BCMA_CC_PMU_ALP_CLOCK);

drivers/bcma/driver_chipcommon_pmu.c

445

bus->chipinfo.id, cc->pmu.rev, BCMA_CC_PMU_HT_CLOCK);

drivers/bcma/driver_chipcommon_pmu.c

460

if (cc->pmu.rev >= 5) {

drivers/cxl/core/pmu.c

14

struct cxl_pmu *pmu = to_cxl_pmu(dev);

drivers/cxl/core/pmu.c

16

kfree(pmu);

drivers/cxl/core/pmu.c

32

struct cxl_pmu *pmu;

drivers/cxl/core/pmu.c

36

pmu = kzalloc_obj(*pmu);

drivers/cxl/core/pmu.c

37

if (!pmu)

drivers/cxl/core/pmu.c

40

pmu->assoc_id = assoc_id;

drivers/cxl/core/pmu.c

41

pmu->index = index;

drivers/cxl/core/pmu.c

42

pmu->type = type;

drivers/cxl/core/pmu.c

43

pmu->base = regs->pmu;

drivers/cxl/core/pmu.c

44

dev = &pmu->dev;

drivers/cxl/core/pmu.c

50

switch (pmu->type) {

drivers/cxl/core/pmu.c

65

put_device(&pmu->dev);

drivers/cxl/core/regs.c

408

regs->pmu = devm_cxl_iomap_block(dev, phys_addr, CXL_PMU_REGMAP_SIZE);

drivers/cxl/core/regs.c

409

if (!regs->pmu)

drivers/cxl/cxl.h

229

void __iomem *pmu;

drivers/cxl/cxl.h

268

struct cxl_reg_map pmu;

drivers/devfreq/event/rockchip-dfi.c

109

struct pmu pmu;

drivers/devfreq/event/rockchip-dfi.c

354

struct pmu *pmu = dev_get_drvdata(dev);

drivers/devfreq/event/rockchip-dfi.c

355

struct rockchip_dfi *dfi = container_of(pmu, struct rockchip_dfi, pmu);

drivers/devfreq/event/rockchip-dfi.c

443

struct rockchip_dfi *dfi = container_of(event->pmu, struct rockchip_dfi, pmu);

drivers/devfreq/event/rockchip-dfi.c

445

if (event->attr.type != event->pmu->type)

drivers/devfreq/event/rockchip-dfi.c

461

struct rockchip_dfi *dfi = container_of(event->pmu, struct rockchip_dfi, pmu);

drivers/devfreq/event/rockchip-dfi.c

542

struct rockchip_dfi *dfi = container_of(event->pmu, struct rockchip_dfi, pmu);

drivers/devfreq/event/rockchip-dfi.c

565

struct rockchip_dfi *dfi = container_of(event->pmu, struct rockchip_dfi, pmu);

drivers/devfreq/event/rockchip-dfi.c

607

perf_pmu_migrate_context(&dfi->pmu, cpu, target);

drivers/devfreq/event/rockchip-dfi.c

633

perf_pmu_unregister(&dfi->pmu);

drivers/devfreq/event/rockchip-dfi.c

638

struct pmu *pmu = &dfi->pmu;

drivers/devfreq/event/rockchip-dfi.c

643

pmu->module = THIS_MODULE;

drivers/devfreq/event/rockchip-dfi.c

644

pmu->capabilities = PERF_PMU_CAP_NO_EXCLUDE;

drivers/devfreq/event/rockchip-dfi.c

645

pmu->task_ctx_nr = perf_invalid_context;

drivers/devfreq/event/rockchip-dfi.c

646

pmu->attr_groups = attr_groups;

drivers/devfreq/event/rockchip-dfi.c

647

pmu->event_init = rockchip_ddr_perf_event_init;

drivers/devfreq/event/rockchip-dfi.c

648

pmu->add = rockchip_ddr_perf_event_add;

drivers/devfreq/event/rockchip-dfi.c

649

pmu->del = rockchip_ddr_perf_event_del;

drivers/devfreq/event/rockchip-dfi.c

650

pmu->start = rockchip_ddr_perf_event_start;

drivers/devfreq/event/rockchip-dfi.c

651

pmu->stop = rockchip_ddr_perf_event_stop;

drivers/devfreq/event/rockchip-dfi.c

652

pmu->read = rockchip_ddr_perf_event_update;

drivers/devfreq/event/rockchip-dfi.c

701

ret = perf_pmu_register(pmu, "rockchip_ddr", -1);

drivers/dma/idxd/idxd.h

124

struct pmu pmu;

drivers/dma/idxd/perfmon.c

124

static int perfmon_validate_group(struct idxd_pmu *pmu,

drivers/dma/idxd/perfmon.c

135

fake_pmu->pmu.name = pmu->pmu.name;

drivers/dma/idxd/perfmon.c

136

fake_pmu->n_counters = pmu->n_counters;

drivers/dma/idxd/perfmon.c

176

if (event->attr.type != event->pmu->type)

drivers/dma/idxd/perfmon.c

186

if (event->pmu != &idxd->idxd_pmu->pmu)

drivers/dma/idxd/perfmon.c

416

static void perfmon_pmu_enable(struct pmu *pmu)

drivers/dma/idxd/perfmon.c

418

struct idxd_device *idxd = pmu_to_idxd(pmu);

drivers/dma/idxd/perfmon.c

423

static void perfmon_pmu_disable(struct pmu *pmu)

drivers/dma/idxd/perfmon.c

425

struct idxd_device *idxd = pmu_to_idxd(pmu);

drivers/dma/idxd/perfmon.c

448

idxd_pmu->pmu.name = idxd_pmu->name;

drivers/dma/idxd/perfmon.c

449

idxd_pmu->pmu.attr_groups = perfmon_attr_groups;

drivers/dma/idxd/perfmon.c

450

idxd_pmu->pmu.task_ctx_nr = perf_invalid_context;

drivers/dma/idxd/perfmon.c

451

idxd_pmu->pmu.event_init = perfmon_pmu_event_init;

drivers/dma/idxd/perfmon.c

452

idxd_pmu->pmu.pmu_enable = perfmon_pmu_enable;

drivers/dma/idxd/perfmon.c

453

idxd_pmu->pmu.pmu_disable = perfmon_pmu_disable;

drivers/dma/idxd/perfmon.c

454

idxd_pmu->pmu.add = perfmon_pmu_event_add;

drivers/dma/idxd/perfmon.c

455

idxd_pmu->pmu.del = perfmon_pmu_event_del;

drivers/dma/idxd/perfmon.c

456

idxd_pmu->pmu.start = perfmon_pmu_event_start;

drivers/dma/idxd/perfmon.c

457

idxd_pmu->pmu.stop = perfmon_pmu_event_stop;

drivers/dma/idxd/perfmon.c

458

idxd_pmu->pmu.read = perfmon_pmu_event_update;

drivers/dma/idxd/perfmon.c

459

idxd_pmu->pmu.capabilities = PERF_PMU_CAP_NO_EXCLUDE;

drivers/dma/idxd/perfmon.c

460

idxd_pmu->pmu.scope = PERF_PMU_SCOPE_SYS_WIDE;

drivers/dma/idxd/perfmon.c

461

idxd_pmu->pmu.module = THIS_MODULE;

drivers/dma/idxd/perfmon.c

469

perf_pmu_unregister(&idxd->idxd_pmu->pmu);

drivers/dma/idxd/perfmon.c

52

return &idxd_pmu->pmu == event->pmu;

drivers/dma/idxd/perfmon.c

551

rc = perf_pmu_register(&idxd_pmu->pmu, idxd_pmu->name, -1);

drivers/dma/idxd/perfmon.h

22

struct pmu *pmu;

drivers/dma/idxd/perfmon.h

24

pmu = event->pmu;

drivers/dma/idxd/perfmon.h

25

idxd_pmu = container_of(pmu, struct idxd_pmu, pmu);

drivers/dma/idxd/perfmon.h

33

struct pmu *pmu;

drivers/dma/idxd/perfmon.h

35

pmu = event->pmu;

drivers/dma/idxd/perfmon.h

36

idxd_pmu = container_of(pmu, struct idxd_pmu, pmu);

drivers/dma/idxd/perfmon.h

41

static inline struct idxd_device *pmu_to_idxd(struct pmu *pmu)

drivers/dma/idxd/perfmon.h

45

idxd_pmu = container_of(pmu, struct idxd_pmu, pmu);

drivers/fpga/dfl-fme-perf.c

150

struct pmu pmu;

drivers/fpga/dfl-fme-perf.c

176

#define to_fme_perf_priv(_pmu) container_of(_pmu, struct fme_perf_priv, pmu)

drivers/fpga/dfl-fme-perf.c

181

struct pmu *pmu = dev_get_drvdata(dev);

drivers/fpga/dfl-fme-perf.c

184

priv = to_fme_perf_priv(pmu);

drivers/fpga/dfl-fme-perf.c

609

struct pmu *pmu = dev_get_drvdata(kobj_to_dev(kobj));

drivers/fpga/dfl-fme-perf.c

610

struct fme_perf_priv *priv = to_fme_perf_priv(pmu);

drivers/fpga/dfl-fme-perf.c

675

struct pmu *pmu = dev_get_drvdata(kobj_to_dev(kobj));

drivers/fpga/dfl-fme-perf.c

676

struct fme_perf_priv *priv = to_fme_perf_priv(pmu);

drivers/fpga/dfl-fme-perf.c

789

struct fme_perf_priv *priv = to_fme_perf_priv(event->pmu);

drivers/fpga/dfl-fme-perf.c

797

struct fme_perf_priv *priv = to_fme_perf_priv(event->pmu);

drivers/fpga/dfl-fme-perf.c

803

if (event->attr.type != event->pmu->type)

drivers/fpga/dfl-fme-perf.c

845

struct fme_perf_priv *priv = to_fme_perf_priv(event->pmu);

drivers/fpga/dfl-fme-perf.c

859

struct fme_perf_priv *priv = to_fme_perf_priv(event->pmu);

drivers/fpga/dfl-fme-perf.c

907

struct pmu *pmu = &priv->pmu;

drivers/fpga/dfl-fme-perf.c

915

pmu->task_ctx_nr = perf_invalid_context;

drivers/fpga/dfl-fme-perf.c

916

pmu->attr_groups = fme_perf_groups;

drivers/fpga/dfl-fme-perf.c

917

pmu->attr_update = fme_perf_events_groups;

drivers/fpga/dfl-fme-perf.c

918

pmu->event_init = fme_perf_event_init;

drivers/fpga/dfl-fme-perf.c

919

pmu->add = fme_perf_event_add;

drivers/fpga/dfl-fme-perf.c

920

pmu->del = fme_perf_event_del;

drivers/fpga/dfl-fme-perf.c

921

pmu->start = fme_perf_event_start;

drivers/fpga/dfl-fme-perf.c

922

pmu->stop = fme_perf_event_stop;

drivers/fpga/dfl-fme-perf.c

923

pmu->read = fme_perf_event_read;

drivers/fpga/dfl-fme-perf.c

924

pmu->capabilities = PERF_PMU_CAP_NO_INTERRUPT |

drivers/fpga/dfl-fme-perf.c

929

ret = perf_pmu_register(pmu, name, -1);

drivers/fpga/dfl-fme-perf.c

938

perf_pmu_unregister(&priv->pmu);

drivers/fpga/dfl-fme-perf.c

956

perf_pmu_migrate_context(&priv->pmu, cpu, target);

drivers/gpu/drm/amd/amdgpu/amdgpu_pmu.c

214

if (event->attr.type != event->pmu->type)

drivers/gpu/drm/amd/amdgpu/amdgpu_pmu.c

228

struct amdgpu_pmu_entry *pe = container_of(event->pmu,

drivers/gpu/drm/amd/amdgpu/amdgpu_pmu.c

230

pmu);

drivers/gpu/drm/amd/amdgpu/amdgpu_pmu.c

270

struct amdgpu_pmu_entry *pe = container_of(event->pmu,

drivers/gpu/drm/amd/amdgpu/amdgpu_pmu.c

272

pmu);

drivers/gpu/drm/amd/amdgpu/amdgpu_pmu.c

300

struct amdgpu_pmu_entry *pe = container_of(event->pmu,

drivers/gpu/drm/amd/amdgpu/amdgpu_pmu.c

302

pmu);

drivers/gpu/drm/amd/amdgpu/amdgpu_pmu.c

336

struct amdgpu_pmu_entry *pe = container_of(event->pmu,

drivers/gpu/drm/amd/amdgpu/amdgpu_pmu.c

338

pmu);

drivers/gpu/drm/amd/amdgpu/amdgpu_pmu.c

386

struct amdgpu_pmu_entry *pe = container_of(event->pmu,

drivers/gpu/drm/amd/amdgpu/amdgpu_pmu.c

388

pmu);

drivers/gpu/drm/amd/amdgpu/amdgpu_pmu.c

493

pmu_entry->pmu = (struct pmu){

drivers/gpu/drm/amd/amdgpu/amdgpu_pmu.c

50

struct pmu pmu;

drivers/gpu/drm/amd/amdgpu/amdgpu_pmu.c

536

pmu_entry->pmu.attr_groups = kmemdup(attr_groups, sizeof(attr_groups),

drivers/gpu/drm/amd/amdgpu/amdgpu_pmu.c

539

if (!pmu_entry->pmu.attr_groups) {

drivers/gpu/drm/amd/amdgpu/amdgpu_pmu.c

547

ret = perf_pmu_register(&pmu_entry->pmu, pmu_name, -1);

drivers/gpu/drm/amd/amdgpu/amdgpu_pmu.c

563

kfree(pmu_entry->pmu.attr_groups);

drivers/gpu/drm/amd/amdgpu/amdgpu_pmu.c

584

perf_pmu_unregister(&pe->pmu);

drivers/gpu/drm/amd/amdgpu/amdgpu_pmu.c

585

kfree(pe->pmu.attr_groups);

drivers/gpu/drm/i915/gt/intel_engine_types.h

496

} pmu;

drivers/gpu/drm/i915/i915_drv.h

310

struct i915_pmu pmu;

drivers/gpu/drm/i915/i915_irq.c

78

WRITE_ONCE(i915->pmu.irq_count, i915->pmu.irq_count + 1);

drivers/gpu/drm/i915/i915_pmu.c

1116

pmu->i915_attr = i915_attr;

drivers/gpu/drm/i915/i915_pmu.c

1117

pmu->pmu_attr = pmu_attr;

drivers/gpu/drm/i915/i915_pmu.c

1133

static void free_event_attributes(struct i915_pmu *pmu)

drivers/gpu/drm/i915/i915_pmu.c

1135

struct attribute **attr_iter = pmu->events_attr_group.attrs;

drivers/gpu/drm/i915/i915_pmu.c

1140

kfree(pmu->events_attr_group.attrs);

drivers/gpu/drm/i915/i915_pmu.c

1141

kfree(pmu->i915_attr);

drivers/gpu/drm/i915/i915_pmu.c

1142

kfree(pmu->pmu_attr);

drivers/gpu/drm/i915/i915_pmu.c

1144

pmu->events_attr_group.attrs = NULL;

drivers/gpu/drm/i915/i915_pmu.c

1145

pmu->i915_attr = NULL;

drivers/gpu/drm/i915/i915_pmu.c

1146

pmu->pmu_attr = NULL;

drivers/gpu/drm/i915/i915_pmu.c

1151

struct i915_pmu *pmu = &i915->pmu;

drivers/gpu/drm/i915/i915_pmu.c

1154

&pmu->events_attr_group,

drivers/gpu/drm/i915/i915_pmu.c

1159

spin_lock_init(&pmu->lock);

drivers/gpu/drm/i915/i915_pmu.c

1160

hrtimer_setup(&pmu->timer, i915_sample, CLOCK_MONOTONIC, HRTIMER_MODE_REL);

drivers/gpu/drm/i915/i915_pmu.c

1161

init_rc6(pmu);

drivers/gpu/drm/i915/i915_pmu.c

1164

pmu->name = kasprintf(GFP_KERNEL,

drivers/gpu/drm/i915/i915_pmu.c

1167

if (pmu->name) {

drivers/gpu/drm/i915/i915_pmu.c

1169

strreplace((char *)pmu->name, ':', '_');

drivers/gpu/drm/i915/i915_pmu.c

1172

pmu->name = "i915";

drivers/gpu/drm/i915/i915_pmu.c

1174

if (!pmu->name)

drivers/gpu/drm/i915/i915_pmu.c

1177

pmu->events_attr_group.name = "events";

drivers/gpu/drm/i915/i915_pmu.c

1178

pmu->events_attr_group.attrs = create_event_attributes(pmu);

drivers/gpu/drm/i915/i915_pmu.c

1179

if (!pmu->events_attr_group.attrs)

drivers/gpu/drm/i915/i915_pmu.c

1182

pmu->base.attr_groups = kmemdup(attr_groups, sizeof(attr_groups),

drivers/gpu/drm/i915/i915_pmu.c

1184

if (!pmu->base.attr_groups)

drivers/gpu/drm/i915/i915_pmu.c

1187

pmu->base.module = THIS_MODULE;

drivers/gpu/drm/i915/i915_pmu.c

1188

pmu->base.task_ctx_nr = perf_invalid_context;

drivers/gpu/drm/i915/i915_pmu.c

1189

pmu->base.scope = PERF_PMU_SCOPE_SYS_WIDE;

drivers/gpu/drm/i915/i915_pmu.c

1190

pmu->base.event_init = i915_pmu_event_init;

drivers/gpu/drm/i915/i915_pmu.c

1191

pmu->base.add = i915_pmu_event_add;

drivers/gpu/drm/i915/i915_pmu.c

1192

pmu->base.del = i915_pmu_event_del;

drivers/gpu/drm/i915/i915_pmu.c

1193

pmu->base.start = i915_pmu_event_start;

drivers/gpu/drm/i915/i915_pmu.c

1194

pmu->base.stop = i915_pmu_event_stop;

drivers/gpu/drm/i915/i915_pmu.c

1195

pmu->base.read = i915_pmu_event_read;

drivers/gpu/drm/i915/i915_pmu.c

1197

ret = perf_pmu_register(&pmu->base, pmu->name, -1);

drivers/gpu/drm/i915/i915_pmu.c

1201

pmu->registered = true;

drivers/gpu/drm/i915/i915_pmu.c

1206

kfree(pmu->base.attr_groups);

drivers/gpu/drm/i915/i915_pmu.c

1208

free_event_attributes(pmu);

drivers/gpu/drm/i915/i915_pmu.c

1211

kfree(pmu->name);

drivers/gpu/drm/i915/i915_pmu.c

1218

struct i915_pmu *pmu = &i915->pmu;

drivers/gpu/drm/i915/i915_pmu.c

1220

if (!pmu->registered)

drivers/gpu/drm/i915/i915_pmu.c

1224

pmu->registered = false;

drivers/gpu/drm/i915/i915_pmu.c

1226

hrtimer_cancel(&pmu->timer);

drivers/gpu/drm/i915/i915_pmu.c

1228

perf_pmu_unregister(&pmu->base);

drivers/gpu/drm/i915/i915_pmu.c

1229

kfree(pmu->base.attr_groups);

drivers/gpu/drm/i915/i915_pmu.c

1231

kfree(pmu->name);

drivers/gpu/drm/i915/i915_pmu.c

1232

free_event_attributes(pmu);

drivers/gpu/drm/i915/i915_pmu.c

151

static bool pmu_needs_timer(struct i915_pmu *pmu)

drivers/gpu/drm/i915/i915_pmu.c

153

struct drm_i915_private *i915 = pmu_to_i915(pmu);

drivers/gpu/drm/i915/i915_pmu.c

161

enable = pmu->enable;

drivers/gpu/drm/i915/i915_pmu.c

203

static u64 read_sample(struct i915_pmu *pmu, unsigned int gt_id, int sample)

drivers/gpu/drm/i915/i915_pmu.c

205

return pmu->sample[gt_id][sample].cur;

drivers/gpu/drm/i915/i915_pmu.c

209

store_sample(struct i915_pmu *pmu, unsigned int gt_id, int sample, u64 val)

drivers/gpu/drm/i915/i915_pmu.c

211

pmu->sample[gt_id][sample].cur = val;

drivers/gpu/drm/i915/i915_pmu.c

215

add_sample_mult(struct i915_pmu *pmu, unsigned int gt_id, int sample, u32 val, u32 mul)

drivers/gpu/drm/i915/i915_pmu.c

217

pmu->sample[gt_id][sample].cur += mul_u32_u32(val, mul);

drivers/gpu/drm/i915/i915_pmu.c

224

struct i915_pmu *pmu = &i915->pmu;

drivers/gpu/drm/i915/i915_pmu.c

235

spin_lock_irqsave(&pmu->lock, flags);

drivers/gpu/drm/i915/i915_pmu.c

238

store_sample(pmu, gt_id, __I915_SAMPLE_RC6, val);

drivers/gpu/drm/i915/i915_pmu.c

247

val = ktime_since_raw(pmu->sleep_last[gt_id]);

drivers/gpu/drm/i915/i915_pmu.c

248

val += read_sample(pmu, gt_id, __I915_SAMPLE_RC6);

drivers/gpu/drm/i915/i915_pmu.c

251

if (val < read_sample(pmu, gt_id, __I915_SAMPLE_RC6_LAST_REPORTED))

drivers/gpu/drm/i915/i915_pmu.c

252

val = read_sample(pmu, gt_id, __I915_SAMPLE_RC6_LAST_REPORTED);

drivers/gpu/drm/i915/i915_pmu.c

254

store_sample(pmu, gt_id, __I915_SAMPLE_RC6_LAST_REPORTED, val);

drivers/gpu/drm/i915/i915_pmu.c

256

spin_unlock_irqrestore(&pmu->lock, flags);

drivers/gpu/drm/i915/i915_pmu.c

261

static void init_rc6(struct i915_pmu *pmu)

drivers/gpu/drm/i915/i915_pmu.c

263

struct drm_i915_private *i915 = pmu_to_i915(pmu);

drivers/gpu/drm/i915/i915_pmu.c

273

store_sample(pmu, i, __I915_SAMPLE_RC6, val);

drivers/gpu/drm/i915/i915_pmu.c

274

store_sample(pmu, i, __I915_SAMPLE_RC6_LAST_REPORTED,

drivers/gpu/drm/i915/i915_pmu.c

276

pmu->sleep_last[i] = ktime_get_raw();

drivers/gpu/drm/i915/i915_pmu.c

283

struct i915_pmu *pmu = &gt->i915->pmu;

drivers/gpu/drm/i915/i915_pmu.c

285

store_sample(pmu, gt->info.id, __I915_SAMPLE_RC6, __get_rc6(gt));

drivers/gpu/drm/i915/i915_pmu.c

286

pmu->sleep_last[gt->info.id] = ktime_get_raw();

drivers/gpu/drm/i915/i915_pmu.c

289

static void __i915_pmu_maybe_start_timer(struct i915_pmu *pmu)

drivers/gpu/drm/i915/i915_pmu.c

291

if (!pmu->timer_enabled && pmu_needs_timer(pmu)) {

drivers/gpu/drm/i915/i915_pmu.c

292

pmu->timer_enabled = true;

drivers/gpu/drm/i915/i915_pmu.c

293

pmu->timer_last = ktime_get();

drivers/gpu/drm/i915/i915_pmu.c

294

hrtimer_start_range_ns(&pmu->timer,

drivers/gpu/drm/i915/i915_pmu.c

302

struct i915_pmu *pmu = &gt->i915->pmu;

drivers/gpu/drm/i915/i915_pmu.c

304

if (!pmu->registered)

drivers/gpu/drm/i915/i915_pmu.c

307

spin_lock_irq(&pmu->lock);

drivers/gpu/drm/i915/i915_pmu.c

315

pmu->unparked &= ~BIT(gt->info.id);

drivers/gpu/drm/i915/i915_pmu.c

316

if (pmu->unparked == 0)

drivers/gpu/drm/i915/i915_pmu.c

317

pmu->timer_enabled = false;

drivers/gpu/drm/i915/i915_pmu.c

319

spin_unlock_irq(&pmu->lock);

drivers/gpu/drm/i915/i915_pmu.c

324

struct i915_pmu *pmu = &gt->i915->pmu;

drivers/gpu/drm/i915/i915_pmu.c

326

if (!pmu->registered)

drivers/gpu/drm/i915/i915_pmu.c

329

spin_lock_irq(&pmu->lock);

drivers/gpu/drm/i915/i915_pmu.c

334

if (pmu->unparked == 0)

drivers/gpu/drm/i915/i915_pmu.c

335

__i915_pmu_maybe_start_timer(pmu);

drivers/gpu/drm/i915/i915_pmu.c

337

pmu->unparked |= BIT(gt->info.id);

drivers/gpu/drm/i915/i915_pmu.c

339

spin_unlock_irq(&pmu->lock);

drivers/gpu/drm/i915/i915_pmu.c

35

return container_of(event->pmu, struct i915_pmu, base);

drivers/gpu/drm/i915/i915_pmu.c

360

struct intel_engine_pmu *pmu = &engine->pmu;

drivers/gpu/drm/i915/i915_pmu.c

369

add_sample(&pmu->sample[I915_SAMPLE_WAIT], period_ns);

drivers/gpu/drm/i915/i915_pmu.c

371

add_sample(&pmu->sample[I915_SAMPLE_SEMA], period_ns);

drivers/gpu/drm/i915/i915_pmu.c

38

static struct drm_i915_private *pmu_to_i915(struct i915_pmu *pmu)

drivers/gpu/drm/i915/i915_pmu.c

390

add_sample(&pmu->sample[I915_SAMPLE_BUSY], period_ns);

drivers/gpu/drm/i915/i915_pmu.c

395

struct intel_engine_pmu *pmu = &engine->pmu;

drivers/gpu/drm/i915/i915_pmu.c

40

return container_of(pmu, struct drm_i915_private, pmu);

drivers/gpu/drm/i915/i915_pmu.c

403

add_sample(&pmu->sample[I915_SAMPLE_WAIT], period_ns);

drivers/gpu/drm/i915/i915_pmu.c

407

add_sample(&pmu->sample[I915_SAMPLE_BUSY], period_ns);

drivers/gpu/drm/i915/i915_pmu.c

426

if ((i915->pmu.enable & ENGINE_SAMPLE_MASK) == 0)

drivers/gpu/drm/i915/i915_pmu.c

433

if (!engine->pmu.enable)

drivers/gpu/drm/i915/i915_pmu.c

452

frequency_sampling_enabled(struct i915_pmu *pmu, unsigned int gt)

drivers/gpu/drm/i915/i915_pmu.c

454

return pmu->enable &

drivers/gpu/drm/i915/i915_pmu.c

464

struct i915_pmu *pmu = &i915->pmu;

drivers/gpu/drm/i915/i915_pmu.c

468

if (!frequency_sampling_enabled(pmu, gt_id))

drivers/gpu/drm/i915/i915_pmu.c

476

if (pmu->enable & config_mask(__I915_PMU_ACTUAL_FREQUENCY(gt_id))) {

drivers/gpu/drm/i915/i915_pmu.c

492

add_sample_mult(pmu, gt_id, __I915_SAMPLE_FREQ_ACT,

drivers/gpu/drm/i915/i915_pmu.c

496

if (pmu->enable & config_mask(__I915_PMU_REQUESTED_FREQUENCY(gt_id))) {

drivers/gpu/drm/i915/i915_pmu.c

497

add_sample_mult(pmu, gt_id, __I915_SAMPLE_FREQ_REQ,

drivers/gpu/drm/i915/i915_pmu.c

507

struct i915_pmu *pmu = container_of(hrtimer, struct i915_pmu, timer);

drivers/gpu/drm/i915/i915_pmu.c

508

struct drm_i915_private *i915 = pmu_to_i915(pmu);

drivers/gpu/drm/i915/i915_pmu.c

514

if (!READ_ONCE(pmu->timer_enabled))

drivers/gpu/drm/i915/i915_pmu.c

518

period_ns = ktime_to_ns(ktime_sub(now, pmu->timer_last));

drivers/gpu/drm/i915/i915_pmu.c

519

pmu->timer_last = now;

drivers/gpu/drm/i915/i915_pmu.c

529

if (!(pmu->unparked & BIT(i)))

drivers/gpu/drm/i915/i915_pmu.c

543

struct i915_pmu *pmu = event_to_pmu(event);

drivers/gpu/drm/i915/i915_pmu.c

544

struct drm_i915_private *i915 = pmu_to_i915(pmu);

drivers/gpu/drm/i915/i915_pmu.c

610

struct i915_pmu *pmu = event_to_pmu(event);

drivers/gpu/drm/i915/i915_pmu.c

611

struct drm_i915_private *i915 = pmu_to_i915(pmu);

drivers/gpu/drm/i915/i915_pmu.c

624

struct i915_pmu *pmu = event_to_pmu(event);

drivers/gpu/drm/i915/i915_pmu.c

625

struct drm_i915_private *i915 = pmu_to_i915(pmu);

drivers/gpu/drm/i915/i915_pmu.c

628

if (!pmu->registered)

drivers/gpu/drm/i915/i915_pmu.c

631

if (event->attr.type != event->pmu->type)

drivers/gpu/drm/i915/i915_pmu.c

661

struct i915_pmu *pmu = event_to_pmu(event);

drivers/gpu/drm/i915/i915_pmu.c

662

struct drm_i915_private *i915 = pmu_to_i915(pmu);

drivers/gpu/drm/i915/i915_pmu.c

682

val = engine->pmu.sample[sample].cur;

drivers/gpu/drm/i915/i915_pmu.c

691

div_u64(read_sample(pmu, gt_id,

drivers/gpu/drm/i915/i915_pmu.c

697

div_u64(read_sample(pmu, gt_id,

drivers/gpu/drm/i915/i915_pmu.c

702

val = READ_ONCE(pmu->irq_count);

drivers/gpu/drm/i915/i915_pmu.c

718

struct i915_pmu *pmu = event_to_pmu(event);

drivers/gpu/drm/i915/i915_pmu.c

722

if (!pmu->registered) {

drivers/gpu/drm/i915/i915_pmu.c

737

struct i915_pmu *pmu = event_to_pmu(event);

drivers/gpu/drm/i915/i915_pmu.c

738

struct drm_i915_private *i915 = pmu_to_i915(pmu);

drivers/gpu/drm/i915/i915_pmu.c

745

spin_lock_irqsave(&pmu->lock, flags);

drivers/gpu/drm/i915/i915_pmu.c

751

BUILD_BUG_ON(ARRAY_SIZE(pmu->enable_count) != I915_PMU_MASK_BITS);

drivers/gpu/drm/i915/i915_pmu.c

752

GEM_BUG_ON(bit >= ARRAY_SIZE(pmu->enable_count));

drivers/gpu/drm/i915/i915_pmu.c

753

GEM_BUG_ON(pmu->enable_count[bit] == ~0);

drivers/gpu/drm/i915/i915_pmu.c

755

pmu->enable |= BIT(bit);

drivers/gpu/drm/i915/i915_pmu.c

756

pmu->enable_count[bit]++;

drivers/gpu/drm/i915/i915_pmu.c

761

__i915_pmu_maybe_start_timer(pmu);

drivers/gpu/drm/i915/i915_pmu.c

775

BUILD_BUG_ON(ARRAY_SIZE(engine->pmu.enable_count) !=

drivers/gpu/drm/i915/i915_pmu.c

777

BUILD_BUG_ON(ARRAY_SIZE(engine->pmu.sample) !=

drivers/gpu/drm/i915/i915_pmu.c

779

GEM_BUG_ON(sample >= ARRAY_SIZE(engine->pmu.enable_count));

drivers/gpu/drm/i915/i915_pmu.c

780

GEM_BUG_ON(sample >= ARRAY_SIZE(engine->pmu.sample));

drivers/gpu/drm/i915/i915_pmu.c

781

GEM_BUG_ON(engine->pmu.enable_count[sample] == ~0);

drivers/gpu/drm/i915/i915_pmu.c

783

engine->pmu.enable |= BIT(sample);

drivers/gpu/drm/i915/i915_pmu.c

784

engine->pmu.enable_count[sample]++;

drivers/gpu/drm/i915/i915_pmu.c

787

spin_unlock_irqrestore(&pmu->lock, flags);

drivers/gpu/drm/i915/i915_pmu.c

800

struct i915_pmu *pmu = event_to_pmu(event);

drivers/gpu/drm/i915/i915_pmu.c

801

struct drm_i915_private *i915 = pmu_to_i915(pmu);

drivers/gpu/drm/i915/i915_pmu.c

808

spin_lock_irqsave(&pmu->lock, flags);

drivers/gpu/drm/i915/i915_pmu.c

818

GEM_BUG_ON(sample >= ARRAY_SIZE(engine->pmu.enable_count));

drivers/gpu/drm/i915/i915_pmu.c

819

GEM_BUG_ON(sample >= ARRAY_SIZE(engine->pmu.sample));

drivers/gpu/drm/i915/i915_pmu.c

820

GEM_BUG_ON(engine->pmu.enable_count[sample] == 0);

drivers/gpu/drm/i915/i915_pmu.c

826

if (--engine->pmu.enable_count[sample] == 0)

drivers/gpu/drm/i915/i915_pmu.c

827

engine->pmu.enable &= ~BIT(sample);

drivers/gpu/drm/i915/i915_pmu.c

830

GEM_BUG_ON(bit >= ARRAY_SIZE(pmu->enable_count));

drivers/gpu/drm/i915/i915_pmu.c

831

GEM_BUG_ON(pmu->enable_count[bit] == 0);

drivers/gpu/drm/i915/i915_pmu.c

836

if (--pmu->enable_count[bit] == 0) {

drivers/gpu/drm/i915/i915_pmu.c

837

pmu->enable &= ~BIT(bit);

drivers/gpu/drm/i915/i915_pmu.c

838

pmu->timer_enabled &= pmu_needs_timer(pmu);

drivers/gpu/drm/i915/i915_pmu.c

841

spin_unlock_irqrestore(&pmu->lock, flags);

drivers/gpu/drm/i915/i915_pmu.c

846

struct i915_pmu *pmu = event_to_pmu(event);

drivers/gpu/drm/i915/i915_pmu.c

848

if (!pmu->registered)

drivers/gpu/drm/i915/i915_pmu.c

857

struct i915_pmu *pmu = event_to_pmu(event);

drivers/gpu/drm/i915/i915_pmu.c

859

if (!pmu->registered)

drivers/gpu/drm/i915/i915_pmu.c

873

struct i915_pmu *pmu = event_to_pmu(event);

drivers/gpu/drm/i915/i915_pmu.c

875

if (!pmu->registered)

drivers/gpu/drm/i915/i915_pmu.c

981

create_event_attributes(struct i915_pmu *pmu)

drivers/gpu/drm/i915/i915_pmu.c

983

struct drm_i915_private *i915 = pmu_to_i915(pmu);

drivers/gpu/drm/i915/i915_pmu.h

62

struct pmu base;

drivers/gpu/drm/lima/lima_device.c

52

LIMA_IP_DESC(pmu, false, false, 0x02000, 0x02000, pmu, "pmu"),

drivers/gpu/drm/nouveau/include/nvkm/core/layout.h

24

NVKM_LAYOUT_ONCE(NVKM_SUBDEV_PMU , struct nvkm_pmu , pmu)

drivers/gpu/drm/nouveau/include/nvkm/subdev/gsp.h

261

struct dentry *pmu;

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

1113

.pmu = { 0x00000001, gt215_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

1146

.pmu = { 0x00000001, gt215_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

1178

.pmu = { 0x00000001, gt215_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

1272

.pmu = { 0x00000001, gt215_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

1306

.pmu = { 0x00000001, gf100_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

1341

.pmu = { 0x00000001, gf100_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

1376

.pmu = { 0x00000001, gf100_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

1411

.pmu = { 0x00000001, gf100_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

1446

.pmu = { 0x00000001, gf100_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

1481

.pmu = { 0x00000001, gf100_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

1516

.pmu = { 0x00000001, gf100_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

1585

.pmu = { 0x00000001, gf119_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

1620

.pmu = { 0x00000001, gk104_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

1656

.pmu = { 0x00000001, gk104_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

1692

.pmu = { 0x00000001, gk104_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

1721

.pmu = { 0x00000001, gk20a_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

1752

.pmu = { 0x00000001, gk110_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

1788

.pmu = { 0x00000001, gk110_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

1824

.pmu = { 0x00000001, gk208_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

1860

.pmu = { 0x00000001, gk208_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

1896

.pmu = { 0x00000001, gm107_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

1931

.pmu = { 0x00000001, gm107_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

1964

.pmu = { 0x00000001, gm200_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

1999

.pmu = { 0x00000001, gm200_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

2034

.pmu = { 0x00000001, gm200_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

2063

.pmu = { 0x00000001, gm20b_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

2094

.pmu = { 0x00000001, gm200_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

2127

.pmu = { 0x00000001, gp102_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

2161

.pmu = { 0x00000001, gp102_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

2195

.pmu = { 0x00000001, gp102_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

2229

.pmu = { 0x00000001, gp102_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

2263

.pmu = { 0x00000001, gp102_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

2291

.pmu = { 0x00000001, gp10b_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

2321

.pmu = { 0x00000001, gp102_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

2356

.pmu = { 0x00000001, gp102_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

2391

.pmu = { 0x00000001, gp102_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

2426

.pmu = { 0x00000001, gp102_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

2461

.pmu = { 0x00000001, gp102_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

2496

.pmu = { 0x00000001, gp102_pmu_new },

drivers/gpu/drm/nouveau/nvkm/engine/gr/gf100.c

2007

nvkm_pmu_pgob(device->pmu, false);

drivers/gpu/drm/nouveau/nvkm/engine/gr/gf100.c

2097

nvkm_pmu_pgob(gr->base.engine.subdev.device->pmu, false);

drivers/gpu/drm/nouveau/nvkm/subdev/acr/base.c

341

case NVKM_ACR_HSF_PMU : falcon = &device->pmu->falcon; break;

drivers/gpu/drm/nouveau/nvkm/subdev/devinit/gm200.c

101

pmu_code(init, pmu.boot_addr_pmu, pmu.boot_addr, pmu.boot_size, false);

drivers/gpu/drm/nouveau/nvkm/subdev/devinit/gm200.c

102

pmu_code(init, pmu.code_addr_pmu, pmu.code_addr, pmu.code_size, true);

drivers/gpu/drm/nouveau/nvkm/subdev/devinit/gm200.c

103

pmu_data(init, pmu.data_addr_pmu, pmu.data_addr, pmu.data_size);

drivers/gpu/drm/nouveau/nvkm/subdev/devinit/gm200.c

106

*init_addr_pmu = pmu.init_addr_pmu;

drivers/gpu/drm/nouveau/nvkm/subdev/devinit/gm200.c

107

*args_addr_pmu = pmu.args_addr_pmu;

drivers/gpu/drm/nouveau/nvkm/subdev/devinit/gm200.c

111

return pmu_exec(init, pmu.init_addr_pmu), 0;

drivers/gpu/drm/nouveau/nvkm/subdev/devinit/gm200.c

149

u32 pmu = pmu_args(init, args + 0x08, 0x08);

drivers/gpu/drm/nouveau/nvkm/subdev/devinit/gm200.c

152

pmu_data(init, pmu, img, len);

drivers/gpu/drm/nouveau/nvkm/subdev/devinit/gm200.c

157

u32 pmu = pmu_args(init, args + 0x08, 0x10);

drivers/gpu/drm/nouveau/nvkm/subdev/devinit/gm200.c

160

pmu_data(init, pmu, img, len);

drivers/gpu/drm/nouveau/nvkm/subdev/devinit/gm200.c

33

pmu_code(struct nv50_devinit *init, u32 pmu, u32 img, u32 len, bool sec)

drivers/gpu/drm/nouveau/nvkm/subdev/devinit/gm200.c

39

nvkm_wr32(device, 0x10a180, 0x01000000 | (sec ? 0x10000000 : 0) | pmu);

drivers/gpu/drm/nouveau/nvkm/subdev/devinit/gm200.c

42

nvkm_wr32(device, 0x10a188, (pmu + i) >> 8);

drivers/gpu/drm/nouveau/nvkm/subdev/devinit/gm200.c

53

pmu_data(struct nv50_devinit *init, u32 pmu, u32 img, u32 len)

drivers/gpu/drm/nouveau/nvkm/subdev/devinit/gm200.c

59

nvkm_wr32(device, 0x10a1c0, 0x01000000 | pmu);

drivers/gpu/drm/nouveau/nvkm/subdev/devinit/gm200.c

88

struct nvbios_pmuR pmu;

drivers/gpu/drm/nouveau/nvkm/subdev/devinit/gm200.c

91

if (!nvbios_pmuRm(bios, type, &pmu))

drivers/gpu/drm/nouveau/nvkm/subdev/devinit/gm200.c

94

if (!post || !subdev->device->pmu)

drivers/gpu/drm/nouveau/nvkm/subdev/devinit/gm200.c

97

ret = nvkm_falcon_reset(&subdev->device->pmu->falcon);

drivers/gpu/drm/nouveau/nvkm/subdev/fb/ramfuc.h

149

return nvkm_memx_train_result(fb->subdev.device->pmu, result, rsize);

drivers/gpu/drm/nouveau/nvkm/subdev/fb/ramfuc.h

61

int ret = nvkm_memx_init(fb->subdev.device->pmu, &ram->memx);

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1405

gsp->debugfs.pmu = create_debugfs(gsp, "logpmu", &gsp->blob_pmu);

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1406

if (!gsp->debugfs.pmu) {

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1414

i_size_write(d_inode(gsp->debugfs.pmu), gsp->blob_pmu.size);

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

2019

debugfs_remove(gsp->debugfs.pmu);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

101

return pmu->func->init(pmu);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

107

struct nvkm_pmu *pmu = nvkm_pmu(subdev);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

108

nvkm_falcon_msgq_del(&pmu->msgq);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

109

nvkm_falcon_cmdq_del(&pmu->lpq);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

110

nvkm_falcon_cmdq_del(&pmu->hpq);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

111

nvkm_falcon_qmgr_del(&pmu->qmgr);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

112

nvkm_falcon_dtor(&pmu->falcon);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

113

mutex_destroy(&pmu->send.mutex);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

127

enum nvkm_subdev_type type, int inst, struct nvkm_pmu *pmu)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

131

nvkm_subdev_ctor(&nvkm_pmu, device, type, inst, &pmu->subdev);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

133

mutex_init(&pmu->send.mutex);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

135

INIT_WORK(&pmu->recv.work, nvkm_pmu_recv);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

136

init_waitqueue_head(&pmu->recv.wait);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

138

fwif = nvkm_firmware_load(&pmu->subdev, fwif, "Pmu", pmu);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

142

pmu->func = fwif->func;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

144

ret = nvkm_falcon_ctor(pmu->func->flcn, &pmu->subdev, pmu->subdev.name,

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

145

0x10a000, &pmu->falcon);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

149

if ((ret = nvkm_falcon_qmgr_new(&pmu->falcon, &pmu->qmgr)) ||

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

150

(ret = nvkm_falcon_cmdq_new(pmu->qmgr, "hpq", &pmu->hpq)) ||

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

151

(ret = nvkm_falcon_cmdq_new(pmu->qmgr, "lpq", &pmu->lpq)) ||

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

152

(ret = nvkm_falcon_msgq_new(pmu->qmgr, "msgq", &pmu->msgq)))

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

155

init_completion(&pmu->wpr_ready);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

163

struct nvkm_pmu *pmu;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

164

if (!(pmu = *ppmu = kzalloc_obj(*pmu)))

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

32

struct nvkm_pmu *pmu = device->pmu;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

37

if (pmu && pmu->func->code.size)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

48

nvkm_pmu_pgob(struct nvkm_pmu *pmu, bool enable)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

50

if (pmu && pmu->func->pgob)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

51

pmu->func->pgob(pmu, enable);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

57

struct nvkm_pmu *pmu = container_of(work, typeof(*pmu), recv.work);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

58

return pmu->func->recv(pmu);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

62

nvkm_pmu_send(struct nvkm_pmu *pmu, u32 reply[2],

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

65

if (!pmu || !pmu->func->send)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

67

return pmu->func->send(pmu, reply, process, message, data0, data1);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

73

struct nvkm_pmu *pmu = nvkm_pmu(subdev);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

74

if (!pmu->func->intr)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

76

pmu->func->intr(pmu);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

82

struct nvkm_pmu *pmu = nvkm_pmu(subdev);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

87

if (pmu->func->fini)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

88

pmu->func->fini(pmu);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

96

struct nvkm_pmu *pmu = nvkm_pmu(subdev);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

98

if (!pmu->func->init)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gf100.c

30

gf100_pmu_reset(struct nvkm_pmu *pmu)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gf100.c

32

struct nvkm_device *device = pmu->subdev.device;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gf100.c

38

gf100_pmu_enabled(struct nvkm_pmu *pmu)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gf100.c

40

return nvkm_mc_enabled(pmu->subdev.device, NVKM_SUBDEV_PMU, 0);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gf100.c

60

gf100_pmu_nofw(struct nvkm_pmu *pmu, int ver, const struct nvkm_pmu_fwif *fwif)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk104.c

57

gk104_pmu_pgob(struct nvkm_pmu *pmu, bool enable)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk104.c

59

struct nvkm_device *device = pmu->subdev.device;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk110.c

32

gk110_pmu_pgob(struct nvkm_pmu *pmu, bool enable)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk110.c

34

struct nvkm_device *device = pmu->subdev.device;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

105

gk20a_pmu_dvfs_reset_dev_status(struct gk20a_pmu *pmu)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

107

struct nvkm_falcon *falcon = &pmu->base.falcon;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

116

struct gk20a_pmu *pmu =

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

118

struct gk20a_pmu_dvfs_data *data = pmu->data;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

120

struct nvkm_subdev *subdev = &pmu->base.subdev;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

135

gk20a_pmu_dvfs_get_dev_status(pmu, &status);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

145

gk20a_pmu_dvfs_get_cur_state(pmu, &state);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

147

if (gk20a_pmu_dvfs_get_target_state(pmu, &state, data->avg_load)) {

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

149

gk20a_pmu_dvfs_target(pmu, &state);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

153

gk20a_pmu_dvfs_reset_dev_status(pmu);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

158

gk20a_pmu_fini(struct nvkm_pmu *pmu)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

160

struct gk20a_pmu *gpmu = gk20a_pmu(pmu);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

161

nvkm_timer_alarm(pmu->subdev.device->timer, 0, &gpmu->alarm);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

163

nvkm_falcon_put(&pmu->falcon, &pmu->subdev);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

167

gk20a_pmu_init(struct nvkm_pmu *pmu)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

169

struct gk20a_pmu *gpmu = gk20a_pmu(pmu);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

170

struct nvkm_subdev *subdev = &pmu->subdev;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

171

struct nvkm_device *device = pmu->subdev.device;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

172

struct nvkm_falcon *falcon = &pmu->falcon;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

215

struct gk20a_pmu *pmu;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

218

if (!(pmu = kzalloc_obj(*pmu)))

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

220

*ppmu = &pmu->base;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

222

ret = nvkm_pmu_ctor(gk20a_pmu_fwif, device, type, inst, &pmu->base);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

226

pmu->data = &gk20a_dvfs_data;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

227

nvkm_alarm_init(&pmu->alarm, gk20a_pmu_dvfs_work);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

51

gk20a_pmu_dvfs_target(struct gk20a_pmu *pmu, int *state)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

53

struct nvkm_clk *clk = pmu->base.subdev.device->clk;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

59

gk20a_pmu_dvfs_get_cur_state(struct gk20a_pmu *pmu, int *state)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

61

struct nvkm_clk *clk = pmu->base.subdev.device->clk;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

67

gk20a_pmu_dvfs_get_target_state(struct gk20a_pmu *pmu,

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

70

struct gk20a_pmu_dvfs_data *data = pmu->data;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

71

struct nvkm_clk *clk = pmu->base.subdev.device->clk;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

86

nvkm_trace(&pmu->base.subdev, "cur level = %d, new level = %d\n",

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

95

gk20a_pmu_dvfs_get_dev_status(struct gk20a_pmu *pmu,

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gk20a.c

98

struct nvkm_falcon *falcon = &pmu->base.falcon;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm200.c

68

gm200_pmu_nofw(struct nvkm_pmu *pmu, int ver, const struct nvkm_pmu_fwif *fwif)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm200.c

70

nvkm_warn(&pmu->subdev, "firmware unavailable\n");

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

129

struct nvkm_pmu *pmu = priv;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

130

struct nvkm_subdev *subdev = &pmu->subdev;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

139

complete_all(&pmu->wpr_ready);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

144

gm20b_pmu_acr_init_wpr(struct nvkm_pmu *pmu)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

154

return nvkm_falcon_cmdq_send(pmu->hpq, &cmd.cmd.hdr,

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

155

gm20b_pmu_acr_init_wpr_callback, pmu, 0);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

159

gm20b_pmu_initmsg(struct nvkm_pmu *pmu)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

164

ret = nvkm_falcon_msgq_recv_initmsg(pmu->msgq, &msg, sizeof(msg));

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

172

nvkm_falcon_cmdq_init(pmu->hpq, msg.queue_info[0].index,

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

175

nvkm_falcon_cmdq_init(pmu->lpq, msg.queue_info[1].index,

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

178

nvkm_falcon_msgq_init(pmu->msgq, msg.queue_info[4].index,

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

181

return gm20b_pmu_acr_init_wpr(pmu);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

185

gm20b_pmu_recv(struct nvkm_pmu *pmu)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

187

if (!pmu->initmsg_received) {

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

188

int ret = pmu->func->initmsg(pmu);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

190

nvkm_error(&pmu->subdev, "error parsing init message: %d\n", ret);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

194

pmu->initmsg_received = true;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

197

nvkm_falcon_msgq_recv(pmu->msgq);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

201

gm20b_pmu_fini(struct nvkm_pmu *pmu)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

205

flush_work(&pmu->recv.work);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

206

nvkm_falcon_cmdq_fini(pmu->lpq);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

207

nvkm_falcon_cmdq_fini(pmu->hpq);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

209

reinit_completion(&pmu->wpr_ready);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

211

nvkm_falcon_put(&pmu->falcon, &pmu->subdev);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

215

gm20b_pmu_init(struct nvkm_pmu *pmu)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

217

struct nvkm_falcon *falcon = &pmu->falcon;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

222

ret = nvkm_falcon_get(&pmu->falcon, &pmu->subdev);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

226

pmu->initmsg_received = false;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

251

gm20b_pmu_load(struct nvkm_pmu *pmu, int ver, const struct nvkm_pmu_fwif *fwif)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

253

return nvkm_acr_lsfw_load_sig_image_desc(&pmu->subdev, &pmu->falcon,

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

42

struct nvkm_pmu *pmu = container_of(falcon, typeof(*pmu), falcon);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

52

ret = nvkm_falcon_cmdq_send(pmu->hpq, &cmd.cmd.hdr,

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm20b.c

54

&pmu->subdev, msecs_to_jiffies(1000));

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gp10b.c

40

struct nvkm_pmu *pmu = container_of(falcon, typeof(*pmu), falcon);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gp10b.c

52

ret = nvkm_falcon_cmdq_send(pmu->hpq, &cmd.cmd.hdr,

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gp10b.c

54

&pmu->subdev, msecs_to_jiffies(1000));

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

105

pmu->recv.base));

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

116

if (pmu->recv.process) {

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

117

if (process == pmu->recv.process &&

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

118

message == pmu->recv.message) {

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

119

pmu->recv.data[0] = data0;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

120

pmu->recv.data[1] = data1;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

121

pmu->recv.process = 0;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

122

wake_up(&pmu->recv.wait);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

139

gt215_pmu_intr(struct nvkm_pmu *pmu)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

141

struct nvkm_subdev *subdev = &pmu->subdev;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

158

schedule_work(&pmu->recv.work);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

178

gt215_pmu_fini(struct nvkm_pmu *pmu)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

180

nvkm_wr32(pmu->subdev.device, 0x10a014, 0x00000060);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

181

flush_work(&pmu->recv.work);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

185

gt215_pmu_reset(struct nvkm_pmu *pmu)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

187

struct nvkm_device *device = pmu->subdev.device;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

195

gt215_pmu_enabled(struct nvkm_pmu *pmu)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

197

return nvkm_rd32(pmu->subdev.device, 0x022210) & 0x00000001;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

201

gt215_pmu_init(struct nvkm_pmu *pmu)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

203

struct nvkm_device *device = pmu->subdev.device;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

207

if (pmu->func->enabled(pmu)) {

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

215

pmu->func->reset(pmu);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

225

for (i = 0; i < pmu->func->data.size / 4; i++)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

226

nvkm_wr32(device, 0x10a1c4, pmu->func->data.data[i]);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

230

for (i = 0; i < pmu->func->code.size / 4; i++) {

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

233

nvkm_wr32(device, 0x10a184, pmu->func->code.data[i]);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

247

pmu->send.base = nvkm_rd32(device, 0x10a4d0) & 0x0000ffff;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

248

pmu->send.size = nvkm_rd32(device, 0x10a4d0) >> 16;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

256

pmu->recv.base = nvkm_rd32(device, 0x10a4dc) & 0x0000ffff;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

257

pmu->recv.size = nvkm_rd32(device, 0x10a4dc) >> 16;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

30

gt215_pmu_send(struct nvkm_pmu *pmu, u32 reply[2],

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

33

struct nvkm_subdev *subdev = &pmu->subdev;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

37

mutex_lock(&pmu->send.mutex);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

45

mutex_unlock(&pmu->send.mutex);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

54

pmu->recv.message = message;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

55

pmu->recv.process = process;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

65

pmu->send.base));

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

77

wait_event(pmu->recv.wait, (pmu->recv.process == 0));

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

78

reply[0] = pmu->recv.data[0];

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

79

reply[1] = pmu->recv.data[1];

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

82

mutex_unlock(&pmu->send.mutex);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

87

gt215_pmu_recv(struct nvkm_pmu *pmu)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gt215.c

89

struct nvkm_subdev *subdev = &pmu->subdev;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/memx.c

102

nvkm_debug(&memx->pmu->subdev, "R[%06x] = %08x\n", addr, data);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/memx.c

110

nvkm_debug(&memx->pmu->subdev, "R[%06x] & %08x == %08x, %d us\n",

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/memx.c

119

nvkm_debug(&memx->pmu->subdev, " DELAY = %d ns\n", nsec);

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/memx.c

127

struct nvkm_subdev *subdev = &memx->pmu->subdev;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/memx.c

161

nvkm_debug(&memx->pmu->subdev, " MEM TRAIN\n");

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/memx.c

166

nvkm_memx_train_result(struct nvkm_pmu *pmu, u32 *res, int rsize)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/memx.c

168

struct nvkm_device *device = pmu->subdev.device;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/memx.c

172

ret = nvkm_pmu_send(pmu, reply, PROC_MEMX, MEMX_MSG_INFO,

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/memx.c

194

nvkm_debug(&memx->pmu->subdev, " HOST BLOCKED\n");

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/memx.c

20

struct nvkm_device *device = memx->pmu->subdev.device;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/memx.c

201

nvkm_debug(&memx->pmu->subdev, " HOST UNBLOCKED\n");

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/memx.c

44

nvkm_memx_init(struct nvkm_pmu *pmu, struct nvkm_memx **pmemx)

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/memx.c

46

struct nvkm_device *device = pmu->subdev.device;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/memx.c

51

ret = nvkm_pmu_send(pmu, reply, PROC_MEMX, MEMX_MSG_INFO,

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/memx.c

59

memx->pmu = pmu;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/memx.c

7

struct nvkm_pmu *pmu;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/memx.c

75

struct nvkm_pmu *pmu = memx->pmu;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/memx.c

76

struct nvkm_subdev *subdev = &pmu->subdev;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/memx.c

89

nvkm_pmu_send(pmu, reply, PROC_MEMX, MEMX_MSG_EXEC,

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/priv.h

44

void gp102_pmu_reset(struct nvkm_pmu *pmu);

drivers/gpu/drm/xe/xe_device.c

995

err = xe_pmu_register(&xe->pmu);

drivers/gpu/drm/xe/xe_device_types.h

666

struct xe_pmu pmu;

drivers/gpu/drm/xe/xe_pmu.c

101

struct xe_device *xe = container_of(event->pmu, typeof(*xe), pmu.base);

drivers/gpu/drm/xe/xe_pmu.c

135

struct xe_device *xe = container_of(event->pmu, typeof(*xe), pmu.base);

drivers/gpu/drm/xe/xe_pmu.c

160

static bool event_supported(struct xe_pmu *pmu, unsigned int gt_id,

drivers/gpu/drm/xe/xe_pmu.c

163

struct xe_device *xe = container_of(pmu, typeof(*xe), pmu);

drivers/gpu/drm/xe/xe_pmu.c

169

return id < sizeof(pmu->supported_events) * BITS_PER_BYTE &&

drivers/gpu/drm/xe/xe_pmu.c

170

pmu->supported_events & BIT_ULL(id);

drivers/gpu/drm/xe/xe_pmu.c

175

struct xe_device *xe = container_of(event->pmu, typeof(*xe), pmu.base);

drivers/gpu/drm/xe/xe_pmu.c

216

struct xe_device *xe = container_of(event->pmu, typeof(*xe), pmu.base);

drivers/gpu/drm/xe/xe_pmu.c

234

struct xe_device *xe = container_of(event->pmu, typeof(*xe), pmu.base);

drivers/gpu/drm/xe/xe_pmu.c

235

struct xe_pmu *pmu = &xe->pmu;

drivers/gpu/drm/xe/xe_pmu.c

238

if (!pmu->registered)

drivers/gpu/drm/xe/xe_pmu.c

241

if (event->attr.type != event->pmu->type)

drivers/gpu/drm/xe/xe_pmu.c

253

if (!event_supported(pmu, gt, id))

drivers/gpu/drm/xe/xe_pmu.c

338

struct xe_device *xe = container_of(event->pmu, typeof(*xe), pmu.base);

drivers/gpu/drm/xe/xe_pmu.c

339

struct xe_pmu *pmu = &xe->pmu;

drivers/gpu/drm/xe/xe_pmu.c

341

if (!pmu->registered) {

drivers/gpu/drm/xe/xe_pmu.c

361

struct xe_device *xe = container_of(event->pmu, typeof(*xe), pmu.base);

drivers/gpu/drm/xe/xe_pmu.c

362

struct xe_pmu *pmu = &xe->pmu;

drivers/gpu/drm/xe/xe_pmu.c

364

if (!pmu->registered)

drivers/gpu/drm/xe/xe_pmu.c

373

struct xe_device *xe = container_of(event->pmu, typeof(*xe), pmu.base);

drivers/gpu/drm/xe/xe_pmu.c

374

struct xe_pmu *pmu = &xe->pmu;

drivers/gpu/drm/xe/xe_pmu.c

376

if (pmu->registered)

drivers/gpu/drm/xe/xe_pmu.c

385

struct xe_device *xe = container_of(event->pmu, typeof(*xe), pmu.base);

drivers/gpu/drm/xe/xe_pmu.c

386

struct xe_pmu *pmu = &xe->pmu;

drivers/gpu/drm/xe/xe_pmu.c

388

if (!pmu->registered)

drivers/gpu/drm/xe/xe_pmu.c

446

struct xe_pmu *pmu; \

drivers/gpu/drm/xe/xe_pmu.c

449

pmu = container_of(dev_get_drvdata(kobj_to_dev(kobj)), \

drivers/gpu/drm/xe/xe_pmu.c

450

typeof(*pmu), base); \

drivers/gpu/drm/xe/xe_pmu.c

452

return event_supported(pmu, 0, id_) ? attr->mode : 0; \

drivers/gpu/drm/xe/xe_pmu.c

497

static void set_supported_events(struct xe_pmu *pmu)

drivers/gpu/drm/xe/xe_pmu.c

499

struct xe_device *xe = container_of(pmu, typeof(*xe), pmu);

drivers/gpu/drm/xe/xe_pmu.c

508

pmu->supported_events |= BIT_ULL(XE_PMU_EVENT_GT_C6_RESIDENCY);

drivers/gpu/drm/xe/xe_pmu.c

509

pmu->supported_events |= BIT_ULL(XE_PMU_EVENT_GT_ACTUAL_FREQUENCY);

drivers/gpu/drm/xe/xe_pmu.c

510

pmu->supported_events |= BIT_ULL(XE_PMU_EVENT_GT_REQUESTED_FREQUENCY);

drivers/gpu/drm/xe/xe_pmu.c

518

pmu->supported_events |= BIT_ULL(XE_PMU_EVENT_ENGINE_ACTIVE_TICKS);

drivers/gpu/drm/xe/xe_pmu.c

519

pmu->supported_events |= BIT_ULL(XE_PMU_EVENT_ENGINE_TOTAL_TICKS);

drivers/gpu/drm/xe/xe_pmu.c

529

struct xe_pmu *pmu = arg;

drivers/gpu/drm/xe/xe_pmu.c

530

struct xe_device *xe = container_of(pmu, typeof(*xe), pmu);

drivers/gpu/drm/xe/xe_pmu.c

532

if (!pmu->registered)

drivers/gpu/drm/xe/xe_pmu.c

535

pmu->registered = false;

drivers/gpu/drm/xe/xe_pmu.c

537

perf_pmu_unregister(&pmu->base);

drivers/gpu/drm/xe/xe_pmu.c

538

kfree(pmu->name);

drivers/gpu/drm/xe/xe_pmu.c

547

int xe_pmu_register(struct xe_pmu *pmu)

drivers/gpu/drm/xe/xe_pmu.c

549

struct xe_device *xe = container_of(pmu, typeof(*xe), pmu);

drivers/gpu/drm/xe/xe_pmu.c

571

pmu->name = name;

drivers/gpu/drm/xe/xe_pmu.c

572

pmu->base.attr_groups = attr_groups;

drivers/gpu/drm/xe/xe_pmu.c

573

pmu->base.attr_update = pmu_events_attr_update;

drivers/gpu/drm/xe/xe_pmu.c

574

pmu->base.scope = PERF_PMU_SCOPE_SYS_WIDE;

drivers/gpu/drm/xe/xe_pmu.c

575

pmu->base.module = THIS_MODULE;

drivers/gpu/drm/xe/xe_pmu.c

576

pmu->base.task_ctx_nr = perf_invalid_context;

drivers/gpu/drm/xe/xe_pmu.c

577

pmu->base.event_init = xe_pmu_event_init;

drivers/gpu/drm/xe/xe_pmu.c

578

pmu->base.add = xe_pmu_event_add;

drivers/gpu/drm/xe/xe_pmu.c

579

pmu->base.del = xe_pmu_event_del;

drivers/gpu/drm/xe/xe_pmu.c

580

pmu->base.start = xe_pmu_event_start;

drivers/gpu/drm/xe/xe_pmu.c

581

pmu->base.stop = xe_pmu_event_stop;

drivers/gpu/drm/xe/xe_pmu.c

582

pmu->base.read = xe_pmu_event_read;

drivers/gpu/drm/xe/xe_pmu.c

584

set_supported_events(pmu);

drivers/gpu/drm/xe/xe_pmu.c

586

ret = perf_pmu_register(&pmu->base, pmu->name, -1);

drivers/gpu/drm/xe/xe_pmu.c

590

pmu->registered = true;

drivers/gpu/drm/xe/xe_pmu.c

592

return devm_add_action_or_reset(xe->drm.dev, xe_pmu_unregister, pmu);

drivers/gpu/drm/xe/xe_pmu.c

93

struct xe_device *xe = container_of(event->pmu, typeof(*xe), pmu.base);

drivers/gpu/drm/xe/xe_pmu.h

12

int xe_pmu_register(struct xe_pmu *pmu);

drivers/gpu/drm/xe/xe_pmu.h

14

static inline int xe_pmu_register(struct xe_pmu *pmu) { return 0; }

drivers/gpu/drm/xe/xe_pmu_types.h

24

struct pmu base;

drivers/hwtracing/coresight/coresight-etm-perf.c

29

static struct pmu etm_pmu;

drivers/hwtracing/ptt/hisi_ptt.c

1005

dev_dbg(event->pmu->dev, "Per-task mode not supported\n");

drivers/hwtracing/ptt/hisi_ptt.c

1038

dev_warn(event->pmu->dev, "Overwrite mode is not supported\n");

drivers/hwtracing/ptt/hisi_ptt.c

1084

struct hisi_ptt *hisi_ptt = to_hisi_ptt(event->pmu);

drivers/hwtracing/ptt/hisi_ptt.c

1087

struct device *dev = event->pmu->dev;

drivers/hwtracing/ptt/hisi_ptt.c

1139

struct hisi_ptt *hisi_ptt = to_hisi_ptt(event->pmu);

drivers/hwtracing/ptt/hisi_ptt.c

1150

dev_warn(event->pmu->dev, "Device is still busy\n");

drivers/hwtracing/ptt/hisi_ptt.c

1163

struct hisi_ptt *hisi_ptt = to_hisi_ptt(event->pmu);

drivers/hwtracing/ptt/hisi_ptt.c

1196

static void hisi_ptt_unregister_pmu(void *pmu)

drivers/hwtracing/ptt/hisi_ptt.c

1198

perf_pmu_unregister(pmu);

drivers/hwtracing/ptt/hisi_ptt.c

1222

hisi_ptt->hisi_ptt_pmu = (struct pmu) {

drivers/hwtracing/ptt/hisi_ptt.c

997

struct hisi_ptt *hisi_ptt = to_hisi_ptt(event->pmu);

drivers/hwtracing/ptt/hisi_ptt.h

221

struct pmu hisi_ptt_pmu;

drivers/hwtracing/ptt/hisi_ptt.h

255

#define to_hisi_ptt(pmu) container_of(pmu, struct hisi_ptt, hisi_ptt_pmu)

drivers/iommu/intel/iommu.h

678

struct pmu pmu;

drivers/iommu/intel/iommu.h

741

struct iommu_pmu *pmu;

drivers/iommu/intel/perfmon.c

228

return container_of(event->pmu, struct iommu_pmu, pmu);

drivers/iommu/intel/perfmon.c

243

return event->pmu == &iommu_pmu->pmu;

drivers/iommu/intel/perfmon.c

283

if (event->attr.type != event->pmu->type)

drivers/iommu/intel/perfmon.c

473

static void iommu_pmu_enable(struct pmu *pmu)

drivers/iommu/intel/perfmon.c

475

struct iommu_pmu *iommu_pmu = container_of(pmu, struct iommu_pmu, pmu);

drivers/iommu/intel/perfmon.c

481

static void iommu_pmu_disable(struct pmu *pmu)

drivers/iommu/intel/perfmon.c

483

struct iommu_pmu *iommu_pmu = container_of(pmu, struct iommu_pmu, pmu);

drivers/iommu/intel/perfmon.c

49

return container_of(dev_get_drvdata(dev), struct iommu_pmu, pmu);

drivers/iommu/intel/perfmon.c

524

iommu_pmu_counter_overflow(iommu->pmu);

drivers/iommu/intel/perfmon.c

534

struct iommu_pmu *iommu_pmu = iommu->pmu;

drivers/iommu/intel/perfmon.c

536

iommu_pmu->pmu.name = iommu->name;

drivers/iommu/intel/perfmon.c

537

iommu_pmu->pmu.task_ctx_nr = perf_invalid_context;

drivers/iommu/intel/perfmon.c

538

iommu_pmu->pmu.event_init = iommu_pmu_event_init;

drivers/iommu/intel/perfmon.c

539

iommu_pmu->pmu.pmu_enable = iommu_pmu_enable;

drivers/iommu/intel/perfmon.c

540

iommu_pmu->pmu.pmu_disable = iommu_pmu_disable;

drivers/iommu/intel/perfmon.c

541

iommu_pmu->pmu.add = iommu_pmu_add;

drivers/iommu/intel/perfmon.c

542

iommu_pmu->pmu.del = iommu_pmu_del;

drivers/iommu/intel/perfmon.c

543

iommu_pmu->pmu.start = iommu_pmu_start;

drivers/iommu/intel/perfmon.c

544

iommu_pmu->pmu.stop = iommu_pmu_stop;

drivers/iommu/intel/perfmon.c

545

iommu_pmu->pmu.read = iommu_pmu_event_update;

drivers/iommu/intel/perfmon.c

546

iommu_pmu->pmu.attr_groups = iommu_pmu_attr_groups;

drivers/iommu/intel/perfmon.c

547

iommu_pmu->pmu.attr_update = iommu_pmu_attr_update;

drivers/iommu/intel/perfmon.c

548

iommu_pmu->pmu.capabilities = PERF_PMU_CAP_NO_EXCLUDE;

drivers/iommu/intel/perfmon.c

549

iommu_pmu->pmu.scope = PERF_PMU_SCOPE_SYS_WIDE;

drivers/iommu/intel/perfmon.c

550

iommu_pmu->pmu.module = THIS_MODULE;

drivers/iommu/intel/perfmon.c

552

return perf_pmu_register(&iommu_pmu->pmu, iommu_pmu->pmu.name, -1);

drivers/iommu/intel/perfmon.c

691

iommu->pmu = iommu_pmu;

drivers/iommu/intel/perfmon.c

709

struct iommu_pmu *iommu_pmu = iommu->pmu;

drivers/iommu/intel/perfmon.c

723

iommu->pmu = NULL;

drivers/iommu/intel/perfmon.c

728

struct iommu_pmu *iommu_pmu = iommu->pmu;

drivers/iommu/intel/perfmon.c

760

struct iommu_pmu *iommu_pmu = iommu->pmu;

drivers/iommu/intel/perfmon.c

775

perf_pmu_unregister(&iommu_pmu->pmu);

drivers/iommu/intel/perfmon.c

783

struct iommu_pmu *iommu_pmu = iommu->pmu;

drivers/iommu/intel/perfmon.c

789

perf_pmu_unregister(&iommu_pmu->pmu);

drivers/media/cec/platform/s5p/exynos_hdmi_cecctrl.c

30

if (regmap_read(cec->pmu, EXYNOS_HDMI_PHY_CONTROL, &reg)) {

drivers/media/cec/platform/s5p/exynos_hdmi_cecctrl.c

37

if (regmap_write(cec->pmu, EXYNOS_HDMI_PHY_CONTROL, reg)) {

drivers/media/cec/platform/s5p/s5p_cec.c

211

cec->pmu = syscon_regmap_lookup_by_phandle(dev->of_node,

drivers/media/cec/platform/s5p/s5p_cec.c

213

if (IS_ERR(cec->pmu))

drivers/media/cec/platform/s5p/s5p_cec.h

66

struct regmap *pmu;

drivers/net/wireless/broadcom/b43/phy_lp.c

1275

u32 crystal_freq = bus->chipco.pmu.crystalfreq * 1000;

drivers/net/wireless/broadcom/b43/phy_lp.c

2392

u32 crystal_freq = bus->chipco.pmu.crystalfreq * 1000;

drivers/net/wireless/broadcom/b43/phy_lp.c

2483

u32 crystal_freq = bus->chipco.pmu.crystalfreq * 1000;

drivers/net/wireless/broadcom/b43/phy_lp.c

544

crystalfreq = bus->chipco.pmu.crystalfreq * 1000;

drivers/net/wireless/broadcom/brcm80211/brcmfmac/chip.c

1088

struct brcmf_core *pmu;

drivers/net/wireless/broadcom/brcm80211/brcmfmac/chip.c

1105

pmu = brcmf_chip_get_pmu(pub); /* after reading cc_caps_ext */

drivers/net/wireless/broadcom/brcm80211/brcmfmac/chip.c

1108

CORE_CC_REG(pmu->base, pmucapabilities));

drivers/net/wireless/broadcom/brcm80211/brcmfmac/chip.c

1226

struct brcmf_core *pmu;

drivers/net/wireless/broadcom/brcm80211/brcmfmac/chip.c

1231

pmu = brcmf_chip_get_core(pub, BCMA_CORE_PMU);

drivers/net/wireless/broadcom/brcm80211/brcmfmac/chip.c

1232

if (pmu)

drivers/net/wireless/broadcom/brcm80211/brcmfmac/chip.c

1233

return pmu;

drivers/net/wireless/broadcom/brcm80211/brcmfmac/chip.c

1414

struct brcmf_core *pmu = brcmf_chip_get_pmu(pub);

drivers/net/wireless/broadcom/brcm80211/brcmfmac/chip.c

1437

addr = CORE_CC_REG(pmu->base, chipcontrol_addr);

drivers/net/wireless/broadcom/brcm80211/brcmfmac/chip.c

1439

addr = CORE_CC_REG(pmu->base, chipcontrol_data);

drivers/net/wireless/broadcom/brcm80211/brcmfmac/chip.c

1457

addr = CORE_CC_REG(pmu->base, retention_ctl);

drivers/net/wireless/broadcom/brcm80211/brcmfmac/chip.c

1462

addr = CORE_CC_REG(pmu->base, pmucapabilities_ext);

drivers/net/wireless/broadcom/brcm80211/brcmfmac/chip.c

1467

addr = CORE_CC_REG(pmu->base, retention_ctl);

drivers/net/wireless/broadcom/brcm80211/brcmfmac/sdio.c

3824

struct brcmf_core *pmu = brcmf_chip_get_pmu(ci);

drivers/net/wireless/broadcom/brcm80211/brcmfmac/sdio.c

3832

addr = CORE_CC_REG(pmu->base, chipcontrol_addr);

drivers/net/wireless/broadcom/brcm80211/brcmfmac/sdio.c

558

#define SDIOD_DRVSTR_KEY(chip, pmu) (((unsigned int)(chip) << 16) | (pmu))

drivers/nvdimm/nd_perf.c

121

struct pmu *pmu = dev_get_drvdata(dev);

drivers/nvdimm/nd_perf.c

124

nd_pmu = container_of(pmu, struct nvdimm_pmu, pmu);

drivers/nvdimm/nd_perf.c

164

perf_pmu_migrate_context(&nd_pmu->pmu, cpu, target);

drivers/nvdimm/nd_perf.c

213

nd_pmu->pmu.attr_groups[NVDIMM_PMU_CPUMASK_ATTR] = nvdimm_pmu_cpumask_group;

drivers/nvdimm/nd_perf.c

268

if (nd_pmu->pmu.attr_groups[NVDIMM_PMU_CPUMASK_ATTR])

drivers/nvdimm/nd_perf.c

269

kfree(nd_pmu->pmu.attr_groups[NVDIMM_PMU_CPUMASK_ATTR]->attrs);

drivers/nvdimm/nd_perf.c

270

kfree(nd_pmu->pmu.attr_groups[NVDIMM_PMU_CPUMASK_ATTR]);

drivers/nvdimm/nd_perf.c

281

if (WARN_ON_ONCE(!(nd_pmu->pmu.event_init && nd_pmu->pmu.add &&

drivers/nvdimm/nd_perf.c

282

nd_pmu->pmu.del && nd_pmu->pmu.read && nd_pmu->pmu.name)))

drivers/nvdimm/nd_perf.c

285

nd_pmu->pmu.attr_groups = kzalloc((NVDIMM_PMU_NULL_ATTR + 1) *

drivers/nvdimm/nd_perf.c

287

if (!nd_pmu->pmu.attr_groups)

drivers/nvdimm/nd_perf.c

297

nd_pmu->pmu.attr_groups[NVDIMM_PMU_FORMAT_ATTR] = &nvdimm_pmu_format_group;

drivers/nvdimm/nd_perf.c

298

nd_pmu->pmu.attr_groups[NVDIMM_PMU_EVENT_ATTR] = &nvdimm_pmu_events_group;

drivers/nvdimm/nd_perf.c

299

nd_pmu->pmu.attr_groups[NVDIMM_PMU_NULL_ATTR] = NULL;

drivers/nvdimm/nd_perf.c

304

pr_info("cpu hotplug feature failed for device: %s\n", nd_pmu->pmu.name);

drivers/nvdimm/nd_perf.c

305

kfree(nd_pmu->pmu.attr_groups);

drivers/nvdimm/nd_perf.c

309

rc = perf_pmu_register(&nd_pmu->pmu, nd_pmu->pmu.name, -1);

drivers/nvdimm/nd_perf.c

312

kfree(nd_pmu->pmu.attr_groups);

drivers/nvdimm/nd_perf.c

317

nd_pmu->pmu.name);

drivers/nvdimm/nd_perf.c

325

perf_pmu_unregister(&nd_pmu->pmu);

drivers/nvdimm/nd_perf.c

327

kfree(nd_pmu->pmu.attr_groups);

drivers/pci/controller/dwc/pcie-spacemit-k1.c

158

regmap_set_bits(k1->pmu, reset_ctrl, PCIE_RC_PERST);

drivers/pci/controller/dwc/pcie-spacemit-k1.c

159

regmap_read(k1->pmu, reset_ctrl, &val);

drivers/pci/controller/dwc/pcie-spacemit-k1.c

166

regmap_set_bits(k1->pmu, reset_ctrl, DEVICE_TYPE_RC | PCIE_AUX_PWR_DET);

drivers/pci/controller/dwc/pcie-spacemit-k1.c

176

regmap_clear_bits(k1->pmu, reset_ctrl, PCIE_RC_PERST);

drivers/pci/controller/dwc/pcie-spacemit-k1.c

190

regmap_set_bits(k1->pmu, k1->pmu_off + PCIE_CLK_RESET_CONTROL,

drivers/pci/controller/dwc/pcie-spacemit-k1.c

219

regmap_update_bits(k1->pmu, k1->pmu_off + PCIE_CLK_RESET_CONTROL,

drivers/pci/controller/dwc/pcie-spacemit-k1.c

246

regmap_update_bits(k1->pmu, k1->pmu_off + PCIE_CLK_RESET_CONTROL,

drivers/pci/controller/dwc/pcie-spacemit-k1.c

289

k1->pmu = syscon_regmap_lookup_by_phandle_args(dev_of_node(dev),

drivers/pci/controller/dwc/pcie-spacemit-k1.c

292

if (IS_ERR(k1->pmu))

drivers/pci/controller/dwc/pcie-spacemit-k1.c

293

return dev_err_probe(dev, PTR_ERR(k1->pmu),

drivers/pci/controller/dwc/pcie-spacemit-k1.c

309

regmap_set_bits(k1->pmu, k1->pmu_off + PCIE_CLK_RESET_CONTROL,

drivers/pci/controller/dwc/pcie-spacemit-k1.c

56

struct regmap *pmu; /* Errors ignored; MMIO-backed regmap */

drivers/pci/controller/dwc/pcie-spacemit-k1.c

73

regmap_set_bits(k1->pmu, offset, PCIE_SOFT_RESET);

drivers/pci/controller/dwc/pcie-spacemit-k1.c

74

regmap_read(k1->pmu, offset, &val);

drivers/pci/controller/dwc/pcie-spacemit-k1.c

78

regmap_clear_bits(k1->pmu, offset, PCIE_SOFT_RESET);

drivers/perf/alibaba_uncore_drw_pmu.c

105

struct pmu pmu;

drivers/perf/alibaba_uncore_drw_pmu.c

108

#define to_ali_drw_pmu(p) (container_of(p, struct ali_drw_pmu, pmu))

drivers/perf/alibaba_uncore_drw_pmu.c

268

struct ali_drw_pmu *drw_pmu = to_ali_drw_pmu(event->pmu);

drivers/perf/alibaba_uncore_drw_pmu.c

282

struct ali_drw_pmu *drw_pmu = to_ali_drw_pmu(event->pmu);

drivers/perf/alibaba_uncore_drw_pmu.c

319

struct ali_drw_pmu *drw_pmu = to_ali_drw_pmu(event->pmu);

drivers/perf/alibaba_uncore_drw_pmu.c

338

struct ali_drw_pmu *drw_pmu = to_ali_drw_pmu(event->pmu);

drivers/perf/alibaba_uncore_drw_pmu.c

355

struct ali_drw_pmu *drw_pmu = to_ali_drw_pmu(event->pmu);

drivers/perf/alibaba_uncore_drw_pmu.c

527

struct ali_drw_pmu *drw_pmu = to_ali_drw_pmu(event->pmu);

drivers/perf/alibaba_uncore_drw_pmu.c

530

struct device *dev = drw_pmu->pmu.dev;

drivers/perf/alibaba_uncore_drw_pmu.c

532

if (event->attr.type != event->pmu->type)

drivers/perf/alibaba_uncore_drw_pmu.c

574

struct ali_drw_pmu *drw_pmu = to_ali_drw_pmu(event->pmu);

drivers/perf/alibaba_uncore_drw_pmu.c

599

struct ali_drw_pmu *drw_pmu = to_ali_drw_pmu(event->pmu);

drivers/perf/alibaba_uncore_drw_pmu.c

615

struct ali_drw_pmu *drw_pmu = to_ali_drw_pmu(event->pmu);

drivers/perf/alibaba_uncore_drw_pmu.c

644

struct ali_drw_pmu *drw_pmu = to_ali_drw_pmu(event->pmu);

drivers/perf/alibaba_uncore_drw_pmu.c

702

drw_pmu->pmu = (struct pmu) {

drivers/perf/alibaba_uncore_drw_pmu.c

716

ret = perf_pmu_register(&drw_pmu->pmu, name, -1);

drivers/perf/alibaba_uncore_drw_pmu.c

734

perf_pmu_unregister(&drw_pmu->pmu);

drivers/perf/alibaba_uncore_drw_pmu.c

758

perf_pmu_migrate_context(&drw_pmu->pmu, irq->cpu, target);

drivers/perf/amlogic/meson_ddr_pmu_core.c

120

struct ddr_pmu *pmu = to_ddr_pmu(event->pmu);

drivers/perf/amlogic/meson_ddr_pmu_core.c

124

if (event->attr.type != event->pmu->type)

drivers/perf/amlogic/meson_ddr_pmu_core.c

138

event->cpu = pmu->cpu;

drivers/perf/amlogic/meson_ddr_pmu_core.c

145

struct ddr_pmu *pmu = to_ddr_pmu(event->pmu);

drivers/perf/amlogic/meson_ddr_pmu_core.c

147

memset(&pmu->counters, 0, sizeof(pmu->counters));

drivers/perf/amlogic/meson_ddr_pmu_core.c

148

dmc_pmu_enable(pmu);

drivers/perf/amlogic/meson_ddr_pmu_core.c

175

struct ddr_pmu *pmu = to_ddr_pmu(event->pmu);

drivers/perf/amlogic/meson_ddr_pmu_core.c

180

dmc_pmu_disable(pmu);

drivers/perf/amlogic/meson_ddr_pmu_core.c

192

struct ddr_pmu *pmu = dev_get_drvdata(dev);

drivers/perf/amlogic/meson_ddr_pmu_core.c

194

return cpumap_print_to_pagebuf(true, buf, cpumask_of(pmu->cpu));

drivers/perf/amlogic/meson_ddr_pmu_core.c

21

struct pmu pmu;

drivers/perf/amlogic/meson_ddr_pmu_core.c

294

struct pmu *pmu = dev_get_drvdata(kobj_to_dev(kobj));

drivers/perf/amlogic/meson_ddr_pmu_core.c

295

struct ddr_pmu *ddr_pmu = to_ddr_pmu(pmu);

drivers/perf/amlogic/meson_ddr_pmu_core.c

322

struct ddr_pmu *pmu = dev_get_drvdata(dev);

drivers/perf/amlogic/meson_ddr_pmu_core.c

324

return sysfs_emit(page, "%s\n", pmu->name);

drivers/perf/amlogic/meson_ddr_pmu_core.c

35

#define to_ddr_pmu(p) container_of(p, struct ddr_pmu, pmu)

drivers/perf/amlogic/meson_ddr_pmu_core.c

350

struct ddr_pmu *pmu;

drivers/perf/amlogic/meson_ddr_pmu_core.c

354

pmu = dmc_info_to_pmu(info);

drivers/perf/amlogic/meson_ddr_pmu_core.c

359

sum_cnter = &pmu->counters;

drivers/perf/amlogic/meson_ddr_pmu_core.c

363

for (i = 0; i < pmu->info.hw_info->chann_nr; i++)

drivers/perf/amlogic/meson_ddr_pmu_core.c

366

if (pmu->pmu_enabled)

drivers/perf/amlogic/meson_ddr_pmu_core.c

374

dev_dbg(pmu->dev, "counts: %llu %llu %llu, %llu, %llu, %llu\t\t"

drivers/perf/amlogic/meson_ddr_pmu_core.c

38

static void dmc_pmu_enable(struct ddr_pmu *pmu)

drivers/perf/amlogic/meson_ddr_pmu_core.c

383

pmu->counters.all_req,

drivers/perf/amlogic/meson_ddr_pmu_core.c

384

pmu->counters.all_cnt,

drivers/perf/amlogic/meson_ddr_pmu_core.c

385

pmu->counters.channel_cnt[0],

drivers/perf/amlogic/meson_ddr_pmu_core.c

386

pmu->counters.channel_cnt[1],

drivers/perf/amlogic/meson_ddr_pmu_core.c

387

pmu->counters.channel_cnt[2],

drivers/perf/amlogic/meson_ddr_pmu_core.c

388

pmu->counters.channel_cnt[3]);

drivers/perf/amlogic/meson_ddr_pmu_core.c

395

struct ddr_pmu *pmu = hlist_entry_safe(node, struct ddr_pmu, node);

drivers/perf/amlogic/meson_ddr_pmu_core.c

398

if (cpu != pmu->cpu)

drivers/perf/amlogic/meson_ddr_pmu_core.c

40

if (!pmu->pmu_enabled)

drivers/perf/amlogic/meson_ddr_pmu_core.c

405

perf_pmu_migrate_context(&pmu->pmu, cpu, target);

drivers/perf/amlogic/meson_ddr_pmu_core.c

406

pmu->cpu = target;

drivers/perf/amlogic/meson_ddr_pmu_core.c

408

WARN_ON(irq_set_affinity(pmu->info.irq_num, cpumask_of(pmu->cpu)));

drivers/perf/amlogic/meson_ddr_pmu_core.c

41

pmu->info.hw_info->enable(&pmu->info);

drivers/perf/amlogic/meson_ddr_pmu_core.c

413

static void fill_event_attr(struct ddr_pmu *pmu)

drivers/perf/amlogic/meson_ddr_pmu_core.c

429

for (i = 0; i < pmu->info.hw_info->chann_nr; i++, k++) {

drivers/perf/amlogic/meson_ddr_pmu_core.c

43

pmu->pmu_enabled = true;

drivers/perf/amlogic/meson_ddr_pmu_core.c

46

static void dmc_pmu_disable(struct ddr_pmu *pmu)

drivers/perf/amlogic/meson_ddr_pmu_core.c

48

if (pmu->pmu_enabled)

drivers/perf/amlogic/meson_ddr_pmu_core.c

486

struct ddr_pmu *pmu;

drivers/perf/amlogic/meson_ddr_pmu_core.c

488

pmu = devm_kzalloc(&pdev->dev, sizeof(struct ddr_pmu), GFP_KERNEL);

drivers/perf/amlogic/meson_ddr_pmu_core.c

489

if (!pmu)

drivers/perf/amlogic/meson_ddr_pmu_core.c

49

pmu->info.hw_info->disable(&pmu->info);

drivers/perf/amlogic/meson_ddr_pmu_core.c

492

*pmu = (struct ddr_pmu) {

drivers/perf/amlogic/meson_ddr_pmu_core.c

493

.pmu = {

drivers/perf/amlogic/meson_ddr_pmu_core.c

508

ret = ddr_pmu_parse_dt(pdev, &pmu->info);

drivers/perf/amlogic/meson_ddr_pmu_core.c

51

pmu->pmu_enabled = false;

drivers/perf/amlogic/meson_ddr_pmu_core.c

512

fmt_attr_fill(pmu->info.hw_info->fmt_attr);

drivers/perf/amlogic/meson_ddr_pmu_core.c

514

pmu->cpu = raw_smp_processor_id();

drivers/perf/amlogic/meson_ddr_pmu_core.c

525

pmu->cpuhp_state = ret;

drivers/perf/amlogic/meson_ddr_pmu_core.c

528

ret = cpuhp_state_add_instance_nocalls(pmu->cpuhp_state, &pmu->node);

drivers/perf/amlogic/meson_ddr_pmu_core.c

532

fill_event_attr(pmu);

drivers/perf/amlogic/meson_ddr_pmu_core.c

534

ret = perf_pmu_register(&pmu->pmu, name, -1);

drivers/perf/amlogic/meson_ddr_pmu_core.c

538

pmu->name = name;

drivers/perf/amlogic/meson_ddr_pmu_core.c

539

pmu->dev = &pdev->dev;

drivers/perf/amlogic/meson_ddr_pmu_core.c

540

pmu->pmu_enabled = false;

drivers/perf/amlogic/meson_ddr_pmu_core.c

542

platform_set_drvdata(pdev, pmu);

drivers/perf/amlogic/meson_ddr_pmu_core.c

547

cpuhp_state_remove_instance_nocalls(pmu->cpuhp_state, &pmu->node);

drivers/perf/amlogic/meson_ddr_pmu_core.c

550

cpuhp_remove_state(pmu->cpuhp_state);

drivers/perf/amlogic/meson_ddr_pmu_core.c

557

struct ddr_pmu *pmu = platform_get_drvdata(pdev);

drivers/perf/amlogic/meson_ddr_pmu_core.c

559

perf_pmu_unregister(&pmu->pmu);

drivers/perf/amlogic/meson_ddr_pmu_core.c

56

struct ddr_pmu *pmu = to_ddr_pmu(event->pmu);

drivers/perf/amlogic/meson_ddr_pmu_core.c

560

cpuhp_state_remove_instance_nocalls(pmu->cpuhp_state, &pmu->node);

drivers/perf/amlogic/meson_ddr_pmu_core.c

561

cpuhp_remove_state(pmu->cpuhp_state);

drivers/perf/amlogic/meson_ddr_pmu_core.c

63

pmu->info.hw_info->set_axi_filter(&pmu->info, axi_id, chann);

drivers/perf/amlogic/meson_ddr_pmu_core.c

87

struct ddr_pmu *pmu = to_ddr_pmu(event->pmu);

drivers/perf/amlogic/meson_ddr_pmu_core.c

91

int chann_nr = pmu->info.hw_info->chann_nr;

drivers/perf/amlogic/meson_ddr_pmu_core.c

94

pmu->info.hw_info->get_counters(&pmu->info, &dc);

drivers/perf/amlogic/meson_ddr_pmu_core.c

96

ddr_cnt_addition(&sum_dc, &pmu->counters, &dc, chann_nr);

drivers/perf/apple_m1_cpu_pmu.c

578

static void m1_pmu_init_pmceid(struct arm_pmu *pmu)

drivers/perf/apple_m1_cpu_pmu.c

584

set_bit(event, pmu->pmceid_bitmap);

drivers/perf/arm-cci.c

1072

struct cci_pmu *cci_pmu = to_cci_pmu(event->pmu);

drivers/perf/arm-cci.c

1082

static void cci_pmu_enable(struct pmu *pmu)

drivers/perf/arm-cci.c

1084

struct cci_pmu *cci_pmu = to_cci_pmu(pmu);

drivers/perf/arm-cci.c

1098

static void cci_pmu_disable(struct pmu *pmu)

drivers/perf/arm-cci.c

1100

struct cci_pmu *cci_pmu = to_cci_pmu(pmu);

drivers/perf/arm-cci.c

112

#define to_cci_pmu(c) (container_of(c, struct cci_pmu, pmu))

drivers/perf/arm-cci.c

1121

struct cci_pmu *cci_pmu = to_cci_pmu(event->pmu);

drivers/perf/arm-cci.c

1155

struct cci_pmu *cci_pmu = to_cci_pmu(event->pmu);

drivers/perf/arm-cci.c

1178

struct cci_pmu *cci_pmu = to_cci_pmu(event->pmu);

drivers/perf/arm-cci.c

1203

struct cci_pmu *cci_pmu = to_cci_pmu(event->pmu);

drivers/perf/arm-cci.c

1215

static int validate_event(struct pmu *cci_pmu,

drivers/perf/arm-cci.c

1227

if (event->pmu != cci_pmu)

drivers/perf/arm-cci.c

1242

struct cci_pmu *cci_pmu = to_cci_pmu(event->pmu);

drivers/perf/arm-cci.c

1253

if (!validate_event(event->pmu, &fake_pmu, leader))

drivers/perf/arm-cci.c

1257

if (!validate_event(event->pmu, &fake_pmu, sibling))

drivers/perf/arm-cci.c

1261

if (!validate_event(event->pmu, &fake_pmu, event))

drivers/perf/arm-cci.c

1305

struct cci_pmu *cci_pmu = to_cci_pmu(event->pmu);

drivers/perf/arm-cci.c

1309

if (event->attr.type != event->pmu->type)

drivers/perf/arm-cci.c

1351

struct pmu *pmu = dev_get_drvdata(dev);

drivers/perf/arm-cci.c

1352

struct cci_pmu *cci_pmu = to_cci_pmu(pmu);

drivers/perf/arm-cci.c

1400

cci_pmu->pmu = (struct pmu) {

drivers/perf/arm-cci.c

1428

return perf_pmu_register(&cci_pmu->pmu, name, -1);

drivers/perf/arm-cci.c

1442

perf_pmu_migrate_context(&g_cci_pmu->pmu, cpu, target);

drivers/perf/arm-cci.c

1697

perf_pmu_unregister(&g_cci_pmu->pmu);

drivers/perf/arm-cci.c

788

struct cci_pmu *cci_pmu = to_cci_pmu(event->pmu);

drivers/perf/arm-cci.c

806

struct cci_pmu *cci_pmu = to_cci_pmu(event->pmu);

drivers/perf/arm-cci.c

864

struct cci_pmu *cci_pmu = to_cci_pmu(event->pmu);

drivers/perf/arm-cci.c

99

struct pmu pmu;

drivers/perf/arm-ccn.c

1005

struct arm_ccn *ccn = pmu_to_arm_ccn(event->pmu);

drivers/perf/arm-ccn.c

1042

struct arm_ccn *ccn = pmu_to_arm_ccn(event->pmu);

drivers/perf/arm-ccn.c

1088

struct arm_ccn *ccn = pmu_to_arm_ccn(event->pmu);

drivers/perf/arm-ccn.c

1115

struct arm_ccn *ccn = pmu_to_arm_ccn(event->pmu);

drivers/perf/arm-ccn.c

1130

static void arm_ccn_pmu_enable(struct pmu *pmu)

drivers/perf/arm-ccn.c

1132

struct arm_ccn *ccn = pmu_to_arm_ccn(pmu);

drivers/perf/arm-ccn.c

1139

static void arm_ccn_pmu_disable(struct pmu *pmu)

drivers/perf/arm-ccn.c

1141

struct arm_ccn *ccn = pmu_to_arm_ccn(pmu);

drivers/perf/arm-ccn.c

1202

perf_pmu_migrate_context(&dt->pmu, cpu, target);

drivers/perf/arm-ccn.c

1257

ccn->dt.pmu = (struct pmu) {

drivers/perf/arm-ccn.c

1295

err = perf_pmu_register(&ccn->dt.pmu, name, -1);

drivers/perf/arm-ccn.c

1322

perf_pmu_unregister(&ccn->dt.pmu);

drivers/perf/arm-ccn.c

143

struct arm_ccn_dt, pmu), struct arm_ccn, dt)

drivers/perf/arm-ccn.c

166

struct pmu pmu;

drivers/perf/arm-ccn.c

624

struct arm_ccn *ccn = pmu_to_arm_ccn(event->pmu);

drivers/perf/arm-ccn.c

682

struct arm_ccn *ccn = pmu_to_arm_ccn(event->pmu);

drivers/perf/arm-ccn.c

713

if (event->attr.type != event->pmu->type)

drivers/perf/arm-ccn.c

716

ccn = pmu_to_arm_ccn(event->pmu);

drivers/perf/arm-ccn.c

822

if (event->group_leader->pmu != event->pmu &&

drivers/perf/arm-ccn.c

827

if (sibling->pmu != event->pmu &&

drivers/perf/arm-ccn.c

861

struct arm_ccn *ccn = pmu_to_arm_ccn(event->pmu);

drivers/perf/arm-ccn.c

877

struct arm_ccn *ccn = pmu_to_arm_ccn(event->pmu);

drivers/perf/arm-ccn.c

910

struct arm_ccn *ccn = pmu_to_arm_ccn(event->pmu);

drivers/perf/arm-ccn.c

936

struct arm_ccn *ccn = pmu_to_arm_ccn(event->pmu);

drivers/perf/arm-ccn.c

984

struct arm_ccn *ccn = pmu_to_arm_ccn(event->pmu);

drivers/perf/arm-cmn.c

1401

bool is_cmn600 = to_cmn(event->pmu)->part == PART_CMN600;

drivers/perf/arm-cmn.c

1437

static void arm_cmn_pmu_enable(struct pmu *pmu)

drivers/perf/arm-cmn.c

1439

arm_cmn_clear_state(to_cmn(pmu), CMN_STATE_DISABLED);

drivers/perf/arm-cmn.c

1442

static void arm_cmn_pmu_disable(struct pmu *pmu)

drivers/perf/arm-cmn.c

1444

arm_cmn_set_state(to_cmn(pmu), CMN_STATE_DISABLED);

drivers/perf/arm-cmn.c

1487

struct arm_cmn *cmn = to_cmn(event->pmu);

drivers/perf/arm-cmn.c

1502

struct arm_cmn *cmn = to_cmn(event->pmu);

drivers/perf/arm-cmn.c

1568

struct arm_cmn *cmn = to_cmn(event->pmu);

drivers/perf/arm-cmn.c

1602

struct arm_cmn *cmn = to_cmn(event->pmu);

drivers/perf/arm-cmn.c

1700

if (event->pmu != leader->pmu && !is_software_event(leader))

drivers/perf/arm-cmn.c

1768

struct arm_cmn *cmn = to_cmn(event->pmu);

drivers/perf/arm-cmn.c

1775

if (event->attr.type != event->pmu->type)

drivers/perf/arm-cmn.c

1873

struct arm_cmn *cmn = to_cmn(event->pmu);

drivers/perf/arm-cmn.c

1976

struct arm_cmn *cmn = to_cmn(event->pmu);

drivers/perf/arm-cmn.c

1994

static void arm_cmn_start_txn(struct pmu *pmu, unsigned int flags)

drivers/perf/arm-cmn.c

1996

arm_cmn_set_state(to_cmn(pmu), CMN_STATE_TXN);

drivers/perf/arm-cmn.c

1999

static void arm_cmn_end_txn(struct pmu *pmu)

drivers/perf/arm-cmn.c

2001

arm_cmn_clear_state(to_cmn(pmu), CMN_STATE_TXN);

drivers/perf/arm-cmn.c

2004

static int arm_cmn_commit_txn(struct pmu *pmu)

drivers/perf/arm-cmn.c

2006

arm_cmn_end_txn(pmu);

drivers/perf/arm-cmn.c

2014

perf_pmu_migrate_context(&cmn->pmu, cmn->cpu, cpu);

drivers/perf/arm-cmn.c

2603

cmn->pmu = (struct pmu) {

drivers/perf/arm-cmn.c

2631

err = perf_pmu_register(&cmn->pmu, name, -1);

drivers/perf/arm-cmn.c

2646

perf_pmu_unregister(&cmn->pmu);

drivers/perf/arm-cmn.c

363

struct pmu pmu;

drivers/perf/arm-cmn.c

367

#define to_cmn(p) container_of(p, struct arm_cmn, pmu)

drivers/perf/arm-ni.c

120

struct pmu pmu;

drivers/perf/arm-ni.c

138

#define pmu_to_cd(p) container_of((p), struct arm_ni_cd, pmu)

drivers/perf/arm-ni.c

278

static void arm_ni_pmu_enable(struct pmu *pmu)

drivers/perf/arm-ni.c

280

writel_relaxed(NI_PMCR_ENABLE, pmu_to_cd(pmu)->pmu_base + NI_PMCR);

drivers/perf/arm-ni.c

283

static void arm_ni_pmu_disable(struct pmu *pmu)

drivers/perf/arm-ni.c

285

writel_relaxed(0, pmu_to_cd(pmu)->pmu_base + NI_PMCR);

drivers/perf/arm-ni.c

333

struct arm_ni_cd *cd = pmu_to_cd(event->pmu);

drivers/perf/arm-ni.c

336

if (event->attr.type != event->pmu->type)

drivers/perf/arm-ni.c

397

struct arm_ni_cd *cd = pmu_to_cd(event->pmu);

drivers/perf/arm-ni.c

404

struct arm_ni_cd *cd = pmu_to_cd(event->pmu);

drivers/perf/arm-ni.c

425

struct arm_ni_cd *cd = pmu_to_cd(event->pmu);

drivers/perf/arm-ni.c

464

struct arm_ni_cd *cd = pmu_to_cd(event->pmu);

drivers/perf/arm-ni.c

598

cd->pmu = (struct pmu) {

drivers/perf/arm-ni.c

618

return perf_pmu_register(&cd->pmu, name, -1);

drivers/perf/arm-ni.c

628

perf_pmu_unregister(&cd->pmu);

drivers/perf/arm-ni.c

794

perf_pmu_migrate_context(&cd->pmu, ni->cpu, cpu);

drivers/perf/arm_brbe.c

775

struct arm_pmu *cpu_pmu = to_arm_pmu(event->pmu);

drivers/perf/arm_cspmu/arm_cspmu.c

1191

cspmu->pmu = (struct pmu){

drivers/perf/arm_cspmu/arm_cspmu.c

1210

ret = perf_pmu_register(&cspmu->pmu, cspmu->name, -1);

drivers/perf/arm_cspmu/arm_cspmu.c

1257

perf_pmu_unregister(&cspmu->pmu);

drivers/perf/arm_cspmu/arm_cspmu.c

1327

perf_pmu_migrate_context(&cspmu->pmu, cpu, dst);

drivers/perf/arm_cspmu/arm_cspmu.c

291

struct pmu *pmu = dev_get_drvdata(dev);

drivers/perf/arm_cspmu/arm_cspmu.c

292

struct arm_cspmu *cspmu = to_arm_cspmu(pmu);

drivers/perf/arm_cspmu/arm_cspmu.c

529

static void arm_cspmu_enable(struct pmu *pmu)

drivers/perf/arm_cspmu/arm_cspmu.c

532

struct arm_cspmu *cspmu = to_arm_cspmu(pmu);

drivers/perf/arm_cspmu/arm_cspmu.c

543

static void arm_cspmu_disable(struct pmu *pmu)

drivers/perf/arm_cspmu/arm_cspmu.c

545

struct arm_cspmu *cspmu = to_arm_cspmu(pmu);

drivers/perf/arm_cspmu/arm_cspmu.c

554

struct arm_cspmu *cspmu = to_arm_cspmu(event->pmu);

drivers/perf/arm_cspmu/arm_cspmu.c

598

static bool arm_cspmu_validate_event(struct pmu *pmu,

drivers/perf/arm_cspmu/arm_cspmu.c

606

if (event->pmu != pmu)

drivers/perf/arm_cspmu/arm_cspmu.c

626

if (!arm_cspmu_validate_event(event->pmu, &fake_hw_events, leader))

drivers/perf/arm_cspmu/arm_cspmu.c

630

if (!arm_cspmu_validate_event(event->pmu, &fake_hw_events,

drivers/perf/arm_cspmu/arm_cspmu.c

635

return arm_cspmu_validate_event(event->pmu, &fake_hw_events, event);

drivers/perf/arm_cspmu/arm_cspmu.c

643

cspmu = to_arm_cspmu(event->pmu);

drivers/perf/arm_cspmu/arm_cspmu.c

645

if (event->attr.type != event->pmu->type)

drivers/perf/arm_cspmu/arm_cspmu.c

653

dev_dbg(cspmu->pmu.dev,

drivers/perf/arm_cspmu/arm_cspmu.c

659

dev_dbg(cspmu->pmu.dev,

drivers/perf/arm_cspmu/arm_cspmu.c

669

dev_dbg(cspmu->pmu.dev,

drivers/perf/arm_cspmu/arm_cspmu.c

704

struct arm_cspmu *cspmu = to_arm_cspmu(event->pmu);

drivers/perf/arm_cspmu/arm_cspmu.c

724

struct arm_cspmu *cspmu = to_arm_cspmu(event->pmu);

drivers/perf/arm_cspmu/arm_cspmu.c

747

struct arm_cspmu *cspmu = to_arm_cspmu(event->pmu);

drivers/perf/arm_cspmu/arm_cspmu.c

784

struct arm_cspmu *cspmu = to_arm_cspmu(event->pmu);

drivers/perf/arm_cspmu/arm_cspmu.c

826

struct arm_cspmu *cspmu = to_arm_cspmu(event->pmu);

drivers/perf/arm_cspmu/arm_cspmu.c

849

struct arm_cspmu *cspmu = to_arm_cspmu(event->pmu);

drivers/perf/arm_cspmu/arm_cspmu.c

873

struct arm_cspmu *cspmu = to_arm_cspmu(event->pmu);

drivers/perf/arm_cspmu/arm_cspmu.c

902

struct arm_cspmu *cspmu = to_arm_cspmu(event->pmu);

drivers/perf/arm_cspmu/arm_cspmu.h

20

#define to_arm_cspmu(p) (container_of(p, struct arm_cspmu, pmu))

drivers/perf/arm_cspmu/arm_cspmu.h

224

struct pmu pmu;

drivers/perf/arm_cspmu/nvidia_cspmu.c

189

to_nv_cspmu_ctx(to_arm_cspmu(event->pmu));

drivers/perf/arm_cspmu/nvidia_cspmu.c

202

to_nv_cspmu_ctx(to_arm_cspmu(event->pmu));

drivers/perf/arm_cspmu/nvidia_cspmu.c

217

to_nv_cspmu_ctx(to_arm_cspmu(event->pmu));

drivers/perf/arm_dmc620_pmu.c

103

#define to_dmc620_pmu(p) (container_of(p, struct dmc620_pmu, pmu))

drivers/perf/arm_dmc620_pmu.c

295

struct dmc620_pmu *dmc620_pmu = to_dmc620_pmu(event->pmu);

drivers/perf/arm_dmc620_pmu.c

318

struct dmc620_pmu *dmc620_pmu = to_dmc620_pmu(event->pmu);

drivers/perf/arm_dmc620_pmu.c

341

struct dmc620_pmu *dmc620_pmu = to_dmc620_pmu(event->pmu);

drivers/perf/arm_dmc620_pmu.c

350

struct dmc620_pmu *dmc620_pmu = to_dmc620_pmu(event->pmu);

drivers/perf/arm_dmc620_pmu.c

360

struct dmc620_pmu *dmc620_pmu = to_dmc620_pmu(event->pmu);

drivers/perf/arm_dmc620_pmu.c

514

struct dmc620_pmu *dmc620_pmu = to_dmc620_pmu(event->pmu);

drivers/perf/arm_dmc620_pmu.c

518

if (event->attr.type != event->pmu->type)

drivers/perf/arm_dmc620_pmu.c

527

dev_dbg(dmc620_pmu->pmu.dev,

drivers/perf/arm_dmc620_pmu.c

590

struct dmc620_pmu *dmc620_pmu = to_dmc620_pmu(event->pmu);

drivers/perf/arm_dmc620_pmu.c

625

struct dmc620_pmu *dmc620_pmu = to_dmc620_pmu(event->pmu);

drivers/perf/arm_dmc620_pmu.c

653

perf_pmu_migrate_context(&dmc620_pmu->pmu, irq->cpu, target);

drivers/perf/arm_dmc620_pmu.c

677

dmc620_pmu->pmu = (struct pmu) {

drivers/perf/arm_dmc620_pmu.c

719

ret = perf_pmu_register(&dmc620_pmu->pmu, name, -1);

drivers/perf/arm_dmc620_pmu.c

738

perf_pmu_unregister(&dmc620_pmu->pmu);

drivers/perf/arm_dmc620_pmu.c

87

struct pmu pmu;

drivers/perf/arm_dsu_pmu.c

109

struct pmu pmu;

drivers/perf/arm_dsu_pmu.c

125

static inline struct dsu_pmu *to_dsu_pmu(struct pmu *pmu)

drivers/perf/arm_dsu_pmu.c

127

return container_of(pmu, struct dsu_pmu, pmu);

drivers/perf/arm_dsu_pmu.c

143

struct pmu *pmu = dev_get_drvdata(dev);

drivers/perf/arm_dsu_pmu.c

144

struct dsu_pmu *dsu_pmu = to_dsu_pmu(pmu);

drivers/perf/arm_dsu_pmu.c

189

struct pmu *pmu = dev_get_drvdata(kobj_to_dev(kobj));

drivers/perf/arm_dsu_pmu.c

190

struct dsu_pmu *dsu_pmu = to_dsu_pmu(pmu);

drivers/perf/arm_dsu_pmu.c

231

struct dsu_pmu *dsu_pmu = to_dsu_pmu(event->pmu);

drivers/perf/arm_dsu_pmu.c

239

dev_err(event->pmu->dev,

drivers/perf/arm_dsu_pmu.c

257

struct dsu_pmu *dsu_pmu = to_dsu_pmu(event->pmu);

drivers/perf/arm_dsu_pmu.c

265

dev_err(event->pmu->dev,

drivers/perf/arm_dsu_pmu.c

283

struct dsu_pmu *dsu_pmu = to_dsu_pmu(event->pmu);

drivers/perf/arm_dsu_pmu.c

317

dev_err(event->pmu->dev,

drivers/perf/arm_dsu_pmu.c

399

struct dsu_pmu *dsu_pmu = to_dsu_pmu(event->pmu);

drivers/perf/arm_dsu_pmu.c

413

struct dsu_pmu *dsu_pmu = to_dsu_pmu(event->pmu);

drivers/perf/arm_dsu_pmu.c

424

struct dsu_pmu *dsu_pmu = to_dsu_pmu(event->pmu);

drivers/perf/arm_dsu_pmu.c

450

struct dsu_pmu *dsu_pmu = to_dsu_pmu(event->pmu);

drivers/perf/arm_dsu_pmu.c

461

static void dsu_pmu_enable(struct pmu *pmu)

drivers/perf/arm_dsu_pmu.c

465

struct dsu_pmu *dsu_pmu = to_dsu_pmu(pmu);

drivers/perf/arm_dsu_pmu.c

478

static void dsu_pmu_disable(struct pmu *pmu)

drivers/perf/arm_dsu_pmu.c

482

struct dsu_pmu *dsu_pmu = to_dsu_pmu(pmu);

drivers/perf/arm_dsu_pmu.c

491

static bool dsu_pmu_validate_event(struct pmu *pmu,

drivers/perf/arm_dsu_pmu.c

498

if (event->pmu != pmu)

drivers/perf/arm_dsu_pmu.c

516

if (!dsu_pmu_validate_event(event->pmu, &fake_hw, leader))

drivers/perf/arm_dsu_pmu.c

519

if (!dsu_pmu_validate_event(event->pmu, &fake_hw, sibling))

drivers/perf/arm_dsu_pmu.c

522

return dsu_pmu_validate_event(event->pmu, &fake_hw, event);

drivers/perf/arm_dsu_pmu.c

527

struct dsu_pmu *dsu_pmu = to_dsu_pmu(event->pmu);

drivers/perf/arm_dsu_pmu.c

529

if (event->attr.type != event->pmu->type)

drivers/perf/arm_dsu_pmu.c

534

dev_dbg(dsu_pmu->pmu.dev, "Can't support sampling events\n");

drivers/perf/arm_dsu_pmu.c

540

dev_dbg(dsu_pmu->pmu.dev, "Can't support per-task counters\n");

drivers/perf/arm_dsu_pmu.c

545

dev_dbg(dsu_pmu->pmu.dev, "Can't support filtering\n");

drivers/perf/arm_dsu_pmu.c

550

dev_dbg(dsu_pmu->pmu.dev,

drivers/perf/arm_dsu_pmu.c

743

dsu_pmu->pmu = (struct pmu) {

drivers/perf/arm_dsu_pmu.c

760

rc = perf_pmu_register(&dsu_pmu->pmu, name, -1);

drivers/perf/arm_dsu_pmu.c

773

perf_pmu_unregister(&dsu_pmu->pmu);

drivers/perf/arm_dsu_pmu.c

836

perf_pmu_migrate_context(&dsu_pmu->pmu, cpu, dst);

drivers/perf/arm_pmu.c

189

if (type == event->pmu->type)

drivers/perf/arm_pmu.c

206

struct arm_pmu *armpmu = to_arm_pmu(event->pmu);

drivers/perf/arm_pmu.c

248

struct arm_pmu *armpmu = to_arm_pmu(event->pmu);

drivers/perf/arm_pmu.c

278

struct arm_pmu *armpmu = to_arm_pmu(event->pmu);

drivers/perf/arm_pmu.c

294

struct arm_pmu *armpmu = to_arm_pmu(event->pmu);

drivers/perf/arm_pmu.c

319

struct arm_pmu *armpmu = to_arm_pmu(event->pmu);

drivers/perf/arm_pmu.c

328

perf_sched_cb_dec(event->pmu);

drivers/perf/arm_pmu.c

341

struct arm_pmu *armpmu = to_arm_pmu(event->pmu);

drivers/perf/arm_pmu.c

360

perf_sched_cb_inc(event->pmu);

drivers/perf/arm_pmu.c

377

validate_event(struct pmu *pmu, struct pmu_hw_events *hw_events,

drivers/perf/arm_pmu.c

390

if (event->pmu != pmu)

drivers/perf/arm_pmu.c

399

armpmu = to_arm_pmu(event->pmu);

drivers/perf/arm_pmu.c

415

if (!validate_event(event->pmu, &fake_pmu, leader))

drivers/perf/arm_pmu.c

422

if (!validate_event(event->pmu, &fake_pmu, sibling))

drivers/perf/arm_pmu.c

426

if (!validate_event(event->pmu, &fake_pmu, event))

drivers/perf/arm_pmu.c

459

struct arm_pmu *armpmu = to_arm_pmu(event->pmu);

drivers/perf/arm_pmu.c

514

struct arm_pmu *armpmu = to_arm_pmu(event->pmu);

drivers/perf/arm_pmu.c

533

static void armpmu_enable(struct pmu *pmu)

drivers/perf/arm_pmu.c

535

struct arm_pmu *armpmu = to_arm_pmu(pmu);

drivers/perf/arm_pmu.c

547

static void armpmu_disable(struct pmu *pmu)

drivers/perf/arm_pmu.c

549

struct arm_pmu *armpmu = to_arm_pmu(pmu);

drivers/perf/arm_pmu.c

563

static bool armpmu_filter(struct pmu *pmu, int cpu)

drivers/perf/arm_pmu.c

565

struct arm_pmu *armpmu = to_arm_pmu(pmu);

drivers/perf/arm_pmu.c

700

static int armpmu_get_cpu_irq(struct arm_pmu *pmu, int cpu)

drivers/perf/arm_pmu.c

702

struct pmu_hw_events __percpu *hw_events = pmu->hw_events;

drivers/perf/arm_pmu.c

719

struct arm_pmu *pmu = hlist_entry_safe(node, struct arm_pmu, node);

drivers/perf/arm_pmu.c

722

if (!cpumask_test_cpu(cpu, &pmu->supported_cpus))

drivers/perf/arm_pmu.c

724

if (pmu->reset)

drivers/perf/arm_pmu.c

725

pmu->reset(pmu);

drivers/perf/arm_pmu.c

727

irq = armpmu_get_cpu_irq(pmu, cpu);

drivers/perf/arm_pmu.c

736

struct arm_pmu *pmu = hlist_entry_safe(node, struct arm_pmu, node);

drivers/perf/arm_pmu.c

739

if (!cpumask_test_cpu(cpu, &pmu->supported_cpus))

drivers/perf/arm_pmu.c

742

irq = armpmu_get_cpu_irq(pmu, cpu);

drivers/perf/arm_pmu.c

864

struct arm_pmu *pmu;

drivers/perf/arm_pmu.c

867

pmu = kzalloc_obj(*pmu);

drivers/perf/arm_pmu.c

868

if (!pmu)

drivers/perf/arm_pmu.c

871

pmu->hw_events = alloc_percpu_gfp(struct pmu_hw_events, GFP_KERNEL);

drivers/perf/arm_pmu.c

872

if (!pmu->hw_events) {

drivers/perf/arm_pmu.c

877

pmu->pmu = (struct pmu) {

drivers/perf/arm_pmu.c

887

.attr_groups = pmu->attr_groups,

drivers/perf/arm_pmu.c

899

pmu->attr_groups[ARMPMU_ATTR_GROUP_COMMON] =

drivers/perf/arm_pmu.c

905

events = per_cpu_ptr(pmu->hw_events, cpu);

drivers/perf/arm_pmu.c

906

events->percpu_pmu = pmu;

drivers/perf/arm_pmu.c

909

return pmu;

drivers/perf/arm_pmu.c

912

kfree(pmu);

drivers/perf/arm_pmu.c

917

void armpmu_free(struct arm_pmu *pmu)

drivers/perf/arm_pmu.c

919

free_percpu(pmu->hw_events);

drivers/perf/arm_pmu.c

920

kfree(pmu);

drivers/perf/arm_pmu.c

923

int armpmu_register(struct arm_pmu *pmu)

drivers/perf/arm_pmu.c

927

ret = cpu_pmu_init(pmu);

drivers/perf/arm_pmu.c

935

pmu->has_smt = topology_core_has_smt(cpumask_first(&pmu->supported_cpus));

drivers/perf/arm_pmu.c

937

if (!pmu->set_event_filter)

drivers/perf/arm_pmu.c

938

pmu->pmu.capabilities |= PERF_PMU_CAP_NO_EXCLUDE;

drivers/perf/arm_pmu.c

940

ret = perf_pmu_register(&pmu->pmu, pmu->name, -1);

drivers/perf/arm_pmu.c

945

pmu->name, bitmap_weight(pmu->cntr_mask, ARMPMU_MAX_HWEVENTS),

drivers/perf/arm_pmu.c

946

ARMPMU_MAX_HWEVENTS, &pmu->cntr_mask,

drivers/perf/arm_pmu.c

949

kvm_host_pmu_init(pmu);

drivers/perf/arm_pmu.c

954

cpu_pmu_destroy(pmu);

drivers/perf/arm_pmu_acpi.c

252

struct arm_pmu *pmu;

drivers/perf/arm_pmu_acpi.c

256

pmu = per_cpu(probed_pmus, cpu);

drivers/perf/arm_pmu_acpi.c

257

if (!pmu || pmu->acpi_cpuid != cpuid)

drivers/perf/arm_pmu_acpi.c

260

return pmu;

drivers/perf/arm_pmu_acpi.c

270

static bool pmu_irq_matches(struct arm_pmu *pmu, int irq)

drivers/perf/arm_pmu_acpi.c

272

struct pmu_hw_events __percpu *hw_events = pmu->hw_events;

drivers/perf/arm_pmu_acpi.c

278

for_each_cpu(cpu, &pmu->supported_cpus) {

drivers/perf/arm_pmu_acpi.c

295

static void arm_pmu_acpi_associate_pmu_cpu(struct arm_pmu *pmu,

drivers/perf/arm_pmu_acpi.c

300

per_cpu(probed_pmus, cpu) = pmu;

drivers/perf/arm_pmu_acpi.c

302

if (pmu_irq_matches(pmu, irq)) {

drivers/perf/arm_pmu_acpi.c

304

hw_events = pmu->hw_events;

drivers/perf/arm_pmu_acpi.c

308

cpumask_set_cpu(cpu, &pmu->supported_cpus);

drivers/perf/arm_pmu_acpi.c

322

struct arm_pmu *pmu;

drivers/perf/arm_pmu_acpi.c

328

pmu = arm_pmu_acpi_find_pmu();

drivers/perf/arm_pmu_acpi.c

329

if (!pmu) {

drivers/perf/arm_pmu_acpi.c

335

arm_pmu_acpi_associate_pmu_cpu(pmu, cpu);

drivers/perf/arm_pmu_acpi.c

339

static void arm_pmu_acpi_probe_matching_cpus(struct arm_pmu *pmu,

drivers/perf/arm_pmu_acpi.c

348

arm_pmu_acpi_associate_pmu_cpu(pmu, cpu);

drivers/perf/arm_pmu_acpi.c

382

struct arm_pmu *pmu = per_cpu(probed_pmus, cpu);

drivers/perf/arm_pmu_acpi.c

387

if (pmu)

drivers/perf/arm_pmu_acpi.c

390

pmu = armpmu_alloc();

drivers/perf/arm_pmu_acpi.c

391

if (!pmu) {

drivers/perf/arm_pmu_acpi.c

398

pmu->acpi_cpuid = cpuid;

drivers/perf/arm_pmu_acpi.c

400

arm_pmu_acpi_probe_matching_cpus(pmu, cpuid);

drivers/perf/arm_pmu_acpi.c

402

ret = init_fn(pmu);

drivers/perf/arm_pmu_acpi.c

411

base_name = pmu->name;

drivers/perf/arm_pmu_acpi.c

412

pmu->name = kasprintf(GFP_KERNEL, "%s_%d", base_name, pmu_idx++);

drivers/perf/arm_pmu_acpi.c

413

if (!pmu->name) {

drivers/perf/arm_pmu_acpi.c

418

ret = armpmu_register(pmu);

drivers/perf/arm_pmu_acpi.c

421

kfree(pmu->name);

drivers/perf/arm_pmu_platform.c

111

pmu->pmu.capabilities |= PERF_PMU_CAP_NO_INTERRUPT;

drivers/perf/arm_pmu_platform.c

112

cpumask_setall(&pmu->supported_cpus);

drivers/perf/arm_pmu_platform.c

122

return pmu_parse_percpu_irq(pmu, irq, affinity);

drivers/perf/arm_pmu_platform.c

152

cpumask_set_cpu(cpu, &pmu->supported_cpus);

drivers/perf/arm_pmu_platform.c

194

struct arm_pmu *pmu;

drivers/perf/arm_pmu_platform.c

197

pmu = armpmu_alloc();

drivers/perf/arm_pmu_platform.c

198

if (!pmu)

drivers/perf/arm_pmu_platform.c

201

pmu->pmu.parent = &pdev->dev;

drivers/perf/arm_pmu_platform.c

202

pmu->plat_device = pdev;

drivers/perf/arm_pmu_platform.c

204

ret = pmu_parse_irqs(pmu);

drivers/perf/arm_pmu_platform.c

210

pmu->secure_access = of_property_read_bool(dev->of_node,

drivers/perf/arm_pmu_platform.c

214

if (IS_ENABLED(CONFIG_ARM64) && pmu->secure_access) {

drivers/perf/arm_pmu_platform.c

216

pmu->secure_access = false;

drivers/perf/arm_pmu_platform.c

219

ret = init_fn(pmu);

drivers/perf/arm_pmu_platform.c

221

cpumask_setall(&pmu->supported_cpus);

drivers/perf/arm_pmu_platform.c

222

ret = probe_current_pmu(pmu, probe_table);

drivers/perf/arm_pmu_platform.c

230

ret = armpmu_request_irqs(pmu);

drivers/perf/arm_pmu_platform.c

234

ret = armpmu_register(pmu);

drivers/perf/arm_pmu_platform.c

243

armpmu_free_irqs(pmu);

drivers/perf/arm_pmu_platform.c

245

armpmu_free(pmu);

drivers/perf/arm_pmu_platform.c

25

static int probe_current_pmu(struct arm_pmu *pmu,

drivers/perf/arm_pmu_platform.c

37

ret = info->init(pmu);

drivers/perf/arm_pmu_platform.c

45

static int pmu_parse_percpu_irq(struct arm_pmu *pmu, int irq,

drivers/perf/arm_pmu_platform.c

48

struct pmu_hw_events __percpu *hw_events = pmu->hw_events;

drivers/perf/arm_pmu_platform.c

51

cpumask_copy(&pmu->supported_cpus, affinity);

drivers/perf/arm_pmu_platform.c

53

for_each_cpu(cpu, &pmu->supported_cpus)

drivers/perf/arm_pmu_platform.c

94

static int pmu_parse_irqs(struct arm_pmu *pmu)

drivers/perf/arm_pmu_platform.c

97

struct platform_device *pdev = pmu->plat_device;

drivers/perf/arm_pmu_platform.c

98

struct pmu_hw_events __percpu *hw_events = pmu->hw_events;

drivers/perf/arm_pmuv3.c

1020

struct arm_pmu *cpu_pmu = to_arm_pmu(event->pmu);

drivers/perf/arm_pmuv3.c

1077

struct arm_pmu *armpmu = to_arm_pmu(pmu_ctx->pmu);

drivers/perf/arm_pmuv3.c

1096

struct arm_pmu *cpu_pmu = to_arm_pmu(perf_event->pmu);

drivers/perf/arm_pmuv3.c

1226

struct arm_pmu *armpmu = to_arm_pmu(event->pmu);

drivers/perf/arm_pmuv3.c

1303

struct arm_pmu *pmu;

drivers/perf/arm_pmuv3.c

1310

struct arm_pmu *cpu_pmu = probe->pmu;

drivers/perf/arm_pmuv3.c

1374

.pmu = cpu_pmu,

drivers/perf/arm_pmuv3.c

1451

cpu_pmu->pmu.event_idx = armv8pmu_user_event_idx;

drivers/perf/arm_pmuv3.c

1453

cpu_pmu->pmu.sched_task = armv8pmu_sched_task;

drivers/perf/arm_pmuv3.c

275

struct pmu *pmu = dev_get_drvdata(dev);

drivers/perf/arm_pmuv3.c

276

struct arm_pmu *cpu_pmu = container_of(pmu, struct arm_pmu, pmu);

drivers/perf/arm_pmuv3.c

378

struct pmu *pmu = dev_get_drvdata(dev);

drivers/perf/arm_pmuv3.c

379

struct arm_pmu *cpu_pmu = container_of(pmu, struct arm_pmu, pmu);

drivers/perf/arm_pmuv3.c

390

struct pmu *pmu = dev_get_drvdata(dev);

drivers/perf/arm_pmuv3.c

391

struct arm_pmu *cpu_pmu = container_of(pmu, struct arm_pmu, pmu);

drivers/perf/arm_pmuv3.c

402

struct pmu *pmu = dev_get_drvdata(dev);

drivers/perf/arm_pmuv3.c

403

struct arm_pmu *cpu_pmu = container_of(pmu, struct arm_pmu, pmu);

drivers/perf/arm_pmuv3.c

435

struct pmu *pmu = dev_get_drvdata(dev);

drivers/perf/arm_pmuv3.c

436

struct arm_pmu *cpu_pmu = container_of(pmu, struct arm_pmu, pmu);

drivers/perf/arm_pmuv3.c

446

struct pmu *pmu = dev_get_drvdata(dev);

drivers/perf/arm_pmuv3.c

447

struct arm_pmu *cpu_pmu = container_of(pmu, struct arm_pmu, pmu);

drivers/perf/arm_pmuv3.c

466

struct pmu *pmu = dev_get_drvdata(dev);

drivers/perf/arm_pmuv3.c

467

struct arm_pmu *cpu_pmu = container_of(pmu, struct arm_pmu, pmu);

drivers/perf/arm_pmuv3.c

507

struct arm_pmu *cpu_pmu = to_arm_pmu(event->pmu);

drivers/perf/arm_pmuv3.c

563

struct arm_pmu *cpu_pmu = to_arm_pmu(event->pmu);

drivers/perf/arm_pmuv3.c

984

struct arm_pmu *cpu_pmu = to_arm_pmu(event->pmu);

drivers/perf/arm_smmuv3_pmu.c

129

struct pmu pmu;

drivers/perf/arm_smmuv3_pmu.c

140

#define to_smmu_pmu(p) (container_of(p, struct smmu_pmu, pmu))

drivers/perf/arm_smmuv3_pmu.c

154

static inline void smmu_pmu_enable(struct pmu *pmu)

drivers/perf/arm_smmuv3_pmu.c

156

struct smmu_pmu *smmu_pmu = to_smmu_pmu(pmu);

drivers/perf/arm_smmuv3_pmu.c

166

static inline void smmu_pmu_enable_quirk_hip08_09(struct pmu *pmu)

drivers/perf/arm_smmuv3_pmu.c

168

struct smmu_pmu *smmu_pmu = to_smmu_pmu(pmu);

drivers/perf/arm_smmuv3_pmu.c

174

smmu_pmu_enable(pmu);

drivers/perf/arm_smmuv3_pmu.c

177

static inline void smmu_pmu_disable(struct pmu *pmu)

drivers/perf/arm_smmuv3_pmu.c

179

struct smmu_pmu *smmu_pmu = to_smmu_pmu(pmu);

drivers/perf/arm_smmuv3_pmu.c

185

static inline void smmu_pmu_disable_quirk_hip08_09(struct pmu *pmu)

drivers/perf/arm_smmuv3_pmu.c

187

struct smmu_pmu *smmu_pmu = to_smmu_pmu(pmu);

drivers/perf/arm_smmuv3_pmu.c

198

smmu_pmu_disable(pmu);

drivers/perf/arm_smmuv3_pmu.c

257

struct smmu_pmu *smmu_pmu = to_smmu_pmu(event->pmu);

drivers/perf/arm_smmuv3_pmu.c

305

struct smmu_pmu *smmu_pmu = to_smmu_pmu(event->pmu);

drivers/perf/arm_smmuv3_pmu.c

380

if (new->pmu != curr->pmu)

drivers/perf/arm_smmuv3_pmu.c

383

if (to_smmu_pmu(new->pmu)->global_filter &&

drivers/perf/arm_smmuv3_pmu.c

398

struct smmu_pmu *smmu_pmu = to_smmu_pmu(event->pmu);

drivers/perf/arm_smmuv3_pmu.c

404

if (event->attr.type != event->pmu->type)

drivers/perf/arm_smmuv3_pmu.c

461

struct smmu_pmu *smmu_pmu = to_smmu_pmu(event->pmu);

drivers/perf/arm_smmuv3_pmu.c

474

struct smmu_pmu *smmu_pmu = to_smmu_pmu(event->pmu);

drivers/perf/arm_smmuv3_pmu.c

491

struct smmu_pmu *smmu_pmu = to_smmu_pmu(event->pmu);

drivers/perf/arm_smmuv3_pmu.c

516

struct smmu_pmu *smmu_pmu = to_smmu_pmu(event->pmu);

drivers/perf/arm_smmuv3_pmu.c

681

perf_pmu_migrate_context(&smmu_pmu->pmu, cpu, target);

drivers/perf/arm_smmuv3_pmu.c

729

struct smmu_pmu *pmu = dev_get_drvdata(dev);

drivers/perf/arm_smmuv3_pmu.c

734

writeq_relaxed(doorbell, pmu->reg_base + SMMU_PMCG_IRQ_CFG0);

drivers/perf/arm_smmuv3_pmu.c

735

writel_relaxed(msg->data, pmu->reg_base + SMMU_PMCG_IRQ_CFG1);

drivers/perf/arm_smmuv3_pmu.c

737

pmu->reg_base + SMMU_PMCG_IRQ_CFG2);

drivers/perf/arm_smmuv3_pmu.c

740

static void smmu_pmu_setup_msi(struct smmu_pmu *pmu)

drivers/perf/arm_smmuv3_pmu.c

742

struct device *dev = pmu->dev;

drivers/perf/arm_smmuv3_pmu.c

746

writeq_relaxed(0, pmu->reg_base + SMMU_PMCG_IRQ_CFG0);

drivers/perf/arm_smmuv3_pmu.c

749

if (!(readl(pmu->reg_base + SMMU_PMCG_CFGR) & SMMU_PMCG_CFGR_MSI))

drivers/perf/arm_smmuv3_pmu.c

758

pmu->irq = msi_get_virq(dev, 0);

drivers/perf/arm_smmuv3_pmu.c

764

static int smmu_pmu_setup_irq(struct smmu_pmu *pmu)

drivers/perf/arm_smmuv3_pmu.c

769

smmu_pmu_setup_msi(pmu);

drivers/perf/arm_smmuv3_pmu.c

771

irq = pmu->irq;

drivers/perf/arm_smmuv3_pmu.c

773

ret = devm_request_irq(pmu->dev, irq, smmu_pmu_handle_irq,

drivers/perf/arm_smmuv3_pmu.c

774

flags, "smmuv3-pmu", pmu);

drivers/perf/arm_smmuv3_pmu.c

782

smmu_pmu_disable(&smmu_pmu->pmu);

drivers/perf/arm_smmuv3_pmu.c

864

smmu_pmu->pmu = (struct pmu) {

drivers/perf/arm_smmuv3_pmu.c

937

smmu_pmu->pmu.pmu_enable = smmu_pmu_enable_quirk_hip08_09;

drivers/perf/arm_smmuv3_pmu.c

938

smmu_pmu->pmu.pmu_disable = smmu_pmu_disable_quirk_hip08_09;

drivers/perf/arm_smmuv3_pmu.c

953

err = perf_pmu_register(&smmu_pmu->pmu, name, -1);

drivers/perf/arm_smmuv3_pmu.c

976

perf_pmu_unregister(&smmu_pmu->pmu);

drivers/perf/arm_smmuv3_pmu.c

984

smmu_pmu_disable(&smmu_pmu->pmu);

drivers/perf/arm_spe_pmu.c

100

#define to_spe_pmu(p) (container_of(p, struct arm_spe_pmu, pmu))

drivers/perf/arm_spe_pmu.c

1064

spe_pmu->pmu = (struct pmu) {

drivers/perf/arm_spe_pmu.c

1097

return perf_pmu_register(&spe_pmu->pmu, name, -1);

drivers/perf/arm_spe_pmu.c

1102

perf_pmu_unregister(&spe_pmu->pmu);

drivers/perf/arm_spe_pmu.c

497

struct arm_spe_pmu *spe_pmu = to_spe_pmu(handle->event->pmu);

drivers/perf/arm_spe_pmu.c

525

struct arm_spe_pmu *spe_pmu = to_spe_pmu(handle->event->pmu);

drivers/perf/arm_spe_pmu.c

596

struct arm_spe_pmu *spe_pmu = to_spe_pmu(handle->event->pmu);

drivers/perf/arm_spe_pmu.c

71

struct pmu pmu;

drivers/perf/arm_spe_pmu.c

808

struct arm_spe_pmu *spe_pmu = to_spe_pmu(event->pmu);

drivers/perf/arm_spe_pmu.c

811

if (attr->type != event->pmu->type)

drivers/perf/arm_spe_pmu.c

883

struct arm_spe_pmu *spe_pmu = to_spe_pmu(event->pmu);

drivers/perf/arm_spe_pmu.c

927

struct arm_spe_pmu *spe_pmu = to_spe_pmu(event->pmu);

drivers/perf/arm_spe_pmu.c

969

struct arm_spe_pmu *spe_pmu = to_spe_pmu(event->pmu);

drivers/perf/arm_v7_pmu.c

1494

struct arm_pmu *cpu_pmu = to_arm_pmu(event->pmu);

drivers/perf/arm_v7_pmu.c

1804

struct arm_pmu *cpu_pmu = to_arm_pmu(event->pmu);

drivers/perf/arm_v7_pmu.c

732

struct arm_pmu *cpu_pmu = to_arm_pmu(event->pmu);

drivers/perf/arm_v7_pmu.c

752

struct arm_pmu *cpu_pmu = to_arm_pmu(event->pmu);

drivers/perf/arm_v7_pmu.c

851

struct arm_pmu *cpu_pmu = to_arm_pmu(event->pmu);

drivers/perf/arm_v7_pmu.c

875

struct arm_pmu *cpu_pmu = to_arm_pmu(event->pmu);

drivers/perf/arm_v7_pmu.c

964

struct arm_pmu *cpu_pmu = to_arm_pmu(event->pmu);

drivers/perf/cxl_pmu.c

112

#define pmu_to_cxl_pmu_info(_pmu) container_of(_pmu, struct cxl_pmu_info, pmu)

drivers/perf/cxl_pmu.c

520

struct cxl_pmu_info *info = pmu_to_cxl_pmu_info(event->pmu);

drivers/perf/cxl_pmu.c

563

struct cxl_pmu_info *info = pmu_to_cxl_pmu_info(event->pmu);

drivers/perf/cxl_pmu.c

567

if (event->attr.type != event->pmu->type)

drivers/perf/cxl_pmu.c

588

static void cxl_pmu_enable(struct pmu *pmu)

drivers/perf/cxl_pmu.c

590

struct cxl_pmu_info *info = pmu_to_cxl_pmu_info(pmu);

drivers/perf/cxl_pmu.c

597

static void cxl_pmu_disable(struct pmu *pmu)

drivers/perf/cxl_pmu.c

599

struct cxl_pmu_info *info = pmu_to_cxl_pmu_info(pmu);

drivers/perf/cxl_pmu.c

614

struct cxl_pmu_info *info = pmu_to_cxl_pmu_info(event->pmu);

drivers/perf/cxl_pmu.c

678

struct cxl_pmu_info *info = pmu_to_cxl_pmu_info(event->pmu);

drivers/perf/cxl_pmu.c

686

struct cxl_pmu_info *info = pmu_to_cxl_pmu_info(event->pmu);

drivers/perf/cxl_pmu.c

713

struct cxl_pmu_info *info = pmu_to_cxl_pmu_info(event->pmu);

drivers/perf/cxl_pmu.c

732

struct cxl_pmu_info *info = pmu_to_cxl_pmu_info(event->pmu);

drivers/perf/cxl_pmu.c

758

struct cxl_pmu_info *info = pmu_to_cxl_pmu_info(event->pmu);

drivers/perf/cxl_pmu.c

786

dev_dbg(info->pmu.dev,

drivers/perf/cxl_pmu.c

803

perf_pmu_unregister(&info->pmu);

drivers/perf/cxl_pmu.c

815

struct cxl_pmu *pmu = to_cxl_pmu(dev);

drivers/perf/cxl_pmu.c

830

info->base = pmu->base;

drivers/perf/cxl_pmu.c

842

switch (pmu->type) {

drivers/perf/cxl_pmu.c

845

pmu->assoc_id, pmu->index);

drivers/perf/cxl_pmu.c

851

info->pmu = (struct pmu) {

drivers/perf/cxl_pmu.c

894

rc = perf_pmu_register(&info->pmu, info->pmu.name, -1);

drivers/perf/cxl_pmu.c

939

dev_err(info->pmu.dev, "Unable to find a suitable CPU\n");

drivers/perf/cxl_pmu.c

943

perf_pmu_migrate_context(&info->pmu, cpu, target);

drivers/perf/cxl_pmu.c

96

struct pmu pmu;

drivers/perf/dwc_pcie_pmu.c

101

#define to_dwc_pcie_pmu(p) (container_of(p, struct dwc_pcie_pmu, pmu))

drivers/perf/dwc_pcie_pmu.c

295

struct dwc_pcie_pmu *pcie_pmu = to_dwc_pcie_pmu(event->pmu);

drivers/perf/dwc_pcie_pmu.c

318

struct dwc_pcie_pmu *pcie_pmu = to_dwc_pcie_pmu(event->pmu);

drivers/perf/dwc_pcie_pmu.c

434

struct dwc_pcie_pmu *pcie_pmu = to_dwc_pcie_pmu(event->pmu);

drivers/perf/dwc_pcie_pmu.c

439

if (event->attr.type != event->pmu->type)

drivers/perf/dwc_pcie_pmu.c

451

if (sibling->pmu != event->pmu && !is_software_event(sibling))

drivers/perf/dwc_pcie_pmu.c

475

struct dwc_pcie_pmu *pcie_pmu = to_dwc_pcie_pmu(event->pmu);

drivers/perf/dwc_pcie_pmu.c

489

struct dwc_pcie_pmu *pcie_pmu = to_dwc_pcie_pmu(event->pmu);

drivers/perf/dwc_pcie_pmu.c

508

struct dwc_pcie_pmu *pcie_pmu = to_dwc_pcie_pmu(event->pmu);

drivers/perf/dwc_pcie_pmu.c

564

struct dwc_pcie_pmu *pcie_pmu = to_dwc_pcie_pmu(event->pmu);

drivers/perf/dwc_pcie_pmu.c

607

perf_pmu_unregister(&pcie_pmu->pmu);

drivers/perf/dwc_pcie_pmu.c

729

pcie_pmu->pmu = (struct pmu){

drivers/perf/dwc_pcie_pmu.c

759

ret = perf_pmu_register(&pcie_pmu->pmu, name, -1);

drivers/perf/dwc_pcie_pmu.c

810

perf_pmu_migrate_context(&pcie_pmu->pmu, cpu, target);

drivers/perf/dwc_pcie_pmu.c

88

struct pmu pmu;

drivers/perf/fsl_imx8_ddr_perf.c

130

struct pmu pmu;

drivers/perf/fsl_imx8_ddr_perf.c

147

struct ddr_pmu *pmu = dev_get_drvdata(dev);

drivers/perf/fsl_imx8_ddr_perf.c

149

return sysfs_emit(page, "%s\n", pmu->devtype_data->identifier);

drivers/perf/fsl_imx8_ddr_perf.c

157

struct ddr_pmu *pmu = dev_get_drvdata(dev);

drivers/perf/fsl_imx8_ddr_perf.c

159

if (!pmu->devtype_data->identifier)

drivers/perf/fsl_imx8_ddr_perf.c

184

static u32 ddr_perf_filter_cap_get(struct ddr_pmu *pmu, int cap)

drivers/perf/fsl_imx8_ddr_perf.c

186

u32 quirks = pmu->devtype_data->quirks;

drivers/perf/fsl_imx8_ddr_perf.c

207

struct ddr_pmu *pmu = dev_get_drvdata(dev);

drivers/perf/fsl_imx8_ddr_perf.c

212

return sysfs_emit(buf, "%u\n", ddr_perf_filter_cap_get(pmu, cap));

drivers/perf/fsl_imx8_ddr_perf.c

238

struct ddr_pmu *pmu = dev_get_drvdata(dev);

drivers/perf/fsl_imx8_ddr_perf.c

240

return cpumap_print_to_pagebuf(true, buf, cpumask_of(pmu->cpu));

drivers/perf/fsl_imx8_ddr_perf.c

314

struct ddr_pmu *pmu = dev_get_drvdata(dev);

drivers/perf/fsl_imx8_ddr_perf.c

320

if (pmu->devtype_data->type == DDR_PERF_TYPE)

drivers/perf/fsl_imx8_ddr_perf.c

389

struct ddr_pmu *pmu = to_ddr_pmu(event->pmu);

drivers/perf/fsl_imx8_ddr_perf.c

391

filt = pmu->devtype_data->quirks & DDR_CAP_AXI_ID_FILTER_ENHANCED;

drivers/perf/fsl_imx8_ddr_perf.c

396

static u32 ddr_perf_alloc_counter(struct ddr_pmu *pmu, int event)

drivers/perf/fsl_imx8_ddr_perf.c

406

if (pmu->events[EVENT_CYCLES_COUNTER] == NULL)

drivers/perf/fsl_imx8_ddr_perf.c

413

if (pmu->events[i] == NULL)

drivers/perf/fsl_imx8_ddr_perf.c

420

static void ddr_perf_free_counter(struct ddr_pmu *pmu, int counter)

drivers/perf/fsl_imx8_ddr_perf.c

422

pmu->events[counter] = NULL;

drivers/perf/fsl_imx8_ddr_perf.c

425

static u32 ddr_perf_read_counter(struct ddr_pmu *pmu, int counter)

drivers/perf/fsl_imx8_ddr_perf.c

427

struct perf_event *event = pmu->events[counter];

drivers/perf/fsl_imx8_ddr_perf.c

428

void __iomem *base = pmu->base;

drivers/perf/fsl_imx8_ddr_perf.c

442

struct ddr_pmu *pmu = to_ddr_pmu(event->pmu);

drivers/perf/fsl_imx8_ddr_perf.c

446

if (event->attr.type != event->pmu->type)

drivers/perf/fsl_imx8_ddr_perf.c

453

dev_warn(pmu->dev, "Can't provide per-task data!\n");

drivers/perf/fsl_imx8_ddr_perf.c

462

if (event->group_leader->pmu != event->pmu &&

drivers/perf/fsl_imx8_ddr_perf.c

466

if (pmu->devtype_data->quirks & DDR_CAP_AXI_ID_FILTER) {

drivers/perf/fsl_imx8_ddr_perf.c

476

if (sibling->pmu != event->pmu &&

drivers/perf/fsl_imx8_ddr_perf.c

481

event->cpu = pmu->cpu;

drivers/perf/fsl_imx8_ddr_perf.c

487

static void ddr_perf_counter_enable(struct ddr_pmu *pmu, int config,

drivers/perf/fsl_imx8_ddr_perf.c

500

writel(0, pmu->base + reg);

drivers/perf/fsl_imx8_ddr_perf.c

509

if (pmu->devtype_data->quirks & DDR_CAP_AXI_ID_FILTER_ENHANCED) {

drivers/perf/fsl_imx8_ddr_perf.c

514

writel(val, pmu->base + reg);

drivers/perf/fsl_imx8_ddr_perf.c

517

val = readl_relaxed(pmu->base + reg) & CNTL_EN_MASK;

drivers/perf/fsl_imx8_ddr_perf.c

518

writel(val, pmu->base + reg);

drivers/perf/fsl_imx8_ddr_perf.c

522

static bool ddr_perf_counter_overflow(struct ddr_pmu *pmu, int counter)

drivers/perf/fsl_imx8_ddr_perf.c

526

val = readl_relaxed(pmu->base + counter * 4 + COUNTER_CNTL);

drivers/perf/fsl_imx8_ddr_perf.c

53

#define to_ddr_pmu(p) container_of(p, struct ddr_pmu, pmu)

drivers/perf/fsl_imx8_ddr_perf.c

531

static void ddr_perf_counter_clear(struct ddr_pmu *pmu, int counter)

drivers/perf/fsl_imx8_ddr_perf.c

536

val = readl_relaxed(pmu->base + reg);

drivers/perf/fsl_imx8_ddr_perf.c

538

writel(val, pmu->base + reg);

drivers/perf/fsl_imx8_ddr_perf.c

541

writel(val, pmu->base + reg);

drivers/perf/fsl_imx8_ddr_perf.c

546

struct ddr_pmu *pmu = to_ddr_pmu(event->pmu);

drivers/perf/fsl_imx8_ddr_perf.c

552

new_raw_count = ddr_perf_read_counter(pmu, counter);

drivers/perf/fsl_imx8_ddr_perf.c

554

if (pmu->devtype_data->quirks & DDR_CAP_AXI_ID_FILTER_ENHANCED) {

drivers/perf/fsl_imx8_ddr_perf.c

568

ret = ddr_perf_counter_overflow(pmu, counter);

drivers/perf/fsl_imx8_ddr_perf.c

570

dev_warn_ratelimited(pmu->dev, "events lost due to counter overflow (config 0x%llx)\n",

drivers/perf/fsl_imx8_ddr_perf.c

575

ddr_perf_counter_clear(pmu, counter);

drivers/perf/fsl_imx8_ddr_perf.c

580

struct ddr_pmu *pmu = to_ddr_pmu(event->pmu);

drivers/perf/fsl_imx8_ddr_perf.c

586

ddr_perf_counter_enable(pmu, event->attr.config, counter, true);

drivers/perf/fsl_imx8_ddr_perf.c

588

if (!pmu->active_counter++)

drivers/perf/fsl_imx8_ddr_perf.c

589

ddr_perf_counter_enable(pmu, EVENT_CYCLES_ID,

drivers/perf/fsl_imx8_ddr_perf.c

597

struct ddr_pmu *pmu = to_ddr_pmu(event->pmu);

drivers/perf/fsl_imx8_ddr_perf.c

604

if (pmu->devtype_data->quirks & DDR_CAP_AXI_ID_FILTER) {

drivers/perf/fsl_imx8_ddr_perf.c

608

if (pmu->events[i] &&

drivers/perf/fsl_imx8_ddr_perf.c

609

!ddr_perf_filters_compatible(event, pmu->events[i]))

drivers/perf/fsl_imx8_ddr_perf.c

616

writel(cfg1, pmu->base + COUNTER_DPCR1);

drivers/perf/fsl_imx8_ddr_perf.c

620

counter = ddr_perf_alloc_counter(pmu, cfg);

drivers/perf/fsl_imx8_ddr_perf.c

622

dev_dbg(pmu->dev, "There are not enough counters\n");

drivers/perf/fsl_imx8_ddr_perf.c

626

if (pmu->devtype_data->quirks & DDR_CAP_AXI_ID_PORT_CHANNEL_FILTER) {

drivers/perf/fsl_imx8_ddr_perf.c

630

writel(cfg1, pmu->base + COUNTER_MASK_COMP + ((counter - 1) << 4));

drivers/perf/fsl_imx8_ddr_perf.c

642

writel(cfg2, pmu->base + COUNTER_MUX_CNTL + ((counter - 1) << 4));

drivers/perf/fsl_imx8_ddr_perf.c

646

pmu->events[counter] = event;

drivers/perf/fsl_imx8_ddr_perf.c

659

struct ddr_pmu *pmu = to_ddr_pmu(event->pmu);

drivers/perf/fsl_imx8_ddr_perf.c

663

ddr_perf_counter_enable(pmu, event->attr.config, counter, false);

drivers/perf/fsl_imx8_ddr_perf.c

666

if (!--pmu->active_counter)

drivers/perf/fsl_imx8_ddr_perf.c

667

ddr_perf_counter_enable(pmu, EVENT_CYCLES_ID,

drivers/perf/fsl_imx8_ddr_perf.c

675

struct ddr_pmu *pmu = to_ddr_pmu(event->pmu);

drivers/perf/fsl_imx8_ddr_perf.c

681

ddr_perf_free_counter(pmu, counter);

drivers/perf/fsl_imx8_ddr_perf.c

685

static void ddr_perf_pmu_enable(struct pmu *pmu)

drivers/perf/fsl_imx8_ddr_perf.c

689

static void ddr_perf_pmu_disable(struct pmu *pmu)

drivers/perf/fsl_imx8_ddr_perf.c

693

static void ddr_perf_init(struct ddr_pmu *pmu, void __iomem *base,

drivers/perf/fsl_imx8_ddr_perf.c

696

*pmu = (struct ddr_pmu) {

drivers/perf/fsl_imx8_ddr_perf.c

697

.pmu = (struct pmu) {

drivers/perf/fsl_imx8_ddr_perf.c

720

struct ddr_pmu *pmu = (struct ddr_pmu *) p;

drivers/perf/fsl_imx8_ddr_perf.c

724

ddr_perf_counter_enable(pmu,

drivers/perf/fsl_imx8_ddr_perf.c

742

if (!pmu->events[i])

drivers/perf/fsl_imx8_ddr_perf.c

745

event = pmu->events[i];

drivers/perf/fsl_imx8_ddr_perf.c

750

ddr_perf_counter_enable(pmu,

drivers/perf/fsl_imx8_ddr_perf.c

760

struct ddr_pmu *pmu = hlist_entry_safe(node, struct ddr_pmu, node);

drivers/perf/fsl_imx8_ddr_perf.c

763

if (cpu != pmu->cpu)

drivers/perf/fsl_imx8_ddr_perf.c

770

perf_pmu_migrate_context(&pmu->pmu, cpu, target);

drivers/perf/fsl_imx8_ddr_perf.c

771

pmu->cpu = target;

drivers/perf/fsl_imx8_ddr_perf.c

773

WARN_ON(irq_set_affinity(pmu->irq, cpumask_of(pmu->cpu)));

drivers/perf/fsl_imx8_ddr_perf.c

781

struct ddr_pmu *pmu;

drivers/perf/fsl_imx8_ddr_perf.c

797

pmu = devm_kzalloc(&pdev->dev, sizeof(*pmu), GFP_KERNEL);

drivers/perf/fsl_imx8_ddr_perf.c

798

if (!pmu)

drivers/perf/fsl_imx8_ddr_perf.c

801

ddr_perf_init(pmu, base, &pdev->dev);

drivers/perf/fsl_imx8_ddr_perf.c

803

platform_set_drvdata(pdev, pmu);

drivers/perf/fsl_imx8_ddr_perf.c

809

pmu->devtype_data = of_device_get_match_data(&pdev->dev);

drivers/perf/fsl_imx8_ddr_perf.c

811

ida = pmu->devtype_data->type == DDR_PERF_TYPE ? &ddr_ida : &db_ida;

drivers/perf/fsl_imx8_ddr_perf.c

816

pmu->id = num;

drivers/perf/fsl_imx8_ddr_perf.c

818

if (pmu->devtype_data->type == DDR_PERF_TYPE)

drivers/perf/fsl_imx8_ddr_perf.c

828

pmu->cpu = raw_smp_processor_id();

drivers/perf/fsl_imx8_ddr_perf.c

839

pmu->cpuhp_state = ret;

drivers/perf/fsl_imx8_ddr_perf.c

842

ret = cpuhp_state_add_instance_nocalls(pmu->cpuhp_state, &pmu->node);

drivers/perf/fsl_imx8_ddr_perf.c

860

pmu);

drivers/perf/fsl_imx8_ddr_perf.c

866

pmu->irq = irq;

drivers/perf/fsl_imx8_ddr_perf.c

867

ret = irq_set_affinity(pmu->irq, cpumask_of(pmu->cpu));

drivers/perf/fsl_imx8_ddr_perf.c

869

dev_err(pmu->dev, "Failed to set interrupt affinity!\n");

drivers/perf/fsl_imx8_ddr_perf.c

873

ret = perf_pmu_register(&pmu->pmu, name, -1);

drivers/perf/fsl_imx8_ddr_perf.c

880

cpuhp_state_remove_instance_nocalls(pmu->cpuhp_state, &pmu->node);

drivers/perf/fsl_imx8_ddr_perf.c

882

cpuhp_remove_multi_state(pmu->cpuhp_state);

drivers/perf/fsl_imx8_ddr_perf.c

884

ida_free(ida, pmu->id);

drivers/perf/fsl_imx8_ddr_perf.c

891

struct ddr_pmu *pmu = platform_get_drvdata(pdev);

drivers/perf/fsl_imx8_ddr_perf.c

893

cpuhp_state_remove_instance_nocalls(pmu->cpuhp_state, &pmu->node);

drivers/perf/fsl_imx8_ddr_perf.c

894

cpuhp_remove_multi_state(pmu->cpuhp_state);

drivers/perf/fsl_imx8_ddr_perf.c

896

perf_pmu_unregister(&pmu->pmu);

drivers/perf/fsl_imx8_ddr_perf.c

898

if (pmu->devtype_data->type == DDR_PERF_TYPE)

drivers/perf/fsl_imx8_ddr_perf.c

899

ida_free(&ddr_ida, pmu->id);

drivers/perf/fsl_imx8_ddr_perf.c

901

ida_free(&db_ida, pmu->id);

drivers/perf/fsl_imx9_ddr_perf.c

117

static inline bool axi_filter_v1(struct ddr_pmu *pmu)

drivers/perf/fsl_imx9_ddr_perf.c

119

return pmu->devtype_data->filter_ver == DDR_PERF_AXI_FILTER_V1;

drivers/perf/fsl_imx9_ddr_perf.c

122

static inline bool axi_filter_v2(struct ddr_pmu *pmu)

drivers/perf/fsl_imx9_ddr_perf.c

124

return pmu->devtype_data->filter_ver == DDR_PERF_AXI_FILTER_V2;

drivers/perf/fsl_imx9_ddr_perf.c

140

struct ddr_pmu *pmu = dev_get_drvdata(dev);

drivers/perf/fsl_imx9_ddr_perf.c

142

return sysfs_emit(page, "%s\n", pmu->devtype_data->identifier);

drivers/perf/fsl_imx9_ddr_perf.c

160

struct ddr_pmu *pmu = dev_get_drvdata(dev);

drivers/perf/fsl_imx9_ddr_perf.c

162

return cpumap_print_to_pagebuf(true, buf, cpumask_of(pmu->cpu));

drivers/perf/fsl_imx9_ddr_perf.c

323

struct pmu *pmu = dev_get_drvdata(kobj_to_dev(kobj));

drivers/perf/fsl_imx9_ddr_perf.c

324

struct ddr_pmu *ddr_pmu = to_ddr_pmu(pmu);

drivers/perf/fsl_imx9_ddr_perf.c

371

static void ddr_perf_clear_counter(struct ddr_pmu *pmu, int counter)

drivers/perf/fsl_imx9_ddr_perf.c

374

writel(0, pmu->base + PMC(counter) + 0x4);

drivers/perf/fsl_imx9_ddr_perf.c

375

writel(0, pmu->base + PMC(counter));

drivers/perf/fsl_imx9_ddr_perf.c

377

writel(0, pmu->base + PMC(counter));

drivers/perf/fsl_imx9_ddr_perf.c

381

static u64 ddr_perf_read_counter(struct ddr_pmu *pmu, int counter)

drivers/perf/fsl_imx9_ddr_perf.c

387

val = readl_relaxed(pmu->base + PMC(counter));

drivers/perf/fsl_imx9_ddr_perf.c

393

val_upper = readl_relaxed(pmu->base + PMC(counter) + 0x4);

drivers/perf/fsl_imx9_ddr_perf.c

394

val_lower = readl_relaxed(pmu->base + PMC(counter));

drivers/perf/fsl_imx9_ddr_perf.c

395

} while (val_upper != readl_relaxed(pmu->base + PMC(counter) + 0x4));

drivers/perf/fsl_imx9_ddr_perf.c

404

static void ddr_perf_counter_global_config(struct ddr_pmu *pmu, bool enable)

drivers/perf/fsl_imx9_ddr_perf.c

408

ctrl = readl_relaxed(pmu->base + PMGC0);

drivers/perf/fsl_imx9_ddr_perf.c

422

writel(ctrl, pmu->base + PMGC0);

drivers/perf/fsl_imx9_ddr_perf.c

430

writel(ctrl, pmu->base + PMGC0);

drivers/perf/fsl_imx9_ddr_perf.c

434

writel(ctrl, pmu->base + PMGC0);

drivers/perf/fsl_imx9_ddr_perf.c

438

static void ddr_perf_counter_local_config(struct ddr_pmu *pmu, int config,

drivers/perf/fsl_imx9_ddr_perf.c

444

ctrl_a = readl_relaxed(pmu->base + PMLCA(counter));

drivers/perf/fsl_imx9_ddr_perf.c

449

writel(ctrl_a, pmu->base + PMLCA(counter));

drivers/perf/fsl_imx9_ddr_perf.c

451

ddr_perf_clear_counter(pmu, counter);

drivers/perf/fsl_imx9_ddr_perf.c

458

writel(ctrl_a, pmu->base + PMLCA(counter));

drivers/perf/fsl_imx9_ddr_perf.c

462

writel(ctrl_a, pmu->base + PMLCA(counter));

drivers/perf/fsl_imx9_ddr_perf.c

466

static void imx93_ddr_perf_monitor_config(struct ddr_pmu *pmu, int event,

drivers/perf/fsl_imx9_ddr_perf.c

476

pmcfg1 = readl_relaxed(pmu->base + PMCFG1);

drivers/perf/fsl_imx9_ddr_perf.c

484

writel_relaxed(pmcfg1, pmu->base + PMCFG1);

drivers/perf/fsl_imx9_ddr_perf.c

486

pmcfg2 = readl_relaxed(pmu->base + PMCFG2);

drivers/perf/fsl_imx9_ddr_perf.c

489

writel_relaxed(pmcfg2, pmu->base + PMCFG2);

drivers/perf/fsl_imx9_ddr_perf.c

492

static void imx95_ddr_perf_monitor_config(struct ddr_pmu *pmu, int event,

drivers/perf/fsl_imx9_ddr_perf.c

497

pmcfg1 = readl_relaxed(pmu->base + PMCFG1);

drivers/perf/fsl_imx9_ddr_perf.c

531

writel_relaxed(pmcfg1, pmu->base + PMCFG1);

drivers/perf/fsl_imx9_ddr_perf.c

534

pmcfg = readl_relaxed(pmu->base + offset);

drivers/perf/fsl_imx9_ddr_perf.c

539

writel_relaxed(pmcfg, pmu->base + offset);

drivers/perf/fsl_imx9_ddr_perf.c

545

struct ddr_pmu *pmu = to_ddr_pmu(event->pmu);

drivers/perf/fsl_imx9_ddr_perf.c

550

new_raw_count = ddr_perf_read_counter(pmu, counter);

drivers/perf/fsl_imx9_ddr_perf.c

554

ddr_perf_clear_counter(pmu, counter);

drivers/perf/fsl_imx9_ddr_perf.c

559

struct ddr_pmu *pmu = to_ddr_pmu(event->pmu);

drivers/perf/fsl_imx9_ddr_perf.c

563

if (event->attr.type != event->pmu->type)

drivers/perf/fsl_imx9_ddr_perf.c

570

dev_warn(pmu->dev, "Can't provide per-task data!\n");

drivers/perf/fsl_imx9_ddr_perf.c

579

if (event->group_leader->pmu != event->pmu &&

drivers/perf/fsl_imx9_ddr_perf.c

584

if (sibling->pmu != event->pmu &&

drivers/perf/fsl_imx9_ddr_perf.c

589

event->cpu = pmu->cpu;

drivers/perf/fsl_imx9_ddr_perf.c

59

#define to_ddr_pmu(p) container_of(p, struct ddr_pmu, pmu)

drivers/perf/fsl_imx9_ddr_perf.c

597

struct ddr_pmu *pmu = to_ddr_pmu(event->pmu);

drivers/perf/fsl_imx9_ddr_perf.c

603

ddr_perf_counter_local_config(pmu, event->attr.config, counter, true);

drivers/perf/fsl_imx9_ddr_perf.c

607

static int ddr_perf_alloc_counter(struct ddr_pmu *pmu, int event, int counter)

drivers/perf/fsl_imx9_ddr_perf.c

613

if (pmu->events[CYCLES_COUNTER] == NULL)

drivers/perf/fsl_imx9_ddr_perf.c

617

if (pmu->events[counter] == NULL)

drivers/perf/fsl_imx9_ddr_perf.c

622

if (pmu->events[i] == NULL)

drivers/perf/fsl_imx9_ddr_perf.c

631

struct ddr_pmu *pmu = to_ddr_pmu(event->pmu);

drivers/perf/fsl_imx9_ddr_perf.c

641

counter = ddr_perf_alloc_counter(pmu, event_id, counter);

drivers/perf/fsl_imx9_ddr_perf.c

643

dev_dbg(pmu->dev, "There are not enough counters\n");

drivers/perf/fsl_imx9_ddr_perf.c

647

pmu->events[counter] = event;

drivers/perf/fsl_imx9_ddr_perf.c

648

pmu->active_events++;

drivers/perf/fsl_imx9_ddr_perf.c

652

if (axi_filter_v1(pmu))

drivers/perf/fsl_imx9_ddr_perf.c

654

imx93_ddr_perf_monitor_config(pmu, event_id, counter, cfg1, cfg2);

drivers/perf/fsl_imx9_ddr_perf.c

656

if (axi_filter_v2(pmu))

drivers/perf/fsl_imx9_ddr_perf.c

658

imx95_ddr_perf_monitor_config(pmu, event_id, counter, cfg1, cfg2);

drivers/perf/fsl_imx9_ddr_perf.c

668

struct ddr_pmu *pmu = to_ddr_pmu(event->pmu);

drivers/perf/fsl_imx9_ddr_perf.c

672

ddr_perf_counter_local_config(pmu, event->attr.config, counter, false);

drivers/perf/fsl_imx9_ddr_perf.c

680

struct ddr_pmu *pmu = to_ddr_pmu(event->pmu);

drivers/perf/fsl_imx9_ddr_perf.c

686

pmu->events[counter] = NULL;

drivers/perf/fsl_imx9_ddr_perf.c

687

pmu->active_events--;

drivers/perf/fsl_imx9_ddr_perf.c

691

static void ddr_perf_pmu_enable(struct pmu *pmu)

drivers/perf/fsl_imx9_ddr_perf.c

693

struct ddr_pmu *ddr_pmu = to_ddr_pmu(pmu);

drivers/perf/fsl_imx9_ddr_perf.c

698

static void ddr_perf_pmu_disable(struct pmu *pmu)

drivers/perf/fsl_imx9_ddr_perf.c

700

struct ddr_pmu *ddr_pmu = to_ddr_pmu(pmu);

drivers/perf/fsl_imx9_ddr_perf.c

705

static void ddr_perf_init(struct ddr_pmu *pmu, void __iomem *base,

drivers/perf/fsl_imx9_ddr_perf.c

708

*pmu = (struct ddr_pmu) {

drivers/perf/fsl_imx9_ddr_perf.c

709

.pmu = (struct pmu) {

drivers/perf/fsl_imx9_ddr_perf.c

730

struct ddr_pmu *pmu = (struct ddr_pmu *)p;

drivers/perf/fsl_imx9_ddr_perf.c

746

if (!pmu->events[i])

drivers/perf/fsl_imx9_ddr_perf.c

749

event = pmu->events[i];

drivers/perf/fsl_imx9_ddr_perf.c

754

ddr_perf_counter_global_config(pmu, true);

drivers/perf/fsl_imx9_ddr_perf.c

761

struct ddr_pmu *pmu = hlist_entry_safe(node, struct ddr_pmu, node);

drivers/perf/fsl_imx9_ddr_perf.c

764

if (cpu != pmu->cpu)

drivers/perf/fsl_imx9_ddr_perf.c

771

perf_pmu_migrate_context(&pmu->pmu, cpu, target);

drivers/perf/fsl_imx9_ddr_perf.c

772

pmu->cpu = target;

drivers/perf/fsl_imx9_ddr_perf.c

774

WARN_ON(irq_set_affinity(pmu->irq, cpumask_of(pmu->cpu)));

drivers/perf/fsl_imx9_ddr_perf.c

781

struct ddr_pmu *pmu;

drivers/perf/fsl_imx9_ddr_perf.c

790

pmu = devm_kzalloc(&pdev->dev, sizeof(*pmu), GFP_KERNEL);

drivers/perf/fsl_imx9_ddr_perf.c

791

if (!pmu)

drivers/perf/fsl_imx9_ddr_perf.c

794

ddr_perf_init(pmu, base, &pdev->dev);

drivers/perf/fsl_imx9_ddr_perf.c

796

pmu->devtype_data = of_device_get_match_data(&pdev->dev);

drivers/perf/fsl_imx9_ddr_perf.c

798

platform_set_drvdata(pdev, pmu);

drivers/perf/fsl_imx9_ddr_perf.c

800

pmu->id = ida_alloc(&ddr_ida, GFP_KERNEL);

drivers/perf/fsl_imx9_ddr_perf.c

801

name = devm_kasprintf(&pdev->dev, GFP_KERNEL, DDR_PERF_DEV_NAME "%d", pmu->id);

drivers/perf/fsl_imx9_ddr_perf.c

807

pmu->cpu = raw_smp_processor_id();

drivers/perf/fsl_imx9_ddr_perf.c

814

pmu->cpuhp_state = ret;

drivers/perf/fsl_imx9_ddr_perf.c

817

ret = cpuhp_state_add_instance_nocalls(pmu->cpuhp_state, &pmu->node);

drivers/perf/fsl_imx9_ddr_perf.c

832

DDR_CPUHP_CB_NAME, pmu);

drivers/perf/fsl_imx9_ddr_perf.c

838

pmu->irq = irq;

drivers/perf/fsl_imx9_ddr_perf.c

839

ret = irq_set_affinity(pmu->irq, cpumask_of(pmu->cpu));

drivers/perf/fsl_imx9_ddr_perf.c

84

struct pmu pmu;

drivers/perf/fsl_imx9_ddr_perf.c

841

dev_err(pmu->dev, "Failed to set interrupt affinity\n");

drivers/perf/fsl_imx9_ddr_perf.c

845

ret = perf_pmu_register(&pmu->pmu, name, -1);

drivers/perf/fsl_imx9_ddr_perf.c

852

cpuhp_state_remove_instance_nocalls(pmu->cpuhp_state, &pmu->node);

drivers/perf/fsl_imx9_ddr_perf.c

854

cpuhp_remove_multi_state(pmu->cpuhp_state);

drivers/perf/fsl_imx9_ddr_perf.c

857

ida_free(&ddr_ida, pmu->id);

drivers/perf/fsl_imx9_ddr_perf.c

864

struct ddr_pmu *pmu = platform_get_drvdata(pdev);

drivers/perf/fsl_imx9_ddr_perf.c

866

cpuhp_state_remove_instance_nocalls(pmu->cpuhp_state, &pmu->node);

drivers/perf/fsl_imx9_ddr_perf.c

867

cpuhp_remove_multi_state(pmu->cpuhp_state);

drivers/perf/fsl_imx9_ddr_perf.c

869

perf_pmu_unregister(&pmu->pmu);

drivers/perf/fsl_imx9_ddr_perf.c

871

ida_free(&ddr_ida, pmu->id);

drivers/perf/fujitsu_uncore_pmu.c

104

struct uncore_pmu *uncorepmu = to_uncore_pmu(event->pmu);

drivers/perf/fujitsu_uncore_pmu.c

159

static void fujitsu_uncore_pmu_enable(struct pmu *pmu)

drivers/perf/fujitsu_uncore_pmu.c

161

writeq_relaxed(PM_CR_ENABLE, to_uncore_pmu(pmu)->regs + PM_CR);

drivers/perf/fujitsu_uncore_pmu.c

164

static void fujitsu_uncore_pmu_disable(struct pmu *pmu)

drivers/perf/fujitsu_uncore_pmu.c

166

writeq_relaxed(0, to_uncore_pmu(pmu)->regs + PM_CR);

drivers/perf/fujitsu_uncore_pmu.c

171

struct uncore_pmu *uncorepmu = to_uncore_pmu(event->pmu);

drivers/perf/fujitsu_uncore_pmu.c

179

if (leader->pmu == event->pmu)

drivers/perf/fujitsu_uncore_pmu.c

183

if (sibling->pmu == event->pmu)

drivers/perf/fujitsu_uncore_pmu.c

196

struct uncore_pmu *uncorepmu = to_uncore_pmu(event->pmu);

drivers/perf/fujitsu_uncore_pmu.c

200

if (event->attr.type != event->pmu->type)

drivers/perf/fujitsu_uncore_pmu.c

251

struct uncore_pmu *uncorepmu = to_uncore_pmu(event->pmu);

drivers/perf/fujitsu_uncore_pmu.c

276

struct uncore_pmu *uncorepmu = to_uncore_pmu(event->pmu);

drivers/perf/fujitsu_uncore_pmu.c

406

perf_pmu_migrate_context(&uncorepmu->pmu, uncorepmu->cpu, cpu);

drivers/perf/fujitsu_uncore_pmu.c

488

uncorepmu->pmu = (struct pmu) {

drivers/perf/fujitsu_uncore_pmu.c

543

ret = perf_pmu_register(&uncorepmu->pmu, name, -1);

drivers/perf/fujitsu_uncore_pmu.c

549

dev_dbg(dev, "Registered %s, type: %d\n", name, uncorepmu->pmu.type);

drivers/perf/fujitsu_uncore_pmu.c

56

struct pmu pmu;

drivers/perf/fujitsu_uncore_pmu.c

560

perf_pmu_unregister(&uncorepmu->pmu);

drivers/perf/fujitsu_uncore_pmu.c

66

#define to_uncore_pmu(p) (container_of(p, struct uncore_pmu, pmu))

drivers/perf/fujitsu_uncore_pmu.c

72

struct uncore_pmu *uncorepmu = to_uncore_pmu(event->pmu);

drivers/perf/fujitsu_uncore_pmu.c

92

struct uncore_pmu *uncorepmu = to_uncore_pmu(event->pmu);

drivers/perf/hisilicon/hisi_pcie_pmu.c

267

struct hisi_pcie_pmu *pcie_pmu = to_pcie_pmu(event->pmu);

drivers/perf/hisilicon/hisi_pcie_pmu.c

276

struct hisi_pcie_pmu *pcie_pmu = to_pcie_pmu(event->pmu);

drivers/perf/hisilicon/hisi_pcie_pmu.c

343

if (leader->pmu != event->pmu)

drivers/perf/hisilicon/hisi_pcie_pmu.c

354

if (sibling->pmu != event->pmu)

drivers/perf/hisilicon/hisi_pcie_pmu.c

383

struct hisi_pcie_pmu *pcie_pmu = to_pcie_pmu(event->pmu);

drivers/perf/hisilicon/hisi_pcie_pmu.c

387

if (event->attr.type != event->pmu->type)

drivers/perf/hisilicon/hisi_pcie_pmu.c

412

struct hisi_pcie_pmu *pcie_pmu = to_pcie_pmu(event->pmu);

drivers/perf/hisilicon/hisi_pcie_pmu.c

468

struct hisi_pcie_pmu *pcie_pmu = to_pcie_pmu(event->pmu);

drivers/perf/hisilicon/hisi_pcie_pmu.c

533

struct hisi_pcie_pmu *pcie_pmu = to_pcie_pmu(event->pmu);

drivers/perf/hisilicon/hisi_pcie_pmu.c

559

struct hisi_pcie_pmu *pcie_pmu = to_pcie_pmu(event->pmu);

drivers/perf/hisilicon/hisi_pcie_pmu.c

577

struct hisi_pcie_pmu *pcie_pmu = to_pcie_pmu(event->pmu);

drivers/perf/hisilicon/hisi_pcie_pmu.c

603

struct hisi_pcie_pmu *pcie_pmu = to_pcie_pmu(event->pmu);

drivers/perf/hisilicon/hisi_pcie_pmu.c

611

static void hisi_pcie_pmu_enable(struct pmu *pmu)

drivers/perf/hisilicon/hisi_pcie_pmu.c

613

struct hisi_pcie_pmu *pcie_pmu = to_pcie_pmu(pmu);

drivers/perf/hisilicon/hisi_pcie_pmu.c

627

static void hisi_pcie_pmu_disable(struct pmu *pmu)

drivers/perf/hisilicon/hisi_pcie_pmu.c

629

struct hisi_pcie_pmu *pcie_pmu = to_pcie_pmu(pmu);

drivers/perf/hisilicon/hisi_pcie_pmu.c

69

struct pmu pmu;

drivers/perf/hisilicon/hisi_pcie_pmu.c

728

perf_pmu_migrate_context(&pcie_pmu->pmu, cpu, target);

drivers/perf/hisilicon/hisi_pcie_pmu.c

839

pcie_pmu->pmu = (struct pmu) {

drivers/perf/hisilicon/hisi_pcie_pmu.c

84

#define to_pcie_pmu(p) (container_of((p), struct hisi_pcie_pmu, pmu))

drivers/perf/hisilicon/hisi_pcie_pmu.c

883

ret = perf_pmu_register(&pcie_pmu->pmu, pcie_pmu->pmu.name, -1);

drivers/perf/hisilicon/hisi_pcie_pmu.c

908

perf_pmu_unregister(&pcie_pmu->pmu);

drivers/perf/hisilicon/hisi_uncore_cpa_pmu.c

306

ret = perf_pmu_register(&cpa_pmu->pmu, name, -1);

drivers/perf/hisilicon/hisi_uncore_cpa_pmu.c

323

perf_pmu_unregister(&cpa_pmu->pmu);

drivers/perf/hisilicon/hisi_uncore_ddrc_pmu.c

126

struct hisi_pmu *ddrc_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_ddrc_pmu.c

142

struct hisi_pmu *ddrc_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_ddrc_pmu.c

413

ret = perf_pmu_register(&ddrc_pmu->pmu, name, -1);

drivers/perf/hisilicon/hisi_uncore_ddrc_pmu.c

427

perf_pmu_unregister(&ddrc_pmu->pmu);

drivers/perf/hisilicon/hisi_uncore_hha_pmu.c

113

struct hisi_pmu *hha_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_hha_pmu.c

129

struct hisi_pmu *hha_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_hha_pmu.c

502

ret = perf_pmu_register(&hha_pmu->pmu, name, -1);

drivers/perf/hisilicon/hisi_uncore_hha_pmu.c

516

perf_pmu_unregister(&hha_pmu->pmu);

drivers/perf/hisilicon/hisi_uncore_hha_pmu.c

61

struct hisi_pmu *hha_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_hha_pmu.c

75

struct hisi_pmu *hha_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_hha_pmu.c

85

struct hisi_pmu *hha_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_hha_pmu.c

99

struct hisi_pmu *hha_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_l3c_pmu.c

120

struct hisi_pmu *l3c_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_l3c_pmu.c

347

struct hisi_pmu *l3c_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_l3c_pmu.c

857

ret = perf_pmu_register(&l3c_pmu->pmu, name, -1);

drivers/perf/hisilicon/hisi_uncore_l3c_pmu.c

871

perf_pmu_unregister(&l3c_pmu->pmu);

drivers/perf/hisilicon/hisi_uncore_l3c_pmu.c

96

static bool support_ext(struct hisi_l3c_pmu *pmu)

drivers/perf/hisilicon/hisi_uncore_l3c_pmu.c

98

struct hisi_l3c_pmu_ext *l3c_pmu_ext = pmu->l3c_pmu.dev_info->private;

drivers/perf/hisilicon/hisi_uncore_mn_pmu.c

298

static void hisi_mn_pmu_unregister(void *pmu)

drivers/perf/hisilicon/hisi_uncore_mn_pmu.c

300

perf_pmu_unregister(pmu);

drivers/perf/hisilicon/hisi_uncore_mn_pmu.c

334

ret = perf_pmu_register(&mn_pmu->pmu, name, -1);

drivers/perf/hisilicon/hisi_uncore_mn_pmu.c

338

return devm_add_action_or_reset(&pdev->dev, hisi_mn_pmu_unregister, &mn_pmu->pmu);

drivers/perf/hisilicon/hisi_uncore_noc_pmu.c

180

struct hisi_pmu *noc_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_noc_pmu.c

208

struct hisi_pmu *noc_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_noc_pmu.c

331

static void hisi_noc_pmu_unregister_pmu(void *pmu)

drivers/perf/hisilicon/hisi_uncore_noc_pmu.c

333

perf_pmu_unregister(pmu);

drivers/perf/hisilicon/hisi_uncore_noc_pmu.c

374

ret = perf_pmu_register(&noc_pmu->pmu, name, -1);

drivers/perf/hisilicon/hisi_uncore_noc_pmu.c

379

&noc_pmu->pmu);

drivers/perf/hisilicon/hisi_uncore_noc_pmu.c

80

struct hisi_pmu *noc_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_pa_pmu.c

104

struct hisi_pmu *pa_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_pa_pmu.c

113

struct hisi_pmu *pa_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_pa_pmu.c

126

struct hisi_pmu *pa_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_pa_pmu.c

479

ret = perf_pmu_register(&pa_pmu->pmu, name, -1);

drivers/perf/hisilicon/hisi_uncore_pa_pmu.c

495

perf_pmu_unregister(&pa_pmu->pmu);

drivers/perf/hisilicon/hisi_uncore_pa_pmu.c

63

struct hisi_pmu *pa_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_pa_pmu.c

77

struct hisi_pmu *pa_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_pa_pmu.c

91

struct hisi_pmu *pa_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_pmu.c

100

struct hisi_pmu *hisi_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_pmu.c

109

if (leader->pmu != event->pmu)

drivers/perf/hisilicon/hisi_uncore_pmu.c

120

if (sibling->pmu != event->pmu)

drivers/perf/hisilicon/hisi_uncore_pmu.c

132

struct hisi_pmu *hisi_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_pmu.c

212

if (event->attr.type != event->pmu->type)

drivers/perf/hisilicon/hisi_uncore_pmu.c

237

hisi_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_pmu.c

267

struct hisi_pmu *hisi_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_pmu.c

285

struct hisi_pmu *hisi_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_pmu.c

297

struct hisi_pmu *hisi_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_pmu.c

317

struct hisi_pmu *hisi_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_pmu.c

338

struct hisi_pmu *hisi_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_pmu.c

378

struct hisi_pmu *hisi_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_pmu.c

401

struct hisi_pmu *hisi_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_pmu.c

418

void hisi_uncore_pmu_enable(struct pmu *pmu)

drivers/perf/hisilicon/hisi_uncore_pmu.c

420

struct hisi_pmu *hisi_pmu = to_hisi_pmu(pmu);

drivers/perf/hisilicon/hisi_uncore_pmu.c

431

void hisi_uncore_pmu_disable(struct pmu *pmu)

drivers/perf/hisilicon/hisi_uncore_pmu.c

433

struct hisi_pmu *hisi_pmu = to_hisi_pmu(pmu);

drivers/perf/hisilicon/hisi_uncore_pmu.c

564

perf_pmu_migrate_context(&hisi_pmu->pmu, cpu, target);

drivers/perf/hisilicon/hisi_uncore_pmu.c

606

struct pmu *pmu = &hisi_pmu->pmu;

drivers/perf/hisilicon/hisi_uncore_pmu.c

608

pmu->module = module;

drivers/perf/hisilicon/hisi_uncore_pmu.c

609

pmu->parent = hisi_pmu->dev;

drivers/perf/hisilicon/hisi_uncore_pmu.c

610

pmu->task_ctx_nr = perf_invalid_context;

drivers/perf/hisilicon/hisi_uncore_pmu.c

611

pmu->event_init = hisi_uncore_pmu_event_init;

drivers/perf/hisilicon/hisi_uncore_pmu.c

612

pmu->pmu_enable = hisi_uncore_pmu_enable;

drivers/perf/hisilicon/hisi_uncore_pmu.c

613

pmu->pmu_disable = hisi_uncore_pmu_disable;

drivers/perf/hisilicon/hisi_uncore_pmu.c

614

pmu->add = hisi_uncore_pmu_add;

drivers/perf/hisilicon/hisi_uncore_pmu.c

615

pmu->del = hisi_uncore_pmu_del;

drivers/perf/hisilicon/hisi_uncore_pmu.c

616

pmu->start = hisi_uncore_pmu_start;

drivers/perf/hisilicon/hisi_uncore_pmu.c

617

pmu->stop = hisi_uncore_pmu_stop;

drivers/perf/hisilicon/hisi_uncore_pmu.c

618

pmu->read = hisi_uncore_pmu_read;

drivers/perf/hisilicon/hisi_uncore_pmu.c

619

pmu->attr_groups = hisi_pmu->pmu_events.attr_groups;

drivers/perf/hisilicon/hisi_uncore_pmu.c

620

pmu->capabilities = PERF_PMU_CAP_NO_EXCLUDE;

drivers/perf/hisilicon/hisi_uncore_pmu.h

119

struct pmu pmu;

drivers/perf/hisilicon/hisi_uncore_pmu.h

156

void hisi_uncore_pmu_enable(struct pmu *pmu);

drivers/perf/hisilicon/hisi_uncore_pmu.h

157

void hisi_uncore_pmu_disable(struct pmu *pmu);

drivers/perf/hisilicon/hisi_uncore_pmu.h

28

#define to_hisi_pmu(p) (container_of(p, struct hisi_pmu, pmu))

drivers/perf/hisilicon/hisi_uncore_sllc_pmu.c

109

struct hisi_pmu *sllc_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_sllc_pmu.c

124

struct hisi_pmu *sllc_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_sllc_pmu.c

143

struct hisi_pmu *sllc_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_sllc_pmu.c

161

struct hisi_pmu *sllc_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_sllc_pmu.c

181

struct hisi_pmu *sllc_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_sllc_pmu.c

515

ret = perf_pmu_register(&sllc_pmu->pmu, name, -1);

drivers/perf/hisilicon/hisi_uncore_sllc_pmu.c

532

perf_pmu_unregister(&sllc_pmu->pmu);

drivers/perf/hisilicon/hisi_uncore_sllc_pmu.c

94

struct hisi_pmu *sllc_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_uc_pmu.c

118

struct hisi_pmu *uc_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_uc_pmu.c

145

struct hisi_pmu *uc_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_uc_pmu.c

170

struct hisi_pmu *uc_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_uc_pmu.c

191

struct hisi_pmu *uc_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_uc_pmu.c

495

static void hisi_uc_pmu_unregister_pmu(void *pmu)

drivers/perf/hisilicon/hisi_uncore_uc_pmu.c

497

perf_pmu_unregister(pmu);

drivers/perf/hisilicon/hisi_uncore_uc_pmu.c

534

ret = perf_pmu_register(&uc_pmu->pmu, name, -1);

drivers/perf/hisilicon/hisi_uncore_uc_pmu.c

540

&uc_pmu->pmu);

drivers/perf/hisilicon/hisi_uncore_uc_pmu.c

55

struct hisi_pmu *uc_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_uc_pmu.c

77

struct hisi_pmu *uc_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hisi_uncore_uc_pmu.c

98

struct hisi_pmu *uc_pmu = to_hisi_pmu(event->pmu);

drivers/perf/hisilicon/hns3_pmu.c

1063

if (leader->pmu != event->pmu)

drivers/perf/hisilicon/hns3_pmu.c

1074

if (sibling->pmu != event->pmu)

drivers/perf/hisilicon/hns3_pmu.c

1130

struct hns3_pmu *hns3_pmu = to_hns3_pmu(event->pmu);

drivers/perf/hisilicon/hns3_pmu.c

1212

struct hns3_pmu *hns3_pmu = to_hns3_pmu(event->pmu);

drivers/perf/hisilicon/hns3_pmu.c

1219

struct hns3_pmu *hns3_pmu = to_hns3_pmu(event->pmu);

drivers/perf/hisilicon/hns3_pmu.c

1236

struct hns3_pmu *hns3_pmu = to_hns3_pmu(event->pmu);

drivers/perf/hisilicon/hns3_pmu.c

1241

if (event->attr.type != event->pmu->type)

drivers/perf/hisilicon/hns3_pmu.c

1295

struct hns3_pmu *hns3_pmu = to_hns3_pmu(event->pmu);

drivers/perf/hisilicon/hns3_pmu.c

1314

struct hns3_pmu *hns3_pmu = to_hns3_pmu(event->pmu);

drivers/perf/hisilicon/hns3_pmu.c

1333

struct hns3_pmu *hns3_pmu = to_hns3_pmu(event->pmu);

drivers/perf/hisilicon/hns3_pmu.c

1366

struct hns3_pmu *hns3_pmu = to_hns3_pmu(event->pmu);

drivers/perf/hisilicon/hns3_pmu.c

1374

static void hns3_pmu_enable(struct pmu *pmu)

drivers/perf/hisilicon/hns3_pmu.c

1376

struct hns3_pmu *hns3_pmu = to_hns3_pmu(pmu);

drivers/perf/hisilicon/hns3_pmu.c

1384

static void hns3_pmu_disable(struct pmu *pmu)

drivers/perf/hisilicon/hns3_pmu.c

1386

struct hns3_pmu *hns3_pmu = to_hns3_pmu(pmu);

drivers/perf/hisilicon/hns3_pmu.c

1421

hns3_pmu->pmu = (struct pmu) {

drivers/perf/hisilicon/hns3_pmu.c

1496

perf_pmu_migrate_context(&hns3_pmu->pmu, cpu, target);

drivers/perf/hisilicon/hns3_pmu.c

1529

hns3_pmu->pmu.name, hns3_pmu);

drivers/perf/hisilicon/hns3_pmu.c

1559

ret = perf_pmu_register(&hns3_pmu->pmu, hns3_pmu->pmu.name, -1);

drivers/perf/hisilicon/hns3_pmu.c

1573

perf_pmu_unregister(&hns3_pmu->pmu);

drivers/perf/hisilicon/hns3_pmu.c

305

struct pmu pmu;

drivers/perf/hisilicon/hns3_pmu.c

316

#define to_hns3_pmu(p) (container_of((p), struct hns3_pmu, pmu))

drivers/perf/marvell_cn10k_ddr_pmu.c

1026

ddr_pmu->pmu = (struct pmu) {

drivers/perf/marvell_cn10k_ddr_pmu.c

1045

ddr_pmu->pmu = (struct pmu) {

drivers/perf/marvell_cn10k_ddr_pmu.c

1074

ret = perf_pmu_register(&ddr_pmu->pmu, name, -1);

drivers/perf/marvell_cn10k_ddr_pmu.c

1095

perf_pmu_unregister(&ddr_pmu->pmu);

drivers/perf/marvell_cn10k_ddr_pmu.c

148

struct pmu pmu;

drivers/perf/marvell_cn10k_ddr_pmu.c

161

void (*enable_read_freerun_counter)(struct cn10k_ddr_pmu *pmu,

drivers/perf/marvell_cn10k_ddr_pmu.c

163

void (*enable_write_freerun_counter)(struct cn10k_ddr_pmu *pmu,

drivers/perf/marvell_cn10k_ddr_pmu.c

165

void (*clear_read_freerun_counter)(struct cn10k_ddr_pmu *pmu);

drivers/perf/marvell_cn10k_ddr_pmu.c

166

void (*clear_write_freerun_counter)(struct cn10k_ddr_pmu *pmu);

drivers/perf/marvell_cn10k_ddr_pmu.c

167

void (*pmu_overflow_handler)(struct cn10k_ddr_pmu *pmu, int evt_idx);

drivers/perf/marvell_cn10k_ddr_pmu.c

170

#define to_cn10k_ddr_pmu(p) container_of(p, struct cn10k_ddr_pmu, pmu)

drivers/perf/marvell_cn10k_ddr_pmu.c

365

struct cn10k_ddr_pmu *pmu = dev_get_drvdata(dev);

drivers/perf/marvell_cn10k_ddr_pmu.c

367

return cpumap_print_to_pagebuf(true, buf, cpumask_of(pmu->cpu));

drivers/perf/marvell_cn10k_ddr_pmu.c

438

static int cn10k_ddr_perf_alloc_counter(struct cn10k_ddr_pmu *pmu,

drivers/perf/marvell_cn10k_ddr_pmu.c

446

pmu->events[DDRC_PERF_READ_COUNTER_IDX] = event;

drivers/perf/marvell_cn10k_ddr_pmu.c

452

pmu->events[DDRC_PERF_WRITE_COUNTER_IDX] = event;

drivers/perf/marvell_cn10k_ddr_pmu.c

458

if (pmu->events[i] == NULL) {

drivers/perf/marvell_cn10k_ddr_pmu.c

459

pmu->events[i] = event;

drivers/perf/marvell_cn10k_ddr_pmu.c

467

static void cn10k_ddr_perf_free_counter(struct cn10k_ddr_pmu *pmu, int counter)

drivers/perf/marvell_cn10k_ddr_pmu.c

469

pmu->events[counter] = NULL;

drivers/perf/marvell_cn10k_ddr_pmu.c

474

struct cn10k_ddr_pmu *pmu = to_cn10k_ddr_pmu(event->pmu);

drivers/perf/marvell_cn10k_ddr_pmu.c

477

if (event->attr.type != event->pmu->type)

drivers/perf/marvell_cn10k_ddr_pmu.c

481

dev_info(pmu->dev, "Sampling not supported!\n");

drivers/perf/marvell_cn10k_ddr_pmu.c

486

dev_warn(pmu->dev, "Can't provide per-task data!\n");

drivers/perf/marvell_cn10k_ddr_pmu.c

491

if (event->group_leader->pmu != event->pmu &&

drivers/perf/marvell_cn10k_ddr_pmu.c

498

event->cpu = pmu->cpu;

drivers/perf/marvell_cn10k_ddr_pmu.c

523

static void cn10k_ddr_perf_counter_enable(struct cn10k_ddr_pmu *pmu,

drivers/perf/marvell_cn10k_ddr_pmu.c

526

const struct ddr_pmu_platform_data *p_data = pmu->p_data;

drivers/perf/marvell_cn10k_ddr_pmu.c

527

u64 ctrl_reg = pmu->p_data->cnt_op_mode_ctrl;

drivers/perf/marvell_cn10k_ddr_pmu.c

528

const struct ddr_pmu_ops *ops = pmu->ops;

drivers/perf/marvell_cn10k_ddr_pmu.c

529

bool is_ody = pmu->p_data->is_ody;

drivers/perf/marvell_cn10k_ddr_pmu.c

540

val = readq_relaxed(pmu->base + reg);

drivers/perf/marvell_cn10k_ddr_pmu.c

547

writeq_relaxed(val, pmu->base + reg);

drivers/perf/marvell_cn10k_ddr_pmu.c

557

pmu->base + reg);

drivers/perf/marvell_cn10k_ddr_pmu.c

559

cn10k_ddr_perf_counter_start(pmu, counter);

drivers/perf/marvell_cn10k_ddr_pmu.c

561

cn10k_ddr_perf_counter_stop(pmu, counter);

drivers/perf/marvell_cn10k_ddr_pmu.c

566

ops->enable_read_freerun_counter(pmu, enable);

drivers/perf/marvell_cn10k_ddr_pmu.c

568

ops->enable_write_freerun_counter(pmu, enable);

drivers/perf/marvell_cn10k_ddr_pmu.c

572

static u64 cn10k_ddr_perf_read_counter(struct cn10k_ddr_pmu *pmu, int counter)

drivers/perf/marvell_cn10k_ddr_pmu.c

574

const struct ddr_pmu_platform_data *p_data = pmu->p_data;

drivers/perf/marvell_cn10k_ddr_pmu.c

578

return readq_relaxed(pmu->base +

drivers/perf/marvell_cn10k_ddr_pmu.c

582

return readq_relaxed(pmu->base +

drivers/perf/marvell_cn10k_ddr_pmu.c

585

val = readq_relaxed(pmu->base +

drivers/perf/marvell_cn10k_ddr_pmu.c

592

struct cn10k_ddr_pmu *pmu = to_cn10k_ddr_pmu(event->pmu);

drivers/perf/marvell_cn10k_ddr_pmu.c

593

const struct ddr_pmu_platform_data *p_data = pmu->p_data;

drivers/perf/marvell_cn10k_ddr_pmu.c

599

new_count = cn10k_ddr_perf_read_counter(pmu, hwc->idx);

drivers/perf/marvell_cn10k_ddr_pmu.c

609

struct cn10k_ddr_pmu *pmu = to_cn10k_ddr_pmu(event->pmu);

drivers/perf/marvell_cn10k_ddr_pmu.c

615

cn10k_ddr_perf_counter_enable(pmu, counter, true);

drivers/perf/marvell_cn10k_ddr_pmu.c

622

struct cn10k_ddr_pmu *pmu = to_cn10k_ddr_pmu(event->pmu);

drivers/perf/marvell_cn10k_ddr_pmu.c

623

const struct ddr_pmu_platform_data *p_data = pmu->p_data;

drivers/perf/marvell_cn10k_ddr_pmu.c

624

const struct ddr_pmu_ops *ops = pmu->ops;

drivers/perf/marvell_cn10k_ddr_pmu.c

631

counter = cn10k_ddr_perf_alloc_counter(pmu, event);

drivers/perf/marvell_cn10k_ddr_pmu.c

635

pmu->active_events++;

drivers/perf/marvell_cn10k_ddr_pmu.c

638

if (pmu->active_events == 1)

drivers/perf/marvell_cn10k_ddr_pmu.c

639

hrtimer_start(&pmu->hrtimer, cn10k_ddr_pmu_timer_period(),

drivers/perf/marvell_cn10k_ddr_pmu.c

645

ret = ddr_perf_get_event_bitmap(config, &val, pmu);

drivers/perf/marvell_cn10k_ddr_pmu.c

649

writeq_relaxed(val, pmu->base + reg_offset);

drivers/perf/marvell_cn10k_ddr_pmu.c

653

ops->clear_read_freerun_counter(pmu);

drivers/perf/marvell_cn10k_ddr_pmu.c

655

ops->clear_write_freerun_counter(pmu);

drivers/perf/marvell_cn10k_ddr_pmu.c

668

struct cn10k_ddr_pmu *pmu = to_cn10k_ddr_pmu(event->pmu);

drivers/perf/marvell_cn10k_ddr_pmu.c

672

cn10k_ddr_perf_counter_enable(pmu, counter, false);

drivers/perf/marvell_cn10k_ddr_pmu.c

682

struct cn10k_ddr_pmu *pmu = to_cn10k_ddr_pmu(event->pmu);

drivers/perf/marvell_cn10k_ddr_pmu.c

688

cn10k_ddr_perf_free_counter(pmu, counter);

drivers/perf/marvell_cn10k_ddr_pmu.c

689

pmu->active_events--;

drivers/perf/marvell_cn10k_ddr_pmu.c

693

if (pmu->active_events == 0)

drivers/perf/marvell_cn10k_ddr_pmu.c

694

hrtimer_cancel(&pmu->hrtimer);

drivers/perf/marvell_cn10k_ddr_pmu.c

697

static void cn10k_ddr_perf_pmu_enable(struct pmu *pmu)

drivers/perf/marvell_cn10k_ddr_pmu.c

699

struct cn10k_ddr_pmu *ddr_pmu = to_cn10k_ddr_pmu(pmu);

drivers/perf/marvell_cn10k_ddr_pmu.c

706

static void cn10k_ddr_perf_pmu_disable(struct pmu *pmu)

drivers/perf/marvell_cn10k_ddr_pmu.c

708

struct cn10k_ddr_pmu *ddr_pmu = to_cn10k_ddr_pmu(pmu);

drivers/perf/marvell_cn10k_ddr_pmu.c

715

static void cn10k_ddr_perf_event_update_all(struct cn10k_ddr_pmu *pmu)

drivers/perf/marvell_cn10k_ddr_pmu.c

721

if (pmu->events[i] == NULL)

drivers/perf/marvell_cn10k_ddr_pmu.c

724

cn10k_ddr_perf_event_update(pmu->events[i]);

drivers/perf/marvell_cn10k_ddr_pmu.c

729

if (pmu->events[i] == NULL)

drivers/perf/marvell_cn10k_ddr_pmu.c

732

hwc = &pmu->events[i]->hw;

drivers/perf/marvell_cn10k_ddr_pmu.c

737

static void ddr_pmu_enable_read_freerun(struct cn10k_ddr_pmu *pmu, bool enable)

drivers/perf/marvell_cn10k_ddr_pmu.c

739

const struct ddr_pmu_platform_data *p_data = pmu->p_data;

drivers/perf/marvell_cn10k_ddr_pmu.c

742

val = readq_relaxed(pmu->base + p_data->cnt_freerun_en);

drivers/perf/marvell_cn10k_ddr_pmu.c

748

writeq_relaxed(val, pmu->base + p_data->cnt_freerun_en);

drivers/perf/marvell_cn10k_ddr_pmu.c

751

static void ddr_pmu_enable_write_freerun(struct cn10k_ddr_pmu *pmu, bool enable)

drivers/perf/marvell_cn10k_ddr_pmu.c

753

const struct ddr_pmu_platform_data *p_data = pmu->p_data;

drivers/perf/marvell_cn10k_ddr_pmu.c

756

val = readq_relaxed(pmu->base + p_data->cnt_freerun_en);

drivers/perf/marvell_cn10k_ddr_pmu.c

762

writeq_relaxed(val, pmu->base + p_data->cnt_freerun_en);

drivers/perf/marvell_cn10k_ddr_pmu.c

765

static void ddr_pmu_read_clear_freerun(struct cn10k_ddr_pmu *pmu)

drivers/perf/marvell_cn10k_ddr_pmu.c

767

const struct ddr_pmu_platform_data *p_data = pmu->p_data;

drivers/perf/marvell_cn10k_ddr_pmu.c

771

writeq_relaxed(val, pmu->base + p_data->cnt_freerun_ctrl);

drivers/perf/marvell_cn10k_ddr_pmu.c

774

static void ddr_pmu_write_clear_freerun(struct cn10k_ddr_pmu *pmu)

drivers/perf/marvell_cn10k_ddr_pmu.c

776

const struct ddr_pmu_platform_data *p_data = pmu->p_data;

drivers/perf/marvell_cn10k_ddr_pmu.c

780

writeq_relaxed(val, pmu->base + p_data->cnt_freerun_ctrl);

drivers/perf/marvell_cn10k_ddr_pmu.c

783

static void ddr_pmu_overflow_hander(struct cn10k_ddr_pmu *pmu, int evt_idx)

drivers/perf/marvell_cn10k_ddr_pmu.c

785

cn10k_ddr_perf_event_update_all(pmu);

drivers/perf/marvell_cn10k_ddr_pmu.c

786

cn10k_ddr_perf_pmu_disable(&pmu->pmu);

drivers/perf/marvell_cn10k_ddr_pmu.c

787

cn10k_ddr_perf_pmu_enable(&pmu->pmu);

drivers/perf/marvell_cn10k_ddr_pmu.c

790

static void ddr_pmu_ody_enable_read_freerun(struct cn10k_ddr_pmu *pmu,

drivers/perf/marvell_cn10k_ddr_pmu.c

793

const struct ddr_pmu_platform_data *p_data = pmu->p_data;

drivers/perf/marvell_cn10k_ddr_pmu.c

796

val = readq_relaxed(pmu->base + p_data->cnt_freerun_ctrl);

drivers/perf/marvell_cn10k_ddr_pmu.c

802

writeq_relaxed(val, pmu->base + p_data->cnt_freerun_ctrl);

drivers/perf/marvell_cn10k_ddr_pmu.c

805

static void ddr_pmu_ody_enable_write_freerun(struct cn10k_ddr_pmu *pmu,

drivers/perf/marvell_cn10k_ddr_pmu.c

808

const struct ddr_pmu_platform_data *p_data = pmu->p_data;

drivers/perf/marvell_cn10k_ddr_pmu.c

811

val = readq_relaxed(pmu->base + p_data->cnt_freerun_ctrl);

drivers/perf/marvell_cn10k_ddr_pmu.c

817

writeq_relaxed(val, pmu->base + p_data->cnt_freerun_ctrl);

drivers/perf/marvell_cn10k_ddr_pmu.c

820

static void ddr_pmu_ody_read_clear_freerun(struct cn10k_ddr_pmu *pmu)

drivers/perf/marvell_cn10k_ddr_pmu.c

822

const struct ddr_pmu_platform_data *p_data = pmu->p_data;

drivers/perf/marvell_cn10k_ddr_pmu.c

826

writeq_relaxed(val, pmu->base + p_data->cnt_freerun_clr);

drivers/perf/marvell_cn10k_ddr_pmu.c

829

static void ddr_pmu_ody_write_clear_freerun(struct cn10k_ddr_pmu *pmu)

drivers/perf/marvell_cn10k_ddr_pmu.c

831

const struct ddr_pmu_platform_data *p_data = pmu->p_data;

drivers/perf/marvell_cn10k_ddr_pmu.c

835

writeq_relaxed(val, pmu->base + p_data->cnt_freerun_clr);

drivers/perf/marvell_cn10k_ddr_pmu.c

838

static void ddr_pmu_ody_overflow_hander(struct cn10k_ddr_pmu *pmu, int evt_idx)

drivers/perf/marvell_cn10k_ddr_pmu.c

845

cn10k_ddr_perf_event_update(pmu->events[evt_idx]);

drivers/perf/marvell_cn10k_ddr_pmu.c

846

cn10k_ddr_perf_counter_stop(pmu, evt_idx);

drivers/perf/marvell_cn10k_ddr_pmu.c

847

cn10k_ddr_perf_counter_start(pmu, evt_idx);

drivers/perf/marvell_cn10k_ddr_pmu.c

850

static irqreturn_t cn10k_ddr_pmu_overflow_handler(struct cn10k_ddr_pmu *pmu)

drivers/perf/marvell_cn10k_ddr_pmu.c

852

const struct ddr_pmu_platform_data *p_data = pmu->p_data;

drivers/perf/marvell_cn10k_ddr_pmu.c

853

const struct ddr_pmu_ops *ops = pmu->ops;

drivers/perf/marvell_cn10k_ddr_pmu.c

860

event = pmu->events[DDRC_PERF_READ_COUNTER_IDX];

drivers/perf/marvell_cn10k_ddr_pmu.c

864

new_count = cn10k_ddr_perf_read_counter(pmu, hwc->idx);

drivers/perf/marvell_cn10k_ddr_pmu.c

873

event = pmu->events[DDRC_PERF_WRITE_COUNTER_IDX];

drivers/perf/marvell_cn10k_ddr_pmu.c

877

new_count = cn10k_ddr_perf_read_counter(pmu, hwc->idx);

drivers/perf/marvell_cn10k_ddr_pmu.c

887

if (pmu->events[i] == NULL)

drivers/perf/marvell_cn10k_ddr_pmu.c

890

value = cn10k_ddr_perf_read_counter(pmu, i);

drivers/perf/marvell_cn10k_ddr_pmu.c

893

ops->pmu_overflow_handler(pmu, i);

drivers/perf/marvell_cn10k_ddr_pmu.c

902

struct cn10k_ddr_pmu *pmu = container_of(hrtimer, struct cn10k_ddr_pmu,

drivers/perf/marvell_cn10k_ddr_pmu.c

907

cn10k_ddr_pmu_overflow_handler(pmu);

drivers/perf/marvell_cn10k_ddr_pmu.c

916

struct cn10k_ddr_pmu *pmu = hlist_entry_safe(node, struct cn10k_ddr_pmu,

drivers/perf/marvell_cn10k_ddr_pmu.c

920

if (cpu != pmu->cpu)

drivers/perf/marvell_cn10k_ddr_pmu.c

927

perf_pmu_migrate_context(&pmu->pmu, cpu, target);

drivers/perf/marvell_cn10k_ddr_pmu.c

928

pmu->cpu = target;

drivers/perf/marvell_cn10k_tad_pmu.c

116

struct tad_pmu *tad_pmu = to_tad_pmu(event->pmu);

drivers/perf/marvell_cn10k_tad_pmu.c

127

struct tad_pmu *tad_pmu = to_tad_pmu(event->pmu);

drivers/perf/marvell_cn10k_tad_pmu.c

150

struct tad_pmu *tad_pmu = to_tad_pmu(event->pmu);

drivers/perf/marvell_cn10k_tad_pmu.c

152

if (event->attr.type != event->pmu->type)

drivers/perf/marvell_cn10k_tad_pmu.c

24

#define to_tad_pmu(p) (container_of(p, struct tad_pmu, pmu))

drivers/perf/marvell_cn10k_tad_pmu.c

31

struct pmu pmu;

drivers/perf/marvell_cn10k_tad_pmu.c

362

tad_pmu->pmu = (struct pmu) {

drivers/perf/marvell_cn10k_tad_pmu.c

378

tad_pmu->pmu.attr_groups = tad_pmu_attr_groups;

drivers/perf/marvell_cn10k_tad_pmu.c

380

tad_pmu->pmu.attr_groups = ody_tad_pmu_attr_groups;

drivers/perf/marvell_cn10k_tad_pmu.c

393

ret = perf_pmu_register(&tad_pmu->pmu, name, -1);

drivers/perf/marvell_cn10k_tad_pmu.c

403

struct tad_pmu *pmu = platform_get_drvdata(pdev);

drivers/perf/marvell_cn10k_tad_pmu.c

406

&pmu->node);

drivers/perf/marvell_cn10k_tad_pmu.c

407

perf_pmu_unregister(&pmu->pmu);

drivers/perf/marvell_cn10k_tad_pmu.c

451

struct tad_pmu *pmu = hlist_entry_safe(node, struct tad_pmu, node);

drivers/perf/marvell_cn10k_tad_pmu.c

454

if (cpu != pmu->cpu)

drivers/perf/marvell_cn10k_tad_pmu.c

461

perf_pmu_migrate_context(&pmu->pmu, cpu, target);

drivers/perf/marvell_cn10k_tad_pmu.c

462

pmu->cpu = target;

drivers/perf/marvell_cn10k_tad_pmu.c

53

struct tad_pmu *tad_pmu = to_tad_pmu(event->pmu);

drivers/perf/marvell_cn10k_tad_pmu.c

71

struct tad_pmu *tad_pmu = to_tad_pmu(event->pmu);

drivers/perf/marvell_cn10k_tad_pmu.c

90

struct tad_pmu *tad_pmu = to_tad_pmu(event->pmu);

drivers/perf/marvell_pem_pmu.c

165

struct pem_pmu *pmu = dev_get_drvdata(dev);

drivers/perf/marvell_pem_pmu.c

167

return cpumap_print_to_pagebuf(true, buf, cpumask_of(pmu->cpu));

drivers/perf/marvell_pem_pmu.c

191

struct pem_pmu *pmu = to_pem_pmu(event->pmu);

drivers/perf/marvell_pem_pmu.c

195

if (event->attr.type != event->pmu->type)

drivers/perf/marvell_pem_pmu.c

210

if (event->group_leader->pmu != event->pmu &&

drivers/perf/marvell_pem_pmu.c

215

if (sibling->pmu != event->pmu &&

drivers/perf/marvell_pem_pmu.c

223

event->cpu = pmu->cpu;

drivers/perf/marvell_pem_pmu.c

228

static u64 pem_perf_read_counter(struct pem_pmu *pmu,

drivers/perf/marvell_pem_pmu.c

231

return readq_relaxed(pmu->base + eventid_to_offset(eventid));

drivers/perf/marvell_pem_pmu.c

236

struct pem_pmu *pmu = to_pem_pmu(event->pmu);

drivers/perf/marvell_pem_pmu.c

242

new_count = pem_perf_read_counter(pmu, event, hwc->idx);

drivers/perf/marvell_pem_pmu.c

250

struct pem_pmu *pmu = to_pem_pmu(event->pmu);

drivers/perf/marvell_pem_pmu.c

259

pem_perf_read_counter(pmu, event, eventid));

drivers/perf/marvell_pem_pmu.c

299

struct pem_pmu *pmu = hlist_entry_safe(node, struct pem_pmu, node);

drivers/perf/marvell_pem_pmu.c

302

if (cpu != pmu->cpu)

drivers/perf/marvell_pem_pmu.c

309

perf_pmu_migrate_context(&pmu->pmu, cpu, target);

drivers/perf/marvell_pem_pmu.c

310

pmu->cpu = target;

drivers/perf/marvell_pem_pmu.c

335

pem_pmu->pmu = (struct pmu) {

drivers/perf/marvell_pem_pmu.c

359

ret = perf_pmu_register(&pem_pmu->pmu, name, -1);

drivers/perf/marvell_pem_pmu.c

377

perf_pmu_unregister(&pem_pmu->pmu);

drivers/perf/marvell_pem_pmu.c

81

struct pmu pmu;

drivers/perf/marvell_pem_pmu.c

88

#define to_pem_pmu(p) container_of(p, struct pem_pmu, pmu)

drivers/perf/qcom_l2_pmu.c

112

struct pmu pmu;

drivers/perf/qcom_l2_pmu.c

150

#define to_l2cache_pmu(p) (container_of(p, struct l2cache_pmu, pmu))

drivers/perf/qcom_l2_pmu.c

420

static void l2_cache_pmu_enable(struct pmu *pmu)

drivers/perf/qcom_l2_pmu.c

433

static void l2_cache_pmu_disable(struct pmu *pmu)

drivers/perf/qcom_l2_pmu.c

445

if (event->attr.type != event->pmu->type)

drivers/perf/qcom_l2_pmu.c

448

l2cache_pmu = to_l2cache_pmu(event->pmu);

drivers/perf/qcom_l2_pmu.c

472

if (event->group_leader->pmu != event->pmu &&

drivers/perf/qcom_l2_pmu.c

480

if (sibling->pmu != event->pmu &&

drivers/perf/qcom_l2_pmu.c

551

cluster = get_cluster_pmu(to_l2cache_pmu(event->pmu), event->cpu);

drivers/perf/qcom_l2_pmu.c

595

cluster = get_cluster_pmu(to_l2cache_pmu(event->pmu), event->cpu);

drivers/perf/qcom_l2_pmu.c

621

cluster = get_cluster_pmu(to_l2cache_pmu(event->pmu), event->cpu);

drivers/perf/qcom_l2_pmu.c

829

perf_pmu_migrate_context(&l2cache_pmu->pmu, cpu, target);

drivers/perf/qcom_l2_pmu.c

902

l2cache_pmu->pmu = (struct pmu) {

drivers/perf/qcom_l2_pmu.c

950

err = perf_pmu_register(&l2cache_pmu->pmu, l2cache_pmu->pmu.name, -1);

drivers/perf/qcom_l2_pmu.c

972

perf_pmu_unregister(&l2cache_pmu->pmu);

drivers/perf/qcom_l3_pmu.c

155

struct pmu pmu;

drivers/perf/qcom_l3_pmu.c

163

#define to_l3cache_pmu(p) (container_of(p, struct l3cache_pmu, pmu))

drivers/perf/qcom_l3_pmu.c

195

struct l3cache_pmu *l3pmu = to_l3cache_pmu(event->pmu);

drivers/perf/qcom_l3_pmu.c

227

struct l3cache_pmu *l3pmu = to_l3cache_pmu(event->pmu);

drivers/perf/qcom_l3_pmu.c

241

struct l3cache_pmu *l3pmu = to_l3cache_pmu(event->pmu);

drivers/perf/qcom_l3_pmu.c

276

struct l3cache_pmu *l3pmu = to_l3cache_pmu(event->pmu);

drivers/perf/qcom_l3_pmu.c

302

struct l3cache_pmu *l3pmu = to_l3cache_pmu(event->pmu);

drivers/perf/qcom_l3_pmu.c

318

struct l3cache_pmu *l3pmu = to_l3cache_pmu(event->pmu);

drivers/perf/qcom_l3_pmu.c

427

static void qcom_l3_cache__pmu_enable(struct pmu *pmu)

drivers/perf/qcom_l3_pmu.c

429

struct l3cache_pmu *l3pmu = to_l3cache_pmu(pmu);

drivers/perf/qcom_l3_pmu.c

437

static void qcom_l3_cache__pmu_disable(struct pmu *pmu)

drivers/perf/qcom_l3_pmu.c

439

struct l3cache_pmu *l3pmu = to_l3cache_pmu(pmu);

drivers/perf/qcom_l3_pmu.c

457

if (leader->pmu != event->pmu && !is_software_event(leader))

drivers/perf/qcom_l3_pmu.c

466

if (sibling->pmu != event->pmu)

drivers/perf/qcom_l3_pmu.c

480

struct l3cache_pmu *l3pmu = to_l3cache_pmu(event->pmu);

drivers/perf/qcom_l3_pmu.c

486

if (event->attr.type != event->pmu->type)

drivers/perf/qcom_l3_pmu.c

549

struct l3cache_pmu *l3pmu = to_l3cache_pmu(event->pmu);

drivers/perf/qcom_l3_pmu.c

577

struct l3cache_pmu *l3pmu = to_l3cache_pmu(event->pmu);

drivers/perf/qcom_l3_pmu.c

715

perf_pmu_migrate_context(&l3pmu->pmu, cpu, target);

drivers/perf/qcom_l3_pmu.c

741

l3pmu->pmu = (struct pmu) {

drivers/perf/qcom_l3_pmu.c

783

ret = perf_pmu_register(&l3pmu->pmu, name, -1);

drivers/perf/qcom_l3_pmu.c

789

dev_info(&pdev->dev, "Registered %s, type: %d\n", name, l3pmu->pmu.type);

drivers/perf/riscv_pmu.c

148

struct riscv_pmu *rvpmu = to_riscv_pmu(event->pmu);

drivers/perf/riscv_pmu.c

162

struct riscv_pmu *rvpmu = to_riscv_pmu(event->pmu);

drivers/perf/riscv_pmu.c

190

struct riscv_pmu *rvpmu = to_riscv_pmu(event->pmu);

drivers/perf/riscv_pmu.c

243

struct riscv_pmu *rvpmu = to_riscv_pmu(event->pmu);

drivers/perf/riscv_pmu.c

259

struct riscv_pmu *rvpmu = to_riscv_pmu(event->pmu);

drivers/perf/riscv_pmu.c

283

struct riscv_pmu *rvpmu = to_riscv_pmu(event->pmu);

drivers/perf/riscv_pmu.c

307

struct riscv_pmu *rvpmu = to_riscv_pmu(event->pmu);

drivers/perf/riscv_pmu.c

355

struct riscv_pmu *rvpmu = to_riscv_pmu(event->pmu);

drivers/perf/riscv_pmu.c

368

struct riscv_pmu *rvpmu = to_riscv_pmu(event->pmu);

drivers/perf/riscv_pmu.c

378

struct riscv_pmu *rvpmu = to_riscv_pmu(event->pmu);

drivers/perf/riscv_pmu.c

388

struct riscv_pmu *pmu;

drivers/perf/riscv_pmu.c

392

pmu = kzalloc_obj(*pmu);

drivers/perf/riscv_pmu.c

393

if (!pmu)

drivers/perf/riscv_pmu.c

396

pmu->hw_events = alloc_percpu_gfp(struct cpu_hw_events, GFP_KERNEL);

drivers/perf/riscv_pmu.c

397

if (!pmu->hw_events) {

drivers/perf/riscv_pmu.c

403

cpuc = per_cpu_ptr(pmu->hw_events, cpuid);

drivers/perf/riscv_pmu.c

409

pmu->pmu = (struct pmu) {

drivers/perf/riscv_pmu.c

421

return pmu;

drivers/perf/riscv_pmu.c

424

kfree(pmu);

drivers/perf/riscv_pmu.c

48

userpg->pmc_width = to_riscv_pmu(event->pmu)->ctr_get_width(event->hw.idx) + 1;

drivers/perf/riscv_pmu_legacy.c

110

static void pmu_legacy_init(struct riscv_pmu *pmu)

drivers/perf/riscv_pmu_legacy.c

114

pmu->cmask = BIT(RISCV_PMU_LEGACY_CYCLE) |

drivers/perf/riscv_pmu_legacy.c

116

pmu->ctr_start = pmu_legacy_ctr_start;

drivers/perf/riscv_pmu_legacy.c

117

pmu->ctr_stop = NULL;

drivers/perf/riscv_pmu_legacy.c

118

pmu->event_map = pmu_legacy_event_map;

drivers/perf/riscv_pmu_legacy.c

119

pmu->ctr_get_idx = pmu_legacy_ctr_get_idx;

drivers/perf/riscv_pmu_legacy.c

120

pmu->ctr_get_width = pmu_legacy_ctr_get_width;

drivers/perf/riscv_pmu_legacy.c

121

pmu->ctr_clear_idx = NULL;

drivers/perf/riscv_pmu_legacy.c

122

pmu->ctr_read = pmu_legacy_read_ctr;

drivers/perf/riscv_pmu_legacy.c

123

pmu->event_mapped = pmu_legacy_event_mapped;

drivers/perf/riscv_pmu_legacy.c

124

pmu->event_unmapped = pmu_legacy_event_unmapped;

drivers/perf/riscv_pmu_legacy.c

125

pmu->csr_index = pmu_legacy_csr_index;

drivers/perf/riscv_pmu_legacy.c

126

pmu->pmu.capabilities |= PERF_PMU_CAP_NO_INTERRUPT;

drivers/perf/riscv_pmu_legacy.c

127

pmu->pmu.capabilities |= PERF_PMU_CAP_NO_EXCLUDE;

drivers/perf/riscv_pmu_legacy.c

129

perf_pmu_register(&pmu->pmu, "cpu", PERF_TYPE_RAW);

drivers/perf/riscv_pmu_legacy.c

134

struct riscv_pmu *pmu = NULL;

drivers/perf/riscv_pmu_legacy.c

136

pmu = riscv_pmu_alloc();

drivers/perf/riscv_pmu_legacy.c

137

if (!pmu)

drivers/perf/riscv_pmu_legacy.c

139

pmu->pmu.parent = &pdev->dev;

drivers/perf/riscv_pmu_legacy.c

140

pmu_legacy_init(pmu);

drivers/perf/riscv_pmu_sbi.c

1030

static void pmu_sbi_start_overflow_mask(struct riscv_pmu *pmu,

drivers/perf/riscv_pmu_sbi.c

1033

struct cpu_hw_events *cpu_hw_evt = this_cpu_ptr(pmu->hw_events);

drivers/perf/riscv_pmu_sbi.c

1048

struct riscv_pmu *pmu;

drivers/perf/riscv_pmu_sbi.c

1072

pmu = to_riscv_pmu(event->pmu);

drivers/perf/riscv_pmu_sbi.c

1073

pmu_sbi_stop_hw_ctrs(pmu);

drivers/perf/riscv_pmu_sbi.c

1142

pmu_sbi_start_overflow_mask(pmu, overflowed_ctrs);

drivers/perf/riscv_pmu_sbi.c

1150

struct riscv_pmu *pmu = hlist_entry_safe(node, struct riscv_pmu, node);

drivers/perf/riscv_pmu_sbi.c

1151

struct cpu_hw_events *cpu_hw_evt = this_cpu_ptr(pmu->hw_events);

drivers/perf/riscv_pmu_sbi.c

1163

pmu_sbi_stop_all(pmu);

drivers/perf/riscv_pmu_sbi.c

1172

return pmu_sbi_snapshot_setup(pmu, cpu);

drivers/perf/riscv_pmu_sbi.c

1192

static int pmu_sbi_setup_irqs(struct riscv_pmu *pmu, struct platform_device *pdev)

drivers/perf/riscv_pmu_sbi.c

1195

struct cpu_hw_events __percpu *hw_events = pmu->hw_events;

drivers/perf/riscv_pmu_sbi.c

1281

static int riscv_pm_pmu_register(struct riscv_pmu *pmu)

drivers/perf/riscv_pmu_sbi.c

1283

pmu->riscv_pm_nb.notifier_call = riscv_pm_pmu_notify;

drivers/perf/riscv_pmu_sbi.c

1284

return cpu_pm_register_notifier(&pmu->riscv_pm_nb);

drivers/perf/riscv_pmu_sbi.c

1287

static void riscv_pm_pmu_unregister(struct riscv_pmu *pmu)

drivers/perf/riscv_pmu_sbi.c

1289

cpu_pm_unregister_notifier(&pmu->riscv_pm_nb);

drivers/perf/riscv_pmu_sbi.c

1292

static inline int riscv_pm_pmu_register(struct riscv_pmu *pmu) { return 0; }

drivers/perf/riscv_pmu_sbi.c

1293

static inline void riscv_pm_pmu_unregister(struct riscv_pmu *pmu) { }

drivers/perf/riscv_pmu_sbi.c

1296

static void riscv_pmu_destroy(struct riscv_pmu *pmu)

drivers/perf/riscv_pmu_sbi.c

1301

pmu_sbi_snapshot_free(pmu);

drivers/perf/riscv_pmu_sbi.c

1304

riscv_pm_pmu_unregister(pmu);

drivers/perf/riscv_pmu_sbi.c

1305

cpuhp_state_remove_instance(CPUHP_AP_PERF_RISCV_STARTING, &pmu->node);

drivers/perf/riscv_pmu_sbi.c

1424

struct riscv_pmu *pmu = NULL;

drivers/perf/riscv_pmu_sbi.c

1429

pmu = riscv_pmu_alloc();

drivers/perf/riscv_pmu_sbi.c

1430

if (!pmu)

drivers/perf/riscv_pmu_sbi.c

1449

ret = pmu_sbi_setup_irqs(pmu, pdev);

drivers/perf/riscv_pmu_sbi.c

1452

pmu->pmu.capabilities |= PERF_PMU_CAP_NO_INTERRUPT;

drivers/perf/riscv_pmu_sbi.c

1453

pmu->pmu.capabilities |= PERF_PMU_CAP_NO_EXCLUDE;

drivers/perf/riscv_pmu_sbi.c

1456

pmu->pmu.attr_groups = riscv_pmu_attr_groups;

drivers/perf/riscv_pmu_sbi.c

1457

pmu->pmu.parent = &pdev->dev;

drivers/perf/riscv_pmu_sbi.c

1458

pmu->cmask = cmask;

drivers/perf/riscv_pmu_sbi.c

1459

pmu->ctr_start = pmu_sbi_ctr_start;

drivers/perf/riscv_pmu_sbi.c

1460

pmu->ctr_stop = pmu_sbi_ctr_stop;

drivers/perf/riscv_pmu_sbi.c

1461

pmu->event_map = pmu_sbi_event_map;

drivers/perf/riscv_pmu_sbi.c

1462

pmu->ctr_get_idx = pmu_sbi_ctr_get_idx;

drivers/perf/riscv_pmu_sbi.c

1463

pmu->ctr_get_width = pmu_sbi_ctr_get_width;

drivers/perf/riscv_pmu_sbi.c

1464

pmu->ctr_clear_idx = pmu_sbi_ctr_clear_idx;

drivers/perf/riscv_pmu_sbi.c

1465

pmu->ctr_read = pmu_sbi_ctr_read;

drivers/perf/riscv_pmu_sbi.c

1466

pmu->event_init = pmu_sbi_event_init;

drivers/perf/riscv_pmu_sbi.c

1467

pmu->event_mapped = pmu_sbi_event_mapped;

drivers/perf/riscv_pmu_sbi.c

1468

pmu->event_unmapped = pmu_sbi_event_unmapped;

drivers/perf/riscv_pmu_sbi.c

1469

pmu->csr_index = pmu_sbi_csr_index;

drivers/perf/riscv_pmu_sbi.c

1471

ret = riscv_pm_pmu_register(pmu);

drivers/perf/riscv_pmu_sbi.c

1475

ret = perf_pmu_register(&pmu->pmu, "cpu", PERF_TYPE_RAW);

drivers/perf/riscv_pmu_sbi.c

1483

ret = pmu_sbi_snapshot_alloc(pmu);

drivers/perf/riscv_pmu_sbi.c

1488

ret = pmu_sbi_snapshot_setup(pmu, cpu);

drivers/perf/riscv_pmu_sbi.c

1493

pmu_sbi_snapshot_free(pmu);

drivers/perf/riscv_pmu_sbi.c

1508

ret = cpuhp_state_add_instance(CPUHP_AP_PERF_RISCV_STARTING, &pmu->node);

drivers/perf/riscv_pmu_sbi.c

1518

riscv_pmu_destroy(pmu);

drivers/perf/riscv_pmu_sbi.c

1521

kfree(pmu);

drivers/perf/riscv_pmu_sbi.c

541

struct riscv_pmu *rvpmu = to_riscv_pmu(event->pmu);

drivers/perf/riscv_pmu_sbi.c

600

struct riscv_pmu *rvpmu = to_riscv_pmu(event->pmu);

drivers/perf/riscv_pmu_sbi.c

656

static void pmu_sbi_snapshot_free(struct riscv_pmu *pmu)

drivers/perf/riscv_pmu_sbi.c

661

struct cpu_hw_events *cpu_hw_evt = per_cpu_ptr(pmu->hw_events, cpu);

drivers/perf/riscv_pmu_sbi.c

672

static int pmu_sbi_snapshot_alloc(struct riscv_pmu *pmu)

drivers/perf/riscv_pmu_sbi.c

678

struct cpu_hw_events *cpu_hw_evt = per_cpu_ptr(pmu->hw_events, cpu);

drivers/perf/riscv_pmu_sbi.c

682

pmu_sbi_snapshot_free(pmu);

drivers/perf/riscv_pmu_sbi.c

706

static int pmu_sbi_snapshot_setup(struct riscv_pmu *pmu, int cpu)

drivers/perf/riscv_pmu_sbi.c

711

cpu_hw_evt = per_cpu_ptr(pmu->hw_events, cpu);

drivers/perf/riscv_pmu_sbi.c

745

struct riscv_pmu *pmu = to_riscv_pmu(event->pmu);

drivers/perf/riscv_pmu_sbi.c

746

struct cpu_hw_events *cpu_hw_evt = this_cpu_ptr(pmu->hw_events);

drivers/perf/riscv_pmu_sbi.c

826

struct riscv_pmu *pmu = to_riscv_pmu(event->pmu);

drivers/perf/riscv_pmu_sbi.c

827

struct cpu_hw_events *cpu_hw_evt = this_cpu_ptr(pmu->hw_events);

drivers/perf/riscv_pmu_sbi.c

900

static inline void pmu_sbi_stop_all(struct riscv_pmu *pmu)

drivers/perf/riscv_pmu_sbi.c

907

0, pmu->cmask, SBI_PMU_STOP_FLAG_RESET, 0, 0, 0);

drivers/perf/riscv_pmu_sbi.c

910

static inline void pmu_sbi_stop_hw_ctrs(struct riscv_pmu *pmu)

drivers/perf/riscv_pmu_sbi.c

912

struct cpu_hw_events *cpu_hw_evt = this_cpu_ptr(pmu->hw_events);

drivers/perf/starfive_starlink_pmu.c

157

struct starlink_pmu *starlink_pmu = to_starlink_pmu(event->pmu);

drivers/perf/starfive_starlink_pmu.c

234

struct starlink_pmu *starlink_pmu = to_starlink_pmu(event->pmu);

drivers/perf/starfive_starlink_pmu.c

260

struct starlink_pmu *starlink_pmu = to_starlink_pmu(event->pmu);

drivers/perf/starfive_starlink_pmu.c

279

struct starlink_pmu *starlink_pmu = to_starlink_pmu(event->pmu);

drivers/perf/starfive_starlink_pmu.c

292

struct starlink_pmu *starlink_pmu = to_starlink_pmu(event->pmu);

drivers/perf/starfive_starlink_pmu.c

332

struct starlink_pmu *starlink_pmu = to_starlink_pmu(event->pmu);

drivers/perf/starfive_starlink_pmu.c

354

if (event->group_leader->pmu != event->pmu &&

drivers/perf/starfive_starlink_pmu.c

359

if (sibling->pmu != event->pmu && !is_software_event(sibling))

drivers/perf/starfive_starlink_pmu.c

370

struct starlink_pmu *starlink_pmu = to_starlink_pmu(event->pmu);

drivers/perf/starfive_starlink_pmu.c

51

#define to_starlink_pmu(p) (container_of(p, struct starlink_pmu, pmu))

drivers/perf/starfive_starlink_pmu.c

554

starlink_pmu->pmu = (struct pmu) {

drivers/perf/starfive_starlink_pmu.c

565

ret = perf_pmu_register(&starlink_pmu->pmu, STARLINK_PMU_PDEV_NAME, -1);

drivers/perf/starfive_starlink_pmu.c

617

perf_pmu_migrate_context(&starlink_pmu->pmu, cpu, target);

drivers/perf/starfive_starlink_pmu.c

70

struct pmu pmu;

drivers/perf/thunderx2_pmu.c

119

static inline struct tx2_uncore_pmu *pmu_to_tx2_pmu(struct pmu *pmu)

drivers/perf/thunderx2_pmu.c

121

return container_of(pmu, struct tx2_uncore_pmu, pmu);

drivers/perf/thunderx2_pmu.c

328

tx2_pmu = pmu_to_tx2_pmu(event->pmu);

drivers/perf/thunderx2_pmu.c

344

tx2_pmu = pmu_to_tx2_pmu(event->pmu);

drivers/perf/thunderx2_pmu.c

373

tx2_pmu = pmu_to_tx2_pmu(event->pmu);

drivers/perf/thunderx2_pmu.c

395

tx2_pmu = pmu_to_tx2_pmu(event->pmu);

drivers/perf/thunderx2_pmu.c

420

tx2_pmu = pmu_to_tx2_pmu(event->pmu);

drivers/perf/thunderx2_pmu.c

436

tx2_pmu = pmu_to_tx2_pmu(event->pmu);

drivers/perf/thunderx2_pmu.c

472

tx2_pmu = pmu_to_tx2_pmu(event->pmu);

drivers/perf/thunderx2_pmu.c

522

static bool tx2_uncore_validate_event(struct pmu *pmu,

drivers/perf/thunderx2_pmu.c

528

if (event->pmu != pmu)

drivers/perf/thunderx2_pmu.c

548

if (!tx2_uncore_validate_event(event->pmu, leader, &counters))

drivers/perf/thunderx2_pmu.c

552

if (!tx2_uncore_validate_event(event->pmu, sibling, &counters))

drivers/perf/thunderx2_pmu.c

556

if (!tx2_uncore_validate_event(event->pmu, event, &counters))

drivers/perf/thunderx2_pmu.c

573

if (event->attr.type != event->pmu->type)

drivers/perf/thunderx2_pmu.c

587

tx2_pmu = pmu_to_tx2_pmu(event->pmu);

drivers/perf/thunderx2_pmu.c

611

tx2_pmu = pmu_to_tx2_pmu(event->pmu);

drivers/perf/thunderx2_pmu.c

637

tx2_pmu = pmu_to_tx2_pmu(event->pmu);

drivers/perf/thunderx2_pmu.c

652

tx2_pmu = pmu_to_tx2_pmu(event->pmu);

drivers/perf/thunderx2_pmu.c

672

struct tx2_uncore_pmu *tx2_pmu = pmu_to_tx2_pmu(event->pmu);

drivers/perf/thunderx2_pmu.c

725

tx2_pmu->pmu = (struct pmu) {

drivers/perf/thunderx2_pmu.c

739

tx2_pmu->pmu.name = devm_kasprintf(dev, GFP_KERNEL,

drivers/perf/thunderx2_pmu.c

742

return perf_pmu_register(&tx2_pmu->pmu, tx2_pmu->pmu.name, -1);

drivers/perf/thunderx2_pmu.c

779

tx2_pmu->pmu.name);

drivers/perf/thunderx2_pmu.c

93

struct pmu pmu;

drivers/perf/thunderx2_pmu.c

948

perf_pmu_migrate_context(&tx2_pmu->pmu, cpu, new_cpu);

drivers/perf/thunderx2_pmu.c

998

perf_pmu_unregister(&tx2_pmu->pmu);

drivers/perf/xgene_pmu.c

1003

struct xgene_pmu_dev *pmu_dev = to_pmu_dev(event->pmu);

drivers/perf/xgene_pmu.c

102

void (*mask_int)(struct xgene_pmu *pmu);

drivers/perf/xgene_pmu.c

103

void (*unmask_int)(struct xgene_pmu *pmu);

drivers/perf/xgene_pmu.c

104

u64 (*read_counter)(struct xgene_pmu_dev *pmu, int idx);

drivers/perf/xgene_pmu.c

1046

struct xgene_pmu_dev *pmu_dev = to_pmu_dev(event->pmu);

drivers/perf/xgene_pmu.c

105

void (*write_counter)(struct xgene_pmu_dev *pmu, int idx, u64 val);

drivers/perf/xgene_pmu.c

1067

struct xgene_pmu_dev *pmu_dev = to_pmu_dev(event->pmu);

drivers/perf/xgene_pmu.c

1095

pmu_dev->pmu = (struct pmu) {

drivers/perf/xgene_pmu.c

1114

return perf_pmu_register(&pmu_dev->pmu, name, -1);

drivers/perf/xgene_pmu.c

1121

struct xgene_pmu_dev *pmu;

drivers/perf/xgene_pmu.c

1123

pmu = devm_kzalloc(dev, sizeof(*pmu), GFP_KERNEL);

drivers/perf/xgene_pmu.c

1124

if (!pmu)

drivers/perf/xgene_pmu.c

1126

pmu->parent = xgene_pmu;

drivers/perf/xgene_pmu.c

1127

pmu->inf = &ctx->inf;

drivers/perf/xgene_pmu.c

1128

ctx->pmu_dev = pmu;

drivers/perf/xgene_pmu.c

1130

switch (pmu->inf->type) {

drivers/perf/xgene_pmu.c

1132

if (!(xgene_pmu->l3c_active_mask & pmu->inf->enable_mask))

drivers/perf/xgene_pmu.c

1135

pmu->attr_groups = l3c_pmu_v3_attr_groups;

drivers/perf/xgene_pmu.c

1137

pmu->attr_groups = l3c_pmu_attr_groups;

drivers/perf/xgene_pmu.c

1141

pmu->attr_groups = iob_fast_pmu_v3_attr_groups;

drivers/perf/xgene_pmu.c

1143

pmu->attr_groups = iob_pmu_attr_groups;

drivers/perf/xgene_pmu.c

1147

pmu->attr_groups = iob_slow_pmu_v3_attr_groups;

drivers/perf/xgene_pmu.c

1150

if (!(xgene_pmu->mcb_active_mask & pmu->inf->enable_mask))

drivers/perf/xgene_pmu.c

1153

pmu->attr_groups = mcb_pmu_v3_attr_groups;

drivers/perf/xgene_pmu.c

1155

pmu->attr_groups = mcb_pmu_attr_groups;

drivers/perf/xgene_pmu.c

1158

if (!(xgene_pmu->mc_active_mask & pmu->inf->enable_mask))

drivers/perf/xgene_pmu.c

1161

pmu->attr_groups = mc_pmu_v3_attr_groups;

drivers/perf/xgene_pmu.c

1163

pmu->attr_groups = mc_pmu_attr_groups;

drivers/perf/xgene_pmu.c

1169

if (xgene_init_perf(pmu, ctx->name)) {

drivers/perf/xgene_pmu.c

1808

perf_pmu_migrate_context(&ctx->pmu_dev->pmu, cpu, target);

drivers/perf/xgene_pmu.c

1811

perf_pmu_migrate_context(&ctx->pmu_dev->pmu, cpu, target);

drivers/perf/xgene_pmu.c

1814

perf_pmu_migrate_context(&ctx->pmu_dev->pmu, cpu, target);

drivers/perf/xgene_pmu.c

1817

perf_pmu_migrate_context(&ctx->pmu_dev->pmu, cpu, target);

drivers/perf/xgene_pmu.c

1928

perf_pmu_unregister(&ctx->pmu_dev->pmu);

drivers/perf/xgene_pmu.c

78

#define to_pmu_dev(p) container_of(p, struct xgene_pmu_dev, pmu)

drivers/perf/xgene_pmu.c

855

static void xgene_perf_pmu_enable(struct pmu *pmu)

drivers/perf/xgene_pmu.c

857

struct xgene_pmu_dev *pmu_dev = to_pmu_dev(pmu);

drivers/perf/xgene_pmu.c

868

static void xgene_perf_pmu_disable(struct pmu *pmu)

drivers/perf/xgene_pmu.c

870

struct xgene_pmu_dev *pmu_dev = to_pmu_dev(pmu);

drivers/perf/xgene_pmu.c

878

struct xgene_pmu_dev *pmu_dev = to_pmu_dev(event->pmu);

drivers/perf/xgene_pmu.c

883

if (event->attr.type != event->pmu->type)

drivers/perf/xgene_pmu.c

920

if (event->group_leader->pmu != event->pmu &&

drivers/perf/xgene_pmu.c

925

if (sibling->pmu != event->pmu &&

drivers/perf/xgene_pmu.c

93

struct pmu pmu;

drivers/perf/xgene_pmu.c

935

struct xgene_pmu_dev *pmu_dev = to_pmu_dev(event->pmu);

drivers/perf/xgene_pmu.c

951

struct xgene_pmu_dev *pmu_dev = to_pmu_dev(event->pmu);

drivers/perf/xgene_pmu.c

960

struct xgene_pmu_dev *pmu_dev = to_pmu_dev(event->pmu);

drivers/perf/xgene_pmu.c

978

struct xgene_pmu_dev *pmu_dev = to_pmu_dev(event->pmu);

drivers/phy/allwinner/phy-sun4i-usb.c

120

void __iomem *pmu;

drivers/phy/allwinner/phy-sun4i-usb.c

234

if (!phy->pmu)

drivers/phy/allwinner/phy-sun4i-usb.c

246

reg_value = readl(phy->pmu);

drivers/phy/allwinner/phy-sun4i-usb.c

253

writel(reg_value, phy->pmu);

drivers/phy/allwinner/phy-sun4i-usb.c

315

if (phy2->pmu && data->cfg->hci_phy_ctl_clear) {

drivers/phy/allwinner/phy-sun4i-usb.c

316

val = readl(phy2->pmu + REG_HCI_PHY_CTL);

drivers/phy/allwinner/phy-sun4i-usb.c

318

writel(val, phy2->pmu + REG_HCI_PHY_CTL);

drivers/phy/allwinner/phy-sun4i-usb.c

324

if (phy->pmu && data->cfg->hci_phy_ctl_clear) {

drivers/phy/allwinner/phy-sun4i-usb.c

325

val = readl(phy->pmu + REG_HCI_PHY_CTL);

drivers/phy/allwinner/phy-sun4i-usb.c

327

writel(val, phy->pmu + REG_HCI_PHY_CTL);

drivers/phy/allwinner/phy-sun4i-usb.c

842

phy->pmu = devm_platform_ioremap_resource_byname(pdev, name);

drivers/phy/allwinner/phy-sun4i-usb.c

843

if (IS_ERR(phy->pmu))

drivers/phy/allwinner/phy-sun4i-usb.c

844

return PTR_ERR(phy->pmu);

drivers/phy/allwinner/phy-sun9i-usb.c

158

phy->pmu = devm_platform_ioremap_resource(pdev, 0);

drivers/phy/allwinner/phy-sun9i-usb.c

159

if (IS_ERR(phy->pmu))

drivers/phy/allwinner/phy-sun9i-usb.c

160

return PTR_ERR(phy->pmu);

drivers/phy/allwinner/phy-sun9i-usb.c

37

void __iomem *pmu;

drivers/phy/allwinner/phy-sun9i-usb.c

56

reg_value = readl(phy->pmu);

drivers/phy/allwinner/phy-sun9i-usb.c

63

writel(reg_value, phy->pmu);

drivers/phy/phy-spacemit-k1-pcie.c

173

return !!k1_phy->pmu;

drivers/phy/phy-spacemit-k1-pcie.c

316

struct regmap *pmu = k1_phy->pmu;

drivers/phy/phy-spacemit-k1-pcie.c

319

if (!regmap_test_bits(pmu, PMUA_USB_PHY_CTRL0, COMBO_PHY_SEL) == usb)

drivers/phy/phy-spacemit-k1-pcie.c

320

regmap_assign_bits(pmu, PMUA_USB_PHY_CTRL0, COMBO_PHY_SEL, usb);

drivers/phy/phy-spacemit-k1-pcie.c

470

regmap_assign_bits(k1_phy->pmu, PCIE_CLK_RES_CTRL,

drivers/phy/phy-spacemit-k1-pcie.c

582

k1_phy->pmu = regmap;

drivers/phy/phy-spacemit-k1-pcie.c

68

struct regmap *pmu; /* MMIO regmap (no errors) */

drivers/pinctrl/mvebu/pinctrl-dove.c

192

unsigned long pmu = readl(data->base + PMU_MPP_GENERAL_CTRL);

drivers/pinctrl/mvebu/pinctrl-dove.c

194

*config = ((pmu & AU0_AC97_SEL) != 0);

drivers/pinctrl/mvebu/pinctrl-dove.c

202

unsigned long pmu = readl(data->base + PMU_MPP_GENERAL_CTRL);

drivers/pinctrl/mvebu/pinctrl-dove.c

204

pmu &= ~AU0_AC97_SEL;

drivers/pinctrl/mvebu/pinctrl-dove.c

206

pmu |= AU0_AC97_SEL;

drivers/pinctrl/mvebu/pinctrl-dove.c

207

writel(pmu, data->base + PMU_MPP_GENERAL_CTRL);

drivers/pinctrl/mvebu/pinctrl-dove.c

68

unsigned long pmu = readl(data->base + PMU_MPP_GENERAL_CTRL);

drivers/pinctrl/mvebu/pinctrl-dove.c

71

if ((pmu & BIT(pid)) == 0)

drivers/pinctrl/mvebu/pinctrl-dove.c

86

unsigned long pmu = readl(data->base + PMU_MPP_GENERAL_CTRL);

drivers/pinctrl/mvebu/pinctrl-dove.c

90

writel(pmu & ~BIT(pid), data->base + PMU_MPP_GENERAL_CTRL);

drivers/pinctrl/mvebu/pinctrl-dove.c

94

writel(pmu | BIT(pid), data->base + PMU_MPP_GENERAL_CTRL);

drivers/pinctrl/qcom/pinctrl-ipq4019.c

505

QCA_PIN_FUNCTION(pmu),

drivers/pinctrl/qcom/pinctrl-ipq4019.c

623

PINGROUP(54, qpic, blsp_spi0, i2s_td, NA, pmu, NA, NA, NA, tm, NA, NA,

drivers/pinctrl/qcom/pinctrl-ipq4019.c

625

PINGROUP(55, qpic, blsp_spi0, i2s_td, NA, pmu, NA, NA, NA, tm, NA, NA,

drivers/pmdomain/rockchip/pm-domains.c

1000

dev_err(pmu->dev, "%s failed to add subdomain %s: %d\n",

drivers/pmdomain/rockchip/pm-domains.c

1004

dev_dbg(pmu->dev, "%s add subdomain: %s\n",

drivers/pmdomain/rockchip/pm-domains.c

1008

rockchip_pm_add_subdomain(pmu, np);

drivers/pmdomain/rockchip/pm-domains.c

1019

struct rockchip_pmu *pmu;

drivers/pmdomain/rockchip/pm-domains.c

1030

pmu = devm_kzalloc(dev,

drivers/pmdomain/rockchip/pm-domains.c

1031

struct_size(pmu, domains, pmu_info->num_domains),

drivers/pmdomain/rockchip/pm-domains.c

1033

if (!pmu)

drivers/pmdomain/rockchip/pm-domains.c

1036

pmu->dev = &pdev->dev;

drivers/pmdomain/rockchip/pm-domains.c

1037

mutex_init(&pmu->mutex);

drivers/pmdomain/rockchip/pm-domains.c

1039

pmu->info = pmu_info;

drivers/pmdomain/rockchip/pm-domains.c

1041

pmu->genpd_data.domains = pmu->domains;

drivers/pmdomain/rockchip/pm-domains.c

1042

pmu->genpd_data.num_domains = pmu_info->num_domains;

drivers/pmdomain/rockchip/pm-domains.c

1050

pmu->regmap = syscon_node_to_regmap(parent->of_node);

drivers/pmdomain/rockchip/pm-domains.c

1051

if (IS_ERR(pmu->regmap)) {

drivers/pmdomain/rockchip/pm-domains.c

1053

return PTR_ERR(pmu->regmap);

drivers/pmdomain/rockchip/pm-domains.c

1061

rockchip_configure_pd_cnt(pmu, pmu_info->core_pwrcnt_offset,

drivers/pmdomain/rockchip/pm-domains.c

1064

rockchip_configure_pd_cnt(pmu, pmu_info->gpu_pwrcnt_offset,

drivers/pmdomain/rockchip/pm-domains.c

1076

error = rockchip_pm_add_one_domain(pmu, node);

drivers/pmdomain/rockchip/pm-domains.c

1083

error = rockchip_pm_add_subdomain(pmu, node);

drivers/pmdomain/rockchip/pm-domains.c

1096

error = of_genpd_add_provider_onecell(np, &pmu->genpd_data);

drivers/pmdomain/rockchip/pm-domains.c

1104

dmc_pmu = pmu;

drivers/pmdomain/rockchip/pm-domains.c

1109

rockchip_pm_domain_cleanup(pmu);

drivers/pmdomain/rockchip/pm-domains.c

268

struct rockchip_pmu *pmu;

drivers/pmdomain/rockchip/pm-domains.c

278

pmu = dmc_pmu;

drivers/pmdomain/rockchip/pm-domains.c

285

mutex_lock(&pmu->mutex);

drivers/pmdomain/rockchip/pm-domains.c

297

for (i = 0; i < pmu->genpd_data.num_domains; i++) {

drivers/pmdomain/rockchip/pm-domains.c

298

genpd = pmu->genpd_data.domains[i];

drivers/pmdomain/rockchip/pm-domains.c

303

dev_err(pmu->dev,

drivers/pmdomain/rockchip/pm-domains.c

315

genpd = pmu->genpd_data.domains[i];

drivers/pmdomain/rockchip/pm-domains.c

321

mutex_unlock(&pmu->mutex);

drivers/pmdomain/rockchip/pm-domains.c

331

struct rockchip_pmu *pmu;

drivers/pmdomain/rockchip/pm-domains.c

337

pmu = dmc_pmu;

drivers/pmdomain/rockchip/pm-domains.c

338

for (i = 0; i < pmu->genpd_data.num_domains; i++) {

drivers/pmdomain/rockchip/pm-domains.c

339

genpd = pmu->genpd_data.domains[i];

drivers/pmdomain/rockchip/pm-domains.c

346

mutex_unlock(&pmu->mutex);

drivers/pmdomain/rockchip/pm-domains.c

358

struct rockchip_pmu *pmu = pd->pmu;

drivers/pmdomain/rockchip/pm-domains.c

362

regmap_read(pmu->regmap, pmu->info->idle_offset, &val);

drivers/pmdomain/rockchip/pm-domains.c

366

static unsigned int rockchip_pmu_read_ack(struct rockchip_pmu *pmu)

drivers/pmdomain/rockchip/pm-domains.c

370

regmap_read(pmu->regmap, pmu->info->ack_offset, &val);

drivers/pmdomain/rockchip/pm-domains.c

377

struct rockchip_pmu *pmu = pd->pmu;

drivers/pmdomain/rockchip/pm-domains.c

384

if (!pmu->info->clk_ungate_offset)

drivers/pmdomain/rockchip/pm-domains.c

389

regmap_write(pmu->regmap, pmu->info->clk_ungate_offset, val);

drivers/pmdomain/rockchip/pm-domains.c

399

struct rockchip_pmu *pmu = pd->pmu;

drivers/pmdomain/rockchip/pm-domains.c

409

regmap_write(pmu->regmap, pmu->info->req_offset + pd_req_offset,

drivers/pmdomain/rockchip/pm-domains.c

413

regmap_update_bits(pmu->regmap, pmu->info->req_offset + pd_req_offset,

drivers/pmdomain/rockchip/pm-domains.c

420

ret = readx_poll_timeout_atomic(rockchip_pmu_read_ack, pmu, val,

drivers/pmdomain/rockchip/pm-domains.c

424

dev_err(pmu->dev,

drivers/pmdomain/rockchip/pm-domains.c

433

dev_err(pmu->dev,

drivers/pmdomain/rockchip/pm-domains.c

493

struct rockchip_pmu *pmu = pd->pmu;

drivers/pmdomain/rockchip/pm-domains.c

497

regmap_read(pmu->regmap, pmu->info->repair_status_offset, &val);

drivers/pmdomain/rockchip/pm-domains.c

506

regmap_read(pmu->regmap, pmu->info->status_offset, &val);

drivers/pmdomain/rockchip/pm-domains.c

514

struct rockchip_pmu *pmu = pd->pmu;

drivers/pmdomain/rockchip/pm-domains.c

517

regmap_read(pmu->regmap,

drivers/pmdomain/rockchip/pm-domains.c

518

pmu->info->mem_status_offset + pd->info->mem_offset, &val);

drivers/pmdomain/rockchip/pm-domains.c

526

struct rockchip_pmu *pmu = pd->pmu;

drivers/pmdomain/rockchip/pm-domains.c

529

regmap_read(pmu->regmap,

drivers/pmdomain/rockchip/pm-domains.c

530

pmu->info->chain_status_offset + pd->info->mem_offset, &val);

drivers/pmdomain/rockchip/pm-domains.c

538

struct rockchip_pmu *pmu = pd->pmu;

drivers/pmdomain/rockchip/pm-domains.c

546

dev_err(pmu->dev,

drivers/pmdomain/rockchip/pm-domains.c

554

regmap_write(pmu->regmap, pmu->info->mem_pwr_offset + pd->info->pwr_offset,

drivers/pmdomain/rockchip/pm-domains.c

561

dev_err(pmu->dev,

drivers/pmdomain/rockchip/pm-domains.c

567

regmap_write(pmu->regmap, pmu->info->mem_pwr_offset + pd->info->pwr_offset,

drivers/pmdomain/rockchip/pm-domains.c

574

dev_err(pmu->dev,

drivers/pmdomain/rockchip/pm-domains.c

586

struct rockchip_pmu *pmu = pd->pmu;

drivers/pmdomain/rockchip/pm-domains.c

600

regmap_write(pmu->regmap, pmu->info->pwr_offset + pd_pwr_offset,

drivers/pmdomain/rockchip/pm-domains.c

604

regmap_update_bits(pmu->regmap, pmu->info->pwr_offset + pd_pwr_offset,

drivers/pmdomain/rockchip/pm-domains.c

619

dev_err(pmu->dev, "failed to set domain '%s' %s, val=%d\n",

drivers/pmdomain/rockchip/pm-domains.c

627

pmu->info->pwr_offset + pd_pwr_offset,

drivers/pmdomain/rockchip/pm-domains.c

635

struct rockchip_pmu *pmu = pd->pmu;

drivers/pmdomain/rockchip/pm-domains.c

638

guard(mutex)(&pmu->mutex);

drivers/pmdomain/rockchip/pm-domains.c

645

dev_err(pmu->dev, "failed to enable clocks\n");

drivers/pmdomain/rockchip/pm-domains.c

687

struct rockchip_pmu *pmu = pd->pmu;

drivers/pmdomain/rockchip/pm-domains.c

693

pd->supply = devm_of_regulator_get(pmu->dev, pd->node, "domain");

drivers/pmdomain/rockchip/pm-domains.c

709

dev_err(pd->pmu->dev, "Failed to enable supply: %d\n", ret);

drivers/pmdomain/rockchip/pm-domains.c

771

static int rockchip_pm_add_one_domain(struct rockchip_pmu *pmu,

drivers/pmdomain/rockchip/pm-domains.c

783

dev_err(pmu->dev,

drivers/pmdomain/rockchip/pm-domains.c

789

if (id >= pmu->info->num_domains) {

drivers/pmdomain/rockchip/pm-domains.c

790

dev_err(pmu->dev, "%pOFn: invalid domain id %d\n",

drivers/pmdomain/rockchip/pm-domains.c

795

if (pmu->genpd_data.domains[id])

drivers/pmdomain/rockchip/pm-domains.c

798

pd_info = &pmu->info->domain_info[id];

drivers/pmdomain/rockchip/pm-domains.c

800

dev_err(pmu->dev, "%pOFn: undefined domain id %d\n",

drivers/pmdomain/rockchip/pm-domains.c

805

pd = devm_kzalloc(pmu->dev, sizeof(*pd), GFP_KERNEL);

drivers/pmdomain/rockchip/pm-domains.c

810

pd->pmu = pmu;

drivers/pmdomain/rockchip/pm-domains.c

815

pd->clks = devm_kcalloc(pmu->dev, pd->num_clks,

drivers/pmdomain/rockchip/pm-domains.c

820

dev_dbg(pmu->dev, "%pOFn: doesn't have clocks: %d\n",

drivers/pmdomain/rockchip/pm-domains.c

829

dev_err(pmu->dev,

drivers/pmdomain/rockchip/pm-domains.c

844

pd->qos_regmap = devm_kcalloc(pmu->dev, pd->num_qos,

drivers/pmdomain/rockchip/pm-domains.c

853

pd->qos_save_regs[j] = devm_kcalloc(pmu->dev,

drivers/pmdomain/rockchip/pm-domains.c

903

pmu->genpd_data.domains[id] = &pd->genpd;

drivers/pmdomain/rockchip/pm-domains.c

923

dev_err(pd->pmu->dev, "failed to remove domain '%s' : %d - state may be inconsistent\n",

drivers/pmdomain/rockchip/pm-domains.c

930

mutex_lock(&pd->pmu->mutex);

drivers/pmdomain/rockchip/pm-domains.c

932

mutex_unlock(&pd->pmu->mutex);

drivers/pmdomain/rockchip/pm-domains.c

937

static void rockchip_pm_domain_cleanup(struct rockchip_pmu *pmu)

drivers/pmdomain/rockchip/pm-domains.c

943

for (i = 0; i < pmu->genpd_data.num_domains; i++) {

drivers/pmdomain/rockchip/pm-domains.c

944

genpd = pmu->genpd_data.domains[i];

drivers/pmdomain/rockchip/pm-domains.c

954

static void rockchip_configure_pd_cnt(struct rockchip_pmu *pmu,

drivers/pmdomain/rockchip/pm-domains.c

959

regmap_write(pmu->regmap, domain_reg_offset, count);

drivers/pmdomain/rockchip/pm-domains.c

96

struct rockchip_pmu *pmu;

drivers/pmdomain/rockchip/pm-domains.c

961

regmap_write(pmu->regmap, domain_reg_offset + 4, count);

drivers/pmdomain/rockchip/pm-domains.c

964

static int rockchip_pm_add_subdomain(struct rockchip_pmu *pmu,

drivers/pmdomain/rockchip/pm-domains.c

975

dev_err(pmu->dev,

drivers/pmdomain/rockchip/pm-domains.c

980

parent_domain = pmu->genpd_data.domains[idx];

drivers/pmdomain/rockchip/pm-domains.c

982

error = rockchip_pm_add_one_domain(pmu, np);

drivers/pmdomain/rockchip/pm-domains.c

984

dev_err(pmu->dev, "failed to handle node %pOFn: %d\n",

drivers/pmdomain/rockchip/pm-domains.c

991

dev_err(pmu->dev,

drivers/pmdomain/rockchip/pm-domains.c

996

child_domain = pmu->genpd_data.domains[idx];

drivers/pmdomain/starfive/jh71xx-pmu.c

107

spin_lock_irqsave(&pmu->lock, flags);

drivers/pmdomain/starfive/jh71xx-pmu.c

129

writel(mask, pmu->base + mode);

drivers/pmdomain/starfive/jh71xx-pmu.c

139

writel(JH71XX_PMU_SW_ENCOURAGE_ON, pmu->base + JH71XX_PMU_SW_ENCOURAGE);

drivers/pmdomain/starfive/jh71xx-pmu.c

140

writel(encourage_lo, pmu->base + JH71XX_PMU_SW_ENCOURAGE);

drivers/pmdomain/starfive/jh71xx-pmu.c

141

writel(encourage_hi, pmu->base + JH71XX_PMU_SW_ENCOURAGE);

drivers/pmdomain/starfive/jh71xx-pmu.c

143

spin_unlock_irqrestore(&pmu->lock, flags);

drivers/pmdomain/starfive/jh71xx-pmu.c

147

ret = readl_poll_timeout_atomic(pmu->base + JH71XX_PMU_CURR_POWER_MODE,

drivers/pmdomain/starfive/jh71xx-pmu.c

151

ret = readl_poll_timeout_atomic(pmu->base + JH71XX_PMU_CURR_POWER_MODE,

drivers/pmdomain/starfive/jh71xx-pmu.c

157

dev_err(pmu->dev, "%s: failed to power %s\n",

drivers/pmdomain/starfive/jh71xx-pmu.c

167

struct jh71xx_pmu *pmu = pmd->pmu;

drivers/pmdomain/starfive/jh71xx-pmu.c

171

spin_lock_irqsave(&pmu->lock, flags);

drivers/pmdomain/starfive/jh71xx-pmu.c

172

val = readl(pmu->base + JH71XX_AON_PMU_SWITCH);

drivers/pmdomain/starfive/jh71xx-pmu.c

179

writel(val, pmu->base + JH71XX_AON_PMU_SWITCH);

drivers/pmdomain/starfive/jh71xx-pmu.c

180

spin_unlock_irqrestore(&pmu->lock, flags);

drivers/pmdomain/starfive/jh71xx-pmu.c

187

struct jh71xx_pmu *pmu = pmd->pmu;

drivers/pmdomain/starfive/jh71xx-pmu.c

188

const struct jh71xx_pmu_match_data *match_data = pmu->match_data;

drivers/pmdomain/starfive/jh71xx-pmu.c

194

dev_dbg(pmu->dev, "unable to get current state for %s\n",

drivers/pmdomain/starfive/jh71xx-pmu.c

200

dev_dbg(pmu->dev, "pm domain [%s] is already %sable status.\n",

drivers/pmdomain/starfive/jh71xx-pmu.c

226

static void jh71xx_pmu_int_enable(struct jh71xx_pmu *pmu, u32 mask, bool enable)

drivers/pmdomain/starfive/jh71xx-pmu.c

231

spin_lock_irqsave(&pmu->lock, flags);

drivers/pmdomain/starfive/jh71xx-pmu.c

232

val = readl(pmu->base + JH71XX_PMU_TIMER_INT_MASK);

drivers/pmdomain/starfive/jh71xx-pmu.c

239

writel(val, pmu->base + JH71XX_PMU_TIMER_INT_MASK);

drivers/pmdomain/starfive/jh71xx-pmu.c

240

spin_unlock_irqrestore(&pmu->lock, flags);

drivers/pmdomain/starfive/jh71xx-pmu.c

245

struct jh71xx_pmu *pmu = data;

drivers/pmdomain/starfive/jh71xx-pmu.c

248

val = readl(pmu->base + JH71XX_PMU_INT_STATUS);

drivers/pmdomain/starfive/jh71xx-pmu.c

251

dev_dbg(pmu->dev, "sequence done.\n");

drivers/pmdomain/starfive/jh71xx-pmu.c

253

dev_dbg(pmu->dev, "hardware encourage requestion.\n");

drivers/pmdomain/starfive/jh71xx-pmu.c

255

dev_err(pmu->dev, "software encourage fail.\n");

drivers/pmdomain/starfive/jh71xx-pmu.c

257

dev_err(pmu->dev, "hardware encourage fail.\n");

drivers/pmdomain/starfive/jh71xx-pmu.c

259

dev_err(pmu->dev, "p-channel fail event.\n");

drivers/pmdomain/starfive/jh71xx-pmu.c

262

writel(val, pmu->base + JH71XX_PMU_INT_STATUS);

drivers/pmdomain/starfive/jh71xx-pmu.c

263

writel(val, pmu->base + JH71XX_PMU_EVENT_STATUS);

drivers/pmdomain/starfive/jh71xx-pmu.c

268

static int jh7110_pmu_parse_irq(struct platform_device *pdev, struct jh71xx_pmu *pmu)

drivers/pmdomain/starfive/jh71xx-pmu.c

273

pmu->irq = platform_get_irq(pdev, 0);

drivers/pmdomain/starfive/jh71xx-pmu.c

274

if (pmu->irq < 0)

drivers/pmdomain/starfive/jh71xx-pmu.c

275

return pmu->irq;

drivers/pmdomain/starfive/jh71xx-pmu.c

277

ret = devm_request_irq(dev, pmu->irq, jh71xx_pmu_interrupt,

drivers/pmdomain/starfive/jh71xx-pmu.c

278

0, pdev->name, pmu);

drivers/pmdomain/starfive/jh71xx-pmu.c

282

jh71xx_pmu_int_enable(pmu, JH71XX_PMU_INT_ALL_MASK & ~JH71XX_PMU_INT_PCH_FAIL, true);

drivers/pmdomain/starfive/jh71xx-pmu.c

287

static int jh71xx_pmu_init_domain(struct jh71xx_pmu *pmu, int index)

drivers/pmdomain/starfive/jh71xx-pmu.c

294

pmd = devm_kzalloc(pmu->dev, sizeof(*pmd), GFP_KERNEL);

drivers/pmdomain/starfive/jh71xx-pmu.c

298

pmd->domain_info = &pmu->match_data->domain_info[index];

drivers/pmdomain/starfive/jh71xx-pmu.c

299

pmd->pmu = pmu;

drivers/pmdomain/starfive/jh71xx-pmu.c

307

dev_warn(pmu->dev, "unable to get current state for %s\n",

drivers/pmdomain/starfive/jh71xx-pmu.c

314

pmu->genpd_data.domains[index] = &pmd->genpd;

drivers/pmdomain/starfive/jh71xx-pmu.c

324

struct jh71xx_pmu *pmu;

drivers/pmdomain/starfive/jh71xx-pmu.c

328

pmu = devm_kzalloc(dev, sizeof(*pmu), GFP_KERNEL);

drivers/pmdomain/starfive/jh71xx-pmu.c

329

if (!pmu)

drivers/pmdomain/starfive/jh71xx-pmu.c

332

pmu->base = devm_platform_ioremap_resource(pdev, 0);

drivers/pmdomain/starfive/jh71xx-pmu.c

333

if (IS_ERR(pmu->base))

drivers/pmdomain/starfive/jh71xx-pmu.c

334

return PTR_ERR(pmu->base);

drivers/pmdomain/starfive/jh71xx-pmu.c

336

spin_lock_init(&pmu->lock);

drivers/pmdomain/starfive/jh71xx-pmu.c

343

ret = match_data->pmu_parse_irq(pdev, pmu);

drivers/pmdomain/starfive/jh71xx-pmu.c

350

pmu->genpd = devm_kcalloc(dev, match_data->num_domains,

drivers/pmdomain/starfive/jh71xx-pmu.c

353

if (!pmu->genpd)

drivers/pmdomain/starfive/jh71xx-pmu.c

356

pmu->dev = dev;

drivers/pmdomain/starfive/jh71xx-pmu.c

357

pmu->match_data = match_data;

drivers/pmdomain/starfive/jh71xx-pmu.c

358

pmu->genpd_data.domains = pmu->genpd;

drivers/pmdomain/starfive/jh71xx-pmu.c

359

pmu->genpd_data.num_domains = match_data->num_domains;

drivers/pmdomain/starfive/jh71xx-pmu.c

362

ret = jh71xx_pmu_init_domain(pmu, i);

drivers/pmdomain/starfive/jh71xx-pmu.c

369

ret = of_genpd_add_provider_onecell(np, &pmu->genpd_data);

drivers/pmdomain/starfive/jh71xx-pmu.c

64

struct jh71xx_pmu *pmu);

drivers/pmdomain/starfive/jh71xx-pmu.c

81

struct jh71xx_pmu *pmu;

drivers/pmdomain/starfive/jh71xx-pmu.c

87

struct jh71xx_pmu *pmu = pmd->pmu;

drivers/pmdomain/starfive/jh71xx-pmu.c

92

*is_on = readl(pmu->base + pmu->match_data->pmu_status) & mask;

drivers/pmdomain/starfive/jh71xx-pmu.c

99

struct jh71xx_pmu *pmu = pmd->pmu;

drivers/powercap/intel_rapl_common.c

1582

struct pmu pmu; /* Perf PMU structure */

drivers/powercap/intel_rapl_common.c

1797

if (event->attr.type != event->pmu->type)

drivers/powercap/intel_rapl_common.c

2000

perf_pmu_unregister(&rapl_pmu.pmu);

drivers/powercap/intel_rapl_common.c

2005

memset(&rapl_pmu.pmu, 0, sizeof(struct pmu));

drivers/powercap/intel_rapl_common.c

2006

rapl_pmu.pmu.attr_groups = pmu_attr_groups;

drivers/powercap/intel_rapl_common.c

2007

rapl_pmu.pmu.attr_update = pmu_attr_update;

drivers/powercap/intel_rapl_common.c

2008

rapl_pmu.pmu.task_ctx_nr = perf_invalid_context;

drivers/powercap/intel_rapl_common.c

2009

rapl_pmu.pmu.event_init = rapl_pmu_event_init;

drivers/powercap/intel_rapl_common.c

2010

rapl_pmu.pmu.add = rapl_pmu_event_add;

drivers/powercap/intel_rapl_common.c

2011

rapl_pmu.pmu.del = rapl_pmu_event_del;

drivers/powercap/intel_rapl_common.c

2012

rapl_pmu.pmu.start = rapl_pmu_event_start;

drivers/powercap/intel_rapl_common.c

2013

rapl_pmu.pmu.stop = rapl_pmu_event_stop;

drivers/powercap/intel_rapl_common.c

2014

rapl_pmu.pmu.read = rapl_pmu_event_read;

drivers/powercap/intel_rapl_common.c

2015

rapl_pmu.pmu.module = THIS_MODULE;

drivers/powercap/intel_rapl_common.c

2016

rapl_pmu.pmu.capabilities = PERF_PMU_CAP_NO_EXCLUDE | PERF_PMU_CAP_NO_INTERRUPT;

drivers/powercap/intel_rapl_common.c

2017

ret = perf_pmu_register(&rapl_pmu.pmu, "power", -1);

drivers/powercap/intel_rapl_common.c

2109

perf_pmu_unregister(&rapl_pmu.pmu);

drivers/regulator/bcm590xx-regulator.c

1101

struct bcm590xx_reg *pmu;

drivers/regulator/bcm590xx-regulator.c

1107

pmu = devm_kzalloc(&pdev->dev, sizeof(*pmu), GFP_KERNEL);

drivers/regulator/bcm590xx-regulator.c

1108

if (!pmu)

drivers/regulator/bcm590xx-regulator.c

1111

pmu->mfd = bcm590xx;

drivers/regulator/bcm590xx-regulator.c

1113

switch (pmu->mfd->pmu_id) {

drivers/regulator/bcm590xx-regulator.c

1115

pmu->n_regulators = BCM59054_NUM_REGS;

drivers/regulator/bcm590xx-regulator.c

1116

if (pmu->mfd->rev_analog == BCM59054_REV_ANALOG_A1)

drivers/regulator/bcm590xx-regulator.c

1117

pmu->regs = bcm59054_a1_regs;

drivers/regulator/bcm590xx-regulator.c

1119

pmu->regs = bcm59054_regs;

drivers/regulator/bcm590xx-regulator.c

1122

pmu->n_regulators = BCM59056_NUM_REGS;

drivers/regulator/bcm590xx-regulator.c

1123

pmu->regs = bcm59056_regs;

drivers/regulator/bcm590xx-regulator.c

1131

platform_set_drvdata(pdev, pmu);

drivers/regulator/bcm590xx-regulator.c

1134

for (i = 0; i < pmu->n_regulators; i++) {

drivers/regulator/bcm590xx-regulator.c

1135

info = &pmu->regs[i];

drivers/regulator/bcm590xx-regulator.c

1138

config.driver_data = pmu;

drivers/scsi/arcmsr/arcmsr_hba.c

1591

struct MessageUnit_D *pmu = acb->pmuD;

drivers/scsi/arcmsr/arcmsr_hba.c

1600

pmu->done_qbuffer[0].addressLow + 1;

drivers/scsi/arcmsr/arcmsr_hba.c

1601

doneq_index = pmu->doneq_index;

drivers/scsi/arcmsr/arcmsr_hba.c

1607

pmu->doneq_index = index_stripped ? (index_stripped | toggle) :

drivers/scsi/arcmsr/arcmsr_hba.c

1609

doneq_index = pmu->doneq_index;

drivers/scsi/arcmsr/arcmsr_hba.c

1611

addressLow = pmu->done_qbuffer[doneq_index &

drivers/scsi/arcmsr/arcmsr_hba.c

1625

pmu->outboundlist_read_pointer);

drivers/scsi/arcmsr/arcmsr_hba.c

1631

pmu->postq_index = 0;

drivers/scsi/arcmsr/arcmsr_hba.c

1632

pmu->doneq_index = 0x40FF;

drivers/scsi/arcmsr/arcmsr_hba.c

1946

struct MessageUnit_D *pmu = acb->pmuD;

drivers/scsi/arcmsr/arcmsr_hba.c

1953

postq_index = pmu->postq_index;

drivers/scsi/arcmsr/arcmsr_hba.c

1954

pinbound_srb = (struct InBound_SRB *)&(pmu->post_qbuffer[postq_index & 0xFF]);

drivers/scsi/arcmsr/arcmsr_hba.c

1962

pmu->postq_index = index_stripped ? (index_stripped | toggle) :

drivers/scsi/arcmsr/arcmsr_hba.c

1964

writel(postq_index, pmu->inboundlist_write_pointer);

drivers/scsi/arcmsr/arcmsr_hba.c

1969

struct MessageUnit_E __iomem *pmu = acb->pmuE;

drivers/scsi/arcmsr/arcmsr_hba.c

1974

writel(0, &pmu->inbound_queueport_high);

drivers/scsi/arcmsr/arcmsr_hba.c

1975

writel(ccb_post_stamp, &pmu->inbound_queueport_low);

drivers/scsi/arcmsr/arcmsr_hba.c

1979

struct MessageUnit_F __iomem *pmu = acb->pmuF;

drivers/scsi/arcmsr/arcmsr_hba.c

1991

writel(0, &pmu->inbound_queueport_high);

drivers/scsi/arcmsr/arcmsr_hba.c

1992

writel(ccb_post_stamp, &pmu->inbound_queueport_low);

drivers/scsi/arcmsr/arcmsr_hba.c

2487

struct MessageUnit_D *pmu = pACB->pmuD;

drivers/scsi/arcmsr/arcmsr_hba.c

2489

outbound_doorbell = readl(pmu->outbound_doorbell);

drivers/scsi/arcmsr/arcmsr_hba.c

2491

writel(outbound_doorbell, pmu->outbound_doorbell);

drivers/scsi/arcmsr/arcmsr_hba.c

2498

outbound_doorbell = readl(pmu->outbound_doorbell);

drivers/scsi/arcmsr/arcmsr_hba.c

2623

struct MessageUnit_D *pmu;

drivers/scsi/arcmsr/arcmsr_hba.c

2629

pmu = acb->pmuD;

drivers/scsi/arcmsr/arcmsr_hba.c

2630

outbound_write_pointer = pmu->done_qbuffer[0].addressLow + 1;

drivers/scsi/arcmsr/arcmsr_hba.c

2631

doneq_index = pmu->doneq_index;

drivers/scsi/arcmsr/arcmsr_hba.c

2637

pmu->doneq_index = index_stripped ? (index_stripped | toggle) :

drivers/scsi/arcmsr/arcmsr_hba.c

2639

doneq_index = pmu->doneq_index;

drivers/scsi/arcmsr/arcmsr_hba.c

2640

addressLow = pmu->done_qbuffer[doneq_index &

drivers/scsi/arcmsr/arcmsr_hba.c

2652

writel(doneq_index, pmu->outboundlist_read_pointer);

drivers/scsi/arcmsr/arcmsr_hba.c

2657

pmu->outboundlist_interrupt_cause);

drivers/scsi/arcmsr/arcmsr_hba.c

2658

readl(pmu->outboundlist_interrupt_cause);

drivers/scsi/arcmsr/arcmsr_hba.c

2667

struct MessageUnit_E __iomem *pmu;

drivers/scsi/arcmsr/arcmsr_hba.c

2673

pmu = acb->pmuE;

drivers/scsi/arcmsr/arcmsr_hba.c

2674

while ((readl(&pmu->reply_post_producer_index) & 0xFFFF) != doneq_index) {

drivers/scsi/arcmsr/arcmsr_hba.c

2685

writel(doneq_index, &pmu->reply_post_consumer_index);

drivers/scsi/arcmsr/arcmsr_hba.c

2862

struct MessageUnit_D *pmu = pACB->pmuD;

drivers/scsi/arcmsr/arcmsr_hba.c

2864

host_interrupt_status = readl(pmu->host_int_status) &

drivers/scsi/arcmsr/arcmsr_hba.c

2877

host_interrupt_status = readl(pmu->host_int_status);

drivers/scsi/arcmsr/arcmsr_hba.c

2887

struct MessageUnit_E __iomem *pmu = pACB->pmuE;

drivers/scsi/arcmsr/arcmsr_hba.c

2889

host_interrupt_status = readl(&pmu->host_int_status) &

drivers/scsi/arcmsr/arcmsr_hba.c

2903

host_interrupt_status = readl(&pmu->host_int_status);

drivers/scsi/arcmsr/arcmsr_hba.c

3775

struct MessageUnit_D *pmu = acb->pmuD;

drivers/scsi/arcmsr/arcmsr_hba.c

3781

outbound_write_pointer = pmu->done_qbuffer[0].addressLow + 1;

drivers/scsi/arcmsr/arcmsr_hba.c

3782

doneq_index = pmu->doneq_index;

drivers/scsi/arcmsr/arcmsr_hba.c

3800

pmu->doneq_index = index_stripped ? (index_stripped | toggle) :

drivers/scsi/arcmsr/arcmsr_hba.c

3802

doneq_index = pmu->doneq_index;

drivers/scsi/arcmsr/arcmsr_hba.c

3804

flag_ccb = pmu->done_qbuffer[doneq_index & 0xFFF].addressLow;

drivers/scsi/arcmsr/arcmsr_hba.c

4361

struct MessageUnit_D *pmu = pACB->pmuD;

drivers/scsi/arcmsr/arcmsr_hba.c

4364

writel(ARCMSR_INBOUND_MESG0_START_BGRB, pmu->inbound_msgaddr0);

drivers/scsi/arcmsr/arcmsr_hba.c

4373

struct MessageUnit_E __iomem *pmu = pACB->pmuE;

drivers/scsi/arcmsr/arcmsr_hba.c

4376

writel(ARCMSR_INBOUND_MESG0_START_BGRB, &pmu->inbound_msgaddr0);

drivers/scsi/arcmsr/arcmsr_hba.c

4378

writel(pACB->out_doorbell, &pmu->iobound_doorbell);

drivers/soc/dove/pmu.c

103

static void __init pmu_reset_init(struct pmu_data *pmu)

drivers/soc/dove/pmu.c

107

pmu->reset = pmu_reset;

drivers/soc/dove/pmu.c

108

pmu->reset.of_node = pmu->of_node;

drivers/soc/dove/pmu.c

110

ret = reset_controller_register(&pmu->reset);

drivers/soc/dove/pmu.c

115

static void __init pmu_reset_init(struct pmu_data *pmu)

drivers/soc/dove/pmu.c

121

struct pmu_data *pmu;

drivers/soc/dove/pmu.c

146

struct pmu_data *pmu = pmu_dom->pmu;

drivers/soc/dove/pmu.c

149

void __iomem *pmu_base = pmu->pmu_base;

drivers/soc/dove/pmu.c

150

void __iomem *pmc_base = pmu->pmc_base;

drivers/soc/dove/pmu.c

152

spin_lock_irqsave(&pmu->lock, flags);

drivers/soc/dove/pmu.c

172

spin_unlock_irqrestore(&pmu->lock, flags);

drivers/soc/dove/pmu.c

180

struct pmu_data *pmu = pmu_dom->pmu;

drivers/soc/dove/pmu.c

183

void __iomem *pmu_base = pmu->pmu_base;

drivers/soc/dove/pmu.c

184

void __iomem *pmc_base = pmu->pmc_base;

drivers/soc/dove/pmu.c

186

spin_lock_irqsave(&pmu->lock, flags);

drivers/soc/dove/pmu.c

206

spin_unlock_irqrestore(&pmu->lock, flags);

drivers/soc/dove/pmu.c

214

unsigned int val = readl_relaxed(domain->pmu->pmu_base + PMU_PWR);

drivers/soc/dove/pmu.c

228

struct pmu_data *pmu = irq_desc_get_handler_data(desc);

drivers/soc/dove/pmu.c

229

struct irq_chip_generic *gc = pmu->irq_gc;

drivers/soc/dove/pmu.c

230

struct irq_domain *domain = pmu->irq_domain;

drivers/soc/dove/pmu.c

265

static int __init dove_init_pmu_irq(struct pmu_data *pmu, int irq)

drivers/soc/dove/pmu.c

273

writel(0, pmu->pmc_base + PMC_IRQ_MASK);

drivers/soc/dove/pmu.c

274

writel(0, pmu->pmc_base + PMC_IRQ_CAUSE);

drivers/soc/dove/pmu.c

276

domain = irq_domain_create_linear(of_fwnode_handle(pmu->of_node), NR_PMU_IRQS,

drivers/soc/dove/pmu.c

294

gc->reg_base = pmu->pmc_base;

drivers/soc/dove/pmu.c

299

pmu->irq_domain = domain;

drivers/soc/dove/pmu.c

300

pmu->irq_gc = gc;

drivers/soc/dove/pmu.c

302

irq_set_handler_data(irq, pmu);

drivers/soc/dove/pmu.c

311

struct pmu_data *pmu;

drivers/soc/dove/pmu.c

314

pmu = kzalloc_obj(*pmu);

drivers/soc/dove/pmu.c

315

if (!pmu)

drivers/soc/dove/pmu.c

318

spin_lock_init(&pmu->lock);

drivers/soc/dove/pmu.c

319

pmu->pmc_base = initdata->pmc_base;

drivers/soc/dove/pmu.c

320

pmu->pmu_base = initdata->pmu_base;

drivers/soc/dove/pmu.c

322

pmu_reset_init(pmu);

drivers/soc/dove/pmu.c

329

domain->pmu = pmu;

drivers/soc/dove/pmu.c

339

ret = dove_init_pmu_irq(pmu, initdata->irq);

drivers/soc/dove/pmu.c

343

if (pmu->irq_domain)

drivers/soc/dove/pmu.c

344

irq_domain_associate_many(pmu->irq_domain,

drivers/soc/dove/pmu.c

375

struct pmu_data *pmu;

drivers/soc/dove/pmu.c

389

pmu = kzalloc_obj(*pmu);

drivers/soc/dove/pmu.c

390

if (!pmu)

drivers/soc/dove/pmu.c

393

spin_lock_init(&pmu->lock);

drivers/soc/dove/pmu.c

394

pmu->of_node = np_pmu;

drivers/soc/dove/pmu.c

395

pmu->pmc_base = of_iomap(pmu->of_node, 0);

drivers/soc/dove/pmu.c

396

pmu->pmu_base = of_iomap(pmu->of_node, 1);

drivers/soc/dove/pmu.c

397

if (!pmu->pmc_base || !pmu->pmu_base) {

drivers/soc/dove/pmu.c

399

iounmap(pmu->pmu_base);

drivers/soc/dove/pmu.c

400

iounmap(pmu->pmc_base);

drivers/soc/dove/pmu.c

401

kfree(pmu);

drivers/soc/dove/pmu.c

405

pmu_reset_init(pmu);

drivers/soc/dove/pmu.c

415

domain->pmu = pmu;

drivers/soc/dove/pmu.c

435

if (args.np == pmu->of_node)

drivers/soc/dove/pmu.c

444

parent_irq = irq_of_parse_and_map(pmu->of_node, 0);

drivers/soc/dove/pmu.c

448

ret = dove_init_pmu_irq(pmu, parent_irq);

drivers/soc/dove/pmu.c

50

struct pmu_data *pmu = rcdev_to_pmu(rc);

drivers/soc/dove/pmu.c

54

spin_lock_irqsave(&pmu->lock, flags);

drivers/soc/dove/pmu.c

55

val = readl_relaxed(pmu->pmc_base + PMC_SW_RST);

drivers/soc/dove/pmu.c

56

writel_relaxed(val & ~BIT(id), pmu->pmc_base + PMC_SW_RST);

drivers/soc/dove/pmu.c

57

writel_relaxed(val | BIT(id), pmu->pmc_base + PMC_SW_RST);

drivers/soc/dove/pmu.c

58

spin_unlock_irqrestore(&pmu->lock, flags);

drivers/soc/dove/pmu.c

65

struct pmu_data *pmu = rcdev_to_pmu(rc);

drivers/soc/dove/pmu.c

69

spin_lock_irqsave(&pmu->lock, flags);

drivers/soc/dove/pmu.c

70

val &= readl_relaxed(pmu->pmc_base + PMC_SW_RST);

drivers/soc/dove/pmu.c

71

writel_relaxed(val, pmu->pmc_base + PMC_SW_RST);

drivers/soc/dove/pmu.c

72

spin_unlock_irqrestore(&pmu->lock, flags);

drivers/soc/dove/pmu.c

79

struct pmu_data *pmu = rcdev_to_pmu(rc);

drivers/soc/dove/pmu.c

83

spin_lock_irqsave(&pmu->lock, flags);

drivers/soc/dove/pmu.c

84

val |= readl_relaxed(pmu->pmc_base + PMC_SW_RST);

drivers/soc/dove/pmu.c

85

writel_relaxed(val, pmu->pmc_base + PMC_SW_RST);

drivers/soc/dove/pmu.c

86

spin_unlock_irqrestore(&pmu->lock, flags);

drivers/soc/tegra/pmc.c

3463

u32 value, osc, pmu, off;

drivers/soc/tegra/pmc.c

3493

pmu = DIV_ROUND_UP(pmc->core_pmu_time * 32768, 1000000);

drivers/soc/tegra/pmc.c

3495

tegra_pmc_writel(pmc, ((osc << 8) & 0xff00) | (pmu & 0xff),

drivers/ssb/driver_chipcommon_pmu.c

104

cc->pmu.crystalfreq = e->freq;

drivers/ssb/driver_chipcommon_pmu.c

233

cc->pmu.crystalfreq = 20000;

drivers/ssb/driver_chipcommon_pmu.c

243

cc->pmu.crystalfreq = e->freq;

drivers/ssb/driver_chipcommon_pmu.c

344

if (cc->pmu.rev == 2) {

drivers/ssb/driver_chipcommon_pmu.c

525

cc->pmu.rev = (pmucap & SSB_CHIPCO_PMU_CAP_REVISION);

drivers/ssb/driver_chipcommon_pmu.c

528

cc->pmu.rev, pmucap);

drivers/ssb/driver_chipcommon_pmu.c

530

if (cc->pmu.rev == 1)

include/kvm/arm_pmu.h

41

#define kvm_arm_pmu_irq_initialized(v) ((v)->arch.pmu.irq_num >= VGIC_NR_SGIS)

include/kvm/arm_pmu.h

84

vcpu->arch.pmu.events = *kvm_get_pmu_events(); \

include/linux/bcma/bcma_driver_chipcommon.h

632

struct bcma_chipcommon_pmu pmu;

include/linux/bcma/bcma_driver_chipcommon.h

678

bcma_read32((cc)->pmu.core, offset)

include/linux/bcma/bcma_driver_chipcommon.h

680

bcma_write32((cc)->pmu.core, offset, val)

include/linux/nd.h

50

struct pmu pmu;

include/linux/perf/arm_pmu.h

134

#define to_arm_pmu(p) (container_of(p, struct arm_pmu, pmu))

include/linux/perf/arm_pmu.h

181

void kvm_host_pmu_init(struct arm_pmu *pmu);

include/linux/perf/arm_pmu.h

190

void armpmu_free(struct arm_pmu *pmu);

include/linux/perf/arm_pmu.h

191

int armpmu_register(struct arm_pmu *pmu);

include/linux/perf/arm_pmu.h

89

struct pmu pmu;

include/linux/perf/arm_pmu.h

92

irqreturn_t (*handle_irq)(struct arm_pmu *pmu);

include/linux/perf/riscv_pmu.h

53

struct pmu pmu;

include/linux/perf/riscv_pmu.h

76

#define to_riscv_pmu(p) (container_of(p, struct riscv_pmu, pmu))

include/linux/perf_event.h

1222

extern int perf_pmu_register(struct pmu *pmu, const char *name, int type);

include/linux/perf_event.h

1223

extern int perf_pmu_unregister(struct pmu *pmu);

include/linux/perf_event.h

1237

extern void perf_pmu_disable(struct pmu *pmu);

include/linux/perf_event.h

1238

extern void perf_pmu_enable(struct pmu *pmu);

include/linux/perf_event.h

1239

extern void perf_sched_cb_dec(struct pmu *pmu);

include/linux/perf_event.h

1240

extern void perf_sched_cb_inc(struct pmu *pmu);

include/linux/perf_event.h

1244

extern void perf_pmu_resched(struct pmu *pmu);

include/linux/perf_event.h

1257

extern void perf_pmu_migrate_context(struct pmu *pmu,

include/linux/perf_event.h

1564

return event->pmu_ctx->pmu->task_ctx_nr == perf_sw_context;

include/linux/perf_event.h

1567

static inline int is_exclusive_pmu(struct pmu *pmu)

include/linux/perf_event.h

1569

return pmu->capabilities & PERF_PMU_CAP_EXCLUSIVE;

include/linux/perf_event.h

1856

return event->pmu && event->pmu->setup_aux;

include/linux/perf_event.h

1873

return event->pmu->nr_addr_filters;

include/linux/perf_event.h

366

void (*pmu_enable) (struct pmu *pmu); /* optional */

include/linux/perf_event.h

367

void (*pmu_disable) (struct pmu *pmu); /* optional */

include/linux/perf_event.h

486

void (*start_txn) (struct pmu *pmu, unsigned int txn_flags);

include/linux/perf_event.h

495

int (*commit_txn) (struct pmu *pmu);

include/linux/perf_event.h

502

void (*cancel_txn) (struct pmu *pmu);

include/linux/perf_event.h

586

bool (*filter) (struct pmu *pmu, int cpu); /* optional */

include/linux/perf_event.h

808

struct pmu *pmu;

include/linux/perf_event.h

965

struct pmu *pmu;

include/linux/ssb/ssb_driver_chipcommon.h

594

struct ssb_chipcommon_pmu pmu;

include/xen/interface/xenpmu.h

92

struct xen_pmu_arch pmu;

kernel/events/core.c

10477

if (!(event->pmu->capabilities & PERF_PMU_CAP_ITRACE) ||

kernel/events/core.c

10714

event->pmu->stop(event, 0);

kernel/events/core.c

11192

static struct pmu perf_cpu_clock; /* fwd declaration */

kernel/events/core.c

11193

static struct pmu perf_task_clock;

kernel/events/core.c

11237

static struct pmu perf_swevent = {

kernel/events/core.c

11279

static struct pmu perf_tracepoint = {

kernel/events/core.c

11366

struct pmu *pmu = &perf_tracepoint;

kernel/events/core.c

11369

perf_event_groups_for_cpu_pmu(event, &ctx->pinned_groups, cpu, pmu) {

kernel/events/core.c

11375

perf_event_groups_for_cpu_pmu(event, &ctx->flexible_groups, cpu, pmu) {

kernel/events/core.c

11483

static struct pmu perf_kprobe = {

kernel/events/core.c

11542

static struct pmu perf_uprobe = {

kernel/events/core.c

11605

if (event->pmu == &perf_tracepoint)

kernel/events/core.c

11608

if (event->pmu == &perf_kprobe)

kernel/events/core.c

11612

if (event->pmu == &perf_uprobe)

kernel/events/core.c

12113

ret = event->pmu->addr_filters_validate(&filters);

kernel/events/core.c

12188

event->pmu->read(event);

kernel/events/core.c

12345

static struct pmu perf_cpu_clock = {

kernel/events/core.c

12430

static struct pmu perf_task_clock = {

kernel/events/core.c

12444

static void perf_pmu_nop_void(struct pmu *pmu)

kernel/events/core.c

12448

static void perf_pmu_nop_txn(struct pmu *pmu, unsigned int flags)

kernel/events/core.c

12452

static int perf_pmu_nop_int(struct pmu *pmu)

kernel/events/core.c

12464

static void perf_pmu_start_txn(struct pmu *pmu, unsigned int flags)

kernel/events/core.c

12471

perf_pmu_disable(pmu);

kernel/events/core.c

12474

static int perf_pmu_commit_txn(struct pmu *pmu)

kernel/events/core.c

12483

perf_pmu_enable(pmu);

kernel/events/core.c

12487

static void perf_pmu_cancel_txn(struct pmu *pmu)

kernel/events/core.c

12496

perf_pmu_enable(pmu);

kernel/events/core.c

12511

struct pmu *pmu = dev_get_drvdata(dev);

kernel/events/core.c

12513

return sysfs_emit(page, "%d\n", pmu->nr_addr_filters);

kernel/events/core.c

12522

struct pmu *pmu = dev_get_drvdata(dev);

kernel/events/core.c

12524

return sysfs_emit(page, "%d\n", pmu->type);

kernel/events/core.c

12533

struct pmu *pmu = dev_get_drvdata(dev);

kernel/events/core.c

12535

return sysfs_emit(page, "%d\n", pmu->hrtimer_interval_ms);

kernel/events/core.c

12545

struct pmu *pmu = dev_get_drvdata(dev);

kernel/events/core.c

12556

if (timer == pmu->hrtimer_interval_ms)

kernel/events/core.c

12560

pmu->hrtimer_interval_ms = timer;

kernel/events/core.c

12566

cpc = *per_cpu_ptr(pmu->cpu_pmu_context, cpu);

kernel/events/core.c

12617

struct pmu *pmu = dev_get_drvdata(dev);

kernel/events/core.c

12618

struct cpumask *mask = perf_scope_cpumask(pmu->scope);

kernel/events/core.c

12638

struct pmu *pmu = dev_get_drvdata(dev);

kernel/events/core.c

12640

if (n == 2 && !pmu->nr_addr_filters)

kernel/events/core.c

12644

if (n == 3 && pmu->scope == PERF_PMU_SCOPE_NONE)

kernel/events/core.c

12671

static int pmu_dev_alloc(struct pmu *pmu)

kernel/events/core.c

12675

pmu->dev = kzalloc_obj(struct device);

kernel/events/core.c

12676

if (!pmu->dev)

kernel/events/core.c

12679

pmu->dev->groups = pmu->attr_groups;

kernel/events/core.c

12680

device_initialize(pmu->dev);

kernel/events/core.c

12682

dev_set_drvdata(pmu->dev, pmu);

kernel/events/core.c

12683

pmu->dev->bus = &pmu_bus;

kernel/events/core.c

12684

pmu->dev->parent = pmu->parent;

kernel/events/core.c

12685

pmu->dev->release = pmu_dev_release;

kernel/events/core.c

12687

ret = dev_set_name(pmu->dev, "%s", pmu->name);

kernel/events/core.c

12691

ret = device_add(pmu->dev);

kernel/events/core.c

12695

if (pmu->attr_update) {

kernel/events/core.c

12696

ret = sysfs_update_groups(&pmu->dev->kobj, pmu->attr_update);

kernel/events/core.c

12705

device_del(pmu->dev);

kernel/events/core.c

12708

put_device(pmu->dev);

kernel/events/core.c

12709

pmu->dev = NULL;

kernel/events/core.c

12731

static void perf_pmu_free(struct pmu *pmu)

kernel/events/core.c

12733

if (pmu_bus_running && pmu->dev && pmu->dev != PMU_NULL_DEV) {

kernel/events/core.c

12734

if (pmu->nr_addr_filters)

kernel/events/core.c

12735

device_remove_file(pmu->dev, &dev_attr_nr_addr_filters);

kernel/events/core.c

12736

device_del(pmu->dev);

kernel/events/core.c

12737

put_device(pmu->dev);

kernel/events/core.c

12740

if (pmu->cpu_pmu_context) {

kernel/events/core.c

12746

cpc = *per_cpu_ptr(pmu->cpu_pmu_context, cpu);

kernel/events/core.c

12756

free_percpu(pmu->cpu_pmu_context);

kernel/events/core.c

12760

DEFINE_FREE(pmu_unregister, struct pmu *, if (_T) perf_pmu_free(_T))

kernel/events/core.c

12762

int perf_pmu_register(struct pmu *_pmu, const char *name, int type)

kernel/events/core.c

12766

struct pmu *pmu __free(pmu_unregister) = _pmu;

kernel/events/core.c

12772

if (WARN_ONCE(pmu->scope >= PERF_PMU_MAX_SCOPE,

kernel/events/core.c

12776

pmu->name = name;

kernel/events/core.c

12787

pmu->type = pmu_type.id;

kernel/events/core.c

12788

atomic_set(&pmu->exclusive_cnt, 0);

kernel/events/core.c

12790

if (pmu_bus_running && !pmu->dev) {

kernel/events/core.c

12791

int ret = pmu_dev_alloc(pmu);

kernel/events/core.c

12796

pmu->cpu_pmu_context = alloc_percpu(struct perf_cpu_pmu_context *);

kernel/events/core.c

12797

if (!pmu->cpu_pmu_context)

kernel/events/core.c

12809

*per_cpu_ptr(pmu->cpu_pmu_context, cpu) = cpc;

kernel/events/core.c

12810

__perf_init_event_pmu_context(&cpc->epc, pmu);

kernel/events/core.c

12814

if (!pmu->start_txn) {

kernel/events/core.c

12815

if (pmu->pmu_enable) {

kernel/events/core.c

12821

pmu->start_txn = perf_pmu_start_txn;

kernel/events/core.c

12822

pmu->commit_txn = perf_pmu_commit_txn;

kernel/events/core.c

12823

pmu->cancel_txn = perf_pmu_cancel_txn;

kernel/events/core.c

12825

pmu->start_txn = perf_pmu_nop_txn;

kernel/events/core.c

12826

pmu->commit_txn = perf_pmu_nop_int;

kernel/events/core.c

12827

pmu->cancel_txn = perf_pmu_nop_void;

kernel/events/core.c

12831

if (!pmu->pmu_enable) {

kernel/events/core.c

12832

pmu->pmu_enable = perf_pmu_nop_void;

kernel/events/core.c

12833

pmu->pmu_disable = perf_pmu_nop_void;

kernel/events/core.c

12836

if (!pmu->check_period)

kernel/events/core.c

12837

pmu->check_period = perf_event_nop_int;

kernel/events/core.c

12839

if (!pmu->event_idx)

kernel/events/core.c

12840

pmu->event_idx = perf_event_idx_default;

kernel/events/core.c

12842

INIT_LIST_HEAD(&pmu->events);

kernel/events/core.c

12843

spin_lock_init(&pmu->events_lock);

kernel/events/core.c

12848

if (!idr_cmpxchg(&pmu_idr, pmu->type, NULL, pmu))

kernel/events/core.c

12850

list_add_rcu(&pmu->entry, &pmus);

kernel/events/core.c

12853

_pmu = no_free_ptr(pmu); // let it rip

kernel/events/core.c

12858

static void __pmu_detach_event(struct pmu *pmu, struct perf_event *event,

kernel/events/core.c

12872

WARN_ON_ONCE(pmu->event_unmapped);

kernel/events/core.c

12893

module_put(pmu->module);

kernel/events/core.c

12895

event->pmu = NULL; /* force fault instead of UAF */

kernel/events/core.c

12898

static void pmu_detach_event(struct pmu *pmu, struct perf_event *event)

kernel/events/core.c

12903

__pmu_detach_event(pmu, event, ctx);

kernel/events/core.c

12906

scoped_guard (spinlock, &pmu->events_lock)

kernel/events/core.c

12910

static struct perf_event *pmu_get_event(struct pmu *pmu)

kernel/events/core.c

12914

guard(spinlock)(&pmu->events_lock);

kernel/events/core.c

12915

list_for_each_entry(event, &pmu->events, pmu_list) {

kernel/events/core.c

12923

static bool pmu_empty(struct pmu *pmu)

kernel/events/core.c

12925

guard(spinlock)(&pmu->events_lock);

kernel/events/core.c

12926

return list_empty(&pmu->events);

kernel/events/core.c

12929

static void pmu_detach_events(struct pmu *pmu)

kernel/events/core.c

12934

event = pmu_get_event(pmu);

kernel/events/core.c

12938

pmu_detach_event(pmu, event);

kernel/events/core.c

12945

wait_var_event(pmu, pmu_empty(pmu));

kernel/events/core.c

12948

int perf_pmu_unregister(struct pmu *pmu)

kernel/events/core.c

12951

if (!idr_cmpxchg(&pmu_idr, pmu->type, pmu, NULL))

kernel/events/core.c

12954

list_del_rcu(&pmu->entry);

kernel/events/core.c

12970

if (pmu->event_unmapped && !pmu_empty(pmu)) {

kernel/events/core.c

12976

idr_cmpxchg(&pmu_idr, pmu->type, NULL, pmu);

kernel/events/core.c

12977

list_add_rcu(&pmu->entry, &pmus);

kernel/events/core.c

12982

idr_remove(&pmu_idr, pmu->type);

kernel/events/core.c

12988

pmu_detach_events(pmu);

kernel/events/core.c

12993

perf_pmu_free(pmu);

kernel/events/core.c

1300

struct pmu *pmu = cpc->epc.pmu;

kernel/events/core.c

13004

static int perf_try_init_event(struct pmu *pmu, struct perf_event *event)

kernel/events/core.c

13009

if (!try_module_get(pmu->module))

kernel/events/core.c

13018

if (event->group_leader != event && pmu->task_ctx_nr != perf_sw_context) {

kernel/events/core.c

13028

event->pmu = pmu;

kernel/events/core.c

13029

ret = pmu->event_init(event);

kernel/events/core.c

13037

if (!(pmu->capabilities & PERF_PMU_CAP_EXTENDED_REGS) &&

kernel/events/core.c

13043

if (pmu->capabilities & PERF_PMU_CAP_NO_EXCLUDE &&

kernel/events/core.c

13049

if (pmu->scope != PERF_PMU_SCOPE_NONE && event->cpu >= 0) {

kernel/events/core.c

13054

cpumask = perf_scope_cpu_topology_cpumask(pmu->scope, event->cpu);

kernel/events/core.c

13055

pmu_cpumask = perf_scope_cpumask(pmu->scope);

kernel/events/core.c

1307

interval = pmu->hrtimer_interval_ms;

kernel/events/core.c

13077

event->pmu = NULL;

kernel/events/core.c

13078

module_put(pmu->module);

kernel/events/core.c

13082

static struct pmu *perf_init_event(struct perf_event *event)

kernel/events/core.c

13085

struct pmu *pmu;

kernel/events/core.c

1309

interval = pmu->hrtimer_interval_ms = PERF_CPU_HRTIMER;

kernel/events/core.c

13097

if (event->parent && event->parent->pmu) {

kernel/events/core.c

13098

pmu = event->parent->pmu;

kernel/events/core.c

13099

ret = perf_try_init_event(pmu, event);

kernel/events/core.c

13101

return pmu;

kernel/events/core.c

13121

pmu = idr_find(&pmu_idr, type);

kernel/events/core.c

13122

if (pmu) {

kernel/events/core.c

13124

!(pmu->capabilities & PERF_PMU_CAP_EXTENDED_HW_TYPE))

kernel/events/core.c

13127

ret = perf_try_init_event(pmu, event);

kernel/events/core.c

13136

return pmu;

kernel/events/core.c

13139

list_for_each_entry_rcu(pmu, &pmus, entry, lockdep_is_held(&pmus_srcu)) {

kernel/events/core.c

13140

ret = perf_try_init_event(pmu, event);

kernel/events/core.c

13142

return pmu;

kernel/events/core.c

13274

struct pmu *pmu;

kernel/events/core.c

13327

event->pmu = NULL;

kernel/events/core.c

13380

pmu = NULL;

kernel/events/core.c

1339

static __always_inline struct perf_cpu_pmu_context *this_cpc(struct pmu *pmu)

kernel/events/core.c

13402

pmu = perf_init_event(event);

kernel/events/core.c

13403

if (IS_ERR(pmu))

kernel/events/core.c

13404

return (void*)pmu;

kernel/events/core.c

1341

return *this_cpu_ptr(pmu->cpu_pmu_context);

kernel/events/core.c

13423

if (pmu->task_ctx_nr == perf_invalid_context && (task || cgroup_fd != -1))

kernel/events/core.c

13427

(!(pmu->capabilities & PERF_PMU_CAP_AUX_OUTPUT) ||

kernel/events/core.c

13435

if (!(pmu->capabilities & PERF_PMU_CAP_AUX_PAUSE))

kernel/events/core.c

1344

void perf_pmu_disable(struct pmu *pmu)

kernel/events/core.c

13451

event->addr_filter_ranges = kcalloc(pmu->nr_addr_filters,

kernel/events/core.c

1346

int *count = &this_cpc(pmu)->pmu_disable_count;

kernel/events/core.c

13467

pmu->nr_addr_filters * sizeof(struct perf_addr_filter_range));

kernel/events/core.c

1348

pmu->pmu_disable(pmu);

kernel/events/core.c

13499

scoped_guard (spinlock, &pmu->events_lock)

kernel/events/core.c

13500

list_add(&event->pmu_list, &pmu->events);

kernel/events/core.c

1351

void perf_pmu_enable(struct pmu *pmu)

kernel/events/core.c

1353

int *count = &this_cpc(pmu)->pmu_disable_count;

kernel/events/core.c

1355

pmu->pmu_enable(pmu);

kernel/events/core.c

1358

static void perf_assert_pmu_disabled(struct pmu *pmu)

kernel/events/core.c

1360

int *count = &this_cpc(pmu)->pmu_disable_count;

kernel/events/core.c

1367

event->pmu->read(event);

kernel/events/core.c

13684

event->pmu != output_event->pmu)

kernel/events/core.c

13759

if (!nmi_safe && !(event->pmu->capabilities & PERF_PMU_CAP_NO_NMI))

kernel/events/core.c

13816

struct pmu *pmu;

kernel/events/core.c

13932

if (event->pmu->capabilities & PERF_PMU_CAP_NO_INTERRUPT) {

kernel/events/core.c

13942

pmu = event->pmu;

kernel/events/core.c

13950

if (pmu->task_ctx_nr == perf_sw_context)

kernel/events/core.c

14047

pmu = group_leader->pmu_ctx->pmu;

kernel/events/core.c

14061

group_leader->pmu_ctx->pmu != pmu)

kernel/events/core.c

14069

pmu_ctx = find_get_pmu_context(pmu, ctx, event);

kernel/events/core.c

14224

struct pmu *pmu;

kernel/events/core.c

14248

pmu = event->pmu;

kernel/events/core.c

14250

if (pmu->task_ctx_nr == perf_sw_context)

kernel/events/core.c

14269

pmu_ctx = find_get_pmu_context(pmu, ctx, event);

kernel/events/core.c

14317

int cpu, struct pmu *pmu,

kernel/events/core.c

14323

perf_event_groups_for_cpu_pmu(event, groups, cpu, pmu) {

kernel/events/core.c

14336

static void __perf_pmu_install_event(struct pmu *pmu,

kernel/events/core.c

14346

epc = find_get_pmu_context(pmu, ctx, event);

kernel/events/core.c

14360

int cpu, struct pmu *pmu, struct list_head *events)

kernel/events/core.c

14377

__perf_pmu_install_event(pmu, ctx, cpu, event);

kernel/events/core.c

14386

__perf_pmu_install_event(pmu, ctx, cpu, event);

kernel/events/core.c

14390

void perf_pmu_migrate_context(struct pmu *pmu, int src_cpu, int dst_cpu)

kernel/events/core.c

14408

__perf_pmu_remove(src_ctx, src_cpu, pmu, &src_ctx->pinned_groups, &events);

kernel/events/core.c

14409

__perf_pmu_remove(src_ctx, src_cpu, pmu, &src_ctx->flexible_groups, &events);

kernel/events/core.c

14417

__perf_pmu_install(dst_ctx, dst_cpu, pmu, &events);

kernel/events/core.c

14744

pmu_ctx = find_get_pmu_context(parent_event->pmu_ctx->pmu, child_ctx, child_event);

kernel/events/core.c

15092

struct pmu *pmu;

kernel/events/core.c

15112

list_for_each_entry(pmu, &pmus, entry) {

kernel/events/core.c

15113

if (pmu->scope == PERF_PMU_SCOPE_NONE ||

kernel/events/core.c

15114

WARN_ON_ONCE(pmu->scope >= PERF_PMU_MAX_SCOPE))

kernel/events/core.c

15117

if (target[pmu->scope] >= 0 && target[pmu->scope] < nr_cpu_ids)

kernel/events/core.c

15118

perf_pmu_migrate_context(pmu, cpu, target[pmu->scope]);

kernel/events/core.c

15278

struct pmu *pmu;

kernel/events/core.c

15287

list_for_each_entry(pmu, &pmus, entry) {

kernel/events/core.c

15288

if (pmu->dev)

kernel/events/core.c

15291

ret = pmu_dev_alloc(pmu);

kernel/events/core.c

15292

WARN(ret, "Failed to register pmu: %s, reason %d\n", pmu->name, ret);

kernel/events/core.c

1772

perf_event_groups_cmp(const int left_cpu, const struct pmu *left_pmu,

kernel/events/core.c

1782

if (left_pmu < right->pmu_ctx->pmu)

kernel/events/core.c

1784

if (left_pmu > right->pmu_ctx->pmu)

kernel/events/core.c

1830

return perf_event_groups_cmp(e->cpu, e->pmu_ctx->pmu, event_cgroup(e),

kernel/events/core.c

1836

struct pmu *pmu;

kernel/events/core.c

1846

return perf_event_groups_cmp(a->cpu, a->pmu, a->cgroup, b->group_index, b);

kernel/events/core.c

1856

return perf_event_groups_cmp(a->cpu, a->pmu, event_cgroup(b),

kernel/events/core.c

1917

struct pmu *pmu, struct cgroup *cgrp)

kernel/events/core.c

1921

.pmu = pmu,

kernel/events/core.c

1934

perf_event_groups_next(struct perf_event *event, struct pmu *pmu)

kernel/events/core.c

1938

.pmu = pmu,

kernel/events/core.c

1950

#define perf_event_groups_for_cpu_pmu(event, groups, cpu, pmu) \

kernel/events/core.c

1951

for (event = perf_event_groups_first(groups, cpu, pmu, NULL); \

kernel/events/core.c

1952

event; event = perf_event_groups_next(event, pmu))

kernel/events/core.c

2245

if (!event->pmu->aux_output_match)

kernel/events/core.c

2248

return event->pmu->aux_output_match(aux_event);

kernel/events/core.c

2319

!(group_leader->pmu->capabilities & PERF_PMU_CAP_AUX_PAUSE))

kernel/events/core.c

2322

if (event->attr.aux_sample_size && !group_leader->pmu->snapshot_aux)

kernel/events/core.c

2455

struct perf_cpu_pmu_context *cpc = this_cpc(epc->pmu);

kernel/events/core.c

2473

perf_pmu_disable(event->pmu);

kernel/events/core.c

2475

event->pmu->del(event, 0);

kernel/events/core.c

2495

perf_pmu_enable(event->pmu);

kernel/events/core.c

2506

perf_assert_pmu_disabled(group_event->pmu_ctx->pmu);

kernel/events/core.c

2611

struct perf_cpu_pmu_context *cpc = this_cpc(pmu_ctx->pmu);

kernel/events/core.c

2683

perf_pmu_disable(event->pmu_ctx->pmu);

kernel/events/core.c

2699

perf_pmu_enable(event->pmu_ctx->pmu);

kernel/events/core.c

2767

event->pmu->start(event, 0);

kernel/events/core.c

2778

event->pmu->stop(event, 0);

kernel/events/core.c

2805

struct perf_cpu_pmu_context *cpc = this_cpc(epc->pmu);

kernel/events/core.c

2832

perf_pmu_disable(event->pmu);

kernel/events/core.c

2836

if (event->pmu->add(event, PERF_EF_START)) {

kernel/events/core.c

2853

perf_pmu_enable(event->pmu);

kernel/events/core.c

2862

struct pmu *pmu = group_event->pmu_ctx->pmu;

kernel/events/core.c

2867

pmu->start_txn(pmu, PERF_PMU_TXN_ADD);

kernel/events/core.c

2882

if (!pmu->commit_txn(pmu))

kernel/events/core.c

2900

pmu->cancel_txn(pmu);

kernel/events/core.c

2910

struct perf_cpu_pmu_context *cpc = this_cpc(epc->pmu);

kernel/events/core.c

2944

struct pmu *pmu,

kernel/events/core.c

2955

ctx_sched_out(ctx, pmu, event_type);

kernel/events/core.c

2960

struct pmu *pmu,

kernel/events/core.c

2963

ctx_sched_in(&cpuctx->ctx, pmu, EVENT_PINNED | event_type);

kernel/events/core.c

2965

ctx_sched_in(ctx, pmu, EVENT_PINNED | event_type);

kernel/events/core.c

2966

ctx_sched_in(&cpuctx->ctx, pmu, EVENT_FLEXIBLE | event_type);

kernel/events/core.c

2968

ctx_sched_in(ctx, pmu, EVENT_FLEXIBLE | event_type);

kernel/events/core.c

2988

struct pmu *pmu, enum event_type_t event_type)

kernel/events/core.c

3002

for_each_epc(epc, &cpuctx->ctx, pmu, 0)

kernel/events/core.c

3003

perf_pmu_disable(epc->pmu);

kernel/events/core.c

3006

for_each_epc(epc, task_ctx, pmu, 0)

kernel/events/core.c

3007

perf_pmu_disable(epc->pmu);

kernel/events/core.c

3009

task_ctx_sched_out(task_ctx, pmu, event_type);

kernel/events/core.c

3020

ctx_sched_out(&cpuctx->ctx, pmu, event_type);

kernel/events/core.c

3022

ctx_sched_out(&cpuctx->ctx, pmu, EVENT_FLEXIBLE);

kernel/events/core.c

3024

perf_event_sched_in(cpuctx, task_ctx, pmu, 0);

kernel/events/core.c

3026

for_each_epc(epc, &cpuctx->ctx, pmu, 0)

kernel/events/core.c

3027

perf_pmu_enable(epc->pmu);

kernel/events/core.c

3030

for_each_epc(epc, task_ctx, pmu, 0)

kernel/events/core.c

3031

perf_pmu_enable(epc->pmu);

kernel/events/core.c

3035

void perf_pmu_resched(struct pmu *pmu)

kernel/events/core.c

3041

ctx_resched(cpuctx, task_ctx, pmu, EVENT_ALL|EVENT_CPU);

kernel/events/core.c

3099

ctx_resched(cpuctx, task_ctx, event->pmu_ctx->pmu,

kernel/events/core.c

3265

ctx_resched(cpuctx, task_ctx, event->pmu_ctx->pmu, get_event_type(event));

kernel/events/core.c

3348

event->pmu->stop(event, PERF_EF_UPDATE);

kernel/events/core.c

3360

event->pmu->start(event, 0);

kernel/events/core.c

3423

event->pmu->addr_filters_sync(event);

kernel/events/core.c

3531

struct pmu *pmu = pmu_ctx->pmu;

kernel/events/core.c

3534

struct perf_cpu_pmu_context *cpc = this_cpc(pmu);

kernel/events/core.c

3543

perf_pmu_disable(pmu);

kernel/events/core.c

3563

perf_pmu_enable(pmu);

kernel/events/core.c

3576

ctx_sched_out(struct perf_event_context *ctx, struct pmu *pmu, enum event_type_t event_type)

kernel/events/core.c

3645

for_each_epc(pmu_ctx, ctx, pmu, event_type)

kernel/events/core.c

3757

cpc = this_cpc(pmu_ctx->pmu);

kernel/events/core.c

3759

if (cpc->sched_cb_usage && pmu_ctx->pmu->sched_task)

kernel/events/core.c

3760

pmu_ctx->pmu->sched_task(pmu_ctx, task, sched_in);

kernel/events/core.c

3863

void perf_sched_cb_dec(struct pmu *pmu)

kernel/events/core.c

3865

struct perf_cpu_pmu_context *cpc = this_cpc(pmu);

kernel/events/core.c

3875

void perf_sched_cb_inc(struct pmu *pmu)

kernel/events/core.c

3877

struct perf_cpu_pmu_context *cpc = this_cpc(pmu);

kernel/events/core.c

3898

struct pmu *pmu;

kernel/events/core.c

3900

pmu = cpc->epc.pmu;

kernel/events/core.c

3903

if (WARN_ON_ONCE(!pmu->sched_task))

kernel/events/core.c

3907

perf_pmu_disable(pmu);

kernel/events/core.c

3909

pmu->sched_task(cpc->task_epc, task, sched_in);

kernel/events/core.c

3911

perf_pmu_enable(pmu);

kernel/events/core.c

3995

cpc = this_cpc(pmu_ctx->pmu);

kernel/events/core.c

4002

struct pmu *pmu,

kernel/events/core.c

4016

if (pmu->filter && pmu->filter(pmu, cpu))

kernel/events/core.c

4040

__heap_add(&event_heap, perf_event_groups_first(groups, -1, pmu, NULL));

kernel/events/core.c

4044

__heap_add(&event_heap, perf_event_groups_first(groups, cpu, pmu, NULL));

kernel/events/core.c

4048

__heap_add(&event_heap, perf_event_groups_first(groups, cpu, pmu, css->cgroup));

kernel/events/core.c

4053

perf_assert_pmu_disabled((*evt)->pmu_ctx->pmu);

kernel/events/core.c

4063

*evt = perf_event_groups_next(*evt, pmu);

kernel/events/core.c

4123

event->pmu_ctx->pmu->capabilities & PERF_PMU_CAP_MEDIATED_VPMU &&

kernel/events/core.c

4144

struct perf_cpu_pmu_context *cpc = this_cpc(event->pmu_ctx->pmu);

kernel/events/core.c

4157

struct pmu *pmu,

kernel/events/core.c

4164

visit_groups_merge(ctx, groups, smp_processor_id(), pmu,

kernel/events/core.c

4174

pmu_groups_sched_in(ctx, &ctx->pinned_groups, pmu_ctx->pmu, event_type);

kernel/events/core.c

4176

pmu_groups_sched_in(ctx, &ctx->flexible_groups, pmu_ctx->pmu, event_type);

kernel/events/core.c

4180

ctx_sched_in(struct perf_event_context *ctx, struct pmu *pmu, enum event_type_t event_type)

kernel/events/core.c

4236

for_each_epc(pmu_ctx, ctx, pmu, event_type)

kernel/events/core.c

4242

for_each_epc(pmu_ctx, ctx, pmu, event_type)

kernel/events/core.c

4428

event->pmu->stop(event, PERF_EF_UPDATE);

kernel/events/core.c

4433

event->pmu->start(event, PERF_EF_RELOAD);

kernel/events/core.c

4463

event->pmu->stop(event, PERF_EF_UPDATE);

kernel/events/core.c

4479

event->pmu->start(event, delta > 0 ? PERF_EF_RELOAD : 0);

kernel/events/core.c

4508

if (pmu_ctx->pmu->capabilities & PERF_PMU_CAP_NO_INTERRUPT)

kernel/events/core.c

4511

perf_pmu_disable(pmu_ctx->pmu);

kernel/events/core.c

4514

perf_pmu_enable(pmu_ctx->pmu);

kernel/events/core.c

4544

.pmu = pmu_ctx->pmu,

kernel/events/core.c

4593

struct pmu *pmu;

kernel/events/core.c

4601

pmu = cpu_epc->pmu;

kernel/events/core.c

4611

perf_pmu_disable(pmu);

kernel/events/core.c

4640

perf_pmu_enable(pmu);

kernel/events/core.c

4790

const struct cpumask *cpumask = perf_scope_cpu_topology_cpumask(event->pmu->scope, event_cpu);

kernel/events/core.c

4816

struct pmu *pmu;

kernel/events/core.c

4844

pmu = event->pmu_ctx->pmu;

kernel/events/core.c

4845

pmu->start_txn(pmu, PERF_PMU_TXN_READ);

kernel/events/core.c

4851

data->ret = pmu->commit_txn(pmu);

kernel/events/core.c

4938

event->pmu->read(event);

kernel/events/core.c

5045

__perf_init_event_pmu_context(struct perf_event_pmu_context *epc, struct pmu *pmu)

kernel/events/core.c

5047

epc->pmu = pmu;

kernel/events/core.c

5167

find_get_pmu_context(struct pmu *pmu, struct perf_event_context *ctx,

kernel/events/core.c

5180

cpc = *per_cpu_ptr(pmu->cpu_pmu_context, event->cpu);

kernel/events/core.c

5203

__perf_init_event_pmu_context(new, pmu);

kernel/events/core.c

5216

if (epc->pmu == pmu) {

kernel/events/core.c

5222

if (!pos && epc->pmu->type > pmu->type)

kernel/events/core.c

5513

struct kmem_cache *ctx_cache = event->pmu->task_ctx_cache;

kernel/events/core.c

5669

struct pmu *pmu = event->pmu;

kernel/events/core.c

5671

if (!is_exclusive_pmu(pmu))

kernel/events/core.c

5688

if (!atomic_inc_unless_negative(&pmu->exclusive_cnt))

kernel/events/core.c

5691

if (!atomic_dec_unless_positive(&pmu->exclusive_cnt))

kernel/events/core.c

5702

struct pmu *pmu = event->pmu;

kernel/events/core.c

5706

atomic_dec(&pmu->exclusive_cnt);

kernel/events/core.c

5708

atomic_inc(&pmu->exclusive_cnt);

kernel/events/core.c

5715

if ((e1->pmu == e2->pmu) &&

kernel/events/core.c

5727

struct pmu *pmu = event->pmu;

kernel/events/core.c

5731

if (!is_exclusive_pmu(pmu))

kernel/events/core.c

5747

struct pmu *pmu = event->pmu;

kernel/events/core.c

5780

WARN_ON_ONCE(!pmu);

kernel/events/core.c

5793

if (pmu) {

kernel/events/core.c

5794

module_put(pmu->module);

kernel/events/core.c

5795

scoped_guard (spinlock, &pmu->events_lock) {

kernel/events/core.c

5797

wake_up_var(pmu);

kernel/events/core.c

6347

if ((event->pmu->capabilities & PERF_PMU_CAP_MEDIATED_VPMU) &&

kernel/events/core.c

6522

perf_pmu_disable(event->pmu);

kernel/events/core.c

6523

event->pmu->stop(event, PERF_EF_UPDATE);

kernel/events/core.c

6529

event->pmu->start(event, PERF_EF_RELOAD);

kernel/events/core.c

6538

perf_pmu_enable(event->pmu);

kernel/events/core.c

6544

return event->pmu->check_period(event, value);

kernel/events/core.c

6791

return event->pmu->event_idx(event);

kernel/events/core.c

6985

({ struct pmu *pmu; \

kernel/events/core.c

6988

pmu = READ_ONCE(event->pmu); \

kernel/events/core.c

6989

if (pmu) \

kernel/events/core.c

6990

f = pmu->func; \

kernel/events/core.c

7933

ret = event->pmu->snapshot_aux(event, handle, size);

kernel/events/core.c

815

!(pmu_ctx->pmu->capabilities & PERF_PMU_CAP_MEDIATED_VPMU))

kernel/events/core.c

824

else if (_pmu && _epc->pmu != _pmu) \

kernel/events/core.c

834

perf_pmu_disable(pmu_ctx->pmu);

kernel/events/core.c

843

perf_pmu_enable(pmu_ctx->pmu);

kernel/events/core.c

846

static void ctx_sched_out(struct perf_event_context *ctx, struct pmu *pmu, enum event_type_t event_type);

kernel/events/core.c

847

static void ctx_sched_in(struct perf_event_context *ctx, struct pmu *pmu, enum event_type_t event_type);

kernel/events/core.c

8749

event->pmu->stop(event, PERF_EF_PAUSE);

kernel/events/core.c

8754

event->pmu->start(event, PERF_EF_RESUME);

kernel/events/hw_breakpoint.c

997

static struct pmu perf_breakpoint = {

kernel/events/ring_buffer.c

682

bool use_contiguous_pages = event->pmu->capabilities & (

kernel/events/ring_buffer.c

736

rb->free_aux = event->pmu->free_aux;

kernel/events/ring_buffer.c

757

if ((event->pmu->capabilities & PERF_PMU_CAP_AUX_NO_SG) &&

kernel/events/ring_buffer.c

765

rb->aux_priv = event->pmu->setup_aux(event, rb->aux_pages, nr_pages,

sound/soc/codecs/cs42l43.c

1498

static int cs42l43_dapm_wait_completion(struct completion *pmu, struct completion *pmd,

sound/soc/codecs/cs42l43.c

1505

reinit_completion(pmu);

sound/soc/codecs/cs42l43.c

1511

time_left = wait_for_completion_timeout(pmu, msecs_to_jiffies(timeout_ms));

tools/perf/arch/arm/util/cs-etm.c

267

static int cs_etm_set_sink_attr(struct perf_pmu *pmu,

tools/perf/arch/arm/util/cs-etm.c

282

ret = perf_pmu__scan_file(pmu, path, "%x", &hash);

tools/perf/arch/arm/util/cs-etm.c

582

static int cs_etm_get_ro(struct perf_pmu *pmu, struct perf_cpu cpu, const char *path, __u64 *val)

tools/perf/arch/arm/util/cs-etm.c

590

scan = perf_pmu__scan_file(pmu, pmu_path, "%llx", val);

tools/perf/arch/arm/util/cs-etm.c

599

static int cs_etm_get_ro_signed(struct perf_pmu *pmu, struct perf_cpu cpu, const char *path,

tools/perf/arch/arm/util/cs-etm.c

609

scan = perf_pmu__scan_file(pmu, pmu_path, "%d", &val);

tools/perf/arch/arm/util/cs-etm.c

619

static bool cs_etm_pmu_path_exists(struct perf_pmu *pmu, struct perf_cpu cpu, const char *path)

tools/perf/arch/arm/util/cs-etm.c

626

return perf_pmu__file_exists(pmu, pmu_path);

tools/perf/arch/arm/util/cs-etm.c

72

static int cs_etm_get_ro(struct perf_pmu *pmu, struct perf_cpu cpu, const char *path, __u64 *val);

tools/perf/arch/arm/util/cs-etm.c

73

static bool cs_etm_pmu_path_exists(struct perf_pmu *pmu, struct perf_cpu cpu, const char *path);

tools/perf/arch/arm/util/cs-etm.c

919

cs_etm_get_default_config(const struct perf_pmu *pmu __maybe_unused,

tools/perf/arch/arm/util/pmu.c

19

void perf_pmu__arch_init(struct perf_pmu *pmu)

tools/perf/arch/arm/util/pmu.c

23

if (!strcmp(pmu->name, CORESIGHT_ETM_PMU_NAME)) {

tools/perf/arch/arm/util/pmu.c

25

pmu->auxtrace = true;

tools/perf/arch/arm/util/pmu.c

26

pmu->selectable = true;

tools/perf/arch/arm/util/pmu.c

27

pmu->perf_event_attr_init_default = cs_etm_get_default_config;

tools/perf/arch/arm/util/pmu.c

29

} else if (strstarts(pmu->name, ARM_SPE_PMU_NAME)) {

tools/perf/arch/arm/util/pmu.c

30

pmu->auxtrace = true;

tools/perf/arch/arm/util/pmu.c

31

pmu->selectable = true;

tools/perf/arch/arm/util/pmu.c

32

pmu->is_uncore = false;

tools/perf/arch/arm/util/pmu.c

33

pmu->perf_event_attr_init_default = arm_spe_pmu_default_config;

tools/perf/arch/arm/util/pmu.c

34

if (strstarts(pmu->name, "arm_spe_"))

tools/perf/arch/arm/util/pmu.c

35

pmu->mem_events = perf_mem_events_arm;

tools/perf/arch/arm/util/pmu.c

36

} else if (strstarts(pmu->name, HISI_PTT_PMU_NAME)) {

tools/perf/arch/arm/util/pmu.c

37

pmu->auxtrace = true;

tools/perf/arch/arm/util/pmu.c

38

pmu->selectable = true;

tools/perf/arch/arm/util/pmu.c

42

intersect = perf_cpu_map__intersect(online, pmu->cpus);

tools/perf/arch/arm/util/pmu.c

44

perf_cpu_map__put(pmu->cpus);

tools/perf/arch/arm/util/pmu.c

45

pmu->cpus = intersect;

tools/perf/arch/arm64/util/arm-spe.c

102

struct perf_pmu *pmu = NULL;

tools/perf/arch/arm64/util/arm-spe.c

119

pmu = sper->arm_spe_pmu;

tools/perf/arch/arm64/util/arm-spe.c

121

if (!pmu) {

tools/perf/arch/arm64/util/arm-spe.c

127

data[ARM_SPE_CPU_PMU_TYPE] = pmu->type;

tools/perf/arch/arm64/util/arm-spe.c

129

if (perf_pmu__scan_file(pmu, "caps/min_interval", "%lu", &val) != 1)

tools/perf/arch/arm64/util/arm-spe.c

133

if (perf_pmu__scan_file(pmu, "caps/event_filter", "%lx", &val) != 1)

tools/perf/arch/arm64/util/arm-spe.c

262

evsel->core.attr.sample_period = arm_spe_pmu__sample_period(evsel->pmu);

tools/perf/arch/arm64/util/arm-spe.c

407

if (!strstarts(evsel->pmu->name, ARM_SPE_PMU_NAME)) {

tools/perf/arch/arm64/util/arm-spe.c

409

evsel->pmu->name);

tools/perf/arch/arm64/util/arm-spe.c

418

evsel->pmu->name);

tools/perf/arch/arm64/util/pmu.c

12

struct perf_pmu *pmu = perf_pmus__find_core_pmu();

tools/perf/arch/arm64/util/pmu.c

14

if (pmu) {

tools/perf/arch/arm64/util/pmu.c

16

pmu->name, "caps/slots");

tools/perf/arch/powerpc/util/pmu.c

10

if (pmu->is_core)

tools/perf/arch/powerpc/util/pmu.c

11

pmu->mem_events = perf_mem_events_power;

tools/perf/arch/powerpc/util/pmu.c

8

void perf_pmu__arch_init(struct perf_pmu *pmu)

tools/perf/arch/s390/util/pmu.c

16

void perf_pmu__arch_init(struct perf_pmu *pmu)

tools/perf/arch/s390/util/pmu.c

18

if (!strcmp(pmu->name, S390_PMUPAI_CRYPTO) ||

tools/perf/arch/s390/util/pmu.c

19

!strcmp(pmu->name, S390_PMUPAI_EXT) ||

tools/perf/arch/s390/util/pmu.c

20

!strcmp(pmu->name, S390_PMUCPUM_CF))

tools/perf/arch/s390/util/pmu.c

21

pmu->selectable = true;

tools/perf/arch/x86/tests/hybrid.c

117

struct perf_pmu *pmu = perf_pmus__find_by_type(evsel->attr.type);

tools/perf/arch/x86/tests/hybrid.c

119

TEST_ASSERT_VAL("missing pmu", pmu);

tools/perf/arch/x86/tests/hybrid.c

120

TEST_ASSERT_VAL("unexpected pmu", !strncmp(pmu->name, "cpu_", 4));

tools/perf/arch/x86/tests/topdown.c

23

snprintf(buf, sizeof(buf), "%s/%s/", info->pmu->name, info->name);

tools/perf/arch/x86/tests/topdown.c

32

bool p_core_pmu = evsel->pmu->type == PERF_TYPE_RAW;

tools/perf/arch/x86/tests/topdown.c

66

struct perf_pmu *pmu = NULL;

tools/perf/arch/x86/tests/topdown.c

71

while ((pmu = perf_pmus__scan_core(pmu)) != NULL) {

tools/perf/arch/x86/tests/topdown.c

72

if (perf_pmu__for_each_event(pmu, /*skip_duplicate_pmus=*/false, &ret, event_cb))

tools/perf/arch/x86/util/evsel.c

163

struct perf_pmu *pmu;

tools/perf/arch/x86/util/evsel.c

168

pmu = evsel__find_pmu(evsel);

tools/perf/arch/x86/util/evsel.c

169

if (!pmu || strncmp(pmu->name, "ibs", 3))

tools/perf/arch/x86/util/evsel.c

30

struct perf_pmu *pmu;

tools/perf/arch/x86/util/evsel.c

43

pmu = evsel__find_pmu(evsel);

tools/perf/arch/x86/util/evsel.c

44

return pmu && pmu->type == PERF_TYPE_RAW;

tools/perf/arch/x86/util/evsel.c

58

u64 pmu = evsel->core.attr.config >> PERF_PMU_TYPE_SHIFT;

tools/perf/arch/x86/util/evsel.c

67

if (!pmu)

tools/perf/arch/x86/util/evsel.c

71

evsel->pmu ? evsel->pmu->name : "cpu",

tools/perf/arch/x86/util/evsel.c

84

if (!perf_pmu__has_format(evsel->pmu, name)) {

tools/perf/arch/x86/util/evsel.c

85

pr_err("'%s' does not have acr_mask format support\n", evsel->pmu->name);

tools/perf/arch/x86/util/evsel.c

88

if (perf_pmu__format_type(evsel->pmu, name) !=

tools/perf/arch/x86/util/evsel.c

90

pr_err("'%s' does not have config2 format support\n", evsel->pmu->name);

tools/perf/arch/x86/util/intel-pt.c

66

static int intel_pt_parse_terms_with_default(const struct perf_pmu *pmu,

tools/perf/arch/x86/util/intel-pt.c

80

err = perf_pmu__config_terms(pmu, &attr, &terms, /*zero=*/true, /*apply_hardcoded=*/false,

tools/perf/arch/x86/util/intel-pt.c

91

static int intel_pt_parse_terms(const struct perf_pmu *pmu, const char *str, u64 *config)

tools/perf/arch/x86/util/intel-pt.c

94

return intel_pt_parse_terms_with_default(pmu, str, config);

tools/perf/arch/x86/util/pmu.c

107

static int uncore_cha_snc(struct perf_pmu *pmu)

tools/perf/arch/x86/util/pmu.c

124

if (sscanf(pmu->name, "uncore_cha_%u", &cha_num) != 1) {

tools/perf/arch/x86/util/pmu.c

125

pr_warning("Unexpected: unable to compute CHA number '%s'\n", pmu->name);

tools/perf/arch/x86/util/pmu.c

135

static int uncore_imc_snc(struct perf_pmu *pmu)

tools/perf/arch/x86/util/pmu.c

160

if (sscanf(pmu->name, "uncore_imc_%u", &imc_num) != 1) {

tools/perf/arch/x86/util/pmu.c

161

pr_warning("Unexpected: unable to compute IMC number '%s'\n", pmu->name);

tools/perf/arch/x86/util/pmu.c

208

static void gnr_uncore_cha_imc_adjust_cpumask_for_snc(struct perf_pmu *pmu, bool cha)

tools/perf/arch/x86/util/pmu.c

233

if (perf_cpu_map__cpu(pmu->cpus, 0).cpu != 0) {

tools/perf/arch/x86/util/pmu.c

234

pr_debug("Ignoring cpumask adjust for %s as unexpected first CPU\n", pmu->name);

tools/perf/arch/x86/util/pmu.c

238

pmu_snc = cha ? uncore_cha_snc(pmu) : uncore_imc_snc(pmu);

tools/perf/arch/x86/util/pmu.c

248

adjusted[pmu_snc] = perf_cpu_map__empty_new(perf_cpu_map__nr(pmu->cpus));

tools/perf/arch/x86/util/pmu.c

253

perf_cpu_map__for_each_cpu(cpu, idx, pmu->cpus) {

tools/perf/arch/x86/util/pmu.c

268

perf_cpu_map__put(pmu->cpus);

tools/perf/arch/x86/util/pmu.c

269

pmu->cpus = perf_cpu_map__get(adjusted[pmu_snc]);

tools/perf/arch/x86/util/pmu.c

272

void perf_pmu__arch_init(struct perf_pmu *pmu)

tools/perf/arch/x86/util/pmu.c

276

if (!strcmp(pmu->name, INTEL_PT_PMU_NAME)) {

tools/perf/arch/x86/util/pmu.c

277

pmu->auxtrace = true;

tools/perf/arch/x86/util/pmu.c

278

pmu->selectable = true;

tools/perf/arch/x86/util/pmu.c

279

pmu->perf_event_attr_init_default = intel_pt_pmu_default_config;

tools/perf/arch/x86/util/pmu.c

281

if (!strcmp(pmu->name, INTEL_BTS_PMU_NAME)) {

tools/perf/arch/x86/util/pmu.c

282

pmu->auxtrace = true;

tools/perf/arch/x86/util/pmu.c

283

pmu->selectable = true;

tools/perf/arch/x86/util/pmu.c

287

if (strcmp(pmu->name, "ibs_op"))

tools/perf/arch/x86/util/pmu.c

290

pmu->mem_events = perf_mem_events_amd;

tools/perf/arch/x86/util/pmu.c

292

if (!perf_pmu__caps_parse(pmu))

tools/perf/arch/x86/util/pmu.c

295

ldlat_cap = perf_pmu__get_cap(pmu, "ldlat");

tools/perf/arch/x86/util/pmu.c

300

pmu->mem_events = perf_mem_events_amd_ldlat;

tools/perf/arch/x86/util/pmu.c

302

if (pmu->is_core) {

tools/perf/arch/x86/util/pmu.c

303

if (perf_pmu__have_event(pmu, "mem-loads-aux"))

tools/perf/arch/x86/util/pmu.c

304

pmu->mem_events = perf_mem_events_intel_aux;

tools/perf/arch/x86/util/pmu.c

306

pmu->mem_events = perf_mem_events_intel;

tools/perf/arch/x86/util/pmu.c

308

if (starts_with(pmu->name, "uncore_cha_"))

tools/perf/arch/x86/util/pmu.c

309

gnr_uncore_cha_imc_adjust_cpumask_for_snc(pmu, /*cha=*/true);

tools/perf/arch/x86/util/pmu.c

310

else if (starts_with(pmu->name, "uncore_imc_"))

tools/perf/arch/x86/util/pmu.c

311

gnr_uncore_cha_imc_adjust_cpumask_for_snc(pmu, /*cha=*/false);

tools/perf/arch/x86/util/topdown.c

18

struct perf_pmu *pmu;

tools/perf/arch/x86/util/topdown.c

29

pmu = perf_pmus__find_by_type(PERF_TYPE_RAW);

tools/perf/arch/x86/util/topdown.c

30

if (pmu && perf_pmu__have_event(pmu, "slots"))

tools/perf/arch/x86/util/topdown.c

98

evsel->pmu = metric_event->pmu;

tools/perf/bench/pmu-scan.c

100

nr = perf_pmu__num_events(pmu);

tools/perf/bench/pmu-scan.c

103

pmu->name, r->nr_aliases, nr);

tools/perf/bench/pmu-scan.c

108

list_for_each(list, &pmu->format)

tools/perf/bench/pmu-scan.c

112

pmu->name, r->nr_formats, nr);

tools/perf/bench/pmu-scan.c

45

struct perf_pmu *pmu = NULL;

tools/perf/bench/pmu-scan.c

49

while ((pmu = perf_pmus__scan(pmu)) != NULL) {

tools/perf/bench/pmu-scan.c

57

r->name = strdup(pmu->name);

tools/perf/bench/pmu-scan.c

58

r->is_core = pmu->is_core;

tools/perf/bench/pmu-scan.c

59

r->nr_caps = pmu->nr_caps;

tools/perf/bench/pmu-scan.c

61

r->nr_aliases = perf_pmu__num_events(pmu);

tools/perf/bench/pmu-scan.c

64

list_for_each(list, &pmu->format)

tools/perf/bench/pmu-scan.c

79

struct perf_pmu *pmu;

tools/perf/bench/pmu-scan.c

88

pmu = perf_pmus__find(r->name);

tools/perf/bench/pmu-scan.c

89

if (pmu == NULL) {

tools/perf/bench/pmu-scan.c

94

if (pmu->nr_caps != (u32)r->nr_caps) {

tools/perf/bench/pmu-scan.c

96

pmu->name, r->nr_caps, pmu->nr_caps);

tools/perf/builtin-c2c.c

3361

struct perf_pmu *pmu;

tools/perf/builtin-c2c.c

3363

pmu = perf_mem_events_find_pmu();

tools/perf/builtin-c2c.c

3364

if (!pmu) {

tools/perf/builtin-c2c.c

3370

perf_pmu__mem_events_list(pmu);

tools/perf/builtin-c2c.c

3373

if (perf_pmu__mem_events_parse(pmu, str))

tools/perf/builtin-c2c.c

3398

struct perf_pmu *pmu;

tools/perf/builtin-c2c.c

3410

pmu = perf_mem_events_find_pmu();

tools/perf/builtin-c2c.c

3411

if (!pmu) {

tools/perf/builtin-c2c.c

3425

rec_argc = argc + 11 * (perf_pmu__mem_events_num_mem_pmus(pmu) + 1);

tools/perf/builtin-c2c.c

3434

e = perf_pmu__mem_events_ptr(pmu, PERF_MEM_EVENTS__LOAD_STORE);

tools/perf/builtin-list.c

629

const struct perf_pmu *pmu = perf_pmus__pmu_for_pmu_filter(cputype);

tools/perf/builtin-list.c

631

if (!pmu) {

tools/perf/builtin-list.c

636

ps->pmu_glob = strdup(pmu->name);

tools/perf/builtin-mem.c

103

rec_argc = argc + 9 * (perf_pmu__mem_events_num_mem_pmus(pmu) + 1);

tools/perf/builtin-mem.c

114

e = perf_pmu__mem_events_ptr(pmu, PERF_MEM_EVENTS__LOAD_STORE);

tools/perf/builtin-mem.c

53

struct perf_pmu *pmu;

tools/perf/builtin-mem.c

55

pmu = perf_mem_events_find_pmu();

tools/perf/builtin-mem.c

56

if (!pmu) {

tools/perf/builtin-mem.c

62

perf_pmu__mem_events_list(pmu);

tools/perf/builtin-mem.c

65

if (perf_pmu__mem_events_parse(pmu, str))

tools/perf/builtin-mem.c

81

struct perf_pmu *pmu;

tools/perf/builtin-mem.c

88

pmu = perf_mem_events_find_pmu();

tools/perf/builtin-mem.c

89

if (!pmu) {

tools/perf/builtin-script.c

402

struct perf_pmu *pmu = evsel__find_pmu(evsel);

tools/perf/builtin-script.c

404

if (pmu && pmu->is_core)

tools/perf/builtin-stat.c

1199

const struct perf_pmu *pmu;

tools/perf/builtin-stat.c

1207

pmu = perf_pmus__pmu_for_pmu_filter(str);

tools/perf/builtin-stat.c

1208

if (!pmu) {

tools/perf/builtin-stat.c

1212

parse_events_option_args.pmu_filter = pmu->name;

tools/perf/builtin-stat.c

1934

if (lhs->pmu != rhs->pmu)

tools/perf/builtin-stat.c

1935

return lhs->pmu->type - rhs->pmu->type;

tools/perf/builtin-stat.c

1947

const char *pmu = parse_events_option_args.pmu_filter ?: "all";

tools/perf/builtin-stat.c

1968

if (!metricgroup__has_metric_or_groups(pmu, "transaction")) {

tools/perf/builtin-stat.c

1973

ret = metricgroup__parse_groups(evlist, pmu, "transaction",

tools/perf/builtin-stat.c

2001

if (!metricgroup__has_metric_or_groups(pmu, "smi")) {

tools/perf/builtin-stat.c

2010

ret = metricgroup__parse_groups(evlist, pmu, "smi",

tools/perf/builtin-stat.c

2047

pmu, str,

tools/perf/builtin-stat.c

2075

if (!metricgroup__has_metric_or_groups(pmu, default_metricgroup_names[i]))

tools/perf/builtin-stat.c

2086

if (metricgroup__parse_groups(metric_evlist, pmu, default_metricgroup_names[i],

tools/perf/builtin-stat.c

2814

const char *pmu = parse_events_option_args.pmu_filter ?: "all";

tools/perf/builtin-stat.c

2815

int ret = metricgroup__parse_groups(evsel_list, pmu, metrics,

tools/perf/pmu-events/empty-pmu-events.c

2918

const struct pmu_table_entry *pmu,

tools/perf/pmu-events/empty-pmu-events.c

2924

.pmu = &big_c_string[pmu->pmu_name.offset],

tools/perf/pmu-events/empty-pmu-events.c

2927

for (uint32_t i = 0; i < pmu->num_entries; i++) {

tools/perf/pmu-events/empty-pmu-events.c

2928

decompress_event(pmu->entries[i].offset, &pe);

tools/perf/pmu-events/empty-pmu-events.c

2939

const struct pmu_table_entry *pmu,

tools/perf/pmu-events/empty-pmu-events.c

2945

.pmu = &big_c_string[pmu->pmu_name.offset],

tools/perf/pmu-events/empty-pmu-events.c

2947

int low = 0, high = pmu->num_entries - 1;

tools/perf/pmu-events/empty-pmu-events.c

2952

decompress_event(pmu->entries[mid].offset, &pe);

tools/perf/pmu-events/empty-pmu-events.c

2982

struct perf_pmu *pmu,

tools/perf/pmu-events/empty-pmu-events.c

2993

if (pmu && !perf_pmu__name_wildcard_match(pmu, pmu_name))

tools/perf/pmu-events/empty-pmu-events.c

3004

struct perf_pmu *pmu,

tools/perf/pmu-events/empty-pmu-events.c

3016

if (pmu && !perf_pmu__name_wildcard_match(pmu, pmu_name))

tools/perf/pmu-events/empty-pmu-events.c

3027

struct perf_pmu *pmu)

tools/perf/pmu-events/empty-pmu-events.c

3037

if (perf_pmu__name_wildcard_match(pmu, pmu_name))

tools/perf/pmu-events/empty-pmu-events.c

3044

const struct pmu_table_entry *pmu,

tools/perf/pmu-events/empty-pmu-events.c

3050

.pmu = &big_c_string[pmu->pmu_name.offset],

tools/perf/pmu-events/empty-pmu-events.c

3053

for (uint32_t i = 0; i < pmu->num_entries; i++) {

tools/perf/pmu-events/empty-pmu-events.c

3054

decompress_metric(pmu->entries[i].offset, &pm);

tools/perf/pmu-events/empty-pmu-events.c

3065

const struct pmu_table_entry *pmu,

tools/perf/pmu-events/empty-pmu-events.c

3071

.pmu = &big_c_string[pmu->pmu_name.offset],

tools/perf/pmu-events/empty-pmu-events.c

3073

int low = 0, high = pmu->num_entries - 1;

tools/perf/pmu-events/empty-pmu-events.c

3078

decompress_metric(pmu->entries[mid].offset, &pm);

tools/perf/pmu-events/empty-pmu-events.c

3124

struct perf_pmu *pmu,

tools/perf/pmu-events/empty-pmu-events.c

3136

if (pmu && !perf_pmu__name_wildcard_match(pmu, pmu_name))

tools/perf/pmu-events/empty-pmu-events.c

3201

static const struct pmu_events_map *map_for_pmu(struct perf_pmu *pmu)

tools/perf/pmu-events/empty-pmu-events.c

3205

if (pmu) {

tools/perf/pmu-events/empty-pmu-events.c

3209

if (!strcmp(pmu_name, pmu->name)) {

tools/perf/pmu-events/empty-pmu-events.c

3217

cpu = perf_cpu_map__min(pmu->cpus);

tools/perf/pmu-events/empty-pmu-events.c

3222

const struct pmu_events_table *perf_pmu__find_events_table(struct perf_pmu *pmu)

tools/perf/pmu-events/empty-pmu-events.c

3224

const struct pmu_events_map *map = map_for_pmu(pmu);

tools/perf/pmu-events/empty-pmu-events.c

3229

if (!pmu)

tools/perf/pmu-events/empty-pmu-events.c

3236

if (perf_pmu__name_wildcard_match(pmu, pmu_name))

tools/perf/pmu-events/pmu-events.h

106

struct perf_pmu *pmu,

tools/perf/pmu-events/pmu-events.h

111

struct perf_pmu *pmu);

tools/perf/pmu-events/pmu-events.h

123

struct perf_pmu *pmu,

tools/perf/pmu-events/pmu-events.h

128

const struct pmu_events_table *perf_pmu__find_events_table(struct perf_pmu *pmu);

tools/perf/pmu-events/pmu-events.h

54

const char *pmu;

tools/perf/pmu-events/pmu-events.h

64

const char *pmu;

tools/perf/pmu-events/pmu-events.h

95

struct perf_pmu *pmu,

tools/perf/tests/event_groups.c

54

struct perf_pmu *pmu = NULL;

tools/perf/tests/event_groups.c

57

while ((pmu = perf_pmus__scan(pmu)) != NULL) {

tools/perf/tests/event_groups.c

59

if (!strcmp(uncore_pmus[i].name, pmu->name)) {

tools/perf/tests/event_groups.c

60

pr_debug("Using %s for uncore pmu event\n", pmu->name);

tools/perf/tests/event_groups.c

61

types[2] = pmu->type;

tools/perf/tests/hwmon_pmu.c

190

if (!evsel->pmu || !evsel->pmu->name ||

tools/perf/tests/hwmon_pmu.c

191

strcmp(evsel->pmu->name, "hwmon_a_test_hwmon_pmu"))

tools/perf/tests/hwmon_pmu.c

220

struct perf_pmu *pmu = test_pmu_get(dir, sizeof(dir));

tools/perf/tests/hwmon_pmu.c

223

if (!pmu)

tools/perf/tests/hwmon_pmu.c

237

test_pmu_put(dir, pmu);

tools/perf/tests/mmap-basic.c

184

static enum user_read_state set_user_read(struct perf_pmu *pmu, enum user_read_state enabled)

tools/perf/tests/mmap-basic.c

198

rdpmc_fd = perf_pmu__pathname_fd(events_fd, pmu->name, "rdpmc", O_RDWR);

tools/perf/tests/mmap-basic.c

225

struct perf_pmu *pmu = NULL;

tools/perf/tests/mmap-basic.c

236

while ((pmu = perf_pmus__scan_core(pmu)) != NULL) {

tools/perf/tests/mmap-basic.c

237

enum user_read_state saved_user_read_state = set_user_read(pmu, enabled);

tools/perf/tests/mmap-basic.c

241

? event | ((u64)pmu->type << PERF_PMU_TYPE_SHIFT)

tools/perf/tests/mmap-basic.c

254

pr_debug("User space counter reading for PMU %s\n", pmu->name);

tools/perf/tests/mmap-basic.c

261

if (pmu->cpus != NULL)

tools/perf/tests/mmap-basic.c

262

cpu_map__set_affinity(pmu->cpus);

tools/perf/tests/mmap-basic.c

268

pmu->name);

tools/perf/tests/mmap-basic.c

276

pmu->name);

tools/perf/tests/mmap-basic.c

284

pmu->name);

tools/perf/tests/mmap-basic.c

293

pmu->name);

tools/perf/tests/mmap-basic.c

305

pmu->name, pc->cap_user_rdpmc, pc->index);

tools/perf/tests/mmap-basic.c

312

pmu->name, pc->cap_user_rdpmc);

tools/perf/tests/mmap-basic.c

319

pmu->name, pc->pmc_width);

tools/perf/tests/mmap-basic.c

326

pr_err("User space counter reading for PMU %s [Failed read]\n", pmu->name);

tools/perf/tests/mmap-basic.c

347

pmu->name, end, start, last);

tools/perf/tests/mmap-basic.c

354

pr_debug("User space counter reading for PMU %s [Success]\n", pmu->name);

tools/perf/tests/mmap-basic.c

363

if (pmu->cpus != NULL) {

tools/perf/tests/mmap-basic.c

369

set_user_read(pmu, saved_user_read_state);

tools/perf/tests/parse-events.c

150

struct perf_pmu *pmu __maybe_unused = NULL;

tools/perf/tests/parse-events.c

166

while ((pmu = perf_pmus__scan(pmu)) != NULL) {

tools/perf/tests/parse-events.c

167

if (pmu->type == evsel->core.attr.type) {

tools/perf/tests/parse-events.c

170

if (pmu->type == PERF_TYPE_RAW)

tools/perf/tests/parse-events.c

1763

struct perf_pmu *pmu = perf_pmus__find_core_pmu();

tools/perf/tests/parse-events.c

1765

if (!pmu)

tools/perf/tests/parse-events.c

1768

return perf_pmu__has_format(pmu, "event");

tools/perf/tests/parse-events.c

1787

struct perf_pmu *pmu = NULL;

tools/perf/tests/parse-events.c

1789

while ((pmu = perf_pmus__scan_core(pmu)) != NULL) {

tools/perf/tests/parse-events.c

1790

if (perf_pmu__has_format(pmu, "acr_mask"))

tools/perf/tests/parse-events.c

1804

if (!perf_pmu__has_format(evsel->pmu, "acr_mask"))

tools/perf/tests/parse-events.c

2686

struct perf_pmu *pmu = NULL;

tools/perf/tests/parse-events.c

2689

while ((pmu = perf_pmus__scan(pmu)) != NULL) {

tools/perf/tests/parse-events.c

2702

sysfs__mountpoint(), pmu->name);

tools/perf/tests/parse-events.c

2706

pr_debug("skipping PMU %s events tests: %s\n", pmu->name, path);

tools/perf/tests/parse-events.c

2760

snprintf(name, sizeof(name), "%s/event=%s/u", pmu->name, ent->d_name);

tools/perf/tests/parse-events.c

2771

if (!is_pmu_core(pmu->name))

tools/perf/tests/parse-events.c

2788

ent->d_name, pmu->name, ent->d_name);

tools/perf/tests/parse-events.c

68

if (!evsel->pmu->is_core)

tools/perf/tests/parse-events.c

70

if (core_pmu != evsel->pmu && core_pmu != NULL)

tools/perf/tests/parse-events.c

72

core_pmu = evsel->pmu;

tools/perf/tests/parse-events.c

768

!strncmp(evsel__name(evsel), evsel->pmu->name,

tools/perf/tests/parse-events.c

769

strlen(evsel->pmu->name)),

tools/perf/tests/pmu-events.c

121

.pmu = "hisi_sccl,ddrc",

tools/perf/tests/pmu-events.c

132

.pmu = "uncore_cbox",

tools/perf/tests/pmu-events.c

143

.pmu = "uncore_cbox",

tools/perf/tests/pmu-events.c

154

.pmu = "uncore_cbox",

tools/perf/tests/pmu-events.c

165

.pmu = "hisi_sccl,l3c",

tools/perf/tests/pmu-events.c

176

.pmu = "uncore_imc_free_running",

tools/perf/tests/pmu-events.c

187

.pmu = "uncore_imc",

tools/perf/tests/pmu-events.c

209

.pmu = "uncore_sys_ddr_pmu",

tools/perf/tests/pmu-events.c

221

.pmu = "uncore_sys_ccn_pmu",

tools/perf/tests/pmu-events.c

233

.pmu = "uncore_sys_cmn_pmu",

tools/perf/tests/pmu-events.c

298

if (!is_same(e1->pmu, e2->pmu)) {

tools/perf/tests/pmu-events.c

300

e1->name, e1->pmu, e2->pmu);

tools/perf/tests/pmu-events.c

369

if (!is_same(alias->pmu_name, test_event->event.pmu) &&

tools/perf/tests/pmu-events.c

372

pmu_name, alias->pmu_name, test_event->event.pmu);

tools/perf/tests/pmu-events.c

387

if (strcmp(pe->pmu, "default_core"))

tools/perf/tests/pmu-events.c

45

.pmu = "default_core",

tools/perf/tests/pmu-events.c

491

if (compare_alias_to_test_event(alias, args->test_event, alias->pmu->name))

tools/perf/tests/pmu-events.c

503

struct perf_pmu *pmu;

tools/perf/tests/pmu-events.c

512

pmu = zalloc(sizeof(*pmu));

tools/perf/tests/pmu-events.c

513

if (!pmu)

tools/perf/tests/pmu-events.c

516

if (perf_pmu__init(pmu, PERF_PMU_TYPE_FAKE, pmu_name) != 0) {

tools/perf/tests/pmu-events.c

517

perf_pmu__delete(pmu);

tools/perf/tests/pmu-events.c

520

pmu->is_core = true;

tools/perf/tests/pmu-events.c

522

pmu->events_table = table;

tools/perf/tests/pmu-events.c

523

pmu_add_cpu_aliases_table(pmu, table);

tools/perf/tests/pmu-events.c

524

pmu->cpu_aliases_added = true;

tools/perf/tests/pmu-events.c

525

pmu->sysfs_aliases_loaded = true;

tools/perf/tests/pmu-events.c

527

res = pmu_events_table__find_event(table, pmu, "bp_l1_btb_correct", NULL, NULL);

tools/perf/tests/pmu-events.c

541

test_event.event.pmu = pmu_name;

tools/perf/tests/pmu-events.c

542

err = perf_pmu__find_event(pmu, event->name, &args,

tools/perf/tests/pmu-events.c

547

perf_pmu__delete(pmu);

tools/perf/tests/pmu-events.c

55

.pmu = "default_core",

tools/perf/tests/pmu-events.c

556

struct perf_pmu *pmu;

tools/perf/tests/pmu-events.c

564

pmu = zalloc(sizeof(*pmu));

tools/perf/tests/pmu-events.c

565

if (!pmu)

tools/perf/tests/pmu-events.c

568

if (perf_pmu__init(pmu, PERF_PMU_TYPE_FAKE, test_pmu->pmu_name) != 0) {

tools/perf/tests/pmu-events.c

569

perf_pmu__delete(pmu);

tools/perf/tests/pmu-events.c

572

pmu->is_uncore = test_pmu->pmu_is_uncore;

tools/perf/tests/pmu-events.c

574

pmu->id = strdup(test_pmu->pmu_id);

tools/perf/tests/pmu-events.c

575

if (!pmu->id) {

tools/perf/tests/pmu-events.c

576

perf_pmu__delete(pmu);

tools/perf/tests/pmu-events.c

580

pmu->events_table = events_table;

tools/perf/tests/pmu-events.c

581

pmu_add_cpu_aliases_table(pmu, events_table);

tools/perf/tests/pmu-events.c

582

pmu->cpu_aliases_added = true;

tools/perf/tests/pmu-events.c

583

pmu->sysfs_aliases_loaded = true;

tools/perf/tests/pmu-events.c

584

pmu_add_sys_aliases(pmu);

tools/perf/tests/pmu-events.c

587

alias_count = perf_pmu__num_events(pmu);

tools/perf/tests/pmu-events.c

595

pmu->name, to_match_count, alias_count);

tools/perf/tests/pmu-events.c

596

perf_pmu__delete(pmu);

tools/perf/tests/pmu-events.c

609

if (strcmp(pmu->name, test_event.matching_pmu)) {

tools/perf/tests/pmu-events.c

611

pmu->name, test_event.matching_pmu, pmu->name);

tools/perf/tests/pmu-events.c

612

perf_pmu__delete(pmu);

tools/perf/tests/pmu-events.c

616

err = perf_pmu__find_event(pmu, event->name, &args,

tools/perf/tests/pmu-events.c

621

pmu->name, event->name);

tools/perf/tests/pmu-events.c

622

perf_pmu__delete(pmu);

tools/perf/tests/pmu-events.c

629

pmu->name, matched_count, alias_count);

tools/perf/tests/pmu-events.c

632

perf_pmu__delete(pmu);

tools/perf/tests/pmu-events.c

65

.pmu = "default_core",

tools/perf/tests/pmu-events.c

728

struct perf_pmu *pmu = NULL;

tools/perf/tests/pmu-events.c

731

while ((pmu = perf_pmus__scan_core(pmu)) != NULL) {

tools/perf/tests/pmu-events.c

734

if (list_empty(&pmu->format)) {

tools/perf/tests/pmu-events.c

735

pr_debug2("skipping testing core PMU %s\n", pmu->name);

tools/perf/tests/pmu-events.c

739

if (__test_core_pmu_event_aliases(pmu->name, &count)) {

tools/perf/tests/pmu-events.c

740

pr_debug("testing core PMU %s aliases: failed\n", pmu->name);

tools/perf/tests/pmu-events.c

746

pmu->name);

tools/perf/tests/pmu-events.c

75

.pmu = "default_core",

tools/perf/tests/pmu-events.c

750

pr_debug("testing core PMU %s aliases: pass\n", pmu->name);

tools/perf/tests/pmu-events.c

85

.pmu = "default_core",

tools/perf/tests/pmu-events.c

95

.pmu = "default_core",

tools/perf/tests/pmu.c

146

pmu = perf_pmus__add_test_pmu(dirfd, "perf-pmu-test");

tools/perf/tests/pmu.c

147

if (!pmu)

tools/perf/tests/pmu.c

151

if (!pmu)

tools/perf/tests/pmu.c

152

test_pmu_put(dir, pmu);

tools/perf/tests/pmu.c

155

return pmu;

tools/perf/tests/pmu.c

164

struct perf_pmu *pmu = test_pmu_get(dir, sizeof(dir));

tools/perf/tests/pmu.c

166

if (!pmu)

tools/perf/tests/pmu.c

178

ret = perf_pmu__config_terms(pmu, &attr, &terms, /*zero=*/false,

tools/perf/tests/pmu.c

200

test_pmu_put(dir, pmu);

tools/perf/tests/pmu.c

212

struct perf_pmu *pmu;

tools/perf/tests/pmu.c

218

pmu = test_pmu_get(dir, sizeof(dir));

tools/perf/tests/pmu.c

219

if (!pmu)

tools/perf/tests/pmu.c

22

static int test_pmu_put(const char *dir, struct perf_pmu *pmu)

tools/perf/tests/pmu.c

291

test_pmu_put(dir, pmu);

tools/perf/tests/pmu.c

303

struct perf_pmu *pmu = test_pmu_get(dir, sizeof(dir));

tools/perf/tests/pmu.c

307

if (!pmu)

tools/perf/tests/pmu.c

343

test_pmu_put(dir, pmu);

tools/perf/tests/pmu.c

35

list_del(&pmu->list);

tools/perf/tests/pmu.c

36

perf_pmu__delete(pmu);

tools/perf/tests/pmu.c

67

struct perf_pmu *pmu = NULL;

tools/perf/tests/tests.h

113

DECLARE_SUITE(pmu);

tools/perf/tests/tool_pmu.c

51

if (perf_pmu__is_tool(evsel->pmu)) {

tools/perf/util/auxtrace.c

2879

struct perf_pmu *pmu = evsel__find_pmu(evsel);

tools/perf/util/auxtrace.c

2882

if (!pmu)

tools/perf/util/auxtrace.c

2885

perf_pmu__scan_file(pmu, "nr_addr_filters", "%d", &nr_addr_filters);

tools/perf/util/cputopo.c

438

struct perf_pmu *pmu)

tools/perf/util/cputopo.c

444

node->pmu_name = strdup(pmu->name);

tools/perf/util/cputopo.c

448

fp = perf_pmu__open_file(pmu, "cpus");

tools/perf/util/cputopo.c

473

struct perf_pmu *pmu = NULL;

tools/perf/util/cputopo.c

485

while ((pmu = perf_pmus__scan_core(pmu)) != NULL) {

tools/perf/util/cputopo.c

486

if (load_hybrid_node(&tp->nodes[i], pmu)) {

tools/perf/util/cs-etm.h

250

void cs_etm_get_default_config(const struct perf_pmu *pmu, struct perf_event_attr *attr);

tools/perf/util/drm_pmu.c

118

if (perf_pmu__init(&drm->pmu, type, name) != 0) {

tools/perf/util/drm_pmu.c

119

perf_pmu__delete(&drm->pmu);

tools/perf/util/drm_pmu.c

123

drm->pmu.cpus = perf_cpu_map__new_int(0);

tools/perf/util/drm_pmu.c

124

if (!drm->pmu.cpus) {

tools/perf/util/drm_pmu.c

125

perf_pmu__delete(&drm->pmu);

tools/perf/util/drm_pmu.c

245

list_add_tail(&drm->pmu.list, pmus);

tools/perf/util/drm_pmu.c

253

void drm_pmu__exit(struct perf_pmu *pmu)

tools/perf/util/drm_pmu.c

255

struct drm_pmu *drm = container_of(pmu, struct drm_pmu, pmu);

tools/perf/util/drm_pmu.c

260

bool drm_pmu__have_event(const struct perf_pmu *pmu, const char *name)

tools/perf/util/drm_pmu.c

262

struct drm_pmu *drm = container_of(pmu, struct drm_pmu, pmu);

tools/perf/util/drm_pmu.c

274

int drm_pmu__for_each_event(const struct perf_pmu *pmu, void *state, pmu_event_callback cb)

tools/perf/util/drm_pmu.c

276

struct drm_pmu *drm = container_of(pmu, struct drm_pmu, pmu);

tools/perf/util/drm_pmu.c

281

.pmu = pmu,

tools/perf/util/drm_pmu.c

289

.pmu_name = pmu->name,

tools/perf/util/drm_pmu.c

294

snprintf(encoding_buf, sizeof(encoding_buf), "%s/config=0x%x/", pmu->name, i);

tools/perf/util/drm_pmu.c

303

size_t drm_pmu__num_events(const struct perf_pmu *pmu)

tools/perf/util/drm_pmu.c

305

const struct drm_pmu *drm = container_of(pmu, struct drm_pmu, pmu);

tools/perf/util/drm_pmu.c

347

int drm_pmu__config_terms(const struct perf_pmu *pmu,

tools/perf/util/drm_pmu.c

352

struct drm_pmu *drm = container_of(pmu, struct drm_pmu, pmu);

tools/perf/util/drm_pmu.c

363

int drm_pmu__check_alias(const struct perf_pmu *pmu, struct parse_events_terms *terms,

tools/perf/util/drm_pmu.c

366

struct drm_pmu *drm = container_of(pmu, struct drm_pmu, pmu);

tools/perf/util/drm_pmu.c

41

struct perf_pmu pmu;

tools/perf/util/drm_pmu.c

62

bool perf_pmu__is_drm(const struct perf_pmu *pmu)

tools/perf/util/drm_pmu.c

64

return pmu && pmu->type >= PERF_PMU_TYPE_DRM_START &&

tools/perf/util/drm_pmu.c

65

pmu->type <= PERF_PMU_TYPE_DRM_END;

tools/perf/util/drm_pmu.c

665

struct drm_pmu *drm = container_of(evsel->pmu, struct drm_pmu, pmu);

tools/perf/util/drm_pmu.c

70

return perf_pmu__is_drm(evsel->pmu);

tools/perf/util/drm_pmu.c

76

struct perf_pmu *pmu;

tools/perf/util/drm_pmu.c

92

list_for_each_entry(pmu, pmus, list) {

tools/perf/util/drm_pmu.c

93

if (!perf_pmu__is_drm(pmu))

tools/perf/util/drm_pmu.c

95

if (pmu->type > max_drm_pmu_type)

tools/perf/util/drm_pmu.c

96

max_drm_pmu_type = pmu->type;

tools/perf/util/drm_pmu.c

97

if (!strcmp(pmu->name, name)) {

tools/perf/util/drm_pmu.h

17

void drm_pmu__exit(struct perf_pmu *pmu);

tools/perf/util/drm_pmu.h

18

bool drm_pmu__have_event(const struct perf_pmu *pmu, const char *name);

tools/perf/util/drm_pmu.h

19

int drm_pmu__for_each_event(const struct perf_pmu *pmu, void *state, pmu_event_callback cb);

tools/perf/util/drm_pmu.h

20

size_t drm_pmu__num_events(const struct perf_pmu *pmu);

tools/perf/util/drm_pmu.h

21

int drm_pmu__config_terms(const struct perf_pmu *pmu,

tools/perf/util/drm_pmu.h

25

int drm_pmu__check_alias(const struct perf_pmu *pmu, struct parse_events_terms *terms,

tools/perf/util/drm_pmu.h

29

bool perf_pmu__is_drm(const struct perf_pmu *pmu);

tools/perf/util/env.c

394

struct perf_pmu *pmu = NULL;

tools/perf/util/env.c

398

while ((pmu = perf_pmus__scan(pmu)))

tools/perf/util/env.c

410

while ((pmu = perf_pmus__scan(pmu))) {

tools/perf/util/env.c

411

if (strbuf_addf(&sb, "%u:%s", pmu->type, pmu->name) < 0)

tools/perf/util/env.c

464

static int __perf_env__read_core_pmu_caps(const struct perf_pmu *pmu,

tools/perf/util/env.c

477

if (!pmu->nr_caps)

tools/perf/util/env.c

480

*caps = calloc(pmu->nr_caps, sizeof(char *));

tools/perf/util/env.c

485

list_for_each_entry(pcaps, &pmu->caps, list) {

tools/perf/util/env.c

500

*nr_caps = pmu->nr_caps;

tools/perf/util/env.c

513

struct perf_pmu *pmu = NULL;

tools/perf/util/env.c

523

pmu = perf_pmus__find_core_pmu();

tools/perf/util/env.c

524

if (!pmu)

tools/perf/util/env.c

526

ret = perf_pmu__caps_parse(pmu);

tools/perf/util/env.c

529

return __perf_env__read_core_pmu_caps(pmu, &env->nr_cpu_pmu_caps,

tools/perf/util/env.c

540

while ((pmu = perf_pmus__scan_core(pmu)) != NULL) {

tools/perf/util/env.c

541

if (perf_pmu__caps_parse(pmu) <= 0)

tools/perf/util/env.c

543

ret = __perf_env__read_core_pmu_caps(pmu, &pmu_caps[i].nr_caps,

tools/perf/util/env.c

551

pmu_caps[i].pmu_name = strdup(pmu->name);

tools/perf/util/evlist.c

105

struct perf_pmu *pmu = NULL;

tools/perf/util/evlist.c

112

while ((pmu = perf_pmus__scan_core(pmu)) != NULL) {

tools/perf/util/evlist.c

116

snprintf(buf, sizeof(buf), "%s/cycles/%s", pmu->name,

tools/perf/util/evlist.c

2615

if (!first && counter->pmu != last_pmu)

tools/perf/util/evlist.c

2618

if (counter->pmu) {

tools/perf/util/evlist.c

2620

if (!counter->pmu->is_core)

tools/perf/util/evlist.c

2626

last_pmu = counter->pmu;

tools/perf/util/evlist.c

379

if (!perf_pmu__benefits_from_affinity(pos->pmu))

tools/perf/util/evsel.c

1127

if (!evsel->pmu->is_core) {

tools/perf/util/evsel.c

1138

if (evsel_prev->pmu->type != evsel->pmu->type) {

tools/perf/util/evsel.c

1344

struct perf_pmu_format *format = pmu_find_format(&evsel->pmu->format,

tools/perf/util/evsel.c

1397

struct perf_pmu_format *format = pmu_find_format(&evsel->pmu->format, config_name);

tools/perf/util/evsel.c

2072

if (type == PERF_TYPE_HARDWARE && evsel->pmu && evsel->pmu->is_core &&

tools/perf/util/evsel.c

2349

if (evsel->pmu && evsel->pmu->missing_features.exclude_guest)

tools/perf/util/evsel.c

2432

struct perf_pmu *pmu = evsel->pmu;

tools/perf/util/evsel.c

2437

if (pmu == NULL)

tools/perf/util/evsel.c

2438

pmu = evsel->pmu = evsel__find_pmu(evsel);

tools/perf/util/evsel.c

2440

if (pmu == NULL || pmu->missing_features.checked)

tools/perf/util/evsel.c

2455

pmu->missing_features.exclude_guest = true;

tools/perf/util/evsel.c

2456

pr_debug2("switching off exclude_guest for PMU %s\n", pmu->name);

tools/perf/util/evsel.c

2459

pmu->missing_features.checked = true;

tools/perf/util/evsel.c

246

struct perf_pmu *pmu = evsel__find_pmu(evsel);

tools/perf/util/evsel.c

248

if (pmu)

tools/perf/util/evsel.c

249

return pmu->name;

tools/perf/util/evsel.c

3982

struct perf_pmu *pmu;

tools/perf/util/evsel.c

4079

evsel->pmu ? evsel->pmu->name : "");

tools/perf/util/evsel.c

4097

pmu = evsel__find_pmu(evsel);

tools/perf/util/evsel.c

4098

if (!pmu->is_core && !target__has_cpu(target))

tools/perf/util/evsel.c

4141

if (perf_pmu__kind(evsel->pmu) != PERF_PMU_KIND_PE)

tools/perf/util/evsel.c

4219

struct perf_pmu *pmu;

tools/perf/util/evsel.c

4224

pmu = evsel__find_pmu(evsel);

tools/perf/util/evsel.c

4225

return pmu && pmu->auxtrace;

tools/perf/util/evsel.c

4284

if (counter->pmu && counter->pmu->is_core &&

tools/perf/util/evsel.c

4310

if (evsel == counter || evsel->first_wildcard_match || evsel->pmu == counter->pmu)

tools/perf/util/evsel.c

4340

pmu_name = counter->pmu->name;

tools/perf/util/evsel.c

4387

const struct perf_pmu *pmu = evsel__find_pmu(evsel);

tools/perf/util/evsel.c

4389

if (pmu && pmu->is_core) {

tools/perf/util/evsel.c

4390

intersect = perf_cpu_map__intersect(pmu->cpus, user_requested_cpus);

tools/perf/util/evsel.c

4400

cpu_map__snprint(online ?: pmu->cpus, buf2, sizeof(buf2));

tools/perf/util/evsel.c

4402

buf1, pmu ? pmu->name : "cpu", buf2, evsel__name(evsel));

tools/perf/util/evsel.c

563

evsel->pmu = orig->pmu;

tools/perf/util/evsel.h

179

struct perf_pmu *pmu;

tools/perf/util/header.c

1541

static int __write_pmu_caps(struct feat_fd *ff, struct perf_pmu *pmu,

tools/perf/util/header.c

1547

ret = do_write(ff, &pmu->nr_caps, sizeof(pmu->nr_caps));

tools/perf/util/header.c

1551

list_for_each_entry(caps, &pmu->caps, list) {

tools/perf/util/header.c

1562

ret = do_write_string(ff, pmu->name);

tools/perf/util/header.c

1589

struct perf_pmu *pmu = NULL;

tools/perf/util/header.c

1593

while ((pmu = perf_pmus__scan(pmu))) {

tools/perf/util/header.c

1594

if (!strcmp(pmu->name, "cpu")) {

tools/perf/util/header.c

1602

if (perf_pmu__caps_parse(pmu) <= 0)

tools/perf/util/header.c

1618

pmu = NULL;

tools/perf/util/header.c

1619

while ((pmu = perf_pmus__scan(pmu))) {

tools/perf/util/header.c

1620

if (!strcmp(pmu->name, "cpu")) {

tools/perf/util/header.c

1624

if (perf_pmu__caps_parse(pmu) <= 0)

tools/perf/util/header.c

1626

ret = __write_pmu_caps(ff, pmu, true);

tools/perf/util/header.c

761

struct perf_pmu *pmu = NULL;

tools/perf/util/header.c

769

while ((pmu = perf_pmus__scan(pmu)))

tools/perf/util/header.c

776

while ((pmu = perf_pmus__scan(pmu))) {

tools/perf/util/header.c

777

ret = do_write(ff, &pmu->type, sizeof(pmu->type));

tools/perf/util/header.c

781

ret = do_write_string(ff, pmu->name);

tools/perf/util/hwmon_pmu.c

105

struct perf_pmu pmu;

tools/perf/util/hwmon_pmu.c

127

bool perf_pmu__is_hwmon(const struct perf_pmu *pmu)

tools/perf/util/hwmon_pmu.c

129

return pmu && pmu->type >= PERF_PMU_TYPE_HWMON_START &&

tools/perf/util/hwmon_pmu.c

130

pmu->type <= PERF_PMU_TYPE_HWMON_END;

tools/perf/util/hwmon_pmu.c

135

return perf_pmu__is_hwmon(evsel->pmu);

tools/perf/util/hwmon_pmu.c

236

static int hwmon_pmu__read_events(struct hwmon_pmu *pmu)

tools/perf/util/hwmon_pmu.c

244

if (pmu->pmu.sysfs_aliases_loaded)

tools/perf/util/hwmon_pmu.c

248

io_dir__init(&dir, open(pmu->hwmon_dir, O_CLOEXEC | O_DIRECTORY | O_RDONLY));

tools/perf/util/hwmon_pmu.c

270

if (!hashmap__find(&pmu->events, key.type_and_num, &value)) {

tools/perf/util/hwmon_pmu.c

276

err = hashmap__add(&pmu->events, key.type_and_num, value);

tools/perf/util/hwmon_pmu.c

302

pmu->pmu.name, ent->d_name);

tools/perf/util/hwmon_pmu.c

320

if (hashmap__size(&pmu->events) == 0)

tools/perf/util/hwmon_pmu.c

321

pr_debug2("hwmon_pmu: %s has no events\n", pmu->pmu.name);

tools/perf/util/hwmon_pmu.c

323

hashmap__for_each_entry_safe((&pmu->events), cur, tmp, bkt) {

tools/perf/util/hwmon_pmu.c

331

pmu->pmu.name, hwmon_type_strs[key.type], key.num);

tools/perf/util/hwmon_pmu.c

332

hashmap__delete(&pmu->events, key.type_and_num, &key, &value);

tools/perf/util/hwmon_pmu.c

338

pmu->pmu.sysfs_aliases_loaded = true;

tools/perf/util/hwmon_pmu.c

364

if (perf_pmu__init(&hwm->pmu, type, buf) != 0) {

tools/perf/util/hwmon_pmu.c

365

perf_pmu__delete(&hwm->pmu);

tools/perf/util/hwmon_pmu.c

371

perf_pmu__delete(&hwm->pmu);

tools/perf/util/hwmon_pmu.c

374

hwm->pmu.alias_name = strdup(sysfs_name);

tools/perf/util/hwmon_pmu.c

375

if (!hwm->pmu.alias_name) {

tools/perf/util/hwmon_pmu.c

376

perf_pmu__delete(&hwm->pmu);

tools/perf/util/hwmon_pmu.c

379

hwm->pmu.cpus = perf_cpu_map__new_int(0);

tools/perf/util/hwmon_pmu.c

380

if (!hwm->pmu.cpus) {

tools/perf/util/hwmon_pmu.c

381

perf_pmu__delete(&hwm->pmu);

tools/perf/util/hwmon_pmu.c

384

INIT_LIST_HEAD(&hwm->pmu.format);

tools/perf/util/hwmon_pmu.c

385

INIT_LIST_HEAD(&hwm->pmu.caps);

tools/perf/util/hwmon_pmu.c

389

list_add_tail(&hwm->pmu.list, pmus);

tools/perf/util/hwmon_pmu.c

390

return &hwm->pmu;

tools/perf/util/hwmon_pmu.c

393

void hwmon_pmu__exit(struct perf_pmu *pmu)

tools/perf/util/hwmon_pmu.c

395

struct hwmon_pmu *hwm = container_of(pmu, struct hwmon_pmu, pmu);

tools/perf/util/hwmon_pmu.c

459

int hwmon_pmu__for_each_event(struct perf_pmu *pmu, void *state, pmu_event_callback cb)

tools/perf/util/hwmon_pmu.c

461

struct hwmon_pmu *hwm = container_of(pmu, struct hwmon_pmu, pmu);

tools/perf/util/hwmon_pmu.c

503

.pmu = pmu,

tools/perf/util/hwmon_pmu.c

511

.pmu_name = pmu->name,

tools/perf/util/hwmon_pmu.c

526

pmu->name + 6,

tools/perf/util/hwmon_pmu.c

536

pmu->name, cur->key);

tools/perf/util/hwmon_pmu.c

545

size_t hwmon_pmu__num_events(struct perf_pmu *pmu)

tools/perf/util/hwmon_pmu.c

547

struct hwmon_pmu *hwm = container_of(pmu, struct hwmon_pmu, pmu);

tools/perf/util/hwmon_pmu.c

553

bool hwmon_pmu__have_event(struct perf_pmu *pmu, const char *name)

tools/perf/util/hwmon_pmu.c

555

struct hwmon_pmu *hwm = container_of(pmu, struct hwmon_pmu, pmu);

tools/perf/util/hwmon_pmu.c

646

int hwmon_pmu__config_terms(const struct perf_pmu *pmu,

tools/perf/util/hwmon_pmu.c

651

struct hwmon_pmu *hwm = container_of(pmu, struct hwmon_pmu, pmu);

tools/perf/util/hwmon_pmu.c

762

struct hwmon_pmu *hwm = container_of(evsel->pmu, struct hwmon_pmu, pmu);

tools/perf/util/hwmon_pmu.h

110

bool perf_pmu__is_hwmon(const struct perf_pmu *pmu);

tools/perf/util/hwmon_pmu.h

147

void hwmon_pmu__exit(struct perf_pmu *pmu);

tools/perf/util/hwmon_pmu.h

149

int hwmon_pmu__for_each_event(struct perf_pmu *pmu, void *state, pmu_event_callback cb);

tools/perf/util/hwmon_pmu.h

150

size_t hwmon_pmu__num_events(struct perf_pmu *pmu);

tools/perf/util/hwmon_pmu.h

151

bool hwmon_pmu__have_event(struct perf_pmu *pmu, const char *name);

tools/perf/util/hwmon_pmu.h

152

int hwmon_pmu__config_terms(const struct perf_pmu *pmu,

tools/perf/util/mem-events.c

103

e->name, pmu->name, pmu->name,

tools/perf/util/mem-events.c

110

e->name, pmu->name);

tools/perf/util/mem-events.c

120

e->name, pmu->name);

tools/perf/util/mem-events.c

129

struct perf_pmu *pmu = leader->pmu;

tools/perf/util/mem-events.c

132

if (!pmu || !pmu->mem_events)

tools/perf/util/mem-events.c

135

e = &pmu->mem_events[PERF_MEM_EVENTS__LOAD];

tools/perf/util/mem-events.c

142

int perf_pmu__mem_events_parse(struct perf_pmu *pmu, const char *str)

tools/perf/util/mem-events.c

160

struct perf_mem_event *e = perf_pmu__mem_events_ptr(pmu, j);

tools/perf/util/mem-events.c

181

static bool perf_pmu__mem_events_supported(const char *mnt, struct perf_pmu *pmu,

tools/perf/util/mem-events.c

190

scnprintf(path, PATH_MAX, "%s/bus/event_source/devices/%s/events/%s", mnt, pmu->name, e->event_name);

tools/perf/util/mem-events.c

195

static int __perf_pmu__mem_events_init(struct perf_pmu *pmu)

tools/perf/util/mem-events.c

205

struct perf_mem_event *e = perf_pmu__mem_events_ptr(pmu, j);

tools/perf/util/mem-events.c

214

e->supported |= perf_pmu__mem_events_supported(mnt, pmu, e);

tools/perf/util/mem-events.c

224

struct perf_pmu *pmu = NULL;

tools/perf/util/mem-events.c

226

while ((pmu = perf_pmus__scan_mem(pmu)) != NULL) {

tools/perf/util/mem-events.c

227

if (__perf_pmu__mem_events_init(pmu))

tools/perf/util/mem-events.c

234

void perf_pmu__mem_events_list(struct perf_pmu *pmu)

tools/perf/util/mem-events.c

240

struct perf_mem_event *e = perf_pmu__mem_events_ptr(pmu, j);

tools/perf/util/mem-events.c

247

? perf_pmu__mem_events_name(pmu, j, buf, sizeof(buf))

tools/perf/util/mem-events.c

256

struct perf_pmu *pmu = NULL;

tools/perf/util/mem-events.c

269

while ((pmu = perf_pmus__scan_mem(pmu)) != NULL) {

tools/perf/util/mem-events.c

272

struct perf_mem_event *e = perf_pmu__mem_events_ptr(pmu, j);

tools/perf/util/mem-events.c

282

perf_pmu__mem_events_name(pmu, j, buf, sizeof(buf)));

tools/perf/util/mem-events.c

287

s = perf_pmu__mem_events_name(pmu, j, event_name_storage_ptr,

tools/perf/util/mem-events.c

289

if (!s || !perf_pmu__mem_events_supported(mnt, pmu, e))

tools/perf/util/mem-events.c

297

ret = perf_cpu_map__merge(&cpu_map, pmu->cpus);

tools/perf/util/mem-events.c

34

struct perf_mem_event *perf_pmu__mem_events_ptr(struct perf_pmu *pmu, int i)

tools/perf/util/mem-events.c

36

if (i >= PERF_MEM_EVENTS__MAX || !pmu)

tools/perf/util/mem-events.c

39

return &pmu->mem_events[i];

tools/perf/util/mem-events.c

42

static struct perf_pmu *perf_pmus__scan_mem(struct perf_pmu *pmu)

tools/perf/util/mem-events.c

44

while ((pmu = perf_pmus__scan(pmu)) != NULL) {

tools/perf/util/mem-events.c

45

if (pmu->mem_events)

tools/perf/util/mem-events.c

46

return pmu;

tools/perf/util/mem-events.c

71

int perf_pmu__mem_events_num_mem_pmus(struct perf_pmu *pmu)

tools/perf/util/mem-events.c

75

while ((pmu = perf_pmus__scan_mem(pmu)) != NULL)

tools/perf/util/mem-events.c

81

static const char *perf_pmu__mem_events_name(struct perf_pmu *pmu, int i,

tools/perf/util/mem-events.c

86

if (i >= PERF_MEM_EVENTS__MAX || !pmu)

tools/perf/util/mem-events.c

89

e = &pmu->mem_events[i];

tools/perf/util/mem-events.c

98

e->name, pmu->name,

tools/perf/util/mem-events.h

32

int perf_pmu__mem_events_parse(struct perf_pmu *pmu, const char *str);

tools/perf/util/mem-events.h

35

struct perf_mem_event *perf_pmu__mem_events_ptr(struct perf_pmu *pmu, int i);

tools/perf/util/mem-events.h

37

int perf_pmu__mem_events_num_mem_pmus(struct perf_pmu *pmu);

tools/perf/util/mem-events.h

40

void perf_pmu__mem_events_list(struct perf_pmu *pmu);

tools/perf/util/metricgroup.c

1026

const char *pmu;

tools/perf/util/metricgroup.c

1043

if (pm->metric_expr && match_pm_metric_or_groups(pm, data->pmu, data->metric_name)) {

tools/perf/util/metricgroup.c

1072

static int metricgroup__add_metric(const char *pmu, const char *metric_name, const char *modifier,

tools/perf/util/metricgroup.c

1083

.pmu = pmu,

tools/perf/util/metricgroup.c

1125

static int metricgroup__add_metric_list(const char *pmu, const char *list,

tools/perf/util/metricgroup.c

1145

ret = metricgroup__add_metric(pmu, metric_name, modifier,

tools/perf/util/metricgroup.c

130

const char *pmu;

tools/perf/util/metricgroup.c

1382

const char *pmu, const char *str,

tools/perf/util/metricgroup.c

1398

ret = metricgroup__add_metric_list(pmu, str, metric_no_group, metric_no_threshold,

tools/perf/util/metricgroup.c

1458

if ((!m->pmu && n->pmu) ||

tools/perf/util/metricgroup.c

1459

(m->pmu && !n->pmu) ||

tools/perf/util/metricgroup.c

1460

(m->pmu && n->pmu && strcmp(m->pmu, n->pmu)))

tools/perf/util/metricgroup.c

1480

ret = setup_metric_events(fake_pmu ? "all" : m->pmu, m->pctx->ids,

tools/perf/util/metricgroup.c

1554

const char *pmu,

tools/perf/util/metricgroup.c

1568

return parse_groups(perf_evlist, pmu, str, metric_no_group, metric_no_merge,

tools/perf/util/metricgroup.c

1587

const char *pmu;

tools/perf/util/metricgroup.c

1597

return match_pm_metric_or_groups(pm, data->pmu, data->metric_or_groups) ? 1 : 0;

tools/perf/util/metricgroup.c

1600

bool metricgroup__has_metric_or_groups(const char *pmu, const char *metric_or_groups)

tools/perf/util/metricgroup.c

1604

.pmu = pmu,

tools/perf/util/metricgroup.c

239

m->pmu = pm->pmu ?: "cpu";

tools/perf/util/metricgroup.c

290

static int setup_metric_events(const char *pmu, struct hashmap *ids,

tools/perf/util/metricgroup.c

298

bool all_pmus = !strcmp(pmu, "all") || perf_pmus__num_core_pmus() == 1 || !is_pmu_core(pmu);

tools/perf/util/metricgroup.c

312

if (!all_pmus && ev->pmu && evsel__is_hybrid(ev) &&

tools/perf/util/metricgroup.c

313

strcmp(ev->pmu->name, pmu))

tools/perf/util/metricgroup.c

386

static bool match_pm_metric_or_groups(const struct pmu_metric *pm, const char *pmu,

tools/perf/util/metricgroup.c

389

const char *pm_pmu = pm->pmu ?: "cpu";

tools/perf/util/metricgroup.c

391

if (strcmp(pmu, "all") && strcmp(pm_pmu, pmu))

tools/perf/util/metricgroup.c

408

struct perf_pmu *pmu = NULL;

tools/perf/util/metricgroup.c

413

while ((pmu = perf_pmus__scan(pmu))) {

tools/perf/util/metricgroup.c

415

if (!pmu->id || !pmu_uncore_identifier_match(pm->compat, pmu->id))

tools/perf/util/metricgroup.c

680

const char *pmu;

tools/perf/util/metricgroup.c

735

struct perf_pmu *pmu,

tools/perf/util/metricgroup.c

765

if (pmu_metrics_table__find_metric(table, pmu, cur->pkey,

tools/perf/util/metricgroup.c

918

struct perf_pmu *pmu;

tools/perf/util/metricgroup.c

920

if (pm->pmu && pm->pmu[0] != '\0')

tools/perf/util/metricgroup.c

921

pmu = perf_pmus__find(pm->pmu);

tools/perf/util/metricgroup.c

923

pmu = perf_pmus__scan_core(/*pmu=*/ NULL);

tools/perf/util/metricgroup.c

925

ret = resolve_metric(metric_list, pmu, modifier, metric_no_group,

tools/perf/util/metricgroup.h

73

const char *pmu,

tools/perf/util/metricgroup.h

87

bool metricgroup__has_metric_or_groups(const char *pmu, const char *metric_or_groups);

tools/perf/util/parse-events.c

105

struct perf_pmu *pmu = perf_pmus__find(term->val.str);

tools/perf/util/parse-events.c

107

if (pmu) {

tools/perf/util/parse-events.c

108

term_cpus = pmu->is_core && perf_cpu_map__is_empty(pmu->cpus)

tools/perf/util/parse-events.c

110

: perf_cpu_map__get(pmu->cpus);

tools/perf/util/parse-events.c

1304

static int add_cfg_chg(const struct perf_pmu *pmu,

tools/perf/util/parse-events.c

1317

type = perf_pmu__format_type(pmu, term->config);

tools/perf/util/parse-events.c

1320

bits |= perf_pmu__format_bits(pmu, term->config);

tools/perf/util/parse-events.c

1341

static int get_config_chgs(const struct perf_pmu *pmu,

tools/perf/util/parse-events.c

1347

ret = add_cfg_chg(pmu, head_config, head_terms,

tools/perf/util/parse-events.c

1354

ret = add_cfg_chg(pmu, head_config, head_terms,

tools/perf/util/parse-events.c

1361

ret = add_cfg_chg(pmu, head_config, head_terms,

tools/perf/util/parse-events.c

1368

ret = add_cfg_chg(pmu, head_config, head_terms,

tools/perf/util/parse-events.c

1375

return add_cfg_chg(pmu, head_config, head_terms,

tools/perf/util/parse-events.c

140

static void fix_raw(struct parse_events_terms *config_terms, struct perf_pmu *pmu)

tools/perf/util/parse-events.c

1402

struct perf_pmu *pmu, u32 type, u32 extended_type,

tools/perf/util/parse-events.c

1432

metric_id, pmu, &config_terms, first_wildcard_match,

tools/perf/util/parse-events.c

1445

struct perf_pmu *pmu = NULL;

tools/perf/util/parse-events.c

1451

while ((pmu = perf_pmus__scan_core(pmu)) != NULL) {

tools/perf/util/parse-events.c

1455

if (parse_events__filter_pmu(parse_state, pmu))

tools/perf/util/parse-events.c

1458

ret = __parse_events_add_numeric(parse_state, list, pmu,

tools/perf/util/parse-events.c

1459

type, pmu->type,

tools/perf/util/parse-events.c

1489

struct list_head *list, struct perf_pmu *pmu,

tools/perf/util/parse-events.c

150

if (perf_pmu__have_event(pmu, term->val.str)) {

tools/perf/util/parse-events.c

1507

if (pmu->selectable && const_parsed_terms &&

tools/perf/util/parse-events.c

1509

strbuf_addf(&sb, "%s//", pmu->name);

tools/perf/util/parse-events.c

1511

strbuf_addf(&sb, "%s/", pmu->name);

tools/perf/util/parse-events.c

1520

if (pmu->perf_event_attr_init_default)

tools/perf/util/parse-events.c

1521

pmu->perf_event_attr_init_default(pmu, &attr);

tools/perf/util/parse-events.c

1523

attr.type = pmu->type;

tools/perf/util/parse-events.c

1528

/*metric_id=*/NULL, pmu,

tools/perf/util/parse-events.c

1541

fix_raw(&parsed_terms, pmu);

tools/perf/util/parse-events.c

1550

if (perf_pmu__check_alias(pmu, &parsed_terms,

tools/perf/util/parse-events.c

1562

fprintf(stderr, "..after resolving event: %s/%s/\n", pmu->name, sb.buf);

tools/perf/util/parse-events.c

1579

if (get_config_chgs(pmu, &parsed_terms, &config_terms)) {

tools/perf/util/parse-events.c

1585

if (perf_pmu__config(pmu, &attr, &parsed_terms, /*apply_hardcoded=*/false,

tools/perf/util/parse-events.c

1595

get_config_metric_id(&parsed_terms), pmu,

tools/perf/util/parse-events.c

1628

struct perf_pmu *pmu = NULL;

tools/perf/util/parse-events.c

1665

while ((pmu = perf_pmus__scan_for_event(pmu, event_name)) != NULL) {

tools/perf/util/parse-events.c

1667

if (parse_events__filter_pmu(parse_state, pmu))

tools/perf/util/parse-events.c

1670

if (!perf_pmu__have_event(pmu, event_name))

tools/perf/util/parse-events.c

1673

if (!parse_events_add_pmu(parse_state, list, pmu,

tools/perf/util/parse-events.c

1679

pr_debug("%s -> %s/%s/\n", event_name, pmu->name, sb.buf);

tools/perf/util/parse-events.c

1717

struct perf_pmu *pmu;

tools/perf/util/parse-events.c

1729

pmu = perf_pmus__find(event_or_pmu);

tools/perf/util/parse-events.c

1730

if (pmu && !parse_events_add_pmu(parse_state, *listp, pmu, const_parsed_terms,

tools/perf/util/parse-events.c

1741

pmu = NULL;

tools/perf/util/parse-events.c

1743

while ((pmu = perf_pmus__scan_matching_wildcard(pmu, event_or_pmu)) != NULL) {

tools/perf/util/parse-events.c

1745

if (parse_events__filter_pmu(parse_state, pmu))

tools/perf/util/parse-events.c

1748

if (!parse_events_add_pmu(parse_state, *listp, pmu,

tools/perf/util/parse-events.c

177

const char *name, const char *metric_id, struct perf_pmu *pmu,

tools/perf/util/parse-events.c

196

if (perf_pmu__name_no_suffix_match(pos->pmu, pmu->name)) {

tools/perf/util/parse-events.c

1986

struct perf_pmu *pmu = evsel__find_pmu(evsel);

tools/perf/util/parse-events.c

1988

if (!pmu) {

tools/perf/util/parse-events.c

1994

pmu = perf_pmus__scan_core(NULL);

tools/perf/util/parse-events.c

1996

if (!pmu) {

tools/perf/util/parse-events.c

200

if (pos->pmu->is_core && (!pmu || pmu->is_core)) {

tools/perf/util/parse-events.c

2000

group_pmu_name = pmu->name;

tools/perf/util/parse-events.c

2009

if (perf_pmu__is_software(pmu) || evsel__is_aux_event(leader)) {

tools/perf/util/parse-events.c

207

if (pmu) {

tools/perf/util/parse-events.c

208

perf_pmu__warn_invalid_formats(pmu);

tools/perf/util/parse-events.c

210

perf_pmu__warn_invalid_config(pmu, attr->config, name,

tools/perf/util/parse-events.c

212

perf_pmu__warn_invalid_config(pmu, attr->config1, name,

tools/perf/util/parse-events.c

214

perf_pmu__warn_invalid_config(pmu, attr->config2, name,

tools/perf/util/parse-events.c

216

perf_pmu__warn_invalid_config(pmu, attr->config3, name,

tools/perf/util/parse-events.c

218

perf_pmu__warn_invalid_config(pmu, attr->config4, name,

tools/perf/util/parse-events.c

226

if (!pmu)

tools/perf/util/parse-events.c

227

pmu = perf_pmus__find_by_attr(attr);

tools/perf/util/parse-events.c

229

if (pmu) {

tools/perf/util/parse-events.c

230

is_pmu_core = pmu->is_core;

tools/perf/util/parse-events.c

231

pmu_cpus = perf_cpu_map__get(pmu->cpus);

tools/perf/util/parse-events.c

2572

struct perf_pmu *pmu;

tools/perf/util/parse-events.c

2590

pmu = evsel__find_pmu(evsel);

tools/perf/util/parse-events.c

2591

if (pmu) {

tools/perf/util/parse-events.c

2592

perf_pmu__scan_file(pmu, "nr_addr_filters",

tools/perf/util/parse-events.c

270

evsel->core.requires_cpu = pmu ? pmu->is_uncore : false;

tools/perf/util/parse-events.c

273

evsel->pmu = pmu;

tools/perf/util/parse-events.c

298

struct perf_pmu *pmu)

tools/perf/util/parse-events.c

301

metric_id, pmu, /*config_terms=*/NULL,

tools/perf/util/parse-events.c

427

const struct perf_pmu *pmu)

tools/perf/util/parse-events.c

432

return strcmp(parse_state->pmu_filter, pmu->name) != 0;

tools/perf/util/parse-events.c

436

struct list_head *list, struct perf_pmu *pmu,

tools/perf/util/parse-events.c

987

struct perf_pmu *pmu = NULL;

tools/perf/util/parse-events.c

990

while ((pmu = perf_pmus__scan_core(pmu)) != NULL) {

tools/perf/util/parse-events.c

991

if (pmu->type == type)

tools/perf/util/parse-events.h

173

const struct perf_pmu *pmu);

tools/perf/util/parse-events.h

239

struct perf_pmu *pmu);

tools/perf/util/perf-regs-arch/perf_regs_x86.c

260

struct perf_pmu *pmu = NULL;

tools/perf/util/perf-regs-arch/perf_regs_x86.c

267

while ((pmu = perf_pmus__scan_core(pmu)) != NULL) {

tools/perf/util/perf-regs-arch/perf_regs_x86.c

268

type = pmu->type;

tools/perf/util/perf_api_probe.c

62

struct perf_pmu *pmu;

tools/perf/util/perf_api_probe.c

77

pmu = perf_pmus__scan_core(/*pmu=*/NULL);

tools/perf/util/perf_api_probe.c

78

if (pmu) {

tools/perf/util/perf_api_probe.c

84

snprintf(buf, sizeof(buf), "%s/%s/u", pmu->name, try[i++]);

tools/perf/util/perf_event_attr_fprintf.c

186

static void __p_type_id(char *buf, size_t size, struct perf_pmu *pmu, u32 type)

tools/perf/util/perf_event_attr_fprintf.c

188

print_id_unsigned(buf, size, type, stringify_perf_type_id(pmu, type));

tools/perf/util/perf_event_attr_fprintf.c

191

static void __p_config_hw_id(char *buf, size_t size, struct perf_pmu *pmu, u64 config)

tools/perf/util/perf_event_attr_fprintf.c

196

if (pmu == NULL) {

tools/perf/util/perf_event_attr_fprintf.c

199

snprintf(buf, size, "%#"PRIx64" (%s/config=%#"PRIx64"/)", config, pmu->name,

tools/perf/util/perf_event_attr_fprintf.c

203

if (pmu == NULL)

tools/perf/util/perf_event_attr_fprintf.c

206

snprintf(buf, size, "%#"PRIx64" (%s/%s/)", config, pmu->name, name);

tools/perf/util/perf_event_attr_fprintf.c

215

static void __p_config_hw_cache_id(char *buf, size_t size, struct perf_pmu *pmu, u64 config)

tools/perf/util/perf_event_attr_fprintf.c

224

if (pmu == NULL) {

tools/perf/util/perf_event_attr_fprintf.c

227

snprintf(buf, size, "%#"PRIx64" (%s/config=%#"PRIx64"/)", config, pmu->name,

tools/perf/util/perf_event_attr_fprintf.c

231

if (pmu == NULL) {

tools/perf/util/perf_event_attr_fprintf.c

235

snprintf(buf, size, "%#"PRIx64" (%s/%s | %s | %s/)", config, pmu->name,

tools/perf/util/perf_event_attr_fprintf.c

249

static void __p_config_id(struct perf_pmu *pmu, char *buf, size_t size, u32 type, u64 config)

tools/perf/util/perf_event_attr_fprintf.c

253

return __p_config_hw_id(buf, size, pmu, config);

tools/perf/util/perf_event_attr_fprintf.c

257

return __p_config_hw_cache_id(buf, size, pmu, config);

tools/perf/util/perf_event_attr_fprintf.c

263

return print_id_hex(buf, size, config, perf_pmu__name_from_config(pmu, config));

tools/perf/util/perf_event_attr_fprintf.c

275

#define p_type_id(val) __p_type_id(buf, BUF_SIZE, pmu, val)

tools/perf/util/perf_event_attr_fprintf.c

276

#define p_config_id(val) __p_config_id(pmu, buf, BUF_SIZE, attr->type, val)

tools/perf/util/perf_event_attr_fprintf.c

291

struct perf_pmu *pmu = perf_pmus__find_by_type(attr->type);

tools/perf/util/perf_event_attr_fprintf.c

295

if (!pmu && (attr->type == PERF_TYPE_HARDWARE || attr->type == PERF_TYPE_HW_CACHE)) {

tools/perf/util/perf_event_attr_fprintf.c

299

pmu = perf_pmus__find_by_type(extended_type);

tools/perf/util/perf_event_attr_fprintf.c

80

static const char *stringify_perf_type_id(struct perf_pmu *pmu, u32 type)

tools/perf/util/perf_event_attr_fprintf.c

89

return pmu ? pmu->name : "PERF_TYPE_RAW";

tools/perf/util/perf_event_attr_fprintf.c

91

return pmu ? pmu->name : NULL;

tools/perf/util/pfm.c

127

struct perf_pmu *pmu;

tools/perf/util/pfm.c

138

pmu = perf_pmus__find_by_type((unsigned int)attr.type);

tools/perf/util/pfm.c

139

evsel = parse_events__add_event(0, &attr, name, /*metric_id=*/NULL, pmu);

tools/perf/util/pfm.c

308

if (pinfo.pmu == PFM_PMU_PERF_EVENT)

tools/perf/util/pfm.c

39

struct perf_pmu *pmu;

tools/perf/util/pfm.c

87

pmu = perf_pmus__find_by_type((unsigned int)attr.type);

tools/perf/util/pfm.c

90

pmu);

tools/perf/util/pmu.c

1057

struct perf_pmu *pmu = vdata;

tools/perf/util/pmu.c

1059

perf_pmu__new_alias(pmu, pe->name, pe->desc, pe->event, /*val_fd=*/ -1,

tools/perf/util/pmu.c

1068

void pmu_add_cpu_aliases_table(struct perf_pmu *pmu, const struct pmu_events_table *table)

tools/perf/util/pmu.c

1070

pmu_events_table__for_each_event(table, pmu, pmu_add_cpu_aliases_map_callback, pmu);

tools/perf/util/pmu.c

1073

static void pmu_add_cpu_aliases(struct perf_pmu *pmu)

tools/perf/util/pmu.c

1075

if (!pmu->events_table && !pmu->is_core)

tools/perf/util/pmu.c

1078

if (pmu->cpu_aliases_added)

tools/perf/util/pmu.c

1081

pmu_add_cpu_aliases_table(pmu, pmu->events_table);

tools/perf/util/pmu.c

1082

if (pmu->is_core)

tools/perf/util/pmu.c

1083

pmu_add_cpu_aliases_table(pmu, perf_pmu__default_core_events_table());

tools/perf/util/pmu.c

1085

pmu->cpu_aliases_added = true;

tools/perf/util/pmu.c

1092

struct perf_pmu *pmu = vdata;

tools/perf/util/pmu.c

1094

if (!pe->compat || !pe->pmu) {

tools/perf/util/pmu.c

1099

if (!perf_pmu__match_wildcard_uncore(pmu->name, pe->pmu) &&

tools/perf/util/pmu.c

1100

!perf_pmu__match_wildcard_uncore(pmu->alias_name, pe->pmu)) {

tools/perf/util/pmu.c

1105

if (pmu_uncore_identifier_match(pe->compat, pmu->id)) {

tools/perf/util/pmu.c

1107

perf_pmu__new_alias(pmu,

tools/perf/util/pmu.c

1118

void pmu_add_sys_aliases(struct perf_pmu *pmu)

tools/perf/util/pmu.c

1120

if (!pmu->id)

tools/perf/util/pmu.c

1123

pmu_for_each_sys_event(pmu_add_sys_aliases_iter_fn, pmu);

tools/perf/util/pmu.c

1126

static char *pmu_find_alias_name(struct perf_pmu *pmu, int dirfd)

tools/perf/util/pmu.c

1128

FILE *file = perf_pmu__open_file_at(pmu, dirfd, "alias");

tools/perf/util/pmu.c

1149

static int pmu_max_precise(int dirfd, struct perf_pmu *pmu)

tools/perf/util/pmu.c

1153

perf_pmu__scan_file_at(pmu, dirfd, "caps/max_precise", "%d", &max_precise);

tools/perf/util/pmu.c

1158

perf_pmu__arch_init(struct perf_pmu *pmu)

tools/perf/util/pmu.c

1160

if (pmu->is_core)

tools/perf/util/pmu.c

1161

pmu->mem_events = perf_mem_events;

tools/perf/util/pmu.c

1182

int perf_pmu__init(struct perf_pmu *pmu, __u32 type, const char *name)

tools/perf/util/pmu.c

1184

pmu->type = type;

tools/perf/util/pmu.c

1185

INIT_LIST_HEAD(&pmu->format);

tools/perf/util/pmu.c

1186

INIT_LIST_HEAD(&pmu->caps);

tools/perf/util/pmu.c

1188

pmu->name = strdup(name);

tools/perf/util/pmu.c

1189

if (!pmu->name)

tools/perf/util/pmu.c

1192

pmu->aliases = hashmap__new(aliases__hash, aliases__equal, /*ctx=*/ NULL);

tools/perf/util/pmu.c

1193

if (!pmu->aliases)

tools/perf/util/pmu.c

121

static int pmu_aliases_parse(struct perf_pmu *pmu);

tools/perf/util/pmu.c

1228

struct perf_pmu *pmu;

tools/perf/util/pmu.c

1230

pmu = zalloc(sizeof(*pmu));

tools/perf/util/pmu.c

1231

if (!pmu)

tools/perf/util/pmu.c

1234

if (perf_pmu__init(pmu, PERF_PMU_TYPE_FAKE, name) != 0) {

tools/perf/util/pmu.c

1235

perf_pmu__delete(pmu);

tools/perf/util/pmu.c

1243

if (perf_pmu__scan_file_at(pmu, dirfd, "type", "%u", &pmu->type) != 1) {

tools/perf/util/pmu.c

1245

pmu->type = wellknown_pmu_type(name);

tools/perf/util/pmu.c

1246

if (pmu->type == PERF_TYPE_MAX) {

tools/perf/util/pmu.c

1247

perf_pmu__delete(pmu);

tools/perf/util/pmu.c

1257

if (pmu_format(pmu, dirfd, name, eager_load)) {

tools/perf/util/pmu.c

1258

perf_pmu__delete(pmu);

tools/perf/util/pmu.c

1262

pmu->is_core = is_pmu_core(name);

tools/perf/util/pmu.c

1263

pmu->cpus = pmu_cpumask(dirfd, name, pmu->is_core);

tools/perf/util/pmu.c

1265

pmu->is_uncore = pmu_is_uncore(dirfd, name);

tools/perf/util/pmu.c

1266

if (pmu->is_uncore)

tools/perf/util/pmu.c

1267

pmu->id = pmu_id(name);

tools/perf/util/pmu.c

1268

pmu->max_precise = pmu_max_precise(dirfd, pmu);

tools/perf/util/pmu.c

1269

pmu->alias_name = pmu_find_alias_name(pmu, dirfd);

tools/perf/util/pmu.c

1270

pmu->events_table = perf_pmu__find_events_table(pmu);

tools/perf/util/pmu.c

1277

pmu_add_sys_aliases(pmu);

tools/perf/util/pmu.c

1278

list_add_tail(&pmu->list, pmus);

tools/perf/util/pmu.c

1280

perf_pmu__arch_init(pmu);

tools/perf/util/pmu.c

1283

pmu_aliases_parse_eager(pmu, dirfd);

tools/perf/util/pmu.c

1285

return pmu;

tools/perf/util/pmu.c

1291

struct perf_pmu *pmu = zalloc(sizeof(*pmu));

tools/perf/util/pmu.c

1293

if (!pmu)

tools/perf/util/pmu.c

1296

pmu->name = strdup("cpu");

tools/perf/util/pmu.c

1297

if (!pmu->name) {

tools/perf/util/pmu.c

1298

free(pmu);

tools/perf/util/pmu.c

1302

pmu->is_core = true;

tools/perf/util/pmu.c

1303

pmu->type = PERF_TYPE_RAW;

tools/perf/util/pmu.c

1304

pmu->cpus = cpu_map__online();

tools/perf/util/pmu.c

1306

INIT_LIST_HEAD(&pmu->format);

tools/perf/util/pmu.c

1307

pmu->aliases = hashmap__new(aliases__hash, aliases__equal, /*ctx=*/ NULL);

tools/perf/util/pmu.c

1308

INIT_LIST_HEAD(&pmu->caps);

tools/perf/util/pmu.c

1309

list_add_tail(&pmu->list, core_pmus);

tools/perf/util/pmu.c

1310

return pmu;

tools/perf/util/pmu.c

1313

bool perf_pmu__is_fake(const struct perf_pmu *pmu)

tools/perf/util/pmu.c

1315

return pmu->type == PERF_PMU_TYPE_FAKE;

tools/perf/util/pmu.c

1318

void perf_pmu__warn_invalid_formats(struct perf_pmu *pmu)

tools/perf/util/pmu.c

1322

if (pmu->formats_checked)

tools/perf/util/pmu.c

1325

pmu->formats_checked = true;

tools/perf/util/pmu.c

1328

if (perf_pmu__is_fake(pmu))

tools/perf/util/pmu.c

1331

list_for_each_entry(format, &pmu->format, list) {

tools/perf/util/pmu.c

1332

perf_pmu_format__load(pmu, format);

tools/perf/util/pmu.c

1336

pmu->name, format->name, format->value);

tools/perf/util/pmu.c

1374

__u64 perf_pmu__format_bits(const struct perf_pmu *pmu, const char *name)

tools/perf/util/pmu.c

1376

struct perf_pmu_format *format = pmu_find_format(&pmu->format, name);

tools/perf/util/pmu.c

1389

int perf_pmu__format_type(const struct perf_pmu *pmu, const char *name)

tools/perf/util/pmu.c

1391

struct perf_pmu_format *format = pmu_find_format(&pmu->format, name);

tools/perf/util/pmu.c

1396

perf_pmu_format__load(pmu, format);

tools/perf/util/pmu.c

1487

static int pmu_config_term(const struct perf_pmu *pmu,

tools/perf/util/pmu.c

1543

assert(pmu->is_core);

tools/perf/util/pmu.c

1546

attr->config |= (__u64)pmu->type << PERF_PMU_TYPE_SHIFT;

tools/perf/util/pmu.c

1561

assert(pmu->is_core);

tools/perf/util/pmu.c

1564

attr->config |= (__u64)pmu->type << PERF_PMU_TYPE_SHIFT;

tools/perf/util/pmu.c

1579

format = pmu_find_format(&pmu->format, term->config);

tools/perf/util/pmu.c

1581

char *pmu_term = pmu_formats_string(&pmu->format);

tools/perf/util/pmu.c

1587

term->config, pmu->name) < 0)

tools/perf/util/pmu.c

1601

perf_pmu_format__load(pmu, format);

tools/perf/util/pmu.c

164

static void perf_pmu_format__load(const struct perf_pmu *pmu, struct perf_pmu_format *format)

tools/perf/util/pmu.c

1680

int perf_pmu__config_terms(const struct perf_pmu *pmu,

tools/perf/util/pmu.c

1688

if (perf_pmu__is_hwmon(pmu))

tools/perf/util/pmu.c

1689

return hwmon_pmu__config_terms(pmu, attr, terms, err);

tools/perf/util/pmu.c

1690

if (perf_pmu__is_drm(pmu))

tools/perf/util/pmu.c

1691

return drm_pmu__config_terms(pmu, attr, terms, err);

tools/perf/util/pmu.c

1694

if (pmu_config_term(pmu, attr, term, terms, zero, apply_hardcoded, err))

tools/perf/util/pmu.c

1706

int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr,

tools/perf/util/pmu.c

1711

bool zero = !!pmu->perf_event_attr_init_default;

tools/perf/util/pmu.c

1714

if (perf_pmu__is_fake(pmu))

tools/perf/util/pmu.c

1717

return perf_pmu__config_terms(pmu, attr, head_terms, zero, apply_hardcoded, err);

tools/perf/util/pmu.c

172

if (!perf_pmu__pathname_scnprintf(path, sizeof(path), pmu->name, "format"))

tools/perf/util/pmu.c

1720

static struct perf_pmu_alias *pmu_find_alias(struct perf_pmu *pmu,

tools/perf/util/pmu.c

1732

if (pmu_find_format(&pmu->format, term->config))

tools/perf/util/pmu.c

1744

alias = perf_pmu__find_alias(pmu, name, /*load=*/ true);

tools/perf/util/pmu.c

1745

if (alias || pmu->cpu_aliases_added)

tools/perf/util/pmu.c

1749

if ((pmu_events_table__find_event(pmu->events_table, pmu, name,

tools/perf/util/pmu.c

1751

pmu) == 0) ||

tools/perf/util/pmu.c

1752

(pmu->is_core &&

tools/perf/util/pmu.c

1754

pmu, name,

tools/perf/util/pmu.c

1756

pmu) == 0)) {

tools/perf/util/pmu.c

1757

alias = perf_pmu__find_alias(pmu, name, /*load=*/ false);

tools/perf/util/pmu.c

1763

static int check_info_data(struct perf_pmu *pmu,

tools/perf/util/pmu.c

1769

read_alias_info(pmu, alias);

tools/perf/util/pmu.c

1806

static int perf_pmu__parse_terms_to_attr(struct perf_pmu *pmu, const char *terms_str,

tools/perf/util/pmu.c

1819

ret = perf_pmu__config(pmu, attr, &terms, /*apply_hardcoded=*/true, /*err=*/NULL);

tools/perf/util/pmu.c

1828

int perf_pmu__check_alias(struct perf_pmu *pmu, struct parse_events_terms *head_terms,

tools/perf/util/pmu.c

1850

if (perf_pmu__is_hwmon(pmu)) {

tools/perf/util/pmu.c

1854

if (perf_pmu__is_drm(pmu)) {

tools/perf/util/pmu.c

1855

ret = drm_pmu__check_alias(pmu, head_terms, info, err);

tools/perf/util/pmu.c

1860

if (perf_pmu__is_fake(pmu))

tools/perf/util/pmu.c

1864

alias = pmu_find_alias(pmu, term);

tools/perf/util/pmu.c

1876

ret = check_info_data(pmu, alias, info, err, term->err_term);

tools/perf/util/pmu.c

1883

ret = perf_pmu__parse_terms_to_attr(pmu, alias->legacy_terms, &attr);

tools/perf/util/pmu.c

190

static int perf_pmu__format_parse(struct perf_pmu *pmu, int dirfd, bool eager_load)

tools/perf/util/pmu.c

1935

int perf_pmu__find_event(struct perf_pmu *pmu, const char *event, void *state, pmu_event_callback cb)

tools/perf/util/pmu.c

1944

return perf_pmu__for_each_event(pmu, /*skip_duplicate_pmus=*/ false,

tools/perf/util/pmu.c

1959

bool perf_pmu__has_format(const struct perf_pmu *pmu, const char *name)

tools/perf/util/pmu.c

1963

list_for_each_entry(format, &pmu->format, list) {

tools/perf/util/pmu.c

1970

int perf_pmu__for_each_format(struct perf_pmu *pmu, void *state, pmu_format_callback cb)

tools/perf/util/pmu.c

2010

list_for_each_entry(format, &pmu->format, list) {

tools/perf/util/pmu.c

2011

perf_pmu_format__load(pmu, format);

tools/perf/util/pmu.c

2016

if (!pmu->is_core)

tools/perf/util/pmu.c

2037

bool perf_pmu__supports_legacy_cache(const struct perf_pmu *pmu)

tools/perf/util/pmu.c

2039

return pmu->is_core;

tools/perf/util/pmu.c

2042

bool perf_pmu__auto_merge_stats(const struct perf_pmu *pmu)

tools/perf/util/pmu.c

2044

return !pmu->is_core || perf_pmus__num_core_pmus() == 1;

tools/perf/util/pmu.c

2047

bool perf_pmu__have_event(struct perf_pmu *pmu, const char *name)

tools/perf/util/pmu.c

205

format = perf_pmu__new_format(&pmu->format, name);

tools/perf/util/pmu.c

2051

if (perf_pmu__is_tool(pmu) && tool_pmu__skip_event(name))

tools/perf/util/pmu.c

2053

if (perf_pmu__is_tracepoint(pmu))

tools/perf/util/pmu.c

2054

return tp_pmu__have_event(pmu, name);

tools/perf/util/pmu.c

2055

if (perf_pmu__is_hwmon(pmu))

tools/perf/util/pmu.c

2056

return hwmon_pmu__have_event(pmu, name);

tools/perf/util/pmu.c

2057

if (perf_pmu__is_drm(pmu))

tools/perf/util/pmu.c

2058

return drm_pmu__have_event(pmu, name);

tools/perf/util/pmu.c

2059

if (perf_pmu__find_alias(pmu, name, /*load=*/ true) != NULL)

tools/perf/util/pmu.c

2061

if (pmu->cpu_aliases_added || (!pmu->events_table && !pmu->is_core))

tools/perf/util/pmu.c

2063

if (pmu_events_table__find_event(pmu->events_table, pmu, name, NULL, NULL) == 0)

tools/perf/util/pmu.c

2065

return pmu->is_core &&

tools/perf/util/pmu.c

2067

pmu, name, NULL, NULL) == 0;

tools/perf/util/pmu.c

2070

size_t perf_pmu__num_events(struct perf_pmu *pmu)

tools/perf/util/pmu.c

2074

if (perf_pmu__is_tracepoint(pmu))

tools/perf/util/pmu.c

2075

return tp_pmu__num_events(pmu);

tools/perf/util/pmu.c

2076

if (perf_pmu__is_hwmon(pmu))

tools/perf/util/pmu.c

2077

return hwmon_pmu__num_events(pmu);

tools/perf/util/pmu.c

2078

if (perf_pmu__is_drm(pmu))

tools/perf/util/pmu.c

2079

return drm_pmu__num_events(pmu);

tools/perf/util/pmu.c

2081

pmu_aliases_parse(pmu);

tools/perf/util/pmu.c

2082

nr = pmu->sysfs_aliases + pmu->sys_json_aliases;

tools/perf/util/pmu.c

2084

if (pmu->cpu_aliases_added) {

tools/perf/util/pmu.c

2085

nr += pmu->cpu_json_aliases;

tools/perf/util/pmu.c

2086

} else if (pmu->events_table || pmu->is_core) {

tools/perf/util/pmu.c

2087

nr += pmu_events_table__num_events(pmu->events_table, pmu);

tools/perf/util/pmu.c

2088

if (pmu->is_core) {

tools/perf/util/pmu.c

2090

perf_pmu__default_core_events_table(), pmu);

tools/perf/util/pmu.c

2092

nr -= pmu->cpu_common_json_aliases;

tools/perf/util/pmu.c

2094

assert(pmu->cpu_json_aliases == 0 && pmu->cpu_common_json_aliases == 0);

tools/perf/util/pmu.c

2097

if (perf_pmu__is_tool(pmu))

tools/perf/util/pmu.c

2100

return pmu->selectable ? nr + 1 : nr;

tools/perf/util/pmu.c

2110

static char *format_alias(char *buf, int len, const struct perf_pmu *pmu,

tools/perf/util/pmu.c

2116

size_t pmu_name_len = pmu_deduped_name_len(pmu, pmu->name,

tools/perf/util/pmu.c

2122

snprintf(buf, len, "%.*s/%s/", (int)pmu_name_len, pmu->name, alias->name);

tools/perf/util/pmu.c

2132

snprintf(buf, len, "%.*s/%s/", (int)pmu_name_len, pmu->name, alias->name);

tools/perf/util/pmu.c

2135

used = snprintf(buf, len, "%.*s/%s", (int)pmu_name_len, pmu->name, alias->name);

tools/perf/util/pmu.c

2157

static bool perf_pmu_alias__check_deprecated(struct perf_pmu *pmu, struct perf_pmu_alias *alias)

tools/perf/util/pmu.c

2183

if (perf_pmu__parse_terms_to_attr(pmu, check_terms, &attr) != 0) {

tools/perf/util/pmu.c

2193

int perf_pmu__for_each_event(struct perf_pmu *pmu, bool skip_duplicate_pmus,

tools/perf/util/pmu.c

2198

.pmu = pmu,

tools/perf/util/pmu.c

2205

if (perf_pmu__is_tracepoint(pmu))

tools/perf/util/pmu.c

2206

return tp_pmu__for_each_event(pmu, state, cb);

tools/perf/util/pmu.c

2207

if (perf_pmu__is_hwmon(pmu))

tools/perf/util/pmu.c

2208

return hwmon_pmu__for_each_event(pmu, state, cb);

tools/perf/util/pmu.c

2209

if (perf_pmu__is_drm(pmu))

tools/perf/util/pmu.c

2210

return drm_pmu__for_each_event(pmu, state, cb);

tools/perf/util/pmu.c

2212

pmu_aliases_parse(pmu);

tools/perf/util/pmu.c

2213

pmu_add_cpu_aliases(pmu);

tools/perf/util/pmu.c

2214

hashmap__for_each_entry(pmu->aliases, entry, bkt) {

tools/perf/util/pmu.c

2218

if (perf_pmu__is_tool(pmu) && tool_pmu__skip_event(event->name))

tools/perf/util/pmu.c

2221

info.pmu_name = event->pmu_name ?: pmu->name;

tools/perf/util/pmu.c

2222

pmu_name_len = pmu_deduped_name_len(pmu, info.pmu_name,

tools/perf/util/pmu.c

2229

info.name = format_alias(buf, sizeof(buf), pmu, event,

tools/perf/util/pmu.c

2231

if (pmu->is_core) {

tools/perf/util/pmu.c

2250

info.deprecated = perf_pmu_alias__check_deprecated(pmu, event);

tools/perf/util/pmu.c

2255

if (pmu->selectable) {

tools/perf/util/pmu.c

2257

snprintf(buf, sizeof(buf), "%s//", pmu->name);

tools/perf/util/pmu.c

2264

info.pmu_name = pmu->name;

tools/perf/util/pmu.c

2272

static bool perf_pmu___name_match(const struct perf_pmu *pmu, const char *to_match, bool wildcard)

tools/perf/util/pmu.c

2275

pmu->name,

tools/perf/util/pmu.c

2276

pmu->alias_name,

tools/perf/util/pmu.c

2278

if (pmu->is_core) {

tools/perf/util/pmu.c

2299

if (!pmu->is_uncore) {

tools/perf/util/pmu.c

2337

bool perf_pmu__name_wildcard_match(const struct perf_pmu *pmu, const char *to_match)

tools/perf/util/pmu.c

2339

return perf_pmu___name_match(pmu, to_match, /*wildcard=*/true);

tools/perf/util/pmu.c

2348

bool perf_pmu__name_no_suffix_match(const struct perf_pmu *pmu, const char *to_match)

tools/perf/util/pmu.c

2350

return perf_pmu___name_match(pmu, to_match, /*wildcard=*/false);

tools/perf/util/pmu.c

2353

bool perf_pmu__is_software(const struct perf_pmu *pmu)

tools/perf/util/pmu.c

2361

if (pmu->is_core || pmu->is_uncore || pmu->auxtrace)

tools/perf/util/pmu.c

2363

switch (pmu->type) {

tools/perf/util/pmu.c

2374

if (!strcmp(pmu->name, known_sw_pmus[i]))

tools/perf/util/pmu.c

238

static int pmu_format(struct perf_pmu *pmu, int dirfd, const char *name, bool eager_load)

tools/perf/util/pmu.c

2380

bool perf_pmu__benefits_from_affinity(struct perf_pmu *pmu)

tools/perf/util/pmu.c

2382

if (!pmu)

tools/perf/util/pmu.c

2389

return pmu->type <= PERF_PMU_TYPE_PE_END;

tools/perf/util/pmu.c

2392

FILE *perf_pmu__open_file(const struct perf_pmu *pmu, const char *name)

tools/perf/util/pmu.c

2396

if (!perf_pmu__pathname_scnprintf(path, sizeof(path), pmu->name, name) ||

tools/perf/util/pmu.c

2403

FILE *perf_pmu__open_file_at(const struct perf_pmu *pmu, int dirfd, const char *name)

tools/perf/util/pmu.c

2407

fd = perf_pmu__pathname_fd(dirfd, pmu->name, name, O_RDONLY);

tools/perf/util/pmu.c

2414

int perf_pmu__scan_file(const struct perf_pmu *pmu, const char *name, const char *fmt,

tools/perf/util/pmu.c

2422

file = perf_pmu__open_file(pmu, name);

tools/perf/util/pmu.c

2431

int perf_pmu__scan_file_at(const struct perf_pmu *pmu, int dirfd, const char *name,

tools/perf/util/pmu.c

2439

file = perf_pmu__open_file_at(pmu, dirfd, name);

tools/perf/util/pmu.c

2448

bool perf_pmu__file_exists(const struct perf_pmu *pmu, const char *name)

tools/perf/util/pmu.c

2452

if (!perf_pmu__pathname_scnprintf(path, sizeof(path), pmu->name, name))

tools/perf/util/pmu.c

247

if (perf_pmu__format_parse(pmu, fd, eager_load))

tools/perf/util/pmu.c

2482

static void perf_pmu__del_caps(struct perf_pmu *pmu)

tools/perf/util/pmu.c

2486

list_for_each_entry_safe(caps, tmp, &pmu->caps, list) {

tools/perf/util/pmu.c

2494

struct perf_pmu_caps *perf_pmu__get_cap(struct perf_pmu *pmu, const char *name)

tools/perf/util/pmu.c

2498

list_for_each_entry(caps, &pmu->caps, list) {

tools/perf/util/pmu.c

2510

int perf_pmu__caps_parse(struct perf_pmu *pmu)

tools/perf/util/pmu.c

2517

if (pmu->caps_initialized)

tools/perf/util/pmu.c

2518

return pmu->nr_caps;

tools/perf/util/pmu.c

2520

pmu->nr_caps = 0;

tools/perf/util/pmu.c

2522

if (!perf_pmu__pathname_scnprintf(caps_path, sizeof(caps_path), pmu->name, "caps"))

tools/perf/util/pmu.c

2527

pmu->caps_initialized = true;

tools/perf/util/pmu.c

2552

(perf_pmu__new_caps(&pmu->caps, name, value) < 0)) {

tools/perf/util/pmu.c

2557

pmu->nr_caps++;

tools/perf/util/pmu.c

2563

pmu->caps_initialized = true;

tools/perf/util/pmu.c

2564

return pmu->nr_caps;

tools/perf/util/pmu.c

2567

static void perf_pmu__compute_config_masks(struct perf_pmu *pmu)

tools/perf/util/pmu.c

2571

if (pmu->config_masks_computed)

tools/perf/util/pmu.c

2574

list_for_each_entry(format, &pmu->format, list) {

tools/perf/util/pmu.c

2581

pmu->config_masks_present = true;

tools/perf/util/pmu.c

2582

mask = &pmu->config_masks[format->value];

tools/perf/util/pmu.c

2587

pmu->config_masks_computed = true;

tools/perf/util/pmu.c

2590

void perf_pmu__warn_invalid_config(struct perf_pmu *pmu, __u64 config,

tools/perf/util/pmu.c

2597

perf_pmu__compute_config_masks(pmu);

tools/perf/util/pmu.c

2602

if (!pmu->config_masks_present)

tools/perf/util/pmu.c

2605

bits = config & ~pmu->config_masks[config_num];

tools/perf/util/pmu.c

2616

bool perf_pmu__wildcard_match(const struct perf_pmu *pmu, const char *wildcard_to_match)

tools/perf/util/pmu.c

2619

pmu->name,

tools/perf/util/pmu.c

2620

pmu->alias_name,

tools/perf/util/pmu.c

2693

void perf_pmu__delete(struct perf_pmu *pmu)

tools/perf/util/pmu.c

2695

if (!pmu)

tools/perf/util/pmu.c

2698

if (perf_pmu__is_hwmon(pmu))

tools/perf/util/pmu.c

2699

hwmon_pmu__exit(pmu);

tools/perf/util/pmu.c

2700

else if (perf_pmu__is_drm(pmu))

tools/perf/util/pmu.c

2701

drm_pmu__exit(pmu);

tools/perf/util/pmu.c

2703

perf_pmu__del_formats(&pmu->format);

tools/perf/util/pmu.c

2704

perf_pmu__del_aliases(pmu);

tools/perf/util/pmu.c

2705

perf_pmu__del_caps(pmu);

tools/perf/util/pmu.c

2707

perf_cpu_map__put(pmu->cpus);

tools/perf/util/pmu.c

2709

zfree(&pmu->name);

tools/perf/util/pmu.c

2710

zfree(&pmu->alias_name);

tools/perf/util/pmu.c

2711

zfree(&pmu->id);

tools/perf/util/pmu.c

2712

free(pmu);

tools/perf/util/pmu.c

2715

const char *perf_pmu__name_from_config(struct perf_pmu *pmu, u64 config)

tools/perf/util/pmu.c

2720

if (!pmu)

tools/perf/util/pmu.c

2723

pmu_aliases_parse(pmu);

tools/perf/util/pmu.c

2724

pmu_add_cpu_aliases(pmu);

tools/perf/util/pmu.c

2725

hashmap__for_each_entry(pmu->aliases, entry, bkt) {

tools/perf/util/pmu.c

2728

int ret = perf_pmu__parse_terms_to_attr(pmu, event->terms, &attr);

tools/perf/util/pmu.c

295

static int perf_pmu__parse_scale(struct perf_pmu *pmu, struct perf_pmu_alias *alias)

tools/perf/util/pmu.c

307

scnprintf(path + len, sizeof(path) - len, "%s/events/%s.scale", pmu->name, alias->name);

tools/perf/util/pmu.c

331

static int perf_pmu__parse_unit(struct perf_pmu *pmu, struct perf_pmu_alias *alias)

tools/perf/util/pmu.c

342

scnprintf(path + len, sizeof(path) - len, "%s/events/%s.unit", pmu->name, alias->name);

tools/perf/util/pmu.c

397

static void perf_pmu__parse_per_pkg(struct perf_pmu *pmu, struct perf_pmu_alias *alias)

tools/perf/util/pmu.c

399

alias->per_pkg = perf_pmu__parse_event_source_bool(pmu->name, alias->name, "per-pkg");

tools/perf/util/pmu.c

402

static void perf_pmu__parse_snapshot(struct perf_pmu *pmu, struct perf_pmu_alias *alias)

tools/perf/util/pmu.c

404

alias->snapshot = perf_pmu__parse_event_source_bool(pmu->name, alias->name, "snapshot");

tools/perf/util/pmu.c

423

static void perf_pmu__del_aliases(struct perf_pmu *pmu)

tools/perf/util/pmu.c

428

if (!pmu->aliases)

tools/perf/util/pmu.c

431

hashmap__for_each_entry(pmu->aliases, entry, bkt)

tools/perf/util/pmu.c

434

hashmap__free(pmu->aliases);

tools/perf/util/pmu.c

435

pmu->aliases = NULL;

tools/perf/util/pmu.c

438

static struct perf_pmu_alias *perf_pmu__find_alias(struct perf_pmu *pmu,

tools/perf/util/pmu.c

446

if (hashmap__find(pmu->aliases, name, &alias))

tools/perf/util/pmu.c

449

if (!load || pmu->sysfs_aliases_loaded)

tools/perf/util/pmu.c

461

has_sysfs_event = perf_pmu__file_exists(pmu, event_file_name);

tools/perf/util/pmu.c

466

has_sysfs_event = perf_pmu__file_exists(pmu, event_file_name);

tools/perf/util/pmu.c

469

pmu_aliases_parse(pmu);

tools/perf/util/pmu.c

470

if (hashmap__find(pmu->aliases, name, &alias))

tools/perf/util/pmu.c

495

static void read_alias_info(struct perf_pmu *pmu, struct perf_pmu_alias *alias)

tools/perf/util/pmu.c

503

perf_pmu__parse_unit(pmu, alias);

tools/perf/util/pmu.c

504

perf_pmu__parse_scale(pmu, alias);

tools/perf/util/pmu.c

505

perf_pmu__parse_per_pkg(pmu, alias);

tools/perf/util/pmu.c

506

perf_pmu__parse_snapshot(pmu, alias);

tools/perf/util/pmu.c

510

struct perf_pmu *pmu;

tools/perf/util/pmu.c

522

read_alias_info(data->pmu, data->alias);

tools/perf/util/pmu.c

558

static int perf_pmu__new_alias(struct perf_pmu *pmu, const char *name,

tools/perf/util/pmu.c

567

if (perf_pmu__find_alias(pmu, name, /*load=*/ false)) {

tools/perf/util/pmu.c

578

if (pe->pmu && strcmp(pe->pmu, "default_core"))

tools/perf/util/pmu.c

579

pmu_name = pe->pmu;

tools/perf/util/pmu.c

642

if (pmu->events_table || pmu->is_core) {

tools/perf/util/pmu.c

645

.pmu = pmu,

tools/perf/util/pmu.c

649

if ((pmu_events_table__find_event(pmu->events_table, pmu, name,

tools/perf/util/pmu.c

655

pmu->cpu_common_json_aliases++;

tools/perf/util/pmu.c

657

if (pmu->is_core) {

tools/perf/util/pmu.c

662

pmu, name, update_alias, &data) == 0)

tools/perf/util/pmu.c

663

pmu->cpu_common_json_aliases++;

tools/perf/util/pmu.c

666

pmu->sysfs_aliases++;

tools/perf/util/pmu.c

669

pmu->cpu_json_aliases++;

tools/perf/util/pmu.c

672

pmu->sys_json_aliases++;

tools/perf/util/pmu.c

676

hashmap__set(pmu->aliases, alias->name, alias, /*old_key=*/ NULL, &old_alias);

tools/perf/util/pmu.c

702

static int __pmu_aliases_parse(struct perf_pmu *pmu, int events_dir_fd)

tools/perf/util/pmu.c

728

if (perf_pmu__new_alias(pmu, name, /*desc=*/ NULL,

tools/perf/util/pmu.c

735

pmu->sysfs_aliases_loaded = true;

tools/perf/util/pmu.c

739

static int pmu_aliases_parse(struct perf_pmu *pmu)

tools/perf/util/pmu.c

745

if (pmu->sysfs_aliases_loaded)

tools/perf/util/pmu.c

751

scnprintf(path + len, sizeof(path) - len, "%s/events", pmu->name);

tools/perf/util/pmu.c

755

pmu->sysfs_aliases_loaded = true;

tools/perf/util/pmu.c

758

ret = __pmu_aliases_parse(pmu, events_dir_fd);

tools/perf/util/pmu.c

763

static int pmu_aliases_parse_eager(struct perf_pmu *pmu, int sysfs_fd)

tools/perf/util/pmu.c

768

scnprintf(path, sizeof(path), "%s/events", pmu->name);

tools/perf/util/pmu.c

771

pmu->sysfs_aliases_loaded = true;

tools/perf/util/pmu.c

774

ret = __pmu_aliases_parse(pmu, events_dir_fd);

tools/perf/util/pmu.c

898

static size_t pmu_deduped_name_len(const struct perf_pmu *pmu, const char *name,

tools/perf/util/pmu.c

901

return skip_duplicate_pmus && !pmu->is_core

tools/perf/util/pmu.h

126

void (*perf_event_attr_init_default)(const struct perf_pmu *pmu,

tools/perf/util/pmu.h

222

const struct perf_pmu *pmu;

tools/perf/util/pmu.h

265

void pmu_add_sys_aliases(struct perf_pmu *pmu);

tools/perf/util/pmu.h

266

int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr,

tools/perf/util/pmu.h

270

int perf_pmu__config_terms(const struct perf_pmu *pmu,

tools/perf/util/pmu.h

275

__u64 perf_pmu__format_bits(const struct perf_pmu *pmu, const char *name);

tools/perf/util/pmu.h

276

int perf_pmu__format_type(const struct perf_pmu *pmu, const char *name);

tools/perf/util/pmu.h

277

int perf_pmu__check_alias(struct perf_pmu *pmu, struct parse_events_terms *head_terms,

tools/perf/util/pmu.h

280

int perf_pmu__find_event(struct perf_pmu *pmu, const char *event, void *state, pmu_event_callback cb);

tools/perf/util/pmu.h

287

bool perf_pmu__has_format(const struct perf_pmu *pmu, const char *name);

tools/perf/util/pmu.h

288

int perf_pmu__for_each_format(struct perf_pmu *pmu, void *state, pmu_format_callback cb);

tools/perf/util/pmu.h

292

bool perf_pmu__supports_legacy_cache(const struct perf_pmu *pmu);

tools/perf/util/pmu.h

293

bool perf_pmu__auto_merge_stats(const struct perf_pmu *pmu);

tools/perf/util/pmu.h

294

bool perf_pmu__have_event(struct perf_pmu *pmu, const char *name);

tools/perf/util/pmu.h

295

size_t perf_pmu__num_events(struct perf_pmu *pmu);

tools/perf/util/pmu.h

296

int perf_pmu__for_each_event(struct perf_pmu *pmu, bool skip_duplicate_pmus,

tools/perf/util/pmu.h

298

bool perf_pmu__name_wildcard_match(const struct perf_pmu *pmu, const char *to_match);

tools/perf/util/pmu.h

299

bool perf_pmu__name_no_suffix_match(const struct perf_pmu *pmu, const char *to_match);

tools/perf/util/pmu.h

305

bool perf_pmu__is_software(const struct perf_pmu *pmu);

tools/perf/util/pmu.h

306

bool perf_pmu__benefits_from_affinity(struct perf_pmu *pmu);

tools/perf/util/pmu.h

308

FILE *perf_pmu__open_file(const struct perf_pmu *pmu, const char *name);

tools/perf/util/pmu.h

309

FILE *perf_pmu__open_file_at(const struct perf_pmu *pmu, int dirfd, const char *name);

tools/perf/util/pmu.h

311

int perf_pmu__scan_file(const struct perf_pmu *pmu, const char *name, const char *fmt, ...)

tools/perf/util/pmu.h

313

int perf_pmu__scan_file_at(const struct perf_pmu *pmu, int dirfd, const char *name,

tools/perf/util/pmu.h

316

bool perf_pmu__file_exists(const struct perf_pmu *pmu, const char *name);

tools/perf/util/pmu.h

320

void perf_pmu__arch_init(struct perf_pmu *pmu);

tools/perf/util/pmu.h

321

void pmu_add_cpu_aliases_table(struct perf_pmu *pmu,

tools/perf/util/pmu.h

328

struct perf_pmu_caps *perf_pmu__get_cap(struct perf_pmu *pmu, const char *name);

tools/perf/util/pmu.h

330

int perf_pmu__caps_parse(struct perf_pmu *pmu);

tools/perf/util/pmu.h

332

void perf_pmu__warn_invalid_config(struct perf_pmu *pmu, __u64 config,

tools/perf/util/pmu.h

335

void perf_pmu__warn_invalid_formats(struct perf_pmu *pmu);

tools/perf/util/pmu.h

337

bool perf_pmu__wildcard_match(const struct perf_pmu *pmu, const char *wildcard_to_match);

tools/perf/util/pmu.h

345

int perf_pmu__init(struct perf_pmu *pmu, __u32 type, const char *name);

tools/perf/util/pmu.h

349

void perf_pmu__delete(struct perf_pmu *pmu);

tools/perf/util/pmu.h

351

const char *perf_pmu__name_from_config(struct perf_pmu *pmu, u64 config);

tools/perf/util/pmu.h

352

bool perf_pmu__is_fake(const struct perf_pmu *pmu);

tools/perf/util/pmu.h

356

static inline enum pmu_kind perf_pmu__kind(const struct perf_pmu *pmu)

tools/perf/util/pmu.h

360

if (!pmu)

tools/perf/util/pmu.h

363

type = pmu->type;

tools/perf/util/pmus.c

113

struct perf_pmu *pmu, *tmp;

tools/perf/util/pmus.c

115

list_for_each_entry_safe(pmu, tmp, &core_pmus, list) {

tools/perf/util/pmus.c

116

list_del(&pmu->list);

tools/perf/util/pmus.c

118

perf_pmu__delete(pmu);

tools/perf/util/pmus.c

120

list_for_each_entry_safe(pmu, tmp, &other_pmus, list) {

tools/perf/util/pmus.c

121

list_del(&pmu->list);

tools/perf/util/pmus.c

123

perf_pmu__delete(pmu);

tools/perf/util/pmus.c

130

struct perf_pmu *pmu;

tools/perf/util/pmus.c

132

list_for_each_entry(pmu, &core_pmus, list) {

tools/perf/util/pmus.c

133

if (!strcmp(pmu->name, name) ||

tools/perf/util/pmus.c

134

(pmu->alias_name && !strcmp(pmu->alias_name, name)))

tools/perf/util/pmus.c

135

return pmu;

tools/perf/util/pmus.c

137

list_for_each_entry(pmu, &other_pmus, list) {

tools/perf/util/pmus.c

138

if (!strcmp(pmu->name, name) ||

tools/perf/util/pmus.c

139

(pmu->alias_name && !strcmp(pmu->alias_name, name)))

tools/perf/util/pmus.c

140

return pmu;

tools/perf/util/pmus.c

148

struct perf_pmu *pmu;

tools/perf/util/pmus.c

158

pmu = pmu_find(name);

tools/perf/util/pmus.c

159

if (pmu)

tools/perf/util/pmus.c

160

return pmu;

tools/perf/util/pmus.c

170

pmu = perf_pmu__lookup(core_pmu ? &core_pmus : &other_pmus, dirfd, name,

tools/perf/util/pmus.c

174

if (pmu)

tools/perf/util/pmus.c

175

return pmu;

tools/perf/util/pmus.c

187

pmu = pmu_find(name);

tools/perf/util/pmus.c

188

if (pmu)

tools/perf/util/pmus.c

189

return pmu;

tools/perf/util/pmus.c

201

struct perf_pmu *pmu;

tools/perf/util/pmus.c

209

pmu = pmu_find(name);

tools/perf/util/pmus.c

210

if (pmu)

tools/perf/util/pmus.c

211

return pmu;

tools/perf/util/pmus.c

293

struct perf_pmu *pmu;

tools/perf/util/pmus.c

295

list_for_each_entry(pmu, &core_pmus, list) {

tools/perf/util/pmus.c

296

if (pmu->type == type)

tools/perf/util/pmus.c

297

return pmu;

tools/perf/util/pmus.c

300

list_for_each_entry(pmu, &other_pmus, list) {

tools/perf/util/pmus.c

301

if (pmu->type == type)

tools/perf/util/pmus.c

302

return pmu;

tools/perf/util/pmus.c

310

struct perf_pmu *pmu = __perf_pmus__find_by_type(type);

tools/perf/util/pmus.c

312

if (pmu || (read_pmu_types == PERF_TOOL_PMU_TYPE_ALL_MASK))

tools/perf/util/pmus.c

313

return pmu;

tools/perf/util/pmus.c

326

pmu = __perf_pmus__find_by_type(type);

tools/perf/util/pmus.c

327

return pmu;

tools/perf/util/pmus.c

334

struct perf_pmu *perf_pmus__scan(struct perf_pmu *pmu)

tools/perf/util/pmus.c

336

bool use_core_pmus = !pmu || pmu->is_core;

tools/perf/util/pmus.c

338

if (!pmu) {

tools/perf/util/pmus.c

340

pmu = list_prepare_entry(pmu, &core_pmus, list);

tools/perf/util/pmus.c

343

list_for_each_entry_continue(pmu, &core_pmus, list)

tools/perf/util/pmus.c

344

return pmu;

tools/perf/util/pmus.c

346

pmu = NULL;

tools/perf/util/pmus.c

347

pmu = list_prepare_entry(pmu, &other_pmus, list);

tools/perf/util/pmus.c

349

list_for_each_entry_continue(pmu, &other_pmus, list)

tools/perf/util/pmus.c

350

return pmu;

tools/perf/util/pmus.c

354

struct perf_pmu *perf_pmus__scan_core(struct perf_pmu *pmu)

tools/perf/util/pmus.c

356

if (!pmu) {

tools/perf/util/pmus.c

358

return list_first_entry_or_null(&core_pmus, typeof(*pmu), list);

tools/perf/util/pmus.c

360

list_for_each_entry_continue(pmu, &core_pmus, list)

tools/perf/util/pmus.c

361

return pmu;

tools/perf/util/pmus.c

366

struct perf_pmu *perf_pmus__scan_for_event(struct perf_pmu *pmu, const char *event)

tools/perf/util/pmus.c

368

bool use_core_pmus = !pmu || pmu->is_core;

tools/perf/util/pmus.c

370

if (!pmu) {

tools/perf/util/pmus.c

391

pmu = list_prepare_entry(pmu, &core_pmus, list);

tools/perf/util/pmus.c

394

list_for_each_entry_continue(pmu, &core_pmus, list)

tools/perf/util/pmus.c

395

return pmu;

tools/perf/util/pmus.c

397

pmu = NULL;

tools/perf/util/pmus.c

398

pmu = list_prepare_entry(pmu, &other_pmus, list);

tools/perf/util/pmus.c

400

list_for_each_entry_continue(pmu, &other_pmus, list)

tools/perf/util/pmus.c

401

return pmu;

tools/perf/util/pmus.c

405

struct perf_pmu *perf_pmus__scan_matching_wildcard(struct perf_pmu *pmu, const char *wildcard)

tools/perf/util/pmus.c

407

bool use_core_pmus = !pmu || pmu->is_core;

tools/perf/util/pmus.c

409

if (!pmu) {

tools/perf/util/pmus.c

435

pmu = list_prepare_entry(pmu, &core_pmus, list);

tools/perf/util/pmus.c

438

list_for_each_entry_continue(pmu, &core_pmus, list) {

tools/perf/util/pmus.c

439

if (perf_pmu__wildcard_match(pmu, wildcard))

tools/perf/util/pmus.c

440

return pmu;

tools/perf/util/pmus.c

442

pmu = NULL;

tools/perf/util/pmus.c

443

pmu = list_prepare_entry(pmu, &other_pmus, list);

tools/perf/util/pmus.c

445

list_for_each_entry_continue(pmu, &other_pmus, list) {

tools/perf/util/pmus.c

446

if (perf_pmu__wildcard_match(pmu, wildcard))

tools/perf/util/pmus.c

447

return pmu;

tools/perf/util/pmus.c

452

static struct perf_pmu *perf_pmus__scan_skip_duplicates(struct perf_pmu *pmu)

tools/perf/util/pmus.c

454

bool use_core_pmus = !pmu || pmu->is_core;

tools/perf/util/pmus.c

456

const char *last_pmu_name = (pmu && pmu->name) ? pmu->name : "";

tools/perf/util/pmus.c

458

if (!pmu) {

tools/perf/util/pmus.c

460

pmu = list_prepare_entry(pmu, &core_pmus, list);

tools/perf/util/pmus.c

462

last_pmu_name_len = pmu_name_len_no_suffix(pmu->name ?: "");

tools/perf/util/pmus.c

465

list_for_each_entry_continue(pmu, &core_pmus, list) {

tools/perf/util/pmus.c

466

int pmu_name_len = pmu_name_len_no_suffix(pmu->name ?: "");

tools/perf/util/pmus.c

469

!strncmp(last_pmu_name, pmu->name ?: "", pmu_name_len))

tools/perf/util/pmus.c

472

return pmu;

tools/perf/util/pmus.c

474

pmu = NULL;

tools/perf/util/pmus.c

475

pmu = list_prepare_entry(pmu, &other_pmus, list);

tools/perf/util/pmus.c

477

list_for_each_entry_continue(pmu, &other_pmus, list) {

tools/perf/util/pmus.c

478

int pmu_name_len = pmu_name_len_no_suffix(pmu->name ?: "");

tools/perf/util/pmus.c

481

!strncmp(last_pmu_name, pmu->name ?: "", pmu_name_len))

tools/perf/util/pmus.c

484

return pmu;

tools/perf/util/pmus.c

491

struct perf_pmu *pmu = NULL;

tools/perf/util/pmus.c

493

while ((pmu = perf_pmus__scan(pmu)) != NULL) {

tools/perf/util/pmus.c

494

if (!strcmp(pmu->name, str))

tools/perf/util/pmus.c

495

return pmu;

tools/perf/util/pmus.c

497

if (!strncmp(pmu->name, "uncore_", 7)) {

tools/perf/util/pmus.c

498

if (!strcmp(pmu->name + 7, str))

tools/perf/util/pmus.c

499

return pmu;

tools/perf/util/pmus.c

502

if (!strncmp(pmu->name, "cpu_", 4)) {

tools/perf/util/pmus.c

503

if (!strcmp(pmu->name + 4, str))

tools/perf/util/pmus.c

504

return pmu;

tools/perf/util/pmus.c

513

const struct perf_pmu *pmu;

tools/perf/util/pmus.c

543

a_iscpu = as->pmu ? as->pmu->is_core : true;

tools/perf/util/pmus.c

544

b_iscpu = bs->pmu ? bs->pmu->is_core : true;

tools/perf/util/pmus.c

549

if (as->pmu != bs->pmu) {

tools/perf/util/pmus.c

582

pr_err("Unexpected event %s/%s/\n", info->pmu->name, info->name);

tools/perf/util/pmus.c

585

assert(info->pmu != NULL || info->name != NULL);

tools/perf/util/pmus.c

587

s->pmu = info->pmu;

tools/perf/util/pmus.c

606

struct perf_pmu *pmu;

tools/perf/util/pmus.c

619

pmu = NULL;

tools/perf/util/pmus.c

621

while ((pmu = scan_fn(pmu)) != NULL)

tools/perf/util/pmus.c

622

len += perf_pmu__num_events(pmu);

tools/perf/util/pmus.c

629

pmu = NULL;

tools/perf/util/pmus.c

635

while ((pmu = scan_fn(pmu)) != NULL) {

tools/perf/util/pmus.c

636

perf_pmu__for_each_event(pmu, skip_duplicate_pmus, &state,

tools/perf/util/pmus.c

648

aliases[j].pmu->type,

tools/perf/util/pmus.c

721

struct perf_pmu *pmu = NULL;

tools/perf/util/pmus.c

728

while ((pmu = scan_fn(pmu)) != NULL) {

tools/perf/util/pmus.c

734

int len = pmu_name_len_no_suffix(pmu->name);

tools/perf/util/pmus.c

737

if (!pmu->is_core)

tools/perf/util/pmus.c

740

strbuf_addf(&format_args.short_string, "%.*s/", len, pmu->name);

tools/perf/util/pmus.c

741

strbuf_addf(&format_args.long_string, "%.*s/", len, pmu->name);

tools/perf/util/pmus.c

742

perf_pmu__for_each_format(pmu, &format_args, build_format_string);

tools/perf/util/pmus.c

753

pmu->type,

tools/perf/util/pmus.c

770

struct perf_pmu *pmu = perf_pmus__find(pname);

tools/perf/util/pmus.c

772

return pmu && perf_pmu__have_event(pmu, name);

tools/perf/util/pmus.c

780

struct perf_pmu *pmu = NULL;

tools/perf/util/pmus.c

782

while ((pmu = perf_pmus__scan_core(pmu)) != NULL)

tools/perf/util/pmus.c

790

struct perf_pmu *pmu = NULL;

tools/perf/util/pmus.c

795

while ((pmu = perf_pmus__scan_core(pmu)) != NULL) {

tools/perf/util/pmus.c

796

if (!is_event_supported(PERF_TYPE_HARDWARE, PERF_COUNT_HW_CPU_CYCLES | ((__u64)pmu->type << PERF_PMU_TYPE_SHIFT)))

tools/perf/util/pmus.c

821

struct perf_pmu *pmu = perf_pmus__find_by_type(attr->type);

tools/perf/util/pmus.c

825

if (!pmu && legacy_core_type && perf_pmus__supports_extended_type()) {

tools/perf/util/pmus.c

828

pmu = perf_pmus__find_by_type(type);

tools/perf/util/pmus.c

830

if (!pmu && (legacy_core_type || type == PERF_TYPE_RAW)) {

tools/perf/util/pmus.c

839

pmu = perf_pmus__find_core_pmu();

tools/perf/util/pmus.c

841

return pmu;

tools/perf/util/pmus.c

846

struct perf_pmu *pmu = evsel->pmu;

tools/perf/util/pmus.c

848

if (pmu)

tools/perf/util/pmus.c

849

return pmu;

tools/perf/util/pmus.c

851

pmu = perf_pmus__find_by_attr(&evsel->core.attr);

tools/perf/util/pmus.c

852

((struct evsel *)evsel)->pmu = pmu;

tools/perf/util/pmus.c

853

return pmu;

tools/perf/util/pmus.h

22

struct perf_pmu *perf_pmus__scan(struct perf_pmu *pmu);

tools/perf/util/pmus.h

23

struct perf_pmu *perf_pmus__scan_core(struct perf_pmu *pmu);

tools/perf/util/pmus.h

24

struct perf_pmu *perf_pmus__scan_for_event(struct perf_pmu *pmu, const char *event);

tools/perf/util/pmus.h

25

struct perf_pmu *perf_pmus__scan_matching_wildcard(struct perf_pmu *pmu, const char *wildcard);

tools/perf/util/print-events.c

279

me->pmu_name = pm->pmu;

tools/perf/util/python.c

1358

evsel->pmu != evsel->metric_leader->pmu &&

tools/perf/util/python.c

1359

cur->pmu == evsel->metric_leader->pmu) {

tools/perf/util/python.c

1363

if (pos->pmu != evsel->pmu)

tools/perf/util/python.c

1819

if (!pos->pmu)

tools/perf/util/python.c

1822

strbuf_addf(&sb, "%s/%s/", pos->pmu->name, evsel__name(pos));

tools/perf/util/python.c

2092

const char *input, *pmu = NULL;

tools/perf/util/python.c

2100

if (!PyArg_ParseTuple(args, "s|sOO", &input, &pmu, &pcpus, &pthreads))

tools/perf/util/python.c

2107

ret = metricgroup__parse_groups(&evlist, pmu ?: "all", input,

tools/perf/util/python.c

2166

!add_to_dict(dict, "PMU", pm->pmu) ||

tools/perf/util/python.c

659

struct perf_pmu *pmu;

tools/perf/util/python.c

671

return PyUnicode_FromString(ppmu->pmu->name);

tools/perf/util/python.c

726

ret = perf_pmu__for_each_event(ppmu->pmu,

tools/perf/util/python.c

743

return PyUnicode_FromFormat("pmu(%s)", ppmu->pmu->name);

tools/perf/util/python.c

787

struct perf_pmu *pmu;

tools/perf/util/python.c

801

itr->pmu = perf_pmus__scan(/*pmu=*/NULL);

tools/perf/util/python.c

817

if (itr->pmu == NULL) {

tools/perf/util/python.c

824

ppmu->pmu = itr->pmu;

tools/perf/util/python.c

826

itr->pmu = perf_pmus__scan(itr->pmu);

tools/perf/util/s390-sample-raw.c

177

static char *get_counter_name(int set, int nr, struct perf_pmu *pmu)

tools/perf/util/s390-sample-raw.c

188

if (!pmu)

tools/perf/util/s390-sample-raw.c

191

if (cache_pmu == pmu && hashmap__find(cache, cache_key, &result))

tools/perf/util/s390-sample-raw.c

194

perf_pmu__for_each_event(pmu, /*skip_duplicate_pmus=*/ true,

tools/perf/util/s390-sample-raw.c

206

cache_pmu = pmu;

tools/perf/util/s390-sample-raw.c

210

if (cache_pmu == pmu && result) {

tools/perf/util/s390-sample-raw.c

225

static void s390_cpumcfdg_dump(struct perf_pmu *pmu, struct perf_sample *sample)

tools/perf/util/s390-sample-raw.c

250

char *ev_name = get_counter_name(ce.set, i, pmu);

tools/perf/util/s390-sample-raw.c

307

pai_data.event_nr, evsel->pmu);

tools/perf/util/s390-sample-raw.c

350

if (!evsel->pmu)

tools/perf/util/s390-sample-raw.c

351

evsel->pmu = perf_pmus__find("cpum_cf");

tools/perf/util/s390-sample-raw.c

355

s390_cpumcfdg_dump(evsel->pmu, sample);

tools/perf/util/s390-sample-raw.c

373

if (!evsel->pmu)

tools/perf/util/s390-sample-raw.c

374

evsel->pmu = perf_pmus__find_by_type(evsel->core.attr.type);

tools/perf/util/stat-display.c

780

struct perf_pmu *pmu = evsel__find_pmu(evsel);

tools/perf/util/stat-display.c

782

if (pmu == last_core_pmu)

tools/perf/util/stat-display.c

786

last_core_pmu = pmu;

tools/perf/util/stat-shadow.c

244

if (last_name && !strcmp(last_name, name) && last_pmu == evsel->pmu) {

tools/perf/util/stat-shadow.c

249

if (need_full_name && evsel->pmu)

tools/perf/util/stat-shadow.c

250

scnprintf(full_name, sizeof(full_name), "%s (%s)", name, evsel->pmu->name);

tools/perf/util/stat-shadow.c

257

last_pmu = evsel->pmu;

tools/perf/util/stat-shadow.c

69

evsel->pmu != evsel->metric_leader->pmu &&

tools/perf/util/stat-shadow.c

70

mexp->metric_events[i]->pmu == evsel->metric_leader->pmu) {

tools/perf/util/stat-shadow.c

74

if (pos->pmu != evsel->pmu)

tools/perf/util/stat.c

561

if (!evsel->pmu || !evsel->pmu->is_core || evsel__should_merge_hybrid(evsel, config))

tools/perf/util/tool_pmu.c

89

bool perf_pmu__is_tool(const struct perf_pmu *pmu)

tools/perf/util/tool_pmu.c

91

return pmu && pmu->type == PERF_PMU_TYPE_TOOL;

tools/perf/util/tool_pmu.c

96

return perf_pmu__is_tool(evsel->pmu);

tools/perf/util/tool_pmu.h

48

bool perf_pmu__is_tool(const struct perf_pmu *pmu);

tools/perf/util/tp_pmu.c

104

const struct perf_pmu *pmu;

tools/perf/util/tp_pmu.c

116

.pmu = args->pmu,

tools/perf/util/tp_pmu.c

117

.pmu_name = args->pmu->name,

tools/perf/util/tp_pmu.c

157

int tp_pmu__for_each_event(struct perf_pmu *pmu, void *state, pmu_event_callback cb)

tools/perf/util/tp_pmu.c

162

.pmu = pmu,

tools/perf/util/tp_pmu.c

182

size_t tp_pmu__num_events(struct perf_pmu *pmu __maybe_unused)

tools/perf/util/tp_pmu.c

190

bool tp_pmu__have_event(struct perf_pmu *pmu __maybe_unused, const char *name)

tools/perf/util/tp_pmu.c

96

bool perf_pmu__is_tracepoint(const struct perf_pmu *pmu)

tools/perf/util/tp_pmu.c

98

return pmu->type == PERF_TYPE_TRACEPOINT;

tools/perf/util/tp_pmu.h

14

bool perf_pmu__is_tracepoint(const struct perf_pmu *pmu);

tools/perf/util/tp_pmu.h

15

int tp_pmu__for_each_event(struct perf_pmu *pmu, void *state, pmu_event_callback cb);

tools/perf/util/tp_pmu.h

16

size_t tp_pmu__num_events(struct perf_pmu *pmu);

tools/perf/util/tp_pmu.h

17

bool tp_pmu__have_event(struct perf_pmu *pmu, const char *name);

tools/testing/selftests/kvm/riscv/get-reg-list.c

1150

KVM_SBI_EXT_SIMPLE_CONFIG(pmu, PMU);