arch/arm/include/asm/hardware/ssp.h

20

void ssp_save_state(struct ssp_state *ssp);

arch/arm/include/asm/hardware/ssp.h

21

void ssp_restore_state(struct ssp_state *ssp);

arch/arm/mach-sa1100/ssp.c

158

void ssp_save_state(struct ssp_state *ssp)

arch/arm/mach-sa1100/ssp.c

160

ssp->cr0 = Ser4SSCR0;

arch/arm/mach-sa1100/ssp.c

161

ssp->cr1 = Ser4SSCR1;

arch/arm/mach-sa1100/ssp.c

172

void ssp_restore_state(struct ssp_state *ssp)

arch/arm/mach-sa1100/ssp.c

176

Ser4SSCR0 = ssp->cr0 & ~SSCR0_SSE;

arch/arm/mach-sa1100/ssp.c

177

Ser4SSCR1 = ssp->cr1;

arch/arm/mach-sa1100/ssp.c

178

Ser4SSCR0 = ssp->cr0;

arch/m68k/kernel/traps.c

1139

asmlinkage void set_esp0(unsigned long ssp)

arch/m68k/kernel/traps.c

1141

current->thread.esp0 = ssp;

arch/m68k/kernel/traps.h

10

asmlinkage void set_esp0(unsigned long ssp);

arch/riscv/kernel/process.c

245

unsigned long ssp = 0;

arch/riscv/kernel/process.c

266

ssp = shstk_alloc_thread_stack(p, args);

arch/riscv/kernel/process.c

267

if (IS_ERR_VALUE(ssp))

arch/riscv/kernel/process.c

268

return PTR_ERR((void *)ssp);

arch/riscv/kernel/process.c

276

if (ssp)

arch/riscv/kernel/process.c

277

set_active_shstk(p, ssp);

arch/riscv/kernel/usercfi.c

159

static int create_rstor_token(unsigned long ssp, unsigned long *token_addr)

arch/riscv/kernel/usercfi.c

164

if (!IS_ALIGNED(ssp, SHSTK_ENTRY_SIZE))

arch/riscv/kernel/usercfi.c

168

addr = ssp - SHSTK_ENTRY_SIZE;

arch/riscv/kernel/usercfi.c

170

if (amo_user_shstk((unsigned long __user *)addr, (unsigned long)ssp) == -1)

arch/x86/include/asm/perf_event.h

590

u64 r8, r9, r10, r11, r12, r13, r14, r15, ssp;

arch/x86/include/asm/svm.h

352

u64 ssp;

arch/x86/include/asm/svm.h

417

u64 ssp;

arch/x86/kernel/cet.c

51

unsigned long ssp;

arch/x86/kernel/cet.c

59

rdmsrq(MSR_IA32_PL3_SSP, ssp);

arch/x86/kernel/cet.c

72

regs->ip, regs->sp, ssp, error_code,

arch/x86/kernel/fpu/core.c

629

static int update_fpu_shstk(struct task_struct *dst, unsigned long ssp)

arch/x86/kernel/fpu/core.c

635

if (!ssp)

arch/x86/kernel/fpu/core.c

650

xstate->user_ssp = (u64)ssp;

arch/x86/kernel/fpu/core.c

657

unsigned long ssp)

arch/x86/kernel/fpu/core.c

728

if (update_fpu_shstk(dst, ssp))

arch/x86/kernel/shstk.c

230

unsigned long long ssp;

arch/x86/kernel/shstk.c

234

rdmsrq(MSR_IA32_PL3_SSP, ssp);

arch/x86/kernel/shstk.c

238

return ssp;

arch/x86/kernel/shstk.c

244

u64 ssp;

arch/x86/kernel/shstk.c

251

rdmsrq(MSR_IA32_PL3_SSP, ssp);

arch/x86/kernel/shstk.c

252

if (val && get_user(*val, (__user u64 *)ssp))

arch/x86/kernel/shstk.c

255

wrmsrq(MSR_IA32_PL3_SSP, ssp + SS_FRAME_SIZE);

arch/x86/kernel/shstk.c

263

u64 ssp;

arch/x86/kernel/shstk.c

271

rdmsrq(MSR_IA32_PL3_SSP, ssp);

arch/x86/kernel/shstk.c

272

ssp -= SS_FRAME_SIZE;

arch/x86/kernel/shstk.c

273

ret = write_user_shstk_64((__user void *)ssp, val);

arch/x86/kernel/shstk.c

275

wrmsrq(MSR_IA32_PL3_SSP, ssp);

arch/x86/kernel/shstk.c

312

static int shstk_push_sigframe(unsigned long *ssp)

arch/x86/kernel/shstk.c

314

unsigned long target_ssp = *ssp;

arch/x86/kernel/shstk.c

320

*ssp -= SS_FRAME_SIZE;

arch/x86/kernel/shstk.c

321

if (put_shstk_data((void __user *)*ssp, target_ssp))

arch/x86/kernel/shstk.c

327

static int shstk_pop_sigframe(unsigned long *ssp)

arch/x86/kernel/shstk.c

338

if (!IS_ALIGNED(*ssp, 8))

arch/x86/kernel/shstk.c

349

vma = find_vma(current->mm, *ssp);

arch/x86/kernel/shstk.c

366

err = get_shstk_data(&token_addr, (unsigned long __user *)*ssp);

arch/x86/kernel/shstk.c

379

*ssp = token_addr;

arch/x86/kernel/shstk.c

387

unsigned long ssp;

arch/x86/kernel/shstk.c

397

ssp = get_user_shstk_addr();

arch/x86/kernel/shstk.c

398

if (unlikely(!ssp))

arch/x86/kernel/shstk.c

401

err = shstk_push_sigframe(&ssp);

arch/x86/kernel/shstk.c

406

ssp -= SS_FRAME_SIZE;

arch/x86/kernel/shstk.c

407

err = write_user_shstk_64((u64 __user *)ssp, (u64)restorer);

arch/x86/kernel/shstk.c

412

wrmsrq(MSR_IA32_PL3_SSP, ssp);

arch/x86/kernel/shstk.c

420

unsigned long ssp;

arch/x86/kernel/shstk.c

427

ssp = get_user_shstk_addr();

arch/x86/kernel/shstk.c

428

if (unlikely(!ssp))

arch/x86/kernel/shstk.c

431

err = shstk_pop_sigframe(&ssp);

arch/x86/kernel/shstk.c

436

wrmsrq(MSR_IA32_PL3_SSP, ssp);

arch/x86/kernel/shstk.c

50

static int create_rstor_token(unsigned long ssp, unsigned long *token_addr)

arch/x86/kernel/shstk.c

55

if (!IS_ALIGNED(ssp, 8))

arch/x86/kernel/shstk.c

58

addr = ssp - SS_FRAME_SIZE;

arch/x86/kernel/shstk.c

620

unsigned long ssp;

arch/x86/kernel/shstk.c

625

ssp = get_user_shstk_addr();

arch/x86/kernel/shstk.c

626

return write_user_shstk_64((u64 __user *)ssp, (u64)val);

arch/x86/kernel/shstk.c

64

ssp |= BIT(0);

arch/x86/kernel/shstk.c

66

if (write_user_shstk_64((u64 __user *)addr, (u64)ssp))

arch/x86/kernel/vm86_32.c

495

unsigned char __user *ssp, unsigned short sp)

arch/x86/kernel/vm86_32.c

512

pushw(ssp, sp, get_vflags(regs), cannot_handle);

arch/x86/kernel/vm86_32.c

513

pushw(ssp, sp, regs->pt.cs, cannot_handle);

arch/x86/kernel/vm86_32.c

514

pushw(ssp, sp, IP(regs), cannot_handle);

arch/x86/kernel/vm86_32.c

551

unsigned char __user *ssp;

arch/x86/kernel/vm86_32.c

563

ssp = (unsigned char __user *) (regs->pt.ss << 4);

arch/x86/kernel/vm86_32.c

590

pushl(ssp, sp, get_vflags(regs), simulate_sigsegv);

arch/x86/kernel/vm86_32.c

593

pushw(ssp, sp, get_vflags(regs), simulate_sigsegv);

arch/x86/kernel/vm86_32.c

604

newflags = popl(ssp, sp, simulate_sigsegv);

arch/x86/kernel/vm86_32.c

607

newflags = popw(ssp, sp, simulate_sigsegv);

arch/x86/kernel/vm86_32.c

630

do_int(regs, intno, ssp, sp);

arch/x86/kernel/vm86_32.c

641

newip = popl(ssp, sp, simulate_sigsegv);

arch/x86/kernel/vm86_32.c

642

newcs = popl(ssp, sp, simulate_sigsegv);

arch/x86/kernel/vm86_32.c

643

newflags = popl(ssp, sp, simulate_sigsegv);

arch/x86/kernel/vm86_32.c

646

newip = popw(ssp, sp, simulate_sigsegv);

arch/x86/kernel/vm86_32.c

647

newcs = popw(ssp, sp, simulate_sigsegv);

arch/x86/kernel/vm86_32.c

648

newflags = popw(ssp, sp, simulate_sigsegv);

arch/x86/kvm/emulate.c

1507

u64 efer = 0, cet = 0, ssp = 0;

arch/x86/kvm/emulate.c

1525

if (ctxt->ops->get_msr(ctxt, MSR_KVM_INTERNAL_GUEST_SSP, &ssp))

arch/x86/kvm/emulate.c

1532

return ssp >> 32;

arch/x86/kvm/smm.c

274

kvm_msr_read(vcpu, MSR_KVM_INTERNAL_GUEST_SSP, &smram->ssp))

arch/x86/kvm/smm.c

566

kvm_msr_write(vcpu, MSR_KVM_INTERNAL_GUEST_SSP, smstate->ssp))

arch/x86/kvm/smm.c

90

CHECK_SMRAM64_OFFSET(ssp, 0xFF18);

arch/x86/kvm/smm.h

119

u64 ssp;

arch/x86/kvm/svm/nested.c

1225

to_save->ssp = from_save->ssp;

arch/x86/kvm/svm/nested.c

1289

vmcb12->save.ssp = vmcb02->save.ssp;

arch/x86/kvm/svm/nested.c

600

to->ssp = from->ssp;

arch/x86/kvm/svm/nested.c

779

vmcb02->save.ssp = save->ssp;

arch/x86/kvm/svm/svm.c

2876

msr_info->data = svm->vmcb->save.ssp;

arch/x86/kvm/svm/svm.c

3128

svm->vmcb->save.ssp = data;

arch/x86/kvm/svm/svm.c

3539

"s_cet:", save->s_cet, "ssp:", save->ssp);

arch/x86/kvm/svm/svm.h

167

u64 ssp;

arch/x86/kvm/vmx/nested.c

2599

u64 *ssp, u64 *ssp_tbl)

arch/x86/kvm/vmx/nested.c

2606

*ssp = vmcs_readl(GUEST_SSP);

arch/x86/kvm/vmx/nested.c

2612

u64 ssp, u64 ssp_tbl)

arch/x86/kvm/vmx/nested.c

2619

vmcs_writel(GUEST_SSP, ssp);

arch/x86/kvm/vmx/nested.c

3166

u64 ssp, u64 ssp_tbl)

arch/x86/kvm/vmx/nested.c

3168

if (CC(!kvm_is_valid_u_s_cet(vcpu, s_cet)) || CC(!IS_ALIGNED(ssp, 4)) ||

drivers/clk/mxs/clk-imx23.c

145

clks[ssp] = mxs_clk_gate("ssp", "ssp_div", SSP, 31);

drivers/clk/mxs/clk-ssp.c

21

void mxs_ssp_set_clk_rate(struct mxs_ssp *ssp, unsigned int rate)

drivers/clk/mxs/clk-ssp.c

27

ssp_clk = clk_get_rate(ssp->clk);

drivers/clk/mxs/clk-ssp.c

37

dev_err(ssp->dev,

drivers/clk/mxs/clk-ssp.c

44

val = readl(ssp->base + HW_SSP_TIMING(ssp));

drivers/clk/mxs/clk-ssp.c

48

writel(val, ssp->base + HW_SSP_TIMING(ssp));

drivers/clk/mxs/clk-ssp.c

50

ssp->clk_rate = ssp_sck;

drivers/clk/mxs/clk-ssp.c

52

dev_dbg(ssp->dev,

drivers/mmc/host/mxs-mmc.c

108

ssp->base + HW_SSP_TIMING(ssp));

drivers/mmc/host/mxs-mmc.c

115

writel(ctrl0, ssp->base + HW_SSP_CTRL0);

drivers/mmc/host/mxs-mmc.c

116

writel(ctrl1, ssp->base + HW_SSP_CTRL1(ssp));

drivers/mmc/host/mxs-mmc.c

128

struct mxs_ssp *ssp = &host->ssp;

drivers/mmc/host/mxs-mmc.c

132

cmd->resp[3] = readl(ssp->base + HW_SSP_SDRESP0(ssp));

drivers/mmc/host/mxs-mmc.c

133

cmd->resp[2] = readl(ssp->base + HW_SSP_SDRESP1(ssp));

drivers/mmc/host/mxs-mmc.c

134

cmd->resp[1] = readl(ssp->base + HW_SSP_SDRESP2(ssp));

drivers/mmc/host/mxs-mmc.c

135

cmd->resp[0] = readl(ssp->base + HW_SSP_SDRESP3(ssp));

drivers/mmc/host/mxs-mmc.c

137

cmd->resp[0] = readl(ssp->base + HW_SSP_SDRESP0(ssp));

drivers/mmc/host/mxs-mmc.c

147

data->sg_len, ssp->dma_dir);

drivers/mmc/host/mxs-mmc.c

180

struct mxs_ssp *ssp = &host->ssp;

drivers/mmc/host/mxs-mmc.c

185

stat = readl(ssp->base + HW_SSP_CTRL1(ssp));

drivers/mmc/host/mxs-mmc.c

187

ssp->base + HW_SSP_CTRL1(ssp) + STMP_OFFSET_REG_CLR);

drivers/mmc/host/mxs-mmc.c

216

struct mxs_ssp *ssp = &host->ssp;

drivers/mmc/host/mxs-mmc.c

225

data->sg_len, ssp->dma_dir);

drivers/mmc/host/mxs-mmc.c

230

sgl = (struct scatterlist *) ssp->ssp_pio_words;

drivers/mmc/host/mxs-mmc.c

234

desc = dmaengine_prep_slave_sg(ssp->dmach,

drivers/mmc/host/mxs-mmc.c

235

sgl, sg_len, ssp->slave_dirn, flags);

drivers/mmc/host/mxs-mmc.c

242

data->sg_len, ssp->dma_dir);

drivers/mmc/host/mxs-mmc.c

250

struct mxs_ssp *ssp = &host->ssp;

drivers/mmc/host/mxs-mmc.c

264

ssp->ssp_pio_words[0] = ctrl0;

drivers/mmc/host/mxs-mmc.c

265

ssp->ssp_pio_words[1] = cmd0;

drivers/mmc/host/mxs-mmc.c

266

ssp->ssp_pio_words[2] = cmd1;

drivers/mmc/host/mxs-mmc.c

267

ssp->dma_dir = DMA_NONE;

drivers/mmc/host/mxs-mmc.c

268

ssp->slave_dirn = DMA_TRANS_NONE;

drivers/mmc/host/mxs-mmc.c

274

dma_async_issue_pending(ssp->dmach);

drivers/mmc/host/mxs-mmc.c

284

struct mxs_ssp *ssp = &host->ssp;

drivers/mmc/host/mxs-mmc.c

309

ssp->ssp_pio_words[0] = ctrl0;

drivers/mmc/host/mxs-mmc.c

310

ssp->ssp_pio_words[1] = cmd0;

drivers/mmc/host/mxs-mmc.c

311

ssp->ssp_pio_words[2] = cmd1;

drivers/mmc/host/mxs-mmc.c

312

ssp->dma_dir = DMA_NONE;

drivers/mmc/host/mxs-mmc.c

313

ssp->slave_dirn = DMA_TRANS_NONE;

drivers/mmc/host/mxs-mmc.c

319

dma_async_issue_pending(ssp->dmach);

drivers/mmc/host/mxs-mmc.c

357

struct mxs_ssp *ssp = &host->ssp;

drivers/mmc/host/mxs-mmc.c

401

if (ssp_is_old(ssp)) {

drivers/mmc/host/mxs-mmc.c

406

writel(data_size, ssp->base + HW_SSP_XFER_SIZE);

drivers/mmc/host/mxs-mmc.c

409

ssp->base + HW_SSP_BLOCK_SIZE);

drivers/mmc/host/mxs-mmc.c

423

timeout = mxs_ns_to_ssp_ticks(ssp->clk_rate, data->timeout_ns);

drivers/mmc/host/mxs-mmc.c

424

val = readl(ssp->base + HW_SSP_TIMING(ssp));

drivers/mmc/host/mxs-mmc.c

427

writel(val, ssp->base + HW_SSP_TIMING(ssp));

drivers/mmc/host/mxs-mmc.c

430

ssp->ssp_pio_words[0] = ctrl0;

drivers/mmc/host/mxs-mmc.c

431

ssp->ssp_pio_words[1] = cmd0;

drivers/mmc/host/mxs-mmc.c

432

ssp->ssp_pio_words[2] = cmd1;

drivers/mmc/host/mxs-mmc.c

433

ssp->dma_dir = DMA_NONE;

drivers/mmc/host/mxs-mmc.c

434

ssp->slave_dirn = DMA_TRANS_NONE;

drivers/mmc/host/mxs-mmc.c

442

ssp->dma_dir = dma_data_dir;

drivers/mmc/host/mxs-mmc.c

443

ssp->slave_dirn = slave_dirn;

drivers/mmc/host/mxs-mmc.c

449

dma_async_issue_pending(ssp->dmach);

drivers/mmc/host/mxs-mmc.c

48

struct mxs_ssp ssp;

drivers/mmc/host/mxs-mmc.c

506

mxs_ssp_set_clk_rate(&host->ssp, ios->clock);

drivers/mmc/host/mxs-mmc.c

512

struct mxs_ssp *ssp = &host->ssp;

drivers/mmc/host/mxs-mmc.c

521

ssp->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_SET);

drivers/mmc/host/mxs-mmc.c

523

ssp->base + HW_SSP_CTRL1(ssp) + STMP_OFFSET_REG_SET);

drivers/mmc/host/mxs-mmc.c

526

ssp->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_CLR);

drivers/mmc/host/mxs-mmc.c

528

ssp->base + HW_SSP_CTRL1(ssp) + STMP_OFFSET_REG_CLR);

drivers/mmc/host/mxs-mmc.c

533

