arch/powerpc/kvm/book3s_hv_nested.c

1026

struct rmap_nested *cursor;

arch/powerpc/kvm/book3s_hv_nested.c

1029

for_each_nest_rmap_safe(cursor, entry, &rmap) {

arch/powerpc/kvm/book3s_hv_nested.c

1031

kfree(cursor);

arch/powerpc/kvm/book3s_hv_nested.c

1064

struct rmap_nested *cursor;

arch/powerpc/kvm/book3s_hv_nested.c

1068

for_each_nest_rmap_safe(cursor, entry, &rmap)

arch/powerpc/kvm/book3s_hv_nested.c

1069

kfree(cursor);

arch/powerpc/kvm/book3s_hv_nested.c

926

struct rmap_nested *cursor;

arch/powerpc/kvm/book3s_hv_nested.c

937

for_each_nest_rmap_safe(cursor, entry, &rmap) {

arch/powerpc/kvm/book3s_hv_nested.c

988

struct rmap_nested *cursor;

arch/powerpc/kvm/book3s_hv_nested.c

997

for_each_nest_rmap_safe(cursor, entry, &rmap)

arch/x86/kernel/uprobes.c

467

u8 *cursor;

arch/x86/kernel/uprobes.c

480

cursor = auprobe->insn + insn_offset_rex_prefix(insn);

arch/x86/kernel/uprobes.c

482

*cursor &= 0xfe;

arch/x86/kernel/uprobes.c

499

cursor = auprobe->insn + insn_offset_vex_prefix(insn) + 1;

arch/x86/kernel/uprobes.c

500

*cursor |= 0x60;

arch/x86/kernel/uprobes.c

577

cursor = auprobe->insn + insn_offset_modrm(insn);

arch/x86/kernel/uprobes.c

583

*cursor = 0x80 | (reg << 3) | reg2;

block/blk-iocost.c

2555

if (iocg->cursor) {

block/blk-iocost.c

2556

seek_pages = abs(bio->bi_iter.bi_sector - iocg->cursor);

block/blk-iocost.c

2711

iocg->cursor = bio_end_sector(bio);

block/blk-iocost.c

2800

blk_rq_pos(rq) + blk_rq_sectors(rq) == iocg->cursor)

block/blk-iocost.c

2801

iocg->cursor = bio_end;

block/blk-iocost.c

492

sector_t cursor; /* to detect randio */

crypto/asymmetric_keys/asymmetric_type.c

629

struct asymmetric_key_parser *cursor;

crypto/asymmetric_keys/asymmetric_type.c

634

list_for_each_entry(cursor, &asymmetric_key_parsers, link) {

crypto/asymmetric_keys/asymmetric_type.c

635

if (strcmp(cursor->name, parser->name) == 0) {

crypto/asymmetric_keys/verify_pefile.c

111

if (ctx->n_sections > (ctx->header_size - cursor) / sizeof(*sec))

crypto/asymmetric_keys/verify_pefile.c

113

ctx->secs = pebuf + cursor;

crypto/asymmetric_keys/verify_pefile.c

32

size_t cursor, datalen = pelen;

crypto/asymmetric_keys/verify_pefile.c

45

cursor = sizeof(*mz);

crypto/asymmetric_keys/verify_pefile.c

47

chkaddr(cursor, mz->peaddr, sizeof(*pe));

crypto/asymmetric_keys/verify_pefile.c

51

cursor = mz->peaddr + sizeof(*pe);

crypto/asymmetric_keys/verify_pefile.c

53

chkaddr(0, cursor, sizeof(pe32->magic));

crypto/asymmetric_keys/verify_pefile.c

54

pe32 = pebuf + cursor;

crypto/asymmetric_keys/verify_pefile.c

55

pe64 = pebuf + cursor;

crypto/asymmetric_keys/verify_pefile.c

59

chkaddr(0, cursor, sizeof(*pe32));

crypto/asymmetric_keys/verify_pefile.c

63

cursor += sizeof(*pe32);

crypto/asymmetric_keys/verify_pefile.c

68

chkaddr(0, cursor, sizeof(*pe64));

crypto/asymmetric_keys/verify_pefile.c

72

cursor += sizeof(*pe64);

crypto/asymmetric_keys/verify_pefile.c

84

if (cursor >= ctx->header_size || ctx->header_size >= datalen)

crypto/asymmetric_keys/verify_pefile.c

87

if (ctx->n_data_dirents > (ctx->header_size - cursor) / sizeof(*dde))

crypto/asymmetric_keys/verify_pefile.c

90

ddir = pebuf + cursor;

crypto/asymmetric_keys/verify_pefile.c

91

cursor += sizeof(*dde) * ctx->n_data_dirents;

drivers/accessibility/speakup/kobjects.c

711

enum msg_index_t cursor;

drivers/accessibility/speakup/kobjects.c

715

for (cursor = first; cursor <= last; cursor++, index++) {

drivers/accessibility/speakup/kobjects.c

719

index, spk_msg_get(cursor));

drivers/ata/libata-eh.c

377

ering->cursor++;

drivers/ata/libata-eh.c

378

ering->cursor %= ATA_ERING_SIZE;

drivers/ata/libata-eh.c

380

ent = &ering->ring[ering->cursor];

drivers/ata/libata-eh.c

388

struct ata_ering_entry *ent = &ering->ring[ering->cursor];

drivers/ata/libata-eh.c

402

idx = ering->cursor;

drivers/ata/libata-eh.c

411

} while (idx != ering->cursor);

drivers/auxdisplay/charlcd.c

227

lcd->ops->cursor(lcd, CHARLCD_ON);

drivers/auxdisplay/charlcd.c

234

lcd->ops->cursor(lcd, CHARLCD_OFF);

drivers/auxdisplay/charlcd.h

90

int (*cursor)(struct charlcd *lcd, enum charlcd_onoff on);

drivers/auxdisplay/hd44780.c

136

.cursor = hd44780_common_cursor,

drivers/auxdisplay/hd44780.c

192

.cursor = hd44780_common_cursor,

drivers/auxdisplay/lcd2s.c

292

.cursor = lcd2s_cursor,

drivers/auxdisplay/panel.c

821

.cursor = hd44780_common_cursor,

drivers/dma-buf/dma-buf.c

321

struct dma_resv_iter cursor;

drivers/dma-buf/dma-buf.c

325

dma_resv_for_each_fence(&cursor, resv, dma_resv_usage_rw(write),

drivers/dma-buf/dma-fence-unwrap.c

19

__dma_fence_unwrap_array(struct dma_fence_unwrap *cursor)

drivers/dma-buf/dma-fence-unwrap.c

21

cursor->array = dma_fence_chain_contained(cursor->chain);

drivers/dma-buf/dma-fence-unwrap.c

22

cursor->index = 0;

drivers/dma-buf/dma-fence-unwrap.c

23

return dma_fence_array_first(cursor->array);

drivers/dma-buf/dma-fence-unwrap.c

35

struct dma_fence_unwrap *cursor)

drivers/dma-buf/dma-fence-unwrap.c

37

cursor->chain = dma_fence_get(head);

drivers/dma-buf/dma-fence-unwrap.c

38

return __dma_fence_unwrap_array(cursor);

drivers/dma-buf/dma-fence-unwrap.c

49

struct dma_fence *dma_fence_unwrap_next(struct dma_fence_unwrap *cursor)

drivers/dma-buf/dma-fence-unwrap.c

53

++cursor->index;

drivers/dma-buf/dma-fence-unwrap.c

54

tmp = dma_fence_array_next(cursor->array, cursor->index);

drivers/dma-buf/dma-fence-unwrap.c

58

cursor->chain = dma_fence_chain_walk(cursor->chain);

drivers/dma-buf/dma-fence-unwrap.c

59

return __dma_fence_unwrap_array(cursor);

drivers/dma-buf/dma-resv.c

367

static void dma_resv_iter_restart_unlocked(struct dma_resv_iter *cursor)

drivers/dma-buf/dma-resv.c

369

cursor->index = 0;

drivers/dma-buf/dma-resv.c

370

cursor->num_fences = 0;

drivers/dma-buf/dma-resv.c

371

cursor->fences = dma_resv_fences_list(cursor->obj);

drivers/dma-buf/dma-resv.c

372

if (cursor->fences)

drivers/dma-buf/dma-resv.c

373

cursor->num_fences = cursor->fences->num_fences;

drivers/dma-buf/dma-resv.c

374

cursor->is_restarted = true;

drivers/dma-buf/dma-resv.c

378

static void dma_resv_iter_walk_unlocked(struct dma_resv_iter *cursor)

drivers/dma-buf/dma-resv.c

380

if (!cursor->fences)

drivers/dma-buf/dma-resv.c

385

dma_fence_put(cursor->fence);

drivers/dma-buf/dma-resv.c

387

if (cursor->index >= cursor->num_fences) {

drivers/dma-buf/dma-resv.c

388

cursor->fence = NULL;

drivers/dma-buf/dma-resv.c

393

dma_resv_list_entry(cursor->fences, cursor->index++,

drivers/dma-buf/dma-resv.c

394

cursor->obj, &cursor->fence,

drivers/dma-buf/dma-resv.c

395

&cursor->fence_usage);

drivers/dma-buf/dma-resv.c

396

cursor->fence = dma_fence_get_rcu(cursor->fence);

drivers/dma-buf/dma-resv.c

397

if (!cursor->fence) {

drivers/dma-buf/dma-resv.c

398

dma_resv_iter_restart_unlocked(cursor);

drivers/dma-buf/dma-resv.c

402

if (!dma_fence_is_signaled(cursor->fence) &&

drivers/dma-buf/dma-resv.c

403

cursor->usage >= cursor->fence_usage)

drivers/dma-buf/dma-resv.c

420

struct dma_fence *dma_resv_iter_first_unlocked(struct dma_resv_iter *cursor)

drivers/dma-buf/dma-resv.c

424

dma_resv_iter_restart_unlocked(cursor);

drivers/dma-buf/dma-resv.c

425

dma_resv_iter_walk_unlocked(cursor);

drivers/dma-buf/dma-resv.c

426

} while (dma_resv_fences_list(cursor->obj) != cursor->fences);

drivers/dma-buf/dma-resv.c

429

return cursor->fence;

drivers/dma-buf/dma-resv.c

443

struct dma_fence *dma_resv_iter_next_unlocked(struct dma_resv_iter *cursor)

drivers/dma-buf/dma-resv.c

448

cursor->is_restarted = false;

drivers/dma-buf/dma-resv.c

449

restart = dma_resv_fences_list(cursor->obj) != cursor->fences;

drivers/dma-buf/dma-resv.c

452

dma_resv_iter_restart_unlocked(cursor);

drivers/dma-buf/dma-resv.c

453

dma_resv_iter_walk_unlocked(cursor);

drivers/dma-buf/dma-resv.c

455

} while (dma_resv_fences_list(cursor->obj) != cursor->fences);

drivers/dma-buf/dma-resv.c

458

return cursor->fence;

drivers/dma-buf/dma-resv.c

471

struct dma_fence *dma_resv_iter_first(struct dma_resv_iter *cursor)

drivers/dma-buf/dma-resv.c

475

dma_resv_assert_held(cursor->obj);

drivers/dma-buf/dma-resv.c

477

cursor->index = 0;

drivers/dma-buf/dma-resv.c

478

cursor->fences = dma_resv_fences_list(cursor->obj);

drivers/dma-buf/dma-resv.c

480

fence = dma_resv_iter_next(cursor);

drivers/dma-buf/dma-resv.c

481

cursor->is_restarted = true;

drivers/dma-buf/dma-resv.c

493

struct dma_fence *dma_resv_iter_next(struct dma_resv_iter *cursor)

drivers/dma-buf/dma-resv.c

497

dma_resv_assert_held(cursor->obj);

drivers/dma-buf/dma-resv.c

499

cursor->is_restarted = false;

drivers/dma-buf/dma-resv.c

502

if (!cursor->fences ||

drivers/dma-buf/dma-resv.c

503

cursor->index >= cursor->fences->num_fences)

drivers/dma-buf/dma-resv.c

506

dma_resv_list_entry(cursor->fences, cursor->index++,

drivers/dma-buf/dma-resv.c

507

cursor->obj, &fence, &cursor->fence_usage);

drivers/dma-buf/dma-resv.c

508

} while (cursor->fence_usage > cursor->usage);

drivers/dma-buf/dma-resv.c

523

struct dma_resv_iter cursor;

drivers/dma-buf/dma-resv.c

531

dma_resv_iter_begin(&cursor, src, DMA_RESV_USAGE_BOOKKEEP);

drivers/dma-buf/dma-resv.c

532

dma_resv_for_each_fence_unlocked(&cursor, f) {

drivers/dma-buf/dma-resv.c

534

if (dma_resv_iter_is_restarted(&cursor)) {

drivers/dma-buf/dma-resv.c

537

list = dma_resv_list_alloc(cursor.num_fences);

drivers/dma-buf/dma-resv.c

539

dma_resv_iter_end(&cursor);

drivers/dma-buf/dma-resv.c

547

dma_resv_iter_usage(&cursor));

drivers/dma-buf/dma-resv.c

549

dma_resv_iter_end(&cursor);

drivers/dma-buf/dma-resv.c

572

struct dma_resv_iter cursor;

drivers/dma-buf/dma-resv.c

578

dma_resv_iter_begin(&cursor, obj, usage);

drivers/dma-buf/dma-resv.c

579

dma_resv_for_each_fence_unlocked(&cursor, fence) {

drivers/dma-buf/dma-resv.c

581

if (dma_resv_iter_is_restarted(&cursor)) {

drivers/dma-buf/dma-resv.c

588

count = cursor.num_fences + 1;

drivers/dma-buf/dma-resv.c

598

dma_resv_iter_end(&cursor);

drivers/dma-buf/dma-resv.c

606

dma_resv_iter_end(&cursor);

drivers/dma-buf/dma-resv.c

681

struct dma_resv_iter cursor;

drivers/dma-buf/dma-resv.c

684

dma_resv_iter_begin(&cursor, obj, usage);

drivers/dma-buf/dma-resv.c

685

dma_resv_for_each_fence_unlocked(&cursor, fence) {

drivers/dma-buf/dma-resv.c

695

dma_resv_iter_end(&cursor);

drivers/dma-buf/dma-resv.c

713

struct dma_resv_iter cursor;

drivers/dma-buf/dma-resv.c

716

dma_resv_iter_begin(&cursor, obj, usage);

drivers/dma-buf/dma-resv.c

717

dma_resv_for_each_fence_unlocked(&cursor, fence) {

drivers/dma-buf/dma-resv.c

720

dma_resv_iter_end(&cursor);

drivers/dma-buf/dma-resv.c

739

struct dma_resv_iter cursor;

drivers/dma-buf/dma-resv.c

742

dma_resv_iter_begin(&cursor, obj, usage);

drivers/dma-buf/dma-resv.c

743

dma_resv_for_each_fence_unlocked(&cursor, fence) {

drivers/dma-buf/dma-resv.c

744

dma_resv_iter_end(&cursor);

drivers/dma-buf/dma-resv.c

747

dma_resv_iter_end(&cursor);

drivers/dma-buf/dma-resv.c

763

struct dma_resv_iter cursor;

drivers/dma-buf/dma-resv.c

766

dma_resv_for_each_fence(&cursor, obj, DMA_RESV_USAGE_READ, fence) {

drivers/dma-buf/dma-resv.c

768

usage[dma_resv_iter_usage(&cursor)]);

drivers/dma-buf/st-dma-resv.c

112

struct dma_resv_iter cursor;

drivers/dma-buf/st-dma-resv.c

138

dma_resv_for_each_fence(&cursor, &resv, usage, fence) {

drivers/dma-buf/st-dma-resv.c

148

if (dma_resv_iter_usage(&cursor) != usage) {

drivers/dma-buf/st-dma-resv.c

171

struct dma_resv_iter cursor;

drivers/dma-buf/st-dma-resv.c

199

dma_resv_iter_begin(&cursor, &resv, usage);

drivers/dma-buf/st-dma-resv.c

200

dma_resv_for_each_fence_unlocked(&cursor, fence) {

drivers/dma-buf/st-dma-resv.c

205

if (!dma_resv_iter_is_restarted(&cursor)) {

drivers/dma-buf/st-dma-resv.c

214

if (dma_resv_iter_usage(&cursor) != usage) {

drivers/dma-buf/st-dma-resv.c

224

cursor.fences = (void*)~0;

drivers/dma-buf/st-dma-resv.c

231

dma_resv_iter_end(&cursor);

drivers/dma/ppc4xx/adma.c

114

struct ppc440spe_rxor *cursor, int index,

drivers/dma/ppc4xx/adma.c

2060

static void ppc440spe_init_rxor_cursor(struct ppc440spe_rxor *cursor);

drivers/dma/ppc4xx/adma.c

3222

struct ppc440spe_rxor *cursor, int index, int src_cnt)

drivers/dma/ppc4xx/adma.c

3224

cursor->addr_count++;

drivers/dma/ppc4xx/adma.c

3226

ppc440spe_desc_set_xor_src_cnt(desc, cursor->addr_count);

drivers/dma/ppc4xx/adma.c

3227

} else if (cursor->addr_count == XOR_MAX_OPS) {

drivers/dma/ppc4xx/adma.c

3228

ppc440spe_desc_set_xor_src_cnt(desc, cursor->addr_count);

drivers/dma/ppc4xx/adma.c

3229

cursor->addr_count = 0;

drivers/dma/ppc4xx/adma.c

3230

cursor->desc_count++;

drivers/dma/ppc4xx/adma.c

3239

struct ppc440spe_rxor *cursor, int index,

drivers/dma/ppc4xx/adma.c

3246

for (i = 0; i < cursor->desc_count; i++) {

drivers/dma/ppc4xx/adma.c

3252

switch (cursor->state) {

drivers/dma/ppc4xx/adma.c

3254

if (addr == cursor->addrl + cursor->len) {

drivers/dma/ppc4xx/adma.c

3256

cursor->state = 1;

drivers/dma/ppc4xx/adma.c

3257

cursor->xor_count++;

drivers/dma/ppc4xx/adma.c

3260

cursor->addr_count,

drivers/dma/ppc4xx/adma.c

3263

desc, cursor, index, src_cnt);

drivers/dma/ppc4xx/adma.c

3265

} else if (cursor->addrl == addr + cursor->len) {

drivers/dma/ppc4xx/adma.c

3267

cursor->state = 1;

drivers/dma/ppc4xx/adma.c

3268

cursor->xor_count++;

drivers/dma/ppc4xx/adma.c

3269

set_bit(cursor->addr_count, &desc->reverse_flags[0]);

drivers/dma/ppc4xx/adma.c

3272

cursor->addr_count,

drivers/dma/ppc4xx/adma.c

3275

desc, cursor, index, src_cnt);

drivers/dma/ppc4xx/adma.c

3284

sign = test_bit(cursor->addr_count,

drivers/dma/ppc4xx/adma.c

3288

&& addr != cursor->addrl - 2*cursor->len)) {

drivers/dma/ppc4xx/adma.c

3289

cursor->state = 0;

drivers/dma/ppc4xx/adma.c

3290

cursor->xor_count = 1;

drivers/dma/ppc4xx/adma.c

3291

cursor->addrl = addr;

drivers/dma/ppc4xx/adma.c

3293

cursor->addr_count,

drivers/dma/ppc4xx/adma.c

3296

desc, cursor, index, src_cnt);

drivers/dma/ppc4xx/adma.c

3297

} else if (addr == cursor->addrl + 2*sign*cursor->len) {

drivers/dma/ppc4xx/adma.c

3298

cursor->state = 2;

drivers/dma/ppc4xx/adma.c

3299

cursor->xor_count = 0;

drivers/dma/ppc4xx/adma.c

3301

cursor->addr_count,

drivers/dma/ppc4xx/adma.c

3305

desc, cursor, index, src_cnt);

drivers/dma/ppc4xx/adma.c

3307

} else if (addr == cursor->addrl + 3*cursor->len) {

drivers/dma/ppc4xx/adma.c

3308

cursor->state = 2;

drivers/dma/ppc4xx/adma.c

3309

cursor->xor_count = 0;

drivers/dma/ppc4xx/adma.c

3311

cursor->addr_count,

drivers/dma/ppc4xx/adma.c

3315

desc, cursor, index, src_cnt);

drivers/dma/ppc4xx/adma.c

3317

} else if (addr == cursor->addrl + 4*cursor->len) {

drivers/dma/ppc4xx/adma.c

3318

cursor->state = 2;

drivers/dma/ppc4xx/adma.c

3319

cursor->xor_count = 0;

drivers/dma/ppc4xx/adma.c

3321

cursor->addr_count,

drivers/dma/ppc4xx/adma.c

3325

desc, cursor, index, src_cnt);

drivers/dma/ppc4xx/adma.c

3328

cursor->state = 0;

drivers/dma/ppc4xx/adma.c

3329

cursor->xor_count = 1;

drivers/dma/ppc4xx/adma.c

3330

cursor->addrl = addr;

drivers/dma/ppc4xx/adma.c

3332

cursor->addr_count,

drivers/dma/ppc4xx/adma.c

3335

desc, cursor, index, src_cnt);

drivers/dma/ppc4xx/adma.c

3339

cursor->state = 0;

drivers/dma/ppc4xx/adma.c

3340

cursor->addrl = addr;

drivers/dma/ppc4xx/adma.c

3341

cursor->xor_count++;

drivers/dma/ppc4xx/adma.c

3344

desc, cursor, index, src_cnt);

drivers/dma/ppc4xx/adma.c

3435

static void ppc440spe_init_rxor_cursor(struct ppc440spe_rxor *cursor)

drivers/dma/ppc4xx/adma.c

3437

memset(cursor, 0, sizeof(struct ppc440spe_rxor));

drivers/dma/ppc4xx/adma.c

3438

cursor->state = 2;

drivers/firewire/core-topology.c

102

.cursor = sid,

drivers/firewire/phy-packet-definitions.h

219

const u32 *cursor;

drivers/firewire/phy-packet-definitions.h

226

const u32 *self_id_sequence, *cursor;

drivers/firewire/phy-packet-definitions.h

231

if (enumerator->cursor == NULL || enumerator->quadlet_count == 0)

drivers/firewire/phy-packet-definitions.h

233

cursor = enumerator->cursor;

drivers/firewire/phy-packet-definitions.h

236

quadlet = *cursor;

drivers/firewire/phy-packet-definitions.h

242

++cursor;

drivers/firewire/phy-packet-definitions.h

244

quadlet = *cursor;

drivers/firewire/phy-packet-definitions.h

253

self_id_sequence = enumerator->cursor;

drivers/firewire/phy-packet-definitions.h

255

enumerator->cursor += count;

drivers/firewire/self-id-sequence-helper-test.c

23

enumerator.cursor = valid_sequences;

drivers/firewire/self-id-sequence-helper-test.c

59

enumerator.cursor = invalid_sequences;

drivers/firmware/google/memconsole-coreboot.c

24

u32 cursor;

drivers/firmware/google/memconsole-coreboot.c

43

u32 cursor = cbmem_console->cursor & CURSOR_MASK;

drivers/firmware/google/memconsole-coreboot.c

44

u32 flags = cbmem_console->cursor & ~CURSOR_MASK;

drivers/firmware/google/memconsole-coreboot.c

54

if (cursor > size) /* Shouldn't really happen, but... */

drivers/firmware/google/memconsole-coreboot.c

55

cursor = 0;

drivers/firmware/google/memconsole-coreboot.c

56

seg[0] = (struct seg){.phys = cursor, .len = size - cursor};

drivers/firmware/google/memconsole-coreboot.c

57

seg[1] = (struct seg){.phys = 0, .len = cursor};

drivers/firmware/google/memconsole-coreboot.c

59

seg[0] = (struct seg){.phys = 0, .len = min(cursor, size)};

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

2972

struct dma_resv_iter cursor;

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

2988

dma_resv_for_each_fence(&cursor, bo->tbo.base.resv,

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

402

struct dma_resv_iter cursor;

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

407

dma_resv_for_each_fence(&cursor, resv, DMA_RESV_USAGE_BOOKKEEP, fence) {

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

291

struct amdgpu_res_cursor cursor;

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

299

coredump->ibs[i].ib_size_dw * 4, &cursor);

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

300

while (cursor.remaining) {

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

301

amdgpu_device_mm_access(adev, cursor.start / 4,

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

302

&ib_content[off], cursor.size / 4,

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

304

off += cursor.size;

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

305

amdgpu_res_next(&cursor, cursor.size);

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

1848

struct amdgpu_res_cursor cursor;

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

1855

amdgpu_res_first(abo->tbo.resource, offset, 4, &cursor);

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

1857

tmp = cursor.start >> 31;

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

1858

WREG32_NO_KIQ(mmMM_INDEX, ((uint32_t) cursor.start) | 0x80000000);

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

246

struct dma_resv_iter cursor;

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

253

dma_resv_for_each_fence(&cursor, resv, DMA_RESV_USAGE_READ, f) {

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

279

struct dma_resv_iter cursor;

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

283

dma_resv_iter_begin(&cursor, resv, DMA_RESV_USAGE_BOOKKEEP);

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

284

dma_resv_for_each_fence_unlocked(&cursor, f) {

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

294

dma_resv_iter_end(&cursor);

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

1643

struct amdgpu_res_cursor cursor;

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

1653

amdgpu_res_first(bo->resource, offset, len, &cursor);

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

1654

while (cursor.remaining) {

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

1655

size_t count, size = cursor.size;

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

1656

loff_t pos = cursor.start;

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

1667

ret += cursor.size;

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

1668

buf += cursor.size;

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

1669

amdgpu_res_next(&cursor, cursor.size);

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

460

struct amdgpu_res_cursor cursor;

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

473

amdgpu_res_first(res, 0, res->size, &cursor);

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

474

while (cursor.remaining) {

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

475

if ((cursor.start + cursor.size) > adev->gmc.visible_vram_size)

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

477

amdgpu_res_next(&cursor, cursor.size);

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

685

struct amdgpu_res_cursor cursor;

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

688

&cursor);

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

691

return ((uint64_t)(adev->doorbell.base + cursor.start)) >> PAGE_SHIFT;

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

693

return ((uint64_t)(adev->rmmio_remap.bus_addr + cursor.start)) >> PAGE_SHIFT;

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

695

return (adev->gmc.aper_base + cursor.start) >> PAGE_SHIFT;

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

325

struct drm_plane *primary, *cursor = NULL;

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

332

ret = amdgpu_vkms_crtc_init(dev, crtc, primary, cursor);

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

61

struct drm_plane *primary, struct drm_plane *cursor)

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

67

ret = drm_crtc_init_with_planes(dev, crtc, primary, cursor,

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

1117

struct amdgpu_res_cursor cursor;

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

1170

(last - start + 1) * AMDGPU_GPU_PAGE_SIZE, &cursor);

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

1171

while (cursor.remaining) {

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

1174

num_entries = cursor.size >> AMDGPU_GPU_PAGE_SHIFT;

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

1179

uint64_t pfn = cursor.start >> PAGE_SHIFT;

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

1201

addr = cursor.start;

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

1204

addr = pages_addr[cursor.start >> PAGE_SHIFT];

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

1209

addr = vram_base + cursor.start;

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

1219

amdgpu_res_next(&cursor, num_entries * AMDGPU_GPU_PAGE_SIZE);

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

1522

struct dma_resv_iter cursor;

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

1525

dma_resv_for_each_fence(&cursor, resv, DMA_RESV_USAGE_BOOKKEEP, fence) {

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

160

struct amdgpu_vm_pt_cursor *cursor)

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

162

cursor->pfn = start;

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

163

cursor->parent = NULL;

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

164

cursor->entry = &vm->root;

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

165

cursor->level = adev->vm_manager.root_level;

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

179

struct amdgpu_vm_pt_cursor *cursor)

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

183

if ((cursor->level == AMDGPU_VM_PTB) || !cursor->entry ||

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

184

!cursor->entry->bo)

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

187

mask = amdgpu_vm_pt_entries_mask(adev, cursor->level);

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

188

shift = amdgpu_vm_pt_level_shift(adev, cursor->level);

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

190

++cursor->level;

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

191

idx = (cursor->pfn >> shift) & mask;

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

192

cursor->parent = cursor->entry;

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

193

cursor->entry = &to_amdgpu_bo_vm(cursor->entry->bo)->entries[idx];

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

208

struct amdgpu_vm_pt_cursor *cursor)

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

215

if (!cursor->parent)

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

219

shift = amdgpu_vm_pt_level_shift(adev, cursor->level - 1);

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

220

num_entries = amdgpu_vm_pt_num_entries(adev, cursor->level - 1);

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

221

parent = to_amdgpu_bo_vm(cursor->parent->bo);

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

223

if (cursor->entry == &parent->entries[num_entries - 1])

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

226

cursor->pfn += 1ULL << shift;

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

227

cursor->pfn &= ~((1ULL << shift) - 1);

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

228

++cursor->entry;

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

241

static bool amdgpu_vm_pt_ancestor(struct amdgpu_vm_pt_cursor *cursor)

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

243

if (!cursor->parent)

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

246

--cursor->level;

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

247

cursor->entry = cursor->parent;

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

248

cursor->parent = amdgpu_vm_pt_parent(cursor->parent);

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

261

struct amdgpu_vm_pt_cursor *cursor)

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

264

if (amdgpu_vm_pt_descendant(adev, cursor))

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

268

while (!amdgpu_vm_pt_sibling(adev, cursor)) {

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

270

if (!amdgpu_vm_pt_ancestor(cursor)) {

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

271

cursor->pfn = ~0ll;

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

290

struct amdgpu_vm_pt_cursor *cursor)

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

293

*cursor = *start;

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

295

amdgpu_vm_pt_start(adev, vm, 0, cursor);

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

297

while (amdgpu_vm_pt_descendant(adev, cursor))

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

325

struct amdgpu_vm_pt_cursor *cursor)

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

327

if (!cursor->entry)

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

330

if (!cursor->parent)

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

331

cursor->entry = NULL;

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

332

else if (amdgpu_vm_pt_sibling(adev, cursor))

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

333

while (amdgpu_vm_pt_descendant(adev, cursor))

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

336

amdgpu_vm_pt_ancestor(cursor);

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

342

#define for_each_amdgpu_vm_pt_dfs_safe(adev, vm, start, cursor, entry) \

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

343

for (amdgpu_vm_pt_first_dfs((adev), (vm), (start), &(cursor)), \

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

344

(entry) = (cursor).entry, amdgpu_vm_pt_next_dfs((adev), &(cursor));\

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

346

(entry) = (cursor).entry, amdgpu_vm_pt_next_dfs((adev), &(cursor)))

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

498

struct amdgpu_vm_pt_cursor *cursor,

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

501

struct amdgpu_vm_bo_base *entry = cursor->entry;

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

510

r = amdgpu_vm_pt_create(adev, vm, cursor->level, immediate, &pt,

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

520

pt_bo->parent = amdgpu_bo_ref(cursor->parent->bo);

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

586

struct amdgpu_vm_pt_cursor *cursor)

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

591

for_each_amdgpu_vm_pt_dfs_safe(params->adev, params->vm, cursor, seek, entry) {

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

597

list_move(&cursor->entry->vm_status, &params->tlb_flush_waitlist);

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

609

struct amdgpu_vm_pt_cursor cursor;

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

612

for_each_amdgpu_vm_pt_dfs_safe(adev, vm, NULL, cursor, entry) {

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

793

struct amdgpu_vm_pt_cursor cursor;

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

803

amdgpu_vm_pt_start(adev, params->vm, start, &cursor);

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

804

while (cursor.pfn < end) {

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

814

&cursor, params->immediate);

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

819

shift = amdgpu_vm_pt_level_shift(adev, cursor.level);

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

820

parent_shift = amdgpu_vm_pt_level_shift(adev, cursor.level - 1);

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

823

if (amdgpu_vm_pt_descendant(adev, &cursor))

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

828

if (cursor.level != AMDGPU_VM_PTB) {

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

829

if (!amdgpu_vm_pt_descendant(adev, &cursor))

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

838

if (amdgpu_vm_pt_descendant(adev, &cursor))

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

844

if (!amdgpu_vm_pt_ancestor(&cursor))

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

849

pt = cursor.entry->bo;

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

858

if (!amdgpu_vm_pt_ancestor(&cursor))

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

861

pt = cursor.entry->bo;

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

869

mask = amdgpu_vm_pt_entries_mask(adev, cursor.level);

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

870

pe_start = ((cursor.pfn >> shift) & mask) * 8;

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

872

if (cursor.level < AMDGPU_VM_PTB && params->unlocked)

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

880

entry_end += cursor.pfn & ~(entry_end - 1);

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

900

cursor.level, pe_start, dst,

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

916

if (amdgpu_vm_pt_descendant(adev, &cursor)) {

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

923

while (cursor.pfn < frag_start) {

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

925

if (cursor.entry->bo) {

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

927

amdgpu_vm_pt_add_list(params, &cursor);

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

929

amdgpu_vm_pt_next(adev, &cursor);

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

934

amdgpu_vm_pt_next(adev, &cursor);

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

950

struct amdgpu_vm_pt_cursor cursor;

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

953

for_each_amdgpu_vm_pt_dfs_safe(adev, vm, NULL, cursor, entry) {

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

225

struct dma_resv_iter cursor;

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

232

dma_resv_iter_begin(&cursor, bo->tbo.base.resv, DMA_RESV_USAGE_KERNEL);

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

233

dma_resv_for_each_fence_unlocked(&cursor, fence) {

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

238

dma_resv_iter_end(&cursor);

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

242

dma_resv_iter_end(&cursor);

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

683

struct amdgpu_res_cursor cursor;

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

693

amdgpu_res_first(res, offset, length, &cursor);

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

694

while (cursor.remaining) {

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

696

amdgpu_res_next(&cursor, min(cursor.size, AMDGPU_MAX_SG_SEGMENT_SIZE));

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

713

amdgpu_res_first(res, offset, length, &cursor);

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

715

phys_addr_t phys = cursor.start + adev->gmc.aper_base;

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

716

unsigned long size = min(cursor.size, AMDGPU_MAX_SG_SEGMENT_SIZE);

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

729

amdgpu_res_next(&cursor, size);

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

291

struct amdgpu_res_cursor cursor;

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

305

npages << PAGE_SHIFT, &cursor);

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

310

dst[i] = cursor.start + (j << PAGE_SHIFT);

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

335

amdgpu_res_next(&cursor, (j + 1) << PAGE_SHIFT);

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

338

amdgpu_res_next(&cursor, PAGE_SIZE);

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

346

if (j >= (cursor.size >> PAGE_SHIFT) - 1 && i < npages - 1) {

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

353

amdgpu_res_next(&cursor, (j + 1) * PAGE_SIZE);

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

13006

!(drm_plane_mask(crtc_state->crtc->cursor) & crtc_state->plane_mask)) {

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

13011

crtc_state->crtc->cursor);

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

13388

if ((drm_plane_mask(crtc->cursor) &

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

13393

new_cursor_state = drm_atomic_get_new_plane_state(state, crtc->cursor);

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/dml21_translation_helper.c

418

plane->cursor.cursor_bpp = 32;

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/dml21_translation_helper.c

420

plane->cursor.cursor_width = 256;

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/dml21_translation_helper.c

421

plane->cursor.num_cursors = 1;

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/dml21_translation_helper.c

525

plane->cursor.cursor_bpp = 32;

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/dml21_translation_helper.c

526

plane->cursor.cursor_width = 256;

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/dml21_translation_helper.c

527

plane->cursor.num_cursors = 1;

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/inc/dml_top_display_cfg_types.h

381

} cursor;

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_core/dml2_core_dcn4.c

299

phantom->cursor.num_cursors = 0;

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_core/dml2_core_dcn4.c

300

phantom->cursor.cursor_width = 0;

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_core/dml2_core_dcn4_calcs.c

10653

mode_lib->mp.cursor_bw[k] = display_cfg->plane_descriptors[k].cursor.num_cursors * display_cfg->plane_descriptors[k].cursor.cursor_width * display_cfg->plane_descriptors[k].cursor.cursor_bpp / 8.0 /

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_core/dml2_core_dcn4_calcs.c

11157

if (display_cfg->plane_descriptors[k].cursor.num_cursors > 0) {

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_core/dml2_core_dcn4_calcs.c

11159

display_cfg->plane_descriptors[k].cursor.cursor_width,

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_core/dml2_core_dcn4_calcs.c

11160

display_cfg->plane_descriptors[k].cursor.cursor_bpp,

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_core/dml2_core_dcn4_calcs.c

11170

display_cfg->plane_descriptors[k].cursor.cursor_width,

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_core/dml2_core_dcn4_calcs.c

11289

myPipe->NumberOfCursors = display_cfg->plane_descriptors[k].cursor.num_cursors;

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_core/dml2_core_dcn4_calcs.c

11343

CalculatePrefetchSchedule_params->num_cursors = (display_cfg->plane_descriptors[k].cursor.cursor_width > 0);

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_core/dml2_core_dcn4_calcs.c

12638

DML_ASSERT(display_cfg->plane_descriptors[l->plane_idx].cursor.num_cursors <= 1);

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_core/dml2_core_dcn4_calcs.c

7500

myPipe->NumberOfCursors = display_cfg->plane_descriptors[k].cursor.num_cursors;

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_core/dml2_core_dcn4_calcs.c

7555

CalculatePrefetchSchedule_params->num_cursors = (display_cfg->plane_descriptors[k].cursor.cursor_width > 0);

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_core/dml2_core_dcn4_calcs.c

8150

mode_lib->ms.cursor_bw[k] = display_cfg->plane_descriptors[k].cursor.num_cursors * display_cfg->plane_descriptors[k].cursor.cursor_width *

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_core/dml2_core_dcn4_calcs.c

8151

display_cfg->plane_descriptors[k].cursor.cursor_bpp / 8.0 / (display_cfg->stream_descriptors[display_cfg->plane_descriptors[k].stream_index].timing.h_total / ((double)display_cfg->stream_descriptors[display_cfg->plane_descriptors[k].stream_index].timing.pixel_clock_khz / 1000));

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_core/dml2_core_dcn4_calcs.c

8289

if (display_cfg->plane_descriptors[k].cursor.num_cursors > 0) {

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_core/dml2_core_dcn4_calcs.c

8290

if (display_cfg->plane_descriptors[k].cursor.cursor_bpp == 64 && mode_lib->ip.cursor_64bpp_support == false)

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_core/dml2_core_dcn4_calcs.c

9167

if (display_cfg->plane_descriptors[k].cursor.num_cursors > 0) {

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_core/dml2_core_dcn4_calcs.c

9169

display_cfg->plane_descriptors[k].cursor.cursor_width,

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_core/dml2_core_dcn4_calcs.c

9170

display_cfg->plane_descriptors[k].cursor.cursor_bpp,

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_core/dml2_core_dcn4_calcs.c

9180

display_cfg->plane_descriptors[k].cursor.cursor_width,

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_core/dml2_core_utils.c

605

phantom->cursor.num_cursors = 0;

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_core/dml2_core_utils.c

606

phantom->cursor.cursor_width = 0;

drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_crtc.c

611

struct atmel_hlcdc_plane *primary = NULL, *cursor = NULL;

drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_crtc.c

626

cursor = atmel_hlcdc_layer_to_plane(dc->layers[i]);

drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_crtc.c

634

&primary->base, &cursor->base, &atmel_hlcdc_crtc_funcs,

drivers/gpu/drm/drm_atomic_helper.c

3435

if (plane == crtc->cursor)

drivers/gpu/drm/drm_atomic_helper.c

3473

if (plane_state->crtc && plane_state->crtc->cursor == plane)

drivers/gpu/drm/drm_crtc.c

256

struct drm_plane *cursor,

drivers/gpu/drm/drm_crtc.c

264

WARN_ON(cursor && cursor->type != DRM_PLANE_TYPE_CURSOR);

drivers/gpu/drm/drm_crtc.c

306

crtc->cursor = cursor;

drivers/gpu/drm/drm_crtc.c

309

if (cursor && !cursor->possible_crtcs)

drivers/gpu/drm/drm_crtc.c

310

cursor->possible_crtcs = drm_crtc_mask(crtc);

drivers/gpu/drm/drm_crtc.c

361

struct drm_plane *cursor,

drivers/gpu/drm/drm_crtc.c

371

ret = __drm_crtc_init_with_planes(dev, crtc, primary, cursor, funcs,

drivers/gpu/drm/drm_crtc.c

391

struct drm_plane *cursor,

drivers/gpu/drm/drm_crtc.c

400

ret = __drm_crtc_init_with_planes(dev, crtc, primary, cursor, funcs,

drivers/gpu/drm/drm_crtc.c

442

struct drm_plane *cursor,

drivers/gpu/drm/drm_crtc.c

450

ret = __drmm_crtc_init_with_planes(dev, crtc, primary, cursor, funcs,

drivers/gpu/drm/drm_crtc.c

463

struct drm_plane *cursor,

drivers/gpu/drm/drm_crtc.c

482

ret = __drmm_crtc_init_with_planes(dev, crtc, primary, cursor, funcs,

drivers/gpu/drm/drm_lease.c

448

if (crtc->cursor) {

drivers/gpu/drm/drm_lease.c

449

ret = idr_alloc(leases, &drm_lease_idr_object, crtc->cursor->base.id, crtc->cursor->base.id + 1, GFP_KERNEL);

drivers/gpu/drm/drm_mode_config.c

700

WARN(crtc->cursor && crtc->funcs->cursor_set,

drivers/gpu/drm/drm_mode_config.c

703

WARN(crtc->cursor && crtc->funcs->cursor_set2,

drivers/gpu/drm/drm_mode_config.c

706

WARN(crtc->cursor && crtc->funcs->cursor_move,

drivers/gpu/drm/drm_mode_config.c

720

if (crtc->cursor) {

drivers/gpu/drm/drm_mode_config.c

721

WARN(!(crtc->cursor->possible_crtcs & drm_crtc_mask(crtc)),

drivers/gpu/drm/drm_mode_config.c

723

crtc->cursor->base.id, crtc->cursor->name,

drivers/gpu/drm/drm_mode_config.c

725

WARN(cursor_with_crtc & drm_plane_mask(crtc->cursor),

drivers/gpu/drm/drm_mode_config.c

727

crtc->cursor->base.id, crtc->cursor->name);

drivers/gpu/drm/drm_mode_config.c

728

cursor_with_crtc |= drm_plane_mask(crtc->cursor);

drivers/gpu/drm/drm_plane.c

1193

struct drm_plane *plane = crtc->cursor;

drivers/gpu/drm/drm_plane.c

1305

if (crtc->cursor) {

drivers/gpu/drm/drm_plane.c

1306

ret = drm_modeset_lock(&crtc->cursor->mutex, &ctx);

drivers/gpu/drm/drm_plane.c

1310

if (!drm_lease_held(file_priv, crtc->cursor->base.id)) {

drivers/gpu/drm/i915/display/i9xx_wm.c

1170

wm_state->sr.cursor = USHRT_MAX;

drivers/gpu/drm/i915/display/i9xx_wm.c

1177

wm_state->hpll.cursor = USHRT_MAX;

drivers/gpu/drm/i915/display/i9xx_wm.c

1223

wm_state->sr.cursor = raw->plane[PLANE_CURSOR];

drivers/gpu/drm/i915/display/i9xx_wm.c

1234

wm_state->hpll.cursor = raw->plane[PLANE_CURSOR];

drivers/gpu/drm/i915/display/i9xx_wm.c

1327

intermediate->sr.cursor = max(optimal->sr.cursor,

drivers/gpu/drm/i915/display/i9xx_wm.c

1328

active->sr.cursor);

drivers/gpu/drm/i915/display/i9xx_wm.c

1334

intermediate->hpll.cursor = max(optimal->hpll.cursor,

drivers/gpu/drm/i915/display/i9xx_wm.c

1335

active->hpll.cursor);

drivers/gpu/drm/i915/display/i9xx_wm.c

1342

intermediate->sr.cursor >

drivers/gpu/drm/i915/display/i9xx_wm.c

1348

intermediate->sr.cursor >

drivers/gpu/drm/i915/display/i9xx_wm.c

1649

wm_state->sr[level].cursor = USHRT_MAX;

drivers/gpu/drm/i915/display/i9xx_wm.c

1782

wm_state->sr[level].cursor =

drivers/gpu/drm/i915/display/i9xx_wm.c

1995

intermediate->sr[level].cursor = min(optimal->sr[level].cursor,

drivers/gpu/drm/i915/display/i9xx_wm.c

1996

active->sr[level].cursor);

drivers/gpu/drm/i915/display/i9xx_wm.c

2167

crtc->base.cursor->state->crtc_w, 4,

drivers/gpu/drm/i915/display/i9xx_wm.c

3682

wm->sr.cursor = _FW_WM(tmp, CURSOR_SR);

drivers/gpu/drm/i915/display/i9xx_wm.c

3683

wm->hpll.cursor = _FW_WM(tmp, HPLL_CURSOR);

drivers/gpu/drm/i915/display/i9xx_wm.c

3718

wm->sr.cursor = _FW_WM(tmp, CURSOR_SR);

drivers/gpu/drm/i915/display/i9xx_wm.c

3811

raw->plane[PLANE_CURSOR] = active->sr.cursor;

drivers/gpu/drm/i915/display/i9xx_wm.c

3821

raw->plane[PLANE_CURSOR] = active->hpll.cursor;

drivers/gpu/drm/i915/display/i9xx_wm.c

3847

wm->sr.plane, wm->sr.cursor, wm->sr.fbc);

drivers/gpu/drm/i915/display/i9xx_wm.c

3850

wm->hpll.plane, wm->hpll.cursor, wm->hpll.fbc);

drivers/gpu/drm/i915/display/i9xx_wm.c

3974

active->sr[level].cursor = wm->sr.cursor;

drivers/gpu/drm/i915/display/i9xx_wm.c

4005

wm->sr.plane, wm->sr.cursor, wm->level, wm->cxsr);

drivers/gpu/drm/i915/display/i9xx_wm.c

828

FW_WM(wm->sr.cursor, CURSOR_SR) |

drivers/gpu/drm/i915/display/i9xx_wm.c

829

FW_WM(wm->hpll.cursor, HPLL_CURSOR) |

drivers/gpu/drm/i915/display/i9xx_wm.c

874

FW_WM(wm->sr.cursor, CURSOR_SR));

drivers/gpu/drm/i915/display/intel_crtc.c

332

struct intel_plane *primary, *cursor;

drivers/gpu/drm/i915/display/intel_crtc.c

370

cursor = intel_cursor_plane_create(display, pipe);

drivers/gpu/drm/i915/display/intel_crtc.c

371

if (IS_ERR(cursor)) {

drivers/gpu/drm/i915/display/intel_crtc.c

372

ret = PTR_ERR(cursor);

drivers/gpu/drm/i915/display/intel_crtc.c

375

crtc->plane_ids_mask |= BIT(cursor->id);

drivers/gpu/drm/i915/display/intel_crtc.c

399

&primary->base, &cursor->base,

drivers/gpu/drm/i915/display/intel_cursor.c

1006

struct intel_plane *cursor;

drivers/gpu/drm/i915/display/intel_cursor.c

1010

cursor = intel_plane_alloc();

drivers/gpu/drm/i915/display/intel_cursor.c

1011

if (IS_ERR(cursor))

drivers/gpu/drm/i915/display/intel_cursor.c

1012

return cursor;

drivers/gpu/drm/i915/display/intel_cursor.c

1014

cursor->pipe = pipe;

drivers/gpu/drm/i915/display/intel_cursor.c

1015

cursor->i9xx_plane = (enum i9xx_plane_id) pipe;

drivers/gpu/drm/i915/display/intel_cursor.c

1016

cursor->id = PLANE_CURSOR;

drivers/gpu/drm/i915/display/intel_cursor.c

1017

cursor->frontbuffer_bit = INTEL_FRONTBUFFER(pipe, cursor->id);

drivers/gpu/drm/i915/display/intel_cursor.c

1020

cursor->max_stride = i845_cursor_max_stride;

drivers/gpu/drm/i915/display/intel_cursor.c

1021

cursor->min_alignment = i845_cursor_min_alignment;

drivers/gpu/drm/i915/display/intel_cursor.c

1022

cursor->update_arm = i845_cursor_update_arm;

drivers/gpu/drm/i915/display/intel_cursor.c

1023

cursor->disable_arm = i845_cursor_disable_arm;

drivers/gpu/drm/i915/display/intel_cursor.c

1024

cursor->get_hw_state = i845_cursor_get_hw_state;

drivers/gpu/drm/i915/display/intel_cursor.c

1025

cursor->check_plane = i845_check_cursor;

drivers/gpu/drm/i915/display/intel_cursor.c

1027

cursor->max_stride = i9xx_cursor_max_stride;

drivers/gpu/drm/i915/display/intel_cursor.c

1030

cursor->min_alignment = i830_cursor_min_alignment;

drivers/gpu/drm/i915/display/intel_cursor.c

1032

cursor->min_alignment = i85x_cursor_min_alignment;

drivers/gpu/drm/i915/display/intel_cursor.c

1034

cursor->min_alignment = i9xx_cursor_min_alignment;

drivers/gpu/drm/i915/display/intel_cursor.c

1037

cursor->vtd_guard = 2;

drivers/gpu/drm/i915/display/intel_cursor.c

1039

cursor->update_arm = i9xx_cursor_update_arm;

drivers/gpu/drm/i915/display/intel_cursor.c

1040

cursor->disable_arm = i9xx_cursor_disable_arm;

drivers/gpu/drm/i915/display/intel_cursor.c

1041

cursor->get_hw_state = i9xx_cursor_get_hw_state;

drivers/gpu/drm/i915/display/intel_cursor.c

1042

cursor->check_plane = i9xx_check_cursor;

drivers/gpu/drm/i915/display/intel_cursor.c

1045

cursor->surf_offset = intel_cursor_surf_offset;

drivers/gpu/drm/i915/display/intel_cursor.c

1048

cursor->capture_error = g4x_cursor_capture_error;

drivers/gpu/drm/i915/display/intel_cursor.c

1050

cursor->capture_error = i9xx_cursor_capture_error;

drivers/gpu/drm/i915/display/intel_cursor.c

1052

cursor->cursor.base = ~0;

drivers/gpu/drm/i915/display/intel_cursor.c

1053

cursor->cursor.cntl = ~0;

drivers/gpu/drm/i915/display/intel_cursor.c

1056

cursor->cursor.size = ~0;

drivers/gpu/drm/i915/display/intel_cursor.c

1060

ret = drm_universal_plane_init(display->drm, &cursor->base,

drivers/gpu/drm/i915/display/intel_cursor.c

1074

drm_plane_create_rotation_property(&cursor->base,

drivers/gpu/drm/i915/display/intel_cursor.c

1079

intel_cursor_add_size_hints_property(cursor);

drivers/gpu/drm/i915/display/intel_cursor.c

1082

drm_plane_create_zpos_immutable_property(&cursor->base, zpos);

drivers/gpu/drm/i915/display/intel_cursor.c

1085

drm_plane_enable_fb_damage_clips(&cursor->base);

drivers/gpu/drm/i915/display/intel_cursor.c

1087

intel_plane_helper_add(cursor);

drivers/gpu/drm/i915/display/intel_cursor.c

1089

return cursor;

drivers/gpu/drm/i915/display/intel_cursor.c

1092

intel_plane_free(cursor);

drivers/gpu/drm/i915/display/intel_cursor.c

298

if (plane->cursor.base != base ||

drivers/gpu/drm/i915/display/intel_cursor.c

299

plane->cursor.size != size ||

drivers/gpu/drm/i915/display/intel_cursor.c

300

plane->cursor.cntl != cntl) {

drivers/gpu/drm/i915/display/intel_cursor.c

307

plane->cursor.base = base;

drivers/gpu/drm/i915/display/intel_cursor.c

308

plane->cursor.size = size;

drivers/gpu/drm/i915/display/intel_cursor.c

309

plane->cursor.cntl = cntl;

drivers/gpu/drm/i915/display/intel_cursor.c

700

if (plane->cursor.base != base ||

drivers/gpu/drm/i915/display/intel_cursor.c

701

plane->cursor.size != fbc_ctl ||

drivers/gpu/drm/i915/display/intel_cursor.c

702

plane->cursor.cntl != cntl) {

drivers/gpu/drm/i915/display/intel_cursor.c

709

plane->cursor.base = base;

drivers/gpu/drm/i915/display/intel_cursor.c

710

plane->cursor.size = fbc_ctl;

drivers/gpu/drm/i915/display/intel_cursor.c

711

plane->cursor.cntl = cntl;

drivers/gpu/drm/i915/display/intel_display_trace.h

271

__field(u16, cursor)

drivers/gpu/drm/i915/display/intel_display_trace.h

290

__entry->cursor = wm->pipe[crtc->pipe].plane[PLANE_CURSOR];

drivers/gpu/drm/i915/display/intel_display_trace.h

292

__entry->sr_cursor = wm->sr.cursor;

drivers/gpu/drm/i915/display/intel_display_trace.h

295

__entry->hpll_cursor = wm->hpll.cursor;

drivers/gpu/drm/i915/display/intel_display_trace.h

305

__entry->primary, __entry->sprite, __entry->cursor,

drivers/gpu/drm/i915/display/intel_display_trace.h

325

__field(u32, cursor)

drivers/gpu/drm/i915/display/intel_display_trace.h

340

__entry->cursor = wm->pipe[crtc->pipe].plane[PLANE_CURSOR];

drivers/gpu/drm/i915/display/intel_display_trace.h

342

__entry->sr_cursor = wm->sr.cursor;

drivers/gpu/drm/i915/display/intel_display_trace.h

349

__entry->primary, __entry->sprite0, __entry->sprite1, __entry->cursor,

drivers/gpu/drm/i915/display/intel_display_types.h

1593

} cursor;

drivers/gpu/drm/i915/display/intel_wm_types.h

33

u16 cursor;

drivers/gpu/drm/i915/display/skl_watermark.c

633

struct intel_plane *plane = to_intel_plane(crtc_state->uapi.crtc->cursor);

drivers/gpu/drm/i915/gem/i915_gem_busy.c

117

struct dma_resv_iter cursor;

drivers/gpu/drm/i915/gem/i915_gem_busy.c

145

dma_resv_iter_begin(&cursor, obj->base.resv, DMA_RESV_USAGE_READ);

drivers/gpu/drm/i915/gem/i915_gem_busy.c

146

dma_resv_for_each_fence_unlocked(&cursor, fence) {

drivers/gpu/drm/i915/gem/i915_gem_busy.c

147

if (dma_resv_iter_is_restarted(&cursor))

drivers/gpu/drm/i915/gem/i915_gem_busy.c

150

if (dma_resv_iter_usage(&cursor) <= DMA_RESV_USAGE_WRITE)

drivers/gpu/drm/i915/gem/i915_gem_busy.c

157

dma_resv_iter_end(&cursor);

drivers/gpu/drm/i915/gem/i915_gem_wait.c

153

struct dma_resv_iter cursor;

drivers/gpu/drm/i915/gem/i915_gem_wait.c

156

dma_resv_iter_begin(&cursor, obj->base.resv,

drivers/gpu/drm/i915/gem/i915_gem_wait.c

158

dma_resv_for_each_fence_unlocked(&cursor, fence)

drivers/gpu/drm/i915/gem/i915_gem_wait.c

160

dma_resv_iter_end(&cursor);

drivers/gpu/drm/i915/gem/i915_gem_wait.c

37

struct dma_resv_iter cursor;

drivers/gpu/drm/i915/gem/i915_gem_wait.c

56

dma_resv_iter_begin(&cursor, resv,

drivers/gpu/drm/i915/gem/i915_gem_wait.c

58

dma_resv_for_each_fence_unlocked(&cursor, fence)

drivers/gpu/drm/i915/gem/i915_gem_wait.c

62

dma_resv_iter_end(&cursor);

drivers/gpu/drm/i915/gem/i915_gem_wait.c

70

struct dma_resv_iter cursor;

drivers/gpu/drm/i915/gem/i915_gem_wait.c

76

dma_resv_iter_begin(&cursor, resv,

drivers/gpu/drm/i915/gem/i915_gem_wait.c

78

dma_resv_for_each_fence_unlocked(&cursor, fence) {

drivers/gpu/drm/i915/gem/i915_gem_wait.c

86

dma_resv_iter_end(&cursor);

drivers/gpu/drm/i915/i915_request.c

1607

struct dma_resv_iter cursor;

drivers/gpu/drm/i915/i915_request.c

1611

dma_resv_for_each_fence(&cursor, obj->base.resv,

drivers/gpu/drm/i915/i915_sw_fence.c

585

struct dma_resv_iter cursor;

drivers/gpu/drm/i915/i915_sw_fence.c

592

dma_resv_iter_begin(&cursor, resv, dma_resv_usage_rw(write));

drivers/gpu/drm/i915/i915_sw_fence.c

593

dma_resv_for_each_fence_unlocked(&cursor, f) {

drivers/gpu/drm/i915/i915_sw_fence.c

603

dma_resv_iter_end(&cursor);

drivers/gpu/drm/loongson/lsdc_crtc.c

1009

ret = drm_crtc_init_with_planes(ddev, crtc, primary, cursor,

drivers/gpu/drm/loongson/lsdc_crtc.c

953

struct drm_plane *cursor,

drivers/gpu/drm/loongson/lsdc_crtc.c

970

ret = drm_crtc_init_with_planes(ddev, crtc, primary, cursor,

drivers/gpu/drm/loongson/lsdc_crtc.c

992

struct drm_plane *cursor,

drivers/gpu/drm/loongson/lsdc_drv.c

104

ret = funcs->cursor_plane_init(ddev, &dispipe->cursor.base, i);

drivers/gpu/drm/loongson/lsdc_drv.c

110

&dispipe->cursor.base,

drivers/gpu/drm/loongson/lsdc_drv.h

190

struct lsdc_cursor cursor;

drivers/gpu/drm/loongson/lsdc_drv.h

225

struct drm_plane *cursor,

drivers/gpu/drm/loongson/lsdc_drv.h

321

struct drm_plane *cursor,

drivers/gpu/drm/loongson/lsdc_drv.h

328

struct drm_plane *cursor,

drivers/gpu/drm/loongson/lsdc_plane.c

224

struct lsdc_cursor *cursor = to_lsdc_cursor(plane);

drivers/gpu/drm/loongson/lsdc_plane.c

225

const struct lsdc_cursor_plane_ops *ops = cursor->ops;

drivers/gpu/drm/loongson/lsdc_plane.c

259

ops->update_position(cursor, new_state->crtc_x, new_state->crtc_y);

drivers/gpu/drm/loongson/lsdc_plane.c

261

ops->update_cfg(cursor, cursor_size, CURSOR_FORMAT_ARGB8888);

drivers/gpu/drm/loongson/lsdc_plane.c

264

ops->update_bo_addr(cursor, lsdc_fb_base_addr(new_fb));

drivers/gpu/drm/loongson/lsdc_plane.c

303

struct lsdc_cursor *cursor = to_lsdc_cursor(plane);

drivers/gpu/drm/loongson/lsdc_plane.c

308

const struct lsdc_cursor_plane_ops *ops = cursor->ops;

drivers/gpu/drm/loongson/lsdc_plane.c

314

ops->update_position(cursor, new_plane_state->crtc_x, new_plane_state->crtc_y);

drivers/gpu/drm/loongson/lsdc_plane.c

317

ops->update_bo_addr(cursor, addr);

drivers/gpu/drm/loongson/lsdc_plane.c

319

ops->update_cfg(cursor, CURSOR_SIZE_32X32, CURSOR_FORMAT_ARGB8888);

drivers/gpu/drm/loongson/lsdc_plane.c

325

struct lsdc_cursor *cursor = to_lsdc_cursor(plane);

drivers/gpu/drm/loongson/lsdc_plane.c

326

const struct lsdc_cursor_plane_ops *ops = cursor->ops;

drivers/gpu/drm/loongson/lsdc_plane.c

328

ops->update_cfg(cursor, CURSOR_SIZE_32X32, CURSOR_FORMAT_DISABLE);

drivers/gpu/drm/loongson/lsdc_plane.c

384

struct lsdc_cursor *cursor = to_lsdc_cursor(plane);

drivers/gpu/drm/loongson/lsdc_plane.c

389

const struct lsdc_cursor_plane_ops *ops = cursor->ops;

drivers/gpu/drm/loongson/lsdc_plane.c

395

ops->update_position(cursor, new_plane_state->crtc_x, new_plane_state->crtc_y);

drivers/gpu/drm/loongson/lsdc_plane.c

400

ops->update_bo_addr(cursor, addr);

drivers/gpu/drm/loongson/lsdc_plane.c

415

ops->update_cfg(cursor, cursor_size, CURSOR_FORMAT_ARGB8888);

drivers/gpu/drm/loongson/lsdc_plane.c

421

struct lsdc_cursor *cursor = to_lsdc_cursor(plane);

drivers/gpu/drm/loongson/lsdc_plane.c

422

const struct lsdc_cursor_plane_ops *hw_ops = cursor->ops;

drivers/gpu/drm/loongson/lsdc_plane.c

424

hw_ops->update_cfg(cursor, CURSOR_SIZE_64X64, CURSOR_FORMAT_DISABLE);

drivers/gpu/drm/loongson/lsdc_plane.c

578

static void lsdc_cursor0_update_bo_addr(struct lsdc_cursor *cursor, u64 addr)

drivers/gpu/drm/loongson/lsdc_plane.c

580

struct lsdc_device *ldev = cursor->ldev;

drivers/gpu/drm/loongson/lsdc_plane.c

587

static void lsdc_cursor0_update_position(struct lsdc_cursor *cursor, int x, int y)

drivers/gpu/drm/loongson/lsdc_plane.c

589

struct lsdc_device *ldev = cursor->ldev;

drivers/gpu/drm/loongson/lsdc_plane.c

600

static void lsdc_cursor0_update_cfg(struct lsdc_cursor *cursor,

drivers/gpu/drm/loongson/lsdc_plane.c

604

struct lsdc_device *ldev = cursor->ldev;

drivers/gpu/drm/loongson/lsdc_plane.c

616

static void lsdc_cursor1_update_bo_addr(struct lsdc_cursor *cursor, u64 addr)

drivers/gpu/drm/loongson/lsdc_plane.c

618

struct lsdc_device *ldev = cursor->ldev;

drivers/gpu/drm/loongson/lsdc_plane.c

625

static void lsdc_cursor1_update_position(struct lsdc_cursor *cursor, int x, int y)

drivers/gpu/drm/loongson/lsdc_plane.c

627

struct lsdc_device *ldev = cursor->ldev;

drivers/gpu/drm/loongson/lsdc_plane.c

638

static void lsdc_cursor1_update_cfg(struct lsdc_cursor *cursor,

drivers/gpu/drm/loongson/lsdc_plane.c

642

struct lsdc_device *ldev = cursor->ldev;

drivers/gpu/drm/loongson/lsdc_plane.c

669

static void lsdc_cursor1_update_bo_addr_quirk(struct lsdc_cursor *cursor, u64 addr)

drivers/gpu/drm/loongson/lsdc_plane.c

671

struct lsdc_device *ldev = cursor->ldev;

drivers/gpu/drm/loongson/lsdc_plane.c

678

static void lsdc_cursor1_update_position_quirk(struct lsdc_cursor *cursor, int x, int y)

drivers/gpu/drm/loongson/lsdc_plane.c

680

struct lsdc_device *ldev = cursor->ldev;

drivers/gpu/drm/loongson/lsdc_plane.c

691

static void lsdc_cursor1_update_cfg_quirk(struct lsdc_cursor *cursor,

drivers/gpu/drm/loongson/lsdc_plane.c

695

struct lsdc_device *ldev = cursor->ldev;

drivers/gpu/drm/loongson/lsdc_plane.c

750

struct lsdc_cursor *cursor = to_lsdc_cursor(plane);

drivers/gpu/drm/loongson/lsdc_plane.c

763

cursor->ldev = to_lsdc(ddev);

drivers/gpu/drm/loongson/lsdc_plane.c

764

cursor->ops = &ls7a1000_cursor_hw_ops[index];

drivers/gpu/drm/loongson/lsdc_plane.c

775

struct lsdc_cursor *cursor = to_lsdc_cursor(plane);

drivers/gpu/drm/loongson/lsdc_plane.c

788

cursor->ldev = to_lsdc(ddev);

drivers/gpu/drm/loongson/lsdc_plane.c

789

cursor->ops = &ls7a2000_cursor_hw_ops[index];

drivers/gpu/drm/mediatek/mtk_crtc.c

910

struct drm_plane *cursor = NULL;

drivers/gpu/drm/mediatek/mtk_crtc.c

917

cursor = &mtk_crtc->planes[i];

drivers/gpu/drm/mediatek/mtk_crtc.c

920

ret = drm_crtc_init_with_planes(drm, &mtk_crtc->base, primary, cursor,

drivers/gpu/drm/mediatek/mtk_plane.c

90

if (plane != new_plane_state->crtc->cursor)

drivers/gpu/drm/msm/disp/dpu1/dpu_crtc.c

1879

struct drm_plane *cursor)

drivers/gpu/drm/msm/disp/dpu1/dpu_crtc.c

1888

plane, cursor,

drivers/gpu/drm/msm/disp/dpu1/dpu_crtc.h

254

struct drm_plane *cursor);

drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c

362

spin_lock_irqsave(&mdp4_crtc->cursor.lock, flags);

drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c

363

if (mdp4_crtc->cursor.stale) {

drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c

364

struct drm_gem_object *next_bo = mdp4_crtc->cursor.next_bo;

drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c

365

struct drm_gem_object *prev_bo = mdp4_crtc->cursor.scanout_bo;

drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c

366

uint64_t iova = mdp4_crtc->cursor.next_iova;

drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c

375

MDP4_DMA_CURSOR_SIZE_WIDTH(mdp4_crtc->cursor.width) |

drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c

376

MDP4_DMA_CURSOR_SIZE_HEIGHT(mdp4_crtc->cursor.height));

drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c

39

} cursor;

drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c

391

mdp4_crtc->cursor.scanout_bo = next_bo;

drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c

392

mdp4_crtc->cursor.stale = false;

drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c

396

MDP4_DMA_CURSOR_POS_X(mdp4_crtc->cursor.x) |

drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c

397

MDP4_DMA_CURSOR_POS_Y(mdp4_crtc->cursor.y));

drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c

399

spin_unlock_irqrestore(&mdp4_crtc->cursor.lock, flags);

drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c

436

spin_lock_irqsave(&mdp4_crtc->cursor.lock, flags);

drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c

437

old_bo = mdp4_crtc->cursor.next_bo;

drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c

438

mdp4_crtc->cursor.next_bo = cursor_bo;

drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c

439

mdp4_crtc->cursor.next_iova = iova;

drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c

440

mdp4_crtc->cursor.width = width;

drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c

441

mdp4_crtc->cursor.height = height;

drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c

442

mdp4_crtc->cursor.stale = true;

drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c

443

spin_unlock_irqrestore(&mdp4_crtc->cursor.lock, flags);

drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c

464

spin_lock_irqsave(&mdp4_crtc->cursor.lock, flags);

drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c

465

mdp4_crtc->cursor.x = x;

drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c

466

mdp4_crtc->cursor.y = y;

drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c

467

spin_unlock_irqrestore(&mdp4_crtc->cursor.lock, flags);

drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c

654

spin_lock_init(&mdp4_crtc->cursor.lock);

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

1005

spin_lock_irqsave(&mdp5_crtc->cursor.lock, flags);

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

1006

old_bo = mdp5_crtc->cursor.scanout_bo;

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

1008

mdp5_crtc->cursor.scanout_bo = cursor_bo;

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

1009

mdp5_crtc->cursor.width = width;

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

1010

mdp5_crtc->cursor.height = height;

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

1014

spin_unlock_irqrestore(&mdp5_crtc->cursor.lock, flags);

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

1062

mdp5_crtc->cursor.x = x = max(x, -(int)mdp5_crtc->cursor.width);

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

1063

mdp5_crtc->cursor.y = y = max(y, -(int)mdp5_crtc->cursor.height);

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

1069

spin_lock_irqsave(&mdp5_crtc->cursor.lock, flags);

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

1071

spin_unlock_irqrestore(&mdp5_crtc->cursor.lock, flags);

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

1341

spin_lock_init(&mdp5_crtc->cursor.lock);

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

553

if (mdp5_crtc->cursor.iova) {

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

556

spin_lock_irqsave(&mdp5_crtc->cursor.lock, flags);

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

558

spin_unlock_irqrestore(&mdp5_crtc->cursor.lock, flags);

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

65

} cursor;

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

867

if (mdp5_crtc->cursor.x >= 0)

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

868

*roi_w = min(mdp5_crtc->cursor.width, xres -

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

869

mdp5_crtc->cursor.x);

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

871

*roi_w = mdp5_crtc->cursor.width - abs(mdp5_crtc->cursor.x);

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

872

if (mdp5_crtc->cursor.y >= 0)

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

873

*roi_h = min(mdp5_crtc->cursor.height, yres -

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

874

mdp5_crtc->cursor.y);

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

876

*roi_h = mdp5_crtc->cursor.height - abs(mdp5_crtc->cursor.y);

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

891

assert_spin_locked(&mdp5_crtc->cursor.lock);

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

895

x = mdp5_crtc->cursor.x;

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

896

y = mdp5_crtc->cursor.y;

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

897

width = mdp5_crtc->cursor.width;

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

898

height = mdp5_crtc->cursor.height;

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

909

if (mdp5_crtc->cursor.x < 0) {

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

910

src_x = abs(mdp5_crtc->cursor.x);

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

915

if (mdp5_crtc->cursor.y < 0) {

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

916

src_y = abs(mdp5_crtc->cursor.y);

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

940

mdp5_crtc->cursor.iova);

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

987

mdp5_crtc->cursor.iova = 0;

drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c

997

&mdp5_crtc->cursor.iova);

drivers/gpu/drm/msm/disp/mdp5/mdp5_kms.c

385

struct drm_plane *cursor[MAX_BASES] = { NULL };

drivers/gpu/drm/msm/disp/mdp5/mdp5_kms.c

437

cursor[ci++] = plane;

drivers/gpu/drm/msm/disp/mdp5/mdp5_kms.c

443

crtc = mdp5_crtc_init(dev, primary[i], cursor[i], i);

drivers/gpu/drm/nouveau/dispnv04/crtc.c

1001

cursor = nouveau_gem_object(gem);

drivers/gpu/drm/nouveau/dispnv04/crtc.c

1003

ret = nouveau_bo_map(cursor);

drivers/gpu/drm/nouveau/dispnv04/crtc.c

1008

nv11_cursor_upload(dev, cursor, nv_crtc->cursor.nvbo);

drivers/gpu/drm/nouveau/dispnv04/crtc.c

1010

nv04_cursor_upload(dev, cursor, nv_crtc->cursor.nvbo);

drivers/gpu/drm/nouveau/dispnv04/crtc.c

1012

nouveau_bo_unmap(cursor);

drivers/gpu/drm/nouveau/dispnv04/crtc.c

1013

nv_crtc->cursor.offset = nv_crtc->cursor.nvbo->offset;

drivers/gpu/drm/nouveau/dispnv04/crtc.c

1014

nv_crtc->cursor.set_offset(nv_crtc, nv_crtc->cursor.offset);

drivers/gpu/drm/nouveau/dispnv04/crtc.c

1015

nv_crtc->cursor.show(nv_crtc, true);

drivers/gpu/drm/nouveau/dispnv04/crtc.c

1026

nv_crtc->cursor.set_pos(nv_crtc, x, y);

drivers/gpu/drm/nouveau/dispnv04/crtc.c

1322

ret = nouveau_bo_new_map(cli, NOUVEAU_GEM_DOMAIN_VRAM, 64 * 64 * 4, &nv_crtc->cursor.nvbo);

drivers/gpu/drm/nouveau/dispnv04/crtc.c

171

nv_crtc->cursor.set_offset(nv_crtc, nv_crtc->cursor.offset);

drivers/gpu/drm/nouveau/dispnv04/crtc.c

771

nouveau_bo_unpin_del(&nv_crtc->cursor.nvbo);

drivers/gpu/drm/nouveau/dispnv04/crtc.c

986

struct nouveau_bo *cursor = NULL;

drivers/gpu/drm/nouveau/dispnv04/crtc.c

991

nv_crtc->cursor.hide(nv_crtc, true);

drivers/gpu/drm/nouveau/dispnv04/cursor.c

65

crtc->cursor.set_offset = nv04_cursor_set_offset;

drivers/gpu/drm/nouveau/dispnv04/cursor.c

66

crtc->cursor.set_pos = nv04_cursor_set_pos;

drivers/gpu/drm/nouveau/dispnv04/cursor.c

67

crtc->cursor.hide = nv04_cursor_hide;

drivers/gpu/drm/nouveau/dispnv04/cursor.c

68

crtc->cursor.show = nv04_cursor_show;

drivers/gpu/drm/nouveau/dispnv04/disp.c

144

if (!nv_crtc->cursor.nvbo)

drivers/gpu/drm/nouveau/dispnv04/disp.c

147

ret = nouveau_bo_pin(nv_crtc->cursor.nvbo,

drivers/gpu/drm/nouveau/dispnv04/disp.c

149

if (!ret && nv_crtc->cursor.set_offset)

drivers/gpu/drm/nouveau/dispnv04/disp.c

150

ret = nouveau_bo_map(nv_crtc->cursor.nvbo);

drivers/gpu/drm/nouveau/dispnv04/disp.c

175

if (!nv_crtc->cursor.nvbo)

drivers/gpu/drm/nouveau/dispnv04/disp.c

178

if (nv_crtc->cursor.set_offset)

drivers/gpu/drm/nouveau/dispnv04/disp.c

179

nv_crtc->cursor.set_offset(nv_crtc,

drivers/gpu/drm/nouveau/dispnv04/disp.c

180

nv_crtc->cursor.nvbo->offset);

drivers/gpu/drm/nouveau/dispnv04/disp.c

181

nv_crtc->cursor.set_pos(nv_crtc, nv_crtc->cursor_saved_x,

drivers/gpu/drm/nouveau/dispnv04/disp.c

90

if (nv_crtc->cursor.nvbo) {

drivers/gpu/drm/nouveau/dispnv04/disp.c

91

if (nv_crtc->cursor.set_offset)

drivers/gpu/drm/nouveau/dispnv04/disp.c

92

nouveau_bo_unmap(nv_crtc->cursor.nvbo);

drivers/gpu/drm/nouveau/dispnv04/disp.c

93

nouveau_bo_unpin(nv_crtc->cursor.nvbo);

drivers/gpu/drm/nouveau/nouveau_crtc.h

63

} cursor;

drivers/gpu/drm/nouveau/nouveau_fence.c

356

struct dma_resv_iter cursor;

drivers/gpu/drm/nouveau/nouveau_fence.c

359

dma_resv_for_each_fence(&cursor, resv,

drivers/gpu/drm/nouveau/nouveau_fence.c

365

usage = dma_resv_iter_usage(&cursor);

drivers/gpu/drm/qxl/qxl_debugfs.c

61

struct dma_resv_iter cursor;

drivers/gpu/drm/qxl/qxl_debugfs.c

65

dma_resv_iter_begin(&cursor, bo->tbo.base.resv,

drivers/gpu/drm/qxl/qxl_debugfs.c

67

dma_resv_for_each_fence_unlocked(&cursor, fence) {

drivers/gpu/drm/qxl/qxl_debugfs.c

68

if (dma_resv_iter_is_restarted(&cursor))

drivers/gpu/drm/qxl/qxl_display.c

1006

struct drm_plane *primary, *cursor;

drivers/gpu/drm/qxl/qxl_display.c

1020

cursor = qxl_create_plane(qdev, 1 << crtc_id, DRM_PLANE_TYPE_CURSOR);

drivers/gpu/drm/qxl/qxl_display.c

1021

if (IS_ERR(cursor)) {

drivers/gpu/drm/qxl/qxl_display.c

1026

r = drm_crtc_init_with_planes(dev, &qxl_crtc->base, primary, cursor,

drivers/gpu/drm/qxl/qxl_display.c

1036

drm_plane_cleanup(cursor);

drivers/gpu/drm/qxl/qxl_display.c

1037

kfree(cursor);

drivers/gpu/drm/qxl/qxl_display.c

600

struct qxl_cursor cursor;

drivers/gpu/drm/qxl/qxl_display.c

620

cursor.header.unique = 0;

drivers/gpu/drm/qxl/qxl_display.c

621

cursor.header.type = SPICE_CURSOR_TYPE_ALPHA;

drivers/gpu/drm/qxl/qxl_display.c

622

cursor.header.width = 64;

drivers/gpu/drm/qxl/qxl_display.c

623

cursor.header.height = 64;

drivers/gpu/drm/qxl/qxl_display.c

624

cursor.header.hot_spot_x = hot_x;

drivers/gpu/drm/qxl/qxl_display.c

625

cursor.header.hot_spot_y = hot_y;

drivers/gpu/drm/qxl/qxl_display.c

626

cursor.data_size = size;

drivers/gpu/drm/qxl/qxl_display.c

627

cursor.chunk.next_chunk = 0;

drivers/gpu/drm/qxl/qxl_display.c

628

cursor.chunk.prev_chunk = 0;

drivers/gpu/drm/qxl/qxl_display.c

629

cursor.chunk.data_size = size;

drivers/gpu/drm/qxl/qxl_display.c

632

&cursor, sizeof(cursor));

drivers/gpu/drm/qxl/qxl_display.c

633

memcpy_toio(cursor_map.vaddr_iomem + sizeof(cursor),

drivers/gpu/drm/qxl/qxl_display.c

637

&cursor, sizeof(cursor));

drivers/gpu/drm/qxl/qxl_display.c

638

memcpy(cursor_map.vaddr + sizeof(cursor),

drivers/gpu/drm/radeon/radeon_sync.c

94

struct dma_resv_iter cursor;

drivers/gpu/drm/radeon/radeon_sync.c

99

dma_resv_for_each_fence(&cursor, resv, dma_resv_usage_rw(!shared), f) {

drivers/gpu/drm/rockchip/rockchip_drm_vop.c

1086

if (plane != new_plane_state->crtc->cursor)

drivers/gpu/drm/rockchip/rockchip_drm_vop.c

1860

struct drm_plane *primary = NULL, *cursor = NULL, *plane, *tmp;

drivers/gpu/drm/rockchip/rockchip_drm_vop.c

1897

cursor = plane;

drivers/gpu/drm/rockchip/rockchip_drm_vop.c

1900

ret = drm_crtc_init_with_planes(drm_dev, crtc, primary, cursor,

drivers/gpu/drm/scheduler/sched_main.c

751

struct dma_resv_iter cursor;

drivers/gpu/drm/scheduler/sched_main.c

757

dma_resv_for_each_fence(&cursor, resv, usage, fence) {

drivers/gpu/drm/sti/sti_compositor.c

113

cursor = sti_cursor_create(drm_dev, compo->dev,

drivers/gpu/drm/sti/sti_compositor.c

117

if (!cursor) {

drivers/gpu/drm/sti/sti_compositor.c

141

primary, cursor);

drivers/gpu/drm/sti/sti_compositor.c

143

cursor = NULL;

drivers/gpu/drm/sti/sti_compositor.c

68

struct drm_plane *cursor = NULL;

drivers/gpu/drm/sti/sti_crtc.c

350

struct drm_plane *primary, struct drm_plane *cursor)

drivers/gpu/drm/sti/sti_crtc.c

355

res = drm_crtc_init_with_planes(drm_dev, crtc, primary, cursor,

drivers/gpu/drm/sti/sti_crtc.h

17

struct drm_plane *primary, struct drm_plane *cursor);

drivers/gpu/drm/sti/sti_cursor.c

102

struct sti_cursor *cursor, u32 val)

drivers/gpu/drm/sti/sti_cursor.c

104

if (cursor->clut_paddr == val)

drivers/gpu/drm/sti/sti_cursor.c

105

seq_printf(s, "\tVirt @: %p", cursor->clut);

drivers/gpu/drm/sti/sti_cursor.c

111

struct sti_cursor *cursor = (struct sti_cursor *)node->info_ent->data;

drivers/gpu/drm/sti/sti_cursor.c

114

sti_plane_to_str(&cursor->plane), cursor->regs);

drivers/gpu/drm/sti/sti_cursor.c

118

cursor_dbg_vpo(s, readl(cursor->regs + CUR_VPO));

drivers/gpu/drm/sti/sti_cursor.c

120

cursor_dbg_pml(s, cursor, readl(cursor->regs + CUR_PML));

drivers/gpu/drm/sti/sti_cursor.c

123

cursor_dbg_size(s, readl(cursor->regs + CUR_SIZE));

drivers/gpu/drm/sti/sti_cursor.c

125

cursor_dbg_cml(s, cursor, readl(cursor->regs + CUR_CML));

drivers/gpu/drm/sti/sti_cursor.c

136

static void cursor_debugfs_init(struct sti_cursor *cursor,

drivers/gpu/drm/sti/sti_cursor.c

142

cursor_debugfs_files[i].data = cursor;

drivers/gpu/drm/sti/sti_cursor.c

149

static void sti_cursor_argb8888_to_clut8(struct sti_cursor *cursor, u32 *src)

drivers/gpu/drm/sti/sti_cursor.c

151

u8 *dst = cursor->pixmap.base;

drivers/gpu/drm/sti/sti_cursor.c

155

for (i = 0; i < cursor->height; i++) {

drivers/gpu/drm/sti/sti_cursor.c

156

for (j = 0; j < cursor->width; j++) {

drivers/gpu/drm/sti/sti_cursor.c

169

static void sti_cursor_init(struct sti_cursor *cursor)

drivers/gpu/drm/sti/sti_cursor.c

171

unsigned short *base = cursor->clut;

drivers/gpu/drm/sti/sti_cursor.c

191

struct sti_cursor *cursor = to_sti_cursor(plane);

drivers/gpu/drm/sti/sti_cursor.c

228

if (!cursor->pixmap.base ||

drivers/gpu/drm/sti/sti_cursor.c

229

(cursor->width != src_w) ||

drivers/gpu/drm/sti/sti_cursor.c

230

(cursor->height != src_h)) {

drivers/gpu/drm/sti/sti_cursor.c

231

cursor->width = src_w;

drivers/gpu/drm/sti/sti_cursor.c

232

cursor->height = src_h;

drivers/gpu/drm/sti/sti_cursor.c

234

if (cursor->pixmap.base)

drivers/gpu/drm/sti/sti_cursor.c

235

dma_free_wc(cursor->dev, cursor->pixmap.size,

drivers/gpu/drm/sti/sti_cursor.c

236

cursor->pixmap.base, cursor->pixmap.paddr);

drivers/gpu/drm/sti/sti_cursor.c

238

cursor->pixmap.size = cursor->width * cursor->height;

drivers/gpu/drm/sti/sti_cursor.c

240

cursor->pixmap.base = dma_alloc_wc(cursor->dev,

drivers/gpu/drm/sti/sti_cursor.c

241

cursor->pixmap.size,

drivers/gpu/drm/sti/sti_cursor.c

242

&cursor->pixmap.paddr,

drivers/gpu/drm/sti/sti_cursor.c

244

if (!cursor->pixmap.base) {

drivers/gpu/drm/sti/sti_cursor.c

269

struct sti_cursor *cursor = to_sti_cursor(plane);

drivers/gpu/drm/sti/sti_cursor.c

288

sti_cursor_argb8888_to_clut8(cursor, (u32 *)dma_obj->vaddr);

drivers/gpu/drm/sti/sti_cursor.c

294

writel(val, cursor->regs + CUR_AWS);

drivers/gpu/drm/sti/sti_cursor.c

298

writel(val, cursor->regs + CUR_AWE);

drivers/gpu/drm/sti/sti_cursor.c

301

writel(cursor->pixmap.paddr, cursor->regs + CUR_PML);

drivers/gpu/drm/sti/sti_cursor.c

302

writel(cursor->width, cursor->regs + CUR_PMP);

drivers/gpu/drm/sti/sti_cursor.c

303

writel(cursor->height << 16 | cursor->width, cursor->regs + CUR_SIZE);

drivers/gpu/drm/sti/sti_cursor.c

307

writel((y << 16) | x, cursor->regs + CUR_VPO);

drivers/gpu/drm/sti/sti_cursor.c

310

writel(cursor->clut_paddr, cursor->regs + CUR_CML);

drivers/gpu/drm/sti/sti_cursor.c

311

writel(CUR_CTL_CLUT_UPDATE, cursor->regs + CUR_CTL);

drivers/gpu/drm/sti/sti_cursor.c

348

struct sti_cursor *cursor = to_sti_cursor(plane);

drivers/gpu/drm/sti/sti_cursor.c

350

cursor_debugfs_init(cursor, drm_plane->dev->primary);

drivers/gpu/drm/sti/sti_cursor.c

370

struct sti_cursor *cursor;

drivers/gpu/drm/sti/sti_cursor.c

374

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

drivers/gpu/drm/sti/sti_cursor.c

375

if (!cursor) {

drivers/gpu/drm/sti/sti_cursor.c

382

cursor->clut = dma_alloc_wc(dev, size, &cursor->clut_paddr,

drivers/gpu/drm/sti/sti_cursor.c

385

if (!cursor->clut) {

drivers/gpu/drm/sti/sti_cursor.c

390

cursor->dev = dev;

drivers/gpu/drm/sti/sti_cursor.c

391

cursor->regs = baseaddr;

drivers/gpu/drm/sti/sti_cursor.c

392

cursor->plane.desc = desc;

drivers/gpu/drm/sti/sti_cursor.c

393

cursor->plane.status = STI_PLANE_DISABLED;

drivers/gpu/drm/sti/sti_cursor.c

395

sti_cursor_init(cursor);

drivers/gpu/drm/sti/sti_cursor.c

397

res = drm_universal_plane_init(drm_dev, &cursor->plane.drm_plane,

drivers/gpu/drm/sti/sti_cursor.c

408

drm_plane_helper_add(&cursor->plane.drm_plane,

drivers/gpu/drm/sti/sti_cursor.c

411

sti_plane_init_property(&cursor->plane, DRM_PLANE_TYPE_CURSOR);

drivers/gpu/drm/sti/sti_cursor.c

413

return &cursor->plane.drm_plane;

drivers/gpu/drm/sti/sti_cursor.c

416

dma_free_wc(dev, size, cursor->clut, cursor->clut_paddr);

drivers/gpu/drm/sti/sti_cursor.c

418

devm_kfree(dev, cursor);

drivers/gpu/drm/sti/sti_cursor.c

82

readl(cursor->regs + reg))

drivers/gpu/drm/sti/sti_cursor.c

95

struct sti_cursor *cursor, u32 val)

drivers/gpu/drm/sti/sti_cursor.c

97

if (cursor->pixmap.paddr == val)

drivers/gpu/drm/sti/sti_cursor.c

98

seq_printf(s, "\tVirt @: %p", cursor->pixmap.base);

drivers/gpu/drm/sun4i/sun4i_crtc.c

198

struct drm_plane *primary = NULL, *cursor = NULL;

drivers/gpu/drm/sun4i/sun4i_crtc.c

223

cursor = plane;

drivers/gpu/drm/sun4i/sun4i_crtc.c

232

cursor,

drivers/gpu/drm/tegra/dc.c

1356

bool cursor)

drivers/gpu/drm/tegra/dc.c

1382

if (!cursor)

drivers/gpu/drm/tegra/dc.c

2718

struct drm_plane *cursor = NULL;

drivers/gpu/drm/tegra/dc.c

2765

cursor = tegra_dc_cursor_plane_create(drm, dc);

drivers/gpu/drm/tegra/dc.c

2766

if (IS_ERR(cursor)) {

drivers/gpu/drm/tegra/dc.c

2767

err = PTR_ERR(cursor);

drivers/gpu/drm/tegra/dc.c

2772

cursor = tegra_dc_overlay_plane_create(drm, dc, 2, true);

drivers/gpu/drm/tegra/dc.c

2773

if (IS_ERR(cursor)) {

drivers/gpu/drm/tegra/dc.c

2774

err = PTR_ERR(cursor);

drivers/gpu/drm/tegra/dc.c

2779

err = drm_crtc_init_with_planes(drm, &dc->base, primary, cursor,

drivers/gpu/drm/tegra/dc.c

2822

if (!IS_ERR_OR_NULL(cursor))

drivers/gpu/drm/tegra/dc.c

2823

drm_plane_cleanup(cursor);

drivers/gpu/drm/tests/drm_kunit_helpers.c

247

struct drm_plane *cursor,

drivers/gpu/drm/tests/drm_kunit_helpers.c

265

cursor,

drivers/gpu/drm/ttm/tests/ttm_bo_validate_test.c

577

struct dma_resv_iter cursor;

drivers/gpu/drm/ttm/tests/ttm_bo_validate_test.c

580

dma_resv_iter_begin(&cursor, resv, DMA_RESV_USAGE_BOOKKEEP);

drivers/gpu/drm/ttm/tests/ttm_bo_validate_test.c

581

dma_resv_for_each_fence_unlocked(&cursor, fence) {

drivers/gpu/drm/ttm/tests/ttm_bo_validate_test.c

584

dma_resv_iter_end(&cursor);

drivers/gpu/drm/ttm/ttm_bo.c

222

struct dma_resv_iter cursor;

drivers/gpu/drm/ttm/ttm_bo.c

225

dma_resv_iter_begin(&cursor, resv, DMA_RESV_USAGE_BOOKKEEP);

drivers/gpu/drm/ttm/ttm_bo.c

226

dma_resv_for_each_fence_unlocked(&cursor, fence)

drivers/gpu/drm/ttm/ttm_bo.c

228

dma_resv_iter_end(&cursor);

drivers/gpu/drm/ttm/ttm_bo.c

448

struct ttm_resource_cursor cursor;

drivers/gpu/drm/ttm/ttm_bo.c

455

ttm_resource_cursor_init(&cursor, man);

drivers/gpu/drm/ttm/ttm_bo.c

456

res = ttm_resource_manager_first(&cursor);

drivers/gpu/drm/ttm/ttm_bo.c

457

ttm_resource_cursor_fini(&cursor);

drivers/gpu/drm/ttm/ttm_bo_util.c

903

struct ttm_bo_lru_cursor cursor;

drivers/gpu/drm/ttm/ttm_bo_util.c

908

ttm_bo_lru_for_each_reserved_guarded(&cursor, man, &walk->arg, bo) {

drivers/gpu/drm/ttm/ttm_resource.c

100

INIT_LIST_HEAD(&cursor->bulk_link);

drivers/gpu/drm/ttm/ttm_resource.c

101

INIT_LIST_HEAD(&cursor->hitch.link);

drivers/gpu/drm/ttm/ttm_resource.c

112

void ttm_resource_cursor_fini(struct ttm_resource_cursor *cursor)

drivers/gpu/drm/ttm/ttm_resource.c

114

lockdep_assert_held(&cursor->man->bdev->lru_lock);

drivers/gpu/drm/ttm/ttm_resource.c

115

list_del_init(&cursor->hitch.link);

drivers/gpu/drm/ttm/ttm_resource.c

116

ttm_resource_cursor_clear_bulk(cursor);

drivers/gpu/drm/ttm/ttm_resource.c

42

ttm_resource_cursor_clear_bulk(struct ttm_resource_cursor *cursor)

drivers/gpu/drm/ttm/ttm_resource.c

44

lockdep_assert_held(&cursor->man->bdev->lru_lock);

drivers/gpu/drm/ttm/ttm_resource.c

46

cursor->bulk = NULL;

drivers/gpu/drm/ttm/ttm_resource.c

47

list_del_init(&cursor->bulk_link);

drivers/gpu/drm/ttm/ttm_resource.c

52

struct ttm_resource_cursor *cursor)

drivers/gpu/drm/ttm/ttm_resource.c

56

lockdep_assert_held(&cursor->man->bdev->lru_lock);

drivers/gpu/drm/ttm/ttm_resource.c

58

if (WARN_ON_ONCE(bulk != cursor->bulk)) {

drivers/gpu/drm/ttm/ttm_resource.c

59

list_del_init(&cursor->bulk_link);

drivers/gpu/drm/ttm/ttm_resource.c

63

pos = &bulk->pos[cursor->mem_type][cursor->priority];

drivers/gpu/drm/ttm/ttm_resource.c

637

ttm_resource_cursor_check_bulk(struct ttm_resource_cursor *cursor,

drivers/gpu/drm/ttm/ttm_resource.c

643

lockdep_assert_held(&cursor->man->bdev->lru_lock);

drivers/gpu/drm/ttm/ttm_resource.c

647

if (cursor->bulk != bulk) {

drivers/gpu/drm/ttm/ttm_resource.c

649

list_move_tail(&cursor->bulk_link, &bulk->cursor_list);

drivers/gpu/drm/ttm/ttm_resource.c

65

list_move(&cursor->hitch.link, &pos->last->lru.link);

drivers/gpu/drm/ttm/ttm_resource.c

650

cursor->mem_type = next->mem_type;

drivers/gpu/drm/ttm/ttm_resource.c

652

list_del_init(&cursor->bulk_link);

drivers/gpu/drm/ttm/ttm_resource.c

654

cursor->bulk = bulk;

drivers/gpu/drm/ttm/ttm_resource.c

66

ttm_resource_cursor_clear_bulk(cursor);

drivers/gpu/drm/ttm/ttm_resource.c

669

ttm_resource_manager_first(struct ttm_resource_cursor *cursor)

drivers/gpu/drm/ttm/ttm_resource.c

671

struct ttm_resource_manager *man = cursor->man;

drivers/gpu/drm/ttm/ttm_resource.c

678

list_move(&cursor->hitch.link, &man->lru[cursor->priority]);

drivers/gpu/drm/ttm/ttm_resource.c

679

return ttm_resource_manager_next(cursor);

drivers/gpu/drm/ttm/ttm_resource.c

690

ttm_resource_manager_next(struct ttm_resource_cursor *cursor)

drivers/gpu/drm/ttm/ttm_resource.c

692

struct ttm_resource_manager *man = cursor->man;

drivers/gpu/drm/ttm/ttm_resource.c

698

lru = &cursor->hitch;

drivers/gpu/drm/ttm/ttm_resource.c

699

list_for_each_entry_continue(lru, &man->lru[cursor->priority], link) {

drivers/gpu/drm/ttm/ttm_resource.c

701

ttm_resource_cursor_check_bulk(cursor, lru);

drivers/gpu/drm/ttm/ttm_resource.c

702

list_move(&cursor->hitch.link, &lru->link);

drivers/gpu/drm/ttm/ttm_resource.c

707

if (++cursor->priority >= TTM_MAX_BO_PRIORITY)

drivers/gpu/drm/ttm/ttm_resource.c

710

list_move(&cursor->hitch.link, &man->lru[cursor->priority]);

drivers/gpu/drm/ttm/ttm_resource.c

711

ttm_resource_cursor_clear_bulk(cursor);

drivers/gpu/drm/ttm/ttm_resource.c

72

struct ttm_resource_cursor *cursor, *next;

drivers/gpu/drm/ttm/ttm_resource.c

74

list_for_each_entry_safe(cursor, next, &bulk->cursor_list, bulk_link)

drivers/gpu/drm/ttm/ttm_resource.c

75

ttm_resource_cursor_move_bulk_tail(bulk, cursor);

drivers/gpu/drm/ttm/ttm_resource.c

81

struct ttm_resource_cursor *cursor, *next;

drivers/gpu/drm/ttm/ttm_resource.c

83

list_for_each_entry_safe(cursor, next, &bulk->cursor_list, bulk_link)

drivers/gpu/drm/ttm/ttm_resource.c

84

ttm_resource_cursor_clear_bulk(cursor);

drivers/gpu/drm/ttm/ttm_resource.c

94

void ttm_resource_cursor_init(struct ttm_resource_cursor *cursor,

drivers/gpu/drm/ttm/ttm_resource.c

97

cursor->priority = 0;

drivers/gpu/drm/ttm/ttm_resource.c

98

cursor->man = man;

drivers/gpu/drm/ttm/ttm_resource.c

99

ttm_lru_item_init(&cursor->hitch, TTM_LRU_HITCH);

drivers/gpu/drm/vboxvideo/vbox_mode.c

554

struct drm_plane *cursor = NULL;

drivers/gpu/drm/vboxvideo/vbox_mode.c

576

cursor = vbox_create_plane(vbox, 1 << i, DRM_PLANE_TYPE_CURSOR);

drivers/gpu/drm/vboxvideo/vbox_mode.c

577

if (IS_ERR(cursor)) {

drivers/gpu/drm/vboxvideo/vbox_mode.c

578

ret = PTR_ERR(cursor);

drivers/gpu/drm/vboxvideo/vbox_mode.c

587

ret = drm_crtc_init_with_planes(dev, &vbox_crtc->base, primary, cursor,

drivers/gpu/drm/vboxvideo/vbox_mode.c

598

if (cursor) {

drivers/gpu/drm/vboxvideo/vbox_mode.c

599

drm_plane_cleanup(cursor);

drivers/gpu/drm/vboxvideo/vbox_mode.c

600

kfree(cursor);

drivers/gpu/drm/vc4/vc4_plane.c

2610

crtc->cursor = cursor_plane;

drivers/gpu/drm/verisilicon/vs_crtc.c

162

struct drm_plane *primary, *cursor;

drivers/gpu/drm/verisilicon/vs_crtc.c

179

cursor = vs_cursor_plane_init(drm_dev, dc);

drivers/gpu/drm/verisilicon/vs_crtc.c

180

if (IS_ERR(cursor)) {

drivers/gpu/drm/verisilicon/vs_crtc.c

182

return ERR_CAST(cursor);

drivers/gpu/drm/verisilicon/vs_crtc.c

187

cursor,

drivers/gpu/drm/virtio/virtgpu_display.c

281

struct drm_plane *primary, *cursor;

drivers/gpu/drm/virtio/virtgpu_display.c

294

cursor = virtio_gpu_plane_init(vgdev, DRM_PLANE_TYPE_CURSOR, index);

drivers/gpu/drm/virtio/virtgpu_display.c

295

if (IS_ERR(cursor))

drivers/gpu/drm/virtio/virtgpu_display.c

296

return PTR_ERR(cursor);

drivers/gpu/drm/virtio/virtgpu_display.c

297

ret = drm_crtc_init_with_planes(dev, crtc, primary, cursor,

drivers/gpu/drm/virtio/virtgpu_drv.h

183

struct virtio_gpu_update_cursor cursor;

drivers/gpu/drm/virtio/virtgpu_plane.c

484

output->cursor.hdr.type =

drivers/gpu/drm/virtio/virtgpu_plane.c

486

output->cursor.resource_id = cpu_to_le32(handle);

drivers/gpu/drm/virtio/virtgpu_plane.c

488

output->cursor.hot_x =

drivers/gpu/drm/virtio/virtgpu_plane.c

490

output->cursor.hot_y =

drivers/gpu/drm/virtio/virtgpu_plane.c

493

output->cursor.hot_x = cpu_to_le32(0);

drivers/gpu/drm/virtio/virtgpu_plane.c

494

output->cursor.hot_y = cpu_to_le32(0);

drivers/gpu/drm/virtio/virtgpu_plane.c

500

output->cursor.hdr.type =

drivers/gpu/drm/virtio/virtgpu_plane.c

503

output->cursor.pos.x = cpu_to_le32(plane->state->crtc_x);

drivers/gpu/drm/virtio/virtgpu_plane.c

504

output->cursor.pos.y = cpu_to_le32(plane->state->crtc_y);

drivers/gpu/drm/virtio/virtgpu_vq.c

1300

output->cursor.pos.scanout_id = cpu_to_le32(output->index);

drivers/gpu/drm/virtio/virtgpu_vq.c

1302

memcpy(cur_p, &output->cursor, sizeof(output->cursor));

drivers/gpu/drm/vkms/vkms_crtc.c

205

struct drm_plane *cursor)

drivers/gpu/drm/vkms/vkms_crtc.c

212

primary, cursor,

drivers/gpu/drm/vkms/vkms_drv.h

293

struct drm_plane *cursor);

drivers/gpu/drm/vkms/vkms_output.c

31

struct vkms_config_plane *primary, *cursor;

drivers/gpu/drm/vkms/vkms_output.c

34

cursor = vkms_config_crtc_cursor_plane(vkmsdev->config, crtc_cfg);

drivers/gpu/drm/vkms/vkms_output.c

37

cursor ? &cursor->plane->base : NULL);

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

119

header = vmw_bo_map_and_cache(vps->cursor.mob);

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

127

alpha_header->hotspotX = vps->cursor.legacy.hotspot_x + vps->base.hotspot_x;

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

128

alpha_header->hotspotY = vps->cursor.legacy.hotspot_y + vps->base.hotspot_y;

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

133

vmw_write(vmw, SVGA_REG_CURSOR_MOBID, vmw_bo_mobid(vps->cursor.mob));

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

136

vmw_bo_unmap(vps->cursor.mob);

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

174

struct vmw_bo *vbo = vps->cursor.mob;

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

193

if (!vps->cursor.mob)

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

201

vcp->cursor_mobs[i] = vps->cursor.mob;

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

202

vps->cursor.mob = NULL;

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

210

vps->cursor.mob->tbo.base.size) {

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

212

vcp->cursor_mobs[i] = vps->cursor.mob;

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

213

vps->cursor.mob = NULL;

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

219

vmw_cursor_mob_destroy(&vps->cursor.mob);

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

226

u32 size = vmw_cursor_mob_size(vps->cursor.update_type,

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

244

if (vps->cursor.mob) {

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

245

if (vps->cursor.mob->tbo.base.size >= size)

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

254

vps->cursor.mob = vcp->cursor_mobs[i];

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

261

&vps->cursor.mob);

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

267

ret = ttm_bo_reserve(&vps->cursor.mob->tbo, false, false, NULL);

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

27

SVGAFifoCmdDefineAlphaCursor cursor;

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

273

ttm_bo_unreserve(&vps->cursor.mob->tbo);

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

280

ttm_bo_unreserve(&vps->cursor.mob->tbo);

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

285

vmw_cursor_mob_destroy(&vps->cursor.mob);

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

432

u32 size = vmw_cursor_mob_size(vps->cursor.update_type,

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

434

struct vmw_bo *vbo = vps->cursor.mob;

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

575

if (old_vps->cursor.legacy.hotspot_x !=

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

576

new_vps->cursor.legacy.hotspot_x ||

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

577

old_vps->cursor.legacy.hotspot_y !=

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

578

new_vps->cursor.legacy.hotspot_y)

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

622

vps->cursor.update_type = vmw_cursor_update_type(vmw, vps);

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

623

switch (vps->cursor.update_type) {

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

626

if (!surface || vps->cursor.legacy.id == surface->snooper.id)

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

627

vps->cursor.update_type = VMW_CURSOR_UPDATE_NONE;

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

64

cmd->cursor.id = 0;

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

65

cmd->cursor.width = width;

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

66

cmd->cursor.height = height;

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

664

vps->cursor.update_type =

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

67

cmd->cursor.hotspotX = hotspotX;

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

68

cmd->cursor.hotspotY = hotspotY;

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

763

switch (vps->cursor.update_type) {

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

78

s32 hotspot_x = vps->cursor.legacy.hotspot_x + vps->base.hotspot_x;

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

79

s32 hotspot_y = vps->cursor.legacy.hotspot_y + vps->base.hotspot_y;

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

790

hotspot_x = vps->cursor.legacy.hotspot_x + new_state->hotspot_x;

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

791

hotspot_y = vps->cursor.legacy.hotspot_y + new_state->hotspot_y;

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

810

vps = vmw_plane_state_to_vps(du->cursor.base.state);

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

811

vps->cursor.legacy.hotspot_x = arg->xhot;

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

812

vps->cursor.legacy.hotspot_y = arg->yhot;

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

826

vps = vmw_plane_state_to_vps(du->cursor.base.state);

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

827

vps->cursor.legacy.hotspot_x = arg->xhot;

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

828

vps->cursor.legacy.hotspot_y = arg->yhot;

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

84

if (vps->cursor.legacy.id != surface->snooper.id) {

drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c

88

vps->cursor.legacy.id = surface->snooper.id;

drivers/gpu/drm/vmwgfx/vmwgfx_kms.c

277

vps->cursor.mob = NULL;

drivers/gpu/drm/vmwgfx/vmwgfx_kms.c

36

drm_plane_cleanup(&du->cursor.base);

drivers/gpu/drm/vmwgfx/vmwgfx_kms.h

257

struct vmw_cursor_plane_state cursor;

drivers/gpu/drm/vmwgfx/vmwgfx_kms.h

303

struct vmw_cursor_plane cursor;

drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c

416

struct vmw_cursor_plane *cursor;

drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c

429

cursor = &ldu->base.cursor;

drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c

461

ret = drm_universal_plane_init(dev, &cursor->base,

drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c

472

drm_plane_helper_add(&cursor->base, &vmw_ldu_cursor_plane_helper_funcs);

drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c

502

vmw_cmd_supported(dev_priv) ? &cursor->base : NULL,

drivers/gpu/drm/vmwgfx/vmwgfx_scrn.c

811

struct vmw_cursor_plane *cursor;

drivers/gpu/drm/vmwgfx/vmwgfx_scrn.c

824

cursor = &sou->base.cursor;

drivers/gpu/drm/vmwgfx/vmwgfx_scrn.c

851

ret = drm_universal_plane_init(dev, &cursor->base,

drivers/gpu/drm/vmwgfx/vmwgfx_scrn.c

862

drm_plane_helper_add(&cursor->base, &vmw_sou_cursor_plane_helper_funcs);

drivers/gpu/drm/vmwgfx/vmwgfx_scrn.c

891

&cursor->base,

drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c

1541

struct vmw_cursor_plane *cursor;

drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c

1554

cursor = &stdu->base.cursor;

drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c

1576

ret = drm_universal_plane_init(dev, &cursor->base,

drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c

1587

drm_plane_helper_add(&cursor->base, &vmw_stdu_cursor_plane_helper_funcs);

drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c

1588

drm_plane_enable_fb_damage_clips(&cursor->base);

drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c

1617

&cursor->base,

drivers/gpu/drm/xe/xe_bo.c

1644

struct xe_res_cursor cursor;

drivers/gpu/drm/xe/xe_bo.c

1651

xe_res_first(ttm_bo->resource, (u64)page_offset << PAGE_SHIFT, 0, &cursor);

drivers/gpu/drm/xe/xe_bo.c

1652

return (vram->io_start + cursor.start) >> PAGE_SHIFT;

drivers/gpu/drm/xe/xe_bo.c

1684

struct dma_resv_iter cursor;

drivers/gpu/drm/xe/xe_bo.c

1704

dma_resv_for_each_fence(&cursor, &ttm_bo->base._resv,

drivers/gpu/drm/xe/xe_bo.c

1770

struct xe_res_cursor cursor;

drivers/gpu/drm/xe/xe_bo.c

1792

xe_bo_size(bo) - (offset & PAGE_MASK), &cursor);

drivers/gpu/drm/xe/xe_bo.c

1799

cursor.start);

drivers/gpu/drm/xe/xe_bo.c

1809

xe_res_next(&cursor, PAGE_SIZE);

drivers/gpu/drm/xe/xe_bo.c

660

struct dma_resv_iter cursor;

drivers/gpu/drm/xe/xe_bo.c

670

dma_resv_iter_begin(&cursor, bo->ttm.base.resv,

drivers/gpu/drm/xe/xe_bo.c

672

dma_resv_for_each_fence_unlocked(&cursor, fence)

drivers/gpu/drm/xe/xe_bo.c

674

dma_resv_iter_end(&cursor);

drivers/gpu/drm/xe/xe_migrate.c

2463

struct xe_res_cursor cursor;

drivers/gpu/drm/xe/xe_migrate.c

2531

xe_res_first(bo->ttm.resource, offset, xe_bo_size(bo) - offset, &cursor);

drivers/gpu/drm/xe/xe_migrate.c

2536

cursor.start;

drivers/gpu/drm/xe/xe_migrate.c

2540

if (cursor.size > MAX_PREEMPTDISABLE_TRANSFER)

drivers/gpu/drm/xe/xe_migrate.c

2544

current_bytes = min_t(int, bytes_left, cursor.size);

drivers/gpu/drm/xe/xe_migrate.c

2577

xe_res_next(&cursor, current_bytes);

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c

357

struct xe_res_cursor cursor;

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c

370

xe_res_first(res, offset, length, &cursor);

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c

371

while (cursor.remaining) {

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c

374

xe_res_next(&cursor, min_t(u64, cursor.size, SZ_2G));

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c

391

xe_res_first(res, offset, length, &cursor);

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c

393

phys_addr_t phys = cursor.start + xe_vram_region_io_start(tile->mem.vram);

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c

394

size_t size = min_t(u64, cursor.size, SZ_2G);

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c

407

xe_res_next(&cursor, size);

drivers/gpu/drm/xe/xe_userptr.c

156

struct dma_resv_iter cursor;

drivers/gpu/drm/xe/xe_userptr.c

180

dma_resv_iter_begin(&cursor, xe_vm_resv(vm),

drivers/gpu/drm/xe/xe_userptr.c

182

dma_resv_for_each_fence_unlocked(&cursor, fence) {

drivers/gpu/drm/xe/xe_userptr.c

187

dma_resv_iter_end(&cursor);

drivers/hsi/clients/cmt_speech.c

1322

struct list_head *cursor, *next;

drivers/hsi/clients/cmt_speech.c

1325

list_for_each_safe(cursor, next, head) {

drivers/hsi/clients/cmt_speech.c

1326

entry = list_entry(cursor, struct char_queue, list);

drivers/md/dm-bufio.c

102

WARN_ON_ONCE(lru->cursor);

drivers/md/dm-bufio.c

117

if (lru->cursor) {

drivers/md/dm-bufio.c

118

list_add_tail(&le->list, lru->cursor);

drivers/md/dm-bufio.c

121

lru->cursor = &le->list;

drivers/md/dm-bufio.c

142

it->stop = lru->cursor ? to_le(lru->cursor->prev) : NULL;

drivers/md/dm-bufio.c

143

it->e = lru->cursor ? to_le(lru->cursor) : NULL;

drivers/md/dm-bufio.c

218

lru->cursor = NULL;

drivers/md/dm-bufio.c

220

if (lru->cursor == &le->list)

drivers/md/dm-bufio.c

221

lru->cursor = lru->cursor->next;

drivers/md/dm-bufio.c

275

lru->cursor = le->list.next;

drivers/md/dm-bufio.c

283

lru->cursor = le->list.next;

drivers/md/dm-bufio.c

85

struct list_head *cursor;

drivers/md/dm-bufio.c

95

lru->cursor = NULL;

drivers/md/dm-vdo/block-map.c

103

struct cursor cursors[];

drivers/md/dm-vdo/block-map.c

2512

static void finish_cursor(struct cursor *cursor)

drivers/md/dm-vdo/block-map.c

2514

struct cursors *cursors = cursor->parent;

drivers/md/dm-vdo/block-map.c

2517

return_vio_to_pool(vdo_forget(cursor->vio));

drivers/md/dm-vdo/block-map.c

2526

static void traverse(struct cursor *cursor);

drivers/md/dm-vdo/block-map.c

2544

struct cursor *cursor = completion->parent;

drivers/md/dm-vdo/block-map.c

2545

height_t height = cursor->height;

drivers/md/dm-vdo/block-map.c

2546

struct cursor_level *level = &cursor->levels[height];

drivers/md/dm-vdo/block-map.c

2548

&(cursor->tree->segments[0].levels[height][level->page_index]);

drivers/md/dm-vdo/block-map.c

2551

vdo_copy_valid_page(cursor->vio->vio.data,

drivers/md/dm-vdo/block-map.c

2552

cursor->parent->zone->block_map->nonce,

drivers/md/dm-vdo/block-map.c

2553

pbn_from_vio_bio(cursor->vio->vio.bio), page);

drivers/md/dm-vdo/block-map.c

2554

traverse(cursor);

drivers/md/dm-vdo/block-map.c

2560

struct cursor *cursor = vio->completion.parent;

drivers/md/dm-vdo/block-map.c

2563

cursor->parent->zone->thread_id);

drivers/md/dm-vdo/block-map.c

2572

static void traverse(struct cursor *cursor)

drivers/md/dm-vdo/block-map.c

2574

for (; cursor->height < VDO_BLOCK_MAP_TREE_HEIGHT; cursor->height++) {

drivers/md/dm-vdo/block-map.c

2575

height_t height = cursor->height;

drivers/md/dm-vdo/block-map.c

2576

struct cursor_level *level = &cursor->levels[height];

drivers/md/dm-vdo/block-map.c

2578

&(cursor->tree->segments[0].levels[height][level->page_index]);

drivers/md/dm-vdo/block-map.c

2594

vdo_write_tree_page(tree_page, cursor->parent->zone);

drivers/md/dm-vdo/block-map.c

2602

if (entry_index >= cursor->boundary.levels[height]) {

drivers/md/dm-vdo/block-map.c

2604

vdo_write_tree_page(tree_page, cursor->parent->zone);

drivers/md/dm-vdo/block-map.c

2608

if (cursor->height < VDO_BLOCK_MAP_TREE_HEIGHT - 1) {

drivers/md/dm-vdo/block-map.c

2609

int result = cursor->parent->entry_callback(location.pbn,

drivers/md/dm-vdo/block-map.c

2610

cursor->parent->completion);

drivers/md/dm-vdo/block-map.c

2613

vdo_write_tree_page(tree_page, cursor->parent->zone);

drivers/md/dm-vdo/block-map.c

2618

if (cursor->height == 0)

drivers/md/dm-vdo/block-map.c

2621

cursor->height--;

drivers/md/dm-vdo/block-map.c

2622

next_level = &cursor->levels[cursor->height];

drivers/md/dm-vdo/block-map.c

2626

vdo_submit_metadata_vio(&cursor->vio->vio, location.pbn,

drivers/md/dm-vdo/block-map.c

2633

finish_cursor(cursor);

drivers/md/dm-vdo/block-map.c

2646

struct cursor *cursor = container_of(waiter, struct cursor, waiter);

drivers/md/dm-vdo/block-map.c

2649

cursor->vio = pooled;

drivers/md/dm-vdo/block-map.c

2650

pooled->vio.completion.parent = cursor;

drivers/md/dm-vdo/block-map.c

2651

pooled->vio.completion.callback_thread_id = cursor->parent->zone->thread_id;

drivers/md/dm-vdo/block-map.c

2652

traverse(cursor);

drivers/md/dm-vdo/block-map.c

2714

struct cursor *cursor = &cursors->cursors[root];

drivers/md/dm-vdo/block-map.c

2716

*cursor = (struct cursor) {

drivers/md/dm-vdo/block-map.c

2723

cursor->waiter.callback = launch_cursor;

drivers/md/dm-vdo/block-map.c

2724

acquire_vio_from_pool(cursors->pool, &cursor->waiter);

drivers/md/dm-vdo/slab-depot.c

1896

struct search_cursor *cursor = &slab->search_cursor;

drivers/md/dm-vdo/slab-depot.c

1898

cursor->block = cursor->first_block;

drivers/md/dm-vdo/slab-depot.c

1899

cursor->index = 0;

drivers/md/dm-vdo/slab-depot.c

1900

cursor->end_index = min_t(u32, COUNTS_PER_BLOCK, slab->block_count);

drivers/md/dm-vdo/slab-depot.c

1914

struct search_cursor *cursor = &slab->search_cursor;

drivers/md/dm-vdo/slab-depot.c

1920

if (cursor->block == cursor->last_block) {

drivers/md/dm-vdo/slab-depot.c

1926

cursor->block++;

drivers/md/dm-vdo/slab-depot.c

1927

cursor->index = cursor->end_index;

drivers/md/dm-vdo/slab-depot.c

1929

if (cursor->block == cursor->last_block) {

drivers/md/dm-vdo/slab-depot.c

1931

cursor->end_index = slab->block_count;

drivers/md/dm-vdo/slab-depot.c

1933

cursor->end_index += COUNTS_PER_BLOCK;

drivers/md/persistent-data/dm-array.c

922

r = dm_btree_cursor_get_value(&c->cursor, &key, &value_le);

drivers/md/persistent-data/dm-array.c

938

dm_btree_cursor_end(&c->cursor);

drivers/md/persistent-data/dm-array.c

951

r = dm_btree_cursor_begin(&info->btree_info, root, true, &c->cursor);

drivers/md/persistent-data/dm-array.c

966

dm_btree_cursor_end(&c->cursor);

drivers/md/persistent-data/dm-array.c

980

r = dm_btree_cursor_next(&c->cursor);

drivers/md/persistent-data/dm-array.h

198

struct dm_btree_cursor cursor;

drivers/md/persistent-data/dm-bitset.c

220

r = dm_array_cursor_next(&c->cursor);

drivers/md/persistent-data/dm-bitset.c

224

dm_array_cursor_get_value(&c->cursor, (void **) &value);

drivers/md/persistent-data/dm-bitset.c

244

r = dm_array_cursor_begin(&info->array_info, root, &c->cursor);

drivers/md/persistent-data/dm-bitset.c

248

dm_array_cursor_get_value(&c->cursor, (void **) &value);

drivers/md/persistent-data/dm-bitset.c

259

return dm_array_cursor_end(&c->cursor);

drivers/md/persistent-data/dm-bitset.c

299

r = dm_array_cursor_skip(&c->cursor, nr_array_skip);

drivers/md/persistent-data/dm-bitset.c

303

dm_array_cursor_get_value(&c->cursor, (void **) &value);

drivers/md/persistent-data/dm-bitset.h

183

struct dm_array_cursor cursor;

drivers/media/mc/mc-entity.c

1007

iter->cursor = pipe->pads.next;

drivers/media/mc/mc-entity.c

1009

if (iter->cursor == &pipe->pads)

drivers/media/mc/mc-entity.c

1012

pad = list_entry(iter->cursor, struct media_pipeline_pad, list)->pad;

drivers/media/mc/mc-entity.c

1013

iter->cursor = iter->cursor->next;

drivers/media/mc/mc-entity.c

1038

iter->cursor = pipe->pads.next;

drivers/media/mc/mc-entity.c

1040

while (iter->cursor != &pipe->pads) {

drivers/media/mc/mc-entity.c

1044

ppad = list_entry(iter->cursor, struct media_pipeline_pad, list);

drivers/media/mc/mc-entity.c

1046

iter->cursor = iter->cursor->next;

drivers/mtd/nand/raw/nand_onfi.c

42

uint8_t *cursor;

drivers/mtd/nand/raw/nand_onfi.c

79

cursor = (uint8_t *)(ep + 1);

drivers/mtd/nand/raw/nand_onfi.c

84

cursor += s->length * 16;

drivers/mtd/nand/raw/nand_onfi.c

92

ecc = (struct onfi_ext_ecc_info *)cursor;

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

3252

entry_idx = log->cursor + k;

drivers/net/ethernet/chelsio/cxgb4/cxgb4.h

517

unsigned int cursor; /* next position in the log to write */

drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c

1169

entry_idx = log->cursor + ((uintptr_t)v - 2);

drivers/net/ethernet/chelsio/cxgb4/t4_hw.c

245

entry = mbox_cmd_log_entry(log, log->cursor++);

drivers/net/ethernet/chelsio/cxgb4/t4_hw.c

246

if (log->cursor == log->size)

drivers/net/ethernet/chelsio/cxgb4/t4_hw.c

247

log->cursor = 0;

drivers/net/ethernet/chelsio/cxgb4vf/cxgb4vf_main.c

1982

entry_idx = log->cursor + ((uintptr_t)v - 2);

drivers/net/ethernet/chelsio/cxgb4vf/t4vf_common.h

286

unsigned int cursor; /* next position in the log to write */

drivers/net/ethernet/chelsio/cxgb4vf/t4vf_hw.c

95

entry = mbox_cmd_log_entry(log, log->cursor++);

drivers/net/ethernet/chelsio/cxgb4vf/t4vf_hw.c

96

if (log->cursor == log->size)

drivers/net/ethernet/chelsio/cxgb4vf/t4vf_hw.c

97

log->cursor = 0;

drivers/net/ethernet/sfc/siena/ptp.c

1155

struct list_head *cursor;

drivers/net/ethernet/sfc/siena/ptp.c

1163

list_for_each_safe(cursor, next, &ptp->evt_list) {

drivers/net/ethernet/sfc/siena/ptp.c

1166

evt = list_entry(cursor, struct efx_ptp_event_rx,

drivers/net/ethernet/sfc/siena/ptp.c

1182

struct list_head *cursor;

drivers/net/ethernet/sfc/siena/ptp.c

1199

list_for_each_safe(cursor, next, &ptp->evt_list) {

drivers/net/ethernet/sfc/siena/ptp.c

1202

evt = list_entry(cursor, struct efx_ptp_event_rx, link);

drivers/net/ethernet/sfc/siena/ptp.c

1350

struct list_head *cursor;

drivers/net/ethernet/sfc/siena/ptp.c

1367

list_for_each_safe(cursor, next, &efx->ptp_data->evt_list) {

drivers/net/ethernet/sfc/siena/ptp.c

1368

list_move(cursor, &efx->ptp_data->evt_free_list);

drivers/net/usb/r8152.c

2545

struct list_head *cursor;

drivers/net/usb/r8152.c

2547

cursor = tp->tx_free.next;

drivers/net/usb/r8152.c

2548

list_del_init(cursor);

drivers/net/usb/r8152.c

2549

agg = list_entry(cursor, struct tx_agg, list);

drivers/net/usb/r8152.c

2979

struct list_head *cursor, *next, rx_queue;

drivers/net/usb/r8152.c

3010

list_for_each_safe(cursor, next, &rx_queue) {

drivers/net/usb/r8152.c

3026

list_del_init(cursor);

drivers/net/usb/r8152.c

3028

agg = list_entry(cursor, struct rx_agg, list);

drivers/net/wireless/realtek/rtw89/core.h

4327

static inline bool rtw89_txpwr_entcpy(void *entry, const void *cursor, u8 size,

drivers/net/wireless/realtek/rtw89/core.h

4332

memcpy(entry, cursor, valid_size);

drivers/net/wireless/realtek/rtw89/core.h

4338

#define rtw89_for_each_in_txpwr_conf(entry, cursor, conf) \

drivers/net/wireless/realtek/rtw89/core.h

4339

for (typecheck(const void *, cursor), (cursor) = (conf)->data; \

drivers/net/wireless/realtek/rtw89/core.h

4340

(cursor) < (conf)->data + (conf)->num_ents * (conf)->ent_sz; \

drivers/net/wireless/realtek/rtw89/core.h

4341

(cursor) += (conf)->ent_sz) \

drivers/net/wireless/realtek/rtw89/core.h

4342

if (rtw89_txpwr_entcpy(&(entry), cursor, sizeof(entry), conf))

drivers/net/wireless/realtek/rtw89/fw.c

10997

#define __fw_txpwr_entry_acceptable(e, cursor, ent_sz) \

drivers/net/wireless/realtek/rtw89/fw.c

11004

__accept = __fw_txpwr_entry_zero_ext((cursor) + __var_sz,\

drivers/net/wireless/realtek/rtw89/fw.c

11011

const void *cursor,

drivers/net/wireless/realtek/rtw89/fw.c

11014

if (!__fw_txpwr_entry_acceptable(e, cursor, conf->ent_sz))

drivers/net/wireless/realtek/rtw89/fw.c

11060

const void *cursor;

drivers/net/wireless/realtek/rtw89/fw.c

11065

rtw89_for_each_in_txpwr_conf(entry, cursor, conf) {

drivers/net/wireless/realtek/rtw89/fw.c

11066

if (!fw_txpwr_byrate_entry_valid(&entry, cursor, conf))

drivers/net/wireless/realtek/rtw89/fw.c

11085

const void *cursor,

drivers/net/wireless/realtek/rtw89/fw.c

11088

if (!__fw_txpwr_entry_acceptable(e, cursor, conf->ent_sz))

drivers/net/wireless/realtek/rtw89/fw.c

11112

const void *cursor;

drivers/net/wireless/realtek/rtw89/fw.c

11114

rtw89_for_each_in_txpwr_conf(entry, cursor, conf) {

drivers/net/wireless/realtek/rtw89/fw.c

11115

if (!fw_txpwr_lmt_2ghz_entry_valid(&entry, cursor, conf))

drivers/net/wireless/realtek/rtw89/fw.c

11125

const void *cursor,

drivers/net/wireless/realtek/rtw89/fw.c

11128

if (!__fw_txpwr_entry_acceptable(e, cursor, conf->ent_sz))

drivers/net/wireless/realtek/rtw89/fw.c

11152

const void *cursor;

drivers/net/wireless/realtek/rtw89/fw.c

11154

rtw89_for_each_in_txpwr_conf(entry, cursor, conf) {

drivers/net/wireless/realtek/rtw89/fw.c

11155

if (!fw_txpwr_lmt_5ghz_entry_valid(&entry, cursor, conf))

drivers/net/wireless/realtek/rtw89/fw.c

11165

const void *cursor,

drivers/net/wireless/realtek/rtw89/fw.c

11168

if (!__fw_txpwr_entry_acceptable(e, cursor, conf->ent_sz))

drivers/net/wireless/realtek/rtw89/fw.c

11194

const void *cursor;

drivers/net/wireless/realtek/rtw89/fw.c

11196

rtw89_for_each_in_txpwr_conf(entry, cursor, conf) {

drivers/net/wireless/realtek/rtw89/fw.c

11197

if (!fw_txpwr_lmt_6ghz_entry_valid(&entry, cursor, conf))

drivers/net/wireless/realtek/rtw89/fw.c

11207

const void *cursor,

drivers/net/wireless/realtek/rtw89/fw.c

11210

if (!__fw_txpwr_entry_acceptable(e, cursor, conf->ent_sz))

drivers/net/wireless/realtek/rtw89/fw.c

11230

const void *cursor;

drivers/net/wireless/realtek/rtw89/fw.c

11232

rtw89_for_each_in_txpwr_conf(entry, cursor, conf) {

drivers/net/wireless/realtek/rtw89/fw.c

11233

if (!fw_txpwr_lmt_ru_2ghz_entry_valid(&entry, cursor, conf))

drivers/net/wireless/realtek/rtw89/fw.c

11242

const void *cursor,

drivers/net/wireless/realtek/rtw89/fw.c

11245

if (!__fw_txpwr_entry_acceptable(e, cursor, conf->ent_sz))

drivers/net/wireless/realtek/rtw89/fw.c

11265

const void *cursor;

drivers/net/wireless/realtek/rtw89/fw.c

11267

rtw89_for_each_in_txpwr_conf(entry, cursor, conf) {

drivers/net/wireless/realtek/rtw89/fw.c

11268

if (!fw_txpwr_lmt_ru_5ghz_entry_valid(&entry, cursor, conf))

drivers/net/wireless/realtek/rtw89/fw.c

11277

const void *cursor,

drivers/net/wireless/realtek/rtw89/fw.c

11280

if (!__fw_txpwr_entry_acceptable(e, cursor, conf->ent_sz))

drivers/net/wireless/realtek/rtw89/fw.c

11302

const void *cursor;

drivers/net/wireless/realtek/rtw89/fw.c

11304

rtw89_for_each_in_txpwr_conf(entry, cursor, conf) {

drivers/net/wireless/realtek/rtw89/fw.c

11305

if (!fw_txpwr_lmt_ru_6ghz_entry_valid(&entry, cursor, conf))

drivers/net/wireless/realtek/rtw89/fw.c

11315

const void *cursor,

drivers/net/wireless/realtek/rtw89/fw.c

11318

if (!__fw_txpwr_entry_acceptable(e, cursor, conf->ent_sz))

drivers/net/wireless/realtek/rtw89/fw.c

11336

const void *cursor;

drivers/net/wireless/realtek/rtw89/fw.c

11338

rtw89_for_each_in_txpwr_conf(entry, cursor, conf) {

drivers/net/wireless/realtek/rtw89/fw.c

11339

if (!fw_tx_shape_lmt_entry_valid(&entry, cursor, conf))

drivers/net/wireless/realtek/rtw89/fw.c

11348

const void *cursor,

drivers/net/wireless/realtek/rtw89/fw.c

11351

if (!__fw_txpwr_entry_acceptable(e, cursor, conf->ent_sz))

drivers/net/wireless/realtek/rtw89/fw.c

11367

const void *cursor;

drivers/net/wireless/realtek/rtw89/fw.c

11369

rtw89_for_each_in_txpwr_conf(entry, cursor, conf) {

drivers/net/wireless/realtek/rtw89/fw.c

11370

if (!fw_tx_shape_lmt_ru_entry_valid(&entry, cursor, conf))

drivers/net/wireless/realtek/rtw89/fw.c

1301

static bool rtw89_regd_entcpy(struct rtw89_regd *regd, const void *cursor,

drivers/net/wireless/realtek/rtw89/fw.c

1315

memcpy(&entry, cursor, valid_size);

drivers/net/wireless/realtek/rtw89/fw.c

1343

for (const void *cursor = (element)->content, \

drivers/net/wireless/realtek/rtw89/fw.c

1346

cursor < end; cursor += (element)->ent_sz) \

drivers/net/wireless/realtek/rtw89/fw.c

1347

if (rtw89_regd_entcpy(regd, cursor, (element)->ent_sz))

drivers/soc/fsl/qbman/bman.c

123

struct bm_rcr_entry *ring, *cursor;

drivers/soc/fsl/qbman/bman.c

297

struct bm_rcr_entry *partial = rcr->cursor + 1;

drivers/soc/fsl/qbman/bman.c

299

rcr->cursor = rcr_carryclear(partial);

drivers/soc/fsl/qbman/bman.c

300

if (partial != rcr->cursor)

drivers/soc/fsl/qbman/bman.c

357

dpaa_zero(rcr->cursor);

drivers/soc/fsl/qbman/bman.c

358

return rcr->cursor;

drivers/soc/fsl/qbman/bman.c

370

rcursor = rcr->cursor;

drivers/soc/fsl/qbman/bman.c

390

rcr->cursor = rcr->ring + pi;

drivers/soc/fsl/qbman/bman.c

416

if (i != rcr_ptr2idx(rcr->cursor))

drivers/soc/fsl/qbman/bman.c

422

if (rcr->ci != rcr_ptr2idx(rcr->cursor))

drivers/soc/fsl/qbman/qman.c

198

struct qm_eqcr_entry *ring, *cursor;

drivers/soc/fsl/qbman/qman.c

207

const struct qm_dqrr_entry *ring, *cursor;

drivers/soc/fsl/qbman/qman.c

217

union qm_mr_entry *ring, *cursor;

drivers/soc/fsl/qbman/qman.c

414

struct qm_eqcr_entry *partial = eqcr->cursor + 1;

drivers/soc/fsl/qbman/qman.c

416

eqcr->cursor = eqcr_carryclear(partial);

drivers/soc/fsl/qbman/qman.c

417

if (partial != eqcr->cursor)

drivers/soc/fsl/qbman/qman.c

434

eqcr->cursor = eqcr->ring + pi;

drivers/soc/fsl/qbman/qman.c

459

if (pi != eqcr_ptr2idx(eqcr->cursor))

drivers/soc/fsl/qbman/qman.c

463

if (eqcr->ci != eqcr_ptr2idx(eqcr->cursor))

drivers/soc/fsl/qbman/qman.c

479

dpaa_zero(eqcr->cursor);

drivers/soc/fsl/qbman/qman.c

480

return eqcr->cursor;

drivers/soc/fsl/qbman/qman.c

502

dpaa_zero(eqcr->cursor);

drivers/soc/fsl/qbman/qman.c

503

return eqcr->cursor;

drivers/soc/fsl/qbman/qman.c

509

DPAA_ASSERT(!(be32_to_cpu(eqcr->cursor->fqid) & ~QM_FQID_MASK));

drivers/soc/fsl/qbman/qman.c

521

eqcursor = eqcr->cursor;

drivers/soc/fsl/qbman/qman.c

617

dqrr->cursor = dqrr->ring + dqrr->ci;

drivers/soc/fsl/qbman/qman.c

648

dqrr->ci != dqrr_ptr2idx(dqrr->cursor))

drivers/soc/fsl/qbman/qman.c

660

return dqrr->cursor;

drivers/soc/fsl/qbman/qman.c

668

dqrr->cursor = dqrr_inc(dqrr->cursor);

drivers/soc/fsl/qbman/qman.c

771

mr->cursor = mr->ring + mr->ci;

drivers/soc/fsl/qbman/qman.c

790

if (mr->ci != mr_ptr2idx(mr->cursor))

drivers/soc/fsl/qbman/qman.c

800

return mr->cursor;

drivers/soc/fsl/qbman/qman.c

808

mr->cursor = mr_inc(mr->cursor);

drivers/soc/fsl/qbman/qman.c

843

mr->ci = mr_ptr2idx(mr->cursor);

drivers/staging/sm750fb/sm750.c

101

cursor = &crtc->cursor;

drivers/staging/sm750fb/sm750.c

103

if (fbcursor->image.width > cursor->max_w ||

drivers/staging/sm750fb/sm750.c

104

fbcursor->image.height > cursor->max_h ||

drivers/staging/sm750fb/sm750.c

109

sm750_hw_cursor_disable(cursor);

drivers/staging/sm750fb/sm750.c

111

sm750_hw_cursor_set_size(cursor,

drivers/staging/sm750fb/sm750.c

116

sm750_hw_cursor_set_pos(cursor,

drivers/staging/sm750fb/sm750.c

132

sm750_hw_cursor_set_color(cursor, fg, bg);

drivers/staging/sm750fb/sm750.c

136

sm750_hw_cursor_set_data(cursor, fbcursor->rop, fbcursor->image.data,

drivers/staging/sm750fb/sm750.c

141

sm750_hw_cursor_enable(cursor);

drivers/staging/sm750fb/sm750.c

426

struct lynx_cursor *cursor;

drivers/staging/sm750fb/sm750.c

439

cursor = &crtc->cursor;

drivers/staging/sm750fb/sm750.c

440

memset_io(cursor->vstart, 0x0, cursor->size);

drivers/staging/sm750fb/sm750.c

451

cursor = &crtc->cursor;

drivers/staging/sm750fb/sm750.c

452

memset_io(cursor->vstart, 0x0, cursor->size);

drivers/staging/sm750fb/sm750.c

745

crtc->cursor.offset = crtc->o_screen + crtc->vidmem_size - 1024;

drivers/staging/sm750fb/sm750.c

746

crtc->cursor.mmio = sm750_dev->pvReg +

drivers/staging/sm750fb/sm750.c

749

crtc->cursor.max_h = 64;

drivers/staging/sm750fb/sm750.c

750

crtc->cursor.max_w = 64;

drivers/staging/sm750fb/sm750.c

751

crtc->cursor.size = crtc->cursor.max_h * crtc->cursor.max_w * 2 / 8;

drivers/staging/sm750fb/sm750.c

752

crtc->cursor.vstart = sm750_dev->vmem + crtc->cursor.offset;

drivers/staging/sm750fb/sm750.c

754

memset_io(crtc->cursor.vstart, 0, crtc->cursor.size);

drivers/staging/sm750fb/sm750.c

756

sm750_hw_cursor_disable(&crtc->cursor);

drivers/staging/sm750fb/sm750.c

97

struct lynx_cursor *cursor;

drivers/staging/sm750fb/sm750.h

151

struct lynx_cursor cursor;

drivers/staging/sm750fb/sm750_cursor.c

33

void sm750_hw_cursor_enable(struct lynx_cursor *cursor)

drivers/staging/sm750fb/sm750_cursor.c

37

reg = (cursor->offset & HWC_ADDRESS_ADDRESS_MASK) | HWC_ADDRESS_ENABLE;

drivers/staging/sm750fb/sm750_cursor.c

41

void sm750_hw_cursor_disable(struct lynx_cursor *cursor)

drivers/staging/sm750fb/sm750_cursor.c

46

void sm750_hw_cursor_set_size(struct lynx_cursor *cursor, int w, int h)

drivers/staging/sm750fb/sm750_cursor.c

48

cursor->w = w;

drivers/staging/sm750fb/sm750_cursor.c

49

cursor->h = h;

drivers/staging/sm750fb/sm750_cursor.c

52

void sm750_hw_cursor_set_pos(struct lynx_cursor *cursor, int x, int y)

drivers/staging/sm750fb/sm750_cursor.c

61

void sm750_hw_cursor_set_color(struct lynx_cursor *cursor, u32 fg, u32 bg)

drivers/staging/sm750fb/sm750_cursor.c

70

void sm750_hw_cursor_set_data(struct lynx_cursor *cursor, u16 rop,

drivers/staging/sm750fb/sm750_cursor.c

79

pitch = cursor->w >> 3;

drivers/staging/sm750fb/sm750_cursor.c

8

writel((data), cursor->mmio + (addr))

drivers/staging/sm750fb/sm750_cursor.c

82

count = pitch * cursor->h;

drivers/staging/sm750fb/sm750_cursor.c

85

offset = cursor->max_w * 2 / 8;

drivers/staging/sm750fb/sm750_cursor.c

87

pstart = cursor->vstart;

drivers/staging/sm750fb/sm750_cursor.h

10

void sm750_hw_cursor_set_color(struct lynx_cursor *cursor, u32 fg, u32 bg);

drivers/staging/sm750fb/sm750_cursor.h

11

void sm750_hw_cursor_set_data(struct lynx_cursor *cursor, u16 rop,

drivers/staging/sm750fb/sm750_cursor.h

6

void sm750_hw_cursor_enable(struct lynx_cursor *cursor);

drivers/staging/sm750fb/sm750_cursor.h

7

void sm750_hw_cursor_disable(struct lynx_cursor *cursor);

drivers/staging/sm750fb/sm750_cursor.h

8

void sm750_hw_cursor_set_size(struct lynx_cursor *cursor, int w, int h);

drivers/staging/sm750fb/sm750_cursor.h

9

void sm750_hw_cursor_set_pos(struct lynx_cursor *cursor, int x, int y);

drivers/usb/core/hub.c

511

int cursor = -1;

drivers/usb/core/hub.c

524

cursor = i;

drivers/usb/core/hub.c

564

cursor++;

drivers/usb/core/hub.c

565

cursor %= hdev->maxchild;

drivers/usb/core/hub.c

566

set_port_led(hub, cursor + 1, HUB_LED_GREEN);

drivers/usb/core/hub.c

567

hub->indicator[cursor] = INDICATOR_CYCLE;

drivers/video/fbdev/arkfb.c

148

static void arkfb_tilecursor(struct fb_info *info, struct fb_tilecursor *cursor)

drivers/video/fbdev/arkfb.c

152

svga_tilecursor(par->state.vgabase, info, cursor);

drivers/video/fbdev/aty/mach64_cursor.c

104

y = cursor->image.dy - cursor->hot.y - info->var.yoffset;

drivers/video/fbdev/aty/mach64_cursor.c

112

h = cursor->image.height;

drivers/video/fbdev/aty/mach64_cursor.c

130

if (cursor->set & FB_CUR_SETCMAP) {

drivers/video/fbdev/aty/mach64_cursor.c

133

fg_idx = cursor->image.fg_color;

drivers/video/fbdev/aty/mach64_cursor.c

134

bg_idx = cursor->image.bg_color;

drivers/video/fbdev/aty/mach64_cursor.c

149

if (cursor->set & (FB_CUR_SETSHAPE | FB_CUR_SETIMAGE)) {

drivers/video/fbdev/aty/mach64_cursor.c

150

u8 *src = (u8 *)cursor->image.data;

drivers/video/fbdev/aty/mach64_cursor.c

151

u8 *msk = (u8 *)cursor->mask;

drivers/video/fbdev/aty/mach64_cursor.c

153

unsigned int width = (cursor->image.width + 7) >> 3;

drivers/video/fbdev/aty/mach64_cursor.c

154

unsigned int height = cursor->image.height;

drivers/video/fbdev/aty/mach64_cursor.c

170

switch (cursor->rop) {

drivers/video/fbdev/aty/mach64_cursor.c

188

if ((j + 1) * 8 > cursor->image.width) {

drivers/video/fbdev/aty/mach64_cursor.c

190

(1 << ((cursor->image.width & 7) * 2)) - 1);

drivers/video/fbdev/aty/mach64_cursor.c

73

static int atyfb_cursor(struct fb_info *info, struct fb_cursor *cursor)

drivers/video/fbdev/aty/mach64_cursor.c

87

if (cursor->enable)

drivers/video/fbdev/aty/mach64_cursor.c

95

if (cursor->set & FB_CUR_SETPOS) {

drivers/video/fbdev/aty/mach64_cursor.c

96

x = cursor->image.dx - cursor->hot.x - info->var.xoffset;

drivers/video/fbdev/bw2.c

54

u32 cursor;

drivers/video/fbdev/cg14.c

188

struct cg14_cursor __iomem *cursor;

drivers/video/fbdev/cg14.c

451

if (par->cursor)

drivers/video/fbdev/cg14.c

453

par->cursor, sizeof(struct cg14_cursor));

drivers/video/fbdev/cg14.c

497

par->cursor = of_ioremap(&op->resource[0], CG14_CURSORREGS,

drivers/video/fbdev/cg14.c

503

if (!par->regs || !par->clut || !par->cursor || !info->screen_base)

drivers/video/fbdev/cg3.c

79

u32 cursor;

drivers/video/fbdev/cg6.c

252

u32 cursor;

drivers/video/fbdev/cobalt_lcdfb.c

243

static int cobalt_lcdfb_cursor(struct fb_info *info, struct fb_cursor *cursor)

drivers/video/fbdev/cobalt_lcdfb.c

248

switch (cursor->set) {

drivers/video/fbdev/cobalt_lcdfb.c

250

x = cursor->image.dx;

drivers/video/fbdev/cobalt_lcdfb.c

251

y = cursor->image.dy;

drivers/video/fbdev/cobalt_lcdfb.c

270

if (cursor->enable)

drivers/video/fbdev/core/bitblit.c

262

struct fb_cursor cursor;

drivers/video/fbdev/core/bitblit.c

271

cursor.set = 0;

drivers/video/fbdev/core/bitblit.c

283

cursor.set |= FB_CUR_SETIMAGE;

drivers/video/fbdev/core/bitblit.c

303

cursor.set |= FB_CUR_SETCMAP;

drivers/video/fbdev/core/bitblit.c

311

cursor.set |= FB_CUR_SETPOS;

drivers/video/fbdev/core/bitblit.c

319

cursor.set |= FB_CUR_SETSIZE;

drivers/video/fbdev/core/bitblit.c

324

par->cursor_state.hot.x = cursor.hot.y = 0;

drivers/video/fbdev/core/bitblit.c

325

cursor.set |= FB_CUR_SETHOT;

drivers/video/fbdev/core/bitblit.c

328

if (cursor.set & FB_CUR_SETSIZE ||

drivers/video/fbdev/core/bitblit.c

342

cursor.set |= FB_CUR_SETSHAPE;

drivers/video/fbdev/core/bitblit.c

347

cursor.image.data = src;

drivers/video/fbdev/core/bitblit.c

348

cursor.image.fg_color = par->cursor_state.image.fg_color;

drivers/video/fbdev/core/bitblit.c

349

cursor.image.bg_color = par->cursor_state.image.bg_color;

drivers/video/fbdev/core/bitblit.c

350

cursor.image.dx = par->cursor_state.image.dx;

drivers/video/fbdev/core/bitblit.c

351

cursor.image.dy = par->cursor_state.image.dy;

drivers/video/fbdev/core/bitblit.c

352

cursor.image.height = par->cursor_state.image.height;

drivers/video/fbdev/core/bitblit.c

353

cursor.image.width = par->cursor_state.image.width;

drivers/video/fbdev/core/bitblit.c

354

cursor.hot.x = par->cursor_state.hot.x;

drivers/video/fbdev/core/bitblit.c

355

cursor.hot.y = par->cursor_state.hot.y;

drivers/video/fbdev/core/bitblit.c

356

cursor.mask = par->cursor_state.mask;

drivers/video/fbdev/core/bitblit.c

357

cursor.enable = par->cursor_state.enable;

drivers/video/fbdev/core/bitblit.c

358

cursor.image.depth = 1;

drivers/video/fbdev/core/bitblit.c

359

cursor.rop = ROP_XOR;

drivers/video/fbdev/core/bitblit.c

362

err = info->fbops->fb_cursor(info, &cursor);

drivers/video/fbdev/core/bitblit.c

365

soft_cursor(info, &cursor);

drivers/video/fbdev/core/bitblit.c

387

.cursor = bit_cursor,

drivers/video/fbdev/core/fbcon.c

1424

if (!par->bitops->cursor)

drivers/video/fbdev/core/fbcon.c

1427

par->bitops->cursor(vc, info, enable,

drivers/video/fbdev/core/fbcon.c

423

par->bitops->cursor(vc, info, enable,

drivers/video/fbdev/core/fbcon.h

203

extern int soft_cursor(struct fb_info *info, struct fb_cursor *cursor);

drivers/video/fbdev/core/fbcon.h

69

void (*cursor)(struct vc_data *vc, struct fb_info *info,

drivers/video/fbdev/core/fbcon_ccw.c

224

struct fb_cursor cursor;

drivers/video/fbdev/core/fbcon_ccw.c

238

cursor.set = 0;

drivers/video/fbdev/core/fbcon_ccw.c

247

cursor.set |= FB_CUR_SETIMAGE;

drivers/video/fbdev/core/fbcon_ccw.c

267

cursor.set |= FB_CUR_SETCMAP;

drivers/video/fbdev/core/fbcon_ccw.c

275

cursor.set |= FB_CUR_SETSIZE;

drivers/video/fbdev/core/fbcon_ccw.c

286

cursor.set |= FB_CUR_SETPOS;

drivers/video/fbdev/core/fbcon_ccw.c

291

par->cursor_state.hot.x = cursor.hot.y = 0;

drivers/video/fbdev/core/fbcon_ccw.c

292

cursor.set |= FB_CUR_SETHOT;

drivers/video/fbdev/core/fbcon_ccw.c

295

if (cursor.set & FB_CUR_SETSIZE ||

drivers/video/fbdev/core/fbcon_ccw.c

318

cursor.set |= FB_CUR_SETSHAPE;

drivers/video/fbdev/core/fbcon_ccw.c

323

cursor.image.data = src;

drivers/video/fbdev/core/fbcon_ccw.c

324

cursor.image.fg_color = par->cursor_state.image.fg_color;

drivers/video/fbdev/core/fbcon_ccw.c

325

cursor.image.bg_color = par->cursor_state.image.bg_color;

drivers/video/fbdev/core/fbcon_ccw.c

326

cursor.image.dx = par->cursor_state.image.dx;

drivers/video/fbdev/core/fbcon_ccw.c

327

cursor.image.dy = par->cursor_state.image.dy;

drivers/video/fbdev/core/fbcon_ccw.c

328

cursor.image.height = par->cursor_state.image.height;

drivers/video/fbdev/core/fbcon_ccw.c

329

cursor.image.width = par->cursor_state.image.width;

drivers/video/fbdev/core/fbcon_ccw.c

330

cursor.hot.x = par->cursor_state.hot.x;

drivers/video/fbdev/core/fbcon_ccw.c

331

cursor.hot.y = par->cursor_state.hot.y;

drivers/video/fbdev/core/fbcon_ccw.c

332

cursor.mask = par->cursor_state.mask;

drivers/video/fbdev/core/fbcon_ccw.c

333

cursor.enable = par->cursor_state.enable;

drivers/video/fbdev/core/fbcon_ccw.c

334

cursor.image.depth = 1;

drivers/video/fbdev/core/fbcon_ccw.c

335

cursor.rop = ROP_XOR;

drivers/video/fbdev/core/fbcon_ccw.c

338

err = info->fbops->fb_cursor(info, &cursor);

drivers/video/fbdev/core/fbcon_ccw.c

341

soft_cursor(info, &cursor);

drivers/video/fbdev/core/fbcon_ccw.c

368

.cursor = ccw_cursor,

drivers/video/fbdev/core/fbcon_cw.c

207

struct fb_cursor cursor;

drivers/video/fbdev/core/fbcon_cw.c

221

cursor.set = 0;

drivers/video/fbdev/core/fbcon_cw.c

230

cursor.set |= FB_CUR_SETIMAGE;

drivers/video/fbdev/core/fbcon_cw.c

250

cursor.set |= FB_CUR_SETCMAP;

drivers/video/fbdev/core/fbcon_cw.c

258

cursor.set |= FB_CUR_SETSIZE;

drivers/video/fbdev/core/fbcon_cw.c

269

cursor.set |= FB_CUR_SETPOS;

drivers/video/fbdev/core/fbcon_cw.c

274

par->cursor_state.hot.x = cursor.hot.y = 0;

drivers/video/fbdev/core/fbcon_cw.c

275

cursor.set |= FB_CUR_SETHOT;

drivers/video/fbdev/core/fbcon_cw.c

278

if (cursor.set & FB_CUR_SETSIZE ||

drivers/video/fbdev/core/fbcon_cw.c

301

cursor.set |= FB_CUR_SETSHAPE;

drivers/video/fbdev/core/fbcon_cw.c

306

cursor.image.data = src;

drivers/video/fbdev/core/fbcon_cw.c

307

cursor.image.fg_color = par->cursor_state.image.fg_color;

drivers/video/fbdev/core/fbcon_cw.c

308

cursor.image.bg_color = par->cursor_state.image.bg_color;

drivers/video/fbdev/core/fbcon_cw.c

309

cursor.image.dx = par->cursor_state.image.dx;

drivers/video/fbdev/core/fbcon_cw.c

310

cursor.image.dy = par->cursor_state.image.dy;

drivers/video/fbdev/core/fbcon_cw.c

311

cursor.image.height = par->cursor_state.image.height;

drivers/video/fbdev/core/fbcon_cw.c

312

cursor.image.width = par->cursor_state.image.width;

drivers/video/fbdev/core/fbcon_cw.c

313

cursor.hot.x = par->cursor_state.hot.x;

drivers/video/fbdev/core/fbcon_cw.c

314

cursor.hot.y = par->cursor_state.hot.y;

drivers/video/fbdev/core/fbcon_cw.c

315

cursor.mask = par->cursor_state.mask;

drivers/video/fbdev/core/fbcon_cw.c

316

cursor.enable = par->cursor_state.enable;

drivers/video/fbdev/core/fbcon_cw.c

317

cursor.image.depth = 1;

drivers/video/fbdev/core/fbcon_cw.c

318

cursor.rop = ROP_XOR;

drivers/video/fbdev/core/fbcon_cw.c

321

err = info->fbops->fb_cursor(info, &cursor);

drivers/video/fbdev/core/fbcon_cw.c

324

soft_cursor(info, &cursor);

drivers/video/fbdev/core/fbcon_cw.c

351

.cursor = cw_cursor,

drivers/video/fbdev/core/fbcon_ud.c

253

struct fb_cursor cursor;

drivers/video/fbdev/core/fbcon_ud.c

268

cursor.set = 0;

drivers/video/fbdev/core/fbcon_ud.c

277

cursor.set |= FB_CUR_SETIMAGE;

drivers/video/fbdev/core/fbcon_ud.c

297

cursor.set |= FB_CUR_SETCMAP;

drivers/video/fbdev/core/fbcon_ud.c

305

cursor.set |= FB_CUR_SETSIZE;

drivers/video/fbdev/core/fbcon_ud.c

316

cursor.set |= FB_CUR_SETPOS;

drivers/video/fbdev/core/fbcon_ud.c

321

par->cursor_state.hot.x = cursor.hot.y = 0;

drivers/video/fbdev/core/fbcon_ud.c

322

cursor.set |= FB_CUR_SETHOT;

drivers/video/fbdev/core/fbcon_ud.c

325

if (cursor.set & FB_CUR_SETSIZE ||

drivers/video/fbdev/core/fbcon_ud.c

348

cursor.set |= FB_CUR_SETSHAPE;

drivers/video/fbdev/core/fbcon_ud.c

353

cursor.image.data = src;

drivers/video/fbdev/core/fbcon_ud.c

354

cursor.image.fg_color = par->cursor_state.image.fg_color;

drivers/video/fbdev/core/fbcon_ud.c

355

cursor.image.bg_color = par->cursor_state.image.bg_color;

drivers/video/fbdev/core/fbcon_ud.c

356

cursor.image.dx = par->cursor_state.image.dx;

drivers/video/fbdev/core/fbcon_ud.c

357

cursor.image.dy = par->cursor_state.image.dy;

drivers/video/fbdev/core/fbcon_ud.c

358

cursor.image.height = par->cursor_state.image.height;

drivers/video/fbdev/core/fbcon_ud.c

359

cursor.image.width = par->cursor_state.image.width;

drivers/video/fbdev/core/fbcon_ud.c

360

cursor.hot.x = par->cursor_state.hot.x;

drivers/video/fbdev/core/fbcon_ud.c

361

cursor.hot.y = par->cursor_state.hot.y;

drivers/video/fbdev/core/fbcon_ud.c

362

cursor.mask = par->cursor_state.mask;

drivers/video/fbdev/core/fbcon_ud.c

363

cursor.enable = par->cursor_state.enable;

drivers/video/fbdev/core/fbcon_ud.c

364

cursor.image.depth = 1;

drivers/video/fbdev/core/fbcon_ud.c

365

cursor.rop = ROP_XOR;

drivers/video/fbdev/core/fbcon_ud.c

368

err = info->fbops->fb_cursor(info, &cursor);

drivers/video/fbdev/core/fbcon_ud.c

371

soft_cursor(info, &cursor);

drivers/video/fbdev/core/fbcon_ud.c

402

.cursor = ud_cursor,

drivers/video/fbdev/core/fbsysfs.c

423

static DEVICE_ATTR(cursor, 0644, show_cursor, store_cursor);

drivers/video/fbdev/core/softcursor.c

22

int soft_cursor(struct fb_info *info, struct fb_cursor *cursor)

drivers/video/fbdev/core/softcursor.c

34

s_pitch = (cursor->image.width + 7) >> 3;

drivers/video/fbdev/core/softcursor.c

35

dsize = s_pitch * cursor->image.height;

drivers/video/fbdev/core/softcursor.c

50

*image = cursor->image;

drivers/video/fbdev/core/softcursor.c

57

if (cursor->enable) {

drivers/video/fbdev/core/softcursor.c

58

switch (cursor->rop) {

drivers/video/fbdev/core/softcursor.c

61

src[i] = image->data[i] ^ cursor->mask[i];

drivers/video/fbdev/core/softcursor.c

66

src[i] = image->data[i] & cursor->mask[i];

drivers/video/fbdev/core/svgalib.c

301

void svga_tilecursor(void __iomem *regbase, struct fb_info *info, struct fb_tilecursor *cursor)

drivers/video/fbdev/core/svgalib.c

305

u16 pos = cursor->sx + (info->var.xoffset / 8)

drivers/video/fbdev/core/svgalib.c

306

+ (cursor->sy + (info->var.yoffset / 16))

drivers/video/fbdev/core/svgalib.c

309

if (!cursor->mode)

drivers/video/fbdev/core/svgalib.c

314

if (cursor->shape == FB_TILE_CURSOR_NONE)

drivers/video/fbdev/core/svgalib.c

317

switch (cursor->shape) {

drivers/video/fbdev/core/tileblit.c

118

struct fb_tilecursor cursor;

drivers/video/fbdev/core/tileblit.c

121

cursor.sx = vc->state.x;

drivers/video/fbdev/core/tileblit.c

122

cursor.sy = vc->state.y;

drivers/video/fbdev/core/tileblit.c

123

cursor.mode = enable && !use_sw;

drivers/video/fbdev/core/tileblit.c

124

cursor.fg = fg;

drivers/video/fbdev/core/tileblit.c

125

cursor.bg = bg;

drivers/video/fbdev/core/tileblit.c

129

cursor.shape = FB_TILE_CURSOR_NONE;

drivers/video/fbdev/core/tileblit.c

132

cursor.shape = FB_TILE_CURSOR_UNDERLINE;

drivers/video/fbdev/core/tileblit.c

135

cursor.shape = FB_TILE_CURSOR_LOWER_THIRD;

drivers/video/fbdev/core/tileblit.c

138

cursor.shape = FB_TILE_CURSOR_LOWER_HALF;

drivers/video/fbdev/core/tileblit.c

141

cursor.shape = FB_TILE_CURSOR_TWO_THIRDS;

drivers/video/fbdev/core/tileblit.c

145

cursor.shape = FB_TILE_CURSOR_BLOCK;

drivers/video/fbdev/core/tileblit.c

149

info->tileops->fb_tilecursor(info, &cursor);

drivers/video/fbdev/core/tileblit.c

169

.cursor = tile_cursor,

drivers/video/fbdev/fsl-diu-fb.c

1000

__le16 *cursor = data->cursor;

drivers/video/fbdev/fsl-diu-fb.c

1010

cursor[w] = (line & mask) ? _fg : _bg;

drivers/video/fbdev/fsl-diu-fb.c

1014

cursor += MAX_CURS;

drivers/video/fbdev/fsl-diu-fb.c

1023

static int fsl_diu_cursor(struct fb_info *info, struct fb_cursor *cursor)

drivers/video/fbdev/fsl-diu-fb.c

1029

if (cursor->image.width > MAX_CURS || cursor->image.height > MAX_CURS)

drivers/video/fbdev/fsl-diu-fb.c

1033

if (cursor->set & FB_CUR_SETSIZE) {

drivers/video/fbdev/fsl-diu-fb.c

1041

memset(data->cursor, 0, sizeof(data->cursor));

drivers/video/fbdev/fsl-diu-fb.c

1045

if (cursor->set & FB_CUR_SETPOS) {

drivers/video/fbdev/fsl-diu-fb.c

1048

yy = (cursor->image.dy - info->var.yoffset) & 0x7ff;

drivers/video/fbdev/fsl-diu-fb.c

1049

xx = (cursor->image.dx - info->var.xoffset) & 0x7ff;

drivers/video/fbdev/fsl-diu-fb.c

1059

if (cursor->set & (FB_CUR_SETSHAPE | FB_CUR_SETCMAP | FB_CUR_SETIMAGE)) {

drivers/video/fbdev/fsl-diu-fb.c

1065

DIV_ROUND_UP(cursor->image.width, 8) *

drivers/video/fbdev/fsl-diu-fb.c

1066

cursor->image.height;

drivers/video/fbdev/fsl-diu-fb.c

1069

unsigned int bg_idx = cursor->image.bg_color;

drivers/video/fbdev/fsl-diu-fb.c

1070

unsigned int fg_idx = cursor->image.fg_color;

drivers/video/fbdev/fsl-diu-fb.c

1090

source = (uint32_t *)cursor->image.data;

drivers/video/fbdev/fsl-diu-fb.c

1091

mask = (uint32_t *)cursor->mask;

drivers/video/fbdev/fsl-diu-fb.c

1093

if (cursor->rop == ROP_XOR)

drivers/video/fbdev/fsl-diu-fb.c

1101

cursor->image.width, cursor->image.height);

drivers/video/fbdev/fsl-diu-fb.c

1111

if (cursor->enable)

drivers/video/fbdev/fsl-diu-fb.c

1112

out_be32(&hw->cursor, DMA_ADDR(data, cursor));

drivers/video/fbdev/fsl-diu-fb.c

1114

out_be32(&hw->cursor, DMA_ADDR(data, blank_cursor));

drivers/video/fbdev/fsl-diu-fb.c

380

__le16 cursor[MAX_CURS * MAX_CURS] __aligned(32);

drivers/video/fbdev/fsl-diu-fb.c

448

hw->palette, hw->cursor, hw->curs_pos, hw->diu_mode,

drivers/video/fbdev/i810/i810_main.c

1479

static int i810fb_cursor(struct fb_info *info, struct fb_cursor *cursor)

drivers/video/fbdev/i810/i810_main.c

1487

if (cursor->image.width > 64 || cursor->image.height > 64)

drivers/video/fbdev/i810/i810_main.c

1492

cursor->set |= FB_CUR_SETALL;

drivers/video/fbdev/i810/i810_main.c

1497

if (cursor->set & FB_CUR_SETPOS) {

drivers/video/fbdev/i810/i810_main.c

1500

tmp = (cursor->image.dx - info->var.xoffset) & 0xffff;

drivers/video/fbdev/i810/i810_main.c

1501

tmp |= (cursor->image.dy - info->var.yoffset) << 16;

drivers/video/fbdev/i810/i810_main.c

1505

if (cursor->set & FB_CUR_SETSIZE)

drivers/video/fbdev/i810/i810_main.c

1508

if (cursor->set & FB_CUR_SETCMAP)

drivers/video/fbdev/i810/i810_main.c

1509

i810_load_cursor_colors(cursor->image.fg_color,

drivers/video/fbdev/i810/i810_main.c

1510

cursor->image.bg_color,

drivers/video/fbdev/i810/i810_main.c

1513

if (cursor->set & (FB_CUR_SETSHAPE | FB_CUR_SETIMAGE)) {

drivers/video/fbdev/i810/i810_main.c

1514

int size = ((cursor->image.width + 7) >> 3) *

drivers/video/fbdev/i810/i810_main.c

1515

cursor->image.height;

drivers/video/fbdev/i810/i810_main.c

1522

switch (cursor->rop) {

drivers/video/fbdev/i810/i810_main.c

1525

data[i] = cursor->image.data[i] ^ cursor->mask[i];

drivers/video/fbdev/i810/i810_main.c

1530

data[i] = cursor->image.data[i] & cursor->mask[i];

drivers/video/fbdev/i810/i810_main.c

1534

i810_load_cursor_image(cursor->image.width,

drivers/video/fbdev/i810/i810_main.c

1535

cursor->image.height, data,

drivers/video/fbdev/i810/i810_main.c

1540

if (cursor->enable)

drivers/video/fbdev/i810/i810_main.c

82

static int i810fb_cursor(struct fb_info *info, struct fb_cursor *cursor);

drivers/video/fbdev/imsttfb.c

1197

imsttfb_cursor(struct fb_info *info, struct fb_cursor *cursor)

drivers/video/fbdev/imsttfb.c

1200

u32 flags = cursor->set, fg, bg, xx, yy;

drivers/video/fbdev/imsttfb.c

1202

if (cursor->dest == NULL && cursor->rop == ROP_XOR)

drivers/video/fbdev/imsttfb.c

1205

imstt_set_cursor(info, cursor, 0);

drivers/video/fbdev/imsttfb.c

1208

xx = cursor->image.dx - info->var.xoffset;

drivers/video/fbdev/imsttfb.c

1209

yy = cursor->image.dy - info->var.yoffset;

drivers/video/fbdev/imsttfb.c

1216

int fg_idx = cursor->image.fg_color;

drivers/video/fbdev/imsttfb.c

1217

int width = (cursor->image.width+7)/8;

drivers/video/fbdev/imsttfb.c

1218

u8 *dat = (u8 *) cursor->image.data;

drivers/video/fbdev/imsttfb.c

1219

u8 *dst = (u8 *) cursor->dest;

drivers/video/fbdev/imsttfb.c

1220

u8 *msk = (u8 *) cursor->mask;

drivers/video/fbdev/imsttfb.c

1222

switch (cursor->rop) {

drivers/video/fbdev/imsttfb.c

1224

for (i = 0; i < cursor->image.height; i++) {

drivers/video/fbdev/imsttfb.c

1236

for (i = 0; i < cursor->image.height; i++) {

drivers/video/fbdev/imsttfb.c

1253

if (cursor->enable)

drivers/video/fbdev/imsttfb.c

1254

imstt_set_cursor(info, cursor, 1);

drivers/video/fbdev/leo.c

181

struct leo_cursor __iomem *cursor;

drivers/video/fbdev/leo.c

207

struct leo_cursor __iomem *cursor = par->cursor;

drivers/video/fbdev/leo.c

240

sbus_writel(sbus_readl(&cursor->cur_misc) & ~LEO_CUR_ENABLE, &cursor->cur_misc);

drivers/video/fbdev/leo.c

538

if (par->cursor)

drivers/video/fbdev/leo.c

540

par->cursor, sizeof(struct leo_cursor));

drivers/video/fbdev/leo.c

583

par->cursor =

drivers/video/fbdev/leo.c

593

!par->cursor ||

drivers/video/fbdev/nvidia/nvidia.c

529

static int nvidiafb_cursor(struct fb_info *info, struct fb_cursor *cursor)

drivers/video/fbdev/nvidia/nvidia.c

533

int i, set = cursor->set;

drivers/video/fbdev/nvidia/nvidia.c

536

if (cursor->image.width > MAX_CURS || cursor->image.height > MAX_CURS)

drivers/video/fbdev/nvidia/nvidia.c

552

yy = cursor->image.dy - info->var.yoffset;

drivers/video/fbdev/nvidia/nvidia.c

553

xx = cursor->image.dx - info->var.xoffset;

drivers/video/fbdev/nvidia/nvidia.c

561

u32 bg_idx = cursor->image.bg_color;

drivers/video/fbdev/nvidia/nvidia.c

562

u32 fg_idx = cursor->image.fg_color;

drivers/video/fbdev/nvidia/nvidia.c

563

u32 s_pitch = (cursor->image.width + 7) >> 3;

drivers/video/fbdev/nvidia/nvidia.c

565

u8 *dat = (u8 *) cursor->image.data;

drivers/video/fbdev/nvidia/nvidia.c

566

u8 *msk = (u8 *) cursor->mask;

drivers/video/fbdev/nvidia/nvidia.c

569

src = kmalloc_array(s_pitch, cursor->image.height, GFP_ATOMIC);

drivers/video/fbdev/nvidia/nvidia.c

572

switch (cursor->rop) {

drivers/video/fbdev/nvidia/nvidia.c

574

for (i = 0; i < s_pitch * cursor->image.height; i++)

drivers/video/fbdev/nvidia/nvidia.c

579

for (i = 0; i < s_pitch * cursor->image.height; i++)

drivers/video/fbdev/nvidia/nvidia.c

585

cursor->image.height);

drivers/video/fbdev/nvidia/nvidia.c

598

cursor->image.width,

drivers/video/fbdev/nvidia/nvidia.c

599

cursor->image.height);

drivers/video/fbdev/nvidia/nvidia.c

604

if (cursor->enable)

drivers/video/fbdev/pm2fb.c

1266

static int pm2vfb_cursor(struct fb_info *info, struct fb_cursor *cursor)

drivers/video/fbdev/pm2fb.c

1270

int x = cursor->image.dx - info->var.xoffset;

drivers/video/fbdev/pm2fb.c

1271

int y = cursor->image.dy - info->var.yoffset;

drivers/video/fbdev/pm2fb.c

1273

if (cursor->enable)

drivers/video/fbdev/pm2fb.c

1278

if (!cursor->enable)

drivers/video/fbdev/pm2fb.c

1290

if (!cursor->set)

drivers/video/fbdev/pm2fb.c

1293

if (cursor->set & FB_CUR_SETHOT) {

drivers/video/fbdev/pm2fb.c

1295

cursor->hot.x & 0x3f);

drivers/video/fbdev/pm2fb.c

1297

cursor->hot.y & 0x3f);

drivers/video/fbdev/pm2fb.c

1300

if (cursor->set & FB_CUR_SETCMAP) {

drivers/video/fbdev/pm2fb.c

1301

u32 fg_idx = cursor->image.fg_color;

drivers/video/fbdev/pm2fb.c

1302

u32 bg_idx = cursor->image.bg_color;

drivers/video/fbdev/pm2fb.c

1323

if (cursor->set & (FB_CUR_SETSHAPE | FB_CUR_SETIMAGE)) {

drivers/video/fbdev/pm2fb.c

1324

u8 *bitmap = (u8 *)cursor->image.data;

drivers/video/fbdev/pm2fb.c

1325

u8 *mask = (u8 *)cursor->mask;

drivers/video/fbdev/pm2fb.c

1329

for (i = 0; i < cursor->image.height; i++) {

drivers/video/fbdev/pm2fb.c

1330

int j = (cursor->image.width + 7) >> 3;

drivers/video/fbdev/pm2fb.c

1338

if (cursor->rop == ROP_COPY)

drivers/video/fbdev/pm2fb.c

1367

static int pm2fb_cursor(struct fb_info *info, struct fb_cursor *cursor)

drivers/video/fbdev/pm2fb.c

1376

if (cursor->image.width > 64 ||

drivers/video/fbdev/pm2fb.c

1377

cursor->image.height > 64 ||

drivers/video/fbdev/pm2fb.c

1378

cursor->image.depth > 1)

drivers/video/fbdev/pm2fb.c

1382

return pm2vfb_cursor(info, cursor);

drivers/video/fbdev/pm2fb.c

1385

if (cursor->enable)

drivers/video/fbdev/pm2fb.c

1395

if (!cursor->set)

drivers/video/fbdev/pm2fb.c

1398

if (cursor->set & FB_CUR_SETPOS) {

drivers/video/fbdev/pm2fb.c

1399

int x = cursor->image.dx - info->var.xoffset + 63;

drivers/video/fbdev/pm2fb.c

1400

int y = cursor->image.dy - info->var.yoffset + 63;

drivers/video/fbdev/pm2fb.c

1409

if (cursor->set & FB_CUR_SETCMAP) {

drivers/video/fbdev/pm2fb.c

1410

u32 fg_idx = cursor->image.fg_color;

drivers/video/fbdev/pm2fb.c

1411

u32 bg_idx = cursor->image.bg_color;

drivers/video/fbdev/pm2fb.c

1430

if (cursor->set & (FB_CUR_SETSHAPE | FB_CUR_SETIMAGE)) {

drivers/video/fbdev/pm2fb.c

1431

u8 *bitmap = (u8 *)cursor->image.data;

drivers/video/fbdev/pm2fb.c

1432

u8 *mask = (u8 *)cursor->mask;

drivers/video/fbdev/pm2fb.c

1438

for (i = 0; i < cursor->image.height; i++) {

drivers/video/fbdev/pm2fb.c

1439

int j = (cursor->image.width + 7) >> 3;

drivers/video/fbdev/pm2fb.c

1446

if (cursor->rop == ROP_COPY)

drivers/video/fbdev/pm2fb.c

1463

mask = (u8 *)cursor->mask;

drivers/video/fbdev/pm2fb.c

1464

for (i = 0; i < cursor->image.height; i++) {

drivers/video/fbdev/pm2fb.c

1465

int j = (cursor->image.width + 7) >> 3;

drivers/video/fbdev/pm3fb.c

613

static int pm3fb_cursor(struct fb_info *info, struct fb_cursor *cursor)

drivers/video/fbdev/pm3fb.c

622

if (cursor->image.width > 64 ||

drivers/video/fbdev/pm3fb.c

623

cursor->image.height > 64 ||

drivers/video/fbdev/pm3fb.c

624

cursor->image.depth > 1)

drivers/video/fbdev/pm3fb.c

628

if (cursor->enable)

drivers/video/fbdev/pm3fb.c

638

if (!cursor->set)

drivers/video/fbdev/pm3fb.c

641

if (cursor->set & FB_CUR_SETPOS) {

drivers/video/fbdev/pm3fb.c

642

int x = cursor->image.dx - info->var.xoffset;

drivers/video/fbdev/pm3fb.c

643

int y = cursor->image.dy - info->var.yoffset;

drivers/video/fbdev/pm3fb.c

651

if (cursor->set & FB_CUR_SETHOT) {

drivers/video/fbdev/pm3fb.c

653

cursor->hot.x & 0x3f);

drivers/video/fbdev/pm3fb.c

655

cursor->hot.y & 0x3f);

drivers/video/fbdev/pm3fb.c

658

if (cursor->set & FB_CUR_SETCMAP) {

drivers/video/fbdev/pm3fb.c

659

u32 fg_idx = cursor->image.fg_color;

drivers/video/fbdev/pm3fb.c

660

u32 bg_idx = cursor->image.bg_color;

drivers/video/fbdev/pm3fb.c

679

if (cursor->set & (FB_CUR_SETSHAPE | FB_CUR_SETIMAGE)) {

drivers/video/fbdev/pm3fb.c

680

u8 *bitmap = (u8 *)cursor->image.data;

drivers/video/fbdev/pm3fb.c

681

u8 *mask = (u8 *)cursor->mask;

drivers/video/fbdev/pm3fb.c

685

for (i = 0; i < cursor->image.height; i++) {

drivers/video/fbdev/pm3fb.c

686

int j = (cursor->image.width + 7) >> 3;

drivers/video/fbdev/pm3fb.c

692

if (cursor->rop == ROP_COPY)

drivers/video/fbdev/pmag-aa-fb.c

104

static int aafb_cursor(struct fb_info *info, struct fb_cursor *cursor)

drivers/video/fbdev/pmag-aa-fb.c

108

if (cursor->image.height > BT431_CURSOR_SIZE ||

drivers/video/fbdev/pmag-aa-fb.c

109

cursor->image.width > BT431_CURSOR_SIZE) {

drivers/video/fbdev/pmag-aa-fb.c

114

if (!cursor->enable)

drivers/video/fbdev/pmag-aa-fb.c

117

if (cursor->set & FB_CUR_SETPOS)

drivers/video/fbdev/pmag-aa-fb.c

119

cursor->image.dx, cursor->image.dy);

drivers/video/fbdev/pmag-aa-fb.c

120

if (cursor->set & FB_CUR_SETCMAP) {

drivers/video/fbdev/pmag-aa-fb.c

121

u8 fg = cursor->image.fg_color ? 0xf : 0x0;

drivers/video/fbdev/pmag-aa-fb.c

122

u8 bg = cursor->image.bg_color ? 0xf : 0x0;

drivers/video/fbdev/pmag-aa-fb.c

128

if (cursor->set & (FB_CUR_SETSIZE | FB_CUR_SETSHAPE | FB_CUR_SETIMAGE))

drivers/video/fbdev/pmag-aa-fb.c

130

cursor->image.data, cursor->mask, cursor->rop,

drivers/video/fbdev/pmag-aa-fb.c

131

cursor->image.width, cursor->image.height);

drivers/video/fbdev/pmag-aa-fb.c

133

if (cursor->enable)

drivers/video/fbdev/riva/fbdev.c

1528

static int rivafb_cursor(struct fb_info *info, struct fb_cursor *cursor)

drivers/video/fbdev/riva/fbdev.c

1532

int i, set = cursor->set;

drivers/video/fbdev/riva/fbdev.c

1535

if (cursor->image.width > MAX_CURS || cursor->image.height > MAX_CURS)

drivers/video/fbdev/riva/fbdev.c

1551

yy = cursor->image.dy - info->var.yoffset;

drivers/video/fbdev/riva/fbdev.c

1552

xx = cursor->image.dx - info->var.xoffset;

drivers/video/fbdev/riva/fbdev.c

1561

u32 bg_idx = cursor->image.bg_color;

drivers/video/fbdev/riva/fbdev.c

1562

u32 fg_idx = cursor->image.fg_color;

drivers/video/fbdev/riva/fbdev.c

1563

u32 s_pitch = (cursor->image.width+7) >> 3;

drivers/video/fbdev/riva/fbdev.c

1565

u8 *dat = (u8 *) cursor->image.data;

drivers/video/fbdev/riva/fbdev.c

1566

u8 *msk = (u8 *) cursor->mask;

drivers/video/fbdev/riva/fbdev.c

1569

src = kmalloc_array(s_pitch, cursor->image.height, GFP_ATOMIC);

drivers/video/fbdev/riva/fbdev.c

1572

switch (cursor->rop) {

drivers/video/fbdev/riva/fbdev.c

1574

for (i = 0; i < s_pitch * cursor->image.height; i++)

drivers/video/fbdev/riva/fbdev.c

1579

for (i = 0; i < s_pitch * cursor->image.height; i++)

drivers/video/fbdev/riva/fbdev.c

1585

cursor->image.height);

drivers/video/fbdev/riva/fbdev.c

1600

cursor->image.width,

drivers/video/fbdev/riva/fbdev.c

1601

cursor->image.height);

drivers/video/fbdev/riva/fbdev.c

1606

if (cursor->enable)

drivers/video/fbdev/riva/riva_hw.c

125

int cursor;

drivers/video/fbdev/riva/riva_hw.c

126

cursor = chip->CurrentState->cursor1;

drivers/video/fbdev/riva/riva_hw.c

131

return (cursor & 0x01);

drivers/video/fbdev/s3fb.c

316

static void s3fb_tilecursor(struct fb_info *info, struct fb_tilecursor *cursor)

drivers/video/fbdev/s3fb.c

320

svga_tilecursor(par->state.vgabase, info, cursor);

drivers/video/fbdev/skeletonfb.c

579

int xxxfb_cursor(struct fb_info *info, struct fb_cursor *cursor)

drivers/video/fbdev/sm501fb.c

1047

static int sm501fb_cursor(struct fb_info *info, struct fb_cursor *cursor)

drivers/video/fbdev/sm501fb.c

1055

dev_dbg(fbi->dev, "%s(%p,%p)\n", __func__, info, cursor);

drivers/video/fbdev/sm501fb.c

1064

if (cursor->image.width > 64)

drivers/video/fbdev/sm501fb.c

1067

if (cursor->image.height > 64)

drivers/video/fbdev/sm501fb.c

107

struct sm501_mem cursor;

drivers/video/fbdev/sm501fb.c

1070

if (cursor->image.depth > 1)

drivers/video/fbdev/sm501fb.c

1075

if (cursor->enable)

drivers/video/fbdev/sm501fb.c

1083

if (cursor->set & FB_CUR_SETPOS) {

drivers/video/fbdev/sm501fb.c

1084

unsigned int x = cursor->image.dx;

drivers/video/fbdev/sm501fb.c

1085

unsigned int y = cursor->image.dy;

drivers/video/fbdev/sm501fb.c

1097

if (cursor->set & FB_CUR_SETCMAP) {

drivers/video/fbdev/sm501fb.c

1098

unsigned int bg_col = cursor->image.bg_color;

drivers/video/fbdev/sm501fb.c

1099

unsigned int fg_col = cursor->image.fg_color;

drivers/video/fbdev/sm501fb.c

1118

if (cursor->set & FB_CUR_SETSIZE ||

drivers/video/fbdev/sm501fb.c

1119

cursor->set & (FB_CUR_SETIMAGE | FB_CUR_SETSHAPE)) {

drivers/video/fbdev/sm501fb.c

1125

const unsigned char *pcol = cursor->image.data;

drivers/video/fbdev/sm501fb.c

1126

const unsigned char *pmsk = cursor->mask;

drivers/video/fbdev/sm501fb.c

1127

void __iomem *dst = par->cursor.k_addr;

drivers/video/fbdev/sm501fb.c

1133

__func__, cursor->image.width, cursor->image.height);

drivers/video/fbdev/sm501fb.c

1138

for (y = 0; y < cursor->image.height; y++) {

drivers/video/fbdev/sm501fb.c

1139

for (x = 0; x < cursor->image.width; x++) {

drivers/video/fbdev/sm501fb.c

1513

ret = sm501_alloc_mem(info, &par->cursor, SM501_MEMF_CURSOR, 1024,

drivers/video/fbdev/sm501fb.c

1520

smc501_writel(par->cursor.sm_addr,

drivers/video/fbdev/sm501fb.c

2121

par->store_cursor = vmalloc(par->cursor.size);

drivers/video/fbdev/sm501fb.c

2131

memcpy_fromio(par->store_cursor, par->cursor.k_addr, par->cursor.size);

drivers/video/fbdev/sm501fb.c

2169

memcpy_toio(par->cursor.k_addr, par->store_cursor,

drivers/video/fbdev/sm501fb.c

2170

par->cursor.size);

drivers/video/fbdev/tcx.c

98

u32 cursor;

drivers/video/fbdev/tdfxfb.c

1045

static int tdfxfb_cursor(struct fb_info *info, struct fb_cursor *cursor)

drivers/video/fbdev/tdfxfb.c

1054

if (cursor->image.width > 64 ||

drivers/video/fbdev/tdfxfb.c

1055

cursor->image.height > 64 ||

drivers/video/fbdev/tdfxfb.c

1056

cursor->image.depth > 1)

drivers/video/fbdev/tdfxfb.c

1060

if (cursor->enable)

drivers/video/fbdev/tdfxfb.c

1070

if (!cursor->set)

drivers/video/fbdev/tdfxfb.c

1074

if (cursor->set & FB_CUR_SETCMAP) {

drivers/video/fbdev/tdfxfb.c

1076

u32 bg_idx = cursor->image.bg_color;

drivers/video/fbdev/tdfxfb.c

1077

u32 fg_idx = cursor->image.fg_color;

drivers/video/fbdev/tdfxfb.c

1091

if (cursor->set & FB_CUR_SETPOS) {

drivers/video/fbdev/tdfxfb.c

1092

int x = cursor->image.dx;

drivers/video/fbdev/tdfxfb.c

1093

int y = cursor->image.dy - info->var.yoffset;

drivers/video/fbdev/tdfxfb.c

1100

if (cursor->set & (FB_CUR_SETIMAGE | FB_CUR_SETSHAPE)) {

drivers/video/fbdev/tdfxfb.c

1120

u8 *bitmap = (u8 *)cursor->image.data;

drivers/video/fbdev/tdfxfb.c

1121

u8 *mask = (u8 *)cursor->mask;

drivers/video/fbdev/tdfxfb.c

1126

for (i = 0; i < cursor->image.height; i++) {

drivers/video/fbdev/tdfxfb.c

1128

int j = (cursor->image.width + 7) >> 3;

drivers/video/fbdev/tdfxfb.c

1132

if (cursor->rop == ROP_COPY)

drivers/video/fbdev/via/viafbdev.c

758

static int viafb_cursor(struct fb_info *info, struct fb_cursor *cursor)

drivers/video/fbdev/via/viafbdev.c

776

if (cursor->set & FB_CUR_SETHOT) {

drivers/video/fbdev/via/viafbdev.c

777

temp = (cursor->hot.x << 16) + cursor->hot.y;

drivers/video/fbdev/via/viafbdev.c

781

if (cursor->set & FB_CUR_SETPOS) {

drivers/video/fbdev/via/viafbdev.c

782

yy = cursor->image.dy - info->var.yoffset;

drivers/video/fbdev/via/viafbdev.c

783

xx = cursor->image.dx - info->var.xoffset;

drivers/video/fbdev/via/viafbdev.c

789

if (cursor->image.width <= 32 && cursor->image.height <= 32)

drivers/video/fbdev/via/viafbdev.c

791

else if (cursor->image.width <= 64 && cursor->image.height <= 64)

drivers/video/fbdev/via/viafbdev.c

795

"%dx%d", cursor->image.width, cursor->image.height);

drivers/video/fbdev/via/viafbdev.c

799

if (cursor->set & FB_CUR_SETSIZE) {

drivers/video/fbdev/via/viafbdev.c

809

if (cursor->set & FB_CUR_SETCMAP) {

drivers/video/fbdev/via/viafbdev.c

810

fg_color = cursor->image.fg_color;

drivers/video/fbdev/via/viafbdev.c

811

bg_color = cursor->image.bg_color;

drivers/video/fbdev/via/viafbdev.c

839

if (cursor->set & FB_CUR_SETSHAPE) {

drivers/video/fbdev/via/viafbdev.c

844

int size = ((cursor->image.width + 7) >> 3) *

drivers/video/fbdev/via/viafbdev.c

845

cursor->image.height;

drivers/video/fbdev/via/viafbdev.c

866

switch (cursor->rop) {

drivers/video/fbdev/via/viafbdev.c

869

cr_data->data[i] = cursor->mask[i];

drivers/video/fbdev/via/viafbdev.c

874

cr_data->data[i] = cursor->mask[i];

drivers/video/fbdev/via/viafbdev.c

901

if (cursor->enable)

drivers/video/fbdev/vt8623fb.c

115

static void vt8623fb_tilecursor(struct fb_info *info, struct fb_tilecursor *cursor)

drivers/video/fbdev/vt8623fb.c

119

svga_tilecursor(par->state.vgabase, info, cursor);

fs/afs/cell.c

247

struct afs_cell *cell, *candidate, *cursor;

fs/afs/cell.c

288

cursor = rb_entry(parent, struct afs_cell, net_node);

fs/afs/cell.c

290

n = strncasecmp(cursor->name, name,

fs/afs/cell.c

291

min_t(size_t, cursor->name_len, namesz));

fs/afs/cell.c

293

n = cursor->name_len - namesz;

fs/afs/cell.c

390

cell = cursor;

fs/afs/cell.c

394

afs_use_cell(cursor, trace);

fs/afs/cell.c

911

struct rb_node *cursor;

fs/afs/cell.c

923

for (cursor = rb_first(&net->cells); cursor; cursor = rb_next(cursor)) {

fs/afs/cell.c

924

struct afs_cell *cell = rb_entry(cursor, struct afs_cell, net_node);

fs/ceph/metric.c

113

void *cursor;

fs/ceph/metric.c

280

cursor = wsize + 1;

fs/ceph/metric.c

288

ceph_encode_32(&cursor, CLIENT_METRIC_TYPE_SUBVOLUME_METRICS);

fs/ceph/metric.c

291

payload = cursor;

fs/ceph/metric.c

306

cursor = payload;

fs/ceph/metric.c

310

msg->front.iov_len = (char *)cursor - (char *)head;

fs/configfs/dir.c

1617

struct configfs_dirent * cursor = file->private_data;

fs/configfs/dir.c

1621

list_del_init(&cursor->s_sibling);

fs/configfs/dir.c

1625

release_configfs_dirent(cursor);

fs/configfs/dir.c

1635

struct configfs_dirent *cursor = file->private_data;

fs/configfs/dir.c

1636

struct list_head *p, *q = &cursor->s_sibling;

fs/configfs/dir.c

1711

struct configfs_dirent *cursor = file->private_data;

fs/configfs/dir.c

1716

list_del(&cursor->s_sibling);

fs/configfs/dir.c

1726

list_add_tail(&cursor->s_sibling, p);

fs/libfs.c

107

static struct dentry *scan_positives(struct dentry *cursor,

fs/libfs.c

112

struct dentry *dentry = cursor->d_parent, *found = NULL;

fs/libfs.c

131

if (!hlist_unhashed(&cursor->d_sib))

fs/libfs.c

132

__hlist_del(&cursor->d_sib);

fs/libfs.c

133

hlist_add_behind(&cursor->d_sib, &d->d_sib);

fs/libfs.c

134

p = &cursor->d_sib.next;

fs/libfs.c

160

struct dentry *cursor = file->private_data;

fs/libfs.c

166

to = scan_positives(cursor, &dentry->d_children.first,

fs/libfs.c

169

hlist_del_init(&cursor->d_sib);

fs/libfs.c

171

hlist_add_behind(&cursor->d_sib, &to->d_sib);

fs/libfs.c

192

struct dentry *cursor = file->private_data;

fs/libfs.c

202

p = &cursor->d_sib.next;

fs/libfs.c

204

while ((next = scan_positives(cursor, p, 1, next)) != NULL) {

fs/libfs.c

213

hlist_del_init(&cursor->d_sib);

fs/libfs.c

215

hlist_add_before(&cursor->d_sib, &next->d_sib);

fs/netfs/fscache_cookie.c

403

struct fscache_cookie *cursor, *wait_for = NULL;

fs/netfs/fscache_cookie.c

412

hlist_bl_for_each_entry(cursor, p, h, hash_link) {

fs/netfs/fscache_cookie.c

413

if (fscache_cookie_same(candidate, cursor)) {

fs/netfs/fscache_cookie.c

414

if (!test_bit(FSCACHE_COOKIE_RELINQUISHED, &cursor->flags))

fs/netfs/fscache_cookie.c

416

wait_for = fscache_get_cookie(cursor,

fs/netfs/fscache_cookie.c

435

trace_fscache_cookie(cursor->debug_id, refcount_read(&cursor->ref),

fs/netfs/fscache_cookie.c

438

fscache_print_cookie(cursor, 'O');

fs/netfs/fscache_volume.c

175

struct fscache_volume *cursor;

fs/netfs/fscache_volume.c

184

hlist_bl_for_each_entry(cursor, p, h, hash_link) {

fs/netfs/fscache_volume.c

185

if (fscache_volume_same(candidate, cursor)) {

fs/netfs/fscache_volume.c

186

if (!test_bit(FSCACHE_VOLUME_RELINQUISHED, &cursor->flags))

fs/netfs/fscache_volume.c

188

fscache_see_volume(cursor, fscache_volume_get_hash_collision);

fs/netfs/fscache_volume.c

189

set_bit(FSCACHE_VOLUME_COLLIDED_WITH, &cursor->flags);

fs/netfs/fscache_volume.c

191

collidee_debug_id = cursor->debug_id;

fs/netfs/fscache_volume.c

204

fscache_see_volume(cursor, fscache_volume_collision);

fs/netfs/fscache_volume.c

355

struct fscache_volume *cursor;

fs/netfs/fscache_volume.c

358

hlist_bl_for_each_entry(cursor, p, h, hash_link) {

fs/netfs/fscache_volume.c

359

if (fscache_volume_same(cursor, volume)) {

fs/netfs/fscache_volume.c

360

fscache_see_volume(cursor, fscache_volume_see_hash_wake);

fs/netfs/fscache_volume.c

362

&cursor->flags);

fs/overlayfs/readdir.c

411

od->cursor = NULL;

fs/overlayfs/readdir.c

479

od->cursor = p;

fs/overlayfs/readdir.c

63

struct list_head *cursor;

fs/overlayfs/readdir.c

854

while (od->cursor != &od->cache->entries) {

fs/overlayfs/readdir.c

855

p = list_entry(od->cursor, struct ovl_cache_entry, l_node);

fs/overlayfs/readdir.c

868

od->cursor = p->l_node.next;

fs/unicode/mkutf8data.c

537

void **cursor;

fs/unicode/mkutf8data.c

543

cursor = &tree->root;

fs/unicode/mkutf8data.c

548

if (!*cursor)

fs/unicode/mkutf8data.c

549

*cursor = alloc_node(node);

fs/unicode/mkutf8data.c

550

node = *cursor;

fs/unicode/mkutf8data.c

554

cursor = &node->right;

fs/unicode/mkutf8data.c

556

cursor = &node->left;

fs/unicode/mkutf8data.c

559

*cursor = leaf;

fs/vboxsf/utils.c

22

int cursor, ret;

fs/vboxsf/utils.c

31

cursor = idr_get_cursor(&sbi->ino_idr);

fs/vboxsf/utils.c

33

if (ret >= 0 && ret < cursor)

fs/xfs/libxfs/xfs_attr.h

57

struct xfs_attrlist_cursor_kern cursor; /* position in list */

fs/xfs/scrub/dirtree.c

598

xfs_ino_t *cursor)

fs/xfs/scrub/dirtree.c

601

xfs_ino_t child_ino = *cursor;

fs/xfs/scrub/dirtree.c

607

*cursor = be64_to_cpu(step.pptr_rec.p_ino);

fs/xfs/scrub/dirtree.c

613

if (I_INO(p->ip) != child_ino || I_INO(p->dp) != *cursor)

fs/xfs/scrub/dirtree.c

663

xfs_ino_t cursor = dl->scan_ino;

fs/xfs/scrub/dirtree.c

675

ret = xchk_dirpath_step_is_stale(dl, path, 0, idx, p, &cursor);

fs/xfs/scrub/dirtree.c

680

ret = xchk_dirpath_step_is_stale(dl, path, i, idx, p, &cursor);

fs/xfs/scrub/dqiterate.c

100

fileoff = cursor->bmap.br_startoff + cursor->bmap.br_blockcount;

fs/xfs/scrub/dqiterate.c

107

error = xfs_bmapi_read(cursor->quota_ip, fileoff,

fs/xfs/scrub/dqiterate.c

108

XFS_MAX_FILEOFF - fileoff, &cursor->bmap,

fs/xfs/scrub/dqiterate.c

117

if (cursor->bmap.br_startoff > fileoff) {

fs/xfs/scrub/dqiterate.c

118

ASSERT(cursor->bmap.br_startoff == fileoff);

fs/xfs/scrub/dqiterate.c

121

} while (!xfs_bmap_is_real_extent(&cursor->bmap));

fs/xfs/scrub/dqiterate.c

123

next_id = cursor->bmap.br_startoff * qi->qi_dqperchunk;

fs/xfs/scrub/dqiterate.c

132

cursor->if_seq = ifp->if_seq;

fs/xfs/scrub/dqiterate.c

133

trace_xchk_dquot_iter_advance_bmap(cursor, *next_ondisk_id);

fs/xfs/scrub/dqiterate.c

145

struct xchk_dqiter *cursor,

fs/xfs/scrub/dqiterate.c

148

struct xfs_quotainfo *qi = cursor->sc->mp->m_quotainfo;

fs/xfs/scrub/dqiterate.c

149

struct radix_tree_root *tree = xfs_dquot_tree(qi, cursor->dqtype);

fs/xfs/scrub/dqiterate.c

156

nr_found = radix_tree_gang_lookup(tree, (void **)&dq, cursor->id, 1);

fs/xfs/scrub/dqiterate.c

161

trace_xchk_dquot_iter_advance_incore(cursor, *next_incore_id);

fs/xfs/scrub/dqiterate.c

172

struct xchk_dqiter *cursor,

fs/xfs/scrub/dqiterate.c

175

struct xfs_mount *mp = cursor->sc->mp;

fs/xfs/scrub/dqiterate.c

181

if (cursor->id > XFS_DQ_ID_MAX)

fs/xfs/scrub/dqiterate.c

183

next_ondisk = cursor->id;

fs/xfs/scrub/dqiterate.c

186

lock_mode = xfs_ilock_data_map_shared(cursor->quota_ip);

fs/xfs/scrub/dqiterate.c

187

error = xchk_dquot_iter_revalidate_bmap(cursor);

fs/xfs/scrub/dqiterate.c

188

if (!error && !xfs_bmap_is_real_extent(&cursor->bmap))

fs/xfs/scrub/dqiterate.c

189

error = xchk_dquot_iter_advance_bmap(cursor, &next_ondisk);

fs/xfs/scrub/dqiterate.c

190

xfs_iunlock(cursor->quota_ip, lock_mode);

fs/xfs/scrub/dqiterate.c

194

if (next_ondisk > cursor->id)

fs/xfs/scrub/dqiterate.c

195

xchk_dquot_iter_advance_incore(cursor, &next_incore);

fs/xfs/scrub/dqiterate.c

198

cursor->id = min(next_ondisk, next_incore);

fs/xfs/scrub/dqiterate.c

199

if (cursor->id > XFS_DQ_ID_MAX)

fs/xfs/scrub/dqiterate.c

202

trace_xchk_dquot_iter(cursor, cursor->id);

fs/xfs/scrub/dqiterate.c

204

error = xfs_qm_dqget(mp, cursor->id, cursor->dqtype, false, &dq);

fs/xfs/scrub/dqiterate.c

208

cursor->id = (uint64_t)dq->q_id + 1;

fs/xfs/scrub/dqiterate.c

27

struct xchk_dqiter *cursor,

fs/xfs/scrub/dqiterate.c

31

cursor->sc = sc;

fs/xfs/scrub/dqiterate.c

32

cursor->bmap.br_startoff = NULLFILEOFF;

fs/xfs/scrub/dqiterate.c

33

cursor->dqtype = dqtype & XFS_DQTYPE_REC_MASK;

fs/xfs/scrub/dqiterate.c

34

cursor->quota_ip = xfs_quota_inode(sc->mp, cursor->dqtype);

fs/xfs/scrub/dqiterate.c

35

cursor->id = 0;

fs/xfs/scrub/dqiterate.c

44

struct xchk_dqiter *cursor)

fs/xfs/scrub/dqiterate.c

46

struct xfs_quotainfo *qi = cursor->sc->mp->m_quotainfo;

fs/xfs/scrub/dqiterate.c

47

struct xfs_ifork *ifp = xfs_ifork_ptr(cursor->quota_ip,

fs/xfs/scrub/dqiterate.c

50

xfs_dqid_t this_id = cursor->id;

fs/xfs/scrub/dqiterate.c

60

if (cursor->bmap.br_startoff != NULLFILEOFF &&

fs/xfs/scrub/dqiterate.c

61

cursor->if_seq == ifp->if_seq &&

fs/xfs/scrub/dqiterate.c

62

cursor->bmap.br_startoff + cursor->bmap.br_blockcount > fileoff)

fs/xfs/scrub/dqiterate.c

66

error = xfs_bmapi_read(cursor->quota_ip, fileoff,

fs/xfs/scrub/dqiterate.c

67

XFS_MAX_FILEOFF - fileoff, &cursor->bmap, &nmaps, 0);

fs/xfs/scrub/dqiterate.c

74

if (cursor->bmap.br_startoff > fileoff) {

fs/xfs/scrub/dqiterate.c

75

ASSERT(cursor->bmap.br_startoff == fileoff);

fs/xfs/scrub/dqiterate.c

79

cursor->if_seq = ifp->if_seq;

fs/xfs/scrub/dqiterate.c

80

trace_xchk_dquot_iter_revalidate_bmap(cursor, cursor->id);

fs/xfs/scrub/dqiterate.c

87

struct xchk_dqiter *cursor,

fs/xfs/scrub/dqiterate.c

90

struct xfs_quotainfo *qi = cursor->sc->mp->m_quotainfo;

fs/xfs/scrub/dqiterate.c

91

struct xfs_ifork *ifp = xfs_ifork_ptr(cursor->quota_ip,

fs/xfs/scrub/iscan.c

101

xfs_agino_t agino = *cursor;

fs/xfs/scrub/iscan.c

108

*cursor = NULLAGINO;

fs/xfs/scrub/iscan.c

129

*cursor = NULLAGINO;

fs/xfs/scrub/iscan.c

178

*cursor = rec.ir_startino + next;

fs/xfs/scrub/iscan.c

206

xfs_ino_t cursor, visited;

fs/xfs/scrub/iscan.c

215

cursor = XFS_AGINO_TO_INO(mp, agno, agino);

fs/xfs/scrub/iscan.c

216

if (cursor == 0)

fs/xfs/scrub/iscan.c

219

visited = cursor - 1;

fs/xfs/scrub/iscan.c

222

iscan->cursor_ino = cursor;

fs/xfs/scrub/iscan.c

90

xfs_agino_t *cursor,

fs/xfs/scrub/quota.c

305

struct xchk_dqiter cursor = { };

fs/xfs/scrub/quota.c

330

xchk_dqiter_init(&cursor, sc, dqtype);

fs/xfs/scrub/quota.c

331

while ((error = xchk_dquot_iter(&cursor, &dq)) == 1) {

fs/xfs/scrub/quota.h

32

void xchk_dqiter_init(struct xchk_dqiter *cursor, struct xfs_scrub *sc,

fs/xfs/scrub/quota.h

34

int xchk_dquot_iter(struct xchk_dqiter *cursor, struct xfs_dquot **dqpp);

fs/xfs/scrub/quota_repair.c

506

struct xchk_dqiter cursor = { };

fs/xfs/scrub/quota_repair.c

511

xchk_dqiter_init(&cursor, sc, dqtype);

fs/xfs/scrub/quota_repair.c

512

while ((error = xchk_dquot_iter(&cursor, &dq)) == 1) {

fs/xfs/scrub/quotacheck.c

658

struct xchk_dqiter cursor = { };

fs/xfs/scrub/quotacheck.c

673

xchk_dqiter_init(&cursor, sc, dqtype);

fs/xfs/scrub/quotacheck.c

674

while ((error = xchk_dquot_iter(&cursor, &dq)) == 1) {

fs/xfs/scrub/quotacheck_repair.c

131

struct xchk_dqiter cursor = { };

fs/xfs/scrub/quotacheck_repair.c

143

xchk_dqiter_init(&cursor, sc, dqtype);

fs/xfs/scrub/quotacheck_repair.c

144

while ((error = xchk_dquot_iter(&cursor, &dq)) == 1) {

fs/xfs/scrub/trace.h

1283

__field(xfs_ino_t, cursor)

fs/xfs/scrub/trace.h

1288

__entry->cursor = iscan->cursor_ino;

fs/xfs/scrub/trace.h

1293

__entry->cursor,

fs/xfs/scrub/trace.h

1311

__field(xfs_ino_t, cursor)

fs/xfs/scrub/trace.h

1318

__entry->cursor = iscan->cursor_ino;

fs/xfs/scrub/trace.h

1325

__entry->cursor,

fs/xfs/scrub/trace.h

1341

__field(xfs_ino_t, cursor)

fs/xfs/scrub/trace.h

1347

__entry->cursor = iscan->cursor_ino;

fs/xfs/scrub/trace.h

1353

__entry->cursor,

fs/xfs/scrub/trace.h

1364

__field(xfs_ino_t, cursor)

fs/xfs/scrub/trace.h

1374

__entry->cursor = iscan->cursor_ino;

fs/xfs/scrub/trace.h

1384

__entry->cursor,

fs/xfs/scrub/trace.h

1398

__field(xfs_ino_t, cursor)

fs/xfs/scrub/trace.h

1406

__entry->cursor = iscan->cursor_ino;

fs/xfs/scrub/trace.h

1414

__entry->cursor,

fs/xfs/scrub/trace.h

468

TP_PROTO(struct xchk_dqiter *cursor, uint64_t id),

fs/xfs/scrub/trace.h

469

TP_ARGS(cursor, id),

fs/xfs/scrub/trace.h

482

__entry->dev = cursor->sc->mp->m_super->s_dev;

fs/xfs/scrub/trace.h

483

__entry->dqtype = cursor->dqtype;

fs/xfs/scrub/trace.h

484

__entry->ino = I_INO(cursor->quota_ip);

fs/xfs/scrub/trace.h

485

__entry->cur_id = cursor->id;

fs/xfs/scrub/trace.h

486

__entry->startoff = cursor->bmap.br_startoff;

fs/xfs/scrub/trace.h

487

__entry->startblock = cursor->bmap.br_startblock;

fs/xfs/scrub/trace.h

488

__entry->blockcount = cursor->bmap.br_blockcount;

fs/xfs/scrub/trace.h

489

__entry->state = cursor->bmap.br_state;

fs/xfs/scrub/trace.h

506

TP_PROTO(struct xchk_dqiter *cursor, uint64_t id), \

fs/xfs/scrub/trace.h

507

TP_ARGS(cursor, id))

fs/xfs/xfs_attr_list.c

164

cursor->initted = 1;

fs/xfs/xfs_attr_list.c

165

cursor->blkno = 0;

fs/xfs/xfs_attr_list.c

167

if (sbp->hash == cursor->hashval) {

fs/xfs/xfs_attr_list.c

168

if (cursor->offset == count) {

fs/xfs/xfs_attr_list.c

172

} else if (sbp->hash > cursor->hashval) {

fs/xfs/xfs_attr_list.c

183

if (cursor->hashval != sbp->hash) {

fs/xfs/xfs_attr_list.c

184

cursor->hashval = sbp->hash;

fs/xfs/xfs_attr_list.c

185

cursor->offset = 0;

fs/xfs/xfs_attr_list.c

202

cursor->offset++;

fs/xfs/xfs_attr_list.c

216

struct xfs_attrlist_cursor_kern *cursor,

fs/xfs/xfs_attr_list.c

233

cursor->blkno = 0;

fs/xfs/xfs_attr_list.c

235

error = xfs_da3_node_read(tp, dp, cursor->blkno, &bp,

fs/xfs/xfs_attr_list.c

262

if (cursor->blkno == 0)

fs/xfs/xfs_attr_list.c

271

if (cursor->hashval <= be32_to_cpu(btree->hashval)) {

fs/xfs/xfs_attr_list.c

272

cursor->blkno = be32_to_cpu(btree->before);

fs/xfs/xfs_attr_list.c

284

if (XFS_IS_CORRUPT(mp, cursor->blkno == 0)) {

fs/xfs/xfs_attr_list.c

314

struct xfs_attrlist_cursor_kern *cursor = &context->cursor;

fs/xfs/xfs_attr_list.c

326

cursor->initted = 1;

fs/xfs/xfs_attr_list.c

334

if (cursor->blkno > 0) {

fs/xfs/xfs_attr_list.c

337

error = xfs_da3_node_read(context->tp, dp, cursor->blkno, &bp,

fs/xfs/xfs_attr_list.c

373

if (cursor->hashval > be32_to_cpu(

fs/xfs/xfs_attr_list.c

378

} else if (cursor->hashval <= be32_to_cpu(

fs/xfs/xfs_attr_list.c

399

error = xfs_attr_node_list_lookup(context, cursor, &bp);

fs/xfs/xfs_attr_list.c

418

cursor->blkno = leafhdr.forw;

fs/xfs/xfs_attr_list.c

421

cursor->blkno, &bp);

fs/xfs/xfs_attr_list.c

43

#define XFS_ISRESET_CURSOR(cursor) \

fs/xfs/xfs_attr_list.c

437

struct xfs_attrlist_cursor_kern *cursor = &context->cursor;

fs/xfs/xfs_attr_list.c

44

(!((cursor)->initted) && !((cursor)->hashval) && \

fs/xfs/xfs_attr_list.c

45

!((cursor)->blkno) && !((cursor)->offset))

fs/xfs/xfs_attr_list.c

451

cursor->initted = 1;

fs/xfs/xfs_attr_list.c

459

if (be32_to_cpu(entry->hashval) == cursor->hashval) {

fs/xfs/xfs_attr_list.c

460

if (cursor->offset == context->dupcnt) {

fs/xfs/xfs_attr_list.c

466

cursor->hashval) {

fs/xfs/xfs_attr_list.c

489

if (be32_to_cpu(entry->hashval) != cursor->hashval) {

fs/xfs/xfs_attr_list.c

490

cursor->hashval = be32_to_cpu(entry->hashval);

fs/xfs/xfs_attr_list.c

491

cursor->offset = 0;

fs/xfs/xfs_attr_list.c

526

cursor->offset++;

fs/xfs/xfs_attr_list.c

544

context->cursor.blkno = 0;

fs/xfs/xfs_attr_list.c

57

struct xfs_attrlist_cursor_kern *cursor = &context->cursor;

fs/xfs/xfs_attr_list.c

81

(XFS_ISRESET_CURSOR(cursor) &&

fs/xfs/xfs_handle.c

427

if (copy_from_user(&context.cursor, ucursor, sizeof(context.cursor)))

fs/xfs/xfs_handle.c

429

if (context.cursor.pad1 || context.cursor.pad2)

fs/xfs/xfs_handle.c

431

if (!context.cursor.initted &&

fs/xfs/xfs_handle.c

432

(context.cursor.hashval || context.cursor.blkno ||

fs/xfs/xfs_handle.c

433

context.cursor.offset))

fs/xfs/xfs_handle.c

461

copy_to_user(ucursor, &context.cursor, sizeof(context.cursor)))

fs/xfs/xfs_handle.c

790

memcpy(&gpx->context.cursor, &gp->gp_cursor,

fs/xfs/xfs_handle.c

795

trace_xfs_getparents_begin(ip, gp, &gpx->context.cursor);

fs/xfs/xfs_handle.c

807

memcpy(&gp->gp_cursor, &gpx->context.cursor,

fs/xfs/xfs_handle.c

830

trace_xfs_getparents_end(ip, gp, &gpx->context.cursor);

fs/xfs/xfs_trace.h

136

__entry->hashval = ctx->cursor.hashval;

fs/xfs/xfs_trace.h

137

__entry->blkno = ctx->cursor.blkno;

fs/xfs/xfs_trace.h

138

__entry->offset = ctx->cursor.offset;

fs/xfs/xfs_trace.h

638

__entry->hashval = ctx->cursor.hashval;

fs/xfs/xfs_trace.h

639

__entry->blkno = ctx->cursor.blkno;

fs/xfs/xfs_trace.h

640

__entry->offset = ctx->cursor.offset;

include/drm/drm_crtc.h

1003

struct drm_plane *cursor;

include/drm/drm_crtc.h

1240

struct drm_plane *cursor,

include/drm/drm_crtc.h

1248

struct drm_plane *cursor,

include/drm/drm_crtc.h

1258

struct drm_plane *cursor,

include/drm/drm_crtc.h

1281

#define drmm_crtc_alloc_with_planes(dev, type, member, primary, cursor, funcs, name, ...) \

include/drm/drm_crtc.h

1284

primary, cursor, funcs, \

include/drm/drm_kunit_helpers.h

118

struct drm_plane *cursor,

include/drm/ttm/ttm_resource.h

347

void ttm_resource_cursor_init(struct ttm_resource_cursor *cursor,

include/drm/ttm/ttm_resource.h

350

void ttm_resource_cursor_fini(struct ttm_resource_cursor *cursor);

include/drm/ttm/ttm_resource.h

488

ttm_resource_manager_first(struct ttm_resource_cursor *cursor);

include/drm/ttm/ttm_resource.h

490

ttm_resource_manager_next(struct ttm_resource_cursor *cursor);

include/drm/ttm/ttm_resource.h

502

#define ttm_resource_manager_for_each_res(cursor, res) \

include/drm/ttm/ttm_resource.h

503

for (res = ttm_resource_manager_first(cursor); res; \

include/drm/ttm/ttm_resource.h

504

res = ttm_resource_manager_next(cursor))

include/linux/ceph/messenger.h

279

struct ceph_msg_data_cursor cursor;

include/linux/ceph/messenger.h

537

void ceph_msg_data_cursor_init(struct ceph_msg_data_cursor *cursor,

include/linux/ceph/messenger.h

539

struct page *ceph_msg_data_next(struct ceph_msg_data_cursor *cursor,

include/linux/ceph/messenger.h

541

void ceph_msg_data_advance(struct ceph_msg_data_cursor *cursor, size_t bytes);

include/linux/ceph/messenger.h

96

struct ceph_msg_data_cursor *cursor,

include/linux/dma-fence-unwrap.h

34

struct dma_fence_unwrap *cursor);

include/linux/dma-fence-unwrap.h

35

struct dma_fence *dma_fence_unwrap_next(struct dma_fence_unwrap *cursor);

include/linux/dma-fence-unwrap.h

47

#define dma_fence_unwrap_for_each(fence, cursor, head) \

include/linux/dma-fence-unwrap.h

48

for (fence = dma_fence_unwrap_first(head, cursor); fence; \

include/linux/dma-fence-unwrap.h

49

fence = dma_fence_unwrap_next(cursor))

include/linux/dma-resv.h

219

struct dma_fence *dma_resv_iter_first_unlocked(struct dma_resv_iter *cursor);

include/linux/dma-resv.h

220

struct dma_fence *dma_resv_iter_next_unlocked(struct dma_resv_iter *cursor);

include/linux/dma-resv.h

221

struct dma_fence *dma_resv_iter_first(struct dma_resv_iter *cursor);

include/linux/dma-resv.h

222

struct dma_fence *dma_resv_iter_next(struct dma_resv_iter *cursor);

include/linux/dma-resv.h

230

static inline void dma_resv_iter_begin(struct dma_resv_iter *cursor,

include/linux/dma-resv.h

234

cursor->obj = obj;

include/linux/dma-resv.h

235

cursor->usage = usage;

include/linux/dma-resv.h

236

cursor->fence = NULL;

include/linux/dma-resv.h

246

static inline void dma_resv_iter_end(struct dma_resv_iter *cursor)

include/linux/dma-resv.h

248

dma_fence_put(cursor->fence);

include/linux/dma-resv.h

258

dma_resv_iter_usage(struct dma_resv_iter *cursor)

include/linux/dma-resv.h

260

return cursor->fence_usage;

include/linux/dma-resv.h

269

static inline bool dma_resv_iter_is_restarted(struct dma_resv_iter *cursor)

include/linux/dma-resv.h

271

return cursor->is_restarted;

include/linux/dma-resv.h

289

#define dma_resv_for_each_fence_unlocked(cursor, fence) \

include/linux/dma-resv.h

290

for (fence = dma_resv_iter_first_unlocked(cursor); \

include/linux/dma-resv.h

291

fence; fence = dma_resv_iter_next_unlocked(cursor))

include/linux/dma-resv.h

306

#define dma_resv_for_each_fence(cursor, obj, usage, fence) \

include/linux/dma-resv.h

307

for (dma_resv_iter_begin(cursor, obj, usage), \

include/linux/dma-resv.h

308

fence = dma_resv_iter_first(cursor); fence; \

include/linux/dma-resv.h

309

fence = dma_resv_iter_next(cursor))

include/linux/fb.h

284

int (*fb_cursor) (struct fb_info *info, struct fb_cursor *cursor);

include/linux/fb.h

379

struct fb_tilecursor *cursor);

include/linux/fsl-diu-fb.h

141

__be32 cursor;

include/linux/io.h

191

u64 cursor = from;

include/linux/io.h

193

while (cursor < to) {

include/linux/io.h

196

cursor += PAGE_SIZE;

include/linux/libata.h

689

int cursor;

include/linux/svga.h

113

void svga_tilecursor(void __iomem *regbase, struct fb_info *info, struct fb_tilecursor *cursor);

include/media/media-entity.h

139

struct list_head *cursor;

include/media/media-entity.h

150

struct list_head *cursor;

kernel/audit_tree.c

675

struct list_head cursor;

kernel/audit_tree.c

678

list_add(&cursor, &tree_list);

kernel/audit_tree.c

679

while (cursor.next != &tree_list) {

kernel/audit_tree.c

687

tree = container_of(cursor.next, struct audit_tree, list);

kernel/audit_tree.c

689

list_move(&cursor, &tree->list);

kernel/audit_tree.c

721

list_del(&cursor);

kernel/audit_tree.c

878

struct list_head cursor, barrier;

kernel/audit_tree.c

901

list_add(&cursor, &barrier);

kernel/audit_tree.c

903

while (cursor.next != &tree_list) {

kernel/audit_tree.c

907

tree = container_of(cursor.next, struct audit_tree, list);

kernel/audit_tree.c

909

list_move(&cursor, &tree->list);

kernel/audit_tree.c

962

list_del(&cursor);

kernel/bpf/hashtab.c

3254

void *cursor = NULL, *keys = NULL, *values = NULL, *dst_key, *dst_val;

kernel/bpf/hashtab.c

3286

cursor = kmalloc(key_size, GFP_USER | __GFP_NOWARN);

kernel/bpf/hashtab.c

3288

if (!keys || !values || !cursor || (do_delete && !del_elems)) {

kernel/bpf/hashtab.c

3293

if (ubatch && copy_from_user(cursor, ubatch, key_size)) {

kernel/bpf/hashtab.c

3313

elem = rhtab_lookup_elem(map, cursor);

kernel/bpf/hashtab.c

3343

memcpy(cursor, elem->data, key_size);

kernel/bpf/hashtab.c

3368

cursor, key_size))) {

kernel/bpf/hashtab.c

3374

kfree(cursor);

kernel/sched/ext/ext.c

189

s32 cursor;

kernel/sched/ext/ext.c

2753

for (u = 0; u < dspc->cursor; u++) {

kernel/sched/ext/ext.c

2760

dspc->nr_tasks += dspc->cursor;

kernel/sched/ext/ext.c

2761

dspc->cursor = 0;

kernel/sched/ext/ext.c

4236

struct scx_dsq_list_node cursor = INIT_DSQ_LIST_CURSOR(cursor, dsq, 0);

kernel/sched/ext/ext.c

4248

p = nldsq_cursor_next_task(&cursor, dsq);

kernel/sched/ext/ext.c

4268

if (nldsq_cursor_lost_task(&cursor, task_rq, dsq, p))

kernel/sched/ext/ext.c

4293

list_del_init(&cursor.node);

kernel/sched/ext/ext.c

5263

struct scx_dsq_list_node cursor = INIT_DSQ_LIST_CURSOR(cursor, donor_dsq, 0);

kernel/sched/ext/ext.c

5279

list_add(&cursor.node, &donor_dsq->list);

kernel/sched/ext/ext.c

5281

n = container_of(&cursor, struct task_struct, scx.dsq_list);

kernel/sched/ext/ext.c

5343

list_move_tail(&cursor.node, &n->scx.dsq_list.node);

kernel/sched/ext/ext.c

5353

list_del_init(&cursor.node);

kernel/sched/ext/ext.c

606

static struct task_struct *nldsq_cursor_next_task(struct scx_dsq_list_node *cursor,

kernel/sched/ext/ext.c

609

bool rev = cursor->flags & SCX_DSQ_ITER_REV;

kernel/sched/ext/ext.c

613

BUG_ON(!(cursor->flags & SCX_DSQ_LNODE_ITER_CURSOR));

kernel/sched/ext/ext.c

615

if (list_empty(&cursor->node))

kernel/sched/ext/ext.c

618

p = container_of(cursor, struct task_struct, scx.dsq_list);

kernel/sched/ext/ext.c

623

} while (p && unlikely(u32_before(cursor->priv, p->scx.dsq_seq)));

kernel/sched/ext/ext.c

627

list_move_tail(&cursor->node, &p->scx.dsq_list.node);

kernel/sched/ext/ext.c

629

list_move(&cursor->node, &p->scx.dsq_list.node);

kernel/sched/ext/ext.c

631

list_del_init(&cursor->node);

kernel/sched/ext/ext.c

6370

dd->cursor = 0;

kernel/sched/ext/ext.c

6380

if (!dd->cursor)

kernel/sched/ext/ext.c

6420

dd->cursor = 0;

kernel/sched/ext/ext.c

650

static bool nldsq_cursor_lost_task(struct scx_dsq_list_node *cursor,

kernel/sched/ext/ext.c

662

u32_before(cursor->priv, p->scx.dsq_seq) ||

kernel/sched/ext/ext.c

680

struct scx_dsq_list_node cursor;

kernel/sched/ext/ext.c

740

struct sched_ext_entity cursor;

kernel/sched/ext/ext.c

797

iter->cursor = (struct sched_ext_entity){ .flags = SCX_TASK_CURSOR };

kernel/sched/ext/ext.c

798

list_add(&iter->cursor.tasks_node, &scx_tasks);

kernel/sched/ext/ext.c

8628

if (unlikely(dspc->cursor >= sch->dsp_max_batch)) {

kernel/sched/ext/ext.c

8633

dspc->buf[dspc->cursor++] = (struct scx_dsp_buf_ent){

kernel/sched/ext/ext.c

874

list_del_init(&iter->cursor.tasks_node);

kernel/sched/ext/ext.c

888

struct list_head *cursor = &iter->cursor.tasks_node;

kernel/sched/ext/ext.c

8892

if (nldsq_cursor_lost_task(&kit->cursor, src_rq, src_dsq, p)) {

kernel/sched/ext/ext.c

8905

if (kit->cursor.flags & __SCX_DSQ_ITER_HAS_VTIME)

kernel/sched/ext/ext.c

8907

if (kit->cursor.flags & __SCX_DSQ_ITER_HAS_SLICE)

kernel/sched/ext/ext.c

8921

kit->cursor.flags &= ~(__SCX_DSQ_ITER_HAS_SLICE |

kernel/sched/ext/ext.c

8944

return sch->dsp_max_batch - __this_cpu_read(sch->pcpu->dsp_ctx.cursor);

kernel/sched/ext/ext.c

8967

if (dspc->cursor > 0)

kernel/sched/ext/ext.c

8968

dspc->cursor--;

kernel/sched/ext/ext.c

9061

kit->cursor.flags |= __SCX_DSQ_ITER_HAS_SLICE;

kernel/sched/ext/ext.c

9080

kit->cursor.flags |= __SCX_DSQ_ITER_HAS_VTIME;

kernel/sched/ext/ext.c

917

list_for_each_entry(pos, cursor, tasks_node) {

kernel/sched/ext/ext.c

921

list_move(cursor, &pos->tasks_node);

kernel/sched/ext/ext.c

9569

kit->cursor = INIT_DSQ_LIST_CURSOR(kit->cursor, kit->dsq, flags);

kernel/sched/ext/ext.c

9589

return nldsq_cursor_next_task(&kit->cursor, kit->dsq);

kernel/sched/ext/ext.c

9605

if (!list_empty(&kit->cursor.node)) {

kernel/sched/ext/ext.c

9609

list_del_init(&kit->cursor.node);

kernel/sched/ext/ext.c

9843

ret = __bstr_format(sch, buf->data, buf->line + dd->cursor,

kernel/sched/ext/ext.c

9844

sizeof(buf->line) - dd->cursor, fmt, data, data__sz);

kernel/sched/ext/ext.c

9851

dd->cursor += ret;

kernel/sched/ext/ext.c

9852

dd->cursor = min_t(s32, dd->cursor, sizeof(buf->line));

kernel/sched/ext/ext.c

9854

if (!dd->cursor)

kernel/sched/ext/ext.c

9865

if (dd->cursor >= sizeof(buf->line) || buf->line[dd->cursor - 1] == '\n')

kernel/sched/ext/internal.h

1070

u32 cursor;

kernel/sched/fair.c

6969

struct cfs_rq *cursor, *tmp;

kernel/sched/fair.c

6991

list_for_each_entry_safe(cursor, tmp, &rq->cfsb_csd_list,

kernel/sched/fair.c

6993

list_del_init(&cursor->throttled_csd_list);

kernel/sched/fair.c

6995

if (cfs_rq_throttled(cursor))

kernel/sched/fair.c

6996

unthrottle_cfs_rq(cursor);

kernel/workqueue.c

3508

struct work_struct *cursor = &pwq->mayday_cursor;

kernel/workqueue.c

3543

if (list_empty(&cursor->entry))

kernel/workqueue.c

3546

work = list_next_entry(cursor, entry);

kernel/workqueue.c

3553

list_move_tail(&cursor->entry, &n->entry);

lib/assoc_array.c

105

cursor = parent;

lib/assoc_array.c

1460

struct assoc_array_ptr *cursor, *ptr;

lib/assoc_array.c

1482

cursor = array->root;

lib/assoc_array.c

1488

if (assoc_array_ptr_is_shortcut(cursor)) {

lib/assoc_array.c

1489

shortcut = assoc_array_ptr_to_shortcut(cursor);

lib/assoc_array.c

1501

cursor = shortcut->next_node;

lib/assoc_array.c

1505

node = assoc_array_ptr_to_node(cursor);

lib/assoc_array.c

1534

cursor = ptr;

lib/assoc_array.c

1701

cursor = shortcut->back_pointer;

lib/assoc_array.c

1702

if (!cursor)

lib/assoc_array.c

1706

cursor = ptr;

lib/assoc_array.c

1708

BUG_ON(!cursor);

lib/assoc_array.c

1709

node = assoc_array_ptr_to_node(cursor);

lib/assoc_array.c

177

struct assoc_array_ptr *cursor, *ptr;

lib/assoc_array.c

185

cursor = READ_ONCE(array->root); /* Address dependency. */

lib/assoc_array.c

186

if (!cursor)

lib/assoc_array.c

202

if (assoc_array_ptr_is_shortcut(cursor))

lib/assoc_array.c

206

node = assoc_array_ptr_to_node(cursor);

lib/assoc_array.c

229

cursor = ptr;

lib/assoc_array.c

240

cursor = ptr;

lib/assoc_array.c

242

shortcut = assoc_array_ptr_to_shortcut(cursor);

lib/assoc_array.c

27

const struct assoc_array_ptr *cursor, *ptr, *parent;

lib/assoc_array.c

283

cursor = READ_ONCE(shortcut->next_node); /* Address dependency. */

lib/assoc_array.c

31

cursor = root;

lib/assoc_array.c

34

if (assoc_array_ptr_is_shortcut(cursor)) {

lib/assoc_array.c

349

struct assoc_array_ptr *cursor, *parent = NULL;

lib/assoc_array.c

354

cursor = root;

lib/assoc_array.c

355

if (!cursor) {

lib/assoc_array.c

36

shortcut = assoc_array_ptr_to_shortcut(cursor);

lib/assoc_array.c

361

if (assoc_array_ptr_is_shortcut(cursor)) {

lib/assoc_array.c

364

BUG_ON(!assoc_array_ptr_is_shortcut(cursor));

lib/assoc_array.c

365

shortcut = assoc_array_ptr_to_shortcut(cursor);

lib/assoc_array.c

368

parent = cursor;

lib/assoc_array.c

369

cursor = shortcut->next_node;

lib/assoc_array.c

37

cursor = READ_ONCE(shortcut->next_node); /* Address dependency. */

lib/assoc_array.c

371

BUG_ON(!assoc_array_ptr_is_node(cursor));

lib/assoc_array.c

375

node = assoc_array_ptr_to_node(cursor);

lib/assoc_array.c

387

parent = cursor;

lib/assoc_array.c

388

cursor = ptr;

lib/assoc_array.c

40

node = assoc_array_ptr_to_node(cursor);

lib/assoc_array.c

409

BUG_ON(shortcut->next_node != cursor);

lib/assoc_array.c

410

cursor = parent;

lib/assoc_array.c

423

cursor = parent;

lib/assoc_array.c

424

node = assoc_array_ptr_to_node(cursor);

lib/assoc_array.c

79

node = assoc_array_ptr_to_node(cursor);

lib/assoc_array.c

83

cursor = ptr;

lib/assoc_array.c

97

cursor = parent;

mm/zsmalloc.c

784

struct zpdesc *cursor, *fail;

mm/zsmalloc.c

786

for (cursor = get_first_zpdesc(zspage); cursor != NULL; cursor =

mm/zsmalloc.c

787

get_next_zpdesc(cursor)) {

mm/zsmalloc.c

788

if (!zpdesc_trylock(cursor)) {

mm/zsmalloc.c

789

fail = cursor;

mm/zsmalloc.c

796

for (cursor = get_first_zpdesc(zspage); cursor != fail; cursor =

mm/zsmalloc.c

797

get_next_zpdesc(cursor))

mm/zsmalloc.c

798

zpdesc_unlock(cursor);

net/ceph/messenger.c

1009

*length = min_t(size_t, len, cursor->resid);

net/ceph/messenger.c

1013

static bool ceph_msg_data_iter_advance(struct ceph_msg_data_cursor *cursor,

net/ceph/messenger.c

1016

BUG_ON(bytes > cursor->resid);

net/ceph/messenger.c

1017

cursor->resid -= bytes;

net/ceph/messenger.c

1019

if (bytes < cursor->lastlen) {

net/ceph/messenger.c

1020

cursor->lastlen -= bytes;

net/ceph/messenger.c

1022

iov_iter_advance(&cursor->iov_iter, bytes - cursor->lastlen);

net/ceph/messenger.c

1023

cursor->lastlen = 0;

net/ceph/messenger.c

1026

return cursor->resid;

net/ceph/messenger.c

1037

static void __ceph_msg_data_cursor_init(struct ceph_msg_data_cursor *cursor)

net/ceph/messenger.c

1039

size_t length = cursor->total_resid;

net/ceph/messenger.c

1041

switch (cursor->data->type) {

net/ceph/messenger.c

1043

ceph_msg_data_pagelist_cursor_init(cursor, length);

net/ceph/messenger.c

1046

ceph_msg_data_pages_cursor_init(cursor, length);

net/ceph/messenger.c

1050

ceph_msg_data_bio_cursor_init(cursor, length);

net/ceph/messenger.c

1054

ceph_msg_data_bvecs_cursor_init(cursor, length);

net/ceph/messenger.c

1057

ceph_msg_data_iter_cursor_init(cursor, length);

net/ceph/messenger.c

1064

cursor->need_crc = true;

net/ceph/messenger.c

1067

void ceph_msg_data_cursor_init(struct ceph_msg_data_cursor *cursor,

net/ceph/messenger.c

1074

cursor->total_resid = length;

net/ceph/messenger.c

1075

cursor->data = msg->data;

net/ceph/messenger.c

1076

cursor->sr_resid = 0;

net/ceph/messenger.c

1078

__ceph_msg_data_cursor_init(cursor);

net/ceph/messenger.c

1086

struct page *ceph_msg_data_next(struct ceph_msg_data_cursor *cursor,

net/ceph/messenger.c

1091

switch (cursor->data->type) {

net/ceph/messenger.c

1093

page = ceph_msg_data_pagelist_next(cursor, page_offset, length);

net/ceph/messenger.c

1096

page = ceph_msg_data_pages_next(cursor, page_offset, length);

net/ceph/messenger.c

1100

page = ceph_msg_data_bio_next(cursor, page_offset, length);

net/ceph/messenger.c

1104

page = ceph_msg_data_bvecs_next(cursor, page_offset, length);

net/ceph/messenger.c

1107

page = ceph_msg_data_iter_next(cursor, page_offset, length);

net/ceph/messenger.c

1118

BUG_ON(*length > cursor->resid);

net/ceph/messenger.c

1127

void ceph_msg_data_advance(struct ceph_msg_data_cursor *cursor, size_t bytes)

net/ceph/messenger.c

1131

BUG_ON(bytes > cursor->resid);

net/ceph/messenger.c

1132

switch (cursor->data->type) {

net/ceph/messenger.c

1134

new_piece = ceph_msg_data_pagelist_advance(cursor, bytes);

net/ceph/messenger.c

1137

new_piece = ceph_msg_data_pages_advance(cursor, bytes);

net/ceph/messenger.c

1141

new_piece = ceph_msg_data_bio_advance(cursor, bytes);

net/ceph/messenger.c

1145

new_piece = ceph_msg_data_bvecs_advance(cursor, bytes);

net/ceph/messenger.c

1148

new_piece = ceph_msg_data_iter_advance(cursor, bytes);

net/ceph/messenger.c

1155

cursor->total_resid -= bytes;

net/ceph/messenger.c

1157

if (!cursor->resid && cursor->total_resid) {

net/ceph/messenger.c

1158

cursor->data++;

net/ceph/messenger.c

1159

__ceph_msg_data_cursor_init(cursor);

net/ceph/messenger.c

1162

cursor->need_crc = new_piece;

net/ceph/messenger.c

725

static void ceph_msg_data_bio_cursor_init(struct ceph_msg_data_cursor *cursor,

net/ceph/messenger.c

728

struct ceph_msg_data *data = cursor->data;

net/ceph/messenger.c

729

struct ceph_bio_iter *it = &cursor->bio_iter;

net/ceph/messenger.c

731

cursor->resid = min_t(size_t, length, data->bio_length);

net/ceph/messenger.c

733

if (cursor->resid < it->iter.bi_size)

net/ceph/messenger.c

734

it->iter.bi_size = cursor->resid;

net/ceph/messenger.c

736

BUG_ON(cursor->resid < bio_iter_len(it->bio, it->iter));

net/ceph/messenger.c

739

static struct page *ceph_msg_data_bio_next(struct ceph_msg_data_cursor *cursor,

net/ceph/messenger.c

743

struct bio_vec bv = bio_iter_iovec(cursor->bio_iter.bio,

net/ceph/messenger.c

744

cursor->bio_iter.iter);

net/ceph/messenger.c

751

static bool ceph_msg_data_bio_advance(struct ceph_msg_data_cursor *cursor,

net/ceph/messenger.c

754

struct ceph_bio_iter *it = &cursor->bio_iter;

net/ceph/messenger.c

757

BUG_ON(bytes > cursor->resid);

net/ceph/messenger.c

759

cursor->resid -= bytes;

net/ceph/messenger.c

762

if (!cursor->resid)

net/ceph/messenger.c

772

if (cursor->resid < it->iter.bi_size)

net/ceph/messenger.c

773

it->iter.bi_size = cursor->resid;

net/ceph/messenger.c

776

BUG_ON(cursor->resid < bio_iter_len(it->bio, it->iter));

net/ceph/messenger.c

781

static void ceph_msg_data_bvecs_cursor_init(struct ceph_msg_data_cursor *cursor,

net/ceph/messenger.c

784

struct ceph_msg_data *data = cursor->data;

net/ceph/messenger.c

787

cursor->resid = min_t(size_t, length, data->bvec_pos.iter.bi_size);

net/ceph/messenger.c

788

cursor->bvec_iter = data->bvec_pos.iter;

net/ceph/messenger.c

789

cursor->bvec_iter.bi_size = cursor->resid;

net/ceph/messenger.c

791

BUG_ON(cursor->resid < bvec_iter_len(bvecs, cursor->bvec_iter));

net/ceph/messenger.c

794

static struct page *ceph_msg_data_bvecs_next(struct ceph_msg_data_cursor *cursor,

net/ceph/messenger.c

798

struct bio_vec bv = bvec_iter_bvec(cursor->data->bvec_pos.bvecs,

net/ceph/messenger.c

799

cursor->bvec_iter);

net/ceph/messenger.c

806

static bool ceph_msg_data_bvecs_advance(struct ceph_msg_data_cursor *cursor,

net/ceph/messenger.c

809

struct bio_vec *bvecs = cursor->data->bvec_pos.bvecs;

net/ceph/messenger.c

810

struct page *page = bvec_iter_page(bvecs, cursor->bvec_iter);

net/ceph/messenger.c

812

BUG_ON(bytes > cursor->resid);

net/ceph/messenger.c

813

BUG_ON(bytes > bvec_iter_len(bvecs, cursor->bvec_iter));

net/ceph/messenger.c

814

cursor->resid -= bytes;

net/ceph/messenger.c

815

bvec_iter_advance(bvecs, &cursor->bvec_iter, bytes);

net/ceph/messenger.c

817

if (!cursor->resid)

net/ceph/messenger.c

820

if (!bytes || (cursor->bvec_iter.bi_bvec_done &&

net/ceph/messenger.c

821

page == bvec_iter_page(bvecs, cursor->bvec_iter)))

net/ceph/messenger.c

824

BUG_ON(cursor->resid < bvec_iter_len(bvecs, cursor->bvec_iter));

net/ceph/messenger.c

832

static void ceph_msg_data_pages_cursor_init(struct ceph_msg_data_cursor *cursor,

net/ceph/messenger.c

835

struct ceph_msg_data *data = cursor->data;

net/ceph/messenger.c

843

cursor->resid = min(length, data->length);

net/ceph/messenger.c

845

cursor->page_offset = data->alignment & ~PAGE_MASK;

net/ceph/messenger.c

846

cursor->page_index = 0;

net/ceph/messenger.c

848

cursor->page_count = (unsigned short)page_count;

net/ceph/messenger.c

849

BUG_ON(length > SIZE_MAX - cursor->page_offset);

net/ceph/messenger.c

853

ceph_msg_data_pages_next(struct ceph_msg_data_cursor *cursor,

net/ceph/messenger.c

856

struct ceph_msg_data *data = cursor->data;

net/ceph/messenger.c

860

BUG_ON(cursor->page_index >= cursor->page_count);

net/ceph/messenger.c

861

BUG_ON(cursor->page_offset >= PAGE_SIZE);

net/ceph/messenger.c

863

*page_offset = cursor->page_offset;

net/ceph/messenger.c

864

*length = min_t(size_t, cursor->resid, PAGE_SIZE - *page_offset);

net/ceph/messenger.c

865

return data->pages[cursor->page_index];

net/ceph/messenger.c

868

static bool ceph_msg_data_pages_advance(struct ceph_msg_data_cursor *cursor,

net/ceph/messenger.c

871

BUG_ON(cursor->data->type != CEPH_MSG_DATA_PAGES);

net/ceph/messenger.c

873

BUG_ON(cursor->page_offset + bytes > PAGE_SIZE);

net/ceph/messenger.c

877

cursor->resid -= bytes;

net/ceph/messenger.c

878

cursor->page_offset = (cursor->page_offset + bytes) & ~PAGE_MASK;

net/ceph/messenger.c

879

if (!bytes || cursor->page_offset)

net/ceph/messenger.c

882

if (!cursor->resid)

net/ceph/messenger.c

887

BUG_ON(cursor->page_index >= cursor->page_count);

net/ceph/messenger.c

888

cursor->page_index++;

net/ceph/messenger.c

897

ceph_msg_data_pagelist_cursor_init(struct ceph_msg_data_cursor *cursor,

net/ceph/messenger.c

900

struct ceph_msg_data *data = cursor->data;

net/ceph/messenger.c

915

cursor->resid = min(length, pagelist->length);

net/ceph/messenger.c

916

cursor->page = page;

net/ceph/messenger.c

917

cursor->offset = 0;

net/ceph/messenger.c

921

ceph_msg_data_pagelist_next(struct ceph_msg_data_cursor *cursor,

net/ceph/messenger.c

924

struct ceph_msg_data *data = cursor->data;

net/ceph/messenger.c

932

BUG_ON(!cursor->page);

net/ceph/messenger.c

933

BUG_ON(cursor->offset + cursor->resid != pagelist->length);

net/ceph/messenger.c

936

*page_offset = cursor->offset & ~PAGE_MASK;

net/ceph/messenger.c

937

*length = min_t(size_t, cursor->resid, PAGE_SIZE - *page_offset);

net/ceph/messenger.c

938

return cursor->page;

net/ceph/messenger.c

941

static bool ceph_msg_data_pagelist_advance(struct ceph_msg_data_cursor *cursor,

net/ceph/messenger.c

944

struct ceph_msg_data *data = cursor->data;

net/ceph/messenger.c

952

BUG_ON(cursor->offset + cursor->resid != pagelist->length);

net/ceph/messenger.c

953

BUG_ON((cursor->offset & ~PAGE_MASK) + bytes > PAGE_SIZE);

net/ceph/messenger.c

957

cursor->resid -= bytes;

net/ceph/messenger.c

958

cursor->offset += bytes;

net/ceph/messenger.c

960

if (!bytes || cursor->offset & ~PAGE_MASK)

net/ceph/messenger.c

963

if (!cursor->resid)

net/ceph/messenger.c

968

BUG_ON(list_is_last(&cursor->page->lru, &pagelist->head));

net/ceph/messenger.c

969

cursor->page = list_next_entry(cursor->page, lru);

net/ceph/messenger.c

973

static void ceph_msg_data_iter_cursor_init(struct ceph_msg_data_cursor *cursor,

net/ceph/messenger.c

976

struct ceph_msg_data *data = cursor->data;

net/ceph/messenger.c

978

cursor->iov_iter = data->iter;

net/ceph/messenger.c

979

cursor->lastlen = 0;

net/ceph/messenger.c

980

iov_iter_truncate(&cursor->iov_iter, length);

net/ceph/messenger.c

981

cursor->resid = iov_iter_count(&cursor->iov_iter);

net/ceph/messenger.c

984

static struct page *ceph_msg_data_iter_next(struct ceph_msg_data_cursor *cursor,

net/ceph/messenger.c

990

if (cursor->lastlen)

net/ceph/messenger.c

991

iov_iter_revert(&cursor->iov_iter, cursor->lastlen);

net/ceph/messenger.c

993

len = iov_iter_get_pages2(&cursor->iov_iter, &page, PAGE_SIZE,

net/ceph/messenger.c

997

cursor->lastlen = len;

net/ceph/messenger_v1.c

1004

while (cursor->sr_resid > 0) {

net/ceph/messenger_v1.c

1009

page = ceph_msg_data_next(cursor, &off, &len);

net/ceph/messenger_v1.c

1013

len = min_t(int, len, cursor->sr_resid);

net/ceph/messenger_v1.c

1018

ceph_msg_data_advance(cursor, (size_t)ret);

net/ceph/messenger_v1.c

1019

cursor->sr_resid -= ret;

net/ceph/messenger_v1.c

1028

struct ceph_msg_data_cursor *cursor = &con->in_msg->cursor;

net/ceph/messenger_v1.c

1036

while (cursor->total_resid) {

net/ceph/messenger_v1.c

1042

else if (cursor->sr_resid > 0)

net/ceph/messenger_v1.c

1048

ret = con->ops->sparse_read(con, cursor,

net/ceph/messenger_v1.c

1065

struct ceph_msg_data_cursor *cursor = &con->in_msg->cursor;

net/ceph/messenger_v1.c

1075

while (cursor->total_resid) {

net/ceph/messenger_v1.c

1076

if (!cursor->resid) {

net/ceph/messenger_v1.c

1077

ceph_msg_data_advance(cursor, 0);

net/ceph/messenger_v1.c

1081

page = ceph_msg_data_next(cursor, &page_offset, &length);

net/ceph/messenger_v1.c

1092

ceph_msg_data_advance(cursor, (size_t)ret);

net/ceph/messenger_v1.c

1102

struct ceph_msg_data_cursor *cursor = &con->in_msg->cursor;

net/ceph/messenger_v1.c

1117

while (cursor->total_resid) {

net/ceph/messenger_v1.c

1118

if (!cursor->resid) {

net/ceph/messenger_v1.c

1119

ceph_msg_data_advance(cursor, 0);

net/ceph/messenger_v1.c

1123

page = ceph_msg_data_next(cursor, &off, &len);

net/ceph/messenger_v1.c

1133

ceph_msg_data_advance(cursor, ret);

net/ceph/messenger_v1.c

1577

con->v1.out_skip += msg->cursor.total_resid;

net/ceph/messenger_v1.c

165

ceph_msg_data_cursor_init(&msg->cursor, msg, len);

net/ceph/messenger_v1.c

464

struct ceph_msg_data_cursor *cursor = &msg->cursor;

net/ceph/messenger_v1.c

482

while (cursor->total_resid) {

net/ceph/messenger_v1.c

488

if (!cursor->resid) {

net/ceph/messenger_v1.c

489

ceph_msg_data_advance(cursor, 0);

net/ceph/messenger_v1.c

493

page = ceph_msg_data_next(cursor, &page_offset, &length);

net/ceph/messenger_v1.c

502

if (do_datacrc && cursor->need_crc)

net/ceph/messenger_v1.c

504

ceph_msg_data_advance(cursor, (size_t)ret);

net/ceph/messenger_v1.c

993

struct ceph_msg_data_cursor *cursor = &con->in_msg->cursor;

net/ceph/messenger_v2.c

1001

ceph_msg_data_cursor_init(&cursor, msg, dlen);

net/ceph/messenger_v2.c

1002

sg_cnt += calc_sg_cnt_cursor(&cursor);

net/ceph/messenger_v2.c

1021

ceph_msg_data_cursor_init(&cursor, msg, dlen);

net/ceph/messenger_v2.c

1022

init_sgs_cursor(&cur_sg, &cursor, data_pad);

net/ceph/messenger_v2.c

1062

struct ceph_msg_data_cursor cursor;

net/ceph/messenger_v2.c

1065

ceph_msg_data_cursor_init(&cursor, con->in_msg,

net/ceph/messenger_v2.c

1071

ret = con->ops->sparse_read(con, &cursor, &buf);

net/ceph/messenger_v2.c

1089

get_bvec_at(&cursor, &bv);

net/ceph/messenger_v2.c

1093

ceph_msg_data_advance(&cursor, len);

net/ceph/messenger_v2.c

1903

struct ceph_msg_data_cursor *cursor = &con->v2.in_cursor;

net/ceph/messenger_v2.c

1912

get_bvec_at(cursor, &bv);

net/ceph/messenger_v2.c

1923

ceph_msg_data_advance(cursor, con->v2.in_bvec.bv_len);

net/ceph/messenger_v2.c

1924

cursor->sr_resid -= con->v2.in_bvec.bv_len;

net/ceph/messenger_v2.c

1926

con->v2.in_bvec.bv_len, cursor->sr_resid);

net/ceph/messenger_v2.c

1927

WARN_ON_ONCE(cursor->sr_resid > cursor->total_resid);

net/ceph/messenger_v2.c

1928

if (cursor->sr_resid) {

net/ceph/messenger_v2.c

1929

get_bvec_at(cursor, &bv);

net/ceph/messenger_v2.c

1930

if (bv.bv_len > cursor->sr_resid)

net/ceph/messenger_v2.c

1931

bv.bv_len = cursor->sr_resid;

net/ceph/messenger_v2.c

1953

ret = con->ops->sparse_read(con, cursor, &buf);

net/ceph/messenger_v2.c

1972

if (ret > cursor->total_resid) {

net/ceph/messenger_v2.c

1974

__func__, ret, cursor->total_resid, cursor->resid);

net/ceph/messenger_v2.c

1977

get_bvec_at(cursor, &bv);

net/ceph/messenger_v2.c

1978

if (bv.bv_len > cursor->sr_resid)

net/ceph/messenger_v2.c

1979

bv.bv_len = cursor->sr_resid;

net/ceph/messenger_v2.c

831

static void get_bvec_at(struct ceph_msg_data_cursor *cursor,

net/ceph/messenger_v2.c

837

WARN_ON(!cursor->total_resid);

net/ceph/messenger_v2.c

840

while (!cursor->resid)

net/ceph/messenger_v2.c

841

ceph_msg_data_advance(cursor, 0);

net/ceph/messenger_v2.c

844

page = ceph_msg_data_next(cursor, &off, &len);

net/ceph/messenger_v2.c

866

static int calc_sg_cnt_cursor(struct ceph_msg_data_cursor *cursor)

net/ceph/messenger_v2.c

868

int data_len = cursor->total_resid;

net/ceph/messenger_v2.c

877

get_bvec_at(cursor, &bv);

net/ceph/messenger_v2.c

880

ceph_msg_data_advance(cursor, bv.bv_len);

net/ceph/messenger_v2.c

881

} while (cursor->total_resid);

net/ceph/messenger_v2.c

918

struct ceph_msg_data_cursor *cursor, u8 *pad)

net/ceph/messenger_v2.c

920

int data_len = cursor->total_resid;

net/ceph/messenger_v2.c

927

get_bvec_at(cursor, &bv);

net/ceph/messenger_v2.c

931

ceph_msg_data_advance(cursor, bv.bv_len);

net/ceph/messenger_v2.c

932

} while (cursor->total_resid);

net/ceph/messenger_v2.c

979

struct ceph_msg_data_cursor cursor;

net/ceph/osd_client.c

5699

static void advance_cursor(struct ceph_msg_data_cursor *cursor, size_t len,

net/ceph/osd_client.c

5706

page = ceph_msg_data_next(cursor, &poff, &plen);

net/ceph/osd_client.c

5712

ceph_msg_data_advance(cursor, plen);

net/ceph/osd_client.c

5717

struct ceph_msg_data_cursor *cursor)

net/ceph/osd_client.c

5747

__func__, o->o_osd, op->extent.sparse_ext_cnt, cursor->resid);

net/ceph/osd_client.c

5751

advance_cursor(cursor, sr->sr_req_len - end, false);

net/ceph/osd_client.c

5803

struct ceph_msg_data_cursor *cursor,

net/ceph/osd_client.c

5815

ret = prep_next_sparse_read(con, cursor);

net/ceph/osd_client.c

5888

advance_cursor(cursor, eoff - sr->sr_pos, true);

net/ceph/osd_client.c

5894

cursor->sr_resid = elen;

net/rxrpc/conn_service.c

109

rb_replace_node_rcu(&cursor->service_node,

net/rxrpc/conn_service.c

112

clear_bit(RXRPC_CONN_IN_SERVICE_CONNS, &cursor->flags);

net/rxrpc/conn_service.c

67

struct rxrpc_connection *cursor = NULL;

net/rxrpc/conn_service.c

77

cursor = rb_entry(parent,

net/rxrpc/conn_service.c

80

if (cursor->proto.index_key < k.index_key)

net/rxrpc/conn_service.c

82

else if (cursor->proto.index_key > k.index_key)

net/rxrpc/conn_service.c

97

if (refcount_read(&cursor->ref) == 0)

net/rxrpc/local_object.c

252

struct hlist_node *cursor;

net/rxrpc/local_object.c

261

hlist_for_each(cursor, &rxnet->local_endpoints) {

net/rxrpc/local_object.c

262

local = hlist_entry(cursor, struct rxrpc_local, link);

net/rxrpc/local_object.c

297

if (cursor) {

net/rxrpc/local_object.c

298

hlist_replace_rcu(cursor, &local->link);

net/rxrpc/local_object.c

299

cursor->pprev = NULL;

net/rxrpc/peer_event.c

261

u8 cursor)

net/rxrpc/peer_event.c

286

cursor, peer->debug_id, slot, &peer->srx.transport);

net/rxrpc/peer_event.c

298

slot += cursor;

net/rxrpc/peer_event.c

322

u8 cursor, stop;

net/rxrpc/peer_event.c

327

cursor = rxnet->peer_keepalive_cursor;

net/rxrpc/peer_event.c

328

_enter("%lld,%u", base - now, cursor);

net/rxrpc/peer_event.c

343

stop = cursor + ARRAY_SIZE(rxnet->peer_keepalive);

net/rxrpc/peer_event.c

344

while (base <= now && (s8)(cursor - stop) < 0) {

net/rxrpc/peer_event.c

345

list_splice_tail_init(&rxnet->peer_keepalive[cursor & mask],

net/rxrpc/peer_event.c

348

cursor++;

net/rxrpc/peer_event.c

355

rxnet->peer_keepalive_cursor = cursor;

net/rxrpc/peer_event.c

356

rxrpc_peer_keepalive_dispatch(rxnet, &collector, base, cursor);

net/rxrpc/peer_event.c

360

cursor = rxnet->peer_keepalive_cursor;

net/rxrpc/peer_event.c

361

stop = cursor + RXRPC_KEEPALIVE_TIME - 1;

net/rxrpc/peer_event.c

362

for (; (s8)(cursor - stop) < 0; cursor++) {

net/rxrpc/peer_event.c

363

if (!list_empty(&rxnet->peer_keepalive[cursor & mask]))

net/smc/smc_cdc.c

107

pend->cursor = conn->tx_curs_sent;

net/smc/smc_cdc.c

42

&cdcpend->cursor);

net/smc/smc_cdc.c

48

smc_curs_copy(&conn->tx_curs_fin, &cdcpend->cursor, conn);

net/smc/smc_cdc.h

284

union smc_host_cursor cursor; /* tx sndbuf cursor sent */

net/sunrpc/xprtmultipath.c

417

struct rpc_xprt **cursor,

net/sunrpc/xprtmultipath.c

422

old = smp_load_acquire(cursor);

net/sunrpc/xprtmultipath.c

424

smp_store_release(cursor, pos);

scripts/asn1_compiler.c

1002

cursor++;

scripts/asn1_compiler.c

1003

if (cursor >= end)

scripts/asn1_compiler.c

1005

if (cursor->token_type != DIRECTIVE_IDENTIFIER)

scripts/asn1_compiler.c

1007

cursor++;

scripts/asn1_compiler.c

1012

ref = bsearch(cursor, type_index, nr_types, sizeof(type_index[0]),

scripts/asn1_compiler.c

1016

filename, cursor->line, cursor->content);

scripts/asn1_compiler.c

1019

cursor->type = *ref;

scripts/asn1_compiler.c

1021

cursor++;

scripts/asn1_compiler.c

1026

cursor++;

scripts/asn1_compiler.c

1027

element->children = parse_compound(&cursor, end, 1);

scripts/asn1_compiler.c

1033

cursor++;

scripts/asn1_compiler.c

1034

if (cursor >= end)

scripts/asn1_compiler.c

1036

if (cursor->token_type == DIRECTIVE_OF) {

scripts/asn1_compiler.c

1038

cursor++;

scripts/asn1_compiler.c

1039

if (cursor >= end)

scripts/asn1_compiler.c

1041

element->children = parse_type(&cursor, end, NULL);

scripts/asn1_compiler.c

1043

element->children = parse_compound(&cursor, end, 0);

scripts/asn1_compiler.c

1050

cursor++;

scripts/asn1_compiler.c

1051

if (cursor >= end)

scripts/asn1_compiler.c

1053

if (cursor->token_type == DIRECTIVE_OF) {

scripts/asn1_compiler.c

1055

cursor++;

scripts/asn1_compiler.c

1056

if (cursor >= end)

scripts/asn1_compiler.c

1058

element->children = parse_type(&cursor, end, NULL);

scripts/asn1_compiler.c

1060

element->children = parse_compound(&cursor, end, 1);

scripts/asn1_compiler.c

1066

filename, cursor->line, cursor->content);

scripts/asn1_compiler.c

1071

if (cursor < end && (cursor->token_type == DIRECTIVE_OPTIONAL ||

scripts/asn1_compiler.c

1072

cursor->token_type == DIRECTIVE_DEFAULT)

scripts/asn1_compiler.c

1074

cursor++;

scripts/asn1_compiler.c

1078

if (cursor < end && cursor->token_type == TOKEN_OPEN_ACTION) {

scripts/asn1_compiler.c

1079

cursor++;

scripts/asn1_compiler.c

1080

if (cursor >= end)

scripts/asn1_compiler.c

1082

if (cursor->token_type != TOKEN_ELEMENT_NAME) {

scripts/asn1_compiler.c

1084

filename, cursor->line, cursor->content);

scripts/asn1_compiler.c

1094

action->name = cursor->content;

scripts/asn1_compiler.c

1119

cursor->action = action;

scripts/asn1_compiler.c

1120

cursor++;

scripts/asn1_compiler.c

1121

if (cursor >= end)

scripts/asn1_compiler.c

1123

if (cursor->token_type != TOKEN_CLOSE_ACTION) {

scripts/asn1_compiler.c

1125

filename, cursor->line, cursor->content);

scripts/asn1_compiler.c

1128

cursor++;

scripts/asn1_compiler.c

1131

*_cursor = cursor;

scripts/asn1_compiler.c

1136

filename, cursor->line, cursor->content);

scripts/asn1_compiler.c

1151

struct token *cursor = *_cursor, *name;

scripts/asn1_compiler.c

1153

if (cursor->token_type != TOKEN_OPEN_CURLY) {

scripts/asn1_compiler.c

1155

filename, cursor->line, cursor->content);

scripts/asn1_compiler.c

1158

cursor++;

scripts/asn1_compiler.c

1159

if (cursor >= end)

scripts/asn1_compiler.c

1162

if (cursor->token_type == TOKEN_OPEN_CURLY) {

scripts/asn1_compiler.c

1164

filename, cursor->line);

scripts/asn1_compiler.c

1170

if (cursor->token_type == TOKEN_ELEMENT_NAME) {

scripts/asn1_compiler.c

1171

name = cursor;

scripts/asn1_compiler.c

1172

cursor++;

scripts/asn1_compiler.c

1173

if (cursor >= end)

scripts/asn1_compiler.c

1177

element = parse_type(&cursor, end, name);

scripts/asn1_compiler.c

1184

if (cursor >= end)

scripts/asn1_compiler.c

1186

if (cursor->token_type != TOKEN_COMMA)

scripts/asn1_compiler.c

1188

cursor++;

scripts/asn1_compiler.c

1189

if (cursor >= end)

scripts/asn1_compiler.c

1195

if (cursor->token_type != TOKEN_CLOSE_CURLY) {

scripts/asn1_compiler.c

1197

filename, cursor->line, cursor->content);

scripts/asn1_compiler.c

1200

cursor++;

scripts/asn1_compiler.c

1202

*_cursor = cursor;

scripts/asn1_compiler.c

806

struct token *cursor;

scripts/asn1_compiler.c

812

cursor = type->name;

scripts/asn1_compiler.c

814

if (cursor[0].token_type != TOKEN_TYPE_NAME ||

scripts/asn1_compiler.c

815

cursor[1].token_type != TOKEN_ASSIGNMENT)

scripts/asn1_compiler.c

817

cursor += 2;

scripts/asn1_compiler.c

819

type->element = parse_type(&cursor, type[1].name, NULL);

scripts/asn1_compiler.c

822

if (cursor != type[1].name) {

scripts/asn1_compiler.c

824

filename, cursor->line, cursor->content);

scripts/asn1_compiler.c

858

struct token *cursor = *_cursor;

scripts/asn1_compiler.c

866

element->tag = token_to_tag[cursor->token_type];

scripts/asn1_compiler.c

870

if (cursor->token_type == TOKEN_OPEN_SQUARE) {

scripts/asn1_compiler.c

871

cursor++;

scripts/asn1_compiler.c

872

if (cursor >= end)

scripts/asn1_compiler.c

874

switch (cursor->token_type) {

scripts/asn1_compiler.c

877

cursor++;

scripts/asn1_compiler.c

881

cursor++;

scripts/asn1_compiler.c

888

cursor++;

scripts/asn1_compiler.c

892

filename, cursor->line, cursor->content);

scripts/asn1_compiler.c

896

if (cursor >= end)

scripts/asn1_compiler.c

898

if (cursor->token_type != TOKEN_NUMBER) {

scripts/asn1_compiler.c

900

filename, cursor->line, cursor->content);

scripts/asn1_compiler.c

905

element->tag |= strtoul(cursor->content, &p, 10);

scripts/asn1_compiler.c

907

if (p - cursor->content != cursor->size)

scripts/asn1_compiler.c

909

cursor++;

scripts/asn1_compiler.c

911

if (cursor >= end)

scripts/asn1_compiler.c

913

if (cursor->token_type != TOKEN_CLOSE_SQUARE) {

scripts/asn1_compiler.c

915

filename, cursor->line, cursor->content);

scripts/asn1_compiler.c

918

cursor++;

scripts/asn1_compiler.c

919

if (cursor >= end)

scripts/asn1_compiler.c

925

if (cursor->token_type == DIRECTIVE_IMPLICIT) {

scripts/asn1_compiler.c

928

cursor++;

scripts/asn1_compiler.c

929

if (cursor >= end)

scripts/asn1_compiler.c

931

} else if (cursor->token_type == DIRECTIVE_EXPLICIT) {

scripts/asn1_compiler.c

933

cursor++;

scripts/asn1_compiler.c

934

if (cursor >= end)

scripts/asn1_compiler.c

946

element->tag = token_to_tag[cursor->token_type];

scripts/asn1_compiler.c

951

element->type = cursor;

scripts/asn1_compiler.c

952

switch (cursor->token_type) {

scripts/asn1_compiler.c

955

cursor++;

scripts/asn1_compiler.c

963

cursor++;

scripts/asn1_compiler.c

986

cursor++;

scripts/asn1_compiler.c

992

cursor++;

scripts/asn1_compiler.c

993

if (cursor >= end)

scripts/asn1_compiler.c

995

if (cursor->token_type != DIRECTIVE_STRING)

scripts/asn1_compiler.c

997

cursor++;

security/keys/gc.c

189

struct rb_node *cursor;

security/keys/gc.c

214

cursor = rb_first(&key_serial_tree);

security/keys/gc.c

217

while (cursor) {

security/keys/gc.c

218

key = rb_entry(cursor, struct key, serial_node);

security/keys/gc.c

219

cursor = rb_next(cursor);

security/keys/gc.c

272

if (cursor) {

sound/firewire/motu/amdtp-motu.c

336

const struct pkt_desc *cursor = desc;

sound/firewire/motu/amdtp-motu.c

361

desc = cursor;

sound/firewire/motu/amdtp-motu.c

399

const struct pkt_desc *cursor = desc;

sound/firewire/motu/amdtp-motu.c

426

desc = cursor;

tools/perf/builtin-c2c.c

341

struct callchain_cursor *cursor;

tools/perf/builtin-c2c.c

356

cursor = get_tls_callchain_cursor();

tools/perf/builtin-c2c.c

357

ret = sample__resolve_callchain(sample, cursor, NULL,

tools/perf/builtin-inject.c

529

struct callchain_cursor *cursor = get_tls_callchain_cursor();

tools/perf/builtin-inject.c

546

if (cursor == NULL)

tools/perf/builtin-inject.c

549

callchain_cursor_reset(cursor);

tools/perf/builtin-inject.c

556

ret = thread__resolve_callchain(thread, cursor, sample,

tools/perf/builtin-inject.c

574

node = cursor->first;

tools/perf/builtin-inject.c

575

for (k = 0; k < cursor->nr && i < PERF_MAX_STACK_DEPTH; k++) {

tools/perf/builtin-kmem.c

403

struct callchain_cursor *cursor;

tools/perf/builtin-kmem.c

414

cursor = get_tls_callchain_cursor();

tools/perf/builtin-kmem.c

415

if (cursor == NULL)

tools/perf/builtin-kmem.c

418

sample__resolve_callchain(sample, cursor, /*parent=*/NULL, &al, 16);

tools/perf/builtin-kmem.c

420

callchain_cursor_commit(cursor);

tools/perf/builtin-kmem.c

425

node = callchain_cursor_current(cursor);

tools/perf/builtin-kmem.c

444

callchain_cursor_advance(cursor);

tools/perf/builtin-kwork.c

742

struct callchain_cursor *cursor;

tools/perf/builtin-kwork.c

754

cursor = get_tls_callchain_cursor();

tools/perf/builtin-kwork.c

756

if (thread__resolve_callchain(thread, cursor, sample,

tools/perf/builtin-kwork.c

762

callchain_cursor_commit(cursor);

tools/perf/builtin-kwork.c

765

node = callchain_cursor_current(cursor);

tools/perf/builtin-kwork.c

776

callchain_cursor_advance(cursor);

tools/perf/builtin-kwork.c

841

struct callchain_cursor *cursor = get_tls_callchain_cursor();

tools/perf/builtin-kwork.c

843

if (cursor == NULL)

tools/perf/builtin-kwork.c

852

cursor, symbol_conf.bt_stop_list,

tools/perf/builtin-lock.c

840

struct callchain_cursor *cursor;

tools/perf/builtin-lock.c

854

cursor = get_tls_callchain_cursor();

tools/perf/builtin-lock.c

857

ret = thread__resolve_callchain(thread, cursor, sample,

tools/perf/builtin-lock.c

864

callchain_cursor_commit(cursor);

tools/perf/builtin-lock.c

870

node = callchain_cursor_current(cursor);

tools/perf/builtin-lock.c

886

callchain_cursor_advance(cursor);

tools/perf/builtin-lock.c

893

struct callchain_cursor *cursor;

tools/perf/builtin-lock.c

904

cursor = get_tls_callchain_cursor();

tools/perf/builtin-lock.c

906

ret = thread__resolve_callchain(thread, cursor, sample,

tools/perf/builtin-lock.c

913

callchain_cursor_commit(cursor);

tools/perf/builtin-lock.c

918

node = callchain_cursor_current(cursor);

tools/perf/builtin-lock.c

932

callchain_cursor_advance(cursor);

tools/perf/builtin-sched.c

2404

struct callchain_cursor *cursor;

tools/perf/builtin-sched.c

2419

cursor = get_tls_callchain_cursor();

tools/perf/builtin-sched.c

2421

if (thread__resolve_callchain(thread, cursor, sample,

tools/perf/builtin-sched.c

2430

callchain_cursor_commit(cursor);

tools/perf/builtin-sched.c

2437

node = callchain_cursor_current(cursor);

tools/perf/builtin-sched.c

2449

callchain_cursor_advance(cursor);

tools/perf/builtin-sched.c

2466

callchain_cursor_reset(&itr->cursor);

tools/perf/builtin-sched.c

2517

callchain_cursor_cleanup(&itr->cursor);

tools/perf/builtin-sched.c

2568

struct callchain_cursor *cursor;

tools/perf/builtin-sched.c

2573

cursor = get_tls_callchain_cursor();

tools/perf/builtin-sched.c

2574

if (cursor == NULL)

tools/perf/builtin-sched.c

2577

callchain_cursor__copy(&itr->cursor, cursor);

tools/perf/builtin-sched.c

292

struct callchain_cursor cursor;

tools/perf/builtin-sched.c

2978

if (itr->cursor.nr)

tools/perf/builtin-sched.c

2979

callchain_append(&itr->callchain, &itr->cursor, t - tprev);

tools/perf/builtin-script.c

1690

struct callchain_cursor *cursor = NULL;

tools/perf/builtin-script.c

1693

cursor = get_tls_callchain_cursor();

tools/perf/builtin-script.c

1694

if (thread__resolve_callchain(al->thread, cursor,

tools/perf/builtin-script.c

1697

cursor = NULL;

tools/perf/builtin-script.c

1699

if (cursor == NULL) {

tools/perf/builtin-script.c

1708

printed += sample__fprintf_sym(sample, al, 0, print_opts, cursor,

tools/perf/builtin-script.c

2511

struct callchain_cursor *cursor = NULL;

tools/perf/builtin-script.c

2517

cursor = get_tls_callchain_cursor();

tools/perf/builtin-script.c

2518

if (thread__resolve_callchain(al->thread, cursor,

tools/perf/builtin-script.c

2521

cursor = NULL;

tools/perf/builtin-script.c

2523

fputc(cursor ? '\n' : ' ', fp);

tools/perf/builtin-script.c

2524

sample__fprintf_sym(sample, al, 0, output[type].print_ip_opts, cursor,

tools/perf/builtin-script.c

2801

struct callchain_cursor *cursor = NULL;

tools/perf/builtin-script.c

2804

cursor = get_tls_callchain_cursor();

tools/perf/builtin-script.c

2805

if (thread__resolve_callchain(al.thread, cursor,

tools/perf/builtin-script.c

2809

cursor = NULL;

tools/perf/builtin-script.c

2813

fputc(cursor ? '\n' : ' ', fp);

tools/perf/builtin-script.c

2815

cursor, symbol_conf.bt_stop_list, fp);

tools/perf/builtin-timechart.c

1018

struct per_pid *new_list, *p, *cursor, *prev;

tools/perf/builtin-timechart.c

1034

cursor = new_list;

tools/perf/builtin-timechart.c

1035

while (cursor) {

tools/perf/builtin-timechart.c

1036

if (cursor->ppid > p->ppid ||

tools/perf/builtin-timechart.c

1037

(cursor->ppid == p->ppid && cursor->pid > p->pid)) {

tools/perf/builtin-timechart.c

1042

cursor = NULL;

tools/perf/builtin-timechart.c

1047

cursor = NULL;

tools/perf/builtin-timechart.c

1052

prev = cursor;

tools/perf/builtin-timechart.c

1053

cursor = cursor->next;

tools/perf/builtin-timechart.c

1054

if (!cursor)

tools/perf/builtin-timechart.c

204

struct per_pid *cursor = tchart->all_data;

tools/perf/builtin-timechart.c

206

while (cursor) {

tools/perf/builtin-timechart.c

207

if (cursor->pid == pid)

tools/perf/builtin-timechart.c

208

return cursor;

tools/perf/builtin-timechart.c

209

cursor = cursor->next;

tools/perf/builtin-timechart.c

211

cursor = zalloc(sizeof(*cursor));

tools/perf/builtin-timechart.c

212

assert(cursor != NULL);

tools/perf/builtin-timechart.c

213

cursor->pid = pid;

tools/perf/builtin-timechart.c

214

cursor->next = tchart->all_data;

tools/perf/builtin-timechart.c

215

tchart->all_data = cursor;

tools/perf/builtin-timechart.c

216

return cursor;

tools/perf/builtin-trace.c

2918

struct callchain_cursor *cursor)

tools/perf/builtin-trace.c

2931

err = thread__resolve_callchain(al.thread, cursor, sample, NULL, NULL, max_stack);

tools/perf/builtin-trace.c

2992

struct callchain_cursor *cursor = get_tls_callchain_cursor();

tools/perf/builtin-trace.c

2994

callchain_ret = trace__resolve_callchain(trace, sample, cursor);

tools/perf/builtin-trace.c

2996

if (cursor->nr < trace->min_stack)

tools/perf/builtin-trace.c

3316

struct callchain_cursor *cursor = get_tls_callchain_cursor();

tools/perf/builtin-trace.c

3318

callchain_ret = trace__resolve_callchain(trace, sample, cursor);

tools/perf/builtin-trace.c

3320

if (cursor->nr < trace->min_stack)

tools/perf/builtin-trace.c

3429

struct callchain_cursor *cursor = get_tls_callchain_cursor();

tools/perf/builtin-trace.c

3431

callchain_ret = trace__resolve_callchain(trace, sample, cursor);

tools/perf/builtin-trace.c

3433

if (cursor->nr < trace->min_stack)

tools/perf/ui/browsers/annotate.c

155

static int is_fused(struct annotate_browser *ab, struct disasm_line *cursor)

tools/perf/ui/browsers/annotate.c

157

struct disasm_line *pos = list_prev_entry(cursor, al.node);

tools/perf/ui/browsers/annotate.c

175

if (!name || !cursor->ins.name)

tools/perf/ui/browsers/annotate.c

178

if (ins__is_fused(ab->arch, name, cursor->ins.name))

tools/perf/ui/browsers/annotate.c

186

struct disasm_line *cursor = disasm_line(ab->selection);

tools/perf/ui/browsers/annotate.c

201

if (!disasm_line__is_valid_local_jump(cursor, sym))

tools/perf/ui/browsers/annotate.c

224

target = annotated_source__get_line(notes->src, cursor->ops.target.offset);

tools/perf/ui/browsers/annotate.c

227

cursor->ops.target.offset);

tools/perf/ui/browsers/annotate.c

232

from = cursor->al.idx_asm;

tools/perf/ui/browsers/annotate.c

235

from = (u64)cursor->al.idx;

tools/perf/ui/browsers/annotate.c

246

diff = is_fused(ab, cursor);

tools/perf/ui/browsers/annotate.c

531

struct disasm_line *cursor = disasm_line(ab->selection);

tools/perf/ui/browsers/annotate.c

532

struct annotation_line *al = &cursor->al;

tools/perf/util/callchain.c

1001

u64 start = cursor->pos;

tools/perf/util/callchain.c

1015

node = callchain_cursor_current(cursor);

tools/perf/util/callchain.c

1025

callchain_cursor_advance(cursor);

tools/perf/util/callchain.c

1034

matches = cursor->pos - start;

tools/perf/util/callchain.c

1038

if (split_add_child(root, cursor, cnode, start, matches,

tools/perf/util/callchain.c

1046

if (matches == root->val_nr && cursor->pos == cursor->nr) {

tools/perf/util/callchain.c

1053

if (append_chain_children(root, cursor, period) < 0)

tools/perf/util/callchain.c

1060

struct callchain_cursor *cursor,

tools/perf/util/callchain.c

1063

if (cursor == NULL)

tools/perf/util/callchain.c

1066

if (!cursor->nr)

tools/perf/util/callchain.c

1069

callchain_cursor_commit(cursor);

tools/perf/util/callchain.c

1071

if (append_chain_children(&root->node, cursor, period) < 0)

tools/perf/util/callchain.c

1074

if (cursor->nr > root->max_depth)

tools/perf/util/callchain.c

1075

root->max_depth = cursor->nr;

tools/perf/util/callchain.c

1081

merge_chain_branch(struct callchain_cursor *cursor,

tools/perf/util/callchain.c

1084

struct callchain_cursor_node **old_last = cursor->last;

tools/perf/util/callchain.c

1088

int old_pos = cursor->nr;

tools/perf/util/callchain.c

1096

callchain_cursor_append(cursor, list->ip, &ms, false, NULL, 0, 0, 0, list->srcline);

tools/perf/util/callchain.c

1105

callchain_cursor_commit(cursor);

tools/perf/util/callchain.c

1106

if (append_chain_children(dst, cursor, src->hit) < 0)

tools/perf/util/callchain.c

1116

err = merge_chain_branch(cursor, dst, child);

tools/perf/util/callchain.c

1123

cursor->nr = old_pos;

tools/perf/util/callchain.c

1124

cursor->last = old_last;

tools/perf/util/callchain.c

1129

int callchain_merge(struct callchain_cursor *cursor,

tools/perf/util/callchain.c

1132

return merge_chain_branch(cursor, &dst->node, &src->node);

tools/perf/util/callchain.c

1135

int callchain_cursor_append(struct callchain_cursor *cursor,

tools/perf/util/callchain.c

1141

struct callchain_cursor_node *node = *cursor->last;

tools/perf/util/callchain.c

1148

*cursor->last = node;

tools/perf/util/callchain.c

1164

cursor->nr++;

tools/perf/util/callchain.c

1166

cursor->last = &node->next;

tools/perf/util/callchain.c

1172

struct callchain_cursor *cursor, struct symbol **parent,

tools/perf/util/callchain.c

1181

return thread__resolve_callchain(al->thread, cursor, sample,

tools/perf/util/callchain.c

1581

void callchain_cursor_cleanup(struct callchain_cursor *cursor)

tools/perf/util/callchain.c

1585

callchain_cursor_reset(cursor);

tools/perf/util/callchain.c

1587

for (node = cursor->first; node; node = next) {

tools/perf/util/callchain.c

1591

cursor->first = NULL;

tools/perf/util/callchain.c

1592

cursor->last = &cursor->first;

tools/perf/util/callchain.c

1593

cursor->curr = NULL;

tools/perf/util/callchain.c

1667

struct callchain_cursor *cursor = vcursor;

tools/perf/util/callchain.c

1670

callchain_cursor_reset(cursor);

tools/perf/util/callchain.c

1671

for (node = cursor->first; node != NULL; node = next) {

tools/perf/util/callchain.c

1675

free(cursor);

tools/perf/util/callchain.c

1689

struct callchain_cursor *cursor;

tools/perf/util/callchain.c

1692

cursor = pthread_getspecific(callchain_cursor);

tools/perf/util/callchain.c

1693

if (!cursor) {

tools/perf/util/callchain.c

1694

cursor = zalloc(sizeof(*cursor));

tools/perf/util/callchain.c

1695

if (!cursor)

tools/perf/util/callchain.c

1697

pthread_setspecific(callchain_cursor, cursor);

tools/perf/util/callchain.c

1699

return cursor;

tools/perf/util/callchain.c

1735

void callchain_cursor_reset(struct callchain_cursor *cursor)

tools/perf/util/callchain.c

1739

cursor->nr = 0;

tools/perf/util/callchain.c

1740

cursor->last = &cursor->first;

tools/perf/util/callchain.c

1742

for (node = cursor->first; node != NULL; node = node->next)

tools/perf/util/callchain.c

1875

struct callchain_cursor *cursor = get_tls_callchain_cursor();

tools/perf/util/callchain.c

1878

if (!cursor)

tools/perf/util/callchain.c

1882

ret = __thread__resolve_callchain(thread, cursor, sample,

tools/perf/util/callchain.c

1889

callchain_cursor_commit(cursor);

tools/perf/util/callchain.c

1892

struct callchain_cursor_node *node = callchain_cursor_current(cursor);

tools/perf/util/callchain.c

1901

callchain_cursor_advance(cursor);

tools/perf/util/callchain.c

631

fill_node(struct callchain_node *node, struct callchain_cursor *cursor)

tools/perf/util/callchain.c

635

node->val_nr = cursor->nr - cursor->pos;

tools/perf/util/callchain.c

639

cursor_node = callchain_cursor_current(cursor);

tools/perf/util/callchain.c

696

callchain_cursor_advance(cursor);

tools/perf/util/callchain.c

697

cursor_node = callchain_cursor_current(cursor);

tools/perf/util/callchain.c

704

struct callchain_cursor *cursor,

tools/perf/util/callchain.c

713

if (fill_node(new, cursor) < 0) {

tools/perf/util/callchain.c

872

struct callchain_cursor *cursor,

tools/perf/util/callchain.c

904

if (idx_total < cursor->nr) {

tools/perf/util/callchain.c

915

node = callchain_cursor_current(cursor);

tools/perf/util/callchain.c

916

new = add_child(parent, cursor, period);

tools/perf/util/callchain.c

945

struct callchain_cursor *cursor,

tools/perf/util/callchain.c

950

struct callchain_cursor *cursor,

tools/perf/util/callchain.c

958

node = callchain_cursor_current(cursor);

tools/perf/util/callchain.c

970

ret = append_chain(rnode, cursor, period);

tools/perf/util/callchain.c

982

rnode = add_child(root, cursor, period);

tools/perf/util/callchain.c

997

struct callchain_cursor *cursor,

tools/perf/util/callchain.h

161

struct callchain_cursor_node cursor;

tools/perf/util/callchain.h

196

struct callchain_cursor *cursor,

tools/perf/util/callchain.h

199

int callchain_merge(struct callchain_cursor *cursor,

tools/perf/util/callchain.h

202

void callchain_cursor_reset(struct callchain_cursor *cursor);

tools/perf/util/callchain.h

204

int callchain_cursor_append(struct callchain_cursor *cursor, u64 ip,

tools/perf/util/callchain.h

211

static inline void callchain_cursor_commit(struct callchain_cursor *cursor)

tools/perf/util/callchain.h

213

if (cursor == NULL)

tools/perf/util/callchain.h

215

cursor->curr = cursor->first;

tools/perf/util/callchain.h

216

cursor->pos = 0;

tools/perf/util/callchain.h

221

callchain_cursor_current(struct callchain_cursor *cursor)

tools/perf/util/callchain.h

223

if (cursor == NULL || cursor->pos == cursor->nr)

tools/perf/util/callchain.h

226

return cursor->curr;

tools/perf/util/callchain.h

229

static inline void callchain_cursor_advance(struct callchain_cursor *cursor)

tools/perf/util/callchain.h

231

cursor->curr = cursor->curr->next;

tools/perf/util/callchain.h

232

cursor->pos++;

tools/perf/util/callchain.h

245

struct callchain_cursor *cursor, struct symbol **parent,

tools/perf/util/callchain.h

289

void callchain_cursor_cleanup(struct callchain_cursor *cursor);

tools/perf/util/db-export.c

216

struct callchain_cursor *cursor;

tools/perf/util/db-export.c

228

cursor = get_tls_callchain_cursor();

tools/perf/util/db-export.c

229

err = thread__resolve_callchain(thread, cursor,

tools/perf/util/db-export.c

235

callchain_cursor_commit(cursor);

tools/perf/util/db-export.c

243

node = callchain_cursor_current(cursor);

tools/perf/util/db-export.c

268

callchain_cursor_advance(cursor);

tools/perf/util/evsel_fprintf.c

113

unsigned int print_opts, struct callchain_cursor *cursor,

tools/perf/util/evsel_fprintf.c

131

if (cursor == NULL)

tools/perf/util/evsel_fprintf.c

135

callchain_cursor_commit(cursor);

tools/perf/util/evsel_fprintf.c

142

node = callchain_cursor_current(cursor);

tools/perf/util/evsel_fprintf.c

209

callchain_cursor_advance(cursor);

tools/perf/util/evsel_fprintf.c

218

struct callchain_cursor *cursor, struct strlist *bt_stop_list, FILE *fp)

tools/perf/util/evsel_fprintf.c

229

if (cursor != NULL) {

tools/perf/util/evsel_fprintf.c

231

cursor, bt_stop_list, fp);

tools/perf/util/evsel_fprintf.h

38

unsigned int print_opts, struct callchain_cursor *cursor,

tools/perf/util/evsel_fprintf.h

43

struct callchain_cursor *cursor,

tools/perf/util/hist.c

1142

struct callchain_cursor *cursor = get_tls_callchain_cursor();

tools/perf/util/hist.c

1144

if (cursor == NULL)

tools/perf/util/hist.c

1147

callchain_cursor_commit(cursor);

tools/perf/util/hist.c

1154

he_cache = calloc(cursor->nr + 1, sizeof(*he_cache));

tools/perf/util/hist.c

1248

struct callchain_cursor cursor, *tls_cursor = get_tls_callchain_cursor();

tools/perf/util/hist.c

1254

callchain_cursor_snapshot(&cursor, tls_cursor);

tools/perf/util/hist.c

1287

callchain_append(he->callchain, &cursor, sample->period);

tools/perf/util/hist.c

1729

struct callchain_cursor *cursor = get_tls_callchain_cursor();

tools/perf/util/hist.c

1731

if (cursor == NULL)

tools/perf/util/hist.c

1734

callchain_cursor_reset(cursor);

tools/perf/util/hist.c

1735

if (callchain_merge(cursor,

tools/perf/util/hist.c

1777

struct callchain_cursor *cursor = get_tls_callchain_cursor();

tools/perf/util/hist.c

1779

if (cursor != NULL) {

tools/perf/util/hist.c

1780

callchain_cursor_reset(cursor);

tools/perf/util/hist.c

1781

if (callchain_merge(cursor, iter->callchain, he->callchain) < 0)

tools/perf/util/libunwind-arch/libunwind-arch.h

18

void *cursor;

tools/perf/util/libunwind-arch/libunwind-arm.c

238

ui->ui.cursor = &ui->_cursor;

tools/perf/util/libunwind-arch/libunwind-arm.c

269

ret = unw_step(ui->cursor);

tools/perf/util/libunwind-arch/libunwind-arm.c

273

unw_get_reg(ui->cursor, UNW_REG_IP, &ip);

tools/perf/util/libunwind-arch/libunwind-arm.c

275

if (unw_is_signal_frame(ui->cursor) <= 0) {

tools/perf/util/libunwind-arch/libunwind-arm64.c

237

ui->ui.cursor = &ui->_cursor;

tools/perf/util/libunwind-arch/libunwind-arm64.c

268

ret = unw_step(ui->cursor);

tools/perf/util/libunwind-arch/libunwind-arm64.c

272

unw_get_reg(ui->cursor, UNW_REG_IP, &ip);

tools/perf/util/libunwind-arch/libunwind-arm64.c

274

if (unw_is_signal_frame(ui->cursor) <= 0) {

tools/perf/util/libunwind-arch/libunwind-i386.c

260

ui->ui.cursor = &ui->_cursor;

tools/perf/util/libunwind-arch/libunwind-i386.c

291

ret = unw_step(ui->cursor);

tools/perf/util/libunwind-arch/libunwind-i386.c

295

unw_get_reg(ui->cursor, UNW_REG_IP, &ip);

tools/perf/util/libunwind-arch/libunwind-i386.c

297

if (unw_is_signal_frame(ui->cursor) <= 0) {

tools/perf/util/libunwind-arch/libunwind-loongarch.c

245

ui->ui.cursor = &ui->_cursor;

tools/perf/util/libunwind-arch/libunwind-loongarch.c

276

ret = unw_step(ui->cursor);

tools/perf/util/libunwind-arch/libunwind-loongarch.c

280

unw_get_reg(ui->cursor, UNW_REG_IP, &ip);

tools/perf/util/libunwind-arch/libunwind-loongarch.c

282

if (unw_is_signal_frame(ui->cursor) <= 0) {

tools/perf/util/libunwind-arch/libunwind-mips.c

247

ui->ui.cursor = &ui->_cursor;

tools/perf/util/libunwind-arch/libunwind-mips.c

278

ret = unw_step(ui->cursor);

tools/perf/util/libunwind-arch/libunwind-mips.c

282

unw_get_reg(ui->cursor, UNW_REG_IP, &ip);

tools/perf/util/libunwind-arch/libunwind-mips.c

284

if (unw_is_signal_frame(ui->cursor) <= 0) {

tools/perf/util/libunwind-arch/libunwind-ppc32.c

251

ui->ui.cursor = &ui->_cursor;

tools/perf/util/libunwind-arch/libunwind-ppc32.c

282

ret = unw_step(ui->cursor);

tools/perf/util/libunwind-arch/libunwind-ppc32.c

286

unw_get_reg(ui->cursor, UNW_REG_IP, &ip);

tools/perf/util/libunwind-arch/libunwind-ppc32.c

288

if (unw_is_signal_frame(ui->cursor) <= 0) {

tools/perf/util/libunwind-arch/libunwind-ppc64.c

251

ui->ui.cursor = &ui->_cursor;

tools/perf/util/libunwind-arch/libunwind-ppc64.c

282

ret = unw_step(ui->cursor);

tools/perf/util/libunwind-arch/libunwind-ppc64.c

286

unw_get_reg(ui->cursor, UNW_REG_IP, &ip);

tools/perf/util/libunwind-arch/libunwind-ppc64.c

288

if (unw_is_signal_frame(ui->cursor) <= 0) {

tools/perf/util/libunwind-arch/libunwind-riscv.c

245

ui->ui.cursor = &ui->_cursor;

tools/perf/util/libunwind-arch/libunwind-riscv.c

276

ret = unw_step(ui->cursor);

tools/perf/util/libunwind-arch/libunwind-riscv.c

280

unw_get_reg(ui->cursor, UNW_REG_IP, &ip);

tools/perf/util/libunwind-arch/libunwind-riscv.c

282

if (unw_is_signal_frame(ui->cursor) <= 0) {

tools/perf/util/libunwind-arch/libunwind-s390.c

247

ui->ui.cursor = &ui->_cursor;

tools/perf/util/libunwind-arch/libunwind-s390.c

278

ret = unw_step(ui->cursor);

tools/perf/util/libunwind-arch/libunwind-s390.c

282

unw_get_reg(ui->cursor, UNW_REG_IP, &ip);

tools/perf/util/libunwind-arch/libunwind-s390.c

284

if (unw_is_signal_frame(ui->cursor) <= 0) {

tools/perf/util/libunwind-arch/libunwind-x86_64.c

269

ui->ui.cursor = &ui->_cursor;

tools/perf/util/libunwind-arch/libunwind-x86_64.c

299

ret = unw_step(ui->cursor);

tools/perf/util/libunwind-arch/libunwind-x86_64.c

303

unw_get_reg(ui->cursor, UNW_REG_IP, &ip);

tools/perf/util/libunwind-arch/libunwind-x86_64.c

305

if (unw_is_signal_frame(ui->cursor) <= 0) {

tools/perf/util/machine.c

2136

static int append_inlines(struct callchain_cursor *cursor, struct map_symbol *ms, u64 ip,

tools/perf/util/machine.c

2172

ret = callchain_cursor_append(cursor, ip, &ilist_ms,

tools/perf/util/machine.c

2176

ret = callchain_cursor_append(cursor, ip, &ilist_ms, false,

tools/perf/util/machine.c

2190

struct callchain_cursor *cursor,

tools/perf/util/machine.c

2233

callchain_cursor_reset(cursor);

tools/perf/util/machine.c

2254

callchain_cursor_reset(cursor);

tools/perf/util/machine.c

2270

if (append_inlines(cursor, &ms, ip, branch, flags, nr_loop_iter,

tools/perf/util/machine.c

2275

err = callchain_cursor_append(cursor, ip, &ms,

tools/perf/util/machine.c

2371

struct callchain_cursor *cursor,

tools/perf/util/machine.c

2385

err = add_callchain_ip(thread, cursor, parent,

tools/perf/util/machine.c

2396

err = add_callchain_ip(thread, cursor, parent,

tools/perf/util/machine.c

2408

struct callchain_cursor *cursor,

tools/perf/util/machine.c

2416

if (cursor->pos == cursor->nr) {

tools/perf/util/machine.c

2421

if (!cursor->curr)

tools/perf/util/machine.c

2422

cursor->curr = cursor->first;

tools/perf/util/machine.c

2424

cursor->curr = cursor->curr->next;

tools/perf/util/machine.c

2427

memcpy(&lbr_stitch->prev_lbr_cursor[idx], cursor->curr,

tools/perf/util/machine.c

2429

lbr_stitch->prev_lbr_cursor[idx].ms.thread = thread__get(cursor->curr->ms.thread);

tools/perf/util/machine.c

2430

lbr_stitch->prev_lbr_cursor[idx].ms.map = map__get(cursor->curr->ms.map);

tools/perf/util/machine.c

2433

cursor->pos++;

tools/perf/util/machine.c

2437

struct callchain_cursor *cursor,

tools/perf/util/machine.c

2459

cursor->curr = NULL;

tools/perf/util/machine.c

2460

cursor->pos = cursor->nr;

tools/perf/util/machine.c

2461

if (cursor->nr) {

tools/perf/util/machine.c

2462

cursor->curr = cursor->first;

tools/perf/util/machine.c

2463

for (i = 0; i < (int)(cursor->nr - 1); i++)

tools/perf/util/machine.c

2464

cursor->curr = cursor->curr->next;

tools/perf/util/machine.c

2479

err = add_callchain_ip(thread, cursor, parent,

tools/perf/util/machine.c

2492

if (thread__lbr_stitch(thread) && (cursor->pos != cursor->nr)) {

tools/perf/util/machine.c

2493

if (!cursor->curr)

tools/perf/util/machine.c

2494

cursor->curr = cursor->first;

tools/perf/util/machine.c

2496

cursor->curr = cursor->curr->next;

tools/perf/util/machine.c

2497

cursor->pos++;

tools/perf/util/machine.c

2504

err = add_callchain_ip(thread, cursor, parent,

tools/perf/util/machine.c

2510

save_lbr_cursor_node(thread, cursor, i);

tools/perf/util/machine.c

2519

err = add_callchain_ip(thread, cursor, parent,

tools/perf/util/machine.c

2525

save_lbr_cursor_node(thread, cursor, i);

tools/perf/util/machine.c

2539

err = add_callchain_ip(thread, cursor, parent,

tools/perf/util/machine.c

2551

struct callchain_cursor *cursor)

tools/perf/util/machine.c

2559

cnode = &stitch_node->cursor;

tools/perf/util/machine.c

2561

err = callchain_cursor_append(cursor, cnode->ip,

tools/perf/util/machine.c

2651

memcpy(&stitch_node->cursor, &lbr_stitch->prev_lbr_cursor[i],

tools/perf/util/machine.c

2654

stitch_node->cursor.ms.thread =

tools/perf/util/machine.c

2656

stitch_node->cursor.ms.map = map__get(lbr_stitch->prev_lbr_cursor[i].ms.map);

tools/perf/util/machine.c

2705

struct callchain_cursor *cursor,

tools/perf/util/machine.c

2742

map_symbol__exit(&stitch_node->cursor.ms);

tools/perf/util/machine.c

2751

err = lbr_callchain_add_kernel_ip(thread, cursor, sample,

tools/perf/util/machine.c

2757

err = lbr_callchain_add_lbr_ip(thread, cursor, sample, parent,

tools/perf/util/machine.c

2763

err = lbr_callchain_add_stitched_lbr_ip(thread, cursor);

tools/perf/util/machine.c

2770

err = lbr_callchain_add_stitched_lbr_ip(thread, cursor);

tools/perf/util/machine.c

2774

err = lbr_callchain_add_lbr_ip(thread, cursor, sample, parent,

tools/perf/util/machine.c

2780

err = lbr_callchain_add_kernel_ip(thread, cursor, sample,

tools/perf/util/machine.c

2793

struct callchain_cursor *cursor,

tools/perf/util/machine.c

2804

err = add_callchain_ip(thread, cursor, parent,

tools/perf/util/machine.c

2823

struct callchain_cursor *cursor,

tools/perf/util/machine.c

2847

err = resolve_lbr_callchain_sample(thread, cursor, sample, parent,

tools/perf/util/machine.c

2911

err = add_callchain_ip(thread, cursor, parent,

tools/perf/util/machine.c

2918

err = add_callchain_ip(thread, cursor, parent, root_al,

tools/perf/util/machine.c

2937

err = find_prev_cpumode(chain, thread, cursor, parent, root_al,

tools/perf/util/machine.c

2959

err = find_prev_cpumode(chain, thread, cursor, parent,

tools/perf/util/machine.c

2986

err = add_callchain_ip(thread, cursor, parent,

tools/perf/util/machine.c

2994

err = add_callchain_ip(thread, cursor, parent,

tools/perf/util/machine.c

3007

struct callchain_cursor *cursor = arg;

tools/perf/util/machine.c

3014

if (append_inlines(cursor, &entry->ms, entry->ip, /*branch=*/false, /*branch_flags=*/NULL,

tools/perf/util/machine.c

3026

return callchain_cursor_append(cursor, entry->ip, &entry->ms,

tools/perf/util/machine.c

3031

struct callchain_cursor *cursor,

tools/perf/util/machine.c

3050

return unwind__get_entries(unwind_entry, cursor,

tools/perf/util/machine.c

3055

struct callchain_cursor *cursor,

tools/perf/util/machine.c

3064

if (cursor == NULL)

tools/perf/util/machine.c

3067

callchain_cursor_reset(cursor);

tools/perf/util/machine.c

3070

ret = thread__resolve_callchain_sample(thread, cursor,

tools/perf/util/machine.c

3076

ret = thread__resolve_callchain_unwind(thread, cursor,

tools/perf/util/machine.c

3080

ret = thread__resolve_callchain_unwind(thread, cursor,

tools/perf/util/machine.c

3085

ret = thread__resolve_callchain_sample(thread, cursor,

tools/perf/util/machine.h

189

struct callchain_cursor *cursor,

tools/perf/util/machine.h

197

struct callchain_cursor *cursor,

tools/perf/util/machine.h

204

cursor,

tools/perf/util/scripting-engines/trace-event-perl.c

262

struct callchain_cursor *cursor;

tools/perf/util/scripting-engines/trace-event-perl.c

272

cursor = get_tls_callchain_cursor();

tools/perf/util/scripting-engines/trace-event-perl.c

274

if (thread__resolve_callchain(al->thread, cursor,

tools/perf/util/scripting-engines/trace-event-perl.c

279

callchain_cursor_commit(cursor);

tools/perf/util/scripting-engines/trace-event-perl.c

285

node = callchain_cursor_current(cursor);

tools/perf/util/scripting-engines/trace-event-perl.c

333

callchain_cursor_advance(cursor);

tools/perf/util/scripting-engines/trace-event-python.c

396

struct callchain_cursor *cursor;

tools/perf/util/scripting-engines/trace-event-python.c

405

cursor = get_tls_callchain_cursor();

tools/perf/util/scripting-engines/trace-event-python.c

406

if (thread__resolve_callchain(al->thread, cursor,

tools/perf/util/scripting-engines/trace-event-python.c

412

callchain_cursor_commit(cursor);

tools/perf/util/scripting-engines/trace-event-python.c

418

node = callchain_cursor_current(cursor);

tools/perf/util/scripting-engines/trace-event-python.c

474

callchain_cursor_advance(cursor);

tools/perf/util/thread.c

622

map_symbol__exit(&pos->cursor.ms);

tools/testing/selftests/bpf/progs/test_lwt_seg6local.c

57

void *cursor, *data_end;

tools/testing/selftests/bpf/progs/test_lwt_seg6local.c

63

cursor = (void *)(long)skb->data;

tools/testing/selftests/bpf/progs/test_lwt_seg6local.c

64

ipver = (uint8_t *)cursor;

tools/testing/selftests/bpf/progs/test_lwt_seg6local.c

72

ip = cursor_advance(cursor, sizeof(*ip));

tools/testing/selftests/bpf/progs/test_lwt_seg6local.c

79

srh = cursor_advance(cursor, sizeof(*srh));

tools/testing/selftests/bpf/progs/test_seg6_loop.c

57

void *cursor, *data_end;

tools/testing/selftests/bpf/progs/test_seg6_loop.c

63

cursor = (void *)(long)skb->data;

tools/testing/selftests/bpf/progs/test_seg6_loop.c

64

ipver = (uint8_t *)cursor;

tools/testing/selftests/bpf/progs/test_seg6_loop.c

72

ip = cursor_advance(cursor, sizeof(*ip));

tools/testing/selftests/bpf/progs/test_seg6_loop.c

79

srh = cursor_advance(cursor, sizeof(*srh));

tools/testing/selftests/cachestat/test_cachestat.c

44

char *cursor, *data;

tools/testing/selftests/cachestat/test_cachestat.c

62

cursor = data;

tools/testing/selftests/cachestat/test_cachestat.c

65

ssize_t read_len = read(random_fd, cursor, remained);

tools/testing/selftests/cachestat/test_cachestat.c

74

cursor += read_len;

tools/testing/selftests/cachestat/test_cachestat.c

79

cursor = data;

tools/testing/selftests/cachestat/test_cachestat.c

81

ssize_t write_len = write(fd, cursor, remained);

tools/testing/selftests/cachestat/test_cachestat.c

90

cursor += write_len;

tools/verification/rv/src/in_kernel.c

61

char *available_monitors, *cursor, *line;

tools/verification/rv/src/in_kernel.c

70

cursor = available_monitors;

tools/verification/rv/src/in_kernel.c

71

while ((line = strsep(&cursor, "\n"))) {

tools/verification/rv/src/in_kernel.c

84

line = strsep(&cursor, "\n");