drivers/accel/ivpu/ivpu_job.c

101

cmdq = kzalloc_obj(*cmdq);

drivers/accel/ivpu/ivpu_job.c

1015

cmdq = ivpu_cmdq_create(file_priv, ivpu_job_to_jsm_priority(args->priority), args->flags);

drivers/accel/ivpu/ivpu_job.c

1016

if (cmdq)

drivers/accel/ivpu/ivpu_job.c

1017

args->cmdq_id = cmdq->id;

drivers/accel/ivpu/ivpu_job.c

102

if (!cmdq)

drivers/accel/ivpu/ivpu_job.c

1023

return cmdq ? 0 : -ENOMEM;

drivers/accel/ivpu/ivpu_job.c

1031

struct ivpu_cmdq *cmdq;

drivers/accel/ivpu/ivpu_job.c

1046

cmdq = xa_load(&file_priv->cmdq_xa, args->cmdq_id);

drivers/accel/ivpu/ivpu_job.c

1047

if (!cmdq || cmdq->is_legacy) {

drivers/accel/ivpu/ivpu_job.c

105

cmdq->mem = ivpu_bo_create_global(vdev, SZ_4K, DRM_IVPU_BO_WC | DRM_IVPU_BO_MAPPABLE);

drivers/accel/ivpu/ivpu_job.c

1050

cmdq_id = cmdq->id;

drivers/accel/ivpu/ivpu_job.c

1051

ivpu_cmdq_destroy(file_priv, cmdq);

drivers/accel/ivpu/ivpu_job.c

106

if (!cmdq->mem)

drivers/accel/ivpu/ivpu_job.c

109

return cmdq;

drivers/accel/ivpu/ivpu_job.c

112

kfree(cmdq);

drivers/accel/ivpu/ivpu_job.c

122

static inline u32 ivpu_cmdq_get_entry_count(struct ivpu_cmdq *cmdq)

drivers/accel/ivpu/ivpu_job.c

124

size_t size = ivpu_bo_size(cmdq->mem) - sizeof(struct vpu_job_queue_header);

drivers/accel/ivpu/ivpu_job.c

153

static void ivpu_cmdq_free(struct ivpu_file_priv *file_priv, struct ivpu_cmdq *cmdq)

drivers/accel/ivpu/ivpu_job.c

155

ivpu_preemption_buffers_free(file_priv->vdev, file_priv, cmdq);

drivers/accel/ivpu/ivpu_job.c

156

ivpu_bo_free(cmdq->mem);

drivers/accel/ivpu/ivpu_job.c

157

kfree(cmdq);

drivers/accel/ivpu/ivpu_job.c

163

struct ivpu_cmdq *cmdq = NULL;

drivers/accel/ivpu/ivpu_job.c

168

cmdq = ivpu_cmdq_alloc(file_priv);

drivers/accel/ivpu/ivpu_job.c

169

if (!cmdq) {

drivers/accel/ivpu/ivpu_job.c

173

ret = xa_alloc_cyclic(&file_priv->cmdq_xa, &cmdq->id, cmdq, file_priv->cmdq_limit,

drivers/accel/ivpu/ivpu_job.c

180

cmdq->entry_count = ivpu_cmdq_get_entry_count(cmdq);

drivers/accel/ivpu/ivpu_job.c

181

cmdq->priority = priority;

drivers/accel/ivpu/ivpu_job.c

183

cmdq->jobq = (struct vpu_job_queue *)ivpu_bo_vaddr(cmdq->mem);

drivers/accel/ivpu/ivpu_job.c

184

cmdq->jobq->header.engine_idx = VPU_ENGINE_COMPUTE;

drivers/accel/ivpu/ivpu_job.c

185

cmdq->jobq->header.flags = ivpu_cmdq_get_flags(vdev, flags);

drivers/accel/ivpu/ivpu_job.c

188

cmdq->id, file_priv->ctx.id, cmdq->jobq->header.flags);

drivers/accel/ivpu/ivpu_job.c

189

return cmdq;

drivers/accel/ivpu/ivpu_job.c

192

ivpu_cmdq_free(file_priv, cmdq);

drivers/accel/ivpu/ivpu_job.c

196

static int ivpu_hws_cmdq_init(struct ivpu_file_priv *file_priv, struct ivpu_cmdq *cmdq, u16 engine,

drivers/accel/ivpu/ivpu_job.c

202

ret = ivpu_jsm_hws_create_cmdq(vdev, file_priv->ctx.id, file_priv->ctx.id, cmdq->id,

drivers/accel/ivpu/ivpu_job.c

204

cmdq->mem->vpu_addr, ivpu_bo_size(cmdq->mem));

drivers/accel/ivpu/ivpu_job.c

208

ret = ivpu_jsm_hws_set_context_sched_properties(vdev, file_priv->ctx.id, cmdq->id,

drivers/accel/ivpu/ivpu_job.c

216

static int ivpu_register_db(struct ivpu_file_priv *file_priv, struct ivpu_cmdq *cmdq)

drivers/accel/ivpu/ivpu_job.c

221

ret = xa_alloc_cyclic(&vdev->db_xa, &cmdq->db_id, NULL, vdev->db_limit, &vdev->db_next,

drivers/accel/ivpu/ivpu_job.c

229

ret = ivpu_jsm_hws_register_db(vdev, file_priv->ctx.id, cmdq->id, cmdq->db_id,

drivers/accel/ivpu/ivpu_job.c

230

cmdq->mem->vpu_addr, ivpu_bo_size(cmdq->mem));

drivers/accel/ivpu/ivpu_job.c

232

ret = ivpu_jsm_register_db(vdev, file_priv->ctx.id, cmdq->db_id,

drivers/accel/ivpu/ivpu_job.c

233

cmdq->mem->vpu_addr, ivpu_bo_size(cmdq->mem));

drivers/accel/ivpu/ivpu_job.c

237

cmdq->db_id, cmdq->id, file_priv->ctx.id, cmdq->priority);

drivers/accel/ivpu/ivpu_job.c

239

xa_erase(&vdev->db_xa, cmdq->db_id);

drivers/accel/ivpu/ivpu_job.c

240

cmdq->db_id = 0;

drivers/accel/ivpu/ivpu_job.c

254

static int ivpu_cmdq_register(struct ivpu_file_priv *file_priv, struct ivpu_cmdq *cmdq)

drivers/accel/ivpu/ivpu_job.c

261

if (cmdq->db_id)

drivers/accel/ivpu/ivpu_job.c

264

ivpu_cmdq_jobq_reset(vdev, cmdq->jobq);

drivers/accel/ivpu/ivpu_job.c

267

ret = ivpu_hws_cmdq_init(file_priv, cmdq, VPU_ENGINE_COMPUTE, cmdq->priority);

drivers/accel/ivpu/ivpu_job.c

272

ret = ivpu_register_db(file_priv, cmdq);

drivers/accel/ivpu/ivpu_job.c

279

static int ivpu_cmdq_unregister(struct ivpu_file_priv *file_priv, struct ivpu_cmdq *cmdq)

drivers/accel/ivpu/ivpu_job.c

286

if (!cmdq->db_id)

drivers/accel/ivpu/ivpu_job.c

289

ret = ivpu_jsm_unregister_db(vdev, cmdq->db_id);

drivers/accel/ivpu/ivpu_job.c

29

static void ivpu_cmdq_ring_db(struct ivpu_device *vdev, struct ivpu_cmdq *cmdq)

drivers/accel/ivpu/ivpu_job.c

291

ivpu_dbg(vdev, JOB, "DB %d unregistered\n", cmdq->db_id);

drivers/accel/ivpu/ivpu_job.c

294

ret = ivpu_jsm_hws_destroy_cmdq(vdev, file_priv->ctx.id, cmdq->id);

drivers/accel/ivpu/ivpu_job.c

297

cmdq->id, file_priv->ctx.id);

drivers/accel/ivpu/ivpu_job.c

300

xa_erase(&file_priv->vdev->db_xa, cmdq->db_id);

drivers/accel/ivpu/ivpu_job.c

301

cmdq->db_id = 0;

drivers/accel/ivpu/ivpu_job.c

31

ivpu_hw_db_set(vdev, cmdq->db_id);

drivers/accel/ivpu/ivpu_job.c

314

static void ivpu_cmdq_destroy(struct ivpu_file_priv *file_priv, struct ivpu_cmdq *cmdq)

drivers/accel/ivpu/ivpu_job.c

316

ivpu_cmdq_unregister(file_priv, cmdq);

drivers/accel/ivpu/ivpu_job.c

317

xa_erase(&file_priv->cmdq_xa, cmdq->id);

drivers/accel/ivpu/ivpu_job.c

318

ivpu_cmdq_free(file_priv, cmdq);

drivers/accel/ivpu/ivpu_job.c

323

struct ivpu_cmdq *cmdq;

drivers/accel/ivpu/ivpu_job.c

328

xa_for_each(&file_priv->cmdq_xa, id, cmdq)

drivers/accel/ivpu/ivpu_job.c

329

if (cmdq->is_legacy && cmdq->priority == priority)

drivers/accel/ivpu/ivpu_job.c

332

if (!cmdq) {

drivers/accel/ivpu/ivpu_job.c

333

cmdq = ivpu_cmdq_create(file_priv, priority, 0);

drivers/accel/ivpu/ivpu_job.c

334

if (!cmdq)

drivers/accel/ivpu/ivpu_job.c

336

cmdq->is_legacy = true;

drivers/accel/ivpu/ivpu_job.c

339

return cmdq;

drivers/accel/ivpu/ivpu_job.c

345

struct ivpu_cmdq *cmdq;

drivers/accel/ivpu/ivpu_job.c

349

cmdq = xa_load(&file_priv->cmdq_xa, cmdq_id);

drivers/accel/ivpu/ivpu_job.c

35

struct ivpu_file_priv *file_priv, struct ivpu_cmdq *cmdq)

drivers/accel/ivpu/ivpu_job.c

350

if (!cmdq) {

drivers/accel/ivpu/ivpu_job.c

355

return cmdq;

drivers/accel/ivpu/ivpu_job.c

360

struct ivpu_cmdq *cmdq;

drivers/accel/ivpu/ivpu_job.c

365

xa_for_each(&file_priv->cmdq_xa, cmdq_id, cmdq)

drivers/accel/ivpu/ivpu_job.c

366

ivpu_cmdq_destroy(file_priv, cmdq);

drivers/accel/ivpu/ivpu_job.c

377

struct ivpu_cmdq *cmdq;

drivers/accel/ivpu/ivpu_job.c

382

xa_for_each(&file_priv->cmdq_xa, cmdq_id, cmdq) {

drivers/accel/ivpu/ivpu_job.c

383

xa_erase(&file_priv->vdev->db_xa, cmdq->db_id);

drivers/accel/ivpu/ivpu_job.c

384

cmdq->db_id = 0;

drivers/accel/ivpu/ivpu_job.c

40

cmdq->primary_preempt_buf = ivpu_bo_create(vdev, &file_priv->ctx, &vdev->hw->ranges.user,

drivers/accel/ivpu/ivpu_job.c

406

struct ivpu_cmdq *cmdq;

drivers/accel/ivpu/ivpu_job.c

412

xa_for_each(&file_priv->cmdq_xa, cmdq_id, cmdq)

drivers/accel/ivpu/ivpu_job.c

413

ivpu_cmdq_unregister(file_priv, cmdq);

drivers/accel/ivpu/ivpu_job.c

423

static int ivpu_cmdq_push_job(struct ivpu_cmdq *cmdq, struct ivpu_job *job)

drivers/accel/ivpu/ivpu_job.c

426

struct vpu_job_queue_header *header = &cmdq->jobq->header;

drivers/accel/ivpu/ivpu_job.c

429

u32 next_entry = (tail + 1) % cmdq->entry_count;

drivers/accel/ivpu/ivpu_job.c

43

if (!cmdq->primary_preempt_buf) {

drivers/accel/ivpu/ivpu_job.c

434

job->file_priv->ctx.id, cmdq->id, cmdq->db_id, header->head, tail);

drivers/accel/ivpu/ivpu_job.c

438

entry = &cmdq->jobq->slot[tail].job;

drivers/accel/ivpu/ivpu_job.c

48

cmdq->secondary_preempt_buf = ivpu_bo_create(vdev, &file_priv->ctx, &vdev->hw->ranges.dma,

drivers/accel/ivpu/ivpu_job.c

51

if (!cmdq->secondary_preempt_buf) {

drivers/accel/ivpu/ivpu_job.c

59

ivpu_bo_free(cmdq->primary_preempt_buf);

drivers/accel/ivpu/ivpu_job.c

60

cmdq->primary_preempt_buf = NULL;

drivers/accel/ivpu/ivpu_job.c

65

struct ivpu_file_priv *file_priv, struct ivpu_cmdq *cmdq)

drivers/accel/ivpu/ivpu_job.c

67

if (cmdq->primary_preempt_buf)

drivers/accel/ivpu/ivpu_job.c

674

struct ivpu_cmdq *cmdq;

drivers/accel/ivpu/ivpu_job.c

68

ivpu_bo_free(cmdq->primary_preempt_buf);

drivers/accel/ivpu/ivpu_job.c

686

cmdq = ivpu_cmdq_acquire_legacy(file_priv, priority);

drivers/accel/ivpu/ivpu_job.c

688

cmdq = ivpu_cmdq_acquire(file_priv, cmdq_id);

drivers/accel/ivpu/ivpu_job.c

689

if (!cmdq) {

drivers/accel/ivpu/ivpu_job.c

69

if (cmdq->secondary_preempt_buf)

drivers/accel/ivpu/ivpu_job.c

694

ret = ivpu_cmdq_register(file_priv, cmdq);

drivers/accel/ivpu/ivpu_job.c

70

ivpu_bo_free(cmdq->secondary_preempt_buf);

drivers/accel/ivpu/ivpu_job.c

700

ret = ivpu_preemption_job_init(vdev, file_priv, cmdq, job);

drivers/accel/ivpu/ivpu_job.c

707

job->cmdq_id = cmdq->id;

drivers/accel/ivpu/ivpu_job.c

719

ret = ivpu_cmdq_push_job(cmdq, job);

drivers/accel/ivpu/ivpu_job.c

726

cmdq->jobq->header.head = cmdq->jobq->header.tail;

drivers/accel/ivpu/ivpu_job.c

729

ivpu_cmdq_ring_db(vdev, cmdq);

drivers/accel/ivpu/ivpu_job.c

736

job->job_id, file_priv->ctx.id, cmdq->id, job->engine_idx, cmdq->priority,

drivers/accel/ivpu/ivpu_job.c

737

job->cmd_buf_vpu_addr, cmdq->jobq->header.tail);

drivers/accel/ivpu/ivpu_job.c

74

struct ivpu_cmdq *cmdq, struct ivpu_job *job)

drivers/accel/ivpu/ivpu_job.c

82

if (!cmdq->primary_preempt_buf) {

drivers/accel/ivpu/ivpu_job.c

84

ret = ivpu_preemption_buffers_create(vdev, file_priv, cmdq);

drivers/accel/ivpu/ivpu_job.c

90

job->primary_preempt_buf = cmdq->primary_preempt_buf;

drivers/accel/ivpu/ivpu_job.c

91

job->secondary_preempt_buf = cmdq->secondary_preempt_buf;

drivers/accel/ivpu/ivpu_job.c

99

struct ivpu_cmdq *cmdq;

drivers/accel/ivpu/ivpu_job.c

996

struct ivpu_cmdq *cmdq;

drivers/accel/ivpu/ivpu_mmu.c

373

struct ivpu_mmu_queue *q = &mmu->cmdq;

drivers/accel/ivpu/ivpu_mmu.c

465

struct ivpu_mmu_queue *cmdq = &vdev->mmu->cmdq;

drivers/accel/ivpu/ivpu_mmu.c

468

ret = REGV_POLL_FLD(IVPU_MMU_REG_CMDQ_CONS, VAL, cmdq->prod,

drivers/accel/ivpu/ivpu_mmu.c

473

cmdq->cons = cmdq->prod;

drivers/accel/ivpu/ivpu_mmu.c

492

struct ivpu_mmu_queue *cmdq = &vdev->mmu->cmdq;

drivers/accel/ivpu/ivpu_mmu.c

493

u64 *queue_buffer = cmdq->base;

drivers/accel/ivpu/ivpu_mmu.c

494

int idx = IVPU_MMU_Q_IDX(cmdq->prod) * (IVPU_MMU_CMDQ_CMD_SIZE / sizeof(*queue_buffer));

drivers/accel/ivpu/ivpu_mmu.c

496

if (ivpu_mmu_queue_is_full(cmdq)) {

drivers/accel/ivpu/ivpu_mmu.c

503

cmdq->prod = (cmdq->prod + 1) & IVPU_MMU_Q_WRAP_MASK;

drivers/accel/ivpu/ivpu_mmu.c

512

struct ivpu_mmu_queue *q = &vdev->mmu->cmdq;

drivers/accel/ivpu/ivpu_mmu.c

570

memset(mmu->cmdq.base, 0, IVPU_MMU_CMDQ_SIZE);

drivers/accel/ivpu/ivpu_mmu.c

572

clflush_cache_range(mmu->cmdq.base, IVPU_MMU_CMDQ_SIZE);

drivers/accel/ivpu/ivpu_mmu.c

573

mmu->cmdq.prod = 0;

drivers/accel/ivpu/ivpu_mmu.c

574

mmu->cmdq.cons = 0;

drivers/accel/ivpu/ivpu_mmu.c

595

REGV_WR64(IVPU_MMU_REG_CMDQ_BASE, mmu->cmdq.dma_q);

drivers/accel/ivpu/ivpu_mmu.h

35

struct ivpu_mmu_queue cmdq;

drivers/atm/fore200e.c

1226

struct host_cmdq* cmdq = &fore200e->host_cmdq;

drivers/atm/fore200e.c

1227

struct host_cmdq_entry* entry = &cmdq->host_entry[ cmdq->head ];

drivers/atm/fore200e.c

1234

FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);

drivers/atm/fore200e.c

1672

struct host_cmdq* cmdq = &fore200e->host_cmdq;

drivers/atm/fore200e.c

1673

struct host_cmdq_entry* entry = &cmdq->host_entry[ cmdq->head ];

drivers/atm/fore200e.c

1689

FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);

drivers/atm/fore200e.c

1718

struct host_cmdq* cmdq = &fore200e->host_cmdq;

drivers/atm/fore200e.c

1719

struct host_cmdq_entry* entry = &cmdq->host_entry[ cmdq->head ];

drivers/atm/fore200e.c

1726

FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);

drivers/atm/fore200e.c

1758

struct host_cmdq* cmdq = &fore200e->host_cmdq;

drivers/atm/fore200e.c

1759

struct host_cmdq_entry* entry = &cmdq->host_entry[ cmdq->head ];

drivers/atm/fore200e.c

1765

FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);

drivers/atm/fore200e.c

2234

struct host_cmdq* cmdq = &fore200e->host_cmdq;

drivers/atm/fore200e.c

2242

&cmdq->status,

drivers/atm/fore200e.c

2255

cmdq->host_entry[ i ].status =

drivers/atm/fore200e.c

2256

FORE200E_INDEX(cmdq->status.align_addr, enum status, i);

drivers/atm/fore200e.c

2257

cmdq->host_entry[ i ].cp_entry = &cp_entry[ i ];

drivers/atm/fore200e.c

2259

*cmdq->host_entry[ i ].status = STATUS_FREE;

drivers/atm/fore200e.c

2261

fore200e->bus->write(FORE200E_DMA_INDEX(cmdq->status.dma_addr, enum status, i),

drivers/atm/fore200e.c

2266

cmdq->head = 0;

drivers/atm/fore200e.c

557

struct host_cmdq* cmdq = &fore200e->host_cmdq;

drivers/atm/fore200e.c

558

struct host_cmdq_entry* entry = &cmdq->host_entry[ cmdq->head ];

drivers/atm/fore200e.c

563

FORE200E_NEXT_ENTRY(cmdq->head, QUEUE_SIZE_CMD);

drivers/crypto/cavium/nitrox/nitrox_dev.h

107

struct nitrox_cmdq *cmdq;

drivers/crypto/cavium/nitrox/nitrox_hal.c

125

struct nitrox_cmdq *cmdq = &ndev->pkt_inq[i];

drivers/crypto/cavium/nitrox/nitrox_hal.c

138

nitrox_write_csr(ndev, offset, cmdq->dma);

drivers/crypto/cavium/nitrox/nitrox_hal.c

357

struct nitrox_cmdq *cmdq = ndev->aqmq[ring];

drivers/crypto/cavium/nitrox/nitrox_hal.c

380

nitrox_write_csr(ndev, offset, cmdq->dma);

drivers/crypto/cavium/nitrox/nitrox_isr.c

32

struct nitrox_cmdq *cmdq = qvec->cmdq;

drivers/crypto/cavium/nitrox/nitrox_isr.c

337

qvec->cmdq = &ndev->pkt_inq[qvec->ring];

drivers/crypto/cavium/nitrox/nitrox_isr.c

34

slc_cnts.value = readq(cmdq->compl_cnt_csr_addr);

drivers/crypto/cavium/nitrox/nitrox_lib.c

103

struct nitrox_cmdq *cmdq;

drivers/crypto/cavium/nitrox/nitrox_lib.c

106

cmdq = kzalloc_node(sizeof(*cmdq), GFP_KERNEL, ndev->node);

drivers/crypto/cavium/nitrox/nitrox_lib.c

107

if (!cmdq) {

drivers/crypto/cavium/nitrox/nitrox_lib.c

112

cmdq->ndev = ndev;

drivers/crypto/cavium/nitrox/nitrox_lib.c

113

cmdq->qno = i;

drivers/crypto/cavium/nitrox/nitrox_lib.c

114

cmdq->instr_size = sizeof(struct aqmq_command_s);

drivers/crypto/cavium/nitrox/nitrox_lib.c

118

cmdq->dbell_csr_addr = NITROX_CSR_ADDR(ndev, offset);

drivers/crypto/cavium/nitrox/nitrox_lib.c

121

cmdq->compl_cnt_csr_addr = NITROX_CSR_ADDR(ndev, offset);

drivers/crypto/cavium/nitrox/nitrox_lib.c

123

err = nitrox_cmdq_init(cmdq, AQM_Q_ALIGN_BYTES);

drivers/crypto/cavium/nitrox/nitrox_lib.c

125

kfree_sensitive(cmdq);

drivers/crypto/cavium/nitrox/nitrox_lib.c

128

ndev->aqmq[i] = cmdq;

drivers/crypto/cavium/nitrox/nitrox_lib.c

143

struct nitrox_cmdq *cmdq = &ndev->pkt_inq[i];

drivers/crypto/cavium/nitrox/nitrox_lib.c

145

nitrox_cmdq_cleanup(cmdq);

drivers/crypto/cavium/nitrox/nitrox_lib.c

162

struct nitrox_cmdq *cmdq;

drivers/crypto/cavium/nitrox/nitrox_lib.c

165

cmdq = &ndev->pkt_inq[i];

drivers/crypto/cavium/nitrox/nitrox_lib.c

166

cmdq->ndev = ndev;

drivers/crypto/cavium/nitrox/nitrox_lib.c

167

cmdq->qno = i;

drivers/crypto/cavium/nitrox/nitrox_lib.c

168

cmdq->instr_size = sizeof(struct nps_pkt_instr);

drivers/crypto/cavium/nitrox/nitrox_lib.c

172

cmdq->dbell_csr_addr = NITROX_CSR_ADDR(ndev, offset);

drivers/crypto/cavium/nitrox/nitrox_lib.c

175

cmdq->compl_cnt_csr_addr = NITROX_CSR_ADDR(ndev, offset);

drivers/crypto/cavium/nitrox/nitrox_lib.c

177

err = nitrox_cmdq_init(cmdq, PKTIN_Q_ALIGN_BYTES);

drivers/crypto/cavium/nitrox/nitrox_lib.c

25

static int nitrox_cmdq_init(struct nitrox_cmdq *cmdq, int align_bytes)

drivers/crypto/cavium/nitrox/nitrox_lib.c

27

struct nitrox_device *ndev = cmdq->ndev;

drivers/crypto/cavium/nitrox/nitrox_lib.c

29

cmdq->qsize = (ndev->qlen * cmdq->instr_size) + align_bytes;

drivers/crypto/cavium/nitrox/nitrox_lib.c

30

cmdq->unalign_base = dma_alloc_coherent(DEV(ndev), cmdq->qsize,

drivers/crypto/cavium/nitrox/nitrox_lib.c

31

&cmdq->unalign_dma,

drivers/crypto/cavium/nitrox/nitrox_lib.c

33

if (!cmdq->unalign_base)

drivers/crypto/cavium/nitrox/nitrox_lib.c

36

cmdq->dma = PTR_ALIGN(cmdq->unalign_dma, align_bytes);

drivers/crypto/cavium/nitrox/nitrox_lib.c

37

cmdq->base = cmdq->unalign_base + (cmdq->dma - cmdq->unalign_dma);

drivers/crypto/cavium/nitrox/nitrox_lib.c

38

cmdq->write_idx = 0;

drivers/crypto/cavium/nitrox/nitrox_lib.c

40

spin_lock_init(&cmdq->cmd_qlock);

drivers/crypto/cavium/nitrox/nitrox_lib.c

41

spin_lock_init(&cmdq->resp_qlock);

drivers/crypto/cavium/nitrox/nitrox_lib.c

42

spin_lock_init(&cmdq->backlog_qlock);

drivers/crypto/cavium/nitrox/nitrox_lib.c

44

INIT_LIST_HEAD(&cmdq->response_head);

drivers/crypto/cavium/nitrox/nitrox_lib.c

45

INIT_LIST_HEAD(&cmdq->backlog_head);

drivers/crypto/cavium/nitrox/nitrox_lib.c

46

INIT_WORK(&cmdq->backlog_qflush, backlog_qflush_work);

drivers/crypto/cavium/nitrox/nitrox_lib.c

48

atomic_set(&cmdq->pending_count, 0);

drivers/crypto/cavium/nitrox/nitrox_lib.c

49

atomic_set(&cmdq->backlog_count, 0);

drivers/crypto/cavium/nitrox/nitrox_lib.c

53

static void nitrox_cmdq_reset(struct nitrox_cmdq *cmdq)

drivers/crypto/cavium/nitrox/nitrox_lib.c

55

cmdq->write_idx = 0;

drivers/crypto/cavium/nitrox/nitrox_lib.c

56

atomic_set(&cmdq->pending_count, 0);

drivers/crypto/cavium/nitrox/nitrox_lib.c

57

atomic_set(&cmdq->backlog_count, 0);

drivers/crypto/cavium/nitrox/nitrox_lib.c

60

static void nitrox_cmdq_cleanup(struct nitrox_cmdq *cmdq)

drivers/crypto/cavium/nitrox/nitrox_lib.c

64

if (!cmdq)

drivers/crypto/cavium/nitrox/nitrox_lib.c

67

if (!cmdq->unalign_base)

drivers/crypto/cavium/nitrox/nitrox_lib.c

70

ndev = cmdq->ndev;

drivers/crypto/cavium/nitrox/nitrox_lib.c

71

cancel_work_sync(&cmdq->backlog_qflush);

drivers/crypto/cavium/nitrox/nitrox_lib.c

73

dma_free_coherent(DEV(ndev), cmdq->qsize,

drivers/crypto/cavium/nitrox/nitrox_lib.c

74

cmdq->unalign_base, cmdq->unalign_dma);

drivers/crypto/cavium/nitrox/nitrox_lib.c

75

nitrox_cmdq_reset(cmdq);

drivers/crypto/cavium/nitrox/nitrox_lib.c

77

cmdq->dbell_csr_addr = NULL;

drivers/crypto/cavium/nitrox/nitrox_lib.c

78

cmdq->compl_cnt_csr_addr = NULL;

drivers/crypto/cavium/nitrox/nitrox_lib.c

79

cmdq->unalign_base = NULL;

drivers/crypto/cavium/nitrox/nitrox_lib.c

80

cmdq->base = NULL;

drivers/crypto/cavium/nitrox/nitrox_lib.c

81

cmdq->unalign_dma = 0;

drivers/crypto/cavium/nitrox/nitrox_lib.c

82

cmdq->dma = 0;

drivers/crypto/cavium/nitrox/nitrox_lib.c

83

cmdq->qsize = 0;

drivers/crypto/cavium/nitrox/nitrox_lib.c

84

cmdq->instr_size = 0;

drivers/crypto/cavium/nitrox/nitrox_req.h

521

struct nitrox_cmdq *cmdq;

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

230

struct nitrox_cmdq *cmdq)

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

234

spin_lock_bh(&cmdq->backlog_qlock);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

235

list_add_tail(&sr->backlog, &cmdq->backlog_head);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

236

atomic_inc(&cmdq->backlog_count);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

238

spin_unlock_bh(&cmdq->backlog_qlock);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

242

struct nitrox_cmdq *cmdq)

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

246

spin_lock_bh(&cmdq->resp_qlock);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

247

list_add_tail(&sr->response, &cmdq->response_head);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

248

spin_unlock_bh(&cmdq->resp_qlock);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

252

struct nitrox_cmdq *cmdq)

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

254

spin_lock_bh(&cmdq->resp_qlock);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

256

spin_unlock_bh(&cmdq->resp_qlock);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

260

get_first_response_entry(struct nitrox_cmdq *cmdq)

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

262

return list_first_entry_or_null(&cmdq->response_head,

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

266

static inline bool cmdq_full(struct nitrox_cmdq *cmdq, int qlen)

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

268

if (atomic_inc_return(&cmdq->pending_count) > qlen) {

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

269

atomic_dec(&cmdq->pending_count);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

288

struct nitrox_cmdq *cmdq)

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

294

spin_lock_bh(&cmdq->cmd_qlock);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

296

idx = cmdq->write_idx;

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

298

ent = cmdq->base + (idx * cmdq->instr_size);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

299

memcpy(ent, &sr->instr, cmdq->instr_size);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

302

response_list_add(sr, cmdq);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

308

writeq(1, cmdq->dbell_csr_addr);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

310

cmdq->write_idx = incr_index(idx, 1, ndev->qlen);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

312

spin_unlock_bh(&cmdq->cmd_qlock);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

318

static int post_backlog_cmds(struct nitrox_cmdq *cmdq)

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

320

struct nitrox_device *ndev = cmdq->ndev;

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

324

if (!atomic_read(&cmdq->backlog_count))

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

327

spin_lock_bh(&cmdq->backlog_qlock);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

329

list_for_each_entry_safe(sr, tmp, &cmdq->backlog_head, backlog) {

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

331

if (unlikely(cmdq_full(cmdq, ndev->qlen))) {

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

337

atomic_dec(&cmdq->backlog_count);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

342

post_se_instr(sr, cmdq);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

344

spin_unlock_bh(&cmdq->backlog_qlock);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

351

struct nitrox_cmdq *cmdq = sr->cmdq;

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

355

post_backlog_cmds(cmdq);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

357

if (unlikely(cmdq_full(cmdq, ndev->qlen))) {

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

364

backlog_list_add(sr, cmdq);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

367

post_se_instr(sr, cmdq);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

427

sr->cmdq = &ndev->pkt_inq[qno];

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

507

struct nitrox_cmdq *cmdq;

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

509

cmdq = container_of(work, struct nitrox_cmdq, backlog_qflush);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

510

post_backlog_cmds(cmdq);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

537

static void process_response_list(struct nitrox_cmdq *cmdq)

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

539

struct nitrox_device *ndev = cmdq->ndev;

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

546

budget = atomic_read(&cmdq->pending_count);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

549

sr = get_first_response_entry(cmdq);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

565

atomic_dec(&cmdq->pending_count);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

570

response_list_del(sr, cmdq);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

589

struct nitrox_cmdq *cmdq = qvec->cmdq;

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

593

slc_cnts.value = readq(cmdq->compl_cnt_csr_addr);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

597

process_response_list(cmdq);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

603

writeq(slc_cnts.value, cmdq->compl_cnt_csr_addr);

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

605

if (atomic_read(&cmdq->backlog_count))

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

606

schedule_work(&cmdq->backlog_qflush);

drivers/gpu/drm/nouveau/include/nvkm/engine/falcon.h

89

} cmdq, msgq;

drivers/gpu/drm/nouveau/include/nvkm/engine/sec2.h

17

struct nvkm_falcon_cmdq *cmdq;

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

171

} cmdq, msgq;

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

180

} cmdq;

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

119

nvkm_falcon_cmdq_del(&sec2->cmdq);

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

159

(ret = nvkm_falcon_cmdq_new(sec2->qmgr, "cmdq", &sec2->cmdq)) ||

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

45

struct nvkm_falcon_cmdq *cmdq = sec2->cmdq;

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

56

ret = nvkm_falcon_cmdq_send(cmdq, &cmd, nvkm_sec2_finimsg, sec2,

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

68

nvkm_falcon_cmdq_fini(cmdq);

drivers/gpu/drm/nouveau/nvkm/engine/sec2/ga102.c

104

return nvkm_falcon_cmdq_send(sec2->cmdq, &cmd.cmd.hdr,

drivers/gpu/drm/nouveau/nvkm/engine/sec2/ga102.c

137

.cmdq = { 0xc00, 0xc04, 8 },

drivers/gpu/drm/nouveau/nvkm/engine/sec2/ga102.c

50

nvkm_falcon_cmdq_init(sec2->cmdq, msg.queue_info[i].index,

drivers/gpu/drm/nouveau/nvkm/engine/sec2/gp102.c

142

nvkm_falcon_cmdq_init(sec2->cmdq,

drivers/gpu/drm/nouveau/nvkm/engine/sec2/gp102.c

214

.cmdq = { 0xa00, 0xa04, 8 },

drivers/gpu/drm/nouveau/nvkm/engine/sec2/gp102.c

71

return nvkm_falcon_cmdq_send(sec2->cmdq, &cmd.cmd.hdr,

drivers/gpu/drm/nouveau/nvkm/engine/sec2/tu102.c

44

.cmdq = { 0xc00, 0xc04, 8 },

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

100

nvkm_falcon_cmdq_write(struct nvkm_falcon_cmdq *cmdq, struct nvfw_falcon_cmd *cmd)

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

107

ret = nvkm_falcon_cmdq_open(cmdq, cmd->size);

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

109

FLCNQ_ERR(cmdq, "timeout waiting for queue space");

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

113

nvkm_falcon_cmdq_push(cmdq, cmd, cmd->size);

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

114

nvkm_falcon_cmdq_close(cmdq);

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

124

nvkm_falcon_cmdq_send(struct nvkm_falcon_cmdq *cmdq, struct nvfw_falcon_cmd *cmd,

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

131

if (!wait_for_completion_timeout(&cmdq->ready,

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

133

FLCNQ_ERR(cmdq, "timeout waiting for queue ready");

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

137

seq = nvkm_falcon_qmgr_seq_acquire(cmdq->qmgr);

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

149

ret = nvkm_falcon_cmdq_write(cmdq, cmd);

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

152

nvkm_falcon_qmgr_seq_release(cmdq->qmgr, seq);

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

158

FLCNQ_ERR(cmdq, "timeout waiting for reply");

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

162

nvkm_falcon_qmgr_seq_release(cmdq->qmgr, seq);

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

169

nvkm_falcon_cmdq_fini(struct nvkm_falcon_cmdq *cmdq)

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

171

reinit_completion(&cmdq->ready);

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

175

nvkm_falcon_cmdq_init(struct nvkm_falcon_cmdq *cmdq,

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

178

const struct nvkm_falcon_func *func = cmdq->qmgr->falcon->func;

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

180

cmdq->head_reg = func->cmdq.head + index * func->cmdq.stride;

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

181

cmdq->tail_reg = func->cmdq.tail + index * func->cmdq.stride;

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

182

cmdq->offset = offset;

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

183

cmdq->size = size;

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

184

complete_all(&cmdq->ready);

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

186

FLCNQ_DBG(cmdq, "initialised @ index %d offset 0x%08x size 0x%08x",

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

187

index, cmdq->offset, cmdq->size);

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

193

struct nvkm_falcon_cmdq *cmdq = *pcmdq;

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

194

if (cmdq) {

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

204

struct nvkm_falcon_cmdq *cmdq = *pcmdq;

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

206

if (!(cmdq = *pcmdq = kzalloc_obj(*cmdq)))

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

209

cmdq->qmgr = qmgr;

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

210

cmdq->name = name;

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

211

mutex_init(&cmdq->mutex);

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

212

init_completion(&cmdq->ready);

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

26

nvkm_falcon_cmdq_has_room(struct nvkm_falcon_cmdq *cmdq, u32 size, bool *rewind)

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

28

u32 head = nvkm_falcon_rd32(cmdq->qmgr->falcon, cmdq->head_reg);

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

29

u32 tail = nvkm_falcon_rd32(cmdq->qmgr->falcon, cmdq->tail_reg);

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

35

free = cmdq->offset + cmdq->size - head;

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

40

head = cmdq->offset;

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

51

nvkm_falcon_cmdq_push(struct nvkm_falcon_cmdq *cmdq, void *data, u32 size)

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

53

struct nvkm_falcon *falcon = cmdq->qmgr->falcon;

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

54

nvkm_falcon_pio_wr(falcon, data, 0, 0, DMEM, cmdq->position, size, 0, false);

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

55

cmdq->position += ALIGN(size, QUEUE_ALIGNMENT);

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

59

nvkm_falcon_cmdq_rewind(struct nvkm_falcon_cmdq *cmdq)

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

65

nvkm_falcon_cmdq_push(cmdq, &cmd, cmd.size);

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

67

cmdq->position = cmdq->offset;

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

71

nvkm_falcon_cmdq_open(struct nvkm_falcon_cmdq *cmdq, u32 size)

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

73

struct nvkm_falcon *falcon = cmdq->qmgr->falcon;

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

76

mutex_lock(&cmdq->mutex);

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

78

if (!nvkm_falcon_cmdq_has_room(cmdq, size, &rewind)) {

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

79

FLCNQ_DBG(cmdq, "queue full");

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

80

mutex_unlock(&cmdq->mutex);

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

84

cmdq->position = nvkm_falcon_rd32(falcon, cmdq->head_reg);

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

87

nvkm_falcon_cmdq_rewind(cmdq);

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

93

nvkm_falcon_cmdq_close(struct nvkm_falcon_cmdq *cmdq)

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

95

nvkm_falcon_wr32(cmdq->qmgr->falcon, cmdq->head_reg, cmdq->position);

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

96

mutex_unlock(&cmdq->mutex);

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1139

} *cmdq, *msgq;

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1142

gsp->shm.cmdq.size = 0x40000;

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1145

gsp->shm.ptes.nr = (gsp->shm.cmdq.size + gsp->shm.msgq.size) >> GSP_PAGE_SHIFT;

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1150

gsp->shm.cmdq.size +

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1157

gsp->shm.cmdq.ptr = (u8 *)gsp->shm.ptes.ptr + gsp->shm.ptes.size;

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1158

gsp->shm.msgq.ptr = (u8 *)gsp->shm.cmdq.ptr + gsp->shm.cmdq.size;

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1163

cmdq = gsp->shm.cmdq.ptr;

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1164

cmdq->tx.version = 0;

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1165

cmdq->tx.size = gsp->shm.cmdq.size;

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1166

cmdq->tx.entryOff = GSP_PAGE_SIZE;

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1167

cmdq->tx.msgSize = GSP_PAGE_SIZE;

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1168

cmdq->tx.msgCount = (cmdq->tx.size - cmdq->tx.entryOff) / cmdq->tx.msgSize;

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1169

cmdq->tx.writePtr = 0;

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1170

cmdq->tx.flags = 1;

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1171

cmdq->tx.rxHdrOff = offsetof(typeof(*cmdq), rx.readPtr);

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1175

gsp->cmdq.cnt = cmdq->tx.msgCount;

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1176

gsp->cmdq.wptr = &cmdq->tx.writePtr;

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1177

gsp->cmdq.rptr = &msgq->rx.readPtr;

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1178

gsp->msgq.cnt = cmdq->tx.msgCount;

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1180

gsp->msgq.rptr = &cmdq->rx.readPtr;

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1192

(u8 *)gsp->shm.cmdq.ptr - (u8 *)gsp->shm.mem.data;

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

2108

mutex_destroy(&gsp->cmdq.mutex);

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

2139

mutex_init(&gsp->cmdq.mutex);

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

53

mutex_lock(&gsp->cmdq.mutex);

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

56

mutex_unlock(&gsp->cmdq.mutex);

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/rpc.c

369

msg->sequence = gsp->cmdq.seq++;

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/rpc.c

377

wptr = *gsp->cmdq.wptr;

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/rpc.c

380

free = *gsp->cmdq.rptr + gsp->cmdq.cnt - wptr - 1;

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/rpc.c

381

if (free >= gsp->cmdq.cnt)

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/rpc.c

382

free -= gsp->cmdq.cnt;

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/rpc.c

394

cqe = (void *)((u8 *)gsp->shm.cmdq.ptr + 0x1000 + wptr * 0x1000);

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/rpc.c

395

step = min_t(u32, free, (gsp->cmdq.cnt - wptr));

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/rpc.c

401

if (wptr == gsp->cmdq.cnt)

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/rpc.c

410

(*gsp->cmdq.wptr) = wptr;

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/rpc.c

541

mutex_lock(&gsp->cmdq.mutex);

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/rpc.c

543

mutex_unlock(&gsp->cmdq.mutex);

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/rpc.c

642

mutex_lock(&gsp->cmdq.mutex);

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/rpc.c

695

mutex_unlock(&gsp->cmdq.mutex);

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r570/gsp.c

191

(u8 *)gsp->shm.cmdq.ptr - (u8 *)gsp->shm.mem.data;

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gm200.c

57

.cmdq = { 0x4a0, 0x4b0, 4 },

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/gp102.c

40

.cmdq = { 0x4a0, 0x4b0, 4 },

drivers/infiniband/hw/bng_re/bng_fw.c

101

rcfw->crsqe_tbl = kzalloc_objs(*rcfw->crsqe_tbl, cmdq->hwq.max_elements);

drivers/infiniband/hw/bng_re/bng_fw.c

119

struct bng_re_hwq *hwq = &rcfw->cmdq.hwq;

drivers/infiniband/hw/bng_re/bng_fw.c

149

&rcfw->cmdq.flags),

drivers/infiniband/hw/bng_re/bng_fw.c

270

wake_up_nr(&rcfw->cmdq.waitq, num_wakeup);

drivers/infiniband/hw/bng_re/bng_fw.c

277

struct bng_re_cmdq_ctx *cmdq;

drivers/infiniband/hw/bng_re/bng_fw.c

279

cmdq = &rcfw->cmdq;

drivers/infiniband/hw/bng_re/bng_fw.c

281

if (test_bit(FIRMWARE_STALL_DETECTED, &cmdq->flags))

drivers/infiniband/hw/bng_re/bng_fw.c

284

if (test_bit(FIRMWARE_INITIALIZED_FLAG, &cmdq->flags) &&

drivers/infiniband/hw/bng_re/bng_fw.c

290

if (!test_bit(FIRMWARE_INITIALIZED_FLAG, &cmdq->flags) &&

drivers/infiniband/hw/bng_re/bng_fw.c

307

struct bng_re_cmdq_ctx *cmdq;

drivers/infiniband/hw/bng_re/bng_fw.c

316

cmdq = &rcfw->cmdq;

drivers/infiniband/hw/bng_re/bng_fw.c

317

hwq = &cmdq->hwq;

drivers/infiniband/hw/bng_re/bng_fw.c

326

cookie = cmdq->seq_num & BNG_FW_MAX_COOKIE_VALUE;

drivers/infiniband/hw/bng_re/bng_fw.c

369

cmdq->seq_num++;

drivers/infiniband/hw/bng_re/bng_fw.c

372

if (test_bit(FIRMWARE_FIRST_FLAG, &cmdq->flags)) {

drivers/infiniband/hw/bng_re/bng_fw.c

379

clear_bit(FIRMWARE_FIRST_FLAG, &cmdq->flags);

drivers/infiniband/hw/bng_re/bng_fw.c

383

writel(cmdq_prod, cmdq->cmdq_mbox.prod);

drivers/infiniband/hw/bng_re/bng_fw.c

384

writel(BNG_FW_CMDQ_TRIG_VAL, cmdq->cmdq_mbox.db);

drivers/infiniband/hw/bng_re/bng_fw.c

403

struct bng_re_cmdq_ctx *cmdq;

drivers/infiniband/hw/bng_re/bng_fw.c

406

cmdq = &rcfw->cmdq;

drivers/infiniband/hw/bng_re/bng_fw.c

410

wait_event_timeout(cmdq->waitq,

drivers/infiniband/hw/bng_re/bng_fw.c

462

spin_lock_bh(&rcfw->cmdq.hwq.lock);

drivers/infiniband/hw/bng_re/bng_fw.c

466

set_bit(FIRMWARE_STALL_DETECTED, &rcfw->cmdq.flags);

drivers/infiniband/hw/bng_re/bng_fw.c

467

spin_unlock_bh(&rcfw->cmdq.hwq.lock);

drivers/infiniband/hw/bng_re/bng_fw.c

488

mbox = &rcfw->cmdq.cmdq_mbox;

drivers/infiniband/hw/bng_re/bng_fw.c

56

bng_re_free_hwq(rcfw->res, &rcfw->cmdq.hwq);

drivers/infiniband/hw/bng_re/bng_fw.c

631

struct bng_re_cmdq_ctx *cmdq;

drivers/infiniband/hw/bng_re/bng_fw.c

634

cmdq = &rcfw->cmdq;

drivers/infiniband/hw/bng_re/bng_fw.c

638

iounmap(cmdq->cmdq_mbox.reg.bar_reg);

drivers/infiniband/hw/bng_re/bng_fw.c

641

cmdq->cmdq_mbox.reg.bar_reg = NULL;

drivers/infiniband/hw/bng_re/bng_fw.c

648

struct bng_re_cmdq_ctx *cmdq;

drivers/infiniband/hw/bng_re/bng_fw.c

653

cmdq = &rcfw->cmdq;

drivers/infiniband/hw/bng_re/bng_fw.c

655

mbox = &cmdq->cmdq_mbox;

drivers/infiniband/hw/bng_re/bng_fw.c

657

init.cmdq_pbl = cpu_to_le64(cmdq->hwq.pbl[BNG_PBL_LVL_0].pg_map_arr[0]);

drivers/infiniband/hw/bng_re/bng_fw.c

66

struct bng_re_cmdq_ctx *cmdq;

drivers/infiniband/hw/bng_re/bng_fw.c

662

((cmdq->hwq.level <<

drivers/infiniband/hw/bng_re/bng_fw.c

674

struct bng_re_cmdq_ctx *cmdq;

drivers/infiniband/hw/bng_re/bng_fw.c

677

cmdq = &rcfw->cmdq;

drivers/infiniband/hw/bng_re/bng_fw.c

680

cmdq->seq_num = 0;

drivers/infiniband/hw/bng_re/bng_fw.c

681

set_bit(FIRMWARE_FIRST_FLAG, &cmdq->flags);

drivers/infiniband/hw/bng_re/bng_fw.c

682

init_waitqueue_head(&cmdq->waitq);

drivers/infiniband/hw/bng_re/bng_fw.c

70

cmdq = &rcfw->cmdq;

drivers/infiniband/hw/bng_re/bng_fw.c

720

clear_bit(FIRMWARE_INITIALIZED_FLAG, &rcfw->cmdq.flags);

drivers/infiniband/hw/bng_re/bng_fw.c

764

set_bit(FIRMWARE_INITIALIZED_FLAG, &rcfw->cmdq.flags);

drivers/infiniband/hw/bng_re/bng_fw.c

95

if (bng_re_alloc_init_hwq(&cmdq->hwq, &hwq_attr)) {

drivers/infiniband/hw/bng_re/bng_fw.h

120

struct bng_re_cmdq_ctx cmdq;

drivers/infiniband/hw/bnxt_re/main.c

2529

set_bit(ERR_DEVICE_DETACHED, &rdev->rcfw.cmdq.flags);

drivers/infiniband/hw/bnxt_re/main.c

2531

wake_up_all(&rdev->rcfw.cmdq.waitq);

drivers/infiniband/hw/bnxt_re/main.c

451

set_bit(ERR_DEVICE_DETACHED, &rdev->rcfw.cmdq.flags);

drivers/infiniband/hw/bnxt_re/main.c

453

wake_up_all(&rdev->rcfw.cmdq.waitq);

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

1012

struct bnxt_qplib_cmdq_ctx *cmdq;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

1015

cmdq = &rcfw->cmdq;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

1019

iounmap(cmdq->cmdq_mbox.reg.bar_reg);

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

1022

cmdq->cmdq_mbox.reg.bar_reg = NULL;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

1074

mbox = &rcfw->cmdq.cmdq_mbox;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

1137

struct bnxt_qplib_cmdq_ctx *cmdq;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

114

struct bnxt_qplib_cmdq_ctx *cmdq;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

1142

cmdq = &rcfw->cmdq;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

1144

mbox = &cmdq->cmdq_mbox;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

1146

init.cmdq_pbl = cpu_to_le64(cmdq->hwq.pbl[PBL_LVL_0].pg_map_arr[0]);

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

1151

((cmdq->hwq.level <<

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

1164

struct bnxt_qplib_cmdq_ctx *cmdq;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

1168

cmdq = &rcfw->cmdq;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

1173

cmdq->seq_num = 0;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

1174

set_bit(FIRMWARE_FIRST_FLAG, &cmdq->flags);

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

1175

init_waitqueue_head(&cmdq->waitq);

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

118

cmdq = &rcfw->cmdq;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

120

if (time_after(jiffies, cmdq->last_seen +

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

125

jiffies_to_msecs(jiffies - cmdq->last_seen),

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

147

struct bnxt_qplib_cmdq_ctx *cmdq;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

151

cmdq = &rcfw->cmdq;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

155

if (test_bit(ERR_DEVICE_DETACHED, &cmdq->flags))

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

157

if (test_bit(FIRMWARE_STALL_DETECTED, &cmdq->flags))

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

160

wait_event_timeout(cmdq->waitq,

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

162

test_bit(ERR_DEVICE_DETACHED, &cmdq->flags),

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

194

struct bnxt_qplib_cmdq_ctx *cmdq = &rcfw->cmdq;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

202

if (test_bit(ERR_DEVICE_DETACHED, &cmdq->flags))

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

204

if (test_bit(FIRMWARE_STALL_DETECTED, &cmdq->flags))

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

238

struct bnxt_qplib_cmdq_ctx *cmdq = &rcfw->cmdq;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

239

struct bnxt_qplib_hwq *hwq = &cmdq->hwq;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

247

cookie = cmdq->seq_num & RCFW_MAX_COOKIE_VALUE;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

273

cmdq->seq_num++;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

279

writel(cmdq_prod, cmdq->cmdq_mbox.prod);

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

280

writel(RCFW_CMDQ_TRIG_VAL, cmdq->cmdq_mbox.db);

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

287

struct bnxt_qplib_cmdq_ctx *cmdq;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

296

cmdq = &rcfw->cmdq;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

297

hwq = &cmdq->hwq;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

306

cookie = cmdq->seq_num & RCFW_MAX_COOKIE_VALUE;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

353

cmdq->seq_num++;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

356

if (test_bit(FIRMWARE_FIRST_FLAG, &cmdq->flags)) {

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

363

clear_bit(FIRMWARE_FIRST_FLAG, &cmdq->flags);

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

367

writel(cmdq_prod, cmdq->cmdq_mbox.prod);

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

368

writel(RCFW_CMDQ_TRIG_VAL, cmdq->cmdq_mbox.db);

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

390

struct bnxt_qplib_cmdq_ctx *cmdq = &rcfw->cmdq;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

399

if (test_bit(ERR_DEVICE_DETACHED, &cmdq->flags))

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

401

if (test_bit(FIRMWARE_STALL_DETECTED, &cmdq->flags))

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

422

struct bnxt_qplib_cmdq_ctx *cmdq;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

424

cmdq = &rcfw->cmdq;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

427

if (test_bit(ERR_DEVICE_DETACHED, &rcfw->cmdq.flags))

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

430

if (test_bit(FIRMWARE_STALL_DETECTED, &cmdq->flags))

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

433

if (test_bit(FIRMWARE_INITIALIZED_FLAG, &cmdq->flags) &&

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

439

if (!test_bit(FIRMWARE_INITIALIZED_FLAG, &cmdq->flags) &&

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

515

spin_lock_bh(&rcfw->cmdq.hwq.lock);

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

519

set_bit(FIRMWARE_STALL_DETECTED, &rcfw->cmdq.flags);

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

520

spin_unlock_bh(&rcfw->cmdq.hwq.lock);

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

624

struct bnxt_qplib_hwq *hwq = &rcfw->cmdq.hwq;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

673

&rcfw->cmdq.flags),

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

753

rcfw->cmdq.last_seen = jiffies;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

789

wake_up_nr(&rcfw->cmdq.waitq, num_wakeup);

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

827

clear_bit(FIRMWARE_INITIALIZED_FLAG, &rcfw->cmdq.flags);

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

918

set_bit(FIRMWARE_INITIALIZED_FLAG, &rcfw->cmdq.flags);

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

925

bnxt_qplib_free_hwq(rcfw->res, &rcfw->cmdq.hwq);

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

936

struct bnxt_qplib_cmdq_ctx *cmdq;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

940

cmdq = &rcfw->cmdq;

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

965

if (bnxt_qplib_alloc_init_hwq(&cmdq->hwq, &hwq_attr)) {

drivers/infiniband/hw/bnxt_re/qplib_rcfw.c

971

rcfw->crsqe_tbl = kzalloc_objs(*rcfw->crsqe_tbl, cmdq->hwq.max_elements);

drivers/infiniband/hw/bnxt_re/qplib_rcfw.h

224

struct bnxt_qplib_cmdq_ctx cmdq;

drivers/infiniband/hw/erdma/erdma.h

200

struct erdma_cmdq cmdq;

drivers/infiniband/hw/erdma/erdma.h

267

int erdma_post_cmd_wait(struct erdma_cmdq *cmdq, void *req, u32 req_size,

drivers/infiniband/hw/erdma/erdma.h

269

void erdma_cmdq_completion_handler(struct erdma_cmdq *cmdq);

drivers/infiniband/hw/erdma/erdma_cmdq.c

11

struct erdma_dev *dev = container_of(cmdq, struct erdma_dev, cmdq);

drivers/infiniband/hw/erdma/erdma_cmdq.c

12

u64 db_data = FIELD_PREP(ERDMA_CQDB_CI_MASK, cmdq->cq.ci) |

drivers/infiniband/hw/erdma/erdma_cmdq.c

125

struct erdma_cmdq *cmdq = &dev->cmdq;

drivers/infiniband/hw/erdma/erdma_cmdq.c

126

struct erdma_cmdq_cq *cq = &cmdq->cq;

drivers/infiniband/hw/erdma/erdma_cmdq.c

128

cq->depth = cmdq->sq.depth;

drivers/infiniband/hw/erdma/erdma_cmdq.c

14

FIELD_PREP(ERDMA_CQDB_CMDSN_MASK, cmdq->cq.cmdsn) |

drivers/infiniband/hw/erdma/erdma_cmdq.c

15

FIELD_PREP(ERDMA_CQDB_IDX_MASK, cmdq->cq.cmdsn);

drivers/infiniband/hw/erdma/erdma_cmdq.c

159

struct erdma_cmdq *cmdq = &dev->cmdq;

drivers/infiniband/hw/erdma/erdma_cmdq.c

160

struct erdma_eq *eq = &cmdq->eq;

drivers/infiniband/hw/erdma/erdma_cmdq.c

163

ret = erdma_eq_common_init(dev, eq, cmdq->max_outstandings);

drivers/infiniband/hw/erdma/erdma_cmdq.c

17

*cmdq->cq.dbrec = db_data;

drivers/infiniband/hw/erdma/erdma_cmdq.c

181

struct erdma_cmdq *cmdq = &dev->cmdq;

drivers/infiniband/hw/erdma/erdma_cmdq.c

184

cmdq->max_outstandings = ERDMA_CMDQ_MAX_OUTSTANDING;

drivers/infiniband/hw/erdma/erdma_cmdq.c

186

sema_init(&cmdq->credits, cmdq->max_outstandings);

drivers/infiniband/hw/erdma/erdma_cmdq.c

188

err = erdma_cmdq_wait_res_init(dev, cmdq);

drivers/infiniband/hw/erdma/erdma_cmdq.c

20

atomic64_inc(&cmdq->cq.armed_num);

drivers/infiniband/hw/erdma/erdma_cmdq.c

204

set_bit(ERDMA_CMDQ_STATE_OK_BIT, &cmdq->state);

drivers/infiniband/hw/erdma/erdma_cmdq.c

209

dma_free_coherent(&dev->pdev->dev, cmdq->cq.depth << CQE_SHIFT,

drivers/infiniband/hw/erdma/erdma_cmdq.c

210

cmdq->cq.qbuf, cmdq->cq.qbuf_dma_addr);

drivers/infiniband/hw/erdma/erdma_cmdq.c

212

dma_pool_free(dev->db_pool, cmdq->cq.dbrec, cmdq->cq.dbrec_dma);

drivers/infiniband/hw/erdma/erdma_cmdq.c

215

dma_free_coherent(&dev->pdev->dev, cmdq->sq.depth << SQEBB_SHIFT,

drivers/infiniband/hw/erdma/erdma_cmdq.c

216

cmdq->sq.qbuf, cmdq->sq.qbuf_dma_addr);

drivers/infiniband/hw/erdma/erdma_cmdq.c

218

dma_pool_free(dev->db_pool, cmdq->sq.dbrec, cmdq->sq.dbrec_dma);

drivers/infiniband/hw/erdma/erdma_cmdq.c

225

arm_cmdq_cq(&dev->cmdq);

drivers/infiniband/hw/erdma/erdma_cmdq.c

23

static void kick_cmdq_db(struct erdma_cmdq *cmdq)

drivers/infiniband/hw/erdma/erdma_cmdq.c

230

struct erdma_cmdq *cmdq = &dev->cmdq;

drivers/infiniband/hw/erdma/erdma_cmdq.c

232

clear_bit(ERDMA_CMDQ_STATE_OK_BIT, &cmdq->state);

drivers/infiniband/hw/erdma/erdma_cmdq.c

234

erdma_eq_destroy(dev, &cmdq->eq);

drivers/infiniband/hw/erdma/erdma_cmdq.c

236

dma_free_coherent(&dev->pdev->dev, cmdq->sq.depth << SQEBB_SHIFT,

drivers/infiniband/hw/erdma/erdma_cmdq.c

237

cmdq->sq.qbuf, cmdq->sq.qbuf_dma_addr);

drivers/infiniband/hw/erdma/erdma_cmdq.c

239

dma_pool_free(dev->db_pool, cmdq->sq.dbrec, cmdq->sq.dbrec_dma);

drivers/infiniband/hw/erdma/erdma_cmdq.c

241

dma_free_coherent(&dev->pdev->dev, cmdq->cq.depth << CQE_SHIFT,

drivers/infiniband/hw/erdma/erdma_cmdq.c

242

cmdq->cq.qbuf, cmdq->cq.qbuf_dma_addr);

drivers/infiniband/hw/erdma/erdma_cmdq.c

244

dma_pool_free(dev->db_pool, cmdq->cq.dbrec, cmdq->cq.dbrec_dma);

drivers/infiniband/hw/erdma/erdma_cmdq.c

247

static void *get_next_valid_cmdq_cqe(struct erdma_cmdq *cmdq)

drivers/infiniband/hw/erdma/erdma_cmdq.c

249

__be32 *cqe = get_queue_entry(cmdq->cq.qbuf, cmdq->cq.ci,

drivers/infiniband/hw/erdma/erdma_cmdq.c

25

struct erdma_dev *dev = container_of(cmdq, struct erdma_dev, cmdq);

drivers/infiniband/hw/erdma/erdma_cmdq.c

250

cmdq->cq.depth, CQE_SHIFT);

drivers/infiniband/hw/erdma/erdma_cmdq.c

254

return owner ^ !!(cmdq->cq.ci & cmdq->cq.depth) ? cqe : NULL;

drivers/infiniband/hw/erdma/erdma_cmdq.c

257

static void push_cmdq_sqe(struct erdma_cmdq *cmdq, u64 *req, size_t req_len,

drivers/infiniband/hw/erdma/erdma_cmdq.c

26

u64 db_data = FIELD_PREP(ERDMA_CMD_HDR_WQEBB_INDEX_MASK, cmdq->sq.pi);

drivers/infiniband/hw/erdma/erdma_cmdq.c

265

comp_wait->sq_pi = cmdq->sq.pi;

drivers/infiniband/hw/erdma/erdma_cmdq.c

267

wqe = get_queue_entry(cmdq->sq.qbuf, cmdq->sq.pi, cmdq->sq.depth,

drivers/infiniband/hw/erdma/erdma_cmdq.c

271

cmdq->sq.pi += cmdq->sq.wqebb_cnt;

drivers/infiniband/hw/erdma/erdma_cmdq.c

272

hdr |= FIELD_PREP(ERDMA_CMD_HDR_WQEBB_INDEX_MASK, cmdq->sq.pi) |

drivers/infiniband/hw/erdma/erdma_cmdq.c

275

FIELD_PREP(ERDMA_CMD_HDR_WQEBB_CNT_MASK, cmdq->sq.wqebb_cnt - 1);

drivers/infiniband/hw/erdma/erdma_cmdq.c

278

kick_cmdq_db(cmdq);

drivers/infiniband/hw/erdma/erdma_cmdq.c

28

*cmdq->sq.dbrec = db_data;

drivers/infiniband/hw/erdma/erdma_cmdq.c

281

static int erdma_poll_single_cmd_completion(struct erdma_cmdq *cmdq)

drivers/infiniband/hw/erdma/erdma_cmdq.c

289

cqe = get_next_valid_cmdq_cqe(cmdq);

drivers/infiniband/hw/erdma/erdma_cmdq.c

293

cmdq->cq.ci++;

drivers/infiniband/hw/erdma/erdma_cmdq.c

299

sqe = get_queue_entry(cmdq->sq.qbuf, sqe_idx, cmdq->sq.depth,

drivers/infiniband/hw/erdma/erdma_cmdq.c

302

comp_wait = &cmdq->wait_pool[ctx_id];

drivers/infiniband/hw/erdma/erdma_cmdq.c

308

cmdq->sq.ci += cmdq->sq.wqebb_cnt;

drivers/infiniband/hw/erdma/erdma_cmdq.c

317

static void erdma_polling_cmd_completions(struct erdma_cmdq *cmdq)

drivers/infiniband/hw/erdma/erdma_cmdq.c

32

static struct erdma_comp_wait *get_comp_wait(struct erdma_cmdq *cmdq)

drivers/infiniband/hw/erdma/erdma_cmdq.c

322

spin_lock_irqsave(&cmdq->cq.lock, flags);

drivers/infiniband/hw/erdma/erdma_cmdq.c

327

for (comp_num = 0; comp_num < cmdq->max_outstandings; comp_num++)

drivers/infiniband/hw/erdma/erdma_cmdq.c

328

if (erdma_poll_single_cmd_completion(cmdq))

drivers/infiniband/hw/erdma/erdma_cmdq.c

331

spin_unlock_irqrestore(&cmdq->cq.lock, flags);

drivers/infiniband/hw/erdma/erdma_cmdq.c

334

void erdma_cmdq_completion_handler(struct erdma_cmdq *cmdq)

drivers/infiniband/hw/erdma/erdma_cmdq.c

338

if (!test_bit(ERDMA_CMDQ_STATE_OK_BIT, &cmdq->state))

drivers/infiniband/hw/erdma/erdma_cmdq.c

341

while (get_next_valid_eqe(&cmdq->eq)) {

drivers/infiniband/hw/erdma/erdma_cmdq.c

342

cmdq->eq.ci++;

drivers/infiniband/hw/erdma/erdma_cmdq.c

347

cmdq->cq.cmdsn++;

drivers/infiniband/hw/erdma/erdma_cmdq.c

348

erdma_polling_cmd_completions(cmdq);

drivers/infiniband/hw/erdma/erdma_cmdq.c

349

arm_cmdq_cq(cmdq);

drivers/infiniband/hw/erdma/erdma_cmdq.c

352

notify_eq(&cmdq->eq);

drivers/infiniband/hw/erdma/erdma_cmdq.c

356

struct erdma_cmdq *cmdq, u32 timeout)

drivers/infiniband/hw/erdma/erdma_cmdq.c

36

spin_lock(&cmdq->lock);

drivers/infiniband/hw/erdma/erdma_cmdq.c

361

erdma_polling_cmd_completions(cmdq);

drivers/infiniband/hw/erdma/erdma_cmdq.c

37

comp_idx = find_first_zero_bit(cmdq->comp_wait_bitmap,

drivers/infiniband/hw/erdma/erdma_cmdq.c

375

struct erdma_cmdq *cmdq, u32 timeout)

drivers/infiniband/hw/erdma/erdma_cmdq.c

38

cmdq->max_outstandings);

drivers/infiniband/hw/erdma/erdma_cmdq.c

383

spin_lock_irqsave(&cmdq->cq.lock, flags);

drivers/infiniband/hw/erdma/erdma_cmdq.c

385

spin_unlock_irqrestore(&cmdq->cq.lock, flags);

drivers/infiniband/hw/erdma/erdma_cmdq.c

39

if (comp_idx == cmdq->max_outstandings) {

drivers/infiniband/hw/erdma/erdma_cmdq.c

398

int erdma_post_cmd_wait(struct erdma_cmdq *cmdq, void *req, u32 req_size,

drivers/infiniband/hw/erdma/erdma_cmdq.c

40

spin_unlock(&cmdq->lock);

drivers/infiniband/hw/erdma/erdma_cmdq.c

404

if (!test_bit(ERDMA_CMDQ_STATE_OK_BIT, &cmdq->state))

drivers/infiniband/hw/erdma/erdma_cmdq.c

408

while (down_trylock(&cmdq->credits))

drivers/infiniband/hw/erdma/erdma_cmdq.c

411

down(&cmdq->credits);

drivers/infiniband/hw/erdma/erdma_cmdq.c

414

comp_wait = get_comp_wait(cmdq);

drivers/infiniband/hw/erdma/erdma_cmdq.c

416

clear_bit(ERDMA_CMDQ_STATE_OK_BIT, &cmdq->state);

drivers/infiniband/hw/erdma/erdma_cmdq.c

417

set_bit(ERDMA_CMDQ_STATE_CTX_ERR_BIT, &cmdq->state);

drivers/infiniband/hw/erdma/erdma_cmdq.c

418

up(&cmdq->credits);

drivers/infiniband/hw/erdma/erdma_cmdq.c

422

spin_lock(&cmdq->sq.lock);

drivers/infiniband/hw/erdma/erdma_cmdq.c

423

push_cmdq_sqe(cmdq, req, req_size, comp_wait);

drivers/infiniband/hw/erdma/erdma_cmdq.c

424

spin_unlock(&cmdq->sq.lock);

drivers/infiniband/hw/erdma/erdma_cmdq.c

427

ret = erdma_wait_cmd_completion(comp_wait, cmdq,

drivers/infiniband/hw/erdma/erdma_cmdq.c

430

ret = erdma_poll_cmd_completion(comp_wait, cmdq,

drivers/infiniband/hw/erdma/erdma_cmdq.c

434

set_bit(ERDMA_CMDQ_STATE_TIMEOUT_BIT, &cmdq->state);

drivers/infiniband/hw/erdma/erdma_cmdq.c

435

clear_bit(ERDMA_CMDQ_STATE_OK_BIT, &cmdq->state);

drivers/infiniband/hw/erdma/erdma_cmdq.c

44

__set_bit(comp_idx, cmdq->comp_wait_bitmap);

drivers/infiniband/hw/erdma/erdma_cmdq.c

446

put_comp_wait(cmdq, comp_wait);

drivers/infiniband/hw/erdma/erdma_cmdq.c

449

up(&cmdq->credits);

drivers/infiniband/hw/erdma/erdma_cmdq.c

45

spin_unlock(&cmdq->lock);

drivers/infiniband/hw/erdma/erdma_cmdq.c

47

return &cmdq->wait_pool[comp_idx];

drivers/infiniband/hw/erdma/erdma_cmdq.c

50

static void put_comp_wait(struct erdma_cmdq *cmdq,

drivers/infiniband/hw/erdma/erdma_cmdq.c

55

cmdq->wait_pool[comp_wait->ctx_id].cmd_status = ERDMA_CMD_STATUS_INIT;

drivers/infiniband/hw/erdma/erdma_cmdq.c

56

spin_lock(&cmdq->lock);

drivers/infiniband/hw/erdma/erdma_cmdq.c

57

used = __test_and_clear_bit(comp_wait->ctx_id, cmdq->comp_wait_bitmap);

drivers/infiniband/hw/erdma/erdma_cmdq.c

58

spin_unlock(&cmdq->lock);

drivers/infiniband/hw/erdma/erdma_cmdq.c

64

struct erdma_cmdq *cmdq)

drivers/infiniband/hw/erdma/erdma_cmdq.c

68

cmdq->wait_pool =

drivers/infiniband/hw/erdma/erdma_cmdq.c

69

devm_kcalloc(&dev->pdev->dev, cmdq->max_outstandings,

drivers/infiniband/hw/erdma/erdma_cmdq.c

71

if (!cmdq->wait_pool)

drivers/infiniband/hw/erdma/erdma_cmdq.c

74

spin_lock_init(&cmdq->lock);

drivers/infiniband/hw/erdma/erdma_cmdq.c

75

cmdq->comp_wait_bitmap = devm_bitmap_zalloc(

drivers/infiniband/hw/erdma/erdma_cmdq.c

76

&dev->pdev->dev, cmdq->max_outstandings, GFP_KERNEL);

drivers/infiniband/hw/erdma/erdma_cmdq.c

77

if (!cmdq->comp_wait_bitmap)

drivers/infiniband/hw/erdma/erdma_cmdq.c

80

for (i = 0; i < cmdq->max_outstandings; i++) {

drivers/infiniband/hw/erdma/erdma_cmdq.c

81

init_completion(&cmdq->wait_pool[i].wait_event);

drivers/infiniband/hw/erdma/erdma_cmdq.c

82

cmdq->wait_pool[i].ctx_id = i;

drivers/infiniband/hw/erdma/erdma_cmdq.c

9

static void arm_cmdq_cq(struct erdma_cmdq *cmdq)

drivers/infiniband/hw/erdma/erdma_cmdq.c

90

struct erdma_cmdq *cmdq = &dev->cmdq;

drivers/infiniband/hw/erdma/erdma_cmdq.c

91

struct erdma_cmdq_sq *sq = &cmdq->sq;

drivers/infiniband/hw/erdma/erdma_cmdq.c

94

sq->depth = cmdq->max_outstandings * sq->wqebb_cnt;

drivers/infiniband/hw/erdma/erdma_eq.c

239

return erdma_post_cmd_wait(&dev->cmdq, &req, sizeof(req), NULL, NULL,

drivers/infiniband/hw/erdma/erdma_eq.c

282

err = erdma_post_cmd_wait(&dev->cmdq, &req, sizeof(req), NULL, NULL,

drivers/infiniband/hw/erdma/erdma_main.c

119

erdma_cmdq_completion_handler(&dev->cmdq);

drivers/infiniband/hw/erdma/erdma_main.c

386

err = erdma_post_cmd_wait(&dev->cmdq, &req_hdr, sizeof(req_hdr), &cap0,

drivers/infiniband/hw/erdma/erdma_main.c

419

err = erdma_post_cmd_wait(&dev->cmdq, &req_hdr, sizeof(req_hdr), &cap0,

drivers/infiniband/hw/erdma/erdma_main.c

441

return erdma_post_cmd_wait(&dev->cmdq, &req, sizeof(req), NULL, NULL,

drivers/infiniband/hw/erdma/erdma_qp.c

101

ret = erdma_post_cmd_wait(&dev->cmdq, &req, sizeof(req), NULL, NULL,

drivers/infiniband/hw/erdma/erdma_qp.c

135

ret = erdma_post_cmd_wait(&dev->cmdq, &req, sizeof(req), NULL, NULL,

drivers/infiniband/hw/erdma/erdma_qp.c

250

return erdma_post_cmd_wait(&qp->dev->cmdq, &req, sizeof(req), NULL,

drivers/infiniband/hw/erdma/erdma_verbs.c

129

err = erdma_post_cmd_wait(&dev->cmdq, &req, sizeof(req), &resp0, &resp1,

drivers/infiniband/hw/erdma/erdma_verbs.c

1303

ret = erdma_post_cmd_wait(&dev->cmdq, &req, sizeof(req), NULL, NULL,

drivers/infiniband/hw/erdma/erdma_verbs.c

1329

err = erdma_post_cmd_wait(&dev->cmdq, &req, sizeof(req), NULL, NULL,

drivers/infiniband/hw/erdma/erdma_verbs.c

1377

err = erdma_post_cmd_wait(&dev->cmdq, &req, sizeof(req), NULL, NULL,

drivers/infiniband/hw/erdma/erdma_verbs.c

1476

ret = erdma_post_cmd_wait(&dev->cmdq, &req, sizeof(req), &val0, &val1,

drivers/infiniband/hw/erdma/erdma_verbs.c

1512

ret = erdma_post_cmd_wait(&dev->cmdq, &req, sizeof(req), NULL, NULL,

drivers/infiniband/hw/erdma/erdma_verbs.c

1876

ret = erdma_post_cmd_wait(&dev->cmdq, &req, sizeof(req), &resp0,

drivers/infiniband/hw/erdma/erdma_verbs.c

188

return erdma_post_cmd_wait(&dev->cmdq, &req, sizeof(req), NULL, NULL,

drivers/infiniband/hw/erdma/erdma_verbs.c

2040

erdma_post_cmd_wait(&dev->cmdq, &req, sizeof(req), NULL, NULL, true);

drivers/infiniband/hw/erdma/erdma_verbs.c

2110

err = erdma_post_cmd_wait(&dev->cmdq, &req, sizeof(req), NULL, NULL,

drivers/infiniband/hw/erdma/erdma_verbs.c

2172

return erdma_post_cmd_wait(&dev->cmdq, &req, sizeof(req), NULL, NULL,

drivers/infiniband/hw/erdma/erdma_verbs.c

2257

ret = erdma_post_cmd_wait(&dev->cmdq, &req, sizeof(req), NULL, NULL,

drivers/infiniband/hw/erdma/erdma_verbs.c

2281

ret = erdma_post_cmd_wait(&dev->cmdq, &req, sizeof(req), NULL, NULL,

drivers/infiniband/hw/erdma/erdma_verbs.c

251

return erdma_post_cmd_wait(&dev->cmdq, &req, sizeof(req), NULL, NULL,

drivers/infiniband/hw/erdma/erdma_verbs.c

467

erdma_post_cmd_wait(&qp->dev->cmdq, &req, sizeof(req), NULL, NULL,

drivers/infiniband/hw/hns/hns_roce_trace.h

175

DECLARE_EVENT_CLASS(cmdq,

drivers/infiniband/hw/hns/hns_roce_trace.h

201

DEFINE_EVENT(cmdq, hns_cmdq_req,

drivers/infiniband/hw/hns/hns_roce_trace.h

205

DEFINE_EVENT(cmdq, hns_cmdq_resp,

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3-iommufd.c

389

ret = arm_smmu_cmdq_issue_cmdlist(smmu, &smmu->cmdq, last->cmd,

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

374

struct arm_smmu_cmdq *cmdq = NULL;

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

377

cmdq = smmu->impl_ops->get_secondary_cmdq(smmu, ent);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

379

return cmdq ?: &smmu->cmdq;

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

3818

struct arm_smmu_cmdq *cmdq)

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

3820

unsigned int nents = 1 << cmdq->q.llq.max_n_shift;

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

3822

atomic_set(&cmdq->owner_prod, 0);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

3823

atomic_set(&cmdq->lock, 0);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

3825

cmdq->valid_map = (atomic_long_t *)devm_bitmap_zalloc(smmu->dev, nents,

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

3827

if (!cmdq->valid_map)

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

383

struct arm_smmu_cmdq *cmdq)

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

3838

ret = arm_smmu_init_one_queue(smmu, &smmu->cmdq.q, smmu->base,

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

3844

ret = arm_smmu_cmdq_init(smmu, &smmu->cmdq);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

385

if (cmdq == &smmu->cmdq)

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

392

struct arm_smmu_cmdq *cmdq, u32 prod)

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

394

struct arm_smmu_queue *q = &cmdq->q;

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

409

if (arm_smmu_cmdq_needs_busy_polling(smmu, cmdq))

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

414

struct arm_smmu_cmdq *cmdq)

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

4213

writeq_relaxed(smmu->cmdq.q.q_base, smmu->base + ARM_SMMU_CMDQ_BASE);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

4214

writel_relaxed(smmu->cmdq.q.llq.prod, smmu->base + ARM_SMMU_CMDQ_PROD);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

4215

writel_relaxed(smmu->cmdq.q.llq.cons, smmu->base + ARM_SMMU_CMDQ_CONS);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

422

struct arm_smmu_queue *q = &cmdq->q;

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

4478

smmu->cmdq.q.llq.max_n_shift = min_t(u32, CMDQ_MAX_SZ_SHIFT,

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

4480

if (smmu->cmdq.q.llq.max_n_shift <= ilog2(CMDQ_BATCH_ENTRIES)) {

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

465

if (arm_smmu_cmdq_needs_busy_polling(smmu, cmdq))

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

473

__arm_smmu_cmdq_skip_err(smmu, &smmu->cmdq);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

488

static void arm_smmu_cmdq_shared_lock(struct arm_smmu_cmdq *cmdq)

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

496

if (atomic_fetch_inc_relaxed(&cmdq->lock) >= 0)

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

509

atomic_cond_read_relaxed(&cmdq->lock, VAL > 0);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

512

static void arm_smmu_cmdq_shared_unlock(struct arm_smmu_cmdq *cmdq)

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

514

(void)atomic_dec_return_release(&cmdq->lock);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

517

static bool arm_smmu_cmdq_shared_tryunlock(struct arm_smmu_cmdq *cmdq)

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

519

if (atomic_read(&cmdq->lock) == 1)

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

522

arm_smmu_cmdq_shared_unlock(cmdq);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

526

#define arm_smmu_cmdq_exclusive_trylock_irqsave(cmdq, flags) \

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

530

__ret = !atomic_cmpxchg_relaxed(&cmdq->lock, 0, INT_MIN); \

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

541

#define arm_smmu_cmdq_exclusive_unlock_irqrestore(cmdq, flags) \

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

543

atomic_fetch_andnot_release(INT_MIN, &cmdq->lock); \

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

587

static void __arm_smmu_cmdq_poll_set_valid_map(struct arm_smmu_cmdq *cmdq,

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

592

.max_n_shift = cmdq->q.llq.max_n_shift,

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

607

ptr = &cmdq->valid_map[swidx];

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

634

static void arm_smmu_cmdq_set_valid_map(struct arm_smmu_cmdq *cmdq,

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

637

__arm_smmu_cmdq_poll_set_valid_map(cmdq, sprod, eprod, true);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

641

static void arm_smmu_cmdq_poll_valid_map(struct arm_smmu_cmdq *cmdq,

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

644

__arm_smmu_cmdq_poll_set_valid_map(cmdq, sprod, eprod, false);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

649

struct arm_smmu_cmdq *cmdq,

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

660

if (arm_smmu_cmdq_exclusive_trylock_irqsave(cmdq, flags)) {

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

661

WRITE_ONCE(cmdq->q.llq.cons, readl_relaxed(cmdq->q.cons_reg));

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

662

arm_smmu_cmdq_exclusive_unlock_irqrestore(cmdq, flags);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

663

llq->val = READ_ONCE(cmdq->q.llq.val);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

669

llq->val = READ_ONCE(cmdq->q.llq.val);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

684

struct arm_smmu_cmdq *cmdq,

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

689

u32 *cmd = (u32 *)(Q_ENT(&cmdq->q, llq->prod));

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

708

struct arm_smmu_cmdq *cmdq,

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

716

llq->val = READ_ONCE(cmdq->q.llq.val);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

751

llq->cons = readl(cmdq->q.cons_reg);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

758

struct arm_smmu_cmdq *cmdq,

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

762

!arm_smmu_cmdq_needs_busy_polling(smmu, cmdq))

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

763

return __arm_smmu_cmdq_poll_until_msi(smmu, cmdq, llq);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

765

return __arm_smmu_cmdq_poll_until_consumed(smmu, cmdq, llq);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

768

static void arm_smmu_cmdq_write_entries(struct arm_smmu_cmdq *cmdq, u64 *cmds,

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

773

.max_n_shift = cmdq->q.llq.max_n_shift,

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

781

queue_write(Q_ENT(&cmdq->q, prod), cmd, CMDQ_ENT_DWORDS);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

802

struct arm_smmu_cmdq *cmdq, u64 *cmds, int n,

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

812

llq.max_n_shift = cmdq->q.llq.max_n_shift;

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

816

llq.val = READ_ONCE(cmdq->q.llq.val);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

822

if (arm_smmu_cmdq_poll_until_not_full(smmu, cmdq, &llq))

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

831

old = cmpxchg_relaxed(&cmdq->q.llq.val, llq.val, head.val);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

845

arm_smmu_cmdq_write_entries(cmdq, cmds, llq.prod, n);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

848

arm_smmu_cmdq_build_sync_cmd(cmd_sync, smmu, cmdq, prod);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

849

queue_write(Q_ENT(&cmdq->q, prod), cmd_sync, CMDQ_ENT_DWORDS);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

857

arm_smmu_cmdq_shared_lock(cmdq);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

862

arm_smmu_cmdq_set_valid_map(cmdq, llq.prod, head.prod);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

867

atomic_cond_read_relaxed(&cmdq->owner_prod, VAL == llq.prod);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

871

&cmdq->q.llq.atomic.prod);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

879

arm_smmu_cmdq_poll_valid_map(cmdq, llq.prod, prod);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

885

writel_relaxed(prod, cmdq->q.prod_reg);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

892

atomic_set_release(&cmdq->owner_prod, prod);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

898

ret = arm_smmu_cmdq_poll_until_sync(smmu, cmdq, &llq);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

903

readl_relaxed(cmdq->q.prod_reg),

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

904

readl_relaxed(cmdq->q.cons_reg));

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

911

if (!arm_smmu_cmdq_shared_tryunlock(cmdq)) {

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

912

WRITE_ONCE(cmdq->q.llq.cons, llq.cons);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

913

arm_smmu_cmdq_shared_unlock(cmdq);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

954

cmds->cmdq = arm_smmu_get_cmdq(smmu, ent);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

961

bool unsupported_cmd = !arm_smmu_cmdq_supports_cmd(cmds->cmdq, cmd);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

967

arm_smmu_cmdq_issue_cmdlist(smmu, cmds->cmdq, cmds->cmds,

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

973

arm_smmu_cmdq_issue_cmdlist(smmu, cmds->cmdq, cmds->cmds,

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

991

return arm_smmu_cmdq_issue_cmdlist(smmu, cmds->cmdq, cmds->cmds,

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h

1013

struct arm_smmu_cmdq *cmdq, u64 *cmds, int n,

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h

639

static inline bool arm_smmu_cmdq_supports_cmd(struct arm_smmu_cmdq *cmdq,

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h

642

return cmdq->supports_cmd ? cmdq->supports_cmd(ent) : true;

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h

647

struct arm_smmu_cmdq *cmdq;

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h

779

struct arm_smmu_cmdq cmdq;

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h

980

struct arm_smmu_cmdq *cmdq);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h

986

struct arm_smmu_cmdq *cmdq);

drivers/iommu/arm/arm-smmu-v3/tegra241-cmdqv.c

1025

writeq_relaxed(vcmdq->cmdq.q.q_base, REG_VCMDQ_PAGE1(vcmdq, BASE));

drivers/iommu/arm/arm-smmu-v3/tegra241-cmdqv.c

1029

vcmdq->cmdq.q.q_base & VCMDQ_ADDR,

drivers/iommu/arm/arm-smmu-v3/tegra241-cmdqv.c

1030

1UL << (vcmdq->cmdq.q.q_base & VCMDQ_LOG2SIZE));

drivers/iommu/arm/arm-smmu-v3/tegra241-cmdqv.c

1125

vcmdq->cmdq.q.q_base = base_addr_pa & VCMDQ_ADDR;

drivers/iommu/arm/arm-smmu-v3/tegra241-cmdqv.c

1126

vcmdq->cmdq.q.q_base |= log2size;

drivers/iommu/arm/arm-smmu-v3/tegra241-cmdqv.c

144

struct arm_smmu_cmdq cmdq;

drivers/iommu/arm/arm-smmu-v3/tegra241-cmdqv.c

324

__arm_smmu_cmdq_skip_err(&vintf->cmdqv->smmu, &vcmdq->cmdq);

drivers/iommu/arm/arm-smmu-v3/tegra241-cmdqv.c

412

if (!arm_smmu_cmdq_supports_cmd(&vcmdq->cmdq, ent))

drivers/iommu/arm/arm-smmu-v3/tegra241-cmdqv.c

414

return &vcmdq->cmdq;

drivers/iommu/arm/arm-smmu-v3/tegra241-cmdqv.c

439

arm_smmu_cmdq_issue_cmdlist(smmu, &smmu->cmdq, cmd_sync, 1, true);

drivers/iommu/arm/arm-smmu-v3/tegra241-cmdqv.c

483

writeq_relaxed(vcmdq->cmdq.q.q_base, REG_VCMDQ_PAGE1(vcmdq, BASE));

drivers/iommu/arm/arm-smmu-v3/tegra241-cmdqv.c

618

struct arm_smmu_cmdq *cmdq = &vcmdq->cmdq;

drivers/iommu/arm/arm-smmu-v3/tegra241-cmdqv.c

619

struct arm_smmu_queue *q = &cmdq->q;

drivers/iommu/arm/arm-smmu-v3/tegra241-cmdqv.c

643

cmdq->supports_cmd = tegra241_guest_vcmdq_supports_cmd;

drivers/iommu/arm/arm-smmu-v3/tegra241-cmdqv.c

645

return arm_smmu_cmdq_init(smmu, cmdq);

drivers/iommu/riscv/iommu.c

1610

riscv_iommu_queue_disable(&iommu->cmdq);

drivers/iommu/riscv/iommu.c

1618

RISCV_IOMMU_QUEUE_INIT(&iommu->cmdq, CQ);

drivers/iommu/riscv/iommu.c

1629

rc = riscv_iommu_queue_alloc(iommu, &iommu->cmdq,

drivers/iommu/riscv/iommu.c

1639

rc = riscv_iommu_queue_enable(iommu, &iommu->cmdq, riscv_iommu_cmdq_process);

drivers/iommu/riscv/iommu.c

1680

riscv_iommu_queue_disable(&iommu->cmdq);

drivers/iommu/riscv/iommu.c

489

riscv_iommu_queue_send(&iommu->cmdq, cmd, sizeof(*cmd));

drivers/iommu/riscv/iommu.c

500

prod = riscv_iommu_queue_send(&iommu->cmdq, &cmd, sizeof(cmd));

drivers/iommu/riscv/iommu.c

505

if (riscv_iommu_queue_wait(&iommu->cmdq, prod, timeout_us))

drivers/iommu/riscv/iommu.h

56

struct riscv_iommu_queue cmdq;

drivers/mailbox/mtk-cmdq-mailbox.c

119

struct cmdq *cmdq = container_of(chan->mbox, struct cmdq, mbox);

drivers/mailbox/mtk-cmdq-mailbox.c

121

priv->shift_pa = cmdq->pdata->shift;

drivers/mailbox/mtk-cmdq-mailbox.c

122

priv->mminfra_offset = cmdq->pdata->mminfra_offset;

drivers/mailbox/mtk-cmdq-mailbox.c

128

struct cmdq *cmdq = container_of(chan->mbox, struct cmdq, mbox);

drivers/mailbox/mtk-cmdq-mailbox.c

130

return cmdq->pdata->shift;

drivers/mailbox/mtk-cmdq-mailbox.c

134

static void cmdq_vm_init(struct cmdq *cmdq)

drivers/mailbox/mtk-cmdq-mailbox.c

140

if (!cmdq->pdata->gce_vm)

drivers/mailbox/mtk-cmdq-mailbox.c

143

vm_map = kcalloc(cmdq->pdata->thread_nr, sizeof(*vm_map), GFP_KERNEL);

drivers/mailbox/mtk-cmdq-mailbox.c

151

for (i = 0; i < cmdq->pdata->thread_nr; i++)

drivers/mailbox/mtk-cmdq-mailbox.c

155

writel(vm_cpr_gsize, cmdq->base + GCE_VM_CPR_GSIZE);

drivers/mailbox/mtk-cmdq-mailbox.c

158

for (i = 0; i < cmdq->pdata->thread_nr; i++) {

drivers/mailbox/mtk-cmdq-mailbox.c

162

writel(vm_id_map, cmdq->base + GCE_VM_ID_MAP(i));

drivers/mailbox/mtk-cmdq-mailbox.c

167

if (cmdq->pdata->thread_nr % 10 != 0)

drivers/mailbox/mtk-cmdq-mailbox.c

168

writel(vm_id_map, cmdq->base + GCE_VM_ID_MAP(cmdq->pdata->thread_nr - 1));

drivers/mailbox/mtk-cmdq-mailbox.c

173

static void cmdq_gctl_value_toggle(struct cmdq *cmdq, bool ddr_enable)

drivers/mailbox/mtk-cmdq-mailbox.c

175

u32 val = cmdq->pdata->control_by_sw ? GCE_CTRL_BY_SW : 0;

drivers/mailbox/mtk-cmdq-mailbox.c

177

if (!cmdq->pdata->control_by_sw && !cmdq->pdata->sw_ddr_en)

drivers/mailbox/mtk-cmdq-mailbox.c

180

if (cmdq->pdata->sw_ddr_en && ddr_enable)

drivers/mailbox/mtk-cmdq-mailbox.c

183

writel(val, cmdq->base + GCE_GCTL_VALUE);

drivers/mailbox/mtk-cmdq-mailbox.c

186

static int cmdq_thread_suspend(struct cmdq *cmdq, struct cmdq_thread *thread)

drivers/mailbox/mtk-cmdq-mailbox.c

198

dev_err(cmdq->mbox.dev, "suspend GCE thread 0x%x failed\n",

drivers/mailbox/mtk-cmdq-mailbox.c

199

(u32)(thread->base - cmdq->base));

drivers/mailbox/mtk-cmdq-mailbox.c

211

static void cmdq_init(struct cmdq *cmdq)

drivers/mailbox/mtk-cmdq-mailbox.c

215

WARN_ON(clk_bulk_enable(cmdq->pdata->gce_num, cmdq->clocks));

drivers/mailbox/mtk-cmdq-mailbox.c

217

cmdq_vm_init(cmdq);

drivers/mailbox/mtk-cmdq-mailbox.c

218

cmdq_gctl_value_toggle(cmdq, true);

drivers/mailbox/mtk-cmdq-mailbox.c

220

writel(CMDQ_THR_ACTIVE_SLOT_CYCLES, cmdq->base + CMDQ_THR_SLOT_CYCLES);

drivers/mailbox/mtk-cmdq-mailbox.c

222

writel(i, cmdq->base + CMDQ_SYNC_TOKEN_UPDATE);

drivers/mailbox/mtk-cmdq-mailbox.c

223

clk_bulk_disable(cmdq->pdata->gce_num, cmdq->clocks);

drivers/mailbox/mtk-cmdq-mailbox.c

226

static int cmdq_thread_reset(struct cmdq *cmdq, struct cmdq_thread *thread)

drivers/mailbox/mtk-cmdq-mailbox.c

234

dev_err(cmdq->mbox.dev, "reset GCE thread 0x%x failed\n",

drivers/mailbox/mtk-cmdq-mailbox.c

235

(u32)(thread->base - cmdq->base));

drivers/mailbox/mtk-cmdq-mailbox.c

242

static void cmdq_thread_disable(struct cmdq *cmdq, struct cmdq_thread *thread)

drivers/mailbox/mtk-cmdq-mailbox.c

244

cmdq_thread_reset(cmdq, thread);

drivers/mailbox/mtk-cmdq-mailbox.c

257

struct device *dev = task->cmdq->mbox.dev;

drivers/mailbox/mtk-cmdq-mailbox.c

262

u32 gce_addr = cmdq_convert_gce_addr(task->pa_base, task->cmdq->pdata);

drivers/mailbox/mtk-cmdq-mailbox.c

294

struct cmdq *cmdq = task->cmdq;

drivers/mailbox/mtk-cmdq-mailbox.c

296

dev_err(cmdq->mbox.dev, "task 0x%p error\n", task);

drivers/mailbox/mtk-cmdq-mailbox.c

297

WARN_ON(cmdq_thread_suspend(cmdq, thread) < 0);

drivers/mailbox/mtk-cmdq-mailbox.c

301

writel(next_task->pa_base >> cmdq->pdata->shift,

drivers/mailbox/mtk-cmdq-mailbox.c

306

static void cmdq_thread_irq_handler(struct cmdq *cmdq,

drivers/mailbox/mtk-cmdq-mailbox.c

334

curr_pa = cmdq_revert_gce_addr(gce_addr, cmdq->pdata);

drivers/mailbox/mtk-cmdq-mailbox.c

356

cmdq_thread_disable(cmdq, thread);

drivers/mailbox/mtk-cmdq-mailbox.c

361

struct cmdq *cmdq = dev;

drivers/mailbox/mtk-cmdq-mailbox.c

365

irq_status = readl(cmdq->base + CMDQ_CURR_IRQ_STATUS) & cmdq->irq_mask;

drivers/mailbox/mtk-cmdq-mailbox.c

366

if (!(irq_status ^ cmdq->irq_mask))

drivers/mailbox/mtk-cmdq-mailbox.c

369

for_each_clear_bit(bit, &irq_status, cmdq->pdata->thread_nr) {

drivers/mailbox/mtk-cmdq-mailbox.c

370

struct cmdq_thread *thread = &cmdq->thread[bit];

drivers/mailbox/mtk-cmdq-mailbox.c

373

cmdq_thread_irq_handler(cmdq, thread);

drivers/mailbox/mtk-cmdq-mailbox.c

377

pm_runtime_mark_last_busy(cmdq->mbox.dev);

drivers/mailbox/mtk-cmdq-mailbox.c

384

struct cmdq *cmdq = dev_get_drvdata(dev);

drivers/mailbox/mtk-cmdq-mailbox.c

387

ret = clk_bulk_enable(cmdq->pdata->gce_num, cmdq->clocks);

drivers/mailbox/mtk-cmdq-mailbox.c

391

cmdq_gctl_value_toggle(cmdq, true);

drivers/mailbox/mtk-cmdq-mailbox.c

397

struct cmdq *cmdq = dev_get_drvdata(dev);

drivers/mailbox/mtk-cmdq-mailbox.c

399

cmdq_gctl_value_toggle(cmdq, false);

drivers/mailbox/mtk-cmdq-mailbox.c

400

clk_bulk_disable(cmdq->pdata->gce_num, cmdq->clocks);

drivers/mailbox/mtk-cmdq-mailbox.c

406

struct cmdq *cmdq = dev_get_drvdata(dev);

drivers/mailbox/mtk-cmdq-mailbox.c

411

cmdq->suspended = true;

drivers/mailbox/mtk-cmdq-mailbox.c

413

for (i = 0; i < cmdq->pdata->thread_nr; i++) {

drivers/mailbox/mtk-cmdq-mailbox.c

414

thread = &cmdq->thread[i];

drivers/mailbox/mtk-cmdq-mailbox.c

429

struct cmdq *cmdq = dev_get_drvdata(dev);

drivers/mailbox/mtk-cmdq-mailbox.c

432

cmdq->suspended = false;

drivers/mailbox/mtk-cmdq-mailbox.c

439

struct cmdq *cmdq = platform_get_drvdata(pdev);

drivers/mailbox/mtk-cmdq-mailbox.c

444

clk_bulk_unprepare(cmdq->pdata->gce_num, cmdq->clocks);

drivers/mailbox/mtk-cmdq-mailbox.c

451

struct cmdq *cmdq = dev_get_drvdata(chan->mbox->dev);

drivers/mailbox/mtk-cmdq-mailbox.c

457

WARN_ON(cmdq->suspended);

drivers/mailbox/mtk-cmdq-mailbox.c

463

task->cmdq = cmdq;

drivers/mailbox/mtk-cmdq-mailbox.c

476

WARN_ON(cmdq_thread_reset(cmdq, thread) < 0);

drivers/mailbox/mtk-cmdq-mailbox.c

478

gce_addr = cmdq_convert_gce_addr(task->pa_base, cmdq->pdata);

drivers/mailbox/mtk-cmdq-mailbox.c

480

gce_addr = cmdq_convert_gce_addr(task->pa_base + pkt->cmd_buf_size, cmdq->pdata);

drivers/mailbox/mtk-cmdq-mailbox.c

487

WARN_ON(cmdq_thread_suspend(cmdq, thread) < 0);

drivers/mailbox/mtk-cmdq-mailbox.c

489

curr_pa = cmdq_revert_gce_addr(gce_addr, cmdq->pdata);

drivers/mailbox/mtk-cmdq-mailbox.c

491

end_pa = cmdq_revert_gce_addr(gce_addr, cmdq->pdata);

drivers/mailbox/mtk-cmdq-mailbox.c

496

writel(task->pa_base >> cmdq->pdata->shift,

drivers/mailbox/mtk-cmdq-mailbox.c

502

writel((task->pa_base + pkt->cmd_buf_size) >> cmdq->pdata->shift,

drivers/mailbox/mtk-cmdq-mailbox.c

519

struct cmdq *cmdq = dev_get_drvdata(chan->mbox->dev);

drivers/mailbox/mtk-cmdq-mailbox.c

523

WARN_ON(pm_runtime_get_sync(cmdq->mbox.dev) < 0);

drivers/mailbox/mtk-cmdq-mailbox.c

529

WARN_ON(cmdq_thread_suspend(cmdq, thread) < 0);

drivers/mailbox/mtk-cmdq-mailbox.c

532

cmdq_thread_irq_handler(cmdq, thread);

drivers/mailbox/mtk-cmdq-mailbox.c

542

cmdq_thread_disable(cmdq, thread);

drivers/mailbox/mtk-cmdq-mailbox.c

553

pm_runtime_mark_last_busy(cmdq->mbox.dev);

drivers/mailbox/mtk-cmdq-mailbox.c

554

pm_runtime_put_autosuspend(cmdq->mbox.dev);

drivers/mailbox/mtk-cmdq-mailbox.c

561

struct cmdq *cmdq = dev_get_drvdata(chan->mbox->dev);

drivers/mailbox/mtk-cmdq-mailbox.c

567

ret = pm_runtime_get_sync(cmdq->mbox.dev);

drivers/mailbox/mtk-cmdq-mailbox.c

575

WARN_ON(cmdq_thread_suspend(cmdq, thread) < 0);

drivers/mailbox/mtk-cmdq-mailbox.c

589

cmdq_thread_disable(cmdq, thread);

drivers/mailbox/mtk-cmdq-mailbox.c

593

pm_runtime_mark_last_busy(cmdq->mbox.dev);

drivers/mailbox/mtk-cmdq-mailbox.c

594

pm_runtime_put_autosuspend(cmdq->mbox.dev);

drivers/mailbox/mtk-cmdq-mailbox.c

603

dev_err(cmdq->mbox.dev, "Fail to wait GCE thread 0x%x done\n",

drivers/mailbox/mtk-cmdq-mailbox.c

604

(u32)(thread->base - cmdq->base));

drivers/mailbox/mtk-cmdq-mailbox.c

608

pm_runtime_mark_last_busy(cmdq->mbox.dev);

drivers/mailbox/mtk-cmdq-mailbox.c

609

pm_runtime_put_autosuspend(cmdq->mbox.dev);

drivers/mailbox/mtk-cmdq-mailbox.c

636

static int cmdq_get_clocks(struct device *dev, struct cmdq *cmdq)

drivers/mailbox/mtk-cmdq-mailbox.c

642

cmdq->clocks = devm_kcalloc(dev, cmdq->pdata->gce_num,

drivers/mailbox/mtk-cmdq-mailbox.c

643

sizeof(*cmdq->clocks), GFP_KERNEL);

drivers/mailbox/mtk-cmdq-mailbox.c

644

if (!cmdq->clocks)

drivers/mailbox/mtk-cmdq-mailbox.c

647

if (cmdq->pdata->gce_num == 1) {

drivers/mailbox/mtk-cmdq-mailbox.c

648

clks = &cmdq->clocks[0];

drivers/mailbox/mtk-cmdq-mailbox.c

667

if (alias_id < 0 || alias_id >= cmdq->pdata->gce_num)

drivers/mailbox/mtk-cmdq-mailbox.c

670

clks = &cmdq->clocks[alias_id];

drivers/mailbox/mtk-cmdq-mailbox.c

688

struct cmdq *cmdq;

drivers/mailbox/mtk-cmdq-mailbox.c

691

cmdq = devm_kzalloc(dev, sizeof(*cmdq), GFP_KERNEL);

drivers/mailbox/mtk-cmdq-mailbox.c

692

if (!cmdq)

drivers/mailbox/mtk-cmdq-mailbox.c

695

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

drivers/mailbox/mtk-cmdq-mailbox.c

696

if (IS_ERR(cmdq->base))

drivers/mailbox/mtk-cmdq-mailbox.c

697

return PTR_ERR(cmdq->base);

drivers/mailbox/mtk-cmdq-mailbox.c

699

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

drivers/mailbox/mtk-cmdq-mailbox.c

700

if (cmdq->irq < 0)

drivers/mailbox/mtk-cmdq-mailbox.c

701

return cmdq->irq;

drivers/mailbox/mtk-cmdq-mailbox.c

703

cmdq->pdata = device_get_match_data(dev);

drivers/mailbox/mtk-cmdq-mailbox.c

704

if (!cmdq->pdata) {

drivers/mailbox/mtk-cmdq-mailbox.c

709

cmdq->irq_mask = GENMASK(cmdq->pdata->thread_nr - 1, 0);

drivers/mailbox/mtk-cmdq-mailbox.c

712

dev, cmdq->base, cmdq->irq);

drivers/mailbox/mtk-cmdq-mailbox.c

714

err = cmdq_get_clocks(dev, cmdq);

drivers/mailbox/mtk-cmdq-mailbox.c

719

DMA_BIT_MASK(sizeof(u32) * BITS_PER_BYTE + cmdq->pdata->shift));

drivers/mailbox/mtk-cmdq-mailbox.c

721

cmdq->mbox.dev = dev;

drivers/mailbox/mtk-cmdq-mailbox.c

722

cmdq->mbox.chans = devm_kcalloc(dev, cmdq->pdata->thread_nr,

drivers/mailbox/mtk-cmdq-mailbox.c

723

sizeof(*cmdq->mbox.chans), GFP_KERNEL);

drivers/mailbox/mtk-cmdq-mailbox.c

724

if (!cmdq->mbox.chans)

drivers/mailbox/mtk-cmdq-mailbox.c

727

cmdq->mbox.num_chans = cmdq->pdata->thread_nr;

drivers/mailbox/mtk-cmdq-mailbox.c

728

cmdq->mbox.ops = &cmdq_mbox_chan_ops;

drivers/mailbox/mtk-cmdq-mailbox.c

729

cmdq->mbox.of_xlate = cmdq_xlate;

drivers/mailbox/mtk-cmdq-mailbox.c

732

cmdq->mbox.txdone_irq = false;

drivers/mailbox/mtk-cmdq-mailbox.c

733

cmdq->mbox.txdone_poll = false;

drivers/mailbox/mtk-cmdq-mailbox.c

735

cmdq->thread = devm_kcalloc(dev, cmdq->pdata->thread_nr,

drivers/mailbox/mtk-cmdq-mailbox.c

736

sizeof(*cmdq->thread), GFP_KERNEL);

drivers/mailbox/mtk-cmdq-mailbox.c

737

if (!cmdq->thread)

drivers/mailbox/mtk-cmdq-mailbox.c

740

for (i = 0; i < cmdq->pdata->thread_nr; i++) {

drivers/mailbox/mtk-cmdq-mailbox.c

741

cmdq->thread[i].base = cmdq->base + CMDQ_THR_BASE +

drivers/mailbox/mtk-cmdq-mailbox.c

743

INIT_LIST_HEAD(&cmdq->thread[i].task_busy_list);

drivers/mailbox/mtk-cmdq-mailbox.c

744

cmdq->mbox.chans[i].con_priv = (void *)&cmdq->thread[i];

drivers/mailbox/mtk-cmdq-mailbox.c

747

platform_set_drvdata(pdev, cmdq);

drivers/mailbox/mtk-cmdq-mailbox.c

749

WARN_ON(clk_bulk_prepare(cmdq->pdata->gce_num, cmdq->clocks));

drivers/mailbox/mtk-cmdq-mailbox.c

751

cmdq_init(cmdq);

drivers/mailbox/mtk-cmdq-mailbox.c

753

err = devm_request_irq(dev, cmdq->irq, cmdq_irq_handler, IRQF_SHARED,

drivers/mailbox/mtk-cmdq-mailbox.c

754

"mtk_cmdq", cmdq);

drivers/mailbox/mtk-cmdq-mailbox.c

77

struct cmdq *cmdq;

drivers/mailbox/mtk-cmdq-mailbox.c

774

err = devm_mbox_controller_register(dev, &cmdq->mbox);

drivers/net/ethernet/brocade/bna/bfa_cs.h

45

BFA_SM_TABLE(cmdq, bfa_msgq_cmdq, cmdq_event, bfa_fsm_msgq_cmdq_t)

drivers/net/ethernet/brocade/bna/bfa_msgq.c

102

bfa_fsm_set_state(cmdq, cmdq_sm_stopped);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

106

cmdq->flags |= BFA_MSGQ_CMDQ_F_DB_UPDATE;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

110

if (cmdq->flags & BFA_MSGQ_CMDQ_F_DB_UPDATE) {

drivers/net/ethernet/brocade/bna/bfa_msgq.c

111

cmdq->flags &= ~BFA_MSGQ_CMDQ_F_DB_UPDATE;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

112

bfa_fsm_set_state(cmdq, cmdq_sm_dbell_wait);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

114

bfa_fsm_set_state(cmdq, cmdq_sm_ready);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

123

cmdq_sm_ready_entry(struct bfa_msgq_cmdq *cmdq)

drivers/net/ethernet/brocade/bna/bfa_msgq.c

128

cmdq_sm_ready(struct bfa_msgq_cmdq *cmdq, enum cmdq_event event)

drivers/net/ethernet/brocade/bna/bfa_msgq.c

133

bfa_fsm_set_state(cmdq, cmdq_sm_stopped);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

137

bfa_fsm_set_state(cmdq, cmdq_sm_dbell_wait);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

146

cmdq_sm_dbell_wait_entry(struct bfa_msgq_cmdq *cmdq)

drivers/net/ethernet/brocade/bna/bfa_msgq.c

148

bfa_msgq_cmdq_dbell(cmdq);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

152

cmdq_sm_dbell_wait(struct bfa_msgq_cmdq *cmdq, enum cmdq_event event)

drivers/net/ethernet/brocade/bna/bfa_msgq.c

157

bfa_fsm_set_state(cmdq, cmdq_sm_stopped);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

161

cmdq->flags |= BFA_MSGQ_CMDQ_F_DB_UPDATE;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

165

if (cmdq->flags & BFA_MSGQ_CMDQ_F_DB_UPDATE) {

drivers/net/ethernet/brocade/bna/bfa_msgq.c

166

cmdq->flags &= ~BFA_MSGQ_CMDQ_F_DB_UPDATE;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

167

bfa_fsm_set_state(cmdq, cmdq_sm_dbell_wait);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

169

bfa_fsm_set_state(cmdq, cmdq_sm_ready);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

180

struct bfa_msgq_cmdq *cmdq = (struct bfa_msgq_cmdq *)arg;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

181

bfa_fsm_send_event(cmdq, CMDQ_E_DB_READY);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

185

bfa_msgq_cmdq_dbell(struct bfa_msgq_cmdq *cmdq)

drivers/net/ethernet/brocade/bna/bfa_msgq.c

188

(struct bfi_msgq_h2i_db *)(&cmdq->dbell_mb.msg[0]);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

193

dbell->idx.cmdq_pi = htons(cmdq->producer_index);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

195

if (!bfa_nw_ioc_mbox_queue(cmdq->msgq->ioc, &cmdq->dbell_mb,

drivers/net/ethernet/brocade/bna/bfa_msgq.c

196

bfa_msgq_cmdq_dbell_ready, cmdq)) {

drivers/net/ethernet/brocade/bna/bfa_msgq.c

197

bfa_msgq_cmdq_dbell_ready(cmdq);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

202

__cmd_copy(struct bfa_msgq_cmdq *cmdq, struct bfa_msgq_cmd_entry *cmd)

drivers/net/ethernet/brocade/bna/bfa_msgq.c

209

dst = (u8 *)cmdq->addr.kva;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

210

dst += (cmdq->producer_index * BFI_MSGQ_CMD_ENTRY_SIZE);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

218

BFA_MSGQ_INDX_ADD(cmdq->producer_index, 1, cmdq->depth);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

219

dst = (u8 *)cmdq->addr.kva;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

220

dst += (cmdq->producer_index * BFI_MSGQ_CMD_ENTRY_SIZE);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

226

bfa_msgq_cmdq_ci_update(struct bfa_msgq_cmdq *cmdq, struct bfi_mbmsg *mb)

drivers/net/ethernet/brocade/bna/bfa_msgq.c

232

cmdq->consumer_index = ntohs(dbell->idx.cmdq_ci);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

235

while (!list_empty(&cmdq->pending_q)) {

drivers/net/ethernet/brocade/bna/bfa_msgq.c

236

cmd = list_first_entry(&cmdq->pending_q,

drivers/net/ethernet/brocade/bna/bfa_msgq.c

239

BFA_MSGQ_FREE_CNT(cmdq)) {

drivers/net/ethernet/brocade/bna/bfa_msgq.c

241

__cmd_copy(cmdq, cmd);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

250

bfa_fsm_send_event(cmdq, CMDQ_E_POST);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

256

struct bfa_msgq_cmdq *cmdq = (struct bfa_msgq_cmdq *)arg;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

258

if (cmdq->bytes_to_copy)

drivers/net/ethernet/brocade/bna/bfa_msgq.c

259

bfa_msgq_cmdq_copy_rsp(cmdq);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

263

bfa_msgq_cmdq_copy_req(struct bfa_msgq_cmdq *cmdq, struct bfi_mbmsg *mb)

drivers/net/ethernet/brocade/bna/bfa_msgq.c

268

cmdq->token = 0;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

269

cmdq->offset = ntohs(req->offset);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

270

cmdq->bytes_to_copy = ntohs(req->len);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

271

bfa_msgq_cmdq_copy_rsp(cmdq);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

275

bfa_msgq_cmdq_copy_rsp(struct bfa_msgq_cmdq *cmdq)

drivers/net/ethernet/brocade/bna/bfa_msgq.c

278

(struct bfi_msgq_h2i_cmdq_copy_rsp *)&cmdq->copy_mb.msg[0];

drivers/net/ethernet/brocade/bna/bfa_msgq.c

280

u8 *addr = (u8 *)cmdq->addr.kva;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

284

rsp->mh.mtag.i2htok = htons(cmdq->token);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

285

copied = (cmdq->bytes_to_copy >= BFI_CMD_COPY_SZ) ? BFI_CMD_COPY_SZ :

drivers/net/ethernet/brocade/bna/bfa_msgq.c

286

cmdq->bytes_to_copy;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

287

addr += cmdq->offset;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

290

cmdq->token++;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

291

cmdq->offset += copied;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

292

cmdq->bytes_to_copy -= copied;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

294

if (!bfa_nw_ioc_mbox_queue(cmdq->msgq->ioc, &cmdq->copy_mb,

drivers/net/ethernet/brocade/bna/bfa_msgq.c

295

bfa_msgq_cmdq_copy_next, cmdq)) {

drivers/net/ethernet/brocade/bna/bfa_msgq.c

296

bfa_msgq_cmdq_copy_next(cmdq);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

301

bfa_msgq_cmdq_attach(struct bfa_msgq_cmdq *cmdq, struct bfa_msgq *msgq)

drivers/net/ethernet/brocade/bna/bfa_msgq.c

303

cmdq->depth = BFA_MSGQ_CMDQ_NUM_ENTRY;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

304

INIT_LIST_HEAD(&cmdq->pending_q);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

305

cmdq->msgq = msgq;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

306

bfa_fsm_set_state(cmdq, cmdq_sm_stopped);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

31

static void bfa_msgq_cmdq_dbell(struct bfa_msgq_cmdq *cmdq);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

32

static void bfa_msgq_cmdq_copy_rsp(struct bfa_msgq_cmdq *cmdq);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

43

bfa_fsm_state_decl(cmdq, stopped, struct bfa_msgq_cmdq, enum cmdq_event);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

44

bfa_fsm_state_decl(cmdq, init_wait, struct bfa_msgq_cmdq, enum cmdq_event);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

45

bfa_fsm_state_decl(cmdq, ready, struct bfa_msgq_cmdq, enum cmdq_event);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

46

bfa_fsm_state_decl(cmdq, dbell_wait, struct bfa_msgq_cmdq,

drivers/net/ethernet/brocade/bna/bfa_msgq.c

50

cmdq_sm_stopped_entry(struct bfa_msgq_cmdq *cmdq)

drivers/net/ethernet/brocade/bna/bfa_msgq.c

500

bfa_fsm_send_event(&msgq->cmdq, CMDQ_E_INIT_RESP);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

515

bfa_dma_be_addr_set(msgq_cfg->cmdq.addr, msgq->cmdq.addr.pa);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

516

msgq_cfg->cmdq.q_depth = htons(msgq->cmdq.depth);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

538

bfa_msgq_cmdq_ci_update(&msgq->cmdq, msg);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

54

cmdq->producer_index = 0;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

542

bfa_msgq_cmdq_copy_req(&msgq->cmdq, msg);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

55

cmdq->consumer_index = 0;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

559

bfa_fsm_send_event(&msgq->cmdq, CMDQ_E_START);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

56

cmdq->flags = 0;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

566

bfa_fsm_send_event(&msgq->cmdq, CMDQ_E_STOP);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

57

cmdq->token = 0;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

571

bfa_fsm_send_event(&msgq->cmdq, CMDQ_E_FAIL);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

58

cmdq->offset = 0;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

59

cmdq->bytes_to_copy = 0;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

590

msgq->cmdq.addr.kva = kva;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

591

msgq->cmdq.addr.pa = pa;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

60

while (!list_empty(&cmdq->pending_q)) {

drivers/net/ethernet/brocade/bna/bfa_msgq.c

605

bfa_msgq_cmdq_attach(&msgq->cmdq, msgq);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

61

cmdq_ent = list_first_entry(&cmdq->pending_q,

drivers/net/ethernet/brocade/bna/bfa_msgq.c

625

BFA_MSGQ_FREE_CNT(&msgq->cmdq)) {

drivers/net/ethernet/brocade/bna/bfa_msgq.c

626

__cmd_copy(&msgq->cmdq, cmd);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

628

bfa_fsm_send_event(&msgq->cmdq, CMDQ_E_POST);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

630

list_add_tail(&cmd->qe, &msgq->cmdq.pending_q);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

69

cmdq_sm_stopped(struct bfa_msgq_cmdq *cmdq, enum cmdq_event event)

drivers/net/ethernet/brocade/bna/bfa_msgq.c

73

bfa_fsm_set_state(cmdq, cmdq_sm_init_wait);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

82

cmdq->flags |= BFA_MSGQ_CMDQ_F_DB_UPDATE;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

91

cmdq_sm_init_wait_entry(struct bfa_msgq_cmdq *cmdq)

drivers/net/ethernet/brocade/bna/bfa_msgq.c

93

bfa_wc_down(&cmdq->msgq->init_wc);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

97

cmdq_sm_init_wait(struct bfa_msgq_cmdq *cmdq, enum cmdq_event event)

drivers/net/ethernet/brocade/bna/bfa_msgq.h

108

struct bfa_msgq_cmdq cmdq;

drivers/net/ethernet/brocade/bna/bfi.h

420

struct bfi_msgq cmdq;

drivers/net/ethernet/chelsio/cxgb/sge.c

1438

struct cmdQ *cmdq = &sge->cmdQ[0];

drivers/net/ethernet/chelsio/cxgb/sge.c

1440

cmdq->processed += pr0;

drivers/net/ethernet/chelsio/cxgb/sge.c

1446

clear_bit(CMDQ_STAT_RUNNING, &cmdq->status);

drivers/net/ethernet/chelsio/cxgb/sge.c

1448

if (cmdq->cleaned + cmdq->in_use != cmdq->processed &&

drivers/net/ethernet/chelsio/cxgb/sge.c

1449

!test_and_set_bit(CMDQ_STAT_LAST_PKT_DB, &cmdq->status)) {

drivers/net/ethernet/chelsio/cxgb/sge.c

1450

set_bit(CMDQ_STAT_RUNNING, &cmdq->status);

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_cmd.c

541

struct hclge_comm_cmq *cmdq = &hw->cmq;

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_cmd.c

550

spin_lock_bh(&cmdq->csq.lock);

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_cmd.c

551

spin_lock(&cmdq->crq.lock);

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_cmd.c

553

spin_unlock(&cmdq->crq.lock);

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_cmd.c

554

spin_unlock_bh(&cmdq->csq.lock);

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_cmd.c

556

hclge_comm_free_cmd_desc(&cmdq->csq);

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_cmd.c

557

hclge_comm_free_cmd_desc(&cmdq->crq);

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_cmd.c

563

struct hclge_comm_cmq *cmdq = &hw->cmq;

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_cmd.c

567

spin_lock_init(&cmdq->csq.lock);

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_cmd.c

568

spin_lock_init(&cmdq->crq.lock);

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_cmd.c

570

cmdq->csq.pdev = pdev;

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_cmd.c

571

cmdq->crq.pdev = pdev;

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_cmd.c

574

cmdq->csq.desc_num = HCLGE_COMM_NIC_CMQ_DESC_NUM;

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_cmd.c

575

cmdq->crq.desc_num = HCLGE_COMM_NIC_CMQ_DESC_NUM;

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_cmd.c

578

cmdq->tx_timeout = HCLGE_COMM_CMDQ_TX_TIMEOUT_DEFAULT;

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_cmd.c

603

struct hclge_comm_cmq *cmdq = &hw->cmq;

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_cmd.c

606

cmdq->ops.trace_cmd_send = ops->trace_cmd_send;

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_cmd.c

607

cmdq->ops.trace_cmd_get = ops->trace_cmd_get;

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_cmd.c

616

struct hclge_comm_cmq *cmdq = &hw->cmq;

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_cmd.c

619

spin_lock_bh(&cmdq->csq.lock);

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_cmd.c

620

spin_lock(&cmdq->crq.lock);

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_cmd.c

622

cmdq->csq.next_to_clean = 0;

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_cmd.c

623

cmdq->csq.next_to_use = 0;

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_cmd.c

624

cmdq->crq.next_to_clean = 0;

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_cmd.c

625

cmdq->crq.next_to_use = 0;

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_cmd.c

629

spin_unlock(&cmdq->crq.lock);

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_cmd.c

630

spin_unlock_bh(&cmdq->csq.lock);

drivers/net/ethernet/hisilicon/hns3/hns3vf/hclgevf_main.c

89

struct hclge_comm_cmq *cmdq = &hdev->hw.hw.cmq;

drivers/net/ethernet/hisilicon/hns3/hns3vf/hclgevf_main.c

91

spin_lock(&cmdq->crq.lock);

drivers/net/ethernet/hisilicon/hns3/hns3vf/hclgevf_main.c

97

spin_unlock(&cmdq->crq.lock);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

320

static void cmdq_set_db(struct hinic_cmdq *cmdq,

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

332

writel(db_info, CMDQ_DB_ADDR(cmdq->db_base, prod_idx));

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

335

static int cmdq_sync_cmd_direct_resp(struct hinic_cmdq *cmdq,

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

343

struct hinic_wq *wq = cmdq->wq;

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

348

spin_lock_bh(&cmdq->cmdq_lock);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

353

spin_unlock_bh(&cmdq->cmdq_lock);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

359

wrapped = cmdq->wrapped;

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

364

cmdq->wrapped = !cmdq->wrapped;

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

368

cmdq->errcode[curr_prod_idx] = &errcode;

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

371

cmdq->done[curr_prod_idx] = &done;

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

383

cmdq_set_db(cmdq, HINIC_CMDQ_SYNC, next_prod_idx);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

385

spin_unlock_bh(&cmdq->cmdq_lock);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

389

spin_lock_bh(&cmdq->cmdq_lock);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

391

if (cmdq->errcode[curr_prod_idx] == &errcode)

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

392

cmdq->errcode[curr_prod_idx] = NULL;

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

394

if (cmdq->done[curr_prod_idx] == &done)

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

395

cmdq->done[curr_prod_idx] = NULL;

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

397

spin_unlock_bh(&cmdq->cmdq_lock);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

399

hinic_dump_ceq_info(cmdq->hwdev);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

417

static int cmdq_set_arm_bit(struct hinic_cmdq *cmdq, void *buf_in,

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

422

struct hinic_wq *wq = cmdq->wq;

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

427

spin_lock(&cmdq->cmdq_lock);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

432

spin_unlock(&cmdq->cmdq_lock);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

438

wrapped = cmdq->wrapped;

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

443

cmdq->wrapped = !cmdq->wrapped;

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

457

cmdq_set_db(cmdq, HINIC_CMDQ_SYNC, next_prod_idx);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

459

spin_unlock(&cmdq->cmdq_lock);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

495

return cmdq_sync_cmd_direct_resp(&cmdqs->cmdq[HINIC_CMDQ_SYNC],

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

510

struct hinic_cmdq *cmdq = &cmdqs->cmdq[HINIC_CMDQ_SYNC];

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

519

err = cmdq_set_arm_bit(cmdq, &arm_bit, sizeof(arm_bit));

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

528

static void clear_wqe_complete_bit(struct hinic_cmdq *cmdq,

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

562

static int cmdq_arm_ceq_handler(struct hinic_cmdq *cmdq,

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

578

clear_wqe_complete_bit(cmdq, wqe);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

580

hinic_put_wqe(cmdq->wq, WQE_SCMD_SIZE);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

584

static void cmdq_update_errcode(struct hinic_cmdq *cmdq, u16 prod_idx,

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

587

if (cmdq->errcode[prod_idx])

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

588

*cmdq->errcode[prod_idx] = errcode;

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

597

static void cmdq_sync_cmd_handler(struct hinic_cmdq *cmdq, u16 cons_idx,

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

602

spin_lock(&cmdq->cmdq_lock);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

603

cmdq_update_errcode(cmdq, prod_idx, errcode);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

607

if (cmdq->done[prod_idx])

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

608

complete(cmdq->done[prod_idx]);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

609

spin_unlock(&cmdq->cmdq_lock);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

612

static int cmdq_cmd_ceq_handler(struct hinic_cmdq *cmdq, u16 ci,

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

627

cmdq_sync_cmd_handler(cmdq, ci, errcode);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

629

clear_wqe_complete_bit(cmdq, cmdq_wqe);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

630

hinic_put_wqe(cmdq->wq, WQE_LCMD_SIZE);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

643

struct hinic_cmdq *cmdq = &cmdqs->cmdq[cmdq_type];

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

651

while ((hw_wqe = hinic_read_wqe(cmdq->wq, WQE_SCMD_SIZE, &ci))) {

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

662

if (cmdq_arm_ceq_handler(cmdq, &hw_wqe->cmdq_wqe))

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

667

hw_wqe = hinic_read_wqe(cmdq->wq, WQE_LCMD_SIZE, &ci);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

671

if (cmdq_cmd_ceq_handler(cmdq, ci, &hw_wqe->cmdq_wqe))

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

693

struct hinic_cmdq *cmdq,

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

698

struct hinic_cmdqs *cmdqs = cmdq_to_cmdqs(cmdq);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

699

struct hinic_wq *wq = cmdq->wq;

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

711

HINIC_CMDQ_CTXT_PAGE_INFO_SET(cmdq->wrapped, WRAPPED);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

726

cmdq_ctxt->cmdq_type = cmdq->cmdq_type;

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

738

static int init_cmdq(struct hinic_cmdq *cmdq, struct hinic_wq *wq,

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

743

cmdq->wq = wq;

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

744

cmdq->cmdq_type = q_type;

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

745

cmdq->wrapped = 1;

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

747

spin_lock_init(&cmdq->cmdq_lock);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

749

cmdq->done = vzalloc(array_size(sizeof(*cmdq->done), wq->q_depth));

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

750

if (!cmdq->done)

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

753

cmdq->errcode = vzalloc(array_size(sizeof(*cmdq->errcode),

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

755

if (!cmdq->errcode) {

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

760

cmdq->db_base = db_area + CMDQ_DB_OFF;

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

764

vfree(cmdq->done);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

772

static void free_cmdq(struct hinic_cmdq *cmdq)

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

774

vfree(cmdq->errcode);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

775

vfree(cmdq->done);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

78

#define cmdq_to_cmdqs(cmdq) container_of((cmdq) - (cmdq)->cmdq_type, \

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

79

struct hinic_cmdqs, cmdq[0])

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

805

cmdqs->cmdq[cmdq_type].hwdev = hwdev;

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

806

err = init_cmdq(&cmdqs->cmdq[cmdq_type],

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

815

&cmdqs->cmdq[cmdq_type],

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

842

free_cmdq(&cmdqs->cmdq[type]);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

927

free_cmdq(&cmdqs->cmdq[HINIC_CMDQ_SYNC]);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

955

free_cmdq(&cmdqs->cmdq[cmdq_type]);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.h

167

struct hinic_cmdq cmdq[HINIC_MAX_CMDQ_TYPES];

drivers/net/ethernet/huawei/hinic/hinic_hw_io.c

533

enum hinic_cmdq_type cmdq, type;

drivers/net/ethernet/huawei/hinic/hinic_hw_io.c

565

for (cmdq = HINIC_CMDQ_SYNC; cmdq < HINIC_MAX_CMDQ_TYPES; cmdq++) {

drivers/net/ethernet/huawei/hinic/hinic_hw_io.c

573

func_to_io->cmdq_db_area[cmdq] = db_area;

drivers/net/ethernet/huawei/hinic/hinic_hw_io.c

600

for (type = HINIC_CMDQ_SYNC; type < cmdq; type++)

drivers/net/ethernet/huawei/hinic/hinic_hw_io.c

619

enum hinic_cmdq_type cmdq;

drivers/net/ethernet/huawei/hinic/hinic_hw_io.c

628

for (cmdq = HINIC_CMDQ_SYNC; cmdq < HINIC_MAX_CMDQ_TYPES; cmdq++)

drivers/net/ethernet/huawei/hinic/hinic_hw_io.c

629

return_db_area(func_to_io, func_to_io->cmdq_db_area[cmdq]);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

171

static void clear_wqe_complete_bit(struct hinic3_cmdq *cmdq,

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

187

cmdq->cmd_infos[ci].cmd_type = HINIC3_CMD_TYPE_NONE;

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

189

hinic3_wq_put_wqebbs(&cmdq->wq, CMDQ_WQE_NUM_WQEBBS);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

192

static void cmdq_update_cmd_status(struct hinic3_cmdq *cmdq, u16 prod_idx,

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

200

cmd_info = &cmdq->cmd_infos[prod_idx];

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

210

static void cmdq_sync_cmd_handler(struct hinic3_cmdq *cmdq,

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

213

spin_lock(&cmdq->cmdq_lock);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

214

cmdq_update_cmd_status(cmdq, ci, wqe);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

215

if (cmdq->cmd_infos[ci].cmpt_code) {

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

216

*cmdq->cmd_infos[ci].cmpt_code = CMDQ_DIRECT_SYNC_CMPT_CODE;

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

217

cmdq->cmd_infos[ci].cmpt_code = NULL;

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

222

if (cmdq->cmd_infos[ci].done) {

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

223

complete(cmdq->cmd_infos[ci].done);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

224

cmdq->cmd_infos[ci].done = NULL;

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

226

spin_unlock(&cmdq->cmdq_lock);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

228

cmdq_clear_cmd_buf(&cmdq->cmd_infos[ci], cmdq->hwdev);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

229

clear_wqe_complete_bit(cmdq, wqe, ci);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

238

struct hinic3_cmdq *cmdq;

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

243

if (unlikely(cmdq_type >= ARRAY_SIZE(cmdqs->cmdq)))

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

246

cmdq = &cmdqs->cmdq[cmdq_type];

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

247

while ((wqe = cmdq_read_wqe(&cmdq->wq, &ci)) != NULL) {

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

248

cmd_info = &cmdq->cmd_infos[ci];

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

258

clear_wqe_complete_bit(cmdq, wqe, ci);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

276

clear_wqe_complete_bit(cmdq, wqe, ci);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

278

cmdq_sync_cmd_handler(cmdq, wqe, ci);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

325

static void cmdq_set_db(struct hinic3_cmdq *cmdq,

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

328

u8 __iomem *db_base = cmdq->hwdev->cmdqs->cmdqs_db_base;

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

417

static int hinic3_cmdq_sync_timeout_check(struct hinic3_cmdq *cmdq,

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

428

dev_dbg(cmdq->hwdev->dev, "Cmdq sync command check busy bit not set\n");

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

431

cmdq_update_cmd_status(cmdq, pi, wqe);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

449

static int wait_cmdq_sync_cmd_completion(struct hinic3_cmdq *cmdq,

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

462

spin_lock_bh(&cmdq->cmdq_lock);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

467

dev_dbg(cmdq->hwdev->dev, "Cmdq direct sync command has been completed\n");

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

468

spin_unlock_bh(&cmdq->cmdq_lock);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

473

err = hinic3_cmdq_sync_timeout_check(cmdq, curr_wqe,

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

481

dev_err(cmdq->hwdev->dev,

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

486

spin_unlock_bh(&cmdq->cmdq_lock);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

491

static int cmdq_sync_cmd_direct_resp(struct hinic3_cmdq *cmdq, u8 mod, u8 cmd,

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

498

struct hinic3_wq *wq = &cmdq->wq;

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

506

spin_lock_bh(&cmdq->cmdq_lock);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

509

spin_unlock_bh(&cmdq->cmdq_lock);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

513

wrapped = cmdq->wrapped;

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

516

cmdq->wrapped ^= 1;

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

520

cmd_info = &cmdq->cmd_infos[curr_prod_idx];

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

536

cmdq_set_db(cmdq, HINIC3_CMDQ_SYNC, next_prod_idx);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

537

spin_unlock_bh(&cmdq->cmdq_lock);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

539

err = wait_cmdq_sync_cmd_completion(cmdq, cmd_info, &saved_cmd_info,

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

543

dev_err(cmdq->hwdev->dev,

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

550

dev_dbg(cmdq->hwdev->dev,

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

573

err = cmdq_sync_cmd_direct_resp(&cmdqs->cmdq[HINIC3_CMDQ_SYNC],

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

587

wq = &cmdqs->cmdq[cmdq_id].wq;

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

606

static int init_cmdq(struct hinic3_cmdq *cmdq, struct hinic3_hwdev *hwdev,

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

611

cmdq->cmdq_type = q_type;

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

612

cmdq->wrapped = 1;

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

613

cmdq->hwdev = hwdev;

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

615

spin_lock_init(&cmdq->cmdq_lock);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

617

cmdq->cmd_infos = kzalloc_objs(*cmdq->cmd_infos, cmdq->wq.q_depth);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

618

if (!cmdq->cmd_infos) {

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

675

err = hinic3_wq_create(hwdev, &cmdqs->cmdq[cmdq_type].wq,

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

686

if (!hinic3_wq_is_0_level_cla(&cmdqs->cmdq[HINIC3_CMDQ_SYNC].wq)) {

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

687

if (cmdqs->cmdq[HINIC3_CMDQ_SYNC].wq.qpages.num_pages >

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

707

cmdqs->cmdq[cmdq_type].wq.wq_block_vaddr,

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

708

cmdqs->cmdq[cmdq_type].wq.qpages.num_pages *

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

717

hinic3_wq_destroy(hwdev, &cmdqs->cmdq[cmdq_type].wq);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

733

hinic3_wq_destroy(hwdev, &cmdqs->cmdq[cmdq_type].wq);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

779

static void hinic3_cmdq_flush_cmd(struct hinic3_cmdq *cmdq)

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

784

spin_lock_bh(&cmdq->cmdq_lock);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

785

while (cmdq_read_wqe(&cmdq->wq, &ci)) {

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

786

hinic3_wq_put_wqebbs(&cmdq->wq, CMDQ_WQE_NUM_WQEBBS);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

787

cmd_info = &cmdq->cmd_infos[ci];

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

791

spin_unlock_bh(&cmdq->cmdq_lock);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

796

struct hinic3_cmdq *cmdq;

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

800

cmdq = &hwdev->cmdqs->cmdq[HINIC3_CMDQ_SYNC];

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

801

spin_lock_bh(&cmdq->cmdq_lock);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

802

wq = &cmdq->wq;

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

806

cmdq_flush_sync_cmd(cmdq->cmd_infos + wqe_idx);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

808

spin_unlock_bh(&cmdq->cmdq_lock);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

811

static void hinic3_cmdq_reset_all_cmd_buf(struct hinic3_cmdq *cmdq)

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

815

for (i = 0; i < cmdq->wq.q_depth; i++)

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

816

cmdq_clear_cmd_buf(&cmdq->cmd_infos[i], cmdq->hwdev);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

825

hinic3_cmdq_flush_cmd(&cmdqs->cmdq[cmdq_type]);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

826

hinic3_cmdq_reset_all_cmd_buf(&cmdqs->cmdq[cmdq_type]);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

827

cmdqs->cmdq[cmdq_type].wrapped = 1;

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

828

hinic3_wq_reset(&cmdqs->cmdq[cmdq_type].wq);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

858

err = init_cmdq(&cmdqs->cmdq[cmdq_type], hwdev, cmdq_type);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

876

kfree(cmdqs->cmdq[cmdq_type].cmd_infos);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

897

hinic3_cmdq_flush_cmd(&cmdqs->cmdq[cmdq_type]);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

898

hinic3_cmdq_reset_all_cmd_buf(&cmdqs->cmdq[cmdq_type]);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

899

kfree(cmdqs->cmdq[cmdq_type].cmd_infos);

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

908

bool hinic3_cmdq_idle(struct hinic3_cmdq *cmdq)

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.c

910

return hinic3_wq_get_used(&cmdq->wq) == 0;

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.h

124

struct hinic3_cmdq cmdq[HINIC3_MAX_CMDQ_TYPES];

drivers/net/ethernet/huawei/hinic3/hinic3_cmdq.h

154

bool hinic3_cmdq_idle(struct hinic3_cmdq *cmdq);

drivers/net/ethernet/huawei/hinic3/hinic3_hw_comm.c

305

if (!hinic3_cmdq_idle(&cmdqs->cmdq[cmdq_type]))

drivers/net/ethernet/huawei/hinic3/hinic3_hw_comm.c

333

if (!hinic3_cmdq_idle(&cmdqs->cmdq[cmdq_type]))

drivers/net/ethernet/marvell/prestera/prestera_pci.c

480

struct prestera_fw_cmdq *cmdq = &fw->cmd_queue[qid];

drivers/net/ethernet/marvell/prestera/prestera_pci.c

482

cmdq->len = prestera_fw_read(fw, PRESTERA_CMDQ_LEN_REG(qid));

drivers/net/ethernet/marvell/prestera/prestera_pci.c

483

cmdq->addr = fw->cmd_mbox + offs;

drivers/net/ethernet/marvell/prestera/prestera_pci.c

484

mutex_init(&cmdq->cmd_mtx);

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/trans.c

3537

struct iwl_txq *cmdq = trans_pcie->txqs.txq[trans->conf.cmd_queue];

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/trans.c

3553

if (dump_mask & BIT(IWL_FW_ERROR_DUMP_TXCMD) && cmdq)

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/trans.c

3555

cmdq->n_window * (sizeof(*txcmd) +

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/trans.c

3606

if (dump_mask & BIT(IWL_FW_ERROR_DUMP_TXCMD) && cmdq) {

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/trans.c

3611

spin_lock_bh(&cmdq->lock);

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/trans.c

3612

ptr = cmdq->write_ptr;

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/trans.c

3613

for (i = 0; i < cmdq->n_window; i++) {

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/trans.c

3614

u8 idx = iwl_txq_get_cmd_index(cmdq, ptr);

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/trans.c

3624

(u8 *)cmdq->tfds +

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/trans.c

3632

memcpy(txcmd->data, cmdq->entries[idx].cmd,

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/trans.c

3643

spin_unlock_bh(&cmdq->lock);

drivers/scsi/aacraid/aacraid.h

993

struct list_head cmdq; /* A queue of FIBs which need to be prcessed by the FS thread. This is */

drivers/scsi/aacraid/comminit.c

264

INIT_LIST_HEAD(&q->cmdq);

drivers/scsi/aacraid/commsup.c

2039

while (!list_empty(&(dev->queues->queue[HostNormCmdQueue].cmdq))) {

drivers/scsi/aacraid/commsup.c

2048

entry = dev->queues->queue[HostNormCmdQueue].cmdq.next;

drivers/scsi/aacraid/dpcsup.c

200

list_add_tail(&fib->fiblink, &q->cmdq);

drivers/scsi/aacraid/dpcsup.c

310

list_add_tail(&fib->fiblink, &q->cmdq);

drivers/scsi/bfa/bfi.h

592

struct bfi_msgq_s cmdq;

tools/testing/selftests/kvm/include/arm64/gic_v3_its.h

10

vm_paddr_t cmdq, size_t cmdq_size);

tools/testing/selftests/kvm/lib/arm64/gic_v3_its.c

87

vm_paddr_t cmdq, size_t cmdq_size)

tools/testing/selftests/kvm/lib/arm64/gic_v3_its.c

93

its_install_cmdq(cmdq, cmdq_size);