arch/arm/net/bpf_jit_32.c

246

return div64_u64(dividend, divisor);

arch/arm64/kernel/topology.c

108

ratio = div64_u64(ratio, max_rate);

arch/arm64/kernel/topology.c

149

scale = div64_u64(scale >> SCHED_CAPACITY_SHIFT,

arch/mips/net/bpf_jit_comp32.c

549

addr = (u32)&div64_u64;

arch/parisc/net/bpf_jit_core.c

198

div = div64_u64(div, divisor);

arch/x86/hyperv/hv_init.c

204

tsc_khz = div64_u64(freq, 1000);

arch/x86/kernel/cpu/aperfmperf.c

455

freq_scale = div64_u64(acnt, mcnt);

arch/x86/kernel/cpu/aperfmperf.c

530

return div64_u64((cpu_khz * acnt), mcnt);

arch/x86/kernel/tsc.c

398

deltatsc = div64_u64(deltatsc, tmp);

arch/x86/kvm/hyperv.c

1741

data = div64_u64(1000000000ULL,

arch/x86/kvm/i8254.c

44

#define mod_64(x, y) ((x) - (y) * div64_u64(x, y))

arch/x86/kvm/lapic.c

1670

return div64_u64(ns, (apic->vcpu->kvm->arch.apic_bus_cycle_ns *

arch/x86/kvm/lapic.c

51

#define mod_64(x, y) ((x) - (y) * div64_u64(x, y))

block/bfq-cgroup.c

1212

v = div64_u64(v, samples);

block/blk-iocost.c

1015

vrate = div64_u64(vrate * (100 + VRATE_CLAMP_ADJ_PCT), 100);

block/blk-iocost.c

1018

vrate = div64_u64(vrate * (100 - VRATE_CLAMP_ADJ_PCT), 100);

block/blk-iocost.c

1211

hwa = div64_u64((u64)hwa * active, active_sum);

block/blk-iocost.c

1214

hwi = div64_u64((u64)hwi * inuse, inuse_sum);

block/blk-iocost.c

1245

hwm = div64_u64((u64)hwm * inuse, child_inuse_sum);

block/blk-iocost.c

1372

shift = div64_u64(tdelta, USEC_PER_SEC);

block/blk-iocost.c

1634

*rq_wait_pct_p = div64_u64(rq_wait_ns * 100,

block/blk-iocost.c

1720

iocg->usage_delta_us = div64_u64(vusage_delta, ioc->vtime_base_rate);

block/blk-iocost.c

1772

ioc->vtime_err -= div64_u64(excess * old_hwi, WEIGHT_ONE);

block/blk-iocost.c

2114

usage_pct = div64_u64(100 * ioc->dfgv_usage_us_sum, dur);

block/blk-iocost.c

2225

ioc->vtime_err -= div64_u64(excess * old_hwi,

block/blk-iocost.c

2832

size_nsec = div64_u64(calc_size_vtime_cost(rq, ioc), VTIME_PER_NSEC);

block/blk-iocost.c

797

ioc->timer_slack_ns = div64_u64(

block/blk-iocost.c

831

vrate_pct = div64_u64(ioc->vtime_base_rate * 100, VTIME_PER_USEC);

block/blk-iolatency.c

236

u64 thresh = div64_u64(stat->ps.total, 10);

block/blk-iolatency.c

267

div64_u64(iolat->cur_win_nsec,

block/blk-iolatency.c

441

samples_thresh = max(1ULL, div64_u64(samples_thresh, 100));

block/blk-iolatency.c

955

avg_lat = div64_u64(iolat->lat_avg, NSEC_PER_USEC);

block/blk-iolatency.c

956

cur_win = div64_u64(iolat->cur_win_nsec, NSEC_PER_MSEC);

block/blk-throttle.c

806

jiffy_wait = div64_u64(extra_bytes * HZ, bps_limit);

block/kyber-iosched.c

616

bucket = min_t(unsigned int, div64_u64(latency - 1, divisor),

drivers/accel/habanalabs/common/device.c

61

div64_u64((addr - region->region_base), prop->dram_pci_bar_size) *

drivers/accel/habanalabs/gaudi2/gaudi2.c

10696

num_of_pkts = div64_u64(round_up(size, SZ_2G), SZ_2G);

drivers/acpi/acpi_lpit.c

38

*counter = div64_u64(count * 1000000ULL, residency_info_mem.frequency);

drivers/acpi/acpi_lpit.c

50

*counter = div64_u64(*counter * 1000000ULL, residency_info_ffh.frequency);

drivers/acpi/cppc_acpi.c

1986

div64_u64(caps->nominal_perf * mul, div);

drivers/acpi/cppc_acpi.c

1994

retval = offset + div64_u64(perf * mul, div);

drivers/acpi/cppc_acpi.c

2022

div64_u64(caps->nominal_freq * mul, div);

drivers/acpi/cppc_acpi.c

2032

retval = offset + div64_u64(freq * mul, div);

drivers/base/arch_topology.c

261

capacity = div64_u64(capacity << SCHED_CAPACITY_SHIFT,

drivers/base/arch_topology.c

365

capacity = div64_u64(capacity << SCHED_CAPACITY_SHIFT,

drivers/clk/analogbits/wrpll-cln28hpc.c

266

ratio = div64_u64((target_vco_rate << ROUND_SHIFT), parent_rate);

drivers/clk/bcm/clk-iproc-pll.c

100

ndiv_frac = div64_u64((u64)residual, (u64)parent_rate);

drivers/clk/clk-apple-nco.c

211

return div64_u64(((u64) parent_rate) * 2 * incbase,

drivers/clk/clk-pwm.c

120

clk_pwm->fixed_rate = div64_u64(NSEC_PER_SEC, pargs.period);

drivers/clk/clk-rp1.c

808

calc_rate = div64_u64(calc_rate, div);

drivers/clk/clk-si5341.c

661

f = div64_u64(f, (n_num >> 4));

drivers/clk/clk-si570.c

154

data->fxtal = div64_u64(fdco << 24, data->rfreq >> 4);

drivers/clk/clk-si570.c

156

data->fxtal = div64_u64(fdco << 28, data->rfreq);

drivers/clk/clk-si570.c

216

*out_rfreq = div64_u64(fdco << 28, data->fxtal);

drivers/clk/clk-si570.c

263

if (div64_u64(abs(req->rate - data->frequency) * 10000LL,

drivers/clk/clk-si570.c

265

rfreq = div64_u64((data->rfreq * req->rate) +

drivers/clk/clk-si570.c

266

div64_u64(data->frequency, 2),

drivers/clk/clk-si570.c

336

data->rfreq = div64_u64((data->rfreq * frequency) +

drivers/clk/clk-si570.c

361

if (div64_u64(abs(rate - data->frequency) * 10000LL,

drivers/clk/clk-versaclock5.c

527

return div64_u64((u64)f_in << 24ULL, ((u64)div_int << 24ULL) + div_frc);

drivers/clk/clk-versaclock5.c

559

req->rate = div64_u64((u64)f_in << 24ULL, ((u64)div_int << 24ULL) + div_frc);

drivers/clk/clk-versaclock7.c

1022

iod_rate = div64_u64(parent_rate, iod->iod_int);

drivers/clk/clk-versaclock7.c

743

refin_div = div64_u64(xtal_rate, vc7->clk_apll.xo_ib_h_div);

drivers/clk/clk-versaclock7.c

777

*div_frac = div64_u64(rem << VC7_FOD_DENOMINATOR_BITS, rate);

drivers/clk/clk-versaclock7.c

794

return div64_u64(parent_rate, fod_1st_int);

drivers/clk/clk-versaclock7.c

812

return div64_u64(fod_1st_stage_rate >> 1, fod_2nd_int);

drivers/clk/clk-versaclock7.c

976

iod_rate = div64_u64(parent_rate, iod->iod_int);

drivers/clk/clk-versaclock7.c

994

iod_rate = div64_u64(req->best_parent_rate, iod->iod_int);

drivers/clk/nxp/clk-lpc32xx.c

597

m_i = div64_u64(o * n_i * (1 << p_i), i);

drivers/clk/nxp/clk-lpc32xx.c

632

o = div64_u64(i * m, n * (1 << p));

drivers/clk/nxp/clk-lpc32xx.c

679

m = div64_u64(192000000 * d_i * n_i, o);

drivers/clk/nxp/clk-lpc32xx.c

690

req->best_parent_rate = div64_u64(o, d_i);

drivers/clk/pistachio/clk-pll.c

216

vco = div64_u64(vco, params->refdiv << 24);

drivers/clk/pistachio/clk-pll.c

222

val = div64_u64(params->fref, params->refdiv);

drivers/clk/pistachio/clk-pll.c

97

return div64_u64(dividend, divisor);

drivers/clk/qcom/clk-rcg2.c

443

m = div64_u64(rate, rates_gcd);

drivers/clk/qcom/clk-rcg2.c

444

scaled_parent_rate = div64_u64(parent_rate, rates_gcd);

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

158

numerator = div64_u64(numerator, denominator);

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

136

return div64_u64(numerator, denominator);

drivers/clk/st/clkgen-fsyn.c

639

*rate = (unsigned long)div64_u64(input * P20 * 32, res);

drivers/clk/st/clkgen-fsyn.c

657

*p = div64_u64(*p, val);

drivers/clk/xilinx/clk-xlnx-clock-wizard.c

401

mdmin = max(dmin, div64_u64(parent_rate * m + vcomax / 2, vcomax));

drivers/clk/xilinx/clk-xlnx-clock-wizard.c

402

mdmax = min(dmax, div64_u64(parent_rate * m + vcomin / 2, vcomin));

drivers/cpufreq/amd-pstate.c

563

cpudata->freq = div64_u64((cpudata->cur.aperf * cpu_khz), cpudata->cur.mperf);

drivers/cpufreq/cppc_cpufreq.c

89

local_freq_scale = div64_u64(perf, cpu_data->perf_caps.highest_perf);

drivers/cpufreq/intel_pstate.c

91

return div64_u64(x << EXT_FRAC_BITS, y);

drivers/cpuidle/governors/menu.c

479

new_factor += div64_u64(RESOLUTION * measured_ns,

drivers/cxl/core/region.c

3043

bits_upper = div64_u64(hpa_offset >> (eig + eiw), 3);

drivers/cxl/core/region.c

3363

interleave_index = div64_u64(offset, interleave_width);

drivers/dpll/zl3073x/dpll.c

995

out.esync_n_period = div64_u64(synth_freq, frequency * out.div);

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

868

pbn_div_x100 = div64_u64(dividend, divisor);

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

163

vsync_rate_hz = div64_u64(div64_u64((

drivers/gpu/drm/amd/display/dc/dc_dmub_srv.c

1252

cntl->data.line_time_in_ns = 1u + (uint32_t)(div64_u64(stream->timing.h_total * 1000000ull,

drivers/gpu/drm/amd/display/dc/dc_dmub_srv.c

613

drr_frame_us = div64_u64(((uint64_t)drr_timing->v_total * drr_timing->h_total * 1000000),

drivers/gpu/drm/amd/display/dc/dc_dmub_srv.c

616

mall_region_us = div64_u64(((uint64_t)phantom_timing->v_addressable * phantom_timing->h_total * 1000000),

drivers/gpu/drm/amd/display/dc/dc_dmub_srv.c

619

min_vtotal_supported = div64_u64(((uint64_t)drr_timing->pix_clk_100hz * 100 * min_drr_supported_us),

drivers/gpu/drm/amd/display/dc/dc_dmub_srv.c

622

prefetch_us = div64_u64(((uint64_t)(phantom_timing->v_total - phantom_timing->v_front_porch) * phantom_timing->h_total * 1000000),

drivers/gpu/drm/amd/display/dc/dc_dmub_srv.c

624

subvp_active_us = div64_u64(((uint64_t)main_timing->v_addressable * main_timing->h_total * 1000000),

drivers/gpu/drm/amd/display/dc/dc_dmub_srv.c

626

drr_active_us = div64_u64(((uint64_t)drr_timing->v_addressable * drr_timing->h_total * 1000000),

drivers/gpu/drm/amd/display/dc/dc_dmub_srv.c

628

max_drr_vblank_us = div64_u64((subvp_active_us - prefetch_us -

drivers/gpu/drm/amd/display/dc/dc_dmub_srv.c

632

max_vtotal_supported = div64_u64(((uint64_t)drr_timing->pix_clk_100hz * 100 * max_drr_supported_us),

drivers/gpu/drm/amd/display/dc/dc_dmub_srv.c

742

subvp0_prefetch_us = div64_u64(((uint64_t)(phantom_timing0->v_total - phantom_timing0->v_front_porch) *

drivers/gpu/drm/amd/display/dc/dc_dmub_srv.c

745

subvp1_prefetch_us = div64_u64(((uint64_t)(phantom_timing1->v_total - phantom_timing1->v_front_porch) *

drivers/gpu/drm/amd/display/dc/dc_dmub_srv.c

755

div64_u64(((uint64_t)(dc->caps.subvp_prefetch_end_to_mall_start_us + prefetch_delta_us) *

drivers/gpu/drm/amd/display/dc/dc_dmub_srv.c

763

div64_u64(((uint64_t)(dc->caps.subvp_prefetch_end_to_mall_start_us + prefetch_delta_us) *

drivers/gpu/drm/amd/display/dc/dc_dmub_srv.c

834

div64_u64(((uint64_t)dc->caps.subvp_prefetch_end_to_mall_start_us * ((uint64_t)phantom_timing->pix_clk_100hz * 100) +

drivers/gpu/drm/amd/display/dc/dc_dmub_srv.c

837

div64_u64(((uint64_t)(dc->caps.subvp_fw_processing_delay_us) * ((uint64_t)phantom_timing->pix_clk_100hz * 100) +

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

133

min_hardware_refresh_in_uhz = div64_u64((pix_clk_100hz * 100000000ULL),

drivers/gpu/drm/amd/display/dc/hwss/dce110/dce110_hwseq.c

786

div64_u64(dm_get_elapse_time_in_ns(

drivers/gpu/drm/amd/display/dc/hwss/dce110/dce110_hwseq.c

791

div64_u64(dm_get_elapse_time_in_ns(

drivers/gpu/drm/amd/display/dc/hwss/dce110/dce110_hwseq.c

914

div64_u64(dm_get_elapse_time_in_ns(

drivers/gpu/drm/amd/display/dc/link/protocols/link_dp_panel_replay.c

63

unsigned int vsync_rate_hz = div64_u64(div64_u64(

drivers/gpu/drm/amd/display/dc/link/protocols/link_edp_panel_control.c

818

psr_context->vsync_rate_hz = div64_u64(div64_u64((stream->

drivers/gpu/drm/amd/display/dc/sspl/spl_os_types.h

36

return div64_u64(dividend, divisor);

drivers/gpu/drm/amd/display/modules/freesync/freesync.c

1000

min_hardware_refresh_in_uhz = div64_u64((stream->timing.pix_clk_100hz * 100000000ULL),

drivers/gpu/drm/amd/display/modules/freesync/freesync.c

107

((unsigned int)(div64_u64((1000000000ULL * 1000),

drivers/gpu/drm/amd/display/modules/freesync/freesync.c

118

(unsigned int)(div64_u64(((unsigned long long)(v_total)

drivers/gpu/drm/amd/display/modules/freesync/freesync.c

147

((unsigned int)(div64_u64((1000000000ULL * 1000000),

drivers/gpu/drm/amd/display/modules/freesync/freesync.c

155

v_total = div64_u64(div64_u64(((unsigned long long)(

drivers/gpu/drm/amd/display/modules/freesync/freesync.c

163

v_total = div64_u64(div64_u64(((unsigned long long)(

drivers/gpu/drm/amd/display/modules/freesync/freesync.c

167

v_total = div64_u64(div64_u64(((unsigned long long)(

drivers/gpu/drm/amd/display/modules/freesync/freesync.c

202

v_total = div64_u64(div64_u64(((unsigned long long)(

drivers/gpu/drm/amd/display/modules/freesync/freesync.c

233

unsigned int frame_duration_ratio = div64_u64(1000000,

drivers/gpu/drm/amd/display/modules/freesync/freesync.c

234

(1000 + div64_u64(((unsigned long long)(

drivers/gpu/drm/amd/display/modules/freesync/freesync.c

240

unsigned int frame_duration_delta = div64_u64(((unsigned long long)(

drivers/gpu/drm/amd/display/modules/freesync/freesync.c

247

unsigned int ramp_rate_interpolated = div64_u64(((unsigned long long)(

drivers/gpu/drm/amd/display/modules/freesync/freesync.c

278

v_total = div64_u64(div64_u64(((unsigned long long)(

drivers/gpu/drm/amd/display/modules/freesync/freesync.c

97

((unsigned int)(div64_u64((1000000000ULL * 1000000),

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

2363

n = div64_u64((u64)1024 * curr_vddc * curr_vddc * ((u64)1000 + margin), (u64)1000);

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

2365

pwr_efficiency_ratio = div64_u64(n, d);

drivers/gpu/drm/amd/ras/ras_mgr/amdgpu_ras_mgr.c

133

div64_u64(adev->gmc.mc_vram_size, TYPICAL_ECC_BAD_PAGE_RATE);

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

176

return div64_u64((ras_ring_wptr_dw << 2), sizeof(struct psp_gfx_rb_frame));

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

203

div64_u64(ring_mem->mem_size, sizeof(struct psp_gfx_rb_frame));

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

61

kcrtc_st->clock_ratio = div64_u64(aclk << 32, pxlclk);

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

1626

scale = div64_u64(period * pdata->pwm_refclk_freq, (u64)NSEC_PER_SEC * pre_div) - 1;

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

1639

backlight = div64_u64(state->duty_cycle * pdata->pwm_refclk_freq,

drivers/gpu/drm/gud/gud_drv.c

333

u64 ratio_frac = div64_u64(remainder * 10, gdrm->stats_actual_length);

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

232

f_kHz = div64_u64((u64)1000000000 * (u64)m_pll,

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

488

tu_data = div64_u64(mul_u32_u32(pixel_clk * vdsc_bppx16 * 8, 1000000),

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

490

tu_line = div64_u64(h_active * mul_u32_u32(link_clk, fec_coeff),

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

2409

mpll_tx_clk_div = ilog2(div64_u64((u64)CLOCK_9999MHZ, (u64)datarate));

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

2410

vco_freq_shift = ilog2(div64_u64((u64)CLOCK_4999MHZ * (u64)256, (u64)datarate));

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

2412

multiplier = div64_u64((vco_freq << 28), (REFCLK_38_4_MHZ >> 4));

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

2418

mpll_div_multiplier = min_t(u8, div64_u64((vco_freq * 16 + (datarate >> 1)),

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

486

hdr, div64_u64(crtc->debug.vbl.sum, count));

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

172

return div64_u64(mul_u32_u32(intel_dp_link_symbol_clock(crtc_state->port_clock) * 72,

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

1533

deviation = div64_u64(10000 * abs_diff(dco_freq, central_freq),

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

1421

val = div64_u64((u64)y * frequency_khz, 200);

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

1422

m2div = div64_u64(((u64)(val) << 32), refclk_khz);

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

1425

val_with_frac = div64_u64(val_with_frac, 500);

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

1429

ppm = div64_u64(temp0, val);

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

1590

m2div = div64_u64(target_dco_mhz, (refclk_khz * ndiv * m1div));

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

1605

temp1 = div64_u64(((4 * TDC_RES_MULTIPLIER) + temp0) * 500, temp0 * refclk_khz);

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

1606

temp2 = div64_u64(temp0 * refclk_khz, 1000);

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

1607

temp3 = div64_u64(((8 * TDC_RES_MULTIPLIER) + temp2), temp2);

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

1612

feedfwd_gain = (m2div_frac > 0) ? div64_u64(m1div * TDC_RES_MULTIPLIER, temp0) : 0;

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

168

tx_clk_div = ilog2(div64_u64(INTEL_SNPS_PHY_HDMI_9999MHZ, datarate));

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

171

tx_clk_div = ilog2(div64_u64(INTEL_SNPS_PHY_HDMI_16GHZ, datarate));

drivers/gpu/drm/i915/gem/selftests/i915_gem_context.c

173

prime - 1, div64_u64(ktime_to_ns(times[1]), prime - 1));

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

135

busy, (int)div64_u64(100 * busy, dt),

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

289

de, (int)div64_u64(100 * de, dt), dt);

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

328

de, (int)div64_u64(100 * de, dt), dt);

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

3824

prime, div64_u64(ktime_to_ns(times[1]), prime));

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

885

div64_u64(mul_u32_u32(4 * sz,

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

968

div64_u64(mul_u32_u32(4 * sz,

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

125

rc6_power = div64_u64(NSEC_PER_SEC * rc6_sample_energy[1],

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

90

rc0_power = div64_u64(NSEC_PER_SEC * rc0_sample_energy[1],

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

1110

return div64_u64(1000 * 1000 * dE, dt);

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

552

return div64_u64(1000 * 1000 * dc, dt);

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

581

return div64_u64(1000 * 1000 * dc, dt);

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

1108

prime, div64_u64(ktime_to_ns(times[1]), prime));

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

2924

integer = div64_u64(busy, dt);

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

2926

decimal = div64_u64(100 * busy, dt);

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

3269

integer = div64_u64(busy, dt);

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

3271

decimal = div64_u64(100 * busy, dt);

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

638

prime, div64_u64(ktime_to_ns(times[1]), prime));

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

1282

div64_u64(mul_u32_u32(4 * size,

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

310

n_objects = div64_u64(total, target);

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

66

max_pages = div64_u64(total, page_size);

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

174

norm = (u32)div64_u64(busy_cycles * PMU_BUSY_CYCLES_NORM_MAX,

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

3587

#define TO_DSI_T(x) ((u32)div64_u64((u64)x * 1000000000llu, byteclk))

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

3618

#define TO_DISPC_T(x) ((u32)div64_u64((u64)x * 1000000000llu, pck))

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

3647

pck = (u32)div64_u64(dsi_tput, t->bitspp);

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

3652

vm.hsync_len = div64_u64((u64)(t->hsa + t->hse) * pck, byteclk);

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

3653

vm.hback_porch = div64_u64((u64)t->hbp * pck, byteclk);

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

3654

vm.hfront_porch = div64_u64((u64)t->hfp * pck, byteclk);

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

3822

dsi_htot = div64_u64((u64)panel_htot * byteclk, req_pck_nom);

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

3832

dispc_htot = div64_u64((u64)dsi_htot * dispc_pck, byteclk);

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

3855

hsa = div64_u64((u64)req_vm->hsync_len * byteclk, req_pck_nom);

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

3859

hbp = div64_u64((u64)req_vm->hback_porch * byteclk, req_pck_nom);

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

3910

hsa = div64_u64((u64)req_vm->hsync_len * dispc_pck,

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

3917

hbp = div64_u64((u64)req_vm->hback_porch * dispc_pck, req_pck_nom);

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

4035

byteclk_min = div64_u64((u64)ctx->req_pck_min * bitspp, ndl * 8);

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

4042

byteclk_max = div64_u64((u64)ctx->req_pck_max * bitspp,

drivers/gpu/drm/radeon/ni_dpm.c

1422

tmp = div64_u64(n, d);

drivers/gpu/drm/radeon/si_dpm.c

2200

n = div64_u64((u64)1024 * curr_vddc * curr_vddc * ((u64)1000 + margin), (u64)1000);

drivers/gpu/drm/radeon/si_dpm.c

2202

pwr_efficiency_ratio = div64_u64(n, d);

drivers/gpu/drm/renesas/rcar-du/rcar_mipi_dsi.c

358

fout = div64_u64((u64)fpfd * m, dsi->info->n_mul);

drivers/gpu/drm/renesas/rcar-du/rcar_mipi_dsi.c

363

fout = div64_u64(fout, setup_info->vclk_divider);

drivers/gpu/drm/sysfb/drm_sysfb_screen_info.c

63

return drm_sysfb_get_validated_int0(dev, "stride", lfb_linelength, div64_u64(size, height));

drivers/gpu/drm/tegra/sor.c

1176

params.ratio = div64_u64(input * f, output);

drivers/gpu/drm/xe/tests/xe_bo.c

476

purgeable += div64_u64(purgeable, 5);

drivers/gpu/drm/xe/xe_oa.c

2106

oa_freq_hz = div64_u64(NSEC_PER_SEC, oa_period);

drivers/gpu/drm/xe/xe_sriov_vf_ccs.c

128

ccs_mem_size = div64_u64(sys_mem_size, NUM_BYTES_PER_CCS_BYTE(xe));

drivers/hwmon/aspeed-g6-pwm-tach.c

195

expect_period = div64_u64(ULLONG_MAX, (u64)priv->clk_rate);

drivers/hwmon/aspeed-g6-pwm-tach.c

210

div_l = div64_u64(priv->clk_rate * expect_period, divisor);

drivers/hwmon/aspeed-g6-pwm-tach.c

223

duty_pt = div64_u64(state->duty_cycle * priv->clk_rate,

drivers/hwmon/ibmaem.c

846

(unsigned long long)div64_u64(delta * NSEC_PER_SEC, time));

drivers/hwmon/ntc_thermistor.c

421

return div64_u64(dividend, divisor);

drivers/hwmon/occ/common.c

699

user_power_cap = div64_u64(value, 1000000ULL); /* microwatt to watt */

drivers/hwmon/pmbus/ina233.c

153

calibration = div64_u64(5120000000ULL, (u64)rshunt * current_lsb);

drivers/hwmon/pmbus/ina233.c

45

scaled_m = div64_u64(1000000 * scale_coef, (u64)current_lsb * power_coef);

drivers/hwmon/scmi-hwmon.c

67

*value = div64_u64(*value, f);

drivers/iio/adc/nxp-sar-adc.c

224

ndelay(div64_u64(NSEC_PER_SEC, clk_get_rate(info->clk) * 3));

drivers/iio/adc/nxp-sar-adc.c

471

ndelay(div64_u64(NSEC_PER_SEC, clk_get_rate(info->clk)) * 80);

drivers/iio/common/ssp_sensors/ssp_iio_sensor.h

70

return div64_u64((u64)SSP_FACTOR_WITH_MS, value);

drivers/iio/imu/inv_icm42600/inv_icm42600_accel.c

335

value = div64_u64(roc * MICRO, freq_uhz * (u64)convert);

drivers/iio/industrialio-gts-helper.c

41

return div64_u64(full, scale);

drivers/iio/test/iio-test-rescale.c

643

return (int)div64_u64(err, abs(exp));

drivers/infiniband/hw/cxgb4/device.c

130

#define ts2ns(ts) div64_u64((ts) * dev->rdev.lldi.cclk_ps, 1000)

drivers/leds/rgb/leds-qcom-lpg.c

467

min_period = div64_u64((u64)NSEC_PER_SEC * ((1 << pwm_resolution_arr[0]) - 1),

drivers/leds/rgb/leds-qcom-lpg.c

473

max_period = div64_u64((u64)NSEC_PER_SEC * max_res * LPG_MAX_PREDIV * (1 << LPG_MAX_M),

drivers/leds/rgb/leds-qcom-lpg.c

501

ratio = div64_u64(numerator, denominator);

drivers/leds/rgb/leds-qcom-lpg.c

542

val = div64_u64(duty * clk_rate,

drivers/macintosh/rack-meter.c

234

load = div64_u64(9 * (total_nsecs - idle_nsecs), total_nsecs);

drivers/md/bcache/sysfs.c

1099

sum = div64_u64(sum, n);

drivers/md/bcache/sysfs.c

713

return div64_u64(c->gc_stats.key_bytes * 100,

drivers/md/bcache/sysfs.c

720

? div64_u64(c->gc_stats.data, c->gc_stats.nkeys)

drivers/md/bcache/writeback.c

48

div64_u64(bdev_nr_sectors(dc->bdev) << WRITEBACK_SHARE_SHIFT,

drivers/md/dm-cache-policy-smq.c

1750

mq->cache_blocks_per_hotspot_block = div64_u64(mq->hotspot_block_size, mq->cache_block_size);

drivers/md/dm-verity-fec.c

421

res = div64_u64(offset, v->fec->rounds << v->data_dev_block_bits);

drivers/md/dm-verity-fec.c

709

fec_blocks = div64_u64(f->rounds * f->roots, v->fec->roots << SECTOR_SHIFT);

drivers/md/md.c

8771

rt = div64_u64(rt, db/32+1);

drivers/media/dvb-core/dvb_demux.c

425

speed_bytes = 1000 * div64_u64(speed_bytes,

drivers/media/dvb-core/dvb_demux.c

431

div64_u64(speed_bytes,

drivers/media/i2c/ds90ub913.c

686

scl_high = div64_u64((u64)scl_high * ref, 1000000000);

drivers/media/i2c/ds90ub913.c

687

scl_low = div64_u64((u64)scl_low * ref, 1000000000);

drivers/media/i2c/ds90ub953.c

814

scl_high = div64_u64((u64)scl_high * ref, 1000000000) - 5;

drivers/media/i2c/ds90ub953.c

815

scl_low = div64_u64((u64)scl_low * ref, 1000000000) - 5;

drivers/media/i2c/st-mipid02.c

324

ui_4 = div64_u64(ui_4, link_freq);

drivers/media/i2c/tc358746.c

575

return div64_u64((u64)cfg_val * clk_hz + time_base - 1, time_base);

drivers/media/i2c/vgxy61.c

482

return div64_u64((u64)sensor->data_rate_in_mbps * sensor->nb_of_lane,

drivers/media/i2c/vgxy61.c

569

max_bit_per_line = div64_u64(line_rate, sensor->pclk) - mipi_margin;

drivers/media/pci/intel/ipu6/ipu6-isys-video.c

816

stream_data_rate = div64_u64(pb_bytes_per_line * 1000, line_time_ns);

drivers/media/pci/intel/ipu6/ipu6-isys.c

580

calc_fill_time_us = div64_u64(max_sram_size, isys_pb_datarate_mbs);

drivers/media/platform/ti/vpe/sc.c

202

lin_acc_inc = div64_u64(((u64)(src_w >> dcm_shift) - 1) << 24, lltmp);

drivers/media/tuners/fc2580.c

240

uitmp = div64_u64((u64) dev->clk * uitmp, 1000000000000ULL);

drivers/mtd/spi-nor/otp.c

244

return div64_u64(ofs, spi_nor_otp_region_len(nor));

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_b0.c

1245

nsi = div64_u64(base_ns, NSEC_PER_SEC);

drivers/net/ethernet/broadcom/bnxt/bnxt_ptp.c

436

*cycles_delta = div64_u64(nsec_delta << ptp->cc.shift, ptp->cc.mult);

drivers/net/ethernet/engleder/tsnep_selftests.c

164

n = div64_u64(system_time - base_time, qopt->cycle_time);

drivers/net/ethernet/engleder/tsnep_selftests.c

196

u64 n = div64_u64(system_time - gcl->base_time, gcl->cycle_time);

drivers/net/ethernet/engleder/tsnep_selftests.c

253

n = div64_u64(curr->start_time - start_before,

drivers/net/ethernet/engleder/tsnep_tc.c

139

n = div64_u64(limit - start, gcl->cycle_time);

drivers/net/ethernet/engleder/tsnep_tc.c

151

n = div64_u64(limit - start, gcl->cycle_time);

drivers/net/ethernet/freescale/dpaa2/dpaa2-eth-debugfs.c

113

div64_u64(ch->stats.frames, ch->stats.cdan),

drivers/net/ethernet/freescale/enetc/enetc_qos.c

731

n = div64_u64(now, cycle);

drivers/net/ethernet/intel/ice/ice_ptp.c

1740

start = div64_u64(clk + period - 1, period) * period + phase;

drivers/net/ethernet/mellanox/mlx4/en_clock.c

255

u64 max_mul = div64_u64(ULLONG_MAX, max_val_cycles_rounded);

drivers/net/ethernet/mellanox/mlx5/core/debugfs.c

140

field = div64_u64(stats->sum, stats->n);

drivers/net/ethernet/mellanox/mlx5/core/en/htb.c

263

share = div64_u64(div_u64(rate * 100, BYTES_IN_MBIT),

drivers/net/ethernet/mellanox/mlx5/core/en/tc/meter.c

63

m = div64_u64(m, MLX5_CONST_CIR);

drivers/net/ethernet/mellanox/mlx5/core/lib/clock.c

1244

overflow_cycles = div64_u64(~0ULL >> 1, timer->cycles.mult);

drivers/net/ethernet/mellanox/mlx5/core/lib/clock.c

789

cycles_delta = div64_u64(nsec_delta << timer->cycles.shift,

drivers/net/ethernet/mellanox/mlxsw/spectrum_cnt.c

300

if (WARN_ON(total_bank_config > div64_u64(pool_size, bank_size) + 1))

drivers/net/ethernet/mellanox/mlxsw/spectrum_ptp.c

302

overflow_cycles = div64_u64(~0ULL >> 1, clock->cycles.mult);

drivers/net/ethernet/microchip/sparx5/sparx5_sdlb.c

45

return div64_u64((8 * clk_hz * max_token), max_rate);

drivers/net/ethernet/ti/am65-cpsw-qos.c

927

n = div64_u64(cur_time - est_new->taprio.base_time, est_new->taprio.cycle_time);

drivers/net/phy/mscc/mscc_ptp.c

622

adj = div64_u64(1000000ULL * 65536ULL, abs(scaled_ppm));

drivers/net/wireless/intel/iwlwifi/mld/ptp.c

70

div64_u64(base_time_ns, NSEC_PER_USEC));

drivers/net/wireless/intel/iwlwifi/mld/rx.c

1532

rx_status->mactime = div64_u64(adj_time, NSEC_PER_USEC);

drivers/net/wireless/intel/iwlwifi/mvm/ptp.c

55

div64_u64(base_time_ns, NSEC_PER_USEC));

drivers/net/wireless/intel/iwlwifi/mvm/rxmq.c

2022

rx_status->mactime = div64_u64(adj_time, NSEC_PER_USEC);

drivers/ntb/test/ntb_perf.c

1142

div64_u64(pthr->copied, ktime_to_us(pthr->duration)));

drivers/ntb/test/ntb_perf.c

988

div64_u64(pthr->copied, ktime_to_us(pthr->duration)));

drivers/pci/endpoint/functions/pci-epf-test.c

343

rate = div64_u64(size * NSEC_PER_SEC, ns * 1000);

drivers/pinctrl/ti/pinctrl-ti-iodelay.c

192

return div64_u64(m, d);

drivers/platform/x86/intel/pmc/core.c

1067

die_c6_res = div64_u64(count * HZ_PER_MHZ, pmcdev->crystal_freq);

drivers/powercap/intel_rapl_common.c

1125

f = div64_u64(4 * (value - (1ULL << y)), 1ULL << y);

drivers/powercap/intel_rapl_common.c

1141

value = div64_u64(value, rd->time_unit);

drivers/powercap/intel_rapl_common.c

652

return div64_u64(value, units) * scale;

drivers/powercap/intel_rapl_common.c

656

return div64_u64(value, scale);

drivers/ptp/ptp_dte.c

37

#define DTE_PPB_ADJ(ppb) (u32)(div64_u64((((u64)abs(ppb) * BIT(28)) +\

drivers/ptp/ptp_netc.c

223

pulse_width = div64_u64(mul_u32_u32(fiper, priv->clk_freq), divisor);

drivers/pwm/pwm-bcm-iproc.c

104

state->period = div64_u64(tmp, rate);

drivers/pwm/pwm-bcm-iproc.c

108

state->duty_cycle = div64_u64(tmp, rate);

drivers/pwm/pwm-bcm-iproc.c

138

period = div64_u64(value, div);

drivers/pwm/pwm-bcm-iproc.c

140

duty = div64_u64(value, div);

drivers/pwm/pwm-lpc32xx.c

40

period_cycles = div64_u64(c * period_ns,

drivers/pwm/pwm-lpc32xx.c

48

duty_cycles = div64_u64((unsigned long long)(period_ns - duty_ns) * 256,

drivers/pwm/pwm-mc33xs2410.c

252

rel_dc = div64_u64(duty_cycle * 256, period) - 1;

drivers/pwm/pwm-meson.c

180

freq = div64_u64(NSEC_PER_SEC * 0xffffULL, period);

drivers/pwm/pwm-rcar.c

83

tmp = div64_u64(tmp, div);

drivers/pwm/pwm-spear.c

100

dc = div64_u64(val, div);

drivers/pwm/pwm-spear.c

98

pv = div64_u64(val, div);

drivers/pwm/pwm-vt8500.c

106

dc = div64_u64(c, period_ns);

drivers/rtc/rtc-s32g.c

343

if (check_add_overflow(priv->sleep_sec, div64_u64(apival, priv->rtc_hz),

drivers/scsi/lpfc/lpfc_init.c

1327

idle_percent = div64_u64(100 * busy_time, diff_wall);

drivers/scsi/lpfc/lpfc_sli.c

1847

pcent = div64_u64(bwdif * 100 + slop,

drivers/scsi/lpfc/lpfc_sli.c

1849

bwpcent = div64_u64(bw * 100 + slop,

drivers/staging/media/ipu7/ipu7-isys-csi-phy.c

820

delay_thresh = div64_u64((224U - (9U * 7U)) * 1000U, 5U * mbps) - 7u;

drivers/thermal/cpufreq_cooling.c

182

load = div64_u64(100 * (delta_time - delta_idle), delta_time);

drivers/usb/dwc3/core.c

450

fladj = div64_u64(125000ULL * NSEC_PER_SEC, (u64)rate * period);

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

4329

#define TO_DSI_T(x) ((u32)div64_u64((u64)x * 1000000000llu, byteclk))

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

4360

#define TO_DISPC_T(x) ((u32)div64_u64((u64)x * 1000000000llu, pck))

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

4389

pck = (u32)div64_u64(dsi_tput, t->bitspp);

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

4394

vm.hsw = div64_u64((u64)(t->hsa + t->hse) * pck, byteclk);

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

4395

vm.hbp = div64_u64((u64)t->hbp * pck, byteclk);

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

4396

vm.hfp = div64_u64((u64)t->hfp * pck, byteclk);

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

4561

dsi_htot = div64_u64((u64)panel_htot * byteclk, req_pck_nom);

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

4571

dispc_htot = div64_u64((u64)dsi_htot * dispc_pck, byteclk);

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

4594

hsa = div64_u64((u64)req_vm->hsw * byteclk, req_pck_nom);

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

4598

hbp = div64_u64((u64)req_vm->hbp * byteclk, req_pck_nom);

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

4650

hsa = div64_u64((u64)req_vm->hsw * dispc_pck,

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

4657

hbp = div64_u64((u64)req_vm->hbp * dispc_pck, req_pck_nom);

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

4773

byteclk_min = div64_u64((u64)ctx->req_pck_min * bitspp, ndl * 8);

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

4780

byteclk_max = div64_u64((u64)ctx->req_pck_max * bitspp,

drivers/watchdog/xilinx_wwdt.c

171

div64_u64(XWWDT_MAX_COUNT_WINDOW_COMBINED, xdev->freq) * 1000;

drivers/watchdog/xilinx_wwdt.c

196

xdev->closed_timeout = div64_u64(timeout_count * xdev->close_percent, 100);

drivers/watchdog/xilinx_wwdt.c

198

div64_u64(timeout_ms * xdev->close_percent, 100);

fs/btrfs/block-group.c

2964

offset = div64_u64(offset, div);

fs/btrfs/dev-replace.c

1046

ret = div64_u64(dev_replace->cursor_left,

fs/btrfs/discard.c

433

u64 bps_delay = div64_u64(discard_ctl->prev_discard *

fs/btrfs/free-space-cache.c

1576

bitmap_start = div64_u64(bitmap_start, bytes_per_bitmap);

fs/btrfs/free-space-cache.c

2058

tmp = div64_u64(tmp, align);

fs/btrfs/free-space-cache.c

698

u64 max_bitmaps = div64_u64(size + bytes_per_bg - 1, bytes_per_bg);

fs/btrfs/space-info.c

2012

return div64_u64(x, y);

fs/btrfs/space-info.c

699

nr = div64_u64(to_reclaim, bytes);

fs/btrfs/zoned.c

2897

factor = div64_u64(used * 100, total);

fs/ext4/resize.c

1446

reserved_blocks = div64_u64(reserved_blocks, ext4_blocks_count(es));

fs/f2fs/checkpoint.c

2047

cprc->cur_time = (unsigned int)div64_u64(sum_diff, count);

fs/f2fs/debug.c

55

si->bimodal = div64_u64(bimodal, dist);

fs/f2fs/debug.c

668

div64_u64(si->hit_total[EX_READ] * 100,

fs/f2fs/debug.c

682

div64_u64(si->hit_total[EX_BLOCK_AGE] * 100,

fs/f2fs/gc.c

389

age = 100 - div64_u64(100 * (mtime - sit_i->min_mtime),

fs/f2fs/gc.c

579

accu = div64_u64(ULLONG_MAX, total_time);

fs/f2fs/gc.c

593

age = div64_u64(accu * (max_mtime - ve->mtime), total_time) *

fs/f2fs/gc.c

600

u = div64_u64(accu * (sec_blocks - vblocks), sec_blocks) *

fs/f2fs/iostat.c

23

return sbi->iostat_count[type] ? div64_u64(sbi->iostat_bytes[type],

include/linux/kvm_host.h

2072

size_t index = div64_u64(value, bucket_size);

include/linux/math64.h

105

#ifndef div64_u64

include/linux/math64.h

106

extern u64 div64_u64(u64 dividend, u64 divisor);

include/linux/math64.h

13

#define div64_ul(x, y) div64_u64((x), (y))

include/linux/math64.h

355

({ u64 _tmp = (d); div64_u64((ll) + _tmp - 1, _tmp); })

include/linux/math64.h

381

({ u64 _tmp = (divisor); div64_u64((dividend) + _tmp / 2, _tmp); })

kernel/bpf/core.c

1970

DST = div64_u64(DST, SRC);

kernel/bpf/core.c

1997

DST = div64_u64(DST, IMM);

kernel/bpf/verifier.c

15311

*dst_umin = div64_u64(*dst_umin, src_val);

kernel/bpf/verifier.c

15312

*dst_umax = div64_u64(*dst_umax, src_val);

kernel/dma/map_benchmark.c

179

map->bparam.avg_map_100ns = div64_u64(sum_map, loops);

kernel/dma/map_benchmark.c

180

map->bparam.avg_unmap_100ns = div64_u64(sum_unmap, loops);

kernel/dma/map_benchmark.c

183

map_variance = div64_u64(sum_sq_map, loops) -

kernel/dma/map_benchmark.c

186

unmap_variance = div64_u64(sum_sq_unmap, loops) -

kernel/events/core.c

10820

nr = div64_u64(period + val, period);

kernel/events/core.c

4398

return div64_u64(dividend, divisor);

kernel/fork.c

820

threads = div64_u64((u64) nr_pages * (u64) PAGE_SIZE,

kernel/locking/lockdep_proc.c

457

seq_time(m, lt->nr ? div64_u64(lt->total, lt->nr) : 0);

kernel/power/energy_model.c

249

table[i].performance = div64_u64(max_cap * table[i].frequency,

kernel/power/snapshot.c

1695

return div64_u64(x * multiplier, base);

kernel/rcu/rcutorture.c

4104

pr_alert("\t%lluus ", div64_u64(err_segs[i].rt_ts, 1000ULL));

kernel/sched/core.c

4754

return div64_u64(runtime << BW_SHIFT, period);

kernel/sched/debug.c

1315

avg_per_cpu = div64_u64(avg_per_cpu,

kernel/sched/fair.c

3012

f_weight = div64_u64(runtime << 16, period + 1);

kernel/sched/psi.c

457

growth += div64_u64(win->prev_growth * remaining, win->size);

kernel/time/timekeeping.c

1093

rem = div64_u64(rem * mult, div);

kernel/time/timekeeping.c

2185

mult = div64_u64((tk->ntp_tick >> tk->ntp_error_shift) -

kernel/trace/trace_benchmark.c

129

seed = div64_u64(seed, last_seed);

kernel/trace/trace_events_hist.c

367

return div64_u64(val1, val2);

kernel/trace/trace_events_hist.c

395

return div64_u64(val1, operand2->constant);

kernel/trace/trace_events_hist.c

429

return div64_u64(val1, operand2->constant);

kernel/trace/trace_events_hist.c

5563

total = div64_u64(total, 10000);

kernel/trace/trace_events_hist.c

709

divisor->div_multiplier = div64_u64((u64)(1 << HIST_DIV_SHIFT), div);

lib/crc/tests/crc_kunit.c

267

len, div64_u64((u64)len * num_iters * 1000, t));

lib/crypto/tests/curve25519_kunit.c

1346

div64_u64((u64)benchmark_niter * NSEC_PER_SEC, t ?: 1));

lib/crypto/tests/hash-test-template.h

566

div64_u64((u64)len * num_iters * 1000, t ?: 1));

lib/crypto/tests/mldsa_kunit.c

400

div64_u64((u64)benchmark_niter * NSEC_PER_SEC,

lib/crypto/tests/sha256_kunit.c

200

div64_u64((u64)data_len * 2 * num_iters * 1000,

lib/math/div64.c

138

#ifndef div64_u64

lib/math/div64.c

158

EXPORT_SYMBOL(div64_u64);

lib/math/div64.c

166

quot = div64_u64(abs(dividend), abs(divisor));

lib/math/div64.c

251

return div64_u64(n_lo, d);

lib/math/test_mul_u64_u64_div_u64.c

160

#define div64_u64 div64_u64

lib/test_bpf.c

602

*res = div64_u64(v1, v2);

lib/tests/base64_kunit.c

22

return div64_u64(t1 - t0, (u64)reps);

lib/tests/base64_kunit.c

35

return div64_u64(t1 - t0, (u64)reps);

mm/memcontrol.c

2191

return div64_u64(overage, high);

mm/page-writeback.c

1204

pos_ratio = div64_u64(pos_ratio * (x_intercept - dtc->wb_dirty),

mm/page-writeback.c

667

ratio = div64_u64(pages * 100ULL * BDI_RATIO_SCALE, dirty_thresh);

mm/vmscan.c

2624

div64_u64(scan * fraction[file], denominator) :

net/core/pktgen.c

2679

cumulative_prob += div64_u64(pkt_dev->imix_entries[i].weight *

net/core/pktgen.c

3356

pps = div64_u64(pkt_dev->sofar * NSEC_PER_SEC,

net/core/pktgen.c

3368

bps = div64_u64(bps * 8 * NSEC_PER_SEC, ktime_to_ns(elapsed));

net/ipv4/tcp_cubic.c

206

x = (2 * x + (u32)div64_u64(a, (u64)x * (u64)(x - 1)));

net/ipv4/tcp_nv.c

366

div64_u64(((u64)ca->nv_rtt_max_rate) * ca->nv_min_rtt,

net/netfilter/nft_ct.c

147

avgcnt = div64_u64(bcnt, pcnt);

net/netfilter/nft_limit.c

100

tokens = div64_u64(tmp, priv->rate);

net/netfilter/nft_limit.c

206

priv->cost = div64_u64(priv->limit.nsecs, priv->limit.rate);

net/netfilter/nft_limit.c

254

u64 cost = div64_u64(priv->nsecs * pkt->skb->len, priv->rate);

net/netfilter/nft_limit.c

351

priv->cost = div64_u64(priv->limit.nsecs, priv->limit.rate);

net/netfilter/nft_limit.c

387

u64 cost = div64_u64(priv->nsecs * pkt->skb->len, priv->rate);

net/netfilter/nft_limit.c

86

u64 tmp = div64_u64(priv->nsecs, priv->rate);

net/netfilter/xt_connbytes.c

88

what = div64_u64(bytes, pkts);

net/netfilter/xt_hashlimit.c

500

return div64_u64(user, div64_u64(scale, HZ * cpj));

net/netfilter/xt_hashlimit.c

502

return user * div64_u64(HZ * cpj, scale);

net/netfilter/xt_hashlimit.c

515

return div64_u64(XT_HASHLIMIT_SCALE_v2, user);

net/sched/act_gate.c

109

n = div64_u64(ktime_sub_ns(now, base), cycle);

net/sched/act_gate.c

54

n = div64_u64(ktime_sub_ns(now, base), cycle);

net/sched/sch_cake.c

1896

b = div64_u64(b, window_interval);

net/sched/sch_cake.c

2041

new_rate = div64_u64(q->config->rate_bps, num_active_qs);

net/sched/sch_cake.c

2337

rate_ns = div64_u64(rate_ns, max(MIN_RATE, rate));

net/sched/sch_ets.c

143

w_psum = div64_u64(q_psum * 100, q_sum);

net/sched/sch_generic.c

1504

*mult = div64_u64(factor, rate);

net/sched/sch_hfsc.c

601

dx = div64_u64(dx, dsm);

net/sched/sch_netem.c

369

return div64_u64(len * NSEC_PER_SEC, q->rate);

net/sched/sch_taprio.c

675

budget = div64_u64((u64)entry->gate_duration[tc] * PSEC_PER_NSEC,

samples/bpf/hbm_kern.h

58

#define BYTES_TO_NS(bytes, rate) div64_u64(((u64)(bytes)) << 20, (u64)(rate))

sound/core/compress_offload.c

296

u64 app_pointer = div64_u64(runtime->total_bytes_available,

sound/soc/sof/ipc4-mtrace.c

426

system_time = div64_u64(local_clock(), NSEC_PER_USEC);

sound/soc/sof/ipc4-pcm.c

1082

value = div64_u64(value, dai_rate);

sound/soc/sof/ipc4-pcm.c

1086

value = div64_u64(value, dai_rate);

sound/soc/sof/ipc4-pcm.c

1202

host_cnt = div64_u64(host_cnt, frames_to_bytes(substream->runtime, 1));

sound/soc/sti/uniperif_player.c

182

delta *= (int)div64_u64((uint64_t)rate *

sound/soc/sti/uniperif_player.c

212

adjustment *= (int)div64_u64((uint64_t)delta * 1000000 + rate / 2,

sound/usb/mixer_quirks.c

2673

freq = (den == 0) ? 0 : div64_u64(num, den);

sound/x86/intel_hdmi_audio.c

737

cts_val = div64_u64(dividend, divisor);

tools/testing/selftests/bpf/progs/bpf_cc_cubic.c

33

static __u64 div64_u64(__u64 dividend, __u64 divisor)

tools/testing/selftests/bpf/progs/bpf_cc_cubic.c

62

rate = div64_u64(rate, (__u64)tp->srtt_us);

tools/testing/selftests/bpf/progs/bpf_cc_cubic.c

83

sndcnt = (__u32)div64_u64(dividend, (__u64)tp->prior_cwnd) - tp->prr_out;

tools/testing/selftests/bpf/progs/bpf_cubic.c

121

#define div64_ul div64_u64

tools/testing/selftests/bpf/progs/bpf_cubic.c

257

x = (2 * x + (__u32)div64_u64(a, (__u64)x * (__u64)(x - 1)));