if (enable && readl(ssp->base + HW_SSP_STATUS(ssp)) &

drivers/mmc/host/mxs-mmc.c

566

struct mxs_ssp *ssp;

drivers/mmc/host/mxs-mmc.c

577

ssp = &host->ssp;

drivers/mmc/host/mxs-mmc.c

578

ssp->dev = &pdev->dev;

drivers/mmc/host/mxs-mmc.c

579

ssp->base = devm_platform_ioremap_resource(pdev, 0);

drivers/mmc/host/mxs-mmc.c

580

if (IS_ERR(ssp->base))

drivers/mmc/host/mxs-mmc.c

581

return PTR_ERR(ssp->base);

drivers/mmc/host/mxs-mmc.c

583

ssp->devid = (enum mxs_ssp_id)of_device_get_match_data(&pdev->dev);

drivers/mmc/host/mxs-mmc.c

601

ssp->clk = devm_clk_get(&pdev->dev, NULL);

drivers/mmc/host/mxs-mmc.c

602

if (IS_ERR(ssp->clk))

drivers/mmc/host/mxs-mmc.c

603

return PTR_ERR(ssp->clk);

drivers/mmc/host/mxs-mmc.c

605

ret = clk_prepare_enable(ssp->clk);

drivers/mmc/host/mxs-mmc.c

615

ssp->dmach = dma_request_chan(&pdev->dev, "rx-tx");

drivers/mmc/host/mxs-mmc.c

616

if (IS_ERR(ssp->dmach)) {

drivers/mmc/host/mxs-mmc.c

619

ret = PTR_ERR(ssp->dmach);

drivers/mmc/host/mxs-mmc.c

64

struct mxs_ssp *ssp = &host->ssp;

drivers/mmc/host/mxs-mmc.c

641

mmc->max_blk_count = (ssp_is_old(ssp)) ? 0xff : 0xffffff;

drivers/mmc/host/mxs-mmc.c

642

mmc->max_req_size = (ssp_is_old(ssp)) ? 0xffff : 0xffffffff;

drivers/mmc/host/mxs-mmc.c

643

mmc->max_seg_size = dma_get_max_seg_size(ssp->dmach->device->dev);

drivers/mmc/host/mxs-mmc.c

663

dma_release_channel(ssp->dmach);

drivers/mmc/host/mxs-mmc.c

665

clk_disable_unprepare(ssp->clk);

drivers/mmc/host/mxs-mmc.c

673

struct mxs_ssp *ssp = &host->ssp;

drivers/mmc/host/mxs-mmc.c

677

if (ssp->dmach)

drivers/mmc/host/mxs-mmc.c

678

dma_release_channel(ssp->dmach);

drivers/mmc/host/mxs-mmc.c

680

clk_disable_unprepare(ssp->clk);

drivers/mmc/host/mxs-mmc.c

687

struct mxs_ssp *ssp = &host->ssp;

drivers/mmc/host/mxs-mmc.c

689

clk_disable_unprepare(ssp->clk);

drivers/mmc/host/mxs-mmc.c

697

struct mxs_ssp *ssp = &host->ssp;

drivers/mmc/host/mxs-mmc.c

699

return clk_prepare_enable(ssp->clk);

drivers/mmc/host/mxs-mmc.c

75

!(readl(ssp->base + HW_SSP_STATUS(ssp)) &

drivers/mmc/host/mxs-mmc.c

86

struct mxs_ssp *ssp = &host->ssp;

drivers/mmc/host/mxs-mmc.c

90

ret = stmp_reset_block(ssp->base);

drivers/net/can/m_can/m_can.c

1438

u32 tdco, ssp;

drivers/net/can/m_can/m_can.c

1443

ssp = dbt->sample_point;

drivers/net/can/m_can/m_can.c

1449

ssp / dbt->bitrate;

drivers/scsi/hisi_sas/hisi_sas.h

626

struct hisi_sas_command_table_ssp ssp;

drivers/scsi/isci/port.c

1003

rnc->ssp.is_valid = false;

drivers/scsi/isci/port.c

1470

rnc->ssp.is_valid = true;

drivers/scsi/isci/port.c

552

rnc->ssp.remote_sas_address_hi = 0;

drivers/scsi/isci/port.c

553

rnc->ssp.remote_sas_address_lo = 0;

drivers/scsi/isci/port.c

555

rnc->ssp.remote_node_index = rni;

drivers/scsi/isci/port.c

556

rnc->ssp.remote_node_port_width = 1;

drivers/scsi/isci/port.c

557

rnc->ssp.logical_port_index = iport->physical_port_index;

drivers/scsi/isci/port.c

559

rnc->ssp.nexus_loss_timer_enable = false;

drivers/scsi/isci/port.c

560

rnc->ssp.check_bit = false;

drivers/scsi/isci/port.c

561

rnc->ssp.is_valid = true;

drivers/scsi/isci/port.c

562

rnc->ssp.is_remote_node_context = true;

drivers/scsi/isci/port.c

563

rnc->ssp.function_number = 0;

drivers/scsi/isci/port.c

564

rnc->ssp.arbitration_wait_time = 0;

drivers/scsi/isci/remote_node_context.c

129

rnc->ssp.remote_node_index = rni;

drivers/scsi/isci/remote_node_context.c

130

rnc->ssp.remote_node_port_width = idev->device_port_width;

drivers/scsi/isci/remote_node_context.c

131

rnc->ssp.logical_port_index = idev->owning_port->physical_port_index;

drivers/scsi/isci/remote_node_context.c

135

rnc->ssp.remote_sas_address_hi = upper_32_bits(sas_addr);

drivers/scsi/isci/remote_node_context.c

136

rnc->ssp.remote_sas_address_lo = lower_32_bits(sas_addr);

drivers/scsi/isci/remote_node_context.c

138

rnc->ssp.nexus_loss_timer_enable = true;

drivers/scsi/isci/remote_node_context.c

139

rnc->ssp.check_bit = false;

drivers/scsi/isci/remote_node_context.c

140

rnc->ssp.is_valid = false;

drivers/scsi/isci/remote_node_context.c

141

rnc->ssp.is_remote_node_context = true;

drivers/scsi/isci/remote_node_context.c

142

rnc->ssp.function_number = 0;

drivers/scsi/isci/remote_node_context.c

144

rnc->ssp.arbitration_wait_time = 0;

drivers/scsi/isci/remote_node_context.c

147

rnc->ssp.connection_occupancy_timeout =

drivers/scsi/isci/remote_node_context.c

149

rnc->ssp.connection_inactivity_timeout =

drivers/scsi/isci/remote_node_context.c

152

rnc->ssp.connection_occupancy_timeout =

drivers/scsi/isci/remote_node_context.c

154

rnc->ssp.connection_inactivity_timeout =

drivers/scsi/isci/remote_node_context.c

158

rnc->ssp.initial_arbitration_wait_time = 0;

drivers/scsi/isci/remote_node_context.c

161

rnc->ssp.oaf_connection_rate = idev->connection_rate;

drivers/scsi/isci/remote_node_context.c

162

rnc->ssp.oaf_features = 0;

drivers/scsi/isci/remote_node_context.c

163

rnc->ssp.oaf_source_zone_group = 0;

drivers/scsi/isci/remote_node_context.c

164

rnc->ssp.oaf_more_compatibility_features = 0;

drivers/scsi/isci/remote_node_context.c

241

rnc_buffer->ssp.is_valid = true;

drivers/scsi/isci/remote_node_context.c

262

rnc_buffer->ssp.is_valid = false;

drivers/scsi/isci/request.c

1011

struct ssp_response_iu *resp = &ireq->ssp.rsp;

drivers/scsi/isci/request.c

1014

sci_swab32_cpy(&ireq->ssp.rsp,

drivers/scsi/isci/request.c

1015

&ireq->ssp.rsp,

drivers/scsi/isci/request.c

1030

sci_swab32_cpy(&ireq->ssp.rsp,

drivers/scsi/isci/request.c

1031

&ireq->ssp.rsp,

drivers/scsi/isci/request.c

1044

resp_iu = &ireq->ssp.rsp;

drivers/scsi/isci/request.c

1727

sci_swab32_cpy(&ireq->ssp.rsp, resp_iu, word_cnt);

drivers/scsi/isci/request.c

1729

resp_iu = &ireq->ssp.rsp;

drivers/scsi/isci/request.c

176

cmd_iu = &ireq->ssp.cmd;

drivers/scsi/isci/request.c

197

task_iu = &ireq->ssp.tmf;

drivers/scsi/isci/request.c

260

dma_addr = sci_io_request_get_dma_addr(ireq, &ireq->ssp.cmd);

drivers/scsi/isci/request.c

269

dma_addr = sci_io_request_get_dma_addr(ireq, &ireq->ssp.rsp);

drivers/scsi/isci/request.c

2756

resp_iu = &request->ssp.rsp;

drivers/scsi/isci/request.c

427

task_context->type.ssp.frame_type = SSP_COMMAND;

drivers/scsi/isci/request.c

475

task_context->type.ssp.frame_type = SSP_TASK;

drivers/scsi/isci/request.c

793

(SCU_TASK_CONTEXT_SRAM + offsetof(struct scu_task_context, type.ssp.data_offset)) +

drivers/scsi/isci/request.c

820

tc->type.ssp.tag = ireq->io_tag;

drivers/scsi/isci/request.c

821

tc->type.ssp.target_port_transfer_tag = 0xFFFF;

drivers/scsi/isci/request.c

977

ssp_response = &ireq->ssp.rsp;

drivers/scsi/isci/request.h

141

} ssp;

drivers/scsi/isci/scu_remote_node_context.h

220

struct ssp_remote_node_context ssp;

drivers/scsi/isci/scu_task_context.h

425

struct ssp_task_context ssp;

drivers/scsi/isci/task.c

688

ireq->ssp.rsp_buf,

drivers/scsi/libsas/sas_scsi_host.c

667

struct ssp_device *ssp;

drivers/scsi/libsas/sas_scsi_host.c

669

ssp = list_entry(ha->eh_dev_q.next, typeof(*ssp), eh_list_node);

drivers/scsi/libsas/sas_scsi_host.c

670

list_del_init(&ssp->eh_list_node);

drivers/scsi/libsas/sas_scsi_host.c

671

dev = container_of(ssp, typeof(*dev), ssp_dev);

drivers/scsi/libsas/sas_scsi_host.c

678

i->dft->lldd_lu_reset(dev, ssp->reset_lun.scsi_lun);

drivers/soc/pxa/ssp.c

114

struct ssp_device *ssp;

drivers/soc/pxa/ssp.c

117

ssp = devm_kzalloc(dev, sizeof(struct ssp_device), GFP_KERNEL);

drivers/soc/pxa/ssp.c

118

if (ssp == NULL)

drivers/soc/pxa/ssp.c

121

ssp->dev = dev;

drivers/soc/pxa/ssp.c

123

ssp->clk = devm_clk_get(dev, NULL);

drivers/soc/pxa/ssp.c

124

if (IS_ERR(ssp->clk))

drivers/soc/pxa/ssp.c

125

return PTR_ERR(ssp->clk);

drivers/soc/pxa/ssp.c

140

ssp->phys_base = res->start;

drivers/soc/pxa/ssp.c

142

ssp->mmio_base = devm_ioremap(dev, res->start, resource_size(res));

drivers/soc/pxa/ssp.c

143

if (ssp->mmio_base == NULL) {

drivers/soc/pxa/ssp.c

148

ssp->irq = platform_get_irq(pdev, 0);

drivers/soc/pxa/ssp.c

149

if (ssp->irq < 0)

drivers/soc/pxa/ssp.c

155

ssp->type = (uintptr_t) id->data;

drivers/soc/pxa/ssp.c

159

ssp->type = id->driver_data;

drivers/soc/pxa/ssp.c

164

ssp->port_id = pdev->id + 1;

drivers/soc/pxa/ssp.c

167

ssp->use_count = 0;

drivers/soc/pxa/ssp.c

168

ssp->of_node = dev->of_node;

drivers/soc/pxa/ssp.c

171

list_add(&ssp->node, &ssp_list);

drivers/soc/pxa/ssp.c

174

platform_set_drvdata(pdev, ssp);

drivers/soc/pxa/ssp.c

181

struct ssp_device *ssp = platform_get_drvdata(pdev);

drivers/soc/pxa/ssp.c

184

list_del(&ssp->node);

drivers/soc/pxa/ssp.c

40

struct ssp_device *ssp = NULL;

drivers/soc/pxa/ssp.c

44

list_for_each_entry(ssp, &ssp_list, node) {

drivers/soc/pxa/ssp.c

45

if (ssp->port_id == port && ssp->use_count == 0) {

drivers/soc/pxa/ssp.c

46

ssp->use_count++;

drivers/soc/pxa/ssp.c

47

ssp->label = label;

drivers/soc/pxa/ssp.c

54

if (&ssp->node == &ssp_list)

drivers/soc/pxa/ssp.c

57

return ssp;

drivers/soc/pxa/ssp.c

64

struct ssp_device *ssp = NULL;

drivers/soc/pxa/ssp.c

68

list_for_each_entry(ssp, &ssp_list, node) {

drivers/soc/pxa/ssp.c

69

if (ssp->of_node == of_node && ssp->use_count == 0) {

drivers/soc/pxa/ssp.c

70

ssp->use_count++;

drivers/soc/pxa/ssp.c

71

ssp->label = label;

drivers/soc/pxa/ssp.c

78

if (&ssp->node == &ssp_list)

drivers/soc/pxa/ssp.c

81

return ssp;

drivers/soc/pxa/ssp.c

85

void pxa_ssp_free(struct ssp_device *ssp)

drivers/soc/pxa/ssp.c

88

if (ssp->use_count) {

drivers/soc/pxa/ssp.c

89

ssp->use_count--;

drivers/soc/pxa/ssp.c

90

ssp->label = NULL;

drivers/soc/pxa/ssp.c

92

dev_err(ssp->dev, "device already free\n");

drivers/spi/spi-mxs.c

100

writel(0x0, ssp->base + HW_SSP_CMD1);

drivers/spi/spi-mxs.c

128

struct mxs_ssp *ssp = &spi->ssp;

drivers/spi/spi-mxs.c

132

reg = readl_relaxed(ssp->base + offset);

drivers/spi/spi-mxs.c

155

struct mxs_ssp *ssp = dev_id;

drivers/spi/spi-mxs.c

157

dev_err(ssp->dev, "%s[%i] CTRL1=%08x STATUS=%08x\n",

drivers/spi/spi-mxs.c

159

readl(ssp->base + HW_SSP_CTRL1(ssp)),

drivers/spi/spi-mxs.c

160

readl(ssp->base + HW_SSP_STATUS(ssp)));

drivers/spi/spi-mxs.c

168

struct mxs_ssp *ssp = &spi->ssp;

drivers/spi/spi-mxs.c

192

ctrl0 = readl(ssp->base + HW_SSP_CTRL0);

drivers/spi/spi-mxs.c

212

if (ssp->devid == IMX23_SSP) {

drivers/spi/spi-mxs.c

234

ret = dma_map_sg(ssp->dev, &dma_xfer[sg_count].sg, 1,

drivers/spi/spi-mxs.c

241

desc = dmaengine_prep_slave_sg(ssp->dmach,

drivers/spi/spi-mxs.c

243

(ssp->devid == IMX23_SSP) ? 1 : 4,

drivers/spi/spi-mxs.c

247

dev_err(ssp->dev,

drivers/spi/spi-mxs.c

253

desc = dmaengine_prep_slave_sg(ssp->dmach,

drivers/spi/spi-mxs.c

259

dev_err(ssp->dev,

drivers/spi/spi-mxs.c

275

dma_async_issue_pending(ssp->dmach);

drivers/spi/spi-mxs.c

279

dev_err(ssp->dev, "DMA transfer timeout\n");

drivers/spi/spi-mxs.c

281

dmaengine_terminate_all(ssp->dmach);

drivers/spi/spi-mxs.c

290

dma_unmap_sg(ssp->dev, &dma_xfer[sg_count].sg, 1,

drivers/spi/spi-mxs.c

303

struct mxs_ssp *ssp = &spi->ssp;

drivers/spi/spi-mxs.c

306

ssp->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_CLR);

drivers/spi/spi-mxs.c

311

ssp->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_SET);

drivers/spi/spi-mxs.c

313

if (ssp->devid == IMX23_SSP) {

drivers/spi/spi-mxs.c

315

ssp->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_CLR);

drivers/spi/spi-mxs.c

317

ssp->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_SET);

drivers/spi/spi-mxs.c

319

writel(1, ssp->base + HW_SSP_XFER_SIZE);

drivers/spi/spi-mxs.c

324

ssp->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_CLR);

drivers/spi/spi-mxs.c

327

ssp->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_SET);

drivers/spi/spi-mxs.c

330

ssp->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_SET);

drivers/spi/spi-mxs.c

336

writel(*buf, ssp->base + HW_SSP_DATA(ssp));

drivers/spi/spi-mxs.c

339

ssp->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_SET);

drivers/spi/spi-mxs.c

342

if (mxs_ssp_wait(spi, HW_SSP_STATUS(ssp),

drivers/spi/spi-mxs.c

346

*buf = (readl(ssp->base + HW_SSP_DATA(ssp)) & 0xff);

drivers/spi/spi-mxs.c

365

struct mxs_ssp *ssp = &spi->ssp;

drivers/spi/spi-mxs.c

372

ssp->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_CLR);

drivers/spi/spi-mxs.c

374

ssp->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_SET);

drivers/spi/spi-mxs.c

384

t->effective_speed_hz = ssp->clk_rate;

drivers/spi/spi-mxs.c

401

ssp->base + HW_SSP_CTRL1(ssp) +

drivers/spi/spi-mxs.c

414

ssp->base + HW_SSP_CTRL1(ssp) +

drivers/spi/spi-mxs.c

430

stmp_reset_block(ssp->base);

drivers/spi/spi-mxs.c

447

struct mxs_ssp *ssp = &spi->ssp;

drivers/spi/spi-mxs.c

450

clk_disable_unprepare(ssp->clk);

drivers/spi/spi-mxs.c

454

int ret2 = clk_prepare_enable(ssp->clk);

drivers/spi/spi-mxs.c

468

struct mxs_ssp *ssp = &spi->ssp;

drivers/spi/spi-mxs.c

475

ret = clk_prepare_enable(ssp->clk);

drivers/spi/spi-mxs.c

535

struct mxs_ssp *ssp;

drivers/spi/spi-mxs.c

581

ssp = &spi->ssp;

drivers/spi/spi-mxs.c

582

ssp->dev = &pdev->dev;

drivers/spi/spi-mxs.c

583

ssp->clk = clk;

drivers/spi/spi-mxs.c

584

ssp->base = base;

drivers/spi/spi-mxs.c

585

ssp->devid = devid;

drivers/spi/spi-mxs.c

59

struct mxs_ssp ssp;

drivers/spi/spi-mxs.c

590

dev_name(&pdev->dev), ssp);

drivers/spi/spi-mxs.c

594

ssp->dmach = dma_request_chan(&pdev->dev, "rx-tx");

drivers/spi/spi-mxs.c

595

if (IS_ERR(ssp->dmach)) {

drivers/spi/spi-mxs.c

596

dev_err(ssp->dev, "Failed to request DMA\n");

drivers/spi/spi-mxs.c

597

return PTR_ERR(ssp->dmach);

drivers/spi/spi-mxs.c

600

pm_runtime_enable(ssp->dev);

drivers/spi/spi-mxs.c

601

if (!pm_runtime_enabled(ssp->dev)) {

drivers/spi/spi-mxs.c

602

ret = mxs_spi_runtime_resume(ssp->dev);

drivers/spi/spi-mxs.c

604

dev_err(ssp->dev, "runtime resume failed\n");

drivers/spi/spi-mxs.c

609

ret = pm_runtime_resume_and_get(ssp->dev);

drivers/spi/spi-mxs.c

611

dev_err(ssp->dev, "runtime_get_sync failed\n");

drivers/spi/spi-mxs.c

615

clk_set_rate(ssp->clk, clk_freq);

drivers/spi/spi-mxs.c

617

ret = stmp_reset_block(ssp->base);

drivers/spi/spi-mxs.c

627

pm_runtime_put(ssp->dev);

drivers/spi/spi-mxs.c

632

pm_runtime_put(ssp->dev);

drivers/spi/spi-mxs.c

634

pm_runtime_disable(ssp->dev);

drivers/spi/spi-mxs.c

636

dma_release_channel(ssp->dmach);

drivers/spi/spi-mxs.c

645

struct mxs_ssp *ssp;

drivers/spi/spi-mxs.c

649

ssp = &spi->ssp;

drivers/spi/spi-mxs.c

657

dma_release_channel(ssp->dmach);

drivers/spi/spi-mxs.c

68

struct mxs_ssp *ssp = &spi->ssp;

drivers/spi/spi-mxs.c

77

mxs_ssp_set_clk_rate(ssp, hz);

drivers/spi/spi-mxs.c

91

ssp->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_SET);

drivers/spi/spi-mxs.c

97

ssp->base + HW_SSP_CTRL1(ssp));

drivers/spi/spi-mxs.c

99

writel(0x0, ssp->base + HW_SSP_CMD0);

drivers/spi/spi-pxa2xx-dma.c

100

cfg.src_addr = drv_data->ssp->phys_base + SSDR;

drivers/spi/spi-pxa2xx-dma.c

110

dev_warn(drv_data->ssp->dev, "DMA slave config failed\n");

drivers/spi/spi-pxa2xx-dma.c

124

dev_err(drv_data->ssp->dev, "FIFO overrun\n");

drivers/spi/spi-pxa2xx-dma.c

144

dev_err(drv_data->ssp->dev, "failed to get DMA TX descriptor\n");

drivers/spi/spi-pxa2xx-dma.c

151

dev_err(drv_data->ssp->dev, "failed to get DMA RX descriptor\n");

drivers/spi/spi-pxa2xx-dma.c

189

struct device *dev = drv_data->ssp->dev;

drivers/spi/spi-pxa2xx-dma.c

53

pxa_ssp_disable(drv_data->ssp);

drivers/spi/spi-pxa2xx-dma.c

93

cfg.dst_addr = drv_data->ssp->phys_base + SSDR;

drivers/spi/spi-pxa2xx-pci.c

105

ssp->type = LPSS_BYT_SSP;

drivers/spi/spi-pxa2xx-pci.c

106

ssp->port_id = 0;

drivers/spi/spi-pxa2xx-pci.c

111

ssp->type = LPSS_BSW_SSP;

drivers/spi/spi-pxa2xx-pci.c

112

ssp->port_id = 0;

drivers/spi/spi-pxa2xx-pci.c

117

ssp->type = LPSS_BSW_SSP;

drivers/spi/spi-pxa2xx-pci.c

118

ssp->port_id = 1;

drivers/spi/spi-pxa2xx-pci.c

123

ssp->type = LPSS_BSW_SSP;

drivers/spi/spi-pxa2xx-pci.c

124

ssp->port_id = 2;

drivers/spi/spi-pxa2xx-pci.c

130

ssp->type = LPSS_LPT_SSP;

drivers/spi/spi-pxa2xx-pci.c

131

ssp->port_id = 0;

drivers/spi/spi-pxa2xx-pci.c

137

ssp->type = LPSS_LPT_SSP;

drivers/spi/spi-pxa2xx-pci.c

138

ssp->port_id = 1;

drivers/spi/spi-pxa2xx-pci.c

148

ret = pxa2xx_spi_pci_clk_register(dev, ssp, 50000000);

drivers/spi/spi-pxa2xx-pci.c

179

struct ssp_device *ssp = &c->ssp;

drivers/spi/spi-pxa2xx-pci.c

181

ssp->type = PXA25x_SSP;

drivers/spi/spi-pxa2xx-pci.c

182

ssp->port_id = dev->devfn;

drivers/spi/spi-pxa2xx-pci.c

185

return pxa2xx_spi_pci_clk_register(dev, ssp, 3686400);

drivers/spi/spi-pxa2xx-pci.c

194

struct ssp_device *ssp = &c->ssp;

drivers/spi/spi-pxa2xx-pci.c

199

ssp->type = MRFLD_SSP;

drivers/spi/spi-pxa2xx-pci.c

203

ssp->port_id = 3;

drivers/spi/spi-pxa2xx-pci.c

209

ssp->port_id = 5;

drivers/spi/spi-pxa2xx-pci.c

215

ssp->port_id = 6;

drivers/spi/spi-pxa2xx-pci.c

224

ret = pxa2xx_spi_pci_clk_register(dev, ssp, 25000000);

drivers/spi/spi-pxa2xx-pci.c

251

struct ssp_device *ssp = &c->ssp;

drivers/spi/spi-pxa2xx-pci.c

253

ssp->type = QUARK_X1000_SSP;

drivers/spi/spi-pxa2xx-pci.c

254

ssp->port_id = dev->devfn;

drivers/spi/spi-pxa2xx-pci.c

257

return pxa2xx_spi_pci_clk_register(dev, ssp, 50000000);

drivers/spi/spi-pxa2xx-pci.c

270

struct ssp_device *ssp;

drivers/spi/spi-pxa2xx-pci.c

280

ssp = &pdata->ssp;

drivers/spi/spi-pxa2xx-pci.c

281

ssp->dev = &dev->dev;

drivers/spi/spi-pxa2xx-pci.c

282

ssp->phys_base = pci_resource_start(dev, 0);

drivers/spi/spi-pxa2xx-pci.c

283

ssp->mmio_base = pcim_iomap_region(dev, 0, "PXA2xx SPI");

drivers/spi/spi-pxa2xx-pci.c

284

if (IS_ERR(ssp->mmio_base))

drivers/spi/spi-pxa2xx-pci.c

285

return PTR_ERR(ssp->mmio_base);

drivers/spi/spi-pxa2xx-pci.c

297

ssp->irq = pci_irq_vector(dev, 0);

drivers/spi/spi-pxa2xx-pci.c

299

ret = pxa2xx_spi_probe(&dev->dev, ssp, pdata);

drivers/spi/spi-pxa2xx-pci.c

67

static int pxa2xx_spi_pci_clk_register(struct pci_dev *dev, struct ssp_device *ssp,

drivers/spi/spi-pxa2xx-pci.c

72

snprintf(buf, sizeof(buf), "pxa2xx-spi.%d", ssp->port_id);

drivers/spi/spi-pxa2xx-pci.c

73

ssp->clk = clk_register_fixed_rate(&dev->dev, buf, NULL, 0, rate);

drivers/spi/spi-pxa2xx-pci.c

74

if (IS_ERR(ssp->clk))

drivers/spi/spi-pxa2xx-pci.c

75

return PTR_ERR(ssp->clk);

drivers/spi/spi-pxa2xx-pci.c

77

return devm_add_action_or_reset(&dev->dev, pxa2xx_spi_pci_clk_unregister, ssp->clk);

drivers/spi/spi-pxa2xx-pci.c

98

struct ssp_device *ssp = &c->ssp;

drivers/spi/spi-pxa2xx-platform.c

130

if (ssp)

drivers/spi/spi-pxa2xx-platform.c

133

status = pxa2xx_spi_init_ssp(pdev, &pdata->ssp, type);

drivers/spi/spi-pxa2xx-platform.c

144

struct ssp_device *ssp;

drivers/spi/spi-pxa2xx-platform.c

154

ssp = pxa2xx_spi_ssp_request(pdev);

drivers/spi/spi-pxa2xx-platform.c

155

if (IS_ERR(ssp))

drivers/spi/spi-pxa2xx-platform.c

156

return PTR_ERR(ssp);

drivers/spi/spi-pxa2xx-platform.c

157

if (!ssp)

drivers/spi/spi-pxa2xx-platform.c

158

ssp = &platform_info->ssp;

drivers/spi/spi-pxa2xx-platform.c

165

ret = pxa2xx_spi_probe(dev, ssp, platform_info);

drivers/spi/spi-pxa2xx-platform.c

21

pxa2xx_spi_init_ssp(struct platform_device *pdev, struct ssp_device *ssp, enum pxa_ssp_type type)

drivers/spi/spi-pxa2xx-platform.c

28

ssp->mmio_base = devm_platform_get_and_ioremap_resource(pdev, 0, &res);

drivers/spi/spi-pxa2xx-platform.c

29

if (IS_ERR(ssp->mmio_base))

drivers/spi/spi-pxa2xx-platform.c

30

return PTR_ERR(ssp->mmio_base);

drivers/spi/spi-pxa2xx-platform.c

32

ssp->phys_base = res->start;

drivers/spi/spi-pxa2xx-platform.c

34

ssp->clk = devm_clk_get(dev, NULL);

drivers/spi/spi-pxa2xx-platform.c

35

if (IS_ERR(ssp->clk))

drivers/spi/spi-pxa2xx-platform.c

36

return PTR_ERR(ssp->clk);

drivers/spi/spi-pxa2xx-platform.c

38

ssp->irq = platform_get_irq(pdev, 0);

drivers/spi/spi-pxa2xx-platform.c

39

if (ssp->irq < 0)

drivers/spi/spi-pxa2xx-platform.c

40

return ssp->irq;

drivers/spi/spi-pxa2xx-platform.c

42

ssp->type = type;

drivers/spi/spi-pxa2xx-platform.c

43

ssp->dev = dev;

drivers/spi/spi-pxa2xx-platform.c

47

ssp->port_id = -1;

drivers/spi/spi-pxa2xx-platform.c

49

ssp->port_id = uid;

drivers/spi/spi-pxa2xx-platform.c

54

static void pxa2xx_spi_ssp_release(void *ssp)

drivers/spi/spi-pxa2xx-platform.c

56

pxa_ssp_free(ssp);

drivers/spi/spi-pxa2xx-platform.c

61

struct ssp_device *ssp;

drivers/spi/spi-pxa2xx-platform.c

64

ssp = pxa_ssp_request(pdev->id, pdev->name);

drivers/spi/spi-pxa2xx-platform.c

65

if (!ssp)

drivers/spi/spi-pxa2xx-platform.c

68

status = devm_add_action_or_reset(&pdev->dev, pxa2xx_spi_ssp_release, ssp);

drivers/spi/spi-pxa2xx-platform.c

72

return ssp;

drivers/spi/spi-pxa2xx-platform.c

83

struct ssp_device *ssp;

drivers/spi/spi-pxa2xx-platform.c

88

ssp = pxa2xx_spi_ssp_request(pdev);

drivers/spi/spi-pxa2xx-platform.c

89

if (IS_ERR(ssp))

drivers/spi/spi-pxa2xx-platform.c

90

return ERR_CAST(ssp);

drivers/spi/spi-pxa2xx-platform.c

91

if (ssp) {

drivers/spi/spi-pxa2xx-platform.c

92

type = ssp->type;

drivers/spi/spi-pxa2xx.c

1044

pxa_ssp_disable(drv_data->ssp);

drivers/spi/spi-pxa2xx.c

1056

pxa_ssp_enable(drv_data->ssp);

drivers/spi/spi-pxa2xx.c

1271

int pxa2xx_spi_probe(struct device *dev, struct ssp_device *ssp,

drivers/spi/spi-pxa2xx.c

1290

drv_data->ssp = ssp;

drivers/spi/spi-pxa2xx.c

1295

controller->bus_num = ssp->port_id;

drivers/spi/spi-pxa2xx.c

1308

drv_data->ssp_type = ssp->type;

drivers/spi/spi-pxa2xx.c

1333

status = request_irq(ssp->irq, ssp_int, IRQF_SHARED, dev_name(dev),

drivers/spi/spi-pxa2xx.c

1336

return dev_err_probe(dev, status, "cannot get IRQ %d\n", ssp->irq);

drivers/spi/spi-pxa2xx.c

1355

status = clk_prepare_enable(ssp->clk);

drivers/spi/spi-pxa2xx.c

1359

controller->max_speed_hz = clk_get_rate(ssp->clk);

drivers/spi/spi-pxa2xx.c

1371

pxa_ssp_disable(ssp);

drivers/spi/spi-pxa2xx.c

1452

clk_disable_unprepare(ssp->clk);

drivers/spi/spi-pxa2xx.c

1456

free_irq(ssp->irq, drv_data);

drivers/spi/spi-pxa2xx.c

1465

struct ssp_device *ssp = drv_data->ssp;

drivers/spi/spi-pxa2xx.c

1470

pxa_ssp_disable(ssp);

drivers/spi/spi-pxa2xx.c

1471

clk_disable_unprepare(ssp->clk);

drivers/spi/spi-pxa2xx.c

1478

free_irq(ssp->irq, drv_data);

drivers/spi/spi-pxa2xx.c

1485

struct ssp_device *ssp = drv_data->ssp;

drivers/spi/spi-pxa2xx.c

1492

pxa_ssp_disable(ssp);

drivers/spi/spi-pxa2xx.c

1495

clk_disable_unprepare(ssp->clk);

drivers/spi/spi-pxa2xx.c

1503

struct ssp_device *ssp = drv_data->ssp;

drivers/spi/spi-pxa2xx.c

1508

status = clk_prepare_enable(ssp->clk);

drivers/spi/spi-pxa2xx.c

1521

clk_disable_unprepare(drv_data->ssp->clk);

drivers/spi/spi-pxa2xx.c

1529

return clk_prepare_enable(drv_data->ssp->clk);

drivers/spi/spi-pxa2xx.c

352

drv_data->lpss_base = drv_data->ssp->mmio_base + config->offset;

drivers/spi/spi-pxa2xx.c

478

pxa_ssp_disable(drv_data->ssp);

drivers/spi/spi-pxa2xx.c

617

dev_err(drv_data->ssp->dev, "%s\n", msg);

drivers/spi/spi-pxa2xx.c

713

dev_err(drv_data->ssp->dev, "bad message state in interrupt handler\n");

drivers/spi/spi-pxa2xx.c

729

if (pm_runtime_suspended(drv_data->ssp->dev))

drivers/spi/spi-pxa2xx.c

891

const struct ssp_device *ssp = drv_data->ssp;

drivers/spi/spi-pxa2xx.c

899

if (ssp->type == PXA25x_SSP || ssp->type == CE4100_SSP)

drivers/spi/spi-pxa2xx.h

135

int pxa2xx_spi_probe(struct device *dev, struct ssp_device *ssp,

drivers/spi/spi-pxa2xx.h

36

struct ssp_device ssp;

drivers/spi/spi-pxa2xx.h

45

struct ssp_device *ssp;

drivers/spi/spi-pxa2xx.h

81

return pxa_ssp_read_reg(drv_data->ssp, reg);

drivers/spi/spi-pxa2xx.h

86

pxa_ssp_write_reg(drv_data->ssp, reg, val);

drivers/tty/serial/sifive.c

1008

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

drivers/tty/serial/sifive.c

1009

if (!ssp)

drivers/tty/serial/sifive.c

1012

ssp->port.dev = &pdev->dev;

drivers/tty/serial/sifive.c

1013

ssp->port.type = PORT_SIFIVE_V0;

drivers/tty/serial/sifive.c

1014

ssp->port.iotype = UPIO_MEM;

drivers/tty/serial/sifive.c

1015

ssp->port.irq = irq;

drivers/tty/serial/sifive.c

1016

ssp->port.fifosize = SIFIVE_TX_FIFO_DEPTH;

drivers/tty/serial/sifive.c

1017

ssp->port.ops = &sifive_serial_uops;

drivers/tty/serial/sifive.c

1018

ssp->port.line = id;

drivers/tty/serial/sifive.c

1019

ssp->port.mapbase = mem->start;

drivers/tty/serial/sifive.c

1020

ssp->port.membase = base;

drivers/tty/serial/sifive.c

1021

ssp->dev = &pdev->dev;

drivers/tty/serial/sifive.c

1022

ssp->clk = clk;

drivers/tty/serial/sifive.c

1023

ssp->clk_notifier.notifier_call = sifive_serial_clk_notifier;

drivers/tty/serial/sifive.c

1025

r = clk_notifier_register(ssp->clk, &ssp->clk_notifier);

drivers/tty/serial/sifive.c

1033

ssp->port.uartclk = clk_get_rate(ssp->clk);

drivers/tty/serial/sifive.c

1034

ssp->baud_rate = SIFIVE_DEFAULT_BAUD_RATE;

drivers/tty/serial/sifive.c

1035

__ssp_update_div(ssp);

drivers/tty/serial/sifive.c

1037

platform_set_drvdata(pdev, ssp);

drivers/tty/serial/sifive.c

1042

SIFIVE_SERIAL_TXCTRL_OFFS, ssp);

drivers/tty/serial/sifive.c

1047

SIFIVE_SERIAL_RXCTRL_OFFS, ssp);

drivers/tty/serial/sifive.c

1049

r = request_irq(ssp->port.irq, sifive_serial_irq, ssp->port.irqflags,

drivers/tty/serial/sifive.c

1050

dev_name(&pdev->dev), ssp);

drivers/tty/serial/sifive.c

1056

__ssp_add_console_port(ssp);

drivers/tty/serial/sifive.c

1058

r = uart_add_one_port(&sifive_serial_uart_driver, &ssp->port);

drivers/tty/serial/sifive.c

1067

__ssp_remove_console_port(ssp);

drivers/tty/serial/sifive.c

1068

free_irq(ssp->port.irq, ssp);

drivers/tty/serial/sifive.c

1070

clk_notifier_unregister(ssp->clk, &ssp->clk_notifier);

drivers/tty/serial/sifive.c

1077

struct sifive_serial_port *ssp = platform_get_drvdata(dev);

drivers/tty/serial/sifive.c

1079

__ssp_remove_console_port(ssp);

drivers/tty/serial/sifive.c

1080

uart_remove_one_port(&sifive_serial_uart_driver, &ssp->port);

drivers/tty/serial/sifive.c

1081

free_irq(ssp->port.irq, ssp);

drivers/tty/serial/sifive.c

1082

clk_notifier_unregister(ssp->clk, &ssp->clk_notifier);

drivers/tty/serial/sifive.c

1087

struct sifive_serial_port *ssp = dev_get_drvdata(dev);

drivers/tty/serial/sifive.c

1089

return uart_suspend_port(&sifive_serial_uart_driver, &ssp->port);

drivers/tty/serial/sifive.c

1094

struct sifive_serial_port *ssp = dev_get_drvdata(dev);

drivers/tty/serial/sifive.c

1096

return uart_resume_port(&sifive_serial_uart_driver, &ssp->port);

drivers/tty/serial/sifive.c

227

static void __ssp_writel(u32 v, u16 offs, struct sifive_serial_port *ssp)

drivers/tty/serial/sifive.c

229

__ssp_early_writel(v, offs, &ssp->port);

drivers/tty/serial/sifive.c

244

static u32 __ssp_readl(struct sifive_serial_port *ssp, u16 offs)

drivers/tty/serial/sifive.c

246

return __ssp_early_readl(&ssp->port, offs);

drivers/tty/serial/sifive.c

260

static int sifive_serial_is_txfifo_full(struct sifive_serial_port *ssp)

drivers/tty/serial/sifive.c

262

return __ssp_readl(ssp, SIFIVE_SERIAL_TXDATA_OFFS) &

drivers/tty/serial/sifive.c

277

static void __ssp_transmit_char(struct sifive_serial_port *ssp, int ch)

drivers/tty/serial/sifive.c

279

__ssp_writel(ch, SIFIVE_SERIAL_TXDATA_OFFS, ssp);

drivers/tty/serial/sifive.c

291

static void __ssp_transmit_chars(struct sifive_serial_port *ssp)

drivers/tty/serial/sifive.c

295

uart_port_tx_limited(&ssp->port, ch, SIFIVE_TX_FIFO_DEPTH,

drivers/tty/serial/sifive.c

297

__ssp_transmit_char(ssp, ch),

drivers/tty/serial/sifive.c

308

static void __ssp_enable_txwm(struct sifive_serial_port *ssp)

drivers/tty/serial/sifive.c

310

if (ssp->ier & SIFIVE_SERIAL_IE_TXWM_MASK)

drivers/tty/serial/sifive.c

313

ssp->ier |= SIFIVE_SERIAL_IE_TXWM_MASK;

drivers/tty/serial/sifive.c

314

__ssp_writel(ssp->ier, SIFIVE_SERIAL_IE_OFFS, ssp);

drivers/tty/serial/sifive.c

324

static void __ssp_enable_rxwm(struct sifive_serial_port *ssp)

drivers/tty/serial/sifive.c

326

if (ssp->ier & SIFIVE_SERIAL_IE_RXWM_MASK)

drivers/tty/serial/sifive.c

329

ssp->ier |= SIFIVE_SERIAL_IE_RXWM_MASK;

drivers/tty/serial/sifive.c

330

__ssp_writel(ssp->ier, SIFIVE_SERIAL_IE_OFFS, ssp);

drivers/tty/serial/sifive.c

340

static void __ssp_disable_txwm(struct sifive_serial_port *ssp)

drivers/tty/serial/sifive.c

342

if (!(ssp->ier & SIFIVE_SERIAL_IE_TXWM_MASK))

drivers/tty/serial/sifive.c

345

ssp->ier &= ~SIFIVE_SERIAL_IE_TXWM_MASK;

drivers/tty/serial/sifive.c

346

__ssp_writel(ssp->ier, SIFIVE_SERIAL_IE_OFFS, ssp);

drivers/tty/serial/sifive.c

356

static void __ssp_disable_rxwm(struct sifive_serial_port *ssp)

drivers/tty/serial/sifive.c

358

if (!(ssp->ier & SIFIVE_SERIAL_IE_RXWM_MASK))

drivers/tty/serial/sifive.c

361

ssp->ier &= ~SIFIVE_SERIAL_IE_RXWM_MASK;

drivers/tty/serial/sifive.c

362

__ssp_writel(ssp->ier, SIFIVE_SERIAL_IE_OFFS, ssp);

drivers/tty/serial/sifive.c

377

static char __ssp_receive_char(struct sifive_serial_port *ssp, char *is_empty)

drivers/tty/serial/sifive.c

382

v = __ssp_readl(ssp, SIFIVE_SERIAL_RXDATA_OFFS);

drivers/tty/serial/sifive.c

405

static void __ssp_receive_chars(struct sifive_serial_port *ssp)

drivers/tty/serial/sifive.c

412

ch = __ssp_receive_char(ssp, &is_empty);

drivers/tty/serial/sifive.c

416

ssp->port.icount.rx++;

drivers/tty/serial/sifive.c

417

if (!uart_prepare_sysrq_char(&ssp->port, ch))

drivers/tty/serial/sifive.c

418

uart_insert_char(&ssp->port, 0, 0, ch, TTY_NORMAL);

drivers/tty/serial/sifive.c

421

tty_flip_buffer_push(&ssp->port.state->port);

drivers/tty/serial/sifive.c

432

static void __ssp_update_div(struct sifive_serial_port *ssp)

drivers/tty/serial/sifive.c

436

div = DIV_ROUND_UP(ssp->port.uartclk, ssp->baud_rate) - 1;

drivers/tty/serial/sifive.c

438

__ssp_writel(div, SIFIVE_SERIAL_DIV_OFFS, ssp);

drivers/tty/serial/sifive.c

451

static void __ssp_update_baud_rate(struct sifive_serial_port *ssp,

drivers/tty/serial/sifive.c

454

if (ssp->baud_rate == rate)

drivers/tty/serial/sifive.c

457

ssp->baud_rate = rate;

drivers/tty/serial/sifive.c

458

__ssp_update_div(ssp);

drivers/tty/serial/sifive.c

468

static void __ssp_set_stop_bits(struct sifive_serial_port *ssp, char nstop)

drivers/tty/serial/sifive.c

477

v = __ssp_readl(ssp, SIFIVE_SERIAL_TXCTRL_OFFS);

drivers/tty/serial/sifive.c

480

__ssp_writel(v, SIFIVE_SERIAL_TXCTRL_OFFS, ssp);

drivers/tty/serial/sifive.c

491

static void __maybe_unused __ssp_wait_for_xmitr(struct sifive_serial_port *ssp)

drivers/tty/serial/sifive.c

493

while (sifive_serial_is_txfifo_full(ssp))

drivers/tty/serial/sifive.c

503

struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);

drivers/tty/serial/sifive.c

505

__ssp_disable_txwm(ssp);

drivers/tty/serial/sifive.c

510

struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);

drivers/tty/serial/sifive.c

512

__ssp_disable_rxwm(ssp);

drivers/tty/serial/sifive.c

517

struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);

drivers/tty/serial/sifive.c

519

__ssp_enable_txwm(ssp);

drivers/tty/serial/sifive.c

524

struct sifive_serial_port *ssp = dev_id;

drivers/tty/serial/sifive.c

527

uart_port_lock(&ssp->port);

drivers/tty/serial/sifive.c

529

ip = __ssp_readl(ssp, SIFIVE_SERIAL_IP_OFFS);

drivers/tty/serial/sifive.c

531

uart_port_unlock(&ssp->port);

drivers/tty/serial/sifive.c

536

__ssp_receive_chars(ssp);

drivers/tty/serial/sifive.c

538

__ssp_transmit_chars(ssp);

drivers/tty/serial/sifive.c

540

uart_unlock_and_check_sysrq(&ssp->port);

drivers/tty/serial/sifive.c

567

struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);

drivers/tty/serial/sifive.c

570

uart_port_lock_irqsave(&ssp->port, &flags);

drivers/tty/serial/sifive.c

571

__ssp_enable_rxwm(ssp);

drivers/tty/serial/sifive.c

572

uart_port_unlock_irqrestore(&ssp->port, flags);

drivers/tty/serial/sifive.c

579

struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);

drivers/tty/serial/sifive.c

582

uart_port_lock_irqsave(&ssp->port, &flags);

drivers/tty/serial/sifive.c

583

__ssp_disable_rxwm(ssp);

drivers/tty/serial/sifive.c

584

__ssp_disable_txwm(ssp);

drivers/tty/serial/sifive.c

585

uart_port_unlock_irqrestore(&ssp->port, flags);

drivers/tty/serial/sifive.c

605

struct sifive_serial_port *ssp = notifier_to_sifive_serial_port(nb);

drivers/tty/serial/sifive.c

614

__ssp_wait_for_xmitr(ssp);

drivers/tty/serial/sifive.c

624

udelay(DIV_ROUND_UP(12 * 1000 * 1000, ssp->baud_rate));

drivers/tty/serial/sifive.c

627

if (event == POST_RATE_CHANGE && ssp->port.uartclk != cnd->new_rate) {

drivers/tty/serial/sifive.c

628

ssp->port.uartclk = cnd->new_rate;

drivers/tty/serial/sifive.c

629

__ssp_update_div(ssp);

drivers/tty/serial/sifive.c

639

struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);

drivers/tty/serial/sifive.c

646

dev_err_once(ssp->port.dev, "only 8-bit words supported\n");

drivers/tty/serial/sifive.c

651

dev_err_once(ssp->port.dev, "parity checking not supported\n");

drivers/tty/serial/sifive.c

653

dev_err_once(ssp->port.dev, "BREAK detection not supported\n");

drivers/tty/serial/sifive.c

658

__ssp_set_stop_bits(ssp, nstop);

drivers/tty/serial/sifive.c

662

ssp->port.uartclk / 16);

drivers/tty/serial/sifive.c

663

__ssp_update_baud_rate(ssp, rate);

drivers/tty/serial/sifive.c

665

uart_port_lock_irqsave(&ssp->port, &flags);

drivers/tty/serial/sifive.c

670

ssp->port.read_status_mask = 0;

drivers/tty/serial/sifive.c

673

v = __ssp_readl(ssp, SIFIVE_SERIAL_RXCTRL_OFFS);

drivers/tty/serial/sifive.c

680

__ssp_writel(v, SIFIVE_SERIAL_RXCTRL_OFFS, ssp);

drivers/tty/serial/sifive.c

682

uart_port_unlock_irqrestore(&ssp->port, flags);

drivers/tty/serial/sifive.c

696

struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);

drivers/tty/serial/sifive.c

698

ssp->port.type = PORT_SIFIVE_V0;

drivers/tty/serial/sifive.c

715

struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);

drivers/tty/serial/sifive.c

718

ch = __ssp_receive_char(ssp, &is_empty);

drivers/tty/serial/sifive.c

728

struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);

drivers/tty/serial/sifive.c

730

__ssp_wait_for_xmitr(ssp);

drivers/tty/serial/sifive.c

731

__ssp_transmit_char(ssp, c);

drivers/tty/serial/sifive.c

786

struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);

drivers/tty/serial/sifive.c

788

__ssp_wait_for_xmitr(ssp);

drivers/tty/serial/sifive.c

789

__ssp_transmit_char(ssp, ch);

drivers/tty/serial/sifive.c

791

ssp->console_line_ended = (ch == '\n');

drivers/tty/serial/sifive.c

811

struct sifive_serial_port *ssp = sifive_serial_console_ports[co->index];

drivers/tty/serial/sifive.c

812

struct uart_port *port = &ssp->port;

drivers/tty/serial/sifive.c

815

if (!ssp)

drivers/tty/serial/sifive.c

821

ier = __ssp_readl(ssp, SIFIVE_SERIAL_IE_OFFS);

drivers/tty/serial/sifive.c

822

__ssp_writel(0, SIFIVE_SERIAL_IE_OFFS, ssp);

drivers/tty/serial/sifive.c

824

if (!ssp->console_line_ended)

drivers/tty/serial/sifive.c

829

__ssp_writel(ier, SIFIVE_SERIAL_IE_OFFS, ssp);

drivers/tty/serial/sifive.c

837

struct sifive_serial_port *ssp = sifive_serial_console_ports[co->index];

drivers/tty/serial/sifive.c

838

struct uart_port *port = &ssp->port;

drivers/tty/serial/sifive.c

841

if (!ssp)

drivers/tty/serial/sifive.c

847

ier = __ssp_readl(ssp, SIFIVE_SERIAL_IE_OFFS);

drivers/tty/serial/sifive.c

848

__ssp_writel(0, SIFIVE_SERIAL_IE_OFFS, ssp);

drivers/tty/serial/sifive.c

869

__ssp_writel(ier, SIFIVE_SERIAL_IE_OFFS, ssp);

drivers/tty/serial/sifive.c

876

struct sifive_serial_port *ssp;

drivers/tty/serial/sifive.c

885

ssp = sifive_serial_console_ports[co->index];

drivers/tty/serial/sifive.c

886

if (!ssp)

drivers/tty/serial/sifive.c

889

ssp->console_line_ended = true;

drivers/tty/serial/sifive.c

894

return uart_set_options(&ssp->port, co, baud, parity, bits, flow);

drivers/tty/serial/sifive.c

920

static void __ssp_add_console_port(struct sifive_serial_port *ssp)

drivers/tty/serial/sifive.c

922

sifive_serial_console_ports[ssp->port.line] = ssp;

drivers/tty/serial/sifive.c

925

static void __ssp_remove_console_port(struct sifive_serial_port *ssp)

drivers/tty/serial/sifive.c

927

sifive_serial_console_ports[ssp->port.line] = NULL;

drivers/tty/serial/sifive.c

936

static void __ssp_add_console_port(struct sifive_serial_port *ssp)

drivers/tty/serial/sifive.c

938

static void __ssp_remove_console_port(struct sifive_serial_port *ssp)

drivers/tty/serial/sifive.c

975

struct sifive_serial_port *ssp;

drivers/usb/gadget/composite.c

684

int ssp = 0;

drivers/usb/gadget/composite.c

692

ssp = 1;

drivers/usb/gadget/composite.c

698

if (ssp) {

drivers/usb/gadget/config.c

110

struct usb_descriptor_header **ssp)

drivers/usb/gadget/config.c

117

if (!ssp)

drivers/usb/gadget/config.c

118

ssp = ss;

drivers/usb/gadget/config.c

135

if (ssp) {

drivers/usb/gadget/config.c

136

f->ssp_descriptors = usb_copy_descriptors(ssp);

fs/nilfs2/segment.c

1605

struct nilfs_segsum_pointer ssp;

fs/nilfs2/segment.c

1616

ssp.bh = NILFS_SEGBUF_FIRST_BH(&segbuf->sb_segsum_buffers);

fs/nilfs2/segment.c

1617

ssp.offset = sizeof(struct nilfs_segment_summary);

fs/nilfs2/segment.c

1624

sci, &ssp, sizeof(*finfo));

fs/nilfs2/segment.c

1649

sc_op->write_data_binfo(sci, &ssp, &binfo);

fs/nilfs2/segment.c

1651

sc_op->write_node_binfo(sci, &ssp, &binfo);

fs/nilfs2/segment.c

389

struct nilfs_segsum_pointer *ssp,

fs/nilfs2/segment.c

396

if (unlikely(ssp->offset + bytes > blocksize)) {

fs/nilfs2/segment.c

397

ssp->offset = 0;

fs/nilfs2/segment.c

398

BUG_ON(NILFS_SEGBUF_BH_IS_LAST(ssp->bh,

fs/nilfs2/segment.c

400

ssp->bh = NILFS_SEGBUF_NEXT_BH(ssp->bh);

fs/nilfs2/segment.c

402

p = ssp->bh->b_data + ssp->offset;

fs/nilfs2/segment.c

403

ssp->offset += bytes;

fs/nilfs2/segment.c

444

struct nilfs_segsum_pointer *ssp;

fs/nilfs2/segment.c

446

ssp = sci->sc_blk_cnt > 0 ? &sci->sc_binfo_ptr : &sci->sc_finfo_ptr;

fs/nilfs2/segment.c

447

if (ssp->offset < ssp->bh->b_size)

fs/nilfs2/segment.c

448

memset(ssp->bh->b_data + ssp->offset, 0,

fs/nilfs2/segment.c

449

ssp->bh->b_size - ssp->offset);

fs/nilfs2/segment.c

486

struct nilfs_sc_info *sci, const struct nilfs_segsum_pointer *ssp,

fs/nilfs2/segment.c

492

return ssp->offset + binfo_size +

fs/nilfs2/segment.c

616

struct nilfs_segsum_pointer *ssp,

fs/nilfs2/segment.c

620

sci, ssp, sizeof(*binfo_v));

fs/nilfs2/segment.c

625

struct nilfs_segsum_pointer *ssp,

fs/nilfs2/segment.c

629

sci, ssp, sizeof(*vblocknr));

fs/nilfs2/segment.c

665

struct nilfs_segsum_pointer *ssp,

fs/nilfs2/segment.c

668

__le64 *blkoff = nilfs_segctor_map_segsum_entry(sci, ssp,

fs/nilfs2/segment.c

674

struct nilfs_segsum_pointer *ssp,

fs/nilfs2/segment.c

678

nilfs_segctor_map_segsum_entry(sci, ssp, sizeof(*binfo_dat));

include/linux/pxa2xx_ssp.h

275

static inline void pxa_ssp_enable(struct ssp_device *ssp)

include/linux/pxa2xx_ssp.h

279

sscr0 = pxa_ssp_read_reg(ssp, SSCR0) | SSCR0_SSE;

include/linux/pxa2xx_ssp.h

280

pxa_ssp_write_reg(ssp, SSCR0, sscr0);

include/linux/pxa2xx_ssp.h

283

static inline void pxa_ssp_disable(struct ssp_device *ssp)

include/linux/pxa2xx_ssp.h

287

sscr0 = pxa_ssp_read_reg(ssp, SSCR0) & ~SSCR0_SSE;

include/linux/pxa2xx_ssp.h

288

pxa_ssp_write_reg(ssp, SSCR0, sscr0);

include/linux/pxa2xx_ssp.h

306

static inline void pxa_ssp_free(struct ssp_device *ssp) {}

include/linux/spi/mxs-spi.h

133

void mxs_ssp_set_clk_rate(struct mxs_ssp *ssp, unsigned int rate);

include/linux/srcu.h

108

unsigned long get_state_synchronize_srcu(struct srcu_struct *ssp);

include/linux/srcu.h

109

unsigned long start_poll_synchronize_srcu(struct srcu_struct *ssp);

include/linux/srcu.h

110

bool poll_state_synchronize_srcu(struct srcu_struct *ssp, unsigned long cookie);

include/linux/srcu.h

134

int __srcu_read_lock_nmisafe(struct srcu_struct *ssp) __acquires_shared(ssp);

include/linux/srcu.h

135

void __srcu_read_unlock_nmisafe(struct srcu_struct *ssp, int idx) __releases_shared(ssp);

include/linux/srcu.h

137

static inline int __srcu_read_lock_nmisafe(struct srcu_struct *ssp)

include/linux/srcu.h

138

__acquires_shared(ssp)

include/linux/srcu.h

140

return __srcu_read_lock(ssp);

include/linux/srcu.h

142

static inline void __srcu_read_unlock_nmisafe(struct srcu_struct *ssp, int idx)

include/linux/srcu.h

143

__releases_shared(ssp)

include/linux/srcu.h

145

__srcu_read_unlock(ssp, idx);

include/linux/srcu.h

169

static inline int srcu_read_lock_held(const struct srcu_struct *ssp)

include/linux/srcu.h

173

return lock_is_held(&ssp->dep_map);

include/linux/srcu.h

204

static inline int srcu_read_lock_held(const struct srcu_struct *ssp)

include/linux/srcu.h

222

static inline void __srcu_read_lock_must_hold(const struct srcu_struct *ssp) __must_hold_shared(ssp) { }

include/linux/srcu.h

236

#define srcu_dereference_check(p, ssp, c) \

include/linux/srcu.h

238

__srcu_read_lock_must_hold(ssp); \

include/linux/srcu.h

241

(c) || srcu_read_lock_held(ssp), __rcu); \

include/linux/srcu.h

256

#define srcu_dereference(p, ssp) srcu_dereference_check((p), (ssp), 0)

include/linux/srcu.h

264

#define srcu_dereference_notrace(p, ssp) srcu_dereference_check((p), (ssp), 1)

include/linux/srcu.h

28

int __init_srcu_struct(struct srcu_struct *ssp, const char *name, struct lock_class_key *key);

include/linux/srcu.h

287

static inline int srcu_read_lock(struct srcu_struct *ssp)

include/linux/srcu.h

288

__acquires_shared(ssp)

include/linux/srcu.h

292

srcu_check_read_flavor(ssp, SRCU_READ_FLAVOR_NORMAL);

include/linux/srcu.h

293

retval = __srcu_read_lock(ssp);

include/linux/srcu.h

294

srcu_lock_acquire(&ssp->dep_map);

include/linux/srcu.h

30

int __init_srcu_struct_fast(struct srcu_struct *ssp, const char *name, struct lock_class_key *key);

include/linux/srcu.h

31

int __init_srcu_struct_fast_updown(struct srcu_struct *ssp, const char *name,

include/linux/srcu.h

324

static inline struct srcu_ctr __percpu *srcu_read_lock_fast(struct srcu_struct *ssp) __acquires_shared(ssp)

include/linux/srcu.h

325

__acquires_shared(ssp)

include/linux/srcu.h

330

srcu_check_read_flavor(ssp, SRCU_READ_FLAVOR_FAST);

include/linux/srcu.h

331

retval = __srcu_read_lock_fast(ssp);

include/linux/srcu.h

332

rcu_try_lock_acquire(&ssp->dep_map);

include/linux/srcu.h

35

#define init_srcu_struct(ssp) \

include/linux/srcu.h

364

static inline struct srcu_ctr __percpu *srcu_read_lock_fast_updown(struct srcu_struct *ssp)

include/linux/srcu.h

365

__acquires_shared(ssp)

include/linux/srcu.h

370

srcu_check_read_flavor(ssp, SRCU_READ_FLAVOR_FAST_UPDOWN);

include/linux/srcu.h

371

retval = __srcu_read_lock_fast_updown(ssp);

include/linux/srcu.h

372

rcu_try_lock_acquire(&ssp->dep_map);

include/linux/srcu.h

380

static inline struct srcu_ctr __percpu *srcu_read_lock_fast_notrace(struct srcu_struct *ssp)

include/linux/srcu.h

381

__acquires_shared(ssp)

include/linux/srcu.h

385

srcu_check_read_flavor(ssp, SRCU_READ_FLAVOR_FAST);

include/linux/srcu.h

386

retval = __srcu_read_lock_fast(ssp);

include/linux/srcu.h

39

__init_srcu_struct((ssp), #ssp, &__srcu_key); \

include/linux/srcu.h

402

static inline struct srcu_ctr __percpu *srcu_down_read_fast(struct srcu_struct *ssp) __acquires_shared(ssp)

include/linux/srcu.h

406

srcu_check_read_flavor(ssp, SRCU_READ_FLAVOR_FAST_UPDOWN);

include/linux/srcu.h

407

return __srcu_read_lock_fast_updown(ssp);

include/linux/srcu.h

42

#define init_srcu_struct_fast(ssp) \

include/linux/srcu.h

421

static inline int srcu_read_lock_nmisafe(struct srcu_struct *ssp)

include/linux/srcu.h

422

__acquires_shared(ssp)

include/linux/srcu.h

426

srcu_check_read_flavor(ssp, SRCU_READ_FLAVOR_NMI);

include/linux/srcu.h

427

retval = __srcu_read_lock_nmisafe(ssp);

include/linux/srcu.h

428

rcu_try_lock_acquire(&ssp->dep_map);

include/linux/srcu.h

434

srcu_read_lock_notrace(struct srcu_struct *ssp)

include/linux/srcu.h

435

__acquires_shared(ssp)

include/linux/srcu.h

439

srcu_check_read_flavor(ssp, SRCU_READ_FLAVOR_NORMAL);

include/linux/srcu.h

440

retval = __srcu_read_lock(ssp);

include/linux/srcu.h

46

__init_srcu_struct_fast((ssp), #ssp, &__srcu_key); \

include/linux/srcu.h

466

static inline int srcu_down_read(struct srcu_struct *ssp)

include/linux/srcu.h

467

__acquires_shared(ssp)

include/linux/srcu.h

470

srcu_check_read_flavor(ssp, SRCU_READ_FLAVOR_NORMAL);

include/linux/srcu.h

471

return __srcu_read_lock(ssp);

include/linux/srcu.h

481

static inline void srcu_read_unlock(struct srcu_struct *ssp, int idx)

include/linux/srcu.h

482

__releases_shared(ssp)

include/linux/srcu.h

485

srcu_check_read_flavor(ssp, SRCU_READ_FLAVOR_NORMAL);

include/linux/srcu.h

486

srcu_lock_release(&ssp->dep_map);

include/linux/srcu.h

487

__srcu_read_unlock(ssp, idx);

include/linux/srcu.h

49

#define init_srcu_struct_fast_updown(ssp) \

include/linux/srcu.h

497

static inline void srcu_read_unlock_fast(struct srcu_struct *ssp, struct srcu_ctr __percpu *scp)

include/linux/srcu.h

498

__releases_shared(ssp)

include/linux/srcu.h

500

srcu_check_read_flavor(ssp, SRCU_READ_FLAVOR_FAST);

include/linux/srcu.h

501

srcu_lock_release(&ssp->dep_map);

include/linux/srcu.h

502

__srcu_read_unlock_fast(ssp, scp);

include/linux/srcu.h

514

srcu_read_unlock_fast_updown(struct srcu_struct *ssp, struct srcu_ctr __percpu *scp) __releases_shared(ssp)

include/linux/srcu.h

516

srcu_check_read_flavor(ssp, SRCU_READ_FLAVOR_FAST_UPDOWN);

include/linux/srcu.h

517

srcu_lock_release(&ssp->dep_map);

include/linux/srcu.h

518

__srcu_read_unlock_fast_updown(ssp, scp);

include/linux/srcu.h

527

static inline void srcu_read_unlock_fast_notrace(struct srcu_struct *ssp,

include/linux/srcu.h

528

struct srcu_ctr __percpu *scp) __releases_shared(ssp)

include/linux/srcu.h

53

__init_srcu_struct_fast_updown((ssp), #ssp, &__srcu_key); \

include/linux/srcu.h

530

srcu_check_read_flavor(ssp, SRCU_READ_FLAVOR_FAST);

include/linux/srcu.h

531

__srcu_read_unlock_fast(ssp, scp);

include/linux/srcu.h

542

static inline void srcu_up_read_fast(struct srcu_struct *ssp, struct srcu_ctr __percpu *scp)

include/linux/srcu.h

543

__releases_shared(ssp)

include/linux/srcu.h

546

srcu_check_read_flavor(ssp, SRCU_READ_FLAVOR_FAST_UPDOWN);

include/linux/srcu.h

547

__srcu_read_unlock_fast_updown(ssp, scp);

include/linux/srcu.h

558

static inline void srcu_read_unlock_nmisafe(struct srcu_struct *ssp, int idx)

include/linux/srcu.h

559

__releases_shared(ssp)

include/linux/srcu.h

562

srcu_check_read_flavor(ssp, SRCU_READ_FLAVOR_NMI);

include/linux/srcu.h

563

rcu_lock_release(&ssp->dep_map);

include/linux/srcu.h

564

__srcu_read_unlock_nmisafe(ssp, idx);

include/linux/srcu.h

569

srcu_read_unlock_notrace(struct srcu_struct *ssp, int idx) __releases_shared(ssp)

include/linux/srcu.h

571

srcu_check_read_flavor(ssp, SRCU_READ_FLAVOR_NORMAL);

include/linux/srcu.h

572

__srcu_read_unlock(ssp, idx);

include/linux/srcu.h

583

static inline void srcu_up_read(struct srcu_struct *ssp, int idx)

include/linux/srcu.h

584

__releases_shared(ssp)

include/linux/srcu.h

588

srcu_check_read_flavor(ssp, SRCU_READ_FLAVOR_NORMAL);

include/linux/srcu.h

589

__srcu_read_unlock(ssp, idx);

include/linux/srcu.h

59

int init_srcu_struct(struct srcu_struct *ssp);

include/linux/srcu.h

61

int init_srcu_struct_fast(struct srcu_struct *ssp);

include/linux/srcu.h

62

int init_srcu_struct_fast_updown(struct srcu_struct *ssp);

include/linux/srcu.h

80

void __srcu_read_unlock(struct srcu_struct *ssp, int idx) __releases_shared(ssp);

include/linux/srcu.h

90

void call_srcu(struct srcu_struct *ssp, struct rcu_head *head,

include/linux/srcu.h

92

void cleanup_srcu_struct(struct srcu_struct *ssp);

include/linux/srcu.h

93

void synchronize_srcu(struct srcu_struct *ssp);

include/linux/srcutiny.h

104

static inline struct srcu_ctr __percpu *__srcu_read_lock_fast(struct srcu_struct *ssp)

include/linux/srcutiny.h

105

__acquires_shared(ssp)

include/linux/srcutiny.h

107

return __srcu_ctr_to_ptr(ssp, __srcu_read_lock(ssp));

include/linux/srcutiny.h

110

static inline void __srcu_read_unlock_fast(struct srcu_struct *ssp, struct srcu_ctr __percpu *scp)

include/linux/srcutiny.h

111

__releases_shared(ssp)

include/linux/srcutiny.h

113

__srcu_read_unlock(ssp, __srcu_ptr_to_ctr(ssp, scp));

include/linux/srcutiny.h

116

static inline struct srcu_ctr __percpu *__srcu_read_lock_fast_updown(struct srcu_struct *ssp)

include/linux/srcutiny.h

117

__acquires_shared(ssp)

include/linux/srcutiny.h

119

return __srcu_ctr_to_ptr(ssp, __srcu_read_lock(ssp));

include/linux/srcutiny.h

123

void __srcu_read_unlock_fast_updown(struct srcu_struct *ssp, struct srcu_ctr __percpu *scp)

include/linux/srcutiny.h

124

__releases_shared(ssp)

include/linux/srcutiny.h

126

__srcu_read_unlock(ssp, __srcu_ptr_to_ctr(ssp, scp));

include/linux/srcutiny.h

129

static inline void synchronize_srcu_expedited(struct srcu_struct *ssp)

include/linux/srcutiny.h

131

synchronize_srcu(ssp);

include/linux/srcutiny.h

134

static inline void srcu_barrier(struct srcu_struct *ssp)

include/linux/srcutiny.h

136

synchronize_srcu(ssp);

include/linux/srcutiny.h

139

static inline void srcu_expedite_current(struct srcu_struct *ssp) { }

include/linux/srcutiny.h

140

#define srcu_check_read_flavor(ssp, read_flavor) do { } while (0)

include/linux/srcutiny.h

143

static inline void srcu_torture_stats_print(struct srcu_struct *ssp,

include/linux/srcutiny.h

148

idx = ((data_race(READ_ONCE(ssp->srcu_idx)) + 1) & 0x2) >> 1;

include/linux/srcutiny.h

151

data_race(READ_ONCE(ssp->srcu_lock_nesting[!idx])),

include/linux/srcutiny.h

152

data_race(READ_ONCE(ssp->srcu_lock_nesting[idx])),

include/linux/srcutiny.h

153

data_race(READ_ONCE(ssp->srcu_idx)),

include/linux/srcutiny.h

154

data_race(READ_ONCE(ssp->srcu_idx_max)));

include/linux/srcutiny.h

71

void synchronize_srcu(struct srcu_struct *ssp);

include/linux/srcutiny.h

79

static inline int __srcu_read_lock(struct srcu_struct *ssp)

include/linux/srcutiny.h

80

__acquires_shared(ssp)

include/linux/srcutiny.h

85

idx = ((READ_ONCE(ssp->srcu_idx) + 1) & 0x2) >> 1;

include/linux/srcutiny.h

86

WRITE_ONCE(ssp->srcu_lock_nesting[idx], READ_ONCE(ssp->srcu_lock_nesting[idx]) + 1);

include/linux/srcutiny.h

88

__acquire_shared(ssp);

include/linux/srcutiny.h

94

static inline bool __srcu_ptr_to_ctr(struct srcu_struct *ssp, struct srcu_ctr __percpu *scpp)

include/linux/srcutiny.h

99

static inline struct srcu_ctr __percpu *__srcu_ctr_to_ptr(struct srcu_struct *ssp, int idx)

include/linux/srcutree.h

237

int __srcu_read_lock(struct srcu_struct *ssp) __acquires_shared(ssp);

include/linux/srcutree.h

238

void synchronize_srcu_expedited(struct srcu_struct *ssp);

include/linux/srcutree.h

239

void srcu_barrier(struct srcu_struct *ssp);

include/linux/srcutree.h

240

void srcu_expedite_current(struct srcu_struct *ssp);

include/linux/srcutree.h

241

void srcu_torture_stats_print(struct srcu_struct *ssp, char *tt, char *tf);

include/linux/srcutree.h

245

static inline bool __srcu_ptr_to_ctr(struct srcu_struct *ssp, struct srcu_ctr __percpu *scpp)

include/linux/srcutree.h

247

return scpp - &ssp->sda->srcu_ctrs[0];

include/linux/srcutree.h

252

static inline struct srcu_ctr __percpu *__srcu_ctr_to_ptr(struct srcu_struct *ssp, int idx)

include/linux/srcutree.h

254

return &ssp->sda->srcu_ctrs[idx];

include/linux/srcutree.h

289

static inline struct srcu_ctr __percpu notrace *__srcu_read_lock_fast(struct srcu_struct *ssp)

include/linux/srcutree.h

290

__acquires_shared(ssp)

include/linux/srcutree.h

292

struct srcu_ctr __percpu *scp = READ_ONCE(ssp->srcu_ctrp);

include/linux/srcutree.h

299

__acquire_shared(ssp);

include/linux/srcutree.h

313

__srcu_read_unlock_fast(struct srcu_struct *ssp, struct srcu_ctr __percpu *scp)

include/linux/srcutree.h

314

__releases_shared(ssp)

include/linux/srcutree.h

316

__release_shared(ssp);

include/linux/srcutree.h

333

struct srcu_ctr __percpu notrace *__srcu_read_lock_fast_updown(struct srcu_struct *ssp)

include/linux/srcutree.h

334

__acquires_shared(ssp)

include/linux/srcutree.h

336

struct srcu_ctr __percpu *scp = READ_ONCE(ssp->srcu_ctrp);

include/linux/srcutree.h

343

__acquire_shared(ssp);

include/linux/srcutree.h

357

__srcu_read_unlock_fast_updown(struct srcu_struct *ssp, struct srcu_ctr __percpu *scp)

include/linux/srcutree.h

358

__releases_shared(ssp)

include/linux/srcutree.h

360

__release_shared(ssp);

include/linux/srcutree.h

368

void __srcu_check_read_flavor(struct srcu_struct *ssp, int read_flavor);

include/linux/srcutree.h

371

static inline void srcu_check_read_flavor(struct srcu_struct *ssp, int read_flavor)

include/linux/srcutree.h

374

__srcu_check_read_flavor(ssp, read_flavor);

include/linux/srcutree.h

51

struct srcu_struct *ssp;

include/linux/usb/gadget.h

911

struct usb_descriptor_header **ssp);

include/sound/sof/dai.h

111

struct sof_ipc_dai_ssp_params ssp;

kernel/rcu/rcu.h

409

#define srcu_for_each_node_breadth_first(ssp, rnp) \

kernel/rcu/rcu.h

410

_rcu_for_each_node_breadth_first(ssp->srcu_sup, rnp)

kernel/rcu/srcutiny.c

104

void __srcu_read_unlock(struct srcu_struct *ssp, int idx)

kernel/rcu/srcutiny.c

109

newval = READ_ONCE(ssp->srcu_lock_nesting[idx]) - 1;

kernel/rcu/srcutiny.c

110

WRITE_ONCE(ssp->srcu_lock_nesting[idx], newval);

kernel/rcu/srcutiny.c

112

if (!newval && READ_ONCE(ssp->srcu_gp_waiting) && in_task() && !irqs_disabled())

kernel/rcu/srcutiny.c

113

swake_up_one(&ssp->srcu_wq);

kernel/rcu/srcutiny.c

127

struct srcu_struct *ssp;

kernel/rcu/srcutiny.c

129

ssp = container_of(wp, struct srcu_struct, srcu_work);

kernel/rcu/srcutiny.c

131

if (ssp->srcu_gp_running || ULONG_CMP_GE(ssp->srcu_idx, READ_ONCE(ssp->srcu_idx_max))) {

kernel/rcu/srcutiny.c

137

WRITE_ONCE(ssp->srcu_gp_running, true);

kernel/rcu/srcutiny.c

139

lh = ssp->srcu_cb_head;

kernel/rcu/srcutiny.c

140

ssp->srcu_cb_head = NULL;

kernel/rcu/srcutiny.c

141

ssp->srcu_cb_tail = &ssp->srcu_cb_head;

kernel/rcu/srcutiny.c

143

idx = (ssp->srcu_idx & 0x2) / 2;

kernel/rcu/srcutiny.c

144

WRITE_ONCE(ssp->srcu_idx, ssp->srcu_idx + 1);

kernel/rcu/srcutiny.c

145

WRITE_ONCE(ssp->srcu_gp_waiting, true); /* srcu_read_unlock() wakes! */

kernel/rcu/srcutiny.c

150

swait_event_timeout_exclusive(ssp->srcu_wq,

kernel/rcu/srcutiny.c

151

!READ_ONCE(ssp->srcu_lock_nesting[idx]), HZ / 10);

kernel/rcu/srcutiny.c

152

} while (READ_ONCE(ssp->srcu_lock_nesting[idx]));

kernel/rcu/srcutiny.c

154

WRITE_ONCE(ssp->srcu_gp_waiting, false); /* srcu_read_unlock() cheap. */

kernel/rcu/srcutiny.c

155

WRITE_ONCE(ssp->srcu_idx, ssp->srcu_idx + 1);

kernel/rcu/srcutiny.c

175

WRITE_ONCE(ssp->srcu_gp_running, false);

kernel/rcu/srcutiny.c

176

idx = ULONG_CMP_LT(ssp->srcu_idx, READ_ONCE(ssp->srcu_idx_max));

kernel/rcu/srcutiny.c

179

schedule_work(&ssp->srcu_work);

kernel/rcu/srcutiny.c

190

struct srcu_struct *ssp;

kernel/rcu/srcutiny.c

192

ssp = container_of(irq_work, struct srcu_struct, srcu_irq_work);

kernel/rcu/srcutiny.c

193

schedule_work(&ssp->srcu_work);

kernel/rcu/srcutiny.c

197

static void srcu_gp_start_if_needed(struct srcu_struct *ssp)

kernel/rcu/srcutiny.c

202

cookie = get_state_synchronize_srcu(ssp);

kernel/rcu/srcutiny.c

203

if (ULONG_CMP_GE(READ_ONCE(ssp->srcu_idx_max), cookie)) {

kernel/rcu/srcutiny.c

206

WRITE_ONCE(ssp->srcu_idx_max, cookie);

kernel/rcu/srcutiny.c

207

if (!READ_ONCE(ssp->srcu_gp_running)) {

kernel/rcu/srcutiny.c

209

irq_work_queue(&ssp->srcu_irq_work);

kernel/rcu/srcutiny.c

210

else if (list_empty(&ssp->srcu_work.entry))

kernel/rcu/srcutiny.c

211

list_add(&ssp->srcu_work.entry, &srcu_boot_list);

kernel/rcu/srcutiny.c

219

void call_srcu(struct srcu_struct *ssp, struct rcu_head *rhp,

kernel/rcu/srcutiny.c

228

*ssp->srcu_cb_tail = rhp;

kernel/rcu/srcutiny.c

229

ssp->srcu_cb_tail = &rhp->next;

kernel/rcu/srcutiny.c

231

srcu_gp_start_if_needed(ssp);

kernel/rcu/srcutiny.c

239

void synchronize_srcu(struct srcu_struct *ssp)

kernel/rcu/srcutiny.c

243

srcu_lock_sync(&ssp->dep_map);

kernel/rcu/srcutiny.c

245

RCU_LOCKDEP_WARN(lockdep_is_held(ssp) ||

kernel/rcu/srcutiny.c

257

call_srcu(ssp, &rs.head, wakeme_after_rcu);

kernel/rcu/srcutiny.c

266

unsigned long get_state_synchronize_srcu(struct srcu_struct *ssp)

kernel/rcu/srcutiny.c

271

ret = (READ_ONCE(ssp->srcu_idx) + 3) & ~0x1;

kernel/rcu/srcutiny.c

284

unsigned long start_poll_synchronize_srcu(struct srcu_struct *ssp)

kernel/rcu/srcutiny.c

289

ret = get_state_synchronize_srcu(ssp);

kernel/rcu/srcutiny.c

290

srcu_gp_start_if_needed(ssp);

kernel/rcu/srcutiny.c

299

bool poll_state_synchronize_srcu(struct srcu_struct *ssp, unsigned long cookie)

kernel/rcu/srcutiny.c

301

unsigned long cur_s = READ_ONCE(ssp->srcu_idx);

kernel/rcu/srcutiny.c

32

static int init_srcu_struct_fields(struct srcu_struct *ssp)

kernel/rcu/srcutiny.c

324

struct srcu_struct *ssp;

kernel/rcu/srcutiny.c

328

ssp = list_first_entry(&srcu_boot_list,

kernel/rcu/srcutiny.c

330

list_del_init(&ssp->srcu_work.entry);

kernel/rcu/srcutiny.c

331

schedule_work(&ssp->srcu_work);

kernel/rcu/srcutiny.c

34

ssp->srcu_lock_nesting[0] = 0;

kernel/rcu/srcutiny.c

35

ssp->srcu_lock_nesting[1] = 0;

kernel/rcu/srcutiny.c

36

init_swait_queue_head(&ssp->srcu_wq);

kernel/rcu/srcutiny.c

37

ssp->srcu_cb_head = NULL;

kernel/rcu/srcutiny.c

38

ssp->srcu_cb_tail = &ssp->srcu_cb_head;

kernel/rcu/srcutiny.c

39

ssp->srcu_gp_running = false;

kernel/rcu/srcutiny.c

40

ssp->srcu_gp_waiting = false;

kernel/rcu/srcutiny.c

41

ssp->srcu_idx = 0;

kernel/rcu/srcutiny.c

42

ssp->srcu_idx_max = 0;

kernel/rcu/srcutiny.c

43

INIT_WORK(&ssp->srcu_work, srcu_drive_gp);

kernel/rcu/srcutiny.c

44

INIT_LIST_HEAD(&ssp->srcu_work.entry);

kernel/rcu/srcutiny.c

45

init_irq_work(&ssp->srcu_irq_work, srcu_tiny_irq_work);

kernel/rcu/srcutiny.c

51

int __init_srcu_struct(struct srcu_struct *ssp, const char *name,

kernel/rcu/srcutiny.c

55

debug_check_no_locks_freed((void *)ssp, sizeof(*ssp));

kernel/rcu/srcutiny.c

56

lockdep_init_map(&ssp->dep_map, name, key, 0);

kernel/rcu/srcutiny.c

57

return init_srcu_struct_fields(ssp);

kernel/rcu/srcutiny.c

71

int init_srcu_struct(struct srcu_struct *ssp)

kernel/rcu/srcutiny.c

73

return init_srcu_struct_fields(ssp);

kernel/rcu/srcutiny.c

86

void cleanup_srcu_struct(struct srcu_struct *ssp)

kernel/rcu/srcutiny.c

88

WARN_ON(ssp->srcu_lock_nesting[0] || ssp->srcu_lock_nesting[1]);

kernel/rcu/srcutiny.c

89

irq_work_sync(&ssp->srcu_irq_work);

kernel/rcu/srcutiny.c

90

flush_work(&ssp->srcu_work);

kernel/rcu/srcutiny.c

91

WARN_ON(ssp->srcu_gp_running);

kernel/rcu/srcutiny.c

92

WARN_ON(ssp->srcu_gp_waiting);

kernel/rcu/srcutiny.c

93

WARN_ON(ssp->srcu_cb_head);

kernel/rcu/srcutiny.c

94

WARN_ON(&ssp->srcu_cb_head != ssp->srcu_cb_tail);

kernel/rcu/srcutiny.c

95

WARN_ON(ssp->srcu_idx != ssp->srcu_idx_max);

kernel/rcu/srcutiny.c

96

WARN_ON(ssp->srcu_idx & 0x1);

kernel/rcu/srcutree.c

1007

init_srcu_struct_nodes(ssp, GFP_KERNEL);

kernel/rcu/srcutree.c

1020

static void srcu_funnel_exp_start(struct srcu_struct *ssp, struct srcu_node *snp,

kernel/rcu/srcutree.c

1029

if (WARN_ON_ONCE(rcu_seq_done(&ssp->srcu_sup->srcu_gp_seq, s)) ||

kernel/rcu/srcutree.c

103

sdp->srcu_gp_seq_needed = ssp->srcu_sup->srcu_gp_seq;

kernel/rcu/srcutree.c

104

sdp->srcu_gp_seq_needed_exp = ssp->srcu_sup->srcu_gp_seq;

kernel/rcu/srcutree.c

1041

raw_spin_lock_irqsave_ssp_contention(ssp, &flags);

kernel/rcu/srcutree.c

1042

if (ULONG_CMP_LT(ssp->srcu_sup->srcu_gp_seq_needed_exp, s))

kernel/rcu/srcutree.c

1043

WRITE_ONCE(ssp->srcu_sup->srcu_gp_seq_needed_exp, s);

kernel/rcu/srcutree.c

1044

raw_spin_unlock_irqrestore_rcu_node(ssp->srcu_sup, flags);

kernel/rcu/srcutree.c

1060

static void srcu_funnel_gp_start(struct srcu_struct *ssp, struct srcu_data *sdp,

kernel/rcu/srcutree.c

1069

struct srcu_usage *sup = ssp->srcu_sup;

kernel/rcu/srcutree.c

1093

srcu_funnel_exp_start(ssp, snp, s);

kernel/rcu/srcutree.c

110

sdp->ssp = ssp;

kernel/rcu/srcutree.c

1106

raw_spin_lock_irqsave_ssp_contention(ssp, &flags);

kernel/rcu/srcutree.c

1120

srcu_gp_start(ssp);

kernel/rcu/srcutree.c

1145

static bool try_check_zero(struct srcu_struct *ssp, int idx, int trycount)

kernel/rcu/srcutree.c

1149

raw_spin_lock_irq_rcu_node(ssp->srcu_sup);

kernel/rcu/srcutree.c

1150

curdelay = !srcu_get_delay(ssp);

kernel/rcu/srcutree.c

1151

raw_spin_unlock_irq_rcu_node(ssp->srcu_sup);

kernel/rcu/srcutree.c

1154

if (srcu_readers_active_idx_check(ssp, idx))

kernel/rcu/srcutree.c

1167

static void srcu_flip(struct srcu_struct *ssp)

kernel/rcu/srcutree.c

1201

WRITE_ONCE(ssp->srcu_ctrp,

kernel/rcu/srcutree.c

1202

&ssp->sda->srcu_ctrs[!(ssp->srcu_ctrp - &ssp->sda->srcu_ctrs[0])]);

kernel/rcu/srcutree.c

1248

static bool srcu_should_expedite(struct srcu_struct *ssp)

kernel/rcu/srcutree.c

1256

check_init_srcu_struct(ssp);

kernel/rcu/srcutree.c

1258

if (this_cpu_read(ssp->sda->srcu_reader_flavor) & SRCU_READ_FLAVOR_SLOWGP)

kernel/rcu/srcutree.c

1261

sdp = raw_cpu_ptr(ssp->sda);

kernel/rcu/srcutree.c

1277

tlast = READ_ONCE(ssp->srcu_sup->srcu_last_gp_end);

kernel/rcu/srcutree.c

1283

curseq = rcu_seq_current(&ssp->srcu_sup->srcu_gp_seq);

kernel/rcu/srcutree.c

1285

if (ULONG_CMP_LT(curseq, READ_ONCE(ssp->srcu_sup->srcu_gp_seq_needed)))

kernel/rcu/srcutree.c

1288

if (curseq != rcu_seq_current(&ssp->srcu_sup->srcu_gp_seq))

kernel/rcu/srcutree.c

130

static bool init_srcu_struct_nodes(struct srcu_struct *ssp, gfp_t gfp_flags)

kernel/rcu/srcutree.c

1303

static unsigned long srcu_gp_start_if_needed(struct srcu_struct *ssp,

kernel/rcu/srcutree.c

1315

check_init_srcu_struct(ssp);

kernel/rcu/srcutree.c

1321

idx = __srcu_read_lock_nmisafe(ssp);

kernel/rcu/srcutree.c

1322

ss_state = smp_load_acquire(&ssp->srcu_sup->srcu_size_state);

kernel/rcu/srcutree.c

1326

sdp = per_cpu_ptr(ssp->sda, get_boot_cpu_id());

kernel/rcu/srcutree.c

1328

sdp = raw_cpu_ptr(ssp->sda);

kernel/rcu/srcutree.c

1368

s = rcu_seq_snap(&ssp->srcu_sup->srcu_gp_seq);

kernel/rcu/srcutree.c

1371

rcu_seq_current(&ssp->srcu_sup->srcu_gp_seq));

kernel/rcu/srcutree.c

1398

srcu_funnel_gp_start(ssp, sdp, s, do_norm);

kernel/rcu/srcutree.c

1400

srcu_funnel_exp_start(ssp, sdp_mynode, s);

kernel/rcu/srcutree.c

1401

__srcu_read_unlock_nmisafe(ssp, idx);

kernel/rcu/srcutree.c

142

ssp->srcu_sup->node = kzalloc_objs(*ssp->srcu_sup->node, rcu_num_nodes,

kernel/rcu/srcutree.c

1433

static void __call_srcu(struct srcu_struct *ssp, struct rcu_head *rhp,

kernel/rcu/srcutree.c

144

if (!ssp->srcu_sup->node)

kernel/rcu/srcutree.c

1443

(void)srcu_gp_start_if_needed(ssp, rhp, do_norm);

kernel/rcu/srcutree.c

1467

void call_srcu(struct srcu_struct *ssp, struct rcu_head *rhp,

kernel/rcu/srcutree.c

1470

__call_srcu(ssp, rhp, func, true);

kernel/rcu/srcutree.c

1477

static void __synchronize_srcu(struct srcu_struct *ssp, bool do_norm)

kernel/rcu/srcutree.c

148

ssp->srcu_sup->level[0] = &ssp->srcu_sup->node[0];

kernel/rcu/srcutree.c

1481

srcu_lock_sync(&ssp->dep_map);

kernel/rcu/srcutree.c

1483

RCU_LOCKDEP_WARN(lockdep_is_held(ssp) ||

kernel/rcu/srcutree.c

1492

check_init_srcu_struct(ssp);

kernel/rcu/srcutree.c

1495

__call_srcu(ssp, &rcu.head, wakeme_after_rcu, do_norm);

kernel/rcu/srcutree.c

150

ssp->srcu_sup->level[i] = ssp->srcu_sup->level[i - 1] + num_rcu_lvl[i - 1];

kernel/rcu/srcutree.c

1519

void synchronize_srcu_expedited(struct srcu_struct *ssp)

kernel/rcu/srcutree.c

1521

__synchronize_srcu(ssp, rcu_gp_is_normal());

kernel/rcu/srcutree.c

154

srcu_for_each_node_breadth_first(ssp, snp) {

kernel/rcu/srcutree.c

1574

void synchronize_srcu(struct srcu_struct *ssp)

kernel/rcu/srcutree.c

1576

if (srcu_should_expedite(ssp) || rcu_gp_is_expedited())

kernel/rcu/srcutree.c

1577

synchronize_srcu_expedited(ssp);

kernel/rcu/srcutree.c

1579

__synchronize_srcu(ssp, true);

kernel/rcu/srcutree.c

1593

unsigned long get_state_synchronize_srcu(struct srcu_struct *ssp)

kernel/rcu/srcutree.c

1598

return rcu_seq_snap(&ssp->srcu_sup->srcu_gp_seq);

kernel/rcu/srcutree.c

1612

unsigned long start_poll_synchronize_srcu(struct srcu_struct *ssp)

kernel/rcu/srcutree.c

1614

return srcu_gp_start_if_needed(ssp, NULL, true);

kernel/rcu/srcutree.c

1643

bool poll_state_synchronize_srcu(struct srcu_struct *ssp, unsigned long cookie)

kernel/rcu/srcutree.c

1646

!rcu_seq_done_exact(&ssp->srcu_sup->srcu_gp_seq, cookie))

kernel/rcu/srcutree.c

165

if (snp == &ssp->srcu_sup->node[0]) {

kernel/rcu/srcutree.c

1661

struct srcu_struct *ssp;

kernel/rcu/srcutree.c

1665

ssp = sdp->ssp;

kernel/rcu/srcutree.c

1666

if (atomic_dec_and_test(&ssp->srcu_sup->srcu_barrier_cpu_cnt))

kernel/rcu/srcutree.c

1667

complete(&ssp->srcu_sup->srcu_barrier_completion);

kernel/rcu/srcutree.c

1678

static void srcu_barrier_one_cpu(struct srcu_struct *ssp, struct srcu_data *sdp)

kernel/rcu/srcutree.c

1681

atomic_inc(&ssp->srcu_sup->srcu_barrier_cpu_cnt);

kernel/rcu/srcutree.c

1687

atomic_dec(&ssp->srcu_sup->srcu_barrier_cpu_cnt);

kernel/rcu/srcutree.c

1696

void srcu_barrier(struct srcu_struct *ssp)

kernel/rcu/srcutree.c

1700

unsigned long s = rcu_seq_snap(&ssp->srcu_sup->srcu_barrier_seq);

kernel/rcu/srcutree.c

1702

check_init_srcu_struct(ssp);

kernel/rcu/srcutree.c

1703

mutex_lock(&ssp->srcu_sup->srcu_barrier_mutex);

kernel/rcu/srcutree.c

1704

if (rcu_seq_done(&ssp->srcu_sup->srcu_barrier_seq, s)) {

kernel/rcu/srcutree.c

1706

mutex_unlock(&ssp->srcu_sup->srcu_barrier_mutex);

kernel/rcu/srcutree.c

1709

rcu_seq_start(&ssp->srcu_sup->srcu_barrier_seq);

kernel/rcu/srcutree.c

1710

init_completion(&ssp->srcu_sup->srcu_barrier_completion);

kernel/rcu/srcutree.c

1713

atomic_set(&ssp->srcu_sup->srcu_barrier_cpu_cnt, 1);

kernel/rcu/srcutree.c

1715

idx = __srcu_read_lock_nmisafe(ssp);

kernel/rcu/srcutree.c

1716

if (smp_load_acquire(&ssp->srcu_sup->srcu_size_state) < SRCU_SIZE_WAIT_BARRIER)

kernel/rcu/srcutree.c

1717

srcu_barrier_one_cpu(ssp, per_cpu_ptr(ssp->sda, get_boot_cpu_id()));

kernel/rcu/srcutree.c

172

if (snp == ssp->srcu_sup->level[level + 1])

kernel/rcu/srcutree.c

1720

srcu_barrier_one_cpu(ssp, per_cpu_ptr(ssp->sda, cpu));

kernel/rcu/srcutree.c

1721

__srcu_read_unlock_nmisafe(ssp, idx);

kernel/rcu/srcutree.c

1724

if (atomic_dec_and_test(&ssp->srcu_sup->srcu_barrier_cpu_cnt))

kernel/rcu/srcutree.c

1725

complete(&ssp->srcu_sup->srcu_barrier_completion);

kernel/rcu/srcutree.c

1726

wait_for_completion(&ssp->srcu_sup->srcu_barrier_completion);

kernel/rcu/srcutree.c

1728

rcu_seq_end(&ssp->srcu_sup->srcu_barrier_seq);

kernel/rcu/srcutree.c

1729

mutex_unlock(&ssp->srcu_sup->srcu_barrier_mutex);

kernel/rcu/srcutree.c

174

snp->srcu_parent = ssp->srcu_sup->level[level - 1] +

kernel/rcu/srcutree.c

175

(snp - ssp->srcu_sup->level[level]) /

kernel/rcu/srcutree.c

1753

__call_srcu(sdp->ssp, &sdp->srcu_ec_head, srcu_expedite_current_cb, false);

kernel/rcu/srcutree.c

1766

void srcu_expedite_current(struct srcu_struct *ssp)

kernel/rcu/srcutree.c

1773

sdp = this_cpu_ptr(ssp->sda);

kernel/rcu/srcutree.c

1786

__call_srcu(ssp, &sdp->srcu_ec_head, srcu_expedite_current_cb, false);

kernel/rcu/srcutree.c

1798

unsigned long srcu_batches_completed(struct srcu_struct *ssp)

kernel/rcu/srcutree.c

1800

return READ_ONCE(ssp->srcu_sup->srcu_gp_seq);

kernel/rcu/srcutree.c

1809

static void srcu_advance_state(struct srcu_struct *ssp)

kernel/rcu/srcutree.c

1813

mutex_lock(&ssp->srcu_sup->srcu_gp_mutex);

kernel/rcu/srcutree.c

1825

idx = rcu_seq_state(smp_load_acquire(&ssp->srcu_sup->srcu_gp_seq)); /* ^^^ */

kernel/rcu/srcutree.c

1827

raw_spin_lock_irq_rcu_node(ssp->srcu_sup);

kernel/rcu/srcutree.c

1828

if (ULONG_CMP_GE(ssp->srcu_sup->srcu_gp_seq, ssp->srcu_sup->srcu_gp_seq_needed)) {

kernel/rcu/srcutree.c

1829

WARN_ON_ONCE(rcu_seq_state(ssp->srcu_sup->srcu_gp_seq));

kernel/rcu/srcutree.c

1830

raw_spin_unlock_irq_rcu_node(ssp->srcu_sup);

kernel/rcu/srcutree.c

1831

mutex_unlock(&ssp->srcu_sup->srcu_gp_mutex);

kernel/rcu/srcutree.c

1834

idx = rcu_seq_state(READ_ONCE(ssp->srcu_sup->srcu_gp_seq));

kernel/rcu/srcutree.c

1836

srcu_gp_start(ssp);

kernel/rcu/srcutree.c

1837

raw_spin_unlock_irq_rcu_node(ssp->srcu_sup);

kernel/rcu/srcutree.c

1839

mutex_unlock(&ssp->srcu_sup->srcu_gp_mutex);

kernel/rcu/srcutree.c

184

snp_first = ssp->srcu_sup->level[level];

kernel/rcu/srcutree.c

1844

if (rcu_seq_state(READ_ONCE(ssp->srcu_sup->srcu_gp_seq)) == SRCU_STATE_SCAN1) {

kernel/rcu/srcutree.c

1845

idx = !(ssp->srcu_ctrp - &ssp->sda->srcu_ctrs[0]);

kernel/rcu/srcutree.c

1846

if (!try_check_zero(ssp, idx, 1)) {

kernel/rcu/srcutree.c

1847

mutex_unlock(&ssp->srcu_sup->srcu_gp_mutex);

kernel/rcu/srcutree.c

1850

srcu_flip(ssp);

kernel/rcu/srcutree.c

1851

raw_spin_lock_irq_rcu_node(ssp->srcu_sup);

kernel/rcu/srcutree.c

1852

rcu_seq_set_state(&ssp->srcu_sup->srcu_gp_seq, SRCU_STATE_SCAN2);

kernel/rcu/srcutree.c

1853

ssp->srcu_sup->srcu_n_exp_nodelay = 0;

kernel/rcu/srcutree.c

1854

raw_spin_unlock_irq_rcu_node(ssp->srcu_sup);

kernel/rcu/srcutree.c

1857

if (rcu_seq_state(READ_ONCE(ssp->srcu_sup->srcu_gp_seq)) == SRCU_STATE_SCAN2) {

kernel/rcu/srcutree.c

186

sdp = per_cpu_ptr(ssp->sda, cpu);

kernel/rcu/srcutree.c

1863

idx = !(ssp->srcu_ctrp - &ssp->sda->srcu_ctrs[0]);

kernel/rcu/srcutree.c

1864

if (!try_check_zero(ssp, idx, 2)) {

kernel/rcu/srcutree.c

1865

mutex_unlock(&ssp->srcu_sup->srcu_gp_mutex);

kernel/rcu/srcutree.c

1868

ssp->srcu_sup->srcu_n_exp_nodelay = 0;

kernel/rcu/srcutree.c

1869

srcu_gp_end(ssp); /* Releases ->srcu_gp_mutex. */

kernel/rcu/srcutree.c

1886

struct srcu_struct *ssp;

kernel/rcu/srcutree.c

1890

ssp = sdp->ssp;

kernel/rcu/srcutree.c

1895

rcu_seq_current(&ssp->srcu_sup->srcu_gp_seq));

kernel/rcu/srcutree.c

1940

static void srcu_reschedule(struct srcu_struct *ssp, unsigned long delay)

kernel/rcu/srcutree.c

1944

raw_spin_lock_irq_rcu_node(ssp->srcu_sup);

kernel/rcu/srcutree.c

1945

if (ULONG_CMP_GE(ssp->srcu_sup->srcu_gp_seq, ssp->srcu_sup->srcu_gp_seq_needed)) {

kernel/rcu/srcutree.c

1946

if (!WARN_ON_ONCE(rcu_seq_state(ssp->srcu_sup->srcu_gp_seq))) {

kernel/rcu/srcutree.c

195

smp_store_release(&ssp->srcu_sup->srcu_size_state, SRCU_SIZE_WAIT_BARRIER);

kernel/rcu/srcutree.c

1950

} else if (!rcu_seq_state(ssp->srcu_sup->srcu_gp_seq)) {

kernel/rcu/srcutree.c

1952

srcu_gp_start(ssp);

kernel/rcu/srcutree.c

1954

raw_spin_unlock_irq_rcu_node(ssp->srcu_sup);

kernel/rcu/srcutree.c

1957

queue_delayed_work(rcu_gp_wq, &ssp->srcu_sup->work, delay);

kernel/rcu/srcutree.c

1967

struct srcu_struct *ssp;

kernel/rcu/srcutree.c

1971

ssp = sup->srcu_ssp;

kernel/rcu/srcutree.c

1973

srcu_advance_state(ssp);

kernel/rcu/srcutree.c

1974

raw_spin_lock_irq_rcu_node(ssp->srcu_sup);

kernel/rcu/srcutree.c

1975

curdelay = srcu_get_delay(ssp);

kernel/rcu/srcutree.c

1976

raw_spin_unlock_irq_rcu_node(ssp->srcu_sup);

kernel/rcu/srcutree.c

1991

srcu_reschedule(ssp, curdelay);

kernel/rcu/srcutree.c

1996

struct srcu_struct *ssp;

kernel/rcu/srcutree.c

2002

ssp = sup->srcu_ssp;

kernel/rcu/srcutree.c

2004

raw_spin_lock_irqsave_rcu_node(ssp->srcu_sup, flags);

kernel/rcu/srcutree.c

2005

delay = srcu_get_delay(ssp);

kernel/rcu/srcutree.c

2006

raw_spin_unlock_irqrestore_rcu_node(ssp->srcu_sup, flags);

kernel/rcu/srcutree.c

2011

void srcutorture_get_gp_data(struct srcu_struct *ssp, int *flags,

kernel/rcu/srcutree.c

2015

*gp_seq = rcu_seq_current(&ssp->srcu_sup->srcu_gp_seq);

kernel/rcu/srcutree.c

2032

void srcu_torture_stats_print(struct srcu_struct *ssp, char *tt, char *tf)

kernel/rcu/srcutree.c

2037

int ss_state = READ_ONCE(ssp->srcu_sup->srcu_size_state);

kernel/rcu/srcutree.c

204

static int init_srcu_struct_fields(struct srcu_struct *ssp, bool is_static)

kernel/rcu/srcutree.c

2040

idx = ssp->srcu_ctrp - &ssp->sda->srcu_ctrs[0];

kernel/rcu/srcutree.c

2044

tt, tf, rcu_seq_current(&ssp->srcu_sup->srcu_gp_seq), ss_state,

kernel/rcu/srcutree.c

2046

if (!ssp->sda) {

kernel/rcu/srcutree.c

2057

sdp = per_cpu_ptr(ssp->sda, cpu);

kernel/rcu/srcutree.c

207

ssp->srcu_sup = kzalloc_obj(*ssp->srcu_sup);

kernel/rcu/srcutree.c

208

if (!ssp->srcu_sup)

kernel/rcu/srcutree.c

2081

srcu_transition_to_big(ssp);

kernel/rcu/srcutree.c

211

raw_spin_lock_init(&ACCESS_PRIVATE(ssp->srcu_sup, lock));

kernel/rcu/srcutree.c

212

ssp->srcu_sup->srcu_size_state = SRCU_SIZE_SMALL;

kernel/rcu/srcutree.c

213

ssp->srcu_sup->node = NULL;

kernel/rcu/srcutree.c

2137

struct srcu_struct *ssp;

kernel/rcu/srcutree.c

214

mutex_init(&ssp->srcu_sup->srcu_cb_mutex);

kernel/rcu/srcutree.c

2141

ssp = *(sspp++);

kernel/rcu/srcutree.c

2142

ssp->sda = alloc_percpu(struct srcu_data);

kernel/rcu/srcutree.c

2143

if (WARN_ON_ONCE(!ssp->sda))

kernel/rcu/srcutree.c

2145

ssp->srcu_ctrp = &ssp->sda->srcu_ctrs[0];

kernel/rcu/srcutree.c

215

mutex_init(&ssp->srcu_sup->srcu_gp_mutex);

kernel/rcu/srcutree.c

2154

struct srcu_struct *ssp;

kernel/rcu/srcutree.c

2158

ssp = *(sspp++);

kernel/rcu/srcutree.c

2159

if (!rcu_seq_state(smp_load_acquire(&ssp->srcu_sup->srcu_gp_seq_needed)) &&

kernel/rcu/srcutree.c

216

ssp->srcu_sup->srcu_gp_seq = SRCU_GP_SEQ_INITIAL_VAL;

kernel/rcu/srcutree.c

2160

!WARN_ON_ONCE(!ssp->srcu_sup->sda_is_static))

kernel/rcu/srcutree.c

2161

cleanup_srcu_struct(ssp);

kernel/rcu/srcutree.c

2162

if (!WARN_ON(srcu_readers_active(ssp)))

kernel/rcu/srcutree.c

2163

free_percpu(ssp->sda);

kernel/rcu/srcutree.c

217

ssp->srcu_sup->srcu_barrier_seq = 0;

kernel/rcu/srcutree.c

218

mutex_init(&ssp->srcu_sup->srcu_barrier_mutex);

kernel/rcu/srcutree.c

219

atomic_set(&ssp->srcu_sup->srcu_barrier_cpu_cnt, 0);

kernel/rcu/srcutree.c

220

INIT_DELAYED_WORK(&ssp->srcu_sup->work, process_srcu);

kernel/rcu/srcutree.c

221

init_irq_work(&ssp->srcu_sup->irq_work, srcu_irq_work);

kernel/rcu/srcutree.c

222

ssp->srcu_sup->sda_is_static = is_static;

kernel/rcu/srcutree.c

224

ssp->sda = alloc_percpu(struct srcu_data);

kernel/rcu/srcutree.c

225

ssp->srcu_ctrp = &ssp->sda->srcu_ctrs[0];

kernel/rcu/srcutree.c

227

if (!ssp->sda)

kernel/rcu/srcutree.c

229

init_srcu_struct_data(ssp);

kernel/rcu/srcutree.c

230

ssp->srcu_sup->srcu_gp_seq_needed_exp = SRCU_GP_SEQ_INITIAL_VAL;

kernel/rcu/srcutree.c

231

ssp->srcu_sup->srcu_last_gp_end = ktime_get_mono_fast_ns();

kernel/rcu/srcutree.c

232

if (READ_ONCE(ssp->srcu_sup->srcu_size_state) == SRCU_SIZE_SMALL && SRCU_SIZING_IS_INIT()) {

kernel/rcu/srcutree.c

234

WRITE_ONCE(ssp->srcu_sup->srcu_size_state, SRCU_SIZE_ALLOC);

kernel/rcu/srcutree.c

235

else if (init_srcu_struct_nodes(ssp, GFP_KERNEL))

kernel/rcu/srcutree.c

236

WRITE_ONCE(ssp->srcu_sup->srcu_size_state, SRCU_SIZE_BIG);

kernel/rcu/srcutree.c

240

ssp->srcu_sup->srcu_ssp = ssp;

kernel/rcu/srcutree.c

241

smp_store_release(&ssp->srcu_sup->srcu_gp_seq_needed,

kernel/rcu/srcutree.c

247

free_percpu(ssp->sda);

kernel/rcu/srcutree.c

248

ssp->sda = NULL;

kernel/rcu/srcutree.c

252

kfree(ssp->srcu_sup);

kernel/rcu/srcutree.c

253

ssp->srcu_sup = NULL;

kernel/rcu/srcutree.c

261

__init_srcu_struct_common(struct srcu_struct *ssp, const char *name, struct lock_class_key *key)

kernel/rcu/srcutree.c

264

debug_check_no_locks_freed((void *)ssp, sizeof(*ssp));

kernel/rcu/srcutree.c

265

lockdep_init_map(&ssp->dep_map, name, key, 0);

kernel/rcu/srcutree.c

266

return init_srcu_struct_fields(ssp, false);

kernel/rcu/srcutree.c

269

int __init_srcu_struct(struct srcu_struct *ssp, const char *name, struct lock_class_key *key)

kernel/rcu/srcutree.c

271

ssp->srcu_reader_flavor = 0;

kernel/rcu/srcutree.c

272

return __init_srcu_struct_common(ssp, name, key);

kernel/rcu/srcutree.c

276

int __init_srcu_struct_fast(struct srcu_struct *ssp, const char *name, struct lock_class_key *key)

kernel/rcu/srcutree.c

278

ssp->srcu_reader_flavor = SRCU_READ_FLAVOR_FAST;

kernel/rcu/srcutree.c

279

return __init_srcu_struct_common(ssp, name, key);

kernel/rcu/srcutree.c

283

int __init_srcu_struct_fast_updown(struct srcu_struct *ssp, const char *name,

kernel/rcu/srcutree.c

286

ssp->srcu_reader_flavor = SRCU_READ_FLAVOR_FAST_UPDOWN;

kernel/rcu/srcutree.c

287

return __init_srcu_struct_common(ssp, name, key);

kernel/rcu/srcutree.c

304

int init_srcu_struct(struct srcu_struct *ssp)

kernel/rcu/srcutree.c

306

ssp->srcu_reader_flavor = 0;

kernel/rcu/srcutree.c

307

return init_srcu_struct_fields(ssp, false);

kernel/rcu/srcutree.c

321

int init_srcu_struct_fast(struct srcu_struct *ssp)

kernel/rcu/srcutree.c

323

ssp->srcu_reader_flavor = SRCU_READ_FLAVOR_FAST;

kernel/rcu/srcutree.c

324

return init_srcu_struct_fields(ssp, false);

kernel/rcu/srcutree.c

339

int init_srcu_struct_fast_updown(struct srcu_struct *ssp)

kernel/rcu/srcutree.c

341

ssp->srcu_reader_flavor = SRCU_READ_FLAVOR_FAST_UPDOWN;

kernel/rcu/srcutree.c

342

return init_srcu_struct_fields(ssp, false);

kernel/rcu/srcutree.c

351

static void __srcu_transition_to_big(struct srcu_struct *ssp)

kernel/rcu/srcutree.c

353

lockdep_assert_held(&ACCESS_PRIVATE(ssp->srcu_sup, lock));

kernel/rcu/srcutree.c

354

smp_store_release(&ssp->srcu_sup->srcu_size_state, SRCU_SIZE_ALLOC);

kernel/rcu/srcutree.c

360

static void srcu_transition_to_big(struct srcu_struct *ssp)

kernel/rcu/srcutree.c

365

if (smp_load_acquire(&ssp->srcu_sup->srcu_size_state) != SRCU_SIZE_SMALL)

kernel/rcu/srcutree.c

367

raw_spin_lock_irqsave_rcu_node(ssp->srcu_sup, flags);

kernel/rcu/srcutree.c

368

if (smp_load_acquire(&ssp->srcu_sup->srcu_size_state) != SRCU_SIZE_SMALL) {

kernel/rcu/srcutree.c

369

raw_spin_unlock_irqrestore_rcu_node(ssp->srcu_sup, flags);

kernel/rcu/srcutree.c

372

__srcu_transition_to_big(ssp);

kernel/rcu/srcutree.c

373

raw_spin_unlock_irqrestore_rcu_node(ssp->srcu_sup, flags);

kernel/rcu/srcutree.c

380

static void raw_spin_lock_irqsave_check_contention(struct srcu_struct *ssp)

kernel/rcu/srcutree.c

384

if (!SRCU_SIZING_IS_CONTEND() || ssp->srcu_sup->srcu_size_state)

kernel/rcu/srcutree.c

387

if (ssp->srcu_sup->srcu_size_jiffies != j) {

kernel/rcu/srcutree.c

388

ssp->srcu_sup->srcu_size_jiffies = j;

kernel/rcu/srcutree.c

389

ssp->srcu_sup->srcu_n_lock_retries = 0;

kernel/rcu/srcutree.c

391

if (++ssp->srcu_sup->srcu_n_lock_retries <= small_contention_lim)

kernel/rcu/srcutree.c

393

__srcu_transition_to_big(ssp);

kernel/rcu/srcutree.c

404

struct srcu_struct *ssp = sdp->ssp;

kernel/rcu/srcutree.c

408

raw_spin_lock_irqsave_rcu_node(ssp->srcu_sup, *flags);

kernel/rcu/srcutree.c

409

raw_spin_lock_irqsave_check_contention(ssp);

kernel/rcu/srcutree.c

410

raw_spin_unlock_irqrestore_rcu_node(ssp->srcu_sup, *flags);

kernel/rcu/srcutree.c

420

static void raw_spin_lock_irqsave_ssp_contention(struct srcu_struct *ssp, unsigned long *flags)

kernel/rcu/srcutree.c

422

if (raw_spin_trylock_irqsave_rcu_node(ssp->srcu_sup, *flags))

kernel/rcu/srcutree.c

424

raw_spin_lock_irqsave_rcu_node(ssp->srcu_sup, *flags);

kernel/rcu/srcutree.c

425

raw_spin_lock_irqsave_check_contention(ssp);

kernel/rcu/srcutree.c

436

static void check_init_srcu_struct(struct srcu_struct *ssp)

kernel/rcu/srcutree.c

441

if (!rcu_seq_state(smp_load_acquire(&ssp->srcu_sup->srcu_gp_seq_needed))) /*^^^*/

kernel/rcu/srcutree.c

443

raw_spin_lock_irqsave_rcu_node(ssp->srcu_sup, flags);

kernel/rcu/srcutree.c

444

if (!rcu_seq_state(ssp->srcu_sup->srcu_gp_seq_needed)) {

kernel/rcu/srcutree.c

445

raw_spin_unlock_irqrestore_rcu_node(ssp->srcu_sup, flags);

kernel/rcu/srcutree.c

448

init_srcu_struct_fields(ssp, true);

kernel/rcu/srcutree.c

449

raw_spin_unlock_irqrestore_rcu_node(ssp->srcu_sup, flags);

kernel/rcu/srcutree.c

455

static bool srcu_gp_is_expedited(struct srcu_struct *ssp)

kernel/rcu/srcutree.c

457

struct srcu_usage *sup = ssp->srcu_sup;

kernel/rcu/srcutree.c

468

static bool srcu_readers_lock_idx(struct srcu_struct *ssp, int idx, bool gp, unsigned long unlocks)

kernel/rcu/srcutree.c

475

struct srcu_data *sdp = per_cpu_ptr(ssp->sda, cpu);

kernel/rcu/srcutree.c

482

"Mixed reader flavors for srcu_struct at %ps.\n", ssp);

kernel/rcu/srcutree.c

492

static unsigned long srcu_readers_unlock_idx(struct srcu_struct *ssp, int idx, unsigned long *rdm)

kernel/rcu/srcutree.c

495

unsigned long mask = ssp->srcu_reader_flavor;

kernel/rcu/srcutree.c

499

struct srcu_data *sdp = per_cpu_ptr(ssp->sda, cpu);

kernel/rcu/srcutree.c

505

"Mixed reader flavors for srcu_struct at %ps.\n", ssp);

kernel/rcu/srcutree.c

514

static bool srcu_readers_active_idx_check(struct srcu_struct *ssp, int idx)

kernel/rcu/srcutree.c

520

unlocks = srcu_readers_unlock_idx(ssp, idx, &rdm);

kernel/rcu/srcutree.c

536

else if (srcu_gp_is_expedited(ssp))

kernel/rcu/srcutree.c

598

return srcu_readers_lock_idx(ssp, idx, did_gp, unlocks);

kernel/rcu/srcutree.c

610

static bool srcu_readers_active(struct srcu_struct *ssp)

kernel/rcu/srcutree.c

616

struct srcu_data *sdp = per_cpu_ptr(ssp->sda, cpu);

kernel/rcu/srcutree.c

677

static unsigned long srcu_get_delay(struct srcu_struct *ssp)

kernel/rcu/srcutree.c

682

struct srcu_usage *sup = ssp->srcu_sup;

kernel/rcu/srcutree.c

684

lockdep_assert_held(&ACCESS_PRIVATE(ssp->srcu_sup, lock));

kernel/rcu/srcutree.c

685

if (srcu_gp_is_expedited(ssp))

kernel/rcu/srcutree.c

709

void cleanup_srcu_struct(struct srcu_struct *ssp)

kernel/rcu/srcutree.c

713

struct srcu_usage *sup = ssp->srcu_sup;

kernel/rcu/srcutree.c

715

raw_spin_lock_irq_rcu_node(ssp->srcu_sup);

kernel/rcu/srcutree.c

716

delay = srcu_get_delay(ssp);

kernel/rcu/srcutree.c

717

raw_spin_unlock_irq_rcu_node(ssp->srcu_sup);

kernel/rcu/srcutree.c

720

if (WARN_ON(srcu_readers_active(ssp)))

kernel/rcu/srcutree.c

726

struct srcu_data *sdp = per_cpu_ptr(ssp->sda, cpu);

kernel/rcu/srcutree.c

735

WARN_ON(srcu_readers_active(ssp))) {

kernel/rcu/srcutree.c

737

__func__, ssp, rcu_seq_state(READ_ONCE(sup->srcu_gp_seq)),

kernel/rcu/srcutree.c

748

free_percpu(ssp->sda);

kernel/rcu/srcutree.c

749

ssp->sda = NULL;

kernel/rcu/srcutree.c

751

ssp->srcu_sup = NULL;

kernel/rcu/srcutree.c

759

void __srcu_check_read_flavor(struct srcu_struct *ssp, int read_flavor)

kernel/rcu/srcutree.c

769

sdp = raw_cpu_ptr(ssp->sda);

kernel/rcu/srcutree.c

77

static void srcu_reschedule(struct srcu_struct *ssp, unsigned long delay);

kernel/rcu/srcutree.c

771

WARN_ON_ONCE(ssp->srcu_reader_flavor && read_flavor != ssp->srcu_reader_flavor);

kernel/rcu/srcutree.c

772

WARN_ON_ONCE(old_read_flavor && ssp->srcu_reader_flavor &&

kernel/rcu/srcutree.c

773

old_read_flavor != ssp->srcu_reader_flavor);

kernel/rcu/srcutree.c

774

WARN_ON_ONCE(read_flavor == SRCU_READ_FLAVOR_FAST && !ssp->srcu_reader_flavor);

kernel/rcu/srcutree.c

790

int __srcu_read_lock(struct srcu_struct *ssp)

kernel/rcu/srcutree.c

792

struct srcu_ctr __percpu *scp = READ_ONCE(ssp->srcu_ctrp);

kernel/rcu/srcutree.c

796

return __srcu_ptr_to_ctr(ssp, scp);

kernel/rcu/srcutree.c

805

void __srcu_read_unlock(struct srcu_struct *ssp, int idx)

kernel/rcu/srcutree.c

808

this_cpu_inc(__srcu_ctr_to_ptr(ssp, idx)->srcu_unlocks.counter);

kernel/rcu/srcutree.c

819

int __srcu_read_lock_nmisafe(struct srcu_struct *ssp)

kernel/rcu/srcutree.c

821

struct srcu_ctr __percpu *scpp = READ_ONCE(ssp->srcu_ctrp);

kernel/rcu/srcutree.c

826

return __srcu_ptr_to_ctr(ssp, scpp);

kernel/rcu/srcutree.c

835

void __srcu_read_unlock_nmisafe(struct srcu_struct *ssp, int idx)

kernel/rcu/srcutree.c

838

atomic_long_inc(&raw_cpu_ptr(__srcu_ctr_to_ptr(ssp, idx))->srcu_unlocks);

kernel/rcu/srcutree.c

847

static void srcu_gp_start(struct srcu_struct *ssp)

kernel/rcu/srcutree.c

851

lockdep_assert_held(&ACCESS_PRIVATE(ssp->srcu_sup, lock));

kernel/rcu/srcutree.c

852

WARN_ON_ONCE(ULONG_CMP_GE(ssp->srcu_sup->srcu_gp_seq, ssp->srcu_sup->srcu_gp_seq_needed));

kernel/rcu/srcutree.c

853

WRITE_ONCE(ssp->srcu_sup->srcu_gp_start, jiffies);

kernel/rcu/srcutree.c

854

WRITE_ONCE(ssp->srcu_sup->srcu_n_exp_nodelay, 0);

kernel/rcu/srcutree.c

856

rcu_seq_start(&ssp->srcu_sup->srcu_gp_seq);

kernel/rcu/srcutree.c

857

state = rcu_seq_state(ssp->srcu_sup->srcu_gp_seq);

kernel/rcu/srcutree.c

89

static void init_srcu_struct_data(struct srcu_struct *ssp)

kernel/rcu/srcutree.c

895

static void srcu_schedule_cbs_snp(struct srcu_struct *ssp, struct srcu_node *snp,

kernel/rcu/srcutree.c

902

srcu_schedule_cbs_sdp(per_cpu_ptr(ssp->sda, cpu), delay);

kernel/rcu/srcutree.c

914

static void srcu_gp_end(struct srcu_struct *ssp)

kernel/rcu/srcutree.c

927

struct srcu_usage *sup = ssp->srcu_sup;

kernel/rcu/srcutree.c

936

if (srcu_gp_is_expedited(ssp))

kernel/rcu/srcutree.c

951

srcu_schedule_cbs_sdp(per_cpu_ptr(ssp->sda, get_boot_cpu_id()),

kernel/rcu/srcutree.c

955

srcu_for_each_node_breadth_first(ssp, snp) {

kernel/rcu/srcutree.c

973

srcu_schedule_cbs_snp(ssp, snp, mask, cbdelay);

kernel/rcu/srcutree.c

980

sdp = per_cpu_ptr(ssp->sda, cpu);

kernel/rcu/srcutree.c

99

sdp = per_cpu_ptr(ssp->sda, cpu);

kernel/rcu/srcutree.c

997

srcu_gp_start(ssp);

kernel/rcu/srcutree.c

999

srcu_reschedule(ssp, 0);

security/smack/smack_lsm.c

1610

struct socket_smack *ssp;

security/smack/smack_lsm.c

1639

ssp = smack_sock(sock->sk);

security/smack/smack_lsm.c

1642

isp = ssp->smk_in;

security/smack/smack_lsm.c

1644

isp = ssp->smk_out;

security/smack/smack_lsm.c

2010

struct socket_smack *ssp;

security/smack/smack_lsm.c

2020

ssp = smack_sock(sock->sk);

security/smack/smack_lsm.c

2028

rc = smk_access(tsp->smk_task, ssp->smk_out, MAY_WRITE, &ad);

security/smack/smack_lsm.c

2032

rc = smk_access(ssp->smk_in, tsp->smk_task, MAY_WRITE, &ad);

security/smack/smack_lsm.c

2447

struct socket_smack *ssp = smack_sock(sk);

security/smack/smack_lsm.c

2453

ssp->smk_in = &smack_known_web;

security/smack/smack_lsm.c

2454

ssp->smk_out = &smack_known_web;

security/smack/smack_lsm.c

2456

ssp->smk_in = skp;

security/smack/smack_lsm.c

2457

ssp->smk_out = skp;

security/smack/smack_lsm.c

2459

ssp->smk_packet = NULL;

security/smack/smack_lsm.c

2616

struct socket_smack *ssp = smack_sock(sk);

security/smack/smack_lsm.c

2617

struct smack_known *skp = ssp->smk_out;

security/smack/smack_lsm.c

2627

ssp->smk_state = SMK_NETLBL_LABELED;

security/smack/smack_lsm.c

2630

ssp->smk_state = SMK_NETLBL_REQSKB;

security/smack/smack_lsm.c

2649

struct socket_smack *ssp = smack_sock(sk);

security/smack/smack_lsm.c

2654

if (ssp->smk_state != SMK_NETLBL_LABELED)

security/smack/smack_lsm.c

2662

ssp->smk_state = SMK_NETLBL_UNLABELED;

security/smack/smack_lsm.c

2681

struct socket_smack *ssp = smack_sock(sk);

security/smack/smack_lsm.c

2695

skp = ssp->smk_out;

security/smack/smack_lsm.c

2756

struct socket_smack *ssp = smack_sock(sock->sk);

security/smack/smack_lsm.c

2770

spp->smk_in = ssp->smk_in;

security/smack/smack_lsm.c

2771

spp->smk_out = ssp->smk_out;

security/smack/smack_lsm.c

2805

spp->smk_in = ssp->smk_in;

security/smack/smack_lsm.c

2806

spp->smk_out = ssp->smk_out;

security/smack/smack_lsm.c

2821

spp->smk_in = ssp->smk_in;

security/smack/smack_lsm.c

2822

spp->smk_out = ssp->smk_out;

security/smack/smack_lsm.c

2844

struct socket_smack *ssp = smack_sock(sk);

security/smack/smack_lsm.c

2851

object = ssp->smk_in;

security/smack/smack_lsm.c

2853

skp = ssp->smk_out;

security/smack/smack_lsm.c

2886

ssp->smk_packet = spp->smk_out;

security/smack/smack_lsm.c

2912

struct socket_smack *ssp;

security/smack/smack_lsm.c

2947

ssp = smack_sock(sock->sk);

security/smack/smack_lsm.c

2950

ssp->smk_in = skp;

security/smack/smack_lsm.c

2952

ssp->smk_out = skp;

security/smack/smack_lsm.c

2986

struct socket_smack *ssp;

security/smack/smack_lsm.c

2995

ssp = smack_sock(sock->sk);

security/smack/smack_lsm.c

2996

ssp->smk_in = &smack_known_web;

security/smack/smack_lsm.c

2997

ssp->smk_out = &smack_known_web;

security/smack/smack_lsm.c

3086

struct socket_smack *ssp = smack_sock(sock->sk);

security/smack/smack_lsm.c

3088

rc = smk_ipv6_check(ssp->smk_out, rsp, sip,

security/smack/smack_lsm.c

3175

struct smack_known *ssp = smack_of_ipc(isp);

security/smack/smack_lsm.c

3183

rc = smk_curacc(ssp, access, &ad);

security/smack/smack_lsm.c

3184

rc = smk_bu_current("shm", ssp, access, rc);

security/smack/smack_lsm.c

3264

struct smack_known *ssp = smack_of_ipc(isp);

security/smack/smack_lsm.c

3272

rc = smk_curacc(ssp, access, &ad);

security/smack/smack_lsm.c

3273

rc = smk_bu_current("sem", ssp, access, rc);

security/smack/smack_lsm.c

3928

struct socket_smack *ssp = smack_sock(sock);

security/smack/smack_lsm.c

3938

skp = ssp->smk_out;

security/smack/smack_lsm.c

3948

skp = ssp->smk_in;

security/smack/smack_lsm.c

3959

nsp->smk_packet = ssp->smk_out;

security/smack/smack_lsm.c

3960

ssp->smk_packet = osp->smk_out;

security/smack/smack_lsm.c

3982

struct socket_smack *ssp = smack_sock(sock->sk);

security/smack/smack_lsm.c

3997

rc = smk_access(ssp->smk_out, osp->smk_in, MAY_WRITE, &ad);

security/smack/smack_lsm.c

3998

rc = smk_bu_note("UDS send", ssp->smk_out, osp->smk_in, MAY_WRITE, rc);

security/smack/smack_lsm.c

4020

struct socket_smack *ssp = smack_sock(sock->sk);

security/smack/smack_lsm.c

4046

rc = smk_ipv6_check(ssp->smk_out, rsp, sap,

security/smack/smack_lsm.c

4066

struct socket_smack *ssp)

security/smack/smack_lsm.c

4128

if (ssp != NULL && ssp->smk_in == &smack_known_star)

security/smack/smack_lsm.c

4219

struct socket_smack *ssp = NULL;

security/smack/smack_lsm.c

4225

ssp = smack_sock(sk);

security/smack/smack_lsm.c

4228

skp = smack_from_secattr(&secattr, ssp);

security/smack/smack_lsm.c

4247

struct socket_smack *ssp = smack_sock(sk);

security/smack/smack_lsm.c

4289

rc = smk_access(skp, ssp->smk_in, MAY_WRITE, &ad);

security/smack/smack_lsm.c

4290

rc = smk_bu_note("IPv4 delivery", skp, ssp->smk_in,

security/smack/smack_lsm.c

4315

rc = smk_access(skp, ssp->smk_in, MAY_WRITE, &ad);

security/smack/smack_lsm.c

4316

rc = smk_bu_note("IPv6 delivery", skp, ssp->smk_in,

security/smack/smack_lsm.c

4345

struct socket_smack *ssp;

security/smack/smack_lsm.c

4350

ssp = smack_sock(sock->sk);

security/smack/smack_lsm.c

4351

if (ssp->smk_packet != NULL) {

security/smack/smack_lsm.c

4352

rcp = ssp->smk_packet->smk_known;

security/smack/smack_lsm.c

4381

struct socket_smack *ssp = NULL;

security/smack/smack_lsm.c

4400

ssp = smack_sock(sock->sk);

security/smack/smack_lsm.c

4401

s = ssp->smk_out->smk_secid;

security/smack/smack_lsm.c

4446

struct socket_smack *ssp = smack_sock(sk);

security/smack/smack_lsm.c

4492

rc = smk_access(skp, ssp->smk_in, MAY_WRITE, &ad);

security/smack/smack_lsm.c

4493

rc = smk_bu_note("IPv4 connect", skp, ssp->smk_in, MAY_WRITE, rc);

security/smack/smack_lsm.c

4515

rc = netlbl_req_setattr(req, &ssp->smk_out->smk_netlabel);

security/smack/smack_lsm.c

4532

struct socket_smack *ssp = smack_sock(sk);

security/smack/smack_lsm.c

4537

ssp->smk_packet = skp;

security/smack/smack_lsm.c

4539

ssp->smk_packet = NULL;

security/smack/smack_netfilter.c

26

struct socket_smack *ssp;

security/smack/smack_netfilter.c

30

ssp = smack_sock(sk);

security/smack/smack_netfilter.c

31

skp = ssp->smk_out;

sound/soc/intel/avs/utils.h

74

#define AVS_STRING_FMT(prefix, suffix, ssp, tdm) \

sound/soc/intel/avs/utils.h

75

(tdm) ? prefix "%d:%d" suffix : prefix "%d" suffix, (ssp), (tdm)

sound/soc/intel/boards/sof_es8336.c

644

unsigned long ssp;

sound/soc/intel/boards/sof_es8336.c

647

ssp = fls(mach->mach_params.i2s_link_mask) - 1;

sound/soc/intel/boards/sof_es8336.c

649

quirk |= ssp;

sound/soc/intel/catpt/registers.h

153

#define catpt_ssp_addr(cdev, ssp) \

sound/soc/intel/catpt/registers.h

154

((cdev)->lpe_ba + (cdev)->spec->host_ssp_offset[ssp])

sound/soc/intel/catpt/registers.h

160

#define catpt_writel_ssp(cdev, ssp, reg, val) \

sound/soc/intel/catpt/registers.h

161

writel(val, catpt_ssp_addr(cdev, ssp) + (reg))

sound/soc/intel/catpt/registers.h

35

#define CATPT_CS_SFCR(ssp) BIT(27 + (ssp))

sound/soc/intel/catpt/registers.h

39

#define CATPT_CS_SDPM(ssp) BIT(11 + (ssp))

sound/soc/intel/catpt/registers.h

44

#define CATPT_CS_SBCS(ssp) BIT(2 + (ssp))

sound/soc/pxa/pxa-ssp.c

103

struct ssp_device *ssp = priv->ssp;

sound/soc/pxa/pxa-ssp.c

106

pxa_ssp_disable(ssp);

sound/soc/pxa/pxa-ssp.c

107

clk_disable_unprepare(ssp->clk);

sound/soc/pxa/pxa-ssp.c

121

struct ssp_device *ssp = priv->ssp;

sound/soc/pxa/pxa-ssp.c

124

clk_prepare_enable(ssp->clk);

sound/soc/pxa/pxa-ssp.c

126

priv->cr0 = __raw_readl(ssp->mmio_base + SSCR0);

sound/soc/pxa/pxa-ssp.c

127

priv->cr1 = __raw_readl(ssp->mmio_base + SSCR1);

sound/soc/pxa/pxa-ssp.c

128

priv->to = __raw_readl(ssp->mmio_base + SSTO);

sound/soc/pxa/pxa-ssp.c

129

priv->psp = __raw_readl(ssp->mmio_base + SSPSP);

sound/soc/pxa/pxa-ssp.c

131

pxa_ssp_disable(ssp);

sound/soc/pxa/pxa-ssp.c

132

clk_disable_unprepare(ssp->clk);

sound/soc/pxa/pxa-ssp.c

139

struct ssp_device *ssp = priv->ssp;

sound/soc/pxa/pxa-ssp.c

142

clk_prepare_enable(ssp->clk);

sound/soc/pxa/pxa-ssp.c

144

__raw_writel(sssr, ssp->mmio_base + SSSR);

sound/soc/pxa/pxa-ssp.c

145

__raw_writel(priv->cr0 & ~SSCR0_SSE, ssp->mmio_base + SSCR0);

sound/soc/pxa/pxa-ssp.c

146

__raw_writel(priv->cr1, ssp->mmio_base + SSCR1);

sound/soc/pxa/pxa-ssp.c

147

__raw_writel(priv->to, ssp->mmio_base + SSTO);

sound/soc/pxa/pxa-ssp.c

148

__raw_writel(priv->psp, ssp->mmio_base + SSPSP);

sound/soc/pxa/pxa-ssp.c

151

pxa_ssp_enable(ssp);

sound/soc/pxa/pxa-ssp.c

153

clk_disable_unprepare(ssp->clk);

sound/soc/pxa/pxa-ssp.c

167

static void pxa_ssp_set_scr(struct ssp_device *ssp, u32 div)

sound/soc/pxa/pxa-ssp.c

169

u32 sscr0 = pxa_ssp_read_reg(ssp, SSCR0);

sound/soc/pxa/pxa-ssp.c

171

if (ssp->type == PXA25x_SSP) {

sound/soc/pxa/pxa-ssp.c

178

pxa_ssp_write_reg(ssp, SSCR0, sscr0);

sound/soc/pxa/pxa-ssp.c

188

struct ssp_device *ssp = priv->ssp;

sound/soc/pxa/pxa-ssp.c

190

u32 sscr0 = pxa_ssp_read_reg(ssp, SSCR0) &

sound/soc/pxa/pxa-ssp.c

208

dev_dbg(ssp->dev,

sound/soc/pxa/pxa-ssp.c

218

if (ssp->type == PXA25x_SSP)

sound/soc/pxa/pxa-ssp.c

233

pxa_ssp_set_scr(ssp, 1);

sound/soc/pxa/pxa-ssp.c

242

if (ssp->type != PXA3xx_SSP)

sound/soc/pxa/pxa-ssp.c

243

clk_disable_unprepare(ssp->clk);

sound/soc/pxa/pxa-ssp.c

244

pxa_ssp_write_reg(ssp, SSCR0, sscr0);

sound/soc/pxa/pxa-ssp.c

245

if (ssp->type != PXA3xx_SSP)

sound/soc/pxa/pxa-ssp.c

246

clk_prepare_enable(ssp->clk);

sound/soc/pxa/pxa-ssp.c

256

struct ssp_device *ssp = priv->ssp;

sound/soc/pxa/pxa-ssp.c

257

u32 ssacd = pxa_ssp_read_reg(ssp, SSACD) & ~0x70;

sound/soc/pxa/pxa-ssp.c

259

if (ssp->type == PXA3xx_SSP)

sound/soc/pxa/pxa-ssp.c

260

pxa_ssp_write_reg(ssp, SSACDD, 0);

sound/soc/pxa/pxa-ssp.c

288

if (ssp->type == PXA3xx_SSP) {

sound/soc/pxa/pxa-ssp.c

297

pxa_ssp_write_reg(ssp, SSACDD, val);

sound/soc/pxa/pxa-ssp.c

301

dev_dbg(ssp->dev,

sound/soc/pxa/pxa-ssp.c

310

pxa_ssp_write_reg(ssp, SSACD, ssacd);

sound/soc/pxa/pxa-ssp.c

322

struct ssp_device *ssp = priv->ssp;

sound/soc/pxa/pxa-ssp.c

325

sscr0 = pxa_ssp_read_reg(ssp, SSCR0);

sound/soc/pxa/pxa-ssp.c

342

pxa_ssp_write_reg(ssp, SSTSA, tx_mask);

sound/soc/pxa/pxa-ssp.c

343

pxa_ssp_write_reg(ssp, SSRSA, rx_mask);

sound/soc/pxa/pxa-ssp.c

345

pxa_ssp_write_reg(ssp, SSCR0, sscr0);

sound/soc/pxa/pxa-ssp.c

357

struct ssp_device *ssp = priv->ssp;

sound/soc/pxa/pxa-ssp.c

360

sscr1 = pxa_ssp_read_reg(ssp, SSCR1);

sound/soc/pxa/pxa-ssp.c

365

pxa_ssp_write_reg(ssp, SSCR1, sscr1);

sound/soc/pxa/pxa-ssp.c

39

struct ssp_device *ssp;

sound/soc/pxa/pxa-ssp.c

417

struct ssp_device *ssp = priv->ssp;

sound/soc/pxa/pxa-ssp.c

425

sscr0 = pxa_ssp_read_reg(ssp, SSCR0) &

sound/soc/pxa/pxa-ssp.c

427

sscr1 = pxa_ssp_read_reg(ssp, SSCR1) &

sound/soc/pxa/pxa-ssp.c

430

sspsp = pxa_ssp_read_reg(ssp, SSPSP) &

sound/soc/pxa/pxa-ssp.c

483

pxa_ssp_write_reg(ssp, SSCR0, sscr0);

sound/soc/pxa/pxa-ssp.c

484

pxa_ssp_write_reg(ssp, SSCR1, sscr1);

sound/soc/pxa/pxa-ssp.c

485

pxa_ssp_write_reg(ssp, SSPSP, sspsp);

sound/soc/pxa/pxa-ssp.c

490

scfr = pxa_ssp_read_reg(ssp, SSCR1) | SSCR1_SCFR;

sound/soc/pxa/pxa-ssp.c

491

pxa_ssp_write_reg(ssp, SSCR1, scfr);

sound/soc/pxa/pxa-ssp.c

493

while (pxa_ssp_read_reg(ssp, SSSR) & SSSR_BSY)

sound/soc/pxa/pxa-ssp.c

498

dump_registers(ssp);

sound/soc/pxa/pxa-ssp.c

53

static void dump_registers(struct ssp_device *ssp)

sound/soc/pxa/pxa-ssp.c

536

struct ssp_device *ssp = priv->ssp;

sound/soc/pxa/pxa-ssp.c

540

int ttsa = pxa_ssp_read_reg(ssp, SSTSA) & 0xf;

sound/soc/pxa/pxa-ssp.c

55

dev_dbg(ssp->dev, "SSCR0 0x%08x SSCR1 0x%08x SSTO 0x%08x\n",

sound/soc/pxa/pxa-ssp.c

552

pxa_ssp_set_dma_params(ssp,

sound/soc/pxa/pxa-ssp.c

557

if (pxa_ssp_read_reg(ssp, SSCR0) & SSCR0_SSE)

sound/soc/pxa/pxa-ssp.c

56

pxa_ssp_read_reg(ssp, SSCR0), pxa_ssp_read_reg(ssp, SSCR1),

sound/soc/pxa/pxa-ssp.c

565

sscr0 = pxa_ssp_read_reg(ssp, SSCR0) & ~(SSCR0_DSS | SSCR0_EDSS);

sound/soc/pxa/pxa-ssp.c

57

pxa_ssp_read_reg(ssp, SSTO));

sound/soc/pxa/pxa-ssp.c

570

if (ssp->type == PXA3xx_SSP)

sound/soc/pxa/pxa-ssp.c

581

pxa_ssp_write_reg(ssp, SSCR0, sscr0);

sound/soc/pxa/pxa-ssp.c

59

dev_dbg(ssp->dev, "SSPSP 0x%08x SSSR 0x%08x SSACD 0x%08x\n",

sound/soc/pxa/pxa-ssp.c

60

pxa_ssp_read_reg(ssp, SSPSP), pxa_ssp_read_reg(ssp, SSSR),

sound/soc/pxa/pxa-ssp.c

608

ssacd = pxa_ssp_read_reg(ssp, SSACD);

sound/soc/pxa/pxa-ssp.c

61

pxa_ssp_read_reg(ssp, SSACD));

sound/soc/pxa/pxa-ssp.c

612

pxa_ssp_write_reg(ssp, SSACD, ssacd);

sound/soc/pxa/pxa-ssp.c

620

pxa_ssp_set_scr(ssp, bclk / rate);

sound/soc/pxa/pxa-ssp.c

625

sspsp = pxa_ssp_read_reg(ssp, SSPSP);

sound/soc/pxa/pxa-ssp.c

636

if (ssp->type != PXA3xx_SSP)

sound/soc/pxa/pxa-ssp.c

64

static void pxa_ssp_set_dma_params(struct ssp_device *ssp, int width4,

sound/soc/pxa/pxa-ssp.c

656

pxa_ssp_write_reg(ssp, SSPSP, sspsp);

sound/soc/pxa/pxa-ssp.c

666

dev_err(ssp->dev, "No TDM timeslot configured\n");

sound/soc/pxa/pxa-ssp.c

670

dump_registers(ssp);

sound/soc/pxa/pxa-ssp.c

676

struct ssp_device *ssp, int value)

sound/soc/pxa/pxa-ssp.c

678

uint32_t sscr0 = pxa_ssp_read_reg(ssp, SSCR0);

sound/soc/pxa/pxa-ssp.c

679

uint32_t sscr1 = pxa_ssp_read_reg(ssp, SSCR1);

sound/soc/pxa/pxa-ssp.c

680

uint32_t sspsp = pxa_ssp_read_reg(ssp, SSPSP);

sound/soc/pxa/pxa-ssp.c

681

uint32_t sssr = pxa_ssp_read_reg(ssp, SSSR);

sound/soc/pxa/pxa-ssp.c

684

pxa_ssp_write_reg(ssp, SSCR0, sscr0 & ~SSCR0_SSE);

sound/soc/pxa/pxa-ssp.c

698

pxa_ssp_write_reg(ssp, SSCR1, sscr1);

sound/soc/pxa/pxa-ssp.c

70

dma->addr = ssp->phys_base + SSDR;

sound/soc/pxa/pxa-ssp.c

701

pxa_ssp_write_reg(ssp, SSSR, sssr);

sound/soc/pxa/pxa-ssp.c

702

pxa_ssp_write_reg(ssp, SSPSP, sspsp);

sound/soc/pxa/pxa-ssp.c

703

pxa_ssp_write_reg(ssp, SSCR0, sscr0 | SSCR0_SSE);

sound/soc/pxa/pxa-ssp.c

712

struct ssp_device *ssp = priv->ssp;

sound/soc/pxa/pxa-ssp.c

717

pxa_ssp_enable(ssp);

sound/soc/pxa/pxa-ssp.c

720

pxa_ssp_set_running_bit(substream, ssp, 1);

sound/soc/pxa/pxa-ssp.c

721

val = pxa_ssp_read_reg(ssp, SSSR);

sound/soc/pxa/pxa-ssp.c

722

pxa_ssp_write_reg(ssp, SSSR, val);

sound/soc/pxa/pxa-ssp.c

725

pxa_ssp_set_running_bit(substream, ssp, 1);

sound/soc/pxa/pxa-ssp.c

728

pxa_ssp_set_running_bit(substream, ssp, 0);

sound/soc/pxa/pxa-ssp.c

731

pxa_ssp_disable(ssp);

sound/soc/pxa/pxa-ssp.c

734

pxa_ssp_set_running_bit(substream, ssp, 0);

sound/soc/pxa/pxa-ssp.c

741

dump_registers(ssp);

sound/soc/pxa/pxa-ssp.c

766

priv->ssp = pxa_ssp_request_of(ssp_handle, "SoC audio");

sound/soc/pxa/pxa-ssp.c

767

if (priv->ssp == NULL) {

sound/soc/pxa/pxa-ssp.c

77

struct ssp_device *ssp = priv->ssp;

sound/soc/pxa/pxa-ssp.c

781

priv->ssp = pxa_ssp_request(dai->id + 1, "SoC audio");

sound/soc/pxa/pxa-ssp.c

782

if (priv->ssp == NULL) {

sound/soc/pxa/pxa-ssp.c

802

pxa_ssp_free(priv->ssp);

sound/soc/pxa/pxa-ssp.c

82

clk_prepare_enable(ssp->clk);

sound/soc/pxa/pxa-ssp.c

83

pxa_ssp_disable(ssp);

sound/soc/sof/ipc3-pcm.c

201

if (config->ssp.fsync_rate == params_rate(params)) {

sound/soc/sof/ipc3-pcm.c

259

rate->min = private->dai_config[dai->current_config].ssp.fsync_rate;

sound/soc/sof/ipc3-pcm.c

260

rate->max = private->dai_config[dai->current_config].ssp.fsync_rate;

sound/soc/sof/ipc3-pcm.c

261

channels->min = private->dai_config[dai->current_config].ssp.tdm_slots;

sound/soc/sof/ipc3-pcm.c

262

channels->max = private->dai_config[dai->current_config].ssp.tdm_slots;

sound/soc/sof/ipc3-topology.c

1408

ret = sof_update_ipc_object(scomp, &config->ssp, SOF_SSP_TOKENS, slink->tuples,

sound/soc/sof/ipc3-topology.c

1425

config[i].ssp.mclk_id, sdev->mclk_id_quirk);

sound/soc/sof/ipc3-topology.c

1426

config[i].ssp.mclk_id = sdev->mclk_id_quirk;

sound/soc/sof/ipc3-topology.c

1430

config[i].ssp.mclk_rate = le32_to_cpu(hw_config[i].mclk_rate);

sound/soc/sof/ipc3-topology.c

1431

config[i].ssp.bclk_rate = le32_to_cpu(hw_config[i].bclk_rate);

sound/soc/sof/ipc3-topology.c

1432

config[i].ssp.fsync_rate = le32_to_cpu(hw_config[i].fsync_rate);

sound/soc/sof/ipc3-topology.c

1433

config[i].ssp.tdm_slots = le32_to_cpu(hw_config[i].tdm_slots);

sound/soc/sof/ipc3-topology.c

1434

config[i].ssp.tdm_slot_width = le32_to_cpu(hw_config[i].tdm_slot_width);

sound/soc/sof/ipc3-topology.c

1435

config[i].ssp.mclk_direction = hw_config[i].mclk_direction;

sound/soc/sof/ipc3-topology.c

1436

config[i].ssp.rx_slots = le32_to_cpu(hw_config[i].rx_slots);

sound/soc/sof/ipc3-topology.c

1437

config[i].ssp.tx_slots = le32_to_cpu(hw_config[i].tx_slots);

sound/soc/sof/ipc3-topology.c

1441

config[i].ssp.mclk_rate, config[i].ssp.bclk_rate,

sound/soc/sof/ipc3-topology.c

1442

config[i].ssp.fsync_rate, config[i].ssp.sample_valid_bits,

sound/soc/sof/ipc3-topology.c

1443

config[i].ssp.tdm_slot_width, config[i].ssp.tdm_slots,

sound/soc/sof/ipc3-topology.c

1444

config[i].ssp.mclk_id, config[i].ssp.quirks, config[i].ssp.clks_control);

sound/soc/sof/ipc3-topology.c

1447

if (config[i].ssp.fsync_rate < 8000 || config[i].ssp.fsync_rate > 192000) {

sound/soc/sof/ipc3-topology.c

1452

if (config[i].ssp.tdm_slots < 1 || config[i].ssp.tdm_slots > 8) {

sound/soc/sof/ipc3-topology.c

2533

return private->dai_config->ssp.mclk_rate;

sound/soc/sof/ipc3-topology.c

2535

return private->dai_config->ssp.bclk_rate;

sound/soc/sof/ipc3-topology.c

2537

return private->dai_config->ssp.tdm_slots;

tools/testing/selftests/riscv/cfi/shadowstack.c

28

unsigned long ssp = 0;

tools/testing/selftests/riscv/cfi/shadowstack.c

30

ssp = csr_read(CSR_SSP);

tools/testing/selftests/riscv/cfi/shadowstack.c

33

ssp);

tools/testing/selftests/riscv/cfi/shadowstack.c

48

unsigned long ssp = 0;

tools/testing/selftests/riscv/cfi/shadowstack.c

50

ssp = csr_read(CSR_SSP);

tools/testing/selftests/riscv/cfi/shadowstack.c

53

ssp);

tools/testing/selftests/x86/test_shadow_stack.c

1004

saved_ssp = ssp;

tools/testing/selftests/x86/test_shadow_stack.c

1012

iov.iov_len = sizeof(ssp) + 1;

tools/testing/selftests/x86/test_shadow_stack.c

1018

ssp += 1;

tools/testing/selftests/x86/test_shadow_stack.c

1024

ssp = 0xFFFFFFFFFFFF0000;

tools/testing/selftests/x86/test_shadow_stack.c

1034

ssp = saved_ssp + 8;

tools/testing/selftests/x86/test_shadow_stack.c

1035

iov.iov_len = sizeof(ssp);

tools/testing/selftests/x86/test_shadow_stack.c

135

unsigned long ssp;

tools/testing/selftests/x86/test_shadow_stack.c

140

ssp = get_ssp();

tools/testing/selftests/x86/test_shadow_stack.c

141

printf("[INFO]\tchanging ssp from %lx to %lx\n", ssp, new_ssp);

tools/testing/selftests/x86/test_shadow_stack.c

148

ssp -= 8;

tools/testing/selftests/x86/test_shadow_stack.c

149

asm volatile("rstorssp (%0)\n":: "r" (ssp));

tools/testing/selftests/x86/test_shadow_stack.c

964

unsigned long saved_ssp, ssp = 0;

tools/testing/selftests/x86/test_shadow_stack.c

970

iov.iov_base = &ssp;

tools/testing/selftests/x86/test_shadow_stack.c

971

iov.iov_len = sizeof(ssp);

tools/testing/selftests/x86/test_shadow_stack.c

975

ssp = get_ssp();

tools/testing/selftests/x86/test_shadow_stack.c

999

if (!ssp) {