arch/alpha/kernel/osf_sys.c

1205

unsigned long limit)

arch/alpha/kernel/osf_sys.c

1211

info.high_limit = limit;

arch/alpha/kernel/osf_sys.c

1220

unsigned long limit = TASK_SIZE;

arch/alpha/kernel/osf_sys.c

1222

if (len > limit)

arch/alpha/kernel/osf_sys.c

1239

addr = arch_get_unmapped_area_1 (PAGE_ALIGN(addr), len, limit);

arch/alpha/kernel/osf_sys.c

1246

len, limit);

arch/alpha/kernel/osf_sys.c

1251

addr = arch_get_unmapped_area_1 (PAGE_SIZE, len, limit);

arch/arc/include/asm/arcregs.h

232

unsigned int start:4, limit:4, pad:22, order:1, disable:1;

arch/arc/include/asm/arcregs.h

234

unsigned int disable:1, order:1, pad:22, limit:4, start:4;

arch/arc/mm/cache.c

90

perip_end = (vol.limit << 28) - 1;

arch/arm/include/asm/uaccess-asm.h

19

.macro check_uaccess, addr:req, size:req, limit:req, tmp:req, bad:req

arch/arm/include/asm/uaccess-asm.h

31

.macro uaccess_mask_range_ptr, addr:req, size:req, limit:req, tmp:req

arch/arm/include/asm/uaccess-asm.h

34

subs \tmp, \tmp, \addr @ tmp = limit - 1 - addr

arch/arm/include/asm/uaccess-asm.h

36

subshs \tmp, \tmp, \size @ tmp = limit - (addr + size) }

arch/arm/mach-rpc/include/mach/acornfb.h

15

u_long limit;

arch/arm/mach-rpc/include/mach/acornfb.h

25

limit = 6578;

arch/arm/mach-rpc/include/mach/acornfb.h

27

limit = 13157;

arch/arm/mach-rpc/include/mach/acornfb.h

29

limit = 26315;

arch/arm/mach-rpc/include/mach/acornfb.h

32

return acornfb_bandwidth(var) >= limit;

arch/arm/mach-socfpga/ocram.c

103

if (limit < 0)

arch/arm/mach-socfpga/ocram.c

94

int limit = ALTR_A10_ECC_INIT_WATCHDOG_10US;

arch/arm/mach-socfpga/ocram.c

97

while (limit--) {

arch/arm/mm/dma-mapping.c

553

u64 limit = (mask + 1) & ~mask;

arch/arm/mm/dma-mapping.c

554

if (limit && size >= limit) {

arch/arm/mm/pmsa-v7.c

190

unsigned int limit, struct region *regions)

arch/arm/mm/pmsa-v7.c

218

if (count > limit)

arch/arm64/include/asm/kvm_host.h

1571

#define kvm_cmp_feat_signed(kvm, id, fld, op, limit) \

arch/arm64/include/asm/kvm_host.h

1572

(get_idreg_field_signed((kvm), id, fld) op __expand_field_sign_signed(id, fld, limit))

arch/arm64/include/asm/kvm_host.h

1574

#define kvm_cmp_feat_unsigned(kvm, id, fld, op, limit) \

arch/arm64/include/asm/kvm_host.h

1575

(get_idreg_field_unsigned((kvm), id, fld) op __expand_field_sign_unsigned(id, fld, limit))

arch/arm64/include/asm/kvm_host.h

1577

#define kvm_cmp_feat(kvm, id, fld, op, limit) \

arch/arm64/include/asm/kvm_host.h

1579

kvm_cmp_feat_signed(kvm, id, fld, op, limit) : \

arch/arm64/include/asm/kvm_host.h

1580

kvm_cmp_feat_unsigned(kvm, id, fld, op, limit))

arch/arm64/include/asm/kvm_host.h

1582

#define __kvm_has_feat(kvm, id, fld, limit) \

arch/arm64/include/asm/kvm_host.h

1583

kvm_cmp_feat(kvm, id, fld, >=, limit)

arch/arm64/kernel/ptrace.c

512

int ret, idx = 0, offset, limit;

arch/arm64/kernel/ptrace.c

521

limit = regset->n * regset->size;

arch/arm64/kernel/ptrace.c

522

while (count && offset < limit) {

arch/arm64/kernel/signal.c

137

user->limit = user->size + reserved_size;

arch/arm64/kernel/signal.c

139

user->limit -= TERMINATOR_SIZE;

arch/arm64/kernel/signal.c

140

user->limit -= EXTRA_CONTEXT_SIZE;

arch/arm64/kernel/signal.c

162

if (padded_size > user->limit - user->size &&

arch/arm64/kernel/signal.c

167

user->limit += EXTRA_CONTEXT_SIZE;

arch/arm64/kernel/signal.c

171

user->limit -= EXTRA_CONTEXT_SIZE;

arch/arm64/kernel/signal.c

182

user->limit = SIGFRAME_MAXSZ - TERMINATOR_SIZE;

arch/arm64/kernel/signal.c

186

if (padded_size > user->limit - user->size)

arch/arm64/kernel/signal.c

212

user->limit += TERMINATOR_SIZE;

arch/arm64/kernel/signal.c

220

user->limit = user->size;

arch/arm64/kernel/signal.c

55

unsigned long limit; /* largest allowed size */

arch/arm64/kernel/signal.c

760

size_t limit = sizeof(sc->__reserved);

arch/arm64/kernel/signal.c

786

if (limit - offset < sizeof(*head))

arch/arm64/kernel/signal.c

798

if (limit - offset < size)

arch/arm64/kernel/signal.c

918

if (limit - offset - size < TERMINATOR_SIZE)

arch/arm64/kernel/signal.c

954

limit = extra_size;

arch/arm64/kernel/signal.c

956

if (!access_ok(base, limit))

arch/arm64/kernel/signal.c

968

if (limit - offset < size)

arch/arm64/kvm/hyp/nvhe/mem_protect.c

380

u64 limit = BIT(kvm_phys_shift(&host_mmu.arch.mmu) - PAGE_SHIFT);

arch/arm64/kvm/hyp/nvhe/mem_protect.c

382

return pfn < limit && ((limit - pfn) >= nr_pages);

arch/arm64/kvm/hyp/pgtable.c

249

u64 limit = BIT(pgt->ia_bits);

arch/arm64/kvm/hyp/pgtable.c

251

if (data->addr > limit || data->end > limit)

arch/arm64/kvm/sys_regs.c

1701

u64 limit = rd->reset(vcpu, rd);

arch/arm64/kvm/sys_regs.c

1727

f_lim = arm64_ftr_value(ftrp, limit);

arch/arm64/kvm/sys_regs.c

1740

if ((val & ~mask) != (limit & ~mask))

arch/arm64/kvm/sys_regs.c

3936

u64 limit, vttbr;

arch/arm64/kvm/sys_regs.c

3942

limit = BIT_ULL(kvm_get_pa_bits(vcpu->kvm));

arch/arm64/kvm/sys_regs.c

3948

.size = limit,

arch/arm64/kvm/sys_regs.h

260

#define ID_REG_LIMIT_FIELD_ENUM(val, reg, field, limit) \

arch/arm64/kvm/sys_regs.h

266

(u64)SYS_FIELD_VALUE(reg, field, limit))); \

arch/loongarch/kernel/ftrace.c

29

int limit = 32;

arch/loongarch/kernel/ftrace.c

36

limit--;

arch/loongarch/kernel/ftrace.c

41

} while (!is_stack_alloc_ins(insn) && limit);

arch/loongarch/kernel/ftrace.c

43

if (!limit)

arch/loongarch/kernel/ptrace.c

724

int ret, idx = 0, offset, limit;

arch/loongarch/kernel/ptrace.c

732

limit = regset->n * regset->size;

arch/loongarch/kernel/ptrace.c

733

while (count && offset < limit) {

arch/mips/ath25/board.c

57

static const void __iomem * __init find_board_config(const void __iomem *limit,

arch/mips/ath25/board.c

61

const void __iomem *begin = limit - 0x1000;

arch/mips/ath25/board.c

62

const void __iomem *end = limit - 0x30000;

arch/mips/ath25/board.c

71

static const void __iomem * __init find_radio_config(const void __iomem *limit,

arch/mips/ath25/board.c

82

end = limit;

arch/mips/ath25/board.c

89

end = limit - 0x1000 + 0xf8;

arch/mips/include/asm/octeon/cvmx-agl-defs.h

1425

uint64_t limit:5;

arch/mips/include/asm/octeon/cvmx-agl-defs.h

1427

uint64_t limit:5;

arch/mips/kvm/vz.c

2817

unsigned int config4 = 0, ret = 0, limit;

arch/mips/kvm/vz.c

2845

limit = (read_c0_wired() & MIPSR6_WIRED_LIMIT) >>

arch/mips/kvm/vz.c

2847

if (size - 1 <= limit)

arch/mips/kvm/vz.c

2848

limit = 0;

arch/mips/kvm/vz.c

2849

write_gc0_wired(limit << MIPSR6_WIRED_LIMIT_SHIFT);

arch/parisc/mm/init.c

106

if (limit < mem_limit)

arch/parisc/mm/init.c

107

mem_limit = limit;

arch/parisc/mm/init.c

86

unsigned long limit;

arch/parisc/mm/init.c

90

limit = MAX_MEM;

arch/parisc/mm/init.c

94

limit = memparse(cp, &end);

arch/powerpc/boot/decompress.c

129

limit = output_size;

arch/powerpc/boot/decompress.c

139

if (decompressed_bytes < limit)

arch/powerpc/boot/decompress.c

42

static unsigned long limit;

arch/powerpc/boot/decompress.c

62

if (decompressed_bytes >= limit)

arch/powerpc/boot/decompress.c

81

size = min(decompressed_bytes + size, limit) - decompressed_bytes;

arch/powerpc/boot/decompress.c

92

if (decompressed_bytes >= limit)

arch/powerpc/include/asm/book3s/64/mmu.h

164

static inline void mm_ctx_set_slb_addr_limit(mm_context_t *ctx, unsigned long limit)

arch/powerpc/include/asm/book3s/64/mmu.h

166

ctx->hash_context->slb_addr_limit = limit;

arch/powerpc/include/asm/rtas-work-area.h

91

void rtas_work_area_reserve_arena(phys_addr_t limit);

arch/powerpc/include/asm/rtas-work-area.h

93

static inline void rtas_work_area_reserve_arena(phys_addr_t limit) {}

arch/powerpc/kernel/iommu.c

223

unsigned long limit;

arch/powerpc/kernel/iommu.c

265

limit = pool->end;

arch/powerpc/kernel/iommu.c

271

if (start >= limit)

arch/powerpc/kernel/iommu.c

274

if (limit + tbl->it_offset > mask) {

arch/powerpc/kernel/iommu.c

275

limit = mask - tbl->it_offset + 1;

arch/powerpc/kernel/iommu.c

280

if ((start & mask) >= limit || pass > 0) {

arch/powerpc/kernel/iommu.c

290

n = iommu_area_alloc(tbl->it_map, limit, start, npages, tbl->it_offset,

arch/powerpc/kernel/mce.c

755

u64 limit;

arch/powerpc/kernel/mce.c

758

limit = min(ppc64_bolted_size(), ppc64_rma_size);

arch/powerpc/kernel/mce.c

763

limit, early_cpu_to_node(i));

arch/powerpc/kernel/paca.c

121

static struct lppaca * __init new_lppaca(int cpu, unsigned long limit)

arch/powerpc/kernel/paca.c

131

lp = alloc_shared_lppaca(LPPACA_SIZE, limit, cpu);

arch/powerpc/kernel/paca.c

133

lp = alloc_paca_data(LPPACA_SIZE, 0x400, limit, cpu);

arch/powerpc/kernel/paca.c

149

static struct slb_shadow * __init new_slb_shadow(int cpu, unsigned long limit)

arch/powerpc/kernel/paca.c

163

s = alloc_paca_data(sizeof(*s), L1_CACHE_BYTES, limit, cpu);

arch/powerpc/kernel/paca.c

258

u64 limit;

arch/powerpc/kernel/paca.c

268

limit = min(ppc64_bolted_size(), ppc64_rma_size);

arch/powerpc/kernel/paca.c

27

unsigned long limit, int cpu)

arch/powerpc/kernel/paca.c

270

limit = ppc64_rma_size;

arch/powerpc/kernel/paca.c

274

limit, cpu);

arch/powerpc/kernel/paca.c

279

paca->lppaca_ptr = new_lppaca(cpu, limit);

arch/powerpc/kernel/paca.c

282

paca->slb_shadow_ptr = new_slb_shadow(cpu, limit);

arch/powerpc/kernel/paca.c

45

limit, nid);

arch/powerpc/kernel/paca.c

59

static void *__init alloc_shared_lppaca(unsigned long size, unsigned long limit,

arch/powerpc/kernel/paca.c

80

limit, NUMA_NO_NODE);

arch/powerpc/kernel/security.c

647

u64 l1d_size, limit;

arch/powerpc/kernel/security.c

666

limit = min(ppc64_bolted_size(), ppc64_rma_size);

arch/powerpc/kernel/security.c

675

limit, NUMA_NO_NODE);

arch/powerpc/kernel/security.c

678

__func__, l1d_size * 2, l1d_size, &limit);

arch/powerpc/kernel/setup_64.c

709

static void *__init alloc_stack(unsigned long limit, int cpu)

arch/powerpc/kernel/setup_64.c

716

MEMBLOCK_LOW_LIMIT, limit,

arch/powerpc/kernel/setup_64.c

726

u64 limit = ppc64_bolted_size();

arch/powerpc/kernel/setup_64.c

735

softirq_ctx[i] = alloc_stack(limit, i);

arch/powerpc/kernel/setup_64.c

736

hardirq_ctx[i] = alloc_stack(limit, i);

arch/powerpc/kernel/setup_64.c

773

u64 limit, mce_limit;

arch/powerpc/kernel/setup_64.c

790

limit = mce_limit = min(ppc64_bolted_size(), ppc64_rma_size);

arch/powerpc/kernel/setup_64.c

802

paca_ptrs[i]->emergency_sp = alloc_stack(limit, i) + THREAD_SIZE;

arch/powerpc/kernel/setup_64.c

806

paca_ptrs[i]->nmi_emergency_sp = alloc_stack(limit, i) + THREAD_SIZE;

arch/powerpc/mm/book3s32/mmu.c

294

bat_addrs[index].limit = virt + ((bl + 1) << 17) - 1;

arch/powerpc/mm/book3s32/mmu.c

44

unsigned long limit;

arch/powerpc/mm/book3s32/mmu.c

59

if (va >= bat_addrs[b].start && va < bat_addrs[b].limit)

arch/powerpc/mm/book3s32/mmu.c

72

&& pa < (bat_addrs[b].limit-bat_addrs[b].start)

arch/powerpc/mm/book3s64/hash_utils.c

1314

phys_addr_t base = 0, size = 0, end, limit = MEMBLOCK_ALLOC_ANYWHERE;

arch/powerpc/mm/book3s64/hash_utils.c

1321

limit = ppc64_rma_size;

arch/powerpc/mm/book3s64/hash_utils.c

1341

MEMBLOCK_LOW_LIMIT, limit);

arch/powerpc/mm/book3s64/hash_utils.c

1378

MEMBLOCK_LOW_LIMIT, limit);

arch/powerpc/mm/book3s64/hash_utils.c

1381

&htab_size_bytes, &limit);

arch/powerpc/mm/book3s64/subpage_prot.c

105

limit = addr + len;

arch/powerpc/mm/book3s64/subpage_prot.c

106

if (limit > spt->maxaddr)

arch/powerpc/mm/book3s64/subpage_prot.c

107

limit = spt->maxaddr;

arch/powerpc/mm/book3s64/subpage_prot.c

108

for (; addr < limit; addr = next) {

arch/powerpc/mm/book3s64/subpage_prot.c

109

next = pmd_addr_end(addr, limit);

arch/powerpc/mm/book3s64/subpage_prot.c

192

unsigned long next, limit;

arch/powerpc/mm/book3s64/subpage_prot.c

233

for (limit = addr + len; addr < limit; addr = next) {

arch/powerpc/mm/book3s64/subpage_prot.c

234

next = pmd_addr_end(addr, limit);

arch/powerpc/mm/book3s64/subpage_prot.c

275

if (limit > spt->maxaddr)

arch/powerpc/mm/book3s64/subpage_prot.c

276

spt->maxaddr = limit;

arch/powerpc/mm/book3s64/subpage_prot.c

97

unsigned long next, limit;

arch/powerpc/mm/mem.c

409

unsigned long limit = (unsigned long)_etext - SZ_32M;

arch/powerpc/mm/mem.c

412

if (MODULES_VADDR < PAGE_OFFSET && MODULES_END > limit) {

arch/powerpc/mm/mem.c

413

start = limit;

arch/powerpc/mm/nohash/e500.c

134

tlbcam_addrs[index].limit = virt + size - 1;

arch/powerpc/mm/nohash/e500.c

240

return tlbcam_addrs[tlbcam_index - 1].limit - PAGE_OFFSET + 1;

arch/powerpc/mm/nohash/e500.c

263

return tlbcam_addrs[idx].limit - tlbcam_addrs[idx].start + 1;

arch/powerpc/mm/nohash/e500.c

310

phys_addr_t limit = first_memblock_base + first_memblock_size;

arch/powerpc/mm/nohash/e500.c

313

memblock_set_current_limit(min_t(u64, limit, 0x04000000));

arch/powerpc/mm/nohash/e500.c

58

unsigned long limit;

arch/powerpc/mm/nohash/e500.c

70

if (va >= tlbcam_addrs[b].start && va < tlbcam_addrs[b].limit)

arch/powerpc/mm/nohash/e500.c

83

&& pa < (tlbcam_addrs[b].limit-tlbcam_addrs[b].start)

arch/powerpc/platforms/pasemi/dma_lib.c

105

int start, limit;

arch/powerpc/platforms/pasemi/dma_lib.c

110

limit = 10;

arch/powerpc/platforms/pasemi/dma_lib.c

114

limit = MAX_TXCH;

arch/powerpc/platforms/pasemi/dma_lib.c

118

limit = MAX_TXCH;

arch/powerpc/platforms/pasemi/dma_lib.c

123

if (bit >= limit)

arch/powerpc/platforms/powernv/pci-ioda-tce.c

257

unsigned int levels, unsigned long limit,

arch/powerpc/platforms/powernv/pci-ioda-tce.c

276

levels, limit, current_offset, total_allocated);

arch/powerpc/platforms/powernv/pci-ioda-tce.c

283

if (*current_offset >= limit)

arch/powerpc/platforms/pseries/hotplug-memory.c

181

struct drmem_lmb *limit;

arch/powerpc/platforms/pseries/hotplug-memory.c

196

limit = &drmem_info->lmbs[drmem_info->n_lmbs];

arch/powerpc/platforms/pseries/hotplug-memory.c

197

if (end > limit)

arch/powerpc/platforms/pseries/iommu.c

259

long l, limit;

arch/powerpc/platforms/pseries/iommu.c

301

limit = min_t(long, npages, 4096 / TCE_ENTRY_SIZE);

arch/powerpc/platforms/pseries/iommu.c

303

for (l = 0; l < limit; l++) {

arch/powerpc/platforms/pseries/iommu.c

311

limit);

arch/powerpc/platforms/pseries/iommu.c

313

npages -= limit;

arch/powerpc/platforms/pseries/iommu.c

314

tcenum += limit;

arch/powerpc/platforms/pseries/iommu.c

322

(npages_start - (npages + limit)));

arch/powerpc/platforms/pseries/iommu.c

360

unsigned long limit;

arch/powerpc/platforms/pseries/iommu.c

367

limit = min_t(unsigned long, rpages, 512);

arch/powerpc/platforms/pseries/iommu.c

370

(u64)tcenum << tbl->it_page_shift, 0, limit);

arch/powerpc/platforms/pseries/iommu.c

372

rpages -= limit;

arch/powerpc/platforms/pseries/iommu.c

373

tcenum += limit;

arch/powerpc/platforms/pseries/iommu.c

445

long limit;

arch/powerpc/platforms/pseries/iommu.c

465

limit = min_t(long, num_tce, 512);

arch/powerpc/platforms/pseries/iommu.c

470

0, limit);

arch/powerpc/platforms/pseries/iommu.c

471

next += limit * tce_size;

arch/powerpc/platforms/pseries/iommu.c

472

num_tce -= limit;

arch/powerpc/platforms/pseries/iommu.c

486

long l, limit;

arch/powerpc/platforms/pseries/iommu.c

535

limit = min_t(long, num_tce, 4096 / TCE_ENTRY_SIZE);

arch/powerpc/platforms/pseries/iommu.c

538

for (l = 0; l < limit; l++) {

arch/powerpc/platforms/pseries/iommu.c

546

limit);

arch/powerpc/platforms/pseries/iommu.c

548

num_tce -= limit;

arch/powerpc/platforms/pseries/rtas-work-area.c

189

void __init rtas_work_area_reserve_arena(const phys_addr_t limit)

arch/powerpc/platforms/pseries/rtas-work-area.c

209

rwa_state.arena = memblock_alloc_try_nid(size, align, min, limit, nid);

arch/powerpc/sysdev/dart_iommu.c

105

unsigned int l, limit;

arch/powerpc/sysdev/dart_iommu.c

114

limit = 0;

arch/powerpc/sysdev/dart_iommu.c

117

while ((DART_IN(DART_CNTL) & DART_CNTL_U4_IONE) && l < (1L << limit)) {

arch/powerpc/sysdev/dart_iommu.c

122

if (l == (1L << limit)) {

arch/powerpc/sysdev/dart_iommu.c

123

if (limit < 4) {

arch/powerpc/sysdev/dart_iommu.c

124

limit++;

arch/powerpc/sysdev/dart_iommu.c

62

unsigned long limit;

arch/powerpc/sysdev/dart_iommu.c

76

limit = 0;

arch/powerpc/sysdev/dart_iommu.c

85

while ((DART_IN(DART_CNTL) & inv_bit) && l < (1L << limit))

arch/powerpc/sysdev/dart_iommu.c

87

if (l == (1L << limit)) {

arch/powerpc/sysdev/dart_iommu.c

88

if (limit < 4) {

arch/powerpc/sysdev/dart_iommu.c

89

limit++;

arch/s390/boot/boot.h

47

void physmem_set_usable_limit(unsigned long limit);

arch/s390/boot/boot.h

80

int get_random(unsigned long limit, unsigned long *value);

arch/s390/boot/kaslr.c

46

int get_random(unsigned long limit, unsigned long *value)

arch/s390/boot/kaslr.c

90

*value = random % limit;

arch/s390/boot/physmem_info.c

198

void physmem_set_usable_limit(unsigned long limit)

arch/s390/boot/physmem_info.c

200

physmem_info.usable = limit;

arch/s390/boot/physmem_info.c

201

physmem_alloc_pos = limit;

arch/s390/boot/physmem_info.c

202

boot_debug("Usable memory limit: 0x%016lx\n", limit);

arch/s390/boot/uv.c

58

unsigned long adjust_to_uv_max(unsigned long limit)

arch/s390/boot/uv.c

61

limit = min_t(unsigned long, limit, uv_info.max_sec_stor_addr);

arch/s390/boot/uv.c

62

return limit;

arch/s390/boot/uv.h

5

unsigned long adjust_to_uv_max(unsigned long limit);

arch/s390/crypto/prng.c

750

unsigned limit;

arch/s390/crypto/prng.c

752

if (sscanf(buf, "%u\n", &limit) != 1)

arch/s390/crypto/prng.c

756

if (limit < PRNG_RESEED_LIMIT_SHA512_LOWER)

arch/s390/crypto/prng.c

759

if (limit < PRNG_RESEED_LIMIT_TDES_LOWER)

arch/s390/crypto/prng.c

763

prng_reseed_limit = limit;

arch/s390/include/asm/pgalloc.h

35

int crst_table_upgrade(struct mm_struct *mm, unsigned long limit);

arch/s390/kvm/gmap.c

113

struct gmap *gmap_new_child(struct gmap *parent, gfn_t limit)

arch/s390/kvm/gmap.c

118

res = gmap_new(parent->kvm, limit);

arch/s390/kvm/gmap.c

126

int gmap_set_limit(struct gmap *gmap, gfn_t limit)

arch/s390/kvm/gmap.c

131

type = gmap_limit_to_type(limit);

arch/s390/kvm/gmap.c

32

static int gmap_limit_to_type(gfn_t limit)

arch/s390/kvm/gmap.c

34

if (!limit)

arch/s390/kvm/gmap.c

36

if (limit <= _REGION3_SIZE >> PAGE_SHIFT)

arch/s390/kvm/gmap.c

38

if (limit <= _REGION2_SIZE >> PAGE_SHIFT)

arch/s390/kvm/gmap.c

40

if (limit <= _REGION1_SIZE >> PAGE_SHIFT)

arch/s390/kvm/gmap.c

52

struct gmap *gmap_new(struct kvm *kvm, gfn_t limit)

arch/s390/kvm/gmap.c

58

type = gmap_limit_to_type(limit);

arch/s390/kvm/gmap.h

90

struct gmap *gmap_new(struct kvm *kvm, gfn_t limit);

arch/s390/kvm/gmap.h

91

struct gmap *gmap_new_child(struct gmap *parent, gfn_t limit);

arch/s390/kvm/gmap.h

96

int gmap_set_limit(struct gmap *gmap, gfn_t limit);

arch/s390/pci/pci.c

131

u64 base, u64 limit, u64 iota, u8 *status)

arch/s390/pci/pci.c

139

if (zdev->pft == PCI_FUNC_TYPE_ISM && limit > base)

arch/s390/pci/pci.c

140

fib.pal = limit + (1 << 12);

arch/s390/pci/pci.c

142

fib.pal = limit;

arch/s390/pci/pci_clp.c

494

unsigned long limit = PAGE_SIZE - sizeof(lpcb->request);

arch/s390/pci/pci_clp.c

497

lpcb->response.hdr.len > limit)

arch/s390/pci/pci_clp.c

514

unsigned long limit = PAGE_SIZE - sizeof(lpcb->request);

arch/s390/pci/pci_clp.c

517

lpcb->response.hdr.len > limit)

arch/s390/pci/pci_clp.c

524

unsigned long limit = PAGE_SIZE - sizeof(lpcb->request);

arch/s390/pci/pci_clp.c

527

lpcb->response.hdr.len > limit)

arch/s390/pci/pci_clp.c

537

unsigned long limit = PAGE_SIZE - sizeof(lpcb->request);

arch/s390/pci/pci_clp.c

540

lpcb->response.hdr.len > limit)

arch/s390/pci/pci_clp.c

550

unsigned long limit = PAGE_SIZE - sizeof(lpcb->request);

arch/s390/pci/pci_clp.c

553

lpcb->response.hdr.len > limit)

arch/sparc/include/asm/io-unit.h

49

unsigned long limit[4];

arch/sparc/include/asm/iommu_64.h

25

unsigned int limit;

arch/sparc/include/asm/obio.h

123

unsigned int limit;

arch/sparc/include/asm/obio.h

126

"=r" (limit) :

arch/sparc/include/asm/obio.h

129

return limit;

arch/sparc/include/asm/obio.h

132

static inline void bw_set_prof_limit(int cpu, unsigned int limit)

arch/sparc/include/asm/obio.h

135

"r" (limit),

arch/sparc/include/asm/uaccess_64.h

30

static inline bool __chk_range_not_ok(unsigned long addr, unsigned long size, unsigned long limit)

arch/sparc/include/asm/uaccess_64.h

33

return addr > limit - size;

arch/sparc/include/asm/uaccess_64.h

39

return addr > limit;

arch/sparc/include/asm/uaccess_64.h

42

#define __range_not_ok(addr, size, limit) \

arch/sparc/include/asm/uaccess_64.h

45

__chk_range_not_ok((unsigned long __force)(addr), size, limit); \

arch/sparc/kernel/ds.c

246

int err, limit = 1000;

arch/sparc/kernel/ds.c

249

while (limit-- > 0) {

arch/sparc/kernel/iommu-common.c

105

unsigned long n, end, start, limit, boundary_size;

arch/sparc/kernel/iommu-common.c

142

limit = pool->end;

arch/sparc/kernel/iommu-common.c

150

if (start >= limit)

arch/sparc/kernel/iommu-common.c

153

if (limit + shift > mask) {

arch/sparc/kernel/iommu-common.c

154

limit = mask - shift + 1;

arch/sparc/kernel/iommu-common.c

159

if ((start & mask) >= limit || pass > 0) {

arch/sparc/kernel/iommu-common.c

181

n = iommu_area_alloc(iommu->map, limit, start, npages, shift,

arch/sparc/kernel/iommu.c

334

int limit;

arch/sparc/kernel/iommu.c

382

limit = 100000;

arch/sparc/kernel/iommu.c

384

limit--;

arch/sparc/kernel/iommu.c

385

if (!limit)

arch/sparc/kernel/iommu.c

390

if (!limit)

arch/sparc/kernel/irq.h

75

void (*load_profile_irq)(int cpu, unsigned int limit);

arch/sparc/kernel/ldc.c

1676

int limit = 1000;

arch/sparc/kernel/ldc.c

1680

while (limit-- > 0) {

arch/sparc/kernel/ldc.c

252

unsigned long limit, tail, new_tail, diff;

arch/sparc/kernel/ldc.c

255

limit = head_for_data(lp);

arch/sparc/kernel/ldc.c

258

if (new_tail == limit)

arch/sparc/kernel/ldc.c

261

if (limit > new_tail)

arch/sparc/kernel/ldc.c

262

diff = limit - new_tail;

arch/sparc/kernel/ldc.c

264

diff = (limit +

arch/sparc/kernel/ldc.c

295

int limit = 1000;

arch/sparc/kernel/ldc.c

298

while (limit-- > 0) {

arch/sparc/kernel/ldc.c

322

int limit = 1000;

arch/sparc/kernel/ldc.c

324

while (limit-- > 0) {

arch/sparc/kernel/leon_kernel.c

480

static void leon_load_profile_irq(int cpu, unsigned int limit)

arch/sparc/kernel/pci_schizo.c

382

int reported, limit;

arch/sparc/kernel/pci_schizo.c

391

limit = 1000;

arch/sparc/kernel/pci_schizo.c

394

} while ((afsr & SCHIZO_UEAFSR_ERRPNDG) != 0 && --limit);

arch/sparc/kernel/pci_schizo.c

470

int reported, limit;

arch/sparc/kernel/pci_schizo.c

479

limit = 1000;

arch/sparc/kernel/pci_schizo.c

482

} while ((afsr & SCHIZO_UEAFSR_ERRPNDG) != 0 && --limit);

arch/sparc/kernel/pci_sun4v.c

972

unsigned long err, limit;

arch/sparc/kernel/pci_sun4v.c

978

limit = pbm->msiq_ent_count * sizeof(struct pci_sun4v_msiq_entry);

arch/sparc/kernel/pci_sun4v.c

979

if (unlikely(*head >= limit))

arch/sparc/kernel/pcic.c

802

static void pcic_load_profile_irq(int cpu, unsigned int limit)

arch/sparc/kernel/process_64.c

231

int limit = 0;

arch/sparc/kernel/process_64.c

233

while (!gp->thread && ++limit < 100) {

arch/sparc/kernel/process_64.c

332

int limit = 0;

arch/sparc/kernel/process_64.c

334

while (!pp->pcr[0] && ++limit < 100) {

arch/sparc/kernel/prom_64.c

510

int limit = 2;

arch/sparc/kernel/prom_64.c

513

while (limit--) {

arch/sparc/kernel/prom_irqtrans.c

339

int limit;

arch/sparc/kernel/prom_irqtrans.c

343

limit = 100000;

arch/sparc/kernel/prom_irqtrans.c

345

while (--limit) {

arch/sparc/kernel/prom_irqtrans.c

350

if (limit <= 0) {

arch/sparc/kernel/smp_64.c

1373

int limit = 100;

arch/sparc/kernel/smp_64.c

1381

} while (--limit > 0);

arch/sparc/kernel/smp_64.c

1382

if (limit <= 0) {

arch/sparc/kernel/sun4d_irq.c

273

static void sun4d_load_profile_irq(int cpu, unsigned int limit)

arch/sparc/kernel/sun4d_irq.c

275

unsigned int value = limit ? timer_value(limit) : 0;

arch/sparc/kernel/sun4m_irq.c

352

static void sun4m_load_profile_irq(int cpu, unsigned int limit)

arch/sparc/kernel/sun4m_irq.c

354

unsigned int value = limit ? timer_value(limit) : 0;

arch/sparc/kernel/traps_64.c

72

int i, limit;

arch/sparc/kernel/traps_64.c

77

limit = (tlb_type == hypervisor) ? 2 : 4;

arch/sparc/kernel/traps_64.c

78

for (i = 0; i < limit; i++) {

arch/sparc/kernel/viohs.c

20

int err, limit = 1000;

arch/sparc/kernel/viohs.c

23

while (limit-- > 0) {

arch/sparc/mm/io-unit.c

101

unsigned long rotor, scan, limit;

arch/sparc/mm/io-unit.c

117

limit = iounit->limit[j];

arch/sparc/mm/io-unit.c

119

nexti: scan = find_next_zero_bit(iounit->bmap, limit, scan);

arch/sparc/mm/io-unit.c

120

if (scan + npages > limit) {

arch/sparc/mm/io-unit.c

121

if (limit != rotor) {

arch/sparc/mm/io-unit.c

122

limit = rotor;

arch/sparc/mm/io-unit.c

123

scan = iounit->limit[j - 1];

arch/sparc/mm/io-unit.c

135

iounit->rotor[j - 1] = (scan < limit) ? scan : iounit->limit[j - 1];

arch/sparc/mm/io-unit.c

53

iounit->limit[0] = IOUNIT_BMAP1_START;

arch/sparc/mm/io-unit.c

54

iounit->limit[1] = IOUNIT_BMAP2_START;

arch/sparc/mm/io-unit.c

55

iounit->limit[2] = IOUNIT_BMAPM_START;

arch/sparc/mm/io-unit.c

56

iounit->limit[3] = IOUNIT_BMAPM_END;

arch/x86/coco/sev/core.c

809

vmsa->cs.limit = AP_INIT_CS_LIMIT;

arch/x86/coco/sev/core.c

817

vmsa->ds.limit = AP_INIT_DS_LIMIT;

arch/x86/coco/sev/core.c

824

vmsa->gdtr.limit = AP_INIT_GDTR_LIMIT;

arch/x86/coco/sev/core.c

825

vmsa->ldtr.limit = AP_INIT_LDTR_LIMIT;

arch/x86/coco/sev/core.c

827

vmsa->idtr.limit = AP_INIT_IDTR_LIMIT;

arch/x86/coco/sev/core.c

828

vmsa->tr.limit = AP_INIT_TR_LIMIT;

arch/x86/hyperv/hv_crash.c

414

u16 limit;

arch/x86/hyperv/hv_crash.c

458

BUILD_BUG_ON(offsetof(struct hv_crash_tramp_data, gdtr32.limit) != 18);

arch/x86/hyperv/hv_crash.c

485

tramp->gdtr32.limit = sizeof(struct hv_crash_tramp_gdt);

arch/x86/hyperv/hv_vtl.c

170

input->vp_context.idtr.limit = idt_ptr.size;

arch/x86/hyperv/hv_vtl.c

172

input->vp_context.gdtr.limit = gdt_ptr.size;

arch/x86/hyperv/hv_vtl.c

178

input->vp_context.cs.limit = 0xffffffff;

arch/x86/hyperv/hv_vtl.c

183

input->vp_context.ss.limit = 0xffffffff;

arch/x86/hyperv/hv_vtl.c

189

input->vp_context.ldtr.limit = hv_vtl_system_desc_limit(ldt);

arch/x86/hyperv/hv_vtl.c

195

input->vp_context.tr.limit = hv_vtl_system_desc_limit(tss);

arch/x86/hyperv/ivm.c

260

seg.limit = HV_AP_SEGMENT_LIMIT; \

arch/x86/hyperv/ivm.c

317

vmsa->gdtr.limit = gdtr.size;

arch/x86/include/asm/desc.h

18

desc->limit0 = info->limit & 0x0ffff;

arch/x86/include/asm/desc.h

31

desc->limit1 = (info->limit & 0xf0000) >> 16;

arch/x86/include/asm/desc.h

356

(info)->limit == 0 && \

arch/x86/include/asm/desc.h

368

info->limit == 0 &&

arch/x86/include/asm/desc.h

399

static inline void set_desc_limit(struct desc_struct *desc, unsigned long limit)

arch/x86/include/asm/desc.h

401

desc->limit0 = limit & 0xffff;

arch/x86/include/asm/desc.h

402

desc->limit1 = (limit >> 16) & 0xf;

arch/x86/include/asm/desc_defs.h

73

#define GDT_ENTRY_INIT(flags, base, limit) \

arch/x86/include/asm/desc_defs.h

75

.limit0 = ((limit) >> 0) & 0xFFFF, \

arch/x86/include/asm/desc_defs.h

76

.limit1 = ((limit) >> 16) & 0x000F, \

arch/x86/include/asm/hw_irq.h

53

int limit;

arch/x86/include/asm/kvm_host.h

737

u32 limit;

arch/x86/include/asm/segment.h

13

#define GDT_ENTRY(flags, base, limit) \

arch/x86/include/asm/segment.h

16

(((limit) & _AC(0x000f0000,ULL)) << (48-16)) | \

arch/x86/include/asm/segment.h

18

(((limit) & _AC(0x0000ffff,ULL))))

arch/x86/include/asm/svm.h

315

u32 limit;

arch/x86/include/asm/uv/bios.h

87

u32 limit; /* PA bits 56:26 (UV_GAM_RANGE_SHFT) */

arch/x86/include/asm/uv/uv_hub.h

135

u32 limit; /* PA bits 56:26 (GAM_RANGE_SHFT) */

arch/x86/include/asm/uv/uv_hub.h

399

if (pal < gr->limit)

arch/x86/include/asm/uv/uv_hub.h

416

return uv_hub_info->gr_table[base].limit;

arch/x86/include/asm/uv/uv_hub.h

546

base = (unsigned long)(uv_hub_info->gr_table[sockid - 1].limit);

arch/x86/include/uapi/asm/kvm.h

134

__u32 limit;

arch/x86/include/uapi/asm/kvm.h

144

__u16 limit;

arch/x86/include/uapi/asm/ldt.h

24

unsigned int limit;

arch/x86/kernel/apic/x2apic_uv_x.c

1269

unsigned long size = ((unsigned long)(gre->limit - lgre)

arch/x86/kernel/apic/x2apic_uv_x.c

1292

(unsigned long)gre->limit << UV_GAM_RANGE_SHFT,

arch/x86/kernel/apic/x2apic_uv_x.c

1297

gend = (unsigned long)gre->limit << UV_GAM_RANGE_SHFT;

arch/x86/kernel/apic/x2apic_uv_x.c

1300

lgre = gre->limit;

arch/x86/kernel/apic/x2apic_uv_x.c

596

last_limit = gre->limit;

arch/x86/kernel/apic/x2apic_uv_x.c

600

last_limit = gre->limit;

arch/x86/kernel/apic/x2apic_uv_x.c

614

grt->limit = last_limit = gre->limit;

arch/x86/kernel/apic/x2apic_uv_x.c

622

if (grt->limit == last_limit) {

arch/x86/kernel/apic/x2apic_uv_x.c

623

grt->limit = last_limit = gre->limit;

arch/x86/kernel/apic/x2apic_uv_x.c

632

grt->limit = last_limit = gre->limit;

arch/x86/kernel/apic/x2apic_uv_x.c

640

grt->limit = last_limit = gre->limit;

arch/x86/kernel/apic/x2apic_uv_x.c

663

start = gb < 0 ? 0 : (unsigned long)_gr_table[gb].limit << UV_GAM_RANGE_SHFT;

arch/x86/kernel/apic/x2apic_uv_x.c

664

end = (unsigned long)grt->limit << UV_GAM_RANGE_SHFT;

arch/x86/kernel/head32.c

106

const unsigned long limit)

arch/x86/kernel/head32.c

108

while ((pte.pte & PTE_PFN_MASK) < limit) {

arch/x86/kernel/head32.c

131

unsigned long limit = __pa_nodebug(_end) + (PAGE_TABLE_SIZE(LOWMEM_PAGES) << PAGE_SHIFT);

arch/x86/kernel/head32.c

138

pte = init_map(pte, &ptep, &pl2p, limit);

arch/x86/kernel/head32.c

161

limit = (unsigned long)params->hdr.ramdisk_image;

arch/x86/kernel/head32.c

162

pte.pte = PTE_IDENT_ATTR | PFN_ALIGN(limit);

arch/x86/kernel/head32.c

163

limit = (unsigned long)params->hdr.ramdisk_image + params->hdr.ramdisk_size;

arch/x86/kernel/head32.c

165

init_map(pte, &ptep, &pl2p, limit);

arch/x86/kernel/ldt.c

604

if ((oldmode && !ldt_info.base_addr && !ldt_info.limit) ||

arch/x86/kernel/tls.c

203

info->limit = get_desc_limit(desc);

arch/x86/kvm/cpuid.c

1927

u32 limit;

arch/x86/kvm/cpuid.c

1939

limit = array->entries[array->nent - 1].eax;

arch/x86/kvm/cpuid.c

1940

for (func = func + 1; func <= limit; ++func) {

arch/x86/kvm/cpuid.c

226

cpuid.limit = entry->eax;

arch/x86/kvm/emulate.c

518

u32 limit = get_desc_limit(desc);

arch/x86/kvm/emulate.c

520

return desc->g ? (limit << 12) | 0xfff : limit;

arch/x86/kvm/smm.c

165

state->limit = seg.limit;

arch/x86/kvm/smm.c

179

state->limit = seg.limit;

arch/x86/kvm/smm.c

206

smram->gdtr.limit = dt.size;

arch/x86/kvm/smm.c

210

smram->idtr.limit = dt.size;

arch/x86/kvm/smm.c

255

smram->idtr.limit = dt.size;

arch/x86/kvm/smm.c

261

smram->gdtr.limit = dt.size;

arch/x86/kvm/smm.c

341

cs.limit = ds.limit = 0xffffffff;

arch/x86/kvm/smm.c

396

desc.limit = state->limit;

arch/x86/kvm/smm.c

412

desc.limit = state->limit;

arch/x86/kvm/smm.c

486

dt.size = smstate->gdtr.limit;

arch/x86/kvm/smm.c

490

dt.size = smstate->idtr.limit;

arch/x86/kvm/smm.c

541

dt.size = smstate->idtr.limit;

arch/x86/kvm/smm.c

547

dt.size = smstate->gdtr.limit;

arch/x86/kvm/smm.h

17

u32 limit;

arch/x86/kvm/smm.h

74

u32 limit;

arch/x86/kvm/svm/svm.c

1153

save->cs.limit = 0xffff;

arch/x86/kvm/svm/svm.c

1156

save->gdtr.limit = 0xffff;

arch/x86/kvm/svm/svm.c

1158

save->idtr.limit = 0xffff;

arch/x86/kvm/svm/svm.c

1583

var->limit = s->limit;

arch/x86/kvm/svm/svm.c

1601

var->g = s->limit > 0xfffff;

arch/x86/kvm/svm/svm.c

1666

dt->size = svm->vmcb->save.idtr.limit;

arch/x86/kvm/svm/svm.c

1674

svm->vmcb->save.idtr.limit = dt->size;

arch/x86/kvm/svm/svm.c

1683

dt->size = svm->vmcb->save.gdtr.limit;

arch/x86/kvm/svm/svm.c

1691

svm->vmcb->save.gdtr.limit = dt->size;

arch/x86/kvm/svm/svm.c

1808

s->limit = var->limit;

arch/x86/kvm/svm/svm.c

3384

save->es.limit, save->es.base);

arch/x86/kvm/svm/svm.c

3388

save->cs.limit, save->cs.base);

arch/x86/kvm/svm/svm.c

3392

save->ss.limit, save->ss.base);

arch/x86/kvm/svm/svm.c

3396

save->ds.limit, save->ds.base);

arch/x86/kvm/svm/svm.c

3400

save01->fs.limit, save01->fs.base);

arch/x86/kvm/svm/svm.c

3404

save01->gs.limit, save01->gs.base);

arch/x86/kvm/svm/svm.c

3408

save->gdtr.limit, save->gdtr.base);

arch/x86/kvm/svm/svm.c

3412

save01->ldtr.limit, save01->ldtr.base);

arch/x86/kvm/svm/svm.c

3416

save->idtr.limit, save->idtr.base);

arch/x86/kvm/svm/svm.c

3420

save01->tr.limit, save01->tr.base);

arch/x86/kvm/svm/svm.c

969

seg->limit = 0xffff;

arch/x86/kvm/svm/svm.c

977

seg->limit = 0xffff;

arch/x86/kvm/vmx/nested.c

4856

.limit = 0xFFFFFFFF,

arch/x86/kvm/vmx/nested.c

4870

.limit = 0xFFFFFFFF,

arch/x86/kvm/vmx/nested.c

4891

.limit = 0x67,

arch/x86/kvm/vmx/nested.c

5328

if (!(s.base == 0 && s.limit == 0xffffffff &&

arch/x86/kvm/vmx/nested.c

5330

exn = exn || ((u64)off + len - 1 > s.limit);

arch/x86/kvm/vmx/sgx.c

46

(*gva > s.limit) ||

arch/x86/kvm/vmx/sgx.c

47

((s.base != 0 || s.limit != 0xffffffff) &&

arch/x86/kvm/vmx/sgx.c

48

(((u64)*gva + size - 1) > s.limit + 1));

arch/x86/kvm/vmx/vmx.c

3241

var.limit = 0xffff;

arch/x86/kvm/vmx/vmx.c

3257

vmcs_write32(sf->limit, var.limit);

arch/x86/kvm/vmx/vmx.c

3722

var->limit = vmx_read_guest_seg_limit(vmx, seg);

arch/x86/kvm/vmx/vmx.c

3813

vmcs_write32(sf->limit, var->limit);

arch/x86/kvm/vmx/vmx.c

3885

if (var.limit != 0xffff)

arch/x86/kvm/vmx/vmx.c

4135

vmcs_write32(sf->limit, 0xffff);

arch/x86/kvm/vmx/vmx.c

600

.limit = GUEST_##seg##_LIMIT, \

arch/x86/kvm/vmx/vmx.c

607

unsigned limit;

arch/x86/kvm/vmx/vmx.c

6559

static void vmx_dump_dtsel(char *name, uint32_t limit)

arch/x86/kvm/vmx/vmx.c

6562

name, vmcs_read32(limit),

arch/x86/kvm/vmx/vmx.c

6563

vmcs_readl(limit + GUEST_GDTR_BASE - GUEST_GDTR_LIMIT));

arch/x86/kvm/vmx/vmx.c

911

u32 *p = &vmx->segment_cache.seg[seg].limit;

arch/x86/kvm/vmx/vmx.c

914

*p = vmcs_read32(kvm_vmx_segment_fields[seg].limit);

arch/x86/kvm/vmx/vmx.h

252

u32 limit;

arch/x86/kvm/x86.c

10851

unsigned int limit;

arch/x86/kvm/x86.c

10864

limit = 1;

arch/x86/kvm/x86.c

10866

limit = 2;

arch/x86/kvm/x86.c

10873

limit--;

arch/x86/kvm/x86.c

10876

vcpu->arch.nmi_pending = min(vcpu->arch.nmi_pending, limit);

arch/x86/kvm/x86.c

12150

sregs->idt.limit = dt.size;

arch/x86/kvm/x86.c

12153

sregs->gdt.limit = dt.size;

arch/x86/kvm/x86.c

12369

dt.size = sregs->idt.limit;

arch/x86/kvm/x86.c

12372

dt.size = sregs->gdt.limit;

arch/x86/kvm/x86.c

8662

var.limit >>= 12;

arch/x86/kvm/x86.c

8663

set_desc_limit(desc, var.limit);

arch/x86/kvm/x86.c

8693

var.limit = get_desc_limit(desc);

arch/x86/kvm/x86.c

8695

var.limit = (var.limit << 12) | 0xfff;

arch/x86/kvm/xen.h

57

function <= vcpu->arch.xen.cpuid.limit &&

arch/x86/lib/insn-eval.c

758

unsigned long limit;

arch/x86/lib/insn-eval.c

780

limit = get_desc_limit(&desc);

arch/x86/lib/insn-eval.c

782

limit = (limit << 12) + 0xfff;

arch/x86/lib/insn-eval.c

784

return limit;

arch/x86/lib/insn-eval.c

925

unsigned long *limit)

arch/x86/lib/insn-eval.c

940

if (!limit)

arch/x86/lib/insn-eval.c

943

*limit = get_seg_limit(regs, seg_reg_idx);

arch/x86/lib/insn-eval.c

944

if (!(*limit))

arch/x86/math-emu/get_address.c

141

unsigned long base_address, limit, address, seg_top;

arch/x86/math-emu/get_address.c

165

limit = seg_get_limit(&descriptor) + 1;

arch/x86/math-emu/get_address.c

166

limit *= seg_get_granularity(&descriptor);

arch/x86/math-emu/get_address.c

167

limit += base_address - 1;

arch/x86/math-emu/get_address.c

168

if (limit < base_address)

arch/x86/math-emu/get_address.c

169

limit = 0xffffffff;

arch/x86/math-emu/get_address.c

180

(address <= limit) || (address >= seg_top) ? 0 :

arch/x86/math-emu/get_address.c

184

(address > limit) || (address < base_address) ? 0 :

arch/x86/math-emu/get_address.c

185

((limit - address) >= 254 ? 255 : limit - address + 1);

arch/x86/mm/amdtopology.c

104

if ((base >> 8) & 3 || (limit >> 8) & 3) {

arch/x86/mm/amdtopology.c

106

nodeid, (base >> 8) & 3, (limit >> 8) & 3);

arch/x86/mm/amdtopology.c

115

limit >>= 16;

arch/x86/mm/amdtopology.c

116

limit++;

arch/x86/mm/amdtopology.c

117

limit <<= 24;

arch/x86/mm/amdtopology.c

119

if (limit > end)

arch/x86/mm/amdtopology.c

120

limit = end;

arch/x86/mm/amdtopology.c

121

if (limit <= base)

arch/x86/mm/amdtopology.c

129

if (limit > end)

arch/x86/mm/amdtopology.c

130

limit = end;

arch/x86/mm/amdtopology.c

131

if (limit == base) {

arch/x86/mm/amdtopology.c

135

if (limit < base) {

arch/x86/mm/amdtopology.c

137

nodeid, base, limit);

arch/x86/mm/amdtopology.c

149

nodeid, base, limit);

arch/x86/mm/amdtopology.c

152

numa_add_memblk(nodeid, base, limit);

arch/x86/mm/amdtopology.c

82

u64 base, limit;

arch/x86/mm/amdtopology.c

85

limit = read_pci_config(0, nb, 1, 0x44 + i*8);

arch/x86/mm/amdtopology.c

87

nodeids[i] = nodeid = limit & 7;

arch/x86/mm/amdtopology.c

95

base, limit);

arch/x86/mm/amdtopology.c

99

if (!limit) {

arch/x86/net/bpf_jit_comp.c

2255

u64 limit = TASK_SIZE_MAX + PAGE_SIZE - VSYSCALL_ADDR;

arch/x86/net/bpf_jit_comp.c

2276

emit_mov_imm64(&prog, BPF_REG_AX, (long)limit >> 32,

arch/x86/net/bpf_jit_comp.c

2277

(u32)(long)limit);

arch/x86/pci/amd_bus.c

360

u8 limit = amd_nb_bus_dev_ranges[i].dev_limit;

arch/x86/pci/amd_bus.c

362

for (; slot < limit; ++slot) {

arch/x86/pci/fixup.c

739

u32 base, limit, high;

arch/x86/pci/fixup.c

805

limit = ((res->end + 1) >> 8) & AMD_141b_MMIO_LIMIT_MMIOLIMIT_MASK;

arch/x86/pci/fixup.c

811

pci_write_config_dword(dev, AMD_141b_MMIO_LIMIT(i), limit);

arch/x86/pci/irq.c

127

u8 *limit)

arch/x86/pci/irq.c

140

if (size > limit - addr)

arch/x86/pci/irq.c

74

u8 *limit)

arch/x86/pci/irq.c

85

(limit && rt->size > limit - addr))

arch/x86/pci/numachip.c

121

limit = PCI_DEVFN(0x18 + ((val >> 4) & 7) + 1, 0);

arch/x86/pci/numachip.c

17

static u8 limit __read_mostly;

arch/x86/pci/numachip.c

40

if (unlikely(bus == 0 && devfn >= limit)) {

arch/x86/pci/numachip.c

78

if (unlikely(bus == 0 && devfn >= limit))

arch/x86/platform/uv/uv_irq.c

182

unsigned long mmr_offset, int limit)

arch/x86/platform/uv/uv_irq.c

192

info.uv.limit = limit;

arch/x86/platform/uv/uv_irq.c

93

if (info->uv.limit == UV_AFFINITY_CPU)

arch/x86/um/asm/desc.h

9

(info)->limit == 0 && \

arch/x86/um/shared/sysdep/tls.h

14

unsigned int limit;

arch/x86/xen/mmu_pv.c

2269

unsigned i, limit;

arch/x86/xen/mmu_pv.c

2274

limit = 1u << order;

arch/x86/xen/mmu_pv.c

2275

for (i = 0; i < limit; i++, vaddr += PAGE_SIZE) {

arch/x86/xen/mmu_pv.c

2285

if (i < (limit - 1))

arch/x86/xen/mmu_pv.c

604

bool last, unsigned long limit)

arch/x86/xen/mmu_pv.c

608

nr = last ? pmd_index(limit) + 1 : PTRS_PER_PMD;

arch/x86/xen/mmu_pv.c

618

bool last, unsigned long limit)

arch/x86/xen/mmu_pv.c

622

nr = last ? pud_index(limit) + 1 : PTRS_PER_PUD;

arch/x86/xen/mmu_pv.c

632

xen_pmd_walk(mm, pmd, func, last && i == nr - 1, limit);

arch/x86/xen/mmu_pv.c

639

bool last, unsigned long limit)

arch/x86/xen/mmu_pv.c

650

xen_pud_walk(mm, pud, func, last, limit);

arch/x86/xen/mmu_pv.c

668

unsigned long limit)

arch/x86/xen/mmu_pv.c

674

limit--;

arch/x86/xen/mmu_pv.c

675

BUG_ON(limit >= FIXADDR_TOP);

arch/x86/xen/mmu_pv.c

684

nr = pgd_index(limit) + 1;

arch/x86/xen/mmu_pv.c

695

xen_p4d_walk(mm, p4d, func, i == nr - 1, limit);

arch/x86/xen/mmu_pv.c

706

unsigned long limit)

arch/x86/xen/mmu_pv.c

708

__xen_pgd_walk(mm, mm->pgd, func, limit);

arch/x86/xen/setup.c

501

unsigned long limit;

arch/x86/xen/setup.c

503

limit = MAXMEM / PAGE_SIZE;

arch/x86/xen/setup.c

505

limit = GB(512) / PAGE_SIZE;

arch/x86/xen/setup.c

507

return limit;

arch/x86/xen/setup.c

512

unsigned long max_pages, limit;

arch/x86/xen/setup.c

516

limit = xen_get_pages_limit();

arch/x86/xen/setup.c

517

max_pages = limit;

arch/x86/xen/setup.c

534

return min(max_pages, limit);

block/bfq-iosched.c

4653

unsigned int limit = in_serv_bfqq->inject_limit;

block/bfq-iosched.c

4680

if (limit == 0 && in_serv_bfqq->last_serv_time_ns == 0 &&

block/bfq-iosched.c

4685

limit = 1;

block/bfq-iosched.c

4687

if (bfqd->tot_rq_in_driver >= limit)

block/bfq-iosched.c

580

unsigned int act_idx, int limit)

block/bfq-iosched.c

654

limit = DIV_ROUND_CLOSEST(limit * entity->weight, wsum);

block/bfq-iosched.c

655

if (entity->allocated >= limit) {

block/bfq-iosched.c

658

entity->allocated, limit, level);

block/bfq-iosched.c

672

unsigned int act_idx, int limit)

block/bfq-iosched.c

697

unsigned int limit, act_idx;

block/bfq-iosched.c

701

limit = data->q->nr_requests;

block/bfq-iosched.c

703

limit = bfqd->async_depths[!!bfqd->wr_busy_queues][op_is_sync(opf)];

block/bfq-iosched.c

716

if (bfqq_request_over_limit(bfqd, bic, opf, act_idx, limit)) {

block/bfq-iosched.c

717

limit = 1;

block/bfq-iosched.c

723

__func__, bfqd->wr_busy_queues, op_is_sync(opf), limit);

block/bfq-iosched.c

725

if (limit < data->q->nr_requests)

block/bfq-iosched.c

726

data->shallow_depth = limit;

block/blk-lib.c

121

struct bio **biop, unsigned flags, sector_t limit)

block/blk-lib.c

125

unsigned int len = min(nr_sects, limit);

block/blk-lib.c

149

sector_t limit = bio_write_zeroes_limit(bdev);

block/blk-lib.c

156

flags, limit);

block/blk-lib.c

264

sector_t limit = bio_write_zeroes_limit(bdev);

block/blk-lib.c

269

if (limit) {

block/blk-lib.c

271

gfp_mask, biop, flags, limit);

block/blk-rq-qos.c

21

bool rq_wait_inc_below(struct rq_wait *rq_wait, unsigned int limit)

block/blk-rq-qos.c

23

return atomic_inc_below(&rq_wait->inflight, limit);

block/blk-rq-qos.h

98

bool rq_wait_inc_below(struct rq_wait *rq_wait, unsigned int limit);

block/blk-wbt.c

201

int inflight, limit;

block/blk-wbt.c

211

limit = rwb->wb_background;

block/blk-wbt.c

214

limit = 0;

block/blk-wbt.c

216

limit = rwb->wb_normal;

block/blk-wbt.c

221

if (inflight && inflight >= limit)

block/blk-wbt.c

225

int diff = limit - inflight;

block/blk-wbt.c

539

unsigned int limit;

block/blk-wbt.c

553

limit = rwb->rq_depth.max_depth;

block/blk-wbt.c

559

limit = rwb->wb_background;

block/blk-wbt.c

561

limit = rwb->wb_normal;

block/blk-wbt.c

563

return limit;

block/partitions/acorn.c

140

if (slot == state->limit)

block/partitions/acorn.c

186

if (slot == state->limit)

block/partitions/acorn.c

371

if (slot == state->limit)

block/partitions/aix.c

200

lvip = kzalloc_objs(struct lv_info, state->limit);

block/partitions/aix.c

211

for (i = 0; foundlvs < numlvs && i < state->limit; i += 1) {

block/partitions/aix.c

239

if (lv_ix >= state->limit) {

block/partitions/aix.c

263

for (i = 0; i < state->limit; i += 1)

block/partitions/atari.c

126

if (++slot == state->limit) {

block/partitions/atari.c

139

for (; pi < &rs->icdpart[8] && slot < state->limit; slot++, pi++) {

block/partitions/atari.c

74

for (slot = 1; pi < &rs->part[4] && slot < state->limit; slot++, pi++) {

block/partitions/check.h

22

int limit;

block/partitions/check.h

40

if (n < p->limit) {

block/partitions/cmdline.c

233

if (slot >= state->limit)

block/partitions/cmdline.c

321

for (; slot < state->limit && state->parts[slot].has_info; slot++) {

block/partitions/cmdline.c

322

for (i = slot+1; i < state->limit && state->parts[i].has_info;

block/partitions/core.c

108

state->limit = nr;

block/partitions/core.c

142

memset(state->parts, 0, state->limit * sizeof(state->parts[0]));

block/partitions/core.c

634

for (p = 1; p < state->limit; p++)

block/partitions/efi.c

727

for (i = 0; i < le32_to_cpu(gpt->num_partition_entries) && i < state->limit-1; i++) {

block/partitions/ibm.c

213

if (counter >= state->limit)

block/partitions/karma.c

47

if (slot == state->limit)

block/partitions/mac.c

86

if (blocks_in_map >= state->limit)

block/partitions/mac.c

87

blocks_in_map = state->limit - 1;

block/partitions/msdos.c

150

if (state->next == state->limit)

block/partitions/msdos.c

198

if (++state->next == state->limit)

block/partitions/msdos.c

276

for (i = 0; i < max_nparts && state->next < state->limit; i++) {

block/partitions/msdos.c

369

if (state->next == state->limit)

block/partitions/msdos.c

490

if (state->next == state->limit)

block/partitions/msdos.c

533

if (state->next == state->limit)

block/partitions/of.c

95

if (slot >= state->limit) {

block/partitions/osf.c

76

if (slot == state->limit)

block/partitions/sysv68.c

79

if (slot == state->limit)

crypto/crypto_engine.c

392

unsigned int limit = 500;

crypto/crypto_engine.c

401

while ((crypto_queue_len(&engine->queue) || engine->busy) && limit--) {

crypto/krb5/selftest.c

41

static void dump_sg(struct scatterlist *sg, unsigned int limit)

crypto/krb5/selftest.c

45

for (; sg && limit > 0; sg = sg_next(sg)) {

crypto/krb5/selftest.c

46

unsigned int off = sg->offset, len = umin(sg->length, limit);

crypto/krb5/selftest.c

49

limit -= len;

crypto/scatterwalk.c

124

const unsigned int limit = PAGE_SIZE;

crypto/scatterwalk.c

127

len = min3(len, limit - src_oip, limit - dst_oip);

crypto/tea.c

127

u32 limit = XTEA_DELTA * XTEA_ROUNDS;

crypto/tea.c

133

while (sum != limit) {

crypto/tea.c

167

u32 limit = XTEA_DELTA * XTEA_ROUNDS;

crypto/tea.c

173

while (sum != limit) {

drivers/accel/habanalabs/common/firmware_if.c

1607

u32 ver_off, limit;

drivers/accel/habanalabs/common/firmware_if.c

1618

limit = static_loader->boot_fit_version_max_off;

drivers/accel/habanalabs/common/firmware_if.c

1624

limit = static_loader->preboot_version_max_off;

drivers/accel/habanalabs/common/firmware_if.c

1633

if (ver_off < limit) {

drivers/acpi/arm64/iort.c

1497

static int nc_dma_get_range(struct device *dev, u64 *limit)

drivers/acpi/arm64/iort.c

1514

*limit = ncomp->memory_address_limit >= 64 ? U64_MAX :

drivers/acpi/arm64/iort.c

1520

static int rc_dma_get_range(struct device *dev, u64 *limit)

drivers/acpi/arm64/iort.c

1538

*limit = rc->memory_address_limit >= 64 ? U64_MAX :

drivers/acpi/arm64/iort.c

1551

int iort_dma_get_ranges(struct device *dev, u64 *limit)

drivers/acpi/arm64/iort.c

1554

return rc_dma_get_range(dev, limit);

drivers/acpi/arm64/iort.c

1556

return nc_dma_get_range(dev, limit);

drivers/acpi/arm64/iort.c

2122

phys_addr_t limit = PHYS_ADDR_MAX;

drivers/acpi/arm64/iort.c

2129

return limit;

drivers/acpi/arm64/iort.c

2134

return limit;

drivers/acpi/arm64/iort.c

2151

limit = min_not_zero(limit, local_limit);

drivers/acpi/arm64/iort.c

2160

limit = min_not_zero(limit, local_limit);

drivers/acpi/arm64/iort.c

2166

return limit;

drivers/acpi/processor_driver.c

150

pr->flags.limit = 1;

drivers/acpi/processor_perflib.c

152

int acpi_processor_get_bios_limit(int cpu, unsigned int *limit)

drivers/acpi/processor_perflib.c

160

*limit = pr->performance->states[pr->performance_platform_limit].

drivers/acpi/processor_throttling.c

230

p_limit = &pr->limit;

drivers/acpi/processor_throttling.c

296

struct acpi_processor_limit *limit;

drivers/acpi/processor_throttling.c

323

limit = &pr->limit;

drivers/acpi/processor_throttling.c

325

if (limit->thermal.tx > target_state)

drivers/acpi/processor_throttling.c

326

target_state = limit->thermal.tx;

drivers/acpi/processor_throttling.c

327

if (limit->user.tx > target_state)

drivers/acpi/processor_throttling.c

328

target_state = limit->user.tx;

drivers/ata/libata-sata.c

442

u32 limit, target, spd;

drivers/ata/libata-sata.c

444

limit = link->sata_spd_limit;

drivers/ata/libata-sata.c

451

limit &= (1 << host_link->sata_spd) - 1;

drivers/ata/libata-sata.c

453

if (limit == UINT_MAX)

drivers/ata/libata-sata.c

456

target = fls(limit);

drivers/ata/libata-scsi.c

2492

u32 limit = get_unaligned_le32(buf);

drivers/ata/libata-scsi.c

2494

return min_t(u32, limit / 10000, 65535);

drivers/ata/pata_amd.c

277

unsigned int bios_limit = 0, acpi_limit = 0, limit;

drivers/ata/pata_amd.c

300

limit = bios_limit | acpi_limit;

drivers/ata/pata_amd.c

305

if (!(limit & ATA_MASK_PIO))

drivers/ata/pata_amd.c

306

limit |= ATA_MASK_PIO;

drivers/ata/pata_amd.c

307

if (!(limit & (ATA_MASK_MWDMA | ATA_MASK_UDMA)))

drivers/ata/pata_amd.c

308

limit |= ATA_MASK_MWDMA | ATA_MASK_UDMA;

drivers/ata/pata_amd.c

311

limit |= ata_pack_xfermask(ATA_PIO4, ATA_MWDMA2, ATA_UDMA2);

drivers/ata/pata_amd.c

315

xfer_mask, limit, xfer_mask & limit, bios_limit,

drivers/ata/pata_amd.c

318

return xfer_mask & limit;

drivers/block/rnbd/rnbd-clt.c

952

struct queue_limits *limit = &dev->queue->limits;

drivers/block/rnbd/rnbd-clt.c

954

size = dev->size * (limit->logical_block_size / SECTOR_SIZE);

drivers/block/zram/zram_drv.c

386

u64 limit;

drivers/block/zram/zram_drv.c

390

limit = memparse(buf, &tmp);

drivers/block/zram/zram_drv.c

395

zram->limit_pages = PAGE_ALIGN(limit) >> PAGE_SHIFT;

drivers/char/hw_random/n2-drv.c

525

int err, matches, limit;

drivers/char/hw_random/n2-drv.c

540

for (limit = 0; limit < SELFTEST_LOOPS_MAX; limit++) {

drivers/char/hw_random/n2-drv.c

548

if (limit >= SELFTEST_LOOPS_MAX) {

drivers/char/tpm/eventlog/tpm1.c

114

void *limit = log->bios_event_log_end;

drivers/char/tpm/eventlog/tpm1.c

124

if ((v + sizeof(struct tcpa_event)) > limit)

drivers/char/tpm/eventlog/tpm1.c

133

((v + sizeof(struct tcpa_event) + converted_event_size) > limit))

drivers/char/tpm/eventlog/tpm1.c

76

void *limit = log->bios_event_log_end;

drivers/char/tpm/eventlog/tpm1.c

86

if (addr + sizeof(struct tcpa_event) > limit)

drivers/char/tpm/eventlog/tpm1.c

96

> limit))

drivers/char/tpm/eventlog/tpm2.c

112

if (marker >= limit)

drivers/char/tpm/eventlog/tpm2.c

118

if (((v + event_size) >= limit) || (event_size == 0))

drivers/char/tpm/eventlog/tpm2.c

47

void *limit = log->bios_event_log_end;

drivers/char/tpm/eventlog/tpm2.c

57

if (addr + size < limit) {

drivers/char/tpm/eventlog/tpm2.c

69

if ((addr + size >= limit) || (size == 0))

drivers/char/tpm/eventlog/tpm2.c

77

if ((addr + size >= limit) || (size == 0))

drivers/char/tpm/eventlog/tpm2.c

92

void *limit = log->bios_event_log_end;

drivers/char/tpm/tpm_tis_i2c_cr50.c

559

size_t burstcnt, limit, sent = 0;

drivers/char/tpm/tpm_tis_i2c_cr50.c

592

limit = min_t(size_t, burstcnt - 1, len);

drivers/char/tpm/tpm_tis_i2c_cr50.c

594

&buf[sent], limit);

drivers/char/tpm/tpm_tis_i2c_cr50.c

600

sent += limit;

drivers/char/tpm/tpm_tis_i2c_cr50.c

601

len -= limit;

drivers/clk/bcm/clk-bcm2835.c

1007

unsigned long limit;

drivers/clk/bcm/clk-bcm2835.c

1009

limit = rate / 100000;

drivers/clk/bcm/clk-bcm2835.c

1012

while (scaler < limit)

drivers/clk/bcm/clk-kona-setup.c

102

if (gate->offset > limit) {

drivers/clk/bcm/clk-kona-setup.c

104

__func__, name, gate->offset, limit);

drivers/clk/bcm/clk-kona-setup.c

109

if (hyst->offset > limit) {

drivers/clk/bcm/clk-kona-setup.c

112

name, hyst->offset, limit);

drivers/clk/bcm/clk-kona-setup.c

123

if (div->u.s.offset > limit) {

drivers/clk/bcm/clk-kona-setup.c

125

__func__, name, div->u.s.offset, limit);

drivers/clk/bcm/clk-kona-setup.c

132

if (div->u.s.offset > limit) {

drivers/clk/bcm/clk-kona-setup.c

135

__func__, name, div->u.s.offset, limit);

drivers/clk/bcm/clk-kona-setup.c

142

if (sel->offset > limit) {

drivers/clk/bcm/clk-kona-setup.c

144

__func__, name, sel->offset, limit);

drivers/clk/bcm/clk-kona-setup.c

151

if (trig->offset > limit) {

drivers/clk/bcm/clk-kona-setup.c

153

__func__, name, trig->offset, limit);

drivers/clk/bcm/clk-kona-setup.c

160

if (trig->offset > limit) {

drivers/clk/bcm/clk-kona-setup.c

162

__func__, name, trig->offset, limit);

drivers/clk/bcm/clk-kona-setup.c

174

u32 limit = BITS_PER_BYTE * sizeof(u32) - 1;

drivers/clk/bcm/clk-kona-setup.c

176

if (bit_posn > limit) {

drivers/clk/bcm/clk-kona-setup.c

178

field_name, clock_name, bit_posn, limit);

drivers/clk/bcm/clk-kona-setup.c

194

u32 limit = BITS_PER_BYTE * sizeof(u32);

drivers/clk/bcm/clk-kona-setup.c

201

if (shift + width > limit) {

drivers/clk/bcm/clk-kona-setup.c

203

field_name, clock_name, shift, width, limit);

drivers/clk/bcm/clk-kona-setup.c

21

u32 limit;

drivers/clk/bcm/clk-kona-setup.c

23

limit = ccu->range - sizeof(u32);

drivers/clk/bcm/clk-kona-setup.c

24

limit = round_down(limit, sizeof(u32));

drivers/clk/bcm/clk-kona-setup.c

26

if (ccu_policy->enable.offset > limit) {

drivers/clk/bcm/clk-kona-setup.c

29

ccu->name, ccu_policy->enable.offset, limit);

drivers/clk/bcm/clk-kona-setup.c

291

u32 limit;

drivers/clk/bcm/clk-kona-setup.c

302

limit = (1 << sel->width) - 1;

drivers/clk/bcm/clk-kona-setup.c

303

if (max_sel > limit) {

drivers/clk/bcm/clk-kona-setup.c

32

if (ccu_policy->control.offset > limit) {

drivers/clk/bcm/clk-kona-setup.c

35

ccu->name, ccu_policy->control.offset, limit);

drivers/clk/bcm/clk-kona-setup.c

365

u32 limit;

drivers/clk/bcm/clk-kona-setup.c

377

limit = BITS_PER_BYTE * sizeof(u32);

drivers/clk/bcm/clk-kona-setup.c

379

return div->u.s.frac_width + pre_div->u.s.frac_width <= limit;

drivers/clk/bcm/clk-kona-setup.c

80

u32 limit;

drivers/clk/bcm/clk-kona-setup.c

87

limit = range - sizeof(u32);

drivers/clk/bcm/clk-kona-setup.c

88

limit = round_down(limit, sizeof(u32));

drivers/clk/bcm/clk-kona-setup.c

92

if (policy->offset > limit) {

drivers/clk/bcm/clk-kona-setup.c

94

__func__, name, policy->offset, limit);

drivers/clk/sophgo/clk-cv18xx-pll.c

101

const struct cv1800_clk_pll_limit *limit,

drivers/clk/sophgo/clk-cv18xx-pll.c

107

for_each_pll_limit_range(mode, &limit->mode) {

drivers/clk/sophgo/clk-cv18xx-pll.c

108

for_each_pll_limit_range(ictrl, &limit->ictrl) {

drivers/clk/sophgo/clk-cv18xx-pll.c

283

const struct cv1800_clk_pll_limit *limit,

drivers/clk/sophgo/clk-cv18xx-pll.c

297

for_each_pll_limit_range(pre, &limit->pre_div) {

drivers/clk/sophgo/clk-cv18xx-pll.c

298

for_each_pll_limit_range(post, &limit->post_div) {

drivers/clk/sophgo/clk-cv18xx-pll.c

299

for_each_pll_limit_range(div, &limit->div) {

drivers/clk/sophgo/clk-cv18xx-pll.c

47

static int ipll_find_rate(const struct cv1800_clk_pll_limit *limit,

drivers/clk/sophgo/clk-cv18xx-pll.c

58

for_each_pll_limit_range(pre, &limit->pre_div) {

drivers/clk/sophgo/clk-cv18xx-pll.c

59

for_each_pll_limit_range(div, &limit->div) {

drivers/clk/sophgo/clk-cv18xx-pll.c

60

for_each_pll_limit_range(post, &limit->post_div) {

drivers/clk/sophgo/clk-sg2044-pll.c

105

const struct sg2044_pll_limit *limit)

drivers/clk/sophgo/clk-sg2044-pll.c

107

return value >= limit->min && value <= limit->max;

drivers/comedi/drivers/comedi_test.c

259

unsigned int arg, limit;

drivers/comedi/drivers/comedi_test.c

329

limit = UINT_MAX / cmd->scan_end_arg;

drivers/comedi/drivers/comedi_test.c

330

limit = rounddown(limit, (unsigned int)NSEC_PER_SEC);

drivers/comedi/drivers/comedi_test.c

331

arg = min(arg, limit);

drivers/comedi/drivers/rtd520.c

485

static const unsigned int limit = 0x2000;

drivers/comedi/drivers/rtd520.c

493

for (i = 0; i < limit; ++i) {

drivers/comedi/drivers/rtd520.c

504

if (i == limit) {

drivers/cpufreq/cpufreq.c

950

unsigned int limit;

drivers/cpufreq/cpufreq.c

952

ret = cpufreq_driver->bios_limit(policy->cpu, &limit);

drivers/cpufreq/cpufreq.c

954

return sysfs_emit(buf, "%u\n", limit);

drivers/cpufreq/e_powersaver.c

187

unsigned int limit;

drivers/cpufreq/e_powersaver.c

288

if (!acpi_processor_get_bios_limit(policy->cpu, &limit)) {

drivers/cpufreq/e_powersaver.c

290

limit/1000000,

drivers/cpufreq/e_powersaver.c

291

(limit%1000000)/10000);

drivers/cpufreq/e_powersaver.c

294

if (limit && max_multiplier * fsb > limit) {

drivers/cpufreq/e_powersaver.c

331

centaur->bios_limit = limit;

drivers/cpuidle/poll_state.c

29

u64 limit;

drivers/cpuidle/poll_state.c

31

limit = cpuidle_poll_time(drv, dev);

drivers/cpuidle/poll_state.c

39

if (local_clock_noinstr() - time_start > limit) {

drivers/dpll/zl3073x/devlink.c

104

enum devlink_reload_limit limit,

drivers/dpll/zl3073x/devlink.c

87

enum devlink_reload_limit limit,

drivers/edac/altera_edac.c

917

int limit = ALTR_A10_ECC_INIT_WATCHDOG_10US;

drivers/edac/altera_edac.c

932

while (limit--) {

drivers/edac/altera_edac.c

938

if (limit < 0)

drivers/edac/i5000_edac.c

1136

u16 limit;

drivers/edac/i5000_edac.c

1165

limit = (pvt->mir0 >> 4) & 0x0FFF;

drivers/edac/i5000_edac.c

1169

limit, way1, way0);

drivers/edac/i5000_edac.c

1170

limit = (pvt->mir1 >> 4) & 0x0FFF;

drivers/edac/i5000_edac.c

1174

limit, way1, way0);

drivers/edac/i5000_edac.c

1175

limit = (pvt->mir2 >> 4) & 0x0FFF;

drivers/edac/i5000_edac.c

1179

limit, way1, way0);

drivers/edac/i5100_edac.c

308

u64 limit;

drivers/edac/i5100_edac.c

318

u64 limit;

drivers/edac/i5100_edac.c

802

priv->mir[0].limit = (u64) i5100_mir_limit(w) << 28;

drivers/edac/i5100_edac.c

807

priv->mir[1].limit = (u64) i5100_mir_limit(w) << 28;

drivers/edac/i5100_edac.c

824

priv->dmir[i][j].limit =

drivers/edac/i5400_edac.c

1057

u16 limit;

drivers/edac/i5400_edac.c

1085

limit = (pvt->mir0 >> 4) & 0x0fff;

drivers/edac/i5400_edac.c

1089

limit, way1, way0);

drivers/edac/i5400_edac.c

1090

limit = (pvt->mir1 >> 4) & 0xfff;

drivers/edac/i5400_edac.c

1094

limit, way1, way0);

drivers/edac/i7core_edac.c

799

#define DECLARE_ADDR_MATCH(param, limit) \

drivers/edac/i7core_edac.c

820

if ((rc < 0) || (value >= limit)) \

drivers/edac/pnd2_edac.c

318

static void mk_region(char *name, struct region *rp, u64 base, u64 limit)

drivers/edac/pnd2_edac.c

322

rp->limit = limit;

drivers/edac/pnd2_edac.c

323

edac_dbg(2, "Region:%s [%llx, %llx]\n", name, base, limit);

drivers/edac/pnd2_edac.c

341

rp->limit = (base | ~mask) & GENMASK_ULL(PND_MAX_PHYS_BIT, 0);

drivers/edac/pnd2_edac.c

343

edac_dbg(2, "Region:%s [%llx, %llx]\n", name, base, rp->limit);

drivers/edac/pnd2_edac.c

351

return rp->base <= addr && addr <= rp->limit;

drivers/edac/pnd2_edac.c

80

u64 limit;

drivers/edac/sb_edac.c

1157

u64 *limit,

drivers/edac/sb_edac.c

1205

*limit = ((u64) GET_BITFIELD(reg_limit_lo, 6, 31) << 6) | 63 |

drivers/edac/sb_edac.c

1771

u64 limit, prv = 0;

drivers/edac/sb_edac.c

1806

limit = pvt->info.sad_limit(reg);

drivers/edac/sb_edac.c

1811

if (limit <= prv)

drivers/edac/sb_edac.c

1814

tmp_mb = (limit + 1) >> 20;

drivers/edac/sb_edac.c

1823

prv = limit;

drivers/edac/sb_edac.c

1847

limit = TAD_LIMIT(reg);

drivers/edac/sb_edac.c

1848

if (limit <= prv)

drivers/edac/sb_edac.c

1850

tmp_mb = (limit + 1) >> 20;

drivers/edac/sb_edac.c

1863

prv = limit;

drivers/edac/sb_edac.c

2051

u64 ch_addr, offset, limit = 0, prv = 0;

drivers/edac/sb_edac.c

2081

limit = pvt->info.sad_limit(reg);

drivers/edac/sb_edac.c

2082

if (limit <= prv) {

drivers/edac/sb_edac.c

2086

if (addr <= limit)

drivers/edac/sb_edac.c

2088

prv = limit;

drivers/edac/sb_edac.c

2115

limit,

drivers/edac/sb_edac.c

2202

limit = TAD_LIMIT(reg);

drivers/edac/sb_edac.c

2203

if (limit <= prv) {

drivers/edac/sb_edac.c

2207

if (addr <= limit)

drivers/edac/sb_edac.c

2209

prv = limit;

drivers/edac/sb_edac.c

2279

limit,

drivers/edac/sb_edac.c

2311

limit = pvt->info.rir_limit(reg);

drivers/edac/sb_edac.c

2312

gb = div_u64_rem(limit >> 20, 1024, &mb);

drivers/edac/sb_edac.c

2316

limit,

drivers/edac/sb_edac.c

2318

if (ch_addr <= limit)

drivers/edac/sb_edac.c

2362

limit,

drivers/edac/skx_base.c

275

u64 limit, prev_limit;

drivers/edac/skx_base.c

288

limit = SKX_SAD_LIMIT(sad);

drivers/edac/skx_base.c

290

if (addr >= prev_limit && addr <= limit)

drivers/edac/skx_base.c

293

prev_limit = limit + 1;

drivers/edac/skx_base.c

473

u64 rank_addr, prev_limit = 0, limit;

drivers/edac/skx_base.c

482

limit = SKX_RIR_LIMIT(rirway);

drivers/edac/skx_base.c

485

res->chan_addr <= limit)

drivers/edac/skx_base.c

488

prev_limit = limit;

drivers/firmware/efi/efi.c

291

int limit;

drivers/firmware/efi/efi.c

307

limit = min(EFIVAR_SSDT_NAME_MAX, name_size);

drivers/firmware/efi/efi.c

308

ucs2_as_utf8(utf8_name, name, limit - 1);

drivers/firmware/efi/efi.c

309

if (strncmp(utf8_name, efivar_ssdt, limit) != 0)

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

185

u16 limit;

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

190

limit = 0;

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

192

limit = quirks->max_read_len;

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

194

limit = quirks->max_write_len;

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

196

if (limit == 0) {

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

199

} else if (limit <= EEPROM_OFFSET_SIZE) {

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

211

limit -= EEPROM_OFFSET_SIZE;

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

214

ps = min(limit, buf_size);

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

217

uint64_t limit = (uint64_t)amdgpu_vram_limit << 20;

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

221

if (limit < mc->real_vram_size)

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

222

mc->real_vram_size = limit;

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

116

uint64_t limit = base + alternate_aperture_size - 1;

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

118

if (limit <= base || (base & APE1_FIXED_BITS_MASK) != 0 ||

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

119

(limit & APE1_FIXED_BITS_MASK) != APE1_LIMIT_ALIGNMENT) {

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

125

qpd->sh_mem_ape1_limit = limit >> 16;

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

117

uint64_t limit = base + alternate_aperture_size - 1;

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

119

if (limit <= base || (base & APE1_FIXED_BITS_MASK) != 0 ||

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

120

(limit & APE1_FIXED_BITS_MASK) != APE1_LIMIT_ALIGNMENT) {

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

126

qpd->sh_mem_ape1_limit = limit >> 16;

drivers/gpu/drm/amd/display/dc/core/dc_state.c

1003

bool limit = false;

drivers/gpu/drm/amd/display/dc/core/dc_state.c

1010

limit = stream_status->mall_stream_config.subvp_limit_cursor_size;

drivers/gpu/drm/amd/display/dc/core/dc_state.c

1013

return limit;

drivers/gpu/drm/amd/display/dc/core/dc_state.c

1018

bool limit)

drivers/gpu/drm/amd/display/dc/core/dc_state.c

1025

stream_status->mall_stream_config.cursor_size_limit_subvp = limit;

drivers/gpu/drm/amd/display/dc/core/dc_state.c

1032

bool limit = false;

drivers/gpu/drm/amd/display/dc/core/dc_state.c

1039

limit = stream_status->mall_stream_config.cursor_size_limit_subvp;

drivers/gpu/drm/amd/display/dc/core/dc_state.c

1042

return limit;

drivers/gpu/drm/amd/display/dc/core/dc_state.c

989

bool limit)

drivers/gpu/drm/amd/display/dc/core/dc_state.c

996

stream_status->mall_stream_config.subvp_limit_cursor_size = limit;

drivers/gpu/drm/amd/display/dc/dc_dsc.h

112

void dc_dsc_policy_set_max_target_bpp_limit(uint32_t limit);

drivers/gpu/drm/amd/display/dc/dc_state_priv.h

111

bool limit);

drivers/gpu/drm/amd/display/dc/dc_state_priv.h

118

bool limit);

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_pmo/dml2_pmo_dcn3.c

66

static bool increase_mpc_combine_factor(unsigned int *mpc_combine_factor, unsigned int limit)

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_pmo/dml2_pmo_dcn3.c

68

if (*mpc_combine_factor < limit) {

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_pmo/dml2_pmo_dcn4_fams2.c

221

static bool increase_mpc_combine_factor(unsigned int *mpc_combine_factor, unsigned int limit)

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_pmo/dml2_pmo_dcn4_fams2.c

223

if (*mpc_combine_factor < limit) {

drivers/gpu/drm/amd/display/dc/dsc/dc_dsc.c

1432

void dc_dsc_policy_set_max_target_bpp_limit(uint32_t limit)

drivers/gpu/drm/amd/display/dc/dsc/dc_dsc.c

1434

dsc_policy_max_target_bpp_limit = limit;

drivers/gpu/drm/amd/display/dc/inc/hw/timing_generator.h

497

uint32_t limit);

drivers/gpu/drm/amd/display/dc/optc/dcn30/dcn30_optc.c

169

uint32_t limit)

drivers/gpu/drm/amd/display/dc/optc/dcn30/dcn30_optc.c

175

OTG_DRR_V_TOTAL_CHANGE_LIMIT, limit);

drivers/gpu/drm/amd/display/dc/optc/dcn30/dcn30_optc.h

349

uint32_t limit);

drivers/gpu/drm/amd/include/kgd_pp_interface.h

437

int (*get_apu_thermal_limit)(void *handle, uint32_t *limit);

drivers/gpu/drm/amd/include/kgd_pp_interface.h

438

int (*set_apu_thermal_limit)(void *handle, uint32_t limit);

drivers/gpu/drm/amd/include/kgd_pp_interface.h

461

int (*get_power_limit)(void *handle, uint32_t *limit,

drivers/gpu/drm/amd/pm/amdgpu_dpm.c

1565

uint32_t *limit,

drivers/gpu/drm/amd/pm/amdgpu_dpm.c

1577

limit,

drivers/gpu/drm/amd/pm/amdgpu_dpm.c

1587

uint32_t limit)

drivers/gpu/drm/amd/pm/amdgpu_dpm.c

1597

limit_type, limit);

drivers/gpu/drm/amd/pm/amdgpu_dpm.c

538

int amdgpu_dpm_get_apu_thermal_limit(struct amdgpu_device *adev, uint32_t *limit)

drivers/gpu/drm/amd/pm/amdgpu_dpm.c

545

ret = pp_funcs->get_apu_thermal_limit(adev->powerplay.pp_handle, limit);

drivers/gpu/drm/amd/pm/amdgpu_dpm.c

552

int amdgpu_dpm_set_apu_thermal_limit(struct amdgpu_device *adev, uint32_t limit)

drivers/gpu/drm/amd/pm/amdgpu_dpm.c

559

ret = pp_funcs->set_apu_thermal_limit(adev->powerplay.pp_handle, limit);

drivers/gpu/drm/amd/pm/amdgpu_pm.c

1644

u32 limit;

drivers/gpu/drm/amd/pm/amdgpu_pm.c

1652

ret = amdgpu_dpm_get_apu_thermal_limit(adev, &limit);

drivers/gpu/drm/amd/pm/amdgpu_pm.c

1654

size = sysfs_emit(buf, "%u\n", limit);

drivers/gpu/drm/amd/pm/amdgpu_pm.c

2680

u32 limit;

drivers/gpu/drm/amd/pm/amdgpu_pm.c

2682

if (amdgpu_dpm_get_apu_thermal_limit(adev, &limit) ==

drivers/gpu/drm/amd/pm/amdgpu_pm.c

3364

uint32_t limit;

drivers/gpu/drm/amd/pm/amdgpu_pm.c

3372

r = amdgpu_dpm_get_power_limit(adev, &limit,

drivers/gpu/drm/amd/pm/amdgpu_pm.c

3376

size = sysfs_emit(buf, "%u\n", limit * 1000000);

drivers/gpu/drm/amd/pm/inc/amdgpu_dpm.h

393

int amdgpu_dpm_get_apu_thermal_limit(struct amdgpu_device *adev, uint32_t *limit);

drivers/gpu/drm/amd/pm/inc/amdgpu_dpm.h

394

int amdgpu_dpm_set_apu_thermal_limit(struct amdgpu_device *adev, uint32_t limit);

drivers/gpu/drm/amd/pm/inc/amdgpu_dpm.h

550

uint32_t *limit,

drivers/gpu/drm/amd/pm/inc/amdgpu_dpm.h

554

uint32_t limit_type, uint32_t limit);

drivers/gpu/drm/amd/pm/legacy-dpm/kv_dpm.c

2162

static int kv_get_high_voltage_limit(struct amdgpu_device *adev, int *limit)

drivers/gpu/drm/amd/pm/legacy-dpm/kv_dpm.c

2174

*limit = i;

drivers/gpu/drm/amd/pm/legacy-dpm/kv_dpm.c

2186

*limit = i;

drivers/gpu/drm/amd/pm/legacy-dpm/kv_dpm.c

2192

*limit = 0;

drivers/gpu/drm/amd/pm/legacy-dpm/kv_dpm.c

2204

int i, limit;

drivers/gpu/drm/amd/pm/legacy-dpm/kv_dpm.c

2256

kv_get_high_voltage_limit(adev, &limit);

drivers/gpu/drm/amd/pm/legacy-dpm/kv_dpm.c

2257

ps->levels[i].sclk = table->entries[limit].clk;

drivers/gpu/drm/amd/pm/legacy-dpm/kv_dpm.c

2268

kv_get_high_voltage_limit(adev, &limit);

drivers/gpu/drm/amd/pm/legacy-dpm/kv_dpm.c

2269

ps->levels[i].sclk = table->entries[limit].sclk_frequency;

drivers/gpu/drm/amd/pm/legacy-dpm/kv_dpm.h

222

u32 *value, u32 limit);

drivers/gpu/drm/amd/pm/legacy-dpm/kv_dpm.h

227

const u8 *src, u32 byte_count, u32 limit);

drivers/gpu/drm/amd/pm/legacy-dpm/kv_smc.c

123

const u8 *src, u32 byte_count, u32 limit)

drivers/gpu/drm/amd/pm/legacy-dpm/kv_smc.c

128

if ((smc_start_address + byte_count) > limit)

drivers/gpu/drm/amd/pm/legacy-dpm/kv_smc.c

138

ret = kv_set_smc_sram_address(adev, addr, limit);

drivers/gpu/drm/amd/pm/legacy-dpm/kv_smc.c

164

ret = kv_set_smc_sram_address(adev, addr, limit);

drivers/gpu/drm/amd/pm/legacy-dpm/kv_smc.c

177

ret = kv_set_smc_sram_address(adev, addr, limit);

drivers/gpu/drm/amd/pm/legacy-dpm/kv_smc.c

192

ret = kv_set_smc_sram_address(adev, addr, limit);

drivers/gpu/drm/amd/pm/legacy-dpm/kv_smc.c

210

ret = kv_set_smc_sram_address(adev, addr, limit);

drivers/gpu/drm/amd/pm/legacy-dpm/kv_smc.c

78

u32 smc_address, u32 limit)

drivers/gpu/drm/amd/pm/legacy-dpm/kv_smc.c

82

if ((smc_address + 3) > limit)

drivers/gpu/drm/amd/pm/legacy-dpm/kv_smc.c

93

u32 *value, u32 limit)

drivers/gpu/drm/amd/pm/legacy-dpm/kv_smc.c

97

ret = kv_set_smc_sram_address(adev, smc_address, limit);

drivers/gpu/drm/amd/pm/legacy-dpm/si_smc.c

104

ret = si_set_smc_sram_address(adev, addr, limit);

drivers/gpu/drm/amd/pm/legacy-dpm/si_smc.c

231

int amdgpu_si_load_smc_ucode(struct amdgpu_device *adev, u32 limit)

drivers/gpu/drm/amd/pm/legacy-dpm/si_smc.c

274

u32 *value, u32 limit)

drivers/gpu/drm/amd/pm/legacy-dpm/si_smc.c

280

ret = si_set_smc_sram_address(adev, smc_address, limit);

drivers/gpu/drm/amd/pm/legacy-dpm/si_smc.c

289

u32 value, u32 limit)

drivers/gpu/drm/amd/pm/legacy-dpm/si_smc.c

295

ret = si_set_smc_sram_address(adev, smc_address, limit);

drivers/gpu/drm/amd/pm/legacy-dpm/si_smc.c

40

u32 smc_address, u32 limit)

drivers/gpu/drm/amd/pm/legacy-dpm/si_smc.c

44

if ((smc_address + 3) > limit)

drivers/gpu/drm/amd/pm/legacy-dpm/si_smc.c

55

const u8 *src, u32 byte_count, u32 limit)

drivers/gpu/drm/amd/pm/legacy-dpm/si_smc.c

63

if ((smc_start_address + byte_count) > limit)

drivers/gpu/drm/amd/pm/legacy-dpm/si_smc.c

73

ret = si_set_smc_sram_address(adev, addr, limit);

drivers/gpu/drm/amd/pm/legacy-dpm/si_smc.c

88

ret = si_set_smc_sram_address(adev, addr, limit);

drivers/gpu/drm/amd/pm/legacy-dpm/sislands_smc.h

395

const u8 *src, u32 byte_count, u32 limit);

drivers/gpu/drm/amd/pm/legacy-dpm/sislands_smc.h

403

int amdgpu_si_load_smc_ucode(struct amdgpu_device *adev, u32 limit);

drivers/gpu/drm/amd/pm/legacy-dpm/sislands_smc.h

405

u32 *value, u32 limit);

drivers/gpu/drm/amd/pm/legacy-dpm/sislands_smc.h

407

u32 value, u32 limit);

drivers/gpu/drm/amd/pm/powerplay/amd_powerplay.c

1001

*limit = 0;

drivers/gpu/drm/amd/pm/powerplay/amd_powerplay.c

943

static int pp_set_power_limit(void *handle, uint32_t limit_type, uint32_t limit)

drivers/gpu/drm/amd/pm/powerplay/amd_powerplay.c

956

if (limit == 0)

drivers/gpu/drm/amd/pm/powerplay/amd_powerplay.c

957

limit = hwmgr->default_power_limit;

drivers/gpu/drm/amd/pm/powerplay/amd_powerplay.c

965

if (limit > max_power_limit)

drivers/gpu/drm/amd/pm/powerplay/amd_powerplay.c

968

hwmgr->hwmgr_func->set_power_limit(hwmgr, limit);

drivers/gpu/drm/amd/pm/powerplay/amd_powerplay.c

969

hwmgr->power_limit = limit;

drivers/gpu/drm/amd/pm/powerplay/amd_powerplay.c

973

static int pp_get_power_limit(void *handle, uint32_t *limit,

drivers/gpu/drm/amd/pm/powerplay/amd_powerplay.c

980

if (!hwmgr || !hwmgr->pm_en || !limit)

drivers/gpu/drm/amd/pm/powerplay/amd_powerplay.c

988

*limit = hwmgr->power_limit;

drivers/gpu/drm/amd/pm/powerplay/amd_powerplay.c

991

*limit = hwmgr->default_power_limit;

drivers/gpu/drm/amd/pm/powerplay/amd_powerplay.c

994

*limit = hwmgr->default_power_limit;

drivers/gpu/drm/amd/pm/powerplay/amd_powerplay.c

996

*limit *= (100 + hwmgr->platform_descriptor.TDPODLimit);

drivers/gpu/drm/amd/pm/powerplay/amd_powerplay.c

997

*limit /= 100;

drivers/gpu/drm/amd/pm/powerplay/smumgr/ci_smumgr.c

109

const uint8_t *src, uint32_t byte_count, uint32_t limit)

drivers/gpu/drm/amd/pm/powerplay/smumgr/ci_smumgr.c

118

|| ((smc_start_address + byte_count) >= limit)) {

drivers/gpu/drm/amd/pm/powerplay/smumgr/ci_smumgr.c

129

result = ci_set_smc_sram_address(hwmgr, addr, limit);

drivers/gpu/drm/amd/pm/powerplay/smumgr/ci_smumgr.c

145

result = ci_set_smc_sram_address(hwmgr, addr, limit);

drivers/gpu/drm/amd/pm/powerplay/smumgr/ci_smumgr.c

165

result = ci_set_smc_sram_address(hwmgr, addr, limit);

drivers/gpu/drm/amd/pm/powerplay/smumgr/ci_smumgr.c

195

uint32_t *value, uint32_t limit)

drivers/gpu/drm/amd/pm/powerplay/smumgr/ci_smumgr.c

199

result = ci_set_smc_sram_address(hwmgr, smc_addr, limit);

drivers/gpu/drm/amd/pm/powerplay/smumgr/ci_smumgr.c

95

uint32_t smc_addr, uint32_t limit)

drivers/gpu/drm/amd/pm/powerplay/smumgr/ci_smumgr.c

98

|| ((smc_addr + 3) >= limit)) {

drivers/gpu/drm/amd/pm/powerplay/smumgr/iceland_smumgr.c

159

uint32_t limit, uint32_t start_addr)

drivers/gpu/drm/amd/pm/powerplay/smumgr/iceland_smumgr.c

164

PP_ASSERT_WITH_CODE((limit >= byte_count), "SMC address is beyond the SMC RAM area.", return -EINVAL);

drivers/gpu/drm/amd/pm/powerplay/smumgr/smu7_smumgr.c

103

result = smu7_set_smc_sram_address(hwmgr, addr, limit);

drivers/gpu/drm/amd/pm/powerplay/smumgr/smu7_smumgr.c

229

int smu7_read_smc_sram_dword(struct pp_hwmgr *hwmgr, uint32_t smc_addr, uint32_t *value, uint32_t limit)

drivers/gpu/drm/amd/pm/powerplay/smumgr/smu7_smumgr.c

233

result = smu7_set_smc_sram_address(hwmgr, smc_addr, limit);

drivers/gpu/drm/amd/pm/powerplay/smumgr/smu7_smumgr.c

240

int smu7_write_smc_sram_dword(struct pp_hwmgr *hwmgr, uint32_t smc_addr, uint32_t value, uint32_t limit)

drivers/gpu/drm/amd/pm/powerplay/smumgr/smu7_smumgr.c

244

result = smu7_set_smc_sram_address(hwmgr, smc_addr, limit);

drivers/gpu/drm/amd/pm/powerplay/smumgr/smu7_smumgr.c

38

static int smu7_set_smc_sram_address(struct pp_hwmgr *hwmgr, uint32_t smc_addr, uint32_t limit)

drivers/gpu/drm/amd/pm/powerplay/smumgr/smu7_smumgr.c

41

PP_ASSERT_WITH_CODE((limit > (smc_addr + 3)), "SMC addr is beyond the SMC RAM area.", return -EINVAL);

drivers/gpu/drm/amd/pm/powerplay/smumgr/smu7_smumgr.c

418

static int smu7_upload_smc_firmware_data(struct pp_hwmgr *hwmgr, uint32_t length, uint32_t *src, uint32_t limit)

drivers/gpu/drm/amd/pm/powerplay/smumgr/smu7_smumgr.c

422

PP_ASSERT_WITH_CODE((limit >= byte_count), "SMC address is beyond the SMC RAM area.", return -EINVAL);

drivers/gpu/drm/amd/pm/powerplay/smumgr/smu7_smumgr.c

50

const uint8_t *src, uint32_t byte_count, uint32_t limit)

drivers/gpu/drm/amd/pm/powerplay/smumgr/smu7_smumgr.c

59

PP_ASSERT_WITH_CODE((limit > (smc_start_address + byte_count)), "SMC address is beyond the SMC RAM area.", return -EINVAL);

drivers/gpu/drm/amd/pm/powerplay/smumgr/smu7_smumgr.c

67

result = smu7_set_smc_sram_address(hwmgr, addr, limit);

drivers/gpu/drm/amd/pm/powerplay/smumgr/smu7_smumgr.c

83

result = smu7_set_smc_sram_address(hwmgr, addr, limit);

drivers/gpu/drm/amd/pm/powerplay/smumgr/smu7_smumgr.h

57

const uint8_t *src, uint32_t byte_count, uint32_t limit);

drivers/gpu/drm/amd/pm/powerplay/smumgr/smu7_smumgr.h

68

uint32_t *value, uint32_t limit);

drivers/gpu/drm/amd/pm/powerplay/smumgr/smu7_smumgr.h

70

uint32_t value, uint32_t limit);

drivers/gpu/drm/amd/pm/powerplay/smumgr/smu8_smumgr.c

110

uint32_t smc_address, uint32_t limit)

drivers/gpu/drm/amd/pm/powerplay/smumgr/smu8_smumgr.c

120

if (limit <= (smc_address + 3)) {

drivers/gpu/drm/amd/pm/powerplay/smumgr/smu8_smumgr.c

132

uint32_t smc_address, uint32_t value, uint32_t limit)

drivers/gpu/drm/amd/pm/powerplay/smumgr/smu8_smumgr.c

139

result = smu8_set_smc_sram_address(hwmgr, smc_address, limit);

drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c

2895

uint32_t *limit,

drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c

2908

if (!limit)

drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c

2941

ret = smu->ppt_funcs->get_ppt_limit(smu, limit, limit_type, limit_level);

drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c

2963

*limit = smu->current_power_limit;

drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c

2966

*limit = smu->default_power_limit;

drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c

2969

*limit = smu->max_power_limit;

drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c

2972

*limit = smu->min_power_limit;

drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c

2982

static int smu_set_power_limit(void *handle, uint32_t limit_type, uint32_t limit)

drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c

2991

if (!limit)

drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c

2992

limit = smu->current_power_limit;

drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c

2993

if ((limit > smu->max_power_limit) || (limit < smu->min_power_limit)) {

drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c

2996

limit, smu->min_power_limit, smu->max_power_limit);

drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c

3002

ret = smu->ppt_funcs->set_power_limit(smu, limit_type, limit);

drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c

3006

smu->user_dpm_profile.power_limits[limit_type] = limit;

drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c

3202

static int smu_get_apu_thermal_limit(void *handle, uint32_t *limit)

drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c

3208

ret = smu->ppt_funcs->get_apu_thermal_limit(smu, limit);

drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c

3213

static int smu_set_apu_thermal_limit(void *handle, uint32_t limit)

drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c

3219

ret = smu->ppt_funcs->set_apu_thermal_limit(smu, limit);

drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c

72

static int smu_set_power_limit(void *handle, uint32_t limit_type, uint32_t limit);

drivers/gpu/drm/amd/pm/swsmu/inc/amdgpu_smu.h

1259

uint32_t limit);

drivers/gpu/drm/amd/pm/swsmu/inc/amdgpu_smu.h

1942

uint32_t *limit,

drivers/gpu/drm/amd/pm/swsmu/inc/amdgpu_smu.h

961

int (*get_apu_thermal_limit)(struct smu_context *smu, uint32_t *limit);

drivers/gpu/drm/amd/pm/swsmu/inc/amdgpu_smu.h

967

int (*set_apu_thermal_limit)(struct smu_context *smu, uint32_t limit);

drivers/gpu/drm/amd/pm/swsmu/inc/smu_v11_0.h

173

uint32_t limit);

drivers/gpu/drm/amd/pm/swsmu/inc/smu_v13_0.h

155

uint32_t limit);

drivers/gpu/drm/amd/pm/swsmu/inc/smu_v14_0.h

147

uint32_t limit);

drivers/gpu/drm/amd/pm/swsmu/inc/smu_v15_0.h

165

uint32_t limit);

drivers/gpu/drm/amd/pm/swsmu/smu11/smu_v11_0.c

940

uint32_t limit)

drivers/gpu/drm/amd/pm/swsmu/smu11/smu_v11_0.c

967

limit_param = (limit & 0xFFFF);

drivers/gpu/drm/amd/pm/swsmu/smu11/smu_v11_0.c

976

smu->current_power_limit = limit;

drivers/gpu/drm/amd/pm/swsmu/smu11/vangogh_ppt.c

1582

static int vangogh_get_apu_thermal_limit(struct smu_context *smu, uint32_t *limit)

drivers/gpu/drm/amd/pm/swsmu/smu11/vangogh_ppt.c

1586

0, limit);

drivers/gpu/drm/amd/pm/swsmu/smu11/vangogh_ppt.c

1589

static int vangogh_set_apu_thermal_limit(struct smu_context *smu, uint32_t limit)

drivers/gpu/drm/amd/pm/swsmu/smu11/vangogh_ppt.c

1593

limit, NULL);

drivers/gpu/drm/amd/pm/swsmu/smu13/aldebaran_ppt.c

1173

uint32_t limit)

drivers/gpu/drm/amd/pm/swsmu/smu13/aldebaran_ppt.c

1177

return smu_v13_0_set_power_limit(smu, limit_type, limit);

drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0.c

970

uint32_t limit)

drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0.c

982

ret = smu_cmn_send_smc_msg_with_param(smu, SMU_MSG_SetPptLimit, limit, NULL);

drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0.c

988

smu->current_power_limit = limit;

drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_0_ppt.c

3022

uint32_t limit)

drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_0_ppt.c

3035

if (limit <= msg_limit) {

drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_0_ppt.c

3046

return smu_v13_0_set_power_limit(smu, limit_type, limit);

drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_0_ppt.c

3052

od_table->OverDriveTable.Ppt = (limit * 100) / msg_limit - 100;

drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_0_ppt.c

3061

smu->current_power_limit = limit;

drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_6_ppt.c

1730

uint32_t limit)

drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_6_ppt.c

1740

if (limit > pptable->PPT1Max || limit < pptable->PPT1Min) {

drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_6_ppt.c

1743

limit, pptable->PPT1Min, pptable->PPT1Max);

drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_6_ppt.c

1747

limit, NULL);

drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_6_ppt.c

1753

return smu_v13_0_set_power_limit(smu, limit_type, limit);

drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_7_ppt.c

2650

uint32_t limit)

drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_7_ppt.c

2663

if (limit <= msg_limit) {

drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_7_ppt.c

2674

return smu_v13_0_set_power_limit(smu, limit_type, limit);

drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_7_ppt.c

2680

od_table->OverDriveTable.Ppt = (limit * 100) / msg_limit - 100;

drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_7_ppt.c

2689

smu->current_power_limit = limit;

drivers/gpu/drm/amd/pm/swsmu/smu14/smu_v14_0.c

840

uint32_t limit)

drivers/gpu/drm/amd/pm/swsmu/smu14/smu_v14_0.c

852

ret = smu_cmn_send_smc_msg_with_param(smu, SMU_MSG_SetPptLimit, limit, NULL);

drivers/gpu/drm/amd/pm/swsmu/smu14/smu_v14_0.c

858

smu->current_power_limit = limit;

drivers/gpu/drm/amd/pm/swsmu/smu14/smu_v14_0_2_ppt.c

2740

uint32_t limit)

drivers/gpu/drm/amd/pm/swsmu/smu14/smu_v14_0_2_ppt.c

2752

if (limit <= msg_limit) {

drivers/gpu/drm/amd/pm/swsmu/smu14/smu_v14_0_2_ppt.c

2763

return smu_v14_0_set_power_limit(smu, limit_type, limit);

drivers/gpu/drm/amd/pm/swsmu/smu14/smu_v14_0_2_ppt.c

2769

od_table->OverDriveTable.Ppt = (limit * 100) / msg_limit - 100;

drivers/gpu/drm/amd/pm/swsmu/smu14/smu_v14_0_2_ppt.c

2778

smu->current_power_limit = limit;

drivers/gpu/drm/amd/pm/swsmu/smu15/smu_v15_0.c

805

uint32_t limit)

drivers/gpu/drm/amd/pm/swsmu/smu15/smu_v15_0.c

817

ret = smu_cmn_send_smc_msg_with_param(smu, SMU_MSG_SetPptLimit, limit, NULL);

drivers/gpu/drm/amd/pm/swsmu/smu15/smu_v15_0.c

823

smu->current_power_limit = limit;

drivers/gpu/drm/amd/ras/rascore/ras_eeprom.c

205

u16 limit;

drivers/gpu/drm/amd/ras/rascore/ras_eeprom.c

210

limit = ras_core->ras_eeprom.max_read_len;

drivers/gpu/drm/amd/ras/rascore/ras_eeprom.c

212

limit = ras_core->ras_eeprom.max_write_len;

drivers/gpu/drm/amd/ras/rascore/ras_eeprom.c

214

if (limit && (limit <= EEPROM_OFFSET_SIZE)) {

drivers/gpu/drm/amd/ras/rascore/ras_eeprom.c

224

if (limit == 0) {

drivers/gpu/drm/amd/ras/rascore/ras_eeprom.c

232

limit -= EEPROM_OFFSET_SIZE;

drivers/gpu/drm/amd/ras/rascore/ras_eeprom.c

235

ps = (buf_size < limit) ? buf_size : limit;

drivers/gpu/drm/drm_bridge.c

830

struct drm_bridge *next, *limit;

drivers/gpu/drm/drm_bridge.c

838

limit = NULL;

drivers/gpu/drm/drm_bridge.c

847

limit = next;

drivers/gpu/drm/drm_bridge.c

856

limit = next;

drivers/gpu/drm/drm_bridge.c

862

limit = next;

drivers/gpu/drm/drm_bridge.c

881

if (limit)

drivers/gpu/drm/drm_bridge.c

883

bridge = limit;

drivers/gpu/drm/drm_bridge.c

924

struct drm_bridge *iter, *next, *limit;

drivers/gpu/drm/drm_bridge.c

934

limit = bridge;

drivers/gpu/drm/drm_bridge.c

945

limit = next;

drivers/gpu/drm/drm_bridge.c

968

iter = limit;

drivers/gpu/drm/gma500/cdv_intel_display.c

24

static bool cdv_intel_find_dp_pll(const struct gma_limit_t *limit,

drivers/gpu/drm/gma500/cdv_intel_display.c

368

const struct gma_limit_t *limit;

drivers/gpu/drm/gma500/cdv_intel_display.c

375

limit = &cdv_intel_limits[CDV_LIMIT_SINGLE_LVDS_96];

drivers/gpu/drm/gma500/cdv_intel_display.c

377

limit = &cdv_intel_limits[CDV_LIMIT_SINGLE_LVDS_100];

drivers/gpu/drm/gma500/cdv_intel_display.c

381

limit = &cdv_intel_limits[CDV_LIMIT_DP_27];

drivers/gpu/drm/gma500/cdv_intel_display.c

383

limit = &cdv_intel_limits[CDV_LIMIT_DP_100];

drivers/gpu/drm/gma500/cdv_intel_display.c

386

limit = &cdv_intel_limits[CDV_LIMIT_DAC_HDMI_27];

drivers/gpu/drm/gma500/cdv_intel_display.c

388

limit = &cdv_intel_limits[CDV_LIMIT_DAC_HDMI_96];

drivers/gpu/drm/gma500/cdv_intel_display.c

390

return limit;

drivers/gpu/drm/gma500/cdv_intel_display.c

402

static bool cdv_intel_find_dp_pll(const struct gma_limit_t *limit,

drivers/gpu/drm/gma500/cdv_intel_display.c

591

const struct gma_limit_t *limit;

drivers/gpu/drm/gma500/cdv_intel_display.c

656

limit = gma_crtc->clock_funcs->limit(crtc, refclk);

drivers/gpu/drm/gma500/cdv_intel_display.c

658

ok = limit->find_pll(limit, crtc, adjusted_mode->clock, refclk,

drivers/gpu/drm/gma500/cdv_intel_display.c

973

.limit = cdv_intel_limit,

drivers/gpu/drm/gma500/gma_display.c

720

const struct gma_limit_t *limit,

drivers/gpu/drm/gma500/gma_display.c

723

if (clock->p1 < limit->p1.min || limit->p1.max < clock->p1)

drivers/gpu/drm/gma500/gma_display.c

725

if (clock->p < limit->p.min || limit->p.max < clock->p)

drivers/gpu/drm/gma500/gma_display.c

727

if (clock->m2 < limit->m2.min || limit->m2.max < clock->m2)

drivers/gpu/drm/gma500/gma_display.c

729

if (clock->m1 < limit->m1.min || limit->m1.max < clock->m1)

drivers/gpu/drm/gma500/gma_display.c

734

if (clock->m < limit->m.min || limit->m.max < clock->m)

drivers/gpu/drm/gma500/gma_display.c

736

if (clock->n < limit->n.min || limit->n.max < clock->n)

drivers/gpu/drm/gma500/gma_display.c

738

if (clock->vco < limit->vco.min || limit->vco.max < clock->vco)

drivers/gpu/drm/gma500/gma_display.c

744

if (clock->dot < limit->dot.min || limit->dot.max < clock->dot)

drivers/gpu/drm/gma500/gma_display.c

750

bool gma_find_best_pll(const struct gma_limit_t *limit,

drivers/gpu/drm/gma500/gma_display.c

770

clock.p2 = limit->p2.p2_fast;

drivers/gpu/drm/gma500/gma_display.c

772

clock.p2 = limit->p2.p2_slow;

drivers/gpu/drm/gma500/gma_display.c

774

if (target < limit->p2.dot_limit)

drivers/gpu/drm/gma500/gma_display.c

775

clock.p2 = limit->p2.p2_slow;

drivers/gpu/drm/gma500/gma_display.c

777

clock.p2 = limit->p2.p2_fast;

drivers/gpu/drm/gma500/gma_display.c

783

for (clock.m1 = limit->m1.min; clock.m1 <= limit->m1.max; clock.m1++) {

drivers/gpu/drm/gma500/gma_display.c

784

for (clock.m2 = limit->m2.min;

drivers/gpu/drm/gma500/gma_display.c

786

clock.m2 <= limit->m2.max; clock.m2++) {

drivers/gpu/drm/gma500/gma_display.c

787

for (clock.n = limit->n.min;

drivers/gpu/drm/gma500/gma_display.c

788

clock.n <= limit->n.max; clock.n++) {

drivers/gpu/drm/gma500/gma_display.c

789

for (clock.p1 = limit->p1.min;

drivers/gpu/drm/gma500/gma_display.c

790

clock.p1 <= limit->p1.max;

drivers/gpu/drm/gma500/gma_display.c

797

limit, &clock))

drivers/gpu/drm/gma500/gma_display.h

50

const struct gma_limit_t *(*limit)(struct drm_crtc *crtc, int refclk);

drivers/gpu/drm/gma500/gma_display.h

52

const struct gma_limit_t *limit,

drivers/gpu/drm/gma500/gma_display.h

85

const struct gma_limit_t *limit,

drivers/gpu/drm/gma500/gma_display.h

87

extern bool gma_find_best_pll(const struct gma_limit_t *limit,

drivers/gpu/drm/gma500/oaktrail_crtc.c

101

limit = &mrst_limits[MRST_LIMIT_LVDS_100];

drivers/gpu/drm/gma500/oaktrail_crtc.c

105

limit = &mrst_limits[MRST_LIMIT_SDVO];

drivers/gpu/drm/gma500/oaktrail_crtc.c

107

limit = NULL;

drivers/gpu/drm/gma500/oaktrail_crtc.c

111

return limit;

drivers/gpu/drm/gma500/oaktrail_crtc.c

127

static bool mrst_sdvo_find_best_pll(const struct gma_limit_t *limit,

drivers/gpu/drm/gma500/oaktrail_crtc.c

138

for (clock.m = limit->m.min; clock.m <= limit->m.max; clock.m++) {

drivers/gpu/drm/gma500/oaktrail_crtc.c

139

for (clock.n = limit->n.min; clock.n <= limit->n.max;

drivers/gpu/drm/gma500/oaktrail_crtc.c

141

for (clock.p1 = limit->p1.min;

drivers/gpu/drm/gma500/oaktrail_crtc.c

142

clock.p1 <= limit->p1.max; clock.p1++) {

drivers/gpu/drm/gma500/oaktrail_crtc.c

144

clock.p = clock.p1 * limit->p2.p2_slow;

drivers/gpu/drm/gma500/oaktrail_crtc.c

148

if (target_vco > limit->vco.max)

drivers/gpu/drm/gma500/oaktrail_crtc.c

151

if (target_vco < limit->vco.min)

drivers/gpu/drm/gma500/oaktrail_crtc.c

185

static bool mrst_lvds_find_best_pll(const struct gma_limit_t *limit,

drivers/gpu/drm/gma500/oaktrail_crtc.c

195

for (clock.m = limit->m.min; clock.m <= limit->m.max; clock.m++) {

drivers/gpu/drm/gma500/oaktrail_crtc.c

196

for (clock.p1 = limit->p1.min; clock.p1 <= limit->p1.max;

drivers/gpu/drm/gma500/oaktrail_crtc.c

373

const struct gma_limit_t *limit;

drivers/gpu/drm/gma500/oaktrail_crtc.c

40

static bool mrst_lvds_find_best_pll(const struct gma_limit_t *limit,

drivers/gpu/drm/gma500/oaktrail_crtc.c

44

static bool mrst_sdvo_find_best_pll(const struct gma_limit_t *limit,

drivers/gpu/drm/gma500/oaktrail_crtc.c

507

limit = mrst_limit(crtc, refclk);

drivers/gpu/drm/gma500/oaktrail_crtc.c

508

ok = limit->find_pll(limit, crtc, adjusted_mode->clock,

drivers/gpu/drm/gma500/oaktrail_crtc.c

87

const struct gma_limit_t *limit = NULL;

drivers/gpu/drm/gma500/oaktrail_crtc.c

95

limit = &mrst_limits[MRST_LIMIT_LVDS_100L];

drivers/gpu/drm/gma500/oaktrail_crtc.c

98

limit = &mrst_limits[MRST_LIMIT_LVDS_83];

drivers/gpu/drm/gma500/psb_intel_display.c

113

const struct gma_limit_t *limit;

drivers/gpu/drm/gma500/psb_intel_display.c

147

limit = gma_crtc->clock_funcs->limit(crtc, refclk);

drivers/gpu/drm/gma500/psb_intel_display.c

149

ok = limit->find_pll(limit, crtc, adjusted_mode->clock, refclk,

drivers/gpu/drm/gma500/psb_intel_display.c

438

.limit = psb_intel_limit,

drivers/gpu/drm/gma500/psb_intel_display.c

60

const struct gma_limit_t *limit;

drivers/gpu/drm/gma500/psb_intel_display.c

63

limit = &psb_intel_limits[INTEL_LIMIT_I9XX_LVDS];

drivers/gpu/drm/gma500/psb_intel_display.c

65

limit = &psb_intel_limits[INTEL_LIMIT_I9XX_SDVO_DAC];

drivers/gpu/drm/gma500/psb_intel_display.c

66

return limit;

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

3713

u32 limit = intel_de_read(display, SKL_DFSM) & SKL_DFSM_CDCLK_LIMIT_MASK;

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

3724

if (limit == SKL_DFSM_CDCLK_LIMIT_675)

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

3726

else if (limit == SKL_DFSM_CDCLK_LIMIT_540)

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

3728

else if (limit == SKL_DFSM_CDCLK_LIMIT_450)

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

1359

const struct intel_limit *limit;

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

1377

limit = &ilk_limits_dual_lvds_100m;

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

1379

limit = &ilk_limits_dual_lvds;

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

1382

limit = &ilk_limits_single_lvds_100m;

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

1384

limit = &ilk_limits_single_lvds;

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

1387

limit = &ilk_limits_dac;

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

1391

!g4x_find_best_dpll(limit, crtc_state, crtc_state->port_clock,

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

1480

const struct intel_limit *limit = &intel_limits_chv;

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

1484

!chv_find_best_dpll(limit, crtc_state, crtc_state->port_clock,

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

1507

const struct intel_limit *limit = &intel_limits_vlv;

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

1511

!vlv_find_best_dpll(limit, crtc_state, crtc_state->port_clock,

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

1535

const struct intel_limit *limit;

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

1547

limit = &intel_limits_g4x_dual_channel_lvds;

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

1549

limit = &intel_limits_g4x_single_channel_lvds;

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

1552

limit = &intel_limits_g4x_hdmi;

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

1554

limit = &intel_limits_g4x_sdvo;

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

1557

limit = &intel_limits_i9xx_sdvo;

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

1561

!g4x_find_best_dpll(limit, crtc_state, crtc_state->port_clock,

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

1584

const struct intel_limit *limit;

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

1595

limit = &pnv_limits_lvds;

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

1597

limit = &pnv_limits_sdvo;

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

1601

!pnv_find_best_dpll(limit, crtc_state, crtc_state->port_clock,

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

1622

const struct intel_limit *limit;

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

1633

limit = &intel_limits_i9xx_lvds;

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

1635

limit = &intel_limits_i9xx_sdvo;

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

1639

!i9xx_find_best_dpll(limit, crtc_state, crtc_state->port_clock,

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

1662

const struct intel_limit *limit;

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

1673

limit = &intel_limits_i8xx_lvds;

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

1675

limit = &intel_limits_i8xx_dvo;

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

1677

limit = &intel_limits_i8xx_dac;

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

1681

!i9xx_find_best_dpll(limit, crtc_state, crtc_state->port_clock,

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

583

const struct intel_limit *limit,

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

586

if (clock->n < limit->n.min || limit->n.max < clock->n)

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

588

if (clock->p1 < limit->p1.min || limit->p1.max < clock->p1)

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

590

if (clock->m2 < limit->m2.min || limit->m2.max < clock->m2)

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

592

if (clock->m1 < limit->m1.min || limit->m1.max < clock->m1)

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

603

if (clock->p < limit->p.min || limit->p.max < clock->p)

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

605

if (clock->m < limit->m.min || limit->m.max < clock->m)

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

609

if (clock->vco < limit->vco.min || limit->vco.max < clock->vco)

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

614

if (clock->dot < limit->dot.min || limit->dot.max < clock->dot)

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

621

i9xx_select_p2_div(const struct intel_limit *limit,

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

634

return limit->p2.p2_fast;

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

636

return limit->p2.p2_slow;

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

638

if (target < limit->p2.dot_limit)

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

639

return limit->p2.p2_slow;

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

641

return limit->p2.p2_fast;

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

655

i9xx_find_best_dpll(const struct intel_limit *limit,

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

667

clock.p2 = i9xx_select_p2_div(limit, crtc_state, target);

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

669

for (clock.m1 = limit->m1.min; clock.m1 <= limit->m1.max;

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

671

for (clock.m2 = limit->m2.min;

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

672

clock.m2 <= limit->m2.max; clock.m2++) {

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

675

for (clock.n = limit->n.min;

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

676

clock.n <= limit->n.max; clock.n++) {

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

677

for (clock.p1 = limit->p1.min;

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

678

clock.p1 <= limit->p1.max; clock.p1++) {

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

683

limit,

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

713

pnv_find_best_dpll(const struct intel_limit *limit,

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

725

clock.p2 = i9xx_select_p2_div(limit, crtc_state, target);

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

727

for (clock.m1 = limit->m1.min; clock.m1 <= limit->m1.max;

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

729

for (clock.m2 = limit->m2.min;

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

730

clock.m2 <= limit->m2.max; clock.m2++) {

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

731

for (clock.n = limit->n.min;

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

732

clock.n <= limit->n.max; clock.n++) {

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

733

for (clock.p1 = limit->p1.min;

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

734

clock.p1 <= limit->p1.max; clock.p1++) {

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

739

limit,

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

769

g4x_find_best_dpll(const struct intel_limit *limit,

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

784

clock.p2 = i9xx_select_p2_div(limit, crtc_state, target);

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

786

max_n = limit->n.max;

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

788

for (clock.n = limit->n.min; clock.n <= max_n; clock.n++) {

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

790

for (clock.m1 = limit->m1.max;

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

791

clock.m1 >= limit->m1.min; clock.m1--) {

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

792

for (clock.m2 = limit->m2.max;

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

793

clock.m2 >= limit->m2.min; clock.m2--) {

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

794

for (clock.p1 = limit->p1.max;

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

795

clock.p1 >= limit->p1.min; clock.p1--) {

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

800

limit,

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

863

vlv_find_best_dpll(const struct intel_limit *limit,

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

873

int max_n = min(limit->n.max, refclk / 19200);

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

879

for (clock.n = limit->n.min; clock.n <= max_n; clock.n++) {

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

880

for (clock.p1 = limit->p1.max; clock.p1 >= limit->p1.min; clock.p1--) {

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

881

for (clock.p2 = limit->p2.p2_fast; clock.p2 >= limit->p2.p2_slow;

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

885

for (clock.m1 = limit->m1.min; clock.m1 <= limit->m1.max; clock.m1++) {

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

894

limit,

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

920

chv_find_best_dpll(const struct intel_limit *limit,

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

943

for (clock.p1 = limit->p1.max; clock.p1 >= limit->p1.min; clock.p1--) {

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

944

for (clock.p2 = limit->p2.p2_fast;

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

945

clock.p2 >= limit->p2.p2_slow;

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

961

if (!intel_pll_is_valid(display, limit, &clock))

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

980

const struct intel_limit *limit = &intel_limits_bxt;

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

983

return chv_find_best_dpll(limit, crtc_state,

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

108

u8 limit;

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

1502

return intel_fbc_min_limit(plane_state) <= fbc->limit &&

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

1503

intel_fbc_cfb_size(plane_state) <= fbc->limit *

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

176

unsigned int limit = 4; /* 1:4 compression limit is the worst case */

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

181

stride = width * cpp * height / limit;

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

197

return stride * limit / height;

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

291

cfb_stride = fbc_state->cfb_stride / fbc->limit;

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

437

switch (fbc->limit) {

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

439

MISSING_CASE(fbc->limit);

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

638

FBC_STRIDE(fbc_state->override_cfb_stride / fbc->limit);

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

652

CHICKEN_FBC_STRIDE(fbc_state->override_cfb_stride / fbc->limit);

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

863

int ret, limit = min_limit;

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

865

size /= limit;

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

871

return limit;

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

873

for (; limit <= intel_fbc_max_limit(display); limit <<= 1) {

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

877

return limit;

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

907

fbc->limit = ret;

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

911

intel_parent_stolen_node_size(display, fbc->compressed_fb), fbc->limit);

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

918

unsigned int limit, decimate;

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

940

limit = 9;

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

943

limit -= decimate;

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

947

limit--;

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

956

limit << 16);

drivers/gpu/drm/i915/gt/selftest_rps.c

408

int f, limit;

drivers/gpu/drm/i915/gt/selftest_rps.c

451

limit = rps_set_check(rps, f);

drivers/gpu/drm/i915/gt/selftest_rps.c

464

max = rps_set_check(rps, limit);

drivers/gpu/drm/i915/gt/selftest_rps.c

481

limit, intel_gpu_freq(rps, limit),

drivers/gpu/drm/i915/gt/selftest_rps.c

484

if (limit != rps->max_freq) {

drivers/gpu/drm/i915/selftests/i915_gem_gtt.c

1465

const u64 limit = totalram_pages() << PAGE_SHIFT;

drivers/gpu/drm/i915/selftests/i915_gem_gtt.c

1476

err = func(vm, 0, min(vm->total, limit), end_time);

drivers/gpu/drm/i915/selftests/i915_gem_gtt.c

158

u64 size, last, limit;

drivers/gpu/drm/i915/selftests/i915_gem_gtt.c

180

limit = totalram_pages() << PAGE_SHIFT;

drivers/gpu/drm/i915/selftests/i915_gem_gtt.c

181

limit = min(ppgtt->vm.total, limit);

drivers/gpu/drm/i915/selftests/i915_gem_gtt.c

190

for (size = 4096; size <= limit; size <<= 2) {

drivers/gpu/drm/i915/selftests/i915_gem_gtt.c

212

for (last = 0, size = 4096; size <= limit; last = size, size <<= 2) {

drivers/gpu/drm/mediatek/mtk_dpi.c

308

struct mtk_dpi_yc_limit limit;

drivers/gpu/drm/mediatek/mtk_dpi.c

312

limit.y_bottom = 0x10;

drivers/gpu/drm/mediatek/mtk_dpi.c

313

limit.y_top = 0xfe0;

drivers/gpu/drm/mediatek/mtk_dpi.c

314

limit.c_bottom = 0x10;

drivers/gpu/drm/mediatek/mtk_dpi.c

315

limit.c_top = 0xfe0;

drivers/gpu/drm/mediatek/mtk_dpi.c

317

limit.y_bottom = 0;

drivers/gpu/drm/mediatek/mtk_dpi.c

318

limit.y_top = 0xfff;

drivers/gpu/drm/mediatek/mtk_dpi.c

319

limit.c_bottom = 0;

drivers/gpu/drm/mediatek/mtk_dpi.c

320

limit.c_top = 0xfff;

drivers/gpu/drm/mediatek/mtk_dpi.c

323

mtk_dpi_mask(dpi, DPI_Y_LIMIT, limit.y_bottom << Y_LIMINT_BOT,

drivers/gpu/drm/mediatek/mtk_dpi.c

325

mtk_dpi_mask(dpi, DPI_Y_LIMIT, limit.y_top << Y_LIMINT_TOP,

drivers/gpu/drm/mediatek/mtk_dpi.c

327

mtk_dpi_mask(dpi, DPI_C_LIMIT, limit.c_bottom << C_LIMIT_BOT,

drivers/gpu/drm/mediatek/mtk_dpi.c

329

mtk_dpi_mask(dpi, DPI_C_LIMIT, limit.c_top << C_LIMIT_TOP,

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

257

sharp_ctl = ((de_cfg->limit & 0xF) << 9) |

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

227

uint16_t limit;

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

75

uint16_t limit;

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

104

reg_val |= (limit) << bit_off;

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

115

u32 limit;

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

125

limit = (reg_val >> bit_off) & 0xFF;

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

127

return limit;

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

88

u32 xin_id, bool rd, u32 limit)

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

27

u32 xin_id, bool rd, u32 limit);

drivers/gpu/drm/nouveau/dispnv50/crc.c

523

.limit = ctx->mem.addr

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

298

.limit = syncbuf + 0x0fff,

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

310

.limit = device->info.ram_user - 1,

drivers/gpu/drm/nouveau/dispnv50/wndw.c

90

args.base.limit = drm->client.device.info.ram_user - 1;

drivers/gpu/drm/nouveau/include/nvif/cl0002.h

20

__u64 limit;

drivers/gpu/drm/nouveau/include/nvif/timer.h

7

u64 limit;

drivers/gpu/drm/nouveau/include/nvif/vmm.h

27

u64 limit;

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

16

u64 limit;

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

38

u32 limit;

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

45

u32 limit;

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

28

u32 limit;

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

40

u64 limit;

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

33

u64 limit;

drivers/gpu/drm/nouveau/nouveau_abi16.c

650

args.limit = ntfy->node->offset + ntfy->node->length - 1;

drivers/gpu/drm/nouveau/nouveau_abi16.c

655

args.limit += chan->ntfy_vma->addr;

drivers/gpu/drm/nouveau/nouveau_abi16.c

661

args.limit += drm->agp.base + chan->ntfy->offset;

drivers/gpu/drm/nouveau/nouveau_abi16.c

666

args.limit += chan->ntfy->offset;

drivers/gpu/drm/nouveau/nouveau_chan.c

202

args.limit = chan->vmm->vmm.limit - 1;

drivers/gpu/drm/nouveau/nouveau_chan.c

215

args.limit = args.start + device->info.ram_user - 1;

drivers/gpu/drm/nouveau/nouveau_chan.c

220

args.limit = device->info.ram_user - 1;

drivers/gpu/drm/nouveau/nouveau_chan.c

227

args.limit = drm->agp.base + drm->agp.size - 1;

drivers/gpu/drm/nouveau/nouveau_chan.c

232

args.limit = chan->vmm->vmm.limit - 1;

drivers/gpu/drm/nouveau/nouveau_chan.c

393

args.limit = chan->vmm->vmm.limit - 1;

drivers/gpu/drm/nouveau/nouveau_chan.c

398

args.limit = device->info.ram_user - 1;

drivers/gpu/drm/nouveau/nouveau_chan.c

411

args.limit = chan->vmm->vmm.limit - 1;

drivers/gpu/drm/nouveau/nouveau_chan.c

417

args.limit = drm->agp.base + drm->agp.size - 1;

drivers/gpu/drm/nouveau/nouveau_chan.c

422

args.limit = chan->vmm->vmm.limit - 1;

drivers/gpu/drm/nouveau/nouveau_drm.c

441

.limit = drm->notify->addr + 31

drivers/gpu/drm/nouveau/nouveau_svm.c

240

nouveau_svmm_invalidate(struct nouveau_svmm *svmm, u64 start, u64 limit)

drivers/gpu/drm/nouveau/nouveau_svm.c

242

if (limit > start) {

drivers/gpu/drm/nouveau/nouveau_svm.c

246

.size = limit - start,

drivers/gpu/drm/nouveau/nouveau_svm.c

258

unsigned long limit = update->end;

drivers/gpu/drm/nouveau/nouveau_svm.c

263

SVMM_DBG(svmm, "invalidate %016lx-%016lx", start, limit);

drivers/gpu/drm/nouveau/nouveau_svm.c

277

if (limit > svmm->unmanaged.start && start < svmm->unmanaged.limit) {

drivers/gpu/drm/nouveau/nouveau_svm.c

280

svmm->unmanaged.limit);

drivers/gpu/drm/nouveau/nouveau_svm.c

282

start = svmm->unmanaged.limit;

drivers/gpu/drm/nouveau/nouveau_svm.c

285

nouveau_svmm_invalidate(svmm, start, limit);

drivers/gpu/drm/nouveau/nouveau_svm.c

333

svmm->unmanaged.limit = args->unmanaged_addr + args->unmanaged_size;

drivers/gpu/drm/nouveau/nouveau_svm.c

725

u64 inst, start, limit;

drivers/gpu/drm/nouveau/nouveau_svm.c

793

limit = start + PAGE_SIZE;

drivers/gpu/drm/nouveau/nouveau_svm.c

794

if (start < svmm->unmanaged.limit)

drivers/gpu/drm/nouveau/nouveau_svm.c

795

limit = min_t(u64, limit, svmm->unmanaged.start);

drivers/gpu/drm/nouveau/nouveau_svm.c

841

limit = args->p.addr + args->p.size;

drivers/gpu/drm/nouveau/nouveau_svm.c

853

buffer->fault[fn]->addr >= limit ||

drivers/gpu/drm/nouveau/nouveau_svm.h

14

unsigned long limit;

drivers/gpu/drm/nouveau/nouveau_svm.h

32

void nouveau_svmm_invalidate(struct nouveau_svmm *svmm, u64 start, u64 limit);

drivers/gpu/drm/nouveau/nouveau_ttm.c

331

drm->gem.gart_available = drm->client.vmm.vmm.limit;

drivers/gpu/drm/nouveau/nv17_fence.c

101

.limit = limit,

drivers/gpu/drm/nouveau/nv17_fence.c

83

u32 limit = start + priv->bo->bo.base.size - 1;

drivers/gpu/drm/nouveau/nv50_fence.c

42

u32 limit = start + priv->bo->bo.base.size - 1;

drivers/gpu/drm/nouveau/nv50_fence.c

60

.limit = limit,

drivers/gpu/drm/nouveau/nvif/timer.c

43

if (wait->time1 - wait->time0 > wait->limit)

drivers/gpu/drm/nouveau/nvif/timer.c

54

wait->limit = nsec;

drivers/gpu/drm/nouveau/nvif/vmm.c

234

vmm->limit = args->size;

drivers/gpu/drm/nouveau/nvkm/engine/dma/user.c

88

args->v0.start, args->v0.limit);

drivers/gpu/drm/nouveau/nvkm/engine/dma/user.c

92

dmaobj->limit = args->v0.limit;

drivers/gpu/drm/nouveau/nvkm/engine/dma/user.c

99

if (dmaobj->start > dmaobj->limit)

drivers/gpu/drm/nouveau/nvkm/engine/dma/usergf100.c

52

nvkm_wo32(*pgpuobj, 0x04, lower_32_bits(dmaobj->base.limit));

drivers/gpu/drm/nouveau/nvkm/engine/dma/usergf100.c

54

nvkm_wo32(*pgpuobj, 0x0c, upper_32_bits(dmaobj->base.limit) << 24 |

drivers/gpu/drm/nouveau/nvkm/engine/dma/usergf119.c

52

nvkm_wo32(*pgpuobj, 0x08, dmaobj->base.limit >> 8);

drivers/gpu/drm/nouveau/nvkm/engine/dma/usergv100.c

44

u64 limit = dmaobj->base.limit >> 8;

drivers/gpu/drm/nouveau/nvkm/engine/dma/usergv100.c

53

nvkm_wo32(*pgpuobj, 0x0c, lower_32_bits(limit));

drivers/gpu/drm/nouveau/nvkm/engine/dma/usergv100.c

54

nvkm_wo32(*pgpuobj, 0x10, upper_32_bits(limit));

drivers/gpu/drm/nouveau/nvkm/engine/dma/usernv04.c

48

u32 length = dmaobj->base.limit - dmaobj->base.start;

drivers/gpu/drm/nouveau/nvkm/engine/dma/usernv50.c

52

nvkm_wo32(*pgpuobj, 0x04, lower_32_bits(dmaobj->base.limit));

drivers/gpu/drm/nouveau/nvkm/engine/dma/usernv50.c

54

nvkm_wo32(*pgpuobj, 0x0c, upper_32_bits(dmaobj->base.limit) << 24 |

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

149

falcon->code.limit = (caps & 0x000001ff) << 8;

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

150

falcon->data.limit = (caps & 0x0003fe00) >> 1;

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

154

nvkm_debug(subdev, "code limit: %d\n", falcon->code.limit);

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

155

nvkm_debug(subdev, "data limit: %d\n", falcon->data.limit);

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

274

if (falcon->code.size > falcon->code.limit ||

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

275

falcon->data.size > falcon->data.limit) {

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

299

for (; i < falcon->data.limit; i += 4)

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

305

for (; i < falcon->data.limit / 4; i++)

drivers/gpu/drm/nouveau/nvkm/engine/fifo/g84.c

110

u64 start = 0, limit = 0;

drivers/gpu/drm/nouveau/nvkm/engine/fifo/g84.c

140

limit = start + cctx->vctx->inst->size - 1;

drivers/gpu/drm/nouveau/nvkm/engine/fifo/g84.c

145

nvkm_wo32(chan->eng, ptr0 + 0x04, lower_32_bits(limit));

drivers/gpu/drm/nouveau/nvkm/engine/fifo/g84.c

147

nvkm_wo32(chan->eng, ptr0 + 0x0c, upper_32_bits(limit) << 24 |

drivers/gpu/drm/nouveau/nvkm/engine/fifo/nv50.c

154

u64 start = 0, limit = 0;

drivers/gpu/drm/nouveau/nvkm/engine/fifo/nv50.c

190

limit = start + cctx->vctx->inst->size - 1;

drivers/gpu/drm/nouveau/nvkm/engine/fifo/nv50.c

195

nvkm_wo32(chan->eng, ptr0 + 0x04, lower_32_bits(limit));

drivers/gpu/drm/nouveau/nvkm/engine/fifo/nv50.c

197

nvkm_wo32(chan->eng, ptr0 + 0x0c, upper_32_bits(limit) << 24 |

drivers/gpu/drm/nouveau/nvkm/engine/gr/nv10.c

1059

nvkm_wr32(device, NV10_PGRAPH_TLIMIT(i), tile->limit);

drivers/gpu/drm/nouveau/nvkm/engine/gr/nv20.c

159

nvkm_wr32(device, NV20_PGRAPH_TLIMIT(i), tile->limit);

drivers/gpu/drm/nouveau/nvkm/engine/gr/nv20.c

164

nvkm_wr32(device, NV10_PGRAPH_RDI_DATA, tile->limit);

drivers/gpu/drm/nouveau/nvkm/engine/gr/nv40.c

190

nvkm_wr32(device, NV20_PGRAPH_TLIMIT(i), tile->limit);

drivers/gpu/drm/nouveau/nvkm/engine/gr/nv40.c

193

nvkm_wr32(device, NV40_PGRAPH_TLIMIT1(i), tile->limit);

drivers/gpu/drm/nouveau/nvkm/engine/gr/nv40.c

215

nvkm_wr32(device, NV47_PGRAPH_TLIMIT(i), tile->limit);

drivers/gpu/drm/nouveau/nvkm/engine/gr/nv40.c

218

nvkm_wr32(device, NV40_PGRAPH_TLIMIT1(i), tile->limit);

drivers/gpu/drm/nouveau/nvkm/engine/gr/nv44.c

45

nvkm_wr32(device, NV20_PGRAPH_TLIMIT(i), tile->limit);

drivers/gpu/drm/nouveau/nvkm/engine/gr/nv44.c

54

nvkm_wr32(device, NV47_PGRAPH_TLIMIT(i), tile->limit);

drivers/gpu/drm/nouveau/nvkm/engine/gr/nv44.c

57

nvkm_wr32(device, NV40_PGRAPH_TLIMIT1(i), tile->limit);

drivers/gpu/drm/nouveau/nvkm/engine/gr/nv44.c

62

nvkm_wr32(device, NV20_PGRAPH_TLIMIT(i), tile->limit);

drivers/gpu/drm/nouveau/nvkm/engine/gr/nv44.c

65

nvkm_wr32(device, NV40_PGRAPH_TLIMIT1(i), tile->limit);

drivers/gpu/drm/nouveau/nvkm/engine/mpeg/nv31.c

119

nvkm_wr32(device, 0x00b004 + (i * 0x10), tile->limit);

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

274

falcon->code.limit = (reg & 0x1ff) << 8;

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

275

falcon->data.limit = (reg & 0x3fe00) >> 1;

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

291

IMEM, falcon->code.limit - fw->boot_size, fw->boot_size,

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

105

acr->func->wpr_check(acr, &start, &limit);

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

107

if (start != acr->wpr_start || limit != acr->wpr_end) {

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

110

acr->wpr_start, acr->wpr_end, start, limit);

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

93

u64 start, limit;

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

25

ga100_acr_wpr_check(struct nvkm_acr *acr, u64 *start, u64 *limit)

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

30

*limit = (u64)(nvkm_rd32(device, 0x1fa820) & 0xffffff00) << 8;

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

31

*limit = *limit + 0x20000;

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

53

gm200_acr_wpr_check(struct nvkm_acr *acr, u64 *start, u64 *limit)

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

60

*limit = (u64)(nvkm_rd32(device, 0x100cd4) & 0xffffff00) << 8;

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

61

*limit = *limit + 0x20000;

drivers/gpu/drm/nouveau/nvkm/subdev/acr/priv.h

28

void (*wpr_check)(struct nvkm_acr *, u64 *start, u64 *limit);

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

112

u64 start, limit, size;

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

133

limit = start + size;

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

135

ret = nvkm_vmm_new(device, start, limit-- - start, NULL, 0,

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

157

nvkm_wo32(bar->bar2, 0x04, lower_32_bits(limit));

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

159

nvkm_wo32(bar->bar2, 0x0c, upper_32_bits(limit) << 24 |

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

173

limit = start + size;

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

175

ret = nvkm_vmm_new(device, start, limit-- - start, NULL, 0,

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

193

nvkm_wo32(bar->bar1, 0x04, lower_32_bits(limit));

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

195

nvkm_wo32(bar->bar1, 0x0c, upper_32_bits(limit) << 24 |

drivers/gpu/drm/nouveau/nvkm/subdev/bios/shadow.c

41

const u32 limit = (upto + 3) & ~3;

drivers/gpu/drm/nouveau/nvkm/subdev/bios/shadow.c

44

if (nvbios_extend(bios, limit) > 0) {

drivers/gpu/drm/nouveau/nvkm/subdev/bios/shadow.c

45

u32 read = mthd->func->read(data, start, limit - start, bios);

drivers/gpu/drm/nouveau/nvkm/subdev/bios/shadowacpi.c

66

u32 limit = (offset + length + 0xfff) & ~0xfff;

drivers/gpu/drm/nouveau/nvkm/subdev/bios/shadowacpi.c

68

u32 fetch = limit - start;

drivers/gpu/drm/nouveau/nvkm/subdev/bios/shadowacpi.c

70

if (nvbios_extend(bios, limit) >= 0) {

drivers/gpu/drm/nouveau/nvkm/subdev/bios/shadowacpi.c

87

u32 limit = (offset + length + 0xfff) & ~0xfff;

drivers/gpu/drm/nouveau/nvkm/subdev/bios/shadowacpi.c

91

if (nvbios_extend(bios, limit) >= 0) {

drivers/gpu/drm/nouveau/nvkm/subdev/bios/shadowacpi.c

92

while (start + fetch < limit) {

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv10.c

34

tile->limit = max(1u, addr + size) - 1;

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv10.c

42

tile->limit = 0;

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv10.c

51

nvkm_wr32(device, 0x100244 + (i * 0x10), tile->limit);

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv20.c

34

tile->limit = max(1u, addr + size) - 1;

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv20.c

63

tile->limit = 0;

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv20.c

73

nvkm_wr32(device, 0x100244 + (i * 0x10), tile->limit);

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv30.c

44

tile->limit = max(1u, addr + size) - 1;

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv41.c

33

nvkm_wr32(device, 0x100604 + (i * 0x10), tile->limit);

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

35

tile->limit = max(1u, addr + size) - 1;

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

43

nvkm_wr32(device, 0x100604 + (i * 0x10), tile->limit);

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv46.c

39

tile->limit = max(1u, addr + size) - 1;

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

103

ctrl->limit = nvkm_memory_size(memory) - 1;

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

188

reg->base, reg->limit, reg->reserved, reg->performance,

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

194

const u64 size = (reg->limit + 1) - reg->base;

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

206

u32 rsvd_base = info->fbRegion[last_usable].limit + 1;

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/nvrm/disp.h

706

NV_DECLARE_ALIGNED(NvU64 limit, 8);

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/nvrm/gsp.h

19

NV_DECLARE_ALIGNED(NvU64 limit, 8);

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

66

ctrl->limit = nvkm_memory_size(memory) - 1;

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r570/nvrm/disp.h

302

NV_DECLARE_ALIGNED(NvU64 limit, 8);

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r570/nvrm/gsp.h

19

NV_DECLARE_ALIGNED(NvU64 limit, 8);

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

32

const u32 limit = first + count - 1;

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

34

BUG_ON((first > limit) || (limit >= ltc->num_tags));

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

37

ltc->func->cbc_clear(ltc, first, limit);

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

31

gf100_ltc_cbc_clear(struct nvkm_ltc *ltc, u32 start, u32 limit)

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

35

nvkm_wr32(device, 0x17e8d0, limit);

drivers/gpu/drm/nouveau/nvkm/subdev/ltc/gm107.c

30

gm107_ltc_cbc_clear(struct nvkm_ltc *ltc, u32 start, u32 limit)

drivers/gpu/drm/nouveau/nvkm/subdev/ltc/gm107.c

34

nvkm_wr32(device, 0x17e274, limit);

drivers/gpu/drm/nouveau/nvkm/subdev/ltc/priv.h

16

void (*cbc_clear)(struct nvkm_ltc *, u32 start, u32 limit);

drivers/gpu/drm/nouveau/nvkm/subdev/mmu/uvmm.c

586

args->v0.size = uvmm->vmm->limit;

drivers/gpu/drm/nouveau/nvkm/subdev/mmu/vmm.c

1070

const u64 limit = vmm->limit - vmm->start;

drivers/gpu/drm/nouveau/nvkm/subdev/mmu/vmm.c

1076

nvkm_vmm_ptes_put(vmm, page, vmm->start, limit);

drivers/gpu/drm/nouveau/nvkm/subdev/mmu/vmm.c

1177

vmm->limit = 1ULL << bits;

drivers/gpu/drm/nouveau/nvkm/subdev/mmu/vmm.c

1178

if (addr + size < addr || addr + size > vmm->limit)

drivers/gpu/drm/nouveau/nvkm/subdev/mmu/vmm.c

1198

size = vmm->limit - addr;

drivers/gpu/drm/nouveau/nvkm/subdev/mmu/vmm.c

1209

vmm->limit = size ? (addr + size) : (1ULL << bits);

drivers/gpu/drm/nouveau/nvkm/subdev/mmu/vmm.c

1210

if (vmm->start > vmm->limit || vmm->limit > (1ULL << bits))

drivers/gpu/drm/nouveau/nvkm/subdev/mmu/vmm.c

1213

if (!(vma = nvkm_vma_new(vmm->start, vmm->limit - vmm->start)))

drivers/gpu/drm/nouveau/nvkm/subdev/mmu/vmm.c

1262

u64 limit = addr + size;

drivers/gpu/drm/nouveau/nvkm/subdev/mmu/vmm.c

1272

size = min(limit - start, vma->size - (start - vma->addr));

drivers/gpu/drm/nouveau/nvkm/subdev/mmu/vmm.c

1283

} while ((vma = node(vma, next)) && (start = vma->addr) < limit);

drivers/gpu/drm/nouveau/nvkm/subdev/mmu/vmm.c

1298

u64 limit = addr + size;

drivers/gpu/drm/nouveau/nvkm/subdev/mmu/vmm.c

1312

addr + size < addr || addr + size > vmm->limit) {

drivers/gpu/drm/nouveau/nvkm/subdev/mmu/vmm.c

1324

u64 size = limit - start;

drivers/gpu/drm/nouveau/nvkm/subdev/mmu/vmm.c

1411

} while (vma && start < limit);

drivers/gpu/drm/nouveau/nvkm/subdev/mmu/vmm.c

1947

const u64 limit = vmm->limit - vmm->start;

drivers/gpu/drm/nouveau/nvkm/subdev/mmu/vmm.c

1953

ret = nvkm_vmm_ptes_get(vmm, page, vmm->start, limit);

drivers/gpu/drm/nouveau/nvkm/subdev/mmu/vmm.c

1957

nvkm_vmm_iter(vmm, page, vmm->start, limit, "bootstrap", false, false,

drivers/gpu/drm/nouveau/nvkm/subdev/mmu/vmmgf100.c

360

nvkm_wo64(inst, 0x0208, vmm->limit - 1);

drivers/gpu/drm/nouveau/nvkm/subdev/mmu/vmmnv04.c

138

nvkm_wo32(mem, 0x00004, vmm->limit - 1);

drivers/gpu/drm/nouveau/nvkm/subdev/mmu/vmmnv44.c

188

nvkm_wr32(device, 0x100814, vmm->limit - 4096);

drivers/gpu/drm/nouveau/nvkm/subdev/mmu/vmmnv50.c

355

for (pdei = vmm->start >> 29; pdei <= (vmm->limit - 1) >> 29; pdei++) {

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

103

.argv = lsfw->falcon->data.limit - sizeof(struct nv_pmu_args),

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

219

u32 addr_args = falcon->data.limit - sizeof(args);

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

47

if (wait->time1 - wait->time0 > wait->limit)

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

58

wait->limit = nsec;

drivers/gpu/drm/omapdrm/dss/dispc.c

4409

u32 limit = 0;

drivers/gpu/drm/omapdrm/dss/dispc.c

4413

&limit);

drivers/gpu/drm/omapdrm/dss/dispc.c

4415

return limit;

drivers/gpu/drm/radeon/ci_dpm.h

325

const u8 *src, u32 byte_count, u32 limit);

drivers/gpu/drm/radeon/ci_dpm.h

333

int ci_load_smc_ucode(struct radeon_device *rdev, u32 limit);

drivers/gpu/drm/radeon/ci_dpm.h

335

u32 smc_address, u32 *value, u32 limit);

drivers/gpu/drm/radeon/ci_dpm.h

337

u32 smc_address, u32 value, u32 limit);

drivers/gpu/drm/radeon/ci_smc.c

101

ret = ci_set_smc_sram_address(rdev, addr, limit);

drivers/gpu/drm/radeon/ci_smc.c

186

int ci_load_smc_ucode(struct radeon_device *rdev, u32 limit)

drivers/gpu/drm/radeon/ci_smc.c

247

u32 smc_address, u32 *value, u32 limit)

drivers/gpu/drm/radeon/ci_smc.c

253

ret = ci_set_smc_sram_address(rdev, smc_address, limit);

drivers/gpu/drm/radeon/ci_smc.c

262

u32 smc_address, u32 value, u32 limit)

drivers/gpu/drm/radeon/ci_smc.c

268

ret = ci_set_smc_sram_address(rdev, smc_address, limit);

drivers/gpu/drm/radeon/ci_smc.c

34

u32 smc_address, u32 limit)

drivers/gpu/drm/radeon/ci_smc.c

38

if ((smc_address + 3) > limit)

drivers/gpu/drm/radeon/ci_smc.c

49

const u8 *src, u32 byte_count, u32 limit)

drivers/gpu/drm/radeon/ci_smc.c

59

if ((smc_start_address + byte_count) > limit)

drivers/gpu/drm/radeon/ci_smc.c

69

ret = ci_set_smc_sram_address(rdev, addr, limit);

drivers/gpu/drm/radeon/ci_smc.c

84

ret = ci_set_smc_sram_address(rdev, addr, limit);

drivers/gpu/drm/radeon/kv_dpm.c

1900

static int kv_get_high_voltage_limit(struct radeon_device *rdev, int *limit)

drivers/gpu/drm/radeon/kv_dpm.c

1912

*limit = i;

drivers/gpu/drm/radeon/kv_dpm.c

1924

*limit = i;

drivers/gpu/drm/radeon/kv_dpm.c

1930

*limit = 0;

drivers/gpu/drm/radeon/kv_dpm.c

1942

int i, limit;

drivers/gpu/drm/radeon/kv_dpm.c

1994

kv_get_high_voltage_limit(rdev, &limit);

drivers/gpu/drm/radeon/kv_dpm.c

1995

ps->levels[i].sclk = table->entries[limit].clk;

drivers/gpu/drm/radeon/kv_dpm.c

2006

kv_get_high_voltage_limit(rdev, &limit);

drivers/gpu/drm/radeon/kv_dpm.c

2007

ps->levels[i].sclk = table->entries[limit].sclk_frequency;

drivers/gpu/drm/radeon/kv_dpm.h

193

u32 *value, u32 limit);

drivers/gpu/drm/radeon/kv_dpm.h

198

const u8 *src, u32 byte_count, u32 limit);

drivers/gpu/drm/radeon/kv_smc.c

119

const u8 *src, u32 byte_count, u32 limit)

drivers/gpu/drm/radeon/kv_smc.c

124

if ((smc_start_address + byte_count) > limit)

drivers/gpu/drm/radeon/kv_smc.c

134

ret = kv_set_smc_sram_address(rdev, addr, limit);

drivers/gpu/drm/radeon/kv_smc.c

160

ret = kv_set_smc_sram_address(rdev, addr, limit);

drivers/gpu/drm/radeon/kv_smc.c

173

ret = kv_set_smc_sram_address(rdev, addr, limit);

drivers/gpu/drm/radeon/kv_smc.c

188

ret = kv_set_smc_sram_address(rdev, addr, limit);

drivers/gpu/drm/radeon/kv_smc.c

206

ret = kv_set_smc_sram_address(rdev, addr, limit);

drivers/gpu/drm/radeon/kv_smc.c

75

u32 smc_address, u32 limit)

drivers/gpu/drm/radeon/kv_smc.c

79

if ((smc_address + 3) > limit)

drivers/gpu/drm/radeon/kv_smc.c

89

u32 *value, u32 limit)

drivers/gpu/drm/radeon/kv_smc.c

93

ret = kv_set_smc_sram_address(rdev, smc_address, limit);

drivers/gpu/drm/radeon/radeon_device.c

569

uint64_t limit = (uint64_t)radeon_vram_limit << 20;

drivers/gpu/drm/radeon/radeon_device.c

584

if (limit && limit < mc->real_vram_size)

drivers/gpu/drm/radeon/radeon_device.c

585

mc->real_vram_size = limit;

drivers/gpu/drm/radeon/rv770_smc.c

266

u16 smc_address, u16 limit)

drivers/gpu/drm/radeon/rv770_smc.c

272

if ((smc_address + 3) > limit)

drivers/gpu/drm/radeon/rv770_smc.c

285

u16 byte_count, u16 limit)

drivers/gpu/drm/radeon/rv770_smc.c

294

if ((smc_start_address + byte_count) > limit)

drivers/gpu/drm/radeon/rv770_smc.c

304

ret = rv770_set_smc_sram_address(rdev, addr, limit);

drivers/gpu/drm/radeon/rv770_smc.c

319

ret = rv770_set_smc_sram_address(rdev, addr, limit);

drivers/gpu/drm/radeon/rv770_smc.c

337

ret = rv770_set_smc_sram_address(rdev, addr, limit);

drivers/gpu/drm/radeon/rv770_smc.c

455

static void rv770_clear_smc_sram(struct radeon_device *rdev, u16 limit)

drivers/gpu/drm/radeon/rv770_smc.c

461

for (i = 0; i < limit; i += 4) {

drivers/gpu/drm/radeon/rv770_smc.c

462

rv770_set_smc_sram_address(rdev, i, limit);

drivers/gpu/drm/radeon/rv770_smc.c

469

u16 limit)

drivers/gpu/drm/radeon/rv770_smc.c

482

rv770_clear_smc_sram(rdev, limit);

drivers/gpu/drm/radeon/rv770_smc.c

578

ucode_data, ucode_size, limit);

drivers/gpu/drm/radeon/rv770_smc.c

592

u16 smc_address, u32 *value, u16 limit)

drivers/gpu/drm/radeon/rv770_smc.c

598

ret = rv770_set_smc_sram_address(rdev, smc_address, limit);

drivers/gpu/drm/radeon/rv770_smc.c

607

u16 smc_address, u32 value, u16 limit)

drivers/gpu/drm/radeon/rv770_smc.c

613

ret = rv770_set_smc_sram_address(rdev, smc_address, limit);

drivers/gpu/drm/radeon/rv770_smc.h

183

u16 byte_count, u16 limit);

drivers/gpu/drm/radeon/rv770_smc.h

192

u16 smc_address, u32 *value, u16 limit);

drivers/gpu/drm/radeon/rv770_smc.h

194

u16 smc_address, u32 value, u16 limit);

drivers/gpu/drm/radeon/rv770_smc.h

196

u16 limit);

drivers/gpu/drm/radeon/si_smc.c

100

ret = si_set_smc_sram_address(rdev, addr, limit);

drivers/gpu/drm/radeon/si_smc.c

211

int si_load_smc_ucode(struct radeon_device *rdev, u32 limit)

drivers/gpu/drm/radeon/si_smc.c

283

u32 *value, u32 limit)

drivers/gpu/drm/radeon/si_smc.c

289

ret = si_set_smc_sram_address(rdev, smc_address, limit);

drivers/gpu/drm/radeon/si_smc.c

298

u32 value, u32 limit)

drivers/gpu/drm/radeon/si_smc.c

304

ret = si_set_smc_sram_address(rdev, smc_address, limit);

drivers/gpu/drm/radeon/si_smc.c

34

u32 smc_address, u32 limit)

drivers/gpu/drm/radeon/si_smc.c

38

if ((smc_address + 3) > limit)

drivers/gpu/drm/radeon/si_smc.c

49

const u8 *src, u32 byte_count, u32 limit)

drivers/gpu/drm/radeon/si_smc.c

57

if ((smc_start_address + byte_count) > limit)

drivers/gpu/drm/radeon/si_smc.c

67

ret = si_set_smc_sram_address(rdev, addr, limit);

drivers/gpu/drm/radeon/si_smc.c

82

ret = si_set_smc_sram_address(rdev, addr, limit);

drivers/gpu/drm/radeon/sislands_smc.h

399

const u8 *src, u32 byte_count, u32 limit);

drivers/gpu/drm/radeon/sislands_smc.h

408

int si_load_smc_ucode(struct radeon_device *rdev, u32 limit);

drivers/gpu/drm/radeon/sislands_smc.h

410

u32 *value, u32 limit);

drivers/gpu/drm/radeon/sislands_smc.h

412

u32 value, u32 limit);

drivers/gpu/drm/tegra/drm.c

1050

tegra->carveout.limit, true);

drivers/gpu/drm/tegra/drm.c

1220

tegra->carveout.limit = carveout_end >> tegra->carveout.shift;

drivers/gpu/drm/tegra/drm.h

45

unsigned long limit;

drivers/gpu/drm/xe/tests/xe_bo.c

447

u64 ram, ram_and_swap, purgeable = 0, alloced, to_alloc, limit;

drivers/gpu/drm/xe/tests/xe_bo.c

460

limit = SZ_32G;

drivers/gpu/drm/xe/tests/xe_bo.c

463

limit = SZ_16G;

drivers/gpu/drm/xe/tests/xe_bo.c

467

if (ram > limit) {

drivers/gpu/drm/xe/xe_gt_sriov_pf_service.c

289

static int pf_service_runtime_query(struct xe_gt *gt, u32 start, u32 limit,

drivers/gpu/drm/xe/xe_gt_sriov_pf_service.c

303

count = min_t(u32, runtime->size - start, limit);

drivers/gpu/drm/xe/xe_gt_sriov_pf_service.c

321

u32 limit, start, max_chunks;

drivers/gpu/drm/xe/xe_gt_sriov_pf_service.c

336

limit = FIELD_GET(VF2PF_QUERY_RUNTIME_REQUEST_MSG_0_LIMIT, msg[0]);

drivers/gpu/drm/xe/xe_gt_sriov_pf_service.c

341

limit = limit == VF2PF_QUERY_RUNTIME_NO_LIMIT ? max_chunks : min_t(u32, max_chunks, limit);

drivers/gpu/drm/xe/xe_gt_sriov_pf_service.c

344

ret = pf_service_runtime_query(gt, start, limit, reg_data_buf, &remaining);

drivers/gpu/drm/xe/xe_gt_sriov_vf.c

935

u32 limit = (ARRAY_SIZE(response) - VF2PF_QUERY_RUNTIME_RESPONSE_MSG_MIN_LEN) / 2;

drivers/gpu/drm/xe/xe_gt_sriov_vf.c

941

xe_gt_assert(gt, limit);

drivers/gpu/drm/xe/xe_gt_sriov_vf.c

951

FIELD_PREP(VF2PF_QUERY_RUNTIME_REQUEST_MSG_0_LIMIT, limit);

drivers/gpu/drm/xe/xe_guc_id_mgr.c

76

int xe_guc_id_mgr_init(struct xe_guc_id_mgr *idm, unsigned int limit)

drivers/gpu/drm/xe/xe_guc_id_mgr.c

84

if (limit == ~0)

drivers/gpu/drm/xe/xe_guc_id_mgr.c

85

limit = GUC_ID_MAX;

drivers/gpu/drm/xe/xe_guc_id_mgr.c

86

else if (limit > GUC_ID_MAX)

drivers/gpu/drm/xe/xe_guc_id_mgr.c

88

else if (!limit)

drivers/gpu/drm/xe/xe_guc_id_mgr.c

91

idm->bitmap = bitmap_zalloc(limit, GFP_KERNEL);

drivers/gpu/drm/xe/xe_guc_id_mgr.c

94

idm->total = limit;

drivers/gpu/drm/xe/xe_hwmon.c

1032

*val = hwmon->temp.limit[TEMP_LIMIT_PKG_SHUTDOWN] * MILLIDEGREE_PER_DEGREE;

drivers/gpu/drm/xe/xe_hwmon.c

1036

*val = hwmon->temp.limit[TEMP_LIMIT_MEM_SHUTDOWN] * MILLIDEGREE_PER_DEGREE;

drivers/gpu/drm/xe/xe_hwmon.c

1046

*val = hwmon->temp.limit[TEMP_LIMIT_PKG_CRIT] * MILLIDEGREE_PER_DEGREE;

drivers/gpu/drm/xe/xe_hwmon.c

1050

*val = hwmon->temp.limit[TEMP_LIMIT_MEM_CRIT] * MILLIDEGREE_PER_DEGREE;

drivers/gpu/drm/xe/xe_hwmon.c

1058

*val = hwmon->temp.limit[TEMP_LIMIT_PKG_MAX] * MILLIDEGREE_PER_DEGREE;

drivers/gpu/drm/xe/xe_hwmon.c

141

u8 limit[TEMP_LIMIT_MAX];

drivers/gpu/drm/xe/xe_hwmon.c

940

return hwmon->temp.limit[TEMP_LIMIT_PKG_SHUTDOWN] ? 0444 : 0;

drivers/gpu/drm/xe/xe_hwmon.c

942

return hwmon->temp.limit[TEMP_LIMIT_MEM_SHUTDOWN] ? 0444 : 0;

drivers/gpu/drm/xe/xe_hwmon.c

948

hwmon->temp.limit[TEMP_LIMIT_MEM_SHUTDOWN]) ? 0444 : 0;

drivers/gpu/drm/xe/xe_hwmon.c

955

return hwmon->temp.limit[TEMP_LIMIT_PKG_CRIT] ? 0444 : 0;

drivers/gpu/drm/xe/xe_hwmon.c

957

return hwmon->temp.limit[TEMP_LIMIT_MEM_CRIT] ? 0444 : 0;

drivers/gpu/drm/xe/xe_hwmon.c

963

hwmon->temp.limit[TEMP_LIMIT_MEM_CRIT]) ? 0444 : 0;

drivers/gpu/drm/xe/xe_hwmon.c

970

return hwmon->temp.limit[TEMP_LIMIT_PKG_MAX] ? 0444 : 0;

drivers/gpu/drm/xe/xe_irq.c

934

struct xa_limit limit;

drivers/gpu/drm/xe/xe_irq.c

938

limit = (dynamic_msix) ? XA_LIMIT(NUM_OF_STATIC_MSIX, xe->irq.msix.nvec - 1) :

drivers/gpu/drm/xe/xe_irq.c

940

ret = xa_alloc(&xe->irq.msix.indexes, &id, irq_buf, limit, GFP_KERNEL);

drivers/gpu/drm/xe/xe_sriov_pf.c

30

static int pf_reduce_totalvfs(struct xe_device *xe, int limit)

drivers/gpu/drm/xe/xe_sriov_pf.c

36

err = pci_sriov_set_totalvfs(pdev, limit);

drivers/gpu/drm/xe/xe_sriov_pf.c

39

limit, ERR_PTR(err));

drivers/gpu/host1x/dev.c

154

{ /* SE1 */ .base = 0x1ac8, .offset = 0x90, .limit = 0x90 },

drivers/gpu/host1x/dev.c

155

{ /* SE2 */ .base = 0x1ad0, .offset = 0x90, .limit = 0x90 },

drivers/gpu/host1x/dev.c

156

{ /* SE3 */ .base = 0x1ad8, .offset = 0x90, .limit = 0x90 },

drivers/gpu/host1x/dev.c

157

{ /* SE4 */ .base = 0x1ae0, .offset = 0x90, .limit = 0x90 },

drivers/gpu/host1x/dev.c

158

{ /* ISP */ .base = 0x1ae8, .offset = 0x50, .limit = 0x50 },

drivers/gpu/host1x/dev.c

159

{ /* VIC */ .base = 0x1af0, .offset = 0x30, .limit = 0x34 },

drivers/gpu/host1x/dev.c

160

{ /* NVENC */ .base = 0x1af8, .offset = 0x30, .limit = 0x34 },

drivers/gpu/host1x/dev.c

161

{ /* NVDEC */ .base = 0x1b00, .offset = 0x30, .limit = 0x34 },

drivers/gpu/host1x/dev.c

162

{ /* NVJPG */ .base = 0x1b08, .offset = 0x30, .limit = 0x34 },

drivers/gpu/host1x/dev.c

163

{ /* TSEC */ .base = 0x1b10, .offset = 0x30, .limit = 0x34 },

drivers/gpu/host1x/dev.c

164

{ /* TSECB */ .base = 0x1b18, .offset = 0x30, .limit = 0x34 },

drivers/gpu/host1x/dev.c

165

{ /* VI 0 */ .base = 0x1b80, .offset = 0x10000, .limit = 0x10000 },

drivers/gpu/host1x/dev.c

166

{ /* VI 1 */ .base = 0x1b88, .offset = 0x20000, .limit = 0x20000 },

drivers/gpu/host1x/dev.c

167

{ /* VI 2 */ .base = 0x1b90, .offset = 0x30000, .limit = 0x30000 },

drivers/gpu/host1x/dev.c

168

{ /* VI 3 */ .base = 0x1b98, .offset = 0x40000, .limit = 0x40000 },

drivers/gpu/host1x/dev.c

169

{ /* VI 4 */ .base = 0x1ba0, .offset = 0x50000, .limit = 0x50000 },

drivers/gpu/host1x/dev.c

170

{ /* VI 5 */ .base = 0x1ba8, .offset = 0x60000, .limit = 0x60000 },

drivers/gpu/host1x/dev.c

171

{ /* VI 6 */ .base = 0x1bb0, .offset = 0x70000, .limit = 0x70000 },

drivers/gpu/host1x/dev.c

172

{ /* VI 7 */ .base = 0x1bb8, .offset = 0x80000, .limit = 0x80000 },

drivers/gpu/host1x/dev.c

173

{ /* VI 8 */ .base = 0x1bc0, .offset = 0x90000, .limit = 0x90000 },

drivers/gpu/host1x/dev.c

174

{ /* VI 9 */ .base = 0x1bc8, .offset = 0xa0000, .limit = 0xa0000 },

drivers/gpu/host1x/dev.c

175

{ /* VI 10 */ .base = 0x1bd0, .offset = 0xb0000, .limit = 0xb0000 },

drivers/gpu/host1x/dev.c

176

{ /* VI 11 */ .base = 0x1bd8, .offset = 0xc0000, .limit = 0xc0000 },

drivers/gpu/host1x/dev.c

196

{ /* SE1 */ .base = 0x1ac8, .offset = 0x90, .limit = 0x90 },

drivers/gpu/host1x/dev.c

197

{ /* SE2 */ .base = 0x1ad0, .offset = 0x90, .limit = 0x90 },

drivers/gpu/host1x/dev.c

198

{ /* SE3 */ .base = 0x1ad8, .offset = 0x90, .limit = 0x90 },

drivers/gpu/host1x/dev.c

199

{ /* SE4 */ .base = 0x1ae0, .offset = 0x90, .limit = 0x90 },

drivers/gpu/host1x/dev.c

200

{ /* ISP */ .base = 0x1ae8, .offset = 0x800, .limit = 0x800 },

drivers/gpu/host1x/dev.c

201

{ /* VIC */ .base = 0x1af0, .offset = 0x30, .limit = 0x34 },

drivers/gpu/host1x/dev.c

202

{ /* NVENC */ .base = 0x1af8, .offset = 0x30, .limit = 0x34 },

drivers/gpu/host1x/dev.c

203

{ /* NVDEC */ .base = 0x1b00, .offset = 0x30, .limit = 0x34 },

drivers/gpu/host1x/dev.c

204

{ /* NVJPG */ .base = 0x1b08, .offset = 0x30, .limit = 0x34 },

drivers/gpu/host1x/dev.c

205

{ /* TSEC */ .base = 0x1b10, .offset = 0x30, .limit = 0x34 },

drivers/gpu/host1x/dev.c

206

{ /* TSECB */ .base = 0x1b18, .offset = 0x30, .limit = 0x34 },

drivers/gpu/host1x/dev.c

207

{ /* VI */ .base = 0x1b80, .offset = 0x800, .limit = 0x800 },

drivers/gpu/host1x/dev.c

208

{ /* VI_THI */ .base = 0x1b88, .offset = 0x30, .limit = 0x34 },

drivers/gpu/host1x/dev.c

209

{ /* ISP_THI */ .base = 0x1b90, .offset = 0x30, .limit = 0x34 },

drivers/gpu/host1x/dev.c

210

{ /* PVA0_CLUSTER */ .base = 0x1b98, .offset = 0x0, .limit = 0x0 },

drivers/gpu/host1x/dev.c

211

{ /* PVA0_CLUSTER */ .base = 0x1ba0, .offset = 0x0, .limit = 0x0 },

drivers/gpu/host1x/dev.c

212

{ /* NVDLA0 */ .base = 0x1ba8, .offset = 0x30, .limit = 0x34 },

drivers/gpu/host1x/dev.c

213

{ /* NVDLA1 */ .base = 0x1bb0, .offset = 0x30, .limit = 0x34 },

drivers/gpu/host1x/dev.c

214

{ /* NVENC1 */ .base = 0x1bb8, .offset = 0x30, .limit = 0x34 },

drivers/gpu/host1x/dev.c

215

{ /* NVDEC1 */ .base = 0x1bc0, .offset = 0x30, .limit = 0x34 },

drivers/gpu/host1x/dev.c

240

{ /* SE1 MMIO */ .base = 0x1650, .offset = 0x90, .limit = 0x90 },

drivers/gpu/host1x/dev.c

241

{ /* SE1 ch */ .base = 0x1730, .offset = 0x90, .limit = 0x90 },

drivers/gpu/host1x/dev.c

242

{ /* SE2 MMIO */ .base = 0x1658, .offset = 0x90, .limit = 0x90 },

drivers/gpu/host1x/dev.c

243

{ /* SE2 ch */ .base = 0x1738, .offset = 0x90, .limit = 0x90 },

drivers/gpu/host1x/dev.c

244

{ /* SE4 MMIO */ .base = 0x1660, .offset = 0x90, .limit = 0x90 },

drivers/gpu/host1x/dev.c

245

{ /* SE4 ch */ .base = 0x1740, .offset = 0x90, .limit = 0x90 },

drivers/gpu/host1x/dev.c

246

{ /* ISP MMIO */ .base = 0x1680, .offset = 0x800, .limit = 0x800 },

drivers/gpu/host1x/dev.c

247

{ /* VIC MMIO */ .base = 0x1688, .offset = 0x34, .limit = 0x34 },

drivers/gpu/host1x/dev.c

248

{ /* VIC ch */ .base = 0x17b8, .offset = 0x30, .limit = 0x30 },

drivers/gpu/host1x/dev.c

249

{ /* NVENC MMIO */ .base = 0x1690, .offset = 0x34, .limit = 0x34 },

drivers/gpu/host1x/dev.c

250

{ /* NVENC ch */ .base = 0x17c0, .offset = 0x30, .limit = 0x30 },

drivers/gpu/host1x/dev.c

251

{ /* NVDEC MMIO */ .base = 0x1698, .offset = 0x34, .limit = 0x34 },

drivers/gpu/host1x/dev.c

252

{ /* NVDEC ch */ .base = 0x17c8, .offset = 0x30, .limit = 0x30 },

drivers/gpu/host1x/dev.c

253

{ /* NVJPG MMIO */ .base = 0x16a0, .offset = 0x34, .limit = 0x34 },

drivers/gpu/host1x/dev.c

254

{ /* NVJPG ch */ .base = 0x17d0, .offset = 0x30, .limit = 0x30 },

drivers/gpu/host1x/dev.c

255

{ /* TSEC MMIO */ .base = 0x16a8, .offset = 0x30, .limit = 0x34 },

drivers/gpu/host1x/dev.c

256

{ /* NVJPG1 MMIO */ .base = 0x16b0, .offset = 0x34, .limit = 0x34 },

drivers/gpu/host1x/dev.c

257

{ /* NVJPG1 ch */ .base = 0x17a8, .offset = 0x30, .limit = 0x30 },

drivers/gpu/host1x/dev.c

258

{ /* VI MMIO */ .base = 0x16b8, .offset = 0x800, .limit = 0x800 },

drivers/gpu/host1x/dev.c

259

{ /* VI_THI MMIO */ .base = 0x16c0, .offset = 0x30, .limit = 0x34 },

drivers/gpu/host1x/dev.c

260

{ /* ISP_THI MMIO */ .base = 0x16c8, .offset = 0x30, .limit = 0x34 },

drivers/gpu/host1x/dev.c

261

{ /* NVDLA MMIO */ .base = 0x16d8, .offset = 0x30, .limit = 0x34 },

drivers/gpu/host1x/dev.c

262

{ /* NVDLA ch */ .base = 0x17e0, .offset = 0x30, .limit = 0x34 },

drivers/gpu/host1x/dev.c

263

{ /* NVDLA1 MMIO */ .base = 0x16e0, .offset = 0x30, .limit = 0x34 },

drivers/gpu/host1x/dev.c

264

{ /* NVDLA1 ch */ .base = 0x17e8, .offset = 0x30, .limit = 0x34 },

drivers/gpu/host1x/dev.c

265

{ /* OFA MMIO */ .base = 0x16e8, .offset = 0x34, .limit = 0x34 },

drivers/gpu/host1x/dev.c

266

{ /* OFA ch */ .base = 0x1768, .offset = 0x30, .limit = 0x30 },

drivers/gpu/host1x/dev.c

267

{ /* VI2 MMIO */ .base = 0x16f0, .offset = 0x800, .limit = 0x800 },

drivers/gpu/host1x/dev.c

268

{ /* VI2_THI MMIO */ .base = 0x16f8, .offset = 0x30, .limit = 0x34 },

drivers/gpu/host1x/dev.c

315

host1x_hypervisor_writel(host, entry->limit, entry->base + 4);

drivers/gpu/host1x/dev.h

91

unsigned int limit;

drivers/hid/wacom_sys.c

588

int error = -ENOMEM, limit = 0;

drivers/hid/wacom_sys.c

615

limit++ < WAC_MSG_RETRIES);

drivers/hwmon/adt7x10.c

187

int limit, ret;

drivers/hwmon/adt7x10.c

194

limit = ADT7X10_REG_TO_TEMP(data, regval);

drivers/hwmon/adt7x10.c

197

regval = clamp_val(DIV_ROUND_CLOSEST(limit - hyst, 1000), 0,

drivers/hwmon/bt1-pvt.c

334

u32 data, limit, mask;

drivers/hwmon/bt1-pvt.c

351

limit = readl(pvt->regs + pvt_info[type].thres_base);

drivers/hwmon/bt1-pvt.c

353

limit = FIELD_GET(PVT_THRES_HI_MASK, limit);

drivers/hwmon/bt1-pvt.c

354

data = clamp_val(data, PVT_DATA_MIN, limit);

drivers/hwmon/bt1-pvt.c

358

limit = FIELD_GET(PVT_THRES_LO_MASK, limit);

drivers/hwmon/bt1-pvt.c

359

data = clamp_val(data, limit, PVT_DATA_MAX);

drivers/hwmon/emc1403.c

300

long limit;

drivers/hwmon/emc1403.c

302

ret = emc1403_get_temp(data, channel, map, &limit);

drivers/hwmon/emc1403.c

309

*val = limit + hyst * 1000;

drivers/hwmon/emc1403.c

311

*val = limit - hyst * 1000;

drivers/hwmon/emc1403.c

430

long limit;

drivers/hwmon/emc1403.c

437

ret = emc1403_get_temp(data, 0, temp_crit, &limit);

drivers/hwmon/emc1403.c

441

hyst = limit - val;

drivers/hwmon/k10temp.c

400

static void k10temp_get_ccd_support(struct k10temp_data *data, int limit)

drivers/hwmon/k10temp.c

405

for (i = 0; i < limit; i++) {

drivers/hwmon/lm85.c

1135

return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].limit) -

drivers/hwmon/lm85.c

1155

min = TEMP_FROM_REG(data->zone[nr].limit);

drivers/hwmon/lm85.c

1175

return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].limit));

drivers/hwmon/lm85.c

1193

data->zone[nr].limit = TEMP_TO_REG(val);

drivers/hwmon/lm85.c

1195

data->zone[nr].limit);

drivers/hwmon/lm85.c

1200

TEMP_FROM_REG(data->zone[nr].limit));

drivers/hwmon/lm85.c

1215

return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].limit) +

drivers/hwmon/lm85.c

1235

min = TEMP_FROM_REG(data->zone[nr].limit);

drivers/hwmon/lm85.c

265

s8 limit; /* Low temp limit */

drivers/hwmon/lm85.c

514

data->zone[i].limit =

drivers/hwmon/lm85.c

522

data->zone[i].limit -= 64;

drivers/hwmon/max16065.c

112

static inline int LIMIT_TO_MV(int limit, int range)

drivers/hwmon/max16065.c

114

return limit * range / 256;

drivers/hwmon/max16065.c

236

int limit;

drivers/hwmon/max16065.c

242

limit = MV_TO_LIMIT(val, data->range[attr2->index]);

drivers/hwmon/max16065.c

245

data->limit[attr2->nr][attr2->index]

drivers/hwmon/max16065.c

246

= LIMIT_TO_MV(limit, data->range[attr2->index]);

drivers/hwmon/max16065.c

249

limit);

drivers/hwmon/max16065.c

262

data->limit[attr2->nr][attr2->index]);

drivers/hwmon/max16065.c

561

data->limit[i][j] = LIMIT_TO_MV(val, data->range[j]);

drivers/hwmon/max16065.c

92

int limit[MAX16065_NUM_LIMIT][MAX16065_NUM_ADC];

drivers/hwmon/max197.c

101

data->limit : data->limit / 2;

drivers/hwmon/max197.c

124

int half = data->limit / 2;

drivers/hwmon/max197.c

125

int full = data->limit;

drivers/hwmon/max197.c

283

data->limit = MAX197_LIMIT;

drivers/hwmon/max197.c

286

data->limit = MAX199_LIMIT;

drivers/hwmon/max197.c

52

int limit;

drivers/hwmon/max6650.c

151

int limit = DAC_LIMIT(v12);

drivers/hwmon/max6650.c

153

return limit - (limit * pwm) / 255;

drivers/hwmon/nct7802.c

271

u8 reg_fan_high, unsigned long limit)

drivers/hwmon/nct7802.c

275

if (limit)

drivers/hwmon/nct7802.c

276

limit = DIV_ROUND_CLOSEST(1350000U, limit);

drivers/hwmon/nct7802.c

278

limit = 0x1fff;

drivers/hwmon/nct7802.c

279

limit = clamp_val(limit, 0, 0x1fff);

drivers/hwmon/nct7802.c

282

err = regmap_write(data->regmap, reg_fan_low, limit & 0xff);

drivers/hwmon/nct7802.c

286

err = regmap_write(data->regmap, reg_fan_high, (limit & 0x1f00) >> 5);

drivers/hwmon/pmbus/pmbus_core.c

1535

const struct pmbus_limit_attr *limit;/* limit registers */

drivers/hwmon/pmbus/pmbus_core.c

1551

const struct pmbus_limit_attr *l = attr->limit;

drivers/hwmon/pmbus/pmbus_core.c

1836

.limit = vin_limit_attrs,

drivers/hwmon/pmbus/pmbus_core.c

1845

.limit = vmon_limit_attrs,

drivers/hwmon/pmbus/pmbus_core.c

1861

.limit = vout_limit_attrs,

drivers/hwmon/pmbus/pmbus_core.c

1956

.limit = iin_limit_attrs,

drivers/hwmon/pmbus/pmbus_core.c

1967

.limit = iout_limit_attrs,

drivers/hwmon/pmbus/pmbus_core.c

2057

.limit = pin_limit_attrs,

drivers/hwmon/pmbus/pmbus_core.c

2067

.limit = pout_limit_attrs,

drivers/hwmon/pmbus/pmbus_core.c

2207

.limit = temp_limit_attrs,

drivers/hwmon/pmbus/pmbus_core.c

2219

.limit = temp_limit_attrs2,

drivers/hwmon/pmbus/pmbus_core.c

2231

.limit = temp_limit_attrs3,

drivers/hwmon/pmbus/stpddc60.c

42

static u8 stpddc60_get_offset(int vout, u16 limit, bool over)

drivers/hwmon/pmbus/stpddc60.c

48

l = (limit * 1000L) >> 8; /* Convert LINEAR to mv */

drivers/hwmon/sch5627.c

233

long limit = (value / 1000) + 64;

drivers/hwmon/sch5627.c

235

return clamp_val(limit, 0, U8_MAX);

drivers/hwmon/w83795.c

455

int i, limit;

drivers/hwmon/w83795.c

499

for (limit = TEMP_CRIT; limit <= TEMP_WARN_HYST; limit++)

drivers/hwmon/w83795.c

500

data->temp[i][limit] =

drivers/hwmon/w83795.c

501

w83795_read(client, W83795_REG_TEMP[i][limit]);

drivers/hwmon/w83795.c

506

for (limit = DTS_CRIT; limit <= DTS_WARN_HYST; limit++)

drivers/hwmon/w83795.c

507

data->dts_ext[limit] =

drivers/hwmon/w83795.c

508

w83795_read(client, W83795_REG_DTS_EXT(limit));

drivers/hwtracing/coresight/coresight-trbe.c

408

u64 limit = bufsize;

drivers/hwtracing/coresight/coresight-trbe.c

498

limit = round_down(tail, PAGE_SIZE);

drivers/hwtracing/coresight/coresight-trbe.c

515

limit = min(limit, round_up(wakeup, PAGE_SIZE));

drivers/hwtracing/coresight/coresight-trbe.c

545

if (limit > head)

drivers/hwtracing/coresight/coresight-trbe.c

546

return limit;

drivers/hwtracing/coresight/coresight-trbe.c

555

u64 limit = __trbe_normal_offset(handle);

drivers/hwtracing/coresight/coresight-trbe.c

566

while (limit && ((limit - head) < trbe_min_trace_buf_size(handle))) {

drivers/hwtracing/coresight/coresight-trbe.c

567

trbe_pad_buf(handle, limit - head);

drivers/hwtracing/coresight/coresight-trbe.c

568

limit = __trbe_normal_offset(handle);

drivers/hwtracing/coresight/coresight-trbe.c

571

return limit;

drivers/i2c/busses/i2c-qup.c

677

int ret = 0, limit = QUP_READ_LIMIT;

drivers/i2c/busses/i2c-qup.c

686

rem = msg->len - (blocks - 1) * limit;

drivers/i2c/busses/i2c-qup.c

690

tlen = (i == (blocks - 1)) ? rem : limit;

drivers/i2c/busses/i2c-qup.c

704

&msg->buf[limit * i],

drivers/i2c/busses/i2c-qup.c

722

tlen = (i == (blocks - 1)) ? rem : limit;

drivers/i2c/busses/i2c-qup.c

735

&msg->buf[limit * i],

drivers/idle/intel_idle.c

1744

int cstate, limit;

drivers/idle/intel_idle.c

1746

limit = min_t(int, min_t(int, CPUIDLE_STATE_MAX, max_cstate + 1),

drivers/idle/intel_idle.c

1749

for (cstate = 1; cstate < limit; cstate++) {

drivers/idle/intel_idle.c

1795

int cstate, limit = min_t(int, CPUIDLE_STATE_MAX, acpi_state_table.count);

drivers/idle/intel_idle.c

1801

for (cstate = 1; cstate < limit; cstate++) {

drivers/idle/intel_idle.c

1849

int cstate, limit;

drivers/idle/intel_idle.c

1858

limit = min_t(int, CPUIDLE_STATE_MAX, acpi_state_table.count);

drivers/idle/intel_idle.c

1863

for (cstate = 1; cstate < limit; cstate++) {

drivers/iio/adc/rohm-bd79124.c

473

unsigned int limit;

drivers/iio/adc/rohm-bd79124.c

483

limit = BD79124_HIGH_LIMIT_MAX;

drivers/iio/adc/rohm-bd79124.c

486

limit = BD79124_LOW_LIMIT_MIN;

drivers/iio/adc/rohm-bd79124.c

504

return bd79124_write_int_to_reg(data, reg, limit);

drivers/iio/adc/rohm-bd79124.c

513

u16 *limit;

drivers/iio/adc/rohm-bd79124.c

528

limit = &data->alarm_f_limit[channel];

drivers/iio/adc/rohm-bd79124.c

531

limit = &data->alarm_f_limit[channel];

drivers/iio/adc/rohm-bd79124.c

540

ret = bd79124_write_int_to_reg(data, reg, *limit);

drivers/iio/adc/rohm-bd79124.c

796

unsigned int limit)

drivers/iio/adc/rohm-bd79124.c

800

if (limit > BD79124_HIGH_LIMIT_MAX)

drivers/iio/adc/rohm-bd79124.c

803

ret = bd79124_write_int_to_reg(data, reg, limit);

drivers/infiniband/hw/hfi1/chip.c

11293

u16 limit)

drivers/infiniband/hw/hfi1/chip.c

11295

if (limit != 0)

drivers/infiniband/hw/hfi1/chip.c

11297

what, (int)limit, idx);

drivers/infiniband/hw/hfi1/chip.c

11301

static void set_global_shared(struct hfi1_devdata *dd, u16 limit)

drivers/infiniband/hw/hfi1/chip.c

11307

reg |= (u64)limit << SEND_CM_GLOBAL_CREDIT_SHARED_LIMIT_SHIFT;

drivers/infiniband/hw/hfi1/chip.c

11312

static void set_global_limit(struct hfi1_devdata *dd, u16 limit)

drivers/infiniband/hw/hfi1/chip.c

11318

reg |= (u64)limit << SEND_CM_GLOBAL_CREDIT_TOTAL_CREDIT_LIMIT_SHIFT;

drivers/infiniband/hw/hfi1/chip.c

11323

static void set_vl_shared(struct hfi1_devdata *dd, int vl, u16 limit)

drivers/infiniband/hw/hfi1/chip.c

11335

reg |= (u64)limit << SEND_CM_CREDIT_VL_SHARED_LIMIT_VL_SHIFT;

drivers/infiniband/hw/hfi1/chip.c

11340

static void set_vl_dedicated(struct hfi1_devdata *dd, int vl, u16 limit)

drivers/infiniband/hw/hfi1/chip.c

11352

reg |= (u64)limit << SEND_CM_CREDIT_VL_DEDICATED_LIMIT_VL_SHIFT;

drivers/infiniband/hw/ionic/ionic_ibdev.h

514

int limit,

drivers/infiniband/hw/ionic/ionic_pgtbl.c

106

int limit,

drivers/infiniband/hw/ionic/ionic_pgtbl.c

114

limit = ib_umem_num_dma_blocks(umem, page_size);

drivers/infiniband/hw/ionic/ionic_pgtbl.c

118

if (limit < 1)

drivers/infiniband/hw/ionic/ionic_pgtbl.c

121

buf->tbl_limit = limit;

drivers/infiniband/hw/ionic/ionic_pgtbl.c

124

if (limit > 1) {

drivers/infiniband/hw/mlx5/mlx5_ib.h

822

u32 limit;

drivers/infiniband/hw/mlx5/mr.c

360

target = ent->limit * 2;

drivers/infiniband/hw/mlx5/mr.c

404

if (target < ent->limit || target > ent->limit*2) {

drivers/infiniband/hw/mlx5/mr.c

458

ent->limit = var;

drivers/infiniband/hw/mlx5/mr.c

473

err = snprintf(lbuf, sizeof(lbuf), "%d\n", ent->limit);

drivers/infiniband/hw/mlx5/mr.c

497

ret = ent->mkeys_queue.ci < ent->limit;

drivers/infiniband/hw/mlx5/mr.c

519

if (ent->mkeys_queue.ci < ent->limit) {

drivers/infiniband/hw/mlx5/mr.c

523

ent->mkeys_queue.ci + ent->pending < 2 * ent->limit) {

drivers/infiniband/hw/mlx5/mr.c

529

} else if (ent->mkeys_queue.ci == 2 * ent->limit) {

drivers/infiniband/hw/mlx5/mr.c

531

} else if (ent->mkeys_queue.ci > 2 * ent->limit) {

drivers/infiniband/hw/mlx5/mr.c

568

ent->mkeys_queue.ci + ent->pending < 2 * ent->limit &&

drivers/infiniband/hw/mlx5/mr.c

590

} else if (ent->mkeys_queue.ci > 2 * ent->limit) {

drivers/infiniband/hw/mlx5/mr.c

925

ent->limit = dev->mdev->profile.mr_cache[order].limit;

drivers/infiniband/hw/mlx5/mr.c

927

ent->limit = 0;

drivers/infiniband/hw/mthca/mthca_cmd.c

1720

int mthca_ARM_SRQ(struct mthca_dev *dev, int srq_num, int limit)

drivers/infiniband/hw/mthca/mthca_cmd.c

1722

return mthca_cmd(dev, limit, srq_num, 0, CMD_ARM_SRQ,

drivers/infiniband/hw/mthca/mthca_cmd.h

307

int mthca_ARM_SRQ(struct mthca_dev *dev, int srq_num, int limit);

drivers/infiniband/sw/rdmavt/qp.c

2418

if (kwq->count < srq->limit) {

drivers/infiniband/sw/rdmavt/qp.c

2422

if (kwq->count < srq->limit) {

drivers/infiniband/sw/rdmavt/qp.c

2425

srq->limit = 0;

drivers/infiniband/sw/rdmavt/srq.c

142

attr->srq_limit : srq->limit) > attr->max_wr)

drivers/infiniband/sw/rdmavt/srq.c

221

srq->limit = attr->srq_limit;

drivers/infiniband/sw/rdmavt/srq.c

260

srq->limit = attr->srq_limit;

drivers/infiniband/sw/rdmavt/srq.c

285

attr->srq_limit = srq->limit;

drivers/infiniband/sw/rdmavt/srq.c

87

srq->limit = srq_init_attr->attr.srq_limit;

drivers/infiniband/sw/rxe/rxe_pool.c

110

pool->limit.min = info->min_index;

drivers/infiniband/sw/rxe/rxe_pool.c

111

pool->limit.max = info->max_index;

drivers/infiniband/sw/rxe/rxe_pool.c

141

err = xa_alloc_cyclic(&pool->xa, &elem->index, NULL, pool->limit,

drivers/infiniband/sw/rxe/rxe_pool.h

43

struct xa_limit limit;

drivers/infiniband/sw/rxe/rxe_resp.c

293

if (srq->limit && srq->ibsrq.event_handler && (count < srq->limit)) {

drivers/infiniband/sw/rxe/rxe_resp.c

294

srq->limit = 0;

drivers/infiniband/sw/rxe/rxe_srq.c

120

if (srq->limit && (attr->max_wr < srq->limit)) {

drivers/infiniband/sw/rxe/rxe_srq.c

122

attr->max_wr, srq->limit);

drivers/infiniband/sw/rxe/rxe_srq.c

180

srq->limit = attr->srq_limit;

drivers/infiniband/sw/rxe/rxe_srq.c

54

srq->limit = init->attr.srq_limit;

drivers/infiniband/sw/rxe/rxe_verbs.c

501

attr->srq_limit = srq->limit;

drivers/infiniband/sw/rxe/rxe_verbs.h

101

int limit;

drivers/infiniband/sw/siw/siw.h

245

u32 limit; /* low watermark for async event */

drivers/infiniband/sw/siw/siw_mem.c

62

struct xa_limit limit = XA_LIMIT(1, SIW_STAG_MAX_INDEX);

drivers/infiniband/sw/siw/siw_mem.c

80

if (xa_alloc_cyclic(&sdev->mem_xa, &id, mem, limit, &next,

drivers/infiniband/sw/siw/siw_qp_rx.c

387

u32 off = (srq->rq_get + srq->limit) %

drivers/infiniband/sw/siw/siw_verbs.c

1619

srq->limit = attrs->srq_limit;

drivers/infiniband/sw/siw/siw_verbs.c

1620

if (srq->limit)

drivers/infiniband/sw/siw/siw_verbs.c

1707

srq->limit = attrs->srq_limit;

drivers/infiniband/sw/siw/siw_verbs.c

1729

attrs->srq_limit = srq->limit;

drivers/input/serio/apbps2.c

105

int limit;

drivers/input/serio/apbps2.c

111

limit = 1024;

drivers/input/serio/apbps2.c

112

while ((ioread32be(&priv->regs->status) & APBPS2_STATUS_DR) && --limit)

drivers/input/serio/hp_sdc.c

355

int limit = 0;

drivers/input/serio/hp_sdc.c

587

if (!hp_sdc.ibf && limit++ < 20)

drivers/iommu/amd/init.c

362

u64 limit = (start + iommu->exclusion_length - 1) & PAGE_MASK;

drivers/iommu/amd/init.c

372

entry = limit;

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

602

u32 limit = BITS_PER_LONG;

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

610

limit = ebidx;

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

612

mask = GENMASK(limit - 1, sbidx);

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

629

llq.prod = queue_inc_prod_n(&llq, limit - sbidx);

drivers/iommu/iommufd/iommufd_test.h

139

__u32 limit;

drivers/iommu/iommufd/selftest.c

2147

if (cmd->memory_limit.limit <

drivers/iommu/iommufd/selftest.c

2150

iommufd_test_memory_limit = cmd->memory_limit.limit;

drivers/iommu/virtio-iommu.c

404

u64 limit = vdomain->domain.geometry.aperture_end;

drivers/iommu/virtio-iommu.c

409

limit = ALIGN_DOWN(limit + 1, granule) - 1;

drivers/iommu/virtio-iommu.c

415

if (resv_end < iova || resv_start > limit)

drivers/iommu/virtio-iommu.c

426

if (resv_end >= limit)

drivers/iommu/virtio-iommu.c

432

ret = viommu_add_mapping(vdomain, iova, limit, (phys_addr_t)iova,

drivers/isdn/mISDN/l1oip.h

61

int limit; /* limit number of bchannels */

drivers/isdn/mISDN/l1oip_core.c

1337

if (limit[l1oip_cnt])

drivers/isdn/mISDN/l1oip_core.c

1338

hc->b_num = limit[l1oip_cnt];

drivers/isdn/mISDN/l1oip_core.c

1353

"supported by application.\n", hc->limit);

drivers/isdn/mISDN/l1oip_core.c

242

static u_int limit[MAX_CARDS];

drivers/isdn/mISDN/l1oip_core.c

256

module_param_array(limit, uint, NULL, S_IRUGO | S_IWUSR);

drivers/leds/leds-cpcap.c

20

u16 limit;

drivers/leds/leds-cpcap.c

204

led->led.max_brightness = led->info->limit;

drivers/leds/leds-cpcap.c

28

.limit = 31,

drivers/leds/leds-cpcap.c

34

.limit = 31,

drivers/leds/leds-cpcap.c

40

.limit = 31,

drivers/leds/leds-cpcap.c

47

.limit = 1,

drivers/leds/leds-cpcap.c

56

.limit = 1,

drivers/md/dm-integrity.c

3471

unsigned long limit;

drivers/md/dm-integrity.c

3485

limit = ic->provided_data_sectors;

drivers/md/dm-integrity.c

3487

limit = le64_to_cpu(ic->sb->recalc_sector)

drivers/md/dm-integrity.c

3492

block_bitmap_op(ic, ic->journal, 0, limit, BITMAP_OP_CLEAR);

drivers/md/dm-integrity.c

3493

block_bitmap_op(ic, ic->may_write_bitmap, 0, limit, BITMAP_OP_CLEAR);

drivers/md/dm-integrity.c

717

unsigned int limit = e ? ic->journal_section_entries : ic->journal_section_sectors;

drivers/md/dm-integrity.c

720

unlikely(offset >= limit)) {

drivers/md/dm-integrity.c

722

function, section, offset, ic->journal_sections, limit);

drivers/md/dm-log-userspace-base.c

836

static unsigned long limit;

drivers/md/dm-log-userspace-base.c

852

else if (time_after(limit, jiffies))

drivers/md/dm-log-userspace-base.c

855

limit = jiffies + (HZ / 4);

drivers/md/dm-snap.c

1574

static int do_origin(struct dm_dev *origin, struct bio *bio, bool limit);

drivers/md/dm-snap.c

2547

static int do_origin(struct dm_dev *origin, struct bio *bio, bool limit)

drivers/md/dm-snap.c

2556

if (limit) {

drivers/md/dm-vdo/data-vio.c

1031

limiter->limit, limiter->max_busy,

drivers/md/dm-vdo/data-vio.c

1061

for (i = 0; i < pool->limiter.limit; i++) {

drivers/md/dm-vdo/data-vio.c

1087

return READ_ONCE(pool->limiter.limit);

drivers/md/dm-vdo/data-vio.c

132

data_vio_count_t limit;

drivers/md/dm-vdo/data-vio.c

622

data_vio_count_t available = limiter->limit - limiter->busy;

drivers/md/dm-vdo/data-vio.c

641

WRITE_ONCE(limiter->busy, limiter->limit - available);

drivers/md/dm-vdo/data-vio.c

765

assigner_fn assigner, data_vio_count_t limit)

drivers/md/dm-vdo/data-vio.c

769

limiter->limit = limit;

drivers/md/dm-vdo/data-vio.c

931

if (limiter->busy >= limiter->limit)

drivers/md/dm-vdo/indexer/io-factory.c

114

if (block_number < reader->limit) {

drivers/md/dm-vdo/indexer/io-factory.c

116

reader->limit - block_number);

drivers/md/dm-vdo/indexer/io-factory.c

157

.limit = block_count,

drivers/md/dm-vdo/indexer/io-factory.c

176

if (block_number >= reader->limit)

drivers/md/dm-vdo/indexer/io-factory.c

295

.limit = block_count,

drivers/md/dm-vdo/indexer/io-factory.c

317

if (writer->block_number >= writer->limit) {

drivers/md/dm-vdo/indexer/io-factory.c

34

sector_t limit;

drivers/md/dm-vdo/indexer/io-factory.c

50

sector_t limit;

drivers/md/dm-vdo/indexer/volume.c

1328

static void find_real_end_of_volume(struct volume *volume, u32 limit, u32 *limit_ptr)

drivers/md/dm-vdo/indexer/volume.c

1333

while (limit > 0) {

drivers/md/dm-vdo/indexer/volume.c

1334

u32 chapter = (span > limit) ? 0 : limit - span;

drivers/md/dm-vdo/indexer/volume.c

1339

limit = chapter;

drivers/md/dm-vdo/indexer/volume.c

1350

*limit_ptr = limit;

drivers/md/dm-zoned-metadata.c

585

unsigned long limit)

drivers/md/dm-zoned-metadata.c

595

count < limit) {

drivers/media/dvb-core/dvb_demux.c

236

u16 limit, seclen;

drivers/media/dvb-core/dvb_demux.c

258

limit = sec->tsfeedp;

drivers/media/dvb-core/dvb_demux.c

259

if (limit > DMX_MAX_SECFEED_SIZE)

drivers/media/dvb-core/dvb_demux.c

265

while (sec->secbufp + 2 < limit) {

drivers/media/dvb-core/dvb_demux.c

268

|| seclen + sec->secbufp > limit)

drivers/media/dvb-frontends/dvb-pll.c

605

if (frequency > desc->entries[i].limit)

drivers/media/dvb-frontends/dvb-pll.c

62

u32 limit;

drivers/media/i2c/ccs/ccs-core.c

101

linfo = &ccs_limits[ccs_limit_offsets[limit].info];

drivers/media/i2c/ccs/ccs-core.c

105

ccs_limit_offsets[limit + 1].lim))

drivers/media/i2c/ccs/ccs-core.c

108

*__ptr = sensor->ccs_limits + ccs_limit_offsets[limit].lim + offset;

drivers/media/i2c/ccs/ccs-core.c

114

unsigned int limit, unsigned int offset, u32 val)

drivers/media/i2c/ccs/ccs-core.c

121

ret = ccs_limit_ptr(sensor, limit, offset, &ptr);

drivers/media/i2c/ccs/ccs-core.c

125

linfo = &ccs_limits[ccs_limit_offsets[limit].info];

drivers/media/i2c/ccs/ccs-core.c

133

u32 ccs_get_limit(struct ccs_sensor *sensor, unsigned int limit,

drivers/media/i2c/ccs/ccs-core.c

140

ret = ccs_limit_ptr(sensor, limit, offset, &ptr);

drivers/media/i2c/ccs/ccs-core.c

144

switch (CCI_REG_WIDTH_BYTES(ccs_limits[ccs_limit_offsets[limit].info].reg)) {

drivers/media/i2c/ccs/ccs-core.c

159

return ccs_reg_conv(sensor, ccs_limits[limit].reg, val);

drivers/media/i2c/ccs/ccs-core.c

93

static int ccs_limit_ptr(struct ccs_sensor *sensor, unsigned int limit,

drivers/media/i2c/ccs/ccs-core.c

98

if (WARN_ON(limit >= CCS_L_LAST))

drivers/media/i2c/ccs/ccs.h

272

unsigned int limit, unsigned int offset, u32 val);

drivers/media/i2c/ccs/ccs.h

273

u32 ccs_get_limit(struct ccs_sensor *sensor, unsigned int limit,

drivers/media/i2c/ccs/ccs.h

59

#define CCS_LIM(sensor, limit) \

drivers/media/i2c/ccs/ccs.h

60

ccs_get_limit(sensor, CCS_L_##limit, 0)

drivers/media/i2c/ccs/ccs.h

62

#define CCS_LIM_AT(sensor, limit, offset) \

drivers/media/i2c/ccs/ccs.h

63

ccs_get_limit(sensor, CCS_L_##limit, CCS_L_##limit##_OFFSET(offset))

drivers/media/pci/mgb4/mgb4_sysfs_out.c

248

int limit, ret;

drivers/media/pci/mgb4/mgb4_sysfs_out.c

254

limit = val ? MGB4_HW_FREQ / val : 0;

drivers/media/pci/mgb4/mgb4_sysfs_out.c

256

voutdev->config->regs.frame_limit, limit);

drivers/media/platform/mediatek/mdp3/mtk-mdp3-m2m.c

158

ctx->curr_param.limit);

drivers/media/platform/mediatek/mdp3/mtk-mdp3-m2m.c

569

const struct mdp_limit *limit = mdp->mdp_data->def_limit;

drivers/media/platform/mediatek/mdp3/mtk-mdp3-m2m.c

616

default_format.fmt.pix_mp.width = limit->out_limit.wmin;

drivers/media/platform/mediatek/mdp3/mtk-mdp3-m2m.c

617

default_format.fmt.pix_mp.height = limit->out_limit.hmin;

drivers/media/platform/mediatek/mdp3/mtk-mdp3-regs.c

164

pix_limit = V4L2_TYPE_IS_OUTPUT(f->type) ? &param->limit->out_limit :

drivers/media/platform/mediatek/mdp3/mtk-mdp3-regs.c

165

&param->limit->cap_limit;

drivers/media/platform/mediatek/mdp3/mtk-mdp3-regs.c

285

const struct mdp_limit *limit)

drivers/media/platform/mediatek/mdp3/mtk-mdp3-regs.c

299

if ((crop_w / comp_w) > limit->h_scale_down_max ||

drivers/media/platform/mediatek/mdp3/mtk-mdp3-regs.c

300

(crop_h / comp_h) > limit->v_scale_down_max ||

drivers/media/platform/mediatek/mdp3/mtk-mdp3-regs.c

301

(comp_w / crop_w) > limit->h_scale_up_max ||

drivers/media/platform/mediatek/mdp3/mtk-mdp3-regs.c

302

(comp_h / crop_h) > limit->v_scale_up_max)

drivers/media/platform/mediatek/mdp3/mtk-mdp3-regs.c

489

param->limit = mdp->mdp_data->def_limit;

drivers/media/platform/mediatek/mdp3/mtk-mdp3-regs.h

345

const struct mdp_limit *limit;

drivers/media/platform/mediatek/mdp3/mtk-mdp3-regs.h

370

const struct mdp_limit *limit);

drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-bytecap.c

154

u32 limit;

drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-bytecap.c

538

vcap->count.limit, vcap->count.nactive,

drivers/media/platform/st/stm32/stm32-dcmipp/dcmipp-bytecap.c

736

vcap->count.limit++;

drivers/media/platform/ti/omap3isp/ispresizer.c

504

unsigned long limit = min(pipe->l3_ick, 200000000UL);

drivers/media/platform/ti/omap3isp/ispresizer.c

507

clock = div_u64((u64)limit * res->crop.active.height, ofmt->height);

drivers/media/platform/ti/omap3isp/ispresizer.c

508

clock = min(clock, limit / 2);

drivers/media/tuners/tda18271-maps.c

947

u16 limit;

drivers/media/tuners/tda18271-maps.c

951

{ .rfmax = 46000, .target = 0x04, .limit = 1800 },

drivers/media/tuners/tda18271-maps.c

952

{ .rfmax = 52200, .target = 0x0a, .limit = 1500 },

drivers/media/tuners/tda18271-maps.c

953

{ .rfmax = 70100, .target = 0x01, .limit = 4000 },

drivers/media/tuners/tda18271-maps.c

954

{ .rfmax = 136800, .target = 0x18, .limit = 4000 },

drivers/media/tuners/tda18271-maps.c

955

{ .rfmax = 156700, .target = 0x18, .limit = 4000 },

drivers/media/tuners/tda18271-maps.c

956

{ .rfmax = 186250, .target = 0x0a, .limit = 4000 },

drivers/media/tuners/tda18271-maps.c

957

{ .rfmax = 230000, .target = 0x0a, .limit = 4000 },

drivers/media/tuners/tda18271-maps.c

958

{ .rfmax = 345000, .target = 0x18, .limit = 4000 },

drivers/media/tuners/tda18271-maps.c

959

{ .rfmax = 426000, .target = 0x0e, .limit = 4000 },

drivers/media/tuners/tda18271-maps.c

960

{ .rfmax = 489500, .target = 0x1e, .limit = 4000 },

drivers/media/tuners/tda18271-maps.c

961

{ .rfmax = 697500, .target = 0x32, .limit = 4000 },

drivers/media/tuners/tda18271-maps.c

962

{ .rfmax = 842000, .target = 0x3a, .limit = 4000 },

drivers/media/tuners/tda18271-maps.c

963

{ .rfmax = 0, .target = 0x00, .limit = 0 }, /* end */

drivers/media/tuners/tda18271-maps.c

978

*count_limit = tda18271_cid_target[i].limit;

drivers/media/tuners/tda18271-maps.c

981

tda18271_cid_target[i].target, tda18271_cid_target[i].limit);

drivers/media/tuners/tuner-simple.c

267

if (*frequency > t_params->ranges[i].limit)

drivers/media/tuners/tuner-simple.c

273

*frequency, t_params->ranges[i - 1].limit);

drivers/media/tuners/tuner-simple.c

274

*frequency = t_params->ranges[--i].limit;

drivers/media/v4l2-core/v4l2-ctrls-core.c

687

s32 limit = segmentation_feature_max[j];

drivers/media/v4l2-core/v4l2-ctrls-core.c

690

if (s->feature_data[i][j] < -limit ||

drivers/media/v4l2-core/v4l2-ctrls-core.c

691

s->feature_data[i][j] > limit)

drivers/media/v4l2-core/v4l2-ctrls-core.c

694

if (s->feature_data[i][j] < 0 || s->feature_data[i][j] > limit)

drivers/misc/mei/gsc-me.c

39

u32 limit = (resource_size(mem) / SZ_4K) | GSC_EXT_OP_MEM_VALID;

drivers/misc/mei/gsc-me.c

43

iowrite32(limit, hw->mem_addr + H_GSC_EXT_OP_MEM_LIMIT_REG);

drivers/misc/mei/main.c

1062

u8 limit;

drivers/misc/mei/main.c

1071

limit = inp;

drivers/misc/mei/main.c

1074

dev->tx_queue_limit = limit;

drivers/misc/sgi-gru/gru_instructions.h

296

unsigned int limit;

drivers/misc/sgi-gru/gru_instructions.h

593

static inline union gru_mesqhead gru_mesq_head(int head, int limit)

drivers/misc/sgi-gru/gru_instructions.h

598

mqh.limit = limit;

drivers/misc/sgi-gru/grukservices.c

120

void *limit;

drivers/misc/sgi-gru/grukservices.c

554

mq->limit = &mq->data + (qlines - 2) * GRU_CACHE_LINE_BYTES;

drivers/misc/sgi-gru/grukservices.c

639

unsigned int limit, head;

drivers/misc/sgi-gru/grukservices.c

646

limit = gru_get_amo_value_limit(cb);

drivers/misc/sgi-gru/grukservices.c

649

half = (limit != qlines);

drivers/misc/sgi-gru/grukservices.c

666

if (head != limit) {

drivers/misc/sgi-gru/grukservices.c

849

if (next == mq->limit) {

drivers/misc/sgi-gru/grumain.c

110

if (asid >= limit) {

drivers/misc/sgi-gru/grumain.c

115

limit = MAX_ASID;

drivers/misc/sgi-gru/grumain.c

122

if ((inuse_asid > asid) && (inuse_asid < limit))

drivers/misc/sgi-gru/grumain.c

123

limit = inuse_asid;

drivers/misc/sgi-gru/grumain.c

125

gru->gs_asid_limit = limit;

drivers/misc/sgi-gru/grumain.c

128

asid, limit);

drivers/misc/sgi-gru/grumain.c

91

int i, gid, inuse_asid, limit;

drivers/misc/sgi-gru/grumain.c

95

limit = MAX_ASID;

drivers/misc/sgi-gru/grumain.c

96

if (asid >= limit)

drivers/misc/vmw_balloon.c

629

unsigned long limit;

drivers/misc/vmw_balloon.c

631

limit = totalram_pages();

drivers/misc/vmw_balloon.c

635

limit != (u32)limit)

drivers/misc/vmw_balloon.c

638

status = vmballoon_cmd(b, VMW_BALLOON_CMD_GET_TARGET, limit, 0);

drivers/mmc/core/mmc_test.c

337

unsigned long limit = nr_free_buffer_pages() >> 4;

drivers/mmc/core/mmc_test.c

340

if (max_page_cnt > limit)

drivers/mmc/core/mmc_test.c

341

max_page_cnt = limit;

drivers/mmc/host/cb710-mmc.c

149

unsigned limit = 2000000; /* FIXME: real timeout */

drivers/mmc/host/cb710-mmc.c

157

if (!--limit) {

drivers/mmc/host/cb710-mmc.c

169

limit = 2000000 - limit;

drivers/mmc/host/cb710-mmc.c

170

if (limit > 100)

drivers/mmc/host/cb710-mmc.c

173

limit, what, e, x);

drivers/mmc/host/cb710-mmc.c

181

unsigned limit = 500000; /* FIXME: real timeout */

drivers/mmc/host/cb710-mmc.c

190

if (!--limit) {

drivers/mmc/host/cb710-mmc.c

202

limit = 500000 - limit;

drivers/mmc/host/cb710-mmc.c

203

if (limit > 100)

drivers/mmc/host/cb710-mmc.c

206

limit, mask, e, x);

drivers/mmc/host/omap_hsmmc.c

973

unsigned long limit = MMC_TIMEOUT_US;

drivers/mmc/host/omap_hsmmc.c

984

&& (i++ < limit))

drivers/mmc/host/omap_hsmmc.c

990

(i++ < limit))

drivers/mmc/host/sdhci-omap.c

845

unsigned long limit = MMC_TIMEOUT_US;

drivers/mmc/host/sdhci-omap.c

860

(i++ < limit))

drivers/mmc/host/sdhci-omap.c

864

(i++ < limit))

drivers/mtd/devices/mtd_intel_dg.c

443

u32 address, base, limit, region;

drivers/mtd/devices/mtd_intel_dg.c

450

limit = (FIELD_GET(NVM_FREG_ADDR_MASK, region) << NVM_FREG_ADDR_SHIFT) |

drivers/mtd/devices/mtd_intel_dg.c

454

id, nvm->regions[i].name, region, base, limit);

drivers/mtd/devices/mtd_intel_dg.c

456

if (base >= limit || (i > 0 && limit == 0)) {

drivers/mtd/devices/mtd_intel_dg.c

463

if (nvm->size < limit)

drivers/mtd/devices/mtd_intel_dg.c

464

nvm->size = limit;

drivers/mtd/devices/mtd_intel_dg.c

467

nvm->regions[i].size = limit - base + 1;

drivers/mtd/nand/raw/brcmnand/brcmnand.c

1161

unsigned long limit;

drivers/mtd/nand/raw/brcmnand/brcmnand.c

1167

limit = jiffies + msecs_to_jiffies(timeout_ms);

drivers/mtd/nand/raw/brcmnand/brcmnand.c

1177

} while (time_after(limit, jiffies));

drivers/mtd/nand/raw/marvell_nand.c

711

unsigned long limit;

drivers/mtd/nand/raw/marvell_nand.c

714

limit = jiffies + msecs_to_jiffies(timeout_ms);

drivers/mtd/nand/raw/marvell_nand.c

724

} while (time_after(limit, jiffies));

drivers/mtd/nand/raw/omap2.c

317

unsigned long tim, limit;

drivers/mtd/nand/raw/omap2.c

348

limit = (loops_per_jiffy *

drivers/mtd/nand/raw/omap2.c

354

} while (val && (tim++ < limit));

drivers/mtd/nand/raw/omap2.c

386

unsigned long tim, limit;

drivers/mtd/nand/raw/omap2.c

426

limit = (loops_per_jiffy * msecs_to_jiffies(OMAP_NAND_TIMEOUT_MS));

drivers/mtd/nand/raw/omap2.c

432

} while (val && (tim++ < limit));

drivers/mtd/nand/raw/omap2.c

595

unsigned long tim, limit;

drivers/mtd/nand/raw/omap2.c

626

limit = (loops_per_jiffy * msecs_to_jiffies(OMAP_NAND_TIMEOUT_MS));

drivers/mtd/nand/raw/omap2.c

631

} while (val && (tim++ < limit));

drivers/mtd/ubi/build.c

549

int limit, device_pebs;

drivers/mtd/ubi/build.c

558

limit = mtd_max_bad_blocks(ubi->mtd, 0, ubi->mtd->size);

drivers/mtd/ubi/build.c

559

if (limit < 0)

drivers/mtd/ubi/build.c

561

return limit;

drivers/mtd/ubi/build.c

575

limit = mult_frac(device_pebs, max_beb_per1024, 1024);

drivers/mtd/ubi/build.c

578

if (mult_frac(limit, 1024, max_beb_per1024) < device_pebs)

drivers/mtd/ubi/build.c

579

limit += 1;

drivers/mtd/ubi/build.c

581

return limit;

drivers/net/ethernet/aeroflex/greth.c

72

static int greth_rx(struct net_device *dev, int limit);

drivers/net/ethernet/aeroflex/greth.c

73

static int greth_rx_gbit(struct net_device *dev, int limit);

drivers/net/ethernet/aeroflex/greth.c

739

static int greth_rx(struct net_device *dev, int limit)

drivers/net/ethernet/aeroflex/greth.c

751

for (count = 0; count < limit; ++count) {

drivers/net/ethernet/aeroflex/greth.c

855

static int greth_rx_gbit(struct net_device *dev, int limit)

drivers/net/ethernet/aeroflex/greth.c

867

for (count = 0; count < limit; ++count) {

drivers/net/ethernet/agere/et131x.c

1833

static inline u32 bump_free_buff_ring(u32 *free_buff_ring, u32 limit)

drivers/net/ethernet/agere/et131x.c

1843

if ((tmp_free_buff_ring & ET_DMA10_MASK) > limit) {

drivers/net/ethernet/agere/et131x.c

2296

int limit = budget;

drivers/net/ethernet/agere/et131x.c

2301

limit = MAX_PACKETS_HANDLED;

drivers/net/ethernet/agere/et131x.c

2304

while (count < limit) {

drivers/net/ethernet/agere/et131x.c

2334

if (count == limit || !done) {

drivers/net/ethernet/altera/altera_tse_main.c

351

static int tse_rx(struct altera_tse_private *priv, int limit)

drivers/net/ethernet/altera/altera_tse_main.c

366

while ((count < limit) &&

drivers/net/ethernet/amazon/ena/ena_devlink.c

106

enum devlink_reload_limit limit,

drivers/net/ethernet/amazon/ena/ena_devlink.c

84

enum devlink_reload_limit limit,

drivers/net/ethernet/atheros/ag71xx.c

1604

static int ag71xx_rx_packets(struct ag71xx *ag, int limit)

drivers/net/ethernet/atheros/ag71xx.c

1620

limit, ring->curr, ring->dirty);

drivers/net/ethernet/atheros/ag71xx.c

1622

while (done < limit) {

drivers/net/ethernet/atheros/ag71xx.c

1678

static int ag71xx_poll(struct napi_struct *napi, int limit)

drivers/net/ethernet/atheros/ag71xx.c

1687

tx_done = ag71xx_tx_packets(ag, false, limit);

drivers/net/ethernet/atheros/ag71xx.c

1690

rx_done = ag71xx_rx_packets(ag, limit);

drivers/net/ethernet/atheros/ag71xx.c

1704

if (rx_done < limit) {

drivers/net/ethernet/atheros/ag71xx.c

1713

rx_done, tx_done, limit);

drivers/net/ethernet/atheros/ag71xx.c

1724

rx_done, tx_done, limit);

drivers/net/ethernet/atheros/ag71xx.c

1725

return limit;

drivers/net/ethernet/broadcom/bcm63xx_enet.c

1144

int limit;

drivers/net/ethernet/broadcom/bcm63xx_enet.c

1151

limit = 1000;

drivers/net/ethernet/broadcom/bcm63xx_enet.c

1159

} while (limit--);

drivers/net/ethernet/broadcom/bcm63xx_enet.c

1167

int limit;

drivers/net/ethernet/broadcom/bcm63xx_enet.c

1171

limit = 1000;

drivers/net/ethernet/broadcom/bcm63xx_enet.c

1179

} while (limit--);

drivers/net/ethernet/broadcom/bcm63xx_enet.c

126

int limit;

drivers/net/ethernet/broadcom/bcm63xx_enet.c

135

limit = 1000;

drivers/net/ethernet/broadcom/bcm63xx_enet.c

140

} while (limit-- > 0);

drivers/net/ethernet/broadcom/bcm63xx_enet.c

142

return (limit < 0) ? 1 : 0;

drivers/net/ethernet/broadcom/bcm63xx_enet.c

1664

int limit;

drivers/net/ethernet/broadcom/bcm63xx_enet.c

1674

limit = 1000;

drivers/net/ethernet/broadcom/bcm63xx_enet.c

1680

} while (limit--);

drivers/net/ethernet/broadcom/bnxt/bnxt_devlink.c

427

enum devlink_reload_limit limit,

drivers/net/ethernet/broadcom/bnxt/bnxt_devlink.c

469

if (limit == DEVLINK_RELOAD_LIMIT_NO_RESET)

drivers/net/ethernet/broadcom/bnxt/bnxt_devlink.c

510

enum devlink_reload_limit limit, u32 *actions_performed,

drivers/net/ethernet/broadcom/bnxt/bnxt_devlink.c

535

if (limit == DEVLINK_RELOAD_LIMIT_NO_RESET)

drivers/net/ethernet/broadcom/tg3.c

10794

limit = 8;

drivers/net/ethernet/broadcom/tg3.c

10796

limit = 16;

drivers/net/ethernet/broadcom/tg3.c

10798

limit -= 4;

drivers/net/ethernet/broadcom/tg3.c

10799

switch (limit) {

drivers/net/ethernet/broadcom/tg3.c

1355

int limit, err;

drivers/net/ethernet/broadcom/tg3.c

1365

limit = 5000;

drivers/net/ethernet/broadcom/tg3.c

1366

while (limit--) {

drivers/net/ethernet/broadcom/tg3.c

1377

if (limit < 0)

drivers/net/ethernet/broadcom/tg3.c

2443

int limit = 100;

drivers/net/ethernet/broadcom/tg3.c

2445

while (limit--) {

drivers/net/ethernet/broadcom/tg3.c

2453

if (limit < 0)

drivers/net/ethernet/broadcom/tg3.c

8774

unsigned int i, limit;

drivers/net/ethernet/broadcom/tg3.c

8776

limit = tp->rxq_cnt;

drivers/net/ethernet/broadcom/tg3.c

8782

limit++;

drivers/net/ethernet/broadcom/tg3.c

8784

for (i = 0; i < limit; i++) {

drivers/net/ethernet/broadcom/tg3.c

9560

u32 limit = tp->rxq_cnt;

drivers/net/ethernet/broadcom/tg3.c

9566

limit--;

drivers/net/ethernet/broadcom/tg3.c

9573

for (; i < limit; i++) {

drivers/net/ethernet/broadcom/tg3.c

9612

u32 txrcb, limit;

drivers/net/ethernet/broadcom/tg3.c

9616

limit = NIC_SRAM_SEND_RCB + TG3_BDINFO_SIZE * 16;

drivers/net/ethernet/broadcom/tg3.c

9618

limit = NIC_SRAM_SEND_RCB + TG3_BDINFO_SIZE * 4;

drivers/net/ethernet/broadcom/tg3.c

9621

limit = NIC_SRAM_SEND_RCB + TG3_BDINFO_SIZE * 2;

drivers/net/ethernet/broadcom/tg3.c

9623

limit = NIC_SRAM_SEND_RCB + TG3_BDINFO_SIZE;

drivers/net/ethernet/broadcom/tg3.c

9626

txrcb < limit; txrcb += TG3_BDINFO_SIZE)

drivers/net/ethernet/broadcom/tg3.c

9655

u32 rxrcb, limit;

drivers/net/ethernet/broadcom/tg3.c

9659

limit = NIC_SRAM_RCV_RET_RCB + TG3_BDINFO_SIZE * 17;

drivers/net/ethernet/broadcom/tg3.c

9661

limit = NIC_SRAM_RCV_RET_RCB + TG3_BDINFO_SIZE * 16;

drivers/net/ethernet/broadcom/tg3.c

9665

limit = NIC_SRAM_RCV_RET_RCB + TG3_BDINFO_SIZE * 4;

drivers/net/ethernet/broadcom/tg3.c

9667

limit = NIC_SRAM_RCV_RET_RCB + TG3_BDINFO_SIZE;

drivers/net/ethernet/broadcom/tg3.c

9670

rxrcb < limit; rxrcb += TG3_BDINFO_SIZE)

drivers/net/ethernet/broadcom/tg3.c

9947

int i, err, limit;

drivers/net/ethernet/calxeda/xgmac.c

1164

static int xgmac_rx(struct xgmac_priv *priv, int limit)

drivers/net/ethernet/calxeda/xgmac.c

1170

while (count < limit) {

drivers/net/ethernet/calxeda/xgmac.c

943

int limit;

drivers/net/ethernet/calxeda/xgmac.c

953

limit = 15000;

drivers/net/ethernet/calxeda/xgmac.c

954

while (limit-- &&

drivers/net/ethernet/calxeda/xgmac.c

957

if (limit < 0)

drivers/net/ethernet/chelsio/cxgb4/cudbg_entity.h

107

u32 limit;

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

1203

if (!(meminfo->mem[i].limit))

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

1204

meminfo->mem[i].limit =

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

1211

meminfo->mem[i].limit < meminfo->avail[mc].base)

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

1214

if (meminfo->mem[i].base > meminfo->avail[mc].limit)

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

1248

if (*out_end > meminfo->avail[mc_idx].limit)

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

1249

*out_end = meminfo->avail[mc_idx].limit;

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

1278

payload->end = mem_desc.limit;

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

1483

*region_size = mem_info.avail[mc_idx].limit -

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

2284

&mem_desc.limit);

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

2291

ctx_info[i].end = mem_desc.limit;

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

552

meminfo_buff->mem[i].limit = 0;

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

563

meminfo_buff->avail[i].limit =

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

574

meminfo_buff->avail[i].limit =

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

586

meminfo_buff->avail[i].limit =

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

597

meminfo_buff->avail[i].limit =

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

608

meminfo_buff->avail[i].limit =

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

619

meminfo_buff->avail[i].limit =

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

645

md->limit = md->base - 1 +

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

651

md->limit = md->base - 1 +

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

665

md->limit = 0;

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

674

(md++)->limit = t4_read_reg(padap, ULP_ ## reg ## _ULIMIT_A);\

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

703

md->limit = md->base + (size << 2) - 1;

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

710

md->limit = 0;

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

713

md->limit = 0;

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

718

md->limit = md->base + padap->vres.ocq.size - 1;

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

725

if (meminfo_buff->avail[n].limit <

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

727

(md++)->base = meminfo_buff->avail[n].limit;

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

729

if (meminfo_buff->avail[n].limit)

drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c

730

(md++)->base = meminfo_buff->avail[n].limit;

drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c

3481

meminfo.avail[i].limit - 1);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c

3487

if (!meminfo.mem[i].limit)

drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c

3488

meminfo.mem[i].limit =

drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c

3492

meminfo.mem[i].base, meminfo.mem[i].limit);

drivers/net/ethernet/dec/tulip/winbond-840.c

728

int limit = RXTX_TIMEOUT;

drivers/net/ethernet/dec/tulip/winbond-840.c

749

limit--;

drivers/net/ethernet/dec/tulip/winbond-840.c

750

if(!limit) {

drivers/net/ethernet/emulex/benet/be.h

134

static inline u32 MODULO(u32 val, u32 limit)

drivers/net/ethernet/emulex/benet/be.h

136

BUG_ON(limit & (limit - 1));

drivers/net/ethernet/emulex/benet/be.h

137

return val & (limit - 1);

drivers/net/ethernet/emulex/benet/be.h

140

static inline void index_adv(u32 *index, u32 val, u32 limit)

drivers/net/ethernet/emulex/benet/be.h

142

*index = MODULO((*index + val), limit);

drivers/net/ethernet/emulex/benet/be.h

145

static inline void index_inc(u32 *index, u32 limit)

drivers/net/ethernet/emulex/benet/be.h

147

*index = MODULO((*index + 1), limit);

drivers/net/ethernet/emulex/benet/be.h

170

static inline void index_dec(u32 *index, u32 limit)

drivers/net/ethernet/emulex/benet/be.h

172

*index = MODULO((*index - 1), limit);

drivers/net/ethernet/engleder/tsnep_tc.c

133

static u64 tsnep_gcl_start_after(struct tsnep_gcl *gcl, u64 limit)

drivers/net/ethernet/engleder/tsnep_tc.c

138

if (start <= limit) {

drivers/net/ethernet/engleder/tsnep_tc.c

139

n = div64_u64(limit - start, gcl->cycle_time);

drivers/net/ethernet/engleder/tsnep_tc.c

146

static u64 tsnep_gcl_start_before(struct tsnep_gcl *gcl, u64 limit)

drivers/net/ethernet/engleder/tsnep_tc.c

151

n = div64_u64(limit - start, gcl->cycle_time);

drivers/net/ethernet/engleder/tsnep_tc.c

153

if (start == limit)

drivers/net/ethernet/engleder/tsnep_tc.c

265

u64 limit;

drivers/net/ethernet/engleder/tsnep_tc.c

274

limit = timeout + curr->change_limit;

drivers/net/ethernet/engleder/tsnep_tc.c

276

limit = timeout;

drivers/net/ethernet/engleder/tsnep_tc.c

278

gcl->start_time = tsnep_gcl_start_after(gcl, limit);

drivers/net/ethernet/ethoc.c

420

static int ethoc_rx(struct net_device *dev, int limit)

drivers/net/ethernet/ethoc.c

425

for (count = 0; count < limit; ++count) {

drivers/net/ethernet/ethoc.c

512

static int ethoc_tx(struct net_device *dev, int limit)

drivers/net/ethernet/ethoc.c

518

for (count = 0; count < limit; ++count) {

drivers/net/ethernet/fungible/funeth/funeth_tx.c

426

unsigned int head, limit, reclaim_idx;

drivers/net/ethernet/fungible/funeth/funeth_tx.c

429

limit = budget ? budget : UINT_MAX;

drivers/net/ethernet/fungible/funeth/funeth_tx.c

432

head != reclaim_idx && npkts < limit; head = txq_hw_head(q)) {

drivers/net/ethernet/fungible/funeth/funeth_tx.c

451

} while (reclaim_idx != head && npkts < limit);

drivers/net/ethernet/hisilicon/hisi_femac.c

245

static int hisi_femac_rx(struct net_device *dev, int limit)

drivers/net/ethernet/hisilicon/hisi_femac.c

289

if (rx_pkts_num >= limit)

drivers/net/ethernet/hisilicon/hix5hd2_gmac.c

509

static int hix5hd2_rx(struct net_device *dev, int limit)

drivers/net/ethernet/hisilicon/hix5hd2_gmac.c

522

if (num > limit)

drivers/net/ethernet/hisilicon/hix5hd2_gmac.c

523

num = limit;

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_devlink.c

106

enum devlink_reload_limit limit,

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_devlink.c

72

enum devlink_reload_limit limit,

drivers/net/ethernet/hisilicon/hns3/hns3vf/hclgevf_devlink.c

35

enum devlink_reload_limit limit,

drivers/net/ethernet/hisilicon/hns3/hns3vf/hclgevf_devlink.c

69

enum devlink_reload_limit limit,

drivers/net/ethernet/ibm/emac/phy.c

100

if (limit > 0 && phy->mode == PHY_INTERFACE_MODE_SGMII) {

drivers/net/ethernet/ibm/emac/phy.c

107

return limit <= 0;

drivers/net/ethernet/ibm/emac/phy.c

58

int limit = 10000;

drivers/net/ethernet/ibm/emac/phy.c

67

while (--limit) {

drivers/net/ethernet/ibm/emac/phy.c

73

if ((val & BMCR_ISOLATE) && limit > 0)

drivers/net/ethernet/ibm/emac/phy.c

76

return limit <= 0;

drivers/net/ethernet/ibm/emac/phy.c

82

int limit = 10000;

drivers/net/ethernet/ibm/emac/phy.c

91

while (--limit) {

drivers/net/ethernet/ibm/emac/phy.c

97

if ((val & BMCR_ISOLATE) && limit > 0)

drivers/net/ethernet/intel/e1000e/ich8lan.c

4316

pr0.range.limit = ((gfpreg >> 16) & FLASH_GFPREG_BASE_MASK);

drivers/net/ethernet/intel/e1000e/ich8lan.c

90

u32 limit:13; /* 16:28 Protected Range Limit */

drivers/net/ethernet/intel/fm10k/fm10k.h

212

u16 limit; /* upper limit on feature indices */

drivers/net/ethernet/intel/fm10k/fm10k_ethtool.c

1130

interface->ring_feature[RING_F_RSS].limit = count;

drivers/net/ethernet/intel/fm10k/fm10k_main.c

1501

rss_i = min_t(u16, rss_i, f->limit);

drivers/net/ethernet/intel/fm10k/fm10k_main.c

1529

rss_i = min_t(u16, interface->hw.mac.max_queues, f->limit);

drivers/net/ethernet/intel/fm10k/fm10k_pci.c

1999

interface->ring_feature[RING_F_RSS].limit = rss;

drivers/net/ethernet/intel/ice/devlink/devlink.c

1302

enum devlink_reload_limit limit,

drivers/net/ethernet/intel/ice/devlink/devlink.c

478

enum devlink_reload_limit limit,

drivers/net/ethernet/intel/ice/ice_irq.c

77

struct xa_limit limit = { .max = pf->irq_tracker.num_entries - 1,

drivers/net/ethernet/intel/ice/ice_irq.c

90

limit.max = num_static;

drivers/net/ethernet/intel/ice/ice_irq.c

92

ret = xa_alloc(&pf->irq_tracker.entries, &index, entry, limit,

drivers/net/ethernet/intel/ixgbe/devlink/devlink.c

393

enum devlink_reload_limit limit,

drivers/net/ethernet/intel/ixgbe/devlink/devlink.c

449

enum devlink_reload_limit limit,

drivers/net/ethernet/intel/ixgbe/ixgbe.h

439

u16 limit; /* upper limit on feature indices */

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

3438

adapter->ring_feature[RING_F_FDIR].limit = count;

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

3443

adapter->ring_feature[RING_F_RSS].limit = count;

drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c

3449

adapter->ring_feature[RING_F_FCOE].limit = count;

drivers/net/ethernet/intel/ixgbe/ixgbe_ipsec.c

151

u32 limit;

drivers/net/ethernet/intel/ixgbe/ixgbe_ipsec.c

192

limit = 20;

drivers/net/ethernet/intel/ixgbe/ixgbe_ipsec.c

199

} while (!(t_rdy && r_rdy) && limit--);

drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c

1206

adapter->ring_feature[RING_F_RSS].limit = 1;

drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c

329

u16 vmdq_i = adapter->ring_feature[RING_F_VMDQ].limit;

drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c

396

fcoe_i = min_t(u16, fcoe_i, fcoe->limit);

drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c

458

rss_i = min_t(int, rss_i, f->limit);

drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c

475

f->indices = min_t(u16, rss_i, f->limit);

drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c

502

u16 vmdq_i = adapter->ring_feature[RING_F_VMDQ].limit;

drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c

504

u16 rss_i = adapter->ring_feature[RING_F_RSS].limit;

drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c

574

fcoe_i = min_t(u16, fcoe_i, fcoe->limit);

drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c

589

fcoe->indices = min_t(u16, fcoe_i, fcoe->limit);

drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c

632

rss_i = f->limit;

drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c

652

rss_i = f->indices = f->limit;

drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c

674

fcoe_i = min_t(u16, f->limit + rss_i, num_online_cpus());

drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c

682

f->indices = min_t(u16, fcoe_i, f->limit);

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

10509

adapter->ring_feature[RING_F_RSS].limit = rss;

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

10510

adapter->ring_feature[RING_F_VMDQ].limit = 1;

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

10562

(adapter->ring_feature[RING_F_RSS].limit <= 1) ||

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

10786

adapter->ring_feature[RING_F_VMDQ].limit += reserved_pools;

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

11827

adapter->ring_feature[RING_F_FCOE].limit = fcoe_l;

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

6883

adapter->ring_feature[RING_F_RSS].limit = rss;

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

6888

adapter->ring_feature[RING_F_FDIR].limit = fdir;

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

6890

adapter->ring_feature[RING_F_VMDQ].limit = 1;

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

6937

adapter->ring_feature[RING_F_FDIR].limit = 0;

drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c

267

adapter->ring_feature[RING_F_RSS].limit = rss;

drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c

279

int err = 0, num_rx_pools, i, limit;

drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c

305

limit = (num_tc > 4) ? IXGBE_MAX_VFS_8TC :

drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c

308

if (num_vfs > (limit - num_rx_pools)) {

drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c

310

num_tc, num_rx_pools - 1, limit - num_rx_pools);

drivers/net/ethernet/jme.c

1047

jme_process_receive(struct jme_adapter *jme, int limit)

drivers/net/ethernet/jme.c

1063

while (limit > 0) {

drivers/net/ethernet/jme.c

1070

--limit;

drivers/net/ethernet/jme.c

1086

limit -= desccnt - 1;

drivers/net/ethernet/jme.c

1106

return limit > 0 ? limit : 0;

drivers/net/ethernet/korina.c

596

static int korina_rx(struct net_device *dev, int limit)

drivers/net/ethernet/korina.c

605

for (count = 0; count < limit; count++) {

drivers/net/ethernet/marvell/octeontx2/af/cn20k/debugfs.c

157

(u64)aura->limit, aura->bp, aura->fc_ena);

drivers/net/ethernet/marvell/octeontx2/af/cn20k/struct.h

265

u64 limit : 36; /* W3 */

drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c

1128

(u64)aura->limit, aura->bp, aura->fc_ena);

drivers/net/ethernet/marvell/octeontx2/af/rvu_struct.h

202

u64 limit : 36; /* W3 */

drivers/net/ethernet/marvell/octeontx2/nic/cn20k.c

292

aq->aura.limit = numptrs;

drivers/net/ethernet/marvell/octeontx2/nic/otx2_common.c

1412

aq->aura.limit = numptrs;

drivers/net/ethernet/mellanox/mlx4/main.c

3978

enum devlink_reload_limit limit,

drivers/net/ethernet/mellanox/mlx4/main.c

3996

enum devlink_reload_limit limit, u32 *actions_performed,

drivers/net/ethernet/mellanox/mlx5/core/devlink.c

191

enum devlink_reload_limit limit,

drivers/net/ethernet/mellanox/mlx5/core/devlink.c

229

if (limit == DEVLINK_RELOAD_LIMIT_NO_RESET)

drivers/net/ethernet/mellanox/mlx5/core/devlink.c

244

enum devlink_reload_limit limit, u32 *actions_performed,

drivers/net/ethernet/mellanox/mlx5/core/devlink.c

260

if (limit == DEVLINK_RELOAD_LIMIT_NO_RESET)

drivers/net/ethernet/mellanox/mlx5/core/main.c

119

.limit = 250

drivers/net/ethernet/mellanox/mlx5/core/main.c

123

.limit = 250

drivers/net/ethernet/mellanox/mlx5/core/main.c

127

.limit = 250

drivers/net/ethernet/mellanox/mlx5/core/main.c

131

.limit = 250

drivers/net/ethernet/mellanox/mlx5/core/main.c

135

.limit = 250

drivers/net/ethernet/mellanox/mlx5/core/main.c

139

.limit = 250

drivers/net/ethernet/mellanox/mlx5/core/main.c

143

.limit = 250

drivers/net/ethernet/mellanox/mlx5/core/main.c

147

.limit = 250

drivers/net/ethernet/mellanox/mlx5/core/main.c

151

.limit = 250

drivers/net/ethernet/mellanox/mlx5/core/main.c

155

.limit = 250

drivers/net/ethernet/mellanox/mlx5/core/main.c

159

.limit = 250

drivers/net/ethernet/mellanox/mlx5/core/main.c

163

.limit = 250

drivers/net/ethernet/mellanox/mlx5/core/main.c

167

.limit = 32

drivers/net/ethernet/mellanox/mlx5/core/main.c

171

.limit = 16

drivers/net/ethernet/mellanox/mlx5/core/main.c

175

.limit = 8

drivers/net/ethernet/mellanox/mlx5/core/main.c

179

.limit = 4

drivers/net/ethernet/mellanox/mlxsw/core.c

1580

enum devlink_reload_limit limit,

drivers/net/ethernet/mellanox/mlxsw/core.c

1594

enum devlink_reload_limit limit, u32 *actions_performed,

drivers/net/ethernet/mellanox/mlxsw/reg.h

9434

u16 limit;

drivers/net/ethernet/mellanox/mlxsw/reg.h

9437

limit = mlxsw_reg_fore_fan_under_limit_get(payload);

drivers/net/ethernet/mellanox/mlxsw/reg.h

9438

*fault = limit & BIT(tacho);

drivers/net/ethernet/myricom/myri10ge/myri10ge.c

467

char *ptr, *limit;

drivers/net/ethernet/myricom/myri10ge/myri10ge.c

471

limit = mgp->eeprom_strings + MYRI10GE_EEPROM_STRINGS_SIZE;

drivers/net/ethernet/myricom/myri10ge/myri10ge.c

473

while (*ptr != '\0' && ptr < limit) {

drivers/net/ethernet/myricom/myri10ge/myri10ge.c

478

if ((ptr + 2) > limit)

drivers/net/ethernet/myricom/myri10ge/myri10ge.c

493

while (ptr < limit && *ptr++) ;

drivers/net/ethernet/netronome/nfp/abm/qdisc.c

710

if (opt->set.limit) {

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_hwinfo.c

94

__le32 limit;

drivers/net/ethernet/nvidia/forcedeth.c

2592

static int nv_tx_done(struct net_device *dev, int limit)

drivers/net/ethernet/nvidia/forcedeth.c

2602

(tx_work < limit)) {

drivers/net/ethernet/nvidia/forcedeth.c

2662

static int nv_tx_done_optimized(struct net_device *dev, int limit)

drivers/net/ethernet/nvidia/forcedeth.c

2672

(tx_work < limit)) {

drivers/net/ethernet/nvidia/forcedeth.c

2877

static int nv_rx_process(struct net_device *dev, int limit)

drivers/net/ethernet/nvidia/forcedeth.c

2887

(rx_work < limit)) {

drivers/net/ethernet/nvidia/forcedeth.c

2978

static int nv_rx_process_optimized(struct net_device *dev, int limit)

drivers/net/ethernet/nvidia/forcedeth.c

2989

(rx_work < limit)) {

drivers/net/ethernet/pasemi/pasemi_mac.c

512

int start, limit;

drivers/net/ethernet/pasemi/pasemi_mac.c

515

limit = txring->next_to_fill;

drivers/net/ethernet/pasemi/pasemi_mac.c

518

if (start > limit)

drivers/net/ethernet/pasemi/pasemi_mac.c

519

limit += TX_RING_SIZE;

drivers/net/ethernet/pasemi/pasemi_mac.c

521

for (i = start; i < limit; i += freed) {

drivers/net/ethernet/pasemi/pasemi_mac.c

574

const int limit)

drivers/net/ethernet/pasemi/pasemi_mac.c

580

if (limit <= 0)

drivers/net/ethernet/pasemi/pasemi_mac.c

584

for (count = 0; count < limit; count++) {

drivers/net/ethernet/pasemi/pasemi_mac.c

690

const int limit)

drivers/net/ethernet/pasemi/pasemi_mac.c

712

for (count = 0; count < limit; count++) {

drivers/net/ethernet/qlogic/qed/qed_main.c

875

int limit = 0;

drivers/net/ethernet/qlogic/qed/qed_main.c

881

limit = cdev->num_hwfns * 63;

drivers/net/ethernet/qlogic/qed/qed_main.c

883

limit = cdev->int_params.fp_msix_cnt;

drivers/net/ethernet/qlogic/qed/qed_main.c

885

if (!limit)

drivers/net/ethernet/qlogic/qed/qed_main.c

888

return min_t(int, cnt, limit);

drivers/net/ethernet/qlogic/qed/qed_rdma.c

890

int limit = 0;

drivers/net/ethernet/qlogic/qed/qed_rdma.c

901

limit = cdev->int_params.rdma_msix_cnt;

drivers/net/ethernet/qlogic/qed/qed_rdma.c

904

if (!limit)

drivers/net/ethernet/qlogic/qed/qed_rdma.c

907

return min_t(int, cnt, limit);

drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_hw.c

637

u32 val, limit = 0;

drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_hw.c

651

} while (++limit <= QLCNIC_PCIE_SEM_TIMEOUT);

drivers/net/ethernet/rdc/r6040.c

202

int limit = MAC_DEF_TIMEOUT;

drivers/net/ethernet/rdc/r6040.c

207

while (limit--) {

drivers/net/ethernet/rdc/r6040.c

214

if (limit < 0)

drivers/net/ethernet/rdc/r6040.c

224

int limit = MAC_DEF_TIMEOUT;

drivers/net/ethernet/rdc/r6040.c

231

while (limit--) {

drivers/net/ethernet/rdc/r6040.c

238

return (limit < 0) ? -ETIMEDOUT : 0;

drivers/net/ethernet/rdc/r6040.c

359

int limit = MAC_DEF_TIMEOUT;

drivers/net/ethernet/rdc/r6040.c

364

while (limit--) {

drivers/net/ethernet/rdc/r6040.c

509

static int r6040_rx(struct net_device *dev, int limit)

drivers/net/ethernet/rdc/r6040.c

518

while (count < limit && !(descptr->status & DSC_OWNER_MAC)) {

drivers/net/ethernet/renesas/ravb_main.c

809

int limit;

drivers/net/ethernet/renesas/ravb_main.c

812

limit = priv->dirty_rx[q] + priv->num_rx_ring[q] - priv->cur_rx[q];

drivers/net/ethernet/renesas/ravb_main.c

815

for (i = 0; i < limit; i++, priv->cur_rx[q]++) {

drivers/net/ethernet/renesas/ravb_main.c

979

unsigned int limit, i;

drivers/net/ethernet/renesas/ravb_main.c

986

limit = priv->dirty_rx[q] + priv->num_rx_ring[q] - priv->cur_rx[q];

drivers/net/ethernet/renesas/ravb_main.c

987

for (i = 0; i < limit; i++, priv->cur_rx[q]++) {

drivers/net/ethernet/renesas/rswitch_main.c

830

int limit, boguscnt, ret;

drivers/net/ethernet/renesas/rswitch_main.c

839

limit = boguscnt;

drivers/net/ethernet/renesas/rswitch_main.c

882

*quota -= limit - boguscnt;

drivers/net/ethernet/renesas/sh_eth.c

1589

int limit;

drivers/net/ethernet/renesas/sh_eth.c

1598

limit = boguscnt;

drivers/net/ethernet/renesas/sh_eth.c

1713

*quota -= limit - boguscnt - 1;

drivers/net/ethernet/rocker/rocker_main.c

309

static u32 __pos_inc(u32 pos, size_t limit)

drivers/net/ethernet/rocker/rocker_main.c

311

return ++pos == limit ? 0 : pos;

drivers/net/ethernet/samsung/sxgbe/sxgbe_main.c

1482

static int sxgbe_rx(struct sxgbe_priv_data *priv, int limit)

drivers/net/ethernet/samsung/sxgbe/sxgbe_main.c

1492

while (count < limit) {

drivers/net/ethernet/sfc/falcon/falcon.c

1788

__le16 *word, *limit;

drivers/net/ethernet/sfc/falcon/falcon.c

1829

limit = (__le16 *) (nvconfig + 1);

drivers/net/ethernet/sfc/falcon/falcon.c

1832

limit = region + FALCON_NVCONFIG_END;

drivers/net/ethernet/sfc/falcon/falcon.c

1834

for (csum = 0; word < limit; ++word)

drivers/net/ethernet/sfc/falcon/farch.c

351

unsigned int limit = (~dma_addr & (EF4_PAGE_SIZE - 1)) + 1;

drivers/net/ethernet/sfc/falcon/farch.c

353

len = min(limit, len);

drivers/net/ethernet/sfc/ptp.c

847

struct timespec64 limit;

drivers/net/ethernet/sfc/ptp.c

852

limit = now.ts_real;

drivers/net/ethernet/sfc/ptp.c

853

timespec64_add_ns(&limit, SYNCHRONISE_PERIOD_NS);

drivers/net/ethernet/sfc/ptp.c

856

while ((timespec64_compare(&now.ts_real, &limit) < 0) &&

drivers/net/ethernet/sfc/siena/farch.c

362

unsigned int limit = (~dma_addr & (EFX_PAGE_SIZE - 1)) + 1;

drivers/net/ethernet/sfc/siena/farch.c

364

len = min(limit, len);

drivers/net/ethernet/sfc/siena/ptp.c

860

struct timespec64 limit;

drivers/net/ethernet/sfc/siena/ptp.c

865

limit = now.ts_real;

drivers/net/ethernet/sfc/siena/ptp.c

866

timespec64_add_ns(&limit, SYNCHRONISE_PERIOD_NS);

drivers/net/ethernet/sfc/siena/ptp.c

869

while ((timespec64_compare(&now.ts_real, &limit) < 0) &&

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5400

static int stmmac_rx_zc(struct stmmac_priv *priv, int limit, u32 queue)

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5429

while (count < limit) {

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5447

if (count >= limit)

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5583

return failure ? limit : (int)count;

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5594

static int stmmac_rx(struct stmmac_priv *priv, int limit, u32 queue)

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5612

limit = min(priv->dma_conf.dma_rx_size - 1, (unsigned int)limit);

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5629

while (count < limit) {

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5649

if (count >= limit)

drivers/net/ethernet/sun/cassini.c

1423

int limit;

drivers/net/ethernet/sun/cassini.c

1428

for (limit = 0; limit < STOP_TRIES; limit++) {

drivers/net/ethernet/sun/cassini.c

1433

if (limit == STOP_TRIES) {

drivers/net/ethernet/sun/cassini.c

1440

for (limit = 0; limit < STOP_TRIES; limit++) {

drivers/net/ethernet/sun/cassini.c

1445

if (limit == STOP_TRIES) {

drivers/net/ethernet/sun/cassini.c

1454

for (limit = 0; limit < STOP_TRIES; limit++) {

drivers/net/ethernet/sun/cassini.c

1459

if (limit == STOP_TRIES) {

drivers/net/ethernet/sun/cassini.c

1811

static inline void cas_tx_ringN(struct cas *cp, int ring, int limit)

drivers/net/ethernet/sun/cassini.c

1823

count = TX_BUFF_COUNT(ring, entry, limit);

drivers/net/ethernet/sun/cassini.c

1824

while (entry != limit) {

drivers/net/ethernet/sun/cassini.c

1886

int limit, ring;

drivers/net/ethernet/sun/cassini.c

1897

limit = (CAS_VAL(TX_COMPWB_MSB, compwb) << 8) |

drivers/net/ethernet/sun/cassini.c

1901

limit = readl(cp->regs + REG_TX_COMPN(ring));

drivers/net/ethernet/sun/cassini.c

1903

if (cp->tx_old[ring] != limit)

drivers/net/ethernet/sun/cassini.c

1904

cas_tx_ringN(cp, ring, limit);

drivers/net/ethernet/sun/cassini.c

3694

int limit;

drivers/net/ethernet/sun/cassini.c

3713

limit = STOP_TRIES;

drivers/net/ethernet/sun/cassini.c

3714

while (limit-- > 0) {

drivers/net/ethernet/sun/cassini.c

383

int limit = STOP_TRIES_PHY;

drivers/net/ethernet/sun/cassini.c

392

while (limit-- > 0) {

drivers/net/ethernet/sun/cassini.c

403

int limit = STOP_TRIES_PHY;

drivers/net/ethernet/sun/cassini.c

414

while (limit-- > 0) {

drivers/net/ethernet/sun/cassini.c

4430

int limit = STOP_TRIES;

drivers/net/ethernet/sun/cassini.c

4441

if (!limit--)

drivers/net/ethernet/sun/cassini.c

4447

limit = STOP_TRIES;

drivers/net/ethernet/sun/cassini.c

4451

if (!limit--)

drivers/net/ethernet/sun/cassini.c

772

int limit = STOP_TRIES_PHY;

drivers/net/ethernet/sun/cassini.c

777

while (--limit) {

drivers/net/ethernet/sun/cassini.c

783

return limit <= 0;

drivers/net/ethernet/sun/cassini.c

933

int limit;

drivers/net/ethernet/sun/cassini.c

947

limit = STOP_TRIES;

drivers/net/ethernet/sun/cassini.c

948

while (--limit > 0) {

drivers/net/ethernet/sun/cassini.c

954

if (limit <= 0)

drivers/net/ethernet/sun/niu.c

121

u64 bits, int limit, int delay)

drivers/net/ethernet/sun/niu.c

123

while (--limit >= 0) {

drivers/net/ethernet/sun/niu.c

1278

int err, limit;

drivers/net/ethernet/sun/niu.c

1290

limit = 1000;

drivers/net/ethernet/sun/niu.c

1291

while (--limit >= 0) {

drivers/net/ethernet/sun/niu.c

1299

if (limit < 0) {

drivers/net/ethernet/sun/niu.c

130

if (limit < 0)

drivers/net/ethernet/sun/niu.c

136

u64 bits, int limit, int delay,

drivers/net/ethernet/sun/niu.c

142

err = __niu_wait_bits_clear_mac(np, reg, bits, limit, delay);

drivers/net/ethernet/sun/niu.c

156

u64 bits, int limit, int delay)

drivers/net/ethernet/sun/niu.c

158

while (--limit >= 0) {

drivers/net/ethernet/sun/niu.c

1648

int limit, err;

drivers/net/ethernet/sun/niu.c

165

if (limit < 0)

drivers/net/ethernet/sun/niu.c

1654

limit = 1000;

drivers/net/ethernet/sun/niu.c

1655

while (--limit >= 0) {

drivers/net/ethernet/sun/niu.c

1663

if (limit < 0) {

drivers/net/ethernet/sun/niu.c

171

u64 bits, int limit, int delay,

drivers/net/ethernet/sun/niu.c

181

err = __niu_wait_bits_clear_ipp(np, reg, bits, limit, delay);

drivers/net/ethernet/sun/niu.c

195

u64 bits, int limit, int delay)

drivers/net/ethernet/sun/niu.c

197

while (--limit >= 0) {

drivers/net/ethernet/sun/niu.c

204

if (limit < 0)

drivers/net/ethernet/sun/niu.c

215

u64 bits, int limit, int delay,

drivers/net/ethernet/sun/niu.c

221

err = __niu_wait_bits_clear(np, reg, bits, limit, delay);

drivers/net/ethernet/sun/niu.c

2794

int limit = 1000;

drivers/net/ethernet/sun/niu.c

2796

while (--limit > 0) {

drivers/net/ethernet/sun/niu.c

2801

if (limit <= 0)

drivers/net/ethernet/sun/niu.c

318

int limit = 1000;

drivers/net/ethernet/sun/niu.c

321

while (--limit > 0) {

drivers/net/ethernet/sun/niu.c

3647

const int limit)

drivers/net/ethernet/sun/niu.c

3669

if (unlikely((misc & RXMISC_COUNT) > limit)) {

drivers/net/ethernet/sun/niu.c

3679

rx_channel, misc, misc-limit);

drivers/net/ethernet/sun/niu.c

3684

if (unlikely((wred & RED_DIS_CNT_COUNT) > limit)) {

drivers/net/ethernet/sun/niu.c

3693

rx_channel, wred, wred-limit);

drivers/net/ethernet/sun/niu.c

4557

int limit = 1000;

drivers/net/ethernet/sun/niu.c

4559

while (--limit > 0) {

drivers/net/ethernet/sun/niu.c

4579

int limit = 1000;

drivers/net/ethernet/sun/niu.c

4581

while (--limit > 0) {

drivers/net/ethernet/sun/niu.c

4903

int limit;

drivers/net/ethernet/sun/niu.c

4911

limit = 1000;

drivers/net/ethernet/sun/niu.c

4912

while (--limit > 0) {

drivers/net/ethernet/sun/niu.c

4917

if (limit <= 0)

drivers/net/ethernet/sun/niu.c

5382

int limit = 1000;

drivers/net/ethernet/sun/niu.c

5386

while ((--limit >= 0) && (val & PCS_MII_CTL_RST)) {

drivers/net/ethernet/sun/niu.c

5394

int limit = 1000;

drivers/net/ethernet/sun/niu.c

5398

while ((--limit >= 0) && (val & XPCS_CONTROL1_RESET)) {

drivers/net/ethernet/sun/niu.c

5478

int limit;

drivers/net/ethernet/sun/niu.c

5481

limit = 1000;

drivers/net/ethernet/sun/niu.c

5482

while (--limit >= 0) {

drivers/net/ethernet/sun/niu.c

5487

if (limit < 0) {

drivers/net/ethernet/sun/niu.c

5581

int limit;

drivers/net/ethernet/sun/niu.c

5585

limit = 1000;

drivers/net/ethernet/sun/niu.c

5586

while (--limit >= 0) {

drivers/net/ethernet/sun/niu.c

5592

if (limit < 0) {

drivers/net/ethernet/sun/niu.c

5604

int limit;

drivers/net/ethernet/sun/niu.c

5607

limit = 1000;

drivers/net/ethernet/sun/niu.c

5608

while (--limit >= 0) {

drivers/net/ethernet/sun/niu.c

5613

if (limit < 0) {

drivers/net/ethernet/sun/niu.c

5907

int limit;

drivers/net/ethernet/sun/niu.c

5911

limit = 100;

drivers/net/ethernet/sun/niu.c

5912

while (--limit >= 0 && (rd != wr)) {

drivers/net/ethernet/sun/niu.c

5916

if (limit < 0 &&

drivers/net/ethernet/sun/niu.c

7994

int limit;

drivers/net/ethernet/sun/niu.c

8001

limit = 64;

drivers/net/ethernet/sun/niu.c

8007

} while (limit--);

drivers/net/ethernet/sun/niu.c

8016

limit = 64;

drivers/net/ethernet/sun/niu.c

8022

} while (limit--);

drivers/net/ethernet/sun/sungem.c

1100

int limit;

drivers/net/ethernet/sun/sungem.c

1108

limit = 32;

drivers/net/ethernet/sun/sungem.c

1111

if (limit-- <= 0)

drivers/net/ethernet/sun/sungem.c

1114

if (limit < 0)

drivers/net/ethernet/sun/sungem.c

1165

int limit;

drivers/net/ethernet/sun/sungem.c

1175

limit = STOP_TRIES;

drivers/net/ethernet/sun/sungem.c

1180

if (limit-- <= 0)

drivers/net/ethernet/sun/sungem.c

1184

if (limit < 0)

drivers/net/ethernet/sun/sungem.c

120

int limit = 10000;

drivers/net/ethernet/sun/sungem.c

129

while (--limit) {

drivers/net/ethernet/sun/sungem.c

137

if (!limit)

drivers/net/ethernet/sun/sungem.c

157

int limit = 10000;

drivers/net/ethernet/sun/sungem.c

167

while (limit--) {

drivers/net/ethernet/sun/sungem.c

2450

int limit = 10000;

drivers/net/ethernet/sun/sungem.c

2468

if (!limit--)

drivers/net/ethernet/sun/sungem.c

362

int limit, i;

drivers/net/ethernet/sun/sungem.c

368

for (limit = 0; limit < 5000; limit++) {

drivers/net/ethernet/sun/sungem.c

373

if (limit == 5000) {

drivers/net/ethernet/sun/sungem.c

380

for (limit = 0; limit < 5000; limit++) {

drivers/net/ethernet/sun/sungem.c

385

if (limit == 5000) {

drivers/net/ethernet/sun/sungem.c

392

for (limit = 0; limit < 5000; limit++) {

drivers/net/ethernet/sun/sungem.c

397

if (limit == 5000) {

drivers/net/ethernet/sun/sungem.c

407

for (limit = 0; limit < 5000; limit++) {

drivers/net/ethernet/sun/sungem.c

412

if (limit == 5000) {

drivers/net/ethernet/sun/sungem.c

633

int entry, limit;

drivers/net/ethernet/sun/sungem.c

636

limit = ((gem_status & GREG_STAT_TXNR) >> GREG_STAT_TXNR_SHIFT);

drivers/net/ethernet/sun/sungem.c

637

while (entry != limit) {

drivers/net/ethernet/sun/sungem.c

656

if (walk == limit)

drivers/net/ethernet/sun/sungem.c

702

static __inline__ void gem_post_rxds(struct gem *gp, int limit)

drivers/net/ethernet/sun/sungem.c

710

while (curr != limit) {

drivers/net/ethernet/toshiba/tc35815.c

1370

static int tc35815_do_interrupt(struct net_device *dev, u32 status, int limit)

drivers/net/ethernet/toshiba/tc35815.c

1409

ret = tc35815_rx(dev, limit);

drivers/net/ethernet/toshiba/tc35815.c

1459

tc35815_rx(struct net_device *dev, int limit)

drivers/net/ethernet/toshiba/tc35815.c

1484

if (--limit < 0)

drivers/net/ethernet/toshiba/tc35815.c

480

static int tc35815_rx(struct net_device *dev, int limit);

drivers/net/ethernet/via/via-rhine.c

2035

static int rhine_rx(struct net_device *dev, int limit)

drivers/net/ethernet/via/via-rhine.c

2046

for (count = 0; count < limit; ++count) {

drivers/net/ethernet/via/via-rhine.c

508

static int rhine_rx(struct net_device *dev, int limit);

drivers/net/ethernet/wangxun/libwx/wx_ethtool.c

521

wx->ring_feature[RING_F_FDIR].limit = count;

drivers/net/ethernet/wangxun/libwx/wx_ethtool.c

523

wx->ring_feature[RING_F_RSS].limit = count;

drivers/net/ethernet/wangxun/libwx/wx_lib.c

1776

u16 vmdq_i = wx->ring_feature[RING_F_VMDQ].limit;

drivers/net/ethernet/wangxun/libwx/wx_lib.c

1777

u16 rss_i = wx->ring_feature[RING_F_RSS].limit;

drivers/net/ethernet/wangxun/libwx/wx_lib.c

1851

f->indices = f->limit;

drivers/net/ethernet/wangxun/libwx/wx_lib.c

1866

f->indices = f->limit;

drivers/net/ethernet/wangxun/libwx/wx_lib.c

1979

wx->ring_feature[RING_F_RSS].limit = 1;

drivers/net/ethernet/wangxun/libwx/wx_lib.c

3153

if (wx->ring_feature[RING_F_RSS].limit <= 1)

drivers/net/ethernet/wangxun/libwx/wx_sriov.c

69

if (wx->ring_feature[RING_F_VMDQ].limit == 1)

drivers/net/ethernet/wangxun/libwx/wx_sriov.c

86

if (!wx->ring_feature[RING_F_VMDQ].limit)

drivers/net/ethernet/wangxun/libwx/wx_sriov.c

87

wx->ring_feature[RING_F_VMDQ].limit = 1;

drivers/net/ethernet/wangxun/libwx/wx_type.h

1129

u16 limit; /* upper limit on feature indices */

drivers/net/ethernet/wangxun/ngbe/ngbe_main.c

118

wx->ring_feature[RING_F_RSS].limit = min_t(int, NGBE_MAX_RSS_INDICES,

drivers/net/ethernet/wangxun/txgbe/txgbe_main.c

383

wx->ring_feature[RING_F_RSS].limit = min_t(int, TXGBE_MAX_RSS_INDICES,

drivers/net/ethernet/wangxun/txgbe/txgbe_main.c

387

wx->ring_feature[RING_F_FDIR].limit = min_t(int, TXGBE_MAX_FDIR_INDICES,

drivers/net/fddi/skfp/smtdef.c

337

static int set_min_max(int maxflag, u_long mib, u_long limit, u_long *oper)

drivers/net/fddi/skfp/smtdef.c

341

if ((limit > mib) ^ maxflag)

drivers/net/fddi/skfp/smtdef.c

342

*oper = limit ;

drivers/net/fddi/skfp/smtdef.c

69

static int set_min_max(int maxflag, u_long mib, u_long limit, u_long *oper);

drivers/net/ipa/ipa_endpoint.c

1008

u32 limit;

drivers/net/ipa/ipa_endpoint.c

1015

limit = ipa_aggr_size_kb(buffer_size - NET_SKB_PAD,

drivers/net/ipa/ipa_endpoint.c

1017

val |= reg_encode(reg, BYTE_LIMIT, limit);

drivers/net/ipa/ipa_endpoint.c

1019

limit = rx_config->aggr_time_limit;

drivers/net/ipa/ipa_endpoint.c

1020

val |= aggr_time_limit_encode(ipa, reg, limit);

drivers/net/ipa/ipa_endpoint.c

1995

u32 limit;

drivers/net/ipa/ipa_endpoint.c

2030

limit = rx_base + rx_count;

drivers/net/ipa/ipa_endpoint.c

2031

if (limit > IPA_ENDPOINT_MAX) {

drivers/net/ipa/ipa_endpoint.c

2033

limit, IPA_ENDPOINT_MAX);

drivers/net/ipa/ipa_endpoint.c

2039

if (limit > hw_limit) {

drivers/net/ipa/ipa_endpoint.c

2041

limit, hw_limit);

drivers/net/ipa/ipa_endpoint.c

2046

ipa->available = bitmap_zalloc(limit, GFP_KERNEL);

drivers/net/ipa/ipa_endpoint.c

2049

ipa->available_count = limit;

drivers/net/ipa/ipa_endpoint.c

2058

if (endpoint_id >= limit) {

drivers/net/ipa/ipa_endpoint.c

2060

endpoint_id, limit - 1);

drivers/net/ipa/ipa_endpoint.c

250

u32 limit;

drivers/net/ipa/ipa_endpoint.c

267

limit = IPA_MTU + IPA_RX_BUFFER_OVERHEAD;

drivers/net/ipa/ipa_endpoint.c

268

if (buffer_size < limit) {

drivers/net/ipa/ipa_endpoint.c

270

data->endpoint_id, buffer_size, limit);

drivers/net/ipa/ipa_endpoint.c

310

limit = reg_field_max(reg, BYTE_LIMIT);

drivers/net/ipa/ipa_endpoint.c

311

if (aggr_size > limit) {

drivers/net/ipa/ipa_endpoint.c

313

data->endpoint_id, aggr_size, limit);

drivers/net/ipa/ipa_mem.c

296

u32 limit = ipa->mem_size;

drivers/net/ipa/ipa_mem.c

302

if (mem->offset + mem->size <= limit)

drivers/net/ipa/ipa_mem.c

306

mem->id, limit);

drivers/net/netdevsim/dev.c

1025

enum devlink_reload_action action, enum devlink_reload_limit limit,

drivers/net/netdevsim/dev.c

1043

enum devlink_reload_limit limit, u32 *actions_performed,

drivers/net/sungem_phy.c

70

int limit = 10000;

drivers/net/sungem_phy.c

79

while (--limit) {

drivers/net/sungem_phy.c

85

if ((val & BMCR_ISOLATE) && limit > 0)

drivers/net/sungem_phy.c

88

return limit <= 0;

drivers/net/usb/r8152.c

1346

u16 limit = 64;

drivers/net/usb/r8152.c

1360

if (size > limit) {

drivers/net/usb/r8152.c

1361

ret = get_registers(tp, index, type, limit, data);

drivers/net/usb/r8152.c

1365

index += limit;

drivers/net/usb/r8152.c

1366

data += limit;

drivers/net/usb/r8152.c

1367

size -= limit;

drivers/net/usb/r8152.c

1391

u16 limit = 512;

drivers/net/usb/r8152.c

1427

if (size > limit) {

drivers/net/usb/r8152.c

1430

limit, data);

drivers/net/usb/r8152.c

1434

index += limit;

drivers/net/usb/r8152.c

1435

data += limit;

drivers/net/usb/r8152.c

1436

size -= limit;

drivers/net/wireless/admtek/adm8211.c

357

unsigned int limit = priv->rx_ring_size;

drivers/net/wireless/admtek/adm8211.c

361

if (!limit--)

drivers/net/wireless/ath/ath6kl/htc_mbox.c

168

int limit)

drivers/net/wireless/ath/ath6kl/htc_mbox.c

173

ep_dist->endpoint, limit);

drivers/net/wireless/ath/ath6kl/htc_mbox.c

175

ep_dist->cred_assngd = limit;

drivers/net/wireless/ath/ath6kl/htc_mbox.c

177

if (ep_dist->credits <= limit)

drivers/net/wireless/ath/ath6kl/htc_mbox.c

180

credits = ep_dist->credits - limit;

drivers/net/wireless/ath/ath9k/calib.c

115

if (h[i].privNF > limit->max) {

drivers/net/wireless/ath/ath9k/calib.c

120

i, h[i].privNF, limit->max,

drivers/net/wireless/ath/ath9k/calib.c

133

h[i].privNF = limit->max;

drivers/net/wireless/ath/ath9k/calib.c

367

struct ath_nf_limits *limit;

drivers/net/wireless/ath/ath9k/calib.c

371

limit = &ah->nf_2g;

drivers/net/wireless/ath/ath9k/calib.c

373

limit = &ah->nf_5g;

drivers/net/wireless/ath/ath9k/calib.c

383

if (nf[i] > limit->max) {

drivers/net/wireless/ath/ath9k/calib.c

386

i, nf[i], limit->max);

drivers/net/wireless/ath/ath9k/calib.c

387

nf[i] = limit->max;

drivers/net/wireless/ath/ath9k/calib.c

388

} else if (nf[i] < limit->min) {

drivers/net/wireless/ath/ath9k/calib.c

391

i, nf[i], limit->min);

drivers/net/wireless/ath/ath9k/calib.c

392

nf[i] = limit->nominal;

drivers/net/wireless/ath/ath9k/calib.c

43

struct ath_nf_limits *limit;

drivers/net/wireless/ath/ath9k/calib.c

46

limit = &ah->nf_2g;

drivers/net/wireless/ath/ath9k/calib.c

48

limit = &ah->nf_5g;

drivers/net/wireless/ath/ath9k/calib.c

50

return limit;

drivers/net/wireless/ath/ath9k/calib.c

85

struct ath_nf_limits *limit;

drivers/net/wireless/ath/ath9k/calib.c

92

limit = ath9k_hw_get_nf_limits(ah, ah->curchan);

drivers/net/wireless/ath/ath9k/hw.c

2966

void ath9k_hw_set_txpowerlimit(struct ath_hw *ah, u32 limit, bool test)

drivers/net/wireless/ath/ath9k/hw.c

2972

reg->power_limit = min_t(u32, limit, MAX_COMBINED_POWER);

drivers/net/wireless/ath/ath9k/hw.h

1061

void ath9k_hw_set_txpowerlimit(struct ath_hw *ah, u32 limit, bool test);

drivers/net/wireless/ath/carl9170/carl9170.h

170

unsigned int limit;

drivers/net/wireless/ath/carl9170/debug.c

249

ar->tx_stats[0].len, ar->tx_stats[0].limit,

drivers/net/wireless/ath/carl9170/debug.c

250

ar->tx_stats[1].len, ar->tx_stats[1].limit,

drivers/net/wireless/ath/carl9170/debug.c

251

ar->tx_stats[2].len, ar->tx_stats[2].limit,

drivers/net/wireless/ath/carl9170/debug.c

252

ar->tx_stats[3].len, ar->tx_stats[3].limit);

drivers/net/wireless/ath/carl9170/main.c

308

ar->tx_stats[i].limit = CARL9170_NUM_TX_LIMIT_HARD;

drivers/net/wireless/ath/carl9170/tx.c

97

if (mem_full || ar->tx_stats[i].len >= ar->tx_stats[i].limit) {

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

2728

const struct wil_fw_concurrency_limit *limit;

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

2742

limit = combo->limits + combo->n_limits;

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

2743

combo = (struct wil_fw_concurrency_combo *)limit;

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

2767

limit = combo->limits;

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

2769

iface_limit[j].max = le16_to_cpu(limit[j].max);

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

2770

iface_limit[j].types = le16_to_cpu(limit[j].types);

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

2777

limit += combo->n_limits;

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

2778

combo = (struct wil_fw_concurrency_combo *)limit;

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

203

const struct wil_fw_concurrency_limit *limit;

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

220

limit = combo->limits;

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

221

lsize = combo->n_limits * sizeof(*limit);

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

225

limit += combo->n_limits;

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

226

combo = (struct wil_fw_concurrency_combo *)limit;

drivers/net/wireless/intel/iwlwifi/dvm/scan.c

362

u16 limit;

drivers/net/wireless/intel/iwlwifi/dvm/scan.c

401

limit = (limits[1] * 98) / 100 - IWL_CHANNEL_TUNE_TIME * 2;

drivers/net/wireless/intel/iwlwifi/dvm/scan.c

402

limit /= 2;

drivers/net/wireless/intel/iwlwifi/dvm/scan.c

403

dwell_time = min(limit, dwell_time);

drivers/net/wireless/intel/iwlwifi/dvm/scan.c

406

limit = (limits[0] * 98) / 100 - IWL_CHANNEL_TUNE_TIME * 2;

drivers/net/wireless/intel/iwlwifi/dvm/scan.c

407

limit /= n_active;

drivers/net/wireless/intel/iwlwifi/dvm/scan.c

408

return min(limit, dwell_time);

drivers/net/wireless/intel/iwlwifi/iwl-debug.c

68

u32 level, bool limit, const char *function,

drivers/net/wireless/intel/iwlwifi/iwl-debug.c

80

(!limit || net_ratelimit()))

drivers/net/wireless/intel/iwlwifi/iwl-debug.h

72

u32 level, bool limit, const char *function,

drivers/net/wireless/intel/iwlwifi/iwl-debug.h

77

u32 level, bool limit, const char *function,

drivers/net/wireless/intel/iwlwifi/iwl-debug.h

88

#define __IWL_DEBUG_DEV(dev, level, limit, fmt, args...) \

drivers/net/wireless/intel/iwlwifi/iwl-debug.h

91

__iwl_dbg(dev, level, limit, __func__, fmt, ##args); \

drivers/net/wireless/intersil/p54/fwio.c

142

priv->tx_stats[P54_QUEUE_AC_VO].limit = 16;

drivers/net/wireless/intersil/p54/fwio.c

143

priv->tx_stats[P54_QUEUE_AC_VI].limit = 16;

drivers/net/wireless/intersil/p54/fwio.c

144

priv->tx_stats[P54_QUEUE_AC_BE].limit = 16;

drivers/net/wireless/intersil/p54/fwio.c

145

priv->tx_stats[P54_QUEUE_AC_BK].limit = 16;

drivers/net/wireless/intersil/p54/fwio.c

147

priv->tx_stats[P54_QUEUE_AC_VO].limit = 3;

drivers/net/wireless/intersil/p54/fwio.c

148

priv->tx_stats[P54_QUEUE_AC_VI].limit = 4;

drivers/net/wireless/intersil/p54/fwio.c

149

priv->tx_stats[P54_QUEUE_AC_BE].limit = 3;

drivers/net/wireless/intersil/p54/fwio.c

150

priv->tx_stats[P54_QUEUE_AC_BK].limit = 2;

drivers/net/wireless/intersil/p54/main.c

765

priv->tx_stats[P54_QUEUE_BEACON].limit = 1;

drivers/net/wireless/intersil/p54/main.c

766

priv->tx_stats[P54_QUEUE_FWSCAN].limit = 1;

drivers/net/wireless/intersil/p54/main.c

767

priv->tx_stats[P54_QUEUE_MGMT].limit = 3;

drivers/net/wireless/intersil/p54/main.c

768

priv->tx_stats[P54_QUEUE_CAB].limit = 3;

drivers/net/wireless/intersil/p54/main.c

769

priv->tx_stats[P54_QUEUE_DATA].limit = 5;

drivers/net/wireless/intersil/p54/p54.h

160

unsigned int limit;

drivers/net/wireless/intersil/p54/p54pci.c

138

u32 limit, idx, i;

drivers/net/wireless/intersil/p54/p54pci.c

141

limit = idx;

drivers/net/wireless/intersil/p54/p54pci.c

142

limit -= index;

drivers/net/wireless/intersil/p54/p54pci.c

143

limit = ring_limit - limit;

drivers/net/wireless/intersil/p54/p54pci.c

146

while (limit-- > 1) {

drivers/net/wireless/intersil/p54/txrx.c

179

priv->tx_stats[i + P54_QUEUE_DATA].limit)

drivers/net/wireless/intersil/p54/txrx.c

198

if (unlikely(queue->len >= queue->limit && IS_QOS_QUEUE(p54_queue))) {

drivers/net/wireless/intersil/p54/txrx.c

206

if (unlikely(queue->len == queue->limit && IS_QOS_QUEUE(p54_queue))) {

drivers/net/wireless/marvell/mwifiex/fw.h

2064

u8 limit;

drivers/net/wireless/marvell/mwifiex/uap_cmd.c

592

retry_limit->limit = (u8)bss_cfg->retry_limit;

drivers/net/wireless/marvell/mwl8k.c

1212

static int rxq_refill(struct ieee80211_hw *hw, int index, int limit)

drivers/net/wireless/marvell/mwl8k.c

1218

while (rxq->rxd_count < MWL8K_RX_DESCS && limit--) {

drivers/net/wireless/marvell/mwl8k.c

1328

static int rxq_process(struct ieee80211_hw *hw, int index, int limit)

drivers/net/wireless/marvell/mwl8k.c

1336

while (rxq->rxd_count && limit--) {

drivers/net/wireless/marvell/mwl8k.c

1681

mwl8k_txq_reclaim(struct ieee80211_hw *hw, int index, int limit, int force)

drivers/net/wireless/marvell/mwl8k.c

1688

while (txq->len > 0 && limit--) {

drivers/net/wireless/marvell/mwl8k.c

4715

int limit;

drivers/net/wireless/marvell/mwl8k.c

4718

limit = 32;

drivers/net/wireless/marvell/mwl8k.c

4723

limit -= mwl8k_txq_reclaim(hw, i, limit, 0);

drivers/net/wireless/marvell/mwl8k.c

4732

if (limit) {

drivers/net/wireless/marvell/mwl8k.c

4744

int limit;

drivers/net/wireless/marvell/mwl8k.c

4746

limit = 32;

drivers/net/wireless/marvell/mwl8k.c

4747

limit -= rxq_process(hw, 0, limit);

drivers/net/wireless/marvell/mwl8k.c

4748

limit -= rxq_refill(hw, 0, limit);

drivers/net/wireless/marvell/mwl8k.c

4750

if (limit) {

drivers/net/wireless/mediatek/mt76/mt76x02_phy.c

171

u8 limit = dev->cal.low_gain > 0 ? 16 : 4;

drivers/net/wireless/mediatek/mt76/mt76x02_phy.c

178

if (false_cca > 800 && dev->cal.agc_gain_adjust < limit) {

drivers/net/wireless/mediatek/mt76/mt76x02_phy.c

182

(dev->cal.agc_gain_adjust >= limit && false_cca < 500)) {

drivers/net/wireless/mediatek/mt76/mt76x02_phy.c

187

dev->cal.agc_lowest_gain = dev->cal.agc_gain_adjust >= limit;

drivers/net/wireless/mediatek/mt76/mt76x02_phy.c

74

void mt76x02_limit_rate_power(struct mt76x02_rate_power *r, int limit)

drivers/net/wireless/mediatek/mt76/mt76x02_phy.c

79

if (r->all[i] > limit)

drivers/net/wireless/mediatek/mt76/mt76x02_phy.c

80

r->all[i] = limit;

drivers/net/wireless/mediatek/mt76/mt76x02_phy.h

39

void mt76x02_limit_rate_power(struct mt76x02_rate_power *r, int limit);

drivers/net/wireless/mediatek/mt76/mt792x_acpi_sar.c

295

u8 *limit, band, max;

drivers/net/wireless/mediatek/mt76/mt792x_acpi_sar.c

301

limit = &asar->dyn->tbl[0].frp[0];

drivers/net/wireless/mediatek/mt76/mt792x_acpi_sar.c

304

limit = &asar->dyn_v2->tbl[0].frp[0];

drivers/net/wireless/mediatek/mt76/mt792x_acpi_sar.c

318

return mt792x_asar_get_geo_pwr(phy, band, limit[idx]);

drivers/net/wireless/ralink/rt2x00/rt2400pci.c

1768

queue->limit = 24;

drivers/net/wireless/ralink/rt2x00/rt2400pci.c

1778

queue->limit = 24;

drivers/net/wireless/ralink/rt2x00/rt2400pci.c

1785

queue->limit = 1;

drivers/net/wireless/ralink/rt2x00/rt2400pci.c

1792

queue->limit = 8;

drivers/net/wireless/ralink/rt2x00/rt2400pci.c

767

rt2x00_set_field32(&reg, TXCSR2_NUM_TXD, rt2x00dev->tx[1].limit);

drivers/net/wireless/ralink/rt2x00/rt2400pci.c

768

rt2x00_set_field32(&reg, TXCSR2_NUM_ATIM, rt2x00dev->atim->limit);

drivers/net/wireless/ralink/rt2x00/rt2400pci.c

769

rt2x00_set_field32(&reg, TXCSR2_NUM_PRIO, rt2x00dev->tx[0].limit);

drivers/net/wireless/ralink/rt2x00/rt2400pci.c

798

rt2x00_set_field32(&reg, RXCSR1_NUM_RXD, rt2x00dev->rx->limit);

drivers/net/wireless/ralink/rt2x00/rt2500pci.c

2066

queue->limit = 32;

drivers/net/wireless/ralink/rt2x00/rt2500pci.c

2076

queue->limit = 32;

drivers/net/wireless/ralink/rt2x00/rt2500pci.c

2083

queue->limit = 1;

drivers/net/wireless/ralink/rt2x00/rt2500pci.c

2090

queue->limit = 8;

drivers/net/wireless/ralink/rt2x00/rt2500pci.c

852

rt2x00_set_field32(&reg, TXCSR2_NUM_TXD, rt2x00dev->tx[1].limit);

drivers/net/wireless/ralink/rt2x00/rt2500pci.c

853

rt2x00_set_field32(&reg, TXCSR2_NUM_ATIM, rt2x00dev->atim->limit);

drivers/net/wireless/ralink/rt2x00/rt2500pci.c

854

rt2x00_set_field32(&reg, TXCSR2_NUM_PRIO, rt2x00dev->tx[0].limit);

drivers/net/wireless/ralink/rt2x00/rt2500pci.c

883

rt2x00_set_field32(&reg, RXCSR1_NUM_RXD, rt2x00dev->rx->limit);

drivers/net/wireless/ralink/rt2x00/rt2500usb.c

1855

queue->limit = 32;

drivers/net/wireless/ralink/rt2x00/rt2500usb.c

1865

queue->limit = 32;

drivers/net/wireless/ralink/rt2x00/rt2500usb.c

1872

queue->limit = 1;

drivers/net/wireless/ralink/rt2x00/rt2500usb.c

1879

queue->limit = 8;

drivers/net/wireless/ralink/rt2x00/rt2800lib.c

1391

for (i = 0; i < queue->limit; i++) {

drivers/net/wireless/ralink/rt2x00/rt2800lib.c

1960

for (i = 0; i < queue->limit; i++) {

drivers/net/wireless/ralink/rt2x00/rt2800mmio.c

573

queue->limit = 128;

drivers/net/wireless/ralink/rt2x00/rt2800mmio.c

584

queue->limit = 64;

drivers/net/wireless/ralink/rt2x00/rt2800mmio.c

592

queue->limit = 8;

drivers/net/wireless/ralink/rt2x00/rt2800mmio.c

672

rt2x00dev->tx[0].limit);

drivers/net/wireless/ralink/rt2x00/rt2800mmio.c

680

rt2x00dev->tx[1].limit);

drivers/net/wireless/ralink/rt2x00/rt2800mmio.c

688

rt2x00dev->tx[2].limit);

drivers/net/wireless/ralink/rt2x00/rt2800mmio.c

696

rt2x00dev->tx[3].limit);

drivers/net/wireless/ralink/rt2x00/rt2800mmio.c

714

rt2x00dev->rx[0].limit);

drivers/net/wireless/ralink/rt2x00/rt2800mmio.c

716

rt2x00dev->rx[0].limit - 1);

drivers/net/wireless/ralink/rt2x00/rt2800usb.c

311

((rt2x00dev->rx->limit * DATA_FRAME_SIZE)

drivers/net/wireless/ralink/rt2x00/rt2800usb.c

727

queue->limit = 128;

drivers/net/wireless/ralink/rt2x00/rt2800usb.c

738

queue->limit = 16;

drivers/net/wireless/ralink/rt2x00/rt2800usb.c

746

queue->limit = 8;

drivers/net/wireless/ralink/rt2x00/rt2x00debug.c

325

queue->count, queue->limit, queue->length,

drivers/net/wireless/ralink/rt2x00/rt2x00dev.c

1170

rt2x00dev->tx->limit *

drivers/net/wireless/ralink/rt2x00/rt2x00dev.c

1457

if (rt2x00dev->bcn->limit > 0)

drivers/net/wireless/ralink/rt2x00/rt2x00mac.c

226

for (i = 0; i < queue->limit; i++) {

drivers/net/wireless/ralink/rt2x00/rt2x00mac.c

232

if (unlikely(i == queue->limit))

drivers/net/wireless/ralink/rt2x00/rt2x00mac.c

820

*tx_max += queue->limit;

drivers/net/wireless/ralink/rt2x00/rt2x00mac.c

824

*rx_max = rt2x00dev->rx->limit;

drivers/net/wireless/ralink/rt2x00/rt2x00mmio.c

112

queue->limit * queue->desc_size, &dma,

drivers/net/wireless/ralink/rt2x00/rt2x00mmio.c

120

for (i = 0; i < queue->limit; i++) {

drivers/net/wireless/ralink/rt2x00/rt2x00mmio.c

137

queue->limit * queue->desc_size,

drivers/net/wireless/ralink/rt2x00/rt2x00queue.c

1092

for (i = 0; i < queue->limit; i++)

drivers/net/wireless/ralink/rt2x00/rt2x00queue.c

1109

entries = kcalloc(queue->limit, entry_size, GFP_KERNEL);

drivers/net/wireless/ralink/rt2x00/rt2x00queue.c

1117

for (i = 0; i < queue->limit; i++) {

drivers/net/wireless/ralink/rt2x00/rt2x00queue.c

1123

QUEUE_ENTRY_PRIV_OFFSET(entries, i, queue->limit,

drivers/net/wireless/ralink/rt2x00/rt2x00queue.c

1141

for (i = 0; i < queue->limit; i++) {

drivers/net/wireless/ralink/rt2x00/rt2x00queue.c

1151

for (i = 0; i < queue->limit; i++) {

drivers/net/wireless/ralink/rt2x00/rt2x00queue.c

1228

queue->threshold = DIV_ROUND_UP(queue->limit, 10);

drivers/net/wireless/ralink/rt2x00/rt2x00queue.c

824

for (i = index_start; i < queue->limit; i++) {

drivers/net/wireless/ralink/rt2x00/rt2x00queue.c

875

if (queue->index[index] >= queue->limit)

drivers/net/wireless/ralink/rt2x00/rt2x00queue.h

463

unsigned short limit;

drivers/net/wireless/ralink/rt2x00/rt2x00queue.h

602

return queue->length == queue->limit;

drivers/net/wireless/ralink/rt2x00/rt2x00queue.h

611

return queue->limit - queue->length;

drivers/net/wireless/ralink/rt2x00/rt2x00usb.c

656

for (i = 0; i < queue->limit; i++) {

drivers/net/wireless/ralink/rt2x00/rt2x00usb.c

672

for (i = 0; i < queue->limit; i++) {

drivers/net/wireless/ralink/rt2x00/rt2x00usb.c

692

for (i = 0; i < queue->limit; i++) {

drivers/net/wireless/ralink/rt2x00/rt2x00usb.c

707

for (i = 0; i < queue->limit; i++) {

drivers/net/wireless/ralink/rt2x00/rt61pci.c

1337

rt2x00dev->tx[0].limit);

drivers/net/wireless/ralink/rt2x00/rt61pci.c

1339

rt2x00dev->tx[1].limit);

drivers/net/wireless/ralink/rt2x00/rt61pci.c

1341

rt2x00dev->tx[2].limit);

drivers/net/wireless/ralink/rt2x00/rt61pci.c

1343

rt2x00dev->tx[3].limit);

drivers/net/wireless/ralink/rt2x00/rt61pci.c

1376

rt2x00_set_field32(&reg, RX_RING_CSR_RING_SIZE, rt2x00dev->rx->limit);

drivers/net/wireless/ralink/rt2x00/rt61pci.c

2081

for (i = 0; i < rt2x00dev->tx->limit; i++) {

drivers/net/wireless/ralink/rt2x00/rt61pci.c

2100

if (unlikely(index >= queue->limit))

drivers/net/wireless/ralink/rt2x00/rt61pci.c

2942

queue->limit = 32;

drivers/net/wireless/ralink/rt2x00/rt61pci.c

2952

queue->limit = 32;

drivers/net/wireless/ralink/rt2x00/rt61pci.c

2959

queue->limit = 4;

drivers/net/wireless/ralink/rt2x00/rt73usb.c

2358

queue->limit = 32;

drivers/net/wireless/ralink/rt2x00/rt73usb.c

2368

queue->limit = 32;

drivers/net/wireless/ralink/rt2x00/rt73usb.c

2375

queue->limit = 4;

drivers/net/wireless/realtek/rtlwifi/rtl8192d/rf_common.c

169

u8 limit;

drivers/net/wireless/realtek/rtlwifi/rtl8192d/rf_common.c

178

limit = rtlefuse->pwrgroup_ht40[rf][channel - 1];

drivers/net/wireless/realtek/rtlwifi/rtl8192d/rf_common.c

180

limit = rtlefuse->pwrgroup_ht20[rf][channel - 1];

drivers/net/wireless/realtek/rtlwifi/rtl8192d/rf_common.c

182

if (pwr_diff_limit[i] > limit)

drivers/net/wireless/realtek/rtlwifi/rtl8192d/rf_common.c

183

pwr_diff_limit[i] = limit;

drivers/net/wireless/realtek/rtlwifi/rtl8821ae/phy.c

2483

s8 limit = 0;

drivers/net/wireless/realtek/rtlwifi/rtl8821ae/phy.c

2563

limit = _rtl8812ae_phy_get_txpower_limit(hw, band,

drivers/net/wireless/realtek/rtlwifi/rtl8821ae/phy.c

2569

if (limit < 0) {

drivers/net/wireless/realtek/rtlwifi/rtl8821ae/phy.c

2570

if (tx_pwr_diff < (-limit))

drivers/net/wireless/realtek/rtlwifi/rtl8821ae/phy.c

2571

tx_pwr_diff = -limit;

drivers/net/wireless/realtek/rtlwifi/rtl8821ae/phy.c

2574

if (limit < 0)

drivers/net/wireless/realtek/rtlwifi/rtl8821ae/phy.c

2575

tx_pwr_diff = limit;

drivers/net/wireless/realtek/rtlwifi/rtl8821ae/phy.c

2577

tx_pwr_diff = tx_pwr_diff > limit ? limit : tx_pwr_diff;

drivers/net/wireless/realtek/rtlwifi/rtl8821ae/phy.c

2581

limit, tx_pwr_diff);

drivers/net/wireless/realtek/rtw88/pci.c

1042

u8 hw_queue, u32 limit)

drivers/net/wireless/realtek/rtw88/pci.c

1060

count = min(count, limit);

drivers/net/wireless/realtek/rtw88/phy.c

2248

s8 *limit = &pwr_param->pwr_limit;

drivers/net/wireless/realtek/rtw88/phy.c

2270

*limit = rtw_phy_get_tx_power_limit(rtwdev, band, bw, path,

drivers/net/wireless/realtek/rtw88/sdio.c

1254

int limit, queue;

drivers/net/wireless/realtek/rtw88/sdio.c

1263

for (limit = 0; limit < 1000; limit++) {

drivers/net/wireless/realtek/rtw88/usb.c

467

int i, limit;

drivers/net/wireless/realtek/rtw88/usb.c

470

for (limit = 0; limit < 200; limit++) {

drivers/net/wireless/realtek/rtw88/usb.c

614

int limit;

drivers/net/wireless/realtek/rtw88/usb.c

616

for (limit = 0; limit < 200; limit++) {

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

1186

if (ref->limit.enable)

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

1188

ref->limit.max_toa + aux->duration);

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

1189

else if (aux->limit.enable)

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

1191

ref->duration + aux->limit.max_tob);

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

1207

if (ref->limit.enable) {

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

1208

upper = min_t(s16, upper, ref->limit.max_toa);

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

1209

lower = max_t(s16, lower, ref->duration - ref->limit.max_tob);

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

1210

} else if (aux->limit.enable) {

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

1212

res - (aux->duration - aux->limit.max_toa));

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

1213

lower = max_t(s16, lower, res - aux->limit.max_tob);

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

1277

if (ref->limit.enable) {

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

1278

if (min_tob > ref->limit.max_tob || min_toa > ref->limit.max_toa) {

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

1284

upper_toa_ref = min_t(s16, upper_toa_ref, ref->limit.max_toa);

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

1286

ref->duration - ref->limit.max_tob);

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

1287

} else if (aux->limit.enable) {

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

1288

if (min_tob > aux->limit.max_tob || min_toa > aux->limit.max_toa) {

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

1294

upper_tob_aux = min_t(s16, upper_tob_aux, aux->limit.max_tob);

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

1296

aux->duration - aux->limit.max_toa);

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

1328

if (ref->limit.enable) {

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

1329

ref_tob = ref->limit.max_tob;

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

1330

ref_toa = ref->limit.max_toa;

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

1360

if (aux->limit.enable) {

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

1361

aux_tob = aux->limit.max_tob;

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

1362

aux_toa = aux->limit.max_toa;

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

1394

else if (bcn_ofst < aux->duration - aux->limit.max_toa)

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

1429

if (ref->limit.enable && aux->limit.enable) {

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

1435

if (ref->limit.enable &&

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

1436

ref->duration > ref->limit.max_tob + ref->limit.max_toa) {

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

1442

if (aux->limit.enable &&

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

1443

aux->duration > aux->limit.max_tob + aux->limit.max_toa) {

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

1513

if (role_go->limit.enable)

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

1514

dur_go = min(dur_go, role_go->limit.max_dur);

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

1545

if (ref->limit.enable) {

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

1546

dur_ref = min(dur_ref, ref->limit.max_dur);

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

1548

} else if (aux->limit.enable) {

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

1549

dur_aux = min(dur_aux, aux->limit.max_dur);

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

1674

if (role_non_2ghz->limit.enable) {

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

1677

role_non_2ghz->limit.max_dur);

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

1679

dur_non_2ghz = min(dur_non_2ghz, role_non_2ghz->limit.max_dur);

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

2852

memset(&mcc_role->limit, 0, sizeof(mcc_role->limit));

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

953

mcc_role->limit.max_toa = max_toa_us / 1024;

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

954

mcc_role->limit.max_tob = max_tob_us / 1024;

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

955

mcc_role->limit.max_dur = mcc_role->limit.max_toa + mcc_role->limit.max_tob;

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

956

mcc_role->limit.enable = true;

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

960

mcc_role->limit.max_toa, mcc_role->limit.max_tob,

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

961

mcc_role->limit.max_dur);

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

6015

struct rtw89_mcc_limit limit;

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

4693

int limit;

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

4713

for (limit = 0; limit < 5000 && rule < rule_end; limit++) {

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

2343

int limit = 200;

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

2430

} while (!goout && agc_cnt < 6 && limit-- > 0);

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

2218

int limit = 200;

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

2318

} while (!goout && agc_cnt < 6 && limit-- > 0);

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

2269

int limit = 200;

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

2384

} while (!goout && agc_cnt < 6 && limit-- > 0);

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

2334

int limit = 200;

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

2423

} while (!goout && agc_cnt < 6 && --limit > 0);

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

2425

if (limit <= 0)

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

416

int limit;

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

418

for (limit = 0; limit < 200; limit++) {

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

453

if (limit == 200) {

drivers/net/wireless/st/cw1200/txrx.c

107

if (limit < count)

drivers/net/wireless/st/cw1200/txrx.c

108

limit = count;

drivers/net/wireless/st/cw1200/txrx.c

109

if (total > limit) {

drivers/net/wireless/st/cw1200/txrx.c

112

if (rates[i].count > limit - left)

drivers/net/wireless/st/cw1200/txrx.c

113

rates[i].count = limit - left;

drivers/net/wireless/st/cw1200/txrx.c

114

limit -= rates[i].count;

drivers/net/wireless/st/cw1200/txrx.c

70

unsigned limit = priv->short_frame_max_tx_count;

drivers/ntb/hw/amd/ntb_hw_amd.c

126

u64 base_addr, limit, reg_val;

drivers/ntb/hw/amd/ntb_hw_amd.c

152

limit = size;

drivers/ntb/hw/amd/ntb_hw_amd.c

163

write64(limit, peer_mmio + limit_reg);

drivers/ntb/hw/amd/ntb_hw_amd.c

165

if (reg_val != limit) {

drivers/ntb/hw/amd/ntb_hw_amd.c

175

limit = size;

drivers/ntb/hw/amd/ntb_hw_amd.c

186

writel(limit, peer_mmio + limit_reg);

drivers/ntb/hw/amd/ntb_hw_amd.c

188

if (reg_val != limit) {

drivers/ntb/hw/idt/ntb_hw_idt.c

1309

u64 limit;

drivers/ntb/hw/idt/ntb_hw_idt.c

1318

limit = pci_bus_address(ntb->pdev, mw_cfg->bar) + size;

drivers/ntb/hw/idt/ntb_hw_idt.c

1319

idt_nt_write(ndev, bar->limit, (u32)limit);

drivers/ntb/hw/idt/ntb_hw_idt.c

1321

idt_nt_write(ndev, (bar + 1)->limit, (limit >> 32));

drivers/ntb/hw/idt/ntb_hw_idt.c

1373

idt_nt_write(ndev, bar->limit, 0);

drivers/ntb/hw/idt/ntb_hw_idt.c

1375

idt_nt_write(ndev, (bar + 1)->limit, 0);

drivers/ntb/hw/idt/ntb_hw_idt.h

1164

unsigned int limit;

drivers/ntb/hw/intel/ntb_hw_gen1.c

850

u64 base, limit, reg_val;

drivers/ntb/hw/intel/ntb_hw_gen1.c

888

limit = base + size;

drivers/ntb/hw/intel/ntb_hw_gen1.c

890

limit = 0;

drivers/ntb/hw/intel/ntb_hw_gen1.c

901

iowrite64(limit, mmio + limit_reg);

drivers/ntb/hw/intel/ntb_hw_gen1.c

903

if (reg_val != limit) {

drivers/ntb/hw/intel/ntb_hw_gen1.c

919

limit = base + size;

drivers/ntb/hw/intel/ntb_hw_gen1.c

921

limit = 0;

drivers/ntb/hw/intel/ntb_hw_gen1.c

932

iowrite32(limit, mmio + limit_reg);

drivers/ntb/hw/intel/ntb_hw_gen1.c

934

if (reg_val != limit) {

drivers/ntb/hw/intel/ntb_hw_gen3.c

453

u64 base, limit, reg_val;

drivers/ntb/hw/intel/ntb_hw_gen3.c

488

limit = base + size;

drivers/ntb/hw/intel/ntb_hw_gen3.c

490

limit = base + mw_size;

drivers/ntb/hw/intel/ntb_hw_gen3.c

503

iowrite64(limit, mmio + limit_reg);

drivers/ntb/hw/intel/ntb_hw_gen3.c

505

if (reg_val != limit) {

drivers/ntb/hw/intel/ntb_hw_gen3.c

519

limit = base + size;

drivers/ntb/hw/intel/ntb_hw_gen3.c

521

limit = base + mw_size;

drivers/ntb/hw/intel/ntb_hw_gen3.c

524

iowrite64(limit, mmio + limit_reg);

drivers/ntb/hw/intel/ntb_hw_gen3.c

526

if (reg_val != limit) {

drivers/ntb/hw/intel/ntb_hw_gen4.c

355

u64 base, limit, reg_val;

drivers/ntb/hw/intel/ntb_hw_gen4.c

395

limit = base + size;

drivers/ntb/hw/intel/ntb_hw_gen4.c

398

limit = base + mw_size;

drivers/ntb/hw/intel/ntb_hw_gen4.c

414

iowrite64(limit, mmio + limit_reg);

drivers/ntb/hw/intel/ntb_hw_gen4.c

416

if (reg_val != limit) {

drivers/nvme/target/pci-epf.c

1709

unsigned long limit = jiffies;

drivers/nvme/target/pci-epf.c

1728

if (time_is_before_jiffies(limit + secs_to_jiffies(1))) {

drivers/nvme/target/pci-epf.c

1730

limit = jiffies;

drivers/of/fdt.c

50

void __init of_fdt_limit_memory(int limit)

drivers/of/fdt.c

60

if (len > limit*cell_size) {

drivers/of/fdt.c

61

len = limit*cell_size;

drivers/of/fdt.c

62

pr_debug("Limiting number of entries to %d\n", limit);

drivers/parisc/gsc.c

92

int gsc_find_local_irq(unsigned int irq, int *global_irqs, int limit)

drivers/parisc/gsc.c

96

for (local_irq = 0; local_irq < limit; local_irq++) {

drivers/parisc/gsc.h

42

int gsc_find_local_irq(unsigned int irq, int *global_irq, int limit);

drivers/parport/parport_ip32.c

485

static void parport_ip32_dma_setup_context(unsigned int limit)

drivers/parport/parport_ip32.c

499

if (parport_ip32_dma.left <= limit) {

drivers/parport/parport_ip32.c

503

count = limit;

drivers/parport/parport_ip32.c

509

limit,

drivers/parport/parport_ip32.c

570

unsigned int limit;

drivers/parport/parport_ip32.c

603

limit = MACEPAR_CONTEXT_DATA_BOUND -

drivers/parport/parport_ip32.c

605

parport_ip32_dma_setup_context(limit);

drivers/pci/endpoint/pci-epf-core.c

370

dma_addr_t limit;

drivers/pci/endpoint/pci-epf-core.c

376

limit = bar_addr + size - 1;

drivers/pci/endpoint/pci-epf-core.c

392

if ((limit ^ bar_addr) & BIT_ULL(pos))

drivers/pci/endpoint/pci-epf-core.c

410

if (epf_bar[bar].phys_addr + bar_size < limit)

drivers/pci/ide.c

531

#define PREP_PCI_IDE_SEL_ADDR1(base, limit) \

drivers/pci/ide.c

536

FIELD_GET(SEL_ADDR1_LOWER, (limit))))

drivers/pci/probe.c

395

unsigned long io_mask, io_granularity, base, limit;

drivers/pci/probe.c

409

limit = (io_limit_lo & io_mask) << 8;

drivers/pci/probe.c

417

limit |= ((unsigned long) io_limit_hi << 16);

drivers/pci/probe.c

422

if (base <= limit) {

drivers/pci/probe.c

424

region.end = limit + io_granularity - 1;

drivers/pci/probe.c

438

unsigned long base, limit;

drivers/pci/probe.c

444

limit = ((unsigned long) mem_limit_lo & PCI_MEMORY_RANGE_MASK) << 16;

drivers/pci/probe.c

448

if (base <= limit) {

drivers/pci/probe.c

450

region.end = limit + 0xfffff;

drivers/pci/probe.c

465

pci_bus_addr_t base, limit;

drivers/pci/probe.c

491

limit = (pci_bus_addr_t) limit64;

drivers/pci/probe.c

504

if (base <= limit) {

drivers/pci/probe.c

506

region.end = limit + 0xfffff;

drivers/perf/arm_spe_pmu.c

499

u64 limit = buf->nr_pages * PAGE_SIZE;

drivers/perf/arm_spe_pmu.c

507

if (head < limit >> 1)

drivers/perf/arm_spe_pmu.c

508

limit >>= 1;

drivers/perf/arm_spe_pmu.c

514

if (limit - head < spe_pmu->max_record_sz) {

drivers/perf/arm_spe_pmu.c

515

arm_spe_pmu_pad_buf(handle, limit - head);

drivers/perf/arm_spe_pmu.c

516

handle->head = PERF_IDX2OFF(limit, buf);

drivers/perf/arm_spe_pmu.c

517

limit = ((buf->nr_pages * PAGE_SIZE) >> 1) + handle->head;

drivers/perf/arm_spe_pmu.c

520

return limit;

drivers/perf/arm_spe_pmu.c

528

u64 limit = bufsize;

drivers/perf/arm_spe_pmu.c

569

limit = round_down(tail, PAGE_SIZE);

drivers/perf/arm_spe_pmu.c

581

limit = min(limit, round_up(wakeup, PAGE_SIZE));

drivers/perf/arm_spe_pmu.c

583

if (limit > head)

drivers/perf/arm_spe_pmu.c

584

return limit;

drivers/perf/arm_spe_pmu.c

597

u64 limit = __arm_spe_pmu_next_off(handle);

drivers/perf/arm_spe_pmu.c

604

if (limit && (limit - head < spe_pmu->max_record_sz)) {

drivers/perf/arm_spe_pmu.c

605

arm_spe_pmu_pad_buf(handle, limit - head);

drivers/perf/arm_spe_pmu.c

606

limit = __arm_spe_pmu_next_off(handle);

drivers/perf/arm_spe_pmu.c

609

return limit;

drivers/perf/arm_spe_pmu.c

615

u64 base, limit;

drivers/perf/arm_spe_pmu.c

619

limit = FIELD_PREP(PMBLIMITR_EL1_FM, PMBLIMITR_EL1_FM_DISCARD);

drivers/perf/arm_spe_pmu.c

620

limit |= PMBLIMITR_EL1_E;

drivers/perf/arm_spe_pmu.c

631

limit = 0;

drivers/perf/arm_spe_pmu.c

635

limit = buf->snapshot ? arm_spe_pmu_next_snapshot_off(handle)

drivers/perf/arm_spe_pmu.c

637

if (limit)

drivers/perf/arm_spe_pmu.c

638

limit |= PMBLIMITR_EL1_E;

drivers/perf/arm_spe_pmu.c

640

limit += (u64)buf->base;

drivers/perf/arm_spe_pmu.c

645

write_sysreg_s(limit, SYS_PMBLIMITR_EL1);

drivers/perf/arm_spe_pmu.c

646

return (limit & PMBLIMITR_EL1_E) ? 0 : -EIO;

drivers/perf/xgene_pmu.c

560

XGENE_PMU_EVENT_ATTR(tmac-limit-reached, 0x2b),

drivers/power/supply/bq24190_charger.c

460

int i, limit = ARRAY_SIZE(bq24190_sysfs_field_tbl);

drivers/power/supply/bq24190_charger.c

462

for (i = 0; i < limit; i++)

drivers/power/supply/bq24190_charger.c

465

bq24190_sysfs_attrs[limit] = NULL; /* Has additional entry for this */

drivers/power/supply/bq24190_charger.c

471

int i, limit = ARRAY_SIZE(bq24190_sysfs_field_tbl);

drivers/power/supply/bq24190_charger.c

473

for (i = 0; i < limit; i++)

drivers/power/supply/bq24190_charger.c

477

if (i >= limit)

drivers/power/supply/bq24190_charger.c

832

int ret, limit = 100;

drivers/power/supply/bq24190_charger.c

869

} while (--limit);

drivers/power/supply/bq27xxx_battery.c

1363

const int limit = 100;

drivers/power/supply/bq27xxx_battery.c

1365

int ret, try = limit;

drivers/power/supply/bq27xxx_battery.c

1383

if (limit - try > 3)

drivers/power/supply/bq27xxx_battery.c

1384

dev_warn(di->dev, "cfgupdate %d, retries %d\n", active, limit - try);

drivers/power/supply/rt9455_charger.c

302

int ret, limit = 100;

drivers/power/supply/rt9455_charger.c

325

} while (--limit);

drivers/power/supply/rt9455_charger.c

327

if (!limit)

drivers/power/supply/sc2731_charger.c

100

else if (limit <= SC2731_CURRENT_LIMIT_900)

drivers/power/supply/sc2731_charger.c

331

if (info->limit > 0 && !info->charging) {

drivers/power/supply/sc2731_charger.c

333

ret = sc2731_charger_set_current_limit(info, info->limit);

drivers/power/supply/sc2731_charger.c

337

ret = sc2731_charger_set_current(info, info->limit);

drivers/power/supply/sc2731_charger.c

346

} else if (!info->limit && info->charging) {

drivers/power/supply/sc2731_charger.c

357

unsigned long limit, void *data)

drivers/power/supply/sc2731_charger.c

362

info->limit = limit;

drivers/power/supply/sc2731_charger.c

450

info->limit = min;

drivers/power/supply/sc2731_charger.c

64

u32 limit;

drivers/power/supply/sc2731_charger.c

92

u32 limit)

drivers/power/supply/sc2731_charger.c

96

if (limit <= SC2731_CURRENT_LIMIT_100)

drivers/power/supply/sc2731_charger.c

98

else if (limit <= SC2731_CURRENT_LIMIT_500)

drivers/power/supply/wm831x_power.c

141

unsigned long limit, void *data)

drivers/power/supply/wm831x_power.c

152

if (limit >= wm831x_usb_limits[i] &&

drivers/ras/amd/atl/core.c

25

dram_limit_addr = FIELD_GET(DF4_DRAM_LIMIT_ADDR, ctx->map.limit);

drivers/ras/amd/atl/core.c

27

dram_limit_addr = FIELD_GET(DF2_DRAM_LIMIT_ADDR, ctx->map.limit);

drivers/ras/amd/atl/denormalize.c

22

case DF2: return FIELD_GET(DF2_DST_FABRIC_ID, ctx->map.limit);

drivers/ras/amd/atl/denormalize.c

23

case DF3: return FIELD_GET(DF3_DST_FABRIC_ID, ctx->map.limit);

drivers/ras/amd/atl/denormalize.c

24

case DF3p5: return FIELD_GET(DF3p5_DST_FABRIC_ID, ctx->map.limit);

drivers/ras/amd/atl/internal.h

200

u32 limit;

drivers/ras/amd/atl/map.c

184

u16 dst_fabric_id = FIELD_GET(DF3_DST_FABRIC_ID, ctx->map.limit);

drivers/ras/amd/atl/map.c

221

ctx->inst_id, &ctx->map.limit))

drivers/ras/amd/atl/map.c

252

ctx->inst_id, &ctx->map.limit))

drivers/ras/amd/atl/map.c

308

ctx->inst_id, &ctx->map.limit))

drivers/ras/amd/atl/map.c

582

dies = FIELD_GET(DF2_INTLV_NUM_DIES, ctx->map.limit);

drivers/ras/amd/atl/map.c

609

sockets = FIELD_GET(DF2_INTLV_NUM_SOCKETS, ctx->map.limit);

drivers/ras/amd/atl/map.c

745

pr_debug("limit=0x%x", map->limit);

drivers/regulator/core.c

1389

int limit, int severity)

drivers/regulator/core.c

1393

if (limit == REGULATOR_NOTIF_LIMIT_DISABLE) {

drivers/regulator/core.c

1395

limit = 0;

drivers/regulator/core.c

1400

if (limit == REGULATOR_NOTIF_LIMIT_ENABLE)

drivers/regulator/core.c

1401

limit = 0;

drivers/regulator/core.c

1403

return set(rdev, limit, severity, enable);

drivers/regulator/da9063-regulator.c

548

int val, ret, limit;

drivers/regulator/da9063-regulator.c

551

limit = regulator_get_current_limit_regmap(rdev);

drivers/regulator/da9063-regulator.c

552

if (limit < 0)

drivers/regulator/da9063-regulator.c

553

return limit;

drivers/regulator/da9063-regulator.c

560

limit *= 2;

drivers/regulator/da9063-regulator.c

562

return limit;

drivers/regulator/of_regulator.c

24

static void fill_limit(int *limit, int val)

drivers/regulator/of_regulator.c

28

*limit = REGULATOR_NOTIF_LIMIT_ENABLE;

drivers/regulator/of_regulator.c

30

*limit = val;

drivers/regulator/of_regulator.c

32

*limit = REGULATOR_NOTIF_LIMIT_DISABLE;

drivers/s390/char/sclp.c

121

int len = sccb->length, limit = SCLP_TRACE_MAX_SIZE;

drivers/s390/char/sclp.c

130

limit = SCLP_TRACE_ENTRY_SIZE;

drivers/s390/char/sclp.c

132

return min(len, limit);

drivers/s390/net/qeth_core_sys.c

105

unsigned int portno, limit;

drivers/s390/net/qeth_core_sys.c

120

limit = (card->ssqd.pcnt ? card->ssqd.pcnt - 1 : card->ssqd.pcnt);

drivers/s390/net/qeth_core_sys.c

121

if (portno > limit) {

drivers/sbus/char/bbc_i2c.c

127

int limit = 32;

drivers/sbus/char/bbc_i2c.c

132

while (limit-- > 0) {

drivers/sbus/char/envctrl.c

188

int limit = 1000000;

drivers/sbus/char/envctrl.c

190

while (--limit > 0) {

drivers/sbus/char/envctrl.c

196

if (limit <= 0)

drivers/sbus/char/envctrl.c

205

int limit = 1000000;

drivers/sbus/char/envctrl.c

207

while (--limit > 0) {

drivers/sbus/char/envctrl.c

214

if (limit <= 0)

drivers/scsi/atari_scsi.c

542

int possible_len, limit;

drivers/scsi/atari_scsi.c

613

limit = (atari_dma_buffer && !STRAM_ADDR(virt_to_phys(NCR5380_to_ncmd(cmd)->ptr))) ?

drivers/scsi/atari_scsi.c

615

if (possible_len > limit)

drivers/scsi/atari_scsi.c

616

possible_len = limit;

drivers/scsi/be2iscsi/be.h

40

static inline u32 MODULO(u16 val, u16 limit)

drivers/scsi/be2iscsi/be.h

42

WARN_ON(limit & (limit - 1));

drivers/scsi/be2iscsi/be.h

43

return val & (limit - 1);

drivers/scsi/be2iscsi/be.h

46

static inline void index_inc(u16 *index, u16 limit)

drivers/scsi/be2iscsi/be.h

48

*index = MODULO((*index + 1), limit);

drivers/scsi/esas2r/esas2r.h

1175

sgc->sge.a64.limit = (struct atto_vda_sge *)((u8 *)rq->vrq

drivers/scsi/esas2r/esas2r.h

610

struct atto_vda_sge *limit;

drivers/scsi/esas2r/esas2r_io.c

222

if (unlikely(sgc->sge.a64.curr > sgc->sge.a64.limit)) {

drivers/scsi/esas2r/esas2r_io.c

252

sgc->sge.a64.limit =

drivers/scsi/ibmvscsi/ibmvscsi.c

817

static void ibmvscsi_set_request_limit(struct ibmvscsi_host_data *hostdata, int limit)

drivers/scsi/ibmvscsi/ibmvscsi.c

822

atomic_set(&hostdata->request_limit, limit);

drivers/scsi/qla2xxx/qla_init.c

4241

u16 limit;

drivers/scsi/qla2xxx/qla_init.c

4245

limit = (ha->orig_fw_iocb_count * QLA_IOCB_PCT_LIMIT) / 100;

drivers/scsi/qla2xxx/qla_init.c

4248

qpair->fwres.iocbs_limit = limit;

drivers/scsi/qla2xxx/qla_init.c

4249

qpair->fwres.iocbs_qp_limit = limit / num_qps;

drivers/scsi/smartpqi/smartpqi_init.c

853

static inline u32 pqi_aio_limit_to_bytes(__le16 *limit)

drivers/scsi/smartpqi/smartpqi_init.c

857

bytes = get_unaligned_le16(limit);

drivers/soc/fsl/qbman/qman.c

1613

unsigned int limit = 0;

drivers/soc/fsl/qbman/qman.c

1680

} while (++limit < poll_limit && res != qman_cb_dqrr_consume_stop);

drivers/soc/fsl/qbman/qman.c

1682

return limit;

drivers/soc/fsl/qbman/qman.c

1757

int qman_p_poll_dqrr(struct qman_portal *p, unsigned int limit)

drivers/soc/fsl/qbman/qman.c

1759

return __poll_portal_fast(p, limit, false);

drivers/spi/spi-bcm63xx-hsspi.c

238

unsigned long limit;

drivers/spi/spi-bcm63xx-hsspi.c

247

limit = jiffies + msecs_to_jiffies(HSSPI_POLL_STATUS_TIMEOUT_MS);

drivers/spi/spi-bcm63xx-hsspi.c

249

while (!time_after(jiffies, limit)) {

drivers/spi/spi-bcmbca-hsspi.c

223

unsigned long limit;

drivers/spi/spi-bcmbca-hsspi.c

231

limit = jiffies + msecs_to_jiffies(HSSPI_POLL_STATUS_TIMEOUT_MS);

drivers/spi/spi-bcmbca-hsspi.c

233

while (!time_after(jiffies, limit)) {

drivers/spi/spi-hisi-kunpeng.c

196

unsigned long limit = loops_per_jiffy << 1;

drivers/spi/spi-hisi-kunpeng.c

201

} while (hisi_spi_busy(hs) && limit--);

drivers/spi/spi-intel.c

1205

unsigned int base, unsigned int limit)

drivers/spi/spi-intel.c

1219

if (pr_base >= base && pr_limit <= limit)

drivers/spi/spi-intel.c

1247

u32 region, base, limit;

drivers/spi/spi-intel.c

1251

limit = (region & FREG_LIMIT_MASK) >> FREG_LIMIT_SHIFT;

drivers/spi/spi-intel.c

1253

if (base >= limit || limit == 0)

drivers/spi/spi-intel.c

1265

intel_spi_is_protected(ispi, base, limit))) {

drivers/spi/spi-intel.c

1270

end = (limit << 12) + 4096;

drivers/spi/spi-intel.c

243

u32 base, limit;

drivers/spi/spi-intel.c

249

limit = (value & PR_LIMIT_MASK) >> PR_LIMIT_SHIFT;

drivers/spi/spi-intel.c

253

i, base << 12, (limit << 12) | 0xfff,

drivers/spi/spi-intel.c

259

u32 region, base, limit;

drivers/spi/spi-intel.c

263

limit = (region & FREG_LIMIT_MASK) >> FREG_LIMIT_SHIFT;

drivers/spi/spi-intel.c

265

if (base >= limit || (i > 0 && limit == 0))

drivers/spi/spi-intel.c

269

i, base << 12, (limit << 12) | 0xfff);

drivers/spi/spi-pl022.c

454

unsigned long limit = loops_per_jiffy << 1;

drivers/spi/spi-pl022.c

460

} while ((readw(SSP_SR(pl022->virtbase)) & SSP_SR_MASK_BSY) && limit--);

drivers/spi/spi-pl022.c

464

return limit;

drivers/spi/spi-pxa2xx.c

461

unsigned long limit = loops_per_jiffy << 1;

drivers/spi/spi-pxa2xx.c

466

} while ((pxa2xx_spi_read(drv_data, SSSR) & SSSR_BSY) && --limit);

drivers/spi/spi-pxa2xx.c

469

return limit;

drivers/spi/spi.c

2203

unsigned int limit = 500;

drivers/spi/spi.c

2221

} while (--limit);

drivers/ssb/driver_chipcommon.c

152

int limit;

drivers/ssb/driver_chipcommon.c

189

limit = 43000;

drivers/ssb/driver_chipcommon.c

191

limit = 25000;

drivers/ssb/driver_chipcommon.c

195

limit = 20200000;

drivers/ssb/driver_chipcommon.c

197

limit = 19800000;

drivers/ssb/driver_chipcommon.c

201

limit = 34000000;

drivers/ssb/driver_chipcommon.c

203

limit = 25000000;

drivers/ssb/driver_chipcommon.c

206

limit /= divisor;

drivers/ssb/driver_chipcommon.c

208

return limit;

drivers/staging/media/atomisp/pci/runtime/debug/src/ia_css_debug.c

1668

int i, j, max_trace_points, point_num, limit = -1;

drivers/staging/media/atomisp/pci/runtime/debug/src/ia_css_debug.c

1735

if ((limit == (-1)) && (trace_read_buf[i] == 0))

drivers/staging/media/atomisp/pci/runtime/debug/src/ia_css_debug.c

1736

limit = i;

drivers/staging/media/atomisp/pci/runtime/debug/src/ia_css_debug.c

1758

if ((limit == point_num - 1) ||

drivers/staging/media/atomisp/pci/runtime/debug/src/ia_css_debug.c

1760

(trace_read_buf[limit + 1] ==

drivers/staging/media/atomisp/pci/runtime/debug/src/ia_css_debug.c

1762

limit = 0;

drivers/staging/media/atomisp/pci/runtime/debug/src/ia_css_debug.c

1765

limit++;

drivers/staging/media/atomisp/pci/runtime/debug/src/ia_css_debug.c

1769

j = (limit + i) % point_num;

drivers/staging/media/atomisp/pci/runtime/debug/src/ia_css_debug.c

798

int limit = SH_CSS_NUM_SP_DEBUG;

drivers/staging/media/atomisp/pci/runtime/debug/src/ia_css_debug.c

803

for (i = base; i < limit; i += step) {

drivers/staging/rtl8723bs/core/rtw_ieee80211.c

137

u8 *rtw_get_ie(u8 *pbuf, signed int index, signed int *len, signed int limit)

drivers/staging/rtl8723bs/core/rtw_ieee80211.c

142

if (limit < 2)

drivers/staging/rtl8723bs/core/rtw_ieee80211.c

148

while (i + 2 <= limit) {

drivers/staging/rtl8723bs/core/rtw_ieee80211.c

150

if (i + 2 + tmp > limit)

drivers/staging/rtl8723bs/core/rtw_ieee80211.c

361

unsigned char *rtw_get_wpa_ie(unsigned char *pie, int *wpa_ie_len, int limit)

drivers/staging/rtl8723bs/core/rtw_ieee80211.c

367

int limit_new = limit;

drivers/staging/rtl8723bs/core/rtw_ieee80211.c

396

limit_new = limit - (pbuf - pie) - 2 - len;

drivers/staging/rtl8723bs/core/rtw_ieee80211.c

409

unsigned char *rtw_get_wpa2_ie(unsigned char *pie, int *rsn_ie_len, int limit)

drivers/staging/rtl8723bs/core/rtw_ieee80211.c

411

return rtw_get_ie(pie, WLAN_EID_RSN, rsn_ie_len, limit);

drivers/staging/rtl8723bs/hal/hal_com.c

544

u8 i, limit;

drivers/staging/rtl8723bs/hal/hal_com.c

560

limit = 8; /* 1R */

drivers/staging/rtl8723bs/hal/hal_com.c

562

for (i = 0; i < limit; i++) {

drivers/staging/rtl8723bs/hal/rtl8723b_phycfg.c

532

s8 txPower = 0, powerDiffByRate = 0, limit = 0;

drivers/staging/rtl8723bs/hal/rtl8723b_phycfg.c

537

limit = phy_get_tx_pwr_lmt(

drivers/staging/rtl8723bs/hal/rtl8723b_phycfg.c

546

powerDiffByRate = powerDiffByRate > limit ? limit : powerDiffByRate;

drivers/staging/rtl8723bs/include/ieee80211.h

735

u8 *rtw_get_ie(u8 *pbuf, signed int index, signed int *len, signed int limit);

drivers/staging/rtl8723bs/include/ieee80211.h

741

unsigned char *rtw_get_wpa_ie(unsigned char *pie, int *wpa_ie_len, int limit);

drivers/staging/rtl8723bs/include/ieee80211.h

742

unsigned char *rtw_get_wpa2_ie(unsigned char *pie, int *rsn_ie_len, int limit);

drivers/thermal/intel/int340x_thermal/acpi_thermal_rel.c

308

memset(&psvt->limit, 0, sizeof(u64));

drivers/thermal/intel/int340x_thermal/acpi_thermal_rel.c

309

strscpy(psvt->limit.string, psvt_ptr->limit.str_ptr, ACPI_LIMIT_STR_MAX_LEN);

drivers/thermal/intel/int340x_thermal/acpi_thermal_rel.c

311

psvt->limit.integer = psvt_ptr->limit.integer;

drivers/thermal/intel/int340x_thermal/acpi_thermal_rel.c

468

strscpy(psvt_user[i].limit.string, psvts[i].limit.string,

drivers/thermal/intel/int340x_thermal/acpi_thermal_rel.c

471

psvt_user[i].limit.integer = psvts[i].limit.integer;

drivers/thermal/intel/int340x_thermal/acpi_thermal_rel.h

128

} limit;

drivers/thermal/intel/int340x_thermal/acpi_thermal_rel.h

74

} limit;

drivers/tty/serial/liteuart.c

284

struct xa_limit limit;

drivers/tty/serial/liteuart.c

307

limit = XA_LIMIT(0, CONFIG_SERIAL_LITEUART_MAX_PORTS);

drivers/tty/serial/liteuart.c

309

limit = XA_LIMIT(dev_id, dev_id);

drivers/tty/serial/liteuart.c

311

ret = xa_alloc(&liteuart_array, &dev_id, uart, limit, GFP_KERNEL);

drivers/tty/serial/sunhv.c

120

int limit = 10000;

drivers/tty/serial/sunhv.c

122

while (limit-- > 0) {

drivers/tty/serial/sunhv.c

274

int limit = 10000;

drivers/tty/serial/sunhv.c

281

while (limit-- > 0) {

drivers/tty/serial/sunhv.c

301

int limit = 10000;

drivers/tty/serial/sunhv.c

305

while (limit-- > 0) {

drivers/tty/serial/sunhv.c

459

int limit = 1000000;

drivers/tty/serial/sunhv.c

461

while (limit--) {

drivers/tty/serial/sunhv.c

470

if (limit < 0)

drivers/tty/serial/sunhv.c

483

int limit = 1000000;

drivers/tty/serial/sunhv.c

485

while (limit-- > 0) {

drivers/tty/serial/sunhv.c

77

int limit = 10000;

drivers/tty/serial/sunhv.c

79

while (limit-- > 0) {

drivers/tty/tty_buffer.c

599

int tty_buffer_set_limit(struct tty_port *port, int limit)

drivers/tty/tty_buffer.c

601

if (limit < MIN_TTYB_SIZE)

drivers/tty/tty_buffer.c

603

port->buf.mem_limit = limit;

drivers/usb/dwc2/gadget.c

118

u16 limit = DSTS_SOFFN_LIMIT;

drivers/usb/dwc2/gadget.c

121

limit >>= 3;

drivers/usb/dwc2/gadget.c

124

if (hs_ep->target_frame > limit) {

drivers/usb/dwc2/gadget.c

126

hs_ep->target_frame &= limit;

drivers/usb/dwc2/gadget.c

1352

u16 limit = DSTS_SOFFN_LIMIT;

drivers/usb/dwc2/gadget.c

1355

limit >>= 3;

drivers/usb/dwc2/gadget.c

1361

((current_frame - target_frame) < limit / 2))

drivers/usb/dwc2/gadget.c

145

u16 limit = DSTS_SOFFN_LIMIT;

drivers/usb/dwc2/gadget.c

148

limit >>= 3;

drivers/usb/dwc2/gadget.c

153

hs_ep->target_frame = limit;

drivers/usb/gadget/function/f_hid.c

1330

#define F_HID_OPT(name, prec, limit) \

drivers/usb/gadget/function/f_hid.c

1360

if (num > limit) { \

drivers/usb/gadget/function/f_mass_storage.c

1287

int len, limit;

drivers/usb/gadget/function/f_mass_storage.c

1312

limit = 255;

drivers/usb/gadget/function/f_mass_storage.c

1316

limit = 65535; /* Should really be FSG_BUFLEN */

drivers/usb/gadget/function/f_mass_storage.c

1351

if (!valid_page || len > limit) {

drivers/usb/gadget/function/f_midi.c

1097

#define F_MIDI_OPT(name, test_limit, limit) \

drivers/usb/gadget/function/f_midi.c

1127

if (test_limit && num > limit) { \

drivers/usb/gadget/function/f_midi.c

1141

#define F_MIDI_OPT_SIGNED(name, test_limit, limit) \

drivers/usb/gadget/function/f_midi.c

1171

if (test_limit && num > limit) { \

drivers/usb/gadget/function/uvc_configfs.c

187

#define UVCG_CTRL_HDR_ATTR(cname, aname, bits, limit) \

drivers/usb/gadget/function/uvc_configfs.c

236

if (num > limit) { \

drivers/usb/gadget/function/uvc_configfs.c

3707

#define UVCG_OPTS_ATTR(cname, aname, limit) \

drivers/usb/gadget/function/uvc_configfs.c

3739

if (num > limit) { \

drivers/usb/gadget/udc/dummy_hcd.c

1412

struct dummy_ep *ep, int limit, int *status)

drivers/usb/gadget/udc/dummy_hcd.c

1448

if (limit < ep->ep.maxpacket && limit < len)

drivers/usb/gadget/udc/dummy_hcd.c

1450

len = min_t(unsigned, len, limit);

drivers/usb/gadget/udc/dummy_hcd.c

1470

limit -= len;

drivers/usb/gadget/udc/dummy_hcd.c

1553

int limit = ep->ep.maxpacket;

drivers/usb/gadget/udc/dummy_hcd.c

1561

limit += limit * tmp;

drivers/usb/gadget/udc/dummy_hcd.c

1567

limit = 3 * 16 * 1024 * 8;

drivers/usb/gadget/udc/dummy_hcd.c

1571

limit = 3 * 1024 * 8;

drivers/usb/gadget/udc/dummy_hcd.c

1578

return limit;

drivers/usb/gadget/udc/dummy_hcd.c

1805

int limit, total;

drivers/usb/gadget/udc/dummy_hcd.c

1944

limit = 64*1024;

drivers/usb/gadget/udc/dummy_hcd.c

1963

limit = total;

drivers/usb/gadget/udc/dummy_hcd.c

1975

limit = max(limit, periodic_bytes(dum, ep));

drivers/usb/gadget/udc/dummy_hcd.c

1983

limit = max(limit, periodic_bytes(dum, ep));

drivers/usb/gadget/udc/dummy_hcd.c

1989

total -= transfer(dum_hcd, urb, ep, limit, &status);

drivers/usb/host/ohci-hcd.c

353

unsigned limit = 1000;

drivers/usb/host/ohci-hcd.c

373

if (limit-- == 0) {

drivers/usb/isp1760/isp1760-if.c

37

u8 latency, limit;

drivers/usb/isp1760/isp1760-if.c

65

pci_read_config_byte(dev, PCI_MAX_LAT, &limit);

drivers/usb/isp1760/isp1760-if.c

66

if (limit && limit < latency)

drivers/usb/isp1760/isp1760-if.c

67

pci_write_config_byte(dev, PCI_LATENCY_TIMER, limit);

drivers/usb/mon/mon_text.c

101

int cnt, limit;

drivers/usb/mon/mon_text.c

413

ptr.limit = rp->printf_size;

drivers/usb/mon/mon_text.c

417

ptr.cnt += scnprintf(ptr.pbuf + ptr.cnt, ptr.limit - ptr.cnt,

drivers/usb/mon/mon_text.c

452

ptr.limit = rp->printf_size;

drivers/usb/mon/mon_text.c

465

ptr.cnt += scnprintf(ptr.pbuf + ptr.cnt, ptr.limit - ptr.cnt,

drivers/usb/mon/mon_text.c

523

p->cnt += scnprintf(p->pbuf + p->cnt, p->limit - p->cnt,

drivers/usb/mon/mon_text.c

541

p->cnt += scnprintf(p->pbuf + p->cnt, p->limit - p->cnt,

drivers/usb/mon/mon_text.c

552

p->cnt += scnprintf(p->pbuf + p->cnt, p->limit - p->cnt,

drivers/usb/mon/mon_text.c

560

p->cnt += scnprintf(p->pbuf + p->cnt, p->limit - p->cnt,

drivers/usb/mon/mon_text.c

563

p->cnt += scnprintf(p->pbuf + p->cnt, p->limit - p->cnt,

drivers/usb/mon/mon_text.c

571

p->cnt += scnprintf(p->pbuf + p->cnt, p->limit - p->cnt,

drivers/usb/mon/mon_text.c

579

p->cnt += scnprintf(p->pbuf + p->cnt, p->limit - p->cnt,

drivers/usb/mon/mon_text.c

582

p->cnt += scnprintf(p->pbuf + p->cnt, p->limit - p->cnt,

drivers/usb/mon/mon_text.c

595

p->cnt += scnprintf(p->pbuf + p->cnt, p->limit - p->cnt,

drivers/usb/mon/mon_text.c

604

p->cnt += scnprintf(p->pbuf + p->cnt, p->limit - p->cnt,

drivers/usb/mon/mon_text.c

617

p->cnt += scnprintf(p->pbuf + p->cnt, p->limit - p->cnt,

drivers/usb/mon/mon_text.c

624

p->limit - p->cnt,

drivers/usb/mon/mon_text.c

628

p->limit - p->cnt,

drivers/usb/mon/mon_text.c

631

p->cnt += scnprintf(p->pbuf + p->cnt, p->limit - p->cnt,

drivers/usb/mon/mon_text.c

634

p->cnt += scnprintf(p->pbuf + p->cnt, p->limit - p->cnt,

drivers/usb/mon/mon_text.c

638

p->cnt += scnprintf(p->pbuf + p->cnt, p->limit - p->cnt, "\n");

drivers/usb/mtu3/mtu3.h

146

u32 limit;

drivers/usb/mtu3/mtu3_core.c

31

if (num_bits > fifo->limit)

drivers/usb/mtu3/mtu3_core.c

37

fifo->limit, 0, num_bits, 0);

drivers/usb/mtu3/mtu3_core.c

38

if (start_bit >= fifo->limit)

drivers/usb/mtu3/mtu3_core.c

551

tx_fifo->limit = fifosize / MTU3_EP_FIFO_UNIT;

drivers/usb/mtu3/mtu3_core.c

557

rx_fifo->limit = fifosize / MTU3_EP_FIFO_UNIT;

drivers/usb/mtu3/mtu3_core.c

564

tx_fifo->limit = (fifosize / MTU3_EP_FIFO_UNIT) >> 1;

drivers/usb/mtu3/mtu3_core.c

569

tx_fifo->base + tx_fifo->limit * MTU3_EP_FIFO_UNIT;

drivers/usb/mtu3/mtu3_core.c

570

rx_fifo->limit = tx_fifo->limit;

drivers/usb/mtu3/mtu3_core.c

576

__func__, tx_fifo->base, tx_fifo->limit,

drivers/usb/mtu3/mtu3_core.c

577

rx_fifo->base, rx_fifo->limit);

drivers/usb/mtu3/mtu3_core.c

58

if (unlikely(addr < fifo->base || bits > fifo->limit))

drivers/usb/typec/tcpm/tcpm.c

1138

u32 limit;

drivers/usb/typec/tcpm/tcpm.c

1143

limit = 1500;

drivers/usb/typec/tcpm/tcpm.c

1146

limit = 3000;

drivers/usb/typec/tcpm/tcpm.c

1151

limit = port->tcpc->get_current_limit(port->tcpc);

drivers/usb/typec/tcpm/tcpm.c

1153

limit = 0;

drivers/usb/typec/tcpm/tcpm.c

1157

return limit;

drivers/usb/usbip/vudc_transfer.c

184

struct urb *urb, struct vep *ep, int limit)

drivers/usb/usbip/vudc_transfer.c

311

int total, limit;

drivers/usb/usbip/vudc_transfer.c

385

limit = 64 * 1024;

drivers/usb/usbip/vudc_transfer.c

394

limit = total;

drivers/usb/usbip/vudc_transfer.c

406

limit += urb->transfer_buffer_length;

drivers/usb/usbip/vudc_transfer.c

410

total -= transfer(udc, urb, ep, limit);

drivers/vdpa/vdpa_user/iova_domain.c

407

unsigned long size, unsigned long limit)

drivers/vdpa/vdpa_user/iova_domain.c

413

iova_pfn = alloc_iova_fast(iovad, iova_len, limit >> shift, true);

drivers/vdpa/vdpa_user/iova_domain.c

453

unsigned long limit = domain->bounce_size - 1;

drivers/vdpa/vdpa_user/iova_domain.c

455

dma_addr_t iova = vduse_domain_alloc_iova(iovad, size, limit);

drivers/vdpa/vdpa_user/iova_domain.c

500

unsigned long limit = domain->iova_limit;

drivers/vdpa/vdpa_user/iova_domain.c

501

dma_addr_t iova = vduse_domain_alloc_iova(iovad, size, limit);

drivers/vfio/vfio_iommu_type1.c

1589

unsigned long pfn, limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;

drivers/vfio/vfio_iommu_type1.c

1597

size >> PAGE_SHIFT, &pfn, limit,

drivers/vfio/vfio_iommu_type1.c

1810

unsigned long limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;

drivers/vfio/vfio_iommu_type1.c

1866

&pfn, limit,

drivers/vfio/vfio_iommu_type1.c

678

unsigned long limit, struct vfio_batch *batch)

drivers/vfio/vfio_iommu_type1.c

770

mm->locked_vm + lock_acct + acct_pages > limit) {

drivers/vfio/vfio_iommu_type1.c

772

__func__, limit << PAGE_SHIFT);

drivers/vhost/iotlb.c

134

void vhost_iotlb_init(struct vhost_iotlb *iotlb, unsigned int limit,

drivers/vhost/iotlb.c

138

iotlb->limit = limit;

drivers/vhost/iotlb.c

152

struct vhost_iotlb *vhost_iotlb_alloc(unsigned int limit, unsigned int flags)

drivers/vhost/iotlb.c

159

vhost_iotlb_init(iotlb, limit, flags);

drivers/vhost/iotlb.c

75

if (iotlb->limit &&

drivers/vhost/iotlb.c

76

iotlb->nmaps == iotlb->limit &&

drivers/video/backlight/corgi_lcd.c

434

void corgi_lcd_limit_intensity(int limit)

drivers/video/backlight/corgi_lcd.c

436

if (limit)

drivers/video/fbdev/aty/mach64_gx.c

131

u32 limit; /* pixlock rounding limit (arbitrary) */

drivers/video/fbdev/aty/mach64_gx.c

153

if (vclk_per <= RGB514_clocks[i].limit) {

drivers/video/fbdev/cg6.c

273

int limit = 10000;

drivers/video/fbdev/cg6.c

279

} while (--limit > 0);

drivers/video/fbdev/ffb.c

397

int limit = 10000;

drivers/video/fbdev/ffb.c

407

} while (--limit > 0);

drivers/w1/masters/ds2490.c

376

int ds_stop_pulse(struct ds_device *dev, int limit)

drivers/w1/masters/ds2490.c

397

} while (++count < limit);

drivers/xen/gntalloc.c

295

if (gref_size + op.count > limit) {

drivers/xen/gntalloc.c

73

static int limit = 1024;

drivers/xen/gntalloc.c

74

module_param(limit, int, 0644);

drivers/xen/gntalloc.c

75

MODULE_PARM_DESC(limit, "Maximum number of grants that may be allocated by "

drivers/xen/gntdev.c

71

static unsigned int limit = 64*1024;

drivers/xen/gntdev.c

72

module_param(limit, uint, 0644);

drivers/xen/gntdev.c

73

MODULE_PARM_DESC(limit,

drivers/xen/gntdev.c

85

return !count || count > limit;

fs/9p/v9fs.c

591

ssize_t n = 0, count = 0, limit = PAGE_SIZE;

fs/9p/v9fs.c

597

n = snprintf(buf + count, limit, "%s\n", v9ses->cachetag);

fs/9p/v9fs.c

604

limit -= n;

fs/attr.c

259

unsigned long limit;

fs/attr.c

261

limit = rlimit(RLIMIT_FSIZE);

fs/attr.c

262

if (limit != RLIM_INFINITY && offset > limit)

fs/btrfs/block-group.c

2045

void btrfs_reclaim_block_groups(struct btrfs_fs_info *fs_info, unsigned int limit)

fs/btrfs/block-group.c

2105

if (reclaimed >= limit)

fs/btrfs/block-group.h

353

void btrfs_reclaim_block_groups(struct btrfs_fs_info *fs_info, unsigned int limit);

fs/btrfs/delayed-ref.c

239

u64 limit = btrfs_calc_delayed_ref_bytes(fs_info, 1);

fs/btrfs/delayed-ref.c

248

num_bytes = min(num_bytes, limit);

fs/btrfs/qgroup.c

1922

struct btrfs_qgroup_limit *limit)

fs/btrfs/qgroup.c

1946

if (limit->flags & BTRFS_QGROUP_LIMIT_MAX_RFER) {

fs/btrfs/qgroup.c

1947

if (limit->max_rfer == CLEAR_VALUE) {

fs/btrfs/qgroup.c

1949

limit->flags &= ~BTRFS_QGROUP_LIMIT_MAX_RFER;

fs/btrfs/qgroup.c

1952

qgroup->max_rfer = limit->max_rfer;

fs/btrfs/qgroup.c

1955

if (limit->flags & BTRFS_QGROUP_LIMIT_MAX_EXCL) {

fs/btrfs/qgroup.c

1956

if (limit->max_excl == CLEAR_VALUE) {

fs/btrfs/qgroup.c

1958

limit->flags &= ~BTRFS_QGROUP_LIMIT_MAX_EXCL;

fs/btrfs/qgroup.c

1961

qgroup->max_excl = limit->max_excl;

fs/btrfs/qgroup.c

1964

if (limit->flags & BTRFS_QGROUP_LIMIT_RSV_RFER) {

fs/btrfs/qgroup.c

1965

if (limit->rsv_rfer == CLEAR_VALUE) {

fs/btrfs/qgroup.c

1967

limit->flags &= ~BTRFS_QGROUP_LIMIT_RSV_RFER;

fs/btrfs/qgroup.c

1970

qgroup->rsv_rfer = limit->rsv_rfer;

fs/btrfs/qgroup.c

1973

if (limit->flags & BTRFS_QGROUP_LIMIT_RSV_EXCL) {

fs/btrfs/qgroup.c

1974

if (limit->rsv_excl == CLEAR_VALUE) {

fs/btrfs/qgroup.c

1976

limit->flags &= ~BTRFS_QGROUP_LIMIT_RSV_EXCL;

fs/btrfs/qgroup.c

1979

qgroup->rsv_excl = limit->rsv_excl;

fs/btrfs/qgroup.c

1982

qgroup->lim_flags |= limit->flags;

fs/btrfs/qgroup.h

349

struct btrfs_qgroup_limit *limit);

fs/btrfs/sysfs.c

2038

unsigned long long limit;

fs/btrfs/sysfs.c

2040

limit = memparse(buf, &endptr);

fs/btrfs/sysfs.c

2045

WRITE_ONCE(device->scrub_speed_max, limit);

fs/btrfs/volumes.c

3764

cpu->limit = le64_to_cpu(disk->limit);

fs/btrfs/volumes.c

3783

disk->limit = cpu_to_le64(cpu->limit);

fs/btrfs/volumes.c

4190

if (bargs->limit == 0)

fs/btrfs/volumes.c

4193

bargs->limit--;

fs/btrfs/volumes.c

4334

u64 limit_data = bctl->data.limit;

fs/btrfs/volumes.c

4335

u64 limit_meta = bctl->meta.limit;

fs/btrfs/volumes.c

4336

u64 limit_sys = bctl->sys.limit;

fs/btrfs/volumes.c

4361

bctl->data.limit = limit_data;

fs/btrfs/volumes.c

4362

bctl->meta.limit = limit_meta;

fs/btrfs/volumes.c

4363

bctl->sys.limit = limit_sys;

fs/btrfs/volumes.c

4681

CHECK_APPEND_1ARG("limit=%llu,", bargs->limit);

fs/btrfs/volumes.c

5637

u64 limit;

fs/btrfs/volumes.c

5658

limit = max(round_down(mult_perc(fs_devices->total_rw_bytes, 10),

fs/btrfs/volumes.c

5661

ctl->max_chunk_size = min(limit, ctl->max_chunk_size);

fs/buffer.c

2287

loff_t limit = i_size_read(inode);

fs/buffer.c

2291

limit = inode->i_sb->s_maxbytes;

fs/buffer.c

2297

lblock = div_u64(limit + blocksize - 1, blocksize);

fs/ceph/file.c

2343

loff_t limit = max(i_size_read(inode), fsc->max_file_size);

fs/ceph/file.c

2375

if (unlikely(pos >= limit)) {

fs/ceph/file.c

2379

iov_iter_truncate(from, limit - pos);

fs/configfs/item.c

51

int limit = CONFIGFS_ITEM_NAME_LEN;

fs/configfs/item.c

60

need = vsnprintf(item->ci_namebuf, limit, fmt, args);

fs/configfs/item.c

62

if (need < limit)

fs/coredump.c

1001

cprm->limit = RLIM_INFINITY;

fs/coredump.c

1172

.limit = rlimit(RLIMIT_CORE),

fs/coredump.c

1222

if (cprm->written + nr > cprm->limit)

fs/coredump.c

1297

if (cprm->written + PAGE_SIZE > cprm->limit)

fs/coredump.c

729

cprm->limit = RLIM_INFINITY;

fs/coredump.c

887

if (cprm->limit < binfmt->min_coredump)

fs/coredump.c

982

if (cprm->limit == 1) {

fs/dlm/lock.c

1504

struct xa_limit limit;

fs/dlm/lock.c

1508

limit.max = end;

fs/dlm/lock.c

1509

limit.min = start;

fs/dlm/lock.c

1525

rv = xa_alloc(&ls->ls_lkbxa, &lkb->lkb_id, lkb, limit, GFP_ATOMIC);

fs/dlm/recover.c

311

struct xa_limit limit = {

fs/dlm/recover.c

323

rv = xa_alloc(&ls->ls_recover_xa, &id, r, limit, GFP_ATOMIC);

fs/exec.c

370

unsigned long limit)

fs/exec.c

374

if (bprm->p < limit)

fs/exec.c

376

bprm->argmin = bprm->p - limit;

fs/exec.c

400

unsigned long limit, ptr_size;

fs/exec.c

410

limit = _STK_LIM / 4 * 3;

fs/exec.c

411

limit = min(limit, bprm->rlim_stack.rlim_cur / 4);

fs/exec.c

416

limit = max_t(unsigned long, limit, ARG_MAX);

fs/exec.c

436

if (limit <= ptr_size)

fs/exec.c

438

limit -= ptr_size;

fs/exec.c

440

return bprm_set_stack_limit(bprm, limit);

fs/ext2/dir.c

107

unsigned limit = folio_size(folio);

fs/ext2/dir.c

111

if (dir->i_size < folio_pos(folio) + limit) {

fs/ext2/dir.c

112

limit = offset_in_folio(folio, dir->i_size);

fs/ext2/dir.c

113

if (limit & (chunk_size - 1))

fs/ext2/dir.c

115

if (!limit)

fs/ext2/dir.c

118

for (offs = 0; offs <= limit - EXT2_DIR_REC_LEN(1); offs += rec_len) {

fs/ext2/dir.c

133

if (offs != limit)

fs/ext2/dir.c

280

char *limit;

fs/ext2/dir.c

298

limit = kaddr + ext2_last_byte(inode, n) - EXT2_DIR_REC_LEN(1);

fs/ext2/dir.c

299

for ( ;(char*)de <= limit; de = ext2_next_entry(de)) {

fs/ext4/inline.c

1029

void *limit;

fs/ext4/inline.c

1034

limit = de_buf + old_size;

fs/ext4/inline.c

1040

} while (de_buf < limit);

fs/ext4/namei.c

231

__le16 limit;

fs/ext4/namei.c

463

int count_offset, limit, count;

fs/ext4/namei.c

473

limit = le16_to_cpu(c->limit);

fs/ext4/namei.c

475

if (count_offset + (limit * sizeof(struct dx_entry)) >

fs/ext4/namei.c

480

t = (struct dx_tail *)(((struct dx_entry *)c) + limit);

fs/ext4/namei.c

492

int count_offset, limit, count;

fs/ext4/namei.c

502

limit = le16_to_cpu(c->limit);

fs/ext4/namei.c

504

if (count_offset + (limit * sizeof(struct dx_entry)) >

fs/ext4/namei.c

509

t = (struct dx_tail *)(((struct dx_entry *)c) + limit);

fs/ext4/namei.c

564

return le16_to_cpu(((struct dx_countlimit *) entries)->limit);

fs/ext4/namei.c

574

((struct dx_countlimit *) entries)->limit = cpu_to_le16(value);

fs/ext4/super.c

6901

u64 limit;

fs/ext4/super.c

6910

limit = min_not_zero(dquot->dq_dqb.dqb_bsoftlimit,

fs/ext4/super.c

6912

limit >>= sb->s_blocksize_bits;

fs/ext4/super.c

6914

if (limit) {

fs/ext4/super.c

6919

if (limit > curblock)

fs/ext4/super.c

6920

remaining = limit - curblock;

fs/ext4/super.c

6922

buf->f_blocks = min(buf->f_blocks, limit);

fs/ext4/super.c

6927

limit = min_not_zero(dquot->dq_dqb.dqb_isoftlimit,

fs/ext4/super.c

6929

if (limit) {

fs/ext4/super.c

6932

if (limit > dquot->dq_dqb.dqb_curinodes)

fs/ext4/super.c

6933

remaining = limit - dquot->dq_dqb.dqb_curinodes;

fs/ext4/super.c

6935

buf->f_files = min(buf->f_files, limit);

fs/f2fs/super.c

2167

u64 limit;

fs/f2fs/super.c

2176

limit = min_not_zero(dquot->dq_dqb.dqb_bsoftlimit,

fs/f2fs/super.c

2178

limit >>= sb->s_blocksize_bits;

fs/f2fs/super.c

2180

if (limit) {

fs/f2fs/super.c

2185

if (limit > curblock)

fs/f2fs/super.c

2186

remaining = limit - curblock;

fs/f2fs/super.c

2188

buf->f_blocks = min(buf->f_blocks, limit);

fs/f2fs/super.c

2193

limit = min_not_zero(dquot->dq_dqb.dqb_isoftlimit,

fs/f2fs/super.c

2196

if (limit) {

fs/f2fs/super.c

2199

if (limit > dquot->dq_dqb.dqb_curinodes)

fs/f2fs/super.c

2200

remaining = limit - dquot->dq_dqb.dqb_curinodes;

fs/f2fs/super.c

2202

buf->f_files = min(buf->f_files, limit);

fs/fat/cache.c

224

const int limit = sb->s_maxbytes >> sbi->cluster_bits;

fs/fat/cache.c

253

if (*fclus > limit) {

fs/fat/fatent.c

644

sector_t limit;

fs/fat/fatent.c

678

ra->limit = (block_end + 1) - blocknr;

fs/fat/fatent.c

684

ra->ra_limit = ra->cur + min_t(sector_t, reada_blocks, ra->limit);

fs/fat/fatent.c

716

ra->ra_blocks, ra->limit - ra->ra_limit);

fs/freevxfs/vxfs_lookup.c

197

loff_t pos, limit;

fs/freevxfs/vxfs_lookup.c

211

limit = VXFS_DIRROUND(ip->i_size);

fs/freevxfs/vxfs_lookup.c

212

if (ctx->pos > limit)

fs/freevxfs/vxfs_lookup.c

217

while (pos < limit) {

fs/freevxfs/vxfs_lookup.c

229

while (pg_ofs < PAGE_SIZE && pos < limit) {

fs/freevxfs/vxfs_lookup.c

64

loff_t limit = VXFS_DIRROUND(ip->i_size);

fs/freevxfs/vxfs_lookup.c

69

while (pos < limit) {

fs/freevxfs/vxfs_lookup.c

79

while (pg_ofs < PAGE_SIZE && pos < limit) {

fs/fuse/control.c

82

unsigned limit = (1 << 16) - 1;

fs/fuse/control.c

93

limit = min(limit, global_limit);

fs/fuse/control.c

95

if (t > limit)

fs/fuse/inode.c

1232

static void sanitize_global_limit(unsigned int *limit)

fs/fuse/inode.c

1238

if (*limit == 0)

fs/fuse/inode.c

1239

*limit = ((totalram_pages() << PAGE_SHIFT) >> 13) / 392;

fs/fuse/inode.c

1241

if (*limit >= 1 << 16)

fs/fuse/inode.c

1242

*limit = (1 << 16) - 1;

fs/gfs2/lops.c

640

static void gfs2_before_commit(struct gfs2_sbd *sdp, unsigned int limit,

fs/gfs2/lops.c

656

if (total > limit)

fs/gfs2/lops.c

657

num = limit;

fs/gfs2/lops.c

714

unsigned int limit = buf_limit(sdp); /* 503 for 4k blocks */

fs/gfs2/lops.c

719

gfs2_before_commit(sdp, limit, nbuf, &tr->tr_buf, 0);

fs/gfs2/lops.c

991

unsigned int limit = databuf_limit(sdp);

fs/gfs2/lops.c

996

gfs2_before_commit(sdp, limit, nbuf, &tr->tr_databuf, 1);

fs/gfs2/quota.c

1113

s64 value, change, limit;

fs/gfs2/quota.c

1125

limit = (s64)be64_to_cpu(qd->qd_qb.qb_limit);

fs/gfs2/quota.c

1126

if (value >= limit)

fs/gfs2/quota.c

1136

if (value + change < limit)

fs/gfs2/quota.c

1231

s64 value, warn, limit;

fs/gfs2/quota.c

1248

limit = (s64)be64_to_cpu(qd->qd_qb.qb_limit);

fs/gfs2/quota.c

1253

if (limit > 0 && (limit - value) < ap->allowed)

fs/gfs2/quota.c

1254

ap->allowed = limit - value;

fs/gfs2/quota.c

1256

if (limit && limit < (value + (s64)ap->target)) {

fs/jfs/jfs_types.h

144

#define setDASDLIMIT(dasdp, limit)\

fs/jfs/jfs_types.h

146

(dasdp)->limit_hi = ((u64)limit) >> 32;\

fs/jfs/jfs_types.h

147

(dasdp)->limit_lo = __cpu_to_le32(limit);\

fs/minix/dir.c

102

char *p, *kaddr, *limit;

fs/minix/dir.c

109

limit = kaddr + minix_last_byte(inode, n) - chunk_size;

fs/minix/dir.c

110

for ( ; p <= limit; p = minix_next_entry(p, sbi)) {

fs/minix/dir.c

169

char *kaddr, *limit;

fs/minix/dir.c

175

limit = kaddr + minix_last_byte(dir, n) - sbi->s_dirsize;

fs/minix/dir.c

176

for (p = kaddr; p <= limit; p = minix_next_entry(p, sbi)) {

fs/minix/dir.c

223

char *limit, *dir_end;

fs/minix/dir.c

230

limit = kaddr + PAGE_SIZE - sbi->s_dirsize;

fs/minix/dir.c

231

for (p = kaddr; p <= limit; p = minix_next_entry(p, sbi)) {

fs/minix/dir.c

366

char *p, *limit;

fs/minix/dir.c

372

limit = kaddr + minix_last_byte(inode, i) - sbi->s_dirsize;

fs/minix/dir.c

373

for (p = kaddr; p <= limit; p = minix_next_entry(p, sbi)) {

fs/netfs/buffered_read.c

114

size_t limit = netfs_limit_iter(&rreq->buffer.iter, 0, rsize,

fs/netfs/buffered_read.c

117

if (limit < rsize) {

fs/netfs/buffered_read.c

118

subreq->len = limit;

fs/netfs/direct_read.c

28

size_t limit = netfs_limit_iter(&rreq->buffer.iter, 0, rsize,

fs/netfs/direct_read.c

31

if (limit < rsize) {

fs/netfs/direct_read.c

32

subreq->len = limit;

fs/nfs/nfs4namespace.c

114

char *limit;

fs/nfs/nfs4namespace.c

115

char *path = nfs_path(&limit, dentry, buffer, buflen,

fs/nfs/nfs4namespace.c

118

char *path_component = nfs_path_component(path, limit);

fs/nfsd/nfscache.c

70

unsigned int limit;

fs/nfsd/nfscache.c

73

limit = (16 * int_sqrt(low_pages)) << (PAGE_SHIFT-10);

fs/nfsd/nfscache.c

74

return min_t(unsigned int, limit, 256*1024);

fs/nfsd/nfscache.c

82

nfsd_hashsize(unsigned int limit)

fs/nfsd/nfscache.c

84

return roundup_pow_of_two(limit / TARGET_BUCKET_SIZE);

fs/nilfs2/dir.c

116

size_t limit = folio_size(folio);

fs/nilfs2/dir.c

120

if (dir->i_size < folio_pos(folio) + limit) {

fs/nilfs2/dir.c

121

limit = dir->i_size - folio_pos(folio);

fs/nilfs2/dir.c

122

if (limit & (chunk_size - 1))

fs/nilfs2/dir.c

124

if (!limit)

fs/nilfs2/dir.c

127

for (offs = 0; offs <= limit - NILFS_DIR_REC_LEN(1); offs += rec_len) {

fs/nilfs2/dir.c

143

if (offs != limit)

fs/nilfs2/dir.c

248

char *kaddr, *limit;

fs/nilfs2/dir.c

259

limit = kaddr + nilfs_last_byte(inode, n) -

fs/nilfs2/dir.c

261

for ( ; (char *)de <= limit; de = nilfs_next_entry(de)) {

fs/nilfs2/dir.c

357

size_t limit;

fs/nilfs2/dir.c

364

limit = nilfs_last_byte(dir, 0); /* is a multiple of chunk size */

fs/nilfs2/dir.c

365

if (unlikely(!limit || le64_to_cpu(de->inode) != dir->i_ino ||

fs/ntfs3/super.c

1727

unsigned long limit = global_zone_page_state(NR_FREE_PAGES)

fs/ntfs3/super.c

1730

if (limit >= 0x2000)

fs/ntfs3/super.c

1731

limit -= 0x1000;

fs/ntfs3/super.c

1732

else if (limit < 32)

fs/ntfs3/super.c

1733

limit = 32;

fs/ntfs3/super.c

1735

limit >>= 1;

fs/ntfs3/super.c

1739

if (cnt++ >= limit) {

fs/ocfs2/dir.c

1235

char *trailer, *de_buf, *limit, *start = dirblock_bh->b_data;

fs/ocfs2/dir.c

1240

limit = start + size;

fs/ocfs2/dir.c

1252

} while (de_buf < limit);

fs/ocfs2/dir.c

2645

char *de_buf, *limit;

fs/ocfs2/dir.c

2652

limit = de_buf + dir->i_sb->s_blocksize;

fs/ocfs2/dir.c

2654

while (de_buf < limit) {

fs/ocfs2/dir.c

2690

char *de_buf, *limit;

fs/ocfs2/dir.c

2699

limit = de_buf + dir->i_sb->s_blocksize;

fs/ocfs2/dir.c

2701

while (de_buf < limit) {

fs/ocfs2/dir.c

2733

char *de_buf, *limit;

fs/ocfs2/dir.c

2738

limit = de_buf + i_size_read(dir);

fs/ocfs2/dir.c

2740

while (de_buf < limit) {

fs/ocfs2/dir.c

2773

char *de_buf, *limit;

fs/ocfs2/dir.c

2783

limit = start + old_size;

fs/ocfs2/dir.c

2794

} while (de_buf < limit);

fs/ocfs2/dir.c

3397

char *first_de, *de_buf, *limit;

fs/ocfs2/dir.c

3412

limit = de_buf + i_size_read(dir);

fs/ocfs2/dir.c

3415

while (de_buf < limit) {

fs/qnx6/dir.c

135

char *limit;

fs/qnx6/dir.c

143

limit = kaddr + last_entry(inode, n);

fs/qnx6/dir.c

144

for (; (char *)de < limit; de++, ctx->pos += QNX6_DIR_ENTRY_SIZE) {

fs/qnx6/dir.c

239

int limit = last_entry(dir, n);

fs/qnx6/dir.c

242

for (i = 0; i < limit; i++, de++) {

fs/read_write.c

1715

loff_t limit = rlimit(RLIMIT_FSIZE);

fs/read_write.c

1717

if (limit != RLIM_INFINITY) {

fs/read_write.c

1718

if (pos >= limit) {

fs/read_write.c

1722

*count = min(*count, limit - pos);

fs/romfs/storage.c

131

unsigned long pos, size_t limit)

fs/romfs/storage.c

140

while (limit > 0) {

fs/romfs/storage.c

142

segment = min_t(size_t, limit, ROMBSIZE - offset);

fs/romfs/storage.c

151

limit -= segment;

fs/romfs/storage.c

217

size_t limit;

fs/romfs/storage.c

219

limit = romfs_maxsize(sb);

fs/romfs/storage.c

220

if (pos >= limit || buflen > limit - pos)

fs/romfs/storage.c

240

size_t limit;

fs/romfs/storage.c

242

limit = romfs_maxsize(sb);

fs/romfs/storage.c

243

if (pos >= limit)

fs/romfs/storage.c

245

if (maxlen > limit - pos)

fs/romfs/storage.c

246

maxlen = limit - pos;

fs/romfs/storage.c

268

size_t limit;

fs/romfs/storage.c

270

limit = romfs_maxsize(sb);

fs/romfs/storage.c

271

if (pos >= limit)

fs/romfs/storage.c

275

if (size + 1 > limit - pos)

fs/smb/server/vfs_cache.c

134

void ksmbd_set_fd_limit(unsigned long limit)

fs/smb/server/vfs_cache.c

136

limit = min(limit, get_max_files());

fs/smb/server/vfs_cache.c

137

atomic_long_set(&fd_limit, limit);

fs/smb/server/vfs_cache.h

166

void ksmbd_set_fd_limit(unsigned long limit);

fs/ufs/dir.c

115

unsigned limit = folio_size(folio);

fs/ufs/dir.c

120

if (dir->i_size < folio_pos(folio) + limit) {

fs/ufs/dir.c

121

limit = offset_in_folio(folio, dir->i_size);

fs/ufs/dir.c

122

if (limit & chunk_mask)

fs/ufs/dir.c

124

if (!limit)

fs/ufs/dir.c

127

for (offs = 0; offs <= limit - UFS_DIR_REC_LEN(1); offs += rec_len) {

fs/ufs/dir.c

143

if (offs != limit)

fs/ufs/dir.c

433

char *limit;

fs/ufs/dir.c

451

limit = kaddr + ufs_last_byte(inode, n) - UFS_DIR_REC_LEN(1);

fs/ufs/dir.c

452

for ( ;(char*)de <= limit; de = ufs_next_entry(sb, de)) {

fs/xfs/libxfs/xfs_rtbitmap.c

421

xfs_rtxnum_t limit, /* last rtext to look at */

fs/xfs/libxfs/xfs_rtbitmap.c

437

ASSERT(start <= limit);

fs/xfs/libxfs/xfs_rtbitmap.c

452

len = limit - start + 1;

fs/xfs/libxfs/xfs_rtbitmap.h

393

xfs_rtxnum_t limit, xfs_rtxnum_t *rtblock);

fs/xfs/xfs_pnfs.c

120

loff_t limit;

fs/xfs/xfs_pnfs.c

155

limit = mp->m_super->s_maxbytes;

fs/xfs/xfs_pnfs.c

157

limit = max(limit, round_up(i_size_read(inode),

fs/xfs/xfs_pnfs.c

159

if (offset > limit)

fs/xfs/xfs_pnfs.c

161

if (offset > limit - length)

fs/xfs/xfs_pnfs.c

162

length = limit - offset;

fs/xfs/xfs_qm_bhv.c

26

uint64_t limit;

fs/xfs/xfs_qm_bhv.c

32

limit = blkres->softlimit ?

fs/xfs/xfs_qm_bhv.c

35

if (limit) {

fs/xfs/xfs_qm_bhv.c

38

if (limit > blkres->reserved)

fs/xfs/xfs_qm_bhv.c

39

remaining = limit - blkres->reserved;

fs/xfs/xfs_qm_bhv.c

41

statp->f_blocks = min(statp->f_blocks, limit);

fs/xfs/xfs_qm_bhv.c

45

limit = dqp->q_ino.softlimit ?

fs/xfs/xfs_qm_bhv.c

48

if (limit) {

fs/xfs/xfs_qm_bhv.c

51

if (limit > dqp->q_ino.reserved)

fs/xfs/xfs_qm_bhv.c

52

remaining = limit - dqp->q_ino.reserved;

fs/xfs/xfs_qm_bhv.c

54

statp->f_files = min(statp->f_files, limit);

fs/zonefs/file.c

406

loff_t limit = rlimit(RLIMIT_FSIZE);

fs/zonefs/file.c

409

if (limit != RLIM_INFINITY) {

fs/zonefs/file.c

410

if (pos >= limit) {

fs/zonefs/file.c

414

count = min(count, limit - pos);

include/acpi/processor.h

213

u8 limit:1;

include/acpi/processor.h

237

struct acpi_processor_limit limit;

include/acpi/processor.h

326

extern int acpi_processor_get_bios_limit(int cpu, unsigned int *limit);

include/acpi/processor.h

352

static inline int acpi_processor_get_bios_limit(int cpu, unsigned int *limit)

include/asm-generic/access_ok.h

33

unsigned long limit = TASK_SIZE_MAX;

include/asm-generic/access_ok.h

40

return (size <= limit) && (addr <= (limit - size));

include/crypto/scatterwalk.h

56

unsigned int limit;

include/crypto/scatterwalk.h

76

limit = PAGE_SIZE - offset_in_page(walk->offset);

include/crypto/scatterwalk.h

78

limit = PAGE_SIZE;

include/crypto/scatterwalk.h

80

return min3(nbytes, len_this_sg, limit);

include/hyperv/hvgdk_mini.h

821

u32 limit;

include/hyperv/hvgdk_mini.h

841

u16 limit;

include/linux/acpi_iort.h

45

int iort_dma_get_ranges(struct device *dev, u64 *limit);

include/linux/acpi_iort.h

67

static inline int iort_dma_get_ranges(struct device *dev, u64 *limit)

include/linux/cma.h

31

phys_addr_t size, phys_addr_t limit,

include/linux/cma.h

36

phys_addr_t size, phys_addr_t limit,

include/linux/cma.h

40

return cma_declare_contiguous_nid(base, size, limit, alignment,

include/linux/coredump.h

22

unsigned long limit;

include/linux/cpufreq.h

407

int (*bios_limit)(int cpu, unsigned int *limit);

include/linux/dma-map-ops.h

105

phys_addr_t limit, struct cma **res_cma, bool fixed);

include/linux/dma-map-ops.h

120

static inline void dma_contiguous_reserve(phys_addr_t limit)

include/linux/dma-map-ops.h

124

phys_addr_t base, phys_addr_t limit, struct cma **res_cma,

include/linux/dynamic_queue_limits.h

62

unsigned int limit ____cacheline_aligned_in_smp; /* Current limit */

include/linux/hid.h

1101

unsigned int limit = 0;

include/linux/hid.h

1106

limit = ABS_MAX;

include/linux/hid.h

1110

limit = REL_MAX;

include/linux/hid.h

1114

limit = KEY_MAX;

include/linux/hid.h

1118

limit = LED_MAX;

include/linux/hid.h

1122

limit = MSC_MAX;

include/linux/hid.h

1126

if (unlikely(c > limit || !bmap)) {

include/linux/hid.h

1135

*max = limit;

include/linux/memblock.h

487

phys_addr_t memblock_reserved_kern_size(phys_addr_t limit, int nid);

include/linux/memblock.h

493

void memblock_mem_limit_remove_map(phys_addr_t limit);

include/linux/memblock.h

508

void memblock_set_current_limit(phys_addr_t limit);

include/linux/mlx5/driver.h

723

int limit;

include/linux/netdevice.h

3797

prefetchw(&dev_queue->dql.limit);

include/linux/netfilter/nf_conntrack_sip.h

69

const char *dptr, const char *limit,

include/linux/of_fdt.h

41

extern void of_fdt_limit_memory(int limit);

include/linux/percpu_counter.h

198

percpu_counter_limited_add(struct percpu_counter *fbc, s64 limit, s64 amount)

include/linux/percpu_counter.h

209

if ((amount > 0 && count <= limit) ||

include/linux/percpu_counter.h

210

(amount < 0 && count >= limit)) {

include/linux/percpu_counter.h

60

bool __percpu_counter_limited_add(struct percpu_counter *fbc, s64 limit,

include/linux/percpu_counter.h

75

percpu_counter_limited_add(struct percpu_counter *fbc, s64 limit, s64 amount)

include/linux/percpu_counter.h

77

return __percpu_counter_limited_add(fbc, limit, amount,

include/linux/pipe_fs_i.h

197

unsigned int limit)

include/linux/pipe_fs_i.h

199

return pipe_occupancy(head, tail) >= limit;

include/linux/platform_data/cros_ec_commands.h

4294

uint32_t limit; /* in mA */

include/linux/refcount.h

217

int limit)

include/linux/refcount.h

225

if (i > limit - old) {

include/linux/refcount.h

242

__refcount_inc_not_zero_limited_acquire(refcount_t *r, int *oldp, int limit)

include/linux/refcount.h

244

return __refcount_add_not_zero_limited_acquire(1, r, oldp, limit);

include/linux/sched/signal.h

759

unsigned int limit)

include/linux/sched/signal.h

761

return READ_ONCE(task->signal->rlim[limit].rlim_cur);

include/linux/sched/signal.h

765

unsigned int limit)

include/linux/sched/signal.h

767

return READ_ONCE(task->signal->rlim[limit].rlim_max);

include/linux/sched/signal.h

770

static inline unsigned long rlimit(unsigned int limit)

include/linux/sched/signal.h

772

return task_rlimit(current, limit);

include/linux/sched/signal.h

775

static inline unsigned long rlimit_max(unsigned int limit)

include/linux/sched/signal.h

777

return task_rlimit_max(current, limit);

include/linux/spi/corgi_lcd.h

18

void corgi_lcd_limit_intensity(int limit);

include/linux/tty_flip.h

10

int tty_buffer_set_limit(struct tty_port *port, int limit);

include/linux/vhost_iotlb.h

28

unsigned int limit;

include/linux/vhost_iotlb.h

39

void vhost_iotlb_init(struct vhost_iotlb *iotlb, unsigned int limit,

include/linux/vhost_iotlb.h

41

struct vhost_iotlb *vhost_iotlb_alloc(unsigned int limit, unsigned int flags);

include/linux/writeback.h

320

unsigned long limit; /* hard dirty limit */

include/linux/xarray.h

1016

struct xa_limit limit, u32 *next, gfp_t gfp)

include/linux/xarray.h

1022

err = __xa_alloc_cyclic(xa, id, entry, limit, next, gfp);

include/linux/xarray.h

1055

struct xa_limit limit, u32 *next, gfp_t gfp)

include/linux/xarray.h

1061

err = __xa_alloc_cyclic(xa, id, entry, limit, next, gfp);

include/linux/xarray.h

872

void *entry, struct xa_limit limit, gfp_t gfp)

include/linux/xarray.h

878

err = __xa_alloc(xa, id, entry, limit, gfp);

include/linux/xarray.h

905

void *entry, struct xa_limit limit, gfp_t gfp)

include/linux/xarray.h

911

err = __xa_alloc(xa, id, entry, limit, gfp);

include/linux/xarray.h

938

void *entry, struct xa_limit limit, gfp_t gfp)

include/linux/xarray.h

944

err = __xa_alloc(xa, id, entry, limit, gfp);

include/linux/xarray.h

977

struct xa_limit limit, u32 *next, gfp_t gfp)

include/linux/xarray.h

983

err = __xa_alloc_cyclic(xa, id, entry, limit, next, gfp);

include/media/tuner-types.h

48

unsigned short limit;

include/net/devlink.h

1370

enum devlink_reload_limit limit,

include/net/devlink.h

1373

enum devlink_reload_limit limit, u32 *actions_performed,

include/net/devlink.h

2029

enum devlink_reload_limit limit,

include/net/fq.h

75

u32 limit;

include/net/fq_impl.h

235

while (fq->backlog > fq->limit || oom) {

include/net/fq_impl.h

358

fq->limit = 8192;

include/net/ip_vs.h

1622

unsigned int limit = IPVS_EST_CPU_KTHREADS *

include/net/ip_vs.h

1625

return max(1U, limit);

include/net/pie.h

31

u32 limit;

include/net/pie.h

93

params->limit = 1000;

include/net/pkt_cls.h

899

u32 limit;

include/net/pkt_cls.h

926

u32 limit;

include/net/pkt_sched.h

90

int fifo_set_limit(struct Qdisc *q, unsigned int limit);

include/net/pkt_sched.h

92

unsigned int limit,

include/net/sch_generic.h

93

u32 limit;

include/net/sock.h

1148

static inline bool sk_rcvqueues_full(const struct sock *sk, unsigned int limit)

include/net/sock.h

1152

return qsize > limit;

include/net/sock.h

1157

unsigned int limit)

include/net/sock.h

1159

if (sk_rcvqueues_full(sk, limit))

include/net/tc_act/tc_police.h

41

u32 limit;

include/rdma/rdmavt_qp.h

457

u32 limit;

include/rdma/rdmavt_qp.h

490

u16 limit;

include/trace/events/writeback.h

671

__field(unsigned long, limit)

include/trace/events/writeback.h

690

__entry->limit = dtc->limit;

include/trace/events/writeback.h

691

__entry->setpoint = (dtc->limit + freerun) / 2;

include/trace/events/writeback.h

716

__entry->limit,

include/uapi/linux/acrn.h

251

__le16 limit;

include/uapi/linux/btrfs.h

386

__u64 limit; /* limit number of processed chunks */

include/uapi/linux/btrfs_tree.h

1039

__le64 limit;

include/uapi/linux/netfilter/xt_connlimit.h

25

unsigned int limit;

include/uapi/linux/openvswitch.h

1130

__u32 limit;

include/uapi/linux/pkt_cls.h

157

__u32 limit;

include/uapi/linux/pkt_sched.h

125

__u32 limit; /* Queue length: bytes for bfifo, packets for pfifo */

include/uapi/linux/pkt_sched.h

140

__u32 limit; /* Queue length in packets. */

include/uapi/linux/pkt_sched.h

178

__u32 limit;

include/uapi/linux/pkt_sched.h

186

__u32 limit;

include/uapi/linux/pkt_sched.h

216

__u32 limit; /* Maximal packets in queue */

include/uapi/linux/pkt_sched.h

235

__u32 limit; /* HARD maximal flow queue length (bytes) */

include/uapi/linux/pkt_sched.h

268

__u32 limit; /* HARD maximal queue length (bytes) */

include/uapi/linux/pkt_sched.h

347

__u32 limit; /* HARD maximal queue length (bytes) */

include/uapi/linux/pkt_sched.h

387

__u32 limit; /* Hard queue length (packets) */

include/uapi/linux/pkt_sched.h

505

__u32 limit; /* fifo limit (packets) */

include/uapi/linux/pkt_sched.h

674

__u32 limit; /* max SFB queue length */

ipc/util.c

278

int ipc_addid(struct ipc_ids *ids, struct kern_ipc_perm *new, int limit)

ipc/util.c

287

if (limit > ipc_mni)

ipc/util.c

288

limit = ipc_mni;

ipc/util.c

290

if (ids->in_use >= limit)

ipc/util.c

467

static int ipc_search_maxidx(struct ipc_ids *ids, int limit)

ipc/util.c

473

i = ilog2(limit+1);

kernel/audit.c

469

static int audit_set_rate_limit(u32 limit)

kernel/audit.c

471

return audit_do_config_change("audit_rate_limit", &audit_rate_limit, limit);

kernel/audit.c

474

static int audit_set_backlog_limit(u32 limit)

kernel/audit.c

476

return audit_do_config_change("audit_backlog_limit", &audit_backlog_limit, limit);

kernel/bpf/lpm_trie.c

172

u32 limit = min(node->prefixlen, key->prefixlen);

kernel/bpf/lpm_trie.c

188

if (prefixlen >= limit)

kernel/bpf/lpm_trie.c

189

return limit;

kernel/bpf/lpm_trie.c

201

if (prefixlen >= limit)

kernel/bpf/lpm_trie.c

202

return limit;

kernel/bpf/lpm_trie.c

213

if (prefixlen >= limit)

kernel/bpf/lpm_trie.c

214

return limit;

kernel/bpf/lpm_trie.c

223

if (prefixlen >= limit)

kernel/bpf/lpm_trie.c

224

return limit;

kernel/cgroup/pids.c

172

int64_t limit = atomic64_read(&p->limit);

kernel/cgroup/pids.c

179

if (new > limit) {

kernel/cgroup/pids.c

306

int64_t limit;

kernel/cgroup/pids.c

311

limit = PIDS_MAX;

kernel/cgroup/pids.c

315

err = kstrtoll(buf, 0, &limit);

kernel/cgroup/pids.c

319

if (limit < 0 || limit >= PIDS_MAX)

kernel/cgroup/pids.c

327

atomic64_set(&pids->limit, limit);

kernel/cgroup/pids.c

335

int64_t limit = atomic64_read(&pids->limit);

kernel/cgroup/pids.c

337

if (limit >= PIDS_MAX)

kernel/cgroup/pids.c

340

seq_printf(sf, "%lld\n", limit);

kernel/cgroup/pids.c

57

atomic64_t limit;

kernel/cgroup/pids.c

87

atomic64_set(&pids->limit, PIDS_MAX);

kernel/debug/gdbstub.c

409

unsigned char *limit;

kernel/debug/gdbstub.c

412

limit = id + (BUF_THREAD_ID_SIZE / 2);

kernel/debug/gdbstub.c

413

while (id < limit) {

kernel/dma/contiguous.c

222

void __init dma_contiguous_reserve(phys_addr_t limit)

kernel/dma/contiguous.c

226

phys_addr_t selected_limit = limit;

kernel/dma/contiguous.c

231

pr_debug("%s(limit %08lx)\n", __func__, (unsigned long)limit);

kernel/dma/contiguous.c

238

selected_limit = limit_cmdline ?: limit;

kernel/dma/contiguous.c

296

phys_addr_t limit, struct cma **res_cma,

kernel/dma/contiguous.c

301

ret = cma_declare_contiguous(base, size, limit, 0, 0, fixed,

kernel/dma/debug.c

359

int limit = min(HASH_SIZE, (index.dev_addr >> HASH_FN_SHIFT) + 1);

kernel/dma/debug.c

361

for (int i = 0; i < limit; i++) {

kernel/exit.c

1035

unsigned int limit;

kernel/exit.c

1064

limit = READ_ONCE(oops_limit);

kernel/exit.c

1065

if (atomic_inc_return(&oops_count) >= limit && limit)

kernel/exit.c

1066

panic("Oopsed too often (kernel.oops_limit is %d)", limit);

kernel/futex/core.c

1158

unsigned int limit = ROBUST_LIST_LIMIT, pi, pip;

kernel/futex/core.c

1204

if (!--limit)

kernel/futex/core.c

1252

unsigned int limit = ROBUST_LIST_LIMIT, pi, pip;

kernel/futex/core.c

1304

if (!--limit)

kernel/irq/msi.c

113

struct xa_limit limit = { .min = 0, .max = hwsize - 1 };

kernel/irq/msi.c

117

ret = xa_alloc(xa, &index, desc, limit, GFP_KERNEL);

kernel/kexec_core.c

1021

int limit;

kernel/kexec_core.c

1026

.limit = -1,

kernel/kexec_core.c

1031

.limit = -1,

kernel/kexec_core.c

1042

struct kexec_load_limit *limit = table->data;

kernel/kexec_core.c

1059

mutex_lock(&limit->mutex);

kernel/kexec_core.c

1060

if (limit->limit != -1 && val >= limit->limit)

kernel/kexec_core.c

1063

limit->limit = val;

kernel/kexec_core.c

1064

mutex_unlock(&limit->mutex);

kernel/kexec_core.c

1069

mutex_lock(&limit->mutex);

kernel/kexec_core.c

1070

val = limit->limit;

kernel/kexec_core.c

1071

mutex_unlock(&limit->mutex);

kernel/kexec_core.c

1111

struct kexec_load_limit *limit;

kernel/kexec_core.c

1121

limit = (kexec_image_type == KEXEC_TYPE_CRASH) ?

kernel/kexec_core.c

1123

mutex_lock(&limit->mutex);

kernel/kexec_core.c

1124

if (!limit->limit) {

kernel/kexec_core.c

1125

mutex_unlock(&limit->mutex);

kernel/kexec_core.c

1128

if (limit->limit != -1)

kernel/kexec_core.c

1129

limit->limit--;

kernel/kexec_core.c

1130

mutex_unlock(&limit->mutex);

kernel/livepatch/core.c

1231

struct klp_patch *limit)

kernel/livepatch/core.c

1237

if (patch == limit)

kernel/panic.c

521

unsigned int limit;

kernel/panic.c

526

limit = READ_ONCE(warn_limit);

kernel/panic.c

527

if (atomic_inc_return(&warn_count) >= limit && limit)

kernel/panic.c

529

origin, limit);

kernel/sched/fair.c

770

s64 vlag, limit;

kernel/sched/fair.c

775

limit = calc_delta_fair(max_slice, se);

kernel/sched/fair.c

777

se->vlag = clamp(vlag, -limit, limit);

kernel/signal.c

3423

unsigned char limit, layout;

kernel/signal.c

3444

if (si_code <= sig_sicodes[sig].limit)

kernel/signal.c

3462

(si_code <= sig_sicodes[sig].limit)) {

kernel/time/posix-cpu-timers.c

846

static bool check_rlimit(u64 time, u64 limit, int signo, bool rt, bool hard)

kernel/time/posix-cpu-timers.c

848

if (time < limit)

kernel/user_namespace.c

65

unsigned long limit = RLIM_INFINITY;

kernel/user_namespace.c

70

limit = rlimit(RLIMIT_NPROC);

kernel/user_namespace.c

72

return limit;

lib/debugobjects.c

614

static int limit;

lib/debugobjects.c

625

if (limit < 5 && descr != descr_test) {

lib/debugobjects.c

628

limit++;

lib/debugobjects.c

655

static int limit;

lib/debugobjects.c

657

if (limit > 4)

lib/debugobjects.c

664

limit++;

lib/decompress_bunzip2.c

160

int *limit = NULL;

lib/decompress_bunzip2.c

305

limit = hufGroup->limit-1;

lib/decompress_bunzip2.c

310

temp[i] = limit[i] = 0;

lib/decompress_bunzip2.c

337

limit[i] = (pp << (maxLen - i)) - 1;

lib/decompress_bunzip2.c

341

limit[maxLen+1] = INT_MAX; /* Sentinel value for

lib/decompress_bunzip2.c

343

limit[maxLen] = pp+temp[maxLen]-1;

lib/decompress_bunzip2.c

367

limit = hufGroup->limit-1;

lib/decompress_bunzip2.c

397

while (j > limit[i])

lib/decompress_bunzip2.c

84

int limit[MAX_HUFCODE_BITS+1];

lib/dynamic_queue_limits.c

102

limit = dql->limit;

lib/dynamic_queue_limits.c

103

ovlimit = POSDIFF(num_queued - dql->num_completed, limit);

lib/dynamic_queue_limits.c

125

limit += POSDIFF(completed, dql->prev_num_queued) +

lib/dynamic_queue_limits.c

154

slack = POSDIFF(limit + dql->prev_ovlimit,

lib/dynamic_queue_limits.c

166

limit = POSDIFF(limit, dql->lowest_slack);

lib/dynamic_queue_limits.c

173

limit = clamp(limit, dql->min_limit, dql->max_limit);

lib/dynamic_queue_limits.c

175

if (limit != dql->limit) {

lib/dynamic_queue_limits.c

176

dql->limit = limit;

lib/dynamic_queue_limits.c

180

dql->adj_limit = limit + completed;

lib/dynamic_queue_limits.c

193

dql->limit = dql->min_limit;

lib/dynamic_queue_limits.c

85

unsigned int inprogress, prev_inprogress, limit;

lib/lz4/lz4_compress.c

339

const BYTE *limit;

lib/lz4/lz4_compress.c

342

limit = ip + (dictEnd - match);

lib/lz4/lz4_compress.c

344

if (limit > matchlimit)

lib/lz4/lz4_compress.c

345

limit = matchlimit;

lib/lz4/lz4_compress.c

348

match + MINMATCH, limit);

lib/lz4/lz4_compress.c

352

if (ip == limit) {

lib/lz4/lz4hc_compress.c

344

limitedOutput_directive limit

lib/lz4/lz4hc_compress.c

402

&anchor, ml, ref, limit, oend))

lib/lz4/lz4hc_compress.c

468

ml, ref, limit, oend))

lib/lz4/lz4hc_compress.c

472

ml2, ref2, limit, oend))

lib/lz4/lz4hc_compress.c

498

ml, ref, limit, oend))

lib/lz4/lz4hc_compress.c

539

ref, limit, oend))

lib/lz4/lz4hc_compress.c

557

if ((limit)

lib/lz4/lz4hc_compress.c

673

limitedOutput_directive limit)

lib/lz4/lz4hc_compress.c

713

inputSize, maxOutputSize, ctxPtr->compressionLevel, limit);

lib/lzo/lzo1x_compress.c

112

while (likely(ir < limit) && unlikely(*ir == 0))

lib/lzo/lzo1x_compress.c

65

const unsigned char *limit = min(ip_end, ip + MAX_ZERO_RUN_LENGTH + 1);

lib/lzo/lzo1x_compress.c

70

for (; (ir + 32) <= limit; ir += 32) {

lib/lzo/lzo1x_compress.c

78

for (; (ir + 8) <= limit; ir += 8) {

lib/lzo/lzo1x_compress.c

94

(ir < limit) && (*ir == 0))

lib/lzo/lzo1x_compress.c

97

for (; (ir + 4) <= limit; ir += 4) {

lib/percpu_counter.c

328

s64 limit, s64 amount, s32 batch)

lib/percpu_counter.c

344

((amount > 0 && fbc->count + unknown <= limit) ||

lib/percpu_counter.c

345

(amount < 0 && fbc->count - unknown >= limit))) {

lib/percpu_counter.c

356

if (count - unknown > limit)

lib/percpu_counter.c

358

if (count + unknown <= limit)

lib/percpu_counter.c

361

if (count + unknown < limit)

lib/percpu_counter.c

363

if (count - unknown >= limit)

lib/percpu_counter.c

376

if (count > limit)

lib/percpu_counter.c

379

if (count < limit)

lib/ref_tracker.c

72

ref_tracker_get_stats(struct ref_tracker_dir *dir, unsigned int limit)

lib/ref_tracker.c

77

stats = kmalloc_flex(*stats, stacks, limit, GFP_NOWAIT);

lib/ref_tracker.c

91

if (i >= limit)

lib/stackdepot.c

106

const long long limit = (1LL << (DEPOT_POOL_INDEX_BITS)) - 1;

lib/stackdepot.c

120

if (max_pools > limit) {

lib/stackdepot.c

122

limit, stack_max_pools);

lib/string.c

129

size_t limit = PAGE_SIZE - ((long)src & (PAGE_SIZE - 1));

lib/string.c

130

if (limit < max)

lib/string.c

131

max = limit;

lib/test_maple_tree.c

1325

unsigned long limit = 30, i = 0;

lib/test_maple_tree.c

1330

check_seq(mt, limit, false);

lib/test_maple_tree.c

1335

for ( ; i <= limit + 1; i++) {

lib/test_maple_tree.c

1336

entry = mas_next(&mas, limit);

lib/test_maple_tree.c

1337

if (i > limit)

lib/test_xarray.c

1038

struct xa_limit limit = XA_LIMIT(1, 0x3fff);

lib/test_xarray.c

1045

XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, xa_mk_index(1), limit,

lib/test_xarray.c

1050

XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, xa_mk_index(0x3ffd), limit,

lib/test_xarray.c

1062

XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, entry, limit,

lib/ucs2_string.c

139

unsigned long limit = ucs2_strnlen(src, maxlength);

lib/ucs2_string.c

141

for (i = 0; maxlength && i < limit; i++) {

lib/xarray.c

129

unsigned int limit = xas->xa_offset + xas->xa_sibs + 1;

lib/xarray.c

134

if (find_next_bit(marks, limit, xas->xa_offset + 1) != limit) {

lib/xarray.c

1986

struct xa_limit limit, gfp_t gfp)

lib/xarray.c

1999

xas.xa_index = limit.min;

lib/xarray.c

2000

xas_find_marked(&xas, limit.max, XA_FREE_MARK);

lib/xarray.c

2038

struct xa_limit limit, u32 *next, gfp_t gfp)

lib/xarray.c

2040

u32 min = limit.min;

lib/xarray.c

2043

limit.min = max(min, *next);

lib/xarray.c

2044

ret = __xa_alloc(xa, id, entry, limit, gfp);

lib/xarray.c

2050

if (ret < 0 && limit.min > min) {

lib/xarray.c

2051

limit.min = min;

lib/xarray.c

2052

ret = __xa_alloc(xa, id, entry, limit, gfp);

lib/xxhash.c

109

} while (p <= limit);

lib/xxhash.c

164

const uint8_t *const limit = b_end - 32;

lib/xxhash.c

179

} while (p <= limit);

lib/xxhash.c

276

const uint8_t *const limit = b_end - 32;

lib/xxhash.c

291

} while (p <= limit);

lib/xxhash.c

94

const uint8_t *const limit = b_end - 16;

lib/xz/xz_dec_lzma2.c

298

dict->limit = 0;

lib/xz/xz_dec_lzma2.c

306

dict->limit = dict->end;

lib/xz/xz_dec_lzma2.c

308

dict->limit = dict->pos + out_max;

lib/xz/xz_dec_lzma2.c

314

return dict->pos < dict->limit;

lib/xz/xz_dec_lzma2.c

357

left = min_t(size_t, dict->limit - dict->pos, *len);

lib/xz/xz_dec_lzma2.c

551

uint16_t *probs, uint32_t limit)

lib/xz/xz_dec_lzma2.c

560

} while (symbol < limit);

lib/xz/xz_dec_lzma2.c

568

uint32_t *dest, uint32_t limit)

lib/xz/xz_dec_lzma2.c

580

} while (++i < limit);

lib/xz/xz_dec_lzma2.c

584

static inline void rc_direct(struct rc_dec *rc, uint32_t *dest, uint32_t limit)

lib/xz/xz_dec_lzma2.c

595

} while (--limit > 0);

lib/xz/xz_dec_lzma2.c

60

size_t limit;

lib/xz/xz_dec_lzma2.c

654

uint32_t limit;

lib/xz/xz_dec_lzma2.c

658

limit = LEN_LOW_SYMBOLS;

lib/xz/xz_dec_lzma2.c

663

limit = LEN_MID_SYMBOLS;

lib/xz/xz_dec_lzma2.c

667

limit = LEN_HIGH_SYMBOLS;

lib/xz/xz_dec_lzma2.c

673

s->lzma.len += rc_bittree(&s->rc, probs, limit) - limit;

lib/xz/xz_dec_lzma2.c

681

uint32_t limit;

lib/xz/xz_dec_lzma2.c

697

limit = (dist_slot >> 1) - 1;

lib/xz/xz_dec_lzma2.c

701

s->lzma.rep0 <<= limit;

lib/xz/xz_dec_lzma2.c

705

&s->lzma.rep0, limit);

lib/xz/xz_dec_lzma2.c

707

rc_direct(&s->rc, &s->lzma.rep0, limit - ALIGN_BITS);

lib/zlib_deflate/deflate.c

573

IPos limit = s->strstart > (IPos)MAX_DIST(s) ?

lib/zlib_deflate/deflate.c

694

} while ((cur_match = prev[cur_match & wmask]) > limit

lib/zstd/compress/zstd_compress.c

6939

const __m256i limit = _mm256_set1_epi32(65535);

lib/zstd/compress/zstd_compress.c

6996

__m256i ll_cmp = _mm256_cmpgt_epi32(vadd, limit); /* 0xFFFFFFFF for element > 65535 */

lib/zstd/compress/zstd_preSplit.c

61

size_t limit = srcSize - HASHLENGTH + 1;

lib/zstd/compress/zstd_preSplit.c

64

for (n = 0; n < limit; n+=samplingRate) {

lib/zstd/compress/zstd_preSplit.c

67

fp->nbEvents += limit/samplingRate;

mm/cma.c

382

phys_addr_t align, phys_addr_t limit, int nid)

mm/cma.c

395

if (!memblock_bottom_up() && limit >= SZ_4G + size) {

mm/cma.c

397

addr = memblock_alloc_range_nid(size, align, SZ_4G, limit,

mm/cma.c

416

if (base < highmem && limit > highmem) {

mm/cma.c

418

limit, nid, true);

mm/cma.c

419

limit = highmem;

mm/cma.c

424

addr = memblock_alloc_range_nid(size, align, base, limit, nid,

mm/cma.c

431

phys_addr_t size, phys_addr_t limit,

mm/cma.c

441

__func__, &size, &base, &limit, &alignment);

mm/cma.c

466

limit &= ~(alignment - 1);

mm/cma.c

481

if (limit == 0 || limit > memblock_end)

mm/cma.c

482

limit = memblock_end;

mm/cma.c

484

if (base + size > limit) {

mm/cma.c

486

&size, &base, &limit);

mm/cma.c

496

base = cma_alloc_mem(base, size, alignment, limit, nid);

mm/cma.c

734

phys_addr_t size, phys_addr_t limit,

mm/cma.c

741

ret = __cma_declare_contiguous_nid(&base, size, limit, alignment,

mm/compaction.c

1506

unsigned int limit = max(1U, freelist_scan_limit(cc) >> 1);

mm/compaction.c

1524

limit = pageblock_nr_pages >> 1;

mm/compaction.c

1582

limit >>= 1;

mm/compaction.c

1585

if (order_scanned >= limit)

mm/compaction.c

1627

if (order_scanned >= limit)

mm/compaction.c

1628

limit = max(1U, limit >> 1);

mm/compaction.c

1925

unsigned int limit = freelist_scan_limit(cc);

mm/compaction.c

1981

order >= PAGE_ALLOC_COSTLY_ORDER && !found_block && nr_scanned < limit;

mm/compaction.c

1996

if (nr_scanned++ >= limit) {

mm/hugetlb_cgroup.c

118

limit = round_down(PAGE_COUNTER_MAX,

mm/hugetlb_cgroup.c

121

VM_BUG_ON(page_counter_set_max(fault, limit));

mm/hugetlb_cgroup.c

122

VM_BUG_ON(page_counter_set_max(rsvd, limit));

mm/hugetlb_cgroup.c

546

unsigned long limit;

mm/hugetlb_cgroup.c

553

limit = round_down(PAGE_COUNTER_MAX,

mm/hugetlb_cgroup.c

569

if (val == limit)

mm/hugetlb_cgroup.c

99

unsigned long limit;

mm/memblock.c

1794

phys_addr_t __init_memblock memblock_reserved_kern_size(phys_addr_t limit, int nid)

mm/memblock.c

1802

if (r->base > limit)

mm/memblock.c

1805

if (r->base + r->size > limit)

mm/memblock.c

1806

size = limit - r->base;

mm/memblock.c

1847

static phys_addr_t __init_memblock __find_max_addr(phys_addr_t limit)

mm/memblock.c

1858

if (limit <= r->size) {

mm/memblock.c

1859

max_addr = r->base + limit;

mm/memblock.c

1862

limit -= r->size;

mm/memblock.c

1868

void __init memblock_enforce_memory_limit(phys_addr_t limit)

mm/memblock.c

1872

if (!limit)

mm/memblock.c

1875

max_addr = __find_max_addr(limit);

mm/memblock.c

1921

void __init memblock_mem_limit_remove_map(phys_addr_t limit)

mm/memblock.c

1925

if (!limit)

mm/memblock.c

1928

max_addr = __find_max_addr(limit);

mm/memblock.c

2051

void __init_memblock memblock_set_current_limit(phys_addr_t limit)

mm/memblock.c

2053

memblock.current_limit = limit;

mm/memcontrol.c

1329

unsigned long limit;

mm/memcontrol.c

1332

limit = READ_ONCE(memcg->memory.max);

mm/memcontrol.c

1333

if (count < limit)

mm/memcontrol.c

1334

margin = limit - count;

mm/memcontrol.c

1338

limit = READ_ONCE(memcg->memsw.max);

mm/memcontrol.c

1339

if (count < limit)

mm/memcontrol.c

1340

margin = min(margin, limit - count);

mm/nommu.c

1442

static int limit;

mm/nommu.c

1443

if (limit < 5) {

mm/nommu.c

1447

limit++;

mm/numa_emulation.c

132

u64 start, limit, end;

mm/numa_emulation.c

141

limit = pi->blk[phys_blk].end;

mm/numa_emulation.c

153

if (end > limit) {

mm/numa_emulation.c

154

end = limit;

mm/numa_emulation.c

173

if (limit - end - mem_hole_size(end, limit) < size)

mm/numa_emulation.c

174

end = limit;

mm/numa_emulation.c

178

min(end, limit) - start);

mm/numa_emulation.c

279

u64 start, limit, end;

mm/numa_emulation.c

289

limit = pi->blk[phys_blk].end;

mm/numa_emulation.c

294

end = find_end_of_node(start, limit, size);

mm/numa_emulation.c

309

if ((limit - end - mem_hole_size(end, limit) < size)

mm/numa_emulation.c

311

end = limit;

mm/numa_emulation.c

315

min(end, limit) - start);

mm/page-writeback.c

1068

unsigned long limit = dtc->limit = hard_dirty_limit(dtc_dom(dtc), dtc->thresh);

mm/page-writeback.c

1079

if (unlikely(dtc->dirty >= limit))

mm/page-writeback.c

1087

setpoint = (freerun + limit) / 2;

mm/page-writeback.c

1088

pos_ratio = pos_ratio_polynom(setpoint, dtc->dirty, limit);

mm/page-writeback.c

1280

unsigned long limit = dom->dirty_limit;

mm/page-writeback.c

1285

if (limit < thresh) {

mm/page-writeback.c

1286

limit = thresh;

mm/page-writeback.c

1296

if (limit > thresh) {

mm/page-writeback.c

1297

limit -= (limit - thresh) >> 5;

mm/page-writeback.c

1302

dom->dirty_limit = limit;

mm/page-writeback.c

1337

unsigned long limit = hard_dirty_limit(dtc_dom(dtc), dtc->thresh);

mm/page-writeback.c

1338

unsigned long setpoint = (freerun + limit) / 2;

mm/page-writeback.c

469

unsigned long limit = node_dirty_limit(pgdat);

mm/page-writeback.c

475

return nr_pages <= limit;

mm/page-writeback.c

973

unsigned long limit)

mm/page-writeback.c

979

(limit - setpoint) | 1);

mm/readahead.c

474

pgoff_t limit = (i_size_read(mapping->host) - 1) >> PAGE_SHIFT;

mm/readahead.c

487

limit = min(limit, index + ra->size - 1);

mm/readahead.c

506

while (index <= limit) {

mm/readahead.c

513

while (order > min_order && index + (1UL << order) - 1 > limit)

mm/slab.h

438

unsigned int limit;

mm/slab_common.c

1124

sinfo.limit, sinfo.batchcount, sinfo.shared);

mm/sparse.c

325

unsigned long goal, limit;

mm/sparse.c

338

limit = goal + (1UL << PA_SECTION_SHIFT);

mm/sparse.c

341

usage = memblock_alloc_try_nid(size, SMP_CACHE_BYTES, goal, limit, nid);

mm/sparse.c

342

if (!usage && limit) {

mm/sparse.c

343

limit = MEMBLOCK_ALLOC_ACCESSIBLE;

mm/util.c

509

unsigned long locked_vm, limit;

mm/util.c

517

limit = task_rlimit(task, RLIMIT_MEMLOCK) >> PAGE_SHIFT;

mm/util.c

518

if (locked_vm + pages > limit)

net/9p/trans_virtio.c

171

int limit, char *data, int count)

net/9p/trans_virtio.c

180

BUG_ON(index >= limit);

net/9p/trans_virtio.c

217

pack_sg_list_p(struct scatterlist *sg, int start, int limit,

net/9p/trans_virtio.c

224

BUG_ON(nr_pages > (limit - start));

net/9p/trans_virtio.c

233

BUG_ON(index >= limit);

net/appletalk/ddp.c

679

int limit;

net/appletalk/ddp.c

778

limit = ntohs(nr->nr_lastnet);

net/appletalk/ddp.c

779

if (limit - ntohs(nr->nr_firstnet) > 4096) {

net/appletalk/ddp.c

786

ct <= limit; ct++) {

net/batman-adv/fragmentation.c

85

int limit = BATADV_FRAG_MAX_FRAG_SIZE;

net/batman-adv/fragmentation.c

87

limit -= sizeof(struct batadv_frag_packet);

net/batman-adv/fragmentation.c

88

limit *= BATADV_FRAG_MAX_FRAGMENTS;

net/batman-adv/fragmentation.c

90

return limit;

net/bridge/netfilter/ebt_among.c

28

int start, limit, i;

net/bridge/netfilter/ebt_among.c

34

limit = wh->table[key + 1];

net/bridge/netfilter/ebt_among.c

36

for (i = start; i < limit; i++) {

net/bridge/netfilter/ebt_among.c

43

for (i = start; i < limit; i++) {

net/bridge/netfilter/ebtables.c

469

unsigned int limit = repl->entries_size;

net/bridge/netfilter/ebtables.c

480

while (offset < limit) {

net/bridge/netfilter/ebtables.c

481

size_t left = limit - offset;

net/bridge/netfilter/ebtables.c

517

if (offset != limit)

net/core/dev.c

12348

unsigned int limit = MAX_LOCK_DEPTH / 2;

net/core/dev.c

12350

if (lockdep_depth(current) > limit)

net/core/net-sysfs.c

1687

BQL_ATTR(limit, limit);

net/devlink/dev.c

22

enum devlink_reload_limit limit;

net/devlink/dev.c

29

.limit = DEVLINK_RELOAD_LIMIT_NO_RESET,

net/devlink/dev.c

328

enum devlink_reload_limit limit, u32 actions_performed)

net/devlink/dev.c

335

stat_idx = limit * __DEVLINK_RELOAD_ACTION_MAX + action;

net/devlink/dev.c

342

devlink_reload_stats_update(struct devlink *devlink, enum devlink_reload_limit limit,

net/devlink/dev.c

345

__devlink_reload_stats_update(devlink, devlink->stats.reload_stats, limit,

net/devlink/dev.c

35

enum devlink_reload_limit limit)

net/devlink/dev.c

364

enum devlink_reload_limit limit,

net/devlink/dev.c

370

limit > DEVLINK_RELOAD_LIMIT_MAX))

net/devlink/dev.c

373

__devlink_reload_stats_update(devlink, devlink->stats.remote_reload_stats, limit,

net/devlink/dev.c

41

devlink_reload_invalid_combinations[i].limit == limit)

net/devlink/dev.c

444

enum devlink_reload_limit limit,

net/devlink/dev.c

461

err = devlink->ops->reload_down(devlink, !!dest_net, action, limit, extack);

net/devlink/dev.c

474

err = devlink->ops->reload_up(devlink, action, limit, actions_performed, extack);

net/devlink/dev.c

483

devlink_reload_stats_update(devlink, limit, *actions_performed);

net/devlink/dev.c

523

enum devlink_reload_limit limit;

net/devlink/dev.c

53

devlink_reload_limit_is_supported(struct devlink *devlink, enum devlink_reload_limit limit)

net/devlink/dev.c

542

limit = DEVLINK_RELOAD_LIMIT_UNSPEC;

net/devlink/dev.c

55

return test_bit(limit, &devlink->ops->reload_limits);

net/devlink/dev.c

553

for (limit = 0 ; limit <= DEVLINK_RELOAD_LIMIT_MAX ; limit++)

net/devlink/dev.c

554

if (limits_selected & BIT(limit))

net/devlink/dev.c

557

if (limits_selected != BIT(limit)) {

net/devlink/dev.c

561

if (!devlink_reload_limit_is_supported(devlink, limit)) {

net/devlink/dev.c

565

if (devlink_reload_combination_is_invalid(action, limit)) {

net/devlink/dev.c

584

err = devlink_reload(devlink, dest_net, action, limit, &actions_performed, info->extack);

net/devlink/dev.c

59

enum devlink_reload_limit limit, u32 value)

net/devlink/dev.c

622

ops->reload_limits == BIT(comb->limit))

net/devlink/dev.c

67

if (nla_put_u8(msg, DEVLINK_ATTR_RELOAD_STATS_LIMIT, limit) ||

net/devlink/devl_internal.h

282

enum devlink_reload_limit limit,

net/ethtool/ioctl.c

1657

u32 limit, ctx_id;

net/ethtool/ioctl.c

1669

limit = ops->rxfh_max_num_contexts ?: U32_MAX;

net/ethtool/ioctl.c

1671

XA_LIMIT(1, limit - 1), GFP_KERNEL_ACCOUNT);

net/ethtool/rss.c

1004

u32 limit;

net/ethtool/rss.c

1058

limit = ops->rxfh_max_num_contexts ?: U32_MAX;

net/ethtool/rss.c

1060

XA_LIMIT(1, limit - 1), GFP_KERNEL_ACCOUNT);

net/ipv4/netfilter/arp_tables.c

1078

const unsigned char *limit)

net/ipv4/netfilter/arp_tables.c

1086

(unsigned char *)e + sizeof(struct compat_arpt_entry) >= limit ||

net/ipv4/netfilter/arp_tables.c

1087

(unsigned char *)e + e->next_offset > limit)

net/ipv4/netfilter/arp_tables.c

455

const unsigned char *limit,

net/ipv4/netfilter/arp_tables.c

464

(unsigned char *)e + sizeof(struct arpt_entry) >= limit ||

net/ipv4/netfilter/arp_tables.c

465

(unsigned char *)e + e->next_offset > limit)

net/ipv4/netfilter/ip_tables.c

1290

const unsigned char *limit)

net/ipv4/netfilter/ip_tables.c

1300

(unsigned char *)e + sizeof(struct compat_ipt_entry) >= limit ||

net/ipv4/netfilter/ip_tables.c

1301

(unsigned char *)e + e->next_offset > limit)

net/ipv4/netfilter/ip_tables.c

590

const unsigned char *limit,

net/ipv4/netfilter/ip_tables.c

599

(unsigned char *)e + sizeof(struct ipt_entry) >= limit ||

net/ipv4/netfilter/ip_tables.c

600

(unsigned char *)e + e->next_offset > limit)

net/ipv4/tcp.c

5163

unsigned long limit = nr_free_buffer_pages() / 16;

net/ipv4/tcp.c

5165

limit = max(limit, 128UL);

net/ipv4/tcp.c

5166

sysctl_tcp_mem[0] = limit / 4 * 3; /* 4.68 % */

net/ipv4/tcp.c

5167

sysctl_tcp_mem[1] = limit; /* 6.25 % */

net/ipv4/tcp.c

5267

unsigned long limit;

net/ipv4/tcp.c

5343

limit = nr_free_buffer_pages() << (PAGE_SHIFT - 7);

net/ipv4/tcp.c

5344

max_wshare = min(4UL*1024*1024, limit);

net/ipv4/tcp.c

5345

max_rshare = min(32UL*1024*1024, limit);

net/ipv4/tcp_ipv4.c

1985

u64 limit;

net/ipv4/tcp_ipv4.c

2088

limit = ((u64)READ_ONCE(sk->sk_rcvbuf)) << 1;

net/ipv4/tcp_ipv4.c

2090

limit += ((u32)READ_ONCE(sk->sk_sndbuf)) >> 1;

net/ipv4/tcp_ipv4.c

2096

limit += 64 * 1024;

net/ipv4/tcp_ipv4.c

2098

limit = min_t(u64, limit, UINT_MAX);

net/ipv4/tcp_ipv4.c

2100

err = sk_add_backlog(sk, skb, limit);

net/ipv4/tcp_metrics.c

148

unsigned long limit;

net/ipv4/tcp_metrics.c

152

limit = READ_ONCE(tm->tcpm_stamp) + TCP_METRICS_TIMEOUT;

net/ipv4/tcp_metrics.c

153

if (unlikely(time_after(jiffies, limit)))

net/ipv4/tcp_output.c

1828

long limit;

net/ipv4/tcp_output.c

1842

limit = sk->sk_sndbuf + 2 * SKB_TRUESIZE(GSO_LEGACY_MAX_SIZE);

net/ipv4/tcp_output.c

1843

if (unlikely((sk->sk_wmem_queued >> 1) > limit &&

net/ipv4/tcp_output.c

2437

u32 send_win, cong_win, limit, in_flight, threshold;

net/ipv4/tcp_output.c

2466

limit = min(send_win, cong_win);

net/ipv4/tcp_output.c

2469

if (limit >= max_segs * tp->mss_cache)

net/ipv4/tcp_output.c

2473

if ((skb != tcp_write_queue_tail(sk)) && (limit >= skb->len))

net/ipv4/tcp_output.c

2484

if (limit >= chunk)

net/ipv4/tcp_output.c

2492

if (limit > tcp_max_tso_deferred_mss(tp) * tp->mss_cache)

net/ipv4/tcp_output.c

2838

unsigned long limit;

net/ipv4/tcp_output.c

2840

limit = max_t(unsigned long,

net/ipv4/tcp_output.c

2843

limit = min_t(unsigned long, limit,

net/ipv4/tcp_output.c

2845

limit <<= factor;

net/ipv4/tcp_output.c

2858

limit += extra_bytes;

net/ipv4/tcp_output.c

2860

if (refcount_read(&sk->sk_wmem_alloc) > limit) {

net/ipv4/tcp_output.c

2875

if (refcount_read(&sk->sk_wmem_alloc) > limit)

net/ipv4/tcp_output.c

2996

unsigned int limit;

net/ipv4/tcp_output.c

3043

limit = mss_now;

net/ipv4/tcp_output.c

3045

limit = tcp_mss_split_point(sk, skb, mss_now,

net/ipv4/tcp_output.c

3049

if (skb->len > limit &&

net/ipv4/tcp_output.c

3050

unlikely(tso_fragment(sk, skb, limit, mss_now, gfp)))

net/ipv4/udp.c

4051

unsigned long limit;

net/ipv4/udp.c

4054

limit = nr_free_buffer_pages() / 8;

net/ipv4/udp.c

4055

limit = max(limit, 128UL);

net/ipv4/udp.c

4056

sysctl_udp_mem[0] = limit / 4 * 3;

net/ipv4/udp.c

4057

sysctl_udp_mem[1] = limit;

net/ipv6/netfilter/ip6_tables.c

1306

const unsigned char *limit)

net/ipv6/netfilter/ip6_tables.c

1316

(unsigned char *)e + sizeof(struct compat_ip6t_entry) >= limit ||

net/ipv6/netfilter/ip6_tables.c

1317

(unsigned char *)e + e->next_offset > limit)

net/ipv6/netfilter/ip6_tables.c

608

const unsigned char *limit,

net/ipv6/netfilter/ip6_tables.c

617

(unsigned char *)e + sizeof(struct ip6t_entry) >= limit ||

net/ipv6/netfilter/ip6_tables.c

618

(unsigned char *)e + e->next_offset > limit)

net/mac80211/debugfs.c

104

fq->limit,

net/mac80211/debugfs.c

132

if (sscanf(buf, "fq_limit %u", &local->fq.limit) == 1)

net/mac80211/tx.c

1565

local->fq.limit = local->hw.wiphy->txq_limit;

net/mac80211/tx.c

1567

local->hw.wiphy->txq_limit = local->fq.limit;

net/mpls/af_mpls.c

2581

static int resize_platform_label_table(struct net *net, size_t limit)

net/mpls/af_mpls.c

2583

size_t size = sizeof(struct mpls_route *) * limit;

net/mpls/af_mpls.c

2597

if (limit > MPLS_LABEL_IPV4NULL) {

net/mpls/af_mpls.c

2614

if (limit > MPLS_LABEL_IPV6NULL) {

net/mpls/af_mpls.c

2639

for (index = limit; index < old_limit; index++)

net/mpls/af_mpls.c

2644

if (old_limit < limit)

net/mpls/af_mpls.c

2651

(limit > MPLS_LABEL_IPV6NULL)) {

net/mpls/af_mpls.c

2657

(limit > MPLS_LABEL_IPV4NULL)) {

net/mpls/af_mpls.c

2665

net->mpls.platform_labels = limit;

net/mptcp/pm_kernel.c

1362

static int parse_limit(struct genl_info *info, int id, unsigned int *limit)

net/mptcp/pm_kernel.c

1369

*limit = nla_get_u32(attr);

net/mptcp/pm_kernel.c

1370

if (*limit > MPTCP_PM_ADDR_MAX) {

net/mptcp/protocol.c

1157

u16 limit;

net/mptcp/protocol.c

1288

if (WARN_ON_ONCE(info->sent > info->limit ||

net/mptcp/protocol.c

1289

info->limit > dfrag->data_len))

net/mptcp/protocol.c

1355

copy = min_t(size_t, copy, info->limit - info->sent);

net/mptcp/protocol.c

1582

info->limit = dfrag->data_len;

net/mptcp/protocol.c

160

int limit = READ_ONCE(sk->sk_rcvbuf);

net/mptcp/protocol.c

164

((to->len + from->len) > (limit >> 3)) ||

net/mptcp/protocol.c

1832

u32 limit, not_sent;

net/mptcp/protocol.c

1837

limit = mptcp_notsent_lowat(sk);

net/mptcp/protocol.c

1838

if (limit == UINT_MAX)

net/mptcp/protocol.c

1842

if (not_sent >= limit)

net/mptcp/protocol.c

1845

return limit - not_sent;

net/mptcp/protocol.c

2791

info.limit = READ_ONCE(msk->csum_enabled) ? dfrag->data_len :

net/mptcp/protocol.c

2808

while (info.sent < info.limit) {

net/mptcp/subflow.c

1257

u64 limit)

net/mptcp/subflow.c

1269

incr = limit >= avail_len ? avail_len + fin : limit;

net/ncsi/ncsi-manage.c

357

int i, limit = ARRAY_SIZE(ndp->requests);

net/ncsi/ncsi-manage.c

362

for (i = ndp->request_id; i < limit; i++) {

net/netfilter/nf_conntrack_sip.c

100

static int word_len(const char *dptr, const char *limit)

net/netfilter/nf_conntrack_sip.c

103

while (dptr < limit && iswordc(*dptr)) {

net/netfilter/nf_conntrack_sip.c

111

const char *limit, int *shift)

net/netfilter/nf_conntrack_sip.c

115

len = word_len(dptr, limit);

net/netfilter/nf_conntrack_sip.c

117

if (!len || dptr == limit || *dptr != '@')

net/netfilter/nf_conntrack_sip.c

122

domain_len = word_len(dptr, limit);

net/netfilter/nf_conntrack_sip.c

130

const char *limit, int *shift)

net/netfilter/nf_conntrack_sip.c

132

int len = string_len(ct, dptr, limit, shift);

net/netfilter/nf_conntrack_sip.c

135

if (dptr >= limit || *dptr != ' ')

net/netfilter/nf_conntrack_sip.c

140

return len + digits_len(ct, dptr, limit, shift);

net/netfilter/nf_conntrack_sip.c

145

const char *limit, bool delim)

net/netfilter/nf_conntrack_sip.c

156

ret = in4_pton(cp, limit - cp, (u8 *)&addr->ip, -1, &end);

net/netfilter/nf_conntrack_sip.c

161

if (cp < limit && *cp == '[')

net/netfilter/nf_conntrack_sip.c

166

ret = in6_pton(cp, limit - cp, (u8 *)&addr->ip6, -1, &end);

net/netfilter/nf_conntrack_sip.c

170

if (end < limit && *end == ']')

net/netfilter/nf_conntrack_sip.c

186

const char *limit, int *shift)

net/netfilter/nf_conntrack_sip.c

191

if (!sip_parse_addr(ct, dptr, &dptr, &addr, limit, true)) {

net/netfilter/nf_conntrack_sip.c

199

dptr += digits_len(ct, dptr, limit, shift);

net/netfilter/nf_conntrack_sip.c

206

const char *limit, int *shift)

net/netfilter/nf_conntrack_sip.c

214

while (dptr < limit &&

net/netfilter/nf_conntrack_sip.c

220

if (dptr < limit && *dptr == '@') {

net/netfilter/nf_conntrack_sip.c

228

return epaddr_len(ct, dptr, limit, shift);

net/netfilter/nf_conntrack_sip.c

242

const char *start = dptr, *limit = dptr + datalen, *end;

net/netfilter/nf_conntrack_sip.c

248

mlen = string_len(ct, dptr, limit, NULL);

net/netfilter/nf_conntrack_sip.c

252

if (++dptr >= limit)

net/netfilter/nf_conntrack_sip.c

256

for (; dptr < limit - strlen("sip:"); dptr++) {

net/netfilter/nf_conntrack_sip.c

264

if (!skp_epaddr_len(ct, dptr, limit, &shift))

net/netfilter/nf_conntrack_sip.c

268

if (!sip_parse_addr(ct, dptr, &end, addr, limit, true))

net/netfilter/nf_conntrack_sip.c

270

if (end < limit && *end == ':') {

net/netfilter/nf_conntrack_sip.c

312

static const char *sip_follow_continuation(const char *dptr, const char *limit)

net/netfilter/nf_conntrack_sip.c

315

if (++dptr >= limit)

net/netfilter/nf_conntrack_sip.c

320

if (++dptr >= limit)

net/netfilter/nf_conntrack_sip.c

329

for (; dptr < limit; dptr++) {

net/netfilter/nf_conntrack_sip.c

336

static const char *sip_skip_whitespace(const char *dptr, const char *limit)

net/netfilter/nf_conntrack_sip.c

338

for (; dptr < limit; dptr++) {

net/netfilter/nf_conntrack_sip.c

343

dptr = sip_follow_continuation(dptr, limit);

net/netfilter/nf_conntrack_sip.c

350

static const char *ct_sip_header_search(const char *dptr, const char *limit,

net/netfilter/nf_conntrack_sip.c

353

for (limit -= len; dptr < limit; dptr++) {

net/netfilter/nf_conntrack_sip.c

355

dptr = sip_follow_continuation(dptr, limit);

net/netfilter/nf_conntrack_sip.c

373

const char *start = dptr, *limit = dptr + datalen;

net/netfilter/nf_conntrack_sip.c

376

for (dptr += dataoff; dptr < limit; dptr++) {

net/netfilter/nf_conntrack_sip.c

380

if (++dptr >= limit)

net/netfilter/nf_conntrack_sip.c

383

if (++dptr >= limit)

net/netfilter/nf_conntrack_sip.c

393

if (limit - dptr >= hdr->len &&

net/netfilter/nf_conntrack_sip.c

396

else if (hdr->cname && limit - dptr >= hdr->clen + 1 &&

net/netfilter/nf_conntrack_sip.c

404

dptr = sip_skip_whitespace(dptr, limit);

net/netfilter/nf_conntrack_sip.c

407

if (*dptr != ':' || ++dptr >= limit)

net/netfilter/nf_conntrack_sip.c

411

dptr = sip_skip_whitespace(dptr, limit);

net/netfilter/nf_conntrack_sip.c

417

dptr = ct_sip_header_search(dptr, limit, hdr->search,

net/netfilter/nf_conntrack_sip.c

424

*matchlen = hdr->match_len(ct, dptr, limit, &shift);

net/netfilter/nf_conntrack_sip.c

441

const char *start = dptr, *limit = dptr + datalen;

net/netfilter/nf_conntrack_sip.c

446

dptr = ct_sip_header_search(dptr, limit, ",", strlen(","));

net/netfilter/nf_conntrack_sip.c

450

dptr = ct_sip_header_search(dptr, limit, hdr->search, hdr->slen);

net/netfilter/nf_conntrack_sip.c

456

*matchlen = hdr->match_len(ct, dptr, limit, &shift);

net/netfilter/nf_conntrack_sip.c

511

const char *c, *limit = dptr + datalen;

net/netfilter/nf_conntrack_sip.c

521

if (!sip_parse_addr(ct, dptr + *matchoff, &c, addr, limit, true))

net/netfilter/nf_conntrack_sip.c

543

const char *limit = dptr + datalen;

net/netfilter/nf_conntrack_sip.c

547

limit = ct_sip_header_search(dptr + dataoff, limit, ",", strlen(","));

net/netfilter/nf_conntrack_sip.c

548

if (!limit)

net/netfilter/nf_conntrack_sip.c

549

limit = dptr + datalen;

net/netfilter/nf_conntrack_sip.c

551

start = ct_sip_header_search(dptr + dataoff, limit, name, strlen(name));

net/netfilter/nf_conntrack_sip.c

556

end = ct_sip_header_search(start, limit, ";", strlen(";"));

net/netfilter/nf_conntrack_sip.c

558

end = limit;

net/netfilter/nf_conntrack_sip.c

572

const char *limit = dptr + datalen;

net/netfilter/nf_conntrack_sip.c

575

limit = ct_sip_header_search(dptr + dataoff, limit, ",", strlen(","));

net/netfilter/nf_conntrack_sip.c

576

if (!limit)

net/netfilter/nf_conntrack_sip.c

577

limit = dptr + datalen;

net/netfilter/nf_conntrack_sip.c

579

start = ct_sip_header_search(dptr + dataoff, limit, name, strlen(name));

net/netfilter/nf_conntrack_sip.c

584

if (!sip_parse_addr(ct, start, &end, addr, limit, delim))

net/netfilter/nf_conntrack_sip.c

599

const char *limit = dptr + datalen;

net/netfilter/nf_conntrack_sip.c

603

limit = ct_sip_header_search(dptr + dataoff, limit, ",", strlen(","));

net/netfilter/nf_conntrack_sip.c

604

if (!limit)

net/netfilter/nf_conntrack_sip.c

605

limit = dptr + datalen;

net/netfilter/nf_conntrack_sip.c

607

start = ct_sip_header_search(dptr + dataoff, limit, name, strlen(name));

net/netfilter/nf_conntrack_sip.c

648

const char *limit)

net/netfilter/nf_conntrack_sip.c

656

ret = in4_pton(cp, limit - cp, (u8 *)&addr->ip, -1, &end);

net/netfilter/nf_conntrack_sip.c

659

ret = in6_pton(cp, limit - cp, (u8 *)&addr->ip6, -1, &end);

net/netfilter/nf_conntrack_sip.c

67

const char *limit, int *shift)

net/netfilter/nf_conntrack_sip.c

674

const char *limit, int *shift)

net/netfilter/nf_conntrack_sip.c

679

if (!sdp_parse_addr(ct, dptr, &dptr, &addr, limit)) {

net/netfilter/nf_conntrack_sip.c

71

while (dptr < limit && isalpha(*dptr)) {

net/netfilter/nf_conntrack_sip.c

711

static const char *ct_sdp_header_search(const char *dptr, const char *limit,

net/netfilter/nf_conntrack_sip.c

714

for (limit -= len; dptr < limit; dptr++) {

net/netfilter/nf_conntrack_sip.c

734

const char *start = dptr, *limit = dptr + datalen;

net/netfilter/nf_conntrack_sip.c

741

for (dptr += dataoff; dptr < limit; dptr++) {

net/netfilter/nf_conntrack_sip.c

745

if (++dptr >= limit)

net/netfilter/nf_conntrack_sip.c

748

if (++dptr >= limit)

net/netfilter/nf_conntrack_sip.c

753

limit - dptr >= thdr->len &&

net/netfilter/nf_conntrack_sip.c

756

else if (limit - dptr >= hdr->len &&

net/netfilter/nf_conntrack_sip.c

764

dptr = ct_sdp_header_search(dptr, limit, hdr->search,

net/netfilter/nf_conntrack_sip.c

771

*matchlen = hdr->match_len(ct, dptr, limit, &shift);

net/netfilter/nf_conntrack_sip.c

79

const char *limit, int *shift)

net/netfilter/nf_conntrack_sip.c

82

while (dptr < limit && isdigit(*dptr)) {

net/netfilter/nft_connlimit.c

104

if (nla_put_be32(skb, NFTA_CONNLIMIT_COUNT, htonl(priv->limit)))

net/netfilter/nft_connlimit.c

140

WRITE_ONCE(priv->limit, newpriv->limit);

net/netfilter/nft_connlimit.c

18

u32 limit;

net/netfilter/nft_connlimit.c

228

priv_dst->limit = priv_src->limit;

net/netfilter/nft_connlimit.c

47

if ((count > READ_ONCE(priv->limit)) ^ READ_ONCE(priv->invert)) {

net/netfilter/nft_connlimit.c

58

u32 flags, limit;

net/netfilter/nft_connlimit.c

64

limit = ntohl(nla_get_be32(tb[NFTA_CONNLIMIT_COUNT]));

net/netfilter/nft_connlimit.c

79

priv->limit = limit;

net/netfilter/nft_limit.c

113

priv->limit = kmalloc_obj(*priv->limit, GFP_KERNEL_ACCOUNT);

net/netfilter/nft_limit.c

114

if (!priv->limit)

net/netfilter/nft_limit.c

117

priv->limit->tokens = tokens;

net/netfilter/nft_limit.c

118

priv->tokens_max = priv->limit->tokens;

net/netfilter/nft_limit.c

120

priv->limit->last = ktime_get_ns();

net/netfilter/nft_limit.c

121

spin_lock_init(&priv->limit->lock);

net/netfilter/nft_limit.c

149

kfree(priv->limit);

net/netfilter/nft_limit.c

161

priv_dst->limit = kmalloc_obj(*priv_dst->limit, gfp);

net/netfilter/nft_limit.c

162

if (!priv_dst->limit)

net/netfilter/nft_limit.c

165

spin_lock_init(&priv_dst->limit->lock);

net/netfilter/nft_limit.c

166

priv_dst->limit->tokens = priv_src->tokens_max;

net/netfilter/nft_limit.c

167

priv_dst->limit->last = ktime_get_ns();

net/netfilter/nft_limit.c

173

struct nft_limit_priv limit;

net/netfilter/nft_limit.c

183

if (nft_limit_eval(&priv->limit, priv->cost))

net/netfilter/nft_limit.c

202

err = nft_limit_init(&priv->limit, tb, true);

net/netfilter/nft_limit.c

206

priv->cost = div64_u64(priv->limit.nsecs, priv->limit.rate);

net/netfilter/nft_limit.c

215

return nft_limit_dump(skb, &priv->limit, NFT_LIMIT_PKTS);

net/netfilter/nft_limit.c

223

nft_limit_destroy(ctx, &priv->limit);

net/netfilter/nft_limit.c

234

return nft_limit_clone(&priv_dst->limit, &priv_src->limit, gfp);

net/netfilter/nft_limit.c

24

struct nft_limit *limit;

net/netfilter/nft_limit.c

336

if (nft_limit_eval(&priv->limit, priv->cost))

net/netfilter/nft_limit.c

347

err = nft_limit_init(&priv->limit, tb, true);

net/netfilter/nft_limit.c

351

priv->cost = div64_u64(priv->limit.nsecs, priv->limit.rate);

net/netfilter/nft_limit.c

361

return nft_limit_dump(skb, &priv->limit, NFT_LIMIT_PKTS);

net/netfilter/nft_limit.c

369

nft_limit_destroy(ctx, &priv->limit);

net/netfilter/nft_limit.c

37

spin_lock_bh(&priv->limit->lock);

net/netfilter/nft_limit.c

39

tokens = priv->limit->tokens + now - priv->limit->last;

net/netfilter/nft_limit.c

43

priv->limit->last = now;

net/netfilter/nft_limit.c

46

priv->limit->tokens = delta;

net/netfilter/nft_limit.c

47

spin_unlock_bh(&priv->limit->lock);

net/netfilter/nft_limit.c

50

priv->limit->tokens = tokens;

net/netfilter/nft_limit.c

51

spin_unlock_bh(&priv->limit->lock);

net/netfilter/xt_connlimit.c

70

return (connections > info->limit) ^ !!(info->flags & XT_CONNLIMIT_INVERT);

net/openvswitch/conntrack.c

1681

info->default_limit = zone_limit->limit;

net/openvswitch/conntrack.c

1694

ct_limit->limit = zone_limit->limit;

net/openvswitch/conntrack.c

1751

.limit = info->default_limit,

net/openvswitch/conntrack.c

1759

u16 zone_id, u32 limit,

net/openvswitch/conntrack.c

1767

zone_limit.limit = limit;

net/openvswitch/conntrack.c

1782

u32 limit;

net/openvswitch/conntrack.c

1799

limit = ct_limit_get(info, zone);

net/openvswitch/conntrack.c

1803

net, info->data, zone, limit, reply);

net/openvswitch/conntrack.c

1835

ct_limit->zone, ct_limit->limit, reply);

net/openvswitch/conntrack.c

91

u32 limit;

net/openvswitch/conntrack.c

924

return ct_limit->limit;

net/rxrpc/ar-internal.h

1042

void rxrpc_transmit_some_data(struct rxrpc_call *call, unsigned int limit,

net/rxrpc/call_event.c

194

static void rxrpc_transmit_fresh_data(struct rxrpc_call *call, unsigned int limit,

net/rxrpc/call_event.c

215

int limit = min(space, max(call->peer->pmtud_jumbo, 1));

net/rxrpc/call_event.c

245

} while (req.n < limit && before(seq, send_top));

net/rxrpc/call_event.c

259

void rxrpc_transmit_some_data(struct rxrpc_call *call, unsigned int limit,

net/rxrpc/call_event.c

277

rxrpc_transmit_fresh_data(call, limit, trace);

net/rxrpc/conn_client.c

209

int id_cursor, id, distance, limit;

net/rxrpc/conn_client.c

234

limit = umax(atomic_read(&rxnet->nr_conns) * 4, 1024);

net/rxrpc/conn_client.c

235

if (distance > limit)

net/rxrpc/rxgk.c

288

size_t shdr, alloc, limit, part, offset, gap;

net/rxrpc/rxgk.c

310

limit = crypto_krb5_how_much_data(gk->krb5, mode, &alloc, &offset);

net/rxrpc/rxgk.c

312

if (remain < limit - shdr) {

net/rxrpc/rxgk.c

318

part = limit - shdr;

net/rxrpc/rxkad.c

151

size_t shdr, alloc, limit, part;

net/rxrpc/rxkad.c

167

limit = round_down(RXRPC_JUMBO_DATALEN, RXKAD_ALIGN) - shdr;

net/rxrpc/rxkad.c

168

if (remain < limit) {

net/rxrpc/rxkad.c

172

part = limit;

net/sched/act_police.c

232

static bool tcf_police_mtu_check(struct sk_buff *skb, u32 limit)

net/sched/act_police.c

237

return skb_gso_validate_mac_len(skb, limit);

net/sched/act_police.c

243

return len <= limit;

net/sched/bpf_qdisc.c

59

case offsetof(struct Qdisc, limit):

net/sched/bpf_qdisc.c

60

*end = offsetofend(struct Qdisc, limit);

net/sched/cls_api.c

1724

int limit = 0;

net/sched/cls_api.c

1790

if (unlikely(limit++ >= max_reclassify_loop)) {

net/sched/sch_cake.c

2631

max(sch->limit * psched_mtu(qdisc_dev(sch)),

net/sched/sch_cake.c

2826

sch->limit = 10240;

net/sched/sch_choke.c

267

if (sch->q.qlen < q->limit) {

net/sched/sch_choke.c

366

if (ctl->limit > CHOKE_MAX_QUEUE)

net/sched/sch_choke.c

369

mask = roundup_pow_of_two(ctl->limit + 1) - 1;

net/sched/sch_choke.c

409

WRITE_ONCE(q->limit, ctl->limit);

net/sched/sch_choke.c

437

.limit = READ_ONCE(q->limit),

net/sched/sch_choke.c

50

u32 limit;

net/sched/sch_codel.c

138

WRITE_ONCE(sch->limit,

net/sched/sch_codel.c

145

while (sch->q.qlen > sch->limit) {

net/sched/sch_codel.c

166

sch->limit = DEFAULT_CODEL_LIMIT;

net/sched/sch_codel.c

180

if (sch->limit >= 1)

net/sched/sch_codel.c

203

READ_ONCE(sch->limit)) ||

net/sched/sch_codel.c

83

if (likely(qdisc_qlen(sch) < sch->limit)) {

net/sched/sch_dualpi2.c

391

if (unlikely(qdisc_qlen(sch) >= sch->limit) ||

net/sched/sch_dualpi2.c

678

static u32 get_memory_limit(struct Qdisc *sch, u32 limit)

net/sched/sch_dualpi2.c

683

u64 memlim = mul_u32_u32(limit, 2 * psched_mtu(qdisc_dev(sch)));

net/sched/sch_dualpi2.c

785

u32 limit = nla_get_u32(tb[TCA_DUALPI2_LIMIT]);

net/sched/sch_dualpi2.c

787

WRITE_ONCE(sch->limit, limit);

net/sched/sch_dualpi2.c

788

WRITE_ONCE(q->memory_limit, get_memory_limit(sch, limit));

net/sched/sch_dualpi2.c

873

while (qdisc_qlen(sch) > sch->limit ||

net/sched/sch_dualpi2.c

893

q->sch->limit = 10000; /* Max 125ms at 1Gbps */

net/sched/sch_dualpi2.c

894

q->memory_limit = get_memory_limit(sch, q->sch->limit);

net/sched/sch_dualpi2.c

961

(nla_put_u32(skb, TCA_DUALPI2_LIMIT, READ_ONCE(sch->limit)) ||

net/sched/sch_dualpi2.c

988

(nla_put_u32(skb, TCA_DUALPI2_LIMIT, READ_ONCE(sch->limit)) ||

net/sched/sch_fifo.c

107

u32 limit = qdisc_dev(sch)->tx_queue_len;

net/sched/sch_fifo.c

110

limit *= psched_mtu(qdisc_dev(sch));

net/sched/sch_fifo.c

112

WRITE_ONCE(sch->limit, limit);

net/sched/sch_fifo.c

119

WRITE_ONCE(sch->limit, ctl->limit);

net/sched/sch_fifo.c

123

bypass = sch->limit >= psched_mtu(qdisc_dev(sch));

net/sched/sch_fifo.c

125

bypass = sch->limit >= 1;

net/sched/sch_fifo.c

161

struct tc_fifo_qopt opt = { .limit = READ_ONCE(sch->limit) };

net/sched/sch_fifo.c

23

READ_ONCE(sch->limit)))

net/sched/sch_fifo.c

231

int fifo_set_limit(struct Qdisc *q, unsigned int limit)

net/sched/sch_fifo.c

247

((struct tc_fifo_qopt *)nla_data(nla))->limit = limit;

net/sched/sch_fifo.c

257

unsigned int limit,

net/sched/sch_fifo.c

266

err = fifo_set_limit(q, limit);

net/sched/sch_fifo.c

32

if (likely(sch->q.qlen < READ_ONCE(sch->limit)))

net/sched/sch_fifo.c

43

if (unlikely(READ_ONCE(sch->limit) == 0))

net/sched/sch_fifo.c

46

if (likely(sch->q.qlen < READ_ONCE(sch->limit)))

net/sched/sch_fq.c

1042

WRITE_ONCE(sch->limit,

net/sched/sch_fq.c

1141

while (sch->q.qlen > sch->limit) {

net/sched/sch_fq.c

1172

sch->limit = 10000;

net/sched/sch_fq.c

1240

READ_ONCE(sch->limit)) ||

net/sched/sch_fq.c

553

if (unlikely(q->band_pkt_count[band] >= sch->limit)) {

net/sched/sch_fq_codel.c

218

if (++sch->q.qlen <= sch->limit && !memory_limited)

net/sched/sch_fq_codel.c

425

WRITE_ONCE(sch->limit,

net/sched/sch_fq_codel.c

443

while (sch->q.qlen > sch->limit ||

net/sched/sch_fq_codel.c

476

sch->limit = 10*1024;

net/sched/sch_fq_codel.c

516

if (sch->limit >= 1)

net/sched/sch_fq_codel.c

546

READ_ONCE(sch->limit)) ||

net/sched/sch_fq_pie.c

158

if (unlikely(qdisc_qlen(sch) >= sch->limit)) {

net/sched/sch_fq_pie.c

301

u32 limit = nla_get_u32(tb[TCA_FQ_PIE_LIMIT]);

net/sched/sch_fq_pie.c

303

WRITE_ONCE(q->p_params.limit, limit);

net/sched/sch_fq_pie.c

304

WRITE_ONCE(sch->limit, limit);

net/sched/sch_fq_pie.c

367

while (sch->q.qlen > sch->limit) {

net/sched/sch_fq_pie.c

428

sch->limit = 10 * 1024;

net/sched/sch_fq_pie.c

429

q->p_params.limit = sch->limit;

net/sched/sch_fq_pie.c

483

if (nla_put_u32(skb, TCA_FQ_PIE_LIMIT, READ_ONCE(sch->limit)) ||

net/sched/sch_gred.c

183

sch->limit))

net/sched/sch_gred.c

247

if (gred_backlog(t, q, sch) + qdisc_pkt_len(skb) <= q->limit) {

net/sched/sch_gred.c

339

opt->set.tab[i].limit = q->limit;

net/sched/sch_gred.c

34

u32 limit; /* HARD maximal queue length */

net/sched/sch_gred.c

505

if (ctl->limit > sch->limit)

net/sched/sch_gred.c

506

q->limit = sch->limit;

net/sched/sch_gred.c

508

q->limit = ctl->limit;

net/sched/sch_gred.c

660

sch->limit = nla_get_u32(tb[TCA_GRED_LIMIT]);

net/sched/sch_gred.c

754

sch->limit = nla_get_u32(tb[TCA_GRED_LIMIT]);

net/sched/sch_gred.c

756

sch->limit = qdisc_dev(sch)->tx_queue_len

net/sched/sch_gred.c

798

if (nla_put_u32(skb, TCA_GRED_LIMIT, sch->limit))

net/sched/sch_gred.c

822

opt.limit = q->limit;

net/sched/sch_hhf.c

402

if (++sch->q.qlen <= sch->limit)

net/sched/sch_hhf.c

537

WRITE_ONCE(sch->limit, nla_get_u32(tb[TCA_HHF_BACKLOG_LIMIT]));

net/sched/sch_hhf.c

564

while (sch->q.qlen > sch->limit) {

net/sched/sch_hhf.c

586

sch->limit = 1000;

net/sched/sch_hhf.c

665

if (nla_put_u32(skb, TCA_HHF_BACKLOG_LIMIT, READ_ONCE(sch->limit)) ||

net/sched/sch_netem.c

1063

sch->limit = qopt->limit;

net/sched/sch_netem.c

1067

q->limit = qopt->limit;

net/sched/sch_netem.c

1224

qopt.limit = q->limit;

net/sched/sch_netem.c

527

if (unlikely(q->t_len >= sch->limit)) {

net/sched/sch_netem.c

94

u32 limit;

net/sched/sch_pie.c

172

u32 limit = nla_get_u32(tb[TCA_PIE_LIMIT]);

net/sched/sch_pie.c

174

WRITE_ONCE(q->params.limit, limit);

net/sched/sch_pie.c

175

WRITE_ONCE(sch->limit, limit);

net/sched/sch_pie.c

196

while (sch->q.qlen > sch->limit) {

net/sched/sch_pie.c

452

sch->limit = q->params.limit;

net/sched/sch_pie.c

481

nla_put_u32(skb, TCA_PIE_LIMIT, READ_ONCE(sch->limit)) ||

net/sched/sch_pie.c

92

if (unlikely(qdisc_qlen(sch) >= sch->limit)) {

net/sched/sch_plug.c

133

q->limit = qdisc_dev(sch)->tx_queue_len

net/sched/sch_plug.c

141

q->limit = ctl->limit;

net/sched/sch_plug.c

196

q->limit = msg->limit;

net/sched/sch_plug.c

66

u32 limit;

net/sched/sch_plug.c

92

if (likely(sch->qstats.backlog + skb->len <= q->limit)) {

net/sched/sch_qfq.c

1057

u64 limit, roundedF;

net/sched/sch_qfq.c

1061

limit = qfq_round_down(q->V, slot_shift) + (1ULL << slot_shift);

net/sched/sch_qfq.c

1063

if (!qfq_gt(agg->F, q->V) || qfq_gt(roundedF, limit)) {

net/sched/sch_qfq.c

1069

if (qfq_gt(limit, next->F))

net/sched/sch_qfq.c

1072

agg->S = limit;

net/sched/sch_red.c

203

opt.set.limit = q->limit;

net/sched/sch_red.c

267

if (ctl->limit > 0) {

net/sched/sch_red.c

268

child = fifo_create_dflt(sch, &bfifo_qdisc_ops, ctl->limit,

net/sched/sch_red.c

286

q->limit = ctl->limit;

net/sched/sch_red.c

37

u32 limit; /* HARD maximal queue length */

net/sched/sch_red.c

416

.limit = q->limit,

net/sched/sch_sfb.c

296

if (unlikely(sch->q.qlen >= q->limit)) {

net/sched/sch_sfb.c

303

unsigned long limit = q->rehash_time + q->rehash_interval;

net/sched/sch_sfb.c

305

if (unlikely(time_after(jiffies, limit))) {

net/sched/sch_sfb.c

309

time_after(jiffies, limit - q->warmup_time))) {

net/sched/sch_sfb.c

483

.limit = 0,

net/sched/sch_sfb.c

499

u32 limit;

net/sched/sch_sfb.c

514

limit = ctl->limit;

net/sched/sch_sfb.c

515

if (limit == 0)

net/sched/sch_sfb.c

516

limit = qdisc_dev(sch)->tx_queue_len;

net/sched/sch_sfb.c

518

child = fifo_create_dflt(sch, &pfifo_qdisc_ops, limit, extack);

net/sched/sch_sfb.c

533

q->limit = limit;

net/sched/sch_sfb.c

576

.limit = q->limit,

net/sched/sch_sfb.c

62

u32 limit; /* HARD maximal queue length */

net/sched/sch_sfq.c

109

int limit; /* limit of total number of packets in this qdisc */

net/sched/sch_sfq.c

457

if (++sch->q.qlen <= q->limit)

net/sched/sch_sfq.c

643

int limit;

net/sched/sch_sfq.c

678

limit = q->limit;

net/sched/sch_sfq.c

709

if (ctl->limit) {

net/sched/sch_sfq.c

710

limit = min_t(u32, ctl->limit, maxdepth * maxflows);

net/sched/sch_sfq.c

711

maxflows = min_t(u32, maxflows, limit);

net/sched/sch_sfq.c

713

if (limit == 1) {

net/sched/sch_sfq.c

721

q->limit = limit;

net/sched/sch_sfq.c

733

while (sch->q.qlen > q->limit) {

net/sched/sch_sfq.c

793

q->limit = SFQ_MAX_DEPTH;

net/sched/sch_sfq.c

823

if (q->limit >= 1)

net/sched/sch_sfq.c

840

opt.v0.limit = q->limit;

net/sched/sch_skbprio.c

174

WRITE_ONCE(sch->limit, ctl->limit);

net/sched/sch_skbprio.c

191

sch->limit = 64;

net/sched/sch_skbprio.c

202

opt.limit = READ_ONCE(sch->limit);

net/sched/sch_skbprio.c

84

if (sch->q.qlen < READ_ONCE(sch->limit)) {

net/sched/sch_tbf.c

100

u32 limit; /* Maximal length of backlog: bytes */

net/sched/sch_tbf.c

439

err = fifo_set_limit(q->qdisc, qopt->limit);

net/sched/sch_tbf.c

442

} else if (qopt->limit > 0) {

net/sched/sch_tbf.c

443

child = fifo_create_dflt(sch, &bfifo_qdisc_ops, qopt->limit,

net/sched/sch_tbf.c

460

q->limit = qopt->limit;

net/sched/sch_tbf.c

525

opt.limit = q->limit;

net/sctp/protocol.c

1465

unsigned long limit;

net/sctp/protocol.c

1499

limit = nr_free_buffer_pages() / 8;

net/sctp/protocol.c

1500

limit = max(limit, 128UL);

net/sctp/protocol.c

1501

sysctl_sctp_mem[0] = limit / 4 * 3;

net/sctp/protocol.c

1502

sysctl_sctp_mem[1] = limit;

net/sctp/protocol.c

1506

limit = (sysctl_sctp_mem[1]) << (PAGE_SHIFT - 7);

net/sctp/protocol.c

1507

max_share = min(4UL*1024*1024, limit);

net/sunrpc/svc_xprt.c

411

unsigned int limit = svc_rpc_per_connection_limit;

net/sunrpc/svc_xprt.c

414

return limit == 0 || (nrqsts >= 0 && nrqsts < limit);

net/tipc/link.c

1043

if (unlikely(l->backlog[imp].len >= l->backlog[imp].limit)) {

net/tipc/link.c

176

u16 limit;

net/tipc/link.c

2537

l->backlog[TIPC_LOW_IMPORTANCE].limit = min_win * 2;

net/tipc/link.c

2538

l->backlog[TIPC_MEDIUM_IMPORTANCE].limit = min_win * 4;

net/tipc/link.c

2539

l->backlog[TIPC_HIGH_IMPORTANCE].limit = min_win * 6;

net/tipc/link.c

2540

l->backlog[TIPC_CRITICAL_IMPORTANCE].limit = min_win * 8;

net/tipc/link.c

2541

l->backlog[TIPC_SYSTEM_IMPORTANCE].limit = max_bulk;

net/tipc/link.c

2879

void tipc_link_set_abort_limit(struct tipc_link *l, u32 limit)

net/tipc/link.c

2881

l->abort_limit = limit;

net/tipc/link.c

918

avail[imp] = l->backlog[imp].limit - l->backlog[imp].len;

net/tipc/link.h

126

void tipc_link_set_abort_limit(struct tipc_link *l, u32 limit);

net/tipc/netlink_compat.c

81

int limit;

net/tipc/netlink_compat.c

84

limit = TIPC_SKB_MAX - skb->len;

net/tipc/netlink_compat.c

86

if (tailroom < limit)

net/tipc/netlink_compat.c

89

return limit;

net/tipc/socket.c

2344

int limit, err = TIPC_OK;

net/tipc/socket.c

2363

limit = rcvbuf_limit(sk, skb);

net/tipc/socket.c

2368

else if (sk_rmem_alloc_get(sk) + skb->truesize >= limit) {

net/wireless/of.c

109

struct ieee80211_freq_range *limit = &freq_limits[i];

net/wireless/of.c

111

p = of_prop_next_u32(prop, p, &limit->start_freq_khz);

net/wireless/of.c

117

p = of_prop_next_u32(prop, p, &limit->end_freq_khz);

net/wireless/of.c

123

if (!limit->start_freq_khz ||

net/wireless/of.c

124

!limit->end_freq_khz ||

net/wireless/of.c

125

limit->start_freq_khz >= limit->end_freq_khz) {

net/wireless/of.c

30

struct ieee80211_freq_range *limit = &freq_limits[i];

net/wireless/of.c

32

if (cfg80211_does_bw_fit_range(limit,

net/wireless/reg.c

1298

u32 limit = freq_khz > 45 * KHZ_PER_GHZ ? 20 * KHZ_PER_GHZ : 2 * KHZ_PER_GHZ;

net/wireless/reg.c

1299

if (abs(freq_khz - freq_range->start_freq_khz) <= limit)

net/wireless/reg.c

1301

if (abs(freq_khz - freq_range->end_freq_khz) <= limit)

scripts/dtc/flattree.c

567

char *base, *limit, *ptr;

scripts/dtc/flattree.c

570

static void inbuf_init(struct inbuf *inb, void *base, void *limit)

scripts/dtc/flattree.c

573

inb->limit = limit;

scripts/dtc/flattree.c

579

if ((inb->ptr + len) > inb->limit)

scripts/dtc/flattree.c

603

if (inb->ptr > inb->limit)

scripts/dtc/flattree.c

614

if (p >= inb->limit)

scripts/dtc/flattree.c

651

if (p >= inb->limit || p < inb->base)

security/keys/gc.c

191

time64_t new_timer, limit, expiry;

security/keys/gc.c

195

limit = ktime_get_real_seconds();

security/keys/gc.c

242

if (expiry > limit && expiry < new_timer) {

security/keys/gc.c

244

key_serial(key), key->expiry - limit);

security/keys/gc.c

358

keyring_gc(key, limit);

security/keys/internal.h

167

extern void keyring_gc(struct key *keyring, time64_t limit);

security/keys/internal.h

217

static inline bool key_is_dead(const struct key *key, time64_t limit)

security/keys/internal.h

224

if (expiry <= limit)

security/keys/keyring.c

1696

time64_t *limit = iterator_data;

security/keys/keyring.c

1698

if (key_is_dead(key, *limit))

security/keys/keyring.c

1707

time64_t *limit = iterator_data;

security/keys/keyring.c

1710

return key_is_dead(key, *limit);

security/keys/keyring.c

1719

void keyring_gc(struct key *keyring, time64_t limit)

security/keys/keyring.c

1732

keyring_gc_check_iterator, &limit);

security/keys/keyring.c

1744

keyring_gc_select_iterator, &limit);

sound/isa/azt2320.c

134

unsigned long limit;

sound/isa/azt2320.c

136

limit = jiffies + HZ / 10;

sound/isa/azt2320.c

137

for (i = 50000; i && time_after(limit, jiffies); i--)

sound/isa/wavefront/wavefront_synth.c

267

wavefront_sleep (int limit)

sound/isa/wavefront/wavefront_synth.c

270

schedule_timeout_interruptible(limit);

sound/pci/aw2/aw2-saa7146.c

442

int limit = 0;

sound/pci/aw2/aw2-saa7146.c

445

limit++;

sound/pci/aw2/aw2-saa7146.c

447

return limit;

sound/pci/rme9652/hdspm.c

4629

unsigned int idx, limit;

sound/pci/rme9652/hdspm.c

4637

limit = ARRAY_SIZE(snd_hdspm_controls_madi);

sound/pci/rme9652/hdspm.c

4641

limit = ARRAY_SIZE(snd_hdspm_controls_madiface);

sound/pci/rme9652/hdspm.c

4645

limit = ARRAY_SIZE(snd_hdspm_controls_aio);

sound/pci/rme9652/hdspm.c

4649

limit = ARRAY_SIZE(snd_hdspm_controls_raydat);

sound/pci/rme9652/hdspm.c

4653

limit = ARRAY_SIZE(snd_hdspm_controls_aes32);

sound/pci/rme9652/hdspm.c

4658

for (idx = 0; idx < limit; idx++) {

sound/pci/rme9652/hdspm.c

4670

limit = hdspm->qs_out_channels;

sound/pci/rme9652/hdspm.c

4672

limit = hdspm->ds_out_channels;

sound/pci/rme9652/hdspm.c

4674

limit = hdspm->ss_out_channels;

sound/pci/rme9652/hdspm.c

4676

for (idx = 0; idx < limit; ++idx) {

sound/pci/rme9652/hdspm.c

4689

limit = ARRAY_SIZE(snd_hdspm_controls_tco);

sound/pci/rme9652/hdspm.c

4690

for (idx = 0; idx < limit; idx++) {

sound/soc/ux500/ux500_msp_i2s.c

382

u32 limit = 32;

sound/soc/ux500/ux500_msp_i2s.c

388

while (!(reg_val_FLR & RX_FIFO_EMPTY) && limit--) {

sound/soc/ux500/ux500_msp_i2s.c

399

u32 limit = 32;

sound/soc/ux500/ux500_msp_i2s.c

406

while (!(reg_val_FLR & TX_FIFO_EMPTY) && limit--) {

tools/arch/x86/include/uapi/asm/kvm.h

134

__u32 limit;

tools/arch/x86/include/uapi/asm/kvm.h

144

__u16 limit;

tools/include/nolibc/stdlib.h

444

uintmax_t val = 0, limit, old_val;

tools/include/nolibc/stdlib.h

463

limit = -(uintmax_t)lower_limit;

tools/include/nolibc/stdlib.h

465

limit = upper_limit;

tools/include/nolibc/stdlib.h

498

if (val > limit || val < old_val)

tools/include/nolibc/stdlib.h

505

val = limit;

tools/include/uapi/linux/pkt_cls.h

85

__u32 limit;

tools/include/uapi/linux/pkt_sched.h

124

__u32 limit; /* Queue length: bytes for bfifo, packets for pfifo */

tools/include/uapi/linux/pkt_sched.h

139

__u32 limit; /* Queue length in packets. */

tools/include/uapi/linux/pkt_sched.h

177

__u32 limit;

tools/include/uapi/linux/pkt_sched.h

185

__u32 limit;

tools/include/uapi/linux/pkt_sched.h

215

__u32 limit; /* Maximal packets in queue */

tools/include/uapi/linux/pkt_sched.h

234

__u32 limit; /* HARD maximal flow queue length (bytes) */

tools/include/uapi/linux/pkt_sched.h

264

__u32 limit; /* HARD maximal queue length (bytes) */

tools/include/uapi/linux/pkt_sched.h

327

__u32 limit; /* HARD maximal queue length (bytes) */

tools/include/uapi/linux/pkt_sched.h

367

__u32 limit; /* Hard queue length (packets) */

tools/include/uapi/linux/pkt_sched.h

484

__u32 limit; /* fifo limit (packets) */

tools/include/uapi/linux/pkt_sched.h

637

__u32 limit; /* max SFB queue length */

tools/lib/bpf/libbpf.c

298

struct rlimit limit;

tools/lib/bpf/libbpf.c

304

err = getrlimit(RLIMIT_MEMLOCK, &limit);

tools/lib/bpf/libbpf.c

308

if (limit.rlim_cur == RLIM_INFINITY)

tools/lib/bpf/libbpf.c

311

if (limit.rlim_cur < 1024)

tools/lib/bpf/libbpf.c

312

snprintf(buf, sizeof(buf), "%zu bytes", (size_t)limit.rlim_cur);

tools/lib/bpf/libbpf.c

313

else if (limit.rlim_cur < 1024*1024)

tools/lib/bpf/libbpf.c

314

snprintf(buf, sizeof(buf), "%.1f KiB", (double)limit.rlim_cur / 1024);

tools/lib/bpf/libbpf.c

316

snprintf(buf, sizeof(buf), "%.1f MiB", (double)limit.rlim_cur / (1024*1024));

tools/lib/bpf/zip.c

177

int64_t limit, offset;

tools/lib/bpf/zip.c

188

limit = (int64_t)offset - (1 << 16);

tools/lib/bpf/zip.c

190

for (; offset >= 0 && offset > limit && rc != 0; offset--) {

tools/net/ynl/samples/tc.c

30

if (fq_codel->_present.limit)

tools/net/ynl/samples/tc.c

31

printf("limit: %dp ", fq_codel->limit);

tools/perf/builtin-sched.c

565

struct rlimit limit;

tools/perf/builtin-sched.c

580

BUG_ON(getrlimit(RLIMIT_NOFILE, &limit) == -1);

tools/perf/builtin-sched.c

581

limit.rlim_cur += sched->nr_tasks - cur_task;

tools/perf/builtin-sched.c

582

if (limit.rlim_cur > limit.rlim_max) {

tools/perf/builtin-sched.c

583

limit.rlim_max = limit.rlim_cur;

tools/perf/builtin-sched.c

586

if (setrlimit(RLIMIT_NOFILE, &limit) == -1) {

tools/perf/tests/dso-data.c

253

int dso_cnt, limit, i, fd;

tools/perf/tests/dso-data.c

261

limit = nr * 4;

tools/perf/tests/dso-data.c

262

TEST_ASSERT_VAL("failed to set file limit", !set_fd_limit(limit));

tools/perf/tests/dso-data.c

265

dso_cnt = limit / 2;

tools/perf/util/auxtrace.c

2053

size_t limit;

tools/perf/util/auxtrace.c

2081

c->limit = (c->sz * limit_percent) / 100;

tools/perf/util/auxtrace.c

2134

if (c->limit && ++c->cnt > c->limit)

tools/perf/util/dso.c

709

rlim_t limit = 0;

tools/perf/util/dso.c

714

limit = l.rlim_cur;

tools/perf/util/dso.c

716

limit = l.rlim_cur / 2;

tools/perf/util/dso.c

719

limit = 1;

tools/perf/util/dso.c

722

return limit;

tools/perf/util/header.c

2536

u64 limit = offset + size;

tools/perf/util/header.c

2538

while (offset < limit) {

tools/perf/util/header.c

2577

u64 limit = offset + size, orig_offset = offset;

tools/perf/util/header.c

2580

while (offset < limit) {

tools/perf/util/hist.c

2203

bool hist_entry__has_hierarchy_children(struct hist_entry *he, float limit)

tools/perf/util/hist.c

2225

return node && percent >= limit;

tools/perf/util/hist.h

826

bool hist_entry__has_hierarchy_children(struct hist_entry *he, float limit);

tools/perf/util/ordered-events.c

228

u64 limit = oe->next_flush;

tools/perf/util/ordered-events.c

233

if (!limit)

tools/perf/util/ordered-events.c

243

if (iter->timestamp > limit)

tools/perf/util/ordered-events.c

258

else if (last_ts <= limit)

tools/power/x86/turbostat/turbostat.c

11573

struct rlimit limit;

tools/power/x86/turbostat/turbostat.c

11575

if (getrlimit(RLIMIT_NOFILE, &limit) < 0)

tools/power/x86/turbostat/turbostat.c

11578

if (limit.rlim_max < MAX_NOFILE)

tools/power/x86/turbostat/turbostat.c

11579

limit.rlim_max = MAX_NOFILE;

tools/power/x86/turbostat/turbostat.c

11580

if (limit.rlim_cur < MAX_NOFILE)

tools/power/x86/turbostat/turbostat.c

11581

limit.rlim_cur = MAX_NOFILE;

tools/power/x86/turbostat/turbostat.c

11583

if (setrlimit(RLIMIT_NOFILE, &limit) < 0)

tools/testing/radix-tree/maple.c

34588

int range_cnt = 200, i, limit = 10000;

tools/testing/radix-tree/maple.c

34615

while (limit--) {

tools/testing/radix-tree/maple.c

35659

unsigned long limit = mas->max;

tools/testing/radix-tree/maple.c

35663

mas_for_each(mas, entry, limit) {

tools/testing/selftests/bpf/prog_tests/arena_spin_lock.c

77

skel->bss->limit = repeat * nthreads;

tools/testing/selftests/bpf/progs/arena_spin_lock.c

30

int limit;

tools/testing/selftests/bpf/progs/arena_spin_lock.c

45

if (counter != limit)

tools/testing/selftests/bpf/progs/bpf_qdisc_fifo.c

26

if (sch->q.qlen == sch->limit)

tools/testing/selftests/bpf/progs/bpf_qdisc_fifo.c

81

sch->limit = 1000;

tools/testing/selftests/bpf/progs/bpf_qdisc_fq.c

317

if (sch->q.qlen >= sch->limit)

tools/testing/selftests/bpf/progs/bpf_qdisc_fq.c

604

bpf_for(i, 0, sch->limit) {

tools/testing/selftests/bpf/progs/bpf_qdisc_fq.c

726

sch->limit = 10000;

tools/testing/selftests/bpf/progs/verifier_iterating_callbacks.c

588

volatile const int limit = ARR2_SZ;

tools/testing/selftests/bpf/progs/verifier_iterating_callbacks.c

600

if (i < limit)

tools/testing/selftests/bpf/xdp_synproxy.c

78

static unsigned long parse_arg_ul(const char *progname, const char *arg, unsigned long limit)

tools/testing/selftests/bpf/xdp_synproxy.c

85

if (errno != 0 || *endptr != '\0' || arg[0] == '\0' || res > limit)

tools/testing/selftests/cgroup/lib/include/cgroup_util.h

37

long limit = (a + b) / 100 * err;

tools/testing/selftests/cgroup/lib/include/cgroup_util.h

39

int close = diff <= limit;

tools/testing/selftests/cgroup/lib/include/cgroup_util.h

45

a, b, diff, limit, err, actual_err);

tools/testing/selftests/cgroup/test_memcontrol.c

432

int limit;

tools/testing/selftests/cgroup/test_memcontrol.c

434

for (limit = 10; limit > 0; limit--) {

tools/testing/selftests/iommu/iommufd_utils.h

777

static int _test_ioctl_set_temp_memory_limit(int fd, unsigned int limit)

tools/testing/selftests/iommu/iommufd_utils.h

782

.memory_limit = { .limit = limit },

tools/testing/selftests/iommu/iommufd_utils.h

789

#define test_ioctl_set_temp_memory_limit(limit) \

tools/testing/selftests/iommu/iommufd_utils.h

790

ASSERT_EQ(0, _test_ioctl_set_temp_memory_limit(self->fd, limit))

tools/testing/selftests/kvm/dirty_log_test.c

301

uint32_t limit;

tools/testing/selftests/kvm/dirty_log_test.c

313

limit = 1 << (31 - __builtin_clz(pages));

tools/testing/selftests/kvm/dirty_log_test.c

315

test_dirty_ring_count = min(limit, test_dirty_ring_count);

tools/testing/selftests/kvm/include/x86/svm.h

184

u32 limit;

tools/testing/selftests/kvm/lib/guest_modes.c

22

unsigned int limit = kvm_check_cap(KVM_CAP_ARM_VM_IPA_SIZE);

tools/testing/selftests/kvm/lib/guest_modes.c

26

aarch64_get_supported_page_sizes(limit, &ipa4k, &ipa16k, &ipa64k);

tools/testing/selftests/kvm/lib/x86/processor.c

108

indent, "", dtable->base, dtable->limit,

tools/testing/selftests/kvm/lib/x86/processor.c

575

desc->limit0 = segp->limit & 0xFFFF;

tools/testing/selftests/kvm/lib/x86/processor.c

582

desc->limit1 = segp->limit >> 16;

tools/testing/selftests/kvm/lib/x86/processor.c

596

segp->limit = 0xFFFFFFFFu;

tools/testing/selftests/kvm/lib/x86/processor.c

610

segp->limit = 0xFFFFFFFFu;

tools/testing/selftests/kvm/lib/x86/processor.c

638

segp->limit = 0x67;

tools/testing/selftests/kvm/lib/x86/processor.c

655

sregs.idt.limit = NUM_INTERRUPTS * sizeof(struct idt_entry) - 1;

tools/testing/selftests/kvm/lib/x86/processor.c

657

sregs.gdt.limit = getpagesize() - 1;

tools/testing/selftests/kvm/lib/x86/processor.c

91

indent, "", segment->base, segment->limit,

tools/testing/selftests/kvm/lib/x86/svm.c

57

u64 base, u32 limit, u32 attr)

tools/testing/selftests/kvm/lib/x86/svm.c

61

seg->limit = limit;

tools/testing/selftests/kvm/s390/ucontrol_test.c

203

u64 limit;

tools/testing/selftests/kvm/s390/ucontrol_test.c

207

.addr = (u64)&limit,

tools/testing/selftests/kvm/s390/ucontrol_test.c

216

EXPECT_EQ(~0UL, limit);

tools/testing/selftests/kvm/x86/nested_emulation_test.c

61

vmcb->save.idtr.limit = 0;

tools/testing/selftests/kvm/x86/nested_exceptions_test.c

97

svm->vmcb->save.idtr.limit = 0;

tools/testing/selftests/net/tls.c

2901

__u16 limit = 128;

tools/testing/selftests/net/tls.c

2918

ret = setsockopt(cfd, SOL_TLS, TLS_TX_MAX_PAYLOAD_LEN, &limit,

tools/testing/selftests/net/tls.c

2919

sizeof(limit));

tools/testing/selftests/net/tls.c

2924

EXPECT_EQ(limit, opt);

tools/testing/selftests/net/tls.c

2925

EXPECT_EQ(optlen, sizeof(limit));

tools/testing/selftests/net/tls.c

2939

limit);

tools/testing/selftests/net/tls.c

2952

__u16 og_limit = 512, limit = 128;

tools/testing/selftests/net/tls.c

2978

ret = setsockopt(cfd, SOL_TLS, TLS_TX_MAX_PAYLOAD_LEN, &limit,

tools/testing/selftests/net/tls.c

2979

sizeof(limit));

tools/testing/selftests/rlimits/rlimits-per-userns.c

33

struct rlimit limit = {

tools/testing/selftests/rlimits/rlimits-per-userns.c

40

if (setrlimit(RLIMIT_NPROC, &limit) < 0)

tools/testing/selftests/x86/entry_from_vm86.c

171

unsigned short limit;

tools/testing/selftests/x86/entry_from_vm86.c

176

struct table_desc gdt1 = { .base = 0x3c3c3c3c, .limit = 0x9999 };

tools/testing/selftests/x86/entry_from_vm86.c

177

struct table_desc gdt2 = { .base = 0x1a1a1a1a, .limit = 0xaeae };

tools/testing/selftests/x86/entry_from_vm86.c

178

struct table_desc idt1 = { .base = 0x7b7b7b7b, .limit = 0xf1f1 };

tools/testing/selftests/x86/entry_from_vm86.c

179

struct table_desc idt2 = { .base = 0x89898989, .limit = 0x1313 };

tools/testing/selftests/x86/entry_from_vm86.c

200

idt1.limit, idt1.base);

tools/testing/selftests/x86/entry_from_vm86.c

202

gdt1.limit, gdt1.base);

tools/testing/selftests/x86/fsgsbase.c

236

.limit = 0xfffff,

tools/testing/selftests/x86/fsgsbase_restore.c

64

.limit = sizeof(unsigned int) - 1,

tools/testing/selftests/x86/ldt_gdt.c

104

: [limit] "=r" (limit), [has_limit] "+rm" (has_limit)

tools/testing/selftests/x86/ldt_gdt.c

131

} else if (limit != expected_limit) {

tools/testing/selftests/x86/ldt_gdt.c

133

(ldt ? "LDT" : "GDT"), index, limit, expected_limit);

tools/testing/selftests/x86/ldt_gdt.c

137

(ldt ? "LDT" : "GDT"), index, ar, limit);

tools/testing/selftests/x86/ldt_gdt.c

171

uint32_t limit = desc.limit;

tools/testing/selftests/x86/ldt_gdt.c

173

limit = (limit << 12) + 4095;

tools/testing/selftests/x86/ldt_gdt.c

174

check_valid_segment(desc.entry_number, ldt, ar, limit, true);

tools/testing/selftests/x86/ldt_gdt.c

251

.limit = 10,

tools/testing/selftests/x86/ldt_gdt.c

339

AR_S | AR_DB | AR_AVL, desc.limit,

tools/testing/selftests/x86/ldt_gdt.c

361

desc.limit = i;

tools/testing/selftests/x86/ldt_gdt.c

397

desc.limit = 1;

tools/testing/selftests/x86/ldt_gdt.c

400

desc.limit = 0;

tools/testing/selftests/x86/ldt_gdt.c

410

desc.limit = 0xfffff;

tools/testing/selftests/x86/ldt_gdt.c

425

desc.limit = 0;

tools/testing/selftests/x86/ldt_gdt.c

565

.limit = 0xfffff,

tools/testing/selftests/x86/ldt_gdt.c

634

.limit = 42,

tools/testing/selftests/x86/ldt_gdt.c

67

uint32_t has_limit = 0, has_ar = 0, limit, ar;

tools/testing/selftests/x86/ldt_gdt.c

696

low_user_desc->limit = 0xfffff;

tools/testing/selftests/x86/ldt_gdt.c

74

: [limit] "=r" (limit), [has_limit] "+rm" (has_limit)

tools/testing/selftests/x86/ldt_gdt.c

97

uint32_t has_limit = 0, has_ar = 0, limit, ar;

tools/testing/selftests/x86/sigreturn.c

166

.limit = 4095,

tools/testing/selftests/x86/sigreturn.c

179

.limit = 0xffff,

tools/testing/selftests/x86/sigreturn.c

192

.limit = 4095,

tools/testing/selftests/x86/sigreturn.c

205

.limit = 0xffff,

tools/testing/selftests/x86/sigreturn.c

218

.limit = 0xffff,

tools/testing/selftests/x86/sigreturn.c

243

.limit = 0xffff,

tools/testing/vma/include/dup.h

12

extern unsigned long rlimit(unsigned int limit);

tools/testing/vma/shared.c

119

unsigned long rlimit(unsigned int limit)

tools/tracing/latency/latency-collector.c

542

struct timespec limit;

tools/tracing/latency/latency-collector.c

544

get_time_in_future(&limit, time_us);

tools/tracing/latency/latency-collector.c

549

} while (errno && !time_has_passed(&limit));