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

2556

if (iocg->cursor) {

block/blk-iocost.c

2557

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

block/blk-iocost.c

2629

iocg->cursor = bio_end_sector(bio);

block/blk-iocost.c

2765

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

block/blk-iocost.c

2766

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

137

.cursor = hd44780_common_cursor,

drivers/auxdisplay/hd44780.c

193

.cursor = hd44780_common_cursor,

drivers/auxdisplay/lcd2s.c

293

.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

682

struct dma_resv_iter cursor;

drivers/dma-buf/dma-resv.c

685

dma_resv_iter_begin(&cursor, obj, usage);

drivers/dma-buf/dma-resv.c

686

dma_resv_for_each_fence_unlocked(&cursor, fence) {

drivers/dma-buf/dma-resv.c

696

dma_resv_iter_end(&cursor);

drivers/dma-buf/dma-resv.c

714

struct dma_resv_iter cursor;

drivers/dma-buf/dma-resv.c

717

dma_resv_iter_begin(&cursor, obj, usage);

drivers/dma-buf/dma-resv.c

718

dma_resv_for_each_fence_unlocked(&cursor, fence) {

drivers/dma-buf/dma-resv.c

721

dma_resv_iter_end(&cursor);

drivers/dma-buf/dma-resv.c

740

struct dma_resv_iter cursor;

drivers/dma-buf/dma-resv.c

743

dma_resv_iter_begin(&cursor, obj, usage);

drivers/dma-buf/dma-resv.c

744

dma_resv_for_each_fence_unlocked(&cursor, fence) {

drivers/dma-buf/dma-resv.c

745

dma_resv_iter_end(&cursor);

drivers/dma-buf/dma-resv.c

748

dma_resv_iter_end(&cursor);

drivers/dma-buf/dma-resv.c

764

struct dma_resv_iter cursor;

drivers/dma-buf/dma-resv.c

767

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

drivers/dma-buf/dma-resv.c

769

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

139

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

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

150

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

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

173

struct dma_resv_iter cursor;

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

202

dma_resv_iter_begin(&cursor, &resv, usage);

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

203

dma_resv_for_each_fence_unlocked(&cursor, fence) {

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

209

if (!dma_resv_iter_is_restarted(&cursor)) {

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

218

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

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

228

cursor.fences = (void*)~0;

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

236

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

23

u32 cursor;

drivers/firmware/google/memconsole-coreboot.c

42

u32 cursor = cbmem_console->cursor & CURSOR_MASK;

drivers/firmware/google/memconsole-coreboot.c

43

u32 flags = cbmem_console->cursor & ~CURSOR_MASK;

drivers/firmware/google/memconsole-coreboot.c

53

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

drivers/firmware/google/memconsole-coreboot.c

54

cursor = 0;

drivers/firmware/google/memconsole-coreboot.c

55

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

drivers/firmware/google/memconsole-coreboot.c

56

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

drivers/firmware/google/memconsole-coreboot.c

58

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

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

2969

struct dma_resv_iter cursor;

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

2985

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_display.c

1863

struct amdgpu_res_cursor cursor;

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

1870

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

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

1872

tmp = cursor.start >> 31;

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

1873

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

1616

struct amdgpu_res_cursor cursor;

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

1626

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

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

1627

while (cursor.remaining) {

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

1628

size_t count, size = cursor.size;

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

1629

loff_t pos = cursor.start;

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

1640

ret += cursor.size;

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

1641

buf += cursor.size;

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

1642

amdgpu_res_next(&cursor, cursor.size);

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

2496

struct amdgpu_res_cursor cursor;

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

2508

amdgpu_res_first(bo->tbo.resource, 0, amdgpu_bo_size(bo), &cursor);

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

2511

while (cursor.remaining) {

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

2515

if (amdgpu_res_cleared(&cursor)) {

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

2516

amdgpu_res_next(&cursor, cursor.size);

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

2521

size = min(cursor.size, 256ULL << 20);

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

2524

&bo->tbo, bo->tbo.resource, &cursor,

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

2538

amdgpu_res_next(&cursor, size);

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

451

struct amdgpu_res_cursor cursor;

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

464

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

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

465

while (cursor.remaining) {

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

466

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

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

468

amdgpu_res_next(&cursor, cursor.size);

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

658

struct amdgpu_res_cursor cursor;

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

661

&cursor);

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

664

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

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

666

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

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

668

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

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

169

struct drm_plane *primary, struct drm_plane *cursor)

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

175

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

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

439

struct drm_plane *primary, *cursor = NULL;

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

446

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

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

1118

struct amdgpu_res_cursor cursor;

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

1171

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

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

1172

while (cursor.remaining) {

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

1175

num_entries = cursor.size >> AMDGPU_GPU_PAGE_SHIFT;

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

1180

uint64_t pfn = cursor.start >> PAGE_SHIFT;

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

1202

addr = cursor.start;

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

1205

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

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

1210

addr = vram_base + cursor.start;

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

1220

amdgpu_res_next(&cursor, num_entries * AMDGPU_GPU_PAGE_SIZE);

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

1523

struct dma_resv_iter cursor;

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

1526

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

588

struct amdgpu_vm_pt_cursor *cursor)

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

594

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

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

600

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

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

613

struct amdgpu_vm_pt_cursor cursor;

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

616

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

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

803

struct amdgpu_vm_pt_cursor cursor;

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

813

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

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

814

while (cursor.pfn < end) {

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

824

&cursor, params->immediate);

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

829

shift = amdgpu_vm_pt_level_shift(adev, cursor.level);

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

830

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

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

833

if (amdgpu_vm_pt_descendant(adev, &cursor))

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

838

if (cursor.level != AMDGPU_VM_PTB) {

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

839

if (!amdgpu_vm_pt_descendant(adev, &cursor))

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

848

if (amdgpu_vm_pt_descendant(adev, &cursor))

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

854

if (!amdgpu_vm_pt_ancestor(&cursor))

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

859

pt = cursor.entry->bo;

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

868

if (!amdgpu_vm_pt_ancestor(&cursor))

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

871

pt = cursor.entry->bo;

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

879

mask = amdgpu_vm_pt_entries_mask(adev, cursor.level);

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

880

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

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

882

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

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

890

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

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

910

cursor.level, pe_start, dst,

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

926

if (amdgpu_vm_pt_descendant(adev, &cursor)) {

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

933

while (cursor.pfn < frag_start) {

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

935

if (cursor.entry->bo) {

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

937

amdgpu_vm_pt_add_list(params, &cursor);

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

939

amdgpu_vm_pt_next(adev, &cursor);

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

944

amdgpu_vm_pt_next(adev, &cursor);

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

960

struct amdgpu_vm_pt_cursor cursor;

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

963

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

682

struct amdgpu_res_cursor cursor;

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

692

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

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

693

while (cursor.remaining) {

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

695

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

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

712

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

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

714

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

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

715

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

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

728

amdgpu_res_next(&cursor, size);

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

290

struct amdgpu_res_cursor cursor;

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

304

npages << PAGE_SHIFT, &cursor);

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

309

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

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

334

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

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

337

amdgpu_res_next(&cursor, PAGE_SIZE);

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

345

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

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

352

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

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

12366

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

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

12371

crtc_state->crtc->cursor);

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

12744

if ((drm_plane_mask(crtc->cursor) & new_crtc_state->plane_mask) &&

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

12746

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

398

plane->cursor.cursor_bpp = 32;

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

400

plane->cursor.cursor_width = 256;

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

401

plane->cursor.num_cursors = 1;

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

503

plane->cursor.cursor_bpp = 32;

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

504

plane->cursor.cursor_width = 256;

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

505

plane->cursor.num_cursors = 1;

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

382

} cursor;

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

185

phantom->cursor.num_cursors = 0;

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

186

phantom->cursor.cursor_width = 0;

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

10604

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

11108

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

11110

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

11111

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

11121

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

11240

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

11295

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

12568

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

7452

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

7508

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

8103

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

8104

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

8242

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

8243

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

9120

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

9122

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

9123

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

9133

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

362

struct drm_plane *cursor,

drivers/gpu/drm/drm_crtc.c

372

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

drivers/gpu/drm/drm_crtc.c

392

struct drm_plane *cursor,

drivers/gpu/drm/drm_crtc.c

401

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

drivers/gpu/drm/drm_crtc.c

444

struct drm_plane *cursor,

drivers/gpu/drm/drm_crtc.c

452

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

drivers/gpu/drm/drm_crtc.c

465

struct drm_plane *cursor,

drivers/gpu/drm/drm_crtc.c

484

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

688

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

drivers/gpu/drm/drm_mode_config.c

691

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

drivers/gpu/drm/drm_mode_config.c

694

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

drivers/gpu/drm/drm_mode_config.c

708

if (crtc->cursor) {

drivers/gpu/drm/drm_mode_config.c

709

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

drivers/gpu/drm/drm_mode_config.c

711

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

drivers/gpu/drm/drm_mode_config.c

713

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

drivers/gpu/drm/drm_mode_config.c

715

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

drivers/gpu/drm/drm_mode_config.c

716

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

3685

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

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

3686

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

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

3721

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

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

3814

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

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

3824

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

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

3850

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

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

3853

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

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

3977

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

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

4008

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

313

struct intel_plane *primary, *cursor;

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

351

cursor = intel_cursor_plane_create(display, pipe);

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

352

if (IS_ERR(cursor)) {

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

353

ret = PTR_ERR(cursor);

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

356

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

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

380

&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

1586

} cursor;

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

33

u16 cursor;

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

637

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

103

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

drivers/gpu/drm/loongson/lsdc_drv.c

109

&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

1858

struct drm_plane *cursor)

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

1867

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

382

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

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

434

cursor[ci++] = plane;

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

440

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

355

struct dma_resv_iter cursor;

drivers/gpu/drm/nouveau/nouveau_fence.c

358

dma_resv_for_each_fence(&cursor, resv,

drivers/gpu/drm/nouveau/nouveau_fence.c

364

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

964

struct dma_resv_iter cursor;

drivers/gpu/drm/scheduler/sched_main.c

970

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

1257

bool cursor)

drivers/gpu/drm/tegra/dc.c

1283

if (!cursor)

drivers/gpu/drm/tegra/dc.c

2619

struct drm_plane *cursor = NULL;

drivers/gpu/drm/tegra/dc.c

2666

cursor = tegra_dc_cursor_plane_create(drm, dc);

drivers/gpu/drm/tegra/dc.c

2667

if (IS_ERR(cursor)) {

drivers/gpu/drm/tegra/dc.c

2668

err = PTR_ERR(cursor);

drivers/gpu/drm/tegra/dc.c

2673

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

drivers/gpu/drm/tegra/dc.c

2674

if (IS_ERR(cursor)) {

drivers/gpu/drm/tegra/dc.c

2675

err = PTR_ERR(cursor);

drivers/gpu/drm/tegra/dc.c

2680

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

drivers/gpu/drm/tegra/dc.c

2723

if (!IS_ERR_OR_NULL(cursor))

drivers/gpu/drm/tegra/dc.c

2724

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

221

struct dma_resv_iter cursor;

drivers/gpu/drm/ttm/ttm_bo.c

224

dma_resv_iter_begin(&cursor, resv, DMA_RESV_USAGE_BOOKKEEP);

drivers/gpu/drm/ttm/ttm_bo.c

225

dma_resv_for_each_fence_unlocked(&cursor, fence) {

drivers/gpu/drm/ttm/ttm_bo.c

229

dma_resv_iter_end(&cursor);

drivers/gpu/drm/ttm/ttm_bo.c

449

struct ttm_resource_cursor cursor;

drivers/gpu/drm/ttm/ttm_bo.c

456

ttm_resource_cursor_init(&cursor, man);

drivers/gpu/drm/ttm/ttm_bo.c

457

res = ttm_resource_manager_first(&cursor);

drivers/gpu/drm/ttm/ttm_bo.c

458

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

621

ttm_resource_cursor_check_bulk(struct ttm_resource_cursor *cursor,

drivers/gpu/drm/ttm/ttm_resource.c

627

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

drivers/gpu/drm/ttm/ttm_resource.c

63

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

drivers/gpu/drm/ttm/ttm_resource.c

631

if (cursor->bulk != bulk) {

drivers/gpu/drm/ttm/ttm_resource.c

633

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

drivers/gpu/drm/ttm/ttm_resource.c

634

cursor->mem_type = next->mem_type;

drivers/gpu/drm/ttm/ttm_resource.c

636

list_del_init(&cursor->bulk_link);

drivers/gpu/drm/ttm/ttm_resource.c

638

cursor->bulk = bulk;

drivers/gpu/drm/ttm/ttm_resource.c

65

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

drivers/gpu/drm/ttm/ttm_resource.c

653

ttm_resource_manager_first(struct ttm_resource_cursor *cursor)

drivers/gpu/drm/ttm/ttm_resource.c

655

struct ttm_resource_manager *man = cursor->man;

drivers/gpu/drm/ttm/ttm_resource.c

66

ttm_resource_cursor_clear_bulk(cursor);

drivers/gpu/drm/ttm/ttm_resource.c

662

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

drivers/gpu/drm/ttm/ttm_resource.c

663

return ttm_resource_manager_next(cursor);

drivers/gpu/drm/ttm/ttm_resource.c

674

ttm_resource_manager_next(struct ttm_resource_cursor *cursor)

drivers/gpu/drm/ttm/ttm_resource.c

676

struct ttm_resource_manager *man = cursor->man;

drivers/gpu/drm/ttm/ttm_resource.c

682

lru = &cursor->hitch;

drivers/gpu/drm/ttm/ttm_resource.c

683

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

drivers/gpu/drm/ttm/ttm_resource.c

685

ttm_resource_cursor_check_bulk(cursor, lru);

drivers/gpu/drm/ttm/ttm_resource.c

686

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

drivers/gpu/drm/ttm/ttm_resource.c

691

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

drivers/gpu/drm/ttm/ttm_resource.c

694

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

drivers/gpu/drm/ttm/ttm_resource.c

695

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

2612

crtc->cursor = cursor_plane;

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

182

struct virtio_gpu_update_cursor cursor;

drivers/gpu/drm/virtio/virtgpu_plane.c

478

output->cursor.hdr.type =

drivers/gpu/drm/virtio/virtgpu_plane.c

480

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

drivers/gpu/drm/virtio/virtgpu_plane.c

482

output->cursor.hot_x =

drivers/gpu/drm/virtio/virtgpu_plane.c

484

output->cursor.hot_y =

drivers/gpu/drm/virtio/virtgpu_plane.c

487

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

drivers/gpu/drm/virtio/virtgpu_plane.c

488

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

drivers/gpu/drm/virtio/virtgpu_plane.c

494

output->cursor.hdr.type =

drivers/gpu/drm/virtio/virtgpu_plane.c

497

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

drivers/gpu/drm/virtio/virtgpu_plane.c

498

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

drivers/gpu/drm/virtio/virtgpu_vq.c

1302

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

drivers/gpu/drm/virtio/virtgpu_vq.c

1304

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

drivers/gpu/drm/vkms/vkms_crtc.c

204

struct drm_plane *cursor)

drivers/gpu/drm/vkms/vkms_crtc.c

211

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

415

struct vmw_cursor_plane *cursor;

drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c

428

cursor = &ldu->base.cursor;

drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c

460

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

drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c

471

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

drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c

501

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

drivers/gpu/drm/vmwgfx/vmwgfx_scrn.c

810

struct vmw_cursor_plane *cursor;

drivers/gpu/drm/vmwgfx/vmwgfx_scrn.c

823

cursor = &sou->base.cursor;

drivers/gpu/drm/vmwgfx/vmwgfx_scrn.c

850

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

drivers/gpu/drm/vmwgfx/vmwgfx_scrn.c

861

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

drivers/gpu/drm/vmwgfx/vmwgfx_scrn.c

890

&cursor->base,

drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c

1540

struct vmw_cursor_plane *cursor;

drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c

1553

cursor = &stdu->base.cursor;

drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c

1575

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

drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c

1586

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

drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c

1587

drm_plane_enable_fb_damage_clips(&cursor->base);

drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c

1616

&cursor->base,

drivers/gpu/drm/xe/xe_bo.c

1503

struct xe_res_cursor cursor;

drivers/gpu/drm/xe/xe_bo.c

1510

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

drivers/gpu/drm/xe/xe_bo.c

1511

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

drivers/gpu/drm/xe/xe_bo.c

1543

struct dma_resv_iter cursor;

drivers/gpu/drm/xe/xe_bo.c

1563

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

drivers/gpu/drm/xe/xe_bo.c

1641

struct xe_res_cursor cursor;

drivers/gpu/drm/xe/xe_bo.c

1663

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

drivers/gpu/drm/xe/xe_bo.c

1670

cursor.start);

drivers/gpu/drm/xe/xe_bo.c

1680

xe_res_next(&cursor, PAGE_SIZE);

drivers/gpu/drm/xe/xe_bo.c

669

struct dma_resv_iter cursor;

drivers/gpu/drm/xe/xe_bo.c

679

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

drivers/gpu/drm/xe/xe_bo.c

681

dma_resv_for_each_fence_unlocked(&cursor, fence)

drivers/gpu/drm/xe/xe_bo.c

683

dma_resv_iter_end(&cursor);

drivers/gpu/drm/xe/xe_migrate.c

2362

struct xe_res_cursor cursor;

drivers/gpu/drm/xe/xe_migrate.c

2430

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

drivers/gpu/drm/xe/xe_migrate.c

2435

cursor.start;

drivers/gpu/drm/xe/xe_migrate.c

2439

if (cursor.size > MAX_PREEMPTDISABLE_TRANSFER)

drivers/gpu/drm/xe/xe_migrate.c

2443

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

drivers/gpu/drm/xe/xe_migrate.c

2476

xe_res_next(&cursor, current_bytes);

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c

366

struct xe_res_cursor cursor;

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c

379

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

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c

380

while (cursor.remaining) {

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c

383

xe_res_next(&cursor, min_t(u64, cursor.size, SZ_2G));

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c

400

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

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c

402

phys_addr_t phys = cursor.start + xe_vram_region_io_start(tile->mem.vram);

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c

403

size_t size = min_t(u64, cursor.size, SZ_2G);

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c

416

xe_res_next(&cursor, size);

drivers/gpu/drm/xe/xe_userptr.c

106

dma_resv_iter_begin(&cursor, xe_vm_resv(vm),

drivers/gpu/drm/xe/xe_userptr.c

108

dma_resv_for_each_fence_unlocked(&cursor, fence)

drivers/gpu/drm/xe/xe_userptr.c

110

dma_resv_iter_end(&cursor);

drivers/gpu/drm/xe/xe_userptr.c

80

struct dma_resv_iter 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

2520

static void finish_cursor(struct cursor *cursor)

drivers/md/dm-vdo/block-map.c

2522

struct cursors *cursors = cursor->parent;

drivers/md/dm-vdo/block-map.c

2525

return_vio_to_pool(vdo_forget(cursor->vio));

drivers/md/dm-vdo/block-map.c

2534

static void traverse(struct cursor *cursor);

drivers/md/dm-vdo/block-map.c

2552

struct cursor *cursor = completion->parent;

drivers/md/dm-vdo/block-map.c

2553

height_t height = cursor->height;

drivers/md/dm-vdo/block-map.c

2554

struct cursor_level *level = &cursor->levels[height];

drivers/md/dm-vdo/block-map.c

2556

&(cursor->tree->segments[0].levels[height][level->page_index]);

drivers/md/dm-vdo/block-map.c

2559

vdo_copy_valid_page(cursor->vio->vio.data,

drivers/md/dm-vdo/block-map.c

2560

cursor->parent->zone->block_map->nonce,

drivers/md/dm-vdo/block-map.c

2561

pbn_from_vio_bio(cursor->vio->vio.bio), page);

drivers/md/dm-vdo/block-map.c

2562

traverse(cursor);

drivers/md/dm-vdo/block-map.c

2568

struct cursor *cursor = vio->completion.parent;

drivers/md/dm-vdo/block-map.c

2571

cursor->parent->zone->thread_id);

drivers/md/dm-vdo/block-map.c

2580

static void traverse(struct cursor *cursor)

drivers/md/dm-vdo/block-map.c

2582

for (; cursor->height < VDO_BLOCK_MAP_TREE_HEIGHT; cursor->height++) {

drivers/md/dm-vdo/block-map.c

2583

height_t height = cursor->height;

drivers/md/dm-vdo/block-map.c

2584

struct cursor_level *level = &cursor->levels[height];

drivers/md/dm-vdo/block-map.c

2586

&(cursor->tree->segments[0].levels[height][level->page_index]);

drivers/md/dm-vdo/block-map.c

2602

vdo_write_tree_page(tree_page, cursor->parent->zone);

drivers/md/dm-vdo/block-map.c

2610

if (entry_index >= cursor->boundary.levels[height]) {

drivers/md/dm-vdo/block-map.c

2612

vdo_write_tree_page(tree_page, cursor->parent->zone);

drivers/md/dm-vdo/block-map.c

2616

if (cursor->height < VDO_BLOCK_MAP_TREE_HEIGHT - 1) {

drivers/md/dm-vdo/block-map.c

2617

int result = cursor->parent->entry_callback(location.pbn,

drivers/md/dm-vdo/block-map.c

2618

cursor->parent->completion);

drivers/md/dm-vdo/block-map.c

2621

vdo_write_tree_page(tree_page, cursor->parent->zone);

drivers/md/dm-vdo/block-map.c

2626

if (cursor->height == 0)

drivers/md/dm-vdo/block-map.c

2629

cursor->height--;

drivers/md/dm-vdo/block-map.c

2630

next_level = &cursor->levels[cursor->height];

drivers/md/dm-vdo/block-map.c

2634

vdo_submit_metadata_vio(&cursor->vio->vio, location.pbn,

drivers/md/dm-vdo/block-map.c

2641

finish_cursor(cursor);

drivers/md/dm-vdo/block-map.c

2654

struct cursor *cursor = container_of(waiter, struct cursor, waiter);

drivers/md/dm-vdo/block-map.c

2657

cursor->vio = pooled;

drivers/md/dm-vdo/block-map.c

2658

pooled->vio.completion.parent = cursor;

drivers/md/dm-vdo/block-map.c

2659

pooled->vio.completion.callback_thread_id = cursor->parent->zone->thread_id;

drivers/md/dm-vdo/block-map.c

2660

traverse(cursor);

drivers/md/dm-vdo/block-map.c

2711

struct cursor, __func__, &cursors);

drivers/md/dm-vdo/block-map.c

2723

struct cursor *cursor = &cursors->cursors[root];

drivers/md/dm-vdo/block-map.c

2725

*cursor = (struct cursor) {

drivers/md/dm-vdo/block-map.c

2732

cursor->waiter.callback = launch_cursor;

drivers/md/dm-vdo/block-map.c

2733

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

2196

struct list_head *cursor;

drivers/net/usb/r8152.c

2198

cursor = tp->tx_free.next;

drivers/net/usb/r8152.c

2199

list_del_init(cursor);

drivers/net/usb/r8152.c

2200

agg = list_entry(cursor, struct tx_agg, list);

drivers/net/usb/r8152.c

2525

struct list_head *cursor, *next, rx_queue;

drivers/net/usb/r8152.c

2556

list_for_each_safe(cursor, next, &rx_queue) {

drivers/net/usb/r8152.c

2572

list_del_init(cursor);

drivers/net/usb/r8152.c

2574

agg = list_entry(cursor, struct rx_agg, list);

drivers/net/wireless/realtek/rtw89/core.h

4227

static inline bool rtw89_txpwr_entcpy(void *entry, const void *cursor, u8 size,

drivers/net/wireless/realtek/rtw89/core.h

4232

memcpy(entry, cursor, valid_size);

drivers/net/wireless/realtek/rtw89/core.h

4238

#define rtw89_for_each_in_txpwr_conf(entry, cursor, conf) \

drivers/net/wireless/realtek/rtw89/core.h

4239

for (typecheck(const void *, cursor), (cursor) = (conf)->data; \

drivers/net/wireless/realtek/rtw89/core.h

4240

(cursor) < (conf)->data + (conf)->num_ents * (conf)->ent_sz; \

drivers/net/wireless/realtek/rtw89/core.h

4241

(cursor) += (conf)->ent_sz) \

drivers/net/wireless/realtek/rtw89/core.h

4242

if (rtw89_txpwr_entcpy(&(entry), cursor, sizeof(entry), conf))

drivers/net/wireless/realtek/rtw89/fw.c

10725

#define __fw_txpwr_entry_acceptable(e, cursor, ent_sz) \

drivers/net/wireless/realtek/rtw89/fw.c

10732

__accept = __fw_txpwr_entry_zero_ext((cursor) + __var_sz,\

drivers/net/wireless/realtek/rtw89/fw.c

10739

const void *cursor,

drivers/net/wireless/realtek/rtw89/fw.c

10742

if (!__fw_txpwr_entry_acceptable(e, cursor, conf->ent_sz))

drivers/net/wireless/realtek/rtw89/fw.c

10788

const void *cursor;

drivers/net/wireless/realtek/rtw89/fw.c

10793

rtw89_for_each_in_txpwr_conf(entry, cursor, conf) {

drivers/net/wireless/realtek/rtw89/fw.c

10794

if (!fw_txpwr_byrate_entry_valid(&entry, cursor, conf))

drivers/net/wireless/realtek/rtw89/fw.c

10813

const void *cursor,

drivers/net/wireless/realtek/rtw89/fw.c

10816

if (!__fw_txpwr_entry_acceptable(e, cursor, conf->ent_sz))

drivers/net/wireless/realtek/rtw89/fw.c

10840

const void *cursor;

drivers/net/wireless/realtek/rtw89/fw.c

10842

rtw89_for_each_in_txpwr_conf(entry, cursor, conf) {

drivers/net/wireless/realtek/rtw89/fw.c

10843

if (!fw_txpwr_lmt_2ghz_entry_valid(&entry, cursor, conf))

drivers/net/wireless/realtek/rtw89/fw.c

10853

const void *cursor,

drivers/net/wireless/realtek/rtw89/fw.c

10856

if (!__fw_txpwr_entry_acceptable(e, cursor, conf->ent_sz))

drivers/net/wireless/realtek/rtw89/fw.c

10880

const void *cursor;

drivers/net/wireless/realtek/rtw89/fw.c

10882

rtw89_for_each_in_txpwr_conf(entry, cursor, conf) {

drivers/net/wireless/realtek/rtw89/fw.c

10883

if (!fw_txpwr_lmt_5ghz_entry_valid(&entry, cursor, conf))

drivers/net/wireless/realtek/rtw89/fw.c

10893

const void *cursor,

drivers/net/wireless/realtek/rtw89/fw.c

10896

if (!__fw_txpwr_entry_acceptable(e, cursor, conf->ent_sz))

drivers/net/wireless/realtek/rtw89/fw.c

10922

const void *cursor;

drivers/net/wireless/realtek/rtw89/fw.c

10924

rtw89_for_each_in_txpwr_conf(entry, cursor, conf) {

drivers/net/wireless/realtek/rtw89/fw.c

10925

if (!fw_txpwr_lmt_6ghz_entry_valid(&entry, cursor, conf))

drivers/net/wireless/realtek/rtw89/fw.c

10935

const void *cursor,

drivers/net/wireless/realtek/rtw89/fw.c

10938

if (!__fw_txpwr_entry_acceptable(e, cursor, conf->ent_sz))

drivers/net/wireless/realtek/rtw89/fw.c

10958

const void *cursor;

drivers/net/wireless/realtek/rtw89/fw.c

10960

rtw89_for_each_in_txpwr_conf(entry, cursor, conf) {

drivers/net/wireless/realtek/rtw89/fw.c

10961

if (!fw_txpwr_lmt_ru_2ghz_entry_valid(&entry, cursor, conf))

drivers/net/wireless/realtek/rtw89/fw.c

10970

const void *cursor,

drivers/net/wireless/realtek/rtw89/fw.c

10973

if (!__fw_txpwr_entry_acceptable(e, cursor, conf->ent_sz))

drivers/net/wireless/realtek/rtw89/fw.c

10993

const void *cursor;

drivers/net/wireless/realtek/rtw89/fw.c

10995

rtw89_for_each_in_txpwr_conf(entry, cursor, conf) {

drivers/net/wireless/realtek/rtw89/fw.c

10996

if (!fw_txpwr_lmt_ru_5ghz_entry_valid(&entry, cursor, conf))

drivers/net/wireless/realtek/rtw89/fw.c

11005

const void *cursor,

drivers/net/wireless/realtek/rtw89/fw.c

11008

if (!__fw_txpwr_entry_acceptable(e, cursor, conf->ent_sz))

drivers/net/wireless/realtek/rtw89/fw.c

11030

const void *cursor;

drivers/net/wireless/realtek/rtw89/fw.c

11032

rtw89_for_each_in_txpwr_conf(entry, cursor, conf) {

drivers/net/wireless/realtek/rtw89/fw.c

11033

if (!fw_txpwr_lmt_ru_6ghz_entry_valid(&entry, cursor, conf))

drivers/net/wireless/realtek/rtw89/fw.c

11043

const void *cursor,

drivers/net/wireless/realtek/rtw89/fw.c

11046

if (!__fw_txpwr_entry_acceptable(e, cursor, conf->ent_sz))

drivers/net/wireless/realtek/rtw89/fw.c

11064

const void *cursor;

drivers/net/wireless/realtek/rtw89/fw.c

11066

rtw89_for_each_in_txpwr_conf(entry, cursor, conf) {

drivers/net/wireless/realtek/rtw89/fw.c

11067

if (!fw_tx_shape_lmt_entry_valid(&entry, cursor, conf))

drivers/net/wireless/realtek/rtw89/fw.c

11076

const void *cursor,

drivers/net/wireless/realtek/rtw89/fw.c

11079

if (!__fw_txpwr_entry_acceptable(e, cursor, conf->ent_sz))

drivers/net/wireless/realtek/rtw89/fw.c

11095

const void *cursor;

drivers/net/wireless/realtek/rtw89/fw.c

11097

rtw89_for_each_in_txpwr_conf(entry, cursor, conf) {

drivers/net/wireless/realtek/rtw89/fw.c

11098

if (!fw_tx_shape_lmt_ru_entry_valid(&entry, cursor, conf))

drivers/net/wireless/realtek/rtw89/fw.c

1267

static bool rtw89_regd_entcpy(struct rtw89_regd *regd, const void *cursor,

drivers/net/wireless/realtek/rtw89/fw.c

1281

memcpy(&entry, cursor, valid_size);

drivers/net/wireless/realtek/rtw89/fw.c

1309

for (const void *cursor = (element)->content, \

drivers/net/wireless/realtek/rtw89/fw.c

1312

cursor < end; cursor += (element)->ent_sz) \

drivers/net/wireless/realtek/rtw89/fw.c

1313

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

109

struct lynx_cursor *cursor;

drivers/staging/sm750fb/sm750.c

113

cursor = &crtc->cursor;

drivers/staging/sm750fb/sm750.c

115

if (fbcursor->image.width > cursor->max_w ||

drivers/staging/sm750fb/sm750.c

116

fbcursor->image.height > cursor->max_h ||

drivers/staging/sm750fb/sm750.c

121

sm750_hw_cursor_disable(cursor);

drivers/staging/sm750fb/sm750.c

123

sm750_hw_cursor_set_size(cursor,

drivers/staging/sm750fb/sm750.c

128

sm750_hw_cursor_set_pos(cursor,

drivers/staging/sm750fb/sm750.c

144

sm750_hw_cursor_set_color(cursor, fg, bg);

drivers/staging/sm750fb/sm750.c

148

sm750_hw_cursor_set_data(cursor, fbcursor->rop, fbcursor->image.data,

drivers/staging/sm750fb/sm750.c

153

sm750_hw_cursor_enable(cursor);

drivers/staging/sm750fb/sm750.c

438

struct lynx_cursor *cursor;

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

463

cursor = &crtc->cursor;

drivers/staging/sm750fb/sm750.c

464

memset_io(cursor->vstart, 0x0, cursor->size);

drivers/staging/sm750fb/sm750.c

766

crtc->cursor.offset = crtc->o_screen + crtc->vidmem_size - 1024;

drivers/staging/sm750fb/sm750.c

767

crtc->cursor.mmio = sm750_dev->pvReg +

drivers/staging/sm750fb/sm750.c

770

pr_info("crtc->cursor.mmio = %p\n", crtc->cursor.mmio);

drivers/staging/sm750fb/sm750.c

771

crtc->cursor.max_h = 64;

drivers/staging/sm750fb/sm750.c

772

crtc->cursor.max_w = 64;

drivers/staging/sm750fb/sm750.c

773

crtc->cursor.size = crtc->cursor.max_h * crtc->cursor.max_w * 2 / 8;

drivers/staging/sm750fb/sm750.c

774

crtc->cursor.vstart = sm750_dev->pvMem + crtc->cursor.offset;

drivers/staging/sm750fb/sm750.c

776

memset_io(crtc->cursor.vstart, 0, crtc->cursor.size);

drivers/staging/sm750fb/sm750.c

778

sm750_hw_cursor_disable(&crtc->cursor);

drivers/staging/sm750fb/sm750.h

151

struct lynx_cursor cursor;

drivers/staging/sm750fb/sm750_cursor.c

102

pstart = cursor->vstart;

drivers/staging/sm750fb/sm750_cursor.c

134

void sm750_hw_cursor_set_data2(struct lynx_cursor *cursor, u16 rop,

drivers/staging/sm750fb/sm750_cursor.c

143

pitch = cursor->w >> 3;

drivers/staging/sm750fb/sm750_cursor.c

146

count = pitch * cursor->h;

drivers/staging/sm750fb/sm750_cursor.c

149

offset = cursor->max_w * 2 / 8;

drivers/staging/sm750fb/sm750_cursor.c

152

pstart = cursor->vstart;

drivers/staging/sm750fb/sm750_cursor.c

22

writel((data), cursor->mmio + (addr))

drivers/staging/sm750fb/sm750_cursor.c

47

void sm750_hw_cursor_enable(struct lynx_cursor *cursor)

drivers/staging/sm750fb/sm750_cursor.c

51

reg = (cursor->offset & HWC_ADDRESS_ADDRESS_MASK) | HWC_ADDRESS_ENABLE;

drivers/staging/sm750fb/sm750_cursor.c

55

void sm750_hw_cursor_disable(struct lynx_cursor *cursor)

drivers/staging/sm750fb/sm750_cursor.c

60

void sm750_hw_cursor_set_size(struct lynx_cursor *cursor, int w, int h)

drivers/staging/sm750fb/sm750_cursor.c

62

cursor->w = w;

drivers/staging/sm750fb/sm750_cursor.c

63

cursor->h = h;

drivers/staging/sm750fb/sm750_cursor.c

66

void sm750_hw_cursor_set_pos(struct lynx_cursor *cursor, int x, int y)

drivers/staging/sm750fb/sm750_cursor.c

75

void sm750_hw_cursor_set_color(struct lynx_cursor *cursor, u32 fg, u32 bg)

drivers/staging/sm750fb/sm750_cursor.c

84

void sm750_hw_cursor_set_data(struct lynx_cursor *cursor, u16 rop,

drivers/staging/sm750fb/sm750_cursor.c

93

pitch = cursor->w >> 3;

drivers/staging/sm750fb/sm750_cursor.c

96

count = pitch * cursor->h;

drivers/staging/sm750fb/sm750_cursor.c

99

offset = cursor->max_w * 2 / 8;

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

13

void sm750_hw_cursor_set_data2(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

263

struct fb_cursor cursor;

drivers/video/fbdev/core/bitblit.c

272

cursor.set = 0;

drivers/video/fbdev/core/bitblit.c

284

cursor.set |= FB_CUR_SETIMAGE;

drivers/video/fbdev/core/bitblit.c

304

cursor.set |= FB_CUR_SETCMAP;

drivers/video/fbdev/core/bitblit.c

312

cursor.set |= FB_CUR_SETPOS;

drivers/video/fbdev/core/bitblit.c

320

cursor.set |= FB_CUR_SETSIZE;

drivers/video/fbdev/core/bitblit.c

325

par->cursor_state.hot.x = cursor.hot.y = 0;

drivers/video/fbdev/core/bitblit.c

326

cursor.set |= FB_CUR_SETHOT;

drivers/video/fbdev/core/bitblit.c

329

if (cursor.set & FB_CUR_SETSIZE ||

drivers/video/fbdev/core/bitblit.c

344

cursor.set |= FB_CUR_SETSHAPE;

drivers/video/fbdev/core/bitblit.c

377

cursor.image.data = src;

drivers/video/fbdev/core/bitblit.c

378

cursor.image.fg_color = par->cursor_state.image.fg_color;

drivers/video/fbdev/core/bitblit.c

379

cursor.image.bg_color = par->cursor_state.image.bg_color;

drivers/video/fbdev/core/bitblit.c

380

cursor.image.dx = par->cursor_state.image.dx;

drivers/video/fbdev/core/bitblit.c

381

cursor.image.dy = par->cursor_state.image.dy;

drivers/video/fbdev/core/bitblit.c

382

cursor.image.height = par->cursor_state.image.height;

drivers/video/fbdev/core/bitblit.c

383

cursor.image.width = par->cursor_state.image.width;

drivers/video/fbdev/core/bitblit.c

384

cursor.hot.x = par->cursor_state.hot.x;

drivers/video/fbdev/core/bitblit.c

385

cursor.hot.y = par->cursor_state.hot.y;

drivers/video/fbdev/core/bitblit.c

386

cursor.mask = par->cursor_state.mask;

drivers/video/fbdev/core/bitblit.c

387

cursor.enable = par->cursor_state.enable;

drivers/video/fbdev/core/bitblit.c

388

cursor.image.depth = 1;

drivers/video/fbdev/core/bitblit.c

389

cursor.rop = ROP_XOR;

drivers/video/fbdev/core/bitblit.c

392

err = info->fbops->fb_cursor(info, &cursor);

drivers/video/fbdev/core/bitblit.c

395

soft_cursor(info, &cursor);

drivers/video/fbdev/core/bitblit.c

417

.cursor = bit_cursor,

drivers/video/fbdev/core/fbcon.c

1376

if (!par->bitops->cursor)

drivers/video/fbdev/core/fbcon.c

1379

par->bitops->cursor(vc, info, enable,

drivers/video/fbdev/core/fbcon.c

424

par->bitops->cursor(vc, info, enable,

drivers/video/fbdev/core/fbcon.h

193

extern int soft_cursor(struct fb_info *info, struct fb_cursor *cursor);

drivers/video/fbdev/core/fbcon.h

63

void (*cursor)(struct vc_data *vc, struct fb_info *info,

drivers/video/fbdev/core/fbcon_ccw.c

223

struct fb_cursor cursor;

drivers/video/fbdev/core/fbcon_ccw.c

236

cursor.set = 0;

drivers/video/fbdev/core/fbcon_ccw.c

245

cursor.set |= FB_CUR_SETIMAGE;

drivers/video/fbdev/core/fbcon_ccw.c

265

cursor.set |= FB_CUR_SETCMAP;

drivers/video/fbdev/core/fbcon_ccw.c

273

cursor.set |= FB_CUR_SETSIZE;

drivers/video/fbdev/core/fbcon_ccw.c

284

cursor.set |= FB_CUR_SETPOS;

drivers/video/fbdev/core/fbcon_ccw.c

289

par->cursor_state.hot.x = cursor.hot.y = 0;

drivers/video/fbdev/core/fbcon_ccw.c

290

cursor.set |= FB_CUR_SETHOT;

drivers/video/fbdev/core/fbcon_ccw.c

293

if (cursor.set & FB_CUR_SETSIZE ||

drivers/video/fbdev/core/fbcon_ccw.c

316

cursor.set |= FB_CUR_SETSHAPE;

drivers/video/fbdev/core/fbcon_ccw.c

353

cursor.image.data = src;

drivers/video/fbdev/core/fbcon_ccw.c

354

cursor.image.fg_color = par->cursor_state.image.fg_color;

drivers/video/fbdev/core/fbcon_ccw.c

355

cursor.image.bg_color = par->cursor_state.image.bg_color;

drivers/video/fbdev/core/fbcon_ccw.c

356

cursor.image.dx = par->cursor_state.image.dx;

drivers/video/fbdev/core/fbcon_ccw.c

357

cursor.image.dy = par->cursor_state.image.dy;

drivers/video/fbdev/core/fbcon_ccw.c

358

cursor.image.height = par->cursor_state.image.height;

drivers/video/fbdev/core/fbcon_ccw.c

359

cursor.image.width = par->cursor_state.image.width;

drivers/video/fbdev/core/fbcon_ccw.c

360

cursor.hot.x = par->cursor_state.hot.x;

drivers/video/fbdev/core/fbcon_ccw.c

361

cursor.hot.y = par->cursor_state.hot.y;

drivers/video/fbdev/core/fbcon_ccw.c

362

cursor.mask = par->cursor_state.mask;

drivers/video/fbdev/core/fbcon_ccw.c

363

cursor.enable = par->cursor_state.enable;

drivers/video/fbdev/core/fbcon_ccw.c

364

cursor.image.depth = 1;

drivers/video/fbdev/core/fbcon_ccw.c

365

cursor.rop = ROP_XOR;

drivers/video/fbdev/core/fbcon_ccw.c

368

err = info->fbops->fb_cursor(info, &cursor);

drivers/video/fbdev/core/fbcon_ccw.c

371

soft_cursor(info, &cursor);

drivers/video/fbdev/core/fbcon_ccw.c

398

.cursor = ccw_cursor,

drivers/video/fbdev/core/fbcon_cw.c

206

struct fb_cursor cursor;

drivers/video/fbdev/core/fbcon_cw.c

219

cursor.set = 0;

drivers/video/fbdev/core/fbcon_cw.c

228

cursor.set |= FB_CUR_SETIMAGE;

drivers/video/fbdev/core/fbcon_cw.c

248

cursor.set |= FB_CUR_SETCMAP;

drivers/video/fbdev/core/fbcon_cw.c

256

cursor.set |= FB_CUR_SETSIZE;

drivers/video/fbdev/core/fbcon_cw.c

267

cursor.set |= FB_CUR_SETPOS;

drivers/video/fbdev/core/fbcon_cw.c

272

par->cursor_state.hot.x = cursor.hot.y = 0;

drivers/video/fbdev/core/fbcon_cw.c

273

cursor.set |= FB_CUR_SETHOT;

drivers/video/fbdev/core/fbcon_cw.c

276

if (cursor.set & FB_CUR_SETSIZE ||

drivers/video/fbdev/core/fbcon_cw.c

299

cursor.set |= FB_CUR_SETSHAPE;

drivers/video/fbdev/core/fbcon_cw.c

336

cursor.image.data = src;

drivers/video/fbdev/core/fbcon_cw.c

337

cursor.image.fg_color = par->cursor_state.image.fg_color;

drivers/video/fbdev/core/fbcon_cw.c

338

cursor.image.bg_color = par->cursor_state.image.bg_color;

drivers/video/fbdev/core/fbcon_cw.c

339

cursor.image.dx = par->cursor_state.image.dx;

drivers/video/fbdev/core/fbcon_cw.c

340

cursor.image.dy = par->cursor_state.image.dy;

drivers/video/fbdev/core/fbcon_cw.c

341

cursor.image.height = par->cursor_state.image.height;

drivers/video/fbdev/core/fbcon_cw.c

342

cursor.image.width = par->cursor_state.image.width;

drivers/video/fbdev/core/fbcon_cw.c

343

cursor.hot.x = par->cursor_state.hot.x;

drivers/video/fbdev/core/fbcon_cw.c

344

cursor.hot.y = par->cursor_state.hot.y;

drivers/video/fbdev/core/fbcon_cw.c

345

cursor.mask = par->cursor_state.mask;

drivers/video/fbdev/core/fbcon_cw.c

346

cursor.enable = par->cursor_state.enable;

drivers/video/fbdev/core/fbcon_cw.c

347

cursor.image.depth = 1;

drivers/video/fbdev/core/fbcon_cw.c

348

cursor.rop = ROP_XOR;

drivers/video/fbdev/core/fbcon_cw.c

351

err = info->fbops->fb_cursor(info, &cursor);

drivers/video/fbdev/core/fbcon_cw.c

354

soft_cursor(info, &cursor);

drivers/video/fbdev/core/fbcon_cw.c

381

.cursor = cw_cursor,

drivers/video/fbdev/core/fbcon_ud.c

253

struct fb_cursor cursor;

drivers/video/fbdev/core/fbcon_ud.c

267

cursor.set = 0;

drivers/video/fbdev/core/fbcon_ud.c

276

cursor.set |= FB_CUR_SETIMAGE;

drivers/video/fbdev/core/fbcon_ud.c

296

cursor.set |= FB_CUR_SETCMAP;

drivers/video/fbdev/core/fbcon_ud.c

304

cursor.set |= FB_CUR_SETSIZE;

drivers/video/fbdev/core/fbcon_ud.c

315

cursor.set |= FB_CUR_SETPOS;

drivers/video/fbdev/core/fbcon_ud.c

320

par->cursor_state.hot.x = cursor.hot.y = 0;

drivers/video/fbdev/core/fbcon_ud.c

321

cursor.set |= FB_CUR_SETHOT;

drivers/video/fbdev/core/fbcon_ud.c

324

if (cursor.set & FB_CUR_SETSIZE ||

drivers/video/fbdev/core/fbcon_ud.c

339

cursor.set |= FB_CUR_SETSHAPE;

drivers/video/fbdev/core/fbcon_ud.c

376

cursor.image.data = src;

drivers/video/fbdev/core/fbcon_ud.c

377

cursor.image.fg_color = par->cursor_state.image.fg_color;

drivers/video/fbdev/core/fbcon_ud.c

378

cursor.image.bg_color = par->cursor_state.image.bg_color;

drivers/video/fbdev/core/fbcon_ud.c

379

cursor.image.dx = par->cursor_state.image.dx;

drivers/video/fbdev/core/fbcon_ud.c

380

cursor.image.dy = par->cursor_state.image.dy;

drivers/video/fbdev/core/fbcon_ud.c

381

cursor.image.height = par->cursor_state.image.height;

drivers/video/fbdev/core/fbcon_ud.c

382

cursor.image.width = par->cursor_state.image.width;

drivers/video/fbdev/core/fbcon_ud.c

383

cursor.hot.x = par->cursor_state.hot.x;

drivers/video/fbdev/core/fbcon_ud.c

384

cursor.hot.y = par->cursor_state.hot.y;

drivers/video/fbdev/core/fbcon_ud.c

385

cursor.mask = par->cursor_state.mask;

drivers/video/fbdev/core/fbcon_ud.c

386

cursor.enable = par->cursor_state.enable;

drivers/video/fbdev/core/fbcon_ud.c

387

cursor.image.depth = 1;

drivers/video/fbdev/core/fbcon_ud.c

388

cursor.rop = ROP_XOR;

drivers/video/fbdev/core/fbcon_ud.c

391

err = info->fbops->fb_cursor(info, &cursor);

drivers/video/fbdev/core/fbcon_ud.c

394

soft_cursor(info, &cursor);

drivers/video/fbdev/core/fbcon_ud.c

425

.cursor = ud_cursor,

drivers/video/fbdev/core/fbsysfs.c

420

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

526

static int nvidiafb_cursor(struct fb_info *info, struct fb_cursor *cursor)

drivers/video/fbdev/nvidia/nvidia.c

530

int i, set = cursor->set;

drivers/video/fbdev/nvidia/nvidia.c

533

if (cursor->image.width > MAX_CURS || cursor->image.height > MAX_CURS)

drivers/video/fbdev/nvidia/nvidia.c

549

yy = cursor->image.dy - info->var.yoffset;

drivers/video/fbdev/nvidia/nvidia.c

550

xx = cursor->image.dx - info->var.xoffset;

drivers/video/fbdev/nvidia/nvidia.c

558

u32 bg_idx = cursor->image.bg_color;

drivers/video/fbdev/nvidia/nvidia.c

559

u32 fg_idx = cursor->image.fg_color;

drivers/video/fbdev/nvidia/nvidia.c

560

u32 s_pitch = (cursor->image.width + 7) >> 3;

drivers/video/fbdev/nvidia/nvidia.c

562

u8 *dat = (u8 *) cursor->image.data;

drivers/video/fbdev/nvidia/nvidia.c

563

u8 *msk = (u8 *) cursor->mask;

drivers/video/fbdev/nvidia/nvidia.c

566

src = kmalloc_array(s_pitch, cursor->image.height, GFP_ATOMIC);

drivers/video/fbdev/nvidia/nvidia.c

569

switch (cursor->rop) {

drivers/video/fbdev/nvidia/nvidia.c

571

for (i = 0; i < s_pitch * cursor->image.height; i++)

drivers/video/fbdev/nvidia/nvidia.c

576

for (i = 0; i < s_pitch * cursor->image.height; i++)

drivers/video/fbdev/nvidia/nvidia.c

582

cursor->image.height);

drivers/video/fbdev/nvidia/nvidia.c

595

cursor->image.width,

drivers/video/fbdev/nvidia/nvidia.c

596

cursor->image.height);

drivers/video/fbdev/nvidia/nvidia.c

601

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

1570

static int rivafb_cursor(struct fb_info *info, struct fb_cursor *cursor)

drivers/video/fbdev/riva/fbdev.c

1574

int i, set = cursor->set;

drivers/video/fbdev/riva/fbdev.c

1577

if (cursor->image.width > MAX_CURS || cursor->image.height > MAX_CURS)

drivers/video/fbdev/riva/fbdev.c

1593

yy = cursor->image.dy - info->var.yoffset;

drivers/video/fbdev/riva/fbdev.c

1594

xx = cursor->image.dx - info->var.xoffset;

drivers/video/fbdev/riva/fbdev.c

1603

u32 bg_idx = cursor->image.bg_color;

drivers/video/fbdev/riva/fbdev.c

1604

u32 fg_idx = cursor->image.fg_color;

drivers/video/fbdev/riva/fbdev.c

1605

u32 s_pitch = (cursor->image.width+7) >> 3;

drivers/video/fbdev/riva/fbdev.c

1607

u8 *dat = (u8 *) cursor->image.data;

drivers/video/fbdev/riva/fbdev.c

1608

u8 *msk = (u8 *) cursor->mask;

drivers/video/fbdev/riva/fbdev.c

1611

src = kmalloc_array(s_pitch, cursor->image.height, GFP_ATOMIC);

drivers/video/fbdev/riva/fbdev.c

1614

switch (cursor->rop) {

drivers/video/fbdev/riva/fbdev.c

1616

for (i = 0; i < s_pitch * cursor->image.height; i++)

drivers/video/fbdev/riva/fbdev.c

1621

for (i = 0; i < s_pitch * cursor->image.height; i++)

drivers/video/fbdev/riva/fbdev.c

1627

cursor->image.height);

drivers/video/fbdev/riva/fbdev.c

1642

cursor->image.width,

drivers/video/fbdev/riva/fbdev.c

1643

cursor->image.height);

drivers/video/fbdev/riva/fbdev.c

1648

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

1046

static int sm501fb_cursor(struct fb_info *info, struct fb_cursor *cursor)

drivers/video/fbdev/sm501fb.c

1054

dev_dbg(fbi->dev, "%s(%p,%p)\n", __func__, info, cursor);

drivers/video/fbdev/sm501fb.c

106

struct sm501_mem cursor;

drivers/video/fbdev/sm501fb.c

1063

if (cursor->image.width > 64)

drivers/video/fbdev/sm501fb.c

1066

if (cursor->image.height > 64)

drivers/video/fbdev/sm501fb.c

1069

if (cursor->image.depth > 1)

drivers/video/fbdev/sm501fb.c

1074

if (cursor->enable)

drivers/video/fbdev/sm501fb.c

1082

if (cursor->set & FB_CUR_SETPOS) {

drivers/video/fbdev/sm501fb.c

1083

unsigned int x = cursor->image.dx;

drivers/video/fbdev/sm501fb.c

1084

unsigned int y = cursor->image.dy;

drivers/video/fbdev/sm501fb.c

1096

if (cursor->set & FB_CUR_SETCMAP) {

drivers/video/fbdev/sm501fb.c

1097

unsigned int bg_col = cursor->image.bg_color;

drivers/video/fbdev/sm501fb.c

1098

unsigned int fg_col = cursor->image.fg_color;

drivers/video/fbdev/sm501fb.c

1117

if (cursor->set & FB_CUR_SETSIZE ||

drivers/video/fbdev/sm501fb.c

1118

cursor->set & (FB_CUR_SETIMAGE | FB_CUR_SETSHAPE)) {

drivers/video/fbdev/sm501fb.c

1124

const unsigned char *pcol = cursor->image.data;

drivers/video/fbdev/sm501fb.c

1125

const unsigned char *pmsk = cursor->mask;

drivers/video/fbdev/sm501fb.c

1126

void __iomem *dst = par->cursor.k_addr;

drivers/video/fbdev/sm501fb.c

1132

__func__, cursor->image.width, cursor->image.height);

drivers/video/fbdev/sm501fb.c

1137

for (y = 0; y < cursor->image.height; y++) {

drivers/video/fbdev/sm501fb.c

1138

for (x = 0; x < cursor->image.width; x++) {

drivers/video/fbdev/sm501fb.c

1512

ret = sm501_alloc_mem(info, &par->cursor, SM501_MEMF_CURSOR, 1024,

drivers/video/fbdev/sm501fb.c

1519

smc501_writel(par->cursor.sm_addr,

drivers/video/fbdev/sm501fb.c

2113

par->store_cursor = vmalloc(par->cursor.size);

drivers/video/fbdev/sm501fb.c

2123

memcpy_fromio(par->store_cursor, par->cursor.k_addr, par->cursor.size);

drivers/video/fbdev/sm501fb.c

2161

memcpy_toio(par->cursor.k_addr, par->store_cursor,

drivers/video/fbdev/sm501fb.c

2162

par->cursor.size);

drivers/video/fbdev/tcx.c

98

u32 cursor;

drivers/video/fbdev/tdfxfb.c

1040

static int tdfxfb_cursor(struct fb_info *info, struct fb_cursor *cursor)

drivers/video/fbdev/tdfxfb.c

1049

if (cursor->image.width > 64 ||

drivers/video/fbdev/tdfxfb.c

1050

cursor->image.height > 64 ||

drivers/video/fbdev/tdfxfb.c

1051

cursor->image.depth > 1)

drivers/video/fbdev/tdfxfb.c

1055

if (cursor->enable)

drivers/video/fbdev/tdfxfb.c

1065

if (!cursor->set)

drivers/video/fbdev/tdfxfb.c

1069

if (cursor->set & FB_CUR_SETCMAP) {

drivers/video/fbdev/tdfxfb.c

1071

u32 bg_idx = cursor->image.bg_color;

drivers/video/fbdev/tdfxfb.c

1072

u32 fg_idx = cursor->image.fg_color;

drivers/video/fbdev/tdfxfb.c

1086

if (cursor->set & FB_CUR_SETPOS) {

drivers/video/fbdev/tdfxfb.c

1087

int x = cursor->image.dx;

drivers/video/fbdev/tdfxfb.c

1088

int y = cursor->image.dy - info->var.yoffset;

drivers/video/fbdev/tdfxfb.c

1095

if (cursor->set & (FB_CUR_SETIMAGE | FB_CUR_SETSHAPE)) {

drivers/video/fbdev/tdfxfb.c

1115

u8 *bitmap = (u8 *)cursor->image.data;

drivers/video/fbdev/tdfxfb.c

1116

u8 *mask = (u8 *)cursor->mask;

drivers/video/fbdev/tdfxfb.c

1121

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

drivers/video/fbdev/tdfxfb.c

1123

int j = (cursor->image.width + 7) >> 3;

drivers/video/fbdev/tdfxfb.c

1127

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

252

struct afs_cell *cell, *candidate, *cursor;

fs/afs/cell.c

293

cursor = rb_entry(parent, struct afs_cell, net_node);

fs/afs/cell.c

295

n = strncasecmp(cursor->name, name,

fs/afs/cell.c

296

min_t(size_t, cursor->name_len, namesz));

fs/afs/cell.c

298

n = cursor->name_len - namesz;

fs/afs/cell.c

383

cell = cursor;

fs/afs/cell.c

387

afs_use_cell(cursor, trace);

fs/afs/cell.c

896

struct rb_node *cursor;

fs/afs/cell.c

908

for (cursor = rb_first(&net->cells); cursor; cursor = rb_next(cursor)) {

fs/afs/cell.c

909

struct afs_cell *cell = rb_entry(cursor, struct afs_cell, net_node);

fs/configfs/dir.c

1620

struct configfs_dirent * cursor = file->private_data;

fs/configfs/dir.c

1624

list_del_init(&cursor->s_sibling);

fs/configfs/dir.c

1628

release_configfs_dirent(cursor);

fs/configfs/dir.c

1638

struct configfs_dirent *cursor = file->private_data;

fs/configfs/dir.c

1639

struct list_head *p, *q = &cursor->s_sibling;

fs/configfs/dir.c

1714

struct configfs_dirent *cursor = file->private_data;

fs/configfs/dir.c

1719

list_del(&cursor->s_sibling);

fs/configfs/dir.c

1729

list_add_tail(&cursor->s_sibling, p);

fs/libfs.c

109

static struct dentry *scan_positives(struct dentry *cursor,

fs/libfs.c

114

struct dentry *dentry = cursor->d_parent, *found = NULL;

fs/libfs.c

133

if (!hlist_unhashed(&cursor->d_sib))

fs/libfs.c

134

__hlist_del(&cursor->d_sib);

fs/libfs.c

135

hlist_add_behind(&cursor->d_sib, &d->d_sib);

fs/libfs.c

136

p = &cursor->d_sib.next;

fs/libfs.c

162

struct dentry *cursor = file->private_data;

fs/libfs.c

168

to = scan_positives(cursor, &dentry->d_children.first,

fs/libfs.c

171

hlist_del_init(&cursor->d_sib);

fs/libfs.c

173

hlist_add_behind(&cursor->d_sib, &to->d_sib);

fs/libfs.c

194

struct dentry *cursor = file->private_data;

fs/libfs.c

204

p = &cursor->d_sib.next;

fs/libfs.c

206

while ((next = scan_positives(cursor, p, 1, next)) != NULL) {

fs/libfs.c

215

hlist_del_init(&cursor->d_sib);

fs/libfs.c

217

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

855

while (od->cursor != &od->cache->entries) {

fs/overlayfs/readdir.c

856

p = list_entry(od->cursor, struct ovl_cache_entry, l_node);

fs/overlayfs/readdir.c

869

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

21

int cursor, ret;

fs/vboxsf/utils.c

30

cursor = idr_get_cursor(&sbi->ino_idr);

fs/vboxsf/utils.c

32

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 (p->ip->i_ino != child_ino || p->dp->i_ino != *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 = 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 = cursor->quota_ip->i_ino;

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

636

__entry->hashval = ctx->cursor.hashval;

fs/xfs/xfs_trace.h

637

__entry->blkno = ctx->cursor.blkno;

fs/xfs/xfs_trace.h

638

__entry->offset = ctx->cursor.offset;

include/drm/drm_crtc.h

1228

struct drm_plane *cursor,

include/drm/drm_crtc.h

1236

struct drm_plane *cursor,

include/drm/drm_crtc.h

1246

struct drm_plane *cursor,

include/drm/drm_crtc.h

1269

#define drmm_crtc_alloc_with_planes(dev, type, member, primary, cursor, funcs, name, ...) \

include/drm/drm_crtc.h

1272

primary, cursor, funcs, \

include/drm/drm_crtc.h

991

struct drm_plane *cursor;

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

486

ttm_resource_manager_first(struct ttm_resource_cursor *cursor);

include/drm/ttm/ttm_resource.h

488

ttm_resource_manager_next(struct ttm_resource_cursor *cursor);

include/drm/ttm/ttm_resource.h

500

#define ttm_resource_manager_for_each_res(cursor, res) \

include/drm/ttm/ttm_resource.h

501

for (res = ttm_resource_manager_first(cursor); res; \

include/drm/ttm/ttm_resource.h

502

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

286

int (*fb_cursor) (struct fb_info *info, struct fb_cursor *cursor);

include/linux/fb.h

381

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

688

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/sched/ext.c

121

u32 cursor;

kernel/sched/ext.c

141

s32 cursor;

kernel/sched/ext.c

2150

for (u = 0; u < dspc->cursor; u++) {

kernel/sched/ext.c

2157

dspc->nr_tasks += dspc->cursor;

kernel/sched/ext.c

2158

dspc->cursor = 0;

kernel/sched/ext.c

3974

struct scx_dsq_list_node cursor = INIT_DSQ_LIST_CURSOR(cursor, 0, 0);

kernel/sched/ext.c

3990

list_add(&cursor.node, &donor_dsq->list);

kernel/sched/ext.c

3992

n = container_of(&cursor, struct task_struct, scx.dsq_list);

kernel/sched/ext.c

4047

list_move_tail(&cursor.node, &n->scx.dsq_list.node);

kernel/sched/ext.c

4057

list_del_init(&cursor.node);

kernel/sched/ext.c

4600

dd->cursor = 0;

kernel/sched/ext.c

4610

if (!dd->cursor)

kernel/sched/ext.c

4650

dd->cursor = 0;

kernel/sched/ext.c

496

struct scx_dsq_list_node cursor;

kernel/sched/ext.c

511

struct sched_ext_entity cursor;

kernel/sched/ext.c

541

iter->cursor = (struct sched_ext_entity){ .flags = SCX_TASK_CURSOR };

kernel/sched/ext.c

542

list_add(&iter->cursor.tasks_node, &scx_tasks);

kernel/sched/ext.c

5912

if (unlikely(dspc->cursor >= scx_dsp_max_batch)) {

kernel/sched/ext.c

5917

dspc->buf[dspc->cursor++] = (struct scx_dsp_buf_ent){

kernel/sched/ext.c

592

list_del_init(&iter->cursor.tasks_node);

kernel/sched/ext.c

606

struct list_head *cursor = &iter->cursor.tasks_node;

kernel/sched/ext.c

6150

u32_before(kit->cursor.priv, p->scx.dsq_seq) ||

kernel/sched/ext.c

616

list_for_each_entry(pos, cursor, tasks_node) {

kernel/sched/ext.c

6165

if (kit->cursor.flags & __SCX_DSQ_ITER_HAS_VTIME)

kernel/sched/ext.c

6167

if (kit->cursor.flags & __SCX_DSQ_ITER_HAS_SLICE)

kernel/sched/ext.c

6183

kit->cursor.flags &= ~(__SCX_DSQ_ITER_HAS_SLICE |

kernel/sched/ext.c

620

list_move(cursor, &pos->tasks_node);

kernel/sched/ext.c

6208

return scx_dsp_max_batch - __this_cpu_read(scx_dsp_ctx->cursor);

kernel/sched/ext.c

6231

if (dspc->cursor > 0)

kernel/sched/ext.c

6232

dspc->cursor--;

kernel/sched/ext.c

6303

kit->cursor.flags |= __SCX_DSQ_ITER_HAS_SLICE;

kernel/sched/ext.c

6322

kit->cursor.flags |= __SCX_DSQ_ITER_HAS_VTIME;

kernel/sched/ext.c

6750

kit->cursor = INIT_DSQ_LIST_CURSOR(kit->cursor, flags,

kernel/sched/ext.c

6765

bool rev = kit->cursor.flags & SCX_DSQ_ITER_REV;

kernel/sched/ext.c

6774

if (list_empty(&kit->cursor.node))

kernel/sched/ext.c

6777

p = container_of(&kit->cursor, struct task_struct, scx.dsq_list);

kernel/sched/ext.c

6786

} while (p && unlikely(u32_before(kit->cursor.priv, p->scx.dsq_seq)));

kernel/sched/ext.c

6790

list_move_tail(&kit->cursor.node, &p->scx.dsq_list.node);

kernel/sched/ext.c

6792

list_move(&kit->cursor.node, &p->scx.dsq_list.node);

kernel/sched/ext.c

6794

list_del_init(&kit->cursor.node);

kernel/sched/ext.c

6815

if (!list_empty(&kit->cursor.node)) {

kernel/sched/ext.c

6819

list_del_init(&kit->cursor.node);

kernel/sched/ext.c

6986

ret = __bstr_format(sch, buf->data, buf->line + dd->cursor,

kernel/sched/ext.c

6987

sizeof(buf->line) - dd->cursor, fmt, data, data__sz);

kernel/sched/ext.c

6994

dd->cursor += ret;

kernel/sched/ext.c

6995

dd->cursor = min_t(s32, dd->cursor, sizeof(buf->line));

kernel/sched/ext.c

6997

if (!dd->cursor)

kernel/sched/ext.c

7008

if (dd->cursor >= sizeof(buf->line) || buf->line[dd->cursor - 1] == '\n')

kernel/sched/fair.c

6097

struct cfs_rq *cursor, *tmp;

kernel/sched/fair.c

6120

list_for_each_entry_safe(cursor, tmp, &rq->cfsb_csd_list,

kernel/sched/fair.c

6122

list_del_init(&cursor->throttled_csd_list);

kernel/sched/fair.c

6124

if (cfs_rq_throttled(cursor))

kernel/sched/fair.c

6125

unthrottle_cfs_rq(cursor);

kernel/workqueue.c

3462

struct work_struct *cursor = &pwq->mayday_cursor;

kernel/workqueue.c

3497

if (list_empty(&cursor->entry))

kernel/workqueue.c

3500

work = list_next_entry(cursor, entry);

kernel/workqueue.c

3507

list_move_tail(&cursor->entry, &n->entry);

lib/assoc_array.c

105

cursor = parent;

lib/assoc_array.c

1459

struct assoc_array_ptr *cursor, *ptr;

lib/assoc_array.c

1481

cursor = array->root;

lib/assoc_array.c

1487

if (assoc_array_ptr_is_shortcut(cursor)) {

lib/assoc_array.c

1488

shortcut = assoc_array_ptr_to_shortcut(cursor);

lib/assoc_array.c

1500

cursor = shortcut->next_node;

lib/assoc_array.c

1504

node = assoc_array_ptr_to_node(cursor);

lib/assoc_array.c

1533

cursor = ptr;

lib/assoc_array.c

1700

cursor = shortcut->back_pointer;

lib/assoc_array.c

1701

if (!cursor)

lib/assoc_array.c

1705

cursor = ptr;

lib/assoc_array.c

1707

BUG_ON(!cursor);

lib/assoc_array.c

1708

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

282

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

348

struct assoc_array_ptr *cursor, *parent = NULL;

lib/assoc_array.c

353

cursor = root;

lib/assoc_array.c

354

if (!cursor) {

lib/assoc_array.c

36

shortcut = assoc_array_ptr_to_shortcut(cursor);

lib/assoc_array.c

360

if (assoc_array_ptr_is_shortcut(cursor)) {

lib/assoc_array.c

363

BUG_ON(!assoc_array_ptr_is_shortcut(cursor));

lib/assoc_array.c

364

shortcut = assoc_array_ptr_to_shortcut(cursor);

lib/assoc_array.c

367

parent = cursor;

lib/assoc_array.c

368

cursor = shortcut->next_node;

lib/assoc_array.c

37

cursor = READ_ONCE(shortcut->next_node); /* Address dependency. */

lib/assoc_array.c

370

BUG_ON(!assoc_array_ptr_is_node(cursor));

lib/assoc_array.c

374

node = assoc_array_ptr_to_node(cursor);

lib/assoc_array.c

386

parent = cursor;

lib/assoc_array.c

387

cursor = ptr;

lib/assoc_array.c

40

node = assoc_array_ptr_to_node(cursor);

lib/assoc_array.c

408

BUG_ON(shortcut->next_node != cursor);

lib/assoc_array.c

409

cursor = parent;

lib/assoc_array.c

422

cursor = parent;

lib/assoc_array.c

423

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/memblock.c

1765

phys_addr_t cursor, end;

mm/memblock.c

1771

cursor = PFN_UP(base);

mm/memblock.c

1774

for (; cursor < end; cursor++) {

mm/memblock.c

1775

memblock_free_pages(cursor, 0);

mm/zsmalloc.c

785

struct zpdesc *cursor, *fail;

mm/zsmalloc.c

787

for (cursor = get_first_zpdesc(zspage); cursor != NULL; cursor =

mm/zsmalloc.c

788

get_next_zpdesc(cursor)) {

mm/zsmalloc.c

789

if (!zpdesc_trylock(cursor)) {

mm/zsmalloc.c

790

fail = cursor;

mm/zsmalloc.c

797

for (cursor = get_first_zpdesc(zspage); cursor != fail; cursor =

mm/zsmalloc.c

798

get_next_zpdesc(cursor))

mm/zsmalloc.c

799

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

1002

ceph_msg_data_cursor_init(&cursor, msg, dlen);

net/ceph/messenger_v2.c

1003

sg_cnt += calc_sg_cnt_cursor(&cursor);

net/ceph/messenger_v2.c

1022

ceph_msg_data_cursor_init(&cursor, msg, dlen);

net/ceph/messenger_v2.c

1023

init_sgs_cursor(&cur_sg, &cursor, data_pad);

net/ceph/messenger_v2.c

1063

struct ceph_msg_data_cursor cursor;

net/ceph/messenger_v2.c

1066

ceph_msg_data_cursor_init(&cursor, con->in_msg,

net/ceph/messenger_v2.c

1072

ret = con->ops->sparse_read(con, &cursor, &buf);

net/ceph/messenger_v2.c

1090

get_bvec_at(&cursor, &bv);

net/ceph/messenger_v2.c

1094

ceph_msg_data_advance(&cursor, len);

net/ceph/messenger_v2.c

1904

struct ceph_msg_data_cursor *cursor = &con->v2.in_cursor;

net/ceph/messenger_v2.c

1913

get_bvec_at(cursor, &bv);

net/ceph/messenger_v2.c

1924

ceph_msg_data_advance(cursor, con->v2.in_bvec.bv_len);

net/ceph/messenger_v2.c

1925

cursor->sr_resid -= con->v2.in_bvec.bv_len;

net/ceph/messenger_v2.c

1927

con->v2.in_bvec.bv_len, cursor->sr_resid);

net/ceph/messenger_v2.c

1928

WARN_ON_ONCE(cursor->sr_resid > cursor->total_resid);

net/ceph/messenger_v2.c

1929

if (cursor->sr_resid) {

net/ceph/messenger_v2.c

1930

get_bvec_at(cursor, &bv);

net/ceph/messenger_v2.c

1931

if (bv.bv_len > cursor->sr_resid)

net/ceph/messenger_v2.c

1932

bv.bv_len = cursor->sr_resid;

net/ceph/messenger_v2.c

1954

ret = con->ops->sparse_read(con, cursor, &buf);

net/ceph/messenger_v2.c

1973

if (ret > cursor->total_resid) {

net/ceph/messenger_v2.c

1975

__func__, ret, cursor->total_resid, cursor->resid);

net/ceph/messenger_v2.c

1978

get_bvec_at(cursor, &bv);

net/ceph/messenger_v2.c

1979

if (bv.bv_len > cursor->sr_resid)

net/ceph/messenger_v2.c

1980

bv.bv_len = cursor->sr_resid;

net/ceph/messenger_v2.c

832

static void get_bvec_at(struct ceph_msg_data_cursor *cursor,

net/ceph/messenger_v2.c

838

WARN_ON(!cursor->total_resid);

net/ceph/messenger_v2.c

841

while (!cursor->resid)

net/ceph/messenger_v2.c

842

ceph_msg_data_advance(cursor, 0);

net/ceph/messenger_v2.c

845

page = ceph_msg_data_next(cursor, &off, &len);

net/ceph/messenger_v2.c

867

static int calc_sg_cnt_cursor(struct ceph_msg_data_cursor *cursor)

net/ceph/messenger_v2.c

869

int data_len = cursor->total_resid;

net/ceph/messenger_v2.c

878

get_bvec_at(cursor, &bv);

net/ceph/messenger_v2.c

881

ceph_msg_data_advance(cursor, bv.bv_len);

net/ceph/messenger_v2.c

882

} while (cursor->total_resid);

net/ceph/messenger_v2.c

919

struct ceph_msg_data_cursor *cursor, u8 *pad)

net/ceph/messenger_v2.c

921

int data_len = cursor->total_resid;

net/ceph/messenger_v2.c

928

get_bvec_at(cursor, &bv);

net/ceph/messenger_v2.c

932

ceph_msg_data_advance(cursor, bv.bv_len);

net/ceph/messenger_v2.c

933

} while (cursor->total_resid);

net/ceph/messenger_v2.c

980

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

326

struct callchain_cursor *cursor;

tools/perf/builtin-c2c.c

340

cursor = get_tls_callchain_cursor();

tools/perf/builtin-c2c.c

341

ret = sample__resolve_callchain(sample, cursor, NULL,

tools/perf/builtin-inject.c

395

struct callchain_cursor *cursor = get_tls_callchain_cursor();

tools/perf/builtin-inject.c

412

if (cursor == NULL)

tools/perf/builtin-inject.c

415

callchain_cursor_reset(cursor);

tools/perf/builtin-inject.c

422

ret = thread__resolve_callchain(thread, cursor, evsel, sample,

tools/perf/builtin-inject.c

440

node = cursor->first;

tools/perf/builtin-inject.c

441

for (k = 0; k < cursor->nr && i < PERF_MAX_STACK_DEPTH; k++) {

tools/perf/builtin-kmem.c

402

struct callchain_cursor *cursor;

tools/perf/builtin-kmem.c

413

cursor = get_tls_callchain_cursor();

tools/perf/builtin-kmem.c

414

if (cursor == NULL)

tools/perf/builtin-kmem.c

417

sample__resolve_callchain(sample, cursor, NULL, evsel, &al, 16);

tools/perf/builtin-kmem.c

419

callchain_cursor_commit(cursor);

tools/perf/builtin-kmem.c

424

node = callchain_cursor_current(cursor);

tools/perf/builtin-kmem.c

443

callchain_cursor_advance(cursor);

tools/perf/builtin-kwork.c

697

struct callchain_cursor *cursor;

tools/perf/builtin-kwork.c

709

cursor = get_tls_callchain_cursor();

tools/perf/builtin-kwork.c

711

if (thread__resolve_callchain(thread, cursor, evsel, sample,

tools/perf/builtin-kwork.c

717

callchain_cursor_commit(cursor);

tools/perf/builtin-kwork.c

720

node = callchain_cursor_current(cursor);

tools/perf/builtin-kwork.c

731

callchain_cursor_advance(cursor);

tools/perf/builtin-kwork.c

796

struct callchain_cursor *cursor = get_tls_callchain_cursor();

tools/perf/builtin-kwork.c

798

if (cursor == NULL)

tools/perf/builtin-kwork.c

807

cursor, symbol_conf.bt_stop_list,

tools/perf/builtin-lock.c

848

struct callchain_cursor *cursor;

tools/perf/builtin-lock.c

862

cursor = get_tls_callchain_cursor();

tools/perf/builtin-lock.c

865

ret = thread__resolve_callchain(thread, cursor, evsel, sample,

tools/perf/builtin-lock.c

872

callchain_cursor_commit(cursor);

tools/perf/builtin-lock.c

878

node = callchain_cursor_current(cursor);

tools/perf/builtin-lock.c

894

callchain_cursor_advance(cursor);

tools/perf/builtin-lock.c

901

struct callchain_cursor *cursor;

tools/perf/builtin-lock.c

912

cursor = get_tls_callchain_cursor();

tools/perf/builtin-lock.c

914

ret = thread__resolve_callchain(thread, cursor, evsel, sample,

tools/perf/builtin-lock.c

921

callchain_cursor_commit(cursor);

tools/perf/builtin-lock.c

926

node = callchain_cursor_current(cursor);

tools/perf/builtin-lock.c

940

callchain_cursor_advance(cursor);

tools/perf/builtin-sched.c

2332

struct callchain_cursor *cursor;

tools/perf/builtin-sched.c

2347

cursor = get_tls_callchain_cursor();

tools/perf/builtin-sched.c

2349

if (thread__resolve_callchain(thread, cursor, evsel, sample,

tools/perf/builtin-sched.c

2358

callchain_cursor_commit(cursor);

tools/perf/builtin-sched.c

2365

node = callchain_cursor_current(cursor);

tools/perf/builtin-sched.c

2377

callchain_cursor_advance(cursor);

tools/perf/builtin-sched.c

2394

callchain_cursor_reset(&itr->cursor);

tools/perf/builtin-sched.c

2490

struct callchain_cursor *cursor;

tools/perf/builtin-sched.c

2495

cursor = get_tls_callchain_cursor();

tools/perf/builtin-sched.c

2496

if (cursor == NULL)

tools/perf/builtin-sched.c

2499

callchain_cursor__copy(&itr->cursor, cursor);

tools/perf/builtin-sched.c

2887

if (itr->cursor.nr)

tools/perf/builtin-sched.c

2888

callchain_append(&itr->callchain, &itr->cursor, t - tprev);

tools/perf/builtin-sched.c

290

struct callchain_cursor cursor;

tools/perf/builtin-script.c

1678

struct callchain_cursor *cursor = NULL;

tools/perf/builtin-script.c

1681

cursor = get_tls_callchain_cursor();

tools/perf/builtin-script.c

1682

if (thread__resolve_callchain(al->thread, cursor, evsel,

tools/perf/builtin-script.c

1685

cursor = NULL;

tools/perf/builtin-script.c

1687

if (cursor == NULL) {

tools/perf/builtin-script.c

1696

printed += sample__fprintf_sym(sample, al, 0, print_opts, cursor,

tools/perf/builtin-script.c

2498

struct callchain_cursor *cursor = NULL;

tools/perf/builtin-script.c

2504

cursor = get_tls_callchain_cursor();

tools/perf/builtin-script.c

2505

if (thread__resolve_callchain(al->thread, cursor, evsel,

tools/perf/builtin-script.c

2508

cursor = NULL;

tools/perf/builtin-script.c

2510

fputc(cursor ? '\n' : ' ', fp);

tools/perf/builtin-script.c

2511

sample__fprintf_sym(sample, al, 0, output[type].print_ip_opts, cursor,

tools/perf/builtin-script.c

2785

struct callchain_cursor *cursor = NULL;

tools/perf/builtin-script.c

2788

cursor = get_tls_callchain_cursor();

tools/perf/builtin-script.c

2789

if (thread__resolve_callchain(al.thread, cursor, evsel,

tools/perf/builtin-script.c

2793

cursor = NULL;

tools/perf/builtin-script.c

2797

fputc(cursor ? '\n' : ' ', fp);

tools/perf/builtin-script.c

2799

cursor, symbol_conf.bt_stop_list, fp);

tools/perf/builtin-timechart.c

1004

cursor = NULL;

tools/perf/builtin-timechart.c

1009

prev = cursor;

tools/perf/builtin-timechart.c

1010

cursor = cursor->next;

tools/perf/builtin-timechart.c

1011

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-timechart.c

975

struct per_pid *new_list, *p, *cursor, *prev;

tools/perf/builtin-timechart.c

991

cursor = new_list;

tools/perf/builtin-timechart.c

992

while (cursor) {

tools/perf/builtin-timechart.c

993

if (cursor->ppid > p->ppid ||

tools/perf/builtin-timechart.c

994

(cursor->ppid == p->ppid && cursor->pid > p->pid)) {

tools/perf/builtin-timechart.c

999

cursor = NULL;

tools/perf/builtin-trace.c

2895

struct callchain_cursor *cursor)

tools/perf/builtin-trace.c

2907

err = thread__resolve_callchain(al.thread, cursor, evsel, sample, NULL, NULL, max_stack);

tools/perf/builtin-trace.c

2967

struct callchain_cursor *cursor = get_tls_callchain_cursor();

tools/perf/builtin-trace.c

2969

callchain_ret = trace__resolve_callchain(trace, evsel, sample, cursor);

tools/perf/builtin-trace.c

2971

if (cursor->nr < trace->min_stack)

tools/perf/builtin-trace.c

3267

struct callchain_cursor *cursor = get_tls_callchain_cursor();

tools/perf/builtin-trace.c

3269

callchain_ret = trace__resolve_callchain(trace, evsel, sample, cursor);

tools/perf/builtin-trace.c

3271

if (cursor->nr < trace->min_stack)

tools/perf/builtin-trace.c

3378

struct callchain_cursor *cursor = get_tls_callchain_cursor();

tools/perf/builtin-trace.c

3380

callchain_ret = trace__resolve_callchain(trace, evsel, sample, cursor);

tools/perf/builtin-trace.c

3382

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

528

struct disasm_line *cursor = disasm_line(ab->selection);

tools/perf/ui/browsers/annotate.c

529

struct annotation_line *al = &cursor->al;

tools/perf/util/callchain.c

1006

if (append_chain_children(root, cursor, period) < 0)

tools/perf/util/callchain.c

1013

struct callchain_cursor *cursor,

tools/perf/util/callchain.c

1016

if (cursor == NULL)

tools/perf/util/callchain.c

1019

if (!cursor->nr)

tools/perf/util/callchain.c

1022

callchain_cursor_commit(cursor);

tools/perf/util/callchain.c

1024

if (append_chain_children(&root->node, cursor, period) < 0)

tools/perf/util/callchain.c

1027

if (cursor->nr > root->max_depth)

tools/perf/util/callchain.c

1028

root->max_depth = cursor->nr;

tools/perf/util/callchain.c

1034

merge_chain_branch(struct callchain_cursor *cursor,

tools/perf/util/callchain.c

1037

struct callchain_cursor_node **old_last = cursor->last;

tools/perf/util/callchain.c

1041

int old_pos = cursor->nr;

tools/perf/util/callchain.c

1049

callchain_cursor_append(cursor, list->ip, &ms, false, NULL, 0, 0, 0, list->srcline);

tools/perf/util/callchain.c

1058

callchain_cursor_commit(cursor);

tools/perf/util/callchain.c

1059

if (append_chain_children(dst, cursor, src->hit) < 0)

tools/perf/util/callchain.c

1069

err = merge_chain_branch(cursor, dst, child);

tools/perf/util/callchain.c

1076

cursor->nr = old_pos;

tools/perf/util/callchain.c

1077

cursor->last = old_last;

tools/perf/util/callchain.c

1082

int callchain_merge(struct callchain_cursor *cursor,

tools/perf/util/callchain.c

1085

return merge_chain_branch(cursor, &dst->node, &src->node);

tools/perf/util/callchain.c

1088

int callchain_cursor_append(struct callchain_cursor *cursor,

tools/perf/util/callchain.c

1094

struct callchain_cursor_node *node = *cursor->last;

tools/perf/util/callchain.c

1101

*cursor->last = node;

tools/perf/util/callchain.c

1117

cursor->nr++;

tools/perf/util/callchain.c

1119

cursor->last = &node->next;

tools/perf/util/callchain.c

1125

struct callchain_cursor *cursor, struct symbol **parent,

tools/perf/util/callchain.c

1134

return thread__resolve_callchain(al->thread, cursor, evsel, sample,

tools/perf/util/callchain.c

1605

struct callchain_cursor *cursor = vcursor;

tools/perf/util/callchain.c

1608

callchain_cursor_reset(cursor);

tools/perf/util/callchain.c

1609

for (node = cursor->first; node != NULL; node = next) {

tools/perf/util/callchain.c

1613

free(cursor);

tools/perf/util/callchain.c

1627

struct callchain_cursor *cursor;

tools/perf/util/callchain.c

1630

cursor = pthread_getspecific(callchain_cursor);

tools/perf/util/callchain.c

1631

if (!cursor) {

tools/perf/util/callchain.c

1632

cursor = zalloc(sizeof(*cursor));

tools/perf/util/callchain.c

1633

if (!cursor)

tools/perf/util/callchain.c

1635

pthread_setspecific(callchain_cursor, cursor);

tools/perf/util/callchain.c

1637

return cursor;

tools/perf/util/callchain.c

1673

void callchain_cursor_reset(struct callchain_cursor *cursor)

tools/perf/util/callchain.c

1677

cursor->nr = 0;

tools/perf/util/callchain.c

1678

cursor->last = &cursor->first;

tools/perf/util/callchain.c

1680

for (node = cursor->first; node != NULL; node = node->next)

tools/perf/util/callchain.c

1813

struct callchain_cursor *cursor = get_tls_callchain_cursor();

tools/perf/util/callchain.c

1816

if (!cursor)

tools/perf/util/callchain.c

1820

ret = __thread__resolve_callchain(thread, cursor, evsel, sample,

tools/perf/util/callchain.c

1827

callchain_cursor_commit(cursor);

tools/perf/util/callchain.c

1830

struct callchain_cursor_node *node = callchain_cursor_current(cursor);

tools/perf/util/callchain.c

1839

callchain_cursor_advance(cursor);

tools/perf/util/callchain.c

584

fill_node(struct callchain_node *node, struct callchain_cursor *cursor)

tools/perf/util/callchain.c

588

node->val_nr = cursor->nr - cursor->pos;

tools/perf/util/callchain.c

592

cursor_node = callchain_cursor_current(cursor);

tools/perf/util/callchain.c

649

callchain_cursor_advance(cursor);

tools/perf/util/callchain.c

650

cursor_node = callchain_cursor_current(cursor);

tools/perf/util/callchain.c

657

struct callchain_cursor *cursor,

tools/perf/util/callchain.c

666

if (fill_node(new, cursor) < 0) {

tools/perf/util/callchain.c

825

struct callchain_cursor *cursor,

tools/perf/util/callchain.c

857

if (idx_total < cursor->nr) {

tools/perf/util/callchain.c

868

node = callchain_cursor_current(cursor);

tools/perf/util/callchain.c

869

new = add_child(parent, cursor, period);

tools/perf/util/callchain.c

898

struct callchain_cursor *cursor,

tools/perf/util/callchain.c

903

struct callchain_cursor *cursor,

tools/perf/util/callchain.c

911

node = callchain_cursor_current(cursor);

tools/perf/util/callchain.c

923

ret = append_chain(rnode, cursor, period);

tools/perf/util/callchain.c

935

rnode = add_child(root, cursor, period);

tools/perf/util/callchain.c

950

struct callchain_cursor *cursor,

tools/perf/util/callchain.c

954

u64 start = cursor->pos;

tools/perf/util/callchain.c

968

node = callchain_cursor_current(cursor);

tools/perf/util/callchain.c

978

callchain_cursor_advance(cursor);

tools/perf/util/callchain.c

987

matches = cursor->pos - start;

tools/perf/util/callchain.c

991

if (split_add_child(root, cursor, cnode, start, matches,

tools/perf/util/callchain.c

999

if (matches == root->val_nr && cursor->pos == cursor->nr) {

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

253

struct callchain_cursor *cursor, struct symbol **parent,

tools/perf/util/db-export.c

218

struct callchain_cursor *cursor;

tools/perf/util/db-export.c

230

cursor = get_tls_callchain_cursor();

tools/perf/util/db-export.c

231

err = thread__resolve_callchain(thread, cursor, evsel,

tools/perf/util/db-export.c

237

callchain_cursor_commit(cursor);

tools/perf/util/db-export.c

245

node = callchain_cursor_current(cursor);

tools/perf/util/db-export.c

270

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

1139

struct callchain_cursor *cursor = get_tls_callchain_cursor();

tools/perf/util/hist.c

1141

if (cursor == NULL)

tools/perf/util/hist.c

1144

callchain_cursor_commit(cursor);

tools/perf/util/hist.c

1151

he_cache = malloc(sizeof(*he_cache) * (cursor->nr + 1));

tools/perf/util/hist.c

1245

struct callchain_cursor cursor, *tls_cursor = get_tls_callchain_cursor();

tools/perf/util/hist.c

1251

callchain_cursor_snapshot(&cursor, tls_cursor);

tools/perf/util/hist.c

1284

callchain_append(he->callchain, &cursor, sample->period);

tools/perf/util/hist.c

1726

struct callchain_cursor *cursor = get_tls_callchain_cursor();

tools/perf/util/hist.c

1728

if (cursor == NULL)

tools/perf/util/hist.c

1731

callchain_cursor_reset(cursor);

tools/perf/util/hist.c

1732

if (callchain_merge(cursor,

tools/perf/util/hist.c

1774

struct callchain_cursor *cursor = get_tls_callchain_cursor();

tools/perf/util/hist.c

1776

if (cursor != NULL) {

tools/perf/util/hist.c

1777

callchain_cursor_reset(cursor);

tools/perf/util/hist.c

1778

if (callchain_merge(cursor, iter->callchain, he->callchain) < 0)

tools/perf/util/machine.c

2093

static int append_inlines(struct callchain_cursor *cursor, struct map_symbol *ms, u64 ip,

tools/perf/util/machine.c

2129

ret = callchain_cursor_append(cursor, ip, &ilist_ms,

tools/perf/util/machine.c

2133

ret = callchain_cursor_append(cursor, ip, &ilist_ms, false,

tools/perf/util/machine.c

2147

struct callchain_cursor *cursor,

tools/perf/util/machine.c

2190

callchain_cursor_reset(cursor);

tools/perf/util/machine.c

2211

callchain_cursor_reset(cursor);

tools/perf/util/machine.c

2227

if (append_inlines(cursor, &ms, ip, branch, flags, nr_loop_iter,

tools/perf/util/machine.c

2232

err = callchain_cursor_append(cursor, ip, &ms,

tools/perf/util/machine.c

2328

struct callchain_cursor *cursor,

tools/perf/util/machine.c

2342

err = add_callchain_ip(thread, cursor, parent,

tools/perf/util/machine.c

2353

err = add_callchain_ip(thread, cursor, parent,

tools/perf/util/machine.c

2365

struct callchain_cursor *cursor,

tools/perf/util/machine.c

2373

if (cursor->pos == cursor->nr) {

tools/perf/util/machine.c

2378

if (!cursor->curr)

tools/perf/util/machine.c

2379

cursor->curr = cursor->first;

tools/perf/util/machine.c

2381

cursor->curr = cursor->curr->next;

tools/perf/util/machine.c

2384

memcpy(&lbr_stitch->prev_lbr_cursor[idx], cursor->curr,

tools/perf/util/machine.c

2386

lbr_stitch->prev_lbr_cursor[idx].ms.thread = thread__get(cursor->curr->ms.thread);

tools/perf/util/machine.c

2387

lbr_stitch->prev_lbr_cursor[idx].ms.map = map__get(cursor->curr->ms.map);

tools/perf/util/machine.c

2390

cursor->pos++;

tools/perf/util/machine.c

2394

struct callchain_cursor *cursor,

tools/perf/util/machine.c

2416

cursor->curr = NULL;

tools/perf/util/machine.c

2417

cursor->pos = cursor->nr;

tools/perf/util/machine.c

2418

if (cursor->nr) {

tools/perf/util/machine.c

2419

cursor->curr = cursor->first;

tools/perf/util/machine.c

2420

for (i = 0; i < (int)(cursor->nr - 1); i++)

tools/perf/util/machine.c

2421

cursor->curr = cursor->curr->next;

tools/perf/util/machine.c

2436

err = add_callchain_ip(thread, cursor, parent,

tools/perf/util/machine.c

2449

if (thread__lbr_stitch(thread) && (cursor->pos != cursor->nr)) {

tools/perf/util/machine.c

2450

if (!cursor->curr)

tools/perf/util/machine.c

2451

cursor->curr = cursor->first;

tools/perf/util/machine.c

2453

cursor->curr = cursor->curr->next;

tools/perf/util/machine.c

2454

cursor->pos++;

tools/perf/util/machine.c

2461

err = add_callchain_ip(thread, cursor, parent,

tools/perf/util/machine.c

2467

save_lbr_cursor_node(thread, cursor, i);

tools/perf/util/machine.c

2476

err = add_callchain_ip(thread, cursor, parent,

tools/perf/util/machine.c

2482

save_lbr_cursor_node(thread, cursor, i);

tools/perf/util/machine.c

2496

err = add_callchain_ip(thread, cursor, parent,

tools/perf/util/machine.c

2508

struct callchain_cursor *cursor)

tools/perf/util/machine.c

2516

cnode = &stitch_node->cursor;

tools/perf/util/machine.c

2518

err = callchain_cursor_append(cursor, cnode->ip,

tools/perf/util/machine.c

2608

memcpy(&stitch_node->cursor, &lbr_stitch->prev_lbr_cursor[i],

tools/perf/util/machine.c

2611

stitch_node->cursor.ms.thread =

tools/perf/util/machine.c

2613

stitch_node->cursor.ms.map = map__get(lbr_stitch->prev_lbr_cursor[i].ms.map);

tools/perf/util/machine.c

2662

struct callchain_cursor *cursor,

tools/perf/util/machine.c

2699

map_symbol__exit(&stitch_node->cursor.ms);

tools/perf/util/machine.c

2708

err = lbr_callchain_add_kernel_ip(thread, cursor, sample,

tools/perf/util/machine.c

2714

err = lbr_callchain_add_lbr_ip(thread, cursor, sample, parent,

tools/perf/util/machine.c

2720

err = lbr_callchain_add_stitched_lbr_ip(thread, cursor);

tools/perf/util/machine.c

2727

err = lbr_callchain_add_stitched_lbr_ip(thread, cursor);

tools/perf/util/machine.c

2731

err = lbr_callchain_add_lbr_ip(thread, cursor, sample, parent,

tools/perf/util/machine.c

2737

err = lbr_callchain_add_kernel_ip(thread, cursor, sample,

tools/perf/util/machine.c

2750

struct callchain_cursor *cursor,

tools/perf/util/machine.c

2761

err = add_callchain_ip(thread, cursor, parent,

tools/perf/util/machine.c

2780

struct callchain_cursor *cursor,

tools/perf/util/machine.c

2804

err = resolve_lbr_callchain_sample(thread, cursor, sample, parent,

tools/perf/util/machine.c

2868

err = add_callchain_ip(thread, cursor, parent,

tools/perf/util/machine.c

2875

err = add_callchain_ip(thread, cursor, parent, root_al,

tools/perf/util/machine.c

2894

err = find_prev_cpumode(chain, thread, cursor, parent, root_al,

tools/perf/util/machine.c

2916

err = find_prev_cpumode(chain, thread, cursor, parent,

tools/perf/util/machine.c

2943

err = add_callchain_ip(thread, cursor, parent,

tools/perf/util/machine.c

2951

err = add_callchain_ip(thread, cursor, parent,

tools/perf/util/machine.c

2964

struct callchain_cursor *cursor = arg;

tools/perf/util/machine.c

2971

if (append_inlines(cursor, &entry->ms, entry->ip, /*branch=*/false, /*branch_flags=*/NULL,

tools/perf/util/machine.c

2983

return callchain_cursor_append(cursor, entry->ip, &entry->ms,

tools/perf/util/machine.c

2988

struct callchain_cursor *cursor,

tools/perf/util/machine.c

3006

return unwind__get_entries(unwind_entry, cursor,

tools/perf/util/machine.c

3011

struct callchain_cursor *cursor,

tools/perf/util/machine.c

3021

if (cursor == NULL)

tools/perf/util/machine.c

3024

callchain_cursor_reset(cursor);

tools/perf/util/machine.c

3027

ret = thread__resolve_callchain_sample(thread, cursor,

tools/perf/util/machine.c

3033

ret = thread__resolve_callchain_unwind(thread, cursor,

tools/perf/util/machine.c

3037

ret = thread__resolve_callchain_unwind(thread, cursor,

tools/perf/util/machine.c

3042

ret = thread__resolve_callchain_sample(thread, cursor,

tools/perf/util/machine.h

189

struct callchain_cursor *cursor,

tools/perf/util/machine.h

198

struct callchain_cursor *cursor,

tools/perf/util/machine.h

206

cursor,

tools/perf/util/scripting-engines/trace-event-perl.c

263

struct callchain_cursor *cursor;

tools/perf/util/scripting-engines/trace-event-perl.c

273

cursor = get_tls_callchain_cursor();

tools/perf/util/scripting-engines/trace-event-perl.c

275

if (thread__resolve_callchain(al->thread, cursor, evsel,

tools/perf/util/scripting-engines/trace-event-perl.c

280

callchain_cursor_commit(cursor);

tools/perf/util/scripting-engines/trace-event-perl.c

286

node = callchain_cursor_current(cursor);

tools/perf/util/scripting-engines/trace-event-perl.c

334

callchain_cursor_advance(cursor);

tools/perf/util/scripting-engines/trace-event-python.c

397

struct callchain_cursor *cursor;

tools/perf/util/scripting-engines/trace-event-python.c

406

cursor = get_tls_callchain_cursor();

tools/perf/util/scripting-engines/trace-event-python.c

407

if (thread__resolve_callchain(al->thread, cursor, evsel,

tools/perf/util/scripting-engines/trace-event-python.c

413

callchain_cursor_commit(cursor);

tools/perf/util/scripting-engines/trace-event-python.c

419

node = callchain_cursor_current(cursor);

tools/perf/util/scripting-engines/trace-event-python.c

475

callchain_cursor_advance(cursor);

tools/perf/util/thread.c

607

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, container[MAX_DA_NAME_LEN+1], *cursor, *end;

tools/verification/rv/src/in_kernel.c

68

cursor = strstr(available_monitors, monitor_name);

tools/verification/rv/src/in_kernel.c

69

if (!cursor) {

tools/verification/rv/src/in_kernel.c

74

for (; cursor > available_monitors; cursor--)

tools/verification/rv/src/in_kernel.c

75

if (*(cursor-1) == '\n')

tools/verification/rv/src/in_kernel.c

77

end = strstr(cursor, "\n");

tools/verification/rv/src/in_kernel.c

78

memcpy(out_name, cursor, end-cursor);

tools/verification/rv/src/in_kernel.c

79

out_name[end-cursor] = '\0';

tools/verification/rv/src/in_kernel.c

81

cursor = strstr(out_name, ":");

tools/verification/rv/src/in_kernel.c

82

if (cursor)

tools/verification/rv/src/in_kernel.c

83

*cursor = '/';