rounddown
p_info->act_entry = rounddown(PAGE_SIZE, id->entry_size) - id->entry_size;
rounddown(target, 1 << bb->shift);
rounddown(s, 1 << bb->shift);
rounddown(s, 1 << bb->shift);
time_elapsed = rounddown(jiffies - tg->slice_start[rw],
offset = rounddown(nbytes - 1, bsize);
offset = rounddown(nbytes - 1, bsize);
lower = rounddown((u32)fst->speed - min_trip_distance, fan->fan_trip_granularity);
int rounddown = 0; /* 1 = Round PCR down, i.e. round ICG _up_ */
rounddown = 1;
if (rounddown)
pcr, rounddown ? 'Y' : 'N', icg);
val = rounddown(val, PAGE_SIZE / 4096);
u32 round_freq_6 = rounddown(freq_mhz, 6);
rounddown(UINT_MAX, (unsigned int)NSEC_PER_USEC));
limit = rounddown(limit, (unsigned int)NSEC_PER_SEC);
rounddown(UINT_MAX, (unsigned int)NSEC_PER_USEC));
arg = min(arg, rounddown(UINT_MAX, (unsigned int)NSEC_PER_USEC));
tmp = rounddown(cmd->scan_begin_arg, high_speed ? 125000 : 1000000);
tmp = rounddown(cmd->scan_begin_arg, 1000000);
cpu->pstate.max_freq = rounddown(cpu->pstate.max_freq,
cpu->pstate.turbo_freq = rounddown(cpu->pstate.turbo_freq,
cpu->pstate.turbo_freq = rounddown(cpu->pstate.turbo_pstate * scaling,
cpu->pstate.max_freq = rounddown(cpu->pstate.max_pstate * scaling,
freq = rounddown(freq, cpu->pstate.perf_ctl_scaling);
start_cpu = rounddown(policy->cpu, maxcpus_per_cluster);
bytes = rounddown(bytes, 16);
bytes = rounddown(bytes, 16);
params.sg_len = rounddown(params.sg_len + req_ctx->reqlen, bs) -
params.sg_len = rounddown(params.sg_len + req_ctx->reqlen, bs)
params.sg_len = rounddown(params.sg_len, bs);
params.sg_len = rounddown(params.sg_len, bs);
pset_len = rounddown(len, width);
tlen = rounddown(len, burst_size);
copy = rounddown(copy,
memset32(efi_x_array, rounddown(xres, font->width), ARRAY_SIZE(efi_x_array));
efi_y = rounddown(yres, font->height);
rounded_start = rounddown(start, EFI_PAGE_SIZE);
end = rounddown(sh_memory->addr + sh_memory->size, PAGE_SIZE);
debounce = rounddown(debounce, MEN_Z127_DB_MIN_US);
max_link_bpp_x16 = rounddown(max_link_bpp_x16, fxp_q4_from_int(2 * 3));
offset_aligned = rounddown(offset_aligned, alignment);
offset_aligned = rounddown(offset_aligned, alignment);
pipe_bpp = rounddown(pipe_bpp, 2 * 3);
view.partial.offset = rounddown(page_offset, chunk);
switch (rounddown(offset, 4)) {
offset = rounddown(offset, 4);
e = rounddown(e, mm->block_size);
e = rounddown(e, mm->block_size);
node->length = rounddown(offset + length, mm->block_size);
vsize = rounddown(vsize, 2);
hsize = rounddown(hsize, 2);
rect->x1 = rounddown(rect->x1, 3);
fifo_entries = rounddown(fifo_entries, st->fifo_set_size);
eff = rounddown(AD4130_FIFO_SIZE, st->num_enabled_channels);
dma->fifo_thresh = rounddown(FIFO1_THRESHOLD + 1,
dma->period_size = rounddown(DMA_BUFFER_SIZE / 2,
n = rounddown(n, buffer->bytes_per_datum);
num_cores = rounddown(node_affinity.num_online_cpus / affinity->num_core_siblings,
retval = rounddown(retval - min, step) + min;
retval = rounddown(retval - min, step) + min;
max_hw_discard_sectors = rounddown(max_hw_discard_sectors,
ppl_data_sectors = rounddown(ppl_data_sectors,
? rounddown((dim), (step)) \
: rounddown((dim) + (step) / 2, (step))))
tgt_fps = rounddown(OV5693_PIXEL_RATE / OV5693_FIXED_PPL / height, 30);
/ max(rounddown(tgt_fps, 15), 5)) - format->height;
pix->width = rounddown(pix->width, pixels_in_word);
fsize->stepwise.max_width = rounddown(MAX_WIDTH_BYTES * 8 / fmt->bpp,
max_width = rounddown(XVIP_DMA_MAX_WIDTH, align);
width = rounddown(pix->width * info->bpp, align);
max_bpl = rounddown(XVIP_DMA_MAX_WIDTH, dma->align);
bpl = rounddown(pix->bytesperline, dma->align);
tx_usecs = rounddown(tx_usecs, jiffy_us);
stats_ticks = rounddown(stats_ticks, BNXT_MIN_STATS_COAL_TICKS);
payload[i].end = rounddown(payload[i].end,
txq_info->ntxq = rounddown(i, adap->params.nports);
#define GFAR_RXB_SIZE rounddown(GFAR_RXB_TRUESIZE - GFAR_SKBFRAG_OVR, 64)
fp->indir_table_nentries = rounddown(FUN_ETH_RSS_MAX_INDIR_ENT, nrx);
shared_buf = rounddown(rx_all - rx_priv, HCLGE_BUF_SIZE_UNIT);
hi_thrd = rounddown(hi_thrd, HCLGE_BUF_SIZE_UNIT);
ltb_size = rounddown(IBMVNIC_ONE_LTB_SIZE, buff_size);
aligned_offset = rounddown((offset), 8);
double_size = rounddown(double_size, MLXSW_SP_KVD_GRANULARITY);
*p_double_size = rounddown(double_size,
int cid = rounddown(dst_cid, VCAP_CID_LOOKUP_SIZE);
int min_cid = rounddown(cid, VCAP_CID_LOOKUP_SIZE);
chunk = rounddown(EFX_NVRAM_ERASE_IDEAL_CHUNK_SIZE, align);
chunk = rounddown(write_max, align);
u32 head_len = rounddown(length, 4);
addr_start = rounddown(offset, RK3399_NBYTES) / RK3399_NBYTES;
addr_start = rounddown(offset, RK3399_NBYTES) / RK3399_NBYTES;
roffset = rounddown(offset, 4);
return rounddown(val, 10);
*norm = rounddown(*norm, spz->info->power_cap_step);
*norm = rounddown(*norm, spz->info->pai_step);
size_align = rounddown(*start + *size, alignment) - start_align;
max_iso_data = rounddown(CXGBI_MAX_ISO_DATA_IN_SKB,
rounddown(dlimit,
bufsize = rounddown(bufsize >> 1, SECTOR_SIZE);
f->width = rounddown(clamp_t(u32, f->width, ATOM_ISP_MIN_WIDTH,
f->height = rounddown(clamp_t(u32, f->height, ATOM_ISP_MIN_HEIGHT,
*dvs_env_w = rounddown(width / 5, ATOM_ISP_STEP_WIDTH);
*dvs_env_h = rounddown(height / 5, ATOM_ISP_STEP_HEIGHT);
r->width = rounddown(r->width, ATOM_ISP_STEP_WIDTH);
r->height = rounddown(r->height, ATOM_ISP_STEP_HEIGHT);
dvs_w = rounddown(crop[pad]->width / 5,
dvs_h = rounddown(crop[pad]->height / 5,
rounddown(crop[ATOMISP_SUBDEV_PAD_SINK]->
rounddown(crop[ATOMISP_SUBDEV_PAD_SINK]->
rounddown(css_pipe->rect[IPU3_CSS_RECT_GDC].width -
rounddown(stripe_offset_out_y,
chunk_floor_y = rounddown(stripe_offset_inp_y,
rounddown(stripe_offset_inp_uv,
rounddown(stripe_offset_inp_y,
rounddown(stripe_offset_inp_uv,
next_offset = rounddown(next_offset, 64);
rounddown(stripe_output_width_y,
max_bpl = rounddown(TEGRA210_MAX_WIDTH, SURFACE_ALIGN_BYTES);
max_iso_payload = rounddown(CXGBIT_MAX_ISO_PAYLOAD, csk->emss);
aligned_max_sectors = rounddown(max_sectors, alignment);
end = rounddown(res.result.start + res.result.size, PAGE_SIZE);
start = rounddown(addr, PAGE_SIZE);
new_sel_start = rounddown(ps, vc->vc_size_row);
new_sel_end = rounddown(pe, vc->vc_size_row) +
end_frame_id = rounddown(current_frame_id + 895 * 8, 8);
avail_space = rounddown(avail_space, BTRFS_STRIPE_LEN);
ctl->ndevs = rounddown(ctl->ndevs, ctl->devs_increment);
rounddown(io_geom->stripe_nr, nr_data_stripes(map)));
compacted_2b = rounddown(totalidx - compacted_4b_initial, 16);
start = max(start, rounddown(ac->ac_o_ex.fe_logical,
sec_end_segno = rounddown(end_segno, SEGS_PER_SEC(sbi));
segno = rounddown(segno, sbi->sums_per_block);
segno = rounddown(start_segno, sbi->sums_per_block);
unsigned int block_end_segno = rounddown(segno, sbi->sums_per_block)
start = rounddown(start, SEGS_PER_SEC(sbi));
start_segno = rounddown(start_segno, SEGS_PER_SEC(sbi));
(rounddown(segno, SEGS_PER_SEC(sbi)))
ra_pages = rounddown(ra_pages, sb->s_bdi->io_pages);
entry_start = rounddown(group_offset, epb);
entry_start = rounddown(group_offset, epb);
start = rounddown(paddr, PAGE_SIZE);
start = rounddown(paddr, PAGE_SIZE);
start = rounddown(phdr->p_offset, PAGE_SIZE);
start = rounddown(phdr->p_offset, PAGE_SIZE);
start = rounddown(phdr->p_offset, PAGE_SIZE);
ir_startino = rounddown(ir_startino, XFS_INODES_PER_CHUNK);
return rounddown(rtxlen, prod);
htab->map.max_entries = rounddown(attr->max_entries,
size = rounddown(size, 8);
rb->aux_wakeup = rounddown(rb->aux_head, rb->aux_watermark);
test_hexdump_overflow(buflen, rounddown(len, gs), rs, gs, ascii);
space = rounddown(space, mss);
window = rounddown(free_space, mss);
len = rounddown(avail_wnd, cur_mss);
size_t start = rounddown(offset, sizeof(long));
return rounddown(offsetof(struct sw_flow_key, phy),
mask->range.start = rounddown(first, sizeof(long));
rounddown(bit, BITS_PER_U64) > last_startbit) {
last_startbit = rounddown(bit, BITS_PER_U64);
rounddown(bit, BITS_PER_U64) > last_startbit) {
last_startbit = rounddown(bit, BITS_PER_U64);
last_startbit = rounddown(bit, BITS_PER_U64);
t.max = rounddown(s->max, step);
length = rounddown(remained, sizeof(*entries));
sck_rate = rounddown(pcm512x_pll_max(pcm512x),
for (dac_rate = rounddown(pcm512x_dac_max(pcm512x, 6144000), osr_rate);
max_period_size = rounddown(ASRC_M2M_PERIOD_SIZE, width * pair->channels / 8);