arch/arm/mach-at91/pm.c

127

int (*config_pmc_ws)(void __iomem *pmc, u32 mode, u32 polarity);

arch/arm/mach-at91/pm.c

1449

const struct pmc_info *pmc;

arch/arm/mach-at91/pm.c

1455

soc_pm.data.pmc = of_iomap(pmc_np, 0);

arch/arm/mach-at91/pm.c

1457

if (!soc_pm.data.pmc) {

arch/arm/mach-at91/pm.c

1462

pmc = of_id->data;

arch/arm/mach-at91/pm.c

1463

soc_pm.data.uhp_udp_mask = pmc->uhp_udp_mask;

arch/arm/mach-at91/pm.c

1464

soc_pm.data.pmc_mckr_offset = pmc->mckr;

arch/arm/mach-at91/pm.c

1465

soc_pm.data.pmc_version = pmc->version;

arch/arm/mach-at91/pm.c

1466

soc_pm.data.pmc_mcks = pmc->mcks;

arch/arm/mach-at91/pm.c

257

if (!soc_pm.data.pmc || !soc_pm.data.shdwc || !soc_pm.ws_ids)

arch/arm/mach-at91/pm.c

261

writel(mode, soc_pm.data.pmc + AT91_PMC_FSMR);

arch/arm/mach-at91/pm.c

295

soc_pm.config_pmc_ws(soc_pm.data.pmc, mode, polarity);

arch/arm/mach-at91/pm.c

316

static int at91_sama5d2_config_pmc_ws(void __iomem *pmc, u32 mode, u32 polarity)

arch/arm/mach-at91/pm.c

318

writel(mode, pmc + AT91_PMC_FSMR);

arch/arm/mach-at91/pm.c

319

writel(polarity, pmc + AT91_PMC_FSPR);

arch/arm/mach-at91/pm.c

324

static int at91_sam9x60_config_pmc_ws(void __iomem *pmc, u32 mode, u32 polarity)

arch/arm/mach-at91/pm.c

326

writel(mode, pmc + AT91_PMC_FSMR);

arch/arm/mach-at91/pm.c

505

scsr = readl(soc_pm.data.pmc + AT91_PMC_SCSR);

arch/arm/mach-at91/pm.c

519

css = readl(soc_pm.data.pmc + AT91_PMC_PCKR(i)) & AT91_PMC_CSS;

arch/arm/mach-at91/pm.c

852

ratio = readl(soc_pm.data.pmc + AT91_PMC_RATIO);

arch/arm/mach-at91/pm.c

862

writel(ratio & ~AT91_PMC_RATIO_RATIO, soc_pm.data.pmc + AT91_PMC_RATIO);

arch/arm/mach-at91/pm.c

867

writel(ratio, soc_pm.data.pmc + AT91_PMC_RATIO);

arch/arm/mach-at91/pm.c

971

writel(AT91_PMC_PCK, soc_pm.data.pmc + AT91_PMC_SCDR);

arch/arm/mach-at91/pm.c

976

writel(AT91_PMC_PCK, soc_pm.data.pmc + AT91_PMC_SCDR);

arch/arm/mach-at91/pm.h

30

void __iomem *pmc;

arch/arm/mach-at91/pm_data-offsets.c

8

DEFINE(PM_DATA_PMC, offsetof(struct at91_pm_data, pmc));

arch/arm64/kvm/pmu-emul.c

100

if (kvm_pmu_counter_is_hyp(vcpu, pmc->idx))

arch/arm64/kvm/pmu-emul.c

103

return (pmc->idx < ARMV8_PMU_CYCLE_IDX && (val & ARMV8_PMU_PMCR_LP)) ||

arch/arm64/kvm/pmu-emul.c

104

(pmc->idx == ARMV8_PMU_CYCLE_IDX && (val & ARMV8_PMU_PMCR_LC));

arch/arm64/kvm/pmu-emul.c

107

static bool kvm_pmu_counter_can_chain(struct kvm_pmc *pmc)

arch/arm64/kvm/pmu-emul.c

109

return (!(pmc->idx & 1) && (pmc->idx + 1) < ARMV8_PMU_CYCLE_IDX &&

arch/arm64/kvm/pmu-emul.c

110

!kvm_pmc_has_64bit_overflow(pmc));

arch/arm64/kvm/pmu-emul.c

123

static u64 kvm_pmc_read_evtreg(const struct kvm_pmc *pmc)

arch/arm64/kvm/pmu-emul.c

125

return __vcpu_sys_reg(kvm_pmc_to_vcpu(pmc), counter_index_to_evtreg(pmc->idx));

arch/arm64/kvm/pmu-emul.c

128

static u64 kvm_pmu_get_pmc_value(struct kvm_pmc *pmc)

arch/arm64/kvm/pmu-emul.c

130

struct kvm_vcpu *vcpu = kvm_pmc_to_vcpu(pmc);

arch/arm64/kvm/pmu-emul.c

1316

struct kvm_pmc *pmc = kvm_vcpu_idx_to_pmc(vcpu, i);

arch/arm64/kvm/pmu-emul.c

1323

if (kvm_pmc_counts_at_el1(pmc) == kvm_pmc_counts_at_el2(pmc))

arch/arm64/kvm/pmu-emul.c

1326

kvm_pmu_create_perf_event(pmc);

arch/arm64/kvm/pmu-emul.c

133

reg = counter_index_to_reg(pmc->idx);

arch/arm64/kvm/pmu-emul.c

140

if (pmc->perf_event)

arch/arm64/kvm/pmu-emul.c

141

counter += perf_event_read_value(pmc->perf_event, &enabled,

arch/arm64/kvm/pmu-emul.c

144

if (!kvm_pmc_is_64bit(pmc))

arch/arm64/kvm/pmu-emul.c

160

static void kvm_pmu_set_pmc_value(struct kvm_pmc *pmc, u64 val, bool force)

arch/arm64/kvm/pmu-emul.c

162

struct kvm_vcpu *vcpu = kvm_pmc_to_vcpu(pmc);

arch/arm64/kvm/pmu-emul.c

165

kvm_pmu_release_perf_event(pmc);

arch/arm64/kvm/pmu-emul.c

167

reg = counter_index_to_reg(pmc->idx);

arch/arm64/kvm/pmu-emul.c

169

if (vcpu_mode_is_32bit(vcpu) && pmc->idx != ARMV8_PMU_CYCLE_IDX &&

arch/arm64/kvm/pmu-emul.c

184

kvm_pmu_create_perf_event(pmc);

arch/arm64/kvm/pmu-emul.c

215

static void kvm_pmu_release_perf_event(struct kvm_pmc *pmc)

arch/arm64/kvm/pmu-emul.c

217

if (pmc->perf_event) {

arch/arm64/kvm/pmu-emul.c

218

perf_event_disable(pmc->perf_event);

arch/arm64/kvm/pmu-emul.c

219

perf_event_release_kernel(pmc->perf_event);

arch/arm64/kvm/pmu-emul.c

220

pmc->perf_event = NULL;

arch/arm64/kvm/pmu-emul.c

23

static void kvm_pmu_create_perf_event(struct kvm_pmc *pmc);

arch/arm64/kvm/pmu-emul.c

230

static void kvm_pmu_stop_counter(struct kvm_pmc *pmc)

arch/arm64/kvm/pmu-emul.c

232

struct kvm_vcpu *vcpu = kvm_pmc_to_vcpu(pmc);

arch/arm64/kvm/pmu-emul.c

235

if (!pmc->perf_event)

arch/arm64/kvm/pmu-emul.c

238

val = kvm_pmu_get_pmc_value(pmc);

arch/arm64/kvm/pmu-emul.c

24

static void kvm_pmu_release_perf_event(struct kvm_pmc *pmc);

arch/arm64/kvm/pmu-emul.c

240

reg = counter_index_to_reg(pmc->idx);

arch/arm64/kvm/pmu-emul.c

244

kvm_pmu_release_perf_event(pmc);

arch/arm64/kvm/pmu-emul.c

25

static bool kvm_pmu_counter_is_enabled(struct kvm_pmc *pmc);

arch/arm64/kvm/pmu-emul.c

258

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

arch/arm64/kvm/pmu-emul.c

328

static void kvm_pmc_enable_perf_event(struct kvm_pmc *pmc)

arch/arm64/kvm/pmu-emul.c

33

static struct kvm_vcpu *kvm_pmc_to_vcpu(const struct kvm_pmc *pmc)

arch/arm64/kvm/pmu-emul.c

330

if (!pmc->perf_event) {

arch/arm64/kvm/pmu-emul.c

331

kvm_pmu_create_perf_event(pmc);

arch/arm64/kvm/pmu-emul.c

335

perf_event_enable(pmc->perf_event);

arch/arm64/kvm/pmu-emul.c

336

if (pmc->perf_event->state != PERF_EVENT_STATE_ACTIVE)

arch/arm64/kvm/pmu-emul.c

340

static void kvm_pmc_disable_perf_event(struct kvm_pmc *pmc)

arch/arm64/kvm/pmu-emul.c

342

if (pmc->perf_event)

arch/arm64/kvm/pmu-emul.c

343

perf_event_disable(pmc->perf_event);

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

354

struct kvm_pmc *pmc = kvm_vcpu_idx_to_pmc(vcpu, i);

arch/arm64/kvm/pmu-emul.c

359

if (kvm_pmu_counter_is_enabled(pmc))

arch/arm64/kvm/pmu-emul.c

360

kvm_pmc_enable_perf_event(pmc);

arch/arm64/kvm/pmu-emul.c

362

kvm_pmc_disable_perf_event(pmc);

arch/arm64/kvm/pmu-emul.c

40

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

arch/arm64/kvm/pmu-emul.c

480

struct kvm_pmc *pmc = kvm_vcpu_idx_to_pmc(vcpu, i);

arch/arm64/kvm/pmu-emul.c

491

if (!kvm_pmc_is_64bit(pmc))

arch/arm64/kvm/pmu-emul.c

496

if (kvm_pmc_has_64bit_overflow(pmc) ? reg : lower_32_bits(reg))

arch/arm64/kvm/pmu-emul.c

502

if (kvm_pmu_counter_can_chain(pmc))

arch/arm64/kvm/pmu-emul.c

509

static u64 compute_period(struct kvm_pmc *pmc, u64 counter)

arch/arm64/kvm/pmu-emul.c

513

if (kvm_pmc_is_64bit(pmc) && kvm_pmc_has_64bit_overflow(pmc))

arch/arm64/kvm/pmu-emul.c

528

struct kvm_pmc *pmc = perf_event->overflow_handler_context;

arch/arm64/kvm/pmu-emul.c

530

struct kvm_vcpu *vcpu = kvm_pmc_to_vcpu(pmc);

arch/arm64/kvm/pmu-emul.c

531

int idx = pmc->idx;

arch/arm64/kvm/pmu-emul.c

540

period = compute_period(pmc, local64_read(&perf_event->count));

arch/arm64/kvm/pmu-emul.c

548

if (kvm_pmu_counter_can_chain(pmc))

arch/arm64/kvm/pmu-emul.c

609

static bool kvm_pmu_counter_is_enabled(struct kvm_pmc *pmc)

arch/arm64/kvm/pmu-emul.c

611

struct kvm_vcpu *vcpu = kvm_pmc_to_vcpu(pmc);

arch/arm64/kvm/pmu-emul.c

614

if (!(__vcpu_sys_reg(vcpu, PMCNTENSET_EL0) & BIT(pmc->idx)))

arch/arm64/kvm/pmu-emul.c

617

if (kvm_pmu_counter_is_hyp(vcpu, pmc->idx))

arch/arm64/kvm/pmu-emul.c

623

static bool kvm_pmc_counts_at_el0(struct kvm_pmc *pmc)

arch/arm64/kvm/pmu-emul.c

625

u64 evtreg = kvm_pmc_read_evtreg(pmc);

arch/arm64/kvm/pmu-emul.c

632

static bool kvm_pmc_counts_at_el1(struct kvm_pmc *pmc)

arch/arm64/kvm/pmu-emul.c

634

u64 evtreg = kvm_pmc_read_evtreg(pmc);

arch/arm64/kvm/pmu-emul.c

641

static bool kvm_pmc_counts_at_el2(struct kvm_pmc *pmc)

arch/arm64/kvm/pmu-emul.c

643

struct kvm_vcpu *vcpu = kvm_pmc_to_vcpu(pmc);

arch/arm64/kvm/pmu-emul.c

646

if (!kvm_pmu_counter_is_hyp(vcpu, pmc->idx) && (mdcr & MDCR_EL2_HPMD))

arch/arm64/kvm/pmu-emul.c

649

return kvm_pmc_read_evtreg(pmc) & ARMV8_PMU_INCLUDE_EL2;

arch/arm64/kvm/pmu-emul.c

670

static void kvm_pmu_create_perf_event(struct kvm_pmc *pmc)

arch/arm64/kvm/pmu-emul.c

672

struct kvm_vcpu *vcpu = kvm_pmc_to_vcpu(pmc);

arch/arm64/kvm/pmu-emul.c

679

evtreg = kvm_pmc_read_evtreg(pmc);

arch/arm64/kvm/pmu-emul.c

681

kvm_pmu_stop_counter(pmc);

arch/arm64/kvm/pmu-emul.c

682

if (pmc->idx == ARMV8_PMU_CYCLE_IDX)

arch/arm64/kvm/pmu-emul.c

715

attr.disabled = !kvm_pmu_counter_is_enabled(pmc);

arch/arm64/kvm/pmu-emul.c

716

attr.exclude_user = !kvm_pmc_counts_at_el0(pmc);

arch/arm64/kvm/pmu-emul.c

726

attr.exclude_kernel = !kvm_pmc_counts_at_el2(pmc);

arch/arm64/kvm/pmu-emul.c

728

attr.exclude_kernel = !kvm_pmc_counts_at_el1(pmc);

arch/arm64/kvm/pmu-emul.c

735

if (kvm_pmc_is_64bit(pmc))

arch/arm64/kvm/pmu-emul.c

738

attr.sample_period = compute_period(pmc, kvm_pmu_get_pmc_value(pmc));

arch/arm64/kvm/pmu-emul.c

741

kvm_pmu_perf_overflow, pmc);

arch/arm64/kvm/pmu-emul.c

749

pmc->perf_event = event;

arch/arm64/kvm/pmu-emul.c

765

struct kvm_pmc *pmc = kvm_vcpu_idx_to_pmc(vcpu, select_idx);

arch/arm64/kvm/pmu-emul.c

768

reg = counter_index_to_evtreg(pmc->idx);

arch/arm64/kvm/pmu-emul.c

771

kvm_pmu_create_perf_event(pmc);

arch/arm64/kvm/pmu-emul.c

87

static bool kvm_pmc_is_64bit(struct kvm_pmc *pmc)

arch/arm64/kvm/pmu-emul.c

89

struct kvm_vcpu *vcpu = kvm_pmc_to_vcpu(pmc);

arch/arm64/kvm/pmu-emul.c

91

return (pmc->idx == ARMV8_PMU_CYCLE_IDX ||

arch/arm64/kvm/pmu-emul.c

95

static bool kvm_pmc_has_64bit_overflow(struct kvm_pmc *pmc)

arch/arm64/kvm/pmu-emul.c

97

struct kvm_vcpu *vcpu = kvm_pmc_to_vcpu(pmc);

arch/powerpc/include/asm/kvm_host.h

665

u32 pmc[8];

arch/powerpc/include/asm/perf_event_server.h

51

void (*disable_pmc)(unsigned int pmc, struct mmcr_regs *mmcr);

arch/powerpc/kernel/asm-offsets.c

457

OFFSET(VCPU_PMC, kvm_vcpu, arch.pmc);

arch/powerpc/kvm/book3s_hv.h

129

KVMPPC_BOOK3S_HV_VCPU_ARRAY_ACCESSOR(pmc, 32, KVMPPC_GSID_PMC)

arch/powerpc/kvm/book3s_hv_nestedv2.c

266

rc = kvmppc_gse_put_u32(gsb, iden, vcpu->arch.pmc[i]);

arch/powerpc/kvm/book3s_hv_nestedv2.c

525

vcpu->arch.pmc[i] = kvmppc_gse_get_u32(gse);

arch/powerpc/kvm/book3s_hv_p9_perf.c

142

vcpu->arch.pmc[0] = mfspr(SPRN_PMC1);

arch/powerpc/kvm/book3s_hv_p9_perf.c

143

vcpu->arch.pmc[1] = mfspr(SPRN_PMC2);

arch/powerpc/kvm/book3s_hv_p9_perf.c

144

vcpu->arch.pmc[2] = mfspr(SPRN_PMC3);

arch/powerpc/kvm/book3s_hv_p9_perf.c

145

vcpu->arch.pmc[3] = mfspr(SPRN_PMC4);

arch/powerpc/kvm/book3s_hv_p9_perf.c

146

vcpu->arch.pmc[4] = mfspr(SPRN_PMC5);

arch/powerpc/kvm/book3s_hv_p9_perf.c

147

vcpu->arch.pmc[5] = mfspr(SPRN_PMC6);

arch/powerpc/kvm/book3s_hv_p9_perf.c

88

mtspr(SPRN_PMC1, vcpu->arch.pmc[0]);

arch/powerpc/kvm/book3s_hv_p9_perf.c

89

mtspr(SPRN_PMC2, vcpu->arch.pmc[1]);

arch/powerpc/kvm/book3s_hv_p9_perf.c

90

mtspr(SPRN_PMC3, vcpu->arch.pmc[2]);

arch/powerpc/kvm/book3s_hv_p9_perf.c

91

mtspr(SPRN_PMC4, vcpu->arch.pmc[3]);

arch/powerpc/kvm/book3s_hv_p9_perf.c

92

mtspr(SPRN_PMC5, vcpu->arch.pmc[4]);

arch/powerpc/kvm/book3s_hv_p9_perf.c

93

mtspr(SPRN_PMC6, vcpu->arch.pmc[5]);

arch/powerpc/perf/generic-compat-pmu.c

140

PMU_FORMAT_ATTR(pmc, "config:16-19");

arch/powerpc/perf/isa207-common.c

16

PMU_FORMAT_ATTR(pmc, "config:16-19");

arch/powerpc/perf/isa207-common.c

172

static unsigned long combine_shift(unsigned long pmc)

arch/powerpc/perf/isa207-common.c

175

return p9_MMCR1_COMBINE_SHIFT(pmc);

arch/powerpc/perf/isa207-common.c

177

return MMCR1_COMBINE_SHIFT(pmc);

arch/powerpc/perf/isa207-common.c

415

unsigned int unit, pmc, cache, ebb;

arch/powerpc/perf/isa207-common.c

423

pmc = (event >> EVENT_PMC_SHIFT) & EVENT_PMC_MASK;

arch/powerpc/perf/isa207-common.c

433

if (pmc) {

arch/powerpc/perf/isa207-common.c

436

if (pmc > 6)

arch/powerpc/perf/isa207-common.c

442

if (pmc >= 5 && base_event != 0x500fa &&

arch/powerpc/perf/isa207-common.c

446

mask |= CNST_PMC_MASK(pmc);

arch/powerpc/perf/isa207-common.c

447

value |= CNST_PMC_VAL(pmc);

arch/powerpc/perf/isa207-common.c

455

if (pmc >= 5)

arch/powerpc/perf/isa207-common.c

459

if (pmc <= 4) {

arch/powerpc/perf/isa207-common.c

481

if (pmc == 4)

arch/powerpc/perf/isa207-common.c

543

if (!pmc && ebb)

arch/powerpc/perf/isa207-common.c

576

unsigned int pmc, pmc_inuse;

arch/powerpc/perf/isa207-common.c

583

pmc = (event[i] >> EVENT_PMC_SHIFT) & EVENT_PMC_MASK;

arch/powerpc/perf/isa207-common.c

584

if (pmc)

arch/powerpc/perf/isa207-common.c

585

pmc_inuse |= 1 << pmc;

arch/powerpc/perf/isa207-common.c

599

pmc = (event[i] >> EVENT_PMC_SHIFT) & EVENT_PMC_MASK;

arch/powerpc/perf/isa207-common.c

604

if (!pmc) {

arch/powerpc/perf/isa207-common.c

605

for (pmc = 1; pmc <= 4; ++pmc) {

arch/powerpc/perf/isa207-common.c

606

if (!(pmc_inuse & (1 << pmc)))

arch/powerpc/perf/isa207-common.c

610

pmc_inuse |= 1 << pmc;

arch/powerpc/perf/isa207-common.c

613

if (pmc <= 4) {

arch/powerpc/perf/isa207-common.c

614

mmcr1 |= unit << MMCR1_UNIT_SHIFT(pmc);

arch/powerpc/perf/isa207-common.c

615

mmcr1 |= combine << combine_shift(pmc);

arch/powerpc/perf/isa207-common.c

616

mmcr1 |= psel << MMCR1_PMCSEL_SHIFT(pmc);

arch/powerpc/perf/isa207-common.c

689

mmcr2 |= MMCR2_FCP(pmc);

arch/powerpc/perf/isa207-common.c

692

mmcr2 |= MMCR2_FCH(pmc);

arch/powerpc/perf/isa207-common.c

696

mmcr2 |= MMCR2_FCH(pmc);

arch/powerpc/perf/isa207-common.c

698

mmcr2 |= MMCR2_FCS(pmc);

arch/powerpc/perf/isa207-common.c

702

mmcr2 |= MMCR2_FCWAIT(pmc);

arch/powerpc/perf/isa207-common.c

705

if (pmc <= 4) {

arch/powerpc/perf/isa207-common.c

708

mmcr3 |= val << MMCR3_SHIFT(pmc);

arch/powerpc/perf/isa207-common.c

712

hwc[i] = pmc - 1;

arch/powerpc/perf/isa207-common.c

745

void isa207_disable_pmc(unsigned int pmc, struct mmcr_regs *mmcr)

arch/powerpc/perf/isa207-common.c

747

if (pmc <= 3)

arch/powerpc/perf/isa207-common.c

748

mmcr->mmcr1 &= ~(0xffUL << MMCR1_PMCSEL_SHIFT(pmc + 1));

arch/powerpc/perf/isa207-common.h

200

#define CNST_PMC_SHIFT(pmc) ((pmc - 1) * 2)

arch/powerpc/perf/isa207-common.h

201

#define CNST_PMC_VAL(pmc) (1 << CNST_PMC_SHIFT(pmc))

arch/powerpc/perf/isa207-common.h

202

#define CNST_PMC_MASK(pmc) (2 << CNST_PMC_SHIFT(pmc))

arch/powerpc/perf/isa207-common.h

210

#define MMCR1_UNIT_SHIFT(pmc) (60 - (4 * ((pmc) - 1)))

arch/powerpc/perf/isa207-common.h

211

#define MMCR1_COMBINE_SHIFT(pmc) (35 - ((pmc) - 1))

arch/powerpc/perf/isa207-common.h

212

#define MMCR1_PMCSEL_SHIFT(pmc) (24 - (((pmc) - 1)) * 8)

arch/powerpc/perf/isa207-common.h

218

#define p9_MMCR1_COMBINE_SHIFT(pmc) (38 - ((pmc - 1) * 2))

arch/powerpc/perf/isa207-common.h

250

#define MMCR2_FCS(pmc) (1ull << (63 - (((pmc) - 1) * 9)))

arch/powerpc/perf/isa207-common.h

251

#define MMCR2_FCP(pmc) (1ull << (62 - (((pmc) - 1) * 9)))

arch/powerpc/perf/isa207-common.h

252

#define MMCR2_FCWAIT(pmc) (1ull << (58 - (((pmc) - 1) * 9)))

arch/powerpc/perf/isa207-common.h

253

#define MMCR2_FCH(pmc) (1ull << (57 - (((pmc) - 1) * 9)))

arch/powerpc/perf/isa207-common.h

259

#define MMCR3_SHIFT(pmc) (49 - (15 * ((pmc) - 1)))

arch/powerpc/perf/isa207-common.h

284

void isa207_disable_pmc(unsigned int pmc, struct mmcr_regs *mmcr);

arch/powerpc/perf/mpc7450-pmu.c

153

int pmc, class;

arch/powerpc/perf/mpc7450-pmu.c

161

pmc = ((unsigned int)event >> PM_PMC_SH) & PM_PMC_MSK;

arch/powerpc/perf/mpc7450-pmu.c

162

mask = pmcbits[pmc - 1][0];

arch/powerpc/perf/mpc7450-pmu.c

163

value = pmcbits[pmc - 1][1];

arch/powerpc/perf/mpc7450-pmu.c

269

u32 ev, pmc, thresh;

arch/powerpc/perf/mpc7450-pmu.c

290

pmc = (ev >> PM_PMC_SH) & PM_PMC_MSK;

arch/powerpc/perf/mpc7450-pmu.c

291

if (pmc_inuse & (1 << (pmc - 1)))

arch/powerpc/perf/mpc7450-pmu.c

298

pmc = ffs(pmc_avail);

arch/powerpc/perf/mpc7450-pmu.c

300

pmc_inuse |= 1 << (pmc - 1);

arch/powerpc/perf/mpc7450-pmu.c

309

ev &= pmcsel_mask[pmc - 1];

arch/powerpc/perf/mpc7450-pmu.c

310

ev <<= pmcsel_shift[pmc - 1];

arch/powerpc/perf/mpc7450-pmu.c

311

if (pmc <= 2)

arch/powerpc/perf/mpc7450-pmu.c

315

hwc[event_index[class][i]] = pmc - 1;

arch/powerpc/perf/mpc7450-pmu.c

342

static void mpc7450_disable_pmc(unsigned int pmc, struct mmcr_regs *mmcr)

arch/powerpc/perf/mpc7450-pmu.c

344

if (pmc <= 1)

arch/powerpc/perf/mpc7450-pmu.c

345

mmcr->mmcr0 &= ~(pmcsel_mask[pmc] << pmcsel_shift[pmc]);

arch/powerpc/perf/mpc7450-pmu.c

347

mmcr->mmcr1 &= ~(pmcsel_mask[pmc] << pmcsel_shift[pmc]);

arch/powerpc/perf/mpc7450-pmu.c

39

int pmc;

arch/powerpc/perf/mpc7450-pmu.c

41

pmc = (event >> PM_PMC_SH) & PM_PMC_MSK;

arch/powerpc/perf/mpc7450-pmu.c

42

if (pmc) {

arch/powerpc/perf/mpc7450-pmu.c

43

if (pmc > N_COUNTER)

arch/powerpc/perf/mpc7450-pmu.c

79

int pmc, sel;

arch/powerpc/perf/mpc7450-pmu.c

81

pmc = (event >> PM_PMC_SH) & PM_PMC_MSK;

arch/powerpc/perf/mpc7450-pmu.c

83

switch (pmc) {

arch/powerpc/perf/power10-pmu.c

218

PMU_FORMAT_ATTR(pmc, "config:16-19");

arch/powerpc/perf/power5+-pmu.c

137

int pmc, byte, unit, sh;

arch/powerpc/perf/power5+-pmu.c

141

pmc = (event >> PM_PMC_SH) & PM_PMC_MSK;

arch/powerpc/perf/power5+-pmu.c

142

if (pmc) {

arch/powerpc/perf/power5+-pmu.c

143

if (pmc > 6)

arch/powerpc/perf/power5+-pmu.c

145

sh = (pmc - 1) * 2;

arch/powerpc/perf/power5+-pmu.c

148

if (pmc >= 5 && !(event == 0x500009 || event == 0x600005))

arch/powerpc/perf/power5+-pmu.c

179

if (pmc < 5) {

arch/powerpc/perf/power5+-pmu.c

191

int pmc = (event >> PM_PMC_SH) & PM_PMC_MSK;

arch/powerpc/perf/power5+-pmu.c

193

return pmc == 5 || pmc == 6;

arch/powerpc/perf/power5+-pmu.c

245

int pmc, altpmc, pp, j;

arch/powerpc/perf/power5+-pmu.c

247

pmc = (event >> PM_PMC_SH) & PM_PMC_MSK;

arch/powerpc/perf/power5+-pmu.c

248

if (pmc == 0 || pmc > 4)

arch/powerpc/perf/power5+-pmu.c

250

altpmc = 5 - pmc; /* 1 <-> 4, 2 <-> 3 */

arch/powerpc/perf/power5+-pmu.c

253

if (bytedecode_alternatives[pmc - 1][j] == pp) {

arch/powerpc/perf/power5+-pmu.c

261

if (pmc == 1 && (pp == 0x0d || pp == 0x0e))

arch/powerpc/perf/power5+-pmu.c

263

if (pmc == 3 && (pp == 0x2e || pp == 0x2f))

arch/powerpc/perf/power5+-pmu.c

405

int pmc, psel;

arch/powerpc/perf/power5+-pmu.c

409

pmc = (event >> PM_PMC_SH) & PM_PMC_MSK;

arch/powerpc/perf/power5+-pmu.c

411

if (pmc >= 5)

arch/powerpc/perf/power5+-pmu.c

416

if (direct_event_is_marked[psel] & (1 << pmc))

arch/powerpc/perf/power5+-pmu.c

421

bit = pmc - 1;

arch/powerpc/perf/power5+-pmu.c

423

bit = 4 - pmc;

arch/powerpc/perf/power5+-pmu.c

424

else if (psel == 0x1b && (pmc == 1 || pmc == 3))

arch/powerpc/perf/power5+-pmu.c

429

bit = pmc - 1;

arch/powerpc/perf/power5+-pmu.c

430

} else if (pmc == 3 && (psel == 0x2e || psel == 0x2f)) {

arch/powerpc/perf/power5+-pmu.c

459

unsigned int pmc, unit, byte, psel;

arch/powerpc/perf/power5+-pmu.c

474

pmc = (event[i] >> PM_PMC_SH) & PM_PMC_MSK;

arch/powerpc/perf/power5+-pmu.c

475

if (pmc) {

arch/powerpc/perf/power5+-pmu.c

476

if (pmc > 6)

arch/powerpc/perf/power5+-pmu.c

478

if (pmc_inuse & (1 << (pmc - 1)))

arch/powerpc/perf/power5+-pmu.c

480

pmc_inuse |= 1 << (pmc - 1);

arch/powerpc/perf/power5+-pmu.c

552

pmc = (event[i] >> PM_PMC_SH) & PM_PMC_MSK;

arch/powerpc/perf/power5+-pmu.c

557

if (!pmc) {

arch/powerpc/perf/power5+-pmu.c

559

for (pmc = 0; pmc < 4; ++pmc) {

arch/powerpc/perf/power5+-pmu.c

560

if (!(pmc_inuse & (1 << pmc)))

arch/powerpc/perf/power5+-pmu.c

563

if (pmc >= 4)

arch/powerpc/perf/power5+-pmu.c

565

pmc_inuse |= 1 << pmc;

arch/powerpc/perf/power5+-pmu.c

566

} else if (pmc <= 4) {

arch/powerpc/perf/power5+-pmu.c

568

--pmc;

arch/powerpc/perf/power5+-pmu.c

572

mmcr1 |= 1ul << (MMCR1_PMC1_ADDER_SEL_SH - pmc);

arch/powerpc/perf/power5+-pmu.c

575

--pmc;

arch/powerpc/perf/power5+-pmu.c

584

if ((psel & 0x58) == 0x40 && (byte & 1) != ((pmc >> 1) & 1))

arch/powerpc/perf/power5+-pmu.c

587

if (pmc <= 3)

arch/powerpc/perf/power5+-pmu.c

588

mmcr1 |= psel << MMCR1_PMCSEL_SH(pmc);

arch/powerpc/perf/power5+-pmu.c

589

hwc[i] = pmc;

arch/powerpc/perf/power5+-pmu.c

603

static void power5p_disable_pmc(unsigned int pmc, struct mmcr_regs *mmcr)

arch/powerpc/perf/power5+-pmu.c

605

if (pmc <= 3)

arch/powerpc/perf/power5+-pmu.c

606

mmcr->mmcr1 &= ~(0x7fUL << MMCR1_PMCSEL_SH(pmc));

arch/powerpc/perf/power5-pmu.c

141

int pmc, byte, unit, sh;

arch/powerpc/perf/power5-pmu.c

146

pmc = (event >> PM_PMC_SH) & PM_PMC_MSK;

arch/powerpc/perf/power5-pmu.c

147

if (pmc) {

arch/powerpc/perf/power5-pmu.c

148

if (pmc > 6)

arch/powerpc/perf/power5-pmu.c

150

sh = (pmc - 1) * 2;

arch/powerpc/perf/power5-pmu.c

153

if (pmc <= 4)

arch/powerpc/perf/power5-pmu.c

154

grp = (pmc - 1) >> 1;

arch/powerpc/perf/power5-pmu.c

186

if (!pmc)

arch/powerpc/perf/power5-pmu.c

201

if (pmc < 5) {

arch/powerpc/perf/power5-pmu.c

253

int pmc, altpmc, pp, j;

arch/powerpc/perf/power5-pmu.c

255

pmc = (event >> PM_PMC_SH) & PM_PMC_MSK;

arch/powerpc/perf/power5-pmu.c

256

if (pmc == 0 || pmc > 4)

arch/powerpc/perf/power5-pmu.c

258

altpmc = 5 - pmc; /* 1 <-> 4, 2 <-> 3 */

arch/powerpc/perf/power5-pmu.c

261

if (bytedecode_alternatives[pmc - 1][j] == pp) {

arch/powerpc/perf/power5-pmu.c

341

int pmc, psel;

arch/powerpc/perf/power5-pmu.c

345

pmc = (event >> PM_PMC_SH) & PM_PMC_MSK;

arch/powerpc/perf/power5-pmu.c

347

if (pmc >= 5)

arch/powerpc/perf/power5-pmu.c

352

if (direct_event_is_marked[psel] & (1 << pmc))

arch/powerpc/perf/power5-pmu.c

357

bit = pmc - 1;

arch/powerpc/perf/power5-pmu.c

359

bit = 4 - pmc;

arch/powerpc/perf/power5-pmu.c

360

else if (psel == 0x1b && (pmc == 1 || pmc == 3))

arch/powerpc/perf/power5-pmu.c

390

unsigned int pmc, unit, byte, psel;

arch/powerpc/perf/power5-pmu.c

407

pmc = (event[i] >> PM_PMC_SH) & PM_PMC_MSK;

arch/powerpc/perf/power5-pmu.c

408

if (pmc) {

arch/powerpc/perf/power5-pmu.c

409

if (pmc > 6)

arch/powerpc/perf/power5-pmu.c

411

if (pmc_inuse & (1 << (pmc - 1)))

arch/powerpc/perf/power5-pmu.c

413

pmc_inuse |= 1 << (pmc - 1);

arch/powerpc/perf/power5-pmu.c

415

if (pmc <= 4)

arch/powerpc/perf/power5-pmu.c

416

++pmc_grp_use[(pmc - 1) >> 1];

arch/powerpc/perf/power5-pmu.c

431

if (!pmc)

arch/powerpc/perf/power5-pmu.c

492

pmc = (event[i] >> PM_PMC_SH) & PM_PMC_MSK;

arch/powerpc/perf/power5-pmu.c

497

if (!pmc) {

arch/powerpc/perf/power5-pmu.c

499

for (pmc = 0; pmc < 4; ++pmc) {

arch/powerpc/perf/power5-pmu.c

500

if (pmc_inuse & (1 << pmc))

arch/powerpc/perf/power5-pmu.c

502

grp = (pmc >> 1) & 1;

arch/powerpc/perf/power5-pmu.c

511

pmc_inuse |= 1 << pmc;

arch/powerpc/perf/power5-pmu.c

512

} else if (pmc <= 4) {

arch/powerpc/perf/power5-pmu.c

514

--pmc;

arch/powerpc/perf/power5-pmu.c

517

mmcr1 |= 1ul << (MMCR1_PMC1_ADDER_SEL_SH - pmc);

arch/powerpc/perf/power5-pmu.c

520

--pmc;

arch/powerpc/perf/power5-pmu.c

529

if (pmc <= 3)

arch/powerpc/perf/power5-pmu.c

530

mmcr1 |= psel << MMCR1_PMCSEL_SH(pmc);

arch/powerpc/perf/power5-pmu.c

531

hwc[i] = pmc;

arch/powerpc/perf/power5-pmu.c

545

static void power5_disable_pmc(unsigned int pmc, struct mmcr_regs *mmcr)

arch/powerpc/perf/power5-pmu.c

547

if (pmc <= 3)

arch/powerpc/perf/power5-pmu.c

548

mmcr->mmcr1 &= ~(0x7fUL << MMCR1_PMCSEL_SH(pmc));

arch/powerpc/perf/power6-pmu.c

139

int pmc, psel, ptype;

arch/powerpc/perf/power6-pmu.c

143

pmc = (event >> PM_PMC_SH) & PM_PMC_MSK;

arch/powerpc/perf/power6-pmu.c

145

if (pmc >= 5)

arch/powerpc/perf/power6-pmu.c

151

if (pmc == 0 || !(ptype & (1 << (pmc - 1))))

arch/powerpc/perf/power6-pmu.c

159

bit = ptype ^ (pmc - 1);

arch/powerpc/perf/power6-pmu.c

182

unsigned int pmc, ev, b, u, s, psel;

arch/powerpc/perf/power6-pmu.c

189

pmc = (event[i] >> PM_PMC_SH) & PM_PMC_MSK;

arch/powerpc/perf/power6-pmu.c

190

if (pmc) {

arch/powerpc/perf/power6-pmu.c

191

if (pmc_inuse & (1 << (pmc - 1)))

arch/powerpc/perf/power6-pmu.c

193

pmc_inuse |= 1 << (pmc - 1);

arch/powerpc/perf/power6-pmu.c

198

pmc = (ev >> PM_PMC_SH) & PM_PMC_MSK;

arch/powerpc/perf/power6-pmu.c

199

if (pmc) {

arch/powerpc/perf/power6-pmu.c

200

--pmc;

arch/powerpc/perf/power6-pmu.c

203

for (pmc = 0; pmc < 4; ++pmc)

arch/powerpc/perf/power6-pmu.c

204

if (!(pmc_inuse & (1 << pmc)))

arch/powerpc/perf/power6-pmu.c

206

if (pmc >= 4)

arch/powerpc/perf/power6-pmu.c

208

pmc_inuse |= 1 << pmc;

arch/powerpc/perf/power6-pmu.c

210

hwc[i] = pmc;

arch/powerpc/perf/power6-pmu.c

233

mmcr1 |= MMCR1_PMC1_ADDR_SEL >> pmc;

arch/powerpc/perf/power6-pmu.c

236

if (pmc >= 2 && (psel & 0x90) == 0x80)

arch/powerpc/perf/power6-pmu.c

240

mmcr1 |= MMCR1_PMC1_LLA >> pmc;

arch/powerpc/perf/power6-pmu.c

242

mmcr1 |= MMCR1_PMC1_LLA_VALUE >> pmc;

arch/powerpc/perf/power6-pmu.c

246

if (pmc < 4)

arch/powerpc/perf/power6-pmu.c

247

mmcr1 |= (unsigned long)psel << MMCR1_PMCSEL_SH(pmc);

arch/powerpc/perf/power6-pmu.c

272

int pmc, byte, sh, subunit;

arch/powerpc/perf/power6-pmu.c

275

pmc = (event >> PM_PMC_SH) & PM_PMC_MSK;

arch/powerpc/perf/power6-pmu.c

276

if (pmc) {

arch/powerpc/perf/power6-pmu.c

277

if (pmc > 4 && !(event == 0x500009 || event == 0x600005))

arch/powerpc/perf/power6-pmu.c

279

sh = (pmc - 1) * 2;

arch/powerpc/perf/power6-pmu.c

294

if (pmc <= 4) {

arch/powerpc/perf/power6-pmu.c

305

int pmc = (event >> PM_PMC_SH) & PM_PMC_MSK;

arch/powerpc/perf/power6-pmu.c

307

return pmc == 5 || pmc == 6;

arch/powerpc/perf/power6-pmu.c

376

unsigned int psel, pmc;

arch/powerpc/perf/power6-pmu.c

400

pmc = (event >> PM_PMC_SH) & PM_PMC_MSK;

arch/powerpc/perf/power6-pmu.c

401

if (pmc && (psel == 0x32 || psel == 0x34))

arch/powerpc/perf/power6-pmu.c

403

((5 - pmc) << PM_PMC_SH);

arch/powerpc/perf/power6-pmu.c

406

if (pmc && (psel == 0x38 || psel == 0x3a))

arch/powerpc/perf/power6-pmu.c

408

((pmc > 2? pmc - 2: pmc + 2) << PM_PMC_SH);

arch/powerpc/perf/power6-pmu.c

475

static void p6_disable_pmc(unsigned int pmc, struct mmcr_regs *mmcr)

arch/powerpc/perf/power6-pmu.c

478

if (pmc <= 3)

arch/powerpc/perf/power6-pmu.c

479

mmcr->mmcr1 &= ~(0xffUL << MMCR1_PMCSEL_SH(pmc));

arch/powerpc/perf/power7-pmu.c

146

int pmc, psel;

arch/powerpc/perf/power7-pmu.c

149

pmc = (event >> PM_PMC_SH) & PM_PMC_MSK;

arch/powerpc/perf/power7-pmu.c

151

if ((pmc == 2 || pmc == 4) && (psel & ~7) == 0x40)

arch/powerpc/perf/power7-pmu.c

153

if ((pmc == 1 || pmc == 3) && (psel & ~7) == 0x48)

arch/powerpc/perf/power7-pmu.c

215

int pmc, psel;

arch/powerpc/perf/power7-pmu.c

218

pmc = (event >> PM_PMC_SH) & PM_PMC_MSK;

arch/powerpc/perf/power7-pmu.c

221

if (pmc >= 5)

arch/powerpc/perf/power7-pmu.c

226

return pmc == 2 || pmc == 4;

arch/powerpc/perf/power7-pmu.c

229

return pmc == 1;

arch/powerpc/perf/power7-pmu.c

231

return pmc != 2;

arch/powerpc/perf/power7-pmu.c

238

return pmc >= 3;

arch/powerpc/perf/power7-pmu.c

253

unsigned int pmc, unit, combine, l2sel, psel;

arch/powerpc/perf/power7-pmu.c

259

pmc = (event[i] >> PM_PMC_SH) & PM_PMC_MSK;

arch/powerpc/perf/power7-pmu.c

260

if (pmc) {

arch/powerpc/perf/power7-pmu.c

261

if (pmc > 6)

arch/powerpc/perf/power7-pmu.c

263

if (pmc_inuse & (1 << (pmc - 1)))

arch/powerpc/perf/power7-pmu.c

265

pmc_inuse |= 1 << (pmc - 1);

arch/powerpc/perf/power7-pmu.c

271

pmc = (event[i] >> PM_PMC_SH) & PM_PMC_MSK;

arch/powerpc/perf/power7-pmu.c

276

if (!pmc) {

arch/powerpc/perf/power7-pmu.c

278

for (pmc = 0; pmc < 4; ++pmc) {

arch/powerpc/perf/power7-pmu.c

279

if (!(pmc_inuse & (1 << pmc)))

arch/powerpc/perf/power7-pmu.c

282

if (pmc >= 4)

arch/powerpc/perf/power7-pmu.c

284

pmc_inuse |= 1 << pmc;

arch/powerpc/perf/power7-pmu.c

287

--pmc;

arch/powerpc/perf/power7-pmu.c

289

if (pmc <= 3) {

arch/powerpc/perf/power7-pmu.c

291

<< (MMCR1_TTM0SEL_SH - 4 * pmc);

arch/powerpc/perf/power7-pmu.c

293

<< (MMCR1_PMC1_COMBINE_SH - pmc);

arch/powerpc/perf/power7-pmu.c

294

mmcr1 |= psel << MMCR1_PMCSEL_SH(pmc);

arch/powerpc/perf/power7-pmu.c

301

hwc[i] = pmc;

arch/powerpc/perf/power7-pmu.c

315

static void power7_disable_pmc(unsigned int pmc, struct mmcr_regs *mmcr)

arch/powerpc/perf/power7-pmu.c

317

if (pmc <= 3)

arch/powerpc/perf/power7-pmu.c

318

mmcr->mmcr1 &= ~(0xffUL << MMCR1_PMCSEL_SH(pmc));

arch/powerpc/perf/power7-pmu.c

86

int pmc, sh, unit;

arch/powerpc/perf/power7-pmu.c

89

pmc = (event >> PM_PMC_SH) & PM_PMC_MSK;

arch/powerpc/perf/power7-pmu.c

90

if (pmc) {

arch/powerpc/perf/power7-pmu.c

91

if (pmc > 6)

arch/powerpc/perf/power7-pmu.c

93

sh = (pmc - 1) * 2;

arch/powerpc/perf/power7-pmu.c

96

if (pmc >= 5 && !(event == 0x500fa || event == 0x600f4))

arch/powerpc/perf/power7-pmu.c

99

if (pmc < 5) {

arch/powerpc/perf/power9-pmu.c

230

PMU_FORMAT_ATTR(pmc, "config:16-19");

arch/powerpc/perf/ppc970-pmu.c

147

int pmc, psel, unit, byte, bit;

arch/powerpc/perf/ppc970-pmu.c

150

pmc = (event >> PM_PMC_SH) & PM_PMC_MSK;

arch/powerpc/perf/ppc970-pmu.c

152

if (pmc) {

arch/powerpc/perf/ppc970-pmu.c

153

if (direct_marked_event[pmc - 1] & (1 << psel))

arch/powerpc/perf/ppc970-pmu.c

156

bit = (pmc <= 4)? pmc - 1: 8 - pmc;

arch/powerpc/perf/ppc970-pmu.c

195

int pmc, byte, unit, sh, spcsel;

arch/powerpc/perf/ppc970-pmu.c

199

pmc = (event >> PM_PMC_SH) & PM_PMC_MSK;

arch/powerpc/perf/ppc970-pmu.c

200

if (pmc) {

arch/powerpc/perf/ppc970-pmu.c

201

if (pmc > 8)

arch/powerpc/perf/ppc970-pmu.c

203

sh = (pmc - 1) * 2;

arch/powerpc/perf/ppc970-pmu.c

206

grp = ((pmc - 1) >> 1) & 1;

arch/powerpc/perf/ppc970-pmu.c

219

if (!pmc)

arch/powerpc/perf/ppc970-pmu.c

263

unsigned int pmc, unit, byte, psel;

arch/powerpc/perf/ppc970-pmu.c

283

pmc = (event[i] >> PM_PMC_SH) & PM_PMC_MSK;

arch/powerpc/perf/ppc970-pmu.c

284

if (pmc) {

arch/powerpc/perf/ppc970-pmu.c

285

if (pmc_inuse & (1 << (pmc - 1)))

arch/powerpc/perf/ppc970-pmu.c

287

pmc_inuse |= 1 << (pmc - 1);

arch/powerpc/perf/ppc970-pmu.c

289

++pmc_grp_use[((pmc - 1) >> 1) & 1];

arch/powerpc/perf/ppc970-pmu.c

296

if (!pmc)

arch/powerpc/perf/ppc970-pmu.c

350

pmc = (event[i] >> PM_PMC_SH) & PM_PMC_MSK;

arch/powerpc/perf/ppc970-pmu.c

354

if (!pmc) {

arch/powerpc/perf/ppc970-pmu.c

360

for (pmc = 0; pmc < 8; ++pmc) {

arch/powerpc/perf/ppc970-pmu.c

361

if (pmc_inuse & (1 << pmc))

arch/powerpc/perf/ppc970-pmu.c

363

grp = (pmc >> 1) & 1;

arch/powerpc/perf/ppc970-pmu.c

372

pmc_inuse |= 1 << pmc;

arch/powerpc/perf/ppc970-pmu.c

375

--pmc;

arch/powerpc/perf/ppc970-pmu.c

378

mmcr1 |= 1ull << mmcr1_adder_bits[pmc];

arch/powerpc/perf/ppc970-pmu.c

380

pmcsel[pmc] = psel;

arch/powerpc/perf/ppc970-pmu.c

381

hwc[i] = pmc;

arch/powerpc/perf/ppc970-pmu.c

387

for (pmc = 0; pmc < 2; ++pmc)

arch/powerpc/perf/ppc970-pmu.c

388

mmcr0 |= pmcsel[pmc] << (MMCR0_PMC1SEL_SH - 7 * pmc);

arch/powerpc/perf/ppc970-pmu.c

389

for (; pmc < 8; ++pmc)

arch/powerpc/perf/ppc970-pmu.c

390

mmcr1 |= (unsigned long)pmcsel[pmc]

arch/powerpc/perf/ppc970-pmu.c

391

<< (MMCR1_PMC3SEL_SH - 5 * (pmc - 2));

arch/powerpc/perf/ppc970-pmu.c

406

static void p970_disable_pmc(unsigned int pmc, struct mmcr_regs *mmcr)

arch/powerpc/perf/ppc970-pmu.c

413

if (pmc <= 1) {

arch/powerpc/perf/ppc970-pmu.c

414

shift = MMCR0_PMC1SEL_SH - 7 * pmc;

arch/powerpc/perf/ppc970-pmu.c

417

shift = MMCR1_PMC3SEL_SH - 5 * (pmc - 2);

arch/riscv/include/asm/kvm_vcpu_pmu.h

45

struct kvm_pmc pmc[RISCV_KVM_MAX_COUNTERS];

arch/riscv/kvm/vcpu_pmu.c

211

struct kvm_pmc *pmc;

arch/riscv/kvm/vcpu_pmu.c

225

pmc = &kvpmu->pmc[cidx];

arch/riscv/kvm/vcpu_pmu.c

227

if (pmc->cinfo.type != SBI_PMU_CTR_TYPE_FW)

arch/riscv/kvm/vcpu_pmu.c

230

if (pmc->event_idx == SBI_PMU_EVENT_IDX_INVALID)

arch/riscv/kvm/vcpu_pmu.c

233

fevent_code = get_event_code(pmc->event_idx);

arch/riscv/kvm/vcpu_pmu.c

238

pmc->counter_val = kvpmu->fw_event[fevent_code].value;

arch/riscv/kvm/vcpu_pmu.c

240

*out_val = pmc->counter_val >> 32;

arch/riscv/kvm/vcpu_pmu.c

249

struct kvm_pmc *pmc;

arch/riscv/kvm/vcpu_pmu.c

259

pmc = &kvpmu->pmc[cidx];

arch/riscv/kvm/vcpu_pmu.c

261

if (pmc->cinfo.type == SBI_PMU_CTR_TYPE_FW) {

arch/riscv/kvm/vcpu_pmu.c

262

if (pmc->event_idx == SBI_PMU_EVENT_IDX_INVALID)

arch/riscv/kvm/vcpu_pmu.c

265

fevent_code = get_event_code(pmc->event_idx);

arch/riscv/kvm/vcpu_pmu.c

270

pmc->counter_val = kvpmu->fw_event[fevent_code].value;

arch/riscv/kvm/vcpu_pmu.c

271

} else if (pmc->perf_event) {

arch/riscv/kvm/vcpu_pmu.c

272

pmc->counter_val += perf_event_read_value(pmc->perf_event, &enabled, &running);

arch/riscv/kvm/vcpu_pmu.c

276

*out_val = pmc->counter_val;

arch/riscv/kvm/vcpu_pmu.c

297

struct kvm_pmc *pmc = perf_event->overflow_handler_context;

arch/riscv/kvm/vcpu_pmu.c

298

struct kvm_vcpu *vcpu = pmc->vcpu;

arch/riscv/kvm/vcpu_pmu.c

328

set_bit(pmc->idx, kvpmu->pmc_overflown);

arch/riscv/kvm/vcpu_pmu.c

334

static long kvm_pmu_create_perf_event(struct kvm_pmc *pmc, struct perf_event_attr *attr,

arch/riscv/kvm/vcpu_pmu.c

340

kvm_pmu_release_perf_event(pmc);

arch/riscv/kvm/vcpu_pmu.c

344

pmc->counter_val = 0;

arch/riscv/kvm/vcpu_pmu.c

351

attr->sample_period = kvm_pmu_get_sample_period(pmc);

arch/riscv/kvm/vcpu_pmu.c

353

event = perf_event_create_kernel_counter(attr, -1, current, kvm_riscv_pmu_overflow, pmc);

arch/riscv/kvm/vcpu_pmu.c

359

pmc->perf_event = event;

arch/riscv/kvm/vcpu_pmu.c

361

perf_event_enable(pmc->perf_event);

arch/riscv/kvm/vcpu_pmu.c

39

static u64 kvm_pmu_get_sample_period(struct kvm_pmc *pmc)

arch/riscv/kvm/vcpu_pmu.c

41

u64 counter_val_mask = GENMASK(pmc->cinfo.width, 0);

arch/riscv/kvm/vcpu_pmu.c

44

if (!pmc->counter_val)

arch/riscv/kvm/vcpu_pmu.c

47

sample_period = (-pmc->counter_val) & counter_val_mask;

arch/riscv/kvm/vcpu_pmu.c

556

retdata->out_val = kvpmu->pmc[cidx].cinfo.value;

arch/riscv/kvm/vcpu_pmu.c

567

struct kvm_pmc *pmc;

arch/riscv/kvm/vcpu_pmu.c

596

pmc = &kvpmu->pmc[pmc_index];

arch/riscv/kvm/vcpu_pmu.c

598

pmc->counter_val = ival;

arch/riscv/kvm/vcpu_pmu.c

601

pmc->counter_val = kvpmu->sdata->ctr_values[i];

arch/riscv/kvm/vcpu_pmu.c

604

if (pmc->cinfo.type == SBI_PMU_CTR_TYPE_FW) {

arch/riscv/kvm/vcpu_pmu.c

605

fevent_code = get_event_code(pmc->event_idx);

arch/riscv/kvm/vcpu_pmu.c

618

kvpmu->fw_event[fevent_code].value = pmc->counter_val;

arch/riscv/kvm/vcpu_pmu.c

619

} else if (pmc->perf_event) {

arch/riscv/kvm/vcpu_pmu.c

620

if (unlikely(pmc->started)) {

arch/riscv/kvm/vcpu_pmu.c

624

perf_event_period(pmc->perf_event, kvm_pmu_get_sample_period(pmc));

arch/riscv/kvm/vcpu_pmu.c

625

perf_event_enable(pmc->perf_event);

arch/riscv/kvm/vcpu_pmu.c

626

pmc->started = true;

arch/riscv/kvm/vcpu_pmu.c

645

struct kvm_pmc *pmc;

arch/riscv/kvm/vcpu_pmu.c

666

pmc = &kvpmu->pmc[pmc_index];

arch/riscv/kvm/vcpu_pmu.c

667

if (pmc->cinfo.type == SBI_PMU_CTR_TYPE_FW) {

arch/riscv/kvm/vcpu_pmu.c

668

fevent_code = get_event_code(pmc->event_idx);

arch/riscv/kvm/vcpu_pmu.c

678

} else if (pmc->perf_event) {

arch/riscv/kvm/vcpu_pmu.c

679

if (pmc->started) {

arch/riscv/kvm/vcpu_pmu.c

681

perf_event_disable(pmc->perf_event);

arch/riscv/kvm/vcpu_pmu.c

682

pmc->started = false;

arch/riscv/kvm/vcpu_pmu.c

689

kvm_pmu_release_perf_event(pmc);

arch/riscv/kvm/vcpu_pmu.c

695

if (pmc->cinfo.type == SBI_PMU_CTR_TYPE_FW)

arch/riscv/kvm/vcpu_pmu.c

696

pmc->counter_val = kvpmu->fw_event[fevent_code].value;

arch/riscv/kvm/vcpu_pmu.c

697

else if (pmc->perf_event)

arch/riscv/kvm/vcpu_pmu.c

698

pmc->counter_val += perf_event_read_value(pmc->perf_event,

arch/riscv/kvm/vcpu_pmu.c

707

kvpmu->sdata->ctr_values[i] = pmc->counter_val;

arch/riscv/kvm/vcpu_pmu.c

712

pmc->event_idx = SBI_PMU_EVENT_IDX_INVALID;

arch/riscv/kvm/vcpu_pmu.c

747

struct kvm_pmc *pmc = NULL;

arch/riscv/kvm/vcpu_pmu.c

795

pmc = &kvpmu->pmc[ctr_idx];

arch/riscv/kvm/vcpu_pmu.c

796

pmc->idx = ctr_idx;

arch/riscv/kvm/vcpu_pmu.c

802

ret = kvm_pmu_create_perf_event(pmc, &attr, flags, eidx, evtdata);

arch/riscv/kvm/vcpu_pmu.c

81

static void kvm_pmu_release_perf_event(struct kvm_pmc *pmc)

arch/riscv/kvm/vcpu_pmu.c

810

pmc->event_idx = eidx;

arch/riscv/kvm/vcpu_pmu.c

83

if (pmc->perf_event) {

arch/riscv/kvm/vcpu_pmu.c

84

perf_event_disable(pmc->perf_event);

arch/riscv/kvm/vcpu_pmu.c

846

struct kvm_pmc *pmc;

arch/riscv/kvm/vcpu_pmu.c

85

perf_event_release_kernel(pmc->perf_event);

arch/riscv/kvm/vcpu_pmu.c

86

pmc->perf_event = NULL;

arch/riscv/kvm/vcpu_pmu.c

883

pmc = &kvpmu->pmc[i];

arch/riscv/kvm/vcpu_pmu.c

884

pmc->idx = i;

arch/riscv/kvm/vcpu_pmu.c

885

pmc->event_idx = SBI_PMU_EVENT_IDX_INVALID;

arch/riscv/kvm/vcpu_pmu.c

886

pmc->vcpu = vcpu;

arch/riscv/kvm/vcpu_pmu.c

888

pmc->cinfo.type = SBI_PMU_CTR_TYPE_HW;

arch/riscv/kvm/vcpu_pmu.c

891

pmc->cinfo.width = 63;

arch/riscv/kvm/vcpu_pmu.c

893

pmc->cinfo.width = hpm_width;

arch/riscv/kvm/vcpu_pmu.c

900

pmc->cinfo.csr = CSR_CYCLE + i;

arch/riscv/kvm/vcpu_pmu.c

902

pmc->cinfo.type = SBI_PMU_CTR_TYPE_FW;

arch/riscv/kvm/vcpu_pmu.c

903

pmc->cinfo.width = 63;

arch/riscv/kvm/vcpu_pmu.c

913

struct kvm_pmc *pmc;

arch/riscv/kvm/vcpu_pmu.c

920

pmc = &kvpmu->pmc[i];

arch/riscv/kvm/vcpu_pmu.c

921

pmc->counter_val = 0;

arch/riscv/kvm/vcpu_pmu.c

922

kvm_pmu_release_perf_event(pmc);

arch/riscv/kvm/vcpu_pmu.c

923

pmc->event_idx = SBI_PMU_EVENT_IDX_INVALID;

arch/x86/events/amd/brs.c

29

pmc:3, /* #PMC holding the sampling event */

arch/x86/events/intel/ds.c

2345

static void intel_perf_event_update_pmc(struct perf_event *event, u64 pmc)

arch/x86/events/intel/ds.c

2378

local64_set(&hwc->prev_count, pmc);

arch/x86/events/intel/ds.c

2380

delta = (pmc << shift) - (prev_pmc << shift);

arch/x86/include/asm/intel_telemetry.h

56

struct intel_pmc_dev *pmc;

arch/x86/kvm/emulate.c

3220

u64 pmc;

arch/x86/kvm/emulate.c

3222

if (ctxt->ops->read_pmc(ctxt, reg_read(ctxt, VCPU_REGS_RCX), &pmc))

arch/x86/kvm/emulate.c

3224

*reg_write(ctxt, VCPU_REGS_RAX) = (u32)pmc;

arch/x86/kvm/emulate.c

3225

*reg_write(ctxt, VCPU_REGS_RDX) = pmc >> 32;

arch/x86/kvm/kvm_emulate.h

224

int (*check_rdpmc_early)(struct x86_emulate_ctxt *ctxt, u32 pmc);

arch/x86/kvm/kvm_emulate.h

225

int (*read_pmc)(struct x86_emulate_ctxt *ctxt, u32 pmc, u64 *pdata);

arch/x86/kvm/pmu.c

1027

struct kvm_pmc *pmc = NULL;

arch/x86/kvm/pmu.c

1036

kvm_for_each_pmc(pmu, pmc, i, bitmask) {

arch/x86/kvm/pmu.c

1037

if (pmc->perf_event && !pmc_is_locally_enabled(pmc))

arch/x86/kvm/pmu.c

1038

pmc_stop_counter(pmc);

arch/x86/kvm/pmu.c

1051

static bool pmc_is_pmi_enabled(struct kvm_pmc *pmc)

arch/x86/kvm/pmu.c

1055

if (pmc_is_gp(pmc))

arch/x86/kvm/pmu.c

1056

return pmc->eventsel & ARCH_PERFMON_EVENTSEL_INT;

arch/x86/kvm/pmu.c

1058

fixed_ctr_ctrl = fixed_ctrl_field(pmc_to_pmu(pmc)->fixed_ctr_ctrl,

arch/x86/kvm/pmu.c

1059

pmc->idx - KVM_FIXED_PMC_BASE_IDX);

arch/x86/kvm/pmu.c

1063

static void kvm_pmu_incr_counter(struct kvm_pmc *pmc)

arch/x86/kvm/pmu.c

1065

struct kvm_vcpu *vcpu = pmc->vcpu;

arch/x86/kvm/pmu.c

1074

pmc->emulated_counter++;

arch/x86/kvm/pmu.c

1075

kvm_pmu_request_counter_reprogram(pmc);

arch/x86/kvm/pmu.c

1084

pmc->counter = (pmc->counter + 1) & pmc_bitmask(pmc);

arch/x86/kvm/pmu.c

1085

if (!pmc->counter) {

arch/x86/kvm/pmu.c

1086

pmc_to_pmu(pmc)->global_status |= BIT_ULL(pmc->idx);

arch/x86/kvm/pmu.c

1087

if (pmc_is_pmi_enabled(pmc))

arch/x86/kvm/pmu.c

1092

static inline bool cpl_is_matched(struct kvm_pmc *pmc)

arch/x86/kvm/pmu.c

1097

if (pmc_is_gp(pmc)) {

arch/x86/kvm/pmu.c

1098

config = pmc->eventsel;

arch/x86/kvm/pmu.c

1102

config = fixed_ctrl_field(pmc_to_pmu(pmc)->fixed_ctr_ctrl,

arch/x86/kvm/pmu.c

1103

pmc->idx - KVM_FIXED_PMC_BASE_IDX);

arch/x86/kvm/pmu.c

1115

return (kvm_x86_call(get_cpl)(pmc->vcpu) == 0) ? select_os :

arch/x86/kvm/pmu.c

1124

struct kvm_pmc *pmc;

arch/x86/kvm/pmu.c

1139

kvm_for_each_pmc(pmu, pmc, i, bitmap) {

arch/x86/kvm/pmu.c

1140

if (!pmc_is_event_allowed(pmc) || !cpl_is_matched(pmc))

arch/x86/kvm/pmu.c

1143

kvm_pmu_incr_counter(pmc);

arch/x86/kvm/pmu.c

1321

struct kvm_pmc *pmc;

arch/x86/kvm/pmu.c

1330

pmc = &pmu->gp_counters[i];

arch/x86/kvm/pmu.c

1332

if (pmc->counter != rdpmc(i))

arch/x86/kvm/pmu.c

1333

wrmsrq(gp_counter_msr(i), pmc->counter);

arch/x86/kvm/pmu.c

1334

wrmsrq(gp_eventsel_msr(i), pmc->eventsel_hw);

arch/x86/kvm/pmu.c

1337

pmc = &pmu->fixed_counters[i];

arch/x86/kvm/pmu.c

1339

if (pmc->counter != rdpmc(INTEL_PMC_FIXED_RDPMC_BASE | i))

arch/x86/kvm/pmu.c

1340

wrmsrq(fixed_counter_msr(i), pmc->counter);

arch/x86/kvm/pmu.c

1379

struct kvm_pmc *pmc;

arch/x86/kvm/pmu.c

1387

pmc = &pmu->gp_counters[i];

arch/x86/kvm/pmu.c

1389

pmc->counter = rdpmc(i);

arch/x86/kvm/pmu.c

1390

if (pmc->counter)

arch/x86/kvm/pmu.c

1392

if (pmc->eventsel_hw)

arch/x86/kvm/pmu.c

1397

pmc = &pmu->fixed_counters[i];

arch/x86/kvm/pmu.c

1399

pmc->counter = rdpmc(INTEL_PMC_FIXED_RDPMC_BASE | i);

arch/x86/kvm/pmu.c

1400

if (pmc->counter)

arch/x86/kvm/pmu.c

188

static inline void __kvm_perf_overflow(struct kvm_pmc *pmc, bool in_pmi)

arch/x86/kvm/pmu.c

190

struct kvm_pmu *pmu = pmc_to_pmu(pmc);

arch/x86/kvm/pmu.c

193

if (pmc->perf_event && pmc->perf_event->attr.precise_ip) {

arch/x86/kvm/pmu.c

208

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

arch/x86/kvm/pmu.c

211

if (pmc->intr && !skip_pmi)

arch/x86/kvm/pmu.c

212

kvm_make_request(KVM_REQ_PMI, pmc->vcpu);

arch/x86/kvm/pmu.c

219

struct kvm_pmc *pmc = perf_event->overflow_handler_context;

arch/x86/kvm/pmu.c

226

if (test_and_set_bit(pmc->idx, pmc_to_pmu(pmc)->reprogram_pmi))

arch/x86/kvm/pmu.c

229

__kvm_perf_overflow(pmc, true);

arch/x86/kvm/pmu.c

231

kvm_make_request(KVM_REQ_PMU, pmc->vcpu);

arch/x86/kvm/pmu.c

234

static u64 pmc_get_pebs_precise_level(struct kvm_pmc *pmc)

arch/x86/kvm/pmu.c

243

if ((pmc->idx == 0 && x86_match_cpu(vmx_pebs_pdist_cpu)) ||

arch/x86/kvm/pmu.c

244

(pmc->idx == 32 && x86_match_cpu(vmx_pebs_pdir_cpu)))

arch/x86/kvm/pmu.c

256

static u64 get_sample_period(struct kvm_pmc *pmc, u64 counter_value)

arch/x86/kvm/pmu.c

258

u64 sample_period = (-counter_value) & pmc_bitmask(pmc);

arch/x86/kvm/pmu.c

261

sample_period = pmc_bitmask(pmc) + 1;

arch/x86/kvm/pmu.c

265

static int pmc_reprogram_counter(struct kvm_pmc *pmc, u32 type, u64 config,

arch/x86/kvm/pmu.c

269

struct kvm_pmu *pmu = pmc_to_pmu(pmc);

arch/x86/kvm/pmu.c

281

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

arch/x86/kvm/pmu.c

283

attr.sample_period = get_sample_period(pmc, pmc->counter);

arch/x86/kvm/pmu.c

301

attr.precise_ip = pmc_get_pebs_precise_level(pmc);

arch/x86/kvm/pmu.c

305

kvm_perf_overflow, pmc);

arch/x86/kvm/pmu.c

308

PTR_ERR(event), pmc->idx);

arch/x86/kvm/pmu.c

312

pmc->perf_event = event;

arch/x86/kvm/pmu.c

313

pmc_to_pmu(pmc)->event_count++;

arch/x86/kvm/pmu.c

314

pmc->is_paused = false;

arch/x86/kvm/pmu.c

315

pmc->intr = intr || pebs;

arch/x86/kvm/pmu.c

319

static bool pmc_pause_counter(struct kvm_pmc *pmc)

arch/x86/kvm/pmu.c

321

u64 counter = pmc->counter;

arch/x86/kvm/pmu.c

325

if (pmc->perf_event && !pmc->is_paused)

arch/x86/kvm/pmu.c

326

counter += perf_event_pause(pmc->perf_event, true);

arch/x86/kvm/pmu.c

334

prev_counter = counter & pmc_bitmask(pmc);

arch/x86/kvm/pmu.c

336

counter += pmc->emulated_counter;

arch/x86/kvm/pmu.c

337

pmc->counter = counter & pmc_bitmask(pmc);

arch/x86/kvm/pmu.c

339

pmc->emulated_counter = 0;

arch/x86/kvm/pmu.c

340

pmc->is_paused = true;

arch/x86/kvm/pmu.c

342

return pmc->counter < prev_counter;

arch/x86/kvm/pmu.c

345

static bool pmc_resume_counter(struct kvm_pmc *pmc)

arch/x86/kvm/pmu.c

347

if (!pmc->perf_event)

arch/x86/kvm/pmu.c

351

if (is_sampling_event(pmc->perf_event) &&

arch/x86/kvm/pmu.c

352

perf_event_period(pmc->perf_event,

arch/x86/kvm/pmu.c

353

get_sample_period(pmc, pmc->counter)))

arch/x86/kvm/pmu.c

356

if (test_bit(pmc->idx, (unsigned long *)&pmc_to_pmu(pmc)->pebs_enable) !=

arch/x86/kvm/pmu.c

357

(!!pmc->perf_event->attr.precise_ip))

arch/x86/kvm/pmu.c

361

perf_event_enable(pmc->perf_event);

arch/x86/kvm/pmu.c

362

pmc->is_paused = false;

arch/x86/kvm/pmu.c

367

static void pmc_release_perf_event(struct kvm_pmc *pmc)

arch/x86/kvm/pmu.c

369

if (pmc->perf_event) {

arch/x86/kvm/pmu.c

370

perf_event_release_kernel(pmc->perf_event);

arch/x86/kvm/pmu.c

371

pmc->perf_event = NULL;

arch/x86/kvm/pmu.c

372

pmc->current_config = 0;

arch/x86/kvm/pmu.c

373

pmc_to_pmu(pmc)->event_count--;

arch/x86/kvm/pmu.c

377

static void pmc_stop_counter(struct kvm_pmc *pmc)

arch/x86/kvm/pmu.c

379

if (pmc->perf_event) {

arch/x86/kvm/pmu.c

380

pmc->counter = pmc_read_counter(pmc);

arch/x86/kvm/pmu.c

381

pmc_release_perf_event(pmc);

arch/x86/kvm/pmu.c

385

static void pmc_update_sample_period(struct kvm_pmc *pmc)

arch/x86/kvm/pmu.c

387

if (!pmc->perf_event || pmc->is_paused ||

arch/x86/kvm/pmu.c

388

!is_sampling_event(pmc->perf_event))

arch/x86/kvm/pmu.c

391

perf_event_period(pmc->perf_event,

arch/x86/kvm/pmu.c

392

get_sample_period(pmc, pmc->counter));

arch/x86/kvm/pmu.c

395

void pmc_write_counter(struct kvm_pmc *pmc, u64 val)

arch/x86/kvm/pmu.c

397

if (kvm_vcpu_has_mediated_pmu(pmc->vcpu)) {

arch/x86/kvm/pmu.c

398

pmc->counter = val & pmc_bitmask(pmc);

arch/x86/kvm/pmu.c

410

pmc->emulated_counter = 0;

arch/x86/kvm/pmu.c

411

pmc->counter += val - pmc_read_counter(pmc);

arch/x86/kvm/pmu.c

412

pmc->counter &= pmc_bitmask(pmc);

arch/x86/kvm/pmu.c

413

pmc_update_sample_period(pmc);

arch/x86/kvm/pmu.c

523

static bool pmc_is_event_allowed(struct kvm_pmc *pmc)

arch/x86/kvm/pmu.c

526

struct kvm *kvm = pmc->vcpu->kvm;

arch/x86/kvm/pmu.c

532

if (pmc_is_gp(pmc))

arch/x86/kvm/pmu.c

533

return is_gp_event_allowed(filter, pmc->eventsel);

arch/x86/kvm/pmu.c

535

return is_fixed_event_allowed(filter, pmc->idx);

arch/x86/kvm/pmu.c

538

static void kvm_mediated_pmu_refresh_event_filter(struct kvm_pmc *pmc)

arch/x86/kvm/pmu.c

540

bool allowed = pmc_is_locally_enabled(pmc) && pmc_is_event_allowed(pmc);

arch/x86/kvm/pmu.c

541

struct kvm_pmu *pmu = pmc_to_pmu(pmc);

arch/x86/kvm/pmu.c

543

if (pmc_is_gp(pmc)) {

arch/x86/kvm/pmu.c

544

pmc->eventsel_hw &= ~ARCH_PERFMON_EVENTSEL_ENABLE;

arch/x86/kvm/pmu.c

546

pmc->eventsel_hw |= pmc->eventsel &

arch/x86/kvm/pmu.c

549

u64 mask = intel_fixed_bits_by_idx(pmc->idx - KVM_FIXED_PMC_BASE_IDX, 0xf);

arch/x86/kvm/pmu.c

557

static int reprogram_counter(struct kvm_pmc *pmc)

arch/x86/kvm/pmu.c

559

struct kvm_pmu *pmu = pmc_to_pmu(pmc);

arch/x86/kvm/pmu.c

560

u64 eventsel = pmc->eventsel;

arch/x86/kvm/pmu.c

566

kvm_mediated_pmu_refresh_event_filter(pmc);

arch/x86/kvm/pmu.c

570

emulate_overflow = pmc_pause_counter(pmc);

arch/x86/kvm/pmu.c

572

if (!pmc_is_globally_enabled(pmc) || !pmc_is_locally_enabled(pmc) ||

arch/x86/kvm/pmu.c

573

!pmc_is_event_allowed(pmc))

arch/x86/kvm/pmu.c

577

__kvm_perf_overflow(pmc, false);

arch/x86/kvm/pmu.c

582

if (pmc_is_fixed(pmc)) {

arch/x86/kvm/pmu.c

584

pmc->idx - KVM_FIXED_PMC_BASE_IDX);

arch/x86/kvm/pmu.c

594

if (pmc->current_config == new_config && pmc_resume_counter(pmc))

arch/x86/kvm/pmu.c

597

pmc_release_perf_event(pmc);

arch/x86/kvm/pmu.c

599

pmc->current_config = new_config;

arch/x86/kvm/pmu.c

601

return pmc_reprogram_counter(pmc, PERF_TYPE_RAW,

arch/x86/kvm/pmu.c

608

static bool pmc_is_event_match(struct kvm_pmc *pmc, u64 eventsel)

arch/x86/kvm/pmu.c

624

return !((pmc->eventsel ^ eventsel) & AMD64_RAW_EVENT_MASK_NB);

arch/x86/kvm/pmu.c

627

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

arch/x86/kvm/pmu.c

629

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

arch/x86/kvm/pmu.c

630

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

arch/x86/kvm/pmu.c

638

if (!pmc_is_locally_enabled(pmc))

arch/x86/kvm/pmu.c

641

if (pmc_is_event_match(pmc, kvm_pmu_eventsel.INSTRUCTIONS_RETIRED))

arch/x86/kvm/pmu.c

642

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

arch/x86/kvm/pmu.c

644

if (pmc_is_event_match(pmc, kvm_pmu_eventsel.BRANCH_INSTRUCTIONS_RETIRED))

arch/x86/kvm/pmu.c

645

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

arch/x86/kvm/pmu.c

653

struct kvm_pmc *pmc;

arch/x86/kvm/pmu.c

666

kvm_for_each_pmc(pmu, pmc, bit, bitmap) {

arch/x86/kvm/pmu.c

673

if (reprogram_counter(pmc))

arch/x86/kvm/pmu.c

674

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

arch/x86/kvm/pmu.c

685

kvm_for_each_pmc(pmu, pmc, bit, bitmap)

arch/x86/kvm/pmu.c

686

kvm_pmu_recalc_pmc_emulation(pmu, pmc);

arch/x86/kvm/pmu.c

743

struct kvm_pmc *pmc;

arch/x86/kvm/pmu.c

752

pmc = kvm_pmu_call(rdpmc_ecx_to_pmc)(vcpu, idx, &mask);

arch/x86/kvm/pmu.c

753

if (!pmc)

arch/x86/kvm/pmu.c

761

*data = pmc_read_counter(pmc) & mask;

arch/x86/kvm/pmu.c

830

struct kvm_pmc *pmc = kvm_pmu_call(msr_idx_to_pmc)(vcpu, msr);

arch/x86/kvm/pmu.c

832

if (pmc)

arch/x86/kvm/pmu.c

833

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

arch/x86/kvm/pmu.c

934

struct kvm_pmc *pmc;

arch/x86/kvm/pmu.c

942

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

arch/x86/kvm/pmu.c

943

pmc_stop_counter(pmc);

arch/x86/kvm/pmu.c

944

pmc->counter = 0;

arch/x86/kvm/pmu.c

945

pmc->emulated_counter = 0;

arch/x86/kvm/pmu.c

947

if (pmc_is_gp(pmc)) {

arch/x86/kvm/pmu.c

948

pmc->eventsel = 0;

arch/x86/kvm/pmu.c

949

pmc->eventsel_hw = 0;

arch/x86/kvm/pmu.h

11

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

arch/x86/kvm/pmu.h

117

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

arch/x86/kvm/pmu.h

119

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

arch/x86/kvm/pmu.h

123

static inline u64 pmc_bitmask(struct kvm_pmc *pmc)

arch/x86/kvm/pmu.h

125

struct kvm_pmu *pmu = pmc_to_pmu(pmc);

arch/x86/kvm/pmu.h

127

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

arch/x86/kvm/pmu.h

130

static inline u64 pmc_read_counter(struct kvm_pmc *pmc)

arch/x86/kvm/pmu.h

134

if (kvm_vcpu_has_mediated_pmu(pmc->vcpu))

arch/x86/kvm/pmu.h

135

return pmc->counter & pmc_bitmask(pmc);

arch/x86/kvm/pmu.h

137

counter = pmc->counter + pmc->emulated_counter;

arch/x86/kvm/pmu.h

139

if (pmc->perf_event && !pmc->is_paused)

arch/x86/kvm/pmu.h

140

counter += perf_event_read_value(pmc->perf_event,

arch/x86/kvm/pmu.h

143

return counter & pmc_bitmask(pmc);

arch/x86/kvm/pmu.h

146

void pmc_write_counter(struct kvm_pmc *pmc, u64 val);

arch/x86/kvm/pmu.h

148

static inline bool pmc_is_gp(struct kvm_pmc *pmc)

arch/x86/kvm/pmu.h

150

return pmc->type == KVM_PMC_GP;

arch/x86/kvm/pmu.h

153

static inline bool pmc_is_fixed(struct kvm_pmc *pmc)

arch/x86/kvm/pmu.h

155

return pmc->type == KVM_PMC_FIXED;

arch/x86/kvm/pmu.h

196

static inline bool pmc_is_locally_enabled(struct kvm_pmc *pmc)

arch/x86/kvm/pmu.h

198

struct kvm_pmu *pmu = pmc_to_pmu(pmc);

arch/x86/kvm/pmu.h

200

if (pmc_is_fixed(pmc))

arch/x86/kvm/pmu.h

202

pmc->idx - KVM_FIXED_PMC_BASE_IDX) &

arch/x86/kvm/pmu.h

205

if (!(pmc->eventsel & ARCH_PERFMON_EVENTSEL_ENABLE))

arch/x86/kvm/pmu.h

208

if (!test_bit(pmc->idx, pmu->pmc_has_mode_specific_enables))

arch/x86/kvm/pmu.h

211

return !kvm_pmu_call(pmc_is_disabled_in_current_mode)(pmc);

arch/x86/kvm/pmu.h

218

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

arch/x86/kvm/pmu.h

221

static inline void kvm_pmu_request_counter_reprogram(struct kvm_pmc *pmc)

arch/x86/kvm/pmu.h

223

kvm_pmu_recalc_pmc_emulation(pmc_to_pmu(pmc), pmc);

arch/x86/kvm/pmu.h

225

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

arch/x86/kvm/pmu.h

226

kvm_make_request(KVM_REQ_PMU, pmc->vcpu);

arch/x86/kvm/pmu.h

254

static inline bool pmc_is_globally_enabled(struct kvm_pmc *pmc)

arch/x86/kvm/pmu.h

256

struct kvm_pmu *pmu = pmc_to_pmu(pmc);

arch/x86/kvm/pmu.h

261

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

arch/x86/kvm/pmu.h

275

int kvm_pmu_rdpmc(struct kvm_vcpu *vcpu, unsigned pmc, u64 *data);

arch/x86/kvm/pmu.h

39

bool (*pmc_is_disabled_in_current_mode)(struct kvm_pmc *pmc);

arch/x86/kvm/svm/pmu.c

101

return pmc;

arch/x86/kvm/svm/pmu.c

131

struct kvm_pmc *pmc;

arch/x86/kvm/svm/pmu.c

135

pmc = get_gp_pmc_amd(pmu, msr, PMU_TYPE_COUNTER);

arch/x86/kvm/svm/pmu.c

136

if (pmc) {

arch/x86/kvm/svm/pmu.c

137

msr_info->data = pmc_read_counter(pmc);

arch/x86/kvm/svm/pmu.c

141

pmc = get_gp_pmc_amd(pmu, msr, PMU_TYPE_EVNTSEL);

arch/x86/kvm/svm/pmu.c

142

if (pmc) {

arch/x86/kvm/svm/pmu.c

143

msr_info->data = pmc->eventsel;

arch/x86/kvm/svm/pmu.c

153

struct kvm_pmc *pmc;

arch/x86/kvm/svm/pmu.c

158

pmc = get_gp_pmc_amd(pmu, msr, PMU_TYPE_COUNTER);

arch/x86/kvm/svm/pmu.c

159

if (pmc) {

arch/x86/kvm/svm/pmu.c

160

pmc_write_counter(pmc, data);

arch/x86/kvm/svm/pmu.c

164

pmc = get_gp_pmc_amd(pmu, msr, PMU_TYPE_EVNTSEL);

arch/x86/kvm/svm/pmu.c

165

if (pmc) {

arch/x86/kvm/svm/pmu.c

167

if (data != pmc->eventsel) {

arch/x86/kvm/svm/pmu.c

168

pmc->eventsel = data;

arch/x86/kvm/svm/pmu.c

169

pmc->eventsel_hw = (data & ~AMD64_EVENTSEL_HOSTONLY) |

arch/x86/kvm/svm/pmu.c

173

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

arch/x86/kvm/svm/pmu.c

175

__clear_bit(pmc->idx, pmu->pmc_has_mode_specific_enables);

arch/x86/kvm/svm/pmu.c

177

kvm_pmu_request_counter_reprogram(pmc);

arch/x86/kvm/svm/pmu.c

273

static bool amd_pmc_is_disabled_in_current_mode(struct kvm_pmc *pmc)

arch/x86/kvm/svm/pmu.c

275

struct kvm_vcpu *vcpu = pmc->vcpu;

arch/x86/kvm/svm/pmu.c

282

if (WARN_ON_ONCE(!(pmc->eventsel & ARCH_PERFMON_EVENTSEL_ENABLE)))

arch/x86/kvm/svm/pmu.c

286

host_guest_bits = pmc->eventsel & AMD64_EVENTSEL_HOST_GUEST_MASK;

arch/x86/kvm/svm/pmu.c

96

struct kvm_pmc *pmc;

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/vmx/pmu_intel.c

217

struct kvm_pmc *pmc;

arch/x86/kvm/vmx/pmu_intel.c

219

pmc = get_fixed_pmc(pmu, msr);

arch/x86/kvm/vmx/pmu_intel.c

220

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

arch/x86/kvm/vmx/pmu_intel.c

221

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

arch/x86/kvm/vmx/pmu_intel.c

223

return pmc;

arch/x86/kvm/vmx/pmu_intel.c

342

struct kvm_pmc *pmc;

arch/x86/kvm/vmx/pmu_intel.c

359

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

arch/x86/kvm/vmx/pmu_intel.c

360

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

arch/x86/kvm/vmx/pmu_intel.c

361

u64 val = pmc_read_counter(pmc);

arch/x86/kvm/vmx/pmu_intel.c

365

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

arch/x86/kvm/vmx/pmu_intel.c

366

u64 val = pmc_read_counter(pmc);

arch/x86/kvm/vmx/pmu_intel.c

370

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

arch/x86/kvm/vmx/pmu_intel.c

371

msr_info->data = pmc->eventsel;

arch/x86/kvm/vmx/pmu_intel.c

385

struct kvm_pmc *pmc;

arch/x86/kvm/vmx/pmu_intel.c

421

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

arch/x86/kvm/vmx/pmu_intel.c

422

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

arch/x86/kvm/vmx/pmu_intel.c

430

pmc_write_counter(pmc, data);

arch/x86/kvm/vmx/pmu_intel.c

432

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

arch/x86/kvm/vmx/pmu_intel.c

433

pmc_write_counter(pmc, data);

arch/x86/kvm/vmx/pmu_intel.c

435

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

arch/x86/kvm/vmx/pmu_intel.c

437

if ((pmc->idx == 2) &&

arch/x86/kvm/vmx/pmu_intel.c

443

if (data != pmc->eventsel) {

arch/x86/kvm/vmx/pmu_intel.c

444

pmc->eventsel = data;

arch/x86/kvm/vmx/pmu_intel.c

445

pmc->eventsel_hw = data;

arch/x86/kvm/vmx/pmu_intel.c

446

kvm_pmu_request_counter_reprogram(pmc);

arch/x86/kvm/vmx/pmu_intel.c

69

struct kvm_pmc *pmc;

arch/x86/kvm/vmx/pmu_intel.c

752

struct kvm_pmc *pmc = NULL;

arch/x86/kvm/vmx/pmu_intel.c

755

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

arch/x86/kvm/vmx/pmu_intel.c

756

if (!pmc_is_locally_enabled(pmc) ||

arch/x86/kvm/vmx/pmu_intel.c

757

!pmc_is_globally_enabled(pmc) || !pmc->perf_event)

arch/x86/kvm/vmx/pmu_intel.c

764

hw_idx = pmc->perf_event->hw.idx;

arch/x86/kvm/vmx/pmu_intel.c

765

if (hw_idx != pmc->idx && hw_idx > -1)

arch/x86/kvm/vmx/pmu_intel.c

81

pmc = get_fixed_pmc(pmu, MSR_CORE_PERF_FIXED_CTR0 + i);

arch/x86/kvm/vmx/pmu_intel.c

84

kvm_pmu_request_counter_reprogram(pmc);

arch/x86/kvm/x86.c

1581

u32 pmc = kvm_ecx_read(vcpu);

arch/x86/kvm/x86.c

1584

if (kvm_pmu_rdpmc(vcpu, pmc, &data)) {

arch/x86/kvm/x86.c

8774

static int emulator_check_rdpmc_early(struct x86_emulate_ctxt *ctxt, u32 pmc)

arch/x86/kvm/x86.c

8776

return kvm_pmu_check_rdpmc_early(emul_to_vcpu(ctxt), pmc);

arch/x86/kvm/x86.c

8780

u32 pmc, u64 *pdata)

arch/x86/kvm/x86.c

8782

return kvm_pmu_rdpmc(emul_to_vcpu(ctxt), pmc, pdata);

arch/x86/pci/fixup.c

1034

u16 pmc;

arch/x86/pci/fixup.c

1040

pci_read_config_word(rp, rp->pm_cap + PCI_PM_PMC, &pmc);

arch/x86/pci/fixup.c

1041

rp->pme_support = FIELD_GET(PCI_PM_CAP_PME_MASK, pmc);

drivers/ata/ahci_tegra.c

178

struct tegra_pmc *pmc;

drivers/ata/ahci_tegra.c

250

ret = tegra_pmc_powergate_sequence_power_up(tegra->pmc,

drivers/ata/ahci_tegra.c

274

tegra_pmc_powergate_power_off(tegra->pmc, TEGRA_POWERGATE_SATA);

drivers/ata/ahci_tegra.c

294

tegra_pmc_powergate_power_off(tegra->pmc, TEGRA_POWERGATE_SATA);

drivers/ata/ahci_tegra.c

576

tegra->pmc = devm_tegra_pmc_get(&pdev->dev);

drivers/ata/ahci_tegra.c

577

if (IS_ERR(tegra->pmc))

drivers/ata/ahci_tegra.c

578

return dev_err_probe(&pdev->dev, PTR_ERR(tegra->pmc),

drivers/clk/tegra/clk-pll.c

1880

void __iomem *pmc, struct tegra_clk_pll_params *pll_params,

drivers/clk/tegra/clk-pll.c

1890

pll->pmc = pmc;

drivers/clk/tegra/clk-pll.c

1931

void __iomem *clk_base, void __iomem *pmc,

drivers/clk/tegra/clk-pll.c

1940

pll = _tegra_init_pll(clk_base, pmc, pll_params, lock);

drivers/clk/tegra/clk-pll.c

1962

void __iomem *clk_base, void __iomem *pmc,

drivers/clk/tegra/clk-pll.c

1974

pll = _tegra_init_pll(clk_base, pmc, pll_params, lock);

drivers/clk/tegra/clk-pll.c

2053

void __iomem *clk_base, void __iomem *pmc,

drivers/clk/tegra/clk-pll.c

2104

pll = _tegra_init_pll(clk_base, pmc, pll_params, lock);

drivers/clk/tegra/clk-pll.c

2117

void __iomem *clk_base, void __iomem *pmc,

drivers/clk/tegra/clk-pll.c

2132

pll = _tegra_init_pll(clk_base, pmc, pll_params, lock);

drivers/clk/tegra/clk-pll.c

2166

void __iomem *clk_base, void __iomem *pmc,

drivers/clk/tegra/clk-pll.c

2195

pll = _tegra_init_pll(clk_base, pmc, pll_params, lock);

drivers/clk/tegra/clk-pll.c

2208

void __iomem *clk_base, void __iomem *pmc,

drivers/clk/tegra/clk-pll.c

2234

pll = _tegra_init_pll(clk_base, pmc, pll_params, lock);

drivers/clk/tegra/clk-pll.c

233

#define pll_override_readl(offset, p) readl_relaxed(p->pmc + offset)

drivers/clk/tegra/clk-pll.c

240

#define pll_override_writel(val, offset, p) writel(val, p->pmc + offset)

drivers/clk/tegra/clk-pll.c

2423

void __iomem *pmc, unsigned long flags,

drivers/clk/tegra/clk-pll.c

2436

pll = _tegra_init_pll(clk_base, pmc, pll_params, lock);

drivers/clk/tegra/clk-pll.c

2609

void __iomem *pmc, unsigned long flags,

drivers/clk/tegra/clk-pll.c

2637

pll = _tegra_init_pll(clk_base, pmc, pll_params, lock);

drivers/clk/tegra/clk-pll.c

2699

void __iomem *clk_base, void __iomem *pmc,

drivers/clk/tegra/clk-pll.c

2728

pll = _tegra_init_pll(clk_base, pmc, pll_params, lock);

drivers/clk/tegra/clk-pll.c

332

u32 val = readl_relaxed(pll->pmc + PMC_PLLP_WB0_OVERRIDE);

drivers/clk/tegra/clk-pll.c

383

val = readl_relaxed(pll->pmc + PMC_PLLP_WB0_OVERRIDE);

drivers/clk/tegra/clk-pll.c

385

writel_relaxed(val, pll->pmc + PMC_PLLP_WB0_OVERRIDE);

drivers/clk/tegra/clk-pll.c

401

val = readl_relaxed(pll->pmc + PMC_PLLP_WB0_OVERRIDE);

drivers/clk/tegra/clk-pll.c

403

writel_relaxed(val, pll->pmc + PMC_PLLP_WB0_OVERRIDE);

drivers/clk/tegra/clk-pll.c

924

if (!pll->pmc)

drivers/clk/tegra/clk-pll.c

931

val = readl(pll->pmc + PMC_SATA_PWRGT);

drivers/clk/tegra/clk-pll.c

933

writel(val, pll->pmc + PMC_SATA_PWRGT);

drivers/clk/tegra/clk-pll.c

935

val = readl(pll->pmc + PMC_SATA_PWRGT);

drivers/clk/tegra/clk-pll.c

937

writel(val, pll->pmc + PMC_SATA_PWRGT);

drivers/clk/tegra/clk-pll.c

939

val = readl(pll->pmc + PMC_SATA_PWRGT);

drivers/clk/tegra/clk-pll.c

941

writel(val, pll->pmc + PMC_SATA_PWRGT);

drivers/clk/tegra/clk-tegra114.c

900

void __iomem *pmc)

drivers/clk/tegra/clk-tegra114.c

906

pmc, 0, &pll_c_params, NULL);

drivers/clk/tegra/clk-tegra114.c

919

clk = tegra_clk_register_pllc("pll_c2", "pll_ref", clk_base, pmc, 0,

drivers/clk/tegra/clk-tegra114.c

924

clk = tegra_clk_register_pllc("pll_c3", "pll_ref", clk_base, pmc, 0,

drivers/clk/tegra/clk-tegra114.c

929

clk = tegra_clk_register_pllm("pll_m", "pll_ref", clk_base, pmc,

drivers/clk/tegra/clk-tegra114.c

973

clk = tegra_clk_register_pll("pll_d", "pll_ref", clk_base, pmc, 0,

drivers/clk/tegra/clk-tegra114.c

983

clk = tegra_clk_register_pll("pll_d2", "pll_ref", clk_base, pmc, 0,

drivers/clk/tegra/clk-tegra114.c

993

clk = tegra_clk_register_pllre("pll_re_vco", "pll_ref", clk_base, pmc,

drivers/clk/tegra/clk-tegra124.c

1087

void __iomem *pmc)

drivers/clk/tegra/clk-tegra124.c

1093

pmc, 0, &pll_c_params, NULL);

drivers/clk/tegra/clk-tegra124.c

1114

clk = tegra_clk_register_pllc("pll_c2", "pll_ref", clk_base, pmc, 0,

drivers/clk/tegra/clk-tegra124.c

1120

clk = tegra_clk_register_pllc("pll_c3", "pll_ref", clk_base, pmc, 0,

drivers/clk/tegra/clk-tegra124.c

1126

clk = tegra_clk_register_pllm("pll_m", "pll_ref", clk_base, pmc,

drivers/clk/tegra/clk-tegra124.c

1179

clk = tegra_clk_register_pll("pll_d", "pll_ref", clk_base, pmc, 0,

drivers/clk/tegra/clk-tegra124.c

1191

clk = tegra_clk_register_pllre("pll_re_vco", "pll_ref", clk_base, pmc,

drivers/clk/tegra/clk-tegra210.c

3195

void __iomem *pmc)

drivers/clk/tegra/clk-tegra210.c

3201

pmc, 0, &pll_c_params, NULL);

drivers/clk/tegra/clk-tegra210.c

3224

pmc, 0, &pll_c2_params, NULL);

drivers/clk/tegra/clk-tegra210.c

3230

pmc, 0, &pll_c3_params, NULL);

drivers/clk/tegra/clk-tegra210.c

3235

clk = tegra_clk_register_pllm("pll_m", "osc", clk_base, pmc,

drivers/clk/tegra/clk-tegra210.c

3241

clk = tegra_clk_register_pllmb("pll_mb", "osc", clk_base, pmc,

drivers/clk/tegra/clk-tegra210.c

3322

clk = tegra_clk_register_pll("pll_d", "pll_ref", clk_base, pmc, 0,

drivers/clk/tegra/clk-tegra210.c

3335

clk_base, pmc, 0,

drivers/clk/tegra/clk-tegra210.c

3363

clk = tegra_clk_register_pllre("pll_c4_vco", "pll_ref", clk_base, pmc,

drivers/clk/tegra/clk.h

380

void __iomem *pmc;

drivers/clk/tegra/clk.h

405

void __iomem *clk_base, void __iomem *pmc,

drivers/clk/tegra/clk.h

410

void __iomem *clk_base, void __iomem *pmc,

drivers/clk/tegra/clk.h

415

void __iomem *clk_base, void __iomem *pmc,

drivers/clk/tegra/clk.h

421

void __iomem *clk_base, void __iomem *pmc,

drivers/clk/tegra/clk.h

427

void __iomem *clk_base, void __iomem *pmc,

drivers/clk/tegra/clk.h

433

void __iomem *clk_base, void __iomem *pmc,

drivers/clk/tegra/clk.h

440

void __iomem *pmc, unsigned long flags,

drivers/clk/tegra/clk.h

458

void __iomem *pmc, unsigned long flags,

drivers/clk/tegra/clk.h

474

void __iomem *clk_base, void __iomem *pmc,

drivers/edac/igen6_edac.c

1691

int lmc, pmc, rc;

drivers/edac/igen6_edac.c

1694

for (lmc = 0, pmc = 0; pmc < NUM_IMC; pmc++) {

drivers/edac/igen6_edac.c

1695

base = mchbar + pmc * MCHBAR_SIZE;

drivers/edac/igen6_edac.c

1698

igen6_printk(KERN_ERR, "Failed to ioremap 0x%llx for mc%d\n", base, pmc);

drivers/edac/igen6_edac.c

1705

edac_dbg(2, "Skip absent mc%d\n", pmc);

drivers/edac/imh_base.c

169

int i, rc, pmc;

drivers/edac/imh_base.c

206

pmc = north ? i : 8 + i;

drivers/edac/imh_base.c

207

skx_set_mc_mapping(d, pmc, lmc);

drivers/edac/skx_common.c

413

void skx_set_mc_mapping(struct skx_dev *d, u8 pmc, u8 lmc)

drivers/edac/skx_common.c

416

pmc, lmc);

drivers/edac/skx_common.c

418

d->imc[lmc].mc_mapping = pmc;

drivers/edac/skx_common.c

422

static int skx_get_mc_mapping(struct skx_dev *d, u8 pmc)

drivers/edac/skx_common.c

425

if (d->imc[lmc].mc_mapping == pmc) {

drivers/edac/skx_common.c

427

pmc, lmc);

drivers/edac/skx_common.h

357

void skx_set_mc_mapping(struct skx_dev *d, u8 pmc, u8 lmc);

drivers/gpu/drm/amd/amdkfd/kfd_chardev.c

3415

return kfd_profiler_pmc(p, &args->pmc);

drivers/gpu/drm/etnaviv/etnaviv_gpu.c

637

u32 pmc, ppc;

drivers/gpu/drm/etnaviv/etnaviv_gpu.c

650

pmc = gpu_read_power(gpu, VIVS_PM_MODULE_CONTROLS);

drivers/gpu/drm/etnaviv/etnaviv_gpu.c

656

pmc |= VIVS_PM_MODULE_CONTROLS_DISABLE_MODULE_CLOCK_GATING_PA;

drivers/gpu/drm/etnaviv/etnaviv_gpu.c

666

pmc |= VIVS_PM_MODULE_CONTROLS_DISABLE_MODULE_CLOCK_GATING_PE;

drivers/gpu/drm/etnaviv/etnaviv_gpu.c

669

pmc |= BIT(15); /* Unknown bit */

drivers/gpu/drm/etnaviv/etnaviv_gpu.c

676

pmc |= VIVS_PM_MODULE_CONTROLS_DISABLE_MODULE_CLOCK_GATING_TX;

drivers/gpu/drm/etnaviv/etnaviv_gpu.c

680

pmc |= VIVS_PM_MODULE_CONTROLS_DISABLE_MODULE_CLOCK_GATING_SE |

drivers/gpu/drm/etnaviv/etnaviv_gpu.c

687

pmc |= VIVS_PM_MODULE_CONTROLS_DISABLE_MODULE_CLOCK_GATING_SH_EU;

drivers/gpu/drm/etnaviv/etnaviv_gpu.c

689

pmc |= VIVS_PM_MODULE_CONTROLS_DISABLE_MODULE_CLOCK_GATING_RA_HZ;

drivers/gpu/drm/etnaviv/etnaviv_gpu.c

690

pmc |= VIVS_PM_MODULE_CONTROLS_DISABLE_MODULE_CLOCK_GATING_RA_EZ;

drivers/gpu/drm/etnaviv/etnaviv_gpu.c

692

gpu_write_power(gpu, VIVS_PM_MODULE_CONTROLS, pmc);

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

21

struct tegra_pmc *pmc;

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

311

tdev->pmc = devm_tegra_pmc_get(&pdev->dev);

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

312

if (IS_ERR(tdev->pmc)) {

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

313

ret = PTR_ERR(tdev->pmc);

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

57

ret = tegra_pmc_powergate_remove_clamping(tdev->pmc,

drivers/gpu/drm/nouveau/nvkm/subdev/mc/base.c

128

enum nvkm_subdev_type type, int inst, struct nvkm_mc **pmc)

drivers/gpu/drm/nouveau/nvkm/subdev/mc/base.c

133

if (!(mc = *pmc = kzalloc_obj(*mc)))

drivers/gpu/drm/nouveau/nvkm/subdev/mc/g84.c

64

g84_mc_new(struct nvkm_device *device, enum nvkm_subdev_type type, int inst, struct nvkm_mc **pmc)

drivers/gpu/drm/nouveau/nvkm/subdev/mc/g84.c

66

return nvkm_mc_new_(&g84_mc, device, type, inst, pmc);

drivers/gpu/drm/nouveau/nvkm/subdev/mc/g98.c

64

g98_mc_new(struct nvkm_device *device, enum nvkm_subdev_type type, int inst, struct nvkm_mc **pmc)

drivers/gpu/drm/nouveau/nvkm/subdev/mc/g98.c

66

return nvkm_mc_new_(&g98_mc, device, type, inst, pmc);

drivers/gpu/drm/nouveau/nvkm/subdev/mc/ga100.c

75

ga100_mc_new(struct nvkm_device *device, enum nvkm_subdev_type type, int inst, struct nvkm_mc **pmc)

drivers/gpu/drm/nouveau/nvkm/subdev/mc/ga100.c

80

return nvkm_mc_new_(&ga100_mc, device, type, inst, pmc);

drivers/gpu/drm/nouveau/nvkm/subdev/mc/gf100.c

79

gf100_mc_new(struct nvkm_device *device, enum nvkm_subdev_type type, int inst, struct nvkm_mc **pmc)

drivers/gpu/drm/nouveau/nvkm/subdev/mc/gf100.c

81

return nvkm_mc_new_(&gf100_mc, device, type, inst, pmc);

drivers/gpu/drm/nouveau/nvkm/subdev/mc/gk104.c

63

gk104_mc_new(struct nvkm_device *device, enum nvkm_subdev_type type, int inst, struct nvkm_mc **pmc)

drivers/gpu/drm/nouveau/nvkm/subdev/mc/gk104.c

65

return nvkm_mc_new_(&gk104_mc, device, type, inst, pmc);

drivers/gpu/drm/nouveau/nvkm/subdev/mc/gk20a.c

37

gk20a_mc_new(struct nvkm_device *device, enum nvkm_subdev_type type, int inst, struct nvkm_mc **pmc)

drivers/gpu/drm/nouveau/nvkm/subdev/mc/gk20a.c

39

return nvkm_mc_new_(&gk20a_mc, device, type, inst, pmc);

drivers/gpu/drm/nouveau/nvkm/subdev/mc/gp100.c

101

gp100_mc_new(struct nvkm_device *device, enum nvkm_subdev_type type, int inst, struct nvkm_mc **pmc)

drivers/gpu/drm/nouveau/nvkm/subdev/mc/gp100.c

106

return nvkm_mc_new_(&gp100_mc, device, type, inst, pmc);

drivers/gpu/drm/nouveau/nvkm/subdev/mc/gp10b.c

45

gp10b_mc_new(struct nvkm_device *device, enum nvkm_subdev_type type, int inst, struct nvkm_mc **pmc)

drivers/gpu/drm/nouveau/nvkm/subdev/mc/gp10b.c

47

return nvkm_mc_new_(&gp10b_mc, device, type, inst, pmc);

drivers/gpu/drm/nouveau/nvkm/subdev/mc/gt215.c

91

gt215_mc_new(struct nvkm_device *device, enum nvkm_subdev_type type, int inst, struct nvkm_mc **pmc)

drivers/gpu/drm/nouveau/nvkm/subdev/mc/gt215.c

93

return nvkm_mc_new_(&gt215_mc, device, type, inst, pmc);

drivers/gpu/drm/nouveau/nvkm/subdev/mc/nv04.c

134

nv04_mc_new(struct nvkm_device *device, enum nvkm_subdev_type type, int inst, struct nvkm_mc **pmc)

drivers/gpu/drm/nouveau/nvkm/subdev/mc/nv04.c

136

return nvkm_mc_new_(&nv04_mc, device, type, inst, pmc);

drivers/gpu/drm/nouveau/nvkm/subdev/mc/nv11.c

46

nv11_mc_new(struct nvkm_device *device, enum nvkm_subdev_type type, int inst, struct nvkm_mc **pmc)

drivers/gpu/drm/nouveau/nvkm/subdev/mc/nv11.c

48

return nvkm_mc_new_(&nv11_mc, device, type, inst, pmc);

drivers/gpu/drm/nouveau/nvkm/subdev/mc/nv17.c

55

nv17_mc_new(struct nvkm_device *device, enum nvkm_subdev_type type, int inst, struct nvkm_mc **pmc)

drivers/gpu/drm/nouveau/nvkm/subdev/mc/nv17.c

57

return nvkm_mc_new_(&nv17_mc, device, type, inst, pmc);

drivers/gpu/drm/nouveau/nvkm/subdev/mc/nv44.c

50

nv44_mc_new(struct nvkm_device *device, enum nvkm_subdev_type type, int inst, struct nvkm_mc **pmc)

drivers/gpu/drm/nouveau/nvkm/subdev/mc/nv44.c

52

return nvkm_mc_new_(&nv44_mc, device, type, inst, pmc);

drivers/gpu/drm/nouveau/nvkm/subdev/mc/nv50.c

57

nv50_mc_new(struct nvkm_device *device, enum nvkm_subdev_type type, int inst, struct nvkm_mc **pmc)

drivers/gpu/drm/nouveau/nvkm/subdev/mc/nv50.c

59

return nvkm_mc_new_(&nv50_mc, device, type, inst, pmc);

drivers/gpu/drm/tegra/dc.c

2882

tegra_pmc_powergate_power_off(dc->pmc, dc->powergate);

drivers/gpu/drm/tegra/dc.c

2903

err = tegra_pmc_powergate_sequence_power_up(dc->pmc,

drivers/gpu/drm/tegra/dc.c

3334

dc->pmc = devm_tegra_pmc_get(dc->dev);

drivers/gpu/drm/tegra/dc.c

3335

if (IS_ERR(dc->pmc))

drivers/gpu/drm/tegra/dc.c

3336

return dev_err_probe(dc->dev, PTR_ERR(dc->pmc),

drivers/gpu/drm/tegra/dc.c

3344

tegra_pmc_powergate_power_off(dc->pmc, dc->powergate);

drivers/gpu/drm/tegra/dc.h

97

struct tegra_pmc *pmc;

drivers/gpu/drm/tegra/gr3d.c

354

err = tegra_pmc_powergate_sequence_power_up(gr3d->pmc, id,

drivers/gpu/drm/tegra/gr3d.c

387

gr3d->pmc = devm_tegra_pmc_get(dev);

drivers/gpu/drm/tegra/gr3d.c

388

if (IS_ERR(gr3d->pmc))

drivers/gpu/drm/tegra/gr3d.c

389

return dev_err_probe(dev, PTR_ERR(gr3d->pmc),

drivers/gpu/drm/tegra/gr3d.c

49

struct tegra_pmc *pmc;

drivers/gpu/drm/tegra/sor.c

2243

err = tegra_pmc_io_pad_power_disable(sor->pmc, sor->pad);

drivers/gpu/drm/tegra/sor.c

2283

err = tegra_pmc_io_pad_power_enable(sor->pmc, sor->pad);

drivers/gpu/drm/tegra/sor.c

2718

err = tegra_pmc_io_pad_power_disable(sor->pmc, sor->pad);

drivers/gpu/drm/tegra/sor.c

2760

err = tegra_pmc_io_pad_power_enable(sor->pmc, sor->pad);

drivers/gpu/drm/tegra/sor.c

3766

sor->pmc = devm_tegra_pmc_get(&pdev->dev);

drivers/gpu/drm/tegra/sor.c

3767

if (IS_ERR(sor->pmc))

drivers/gpu/drm/tegra/sor.c

3768

return PTR_ERR(sor->pmc);

drivers/gpu/drm/tegra/sor.c

426

struct tegra_pmc *pmc;

drivers/media/platform/nvidia/tegra-vde/vde.c

164

err = tegra_pmc_powergate_power_off(vde->pmc,

drivers/media/platform/nvidia/tegra-vde/vde.c

197

err = tegra_pmc_powergate_sequence_power_up(vde->pmc,

drivers/media/platform/nvidia/tegra-vde/vde.c

298

vde->pmc = devm_tegra_pmc_get(dev);

drivers/media/platform/nvidia/tegra-vde/vde.c

299

if (IS_ERR(vde->pmc))

drivers/media/platform/nvidia/tegra-vde/vde.c

300

return dev_err_probe(dev, PTR_ERR(vde->pmc),

drivers/media/platform/nvidia/tegra-vde/vde.h

110

struct tegra_pmc *pmc;

drivers/memory/samsung/exynos-srom.c

70

u32 bank, width, pmc = 0;

drivers/memory/samsung/exynos-srom.c

79

pmc = 1 << EXYNOS_SROM_BCX__PMC__SHIFT;

drivers/memory/samsung/exynos-srom.c

94

writel_relaxed(pmc | (timing[0] << EXYNOS_SROM_BCX__TACP__SHIFT) |

drivers/mfd/intel_pmc_bxt.c

107

int intel_pmc_gcr_update(struct intel_pmc_dev *pmc, u32 offset, u32 mask, u32 val)

drivers/mfd/intel_pmc_bxt.c

114

spin_lock(&pmc->gcr_lock);

drivers/mfd/intel_pmc_bxt.c

115

new_val = readl(pmc->gcr_mem_base + offset);

drivers/mfd/intel_pmc_bxt.c

118

writel(new_val, pmc->gcr_mem_base + offset);

drivers/mfd/intel_pmc_bxt.c

120

new_val = readl(pmc->gcr_mem_base + offset);

drivers/mfd/intel_pmc_bxt.c

121

spin_unlock(&pmc->gcr_lock);

drivers/mfd/intel_pmc_bxt.c

138

int intel_pmc_s0ix_counter_read(struct intel_pmc_dev *pmc, u64 *data)

drivers/mfd/intel_pmc_bxt.c

142

spin_lock(&pmc->gcr_lock);

drivers/mfd/intel_pmc_bxt.c

143

deep = readq(pmc->gcr_mem_base + PMC_GCR_TELEM_DEEP_S0IX_REG);

drivers/mfd/intel_pmc_bxt.c

144

shlw = readq(pmc->gcr_mem_base + PMC_GCR_TELEM_SHLW_S0IX_REG);

drivers/mfd/intel_pmc_bxt.c

145

spin_unlock(&pmc->gcr_lock);

drivers/mfd/intel_pmc_bxt.c

168

struct intel_pmc_dev *pmc = dev_get_drvdata(dev);

drivers/mfd/intel_pmc_bxt.c

169

struct intel_scu_ipc_dev *scu = pmc->scu;

drivers/mfd/intel_pmc_bxt.c

204

struct intel_pmc_dev *pmc = dev_get_drvdata(dev);

drivers/mfd/intel_pmc_bxt.c

205

struct intel_scu_ipc_dev *scu = pmc->scu;

drivers/mfd/intel_pmc_bxt.c

303

struct intel_pmc_dev *pmc,

drivers/mfd/intel_pmc_bxt.c

330

pmc->gcr_mem_base = devm_ioremap_resource(&pdev->dev, &gcr_res);

drivers/mfd/intel_pmc_bxt.c

331

if (IS_ERR(pmc->gcr_mem_base))

drivers/mfd/intel_pmc_bxt.c

332

return PTR_ERR(pmc->gcr_mem_base);

drivers/mfd/intel_pmc_bxt.c

387

pmc->telem_base = res;

drivers/mfd/intel_pmc_bxt.c

392

static int intel_pmc_create_devices(struct intel_pmc_dev *pmc)

drivers/mfd/intel_pmc_bxt.c

397

ret = devm_mfd_add_devices(pmc->dev, PLATFORM_DEVID_AUTO, &tco,

drivers/mfd/intel_pmc_bxt.c

403

ret = devm_mfd_add_devices(pmc->dev, PLATFORM_DEVID_AUTO, &punit, 1,

drivers/mfd/intel_pmc_bxt.c

408

if (pmc->telem_base) {

drivers/mfd/intel_pmc_bxt.c

409

ret = devm_mfd_add_devices(pmc->dev, PLATFORM_DEVID_AUTO,

drivers/mfd/intel_pmc_bxt.c

410

&telem, 1, pmc->telem_base, 0, NULL);

drivers/mfd/intel_pmc_bxt.c

425

struct intel_pmc_dev *pmc;

drivers/mfd/intel_pmc_bxt.c

428

pmc = devm_kzalloc(&pdev->dev, sizeof(*pmc), GFP_KERNEL);

drivers/mfd/intel_pmc_bxt.c

429

if (!pmc)

drivers/mfd/intel_pmc_bxt.c

432

pmc->dev = &pdev->dev;

drivers/mfd/intel_pmc_bxt.c

433

spin_lock_init(&pmc->gcr_lock);

drivers/mfd/intel_pmc_bxt.c

435

ret = intel_pmc_get_resources(pdev, pmc, &scu_data);

drivers/mfd/intel_pmc_bxt.c

441

pmc->scu = devm_intel_scu_ipc_register(&pdev->dev, &scu_data);

drivers/mfd/intel_pmc_bxt.c

442

if (IS_ERR(pmc->scu))

drivers/mfd/intel_pmc_bxt.c

443

return PTR_ERR(pmc->scu);

drivers/mfd/intel_pmc_bxt.c

445

platform_set_drvdata(pdev, pmc);

drivers/mfd/intel_pmc_bxt.c

447

ret = intel_pmc_create_devices(pmc);

drivers/mfd/intel_pmc_bxt.c

82

int intel_pmc_gcr_read64(struct intel_pmc_dev *pmc, u32 offset, u64 *data)

drivers/mfd/intel_pmc_bxt.c

87

spin_lock(&pmc->gcr_lock);

drivers/mfd/intel_pmc_bxt.c

88

*data = readq(pmc->gcr_mem_base + offset);

drivers/mfd/intel_pmc_bxt.c

89

spin_unlock(&pmc->gcr_lock);

drivers/mfd/sm501.c

138

unsigned long pmc = smc501_readl(sm->regs + SM501_POWER_MODE_CONTROL);

drivers/mfd/sm501.c

174

(pmc & 3 ) == 0 ? '*' : '-',

drivers/mfd/sm501.c

183

(pmc & 3 ) == 1 ? '*' : '-',

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c

10941

u16 pmc;

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c

11109

pci_read_config_word(bp->pdev, bp->pdev->pm_cap + PCI_PM_PMC, &pmc);

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c

11110

bp->flags |= (pmc & PCI_PM_CAP_PME_D3cold) ? 0 : NO_WOL_FLAG;

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c

9164

u16 pmc;

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c

9179

pci_read_config_word(pdev, pdev->pm_cap + PCI_PM_CTRL, &pmc);

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c

9180

pmc |= PCI_PM_CTRL_PME_ENABLE | PCI_PM_CTRL_PME_STATUS;

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c

9181

pci_write_config_word(pdev, pdev->pm_cap + PCI_PM_CTRL, pmc);

drivers/net/vmxnet3/vmxnet3_drv.c

151

vmxnet3_get_cycles(int pmc)

drivers/net/vmxnet3/vmxnet3_drv.c

154

return native_read_pmc(pmc);

drivers/net/wireless/ath/wil6210/pmc.c

113

pmc->pring_va = dma_alloc_coherent(dev,

drivers/net/wireless/ath/wil6210/pmc.c

115

&pmc->pring_pa,

drivers/net/wireless/ath/wil6210/pmc.c

124

pmc->pring_va, &pmc->pring_pa,

drivers/net/wireless/ath/wil6210/pmc.c

129

if (!pmc->pring_va) {

drivers/net/wireless/ath/wil6210/pmc.c

139

struct vring_tx_desc *_d = &pmc->pring_va[i];

drivers/net/wireless/ath/wil6210/pmc.c

143

pmc->descriptors[i].va = dma_alloc_coherent(dev,

drivers/net/wireless/ath/wil6210/pmc.c

145

&pmc->descriptors[i].pa,

drivers/net/wireless/ath/wil6210/pmc.c

148

if (unlikely(!pmc->descriptors[i].va)) {

drivers/net/wireless/ath/wil6210/pmc.c

154

u32 *p = (u32 *)pmc->descriptors[i].va + j;

drivers/net/wireless/ath/wil6210/pmc.c

160

cpu_to_le32(lower_32_bits(pmc->descriptors[i].pa));

drivers/net/wireless/ath/wil6210/pmc.c

162

cpu_to_le16((u16)upper_32_bits(pmc->descriptors[i].pa));

drivers/net/wireless/ath/wil6210/pmc.c

172

pmc_cmd.ring_size = cpu_to_le16(pmc->num_descriptors);

drivers/net/wireless/ath/wil6210/pmc.c

173

pmc_cmd.mem_base = cpu_to_le64(pmc->pring_pa);

drivers/net/wireless/ath/wil6210/pmc.c

176

pmc->last_cmd_status = wmi_send(wil,

drivers/net/wireless/ath/wil6210/pmc.c

181

if (pmc->last_cmd_status) {

drivers/net/wireless/ath/wil6210/pmc.c

184

pmc->last_cmd_status);

drivers/net/wireless/ath/wil6210/pmc.c

188

mutex_unlock(&pmc->lock);

drivers/net/wireless/ath/wil6210/pmc.c

194

for (i = 0; i < num_descriptors && pmc->descriptors[i].va; i++) {

drivers/net/wireless/ath/wil6210/pmc.c

197

pmc->descriptors[i].va,

drivers/net/wireless/ath/wil6210/pmc.c

198

pmc->descriptors[i].pa);

drivers/net/wireless/ath/wil6210/pmc.c

200

pmc->descriptors[i].va = NULL;

drivers/net/wireless/ath/wil6210/pmc.c

206

pmc->pring_va,

drivers/net/wireless/ath/wil6210/pmc.c

207

pmc->pring_pa);

drivers/net/wireless/ath/wil6210/pmc.c

209

pmc->pring_va = NULL;

drivers/net/wireless/ath/wil6210/pmc.c

21

static int wil_is_pmc_allocated(struct pmc_ctx *pmc)

drivers/net/wireless/ath/wil6210/pmc.c

213

kfree(pmc->descriptors);

drivers/net/wireless/ath/wil6210/pmc.c

214

pmc->descriptors = NULL;

drivers/net/wireless/ath/wil6210/pmc.c

217

pmc->last_cmd_status = last_cmd_err;

drivers/net/wireless/ath/wil6210/pmc.c

218

mutex_unlock(&pmc->lock);

drivers/net/wireless/ath/wil6210/pmc.c

226

struct pmc_ctx *pmc = &wil->pmc;

drivers/net/wireless/ath/wil6210/pmc.c

23

return !!pmc->pring_va;

drivers/net/wireless/ath/wil6210/pmc.c

231

mutex_lock(&pmc->lock);

drivers/net/wireless/ath/wil6210/pmc.c

233

pmc->last_cmd_status = 0;

drivers/net/wireless/ath/wil6210/pmc.c

235

if (!wil_is_pmc_allocated(pmc)) {

drivers/net/wireless/ath/wil6210/pmc.c

238

pmc->last_cmd_status = -EPERM;

drivers/net/wireless/ath/wil6210/pmc.c

239

mutex_unlock(&pmc->lock);

drivers/net/wireless/ath/wil6210/pmc.c

246

pmc->last_cmd_status =

drivers/net/wireless/ath/wil6210/pmc.c

249

if (pmc->last_cmd_status) {

drivers/net/wireless/ath/wil6210/pmc.c

252

pmc->last_cmd_status);

drivers/net/wireless/ath/wil6210/pmc.c

260

if (pmc->pring_va) {

drivers/net/wireless/ath/wil6210/pmc.c

262

pmc->num_descriptors;

drivers/net/wireless/ath/wil6210/pmc.c

265

pmc->pring_va);

drivers/net/wireless/ath/wil6210/pmc.c

266

dma_free_coherent(dev, buf_size, pmc->pring_va, pmc->pring_pa);

drivers/net/wireless/ath/wil6210/pmc.c

268

pmc->pring_va = NULL;

drivers/net/wireless/ath/wil6210/pmc.c

270

pmc->last_cmd_status = -ENOENT;

drivers/net/wireless/ath/wil6210/pmc.c

273

if (pmc->descriptors) {

drivers/net/wireless/ath/wil6210/pmc.c

277

i < pmc->num_descriptors && pmc->descriptors[i].va; i++) {

drivers/net/wireless/ath/wil6210/pmc.c

279

pmc->descriptor_size,

drivers/net/wireless/ath/wil6210/pmc.c

28

memset(&wil->pmc, 0, sizeof(struct pmc_ctx));

drivers/net/wireless/ath/wil6210/pmc.c

280

pmc->descriptors[i].va,

drivers/net/wireless/ath/wil6210/pmc.c

281

pmc->descriptors[i].pa);

drivers/net/wireless/ath/wil6210/pmc.c

282

pmc->descriptors[i].va = NULL;

drivers/net/wireless/ath/wil6210/pmc.c

285

pmc->num_descriptors);

drivers/net/wireless/ath/wil6210/pmc.c

288

pmc->descriptors);

drivers/net/wireless/ath/wil6210/pmc.c

289

kfree(pmc->descriptors);

drivers/net/wireless/ath/wil6210/pmc.c

29

mutex_init(&wil->pmc.lock);

drivers/net/wireless/ath/wil6210/pmc.c

290

pmc->descriptors = NULL;

drivers/net/wireless/ath/wil6210/pmc.c

292

pmc->last_cmd_status = -ENOENT;

drivers/net/wireless/ath/wil6210/pmc.c

295

mutex_unlock(&pmc->lock);

drivers/net/wireless/ath/wil6210/pmc.c

304

wil->pmc.last_cmd_status);

drivers/net/wireless/ath/wil6210/pmc.c

306

return wil->pmc.last_cmd_status;

drivers/net/wireless/ath/wil6210/pmc.c

316

struct pmc_ctx *pmc = &wil->pmc;

drivers/net/wireless/ath/wil6210/pmc.c

322

mutex_lock(&pmc->lock);

drivers/net/wireless/ath/wil6210/pmc.c

324

if (!wil_is_pmc_allocated(pmc)) {

drivers/net/wireless/ath/wil6210/pmc.c

326

pmc->last_cmd_status = -EPERM;

drivers/net/wireless/ath/wil6210/pmc.c

327

mutex_unlock(&pmc->lock);

drivers/net/wireless/ath/wil6210/pmc.c

331

pmc_size = pmc->descriptor_size * pmc->num_descriptors;

drivers/net/wireless/ath/wil6210/pmc.c

337

pmc->last_cmd_status = 0;

drivers/net/wireless/ath/wil6210/pmc.c

340

do_div(idx, pmc->descriptor_size);

drivers/net/wireless/ath/wil6210/pmc.c

341

offset = *f_pos - (idx * pmc->descriptor_size);

drivers/net/wireless/ath/wil6210/pmc.c

347

pmc->last_cmd_status = -ERANGE;

drivers/net/wireless/ath/wil6210/pmc.c

359

pmc->descriptors[idx].va,

drivers/net/wireless/ath/wil6210/pmc.c

360

pmc->descriptor_size);

drivers/net/wireless/ath/wil6210/pmc.c

363

mutex_unlock(&pmc->lock);

drivers/net/wireless/ath/wil6210/pmc.c

372

struct pmc_ctx *pmc = &wil->pmc;

drivers/net/wireless/ath/wil6210/pmc.c

375

mutex_lock(&pmc->lock);

drivers/net/wireless/ath/wil6210/pmc.c

377

if (!wil_is_pmc_allocated(pmc)) {

drivers/net/wireless/ath/wil6210/pmc.c

379

pmc->last_cmd_status = -EPERM;

drivers/net/wireless/ath/wil6210/pmc.c

380

mutex_unlock(&pmc->lock);

drivers/net/wireless/ath/wil6210/pmc.c

384

pmc_size = pmc->descriptor_size * pmc->num_descriptors;

drivers/net/wireless/ath/wil6210/pmc.c

414

mutex_unlock(&pmc->lock);

drivers/net/wireless/ath/wil6210/pmc.c

422

struct pmc_ctx *pmc = &wil->pmc;

drivers/net/wireless/ath/wil6210/pmc.c

424

sizeof(struct vring_rx_desc) * pmc->num_descriptors;

drivers/net/wireless/ath/wil6210/pmc.c

426

mutex_lock(&pmc->lock);

drivers/net/wireless/ath/wil6210/pmc.c

428

if (!wil_is_pmc_allocated(pmc)) {

drivers/net/wireless/ath/wil6210/pmc.c

430

pmc->last_cmd_status = -EPERM;

drivers/net/wireless/ath/wil6210/pmc.c

431

mutex_unlock(&pmc->lock);

drivers/net/wireless/ath/wil6210/pmc.c

437

seq_write(s, pmc->pring_va, pmc_ring_size);

drivers/net/wireless/ath/wil6210/pmc.c

439

mutex_unlock(&pmc->lock);

drivers/net/wireless/ath/wil6210/pmc.c

44

struct pmc_ctx *pmc = &wil->pmc;

drivers/net/wireless/ath/wil6210/pmc.c

50

mutex_lock(&pmc->lock);

drivers/net/wireless/ath/wil6210/pmc.c

52

if (wil_is_pmc_allocated(pmc)) {

drivers/net/wireless/ath/wil6210/pmc.c

81

pmc->num_descriptors = num_descriptors;

drivers/net/wireless/ath/wil6210/pmc.c

82

pmc->descriptor_size = descriptor_size;

drivers/net/wireless/ath/wil6210/pmc.c

88

pmc->descriptors = kzalloc_objs(struct desc_alloc_info, num_descriptors);

drivers/net/wireless/ath/wil6210/pmc.c

89

if (!pmc->descriptors) {

drivers/net/wireless/ath/wil6210/pmc.c

95

pmc->descriptors);

drivers/net/wireless/ath/wil6210/wil6210.h

1023

struct pmc_ctx pmc;

drivers/net/wireless/intel/iwlegacy/3945.h

324

u16 pmc; /* abs.ofs: 20 */

drivers/net/wireless/realtek/rtw88/rtw8821c.h

38

u8 pmc[2];

drivers/net/wireless/realtek/rtw88/rtw8822b.h

38

u8 pmc[2];

drivers/net/wireless/realtek/rtw88/rtw8822c.h

30

u8 pmc[2];

drivers/pci/controller/pci-tegra.c

1170

tegra_pmc_powergate_power_off(pcie->pmc, TEGRA_POWERGATE_PCIE);

drivers/pci/controller/pci-tegra.c

1188

tegra_pmc_powergate_power_off(pcie->pmc, TEGRA_POWERGATE_PCIE);

drivers/pci/controller/pci-tegra.c

1196

err = tegra_pmc_powergate_power_on(pcie->pmc,

drivers/pci/controller/pci-tegra.c

1202

err = tegra_pmc_powergate_remove_clamping(pcie->pmc,

drivers/pci/controller/pci-tegra.c

1241

tegra_pmc_powergate_power_off(pcie->pmc, TEGRA_POWERGATE_PCIE);

drivers/pci/controller/pci-tegra.c

1439

pcie->pmc = devm_tegra_pmc_get(dev);

drivers/pci/controller/pci-tegra.c

1440

if (IS_ERR(pcie->pmc))

drivers/pci/controller/pci-tegra.c

1441

return dev_err_probe(dev, PTR_ERR(pcie->pmc),

drivers/pci/controller/pci-tegra.c

343

struct tegra_pmc *pmc;

drivers/pci/pci.c

3164

u16 pmc;

drivers/pci/pci.c

3177

pci_read_config_word(dev, pm + PCI_PM_PMC, &pmc);

drivers/pci/pci.c

3179

if ((pmc & PCI_PM_CAP_VER_MASK) > 3) {

drivers/pci/pci.c

3181

pmc & PCI_PM_CAP_VER_MASK);

drivers/pci/pci.c

3194

if (pmc & PCI_PM_CAP_D1)

drivers/pci/pci.c

3196

if (pmc & PCI_PM_CAP_D2)

drivers/pci/pci.c

3205

pmc &= PCI_PM_CAP_PME_MASK;

drivers/pci/pci.c

3206

if (pmc) {

drivers/pci/pci.c

3208

(pmc & PCI_PM_CAP_PME_D0) ? " D0" : "",

drivers/pci/pci.c

3209

(pmc & PCI_PM_CAP_PME_D1) ? " D1" : "",

drivers/pci/pci.c

3210

(pmc & PCI_PM_CAP_PME_D2) ? " D2" : "",

drivers/pci/pci.c

3211

(pmc & PCI_PM_CAP_PME_D3hot) ? " D3hot" : "",

drivers/pci/pci.c

3212

(pmc & PCI_PM_CAP_PME_D3cold) ? " D3cold" : "");

drivers/pci/pci.c

3213

dev->pme_support = FIELD_GET(PCI_PM_CAP_PME_MASK, pmc);

drivers/pinctrl/renesas/pinctrl-rzg2l.c

3097

cache->pmc = devm_kcalloc(pctrl->dev, nports, sizeof(*cache->pmc), GFP_KERNEL);

drivers/pinctrl/renesas/pinctrl-rzg2l.c

3098

if (!cache->pmc)

drivers/pinctrl/renesas/pinctrl-rzg2l.c

3445

RZG2L_PCTRL_REG_ACCESS8(suspend, pctrl->base + PMC(off), cache->pmc[port]);

drivers/pinctrl/renesas/pinctrl-rzg2l.c

3447

pctrl->data->pmc_writeb(pctrl, cache->pmc[port], PMC(off));

drivers/pinctrl/renesas/pinctrl-rzg2l.c

3609

u8 pmc = 0, max_pin;

drivers/pinctrl/renesas/pinctrl-rzg2l.c

3626

if (!(cache->pmc[port] & BIT(pin)))

drivers/pinctrl/renesas/pinctrl-rzg2l.c

3640

pmc &= ~BIT(pin);

drivers/pinctrl/renesas/pinctrl-rzg2l.c

3641

writeb(pmc, pctrl->base + PMC(off));

drivers/pinctrl/renesas/pinctrl-rzg2l.c

3649

pmc |= BIT(pin);

drivers/pinctrl/renesas/pinctrl-rzg2l.c

3650

writeb(pmc, pctrl->base + PMC(off));

drivers/pinctrl/renesas/pinctrl-rzg2l.c

379

u8 *pmc;

drivers/pinctrl/tegra/pinctrl-tegra20.c

2125

MUX_PG(pmc, PWR_ON, PWR_INTR, RSVD3, RSVD4, 0x14, 23, 0x98, 18, -1, -1),

drivers/platform/mellanox/mlxbf-pmc.c

1000

static struct mlxbf_pmc_context *pmc;

drivers/platform/mellanox/mlxbf-pmc.c

1011

arm_smccc_smc(command, pmc->sreg_tbl_perf, (uintptr_t)addr, 0, 0, 0, 0,

drivers/platform/mellanox/mlxbf-pmc.c

1034

if (pmc->svc_sreg_support)

drivers/platform/mellanox/mlxbf-pmc.c

1065

arm_smccc_smc(command, pmc->sreg_tbl_perf, value, (uintptr_t)addr, 0, 0,

drivers/platform/mellanox/mlxbf-pmc.c

1085

if (pmc->svc_sreg_support)

drivers/platform/mellanox/mlxbf-pmc.c

1100

(offset + MLXBF_PMC_REG_SIZE <= pmc->block[blk_num].blk_size))

drivers/platform/mellanox/mlxbf-pmc.c

1122

switch (pmc->event_set) {

drivers/platform/mellanox/mlxbf-pmc.c

1137

switch (pmc->event_set) {

drivers/platform/mellanox/mlxbf-pmc.c

1255

return mlxbf_pmc_write(pmc->block[blk_num].mmio_base +

drivers/platform/mellanox/mlxbf-pmc.c

1274

pmcaddr = pmc->block[blk_num].mmio_base +

drivers/platform/mellanox/mlxbf-pmc.c

1279

pmcaddr = pmc->block[blk_num].mmio_base +

drivers/platform/mellanox/mlxbf-pmc.c

1331

addr = pmc->block[blk_num].mmio_base +

drivers/platform/mellanox/mlxbf-pmc.c

1353

addr = pmc->block[blk_num].mmio_base +

drivers/platform/mellanox/mlxbf-pmc.c

1354

MLXBF_PMC_CRSPACE_PERFMON_VAL0(pmc->block[blk_num].counters) +

drivers/platform/mellanox/mlxbf-pmc.c

1365

if (cnt_num >= pmc->block[blk_num].counters)

drivers/platform/mellanox/mlxbf-pmc.c

1371

if (pmc->block[blk_num].type == MLXBF_PMC_TYPE_CRSPACE)

drivers/platform/mellanox/mlxbf-pmc.c

1390

if (mlxbf_pmc_write(pmc->block[blk_num].mmio_base +

drivers/platform/mellanox/mlxbf-pmc.c

1404

if (mlxbf_pmc_write(pmc->block[blk_num].mmio_base +

drivers/platform/mellanox/mlxbf-pmc.c

1415

if (mlxbf_pmc_write(pmc->block[blk_num].mmio_base +

drivers/platform/mellanox/mlxbf-pmc.c

1430

status = mlxbf_pmc_readl(pmc->block[blk_num].mmio_base +

drivers/platform/mellanox/mlxbf-pmc.c

1438

status = mlxbf_pmc_readl(pmc->block[blk_num].mmio_base +

drivers/platform/mellanox/mlxbf-pmc.c

1460

status = mlxbf_pmc_readl(pmc->block[blk_num].mmio_base +

drivers/platform/mellanox/mlxbf-pmc.c

1461

MLXBF_PMC_CRSPACE_PERFMON_VAL0(pmc->block[blk_num].counters) +

drivers/platform/mellanox/mlxbf-pmc.c

1478

if (cnt_num >= pmc->block[blk_num].counters)

drivers/platform/mellanox/mlxbf-pmc.c

1484

if (pmc->block[blk_num].type == MLXBF_PMC_TYPE_CRSPACE)

drivers/platform/mellanox/mlxbf-pmc.c

1489

pmc->block[blk_num].counters * MLXBF_PMC_REG_SIZE;

drivers/platform/mellanox/mlxbf-pmc.c

1497

status = mlxbf_pmc_write(pmc->block[blk_num].mmio_base + perfcfg_offset,

drivers/platform/mellanox/mlxbf-pmc.c

1504

return mlxbf_pmc_read(pmc->block[blk_num].mmio_base + perfval_offset,

drivers/platform/mellanox/mlxbf-pmc.c

1518

pmcaddr = pmc->block[blk_num].mmio_base +

drivers/platform/mellanox/mlxbf-pmc.c

1523

pmcaddr = pmc->block[blk_num].mmio_base +

drivers/platform/mellanox/mlxbf-pmc.c

1567

addr = pmc->block[blk_num].mmio_base +

drivers/platform/mellanox/mlxbf-pmc.c

1589

if (cnt_num >= pmc->block[blk_num].counters)

drivers/platform/mellanox/mlxbf-pmc.c

1595

if (pmc->block[blk_num].type == MLXBF_PMC_TYPE_CRSPACE)

drivers/platform/mellanox/mlxbf-pmc.c

1600

pmc->block[blk_num].counters * MLXBF_PMC_REG_SIZE;

drivers/platform/mellanox/mlxbf-pmc.c

1608

if (mlxbf_pmc_write(pmc->block[blk_num].mmio_base + perfcfg_offset,

drivers/platform/mellanox/mlxbf-pmc.c

1613

if (mlxbf_pmc_read(pmc->block[blk_num].mmio_base + perfval_offset,

drivers/platform/mellanox/mlxbf-pmc.c

1627

if ((strstr(pmc->block_name[blk_num], "ecc")) ||

drivers/platform/mellanox/mlxbf-pmc.c

1628

(strstr(pmc->block_name[blk_num], "clock_measure"))) {

drivers/platform/mellanox/mlxbf-pmc.c

1629

if (mlxbf_pmc_readl(pmc->block[blk_num].mmio_base + offset,

drivers/platform/mellanox/mlxbf-pmc.c

1638

return mlxbf_pmc_read(pmc->block[blk_num].mmio_base + offset,

drivers/platform/mellanox/mlxbf-pmc.c

1647

if (strstr(pmc->block_name[blk_num], "clock_measure"))

drivers/platform/mellanox/mlxbf-pmc.c

1650

if (strstr(pmc->block_name[blk_num], "ecc")) {

drivers/platform/mellanox/mlxbf-pmc.c

1651

return mlxbf_pmc_write(pmc->block[blk_num].mmio_base + offset,

drivers/platform/mellanox/mlxbf-pmc.c

1656

return mlxbf_pmc_write(pmc->block[blk_num].mmio_base + offset,

drivers/platform/mellanox/mlxbf-pmc.c

1676

if (strstr(pmc->block_name[blk_num], "l3cache"))

drivers/platform/mellanox/mlxbf-pmc.c

1679

if ((pmc->block[blk_num].type == MLXBF_PMC_TYPE_COUNTER) ||

drivers/platform/mellanox/mlxbf-pmc.c

1680

(pmc->block[blk_num].type == MLXBF_PMC_TYPE_CRSPACE)) {

drivers/platform/mellanox/mlxbf-pmc.c

1683

} else if (pmc->block[blk_num].type == MLXBF_PMC_TYPE_REGISTER) {

drivers/platform/mellanox/mlxbf-pmc.c

1684

offset = mlxbf_pmc_get_event_num(pmc->block_name[blk_num],

drivers/platform/mellanox/mlxbf-pmc.c

1717

if (!(strstr(pmc->block_name[blk_num], "ecc")) && data)

drivers/platform/mellanox/mlxbf-pmc.c

1721

if (strstr(pmc->block_name[blk_num], "l3cache"))

drivers/platform/mellanox/mlxbf-pmc.c

1724

if (pmc->block[blk_num].type == MLXBF_PMC_TYPE_COUNTER) {

drivers/platform/mellanox/mlxbf-pmc.c

1732

} else if (pmc->block[blk_num].type == MLXBF_PMC_TYPE_REGISTER) {

drivers/platform/mellanox/mlxbf-pmc.c

1733

offset = mlxbf_pmc_get_event_num(pmc->block_name[blk_num],

drivers/platform/mellanox/mlxbf-pmc.c

1740

} else if (pmc->block[blk_num].type == MLXBF_PMC_TYPE_CRSPACE) {

drivers/platform/mellanox/mlxbf-pmc.c

1765

if (strstr(pmc->block_name[blk_num], "l3cache"))

drivers/platform/mellanox/mlxbf-pmc.c

1772

evt_name = mlxbf_pmc_get_event_name(pmc->block_name[blk_num], evt_num);

drivers/platform/mellanox/mlxbf-pmc.c

1801

evt_num = mlxbf_pmc_get_event_num(pmc->block_name[blk_num],

drivers/platform/mellanox/mlxbf-pmc.c

1811

if (!mlxbf_pmc_get_event_name(pmc->block_name[blk_num], evt_num))

drivers/platform/mellanox/mlxbf-pmc.c

1815

if (strstr(pmc->block_name[blk_num], "l3cache"))

drivers/platform/mellanox/mlxbf-pmc.c

1840

events = mlxbf_pmc_event_list(pmc->block_name[blk_num], &size);

drivers/platform/mellanox/mlxbf-pmc.c

1867

if (pmc->block[blk_num].type == MLXBF_PMC_TYPE_CRSPACE) {

drivers/platform/mellanox/mlxbf-pmc.c

1868

if (mlxbf_pmc_readl(pmc->block[blk_num].mmio_base +

drivers/platform/mellanox/mlxbf-pmc.c

1869

MLXBF_PMC_CRSPACE_PERFMON_CTL(pmc->block[blk_num].counters),

drivers/platform/mellanox/mlxbf-pmc.c

1875

if (mlxbf_pmc_readl(pmc->block[blk_num].mmio_base +

drivers/platform/mellanox/mlxbf-pmc.c

1904

if (pmc->block[blk_num].type == MLXBF_PMC_TYPE_CRSPACE) {

drivers/platform/mellanox/mlxbf-pmc.c

1905

err = mlxbf_pmc_readl(pmc->block[blk_num].mmio_base +

drivers/platform/mellanox/mlxbf-pmc.c

1906

MLXBF_PMC_CRSPACE_PERFMON_CTL(pmc->block[blk_num].counters),

drivers/platform/mellanox/mlxbf-pmc.c

1916

mlxbf_pmc_write(pmc->block[blk_num].mmio_base +

drivers/platform/mellanox/mlxbf-pmc.c

1917

MLXBF_PMC_CRSPACE_PERFMON_CTL(pmc->block[blk_num].counters),

drivers/platform/mellanox/mlxbf-pmc.c

1945

if (mlxbf_pmc_readl(pmc->block[blk_num].mmio_base +

drivers/platform/mellanox/mlxbf-pmc.c

1946

MLXBF_PMC_CRSPACE_PERFMON_COUNT_CLOCK(pmc->block[blk_num].counters),

drivers/platform/mellanox/mlxbf-pmc.c

1970

mlxbf_pmc_write(pmc->block[blk_num].mmio_base +

drivers/platform/mellanox/mlxbf-pmc.c

1971

MLXBF_PMC_CRSPACE_PERFMON_COUNT_CLOCK(pmc->block[blk_num].counters),

drivers/platform/mellanox/mlxbf-pmc.c

1983

if (!mlxbf_pmc_event_supported(pmc->block_name[blk_num]))

drivers/platform/mellanox/mlxbf-pmc.c

1987

attr = &pmc->block[blk_num].attr_event_list;

drivers/platform/mellanox/mlxbf-pmc.c

1995

pmc->block[blk_num].block_attr[i] = &attr->dev_attr.attr;

drivers/platform/mellanox/mlxbf-pmc.c

1999

if (strstr(pmc->block_name[blk_num], "l3cache") ||

drivers/platform/mellanox/mlxbf-pmc.c

2000

((pmc->block[blk_num].type == MLXBF_PMC_TYPE_CRSPACE))) {

drivers/platform/mellanox/mlxbf-pmc.c

2001

attr = &pmc->block[blk_num].attr_enable;

drivers/platform/mellanox/mlxbf-pmc.c

2011

pmc->block[blk_num].block_attr[++i] = &attr->dev_attr.attr;

drivers/platform/mellanox/mlxbf-pmc.c

2015

if (pmc->block[blk_num].type == MLXBF_PMC_TYPE_CRSPACE) {

drivers/platform/mellanox/mlxbf-pmc.c

2017

attr = &pmc->block[blk_num].attr_count_clock;

drivers/platform/mellanox/mlxbf-pmc.c

2027

pmc->block[blk_num].block_attr[++i] = &attr->dev_attr.attr;

drivers/platform/mellanox/mlxbf-pmc.c

2031

pmc->block[blk_num].attr_counter = devm_kcalloc(

drivers/platform/mellanox/mlxbf-pmc.c

2032

dev, pmc->block[blk_num].counters,

drivers/platform/mellanox/mlxbf-pmc.c

2034

if (!pmc->block[blk_num].attr_counter)

drivers/platform/mellanox/mlxbf-pmc.c

2037

pmc->block[blk_num].attr_event = devm_kcalloc(

drivers/platform/mellanox/mlxbf-pmc.c

2038

dev, pmc->block[blk_num].counters,

drivers/platform/mellanox/mlxbf-pmc.c

2040

if (!pmc->block[blk_num].attr_event)

drivers/platform/mellanox/mlxbf-pmc.c

2044

for (j = 0; j < pmc->block[blk_num].counters; ++j) {

drivers/platform/mellanox/mlxbf-pmc.c

2045

attr = &pmc->block[blk_num].attr_counter[j];

drivers/platform/mellanox/mlxbf-pmc.c

2055

pmc->block[blk_num].block_attr[++i] = &attr->dev_attr.attr;

drivers/platform/mellanox/mlxbf-pmc.c

2058

attr = &pmc->block[blk_num].attr_event[j];

drivers/platform/mellanox/mlxbf-pmc.c

2068

pmc->block[blk_num].block_attr[++i] = &attr->dev_attr.attr;

drivers/platform/mellanox/mlxbf-pmc.c

2083

events = mlxbf_pmc_event_list(pmc->block_name[blk_num], &count);

drivers/platform/mellanox/mlxbf-pmc.c

2087

pmc->block[blk_num].attr_event = devm_kcalloc(

drivers/platform/mellanox/mlxbf-pmc.c

2089

if (!pmc->block[blk_num].attr_event)

drivers/platform/mellanox/mlxbf-pmc.c

2094

attr = &pmc->block[blk_num].attr_event[count];

drivers/platform/mellanox/mlxbf-pmc.c

2104

pmc->block[blk_num].block_attr[i] = &attr->dev_attr.attr;

drivers/platform/mellanox/mlxbf-pmc.c

2118

if ((pmc->block[blk_num].type == MLXBF_PMC_TYPE_COUNTER) ||

drivers/platform/mellanox/mlxbf-pmc.c

2119

(pmc->block[blk_num].type == MLXBF_PMC_TYPE_CRSPACE))

drivers/platform/mellanox/mlxbf-pmc.c

2121

else if (pmc->block[blk_num].type == MLXBF_PMC_TYPE_REGISTER)

drivers/platform/mellanox/mlxbf-pmc.c

2130

pmc->block[blk_num].block_attr_grp.attrs = pmc->block[blk_num].block_attr;

drivers/platform/mellanox/mlxbf-pmc.c

2131

pmc->block[blk_num].block_attr_grp.name = devm_kasprintf(

drivers/platform/mellanox/mlxbf-pmc.c

2132

dev, GFP_KERNEL, pmc->block_name[blk_num]);

drivers/platform/mellanox/mlxbf-pmc.c

2133

if (!pmc->block[blk_num].block_attr_grp.name)

drivers/platform/mellanox/mlxbf-pmc.c

2135

pmc->groups[pmc->group_num] = &pmc->block[blk_num].block_attr_grp;

drivers/platform/mellanox/mlxbf-pmc.c

2136

pmc->group_num++;

drivers/platform/mellanox/mlxbf-pmc.c

2159

for (i = 0; i < pmc->total_blocks; ++i) {

drivers/platform/mellanox/mlxbf-pmc.c

2161

if (strstr(pmc->block_name[i], "tilenet")) {

drivers/platform/mellanox/mlxbf-pmc.c

2162

if (sscanf(pmc->block_name[i], "tilenet%u", &tile_num) != 1)

drivers/platform/mellanox/mlxbf-pmc.c

2165

if (tile_num >= pmc->tile_count)

drivers/platform/mellanox/mlxbf-pmc.c

2167

} else if (strstr(pmc->block_name[i], "tile")) {

drivers/platform/mellanox/mlxbf-pmc.c

2168

if (sscanf(pmc->block_name[i], "tile%u", &tile_num) != 1)

drivers/platform/mellanox/mlxbf-pmc.c

2171

if (tile_num >= pmc->tile_count)

drivers/platform/mellanox/mlxbf-pmc.c

2176

if (strstr(pmc->block_name[i], "mss") &&

drivers/platform/mellanox/mlxbf-pmc.c

2177

pmc->event_set == MLXBF_PMC_EVENT_SET_BF3) {

drivers/platform/mellanox/mlxbf-pmc.c

2180

if (sscanf(pmc->block_name[i], "mss%u", &mss_num) != 1)

drivers/platform/mellanox/mlxbf-pmc.c

2183

if (!((pmc->mss_enable >> mss_num) & 0x1))

drivers/platform/mellanox/mlxbf-pmc.c

2188

if (strstr(pmc->block_name[i], "emi") &&

drivers/platform/mellanox/mlxbf-pmc.c

2189

pmc->event_set == MLXBF_PMC_EVENT_SET_BF3) {

drivers/platform/mellanox/mlxbf-pmc.c

2192

if (sscanf(pmc->block_name[i], "emi%u", &emi_num) != 1)

drivers/platform/mellanox/mlxbf-pmc.c

2195

if (!((pmc->mss_enable >> (emi_num / 2)) & 0x1))

drivers/platform/mellanox/mlxbf-pmc.c

2200

if (strstr(pmc->block_name[i], "llt_miss")) {

drivers/platform/mellanox/mlxbf-pmc.c

2203

if (sscanf(pmc->block_name[i], "llt_miss%u", &llt_num) != 1)

drivers/platform/mellanox/mlxbf-pmc.c

2206

if (!((pmc->llt_enable >> llt_num) & 0x1))

drivers/platform/mellanox/mlxbf-pmc.c

2208

} else if (strstr(pmc->block_name[i], "llt")) {

drivers/platform/mellanox/mlxbf-pmc.c

2211

if (sscanf(pmc->block_name[i], "llt%u", &llt_num) != 1)

drivers/platform/mellanox/mlxbf-pmc.c

2214

if (!((pmc->llt_enable >> llt_num) & 0x1))

drivers/platform/mellanox/mlxbf-pmc.c

2219

if (strstr(pmc->block_name[i], "apt")) {

drivers/platform/mellanox/mlxbf-pmc.c

2222

if (sscanf(pmc->block_name[i], "apt%u", &apt_num) != 1)

drivers/platform/mellanox/mlxbf-pmc.c

2225

if (!((pmc->apt_enable >> apt_num) & 0x1))

drivers/platform/mellanox/mlxbf-pmc.c

2229

ret = device_property_read_u64_array(dev, pmc->block_name[i],

drivers/platform/mellanox/mlxbf-pmc.c

2238

if (pmc->svc_sreg_support)

drivers/platform/mellanox/mlxbf-pmc.c

2239

pmc->block[i].mmio_base = (void __iomem *)info[0];

drivers/platform/mellanox/mlxbf-pmc.c

2241

pmc->block[i].mmio_base =

drivers/platform/mellanox/mlxbf-pmc.c

2244

pmc->block[i].blk_size = info[1];

drivers/platform/mellanox/mlxbf-pmc.c

2245

pmc->block[i].counters = info[2];

drivers/platform/mellanox/mlxbf-pmc.c

2246

pmc->block[i].type = info[3];

drivers/platform/mellanox/mlxbf-pmc.c

2248

if (!pmc->block[i].mmio_base)

drivers/platform/mellanox/mlxbf-pmc.c

2253

dev_warn(dev, "ignoring unsupported block: '%s'\n", pmc->block_name[i]);

drivers/platform/mellanox/mlxbf-pmc.c

2278

pmc = devm_kzalloc(dev, sizeof(struct mlxbf_pmc_context), GFP_KERNEL);

drivers/platform/mellanox/mlxbf-pmc.c

2279

if (!pmc)

drivers/platform/mellanox/mlxbf-pmc.c

2287

&pmc->sreg_tbl_perf);

drivers/platform/mellanox/mlxbf-pmc.c

2289

pmc->svc_sreg_support = false;

drivers/platform/mellanox/mlxbf-pmc.c

2300

pmc->svc_sreg_support = true;

drivers/platform/mellanox/mlxbf-pmc.c

2306

pmc->event_set = MLXBF_PMC_EVENT_SET_BF1;

drivers/platform/mellanox/mlxbf-pmc.c

2308

pmc->event_set = MLXBF_PMC_EVENT_SET_BF2;

drivers/platform/mellanox/mlxbf-pmc.c

2310

pmc->event_set = MLXBF_PMC_EVENT_SET_BF3;

drivers/platform/mellanox/mlxbf-pmc.c

2314

ret = device_property_read_u32(dev, "block_num", &pmc->total_blocks);

drivers/platform/mellanox/mlxbf-pmc.c

2319

pmc->block_name,

drivers/platform/mellanox/mlxbf-pmc.c

2320

pmc->total_blocks);

drivers/platform/mellanox/mlxbf-pmc.c

2321

if (ret != pmc->total_blocks)

drivers/platform/mellanox/mlxbf-pmc.c

2324

if (device_property_read_u32(dev, "tile_num", &pmc->tile_count)) {

drivers/platform/mellanox/mlxbf-pmc.c

2325

if (device_property_read_u8(dev, "apt_enable", &pmc->apt_enable)) {

drivers/platform/mellanox/mlxbf-pmc.c

2327

pmc->apt_enable = 0;

drivers/platform/mellanox/mlxbf-pmc.c

2329

if (device_property_read_u8(dev, "llt_enable", &pmc->llt_enable)) {

drivers/platform/mellanox/mlxbf-pmc.c

2331

pmc->llt_enable = 0;

drivers/platform/mellanox/mlxbf-pmc.c

2333

if (device_property_read_u8(dev, "mss_enable", &pmc->mss_enable)) {

drivers/platform/mellanox/mlxbf-pmc.c

2335

pmc->mss_enable = 0;

drivers/platform/mellanox/mlxbf-pmc.c

2339

pmc->pdev = pdev;

drivers/platform/mellanox/mlxbf-pmc.c

2340

pmc->group_num = 0;

drivers/platform/mellanox/mlxbf-pmc.c

2346

pmc->hwmon_dev = devm_hwmon_device_register_with_groups(

drivers/platform/mellanox/mlxbf-pmc.c

2347

dev, "bfperf", pmc, pmc->groups);

drivers/platform/mellanox/mlxbf-pmc.c

2348

if (IS_ERR(pmc->hwmon_dev))

drivers/platform/mellanox/mlxbf-pmc.c

2349

return PTR_ERR(pmc->hwmon_dev);

drivers/platform/mellanox/mlxbf-pmc.c

2350

platform_set_drvdata(pdev, pmc);

drivers/platform/x86/amd/pmc/pmc.c

214

static struct amd_pmc_dev pmc;

drivers/platform/x86/amd/pmc/pmc.c

772

struct amd_pmc_dev *pdev = &pmc;

drivers/platform/x86/amd/pmc/pmc.c

804

struct amd_pmc_dev *pdev = &pmc;

drivers/platform/x86/amd/pmc/pmc.c

832

struct amd_pmc_dev *pdev = &pmc;

drivers/platform/x86/amd/pmc/pmc.c

884

struct amd_pmc_dev *dev = &pmc;

drivers/platform/x86/intel/pmc/core.c

1002

pmc_for_each_mode(mode, pmc) {

drivers/platform/x86/intel/pmc/core.c

105

reg = pmc_core_reg_read(pmc, map->etr3_offset);

drivers/platform/x86/intel/pmc/core.c

111

pmc_core_reg_write(pmc, map->etr3_offset, reg);

drivers/platform/x86/intel/pmc/core.c

1116

struct pmc *pmc = pmcdev->pmcs[PMC_IDX_MAIN];

drivers/platform/x86/intel/pmc/core.c

1121

reg = pmc_core_reg_read(pmc, pmc->map->lpm_sts_latch_en_offset);

drivers/platform/x86/intel/pmc/core.c

113

reg = pmc_core_reg_read(pmc, map->etr3_offset);

drivers/platform/x86/intel/pmc/core.c

1130

pmc_for_each_mode(mode, pmc) {

drivers/platform/x86/intel/pmc/core.c

1148

struct pmc *pmc = pmcdev->pmcs[PMC_IDX_MAIN];

drivers/platform/x86/intel/pmc/core.c

1170

pmc_for_each_mode(m, pmc)

drivers/platform/x86/intel/pmc/core.c

1186

reg = pmc_core_reg_read(pmc, pmc->map->etr3_offset);

drivers/platform/x86/intel/pmc/core.c

1188

pmc_core_reg_write(pmc, pmc->map->etr3_offset, reg);

drivers/platform/x86/intel/pmc/core.c

1196

reg = pmc_core_reg_read(pmc, pmc->map->lpm_sts_latch_en_offset);

drivers/platform/x86/intel/pmc/core.c

1198

pmc_core_reg_write(pmc, pmc->map->lpm_sts_latch_en_offset, reg);

drivers/platform/x86/intel/pmc/core.c

1209

pmc_core_reg_write(pmc, pmc->map->lpm_sts_latch_en_offset, reg);

drivers/platform/x86/intel/pmc/core.c

1217

struct pmc *pmc = s->private;

drivers/platform/x86/intel/pmc/core.c

1218

const struct pmc_bit_map *map = pmc->map->msr_sts;

drivers/platform/x86/intel/pmc/core.c

125

struct pmc *pmc = pmcdev->pmcs[PMC_IDX_MAIN];

drivers/platform/x86/intel/pmc/core.c

126

const struct pmc_reg_map *map = pmc->map;

drivers/platform/x86/intel/pmc/core.c

1266

static void pmc_core_pmc_get_low_power_modes(struct pmc_dev *pmcdev, struct pmc *pmc)

drivers/platform/x86/intel/pmc/core.c

1277

if (!pmc->map->lpm_num_maps)

drivers/platform/x86/intel/pmc/core.c

1280

lpm_en = pmc_core_reg_read(pmc, pmc->map->lpm_en_offset);

drivers/platform/x86/intel/pmc/core.c

1285

pmc->num_lpm_modes = hweight32(lpm_en & 0xFF);

drivers/platform/x86/intel/pmc/core.c

1288

lpm_pri = pmc_core_reg_read(pmc, pmc->map->lpm_priority_offset);

drivers/platform/x86/intel/pmc/core.c

130

reg = pmc_core_reg_read(pmc, map->etr3_offset);

drivers/platform/x86/intel/pmc/core.c

1313

pmc->lpm_en_modes[i++] = mode;

drivers/platform/x86/intel/pmc/core.c

1322

struct pmc *pmc;

drivers/platform/x86/intel/pmc/core.c

1324

pmc = pmcdev->pmcs[pmc_idx];

drivers/platform/x86/intel/pmc/core.c

1325

if (!pmc)

drivers/platform/x86/intel/pmc/core.c

1328

pmc_core_pmc_get_low_power_modes(pmcdev, pmc);

drivers/platform/x86/intel/pmc/core.c

1332

int get_primary_reg_base(struct pmc *pmc)

drivers/platform/x86/intel/pmc/core.c

1337

pmc->base_addr = PMC_BASE_ADDR_DEFAULT;

drivers/platform/x86/intel/pmc/core.c

1339

if (page_is_ram(PHYS_PFN(pmc->base_addr)))

drivers/platform/x86/intel/pmc/core.c

1342

pmc->base_addr = slp_s0_addr - pmc->map->slp_s0_offset;

drivers/platform/x86/intel/pmc/core.c

1345

pmc->regbase = ioremap(pmc->base_addr, pmc->map->regmap_length);

drivers/platform/x86/intel/pmc/core.c

1346

if (!pmc->regbase)

drivers/platform/x86/intel/pmc/core.c

139

struct pmc *pmc = pmcdev->pmcs[PMC_IDX_MAIN];

drivers/platform/x86/intel/pmc/core.c

140

const struct pmc_reg_map *map = pmc->map;

drivers/platform/x86/intel/pmc/core.c

1448

struct pmc *primary_pmc = pmcdev->pmcs[PMC_IDX_MAIN];

drivers/platform/x86/intel/pmc/core.c

147

reg = pmc_core_reg_read(pmc, map->etr3_offset);

drivers/platform/x86/intel/pmc/core.c

1582

int pmc_core_pmt_get_lpm_req(struct pmc_dev *pmcdev, struct pmc *pmc, struct telem_endpoint *ep)

drivers/platform/x86/intel/pmc/core.c

1589

lpm_indices = pmc->map->lpm_reg_index;

drivers/platform/x86/intel/pmc/core.c

1590

num_maps = pmc->map->lpm_num_maps;

drivers/platform/x86/intel/pmc/core.c

1593

pmc->lpm_req_regs = devm_kzalloc(&pmcdev->pdev->dev,

drivers/platform/x86/intel/pmc/core.c

1596

if (!pmc->lpm_req_regs)

drivers/platform/x86/intel/pmc/core.c

1600

pmc_for_each_mode(mode, pmc) {

drivers/platform/x86/intel/pmc/core.c

1601

u32 *req_offset = pmc->lpm_req_regs + (mode * num_maps);

drivers/platform/x86/intel/pmc/core.c

1620

int pmc_core_pmt_get_blk_sub_req(struct pmc_dev *pmcdev, struct pmc *pmc,

drivers/platform/x86/intel/pmc/core.c

1628

num_blocker = pmc->map->num_s0ix_blocker;

drivers/platform/x86/intel/pmc/core.c

1629

sample_offset = pmc->map->blocker_req_offset;

drivers/platform/x86/intel/pmc/core.c

1631

pmc->lpm_req_regs = devm_kcalloc(&pmcdev->pdev->dev, num_blocker,

drivers/platform/x86/intel/pmc/core.c

1633

if (!pmc->lpm_req_regs)

drivers/platform/x86/intel/pmc/core.c

1636

req_offset = pmc->lpm_req_regs;

drivers/platform/x86/intel/pmc/core.c

1655

struct pmc *pmc;

drivers/platform/x86/intel/pmc/core.c

1658

pmc = pmcdev->pmcs[pmc_idx];

drivers/platform/x86/intel/pmc/core.c

1659

if (!pmc)

drivers/platform/x86/intel/pmc/core.c

1662

if (!pmc->map->lpm_req_guid)

drivers/platform/x86/intel/pmc/core.c

1668

devid = pmc->devid;

drivers/platform/x86/intel/pmc/core.c

1675

ep = pmt_telem_find_and_register_endpoint(&pcidev->dev, pmc->map->lpm_req_guid, 0);

drivers/platform/x86/intel/pmc/core.c

1681

ret = pmc_dev_info->sub_req(pmcdev, pmc, ep);

drivers/platform/x86/intel/pmc/core.c

1704

struct pmc *pmc;

drivers/platform/x86/intel/pmc/core.c

1715

pmc = pmcdev->pmcs[pmc_idx];

drivers/platform/x86/intel/pmc/core.c

1717

if (!pmc) {

drivers/platform/x86/intel/pmc/core.c

1718

pmc = devm_kzalloc(&pmcdev->pdev->dev, sizeof(*pmc), GFP_KERNEL);

drivers/platform/x86/intel/pmc/core.c

1719

if (!pmc)

drivers/platform/x86/intel/pmc/core.c

1723

pmc->map = map;

drivers/platform/x86/intel/pmc/core.c

1724

pmc->base_addr = pmc_ssram_telemetry.base_addr;

drivers/platform/x86/intel/pmc/core.c

1725

pmc->devid = pmc_ssram_telemetry.devid;

drivers/platform/x86/intel/pmc/core.c

1726

pmc->regbase = ioremap(pmc->base_addr, pmc->map->regmap_length);

drivers/platform/x86/intel/pmc/core.c

1728

if (!pmc->regbase) {

drivers/platform/x86/intel/pmc/core.c

1729

devm_kfree(&pmcdev->pdev->dev, pmc);

drivers/platform/x86/intel/pmc/core.c

1733

pmcdev->pmcs[pmc_idx] = pmc;

drivers/platform/x86/intel/pmc/core.c

1760

struct pmc *pmc = pmcdev->pmcs[PMC_IDX_MAIN];

drivers/platform/x86/intel/pmc/core.c

1789

pmc->map = pmc_dev_info->map;

drivers/platform/x86/intel/pmc/core.c

1790

ret = get_primary_reg_base(pmc);

drivers/platform/x86/intel/pmc/core.c

1809

struct pmc *pmc = pmcdev->pmcs[pmc_idx];

drivers/platform/x86/intel/pmc/core.c

1811

if (pmc && pmc->regbase)

drivers/platform/x86/intel/pmc/core.c

1812

iounmap(pmc->regbase);

drivers/platform/x86/intel/pmc/core.c

1872

static void pmc_core_xtal_ignore(struct pmc *pmc)

drivers/platform/x86/intel/pmc/core.c

1876

value = pmc_core_reg_read(pmc, pmc->map->pm_vric1_offset);

drivers/platform/x86/intel/pmc/core.c

1881

pmc_core_reg_write(pmc, pmc->map->pm_vric1_offset, value);

drivers/platform/x86/intel/pmc/core.c

1896

static void pmc_core_do_dmi_quirks(struct pmc *pmc)

drivers/platform/x86/intel/pmc/core.c

1901

pmc_core_xtal_ignore(pmc);

drivers/platform/x86/intel/pmc/core.c

1910

struct pmc *pmc = pmcdev->pmcs[pmc_idx];

drivers/platform/x86/intel/pmc/core.c

1912

if (pmc && pmc->regbase)

drivers/platform/x86/intel/pmc/core.c

1913

iounmap(pmc->regbase);

drivers/platform/x86/intel/pmc/core.c

1931

struct pmc *primary_pmc;

drivers/platform/x86/intel/pmc/core.c

195

struct pmc *pmc = data;

drivers/platform/x86/intel/pmc/core.c

196

const struct pmc_reg_map *map = pmc->map;

drivers/platform/x86/intel/pmc/core.c

199

value = pmc_core_reg_read(pmc, map->slp_s0_offset);

drivers/platform/x86/intel/pmc/core.c

200

*val = pmc_core_adjust_slp_s0_step(pmc, value);

drivers/platform/x86/intel/pmc/core.c

2012

struct pmc *pmc = pmcdev->pmcs[PMC_IDX_MAIN];

drivers/platform/x86/intel/pmc/core.c

2032

if (pmc_core_dev_state_get(pmc, &pmcdev->s0ix_counter))

drivers/platform/x86/intel/pmc/core.c

2070

struct pmc *pmc = pmcdev->pmcs[PMC_IDX_MAIN];

drivers/platform/x86/intel/pmc/core.c

2071

const struct pmc_bit_map **maps = pmc->map->lpm_sts;

drivers/platform/x86/intel/pmc/core.c

2072

int offset = pmc->map->lpm_status_offset;

drivers/platform/x86/intel/pmc/core.c

209

struct pmc *pmc = data;

drivers/platform/x86/intel/pmc/core.c

210

const struct pmc_reg_map *map = pmc->map;

drivers/platform/x86/intel/pmc/core.c

2108

if (pmc->map->slps0_dbg_maps)

drivers/platform/x86/intel/pmc/core.c

2109

pmc_core_slps0_display(pmc, dev, NULL);

drivers/platform/x86/intel/pmc/core.c

2112

struct pmc *pmc = pmcdev->pmcs[pmc_idx];

drivers/platform/x86/intel/pmc/core.c

2114

if (!pmc)

drivers/platform/x86/intel/pmc/core.c

2116

if (pmc->map->lpm_sts)

drivers/platform/x86/intel/pmc/core.c

2117

pmc_core_lpm_display(pmc, dev, NULL, offset, pmc_idx, "STATUS", maps);

drivers/platform/x86/intel/pmc/core.c

213

value = pmc_core_reg_read(pmc, map->pson_residency_offset);

drivers/platform/x86/intel/pmc/core.c

221

static int pmc_core_check_read_lock_bit(struct pmc *pmc)

drivers/platform/x86/intel/pmc/core.c

225

value = pmc_core_reg_read(pmc, pmc->map->pm_cfg_offset);

drivers/platform/x86/intel/pmc/core.c

226

return value & BIT(pmc->map->pm_read_disable_bit);

drivers/platform/x86/intel/pmc/core.c

229

static void pmc_core_slps0_display(struct pmc *pmc, struct device *dev,

drivers/platform/x86/intel/pmc/core.c

232

const struct pmc_bit_map **maps = pmc->map->slps0_dbg_maps;

drivers/platform/x86/intel/pmc/core.c

234

int offset = pmc->map->slps0_dbg_offset;

drivers/platform/x86/intel/pmc/core.c

239

data = pmc_core_reg_read(pmc, offset);

drivers/platform/x86/intel/pmc/core.c

266

static void pmc_core_lpm_display(struct pmc *pmc, struct device *dev,

drivers/platform/x86/intel/pmc/core.c

280

lpm_regs[index] = pmc_core_reg_read(pmc, offset);

drivers/platform/x86/intel/pmc/core.c

309

static inline u8 pmc_core_reg_read_byte(struct pmc *pmc, int offset)

drivers/platform/x86/intel/pmc/core.c

311

return readb(pmc->regbase + offset);

drivers/platform/x86/intel/pmc/core.c

328

struct pmc *pmc = pmcdev->pmcs[pmc_idx];

drivers/platform/x86/intel/pmc/core.c

333

if (!pmc)

drivers/platform/x86/intel/pmc/core.c

336

maps = pmc->map->pfear_sts;

drivers/platform/x86/intel/pmc/core.c

337

iter = pmc->map->ppfear0_offset;

drivers/platform/x86/intel/pmc/core.c

339

for (index = 0; index < pmc->map->ppfear_buckets &&

drivers/platform/x86/intel/pmc/core.c

341

pf_regs[index] = pmc_core_reg_read_byte(pmc, iter);

drivers/platform/x86/intel/pmc/core.c

345

index < pmc->map->ppfear_buckets * 8; ip++, index++)

drivers/platform/x86/intel/pmc/core.c

356

static int pmc_core_mtpmc_link_status(struct pmc *pmc)

drivers/platform/x86/intel/pmc/core.c

360

value = pmc_core_reg_read(pmc, SPT_PMC_PM_STS_OFFSET);

drivers/platform/x86/intel/pmc/core.c

364

static int pmc_core_send_msg(struct pmc *pmc, u32 *addr_xram)

drivers/platform/x86/intel/pmc/core.c

370

if (pmc_core_mtpmc_link_status(pmc) == 0)

drivers/platform/x86/intel/pmc/core.c

375

if (timeout <= 0 && pmc_core_mtpmc_link_status(pmc))

drivers/platform/x86/intel/pmc/core.c

379

pmc_core_reg_write(pmc, SPT_PMC_MTPMC_OFFSET, dest);

drivers/platform/x86/intel/pmc/core.c

386

struct pmc *pmc = pmcdev->pmcs[PMC_IDX_MAIN];

drivers/platform/x86/intel/pmc/core.c

387

const struct pmc_bit_map *map = pmc->map->mphy_sts;

drivers/platform/x86/intel/pmc/core.c

403

err = pmc_core_send_msg(pmc, &mphy_core_reg_low);

drivers/platform/x86/intel/pmc/core.c

408

val_low = pmc_core_reg_read(pmc, SPT_PMC_MFPMC_OFFSET);

drivers/platform/x86/intel/pmc/core.c

410

err = pmc_core_send_msg(pmc, &mphy_core_reg_high);

drivers/platform/x86/intel/pmc/core.c

415

val_high = pmc_core_reg_read(pmc, SPT_PMC_MFPMC_OFFSET);

drivers/platform/x86/intel/pmc/core.c

438

struct pmc *pmc = pmcdev->pmcs[PMC_IDX_MAIN];

drivers/platform/x86/intel/pmc/core.c

439

const struct pmc_bit_map *map = pmc->map->pll_sts;

drivers/platform/x86/intel/pmc/core.c

452

err = pmc_core_send_msg(pmc, &mphy_common_reg);

drivers/platform/x86/intel/pmc/core.c

458

val = pmc_core_reg_read(pmc, SPT_PMC_MFPMC_OFFSET);

drivers/platform/x86/intel/pmc/core.c

472

struct pmc *pmc;

drivers/platform/x86/intel/pmc/core.c

484

pmc = pmcdev->pmcs[pmc_idx];

drivers/platform/x86/intel/pmc/core.c

486

if (!pmc)

drivers/platform/x86/intel/pmc/core.c

489

map = pmc->map;

drivers/platform/x86/intel/pmc/core.c

508

reg = pmc_core_reg_read(pmc, map->ltr_ignore_offset);

drivers/platform/x86/intel/pmc/core.c

513

pmc_core_reg_write(pmc, map->ltr_ignore_offset, reg);

drivers/platform/x86/intel/pmc/core.c

568

struct pmc *pmc = pmcdev->pmcs[PMC_IDX_MAIN];

drivers/platform/x86/intel/pmc/core.c

569

const struct pmc_reg_map *map = pmc->map;

drivers/platform/x86/intel/pmc/core.c

577

fd = pmc_core_reg_read(pmc, map->slps0_dbg_offset);

drivers/platform/x86/intel/pmc/core.c

582

pmc_core_reg_write(pmc, map->slps0_dbg_offset, fd);

drivers/platform/x86/intel/pmc/core.c

643

struct pmc *pmc;

drivers/platform/x86/intel/pmc/core.c

647

pmc = pmcdev->pmcs[pmc_idx];

drivers/platform/x86/intel/pmc/core.c

648

if (!pmc)

drivers/platform/x86/intel/pmc/core.c

652

ltr_ign_reg = pmc_core_reg_read(pmc, pmc->map->ltr_ignore_offset);

drivers/platform/x86/intel/pmc/core.c

654

map = pmc->map->ltr_show_sts;

drivers/platform/x86/intel/pmc/core.c

658

if (index > pmc->map->ltr_ignore_max)

drivers/platform/x86/intel/pmc/core.c

66

static inline u32 pmc_core_reg_read(struct pmc *pmc, int reg_offset)

drivers/platform/x86/intel/pmc/core.c

664

ltr_raw_data = pmc_core_reg_read(pmc,

drivers/platform/x86/intel/pmc/core.c

68

return readl(pmc->regbase + reg_offset);

drivers/platform/x86/intel/pmc/core.c

700

struct pmc *pmc;

drivers/platform/x86/intel/pmc/core.c

702

pmc = pmcdev->pmcs[pmc_idx];

drivers/platform/x86/intel/pmc/core.c

703

if (!pmc)

drivers/platform/x86/intel/pmc/core.c

705

maps = pmc->map->s0ix_blocker_maps;

drivers/platform/x86/intel/pmc/core.c

706

offset = pmc->map->s0ix_blocker_offset;

drivers/platform/x86/intel/pmc/core.c

71

static inline void pmc_core_reg_write(struct pmc *pmc, int reg_offset,

drivers/platform/x86/intel/pmc/core.c

715

counter = pmc_core_reg_read(pmc, offset);

drivers/platform/x86/intel/pmc/core.c

731

struct pmc *pmc;

drivers/platform/x86/intel/pmc/core.c

734

pmc = pmcdev->pmcs[pmc_idx];

drivers/platform/x86/intel/pmc/core.c

735

if (!pmc)

drivers/platform/x86/intel/pmc/core.c

739

pmc->ltr_ign = pmc_core_reg_read(pmc, pmc->map->ltr_ignore_offset);

drivers/platform/x86/intel/pmc/core.c

74

writel(val, pmc->regbase + reg_offset);

drivers/platform/x86/intel/pmc/core.c

742

ltr_ign = pmc->ltr_ign | GENMASK(pmc->map->ltr_ignore_max, 0);

drivers/platform/x86/intel/pmc/core.c

743

pmc_core_reg_write(pmc, pmc->map->ltr_ignore_offset, ltr_ign);

drivers/platform/x86/intel/pmc/core.c

758

struct pmc *pmc;

drivers/platform/x86/intel/pmc/core.c

760

pmc = pmcdev->pmcs[pmc_idx];

drivers/platform/x86/intel/pmc/core.c

761

if (!pmc)

drivers/platform/x86/intel/pmc/core.c

765

pmc_core_reg_write(pmc, pmc->map->ltr_ignore_offset, pmc->ltr_ign);

drivers/platform/x86/intel/pmc/core.c

769

static inline u64 adjust_lpm_residency(struct pmc *pmc, u32 offset,

drivers/platform/x86/intel/pmc/core.c

77

static inline u64 pmc_core_adjust_slp_s0_step(struct pmc *pmc, u32 value)

drivers/platform/x86/intel/pmc/core.c

772

u64 lpm_res = pmc_core_reg_read(pmc, offset);

drivers/platform/x86/intel/pmc/core.c

784

struct pmc *pmc;

drivers/platform/x86/intel/pmc/core.c

788

pmc = pmcdev->pmcs[pmc_idx];

drivers/platform/x86/intel/pmc/core.c

789

if (!pmc)

drivers/platform/x86/intel/pmc/core.c

792

lpm_adj_x2 = pmc->map->lpm_res_counter_step_x2;

drivers/platform/x86/intel/pmc/core.c

793

offset = pmc->map->lpm_residency_offset;

drivers/platform/x86/intel/pmc/core.c

796

pmc_for_each_mode(mode, pmc) {

drivers/platform/x86/intel/pmc/core.c

798

adjust_lpm_residency(pmc, offset + (4 * mode), lpm_adj_x2));

drivers/platform/x86/intel/pmc/core.c

812

struct pmc *pmc = pmcdev->pmcs[pmc_idx];

drivers/platform/x86/intel/pmc/core.c

816

if (!pmc)

drivers/platform/x86/intel/pmc/core.c

818

maps = pmc->map->lpm_sts;

drivers/platform/x86/intel/pmc/core.c

819

offset = pmc->map->lpm_status_offset;

drivers/platform/x86/intel/pmc/core.c

820

pmc_core_lpm_display(pmc, NULL, s, offset, pmc_idx, "STATUS", maps);

drivers/platform/x86/intel/pmc/core.c

833

struct pmc *pmc = pmcdev->pmcs[pmc_idx];

drivers/platform/x86/intel/pmc/core.c

837

if (!pmc)

drivers/platform/x86/intel/pmc/core.c

839

maps = pmc->map->lpm_sts;

drivers/platform/x86/intel/pmc/core.c

840

offset = pmc->map->lpm_live_status_offset;

drivers/platform/x86/intel/pmc/core.c

841

pmc_core_lpm_display(pmc, NULL, s, offset, pmc_idx, "LIVE_STATUS", maps);

drivers/platform/x86/intel/pmc/core.c

85

const int lpm_adj_x2 = pmc->map->lpm_res_counter_step_x2;

drivers/platform/x86/intel/pmc/core.c

852

struct pmc *pmc = pmcdev->pmcs[pmc_index];

drivers/platform/x86/intel/pmc/core.c

856

pmc_for_each_mode(mode, pmc)

drivers/platform/x86/intel/pmc/core.c

87

if (pmc->map == &adl_reg_map)

drivers/platform/x86/intel/pmc/core.c

877

struct pmc *pmc;

drivers/platform/x86/intel/pmc/core.c

879

pmc = pmcdev->pmcs[pmc_idx];

drivers/platform/x86/intel/pmc/core.c

880

if (!pmc || !pmc->lpm_req_regs)

drivers/platform/x86/intel/pmc/core.c

883

lpm_req_regs = pmc->lpm_req_regs;

drivers/platform/x86/intel/pmc/core.c

884

maps = pmc->map->s0ix_blocker_maps;

drivers/platform/x86/intel/pmc/core.c

885

offset = pmc->map->s0ix_blocker_offset;

drivers/platform/x86/intel/pmc/core.c

90

return (u64)value * pmc->map->slp_s0_res_counter_step;

drivers/platform/x86/intel/pmc/core.c

900

counter = pmc_core_reg_read(pmc, offset);

drivers/platform/x86/intel/pmc/core.c

902

pmc_for_each_mode(mode, pmc) {

drivers/platform/x86/intel/pmc/core.c

939

struct pmc *pmc = pmcdev->pmcs[pmc_idx];

drivers/platform/x86/intel/pmc/core.c

942

if (!pmc)

drivers/platform/x86/intel/pmc/core.c

945

maps = pmc->map->lpm_sts;

drivers/platform/x86/intel/pmc/core.c

946

num_maps = pmc->map->lpm_num_maps;

drivers/platform/x86/intel/pmc/core.c

947

sts_offset = pmc->map->lpm_status_offset;

drivers/platform/x86/intel/pmc/core.c

948

sts_offset_live = pmc->map->lpm_live_status_offset;

drivers/platform/x86/intel/pmc/core.c

949

lpm_req_regs = pmc->lpm_req_regs;

drivers/platform/x86/intel/pmc/core.c

95

struct pmc *pmc = pmcdev->pmcs[PMC_IDX_MAIN];

drivers/platform/x86/intel/pmc/core.c

96

const struct pmc_reg_map *map = pmc->map;

drivers/platform/x86/intel/pmc/core.c

976

pmc_for_each_mode(mode, pmc)

drivers/platform/x86/intel/pmc/core.c

980

lpm_status = pmc_core_reg_read(pmc, sts_offset + (mp * 4));

drivers/platform/x86/intel/pmc/core.c

983

lpm_status_live = pmc_core_reg_read(pmc, sts_offset_live + (mp * 4));

drivers/platform/x86/intel/pmc/core.h

499

struct pmc *pmcs[MAX_NUM_PMC];

drivers/platform/x86/intel/pmc/core.h

569

int (*sub_req)(struct pmc_dev *pmcdev, struct pmc *pmc, struct telem_endpoint *ep);

drivers/platform/x86/intel/pmc/core.h

600

int get_primary_reg_base(struct pmc *pmc);

drivers/platform/x86/intel/pmc/core.h

623

int pmc_core_pmt_get_lpm_req(struct pmc_dev *pmcdev, struct pmc *pmc, struct telem_endpoint *ep);

drivers/platform/x86/intel/pmc/core.h

624

int pmc_core_pmt_get_blk_sub_req(struct pmc_dev *pmcdev, struct pmc *pmc,

drivers/platform/x86/intel/pmc/core.h

632

#define pmc_for_each_mode(mode, pmc) \

drivers/platform/x86/intel/pmc/core.h

634

__cond = __i < (pmc)->num_lpm_modes, \

drivers/platform/x86/intel/pmc/core.h

635

__cond && ((mode) = (pmc)->lpm_en_modes[__i]), \

drivers/platform/x86/intel/pmc/tgl.c

243

struct pmc *pmc = pmcdev->pmcs[PMC_IDX_MAIN];

drivers/platform/x86/intel/pmc/tgl.c

244

const int num_maps = pmc->map->lpm_num_maps;

drivers/platform/x86/intel/pmc/tgl.c

282

pmc->lpm_req_regs = lpm_req_regs;

drivers/platform/x86/intel/telemetry/debugfs.c

654

ret = intel_pmc_s0ix_counter_read(plt_config->pmc, &s0ix_total_res);

drivers/platform/x86/intel/telemetry/debugfs.c

842

struct intel_pmc_dev *pmc = plt_config->pmc;

drivers/platform/x86/intel/telemetry/debugfs.c

844

ret = intel_pmc_gcr_read64(pmc, PMC_GCR_TELEM_SHLW_S0IX_REG,

drivers/platform/x86/intel/telemetry/debugfs.c

849

ret = intel_pmc_gcr_read64(pmc, PMC_GCR_TELEM_DEEP_S0IX_REG,

drivers/platform/x86/intel/telemetry/pltdrv.c

887

telm_conf->pmc = dev_get_drvdata(pdev->dev.parent);

drivers/platform/x86/pmc_atom.c

206

static inline u32 pmc_reg_read(struct pmc_dev *pmc, int reg_offset)

drivers/platform/x86/pmc_atom.c

208

return readl(pmc->regmap + reg_offset);

drivers/platform/x86/pmc_atom.c

211

static inline void pmc_reg_write(struct pmc_dev *pmc, int reg_offset, u32 val)

drivers/platform/x86/pmc_atom.c

213

writel(val, pmc->regmap + reg_offset);

drivers/platform/x86/pmc_atom.c

218

struct pmc_dev *pmc = &pmc_device;

drivers/platform/x86/pmc_atom.c

220

if (!pmc->init)

drivers/platform/x86/pmc_atom.c

223

*value = pmc_reg_read(pmc, offset);

drivers/platform/x86/pmc_atom.c

244

static void pmc_hw_reg_setup(struct pmc_dev *pmc)

drivers/platform/x86/pmc_atom.c

254

pmc_reg_write(pmc, PMC_S0IX_WAKE_EN, (u32)PMC_WAKE_EN_SETTING);

drivers/platform/x86/pmc_atom.c

275

struct pmc_dev *pmc = s->private;

drivers/platform/x86/pmc_atom.c

276

const struct pmc_reg_map *m = pmc->map;

drivers/platform/x86/pmc_atom.c

280

func_dis = pmc_reg_read(pmc, PMC_FUNC_DIS);

drivers/platform/x86/pmc_atom.c

281

func_dis_2 = pmc_reg_read(pmc, PMC_FUNC_DIS_2);

drivers/platform/x86/pmc_atom.c

282

d3_sts_0 = pmc_reg_read(pmc, PMC_D3_STS_0);

drivers/platform/x86/pmc_atom.c

283

d3_sts_1 = pmc_reg_read(pmc, PMC_D3_STS_1);

drivers/platform/x86/pmc_atom.c

298

struct pmc_dev *pmc = s->private;

drivers/platform/x86/pmc_atom.c

299

const struct pmc_bit_map *map = pmc->map->pss;

drivers/platform/x86/pmc_atom.c

300

u32 pss = pmc_reg_read(pmc, PMC_PSS);

drivers/platform/x86/pmc_atom.c

315

struct pmc_dev *pmc = s->private;

drivers/platform/x86/pmc_atom.c

318

s0ir_tmr = (u64)pmc_reg_read(pmc, PMC_S0IR_TMR) << PMC_TMR_SHIFT;

drivers/platform/x86/pmc_atom.c

319

s0i1_tmr = (u64)pmc_reg_read(pmc, PMC_S0I1_TMR) << PMC_TMR_SHIFT;

drivers/platform/x86/pmc_atom.c

320

s0i2_tmr = (u64)pmc_reg_read(pmc, PMC_S0I2_TMR) << PMC_TMR_SHIFT;

drivers/platform/x86/pmc_atom.c

321

s0i3_tmr = (u64)pmc_reg_read(pmc, PMC_S0I3_TMR) << PMC_TMR_SHIFT;

drivers/platform/x86/pmc_atom.c

322

s0_tmr = (u64)pmc_reg_read(pmc, PMC_S0_TMR) << PMC_TMR_SHIFT;

drivers/platform/x86/pmc_atom.c

334

static void pmc_dbgfs_register(struct pmc_dev *pmc)

drivers/platform/x86/pmc_atom.c

340

pmc->dbgfs_dir = dir;

drivers/platform/x86/pmc_atom.c

342

debugfs_create_file("dev_state", S_IFREG | S_IRUGO, dir, pmc,

drivers/platform/x86/pmc_atom.c

344

debugfs_create_file("pss_state", S_IFREG | S_IRUGO, dir, pmc,

drivers/platform/x86/pmc_atom.c

346

debugfs_create_file("sleep_state", S_IFREG | S_IRUGO, dir, pmc,

drivers/platform/x86/pmc_atom.c

350

static void pmc_dbgfs_register(struct pmc_dev *pmc)

drivers/platform/x86/pmc_atom.c

475

struct pmc_dev *pmc = &pmc_device;

drivers/platform/x86/pmc_atom.c

476

const struct pmc_reg_map *m = pmc->map;

drivers/platform/x86/pmc_atom.c

482

func_dis = pmc_reg_read(pmc, PMC_FUNC_DIS);

drivers/platform/x86/pmc_atom.c

483

func_dis_2 = pmc_reg_read(pmc, PMC_FUNC_DIS_2);

drivers/platform/x86/pmc_atom.c

484

d3_sts_0 = pmc_reg_read(pmc, PMC_D3_STS_0);

drivers/platform/x86/pmc_atom.c

485

d3_sts_1 = pmc_reg_read(pmc, PMC_D3_STS_1);

drivers/platform/x86/pmc_atom.c

508

u32 ctl = pmc_reg_read(pmc, PMC_CLK_CTL_OFFSET + 4 * i);

drivers/platform/x86/pmc_atom.c

531

struct pmc_dev *pmc = &pmc_device;

drivers/platform/x86/pmc_atom.c

544

pci_read_config_dword(pdev, PMC_BASE_ADDR_OFFSET, &pmc->base_addr);

drivers/platform/x86/pmc_atom.c

545

pmc->base_addr &= PMC_BASE_ADDR_MASK;

drivers/platform/x86/pmc_atom.c

547

pmc->regmap = ioremap(pmc->base_addr, PMC_MMIO_REG_LEN);

drivers/platform/x86/pmc_atom.c

548

if (!pmc->regmap) {

drivers/platform/x86/pmc_atom.c

553

pmc->map = map;

drivers/platform/x86/pmc_atom.c

556

pmc_hw_reg_setup(pmc);

drivers/platform/x86/pmc_atom.c

558

pmc_dbgfs_register(pmc);

drivers/platform/x86/pmc_atom.c

561

ret = pmc_setup_clks(pdev, pmc->regmap, data);

drivers/platform/x86/pmc_atom.c

567

pmc->init = true;

drivers/power/reset/at91-sama5d2_shdwc.c

168

"r" (at91_shdwc->rcfg->pmc.mckr)

drivers/power/reset/at91-sama5d2_shdwc.c

268

.pmc = {

drivers/power/reset/at91-sama5d2_shdwc.c

285

.pmc = {

drivers/power/reset/at91-sama5d2_shdwc.c

302

.pmc = {

drivers/power/reset/at91-sama5d2_shdwc.c

88

struct pmc_reg_config pmc;

drivers/soc/tegra/pmc.c

1023

pmc = platform_get_drvdata(pdev);

drivers/soc/tegra/pmc.c

1024

if (!pmc) {

drivers/soc/tegra/pmc.c

1029

return pmc;

drivers/soc/tegra/pmc.c

1041

struct tegra_pmc *pmc;

drivers/soc/tegra/pmc.c

1044

pmc = tegra_pmc_get(dev);

drivers/soc/tegra/pmc.c

1045

if (IS_ERR(pmc))

drivers/soc/tegra/pmc.c

1046

return pmc;

drivers/soc/tegra/pmc.c

1048

err = devm_add_action_or_reset(dev, tegra_pmc_put_device, pmc);

drivers/soc/tegra/pmc.c

1052

return pmc;

drivers/soc/tegra/pmc.c

1061

int tegra_pmc_powergate_power_on(struct tegra_pmc *pmc, unsigned int id)

drivers/soc/tegra/pmc.c

1063

if (!tegra_powergate_is_available(pmc, id))

drivers/soc/tegra/pmc.c

1066

return tegra_powergate_set(pmc, id, true);

drivers/soc/tegra/pmc.c

1075

int tegra_pmc_powergate_power_off(struct tegra_pmc *pmc, unsigned int id)

drivers/soc/tegra/pmc.c

1077

if (!tegra_powergate_is_available(pmc, id))

drivers/soc/tegra/pmc.c

1080

return tegra_powergate_set(pmc, id, false);

drivers/soc/tegra/pmc.c

1089

static int tegra_powergate_is_powered(struct tegra_pmc *pmc, unsigned int id)

drivers/soc/tegra/pmc.c

1091

if (!tegra_powergate_is_valid(pmc, id))

drivers/soc/tegra/pmc.c

1094

return tegra_powergate_state(pmc, id);

drivers/soc/tegra/pmc.c

1102

int tegra_pmc_powergate_remove_clamping(struct tegra_pmc *pmc, unsigned int id)

drivers/soc/tegra/pmc.c

1104

if (!tegra_powergate_is_available(pmc, id))

drivers/soc/tegra/pmc.c

1107

return __tegra_powergate_remove_clamping(pmc, id);

drivers/soc/tegra/pmc.c

1120

int tegra_pmc_powergate_sequence_power_up(struct tegra_pmc *pmc,

drivers/soc/tegra/pmc.c

1127

if (!tegra_powergate_is_available(pmc, id))

drivers/soc/tegra/pmc.c

1144

pg->pmc = pmc;

drivers/soc/tegra/pmc.c

1148

dev_err(pmc->dev, "failed to turn on partition %d: %d\n", id,

drivers/soc/tegra/pmc.c

1158

static void tegra_pmc_program_reboot_reason(struct tegra_pmc *pmc,

drivers/soc/tegra/pmc.c

1163

value = tegra_pmc_scratch_readl(pmc, pmc->soc->regs->scratch0);

drivers/soc/tegra/pmc.c

1177

tegra_pmc_scratch_writel(pmc, value, pmc->soc->regs->scratch0);

drivers/soc/tegra/pmc.c

1183

struct tegra_pmc *pmc = container_of(this, struct tegra_pmc,

drivers/soc/tegra/pmc.c

1186

tegra_pmc_program_reboot_reason(pmc, data);

drivers/soc/tegra/pmc.c

1191

static void tegra_pmc_restart(struct tegra_pmc *pmc)

drivers/soc/tegra/pmc.c

1196

value = tegra_pmc_readl(pmc, PMC_CNTRL);

drivers/soc/tegra/pmc.c

1198

tegra_pmc_writel(pmc, value, PMC_CNTRL);

drivers/soc/tegra/pmc.c

1203

struct tegra_pmc *pmc = data->cb_data;

drivers/soc/tegra/pmc.c

1205

tegra_pmc_restart(pmc);

drivers/soc/tegra/pmc.c

1212

struct tegra_pmc *pmc = data->cb_data;

drivers/soc/tegra/pmc.c

1221

tegra_pmc_writel(pmc, go_to_charger_mode, PMC_SCRATCH37);

drivers/soc/tegra/pmc.c

1222

tegra_pmc_restart(pmc);

drivers/soc/tegra/pmc.c

1230

struct tegra_pmc *pmc = data;

drivers/soc/tegra/pmc.c

1237

for (i = 0; i < pmc->soc->num_powergates; i++) {

drivers/soc/tegra/pmc.c

1238

status = tegra_powergate_is_powered(pmc, i);

drivers/soc/tegra/pmc.c

1242

seq_printf(s, " %9s %7s\n", pmc->soc->powergates[i],

drivers/soc/tegra/pmc.c

1297

struct device *dev = pg->pmc->dev;

drivers/soc/tegra/pmc.c

1316

static int tegra_powergate_add(struct tegra_pmc *pmc, struct device_node *np)

drivers/soc/tegra/pmc.c

1318

struct device *dev = pmc->dev;

drivers/soc/tegra/pmc.c

1327

id = tegra_powergate_lookup(pmc, np->name);

drivers/soc/tegra/pmc.c

1338

clear_bit(id, pmc->powergates_available);

drivers/soc/tegra/pmc.c

1345

pg->pmc = pmc;

drivers/soc/tegra/pmc.c

1347

off = !tegra_powergate_is_powered(pmc, pg->id);

drivers/soc/tegra/pmc.c

1422

set_bit(id, pmc->powergates_available);

drivers/soc/tegra/pmc.c

1435

struct tegra_pmc *pmc = pd->pmc;

drivers/soc/tegra/pmc.c

1446

mutex_lock(&pmc->powergates_lock);

drivers/soc/tegra/pmc.c

1447

err = dev_pm_opp_set_opp(pmc->dev, opp);

drivers/soc/tegra/pmc.c

1448

mutex_unlock(&pmc->powergates_lock);

drivers/soc/tegra/pmc.c

1461

static int tegra_pmc_core_pd_add(struct tegra_pmc *pmc, struct device_node *np)

drivers/soc/tegra/pmc.c

1467

pd = devm_kzalloc(pmc->dev, sizeof(*pd), GFP_KERNEL);

drivers/soc/tegra/pmc.c

1474

pd->pmc = pmc;

drivers/soc/tegra/pmc.c

1476

err = devm_pm_opp_set_regulators(pmc->dev, rname);

drivers/soc/tegra/pmc.c

1478

return dev_err_probe(pmc->dev, err,

drivers/soc/tegra/pmc.c

1483

dev_err(pmc->dev, "failed to init core genpd: %d\n", err);

drivers/soc/tegra/pmc.c

1489

dev_err(pmc->dev, "failed to add core genpd: %d\n", err);

drivers/soc/tegra/pmc.c

1501

static int tegra_powergate_init(struct tegra_pmc *pmc,

drivers/soc/tegra/pmc.c

1514

err = tegra_pmc_core_pd_add(pmc, np);

drivers/soc/tegra/pmc.c

1525

err = tegra_powergate_add(pmc, child);

drivers/soc/tegra/pmc.c

1559

set_bit(pg->id, pg->pmc->powergates_available);

drivers/soc/tegra/pmc.c

1593

tegra_io_pad_find(struct tegra_pmc *pmc, enum tegra_io_pad id)

drivers/soc/tegra/pmc.c

1597

for (i = 0; i < pmc->soc->num_io_pads; i++)

drivers/soc/tegra/pmc.c

1598

if (pmc->soc->io_pads[i].id == id)

drivers/soc/tegra/pmc.c

1599

return &pmc->soc->io_pads[i];

drivers/soc/tegra/pmc.c

1605

tegra_io_pad_vctrl_find(struct tegra_pmc *pmc, enum tegra_io_pad id)

drivers/soc/tegra/pmc.c

1609

for (i = 0; i < pmc->soc->num_io_pad_vctrls; i++)

drivers/soc/tegra/pmc.c

1610

if (pmc->soc->io_pad_vctrls[i].id == id)

drivers/soc/tegra/pmc.c

1611

return &pmc->soc->io_pad_vctrls[i];

drivers/soc/tegra/pmc.c

1616

static int tegra_io_pad_prepare(struct tegra_pmc *pmc,

drivers/soc/tegra/pmc.c

1631

if (pmc->clk) {

drivers/soc/tegra/pmc.c

1632

rate = pmc->rate;

drivers/soc/tegra/pmc.c

1634

dev_err(pmc->dev, "failed to get clock rate\n");

drivers/soc/tegra/pmc.c

1638

tegra_pmc_writel(pmc, DPD_SAMPLE_ENABLE, DPD_SAMPLE);

drivers/soc/tegra/pmc.c

1643

tegra_pmc_writel(pmc, value, SEL_DPD_TIM);

drivers/soc/tegra/pmc.c

1649

static int tegra_io_pad_poll(struct tegra_pmc *pmc, unsigned long offset,

drivers/soc/tegra/pmc.c

1657

value = tegra_pmc_readl(pmc, offset);

drivers/soc/tegra/pmc.c

1667

static void tegra_io_pad_unprepare(struct tegra_pmc *pmc)

drivers/soc/tegra/pmc.c

1669

if (pmc->clk)

drivers/soc/tegra/pmc.c

1670

tegra_pmc_writel(pmc, DPD_SAMPLE_DISABLE, DPD_SAMPLE);

drivers/soc/tegra/pmc.c

1680

int tegra_pmc_io_pad_power_enable(struct tegra_pmc *pmc, enum tegra_io_pad id)

drivers/soc/tegra/pmc.c

1687

pad = tegra_io_pad_find(pmc, id);

drivers/soc/tegra/pmc.c

1689

dev_err(pmc->dev, "invalid I/O pad ID %u\n", id);

drivers/soc/tegra/pmc.c

1693

mutex_lock(&pmc->powergates_lock);

drivers/soc/tegra/pmc.c

1695

err = tegra_io_pad_prepare(pmc, pad, &request, &status, &mask);

drivers/soc/tegra/pmc.c

1697

dev_err(pmc->dev, "failed to prepare I/O pad: %d\n", err);

drivers/soc/tegra/pmc.c

1701

tegra_pmc_writel(pmc, IO_DPD_REQ_CODE_OFF | mask, request);

drivers/soc/tegra/pmc.c

1703

err = tegra_io_pad_poll(pmc, status, mask, 0, 250);

drivers/soc/tegra/pmc.c

1705

dev_err(pmc->dev, "failed to enable I/O pad: %d\n", err);

drivers/soc/tegra/pmc.c

1709

tegra_io_pad_unprepare(pmc);

drivers/soc/tegra/pmc.c

1712

mutex_unlock(&pmc->powergates_lock);

drivers/soc/tegra/pmc.c

1724

int tegra_pmc_io_pad_power_disable(struct tegra_pmc *pmc, enum tegra_io_pad id)

drivers/soc/tegra/pmc.c

1731

pad = tegra_io_pad_find(pmc, id);

drivers/soc/tegra/pmc.c

1733

dev_err(pmc->dev, "invalid I/O pad ID %u\n", id);

drivers/soc/tegra/pmc.c

1737

mutex_lock(&pmc->powergates_lock);

drivers/soc/tegra/pmc.c

1739

err = tegra_io_pad_prepare(pmc, pad, &request, &status, &mask);

drivers/soc/tegra/pmc.c

1741

dev_err(pmc->dev, "failed to prepare I/O pad: %d\n", err);

drivers/soc/tegra/pmc.c

1745

tegra_pmc_writel(pmc, IO_DPD_REQ_CODE_ON | mask, request);

drivers/soc/tegra/pmc.c

1747

err = tegra_io_pad_poll(pmc, status, mask, mask, 250);

drivers/soc/tegra/pmc.c

1749

dev_err(pmc->dev, "failed to disable I/O pad: %d\n", err);

drivers/soc/tegra/pmc.c

1753

tegra_io_pad_unprepare(pmc);

drivers/soc/tegra/pmc.c

1756

mutex_unlock(&pmc->powergates_lock);

drivers/soc/tegra/pmc.c

1761

static int tegra_io_pad_is_powered(struct tegra_pmc *pmc, enum tegra_io_pad id)

drivers/soc/tegra/pmc.c

1767

pad = tegra_io_pad_find(pmc, id);

drivers/soc/tegra/pmc.c

1769

dev_err(pmc->dev, "invalid I/O pad ID %u\n", id);

drivers/soc/tegra/pmc.c

1779

value = tegra_pmc_readl(pmc, status);

drivers/soc/tegra/pmc.c

1784

static int tegra_io_pad_set_voltage(struct tegra_pmc *pmc, enum tegra_io_pad id,

drivers/soc/tegra/pmc.c

1790

pad = tegra_io_pad_vctrl_find(pmc, id);

drivers/soc/tegra/pmc.c

1794

mutex_lock(&pmc->powergates_lock);

drivers/soc/tegra/pmc.c

1796

if (pmc->soc->has_io_pad_wren) {

drivers/soc/tegra/pmc.c

1798

value = tegra_pmc_readl(pmc, PMC_PWR_DET);

drivers/soc/tegra/pmc.c

1800

tegra_pmc_writel(pmc, value, PMC_PWR_DET);

drivers/soc/tegra/pmc.c

1803

value = tegra_pmc_readl(pmc, pad->offset);

drivers/soc/tegra/pmc.c

1817

tegra_pmc_writel(pmc, value, pad->offset);

drivers/soc/tegra/pmc.c

1819

mutex_unlock(&pmc->powergates_lock);

drivers/soc/tegra/pmc.c

1826

static int tegra_io_pad_get_voltage(struct tegra_pmc *pmc, enum tegra_io_pad id)

drivers/soc/tegra/pmc.c

1831

pad = tegra_io_pad_vctrl_find(pmc, id);

drivers/soc/tegra/pmc.c

1835

value = tegra_pmc_readl(pmc, pad->offset);

drivers/soc/tegra/pmc.c

1843

static int tegra_pmc_parse_dt(struct tegra_pmc *pmc, struct device_node *np)

drivers/soc/tegra/pmc.c

1848

pmc->suspend_mode = TEGRA_SUSPEND_NONE;

drivers/soc/tegra/pmc.c

1852

pmc->suspend_mode = TEGRA_SUSPEND_LP0;

drivers/soc/tegra/pmc.c

1856

pmc->suspend_mode = TEGRA_SUSPEND_LP1;

drivers/soc/tegra/pmc.c

1860

pmc->suspend_mode = TEGRA_SUSPEND_LP2;

drivers/soc/tegra/pmc.c

1864

pmc->suspend_mode = TEGRA_SUSPEND_NONE;

drivers/soc/tegra/pmc.c

1869

pmc->suspend_mode = tegra_pm_validate_suspend_mode(pmc->suspend_mode);

drivers/soc/tegra/pmc.c

1872

pmc->suspend_mode = TEGRA_SUSPEND_NONE;

drivers/soc/tegra/pmc.c

1874

pmc->cpu_good_time = value;

drivers/soc/tegra/pmc.c

1877

pmc->suspend_mode = TEGRA_SUSPEND_NONE;

drivers/soc/tegra/pmc.c

1879

pmc->cpu_off_time = value;

drivers/soc/tegra/pmc.c

1883

pmc->suspend_mode = TEGRA_SUSPEND_NONE;

drivers/soc/tegra/pmc.c

1885

pmc->core_osc_time = values[0];

drivers/soc/tegra/pmc.c

1886

pmc->core_pmu_time = values[1];

drivers/soc/tegra/pmc.c

1889

pmc->suspend_mode = TEGRA_SUSPEND_NONE;

drivers/soc/tegra/pmc.c

1891

pmc->core_off_time = value;

drivers/soc/tegra/pmc.c

1893

pmc->corereq_high = of_property_read_bool(np,

drivers/soc/tegra/pmc.c

1896

pmc->sysclkreq_high = of_property_read_bool(np,

drivers/soc/tegra/pmc.c

1899

pmc->combined_req = of_property_read_bool(np,

drivers/soc/tegra/pmc.c

1902

pmc->cpu_pwr_good_en = of_property_read_bool(np,

drivers/soc/tegra/pmc.c

1907

if (pmc->suspend_mode == TEGRA_SUSPEND_LP0)

drivers/soc/tegra/pmc.c

1908

pmc->suspend_mode = TEGRA_SUSPEND_LP1;

drivers/soc/tegra/pmc.c

1910

pmc->lp0_vec_phys = values[0];

drivers/soc/tegra/pmc.c

1911

pmc->lp0_vec_size = values[1];

drivers/soc/tegra/pmc.c

1913

pmc->invert_irq = of_property_read_bool(np, "nvidia,invert-interrupt");

drivers/soc/tegra/pmc.c

1921

struct tegra_pmc *pmc = container_of(work, struct tegra_pmc, wake_work);

drivers/soc/tegra/pmc.c

1924

for (i = 0; i < pmc->soc->max_wake_vectors; i++) {

drivers/soc/tegra/pmc.c

1925

unsigned long status = pmc->wake_status[i];

drivers/soc/tegra/pmc.c

1932

irq = irq_find_mapping(pmc->domain, hwirq);

drivers/soc/tegra/pmc.c

1934

dev_warn(pmc->dev,

drivers/soc/tegra/pmc.c

1940

dev_dbg(pmc->dev,

drivers/soc/tegra/pmc.c

1946

dev_warn(pmc->dev,

drivers/soc/tegra/pmc.c

1958

pmc->wake_status[i] = 0;

drivers/soc/tegra/pmc.c

1962

static int tegra_pmc_init(struct tegra_pmc *pmc)

drivers/soc/tegra/pmc.c

1964

if (pmc->soc->max_wake_events > 0) {

drivers/soc/tegra/pmc.c

1965

pmc->wake_type_level_map = bitmap_zalloc(pmc->soc->max_wake_events, GFP_KERNEL);

drivers/soc/tegra/pmc.c

1966

if (!pmc->wake_type_level_map)

drivers/soc/tegra/pmc.c

1969

pmc->wake_type_dual_edge_map = bitmap_zalloc(pmc->soc->max_wake_events, GFP_KERNEL);

drivers/soc/tegra/pmc.c

1970

if (!pmc->wake_type_dual_edge_map)

drivers/soc/tegra/pmc.c

1973

pmc->wake_sw_status_map = bitmap_zalloc(pmc->soc->max_wake_events, GFP_KERNEL);

drivers/soc/tegra/pmc.c

1974

if (!pmc->wake_sw_status_map)

drivers/soc/tegra/pmc.c

1977

pmc->wake_cntrl_level_map = bitmap_zalloc(pmc->soc->max_wake_events, GFP_KERNEL);

drivers/soc/tegra/pmc.c

1978

if (!pmc->wake_cntrl_level_map)

drivers/soc/tegra/pmc.c

1981

pmc->wake_status = kcalloc(pmc->soc->max_wake_vectors, sizeof(u32), GFP_KERNEL);

drivers/soc/tegra/pmc.c

1982

if (!pmc->wake_status)

drivers/soc/tegra/pmc.c

1991

pmc->wake_work = IRQ_WORK_INIT_HARD(tegra186_pmc_wake_handler);

drivers/soc/tegra/pmc.c

1994

if (pmc->soc->init)

drivers/soc/tegra/pmc.c

1995

pmc->soc->init(pmc);

drivers/soc/tegra/pmc.c

2000

static void tegra_pmc_init_tsense_reset(struct tegra_pmc *pmc)

drivers/soc/tegra/pmc.c

2004

struct device *dev = pmc->dev;

drivers/soc/tegra/pmc.c

2008

if (!pmc->soc->has_tsense_reset)

drivers/soc/tegra/pmc.c

2011

np = of_get_child_by_name(pmc->dev->of_node, "i2c-thermtrip");

drivers/soc/tegra/pmc.c

2040

value = tegra_pmc_readl(pmc, PMC_SENSOR_CTRL);

drivers/soc/tegra/pmc.c

2042

tegra_pmc_writel(pmc, value, PMC_SENSOR_CTRL);

drivers/soc/tegra/pmc.c

2046

tegra_pmc_writel(pmc, value, PMC_SCRATCH54);

drivers/soc/tegra/pmc.c

2064

tegra_pmc_writel(pmc, value, PMC_SCRATCH55);

drivers/soc/tegra/pmc.c

2066

value = tegra_pmc_readl(pmc, PMC_SENSOR_CTRL);

drivers/soc/tegra/pmc.c

2068

tegra_pmc_writel(pmc, value, PMC_SENSOR_CTRL);

drivers/soc/tegra/pmc.c

2070

dev_info(pmc->dev, "emergency thermal reset enabled\n");

drivers/soc/tegra/pmc.c

2078

struct tegra_pmc *pmc = pinctrl_dev_get_drvdata(pctl_dev);

drivers/soc/tegra/pmc.c

2080

return pmc->soc->num_io_pads;

drivers/soc/tegra/pmc.c

2086

struct tegra_pmc *pmc = pinctrl_dev_get_drvdata(pctl);

drivers/soc/tegra/pmc.c

2088

return pmc->soc->io_pads[group].name;

drivers/soc/tegra/pmc.c

209

struct tegra_pmc *pmc;

drivers/soc/tegra/pmc.c

2096

struct tegra_pmc *pmc = pinctrl_dev_get_drvdata(pctl_dev);

drivers/soc/tegra/pmc.c

2098

*pins = &pmc->soc->io_pads[group].id;

drivers/soc/tegra/pmc.c

2116

struct tegra_pmc *pmc = pinctrl_dev_get_drvdata(pctl_dev);

drivers/soc/tegra/pmc.c

2121

pad = tegra_io_pad_find(pmc, pin);

drivers/soc/tegra/pmc.c

2127

ret = tegra_io_pad_get_voltage(pmc, pad->id);

drivers/soc/tegra/pmc.c

2135

ret = tegra_io_pad_is_powered(pmc, pad->id);

drivers/soc/tegra/pmc.c

2155

struct tegra_pmc *pmc = pinctrl_dev_get_drvdata(pctl_dev);

drivers/soc/tegra/pmc.c

2162

pad = tegra_io_pad_find(pmc, pin);

drivers/soc/tegra/pmc.c

2173

err = tegra_pmc_io_pad_power_disable(pmc, pad->id);

drivers/soc/tegra/pmc.c

2175

err = tegra_pmc_io_pad_power_enable(pmc, pad->id);

drivers/soc/tegra/pmc.c

2183

err = tegra_io_pad_set_voltage(pmc, pad->id, arg);

drivers/soc/tegra/pmc.c

219

struct tegra_pmc *pmc;

drivers/soc/tegra/pmc.c

2206

static int tegra_pmc_pinctrl_init(struct tegra_pmc *pmc)

drivers/soc/tegra/pmc.c

2210

if (!pmc->soc->num_pin_descs)

drivers/soc/tegra/pmc.c

2213

tegra_pmc_pctl_desc.name = dev_name(pmc->dev);

drivers/soc/tegra/pmc.c

2214

tegra_pmc_pctl_desc.pins = pmc->soc->pin_descs;

drivers/soc/tegra/pmc.c

2215

tegra_pmc_pctl_desc.npins = pmc->soc->num_pin_descs;

drivers/soc/tegra/pmc.c

2217

pmc->pctl_dev = devm_pinctrl_register(pmc->dev, &tegra_pmc_pctl_desc,

drivers/soc/tegra/pmc.c

2218

pmc);

drivers/soc/tegra/pmc.c

2219

if (IS_ERR(pmc->pctl_dev)) {

drivers/soc/tegra/pmc.c

2220

err = PTR_ERR(pmc->pctl_dev);

drivers/soc/tegra/pmc.c

2221

dev_err(pmc->dev, "failed to register pin controller: %d\n",

drivers/soc/tegra/pmc.c

2232

struct tegra_pmc *pmc = dev_get_drvdata(dev);

drivers/soc/tegra/pmc.c

2235

value = tegra_pmc_readl(pmc, pmc->soc->regs->rst_status);

drivers/soc/tegra/pmc.c

2236

value &= pmc->soc->regs->rst_source_mask;

drivers/soc/tegra/pmc.c

2237

value >>= pmc->soc->regs->rst_source_shift;

drivers/soc/tegra/pmc.c

2239

if (WARN_ON(value >= pmc->soc->num_reset_sources))

drivers/soc/tegra/pmc.c

2242

return sprintf(buf, "%s\n", pmc->soc->reset_sources[value]);

drivers/soc/tegra/pmc.c

2250

struct tegra_pmc *pmc = dev_get_drvdata(dev);

drivers/soc/tegra/pmc.c

2253

value = tegra_pmc_readl(pmc, pmc->soc->regs->rst_status);

drivers/soc/tegra/pmc.c

2254

value &= pmc->soc->regs->rst_level_mask;

drivers/soc/tegra/pmc.c

2255

value >>= pmc->soc->regs->rst_level_shift;

drivers/soc/tegra/pmc.c

2257

if (WARN_ON(value >= pmc->soc->num_reset_levels))

drivers/soc/tegra/pmc.c

2260

return sprintf(buf, "%s\n", pmc->soc->reset_levels[value]);

drivers/soc/tegra/pmc.c

2265

static void tegra_pmc_reset_sysfs_init(struct tegra_pmc *pmc)

drivers/soc/tegra/pmc.c

2267

struct device *dev = pmc->dev;

drivers/soc/tegra/pmc.c

2270

if (pmc->soc->reset_sources) {

drivers/soc/tegra/pmc.c

2278

if (pmc->soc->reset_levels) {

drivers/soc/tegra/pmc.c

2304

struct tegra_pmc *pmc = domain->host_data;

drivers/soc/tegra/pmc.c

2305

const struct tegra_pmc_soc *soc = pmc->soc;

drivers/soc/tegra/pmc.c

2325

&pmc->irq, pmc);

drivers/soc/tegra/pmc.c

2335

spec.fwnode = &pmc->dev->of_node->fwnode;

drivers/soc/tegra/pmc.c

2355

&pmc->irq, pmc);

drivers/soc/tegra/pmc.c

2379

struct tegra_pmc *pmc = irq_data_get_irq_chip_data(data);

drivers/soc/tegra/pmc.c

2387

tegra_pmc_writel(pmc, 0, PMC_SW_WAKE_STATUS);

drivers/soc/tegra/pmc.c

2388

tegra_pmc_writel(pmc, 0, PMC_SW_WAKE2_STATUS);

drivers/soc/tegra/pmc.c

2390

tegra_pmc_writel(pmc, 0, PMC_WAKE_STATUS);

drivers/soc/tegra/pmc.c

2391

tegra_pmc_writel(pmc, 0, PMC_WAKE2_STATUS);

drivers/soc/tegra/pmc.c

2399

value = tegra_pmc_readl(pmc, offset);

drivers/soc/tegra/pmc.c

2406

tegra_pmc_writel(pmc, value, offset);

drivers/soc/tegra/pmc.c

2413

struct tegra_pmc *pmc = irq_data_get_irq_chip_data(data);

drivers/soc/tegra/pmc.c

2425

value = tegra_pmc_readl(pmc, offset);

drivers/soc/tegra/pmc.c

2446

tegra_pmc_writel(pmc, value, offset);

drivers/soc/tegra/pmc.c

2451

static void tegra186_pmc_set_wake_filters(struct tegra_pmc *pmc)

drivers/soc/tegra/pmc.c

2456

value = readl(pmc->wake + WAKE_AOWAKE_CNTRL(SW_WAKE_ID));

drivers/soc/tegra/pmc.c

2458

writel(value, pmc->wake + WAKE_AOWAKE_CNTRL(SW_WAKE_ID));

drivers/soc/tegra/pmc.c

2459

dev_dbg(pmc->dev, "WAKE_AOWAKE_CNTRL_83 = 0x%x\n", value);

drivers/soc/tegra/pmc.c

2464

struct tegra_pmc *pmc = irq_data_get_irq_chip_data(data);

drivers/soc/tegra/pmc.c

2472

writel(0x1, pmc->wake + WAKE_AOWAKE_STATUS_W(pmc, data->hwirq));

drivers/soc/tegra/pmc.c

2475

value = readl(pmc->wake + WAKE_AOWAKE_TIER2_ROUTING(pmc, offset));

drivers/soc/tegra/pmc.c

2482

writel(value, pmc->wake + WAKE_AOWAKE_TIER2_ROUTING(pmc, offset));

drivers/soc/tegra/pmc.c

2485

writel(!!on, pmc->wake + WAKE_AOWAKE_MASK_W(pmc, data->hwirq));

drivers/soc/tegra/pmc.c

2492

struct tegra_pmc *pmc = irq_data_get_irq_chip_data(data);

drivers/soc/tegra/pmc.c

2495

value = readl(pmc->wake + WAKE_AOWAKE_CNTRL(data->hwirq));

drivers/soc/tegra/pmc.c

2501

set_bit(data->hwirq, pmc->wake_type_level_map);

drivers/soc/tegra/pmc.c

2502

clear_bit(data->hwirq, pmc->wake_type_dual_edge_map);

drivers/soc/tegra/pmc.c

2508

clear_bit(data->hwirq, pmc->wake_type_level_map);

drivers/soc/tegra/pmc.c

2509

clear_bit(data->hwirq, pmc->wake_type_dual_edge_map);

drivers/soc/tegra/pmc.c

2514

clear_bit(data->hwirq, pmc->wake_type_level_map);

drivers/soc/tegra/pmc.c

2515

set_bit(data->hwirq, pmc->wake_type_dual_edge_map);

drivers/soc/tegra/pmc.c

2522

writel(value, pmc->wake + WAKE_AOWAKE_CNTRL(data->hwirq));

drivers/soc/tegra/pmc.c

2555

static int tegra_pmc_irq_init(struct tegra_pmc *pmc)

drivers/soc/tegra/pmc.c

2560

np = of_irq_find_parent(pmc->dev->of_node);

drivers/soc/tegra/pmc.c

2569

pmc->irq.name = dev_name(pmc->dev);

drivers/soc/tegra/pmc.c

2570

pmc->irq.irq_mask = tegra_irq_mask_parent;

drivers/soc/tegra/pmc.c

2571

pmc->irq.irq_unmask = tegra_irq_unmask_parent;

drivers/soc/tegra/pmc.c

2572

pmc->irq.irq_eoi = tegra_irq_eoi_parent;

drivers/soc/tegra/pmc.c

2573

pmc->irq.irq_set_affinity = tegra_irq_set_affinity_parent;

drivers/soc/tegra/pmc.c

2574

pmc->irq.irq_set_type = pmc->soc->irq_set_type;

drivers/soc/tegra/pmc.c

2575

pmc->irq.irq_set_wake = pmc->soc->irq_set_wake;

drivers/soc/tegra/pmc.c

2577

pmc->domain = irq_domain_create_hierarchy(parent, 0, 96, dev_fwnode(pmc->dev),

drivers/soc/tegra/pmc.c

2578

&tegra_pmc_irq_domain_ops, pmc);

drivers/soc/tegra/pmc.c

2579

if (!pmc->domain) {

drivers/soc/tegra/pmc.c

2580

dev_err(pmc->dev, "failed to allocate domain\n");

drivers/soc/tegra/pmc.c

2590

struct tegra_pmc *pmc = container_of(nb, struct tegra_pmc, clk_nb);

drivers/soc/tegra/pmc.c

2595

mutex_lock(&pmc->powergates_lock);

drivers/soc/tegra/pmc.c

2599

pmc->rate = data->new_rate;

drivers/soc/tegra/pmc.c

2603

mutex_unlock(&pmc->powergates_lock);

drivers/soc/tegra/pmc.c

2614

static void pmc_clk_fence_udelay(struct tegra_pmc *pmc, u32 offset)

drivers/soc/tegra/pmc.c

2616

tegra_pmc_readl(pmc, offset);

drivers/soc/tegra/pmc.c

2626

val = tegra_pmc_readl(clk->pmc, clk->offs) >> clk->mux_shift;

drivers/soc/tegra/pmc.c

2637

val = tegra_pmc_readl(clk->pmc, clk->offs);

drivers/soc/tegra/pmc.c

2640

tegra_pmc_writel(clk->pmc, val, clk->offs);

drivers/soc/tegra/pmc.c

2641

pmc_clk_fence_udelay(clk->pmc, clk->offs);

drivers/soc/tegra/pmc.c

2651

val = tegra_pmc_readl(clk->pmc, clk->offs) & BIT(clk->force_en_shift);

drivers/soc/tegra/pmc.c

2656

static void pmc_clk_set_state(struct tegra_pmc *pmc, unsigned long offs,

drivers/soc/tegra/pmc.c

2661

val = tegra_pmc_readl(pmc, offs);

drivers/soc/tegra/pmc.c

2663

tegra_pmc_writel(pmc, val, offs);

drivers/soc/tegra/pmc.c

2664

pmc_clk_fence_udelay(pmc, offs);

drivers/soc/tegra/pmc.c

2671

pmc_clk_set_state(clk->pmc, clk->offs, clk->force_en_shift, 1);

drivers/soc/tegra/pmc.c

2680

pmc_clk_set_state(clk->pmc, clk->offs, clk->force_en_shift, 0);

drivers/soc/tegra/pmc.c

2693

tegra_pmc_clk_out_register(struct tegra_pmc *pmc,

drivers/soc/tegra/pmc.c

2700

pmc_clk = devm_kzalloc(pmc->dev, sizeof(*pmc_clk), GFP_KERNEL);

drivers/soc/tegra/pmc.c

2712

pmc_clk->pmc = pmc;

drivers/soc/tegra/pmc.c

2723

u32 value = tegra_pmc_readl(gate->pmc, gate->offs);

drivers/soc/tegra/pmc.c

2732

pmc_clk_set_state(gate->pmc, gate->offs, gate->shift, 1);

drivers/soc/tegra/pmc.c

2741

pmc_clk_set_state(gate->pmc, gate->offs, gate->shift, 0);

drivers/soc/tegra/pmc.c

2751

tegra_pmc_clk_gate_register(struct tegra_pmc *pmc, const char *name,

drivers/soc/tegra/pmc.c

2758

gate = devm_kzalloc(pmc->dev, sizeof(*gate), GFP_KERNEL);

drivers/soc/tegra/pmc.c

276

struct tegra_pmc *pmc;

drivers/soc/tegra/pmc.c

2769

gate->pmc = pmc;

drivers/soc/tegra/pmc.c

2776

static void tegra_pmc_clock_register(struct tegra_pmc *pmc,

drivers/soc/tegra/pmc.c

2784

num_clks = pmc->soc->num_pmc_clks;

drivers/soc/tegra/pmc.c

2785

if (pmc->soc->has_blink_output)

drivers/soc/tegra/pmc.c

2791

clk_data = devm_kmalloc(pmc->dev, sizeof(*clk_data), GFP_KERNEL);

drivers/soc/tegra/pmc.c

2795

clk_data->clks = devm_kcalloc(pmc->dev, TEGRA_PMC_CLK_MAX,

drivers/soc/tegra/pmc.c

2805

for (i = 0; i < pmc->soc->num_pmc_clks; i++) {

drivers/soc/tegra/pmc.c

2808

data = pmc->soc->pmc_clks_data + i;

drivers/soc/tegra/pmc.c

2810

clk = tegra_pmc_clk_out_register(pmc, data, PMC_CLK_OUT_CNTRL);

drivers/soc/tegra/pmc.c

2812

dev_warn(pmc->dev, "unable to register clock %s: %d\n",

drivers/soc/tegra/pmc.c

2819

dev_warn(pmc->dev,

drivers/soc/tegra/pmc.c

2828

if (pmc->soc->has_blink_output) {

drivers/soc/tegra/pmc.c

2829

tegra_pmc_writel(pmc, 0x0, PMC_BLINK_TIMER);

drivers/soc/tegra/pmc.c

2830

clk = tegra_pmc_clk_gate_register(pmc,

drivers/soc/tegra/pmc.c

2836

dev_warn(pmc->dev,

drivers/soc/tegra/pmc.c

2842

clk = tegra_pmc_clk_gate_register(pmc, "pmc_blink",

drivers/soc/tegra/pmc.c

2847

dev_warn(pmc->dev,

drivers/soc/tegra/pmc.c

2855

dev_warn(pmc->dev,

drivers/soc/tegra/pmc.c

2866

dev_warn(pmc->dev, "failed to add pmc clock provider: %d\n",

drivers/soc/tegra/pmc.c

287

struct tegra_pmc *pmc;

drivers/soc/tegra/pmc.c

2888

struct tegra_pmc *pmc = context;

drivers/soc/tegra/pmc.c

2890

*value = tegra_pmc_readl(pmc, offset);

drivers/soc/tegra/pmc.c

2896

struct tegra_pmc *pmc = context;

drivers/soc/tegra/pmc.c

2898

tegra_pmc_writel(pmc, value, offset);

drivers/soc/tegra/pmc.c

2914

static int tegra_pmc_regmap_init(struct tegra_pmc *pmc)

drivers/soc/tegra/pmc.c

2919

if (pmc->soc->has_usb_sleepwalk) {

drivers/soc/tegra/pmc.c

2920

regmap = devm_regmap_init(pmc->dev, NULL, pmc, &usb_sleepwalk_regmap_config);

drivers/soc/tegra/pmc.c

2923

dev_err(pmc->dev, "failed to allocate register map (%d)\n", err);

drivers/soc/tegra/pmc.c

2931

static bool tegra_pmc_detect_tz_only(struct tegra_pmc *pmc)

drivers/soc/tegra/pmc.c

2935

saved = readl(pmc->base + pmc->soc->regs->scratch0);

drivers/soc/tegra/pmc.c

2942

writel(value, pmc->base + pmc->soc->regs->scratch0);

drivers/soc/tegra/pmc.c

2943

value = readl(pmc->base + pmc->soc->regs->scratch0);

drivers/soc/tegra/pmc.c

2952

writel(saved, pmc->base + pmc->soc->regs->scratch0);

drivers/soc/tegra/pmc.c

2957

static void tegra_pmc_init_common(struct tegra_pmc *pmc, struct device_node *np)

drivers/soc/tegra/pmc.c

2961

if (pmc->soc->maybe_tz_only)

drivers/soc/tegra/pmc.c

2962

pmc->tz_only = tegra_pmc_detect_tz_only(pmc);

drivers/soc/tegra/pmc.c

2965

for (i = 0; i < pmc->soc->num_powergates; i++)

drivers/soc/tegra/pmc.c

2966

if (pmc->soc->powergates[i])

drivers/soc/tegra/pmc.c

2967

set_bit(i, pmc->powergates_available);

drivers/soc/tegra/pmc.c

2973

pmc->soc->setup_irq_polarity(pmc, np);

drivers/soc/tegra/pmc.c

2978

struct tegra_pmc *pmc = data;

drivers/soc/tegra/pmc.c

2980

pmc->suspend_mode = TEGRA_SUSPEND_NOT_READY;

drivers/soc/tegra/pmc.c

2985

struct tegra_pmc *pmc;

drivers/soc/tegra/pmc.c

2999

pmc = devm_kzalloc(&pdev->dev, sizeof(*pmc), GFP_KERNEL);

drivers/soc/tegra/pmc.c

3000

if (!pmc)

drivers/soc/tegra/pmc.c

3003

pmc->soc = device_get_match_data(&pdev->dev);

drivers/soc/tegra/pmc.c

3004

mutex_init(&pmc->powergates_lock);

drivers/soc/tegra/pmc.c

3005

pmc->dev = &pdev->dev;

drivers/soc/tegra/pmc.c

3007

err = tegra_pmc_parse_dt(pmc, pdev->dev.of_node);

drivers/soc/tegra/pmc.c

3012

pmc);

drivers/soc/tegra/pmc.c

3017

pmc->base = devm_platform_ioremap_resource(pdev, 0);

drivers/soc/tegra/pmc.c

3018

if (IS_ERR(pmc->base))

drivers/soc/tegra/pmc.c

3019

return PTR_ERR(pmc->base);

drivers/soc/tegra/pmc.c

3021

if (pmc->soc->has_single_mmio_aperture) {

drivers/soc/tegra/pmc.c

3022

pmc->wake = pmc->base;

drivers/soc/tegra/pmc.c

3023

pmc->aotag = pmc->base;

drivers/soc/tegra/pmc.c

3024

pmc->scratch = pmc->base;

drivers/soc/tegra/pmc.c

3026

pmc->wake = devm_platform_ioremap_resource_byname(pdev, "wake");

drivers/soc/tegra/pmc.c

3027

if (IS_ERR(pmc->wake))

drivers/soc/tegra/pmc.c

3028

return PTR_ERR(pmc->wake);

drivers/soc/tegra/pmc.c

3034

pmc->aotag = devm_ioremap_resource(&pdev->dev, res);

drivers/soc/tegra/pmc.c

3035

if (IS_ERR(pmc->aotag))

drivers/soc/tegra/pmc.c

3036

return PTR_ERR(pmc->aotag);

drivers/soc/tegra/pmc.c

3038

pmc->aotag = NULL;

drivers/soc/tegra/pmc.c

3045

pmc->scratch = devm_ioremap_resource(&pdev->dev, res);

drivers/soc/tegra/pmc.c

3046

if (IS_ERR(pmc->scratch))

drivers/soc/tegra/pmc.c

3047

return PTR_ERR(pmc->scratch);

drivers/soc/tegra/pmc.c

3049

pmc->scratch = NULL;

drivers/soc/tegra/pmc.c

3053

pmc->clk = devm_clk_get_optional(&pdev->dev, "pclk");

drivers/soc/tegra/pmc.c

3054

if (IS_ERR(pmc->clk))

drivers/soc/tegra/pmc.c

3055

return dev_err_probe(&pdev->dev, PTR_ERR(pmc->clk),

drivers/soc/tegra/pmc.c

3058

tegra_pmc_init_common(pmc, pdev->dev.of_node);

drivers/soc/tegra/pmc.c

3064

if (pmc->scratch) {

drivers/soc/tegra/pmc.c

3065

pmc->reboot_notifier.notifier_call = tegra_pmc_reboot_notify;

drivers/soc/tegra/pmc.c

3068

&pmc->reboot_notifier);

drivers/soc/tegra/pmc.c

3081

pmc);

drivers/soc/tegra/pmc.c

3097

pmc);

drivers/soc/tegra/pmc.c

3110

if (pmc->clk) {

drivers/soc/tegra/pmc.c

3111

pmc->clk_nb.notifier_call = tegra_pmc_clk_notify_cb;

drivers/soc/tegra/pmc.c

3112

err = devm_clk_notifier_register(&pdev->dev, pmc->clk,

drivers/soc/tegra/pmc.c

3113

&pmc->clk_nb);

drivers/soc/tegra/pmc.c

3120

pmc->rate = clk_get_rate(pmc->clk);

drivers/soc/tegra/pmc.c

3123

err = tegra_pmc_init(pmc);

drivers/soc/tegra/pmc.c

3129

tegra_pmc_init_tsense_reset(pmc);

drivers/soc/tegra/pmc.c

3131

tegra_pmc_reset_sysfs_init(pmc);

drivers/soc/tegra/pmc.c

3133

err = tegra_pmc_pinctrl_init(pmc);

drivers/soc/tegra/pmc.c

3137

err = tegra_pmc_regmap_init(pmc);

drivers/soc/tegra/pmc.c

3141

err = tegra_powergate_init(pmc, pdev->dev.of_node);

drivers/soc/tegra/pmc.c

3145

err = tegra_pmc_irq_init(pmc);

drivers/soc/tegra/pmc.c

3152

early_pmc->base = pmc->base;

drivers/soc/tegra/pmc.c

3156

tegra_pmc_clock_register(pmc, pdev->dev.of_node);

drivers/soc/tegra/pmc.c

3157

platform_set_drvdata(pdev, pmc);

drivers/soc/tegra/pmc.c

3161

if (pmc->soc->set_wake_filters)

drivers/soc/tegra/pmc.c

3162

pmc->soc->set_wake_filters(pmc);

drivers/soc/tegra/pmc.c

3164

if (pmc->soc->num_powergates)

drivers/soc/tegra/pmc.c

3165

debugfs_create_file("powergate", 0444, NULL, pmc, &powergate_fops);

drivers/soc/tegra/pmc.c

3182

static void wke_32kwritel(struct tegra_pmc *pmc, u32 value, unsigned int offset)

drivers/soc/tegra/pmc.c

3184

writel(value, pmc->wake + offset);

drivers/soc/tegra/pmc.c

3188

static void wke_write_wake_level(struct tegra_pmc *pmc, int wake, int level)

drivers/soc/tegra/pmc.c

3193

value = readl(pmc->wake + offset);

drivers/soc/tegra/pmc.c

3199

writel(value, pmc->wake + offset);

drivers/soc/tegra/pmc.c

3202

static void wke_write_wake_levels(struct tegra_pmc *pmc)

drivers/soc/tegra/pmc.c

3206

for (i = 0; i < pmc->soc->max_wake_events; i++)

drivers/soc/tegra/pmc.c

3207

wke_write_wake_level(pmc, i, test_bit(i, pmc->wake_cntrl_level_map));

drivers/soc/tegra/pmc.c

3210

static void wke_clear_sw_wake_status(struct tegra_pmc *pmc)

drivers/soc/tegra/pmc.c

3212

wke_32kwritel(pmc, 1, pmc->soc->regs->aowake_sw_status_w);

drivers/soc/tegra/pmc.c

3215

static void wke_read_sw_wake_status(struct tegra_pmc *pmc)

drivers/soc/tegra/pmc.c

3220

for (i = 0; i < pmc->soc->max_wake_events; i++)

drivers/soc/tegra/pmc.c

3221

wke_write_wake_level(pmc, i, 0);

drivers/soc/tegra/pmc.c

3223

wke_clear_sw_wake_status(pmc);

drivers/soc/tegra/pmc.c

3225

wke_32kwritel(pmc, 1, pmc->soc->regs->aowake_latch_sw);

drivers/soc/tegra/pmc.c

3233

for (i = 0; i < pmc->soc->max_wake_events; i++)

drivers/soc/tegra/pmc.c

3234

wke_write_wake_level(pmc, i, 1);

drivers/soc/tegra/pmc.c

3243

wke_32kwritel(pmc, 0, pmc->soc->regs->aowake_latch_sw);

drivers/soc/tegra/pmc.c

3245

bitmap_zero(pmc->wake_sw_status_map, pmc->soc->max_wake_events);

drivers/soc/tegra/pmc.c

3247

for (i = 0; i < pmc->soc->max_wake_vectors; i++) {

drivers/soc/tegra/pmc.c

3248

status = readl(pmc->wake + WAKE_AOWAKE_SW_STATUS(pmc, i));

drivers/soc/tegra/pmc.c

3251

set_bit(wake + (i * 32), pmc->wake_sw_status_map);

drivers/soc/tegra/pmc.c

3255

static void wke_clear_wake_status(struct tegra_pmc *pmc)

drivers/soc/tegra/pmc.c

3261

for (i = 0; i < pmc->soc->max_wake_vectors; i++) {

drivers/soc/tegra/pmc.c

3262

mask = readl(pmc->wake + WAKE_AOWAKE_TIER2_ROUTING(pmc, i));

drivers/soc/tegra/pmc.c

3263

status = readl(pmc->wake + WAKE_AOWAKE_STATUS_R(pmc, i)) & mask;

drivers/soc/tegra/pmc.c

3266

wke_32kwritel(pmc, 0x1, WAKE_AOWAKE_STATUS_W(pmc,

drivers/soc/tegra/pmc.c

3273

struct tegra_pmc *pmc = data;

drivers/soc/tegra/pmc.c

3277

for (i = 0; i < pmc->soc->max_wake_vectors; i++) {

drivers/soc/tegra/pmc.c

3278

mask = readl(pmc->wake + WAKE_AOWAKE_TIER2_ROUTING(pmc, i));

drivers/soc/tegra/pmc.c

3279

pmc->wake_status[i] = readl(pmc->wake +

drivers/soc/tegra/pmc.c

3280

WAKE_AOWAKE_STATUS_R(pmc, i)) & mask;

drivers/soc/tegra/pmc.c

3284

irq_work_queue(&pmc->wake_work);

drivers/soc/tegra/pmc.c

3289

struct tegra_pmc *pmc = data;

drivers/soc/tegra/pmc.c

3293

for (i = 0; i < pmc->soc->max_wake_vectors; i++)

drivers/soc/tegra/pmc.c

3294

if (pmc->wake_status[i])

drivers/soc/tegra/pmc.c

3295

dev_warn(pmc->dev,

drivers/soc/tegra/pmc.c

3297

i, pmc->wake_status[i]);

drivers/soc/tegra/pmc.c

3299

wke_read_sw_wake_status(pmc);

drivers/soc/tegra/pmc.c

3304

bitmap_andnot(pmc->wake_cntrl_level_map, pmc->wake_type_dual_edge_map,

drivers/soc/tegra/pmc.c

3305

pmc->wake_sw_status_map, pmc->soc->max_wake_events);

drivers/soc/tegra/pmc.c

3306

bitmap_or(pmc->wake_cntrl_level_map, pmc->wake_cntrl_level_map,

drivers/soc/tegra/pmc.c

3307

pmc->wake_type_level_map, pmc->soc->max_wake_events);

drivers/soc/tegra/pmc.c

3310

wke_clear_wake_status(pmc);

drivers/soc/tegra/pmc.c

3311

wke_write_wake_levels(pmc);

drivers/soc/tegra/pmc.c

3324

struct tegra_pmc *pmc = dev_get_drvdata(dev);

drivers/soc/tegra/pmc.c

3326

tegra_pmc_writel(pmc, virt_to_phys(tegra_resume), PMC_SCRATCH41);

drivers/soc/tegra/pmc.c

3333

struct tegra_pmc *pmc = dev_get_drvdata(dev);

drivers/soc/tegra/pmc.c

3335

tegra_pmc_writel(pmc, 0x0, PMC_SCRATCH41);

drivers/soc/tegra/pmc.c

3363

static void tegra20_pmc_init(struct tegra_pmc *pmc)

drivers/soc/tegra/pmc.c

3368

value = tegra_pmc_readl(pmc, PMC_CNTRL);

drivers/soc/tegra/pmc.c

3370

tegra_pmc_writel(pmc, value, PMC_CNTRL);

drivers/soc/tegra/pmc.c

3372

value = tegra_pmc_readl(pmc, PMC_CNTRL);

drivers/soc/tegra/pmc.c

3374

if (pmc->sysclkreq_high)

drivers/soc/tegra/pmc.c

3379

if (pmc->corereq_high)

drivers/soc/tegra/pmc.c

3385

tegra_pmc_writel(pmc, value, PMC_CNTRL);

drivers/soc/tegra/pmc.c

3388

value = tegra_pmc_readl(pmc, PMC_CNTRL);

drivers/soc/tegra/pmc.c

3390

tegra_pmc_writel(pmc, value, PMC_CNTRL);

drivers/soc/tegra/pmc.c

3393

if (pmc->suspend_mode != TEGRA_SUSPEND_NONE) {

drivers/soc/tegra/pmc.c

3394

osc = DIV_ROUND_UP(pmc->core_osc_time * 8192, 1000000);

drivers/soc/tegra/pmc.c

3395

pmu = DIV_ROUND_UP(pmc->core_pmu_time * 32768, 1000000);

drivers/soc/tegra/pmc.c

3396

off = DIV_ROUND_UP(pmc->core_off_time * 32768, 1000000);

drivers/soc/tegra/pmc.c

3397

tegra_pmc_writel(pmc, ((osc << 8) & 0xff00) | (pmu & 0xff),

drivers/soc/tegra/pmc.c

3399

tegra_pmc_writel(pmc, off, PMC_COREPWROFF_TIMER);

drivers/soc/tegra/pmc.c

3403

static void tegra20_pmc_setup_irq_polarity(struct tegra_pmc *pmc,

drivers/soc/tegra/pmc.c

3408

value = tegra_pmc_readl(pmc, PMC_CNTRL);

drivers/soc/tegra/pmc.c

3410

if (pmc->invert_irq)

drivers/soc/tegra/pmc.c

3415

tegra_pmc_writel(pmc, value, PMC_CNTRL);

drivers/soc/tegra/pmc.c

391

void (*init)(struct tegra_pmc *pmc);

drivers/soc/tegra/pmc.c

392

void (*setup_irq_polarity)(struct tegra_pmc *pmc,

drivers/soc/tegra/pmc.c

394

void (*set_wake_filters)(struct tegra_pmc *pmc);

drivers/soc/tegra/pmc.c

397

int (*powergate_set)(struct tegra_pmc *pmc, unsigned int id,

drivers/soc/tegra/pmc.c

4008

static void tegra186_pmc_init(struct tegra_pmc *pmc)

drivers/soc/tegra/pmc.c

4010

pmc->syscore.ops = &tegra186_pmc_wake_syscore_ops;

drivers/soc/tegra/pmc.c

4011

pmc->syscore.data = pmc;

drivers/soc/tegra/pmc.c

4012

register_syscore(&pmc->syscore);

drivers/soc/tegra/pmc.c

4015

static void tegra186_pmc_setup_irq_polarity(struct tegra_pmc *pmc,

drivers/soc/tegra/pmc.c

4025

dev_err(pmc->dev, "failed to find PMC wake registers\n");

drivers/soc/tegra/pmc.c

4033

dev_err(pmc->dev, "failed to map PMC wake registers\n");

drivers/soc/tegra/pmc.c

4037

value = readl(wake + pmc->soc->regs->aowake_ctrl);

drivers/soc/tegra/pmc.c

4039

if (pmc->invert_irq)

drivers/soc/tegra/pmc.c

4044

writel(value, wake + pmc->soc->regs->aowake_ctrl);

drivers/soc/tegra/pmc.c

4837

struct tegra_pmc *pmc = dev_get_drvdata(dev);

drivers/soc/tegra/pmc.c

4862

if (!pmc->soc->supports_core_domain)

drivers/soc/tegra/pmc.c

4870

pmc->core_domain_state_synced = true;

drivers/soc/tegra/pmc.c

4873

mutex_lock(&pmc->powergates_lock);

drivers/soc/tegra/pmc.c

4875

mutex_unlock(&pmc->powergates_lock);

drivers/soc/tegra/pmc.c

4904

static int tegra_get_cpu_powergate_id(struct tegra_pmc *pmc,

drivers/soc/tegra/pmc.c

4907

if (pmc->soc && cpuid < pmc->soc->num_cpu_powergates)

drivers/soc/tegra/pmc.c

4908

return pmc->soc->cpu_powergates[cpuid];

drivers/soc/tegra/pmc.c

530

static u32 tegra_pmc_readl(struct tegra_pmc *pmc, unsigned long offset)

drivers/soc/tegra/pmc.c

534

if (pmc->tz_only) {

drivers/soc/tegra/pmc.c

538

if (pmc->dev)

drivers/soc/tegra/pmc.c

539

dev_warn(pmc->dev, "%s(): SMC failed: %lu\n",

drivers/soc/tegra/pmc.c

549

return readl(pmc->base + offset);

drivers/soc/tegra/pmc.c

552

static void tegra_pmc_writel(struct tegra_pmc *pmc, u32 value,

drivers/soc/tegra/pmc.c

557

if (pmc->tz_only) {

drivers/soc/tegra/pmc.c

561

if (pmc->dev)

drivers/soc/tegra/pmc.c

562

dev_warn(pmc->dev, "%s(): SMC failed: %lu\n",

drivers/soc/tegra/pmc.c

569

writel(value, pmc->base + offset);

drivers/soc/tegra/pmc.c

573

static u32 tegra_pmc_scratch_readl(struct tegra_pmc *pmc, unsigned long offset)

drivers/soc/tegra/pmc.c

575

if (pmc->tz_only)

drivers/soc/tegra/pmc.c

576

return tegra_pmc_readl(pmc, offset);

drivers/soc/tegra/pmc.c

578

return readl(pmc->scratch + offset);

drivers/soc/tegra/pmc.c

581

static void tegra_pmc_scratch_writel(struct tegra_pmc *pmc, u32 value,

drivers/soc/tegra/pmc.c

584

if (pmc->tz_only)

drivers/soc/tegra/pmc.c

585

tegra_pmc_writel(pmc, value, offset);

drivers/soc/tegra/pmc.c

587

writel(value, pmc->scratch + offset);

drivers/soc/tegra/pmc.c

590

static inline bool tegra_powergate_state(struct tegra_pmc *pmc, int id)

drivers/soc/tegra/pmc.c

592

if (id == TEGRA_POWERGATE_3D && pmc->soc->has_gpu_clamps)

drivers/soc/tegra/pmc.c

593

return (tegra_pmc_readl(pmc, GPU_RG_CNTRL) & 0x1) == 0;

drivers/soc/tegra/pmc.c

595

return (tegra_pmc_readl(pmc, PWRGATE_STATUS) & BIT(id)) != 0;

drivers/soc/tegra/pmc.c

598

static inline bool tegra_powergate_is_valid(struct tegra_pmc *pmc, int id)

drivers/soc/tegra/pmc.c

600

return (pmc->soc && pmc->soc->powergates[id]);

drivers/soc/tegra/pmc.c

603

static inline bool tegra_powergate_is_available(struct tegra_pmc *pmc, int id)

drivers/soc/tegra/pmc.c

605

return test_bit(id, pmc->powergates_available);

drivers/soc/tegra/pmc.c

608

static int tegra_powergate_lookup(struct tegra_pmc *pmc, const char *name)

drivers/soc/tegra/pmc.c

612

if (!pmc || !pmc->soc || !name)

drivers/soc/tegra/pmc.c

615

for (i = 0; i < pmc->soc->num_powergates; i++) {

drivers/soc/tegra/pmc.c

616

if (!tegra_powergate_is_valid(pmc, i))

drivers/soc/tegra/pmc.c

619

if (!strcmp(name, pmc->soc->powergates[i]))

drivers/soc/tegra/pmc.c

626

static int tegra20_powergate_set(struct tegra_pmc *pmc, unsigned int id,

drivers/soc/tegra/pmc.c

639

tegra_pmc_writel(pmc, PWRGATE_TOGGLE_START | id, PWRGATE_TOGGLE);

drivers/soc/tegra/pmc.c

644

pmc, id);

drivers/soc/tegra/pmc.c

650

static inline bool tegra_powergate_toggle_ready(struct tegra_pmc *pmc)

drivers/soc/tegra/pmc.c

652

return !(tegra_pmc_readl(pmc, PWRGATE_TOGGLE) & PWRGATE_TOGGLE_START);

drivers/soc/tegra/pmc.c

655

static int tegra114_powergate_set(struct tegra_pmc *pmc, unsigned int id,

drivers/soc/tegra/pmc.c

662

err = readx_poll_timeout(tegra_powergate_toggle_ready, pmc, status,

drivers/soc/tegra/pmc.c

667

tegra_pmc_writel(pmc, PWRGATE_TOGGLE_START | id, PWRGATE_TOGGLE);

drivers/soc/tegra/pmc.c

670

err = readx_poll_timeout(tegra_powergate_toggle_ready, pmc, status,

drivers/soc/tegra/pmc.c

678

pmc, id);

drivers/soc/tegra/pmc.c

691

static int tegra_powergate_set(struct tegra_pmc *pmc, unsigned int id,

drivers/soc/tegra/pmc.c

696

if (id == TEGRA_POWERGATE_3D && pmc->soc->has_gpu_clamps)

drivers/soc/tegra/pmc.c

699

mutex_lock(&pmc->powergates_lock);

drivers/soc/tegra/pmc.c

701

if (tegra_powergate_state(pmc, id) == new_state) {

drivers/soc/tegra/pmc.c

702

mutex_unlock(&pmc->powergates_lock);

drivers/soc/tegra/pmc.c

706

err = pmc->soc->powergate_set(pmc, id, new_state);

drivers/soc/tegra/pmc.c

708

mutex_unlock(&pmc->powergates_lock);

drivers/soc/tegra/pmc.c

713

static int __tegra_powergate_remove_clamping(struct tegra_pmc *pmc,

drivers/soc/tegra/pmc.c

718

mutex_lock(&pmc->powergates_lock);

drivers/soc/tegra/pmc.c

725

if (pmc->soc->has_gpu_clamps) {

drivers/soc/tegra/pmc.c

726

tegra_pmc_writel(pmc, 0, GPU_RG_CNTRL);

drivers/soc/tegra/pmc.c

742

tegra_pmc_writel(pmc, mask, REMOVE_CLAMPING);

drivers/soc/tegra/pmc.c

745

mutex_unlock(&pmc->powergates_lock);

drivers/soc/tegra/pmc.c

840

err = tegra_powergate_set(pg->pmc, pg->id, true);

drivers/soc/tegra/pmc.c

856

err = __tegra_powergate_remove_clamping(pg->pmc, pg->id);

drivers/soc/tegra/pmc.c

868

if (pg->pmc->soc->needs_mbist_war)

drivers/soc/tegra/pmc.c

890

tegra_powergate_set(pg->pmc, pg->id, false);

drivers/soc/tegra/pmc.c

919

err = tegra_powergate_set(pg->pmc, pg->id, false);

drivers/soc/tegra/pmc.c

947

struct device *dev = pg->pmc->dev;

drivers/soc/tegra/pmc.c

966

struct device *dev = pg->pmc->dev;

drivers/soc/tegra/pmc.c

988

struct tegra_pmc *pmc = data;

drivers/soc/tegra/pmc.c

990

put_device(pmc->dev);

drivers/soc/tegra/pmc.c

999

struct tegra_pmc *pmc;

drivers/usb/gadget/udc/atmel_usba_udc.c

2042

regmap_update_bits(udc->pmc, AT91_CKGR_UCKR, AT91_PMC_BIASEN,

drivers/usb/gadget/udc/atmel_usba_udc.c

2048

regmap_update_bits(udc->pmc, AT91_CKGR_UCKR, AT91_PMC_BIASEN, 0);

drivers/usb/gadget/udc/atmel_usba_udc.c

2049

regmap_update_bits(udc->pmc, AT91_CKGR_UCKR, AT91_PMC_BIASEN,

drivers/usb/gadget/udc/atmel_usba_udc.c

2156

udc->pmc = syscon_node_to_regmap(pp);

drivers/usb/gadget/udc/atmel_usba_udc.c

2158

if (IS_ERR(udc->pmc))

drivers/usb/gadget/udc/atmel_usba_udc.c

2159

return ERR_CAST(udc->pmc);

drivers/usb/gadget/udc/atmel_usba_udc.h

360

struct regmap *pmc;

drivers/usb/host/xhci-tegra.c

1193

rc = tegra_pmc_powergate_sequence_power_up(tegra->pmc,

drivers/usb/host/xhci-tegra.c

1202

rc = tegra_pmc_powergate_sequence_power_up(tegra->pmc,

drivers/usb/host/xhci-tegra.c

1208

tegra_pmc_powergate_power_off(tegra->pmc,

drivers/usb/host/xhci-tegra.c

1236

rc = tegra_pmc_powergate_power_off(tegra->pmc,

drivers/usb/host/xhci-tegra.c

1243

rc = tegra_pmc_powergate_power_off(tegra->pmc,

drivers/usb/host/xhci-tegra.c

1247

tegra_pmc_powergate_sequence_power_up(tegra->pmc,

drivers/usb/host/xhci-tegra.c

1748

tegra->pmc = devm_tegra_pmc_get(&pdev->dev);

drivers/usb/host/xhci-tegra.c

1749

if (IS_ERR(tegra->pmc)) {

drivers/usb/host/xhci-tegra.c

1750

err = dev_err_probe(&pdev->dev, PTR_ERR(tegra->pmc),

drivers/usb/host/xhci-tegra.c

296

struct tegra_pmc *pmc;

drivers/usb/typec/mux/intel_pmc_mux.c

135

struct pmc_usb *pmc;

drivers/usb/typec/mux/intel_pmc_mux.c

173

port->iom_status = readl(port->pmc->iom_base +

drivers/usb/typec/mux/intel_pmc_mux.c

174

port->pmc->iom_port_status_offset +

drivers/usb/typec/mux/intel_pmc_mux.c

175

port_num * port->pmc->iom_port_status_size);

drivers/usb/typec/mux/intel_pmc_mux.c

239

ret = pmc_usb_send_command(port->pmc->ipc, msg, len);

drivers/usb/typec/mux/intel_pmc_mux.c

302

if (!is_pmc_mux_tbt(port->pmc->iom_adev)) {

drivers/usb/typec/mux/intel_pmc_mux.c

358

if (acpi_dev_hid_uid_match(port->pmc->iom_adev, "INTC1072", NULL) ||

drivers/usb/typec/mux/intel_pmc_mux.c

359

acpi_dev_hid_uid_match(port->pmc->iom_adev, "INTC1079", NULL)) {

drivers/usb/typec/mux/intel_pmc_mux.c

409

if (!acpi_dev_hid_uid_match(port->pmc->iom_adev, "INTC1072", NULL) ||

drivers/usb/typec/mux/intel_pmc_mux.c

410

!acpi_dev_hid_uid_match(port->pmc->iom_adev, "INTC1079", NULL))

drivers/usb/typec/mux/intel_pmc_mux.c

414

if (acpi_dev_hid_uid_match(port->pmc->iom_adev, "INTC1072", NULL) ||

drivers/usb/typec/mux/intel_pmc_mux.c

415

acpi_dev_hid_uid_match(port->pmc->iom_adev, "INTC1079", NULL))

drivers/usb/typec/mux/intel_pmc_mux.c

573

static int pmc_usb_register_port(struct pmc_usb *pmc, int index,

drivers/usb/typec/mux/intel_pmc_mux.c

576

struct pmc_usb_port *port = &pmc->port[index];

drivers/usb/typec/mux/intel_pmc_mux.c

600

port->pmc = pmc;

drivers/usb/typec/mux/intel_pmc_mux.c

607

port->typec_sw = typec_switch_register(pmc->dev, &sw_desc);

drivers/usb/typec/mux/intel_pmc_mux.c

616

port->typec_mux = typec_mux_register(pmc->dev, &mux_desc);

drivers/usb/typec/mux/intel_pmc_mux.c

628

port->usb_sw = usb_role_switch_register(pmc->dev, &desc);

drivers/usb/typec/mux/intel_pmc_mux.c

661

static int pmc_usb_probe_iom(struct pmc_usb *pmc)

drivers/usb/typec/mux/intel_pmc_mux.c

677

pmc->iom_port_status_offset = IOM_PORT_STATUS_REGS_OFFSET(dev_id->driver_data);

drivers/usb/typec/mux/intel_pmc_mux.c

678

pmc->iom_port_status_size = IOM_PORT_STATUS_REGS_SIZE(dev_id->driver_data);

drivers/usb/typec/mux/intel_pmc_mux.c

689

pmc->iom_base = devm_ioremap_resource(pmc->dev, rentry->res);

drivers/usb/typec/mux/intel_pmc_mux.c

693

if (!pmc->iom_base) {

drivers/usb/typec/mux/intel_pmc_mux.c

698

if (IS_ERR(pmc->iom_base)) {

drivers/usb/typec/mux/intel_pmc_mux.c

700

return PTR_ERR(pmc->iom_base);

drivers/usb/typec/mux/intel_pmc_mux.c

703

pmc->iom_adev = adev;

drivers/usb/typec/mux/intel_pmc_mux.c

726

debugfs_dir = debugfs_create_dir(name, port->pmc->dentry);

drivers/usb/typec/mux/intel_pmc_mux.c

734

struct pmc_usb *pmc;

drivers/usb/typec/mux/intel_pmc_mux.c

748

pmc = devm_kzalloc(&pdev->dev, struct_size(pmc, port, num_ports), GFP_KERNEL);

drivers/usb/typec/mux/intel_pmc_mux.c

749

if (!pmc)

drivers/usb/typec/mux/intel_pmc_mux.c

752

pmc->num_ports = num_ports;

drivers/usb/typec/mux/intel_pmc_mux.c

754

pmc->ipc = devm_intel_scu_ipc_dev_get(&pdev->dev);

drivers/usb/typec/mux/intel_pmc_mux.c

755

if (!pmc->ipc)

drivers/usb/typec/mux/intel_pmc_mux.c

758

pmc->dev = &pdev->dev;

drivers/usb/typec/mux/intel_pmc_mux.c

760

ret = pmc_usb_probe_iom(pmc);

drivers/usb/typec/mux/intel_pmc_mux.c

764

pmc->dentry = debugfs_create_dir(dev_name(pmc->dev), pmc_mux_debugfs_root);

drivers/usb/typec/mux/intel_pmc_mux.c

770

for (i = 0; i < pmc->num_ports; i++) {

drivers/usb/typec/mux/intel_pmc_mux.c

771

fwnode = device_get_next_child_node(pmc->dev, fwnode);

drivers/usb/typec/mux/intel_pmc_mux.c

775

ret = pmc_usb_register_port(pmc, i, fwnode);

drivers/usb/typec/mux/intel_pmc_mux.c

781

pmc_mux_port_debugfs_init(&pmc->port[i]);

drivers/usb/typec/mux/intel_pmc_mux.c

784

platform_set_drvdata(pdev, pmc);

drivers/usb/typec/mux/intel_pmc_mux.c

789

for (i = 0; i < pmc->num_ports; i++) {

drivers/usb/typec/mux/intel_pmc_mux.c

790

typec_switch_unregister(pmc->port[i].typec_sw);

drivers/usb/typec/mux/intel_pmc_mux.c

791

typec_mux_unregister(pmc->port[i].typec_mux);

drivers/usb/typec/mux/intel_pmc_mux.c

792

usb_role_switch_unregister(pmc->port[i].usb_sw);

drivers/usb/typec/mux/intel_pmc_mux.c

795

acpi_dev_put(pmc->iom_adev);

drivers/usb/typec/mux/intel_pmc_mux.c

797

debugfs_remove(pmc->dentry);

drivers/usb/typec/mux/intel_pmc_mux.c

804

struct pmc_usb *pmc = platform_get_drvdata(pdev);

drivers/usb/typec/mux/intel_pmc_mux.c

807

for (i = 0; i < pmc->num_ports; i++) {

drivers/usb/typec/mux/intel_pmc_mux.c

808

typec_switch_unregister(pmc->port[i].typec_sw);

drivers/usb/typec/mux/intel_pmc_mux.c

809

typec_mux_unregister(pmc->port[i].typec_mux);

drivers/usb/typec/mux/intel_pmc_mux.c

810

usb_role_switch_unregister(pmc->port[i].usb_sw);

drivers/usb/typec/mux/intel_pmc_mux.c

813

acpi_dev_put(pmc->iom_adev);

drivers/usb/typec/mux/intel_pmc_mux.c

815

debugfs_remove(pmc->dentry);

drivers/vfio/pci/vfio_pci_config.c

1481

__le16 *pmc = (__le16 *)&vdev->vconfig[offset + PCI_PM_PMC];

drivers/vfio/pci/vfio_pci_config.c

1485

*pmc &= ~cpu_to_le16(PCI_PM_CAP_PME_MASK);

drivers/watchdog/iTCO_wdt.c

248

struct intel_pmc_dev *pmc = priv;

drivers/watchdog/iTCO_wdt.c

252

return intel_pmc_gcr_update(pmc, PMC_GCR_PMC_CFG_REG, bits, value);

drivers/watchdog/iTCO_wdt.c

260

struct intel_pmc_dev *pmc = dev_get_drvdata(pdev->dev.parent);

drivers/watchdog/iTCO_wdt.c

263

p->no_reboot_priv = pmc;

include/kvm/arm_pmu.h

32

struct kvm_pmc pmc[KVM_ARMV8_PMU_MAX_COUNTERS];

include/linux/mfd/intel_pmc_bxt.h

31

int intel_pmc_gcr_read64(struct intel_pmc_dev *pmc, u32 offset, u64 *data);

include/linux/mfd/intel_pmc_bxt.h

32

int intel_pmc_gcr_update(struct intel_pmc_dev *pmc, u32 offset, u32 mask, u32 val);

include/linux/mfd/intel_pmc_bxt.h

33

int intel_pmc_s0ix_counter_read(struct intel_pmc_dev *pmc, u64 *data);

include/linux/mfd/intel_pmc_bxt.h

35

static inline int intel_pmc_gcr_read64(struct intel_pmc_dev *pmc, u32 offset,

include/linux/mfd/intel_pmc_bxt.h

41

static inline int intel_pmc_gcr_update(struct intel_pmc_dev *pmc, u32 offset,

include/linux/mfd/intel_pmc_bxt.h

47

static inline int intel_pmc_s0ix_counter_read(struct intel_pmc_dev *pmc, u64 *data)

include/soc/tegra/pmc.h

151

int tegra_pmc_powergate_power_on(struct tegra_pmc *pmc, unsigned int id);

include/soc/tegra/pmc.h

152

int tegra_pmc_powergate_power_off(struct tegra_pmc *pmc, unsigned int id);

include/soc/tegra/pmc.h

153

int tegra_pmc_powergate_remove_clamping(struct tegra_pmc *pmc, unsigned int id);

include/soc/tegra/pmc.h

156

int tegra_pmc_powergate_sequence_power_up(struct tegra_pmc *pmc,

include/soc/tegra/pmc.h

159

int tegra_pmc_io_pad_power_enable(struct tegra_pmc *pmc, enum tegra_io_pad id);

include/soc/tegra/pmc.h

160

int tegra_pmc_io_pad_power_disable(struct tegra_pmc *pmc, enum tegra_io_pad id);

include/soc/tegra/pmc.h

169

tegra_pmc_powergate_power_on(struct tegra_pmc *pmc, unsigned int id)

include/soc/tegra/pmc.h

175

tegra_pmc_powergate_power_off(struct tegra_pmc *pmc, unsigned int id)

include/soc/tegra/pmc.h

181

tegra_pmc_powergate_remove_clamping(struct tegra_pmc *pmc, unsigned int id)

include/soc/tegra/pmc.h

188

tegra_pmc_powergate_sequence_power_up(struct tegra_pmc *pmc, unsigned int id,

include/soc/tegra/pmc.h

196

tegra_pmc_io_pad_power_enable(struct tegra_pmc *pmc, enum tegra_io_pad id)

include/soc/tegra/pmc.h

202

tegra_pmc_io_pad_power_disable(struct tegra_pmc *pmc, enum tegra_io_pad id)

include/uapi/linux/kfd_ioctl.h

1586

struct kfd_ioctl_pmc_settings pmc;

mm/internal.h

1826

unsigned long move_page_tables(struct pagetable_move_control *pmc);

mm/mremap.c

1265

PAGETABLE_MOVE(pmc, NULL, NULL, vrm->addr, vrm->new_addr, vrm->old_len);

mm/mremap.c

1268

&pmc.need_rmap_locks);

mm/mremap.c

1279

pmc.old = vma;

mm/mremap.c

1280

pmc.new = new_vma;

mm/mremap.c

1282

moved_len = move_page_tables(&pmc);

mm/mremap.c

197

static int move_ptes(struct pagetable_move_control *pmc,

mm/mremap.c

200

struct vm_area_struct *vma = pmc->old;

mm/mremap.c

208

unsigned long old_addr = pmc->old_addr;

mm/mremap.c

209

unsigned long new_addr = pmc->new_addr;

mm/mremap.c

234

if (pmc->need_rmap_locks)

mm/mremap.c

316

if (pmc->need_rmap_locks)

mm/mremap.c

330

static inline bool uffd_supports_page_table_move(struct pagetable_move_control *pmc)

mm/mremap.c

345

return !vma_has_uffd_without_event_remap(pmc->old) &&

mm/mremap.c

346

!vma_has_uffd_without_event_remap(pmc->new);

mm/mremap.c

350

static bool move_normal_pmd(struct pagetable_move_control *pmc,

mm/mremap.c

354

struct vm_area_struct *vma = pmc->old;

mm/mremap.c

361

if (!uffd_supports_page_table_move(pmc))

mm/mremap.c

410

flush_tlb_range(vma, pmc->old_addr, pmc->old_addr + PMD_SIZE);

mm/mremap.c

419

static inline bool move_normal_pmd(struct pagetable_move_control *pmc,

mm/mremap.c

427

static bool move_normal_pud(struct pagetable_move_control *pmc,

mm/mremap.c

431

struct vm_area_struct *vma = pmc->old;

mm/mremap.c

437

if (!uffd_supports_page_table_move(pmc))

mm/mremap.c

462

flush_tlb_range(vma, pmc->old_addr, pmc->old_addr + PUD_SIZE);

mm/mremap.c

470

static inline bool move_normal_pud(struct pagetable_move_control *pmc,

mm/mremap.c

478

static bool move_huge_pud(struct pagetable_move_control *pmc,

mm/mremap.c

482

struct vm_area_struct *vma = pmc->old;

mm/mremap.c

510

set_pud_at(mm, pmc->new_addr, new_pud, pud);

mm/mremap.c

511

flush_pud_tlb_range(vma, pmc->old_addr, pmc->old_addr + HPAGE_PUD_SIZE);

mm/mremap.c

519

static bool move_huge_pud(struct pagetable_move_control *pmc,

mm/mremap.c

542

struct pagetable_move_control *pmc)

mm/mremap.c

545

unsigned long old_addr = pmc->old_addr;

mm/mremap.c

546

unsigned long old_end = pmc->old_end;

mm/mremap.c

547

unsigned long new_addr = pmc->new_addr;

mm/mremap.c

580

static bool should_take_rmap_locks(struct pagetable_move_control *pmc,

mm/mremap.c

588

return pmc->need_rmap_locks;

mm/mremap.c

596

static bool move_pgt_entry(struct pagetable_move_control *pmc,

mm/mremap.c

600

bool need_rmap_locks = should_take_rmap_locks(pmc, entry);

mm/mremap.c

604

take_rmap_locks(pmc->old);

mm/mremap.c

608

moved = move_normal_pmd(pmc, old_entry, new_entry);

mm/mremap.c

611

moved = move_normal_pud(pmc, old_entry, new_entry);

mm/mremap.c

615

move_huge_pmd(pmc->old, pmc->old_addr, pmc->new_addr, old_entry,

mm/mremap.c

620

move_huge_pud(pmc, old_entry, new_entry);

mm/mremap.c

629

drop_rmap_locks(pmc->old);

mm/mremap.c

640

static bool can_align_down(struct pagetable_move_control *pmc,

mm/mremap.c

651

if (!pmc->for_stack && vma->vm_start != addr_to_align)

mm/mremap.c

655

if (pmc->for_stack && addr_masked >= vma->vm_start)

mm/mremap.c

669

static bool can_realign_addr(struct pagetable_move_control *pmc,

mm/mremap.c

673

unsigned long old_align = pmc->old_addr & align_mask;

mm/mremap.c

674

unsigned long new_align = pmc->new_addr & align_mask;

mm/mremap.c

698

if (pmc->len_in < old_align_next)

mm/mremap.c

710

if (!can_align_down(pmc, pmc->old, pmc->old_addr, pagetable_mask) ||

mm/mremap.c

711

!can_align_down(pmc, pmc->new, pmc->new_addr, pagetable_mask))

mm/mremap.c

748

static void try_realign_addr(struct pagetable_move_control *pmc,

mm/mremap.c

752

if (!can_realign_addr(pmc, pagetable_mask))

mm/mremap.c

761

pmc->old_addr &= pagetable_mask;

mm/mremap.c

762

pmc->new_addr &= pagetable_mask;

mm/mremap.c

766

static bool pmc_done(struct pagetable_move_control *pmc)

mm/mremap.c

768

return pmc->old_addr >= pmc->old_end;

mm/mremap.c

772

static void pmc_next(struct pagetable_move_control *pmc, unsigned long extent)

mm/mremap.c

774

pmc->old_addr += extent;

mm/mremap.c

775

pmc->new_addr += extent;

mm/mremap.c

782

static unsigned long pmc_progress(struct pagetable_move_control *pmc)

mm/mremap.c

784

unsigned long orig_old_addr = pmc->old_end - pmc->len_in;

mm/mremap.c

785

unsigned long old_addr = pmc->old_addr;

mm/mremap.c

795

unsigned long move_page_tables(struct pagetable_move_control *pmc)

mm/mremap.c

801

struct mm_struct *mm = pmc->old->vm_mm;

mm/mremap.c

803

if (!pmc->len_in)

mm/mremap.c

806

if (is_vm_hugetlb_page(pmc->old))

mm/mremap.c

807

return move_hugetlb_page_tables(pmc->old, pmc->new, pmc->old_addr,

mm/mremap.c

808

pmc->new_addr, pmc->len_in);

mm/mremap.c

814

try_realign_addr(pmc, PMD_MASK);

mm/mremap.c

816

flush_cache_range(pmc->old, pmc->old_addr, pmc->old_end);

mm/mremap.c

818

pmc->old_addr, pmc->old_end);

mm/mremap.c

821

for (; !pmc_done(pmc); pmc_next(pmc, extent)) {

mm/mremap.c

827

extent = get_extent(NORMAL_PUD, pmc);

mm/mremap.c

829

old_pud = get_old_pud(mm, pmc->old_addr);

mm/mremap.c

832

new_pud = alloc_new_pud(mm, pmc->new_addr);

mm/mremap.c

837

move_pgt_entry(pmc, HPAGE_PUD, old_pud, new_pud);

mm/mremap.c

842

if (move_pgt_entry(pmc, NORMAL_PUD, old_pud, new_pud))

mm/mremap.c

846

extent = get_extent(NORMAL_PMD, pmc);

mm/mremap.c

847

old_pmd = get_old_pmd(mm, pmc->old_addr);

mm/mremap.c

850

new_pmd = alloc_new_pmd(mm, pmc->new_addr);

mm/mremap.c

856

move_pgt_entry(pmc, HPAGE_PMD, old_pmd, new_pmd))

mm/mremap.c

858

split_huge_pmd(pmc->old, old_pmd, pmc->old_addr);

mm/mremap.c

865

if (move_pgt_entry(pmc, NORMAL_PMD, old_pmd, new_pmd))

mm/mremap.c

870

if (pte_alloc(pmc->new->vm_mm, new_pmd))

mm/mremap.c

872

if (move_ptes(pmc, extent, old_pmd, new_pmd) < 0)

mm/mremap.c

878

return pmc_progress(pmc);

mm/vma_exec.c

43

PAGETABLE_MOVE(pmc, vma, vma, old_start, new_start, length);

mm/vma_exec.c

66

pmc.for_stack = true;

mm/vma_exec.c

67

if (length != move_page_tables(&pmc))

net/batman-adv/multicast.c

373

struct ip_mc_list *pmc;

net/batman-adv/multicast.c

387

for (pmc = rcu_dereference(in_dev->mc_list); pmc;

net/batman-adv/multicast.c

388

pmc = rcu_dereference(pmc->next_rcu)) {

net/batman-adv/multicast.c

390

ipv4_is_local_multicast(pmc->multiaddr))

net/batman-adv/multicast.c

394

!ipv4_is_local_multicast(pmc->multiaddr))

net/batman-adv/multicast.c

397

ip_eth_mc_map(pmc->multiaddr, mcast_addr);

net/ipv4/igmp.c

1209

struct ip_mc_list *pmc;

net/ipv4/igmp.c

1218

pmc = kzalloc_obj(*pmc, gfp);

net/ipv4/igmp.c

1219

if (!pmc)

net/ipv4/igmp.c

1221

spin_lock_init(&pmc->lock);

net/ipv4/igmp.c

1223

pmc->interface = im->interface;

net/ipv4/igmp.c

1225

pmc->multiaddr = im->multiaddr;

net/ipv4/igmp.c

1226

pmc->crcount = in_dev->mr_qrv ?: READ_ONCE(net->ipv4.sysctl_igmp_qrv);

net/ipv4/igmp.c

1227

pmc->sfmode = im->sfmode;

net/ipv4/igmp.c

1228

if (pmc->sfmode == MCAST_INCLUDE) {

net/ipv4/igmp.c

1231

pmc->tomb = im->tomb;

net/ipv4/igmp.c

1232

pmc->sources = im->sources;

net/ipv4/igmp.c

1234

for (psf = pmc->sources; psf; psf = psf->sf_next)

net/ipv4/igmp.c

1235

psf->sf_crcount = pmc->crcount;

net/ipv4/igmp.c

1240

pmc->next = in_dev->mc_tomb;

net/ipv4/igmp.c

1241

in_dev->mc_tomb = pmc;

net/ipv4/igmp.c

1250

struct ip_mc_list *pmc, *pmc_prev;

net/ipv4/igmp.c

1257

for (pmc = in_dev->mc_tomb; pmc; pmc = pmc->next) {

net/ipv4/igmp.c

1258

if (pmc->multiaddr == multiaddr)

net/ipv4/igmp.c

1260

pmc_prev = pmc;

net/ipv4/igmp.c

1262

if (pmc) {

net/ipv4/igmp.c

1264

pmc_prev->next = pmc->next;

net/ipv4/igmp.c

1266

in_dev->mc_tomb = pmc->next;

net/ipv4/igmp.c

1271

if (pmc) {

net/ipv4/igmp.c

1272

im->interface = pmc->interface;

net/ipv4/igmp.c

1274

swap(im->tomb, pmc->tomb);

net/ipv4/igmp.c

1275

swap(im->sources, pmc->sources);

net/ipv4/igmp.c

1283

in_dev_put(pmc->interface);

net/ipv4/igmp.c

1284

kfree_pmc(pmc);

net/ipv4/igmp.c

1294

struct ip_mc_list *pmc, *nextpmc;

net/ipv4/igmp.c

1297

pmc = in_dev->mc_tomb;

net/ipv4/igmp.c

1301

for (; pmc; pmc = nextpmc) {

net/ipv4/igmp.c

1302

nextpmc = pmc->next;

net/ipv4/igmp.c

1303

ip_mc_clear_src(pmc);

net/ipv4/igmp.c

1304

in_dev_put(pmc->interface);

net/ipv4/igmp.c

1305

kfree_pmc(pmc);

net/ipv4/igmp.c

1309

for_each_pmc_rcu(in_dev, pmc) {

net/ipv4/igmp.c

1312

spin_lock_bh(&pmc->lock);

net/ipv4/igmp.c

1313

psf = pmc->tomb;

net/ipv4/igmp.c

1314

pmc->tomb = NULL;

net/ipv4/igmp.c

1315

spin_unlock_bh(&pmc->lock);

net/ipv4/igmp.c

176

static int sf_setstate(struct ip_mc_list *pmc);

net/ipv4/igmp.c

177

static void sf_markstate(struct ip_mc_list *pmc);

net/ipv4/igmp.c

179

static void ip_mc_clear_src(struct ip_mc_list *pmc);

net/ipv4/igmp.c

1830

struct ip_mc_list *pmc;

net/ipv4/igmp.c

1834

for_each_pmc_rtnl(in_dev, pmc)

net/ipv4/igmp.c

1835

igmp_group_dropped(pmc);

net/ipv4/igmp.c

1840

struct ip_mc_list *pmc;

net/ipv4/igmp.c

1844

for_each_pmc_rtnl(in_dev, pmc) {

net/ipv4/igmp.c

1846

igmpv3_del_delrec(in_dev, pmc);

net/ipv4/igmp.c

1848

igmp_group_added(pmc);

net/ipv4/igmp.c

1856

struct ip_mc_list *pmc;

net/ipv4/igmp.c

1860

for_each_pmc_rtnl(in_dev, pmc)

net/ipv4/igmp.c

1861

igmp_group_dropped(pmc);

net/ipv4/igmp.c

1907

struct ip_mc_list *pmc;

net/ipv4/igmp.c

191

#define for_each_pmc_rcu(in_dev, pmc) \

net/ipv4/igmp.c

1914

for_each_pmc_rtnl(in_dev, pmc) {

net/ipv4/igmp.c

1916

igmpv3_del_delrec(in_dev, pmc);

net/ipv4/igmp.c

1918

igmp_group_added(pmc);

net/ipv4/igmp.c

192

for (pmc = rcu_dereference(in_dev->mc_list); \

net/ipv4/igmp.c

193

pmc != NULL; \

net/ipv4/igmp.c

194

pmc = rcu_dereference(pmc->next_rcu))

net/ipv4/igmp.c

196

#define for_each_pmc_rtnl(in_dev, pmc) \

net/ipv4/igmp.c

197

for (pmc = rtnl_dereference(in_dev->mc_list); \

net/ipv4/igmp.c

198

pmc != NULL; \

net/ipv4/igmp.c

1984

static int ip_mc_del1_src(struct ip_mc_list *pmc, int sfmode,

net/ipv4/igmp.c

199

pmc = rtnl_dereference(pmc->next_rcu))

net/ipv4/igmp.c

1991

for (psf = pmc->sources; psf; psf = psf->sf_next) {

net/ipv4/igmp.c

2002

ip_rt_multicast_event(pmc->interface);

net/ipv4/igmp.c

2006

struct in_device *in_dev = pmc->interface;

net/ipv4/igmp.c

2014

pmc->sources = psf->sf_next;

net/ipv4/igmp.c

2019

psf->sf_next = pmc->tomb;

net/ipv4/igmp.c

2020

pmc->tomb = psf;

net/ipv4/igmp.c

2036

struct ip_mc_list *pmc;

net/ipv4/igmp.c

2043

for_each_pmc_rcu(in_dev, pmc) {

net/ipv4/igmp.c

2044

if (*pmca == pmc->multiaddr)

net/ipv4/igmp.c

2047

if (!pmc) {

net/ipv4/igmp.c

2052

spin_lock_bh(&pmc->lock);

net/ipv4/igmp.c

2055

sf_markstate(pmc);

net/ipv4/igmp.c

2059

if (!pmc->sfcount[sfmode])

net/ipv4/igmp.c

2061

pmc->sfcount[sfmode]--;

net/ipv4/igmp.c

2065

int rv = ip_mc_del1_src(pmc, sfmode, &psfsrc[i]);

net/ipv4/igmp.c

2071

if (pmc->sfmode == MCAST_EXCLUDE &&

net/ipv4/igmp.c

2072

pmc->sfcount[MCAST_EXCLUDE] == 0 &&

net/ipv4/igmp.c

2073

pmc->sfcount[MCAST_INCLUDE]) {

net/ipv4/igmp.c

2080

pmc->sfmode = MCAST_INCLUDE;

net/ipv4/igmp.c

2082

pmc->crcount = in_dev->mr_qrv ?: READ_ONCE(net->ipv4.sysctl_igmp_qrv);

net/ipv4/igmp.c

2083

WRITE_ONCE(in_dev->mr_ifc_count, pmc->crcount);

net/ipv4/igmp.c

2084

for (psf = pmc->sources; psf; psf = psf->sf_next)

net/ipv4/igmp.c

2086

igmp_ifc_event(pmc->interface);

net/ipv4/igmp.c

2087

} else if (sf_setstate(pmc) || changerec) {

net/ipv4/igmp.c

2088

igmp_ifc_event(pmc->interface);

net/ipv4/igmp.c

2092

spin_unlock_bh(&pmc->lock);

net/ipv4/igmp.c

2099

static int ip_mc_add1_src(struct ip_mc_list *pmc, int sfmode,

net/ipv4/igmp.c

2105

for (psf = pmc->sources; psf; psf = psf->sf_next) {

net/ipv4/igmp.c

2118

pmc->sources = psf;

net/ipv4/igmp.c

2122

ip_rt_multicast_event(pmc->interface);

net/ipv4/igmp.c

2128

static void sf_markstate(struct ip_mc_list *pmc)

net/ipv4/igmp.c

2131

int mca_xcount = pmc->sfcount[MCAST_EXCLUDE];

net/ipv4/igmp.c

2133

for (psf = pmc->sources; psf; psf = psf->sf_next)

net/ipv4/igmp.c

2134

if (pmc->sfcount[MCAST_EXCLUDE]) {

net/ipv4/igmp.c

2142

static int sf_setstate(struct ip_mc_list *pmc)

net/ipv4/igmp.c

2145

int mca_xcount = pmc->sfcount[MCAST_EXCLUDE];

net/ipv4/igmp.c

2146

int qrv = pmc->interface->mr_qrv;

net/ipv4/igmp.c

2150

for (psf = pmc->sources; psf; psf = psf->sf_next) {

net/ipv4/igmp.c

2151

if (pmc->sfcount[MCAST_EXCLUDE]) {

net/ipv4/igmp.c

2160

for (dpsf = pmc->tomb; dpsf; dpsf = dpsf->sf_next) {

net/ipv4/igmp.c

2169

pmc->tomb = dpsf->sf_next;

net/ipv4/igmp.c

2182

for (dpsf = pmc->tomb; dpsf; dpsf = dpsf->sf_next)

net/ipv4/igmp.c

2191

dpsf->sf_next = pmc->tomb;

net/ipv4/igmp.c

2192

pmc->tomb = dpsf;

net/ipv4/igmp.c

2208

struct ip_mc_list *pmc;

net/ipv4/igmp.c

2215

for_each_pmc_rcu(in_dev, pmc) {

net/ipv4/igmp.c

2216

if (*pmca == pmc->multiaddr)

net/ipv4/igmp.c

2219

if (!pmc) {

net/ipv4/igmp.c

2224

spin_lock_bh(&pmc->lock);

net/ipv4/igmp.c

2228

sf_markstate(pmc);

net/ipv4/igmp.c

2230

isexclude = pmc->sfmode == MCAST_EXCLUDE;

net/ipv4/igmp.c

2232

pmc->sfcount[sfmode]++;

net/ipv4/igmp.c

2235

err = ip_mc_add1_src(pmc, sfmode, &psfsrc[i]);

net/ipv4/igmp.c

2243

pmc->sfcount[sfmode]--;

net/ipv4/igmp.c

2245

(void) ip_mc_del1_src(pmc, sfmode, &psfsrc[j]);

net/ipv4/igmp.c

2246

} else if (isexclude != (pmc->sfcount[MCAST_EXCLUDE] != 0)) {

net/ipv4/igmp.c

2249

struct net *net = dev_net(pmc->interface->dev);

net/ipv4/igmp.c

2250

in_dev = pmc->interface;

net/ipv4/igmp.c

2254

if (pmc->sfcount[MCAST_EXCLUDE])

net/ipv4/igmp.c

2255

pmc->sfmode = MCAST_EXCLUDE;

net/ipv4/igmp.c

2256

else if (pmc->sfcount[MCAST_INCLUDE])

net/ipv4/igmp.c

2257

pmc->sfmode = MCAST_INCLUDE;

net/ipv4/igmp.c

2261

pmc->crcount = in_dev->mr_qrv ?: READ_ONCE(net->ipv4.sysctl_igmp_qrv);

net/ipv4/igmp.c

2262

WRITE_ONCE(in_dev->mr_ifc_count, pmc->crcount);

net/ipv4/igmp.c

2263

for (psf = pmc->sources; psf; psf = psf->sf_next)

net/ipv4/igmp.c

2266

} else if (sf_setstate(pmc)) {

net/ipv4/igmp.c

2270

spin_unlock_bh(&pmc->lock);

net/ipv4/igmp.c

2274

static void ip_mc_clear_src(struct ip_mc_list *pmc)

net/ipv4/igmp.c

2278

spin_lock_bh(&pmc->lock);

net/ipv4/igmp.c

2279

tomb = pmc->tomb;

net/ipv4/igmp.c

2280

pmc->tomb = NULL;

net/ipv4/igmp.c

2281

sources = pmc->sources;

net/ipv4/igmp.c

2282

pmc->sources = NULL;

net/ipv4/igmp.c

2283

pmc->sfmode = MCAST_EXCLUDE;

net/ipv4/igmp.c

2284

pmc->sfcount[MCAST_INCLUDE] = 0;

net/ipv4/igmp.c

2285

pmc->sfcount[MCAST_EXCLUDE] = 1;

net/ipv4/igmp.c

2286

spin_unlock_bh(&pmc->lock);

net/ipv4/igmp.c

2434

struct ip_mc_socklist *pmc;

net/ipv4/igmp.c

2458

for_each_pmc_rtnl(inet, pmc) {

net/ipv4/igmp.c

2459

if ((pmc->multi.imr_multiaddr.s_addr ==

net/ipv4/igmp.c

2461

(pmc->multi.imr_ifindex == imr.imr_ifindex))

net/ipv4/igmp.c

2464

if (!pmc) { /* must have a prior join */

net/ipv4/igmp.c

2469

if (pmc->sflist) {

net/ipv4/igmp.c

2470

if (pmc->sfmode != omode) {

net/ipv4/igmp.c

2474

} else if (pmc->sfmode != omode) {

net/ipv4/igmp.c

2477

ip_mc_del_src(in_dev, &mreqs->imr_multiaddr, pmc->sfmode, 0,

net/ipv4/igmp.c

2479

pmc->sfmode = omode;

net/ipv4/igmp.c

2482

psl = rtnl_dereference(pmc->sflist);

net/ipv4/igmp.c

2539

rcu_assign_pointer(pmc->sflist, newpsl);

net/ipv4/igmp.c

2572

struct ip_mc_socklist *pmc;

net/ipv4/igmp.c

2603

for_each_pmc_rtnl(inet, pmc) {

net/ipv4/igmp.c

2604

if (pmc->multi.imr_multiaddr.s_addr == msf->imsf_multiaddr &&

net/ipv4/igmp.c

2605

pmc->multi.imr_ifindex == imr.imr_ifindex)

net/ipv4/igmp.c

2608

if (!pmc) { /* must have a prior join */

net/ipv4/igmp.c

2636

psl = rtnl_dereference(pmc->sflist);

net/ipv4/igmp.c

2638

(void) ip_mc_del_src(in_dev, &msf->imsf_multiaddr, pmc->sfmode,

net/ipv4/igmp.c

2644

(void) ip_mc_del_src(in_dev, &msf->imsf_multiaddr, pmc->sfmode,

net/ipv4/igmp.c

2647

rcu_assign_pointer(pmc->sflist, newpsl);

net/ipv4/igmp.c

2650

pmc->sfmode = msf->imsf_fmode;

net/ipv4/igmp.c

2663

struct ip_mc_socklist *pmc;

net/ipv4/igmp.c

2685

for_each_pmc_rtnl(inet, pmc) {

net/ipv4/igmp.c

2686

if (pmc->multi.imr_multiaddr.s_addr == msf->imsf_multiaddr &&

net/ipv4/igmp.c

2687

pmc->multi.imr_ifindex == imr.imr_ifindex)

net/ipv4/igmp.c

2690

if (!pmc) /* must have a prior join */

net/ipv4/igmp.c

2692

msf->imsf_fmode = pmc->sfmode;

net/ipv4/igmp.c

2693

psl = rtnl_dereference(pmc->sflist);

net/ipv4/igmp.c

2723

struct ip_mc_socklist *pmc;

net/ipv4/igmp.c

2736

for_each_pmc_rtnl(inet, pmc) {

net/ipv4/igmp.c

2737

if (pmc->multi.imr_multiaddr.s_addr == addr &&

net/ipv4/igmp.c

2738

pmc->multi.imr_ifindex == gsf->gf_interface)

net/ipv4/igmp.c

2741

if (!pmc) /* must have a prior join */

net/ipv4/igmp.c

2743

gsf->gf_fmode = pmc->sfmode;

net/ipv4/igmp.c

2744

psl = rtnl_dereference(pmc->sflist);

net/ipv4/igmp.c

2770

struct ip_mc_socklist *pmc;

net/ipv4/igmp.c

2780

for_each_pmc_rcu(inet, pmc) {

net/ipv4/igmp.c

2781

if (pmc->multi.imr_multiaddr.s_addr == loc_addr &&

net/ipv4/igmp.c

2782

(pmc->multi.imr_ifindex == dif ||

net/ipv4/igmp.c

2783

(sdif && pmc->multi.imr_ifindex == sdif)))

net/ipv4/igmp.c

2787

if (!pmc)

net/ipv4/igmp.c

2789

psl = rcu_dereference(pmc->sflist);

net/ipv4/igmp.c

2790

ret = (pmc->sfmode == MCAST_EXCLUDE);

net/ipv4/igmp.c

2799

if (pmc->sfmode == MCAST_INCLUDE && i >= psl->sl_count)

net/ipv4/igmp.c

2801

if (pmc->sfmode == MCAST_EXCLUDE && i < psl->sl_count)

net/ipv4/igmp.c

302

static int is_in(struct ip_mc_list *pmc, struct ip_sf_list *psf, int type,

net/ipv4/igmp.c

310

if (!(pmc->gsquery && !psf->sf_gsresp)) {

net/ipv4/igmp.c

311

if (pmc->sfmode == MCAST_INCLUDE)

net/ipv4/igmp.c

318

return pmc->sfcount[MCAST_EXCLUDE] ==

net/ipv4/igmp.c

329

if (pmc->sfcount[MCAST_EXCLUDE] == 0 ||

net/ipv4/igmp.c

332

return pmc->sfcount[MCAST_EXCLUDE] ==

net/ipv4/igmp.c

337

return (pmc->sfmode == MCAST_INCLUDE) ^ sdeleted;

net/ipv4/igmp.c

339

if (pmc->sfmode == MCAST_INCLUDE)

net/ipv4/igmp.c

347

igmp_scount(struct ip_mc_list *pmc, int type, int gdeleted, int sdeleted)

net/ipv4/igmp.c

352

for (psf = pmc->sources; psf; psf = psf->sf_next) {

net/ipv4/igmp.c

353

if (!is_in(pmc, psf, type, gdeleted, sdeleted))

net/ipv4/igmp.c

460

static int grec_size(struct ip_mc_list *pmc, int type, int gdel, int sdel)

net/ipv4/igmp.c

462

return sizeof(struct igmpv3_grec) + 4*igmp_scount(pmc, type, gdel, sdel);

net/ipv4/igmp.c

465

static struct sk_buff *add_grhead(struct sk_buff *skb, struct ip_mc_list *pmc,

net/ipv4/igmp.c

468

struct net_device *dev = pmc->interface->dev;

net/ipv4/igmp.c

481

pgr->grec_mca = pmc->multiaddr;

net/ipv4/igmp.c

490

static struct sk_buff *add_grec(struct sk_buff *skb, struct ip_mc_list *pmc,

net/ipv4/igmp.c

493

struct net_device *dev = pmc->interface->dev;

net/ipv4/igmp.c

501

if (pmc->multiaddr == IGMP_ALL_HOSTS)

net/ipv4/igmp.c

503

if (ipv4_is_local_multicast(pmc->multiaddr) &&

net/ipv4/igmp.c

518

psf_list = sdeleted ? &pmc->tomb : &pmc->sources;

net/ipv4/igmp.c

528

AVAILABLE(skb) < grec_size(pmc, type, gdeleted, sdeleted)) {

net/ipv4/igmp.c

541

if (!is_in(pmc, psf, type, gdeleted, sdeleted)) {

net/ipv4/igmp.c

549

if (((gdeleted && pmc->sfmode == MCAST_EXCLUDE) ||

net/ipv4/igmp.c

550

(!gdeleted && pmc->crcount)) &&

net/ipv4/igmp.c

572

skb = add_grhead(skb, pmc, type, &pgr, mtu);

net/ipv4/igmp.c

601

if (pmc->crcount || isquery) {

net/ipv4/igmp.c

607

skb = add_grhead(skb, pmc, type, &pgr, mtu);

net/ipv4/igmp.c

614

pmc->gsquery = 0; /* clear query state on report */

net/ipv4/igmp.c

618

static int igmpv3_send_report(struct in_device *in_dev, struct ip_mc_list *pmc)

net/ipv4/igmp.c

624

if (!pmc) {

net/ipv4/igmp.c

626

for_each_pmc_rcu(in_dev, pmc) {

net/ipv4/igmp.c

627

if (pmc->multiaddr == IGMP_ALL_HOSTS)

net/ipv4/igmp.c

629

if (ipv4_is_local_multicast(pmc->multiaddr) &&

net/ipv4/igmp.c

632

spin_lock_bh(&pmc->lock);

net/ipv4/igmp.c

633

if (pmc->sfcount[MCAST_EXCLUDE])

net/ipv4/igmp.c

637

skb = add_grec(skb, pmc, type, 0, 0);

net/ipv4/igmp.c

638

spin_unlock_bh(&pmc->lock);

net/ipv4/igmp.c

642

spin_lock_bh(&pmc->lock);

net/ipv4/igmp.c

643

if (pmc->sfcount[MCAST_EXCLUDE])

net/ipv4/igmp.c

647

skb = add_grec(skb, pmc, type, 0, 0);

net/ipv4/igmp.c

648

spin_unlock_bh(&pmc->lock);

net/ipv4/igmp.c

676

static void kfree_pmc(struct ip_mc_list *pmc)

net/ipv4/igmp.c

678

ip_sf_list_clear_all(pmc->sources);

net/ipv4/igmp.c

679

ip_sf_list_clear_all(pmc->tomb);

net/ipv4/igmp.c

680

kfree(pmc);

net/ipv4/igmp.c

685

struct ip_mc_list *pmc, *pmc_prev, *pmc_next;

net/ipv4/igmp.c

694

for (pmc = in_dev->mc_tomb; pmc; pmc = pmc_next) {

net/ipv4/igmp.c

695

pmc_next = pmc->next;

net/ipv4/igmp.c

696

if (pmc->sfmode == MCAST_INCLUDE) {

net/ipv4/igmp.c

699

skb = add_grec(skb, pmc, type, 1, 0);

net/ipv4/igmp.c

700

skb = add_grec(skb, pmc, dtype, 1, 1);

net/ipv4/igmp.c

702

if (pmc->crcount) {

net/ipv4/igmp.c

703

if (pmc->sfmode == MCAST_EXCLUDE) {

net/ipv4/igmp.c

705

skb = add_grec(skb, pmc, type, 1, 0);

net/ipv4/igmp.c

707

pmc->crcount--;

net/ipv4/igmp.c

708

if (pmc->crcount == 0) {

net/ipv4/igmp.c

709

igmpv3_clear_zeros(&pmc->tomb);

net/ipv4/igmp.c

710

igmpv3_clear_zeros(&pmc->sources);

net/ipv4/igmp.c

713

if (pmc->crcount == 0 && !pmc->tomb && !pmc->sources) {

net/ipv4/igmp.c

718

in_dev_put(pmc->interface);

net/ipv4/igmp.c

719

kfree_pmc(pmc);

net/ipv4/igmp.c

721

pmc_prev = pmc;

net/ipv4/igmp.c

726

for_each_pmc_rcu(in_dev, pmc) {

net/ipv4/igmp.c

727

spin_lock_bh(&pmc->lock);

net/ipv4/igmp.c

728

if (pmc->sfcount[MCAST_EXCLUDE]) {

net/ipv4/igmp.c

735

skb = add_grec(skb, pmc, type, 0, 0);

net/ipv4/igmp.c

736

skb = add_grec(skb, pmc, dtype, 0, 1); /* deleted sources */

net/ipv4/igmp.c

739

if (pmc->crcount) {

net/ipv4/igmp.c

740

if (pmc->sfmode == MCAST_EXCLUDE)

net/ipv4/igmp.c

744

skb = add_grec(skb, pmc, type, 0, 0);

net/ipv4/igmp.c

745

pmc->crcount--;

net/ipv4/igmp.c

747

spin_unlock_bh(&pmc->lock);

net/ipv4/igmp.c

756

static int igmp_send_report(struct in_device *in_dev, struct ip_mc_list *pmc,

net/ipv4/igmp.c

765

__be32 group = pmc ? pmc->multiaddr : 0;

net/ipv4/igmp.c

771

return igmpv3_send_report(in_dev, pmc);

net/ipv4/igmp.c

893

static int igmp_xmarksources(struct ip_mc_list *pmc, int nsrcs, __be32 *srcs)

net/ipv4/igmp.c

899

for (psf = pmc->sources; psf; psf = psf->sf_next) {

net/ipv4/igmp.c

905

pmc->sfcount[MCAST_EXCLUDE] !=

net/ipv4/igmp.c

914

pmc->gsquery = 0;

net/ipv4/igmp.c

920

static int igmp_marksources(struct ip_mc_list *pmc, int nsrcs, __be32 *srcs)

net/ipv4/igmp.c

925

if (pmc->sfmode == MCAST_EXCLUDE)

net/ipv4/igmp.c

926

return igmp_xmarksources(pmc, nsrcs, srcs);

net/ipv4/igmp.c

930

for (psf = pmc->sources; psf; psf = psf->sf_next) {

net/ipv4/igmp.c

941

pmc->gsquery = 0;

net/ipv4/igmp.c

944

pmc->gsquery = 1;

net/ipv6/mcast.c

1180

static bool mld_xmarksources(struct ifmcaddr6 *pmc, int nsrcs,

net/ipv6/mcast.c

1186

mc_assert_locked(pmc->idev);

net/ipv6/mcast.c

1189

for_each_psf_mclock(pmc, psf) {

net/ipv6/mcast.c

1195

pmc->mca_sfcount[MCAST_EXCLUDE] !=

net/ipv6/mcast.c

120

#define for_each_pmc_socklock(np, sk, pmc) \

net/ipv6/mcast.c

1204

WRITE_ONCE(pmc->mca_flags, pmc->mca_flags & ~MAF_GSQUERY);

net/ipv6/mcast.c

121

for (pmc = sock_dereference((np)->ipv6_mc_list, sk); \

net/ipv6/mcast.c

1210

static bool mld_marksources(struct ifmcaddr6 *pmc, int nsrcs,

net/ipv6/mcast.c

1216

mc_assert_locked(pmc->idev);

net/ipv6/mcast.c

1218

if (pmc->mca_sfmode == MCAST_EXCLUDE)

net/ipv6/mcast.c

1219

return mld_xmarksources(pmc, nsrcs, srcs);

net/ipv6/mcast.c

122

pmc; \

net/ipv6/mcast.c

1224

for_each_psf_mclock(pmc, psf) {

net/ipv6/mcast.c

123

pmc = sock_dereference(pmc->next, sk))

net/ipv6/mcast.c

1236

WRITE_ONCE(pmc->mca_flags, pmc->mca_flags & ~MAF_GSQUERY);

net/ipv6/mcast.c

1239

WRITE_ONCE(pmc->mca_flags, pmc->mca_flags | MAF_GSQUERY);

net/ipv6/mcast.c

125

#define for_each_pmc_rcu(np, pmc) \

net/ipv6/mcast.c

126

for (pmc = rcu_dereference((np)->ipv6_mc_list); \

net/ipv6/mcast.c

127

pmc; \

net/ipv6/mcast.c

128

pmc = rcu_dereference(pmc->next))

net/ipv6/mcast.c

1689

static bool is_in(struct ifmcaddr6 *pmc, struct ip6_sf_list *psf, int type,

net/ipv6/mcast.c

1697

if (!((pmc->mca_flags & MAF_GSQUERY) && !psf->sf_gsresp)) {

net/ipv6/mcast.c

1698

if (pmc->mca_sfmode == MCAST_INCLUDE)

net/ipv6/mcast.c

1705

return pmc->mca_sfcount[MCAST_EXCLUDE] ==

net/ipv6/mcast.c

1716

if (pmc->mca_sfcount[MCAST_EXCLUDE] == 0 ||

net/ipv6/mcast.c

1719

return pmc->mca_sfcount[MCAST_EXCLUDE] ==

net/ipv6/mcast.c

1724

return (pmc->mca_sfmode == MCAST_INCLUDE) ^ sdeleted;

net/ipv6/mcast.c

1726

if (pmc->mca_sfmode == MCAST_INCLUDE)

net/ipv6/mcast.c

1734

mld_scount(struct ifmcaddr6 *pmc, int type, int gdeleted, int sdeleted)

net/ipv6/mcast.c

1739

for_each_psf_mclock(pmc, psf) {

net/ipv6/mcast.c

1740

if (!is_in(pmc, psf, type, gdeleted, sdeleted))

net/ipv6/mcast.c

1888

static int grec_size(struct ifmcaddr6 *pmc, int type, int gdel, int sdel)

net/ipv6/mcast.c

1890

return sizeof(struct mld2_grec) + 16 * mld_scount(pmc,type,gdel,sdel);

net/ipv6/mcast.c

1893

static struct sk_buff *add_grhead(struct sk_buff *skb, struct ifmcaddr6 *pmc,

net/ipv6/mcast.c

1900

skb = mld_newpack(pmc->idev, mtu);

net/ipv6/mcast.c

1908

pgr->grec_mca = pmc->mca_addr; /* structure copy */

net/ipv6/mcast.c

1917

static struct sk_buff *add_grec(struct sk_buff *skb, struct ifmcaddr6 *pmc,

net/ipv6/mcast.c

1924

struct inet6_dev *idev = pmc->idev;

net/ipv6/mcast.c

1932

if (pmc->mca_flags & MAF_NOREPORT)

net/ipv6/mcast.c

1946

psf_list = sdeleted ? &pmc->mca_tomb : &pmc->mca_sources;

net/ipv6/mcast.c

1956

AVAILABLE(skb) < grec_size(pmc, type, gdeleted, sdeleted)) {

net/ipv6/mcast.c

1971

if (!is_in(pmc, psf, type, gdeleted, sdeleted) && !crsend) {

net/ipv6/mcast.c

1979

if (((gdeleted && pmc->mca_sfmode == MCAST_EXCLUDE) ||

net/ipv6/mcast.c

1980

(!gdeleted && pmc->mca_crcount)) &&

net/ipv6/mcast.c

2002

skb = add_grhead(skb, pmc, type, &pgr, mtu);

net/ipv6/mcast.c

2033

if (pmc->mca_crcount || isquery || crsend) {

net/ipv6/mcast.c

2039

skb = add_grhead(skb, pmc, type, &pgr, mtu);

net/ipv6/mcast.c

2047

WRITE_ONCE(pmc->mca_flags, pmc->mca_flags & ~MAF_GSQUERY);

net/ipv6/mcast.c

2052

static void mld_send_report(struct inet6_dev *idev, struct ifmcaddr6 *pmc)

net/ipv6/mcast.c

2059

if (!pmc) {

net/ipv6/mcast.c

2060

for_each_mc_mclock(idev, pmc) {

net/ipv6/mcast.c

2061

if (pmc->mca_flags & MAF_NOREPORT)

net/ipv6/mcast.c

2063

if (pmc->mca_sfcount[MCAST_EXCLUDE])

net/ipv6/mcast.c

2067

skb = add_grec(skb, pmc, type, 0, 0, 0);

net/ipv6/mcast.c

2070

if (pmc->mca_sfcount[MCAST_EXCLUDE])

net/ipv6/mcast.c

2074

skb = add_grec(skb, pmc, type, 0, 0, 0);

net/ipv6/mcast.c

2106

struct ifmcaddr6 *pmc, *pmc_prev, *pmc_next;

net/ipv6/mcast.c

2112

for (pmc = mc_dereference(idev->mc_tomb, idev);

net/ipv6/mcast.c

2113

pmc;

net/ipv6/mcast.c

2114

pmc = pmc_next) {

net/ipv6/mcast.c

2115

pmc_next = mc_dereference(pmc->next, idev);

net/ipv6/mcast.c

2116

if (pmc->mca_sfmode == MCAST_INCLUDE) {

net/ipv6/mcast.c

2119

skb = add_grec(skb, pmc, type, 1, 0, 0);

net/ipv6/mcast.c

2120

skb = add_grec(skb, pmc, dtype, 1, 1, 0);

net/ipv6/mcast.c

2122

if (pmc->mca_crcount) {

net/ipv6/mcast.c

2123

if (pmc->mca_sfmode == MCAST_EXCLUDE) {

net/ipv6/mcast.c

2125

skb = add_grec(skb, pmc, type, 1, 0, 0);

net/ipv6/mcast.c

2127

pmc->mca_crcount--;

net/ipv6/mcast.c

2128

if (pmc->mca_crcount == 0) {

net/ipv6/mcast.c

2129

mld_clear_zeros(&pmc->mca_tomb, idev);

net/ipv6/mcast.c

2130

mld_clear_zeros(&pmc->mca_sources, idev);

net/ipv6/mcast.c

2133

if (pmc->mca_crcount == 0 &&

net/ipv6/mcast.c

2134

!rcu_access_pointer(pmc->mca_tomb) &&

net/ipv6/mcast.c

2135

!rcu_access_pointer(pmc->mca_sources)) {

net/ipv6/mcast.c

2140

in6_dev_put(pmc->idev);

net/ipv6/mcast.c

2141

kfree_rcu(pmc, rcu);

net/ipv6/mcast.c

2143

pmc_prev = pmc;

net/ipv6/mcast.c

2147

for_each_mc_mclock(idev, pmc) {

net/ipv6/mcast.c

2148

if (pmc->mca_sfcount[MCAST_EXCLUDE]) {

net/ipv6/mcast.c

2155

skb = add_grec(skb, pmc, type, 0, 0, 0);

net/ipv6/mcast.c

2156

skb = add_grec(skb, pmc, dtype, 0, 1, 0); /* deleted sources */

net/ipv6/mcast.c

2159

if (pmc->mca_crcount) {

net/ipv6/mcast.c

2160

if (pmc->mca_sfmode == MCAST_EXCLUDE)

net/ipv6/mcast.c

2164

skb = add_grec(skb, pmc, type, 0, 0, 0);

net/ipv6/mcast.c

2165

pmc->mca_crcount--;

net/ipv6/mcast.c

2269

struct ifmcaddr6 *pmc;

net/ipv6/mcast.c

2279

for_each_mc_mclock(idev, pmc) {

net/ipv6/mcast.c

2280

if (pmc->mca_sfcount[MCAST_EXCLUDE])

net/ipv6/mcast.c

2284

skb = add_grec(skb, pmc, type, 0, 0, 1);

net/ipv6/mcast.c

2321

static int ip6_mc_del1_src(struct ifmcaddr6 *pmc, int sfmode,

net/ipv6/mcast.c

2327

mc_assert_locked(pmc->idev);

net/ipv6/mcast.c

2330

for_each_psf_mclock(pmc, psf) {

net/ipv6/mcast.c

2341

struct inet6_dev *idev = pmc->idev;

net/ipv6/mcast.c

2348

rcu_assign_pointer(pmc->mca_sources,

net/ipv6/mcast.c

2351

if (psf->sf_oldin && !(pmc->mca_flags & MAF_NOREPORT) &&

net/ipv6/mcast.c

2355

mc_dereference(pmc->mca_tomb, idev));

net/ipv6/mcast.c

2356

rcu_assign_pointer(pmc->mca_tomb, psf);

net/ipv6/mcast.c

2369

struct ifmcaddr6 *pmc;

net/ipv6/mcast.c

2378

for_each_mc_mclock(idev, pmc) {

net/ipv6/mcast.c

2379

if (ipv6_addr_equal(pmca, &pmc->mca_addr))

net/ipv6/mcast.c

2382

if (!pmc)

net/ipv6/mcast.c

2385

sf_markstate(pmc);

net/ipv6/mcast.c

2387

if (!pmc->mca_sfcount[sfmode])

net/ipv6/mcast.c

2390

pmc->mca_sfcount[sfmode]--;

net/ipv6/mcast.c

2394

int rv = ip6_mc_del1_src(pmc, sfmode, &psfsrc[i]);

net/ipv6/mcast.c

2400

if (pmc->mca_sfmode == MCAST_EXCLUDE &&

net/ipv6/mcast.c

2401

pmc->mca_sfcount[MCAST_EXCLUDE] == 0 &&

net/ipv6/mcast.c

2402

pmc->mca_sfcount[MCAST_INCLUDE]) {

net/ipv6/mcast.c

2406

pmc->mca_sfmode = MCAST_INCLUDE;

net/ipv6/mcast.c

2407

pmc->mca_crcount = idev->mc_qrv;

net/ipv6/mcast.c

2408

idev->mc_ifc_count = pmc->mca_crcount;

net/ipv6/mcast.c

2409

for_each_psf_mclock(pmc, psf)

net/ipv6/mcast.c

2411

mld_ifc_event(pmc->idev);

net/ipv6/mcast.c

2412

} else if (sf_setstate(pmc) || changerec) {

net/ipv6/mcast.c

2413

mld_ifc_event(pmc->idev);

net/ipv6/mcast.c

2420

static int ip6_mc_add1_src(struct ifmcaddr6 *pmc, int sfmode,

net/ipv6/mcast.c

2425

mc_assert_locked(pmc->idev);

net/ipv6/mcast.c

2428

for_each_psf_mclock(pmc, psf) {

net/ipv6/mcast.c

2442

rcu_assign_pointer(pmc->mca_sources, psf);

net/ipv6/mcast.c

2449

static void sf_markstate(struct ifmcaddr6 *pmc)

net/ipv6/mcast.c

2451

int mca_xcount = pmc->mca_sfcount[MCAST_EXCLUDE];

net/ipv6/mcast.c

2454

mc_assert_locked(pmc->idev);

net/ipv6/mcast.c

2456

for_each_psf_mclock(pmc, psf) {

net/ipv6/mcast.c

2457

if (pmc->mca_sfcount[MCAST_EXCLUDE]) {

net/ipv6/mcast.c

2467

static int sf_setstate(struct ifmcaddr6 *pmc)

net/ipv6/mcast.c

2469

int mca_xcount = pmc->mca_sfcount[MCAST_EXCLUDE];

net/ipv6/mcast.c

2471

int qrv = pmc->idev->mc_qrv;

net/ipv6/mcast.c

2474

mc_assert_locked(pmc->idev);

net/ipv6/mcast.c

2477

for_each_psf_mclock(pmc, psf) {

net/ipv6/mcast.c

2478

if (pmc->mca_sfcount[MCAST_EXCLUDE]) {

net/ipv6/mcast.c

2487

for_each_psf_tomb(pmc, dpsf) {

net/ipv6/mcast.c

2497

pmc->idev));

net/ipv6/mcast.c

2499

rcu_assign_pointer(pmc->mca_tomb,

net/ipv6/mcast.c

2501

pmc->idev));

net/ipv6/mcast.c

2514

for_each_psf_tomb(pmc, dpsf)

net/ipv6/mcast.c

2524

mc_dereference(pmc->mca_tomb, pmc->idev));

net/ipv6/mcast.c

2525

rcu_assign_pointer(pmc->mca_tomb, dpsf);

net/ipv6/mcast.c

2539

struct ifmcaddr6 *pmc;

net/ipv6/mcast.c

2548

for_each_mc_mclock(idev, pmc) {

net/ipv6/mcast.c

2549

if (ipv6_addr_equal(pmca, &pmc->mca_addr))

net/ipv6/mcast.c

2552

if (!pmc)

net/ipv6/mcast.c

2555

sf_markstate(pmc);

net/ipv6/mcast.c

2556

isexclude = pmc->mca_sfmode == MCAST_EXCLUDE;

net/ipv6/mcast.c

2558

WRITE_ONCE(pmc->mca_sfcount[sfmode],

net/ipv6/mcast.c

2559

pmc->mca_sfcount[sfmode] + 1);

net/ipv6/mcast.c

2562

err = ip6_mc_add1_src(pmc, sfmode, &psfsrc[i]);

net/ipv6/mcast.c

2570

WRITE_ONCE(pmc->mca_sfcount[sfmode],

net/ipv6/mcast.c

2571

pmc->mca_sfcount[sfmode] - 1);

net/ipv6/mcast.c

2573

ip6_mc_del1_src(pmc, sfmode, &psfsrc[j]);

net/ipv6/mcast.c

2574

} else if (isexclude != (pmc->mca_sfcount[MCAST_EXCLUDE] != 0)) {

net/ipv6/mcast.c

2578

if (pmc->mca_sfcount[MCAST_EXCLUDE])

net/ipv6/mcast.c

2579

pmc->mca_sfmode = MCAST_EXCLUDE;

net/ipv6/mcast.c

2580

else if (pmc->mca_sfcount[MCAST_INCLUDE])

net/ipv6/mcast.c

2581

pmc->mca_sfmode = MCAST_INCLUDE;

net/ipv6/mcast.c

2584

pmc->mca_crcount = idev->mc_qrv;

net/ipv6/mcast.c

2585

idev->mc_ifc_count = pmc->mca_crcount;

net/ipv6/mcast.c

2586

for_each_psf_mclock(pmc, psf)

net/ipv6/mcast.c

2589

} else if (sf_setstate(pmc)) {

net/ipv6/mcast.c

2595

static void ip6_mc_clear_src(struct ifmcaddr6 *pmc)

net/ipv6/mcast.c

2599

mc_assert_locked(pmc->idev);

net/ipv6/mcast.c

2601

for (psf = mc_dereference(pmc->mca_tomb, pmc->idev);

net/ipv6/mcast.c

2604

nextpsf = mc_dereference(psf->sf_next, pmc->idev);

net/ipv6/mcast.c

2607

RCU_INIT_POINTER(pmc->mca_tomb, NULL);

net/ipv6/mcast.c

2608

for (psf = mc_dereference(pmc->mca_sources, pmc->idev);

net/ipv6/mcast.c

2611

nextpsf = mc_dereference(psf->sf_next, pmc->idev);

net/ipv6/mcast.c

2614

RCU_INIT_POINTER(pmc->mca_sources, NULL);

net/ipv6/mcast.c

2615

pmc->mca_sfmode = MCAST_EXCLUDE;

net/ipv6/mcast.c

2616

pmc->mca_sfcount[MCAST_INCLUDE] = 0;

net/ipv6/mcast.c

2618

WRITE_ONCE(pmc->mca_sfcount[MCAST_EXCLUDE], 1);

net/ipv6/mcast.c

2878

struct ifmcaddr6 *pmc;

net/ipv6/mcast.c

2882

for_each_mc_mclock(idev, pmc)

net/ipv6/mcast.c

2883

igmp6_join_group(pmc);

net/ipv6/mcast.c

359

struct ipv6_mc_socklist *pmc;

net/ipv6/mcast.c

385

for_each_pmc_socklock(inet6, sk, pmc) {

net/ipv6/mcast.c

386

if (pgsr->gsr_interface && pmc->ifindex != pgsr->gsr_interface)

net/ipv6/mcast.c

388

if (ipv6_addr_equal(&pmc->addr, group))

net/ipv6/mcast.c

391

if (!pmc) { /* must have a prior join */

net/ipv6/mcast.c

396

if (rcu_access_pointer(pmc->sflist)) {

net/ipv6/mcast.c

397

if (pmc->sfmode != omode) {

net/ipv6/mcast.c

401

} else if (pmc->sfmode != omode) {

net/ipv6/mcast.c

404

ip6_mc_del_src(idev, group, pmc->sfmode, 0, NULL, 0);

net/ipv6/mcast.c

405

pmc->sfmode = omode;

net/ipv6/mcast.c

408

psl = sock_dereference(pmc->sflist, sk);

net/ipv6/mcast.c

462

rcu_assign_pointer(pmc->sflist, newpsl);

net/ipv6/mcast.c

494

struct ipv6_mc_socklist *pmc;

net/ipv6/mcast.c

525

for_each_pmc_socklock(inet6, sk, pmc) {

net/ipv6/mcast.c

526

if (pmc->ifindex != gsf->gf_interface)

net/ipv6/mcast.c

528

if (ipv6_addr_equal(&pmc->addr, group))

net/ipv6/mcast.c

531

if (!pmc) { /* must have a prior join */

net/ipv6/mcast.c

563

psl = sock_dereference(pmc->sflist, sk);

net/ipv6/mcast.c

565

ip6_mc_del_src(idev, group, pmc->sfmode,

net/ipv6/mcast.c

570

ip6_mc_del_src(idev, group, pmc->sfmode, 0, NULL, 0);

net/ipv6/mcast.c

573

rcu_assign_pointer(pmc->sflist, newpsl);

net/ipv6/mcast.c

575

pmc->sfmode = gsf->gf_fmode;

net/ipv6/mcast.c

590

struct ipv6_mc_socklist *pmc;

net/ipv6/mcast.c

600

for_each_pmc_socklock(inet6, sk, pmc) {

net/ipv6/mcast.c

601

if (pmc->ifindex != gsf->gf_interface)

net/ipv6/mcast.c

603

if (ipv6_addr_equal(group, &pmc->addr))

net/ipv6/mcast.c

606

if (!pmc) /* must have a prior join */

net/ipv6/mcast.c

609

gsf->gf_fmode = pmc->sfmode;

net/ipv6/mcast.c

610

psl = sock_dereference(pmc->sflist, sk);

net/ipv6/mcast.c

733

struct ifmcaddr6 *pmc;

net/ipv6/mcast.c

743

pmc = kzalloc_obj(*pmc);

net/ipv6/mcast.c

744

if (!pmc)

net/ipv6/mcast.c

747

pmc->idev = im->idev;

net/ipv6/mcast.c

749

pmc->mca_addr = im->mca_addr;

net/ipv6/mcast.c

750

pmc->mca_crcount = idev->mc_qrv;

net/ipv6/mcast.c

751

pmc->mca_sfmode = im->mca_sfmode;

net/ipv6/mcast.c

752

if (pmc->mca_sfmode == MCAST_INCLUDE) {

net/ipv6/mcast.c

755

rcu_assign_pointer(pmc->mca_tomb,

net/ipv6/mcast.c

757

rcu_assign_pointer(pmc->mca_sources,

net/ipv6/mcast.c

762

for_each_psf_mclock(pmc, psf)

net/ipv6/mcast.c

763

psf->sf_crcount = pmc->mca_crcount;

net/ipv6/mcast.c

766

rcu_assign_pointer(pmc->next, idev->mc_tomb);

net/ipv6/mcast.c

767

rcu_assign_pointer(idev->mc_tomb, pmc);

net/ipv6/mcast.c

774

struct ifmcaddr6 *pmc, *pmc_prev;

net/ipv6/mcast.c

779

for_each_mc_tomb(idev, pmc) {

net/ipv6/mcast.c

780

if (ipv6_addr_equal(&pmc->mca_addr, pmca))

net/ipv6/mcast.c

782

pmc_prev = pmc;

net/ipv6/mcast.c

784

if (!pmc)

net/ipv6/mcast.c

787

rcu_assign_pointer(pmc_prev->next, pmc->next);

net/ipv6/mcast.c

789

rcu_assign_pointer(idev->mc_tomb, pmc->next);

net/ipv6/mcast.c

791

im->idev = pmc->idev;

net/ipv6/mcast.c

794

mc_dereference(pmc->mca_tomb, pmc->idev),

net/ipv6/mcast.c

796

rcu_assign_pointer(pmc->mca_tomb, tomb);

net/ipv6/mcast.c

799

mc_dereference(pmc->mca_sources, pmc->idev),

net/ipv6/mcast.c

801

rcu_assign_pointer(pmc->mca_sources, sources);

net/ipv6/mcast.c

807

ip6_mc_clear_src(pmc);

net/ipv6/mcast.c

808

in6_dev_put(pmc->idev);

net/ipv6/mcast.c

809

kfree_rcu(pmc, rcu);

net/ipv6/mcast.c

814

struct ifmcaddr6 *pmc, *nextpmc;

net/ipv6/mcast.c

818

pmc = mc_dereference(idev->mc_tomb, idev);

net/ipv6/mcast.c

82

static int sf_setstate(struct ifmcaddr6 *pmc);

net/ipv6/mcast.c

821

for (; pmc; pmc = nextpmc) {

net/ipv6/mcast.c

822

nextpmc = mc_dereference(pmc->next, idev);

net/ipv6/mcast.c

823

ip6_mc_clear_src(pmc);

net/ipv6/mcast.c

824

in6_dev_put(pmc->idev);

net/ipv6/mcast.c

825

kfree_rcu(pmc, rcu);

net/ipv6/mcast.c

829

for_each_mc_mclock(idev, pmc) {

net/ipv6/mcast.c

83

static void sf_markstate(struct ifmcaddr6 *pmc);

net/ipv6/mcast.c

832

psf = mc_dereference(pmc->mca_tomb, idev);

net/ipv6/mcast.c

833

RCU_INIT_POINTER(pmc->mca_tomb, NULL);

net/ipv6/mcast.c

84

static void ip6_mc_clear_src(struct ifmcaddr6 *pmc);

tools/testing/selftests/kvm/arm64/vpmu_counter_access.c

357

int i, pmc;

tools/testing/selftests/kvm/arm64/vpmu_counter_access.c

385

for (pmc = 0; pmc < pmcr_n; pmc++)

tools/testing/selftests/kvm/arm64/vpmu_counter_access.c

386

test_access_pmc_regs(&pmc_accessors[i], pmc);

tools/testing/selftests/kvm/arm64/vpmu_counter_access.c

394

for (pmc = pmcr_n; pmc < ARMV8_PMU_MAX_GENERAL_COUNTERS; pmc++)

tools/testing/selftests/kvm/arm64/vpmu_counter_access.c

395

test_access_invalid_pmc_regs(&pmc_accessors[i], pmc);

tools/testing/selftests/kvm/x86/pmu_counters_test.c

156

static void guest_assert_event_count(u8 idx, u32 pmc, u32 pmc_msr)

tools/testing/selftests/kvm/x86/pmu_counters_test.c

160

count = _rdpmc(pmc);

tools/testing/selftests/kvm/x86/pmu_counters_test.c

203

GUEST_ASSERT_EQ(_rdpmc(pmc), count);

tools/testing/selftests/kvm/x86/pmu_counters_test.c

206

GUEST_ASSERT_EQ(_rdpmc(pmc), 0xdead);

tools/testing/selftests/kvm/x86/pmu_counters_test.c

258

static void __guest_test_arch_event(u8 idx, u32 pmc, u32 pmc_msr,

tools/testing/selftests/kvm/x86/pmu_counters_test.c

261

GUEST_TEST_EVENT(idx, pmc, pmc_msr, ctrl_msr, ctrl_msr_value, "");

tools/testing/selftests/kvm/x86/pmu_counters_test.c

264

GUEST_TEST_EVENT(idx, pmc, pmc_msr, ctrl_msr, ctrl_msr_value, KVM_FEP);

tools/testing/selftests/powerpc/pmu/ebb/ebb.c

252

int count_pmc(int pmc, uint32_t sample_period)

tools/testing/selftests/powerpc/pmu/ebb/ebb.c

260

val = read_pmc(pmc);

tools/testing/selftests/powerpc/pmu/ebb/ebb.c

264

ebb_state.stats.pmc_count[PMC_INDEX(pmc)] += val - start_value;

tools/testing/selftests/powerpc/pmu/ebb/ebb.c

266

trace_log_reg(ebb_state.trace, SPRN_PMC1 + pmc - 1, val);

tools/testing/selftests/powerpc/pmu/ebb/ebb.c

269

write_pmc(pmc, start_value);

tools/testing/selftests/powerpc/pmu/ebb/ebb.c

440

void write_pmc(int pmc, u64 value)

tools/testing/selftests/powerpc/pmu/ebb/ebb.c

442

switch (pmc) {

tools/testing/selftests/powerpc/pmu/ebb/ebb.c

452

u64 read_pmc(int pmc)

tools/testing/selftests/powerpc/pmu/ebb/ebb.c

454

switch (pmc) {

tools/testing/selftests/powerpc/pmu/ebb/ebb.c

71

bool ebb_check_count(int pmc, u64 sample_period, int fudge)

tools/testing/selftests/powerpc/pmu/ebb/ebb.c

75

count = ebb_state.stats.pmc_count[PMC_INDEX(pmc)];

tools/testing/selftests/powerpc/pmu/ebb/ebb.c

81

pmc, count, lower, lower - count);

tools/testing/selftests/powerpc/pmu/ebb/ebb.c

89

pmc, count, upper, count - upper);

tools/testing/selftests/powerpc/pmu/ebb/ebb.c

94

pmc, count, lower, upper, count - lower, upper - count);

tools/testing/selftests/powerpc/pmu/ebb/ebb.h

14

#define PMC_INDEX(pmc) ((pmc)-1)

tools/testing/selftests/powerpc/pmu/ebb/ebb.h

41

static inline void ebb_enable_pmc_counting(int pmc)

tools/testing/selftests/powerpc/pmu/ebb/ebb.h

43

ebb_state.pmc_enable[PMC_INDEX(pmc)] = true;

tools/testing/selftests/powerpc/pmu/ebb/ebb.h

46

bool ebb_check_count(int pmc, u64 sample_period, int fudge);

tools/testing/selftests/powerpc/pmu/ebb/ebb.h

58

int count_pmc(int pmc, uint32_t sample_period);

tools/testing/selftests/powerpc/pmu/ebb/ebb.h

63

void write_pmc(int pmc, u64 value);

tools/testing/selftests/powerpc/pmu/ebb/ebb.h

64

u64 read_pmc(int pmc);

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

100

static inline int get_mmcr1_pmcxsel(u64 mmcr1, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

102

return ((mmcr1 >> ((24 - (((pmc) - 1) * 8))) & 0xff));

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

105

static inline int get_mmcr1_unit(u64 mmcr1, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

107

return ((mmcr1 >> ((60 - (4 * ((pmc) - 1))))) & 0xf);

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

110

static inline int get_mmcr1_comb(u64 mmcr1, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

112

return ((mmcr1 >> (38 - ((pmc - 1) * 2))) & 0x3);

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

115

static inline int get_mmcr1_cache(u64 mmcr1, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

120

static inline int get_mmcr1_rsq(u64 mmcr1, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

125

static inline int get_mmcr2_fcs(u64 mmcr2, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

127

return ((mmcr2 & (1ull << (63 - (((pmc) - 1) * 9)))) >> (63 - (((pmc) - 1) * 9)));

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

130

static inline int get_mmcr2_fcp(u64 mmcr2, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

132

return ((mmcr2 & (1ull << (62 - (((pmc) - 1) * 9)))) >> (62 - (((pmc) - 1) * 9)));

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

135

static inline int get_mmcr2_fcpc(u64 mmcr2, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

137

return ((mmcr2 & (1ull << (61 - (((pmc) - 1) * 9)))) >> (61 - (((pmc) - 1) * 9)));

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

140

static inline int get_mmcr2_fcm1(u64 mmcr2, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

142

return ((mmcr2 & (1ull << (60 - (((pmc) - 1) * 9)))) >> (60 - (((pmc) - 1) * 9)));

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

145

static inline int get_mmcr2_fcm0(u64 mmcr2, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

147

return ((mmcr2 & (1ull << (59 - (((pmc) - 1) * 9)))) >> (59 - (((pmc) - 1) * 9)));

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

150

static inline int get_mmcr2_fcwait(u64 mmcr2, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

152

return ((mmcr2 & (1ull << (58 - (((pmc) - 1) * 9)))) >> (58 - (((pmc) - 1) * 9)));

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

155

static inline int get_mmcr2_fch(u64 mmcr2, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

157

return ((mmcr2 & (1ull << (57 - (((pmc) - 1) * 9)))) >> (57 - (((pmc) - 1) * 9)));

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

160

static inline int get_mmcr2_fcti(u64 mmcr2, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

162

return ((mmcr2 & (1ull << (56 - (((pmc) - 1) * 9)))) >> (56 - (((pmc) - 1) * 9)));

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

165

static inline int get_mmcr2_fcta(u64 mmcr2, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

167

return ((mmcr2 & (1ull << (55 - (((pmc) - 1) * 9)))) >> (55 - (((pmc) - 1) * 9)));

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

170

static inline int get_mmcr2_l2l3(u64 mmcr2, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

177

static inline int get_mmcr3_src(u64 mmcr3, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

181

return ((mmcr3 >> ((49 - (15 * ((pmc) - 1))))) & 0x7fff);

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

184

static inline int get_mmcra_thd_cmp(u64 mmcra, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

191

static inline int get_mmcra_sm(u64 mmcra, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

196

static inline u64 get_mmcra_bhrb_disable(u64 mmcra, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

203

static inline int get_mmcra_ifm(u64 mmcra, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

208

static inline int get_mmcra_thd_sel(u64 mmcra, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

213

static inline int get_mmcra_thd_start(u64 mmcra, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

218

static inline int get_mmcra_thd_stop(u64 mmcra, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

223

static inline int get_mmcra_rand_samp_elig(u64 mmcra, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

228

static inline int get_mmcra_sample_mode(u64 mmcra, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

233

static inline int get_mmcra_marked(u64 mmcra, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

65

static inline int get_mmcr0_fc56(u64 mmcr0, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

70

static inline int get_mmcr0_pmccext(u64 mmcr0, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

75

static inline int get_mmcr0_pmao(u64 mmcr0, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

80

static inline int get_mmcr0_cc56run(u64 mmcr0, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

85

static inline int get_mmcr0_pmcjce(u64 mmcr0, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

90

static inline int get_mmcr0_pmc1ce(u64 mmcr0, int pmc)

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.h

95

static inline int get_mmcr0_pmae(u64 mmcr0, int pmc)

tools/testing/vma/include/stubs.h

47

static inline unsigned long move_page_tables(struct pagetable_move_control *pmc)