arch/arc/mm/cache.c

213

num_lines = DIV_ROUND_UP(sz, L1_CACHE_BYTES);

arch/arc/mm/cache.c

272

num_lines = DIV_ROUND_UP(sz, L1_CACHE_BYTES);

arch/arc/mm/cache.c

643

num_lines = DIV_ROUND_UP(sz, l2_line_sz);

arch/arm/crypto/aes-ce-glue.c

269

int cbc_blocks = DIV_ROUND_UP(req->cryptlen, AES_BLOCK_SIZE) - 2;

arch/arm/crypto/aes-ce-glue.c

327

int cbc_blocks = DIV_ROUND_UP(req->cryptlen, AES_BLOCK_SIZE) - 2;

arch/arm/crypto/aes-ce-glue.c

436

int xts_blocks = DIV_ROUND_UP(req->cryptlen,

arch/arm/crypto/aes-ce-glue.c

508

int xts_blocks = DIV_ROUND_UP(req->cryptlen,

arch/arm/include/asm/kprobes.h

66

#define MAX_COPIED_INSN DIV_ROUND_UP(RELATIVEJUMP_SIZE, sizeof(kprobe_opcode_t))

arch/arm/mach-omap2/omap_twl.c

122

return DIV_ROUND_UP(uv - 709000, 12660) + 1;

arch/arm/mach-omap2/omap_twl.c

124

return DIV_ROUND_UP(uv - 607700, 12660) + 1;

arch/arm/mach-omap2/omap_twl.c

51

return DIV_ROUND_UP(uv - 600000, 12500);

arch/arm/mach-omap2/pmic-cpcap.c

111

return DIV_ROUND_UP(uv - 770000, 10000);

arch/arm/mach-omap2/pmic-cpcap.c

179

vsel = DIV_ROUND_UP(uv - 750000, 12500);

arch/arm/mach-omap2/pmic-cpcap.c

198

vsel = DIV_ROUND_UP(uv - 750000, 12500);

arch/arm/mach-omap2/pmic-cpcap.c

47

return DIV_ROUND_UP(uv - 600000, 12500);

arch/arm/mach-omap2/vc.c

675

capacitance = DIV_ROUND_UP(sr_i2c_pcb_length, 8);

arch/arm/mach-omap2/vp.c

67

waittime = DIV_ROUND_UP(voltdm->pmic->step_size * sys_clk_rate,

arch/arm/mach-pxa/am200epd.c

247

am200_fb_info.modes->yres = DIV_ROUND_UP(totalsize, fw);

arch/arm/mach-pxa/irq.c

185

for (i = 0; i < DIV_ROUND_UP(pxa_internal_irq_nr, 32); i++) {

arch/arm/mach-pxa/irq.c

204

for (i = 0; i < DIV_ROUND_UP(pxa_internal_irq_nr, 32); i++) {

arch/arm64/crypto/aes-glue.c

276

int cbc_blocks = DIV_ROUND_UP(req->cryptlen, AES_BLOCK_SIZE) - 2;

arch/arm64/crypto/aes-glue.c

332

int cbc_blocks = DIV_ROUND_UP(req->cryptlen, AES_BLOCK_SIZE) - 2;

arch/arm64/crypto/aes-glue.c

532

int xts_blocks = DIV_ROUND_UP(req->cryptlen,

arch/arm64/crypto/aes-glue.c

601

int xts_blocks = DIV_ROUND_UP(req->cryptlen,

arch/arm64/crypto/aes-neonbs-glue.c

305

int xts_blocks = DIV_ROUND_UP(req->cryptlen,

arch/arm64/crypto/sm4-ce-glue.c

222

cbc_blocks = DIV_ROUND_UP(req->cryptlen, SM4_BLOCK_SIZE) - 2;

arch/arm64/crypto/sm4-ce-glue.c

331

int nblocks = DIV_ROUND_UP(req->cryptlen, SM4_BLOCK_SIZE) - 2;

arch/arm64/include/asm/fixmap.h

46

FIX_FDT = FIX_FDT_END + DIV_ROUND_UP(MAX_FDT_SIZE, PAGE_SIZE) + 1,

arch/arm64/include/asm/kvm_pkvm.h

115

nr_pages = DIV_ROUND_UP(nr_pages, PTRS_PER_PTE);

arch/arm64/include/asm/kvm_pkvm.h

185

return (2 * KVM_FFA_MBOX_NR_PAGES) + DIV_ROUND_UP(desc_max, PAGE_SIZE);

arch/arm64/kernel/module-plts.c

243

ret += DIV_ROUND_UP(ret, (SZ_4K / sizeof(struct plt_entry)));

arch/arm64/kernel/ptrace.c

1681

.n = DIV_ROUND_UP(SVE_PT_SIZE(ARCH_SVE_VQ_MAX,

arch/arm64/kernel/ptrace.c

1693

.n = DIV_ROUND_UP(SVE_PT_SIZE(SME_VQ_MAX, SVE_PT_REGS_SVE),

arch/arm64/kernel/ptrace.c

1710

.n = DIV_ROUND_UP(ZA_PT_SIZE(SME_VQ_MAX), SVE_VQ_BYTES),

arch/arm64/kvm/mmu.c

101

n += DIV_ROUND_UP(range, PUD_SIZE);

arch/arm64/kvm/mmu.c

102

n += DIV_ROUND_UP(range, PMD_SIZE);

arch/arm64/kvm/trng.c

36

for (i = 0; i < DIV_ROUND_UP(num_bits, BITS_PER_LONG); i++)

arch/arm64/mm/init.c

347

DIV_ROUND_UP(memblock_phys_mem_size(), 1024);

arch/arm64/mm/mmu.c

1340

for (i = 0; i < DIV_ROUND_UP(entry_tramp_text_size(), PAGE_SIZE); i++)

arch/loongarch/include/asm/bootinfo.h

27

#define NR_WORDS DIV_ROUND_UP(NR_CPUS, BITS_PER_LONG)

arch/loongarch/lib/dump_tlb.c

38

int asidwidth = DIV_ROUND_UP(ilog2(asidmask) + 1, 4);

arch/m68k/include/asm/delay.h

118

__delay(DIV_ROUND_UP(nsec *

arch/mips/lib/dump_tlb.c

73

int asidwidth = DIV_ROUND_UP(ilog2(asidmask) + 1, 4);

arch/nios2/kernel/time.c

186

period = DIV_ROUND_UP(timer->freq, HZ);

arch/powerpc/kernel/prom_init.c

1419

cores = DIV_ROUND_UP(NR_CPUS, prom_count_smt_threads());

arch/powerpc/kernel/smp.c

1167

int idx = DIV_ROUND_UP(num_possible_cpus(), threads_per_core);

arch/powerpc/kvm/e500_mmu.c

773

num_pages = DIV_ROUND_UP(cfg->array + array_len - 1, PAGE_SIZE) -

arch/powerpc/perf/imc-pmu.c

1570

int i, nr_cores = DIV_ROUND_UP(num_possible_cpus(), threads_per_core);

arch/powerpc/perf/imc-pmu.c

1714

nr_cores = DIV_ROUND_UP(num_possible_cpus(), threads_per_core);

arch/powerpc/perf/imc-pmu.c

1752

nr_cores = DIV_ROUND_UP(num_possible_cpus(), threads_per_core);

arch/powerpc/platforms/powernv/opal-core.c

102

buf += DIV_ROUND_UP(sizeof(*note), sizeof(Elf64_Word));

arch/powerpc/platforms/powernv/opal-core.c

104

buf += DIV_ROUND_UP(namesz, sizeof(Elf64_Word));

arch/powerpc/platforms/powernv/opal-core.c

106

buf += DIV_ROUND_UP(data_len, sizeof(Elf64_Word));

arch/riscv/crypto/aes-riscv64-glue.c

252

nblocks = DIV_ROUND_UP(nbytes, AES_BLOCK_SIZE);

arch/riscv/kvm/aia_aplic.c

591

aplic->nr_words = DIV_ROUND_UP(aplic->nr_irqs, 32);

arch/riscv/mm/init.c

184

DIV_ROUND_UP(memblock_phys_mem_size(), 1024);

arch/riscv/mm/tlbflush.c

43

unsigned long nr_ptes_in_range = DIV_ROUND_UP(size, stride);

arch/s390/boot/startup.c

377

slots = DIV_ROUND_UP(kaslr_len - kernel_size, THREAD_SIZE);

arch/s390/include/asm/ftrace.lds.h

2

#ifndef DIV_ROUND_UP

arch/s390/include/asm/ftrace.lds.h

9

DIV_ROUND_UP(SIZEOF_FTRACE_HOTPATCH_TRAMPOLINE * (n), \

arch/s390/kernel/module.c

478

numpages = DIV_ROUND_UP(size, PAGE_SIZE);

arch/s390/kernel/perf_cpum_sf.c

1240

OVERFLOW_REG(hwc) = DIV_ROUND_UP(OVERFLOW_REG(hwc) +

arch/s390/kernel/perf_cpum_sf.c

1252

SAMPL_RATE(hwc) += DIV_ROUND_UP(SAMPL_RATE(hwc), 10);

arch/s390/kernel/perf_cpum_sf.c

1622

n_sdbt = DIV_ROUND_UP(nr_pages, CPUM_SF_SDB_PER_TABLE);

arch/s390/kernel/perf_cpum_sf.c

358

CPUM_SF_SDB_DIAG_FACTOR = DIV_ROUND_UP(si.dsdes, si.bsdes);

arch/s390/kernel/perf_cpum_sf.c

431

n_sdb = CPUM_SF_MIN_SDB + DIV_ROUND_UP(freq, 10000);

arch/s390/kernel/perf_cpum_sf.c

452

return min_t(unsigned long, min, DIV_ROUND_UP(percent * base, 100));

arch/s390/kernel/perf_cpum_sf.c

493

ratio = DIV_ROUND_UP(100 * OVERFLOW_REG(hwc) * cpuhw->sfb.num_sdb,

arch/sparc/kernel/traps_64.c

2165

unsigned long page_cnt = DIV_ROUND_UP(ent->err_size,

arch/sparc/mm/init_64.c

2389

num_kernel_image_mappings = DIV_ROUND_UP(real_end - KERNBASE, 1 << ILOG2_4MB);

arch/um/drivers/ubd_kern.c

1157

if (*cow_offset == (DIV_ROUND_UP(bitmap_len,

arch/x86/boot/startup/map_kernel.c

179

for (i = 0; i < DIV_ROUND_UP(va_end - va_text, PMD_SIZE); i++) {

arch/x86/boot/startup/sme.c

267

entries += (DIV_ROUND_UP(len, PGDIR_SIZE) + 1) * sizeof(p4d_t) * PTRS_PER_P4D;

arch/x86/boot/startup/sme.c

268

entries += (DIV_ROUND_UP(len, P4D_SIZE) + 1) * sizeof(pud_t) * PTRS_PER_PUD;

arch/x86/boot/startup/sme.c

269

entries += (DIV_ROUND_UP(len, PUD_SIZE) + 1) * sizeof(pmd_t) * PTRS_PER_PMD;

arch/x86/boot/startup/sme.c

278

tables += DIV_ROUND_UP(entries, PGDIR_SIZE) * sizeof(p4d_t) * PTRS_PER_P4D;

arch/x86/boot/startup/sme.c

279

tables += DIV_ROUND_UP(entries, P4D_SIZE) * sizeof(pud_t) * PTRS_PER_PUD;

arch/x86/boot/startup/sme.c

280

tables += DIV_ROUND_UP(entries, PUD_SIZE) * sizeof(pmd_t) * PTRS_PER_PMD;

arch/x86/crypto/aesni-intel_glue.c

213

int cbc_blocks = DIV_ROUND_UP(req->cryptlen, AES_BLOCK_SIZE) - 2;

arch/x86/crypto/aesni-intel_glue.c

269

int cbc_blocks = DIV_ROUND_UP(req->cryptlen, AES_BLOCK_SIZE) - 2;

arch/x86/crypto/aesni-intel_glue.c

627

nblocks = DIV_ROUND_UP(nbytes, AES_BLOCK_SIZE);

arch/x86/crypto/aesni-intel_glue.c

688

ctr += DIV_ROUND_UP(nbytes, AES_BLOCK_SIZE);

arch/x86/include/asm/pgtable_32_areas.h

27

#define CPU_ENTRY_AREA_PAGES (NR_CPUS * DIV_ROUND_UP(sizeof(struct cpu_entry_area), PAGE_SIZE))

arch/x86/kernel/cpu/topology.c

501

__num_nodes_per_package = DIV_ROUND_UP(cntb, cnta);

arch/x86/kernel/cpu/topology.c

518

__max_threads_per_core = DIV_ROUND_UP(cntb, cnta);

arch/x86/kernel/espfix_64.c

62

#define ESPFIX_MAX_PAGES DIV_ROUND_UP(CONFIG_NR_CPUS, ESPFIX_STACKS_PER_PAGE)

arch/x86/kernel/ftrace.c

354

npages = DIV_ROUND_UP(*tramp_size, PAGE_SIZE);

arch/x86/kernel/ftrace.c

449

npages = DIV_ROUND_UP(size, PAGE_SIZE);

arch/x86/kernel/kvm.c

994

nr_pages = DIV_ROUND_UP(entry->size, PAGE_SIZE);

arch/x86/kernel/ldt.c

309

nr_pages = DIV_ROUND_UP(ldt->nr_entries * LDT_ENTRY_SIZE, PAGE_SIZE);

arch/x86/kernel/ldt.c

361

nr_pages = DIV_ROUND_UP(ldt->nr_entries * LDT_ENTRY_SIZE, PAGE_SIZE);

arch/x86/kernel/ptrace.c

698

return iobm ? DIV_ROUND_UP(iobm->max, regset->size) : 0;

arch/x86/kvm/hyperv.c

45

#define KVM_HV_MAX_SPARSE_VCPU_SET_BITS DIV_ROUND_UP(KVM_MAX_VCPUS, HV_VCPUS_PER_SPARSE_BANK)

arch/x86/kvm/mmu/mmu.c

7700

return ratio ? DIV_ROUND_UP(pages, ratio) : 0;

arch/x86/mm/kaslr.c

113

memory_tb = DIV_ROUND_UP(max_pfn << PAGE_SHIFT, 1UL << TB_SHIFT) +

arch/x86/mm/kaslr.c

132

kaslr_regions[2].size_tb = DIV_ROUND_UP(vmemmap_size, 1UL << TB_SHIFT);

block/blk-iocost.c

1985

gamma = DIV_ROUND_UP(

block/blk-iocost.c

2511

adj_step = DIV_ROUND_UP(iocg->active * INUSE_ADJ_STEP_PCT, 100);

block/blk-map.c

173

nr_pages = bio_max_segs(DIV_ROUND_UP(offset + len, PAGE_SIZE));

block/kyber-iosched.c

244

percentile_samples = DIV_ROUND_UP(samples * percentile, 100);

block/sed-opal.c

759

len = DIV_ROUND_UP(msb, 8);

crypto/algif_hash.c

75

DIV_ROUND_UP(sk->sk_sndbuf, PAGE_SIZE));

crypto/ecdsa.c

143

ndigits = DIV_ROUND_UP(digitlen, sizeof(u64));

crypto/tcrypt.c

1161

unsigned int pages = DIV_ROUND_UP(k, PAGE_SIZE);

crypto/tcrypt.c

1372

sg_init_table(sg, DIV_ROUND_UP(k, PAGE_SIZE));

drivers/accel/ivpu/ivpu_pm.c

211

inference_max_retries = DIV_ROUND_UP(inference_timeout_ms, timeout_ms);

drivers/accel/qaic/qaic_control.c

421

need_pages = DIV_ROUND_UP(total, PAGE_SIZE);

drivers/accel/qaic/qaic_data.c

458

nr_pages = DIV_ROUND_UP(size, PAGE_SIZE);

drivers/accel/qaic/sahara.c

42

#define SAHARA_NUM_TX_BUF DIV_ROUND_UP(SAHARA_TRANSFER_MAX_SIZE,\

drivers/acpi/numa/hmat.c

326

value = DIV_ROUND_UP(value, 10);

drivers/acpi/numa/hmat.c

332

value = DIV_ROUND_UP(value, 1000);

drivers/acpi/x86/cmos_rtc.c

43

for (i = 0; i < DIV_ROUND_UP(bits, 8); ++i, ++address, ++value)

drivers/ata/libata-eh.c

3194

rc, DIV_ROUND_UP(jiffies_to_msecs(delta), 1000));

drivers/ata/pata_octeon_cf.c

81

return DIV_ROUND_UP(nsecs * (octeon_get_io_clock_rate() / 1000000),

drivers/atm/eni.c

1276

*res = DIV_ROUND_UP(TS_CLOCK, div)-1;

drivers/block/drbd/drbd_receiver.c

4594

header_size * (DIV_ROUND_UP(c->bm_words, data_size) + 1) +

drivers/block/floppy.c

1326

srt = 16 - DIV_ROUND_UP(drive_params[drive].srt * scale_dtr / 1000,

drivers/block/floppy.c

1334

hlt = DIV_ROUND_UP(drive_params[drive].hlt * scale_dtr / 2,

drivers/block/floppy.c

1341

hut = DIV_ROUND_UP(drive_params[drive].hut * scale_dtr / 16,

drivers/block/floppy.c

2334

ssize = DIV_ROUND_UP(1 << raw_cmd->cmd[SIZECODE], 4);

drivers/block/floppy.c

2351

DIV_ROUND_UP(in_sector_offset + current_count_sectors, ssize)) {

drivers/block/floppy.c

2608

ssize = DIV_ROUND_UP(1 << raw_cmd->cmd[SIZECODE], 4);

drivers/block/null_blk/zoned.c

245

unsigned int nr_sectors = DIV_ROUND_UP(len, SECTOR_SIZE);

drivers/block/xen-blkback/common.h

68

#define INDIRECT_PAGES(_segs) DIV_ROUND_UP(_segs, XEN_PAGES_PER_INDIRECT_FRAME)

drivers/block/xen-blkfront.c

2183

psegs = DIV_ROUND_UP(grants, GRANTS_PER_PSEG);

drivers/block/xen-blkfront.c

268

DIV_ROUND_UP(_grants, GRANTS_PER_INDIRECT_FRAME)

drivers/bluetooth/btmrvl_sdio.c

1104

blksz = DIV_ROUND_UP(nb, SDIO_BLOCK_SIZE) * SDIO_BLOCK_SIZE;

drivers/bluetooth/btmrvl_sdio.c

672

tx_blocks = DIV_ROUND_UP(txlen, blksz_dl);

drivers/bluetooth/btmrvl_sdio.c

727

num_blocks = DIV_ROUND_UP(buf_len, blksz);

drivers/bluetooth/hci_bcm4377.c

1154

DIV_ROUND_UP(data_size, (size_t)BCM4378_CALIBRATION_CHUNK_SIZE);

drivers/bluetooth/hci_bcm4377.c

1285

size_t chunks = DIV_ROUND_UP(fw->size, (size_t)BCM4378_PTB_CHUNK_SIZE);

drivers/bus/mhi/host/boot.c

373

int segments = DIV_ROUND_UP(alloc_size, seg_size) + 1;

drivers/cdx/controller/mcdi.c

731

cmd->outbuf = outbuf + DIV_ROUND_UP(resp_hdr_len, 4);

drivers/char/hw_random/ks-sa-rng.c

187

DIV_ROUND_UP((u32)(ks_sa_rng->ready_ts - now), 1000);

drivers/char/lp.c

689

to_jiffies = DIV_ROUND_UP(tv_usec, 1000000/HZ);

drivers/char/random.c

1297

stack->samples_per_bit = DIV_ROUND_UP(NUM_TRIAL_SAMPLES, num_different + 1);

drivers/clk/actions/owl-factor.c

102

cur_rate = DIV_ROUND_UP(parent_rate, clkt->div) * clkt->mul;

drivers/clk/at91/clk-pll.c

153

tmpdiv = DIV_ROUND_UP(parent_rate, characteristics->input.max);

drivers/clk/at91/clk-pll.c

165

maxdiv = DIV_ROUND_UP(parent_rate * PLL_MUL_MAX(layout), rate);

drivers/clk/clk-axi-clkgen.c

151

d_min = max(DIV_ROUND_UP(fin, limits->fpfd_max), 1);

drivers/clk/clk-axi-clkgen.c

158

m_min = max(DIV_ROUND_UP(fvco_min_fract, fin) * d_min, 1);

drivers/clk/clk-axi-clkgen.c

162

_d_min = max(d_min, DIV_ROUND_UP(fin * m, fvco_max_fract));

drivers/clk/clk-cdce925.c

397

pdiv_min = (u16)max(1ul, DIV_ROUND_UP(CDCE925_PLL_FREQUENCY_MIN, rate));

drivers/clk/clk-clps711x.c

65

f_pll = DIV_ROUND_UP(CLPS711X_OSC_FREQ * tmp, 2);

drivers/clk/clk-clps711x.c

79

f_bus = DIV_ROUND_UP(f_cpu, 2);

drivers/clk/clk-plldig.c

123

return DIV_ROUND_UP(data->vco_freq, rfdphi1);

drivers/clk/clk-plldig.c

145

req->rate = DIV_ROUND_UP(data->vco_freq, div);

drivers/clk/clk-pwm.c

128

pargs.period != DIV_ROUND_UP(NSEC_PER_SEC, clk_pwm->fixed_rate)) {

drivers/clk/clk-si514.c

194

settings->hs_div = DIV_ROUND_UP(FVCO_MIN >> 1, ls_freq) << 1;

drivers/clk/clk-versaclock3.c

310

idiv = DIV_ROUND_UP(req->best_parent_rate, req->rate);

drivers/clk/clk-versaclock3.c

340

idiv = DIV_ROUND_UP(parent_rate, rate);

drivers/clk/clk-versaclock3.c

521

req->rate = DIV_ROUND_UP(req->best_parent_rate, bestdiv);

drivers/clk/clk-versaclock5.c

382

idiv = DIV_ROUND_UP(req->best_parent_rate, req->rate);

drivers/clk/clk-versaclock5.c

410

idiv = DIV_ROUND_UP(parent_rate, rate);

drivers/clk/clk-versaclock7.c

764

*divider = DIV_ROUND_UP(parent_rate, rate);

drivers/clk/imx/clk-lpcg-scu.c

65

ndelay(4 * (DIV_ROUND_UP(1000 * HZ_PER_MHZ, rate)));

drivers/clk/ingenic/cgu.c

473

div = DIV_ROUND_UP(parent_rate, req_rate);

drivers/clk/ingenic/cgu.c

490

div = DIV_ROUND_UP(div, clk_info->div.div);

drivers/clk/ingenic/cgu.c

511

req->rate = DIV_ROUND_UP(req->best_parent_rate, div);

drivers/clk/ingenic/cgu.c

539

rate = DIV_ROUND_UP(parent_rate, div);

drivers/clk/mxs/clk-ssp.c

30

clock_rate = DIV_ROUND_UP(ssp_clk, rate * clock_divide);

drivers/clk/nxp/clk-lpc32xx.c

973

req->rate = DIV_ROUND_UP(req->best_parent_rate, bestdiv);

drivers/clk/qcom/clk-hfpll.c

143

rrate = DIV_ROUND_UP(req->rate, req->best_parent_rate) * req->best_parent_rate;

drivers/clk/qcom/clk-krait.c

103

req->rate = DIV_ROUND_UP(req->best_parent_rate, 2);

drivers/clk/qcom/clk-krait.c

141

return DIV_ROUND_UP(parent_rate, div);

drivers/clk/qcom/clk-rcg2.c

1002

div = DIV_ROUND_UP((2 * parent_rate), req->rate) - 1;

drivers/clk/qcom/clk-rcg2.c

1018

div = DIV_ROUND_UP((2 * parent_rate), rate) - 1;

drivers/clk/qcom/clk-rcg2.c

1059

div = DIV_ROUND_UP((2 * parent_rate), rate) - 1;

drivers/clk/qcom/clk-rcg2.c

1077

div = DIV_ROUND_UP((2 * parent_rate), rate) - 1;

drivers/clk/qcom/clk-rpm.c

142

u32 value = DIV_ROUND_UP(rate, 1000); /* to kHz */

drivers/clk/qcom/clk-rpm.c

150

u32 value = DIV_ROUND_UP(rate, 1000); /* to kHz */

drivers/clk/qcom/clk-smd-rpm.c

219

.value = cpu_to_le32(DIV_ROUND_UP(rate, 1000)), /* to kHz */

drivers/clk/qcom/clk-smd-rpm.c

233

.value = cpu_to_le32(DIV_ROUND_UP(rate, 1000)), /* to kHz */

drivers/clk/qcom/clk-spmi-pmic-div.c

120

div = DIV_ROUND_UP(req->best_parent_rate, req->rate);

drivers/clk/renesas/clk-div6.c

122

min_div = max(DIV_ROUND_UP(prate, req->max_rate), 1UL);

drivers/clk/renesas/r9a06g032-clocks.c

1001

clk->min, DIV_ROUND_UP(req->best_parent_rate, clk->min),

drivers/clk/renesas/r9a06g032-clocks.c

1002

clk->max, DIV_ROUND_UP(req->best_parent_rate, clk->max));

drivers/clk/renesas/r9a06g032-clocks.c

1020

req->rate = DIV_ROUND_UP(req->best_parent_rate, div);

drivers/clk/renesas/r9a06g032-clocks.c

1032

u32 div = DIV_ROUND_UP(parent_rate, rate + 1);

drivers/clk/renesas/r9a06g032-clocks.c

952

return DIV_ROUND_UP(parent_rate, div);

drivers/clk/renesas/r9a06g032-clocks.c

966

u32 div = DIV_ROUND_UP(prate, rate + 1);

drivers/clk/renesas/r9a06g032-clocks.c

977

DIV_ROUND_UP(prate, clk->table[i]);

drivers/clk/renesas/r9a06g032-clocks.c

979

DIV_ROUND_UP(prate, clk->table[i + 1]) -

drivers/clk/renesas/r9a06g032-clocks.c

996

u32 div = DIV_ROUND_UP(req->best_parent_rate, req->rate);

drivers/clk/rockchip/clk-cpu.c

181

alt_div = DIV_ROUND_UP(alt_prate, ndata->old_rate) - 1;

drivers/clk/samsung/clk-cpu.c

240

alt_div = DIV_ROUND_UP(alt_prate, tmp_rate) - 1;

drivers/clk/samsung/clk-cpu.c

361

alt_div = DIV_ROUND_UP(alt_prate, tmp_rate) - 1;

drivers/clk/samsung/clk-cpu.c

462

div = DIV_ROUND_UP(divp_rate, rate);

drivers/clk/samsung/clk-cpu.c

463

div_rate = DIV_ROUND_UP(divp_rate, div);

drivers/clk/starfive/clk-starfive-jh71x0.c

82

unsigned long div = min_t(unsigned long, DIV_ROUND_UP(parent, rate), clk->max_div);

drivers/clk/sunxi/clk-mod0.c

32

div = DIV_ROUND_UP(req->parent_rate, req->rate);

drivers/clk/sunxi/clk-mod0.c

43

calcm = DIV_ROUND_UP(div, 1 << calcp);

drivers/clk/sunxi/clk-sun6i-ar100.c

34

div = DIV_ROUND_UP(req->parent_rate, req->rate);

drivers/clk/sunxi/clk-sun9i-core.c

106

div = DIV_ROUND_UP(req->parent_rate, req->rate);

drivers/clk/sunxi/clk-sun9i-core.c

161

_p = order_base_2(DIV_ROUND_UP(req->parent_rate, req->rate));

drivers/clk/sunxi/clk-sun9i-core.c

241

div = DIV_ROUND_UP(req->parent_rate, req->rate);

drivers/clk/sunxi/clk-sun9i-core.c

33

n = DIV_ROUND_UP(req->rate, 6000000);

drivers/clk/sunxi/clk-sun9i-cpus.c

81

div = DIV_ROUND_UP(parent_rate, rate);

drivers/clk/sunxi/clk-sun9i-cpus.c

90

pre_div = DIV_ROUND_UP(div, 2);

drivers/clk/sunxi/clk-sun9i-cpus.c

93

pre_div = DIV_ROUND_UP(div, 3);

drivers/clk/sunxi/clk-sun9i-cpus.c

96

pre_div = DIV_ROUND_UP(div, 4);

drivers/clk/sunxi/clk-sun9i-mmc.c

115

count = DIV_ROUND_UP((resource_size(r)), SUN9I_MMC_WIDTH);

drivers/clk/sunxi/clk-sunxi.c

1132

m = DIV_ROUND_UP(req->parent_rate, req->rate);

drivers/clk/sunxi/clk-sunxi.c

218

req->n = DIV_ROUND_UP(div, (req->k + 1));

drivers/clk/sunxi/clk-sunxi.c

240

req->n = DIV_ROUND_UP(div, (req->k + 1)) - 1;

drivers/clk/sunxi/clk-sunxi.c

266

div = order_base_2(DIV_ROUND_UP(req->parent_rate, req->rate));

drivers/clk/sunxi/clk-sunxi.c

299

div = DIV_ROUND_UP(req->parent_rate, req->rate);

drivers/clk/sunxi/clk-sunxi.c

312

calcm = DIV_ROUND_UP(div, 1 << calcp);

drivers/clk/sunxi/clk-sunxi.c

353

div = DIV_ROUND_UP(req->parent_rate, req->rate);

drivers/clk/sunxi/clk-sunxi.c

393

div = DIV_ROUND_UP(req->parent_rate, req->rate);

drivers/clk/sunxi/clk-sunxi.c

404

calcm = DIV_ROUND_UP(div, 1 << calcp);

drivers/clk/tegra/clk-dfll.c

1400

val = DIV_ROUND_UP(td->ref_rate, td->sample_rate * 32);

drivers/clk/tegra/clk-dfll.c

584

div = DIV_ROUND_UP(td->ref_rate, td->pwm_rate);

drivers/clk/tegra/clk-dfll.c

723

val = DIV_ROUND_UP(td->i2c_clk_rate, td->i2c_fs_rate * 8);

drivers/clk/tegra/clk-dfll.c

773

vsel = DIV_ROUND_UP((vinit - vmin), vstep);

drivers/clk/tegra/clk-divider.c

83

req->rate = DIV_ROUND_UP(output_rate * mul, div + mul);

drivers/clk/tegra/clk-pll.c

1236

p = DIV_ROUND_UP(pll->params->vco_min, rate);

drivers/clk/tegra/clk-pll.c

1269

return DIV_ROUND_UP(vco_min, parent_rate) * parent_rate;

drivers/clk/tegra/clk-pll.c

604

cfg->output_rate = cfg->n * DIV_ROUND_UP(parent_rate, cfg->m);

drivers/clk/tegra/clk-sdmmc-mux.c

125

req->rate = DIV_ROUND_UP(output_rate * SDMMC_MUL,

drivers/clk/tegra/clk-tegra20-emc.c

195

divided_rate = DIV_ROUND_UP(parent_rate * 2, div + 2);

drivers/clk/tegra/clk-tegra20-emc.c

63

return DIV_ROUND_UP(parent_rate * 2, div + 2);

drivers/clk/tegra/clk-tegra210-emc.c

86

return DIV_ROUND_UP(parent_rate * 2, div);

drivers/clk/tegra/clk-tegra210.c

1492

p = DIV_ROUND_UP(params->vco_min, rate);

drivers/clk/tegra/clk-tegra210.c

1560

params->vco_min += DIV_ROUND_UP(parent_rate, PLL_SDM_COEFF);

drivers/clk/tegra/cvb.c

34

uv = DIV_ROUND_UP(uv, step) * align->step_uv + align->offset_uv;

drivers/clk/thead/clk-th1520-ap.c

1464

return clamp(DIV_ROUND_UP(parent_rate, TH1520_C910_BUS_MAX_RATE),

drivers/clk/ti/divider.c

110

return DIV_ROUND_UP(parent_rate, div);

drivers/clk/ti/divider.c

163

return DIV_ROUND_UP(parent_rate, rate);

drivers/clk/ti/divider.c

209

now = DIV_ROUND_UP(parent_rate, i);

drivers/clk/ti/divider.c

232

req->rate = DIV_ROUND_UP(req->best_parent_rate, div);

drivers/clk/ti/divider.c

249

div = DIV_ROUND_UP(parent_rate, rate);

drivers/clk/ti/fapll.c

422

synth_post_div_m = DIV_ROUND_UP(frac_rate, req->rate);

drivers/clk/ti/fapll.c

423

r = DIV_ROUND_UP(frac_rate, synth_post_div_m);

drivers/clk/ti/fapll.c

459

post_div_m = DIV_ROUND_UP(frac_rate, rate);

drivers/clk/ti/fapll.c

461

post_rate = DIV_ROUND_UP(frac_rate, post_div_m);

drivers/clk/zynqmp/pll.c

108

div = DIV_ROUND_UP(req->rate, PS_PLL_VCO_MAX);

drivers/clk/zynqmp/pll.c

112

mult = DIV_ROUND_UP(PS_PLL_VCO_MIN, req->rate);

drivers/clocksource/dw_apb_timer.c

151

unsigned long period = DIV_ROUND_UP(dw_ced->timer.freq, HZ);

drivers/clocksource/sh_cmt.c

1077

cmt->reg_delay = DIV_ROUND_UP(2UL * USEC_PER_SEC, rate);

drivers/clocksource/sh_cmt.c

287

unsigned int cmcnt_delay = DIV_ROUND_UP(3 * ch->cmt->reg_delay, 2);

drivers/clocksource/timer-digicolor.c

178

dc_timer_dev.ticks_per_jiffy = DIV_ROUND_UP(rate, HZ);

drivers/clocksource/timer-econet-en751221.c

173

int num_blocks = DIV_ROUND_UP(num_possible_cpus(), 2);

drivers/clocksource/timer-econet-en751221.c

23

#define ECONET_NUM_BLOCKS DIV_ROUND_UP(NR_CPUS, 2)

drivers/clocksource/timer-keystone.c

192

timer.hz_period = DIV_ROUND_UP(rate, HZ);

drivers/clocksource/timer-msc313e.c

186

to->of_clk.period = DIV_ROUND_UP(to->of_clk.rate, HZ);

drivers/clocksource/timer-of.c

128

of_clk->period = DIV_ROUND_UP(of_clk->rate, HZ);

drivers/clocksource/timer-stm32-lp.c

176

priv->period = DIV_ROUND_UP(*rate, HZ);

drivers/clocksource/timer-stm32.c

228

to->of_clk.period = DIV_ROUND_UP(to->of_clk.rate, HZ);

drivers/clocksource/timer-sun5i.c

162

cs->ticks_per_jiffy = DIV_ROUND_UP(ndata->new_rate, HZ);

drivers/clocksource/timer-sun5i.c

277

st->ticks_per_jiffy = DIV_ROUND_UP(rate, HZ);

drivers/comedi/drivers.c

434

num_samples = DIV_ROUND_UP(cmd->scan_end_arg, bits_per_sample);

drivers/comedi/drivers/addi_apci_3120.c

280

divisor = DIV_ROUND_UP(ns, timer_base);

drivers/comedi/drivers/addi_apci_3xxx.c

495

timer = DIV_ROUND_UP(*ns, base);

drivers/comedi/drivers/adv_pci1760.c

185

divisor = DIV_ROUND_UP(ns, PCI1760_PWM_TIMEBASE);

drivers/comedi/drivers/amplc_pci230.c

647

div += DIV_ROUND_UP(rem, timebase);

drivers/comedi/drivers/cb_pcidas64.c

1987

divisor = DIV_ROUND_UP(ns, TIMER_BASE);

drivers/comedi/drivers/comedi_8254.c

492

divisor = DIV_ROUND_UP(*nanosec, i8254->osc_base);

drivers/comedi/drivers/das1800.c

589

arg = DIV_ROUND_UP(arg, 1000);

drivers/comedi/drivers/dt282x.c

381

divider = DIV_ROUND_UP(*ns, base);

drivers/comedi/drivers/dt3000.c

360

divider = DIV_ROUND_UP(*nanosec, base);

drivers/comedi/drivers/ni_labpc_common.c

375

pacer->next_div = DIV_ROUND_UP(convert_period,

drivers/comedi/drivers/ni_labpc_common.c

377

pacer->next_div2 = DIV_ROUND_UP(scan_period,

drivers/comedi/drivers/ni_mio_common.c

1956

divider = DIV_ROUND_UP(nanosec, devpriv->clock_ns);

drivers/comedi/drivers/ni_mio_common.c

4213

DIV_ROUND_UP(data[2], devpriv->clock_ns);

drivers/comedi/drivers/ni_mio_common.c

4228

DIV_ROUND_UP(data[4], devpriv->clock_ns);

drivers/comedi/drivers/ni_mio_common.c

4273

DIV_ROUND_UP(data[2], devpriv->clock_ns);

drivers/comedi/drivers/ni_mio_common.c

4288

DIV_ROUND_UP(data[4], devpriv->clock_ns);

drivers/comedi/drivers/ni_pcidio.c

519

divider = DIV_ROUND_UP(*nanosec, base);

drivers/comedi/drivers/ni_tio.c

1794

counter_dev->num_chips = DIV_ROUND_UP(num_counters, counters_per_chip);

drivers/comedi/drivers/rtd520.c

387

divider = DIV_ROUND_UP(*nanosec, base);

drivers/comedi/drivers/rtd520.c

884

DIV_ROUND_UP(devpriv->xfer_count,

drivers/comedi/drivers/s626.c

1641

divider = DIV_ROUND_UP(*nanosec, base);

drivers/cpufreq/amd-pstate.c

739

des_perf = DIV_ROUND_UP(cap_perf * target_perf, capacity);

drivers/cpufreq/amd-pstate.c

742

min_perf = DIV_ROUND_UP(cap_perf * _min_perf, capacity);

drivers/cpufreq/intel_pstate.c

1667

freq = DIV_ROUND_UP(freq * global.min_perf_pct, 100);

drivers/cpufreq/intel_pstate.c

2863

global_max = DIV_ROUND_UP(turbo_max * global.max_perf_pct, 100);

drivers/cpufreq/intel_pstate.c

2864

global_min = DIV_ROUND_UP(turbo_max * global.min_perf_pct, 100);

drivers/cpufreq/intel_pstate.c

3260

target_pstate = DIV_ROUND_UP(cap_pstate * target_perf, capacity);

drivers/cpufreq/intel_pstate.c

3264

min_pstate = DIV_ROUND_UP(cap_pstate * min_perf, capacity);

drivers/cpufreq/intel_pstate.c

3329

freq = DIV_ROUND_UP(cpu->pstate.turbo_freq * global.min_perf_pct, 100);

drivers/cpufreq/intel_pstate.c

3338

freq = DIV_ROUND_UP(cpu->pstate.turbo_freq * global.max_perf_pct, 100);

drivers/cpufreq/intel_pstate.c

551

return DIV_ROUND_UP(freq, cpu->pstate.scaling);

drivers/cpufreq/mediatek-cpufreq-hw.c

130

target_freq = DIV_ROUND_UP(target_freq, FDVFS_FDIV_HZ);

drivers/cpufreq/mediatek-cpufreq.c

521

info->vtrack_max = 3 * DIV_ROUND_UP(max(info->soc_data->sram_max_volt,

drivers/cpufreq/tegra194-cpufreq.c

650

DIV_ROUND_UP(CPUFREQ_TBL_STEP_HZ, resp.ref_clk_hz);

drivers/cpuidle/cpuidle-powernv.c

307

exit_latency = DIV_ROUND_UP(state->latency_ns, 1000);

drivers/cpuidle/cpuidle-powernv.c

308

target_residency = DIV_ROUND_UP(state->residency_ns, 1000);

drivers/crypto/allwinner/sun8i-ce/sun8i-ce.h

100

#define PRNG_SEED_SIZE DIV_ROUND_UP(175, 8)

drivers/crypto/allwinner/sun8i-ss/sun8i-ss.h

83

#define PRNG_SEED_SIZE DIV_ROUND_UP(175, 8)

drivers/crypto/aspeed/aspeed-acry.c

273

ndw = DIV_ROUND_UP(nbytes, BYTES_PER_DWORD);

drivers/crypto/atmel-aes.c

987

ctx->blocks = DIV_ROUND_UP(datalen, AES_BLOCK_SIZE);

drivers/crypto/atmel-i2c.c

313

u32 no_of_bits = DIV_ROUND_UP(TWLO_USEC * bus_clk_rate, USEC_PER_SEC);

drivers/crypto/atmel-i2c.c

316

return DIV_ROUND_UP(no_of_bits, 8);

drivers/crypto/atmel-sha.c

1511

num_words = DIV_ROUND_UP(ctx->bufcnt, sizeof(u32));

drivers/crypto/atmel-sha.c

581

len32 = DIV_ROUND_UP(length, sizeof(u32));

drivers/crypto/atmel-sha.c

600

len32 = DIV_ROUND_UP(length1, sizeof(u32));

drivers/crypto/atmel-sha.c

605

len32 = DIV_ROUND_UP(length2, sizeof(u32));

drivers/crypto/atmel-tdes.c

378

len32 = DIV_ROUND_UP(length, sizeof(u32));

drivers/crypto/chelsio/chcr_algo.c

1109

ctr_add_iv(iv, req->iv, DIV_ROUND_UP(reqctx->processed,

drivers/crypto/chelsio/chcr_algo.c

154

nents += DIV_ROUND_UP(less, entlen);

drivers/crypto/chelsio/chcr_algo.c

752

htonl(FW_CRYPTO_LOOKASIDE_WR_LEN16_V(DIV_ROUND_UP(len16, 16)));

drivers/crypto/chelsio/chcr_algo.c

758

chcr_req->ulptx.len = htonl((DIV_ROUND_UP(len16, 16) -

drivers/crypto/chelsio/chcr_algo.h

222

htonl(FW_CRYPTO_LOOKASIDE_WR_LEN16_V(DIV_ROUND_UP((\

drivers/crypto/hifn_795x.c

1968

if (dev->started + DIV_ROUND_UP(req->cryptlen, PAGE_SIZE) <= HIFN_QUEUE_LENGTH)

drivers/crypto/img-hash.c

202

len32 = DIV_ROUND_UP(length, sizeof(u32));

drivers/crypto/inside-secure/eip93/eip93-common.c

550

blocks = DIV_ROUND_UP(rctx->textsize, AES_BLOCK_SIZE);

drivers/crypto/intel/qat/qat_common/qat_algs.c

618

iv_lo += DIV_ROUND_UP(sreq->cryptlen, AES_BLOCK_SIZE);

drivers/crypto/nx/nx-842.c

280

DIV_ROUND_UP(p.iremain, c.maximum));

drivers/crypto/omap-sham.c

526

len32 = DIV_ROUND_UP(length, sizeof(u32));

drivers/crypto/omap-sham.c

739

bufcnt = DIV_ROUND_UP(bufcnt, bs) * bs;

drivers/crypto/omap-sham.c

755

new_len = DIV_ROUND_UP(new_len, bs) * bs;

drivers/crypto/qce/common.c

417

return DIV_ROUND_UP(len, sizeof(u32));

drivers/crypto/sa2ul.h

205

unsigned long ctx_bm[DIV_ROUND_UP(SA_MAX_NUM_CTX,

drivers/crypto/stm32/stm32-hash.c

1150

bufcnt = DIV_ROUND_UP(bufcnt, bs) * bs;

drivers/crypto/stm32/stm32-hash.c

1166

new_len = DIV_ROUND_UP(new_len, bs) * bs;

drivers/crypto/stm32/stm32-hash.c

407

len32 = DIV_ROUND_UP(length, sizeof(u32));

drivers/crypto/stm32/stm32-hash.c

762

memset(buffer + ncp, 0, 4 - DIV_ROUND_UP(ncp, sizeof(u32)));

drivers/crypto/stm32/stm32-hash.c

764

DIV_ROUND_UP(ncp, sizeof(u32)));

drivers/cxl/core/cdat.c

44

value = DIV_ROUND_UP(value, 1000);

drivers/devfreq/devfreq.c

1645

value = DIV_ROUND_UP(value, HZ_PER_KHZ);

drivers/devfreq/mtk-cci-devfreq.c

314

drv->vtrack_max = 3 * DIV_ROUND_UP(max(drv->soc_data->sram_max_volt,

drivers/devfreq/rk3399_dmc.c

124

DIV_ROUND_UP(NS_TO_CYCLE(dmcfreq->sr_idle_ns,

drivers/devfreq/rk3399_dmc.c

128

DIV_ROUND_UP(NS_TO_CYCLE(dmcfreq->sr_mc_gate_idle_ns,

drivers/devfreq/rk3399_dmc.c

132

DIV_ROUND_UP(NS_TO_CYCLE(dmcfreq->srpd_lite_idle_ns,

drivers/devfreq/sun8i-a33-mbus.c

168

tRFC_ck = DIV_ROUND_UP(priv->tRFC_ns * mctl_freq_mhz, 1000);

drivers/dma-buf/dma-buf-mapping.c

15

nents = DIV_ROUND_UP(length, UINT_MAX);

drivers/dma-buf/dma-buf-mapping.c

44

nents += DIV_ROUND_UP(phys_vec[i].len, UINT_MAX);

drivers/dma-buf/dma-buf-mapping.c

51

nents = DIV_ROUND_UP(size, UINT_MAX);

drivers/dma/altera-msgdma.c

342

desc_cnt = DIV_ROUND_UP(len, MSGDMA_MAX_TRANS_LEN);

drivers/dma/at_hdmac.c

994

sg_len = DIV_ROUND_UP(len, ATC_BTSIZE_MAX);

drivers/dma/bcm2835-dma.c

185

return DIV_ROUND_UP(len, max_len);

drivers/dma/bcm2835-dma.c

739

DIV_ROUND_UP(buf_len, period_len) *

drivers/dma/dma-axi-dmac.c

595

num_segments = DIV_ROUND_UP(period_len, chan->max_length);

drivers/dma/dma-axi-dmac.c

596

segment_size = DIV_ROUND_UP(period_len, num_segments);

drivers/dma/dma-axi-dmac.c

641

num_sgs += DIV_ROUND_UP(vecs[i].len, chan->max_length);

drivers/dma/dma-axi-dmac.c

723

num_segments = DIV_ROUND_UP(period_len, chan->max_length);

drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c

788

num_segments = DIV_ROUND_UP(period_len, axi_block_len);

drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c

789

segment_len = DIV_ROUND_UP(period_len, num_segments);

drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c

882

num_segments = DIV_ROUND_UP(sg_dma_len(sg), axi_block_len);

drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c

883

segment_len = DIV_ROUND_UP(sg_dma_len(sg), num_segments);

drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c

935

num = DIV_ROUND_UP(len, max_block_ts << xfer_width);

drivers/dma/img-mdc-dma.c

391

mdesc->list_period_len = DIV_ROUND_UP(period_len,

drivers/dma/k3dma.c

500

num = DIV_ROUND_UP(len, DMA_MAX_SIZE);

drivers/dma/k3dma.c

601

num += DIV_ROUND_UP(avail, modulo) - 1;

drivers/dma/loongson2-apb-dma.c

257

num_segments = DIV_ROUND_UP((ldma_sg->len + 3) >> 2, desc->burst_size);

drivers/dma/loongson2-apb-dma.c

258

segment_size = DIV_ROUND_UP((ldma_sg->len + 3) >> 2, num_segments);

drivers/dma/mediatek/mtk-cqdma.c

503

nr_vd = DIV_ROUND_UP(len, MTK_CQDMA_MAX_LEN);

drivers/dma/mediatek/mtk-hsdma.c

427

num_sgs = DIV_ROUND_UP(hvd->len, MTK_HSDMA_MAX_LEN);

drivers/dma/mv_xor.c

1383

DIV_ROUND_UP(num_present_cpus(), 2));

drivers/dma/pxa_dma.c

1039

nb_desc = DIV_ROUND_UP(period_len, PDMA_MAX_DESC_BYTES);

drivers/dma/pxa_dma.c

1040

nb_desc *= DIV_ROUND_UP(len, period_len);

drivers/dma/pxa_dma.c

934

nb_desc = DIV_ROUND_UP(len, PDMA_MAX_DESC_BYTES);

drivers/dma/qcom/qcom_adm.c

395

box_count += DIV_ROUND_UP(sg_dma_len(sg) / burst,

drivers/dma/sa11x0-dma.c

578

unsigned mult = DIV_ROUND_UP(tlen,

drivers/dma/sa11x0-dma.c

617

sgperiod = DIV_ROUND_UP(period, DMA_MAX_SIZE & ~DMA_ALIGN);

drivers/dma/sa11x0-dma.c

638

unsigned mult = DIV_ROUND_UP(tlen, DMA_MAX_SIZE & ~DMA_ALIGN);

drivers/dma/sh/usb-dmac.c

214

DIV_ROUND_UP(sg->size, USB_DMAC_XFER_SIZE));

drivers/dma/stm32/stm32-dma.c

1252

num_sgs = DIV_ROUND_UP(len, STM32_DMA_ALIGNED_MAX_DATA_ITEMS);

drivers/dma/stm32/stm32-dma3.c

1191

return DIV_ROUND_UP(len, STM32_DMA3_MAX_BLOCK_SIZE);

drivers/dma/stm32/stm32-mdma.c

962

count = DIV_ROUND_UP(len, STM32_MDMA_MAX_BLOCK_LEN);

drivers/dma/sun4i-dma.c

845

nr_periods = DIV_ROUND_UP(len, period_len);

drivers/dma/ti/edma.c

2483

array_max = DIV_ROUND_UP(ecc->num_channels, BITS_PER_TYPE(u32));

drivers/dma/xilinx/xdma.c

286

dblk_num = DIV_ROUND_UP(desc_num, XDMA_DESC_ADJACENT);

drivers/dma/xilinx/xdma.c

744

desc_num += DIV_ROUND_UP(xt->sgl[i].size, XDMA_DESC_BLEN_MAX);

drivers/dma/xilinx/zynqmp_dma.c

844

desc_cnt = DIV_ROUND_UP(len, ZYNQMP_DMA_MAX_TRANS_LEN);

drivers/firewire/net.c

1327

ptask->outstanding_pkts = DIV_ROUND_UP(dg_size, max_payload);

drivers/firewire/ohci.c

3242

header_z = DIV_ROUND_UP(p->header_length, sizeof(*d));

drivers/firewire/ohci.c

3333

header_z = DIV_ROUND_UP(header_size, sizeof(*d));

drivers/firewire/ohci.c

3340

z = DIV_ROUND_UP(payload_per_buffer + offset, PAGE_SIZE) + 1;

drivers/firewire/ohci.c

3408

z = DIV_ROUND_UP(offset + rest, PAGE_SIZE);

drivers/firewire/ohci.c

87

#define AR_BUFFERS_MIN DIV_ROUND_UP(AR_BUFFER_SIZE, PAGE_SIZE)

drivers/firewire/ohci.c

93

#define AR_WRAPAROUND_PAGES DIV_ROUND_UP(MAX_AR_PACKET_SIZE, PAGE_SIZE)

drivers/firewire/sbp2.c

1181

sbp2_queue_work(lu, DIV_ROUND_UP(HZ, 5));

drivers/firewire/sbp2.c

824

sbp2_queue_work(lu, DIV_ROUND_UP(HZ, 5));

drivers/firewire/sbp2.c

940

sbp2_queue_work(lu, DIV_ROUND_UP(HZ, 5));

drivers/firmware/broadcom/bcm47xx_nvram.c

64

__ioread32_copy(nvram_buf, nvram_start, DIV_ROUND_UP(copy_size, 4));

drivers/firmware/efi/capsule.c

124

return DIV_ROUND_UP(count, SGLIST_PER_PAGE);

drivers/firmware/efi/capsule.c

230

count = DIV_ROUND_UP(imagesize, PAGE_SIZE);

drivers/firmware/efi/libstub/mem.c

97

EFI_LOADER_DATA, DIV_ROUND_UP(size, EFI_PAGE_SIZE),

drivers/firmware/efi/libstub/unaccepted_memory.c

210

bitmap_size = DIV_ROUND_UP(end, unit_size);

drivers/firmware/efi/libstub/unaccepted_memory.c

62

bitmap_size = DIV_ROUND_UP(unaccepted_end - unaccepted_start,

drivers/firmware/efi/unaccepted_memory.c

97

range.end = DIV_ROUND_UP(end, unit_size);

drivers/firmware/turris-mox-rwtm.c

44

MOX_ECC_NUM_LEN = DIV_ROUND_UP(MOX_ECC_NUM_BITS, 8),

drivers/firmware/turris-mox-rwtm.c

45

MOX_ECC_NUM_WORDS = DIV_ROUND_UP(MOX_ECC_NUM_BITS, 32),

drivers/fpga/fpga-mgr.c

487

nr_pages = DIV_ROUND_UP((unsigned long)buf + count, PAGE_SIZE) -

drivers/fpga/ice40-spi.c

24

#define ICE40_SPI_NUM_ACTIVATION_BYTES DIV_ROUND_UP(49, 8)

drivers/fpga/intel-m10-bmc-sec-update.c

163

#define CSK_32ARRAY_SIZE DIV_ROUND_UP(CSK_BIT_LEN, 32)

drivers/gpio/gpio-74xx-mmio.c

127

config.sz = DIV_ROUND_UP(MMIO_74XX_BIT_CNT(priv->flags), 8);

drivers/gpio/gpio-aspeed-sgpio.c

376

banks = DIV_ROUND_UP(gc->ngpio, 64);

drivers/gpio/gpio-aspeed.c

1097

for (i = 0; i < DIV_ROUND_UP(gpio->chip.ngpio, 32); i++) {

drivers/gpio/gpio-aspeed.c

1355

banks = DIV_ROUND_UP(gpio->chip.ngpio, 32);

drivers/gpio/gpio-aspeed.c

638

banks = DIV_ROUND_UP(gpio->chip.ngpio, 32);

drivers/gpio/gpio-davinci.c

196

nirq = DIV_ROUND_UP(ngpio, 16);

drivers/gpio/gpio-davinci.c

237

nbank = DIV_ROUND_UP(ngpio, 32);

drivers/gpio/gpio-davinci.c

648

u32 nbank = DIV_ROUND_UP(chips->chip.ngpio, 32);

drivers/gpio/gpio-davinci.c

658

u32 nbank = DIV_ROUND_UP(chips->chip.ngpio, 32);

drivers/gpio/gpio-graniterapids.c

33

#define GNR_NUM_REGS DIV_ROUND_UP(GNR_NUM_PINS, GNR_PINS_PER_REG)

drivers/gpio/gpio-omap.c

192

debounce = DIV_ROUND_UP(debounce, 31) - 1;

drivers/gpio/gpio-pca953x.c

193

#define NBANK(chip) DIV_ROUND_UP(chip->gpio_chip.ngpio, BANK_SZ)

drivers/gpio/gpio-pisosr.c

127

gpio->buffer_size = DIV_ROUND_UP(gpio->chip.ngpio, 8);

drivers/gpio/gpio-pxa.c

345

int i, gpio, nbanks = DIV_ROUND_UP(ngpio, 32);

drivers/gpio/gpio-stmpe.c

186

int num_banks = DIV_ROUND_UP(stmpe->num_gpios, 8);

drivers/gpio/gpio-stmpe.c

393

int num_banks = DIV_ROUND_UP(stmpe->num_gpios, 8);

drivers/gpio/gpio-stmpe.c

394

u8 status[DIV_ROUND_UP(MAX_GPIOS, 8)];

drivers/gpio/gpio-tangier.c

418

size_t nctx = DIV_ROUND_UP(info->ngpio, 32);

drivers/gpio/gpio-tegra.c

233

unsigned int debounce_ms = DIV_ROUND_UP(debounce, 1000);

drivers/gpio/gpio-tegra186.c

438

debounce = DIV_ROUND_UP(debounce, USEC_PER_MSEC);

drivers/gpio/gpio-uniphier.c

340

return DIV_ROUND_UP(ngpio, UNIPHIER_GPIO_LINES_PER_BANK);

drivers/gpu/drm/amd/amdgpu/amdgpu.h

515

unsigned long used[DIV_ROUND_UP(AMDGPU_MAX_WB, BITS_PER_LONG)];

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

1044

block_size * DIV_ROUND_UP(height, block_height);

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

138

DIV_ROUND_UP(db_size, 4);

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

1275

DIV_ROUND_UP(args->bpp, 8), 0);

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

99

u32 reserved_hqd_mask = (u32)((1ULL << DIV_ROUND_UP(num_reserved_hqd, num_pipe)) - 1);

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

236

unsigned tmp = DIV_ROUND_UP(fb_div_min, fb_div);

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

56

tmp = DIV_ROUND_UP(nom_min, *nom);

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

63

tmp = DIV_ROUND_UP(den_min, *den);

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

2415

num_loops = DIV_ROUND_UP(byte_count, max_bytes);

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

2411

tmp = DIV_ROUND_UP(fls64(tmp) - 1, 9) - 1;

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

185

num_sdma_xcp = DIV_ROUND_UP(num_sdma, num_xcp);

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

186

num_vcn_xcp = DIV_ROUND_UP(num_vcn, num_xcp);

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

1121

lb_vblank_lead_lines = DIV_ROUND_UP(lb_size, mode->crtc_hdisplay);

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

1008

lb_vblank_lead_lines = DIV_ROUND_UP(lb_size, mode->crtc_hdisplay);

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

1074

lb_vblank_lead_lines = DIV_ROUND_UP(lb_size, mode->crtc_hdisplay);

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

484

num_sdma_xcp = DIV_ROUND_UP(num_sdma, num_xcp);

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

485

num_vcn_xcp = DIV_ROUND_UP(num_vcn, num_xcp);

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

8545

slot_num = DIV_ROUND_UP(pbn, pbn_div);

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

1894

aconnector->dsc_settings.dsc_num_slices_h = DIV_ROUND_UP(

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

2078

aconnector->dsc_settings.dsc_num_slices_v = DIV_ROUND_UP(

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

1038

link_timeslots_used += DIV_ROUND_UP(vars[i + k].pbn, dfixed_trunc(mst_state->pbn_div));

drivers/gpu/drm/amd/pm/powerplay/hwmgr/smu7_hwmgr.c

5123

value = DIV_ROUND_UP(value * 100, golden_value);

drivers/gpu/drm/amd/pm/powerplay/hwmgr/smu7_hwmgr.c

5165

value = DIV_ROUND_UP(value * 100, golden_value);

drivers/gpu/drm/amd/pm/powerplay/hwmgr/vega10_hwmgr.c

5018

value = DIV_ROUND_UP(value * 100, golden_value);

drivers/gpu/drm/amd/pm/powerplay/hwmgr/vega10_hwmgr.c

5071

value = DIV_ROUND_UP(value * 100, golden_value);

drivers/gpu/drm/amd/pm/powerplay/hwmgr/vega12_hwmgr.c

2727

value = DIV_ROUND_UP(value * 100, golden_value);

drivers/gpu/drm/amd/pm/powerplay/hwmgr/vega12_hwmgr.c

2748

value = DIV_ROUND_UP(value * 100, golden_value);

drivers/gpu/drm/amd/pm/powerplay/hwmgr/vega20_hwmgr.c

1490

value = DIV_ROUND_UP(value * 100, golden_value);

drivers/gpu/drm/amd/pm/powerplay/hwmgr/vega20_hwmgr.c

1536

value = DIV_ROUND_UP(value * 100, golden_value);

drivers/gpu/drm/arm/display/komeda/komeda_kms.c

30

u32 pitch = DIV_ROUND_UP(args->width * args->bpp, 8);

drivers/gpu/drm/arm/malidp_drv.c

467

args->pitch = ALIGN(DIV_ROUND_UP(args->width * args->bpp, 8), alignment);

drivers/gpu/drm/armada/armada_crtc.c

889

permillage = DIV_ROUND_UP(real_hz, desired_khz);

drivers/gpu/drm/aspeed/aspeed_gfx_crtc.c

130

t_count = DIV_ROUND_UP(m->hdisplay * bpp, priv->scan_line_max);

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

135

div = DIV_ROUND_UP(prate, mode_rate);

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

142

div = DIV_ROUND_UP(prate, mode_rate);

drivers/gpu/drm/bridge/analogix/anx7625.c

2312

adj->clock += DIV_ROUND_UP(adj_clock, 1000);

drivers/gpu/drm/bridge/analogix/anx7625.c

2316

adj->clock -= DIV_ROUND_UP(adj_clock, 1000);

drivers/gpu/drm/bridge/cadence/cdns-dsi-core.c

461

unsigned int dsi_timing = DIV_ROUND_UP(dpi_timing * dpi_bpp, 8);

drivers/gpu/drm/bridge/cadence/cdns-dsi-core.c

688

ulpout = DIV_ROUND_UP(NSEC_PER_MSEC, sysclk_period);

drivers/gpu/drm/bridge/cadence/cdns-dsi-core.c

797

tmp = DIV_ROUND_UP(dsi_cfg.htotal, nlanes) -

drivers/gpu/drm/bridge/cadence/cdns-dsi-core.c

798

DIV_ROUND_UP(dsi_cfg.hsa, nlanes);

drivers/gpu/drm/bridge/cadence/cdns-dsi-core.c

801

tmp -= DIV_ROUND_UP(DSI_EOT_PKT_SIZE, nlanes);

drivers/gpu/drm/bridge/chipone-icn6211.c

285

p_min = clamp(DIV_ROUND_UP(fin, 20000000), 1U, 31U);

drivers/gpu/drm/bridge/imx/imx93-mipi-dsi.c

247

fvco_div = 8UL / min(DIV_ROUND_UP(fout, FVCO_DIV_FACTOR), 8UL);

drivers/gpu/drm/bridge/imx/imx93-mipi-dsi.c

691

*lane_mbps = DIV_ROUND_UP(phy_cfg.mipi_dphy.hs_clk_rate, USEC_PER_SEC);

drivers/gpu/drm/bridge/ite-it6505.c

1565

audio_source_count = BIT(DIV_ROUND_UP(it6505->audio.channel_count, 2))

drivers/gpu/drm/bridge/nwl-dsi.c

201

return DIV_ROUND_UP(ui, BITS_PER_BYTE);

drivers/gpu/drm/bridge/nwl-dsi.c

209

return DIV_ROUND_UP(us * lp_clk_rate, USEC_PER_SEC);

drivers/gpu/drm/bridge/samsung-dsim.c

743

p_min = DIV_ROUND_UP(fin, (driver_data->pll_fin_max * HZ_PER_MHZ));

drivers/gpu/drm/bridge/samsung-dsim.c

887

hs_clk = samsung_dsim_set_pll(dsi, DIV_ROUND_UP(pix_clk * bpp, dsi->lanes));

drivers/gpu/drm/bridge/samsung-dsim.c

895

esc_div = DIV_ROUND_UP(byte_clk, dsi->esc_clk_rate);

drivers/gpu/drm/bridge/ssd2825.c

424

mul_factor = DIV_ROUND_UP(desired_pll_freq_kbps * div_factor,

drivers/gpu/drm/bridge/synopsys/dw-dp.c

1432

for (i = 0; i < DIV_ROUND_UP(size, 4); i++) {

drivers/gpu/drm/bridge/synopsys/dw-dp.c

1449

for (i = 0; i < DIV_ROUND_UP(size, 4); i++) {

drivers/gpu/drm/bridge/synopsys/dw-hdmi-qp.c

262

unsigned int min_n = DIV_ROUND_UP((128 * freq), 1500);

drivers/gpu/drm/bridge/synopsys/dw-mipi-dsi.c

293

two_frames = DIV_ROUND_UP(MSEC_PER_SEC, refresh) * 2;

drivers/gpu/drm/bridge/synopsys/dw-mipi-dsi2.c

315

esc_clk_div = DIV_ROUND_UP(sys_clk, 20 * 2);

drivers/gpu/drm/bridge/tc358767.c

1010

max_tu_symbol = DIV_ROUND_UP(in_bw * TU_SIZE_RECOMMENDED, out_bw);

drivers/gpu/drm/bridge/tc358768.c

658

return DIV_ROUND_UP(ns * 1000, period_ps);

drivers/gpu/drm/bridge/ti-sn65dsi86.c

886

dp_rate_mhz = DIV_ROUND_UP(bit_rate_khz * DP_CLK_FUDGE_NUM,

drivers/gpu/drm/clients/drm_log.c

112

size_t font_pitch = DIV_ROUND_UP(font->width, 8);

drivers/gpu/drm/display/drm_dp_helper.c

1954

return DIV_ROUND_UP((I2C_START_LEN + I2C_ADDR_LEN +

drivers/gpu/drm/display/drm_dp_helper.c

1971

return DIV_ROUND_UP(i2c_time_us, aux_time_us + AUX_RETRY_INTERVAL);

drivers/gpu/drm/display/drm_dp_helper.c

4691

int cycles = DIV_ROUND_UP(pixels * bpp_x16, 16 * symbol_size * lane_count);

drivers/gpu/drm/display/drm_dp_helper.c

4713

int slice_pixels = DIV_ROUND_UP(pixels, slice_count);

drivers/gpu/drm/display/drm_dp_mst_topology.c

4471

req_slots = DIV_ROUND_UP(dfixed_const(pbn), topology_state->pbn_div.full);

drivers/gpu/drm/display/drm_dp_tunnel.c

1076

int request_bw = DIV_ROUND_UP(bw, tunnel->bw_granularity);

drivers/gpu/drm/display/drm_dp_tunnel.c

56

DIV_ROUND_UP((__kbytes) * 8, 1000)

drivers/gpu/drm/display/drm_dsc_helper.c

1325

groups_per_line = DIV_ROUND_UP(vdsc_cfg->slice_width / 2,

drivers/gpu/drm/display/drm_dsc_helper.c

1329

vdsc_cfg->slice_chunk_size = DIV_ROUND_UP(vdsc_cfg->slice_width / 2 *

drivers/gpu/drm/display/drm_dsc_helper.c

1334

groups_per_line = DIV_ROUND_UP(vdsc_cfg->slice_width,

drivers/gpu/drm/display/drm_dsc_helper.c

1338

vdsc_cfg->slice_chunk_size = DIV_ROUND_UP(vdsc_cfg->slice_width *

drivers/gpu/drm/display/drm_dsc_helper.c

1389

vdsc_cfg->nfl_bpg_offset = DIV_ROUND_UP((vdsc_cfg->first_line_bpg_offset << 11),

drivers/gpu/drm/display/drm_dsc_helper.c

1398

vdsc_cfg->slice_bpg_offset = DIV_ROUND_UP(((vdsc_cfg->rc_model_size -

drivers/gpu/drm/display/drm_dsc_helper.c

1429

DIV_ROUND_UP(vdsc_cfg->initial_xmit_delay *

drivers/gpu/drm/display/drm_dsc_helper.c

1433

hrd_delay = DIV_ROUND_UP((rbs_min * 16), vdsc_cfg->bits_per_pixel);

drivers/gpu/drm/drm_dumb_buffers.c

177

pitch = args->width * DIV_ROUND_UP(args->bpp, SZ_8);

drivers/gpu/drm/drm_dumb_buffers.c

205

cpp = DIV_ROUND_UP(args->bpp, 8);

drivers/gpu/drm/drm_edid.c

5744

DIV_ROUND_UP(drm_eld_calc_baseline_block_size(eld), 4);

drivers/gpu/drm/drm_fb_helper.c

493

u32 y2 = DIV_ROUND_UP(end, line_length);

drivers/gpu/drm/drm_fb_helper.c

510

x2 = DIV_ROUND_UP(bit_end, info->var.bits_per_pixel);

drivers/gpu/drm/drm_fbdev_dma.c

122

len = DIV_ROUND_UP(len + clip->x1 % 8, 8);

drivers/gpu/drm/drm_fbdev_dma.c

126

len = DIV_ROUND_UP(len + clip->x1 % 4, 4);

drivers/gpu/drm/drm_fbdev_dma.c

130

len = DIV_ROUND_UP(len + clip->x1 % 2, 2);

drivers/gpu/drm/drm_fbdev_ttm.c

80

len = DIV_ROUND_UP(len + clip->x1 % 8, 8);

drivers/gpu/drm/drm_fbdev_ttm.c

84

len = DIV_ROUND_UP(len + clip->x1 % 4, 4);

drivers/gpu/drm/drm_fbdev_ttm.c

88

len = DIV_ROUND_UP(len + clip->x1 % 2, 2);

drivers/gpu/drm/drm_format_helper.c

1264

dst_pitch_0 = DIV_ROUND_UP(linepixels, 8);

drivers/gpu/drm/drm_format_helper.c

1352

dst_pitch_0 = DIV_ROUND_UP(linepixels, 4);

drivers/gpu/drm/drm_format_helper.c

430

unsigned int cpp_i = DIV_ROUND_UP(bpp_i, 8);

drivers/gpu/drm/drm_format_helper.c

431

size_t len_i = DIV_ROUND_UP(drm_rect_width(clip) * bpp_i, 8);

drivers/gpu/drm/drm_format_helper.c

498

u8 cpp = DIV_ROUND_UP(drm_format_info_bpp(format, 0), 8);

drivers/gpu/drm/drm_gem_dma_helper.c

271

unsigned int min_pitch = DIV_ROUND_UP(args->width * args->bpp, 8);

drivers/gpu/drm/drm_gem_vram_helper.c

441

pitch = args->width * DIV_ROUND_UP(args->bpp, 8);

drivers/gpu/drm/drm_gem_vram_helper.c

972

fbpages = DIV_ROUND_UP(fbsize, PAGE_SIZE);

drivers/gpu/drm/drm_modes.c

393

hslen = DIV_ROUND_UP(params->hslen_ns.typ, pixel_duration_ns);

drivers/gpu/drm/drm_modes.c

420

unsigned int hfp_min = DIV_ROUND_UP(params->hfp_ns.min,

drivers/gpu/drm/drm_modes.c

422

unsigned int hbp_min = DIV_ROUND_UP(params->hbp_ns.min,

drivers/gpu/drm/drm_modes.c

426

hfp = hfp_min + DIV_ROUND_UP(porches_rem, 2);

drivers/gpu/drm/drm_panic.c

116

size_mul(DIV_ROUND_UP(logo->width, BITS_PER_BYTE), logo->height),

drivers/gpu/drm/drm_panic.c

431

size_t font_pitch = DIV_ROUND_UP(font->width, 8);

drivers/gpu/drm/drm_panic.c

473

DIV_ROUND_UP(drm_rect_width(rect), 8), 1, fg_color);

drivers/gpu/drm/drm_panic.c

797

qr_pitch = DIV_ROUND_UP(qr_width, 8);

drivers/gpu/drm/drm_rect.c

144

return DIV_ROUND_UP(src, dst);

drivers/gpu/drm/exynos/exynos7_drm_decon.c

199

clkdiv = DIV_ROUND_UP(clk_get_rate(ctx->vclk), ideal_clk);

drivers/gpu/drm/exynos/exynos_drm_fb.c

109

DIV_ROUND_UP(mode_cmd->height, info->vsub);

drivers/gpu/drm/exynos/exynos_drm_ipp.c

357

DIV_ROUND_UP(buf->buf.height, buf->format->vsub);

drivers/gpu/drm/exynos/exynos_drm_ipp.c

575

DIV_ROUND_UP(buf->buf.width, buf->format->hsub);

drivers/gpu/drm/gma500/fbdev.c

133

size = ALIGN(sizes->surface_width * DIV_ROUND_UP(bpp, 8), 64) *

drivers/gpu/drm/gma500/fbdev.c

146

mode_cmd.pitches[0] = ALIGN(mode_cmd.width * DIV_ROUND_UP(bpp, 8), 64);

drivers/gpu/drm/gma500/gem.c

209

pitch = args->width * DIV_ROUND_UP(args->bpp, 8);

drivers/gpu/drm/gma500/oaktrail_hdmi.c

185

np_min = DIV_ROUND_UP(oaktrail_hdmi_limit.vco.min, target * 10);

drivers/gpu/drm/gma500/oaktrail_hdmi.c

192

nr_min = DIV_ROUND_UP((refclk * 1000), (target * 10 * np_max));

drivers/gpu/drm/gma500/oaktrail_hdmi.c

193

nr_max = DIV_ROUND_UP((refclk * 1000), (target * 10 * np_min));

drivers/gpu/drm/gma500/oaktrail_hdmi.c

199

np = DIV_ROUND_UP((refclk * 1000), (target * 10 * nr_max));

drivers/gpu/drm/gma500/oaktrail_hdmi.c

200

nr = DIV_ROUND_UP((refclk * 1000), (target * 10 * np));

drivers/gpu/drm/gud/gud_drv.c

409

num_pages = DIV_ROUND_UP(gdrm->bulk_len, PAGE_SIZE);

drivers/gpu/drm/gud/gud_pipe.c

345

for (i = 0; i < DIV_ROUND_UP(drm_rect_height(damage), lines); i++) {

drivers/gpu/drm/hisilicon/hibmc/dp/dp_aux.c

35

reg_num = DIV_ROUND_UP(size, HIBMC_BYTES_IN_U32);

drivers/gpu/drm/hisilicon/hibmc/dp/dp_aux.c

53

reg_num = DIV_ROUND_UP(size, HIBMC_BYTES_IN_U32);

drivers/gpu/drm/hisilicon/kirin/dw_drm_dsi.c

286

DIV_ROUND_UP(phy->lane_byte_clk_kHz, MAX_TX_ESC_CLK);

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

210

return DIV_ROUND_UP(crtc_state->pixel_rate * 100, 95);

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

436

return DIV_ROUND_UP(pixel_rate * num, den);

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

1019

wm = DIV_ROUND_UP(wm, 64) + 2;

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

1491

ret = DIV_ROUND_UP(ret, 64);

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

1609

fifo_extra = DIV_ROUND_UP(fifo_left, num_active_planes ?: 1);

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

2157

entries = DIV_ROUND_UP(entries, I915_FIFO_LINE_SIZE);

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

2169

entries = DIV_ROUND_UP(entries,

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

2335

entries = DIV_ROUND_UP(entries, wm_info->cacheline_size);

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

2398

ret = DIV_ROUND_UP(ret, 64) + 2;

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

2414

ret = DIV_ROUND_UP(ret, 64) + 2;

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

2432

return DIV_ROUND_UP(pri_val * 64, horiz_pixels * cpp) + 2;

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

2814

wm[level] = max_t(u16, wm[level], DIV_ROUND_UP(min, 5));

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

584

entries = DIV_ROUND_UP(entries, wm->cacheline_size) +

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

1075

hs_tx_timeout = DIV_ROUND_UP(intel_dsi->hs_tx_timeout * mul,

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

1077

lp_rx_timeout = DIV_ROUND_UP(intel_dsi->lp_rx_timeout * mul, divisor);

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

1078

ta_timeout = DIV_ROUND_UP(intel_dsi->turn_arnd_val * mul, divisor);

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

1511

DIV_ROUND_UP(adjusted_mode->crtc_htotal * mul, div);

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

1513

DIV_ROUND_UP(adjusted_mode->crtc_hsync_start * mul, div);

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

1515

DIV_ROUND_UP(adjusted_mode->crtc_hsync_end * mul, div);

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

1872

tclk_prepare_esc_clk = DIV_ROUND_UP(mipi_config->tclk_prepare * 4, tlpx_ns);

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

1875

tclk_zero_esc_clk = DIV_ROUND_UP(mipi_config->tclk_prepare_clkzero -

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

1879

tclk_pre_esc_clk = DIV_ROUND_UP(mipi_config->tclk_pre, tlpx_ns);

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

1882

ths_prepare_esc_clk = DIV_ROUND_UP(mipi_config->ths_prepare * 4, tlpx_ns);

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

1885

ths_zero_esc_clk = DIV_ROUND_UP(mipi_config->ths_prepare_hszero -

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

1889

ths_exit_esc_clk = DIV_ROUND_UP(mipi_config->ths_exit, tlpx_ns);

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

372

theo_word_clk = DIV_ROUND_UP(afe_clk_khz, 8 * DSI_MAX_ESC_CLK);

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

377

esc_clk_div_m = DIV_ROUND_UP(afe_clk_khz, DSI_MAX_ESC_CLK);

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

900

htotal = DIV_ROUND_UP(adjusted_mode->crtc_htotal * mul, div);

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

902

htotal = DIV_ROUND_UP((hactive + 160) * mul, div);

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

904

hsync_start = DIV_ROUND_UP(adjusted_mode->crtc_hsync_start * mul, div);

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

905

hsync_end = DIV_ROUND_UP(adjusted_mode->crtc_hsync_end * mul, div);

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

923

vtotal = vactive + DIV_ROUND_UP(400, line_time_us);

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

109

int num_ml_phy_lock = 7 + DIV_ROUND_UP(6500, tml_phy_lock) + 1;

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

113

return DIV_ROUND_UP(tphy2_p2_to_p0 + get_lfps_cycle_time(crtc_state) +

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

480

link_clks_required = DIV_ROUND_UP(192000 * h_total, 1000 * pixel_clk) * (48 / lanes + 2);

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

494

hblank_rise = (link_clks_active + 6 * DIV_ROUND_UP(link_clks_active, 250) + 4) * pixel_clk / link_clk;

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

1087

DIV_ROUND_UP(backlight_data->hdr_dpcd_refresh_timeout[panel_type], 100);

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

1212

data_rate = DIV_ROUND_UP(data_rate, 1000);

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

124

sp->dclk = DIV_ROUND_UP((16667 * dclk) + (DISPLAY_VER(display) >= 12 ? 500 : 0),

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

476

qi.deinterleave = DIV_ROUND_UP(num_channels, is_y_tile ? 4 : 2);

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

501

bw = DIV_ROUND_UP(sp->dclk * clpchgroup * 32 * num_channels, ct);

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

549

qi.deinterleave = qi.deinterleave ? : DIV_ROUND_UP(num_channels, is_y_tile ? 4 : 2);

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

552

qi.deinterleave = max(DIV_ROUND_UP(qi.deinterleave, 2), 1);

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

561

peakbw = num_channels * DIV_ROUND_UP(qi.channel_width, 8) * dclk_max;

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

569

clperchgroup = 4 * DIV_ROUND_UP(8, num_channels) * qi.deinterleave;

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

604

bw = DIV_ROUND_UP(sp->dclk * clpchgroup * 32 * num_channels, ct);

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

862

data_rate = DIV_ROUND_UP(data_rate * 105, 100);

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

87

sp->dclk = DIV_ROUND_UP((16667 * dclk_ratio * dclk_reference) + 500, 1000);

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

1621

return DIV_ROUND_UP(cdclk, 25000);

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

2063

return DIV_ROUND_UP(cdclk_config->vco, cdclk_config->cdclk);

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

2890

return DIV_ROUND_UP(pixel_rate * 100, guardband * ppc);

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

3785

DIV_ROUND_UP(display->cdclk.hw.cdclk, 1000));

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

175

return DIV_ROUND_UP(total_max_bw, 64);

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

350

return DIV_ROUND_UP(port_clock, intel_dp_link_symbol_size(port_clock) * 1000);

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

3339

return DIV_ROUND_UP(bps, link_bw * 8);

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

4220

linetime_wm = DIV_ROUND_UP(pipe_mode->crtc_htotal * 1000 * 8,

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

8105

if (DIV_ROUND_UP(mode->htotal * 1000, mode->clock) > 64)

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

1007

min_slice_count = DIV_ROUND_UP(mode_clock, min(tp_rgb_yuv444, tp_yuv422_420));

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

1025

DIV_ROUND_UP(mode_hdisplay,

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

4200

slice_width = DIV_ROUND_UP(crtc_state->hw.adjusted_mode.hdisplay,

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

222

return DIV_ROUND_UP(effective_data_rate * 64, 54 * 1000);

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

373

remote_tu = DIV_ROUND_UP(pbn.full, mst_state->pbn_div.full);

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

54

return DIV_ROUND_UP(kbytes * 8, 1000);

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

805

intel_dsi->pclk += DIV_ROUND_UP(mode->vtotal * intel_dsi->pixel_overlap * 60, 1000);

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

839

DIV_ROUND_UP(mipi_config->target_burst_mode_freq * 100, bitrate);

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

841

intel_dsi->pclk = DIV_ROUND_UP(intel_dsi->pclk * burst_mode_ratio, 100);

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

1407

return DIV_ROUND_UP(fb->base.pitches[color_plane],

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

1448

return DIV_ROUND_UP(x + dims->width, dims->tile_width);

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

1456

return DIV_ROUND_UP(y + dims->height, dims->tile_height);

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

1470

return DIV_ROUND_UP(size, intel_tile_size(display));

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

1750

max_size = max(max_size, DIV_ROUND_UP(end, tile_size));

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

1827

vtd_guard = max(vtd_guard, DIV_ROUND_UP(stride, tile));

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

752

return DIV_ROUND_UP(main_stride, 4 * main_tile_width) * 64;

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

966

*w = DIV_ROUND_UP(main_width, main_hsub * hsub);

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

967

*h = DIV_ROUND_UP(main_height, main_vsub * vsub);

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

1576

return DIV_ROUND_UP(crtc_state->pixel_rate * 100, 95);

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

219

mode_cmd->pitches[0] = intel_fbdev_fb_pitch_align(mode_cmd->width * DIV_ROUND_UP(sizes->surface_bpp, 8));

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

36

return DIV_ROUND_UP(fp.val, 1 << 16);

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

72

return DIV_ROUND_UP(val.val, d.val);

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

149

DIV_ROUND_UP(display->cdclk.hw.cdclk * cdclk_factor(display), 540000) +

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

155

return DIV_ROUND_UP(intel_flipq_exec_time_us(display), 1000);

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

3220

adjusted_clk_khz = DIV_ROUND_UP(kslice_adjust * pixel_clock, 10);

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

3233

min_slices = DIV_ROUND_UP(adjusted_clk_khz, max_throughput);

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

3261

slice_width = DIV_ROUND_UP(crtc_state->hw.adjusted_mode.hdisplay, target_slices);

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

3347

bpp_decrement_x16 = DIV_ROUND_UP(16, src_fractional_bpp);

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

3353

bpp = DIV_ROUND_UP(bpp_target_x16, 16);

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

3354

target_bytes = DIV_ROUND_UP((num_slices * slice_width * bpp), 8);

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

235

DIV_ROUND_UP(pps->delays.power_cycle, 1000) + 1));

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

857

DIV_ROUND_UP(crtc_state->pixel_rate, 2);

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

525

asle->cblv = DIV_ROUND_UP(bclp * 100, 255) | ASLE_CBLV_VALID;

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

1309

unsigned int width_in_blocks = DIV_ROUND_UP(width, 32);

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

1327

unsigned int width_in_blocks = DIV_ROUND_UP(width, 32);

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

199

pmdemand_state->params.ddiclk_max = DIV_ROUND_UP(max_ddiclk, 1000);

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

366

DIV_ROUND_UP(intel_cdclk_actual(new_cdclk_state), 1000);

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

1453

return DIV_ROUND_UP(val, 10);

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

1656

DIV_ROUND_UP(seq->power_cycle, 1000) + 1));

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

1660

DIV_ROUND_UP(seq->power_cycle, 1000) + 1));

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

1166

return DIV_ROUND_UP(1000 * 1000,

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

254

return DIV_ROUND_UP(pixel_rate * num, den);

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

563

return DIV_ROUND_UP(pixel_rate * num, den);

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

637

return DIV_ROUND_UP(pixel_rate * num, den);

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

588

vdisplay = DIV_ROUND_UP(vdisplay, 2);

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

598

vblank_start = DIV_ROUND_UP(vblank_start, 2);

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

1117

min_cdclk = DIV_ROUND_UP(pixel_rate, num_vdsc_instances);

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

123

vdsc_cfg->nsl_bpg_offset = DIV_ROUND_UP(vdsc_cfg->second_line_bpg_offset << 11,

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

130

vdsc_cfg->initial_offset = 5632 - DIV_ROUND_UP(((bpp - 10) * 3584), 2);

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

132

vdsc_cfg->initial_offset = 6144 - DIV_ROUND_UP(((bpp - 8) * 512), 2);

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

137

vdsc_cfg->initial_xmit_delay = DIV_ROUND_UP(DSC_RC_MODEL_SIZE_CONST, 2 * bpp);

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

281

vdsc_cfg->slice_width = DIV_ROUND_UP(vdsc_cfg->pic_width,

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

72

return offset_low + DIV_ROUND_UP((offset_high - offset_low) * (bpp - bpp_low),

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

386

DIV_ROUND_UP(crtc_state->vrr.dc_balance.vmax *

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

398

DIV_ROUND_UP(adjustment_usec, guardband_usec);

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

400

DIV_ROUND_UP((crtc_state->vrr.vmax - crtc_state->vrr.vmin) *

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

131

return DIV_ROUND_UP(prefill, 0x10000);

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

272

return DIV_ROUND_UP(pixel_rate, 2);

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

299

return DIV_ROUND_UP(pixel_rate * num, 2 * den);

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

325

return DIV_ROUND_UP(pixel_rate * num, den);

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

1643

wm_intermediate_val = DIV_ROUND_UP(wm_intermediate_val,

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

1652

return DIV_ROUND_UP(crtc_state->hw.pipe_mode.crtc_htotal * 1000,

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

1717

interm_pbpl = DIV_ROUND_UP(wp->plane_bytes_per_line *

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

1729

interm_pbpl = DIV_ROUND_UP(wp->plane_bytes_per_line,

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

1906

min_ddb_alloc = blocks + DIV_ROUND_UP(blocks, 10);

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

2847

display->pkgc.linetime[crtc->pipe] = DIV_ROUND_UP(crtc_state->linetime, 8);

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

1632

intel_dsi->lp_byte_clk = DIV_ROUND_UP(tlpx_ns * ui_den, 8 * ui_num);

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

1648

prepare_cnt = DIV_ROUND_UP(ths_prepare_ns * ui_den, ui_num * mul);

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

1657

exit_zero_cnt = DIV_ROUND_UP(

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

1678

clk_zero_cnt = DIV_ROUND_UP(

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

1690

trail_cnt = DIV_ROUND_UP(tclk_trail_ns * ui_den, ui_num * mul);

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

1712

tlpx_ui = DIV_ROUND_UP(tlpx_ns * ui_den, ui_num);

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

1717

lp_to_hs_switch = DIV_ROUND_UP(4 * tlpx_ui + prepare_cnt * mul +

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

1720

hs_to_lp_switch = DIV_ROUND_UP(mipi_config->ths_trail + 2 * tlpx_ui, 8);

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

1735

DIV_ROUND_UP(

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

1750

DIV_ROUND_UP(2 * tlpx_ui + trail_cnt * 2 + 8,

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

60

return DIV_ROUND_UP(DIV_ROUND_UP(pixels * bpp * burst_mode_ratio,

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

68

return DIV_ROUND_UP((clk_hs * lane_count * 8 * 100),

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

412

txesc1_div = DIV_ROUND_UP(div1_value, 2);

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

414

txesc1_div = DIV_ROUND_UP(div1_value, 4);

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

416

txesc1_div = DIV_ROUND_UP(div1_value, 6);

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

418

txesc1_div = DIV_ROUND_UP(div1_value, 8);

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

423

div2_value = DIV_ROUND_UP(div1_value, txesc1_div);

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

461

tx_div = DIV_ROUND_UP(dsi_rate, 20000) - 1;

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

466

rx_div = DIV_ROUND_UP(dsi_rate, 150000) - 1;

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

503

dsi_ratio = DIV_ROUND_UP(dsi_clk * 2, BXT_REF_CLOCK_KHZ);

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

174

int cpp = DIV_ROUND_UP(args->bpp, 8);

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

298

ccs_pages = DIV_ROUND_UP(DIV_ROUND_UP(bo->base.size,

drivers/gpu/drm/i915/gt/gen2_engine_cs.c

224

*cs++ = DIV_ROUND_UP(len, 4096) << 16 | 4096;

drivers/gpu/drm/i915/gt/intel_migrate.c

22

DIV_ROUND_UP(size, NUM_BYTES_PER_CCS_BYTE) : 0)

drivers/gpu/drm/i915/gt/intel_migrate.c

543

num_ccs_blks = DIV_ROUND_UP(GET_CCS_BYTES(i915, size),

drivers/gpu/drm/i915/gt/intel_sseu.c

448

DIV_ROUND_UP(sseu->eu_total, intel_sseu_subslice_total(sseu)) :

drivers/gpu/drm/i915/gt/intel_sseu.c

555

DIV_ROUND_UP(sseu->eu_total, intel_sseu_subslice_total(sseu)) :

drivers/gpu/drm/i915/gt/intel_sseu.c

880

WARN_ON(DIV_ROUND_UP(XEHP_BITMAP_BITS(dss_mask), dss_per_slice) >

drivers/gpu/drm/i915/gt/intel_sseu.h

48

#define GEN_SSEU_STRIDE(max_entries) DIV_ROUND_UP(max_entries, BITS_PER_BYTE)

drivers/gpu/drm/i915/gt/selftest_migrate.c

372

for (i = 0; !err && i < DIV_ROUND_UP(ccs_bytes, PAGE_SIZE); i++) {

drivers/gpu/drm/i915/gt/selftest_rps.c

949

timeout = DIV_ROUND_UP(timeout, 1000);

drivers/gpu/drm/i915/gt/selftest_rps.c

997

timeout = DIV_ROUND_UP(timeout, 1000);

drivers/gpu/drm/i915/gvt/kvmgt.c

133

DIV_ROUND_UP(size, PAGE_SIZE));

drivers/gpu/drm/i915/gvt/kvmgt.c

140

int total_pages = DIV_ROUND_UP(size, PAGE_SIZE);

drivers/gpu/drm/i915/i915_cmd_parser.c

1414

jmp = bitmap_zalloc(DIV_ROUND_UP(batch_length, sizeof(u32)),

drivers/gpu/drm/i915/i915_memcpy.c

160

__memcpy_ntdqu(dst, src, DIV_ROUND_UP(len, 16));

drivers/gpu/drm/i915/i915_perf.c

2185

count += DIV_ROUND_UP(num_regs, MI_LOAD_REGISTER_IMM_MAX_REGS);

drivers/gpu/drm/i915/i915_perf_types.h

505

#define FORMAT_MASK_SIZE DIV_ROUND_UP(I915_OA_FORMAT_MAX - 1, BITS_PER_LONG)

drivers/gpu/drm/i915/selftests/i915_request.c

1730

max_t(int, 2, DIV_ROUND_UP(num_online_cpus(), nengines));

drivers/gpu/drm/imagination/pvr_drv.c

296

max_coeff_pixel_portion = DIV_ROUND_UP(tiles_in_flight, num_phantoms);

drivers/gpu/drm/imagination/pvr_fw.c

79

#define DEV_INFO_MASK_SIZE(x) DIV_ROUND_UP(x, 64)

drivers/gpu/drm/imagination/pvr_fw_mips.h

16

#define PVR_MIPS_PT_PAGE_COUNT DIV_ROUND_UP(ROGUE_MIPSFW_MAX_NUM_PAGETABLE_PAGES * ROGUE_MIPSFW_PAGE_SIZE_4K, PAGE_SIZE)

drivers/gpu/drm/imagination/pvr_hwrt.c

246

info.num_tiles_x = DIV_ROUND_UP(args->width, info.tile_size_x);

drivers/gpu/drm/imagination/pvr_hwrt.c

247

info.num_tiles_y = DIV_ROUND_UP(args->height, info.tile_size_y);

drivers/gpu/drm/imagination/pvr_hwrt.c

263

info.mtile_x[0] = DIV_ROUND_UP(info.num_tiles_x, 8) * 2;

drivers/gpu/drm/imagination/pvr_hwrt.c

264

info.mtile_y[0] = DIV_ROUND_UP(info.num_tiles_y, 8) * 2;

drivers/gpu/drm/imagination/pvr_hwrt.c

273

info.mtile_x[0] = round_up(DIV_ROUND_UP(info.num_tiles_x, 4), 4);

drivers/gpu/drm/imagination/pvr_hwrt.c

274

info.mtile_y[0] = round_up(DIV_ROUND_UP(info.num_tiles_y, 4), 4);

drivers/gpu/drm/imx/ipuv3/imx-drm-core.c

165

pitch_align = DIV_ROUND_UP(args->bpp, SZ_8) * 8;

drivers/gpu/drm/logicvc/logicvc_drm.c

43

args->pitch = logicvc->config.row_stride * DIV_ROUND_UP(args->bpp, 8);

drivers/gpu/drm/mcde/mcde_display.c

966

const int max_div = DIV_ROUND_UP(MCDE_MAX_WIDTH, fifo_size);

drivers/gpu/drm/mediatek/mtk_dsi.c

249

u32 data_rate_mhz = DIV_ROUND_UP(dsi->data_rate, HZ_PER_MHZ);

drivers/gpu/drm/mediatek/mtk_dsi.c

485

hstx_cklp_wc_min = (DIV_ROUND_UP(cklp_wc_min_adjust, dsi->lanes) + da_hs_trail + 1)

drivers/gpu/drm/mediatek/mtk_dsi.c

487

hstx_cklp_wc_max = (DIV_ROUND_UP((cklp_wc_max_adjust + horizontal_backporch_byte +

drivers/gpu/drm/mediatek/mtk_gem.c

149

args->pitch = DIV_ROUND_UP(args->width * args->bpp, 8);

drivers/gpu/drm/meson/meson_drv.c

89

args->pitch = ALIGN(DIV_ROUND_UP(args->width * args->bpp, 8), SZ_64);

drivers/gpu/drm/meson/meson_dw_mipi_dsi.c

173

*lane_mbps = DIV_ROUND_UP(mipi_dsi->phy_opts.mipi_dphy.hs_clk_rate, USEC_PER_SEC);

drivers/gpu/drm/mgag200/mgag200_mode.c

796

fbpages = DIV_ROUND_UP(fbsize, PAGE_SIZE);

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

1988

return DIV_ROUND_UP(total_pixels, dsc->slice_width);

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

101

y_meta_stride = DIV_ROUND_UP(fb->width, y_tile_width);

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

104

y_meta_scanlines = DIV_ROUND_UP(fb->height, y_tile_height);

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

109

uv_meta_stride = DIV_ROUND_UP((fb->width+1)>>1, y_tile_width / 2);

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

112

uv_meta_scanlines = DIV_ROUND_UP((fb->height+1)>>1, y_tile_height);

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

130

rgb_meta_stride = DIV_ROUND_UP(fb->width, 16);

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

133

rgb_meta_scanlines = DIV_ROUND_UP(fb->height, 4);

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

152

n = DIV_ROUND_UP(fetch_stride * nlines, smp->blk_size);

drivers/gpu/drm/msm/dsi/dsi_host.c

1054

hdisplay = DIV_ROUND_UP(msm_dsc_get_bytes_per_line(msm_host->dsc) * 8, bits_per_pclk);

drivers/gpu/drm/msm/dsi/dsi_host.c

604

new_hdisplay = DIV_ROUND_UP(hdisplay * drm_dsc_get_bpp_int(dsc),

drivers/gpu/drm/msm/dsi/dsi_host.c

704

esc_div = DIV_ROUND_UP(byte_mhz, esc_mhz);

drivers/gpu/drm/msm/dsi/phy/dsi_phy.c

105

tmin = DIV_ROUND_UP(temp, ui) - 2;

drivers/gpu/drm/msm/dsi/phy/dsi_phy.c

194

tmin = DIV_ROUND_UP(60 * coeff + 3 * ui, ui_x8);

drivers/gpu/drm/msm/dsi/phy/dsi_phy.c

210

tmin = DIV_ROUND_UP(60 * coeff + 4 * ui + 3 * ui, ui_x8);

drivers/gpu/drm/msm/dsi/phy/dsi_phy.c

218

tmin = DIV_ROUND_UP(100 * coeff, ui_x8) - 1;

drivers/gpu/drm/msm/dsi/phy/dsi_phy.c

226

tmin = DIV_ROUND_UP(temp, ui_x8) - 1;

drivers/gpu/drm/msm/dsi/phy/dsi_phy.c

302

tmin = DIV_ROUND_UP(60 * coeff + 3 * ui, ui_x8);

drivers/gpu/drm/msm/dsi/phy/dsi_phy.c

318

tmin = DIV_ROUND_UP(60 * coeff + 4 * ui, ui_x8) - 1;

drivers/gpu/drm/msm/dsi/phy/dsi_phy.c

326

tmin = DIV_ROUND_UP(100 * coeff, ui_x8) - 1;

drivers/gpu/drm/msm/dsi/phy/dsi_phy.c

334

tmin = DIV_ROUND_UP(temp, ui_x8) - 1;

drivers/gpu/drm/msm/dsi/phy/dsi_phy.c

415

tmin = DIV_ROUND_UP(60 * coeff + 3 * ui, ui_x8);

drivers/gpu/drm/msm/dsi/phy/dsi_phy.c

431

tmin = DIV_ROUND_UP(60 * coeff + 4 * ui, ui_x8) - 1;

drivers/gpu/drm/msm/dsi/phy/dsi_phy.c

439

tmin = DIV_ROUND_UP(100 * coeff, ui_x8) - 1;

drivers/gpu/drm/msm/dsi/phy/dsi_phy.c

447

tmin = DIV_ROUND_UP(temp, 16 * ui) - 1;

drivers/gpu/drm/msm/dsi/phy/dsi_phy.c

457

tmin = DIV_ROUND_UP(temp, 16 * ui) - 1;

drivers/gpu/drm/msm/dsi/phy/dsi_phy.c

459

timing->shared_timings.clk_pre = DIV_ROUND_UP((tmax - tmin) * 125, 10000) + tmin;

drivers/gpu/drm/msm/dsi/phy/dsi_phy.c

493

tmin = DIV_ROUND_UP(50 * coeff, ui_x7);

drivers/gpu/drm/msm/dsi/phy/dsi_phy.c

497

tmin = DIV_ROUND_UP(100 * coeff, ui_x7) - 1;

drivers/gpu/drm/msm/msm_gem.c

693

pitch_align = round_up(args->width, 32) * DIV_ROUND_UP(args->bpp, SZ_8);

drivers/gpu/drm/msm/msm_gpu_trace.h

97

__entry->freq = DIV_ROUND_UP(freq, 1000000);

drivers/gpu/drm/msm/msm_submitqueue.c

277

default_prio = DIV_ROUND_UP(max_priority, 2);

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

394

mode_rate = DIV_ROUND_UP(mode->clock * asyh->or.bpc * 3, 8);

drivers/gpu/drm/nouveau/dispnv50/tile.h

23

return DIV_ROUND_UP(stride, NV_TILE_GOB_WIDTH_BYTES);

drivers/gpu/drm/nouveau/dispnv50/tile.h

38

return DIV_ROUND_UP(height, nouveau_get_gob_height(family) * gobs_in_block);

drivers/gpu/drm/nouveau/nouveau_dp.c

416

min_rate = DIV_ROUND_UP(khz * bpc * 3, 8);

drivers/gpu/drm/nouveau/nouveau_dp.c

546

mode_rate = DIV_ROUND_UP(clock * bpp, 8);

drivers/gpu/drm/nouveau/nvkm/engine/gr/ctxgf100.c

1081

for (i = 0; i < DIV_ROUND_UP(tpcmax, 4); i++) {

drivers/gpu/drm/nouveau/nvkm/engine/gr/ctxgm200.c

49

const u32 dist_nr = DIV_ROUND_UP(gr->tpc_total, 4);

drivers/gpu/drm/nouveau/nvkm/engine/gr/ctxgp100.c

109

const u32 dist_nr = DIV_ROUND_UP(gr->tpc_total, 4);

drivers/gpu/drm/nouveau/nvkm/engine/gr/ctxgv100.c

118

const u32 mapregs = DIV_ROUND_UP(gr->func->gpc_nr * gr->func->tpc_nr, 6);

drivers/gpu/drm/nouveau/nvkm/engine/gr/gf100.c

2291

const u32 magicgpc918 = DIV_ROUND_UP(0x00800000, gr->tpc_total);

drivers/gpu/drm/nouveau/nvkm/engine/gr/gf117.c

127

const u32 magicgpc918 = DIV_ROUND_UP(0x00800000, gr->tpc_total);

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

58

const u32 magicgpc918 = DIV_ROUND_UP(0x00800000, gr->tpc_total);

drivers/gpu/drm/nouveau/nvkm/subdev/clk/gk20a.h

146

return DIV_ROUND_UP(pll->m * clk->params->min_vco,

drivers/gpu/drm/nouveau/nvkm/subdev/clk/gm20b.c

1050

clk_params->max_m = clk_params->min_m = DIV_ROUND_UP(clk_params->max_u,

drivers/gpu/drm/nouveau/nvkm/subdev/clk/gm20b.c

502

nmin = DIV_ROUND_UP(pll->m * clk->base.params->min_vco, parent_rate);

drivers/gpu/drm/nouveau/nvkm/subdev/clk/gm20b.c

506

pll->pl = DIV_ROUND_UP(nmin * parent_rate, pll->m * rate);

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv20.c

46

u32 tiles = DIV_ROUND_UP(size, 0x40);

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv25.c

33

u32 tiles = DIV_ROUND_UP(size, 0x40);

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv30.c

52

u32 tiles = DIV_ROUND_UP(size, 0x40);

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv35.c

33

u32 tiles = DIV_ROUND_UP(size, 0x40);

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv36.c

33

u32 tiles = DIV_ROUND_UP(size, 0x40);

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv40.c

33

u32 tiles = DIV_ROUND_UP(size, 0x80);

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

1146

gsp->shm.ptes.nr += DIV_ROUND_UP(gsp->shm.ptes.nr * sizeof(u64), GSP_PAGE_SIZE);

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

1588

const u64 pages = DIV_ROUND_UP(size, PAGE_SIZE);

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

147

size = DIV_ROUND_UP(GSP_MSG_HDR_SIZE + gsp_rpc_len,

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

279

rptr = (rptr + DIV_ROUND_UP(size, GSP_PAGE_SIZE)) % gsp->msgq.cnt;

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

370

msg->elem_count = DIV_ROUND_UP(len, 0x1000);

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

400

wptr += DIV_ROUND_UP(size, 0x1000);

drivers/gpu/drm/nouveau/nvkm/subdev/volt/gk104.c

60

duty = DIV_ROUND_UP((uv - bios->base) * div, bios->pwm_range);

drivers/gpu/drm/nouveau/nvkm/subdev/volt/gk20a.c

87

mv = DIV_ROUND_UP(mv, v_scale);

drivers/gpu/drm/omapdrm/dss/dispc.c

2104

const int ds = DIV_ROUND_UP(height, out_height);

drivers/gpu/drm/omapdrm/dss/dispc.c

2241

return DIV_ROUND_UP(pclk, out_width) * width;

drivers/gpu/drm/omapdrm/dss/dispc.c

2404

/ DIV_ROUND_UP(pclk, out_width);

drivers/gpu/drm/omapdrm/dss/dispc.c

2407

*decim_x = DIV_ROUND_UP(width, in_width_max);

drivers/gpu/drm/omapdrm/dss/dispc.c

2520

decim_x = DIV_ROUND_UP(DIV_ROUND_UP(width, out_width), maxhdownscale);

drivers/gpu/drm/omapdrm/dss/dispc.c

2521

decim_y = DIV_ROUND_UP(DIV_ROUND_UP(height, out_height), maxvdownscale);

drivers/gpu/drm/omapdrm/dss/dispc.c

3571

lckd_start = max(DIV_ROUND_UP(dispc_freq, lck_max), 1ul);

drivers/gpu/drm/omapdrm/dss/dispc.c

3577

pckd_start = max(DIV_ROUND_UP(lck, pck_max), pckd_hw_min);

drivers/gpu/drm/omapdrm/dss/dsi.c

2687

width_bytes = DIV_ROUND_UP(vm->hactive * bpp, 8);

drivers/gpu/drm/omapdrm/dss/dsi.c

2688

bllp = hbp + hfp + hsa + DIV_ROUND_UP(width_bytes + 6, ndl);

drivers/gpu/drm/omapdrm/dss/dsi.c

2854

ths_eot = DIV_ROUND_UP(4, ndl);

drivers/gpu/drm/omapdrm/dss/dsi.c

2856

ddr_clk_pre = DIV_ROUND_UP(tclk_pre + tlpx + tclk_zero + tclk_prepare,

drivers/gpu/drm/omapdrm/dss/dsi.c

2858

ddr_clk_post = DIV_ROUND_UP(tclk_post + ths_trail, 4) + ths_eot;

drivers/gpu/drm/omapdrm/dss/dsi.c

2872

enter_hs_mode_lat = 1 + DIV_ROUND_UP(tlpx, 4) +

drivers/gpu/drm/omapdrm/dss/dsi.c

2873

DIV_ROUND_UP(ths_prepare, 4) +

drivers/gpu/drm/omapdrm/dss/dsi.c

2874

DIV_ROUND_UP(ths_zero + 3, 4);

drivers/gpu/drm/omapdrm/dss/dsi.c

2876

exit_hs_mode_lat = DIV_ROUND_UP(ths_trail + ths_exit, 4) + 1 + ths_eot;

drivers/gpu/drm/omapdrm/dss/dsi.c

2901

((hsa == 0 && ndl == 3) ? 1 : DIV_ROUND_UP(4, ndl)) : 0;

drivers/gpu/drm/omapdrm/dss/dsi.c

2903

width_bytes = DIV_ROUND_UP(vm->hactive * bpp, 8);

drivers/gpu/drm/omapdrm/dss/dsi.c

2906

tl = DIV_ROUND_UP(4, ndl) + (hsync_end ? hsa : 0) + t_he + hfp +

drivers/gpu/drm/omapdrm/dss/dsi.c

2907

DIV_ROUND_UP(width_bytes + 6, ndl) + hbp;

drivers/gpu/drm/omapdrm/dss/dsi.c

3023

word_count = DIV_ROUND_UP(dsi->vm.hactive * bpp, 8);

drivers/gpu/drm/omapdrm/dss/dsi.c

3582

wc = DIV_ROUND_UP(t->hact * t->bitspp, 8);

drivers/gpu/drm/omapdrm/dss/dsi.c

3583

pps = DIV_ROUND_UP(wc + 6, t->ndl); /* pixel packet size */

drivers/gpu/drm/omapdrm/dss/dsi.c

3648

dsi_hact = DIV_ROUND_UP(DIV_ROUND_UP(t->hact * t->bitspp, 8) + 6, t->ndl);

drivers/gpu/drm/omapdrm/dss/dsi.c

3786

dsi_hact = DIV_ROUND_UP(DIV_ROUND_UP(xres * bitspp, 8) + 6, ndl);

drivers/gpu/drm/omapdrm/dss/dsi.c

3810

hss = DIV_ROUND_UP(4, ndl);

drivers/gpu/drm/omapdrm/dss/dsi.c

3816

hse = DIV_ROUND_UP(4, ndl);

drivers/gpu/drm/omapdrm/dss/dsi.c

814

lp_clk_div = DIV_ROUND_UP(dsi_fclk, lp_clk_max * 2);

drivers/gpu/drm/omapdrm/dss/dsi.c

909

cinfo->mX[HSDIV_DSI] = DIV_ROUND_UP(cinfo->clkdco, max_dsi_fck);

drivers/gpu/drm/omapdrm/dss/dss.c

631

fckd_stop = max(DIV_ROUND_UP(prate * m, fck_hw_max), 1ul);

drivers/gpu/drm/omapdrm/dss/dss.c

634

fck = DIV_ROUND_UP(prate, fckd) * m;

drivers/gpu/drm/omapdrm/dss/dss.c

685

fck_div = DIV_ROUND_UP(prate * dss->feat->dss_fck_multiplier,

drivers/gpu/drm/omapdrm/dss/dss.c

687

fck = DIV_ROUND_UP(prate, fck_div)

drivers/gpu/drm/omapdrm/dss/pll.c

187

m_start = max(DIV_ROUND_UP(clkdco, out_max), 1ul);

drivers/gpu/drm/omapdrm/dss/pll.c

221

n_start = max(DIV_ROUND_UP(clkin, fint_hw_max), 1ul);

drivers/gpu/drm/omapdrm/dss/pll.c

238

m_start = max(DIV_ROUND_UP(DIV_ROUND_UP(pll_min, fint), 2),

drivers/gpu/drm/omapdrm/dss/pll.c

284

n = DIV_ROUND_UP(clkin, hw->fint_max);

drivers/gpu/drm/omapdrm/dss/pll.c

289

m2 = DIV_ROUND_UP(min_dco, target_clkout);

drivers/gpu/drm/omapdrm/dss/pll.c

310

sd = DIV_ROUND_UP(fint * m, 250000000);

drivers/gpu/drm/omapdrm/dss/pll.c

460

sleep_time = DIV_ROUND_UP(1000*1000*1000, cinfo->fint);

drivers/gpu/drm/omapdrm/omap_dmm_tiler.c

546

w = DIV_ROUND_UP(w, geom[fmt].slot_w);

drivers/gpu/drm/omapdrm/omap_dmm_tiler.c

547

h = DIV_ROUND_UP(h, geom[fmt].slot_h);

drivers/gpu/drm/omapdrm/omap_fbdev.c

179

DIV_ROUND_UP(mode_cmd.width * sizes->surface_bpp, 8);

drivers/gpu/drm/omapdrm/omap_gem.c

1412

npages = DIV_ROUND_UP(size, PAGE_SIZE);

drivers/gpu/drm/omapdrm/omap_gem.c

183

const int m = DIV_ROUND_UP(omap_obj->width << fmt, PAGE_SIZE);

drivers/gpu/drm/omapdrm/omap_gem.c

407

const int m = DIV_ROUND_UP(omap_obj->width << fmt, PAGE_SIZE);

drivers/gpu/drm/panthor/panthor_sched.c

3468

return DIV_ROUND_UP(cs_ringbuf_size, min_profiled_job_instrs * sizeof(u64));

drivers/gpu/drm/pl111/pl111_display.c

57

u32 cpp = DIV_ROUND_UP(priv->variant->fb_depth, 8);

drivers/gpu/drm/radeon/cik.c

3661

num_loops = DIV_ROUND_UP(size_in_bytes, 0x1fffff);

drivers/gpu/drm/radeon/cik.c

9346

radeon_crtc->lb_vblank_lead_lines = DIV_ROUND_UP(lb_size, mode->crtc_hdisplay);

drivers/gpu/drm/radeon/cik_sdma.c

594

num_loops = DIV_ROUND_UP(size_in_bytes, 0x1fffff);

drivers/gpu/drm/radeon/evergreen.c

2285

radeon_crtc->lb_vblank_lead_lines = DIV_ROUND_UP(lb_size, mode->crtc_hdisplay);

drivers/gpu/drm/radeon/evergreen_dma.c

123

num_loops = DIV_ROUND_UP(size_in_dw, 0xfffff);

drivers/gpu/drm/radeon/r100.c

178

crtc_pitch = DIV_ROUND_UP(pitch_pixels * fb->format->cpp[0] * 8,

drivers/gpu/drm/radeon/r100.c

3664

rdev->mode_info.crtcs[0]->lb_vblank_lead_lines = DIV_ROUND_UP(lb_size, mode1->crtc_hdisplay);

drivers/gpu/drm/radeon/r100.c

3667

rdev->mode_info.crtcs[1]->lb_vblank_lead_lines = DIV_ROUND_UP(lb_size, mode2->crtc_hdisplay);

drivers/gpu/drm/radeon/r100.c

922

num_loops = DIV_ROUND_UP(num_gpu_pages, 8191);

drivers/gpu/drm/radeon/r200.c

98

num_loops = DIV_ROUND_UP(size, 0x1FFFFF);

drivers/gpu/drm/radeon/r600.c

2980

num_loops = DIV_ROUND_UP(size_in_bytes, 0x1fffff);

drivers/gpu/drm/radeon/r600_cs.c

221

return DIV_ROUND_UP(w, bw);

drivers/gpu/drm/radeon/r600_cs.c

235

return DIV_ROUND_UP(h, bh);

drivers/gpu/drm/radeon/r600_dma.c

459

num_loops = DIV_ROUND_UP(size_in_dw, 0xFFFE);

drivers/gpu/drm/radeon/radeon_display.c

1082

unsigned tmp = DIV_ROUND_UP(fb_div_min, fb_div);

drivers/gpu/drm/radeon/radeon_display.c

907

tmp = DIV_ROUND_UP(nom_min, *nom);

drivers/gpu/drm/radeon/radeon_display.c

914

tmp = DIV_ROUND_UP(den_min, *den);

drivers/gpu/drm/radeon/radeon_gem.c

844

DIV_ROUND_UP(args->bpp, 8), 0);

drivers/gpu/drm/radeon/radeon_legacy_crtc.c

468

crtc_pitch = DIV_ROUND_UP(pitch_pixels * target_fb->format->cpp[0] * 8,

drivers/gpu/drm/radeon/rs690.c

253

rdev->mode_info.crtcs[0]->lb_vblank_lead_lines = DIV_ROUND_UP(lb_size, mode1->crtc_hdisplay);

drivers/gpu/drm/radeon/rs690.c

256

rdev->mode_info.crtcs[1]->lb_vblank_lead_lines = DIV_ROUND_UP(lb_size, mode2->crtc_hdisplay);

drivers/gpu/drm/radeon/rv770_dma.c

58

num_loops = DIV_ROUND_UP(size_in_dw, 0xFFFF);

drivers/gpu/drm/radeon/si.c

2407

radeon_crtc->lb_vblank_lead_lines = DIV_ROUND_UP(lb_size, mode->crtc_hdisplay);

drivers/gpu/drm/radeon/si_dma.c

246

num_loops = DIV_ROUND_UP(size_in_bytes, 0xfffff);

drivers/gpu/drm/renesas/rcar-du/rcar_du_drv.h

92

#define RCAR_DU_MAX_GROUPS DIV_ROUND_UP(RCAR_DU_MAX_CRTCS, 2)

drivers/gpu/drm/renesas/rcar-du/rcar_du_group.c

311

index = rcdu->info->gen < 3 ? 0 : DIV_ROUND_UP(rcdu->num_crtcs, 2) - 1;

drivers/gpu/drm/renesas/rcar-du/rcar_du_kms.c

898

num_groups = DIV_ROUND_UP(rcdu->num_crtcs, 2);

drivers/gpu/drm/renesas/rcar-du/rcar_lvds.c

196

m_min = max_t(unsigned int, 1, DIV_ROUND_UP(fin, 24000000));

drivers/gpu/drm/renesas/rcar-du/rcar_lvds.c

213

n_min = max_t(unsigned int, 60, DIV_ROUND_UP(900000000, fpfd));

drivers/gpu/drm/renesas/rz-du/rzg2l_du_kms.c

184

unsigned int min_pitch = DIV_ROUND_UP(args->width * args->bpp, 8);

drivers/gpu/drm/rockchip/dw-mipi-dsi-rockchip.c

410

return DIV_ROUND_UP(ns * dsi->lane_mbps / 8, 1000);

drivers/gpu/drm/rockchip/dw-mipi-dsi-rockchip.c

418

return DIV_ROUND_UP(ns * dsi->lane_mbps, 1000);

drivers/gpu/drm/rockchip/dw-mipi-dsi-rockchip.c

585

mpclk = DIV_ROUND_UP(mode->clock, MSEC_PER_SEC);

drivers/gpu/drm/rockchip/dw-mipi-dsi-rockchip.c

611

min_prediv = DIV_ROUND_UP(fin, 40 * USEC_PER_SEC);

drivers/gpu/drm/rockchip/dw-mipi-dsi-rockchip.c

650

dsi->lane_mbps = DIV_ROUND_UP(best_freq, USEC_PER_SEC);

drivers/gpu/drm/rockchip/rockchip_drm_vop.c

1017

VOP_WIN_SET(vop, win, uv_vir, DIV_ROUND_UP(fb->pitches[1], 4));

drivers/gpu/drm/rockchip/rockchip_drm_vop.c

1247

adjusted_mode->clock = DIV_ROUND_UP(rate, 1000);

drivers/gpu/drm/rockchip/rockchip_drm_vop.c

996

VOP_WIN_SET(vop, win, yrgb_vir, DIV_ROUND_UP(fb->pitches[0], 4));

drivers/gpu/drm/rockchip/rockchip_drm_vop.h

375

act_height = DIV_ROUND_UP(src_h, vskiplines);

drivers/gpu/drm/rockchip/rockchip_drm_vop2.c

1351

vop2_win_write(win, VOP2_WIN_YRGB_VIR, DIV_ROUND_UP(fb->pitches[0], 4));

drivers/gpu/drm/rockchip/rockchip_drm_vop2.c

1371

vop2_win_write(win, VOP2_WIN_UV_VIR, DIV_ROUND_UP(fb->pitches[1], 4));

drivers/gpu/drm/rockchip/rockchip_drm_vop2.c

541

fac = DIV_ROUND_UP(src << shift, dst) - 1;

drivers/gpu/drm/sitronix/st7571.c

165

dst_pitch = DIV_ROUND_UP(drm_rect_width(rect), 8);

drivers/gpu/drm/sitronix/st7571.c

190

dst_pitch = DIV_ROUND_UP(drm_rect_width(rect), 4);

drivers/gpu/drm/sitronix/st7920.c

330

dst_pitch = DIV_ROUND_UP(drm_rect_width(rect), 8);

drivers/gpu/drm/solomon/ssd130x.c

1016

dst_pitch = DIV_ROUND_UP(drm_rect_width(rect), 8);

drivers/gpu/drm/solomon/ssd130x.c

1485

unsigned int pages = DIV_ROUND_UP(ssd130x->height, SSD130X_PAGE_HEIGHT);

drivers/gpu/drm/solomon/ssd130x.c

1506

unsigned int columns = DIV_ROUND_UP(ssd130x->width, SSD132X_SEGMENT_WIDTH);

drivers/gpu/drm/solomon/ssd130x.c

738

unsigned int line_length = DIV_ROUND_UP(width, 8);

drivers/gpu/drm/solomon/ssd130x.c

741

unsigned int pages = DIV_ROUND_UP(height, page_height);

drivers/gpu/drm/solomon/ssd130x.c

843

unsigned int columns = DIV_ROUND_UP(width, segment_width);

drivers/gpu/drm/solomon/ssd130x.c

935

unsigned int pages = DIV_ROUND_UP(ssd130x->height, SSD130X_PAGE_HEIGHT);

drivers/gpu/drm/solomon/ssd130x.c

976

unsigned int columns = DIV_ROUND_UP(ssd130x->width, SSD132X_SEGMENT_WIDTH);

drivers/gpu/drm/sprd/megacores_pll.c

238

val[CLK] = DIV_ROUND_UP(range[L] * (factor << 1), t_byteck) - 2;

drivers/gpu/drm/sprd/megacores_pll.c

246

val[CLK] = DIV_ROUND_UP(AVERAGE(range[L], range[H]), t_half_byteck) - 1;

drivers/gpu/drm/sprd/megacores_pll.c

250

val[DATA] = DIV_ROUND_UP(AVERAGE(range[L], range[H]), t_half_byteck) - 1;

drivers/gpu/drm/sprd/megacores_pll.c

256

val[CLK] = DIV_ROUND_UP(range[L] * factor + (tmp & 0xffff)

drivers/gpu/drm/sprd/megacores_pll.c

259

val[DATA] = DIV_ROUND_UP(range[L] * factor

drivers/gpu/drm/sprd/megacores_pll.c

267

val[CLK] = DIV_ROUND_UP(range[L] * factor - constant, t_half_byteck);

drivers/gpu/drm/sprd/megacores_pll.c

269

val[DATA] = DIV_ROUND_UP(range[L] * 3 / 2 - constant, t_half_byteck) - 2;

drivers/gpu/drm/sprd/megacores_pll.c

275

val[CLK] = DIV_ROUND_UP(range[L] * factor, t_byteck) - 2;

drivers/gpu/drm/sprd/megacores_pll.c

282

val[CLK] = DIV_ROUND_UP(range[L] * factor, t_byteck) - 2;

drivers/gpu/drm/sprd/sprd_dsi.c

387

DIV_ROUND_UP((ns) * (byte_clk), 1000000)

drivers/gpu/drm/sprd/sprd_dsi.c

409

div = DIV_ROUND_UP(byte_clk, dsi->slave->lp_rate);

drivers/gpu/drm/sti/sti_hqvdp.c

746

inv_zy = DIV_ROUND_UP(src_h, dst_h);

drivers/gpu/drm/stm/drv.c

48

unsigned int min_pitch = DIV_ROUND_UP(args->width * args->bpp, 8);

drivers/gpu/drm/stm/dw_mipi_dsi-stm.c

468

#define DSI_PHY_DELAY(fp, vp, mbps) DIV_ROUND_UP((fp) * (mbps) + 1000 * (vp), 8000)

drivers/gpu/drm/stm/dw_mipi_dsi-stm.c

548

dsi_short_packet_size_px = DIV_ROUND_UP(4 * BITS_PER_BYTE, bpp);

drivers/gpu/drm/stm/dw_mipi_dsi-stm.c

577

delay_to_lp = DIV_ROUND_UP((dphy_timing.data_hs2lp + dphy_timing.data_lp2hs) *

drivers/gpu/drm/sun4i/sun4i_drv.c

40

args->pitch = ALIGN(DIV_ROUND_UP(args->width * args->bpp, 8), 2);

drivers/gpu/drm/sun4i/sun4i_frontend.c

511

chroma_width = DIV_ROUND_UP(luma_width, fb->format->hsub);

drivers/gpu/drm/sun4i/sun4i_frontend.c

512

chroma_height = DIV_ROUND_UP(luma_height, fb->format->vsub);

drivers/gpu/drm/sun4i/sun6i_mipi_dsi.c

903

regmap_bulk_write(dsi->regs, SUN6I_DSI_CMD_TX_REG(1), bounce, DIV_ROUND_UP(len, 4));

drivers/gpu/drm/tegra/dc.c

1891

rate = DIV_ROUND_UP(clk_get_rate(dc->clk) * 2, state->div + 2);

drivers/gpu/drm/tegra/dp.c

436

DIV_ROUND_UP(lanes, 2));

drivers/gpu/drm/tegra/dpaux.c

114

for (i = 0; i < DIV_ROUND_UP(size, 4); i++) {

drivers/gpu/drm/tegra/dpaux.c

98

for (i = 0; i < DIV_ROUND_UP(size, 4); i++) {

drivers/gpu/drm/tegra/dsi.c

601

delay = DIV_ROUND_UP(delay * mul, div * lanes);

drivers/gpu/drm/tegra/dsi.c

605

bclk = DIV_ROUND_UP(mode->htotal * mul, div * lanes);

drivers/gpu/drm/tegra/dsi.c

606

bclk_ganged = DIV_ROUND_UP(bclk * lanes / 2, lanes);

drivers/gpu/drm/tegra/dsi.c

992

plld = DIV_ROUND_UP(state->bclk * 8, USEC_PER_SEC) * USEC_PER_SEC;

drivers/gpu/drm/tegra/fbdev.c

84

bytes_per_pixel = DIV_ROUND_UP(sizes->surface_bpp, 8);

drivers/gpu/drm/tegra/plane.c

272

avg_bandwidth = DIV_ROUND_UP(avg_bandwidth * bpp, 8) + 999;

drivers/gpu/drm/tegra/plane.c

276

peak_bandwidth = DIV_ROUND_UP(crtc_state->adjusted_mode.clock * bpp, 8);

drivers/gpu/drm/tests/drm_framebuffer_test.c

218

.handles = { 1, 1, 1 }, .pitches = { MAX_WIDTH, DIV_ROUND_UP(MAX_WIDTH, 2),

drivers/gpu/drm/tests/drm_framebuffer_test.c

219

DIV_ROUND_UP(MAX_WIDTH, 2) },

drivers/gpu/drm/tests/drm_framebuffer_test.c

224

.handles = { 1, 1, 1 }, .pitches = { MAX_WIDTH, DIV_ROUND_UP(MAX_WIDTH, 2) - 1,

drivers/gpu/drm/tests/drm_framebuffer_test.c

225

DIV_ROUND_UP(MAX_WIDTH, 2) },

drivers/gpu/drm/tests/drm_framebuffer_test.c

230

.handles = { 1, 1, 1 }, .pitches = { MAX_WIDTH, DIV_ROUND_UP(MAX_WIDTH, 2) + 1,

drivers/gpu/drm/tests/drm_framebuffer_test.c

231

DIV_ROUND_UP(MAX_WIDTH, 2) + 7 },

drivers/gpu/drm/tests/drm_framebuffer_test.c

238

.pitches = { MAX_WIDTH, DIV_ROUND_UP(MAX_WIDTH, 2) + 1,

drivers/gpu/drm/tests/drm_framebuffer_test.c

239

DIV_ROUND_UP(MAX_WIDTH, 2) + 7 },

drivers/gpu/drm/tests/drm_framebuffer_test.c

246

.pitches = { MAX_WIDTH, DIV_ROUND_UP(MAX_WIDTH, 2), DIV_ROUND_UP(MAX_WIDTH, 2) },

drivers/gpu/drm/tests/drm_framebuffer_test.c

254

.pitches = { MAX_WIDTH, DIV_ROUND_UP(MAX_WIDTH, 2), DIV_ROUND_UP(MAX_WIDTH, 2) },

drivers/gpu/drm/tests/drm_framebuffer_test.c

262

.pitches = { MAX_WIDTH, DIV_ROUND_UP(MAX_WIDTH, 2), DIV_ROUND_UP(MAX_WIDTH, 2) },

drivers/gpu/drm/tests/drm_framebuffer_test.c

270

.pitches = { MAX_WIDTH, DIV_ROUND_UP(MAX_WIDTH, 2), DIV_ROUND_UP(MAX_WIDTH, 2) },

drivers/gpu/drm/tests/drm_framebuffer_test.c

278

.pitches = { MAX_WIDTH, DIV_ROUND_UP(MAX_WIDTH, 2), DIV_ROUND_UP(MAX_WIDTH, 2) },

drivers/gpu/drm/tests/drm_framebuffer_test.c

286

.pitches = { MAX_WIDTH, DIV_ROUND_UP(MAX_WIDTH, 2), DIV_ROUND_UP(MAX_WIDTH, 2) },

drivers/gpu/drm/tests/drm_panic_test.c

128

npages = DIV_ROUND_UP(fb_size, PAGE_SIZE);

drivers/gpu/drm/tidss/tidss_dispc.c

1880

sp->xinc = DIV_ROUND_UP(DIV_ROUND_UP(sp->in_w,

drivers/gpu/drm/tidss/tidss_dispc.c

1931

sp->yinc = DIV_ROUND_UP(DIV_ROUND_UP(sp->in_h,

drivers/gpu/drm/tiny/panel-mipi-dbi.c

379

buf_size = DIV_ROUND_UP(mode.hdisplay * mode.vdisplay * bpp, 8);

drivers/gpu/drm/ttm/ttm_pool.c

1039

num_pages = DIV_ROUND_UP(num_pages, 2);

drivers/gpu/drm/v3d/v3d_sched.c

452

num_batches = DIV_ROUND_UP(indirect_csd->wg_size, 16) *

drivers/gpu/drm/vc4/vc4_drv.c

69

int min_pitch = DIV_ROUND_UP(args->width * args->bpp, 8);

drivers/gpu/drm/vc4/vc4_dsi.c

1024

ui_ns = DIV_ROUND_UP(500000000, hs_clock);

drivers/gpu/drm/vc4/vc4_dsi.c

789

return roundup(ui + DIV_ROUND_UP(ns, ui_ns), 8);

drivers/gpu/drm/vc4/vc4_dsi.c

798

return DIV_ROUND_UP(ns, ESC_TIME_NS);

drivers/gpu/drm/vc4/vc4_plane.c

777

lines = DIV_ROUND_UP(words, 128 / info->hsub);

drivers/gpu/drm/vc4/vc4_plane.c

911

vscale_factor = DIV_ROUND_UP(vc4_state->src_h[i] >> 16,

drivers/gpu/drm/vc4/vc4_render_cl.c

107

(DIV_ROUND_UP(exec->args->width, 32) * y + x);

drivers/gpu/drm/vc4/vc4_render_cl.c

390

u32 render_tiles_stride = DIV_ROUND_UP(exec->args->width, 32);

drivers/gpu/drm/virtio/virtgpu_vq.c

319

*sg_ents = DIV_ROUND_UP(size, PAGE_SIZE);

drivers/gpu/drm/vmwgfx/vmwgfx_mob.c

378

data_size = DIV_ROUND_UP(data_size, PAGE_SIZE);

drivers/gpu/drm/vmwgfx/vmwgfx_mob.c

461

unsigned long num_pt_pages = DIV_ROUND_UP(pt_size, PAGE_SIZE);

drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c

308

res_end = DIV_ROUND_UP(res_end, PAGE_SIZE);

drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c

344

res_end = DIV_ROUND_UP(res_end, PAGE_SIZE);

drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c

386

res_end = DIV_ROUND_UP(res_end, PAGE_SIZE);

drivers/gpu/drm/xe/xe_bo.c

491

extra_pages = DIV_ROUND_UP(xe_device_ccs_bytes(xe, xe_bo_size(bo)),

drivers/gpu/drm/xe/xe_gt_mcr.c

386

return DIV_ROUND_UP(max_subslices, max_slices);

drivers/gpu/drm/xe/xe_guc_log.c

129

snapshot->num_chunks = DIV_ROUND_UP(snapshot->size, GUC_LOG_CHUNK_SIZE);

drivers/gpu/drm/xe/xe_guc_log.c

283

lfd.data_count = DIV_ROUND_UP(data_len, sizeof(u32));

drivers/gpu/drm/xe/xe_guc_log.c

339

lfd.data_count = DIV_ROUND_UP(section_len + info_len, sizeof(u32));

drivers/gpu/drm/xe/xe_guc_log.c

480

lfd.data_count = DIV_ROUND_UP(data_len, sizeof(u32));

drivers/gpu/drm/xe/xe_guc_log.c

535

lfd.data_count = DIV_ROUND_UP(entry->buf_size, sizeof(u32));

drivers/gpu/drm/xe/xe_hwmon.c

143

u32 data[DIV_ROUND_UP(TEMP_LIMIT_MAX, sizeof(u32))];

drivers/gpu/drm/xe/xe_hwmon.c

787

for (i = 0; i < DIV_ROUND_UP(TEMP_LIMIT_MAX, sizeof(u32)); i++) {

drivers/gpu/drm/xe/xe_migrate.c

1784

u32 num_cmds = DIV_ROUND_UP(updates[j].qwords,

drivers/gpu/drm/xe/xe_migrate.c

1810

u32 num_units = DIV_ROUND_UP(num_updates,

drivers/gpu/drm/xe/xe_migrate.c

2034

ptes = DIV_ROUND_UP(size, gpu_page_size);

drivers/gpu/drm/xe/xe_migrate.c

2085

for (i = 0; i < DIV_ROUND_UP(size, PAGE_SIZE); i += incr)

drivers/gpu/drm/xe/xe_migrate.c

2131

unsigned long npages = DIV_ROUND_UP(len + sram_offset, PAGE_SIZE);

drivers/gpu/drm/xe/xe_migrate.c

2287

unsigned long i, npages = DIV_ROUND_UP(len, PAGE_SIZE);

drivers/gpu/drm/xe/xe_migrate.c

2304

unsigned long i, npages = DIV_ROUND_UP(len, PAGE_SIZE);

drivers/gpu/drm/xe/xe_migrate.c

588

cmds += 3 * DIV_ROUND_UP(num_4k_pages, MAX_PTE_PER_SDI);

drivers/gpu/drm/xe/xe_migrate.c

620

ptes = DIV_ROUND_UP(size, XE_PAGE_SIZE);

drivers/gpu/drm/xe/xe_migrate.c

678

num_pages = DIV_ROUND_UP(size, XE_PAGE_SIZE);

drivers/gpu/drm/xe/xe_migrate.c

685

num_ccs_blks = DIV_ROUND_UP(xe_device_ccs_bytes(gt_to_xe(gt), size),

drivers/gpu/drm/xe/xe_oa.c

692

count += DIV_ROUND_UP(num_regs, MI_LOAD_REGISTER_IMM_MAX_REGS);

drivers/gpu/drm/xen/xen_drm_front.c

182

buf_cfg.num_pages = DIV_ROUND_UP(size, PAGE_SIZE);

drivers/gpu/drm/xen/xen_drm_front.c

418

args->pitch = DIV_ROUND_UP(args->width * args->bpp, 8);

drivers/gpu/drm/xen/xen_drm_front_gem.c

175

xen_obj->num_pages = DIV_ROUND_UP(size, PAGE_SIZE);

drivers/gpu/drm/xen/xen_drm_front_gem.c

49

xen_obj->num_pages = DIV_ROUND_UP(buf_size, PAGE_SIZE);

drivers/gpu/drm/xlnx/zynqmp_dp.c

1156

w = DIV_ROUND_UP(4 * rate, 1000 * 1000 * 10 * 8) * 8;

drivers/gpu/host1x/hw/intr_hw.c

36

for (i = irq_data->offset; i < DIV_ROUND_UP(host->info->nb_pts, 32);

drivers/gpu/host1x/hw/intr_hw.c

63

for (i = irq_data->offset; i < DIV_ROUND_UP(host->info->nb_pts, 64);

drivers/gpu/host1x/hw/intr_hw.c

80

for (i = 0; i < DIV_ROUND_UP(host->info->nb_pts, 32); ++i) {

drivers/gpu/host1x/intr.c

144

err = host1x_hw_intr_init_host_sync(host, DIV_ROUND_UP(hz, 1000000));

drivers/gpu/ipu-v3/ipu-image-convert.c

1155

(DIV_ROUND_UP(last_output * resize_coeff_h, 8192) + 1)

drivers/gpu/ipu-v3/ipu-image-convert.c

1212

(DIV_ROUND_UP(last_output * resize_coeff_v, 8192) + 1)

drivers/gpu/ipu-v3/ipu-pre.c

176

pre->cur.safe_window_end = DIV_ROUND_UP(pre->cur.height, 4) - 1;

drivers/hid/bpf/hid_bpf_dispatch.c

249

alloc_size = DIV_ROUND_UP(max_report_len, 64) * 64;

drivers/hid/hid-sensor-hub.c

262

report_size = DIV_ROUND_UP(report->field[field_index]->report_size,

drivers/hid/intel-ish-hid/ishtp/loader.c

434

fragment_size = PFN_ALIGN(DIV_ROUND_UP(ish_fw->size, FRAGMENT_MAX_NUM));

drivers/hid/intel-ish-hid/ishtp/loader.c

436

fragment_count = DIV_ROUND_UP(ish_fw->size, fragment_size);

drivers/hid/intel-thc-hid/intel-thc/intel-thc-dev.c

1672

val |= FIELD_PREP(THC_M_PRT_SPI_ICRRD_OPCODE_I2C_INTERVAL, DIV_ROUND_UP(delay_us, 10));

drivers/hid/intel-thc-hid/intel-thc/intel-thc-dma.c

452

*nent = DIV_ROUND_UP(mes_len, THC_MIN_BYTES_PER_SG_LIST_ENTRY);

drivers/hv/mshv_root_main.c

1469

bitmap_buf_sz = DIV_ROUND_UP(args.page_count, 8);

drivers/hwmon/amc6821.c

618

val = clamp_val(val, DIV_ROUND_UP(temps[0], 4) * 4000, 124000);

drivers/hwmon/bt1-pvt.c

149

return DIV_ROUND_UP(temp, PVT_TRIM_STEP);

drivers/hwmon/dell-smm-hwmon.c

1266

data->i8k_pwm_mult = DIV_ROUND_UP(255, data->i8k_fan_max);

drivers/hwmon/fschmd.c

721

data->watchdog_preset = DIV_ROUND_UP(timeout, resolution);

drivers/hwmon/ftsteutates.c

239

timeout = DIV_ROUND_UP(timeout, 60) * 60;

drivers/hwmon/gpio-fan.c

214

speed_index = DIV_ROUND_UP(pwm * (fan_data->num_speed - 1), 255);

drivers/hwmon/max16065.c

541

for (i = 0; i < DIV_ROUND_UP(data->num_adc, 4); i++) {

drivers/hwmon/pwm-fan.c

222

state->duty_cycle = DIV_ROUND_UP(pwm * (period - 1), MAX_PWM);

drivers/hwmon/pwm-fan.c

229

state->duty_cycle = DIV_ROUND_UP(pwm * (period - 1), MAX_PWM);

drivers/hwmon/sch56xx-common.c

390

data->watchdog_preset = DIV_ROUND_UP(timeout, resolution);

drivers/hwmon/w83793.c

1193

mtimeout = DIV_ROUND_UP(timeout, 60);

drivers/hwtracing/coresight/coresight-catu.c

271

nr_tpages = DIV_ROUND_UP(size, CATU_PAGES_PER_SYSPAGE * SZ_1M);

drivers/hwtracing/coresight/coresight-tmc-etr.c

361

int npages = DIV_ROUND_UP(size, PAGE_SIZE);

drivers/hwtracing/coresight/coresight-tmc-etr.c

580

nr_tpages = DIV_ROUND_UP(nr_entries, ETR_SG_PTRS_PER_SYSPAGE);

drivers/hwtracing/intel_th/msu-sink.c

62

nents = DIV_ROUND_UP(size, PAGE_SIZE);

drivers/i2c/busses/i2c-aspeed.c

915

divisor = DIV_ROUND_UP(bus->parent_clk_frequency, bus->bus_frequency);

drivers/i2c/busses/i2c-at91-master.c

113

filter_width = DIV_ROUND_UP(t->digital_filter_width_ns

drivers/i2c/busses/i2c-at91-master.c

77

div = max(0, (int)DIV_ROUND_UP(clk_get_rate(dev->clk),

drivers/i2c/busses/i2c-at91-master.c

95

hold = DIV_ROUND_UP(t->sda_hold_ns

drivers/i2c/busses/i2c-bcm2835.c

145

req->rate = DIV_ROUND_UP(req->best_parent_rate, divider);

drivers/i2c/busses/i2c-bcm2835.c

156

return DIV_ROUND_UP(parent_rate, divider);

drivers/i2c/busses/i2c-bcm2835.c

93

u32 divider = DIV_ROUND_UP(parent_rate, rate);

drivers/i2c/busses/i2c-cadence.c

1273

div_b = DIV_ROUND_UP(input_clk, 22 * fscl * (div_a + 1));

drivers/i2c/busses/i2c-digicolor.c

267

clocktime = DIV_ROUND_UP(clk_rate, 64 * i2c->frequency);

drivers/i2c/busses/i2c-diolan-u2c.c

65

#define U2C_I2C_SPEED(f) ((DIV_ROUND_UP(1000000, (f)) - 10) / 2 + 1)

drivers/i2c/busses/i2c-img-scb.c

1247

data = DIV_ROUND_UP(timing.tckl, clk_period);

drivers/i2c/busses/i2c-img-scb.c

1264

tsdh = DIV_ROUND_UP(timing.tsdh, clk_period);

drivers/i2c/busses/i2c-imx-lpi2c.c

327

clkhi = DIV_ROUND_UP(clk_cycle, I2C_CLK_RATIO + 1);

drivers/i2c/busses/i2c-imx-lpi2c.c

740

cmd_num = DIV_ROUND_UP(rx_remain, CHUNK_DATA);

drivers/i2c/busses/i2c-imx-lpi2c.c

938

cmd_num = DIV_ROUND_UP(dma->dma_len, CHUNK_DATA);

drivers/i2c/busses/i2c-imx.c

650

div = DIV_ROUND_UP(i2c_clk_rate, i2c_imx->bitrate);

drivers/i2c/busses/i2c-imx.c

668

i2c_imx->disable_delay = DIV_ROUND_UP(500000U * i2c_clk_div[i].div,

drivers/i2c/busses/i2c-meson.c

152

div_h = DIV_ROUND_UP(clk_rate, freq);

drivers/i2c/busses/i2c-meson.c

153

div_l = DIV_ROUND_UP(div_h, 4);

drivers/i2c/busses/i2c-meson.c

154

div_h = DIV_ROUND_UP(div_h, 2) - FILTER_DELAY;

drivers/i2c/busses/i2c-meson.c

156

div_h = DIV_ROUND_UP(clk_rate * 2, freq * 5) - FILTER_DELAY;

drivers/i2c/busses/i2c-meson.c

157

div_l = DIV_ROUND_UP(clk_rate * 3, freq * 5 * 2);

drivers/i2c/busses/i2c-meson.c

192

div = DIV_ROUND_UP(clk_rate, freq);

drivers/i2c/busses/i2c-meson.c

194

div = DIV_ROUND_UP(div, 4);

drivers/i2c/busses/i2c-mt65xx.c

722

su_sta_cnt = DIV_ROUND_UP(spec->min_su_sta_ns +

drivers/i2c/busses/i2c-mt65xx.c

727

low_cnt = DIV_ROUND_UP(spec->min_low_ns, sample_ns);

drivers/i2c/busses/i2c-mt65xx.c

744

sda_min = DIV_ROUND_UP(spec->min_su_dat_ns, sample_ns);

drivers/i2c/busses/i2c-mt65xx.c

821

opt_div = DIV_ROUND_UP(clk_src >> 1, target_speed);

drivers/i2c/busses/i2c-mt65xx.c

832

step_cnt = DIV_ROUND_UP(opt_div + clk_div_restri, sample_cnt);

drivers/i2c/busses/i2c-mxs.c

707

divider = DIV_ROUND_UP(clk, speed);

drivers/i2c/busses/i2c-mxs.c

749

leadin = DIV_ROUND_UP(600 * (clk / 1000000), 1000);

drivers/i2c/busses/i2c-mxs.c

750

bus_free = DIV_ROUND_UP(1300 * (clk / 1000000), 1000);

drivers/i2c/busses/i2c-mxs.c

755

leadin = DIV_ROUND_UP(4700 * (clk / 1000000), 1000);

drivers/i2c/busses/i2c-mxs.c

756

bus_free = DIV_ROUND_UP(4700 * (clk / 1000000), 1000);

drivers/i2c/busses/i2c-nomadik.c

426

ns = DIV_ROUND_UP(HZ_PER_GHZ, i2c_clk);

drivers/i2c/busses/i2c-nomadik.c

430

slsu = DIV_ROUND_UP(100, ns); /* Fast */

drivers/i2c/busses/i2c-nomadik.c

433

slsu = DIV_ROUND_UP(10, ns); /* High */

drivers/i2c/busses/i2c-nomadik.c

437

slsu = DIV_ROUND_UP(250, ns); /* Standard */

drivers/i2c/busses/i2c-nomadik.c

462

brcr = DIV_ROUND_UP(i2c_clk, priv->clk_freq * div);

drivers/i2c/busses/i2c-npcm7xx.c

2056

#define clk_coef(freq, mul) DIV_ROUND_UP((freq) * (mul), 1000000)

drivers/i2c/busses/i2c-owl.c

162

val = DIV_ROUND_UP(i2c_dev->clk_rate, i2c_dev->bus_freq * 16);

drivers/i2c/busses/i2c-pasemi-platform.c

32

data->smbus.clk_div = DIV_ROUND_UP(clk_rate, 16 * frequency);

drivers/i2c/busses/i2c-qup.c

527

qup->blk.count = DIV_ROUND_UP(msg->len, qup->blk_xfer_limit);

drivers/i2c/busses/i2c-rcar.c

353

scgd = DIV_ROUND_UP(ick, t.bus_freq_hz ?: 1);

drivers/i2c/busses/i2c-rcar.c

354

scgd = DIV_ROUND_UP(scgd - 20 - round, 8);

drivers/i2c/busses/i2c-rcar.c

381

x = DIV_ROUND_UP(rate, t.bus_freq_hz ?: 1);

drivers/i2c/busses/i2c-rcar.c

382

x = DIV_ROUND_UP(x - 8 - 2 * priv->smd - round, sum_ratio);

drivers/i2c/busses/i2c-riic.c

386

total_ticks = DIV_ROUND_UP(rate, t->bus_freq_hz ?: 1);

drivers/i2c/busses/i2c-riic.c

397

total_ticks = DIV_ROUND_UP(total_ticks, 2);

drivers/i2c/busses/i2c-rk3x.c

616

min_high_ns = max(min_high_ns, DIV_ROUND_UP(

drivers/i2c/busses/i2c-rk3x.c

618

min_high_ns = max(min_high_ns, DIV_ROUND_UP(

drivers/i2c/busses/i2c-rk3x.c

627

clk_rate_khz = DIV_ROUND_UP(clk_rate, 1000);

drivers/i2c/busses/i2c-rk3x.c

634

min_total_div = DIV_ROUND_UP(clk_rate_khz, scl_rate_khz * 8);

drivers/i2c/busses/i2c-rk3x.c

637

min_low_div = DIV_ROUND_UP(clk_rate_khz * min_low_ns, 8 * 1000000);

drivers/i2c/busses/i2c-rk3x.c

638

min_high_div = DIV_ROUND_UP(clk_rate_khz * min_high_ns, 8 * 1000000);

drivers/i2c/busses/i2c-rk3x.c

673

ideal_low_div = DIV_ROUND_UP(clk_rate_khz * min_low_ns,

drivers/i2c/busses/i2c-rk3x.c

781

clk_rate_khz = DIV_ROUND_UP(clk_rate, 1000);

drivers/i2c/busses/i2c-rk3x.c

783

min_total_div = DIV_ROUND_UP(clk_rate_khz, scl_rate_khz * 8);

drivers/i2c/busses/i2c-rk3x.c

786

min_high_div = DIV_ROUND_UP(clk_rate_khz * min_high_ns, 8 * 1000000);

drivers/i2c/busses/i2c-rk3x.c

789

min_low_div = DIV_ROUND_UP(clk_rate_khz * min_low_ns, 8 * 1000000);

drivers/i2c/busses/i2c-rk3x.c

821

extra_low_div = DIV_ROUND_UP(min_low_div * extra_div,

drivers/i2c/busses/i2c-rk3x.c

833

max_hold_data_ns = DIV_ROUND_UP((sda_update_cfg

drivers/i2c/busses/i2c-rk3x.c

836

min_setup_data_ns = DIV_ROUND_UP(((8 - sda_update_cfg)

drivers/i2c/busses/i2c-rk3x.c

846

stp_sta_cfg = DIV_ROUND_UP(clk_rate_khz * min_setup_start_ns

drivers/i2c/busses/i2c-rk3x.c

851

stp_sto_cfg = DIV_ROUND_UP(clk_rate_khz * min_setup_stop_ns

drivers/i2c/busses/i2c-s3c2410.c

886

sda_delay = DIV_ROUND_UP(sda_delay, 1000000);

drivers/i2c/busses/i2c-s3c2410.c

887

sda_delay = DIV_ROUND_UP(sda_delay, 5);

drivers/i2c/busses/i2c-sh_mobile.c

298

pd->iccl = DIV_ROUND_UP(clks_per_cycle * 5 / 9 - 1, pd->clks_per_count);

drivers/i2c/busses/i2c-sh_mobile.c

299

pd->icch = DIV_ROUND_UP(clks_per_cycle * 4 / 9 - 5, pd->clks_per_count);

drivers/i2c/busses/i2c-stm32f4.c

157

freq = DIV_ROUND_UP(i2c_dev->parent_rate, HZ_TO_MHZ);

drivers/i2c/busses/i2c-stm32f4.c

193

u32 freq = DIV_ROUND_UP(i2c_dev->parent_rate, HZ_TO_MHZ);

drivers/i2c/busses/i2c-stm32f4.c

266

val = DIV_ROUND_UP(i2c_dev->parent_rate, I2C_MAX_FAST_MODE_FREQ * 3);

drivers/i2c/busses/i2c-synquacer.c

174

return DIV_ROUND_UP((bit_count * 9 + num * 10) * 3, 200) + 10;

drivers/i2c/busses/i2c-synquacer.c

24

ndelay(DIV_ROUND_UP(DIV_ROUND_UP(HZ_PER_GHZ, rate), n) + 10)

drivers/i2c/busses/i2c-synquacer.c

352

udelay(DIV_ROUND_UP(2 * 1000, i2c->speed_khz));

drivers/i2c/busses/i2c-synquacer.c

71

DIV_ROUND_UP(DIV_ROUND_UP((rate), I2C_MAX_STANDARD_MODE_FREQ) - 2, 2)

drivers/i2c/busses/i2c-synquacer.c

74

DIV_ROUND_UP((DIV_ROUND_UP((rate), I2C_MAX_FAST_MODE_FREQ) - 2) * 2, 3)

drivers/i2c/busses/i2c-tegra.c

882

udelay(DIV_ROUND_UP(2 * 1000000, i2c_dev->timings.bus_freq_hz));

drivers/i2c/busses/i2c-xiic.c

419

clk_in_mhz = DIV_ROUND_UP(i2c->input_clk, 1000000);

drivers/i2c/busses/i2c-xiic.c

444

reg_val = (DIV_ROUND_UP(i2c->input_clk, 2 * i2c->i2c_clk)) - 7;

drivers/i2c/busses/i2c-xlp9xx.c

312

prescale = DIV_ROUND_UP(priv->ip_clk_hz, priv->clk_hz);

drivers/i3c/master/dw-i3c-master.c

1098

nrxwords += DIV_ROUND_UP(i2c_xfers[i].len, 4);

drivers/i3c/master/dw-i3c-master.c

1100

ntxwords += DIV_ROUND_UP(i2c_xfers[i].len, 4);

drivers/i3c/master/dw-i3c-master.c

1379

for (i = 0; i < DIV_ROUND_UP(len, 4); i++)

drivers/i3c/master/dw-i3c-master.c

571

core_period = DIV_ROUND_UP(1000000000, core_rate);

drivers/i3c/master/dw-i3c-master.c

573

hcnt = DIV_ROUND_UP(I3C_BUS_THIGH_MAX_NS, core_period) - 1;

drivers/i3c/master/dw-i3c-master.c

577

lcnt = DIV_ROUND_UP(core_rate, master->base.bus.scl_rate.i3c) - hcnt;

drivers/i3c/master/dw-i3c-master.c

595

DIV_ROUND_UP(I3C_BUS_TLOW_OD_MIN_NS, core_period), lcnt);

drivers/i3c/master/dw-i3c-master.c

600

lcnt = DIV_ROUND_UP(core_rate, I3C_BUS_SDR1_SCL_RATE) - hcnt;

drivers/i3c/master/dw-i3c-master.c

602

lcnt = DIV_ROUND_UP(core_rate, I3C_BUS_SDR2_SCL_RATE) - hcnt;

drivers/i3c/master/dw-i3c-master.c

604

lcnt = DIV_ROUND_UP(core_rate, I3C_BUS_SDR3_SCL_RATE) - hcnt;

drivers/i3c/master/dw-i3c-master.c

606

lcnt = DIV_ROUND_UP(core_rate, I3C_BUS_SDR4_SCL_RATE) - hcnt;

drivers/i3c/master/dw-i3c-master.c

624

core_period = DIV_ROUND_UP(1000000000, core_rate);

drivers/i3c/master/dw-i3c-master.c

626

lcnt = DIV_ROUND_UP(I3C_BUS_I2C_FMP_TLOW_MIN_NS, core_period);

drivers/i3c/master/dw-i3c-master.c

627

hcnt = DIV_ROUND_UP(core_rate, I3C_BUS_I2C_FM_PLUS_SCL_MAX_RATE) - lcnt;

drivers/i3c/master/dw-i3c-master.c

633

lcnt = DIV_ROUND_UP(I3C_BUS_I2C_FM_TLOW_MIN_NS, core_period);

drivers/i3c/master/dw-i3c-master.c

634

hcnt = DIV_ROUND_UP(core_rate, I3C_BUS_I2C_FM_SCL_MAX_RATE) - lcnt;

drivers/i3c/master/dw-i3c-master.c

938

nrxwords += DIV_ROUND_UP(i3c_xfers[i].len, 4);

drivers/i3c/master/dw-i3c-master.c

940

ntxwords += DIV_ROUND_UP(i3c_xfers[i].len, 4);

drivers/i3c/master/i3c-master-cdns.c

1101

i3c_lim_period = DIV_ROUND_UP(1000000000, master->i3c_scl_lim);

drivers/i3c/master/i3c-master-cdns.c

1102

ncycles = DIV_ROUND_UP(i3c_lim_period, pres_step);

drivers/i3c/master/i3c-master-cdns.c

1183

u8 thd_delay = DIV_ROUND_UP(master->devdata->thd_delay_ns,

drivers/i3c/master/i3c-master-cdns.c

1224

pres = DIV_ROUND_UP(sysclk_rate, (bus->scl_rate.i3c * 4)) - 1;

drivers/i3c/master/i3c-master-cdns.c

1248

ncycles = DIV_ROUND_UP(I3C_BUS_TLOW_OD_MIN_NS, pres_step) - 2;

drivers/i3c/master/i3c-master-cdns.c

750

rxslots += DIV_ROUND_UP(xfers[i].len, 4);

drivers/i3c/master/i3c-master-cdns.c

752

txslots += DIV_ROUND_UP(xfers[i].len, 4);

drivers/i3c/master/i3c-master-cdns.c

821

nrxwords += DIV_ROUND_UP(xfers[i].len, 4);

drivers/i3c/master/i3c-master-cdns.c

823

ntxwords += DIV_ROUND_UP(xfers[i].len, 4);

drivers/i3c/master/mipi-i3c-hci/pio.c

448

room = DIV_ROUND_UP(xfer->data_len, 4);

drivers/i3c/master/mipi-i3c-hci/pio.c

449

left = DIV_ROUND_UP(xfer->data_left, 4);

drivers/i3c/master/mipi-i3c-hci/pio.c

537

to_keep = DIV_ROUND_UP(expected, 4);

drivers/i3c/master/renesas-i3c.c

524

val = DIV_ROUND_UP(I3C_BUS_TBUF_MIXED_FM_MIN_NS,

drivers/i3c/master/renesas-i3c.c

528

val = DIV_ROUND_UP(I3C_BUS_TAVAL_MIN_NS,

drivers/i3c/master/renesas-i3c.c

532

val = DIV_ROUND_UP(I3C_BUS_TIDLE_MIN_NS,

drivers/i3c/master/renesas-i3c.c

556

i2c_total_ticks = DIV_ROUND_UP(i3c->rate, bus->scl_rate.i2c);

drivers/i3c/master/renesas-i3c.c

557

i3c_total_ticks = DIV_ROUND_UP(i3c->rate, bus->scl_rate.i3c);

drivers/i3c/master/renesas-i3c.c

569

pp_high_ticks = DIV_ROUND_UP(I3C_BUS_THIGH_MIXED_MAX_NS,

drivers/i3c/master/svc-i3c-master.c

721

odbaud = DIV_ROUND_UP(fclk_rate, bus->scl_rate.i2c * (2 + 2 * ppbaud)) - 1;

drivers/i3c/master/svc-i3c-master.c

763

fclk_period_ns = DIV_ROUND_UP(1000000000, fclk_rate);

drivers/i3c/master/svc-i3c-master.c

764

i2c_period_ns = DIV_ROUND_UP(1000000000, bus->scl_rate.i2c);

drivers/i3c/master/svc-i3c-master.c

772

ppbaud = DIV_ROUND_UP(fclk_rate / 2, i3c_scl_rate) - 1;

drivers/i3c/master/svc-i3c-master.c

782

odbaud = DIV_ROUND_UP(fclk_rate, SVC_I3C_QUICK_I2C_CLK * (1 + ppbaud)) - 2;

drivers/i3c/master/svc-i3c-master.c

795

i2cbaud = DIV_ROUND_UP(i2c_period_ns, od_low_period_ns) - 2;

drivers/i3c/master/svc-i3c-master.c

803

pplow = DIV_ROUND_UP(fclk_rate, i3c_scl_rate) - (2 + 2 * ppbaud);

drivers/i3c/master/svc-i3c-master.c

808

odbaud = DIV_ROUND_UP(fclk_rate, i2c_scl_rate * (2 + 2 * ppbaud)) - 1;

drivers/i3c/master/svc-i3c-master.c

811

i2cbaud = DIV_ROUND_UP(i2c_period_ns, od_low_period_ns) - 2;

drivers/iio/accel/adxl345_core.c

405

st->inact_time_ms = DIV_ROUND_UP(val_fract, MILLI);

drivers/iio/accel/adxl367.c

1039

val = val * 1000 + DIV_ROUND_UP(val2, 1000);

drivers/iio/accel/adxl372.c

897

raw_val = DIV_ROUND_UP(val * 1000000, ADXL372_USCALE);

drivers/iio/accel/adxl372.c

909

val_ms = val * 1000 + DIV_ROUND_UP(val2, 1000);

drivers/iio/accel/adxl380.c

1531

val_ms = val * 1000 + DIV_ROUND_UP(val2, 1000);

drivers/iio/adc/ad4170-4.c

1220

settling_time_ms = DIV_ROUND_UP(6291164 * MILLI, st->mclk_hz);

drivers/iio/adc/ad7280a.c

873

st->readback_delay_us = DIV_ROUND_UP(st->readback_delay_us, 1000);

drivers/iio/adc/ad7625.c

182

target = DIV_ROUND_UP(NSEC_PER_SEC, freq);

drivers/iio/adc/ad7768-1.c

597

dec_rate = DIV_ROUND_UP(dec_rate, 32) - 1;

drivers/iio/adc/at91-sama5d2_adc.c

2017

unsigned int pages = DIV_ROUND_UP(AT91_HWFIFO_MAX_SIZE *

drivers/iio/adc/at91-sama5d2_adc.c

2072

unsigned int pages = DIV_ROUND_UP(AT91_HWFIFO_MAX_SIZE *

drivers/iio/adc/at91_adc.c

896

tssctim = DIV_ROUND_UP(TOUCH_SCTIM_US * adc_clk_khz / 1000, 4);

drivers/iio/adc/ep93xx_adc.c

110

ep93xx_adc_delay(DIV_ROUND_UP(1000000, 925),

drivers/iio/adc/ep93xx_adc.c

111

DIV_ROUND_UP(1000000, 925));

drivers/iio/adc/ingenic-adc.c

332

div_main = DIV_ROUND_UP(parent_rate, 8000000);

drivers/iio/adc/ingenic-adc.c

341

div_10us = DIV_ROUND_UP(rate, 100000);

drivers/iio/adc/ingenic-adc.c

367

div_main = DIV_ROUND_UP(parent_rate, 200000);

drivers/iio/adc/ingenic-adc.c

376

div_10us = DIV_ROUND_UP(rate, 10000);

drivers/iio/adc/ingenic-adc.c

378

div_ms = DIV_ROUND_UP(rate, 1000);

drivers/iio/adc/lpc18xx_adc.c

176

clkdiv = DIV_ROUND_UP(rate, LPC18XX_ADC_CLK_TARGET);

drivers/iio/adc/mcp320x.c

407

adc->transfer[1].len = DIV_ROUND_UP(chip_info->resolution, 8);

drivers/iio/adc/spear_adc.c

110

count = DIV_ROUND_UP(apb_clk, val);

drivers/iio/adc/ti-ads1015.c

432

conv_time = DIV_ROUND_UP(USEC_PER_SEC, data_rate[dr_old]);

drivers/iio/adc/ti-ads1015.c

433

conv_time += DIV_ROUND_UP(USEC_PER_SEC, data_rate[dr]);

drivers/iio/adc/ti-ads1018.c

199

hz -= DIV_ROUND_UP(hz, 10);

drivers/iio/adc/ti-ads1018.c

202

return DIV_ROUND_UP(HZ_PER_MHZ, hz);

drivers/iio/adc/ti-ads1298.c

86

(DIV_ROUND_UP((x) * MICROHZ_PER_HZ, ADS1298_CLK_RATE_HZ))

drivers/iio/adc/ti-ads131e08.c

894

st->sdecode_delay_us = DIV_ROUND_UP(

drivers/iio/adc/ti-ads131e08.c

896

st->reset_delay_us = DIV_ROUND_UP(

drivers/iio/adc/ti-tsc2046.c

231

bit_count = DIV_ROUND_UP(time * NSEC_PER_USEC, priv->time_per_bit_ns);

drivers/iio/adc/ti-tsc2046.c

232

sample_count = DIV_ROUND_UP(bit_count, TI_TSC2046_SAMPLE_BITS);

drivers/iio/adc/ti-tsc2046.c

339

return DIV_ROUND_UP(val_normalized, max_count - count_skip);

drivers/iio/adc/ti-tsc2046.c

399

return DIV_ROUND_UP(val_normalized, valid_count);

drivers/iio/adc/ti-tsc2046.c

668

priv->time_per_bit_ns = DIV_ROUND_UP(NSEC_PER_SEC,

drivers/iio/buffer/industrialio-buffer-dma.c

332

size = DIV_ROUND_UP(queue->buffer.bytes_per_datum *

drivers/iio/common/st_sensors/st_sensors_buffer.c

31

DIV_ROUND_UP(channel->scan_type.realbits +

drivers/iio/common/st_sensors/st_sensors_core.c

502

byte_for_channel = DIV_ROUND_UP(ch->scan_type.realbits +

drivers/iio/frequency/adf4350.c

201

band_sel_div = DIV_ROUND_UP(st->fpfd, ADF4350_MAX_BANDSEL_CLK);

drivers/iio/frequency/adf4371.c

317

cp_bleed = DIV_ROUND_UP(400 * 1750, st->integer * 375);

drivers/iio/frequency/adf4371.c

550

vco_band_div = DIV_ROUND_UP(st->fpfd, 2400000U);

drivers/iio/frequency/adf4377.c

804

st->synth_lock_timeout = DIV_ROUND_UP(st->f_div_rclk, 50000);

drivers/iio/frequency/adf4377.c

805

st->vco_alc_timeout = DIV_ROUND_UP(st->f_div_rclk, 20000);

drivers/iio/frequency/adf4377.c

806

st->vco_band_div = DIV_ROUND_UP(st->f_div_rclk, 150000 * 16 * (1 << st->dclk_mode));

drivers/iio/frequency/adf4377.c

807

st->adc_clk_div = DIV_ROUND_UP((st->f_div_rclk / 400000 - 2), 4);

drivers/iio/light/apds9300.c

72

tmp = DIV_ROUND_UP(ch1 * 100, ch0);

drivers/iio/light/ltr390.c

494

new_val = DIV_ROUND_UP(val, samp_period);

drivers/iio/light/ltr501.c

312

ratio = DIV_ROUND_UP(ir_data * 100, ir_data + vis_data);

drivers/iio/light/ltr501.c

486

new_val = DIV_ROUND_UP(period, samp_period);

drivers/iio/light/ltr501.c

506

new_val = DIV_ROUND_UP(period, samp_period);

drivers/infiniband/core/ib_core_uverbs.c

314

npages = (u32)DIV_ROUND_UP(length, PAGE_SIZE);

drivers/infiniband/core/rw.c

1084

return DIV_ROUND_UP(maxpages, mr_pages);

drivers/infiniband/core/rw.c

164

ctx->nr_ops = DIV_ROUND_UP(sg_cnt, pages_per_mr);

drivers/infiniband/core/rw.c

216

ctx->reg = kzalloc_objs(*ctx->reg, DIV_ROUND_UP(nr_bvec, pages_per_mr));

drivers/infiniband/core/rw.c

250

ctx->nr_ops = DIV_ROUND_UP(ctx->reg[0].sgt.nents, pages_per_mr);

drivers/infiniband/core/rw.c

296

ctx->nr_ops = DIV_ROUND_UP(sg_cnt, max_sge);

drivers/infiniband/core/rw.c

413

u32 nr_ops = DIV_ROUND_UP(nr_bvec, max_sge);

drivers/infiniband/core/umem.c

63

DIV_ROUND_UP(sg->length, PAGE_SIZE), make_dirty);

drivers/infiniband/hw/bnxt_re/ib_verbs.c

482

#define BNXT_RE_FENCE_PBL_SIZE DIV_ROUND_UP(BNXT_RE_FENCE_BYTES, PAGE_SIZE)

drivers/infiniband/hw/cxgb4/cm.c

1975

req->len16_pkd = htonl(FW_WR_LEN16_V(DIV_ROUND_UP(sizeof(*req), 16)));

drivers/infiniband/hw/cxgb4/cm.c

4013

req->len16_pkd = htonl(FW_WR_LEN16_V(DIV_ROUND_UP(sizeof(*req), 16)));

drivers/infiniband/hw/cxgb4/cm.c

605

flowclen16 = DIV_ROUND_UP(flowclen, 16);

drivers/infiniband/hw/cxgb4/cq.c

131

res_wr->len16_pkd = cpu_to_be32(DIV_ROUND_UP(wr_len, 16));

drivers/infiniband/hw/cxgb4/cq.c

481

idx += DIV_ROUND_UP(pwr->len16 * 16, T4_EQ_ENTRY_SIZE);

drivers/infiniband/hw/cxgb4/cq.c

53

res_wr->len16_pkd = cpu_to_be32(DIV_ROUND_UP(wr_len, 16));

drivers/infiniband/hw/cxgb4/mem.c

127

num_wqe = DIV_ROUND_UP(len, C4IW_MAX_INLINE_SIZE);

drivers/infiniband/hw/cxgb4/mem.c

154

FW_WR_LEN16_V(DIV_ROUND_UP(wr_len, 16)));

drivers/infiniband/hw/cxgb4/mem.c

158

DIV_ROUND_UP(copy_len, T4_ULPTX_MIN_IO)));

drivers/infiniband/hw/cxgb4/mem.c

159

req->len16 = cpu_to_be32(DIV_ROUND_UP(wr_len-sizeof(req->wr),

drivers/infiniband/hw/cxgb4/mem.c

89

req->wr.wr_mid = cpu_to_be32(FW_WR_LEN16_V(DIV_ROUND_UP(wr_len, 16)));

drivers/infiniband/hw/cxgb4/mem.c

94

req->len16 = cpu_to_be32(DIV_ROUND_UP(wr_len-sizeof(req->wr), 16));

drivers/infiniband/hw/cxgb4/qp.c

1246

idx += DIV_ROUND_UP(len16*16, T4_EQ_ENTRY_SIZE);

drivers/infiniband/hw/cxgb4/qp.c

1324

idx += DIV_ROUND_UP(len16*16, T4_EQ_ENTRY_SIZE);

drivers/infiniband/hw/cxgb4/qp.c

1410

idx += DIV_ROUND_UP(len16 * 16, T4_EQ_ENTRY_SIZE);

drivers/infiniband/hw/cxgb4/qp.c

1577

FW_WR_LEN16_V(DIV_ROUND_UP(sizeof(*wqe), 16)));

drivers/infiniband/hw/cxgb4/qp.c

1718

FW_WR_LEN16_V(DIV_ROUND_UP(sizeof(*wqe), 16)));

drivers/infiniband/hw/cxgb4/qp.c

1740

init->u.write.len16 = DIV_ROUND_UP(

drivers/infiniband/hw/cxgb4/qp.c

1749

init->u.read.len16 = DIV_ROUND_UP(sizeof(init->u.read), 16);

drivers/infiniband/hw/cxgb4/qp.c

1782

FW_WR_LEN16_V(DIV_ROUND_UP(sizeof(*wqe), 16)));

drivers/infiniband/hw/cxgb4/qp.c

2513

res_wr->len16_pkd = cpu_to_be32(DIV_ROUND_UP(wr_len, 16));

drivers/infiniband/hw/cxgb4/qp.c

2601

res_wr->len16_pkd = cpu_to_be32(DIV_ROUND_UP(wr_len, 16));

drivers/infiniband/hw/cxgb4/qp.c

318

res_wr->len16_pkd = cpu_to_be32(DIV_ROUND_UP(wr_len, 16));

drivers/infiniband/hw/cxgb4/qp.c

548

*len16 = DIV_ROUND_UP(size, 16);

drivers/infiniband/hw/cxgb4/qp.c

599

*len16 = DIV_ROUND_UP(size, 16);

drivers/infiniband/hw/cxgb4/qp.c

654

*len16 = DIV_ROUND_UP(size, 16);

drivers/infiniband/hw/cxgb4/qp.c

683

*len16 = DIV_ROUND_UP(sizeof(wqe->read), 16);

drivers/infiniband/hw/cxgb4/qp.c

751

idx = DIV_ROUND_UP(len16 * 16, T4_EQ_ENTRY_SIZE);

drivers/infiniband/hw/cxgb4/qp.c

766

*len16 = DIV_ROUND_UP(

drivers/infiniband/hw/cxgb4/qp.c

780

*len16 = DIV_ROUND_UP(sizeof(wqe->recv) +

drivers/infiniband/hw/cxgb4/qp.c

814

*len16 = DIV_ROUND_UP(sizeof(*fr), 16);

drivers/infiniband/hw/cxgb4/qp.c

854

*len16 = DIV_ROUND_UP(sizeof(wqe->fr) + sizeof(*sglp), 16);

drivers/infiniband/hw/cxgb4/qp.c

875

*len16 = DIV_ROUND_UP(sizeof(wqe->fr) + sizeof(*imdp)

drivers/infiniband/hw/cxgb4/qp.c

886

*len16 = DIV_ROUND_UP(sizeof(wqe->inv), 16);

drivers/infiniband/hw/cxgb4/t4.h

435

srq->wq_pidx += DIV_ROUND_UP(len16 * 16, T4_EQ_ENTRY_SIZE);

drivers/infiniband/hw/cxgb4/t4.h

500

wq->rq.wq_pidx += DIV_ROUND_UP(len16*16, T4_EQ_ENTRY_SIZE);

drivers/infiniband/hw/cxgb4/t4.h

542

wq->sq.wq_pidx += DIV_ROUND_UP(len16*16, T4_EQ_ENTRY_SIZE);

drivers/infiniband/hw/efa/efa_verbs.c

1374

chunk_list_size = DIV_ROUND_UP(page_cnt, EFA_PTRS_PER_CHUNK);

drivers/infiniband/hw/efa/efa_verbs.c

1500

u32 size_in_pages = DIV_ROUND_UP(pbl->pbl_buf_size_in_bytes, EFA_CHUNK_PAYLOAD_SIZE);

drivers/infiniband/hw/hfi1/pio.c

1385

#define dwords_to_blocks(x) DIV_ROUND_UP(x, BLOCK_DWORDS)

drivers/infiniband/hw/hfi1/pio.c

557

release_credits = DIV_ROUND_UP(mtu, PIO_BLOCK_SIZE);

drivers/infiniband/hw/hfi1/tid_rdma.c

3333

DIV_ROUND_UP(wqe->length, priv->tid_req.seg_len);

drivers/infiniband/hw/hfi1/tid_rdma.c

3692

num_segs = DIV_ROUND_UP(len, qpriv->tid_rdma.local.max_len);

drivers/infiniband/hw/hns/hns_roce_alloc.c

126

buf->npages = DIV_ROUND_UP(alloced_size, page_size);

drivers/infiniband/hw/hns/hns_roce_alloc.c

93

ntrunk = DIV_ROUND_UP(size, 1 << buf->trunk_shift);

drivers/infiniband/hw/hns/hns_roce_hem.c

738

num_hem = DIV_ROUND_UP(nobj, obj_per_chunk);

drivers/infiniband/hw/hns/hns_roce_hem.c

760

num_hem = DIV_ROUND_UP(nobj, obj_per_chunk);

drivers/infiniband/hw/hns/hns_roce_hem.c

773

num_bt_l1 = DIV_ROUND_UP(num_hem, bt_chunk_num);

drivers/infiniband/hw/hns/hns_roce_hw_v2.c

1950

desc_num = DIV_ROUND_UP(HNS_ROCE_HW_CNT_TOTAL, CNT_PER_DESC);

drivers/infiniband/hw/hns/hns_roce_hw_v2.c

2289

*bt_page_size = ilog2(DIV_ROUND_UP(obj_num, obj_per_chunk));

drivers/infiniband/hw/hns/hns_roce_hw_v2.c

2291

*buf_page_size = ilog2(DIV_ROUND_UP(obj_num, obj_per_chunk));

drivers/infiniband/hw/hns/hns_roce_mr.c

865

ba_cnt = DIV_ROUND_UP(buf_attr->region[0].size, buf_pg_sz);

drivers/infiniband/hw/hns/hns_roce_mr.c

926

order_base_2(DIV_ROUND_UP(buf_size, HNS_HW_PAGE_SIZE));

drivers/infiniband/hw/hns/hns_roce_mr.c

931

DIV_ROUND_UP(buf_size, buf_pg_sz);

drivers/infiniband/hw/hns/hns_roce_mr.c

946

r->count = DIV_ROUND_UP(buf_size, buf_pg_sz);

drivers/infiniband/hw/hns/hns_roce_mr.c

984

ba_num += DIV_ROUND_UP(re->count, pgs_per_l1ba);

drivers/infiniband/hw/irdma/ctrl.c

5583

return DIV_ROUND_UP(size, IRDMA_HMC_PAGE_SIZE);

drivers/infiniband/hw/irdma/ctrl.c

5609

avail_sds -= DIV_ROUND_UP(mrwanted, MAX_MR_PER_SD);

drivers/infiniband/hw/irdma/hw.c

1472

pg_cnt = DIV_ROUND_UP(aeq->mem.size, PAGE_SIZE);

drivers/infiniband/hw/irdma/hw.c

703

u32 pg_cnt = DIV_ROUND_UP(aeq->mem.size, PAGE_SIZE);

drivers/infiniband/hw/mlx4/qp.c

324

DIV_ROUND_UP(MLX4_IB_UD_HEADER_SIZE,

drivers/infiniband/hw/mlx5/dm.c

20

u32 num_pages = DIV_ROUND_UP(length, PAGE_SIZE);

drivers/infiniband/hw/mlx5/dm.c

92

u32 num_pages = DIV_ROUND_UP(length, PAGE_SIZE);

drivers/infiniband/hw/mlx5/mr.c

232

ret = DIV_ROUND_UP(ndescs, MLX5_IB_UMR_OCTOWORD /

drivers/infiniband/hw/mlx5/mr.c

236

ret = DIV_ROUND_UP(ndescs, MLX5_IB_UMR_OCTOWORD /

drivers/infiniband/hw/mlx5/srq_cmd.c

22

u32 rq_num_pas = DIV_ROUND_UP(rq_sz_po, page_size);

drivers/infiniband/hw/mlx5/wr.c

774

qp->sq.cur_post += DIV_ROUND_UP(size * 16, MLX5_SEND_WQE_BB);

drivers/infiniband/hw/mthca/mthca_memfree.c

368

num_icm = DIV_ROUND_UP(nobj, obj_per_chunk);

drivers/infiniband/hw/qedr/verbs.c

599

num_pbls = DIV_ROUND_UP(num_pbes, NUM_PBES_ON_PAGE(pbl_size));

drivers/infiniband/ulp/iser/iser_verbs.c

512

sg_tablesize = DIV_ROUND_UP(max_sectors * SECTOR_SIZE, SZ_4K);

drivers/infiniband/ulp/isert/ib_isert.c

1076

sg_nents = max(1UL, DIV_ROUND_UP(imm_data_len, PAGE_SIZE));

drivers/infiniband/ulp/isert/ib_isert.c

1143

sg_nents = max(1UL, DIV_ROUND_UP(unsol_data_len, PAGE_SIZE));

drivers/infiniband/ulp/rtrs/rtrs-srv.c

586

mrs_num = DIV_ROUND_UP(srv->queue_depth, chunks_per_mr);

drivers/infiniband/ulp/rtrs/rtrs-srv.c

587

chunks_per_mr = DIV_ROUND_UP(srv->queue_depth, mrs_num);

drivers/input/keyboard/gpio_keys_polled.c

329

bdata->threshold = DIV_ROUND_UP(button->debounce_interval,

drivers/input/keyboard/pmic8xxx-keypad.c

149

udelay((2 * DIV_ROUND_UP(USEC_PER_SEC, KEYP_CLOCK_FREQ)) + 1);

drivers/input/keyboard/pmic8xxx-keypad.c

203

udelay((4 * DIV_ROUND_UP(USEC_PER_SEC, KEYP_CLOCK_FREQ)) + 1);

drivers/input/keyboard/tegra-kbc.c

640

kbc->repoll_dly = DIV_ROUND_UP(kbc->repoll_dly, KBC_CYCLE_MS);

drivers/input/misc/max8997_haptic.c

58

u8 duty_index = DIV_ROUND_UP(chip->level * 64, 100);

drivers/input/rmi4/rmi_f11.c

666

sensor->pkt_size = DIV_ROUND_UP(sensor->nbr_fingers, 4);

drivers/input/rmi4/rmi_f11.c

694

DIV_ROUND_UP(query->nr_touch_shapes + 1, 8);

drivers/input/rmi4/rmi_f11.c

702

i = DIV_ROUND_UP(sensor->nbr_fingers, 4);

drivers/input/rmi4/rmi_f30.c

296

f30->register_count = DIV_ROUND_UP(f30->gpioled_count, 8);

drivers/input/rmi4/rmi_f30.c

33

#define RMI_F30_CTRL_MAX_BYTES DIV_ROUND_UP(RMI_F30_CTRL_MAX_REGS, 8)

drivers/input/rmi4/rmi_f3a.c

13

#define RMI_F3A_MAX_REG_SIZE DIV_ROUND_UP(RMI_F3A_MAX_GPIO_COUNT, 8)

drivers/input/rmi4/rmi_f3a.c

182

f3a->register_count = DIV_ROUND_UP(f3a->gpio_count, 8);

drivers/input/touchscreen/ads7846.c

1057

packet->count_skip = DIV_ROUND_UP(count, 24);

drivers/input/touchscreen/atmel_mxt_ts.c

2731

dbg->t37_pages = DIV_ROUND_UP(data->xsize *

drivers/input/touchscreen/fsl-imx25-tcq.c

381

debounce_cnt = DIV_ROUND_UP(priv->pen_debounce, adc_period * 8) - 1;

drivers/input/touchscreen/fsl-imx25-tcq.c

382

settling_cnt = DIV_ROUND_UP(priv->settling_time, adc_period * 8) - 1;

drivers/input/touchscreen/ilitek_ts_i2c.c

179

count = DIV_ROUND_UP(report_max_point, packet_max_point);

drivers/input/touchscreen/wdt87xx_i2c.c

662

time_delay = DIV_ROUND_UP(length, 1024);

drivers/iommu/amd/iommu.c

1954

return levels ? (DIV_ROUND_UP(levels, 9) - 1) : levels;

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

1515

DIV_ROUND_UP(max_contexts, CTXDESC_L2_ENTRIES);

drivers/iommu/intel/iommu.h

887

return DIV_ROUND_UP(width - 30, LEVEL_STRIDE);

drivers/iommu/io-pgtable-arm.c

941

levels = DIV_ROUND_UP(va_bits, data->bits_per_level);

drivers/iommu/iommufd/iova_bitmap.c

178

npages = DIV_ROUND_UP((bitmap->mapped_total_index -

drivers/iommu/iommufd/iova_bitmap.c

310

DIV_ROUND_UP(bytes, sizeof(*bitmap->bitmap)));

drivers/iommu/iommufd/pages.c

1384

pages->npages = DIV_ROUND_UP(length + start_byte, PAGE_SIZE);

drivers/iommu/iommufd/selftest.c

1740

tmp = kvzalloc(DIV_ROUND_UP(max, BITS_PER_LONG) * sizeof(unsigned long),

drivers/iommu/iommufd/selftest.c

1747

if (copy_from_user(tmp, uptr, DIV_ROUND_UP(max, BITS_PER_BYTE))) {

drivers/irqchip/irq-atmel-aic-common.c

210

nchips = DIV_ROUND_UP(nirqs, 32);

drivers/irqchip/irq-atmel-aic5.c

361

smr_cache = kcalloc(DIV_ROUND_UP(NR_SAMA5D2_IRQS, 32) * 32,

drivers/irqchip/irq-dw-apb-ictl.c

190

for (i = 0; i < DIV_ROUND_UP(nrirqs, 32); i++) {

drivers/irqchip/irq-gic-v3-its.c

2982

nl2 = DIV_ROUND_UP(ITS_MAX_VPEID, epp);

drivers/irqchip/irq-gic-v3-its.c

2985

npg = DIV_ROUND_UP(nl2 * SZ_8, psz);

drivers/irqchip/irq-gic-v3-its.c

2993

np = DIV_ROUND_UP(npg * psz, PAGE_SIZE);

drivers/irqchip/irq-gic.c

565

for (i = 0; i < DIV_ROUND_UP(gic_irqs, 16); i++)

drivers/irqchip/irq-gic.c

569

for (i = 0; i < DIV_ROUND_UP(gic_irqs, 4); i++)

drivers/irqchip/irq-gic.c

573

for (i = 0; i < DIV_ROUND_UP(gic_irqs, 32); i++)

drivers/irqchip/irq-gic.c

577

for (i = 0; i < DIV_ROUND_UP(gic_irqs, 32); i++)

drivers/irqchip/irq-gic.c

606

for (i = 0; i < DIV_ROUND_UP(gic_irqs, 16); i++)

drivers/irqchip/irq-gic.c

610

for (i = 0; i < DIV_ROUND_UP(gic_irqs, 4); i++)

drivers/irqchip/irq-gic.c

614

for (i = 0; i < DIV_ROUND_UP(gic_irqs, 4); i++)

drivers/irqchip/irq-gic.c

618

for (i = 0; i < DIV_ROUND_UP(gic_irqs, 32); i++) {

drivers/irqchip/irq-gic.c

625

for (i = 0; i < DIV_ROUND_UP(gic_irqs, 32); i++) {

drivers/irqchip/irq-gic.c

652

for (i = 0; i < DIV_ROUND_UP(32, 32); i++)

drivers/irqchip/irq-gic.c

656

for (i = 0; i < DIV_ROUND_UP(32, 32); i++)

drivers/irqchip/irq-gic.c

660

for (i = 0; i < DIV_ROUND_UP(32, 16); i++)

drivers/irqchip/irq-gic.c

682

for (i = 0; i < DIV_ROUND_UP(32, 32); i++) {

drivers/irqchip/irq-gic.c

689

for (i = 0; i < DIV_ROUND_UP(32, 32); i++) {

drivers/irqchip/irq-gic.c

696

for (i = 0; i < DIV_ROUND_UP(32, 16); i++)

drivers/irqchip/irq-gic.c

699

for (i = 0; i < DIV_ROUND_UP(32, 4); i++)

drivers/irqchip/irq-gic.c

739

gic->saved_ppi_enable = __alloc_percpu(DIV_ROUND_UP(32, 32) * 4,

drivers/irqchip/irq-gic.c

744

gic->saved_ppi_active = __alloc_percpu(DIV_ROUND_UP(32, 32) * 4,

drivers/irqchip/irq-gic.c

749

gic->saved_ppi_conf = __alloc_percpu(DIV_ROUND_UP(32, 16) * 4,

drivers/irqchip/irq-gic.c

77

u32 saved_spi_enable[DIV_ROUND_UP(1020, 32)];

drivers/irqchip/irq-gic.c

78

u32 saved_spi_active[DIV_ROUND_UP(1020, 32)];

drivers/irqchip/irq-gic.c

79

u32 saved_spi_conf[DIV_ROUND_UP(1020, 16)];

drivers/irqchip/irq-gic.c

80

u32 saved_spi_target[DIV_ROUND_UP(1020, 4)];

drivers/irqchip/irq-gic.c

987

for (i = 8; i < DIV_ROUND_UP(gic_irqs, 4); i++) {

drivers/irqchip/irq-imx-irqsteer.c

195

data->irq_count = DIV_ROUND_UP(irqs_num, 64);

drivers/irqchip/irq-mips-gic.c

248

DIV_ROUND_UP(gic_shared_intrs, 64));

drivers/irqchip/irq-mips-gic.c

251

DIV_ROUND_UP(gic_shared_intrs, 32));

drivers/irqchip/irq-mst-intc.c

133

for (i = 0; i < DIV_ROUND_UP(cd->nr_irqs, 16); i++)

drivers/irqchip/irq-mst-intc.c

142

for (i = 0; i < DIV_ROUND_UP(cd->nr_irqs, 16); i++)

drivers/irqchip/irq-mst-intc.c

35

u16 saved_polarity_conf[DIV_ROUND_UP(MST_INTC_MAX_IRQS, 16)];

drivers/irqchip/irq-pic32-evic.c

218

nchips = DIV_ROUND_UP(NR_IRQS, 32);

drivers/irqchip/irq-pruss-intc.c

263

num_chnl_map_regs = DIV_ROUND_UP(soc_config->num_system_events,

drivers/irqchip/irq-pruss-intc.c

265

num_host_intr_regs = DIV_ROUND_UP(soc_config->num_host_events,

drivers/irqchip/irq-pruss-intc.c

267

num_event_type_regs = DIV_ROUND_UP(soc_config->num_system_events, 32);

drivers/irqchip/irq-qcom-mpm.c

348

priv->reg_stride = DIV_ROUND_UP(pin_cnt, 32);

drivers/irqchip/irq-sifive-plic.c

664

priv->irq_groups = DIV_ROUND_UP(nr_irqs, 32);

drivers/irqchip/irq-sp7021-intc.c

18

#define SP_INTC_NR_GROUPS DIV_ROUND_UP(SP_INTC_NR_IRQS, 32)

drivers/leds/flash/leds-lm3601x.c

345

DIV_ROUND_UP(led->torch_current_max - LM3601X_MIN_TORCH_I_UA + 1,

drivers/leds/leds-aw200xx.c

91

DIV_ROUND_UP((fade) * AW200XX_DIM_MAX, AW200XX_FADE_MAX)

drivers/leds/rgb/leds-qcom-lpg.c

630

hi_pause = DIV_ROUND_UP(chan->ramp_hi_pause_ms, chan->ramp_tick_ms);

drivers/leds/rgb/leds-qcom-lpg.c

631

lo_pause = DIV_ROUND_UP(chan->ramp_lo_pause_ms, chan->ramp_tick_ms);

drivers/leds/rgb/leds-qcom-lpg.c

674

hi_pause = DIV_ROUND_UP(chan->ramp_hi_pause_ms, step);

drivers/leds/rgb/leds-qcom-lpg.c

675

lo_pause = DIV_ROUND_UP(chan->ramp_lo_pause_ms, step);

drivers/leds/trigger/ledtrig-cpu.c

91

DIV_ROUND_UP(LED_FULL * active_cpus, total_cpus));

drivers/mailbox/cix-mailbox.c

149

return DIV_ROUND_UP(len, 4);

drivers/md/bcache/bcache.h

803

DIV_ROUND_UP((size_t) (ca)->sb.nbuckets, prios_per_bucket(ca))

drivers/md/bcache/bset.h

265

DIV_ROUND_UP(__set_bytes(i, k), block_bytes)

drivers/md/bcache/movinggc.c

149

DIV_ROUND_UP(KEY_SIZE(&w->key), PAGE_SECTORS),

drivers/md/bcache/movinggc.c

83

DIV_ROUND_UP(KEY_SIZE(&io->w->key), PAGE_SECTORS), 0);

drivers/md/bcache/request.c

930

DIV_ROUND_UP(s->insert_bio_sectors, PAGE_SECTORS),

drivers/md/bcache/writeback.c

335

DIV_ROUND_UP(KEY_SIZE(&w->key), PAGE_SECTORS), 0);

drivers/md/bcache/writeback.c

540

DIV_ROUND_UP(KEY_SIZE(&w->key), PAGE_SECTORS),

drivers/md/dm-integrity.c

5177

ic->n_bitmap_blocks = DIV_ROUND_UP(n_bitmap_bits, BITMAP_BLOCK_SIZE * 8);

drivers/md/dm-integrity.c

5259

unsigned int n_bitmap_pages = DIV_ROUND_UP(ic->n_bitmap_blocks, PAGE_SIZE / BITMAP_BLOCK_SIZE);

drivers/md/dm-integrity.c

693

unsigned int n_bitmap_pages = DIV_ROUND_UP(ic->n_bitmap_blocks, PAGE_SIZE / BITMAP_BLOCK_SIZE);

drivers/md/dm-kcopyd.c

945

reserve_pages = DIV_ROUND_UP(kc->sub_job_size << SECTOR_SHIFT, PAGE_SIZE);

drivers/md/dm-log-writes.c

269

bio_pages = bio_max_segs(DIV_ROUND_UP(datalen, PAGE_SIZE));

drivers/md/dm-pcache/cache.c

289

n_subtrees = DIV_ROUND_UP(cache->dev_size << SECTOR_SHIFT, PCACHE_CACHE_SUBTREE_SIZE);

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

2688

level_pages = DIV_ROUND_UP(level_pages, VDO_BLOCK_MAP_ENTRIES_PER_PAGE);

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

390

return DIV_ROUND_UP(age * RECOVERY_JOURNAL_1_ENTRIES_PER_BLOCK,

drivers/md/dm-vdo/encodings.c

449

page_count_t level_size = DIV_ROUND_UP(leaf_pages, root_count);

drivers/md/dm-vdo/encodings.c

456

level_size = DIV_ROUND_UP(level_size, VDO_BLOCK_MAP_ENTRIES_PER_PAGE);

drivers/md/dm-vdo/encodings.h

1066

return DIV_ROUND_UP(block_count, COUNTS_PER_BLOCK);

drivers/md/dm-vdo/encodings.h

864

return DIV_ROUND_UP(entries, VDO_BLOCK_MAP_ENTRIES_PER_PAGE);

drivers/md/dm-vdo/indexer/delta-index.c

1957

return DIV_ROUND_UP(bits_per_index, bits_per_page);

drivers/md/dm-vdo/indexer/delta-index.c

362

delta_index->lists_per_zone = DIV_ROUND_UP(list_count, zone_count);

drivers/md/dm-vdo/indexer/index-layout.c

238

DIV_ROUND_UP(uds_compute_index_page_map_save_size(geometry),

drivers/md/dm-vdo/indexer/index-layout.c

241

DIV_ROUND_UP(uds_compute_saved_open_chapter_size(geometry),

drivers/md/dm-vdo/indexer/volume-index.c

382

*block_count = DIV_ROUND_UP(bytes, block_size) + MAX_ZONES;

drivers/md/dm-vdo/repair.c

1702

block_count_t vio_count = DIV_ROUND_UP(remaining, MAX_BLOCKS_PER_VIO);

drivers/md/dm-vdo/slab-depot.c

4099

refcount_reads_needed = DIV_ROUND_UP(reference_block_count, MAX_BLOCKS_PER_VIO);

drivers/md/dm-vdo/slab-depot.c

4100

refcount_blocks_per_vio = DIV_ROUND_UP(reference_block_count, refcount_reads_needed);

drivers/md/dm-vdo/vio.c

222

bvec_count = DIV_ROUND_UP(offset + size, PAGE_SIZE);

drivers/md/md-bitmap.c

1021

bytes = DIV_ROUND_UP(chunks, 8);

drivers/md/md-bitmap.c

1025

num_pages = DIV_ROUND_UP(bytes, PAGE_SIZE);

drivers/md/md-bitmap.c

1057

roundup(DIV_ROUND_UP(num_pages*4, 8), sizeof(unsigned long)),

drivers/md/md-bitmap.c

1358

node_offset = bitmap->cluster_slot * (DIV_ROUND_UP(store->bytes, PAGE_SIZE));

drivers/md/md-bitmap.c

2404

bytes = DIV_ROUND_UP(bitmap->counts.chunks, 8);

drivers/md/md-bitmap.c

2407

space = DIV_ROUND_UP(bytes, 512);

drivers/md/md-bitmap.c

2416

bytes = DIV_ROUND_UP(chunks, 8);

drivers/md/md-bitmap.c

2436

pages = DIV_ROUND_UP(chunks, PAGE_COUNTER_RATIO);

drivers/md/md-llbitmap.c

1347

int nr_blocks = DIV_ROUND_UP(BITMAP_DATA_OFFSET, llbitmap->io_size);

drivers/md/md-llbitmap.c

542

unsigned int nr_pages = DIV_ROUND_UP(llbitmap->chunks +

drivers/md/md-llbitmap.c

780

unsigned long chunks = DIV_ROUND_UP(blocks, chunksize);

drivers/media/cec/platform/meson/ao-cec-g12a.c

252

return DIV_ROUND_UP(100000000, p1 + p2);

drivers/media/dvb-frontends/cxd2841er.c

3338

timeout = DIV_ROUND_UP(3000000, symbol_rate) + 150;

drivers/media/dvb-frontends/horus3a.c

260

fc_lpf = (u8)DIV_ROUND_UP(symbol_rate * 47, 40000);

drivers/media/dvb-frontends/horus3a.c

262

fc_lpf = (u8)DIV_ROUND_UP(symbol_rate * 27, 40000) + 5;

drivers/media/dvb-frontends/m88ds3103.c

907

u16tmp = DIV_ROUND_UP(target_mclk, dev->cfg->ts_clk);

drivers/media/dvb-frontends/m88ds3103.c

909

u8tmp2 = DIV_ROUND_UP(u16tmp, 2) - 1;

drivers/media/dvb-frontends/mxl692.c

200

div_size = DIV_ROUND_UP(size, 4);

drivers/media/firewire/firedtv-fw.c

74

#define N_PAGES DIV_ROUND_UP(N_PACKETS, PACKETS_PER_PAGE)

drivers/media/i2c/aptina-pll.c

127

p1_min = max(limits->p1_min, DIV_ROUND_UP(limits->out_clock_min * div,

drivers/media/i2c/aptina-pll.c

139

mf_low = roundup(max(mf_min, DIV_ROUND_UP(pll->ext_clock * p1,

drivers/media/i2c/aptina-pll.c

55

mf_min = DIV_ROUND_UP(limits->m_min, pll->m);

drivers/media/i2c/aptina-pll.c

62

mf_max = min(mf_max, DIV_ROUND_UP(limits->n_max * limits->p1_max, div));

drivers/media/i2c/ccs-pll.c

268

DIV_ROUND_UP(min_vt_div,

drivers/media/i2c/ccs-pll.c

281

DIV_ROUND_UP(max_vt_div,

drivers/media/i2c/ccs-pll.c

285

DIV_ROUND_UP(pll_fr->pll_op_clk_freq_hz,

drivers/media/i2c/ccs-pll.c

312

more_mul = one_or_more(DIV_ROUND_UP(lim_fr->min_pll_op_clk_freq_hz,

drivers/media/i2c/ccs-pll.c

316

more_mul *= DIV_ROUND_UP(lim_fr->min_pll_multiplier, mul * more_mul);

drivers/media/i2c/ccs-pll.c

409

DIV_ROUND_UP(pll->ext_clk_freq_hz,

drivers/media/i2c/ccs-pll.c

509

DIV_ROUND_UP(pll->bits_per_pixel

drivers/media/i2c/ccs-pll.c

522

DIV_ROUND_UP(pll_fr->pll_op_clk_freq_hz,

drivers/media/i2c/ccs-pll.c

533

DIV_ROUND_UP(pll_fr->pll_op_clk_freq_hz,

drivers/media/i2c/ccs-pll.c

554

pix_div = DIV_ROUND_UP(vt_div, sys_div);

drivers/media/i2c/ccs-pll.c

582

pll->vt_bk.sys_clk_div = DIV_ROUND_UP(vt_div, best_pix_div);

drivers/media/i2c/ccs-pll.c

658

more_mul_min = DIV_ROUND_UP(op_lim_fr->min_pll_op_clk_freq_hz,

drivers/media/i2c/ccs-pll.c

665

DIV_ROUND_UP(op_lim_fr->min_pll_multiplier, mul));

drivers/media/i2c/ccs-pll.c

823

DIV_ROUND_UP(pll->ext_clk_freq_hz,

drivers/media/i2c/ccs-pll.c

828

DIV_ROUND_UP(pll->ext_clk_freq_hz,

drivers/media/i2c/ccs-pll.c

844

DIV_ROUND_UP(op_lim_fr->max_pll_op_clk_freq_hz,

drivers/media/i2c/ccs/ccs-core.c

428

DIV_ROUND_UP(pll->op_bk.sys_clk_freq_hz,

drivers/media/i2c/imx111.c

696

return DIV_ROUND_UP(IMX111_PLL_SETTLING_TIME_DEFAULT * extclk_mhz - 63,

drivers/media/i2c/mt9m114.c

2237

duration = DIV_ROUND_UP(2 * 50 * 1000000, freq);

drivers/media/i2c/mt9m114.c

2306

duration = DIV_ROUND_UP(2 * 10 * 1000000, clk_get_rate(sensor->clk));

drivers/media/i2c/mt9p031.c

253

div = DIV_ROUND_UP(ext_freq, mt9p031->target_freq);

drivers/media/i2c/mt9p031.c

343

delay = DIV_ROUND_UP(850000 * 1000, rate);

drivers/media/i2c/og01a1b.c

1016

unsigned long delay = DIV_ROUND_UP(512 * USEC_PER_SEC, OG01A1B_MCLK);

drivers/media/i2c/og01a1b.c

965

unsigned long delay = DIV_ROUND_UP(8192UL * USEC_PER_SEC, OG01A1B_MCLK);

drivers/media/i2c/os05b10.c

811

delay_us = DIV_ROUND_UP(8192, OS05B10_XCLK_FREQ / 1000 / 1000);

drivers/media/i2c/ov2685.c

448

return DIV_ROUND_UP(cycles, OV2685_XVCLK_FREQ / 1000 / 1000);

drivers/media/i2c/ov4689.c

512

return DIV_ROUND_UP(cycles * 1000,

drivers/media/i2c/ov4689.c

513

DIV_ROUND_UP(ov4689->clock_rate, 1000));

drivers/media/i2c/ov5670.c

2513

delay_us = DIV_ROUND_UP(8192 * 2 * 1000,

drivers/media/i2c/ov5670.c

2514

DIV_ROUND_UP(OV5670_XVCLK_FREQ, 1000));

drivers/media/i2c/ov64a40.c

2982

delay = DIV_ROUND_UP(4096, OV64A40_XCLK_FREQ / 1000 / 1000);

drivers/media/i2c/ov64a40.c

2986

delay += DIV_ROUND_UP(timings->ppl * 4 * ov64a40->exposure->cur.val,

drivers/media/i2c/ov7251.c

930

wait_us = DIV_ROUND_UP(65536 * 1000,

drivers/media/i2c/ov7251.c

931

DIV_ROUND_UP(ov7251->xclk_freq, 1000));

drivers/media/i2c/ov8858.c

1640

delay_us = DIV_ROUND_UP(8192, OV8858_XVCLK_FREQ / 1000 / 1000);

drivers/media/i2c/ov9282.c

740

return DIV_ROUND_UP(value * frame_width, OV9282_STROBE_SPAN_FACTOR);

drivers/media/i2c/tc358743.c

800

return DIV_ROUND_UP(bps, bps_pr_lane);

drivers/media/i2c/thp7312.c

1658

num_banks = DIV_ROUND_UP(size, THP7312_RAM_BANK_SIZE);

drivers/media/i2c/thp7312.c

1674

num_chunks = DIV_ROUND_UP(bank_size, THP7312_FW_DOWNLOAD_UNIT);

drivers/media/i2c/thp7312.c

555

fsleep(DIV_ROUND_UP(10 * USEC_PER_SEC, rate));

drivers/media/i2c/vd55g1.c

932

unsigned int line_time_us = DIV_ROUND_UP(line_length * MEGA,

drivers/media/pci/intel/ipu3/ipu3-cio2.c

107

return DIV_ROUND_UP(width, 50) * 64;

drivers/media/pci/intel/ipu3/ipu3-cio2.c

358

static const int FBPT_WIDTH = DIV_ROUND_UP(CIO2_MAX_LOPS,

drivers/media/pci/intel/ipu3/ipu3-cio2.c

853

unsigned int lops = DIV_ROUND_UP(pages + 1, CIO2_LOP_ENTRIES);

drivers/media/pci/intel/ipu6/ipu6-isys-video.c

254

*bytesperline = *width * DIV_ROUND_UP(pfmt->bpp, BITS_PER_BYTE);

drivers/media/pci/intel/ipu6/ipu6-isys-video.c

256

*bytesperline = DIV_ROUND_UP(*width * pfmt->bpp, BITS_PER_BYTE);

drivers/media/pci/intel/ipu6/ipu6-isys-video.c

814

pages_per_line = DIV_ROUND_UP(bytes_per_line, size);

drivers/media/pci/pt3/pt3.h

69

#define MAX_DESC_BUFS DIV_ROUND_UP(MAX_NUM_XFERS, DESCS_IN_PAGE)

drivers/media/pci/pt3/pt3_dma.c

172

DIV_ROUND_UP(adap->num_bufs * DATA_BUF_XFERS, DESCS_IN_PAGE);

drivers/media/pci/tw686x/tw686x-video.c

920

int max_rates = DIV_ROUND_UP(max_fps, 2);

drivers/media/pci/zoran/zoran_device.c

255

X = DIV_ROUND_UP(vid_win_wid * 64, tvn->wa);

drivers/media/pci/zoran/zoran_device.c

281

Y = DIV_ROUND_UP(vid_win_ht * 64 * 2, tvn->ha);

drivers/media/pci/zoran/zoran_driver.c

420

bpp = DIV_ROUND_UP(zoran_formats[i].depth, 8);

drivers/media/platform/allegro-dvt/allegro-core.c

1324

param->framerate = DIV_ROUND_UP(channel->framerate.numerator,

drivers/media/platform/allegro-dvt/allegro-core.c

1657

DIV_ROUND_UP(channel->width, size_mb) - 1;

drivers/media/platform/allegro-dvt/allegro-core.c

1659

DIV_ROUND_UP(channel->height, size_mb) - 1;

drivers/media/platform/allegro-dvt/allegro-core.c

2625

DIV_ROUND_UP(channel->framerate.numerator,

drivers/media/platform/allegro-dvt/allegro-core.c

543

unsigned int num_blocks = DIV_ROUND_UP(width, SIZE_MACROBLOCK) *

drivers/media/platform/allegro-dvt/allegro-core.c

544

DIV_ROUND_UP(height, SIZE_MACROBLOCK);

drivers/media/platform/allegro-dvt/allegro-core.c

554

unsigned int pic_width_in_mb = DIV_ROUND_UP(width, SIZE_MACROBLOCK);

drivers/media/platform/allegro-dvt/allegro-core.c

555

unsigned int frame_height_in_mb = DIV_ROUND_UP(height, SIZE_MACROBLOCK);

drivers/media/platform/allegro-dvt/nal-h264.c

379

return DIV_ROUND_UP(rbsp.pos, 8);

drivers/media/platform/allegro-dvt/nal-h264.c

39

u8 *p = rbsp->data + DIV_ROUND_UP(rbsp->pos, 8);

drivers/media/platform/allegro-dvt/nal-h264.c

42

if (DIV_ROUND_UP(rbsp->pos, 8) + i > rbsp->size) {

drivers/media/platform/allegro-dvt/nal-h264.c

426

return DIV_ROUND_UP(rbsp.pos, 8);

drivers/media/platform/allegro-dvt/nal-h264.c

471

return DIV_ROUND_UP(rbsp.pos, 8);

drivers/media/platform/allegro-dvt/nal-h264.c

508

return DIV_ROUND_UP(rbsp.pos, 8);

drivers/media/platform/allegro-dvt/nal-h264.c

551

return DIV_ROUND_UP(rbsp.pos, 8);

drivers/media/platform/allegro-dvt/nal-h264.c

57

u8 *p = rbsp->data + DIV_ROUND_UP(rbsp->pos, 8);

drivers/media/platform/allegro-dvt/nal-h264.c

60

if (DIV_ROUND_UP(rbsp->pos, 8) + i > rbsp->size) {

drivers/media/platform/allegro-dvt/nal-h264.c

603

return DIV_ROUND_UP(rbsp.pos, 8);

drivers/media/platform/allegro-dvt/nal-h264.c

75

u8 *p = rbsp->data + DIV_ROUND_UP(rbsp->pos, 8);

drivers/media/platform/allegro-dvt/nal-h264.c

79

i = rbsp->size - DIV_ROUND_UP(rbsp->pos, 8) - 1;

drivers/media/platform/allegro-dvt/nal-h264.c

86

u8 *p = rbsp->data + DIV_ROUND_UP(rbsp->pos, 8);

drivers/media/platform/allegro-dvt/nal-h264.c

89

if (DIV_ROUND_UP(rbsp->pos, 8) > rbsp->size) {

drivers/media/platform/allegro-dvt/nal-hevc.c

40

u8 *p = rbsp->data + DIV_ROUND_UP(rbsp->pos, 8);

drivers/media/platform/allegro-dvt/nal-hevc.c

43

if (DIV_ROUND_UP(rbsp->pos, 8) + i > rbsp->size) {

drivers/media/platform/allegro-dvt/nal-hevc.c

548

return DIV_ROUND_UP(rbsp.pos, 8);

drivers/media/platform/allegro-dvt/nal-hevc.c

58

u8 *p = rbsp->data + DIV_ROUND_UP(rbsp->pos, 8);

drivers/media/platform/allegro-dvt/nal-hevc.c

596

return DIV_ROUND_UP(rbsp.pos, 8);

drivers/media/platform/allegro-dvt/nal-hevc.c

61

if (DIV_ROUND_UP(rbsp->pos, 8) + i > rbsp->size) {

drivers/media/platform/allegro-dvt/nal-hevc.c

643

return DIV_ROUND_UP(rbsp.pos, 8);

drivers/media/platform/allegro-dvt/nal-hevc.c

691

return DIV_ROUND_UP(rbsp.pos, 8);

drivers/media/platform/allegro-dvt/nal-hevc.c

738

return DIV_ROUND_UP(rbsp.pos, 8);

drivers/media/platform/allegro-dvt/nal-hevc.c

76

u8 *p = rbsp->data + DIV_ROUND_UP(rbsp->pos, 8);

drivers/media/platform/allegro-dvt/nal-hevc.c

782

return DIV_ROUND_UP(rbsp.pos, 8);

drivers/media/platform/allegro-dvt/nal-hevc.c

80

i = rbsp->size - DIV_ROUND_UP(rbsp->pos, 8) - 1;

drivers/media/platform/allegro-dvt/nal-hevc.c

829

return DIV_ROUND_UP(rbsp.pos, 8);

drivers/media/platform/allegro-dvt/nal-hevc.c

87

u8 *p = rbsp->data + DIV_ROUND_UP(rbsp->pos, 8);

drivers/media/platform/allegro-dvt/nal-hevc.c

882

return DIV_ROUND_UP(rbsp.pos, 8);

drivers/media/platform/allegro-dvt/nal-hevc.c

90

if (DIV_ROUND_UP(rbsp->pos, 8) > rbsp->size) {

drivers/media/platform/amlogic/c3/isp/c3-isp-capture.c

173

stride = DIV_ROUND_UP(pix_mp->plane_fmt[C3_ISP_PLANE_Y].bytesperline,

drivers/media/platform/amlogic/c3/isp/c3-isp-capture.c

193

stride = DIV_ROUND_UP(pix_mp->plane_fmt[C3_ISP_PLANE_UV].bytesperline,

drivers/media/platform/amlogic/c3/isp/c3-isp-capture.c

205

chrom_h = DIV_ROUND_UP(pix_mp->width, info->hdiv);

drivers/media/platform/amlogic/c3/isp/c3-isp-capture.c

210

chrom_v = DIV_ROUND_UP(pix_mp->height, info->vdiv);

drivers/media/platform/amlogic/c3/isp/c3-isp-capture.c

357

plane->bytesperline = DIV_ROUND_UP(pix_mp->width, hdiv) *

drivers/media/platform/amlogic/c3/isp/c3-isp-capture.c

362

DIV_ROUND_UP(pix_mp->height, vdiv);

drivers/media/platform/amlogic/c3/isp/c3-isp-resizer.c

314

ihsize_after_pre_hsc = DIV_ROUND_UP(ihsize, 2);

drivers/media/platform/amlogic/c3/isp/c3-isp-resizer.c

327

DIV_ROUND_UP(ihsize, 1 << prehsc_rate);

drivers/media/platform/amlogic/c3/isp/c3-isp-resizer.c

340

io_size.tvsize = prev_en ? DIV_ROUND_UP(ivsize, 2) : ivsize;

drivers/media/platform/amphion/vpu_helpers.c

185

bytesperline = DIV_ROUND_UP(width * bitdepth, BITS_PER_BYTE);

drivers/media/platform/amphion/vpu_malone.c

888

mb_w = DIV_ROUND_UP(info->decoded_width, 16);

drivers/media/platform/amphion/vpu_malone.c

889

mb_h = DIV_ROUND_UP(info->decoded_height, 16);

drivers/media/platform/arm/mali-c55/mali-c55-capture.c

716

plane->bytesperline = DIV_ROUND_UP(info->bpp[i] * pix_mp->width,

drivers/media/platform/arm/mali-c55/mali-c55-capture.c

718

plane->sizeimage = DIV_ROUND_UP(plane->bytesperline *

drivers/media/platform/chips-media/coda/coda-bit.c

588

size = (unsigned long)(DIV_ROUND_UP(q_data->rect.width, 16) *

drivers/media/platform/chips-media/coda/coda-bit.c

589

DIV_ROUND_UP(q_data->rect.height, 16)) * 3200 / 8 + 512;

drivers/media/platform/chips-media/coda/coda-bit.c

836

mb_width = DIV_ROUND_UP(q_data_src->rect.width, 16);

drivers/media/platform/chips-media/coda/coda-bit.c

876

mb_width = DIV_ROUND_UP(q_data_dst->width, 16);

drivers/media/platform/chips-media/coda/coda-h264.c

426

*size = 5 + DIV_ROUND_UP(sps.pos, 8);

drivers/media/platform/chips-media/coda/coda-jpeg.c

508

val = DIV_ROUND_UP(vb2_plane_size(buf, 0), 256) + 3;

drivers/media/platform/chips-media/wave5/wave5-hw.c

2081

cnt_8_chunk = DIV_ROUND_UP(count, 8);

drivers/media/platform/chips-media/wave5/wave5-hw.c

867

cnt_8_chunk = DIV_ROUND_UP(count, 8);

drivers/media/platform/chips-media/wave5/wave5-hw.c

944

bit_size = DIV_ROUND_UP(width, 16) * 5 * 8;

drivers/media/platform/chips-media/wave5/wave5-vpuapi.h

49

#define WAVE5_DEC_HEVC_BUF_SIZE(_w, _h) (DIV_ROUND_UP(_w, 64) * DIV_ROUND_UP(_h, 64) * 256 + 64)

drivers/media/platform/mediatek/jpeg/mtk_jpeg_enc_hw.c

161

blk_num = DIV_ROUND_UP(width, 16) *

drivers/media/platform/mediatek/jpeg/mtk_jpeg_enc_hw.c

162

DIV_ROUND_UP(height, 16) * 6 - 1;

drivers/media/platform/mediatek/jpeg/mtk_jpeg_enc_hw.c

164

blk_num = DIV_ROUND_UP(width, 16) *

drivers/media/platform/mediatek/jpeg/mtk_jpeg_enc_hw.c

165

DIV_ROUND_UP(height, 8) * 4 - 1;

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_av1_req_lat_if.c

969

max_sb_w = DIV_ROUND_UP(max_w, 128);

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_av1_req_lat_if.c

970

max_sb_h = DIV_ROUND_UP(max_h, 128);

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_vp9_req_lat_if.c

581

max_sb_w = DIV_ROUND_UP(max_w, 64);

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_vp9_req_lat_if.c

582

max_sb_h = DIV_ROUND_UP(max_h, 64);

drivers/media/platform/mediatek/vcodec/encoder/venc_vpu_if.c

182

return DIV_ROUND_UP(enc_prm->width, 16) *

drivers/media/platform/mediatek/vcodec/encoder/venc_vpu_if.c

183

DIV_ROUND_UP(enc_prm->height, 16);

drivers/media/platform/nxp/dw100/dw100.c

283

return DIV_ROUND_UP(length, DW100_BLOCK_SIZE) + 1;

drivers/media/platform/nxp/dw100/dw100.c

44

#define DW100_DEF_LUT_W (DIV_ROUND_UP(DW100_DEF_W, DW100_BLOCK_SIZE) + 1)

drivers/media/platform/nxp/dw100/dw100.c

45

#define DW100_DEF_LUT_H (DIV_ROUND_UP(DW100_DEF_H, DW100_BLOCK_SIZE) + 1)

drivers/media/platform/nxp/imx-jpeg/mxc-jpeg.c

1870

q->bytesperline[0] = q->w_adjusted * DIV_ROUND_UP(precision, 8);

drivers/media/platform/nxp/imx-jpeg/mxc-jpeg.c

1873

q->bytesperline[0] = q->w_adjusted * DIV_ROUND_UP(precision, 8) * 2;

drivers/media/platform/nxp/imx-jpeg/mxc-jpeg.c

1876

q->bytesperline[0] = q->w_adjusted * DIV_ROUND_UP(precision, 8) * q->fmt->nc;

drivers/media/platform/nxp/imx-jpeg/mxc-jpeg.c

1880

q->bytesperline[0] = q->w_adjusted * DIV_ROUND_UP(precision, 8);

drivers/media/platform/qcom/iris/iris_buffer.c

183

y_meta_stride = ALIGN(DIV_ROUND_UP(f->fmt.pix_mp.width, META_STRIDE_ALIGNED >> 1),

drivers/media/platform/qcom/iris/iris_buffer.c

185

y_meta_plane = y_meta_stride * ALIGN(DIV_ROUND_UP(f->fmt.pix_mp.height,

drivers/media/platform/qcom/iris/iris_buffer.c

193

uv_meta_stride = ALIGN(DIV_ROUND_UP(f->fmt.pix_mp.width / 2, META_STRIDE_ALIGNED >> 2),

drivers/media/platform/qcom/iris/iris_buffer.c

195

uv_meta_plane = uv_meta_stride * ALIGN(DIV_ROUND_UP(f->fmt.pix_mp.height / 2,

drivers/media/platform/qcom/iris/iris_buffer.c

24

#define NUM_MBS_4K (DIV_ROUND_UP(MAX_WIDTH, 16) * DIV_ROUND_UP(MAX_HEIGHT, 16))

drivers/media/platform/qcom/iris/iris_power.c

23

mbs = DIV_ROUND_UP(data->height, 16) * DIV_ROUND_UP(data->width, 16);

drivers/media/platform/qcom/iris/iris_utils.h

34

(DIV_ROUND_UP(height, 16) * DIV_ROUND_UP(width, 16))

drivers/media/platform/qcom/iris/iris_vidc.c

438

fps = DIV_ROUND_UP(core->iris_platform_data->max_core_mbps, mbpf);

drivers/media/platform/qcom/iris/iris_vpu_buffer.c

116

u32 frame_height_in_mbs = DIV_ROUND_UP(frame_height, 16);

drivers/media/platform/qcom/iris/iris_vpu_buffer.c

117

u32 frame_width_in_mbs = DIV_ROUND_UP(frame_width, 16);

drivers/media/platform/qcom/iris/iris_vpu_buffer.c

1712

vp9_top_lb += max3(DIV_ROUND_UP(frame_width, BUFFER_ALIGNMENT_16_BYTES) *

drivers/media/platform/qcom/iris/iris_vpu_buffer.c

1714

DIV_ROUND_UP(frame_width, BUFFER_ALIGNMENT_32_BYTES) *

drivers/media/platform/qcom/iris/iris_vpu_buffer.c

1716

DIV_ROUND_UP(frame_width, BUFFER_ALIGNMENT_64_BYTES) *

drivers/media/platform/qcom/iris/iris_vpu_buffer.c

1719

vp9_top_lb += ALIGN((DMA_ALIGNMENT * DIV_ROUND_UP(frame_width, lcu_size)),

drivers/media/platform/qcom/iris/iris_vpu_buffer.c

1721

vp9_top_lb += ALIGN(DMA_ALIGNMENT * 8 * DIV_ROUND_UP(frame_width, lcu_size),

drivers/media/platform/qcom/iris/iris_vpu_buffer.c

1725

num_lcu_per_pipe = (DIV_ROUND_UP(frame_height, lcu_size) / num_vpp_pipes) +

drivers/media/platform/qcom/iris/iris_vpu_buffer.c

1726

(DIV_ROUND_UP(frame_height, lcu_size) % num_vpp_pipes);

drivers/media/platform/qcom/iris/iris_vpu_buffer.c

173

return min_t(u32, (DIV_ROUND_UP(height, 16) * 48), H264D_MAX_SLICE) *

drivers/media/platform/qcom/iris/iris_vpu_buffer.c

1941

u32 dma_opb_wr_tlb_y_size = DIV_ROUND_UP(frame_width_coded, 16) * opb_packet_bytes;

drivers/media/platform/qcom/iris/iris_vpu_buffer.c

1942

u32 dma_opb_wr_tlb_uv_size = DIV_ROUND_UP(frame_width_coded, 16) * opb_packet_bytes;

drivers/media/platform/qcom/iris/iris_vpu_buffer.c

219

size = min_t(u32, (DIV_ROUND_UP(height, 16) * 48), H264D_MAX_SLICE) *

drivers/media/platform/qcom/iris/iris_vpu_buffer.h

141

#define NUM_MBS_4K (DIV_ROUND_UP(MAX_WIDTH, 16) * DIV_ROUND_UP(MAX_HEIGHT, 16))

drivers/media/platform/qcom/iris/iris_vpu_buffer.h

160

return MAX_FE_NBR_CTRL_LCU64_LINE_BUFFER_SIZE * DIV_ROUND_UP(frame_width, 16);

drivers/media/platform/qcom/iris/iris_vpu_buffer.h

165

return MAX_FE_NBR_CTRL_LCU64_LINE_BUFFER_SIZE * DIV_ROUND_UP(frame_height, 16);

drivers/media/platform/qcom/iris/iris_vpu_buffer.h

170

return MAX_SE_NBR_CTRL_LCU64_LINE_BUFFER_SIZE * DIV_ROUND_UP(frame_width, 16);

drivers/media/platform/qcom/iris/iris_vpu_buffer.h

175

return MAX_SE_NBR_CTRL_LCU64_LINE_BUFFER_SIZE * DIV_ROUND_UP(frame_height, 16);

drivers/media/platform/qcom/iris/iris_vpu_buffer.h

180

return MAX_PE_NBR_DATA_LCU64_LINE_BUFFER_SIZE * DIV_ROUND_UP(frame_width, 16);

drivers/media/platform/qcom/iris/iris_vpu_buffer.h

185

return (DIV_ROUND_UP(frame_width, 16) << 7);

drivers/media/platform/qcom/iris/iris_vpu_buffer.h

195

return DIV_ROUND_UP(frame_width, 64) * DIV_ROUND_UP(frame_height, 64) * 128;

drivers/media/platform/qcom/venus/helpers.c

1019

y_meta_stride = ALIGN(DIV_ROUND_UP(width, 32), 64);

drivers/media/platform/qcom/venus/helpers.c

1020

y_meta_scanlines = ALIGN(DIV_ROUND_UP(height, 4), 16);

drivers/media/platform/qcom/venus/helpers.c

1022

uv_meta_stride = ALIGN(DIV_ROUND_UP((width + 1) >> 1, 16), 64);

drivers/media/platform/qcom/venus/helpers.c

1023

uv_meta_scanlines = ALIGN(DIV_ROUND_UP((height + 1) >> 1, 4), 16);

drivers/media/platform/qcom/venus/helpers.c

1048

y_meta_stride = ALIGN(DIV_ROUND_UP(width, 48), 64);

drivers/media/platform/qcom/venus/helpers.c

1049

y_meta_scanlines = ALIGN(DIV_ROUND_UP(height, 4), 16);

drivers/media/platform/qcom/venus/helpers.c

1051

uv_meta_stride = ALIGN(DIV_ROUND_UP((width + 1) >> 1, 24), 64);

drivers/media/platform/qcom/venus/helpers.c

1052

uv_meta_scanlines = ALIGN(DIV_ROUND_UP((height + 1) >> 1, 4), 16);

drivers/media/platform/qcom/venus/helpers.c

971

y_meta_stride = ALIGN(DIV_ROUND_UP(width, 32), 64);

drivers/media/platform/qcom/venus/helpers.c

972

y_meta_plane = y_meta_stride * ALIGN(DIV_ROUND_UP(height, 8), 16);

drivers/media/platform/qcom/venus/helpers.c

978

uv_meta_stride = ALIGN(DIV_ROUND_UP(width / 2, 16), 64);

drivers/media/platform/qcom/venus/helpers.c

979

uv_meta_plane = uv_meta_stride * ALIGN(DIV_ROUND_UP(height / 2, 8), 16);

drivers/media/platform/renesas/rcar-csi2.c

1352

val = DIV_ROUND_UP(5 * mbps, 64);

drivers/media/platform/renesas/rcar-csi2.c

1399

val = DIV_ROUND_UP(1200, mbps) + 12;

drivers/media/platform/renesas/rzg2l-cru/rzg2l-csi2.c

444

frrskw = DIV_ROUND_UP(frrskw_coeff, csi2->hsfreq);

drivers/media/platform/renesas/rzg2l-cru/rzg2l-csi2.c

445

frrclk = DIV_ROUND_UP(frrclk_coeff, csi2->hsfreq);

drivers/media/platform/renesas/vsp1/vsp1_video.c

722

pipe->partitions = DIV_ROUND_UP(format->width, div_size);

drivers/media/platform/rockchip/rga/rga-buf.c

86

n_desc = DIV_ROUND_UP(f->size, PAGE_SIZE);

drivers/media/platform/rockchip/rkisp1/rkisp1-capture.c

1231

stride = clamp(DIV_ROUND_UP(plane_y->bytesperline, info->bpp[0]),

drivers/media/platform/rockchip/rkisp1/rkisp1-capture.c

1243

plane->bytesperline = DIV_ROUND_UP(stride, info->hdiv) *

drivers/media/platform/rockchip/rkisp1/rkisp1-capture.c

1246

DIV_ROUND_UP(pixm->height, info->vdiv);

drivers/media/platform/rockchip/rkisp1/rkisp1-params.c

1267

DIV_ROUND_UP(RKISP1_CIF_ISP_COMPAND_NUM_POINTS,

drivers/media/platform/rockchip/rkvdec/rkvdec.c

93

return 128 * DIV_ROUND_UP(width, 16) * DIV_ROUND_UP(height, 16);

drivers/media/platform/samsung/s5p-jpeg/jpeg-core.c

2250

bitstream_size = DIV_ROUND_UP(ctx->out_q.size, 16);

drivers/media/platform/samsung/s5p-jpeg/jpeg-core.c

2254

bitstream_size = DIV_ROUND_UP(ctx->out_q.size, 32);

drivers/media/platform/samsung/s5p-mfc/regs-mfc-v10.h

69

+ ((y * 64) + 1280) * DIV_ROUND_UP(x, 8))

drivers/media/platform/samsung/s5p-mfc/regs-mfc-v10.h

73

+ (DIV_ROUND_UP(x * y, 64) * 32))

drivers/media/platform/samsung/s5p-mfc/regs-mfc-v10.h

77

+ (DIV_ROUND_UP(x * y, 128) * 16))

drivers/media/platform/samsung/s5p-mfc/regs-mfc-v10.h

84

+ ((y * 128) + 1280) * DIV_ROUND_UP(x, 4))

drivers/media/platform/samsung/s5p-mfc/regs-mfc-v12.h

39

+ (DIV_ROUND_UP((x) * (y), 64) * 32)), 256)

drivers/media/platform/samsung/s5p-mfc/regs-mfc-v12.h

43

+ (DIV_ROUND_UP((x) * (y), 128) * 16)), 256)

drivers/media/platform/samsung/s5p-mfc/regs-mfc-v6.h

380

(((((imw + 127) / 64) * 16) * DIV_ROUND_UP(imh, 64) * 256) + \

drivers/media/platform/samsung/s5p-mfc/regs-mfc-v6.h

381

(DIV_ROUND_UP((mbw) * (mbh), 32) * 16))

drivers/media/platform/samsung/s5p-mfc/regs-mfc-v8.h

114

((DIV_ROUND_UP((mbw * 16), 64) * DIV_ROUND_UP((mbh * 16), 64) * 256) \

drivers/media/platform/samsung/s5p-mfc/regs-mfc-v8.h

115

+ (DIV_ROUND_UP((mbw) * (mbh), 32) * 16))

drivers/media/platform/samsung/s5p-mfc/s5p_mfc_opr_v6.c

100

ALIGN(DIV_ROUND_UP(lcu_width *

drivers/media/platform/samsung/s5p-mfc/s5p_mfc_opr_v6.c

476

mbX = DIV_ROUND_UP(width, S5P_FIMV_NUM_PIXELS_IN_MB_ROW_V6);

drivers/media/platform/samsung/s5p-mfc/s5p_mfc_opr_v6.c

477

mbY = DIV_ROUND_UP(height, S5P_FIMV_NUM_PIXELS_IN_MB_COL_V6);

drivers/media/platform/samsung/s5p-mfc/s5p_mfc_opr_v6.c

93

ALIGN(DIV_ROUND_UP(lcu_width * 32, 4), 16) * height32 + 128;

drivers/media/platform/samsung/s5p-mfc/s5p_mfc_opr_v6.h

20

#define MB_WIDTH(x_size) DIV_ROUND_UP(x_size, 16)

drivers/media/platform/samsung/s5p-mfc/s5p_mfc_opr_v6.h

21

#define MB_HEIGHT(y_size) DIV_ROUND_UP(y_size, 16)

drivers/media/platform/samsung/s5p-mfc/s5p_mfc_opr_v6.h

24

#define S5P_MFC_LCU_WIDTH(x_size) DIV_ROUND_UP(x_size, 32)

drivers/media/platform/samsung/s5p-mfc/s5p_mfc_opr_v6.h

25

#define S5P_MFC_LCU_HEIGHT(y_size) DIV_ROUND_UP(y_size, 32)

drivers/media/platform/samsung/s5p-mfc/s5p_mfc_opr_v6.h

28

(DIV_ROUND_UP(x, 64) * DIV_ROUND_UP(y, 64) * 256 + 512)

drivers/media/platform/st/stm32/stm32-dcmi.c

545

num_sgs = DIV_ROUND_UP(buf->size, dcmi->dma_max_burst);

drivers/media/platform/sunxi/sun6i-csi/sun6i_csi_capture.c

365

address += info->bpp[1] * DIV_ROUND_UP(width, info->hdiv) *

drivers/media/platform/sunxi/sun6i-csi/sun6i_csi_capture.c

366

DIV_ROUND_UP(height, info->vdiv);

drivers/media/platform/synopsys/hdmirx/snps_hdmirx_cec.c

69

data_len = DIV_ROUND_UP(msg_len, 4);

drivers/media/platform/ti/am437x/am437x-vpfe.c

149

clocksperpixel = DIV_ROUND_UP(fmt->bitsperpixel, bus_width);

drivers/media/platform/ti/cal/cal-camerarx.c

396

sscounter = DIV_ROUND_UP(clk_get_rate(phy->cal->fclk), 10000 * 16 * 4);

drivers/media/platform/ti/omap3isp/ispccdc.c

854

div = DIV_ROUND_UP(l3_ick, pipe->max_rate);

drivers/media/platform/ti/omap3isp/ispccp2.c

402

vpclk_div = max_t(unsigned int, DIV_ROUND_UP(l3_ick, pipe->max_rate),

drivers/media/platform/ti/omap3isp/ispcsiphy.c

224

reg |= (DIV_ROUND_UP(25 * csi2_ddrclk_khz, 2000000) - 1)

drivers/media/platform/ti/omap3isp/ispcsiphy.c

227

reg |= (DIV_ROUND_UP(90 * csi2_ddrclk_khz, 1000000) + 3)

drivers/media/platform/ti/omap3isp/isppreview.c

1188

minimum = DIV_ROUND_UP(cycles_per_request, 32);

drivers/media/platform/ti/omap3isp/isppreview.c

1197

requests_per_frame = DIV_ROUND_UP(ifmt->width * 2, 256) * ifmt->height;

drivers/media/platform/ti/omap3isp/ispresizer.c

579

minimum = DIV_ROUND_UP(cycles_per_request, granularity);

drivers/media/platform/ti/omap3isp/ispresizer.c

588

requests_per_frame = DIV_ROUND_UP(res->crop.active.width * 2, 256)

drivers/media/platform/verisilicon/hantro_hw.h

25

#define MB_WIDTH(w) DIV_ROUND_UP(w, MB_DIM)

drivers/media/platform/verisilicon/hantro_hw.h

26

#define MB_HEIGHT(h) DIV_ROUND_UP(h, MB_DIM)

drivers/media/platform/verisilicon/hantro_hw.h

551

return DIV_ROUND_UP(dimension, 64);

drivers/media/platform/verisilicon/hantro_vp8.c

154

mb_width = DIV_ROUND_UP(ctx->dst_fmt.width, 16);

drivers/media/platform/verisilicon/hantro_vp8.c

155

mb_height = DIV_ROUND_UP(ctx->dst_fmt.height, 16);

drivers/media/platform/verisilicon/hantro_vp8.c

156

segment_map_size = round_up(DIV_ROUND_UP(mb_width * mb_height, 4), 64);

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

1582

int pic_width_in_cbs = DIV_ROUND_UP(frame->frame_width_minus_1 + 1, 8);

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

1583

int pic_height_in_cbs = DIV_ROUND_UP(frame->frame_height_minus_1 + 1, 8);

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

1611

int cur_mi_cols = DIV_ROUND_UP(frame->frame_width_minus_1 + 1, 8);

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

1612

int cur_mi_rows = DIV_ROUND_UP(frame->frame_height_minus_1 + 1, 8);

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

167

av1_dec->frame_refs[i].mi_cols = DIV_ROUND_UP(frame->frame_width_minus_1 + 1, 8);

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

168

av1_dec->frame_refs[i].mi_rows = DIV_ROUND_UP(frame->frame_height_minus_1 + 1, 8);

drivers/media/rc/ite-cir.c

452

mdelay(DIV_ROUND_UP(remaining_us, 1000));

drivers/media/rc/mceusb.c

1078

units = DIV_ROUND_UP(timeout, MCE_TIME_UNIT);

drivers/media/rc/nuvoton-cir.c

176

tolerance = DIV_ROUND_UP(count, 10);

drivers/media/rc/sunxi-cir.c

153

return DIV_ROUND_UP((base_clk / (128 * 64)) * usec, USEC_PER_SEC) - 1;

drivers/media/test-drivers/vidtv/vidtv_s302m.c

214

s = DIV_ROUND_UP(vau_duration_usecs, sample_duration_usecs);

drivers/media/test-drivers/vivid/vivid-ctrls.c

247

.dims = { DIV_ROUND_UP(360, PIXEL_ARRAY_DIV),

drivers/media/test-drivers/vivid/vivid-ctrls.c

248

DIV_ROUND_UP(640, PIXEL_ARRAY_DIV) },

drivers/media/test-drivers/vivid/vivid-vid-cap.c

459

dims[0] = DIV_ROUND_UP(dev->src_rect.height, PIXEL_ARRAY_DIV);

drivers/media/test-drivers/vivid/vivid-vid-cap.c

460

dims[1] = DIV_ROUND_UP(dev->src_rect.width, PIXEL_ARRAY_DIV);

drivers/media/tuners/msi001.c

221

uitmp = DIV_ROUND_UP(k_thresh, 4095);

drivers/media/tuners/mt2063.c

713

n0 = DIV_ROUND_UP(f_LO2 - d, f_LO1 - f_LO2);

drivers/media/tuners/qm1d1b0004.c

146

lpf = DIV_ROUND_UP(lpf_freq, 2000) - 2;

drivers/media/usb/em28xx/em28xx-audio.c

712

bytes_per_transfer = DIV_ROUND_UP(48000 * 2 * 2, 125 * interval);

drivers/media/usb/em28xx/em28xx-audio.c

718

num_urb = DIV_ROUND_UP(bytes_per_transfer, ep_size);

drivers/media/usb/em28xx/em28xx-audio.c

736

npackets = DIV_ROUND_UP(urb_size, ep_size);

drivers/media/usb/uvc/uvc_ctrl.c

1641

return DIV_ROUND_UP(mapping->size, 8);

drivers/media/usb/uvc/uvc_driver.c

407

format->bpp = DIV_ROUND_UP(8 * n, div);

drivers/media/usb/uvc/uvc_video.c

1811

npackets = DIV_ROUND_UP(size, psize);

drivers/media/v4l2-core/v4l2-common.c

413

return DIV_ROUND_UP(aligned_width, hdiv) *

drivers/media/v4l2-core/v4l2-common.c

424

return DIV_ROUND_UP(aligned_height, vdiv);

drivers/memory/atmel-ebi.c

128

ncycles = DIV_ROUND_UP(val, clk_period_ns);

drivers/memory/atmel-ebi.c

158

ncycles = DIV_ROUND_UP(val, clk_period_ns);

drivers/memory/emif.c

306

val = DIV_ROUND_UP(T_ZQCL_DEFAULT_NS, T_ZQCS_DEFAULT_NS) - 1;

drivers/memory/emif.c

309

val = DIV_ROUND_UP(T_ZQINIT_DEFAULT_NS, T_ZQCL_DEFAULT_NS) - 1;

drivers/memory/pl172.c

65

cycles = DIV_ROUND_UP(val * pl172->rate, NSEC_PER_MSEC) - start;

drivers/memory/stm32-fmc2-ebi.c

419

return DIV_ROUND_UP(setup * 1000, hclkp);

drivers/memory/stm32-fmc2-ebi.c

442

return DIV_ROUND_UP(nb_clk_cycles, clk_period);

drivers/memory/stm32-fmc2-ebi.c

466

return DIV_ROUND_UP(nb_clk_cycles, clk_period);

drivers/memory/stm32_omm.c

242

req2ack = DIV_ROUND_UP(req2ack, NSEC_PER_SEC / clk_rate_max) - 1;

drivers/memory/tegra/tegra20.c

475

stat->gather0.result = DIV_ROUND_UP(count0, clocks);

drivers/memory/tegra/tegra20.c

476

stat->gather1.result = DIV_ROUND_UP(count1, clocks);

drivers/memory/ti-aemif.c

208

result = DIV_ROUND_UP((wanted * clk), NSEC_PER_MSEC) - 1;

drivers/memstick/core/ms_block.c

1280

DIV_ROUND_UP(data_size + page_offset, msb->page_size) *

drivers/mfd/fsl-imx25-tsadc.c

113

clk_div = DIV_ROUND_UP(clk_get_rate(tsadc->clk), 1750000);

drivers/mfd/mcp-sa11x0.c

217

mcp->rw_timeout = DIV_ROUND_UP(64 * 3 * 1000000, mcp->sclk_rate);

drivers/mfd/qcom-pm8xxx.c

557

chip->num_blocks = DIV_ROUND_UP(data->num_irqs, 8);

drivers/mfd/qcom-pm8xxx.c

558

chip->num_masters = DIV_ROUND_UP(chip->num_blocks, 8);

drivers/mfd/stmpe.c

1084

int num = DIV_ROUND_UP(variant->num_irqs, 8);

drivers/mfd/stmpe.c

1143

int num = DIV_ROUND_UP(variant->num_irqs, 8);

drivers/mfd/stmpe.c

265

int numregs = DIV_ROUND_UP(stmpe->num_gpios * af_bits, 8);

drivers/mfd/twl4030-irq.c

85

.bytes_ixr = DIV_ROUND_UP(nbits, 8), \

drivers/mfd/twl4030-irq.c

87

.bytes_edr = DIV_ROUND_UP((2*(nbits)), 8), \

drivers/misc/eeprom/at24.c

671

num_addresses = DIV_ROUND_UP(byte_len,

drivers/misc/genwqe/card_dev.c

456

dma_map->nr_pages = DIV_ROUND_UP(vsize, PAGE_SIZE);

drivers/misc/genwqe/card_utils.c

299

sgl->nr_pages = DIV_ROUND_UP(sgl->fpage_offs + user_size, PAGE_SIZE);

drivers/misc/genwqe/card_utils.c

566

m->nr_pages = DIV_ROUND_UP(offs + size, PAGE_SIZE);

drivers/misc/mei/mei_dev.h

674

return DIV_ROUND_UP(length, MEI_SLOT_SIZE);

drivers/misc/mei/mei_dev.h

687

return DIV_ROUND_UP(sizeof(struct mei_msg_hdr) + length, MEI_SLOT_SIZE);

drivers/misc/sgi-gru/gruhandles.h

61

#define GRU_DS_BYTES_TO_AU(n) DIV_ROUND_UP(n, GRU_DSR_AU_BYTES)

drivers/misc/sgi-gru/gruhandles.h

62

#define GRU_CB_COUNT_TO_AU(n) DIV_ROUND_UP(n, GRU_CBR_AU_SIZE)

drivers/misc/sgi-gru/grukservices.c

805

clines = DIV_ROUND_UP(bytes, GRU_CACHE_LINE_BYTES);

drivers/misc/vmw_vmci/vmci_queue_pair.c

1103

DIV_ROUND_UP(produce_size, PAGE_SIZE) + 1;

drivers/misc/vmw_vmci/vmci_queue_pair.c

1105

DIV_ROUND_UP(consume_size, PAGE_SIZE) + 1;

drivers/misc/vmw_vmci/vmci_queue_pair.c

1384

(DIV_ROUND_UP(entry->qp.produce_size, PAGE_SIZE) + 1);

drivers/misc/vmw_vmci/vmci_queue_pair.c

238

(DIV_ROUND_UP(_QPE.produce_size, PAGE_SIZE) + \

drivers/misc/vmw_vmci/vmci_queue_pair.c

239

DIV_ROUND_UP(_QPE.consume_size, PAGE_SIZE) + 2))

drivers/misc/vmw_vmci/vmci_queue_pair.c

256

for (i = 0; i < DIV_ROUND_UP(size, PAGE_SIZE) + 1; i++) {

drivers/misc/vmw_vmci/vmci_queue_pair.c

282

num_pages = DIV_ROUND_UP(size, PAGE_SIZE) + 1;

drivers/misc/vmw_vmci/vmci_queue_pair.c

535

num_pages = DIV_ROUND_UP(size, PAGE_SIZE) + 1;

drivers/misc/vmw_vmci/vmci_queue_pair.c

889

const u64 num_ppns = DIV_ROUND_UP(produce_size, PAGE_SIZE) +

drivers/misc/vmw_vmci/vmci_queue_pair.c

890

DIV_ROUND_UP(consume_size, PAGE_SIZE) + 2;

drivers/mmc/core/block.c

1032

unsigned int ms = DIV_ROUND_UP(data->timeout_ns, 1000000);

drivers/mmc/core/block.c

1037

ms += DIV_ROUND_UP(data->timeout_clks, khz);

drivers/mmc/core/mmc.c

1976

unsigned int timeout_ms = DIV_ROUND_UP(card->ext_csd.sa_timeout, 10000);

drivers/mmc/core/mmc_test.c

333

unsigned long max_page_cnt = DIV_ROUND_UP(max_sz, PAGE_SIZE);

drivers/mmc/core/mmc_test.c

334

unsigned long min_page_cnt = DIV_ROUND_UP(min_sz, PAGE_SIZE);

drivers/mmc/core/mmc_test.c

335

unsigned long max_seg_page_cnt = DIV_ROUND_UP(max_seg_sz, PAGE_SIZE);

drivers/mmc/core/sdio_ops.c

152

nents = DIV_ROUND_UP(left_size, seg_size);

drivers/mmc/host/alcor.c

669

tmp_div = DIV_ROUND_UP(cfg->clk_src_freq, clock);

drivers/mmc/host/alcor.c

673

tmp_clock = DIV_ROUND_UP(cfg->clk_src_freq, tmp_div);

drivers/mmc/host/atmel-mci.c

1451

clkdiv = DIV_ROUND_UP(host->bus_hz, clock_min) - 2;

drivers/mmc/host/atmel-mci.c

1466

clkdiv = DIV_ROUND_UP(host->bus_hz, 2 * clock_min) - 1;

drivers/mmc/host/atmel-mci.c

2271

mmc->f_min = DIV_ROUND_UP(host->bus_hz, 512);

drivers/mmc/host/atmel-mci.c

749

unsigned int us = DIV_ROUND_UP(ns, 1000);

drivers/mmc/host/atmel-mci.c

752

return us * (DIV_ROUND_UP(host->bus_hz, 2000000));

drivers/mmc/host/bcm2835.c

639

timeout = DIV_ROUND_UP(cmd->busy_timeout, 1000) * HZ + HZ;

drivers/mmc/host/dw_mmc-rockchip.c

285

(DIV_ROUND_UP((i) * 360, num_phases))

drivers/mmc/host/dw_mmc-rockchip.c

343

i += DIV_ROUND_UP(20 * priv->num_phases, 360);

drivers/mmc/host/dw_mmc.c

1229

div = (host->bus_hz != clock) ? DIV_ROUND_UP(div, 2) : 0;

drivers/mmc/host/loongson2-mmc.c

522

pre = DIV_ROUND_UP(host->current_clk, ios->clock);

drivers/mmc/host/loongson2-mmc.c

941

mmc->f_min = DIV_ROUND_UP(host->current_clk, 256);

drivers/mmc/host/meson-gx-mmc.c

533

max_dly = DIV_ROUND_UP(clk_get_rate(host->mux_clk),

drivers/mmc/host/mmci.c

1920

max_busy_timeout = U32_MAX / DIV_ROUND_UP(mmc->actual_clock,

drivers/mmc/host/mmci.c

2307

mmc->f_min = DIV_ROUND_UP(host->mclk, 257);

drivers/mmc/host/mmci.c

2309

mmc->f_min = DIV_ROUND_UP(host->mclk, 2046);

drivers/mmc/host/mmci.c

2313

mmc->f_min = DIV_ROUND_UP(host->mclk, 512);

drivers/mmc/host/mmci.c

463

clk = DIV_ROUND_UP(host->mclk, desired) - 2;

drivers/mmc/host/mmci_stm32_sdmmc.c

315

clk = DIV_ROUND_UP(host->mclk, 2 * desired);

drivers/mmc/host/mtk-sd.c

3057

mmc->f_min = DIV_ROUND_UP(host->src_clk_freq, 4 * 255);

drivers/mmc/host/mtk-sd.c

3059

mmc->f_min = DIV_ROUND_UP(host->src_clk_freq, 4 * 4095);

drivers/mmc/host/mtk-sd.c

887

timeout = DIV_ROUND_UP(timeout, BIT(20));

drivers/mmc/host/mvsdio.c

613

u32 m = DIV_ROUND_UP(host->base_clock, ios->clock) - 1;

drivers/mmc/host/mvsdio.c

734

mmc->f_min = DIV_ROUND_UP(host->base_clock, MVSD_BASE_DIV_MAX);

drivers/mmc/host/mvsdio.c

88

tmout = DIV_ROUND_UP(data->timeout_ns, host->ns_per_clk);

drivers/mmc/host/omap.c

181

tick_ns = DIV_ROUND_UP(NSEC_PER_SEC, slot->fclk_freq);

drivers/mmc/host/omap.c

447

tick_ns = DIV_ROUND_UP(NSEC_PER_SEC, slot->fclk_freq);

drivers/mmc/host/omap.c

491

timeout = DIV_ROUND_UP(120 * USEC_PER_SEC, slot->fclk_freq);

drivers/mmc/host/omap.c

686

nwords = DIV_ROUND_UP(n, 2);

drivers/mmc/host/omap_hsmmc.c

525

dsor = DIV_ROUND_UP(clk_get_rate(host->fclk), ios->clock);

drivers/mmc/host/sdhci-of-at91.c

210

preset_div = DIV_ROUND_UP(gck_rate, 24000000) - 1;

drivers/mmc/host/sdhci-of-at91.c

213

preset_div = DIV_ROUND_UP(gck_rate, 50000000) - 1;

drivers/mmc/host/sdhci-of-at91.c

216

preset_div = DIV_ROUND_UP(gck_rate, 100000000) - 1;

drivers/mmc/host/sdhci-of-at91.c

219

preset_div = DIV_ROUND_UP(gck_rate, 120000000) - 1;

drivers/mmc/host/sdhci-of-at91.c

222

preset_div = DIV_ROUND_UP(gck_rate, 50000000) - 1;

drivers/mmc/host/sdhci-omap.c

415

DIV_ROUND_UP(13 * max_len, 16) * 4);

drivers/mmc/host/sdhci-omap.c

417

phase_delay = max_window + DIV_ROUND_UP(9 * max_len, 16) * 4;

drivers/mmc/host/sdhci-omap.c

419

phase_delay = max_window + DIV_ROUND_UP(8 * max_len, 16) * 4;

drivers/mmc/host/sdhci-omap.c

421

phase_delay = max_window + DIV_ROUND_UP(7 * max_len, 16) * 4;

drivers/mmc/host/sdhci-omap.c

423

phase_delay = max_window + DIV_ROUND_UP(5 * max_len, 16) * 4;

drivers/mmc/host/sdhci-omap.c

425

phase_delay = max_window + DIV_ROUND_UP(4 * max_len, 16) * 4;

drivers/mmc/host/sdhci-omap.c

427

phase_delay = max_window + DIV_ROUND_UP(3 * max_len, 16) * 4;

drivers/mmc/host/sdhci-omap.c

672

dsor = DIV_ROUND_UP(clk_get_rate(host->clk), clock);

drivers/mmc/host/sdhci-uhs2.c

722

timeout += DIV_ROUND_UP(cmd->busy_timeout, 1000) * HZ + HZ;

drivers/mmc/host/sdhci.c

1731

timeout += DIV_ROUND_UP(cmd->busy_timeout, 1000) * HZ + HZ;

drivers/mmc/host/sdhci.c

4492

DIV_ROUND_UP(host->ops->get_timeout_clock(host),

drivers/mmc/host/sdhci.c

917

target_timeout = DIV_ROUND_UP(data->timeout_ns, 1000);

drivers/mmc/host/sh_mmcif.c

529

clkdiv = (fls(DIV_ROUND_UP(current_clk, clk) - 1) - 1) << 16;

drivers/mmc/host/usdhi6rol0.c

759

roundup_pow_of_two(DIV_ROUND_UP(host->imclk, rate));

drivers/mtd/chips/cfi_cmdset_0001.c

1793

words = DIV_ROUND_UP(len - word_gap, map_bankwidth(map));

drivers/mtd/chips/cfi_util.c

28

msleep(DIV_ROUND_UP(us, 1000));

drivers/mtd/devices/docg3.c

1821

bbt_nbpages = DIV_ROUND_UP(docg3->max_block + 1,

drivers/mtd/devices/docg3.c

990

nbpages = DIV_ROUND_UP(docg3->max_block + 1, 8 * DOC_LAYOUT_PAGE_SIZE);

drivers/mtd/devices/spear_smi.c

333

prescale = DIV_ROUND_UP(rate, dev->clk_rate);

drivers/mtd/devices/st_spi_fsm.c

1907

clk_div = 2 * DIV_ROUND_UP(emi_freq, 2 * spi_freq);

drivers/mtd/devices/st_spi_fsm.c

1924

fsm->fifo_dir_delay = DIV_ROUND_UP(clk_div, 10);

drivers/mtd/ftl.c

394

nbam = DIV_ROUND_UP(part->BlocksPerUnit * sizeof(uint32_t) +

drivers/mtd/mtdoops.c

359

vmalloc_array(DIV_ROUND_UP(mtdoops_pages, BITS_PER_LONG),

drivers/mtd/nand/ecc-sw-bch.c

219

code_size = DIV_ROUND_UP(conf->strength *

drivers/mtd/nand/raw/ams-delta.c

208

priv->tRP = DIV_ROUND_UP(sdr->tRP_min, 1000);

drivers/mtd/nand/raw/ams-delta.c

212

priv->tWP = DIV_ROUND_UP(sdr->tWP_min, 1000);

drivers/mtd/nand/raw/arasan-nand-controller.c

1081

return DIV_ROUND_UP(ecc_bits, 8);

drivers/mtd/nand/raw/arasan-nand-controller.c

1169

ecc->bytes = DIV_ROUND_UP(anand->ecc_bits, 8);

drivers/mtd/nand/raw/arasan-nand-controller.c

1170

anand->ecc_total = DIV_ROUND_UP(anand->ecc_bits * ecc->steps, 8);

drivers/mtd/nand/raw/atmel/nand-controller.c

1270

ncycles = DIV_ROUND_UP(conf->timings.sdr.tWP_min, mckperiodps);

drivers/mtd/nand/raw/atmel/nand-controller.c

1291

ncycles = DIV_ROUND_UP(timeps, mckperiodps);

drivers/mtd/nand/raw/atmel/nand-controller.c

1309

ncycles = DIV_ROUND_UP(timeps, mckperiodps);

drivers/mtd/nand/raw/atmel/nand-controller.c

1319

ncycles = DIV_ROUND_UP(conf->timings.sdr.tWC_min, mckperiodps);

drivers/mtd/nand/raw/atmel/nand-controller.c

1345

ncycles = DIV_ROUND_UP(timeps, mckperiodps);

drivers/mtd/nand/raw/atmel/nand-controller.c

1351

ncycles = DIV_ROUND_UP(conf->timings.sdr.tRHZ_max, mckperiodps);

drivers/mtd/nand/raw/atmel/nand-controller.c

1378

ncycles = DIV_ROUND_UP(pulse, mckperiodps);

drivers/mtd/nand/raw/atmel/nand-controller.c

1391

ncycles = DIV_ROUND_UP(timeps, mckperiodps);

drivers/mtd/nand/raw/atmel/nand-controller.c

1404

ncycles = DIV_ROUND_UP(conf->timings.sdr.tRC_min, mckperiodps);

drivers/mtd/nand/raw/atmel/nand-controller.c

1424

ncycles = DIV_ROUND_UP(conf->timings.sdr.tCLR_min, mckperiodps);

drivers/mtd/nand/raw/atmel/nand-controller.c

1431

ncycles = DIV_ROUND_UP(conf->timings.sdr.tADL_min, mckperiodps);

drivers/mtd/nand/raw/atmel/nand-controller.c

1449

ncycles = DIV_ROUND_UP(conf->timings.sdr.tAR_min, mckperiodps);

drivers/mtd/nand/raw/atmel/nand-controller.c

1456

ncycles = DIV_ROUND_UP(conf->timings.sdr.tRR_min, mckperiodps);

drivers/mtd/nand/raw/atmel/nand-controller.c

1463

ncycles = DIV_ROUND_UP(conf->timings.sdr.tWB_max, mckperiodps);

drivers/mtd/nand/raw/atmel/pmecc.c

317

nbytes = DIV_ROUND_UP(strength * fls(8 * req->ecc.sectorsize),

drivers/mtd/nand/raw/brcmnand/brcmnand.c

1446

ecc->bytes = DIV_ROUND_UP(ecc_level * 14, 8);

drivers/mtd/nand/raw/brcmnand/brcmnand.c

2848

brcmnand_wr_corr_thresh(host, DIV_ROUND_UP(chip->ecc.strength * 3, 4));

drivers/mtd/nand/raw/cadence-nand-controller.c

1107

int nbytes = DIV_ROUND_UP(fls(8 * max_step_size) * strength, 8);

drivers/mtd/nand/raw/davinci_nand.c

820

#define TO_CYCLES(ps, period_ns) (DIV_ROUND_UP((ps) / 1000, (period_ns)))

drivers/mtd/nand/raw/denali.c

801

re_2_we = DIV_ROUND_UP(timings->tRHW_min, t_x);

drivers/mtd/nand/raw/denali.c

810

re_2_re = DIV_ROUND_UP(timings->tRHZ_max, t_x);

drivers/mtd/nand/raw/denali.c

824

we_2_re = DIV_ROUND_UP(max(timings->tCCS_min, timings->tWHR_min), t_x);

drivers/mtd/nand/raw/denali.c

839

addr_2_data = DIV_ROUND_UP(timings->tADL_min, t_x);

drivers/mtd/nand/raw/denali.c

848

rdwr_en_hi = DIV_ROUND_UP(max(timings->tREH_min, timings->tWH_min),

drivers/mtd/nand/raw/denali.c

871

acc_clks = DIV_ROUND_UP(timings->tREA_max + data_setup_on_host, t_x);

drivers/mtd/nand/raw/denali.c

874

rdwr_en_lo = DIV_ROUND_UP(max(timings->tRP_min, timings->tWP_min), t_x);

drivers/mtd/nand/raw/denali.c

881

rdwr_en_lo_hi = DIV_ROUND_UP(max(timings->tRC_min, timings->tWC_min),

drivers/mtd/nand/raw/denali.c

888

DIV_ROUND_UP(timings->tRHOH_min, t_x)) / 2;

drivers/mtd/nand/raw/denali.c

902

cs_setup = max3((int)DIV_ROUND_UP(timings->tCS_min, t_x) - rdwr_en_lo,

drivers/mtd/nand/raw/denali.c

903

(int)DIV_ROUND_UP(timings->tCEA_max, t_x) - acc_clks,

drivers/mtd/nand/raw/denali.c

918

return DIV_ROUND_UP(strength * fls(step_size * 8), 16) * 2;

drivers/mtd/nand/raw/fsmc_nand.c

294

tims->tar = DIV_ROUND_UP(sdrt->tAR_min / 1000, hclkn) - 1;

drivers/mtd/nand/raw/fsmc_nand.c

297

tims->tclr = DIV_ROUND_UP(sdrt->tCLR_min / 1000, hclkn) - 1;

drivers/mtd/nand/raw/fsmc_nand.c

302

tims->thiz = DIV_ROUND_UP(thiz / 1000, hclkn);

drivers/mtd/nand/raw/fsmc_nand.c

315

tims->thold = DIV_ROUND_UP(thold / 1000, hclkn);

drivers/mtd/nand/raw/fsmc_nand.c

323

tims->tset = DIV_ROUND_UP(tset / 1000, hclkn) - 1;

drivers/mtd/nand/raw/fsmc_nand.c

338

tims->twait = DIV_ROUND_UP(twait / 1000, hclkn) - 1;

drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.c

1455

eccbytes = DIV_ROUND_UP(offset + eccbits, 8);

drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.c

895

hw->timing1 = BF_GPMI_TIMING1_BUSY_TIMEOUT(DIV_ROUND_UP(busy_timeout_cycles, 4096));

drivers/mtd/nand/raw/intel-nand-controller.c

202

unsigned int period = DIV_ROUND_UP(USEC_PER_SEC, rate);

drivers/mtd/nand/raw/intel-nand-controller.c

214

trecov = DIV_ROUND_UP(max(timings->tREA_max, timings->tREH_min),

drivers/mtd/nand/raw/intel-nand-controller.c

218

thold = DIV_ROUND_UP(max(timings->tDH_min, timings->tDS_min), period);

drivers/mtd/nand/raw/intel-nand-controller.c

221

trdwait = DIV_ROUND_UP(max(timings->tRC_min, timings->tREH_min),

drivers/mtd/nand/raw/intel-nand-controller.c

225

twrwait = DIV_ROUND_UP(max(timings->tWC_min, timings->tWH_min), period);

drivers/mtd/nand/raw/intel-nand-controller.c

487

ecc_bytes = DIV_ROUND_UP(ecc_strength_ds * fls(8 * ecc_size), 8);

drivers/mtd/nand/raw/lpc32xx_slc.c

86

#define SLCTAC_CLOCKS(c, n, s) (min_t(u32, DIV_ROUND_UP(c, n) - 1, 0xF) << s)

drivers/mtd/nand/raw/marvell_nand.c

2417

nfc_tmg.tRP = TO_CYCLES(DIV_ROUND_UP(sdr->tRC_min, 2), period_ns) - 1;

drivers/mtd/nand/raw/marvell_nand.c

2419

nfc_tmg.tWP = TO_CYCLES(DIV_ROUND_UP(sdr->tWC_min, 2), period_ns) - 1;

drivers/mtd/nand/raw/marvell_nand.c

473

#define TO_CYCLES(ps, period_ns) (DIV_ROUND_UP(ps / 1000, period_ns))

drivers/mtd/nand/raw/marvell_nand.c

511

udelay(DIV_ROUND_UP(ns, 1000));

drivers/mtd/nand/raw/meson_nand.c

1048

delay_idle = DIV_ROUND_UP(PSEC_TO_NSEC(instr->delay_ns),

drivers/mtd/nand/raw/meson_nand.c

1261

div = DIV_ROUND_UP((timings->tRC_min / 1000), NFC_CLK_CYCLE);

drivers/mtd/nand/raw/meson_nand.c

1266

meson_chip->twb = DIV_ROUND_UP(PSEC_TO_NSEC(timings->tWB_max),

drivers/mtd/nand/raw/meson_nand.c

1268

meson_chip->tadl = DIV_ROUND_UP(PSEC_TO_NSEC(timings->tADL_min),

drivers/mtd/nand/raw/meson_nand.c

1276

bt_min = DIV_ROUND_UP(bt_min, 1000);

drivers/mtd/nand/raw/meson_nand.c

1277

bt_max = DIV_ROUND_UP(bt_max, 1000);

drivers/mtd/nand/raw/meson_nand.c

228

ecc_bytes = DIV_ROUND_UP(strength * fls(step_size * 8), 8);

drivers/mtd/nand/raw/mtk_nand.c

1169

ecc_bytes = DIV_ROUND_UP(nand->ecc.strength *

drivers/mtd/nand/raw/mtk_nand.c

556

tpoecs = DIV_ROUND_UP(tpoecs * rate, 1000000);

drivers/mtd/nand/raw/mtk_nand.c

560

tprecs = DIV_ROUND_UP(tprecs * rate, 1000000);

drivers/mtd/nand/raw/mtk_nand.c

567

tw2r = DIV_ROUND_UP(tw2r * rate, 1000000);

drivers/mtd/nand/raw/mtk_nand.c

568

tw2r = DIV_ROUND_UP(tw2r - 1, 2);

drivers/mtd/nand/raw/mtk_nand.c

572

twh = DIV_ROUND_UP(twh * rate, 1000000) - 1;

drivers/mtd/nand/raw/mtk_nand.c

587

twst = DIV_ROUND_UP(twst * rate, 1000000) - 1;

drivers/mtd/nand/raw/mtk_nand.c

597

trlt = DIV_ROUND_UP(trlt * rate, 1000000) - 1;

drivers/mtd/nand/raw/mtk_nand.c

610

tsel = DIV_ROUND_UP(tsel * rate, 1000000);

drivers/mtd/nand/raw/mtk_nand.c

683

end = DIV_ROUND_UP(offset + len, chip->ecc.size);

drivers/mtd/nand/raw/mtk_nand.c

955

end = DIV_ROUND_UP(data_offs + readlen, chip->ecc.size);

drivers/mtd/nand/raw/nand_base.c

6449

mtd->bitflip_threshold = DIV_ROUND_UP(mtd->ecc_strength * 3, 4);

drivers/mtd/nand/raw/nuvoton-ma35d1-nand-controller.c

533

u32 end = DIV_ROUND_UP(page_off + len, chip->ecc.size);

drivers/mtd/nand/raw/pl35x-nand-controller.c

99

#define TO_CYCLES(ps, period_ns) (DIV_ROUND_UP((ps) / 1000, period_ns))

drivers/mtd/nand/raw/qcom_nandc.c

1665

udelay(DIV_ROUND_UP(ns, 1000));

drivers/mtd/nand/raw/renesas-nand-controller.c

876

DIV_ROUND_UP(rop.len, 4));

drivers/mtd/nand/raw/rockchip-nand-controller.c

1023

ecc->bytes = DIV_ROUND_UP(ecc->strength * fls(8 * chip->ecc.size), 8);

drivers/mtd/nand/raw/rockchip-nand-controller.c

442

trwpw = DIV_ROUND_UP(trwpw * rate, 1000000);

drivers/mtd/nand/raw/rockchip-nand-controller.c

445

temp = DIV_ROUND_UP(temp * rate, 1000000);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1425

timing = DIV_ROUND_UP(tar, hclkp) - 1;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1429

timing = DIV_ROUND_UP(tclr, hclkp) - 1;

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1443

timing = DIV_ROUND_UP(twait, hclkp);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1459

timing = DIV_ROUND_UP(tset_mem, hclkp);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1477

timing = DIV_ROUND_UP(thold_mem, hclkp);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1500

timing = DIV_ROUND_UP(tset_att, hclkp);

drivers/mtd/nand/raw/stm32_fmc2_nand.c

1539

timing = DIV_ROUND_UP(thold_att, hclkp);

drivers/mtd/nand/raw/sunxi_nand.c

1336

i < DIV_ROUND_UP(data_offs + readlen, ecc->size); i++) {

drivers/mtd/nand/raw/sunxi_nand.c

1360

int nchunks = DIV_ROUND_UP(data_offs + readlen, nand->ecc.size);

drivers/mtd/nand/raw/sunxi_nand.c

1428

i < DIV_ROUND_UP(data_offs + data_len, ecc->size); i++) {

drivers/mtd/nand/raw/sunxi_nand.c

1547

u32 clk_cycles = DIV_ROUND_UP(duration, clk_period);

drivers/mtd/nand/raw/sunxi_nand.c

1614

min_clk_period = DIV_ROUND_UP(timings->tRR_min, 3);

drivers/mtd/nand/raw/sunxi_nand.c

1630

min_clk_period = DIV_ROUND_UP(timings->tRC_min, 2);

drivers/mtd/nand/raw/sunxi_nand.c

1634

min_clk_period = DIV_ROUND_UP(timings->tWC_min, 2);

drivers/mtd/nand/raw/sunxi_nand.c

1638

min_clk_period = DIV_ROUND_UP(timings->tWB_max, 20);

drivers/mtd/nand/raw/sunxi_nand.c

1641

min_clk_period = DIV_ROUND_UP(timings->tADL_min, 32);

drivers/mtd/nand/raw/sunxi_nand.c

1644

min_clk_period = DIV_ROUND_UP(timings->tWHR_min, 32);

drivers/mtd/nand/raw/sunxi_nand.c

1647

min_clk_period = DIV_ROUND_UP(timings->tRHW_min, 20);

drivers/mtd/nand/raw/sunxi_nand.c

1670

tADL = DIV_ROUND_UP(timings->tADL_min, min_clk_period) >> 3;

drivers/mtd/nand/raw/sunxi_nand.c

1676

tWHR = DIV_ROUND_UP(timings->tWHR_min, min_clk_period) >> 3;

drivers/mtd/nand/raw/sunxi_nand.c

1702

min_clk_period = DIV_ROUND_UP(min_clk_period, 1000);

drivers/mtd/nand/raw/sunxi_nand.c

1858

ecc->bytes = DIV_ROUND_UP(ecc->strength * fls(8 * 1024), 8);

drivers/mtd/nand/raw/tegra_nand.c

1027

chip->ecc.bytes = DIV_ROUND_UP(bits_per_step, BITS_PER_BYTE);

drivers/mtd/nand/raw/tegra_nand.c

207

int bytes_per_step = DIV_ROUND_UP(BITS_PER_STEP_RS * chip->ecc.strength,

drivers/mtd/nand/raw/tegra_nand.c

234

int bytes_per_step = DIV_ROUND_UP(BITS_PER_STEP_BCH * chip->ecc.strength,

drivers/mtd/nand/raw/tegra_nand.c

789

unsigned int period = DIV_ROUND_UP(1000000, rate);

drivers/mtd/nand/raw/tegra_nand.c

792

val = DIV_ROUND_UP(max3(timings->tAR_min, timings->tRR_min,

drivers/mtd/nand/raw/tegra_nand.c

796

val = DIV_ROUND_UP(max(max(timings->tCS_min, timings->tCH_min),

drivers/mtd/nand/raw/tegra_nand.c

801

val = DIV_ROUND_UP(max(timings->tRP_min, timings->tREA_max) + 6000,

drivers/mtd/nand/raw/tegra_nand.c

805

reg |= TIMING_TWB(OFFSET(DIV_ROUND_UP(timings->tWB_max, period), 1));

drivers/mtd/nand/raw/tegra_nand.c

806

reg |= TIMING_TWHR(OFFSET(DIV_ROUND_UP(timings->tWHR_min, period), 1));

drivers/mtd/nand/raw/tegra_nand.c

807

reg |= TIMING_TWH(OFFSET(DIV_ROUND_UP(timings->tWH_min, period), 1));

drivers/mtd/nand/raw/tegra_nand.c

808

reg |= TIMING_TWP(OFFSET(DIV_ROUND_UP(timings->tWP_min, period), 1));

drivers/mtd/nand/raw/tegra_nand.c

809

reg |= TIMING_TRH(OFFSET(DIV_ROUND_UP(timings->tREH_min, period), 1));

drivers/mtd/nand/raw/tegra_nand.c

813

val = DIV_ROUND_UP(timings->tADL_min, period);

drivers/mtd/nand/raw/tegra_nand.c

868

bytes_per_step = DIV_ROUND_UP(bits_per_step * strength_sel,

drivers/mtd/nand/raw/txx9ndfmc.c

249

DIV_ROUND_UP((ns) * DIV_ROUND_UP(gbusclk, 1000), 1000000)

drivers/mtd/nand/spi/core.c

1912

mtd->bitflip_threshold = DIV_ROUND_UP(mtd->ecc_strength * 3, 4);

drivers/mtd/spi-nor/sfdp.c

1530

sfdp->num_dwords = DIV_ROUND_UP(sfdp_size, sizeof(*sfdp->dwords));

drivers/mtd/ssfdc.c

313

DIV_ROUND_UP(ssfdc->map_len, MAX_PHYS_BLK_PER_ZONE));

drivers/net/can/dev/calc_bittiming.c

244

for (pwm_per_bit = DIV_ROUND_UP(xl_ns, CAN_PWM_NS_MAX);

drivers/net/can/kvaser_pciefd/kvaser_pciefd_core.c

1586

pos += DIV_ROUND_UP(data_len, 4);

drivers/net/can/kvaser_pciefd/kvaser_pciefd_core.c

759

return DIV_ROUND_UP(packet_size, 4);

drivers/net/can/m_can/m_can.c

1867

u8 len_padded = DIV_ROUND_UP(cf->len, 4);

drivers/net/can/m_can/m_can.c

600

cf->data, DIV_ROUND_UP(cf->len, 4));

drivers/net/can/rcar/rcar_canfd.c

747

lwords = DIV_ROUND_UP(cf->len, sizeof(u32));

drivers/net/can/rcar/rcar_canfd.c

758

lwords = DIV_ROUND_UP(cf->len, sizeof(u32));

drivers/net/can/rockchip/rockchip_canfd-timestamp.c

57

div = min(DIV_ROUND_UP(priv->can.clock.freq, bitrate * 2),

drivers/net/can/usb/esd_usb.c

880

msg->hdr.len += DIV_ROUND_UP(cfd->len, sizeof(u32));

drivers/net/dsa/microchip/ksz9477.c

1207

max_val = DIV_ROUND_UP(secs, mult);

drivers/net/dsa/microchip/ksz9477.c

1212

data = DIV_ROUND_UP(secs, max_val);

drivers/net/dsa/microchip/ksz9477.c

1221

value = DIV_ROUND_UP(secs, data);

drivers/net/dsa/microchip/lan937x_main.c

508

max_val = DIV_ROUND_UP(secs, mult);

drivers/net/dsa/microchip/lan937x_main.c

513

data = DIV_ROUND_UP(secs, max_val);

drivers/net/dsa/microchip/lan937x_main.c

522

secs = DIV_ROUND_UP(secs, data);

drivers/net/dsa/mt7530.c

1405

val |= MAX_RX_JUMBO(DIV_ROUND_UP(length, 1024));

drivers/net/dsa/ocelot/felix_vsc9959.c

1616

rate = DIV_ROUND_UP(cbs_qopt->idleslope, 100);

drivers/net/dsa/ocelot/felix_vsc9959.c

1620

burst = DIV_ROUND_UP(cbs_qopt->hicredit, 4096);

drivers/net/dsa/qca/qca8k-8xxx.c

248

real_len = DIV_ROUND_UP(len, sizeof(u16));

drivers/net/dsa/sja1105/sja1105_spi.c

47

num_chunks = DIV_ROUND_UP(len, priv->max_xfer_len);

drivers/net/ethernet/amazon/ena/ena_eth_com.h

141

num_entries_needed += DIV_ROUND_UP(descs_after_first_entry,

drivers/net/ethernet/amd/pds_core/fw.c

121

(int)fw->size, buf_sz, DIV_ROUND_UP(fw->size, buf_sz));

drivers/net/ethernet/atheros/ag71xx.c

60

#define AG71XX_TX_RING_DS_PER_PKT DIV_ROUND_UP(AG71XX_TX_MTU_LEN, \

drivers/net/ethernet/broadcom/bcmsysport.c

567

reg |= DIV_ROUND_UP(usecs * 1000, 8192) << RDMA_TIMEOUT_SHIFT;

drivers/net/ethernet/broadcom/bcmsysport.c

581

reg |= DIV_ROUND_UP(ec->tx_coalesce_usecs * 1000, 8192) <<

drivers/net/ethernet/broadcom/bnge/bnge_hwrm.c

351

tmo_count += DIV_ROUND_UP(timeout, BNGE_HWRM_MIN_TIMEOUT);

drivers/net/ethernet/broadcom/bnge/bnge_rmem.c

152

ctx_pg->nr_pages = DIV_ROUND_UP(mem_size, BNGE_PAGE_SIZE);

drivers/net/ethernet/broadcom/bnge/bnge_rmem.c

164

nr_tbls = DIV_ROUND_UP(ctx_pg->nr_pages, MAX_CTX_PAGES);

drivers/net/ethernet/broadcom/bnge/bnge_rmem.c

193

rmem->nr_pages = DIV_ROUND_UP(mem_size, BNGE_PAGE_SIZE);

drivers/net/ethernet/broadcom/bnx2x/bnx2x.h

1093

#define CNIC_ILT_LINES DIV_ROUND_UP(CNIC_CID_MAX, ILT_PAGE_CIDS)

drivers/net/ethernet/broadcom/bnx2x/bnx2x.h

1106

#define TM_ILT_LINES DIV_ROUND_UP(TM_ILT_SZ, TM_ILT_PAGE_SZ)

drivers/net/ethernet/broadcom/bnx2x/bnx2x.h

1115

#define SRC_ILT_LINES DIV_ROUND_UP(SRC_ILT_SZ, SRC_ILT_PAGE_SZ)

drivers/net/ethernet/broadcom/bnx2x/bnx2x.h

1669

#define L2_ILT_LINES(bp) (DIV_ROUND_UP(BNX2X_L2_CID_COUNT(bp),\

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c

8676

line += DIV_ROUND_UP(bp->qm_cid_count * QM_QUEUES_PER_FUNC * 4,

drivers/net/ethernet/broadcom/bnxt/bnxt.c

2582

pages = DIV_ROUND_UP(mem_size, BNXT_PAGE_SIZE);

drivers/net/ethernet/broadcom/bnxt/bnxt.c

2826

DIV_ROUND_UP(fw_health->polling_dsecs * HZ,

drivers/net/ethernet/broadcom/bnxt/bnxt.c

9041

ctx_pg->nr_pages = DIV_ROUND_UP(mem_size, BNXT_PAGE_SIZE);

drivers/net/ethernet/broadcom/bnxt/bnxt.c

9053

nr_tbls = DIV_ROUND_UP(ctx_pg->nr_pages, MAX_CTX_PAGES);

drivers/net/ethernet/broadcom/bnxt/bnxt.c

9082

rmem->nr_pages = DIV_ROUND_UP(mem_size, BNXT_PAGE_SIZE);

drivers/net/ethernet/broadcom/bnxt/bnxt_hwrm.c

558

tmo_count += DIV_ROUND_UP(timeout, HWRM_MIN_TIMEOUT);

drivers/net/ethernet/broadcom/genet/bcmgenet.c

626

f_length += DIV_ROUND_UP(VLAN_HLEN, 2);

drivers/net/ethernet/broadcom/genet/bcmgenet.c

632

f_length += DIV_ROUND_UP(ETH_HLEN, 2);

drivers/net/ethernet/broadcom/genet/bcmgenet.c

647

f_length += DIV_ROUND_UP(ETH_HLEN + 20, 2);

drivers/net/ethernet/broadcom/genet/bcmgenet.c

684

f_length += DIV_ROUND_UP(size, 2);

drivers/net/ethernet/broadcom/genet/bcmgenet.c

862

reg |= DIV_ROUND_UP(usecs * 1000, 8192);

drivers/net/ethernet/broadcom/sb1250-mac.c

146

#define NUMCACHEBLKS(x) DIV_ROUND_UP(x, SMP_CACHE_BYTES)

drivers/net/ethernet/broadcom/tg3.c

13541

num_pkts = DIV_ROUND_UP(val, TG3_TSO_MSS);

drivers/net/ethernet/cadence/macb.h

1427

return DIV_ROUND_UP((ns) * (speed_mbps),

drivers/net/ethernet/cadence/macb.h

1433

return DIV_ROUND_UP(GENMASK(GEM_ON_TIME_SIZE - 1, 0) *

drivers/net/ethernet/cadence/macb_main.c

2411

desc_cnt = DIV_ROUND_UP((skb_headlen(skb) - hdrlen), bp->max_tx_length) + 1;

drivers/net/ethernet/cadence/macb_main.c

2413

desc_cnt = DIV_ROUND_UP(skb_headlen(skb), bp->max_tx_length);

drivers/net/ethernet/cadence/macb_main.c

2417

desc_cnt += DIV_ROUND_UP(frag_size, bp->max_tx_length);

drivers/net/ethernet/cadence/macb_main.c

504

ferr = DIV_ROUND_UP(ferr, rate / 100000);

drivers/net/ethernet/cavium/liquidio/octeon_droq.c

521

return DIV_ROUND_UP(total_len, buf_size);

drivers/net/ethernet/chelsio/cxgb4/cxgb4.h

72

(1 + DIV_ROUND_UP((3 * MAX_SKB_FRAGS) / 2 + (MAX_SKB_FRAGS & 1), 8))

drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c

2625

return DIV_ROUND_UP(utxq_info->ntxq, 4);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c

2636

return ciq ? DIV_ROUND_UP(urxq_info->nciq, 4) :

drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c

2637

DIV_ROUND_UP(urxq_info->nrxq, 4);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c

2663

eth_entries = DIV_ROUND_UP(adap->sge.ethqsets, 4);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c

2664

ctrl_entries = DIV_ROUND_UP(MAX_CTRL_QUEUES, 4);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c

2755

if (r >= DIV_ROUND_UP(pi->nmirrorqsets, 4)) {

drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c

2756

r -= DIV_ROUND_UP(pi->nmirrorqsets, 4);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c

2806

eohw_entries = DIV_ROUND_UP(adap->sge.eoqsets, 4);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c

2869

eosw_entries = DIV_ROUND_UP(entries, 4);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c

3164

eohw_entries = DIV_ROUND_UP(adap->sge.eoqsets, 4);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c

3174

eosw_entries += DIV_ROUND_UP(entries, 4);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c

3184

mirror_rxq_entries += DIV_ROUND_UP(pi->nmirrorqsets, 4);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c

3202

return DIV_ROUND_UP(adap->sge.ethqsets, 4) + mirror_rxq_entries +

drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c

3204

DIV_ROUND_UP(MAX_CTRL_QUEUES, 4) + 1;

drivers/net/ethernet/chelsio/cxgb4/cxgb4_filter.c

111

txpkt->len = htonl(DIV_ROUND_UP(sizeof(*abort_rpl), 16));

drivers/net/ethernet/chelsio/cxgb4/cxgb4_filter.c

129

txpkt->len = htonl(DIV_ROUND_UP(sizeof(*req), 16));

drivers/net/ethernet/chelsio/cxgb4/cxgb4_filter.c

96

txpkt->len = htonl(DIV_ROUND_UP(sizeof(*abort_req), 16));

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

4109

ncmds = DIV_ROUND_UP(sgt->nents, HMA_MAX_ADDR_IN_CMD);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

5192

DIV_ROUND_UP(adap->tids.nftids, 3);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

5194

DIV_ROUND_UP(adap->tids.nftids, 3);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_uld.h

65

(w)->wr.wr_mid = htonl(FW_WR_LEN16_V(DIV_ROUND_UP(sizeof(*w), 16)) | \

drivers/net/ethernet/chelsio/cxgb4/cxgb4_uld.h

78

(w)->wr.wr_mid = htonl(FW_WR_LEN16_V(DIV_ROUND_UP(wrlen, 16)) | \

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

1577

wr_mid = FW_WR_LEN16_V(DIV_ROUND_UP(flits, 2));

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

1781

return DIV_ROUND_UP(skb->len + sizeof(struct cpl_tx_pkt),

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

1891

wr_mid = FW_WR_LEN16_V(DIV_ROUND_UP(flits, 2));

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

1911

WARN_ON(DIV_ROUND_UP(T4VF_ETHTXQ_MAX_HDR, TXD_PER_EQ_UNIT) > 1);

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

2173

flits = DIV_ROUND_UP(wrlen, 8);

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

2200

wrlen16 = DIV_ROUND_UP(wrlen, 16);

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

2278

flits = DIV_ROUND_UP(hdr_len, 8);

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

2291

wrlen16 = DIV_ROUND_UP(wrlen, 16);

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

2538

len16 = DIV_ROUND_UP(len, 16);

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

2666

flits = DIV_ROUND_UP(pkt_len + sizeof(*cpl) + sizeof(*wr),

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

2689

wr->equiq_to_len16 = htonl(FW_WR_LEN16_V(DIV_ROUND_UP(flits, 2)));

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

2747

ndesc = DIV_ROUND_UP(skb->len, sizeof(struct tx_desc));

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

2877

return DIV_ROUND_UP(skb->len, 8);

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

3232

ndesc = flits_to_desc(DIV_ROUND_UP(len, 8));

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

4096

flits = DIV_ROUND_UP(skb->len, 8);

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

4112

wrlen16 = DIV_ROUND_UP(flits * 8, 16);

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

719

return DIV_ROUND_UP(n, 8);

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

770

return DIV_ROUND_UP(skb->len + hdrlen, sizeof(__be64));

drivers/net/ethernet/chelsio/cxgb4/t4_hw.c

10183

i = DIV_ROUND_UP(FLASH_CFG_MAX_SIZE, /* # of sectors spanned */

drivers/net/ethernet/chelsio/cxgb4/t4_hw.c

10635

i = DIV_ROUND_UP(size ? size : FLASH_FW_START, sf_sec_size);

drivers/net/ethernet/chelsio/cxgb4/t4_hw.c

10735

i = DIV_ROUND_UP(FLASH_BOOTCFG_MAX_SIZE,

drivers/net/ethernet/chelsio/cxgb4/t4_hw.c

3159

u32 exprom_header_buf[DIV_ROUND_UP(sizeof(struct exprom_header),

drivers/net/ethernet/chelsio/cxgb4/t4_hw.c

3668

i = DIV_ROUND_UP(size, sf_sec_size); /* # of sectors spanned */

drivers/net/ethernet/chelsio/cxgb4/t4_hw.c

7988

size_t len16 = DIV_ROUND_UP(offsetof(struct fw_vi_mac_cmd,

drivers/net/ethernet/chelsio/cxgb4/t4_hw.c

8076

size_t len16 = DIV_ROUND_UP(offsetof(struct fw_vi_mac_cmd,

drivers/net/ethernet/chelsio/cxgb4vf/cxgb4vf_main.c

2044

int eth_entries = DIV_ROUND_UP(adapter->sge.ethqsets, QPL);

drivers/net/ethernet/chelsio/cxgb4vf/cxgb4vf_main.c

2140

return DIV_ROUND_UP(adapter->sge.ethqsets, QPL) + 1 +

drivers/net/ethernet/chelsio/cxgb4vf/cxgb4vf_main.c

2180

int eth_entries = DIV_ROUND_UP(adapter->sge.ethqsets, QPL);

drivers/net/ethernet/chelsio/cxgb4vf/cxgb4vf_main.c

2269

return DIV_ROUND_UP(adapter->sge.ethqsets, QPL) + 1 +

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

114

ETHTXQ_STOP_THRES = 1 + DIV_ROUND_UP(ETHTXQ_MAX_FLITS, TXD_PER_EQ_UNIT),

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

1241

wr_mid = FW_WR_LEN16_V(DIV_ROUND_UP(flits, 2));

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

1262

BUG_ON(DIV_ROUND_UP(ETHTXQ_MAX_HDR, TXD_PER_EQ_UNIT) > 1);

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

822

return DIV_ROUND_UP(flits, TXD_PER_EQ_UNIT);

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

861

return DIV_ROUND_UP(skb->len + sizeof(struct cpl_tx_pkt),

drivers/net/ethernet/chelsio/cxgb4vf/t4vf_hw.c

1544

size_t len16 = DIV_ROUND_UP(offsetof(struct fw_vi_mac_cmd,

drivers/net/ethernet/chelsio/cxgb4vf/t4vf_hw.c

1628

size_t len16 = DIV_ROUND_UP(offsetof(struct fw_vi_mac_cmd,

drivers/net/ethernet/chelsio/cxgb4vf/t4vf_hw.c

1696

size_t len16 = DIV_ROUND_UP(offsetof(struct fw_vi_mac_cmd,

drivers/net/ethernet/chelsio/cxgb4vf/t4vf_hw.c

1741

size_t len16 = DIV_ROUND_UP(offsetof(struct fw_vi_mac_cmd,

drivers/net/ethernet/chelsio/cxgb4vf/t4vf_hw.c

1783

size_t len16 = DIV_ROUND_UP(len, 16);

drivers/net/ethernet/chelsio/cxgb4vf/t4vf_hw.c

637

len16 = DIV_ROUND_UP(offsetof(struct fw_params_cmd,

drivers/net/ethernet/chelsio/cxgb4vf/t4vf_hw.c

675

len16 = DIV_ROUND_UP(offsetof(struct fw_params_cmd,

drivers/net/ethernet/chelsio/inline_crypto/ch_ipsec/chcr_ipsec.c

196

((DIV_ROUND_UP(keylen, 16)) << 4) +

drivers/net/ethernet/chelsio/inline_crypto/ch_ipsec/chcr_ipsec.c

216

memcpy(sa_entry->key + (DIV_ROUND_UP(sa_entry->enckey_len, 16) *

drivers/net/ethernet/chelsio/inline_crypto/ch_ipsec/chcr_ipsec.c

218

sa_entry->kctx_len = ((DIV_ROUND_UP(sa_entry->enckey_len, 16)) << 4) +

drivers/net/ethernet/chelsio/inline_crypto/ch_ipsec/chcr_ipsec.c

354

hdrlen += (DIV_ROUND_UP(sizeof(struct chcr_ipsec_aadiv), 16)

drivers/net/ethernet/chelsio/inline_crypto/ch_ipsec/chcr_ipsec.c

372

aadivlen = sa_entry->esn ? DIV_ROUND_UP(sizeof(struct chcr_ipsec_aadiv),

drivers/net/ethernet/chelsio/inline_crypto/ch_ipsec/chcr_ipsec.c

383

return DIV_ROUND_UP(skb->len + hdrlen, sizeof(__be64));

drivers/net/ethernet/chelsio/inline_crypto/ch_ipsec/chcr_ipsec.c

433

len = DIV_ROUND_UP(sizeof(struct chcr_ipsec_aadiv), 16) << 4;

drivers/net/ethernet/chelsio/inline_crypto/ch_ipsec/chcr_ipsec.c

449

(DIV_ROUND_UP(sizeof(struct chcr_ipsec_aadiv),

drivers/net/ethernet/chelsio/inline_crypto/ch_ipsec/chcr_ipsec.c

580

ndesc = DIV_ROUND_UP(flits, 2);

drivers/net/ethernet/chelsio/inline_crypto/ch_ipsec/chcr_ipsec.c

678

return DIV_ROUND_UP(n, 8);

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_common.h

109

return DIV_ROUND_UP(n, 8);

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

1014

len16 = DIV_ROUND_UP(sizeof(*wr) + ctrl, 16);

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

1016

ndesc = DIV_ROUND_UP(len16, 4);

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

1153

len16 = DIV_ROUND_UP(flits, 2);

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

1335

len16 = DIV_ROUND_UP(flits, 2);

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

1475

flits = DIV_ROUND_UP(CHCR_PLAIN_TX_DATA_LEN, 8);

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

1482

len16 = DIV_ROUND_UP(flits, 2);

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

1484

ndesc = DIV_ROUND_UP(flits, 8);

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

1579

flits = DIV_ROUND_UP(sizeof(*wr) + ctrl, 8);

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

1582

len16 = DIV_ROUND_UP(flits, 2);

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

1584

ndesc = DIV_ROUND_UP(flits, 8);

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

756

txpkt->len = htonl(DIV_ROUND_UP(CHCR_SET_TCB_FIELD_LEN, 16));

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

852

ndesc = DIV_ROUND_UP(len, 64);

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

920

FW_WR_LEN16_V(DIV_ROUND_UP(len, 16)));

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

922

ndesc = DIV_ROUND_UP(len, 64);

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

938

DIV_ROUND_UP(key_ctx_len + CHCR_KTLS_WR_SIZE, 8);

drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_cm.c

314

req->wr.wr_mid = htonl(FW_WR_LEN16_V(DIV_ROUND_UP(sizeof(*req), 16)) |

drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_hw.c

392

cpu_to_be32(FW_WR_LEN16_V(DIV_ROUND_UP(len, 16) |

drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_hw.c

403

DIV_ROUND_UP(len - sizeof(kwr->wr), 16));

drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_hw.c

422

csk->wr_credits -= DIV_ROUND_UP(len, 16);

drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_hw.c

423

csk->wr_unacked += DIV_ROUND_UP(len, 16);

drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_hw.c

77

credits_needed = DIV_ROUND_UP(wrlen, 16);

drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_io.c

47

return DIV_ROUND_UP(size, csk->tlshws.mfs);

drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_io.c

484

pdus = DIV_ROUND_UP(tls_len, hws->mfs);

drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_io.c

635

credits_needed = DIV_ROUND_UP(credit_len, 16);

drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_io.c

80

flowclen16 = DIV_ROUND_UP(flowclen, 16);

drivers/net/ethernet/cisco/enic/vnic_rq.h

52

DIV_ROUND_UP(entries, VNIC_RQ_BUF_BLK_ENTRIES(entries))

drivers/net/ethernet/cisco/enic/vnic_wq.h

64

DIV_ROUND_UP(entries, VNIC_WQ_BUF_BLK_ENTRIES(entries))

drivers/net/ethernet/ezchip/nps_enet.c

27

u32 i, len = DIV_ROUND_UP(frame_len, sizeof(u32));

drivers/net/ethernet/ezchip/nps_enet.c

382

u32 i, len = DIV_ROUND_UP(length, sizeof(u32));

drivers/net/ethernet/freescale/dpaa/dpaa_eth.c

1150

DIV_ROUND_UP(sizeof(struct qman_fq),

drivers/net/ethernet/freescale/enetc/enetc_ierb.c

89

rx_credit = DIV_ROUND_UP(ENETC_MAC_MAXFRM_SIZE * 2, 8);

drivers/net/ethernet/freescale/fec_main.c

3096

mii_speed = DIV_ROUND_UP(clk_get_rate(fep->clk_ipg), bus_freq * 2);

drivers/net/ethernet/freescale/fec_main.c

3119

holdtime = DIV_ROUND_UP(clk_get_rate(fep->clk_ipg), 100000000) - 1;

drivers/net/ethernet/freescale/fman/fman.c

2742

fman->dts_params.clk_freq = DIV_ROUND_UP(clk_rate, 1000000);

drivers/net/ethernet/freescale/gianfar_ethtool.c

217

return DIV_ROUND_UP(usecs * 1000, count);

drivers/net/ethernet/fungible/funeth/funeth_tx.c

529

ndesc = DIV_ROUND_UP((sizeof(*req) + nfrags *

drivers/net/ethernet/fungible/funeth/funeth_tx.c

72

return DIV_ROUND_UP(req->len8, FUNETH_SQE_SIZE / 8);

drivers/net/ethernet/fungible/funeth/funeth_txrx.h

30

DIV_ROUND_UP((FUNETH_FUNOS_HDR_SZ + FUNETH_MAX_GL_SZ + FUNETH_TLS_SZ), \

drivers/net/ethernet/google/gve/gve.h

92

#define GVE_MAX_TX_BUFS_PER_PKT (DIV_ROUND_UP(GVE_DQO_TX_MAX, GVE_TX_BUF_SIZE_DQO))

drivers/net/ethernet/google/gve/gve_tx_dqo.c

877

return DIV_ROUND_UP(size, GVE_TX_MAX_BUF_SIZE_DQO);

drivers/net/ethernet/google/gve/gve_tx_dqo.c

981

num_buffer_descs = DIV_ROUND_UP(skb->len, GVE_TX_BUF_SIZE_DQO);

drivers/net/ethernet/hisilicon/hisi_femac.c

706

time_ms = DIV_ROUND_UP(time_us, 1000);

drivers/net/ethernet/hisilicon/hix5hd2_gmac.c

1066

time_ms = DIV_ROUND_UP(time_us, 1000);

drivers/net/ethernet/hisilicon/hns3/hns3_enet.c

40

#define hns3_tx_bd_count(S) DIV_ROUND_UP(S, HNS3_MAX_BD_SIZE)

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.h

640

#define MAX_KEY_DWORDS DIV_ROUND_UP(MAX_KEY_LENGTH / 8, 4)

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_regs.c

191

cmd_num = DIV_ROUND_UP(regs_num + nodata_num,

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_regs.c

245

cmd_num = DIV_ROUND_UP(regs_num + nodata_len,

drivers/net/ethernet/huawei/hinic3/hinic3_rx.c

367

skb_shinfo(skb)->gso_size = DIV_ROUND_UP(skb->len - skb_headlen(skb),

drivers/net/ethernet/ibm/emac/mal.h

134

return DIV_ROUND_UP(len, MAL_MAX_TX_SIZE);

drivers/net/ethernet/ibm/ibmveth.c

1374

DIV_ROUND_UP(skb->len - hdr_len,

drivers/net/ethernet/intel/e1000e/ich8lan.c

1142

value = DIV_ROUND_UP(value, BIT(5));

drivers/net/ethernet/intel/e1000e/netdev.c

5864

count += DIV_ROUND_UP(len, adapter->tx_fifo_limit);

drivers/net/ethernet/intel/e1000e/netdev.c

5868

count += DIV_ROUND_UP(skb_frag_size(&skb_shinfo(skb)->frags[f]),

drivers/net/ethernet/intel/e1000e/netdev.c

5933

DIV_ROUND_UP(PAGE_SIZE,

drivers/net/ethernet/intel/fm10k/fm10k.h

433

#define TXD_USE_COUNT(S) DIV_ROUND_UP((S), FM10K_MAX_DATA_PER_TXD)

drivers/net/ethernet/intel/fm10k/fm10k_main.c

1736

int rqpv = DIV_ROUND_UP(rxr_remaining, q_vectors - v_idx);

drivers/net/ethernet/intel/fm10k/fm10k_main.c

1737

int tqpv = DIV_ROUND_UP(txr_remaining, q_vectors - v_idx);

drivers/net/ethernet/intel/i40e/i40e_main.c

3624

rx_ctx.dbuff = DIV_ROUND_UP(ring->rx_buf_len,

drivers/net/ethernet/intel/i40e/i40e_main.c

4584

num_ringpairs = DIV_ROUND_UP(qp_remaining, q_vectors - v_start);

drivers/net/ethernet/intel/i40e/i40e_txrx.c

1331

itr += DIV_ROUND_UP(avg_wire_size, i40e_itr_divisor(q_vector)) *

drivers/net/ethernet/intel/iavf/iavf_txrx.c

644

itr += DIV_ROUND_UP(avg_wire_size,

drivers/net/ethernet/intel/ice/devlink/devlink.c

1879

num_blks = DIV_ROUND_UP(nvm_size, ICE_DEVLINK_READ_BLK_SIZE);

drivers/net/ethernet/intel/ice/ice_base.c

501

rlan_ctx.dbuf = DIV_ROUND_UP(ring->rx_buf_len,

drivers/net/ethernet/intel/ice/ice_base.c

944

tx_rings_per_v = (u8)DIV_ROUND_UP(tx_rings_rem,

drivers/net/ethernet/intel/ice/ice_base.c

961

rx_rings_per_v = (u8)DIV_ROUND_UP(rx_rings_rem,

drivers/net/ethernet/intel/ice/ice_flow.c

1159

cnt = DIV_ROUND_UP(flds[fld].xtrct.disp + ice_flds_info[fld].size,

drivers/net/ethernet/intel/ice/ice_flow.c

1244

cnt = DIV_ROUND_UP(raw->info.xtrct.disp +

drivers/net/ethernet/intel/ice/ice_main.c

2704

xdp_rings_per_v = DIV_ROUND_UP(xdp_rings_rem,

drivers/net/ethernet/intel/ice/ice_sched.c

1659

num = DIV_ROUND_UP(num, hw->max_children[i]);

drivers/net/ethernet/intel/ice/ice_sched.c

1884

new_num_nodes[vsil] = DIV_ROUND_UP(new_numqs, max_queue_cnt) -

drivers/net/ethernet/intel/idpf/idpf_txrx.c

1207

DIV_ROUND_UP(rsrc->num_rxq_grp, rsrc->num_q_vectors));

drivers/net/ethernet/intel/idpf/idpf_txrx.c

3322

rsc_segments = DIV_ROUND_UP(skb->data_len, rsc_seg_len);

drivers/net/ethernet/intel/idpf/idpf_txrx.c

4264

budget_per_q = DIV_ROUND_UP(budget, num_complq);

drivers/net/ethernet/intel/idpf/idpf_txrx.c

4569

txqs_per_vector = DIV_ROUND_UP(rsrc->num_txq_grp,

drivers/net/ethernet/intel/idpf/idpf_txrx.c

4571

rxqs_per_vector = DIV_ROUND_UP(rsrc->num_rxq_grp,

drivers/net/ethernet/intel/idpf/idpf_txrx.c

4574

DIV_ROUND_UP(rsrc->num_rxq_grp,

drivers/net/ethernet/intel/idpf/idpf_txrx.c

4576

complqs_per_vector = DIV_ROUND_UP(rsrc->num_txq_grp,

drivers/net/ethernet/intel/idpf/idpf_txrx.h

1002

return DIV_ROUND_UP(size, IDPF_TX_MAX_DESC_DATA_ALIGNED);

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

4365

num_msgs = DIV_ROUND_UP(total_filters, IDPF_NUM_FILTERS_PER_MSG);

drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

782

num_msgs = DIV_ROUND_UP(totqs, num_chunks);

drivers/net/ethernet/intel/igb/igb.h

244

#define TXD_USE_COUNT(S) DIV_ROUND_UP((S), IGB_MAX_DATA_PER_TXD)

drivers/net/ethernet/intel/igb/igb_main.c

1328

int rqpv = DIV_ROUND_UP(rxr_remaining, q_vectors - v_idx);

drivers/net/ethernet/intel/igb/igb_main.c

1329

int tqpv = DIV_ROUND_UP(txr_remaining, q_vectors - v_idx);

drivers/net/ethernet/intel/igb/igb_main.c

2332

min_rx_space = DIV_ROUND_UP(MAX_JUMBO_FRAME_SIZE, 1024);

drivers/net/ethernet/intel/igb/igb_main.c

2341

min_tx_space = DIV_ROUND_UP(min_tx_space, 512);

drivers/net/ethernet/intel/igc/igc.h

575

#define TXD_USE_COUNT(S) DIV_ROUND_UP((S), IGC_MAX_DATA_PER_TXD)

drivers/net/ethernet/intel/igc/igc_main.c

4977

int rqpv = DIV_ROUND_UP(rxr_remaining, q_vectors - v_idx);

drivers/net/ethernet/intel/igc/igc_main.c

4978

int tqpv = DIV_ROUND_UP(txr_remaining, q_vectors - v_idx);

drivers/net/ethernet/intel/ixgbe/devlink/region.c

66

num_blks = DIV_ROUND_UP(nvm_size, IXGBE_DEVLINK_READ_BLK_SIZE);

drivers/net/ethernet/intel/ixgbe/ixgbe.h

254

#define TXD_USE_COUNT(S) DIV_ROUND_UP((S), IXGBE_MAX_DATA_PER_TXD)

drivers/net/ethernet/intel/ixgbe/ixgbe_fcoe.c

570

first->gso_segs = DIV_ROUND_UP(skb->len - *hdr_len,

drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c

1079

int rqpv = DIV_ROUND_UP(rxr_remaining, q_vectors - v_idx);

drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c

1080

int tqpv = DIV_ROUND_UP(txr_remaining, q_vectors - v_idx);

drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c

1081

int xqpv = DIV_ROUND_UP(xdp_remaining, q_vectors - v_idx);

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

1858

skb_shinfo(skb)->gso_size = DIV_ROUND_UP((skb->len - hdr_len),

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

2617

total_rx_packets += DIV_ROUND_UP(ddp_bytes,

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

2876

itr += DIV_ROUND_UP(avg_wire_size,

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

2885

itr += DIV_ROUND_UP(avg_wire_size,

drivers/net/ethernet/intel/ixgbevf/ixgbevf.h

23

#define TXD_USE_COUNT(S) DIV_ROUND_UP((S), IXGBE_MAX_DATA_PER_TXD)

drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c

2921

int rqpv = DIV_ROUND_UP(rxr_remaining, q_vectors);

drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c

2935

int rqpv = DIV_ROUND_UP(rxr_remaining, q_vectors);

drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c

2936

int tqpv = DIV_ROUND_UP(txr_remaining, q_vectors);

drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c

2937

int xqpv = DIV_ROUND_UP(xdp_remaining, q_vectors);

drivers/net/ethernet/marvell/mvneta.c

2694

num = DIV_ROUND_UP(txq->size, MVNETA_TSO_PER_PAGE);

drivers/net/ethernet/marvell/mvneta.c

4320

ts = DIV_ROUND_UP(timer, 10);

drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c

6750

ts = DIV_ROUND_UP(timer, 10);

drivers/net/ethernet/marvell/octeontx2/af/rvu_cpt.c

70

flt_vecs = DIV_ROUND_UP(max_engs, 64);

drivers/net/ethernet/mediatek/mtk_eth_soc.c

1012

eth->mdc_divider = min_t(unsigned int, DIV_ROUND_UP(MDC_MAX_FREQ, max_clk), 63);

drivers/net/ethernet/mediatek/mtk_eth_soc.c

1316

for (j = 0; j < DIV_ROUND_UP(soc->tx.fq_dma_size, MTK_FQ_DMA_LENGTH); j++) {

drivers/net/ethernet/mediatek/mtk_eth_soc.c

1720

nfrags += DIV_ROUND_UP(skb_frag_size(frag),

drivers/net/ethernet/mediatek/mtk_eth_soc.c

3316

for (i = 0; i < DIV_ROUND_UP(soc->tx.fq_dma_size, MTK_FQ_DMA_LENGTH); i++) {

drivers/net/ethernet/mediatek/mtk_eth_soc.c

3835

cur = min_t(u32, DIV_ROUND_UP(cur_profile.usec, 20), MTK_PDMA_DELAY_PTIME_MASK);

drivers/net/ethernet/mediatek/mtk_eth_soc.c

3866

cur = min_t(u32, DIV_ROUND_UP(cur_profile.usec, 20), MTK_PDMA_DELAY_PTIME_MASK);

drivers/net/ethernet/mediatek/mtk_eth_soc.c

920

timer = DIV_ROUND_UP(timer, 1000);

drivers/net/ethernet/mellanox/mlx4/alloc.c

594

buf->nbufs = DIV_ROUND_UP(size, PAGE_SIZE);

drivers/net/ethernet/mellanox/mlx4/en_rx.c

262

pp.pool_size = size * DIV_ROUND_UP(priv->rx_skb_size, PAGE_SIZE);

drivers/net/ethernet/mellanox/mlx4/icm.c

427

num_icm = DIV_ROUND_UP(nobj, obj_per_chunk);

drivers/net/ethernet/mellanox/mlx5/core/alloc.c

80

buf->npages = DIV_ROUND_UP(size, PAGE_SIZE);

drivers/net/ethernet/mellanox/mlx5/core/cmd.c

222

return DIV_ROUND_UP(blen, MLX5_CMD_DATA_BLOCK_SIZE);

drivers/net/ethernet/mellanox/mlx5/core/cmd.c

2495

sema_init(&cmd->vars.throttle_sem, DIV_ROUND_UP(cmd->vars.max_reg_cmds, 2));

drivers/net/ethernet/mellanox/mlx5/core/cmd.c

2497

DIV_ROUND_UP(cmd->vars.max_reg_cmds, 2));

drivers/net/ethernet/mellanox/mlx5/core/diag/fw_tracer.c

194

DIV_ROUND_UP(TRACER_BUFFER_PAGE_NUM, 2));

drivers/net/ethernet/mellanox/mlx5/core/diag/fw_tracer.c

208

DIV_ROUND_UP(TRACER_BUFFER_PAGE_NUM, 2));

drivers/net/ethernet/mellanox/mlx5/core/en/params.c

1165

total_pages = DIV_ROUND_UP(wqebbs * MLX5_SEND_WQE_BB, useful_space);

drivers/net/ethernet/mellanox/mlx5/core/en/params.c

161

WARN_ON_ONCE(DIV_ROUND_UP(umr_wqe_sz, MLX5_SEND_WQE_DS) > MLX5_WQE_CTRL_DS_MASK);

drivers/net/ethernet/mellanox/mlx5/core/en/params.c

169

return DIV_ROUND_UP(mlx5e_mpwrq_umr_wqe_sz(mdev, page_shift, umr_mode),

drivers/net/ethernet/mellanox/mlx5/core/en/params.c

420

return order_base_2(DIV_ROUND_UP(MLX5E_SHAMPO_WQ_RESRV_SIZE,

drivers/net/ethernet/mellanox/mlx5/core/en/params.c

659

wqe_bulk = DIV_ROUND_UP(wqe_bulk_in_bytes, sum_frag_strides);

drivers/net/ethernet/mellanox/mlx5/core/en/params.c

666

split_factor = DIV_ROUND_UP(MAX_WQE_BULK_BYTES(params->xdp_prog),

drivers/net/ethernet/mellanox/mlx5/core/en/params.c

668

info->refill_unit = DIV_ROUND_UP(info->wqe_bulk, split_factor);

drivers/net/ethernet/mellanox/mlx5/core/en/qos.c

274

qos_sqs_size = DIV_ROUND_UP(mlx5e_qos_max_leaf_nodes(priv->mdev), chs->num);

drivers/net/ethernet/mellanox/mlx5/core/en/tc/meter.c

160

ds_cnt = DIV_ROUND_UP(sizeof(struct mlx5_aso_wqe_data), MLX5_SEND_WQE_DS);

drivers/net/ethernet/mellanox/mlx5/core/en/txrx.h

21

#define MLX5E_MAX_TX_IPSEC_DS DIV_ROUND_UP(sizeof(struct mlx5_wqe_inline_seg) + \

drivers/net/ethernet/mellanox/mlx5/core/en/txrx.h

27

#define MLX5E_MAX_TX_INLINE_DS DIV_ROUND_UP(366 - INL_HDR_START_SZ + VLAN_HLEN, \

drivers/net/ethernet/mellanox/mlx5/core/en/txrx.h

31

#define MLX5E_MAX_TX_WQEBBS DIV_ROUND_UP(MLX5E_TX_WQE_EMPTY_DS_COUNT + \

drivers/net/ethernet/mellanox/mlx5/core/en/txrx.h

44

(DIV_ROUND_UP(MLX5E_KSM_UMR_WQE_SZ(ksm_entries), MLX5_SEND_WQE_BB))

drivers/net/ethernet/mellanox/mlx5/core/en/txrx.h

47

(DIV_ROUND_UP(MLX5E_KSM_UMR_WQE_SZ(ksm_entries), MLX5_SEND_WQE_DS))

drivers/net/ethernet/mellanox/mlx5/core/en/xdp.c

414

wi->num_wqebbs = DIV_ROUND_UP(ds_count, MLX5_SEND_WQEBB_NUM_DS);

drivers/net/ethernet/mellanox/mlx5/core/en/xdp.c

577

num_wqebbs = DIV_ROUND_UP(ds_cnt, MLX5_SEND_WQEBB_NUM_DS);

drivers/net/ethernet/mellanox/mlx5/core/en/xdp.h

210

u16 ds_cnt = DIV_ROUND_UP(ds_len, MLX5_SEND_WQE_DS);

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ipsec_offload.c

605

ds_cnt = DIV_ROUND_UP(sizeof(*wqe), MLX5_SEND_WQE_DS);

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls_rx.c

291

#define GET_PSV_DS_CNT (DIV_ROUND_UP(sizeof(*wqe), MLX5_SEND_WQE_DS))

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls_tx.c

15

(DIV_ROUND_UP(sizeof(struct mlx5e_dump_wqe), MLX5_SEND_WQE_BB))

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls_tx.c

24

return nfrags + DIV_ROUND_UP(sync_len, MLX5E_SW2HW_MTU(params, params->sw_mtu));

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls_txrx.c

128

#define PROGRESS_PARAMS_DS_CNT DIV_ROUND_UP(sizeof(*wqe), MLX5_SEND_WQE_DS)

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls_txrx.c

86

#define STATIC_PARAMS_DS_CNT DIV_ROUND_UP(sizeof(*wqe), MLX5_SEND_WQE_DS)

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls_utils.h

54

(DIV_ROUND_UP(sizeof(struct mlx5e_set_tls_static_params_wqe), MLX5_SEND_WQE_BB))

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls_utils.h

57

(DIV_ROUND_UP(sizeof(struct mlx5e_set_tls_progress_params_wqe), MLX5_SEND_WQE_BB))

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls_utils.h

60

(DIV_ROUND_UP(sizeof(struct mlx5e_get_tls_progress_params_wqe), MLX5_SEND_WQE_BB))

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

329

ds_cnt = DIV_ROUND_UP(mlx5e_mpwrq_umr_wqe_sz(rq->mdev, rq->mpwqe.page_shift,

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

1427

skb_shinfo(skb)->gso_size = DIV_ROUND_UP(cqe_bcnt - hdrlen, lro_num_seg);

drivers/net/ethernet/mellanox/mlx5/core/en_tx.c

311

ds_cnt_ids = DIV_ROUND_UP(sizeof(struct mlx5_wqe_inline_seg) + attr->insz,

drivers/net/ethernet/mellanox/mlx5/core/en_tx.c

321

ds_cnt_inl = DIV_ROUND_UP(inl, MLX5_SEND_WQE_DS);

drivers/net/ethernet/mellanox/mlx5/core/en_tx.c

332

.num_wqebbs = DIV_ROUND_UP(ds_cnt, MLX5_SEND_WQEBB_NUM_DS),

drivers/net/ethernet/mellanox/mlx5/core/en_tx.c

557

.num_wqebbs = DIV_ROUND_UP(ds_count, MLX5_SEND_WQEBB_NUM_DS),

drivers/net/ethernet/mellanox/mlx5/core/en_tx.c

940

ds_cnt_inl = DIV_ROUND_UP(inl, MLX5_SEND_WQE_DS);

drivers/net/ethernet/mellanox/mlx5/core/en_tx.c

947

.num_wqebbs = DIV_ROUND_UP(ds_cnt, MLX5_SEND_WQEBB_NUM_DS),

drivers/net/ethernet/mellanox/mlx5/core/esw/qos.c

356

DIV_ROUND_UP(value, divider), MLX5_MIN_BW_SHARE));

drivers/net/ethernet/mellanox/mlx5/core/lib/aso.h

11

(DIV_ROUND_UP(sizeof(struct mlx5_aso_wqe), MLX5_SEND_WQE_BB))

drivers/net/ethernet/mellanox/mlx5/core/lib/aso.h

13

(DIV_ROUND_UP(sizeof(struct mlx5_aso_wqe_data), MLX5_SEND_WQE_BB))

drivers/net/ethernet/mellanox/mlx5/core/lib/aso.h

16

#define MLX5_MACSEC_ASO_DS_CNT (DIV_ROUND_UP(sizeof(struct mlx5_aso_wqe), MLX5_SEND_WQE_DS))

drivers/net/ethernet/mellanox/mlx5/core/pci_irq.c

639

num_sf_ctrl = DIV_ROUND_UP(mlx5_sf_max_functions(dev),

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_icm_pool.c

547

num_of_chunks = DIV_ROUND_UP(max_hot_size, entry_size) + 1;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_send.c

477

dr_qp->sq.pc += DIV_ROUND_UP(size * 16, MLX5_SEND_WQE_BB);

drivers/net/ethernet/mellanox/mlx5/core/wc.c

300

DIV_ROUND_UP(sizeof(struct mlx5_wqe_ctrl_seg), MLX5_SEND_WQE_DS));

drivers/net/ethernet/mellanox/mlxsw/i2c.c

427

num = DIV_ROUND_UP(reg_size, mlxsw_i2c->block_size);

drivers/net/ethernet/mellanox/mlxsw/i2c.c

446

num = DIV_ROUND_UP(reg_size, mlxsw_i2c->block_size);

drivers/net/ethernet/mellanox/mlxsw/pci.c

475

return DIV_ROUND_UP(byte_count + MLXSW_PCI_RX_BUF_SW_OVERHEAD,

drivers/net/ethernet/mellanox/mlxsw/reg.h

3377

return DIV_ROUND_UP(block_num, 4);

drivers/net/ethernet/mellanox/mlxsw/spectrum2_kvdl.c

139

bit_count = DIV_ROUND_UP(size, part->indexes_per_usage_bit);

drivers/net/ethernet/mellanox/mlxsw/spectrum2_kvdl.c

97

bit_count = DIV_ROUND_UP(size, part->indexes_per_usage_bit);

drivers/net/ethernet/mellanox/mlxsw/spectrum_buffers.c

135

return DIV_ROUND_UP(bytes, mlxsw_sp->sb->cell_size);

drivers/net/ethernet/mellanox/mlxsw/spectrum_dcb.c

550

hdroom.delay_bytes = DIV_ROUND_UP(pfc->delay, BITS_PER_BYTE);

drivers/net/ethernet/mellanox/mlxsw/spectrum_qdisc.c

736

prob = DIV_ROUND_UP(prob, 1 << 16);

drivers/net/ethernet/mellanox/mlxsw/spectrum_qdisc.c

737

prob = DIV_ROUND_UP(prob, 1 << 16);

drivers/net/ethernet/meta/fbnic/fbnic_csr.h

691

DIV_ROUND_UP(FBNIC_RPC_RSS_KEY_BIT_LEN, 8)

drivers/net/ethernet/meta/fbnic/fbnic_csr.h

693

DIV_ROUND_UP(FBNIC_RPC_RSS_KEY_BIT_LEN, 32)

drivers/net/ethernet/meta/fbnic/fbnic_devlink.c

418

index_count = DIV_ROUND_UP(size, TLV_MAX_DATA);

drivers/net/ethernet/meta/fbnic/fbnic_txrx.c

1788

int tqpv = DIV_ROUND_UP(num_tx, num_napi - txq_idx);

drivers/net/ethernet/meta/fbnic/fbnic_txrx.c

1789

int rqpv = DIV_ROUND_UP(num_rx, num_napi - rxq_idx);

drivers/net/ethernet/microchip/lan966x/lan966x_cbs.c

25

cir = DIV_ROUND_UP(cir, 100);

drivers/net/ethernet/microchip/lan966x/lan966x_cbs.c

29

cbs = DIV_ROUND_UP(cbs, 4096);

drivers/net/ethernet/microchip/lan966x/lan966x_main.c

257

count = DIV_ROUND_UP(skb->len, 4);

drivers/net/ethernet/microchip/lan966x/lan966x_police.c

25

pol->rate = DIV_ROUND_UP(pol->rate * 3, 100);

drivers/net/ethernet/microchip/lan966x/lan966x_police.c

29

pol->burst = DIV_ROUND_UP(pol->burst, 4096);

drivers/net/ethernet/microchip/lan966x/lan966x_tbf.c

29

cir = DIV_ROUND_UP(cir, 100);

drivers/net/ethernet/microchip/lan966x/lan966x_tbf.c

33

cbs = DIV_ROUND_UP(cbs, 4096);

drivers/net/ethernet/microchip/sparx5/lan969x/lan969x_calendar.c

147

speed->n_slots = DIV_ROUND_UP(required_bw, bw_per_slot);

drivers/net/ethernet/microchip/sparx5/lan969x/lan969x_calendar.c

150

speed->gap = DIV_ROUND_UP(cal_len,

drivers/net/ethernet/microchip/sparx5/sparx5_packet.c

193

count = DIV_ROUND_UP(skb->len, 4);

drivers/net/ethernet/microchip/sparx5/sparx5_police.c

28

thres = DIV_ROUND_UP(burst, g->min_burst);

drivers/net/ethernet/microchip/sparx5/sparx5_qos.c

523

sh.rate = DIV_ROUND_UP(sh.rate, lg->resolution);

drivers/net/ethernet/microchip/sparx5/sparx5_qos.c

524

sh.burst = DIV_ROUND_UP(sh.burst, SPX5_SE_BURST_UNIT);

drivers/net/ethernet/microchip/sparx5/sparx5_tc_flower.c

755

if (pol->rate > DIV_ROUND_UP(SPX5_SDLB_GROUP_RATE_MAX, 1000)) {

drivers/net/ethernet/microchip/vcap/vcap_api.c

1460

memset(value, 0, DIV_ROUND_UP(actionfield[idx].width, 8));

drivers/net/ethernet/microchip/vcap/vcap_api.c

1512

memset(mask, 0, DIV_ROUND_UP(keyfield[idx].width, 8));

drivers/net/ethernet/microchip/vcap/vcap_api.c

1521

memset(value, 0, DIV_ROUND_UP(keyfield[idx].width, 8));

drivers/net/ethernet/microchip/vcap/vcap_api.c

176

int bytes = DIV_ROUND_UP(width, BITS_PER_BYTE);

drivers/net/ethernet/microchip/vcap/vcap_api.c

377

keyset_sw_regs = DIV_ROUND_UP(vctrl->vcaps[vt].sw_width, 32);

drivers/net/ethernet/microchip/vcap/vcap_api.c

55

itr->regs_per_sw = DIV_ROUND_UP(sw_width, 32);

drivers/net/ethernet/microchip/vcap/vcap_api.c

897

ri->keyset_sw_regs = DIV_ROUND_UP(sw_width, 32);

drivers/net/ethernet/microchip/vcap/vcap_api.c

917

ri->actionset_sw_regs = DIV_ROUND_UP(act_width, 32);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

105

bytes = DIV_ROUND_UP(keyfield[key].width, BITS_PER_BYTE);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

150

bytes = DIV_ROUND_UP(actionfield[action].width, BITS_PER_BYTE);

drivers/net/ethernet/mscc/ocelot.c

1467

count = DIV_ROUND_UP(skb->len, 4);

drivers/net/ethernet/mscc/ocelot_police.c

53

cir = DIV_ROUND_UP(cir, 100);

drivers/net/ethernet/mscc/ocelot_police.c

55

cbs = DIV_ROUND_UP(cbs, 4096);

drivers/net/ethernet/mscc/ocelot_police.c

67

pir = DIV_ROUND_UP(pir, 100);

drivers/net/ethernet/mscc/ocelot_police.c

69

pbs = DIV_ROUND_UP(pbs, 4096);

drivers/net/ethernet/mscc/ocelot_police.c

77

pir = DIV_ROUND_UP(pir, 100);

drivers/net/ethernet/mscc/ocelot_vcap.c

111

entry_words = DIV_ROUND_UP(vcap->entry_width, ENTRY_WIDTH);

drivers/net/ethernet/mscc/ocelot_vcap.c

137

action_words = DIV_ROUND_UP(vcap->action_width, ENTRY_WIDTH);

drivers/net/ethernet/mscc/ocelot_vcap.c

155

action_words = DIV_ROUND_UP(vcap->action_width, ENTRY_WIDTH);

drivers/net/ethernet/mscc/ocelot_vcap.c

94

entry_words = DIV_ROUND_UP(vcap->entry_width, ENTRY_WIDTH);

drivers/net/ethernet/netronome/nfp/abm/ctrl.c

320

size = DIV_ROUND_UP(size * abm->num_prios, BITS_PER_BYTE);

drivers/net/ethernet/netronome/nfp/bpf/offload.c

262

for (i = 0; i < DIV_ROUND_UP(nfp_map->offmap->map.value_size, 4); i++)

drivers/net/ethernet/netronome/nfp/bpf/offload.c

276

for (i = 0; i < DIV_ROUND_UP(nfp_map->offmap->map.value_size, 4); i++)

drivers/net/ethernet/netronome/nfp/bpf/offload.c

380

use_map_size = DIV_ROUND_UP(offmap->map.value_size, 4) *

drivers/net/ethernet/netronome/nfp/ccm_mbox.c

314

cnt = DIV_ROUND_UP(length, 4);

drivers/net/ethernet/netronome/nfp/crypto/ipsec.c

368

key_len = DIV_ROUND_UP(x->aalg->alg_key_len, BITS_PER_BYTE);

drivers/net/ethernet/netronome/nfp/crypto/ipsec.c

461

key_len = DIV_ROUND_UP(x->aead->alg_key_len, BITS_PER_BYTE);

drivers/net/ethernet/netronome/nfp/crypto/ipsec.c

488

key_len = DIV_ROUND_UP(x->ealg->alg_key_len, BITS_PER_BYTE);

drivers/net/ethernet/netronome/nfp/nfdk/dp.c

135

n_descs += DIV_ROUND_UP(skb_frag_size(frag),

drivers/net/ethernet/netronome/nfp/nfdk/dp.c

522

n_descs += DIV_ROUND_UP(size,

drivers/net/ethernet/netronome/nfp/nfdk/nfdk.h

114

return DIV_ROUND_UP(headlen +

drivers/net/ethernet/netronome/nfp/nfdk/rings.c

47

n_descs += DIV_ROUND_UP(size,

drivers/net/ethernet/netronome/nfp/nfp_net_main.c

252

DIV_ROUND_UP(irqs_left, vnics_left));

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp.c

515

nseg = DIV_ROUND_UP(max_size, chunk_size);

drivers/net/ethernet/pensando/ionic/ionic_fw.c

121

(int)fw->size, buf_sz, DIV_ROUND_UP(fw->size, buf_sz));

drivers/net/ethernet/pensando/ionic/ionic_phc.c

586

diff = DIV_ROUND_UP(diff, phc->cc.mult);

drivers/net/ethernet/pensando/ionic/ionic_txrx.c

1540

stats->pkts += DIV_ROUND_UP(len - hdrlen, mss);

drivers/net/ethernet/qlogic/qed/qed_cxt.c

2155

total_lines = DIV_ROUND_UP(p_fl_seg->total_size,

drivers/net/ethernet/qlogic/qed/qed_cxt.c

2488

total_lines = DIV_ROUND_UP(p_seg->total_size, p_seg->real_size_in_page);

drivers/net/ethernet/qlogic/qed/qed_cxt.c

2508

return DIV_ROUND_UP(p_blk->total_size, p_blk->real_size_in_page);

drivers/net/ethernet/qlogic/qed/qed_cxt.c

397

*p_line += DIV_ROUND_UP(p_blk->total_size, p_blk->real_size_in_page);

drivers/net/ethernet/qlogic/qed/qed_cxt.c

845

p_t2->num_pages = DIV_ROUND_UP(total_size, psz);

drivers/net/ethernet/qlogic/qed/qed_cxt.c

957

lines = DIV_ROUND_UP(sz_left, p_blk->real_size_in_page) - lines_to_skip;

drivers/net/ethernet/qlogic/qed/qed_debug.c

3226

for (i = 0; i < DIV_ROUND_UP(ram_size, BRB_REG_BIG_RAM_DATA_SIZE);

drivers/net/ethernet/qlogic/qed/qed_debug.c

391

#define CEIL_DWORDS(size) DIV_ROUND_UP(size, 32)

drivers/net/ethernet/qlogic/qed/qed_debug.c

4227

DIV_ROUND_UP(trace_data_size_bytes + sizeof(struct mcp_trace),

drivers/net/ethernet/qlogic/qed/qed_debug.c

5171

valid_conn_pf_pages = DIV_ROUND_UP(valid_conn_pf_cids,

drivers/net/ethernet/qlogic/qed/qed_debug.c

5173

valid_conn_vf_pages = DIV_ROUND_UP(valid_conn_vf_cids,

drivers/net/ethernet/qlogic/qed/qed_init_fw_funcs.c

1654

#define PHYS_ADDR_DWORDS DIV_ROUND_UP(sizeof(dma_addr_t), 4)

drivers/net/ethernet/qlogic/qed/qed_init_fw_funcs.c

22

#define QM_PQ_MEM_4KB(pq_size) (pq_size ? DIV_ROUND_UP((pq_size + 1) * \

drivers/net/ethernet/qlogic/qed/qed_init_fw_funcs.c

25

#define QM_PQ_SIZE_256B(pq_size) (pq_size ? DIV_ROUND_UP(pq_size, \

drivers/net/ethernet/qlogic/qed/qed_main.c

2275

DIV_ROUND_UP(nvm_image->length - 4, 4));

drivers/net/ethernet/qlogic/qed/qed_mcp.c

3827

DIV_ROUND_UP(p_params->retry_interval,

drivers/net/ethernet/realtek/r8169_main.c

2108

ec->tx_coalesce_usecs = DIV_ROUND_UP(c_us * scale, 1000);

drivers/net/ethernet/realtek/r8169_main.c

2115

ec->rx_coalesce_usecs = DIV_ROUND_UP(c_us * scale, 1000);

drivers/net/ethernet/realtek/r8169_main.c

2187

w |= FIELD_PREP(RTL_COALESCE_TX_FRAMES, DIV_ROUND_UP(tx_fr, 4));

drivers/net/ethernet/realtek/r8169_main.c

2188

w |= FIELD_PREP(RTL_COALESCE_RX_FRAMES, DIV_ROUND_UP(rx_fr, 4));

drivers/net/ethernet/realtek/r8169_main.c

2190

units = DIV_ROUND_UP(ec->tx_coalesce_usecs * 1000U, scale);

drivers/net/ethernet/realtek/r8169_main.c

2192

units = DIV_ROUND_UP(ec->rx_coalesce_usecs * 1000U, scale);

drivers/net/ethernet/renesas/sh_eth.c

2067

len = DIV_ROUND_UP(SH_ETH_REG_DUMP_MAX_REGS, 32);

drivers/net/ethernet/renesas/sh_eth.c

406

u32 *maxp = p + DIV_ROUND_UP(len, sizeof(u32));

drivers/net/ethernet/sfc/ef10.c

1168

DIV_ROUND_UP(efx->n_tx_channels,

drivers/net/ethernet/sfc/efx.c

306

efx->irq_mod_step_us = DIV_ROUND_UP(efx->timer_quantum_ns, 1000);

drivers/net/ethernet/sfc/efx_channels.c

147

n_xdp_ev = DIV_ROUND_UP(n_xdp_tx, tx_per_ev);

drivers/net/ethernet/sfc/efx_channels.c

182

DIV_ROUND_UP(n_xdp_tx, tx_per_ev * n_xdp_ev));

drivers/net/ethernet/sfc/falcon/efx.c

1656

efx->irq_mod_step_us = DIV_ROUND_UP(efx->timer_quantum_ns, 1000);

drivers/net/ethernet/sfc/falcon/falcon.c

371

.timeout = DIV_ROUND_UP(HZ, 20),

drivers/net/ethernet/sfc/falcon/falcon.c

530

unsigned long timeout = jiffies + 1 + DIV_ROUND_UP(HZ, 10);

drivers/net/ethernet/sfc/falcon/falcon.c

668

unsigned long timeout = jiffies + 1 + DIV_ROUND_UP(HZ, 100);

drivers/net/ethernet/sfc/falcon/rx.c

101

efx->rx_pages_per_batch = DIV_ROUND_UP(EF4_RX_PREFERRED_BATCH,

drivers/net/ethernet/sfc/falcon/rx.c

46

#define EF4_RX_MAX_FRAGS DIV_ROUND_UP(EF4_MAX_FRAME_LEN(EF4_MAX_MTU), \

drivers/net/ethernet/sfc/falcon/tx.c

528

return DIV_ROUND_UP(tx_queue->ptr_mask + 1, PAGE_SIZE >> EF4_TX_CB_ORDER);

drivers/net/ethernet/sfc/falcon/tx.c

93

DIV_ROUND_UP(GSO_LEGACY_MAX_SIZE,

drivers/net/ethernet/sfc/mae.c

1839

if (DIV_ROUND_UP(field.width, 8) != value_size)

drivers/net/ethernet/sfc/mae.c

1973

kw = DIV_ROUND_UP(efx->tc->meta_ct.desc.key_width, 32);

drivers/net/ethernet/sfc/mae.c

1974

rw = DIV_ROUND_UP(efx->tc->meta_ct.desc.resp_width, 32);

drivers/net/ethernet/sfc/mae.c

2045

kw = DIV_ROUND_UP(efx->tc->meta_ct.desc.key_width, 32);

drivers/net/ethernet/sfc/mcdi.c

297

data_len = DIV_ROUND_UP(mcdi->resp_data_len, 4);

drivers/net/ethernet/sfc/mcdi.h

185

#define MCDI_TX_BUF_LEN(_len) DIV_ROUND_UP((_len), 4)

drivers/net/ethernet/sfc/mcdi.h

187

efx_dword_t _name[DIV_ROUND_UP(_len, 4)]

drivers/net/ethernet/sfc/rx.c

40

#define EFX_RX_MAX_FRAGS DIV_ROUND_UP(EFX_MAX_FRAME_LEN(EFX_MAX_MTU), \

drivers/net/ethernet/sfc/rx_common.c

440

efx->rx_pages_per_batch = DIV_ROUND_UP(EFX_RX_PREFERRED_BATCH,

drivers/net/ethernet/sfc/rx_common.h

18

#define EFX_RX_MAX_FRAGS DIV_ROUND_UP(EFX_MAX_FRAME_LEN(EFX_MAX_MTU), \

drivers/net/ethernet/sfc/siena/efx.c

315

efx->irq_mod_step_us = DIV_ROUND_UP(efx->timer_quantum_ns, 1000);

drivers/net/ethernet/sfc/siena/efx_channels.c

148

n_xdp_ev = DIV_ROUND_UP(n_xdp_tx, tx_per_ev);

drivers/net/ethernet/sfc/siena/efx_channels.c

183

DIV_ROUND_UP(n_xdp_tx, tx_per_ev * n_xdp_ev));

drivers/net/ethernet/sfc/siena/mcdi.c

301

data_len = DIV_ROUND_UP(mcdi->resp_data_len, 4);

drivers/net/ethernet/sfc/siena/mcdi.h

195

#define MCDI_TX_BUF_LEN(_len) DIV_ROUND_UP((_len), 4)

drivers/net/ethernet/sfc/siena/mcdi.h

197

efx_dword_t _name[DIV_ROUND_UP(_len, 4)]

drivers/net/ethernet/sfc/siena/ptp.c

169

u32 words[DIV_ROUND_UP(PTP_V1_UUID_LENGTH, 4)];

drivers/net/ethernet/sfc/siena/rx.c

40

#define EFX_RX_MAX_FRAGS DIV_ROUND_UP(EFX_MAX_FRAME_LEN(EFX_MAX_MTU), \

drivers/net/ethernet/sfc/siena/rx_common.c

437

efx->rx_pages_per_batch = DIV_ROUND_UP(EFX_RX_PREFERRED_BATCH,

drivers/net/ethernet/sfc/siena/rx_common.h

18

#define EFX_RX_MAX_FRAGS DIV_ROUND_UP(EFX_MAX_FRAME_LEN(EFX_MAX_MTU), \

drivers/net/ethernet/sfc/siena/siena.c

756

unsigned int inlen_dw = DIV_ROUND_UP(sdu_len, 4);

drivers/net/ethernet/sfc/siena/siena.c

791

unsigned int outlen_dw = DIV_ROUND_UP(outlen, 4);

drivers/net/ethernet/sfc/siena/tx_common.c

19

return DIV_ROUND_UP(tx_queue->ptr_mask + 1,

drivers/net/ethernet/sfc/siena/tx_common.c

416

DIV_ROUND_UP(GSO_MAX_SIZE, EFX_PAGE_SIZE));

drivers/net/ethernet/sfc/tx_common.c

19

return DIV_ROUND_UP(tx_queue->ptr_mask + 1,

drivers/net/ethernet/sfc/tx_common.c

456

DIV_ROUND_UP(GSO_LEGACY_MAX_SIZE,

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

2190

num_pages = DIV_ROUND_UP(dma_buf_sz_pad, PAGE_SIZE);

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5611

bufsz = DIV_ROUND_UP(priv->dma_conf.dma_buf_sz, PAGE_SIZE) * PAGE_SIZE;

drivers/net/ethernet/stmicro/stmmac/stmmac_mdio.c

403

msleep(DIV_ROUND_UP(delays[0], 1000));

drivers/net/ethernet/stmicro/stmmac/stmmac_mdio.c

407

msleep(DIV_ROUND_UP(delays[1], 1000));

drivers/net/ethernet/stmicro/stmmac/stmmac_mdio.c

411

msleep(DIV_ROUND_UP(delays[2], 1000));

drivers/net/ethernet/sun/sunvnet_common.c

1255

gso_segs = DIV_ROUND_UP(skb->len - hlen, datalen);

drivers/net/ethernet/sun/sunvnet_common.c

1292

DIV_ROUND_UP(curr->len - hlen, gso_size);

drivers/net/ethernet/ti/am65-cpsw-qos.c

22

#define TO_MBPS(x) DIV_ROUND_UP((x), BYTES_PER_MBIT)

drivers/net/ethernet/ti/am65-cpsw-qos.c

38

ir = DIV_ROUND_UP(((u64)rate_mbps * 32768), bus_freq);

drivers/net/ethernet/ti/am65-cpsw-qos.c

640

return DIV_ROUND_UP(temp, 8 * 1000);

drivers/net/ethernet/ti/am65-cpsw-qos.c

688

cmd_cnt = DIV_ROUND_UP(fetch_cnt, AM65_CPSW_FETCH_CNT_MAX);

drivers/net/ethernet/ti/am65-cpts.c

623

cycles = DIV_ROUND_UP(cycles, NSEC_PER_SEC);

drivers/net/ethernet/ti/cpsw_ale.h

157

#define ALE_ENTRY_WORDS DIV_ROUND_UP(ALE_ENTRY_BITS, 32)

drivers/net/ethernet/ti/cpsw_priv.c

834

val = DIV_ROUND_UP(bw, priv->shp_cfg_speed * 10);

drivers/net/ethernet/ti/davinci_cpdma.c

467

send_cnt = DIV_ROUND_UP(min_send_cnt, ch->rate);

drivers/net/ethernet/ti/davinci_cpdma.c

817

return DIV_ROUND_UP(divident, divisor);

drivers/net/ethernet/ti/icssm/icssm_prueth.c

566

pkt_block_size = DIV_ROUND_UP(pktlen, ICSS_BLOCK_SIZE);

drivers/net/ethernet/ti/icssm/icssm_prueth.c

675

pkt_block_size = DIV_ROUND_UP(pkt_info->length, ICSS_BLOCK_SIZE);

drivers/net/ethernet/wangxun/libwx/wx_lib.c

2235

rqpv = DIV_ROUND_UP(rxr_remaining, q_vectors - v_idx);

drivers/net/ethernet/wangxun/libwx/wx_lib.c

2236

tqpv = DIV_ROUND_UP(txr_remaining, q_vectors - v_idx);

drivers/net/ethernet/wangxun/libwx/wx_lib.c

602

skb_shinfo(skb)->gso_size = DIV_ROUND_UP((skb->len - hdr_len),

drivers/net/ethernet/wangxun/libwx/wx_sriov.c

507

max_frs = DIV_ROUND_UP(max_frame, 1024);

drivers/net/ethernet/wangxun/libwx/wx_type.h

566

#define TXD_USE_COUNT(S) DIV_ROUND_UP((S), WX_MAX_DATA_PER_TXD)

drivers/net/ethernet/xscale/ixp4xx_eth.c

1193

chunks = DIV_ROUND_UP(framesize, 64);

drivers/net/hyperv/netvsc_drv.c

389

slots = DIV_ROUND_UP(offset + len, HV_HYP_PAGE_SIZE);

drivers/net/ipa/ipa_interrupt.c

56

unit_count = DIV_ROUND_UP(ipa->endpoint_count, 32);

drivers/net/mdio/mdio-ipq4019.c

236

if (priv->mdc_rate == DIV_ROUND_UP(ahb_rate, div)) {

drivers/net/mdio/mdio-ipq4019.c

307

priv->mdc_rate = DIV_ROUND_UP(ahb_rate, div + 1);

drivers/net/mdio/mdio-ipq4019.c

319

if (DIV_ROUND_UP(ahb_rate, div) > 2500000)

drivers/net/mdio/mdio-ipq4019.c

322

priv->mdc_rate = DIV_ROUND_UP(ahb_rate, div);

drivers/net/mdio/mdio-mscc-miim.c

260

div = DIV_ROUND_UP(rate, 2 * miim->bus_freq) - 1;

drivers/net/phy/as21xxx.c

506

for (i = 0; i < DIV_ROUND_UP(ret_size, sizeof(u16)); i++) {

drivers/net/thunderbolt/main.c

1121

nframes = DIV_ROUND_UP(data_len, TBNET_MAX_PAYLOAD_SIZE);

drivers/net/virtio_net.c

6378

unsigned int min_buf_len = DIV_ROUND_UP(buf_len, rq_size);

drivers/net/virtio_net.c

6656

vi->big_packets_num_skbfrags = guest_gso ? MAX_SKB_FRAGS : DIV_ROUND_UP(mtu, PAGE_SIZE);

drivers/net/vmxnet3/vmxnet3_drv.c

1929

DIV_ROUND_UP(skb->len -

drivers/net/wireguard/allowedips.c

385

const unsigned int cidr_bytes = DIV_ROUND_UP(node->cidr, 8U);

drivers/net/wireless/ath/ath10k/htc.c

121

credits = DIV_ROUND_UP(len, ep->tx_credit_size);

drivers/net/wireless/ath/ath10k/htc.c

154

credits = DIV_ROUND_UP(len, ep->tx_credit_size);

drivers/net/wireless/ath/ath10k/mac.c

127

return DIV_ROUND_UP(bitrate, 5) |

drivers/net/wireless/ath/ath11k/dp.c

527

num_scatter_buf = DIV_ROUND_UP(size, HAL_WBM_IDLE_SCATTER_BUF_SIZE);

drivers/net/wireless/ath/ath11k/dp_rx.c

3935

n_buffs = DIV_ROUND_UP(msdu_len,

drivers/net/wireless/ath/ath11k/htc.c

95

credits = DIV_ROUND_UP(skb->len, htc->target_credit_size);

drivers/net/wireless/ath/ath11k/mac.c

559

return DIV_ROUND_UP(bitrate, 5) |

drivers/net/wireless/ath/ath12k/dp.c

586

num_scatter_buf = DIV_ROUND_UP(size, HAL_WBM_IDLE_SCATTER_BUF_SIZE);

drivers/net/wireless/ath/ath12k/htc.c

93

credits = DIV_ROUND_UP(skb->len, htc->target_credit_size);

drivers/net/wireless/ath/ath12k/mac.c

747

return DIV_ROUND_UP(bitrate, 5) |

drivers/net/wireless/ath/ath12k/wifi7/dp_rx.c

1567

n_buffs = DIV_ROUND_UP(msdu_len,

drivers/net/wireless/ath/ath5k/pcu.c

148

bitrate = DIV_ROUND_UP(bitrate, 2);

drivers/net/wireless/ath/ath5k/pcu.c

154

bitrate = DIV_ROUND_UP(bitrate, 4);

drivers/net/wireless/ath/ath5k/pcu.c

164

symbols = DIV_ROUND_UP(bits * 10, symbol_bits);

drivers/net/wireless/ath/ath6kl/cfg80211.c

2920

inactivity_timeout = DIV_ROUND_UP(inactivity_timeout,

drivers/net/wireless/ath/ath6kl/htc_mbox.c

551

DIV_ROUND_UP(len, target->tgt_cred_sz) : 1;

drivers/net/wireless/ath/ath9k/ath9k.h

144

DIV_ROUND_UP(ATH_AGGR_MINPLEN - (_len), ATH_AGGR_DELIM_SZ))

drivers/net/wireless/ath/ath9k/common-beacon.c

86

bs->bs_bmissthreshold = DIV_ROUND_UP(conf->bmiss_timeout, conf->intval);

drivers/net/wireless/ath/ath9k/hw.c

190

numSymbols = DIV_ROUND_UP(numBits, bitsPerSymbol);

drivers/net/wireless/ath/ath9k/hw.c

199

numSymbols = DIV_ROUND_UP(numBits, bitsPerSymbol);

drivers/net/wireless/ath/ath9k/hw.c

206

numSymbols = DIV_ROUND_UP(numBits, bitsPerSymbol);

drivers/net/wireless/ath/ath9k/hw.c

2979

channel->max_power = DIV_ROUND_UP(reg->max_power_level, 2);

drivers/net/wireless/ath/ath9k/wow.c

149

mask_len = DIV_ROUND_UP(patterns[i].pattern_len, 8);

drivers/net/wireless/ath/carl9170/carl9170.h

115

#define CARL9170_BAW_LEN (DIV_ROUND_UP(CARL9170_BAW_BITS, BITS_PER_BYTE))

drivers/net/wireless/ath/carl9170/tx.c

1676

for (i = 0; i < DIV_ROUND_UP(skb->len, 4); i++) {

drivers/net/wireless/ath/carl9170/tx.c

198

chunks = DIV_ROUND_UP(skb->len, ar->fw.mem_block_size);

drivers/net/wireless/ath/carl9170/tx.c

253

atomic_add(DIV_ROUND_UP(skb->len, ar->fw.mem_block_size),

drivers/net/wireless/ath/carl9170/tx.c

72

return (DIV_ROUND_UP(IEEE80211_MAX_FRAME_LEN, ar->fw.mem_block_size) >

drivers/net/wireless/broadcom/brcm80211/brcmfmac/fweh.c

356

fweh->event_mask_len = DIV_ROUND_UP(fweh->num_event_codes, 8);

drivers/net/wireless/intel/iwlwifi/dvm/eeprom.c

409

DIV_ROUND_UP(max_txp_avg_halfdbm, 2));

drivers/net/wireless/intel/iwlwifi/dvm/lib.c

1016

int mask_len = DIV_ROUND_UP(wowlan->patterns[i].pattern_len, 8);

drivers/net/wireless/intel/iwlwifi/dvm/rxon.c

405

if (tx_power > DIV_ROUND_UP(priv->nvm_data->max_tx_pwr_half_dbm, 2)) {

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

570

nents = DIV_ROUND_UP(size, PAGE_SIZE);

drivers/net/wireless/intel/iwlwifi/fw/paging.c

55

DIV_ROUND_UP(num_of_pages, NUM_OF_PAGE_PER_GROUP);

drivers/net/wireless/intel/iwlwifi/iwl-dbg-tlv.c

566

pages = DIV_ROUND_UP(pages, 2);

drivers/net/wireless/intel/iwlwifi/iwl-dbg-tlv.c

615

remain_pages = DIV_ROUND_UP(le32_to_cpu(fw_mon_cfg->req_size),

drivers/net/wireless/intel/iwlwifi/iwl-dbg-tlv.c

619

frag_pages = DIV_ROUND_UP(remain_pages, num_frags);

drivers/net/wireless/intel/iwlwifi/iwl-dbg-tlv.c

684

num_commands = DIV_ROUND_UP(remain_frags, BUF_ALLOC_MAX_NUM_FRAGS);

drivers/net/wireless/intel/iwlwifi/iwl-drv.c

548

if (api_index >= DIV_ROUND_UP(NUM_IWL_UCODE_TLV_API, 32)) {

drivers/net/wireless/intel/iwlwifi/iwl-drv.c

569

if (api_index >= DIV_ROUND_UP(NUM_IWL_UCODE_TLV_CAPA, 32)) {

drivers/net/wireless/intel/iwlwifi/mld/d3.c

1757

int mask_len = DIV_ROUND_UP(wowlan->patterns[i].pattern_len, 8);

drivers/net/wireless/intel/iwlwifi/mld/power.c

243

keep_alive = DIV_ROUND_UP(ieee80211_tu_to_usec(3 * dtimper * bi),

drivers/net/wireless/intel/iwlwifi/mvm/d3.c

649

int mask_len = DIV_ROUND_UP(wowlan->patterns[i].pattern_len, 8);

drivers/net/wireless/intel/iwlwifi/mvm/d3.c

695

int mask_len = DIV_ROUND_UP(wowlan->patterns[i].pattern_len, 8);

drivers/net/wireless/intel/iwlwifi/mvm/ftm-initiator.c

145

cmd->req_timeout = DIV_ROUND_UP(req->timeout, 100);

drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c

5391

DIV_ROUND_UP(chsw->delay, vif->bss_conf.beacon_int);

drivers/net/wireless/intel/iwlwifi/mvm/power.c

365

keep_alive = DIV_ROUND_UP(ieee80211_tu_to_usec(3 * dtimper * bi),

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/tx-gen2.c

186

hdr_room = DIV_ROUND_UP(total_len, mss) *

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/tx-gen2.c

582

num_fetch_chunks = DIV_ROUND_UP(filled_tfd_size, 64) - 1;

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/tx-gen2.c

588

len = DIV_ROUND_UP(len, 4);

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/tx.c

1938

hdr_room = DIV_ROUND_UP(total_len, mss) *

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/tx.c

2094

len = DIV_ROUND_UP(len, 4);

drivers/net/wireless/marvell/libertas/if_spi.c

236

DIV_ROUND_UP((100 + (delay * 10)), 1000);

drivers/net/wireless/marvell/mwifiex/cfg80211.c

3278

for (j = 0; j < DIV_ROUND_UP(pat->pattern_len, 8); j++) {

drivers/net/wireless/marvell/mwifiex/sdio.c

2016

rx_blocks = DIV_ROUND_UP(rx_len, MWIFIEX_SDIO_BLOCK_SIZE);

drivers/net/wireless/mediatek/mt76/mac80211.c

1775

*dbm = DIV_ROUND_UP(phy->txpower_cur + delta, 2);

drivers/net/wireless/mediatek/mt76/mt76.h

784

u32 param_set[DIV_ROUND_UP(NUM_MT76_TM_ATTRS, 32)];

drivers/net/wireless/mediatek/mt76/mt76.h

973

u32 wcid_mask[DIV_ROUND_UP(MT76_N_WCIDS, 32)];

drivers/net/wireless/mediatek/mt76/mt7603/init.c

482

target_power = DIV_ROUND_UP(target_power, 2);

drivers/net/wireless/mediatek/mt76/mt7615/init.c

312

target_power = DIV_ROUND_UP(target_power, 2);

drivers/net/wireless/mediatek/mt76/mt76_connac_mac.c

26

ppet_size = DIV_ROUND_UP(ppet_bits, 8);

drivers/net/wireless/mediatek/mt76/mt76_connac_mcu.c

2176

batch_size = DIV_ROUND_UP(n_chan, batch_len);

drivers/net/wireless/mediatek/mt76/mt76_connac_mcu.c

2540

memcpy(ptlv->mask, pattern->mask, DIV_ROUND_UP(pattern->pattern_len, 8));

drivers/net/wireless/mediatek/mt76/mt76x0/eeprom.c

18

#define MT_MAP_READS DIV_ROUND_UP(MT_EFUSE_USAGE_MAP_SIZE, 16)

drivers/net/wireless/mediatek/mt76/mt76x2/init.c

196

chan->orig_mpwr = DIV_ROUND_UP(chan->orig_mpwr, 2);

drivers/net/wireless/mediatek/mt76/mt7915/eeprom.c

148

block_num = DIV_ROUND_UP(eeprom_size, eeprom_blk_size);

drivers/net/wireless/mediatek/mt76/mt7915/eeprom.h

151

return DIV_ROUND_UP(channel - 29, 32);

drivers/net/wireless/mediatek/mt76/mt7915/init.c

316

target_power = DIV_ROUND_UP(target_power, 2);

drivers/net/wireless/mediatek/mt76/mt7915/mcu.c

2843

u8 total = DIV_ROUND_UP(eeprom_size, PER_PAGE_SIZE);

drivers/net/wireless/mediatek/mt76/mt7915/mcu.c

3333

.txpower_max = DIV_ROUND_UP(mphy->txpower_cur, 2),

drivers/net/wireless/mediatek/mt76/mt7915/mcu.c

3372

DIV_ROUND_UP(txpower - txpower_sku[offs], 2);

drivers/net/wireless/mediatek/mt76/mt7925/mcu.c

244

memcpy(tlv->mask, pattern->mask, DIV_ROUND_UP(pattern->pattern_len, 8));

drivers/net/wireless/mediatek/mt76/mt7925/mcu.c

3698

batch_size = DIV_ROUND_UP(n_chan, batch_len);

drivers/net/wireless/mediatek/mt76/mt7996/eeprom.c

180

u32 block_num = DIV_ROUND_UP(MT7996_EEPROM_SIZE, eeprom_blk_size);

drivers/net/wireless/mediatek/mt76/mt7996/eeprom.h

76

return DIV_ROUND_UP(channel - 29, 32);

drivers/net/wireless/mediatek/mt76/mt7996/init.c

361

target_power = DIV_ROUND_UP(target_power, 2);

drivers/net/wireless/mediatek/mt76/mt7996/main.c

748

*dbm = DIV_ROUND_UP(phy->mt76->txpower_cur + delta, 2);

drivers/net/wireless/mediatek/mt76/mt7996/mcu.c

3775

u8 total = DIV_ROUND_UP(eeprom_size, PER_PAGE_SIZE);

drivers/net/wireless/mediatek/mt76/sdio_txrx.c

193

pse_sz = DIV_ROUND_UP(buf_sz + sdio->sched.deficit,

drivers/net/wireless/mediatek/mt76/util.c

49

for (i = 0; i < DIV_ROUND_UP(size, 32); i++) {

drivers/net/wireless/mediatek/mt7601u/eeprom.c

69

const int map_reads = DIV_ROUND_UP(MT_EFUSE_USAGE_MAP_SIZE, 16);

drivers/net/wireless/ralink/rt2x00/rt2x00queue.c

1228

queue->threshold = DIV_ROUND_UP(queue->limit, 10);

drivers/net/wireless/realtek/rtl818x/rtl8180/dev.c

1473

hw_eifs = DIV_ROUND_UP(eifs, 4);

drivers/net/wireless/realtek/rtl818x/rtl8180/dev.c

1490

hw_eifs = DIV_ROUND_UP(eifs - difs, 4);

drivers/net/wireless/realtek/rtl818x/rtl8180/dev.c

519

plcp_len = DIV_ROUND_UP(16 * (skb->len + 4),

drivers/net/wireless/realtek/rtl818x/rtl8187/dev.c

1243

DIV_ROUND_UP(ack_timeout, 4));

drivers/net/wireless/realtek/rtlwifi/core.c

434

mask_len = DIV_ROUND_UP(patterns[i].pattern_len, 8);

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

1312

return DIV_ROUND_UP(len, page_size);

drivers/net/wireless/realtek/rtw88/main.c

216

expected_beacons = DIV_ROUND_UP(watchdog_delay, beacon_int);

drivers/net/wireless/realtek/rtw88/sdio.c

502

txaddr += DIV_ROUND_UP(size, 4);

drivers/net/wireless/realtek/rtw88/sdio.c

623

pages_needed = DIV_ROUND_UP(count, rtwdev->chip->page_size);

drivers/net/wireless/realtek/rtw88/wow.c

184

mask_len = DIV_ROUND_UP(len, 8);

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

2746

return DIV_ROUND_UP(val, 1000);

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

7949

len = DIV_ROUND_UP(info->content_len + RTW89_H2CREG_HDR_LEN,

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

1065

mpdu_info_b1_ofst = DIV_ROUND_UP(dle_input->mpdu_info_tbl_b0,

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

978

mask_len = DIV_ROUND_UP(len, 8);

drivers/net/wireless/ti/wlcore/scan.c

169

min_dwell_time_active = DIV_ROUND_UP(min_dwell_time_active, 1000);

drivers/net/wireless/ti/wlcore/scan.c

170

max_dwell_time_active = DIV_ROUND_UP(max_dwell_time_active, 1000);

drivers/net/wireless/ti/wlcore/scan.c

171

dwell_time_passive = DIV_ROUND_UP(dwell_time_passive, 1000);

drivers/net/wireless/ti/wlcore/scan.c

172

dwell_time_dfs = DIV_ROUND_UP(dwell_time_dfs, 1000);

drivers/net/xen-netback/netback.c

1259

DIV_ROUND_UP(skb->len - hdrlen, mss);

drivers/net/xen-netback/rx.c

48

needed = DIV_ROUND_UP(skb->len, XEN_PAGE_SIZE);

drivers/nfc/fdp/fdp.c

206

DIV_ROUND_UP(fw->size, max_size));

drivers/nvdimm/label.c

484

DIV_ROUND_UP(config_size, max_xfer);

drivers/nvdimm/label.c

491

read_size = min(DIV_ROUND_UP(read_size, max_xfer) * max_xfer,

drivers/nvdimm/label.c

52

return ALIGN(sizeof(struct nd_namespace_index) + DIV_ROUND_UP(nslot, 8),

drivers/nvdimm/label.c

535

label_read_size = DIV_ROUND_UP(label_read_size, max_xfer) *

drivers/nvme/host/apple.c

357

const unsigned int nprps = DIV_ROUND_UP(

drivers/nvme/host/apple.c

359

const int npages = DIV_ROUND_UP(8 * nprps, PAGE_SIZE - 8);

drivers/nvme/host/apple.c

460

nprps = DIV_ROUND_UP(length, NVME_CTRL_PAGE_SIZE);

drivers/nvme/host/core.c

1426

DIV_ROUND_UP(le32_to_cpu(cmd->common.cdw11), 1000);

drivers/nvme/host/fabrics.c

1087

opts->max_reconnects = DIV_ROUND_UP(ctrl_loss_tmo,

drivers/nvme/host/fc.c

3467

opts->max_reconnects = DIV_ROUND_UP(ctrl_loss_tmo,

drivers/nvme/host/pci.c

1044

if (DIV_ROUND_UP(length, NVME_CTRL_PAGE_SIZE) <=

drivers/nvme/host/pci.c

804

return DIV_ROUND_UP(blk_rq_payload_bytes(req), nseg);

drivers/nvme/host/sysfs.c

506

opts->max_reconnects = DIV_ROUND_UP(ctrl_loss_tmo,

drivers/nvme/target/admin-cmd.c

1229

req->sq->ctrl->kato = DIV_ROUND_UP(val32, 1000);

drivers/nvme/target/admin-cmd.c

246

DIV_ROUND_UP(part_stat_read(req->ns->bdev, sectors[READ]), 1000);

drivers/nvme/target/admin-cmd.c

249

DIV_ROUND_UP(part_stat_read(req->ns->bdev, sectors[WRITE]), 1000);

drivers/nvme/target/admin-cmd.c

274

data_units_read += DIV_ROUND_UP(

drivers/nvme/target/admin-cmd.c

277

data_units_written += DIV_ROUND_UP(

drivers/nvme/target/admin-cmd.c

518

DIV_ROUND_UP(part_stat_read(req->ns->bdev, sectors[READ]), 1000);

drivers/nvme/target/admin-cmd.c

521

DIV_ROUND_UP(part_stat_read(req->ns->bdev, sectors[WRITE]), 1000);

drivers/nvme/target/core.c

1672

ctrl->kato = DIV_ROUND_UP(kato, 1000);

drivers/nvme/target/pci-epf.c

2191

pba_size = ALIGN(DIV_ROUND_UP(epf->msix_interrupts, 8), 8);

drivers/nvme/target/tcp.c

363

nr_pages = DIV_ROUND_UP(length, PAGE_SIZE);

drivers/nvmem/core.c

1633

extra = cell->bytes - DIV_ROUND_UP(cell->nbits, BITS_PER_BYTE);

drivers/nvmem/core.c

1921

*len = DIV_ROUND_UP(nbits, 8);

drivers/nvmem/core.c

595

cell->bytes = DIV_ROUND_UP(cell->nbits + cell->bit_offset,

drivers/nvmem/imx-ocotp.c

276

relax = DIV_ROUND_UP(clk_rate * TIMING_RELAX_NS, 1000000000) - 1;

drivers/nvmem/imx-ocotp.c

277

strobe_read = DIV_ROUND_UP(clk_rate * TIMING_STROBE_READ_NS,

drivers/nvmem/lpc18xx_eeprom.c

218

clk_rate = DIV_ROUND_UP(clk_rate, LPC18XX_EEPROM_CLOCK_HZ) - 1;

drivers/nvmem/qfprom.c

326

int words = DIV_ROUND_UP(bytes, sizeof(u32));

drivers/pci/doe.c

330

length = 2 + DIV_ROUND_UP(task->request_pl_sz, sizeof(__le32));

drivers/pci/doe.c

409

payload_length = DIV_ROUND_UP(task->response_pl_sz, sizeof(__le32));

drivers/pci/endpoint/functions/pci-epf-ntb.c

1039

pba_size = ALIGN(DIV_ROUND_UP(ntb->db_count, 8), 8);

drivers/pci/endpoint/functions/pci-epf-test.c

1228

pba_size = ALIGN(DIV_ROUND_UP(epf->msix_interrupts, 8), 8);

drivers/perf/arm-cmn.c

600

u64 dtm_idx[DIV_ROUND_UP(CMN_MAX_NODES_PER_EVENT * 2, 64)];

drivers/perf/arm_brbe.c

777

int nr_banks = DIV_ROUND_UP(nr_hw, BRBE_BANK_MAX_ENTRIES);

drivers/perf/arm_cspmu/arm_cspmu.c

991

DIV_ROUND_UP(cspmu->num_logical_ctrs,

drivers/phy/allwinner/phy-sun6i-mipi-dphy.c

300

div = 16 >> order_base_2(DIV_ROUND_UP(mipi_symbol_rate, 264000000));

drivers/phy/amlogic/phy-meson-axg-mipi-dphy.c

248

DIV_ROUND_UP(priv->config.clk_trail, temp) |

drivers/phy/amlogic/phy-meson-axg-mipi-dphy.c

249

(DIV_ROUND_UP(priv->config.clk_post +

drivers/phy/amlogic/phy-meson-axg-mipi-dphy.c

251

(DIV_ROUND_UP(priv->config.clk_zero, temp) << 16) |

drivers/phy/amlogic/phy-meson-axg-mipi-dphy.c

252

(DIV_ROUND_UP(priv->config.clk_prepare, temp) << 24));

drivers/phy/amlogic/phy-meson-axg-mipi-dphy.c

254

DIV_ROUND_UP(priv->config.clk_pre, BITS_PER_BYTE));

drivers/phy/amlogic/phy-meson-axg-mipi-dphy.c

257

DIV_ROUND_UP(priv->config.hs_exit, temp) |

drivers/phy/amlogic/phy-meson-axg-mipi-dphy.c

258

(DIV_ROUND_UP(priv->config.hs_trail, temp) << 8) |

drivers/phy/amlogic/phy-meson-axg-mipi-dphy.c

259

(DIV_ROUND_UP(priv->config.hs_zero, temp) << 16) |

drivers/phy/amlogic/phy-meson-axg-mipi-dphy.c

260

(DIV_ROUND_UP(priv->config.hs_prepare, temp) << 24));

drivers/phy/amlogic/phy-meson-axg-mipi-dphy.c

263

DIV_ROUND_UP(priv->config.lpx, temp) |

drivers/phy/amlogic/phy-meson-axg-mipi-dphy.c

264

(DIV_ROUND_UP(priv->config.ta_sure, temp) << 8) |

drivers/phy/amlogic/phy-meson-axg-mipi-dphy.c

265

(DIV_ROUND_UP(priv->config.ta_go, temp) << 16) |

drivers/phy/amlogic/phy-meson-axg-mipi-dphy.c

266

(DIV_ROUND_UP(priv->config.ta_get, temp) << 24));

drivers/phy/amlogic/phy-meson-axg-mipi-dphy.c

270

DIV_ROUND_UP(priv->config.init * NSEC_PER_MSEC, temp));

drivers/phy/amlogic/phy-meson-axg-mipi-dphy.c

272

DIV_ROUND_UP(priv->config.wakeup * NSEC_PER_MSEC, temp));

drivers/phy/freescale/phy-fsl-samsung-hdmi.c

361

fld_tg_code = DIV_ROUND_UP(24 * MHZ * 256, int_pllclk);

drivers/phy/rockchip/phy-rockchip-inno-dsidphy.c

359

min_prediv = DIV_ROUND_UP(fref, 40000000);

drivers/phy/rockchip/phy-rockchip-inno-dsidphy.c

475

esc_clk_div = DIV_ROUND_UP(txbyteclkhs, 20000000);

drivers/phy/rockchip/phy-rockchip-inno-dsidphy.c

483

hs_exit = DIV_ROUND_UP(cfg->hs_exit, t_txbyteclkhs);

drivers/phy/rockchip/phy-rockchip-inno-dsidphy.c

488

clk_post = DIV_ROUND_UP(cfg->clk_post, t_txbyteclkhs);

drivers/phy/rockchip/phy-rockchip-inno-dsidphy.c

493

clk_pre = DIV_ROUND_UP(cfg->clk_pre, BITS_PER_BYTE);

drivers/phy/rockchip/phy-rockchip-inno-dsidphy.c

500

ta_go = DIV_ROUND_UP(cfg->ta_go, t_txclkesc);

drivers/phy/rockchip/phy-rockchip-inno-dsidphy.c

506

ta_sure = DIV_ROUND_UP(cfg->ta_sure, t_txclkesc);

drivers/phy/rockchip/phy-rockchip-inno-dsidphy.c

512

ta_wait = DIV_ROUND_UP(cfg->ta_get, t_txclkesc);

drivers/phy/rockchip/phy-rockchip-inno-dsidphy.c

526

lpx = DIV_ROUND_UP(cfg->lpx, t_txbyteclkhs);

drivers/phy/rockchip/phy-rockchip-samsung-dcphy.c

1411

max_mfr = DIV_ROUND_UP(fin, (20 * prediv) << 5);

drivers/phy/rockchip/phy-rockchip-samsung-dcphy.c

1420

mr = DIV_ROUND_UP(_mfr * _mrr * 100, fbdiv << 6);

drivers/phy/rockchip/phy-rockchip-samsung-hdptx.c

1064

mdiv = DIV_ROUND_UP(fvco, fref);

drivers/pinctrl/intel/pinctrl-intel.c

1464

padown_num += DIV_ROUND_UP(gpps[i].size * 4, INTEL_PINCTRL_MAX_GPP_SIZE);

drivers/pinctrl/intel/pinctrl-intel.c

1478

size_t i, ngpps = DIV_ROUND_UP(npins, community->gpp_size);

drivers/pinctrl/mediatek/mtk-eint.c

255

port_num = DIV_ROUND_UP(eint->base_pin_num[inst], 32);

drivers/pinctrl/mediatek/mtk-eint.c

566

port = DIV_ROUND_UP(eint->base_pin_num[i], 32);

drivers/pinctrl/mvebu/pinctrl-armada-xp.c

546

nregs = DIV_ROUND_UP(soc->nmodes, MVEBU_MPPS_PER_REG);

drivers/pinctrl/mvebu/pinctrl-armada-xp.c

560

nregs = DIV_ROUND_UP(soc->nmodes, MVEBU_MPPS_PER_REG);

drivers/pinctrl/mvebu/pinctrl-armada-xp.c

622

nregs = DIV_ROUND_UP(soc->nmodes, MVEBU_MPPS_PER_REG);

drivers/pinctrl/pinctrl-cy8c95x0.c

1425

chip->nport = DIV_ROUND_UP(CY8C95X0_PIN_TO_OFFSET(chip->tpin), BANK_SZ);

drivers/pinctrl/spear/pinctrl-plgpio.c

381

regs_count = DIV_ROUND_UP(count, MAX_GPIO_PER_REG);

drivers/pinctrl/spear/pinctrl-plgpio.c

569

DIV_ROUND_UP(plgpio->chip.ngpio, MAX_GPIO_PER_REG),

drivers/pinctrl/spear/pinctrl-plgpio.c

638

int i, reg_count = DIV_ROUND_UP(plgpio->chip.ngpio, MAX_GPIO_PER_REG);

drivers/pinctrl/spear/pinctrl-plgpio.c

678

int i, reg_count = DIV_ROUND_UP(plgpio->chip.ngpio, MAX_GPIO_PER_REG);

drivers/pinctrl/uniphier/pinctrl-uniphier-core.c

752

nregs = DIV_ROUND_UP(count * width, 32);

drivers/platform/mellanox/mlxbf-bootctl.c

422

num = min((int)DIV_ROUND_UP(size, sizeof(u64)),

drivers/platform/raspberrypi/vchiq-interface/vchiq_core.c

1522

num_pages = DIV_ROUND_UP(count + offset, PAGE_SIZE);

drivers/platform/x86/dell/dell-wmi-led.c

142

on_eighths = DIV_ROUND_UP(*delay_on, 125);

drivers/platform/x86/dell/dell-wmi-led.c

146

off_eighths = DIV_ROUND_UP(*delay_off, 125);

drivers/platform/x86/intel/uncore-frequency/uncore-frequency-tpmi.c

120

*val = DIV_ROUND_UP(*val, FIELD_MAX(UNCORE_EFF_LAT_CTRL_LOW_THRESHOLD_MASK));

drivers/platform/x86/intel/uncore-frequency/uncore-frequency-tpmi.c

126

*val = DIV_ROUND_UP(*val, FIELD_MAX(UNCORE_EFF_LAT_CTRL_HIGH_THRESHOLD_MASK));

drivers/platform/x86/intel_scu_ipc.c

484

size_t outbuflen = DIV_ROUND_UP(outlen, sizeof(u32));

drivers/platform/x86/intel_scu_ipc.c

485

size_t inbuflen = DIV_ROUND_UP(inlen, sizeof(u32));

drivers/pmdomain/imx/gpc.c

80

udelay(DIV_ROUND_UP(iso + iso2sw, pd->ipg_rate_mhz));

drivers/pmdomain/qcom/cpr.c

840

return DIV_ROUND_UP(uV, step_volt) * step_volt;

drivers/powercap/dtpm_devfreq.c

109

freq = DIV_ROUND_UP(status.current_frequency, HZ_PER_KHZ);

drivers/ptp/ptp_chardev.c

159

DIV_ROUND_UP(PTP_MAX_CHANNELS, BITS_PER_BYTE * sizeof(u32));

drivers/pwm/pwm-crc.c

145

DIV_ROUND_UP(clk_div * NSEC_PER_USEC * 256, PWM_BASE_CLK_MHZ);

drivers/pwm/pwm-img.c

105

output_clk_hz = DIV_ROUND_UP(NSEC_PER_SEC, period_ns);

drivers/pwm/pwm-img.c

107

mul = DIV_ROUND_UP(input_clk_hz, output_clk_hz);

drivers/pwm/pwm-img.c

110

timebase = DIV_ROUND_UP(mul, 1);

drivers/pwm/pwm-img.c

113

timebase = DIV_ROUND_UP(mul, 8);

drivers/pwm/pwm-img.c

116

timebase = DIV_ROUND_UP(mul, 64);

drivers/pwm/pwm-img.c

119

timebase = DIV_ROUND_UP(mul, 512);

drivers/pwm/pwm-img.c

126

duty = DIV_ROUND_UP(timebase * duty_ns, period_ns);

drivers/pwm/pwm-intel-lgm.c

101

state->duty_cycle = DIV_ROUND_UP(duty * pc->period, LGM_PWM_MAX_DUTY_CYCLE);

drivers/pwm/pwm-iqs620a.c

128

state->duty_cycle = DIV_ROUND_UP(iqs620_pwm->duty_scale *

drivers/pwm/pwm-lpc18xx-sct.c

372

lpc18xx_pwm->min_period_ns = DIV_ROUND_UP(NSEC_PER_SEC,

drivers/pwm/pwm-max7360.c

99

wf->duty_length_ns = DIV_ROUND_UP(wfhw->duty_steps * MAX7360_PWM_PERIOD_NS,

drivers/pwm/pwm-mc33xs2410.c

184

count = DIV_ROUND_UP((u32)MC33XS2410_PWM_MAX_PERIOD(step), (u32)period);

drivers/pwm/pwm-mc33xs2410.c

210

return DIV_ROUND_UP(2 * NSEC_PER_SEC, doubled_freq);

drivers/pwm/pwm-raspberrypi-poe.c

91

state->duty_cycle = DIV_ROUND_UP(rpipwm->duty_cycle * RPI_PWM_PERIOD_NS,

drivers/pwm/pwm-stm32-lp.c

115

delay_us = 3 * DIV_ROUND_UP(USEC_PER_SEC, rate);

drivers/pwm/pwm-tiehrpwm.c

227

if (set_prescale_div(DIV_ROUND_UP(period_cycles, PERIOD_MAX), &ps_divval,

drivers/pwm/pwm-twl-led.c

72

int duty_cycle = DIV_ROUND_UP(duty_ns * TWL4030_LED_MAX, period_ns) + 1;

drivers/regulator/ad5398.c

102

selector = DIV_ROUND_UP((min_uA - chip->min_uA) * chip->current_level,

drivers/regulator/core.c

3894

return DIV_ROUND_UP(abs(new_uV - old_uV), ramp_delay);

drivers/regulator/cros-ec-regulator.c

96

int min_mV = DIV_ROUND_UP(min_uV, 1000);

drivers/regulator/da903x-regulator.c

202

sel = DIV_ROUND_UP(thresh - min_uV, info->desc.uV_step);

drivers/regulator/da903x-regulator.c

205

sel = DIV_ROUND_UP(min_uV - thresh, info->desc.uV_step);

drivers/regulator/da9052-regulator.c

192

DIV_ROUND_UP(min_uV - DA9052_CONST_3uV,

drivers/regulator/da9052-regulator.c

195

sel = DIV_ROUND_UP(min_uV - info->min_uV, info->step_uV);

drivers/regulator/da9052-regulator.c

253

ret = DIV_ROUND_UP(abs(new_sel - old_sel) * info->step_uV,

drivers/regulator/helpers.c

402

ret = DIV_ROUND_UP(min_uV - rdev->desc->min_uV, rdev->desc->uV_step);

drivers/regulator/max20411-regulator.c

58

return DIV_ROUND_UP(voltage, rate);

drivers/regulator/max77826-regulator.c

214

return DIV_ROUND_UP(MAX77826_BUCK_VOLT_STEP *

drivers/regulator/max8649.c

79

return DIV_ROUND_UP(voltage, rate);

drivers/regulator/max8925-regulator.c

110

data = DIV_ROUND_UP(uV - SD1_DVM_VMIN, SD1_DVM_STEP);

drivers/regulator/max8997-regulator.c

388

i = DIV_ROUND_UP(min_vol - desc->min, desc->step);

drivers/regulator/max8997-regulator.c

523

return DIV_ROUND_UP(desc->step * (new_selector - old_selector),

drivers/regulator/max8998.c

370

return DIV_ROUND_UP(difference, (val & 0x0f) + 1);

drivers/regulator/qcom-pm8008-regulator.c

73

mV = DIV_ROUND_UP(ret, 1000);

drivers/regulator/qcom-rpmh-regulator.c

221

cmd.data = DIV_ROUND_UP(regulator_list_voltage_linear_range(rdev,

drivers/regulator/qcom_spmi-regulator.c

706

voltage_sel = DIV_ROUND_UP(uV - range->min_uV, range->step_uV);

drivers/regulator/qcom_spmi-regulator.c

829

uV = DIV_ROUND_UP(uV - range->min_uV, range->step_uV);

drivers/regulator/qcom_spmi-regulator.c

917

return DIV_ROUND_UP(diff_uV, vreg->slew_rate);

drivers/regulator/rc5t583-regulator.c

42

return DIV_ROUND_UP(curr_uV, reg_info->enable_uv_per_us);

drivers/regulator/rt6190-regulator.c

159

csel = DIV_ROUND_UP(min_uA - RT6190_OUT_MIN_UA, RT6190_OUT_STEP_UA);

drivers/regulator/s2mpa01.c

86

return DIV_ROUND_UP(abs(new_volt - old_volt), ramp_delay);

drivers/regulator/s2mps11.c

126

return DIV_ROUND_UP(abs(new_volt - old_volt), ramp_delay);

drivers/regulator/s2mps11.c

601

+ DIV_ROUND_UP(curr_uV, s2mpg10_desc->enable_ramp_rate));

drivers/regulator/s2mps11.c

627

return DIV_ROUND_UP(abs(new_uV - old_uV), ramp_rate);

drivers/regulator/s5m8767.c

263

selector = DIV_ROUND_UP(min_vol - desc->min, desc->step);

drivers/regulator/s5m8767.c

345

return DIV_ROUND_UP(rdev->desc->uV_step * (new_sel - old_sel),

drivers/regulator/tps51632-regulator.c

67

(DIV_ROUND_UP(uV - TPS51632_MIN_VOLTAGE, \

drivers/regulator/tps51632-regulator.c

89

bit = DIV_ROUND_UP(ramp_delay, 6000) - 1;

drivers/regulator/tps62360-regulator.c

270

tps->desc.ramp_delay = DIV_ROUND_UP(32000, BIT(ramp_ctrl));

drivers/regulator/tps6287x-regulator.c

136

selector = DIV_ROUND_UP(min_uV - selected_range.min, selected_range.step);

drivers/regulator/twl-regulator.c

415

int vsel = DIV_ROUND_UP(min_uV - 600000, 12500);

drivers/regulator/twl6030-regulator.c

410

vsel = DIV_ROUND_UP(min_uV - 600000, 12500);

drivers/regulator/twl6030-regulator.c

433

vsel = DIV_ROUND_UP(min_uV - 700000, 12500);

drivers/regulator/twl6030-regulator.c

454

vsel = DIV_ROUND_UP(min_uV - 1852000, 38600);

drivers/regulator/twl6030-regulator.c

462

vsel = DIV_ROUND_UP(min_uV - 2161000, 38600);

drivers/regulator/vctrl-regulator.c

136

delay = DIV_ROUND_UP(uV - next_uV, vctrl->min_slew_down_rate);

drivers/regulator/vctrl-regulator.c

137

usleep_range(delay, delay + DIV_ROUND_UP(delay, 10));

drivers/regulator/vctrl-regulator.c

202

delay = DIV_ROUND_UP(vctrl->vtable[vctrl->sel].out -

drivers/regulator/vctrl-regulator.c

205

usleep_range(delay, delay + DIV_ROUND_UP(delay, 10));

drivers/resctrl/mpam_devices.c

1328

num_words = DIV_ROUND_UP(wd, 32);

drivers/reset/reset-lpc18xx.c

168

rc->delay_us = DIV_ROUND_UP(fcclk, firc * firc);

drivers/rtc/rtc-ac100.c

197

tmp_prate = DIV_ROUND_UP(prate, ac100_clkout_prediv[j].div);

drivers/rtc/rtc-s32g.c

314

priv->rtc_hz = DIV_ROUND_UP(rtc_hz, priv->rtc_data->clk_div);

drivers/rtc/rtc-zynqmp.c

197

fract_part = DIV_ROUND_UP(tick_mult, RTC_FR_MAX_TICKS);

drivers/rtc/rtc-zynqmp.c

225

fract_part = DIV_ROUND_UP(tick_mult, RTC_FR_MAX_TICKS);

drivers/scsi/advansys.c

7515

DIV_ROUND_UP(sg_dma_len(slp), 512));

drivers/scsi/advansys.c

7617

DIV_ROUND_UP(sg_dma_len(slp), 512));

drivers/scsi/csiostor/csio_hw.c

714

i = DIV_ROUND_UP(size, sf_sec_size); /* # of sectors spanned */

drivers/scsi/csiostor/csio_lnode.c

1691

wr_len = DIV_ROUND_UP(wr_len, 16);

drivers/scsi/csiostor/csio_scsi.c

1237

int count = DIV_ROUND_UP(tmo, CSIO_SCSI_ABORT_Q_POLL_MS);

drivers/scsi/csiostor/csio_scsi.c

1277

int count = DIV_ROUND_UP(60 * 1000, CSIO_SCSI_ABORT_Q_POLL_MS);

drivers/scsi/csiostor/csio_scsi.c

1323

int count = DIV_ROUND_UP(60 * 1000, CSIO_SCSI_ABORT_Q_POLL_MS);

drivers/scsi/csiostor/csio_scsi.c

213

DIV_ROUND_UP(size, 16)));

drivers/scsi/csiostor/csio_scsi.c

2138

count = DIV_ROUND_UP((ioreq->tmo + 10) * 1000, CSIO_SCSI_TM_POLL_MS);

drivers/scsi/csiostor/csio_scsi.c

373

FW_WR_LEN16_V(DIV_ROUND_UP(size, 16)));

drivers/scsi/csiostor/csio_scsi.c

426

FW_WR_LEN16_V(DIV_ROUND_UP(size, 16)));

drivers/scsi/csiostor/csio_scsi.c

656

DIV_ROUND_UP(size, 16)));

drivers/scsi/cxgbi/cxgb4i/cxgb4i.c

1885

DIV_ROUND_UP(sizeof(struct cpl_abort_req), 16);

drivers/scsi/cxgbi/cxgb4i/cxgb4i.c

1986

req->len16 = htonl(DIV_ROUND_UP(wr_len - sizeof(req->wr), 16));

drivers/scsi/cxgbi/cxgb4i/cxgb4i.c

582

return DIV_ROUND_UP(skb->len, 8);

drivers/scsi/cxgbi/cxgb4i/cxgb4i.c

600

flowclen16 = DIV_ROUND_UP(flowclen, 16);

drivers/scsi/cxgbi/cxgb4i/cxgb4i.c

698

cpl->mpdu = cpu_to_be16(DIV_ROUND_UP(info->mpdu, 4));

drivers/scsi/cxgbi/cxgb4i/cxgb4i.c

794

credits_needed = DIV_ROUND_UP(dlen + iso_cpl_len, 16);

drivers/scsi/cxgbi/cxgb4i/cxgb4i.c

797

DIV_ROUND_UP((8 * calc_tx_flits_ofld(skb)) +

drivers/scsi/cxgbi/cxgb4i/cxgb4i.c

802

DIV_ROUND_UP(sizeof(struct fw_ofld_tx_data_wr), 16);

drivers/scsi/esp_scsi.c

1512

stp = DIV_ROUND_UP(period << 2, one_clock);

drivers/scsi/fnic/vnic_rq.h

67

DIV_ROUND_UP(entries, VNIC_RQ_BUF_BLK_ENTRIES)

drivers/scsi/fnic/vnic_wq.h

72

DIV_ROUND_UP(entries, VNIC_WQ_BUF_BLK_ENTRIES)

drivers/scsi/libfc/fc_exch.c

491

sp->cnt += DIV_ROUND_UP((fr_len(fp) - sizeof(*fh)),

drivers/scsi/megaraid/megaraid_sas_fusion.c

837

dma_alloc_count = DIV_ROUND_UP(msix_count, RDPQ_MAX_INDEX_IN_ONE_CHUNK);

drivers/scsi/mpi3mr/mpi3mr_fw.c

2120

op_reply_q->num_segments = DIV_ROUND_UP(op_reply_q->num_replies,

drivers/scsi/mpi3mr/mpi3mr_fw.c

2178

op_req_q->num_segments = DIV_ROUND_UP(op_req_q->num_requests,

drivers/scsi/mpt3sas/mpt3sas_base.c

5840

dma_alloc_count = DIV_ROUND_UP(count,

drivers/scsi/mpt3sas/mpt3sas_base.c

6231

dma_alloc_count = DIV_ROUND_UP(count,

drivers/scsi/mpt3sas/mpt3sas_base.c

6475

DIV_ROUND_UP(ioc->reply_queue_count, RDPQ_MAX_INDEX_IN_ONE_CHUNK));

drivers/scsi/pm8001/pm8001_ctl.c

746

loopcount = DIV_ROUND_UP(partitionSize + HEADER_LEN,

drivers/scsi/pmcraid.c

3143

ioadl_count = DIV_ROUND_UP(le16_to_cpu(ioarcb->add_cmd_param_length), 16);

drivers/scsi/qla2xxx/qla_target.c

2399

prm->req_cnt += DIV_ROUND_UP(prm->seg_cnt -

drivers/scsi/qla2xxx/qla_target.c

2406

prm->seg_cnt = DIV_ROUND_UP(cmd->bufflen, cmd->blk_sz);

drivers/scsi/qla2xxx/qla_target.c

2422

prm->prot_seg_cnt = DIV_ROUND_UP(cmd->bufflen,

drivers/scsi/smartpqi/smartpqi_init.c

2929

index = DIV_ROUND_UP(rmd->map_index + 1, rmd->total_disks_per_row);

drivers/scsi/smartpqi/smartpqi_init.c

4533

DIV_ROUND_UP(iu_length,

drivers/scsi/smartpqi/smartpqi_init.c

8977

sg_count = DIV_ROUND_UP(total_size, chunk_size);

drivers/scsi/smartpqi/smartpqi_init.c

9028

min_chunk_size = DIV_ROUND_UP(total_required_size, PQI_HOST_MAX_SG_DESCRIPTORS);

drivers/scsi/snic/vnic_wq.h

55

DIV_ROUND_UP(entries, VNIC_WQ_BUF_DFLT_BLK_ENTRIES)

drivers/scsi/snic/vnic_wq.h

57

DIV_ROUND_UP(entries, VNIC_WQ_BUF_DFLT_BLK_ENTRIES)

drivers/scsi/st.c

648

DIV_ROUND_UP(bytes, PAGE_SIZE << mdata->page_order);

drivers/siox/siox-core.c

702

smaster->poll_interval = DIV_ROUND_UP(HZ, 40);

drivers/soc/fsl/qe/tsa.c

498

nb = DIV_ROUND_UP(count, 8);

drivers/soc/fsl/qe/tsa.c

555

nb = DIV_ROUND_UP(count, 8);

drivers/soc/mediatek/mtk-svs.c

555

return DIV_ROUND_UP(numerator * 100, denominator);

drivers/soc/mediatek/mtk-svs.c

934

return DIV_ROUND_UP(vx, 100);

drivers/soc/qcom/qcom-geni-se.c

732

divider = DIV_ROUND_UP(tbl[i], req_freq);

drivers/soc/qcom/spm.c

454

drv->volt_sel = DIV_ROUND_UP(drv->reg_data->init_uV - rdesc->min_uV,

drivers/soc/tegra/pmc.c

1716

value = DIV_ROUND_UP(1000000000, rate);

drivers/soc/tegra/pmc.c

1717

value = DIV_ROUND_UP(200, value);

drivers/soc/tegra/pmc.c

3492

osc = DIV_ROUND_UP(pmc->core_osc_time * 8192, 1000000);

drivers/soc/tegra/pmc.c

3493

pmu = DIV_ROUND_UP(pmc->core_pmu_time * 32768, 1000000);

drivers/soc/tegra/pmc.c

3494

off = DIV_ROUND_UP(pmc->core_off_time * 32768, 1000000);

drivers/soundwire/cadence_master.c

2165

*num_frames = DIV_ROUND_UP(data_bytes, actual_bpt_bytes);

drivers/soundwire/intel_ace2x.c

207

fake_num_frames = DIV_ROUND_UP(rx_pad, pdi1_buf_size_pre_frame);

drivers/spi/atmel-quadspi.c

1184

scbr = DIV_ROUND_UP(src_rate, spi->max_speed_hz);

drivers/spi/atmel-quadspi.c

1228

cs_hold = DIV_ROUND_UP((delay * DIV_ROUND_UP(clk_rate, 1000000)), 32000);

drivers/spi/atmel-quadspi.c

1236

cs_setup = DIV_ROUND_UP((delay * DIV_ROUND_UP(clk_rate, 1000000)),

drivers/spi/atmel-quadspi.c

1243

cs_inactive = DIV_ROUND_UP((delay * DIV_ROUND_UP(clk_rate, 1000000)), 1000);

drivers/spi/spi-altera-core.c

151

hw->bytes_per_word = DIV_ROUND_UP(t->bits_per_word, 8);

drivers/spi/spi-amlogic-spisg.c

420

FIELD_PREP(CFG_BLOCK_NUM, DIV_ROUND_UP(n_sclk, 8));

drivers/spi/spi-apple.c

201

cr = DIV_ROUND_UP(clk_get_rate(spi->clk), t->speed_hz);

drivers/spi/spi-ar934x.c

53

int div = DIV_ROUND_UP(sp->clk_freq, freq * 2) - 1;

drivers/spi/spi-armada-3700.c

223

prescale = DIV_ROUND_UP(clk_get_rate(a3700_spi->clk), speed_hz);

drivers/spi/spi-armada-3700.c

230

prescale = A3700_SPI_CLK_EVEN_OFFS + DIV_ROUND_UP(prescale, 2);

drivers/spi/spi-armada-3700.c

874

host->min_speed_hz = DIV_ROUND_UP(clk_get_rate(spi->clk),

drivers/spi/spi-at91-usart.c

316

DIV_ROUND_UP(aus->spi_clk, xfer->speed_hz));

drivers/spi/spi-at91-usart.c

518

controller->max_speed_hz = DIV_ROUND_UP(clk_get_rate(clk),

drivers/spi/spi-at91-usart.c

520

controller->min_speed_hz = DIV_ROUND_UP(clk_get_rate(clk),

drivers/spi/spi-ath79.c

208

rate = DIV_ROUND_UP(clk_get_rate(sp->clk), MHZ);

drivers/spi/spi-atmel.c

886

scbr = DIV_ROUND_UP(bus_hz, xfer->speed_hz);

drivers/spi/spi-axi-spi-engine.c

317

clk_div = DIV_ROUND_UP(max_hz, xfer->speed_hz);

drivers/spi/spi-axi-spi-engine.c

384

inst_ns = DIV_ROUND_UP(NSEC_PER_SEC, host->max_speed_hz);

drivers/spi/spi-bcm2835.c

1069

cdiv = DIV_ROUND_UP(bs->clk_hz, spi_hz);

drivers/spi/spi-bcm2835aux.c

363

speed = DIV_ROUND_UP(clk_hz, 2 * spi_hz) - 1;

drivers/spi/spi-bcm63xx-hsspi.c

472

reg = DIV_ROUND_UP(2048, DIV_ROUND_UP(bs->speed_hz, hz));

drivers/spi/spi-bcmbca-hsspi.c

199

reg = DIV_ROUND_UP(2048, DIV_ROUND_UP(bs->speed_hz, hz));

drivers/spi/spi-cadence-quadspi.c

1213

ticks = DIV_ROUND_UP(ticks * ns_val, 1000000);

drivers/spi/spi-cadence-quadspi.c

1228

tsclk = DIV_ROUND_UP(ref_clk_hz, cqspi->sclk);

drivers/spi/spi-cadence-quadspi.c

1257

div = DIV_ROUND_UP(ref_clk_hz, 2 * cqspi->sclk) - 1;

drivers/spi/spi-cadence-quadspi.c

1922

cqspi->wr_delay = 50 * DIV_ROUND_UP(NSEC_PER_SEC,

drivers/spi/spi-cadence.c

530

xspi->tx_bytes = DIV_ROUND_UP(xspi->tx_bytes, xspi->n_bytes);

drivers/spi/spi-cadence.c

531

xspi->rx_bytes = DIV_ROUND_UP(xspi->rx_bytes, xspi->n_bytes);

drivers/spi/spi-davinci.c

307

ret = DIV_ROUND_UP(clk_get_rate(dspi->clk), max_speed_hz) - 1;

drivers/spi/spi-davinci.c

725

timeout = DIV_ROUND_UP(t->speed_hz, MSEC_PER_SEC);

drivers/spi/spi-davinci.c

726

timeout = DIV_ROUND_UP(t->len * 8, timeout);

drivers/spi/spi-dw-core.c

343

clk_div = (DIV_ROUND_UP(dws->max_freq, cfg->freq) + 1) & 0xfffe;

drivers/spi/spi-dw-core.c

644

us = DIV_ROUND_UP(ns, NSEC_PER_USEC);

drivers/spi/spi-dw-dma.c

394

us = DIV_ROUND_UP(ns, NSEC_PER_USEC);

drivers/spi/spi-ep93xx.c

321

nents = DIV_ROUND_UP(len, PAGE_SIZE);

drivers/spi/spi-fsl-dspi.c

1002

dspi->oper_word_size = DIV_ROUND_UP(dspi->oper_bits_per_word, 8);

drivers/spi/spi-fsl-dspi.c

1039

dspi->progress += num_bytes / DIV_ROUND_UP(xfer->bits_per_word, 8);

drivers/spi/spi-fsl-dspi.c

1278

u32 period_ns = DIV_ROUND_UP(NSEC_PER_SEC, spi->max_speed_hz);

drivers/spi/spi-fsl-dspi.c

1280

u32 quarter_period_ns = DIV_ROUND_UP(period_ns, 4);

drivers/spi/spi-fsl-dspi.c

979

if (dspi->len >= DIV_ROUND_UP(dspi->oper_bits_per_word, 8))

drivers/spi/spi-fsl-espi.c

337

pm = DIV_ROUND_UP(espi->spibrg, hz * 4) - 1;

drivers/spi/spi-fsl-espi.c

341

pm = DIV_ROUND_UP(espi->spibrg, hz * 16 * 4) - 1;

drivers/spi/spi-fsl-espi.c

697

host->min_speed_hz = DIV_ROUND_UP(espi->spibrg, 4 * 16 * 16);

drivers/spi/spi-fsl-espi.c

698

host->max_speed_hz = DIV_ROUND_UP(espi->spibrg, 4);

drivers/spi/spi-fsl-lpspi.c

201

return DIV_ROUND_UP(bpw, BITS_PER_BYTE);

drivers/spi/spi-fsl-lpspi.c

354

div = DIV_ROUND_UP(perclk_rate, config.speed_hz);

drivers/spi/spi-geni-qcom.c

135

*clk_div = DIV_ROUND_UP(sclk_freq, mas->oversampling * speed_hz);

drivers/spi/spi-geni-qcom.c

695

return roundup_pow_of_two(DIV_ROUND_UP(mas->cur_bits_per_word,

drivers/spi/spi-geni-qcom.c

760

for (i = 0; i < DIV_ROUND_UP(rx_bytes, bytes_per_fifo_word); i++)

drivers/spi/spi-hisi-kunpeng.c

296

chip->clk_div = DIV_ROUND_UP(host->max_speed_hz, speed_hz) + 1;

drivers/spi/spi-hisi-kunpeng.c

498

host->min_speed_hz = DIV_ROUND_UP(host->max_speed_hz, CLK_DIV_MAX);

drivers/spi/spi-hisi-sfc-v3xx.c

224

for (i = 0; i < DIV_ROUND_UP(len, 4); i++, from += 4) {

drivers/spi/spi-hisi-sfc-v3xx.c

261

for (i = 0; i < DIV_ROUND_UP(len, 4); i++, to += 4) {

drivers/spi/spi-img-spfi.c

450

div = DIV_ROUND_UP(clk_get_rate(spfi->spfi_clk), xfer->speed_hz);

drivers/spi/spi-imx.c

1276

spi_imx->txfifo >= DIV_ROUND_UP(spi_imx->remainder, 4))

drivers/spi/spi-imx.c

1501

for (int i = 0; i < DIV_ROUND_UP(dma_data->dma_len, sizeof(*temp)); i++) {

drivers/spi/spi-imx.c

1619

for (int i = 0; i < DIV_ROUND_UP(dma_data->dma_len, sizeof(*temp)); i++) {

drivers/spi/spi-imx.c

2120

words = DIV_ROUND_UP(transfer->len * BITS_PER_BYTE, transfer->bits_per_word);

drivers/spi/spi-imx.c

539

pre = DIV_ROUND_UP(fin, fspi << post) - 1;

drivers/spi/spi-ljca.c

197

u8 div = DIV_ROUND_UP(controller->max_speed_hz, xfer->speed_hz) / 2 - 1;

drivers/spi/spi-meson-spicc.c

327

dma_burst_count = DIV_ROUND_UP(len, dma_burst_len);

drivers/spi/spi-meson-spicc.c

592

DIV_ROUND_UP(spicc->xfer->bits_per_word, 8);

drivers/spi/spi-meson-spicc.c

630

spicc->xfer_remain = DIV_ROUND_UP(xfer->len, spicc->bytes_per_word);

drivers/spi/spi-microchip-core-qspi.c

359

baud_rate_val = DIV_ROUND_UP(clk_hz, 2 * max_freq);

drivers/spi/spi-microchip-core-spi.c

242

clk_div = DIV_ROUND_UP(pclk_hz, 2 * target_hz) - 1;

drivers/spi/spi-mpfs.c

461

clk_gen = DIV_ROUND_UP(clk_hz, 2 * spi_hz) - 1;

drivers/spi/spi-mpfs.c

463

clk_gen = DIV_ROUND_UP(clk_hz, spi_hz);

drivers/spi/spi-mpfs.c

497

spi->n_bytes = roundup_pow_of_two(DIV_ROUND_UP(xfer->bits_per_word, BITS_PER_BYTE));

drivers/spi/spi-mpfs.c

506

int fifo_max = DIV_ROUND_UP(min(spi->tx_len, FIFO_DEPTH), spi->n_bytes);

drivers/spi/spi-mt65xx.c

311

setup = (delay * DIV_ROUND_UP(mdata->spi_clk_hz, 1000000)) / 1000;

drivers/spi/spi-mt65xx.c

316

hold = (delay * DIV_ROUND_UP(mdata->spi_clk_hz, 1000000)) / 1000;

drivers/spi/spi-mt65xx.c

321

inactive = (delay * DIV_ROUND_UP(mdata->spi_clk_hz, 1000000)) / 1000;

drivers/spi/spi-mt65xx.c

513

div = DIV_ROUND_UP(mdata->spi_clk_hz, speed_hz);

drivers/spi/spi-mt7621.c

113

rate = DIV_ROUND_UP(rs->sys_freq, speed);

drivers/spi/spi-mtk-nor.c

100

#define CLK_TO_US(sp, clkcnt) DIV_ROUND_UP(clkcnt, sp->spi_freq / 1000000)

drivers/spi/spi-mxs.c

172

const int sgs = DIV_ROUND_UP(len, desc_len);

drivers/spi/spi-npcm-fiu.c

381

for (i = 0; i < DIV_ROUND_UP(data_size, 4); i++)

drivers/spi/spi-npcm-fiu.c

411

for (i = 0; i < DIV_ROUND_UP(data_size, 4); i++)

drivers/spi/spi-npcm-pspi.c

401

host->max_speed_hz = DIV_ROUND_UP(clk_hz, NPCM_PSPI_MIN_CLK_DIVIDER);

drivers/spi/spi-npcm-pspi.c

402

host->min_speed_hz = DIV_ROUND_UP(clk_hz, NPCM_PSPI_MAX_CLK_DIVIDER);

drivers/spi/spi-oc-tiny.c

63

return min(DIV_ROUND_UP(hw->freq, hz * 2), (1U << hw->baudwidth)) - 1;

drivers/spi/spi-orion.c

161

unsigned divider = DIV_ROUND_UP(tclk_hz, speed);

drivers/spi/spi-orion.c

211

rate = DIV_ROUND_UP(tclk_hz, speed);

drivers/spi/spi-orion.c

718

DIV_ROUND_UP(tclk_hz, devdata->min_divisor));

drivers/spi/spi-orion.c

721

DIV_ROUND_UP(tclk_hz, devdata->min_divisor);

drivers/spi/spi-orion.c

724

host->min_speed_hz = DIV_ROUND_UP(tclk_hz, devdata->max_divisor);

drivers/spi/spi-pic32.c

418

pic32s->fifo_n_elm = DIV_ROUND_UP(pic32s->fifo_n_byte,

drivers/spi/spi-pl022.c

910

pages = DIV_ROUND_UP(pl022->cur_transfer->len, PAGE_SIZE);

drivers/spi/spi-pxa2xx.c

1367

DIV_ROUND_UP(controller->max_speed_hz, 4096);

drivers/spi/spi-pxa2xx.c

1370

DIV_ROUND_UP(controller->max_speed_hz, 512);

drivers/spi/spi-pxa2xx.c

818

q1 = DIV_ROUND_UP(fref1, rate);

drivers/spi/spi-pxa2xx.c

843

q2 = DIV_ROUND_UP(fref2, rate);

drivers/spi/spi-pxa2xx.c

868

q1 = DIV_ROUND_UP(fref, rate);

drivers/spi/spi-pxa2xx.c

900

return (DIV_ROUND_UP(ssp_clk, 2 * rate) - 1) & 0xff;

drivers/spi/spi-pxa2xx.c

902

return (DIV_ROUND_UP(ssp_clk, rate) - 1) & 0xfff;

drivers/spi/spi-qup.c

291

remainder = DIV_ROUND_UP(spi_qup_len(controller) - controller->rx_bytes,

drivers/spi/spi-qup.c

377

remainder = DIV_ROUND_UP(spi_qup_len(controller) - controller->tx_bytes,

drivers/spi/spi-qup.c

613

remainder_tx = DIV_ROUND_UP(spi_qup_len(controller) -

drivers/spi/spi-qup.c

616

remainder_rx = DIV_ROUND_UP(spi_qup_len(controller) -

drivers/spi/spi-qup.c

708

controller->w_size = DIV_ROUND_UP(xfer->bits_per_word, 8);

drivers/spi/spi-qup.c

884

timeout = DIV_ROUND_UP(xfer->speed_hz, MSEC_PER_SEC);

drivers/spi/spi-qup.c

885

timeout = DIV_ROUND_UP(min_t(unsigned long, SPI_MAX_XFER,

drivers/spi/spi-qup.c

938

n_words = xfer->len / DIV_ROUND_UP(xfer->bits_per_word, 8);

drivers/spi/spi-rockchip.c

611

writel_relaxed(2 * DIV_ROUND_UP(rs->freq, 2 * xfer->speed_hz),

drivers/spi/spi-rspi.c

1338

ctlr->min_speed_hz = DIV_ROUND_UP(clksrc, ops->max_div);

drivers/spi/spi-rspi.c

1339

ctlr->max_speed_hz = DIV_ROUND_UP(clksrc, ops->min_div);

drivers/spi/spi-rspi.c

259

spbr = DIV_ROUND_UP(clksrc, 2 * rspi->speed_hz) - 1;

drivers/spi/spi-rspi.c

262

spbr = DIV_ROUND_UP(spbr + 1, 2) - 1;

drivers/spi/spi-rspi.c

267

rspi->speed_hz = DIV_ROUND_UP(clksrc, (2U << brdv) * (spbr + 1));

drivers/spi/spi-rspi.c

352

spbr = DIV_ROUND_UP(clksrc, 2 * rspi->speed_hz);

drivers/spi/spi-rspi.c

355

spbr = DIV_ROUND_UP(spbr, 2);

drivers/spi/spi-rspi.c

358

rspi->speed_hz = DIV_ROUND_UP(clksrc, (2U << brdv) * spbr);

drivers/spi/spi-rzv2h-rspi.c

411

return DIV_ROUND_UP(tclk_rate, (2 * (spr + 1) * (1 << brdv)));

drivers/spi/spi-rzv2h-rspi.c

534

spr = DIV_ROUND_UP(clk_rate, hz * (1 << (brdv + 1)));

drivers/spi/spi-rzv2m-csi.c

373

cks = DIV_ROUND_UP(csiclk_rate, spi_hz << 1);

drivers/spi/spi-sh-msiof.c

1274

ctlr->min_speed_hz = DIV_ROUND_UP(clksrc, 1024);

drivers/spi/spi-sh-msiof.c

1275

ctlr->max_speed_hz = DIV_ROUND_UP(clksrc, 1 << p->min_div_pow);

drivers/spi/spi-sh-msiof.c

145

div = DIV_ROUND_UP(parent_rate, spi_hz);

drivers/spi/spi-sifive.c

174

cr = DIV_ROUND_UP(clk_get_rate(spi->clk) >> 1, t->speed_hz) - 1;

drivers/spi/spi-sn-f-ospi.c

194

u32 div = DIV_ROUND_UP(rate_hz, device_hz);

drivers/spi/spi-sprd.c

180

u32 bit_time_us = DIV_ROUND_UP(USEC_PER_SEC, ss->hw_speed_hz);

drivers/spi/spi-sprd.c

187

u32 interval_time_us = DIV_ROUND_UP(interval_cycle * USEC_PER_SEC,

drivers/spi/spi-sprd.c

657

u32 clk_div = DIV_ROUND_UP(ss->src_clk, speed_hz << 1) - 1;

drivers/spi/spi-sprd.c

687

interval = DIV_ROUND_UP(word_delay - 10, 4);

drivers/spi/spi-stm32-ospi.c

764

ospi->flash_presc[cs] = DIV_ROUND_UP(ospi->clk_rate, spi->max_speed_hz) - 1;

drivers/spi/spi-stm32-qspi.c

669

presc = DIV_ROUND_UP(qspi->clk_rate, spi->max_speed_hz) - 1;

drivers/spi/spi-stm32.c

1553

nents += DIV_ROUND_UP(sg_dma_len(spi_s), sram_period);

drivers/spi/spi-stm32.c

1966

u32 sck_period_ns = DIV_ROUND_UP(NSEC_PER_SEC, spi->cur_speed);

drivers/spi/spi-stm32.c

1967

u32 midi = DIV_ROUND_UP(spi->cur_midi, sck_period_ns);

drivers/spi/spi-stm32.c

2059

nb_words = DIV_ROUND_UP(transfer->len * 8, 16);

drivers/spi/spi-stm32.c

2061

nb_words = DIV_ROUND_UP(transfer->len * 8, 32);

drivers/spi/spi-stm32.c

2099

DIV_ROUND_UP(8 * USEC_PER_SEC, polling_limit_us) : 0;

drivers/spi/spi-stm32.c

607

bpw = DIV_ROUND_UP(spi->cur_bpw, 8);

drivers/spi/spi-stm32.c

608

return DIV_ROUND_UP(packet, bpw);

drivers/spi/spi-sun6i.c

395

div_cdr1 = DIV_ROUND_UP(mclk_rate, tfr->speed_hz);

drivers/spi/spi-sun6i.c

396

div_cdr2 = DIV_ROUND_UP(div_cdr1, 2);

drivers/spi/spi-synquacer.c

268

div = DIV_ROUND_UP(rate, speed);

drivers/spi/spi-tegra114.c

267

tspi->bytes_per_word = DIV_ROUND_UP(bits_per_word, 8);

drivers/spi/spi-tegra114.c

310

max_n_32bit = DIV_ROUND_UP(nbytes, 4);

drivers/spi/spi-tegra114.c

547

len = DIV_ROUND_UP(tspi->curr_dma_words * tspi->bytes_per_word,

drivers/spi/spi-tegra20-sflash.c

164

tsd->bytes_per_word = DIV_ROUND_UP(t->bits_per_word, 8);

drivers/spi/spi-tegra20-slink.c

264

tspi->bytes_per_word = DIV_ROUND_UP(bits_per_word, 8);

drivers/spi/spi-tegra20-slink.c

307

max_n_32bit = DIV_ROUND_UP(nbytes, 4);

drivers/spi/spi-tegra20-slink.c

489

len = DIV_ROUND_UP(tspi->curr_dma_words * tspi->bytes_per_word,

drivers/spi/spi-tegra210-quad.c

282

tqspi->bytes_per_word = DIV_ROUND_UP(bits_per_word, 8);

drivers/spi/spi-tegra210-quad.c

329

max_n_32bit = DIV_ROUND_UP(len, 4);

drivers/spi/spi-tegra210-quad.c

574

len = DIV_ROUND_UP(tqspi->curr_dma_words * tqspi->bytes_per_word, 4) * 4;

drivers/spi/spi-tegra210-quad.c

597

len = DIV_ROUND_UP(tqspi->curr_dma_words * tqspi->bytes_per_word, 4) * 4;

drivers/spi/spi-tegra210-quad.c

626

len = DIV_ROUND_UP(tqspi->curr_dma_words * tqspi->bytes_per_word, 4) * 4;

drivers/spi/spi-ti-qspi.c

177

clk_div = DIV_ROUND_UP(clk_rate, speed_hz) - 1;

drivers/spi/spi-uniphier.c

208

ckdiv = DIV_ROUND_UP(clk_get_rate(priv->clk), speed);

drivers/spi/spi-uniphier.c

322

fifo_threshold = DIV_ROUND_UP(priv->rx_bytes, bpw);

drivers/spi/spi-uniphier.c

328

DIV_ROUND_UP(priv->rx_bytes - priv->tx_bytes, bpw);

drivers/spi/spi-uniphier.c

361

return DIV_ROUND_UP(t->len, bpw) > SSI_FIFO_DEPTH;

drivers/spi/spi-uniphier.c

548

threshold = DIV_ROUND_UP(SSI_POLL_TIMEOUT_US * priv->speed_hz,

drivers/spi/spi-uniphier.c

697

host->max_speed_hz = DIV_ROUND_UP(clk_rate, SSI_MIN_CLK_DIVIDER);

drivers/spi/spi-uniphier.c

698

host->min_speed_hz = DIV_ROUND_UP(clk_rate, SSI_MAX_CLK_DIVIDER);

drivers/spi/spi-xcomm.c

122

divider = DIV_ROUND_UP(SPI_XCOMM_CLOCK, t->speed_hz);

drivers/spi/spi-xlp.c

146

fdiv = DIV_ROUND_UP(xspi->spi_clk, spi->max_speed_hz);

drivers/spi/spi.c

1139

sgs = DIV_ROUND_UP(len + offset_in_page(buf), desc_len);

drivers/spi/spi.c

1142

sgs = DIV_ROUND_UP(len, desc_len);

drivers/spi/spi.c

1486

u32 us = DIV_ROUND_UP(ns, NSEC_PER_USEC);

drivers/spi/spi.c

1521

delay *= DIV_ROUND_UP(NSEC_PER_SEC, hz);

drivers/spi/spi.c

2340

delay->value = DIV_ROUND_UP(value, 1000);

drivers/spi/spi.c

3810

count = DIV_ROUND_UP(xfer->len, maxsize);

drivers/ssb/driver_chipcommon.c

443

tmp = DIV_ROUND_UP(10, ns) << SSB_PROG_WCNT_3_SHIFT; /* Waitcount-3 = 10ns */

drivers/ssb/driver_chipcommon.c

444

tmp |= DIV_ROUND_UP(40, ns) << SSB_PROG_WCNT_1_SHIFT; /* Waitcount-1 = 40ns */

drivers/ssb/driver_chipcommon.c

445

tmp |= DIV_ROUND_UP(240, ns); /* Waitcount-0 = 240ns */

drivers/ssb/driver_chipcommon.c

449

tmp = DIV_ROUND_UP(10, ns) << SSB_FLASH_WCNT_3_SHIFT; /* Waitcount-3 = 10nS */

drivers/ssb/driver_chipcommon.c

450

tmp |= DIV_ROUND_UP(10, ns) << SSB_FLASH_WCNT_1_SHIFT; /* Waitcount-1 = 10nS */

drivers/ssb/driver_chipcommon.c

451

tmp |= DIV_ROUND_UP(120, ns); /* Waitcount-0 = 120nS */

drivers/ssb/driver_chipcommon.c

462

tmp = DIV_ROUND_UP(10, ns) << SSB_PROG_WCNT_3_SHIFT; /* Waitcount-3 = 10ns */

drivers/ssb/driver_chipcommon.c

463

tmp |= DIV_ROUND_UP(20, ns) << SSB_PROG_WCNT_2_SHIFT; /* Waitcount-2 = 20ns */

drivers/ssb/driver_chipcommon.c

464

tmp |= DIV_ROUND_UP(100, ns) << SSB_PROG_WCNT_1_SHIFT; /* Waitcount-1 = 100ns */

drivers/ssb/driver_chipcommon.c

465

tmp |= DIV_ROUND_UP(120, ns); /* Waitcount-0 = 120ns */

drivers/ssb/driver_extif.c

100

tmp = DIV_ROUND_UP(10, ns) << SSB_PROG_WCNT_3_SHIFT;

drivers/ssb/driver_extif.c

101

tmp |= DIV_ROUND_UP(20, ns) << SSB_PROG_WCNT_2_SHIFT;

drivers/ssb/driver_extif.c

102

tmp |= DIV_ROUND_UP(100, ns) << SSB_PROG_WCNT_1_SHIFT;

drivers/ssb/driver_extif.c

103

tmp |= DIV_ROUND_UP(120, ns);

drivers/ssb/driver_extif.c

94

tmp = DIV_ROUND_UP(10, ns) << SSB_PROG_WCNT_3_SHIFT;

drivers/ssb/driver_extif.c

95

tmp |= DIV_ROUND_UP(40, ns) << SSB_PROG_WCNT_1_SHIFT;

drivers/ssb/driver_extif.c

96

tmp |= DIV_ROUND_UP(120, ns);

drivers/staging/fbtft/fb_sh1106.c

117

page_end = DIV_ROUND_UP(offset + len, 8 * 2 * xres);

drivers/staging/greybus/fw-download.c

205

req_count = DIV_ROUND_UP(fw_req->fw->size, MIN_FETCH_SIZE);

drivers/staging/media/atomisp/pci/atomisp_cmd.c

4407

DIV_ROUND_UP(main_compose.width * f->fmt.pix.height,

drivers/staging/media/atomisp/pci/atomisp_cmd.c

4412

DIV_ROUND_UP(main_compose.height *

drivers/staging/media/atomisp/pci/atomisp_cmd.c

542

unsigned int size32 = DIV_ROUND_UP(size, sizeof(u32));

drivers/staging/media/atomisp/pci/isp/kernels/dpc2/ia_css_dpc2_param.h

24

#define DPC2_STATE_INPUT_BUFFER_WIDTH DIV_ROUND_UP(MAX_FRAME_SIMDWIDTH, 2)

drivers/staging/media/atomisp/pci/isp/kernels/dpc2/ia_css_dpc2_param.h

29

#define DPC2_STATE_LOCAL_DEVIATION_BUFFER_WIDTH DIV_ROUND_UP(MAX_FRAME_SIMDWIDTH, 2)

drivers/staging/media/atomisp/pci/isp/kernels/dvs/dvs_1.0/ia_css_dvs.host.c

144

bottom_y = DIV_ROUND_UP(ymax, BIT(DVS_COORD_FRAC_BITS));

drivers/staging/media/atomisp/pci/isp/kernels/dvs/dvs_1.0/ia_css_dvs.host.c

147

bottom_x = DIV_ROUND_UP(xmax, BIT(DVS_COORD_FRAC_BITS));

drivers/staging/media/atomisp/pci/isp/kernels/eed1_8/ia_css_eed1_8_param.h

40

#define EED1_8_STATE_INPUT_BUFFER_WIDTH DIV_ROUND_UP(MAX_FRAME_SIMDWIDTH, 2)

drivers/staging/media/atomisp/pci/isp/kernels/eed1_8/ia_css_eed1_8_param.h

44

#define EED1_8_STATE_LD_H_WIDTH DIV_ROUND_UP(MAX_FRAME_SIMDWIDTH, 2)

drivers/staging/media/atomisp/pci/isp/kernels/eed1_8/ia_css_eed1_8_param.h

48

#define EED1_8_STATE_LD_V_WIDTH DIV_ROUND_UP(MAX_FRAME_SIMDWIDTH, 2)

drivers/staging/media/atomisp/pci/isp/kernels/eed1_8/ia_css_eed1_8_param.h

52

#define EED1_8_STATE_D_HR_WIDTH DIV_ROUND_UP(MAX_FRAME_SIMDWIDTH, 2)

drivers/staging/media/atomisp/pci/isp/kernels/eed1_8/ia_css_eed1_8_param.h

56

#define EED1_8_STATE_D_HB_WIDTH DIV_ROUND_UP(MAX_FRAME_SIMDWIDTH, 2)

drivers/staging/media/atomisp/pci/isp/kernels/eed1_8/ia_css_eed1_8_param.h

60

#define EED1_8_STATE_D_VR_WIDTH DIV_ROUND_UP(MAX_FRAME_SIMDWIDTH, 2)

drivers/staging/media/atomisp/pci/isp/kernels/eed1_8/ia_css_eed1_8_param.h

64

#define EED1_8_STATE_D_VB_WIDTH DIV_ROUND_UP(MAX_FRAME_SIMDWIDTH, 2)

drivers/staging/media/atomisp/pci/isp/kernels/eed1_8/ia_css_eed1_8_param.h

68

#define EED1_8_STATE_RB_ZIPPED_WIDTH DIV_ROUND_UP(MAX_FRAME_SIMDWIDTH, 2)

drivers/staging/media/atomisp/pci/isp/kernels/eed1_8/ia_css_eed1_8_param.h

77

#define EED1_8_STATE_CG_WIDTH DIV_ROUND_UP(MAX_FRAME_SIMDWIDTH, 2)

drivers/staging/media/atomisp/pci/isp/kernels/eed1_8/ia_css_eed1_8_param.h

81

#define EED1_8_STATE_CO_WIDTH DIV_ROUND_UP(MAX_FRAME_SIMDWIDTH, 2)

drivers/staging/media/atomisp/pci/isp/kernels/fpn/fpn_1.0/ia_css_fpn.host.c

76

my_info.res.width = DIV_ROUND_UP(info->res.width, 2); /* Packed by 2x */

drivers/staging/media/atomisp/pci/isp/kernels/fpn/fpn_1.0/ia_css_fpn.host.c

78

my_info.padded_width = DIV_ROUND_UP(info->padded_width, 2); /* Packed by 2x */

drivers/staging/media/atomisp/pci/isp/kernels/ipu2_io_ls/bayer_io_ls/ia_css_bayer_io.host.c

26

DIV_ROUND_UP(HIVE_ISP_DDR_WORD_BITS, BITS_PER_TYPE(short));

drivers/staging/media/atomisp/pci/isp/kernels/ipu2_io_ls/yuv444_io_ls/ia_css_yuv444_io.host.c

27

DIV_ROUND_UP(HIVE_ISP_DDR_WORD_BITS, BITS_PER_TYPE(short));

drivers/staging/media/atomisp/pci/isp/modes/interface/input_buf.isp.h

27

(DIV_ROUND_UP(SH_CSS_MAX_SENSOR_WIDTH, ISP_NWAY) + EXTRA_INPUT_VECTORS)

drivers/staging/media/atomisp/pci/runtime/ifmtr/src/ifmtr.c

152

num_vectors = DIV_ROUND_UP(cropped_width + left_padding, ISP_VEC_NELEMS);

drivers/staging/media/atomisp/pci/runtime/ifmtr/src/ifmtr.c

154

num_vectors = DIV_ROUND_UP(cropped_width, ISP_VEC_NELEMS);

drivers/staging/media/atomisp/pci/runtime/ifmtr/src/ifmtr.c

307

vectors_per_line = DIV_ROUND_UP(cropped_width, ISP_VEC_NELEMS);

drivers/staging/media/atomisp/pci/runtime/isys/src/virtual_isys.c

553

words_per_line = DIV_ROUND_UP(pixels_per_line_padded, pixels_per_word);

drivers/staging/media/atomisp/pci/runtime/isys/src/virtual_isys.c

811

cfg->width = DIV_ROUND_UP(cfg->stride, HIVE_ISP_DDR_WORD_BYTES);

drivers/staging/media/atomisp/pci/sh_css_defs.h

185

#define _ISP_VECS(width) DIV_ROUND_UP(width, ISP_VEC_NELEMS)

drivers/staging/media/atomisp/pci/sh_css_defs.h

197

(DIV_ROUND_UP(int_width, SH_CSS_MORPH_TABLE_GRID) + 1)

drivers/staging/media/atomisp/pci/sh_css_defs.h

199

(DIV_ROUND_UP(int_height, SH_CSS_MORPH_TABLE_GRID) + 1)

drivers/staging/media/atomisp/pci/sh_css_param_dvs.h

25

#define DVS_NUM_BLOCKS_X(X) round_up(DIV_ROUND_UP((X), DVS_BLOCKDIM_X), 2)

drivers/staging/media/atomisp/pci/sh_css_param_dvs.h

26

#define DVS_NUM_BLOCKS_X_CHROMA(X) DIV_ROUND_UP((X), DVS_BLOCKDIM_X)

drivers/staging/media/atomisp/pci/sh_css_param_dvs.h

30

#define DVS_NUM_BLOCKS_Y(X) DIV_ROUND_UP((X), DVS_BLOCKDIM_Y_LUMA)

drivers/staging/media/atomisp/pci/sh_css_param_dvs.h

31

#define DVS_NUM_BLOCKS_Y_CHROMA(X) DIV_ROUND_UP((X), DVS_BLOCKDIM_Y_CHROMA)

drivers/staging/media/ipu3/ipu3-abi.h

386

#define IMGU_VER_CNTX_WORDS DIV_ROUND_UP((IMGU_SCALER_OUT_BPP + \

drivers/staging/media/ipu3/ipu3-abi.h

389

#define IMGU_HOR_CNTX_WORDS DIV_ROUND_UP((IMGU_SCALER_INTR_BPP + \

drivers/staging/media/ipu3/ipu3-abi.h

417

(DIV_ROUND_UP(IMGU_OSYS_BLOCK_HEIGHT, IMGU_VMEM2_ELEMS_PER_VEC))

drivers/staging/media/ipu3/ipu3-css-fw.c

59

unsigned int width = DIV_ROUND_UP(bi->info.isp.sp.internal.max_width,

drivers/staging/media/ipu3/ipu3-css-fw.c

61

unsigned int height = DIV_ROUND_UP(bi->info.isp.sp.internal.max_height,

drivers/staging/media/ipu3/ipu3-css-params.c

152

target_width = DIV_ROUND_UP(target_height * input_width,

drivers/staging/media/ipu3/ipu3-css-params.c

1848

DIV_ROUND_UP(css_pipe->rect[IPU3_CSS_RECT_BDS].width, f)

drivers/staging/media/ipu3/ipu3-css-params.c

239

return DIV_ROUND_UP(stripe_offset_inp - phase_init, phase_step);

drivers/staging/media/ipu3/ipu3-css-params.c

270

stripe_width_inp = DIV_ROUND_UP(stripe_width_inp - phase_init,

drivers/staging/media/ipu3/ipu3-css-params.c

2887

unsigned int blocks_x = ALIGN(DIV_ROUND_UP(frame_out_x,

drivers/staging/media/ipu3/ipu3-css-params.c

2889

unsigned int blocks_y = DIV_ROUND_UP(frame_out_y, IMGU_DVS_BLOCK_H);

drivers/staging/media/ipu3/ipu3-css-params.c

2906

gdc_luma.in_block_width_a = DIV_ROUND_UP(gdc_luma.in_block_width,

drivers/staging/media/ipu3/ipu3-css-params.c

2908

gdc_luma.in_block_width_b = DIV_ROUND_UP(gdc_luma.in_block_width,

drivers/staging/media/ipu3/ipu3-css-params.c

2928

gdc_chroma.in_block_width_a = DIV_ROUND_UP(gdc_chroma.in_block_width,

drivers/staging/media/ipu3/ipu3-css-params.c

2930

gdc_chroma.in_block_width_b = DIV_ROUND_UP(gdc_chroma.in_block_width,

drivers/staging/media/ipu3/ipu3-css-params.c

728

stripe_input_width_uv = max(DIV_ROUND_UP(

drivers/staging/media/ipu3/ipu3-css.c

810

ALIGN(DIV_ROUND_UP(css_pipe->rect[IPU3_CSS_RECT_GDC].width,

drivers/staging/media/ipu3/ipu3-css.c

813

DIV_ROUND_UP(css_pipe->rect[IPU3_CSS_RECT_GDC].height,

drivers/staging/media/ipu3/ipu3.h

175

return DIV_ROUND_UP(width, 50) * 64;

drivers/staging/media/ipu7/ipu7-isys-video.c

190

*bytesperline = *width * DIV_ROUND_UP(pfmt->bpp, BITS_PER_BYTE);

drivers/staging/media/ipu7/ipu7-isys-video.c

192

*bytesperline = DIV_ROUND_UP(*width * pfmt->bpp, BITS_PER_BYTE);

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

146

field_size = DIV_ROUND_UP(ctx->src_fmt.width, 16) *

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

147

DIV_ROUND_UP(ctx->src_fmt.height, 16) * 16;

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

49

size_t count = DIV_ROUND_UP(len, 4);

drivers/staging/media/sunxi/cedrus/cedrus_h265.c

461

DIV_ROUND_UP(sps->pic_width_in_luma_samples, ctb_size_luma);

drivers/staging/media/sunxi/cedrus/cedrus_h265.c

471

DIV_ROUND_UP(ctx->src_fmt.width, ctb_size_luma) *

drivers/staging/media/sunxi/cedrus/cedrus_h265.c

472

DIV_ROUND_UP(ctx->src_fmt.height, ctb_size_luma) *

drivers/staging/media/sunxi/cedrus/cedrus_regs.h

124

SHIFT_AND_MASK_BITS(DIV_ROUND_UP(w, 16), 15, 8)

drivers/staging/media/sunxi/cedrus/cedrus_regs.h

126

SHIFT_AND_MASK_BITS(DIV_ROUND_UP(h, 16), 7, 0)

drivers/staging/media/sunxi/cedrus/cedrus_regs.h

657

SHIFT_AND_MASK_BITS(DIV_ROUND_UP(w, 16), 15, 8)

drivers/staging/media/sunxi/cedrus/cedrus_regs.h

659

SHIFT_AND_MASK_BITS(DIV_ROUND_UP(h, 16), 7, 0)

drivers/staging/media/sunxi/sun6i-isp/sun6i_isp_capture.c

100

DIV_ROUND_UP(width_aligned, info->hdiv) *

drivers/staging/media/sunxi/sun6i-isp/sun6i_isp_capture.c

101

DIV_ROUND_UP(height, info->vdiv);

drivers/staging/media/sunxi/sun6i-isp/sun6i_isp_capture.c

133

stride_luma_div4 = DIV_ROUND_UP(stride_luma, 4);

drivers/staging/media/sunxi/sun6i-isp/sun6i_isp_capture.c

137

stride_chroma_div4 = DIV_ROUND_UP(stride_chroma, 4);

drivers/staging/media/sunxi/sun6i-isp/sun6i_isp_capture.c

410

DIV_ROUND_UP(width_aligned, hdiv) *

drivers/staging/media/sunxi/sun6i-isp/sun6i_isp_capture.c

411

DIV_ROUND_UP(height, vdiv);

drivers/staging/most/dim2/hal.c

116

u32 const blocks = DIV_ROUND_UP(size, DBR_BLOCK_SIZE);

drivers/staging/most/dim2/hal.c

136

u32 const blocks = DIV_ROUND_UP(size, DBR_BLOCK_SIZE);

drivers/staging/most/dim2/hal.c

48

#define ROUND_UP_TO(x, d) (DIV_ROUND_UP(x, (d)) * (d))

drivers/staging/rtl8723bs/hal/rtl8723b_hal_init.c

2682

usNavUpper = DIV_ROUND_UP(usNavUpper,

drivers/target/iscsi/cxgbit/cxgbit_cm.c

1324

DIV_ROUND_UP(sizeof(struct cpl_abort_req), 16);

drivers/target/iscsi/cxgbit/cxgbit_cm.c

1403

flowclen16 = DIV_ROUND_UP(flowclen, 16);

drivers/target/iscsi/cxgbit/cxgbit_ddp.c

88

req->len16 = htonl(DIV_ROUND_UP(wr_len - sizeof(req->wr), 16));

drivers/target/iscsi/cxgbit/cxgbit_target.c

1059

sg_nents = max(1UL, DIV_ROUND_UP(skip + data_len, PAGE_SIZE));

drivers/target/iscsi/cxgbit/cxgbit_target.c

117

return DIV_ROUND_UP(skb->len, 8);

drivers/target/iscsi/cxgbit/cxgbit_target.c

147

cpl->mpdu = htons(DIV_ROUND_UP(iso_info->mpdu, 4));

drivers/target/iscsi/cxgbit/cxgbit_target.c

148

cpl->burst_size = htonl(DIV_ROUND_UP(iso_info->burst_len, 4));

drivers/target/iscsi/cxgbit/cxgbit_target.c

217

credits_needed = DIV_ROUND_UP(dlen + iso_cpl_len, 16);

drivers/target/iscsi/cxgbit/cxgbit_target.c

219

credits_needed = DIV_ROUND_UP((8 *

drivers/target/iscsi/cxgbit/cxgbit_target.c

224

credits_needed += DIV_ROUND_UP(

drivers/target/iscsi/cxgbit/cxgbit_target.c

895

u32 sg_nents = max(1UL, DIV_ROUND_UP(pdu_cb->dlen, PAGE_SIZE));

drivers/target/iscsi/iscsi_target.c

981

u32 iov_count = max(1UL, DIV_ROUND_UP(cmd->se_cmd.data_length, PAGE_SIZE));

drivers/target/iscsi/iscsi_target_auth.c

459

initiatorchg_len = DIV_ROUND_UP(strlen(initiatorchg), 2);

drivers/target/sbp/sbp_target.c

1554

STATUS_BLOCK_LEN(DIV_ROUND_UP(status_data_len, 4) + 1) |

drivers/target/target_core_user.c

513

int page_cnt = DIV_ROUND_UP(length, PAGE_SIZE);

drivers/target/target_core_user.c

584

cmd->dbi_cnt = DIV_ROUND_UP(se_cmd->data_length, blk_size);

drivers/target/target_core_user.c

590

cmd->dbi_bidi_cnt = DIV_ROUND_UP(len, blk_size);

drivers/target/target_core_user.c

729

page_cnt = DIV_ROUND_UP(data_len, PAGE_SIZE);

drivers/tee/optee/smc_abi.c

373

int pages = DIV_ROUND_UP(num_entries, PAGELIST_ENTRIES_PER_PAGE);

drivers/tee/tee_shm.c

452

} else if (DIV_ROUND_UP(len + off, PAGE_SIZE) != num_pages) {

drivers/thermal/broadcom/brcmstb_thermal.c

148

return (u32)(DIV_ROUND_UP(offset - temp, mult));

drivers/thermal/devfreq_cooling.c

114

DIV_ROUND_UP(freq, HZ_PER_KHZ));

drivers/thermal/hisi_thermal.c

109

return DIV_ROUND_UP(temp - HI6220_TEMP_BASE, HI6220_TEMP_STEP);

drivers/thermal/hisi_thermal.c

127

return DIV_ROUND_UP(temp - HI3660_TEMP_BASE, HI3660_TEMP_STEP);

drivers/thermal/hisi_thermal.c

163

writel(DIV_ROUND_UP(value, HI6220_TEMP_STEP) & 0x1F,

drivers/thermal/hisi_thermal.c

215

writel(DIV_ROUND_UP(value, HI3660_TEMP_STEP) & 0x7F,

drivers/thermal/imx_thermal.c

704

measure_freq = DIV_ROUND_UP(32768, 10); /* 10 Hz */

drivers/thermal/intel/intel_hfi.c

569

hfi_features.hdr_size = DIV_ROUND_UP(nr_capabilities, 8) * 8;

drivers/thermal/intel/intel_hfi.c

575

hfi_features.cpu_stride = DIV_ROUND_UP(nr_capabilities, 8) * 8;

drivers/thunderbolt/nhi.c

1041

u32 throttle = DIV_ROUND_UP(128 * NSEC_PER_USEC, 256);

drivers/thunderbolt/usb4.c

1357

size_t dwords = DIV_ROUND_UP(size, 4);

drivers/thunderbolt/usb4.c

1410

size_t dwords = DIV_ROUND_UP(size, 4);

drivers/thunderbolt/usb4.c

2277

return DIV_ROUND_UP(uframes, 512UL << scale);

drivers/tty/n_tty.c

1698

room = DIV_ROUND_UP(room, 3);

drivers/tty/serial/8250/8250_lpc18xx.c

53

rs485_dly_reg = DIV_ROUND_UP(rs485->delay_rts_after_send

drivers/tty/serial/8250/8250_mtk.c

368

quot = DIV_ROUND_UP(port->uartclk, 256 * baud);

drivers/tty/serial/8250/8250_port.c

1390

stop_delay = p->port.frame_time + DIV_ROUND_UP(p->port.frame_time, 7);

drivers/tty/serial/amba-pl011.c

2115

uap->dmarx.poll_rate = DIV_ROUND_UP(10000000, baud);

drivers/tty/serial/amba-pl011.c

2163

uap->rs485_tx_drain_interval = ns_to_ktime(DIV_ROUND_UP(bits * NSEC_PER_SEC, baud));

drivers/tty/serial/mvebu-uart.c

1424

d1 = DIV_ROUND_UP(rate, 9600 * OSAMP_MAX_DIVISOR *

drivers/tty/serial/mvebu-uart.c

1431

d2 = DIV_ROUND_UP(rate, 9600 * OSAMP_MAX_DIVISOR *

drivers/tty/serial/mvebu-uart.c

565

min_baud = DIV_ROUND_UP(port->uartclk, BRDV_BAUD_MAX *

drivers/tty/serial/mxs-auart.c

1030

baud_min = DIV_ROUND_UP(u->uartclk * 32,

drivers/tty/serial/qcom_geni_serial.c

1277

clk_div = DIV_ROUND_UP(clk_rate, baud * sampling_rate);

drivers/tty/serial/qcom_geni_serial.c

326

timeout_us = DIV_ROUND_UP(timeout_us, 10) * 10;

drivers/tty/serial/serial-tegra.c

278

udelay(DIV_ROUND_UP(cycles * 1000000, tup->current_baud * 16));

drivers/tty/serial/serial-tegra.c

286

udelay(DIV_ROUND_UP(syms * tup->symb_bit * 1000000,

drivers/tty/serial/serial-tegra.c

942

unsigned long char_time = DIV_ROUND_UP(10000000, tup->current_baud);

drivers/tty/serial/sh-sci.c

1989

mod_timer(&s->rx_fifo_timer, jiffies + DIV_ROUND_UP(

drivers/tty/serial/sh-sci.c

2913

udelay(DIV_ROUND_UP(10 * 1000000, baud));

drivers/tty/serial/sifive.c

436

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

drivers/tty/serial/sifive.c

624

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

drivers/tty/serial/xilinx_uartps.c

415

+ DIV_ROUND_UP(cdns_uart->port->frame_time, 7)

drivers/tty/synclink_gt.c

4777

if (DIV_ROUND_UP(size, DMABUFSIZE) > free_tbuf_count(info))

drivers/tty/vt/vt.c

4864

c = DIV_ROUND_UP(font.width, 8) * vpitch * font.charcount;

drivers/tty/vt/vt.c

4896

size = DIV_ROUND_UP(op->width, 8) * vpitch * op->charcount;

drivers/ufs/host/ufs-exynos.c

1820

DIV_ROUND_UP(NSEC_PER_SEC, ufs->mclk_rate));

drivers/ufs/host/ufs-exynos.c

1826

DIV_ROUND_UP(NSEC_PER_SEC, ufs->mclk_rate));

drivers/ufs/host/ufs-exynos.c

1832

DIV_ROUND_UP(NSEC_PER_SEC, ufs->mclk_rate));

drivers/ufs/host/ufs-exynos.c

1938

DIV_ROUND_UP(NSEC_PER_SEC, ufs->mclk_rate));

drivers/ufs/host/ufs-exynos.c

1953

DIV_ROUND_UP(NSEC_PER_SEC, ufs->mclk_rate));

drivers/ufs/host/ufs-exynos.c

273

DIV_ROUND_UP(NSEC_PER_SEC, ufs->mclk_rate));

drivers/ufs/host/ufs-exynos.c

290

DIV_ROUND_UP(NSEC_PER_SEC, ufs->mclk_rate));

drivers/ufs/host/ufs-exynos.c

997

DIV_ROUND_UP(NSEC_PER_SEC, ufs->mclk_rate));

drivers/usb/cdns3/cdns3-gadget.c

1034

tdl = DIV_ROUND_UP(length, priv_ep->endpoint.maxpacket);

drivers/usb/cdns3/cdns3-gadget.c

1223

td_size = DIV_ROUND_UP(request->length,

drivers/usb/cdns3/cdns3-gadget.c

1248

total_tdl += DIV_ROUND_UP(length,

drivers/usb/cdns3/cdnsp-debug.h

186

ep_num = DIV_ROUND_UP(ep_id, 2);

drivers/usb/cdns3/cdnsp-ring.c

1712

num_trbs = DIV_ROUND_UP(len + (addr & (TRB_MAX_BUFF_SIZE - 1)),

drivers/usb/cdns3/cdnsp-ring.c

1791

total_packet_count = DIV_ROUND_UP(td_total_len, maxp);

drivers/usb/cdns3/cdnsp-ring.c

2180

return DIV_ROUND_UP(total_packet_count, max_burst + 1) - 1;

drivers/usb/cdns3/cdnsp-ring.c

2264

total_pkt_count = DIV_ROUND_UP(td_len, max_pkt);

drivers/usb/core/devio.c

1723

num_sgs = DIV_ROUND_UP(uurb->buffer_length, USB_SG_SIZE);

drivers/usb/core/hub.c

4119

u1_sel = DIV_ROUND_UP(udev->u1_params.sel, 1000);

drivers/usb/core/hub.c

4120

u1_pel = DIV_ROUND_UP(udev->u1_params.pel, 1000);

drivers/usb/core/hub.c

4121

u2_sel = DIV_ROUND_UP(udev->u2_params.sel, 1000);

drivers/usb/core/hub.c

4122

u2_pel = DIV_ROUND_UP(udev->u2_params.pel, 1000);

drivers/usb/core/hub.c

4283

sel = DIV_ROUND_UP(udev->u1_params.sel, 1000);

drivers/usb/core/hub.c

4285

sel = DIV_ROUND_UP(udev->u2_params.sel, 1000);

drivers/usb/dwc2/core.h

834

(DIV_ROUND_UP((us), DWC2_US_PER_SLICE) * \

drivers/usb/dwc2/gadget.c

1117

packets = DIV_ROUND_UP(length, hs_ep->ep.maxpacket);

drivers/usb/dwc2/gadget.c

2305

to_read = DIV_ROUND_UP(to_read, 4);

drivers/usb/dwc2/gadget.c

652

to_write = DIV_ROUND_UP(to_write, 4);

drivers/usb/dwc2/gadget.c

946

pid = DIV_ROUND_UP(len, hs_ep->ep.maxpacket);

drivers/usb/dwc2/hcd.c

3810

DIV_ROUND_UP(interval * us, us_per_frame);

drivers/usb/dwc2/hcd.h

192

#define DWC2_ELEMENTS_PER_LS_BITMAP DIV_ROUND_UP(DWC2_LS_SCHEDULE_SLICES, \

drivers/usb/dwc2/hcd_queue.c

521

int slices = DIV_ROUND_UP(qh->device_us, DWC2_US_PER_SLICE);

drivers/usb/dwc2/hcd_queue.c

560

int slices = DIV_ROUND_UP(qh->device_us, DWC2_US_PER_SLICE);

drivers/usb/dwc2/hcd_queue.c

767

DIV_ROUND_UP(188 * (qh->ls_start_schedule_slice %

drivers/usb/dwc2/hcd_queue.c

802

qh->num_hs_transfers = 1 + DIV_ROUND_UP(other_data_bytes, 188);

drivers/usb/dwc3/core.c

1215

scale = DIV_ROUND_UP(clk_get_rate(dwc->susp_clk), 16000);

drivers/usb/dwc3/ulpi.c

22

#define DWC3_ULPI_BASE_DELAY DIV_ROUND_UP(NSEC_PER_SEC, 60000000L)

drivers/usb/fotg210/fotg210-hcd.c

4198

DIV_ROUND_UP(mod - excess, period);

drivers/usb/gadget/configfs.c

541

if (DIV_ROUND_UP(val, 8) > 0xff)

drivers/usb/gadget/function/f_uac2.c

693

(DIV_ROUND_UP(srate, factor / (1 << (bint - 1))));

drivers/usb/gadget/function/f_uac2.c

697

(DIV_ROUND_UP(srate, factor / (1 << (bint - 1))) + 1);

drivers/usb/gadget/function/uvc_queue.c

92

DIV_ROUND_UP(buf->bytesused +

drivers/usb/gadget/function/uvc_video.c

312

min(DIV_ROUND_UP(video->uvc_num_requests, 4), UVCG_REQ_MAX_INT_COUNT))) {

drivers/usb/gadget/function/uvc_video.c

511

DIV_ROUND_UP(video->imagesize, max_req_size);

drivers/usb/gadget/function/uvc_video.c

522

nreq = DIV_ROUND_UP(video->interval, interval_duration);

drivers/usb/gadget/function/uvc_video.c

526

req_size = DIV_ROUND_UP(video->imagesize + header_size, nreq);

drivers/usb/gadget/function/uvc_video.c

588

DIV_ROUND_UP(video->req_size - UVCG_REQUEST_HEADER_LEN,

drivers/usb/gadget/udc/cdns2/cdns2-gadget.c

395

num_trbs = DIV_ROUND_UP(len +

drivers/usb/gadget/udc/r8a66597-udc.c

750

DIV_ROUND_UP(req->req.length, ep->ep.maxpacket),

drivers/usb/gadget/udc/renesas_usbf.c

842

npkt = DIV_ROUND_UP(left, epn->ep.maxpacket);

drivers/usb/gadget/udc/tegra-xudc.c

1287

req->trbs_needed = DIV_ROUND_UP(req->usb_req.length,

drivers/usb/host/octeon-hcd.c

1460

packets_to_transfer = DIV_ROUND_UP(bytes_to_transfer,

drivers/usb/host/octeon-hcd.c

1704

DIV_ROUND_UP(bytes_to_transfer, pipe->max_packet);

drivers/usb/host/octeon-hcd.c

770

divisor = DIV_ROUND_UP(octeon_get_clock_rate(), 125000000);

drivers/usb/host/ohci-hcd.c

130

num += DIV_ROUND_UP(this_sg_len, 4096);

drivers/usb/host/ohci-hcd.c

139

num = DIV_ROUND_UP(len, 4096);

drivers/usb/host/ohci-hcd.c

278

urb_priv->td_cnt = DIV_ROUND_UP(

drivers/usb/host/ohci-hub.c

626

int limit_1 = DIV_ROUND_UP(PORT_RESET_MSEC, PORT_RESET_HW_MSEC);

drivers/usb/host/r8a66597-hcd.c

1110

DIV_ROUND_UP

drivers/usb/host/xhci-mtk-sch.c

346

esit_pkts = DIV_ROUND_UP(max_esit_payload, maxpkt);

drivers/usb/host/xhci-mtk-sch.c

367

DIV_ROUND_UP(esit_pkts, sch_ep->pkts);

drivers/usb/host/xhci-mtk-sch.c

386

sch_ep->cs_count = DIV_ROUND_UP(maxpkt, FS_PAYLOAD_MAX);

drivers/usb/host/xhci-mtk-sch.c

599

u32 cs_count = DIV_ROUND_UP(sch_ep->maxpkt, FS_PAYLOAD_MAX);

drivers/usb/host/xhci-ring.c

3378

num_trbs = DIV_ROUND_UP(len + (addr & (TRB_MAX_BUFF_SIZE - 1)),

drivers/usb/host/xhci-ring.c

3534

total_packet_count = DIV_ROUND_UP(td_total_len, maxp);

drivers/usb/host/xhci-ring.c

3934

return DIV_ROUND_UP(total_packet_count, max_burst + 1) - 1;

drivers/usb/host/xhci-ring.c

4122

total_pkt_count = DIV_ROUND_UP(td_len, max_pkt);

drivers/usb/host/xhci-tegra.c

1044

code_tag_blocks = DIV_ROUND_UP(le32_to_cpu(header->boot_codetag),

drivers/usb/host/xhci-tegra.c

1046

code_size_blocks = DIV_ROUND_UP(le32_to_cpu(header->boot_codesize),

drivers/usb/host/xhci.c

1474

unsigned int number = DIV_ROUND_UP(ep_index, 2);

drivers/usb/host/xhci.c

2394

bw_reserved = DIV_ROUND_UP(SS_BW_RESERVED*SS_BW_LIMIT_IN, 100);

drivers/usb/host/xhci.c

2398

bw_reserved = DIV_ROUND_UP(SS_BW_RESERVED*SS_BW_LIMIT_OUT, 100);

drivers/usb/host/xhci.c

2467

bw_reserved = DIV_ROUND_UP(HS_BW_RESERVED * max_bandwidth, 100);

drivers/usb/host/xhci.c

2470

bw_reserved = DIV_ROUND_UP(FS_BW_RESERVED * max_bandwidth, 100);

drivers/usb/host/xhci.c

2504

bw_used = DIV_ROUND_UP(bw_table->interval0_esit_payload, block_size) +

drivers/usb/host/xhci.c

2534

largest_mps = DIV_ROUND_UP(

drivers/usb/host/xhci.c

2635

unsigned int mps = DIV_ROUND_UP(ep_bw->max_packet_size, SS_BLOCK);

drivers/usb/host/xhci.c

2641

return DIV_ROUND_UP(ep_bw->mult * ep_bw->num_packets *

drivers/usb/host/xhci.c

4803

sel = DIV_ROUND_UP(udev->u1_params.sel, 1000);

drivers/usb/host/xhci.c

4804

pel = DIV_ROUND_UP(udev->u1_params.pel, 1000);

drivers/usb/host/xhci.c

4809

sel = DIV_ROUND_UP(udev->u2_params.sel, 1000);

drivers/usb/host/xhci.c

4810

pel = DIV_ROUND_UP(udev->u2_params.pel, 1000);

drivers/usb/host/xhci.c

5150

u1_mel_us = DIV_ROUND_UP(udev->u1_params.mel, 1000);

drivers/usb/host/xhci.c

5153

u2_mel_us = DIV_ROUND_UP(udev->u2_params.mel, 1000);

drivers/usb/misc/usbtest.c

1994

packets = DIV_ROUND_UP(bytes, maxp);

drivers/usb/mtu3/mtu3_core.c

26

u32 num_bits = DIV_ROUND_UP(seg_size, MTU3_EP_FIFO_UNIT);

drivers/usb/renesas_usbhs/pipe.c

391

usbhsp_pipe_trn_set(pipe, 0xffff, DIV_ROUND_UP(len, maxp));

drivers/usb/serial/ch341.c

166

#define CH341_MIN_BPS DIV_ROUND_UP(CH341_CLKRATE, CH341_CLK_DIV(0, 0) * 256)

drivers/usb/usbip/vhci_hcd.c

233

int retval = DIV_ROUND_UP(VHCI_HC_PORTS + 1, 8);

drivers/usb/usbip/vudc_rx.c

130

packets = DIV_ROUND_UP(bytes, maxp);

drivers/vfio/pci/mlx5/cmd.c

330

DIV_ROUND_UP(npages, 2));

drivers/vfio/pci/mlx5/cmd.c

342

MLX5_SET(mkc, mkc, translations_octword_size, DIV_ROUND_UP(npages, 2));

drivers/vfio/pci/mlx5/cmd.c

798

DIV_ROUND_UP(sizeof(struct mlx5_vf_migration_header),

drivers/vfio/pci/mlx5/main.c

1023

DIV_ROUND_UP(sizeof(struct mlx5_vf_migration_header),

drivers/vfio/pci/mlx5/main.c

1136

DIV_ROUND_UP(size, PAGE_SIZE), DMA_FROM_DEVICE);

drivers/vfio/pci/mlx5/main.c

280

u32 npages = DIV_ROUND_UP(required_length, PAGE_SIZE);

drivers/vfio/pci/mlx5/main.c

345

header_buf = mlx5vf_get_data_buffer(migf, DIV_ROUND_UP(size, PAGE_SIZE),

drivers/vfio/pci/mlx5/main.c

411

migf, DIV_ROUND_UP(inc_state_size, PAGE_SIZE),

drivers/vfio/pci/mlx5/main.c

421

DIV_ROUND_UP(sizeof(struct mlx5_vf_migration_header),

drivers/vfio/pci/mlx5/main.c

531

buf = mlx5vf_get_data_buffer(migf, DIV_ROUND_UP(inc_length, PAGE_SIZE),

drivers/vfio/pci/mlx5/main.c

897

u32 npages = DIV_ROUND_UP(migf->record_size, PAGE_SIZE);

drivers/vfio/pci/mlx5/main.c

927

u32 npages = DIV_ROUND_UP(size, PAGE_SIZE);

drivers/vfio/pci/pds/dirty.c

152

max_sge = DIV_ROUND_UP(page_count, PAGE_SIZE * 8);

drivers/vfio/pci/pds/dirty.c

304

page_count = DIV_ROUND_UP(region_size, region_page_size);

drivers/vfio/pci/pds/dirty.c

547

pages = DIV_ROUND_UP(length, region->page_size);

drivers/vfio/pci/pds/dirty.c

563

bmp_bytes = ALIGN(DIV_ROUND_UP(length / region->page_size,

drivers/vfio/pci/pds/dirty.c

579

bmp_offset = DIV_ROUND_UP((iova - region->start) /

drivers/video/backlight/mt6370-backlight.c

173

ovp_uV = DIV_ROUND_UP(ovp_uV - MT6370_BL_OVP_MIN_UV,

drivers/video/backlight/mt6370-backlight.c

186

ocp_uA = DIV_ROUND_UP(ocp_uA - MT6370_BL_OCP_MIN_UA,

drivers/video/backlight/pwm_bl.c

195

min((int)DIV_ROUND_UP(period, fls(period)), 4096);

drivers/video/backlight/rt4831-backlight.c

147

val = DIV_ROUND_UP(ocp_uA - RT4831_BLOCP_MINUA,

drivers/video/fbdev/atmel_lcdfb.c

250

value = DIV_ROUND_UP(value, 4);

drivers/video/fbdev/atmel_lcdfb.c

252

value = DIV_ROUND_UP(value, 8);

drivers/video/fbdev/atmel_lcdfb.c

565

info->fix.line_length = DIV_ROUND_UP(bits_per_line, 8);

drivers/video/fbdev/atmel_lcdfb.c

584

value = DIV_ROUND_UP(clk_value_khz, PICOS2KHZ(info->var.pixclock));

drivers/video/fbdev/broadsheetfb.c

942

h_inc = DIV_ROUND_UP(PAGE_SIZE , xres);

drivers/video/fbdev/bt431.h

210

width = DIV_ROUND_UP(width, 8);

drivers/video/fbdev/clps711x-fb.c

79

val = DIV_ROUND_UP(var->xres, 16) - 1;

drivers/video/fbdev/clps711x-fb.c

83

val = DIV_ROUND_UP(var->yres * var->xres * var->bits_per_pixel, 128);

drivers/video/fbdev/core/bitblit.c

155

u32 width = DIV_ROUND_UP(vc->vc_font.width, 8);

drivers/video/fbdev/core/bitblit.c

201

pitch = DIV_ROUND_UP(image.width, 8) + scan_align;

drivers/video/fbdev/core/bitblit.c

266

int w = DIV_ROUND_UP(vc->vc_font.width, 8), c;

drivers/video/fbdev/core/bitblit.c

29

int width = DIV_ROUND_UP(vc->vc_font.width, 8);

drivers/video/fbdev/core/fb_defio.c

307

npagerefs = DIV_ROUND_UP(info->fix.smem_len, PAGE_SIZE);

drivers/video/fbdev/core/fbcon.c

623

logo_lines = DIV_ROUND_UP(logo_height, vc->vc_font.height);

drivers/video/fbdev/fsl-diu-fb.c

1015

image += DIV_ROUND_UP(width, 8);

drivers/video/fbdev/fsl-diu-fb.c

1065

DIV_ROUND_UP(cursor->image.width, 8) *

drivers/video/fbdev/fsl-diu-fb.c

1068

DIV_ROUND_UP(image_size, sizeof(uint32_t));

drivers/video/fbdev/gxt4500.c

250

pll_period = DIV_ROUND_UP(period_ps, postdiv);

drivers/video/fbdev/omap2/omapfb/dss/dispc.c

2098

const int ds = DIV_ROUND_UP(height, out_height);

drivers/video/fbdev/omap2/omapfb/dss/dispc.c

2233

return DIV_ROUND_UP(pclk, out_width) * width;

drivers/video/fbdev/omap2/omapfb/dss/dispc.c

2387

DIV_ROUND_UP(pclk, out_width);

drivers/video/fbdev/omap2/omapfb/dss/dispc.c

2390

*decim_x = DIV_ROUND_UP(width, in_width_max);

drivers/video/fbdev/omap2/omapfb/dss/dispc.c

2457

decim_x = DIV_ROUND_UP(DIV_ROUND_UP(width, out_width), maxdownscale);

drivers/video/fbdev/omap2/omapfb/dss/dispc.c

2458

decim_y = DIV_ROUND_UP(DIV_ROUND_UP(height, out_height), maxdownscale);

drivers/video/fbdev/omap2/omapfb/dss/dispc.c

3604

lckd_start = max(DIV_ROUND_UP(dispc, lck_max), 1ul);

drivers/video/fbdev/omap2/omapfb/dss/dispc.c

3610

pckd_start = max(DIV_ROUND_UP(lck, pck_max), pckd_hw_min);

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

1272

lp_clk_div = DIV_ROUND_UP(dsi_fclk, lp_clk_max * 2);

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

1372

cinfo->mX[HSDIV_DSI] = DIV_ROUND_UP(cinfo->clkdco, max_dsi_fck);

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

3494

width_bytes = DIV_ROUND_UP(timings->x_res * bpp, 8);

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

3495

bllp = hbp + hfp + hsa + DIV_ROUND_UP(width_bytes + 6, ndl);

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

3663

ths_eot = DIV_ROUND_UP(4, ndl);

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

3665

ddr_clk_pre = DIV_ROUND_UP(tclk_pre + tlpx + tclk_zero + tclk_prepare,

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

3667

ddr_clk_post = DIV_ROUND_UP(tclk_post + ths_trail, 4) + ths_eot;

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

3681

enter_hs_mode_lat = 1 + DIV_ROUND_UP(tlpx, 4) +

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

3682

DIV_ROUND_UP(ths_prepare, 4) +

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

3683

DIV_ROUND_UP(ths_zero + 3, 4);

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

3685

exit_hs_mode_lat = DIV_ROUND_UP(ths_trail + ths_exit, 4) + 1 + ths_eot;

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

3710

((hsa == 0 && ndl == 3) ? 1 : DIV_ROUND_UP(4, ndl)) : 0;

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

3712

width_bytes = DIV_ROUND_UP(timings->x_res * bpp, 8);

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

3715

tl = DIV_ROUND_UP(4, ndl) + (hsync_end ? hsa : 0) + t_he + hfp +

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

3716

DIV_ROUND_UP(width_bytes + 6, ndl) + hbp;

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

3855

word_count = DIV_ROUND_UP(dsi->timings.x_res * bpp, 8);

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

4324

wc = DIV_ROUND_UP(t->hact * t->bitspp, 8);

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

4325

pps = DIV_ROUND_UP(wc + 6, t->ndl); /* pixel packet size */

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

4390

dsi_hact = DIV_ROUND_UP(DIV_ROUND_UP(t->hact * t->bitspp, 8) + 6, t->ndl);

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

4525

dsi_hact = DIV_ROUND_UP(DIV_ROUND_UP(xres * bitspp, 8) + 6, ndl);

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

4549

hss = DIV_ROUND_UP(4, ndl);

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

4555

hse = DIV_ROUND_UP(4, ndl);

drivers/video/fbdev/omap2/omapfb/dss/dss.c

543

fckd_stop = max(DIV_ROUND_UP(prate * m, fck_hw_max), 1ul);

drivers/video/fbdev/omap2/omapfb/dss/dss.c

546

fck = DIV_ROUND_UP(prate, fckd) * m;

drivers/video/fbdev/omap2/omapfb/dss/dss.c

593

fck_div = DIV_ROUND_UP(prate * dss.feat->dss_fck_multiplier,

drivers/video/fbdev/omap2/omapfb/dss/dss.c

595

fck = DIV_ROUND_UP(prate, fck_div) * dss.feat->dss_fck_multiplier;

drivers/video/fbdev/omap2/omapfb/dss/hdmi_pll.c

56

n = DIV_ROUND_UP(clkin, hw->fint_max);

drivers/video/fbdev/omap2/omapfb/dss/hdmi_pll.c

61

m2 = DIV_ROUND_UP(min_dco, target_bitclk);

drivers/video/fbdev/omap2/omapfb/dss/hdmi_pll.c

82

sd = DIV_ROUND_UP(fint * m, 250000000);

drivers/video/fbdev/omap2/omapfb/dss/pll.c

132

m_start = max(DIV_ROUND_UP(clkdco, out_max), 1ul);

drivers/video/fbdev/omap2/omapfb/dss/pll.c

162

n_start = max(DIV_ROUND_UP(clkin, fint_hw_max), 1ul);

drivers/video/fbdev/omap2/omapfb/dss/pll.c

170

m_start = max(DIV_ROUND_UP(DIV_ROUND_UP(pll_min, fint), 2),

drivers/video/fbdev/ssd1307fb.c

219

unsigned int pages = DIV_ROUND_UP(y % 8 + height, 8);

drivers/video/fbdev/ssd1307fb.c

668

vmem_size = DIV_ROUND_UP(par->width, 8) * par->height;

drivers/video/fbdev/ssd1307fb.c

691

info->fix.line_length = DIV_ROUND_UP(par->width, 8);

drivers/watchdog/airoha_wdt.c

110

return DIV_ROUND_UP(val, airoha_wdt->wdt_freq);

drivers/watchdog/dw_wdt.c

212

timeout = dw_wdt_find_best_top(dw_wdt, DIV_ROUND_UP(top_s, dw_wdt->rmod),

drivers/watchdog/ebc-c384_wdt.c

46

t = DIV_ROUND_UP(t, 60);

drivers/watchdog/exar_wdt.c

205

t = DIV_ROUND_UP(t, 60);

drivers/watchdog/f71808e_wdt.c

218

wd->timer_val = DIV_ROUND_UP(timeout, 60);

drivers/watchdog/intel-mid_wdt.c

71

in_size = DIV_ROUND_UP(sizeof(ipc_wd_start), 4);

drivers/watchdog/lpc18xx_wdt.c

108

val = DIV_ROUND_UP(lpc18xx_wdt->wdt_dev.timeout * lpc18xx_wdt->clk_rate,

drivers/watchdog/lpc18xx_wdt.c

236

lpc18xx_wdt->wdt_dev.min_timeout = DIV_ROUND_UP(LPC18XX_WDT_TC_MIN *

drivers/watchdog/nic7018_wdt.c

78

count = DIV_ROUND_UP(timeout + 16, 32);

drivers/watchdog/pseries-wdt.c

182

pw->wd.min_timeout = DIV_ROUND_UP(msecs, MSEC_PER_SEC);

drivers/watchdog/realtek_otto_wdt.c

120

return max(min_ticks, DIV_ROUND_UP(val, tick_duration));

drivers/watchdog/renesas_wdt.c

143

udelay(DIV_ROUND_UP(2 * 1000000, priv->clk_rate));

drivers/watchdog/renesas_wdt.c

155

udelay(DIV_ROUND_UP(2 * 1000000, priv->clk_rate));

drivers/watchdog/renesas_wdt.c

37

DIV_ROUND_UP((d) * (p)->clk_rate, clk_divs[(p)->cks])

drivers/watchdog/renesas_wdt.c

80

delay = DIV_ROUND_UP(cycles * 1000000, priv->clk_rate);

drivers/watchdog/renesas_wwdt.c

115

wdev->timeout = DIV_ROUND_UP(wdev->max_hw_heartbeat_ms, 1000);

drivers/watchdog/rza_wdt.c

56

ticks = DIV_ROUND_UP(timeout * rate, DIVIDER_4BIT);

drivers/watchdog/rzg2l_wdt.c

213

mdelay(DIV_ROUND_UP(2 * 0xFFFFF * 1000, priv->osc_clk_rate));

drivers/watchdog/s3c2410_wdt.c

574

freq = DIV_ROUND_UP(freq, 128);

drivers/watchdog/s3c2410_wdt.c

586

divisor = DIV_ROUND_UP(count, wdt->max_cnt);

drivers/watchdog/s3c2410_wdt.c

595

timeout, divisor, count, DIV_ROUND_UP(count, divisor));

drivers/watchdog/s3c2410_wdt.c

597

count = DIV_ROUND_UP(count, divisor);

drivers/watchdog/starfive-wdt.c

304

return DIV_ROUND_UP(STARFIVE_WDT_MAXCNT, (wdt->freq / 2)) - 1;

drivers/watchdog/starfive-wdt.c

306

return DIV_ROUND_UP(STARFIVE_WDT_MAXCNT, wdt->freq) - 1;

drivers/watchdog/stm32_iwdg.c

113

presc = DIV_ROUND_UP(tout * wdt->rate, RLR_MAX + 1);

drivers/watchdog/stm32_iwdg.c

342

wdd->min_timeout = DIV_ROUND_UP((RLR_MIN + 1) * PR_MIN, wdt->rate);

drivers/watchdog/wdat_wdt.c

352

wdat->wdd.min_timeout = DIV_ROUND_UP(wdat->period * tbl->min_count, 1000);

drivers/xen/arm-device.c

24

nr = DIV_ROUND_UP(resource_size(r), XEN_PAGE_SIZE);

drivers/xen/arm-device.c

58

nr = DIV_ROUND_UP(resource_size(r), XEN_PAGE_SIZE);

drivers/xen/privcmd.c

506

nr_pages = DIV_ROUND_UP(m.num, XEN_PFN_PER_PAGE);

drivers/xen/privcmd.c

618

requested = DIV_ROUND_UP(

drivers/xen/privcmd.c

693

nr_pages += DIV_ROUND_UP(

drivers/xen/privcmd.c

798

unsigned int nr = DIV_ROUND_UP(kdata.num, XEN_PFN_PER_PAGE);

drivers/xen/xen-front-pgdir-shbuf.c

160

return DIV_ROUND_UP(buf->num_pages, XEN_NUM_GREFS_PER_PAGE);

drivers/xen/xenbus/xenbus_client.c

52

#define XENBUS_PAGES(_grants) (DIV_ROUND_UP(_grants, XEN_PFN_PER_PAGE))

drivers/xen/xlate_mmu.c

152

unsigned long range = DIV_ROUND_UP(nr, XEN_PFN_PER_PAGE) << PAGE_SHIFT;

drivers/xen/xlate_mmu.c

225

nr_pages = DIV_ROUND_UP(nr_grant_frames, XEN_PFN_PER_PAGE);

fs/afs/dir.c

380

pos = DIV_ROUND_UP(ctx->pos, AFS_DIR_DIRENT_SIZE) - base;

fs/btrfs/extent_io.c

1604

DIV_ROUND_UP(delalloc_end + 1 - page_start, PAGE_SIZE);

fs/btrfs/free-space-cache.c

383

num_pages = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);

fs/btrfs/free-space-tree.c

155

return DIV_ROUND_UP(size >> fs_info->sectorsize_bits, BITS_PER_BYTE);

fs/btrfs/inode.c

1704

u64 num_chunks = DIV_ROUND_UP(end - start, SZ_512K);

fs/btrfs/inode.c

1774

nr_pages = DIV_ROUND_UP(cur_end - start, PAGE_SIZE);

fs/btrfs/inode.c

9658

nr_pages = DIV_ROUND_UP(disk_io_size, PAGE_SIZE);

fs/btrfs/ioctl.c

4619

nr_pages = DIV_ROUND_UP(disk_io_size, PAGE_SIZE);

fs/btrfs/relocation.c

4043

unsigned int nr_pages = DIV_ROUND_UP(length, PAGE_SIZE);

fs/btrfs/zstd.c

596

unsigned long total_folios_in = DIV_ROUND_UP(srclen, min_folio_size);

fs/buffer.c

356

if (bh->b_folio->index < DIV_ROUND_UP(inode->i_size, PAGE_SIZE))

fs/cachefiles/key.c

81

b64len = DIV_ROUND_UP(keylen, 3);

fs/ceph/mds_client.c

1463

#define FEATURE_BYTES(c) (DIV_ROUND_UP((size_t)feature_bits[c - 1] + 1, 64) * 8)

fs/ceph/mds_client.c

1494

#define METRIC_BYTES(cnt) (DIV_ROUND_UP((size_t)metric_bits[cnt - 1] + 1, 64) * 8)

fs/ceph/mds_client.c

5075

unsigned long targets[DIV_ROUND_UP(CEPH_MAX_MDS, sizeof(unsigned long))] = {0};

fs/crypto/inline_crypt.c

60

return DIV_ROUND_UP(dun_bits, 8);

fs/dax.c

1994

max_pgoff = DIV_ROUND_UP(i_size_read(iter.inode), PAGE_SIZE);

fs/erofs/decompressor.c

10

#define LZ4_MAX_DISTANCE_PAGES (DIV_ROUND_UP(LZ4_DISTANCE_MAX, PAGE_SIZE) + 1)

fs/erofs/decompressor.c

44

DIV_ROUND_UP(distance, PAGE_SIZE) + 1 :

fs/erofs/decompressor.c

57

unsigned long bounced[DIV_ROUND_UP(LZ4_MAX_DISTANCE_PAGES,

fs/exfat/exfat_fs.h

147

(DIV_ROUND_UP(EXFAT_DEN_TO_B(ES_MAX_ENTRY_NUM), SECTOR_SIZE) + 1)

fs/exfat/exfat_fs.h

47

DIV_ROUND_UP(name_len, EXFAT_FILE_NAME_LEN)

fs/ext2/super.c

783

meta_blocks += 1 + DIV_ROUND_UP(upper_limit, ppb);

fs/ext2/super.c

790

meta_blocks += 1 + DIV_ROUND_UP(upper_limit, ppb) +

fs/ext2/super.c

791

DIV_ROUND_UP(upper_limit, ppb*ppb);

fs/ext4/extents.c

2432

DIV_ROUND_UP(extents, ext4_ext_space_block(inode, 0));

fs/ext4/ialloc.c

1555

used_blks = DIV_ROUND_UP(used_inos, sbi->s_inodes_per_block);

fs/ext4/indirect.c

686

return DIV_ROUND_UP(nrblocks, EXT4_ADDR_PER_BLOCK(inode->i_sb)) + 4;

fs/ext4/mballoc.c

1397

groups_per_folio = DIV_ROUND_UP(blocks_per_folio, 2);

fs/ext4/mballoc.c

3821

DIV_ROUND_UP(sbi->s_groups_count, 4));

fs/ext4/readpage.c

409

if (folio->index < DIV_ROUND_UP(inode->i_size, PAGE_SIZE))

fs/ext4/readpage.c

425

if (readahead_index(rac) < DIV_ROUND_UP(inode->i_size, PAGE_SIZE))

fs/ext4/resize.c

1567

credit += 1 + DIV_ROUND_UP(flex_gd->count, EXT4_DESC_PER_BLOCK(sb));

fs/f2fs/compress.c

639

cc->nr_cpages = DIV_ROUND_UP(max_len, PAGE_SIZE);

fs/f2fs/compress.c

683

new_nr_cpages = DIV_ROUND_UP(cc->clen + COMPRESS_HEADER_SIZE, PAGE_SIZE);

fs/f2fs/compress.c

875

unsigned nr_pages = DIV_ROUND_UP(i_size, PAGE_SIZE);

fs/f2fs/data.c

1261

if (idx < DIV_ROUND_UP(inode->i_size, PAGE_SIZE))

fs/f2fs/f2fs.h

601

DIV_ROUND_UP(NR_INLINE_DENTRY(inode), BITS_PER_BYTE)

fs/f2fs/file.c

1559

pgoff_t nrpages = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);

fs/f2fs/file.c

1825

idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);

fs/f2fs/file.c

2560

end = DIV_ROUND_UP(offset + len, PAGE_SIZE);

fs/f2fs/file.c

2908

DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE));

fs/f2fs/file.c

2974

sec_num = DIV_ROUND_UP(total, CAP_BLKS_PER_SEC(sbi));

fs/f2fs/file.c

3901

last_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);

fs/f2fs/file.c

4079

last_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);

fs/f2fs/file.c

4233

pg_end = DIV_ROUND_UP(end_addr, F2FS_BLKSIZE);

fs/f2fs/file.c

4513

last_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);

fs/f2fs/file.c

4593

last_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);

fs/f2fs/gc.c

1788

sum_blk_cnt = DIV_ROUND_UP(end_segno - segno, sbi->sums_per_block);

fs/f2fs/segment.c

317

pgoff_t len = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);

fs/f2fs/segment.h

109

DIV_ROUND_UP(MAIN_SEGS(sbi), SIT_ENTRY_PER_BLOCK)

fs/f2fs/segment.h

689

return DIV_ROUND_UP(total_node_blocks, CAP_BLKS_PER_SEC(sbi)) +

fs/f2fs/segment.h

690

DIV_ROUND_UP(total_dent_blocks, CAP_BLKS_PER_SEC(sbi)) +

fs/f2fs/segment.h

691

DIV_ROUND_UP(total_data_blocks, CAP_BLKS_PER_SEC(sbi));

fs/f2fs/super.c

4258

sit_blk_cnt = DIV_ROUND_UP(main_segs, SIT_ENTRY_PER_BLOCK);

fs/fs-writeback.c

905

max_time = DIV_ROUND_UP((max_bytes >> PAGE_SHIFT) << WB_FRN_TIME_SHIFT,

fs/fs-writeback.c

924

slots = min(DIV_ROUND_UP(max_time, WB_FRN_HIST_UNIT),

fs/fuse/file.c

1604

nfolios = DIV_ROUND_UP(ret + start, PAGE_SIZE);

fs/fuse/ioctl.c

303

max_pages = DIV_ROUND_UP(max(in_size, out_size), PAGE_SIZE);

fs/gfs2/bmap.h

41

tmp = DIV_ROUND_UP(tmp, sdp->sd_inptrs);

fs/gfs2/dir.c

2034

rg_blocks + (DIV_ROUND_UP(size, sdp->sd_jbsize) + 1) +

fs/gfs2/file.c

1239

tmp = DIV_ROUND_UP(tmp, sdp->sd_inptrs);

fs/gfs2/log.c

567

revoke_blks = DIV_ROUND_UP(revokes, sdp->sd_inptrs);

fs/gfs2/log.c

598

revoke_blks = DIV_ROUND_UP(revokes, sdp->sd_inptrs);

fs/gfs2/log.c

61

blks += DIV_ROUND_UP(nstruct - first, second);

fs/gfs2/log.c

658

reserved += blocks + DIV_ROUND_UP(blocks, buf_limit(sdp));

fs/gfs2/log.c

660

reserved += blocks + DIV_ROUND_UP(blocks, databuf_limit(sdp));

fs/gfs2/ops_fstype.c

289

hash_blocks = DIV_ROUND_UP(sizeof(u64) * BIT(GFS2_DIR_MAX_DEPTH),

fs/gfs2/ops_fstype.c

294

tmp_blocks = DIV_ROUND_UP(tmp_blocks, sdp->sd_inptrs);

fs/gfs2/quota.c

1407

bm_size = DIV_ROUND_UP(sdp->sd_quota_slots, 8 * sizeof(unsigned long));

fs/gfs2/trans.c

65

tr->tr_reserved += blocks + 1 + DIV_ROUND_UP(blocks - 1, databuf_limit(sdp));

fs/gfs2/xattr.c

1072

blks += DIV_ROUND_UP(er.er_data_len, GFS2_SB(&ip->i_inode)->sd_jbsize);

fs/gfs2/xattr.c

463

unsigned int nptrs = DIV_ROUND_UP(amount, sdp->sd_jbsize);

fs/gfs2/xattr.c

49

(sizeof(__be64) * DIV_ROUND_UP(dsize, jbsize)), 8);

fs/gfs2/xattr.c

701

ea->ea_num_ptrs = DIV_ROUND_UP(er->er_data_len, sdp->sd_jbsize);

fs/gfs2/xattr.c

819

blks += DIV_ROUND_UP(er.er_data_len, jbsize);

fs/gfs2/xattr.c

959

blks = 2 + DIV_ROUND_UP(es->es_er->er_data_len,

fs/iomap/bio.c

94

unsigned int nr_vecs = DIV_ROUND_UP(length, PAGE_SIZE);

fs/jbd2/journal.c

1435

return 1 + DIV_ROUND_UP(jbd2_journal_get_max_txn_bufs(journal),

fs/jbd2/transaction.c

482

nblocks += DIV_ROUND_UP(revoke_records,

fs/jbd2/transaction.c

663

nblocks += DIV_ROUND_UP(

fs/jbd2/transaction.c

666

DIV_ROUND_UP(

fs/jbd2/transaction.c

717

WARN_ON_ONCE(DIV_ROUND_UP(revokes, rr_per_blk)

fs/jbd2/transaction.c

722

DIV_ROUND_UP(t_revokes, rr_per_blk) -

fs/jbd2/transaction.c

723

DIV_ROUND_UP(t_revokes - revokes, rr_per_blk);

fs/jbd2/transaction.c

793

DIV_ROUND_UP(revoke_records,

fs/jfs/jfs_dtree.h

123

#define NDTLEAF_LEGACY(klen) (DIV_ROUND_UP((2 + (klen)), 15))

fs/jfs/jfs_dtree.h

64

#define NDTINTERNAL(klen) (DIV_ROUND_UP((4 + (klen)), 15))

fs/jfs/resize.c

163

t32 = DIV_ROUND_UP(t64, BITSPERPAGE) + 1 + 50;

fs/minix/bitmap.c

30

unsigned blocks = DIV_ROUND_UP(numbits, blocksize * 8);

fs/minix/minix.h

97

return DIV_ROUND_UP(bits, blocksize * 8);

fs/netfs/buffered_write.c

82

add = DIV_ROUND_UP(copied - gap, SECTOR_SIZE);

fs/netfs/buffered_write.c

85

DIV_ROUND_UP(end, SECTOR_SIZE),

fs/netfs/iterator.c

82

cur_npages = DIV_ROUND_UP(ret, PAGE_SIZE);

fs/nfs/blocklayout/blocklayout.c

894

end = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);

fs/nfs/blocklayout/extent_tree.c

496

int nr_pages = DIV_ROUND_UP(buffer_size, PAGE_SIZE), i;

fs/nfs/blocklayout/extent_tree.c

657

DIV_ROUND_UP(buffer_size, PAGE_SIZE),

fs/nfs/nfs42proc.c

1370

#define NFS4XATTR_MAXPAGES DIV_ROUND_UP(XATTR_SIZE_MAX, PAGE_SIZE)

fs/nfs/nfs4proc.c

5931

#define NFS4ACL_MAXPAGES DIV_ROUND_UP(XATTR_SIZE_MAX, PAGE_SIZE)

fs/nfs/nfs4proc.c

6072

npages = DIV_ROUND_UP(buflen, PAGE_SIZE) + 1;

fs/nfs/nfs4proc.c

6184

unsigned int npages = DIV_ROUND_UP(buflen, PAGE_SIZE);

fs/nfs/nfs4session.h

38

#define SLOT_TABLE_SZ DIV_ROUND_UP(NFS4_MAX_SLOT_TABLE, BITS_PER_LONG)

fs/nfsd/nfs4state.c

4499

int cnt = DIV_ROUND_UP(s, 5);

fs/nilfs2/alloc.c

509

*desc_blocks = DIV_ROUND_UP(

fs/nilfs2/alloc.c

66

DIV_ROUND_UP(nilfs_palloc_entries_per_group(inode),

fs/nilfs2/mdt.c

513

mi->mi_first_entry_offset = DIV_ROUND_UP(header_size, entry_size);

fs/nilfs2/recovery.c

307

bcnt = DIV_ROUND_UP(count, nitem_per_block);

fs/nilfs2/recovery.c

344

blocknr = start_blocknr + DIV_ROUND_UP(sumbytes, nilfs->ns_blocksize);

fs/nilfs2/the_nilfs.c

413

DIV_ROUND_UP(nsegs * nilfs->ns_r_segments_percentage,

fs/ntfs3/inode.c

628

unsigned int nr_vecs = DIV_ROUND_UP(length, PAGE_SIZE);

fs/omfs/inode.c

344

bitmap_size = DIV_ROUND_UP(sbi->s_num_blocks, 8);

fs/omfs/inode.c

345

array_size = DIV_ROUND_UP(bitmap_size, sb->s_blocksize);

fs/orangefs/orangefs-bufmap.c

161

#define N DIV_ROUND_UP(ORANGEFS_READDIR_DEFAULT_DESC_COUNT, BITS_PER_LONG)

fs/pstore/ram_core.c

204

ecc_blocks = DIV_ROUND_UP(prz->buffer_size - prz->ecc_info.ecc_size,

fs/pstore/ram_core.c

424

page_count = DIV_ROUND_UP(size + offset_in_page(start), PAGE_SIZE);

fs/smb/client/cifsproto.h

559

nents += DIV_ROUND_UP(offset_in_page(addr) + len,

fs/smb/client/cifsproto.h

569

nents += DIV_ROUND_UP(offset_in_page(sig) + SMB2_SIGNATURE_SIZE, PAGE_SIZE);

fs/smb/client/smb2ops.c

1843

allowed = DIV_ROUND_UP(max_bytes_copy, max_bytes_chunk);

fs/smb/client/smb2ops.c

278

DIV_ROUND_UP(*num, SMB2_MAX_BUFFER_SIZE);

fs/smb/client/smb2ops.c

305

int new_val = DIV_ROUND_UP(subreq->subreq.len - subreq->subreq.transferred,

fs/smb/client/smb2pdu.c

3439

cpu_to_le16(DIV_ROUND_UP(max(indatalen, max_response_size),

fs/smb/client/smb2pdu.c

4795

shdr->CreditCharge = cpu_to_le16(DIV_ROUND_UP(io_parms.length,

fs/smb/client/smb2pdu.c

5183

shdr->CreditCharge = cpu_to_le16(DIV_ROUND_UP(wdata->subreq.len,

fs/smb/server/smb2misc.c

337

calc_credit_num = DIV_ROUND_UP(max_len, SMB2_MAX_BUFFER_SIZE);

fs/smb/server/transport_rdma.c

1351

return DIV_ROUND_UP(get_buf_page_count(buf, len),

fs/smb/server/transport_rdma.c

147

return DIV_ROUND_UP((uintptr_t)buf + size, PAGE_SIZE) -

fs/smb/server/transport_rdma.c

2210

max_send_sges = DIV_ROUND_UP(sp->max_send_size, PAGE_SIZE) + 3;

fs/smb/server/transport_rdma.c

2218

maxpages = DIV_ROUND_UP(sp->max_read_write_size, PAGE_SIZE);

fs/smb/server/transport_rdma.c

2222

sc->rw_io.credits.num_pages = DIV_ROUND_UP(maxpages, sc->rw_io.credits.max);

fs/splice.c

1466

n = DIV_ROUND_UP(left + start, PAGE_SIZE);

fs/splice.c

334

npages = DIV_ROUND_UP(len, PAGE_SIZE);

fs/splice.c

365

keep = DIV_ROUND_UP(ret, PAGE_SIZE);

fs/squashfs/block.c

227

const int page_count = DIV_ROUND_UP(total_len + offset, PAGE_SIZE);

fs/ubifs/lpt.c

52

max_pnode_cnt = DIV_ROUND_UP(n, UBIFS_LPT_FANOUT);

fs/ubifs/lpt.c

61

c->pnode_cnt = DIV_ROUND_UP(c->main_lebs, UBIFS_LPT_FANOUT);

fs/ubifs/lpt.c

63

n = DIV_ROUND_UP(c->pnode_cnt, UBIFS_LPT_FANOUT);

fs/ubifs/lpt.c

66

n = DIV_ROUND_UP(n, UBIFS_LPT_FANOUT);

fs/ubifs/lpt.c

732

cnt = DIV_ROUND_UP(cnt, UBIFS_LPT_FANOUT);

fs/ubifs/lpt.c

75

n = DIV_ROUND_UP(c->max_leb_cnt, UBIFS_LPT_FANOUT);

fs/ubifs/lpt_commit.c

1515

cnt = DIV_ROUND_UP(c->main_lebs, UBIFS_LPT_FANOUT);

fs/ubifs/lpt_commit.c

1668

cnt = DIV_ROUND_UP(c->main_lebs, UBIFS_LPT_FANOUT);

fs/ubifs/tnc_commit.c

343

return DIV_ROUND_UP(cnt, d);

fs/udf/directory.c

173

if (iter->loffset < DIV_ROUND_UP(iter->elen, 1<<iter->dir->i_blkbits))

fs/udf/super.c

1040

return DIV_ROUND_UP(map->s_partition_len +

fs/udf/truncate.c

164

DIV_ROUND_UP(elen, bsize));

fs/xfs/scrub/reap.c

1300

chunks = DIV_ROUND_UP(BBTOB(bp->b_maps[i].bm_len),

fs/xfs/scrub/reap.c

1302

map_size = DIV_ROUND_UP(chunks, NBWORD);

fs/xfs/xfs_buf_item.c

170

unsigned int chunks = DIV_ROUND_UP(blocksize, XFS_BLF_CHUNK);

fs/xfs/xfs_buf_item.c

171

unsigned int bitmap_size = DIV_ROUND_UP(chunks, NBWORD);

fs/xfs/xfs_buf_item.c

889

chunks = DIV_ROUND_UP(BBTOB(bp->b_maps[i].bm_len),

fs/xfs/xfs_buf_item.c

891

map_size = DIV_ROUND_UP(chunks, NBWORD);

fs/xfs/xfs_log.c

1247

DIV_ROUND_UP(mp->m_logbsize, XLOG_HEADER_CYCLE_SIZE) - 1);

fs/xfs/xfs_log.c

1520

xheads = DIV_ROUND_UP(size, XLOG_HEADER_CYCLE_SIZE) - 1;

fs/xfs/xfs_log_recover.c

3076

hblks = DIV_ROUND_UP(h_size, XLOG_HEADER_CYCLE_SIZE);

fs/xfs/xfs_log_recover.c

376

return DIV_ROUND_UP(h_size, XLOG_HEADER_CYCLE_SIZE);

include/asm-generic/delay.h

22

#define UDELAY_CONST_MULT ((unsigned long)DIV_ROUND_UP(1ULL << 32, USEC_PER_SEC))

include/asm-generic/delay.h

23

#define NDELAY_CONST_MULT ((unsigned long)DIV_ROUND_UP(1ULL << 32, NSEC_PER_SEC))

include/crypto/internal/ecc.h

37

#define ECC_MAX_DIGITS DIV_ROUND_UP(521, 64) /* NIST P521 */

include/crypto/scatterwalk.h

199

num_pages += DIV_ROUND_UP(offset + (nbytes % PAGE_SIZE), PAGE_SIZE);

include/drm/drm_fourcc.h

282

return DIV_ROUND_UP(width, info->hsub);

include/drm/drm_fourcc.h

304

return DIV_ROUND_UP(height, info->vsub);

include/linux/ascii85.h

19

return DIV_ROUND_UP(len, 4);

include/linux/base64.h

17

#define BASE64_CHARS(nbytes) DIV_ROUND_UP((nbytes) * 4, 3)

include/linux/bio.h

458

return DIV_ROUND_UP(offset_in_page(kaddr) + len, PAGE_SIZE);

include/linux/can/length.h

241

DIV_ROUND_UP(can_frame_bits(is_fd, is_eff, bitstuffing, \

include/linux/cdx/mcdi.h

184

#define MCDI_DECLARE_BUF(_name, _len) struct cdx_dword _name[DIV_ROUND_UP(_len, 4)] = {{0}}

include/linux/compat.h

953

#define BITS_TO_COMPAT_LONGS(bits) DIV_ROUND_UP(bits, BITS_PER_COMPAT_LONG)

include/linux/delay.h

134

msleep(DIV_ROUND_UP(usecs, USEC_PER_MSEC));

include/linux/delay.h

52

udelay(DIV_ROUND_UP(x, 1000));

include/linux/ethtool_netlink.h

11

DIV_ROUND_UP(__ETHTOOL_LINK_MODE_MASK_NBITS, 32)

include/linux/generic-radix-tree.h

57

DIV_ROUND_UP(BITS_PER_LONG - GENRADIX_NODE_SHIFT, GENRADIX_ARY_SHIFT)

include/linux/gpio/gpio-nomadik.h

13

#define NMK_MAX_BANKS DIV_ROUND_UP(512, NMK_GPIO_PER_CHIP)

include/linux/hid.h

1266

return DIV_ROUND_UP(report->size, 8) + (report->id > 0);

include/linux/ieee80211-eht.h

342

return DIV_ROUND_UP(n, 8);

include/linux/ieee80211-he.h

504

n = DIV_ROUND_UP(n, 8);

include/linux/ieee80211-s1g.h

432

span = DIV_ROUND_UP(len - 1, 8);

include/linux/iommu-helper.h

41

return DIV_ROUND_UP(size, io_page_size);

include/linux/jbd2.h

1803

DIV_ROUND_UP(handle->h_revoke_credits_requested,

include/linux/math.h

60

# define DIV_ROUND_UP_SECTOR_T(ll,d) DIV_ROUND_UP(ll,d)

include/linux/mmzone.h

1954

#define NR_SECTION_ROOTS DIV_ROUND_UP(NR_MEM_SECTIONS, SECTIONS_PER_ROOT)

include/linux/mtd/rawnand.h

770

DIV_ROUND_UP(dividend, divisor) : \

include/linux/nfs4.h

833

DIV_ROUND_UP(LAST_NFS4_OP, 8 * sizeof(unsigned long))

include/linux/qed/qed_chain.h

176

DIV_ROUND_UP((elem_cnt), \

include/linux/radix-tree.h

71

#define RADIX_TREE_MAX_PATH (DIV_ROUND_UP(RADIX_TREE_INDEX_BITS, \

include/linux/raspberrypi/vchiq_core.h

39

#define VCHIQ_SLOT_ZERO_SLOTS DIV_ROUND_UP(sizeof(struct vchiq_slot_zero), \

include/linux/rcu_node_tree.h

64

# define NUM_RCU_LVL_1 DIV_ROUND_UP(NR_CPUS, RCU_FANOUT_1)

include/linux/rcu_node_tree.h

72

# define NUM_RCU_LVL_1 DIV_ROUND_UP(NR_CPUS, RCU_FANOUT_2)

include/linux/rcu_node_tree.h

73

# define NUM_RCU_LVL_2 DIV_ROUND_UP(NR_CPUS, RCU_FANOUT_1)

include/linux/rcu_node_tree.h

81

# define NUM_RCU_LVL_1 DIV_ROUND_UP(NR_CPUS, RCU_FANOUT_3)

include/linux/rcu_node_tree.h

82

# define NUM_RCU_LVL_2 DIV_ROUND_UP(NR_CPUS, RCU_FANOUT_2)

include/linux/rcu_node_tree.h

83

# define NUM_RCU_LVL_3 DIV_ROUND_UP(NR_CPUS, RCU_FANOUT_1)

include/linux/sunrpc/svc.h

172

return DIV_ROUND_UP(serv->sv_max_mesg, PAGE_SIZE) + 2 + 1;

include/linux/tcp.h

91

__le64 val[DIV_ROUND_UP(TCP_FASTOPEN_COOKIE_MAX, sizeof(u64))];

include/linux/usb/hcd.h

643

#define NS_TO_US(ns) DIV_ROUND_UP(ns, 1000L)

include/net/cfg80211.h

6102

u8 ext_features[DIV_ROUND_UP(NUM_NL80211_EXT_FEATURES, 8)];

include/net/sch_generic.h

1386

return ((u64)(DIV_ROUND_UP(len,48)*53) * r->mult) >> r->shift;

kernel/cgroup/cgroup.c

69

#define CGROUP_FILE_NOTIFY_MIN_INTV DIV_ROUND_UP(HZ, 100)

kernel/crash_core.c

48

struct page *vmcoreinfo_pages[DIV_ROUND_UP(VMCOREINFO_BYTES, PAGE_SIZE)];

kernel/crash_core.c

53

nr_pages = DIV_ROUND_UP(VMCOREINFO_BYTES, PAGE_SIZE);

kernel/dma/debug.c

931

nr_pages = DIV_ROUND_UP(nr_prealloc_entries, DMA_DEBUG_DYNAMIC_ENTRIES);

kernel/dma/swiotlb.c

248

return DIV_ROUND_UP(val, IO_TLB_SIZE);

kernel/events/core.c

510

static int max_samples_per_tick __read_mostly = DIV_ROUND_UP(DEFAULT_MAX_SAMPLE_RATE, HZ);

kernel/events/core.c

545

max_samples_per_tick = DIV_ROUND_UP(sysctl_perf_event_sample_rate, HZ);

kernel/irq/generic-chip.c

292

numchips = DIV_ROUND_UP(d->revmap_size, info->irqs_per_chip);

kernel/locking/rwsem.c

358

#define RWSEM_WAIT_TIMEOUT DIV_ROUND_UP(HZ, 250)

kernel/module/decompress.c

308

n_pages = DIV_ROUND_UP(size, PAGE_SIZE) * 2;

kernel/module/stats.c

332

DIV_ROUND_UP(total_size, live_mod_count));

kernel/module/stats.c

337

DIV_ROUND_UP(text_size, live_mod_count));

kernel/module/stats.c

350

DIV_ROUND_UP(ikread_bytes, fkreads));

kernel/module/stats.c

356

DIV_ROUND_UP(ibecoming_bytes, fbecoming));

kernel/module/stats.c

362

DIV_ROUND_UP(idecompress_bytes, fdecompress));

kernel/module/stats.c

368

DIV_ROUND_UP(imod_bytes, floads));

kernel/power/snapshot.c

1228

rtree = nodes = DIV_ROUND_UP(zone->spanned_pages, BM_BITS_PER_BLOCK);

kernel/power/snapshot.c

1229

rtree += DIV_ROUND_UP(rtree * sizeof(struct rtree_node),

kernel/power/snapshot.c

1232

nodes = DIV_ROUND_UP(nodes, BM_ENTRIES_PER_LEVEL);

kernel/power/snapshot.c

1882

- 2 * DIV_ROUND_UP(reserved_size, PAGE_SIZE);

kernel/power/snapshot.c

1884

size = DIV_ROUND_UP(image_size, PAGE_SIZE);

kernel/power/snapshot.c

2143

nr_meta_pages = DIV_ROUND_UP(nr_pages * sizeof(long), PAGE_SIZE);

kernel/power/snapshot.c

2673

nr_pages = DIV_ROUND_UP(nr_pages, PBES_PER_LINKED_PAGE);

kernel/power/snapshot.c

557

nr_blocks = DIV_ROUND_UP(pages, BM_BITS_PER_BLOCK);

kernel/power/swap.c

1394

need = DIV_ROUND_UP(data[thr].cmp_len + CMP_HEADER,

kernel/power/swap.c

505

#define CMP_PAGES DIV_ROUND_UP(bytes_worst_compress(UNC_SIZE) + \

kernel/rcu/tasks.h

147

.lazy_jiffies = DIV_ROUND_UP(HZ, 4), \

kernel/rcu/tree.c

4841

num_rcu_lvl[i] = DIV_ROUND_UP(nr_cpu_ids, cap);

kernel/rcu/tree_nocb.h

1447

nl = DIV_ROUND_UP(rdp->cpu + 1, ls) * ls;

kernel/rcu/tree_plugin.h

1284

#define RCU_BOOST_DELAY_JIFFIES DIV_ROUND_UP(CONFIG_RCU_BOOST_DELAY * HZ, 1000)

kernel/sched/ext.c

3985

if (delta < DIV_ROUND_UP(min_delta_us, READ_ONCE(scx_slice_bypass_us)))

kernel/sched/ext.c

4094

nr_target = DIV_ROUND_UP(nr_tasks, nr_cpus);

kernel/sched/ext.c

4095

nr_donor_target = DIV_ROUND_UP(nr_target * SCX_BYPASS_LB_DONOR_PCT, 100);

kernel/sched/fair.c

2794

period_slot = DIV_ROUND_UP(p->numa_scan_period, NUMA_PERIOD_SLOTS);

kernel/sched/rt.c

2501

next = DIV_ROUND_UP(min(soft, hard), USEC_PER_SEC/HZ);

kernel/time/time.c

384

return DIV_ROUND_UP(j * HZ_TO_MSEC_NUM, HZ_TO_MSEC_DEN);

kernel/time/timer_migration.c

1981

cpus_per_node = DIV_ROUND_UP(ncpus, nnodes);

kernel/time/timer_migration.c

1984

cpulvl = DIV_ROUND_UP(order_base_2(cpus_per_node),

kernel/time/timer_migration.c

1988

nodelvl = DIV_ROUND_UP(order_base_2(nnodes),

kernel/trace/fgraph.c

27

#define FGRAPH_FRAME_OFFSET DIV_ROUND_UP(FGRAPH_FRAME_SIZE, sizeof(long))

kernel/trace/ftrace.c

3859

pages = DIV_ROUND_UP(count * ENTRY_SIZE, PAGE_SIZE);

kernel/trace/ftrace.c

660

pages = DIV_ROUND_UP(functions, PROFILES_PER_PAGE);

kernel/trace/ring_buffer.c

2576

nr_pages = DIV_ROUND_UP(size, buffer->subbuf_size);

kernel/trace/ring_buffer.c

2962

nr_pages = DIV_ROUND_UP(size, buffer->subbuf_size);

kernel/trace/ring_buffer.c

3803

event->type_len = DIV_ROUND_UP(length, RB_ALIGNMENT);

kernel/trace/ring_buffer.c

6906

nr_pages = DIV_ROUND_UP(nr_pages, buffer->subbuf_size);

kernel/trace/trace.c

9194

pages = DIV_ROUND_UP(val, PAGE_SIZE);

kernel/vmcore_info.c

53

buf += DIV_ROUND_UP(sizeof(*note), sizeof(Elf_Word));

kernel/vmcore_info.c

55

buf += DIV_ROUND_UP(note->n_namesz, sizeof(Elf_Word));

kernel/vmcore_info.c

57

buf += DIV_ROUND_UP(data_len, sizeof(Elf_Word));

kernel/watchdog.c

479

util = DIV_ROUND_UP(100 * (new_stat - old_stat), sample_period_16);

kernel/workqueue.c

1628

clamp(DIV_ROUND_UP(max_active * node_cpus, total_cpus),

lib/842/842_compress.c

188

if (DIV_ROUND_UP(bits, 8) > p->olen)

lib/842/842_decompress.c

106

if (DIV_ROUND_UP(bits, 8) > p->ilen)

lib/bch.c

1109

const int plen = DIV_ROUND_UP(bch->ecc_bits+1, 32);

lib/bch.c

1110

const int ecclen = DIV_ROUND_UP(bch->ecc_bits, 32);

lib/bch.c

1200

genpoly = bch_alloc(DIV_ROUND_UP(m*t+1, 32)*sizeof(*genpoly), &err);

lib/bch.c

1330

words = DIV_ROUND_UP(m*t, 32);

lib/bch.c

1331

bch->ecc_bytes = DIV_ROUND_UP(m*t, 8);

lib/bch.c

92

#define BCH_ECC_WORDS(_p) DIV_ROUND_UP(GF_M(_p)*GF_T(_p), 32)

lib/bch.c

93

#define BCH_ECC_BYTES(_p) DIV_ROUND_UP(GF_M(_p)*GF_T(_p), 8)

lib/bch.c

95

#define BCH_ECC_MAX_WORDS DIV_ROUND_UP(BCH_MAX_M * BCH_MAX_T, 32)

lib/bitmap.c

798

halfwords = DIV_ROUND_UP(nbits, 32);

lib/bitmap.c

821

halfwords = DIV_ROUND_UP(nbits, 32);

lib/crypto/arm/chacha.h

49

state->x[12] += DIV_ROUND_UP(l, CHACHA_BLOCK_SIZE);

lib/crypto/arm/chacha.h

81

state->x[12] += DIV_ROUND_UP(bytes, CHACHA_BLOCK_SIZE);

lib/crypto/arm64/chacha.h

57

state->x[12] += DIV_ROUND_UP(l, CHACHA_BLOCK_SIZE);

lib/crypto/blake2b.c

131

const size_t nblocks = DIV_ROUND_UP(inlen, BLAKE2B_BLOCK_SIZE);

lib/crypto/blake2s.c

125

const size_t nblocks = DIV_ROUND_UP(inlen, BLAKE2S_BLOCK_SIZE);

lib/crypto/mpi/mpicoder.c

382

nlimbs = DIV_ROUND_UP(nbytes, BYTES_PER_MPI_LIMB);

lib/crypto/mpi/mpicoder.c

57

nlimbs = DIV_ROUND_UP(nbytes, BYTES_PER_MPI_LIMB);

lib/crypto/mpi/mpicoder.c

97

nbytes = DIV_ROUND_UP(nbits, 8);

lib/debugobjects.c

44

#define ODEBUG_FREE_WORK_DELAY DIV_ROUND_UP(HZ, 10)

lib/digsig.c

117

mlen = DIV_ROUND_UP(mblen, 8);

lib/dim/dim.c

72

curr_stats->ppms = DIV_ROUND_UP(npkts * USEC_PER_MSEC, delta_us);

lib/dim/dim.c

73

curr_stats->bpms = DIV_ROUND_UP(nbytes * USEC_PER_MSEC, delta_us);

lib/dim/dim.c

74

curr_stats->epms = DIV_ROUND_UP(DIM_NEVENTS * USEC_PER_MSEC,

lib/dim/dim.c

76

curr_stats->cpms = DIV_ROUND_UP(ncomps * USEC_PER_MSEC, delta_us);

lib/iov_iter.c

1169

npages += DIV_ROUND_UP(offs + len, PAGE_SIZE);

lib/iov_iter.c

1188

npages += DIV_ROUND_UP(offs + len, PAGE_SIZE);

lib/iov_iter.c

1201

int npages = DIV_ROUND_UP(offs + i->count, PAGE_SIZE);

lib/iov_iter.c

1211

int npages = DIV_ROUND_UP(offset + i->count, PAGE_SIZE);

lib/iov_iter.c

1216

int npages = DIV_ROUND_UP(offset + i->count, PAGE_SIZE);

lib/iov_iter.c

1865

max_pages = DIV_ROUND_UP(offset + len, PAGE_SIZE);

lib/iov_iter.c

1922

nr_pages = DIV_ROUND_UP(offset + size, PAGE_SIZE);

lib/iov_iter.c

900

unsigned int count = DIV_ROUND_UP(size + start, PAGE_SIZE);

lib/kfifo.c

208

ret = DIV_ROUND_UP(ret + len - l, esize);

lib/kfifo.c

212

ret = DIV_ROUND_UP(ret, esize);

lib/kfifo.c

268

ret = DIV_ROUND_UP(ret + len - l, esize);

lib/kfifo.c

272

ret = DIV_ROUND_UP(ret, esize);

lib/linear_ranges.c

238

*selector = DIV_ROUND_UP(val - r->min, r->step) + r->min_sel;

lib/radix-tree.c

55

#define IDR_MAX_PATH (DIV_ROUND_UP(IDR_INDEX_BITS, \

lib/sbitmap.c

117

sb->map_nr = DIV_ROUND_UP(sb->depth, bits_per_word);

lib/sbitmap.c

154

sb->map_nr = DIV_ROUND_UP(sb->depth, bits_per_word);

lib/scatterlist.c

1139

npages = DIV_ROUND_UP(off + len, PAGE_SIZE);

lib/scatterlist.c

88

nents += DIV_ROUND_UP(sg_dma_len(sg), len);

lib/test_bitmap.c

333

unsigned int nlongs = DIV_ROUND_UP(nbits, BITS_PER_LONG);

lib/test_bitmap.c

668

expect_eq_uint(arr[DIV_ROUND_UP(nbits, 32)],

lib/test_bitmap.c

703

expect_eq_uint(arr[DIV_ROUND_UP(nbits, 64)], 0xa5a5a5a5);

lib/tests/base64_kunit.c

42

size_t outlen = DIV_ROUND_UP(size, 3) * 4;

lib/vsprintf.c

1267

spec.field_width = DIV_ROUND_UP(chunksz, 4);

mm/cma_debug.c

187

DIV_ROUND_UP(cma_bitmap_maxno(cma, cmr),

mm/filemap.c

3524

max_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);

mm/filemap.c

3628

max_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);

mm/filemap.c

3729

max_idx = DIV_ROUND_UP(i_size_read(mapping->host), PAGE_SIZE);

mm/filemap.c

3891

file_end = DIV_ROUND_UP(i_size_read(mapping->host), PAGE_SIZE) - 1;

mm/huge_memory.c

4033

end = DIV_ROUND_UP(i_size_read(mapping->host), PAGE_SIZE);

mm/hugetlb_cma.c

205

per_node = DIV_ROUND_UP(hugetlb_cma_size,

mm/hugetlb_vmemmap.c

869

memmap_boot_pages_add(DIV_ROUND_UP(nr_mmap, PAGE_SIZE));

mm/memory.c

5592

file_end = DIV_ROUND_UP(i_size_read(mapping->host), PAGE_SIZE);

mm/mincore.c

258

unsigned long pages = DIV_ROUND_UP(end - addr, PAGE_SIZE);

mm/mm_init.c

1668

memmap_boot_pages_add(DIV_ROUND_UP(size, PAGE_SIZE));

mm/page-writeback.c

1466

step = DIV_ROUND_UP(step >> shift, 8);

mm/page-writeback.c

372

ratio = min(DIV_ROUND_UP(bytes, global_avail),

mm/page-writeback.c

375

bg_ratio = min(DIV_ROUND_UP(bg_bytes, global_avail),

mm/page-writeback.c

381

thresh = DIV_ROUND_UP(bytes, PAGE_SIZE);

mm/page-writeback.c

386

bg_thresh = DIV_ROUND_UP(bg_bytes, PAGE_SIZE);

mm/page-writeback.c

445

dirty = DIV_ROUND_UP(vm_dirty_bytes, PAGE_SIZE) *

mm/page-writeback.c

498

if (DIV_ROUND_UP(dirty_background_bytes, PAGE_SIZE) >

mm/page-writeback.c

530

if (DIV_ROUND_UP(vm_dirty_bytes, PAGE_SIZE) > UINT_MAX) {

mm/page_alloc.c

5405

unsigned long nr = DIV_ROUND_UP(size, PAGE_SIZE);

mm/page_ext.c

221

memmap_boot_pages_add(DIV_ROUND_UP(table_size, PAGE_SIZE));

mm/page_ext.c

282

memmap_pages_add(DIV_ROUND_UP(size, PAGE_SIZE));

mm/page_ext.c

329

memmap_pages_add(-1L * (DIV_ROUND_UP(table_size, PAGE_SIZE)));

mm/page_reporting.c

180

budget = DIV_ROUND_UP(area->nr_free, PAGE_REPORTING_CAPACITY * 16);

mm/percpu.c

2883

int this_allocs = DIV_ROUND_UP(group_cnt[group], upa);

mm/readahead.c

810

new_nr_pages = DIV_ROUND_UP(new_len, PAGE_SIZE);

mm/shmem.c

1617

DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE));

mm/shmem.c

2579

DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE) <

mm/shmem.c

3269

max_off = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);

mm/shmem.c

4622

ctx->blocks = DIV_ROUND_UP(size, PAGE_SIZE);

mm/shmem.c

785

end = shmem_fallocend(inode, DIV_ROUND_UP(i_size, PAGE_SIZE));

mm/shrinker.c

18

return (DIV_ROUND_UP(nr_items, SHRINKER_UNIT_BITS) * sizeof(struct shrinker_info_unit *));

mm/shrinker.c

30

nr = DIV_ROUND_UP(info->map_nr_max, SHRINKER_UNIT_BITS);

mm/shrinker.c

45

int nr = DIV_ROUND_UP(new->map_nr_max, SHRINKER_UNIT_BITS);

mm/shrinker.c

46

int start = old ? DIV_ROUND_UP(old->map_nr_max, SHRINKER_UNIT_BITS) : 0;

mm/sparse.c

567

memmap_boot_pages_add(DIV_ROUND_UP(PAGES_PER_SECTION * sizeof(struct page),

mm/sparse.c

858

memmap_pages_add(-1L * (DIV_ROUND_UP(nr_pages * sizeof(struct page), PAGE_SIZE)));

mm/sparse.c

861

memmap_boot_pages_add(-1L * (DIV_ROUND_UP(nr_pages * sizeof(struct page),

mm/sparse.c

909

memmap_pages_add(DIV_ROUND_UP(nr_pages * sizeof(struct page), PAGE_SIZE));

mm/swap_cgroup.c

140

map = vzalloc(DIV_ROUND_UP(max_pages, ID_PER_SC) *

mm/swapfile.c

2730

int i, nr_clusters = DIV_ROUND_UP(maxpages, SWAPFILE_CLUSTER);

mm/swapfile.c

3255

unsigned long nr_clusters = DIV_ROUND_UP(maxpages, SWAPFILE_CLUSTER);

mm/userfaultfd.c

158

max_off = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);

mm/zsmalloc.c

121

#define ZS_SIZE_CLASSES (DIV_ROUND_UP(ZS_MAX_ALLOC_SIZE - ZS_MIN_ALLOC_SIZE, \

mm/zsmalloc.c

475

idx = DIV_ROUND_UP(size - ZS_MIN_ALLOC_SIZE,

mm/zswap.c

1673

nr = DIV_ROUND_UP(nr_pages, ZSWAP_ADDRESS_SPACE_PAGES);

net/9p/trans_virtio.c

337

nr_pages = DIV_ROUND_UP(n + *offs, PAGE_SIZE);

net/9p/trans_virtio.c

358

nr_pages = DIV_ROUND_UP((unsigned long)p + len, PAGE_SIZE) -

net/9p/trans_virtio.c

444

out_nr_pages = DIV_ROUND_UP(n + offs, PAGE_SIZE);

net/9p/trans_virtio.c

463

in_nr_pages = DIV_ROUND_UP(n + offs, PAGE_SIZE);

net/bluetooth/l2cap_core.c

560

return DIV_ROUND_UP(chan->rx_avail - sdu_len, chan->mps);

net/bluetooth/l2cap_sock.c

1190

expected_skbs = DIV_ROUND_UP(avail, chan->mps);

net/bridge/br_stp_bpdu.c

75

return DIV_ROUND_UP(ticks * HZ, STP_HZ);

net/core/dev.c

3376

return count > 2 ? DIV_ROUND_UP(count, 2) : count;

net/core/dev.c

4154

gso_segs = DIV_ROUND_UP(payload, shinfo->gso_size);

net/core/skbuff.c

5097

skb_shinfo(tail)->gso_segs = DIV_ROUND_UP(tail->len - doffset, gso_size);

net/core/sock.c

453

val = tv.tv_sec * HZ + DIV_ROUND_UP((unsigned long)tv.tv_usec,

net/core/sysctl_net_core.c

72

len = min(DIV_ROUND_UP(nr_cpumask_bits, 32) * (8 + 1), *lenp);

net/ethtool/bitset.c

183

unsigned int nwords = DIV_ROUND_UP(nbits, 32);

net/ethtool/bitset.c

248

unsigned int nwords = DIV_ROUND_UP(nbits, 32);

net/ethtool/bitset.c

472

unsigned int nwords = DIV_ROUND_UP(nbits, 32);

net/ethtool/bitset.c

551

attr_nwords = DIV_ROUND_UP(attr_nbits, 32);

net/ethtool/bitset.c

737

#define ETHNL_SMALL_BITMAP_WORDS DIV_ROUND_UP(ETHNL_SMALL_BITMAP_BITS, 32)

net/ethtool/bitset.c

750

unsigned int nwords = DIV_ROUND_UP(nbits, 32);

net/ethtool/bitset.c

786

unsigned int nwords = DIV_ROUND_UP(nbits, 32);

net/ethtool/bitset.c

821

unsigned int dst_words = DIV_ROUND_UP(nbits, 32);

net/ethtool/common.h

9

#define ETHTOOL_DEV_FEATURE_WORDS DIV_ROUND_UP(NETDEV_FEATURE_COUNT, 32)

net/ethtool/ioctl.c

425

DIV_ROUND_UP(__ETHTOOL_LINK_MODE_MASK_NBITS, 32)

net/ipv4/tcp_input.c

1246

dup_segs = DIV_ROUND_UP(seq_len, tp->mss_cache);

net/ipv4/tcp_offload.c

170

skb_shinfo(skb)->gso_segs = DIV_ROUND_UP(skb->len, mss);

net/ipv4/tcp_output.c

1747

tso_segs = DIV_ROUND_UP(skb->len, mss_now);

net/ipv4/udp.c

1163

skb_shinfo(skb)->gso_segs = DIV_ROUND_UP(datalen,

net/ipv4/udp_offload.c

510

skb_shinfo(gso_skb)->gso_segs = DIV_ROUND_UP(gso_skb->len - sizeof(*uh),

net/ipv6/udp.c

1415

skb_shinfo(skb)->gso_segs = DIV_ROUND_UP(datalen,

net/key/af_key.c

387

DIV_ROUND_UP(sizeof(*sp) + offsetofend(typeof(*addr), sa_family),

net/key/af_key.c

393

len = DIV_ROUND_UP(sizeof(*sp) + sizeof(*sin), sizeof(uint64_t));

net/key/af_key.c

400

len = DIV_ROUND_UP(sizeof(*sp) + sizeof(*sin6), sizeof(uint64_t));

net/key/af_key.c

424

int key_bytes = DIV_ROUND_UP(key->sadb_key_bits, 8);

net/key/af_key.c

426

return DIV_ROUND_UP(sizeof(struct sadb_key) + key_bytes,

net/key/af_key.c

442

return DIV_ROUND_UP(sizeof(struct sadb_x_sec_ctx) +

net/mac80211/airtime.c

19

#define MCS_N_KSYMS(bps) DIV_ROUND_UP(MCS_NBITS << 10, (bps))

net/mac80211/ibss.c

109

int rate = DIV_ROUND_UP(sband->bitrates[ri].bitrate, 5);

net/mac80211/ibss.c

152

int rate = DIV_ROUND_UP(sband->bitrates[ri].bitrate, 5);

net/mac80211/ibss.c

438

brate = DIV_ROUND_UP(sband->bitrates[j].bitrate, 5);

net/mac80211/led.c

255

return DIV_ROUND_UP(delta, 1024 / 8);

net/mac80211/mesh_hwmp.c

346

rate = DIV_ROUND_UP(sta_get_expected_throughput(sta), 100);

net/mac80211/mlme.c

803

brate = DIV_ROUND_UP(br->bitrate, 5);

net/mac80211/parse.c

1152

brate = DIV_ROUND_UP(br->bitrate, 5);

net/mac80211/rc80211_minstrel_ht.c

26

#define MCS_NSYMS(bps) DIV_ROUND_UP(MCS_NBITS, (bps))

net/mac80211/rx.c

439

*pos = DIV_ROUND_UP(rate->bitrate, 5 * (1 << shift));

net/mac80211/sta_info.c

2552

rinfo->legacy = DIV_ROUND_UP(brate, 1 << shift);

net/mac80211/status.c

310

*pos = DIV_ROUND_UP(legacy_rate, 5);

net/mac80211/tx.c

3584

DIV_ROUND_UP(skb->len, skb_shinfo(skb)->gso_size);

net/mac80211/util.c

151

dur += 4 * DIV_ROUND_UP((16 + 8 * (len + 4) + 6) * 10,

net/mac80211/util.c

167

dur += DIV_ROUND_UP(8 * (len + 4) * 10, rate);

net/mac80211/util.c

2607

n = DIV_ROUND_UP(n, 8);

net/mac80211/util.c

3365

rate = DIV_ROUND_UP(sband->bitrates[i].bitrate, 5);

net/mac80211/util.c

3870

skip = DIV_ROUND_UP(-end, data->desc[i].interval);

net/netfilter/nf_tables_api.c

11559

next_register = DIV_ROUND_UP(len, NFT_REG32_SIZE) + reg;

net/netfilter/nf_tables_api.c

11580

unsigned int registers = DIV_ROUND_UP(len, NFT_REG32_SIZE);

net/netfilter/nf_tables_api.c

5223

num_regs = DIV_ROUND_UP(desc->klen, sizeof(u32));

net/netfilter/nf_tables_api.c

964

regcount = DIV_ROUND_UP(len, NFT_REG32_SIZE);

net/netfilter/nf_tables_api.c

977

regcount = DIV_ROUND_UP(len, NFT_REG32_SIZE);

net/netfilter/nft_bitwise.c

34

for (i = 0; i < DIV_ROUND_UP(priv->len, sizeof(u32)); i++)

net/netfilter/nft_bitwise.c

435

regcount = DIV_ROUND_UP(priv->len, NFT_REG32_SIZE);

net/netfilter/nft_bitwise.c

45

for (i = DIV_ROUND_UP(priv->len, sizeof(u32)); i > 0; i--) {

net/netfilter/nft_bitwise.c

58

for (i = 0; i < DIV_ROUND_UP(priv->len, sizeof(u32)); i++) {

net/netfilter/nft_bitwise.c

69

for (i = 0, n = DIV_ROUND_UP(priv->len, sizeof(u32)); i < n; i++)

net/netfilter/nft_bitwise.c

78

for (i = 0, n = DIV_ROUND_UP(priv->len, sizeof(u32)); i < n; i++)

net/netfilter/nft_bitwise.c

87

for (i = 0, n = DIV_ROUND_UP(priv->len, sizeof(u32)); i < n; i++)

net/netfilter/nft_set_pipapo.c

1130

int step, masks = 0, bytes = DIV_ROUND_UP(len, BITS_PER_BYTE);

net/netfilter/nft_set_pipapo.c

722

new_bucket_size = DIV_ROUND_UP(rules, BITS_PER_LONG);

net/netfilter/nft_set_rbtree.c

639

shrinked_max_intervals = DIV_ROUND_UP(shrinked_max_intervals, 3);

net/rds/ib_send.c

522

i = DIV_ROUND_UP(be32_to_cpu(rm->m_inc.i_hdr.h_len), RDS_FRAG_SIZE);

net/rds/ib_send.c

926

i = DIV_ROUND_UP(op->op_count, max_sge);

net/rds/message.c

378

int num_sgs = DIV_ROUND_UP(total_len, PAGE_SIZE);

net/rds/message.c

387

rm->data.op_nents = DIV_ROUND_UP(total_len, PAGE_SIZE);

net/rds/send.c

1146

int num_sgs = DIV_ROUND_UP(payload_len, PAGE_SIZE);

net/sunrpc/auth_gss/gss_rpc_upcall.c

216

arg->npages = DIV_ROUND_UP(NGROUPS_MAX * 4, PAGE_SIZE);

net/sunrpc/auth_gss/svcauth_gss.c

1071

pages = DIV_ROUND_UP(inlen, PAGE_SIZE);

net/sunrpc/svcsock.c

684

DIV_ROUND_UP(rqstp->rq_arg.page_len, PAGE_SIZE);

net/sunrpc/xprtrdma/frwr_ops.c

253

DIV_ROUND_UP(RPCRDMA_MAX_DATA_SEGS, ep->re_max_fr_depth);

net/sunrpc/xprtsock.c

2293

keepidle = DIV_ROUND_UP(xprt->timeout->to_initval, HZ);

net/sunrpc/xprtsock.c

2311

DIV_ROUND_UP(xprt->connect_timeout, HZ), 1);

net/vmw_vsock/af_vsock.c

2058

DIV_ROUND_UP((unsigned long)tv.tv_usec, (USEC_PER_SEC / HZ));

net/wireless/nl80211.c

10776

DIV_ROUND_UP(interval, MSEC_PER_SEC);

net/wireless/nl80211.c

14564

if (nla_put(msg, NL80211_PKTPAT_MASK, DIV_ROUND_UP(pat_len, 8),

net/wireless/nl80211.c

14603

DIV_ROUND_UP(tcp->wake_len, 8), tcp->wake_mask))

net/wireless/nl80211.c

14830

if (wake_mask_size != DIV_ROUND_UP(wake_size, 8))

net/wireless/nl80211.c

15078

mask_len = DIV_ROUND_UP(pat_len, 8);

net/wireless/nl80211.c

15204

DIV_ROUND_UP(pat_len, 8),

net/wireless/nl80211.c

15323

mask_len = DIV_ROUND_UP(pat_len, 8);

samples/vfio-mdev/mbochs.c

942

dmabuf->pagecount = DIV_ROUND_UP(mode->size, PAGE_SIZE);

security/selinux/ss/sidtab.h

53

DIV_ROUND_UP(SIDTAB_MAX_BITS - size_to_shift(SIDTAB_LEAF_ENTRIES), \

sound/core/control.c

1002

offset = DIV_ROUND_UP(offset, sizeof(u32));

sound/core/control.c

1112

offset = DIV_ROUND_UP(offset, sizeof(u32));

sound/core/seq/seq_memory.c

354

ncells = DIV_ROUND_UP(extlen, sizeof(struct snd_seq_event));

sound/drivers/aloop.c

227

tick = DIV_ROUND_UP(tick, dpcm->pcm_bps);

sound/drivers/dummy.c

247

DIV_ROUND_UP(dpcm->frac_period_rest, dpcm->rate));

sound/firewire/amdtp-am824.c

69

midi_channels = DIV_ROUND_UP(midi_ports, 8);

sound/firewire/amdtp-stream.c

2102

queue_size = DIV_ROUND_UP(CYCLES_PER_SECOND * events_per_buffer,

sound/firewire/amdtp-stream.c

2109

idle_irq_interval = DIV_ROUND_UP(CYCLES_PER_SECOND * events_per_period,

sound/firewire/iso-resources.c

59

s400_bytes = DIV_ROUND_UP(bytes, 1 << (speed - SCODE_400));

sound/firewire/motu/amdtp-motu.c

74

data_block_quadlets = 1 + DIV_ROUND_UP(data_chunks * 3, 4);

sound/firewire/packets-buffer.c

42

pages = DIV_ROUND_UP(count, packets_per_page);

sound/hda/core/stream.c

524

pos_adj = DIV_ROUND_UP(pos_adj * runtime->rate, 48000);

sound/isa/sb/emu8000_pcm.c

241

DIV_ROUND_UP(1000000, HZ), UINT_MAX);

sound/pci/asihpi/hpidebug.c

55

lines = DIV_ROUND_UP(len, cols);

sound/pci/bt87x.c

328

chip->current_line = DIV_ROUND_UP(irq_block * chip->lines,

sound/pci/cs46xx/cs46xx_lib.c

813

initialDelay = DIV_ROUND_UP(48000 * 24, rate);

sound/pci/ctxfi/ctresource.c

211

mgr->rscs = kzalloc(DIV_ROUND_UP(amount, 8), GFP_KERNEL);

sound/pci/emu10k1/memory.c

373

size_t npages = DIV_ROUND_UP(size, PAGE_SIZE);

sound/pci/lola/lola_clock.c

138

nb_verbs = DIV_ROUND_UP(nitems, 4);

sound/pci/riptide/riptide.c

1485

pages = DIV_ROUND_UP(size, f);

sound/sh/aica.c

109

length = DIV_ROUND_UP(length, 4);

sound/soc/adi/axi-i2s.c

98

bclk_div = DIV_ROUND_UP(clk_get_rate(i2s->clk_ref), bclk_rate) / 2 - 1;

sound/soc/codecs/adau-utils.c

28

div = DIV_ROUND_UP(freq_in, 13500000);

sound/soc/codecs/cs35l36.c

917

fs1 = 3 * DIV_ROUND_UP(CS35L36_FS_NOM_6MHZ * 4, freq) + 4;

sound/soc/codecs/cs35l36.c

918

fs2 = 5 * DIV_ROUND_UP(CS35L36_FS_NOM_6MHZ * 4, freq) + 4;

sound/soc/codecs/pcm3168a.c

284

msleep(DIV_ROUND_UP(3846 * 1000, pcm3168a->sysclk));

sound/soc/codecs/pcm3168a.c

791

msleep(DIV_ROUND_UP(3846 * 1000, pcm3168a->sysclk));

sound/soc/codecs/pcm512x.c

1083

ncp_div = DIV_ROUND_UP(dac_rate, 2048000);

sound/soc/codecs/pcm512x.c

574

ranges[1].min = DIV_ROUND_UP(16000000, frame_size);

sound/soc/codecs/pcm512x.c

773

num *= DIV_ROUND_UP(pllin_rate / den, 20000000);

sound/soc/codecs/pcm512x.c

774

den *= DIV_ROUND_UP(pllin_rate / den, 20000000);

sound/soc/codecs/pcm512x.c

830

P = DIV_ROUND_UP(pllin_rate, 20000000);

sound/soc/codecs/tlv320aic32x4-clk.c

323

divisor = DIV_ROUND_UP(parent_rate, rate);

sound/soc/codecs/tlv320aic32x4-clk.c

336

divisor = DIV_ROUND_UP(req->best_parent_rate, req->rate);

sound/soc/codecs/tlv320aic32x4-clk.c

340

req->rate = DIV_ROUND_UP(req->best_parent_rate, divisor);

sound/soc/codecs/tlv320aic32x4-clk.c

359

return DIV_ROUND_UP(parent_rate, val);

sound/soc/codecs/tlv320aic32x4.c

768

madc = DIV_ROUND_UP((32 * adc_resource_class), aosr);

sound/soc/codecs/tlv320aic32x4.c

779

min_mdac = DIV_ROUND_UP((32 * dac_resource_class), dosr);

sound/soc/codecs/wm8978.c

501

opclk_div = DIV_ROUND_UP(3 * f_mclk / 4, f_opclk);

sound/soc/fsl/fsl_esai.c

543

u32 pins = DIV_ROUND_UP(channels, esai_priv->slots);

sound/soc/fsl/fsl_esai.c

652

u32 pins = DIV_ROUND_UP(channels, esai_priv->slots);

sound/soc/fsl/fsl_sai.c

584

pins = DIV_ROUND_UP(channels, slots);

sound/soc/intel/avs/messages.c

152

msg.ext.init_instance.param_block_size = DIV_ROUND_UP(param_size, sizeof(u32));

sound/soc/intel/catpt/pcm.c

397

rinfo.num_pages = DIV_ROUND_UP(rtm->dma_bytes, PAGE_SIZE);

sound/soc/renesas/rcar/core.c

1644

DIV_ROUND_UP(io->converted_rate, k_up);

sound/soc/renesas/rcar/core.c

1646

DIV_ROUND_UP(io->converted_rate, k_up);

sound/soc/rockchip/rockchip_sai.c

589

req_lanes = DIV_ROUND_UP(params_channels(params), 2);

sound/soc/sof/intel/hda-sdw-bpt.c

256

unsigned int num_channels = DIV_ROUND_UP(dma_bandwidth, BPT_FREQUENCY * 32);

sound/soc/sof/intel/hda-sdw-bpt.c

276

num_channels_tx = DIV_ROUND_UP(tx_dma_bandwidth, BPT_FREQUENCY * 32);

sound/soc/sof/intel/hda-sdw-bpt.c

286

num_channels_rx = DIV_ROUND_UP(rx_dma_bandwidth, BPT_FREQUENCY * 32);

sound/soc/sof/ipc3.c

472

num_msg = DIV_ROUND_UP(msg_bytes, payload_size);

sound/soc/sof/ipc4-topology.c

2106

fifo_size = DIV_ROUND_UP((SOF_IPC4_CHAIN_DMA_BUF_SIZE_MS *

sound/soc/sof/ipc4-topology.c

3061

ext_pos = DIV_ROUND_UP(sizeof(*ext_init), sizeof(u32));

sound/soc/sof/ipc4-topology.c

3070

SOF_IPC4_MOD_INIT_EXT_OBJ_WORDS(DIV_ROUND_UP(sizeof(*dp_mem_data),

sound/soc/sof/ipc4-topology.c

3072

ext_pos += DIV_ROUND_UP(sizeof(*hdr), sizeof(u32));

sound/soc/sof/ipc4-topology.c

3077

ext_pos += DIV_ROUND_UP(sizeof(*dp_mem_data), sizeof(u32));

sound/soc/sof/ipc4-topology.c

3098

msg->extension |= SOF_IPC4_MOD_EXT_PARAM_SIZE(DIV_ROUND_UP(new_size, sizeof(u32)));

sound/soc/ti/davinci-mcasp.c

1073

max_active_serializers = DIV_ROUND_UP(channels, slots);

sound/soc/ti/davinci-mcasp.c

1206

active_serializers = DIV_ROUND_UP(channels, active_slots);

sound/soc/ti/davinci-mcasp.c

1217

active_serializers = DIV_ROUND_UP(channels, total_slots);

sound/soc/xilinx/xlnx_formatter_pcm.c

533

bytes_per_ch = DIV_ROUND_UP(params_period_bytes(params), active_ch);

sound/usb/endpoint.c

1220

max_packs_per_period = DIV_ROUND_UP(ep->cur_period_bytes, minsize);

sound/usb/endpoint.c

1223

urbs_per_period = DIV_ROUND_UP(max_packs_per_period,

sound/usb/endpoint.c

1226

urb_packs = DIV_ROUND_UP(max_packs_per_period, urbs_per_period);

sound/usb/endpoint.c

1229

ep->max_urb_frames = DIV_ROUND_UP(ep->cur_period_frames,

sound/usb/misc/ua101.c

39

#define MAX_MEMORY_BUFFERS DIV_ROUND_UP(MAX_QUEUE_LENGTH, \

sound/usb/mixer.c

1372

DIV_ROUND_UP(cval->max - cval->min, cval->res);

sound/usb/mixer.c

264

return DIV_ROUND_UP(cval->max - cval->min, cval->res);

sound/xen/xen_snd_front_alsa.c

444

stream->num_pages = DIV_ROUND_UP(stream->buffer_sz, PAGE_SIZE);

tools/include/linux/bitops.h

18

#define BITS_TO_LONGS(nr) DIV_ROUND_UP(nr, BITS_PER_TYPE(long))

tools/include/linux/bitops.h

19

#define BITS_TO_U64(nr) DIV_ROUND_UP(nr, BITS_PER_TYPE(u64))

tools/include/linux/bitops.h

20

#define BITS_TO_U32(nr) DIV_ROUND_UP(nr, BITS_PER_TYPE(u32))

tools/include/linux/bitops.h

21

#define BITS_TO_BYTES(nr) DIV_ROUND_UP(nr, BITS_PER_TYPE(char))

tools/perf/ui/progress.c

23

u64 nr = DIV_ROUND_UP(p->curr - last, p->step);

tools/perf/util/blake2s.c

132

const size_t nblocks = DIV_ROUND_UP(inlen, BLAKE2S_BLOCK_SIZE);

tools/testing/selftests/iommu/iommufd.c

2154

size = DIV_ROUND_UP(self->bitmap_size, BITS_PER_BYTE);

tools/testing/selftests/iommu/iommufd_utils.h

469

unsigned long bitmap_size = DIV_ROUND_UP(nbits, BITS_PER_BYTE);

tools/testing/selftests/kvm/lib/kvm_util.c

2217

n = DIV_ROUND_UP(size, vm_guest_mode_params[mode].page_size);

tools/testing/selftests/kvm/x86/amx_test.c

274

xstate = vm_vaddr_alloc_pages(vm, DIV_ROUND_UP(XSAVE_SIZE, PAGE_SIZE));

tools/testing/selftests/kvm/x86/amx_test.c

275

memset(addr_gva2hva(vm, xstate), 0, PAGE_SIZE * DIV_ROUND_UP(XSAVE_SIZE, PAGE_SIZE));

tools/testing/vsock/vsock_test.c

2185

} else if (DIV_ROUND_UP(ns, NSEC_PER_SEC) >= LINGER_TIMEOUT) {

virt/kvm/kvm_main.c

2385

n = DIV_ROUND_UP(log->num_pages, BITS_PER_LONG); n--;