arch/alpha/kernel/time.c

394

long diff;

arch/alpha/kernel/time.c

422

diff = cycle_freq - est_cycle_freq;

arch/alpha/kernel/time.c

423

if (diff < 0)

arch/alpha/kernel/time.c

424

diff = -diff;

arch/alpha/kernel/time.c

425

if ((unsigned long)diff > tolerance) {

arch/arm/mm/pmsa-v7.c

193

phys_addr_t diff = size;

arch/arm/mm/pmsa-v7.c

196

while (diff) {

arch/arm/mm/pmsa-v7.c

201

diff -= size;

arch/arm/mm/pmsa-v7.c

202

size = diff;

arch/arm/mm/pmsa-v7.c

213

phys_addr_t p2size = (1 << __fls(diff)) - 1;

arch/arm64/include/asm/tlbflush.h

597

ptdesc_t diff = oldval ^ newval;

arch/arm64/include/asm/tlbflush.h

604

diff &= ~PTE_SWBITS_MASK;

arch/arm64/include/asm/tlbflush.h

606

return diff;

arch/loongarch/kernel/relocate.c

100

diff = (void *)ptr - area;

arch/loongarch/kernel/relocate.c

101

if (size < diff + sizeof(hash))

arch/loongarch/kernel/relocate.c

104

size = ALIGN_DOWN(size - diff, sizeof(hash));

arch/loongarch/kernel/relocate.c

97

size_t i, diff;

arch/m68k/math-emu/fp_arith.c

60

int diff;

arch/m68k/math-emu/fp_arith.c

92

if ((diff = dest->exp - src->exp) > 0)

arch/m68k/math-emu/fp_arith.c

93

fp_denormalize(src, diff);

arch/m68k/math-emu/fp_arith.c

94

else if ((diff = -diff) > 0)

arch/m68k/math-emu/fp_arith.c

95

fp_denormalize(dest, diff);

arch/mips/alchemy/common/clock.c

410

long tdv, tpr, pr, nr, br, bpr, diff, lastdiff;

arch/mips/alchemy/common/clock.c

443

diff = req->rate - nr;

arch/mips/alchemy/common/clock.c

447

if (diff < lastdiff) {

arch/mips/alchemy/common/clock.c

448

lastdiff = diff;

arch/mips/alchemy/common/clock.c

453

if (diff == 0)

arch/mips/alchemy/common/clock.c

471

diff = req->rate - nr;

arch/mips/alchemy/common/clock.c

474

if (diff < lastdiff) {

arch/mips/alchemy/common/clock.c

475

lastdiff = diff;

arch/mips/alchemy/common/clock.c

480

if (diff == 0)

arch/mips/kernel/relocate.c

198

size_t diff, i;

arch/mips/kernel/relocate.c

200

diff = (void *)ptr - area;

arch/mips/kernel/relocate.c

201

if (unlikely(size < diff + sizeof(hash)))

arch/mips/kernel/relocate.c

204

size = ALIGN_DOWN(size - diff, sizeof(hash));

arch/riscv/mm/init.c

127

unsigned long diff = t - b;

arch/riscv/mm/init.c

129

if (IS_ENABLED(CONFIG_64BIT) && (diff >> LOG2_SZ_1T) >= 10)

arch/riscv/mm/init.c

131

else if ((diff >> LOG2_SZ_1G) >= 10)

arch/riscv/mm/init.c

133

else if ((diff >> LOG2_SZ_1M) >= 10)

arch/sparc/kernel/ldc.c

252

unsigned long limit, tail, new_tail, diff;

arch/sparc/kernel/ldc.c

262

diff = limit - new_tail;

arch/sparc/kernel/ldc.c

264

diff = (limit +

arch/sparc/kernel/ldc.c

266

diff /= LDC_PACKET_SIZE;

arch/sparc/kernel/ldc.c

269

if (diff * mss < size)

arch/sparc/kernel/prom_irqtrans.c

645

unsigned long diff = SYSIO_ICLR_UNUSED0 - SYSIO_IMAP_SLOT0;

arch/sparc/kernel/prom_irqtrans.c

646

return imap + diff;

arch/sparc/kernel/sbus.c

207

unsigned long diff = SYSIO_ICLR_UNUSED0 - SYSIO_IMAP_SLOT0;

arch/sparc/kernel/sbus.c

208

return imap + diff;

arch/sparc/kernel/smp_64.c

208

long diff; /* difference between midpoint and master's timestamp */

arch/sparc/kernel/smp_64.c

237

t[i].diff = delta;

arch/sparc/kernel/smp_64.c

247

t[i].rt, t[i].master, t[i].diff, t[i].lat);

arch/um/drivers/mconsole_kern.c

292

unsigned long long diff;

arch/um/drivers/mconsole_kern.c

313

diff = memparse(str, &ret);

arch/um/drivers/mconsole_kern.c

319

diff /= PAGE_SIZE;

arch/um/drivers/mconsole_kern.c

322

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

arch/um/kernel/um_arch.c

308

unsigned long avail, diff;

arch/um/kernel/um_arch.c

357

diff = PAGE_ALIGN(brk_start) - PAGE_ALIGN((unsigned long) &_end);

arch/um/kernel/um_arch.c

358

if (diff > 1024 * 1024) {

arch/um/kernel/um_arch.c

360

"exec-shield gap\n", diff);

arch/um/kernel/um_arch.c

361

physmem_size += diff;

arch/x86/boot/boot.h

157

bool diff;

arch/x86/boot/boot.h

159

: "=@ccnz" (diff), "+D" (s1), "+S" (s2), "+c" (len));

arch/x86/boot/boot.h

160

return diff;

arch/x86/boot/boot.h

164

bool diff;

arch/x86/boot/boot.h

166

: "=@ccnz" (diff), "+D" (s1), "+S" (s2), "+c" (len));

arch/x86/boot/boot.h

167

return diff;

arch/x86/boot/string.c

34

bool diff;

arch/x86/boot/string.c

36

: "=@ccnz" (diff), "+D" (s1), "+S" (s2), "+c" (len));

arch/x86/boot/string.c

37

return diff;

arch/x86/hyperv/mmu.c

29

unsigned long cur = start, diff;

arch/x86/hyperv/mmu.c

32

diff = end > cur ? end - cur : 0;

arch/x86/hyperv/mmu.c

39

if (diff >= HV_TLB_FLUSH_UNIT) {

arch/x86/hyperv/mmu.c

42

} else if (diff) {

arch/x86/hyperv/mmu.c

43

gva_list[gva_n] |= (diff - 1) >> PAGE_SHIFT;

arch/x86/include/asm/tlbflush.h

379

unsigned long diff = oldflags ^ newflags;

arch/x86/include/asm/tlbflush.h

386

diff &= ~software_flags;

arch/x86/include/asm/tlbflush.h

389

diff &= ~_PAGE_ACCESSED;

arch/x86/include/asm/tlbflush.h

395

if (diff & oldflags & flush_on_clear)

arch/x86/include/asm/tlbflush.h

399

if (diff & flush_on_change)

arch/x86/include/asm/tlbflush.h

404

(diff & ~(flush_on_clear | software_flags | flush_on_change))) {

arch/x86/kernel/alternative.c

446

void apply_reloc(int n, void *ptr, uintptr_t diff)

arch/x86/kernel/alternative.c

449

case 1: apply_reloc_n(8, ptr, diff); break;

arch/x86/kernel/alternative.c

450

case 2: apply_reloc_n(16, ptr, diff); break;

arch/x86/kernel/alternative.c

451

case 4: apply_reloc_n(32, ptr, diff); break;

arch/x86/kvm/pmu.c

851

u64 diff;

arch/x86/kvm/pmu.c

880

diff = pmu->global_ctrl ^ data;

arch/x86/kvm/pmu.c

882

reprogram_counters(pmu, diff);

arch/x86/kvm/pmu.h

210

static inline void reprogram_counters(struct kvm_pmu *pmu, u64 diff)

arch/x86/kvm/pmu.h

214

if (!diff)

arch/x86/kvm/pmu.h

217

for_each_set_bit(bit, (unsigned long *)&diff, X86_PMC_IDX_MAX)

arch/x86/kvm/vmx/pmu_intel.c

377

u64 reserved_bits, diff;

arch/x86/kvm/vmx/pmu_intel.c

392

diff = pmu->pebs_enable ^ data;

arch/x86/kvm/vmx/pmu_intel.c

394

reprogram_counters(pmu, diff);

arch/x86/math-emu/reg_add_sub.c

134

int diff, tag = 0, expa, expb, deststnr;

arch/x86/math-emu/reg_add_sub.c

169

diff = expa - expb;

arch/x86/math-emu/reg_add_sub.c

171

if (!diff) {

arch/x86/math-emu/reg_add_sub.c

172

diff = a->sigh - b->sigh; /* Works only if ms bits are identical */

arch/x86/math-emu/reg_add_sub.c

173

if (!diff) {

arch/x86/math-emu/reg_add_sub.c

174

diff = a->sigl > b->sigl;

arch/x86/math-emu/reg_add_sub.c

175

if (!diff)

arch/x86/math-emu/reg_add_sub.c

176

diff = -(a->sigl < b->sigl);

arch/x86/math-emu/reg_add_sub.c

183

if (diff > 0) {

arch/x86/math-emu/reg_add_sub.c

188

} else if (diff == 0) {

arch/x86/math-emu/reg_add_sub.c

45

int diff, tag, expa, expb;

arch/x86/math-emu/reg_add_sub.c

59

diff = expa - expb;

arch/x86/math-emu/reg_add_sub.c

60

if (!diff) {

arch/x86/math-emu/reg_add_sub.c

61

diff = a->sigh - b->sigh; /* This works only if the ms bits

arch/x86/math-emu/reg_add_sub.c

63

if (!diff) {

arch/x86/math-emu/reg_add_sub.c

64

diff = a->sigl > b->sigl;

arch/x86/math-emu/reg_add_sub.c

65

if (!diff)

arch/x86/math-emu/reg_add_sub.c

66

diff = -(a->sigl < b->sigl);

arch/x86/math-emu/reg_add_sub.c

70

if (diff > 0) {

arch/x86/math-emu/reg_add_sub.c

74

} else if (diff < 0) {

arch/x86/math-emu/reg_compare.c

141

diff = exp0 - expb;

arch/x86/math-emu/reg_compare.c

142

if (diff == 0) {

arch/x86/math-emu/reg_compare.c

143

diff = st0_ptr->sigh - b->sigh; /* Works only if ms bits are

arch/x86/math-emu/reg_compare.c

145

if (diff == 0) {

arch/x86/math-emu/reg_compare.c

146

diff = st0_ptr->sigl > b->sigl;

arch/x86/math-emu/reg_compare.c

147

if (diff == 0)

arch/x86/math-emu/reg_compare.c

148

diff = -(st0_ptr->sigl < b->sigl);

arch/x86/math-emu/reg_compare.c

152

if (diff > 0) {

arch/x86/math-emu/reg_compare.c

157

if (diff < 0) {

arch/x86/math-emu/reg_compare.c

26

int diff, exp0, expb;

block/blk-iolatency.c

337

unsigned long diff = 0;

block/blk-iolatency.c

340

diff = DEFAULT_SCALE_COOKIE - old;

block/blk-iolatency.c

346

else if (diff > qd)

block/blk-iolatency.c

357

if (diff > qd) {

block/blk-iolatency.c

358

if (diff < max_scale)

block/blk-timeout.c

154

unsigned long diff = q->timeout.expires - expiry;

block/blk-timeout.c

163

if (!timer_pending(&q->timeout) || (diff >= HZ / 2))

block/blk-wbt.c

225

int diff = limit - inflight;

block/blk-wbt.c

227

if (!inflight || diff >= rwb->wb_background / 2)

crypto/ecc.c

332

u64 diff;

crypto/ecc.c

334

diff = left[i] - right[i] - borrow;

crypto/ecc.c

335

if (diff != left[i])

crypto/ecc.c

336

borrow = (diff > left[i]);

crypto/ecc.c

338

result[i] = diff;

crypto/ecc.c

353

u64 diff;

crypto/ecc.c

355

diff = left[i] - borrow;

crypto/ecc.c

356

if (diff != left[i])

crypto/ecc.c

357

borrow = (diff > left[i]);

crypto/ecc.c

359

result[i] = diff;

crypto/ecc.c

655

u64 diff = v[i][j] - mod_m[j] - borrow;

crypto/ecc.c

657

if (diff != v[i][j])

crypto/ecc.c

658

borrow = (diff > v[i][j]);

crypto/ecc.c

659

v[1 - i][j] = diff;

crypto/ecc.c

74

int diff = ndigits - DIV_ROUND_UP_POW2(nbytes, sizeof(u64));

crypto/ecc.c

79

if (diff > 0) {

crypto/ecc.c

80

ndigits -= diff;

crypto/ecc.c

81

memset(&out[ndigits], 0, diff * sizeof(u64));

crypto/skcipher.c

192

unsigned long diff;

crypto/skcipher.c

194

diff = offset_in_page(walk->in.offset) -

crypto/skcipher.c

196

diff |= (u8 *)(sg_page(walk->in.sg) + (walk->in.offset >> PAGE_SHIFT)) -

crypto/skcipher.c

202

if (diff) {

crypto/testmgr.c

5634

int diff = strcmp(alg_test_descs[i - 1].alg,

crypto/testmgr.c

5637

if (WARN_ON(diff > 0)) {

crypto/testmgr.c

5643

if (WARN_ON(diff == 0)) {

crypto/testmgr.c

5679

int diff = strcmp(alg_test_descs[i].alg, alg);

crypto/testmgr.c

5681

if (diff > 0) {

crypto/testmgr.c

5686

if (diff < 0) {

drivers/bluetooth/hci_qca.c

301

unsigned int diff;

drivers/bluetooth/hci_qca.c

308

diff = jiffies_to_msecs(jiffies - qca->vote_last_jif);

drivers/bluetooth/hci_qca.c

311

qca->vote_off_ms += diff;

drivers/bluetooth/hci_qca.c

313

qca->vote_on_ms += diff;

drivers/bluetooth/hci_qca.c

352

diff = jiffies_to_msecs(jiffies - qca->vote_last_jif);

drivers/bluetooth/hci_qca.c

356

qca->vote_off_ms += diff;

drivers/bluetooth/hci_qca.c

359

qca->vote_on_ms += diff;

drivers/char/xillybus/xillyusb.c

1455

s32 diff, leap;

drivers/char/xillybus/xillyusb.c

1486

diff = (fifo_checkpoint - complete_checkpoint) << sh;

drivers/char/xillybus/xillyusb.c

1488

if (chan->in_synchronous && diff >= 0) {

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

503

unsigned long diff, best_diff;

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

527

diff = abs(req->rate - pll->vco_param[i].rate);

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

528

if (diff <= best_diff) {

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

529

best_diff = diff;

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

533

if (diff == 0)

drivers/clk/clk-cdce706.c

320

unsigned long diff;

drivers/clk/clk-cdce706.c

335

diff = max(div_rate, rate) - min(div_rate, rate);

drivers/clk/clk-cdce706.c

337

if (diff < best_diff) {

drivers/clk/clk-cdce706.c

338

best_diff = diff;

drivers/clk/clk-tps68470.c

131

long diff, best_diff = LONG_MAX;

drivers/clk/clk-tps68470.c

135

diff = clk_freqs[i].freq - rate;

drivers/clk/clk-tps68470.c

136

if (diff == 0)

drivers/clk/clk-tps68470.c

139

diff = abs(diff);

drivers/clk/clk-tps68470.c

140

if (diff < best_diff) {

drivers/clk/clk-tps68470.c

141

best_diff = diff;

drivers/clk/imx/clk-sscg-pll.c

116

int diff = temp_setup->fout_error;

drivers/clk/imx/clk-sscg-pll.c

118

if (abs(diff) > abs(new_diff)) {

drivers/clk/nuvoton/clk-ma35d1-pll.c

146

unsigned long tmp, fout, fclk, diff;

drivers/clk/nuvoton/clk-ma35d1-pll.c

167

diff = abs(rate - fout);

drivers/clk/nuvoton/clk-ma35d1-pll.c

168

if (diff < min_diff) {

drivers/clk/nuvoton/clk-ma35d1-pll.c

173

min_diff = diff;

drivers/clk/renesas/clk-div6.c

107

unsigned long prate, calc_rate, diff, best_rate, best_prate;

drivers/clk/renesas/clk-div6.c

130

diff = calc_rate > req->rate ? calc_rate - req->rate

drivers/clk/renesas/clk-div6.c

132

if (diff < min_diff) {

drivers/clk/renesas/clk-div6.c

136

min_diff = diff;

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

345

u64 vco_freq, freq, diff, vcomin, vcomax, best_diff = -1ULL;

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

368

diff = abs(freq - rate);

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

370

if (diff < best_diff) {

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

371

best_diff = diff;

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

375

if (!diff)

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

387

u64 vco_freq, freq, diff, vcomin, vcomax, best_diff = -1ULL;

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

409

diff = freq - rate;

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

410

if (diff < best_diff) {

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

411

best_diff = diff;

drivers/clocksource/timer-microchip-pit64b.c

294

unsigned long pclk_rate, diff = 0, best_diff = ULONG_MAX;

drivers/clocksource/timer-microchip-pit64b.c

325

diff = abs(pclk_rate / (pres + 1) - max_rate);

drivers/clocksource/timer-microchip-pit64b.c

327

if (best_diff > diff) {

drivers/comedi/drivers/amplc_pci230.c

2079

unsigned int i, chan, range, diff;

drivers/comedi/drivers/amplc_pci230.c

2132

diff = 1;

drivers/comedi/drivers/amplc_pci230.c

2136

diff = 0;

drivers/comedi/drivers/amplc_pci230.c

2152

if (diff) {

drivers/cpufreq/cpufreq-nforce2.c

173

int diff;

drivers/cpufreq/cpufreq-nforce2.c

202

diff = tfsb - fsb;

drivers/cpufreq/cpufreq-nforce2.c

204

if (!diff)

drivers/cpufreq/cpufreq-nforce2.c

208

if (diff < 0)

drivers/cpufreq/freq_table.c

129

unsigned int freq, diff, i;

drivers/cpufreq/freq_table.c

182

diff = abs(freq - target_freq);

drivers/cpufreq/freq_table.c

183

if (diff < optimal.frequency ||

drivers/cpufreq/freq_table.c

184

(diff == optimal.frequency &&

drivers/cpufreq/freq_table.c

186

optimal.frequency = diff;

drivers/cpuidle/cpuidle.c

295

s64 diff, delay = drv->states[entered_state].exit_latency_ns;

drivers/cpuidle/cpuidle.c

303

diff = ktime_sub(time_end, time_start);

drivers/cpuidle/cpuidle.c

305

dev->last_residency_ns = diff;

drivers/cpuidle/cpuidle.c

306

dev->states_usage[entered_state].time_ns += diff;

drivers/cpuidle/cpuidle.c

309

if (diff < drv->states[entered_state].target_residency_ns) {

drivers/cpuidle/cpuidle.c

319

} else if (diff > delay) {

drivers/cpuidle/cpuidle.c

328

if (diff - delay >= drv->states[i].target_residency_ns) {

drivers/crypto/axis/artpec6_crypto.c

1003

unsigned int mod, target, diff, pad_bytes, size_bytes;

drivers/crypto/axis/artpec6_crypto.c

1023

diff = dgstlen & (mod - 1);

drivers/crypto/axis/artpec6_crypto.c

1024

pad_bytes = diff > target ? target + mod - diff : target - diff;

drivers/crypto/hifn_795x.c

1425

unsigned int nbytes = req->cryptlen, offset, copy, diff;

drivers/crypto/hifn_795x.c

1454

diff = slen & (HIFN_D_DST_DALIGN - 1);

drivers/crypto/hifn_795x.c

1467

nbytes += diff;

drivers/crypto/hifn_795x.c

1482

copy += diff + nbytes;

drivers/dma/dmatest.c

380

u8 diff = actual ^ pattern;

drivers/dma/dmatest.c

388

&& (diff & (PATTERN_COPY | PATTERN_OVERWRITE)))

drivers/dma/dmatest.c

391

else if (diff & PATTERN_SRC)

drivers/dma/dmatest.c

595

ktime_t ktime, start, diff;

drivers/dma/dmatest.c

745

diff = ktime_sub(ktime_get(), start);

drivers/dma/dmatest.c

746

filltime = ktime_add(filltime, diff);

drivers/dma/dmatest.c

898

diff = ktime_sub(ktime_get(), start);

drivers/dma/dmatest.c

899

comparetime = ktime_add(comparetime, diff);

drivers/edac/amd64_edac.c

1865

unsigned diff;

drivers/edac/amd64_edac.c

1892

diff = cs_mode/3 + (unsigned)(cs_mode > 5);

drivers/edac/amd64_edac.c

1894

return 32 << (cs_mode - diff);

drivers/gpio/gpio-virtuser.c

878

size_t pos = 0, diff;

drivers/gpio/gpio-virtuser.c

891

diff = dash - prop->name;

drivers/gpio/gpio-virtuser.c

893

tmp = devm_kmemdup(dev, prop->name, diff + 1,

drivers/gpio/gpio-virtuser.c

898

tmp[diff] = '\0';

drivers/gpio/gpiolib-acpi-core.c

619

enum gpiod_flags diff = *flags ^ update;

drivers/gpio/gpiolib-acpi-core.c

628

if (((*flags & GPIOD_FLAGS_BIT_DIR_SET) && (diff & GPIOD_FLAGS_BIT_DIR_OUT)) ||

drivers/gpio/gpiolib-acpi-core.c

629

((*flags & GPIOD_FLAGS_BIT_DIR_OUT) && (diff & GPIOD_FLAGS_BIT_DIR_VAL)))

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

209

unsigned diff;

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

212

diff = abs(target_clock - (pll->reference_freq * fb_div) /

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

215

if (diff < diff_best || (diff == diff_best &&

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

219

diff_best = diff;

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

632

int64_t diff = (int64_t)div_u64(frame_time_diff * base60_refresh_rates[i], 10) - 10000;

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

634

if (diff < 0)

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

635

diff = -diff;

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

636

if (diff < stream1->ctx->dc->config.vblank_alignment_max_frame_time_diff)

drivers/gpu/drm/amd/display/dc/dml/dcn32/dcn32_fpu.c

1127

struct dc_stream_state *stream, int diff)

drivers/gpu/drm/amd/display/dc/dml/dcn32/dcn32_fpu.c

1133

table->odm_combines[i].slice_count += diff;

drivers/gpu/drm/amd/display/dc/dml/dcn32/dcn32_fpu.c

1141

table->odm_combines[i].slice_count = diff;

drivers/gpu/drm/amd/display/dc/dml/dcn32/dcn32_fpu.c

1146

struct pipe_ctx *dpp_pipe, struct dc_plane_state *plane, int diff)

drivers/gpu/drm/amd/display/dc/dml/dcn32/dcn32_fpu.c

1154

table->mpc_combines[i].slice_count += diff;

drivers/gpu/drm/amd/display/dc/dml/dcn32/dcn32_fpu.c

1163

table->mpc_combines[i].slice_count = diff;

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

4431

unsigned int i, diff;

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

4436

diff = voltage_table->count - max_voltage_steps;

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

4439

voltage_table->entries[i] = voltage_table->entries[i + diff];

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

330

unsigned int i, diff;

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

335

diff = vol_table->count - max_vol_steps;

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

338

vol_table->entries[i] = vol_table->entries[i + diff];

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

1150

unsigned int i, diff;

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

1155

diff = vol_table->count - max_vol_steps;

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

1158

vol_table->entries[i] = vol_table->entries[i + diff];

drivers/gpu/drm/ast/ast_2300.c

364

u32 reg_mcr18, reg_mcr0c, passcnt[2], diff;

drivers/gpu/drm/ast/ast_2300.c

427

diff = pass[dqidly][dqsip][1] - pass[dqidly][dqsip][0];

drivers/gpu/drm/ast/ast_2300.c

428

if ((diff + 2) < g_margin)

drivers/gpu/drm/ast/ast_2300.c

445

if (diff > (g_margin + 1) && (passcnt[1] > 0 || passcnt[0] > 8)) {

drivers/gpu/drm/ast/ast_2300.c

446

g_margin = diff;

drivers/gpu/drm/ast/ast_2300.c

451

if (diff > g_margin)

drivers/gpu/drm/ast/ast_2300.c

452

g_margin = diff;

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

1116

unsigned int diff;

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

1131

diff = last_cts - cts;

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

1133

diff = cts - last_cts;

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

1135

if (diff < 5) {

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

275

u64 diff = dw_hdmi_qp_audio_math_diff(freq, n, pixel_clk);

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

277

if (diff < best_diff ||

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

278

(diff == best_diff && abs(n - ideal_n) < best_n_distance)) {

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

280

best_diff = diff;

drivers/gpu/drm/bridge/tc358768.c

365

u32 pll, diff, pll_in;

drivers/gpu/drm/bridge/tc358768.c

376

diff = max(pll, target_pll) - min(pll, target_pll);

drivers/gpu/drm/bridge/tc358768.c

378

if (diff < best_diff) {

drivers/gpu/drm/bridge/tc358768.c

379

best_diff = diff;

drivers/gpu/drm/drm_modes.c

1846

int diff;

drivers/gpu/drm/drm_modes.c

1848

diff = ((b->type & DRM_MODE_TYPE_PREFERRED) != 0) -

drivers/gpu/drm/drm_modes.c

1850

if (diff)

drivers/gpu/drm/drm_modes.c

1851

return diff;

drivers/gpu/drm/drm_modes.c

1852

diff = b->hdisplay * b->vdisplay - a->hdisplay * a->vdisplay;

drivers/gpu/drm/drm_modes.c

1853

if (diff)

drivers/gpu/drm/drm_modes.c

1854

return diff;

drivers/gpu/drm/drm_modes.c

1856

diff = drm_mode_vrefresh(b) - drm_mode_vrefresh(a);

drivers/gpu/drm/drm_modes.c

1857

if (diff)

drivers/gpu/drm/drm_modes.c

1858

return diff;

drivers/gpu/drm/drm_modes.c

1860

diff = b->clock - a->clock;

drivers/gpu/drm/drm_modes.c

1861

return diff;

drivers/gpu/drm/drm_rect.c

102

dst->x1 += diff;

drivers/gpu/drm/drm_rect.c

104

diff = clip->y1 - dst->y1;

drivers/gpu/drm/drm_rect.c

105

if (diff > 0) {

drivers/gpu/drm/drm_rect.c

107

drm_rect_height(dst), &diff);

drivers/gpu/drm/drm_rect.c

110

dst->y1 += diff;

drivers/gpu/drm/drm_rect.c

112

diff = dst->x2 - clip->x2;

drivers/gpu/drm/drm_rect.c

113

if (diff > 0) {

drivers/gpu/drm/drm_rect.c

115

drm_rect_width(dst), &diff);

drivers/gpu/drm/drm_rect.c

118

dst->x2 -= diff;

drivers/gpu/drm/drm_rect.c

120

diff = dst->y2 - clip->y2;

drivers/gpu/drm/drm_rect.c

121

if (diff > 0) {

drivers/gpu/drm/drm_rect.c

123

drm_rect_height(dst), &diff);

drivers/gpu/drm/drm_rect.c

126

dst->y2 -= diff;

drivers/gpu/drm/drm_rect.c

94

int diff;

drivers/gpu/drm/drm_rect.c

96

diff = clip->x1 - dst->x1;

drivers/gpu/drm/drm_rect.c

97

if (diff > 0) {

drivers/gpu/drm/drm_rect.c

99

drm_rect_width(dst), &diff);

drivers/gpu/drm/drm_vblank.c

1545

u32 cur_vblank, diff = 1;

drivers/gpu/drm/drm_vblank.c

1568

diff = DIV_ROUND_CLOSEST_ULL(diff_ns, framedur_ns);

drivers/gpu/drm/drm_vblank.c

1573

diff, diff_ns, framedur_ns, cur_vblank - vblank->last);

drivers/gpu/drm/drm_vblank.c

1574

vblank->last = (cur_vblank - diff) & max_vblank_count;

drivers/gpu/drm/drm_vblank.c

299

u32 cur_vblank, diff;

drivers/gpu/drm/drm_vblank.c

325

diff = (cur_vblank - vblank->last) & max_vblank_count;

drivers/gpu/drm/drm_vblank.c

339

diff = DIV_ROUND_CLOSEST_ULL(diff_ns, framedur_ns);

drivers/gpu/drm/drm_vblank.c

341

if (diff == 0 && in_vblank_irq)

drivers/gpu/drm/drm_vblank.c

346

diff = in_vblank_irq ? 1 : 0;

drivers/gpu/drm/drm_vblank.c

358

if (diff > 1 && (vblank->inmodeset & 0x2)) {

drivers/gpu/drm/drm_vblank.c

361

" due to pre-modeset.\n", pipe, diff);

drivers/gpu/drm/drm_vblank.c

362

diff = 1;

drivers/gpu/drm/drm_vblank.c

368

diff, cur_vblank, vblank->last);

drivers/gpu/drm/drm_vblank.c

370

if (diff == 0) {

drivers/gpu/drm/drm_vblank.c

384

store_vblank(dev, pipe, diff, t_vblank, cur_vblank);

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

4822

int diff;

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

4830

diff = abs(clock1 - clock2);

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

4832

if (((((diff + clock1 + clock2) * 100)) / (clock1 + clock2)) < 105)

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

894

u64 a, b, c, d, diff, diff_best;

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

920

diff = abs_diff(freq2k * p * r2, LC_FREQ_2K * n2);

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

923

c = 1000000 * diff;

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

928

if (best->p * best->r2 * diff < p * r2 * diff_best) {

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

110

ia_freq = consts->max_ia_freq - diff * scale / 2;

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

79

const int diff = consts->max_gpu_freq - gpu_freq;

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

138

diff = res[1] - res[0];

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

140

if (diff < threshold)

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

50

u64 diff;

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

116

u32 diff = node->preg ^ node->vreg;

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

120

32, &diff);

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

124

seq_printf(s, "Total: %d, Diff: %d\n", param.total, param.diff);

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

33

int diff;

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

79

param->diff++;

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

93

.diff = 0,

drivers/gpu/drm/loongson/lsdc_pixpll.c

210

unsigned int diff = 0;

drivers/gpu/drm/loongson/lsdc_pixpll.c

220

diff = clock - computed;

drivers/gpu/drm/loongson/lsdc_pixpll.c

222

diff = computed - clock;

drivers/gpu/drm/loongson/lsdc_pixpll.c

224

if (diff < min) {

drivers/gpu/drm/loongson/lsdc_pixpll.c

225

min = diff;

drivers/gpu/drm/loongson/lsdc_pixpll.c

230

if (diff == 0) {

drivers/gpu/drm/mcde/mcde_clk_div.c

54

unsigned long this_prate, div_rate, diff;

drivers/gpu/drm/mcde/mcde_clk_div.c

61

diff = abs(rate - div_rate);

drivers/gpu/drm/mcde/mcde_clk_div.c

63

if (diff < best_diff) {

drivers/gpu/drm/mcde/mcde_clk_div.c

65

best_diff = diff;

drivers/gpu/drm/mediatek/mtk_disp_gamma.c

148

struct drm_color_lut diff, hwlut;

drivers/gpu/drm/mediatek/mtk_disp_gamma.c

165

diff.red = lut[n].red - lut[n - 1].red;

drivers/gpu/drm/mediatek/mtk_disp_gamma.c

166

diff.red = drm_color_lut_extract(diff.red, lut_bits);

drivers/gpu/drm/mediatek/mtk_disp_gamma.c

168

diff.green = lut[n].green - lut[n - 1].green;

drivers/gpu/drm/mediatek/mtk_disp_gamma.c

169

diff.green = drm_color_lut_extract(diff.green, lut_bits);

drivers/gpu/drm/mediatek/mtk_disp_gamma.c

171

diff.blue = lut[n].blue - lut[n - 1].blue;

drivers/gpu/drm/mediatek/mtk_disp_gamma.c

172

diff.blue = drm_color_lut_extract(diff.blue, lut_bits);

drivers/gpu/drm/mediatek/mtk_disp_gamma.c

175

word[0] = FIELD_PREP(DISP_GAMMA_LUT_12BIT_R, diff.red);

drivers/gpu/drm/mediatek/mtk_disp_gamma.c

176

word[0] |= FIELD_PREP(DISP_GAMMA_LUT_12BIT_G, diff.green);

drivers/gpu/drm/mediatek/mtk_disp_gamma.c

177

word[1] = FIELD_PREP(DISP_GAMMA_LUT_12BIT_B, diff.blue);

drivers/gpu/drm/mediatek/mtk_disp_gamma.c

179

word[0] = FIELD_PREP(DISP_GAMMA_LUT_10BIT_R, diff.red);

drivers/gpu/drm/mediatek/mtk_disp_gamma.c

180

word[0] |= FIELD_PREP(DISP_GAMMA_LUT_10BIT_G, diff.green);

drivers/gpu/drm/mediatek/mtk_disp_gamma.c

181

word[0] |= FIELD_PREP(DISP_GAMMA_LUT_10BIT_B, diff.blue);

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

1756

ktime_t diff = ktime_sub(ktime_get(), dpu_crtc->vblank_cb_time);

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

1757

s64 diff_ms = ktime_to_ms(diff);

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

1764

ktime_to_ms(diff), dpu_crtc->play_count);

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

2186

int short_response, diff, pkt_size, ret = 0;

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

2261

diff = data_byte - rlen;

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

2264

diff = 0;

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

2270

dlen -= diff;

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

2277

DBG("buf=%p dlen=%d diff=%d", buf, dlen, diff);

drivers/gpu/drm/nouveau/dispnv04/dfp.c

381

uint32_t diff, scale;

drivers/gpu/drm/nouveau/dispnv04/dfp.c

394

diff = output_mode->hdisplay -

drivers/gpu/drm/nouveau/dispnv04/dfp.c

396

regp->fp_horiz_regs[FP_VALID_START] += diff / 2;

drivers/gpu/drm/nouveau/dispnv04/dfp.c

397

regp->fp_horiz_regs[FP_VALID_END] -= diff / 2;

drivers/gpu/drm/nouveau/dispnv04/dfp.c

410

diff = output_mode->vdisplay -

drivers/gpu/drm/nouveau/dispnv04/dfp.c

412

regp->fp_vert_regs[FP_VALID_START] += diff / 2;

drivers/gpu/drm/nouveau/dispnv04/dfp.c

413

regp->fp_vert_regs[FP_VALID_END] -= diff / 2;

drivers/gpu/drm/nouveau/nvkm/engine/disp/nv50.c

1193

u32 calc, diff;

drivers/gpu/drm/nouveau/nvkm/engine/disp/nv50.c

1198

diff = tu_valid - calc;

drivers/gpu/drm/nouveau/nvkm/engine/disp/nv50.c

1199

if (diff) {

drivers/gpu/drm/nouveau/nvkm/engine/disp/nv50.c

1200

if (diff >= (symbol / 2)) {

drivers/gpu/drm/nouveau/nvkm/engine/disp/nv50.c

1201

VTUf = symbol / (symbol - diff);

drivers/gpu/drm/nouveau/nvkm/engine/disp/nv50.c

1202

if (symbol - (VTUf * diff))

drivers/gpu/drm/nouveau/nvkm/engine/disp/nv50.c

1215

VTUf = min((int)(symbol / diff), 15);

drivers/gpu/drm/nouveau/nvkm/engine/disp/nv50.c

1219

diff = calc - tu_valid;

drivers/gpu/drm/nouveau/nvkm/engine/disp/nv50.c

1230

if (diff < best_diff) {

drivers/gpu/drm/nouveau/nvkm/engine/disp/nv50.c

1231

best_diff = diff;

drivers/gpu/drm/nouveau/nvkm/engine/disp/nv50.c

1236

if (diff == 0)

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

123

int diff;

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

195

diff = average_tpcs - scale_factor * num_tpc_gpc[gpc];

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

196

if (diff < 0)

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

197

diff = -diff;

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

199

deviation += diff;

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

192

s32 diff;

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

210

diff = ((khz + 3000) - oclk);

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

214

if (diff < 0) {

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

241

int P, N, M, diff;

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

249

diff = khz - ret;

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

250

if (!pll || (diff >= -2000 && diff < 3000)) {

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

1171

if (mask = 0, data = 0, ram->diff.rammap_11_0a_03fe) {

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

1175

if (ram->diff.rammap_11_09_01ff) {

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

1181

if (mask = 0, data = 0, ram->diff.rammap_11_0a_0400) {

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

1187

if (mask = 0, data = 0, ram->diff.rammap_11_0a_0800) {

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

1193

if (mask = 0, data = 0, ram->diff.rammap_11_0b_01f0) {

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

1199

if (mask = 0, data = 0, ram->diff.rammap_11_0b_0200) {

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

1205

if (mask = 0, data = 0, ram->diff.rammap_11_0d) {

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

1209

if (ram->diff.rammap_11_0f) {

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

1215

if (mask = 0, data = 0, ram->diff.rammap_11_0e) {

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

1219

if (ram->diff.rammap_11_0b_0800) {

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

1223

if (ram->diff.rammap_11_0b_0400) {

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

130

struct nvbios_ramcfg diff;

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

1443

struct nvbios_ramcfg *d = &ram->diff;

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

474

if (ram->diff.ramcfg_11_08_20) {

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

482

if (ram->diff.ramcfg_11_02_03) {

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

486

if (ram->diff.ramcfg_11_01_10) {

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

494

if (ram->diff.timing_20_30_07) {

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

498

if (ram->diff.ramcfg_11_01_01) {

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

506

if (ram->diff.timing_20_30_07) {

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

510

if (ram->diff.ramcfg_11_01_02) {

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

544

if (ram->diff.ramcfg_11_02_03) {

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

548

if (ram->diff.ramcfg_11_01_10) {

drivers/gpu/drm/pl111/pl111_display.c

457

unsigned long this_prate, div_rate, diff;

drivers/gpu/drm/pl111/pl111_display.c

464

diff = abs(rate - div_rate);

drivers/gpu/drm/pl111/pl111_display.c

466

if (diff < best_diff) {

drivers/gpu/drm/pl111/pl111_display.c

468

best_diff = diff;

drivers/gpu/drm/radeon/cypress_dpm.c

1473

unsigned int i, diff;

drivers/gpu/drm/radeon/cypress_dpm.c

1478

diff = voltage_table->count - MAX_NO_VREG_STEPS;

drivers/gpu/drm/radeon/cypress_dpm.c

1481

voltage_table->entries[i] = voltage_table->entries[i + diff];

drivers/gpu/drm/radeon/radeon_display.c

1055

unsigned diff;

drivers/gpu/drm/radeon/radeon_display.c

1058

diff = abs(target_clock - (pll->reference_freq * fb_div) /

drivers/gpu/drm/radeon/radeon_display.c

1061

if (diff < diff_best || (diff == diff_best &&

drivers/gpu/drm/radeon/radeon_display.c

1065

diff_best = diff;

drivers/gpu/drm/radeon/si_dpm.c

3866

unsigned int i, diff;

drivers/gpu/drm/radeon/si_dpm.c

3871

diff = voltage_table->count - max_voltage_steps;

drivers/gpu/drm/radeon/si_dpm.c

3874

voltage_table->entries[i] = voltage_table->entries[i + diff];

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

145

diff = abs((long)output - (long)target);

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

146

if (best_diff > diff) {

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

147

best_diff = diff;

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

154

if (diff == 0)

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

169

unsigned long diff;

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

177

unsigned long diff;

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

184

if (params->diff == 0)

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

193

diff = abs(rate / (div + 1) - target);

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

199

if (diff < params->diff) {

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

202

params->diff = diff;

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

255

struct du_clk_params params = { .diff = (unsigned long)-1 };

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

89

unsigned long diff;

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

133

unsigned long diff;

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

233

unsigned long diff;

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

243

diff = abs(fout / div - target);

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

245

if (diff < pll->diff) {

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

246

pll->diff = diff;

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

253

if (diff == 0)

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

275

struct pll_info pll = { .diff = (unsigned long)-1 };

drivers/gpu/drm/sun4i/sun4i_hdmi_enc.c

186

unsigned long diff = div_u64(clock, 200); /* +-0.5% allowed by HDMI spec */

drivers/gpu/drm/sun4i/sun4i_hdmi_enc.c

199

min_t(unsigned long, rounded_rate, clock) < diff)

drivers/gpu/drm/tiny/arcpgu.c

147

long diff = clk_rate / 200; /* +-0.5% allowed by HDMI spec */

drivers/gpu/drm/tiny/arcpgu.c

150

if ((max(rate, clk_rate) - min(rate, clk_rate) < diff) && (rate > 0))

drivers/gpu/drm/vboxvideo/vbva_base.c

24

s32 diff = vbva->data_offset - vbva->free_offset;

drivers/gpu/drm/vboxvideo/vbva_base.c

26

return diff > 0 ? diff : vbva->data_len + diff;

drivers/gpu/drm/vboxvideo/vbva_base.c

35

s32 diff = len - bytes_till_boundary;

drivers/gpu/drm/vboxvideo/vbva_base.c

37

if (diff <= 0) {

drivers/gpu/drm/vboxvideo/vbva_base.c

43

memcpy(&vbva->data[0], (u8 *)p + bytes_till_boundary, diff);

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

248

void vmw_memcpy(struct vmw_diff_cpy *diff, u8 *dest, const u8 *src, size_t n)

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

261

static void vmw_adjust_rect(struct vmw_diff_cpy *diff, size_t diff_offs)

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

263

size_t offs = (diff_offs + diff->line_offset) / diff->cpp;

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

264

struct drm_rect *rect = &diff->rect;

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

268

rect->y1 = min_t(int, rect->y1, diff->line);

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

269

rect->y2 = max_t(int, rect->y2, diff->line + 1);

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

290

void vmw_diff_memcpy(struct vmw_diff_cpy *diff, u8 *dest, const u8 *src,

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

295

if (WARN_ON_ONCE(round_down(n, diff->cpp) != n))

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

299

csize = vmw_find_first_diff(dest, src, n, diff->cpp);

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

301

vmw_adjust_rect(diff, csize);

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

302

byte_len = diff->cpp;

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

308

diff->line_offset += csize;

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

312

csize = vmw_find_last_diff(dest, src, n, diff->cpp);

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

315

vmw_adjust_rect(diff, csize);

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

319

diff->line_offset += n;

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

348

struct vmw_diff_cpy *diff;

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

364

struct vmw_diff_cpy *diff = d->diff;

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

414

diff->do_cpy(diff, d->dst_addr + dst_page_offset,

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

460

struct vmw_diff_cpy *diff)

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

504

diff->rect.x1 = x_in_bytes / diff->cpp;

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

505

diff->rect.y1 = ((dst_offset - x_in_bytes) / dst_stride);

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

506

diff->rect.x2 = diff->rect.x1 + width_in_bytes / diff->cpp;

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

507

diff->rect.y2 = diff->rect.y1 + height;

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

546

struct vmw_diff_cpy *diff)

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

586

w, h, diff);

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

619

d.diff = diff;

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

622

diff->line = j + initial_line;

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

623

diff->line_offset = dst_offset % dst_stride;

drivers/gpu/drm/vmwgfx/vmwgfx_drv.h

1319

void (*do_cpy)(struct vmw_diff_cpy *diff, u8 *dest, const u8 *src,

drivers/gpu/drm/vmwgfx/vmwgfx_drv.h

1339

void vmw_diff_memcpy(struct vmw_diff_cpy *diff, u8 *dest, const u8 *src,

drivers/gpu/drm/vmwgfx/vmwgfx_drv.h

1342

void vmw_memcpy(struct vmw_diff_cpy *diff, u8 *dest, const u8 *src, size_t n);

drivers/gpu/drm/vmwgfx/vmwgfx_drv.h

1349

struct vmw_diff_cpy *diff);

drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c

1174

struct vmw_diff_cpy diff = VMW_CPU_BLIT_DIFF_INITIALIZER(0);

drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c

1189

diff.cpp = stdu->cpp;

drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c

1202

&diff);

drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c

1204

if (drm_rect_visible(&diff.rect)) {

drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c

1213

box->x = diff.rect.x1;

drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c

1214

box->y = diff.rect.y1;

drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c

1216

box->w = drm_rect_width(&diff.rect);

drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c

1217

box->h = drm_rect_height(&diff.rect);

drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c

1222

diff.rect.x1, diff.rect.x2,

drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c

1223

diff.rect.y1, diff.rect.y2);

drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c

507

struct vmw_diff_cpy diff = VMW_CPU_BLIT_DIFF_INITIALIZER(stdu->cpp);

drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c

529

width * stdu->cpp, height, &diff);

drivers/gpu/drm/xe/xe_guc_submit.c

1335

u32 diff;

drivers/gpu/drm/xe/xe_guc_submit.c

1369

diff = ctx_timestamp - ctx_job_timestamp;

drivers/gpu/drm/xe/xe_guc_submit.c

1375

ADJUST_FIVE_PERCENT(xe_gt_clock_interval_to_ms(gt, diff));

drivers/gpu/drm/xe/xe_guc_submit.c

1380

q->guc->id, running_time_ms, timeout_ms, diff);

drivers/gpu/drm/xlnx/zynqmp_disp.c

1330

long diff;

drivers/gpu/drm/xlnx/zynqmp_disp.c

1340

diff = rate - mode_clock;

drivers/gpu/drm/xlnx/zynqmp_disp.c

1341

if (abs(diff) > mode_clock / 20)

drivers/gpu/drm/xlnx/zynqmp_dp.c

1659

int diff = mode->htotal - mode->hsync_end;

drivers/gpu/drm/xlnx/zynqmp_dp.c

1665

if (diff < ZYNQMP_DP_MIN_H_BACKPORCH) {

drivers/gpu/drm/xlnx/zynqmp_dp.c

1670

diff, ZYNQMP_DP_MIN_H_BACKPORCH - diff);

drivers/gpu/drm/xlnx/zynqmp_dp.c

1671

diff = ZYNQMP_DP_MIN_H_BACKPORCH - diff;

drivers/gpu/drm/xlnx/zynqmp_dp.c

1672

adjusted_mode->htotal += diff;

drivers/gpu/ipu-v3/ipu-di.c

508

u32 diff;

drivers/gpu/ipu-v3/ipu-di.c

520

diff = 2 - mode->vfront_porch;

drivers/gpu/ipu-v3/ipu-di.c

522

if (mode->vback_porch >= diff) {

drivers/gpu/ipu-v3/ipu-di.c

524

mode->vback_porch -= diff;

drivers/gpu/ipu-v3/ipu-di.c

525

} else if (mode->vsync_len > diff) {

drivers/gpu/ipu-v3/ipu-di.c

527

mode->vsync_len = mode->vsync_len - diff;

drivers/gpu/ipu-v3/ipu-image-convert.c

535

unsigned int diff;

drivers/gpu/ipu-v3/ipu-image-convert.c

567

diff = abs_diff(in_pos, in_pos_aligned);

drivers/gpu/ipu-v3/ipu-image-convert.c

568

if (diff < min_diff) {

drivers/gpu/ipu-v3/ipu-image-convert.c

571

min_diff = diff;

drivers/hwmon/jc42.c

302

int diff, hyst;

drivers/hwmon/jc42.c

331

diff = jc42_temp_from_reg(regval) - val;

drivers/hwmon/jc42.c

333

if (diff > 0) {

drivers/hwmon/jc42.c

334

if (diff < 2250)

drivers/hwmon/jc42.c

336

else if (diff < 4500)

drivers/i2c/busses/i2c-ocores.c

412

int diff;

drivers/i2c/busses/i2c-ocores.c

422

diff = i2c->ip_clock_khz / (5 * (prescale + 1)) - i2c->bus_clock_khz;

drivers/i2c/busses/i2c-ocores.c

423

if (abs(diff) > i2c->bus_clock_khz / 10) {

drivers/i2c/busses/i2c-octeon-core.c

826

int tclk, thp_base, inc, thp_idx, mdiv_idx, ndiv_idx, foscl, diff;

drivers/i2c/busses/i2c-octeon-core.c

879

diff = abs(foscl - i2c->twsi_freq);

drivers/i2c/busses/i2c-octeon-core.c

885

if (diff < delta_hz) {

drivers/i2c/busses/i2c-octeon-core.c

886

delta_hz = diff;

drivers/iio/adc/ad4030.c

165

s32 diff;

drivers/iio/adc/ad4030.c

169

s32 diff[2];

drivers/iio/adc/ad4030.c

642

&st->rx_data.dual.diff[0],

drivers/iio/adc/ad4030.c

643

&st->rx_data.dual.diff[1]);

drivers/iio/adc/ad4030.c

683

*val = st->rx_data.single.diff;

drivers/iio/adc/ad4030.c

685

*val = st->rx_data.dual.diff[chan->address];

drivers/iio/adc/ad7380.c

320

#define _AD7380_CHANNEL(index, bits, diff, sign, gain) { \

drivers/iio/adc/ad7380.c

324

((diff) ? 0 : BIT(IIO_CHAN_INFO_OFFSET)), \

drivers/iio/adc/ad7380.c

330

.differential = (diff), \

drivers/iio/adc/ad7380.c

331

.channel = (diff) ? (2 * (index)) : (index), \

drivers/iio/adc/ad7380.c

332

.channel2 = (diff) ? (2 * (index) + 1) : 0, \

drivers/iio/adc/ad7380.c

341

#define _AD7380_OFFLOAD_CHANNEL(index, bits, diff, sign, gain) { \

drivers/iio/adc/ad7380.c

345

((diff) ? 0 : BIT(IIO_CHAN_INFO_OFFSET)), \

drivers/iio/adc/ad7380.c

353

.differential = (diff), \

drivers/iio/adc/ad7380.c

354

.channel = (diff) ? (2 * (index)) : (index), \

drivers/iio/adc/ad7380.c

355

.channel2 = (diff) ? (2 * (index) + 1) : 0, \

drivers/iio/adc/ad7380.c

376

#define AD7380_CHANNEL(index, bits, diff, sign) \

drivers/iio/adc/ad7380.c

377

_AD7380_CHANNEL(index, bits, diff, sign, false)

drivers/iio/adc/ad7380.c

379

#define ADAQ4380_CHANNEL(index, bits, diff, sign) \

drivers/iio/adc/ad7380.c

380

_AD7380_CHANNEL(index, bits, diff, sign, true)

drivers/iio/adc/ad7380.c

382

#define DEFINE_AD7380_2_CHANNEL(name, bits, diff, sign) \

drivers/iio/adc/ad7380.c

384

AD7380_CHANNEL(0, bits, diff, sign), \

drivers/iio/adc/ad7380.c

385

AD7380_CHANNEL(1, bits, diff, sign), \

drivers/iio/adc/ad7380.c

389

#define DEFINE_AD7380_4_CHANNEL(name, bits, diff, sign) \

drivers/iio/adc/ad7380.c

391

AD7380_CHANNEL(0, bits, diff, sign), \

drivers/iio/adc/ad7380.c

392

AD7380_CHANNEL(1, bits, diff, sign), \

drivers/iio/adc/ad7380.c

393

AD7380_CHANNEL(2, bits, diff, sign), \

drivers/iio/adc/ad7380.c

394

AD7380_CHANNEL(3, bits, diff, sign), \

drivers/iio/adc/ad7380.c

398

#define DEFINE_ADAQ4380_4_CHANNEL(name, bits, diff, sign) \

drivers/iio/adc/ad7380.c

400

ADAQ4380_CHANNEL(0, bits, diff, sign), \

drivers/iio/adc/ad7380.c

401

ADAQ4380_CHANNEL(1, bits, diff, sign), \

drivers/iio/adc/ad7380.c

402

ADAQ4380_CHANNEL(2, bits, diff, sign), \

drivers/iio/adc/ad7380.c

403

ADAQ4380_CHANNEL(3, bits, diff, sign), \

drivers/iio/adc/ad7380.c

407

#define DEFINE_AD7380_8_CHANNEL(name, bits, diff, sign) \

drivers/iio/adc/ad7380.c

409

AD7380_CHANNEL(0, bits, diff, sign), \

drivers/iio/adc/ad7380.c

410

AD7380_CHANNEL(1, bits, diff, sign), \

drivers/iio/adc/ad7380.c

411

AD7380_CHANNEL(2, bits, diff, sign), \

drivers/iio/adc/ad7380.c

412

AD7380_CHANNEL(3, bits, diff, sign), \

drivers/iio/adc/ad7380.c

413

AD7380_CHANNEL(4, bits, diff, sign), \

drivers/iio/adc/ad7380.c

414

AD7380_CHANNEL(5, bits, diff, sign), \

drivers/iio/adc/ad7380.c

415

AD7380_CHANNEL(6, bits, diff, sign), \

drivers/iio/adc/ad7380.c

416

AD7380_CHANNEL(7, bits, diff, sign), \

drivers/iio/adc/ad7380.c

420

#define AD7380_OFFLOAD_CHANNEL(index, bits, diff, sign) \

drivers/iio/adc/ad7380.c

421

_AD7380_OFFLOAD_CHANNEL(index, bits, diff, sign, false)

drivers/iio/adc/ad7380.c

423

#define ADAQ4380_OFFLOAD_CHANNEL(index, bits, diff, sign) \

drivers/iio/adc/ad7380.c

424

_AD7380_OFFLOAD_CHANNEL(index, bits, diff, sign, true)

drivers/iio/adc/ad7380.c

426

#define DEFINE_AD7380_2_OFFLOAD_CHANNEL(name, bits, diff, sign) \

drivers/iio/adc/ad7380.c

428

AD7380_OFFLOAD_CHANNEL(0, bits, diff, sign), \

drivers/iio/adc/ad7380.c

429

AD7380_OFFLOAD_CHANNEL(1, bits, diff, sign), \

drivers/iio/adc/ad7380.c

432

#define DEFINE_AD7380_4_OFFLOAD_CHANNEL(name, bits, diff, sign) \

drivers/iio/adc/ad7380.c

434

AD7380_OFFLOAD_CHANNEL(0, bits, diff, sign), \

drivers/iio/adc/ad7380.c

435

AD7380_OFFLOAD_CHANNEL(1, bits, diff, sign), \

drivers/iio/adc/ad7380.c

436

AD7380_OFFLOAD_CHANNEL(2, bits, diff, sign), \

drivers/iio/adc/ad7380.c

437

AD7380_OFFLOAD_CHANNEL(3, bits, diff, sign), \

drivers/iio/adc/ad7380.c

440

#define DEFINE_ADAQ4380_4_OFFLOAD_CHANNEL(name, bits, diff, sign) \

drivers/iio/adc/ad7380.c

442

AD7380_OFFLOAD_CHANNEL(0, bits, diff, sign), \

drivers/iio/adc/ad7380.c

443

AD7380_OFFLOAD_CHANNEL(1, bits, diff, sign), \

drivers/iio/adc/ad7380.c

444

AD7380_OFFLOAD_CHANNEL(2, bits, diff, sign), \

drivers/iio/adc/ad7380.c

445

AD7380_OFFLOAD_CHANNEL(3, bits, diff, sign), \

drivers/iio/adc/ad7380.c

448

#define DEFINE_AD7380_8_OFFLOAD_CHANNEL(name, bits, diff, sign) \

drivers/iio/adc/ad7380.c

450

AD7380_OFFLOAD_CHANNEL(0, bits, diff, sign), \

drivers/iio/adc/ad7380.c

451

AD7380_OFFLOAD_CHANNEL(1, bits, diff, sign), \

drivers/iio/adc/ad7380.c

452

AD7380_OFFLOAD_CHANNEL(2, bits, diff, sign), \

drivers/iio/adc/ad7380.c

453

AD7380_OFFLOAD_CHANNEL(3, bits, diff, sign), \

drivers/iio/adc/ad7380.c

454

AD7380_OFFLOAD_CHANNEL(4, bits, diff, sign), \

drivers/iio/adc/ad7380.c

455

AD7380_OFFLOAD_CHANNEL(5, bits, diff, sign), \

drivers/iio/adc/ad7380.c

456

AD7380_OFFLOAD_CHANNEL(6, bits, diff, sign), \

drivers/iio/adc/ad7380.c

457

AD7380_OFFLOAD_CHANNEL(7, bits, diff, sign), \

drivers/iio/adc/at91-sama5d2_adc.c

908

int nbits, diff;

drivers/iio/adc/at91-sama5d2_adc.c

928

diff = st->soc_info.platform->chan_realbits - nbits;

drivers/iio/adc/at91-sama5d2_adc.c

929

*val <<= diff;

drivers/iio/adc/stm32-adc.c

2175

struct stm32_adc_diff_channel diff[STM32_ADC_CH_MAX];

drivers/iio/adc/stm32-adc.c

2179

int size = num_diff * sizeof(*diff) / sizeof(u32);

drivers/iio/adc/stm32-adc.c

2185

(u32 *)diff, size);

drivers/iio/adc/stm32-adc.c

2192

if (diff[i].vinp >= adc_info->max_channels ||

drivers/iio/adc/stm32-adc.c

2193

diff[i].vinn >= adc_info->max_channels) {

drivers/iio/adc/stm32-adc.c

2195

diff[i].vinp, diff[i].vinn);

drivers/iio/adc/stm32-adc.c

2200

diff[i].vinp, diff[i].vinn,

drivers/iio/adc/stm32-adc.c

2221

if (chans[c] == diff[i].vinp) {

drivers/iio/addac/stx104.c

30

#define STX104_IN_CHAN(chan, diff) { \

drivers/iio/addac/stx104.c

38

.differential = diff \

drivers/iio/imu/adis16480.c

606

unsigned int diff, best_diff;

drivers/iio/imu/adis16480.c

628

diff = st->chip_info->filter_freqs[i] - freq;

drivers/iio/imu/adis16480.c

629

if (diff < best_diff) {

drivers/iio/imu/adis16480.c

630

best_diff = diff;

drivers/iio/industrialio-gts-helper.c

864

int i, diff = 0;

drivers/iio/industrialio-gts-helper.c

876

if (!diff) {

drivers/iio/industrialio-gts-helper.c

877

diff = gain - gts->hwgain_table[i].gain;

drivers/iio/industrialio-gts-helper.c

882

if (tmp < diff) {

drivers/iio/industrialio-gts-helper.c

883

diff = tmp;

drivers/iio/industrialio-gts-helper.c

897

if (!diff) {

drivers/iio/proximity/hx9023s.c

119

s16 diff; /* Difference of Low Pass Data and Base Line Data */

drivers/iio/proximity/hx9023s.c

551

data->ch_data[i].diff = 0;

drivers/iio/proximity/hx9023s.c

555

data->ch_data[i].diff = value;

drivers/iio/proximity/hx9023s.c

560

data->ch_data[i].diff = data->ch_data[i].lp - data->ch_data[i].bl;

drivers/iio/proximity/hx9023s.c

672

*val = data->ch_data[chan->channel].diff;

drivers/iio/proximity/hx9023s.c

956

data->buffer.channels[i++] = cpu_to_le16(data->ch_data[index].diff);

drivers/infiniband/hw/bnxt_re/ib_verbs.c

1369

int diff = 0;

drivers/infiniband/hw/bnxt_re/ib_verbs.c

1395

diff = (qplqp->wqe_mode == BNXT_QPLIB_WQE_MODE_VARIABLE) ?

drivers/infiniband/hw/bnxt_re/ib_verbs.c

1397

entries = bnxt_re_init_depth(entries + diff + 1, uctx);

drivers/infiniband/hw/bnxt_re/ib_verbs.c

1398

sq->max_wqe = min_t(u32, entries, dev_attr->max_qp_wqes + diff + 1);

drivers/infiniband/hw/bnxt_re/ib_verbs.c

1405

sq->q_full_delta = diff + 1;

drivers/infiniband/hw/hfi1/affinity.c

1029

ret = zalloc_cpumask_var(&diff, GFP_KERNEL);

drivers/infiniband/hw/hfi1/affinity.c

1083

if (cpumask_andnot(diff, hw_thread_mask, &set->used))

drivers/infiniband/hw/hfi1/affinity.c

1115

if (cpumask_andnot(diff, available_mask, intrs_mask))

drivers/infiniband/hw/hfi1/affinity.c

1116

cpumask_copy(available_mask, diff);

drivers/infiniband/hw/hfi1/affinity.c

1131

if (cpumask_andnot(diff, available_mask, intrs_mask))

drivers/infiniband/hw/hfi1/affinity.c

1132

cpumask_copy(available_mask, diff);

drivers/infiniband/hw/hfi1/affinity.c

1152

free_cpumask_var(diff);

drivers/infiniband/hw/hfi1/affinity.c

62

static int cpu_mask_set_get_first(struct cpu_mask_set *set, cpumask_var_t diff)

drivers/infiniband/hw/hfi1/affinity.c

66

if (!diff || !set)

drivers/infiniband/hw/hfi1/affinity.c

72

cpumask_andnot(diff, &set->mask, &set->used);

drivers/infiniband/hw/hfi1/affinity.c

74

cpu = cpumask_first(diff);

drivers/infiniband/hw/hfi1/affinity.c

827

cpumask_var_t diff;

drivers/infiniband/hw/hfi1/affinity.c

873

if (!zalloc_cpumask_var(&diff, GFP_KERNEL))

drivers/infiniband/hw/hfi1/affinity.c

876

cpu = cpu_mask_set_get_first(set, diff);

drivers/infiniband/hw/hfi1/affinity.c

878

free_cpumask_var(diff);

drivers/infiniband/hw/hfi1/affinity.c

883

free_cpumask_var(diff);

drivers/infiniband/hw/hfi1/affinity.c

980

cpumask_var_t diff, hw_thread_mask, available_mask, intrs_mask;

drivers/infiniband/hw/hfi1/driver.c

101

cap_mask &= ~diff;

drivers/infiniband/hw/hfi1/driver.c

73

cap_mask = *cap_mask_ptr, value, diff,

drivers/infiniband/hw/hfi1/driver.c

83

diff = value ^ (cap_mask & ~HFI1_CAP_LOCKED_SMASK);

drivers/infiniband/hw/hfi1/driver.c

86

if (HFI1_CAP_LOCKED() && (diff & ~write_mask)) {

drivers/infiniband/hw/hfi1/driver.c

88

diff & ~write_mask);

drivers/infiniband/hw/hfi1/driver.c

89

diff &= write_mask;

drivers/infiniband/hw/hfi1/driver.c

93

diff &= ~HFI1_CAP_RESERVED_MASK;

drivers/infiniband/hw/hfi1/driver.c

95

cap_mask &= ~diff;

drivers/infiniband/hw/hfi1/driver.c

97

cap_mask |= (value & diff);

drivers/infiniband/hw/hfi1/driver.c

99

diff = (cap_mask & (HFI1_CAP_MUST_HAVE_KERN << HFI1_CAP_USER_SHIFT)) ^

drivers/infiniband/hw/hfi1/rc.c

1483

int diff;

drivers/infiniband/hw/hfi1/rc.c

1490

diff = cmp_psn(psn, wqe->psn);

drivers/infiniband/hw/hfi1/rc.c

1491

if (diff < 0) {

drivers/infiniband/hw/hfi1/rc.c

1501

if (diff == 0) {

drivers/infiniband/hw/hfi1/rc.c

1973

int diff;

drivers/infiniband/hw/hfi1/rc.c

1993

while ((diff = delta_psn(ack_psn, wqe->lpsn)) >= 0) {

drivers/infiniband/hw/hfi1/rc.c

2002

diff == 0) {

drivers/infiniband/hw/hfi1/rc.c

2016

(opcode != OP(RDMA_READ_RESPONSE_LAST) || diff != 0)) ||

drivers/infiniband/hw/hfi1/rc.c

2018

(opcode != TID_OP(READ_RESP) || diff != 0)) ||

drivers/infiniband/hw/hfi1/rc.c

2021

(opcode != OP(ATOMIC_ACKNOWLEDGE) || diff != 0)) ||

drivers/infiniband/hw/hfi1/rc.c

2313

int diff;

drivers/infiniband/hw/hfi1/rc.c

2331

diff = cmp_psn(psn, qp->s_last_psn);

drivers/infiniband/hw/hfi1/rc.c

2332

if (unlikely(diff <= 0)) {

drivers/infiniband/hw/hfi1/rc.c

2334

if (diff == 0 && opcode == OP(ACKNOWLEDGE)) {

drivers/infiniband/hw/hfi1/rc.c

2512

int diff, struct hfi1_ctxtdata *rcd)

drivers/infiniband/hw/hfi1/rc.c

2522

if (diff > 0) {

drivers/infiniband/hw/hfi1/rc.c

2778

int diff;

drivers/infiniband/hw/hfi1/rc.c

2807

diff = delta_psn(psn, qp->r_psn);

drivers/infiniband/hw/hfi1/rc.c

2808

if (unlikely(diff)) {

drivers/infiniband/hw/hfi1/rc.c

2809

if (rc_rcv_error(ohdr, data, qp, opcode, psn, diff, rcd))

drivers/infiniband/hw/hfi1/rc.c

3215

int diff;

drivers/infiniband/hw/hfi1/rc.c

3227

diff = delta_psn(psn, qp->r_psn);

drivers/infiniband/hw/hfi1/rc.c

3228

if (!qp->r_nak_state && diff >= 0) {

drivers/infiniband/hw/hfi1/tid_rdma.c

130

struct rvt_qp *qp, u32 psn, int diff, bool fecn);

drivers/infiniband/hw/hfi1/tid_rdma.c

1987

struct rvt_qp *qp, u32 psn, int diff)

drivers/infiniband/hw/hfi1/tid_rdma.c

2000

trace_hfi1_tid_rdma_rcv_err(qp, 0, psn, diff);

drivers/infiniband/hw/hfi1/tid_rdma.c

2001

if (diff > 0) {

drivers/infiniband/hw/hfi1/tid_rdma.c

2242

int diff;

drivers/infiniband/hw/hfi1/tid_rdma.c

2266

diff = delta_psn(psn, qp->r_psn);

drivers/infiniband/hw/hfi1/tid_rdma.c

2267

if (unlikely(diff)) {

drivers/infiniband/hw/hfi1/tid_rdma.c

2268

tid_rdma_rcv_err(packet, ohdr, qp, psn, diff, fecn);

drivers/infiniband/hw/hfi1/tid_rdma.c

2670

int diff = 0;

drivers/infiniband/hw/hfi1/tid_rdma.c

2761

diff = cmp_psn(psn,

drivers/infiniband/hw/hfi1/tid_rdma.c

2763

if (diff > 0) {

drivers/infiniband/hw/hfi1/tid_rdma.c

2766

} else if (diff < 0) {

drivers/infiniband/hw/hfi1/tid_rdma.c

2867

int diff = 0;

drivers/infiniband/hw/hfi1/tid_rdma.c

2974

diff = cmp_psn(psn,

drivers/infiniband/hw/hfi1/tid_rdma.c

2976

if (diff > 0)

drivers/infiniband/hw/hfi1/tid_rdma.c

2978

else if (diff < 0)

drivers/infiniband/hw/hfi1/tid_rdma.c

3052

int diff, delta_pkts;

drivers/infiniband/hw/hfi1/tid_rdma.c

3082

diff = delta_pkts + flow->resync_npkts;

drivers/infiniband/hw/hfi1/tid_rdma.c

3088

if (diff) {

drivers/infiniband/hw/hfi1/tid_rdma.c

3096

npkts = min_t(u32, diff, tidnpkts);

drivers/infiniband/hw/hfi1/tid_rdma.c

3101

diff -= npkts;

drivers/infiniband/hw/hfi1/tid_rdma.c

3102

if (!diff)

drivers/infiniband/hw/hfi1/tid_rdma.c

3672

int diff;

drivers/infiniband/hw/hfi1/tid_rdma.c

3693

diff = delta_psn(psn, qp->r_psn);

drivers/infiniband/hw/hfi1/tid_rdma.c

3694

if (unlikely(diff)) {

drivers/infiniband/hw/hfi1/tid_rdma.c

3695

tid_rdma_rcv_err(packet, ohdr, qp, psn, diff, fecn);

drivers/infiniband/hw/hfi1/tid_rdma.c

5505

struct rvt_qp *qp, u32 psn, int diff, bool fecn)

drivers/infiniband/hw/hfi1/tid_rdma.c

5509

tid_rdma_rcv_error(packet, ohdr, qp, psn, diff);

drivers/infiniband/hw/hfi1/trace_tid.h

1272

TP_PROTO(struct rvt_qp *qp, u32 opcode, u32 psn, int diff),

drivers/infiniband/hw/hfi1/trace_tid.h

1273

TP_ARGS(qp, opcode, psn, diff),

drivers/infiniband/hw/hfi1/trace_tid.h

1285

__field(int, diff)

drivers/infiniband/hw/hfi1/trace_tid.h

1298

__entry->diff = diff;

drivers/infiniband/hw/hfi1/trace_tid.h

1312

__entry->diff

drivers/infiniband/hw/hfi1/trace_tid.h

1318

TP_PROTO(struct rvt_qp *qp, u32 opcode, u32 psn, int diff),

drivers/infiniband/hw/hfi1/trace_tid.h

1319

TP_ARGS(qp, opcode, psn, diff)

drivers/infiniband/sw/rxe/rxe_comp.c

179

s32 diff;

drivers/infiniband/sw/rxe/rxe_comp.c

184

diff = psn_compare(pkt->psn, wqe->last_psn);

drivers/infiniband/sw/rxe/rxe_comp.c

185

if (diff > 0) {

drivers/infiniband/sw/rxe/rxe_comp.c

198

diff = psn_compare(pkt->psn, qp->comp.psn);

drivers/infiniband/sw/rxe/rxe_comp.c

199

if (diff < 0) {

drivers/infiniband/sw/rxe/rxe_comp.c

211

} else if ((diff > 0) && (wqe->mask & WR_ATOMIC_OR_READ_MASK)) {

drivers/infiniband/sw/rxe/rxe_resp.c

73

int diff = psn_compare(pkt->psn, qp->resp.psn);

drivers/infiniband/sw/rxe/rxe_resp.c

78

if (diff > 0) {

drivers/infiniband/sw/rxe/rxe_resp.c

86

} else if (diff < 0) {

drivers/infiniband/sw/rxe/rxe_resp.c

97

if (qp->resp.drop_msg || diff != 0) {

drivers/infiniband/sw/rxe/rxe_verbs.h

29

s32 diff;

drivers/infiniband/sw/rxe/rxe_verbs.h

31

diff = (psn_a - psn_b) << 8;

drivers/infiniband/sw/rxe/rxe_verbs.h

32

return diff;

drivers/input/keyboard/adc-keys.c

36

u32 diff, closest = 0xffffffff;

drivers/input/keyboard/adc-keys.c

45

diff = abs(st->map[i].voltage - value);

drivers/input/keyboard/adc-keys.c

46

if (diff < closest) {

drivers/input/keyboard/adc-keys.c

47

closest = diff;

drivers/input/keyboard/hil_kbd.c

390

int diff = input_abs_get_max(input_dev, ABS_X + i) / 10;

drivers/input/keyboard/hil_kbd.c

392

input_abs_get_min(input_dev, ABS_X + i) + diff);

drivers/input/keyboard/hil_kbd.c

394

input_abs_get_max(input_dev, ABS_X + i) - diff);

drivers/input/keyboard/sun4i-lradc-keys.c

111

u32 i, ints, val, voltage, diff, keycode = 0, closest = 0xffffffff;

drivers/input/keyboard/sun4i-lradc-keys.c

130

diff = abs(lradc->chan0_map[i].voltage - voltage);

drivers/input/keyboard/sun4i-lradc-keys.c

131

if (diff < closest) {

drivers/input/keyboard/sun4i-lradc-keys.c

132

closest = diff;

drivers/leds/flash/leds-tps6131x.c

213

u32 diff, min_diff = U32_MAX;

drivers/leds/flash/leds-tps6131x.c

217

diff = abs(tps6131x_timer_configs[i].time_us - timeout_us);

drivers/leds/flash/leds-tps6131x.c

218

if (diff < min_diff) {

drivers/leds/flash/leds-tps6131x.c

220

min_diff = diff;

drivers/leds/leds-tca6507.c

209

int diff = 65536;

drivers/leds/leds-tca6507.c

229

if (d >= diff)

drivers/leds/leds-tca6507.c

234

diff = d;

drivers/leds/leds-tca6507.c

239

if (diff < 65536) {

drivers/leds/leds-tca6507.c

400

int diff = 15-level;

drivers/leds/leds-tca6507.c

415

if (d < diff) {

drivers/leds/leds-tca6507.c

416

diff = d;

drivers/macintosh/via-pmu-backlight.c

51

int diff = abs(bl_curve[i] - value);

drivers/macintosh/via-pmu-backlight.c

52

if (diff < max) {

drivers/macintosh/via-pmu-backlight.c

53

max = diff;

drivers/md/dm-bufio.c

1099

long diff;

drivers/md/dm-bufio.c

1109

diff = (long)b->c->block_size;

drivers/md/dm-bufio.c

1111

diff = -diff;

drivers/md/dm-bufio.c

1115

*class_ptr[data_mode] += diff;

drivers/md/dm-bufio.c

1117

dm_bufio_current_allocated += diff;

drivers/md/raid10.c

3985

long long diff;

drivers/md/raid10.c

4004

diff = (rdev->new_data_offset - rdev->data_offset);

drivers/md/raid10.c

4006

diff = -diff;

drivers/md/raid10.c

4007

if (diff < 0)

drivers/md/raid10.c

4008

diff = 0;

drivers/md/raid10.c

4009

if (first || diff < min_offset_diff)

drivers/md/raid10.c

4010

min_offset_diff = diff;

drivers/md/raid10.c

4383

long long diff = (rdev->new_data_offset

drivers/md/raid10.c

4386

diff = -diff;

drivers/md/raid10.c

4387

if (diff < 0)

drivers/md/raid10.c

4388

diff = 0;

drivers/md/raid10.c

4389

if (first || diff < min_offset_diff)

drivers/md/raid10.c

4390

min_offset_diff = diff;

drivers/md/raid5.c

7842

long long diff;

drivers/md/raid5.c

7850

diff = (rdev->new_data_offset - rdev->data_offset);

drivers/md/raid5.c

7852

min_offset_diff = diff;

drivers/md/raid5.c

7855

diff < min_offset_diff)

drivers/md/raid5.c

7856

min_offset_diff = diff;

drivers/md/raid5.c

7858

diff > min_offset_diff)

drivers/md/raid5.c

7859

min_offset_diff = diff;

drivers/media/i2c/mt9v111.c

455

unsigned int diff;

drivers/media/i2c/mt9v111.c

465

diff = abs(fps - mt9v111_frame_intervals[i]);

drivers/media/i2c/mt9v111.c

466

if (diff < best_diff) {

drivers/media/i2c/mt9v111.c

468

best_diff = diff;

drivers/media/i2c/mt9v111.c

502

diff = abs(fps - t_fps);

drivers/media/i2c/mt9v111.c

503

if (diff < best_diff) {

drivers/media/i2c/mt9v111.c

504

best_diff = diff;

drivers/media/i2c/mt9v111.c

507

if (diff == 0)

drivers/media/i2c/mt9v111.c

512

if (diff == 0)

drivers/media/i2c/ov772x.c

622

unsigned int diff;

drivers/media/i2c/ov772x.c

629

diff = abs(fps - ov772x_frame_intervals[i]);

drivers/media/i2c/ov772x.c

630

if (diff < best_diff) {

drivers/media/i2c/ov772x.c

632

best_diff = diff;

drivers/media/i2c/ov772x.c

648

unsigned int diff;

drivers/media/i2c/ov772x.c

701

diff = abs(pclk - t_pclk);

drivers/media/i2c/ov772x.c

702

if (diff < best_diff) {

drivers/media/i2c/ov772x.c

703

best_diff = diff;

drivers/media/i2c/ov772x.c

977

u32 diff = abs(width - ov772x_win_sizes[i].rect.width)

drivers/media/i2c/ov772x.c

979

if (diff < best_diff) {

drivers/media/i2c/ov772x.c

980

best_diff = diff;

drivers/media/i2c/tw9910.c

428

__u32 diff = 0xffffffff, tmp;

drivers/media/i2c/tw9910.c

444

if (tmp < diff) {

drivers/media/i2c/tw9910.c

445

diff = tmp;

drivers/media/pci/ddbridge/ddbridge-core.c

573

s32 diff;

drivers/media/pci/ddbridge/ddbridge-core.c

584

diff = off - output->dma->coff;

drivers/media/pci/ddbridge/ddbridge-core.c

585

if (diff <= 0 || diff > (2 * 188))

drivers/media/pci/solo6x10/solo6x10-core.c

54

long diff;

drivers/media/pci/solo6x10/solo6x10-core.c

69

diff = (s32)ts.tv_sec - (s32)sec;

drivers/media/pci/solo6x10/solo6x10-core.c

70

diff = (diff * 1000000)

drivers/media/pci/solo6x10/solo6x10-core.c

73

if (diff > 1000 || diff < -1000) {

drivers/media/pci/solo6x10/solo6x10-core.c

75

} else if (diff) {

drivers/media/pci/solo6x10/solo6x10-core.c

78

usec_lsb -= diff / 4;

drivers/media/platform/chips-media/coda/coda-h264.c

69

int diff;

drivers/media/platform/chips-media/coda/coda-h264.c

71

diff = size - (size & ~0x7);

drivers/media/platform/chips-media/coda/coda-h264.c

72

if (diff == 0)

drivers/media/platform/chips-media/coda/coda-h264.c

75

nal_size = coda_filler_size[diff];

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_av1_req_lat_if.c

1474

int diff = 0;

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_av1_req_lat_if.c

1481

diff = a - b;

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_av1_req_lat_if.c

1483

diff = (diff & (m - 1)) - (diff & m);

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_av1_req_lat_if.c

1485

if (diff > 0)

drivers/media/platform/microchip/microchip-isc-clk.c

144

int diff;

drivers/media/platform/microchip/microchip-isc-clk.c

147

diff = abs(req->rate - rate);

drivers/media/platform/microchip/microchip-isc-clk.c

149

if (best_diff < 0 || best_diff > diff) {

drivers/media/platform/microchip/microchip-isc-clk.c

151

best_diff = diff;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

649

int diff, m;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

654

diff = a - b;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

656

diff = (diff & (m - 1)) - (diff & m);

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

658

return diff;

drivers/media/tuners/mt2060.c

137

int dia,diamin,diff;

drivers/media/tuners/mt2060.c

141

diff = I*(int)lo1-J*(int)lo2;

drivers/media/tuners/mt2060.c

142

if (diff < 0) diff=-diff;

drivers/media/tuners/mt2060.c

143

dia = (diff-(int)if2);

drivers/mfd/sm501.c

413

long diff;

drivers/mfd/sm501.c

422

diff = DIV_ROUND_CLOSEST(mclk, divider << shift) - freq;

drivers/mfd/sm501.c

423

if (diff < 0)

drivers/mfd/sm501.c

424

diff = -diff;

drivers/mfd/sm501.c

427

if (diff < *best_diff) {

drivers/mfd/sm501.c

428

*best_diff = diff;

drivers/misc/dw-xdata-pcie.c

166

u64 data[2], time[2], diff;

drivers/misc/dw-xdata-pcie.c

193

diff = jiffies_to_nsecs(time[1] - time[0]);

drivers/misc/dw-xdata-pcie.c

194

*rate = dw_xdata_perf_diff(&data[1], &data[0], diff);

drivers/misc/dw-xdata-pcie.c

199

diff, str_write_read(write), *rate);

drivers/mmc/core/debugfs.c

313

u32 diff = *caps ^ val;

drivers/mmc/core/debugfs.c

323

if (diff & ~allowed)

drivers/mmc/core/debugfs.c

338

u32 diff = *caps ^ val;

drivers/mmc/core/debugfs.c

340

if (diff & ~allowed)

drivers/mmc/host/alcor.c

656

int i, diff = 0x7fffffff, tmp_clock = 0;

drivers/mmc/host/alcor.c

676

if (tmp_diff < diff) {

drivers/mmc/host/alcor.c

677

diff = tmp_diff;

drivers/mmc/host/renesas_sdhi_core.c

132

unsigned int freq, diff, best_freq = 0, diff_min = ~0;

drivers/mmc/host/renesas_sdhi_core.c

177

diff = new_clock - (freq >> i);

drivers/mmc/host/renesas_sdhi_core.c

178

if (diff <= diff_min) {

drivers/mmc/host/renesas_sdhi_core.c

180

diff_min = diff;

drivers/mmc/host/sh_mmcif.c

494

unsigned int freq, best_freq, myclk, div, diff_min, diff;

drivers/mmc/host/sh_mmcif.c

512

diff = (myclk > clk) ? myclk - clk : clk - myclk;

drivers/mmc/host/sh_mmcif.c

514

if (diff <= diff_min) {

drivers/mmc/host/sh_mmcif.c

517

diff_min = diff;

drivers/mtd/mtdcore.c

1545

struct mtd_ecc_stats diff;

drivers/mtd/mtdcore.c

1550

diff = master->ecc_stats;

drivers/mtd/mtdcore.c

1551

diff.failed -= old_stats->failed;

drivers/mtd/mtdcore.c

1552

diff.corrected -= old_stats->corrected;

drivers/mtd/mtdcore.c

1555

mtd->ecc_stats.failed += diff.failed;

drivers/mtd/mtdcore.c

1556

mtd->ecc_stats.corrected += diff.corrected;

drivers/mtd/nand/raw/atmel/pmecc.c

500

int diff;

drivers/mtd/nand/raw/atmel/pmecc.c

577

diff = (mu[i] - mu[ro]);

drivers/mtd/nand/raw/atmel/pmecc.c

580

if ((lmu[i] >> 1) > ((lmu[ro] >> 1) + diff))

drivers/mtd/nand/raw/atmel/pmecc.c

583

lmu[i + 1] = ((lmu[ro] >> 1) + diff) * 2;

drivers/mtd/nand/raw/atmel/pmecc.c

601

smu[(i + 1) * num + (k + diff)] = a;

drivers/mtd/nand/raw/davinci_nand.c

211

uint32_t diff = eccCalc ^ eccNand;

drivers/mtd/nand/raw/davinci_nand.c

213

if (diff) {

drivers/mtd/nand/raw/davinci_nand.c

214

if ((((diff >> 12) ^ diff) & 0xfff) == 0xfff) {

drivers/mtd/nand/raw/davinci_nand.c

216

if ((diff >> (12 + 3)) < chip->ecc.size) {

drivers/mtd/nand/raw/davinci_nand.c

217

dat[diff >> (12 + 3)] ^= BIT((diff >> 12) & 7);

drivers/mtd/nand/raw/davinci_nand.c

222

} else if (!(diff & (diff - 1))) {

drivers/mtd/tests/torturetest.c

419

char *diff;

drivers/mtd/tests/torturetest.c

424

diff = " ";

drivers/mtd/tests/torturetest.c

428

diff = "***";

drivers/mtd/tests/torturetest.c

436

printk(" %s ", diff);

drivers/mtd/ubi/wl.c

326

struct rb_root *root, int diff,

drivers/mtd/ubi/wl.c

334

max = e->ec + diff;

drivers/net/dsa/microchip/ksz_ptp.c

431

struct timespec64 diff;

drivers/net/dsa/microchip/ksz_ptp.c

445

diff = timespec64_sub(ts, ptp_clock_time);

drivers/net/dsa/microchip/ksz_ptp.c

446

if (diff.tv_sec > 2)

drivers/net/dsa/microchip/ksz_ptp.c

448

else if (diff.tv_sec < -2)

drivers/net/dsa/mv88e6xxx/ptp.c

247

u32 diff, mult;

drivers/net/dsa/mv88e6xxx/ptp.c

258

diff = div_u64(adj, chip->cc_coeffs->cc_mult_dem);

drivers/net/dsa/mv88e6xxx/ptp.c

263

chip->tstamp_cc.mult = neg_adj ? mult - diff : mult + diff;

drivers/net/dsa/sja1105/sja1105_tas.c

731

struct timespec64 diff;

drivers/net/dsa/sja1105/sja1105_tas.c

799

diff = ns_to_timespec64(tas_data->oper_base_time - now);

drivers/net/dsa/sja1105/sja1105_tas.c

800

dev_dbg(ds->dev, "time to start: [%ptSp]", &diff);

drivers/net/ethernet/airoha/airoha_ppe.c

1395

u16 now, diff;

drivers/net/ethernet/airoha/airoha_ppe.c

1401

diff = now - ppe->foe_check_time[hash];

drivers/net/ethernet/airoha/airoha_ppe.c

1402

if (diff < HZ / 10)

drivers/net/ethernet/broadcom/bnx2.c

248

u32 diff;

drivers/net/ethernet/broadcom/bnx2.c

253

diff = READ_ONCE(txr->tx_prod) - READ_ONCE(txr->tx_cons);

drivers/net/ethernet/broadcom/bnx2.c

254

if (unlikely(diff >= BNX2_TX_DESC_CNT)) {

drivers/net/ethernet/broadcom/bnx2.c

255

diff &= 0xffff;

drivers/net/ethernet/broadcom/bnx2.c

256

if (diff == BNX2_TX_DESC_CNT)

drivers/net/ethernet/broadcom/bnx2.c

257

diff = BNX2_MAX_TX_DESC_CNT;

drivers/net/ethernet/broadcom/bnx2.c

259

return bp->tx_ring_size - diff;

drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c

1732

int diff = msix_vec - rc;

drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c

1739

bp->num_ethernet_queues -= diff;

drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.c

556

} diff;

drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.c

811

} diff;

drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.c

957

u32 diff;

drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.h

396

DIFF_64(diff.hi, new->s##_hi, pstats->mac_stx[0].t##_hi, \

drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.h

397

diff.lo, new->s##_lo, pstats->mac_stx[0].t##_lo); \

drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.h

400

ADD_64(pstats->mac_stx[1].t##_hi, diff.hi, \

drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.h

401

pstats->mac_stx[1].t##_lo, diff.lo); \

drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.h

406

DIFF_64(diff.hi, new->s##_hi, old->s##_hi, \

drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.h

407

diff.lo, new->s##_lo, old->s##_lo); \

drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.h

408

ADD_64(estats->t##_hi, diff.hi, \

drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.h

409

estats->t##_lo, diff.lo); \

drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.h

419

#define ADD_STAT64(diff, t) \

drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.h

421

ADD_64(pstats->mac_stx[1].t##_hi, new->diff##_hi, \

drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.h

422

pstats->mac_stx[1].t##_lo, new->diff##_lo); \

drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.h

434

diff = le##size##_to_cpu(tclient->s) - \

drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.h

437

ADD_EXTEND_64(qstats->t##_hi, qstats->t##_lo, diff); \

drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.h

445

ADD_EXTEND_64(estats->t##_hi, estats->t##_lo, diff); \

drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.h

450

diff = le32_to_cpu(uclient->s) - le32_to_cpu(old_uclient->s); \

drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.h

452

ADD_EXTEND_64(qstats->t##_hi, qstats->t##_lo, diff); \

drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.h

458

ADD_EXTEND_64(estats->t##_hi, estats->t##_lo, diff); \

drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.h

463

diff = le32_to_cpu(xclient->s) - le32_to_cpu(old_xclient->s); \

drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.h

465

ADD_EXTEND_64(qstats->t##_hi, qstats->t##_lo, diff); \

drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.h

543

diff = le32_to_cpu(uclient->s) - le32_to_cpu(old_uclient->s); \

drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.h

544

SUB_EXTEND_64(qstats->t##_hi, qstats->t##_lo, diff); \

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

12140

u16 diff = advertising ^ supported;

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

12142

return ((supported | diff) != supported);

drivers/net/ethernet/google/gve/gve_rx_dqo.c

467

s32 diff = hwts - low;

drivers/net/ethernet/google/gve/gve_rx_dqo.c

469

return ns_to_ktime(last_read + diff);

drivers/net/ethernet/intel/idpf/idpf_ptp.c

520

u64 incval, diff;

drivers/net/ethernet/intel/idpf/idpf_ptp.c

529

diff = adjust_by_scaled_ppm(incval, scaled_ppm);

drivers/net/ethernet/intel/idpf/idpf_ptp.c

530

err = idpf_ptp_adj_dev_clk_fine(adapter, diff);

drivers/net/ethernet/mediatek/mtk_eth_soc.c

3199

netdev_features_t diff = dev->features ^ features;

drivers/net/ethernet/mediatek/mtk_eth_soc.c

3201

if ((diff & NETIF_F_LRO) && !(features & NETIF_F_LRO))

drivers/net/ethernet/mediatek/mtk_ppe.c

852

struct mtk_foe_accounting *diff)

drivers/net/ethernet/mediatek/mtk_ppe.c

869

if (diff) {

drivers/net/ethernet/mediatek/mtk_ppe.c

870

diff->bytes = bytes;

drivers/net/ethernet/mediatek/mtk_ppe.c

871

diff->packets = packets;

drivers/net/ethernet/mediatek/mtk_ppe.h

358

u16 now, diff;

drivers/net/ethernet/mediatek/mtk_ppe.h

367

diff = now - ppe->foe_check_time[hash];

drivers/net/ethernet/mediatek/mtk_ppe.h

368

if (diff < HZ / 10)

drivers/net/ethernet/mediatek/mtk_ppe.h

404

struct mtk_foe_accounting *diff);

drivers/net/ethernet/mediatek/mtk_ppe_offload.c

544

struct mtk_foe_accounting diff;

drivers/net/ethernet/mediatek/mtk_ppe_offload.c

557

&diff)) {

drivers/net/ethernet/mediatek/mtk_ppe_offload.c

558

f->stats.pkts += diff.packets;

drivers/net/ethernet/mediatek/mtk_ppe_offload.c

559

f->stats.bytes += diff.bytes;

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

103

(s64)diff, sq->sqn);

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

88

ktime_t diff;

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

90

diff = abs(mlx5e_skb_cb_get_hwts(skb)->port_hwtstamp -

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

94

if (diff > (NSEC_PER_SEC >> 7)) {

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

98

ptpsq->cq_stats->abort_abs_diff_ns += diff;

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

99

if (diff > (NSEC_PER_SEC >> 1) &&

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

476

char *storage, char *output, int diff)

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

481

__mlxsw_item_set32(output, output_item, 0, value + diff);

drivers/net/ethernet/meta/fbnic/fbnic_hw_stats.c

31

u32 prev_upper, upper, lower, diff;

drivers/net/ethernet/meta/fbnic/fbnic_hw_stats.c

37

diff = upper - prev_upper;

drivers/net/ethernet/meta/fbnic/fbnic_hw_stats.c

38

if (!diff)

drivers/net/ethernet/meta/fbnic/fbnic_hw_stats.c

41

if (diff > 1)

drivers/net/ethernet/microchip/lan966x/lan966x_tc_flower.c

386

int diff, err = 0;

drivers/net/ethernet/microchip/lan966x/lan966x_tc_flower.c

394

diff = vcap_chain_offset(vctrl, f->common.chain_index, to_cid);

drivers/net/ethernet/microchip/lan966x/lan966x_tc_flower.c

395

if (!diff)

drivers/net/ethernet/microchip/lan966x/lan966x_tc_flower.c

401

err = vcap_rule_add_action_u32(vrule, VCAP_AF_PAG_VAL, diff);

drivers/net/ethernet/microchip/lan966x/lan966x_tc_flower.c

413

diff);

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

647

int diff, err = 0;

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

655

diff = vcap_chain_offset(vctrl, from_cid, to_cid);

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

656

if (!diff)

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

662

err = vcap_rule_add_action_u32(vrule, VCAP_AF_NXT_IDX, diff);

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

672

err = vcap_rule_add_action_u32(vrule, VCAP_AF_PAG_VAL, diff);

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

685

diff);

drivers/net/ethernet/microchip/vcap/vcap_api.c

1661

int diff = to_cid - from_cid;

drivers/net/ethernet/microchip/vcap/vcap_api.c

1663

if (diff < 0) /* Wrong direction */

drivers/net/ethernet/microchip/vcap/vcap_api.c

1664

return diff;

drivers/net/ethernet/microchip/vcap/vcap_api.c

1668

diff %= VCAP_CID_LOOKUP_SIZE; /* Limit to a value within a lookup */

drivers/net/ethernet/microchip/vcap/vcap_api.c

1669

return diff;

drivers/net/ethernet/pensando/ionic/ionic_phc.c

539

u64 delay, diff, mult;

drivers/net/ethernet/pensando/ionic/ionic_phc.c

582

diff = U64_MAX / phc->cc.mult / 2;

drivers/net/ethernet/pensando/ionic/ionic_phc.c

585

diff = (u64)IONIC_PHC_UPDATE_NS << (phc->cc.shift + 2);

drivers/net/ethernet/pensando/ionic/ionic_phc.c

586

diff = DIV_ROUND_UP(diff, phc->cc.mult);

drivers/net/ethernet/pensando/ionic/ionic_phc.c

590

diff |= diff >> 1;

drivers/net/ethernet/pensando/ionic/ionic_phc.c

591

diff |= diff >> 2;

drivers/net/ethernet/pensando/ionic/ionic_phc.c

592

diff |= diff >> 4;

drivers/net/ethernet/pensando/ionic/ionic_phc.c

593

diff |= diff >> 8;

drivers/net/ethernet/pensando/ionic/ionic_phc.c

594

diff |= diff >> 16;

drivers/net/ethernet/pensando/ionic/ionic_phc.c

595

diff |= diff >> 32;

drivers/net/ethernet/pensando/ionic/ionic_phc.c

598

diff &= phc->cc.mask;

drivers/net/ethernet/pensando/ionic/ionic_phc.c

617

mult = U64_MAX / 2 / max(diff / 2, SCALED_PPM);

drivers/net/ethernet/pensando/ionic/ionic_phc.c

637

cyclecounter_cyc2ns(&phc->cc, diff / 4, 0, &frac));

drivers/net/ethernet/qualcomm/rmnet/rmnet_map_data.c

585

struct timespec64 diff, last;

drivers/net/ethernet/qualcomm/rmnet/rmnet_map_data.c

599

diff = timespec64_sub(port->agg_last, last);

drivers/net/ethernet/qualcomm/rmnet/rmnet_map_data.c

608

if (diff.tv_sec > 0 || diff.tv_nsec > RMNET_AGG_BYPASS_TIME_NSEC ||

drivers/net/ethernet/qualcomm/rmnet/rmnet_map_data.c

623

diff = timespec64_sub(port->agg_last, port->agg_time);

drivers/net/ethernet/qualcomm/rmnet/rmnet_map_data.c

647

if (diff.tv_sec > 0 || diff.tv_nsec > port->egress_agg_params.time_nsec ||

drivers/net/ethernet/renesas/rcar_gen4_ptp.c

43

s64 diff;

drivers/net/ethernet/renesas/rcar_gen4_ptp.c

47

diff = div_s64(addend * scaled_ppm_to_ppb(scaled_ppm), NSEC_PER_SEC);

drivers/net/ethernet/renesas/rcar_gen4_ptp.c

48

addend = neg_adj ? addend - diff : addend + diff;

drivers/net/ethernet/sfc/falcon/nic.h

447

static inline void ef4_update_diff_stat(u64 *stat, u64 diff)

drivers/net/ethernet/sfc/falcon/nic.h

449

if ((s64)(diff - *stat) > 0)

drivers/net/ethernet/sfc/falcon/nic.h

450

*stat = diff;

drivers/net/ethernet/sfc/nic_common.h

213

static inline void efx_update_diff_stat(u64 *stat, u64 diff)

drivers/net/ethernet/sfc/nic_common.h

215

if ((s64)(diff - *stat) > 0)

drivers/net/ethernet/sfc/nic_common.h

216

*stat = diff;

drivers/net/ethernet/sfc/ptp.c

2032

u32 diff, carry;

drivers/net/ethernet/sfc/ptp.c

2043

diff = pkt_timestamp_minor - channel->sync_timestamp_minor;

drivers/net/ethernet/sfc/ptp.c

2045

diff += ptp->nic_time.minor_max;

drivers/net/ethernet/sfc/ptp.c

2048

carry = (channel->sync_timestamp_minor >= ptp->nic_time.minor_max - diff) ?

drivers/net/ethernet/sfc/ptp.c

2051

if (diff <= ptp->nic_time.sync_event_diff_max) {

drivers/net/ethernet/sfc/ptp.c

2056

} else if (diff >= ptp->nic_time.sync_event_diff_min) {

drivers/net/ethernet/sfc/siena/nic_common.h

212

static inline void efx_update_diff_stat(u64 *stat, u64 diff)

drivers/net/ethernet/sfc/siena/nic_common.h

214

if ((s64)(diff - *stat) > 0)

drivers/net/ethernet/sfc/siena/nic_common.h

215

*stat = diff;

drivers/net/ethernet/sfc/siena/ptp.c

1990

u32 diff, carry;

drivers/net/ethernet/sfc/siena/ptp.c

2001

diff = pkt_timestamp_minor - channel->sync_timestamp_minor;

drivers/net/ethernet/sfc/siena/ptp.c

2003

diff += ptp->nic_time.minor_max;

drivers/net/ethernet/sfc/siena/ptp.c

2006

carry = (channel->sync_timestamp_minor >= ptp->nic_time.minor_max - diff) ?

drivers/net/ethernet/sfc/siena/ptp.c

2009

if (diff <= ptp->nic_time.sync_event_diff_max) {

drivers/net/ethernet/sfc/siena/ptp.c

2014

} else if (diff >= ptp->nic_time.sync_event_diff_min) {

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

793

s64 diff;

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

812

diff = taprio_new->base_time - taprio_oper->base_time;

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

813

diff = diff < 0 ? -diff : diff;

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

814

if (diff % taprio_new->cycle_time)

drivers/net/fddi/skfp/hwt.c

221

long diff ;

drivers/net/fddi/skfp/hwt.c

236

diff = (long)(start - hwt_quick_read(smc)) ;

drivers/net/fddi/skfp/hwt.c

237

if (diff < 0) {

drivers/net/fddi/skfp/hwt.c

238

diff += interval ;

drivers/net/fddi/skfp/hwt.c

240

} while (diff <= duration) ;

drivers/net/fddi/skfp/hwt.c

243

diff = interval ;

drivers/net/fddi/skfp/hwt.c

248

diff += interval ;

drivers/net/fddi/skfp/hwt.c

257

} while (diff <= duration) ;

drivers/net/phy/bcm-phy-ptp.c

348

u32 diff, freq;

drivers/net/phy/bcm-phy-ptp.c

358

diff = div_u64(adj, 15625);

drivers/net/phy/bcm-phy-ptp.c

359

freq = (8 << 28) + (neg_adj ? -diff : diff);

drivers/net/phy/dp83640.c

621

s64 now, diff;

drivers/net/phy/dp83640.c

707

diff = now - (s64) phy2txts(&event_ts);

drivers/net/phy/dp83640.c

709

diff);

drivers/net/phy/dp83640.c

710

diff += ADJTIME_FIX;

drivers/net/phy/dp83640.c

711

ts = ns_to_timespec64(diff);

drivers/net/vxlan/vxlan_core.c

2162

bool diff;

drivers/net/vxlan/vxlan_core.c

2164

diff = !ether_addr_equal(eth_hdr(skb)->h_dest, n->ha);

drivers/net/vxlan/vxlan_core.c

2165

if (diff) {

drivers/net/vxlan/vxlan_core.c

2171

return diff;

drivers/net/wan/ixp4xx_hss.c

1252

u32 a, b, diff = 0xFFFFFFFF;

drivers/net/wan/ixp4xx_hss.c

1257

check_clock(timer_freq, rate, 0x3FF, 1, 1, best, &diff, reg);

drivers/net/wan/ixp4xx_hss.c

1266

check_clock(timer_freq, rate, a - 1, 1, 1, best, &diff, reg);

drivers/net/wan/ixp4xx_hss.c

1278

&diff, reg))

drivers/net/wan/ixp4xx_hss.c

1281

&diff, reg);

drivers/net/wan/ixp4xx_hss.c

1284

if (!check_clock(timer_freq, rate, a, b, c, best, &diff, reg))

drivers/net/wan/ixp4xx_hss.c

1286

if (!check_clock(timer_freq, rate, a, b, c + 1, best, &diff,

drivers/net/wireless/ath/ath11k/cfr.c

120

u64 diff;

drivers/net/wireless/ath/ath11k/cfr.c

140

diff = lut->dbr_tstamp - lut->txrx_tstamp;

drivers/net/wireless/ath/ath11k/cfr.c

143

jiffies_to_msecs(diff));

drivers/net/wireless/ath/ath11k/cfr.c

145

diff = lut->txrx_tstamp - lut->dbr_tstamp;

drivers/net/wireless/ath/ath11k/cfr.c

148

jiffies_to_msecs(diff));

drivers/net/wireless/ath/ath9k/eeprom_9287.c

366

int16_t diff = 0;

drivers/net/wireless/ath/ath9k/eeprom_9287.c

462

diff = (u16)(pEepData->baseEepHeader.pwrTableOffset -

drivers/net/wireless/ath/ath9k/eeprom_9287.c

464

diff *= 2;

drivers/net/wireless/ath/ath9k/eeprom_9287.c

466

for (j = 0; j < ((u16)AR5416_NUM_PDADC_VALUES-diff); j++)

drivers/net/wireless/ath/ath9k/eeprom_9287.c

467

pdadcValues[j] = pdadcValues[j+diff];

drivers/net/wireless/ath/ath9k/eeprom_9287.c

469

for (j = (u16)(AR5416_NUM_PDADC_VALUES-diff);

drivers/net/wireless/ath/ath9k/eeprom_9287.c

472

pdadcValues[AR5416_NUM_PDADC_VALUES-diff];

drivers/net/wireless/ath/ath9k/eeprom_def.c

696

int16_t *diff)

drivers/net/wireless/ath/ath9k/eeprom_def.c

711

*diff = (u16)(pwr_table_offset - AR5416_PWR_TABLE_OFFSET_DB);

drivers/net/wireless/ath/ath9k/eeprom_def.c

713

*diff *= 2;

drivers/net/wireless/ath/ath9k/eeprom_def.c

718

gb[k] = (u16)(gb[k] - *diff);

drivers/net/wireless/ath/ath9k/eeprom_def.c

729

return *diff;

drivers/net/wireless/ath/ath9k/eeprom_def.c

734

int16_t diff,

drivers/net/wireless/ath/ath9k/eeprom_def.c

737

#define NUM_PDADC(diff) (AR5416_NUM_PDADC_VALUES - diff)

drivers/net/wireless/ath/ath9k/eeprom_def.c

748

for (k = 0; k < (u16)NUM_PDADC(diff); k++ ) {

drivers/net/wireless/ath/ath9k/eeprom_def.c

749

pdadcValues[k] = pdadcValues[k + diff];

drivers/net/wireless/ath/ath9k/eeprom_def.c

753

for (k = (u16)NUM_PDADC(diff); k < NUM_PDADC(0); k++) {

drivers/net/wireless/ath/ath9k/eeprom_def.c

754

pdadcValues[k] = pdadcValues[NUM_PDADC(diff)];

drivers/net/wireless/ath/ath9k/eeprom_def.c

775

int16_t diff = 0;

drivers/net/wireless/ath/ath9k/eeprom_def.c

863

diff = ath9k_change_gain_boundary_setting(ah,

drivers/net/wireless/ath/ath9k/eeprom_def.c

868

&diff);

drivers/net/wireless/ath/ath9k/eeprom_def.c

891

diff, pdadcValues);

drivers/net/wireless/ath/carl9170/fw.c

137

unsigned long fin, diff;

drivers/net/wireless/ath/carl9170/fw.c

166

diff = fin - (unsigned long) otus_desc;

drivers/net/wireless/ath/carl9170/fw.c

168

if (diff < len)

drivers/net/wireless/ath/carl9170/fw.c

169

len -= diff;

drivers/net/wireless/broadcom/b43/ppr.c

25

void b43_ppr_add(struct b43_wldev *dev, struct b43_ppr *ppr, int diff)

drivers/net/wireless/broadcom/b43/ppr.c

31

*rate = clamp_val(*rate + diff, 0, 127);

drivers/net/wireless/broadcom/b43/ppr.h

38

void b43_ppr_add(struct b43_wldev *dev, struct b43_ppr *ppr, int diff);

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

64

u64 diff;

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

79

diff = scale_time_gp2_ns - base_time_ns;

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

80

scaled_diff = -mul_u64_u64_div_u64(diff,

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

84

diff = base_time_ns - scale_time_gp2_ns;

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

85

scaled_diff = mul_u64_u64_div_u64(diff,

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

92

(unsigned long long)diff, (long long)scaled_diff);

drivers/net/wireless/intel/iwlwifi/mvm/debugfs-vif.c

450

s64 diff;

drivers/net/wireless/intel/iwlwifi/mvm/debugfs-vif.c

460

diff = curr_os - curr_gp2;

drivers/net/wireless/intel/iwlwifi/mvm/debugfs-vif.c

461

pos += scnprintf(buf + pos, bufsz - pos, "diff=%lld\n", diff);

drivers/net/wireless/intel/iwlwifi/mvm/ftm-initiator.c

1042

u32 curr_gp2, diff;

drivers/net/wireless/intel/iwlwifi/mvm/ftm-initiator.c

1049

diff = curr_gp2 - gp2_ts;

drivers/net/wireless/intel/iwlwifi/mvm/ftm-initiator.c

1051

diff = curr_gp2 + (U32_MAX - gp2_ts + 1);

drivers/net/wireless/intel/iwlwifi/mvm/ftm-initiator.c

1053

return now_from_boot_ns - (u64)diff * 1000;

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

130

u64 diff = 0, new_diff;

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

139

if (!diff || new_diff < diff) {

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

142

diff = new_diff;

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

52

u64 diff;

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

71

diff = base_time_ns - last_gp2_ns;

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

72

IWL_DEBUG_INFO(mvm, "diff ns=%llu\n", (unsigned long long)diff);

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

74

diff = mul_u64_u64_div_u64(diff, data->scaled_freq,

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

76

IWL_DEBUG_INFO(mvm, "scaled diff ns=%llu\n", (unsigned long long)diff);

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

78

res = data->scale_update_adj_time_ns + data->delta + diff;

drivers/net/wireless/mediatek/mt76/mac80211.c

1209

int cur, diff;

drivers/net/wireless/mediatek/mt76/mac80211.c

1219

diff = signal - cur;

drivers/net/wireless/mediatek/mt76/mac80211.c

1220

if (diff == 0)

drivers/net/wireless/mediatek/mt76/mac80211.c

1222

else if (diff <= 2)

drivers/net/wireless/mediatek/mt76/mac80211.c

1224

else if (diff <= 6)

drivers/net/wireless/realtek/rtl8xxxu/core.c

2879

u32 i, j, diff, simubitmap, bound = 0;

drivers/net/wireless/realtek/rtl8xxxu/core.c

2891

diff = (result[c1][i] > result[c2][i]) ?

drivers/net/wireless/realtek/rtl8xxxu/core.c

2894

if (diff > MAX_TOLERANCE) {

drivers/net/wireless/realtek/rtl8xxxu/core.c

2933

u32 i, j, diff, simubitmap, bound = 0;

drivers/net/wireless/realtek/rtl8xxxu/core.c

2961

diff = (tmp1 > tmp2) ? (tmp1 - tmp2) : (tmp2 - tmp1);

drivers/net/wireless/realtek/rtl8xxxu/core.c

2963

if (diff > MAX_TOLERANCE) {

drivers/net/wireless/realtek/rtlwifi/rtl8188ee/phy.c

1616

u32 i, j, diff, simularity_bitmap, bound;

drivers/net/wireless/realtek/rtlwifi/rtl8188ee/phy.c

1630

diff = (result[c1][i] > result[c2][i]) ?

drivers/net/wireless/realtek/rtlwifi/rtl8188ee/phy.c

1634

if (diff > MAX_TOLERANCE) {

drivers/net/wireless/realtek/rtlwifi/rtl8192c/phy_common.c

1138

u32 i, j, diff, simularity_bitmap, bound;

drivers/net/wireless/realtek/rtlwifi/rtl8192c/phy_common.c

1152

diff = (result[c1][i] > result[c2][i]) ?

drivers/net/wireless/realtek/rtlwifi/rtl8192c/phy_common.c

1156

if (diff > MAX_TOLERANCE) {

drivers/net/wireless/realtek/rtlwifi/rtl8192d/hw_common.c

509

u8 tempval[2], i, pwr, diff;

drivers/net/wireless/realtek/rtlwifi/rtl8192d/hw_common.c

609

diff = pwrinfo.ht40_2sindexdiff[rfpath][group];

drivers/net/wireless/realtek/rtlwifi/rtl8192d/hw_common.c

611

(pwr > diff) ? (pwr - diff) : 0;

drivers/net/wireless/realtek/rtlwifi/rtl8192de/phy.c

1523

u32 i, j, diff, sim_bitmap, bound;

drivers/net/wireless/realtek/rtlwifi/rtl8192de/phy.c

1534

diff = (result[c1][i] > result[c2][i]) ? (result[c1][i] -

drivers/net/wireless/realtek/rtlwifi/rtl8192de/phy.c

1536

if (diff > MAX_TOLERANCE_92D) {

drivers/net/wireless/realtek/rtlwifi/rtl8192du/phy.c

1717

u32 i, j, diff, sim_bitmap, bound, u4temp = 0;

drivers/net/wireless/realtek/rtlwifi/rtl8192du/phy.c

1730

diff = abs_diff(result[c1][i], result[c2][i]);

drivers/net/wireless/realtek/rtlwifi/rtl8192du/phy.c

1732

if (diff > MAX_TOLERANCE_92D) {

drivers/net/wireless/realtek/rtlwifi/rtl8192ee/phy.c

1155

s8 diff = 0;

drivers/net/wireless/realtek/rtlwifi/rtl8192ee/phy.c

1209

diff = (u8)(rtlphy->tx_power_by_rate_offset[band][rf][tx_num][sec] >>

drivers/net/wireless/realtek/rtlwifi/rtl8192ee/phy.c

1212

return diff;

drivers/net/wireless/realtek/rtlwifi/rtl8192ee/phy.c

1223

u8 diff = 0;

drivers/net/wireless/realtek/rtlwifi/rtl8192ee/phy.c

1255

diff = _rtl92ee_get_txpower_by_rate(hw, BAND_ON_2_4G,

drivers/net/wireless/realtek/rtlwifi/rtl8192ee/phy.c

1258

tx_power += diff;

drivers/net/wireless/realtek/rtlwifi/rtl8192ee/phy.c

2402

u32 i, j, diff, simularity_bitmap, bound;

drivers/net/wireless/realtek/rtlwifi/rtl8192ee/phy.c

2428

diff = (tmp1 > tmp2) ? (tmp1 - tmp2) : (tmp2 - tmp1);

drivers/net/wireless/realtek/rtlwifi/rtl8192ee/phy.c

2430

if (diff > MAX_TOLERANCE) {

drivers/net/wireless/realtek/rtlwifi/rtl8723ae/phy.c

1081

u32 i, j, diff, simularity_bitmap, bound;

drivers/net/wireless/realtek/rtlwifi/rtl8723ae/phy.c

1091

diff = (result[c1][i] > result[c2][i]) ?

drivers/net/wireless/realtek/rtlwifi/rtl8723ae/phy.c

1095

if (diff > MAX_TOLERANCE) {

drivers/net/wireless/realtek/rtlwifi/rtl8723be/phy.c

1933

u32 i, j, diff, simularity_bitmap, bound = 0;

drivers/net/wireless/realtek/rtlwifi/rtl8723be/phy.c

1959

diff = (tmp1 > tmp2) ? (tmp1 - tmp2) : (tmp2 - tmp1);

drivers/net/wireless/realtek/rtlwifi/rtl8723be/phy.c

1961

if (diff > MAX_TOLERANCE) {

drivers/net/wireless/realtek/rtw88/phy.c

402

u8 diff;

drivers/net/wireless/realtek/rtw88/phy.c

409

diff = min_rssi > damping_rssi ? min_rssi - damping_rssi :

drivers/net/wireless/realtek/rtw88/phy.c

411

if (diff > 3 || dm_info->damping_cnt++ > 20) {

drivers/net/wireless/realtek/rtw88/rtw8723x.c

571

u32 i, j, diff;

drivers/net/wireless/realtek/rtw88/rtw8723x.c

582

diff = abs(tmp1 - tmp2);

drivers/net/wireless/realtek/rtw88/rtw8723x.c

584

if (diff <= MAX_TOLERANCE)

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

2704

u16 diff;

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

2719

diff = bcn_ofst - config->beacon_offset;

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

2727

diff = config->beacon_offset - bcn_ofst;

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

2736

if (diff <= tolerance)

drivers/net/wireless/ti/wlcore/main.c

436

u8 diff, tx_lnk_free_pkts;

drivers/net/wireless/ti/wlcore/main.c

442

diff = (tx_lnk_free_pkts - lnk->prev_freed_pkts) & 0xff;

drivers/net/wireless/ti/wlcore/main.c

444

if (diff) {

drivers/net/wireless/ti/wlcore/main.c

445

lnk->allocated_pkts -= diff;

drivers/net/wireless/ti/wlcore/main.c

477

if (diff)

drivers/net/wireless/ti/wlcore/main.c

482

lnk->total_freed_pkts += diff;

drivers/net/wireless/ti/wlcore/main.c

499

if (diff)

drivers/net/wireless/ti/wlcore/main.c

504

lnk->total_freed_pkts += diff;

drivers/peci/controller/peci-aspeed.c

315

unsigned long best_diff = ~0ul, diff;

drivers/peci/controller/peci-aspeed.c

320

diff = abs(rate - ASPEED_PECI_CLK_DIV1(i) * ASPEED_PECI_CLK_DIV2(j));

drivers/peci/controller/peci-aspeed.c

321

if (diff < best_diff) {

drivers/peci/controller/peci-aspeed.c

324

best_diff = diff;

drivers/phy/rockchip/phy-rockchip-emmc.c

126

unsigned long diff;

drivers/phy/rockchip/phy-rockchip-emmc.c

146

diff = (rate > ideal_rate) ?

drivers/phy/rockchip/phy-rockchip-emmc.c

155

if ((rate > 50000000 && diff > 15000000) || (rate > 200000000))

drivers/pinctrl/sunxi/pinctrl-sunxi.c

1482

static int sunxi_pinctrl_get_debounce_div(struct clk *clk, int freq, int *diff)

drivers/pinctrl/sunxi/pinctrl-sunxi.c

1500

*diff = best_diff;

drivers/platform/x86/msi-wmi.c

189

ktime_t diff = ktime_sub(cur, last_pressed);

drivers/platform/x86/msi-wmi.c

192

if (ktime_to_us(diff) < 1000 * 50) {

drivers/platform/x86/msi-wmi.c

195

key->code, ktime_to_us(diff));

drivers/ptp/ptp_clockmatrix.c

1003

diff = ktime_sub(stop, start);

drivers/ptp/ptp_clockmatrix.c

1005

current_ns = ktime_to_ns(diff);

drivers/ptp/ptp_clockmatrix.c

738

ktime_t diff = ktime_sub(ktime_get_raw(),

drivers/ptp/ptp_clockmatrix.c

740

total_overhead_ns = ktime_to_ns(diff)

drivers/ptp/ptp_clockmatrix.c

985

ktime_t diff;

drivers/ptp/ptp_dfl_tod.c

174

u32 period, diff, rem, rem_period, adj_period;

drivers/ptp/ptp_dfl_tod.c

196

diff = (period - TOD_PERIOD_MIN) >> PERIOD_FRAC_OFFSET;

drivers/ptp/ptp_dfl_tod.c

197

adj_period = period - (diff << PERIOD_FRAC_OFFSET);

drivers/ptp/ptp_dfl_tod.c

198

count = div_u64_rem(delta, diff, &rem);

drivers/ptp/ptp_dfl_tod.c

201

diff = (TOD_PERIOD_MAX - period) >> PERIOD_FRAC_OFFSET;

drivers/ptp/ptp_dfl_tod.c

202

adj_period = period + (diff << PERIOD_FRAC_OFFSET);

drivers/ptp/ptp_dfl_tod.c

203

count = div_u64_rem(delta, diff, &rem);

drivers/ptp/ptp_fc3.c

791

ktime_t diff;

drivers/ptp/ptp_fc3.c

805

diff = ktime_sub(stop, start);

drivers/ptp/ptp_fc3.c

807

current_ns = ktime_to_ns(diff);

drivers/ptp/ptp_qoriq.c

204

u64 adj, diff;

drivers/ptp/ptp_qoriq.c

223

diff = mul_u64_u64_div_u64(adj, scaled_ppm, 32768000000);

drivers/ptp/ptp_qoriq.c

224

diff = DIV64_U64_ROUND_UP(diff, 2);

drivers/ptp/ptp_qoriq.c

226

tmr_add = neg_adj ? tmr_add - diff : tmr_add + diff;

drivers/regulator/core.c

3817

int diff, old_sel, curr_sel, ret;

drivers/regulator/core.c

3830

diff = new_selector - old_sel;

drivers/regulator/core.c

3831

if (diff == 0)

drivers/regulator/core.c

3834

if (diff > 0) {

drivers/regulator/max8997-regulator.c

582

int diff;

drivers/regulator/max8997-regulator.c

588

diff = (buckx_val[others])[i] -

drivers/regulator/max8997-regulator.c

590

if (diff > 0)

drivers/regulator/max8997-regulator.c

591

side_effect[i] += diff;

drivers/regulator/max8997-regulator.c

592

else if (diff < 0)

drivers/regulator/max8997-regulator.c

593

side_effect[i] -= diff;

drivers/rtc/rtc-snvs.c

67

s64 diff;

drivers/rtc/rtc-snvs.c

78

diff = read1 - read2;

drivers/rtc/rtc-snvs.c

79

} while (((diff < 0) || (diff > MAX_RTC_READ_DIFF_CYCLES)) && --timeout);

drivers/rtc/rtc-snvs.c

91

s32 diff;

drivers/rtc/rtc-snvs.c

98

diff = count1 - count2;

drivers/rtc/rtc-snvs.c

99

} while (((diff < 0) || (diff > MAX_RTC_READ_DIFF_CYCLES)) && --timeout);

drivers/rtc/rtc-sunxi.c

258

time64_t diff;

drivers/rtc/rtc-sunxi.c

271

diff = rtc_tm_sub(alrm_tm, &tm_now);

drivers/rtc/rtc-sunxi.c

272

if (diff <= 0) {

drivers/rtc/rtc-sunxi.c

277

if (diff > 255 * SEC_IN_DAY) {

drivers/rtc/rtc-sunxi.c

282

time_gap = diff;

drivers/s390/cio/blacklist.c

80

int diff;

drivers/s390/cio/blacklist.c

82

diff = 0;

drivers/s390/cio/blacklist.c

85

while (diff <= max_digit) {

drivers/s390/cio/blacklist.c

92

diff++;

drivers/s390/cio/blacklist.c

95

if ((diff < min_digit) || (diff > max_digit) || (*val > max_val))

drivers/s390/virtio/virtio_ccw.c

1481

int diff;

drivers/s390/virtio/virtio_ccw.c

1483

diff = 0;

drivers/s390/virtio/virtio_ccw.c

1486

while (diff <= max_digit) {

drivers/s390/virtio/virtio_ccw.c

1493

diff++;

drivers/s390/virtio/virtio_ccw.c

1496

if ((diff < min_digit) || (diff > max_digit) || (*val > max_val))

drivers/scsi/aic7xxx/aic7xxx_core.c

5786

uint8_t diff;

drivers/scsi/aic7xxx/aic7xxx_core.c

5793

diff = ahc->qinfifonext - qinpos;

drivers/scsi/aic7xxx/aic7xxx_core.c

5794

return (diff);

drivers/scsi/arcmsr/arcmsr_hba.c

913

char diff, temp;

drivers/scsi/arcmsr/arcmsr_hba.c

962

diff = (*acb_dev_map) ^ temp;

drivers/scsi/arcmsr/arcmsr_hba.c

963

if (diff != 0) {

drivers/scsi/arcmsr/arcmsr_hba.c

967

if ((diff & 0x01) == 1 &&

drivers/scsi/arcmsr/arcmsr_hba.c

971

} else if ((diff & 0x01) == 1

drivers/scsi/arcmsr/arcmsr_hba.c

981

diff >>= 1;

drivers/scsi/dc395x.c

1694

const int diff =

drivers/scsi/dc395x.c

1699

diff && scsi_sg_count(srb->cmd))

drivers/scsi/dc395x.c

1701

(PAGE_SIZE - diff))

drivers/scsi/dc395x.c

1704

srb->total_xfer_length - diff;

drivers/scsi/megaraid/megaraid_sas_fp.c

1249

span_set->diff = le32_to_cpu(quad->diff);

drivers/scsi/megaraid/megaraid_sas_fp.c

1267

le64_to_cpu(quad->logStart)) + le32_to_cpu(quad->diff)),

drivers/scsi/megaraid/megaraid_sas_fp.c

1268

le32_to_cpu(quad->diff));

drivers/scsi/megaraid/megaraid_sas_fp.c

1285

(span_row * le32_to_cpu(quad->diff)) - 1;

drivers/scsi/megaraid/megaraid_sas_fp.c

1311

(span_row * le32_to_cpu(quad->diff)) - 1;

drivers/scsi/megaraid/megaraid_sas_fp.c

386

if (le32_to_cpu(quad->diff) == 0)

drivers/scsi/megaraid/megaraid_sas_fp.c

390

le32_to_cpu(quad->diff))) == 0) {

drivers/scsi/megaraid/megaraid_sas_fp.c

393

blk = mega_div64_32((row-le64_to_cpu(quad->logStart)), le32_to_cpu(quad->diff));

drivers/scsi/megaraid/megaraid_sas_fp.c

448

if (le32_to_cpu(quad->diff) == 0)

drivers/scsi/megaraid/megaraid_sas_fp.c

453

le32_to_cpu(quad->diff))) == 0) {

drivers/scsi/megaraid/megaraid_sas_fp.c

458

le32_to_cpu(quad->diff));

drivers/scsi/megaraid/megaraid_sas_fp.c

508

span_set->span_row_data_width) * span_set->diff;

drivers/scsi/megaraid/megaraid_sas_fp.c

570

le32_to_cpu(quad->diff)) == 0) {

drivers/scsi/megaraid/megaraid_sas_fp.c

574

le32_to_cpu(quad->diff));

drivers/scsi/megaraid/megaraid_sas_fusion.h

1144

u32 diff;

drivers/scsi/megaraid/megaraid_sas_fusion.h

746

__le32 diff;

drivers/scsi/sym53c8xx_2/sym_glue.c

51

module_param_named(diff, sym_driver_setup.scsi_diff, byte, 0);

drivers/scsi/sym53c8xx_2/sym_glue.c

65

MODULE_PARM_DESC(diff, "0 for no differential mode, 1 for BIOS, 2 for always, 3 for not GPIO3");

drivers/soc/fsl/qbman/bman.c

337

u8 diff, old_ci = rcr->ci;

drivers/soc/fsl/qbman/bman.c

342

diff = dpaa_cyc_diff(BM_RCR_SIZE, old_ci, rcr->ci);

drivers/soc/fsl/qbman/bman.c

343

rcr->available += diff;

drivers/soc/fsl/qbman/bman.c

344

return diff;

drivers/soc/fsl/qbman/qman.c

487

u8 diff, old_ci;

drivers/soc/fsl/qbman/qman.c

494

diff = dpaa_cyc_diff(QM_EQCR_SIZE, old_ci, eqcr->ci);

drivers/soc/fsl/qbman/qman.c

495

eqcr->available += diff;

drivers/soc/fsl/qbman/qman.c

496

if (!diff)

drivers/soc/fsl/qbman/qman.c

539

u8 diff, old_ci = eqcr->ci;

drivers/soc/fsl/qbman/qman.c

543

diff = dpaa_cyc_diff(QM_EQCR_SIZE, old_ci, eqcr->ci);

drivers/soc/fsl/qbman/qman.c

544

eqcr->available += diff;

drivers/soc/fsl/qbman/qman.c

545

return diff;

drivers/staging/media/atomisp/pci/isp/kernels/s3a/s3a_1.0/ia_css_s3a.host.c

226

int sum_r, diff;

drivers/staging/media/atomisp/pci/isp/kernels/s3a/s3a_1.0/ia_css_s3a.host.c

276

diff = sum_r - count_for_3a;

drivers/staging/media/atomisp/pci/isp/kernels/s3a/s3a_1.0/ia_css_s3a.host.c

277

out_ptr[0].r -= diff;

drivers/staging/media/atomisp/pci/isp/kernels/s3a/s3a_1.0/ia_css_s3a.host.c

278

out_ptr[0].g -= diff;

drivers/staging/media/atomisp/pci/isp/kernels/s3a/s3a_1.0/ia_css_s3a.host.c

279

out_ptr[0].b -= diff;

drivers/staging/media/atomisp/pci/isp/kernels/s3a/s3a_1.0/ia_css_s3a.host.c

280

out_ptr[0].y -= diff;

drivers/staging/media/deprecated/atmel/atmel-isc-clk.c

144

int diff;

drivers/staging/media/deprecated/atmel/atmel-isc-clk.c

147

diff = abs(req->rate - rate);

drivers/staging/media/deprecated/atmel/atmel-isc-clk.c

149

if (best_diff < 0 || best_diff > diff) {

drivers/staging/media/deprecated/atmel/atmel-isc-clk.c

151

best_diff = diff;

drivers/staging/rtl8723bs/hal/HalPhyRf_8723B.c

1223

u32 i, j, diff, SimularityBitMap, bound = 0;

drivers/staging/rtl8723bs/hal/HalPhyRf_8723B.c

1248

diff = (tmp1 > tmp2) ? (tmp1 - tmp2) : (tmp2 - tmp1);

drivers/staging/rtl8723bs/hal/HalPhyRf_8723B.c

1250

if (diff > MAX_TOLERANCE) {

drivers/staging/sm750fb/ddk750_chip.c

365

unsigned int diff;

drivers/staging/sm750fb/ddk750_chip.c

368

diff = abs(tmp_clock - request_orig);

drivers/staging/sm750fb/ddk750_chip.c

369

if (diff < mini_diff) {

drivers/staging/sm750fb/ddk750_chip.c

376

mini_diff = diff;

drivers/target/target_core_user.c

678

int diff = head - tail;

drivers/target/target_core_user.c

680

if (diff >= 0)

drivers/target/target_core_user.c

681

return diff;

drivers/target/target_core_user.c

683

return size + diff;

drivers/tty/serial/ar933x_uart.c

266

int diff;

drivers/tty/serial/ar933x_uart.c

275

diff = abs(ar933x_uart_get_baud(clk, tscale, tstep) - baud);

drivers/tty/serial/ar933x_uart.c

276

if (diff < min_diff) {

drivers/tty/serial/ar933x_uart.c

277

min_diff = diff;

drivers/tty/serial/msm_serial.c

1064

unsigned long target, old, best_rate = 0, diff, best_diff = ULONG_MAX;

drivers/tty/serial/msm_serial.c

1094

diff = abs(result - baud);

drivers/tty/serial/msm_serial.c

1097

if (diff < best_diff) {

drivers/tty/serial/msm_serial.c

1098

best_diff = diff;

drivers/tty/serial/serial-tegra.c

366

long diff;

drivers/tty/serial/serial-tegra.c

368

diff = ((long)(tup->configured_rate - tup->required_rate) * 10000)

drivers/tty/serial/serial-tegra.c

370

if (diff < (tup->cdata->error_tolerance_low_range * 100) ||

drivers/tty/serial/serial-tegra.c

371

diff > (tup->cdata->error_tolerance_high_range * 100)) {

drivers/tty/serial/serial-tegra.c

373

"configured baud rate is out of range by %ld", diff);

drivers/usb/dwc2/hcd.h

608

u16 diff = fr_idx1 - fr_idx2;

drivers/usb/dwc2/hcd.h

609

u16 sign = diff & (FRLISTEN_64_SIZE >> 1);

drivers/usb/dwc2/hcd.h

611

return diff && !sign;

drivers/usb/host/r8a66597-hcd.c

2056

unsigned long diff;

drivers/usb/host/r8a66597-hcd.c

2060

diff = r8a66597->child_connect_map[i] ^ map[i];

drivers/usb/host/r8a66597-hcd.c

2061

if (!diff)

drivers/usb/host/r8a66597-hcd.c

2065

if (!(diff & (1 << j)))

drivers/usb/musb/musb_host.c

2029

int diff;

drivers/usb/musb/musb_host.c

2038

diff = hw_ep->max_packet_sz_rx;

drivers/usb/musb/musb_host.c

2040

diff = hw_ep->max_packet_sz_tx;

drivers/usb/musb/musb_host.c

2041

diff -= (qh->maxpacket * qh->hb_mult);

drivers/usb/musb/musb_host.c

2043

if (diff >= 0 && best_diff > diff) {

drivers/usb/musb/musb_host.c

2065

best_diff = diff;

drivers/usb/serial/keyspan.c

1927

diff, /* error using 13/8 prescaler */

drivers/usb/serial/keyspan.c

1956

diff = (res > b16) ? (res-b16) : (b16-res);

drivers/usb/serial/keyspan.c

1958

if (diff < smallest_diff) {

drivers/usb/serial/keyspan.c

1960

smallest_diff = diff;

drivers/video/fbdev/aty/mach64_gx.c

614

u32 tempA, tempB, fOut, longMHz100, diff, preDiff;

drivers/video/fbdev/aty/mach64_gx.c

647

diff = 0;

drivers/video/fbdev/aty/mach64_gx.c

659

diff = longMHz100 - fOut;

drivers/video/fbdev/aty/mach64_gx.c

661

diff = fOut - longMHz100;

drivers/video/fbdev/aty/mach64_gx.c

663

if (diff < preDiff) {

drivers/video/fbdev/aty/mach64_gx.c

666

preDiff = diff;

drivers/video/fbdev/au1200fb.c

1074

int diff = AU1200_LCD_MAX_CLK % pixclock;

drivers/video/fbdev/au1200fb.c

1075

pixclock -= diff;

drivers/video/fbdev/cirrusfb.c

2744

long h, diff;

drivers/video/fbdev/cirrusfb.c

2757

diff = freq;

drivers/video/fbdev/cirrusfb.c

2772

if (h < diff) {

drivers/video/fbdev/cirrusfb.c

2773

diff = h;

drivers/video/fbdev/cirrusfb.c

2787

if (h < diff) {

drivers/video/fbdev/cirrusfb.c

2788

diff = h;

drivers/video/fbdev/core/modedb.c

1004

u32 diff = -1, diff_refresh = -1;

drivers/video/fbdev/core/modedb.c

1012

if (diff > d) {

drivers/video/fbdev/core/modedb.c

1013

diff = d;

drivers/video/fbdev/core/modedb.c

1016

} else if (diff == d) {

drivers/video/fbdev/core/modedb.c

657

u32 best, diff, tdiff;

drivers/video/fbdev/core/modedb.c

780

diff = -1;

drivers/video/fbdev/core/modedb.c

799

if (score < diff) {

drivers/video/fbdev/core/modedb.c

800

diff = score;

drivers/video/fbdev/core/modedb.c

810

diff = 2 * (xres + yres);

drivers/video/fbdev/core/modedb.c

826

if (diff > tdiff) {

drivers/video/fbdev/core/modedb.c

827

diff = tdiff;

drivers/video/fbdev/core/modedb.c

969

u32 diff = -1;

drivers/video/fbdev/core/modedb.c

978

if (diff > d) {

drivers/video/fbdev/core/modedb.c

979

diff = d;

drivers/video/fbdev/core/modedb.c

981

} else if (diff == d && best &&

drivers/video/fbdev/cyber2000fb.c

692

int diff;

drivers/video/fbdev/cyber2000fb.c

711

diff = pll_ps - t_pll_ps;

drivers/video/fbdev/cyber2000fb.c

712

if (diff < 0)

drivers/video/fbdev/cyber2000fb.c

713

diff = -diff;

drivers/video/fbdev/cyber2000fb.c

715

if (diff < best_diff) {

drivers/video/fbdev/cyber2000fb.c

716

best_diff = diff;

drivers/video/fbdev/cyber2000fb.c

724

if (diff == 0)

drivers/video/fbdev/geode/lxfb_ops.c

163

unsigned int diff, min, best = 0;

drivers/video/fbdev/geode/lxfb_ops.c

171

diff = abs(pll_table[i].freq - freq);

drivers/video/fbdev/geode/lxfb_ops.c

172

if (diff < min) {

drivers/video/fbdev/geode/lxfb_ops.c

173

min = diff;

drivers/video/fbdev/geode/video_cs5530.c

73

long min, diff;

drivers/video/fbdev/geode/video_cs5530.c

80

diff = cs5530_pll_table[i].pixclock - info->var.pixclock;

drivers/video/fbdev/geode/video_cs5530.c

81

if (diff < 0L) diff = -diff;

drivers/video/fbdev/geode/video_cs5530.c

82

if (diff < min) {

drivers/video/fbdev/geode/video_cs5530.c

83

min = diff;

drivers/video/fbdev/geode/video_gx.c

121

long min, diff;

drivers/video/fbdev/geode/video_gx.c

138

diff = abs(pll_table[i].pixclock - info->var.pixclock);

drivers/video/fbdev/geode/video_gx.c

139

if (diff < min) {

drivers/video/fbdev/geode/video_gx.c

140

min = diff;

drivers/video/fbdev/i810/i810_dvt.c

218

u32 diff = 0, diff_best = 0xFFFFFFFF, i = 0, i_best = 0;

drivers/video/fbdev/i810/i810_dvt.c

224

diff = pixclock - std_modes[i].pixclock;

drivers/video/fbdev/i810/i810_dvt.c

225

if (diff < diff_best) {

drivers/video/fbdev/i810/i810_dvt.c

227

diff_best = diff;

drivers/video/fbdev/i810/i810_gtf.c

228

u32 i, size = 0, pixclock, wm_best = 0, min, diff;

drivers/video/fbdev/i810/i810_gtf.c

266

diff = wmark[i].freq - pixclock;

drivers/video/fbdev/i810/i810_gtf.c

268

diff = pixclock - wmark[i].freq;

drivers/video/fbdev/i810/i810_gtf.c

269

if (diff < min) {

drivers/video/fbdev/i810/i810_gtf.c

271

min = diff;

drivers/video/fbdev/i810/i810_main.c

711

u32 f_out, target_freq, diff = 0, mod_min, diff_min;

drivers/video/fbdev/i810/i810_main.c

738

diff = target_freq - f_out;

drivers/video/fbdev/i810/i810_main.c

741

diff = f_out - target_freq;

drivers/video/fbdev/i810/i810_main.c

744

if (diff_min > diff) {

drivers/video/fbdev/i810/i810_main.c

745

diff_min = diff;

drivers/video/fbdev/i810/i810_main.c

750

if (!diff && mod_min > mod) {

drivers/video/fbdev/matrox/matroxfb_maven.c

740

unsigned int diff = h - h2;

drivers/video/fbdev/matrox/matroxfb_maven.c

742

if (diff < err) {

drivers/video/fbdev/matrox/matroxfb_maven.c

743

err = diff;

drivers/video/fbdev/matrox/matroxfb_misc.c

165

unsigned int diff, fvco;

drivers/video/fbdev/matrox/matroxfb_misc.c

175

diff = fwant - fvco;

drivers/video/fbdev/matrox/matroxfb_misc.c

177

diff = fvco - fwant;

drivers/video/fbdev/matrox/matroxfb_misc.c

178

if (diff < bestdiff) {

drivers/video/fbdev/matrox/matroxfb_misc.c

179

bestdiff = diff;

drivers/video/fbdev/ps3fb.c

337

int diff, best_diff;

drivers/video/fbdev/ps3fb.c

348

diff = ps3fb_cmp_mode(vmode, var);

drivers/video/fbdev/ps3fb.c

352

vmode->yres, vmode->lower_margin, diff);

drivers/video/fbdev/ps3fb.c

353

if (diff < 0)

drivers/video/fbdev/ps3fb.c

355

if (diff < best_diff) {

drivers/video/fbdev/ps3fb.c

357

if (!diff)

drivers/video/fbdev/ps3fb.c

359

best_diff = diff;

drivers/video/fbdev/savage/savagefb_driver.c

420

long diff, best_diff;

drivers/video/fbdev/savage/savagefb_driver.c

444

diff = freq * (1 << n2) * n1 - BASE_FREQ * m;

drivers/video/fbdev/savage/savagefb_driver.c

445

if (diff < 0)

drivers/video/fbdev/savage/savagefb_driver.c

446

diff = -diff;

drivers/video/fbdev/savage/savagefb_driver.c

447

if (diff < best_diff) {

drivers/video/fbdev/savage/savagefb_driver.c

448

best_diff = diff;

drivers/video/fbdev/savage/savagefb_driver.c

467

long diff, best_diff;

drivers/video/fbdev/savage/savagefb_driver.c

482

diff = freq * (1 << n2) * n1 - BASE_FREQ * m;

drivers/video/fbdev/savage/savagefb_driver.c

483

if (diff < 0)

drivers/video/fbdev/savage/savagefb_driver.c

484

diff = -diff;

drivers/video/fbdev/savage/savagefb_driver.c

485

if (diff < best_diff) {

drivers/video/fbdev/savage/savagefb_driver.c

486

best_diff = diff;

drivers/virtio/virtio_balloon.c

554

s64 diff;

drivers/virtio/virtio_balloon.c

561

diff = towards_target(vb);

drivers/virtio/virtio_balloon.c

563

if (diff) {

drivers/virtio/virtio_balloon.c

564

if (diff > 0)

drivers/virtio/virtio_balloon.c

565

diff -= fill_balloon(vb, diff);

drivers/virtio/virtio_balloon.c

567

diff += leak_balloon(vb, -diff);

drivers/virtio/virtio_balloon.c

571

if (diff)

drivers/virtio/virtio_mem.c

1760

static int virtio_mem_sbm_plug_request(struct virtio_mem *vm, uint64_t diff)

drivers/virtio/virtio_mem.c

1767

uint64_t nb_sb = diff / vm->sbm.sb_size;

drivers/virtio/virtio_mem.c

1878

static int virtio_mem_bbm_plug_request(struct virtio_mem *vm, uint64_t diff)

drivers/virtio/virtio_mem.c

1880

uint64_t nb_bb = diff / vm->bbm.bb_size;

drivers/virtio/virtio_mem.c

1922

static int virtio_mem_plug_request(struct virtio_mem *vm, uint64_t diff)

drivers/virtio/virtio_mem.c

1925

return virtio_mem_sbm_plug_request(vm, diff);

drivers/virtio/virtio_mem.c

1926

return virtio_mem_bbm_plug_request(vm, diff);

drivers/virtio/virtio_mem.c

2098

static int virtio_mem_sbm_unplug_request(struct virtio_mem *vm, uint64_t diff)

drivers/virtio/virtio_mem.c

2108

uint64_t nb_sb = diff / vm->sbm.sb_size;

drivers/virtio/virtio_mem.c

2263

static int virtio_mem_bbm_unplug_request(struct virtio_mem *vm, uint64_t diff)

drivers/virtio/virtio_mem.c

2265

uint64_t nb_bb = diff / vm->bbm.bb_size;

drivers/virtio/virtio_mem.c

2306

static int virtio_mem_unplug_request(struct virtio_mem *vm, uint64_t diff)

drivers/virtio/virtio_mem.c

2309

return virtio_mem_sbm_unplug_request(vm, diff);

drivers/virtio/virtio_mem.c

2310

return virtio_mem_bbm_unplug_request(vm, diff);

drivers/virtio/virtio_mem.c

2418

uint64_t diff;

drivers/virtio/virtio_mem.c

2451

diff = vm->requested_size - vm->plugged_size;

drivers/virtio/virtio_mem.c

2452

rc = virtio_mem_plug_request(vm, diff);

drivers/virtio/virtio_mem.c

2454

diff = vm->plugged_size - vm->requested_size;

drivers/virtio/virtio_mem.c

2455

rc = virtio_mem_unplug_request(vm, diff);

fs/afs/addr_prefs.c

158

int diff;

fs/afs/addr_prefs.c

175

diff = ntohl(*pa++) - ntohl(*pb++);

fs/afs/addr_prefs.c

176

if (diff < 0)

fs/afs/addr_prefs.c

178

if (diff > 0)

fs/afs/addr_prefs.c

189

diff = (na & mask) - (nb & mask);

fs/afs/addr_prefs.c

191

if (diff < 0)

fs/afs/addr_prefs.c

193

if (diff > 0)

fs/afs/server.c

41

int diff;

fs/afs/server.c

49

diff = memcmp(uuid, &server->uuid, sizeof(*uuid));

fs/afs/server.c

50

if (diff < 0) {

fs/afs/server.c

52

} else if (diff > 0) {

fs/afs/server.c

75

int diff;

fs/afs/server.c

86

diff = memcmp(&(*candidate)->uuid, &server->uuid, sizeof(uuid_t));

fs/afs/server.c

87

if (diff < 0)

fs/afs/server.c

89

else if (diff > 0)

fs/afs/server_list.c

199

int diff;

fs/afs/server_list.c

210

diff = memcmp(&pn->server->uuid, &po->server->uuid,

fs/afs/server_list.c

213

diff = pn ? -1 : 1;

fs/afs/server_list.c

215

if (diff < 0) {

fs/afs/vl_alias.c

50

long diff = pa - pb;

fs/afs/vl_alias.c

52

if (diff < 0) {

fs/afs/vl_alias.c

54

} else if (diff > 0) {

fs/afs/vl_alias.c

86

int diff = memcmp(&server_a->uuid, &server_b->uuid, sizeof(uuid_t));

fs/afs/vl_alias.c

88

if (diff < 0) {

fs/afs/vl_alias.c

90

} else if (diff > 0) {

fs/btrfs/file-item.c

1211

u32 diff;

fs/btrfs/file-item.c

1258

diff = (csum_offset + extend_nr) * csum_size;

fs/btrfs/file-item.c

1259

diff = min(diff,

fs/btrfs/file-item.c

1262

diff = diff - btrfs_item_size(leaf, path->slots[0]);

fs/btrfs/file-item.c

1263

diff = min_t(u32, btrfs_leaf_free_space(leaf), diff);

fs/btrfs/file-item.c

1264

diff /= csum_size;

fs/btrfs/file-item.c

1265

diff *= csum_size;

fs/btrfs/file-item.c

1267

btrfs_extend_item(trans, path, diff);

fs/btrfs/file.c

1171

const u64 diff = reserved_len - new_len;

fs/btrfs/file.c

1176

btrfs_delalloc_release_metadata(inode, diff, true);

fs/btrfs/file.c

1179

reserved_start + new_len, diff, true);

fs/btrfs/relocation.c

3941

struct btrfs_block_group *bg, s64 diff)

fs/btrfs/relocation.c

3948

bg->remap_bytes += diff;

fs/btrfs/volumes.c

3095

u64 diff;

fs/btrfs/volumes.c

3105

diff = round_down(new_size - device->total_bytes, fs_info->sectorsize);

fs/btrfs/volumes.c

3114

round_down(old_total + diff, fs_info->sectorsize));

fs/btrfs/volumes.c

3115

device->fs_devices->total_rw_bytes += diff;

fs/btrfs/volumes.c

3116

atomic64_add(diff, &fs_info->free_chunk_space);

fs/btrfs/volumes.c

5159

u64 diff;

fs/btrfs/volumes.c

5166

diff = round_down(old_size - new_size, fs_info->sectorsize);

fs/btrfs/volumes.c

5187

device->fs_devices->total_rw_bytes -= diff;

fs/btrfs/volumes.c

5208

if (btrfs_first_pending_extent(device, start, diff, &pending_start, &pending_end)) {

fs/btrfs/volumes.c

5315

WARN_ON(diff > old_total);

fs/btrfs/volumes.c

5317

round_down(old_total - diff, fs_info->sectorsize));

fs/btrfs/volumes.c

5336

device->fs_devices->total_rw_bytes += diff;

fs/erofs/namei.c

107

int diff;

fs/erofs/namei.c

131

diff = erofs_dirnamecmp(name, &dname, &matched);

fs/erofs/namei.c

133

if (diff < 0) {

fs/erofs/namei.c

143

if (!diff) {

fs/exec.c

134

long diff = (long)(pages - bprm->vma_pages);

fs/exec.c

136

if (!mm || !diff)

fs/exec.c

140

add_mm_counter(mm, MM_ANONPAGES, diff);

fs/ext4/ioctl.c

383

qsize_t size, size_bl, diff;

fs/ext4/ioctl.c

462

diff = size - size_bl;

fs/ext4/ioctl.c

502

if (diff > 0)

fs/ext4/ioctl.c

503

dquot_free_space(inode, diff);

fs/ext4/ioctl.c

505

err = dquot_alloc_space(inode, -1 * diff);

fs/ext4/mmp.c

144

unsigned long diff;

fs/ext4/mmp.c

187

diff = jiffies - last_update_time;

fs/ext4/mmp.c

188

if (diff < mmp_update_interval * HZ)

fs/ext4/mmp.c

190

HZ - diff);

fs/ext4/mmp.c

197

diff = jiffies - last_update_time;

fs/ext4/mmp.c

198

if (diff > mmp_check_interval * HZ) {

fs/ext4/mmp.c

230

mmp_check_interval = clamp(EXT4_MMP_CHECK_MULT * diff / HZ,

fs/f2fs/checkpoint.c

2023

u64 sum_diff = 0, diff, count = 0;

fs/f2fs/checkpoint.c

2035

diff = (u64)ktime_ms_delta(ktime_get(), req->queue_time);

fs/f2fs/checkpoint.c

2037

req->delta_time = diff;

fs/f2fs/checkpoint.c

2040

sum_diff += diff;

fs/f2fs/checkpoint.c

589

long diff, written;

fs/f2fs/checkpoint.c

605

diff = nr_pages_to_write(sbi, META, wbc);

fs/f2fs/checkpoint.c

608

wbc->nr_to_write = max((long)0, wbc->nr_to_write - written - diff);

fs/f2fs/f2fs.h

2557

long long diff = 0, release = 0;

fs/f2fs/f2fs.h

2579

diff = (long long)sbi->total_valid_block_count + *count -

fs/f2fs/f2fs.h

2581

if (unlikely(diff > 0)) {

fs/f2fs/f2fs.h

2587

if (diff > *count)

fs/f2fs/f2fs.h

2588

diff = *count;

fs/f2fs/f2fs.h

2589

*count -= diff;

fs/f2fs/f2fs.h

2590

release = diff;

fs/f2fs/f2fs.h

3392

block_t diff, bool add, bool claim)

fs/f2fs/f2fs.h

3400

dquot_claim_block(inode, diff);

fs/f2fs/f2fs.h

3402

dquot_alloc_block_nofail(inode, diff);

fs/f2fs/f2fs.h

3404

dquot_free_block(inode, diff);

fs/f2fs/f2fs.h

4684

int diff = F2FS_I(inode)->i_cluster_size - blocks; \

fs/f2fs/f2fs.h

4686

sbi->compr_saved_block += diff; \

fs/f2fs/f2fs.h

4957

int diff = fi->i_cluster_size - blocks;

fs/f2fs/f2fs.h

4964

atomic_add(diff, &fi->i_compr_blocks);

fs/f2fs/f2fs.h

4965

stat_add_compr_blocks(inode, diff);

fs/f2fs/f2fs.h

4967

atomic_sub(diff, &fi->i_compr_blocks);

fs/f2fs/f2fs.h

4968

stat_sub_compr_blocks(inode, diff);

fs/f2fs/node.c

2245

long diff;

fs/f2fs/node.c

2270

diff = nr_pages_to_write(sbi, NODE, wbc);

fs/f2fs/node.c

2274

wbc->nr_to_write = max((long)0, wbc->nr_to_write - diff);

fs/f2fs/segment.h

943

time64_t diff, now = ktime_get_boottime_seconds();

fs/f2fs/segment.h

950

diff = sit_i->mounted_time - now;

fs/f2fs/segment.h

951

if (sit_i->elapsed_time >= diff)

fs/f2fs/segment.h

952

return sit_i->elapsed_time - diff;

fs/fat/fatent.c

693

sector_t blocknr, diff;

fs/fat/fatent.c

698

diff = blocknr - ra->cur;

fs/fat/fatent.c

705

sb_breadahead(sb, ra->ra_next + diff);

fs/gfs2/rgrp.c

1320

u8 diff;

fs/gfs2/rgrp.c

1328

diff = ~(*orig | (*orig >> 1)) & (*clone | (*clone >> 1));

fs/gfs2/rgrp.c

1330

diff = ~(*clone | (*clone >> 1));

fs/gfs2/rgrp.c

1332

diff &= 0x55;

fs/gfs2/rgrp.c

1333

if (diff == 0)

fs/gfs2/rgrp.c

1336

while(diff) {

fs/gfs2/rgrp.c

1337

if (diff & 1) {

fs/gfs2/rgrp.c

1355

diff >>= 2;

fs/hfs/brec.c

375

int newkeylen, diff;

fs/hfs/brec.c

405

diff = newkeylen - fd->keylength;

fs/hfs/brec.c

406

if (!diff)

fs/hfs/brec.c

408

if (diff > 0) {

fs/hfs/brec.c

410

if (end_rec_off - end_off < diff) {

fs/hfs/brec.c

425

hfs_bnode_write_u16(parent, rec_off, start_off + diff);

fs/hfs/brec.c

431

hfs_bnode_write_u16(parent, rec_off, end_off + diff);

fs/hfs/brec.c

433

hfs_bnode_move(parent, start_off + diff, start_off,

fs/hfs/sysdep.c

20

int diff;

fs/hfs/sysdep.c

30

diff = sys_tz.tz_minuteswest * 60 - HFS_I(inode)->tz_secondswest;

fs/hfs/sysdep.c

31

if (diff) {

fs/hfs/sysdep.c

34

inode_set_ctime(inode, ts.tv_sec + diff, ts.tv_nsec);

fs/hfs/sysdep.c

36

inode_set_atime(inode, ts.tv_sec + diff, ts.tv_nsec);

fs/hfs/sysdep.c

38

inode_set_mtime(inode, ts.tv_sec + diff, ts.tv_nsec);

fs/hfs/sysdep.c

39

HFS_I(inode)->tz_secondswest += diff;

fs/hfsplus/brec.c

360

int newkeylen, diff;

fs/hfsplus/brec.c

391

diff = newkeylen - fd->keylength;

fs/hfsplus/brec.c

392

if (!diff)

fs/hfsplus/brec.c

394

if (diff > 0) {

fs/hfsplus/brec.c

396

if (end_rec_off - end_off < diff) {

fs/hfsplus/brec.c

412

hfs_bnode_write_u16(parent, rec_off, start_off + diff);

fs/hfsplus/brec.c

418

hfs_bnode_write_u16(parent, rec_off, end_off + diff);

fs/hfsplus/brec.c

420

hfs_bnode_move(parent, start_off + diff, start_off,

fs/jfs/jfs_logmgr.h

483

#define logdiff(diff, lsn, log)\

fs/jfs/jfs_logmgr.h

485

diff = (lsn) - (log)->syncpt;\

fs/jfs/jfs_logmgr.h

486

if (diff < 0)\

fs/jfs/jfs_logmgr.h

487

diff += (log)->logsize;\

fs/nfs/blocklayout/extent_tree.c

287

sector_t diff = new->be_length - new_len;

fs/nfs/blocklayout/extent_tree.c

289

new->be_f_offset += diff;

fs/nfs/blocklayout/extent_tree.c

290

new->be_v_offset += diff;

fs/nfs/blocklayout/extent_tree.c

300

sector_t diff = new->be_length - new_len;

fs/nfs/blocklayout/extent_tree.c

312

new->be_f_offset += diff;

fs/nfs/blocklayout/extent_tree.c

313

new->be_v_offset += diff;

fs/nfs/blocklayout/extent_tree.c

437

sector_t diff = start - be->be_f_offset;

fs/nfs/blocklayout/extent_tree.c

439

left->be_length += diff;

fs/nfs/blocklayout/extent_tree.c

441

be->be_f_offset += diff;

fs/nfs/blocklayout/extent_tree.c

442

be->be_v_offset += diff;

fs/nfs/blocklayout/extent_tree.c

443

be->be_length -= diff;

fs/nfs/blocklayout/extent_tree.c

455

sector_t diff = end - be->be_f_offset;

fs/nfs/blocklayout/extent_tree.c

457

be->be_length -= diff;

fs/nfs/blocklayout/extent_tree.c

459

right->be_f_offset -= diff;

fs/nfs/blocklayout/extent_tree.c

460

right->be_v_offset -= diff;

fs/nfs/blocklayout/extent_tree.c

461

right->be_length += diff;

fs/nfs/dir.c

2965

unsigned long diff;

fs/nfs/dir.c

2971

diff = nr_entries - nfs_access_max_cachesize;

fs/nfs/dir.c

2972

if (diff < nr_to_scan)

fs/nfs/dir.c

2973

nr_to_scan = diff;

fs/nfs/dir.c

502

loff_t diff = desc->ctx->pos - desc->current_index;

fs/nfs/dir.c

505

if (diff < 0)

fs/nfs/dir.c

507

if (diff >= array->size) {

fs/nfs/dir.c

514

index = (unsigned int)diff;

fs/nfs/inode.c

1921

s64 diff = fattr->change_attr - inode_peek_iversion_raw(inode);

fs/nfs/inode.c

1922

if (diff > 0)

fs/nfs/inode.c

1924

return diff == 0 ? 0 : -1;

fs/nilfs2/bmap.c

442

__s64 diff;

fs/nilfs2/bmap.c

444

diff = key - bmap->b_last_allocated_key;

fs/nilfs2/bmap.c

445

if ((nilfs_bmap_keydiff_abs(diff) < NILFS_INODE_BMAP_SIZE) &&

fs/nilfs2/bmap.c

447

(bmap->b_last_allocated_ptr + diff > 0))

fs/nilfs2/bmap.c

448

return bmap->b_last_allocated_ptr + diff;

fs/nilfs2/bmap.h

22

#define nilfs_bmap_keydiff_abs(diff) ((diff) < 0 ? -(diff) : (diff))

fs/ntfs3/attrlist.c

204

int diff = le32_to_cpu(le->type) - type_in;

fs/ntfs3/attrlist.c

207

if (diff < 0)

fs/ntfs3/attrlist.c

210

if (diff > 0)

fs/ntfs3/attrlist.c

221

diff = ntfs_cmp_names(le_name(le), name_len, name,

fs/ntfs3/attrlist.c

224

if (diff < 0)

fs/ntfs3/attrlist.c

227

if (diff > 0)

fs/ntfs3/attrlist.c

261

int diff = le32_to_cpu(le->type) - type_in;

fs/ntfs3/attrlist.c

263

if (diff < 0)

fs/ntfs3/attrlist.c

266

if (diff > 0)

fs/ntfs3/attrlist.c

273

diff = ntfs_cmp_names(le_name(le), le->name_len, name,

fs/ntfs3/attrlist.c

276

if (diff < 0)

fs/ntfs3/attrlist.c

279

if (diff > 0)

fs/ntfs3/dir.c

242

int diff;

fs/ntfs3/dir.c

255

err = indx_find(&ni->dir, ni, NULL, uni, 0, sbi, &diff, &e, fnd);

fs/ntfs3/dir.c

260

if (diff) {

fs/ntfs3/frecord.c

349

int diff;

fs/ntfs3/frecord.c

370

diff = le32_to_cpu(le->type) - type_in;

fs/ntfs3/frecord.c

371

if (diff < 0)

fs/ntfs3/frecord.c

374

if (diff > 0)

fs/ntfs3/fsntfs.c

1986

int diff;

fs/ntfs3/fsntfs.c

2014

NULL, &diff, (struct NTFS_DE **)&sii_e, fnd_sii);

fs/ntfs3/fsntfs.c

2018

if (diff)

fs/ntfs3/fsntfs.c

2085

int err, diff;

fs/ntfs3/fsntfs.c

2142

&d_security->key.sec_id, &diff, (struct NTFS_DE **)&e,

fs/ntfs3/fsntfs.c

2410

int err, diff;

fs/ntfs3/fsntfs.c

2444

err = indx_find(indx, ni, root_r, &rkey, sizeof(rkey), (void *)1, &diff,

fs/ntfs3/index.c

1138

const void *ctx, int *diff, struct NTFS_DE **entry,

fs/ntfs3/index.c

1158

*diff = 0;

fs/ntfs3/index.c

1166

e = hdr_find_e(indx, &root->ihdr, key, key_len, ctx, diff);

fs/ntfs3/index.c

1174

if (*diff >= 0 || !de_has_vcn_ex(e))

fs/ntfs3/index.c

1186

diff);

fs/ntfs3/index.c

1951

int diff;

fs/ntfs3/index.c

1977

le16_to_cpu(new_de->key_size), ctx, &diff, &e,

fs/ntfs3/index.c

1982

if (!diff) {

fs/ntfs3/index.c

2280

int err, diff;

fs/ntfs3/index.c

2314

err = indx_find(indx, ni, root, key, key_len, ctx, &diff, &e, fnd);

fs/ntfs3/index.c

2318

if (!e || diff) {

fs/ntfs3/index.c

2669

int err, diff;

fs/ntfs3/index.c

2689

&diff, &e, fnd);

fs/ntfs3/index.c

2698

if (diff) {

fs/ntfs3/index.c

717

size_t key_len, const void *ctx, int *diff)

fs/ntfs3/index.c

780

*diff = 0;

fs/ntfs3/index.c

785

*diff = -1;

fs/ntfs3/index.c

805

int diff;

fs/ntfs3/index.c

826

&diff);

fs/ntfs3/ntfs_fs.h

756

const void *param, int *diff, struct NTFS_DE **entry,

fs/ntfs3/record.c

19

int diff = le32_to_cpu(left->type) - le32_to_cpu(type);

fs/ntfs3/record.c

21

if (diff)

fs/ntfs3/record.c

22

return diff;

fs/ntfs3/record.c

497

int diff = compare_attr(attr, type, name, name_len, upcase);

fs/ntfs3/record.c

499

if (diff < 0)

fs/ntfs3/record.c

502

if (!diff && !is_attr_indexed(attr))

fs/smb/client/compress/lz77.c

54

u64 diff;

fs/smb/client/compress/lz77.c

58

diff = lz77_read64(cur) ^ lz77_read64(wnd);

fs/smb/client/compress/lz77.c

59

if (!diff) {

fs/smb/client/compress/lz77.c

67

cur += count_trailing_zeros(diff) >> 3;

fs/udf/directory.c

443

int diff = new_elen - iter->elen;

fs/udf/directory.c

454

iinfo->i_lenExtents += diff;

fs/xfs/libxfs/xfs_alloc.c

1016

xfs_extlen_t len, lena, diff = -1;

fs/xfs/libxfs/xfs_alloc.c

1064

diff = xfs_alloc_compute_diff(args->agbno, args->len,

fs/xfs/libxfs/xfs_alloc.c

1073

if (diff > acur->diff) {

fs/xfs/libxfs/xfs_alloc.c

1079

(args->len == acur->len && diff <= acur->diff));

fs/xfs/libxfs/xfs_alloc.c

1084

acur->diff = diff;

fs/xfs/libxfs/xfs_alloc.c

1092

if (acur->diff == 0 && acur->len == args->maxlen)

fs/xfs/libxfs/xfs_alloc.c

1097

trace_xfs_alloc_cur_check(cur, bno, len, diff, *new);

fs/xfs/libxfs/xfs_alloc.c

328

xfs_extlen_t diff;

fs/xfs/libxfs/xfs_alloc.c

340

diff = args->min_agbno - bno;

fs/xfs/libxfs/xfs_alloc.c

341

if (len > diff) {

fs/xfs/libxfs/xfs_alloc.c

342

bno += diff;

fs/xfs/libxfs/xfs_alloc.c

343

len -= diff;

fs/xfs/libxfs/xfs_alloc.c

350

diff = aligned_bno - bno;

fs/xfs/libxfs/xfs_alloc.c

353

*reslen = diff >= len ? 0 : len - diff;

fs/xfs/libxfs/xfs_alloc.c

931

xfs_extlen_t diff; /* diff from search bno */

fs/xfs/libxfs/xfs_alloc.c

954

acur->diff = -1;

fs/xfs/libxfs/xfs_attr_leaf.c

1698

int diff = 0;

fs/xfs/libxfs/xfs_attr_leaf.c

1706

diff = sizeof(struct xfs_attr_leaf_entry);

fs/xfs/libxfs/xfs_attr_leaf.c

1714

diff = new_end - ichdr->freemap[i].base;

fs/xfs/libxfs/xfs_attr_leaf.c

1717

if (diff) {

fs/xfs/libxfs/xfs_attr_leaf.c

1718

ichdr->freemap[i].base += diff;

fs/xfs/libxfs/xfs_attr_leaf.c

1720

min_t(uint16_t, ichdr->freemap[i].size, diff);

fs/xfs/xfs_buf.c

1957

xfs_daddr_t diff;

fs/xfs/xfs_buf.c

1959

diff = ap->b_maps[0].bm_bn - bp->b_maps[0].bm_bn;

fs/xfs/xfs_buf.c

1960

if (diff < 0)

fs/xfs/xfs_buf.c

1962

if (diff > 0)

fs/xfs/xfs_extent_busy.c

691

s32 diff;

fs/xfs/xfs_extent_busy.c

693

diff = b1->group->xg_gno - b2->group->xg_gno;

fs/xfs/xfs_extent_busy.c

694

if (!diff)

fs/xfs/xfs_extent_busy.c

695

diff = b1->bno - b2->bno;

fs/xfs/xfs_extent_busy.c

696

return diff;

fs/xfs/xfs_log.c

114

int64_t diff = xlog_lsn_sub(log, new_head, old_head);

fs/xfs/xfs_log.c

116

xlog_grant_sub_space(&log->l_reserve_head, diff);

fs/xfs/xfs_log.c

117

xlog_grant_sub_space(&log->l_write_head, diff);

fs/xfs/xfs_rtalloc.c

1832

xfs_extlen_t diff;

fs/xfs/xfs_rtalloc.c

1844

diff = min_rgbno - rgbno;

fs/xfs/xfs_rtalloc.c

1845

if (len > diff) {

fs/xfs/xfs_rtalloc.c

1846

rgbno += diff;

fs/xfs/xfs_rtalloc.c

1847

len -= diff;

fs/xfs/xfs_rtalloc.c

1854

diff = aligned_rgbno - rgbno;

fs/xfs/xfs_rtalloc.c

1858

diff >= len ? 0 : len - diff);

fs/xfs/xfs_trace.h

2306

xfs_extlen_t len, xfs_extlen_t diff, bool new),

fs/xfs/xfs_trace.h

2307

TP_ARGS(cur, bno, len, diff, new),

fs/xfs/xfs_trace.h

2313

__field(xfs_extlen_t, diff)

fs/xfs/xfs_trace.h

2321

__entry->diff = diff;

fs/xfs/xfs_trace.h

2327

__entry->bno, __entry->len, __entry->diff, __entry->new)

fs/xfs/xfs_trans.c

745

int64_t diff;

fs/xfs/xfs_trans.c

758

diff = lia->li_ops->iop_sort(lia) - lib->li_ops->iop_sort(lib);

fs/xfs/xfs_trans.c

759

if (diff < 0)

fs/xfs/xfs_trans.c

761

if (diff > 0)

fs/xfs/xfs_zone_gc.c

293

int diff;

fs/xfs/xfs_zone_gc.c

295

diff = cmp_int(reca->rm_owner, recb->rm_owner);

fs/xfs/xfs_zone_gc.c

296

if (diff)

fs/xfs/xfs_zone_gc.c

297

return diff;

include/linux/iio/events.h

27

#define _IIO_EVENT_CODE(chan_type, diff, modifier, direction, \

include/linux/iio/events.h

29

(((u64)type << 56) | ((u64)diff << 55) | \

include/linux/ptp_classify.h

149

__be64 diff[2] = { ~old, new };

include/linux/ptp_classify.h

151

return csum_partial(diff, sizeof(diff), oldsum);

include/linux/ptp_clock_kernel.h

298

static inline bool diff_by_scaled_ppm(u64 base, long scaled_ppm, u64 *diff)

include/linux/ptp_clock_kernel.h

307

*diff = mul_u64_u64_div_u64(base, (u64)scaled_ppm, 1000000ULL << 16);

include/linux/ptp_clock_kernel.h

322

u64 diff;

include/linux/ptp_clock_kernel.h

324

if (diff_by_scaled_ppm(base, scaled_ppm, &diff))

include/linux/ptp_clock_kernel.h

325

return base - diff;

include/linux/ptp_clock_kernel.h

327

return base + diff;

include/linux/rmap.h

136

int diff, mm_id_t mm_id)

include/linux/rmap.h

139

VM_WARN_ON_ONCE(diff <= 0);

include/linux/rmap.h

148

VM_WARN_ON_ONCE(diff > folio_large_nr_pages(folio));

include/linux/rmap.h

178

int diff, struct vm_area_struct *vma)

include/linux/rmap.h

184

__folio_large_mapcount_sanity_checks(folio, diff, mm_id);

include/linux/rmap.h

186

new_mapcount_val = atomic_read(&folio->_large_mapcount) + diff;

include/linux/rmap.h

197

folio->_mm_id_mapcount[0] += diff;

include/linux/rmap.h

204

folio->_mm_id_mapcount[1] += diff;

include/linux/rmap.h

212

folio->_mm_id_mapcount[0] = diff - 1;

include/linux/rmap.h

214

if (new_mapcount_val != diff - 1)

include/linux/rmap.h

218

folio->_mm_id_mapcount[1] = diff - 1;

include/linux/rmap.h

228

int diff, struct vm_area_struct *vma)

include/linux/rmap.h

234

__folio_large_mapcount_sanity_checks(folio, diff, mm_id);

include/linux/rmap.h

236

new_mapcount_val = atomic_read(&folio->_large_mapcount) - diff;

include/linux/rmap.h

246

folio->_mm_id_mapcount[0] -= diff;

include/linux/rmap.h

252

folio->_mm_id_mapcount[1] -= diff;

include/linux/rmap.h

286

int diff, struct vm_area_struct *vma)

include/linux/rmap.h

288

atomic_add(diff, &folio->_large_mapcount);

include/linux/rmap.h

292

int diff, struct vm_area_struct *vma)

include/linux/rmap.h

298

int diff, struct vm_area_struct *vma)

include/linux/rmap.h

300

atomic_sub(diff, &folio->_large_mapcount);

include/linux/rmap.h

304

int diff, struct vm_area_struct *vma)

include/linux/skbuff.h

3354

unsigned int diff = len - skb->len;

include/linux/skbuff.h

3356

if (skb_tailroom(skb) < diff) {

include/linux/skbuff.h

3357

int ret = pskb_expand_head(skb, 0, diff - skb_tailroom(skb),

include/linux/skmsg.h

332

static inline void sk_psock_msg_len_add_locked(struct sk_psock *psock, int diff)

include/linux/skmsg.h

337

WRITE_ONCE(psock->msg_tot_len, psock->msg_tot_len + diff);

include/linux/skmsg.h

340

static inline void sk_psock_msg_len_add(struct sk_psock *psock, int diff)

include/linux/skmsg.h

343

sk_psock_msg_len_add_locked(psock, diff);

include/math-emu/op-common.h

236

_FP_I_TYPE diff = X##_e - Y##_e; \

include/math-emu/op-common.h

238

if (diff < 0) \

include/math-emu/op-common.h

240

diff = -diff; \

include/math-emu/op-common.h

241

if (diff <= _FP_WFRACBITS_##fs) \

include/math-emu/op-common.h

242

_FP_FRAC_SRS_##wc(X, diff, _FP_WFRACBITS_##fs); \

include/math-emu/op-common.h

249

if (diff > 0) \

include/math-emu/op-common.h

251

if (diff <= _FP_WFRACBITS_##fs) \

include/math-emu/op-common.h

252

_FP_FRAC_SRS_##wc(Y, diff, _FP_WFRACBITS_##fs); \

include/math-emu/op-common.h

293

_FP_FRAC_CLZ_##wc(diff, R); \

include/math-emu/op-common.h

294

diff -= _FP_WFRACXBITS_##fs; \

include/math-emu/op-common.h

295

if (diff) \

include/math-emu/op-common.h

297

R##_e -= diff; \

include/math-emu/op-common.h

298

_FP_FRAC_SLL_##wc(R, diff); \

include/net/checksum.h

114

static __always_inline void csum_replace_by_diff(__sum16 *sum, __wsum diff)

include/net/checksum.h

116

*sum = csum_fold(csum_add(diff, ~csum_unfold(*sum)));

include/net/checksum.h

155

__wsum diff, bool pseudohdr, bool ipv6);

include/net/gro.h

476

struct sk_buff *p, const u16 diff,

include/net/gro.h

479

const void *nh = th - diff;

include/net/gro.h

480

const void *nh2 = th2 - diff;

include/net/ip_vs.h

1731

__be32 diff[2] = { ~old, new };

include/net/ip_vs.h

1733

return csum_partial(diff, sizeof(diff), oldsum);

include/net/ip_vs.h

1740

__be32 diff[8] = { ~old[3], ~old[2], ~old[1], ~old[0],

include/net/ip_vs.h

1743

return csum_partial(diff, sizeof(diff), oldsum);

include/net/ip_vs.h

1749

__be16 diff[2] = { ~old, new };

include/net/ip_vs.h

1751

return csum_partial(diff, sizeof(diff), oldsum);

include/net/ip_vs.h

826

struct sk_buff *, int *diff, struct ip_vs_iphdr *ipvsh);

include/net/ip_vs.h

833

struct sk_buff *, int *diff, struct ip_vs_iphdr *ipvsh);

include/net/seg6.h

20

__be32 diff[] = { ~from, to };

include/net/seg6.h

22

skb->csum = ~csum_partial((char *)diff, sizeof(diff), ~skb->csum);

include/net/seg6.h

28

__be32 diff[] = {

include/net/seg6.h

33

skb->csum = ~csum_partial((char *)diff, sizeof(diff), ~skb->csum);

include/sound/pcm-indirect.h

114

snd_pcm_sframes_t diff = appl_ptr - rec->appl_ptr;

include/sound/pcm-indirect.h

116

if (diff) {

include/sound/pcm-indirect.h

117

if (diff < -(snd_pcm_sframes_t) (runtime->boundary / 2))

include/sound/pcm-indirect.h

118

diff += runtime->boundary;

include/sound/pcm-indirect.h

119

if (diff < 0)

include/sound/pcm-indirect.h

121

rec->sw_ready -= frames_to_bytes(runtime, diff);

include/sound/pcm-indirect.h

40

snd_pcm_sframes_t diff = appl_ptr - rec->appl_ptr;

include/sound/pcm-indirect.h

43

if (diff) {

include/sound/pcm-indirect.h

44

if (diff < -(snd_pcm_sframes_t) (runtime->boundary / 2))

include/sound/pcm-indirect.h

45

diff += runtime->boundary;

include/sound/pcm-indirect.h

46

if (diff < 0)

include/sound/pcm-indirect.h

48

rec->sw_ready += (int)frames_to_bytes(runtime, diff);

include/trace/events/btrfs.h

1830

s64 diff, int type),

include/trace/events/btrfs.h

1832

TP_ARGS(fs_info, qgroup, diff, type),

include/trace/events/btrfs.h

1837

__field( s64, diff )

include/trace/events/btrfs.h

1844

__entry->diff = diff;

include/trace/events/btrfs.h

1850

__entry->cur_reserved, __entry->diff)

include/trace/events/btrfs.h

1855

TP_PROTO(const struct btrfs_root *root, s64 diff, int type),

include/trace/events/btrfs.h

1857

TP_ARGS(root, diff, type),

include/trace/events/btrfs.h

1861

__field( s64, diff )

include/trace/events/btrfs.h

1867

__entry->diff = diff;

include/trace/events/btrfs.h

1873

__print_symbolic(__entry->type, QGROUP_RSV_TYPES), __entry->diff)

include/trace/events/btrfs.h

1878

TP_PROTO(const struct btrfs_root *root, s64 diff),

include/trace/events/btrfs.h

1880

TP_ARGS(root, diff),

include/trace/events/btrfs.h

1884

__field( s64, diff )

include/trace/events/btrfs.h

1889

__entry->diff = diff;

include/trace/events/btrfs.h

1896

__entry->diff)

include/trace/events/btrfs.h

1907

__field( s64, diff )

include/trace/events/btrfs.h

1914

__entry->diff = -(s64)root->qgroup_meta_rsv_pertrans;

include/trace/events/btrfs.h

1921

__print_symbolic(__entry->type, QGROUP_RSV_TYPES), __entry->diff)

include/trace/events/btrfs.h

2346

const struct btrfs_space_info *sinfo, u64 old, s64 diff),

include/trace/events/btrfs.h

2348

TP_ARGS(fs_info, sinfo, old, diff),

include/trace/events/btrfs.h

2353

__field( s64, diff )

include/trace/events/btrfs.h

2359

__entry->diff = diff;

include/trace/events/btrfs.h

2363

__entry->old, __entry->diff)

include/trace/events/btrfs.h

2369

const struct btrfs_space_info *sinfo, u64 old, s64 diff),

include/trace/events/btrfs.h

2371

TP_ARGS(fs_info, sinfo, old, diff)

include/trace/events/btrfs.h

2377

const struct btrfs_space_info *sinfo, u64 old, s64 diff),

include/trace/events/btrfs.h

2379

TP_ARGS(fs_info, sinfo, old, diff)

include/trace/events/btrfs.h

2385

const struct btrfs_space_info *sinfo, u64 old, s64 diff),

include/trace/events/btrfs.h

2387

TP_ARGS(fs_info, sinfo, old, diff)

kernel/bpf/lpm_trie.c

184

u64 diff = be64_to_cpu(*(__be64 *)node->data ^

kernel/bpf/lpm_trie.c

187

prefixlen = 64 - fls64(diff);

kernel/bpf/lpm_trie.c

190

if (diff)

kernel/bpf/lpm_trie.c

197

u32 diff = be32_to_cpu(*(__be32 *)&node->data[i] ^

kernel/bpf/lpm_trie.c

200

prefixlen += 32 - fls(diff);

kernel/bpf/lpm_trie.c

203

if (diff)

kernel/bpf/lpm_trie.c

209

u16 diff = be16_to_cpu(*(__be16 *)&node->data[i] ^

kernel/bpf/lpm_trie.c

212

prefixlen += 16 - fls(diff);

kernel/bpf/lpm_trie.c

215

if (diff)

kernel/kcsan/core.c

532

u64 old, new, diff;

kernel/kcsan/core.c

633

diff = old ^ new;

kernel/kcsan/core.c

635

diff &= access_mask;

kernel/kcsan/core.c

644

if (diff && !kcsan_ignore_data_race(size, type, old, new, diff))

kernel/kcsan/permissive.h

38

kcsan_ignore_data_race(size_t size, int type, u64 old, u64 new, u64 diff)

kernel/kcsan/permissive.h

80

if (hweight64(diff) == 1) {

kernel/kcsan/permissive.h

87

if (!((!old || !new) && diff == 1))

kernel/kcsan/report.c

478

u64 diff = old ^ new;

kernel/kcsan/report.c

481

diff &= mask;

kernel/kcsan/report.c

482

if (diff) {

kernel/kcsan/report.c

488

hex_len, diff, hex_len, mask);

kernel/power/hibernate.c

292

ktime_t diff;

kernel/power/hibernate.c

298

diff = ktime_sub(stop, start);

kernel/power/hibernate.c

299

elapsed_centisecs64 = ktime_divns(diff, 10*NSEC_PER_MSEC);

kernel/power/wakelock.c

158

int diff;

kernel/power/wakelock.c

162

diff = strncmp(name, wl->name, len);

kernel/power/wakelock.c

163

if (diff == 0) {

kernel/power/wakelock.c

165

diff = -1;

kernel/power/wakelock.c

169

if (diff < 0)

kernel/printk/printk.c

4479

u64 diff;

kernel/printk/printk.c

4503

diff = 0;

kernel/printk/printk.c

4543

diff += seq - printk_seq;

kernel/printk/printk.c

4547

if (diff != last_diff && reset_on_progress)

kernel/printk/printk.c

4553

if (diff == 0 || remaining_jiffies == 0)

kernel/printk/printk.c

4563

last_diff = diff;

kernel/printk/printk.c

4566

return (diff == 0);

kernel/printk/printk_ringbuffer.c

2070

unsigned long diff;

kernel/printk/printk_ringbuffer.c

2141

diff = head_id - last_finalized_id;

kernel/printk/printk_ringbuffer.c

2148

return (last_finalized_seq + diff + 1);

kernel/sched/fair.c

2766

int diff;

kernel/sched/fair.c

2806

diff = slot * period_slot;

kernel/sched/fair.c

2816

diff = slot * period_slot;

kernel/sched/fair.c

2824

diff = -(NUMA_PERIOD_THRESHOLD - ratio) * period_slot;

kernel/sched/fair.c

2827

p->numa_scan_period = clamp(p->numa_scan_period + diff,

kernel/sched/fair.c

2993

long diff, f_diff, f_weight;

kernel/sched/fair.c

3001

diff = p->numa_faults[membuf_idx] - p->numa_faults[mem_idx] / 2;

kernel/sched/fair.c

3018

p->numa_faults[mem_idx] += diff;

kernel/sched/fair.c

3021

p->total_numa_faults += diff;

kernel/sched/fair.c

3030

ng->faults[mem_idx] += diff;

kernel/sched/fair.c

3032

ng->total_faults += diff;

kernel/sched/fair.c

3615

u64 diff = p->se.sum_exec_runtime - runtime;

kernel/sched/fair.c

3616

p->node_stamp += 32 * diff;

kernel/sched/rt.c

621

s64 diff;

kernel/sched/rt.c

639

diff = iter->rt_runtime - iter->rt_time;

kernel/sched/rt.c

640

if (diff > 0) {

kernel/sched/rt.c

641

diff = div_u64((u64)diff, weight);

kernel/sched/rt.c

642

if (rt_rq->rt_runtime + diff > rt_period)

kernel/sched/rt.c

643

diff = rt_period - rt_rq->rt_runtime;

kernel/sched/rt.c

644

iter->rt_runtime -= diff;

kernel/sched/rt.c

645

rt_rq->rt_runtime += diff;

kernel/sched/rt.c

698

s64 diff;

kernel/sched/rt.c

708

diff = min_t(s64, iter->rt_runtime, want);

kernel/sched/rt.c

709

iter->rt_runtime -= diff;

kernel/sched/rt.c

710

want -= diff;

kernel/sched/sched.h

243

s64 diff = sample - *avg;

kernel/sched/sched.h

245

*avg += diff / 8;

kernel/time/timer.c

1038

long diff = timer->expires - expires;

kernel/time/timer.c

1040

if (!diff)

kernel/time/timer.c

1042

if (options & MOD_TIMER_REDUCE && diff <= 0)

kernel/trace/trace_hwlat.c

204

s64 diff, outer_diff, total, last_total = 0;

kernel/trace/trace_hwlat.c

253

diff = time_to_us(time_sub(t2, t1)); /* current diff */

kernel/trace/trace_hwlat.c

255

if (diff > thresh || outer_diff > thresh) {

kernel/trace/trace_hwlat.c

262

if (diff < 0) {

kernel/trace/trace_hwlat.c

267

if (diff > sample)

kernel/trace/trace_hwlat.c

268

sample = diff; /* only want highest value */

kernel/trace/trace_osnoise.c

1722

u64 diff;

kernel/trace/trace_osnoise.c

1775

diff = now - tlat->abs_period;

kernel/trace/trace_osnoise.c

1779

s.timer_latency = diff;

kernel/trace/trace_osnoise.c

1785

if (time_to_us(diff) >= osnoise_data.stop_tracing) {

kernel/trace/trace_osnoise.c

1796

timerlat_dump_stack(time_to_us(diff));

kernel/trace/trace_osnoise.c

1800

notify_new_max_latency(diff);

kernel/trace/trace_osnoise.c

1857

u64 now, diff;

kernel/trace/trace_osnoise.c

1895

diff = now - tlat->abs_period;

kernel/trace/trace_osnoise.c

1898

s.timer_latency = diff;

kernel/trace/trace_osnoise.c

1903

notify_new_max_latency(diff);

kernel/trace/trace_osnoise.c

1905

timerlat_dump_stack(time_to_us(diff));

kernel/trace/trace_osnoise.c

1909

if (time_to_us(diff) >= osnoise_data.stop_tracing_total)

kernel/trace/trace_osnoise.c

2457

s64 diff;

kernel/trace/trace_osnoise.c

2494

diff = now - tlat->abs_period;

kernel/trace/trace_osnoise.c

2499

if (diff < 0)

kernel/trace/trace_osnoise.c

2503

s.timer_latency = diff;

kernel/trace/trace_osnoise.c

2508

notify_new_max_latency(diff);

kernel/trace/trace_osnoise.c

2512

if (time_to_us(diff) >= osnoise_data.stop_tracing_total)

kernel/trace/trace_osnoise.c

2529

diff = now - tlat->abs_period;

kernel/trace/trace_osnoise.c

2534

if (diff < 0)

kernel/trace/trace_osnoise.c

2538

s.timer_latency = diff;

kernel/trace/trace_osnoise.c

2544

if (time_to_us(diff) >= osnoise_data.stop_tracing_total) {

kernel/trace/trace_osnoise.c

2545

timerlat_dump_stack(time_to_us(diff));

kernel/trace/trace_osnoise.c

2546

notify_new_max_latency(diff);

lib/assoc_array.c

485

int level, diff;

lib/assoc_array.c

729

diff = INT_MAX;

lib/assoc_array.c

733

if (x < diff) {

lib/assoc_array.c

735

diff = x;

lib/assoc_array.c

738

BUG_ON(diff == INT_MAX);

lib/assoc_array.c

739

BUG_ON(diff < level + ASSOC_ARRAY_LEVEL_STEP);

lib/assoc_array.c

741

keylen = round_up(diff, ASSOC_ARRAY_KEY_CHUNK_SIZE);

lib/assoc_array.c

758

new_s0->skip_to_level = level = diff & ~ASSOC_ARRAY_LEVEL_STEP_MASK;

lib/assoc_array.c

759

pr_devel("skip_to_level = %d [diff %d]\n", level, diff);

lib/assoc_array.c

800

int level, sc_level, diff;

lib/assoc_array.c

818

diff = __ffs(dissimilarity);

lib/assoc_array.c

819

diff &= ~ASSOC_ARRAY_LEVEL_STEP_MASK;

lib/assoc_array.c

820

diff += sc_level & ~ASSOC_ARRAY_KEY_CHUNK_MASK;

lib/assoc_array.c

821

pr_devel("diff=%d\n", diff);

lib/assoc_array.c

846

if (diff > level) {

lib/assoc_array.c

847

pr_devel("pre-shortcut %d...%d\n", level, diff);

lib/assoc_array.c

848

keylen = round_up(diff, ASSOC_ARRAY_KEY_CHUNK_SIZE);

lib/assoc_array.c

859

new_s0->skip_to_level = diff;

lib/assoc_array.c

867

blank = ULONG_MAX << (diff & ASSOC_ARRAY_KEY_CHUNK_MASK);

lib/assoc_array.c

868

pr_devel("blank off [%zu] %d: %lx\n", keylen - 1, diff, blank);

lib/assoc_array.c

883

sc_slot = sc_segments >> (diff & ASSOC_ARRAY_KEY_CHUNK_MASK);

lib/assoc_array.c

887

sc_segments, diff & ASSOC_ARRAY_KEY_CHUNK_MASK, sc_slot);

lib/assoc_array.c

894

level = diff + ASSOC_ARRAY_LEVEL_STEP;

lib/crypto/mpi/mpih-cmp.c

34

goto diff;

lib/crypto/mpi/mpih-cmp.c

38

diff:

lib/lz4/lz4defs.h

203

size_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn);

lib/lz4/lz4defs.h

205

if (!diff) {

lib/lz4/lz4defs.h

211

pIn += LZ4_NbCommonBytes(diff);

lib/test_objagg.c

104

int diff = key->id - parent_key->id;

lib/test_objagg.c

113

delta->key_id_diff = diff;

lib/test_objagg.c

94

int diff = key->id - parent_key->id;

lib/test_objagg.c

96

return diff >= 0 && diff <= MAX_KEY_ID_DIFF;

lib/tests/overflow_kunit.c

332

check_one_op(t, fmt, sub, "-", p->a, p->b, p->diff, p->d_of); \

lib/tests/overflow_kunit.c

52

t sum, diff, prod; \

lib/zstd/common/zstd_internal.h

212

ptrdiff_t diff = (BYTE*)dst - (const BYTE*)src;

lib/zstd/common/zstd_internal.h

217

if (ovtype == ZSTD_overlap_src_before_dst && diff < WILDCOPY_VECLEN) {

lib/zstd/common/zstd_internal.h

223

assert(diff >= WILDCOPY_VECLEN || diff <= -WILDCOPY_VECLEN);

lib/zstd/compress/zstd_compress_internal.h

852

{ size_t const diff = MEM_readST(pMatch) ^ MEM_readST(pIn);

lib/zstd/compress/zstd_compress_internal.h

853

if (diff) return ZSTD_NbCommonBytes(diff); }

lib/zstd/compress/zstd_compress_internal.h

856

size_t const diff = MEM_readST(pMatch) ^ MEM_readST(pIn);

lib/zstd/compress/zstd_compress_internal.h

857

if (!diff) { pIn+=sizeof(size_t); pMatch+=sizeof(size_t); continue; }

lib/zstd/compress/zstd_compress_internal.h

858

pIn += ZSTD_NbCommonBytes(diff);

lib/zstd/decompress/zstd_decompress_block.c

839

ptrdiff_t const diff = op - ip;

lib/zstd/decompress/zstd_decompress_block.c

842

assert((ovtype == ZSTD_no_overlap && (diff <= -8 || diff >= 8 || op >= oend_w)) ||

lib/zstd/decompress/zstd_decompress_block.c

843

(ovtype == ZSTD_overlap_src_before_dst && diff >= 0));

lib/zstd/decompress/zstd_decompress_block.c

853

ZSTD_overlapCopy8(&op, &ip, diff);

lib/zstd/decompress/zstd_decompress_block.c

879

ptrdiff_t const diff = op - ip;

lib/zstd/decompress/zstd_decompress_block.c

882

if (length < 8 || diff > -8) {

lib/zstd/decompress/zstd_decompress_block.c

888

if (op <= oend - WILDCOPY_OVERLENGTH && diff < -WILDCOPY_VECLEN) {

net/batman-adv/bat_iv_ogm.c

2019

int *diff)

net/batman-adv/bat_iv_ogm.c

2035

*diff = (int)tq1 - (int)tq2;

net/batman-adv/bat_iv_ogm.c

2189

int diff;

net/batman-adv/bat_iv_ogm.c

2192

if_outgoing2, &diff);

net/batman-adv/bat_iv_ogm.c

2196

return diff;

net/batman-adv/bat_iv_ogm.c

2217

int diff;

net/batman-adv/bat_iv_ogm.c

2220

if_outgoing2, &diff);

net/batman-adv/bat_iv_ogm.c

2224

ret = diff > -BATADV_TQ_SIMILARITY_THRESHOLD;

net/batman-adv/bitarray.h

30

s32 diff;

net/batman-adv/bitarray.h

32

diff = last_seqno - curr_seqno;

net/batman-adv/bitarray.h

33

if (diff < 0 || diff >= BATADV_TQ_LOCAL_WINDOW_SIZE)

net/batman-adv/bitarray.h

35

return test_bit(diff, seq_bits) != 0;

net/core/dev.c

11054

netdev_features_t diff = features ^ dev->features;

net/core/dev.c

11056

if (diff & NETIF_F_RX_UDP_TUNNEL_PORT) {

net/core/dev.c

11074

if (diff & NETIF_F_HW_VLAN_CTAG_FILTER) {

net/core/dev.c

11083

if (diff & NETIF_F_HW_VLAN_STAG_FILTER) {

net/core/dev_addr_lists.c

176

int diff = memcmp(addr, ha->addr, addr_len);

net/core/dev_addr_lists.c

178

if (diff == 0 && addr_type)

net/core/dev_addr_lists.c

179

diff = memcmp(&addr_type, &ha->type, sizeof(addr_type));

net/core/dev_addr_lists.c

181

if (diff < 0)

net/core/dev_addr_lists.c

183

else if (diff > 0)

net/core/dev_addr_lists.c

28

int diff;

net/core/dev_addr_lists.c

31

diff = memcmp(new->addr, ha->addr, addr_len);

net/core/dev_addr_lists.c

32

if (diff == 0)

net/core/dev_addr_lists.c

33

diff = memcmp(&new->type, &ha->type, sizeof(new->type));

net/core/dev_addr_lists.c

36

if (diff < 0)

net/core/dev_addr_lists.c

38

else if (diff > 0)

net/core/dev_addr_lists.c

85

int diff;

net/core/dev_addr_lists.c

88

diff = memcmp(addr, ha->addr, addr_len);

net/core/dev_addr_lists.c

89

if (diff == 0)

net/core/dev_addr_lists.c

90

diff = memcmp(&addr_type, &ha->type, sizeof(addr_type));

net/core/dev_addr_lists.c

93

if (diff < 0) {

net/core/dev_addr_lists.c

95

} else if (diff > 0) {

net/core/flow_dissector.c

1716

size_t diff = FLOW_KEYS_HASH_OFFSET + sizeof(flow->addrs);

net/core/flow_dissector.c

1722

diff -= sizeof(flow->addrs.v4addrs);

net/core/flow_dissector.c

1725

diff -= sizeof(flow->addrs.v6addrs);

net/core/flow_dissector.c

1728

diff -= sizeof(flow->addrs.tipckey);

net/core/flow_dissector.c

1731

return sizeof(*flow) - diff;

net/core/skbuff.c

6562

__be16 diff[] = { ~hdr->h_proto, ethertype };

net/core/skbuff.c

6564

skb->csum = csum_partial((char *)diff, sizeof(diff), skb->csum);

net/core/skbuff.c

6693

__be32 diff[] = { ~mpls_hdr(skb)->label_stack_entry, mpls_lse };

net/core/skbuff.c

6695

skb->csum = csum_partial((char *)diff, sizeof(diff), skb->csum);

net/core/utils.c

463

__be32 diff[] = {

net/core/utils.c

468

*sum = csum_fold(csum_partial(diff, sizeof(diff),

net/core/utils.c

471

*sum = ~csum_fold(csum_partial(diff, sizeof(diff),

net/core/utils.c

477

__wsum diff, bool pseudohdr, bool ipv6)

net/core/utils.c

480

csum_replace_by_diff(sum, diff);

net/core/utils.c

482

skb->csum = ~csum_sub(diff, skb->csum);

net/core/utils.c

484

*sum = ~csum_fold(csum_add(diff, csum_unfold(*sum)));

net/ipv4/syncookies.c

117

u32 diff, count = tcp_cookie_time();

net/ipv4/syncookies.c

123

diff = (count - (cookie >> COOKIEBITS)) & ((__u32) -1 >> COOKIEBITS);

net/ipv4/syncookies.c

124

if (diff >= MAX_SYNCOOKIE_AGE)

net/ipv4/syncookies.c

128

cookie_hash(saddr, daddr, sport, dport, count - diff, 1))

net/ipv4/tcp_bbr.c

661

u32 diff;

net/ipv4/tcp_bbr.c

665

diff = abs(bw - bbr->lt_bw);

net/ipv4/tcp_bbr.c

666

if ((diff * BBR_UNIT <= bbr_lt_bw_ratio * bbr->lt_bw) ||

net/ipv4/tcp_bbr.c

667

(bbr_rate_bytes_per_sec(sk, diff, BBR_UNIT) <=

net/ipv4/tcp_htcp.c

177

u32 diff = htcp_cong_time(ca);

net/ipv4/tcp_htcp.c

179

if (diff > HZ) {

net/ipv4/tcp_htcp.c

180

diff -= HZ;

net/ipv4/tcp_htcp.c

181

factor = 1 + (10 * diff + ((diff / 2) * (diff / 2) / HZ)) / HZ;

net/ipv4/tcp_output.c

1897

int diff = old_factor - tcp_skb_pcount(skb) -

net/ipv4/tcp_output.c

1900

if (diff)

net/ipv4/tcp_output.c

1901

tcp_adjust_pcount(sk, skb, diff);

net/ipv4/tcp_output.c

3557

int diff, len, err;

net/ipv4/tcp_output.c

3626

diff = tcp_skb_pcount(skb);

net/ipv4/tcp_output.c

3628

diff -= tcp_skb_pcount(skb);

net/ipv4/tcp_output.c

3629

if (diff)

net/ipv4/tcp_output.c

3630

tcp_adjust_pcount(sk, skb, diff);

net/ipv4/tcp_vegas.c

198

u32 rtt, diff;

net/ipv4/tcp_vegas.c

227

diff = tcp_snd_cwnd(tp) * (rtt-vegas->baseRTT) / vegas->baseRTT;

net/ipv4/tcp_vegas.c

229

if (diff > gamma && tcp_in_slow_start(tp)) {

net/ipv4/tcp_vegas.c

254

if (diff > beta) {

net/ipv4/tcp_vegas.c

261

} else if (diff < alpha) {

net/ipv4/tcp_veno.c

153

veno->diff = (tcp_snd_cwnd(tp) << V_PARAM_SHIFT) - target_cwnd;

net/ipv4/tcp_veno.c

163

if (veno->diff < beta) {

net/ipv4/tcp_veno.c

200

if (veno->diff < beta)

net/ipv4/tcp_veno.c

33

u32 diff; /* calculate the diff rate */

net/ipv6/ila/ila.h

81

__be32 diff[] = {

net/ipv6/ila/ila.h

85

return csum_partial(diff, sizeof(diff), 0);

net/ipv6/ila/ila_common.c

100

diff, true, true);

net/ipv6/ila/ila_common.c

112

diff = get_csum_diff(ip6h, p);

net/ipv6/ila/ila_common.c

114

diff, true, true);

net/ipv6/ila/ila_common.c

44

__wsum diff, fval;

net/ipv6/ila/ila_common.c

46

diff = get_csum_diff_iaddr(iaddr, p);

net/ipv6/ila/ila_common.c

51

diff = csum_add(diff, fval);

net/ipv6/ila/ila_common.c

53

*adjust = ~csum_fold(csum_add(diff, csum_unfold(*adjust)));

net/ipv6/ila/ila_common.c

67

__wsum diff;

net/ipv6/ila/ila_common.c

69

diff = get_csum_diff_iaddr(iaddr, p);

net/ipv6/ila/ila_common.c

71

*adjust = ~csum_fold(csum_add(diff, csum_unfold(*adjust)));

net/ipv6/ila/ila_common.c

79

__wsum diff;

net/ipv6/ila/ila_common.c

87

diff = get_csum_diff(ip6h, p);

net/ipv6/ila/ila_common.c

89

diff, true, true);

net/ipv6/ila/ila_common.c

98

diff = get_csum_diff(ip6h, p);

net/ipv6/syncookies.c

80

__u32 diff, count = tcp_cookie_time();

net/ipv6/syncookies.c

84

diff = (count - (cookie >> COOKIEBITS)) & ((__u32) -1 >> COOKIEBITS);

net/ipv6/syncookies.c

85

if (diff >= MAX_SYNCOOKIE_AGE)

net/ipv6/syncookies.c

89

cookie_hash(saddr, daddr, sport, dport, count - diff, 1))

net/mac80211/rc80211_minstrel_ht.c

723

int diff, incr;

net/mac80211/rc80211_minstrel_ht.c

725

diff = new - old;

net/mac80211/rc80211_minstrel_ht.c

726

incr = (EWMA_DIV - weight) * diff / EWMA_DIV;

net/mac80211/rx.c

4398

int i, diff;

net/mac80211/rx.c

4439

diff = (tid_agg_rx->head_seq_num - ssn) & IEEE80211_SN_MASK;

net/mac80211/rx.c

4440

if (diff >= tid_agg_rx->buf_size) {

net/mac80211/rx.c

4444

filtered = filtered >> diff;

net/mac80211/rx.c

4445

ssn += diff;

net/mac80211/spectmgmt.c

48

u8 diff = abs(ccfs0 - ccfs1);

net/mac80211/spectmgmt.c

50

if (diff == 8) {

net/mac80211/spectmgmt.c

53

} else if (diff > 8) {

net/mac80211/util.c

3111

unsigned int diff;

net/mac80211/util.c

3113

diff = abs(ccf1 - ccf0);

net/mac80211/util.c

3114

if ((diff == 8) && support_160) {

net/mac80211/util.c

3117

} else if ((diff > 8) && support_80_80) {

net/netfilter/ipvs/ip_vs_app.c

346

unsigned int flag, __u32 seq, int diff)

net/netfilter/ipvs/ip_vs_app.c

352

vseq->delta += diff;

net/netfilter/ipvs/ip_vs_app.c

363

int diff;

net/netfilter/ipvs/ip_vs_app.c

392

if (!app->pkt_out(app, cp, skb, &diff, ipvsh))

net/netfilter/ipvs/ip_vs_app.c

398

if (diff != 0)

net/netfilter/ipvs/ip_vs_app.c

400

IP_VS_CONN_F_OUT_SEQ, seq, diff);

net/netfilter/ipvs/ip_vs_app.c

440

int diff;

net/netfilter/ipvs/ip_vs_app.c

469

if (!app->pkt_in(app, cp, skb, &diff, ipvsh))

net/netfilter/ipvs/ip_vs_app.c

475

if (diff != 0)

net/netfilter/ipvs/ip_vs_app.c

477

IP_VS_CONN_F_IN_SEQ, seq, diff);

net/netfilter/ipvs/ip_vs_est.c

646

s64 diff;

net/netfilter/ipvs/ip_vs_est.c

687

diff = ktime_to_ns(ktime_sub(t2, t1));

net/netfilter/ipvs/ip_vs_est.c

688

if (diff <= 1 * NSEC_PER_USEC) {

net/netfilter/ipvs/ip_vs_est.c

693

if (diff >= NSEC_PER_SEC)

net/netfilter/ipvs/ip_vs_est.c

695

val = diff;

net/netfilter/ipvs/ip_vs_ftp.c

249

struct sk_buff *skb, int *diff,

net/netfilter/ipvs/ip_vs_ftp.c

263

*diff = 0;

net/netfilter/ipvs/ip_vs_ftp.c

419

struct sk_buff *skb, int *diff,

net/netfilter/ipvs/ip_vs_ftp.c

429

*diff = 0;

net/netfilter/ipvs/ip_vs_sync.c

503

long diff = n - orig;

net/netfilter/ipvs/ip_vs_sync.c

509

if (abs(diff) < min_t(long, sync_refresh_period, min_diff)) {

net/netfilter/nf_conncount.c

418

int diff;

net/netfilter/nf_conncount.c

422

diff = key_diff(key, rbconn->key, data->keylen);

net/netfilter/nf_conncount.c

423

if (diff < 0) {

net/netfilter/nf_conncount.c

425

} else if (diff > 0) {

net/netfilter/nf_conncount.c

504

int diff;

net/netfilter/nf_conncount.c

508

diff = key_diff(key, rbconn->key, data->keylen);

net/netfilter/nf_conncount.c

509

if (diff < 0) {

net/netfilter/nf_conncount.c

511

} else if (diff > 0) {

net/netfilter/nf_conntrack_netlink.c

2891

enum ip_conntrack_info ctinfo, int diff)

net/netfilter/nf_conntrack_netlink.c

2896

nf_ct_tcp_seqadj_set(skb, ct, ctinfo, diff);

net/netfilter/nf_conntrack_sip.c

1546

s16 diff, tdiff = 0;

net/netfilter/nf_conntrack_sip.c

1607

diff = msglen - origlen;

net/netfilter/nf_conntrack_sip.c

1608

tdiff += diff;

net/netfilter/nf_conntrack_sip.c

1612

datalen = datalen + diff - msglen;

net/netfilter/nfnetlink_queue.c

1163

nfqnl_mangle(void *data, unsigned int data_len, struct nf_queue_entry *e, int diff)

net/netfilter/nfnetlink_queue.c

1167

if (diff < 0) {

net/netfilter/nfnetlink_queue.c

1175

} else if (diff > 0) {

net/netfilter/nfnetlink_queue.c

1178

if (diff > skb_tailroom(e->skb)) {

net/netfilter/nfnetlink_queue.c

1180

diff, GFP_ATOMIC);

net/netfilter/nfnetlink_queue.c

1186

skb_put(e->skb, diff);

net/netfilter/nfnetlink_queue.c

1557

int diff = payload_len - entry->skb->len;

net/netfilter/nfnetlink_queue.c

1560

payload_len, entry, diff) < 0)

net/netfilter/nfnetlink_queue.c

1563

if (ct && diff)

net/netfilter/nfnetlink_queue.c

1564

nfnl_ct->seq_adjust(entry->skb, ct, ctinfo, diff);

net/rds/cong.c

112

int diff;

net/rds/cong.c

117

diff = rds_addr_cmp(addr, &map->m_addr);

net/rds/cong.c

118

if (diff < 0)

net/rds/cong.c

120

else if (diff > 0)

net/rds/ib_ring.c

75

u32 diff;

net/rds/ib_ring.c

78

diff = ring->w_alloc_ctr - (u32) atomic_read(&ring->w_free_ctr);

net/rds/ib_ring.c

79

BUG_ON(diff > ring->w_nr);

net/rds/ib_ring.c

81

return diff;

net/rxrpc/conn_client.c

255

long diff;

net/rxrpc/conn_client.c

275

diff = (cmp(bundle->peer, call->peer) ?:

net/rxrpc/conn_client.c

280

if (diff < 0)

net/rxrpc/conn_client.c

282

else if (diff > 0)

net/rxrpc/conn_client.c

304

diff = (cmp(bundle->peer, call->peer) ?:

net/rxrpc/conn_client.c

309

if (diff < 0)

net/rxrpc/conn_client.c

311

else if (diff > 0)

net/rxrpc/local_object.c

253

long diff;

net/rxrpc/local_object.c

264

diff = rxrpc_local_cmp_key(local, srx);

net/rxrpc/local_object.c

265

if (diff != 0)

net/rxrpc/local_object.c

62

long diff;

net/rxrpc/local_object.c

64

diff = ((local->srx.transport_type - srx->transport_type) ?:

net/rxrpc/local_object.c

67

if (diff != 0)

net/rxrpc/local_object.c

68

return diff;

net/rxrpc/peer_event.c

248

s32 diff = last_tx_at - base_lsw;

net/rxrpc/peer_event.c

250

diff = clamp(diff, -RXRPC_KEEPALIVE_TIME, RXRPC_KEEPALIVE_TIME);

net/rxrpc/peer_event.c

252

return diff + base;

net/rxrpc/peer_object.c

83

long diff;

net/rxrpc/peer_object.c

85

diff = ((peer->hash_key - hash_key) ?:

net/rxrpc/peer_object.c

90

if (diff != 0)

net/rxrpc/peer_object.c

91

return diff;

net/sched/cls_api.c

3572

u32 *flags, u32 diff, bool add)

net/sched/cls_api.c

3580

*cnt += diff;

net/sched/cls_api.c

3582

*cnt -= diff;

net/sched/sch_dualpi2.c

621

static s64 __scale_delta(u64 diff)

net/sched/sch_dualpi2.c

623

do_div(diff, 1 << ALPHA_BETA_GRANULARITY);

net/sched/sch_dualpi2.c

624

return diff;

net/sched/sch_htb.c

533

htb_class_mode(struct htb_class *cl, s64 *diff)

net/sched/sch_htb.c

537

if ((toks = (cl->ctokens + *diff)) < htb_lowater(cl)) {

net/sched/sch_htb.c

538

*diff = -toks;

net/sched/sch_htb.c

542

if ((toks = (cl->tokens + *diff)) >= htb_hiwater(cl))

net/sched/sch_htb.c

545

*diff = -toks;

net/sched/sch_htb.c

562

htb_change_class_mode(struct htb_sched *q, struct htb_class *cl, s64 *diff)

net/sched/sch_htb.c

564

enum htb_cmode new_mode = htb_class_mode(cl, diff);

net/sched/sch_htb.c

658

static inline void htb_accnt_tokens(struct htb_class *cl, int bytes, s64 diff)

net/sched/sch_htb.c

660

s64 toks = diff + cl->tokens;

net/sched/sch_htb.c

671

static inline void htb_accnt_ctokens(struct htb_class *cl, int bytes, s64 diff)

net/sched/sch_htb.c

673

s64 toks = diff + cl->ctokens;

net/sched/sch_htb.c

704

s64 diff;

net/sched/sch_htb.c

707

diff = min_t(s64, q->now - cl->t_c, cl->mbuffer);

net/sched/sch_htb.c

711

htb_accnt_tokens(cl, bytes, diff);

net/sched/sch_htb.c

714

cl->tokens += diff; /* we moved t_c; update tokens */

net/sched/sch_htb.c

716

htb_accnt_ctokens(cl, bytes, diff);

net/sched/sch_htb.c

720

diff = 0;

net/sched/sch_htb.c

721

htb_change_class_mode(q, cl, &diff);

net/sched/sch_htb.c

726

htb_add_to_wait_tree(q, cl, diff);

net/sched/sch_htb.c

759

s64 diff;

net/sched/sch_htb.c

770

diff = min_t(s64, q->now - cl->t_c, cl->mbuffer);

net/sched/sch_htb.c

771

htb_change_class_mode(q, cl, &diff);

net/sched/sch_htb.c

773

htb_add_to_wait_tree(q, cl, diff);

net/sctp/auth.c

152

int diff;

net/sctp/auth.c

156

diff = vector1->len - vector2->len;

net/sctp/auth.c

157

if (diff) {

net/sctp/auth.c

158

longer = (diff > 0) ? vector1->data : vector2->data;

net/sctp/auth.c

164

for (i = 0; i < abs(diff); i++) {

net/sctp/auth.c

166

return diff;

net/smc/smc_cdc.c

242

int rc, diff;

net/smc/smc_cdc.c

268

diff = smc_curs_diff(conn->sndbuf_desc->len, &conn->tx_curs_fin,

net/smc/smc_cdc.c

272

atomic_add(diff, &conn->sndbuf_space);

net/smc/smc_cdc.c

313

s16 diff;

net/smc/smc_cdc.c

316

diff = conn->local_rx_ctrl.seqno - recv_seq;

net/smc/smc_cdc.c

317

if (diff < 0) { /* diff larger than 0x7fff */

net/smc/smc_cdc.c

34

int diff;

net/smc/smc_cdc.c

40

diff = smc_curs_diff(sndbuf_desc->len,

net/smc/smc_cdc.c

45

atomic_add(diff, &cdcpend->conn->sndbuf_space);

net/smc/smc_core.c

1039

int diff;

net/smc/smc_core.c

1051

diff = smc_curs_diff(conn->peer_rmbe_size, &fin, &cons);

net/smc/smc_core.c

1053

&conn->tx_curs_sent, diff);

net/smc/smc_core.c

1055

&conn->tx_curs_fin, diff);

net/smc/smc_core.c

1058

atomic_add(diff, &conn->sndbuf_space);

net/smc/smc_core.c

1062

&conn->local_tx_ctrl.prod, diff);

net/smc/smc_core.c

1064

&conn->local_tx_ctrl_fin, diff);

net/smc/smc_rx.c

65

int diff, rc = 0;

net/smc/smc_rx.c

71

diff = smc_curs_comp(conn->rmb_desc->len, &cons,

net/smc/smc_rx.c

74

if (diff == 0) {

net/smc/smc_rx.c

80

if (diff == 1) {

net/smc/smc_rx.c

85

} else if (diff < -1)

net/sunrpc/auth.c

498

unsigned long diff;

net/sunrpc/auth.c

503

diff = number_cred_unused - auth_max_cred_cachesize;

net/sunrpc/auth.c

505

if (diff < nr_to_scan)

net/sunrpc/auth.c

506

nr_to_scan = diff;

net/tipc/monitor.c

278

bool diff;

net/tipc/monitor.c

286

diff = dom->member_cnt != member_cnt;

net/tipc/monitor.c

290

diff |= dom->members[i] != peer->addr;

net/tipc/monitor.c

295

diff |= dom->up_map != prev_up_map;

net/tipc/monitor.c

296

if (!diff)

net/xfrm/xfrm_replay.c

124

u32 diff;

net/xfrm/xfrm_replay.c

136

diff = x->replay.seq - seq;

net/xfrm/xfrm_replay.c

137

if (diff >= x->props.replay_window) {

net/xfrm/xfrm_replay.c

142

if (x->replay.bitmap & (1U << diff)) {

net/xfrm/xfrm_replay.c

158

u32 diff, seq;

net/xfrm/xfrm_replay.c

174

diff = seq - x->replay.seq;

net/xfrm/xfrm_replay.c

175

if (diff < x->props.replay_window)

net/xfrm/xfrm_replay.c

176

x->replay.bitmap = ((x->replay.bitmap) << diff) | 1;

net/xfrm/xfrm_replay.c

181

diff = x->replay.seq - seq;

net/xfrm/xfrm_replay.c

182

x->replay.bitmap |= (1U << diff);

net/xfrm/xfrm_replay.c

220

u32 diff = replay_esn->seq - seq;

net/xfrm/xfrm_replay.c

231

if (diff >= replay_esn->replay_window) {

net/xfrm/xfrm_replay.c

238

if (pos >= diff)

net/xfrm/xfrm_replay.c

239

bitnr = (pos - diff) % replay_esn->replay_window;

net/xfrm/xfrm_replay.c

241

bitnr = replay_esn->replay_window - (diff - pos);

net/xfrm/xfrm_replay.c

260

u32 diff;

net/xfrm/xfrm_replay.c

271

diff = seq - replay_esn->seq;

net/xfrm/xfrm_replay.c

273

if (diff < replay_esn->replay_window) {

net/xfrm/xfrm_replay.c

274

for (i = 1; i < diff; i++) {

net/xfrm/xfrm_replay.c

286

bitnr = (pos + diff) % replay_esn->replay_window;

net/xfrm/xfrm_replay.c

289

diff = replay_esn->seq - seq;

net/xfrm/xfrm_replay.c

291

if (pos >= diff)

net/xfrm/xfrm_replay.c

292

bitnr = (pos - diff) % replay_esn->replay_window;

net/xfrm/xfrm_replay.c

294

bitnr = replay_esn->replay_window - (diff - pos);

net/xfrm/xfrm_replay.c

455

u32 diff;

net/xfrm/xfrm_replay.c

470

diff = top - seq;

net/xfrm/xfrm_replay.c

481

diff = ~seq + top + 1;

net/xfrm/xfrm_replay.c

484

if (diff >= replay_esn->replay_window) {

net/xfrm/xfrm_replay.c

491

if (pos >= diff)

net/xfrm/xfrm_replay.c

492

bitnr = (pos - diff) % replay_esn->replay_window;

net/xfrm/xfrm_replay.c

494

bitnr = replay_esn->replay_window - (diff - pos);

net/xfrm/xfrm_replay.c

557

u32 diff, pos, seq, seq_hi;

net/xfrm/xfrm_replay.c

570

diff = seq - replay_esn->seq;

net/xfrm/xfrm_replay.c

572

diff = ~replay_esn->seq + seq + 1;

net/xfrm/xfrm_replay.c

574

if (diff < replay_esn->replay_window) {

net/xfrm/xfrm_replay.c

575

for (i = 1; i < diff; i++) {

net/xfrm/xfrm_replay.c

587

bitnr = (pos + diff) % replay_esn->replay_window;

net/xfrm/xfrm_replay.c

593

diff = replay_esn->seq - seq;

net/xfrm/xfrm_replay.c

595

if (pos >= diff)

net/xfrm/xfrm_replay.c

596

bitnr = (pos - diff) % replay_esn->replay_window;

net/xfrm/xfrm_replay.c

598

bitnr = replay_esn->replay_window - (diff - pos);

samples/cgroup/memcg_event_listener.c

175

long diff;

samples/cgroup/memcg_event_listener.c

178

diff = *map[i].new - *map[i].old;

samples/cgroup/memcg_event_listener.c

183

diff, map[i].name,

samples/cgroup/memcg_event_listener.c

184

(diff == 1) ? "" : "s",

samples/cgroup/memcg_event_listener.c

187

*map[i].old += diff;

scripts/dtc/srcpos.c

75

int diff = initial_pathlen - slashes, i, j;

scripts/dtc/srcpos.c

79

res = xmalloc((3 * diff) + restlen + 1);

scripts/dtc/srcpos.c

80

for (i = 0, j = 0; i != diff; i++) {

sound/core/pcm_lib.c

1008

diff = q * den - num;

sound/core/pcm_lib.c

1010

diff * best_den < best_diff * den) {

sound/core/pcm_lib.c

1011

best_diff = diff;

sound/core/pcm_lib.c

2232

snd_pcm_sframes_t diff;

sound/core/pcm_lib.c

2244

diff = appl_ptr - old_appl_ptr;

sound/core/pcm_lib.c

2245

if (diff >= 0) {

sound/core/pcm_lib.c

2246

if (diff > runtime->buffer_size)

sound/core/pcm_lib.c

2249

if (runtime->boundary + diff > runtime->buffer_size)

sound/core/pcm_lib.c

848

int diff;

sound/core/pcm_lib.c

862

diff = num - q * den;

sound/core/pcm_lib.c

863

if (diff < 0)

sound/core/pcm_lib.c

864

diff = -diff;

sound/core/pcm_lib.c

866

diff * best_den < best_diff * den) {

sound/core/pcm_lib.c

867

best_diff = diff;

sound/core/pcm_lib.c

887

int diff;

sound/core/pcm_lib.c

903

diff = q * den - num;

sound/core/pcm_lib.c

904

if (diff < 0)

sound/core/pcm_lib.c

905

diff = -diff;

sound/core/pcm_lib.c

907

diff * best_den < best_diff * den) {

sound/core/pcm_lib.c

908

best_diff = diff;

sound/core/pcm_lib.c

964

int diff;

sound/core/pcm_lib.c

976

diff = num - q * den;

sound/core/pcm_lib.c

978

diff * best_den < best_diff * den) {

sound/core/pcm_lib.c

979

best_diff = diff;

sound/core/pcm_lib.c

996

int diff;

sound/drivers/aloop.c

591

snd_pcm_uframes_t appl_ptr, appl_ptr1, diff;

sound/drivers/aloop.c

597

diff = (appl_ptr - appl_ptr1) * play->pcm_salign;

sound/drivers/aloop.c

598

if (diff < bytes) {

sound/drivers/aloop.c

599

clear_bytes = bytes - diff;

sound/drivers/aloop.c

600

bytes = diff;

sound/pci/ctxfi/cttimer.c

177

unsigned int wc, diff;

sound/pci/ctxfi/cttimer.c

186

diff = wc - atimer->wc;

sound/pci/ctxfi/cttimer.c

189

if (ti->frag_count > diff)

sound/pci/ctxfi/cttimer.c

190

ti->frag_count -= diff;

sound/pci/es1938.c

757

unsigned int diff;

sound/pci/es1938.c

761

diff = chip->dma1_start + chip->dma1_size - ptr - count;

sound/pci/es1938.c

763

if (diff > 3 || ptr < chip->dma1_start

sound/pci/es1968.c

1643

ktime_t diff;

sound/pci/es1968.c

1712

diff = ktime_sub(stop_time, start_time);

sound/pci/es1968.c

1713

t = ktime_to_us(diff);

sound/pci/es1968.c

1784

unsigned int diff;

sound/pci/es1968.c

1788

diff = (cp1 > cp2 ? cp1 - cp2 : cp2 - cp1);

sound/pci/es1968.c

1790

if (diff > 1)

sound/pci/es1968.c

1800

unsigned int diff;

sound/pci/es1968.c

1809

diff = (es->dma_size + hwptr - es->hwptr) % es->dma_size;

sound/pci/es1968.c

1812

es->count += diff;

sound/pci/maestro3.c

1478

int diff;

sound/pci/maestro3.c

1489

diff = s->dma_size + hwptr - s->hwptr;

sound/pci/maestro3.c

1490

if (diff >= s->dma_size)

sound/pci/maestro3.c

1491

diff %= s->dma_size;

sound/pci/maestro3.c

1494

s->count += diff;

sound/soc/codecs/arizona.c

2661

bool diff)

sound/soc/codecs/arizona.c

2670

if (diff)

sound/soc/codecs/arizona.h

361

bool diff);

sound/soc/codecs/wm8960.c

645

int diff;

sound/soc/codecs/wm8960.c

662

diff = sysclk - bclk * bclk_divs[k] / 10;

sound/soc/codecs/wm8960.c

663

if (diff == 0) {

sound/soc/codecs/wm8960.c

707

int diff, closest, best_freq_out;

sound/soc/codecs/wm8960.c

734

diff = sysclk - bclk * bclk_divs[k] / 10;

sound/soc/codecs/wm8960.c

735

if (diff == 0) {

sound/soc/codecs/wm8960.c

741

if (diff > 0 && closest > diff) {

sound/soc/codecs/wm8960.c

745

closest = diff;

sound/soc/codecs/wm8962.c

2475

int best, min_diff, diff;

sound/soc/codecs/wm8962.c

2561

diff = (dspclk / bclk_divs[i]) - wm8962->bclk;

sound/soc/codecs/wm8962.c

2562

if (diff < 0) /* Table is sorted */

sound/soc/codecs/wm8962.c

2564

if (diff < min_diff) {

sound/soc/codecs/wm8962.c

2566

min_diff = diff;

sound/soc/codecs/wm8978.c

729

unsigned int f_sel, diff, diff_best = INT_MAX;

sound/soc/codecs/wm8978.c

794

diff = abs(wm8978->f_256fs * 3 -

sound/soc/codecs/wm8978.c

797

if (diff < diff_best) {

sound/soc/codecs/wm8978.c

798

diff_best = diff;

sound/soc/codecs/wm8978.c

802

if (!diff)

sound/soc/codecs/wm8978.c

808

diff = 0;

sound/soc/codecs/wm8978.c

811

if (diff)

sound/soc/fsl/fsl_sai.c

468

int diff;

sound/soc/fsl/fsl_sai.c

482

diff = abs((long)clk_rate - ratio * freq);

sound/soc/fsl/fsl_sai.c

488

if (diff != 0 && clk_rate / diff < 1000)

sound/soc/fsl/fsl_sai.c

496

if (diff < bestdiff) {

sound/soc/fsl/fsl_sai.c

499

bestdiff = diff;

sound/soc/fsl/fsl_sai.c

502

if (diff == 0)

sound/soc/fsl/lpc3xxx-i2s.c

42

u32 diff, trate, baseclk;

sound/soc/fsl/lpc3xxx-i2s.c

56

diff = ~0;

sound/soc/fsl/lpc3xxx-i2s.c

60

if (abs(trate - i2srate) < diff) {

sound/soc/fsl/lpc3xxx-i2s.c

61

diff = abs(trate - i2srate);

sound/soc/renesas/fsi.c

1003

diff = abs(actual - target);

sound/soc/renesas/fsi.c

1004

if (diff < min) {

sound/soc/renesas/fsi.c

1005

min = diff;

sound/soc/renesas/fsi.c

951

unsigned long diff, min;

sound/soc/renesas/rcar/adg.c

138

unsigned int min, diff;

sound/soc/renesas/rcar/adg.c

159

diff = abs(target_rate - sel_rate[sel] / div);

sound/soc/renesas/rcar/adg.c

160

if (min > diff) {

sound/soc/renesas/rcar/adg.c

162

min = diff;

sound/soc/uniphier/aio-core.c

746

int cur, diff, slope = 0, fs;

sound/soc/uniphier/aio-core.c

752

diff = abs(vol - cur);

sound/soc/uniphier/aio-core.c

755

slope = diff / AUD_VOL_FADE_TIME * 1000 / fs;

sound/usb/usx2y/us144mkii_pcm.c

20

int diff, i;

sound/usb/usx2y/us144mkii_pcm.c

28

diff = target_sum - (size * initial_value);

sound/usb/usx2y/us144mkii_pcm.c

29

for (i = 0; i < abs(diff); ++i) {

sound/usb/usx2y/us144mkii_pcm.c

30

if (diff > 0)

sound/usb/usx2y/usb_stream.c

552

int diff;

sound/usb/usx2y/usb_stream.c

558

diff = urb_size -

sound/usb/usx2y/usb_stream.c

560

if (diff < max_diff)

sound/usb/usx2y/usb_stream.c

561

max_diff = diff;

sound/usb/usx2y/usbusx2y.c

183

int i, j, n, diff, send;

sound/usb/usx2y/usbusx2y.c

193

diff = -1;

sound/usb/usx2y/usbusx2y.c

195

diff = 0;

sound/usb/usx2y/usbusx2y.c

201

if (diff < 0)

sound/usb/usx2y/usbusx2y.c

202

diff = i;

sound/usb/usx2y/usbusx2y.c

207

if (diff >= 0) {

sound/usb/usx2y/usbusx2y.c

212

us428ctls->ctl_snapshot_differs_at[n] = diff;

tools/bpf/bpftool/skeleton/profiler.bpf.c

79

struct bpf_perf_event_value___local *before, diff;

tools/bpf/bpftool/skeleton/profiler.bpf.c

86

diff.counter = after->counter - before->counter;

tools/bpf/bpftool/skeleton/profiler.bpf.c

87

diff.enabled = after->enabled - before->enabled;

tools/bpf/bpftool/skeleton/profiler.bpf.c

88

diff.running = after->running - before->running;

tools/bpf/bpftool/skeleton/profiler.bpf.c

92

accum->counter += diff.counter;

tools/bpf/bpftool/skeleton/profiler.bpf.c

93

accum->enabled += diff.enabled;

tools/bpf/bpftool/skeleton/profiler.bpf.c

94

accum->running += diff.running;

tools/iio/iio_event_monitor.c

294

bool diff = IIO_EVENT_CODE_EXTRACT_DIFF(event->id);

tools/iio/iio_event_monitor.c

311

if (diff && chan2 >= 0)

tools/include/nolibc/string.h

126

int diff;

tools/include/nolibc/string.h

128

while (!(diff = (unsigned char)*a++ - (c = (unsigned char)*b++)) && c)

tools/include/nolibc/string.h

130

return diff;

tools/include/nolibc/string.h

277

int diff = 0;

tools/include/nolibc/string.h

280

!(diff = (unsigned char)*a++ - (c = (unsigned char)*b++)) && c)

tools/include/nolibc/string.h

283

return diff;

tools/lib/bpf/btf_relocate.c

113

int diff = cmp_btf_name_size(key, val);

tools/lib/bpf/btf_relocate.c

115

if (diff == 0)

tools/lib/bpf/btf_relocate.c

118

if (diff <= 0)

tools/lib/perf/mmap.c

215

int diff = end - *startp;

tools/lib/perf/mmap.c

217

if (diff >= (int)sizeof(event->header)) {

tools/lib/perf/mmap.c

223

if (size < sizeof(event->header) || diff < (int)size)

tools/net/ynl/ynltool/qstats.c

347

double diff = values[i] - *mean;

tools/net/ynl/ynltool/qstats.c

349

variance += diff * diff;

tools/perf/bench/breakpoint.c

118

struct timeval start, stop, diff;

tools/perf/bench/breakpoint.c

148

timersub(&stop, &start, &diff);

tools/perf/bench/breakpoint.c

158

(long)diff.tv_sec, (long)(diff.tv_usec / USEC_PER_MSEC));

tools/perf/bench/breakpoint.c

159

result_usec = diff.tv_sec * USEC_PER_SEC + diff.tv_usec;

tools/perf/bench/breakpoint.c

167

printf("%lu.%03lu\n", (long)diff.tv_sec, (long)(diff.tv_usec / USEC_PER_MSEC));

tools/perf/bench/breakpoint.c

204

struct timeval start, stop, diff;

tools/perf/bench/breakpoint.c

238

timersub(&stop, &start, &diff);

tools/perf/bench/breakpoint.c

250

(long)diff.tv_sec, (long)(diff.tv_usec / USEC_PER_MSEC));

tools/perf/bench/breakpoint.c

251

result_usec = diff.tv_sec * USEC_PER_SEC + diff.tv_usec;

tools/perf/bench/breakpoint.c

255

printf("%lu.%03lu\n", (long)diff.tv_sec, (long)(diff.tv_usec / USEC_PER_MSEC));

tools/perf/bench/evlist-open-close.c

138

struct timeval start, end, diff;

tools/perf/bench/evlist-open-close.c

170

timersub(&end, &start, &diff);

tools/perf/bench/evlist-open-close.c

171

runtime_us = timeval2usec(&diff);

tools/perf/bench/find-bit-bench.c

102

timersub(&end, &start, &diff);

tools/perf/bench/find-bit-bench.c

103

runtime_us = diff.tv_sec * USEC_PER_SEC + diff.tv_usec;

tools/perf/bench/find-bit-bench.c

58

struct timeval start, end, diff;

tools/perf/bench/find-bit-bench.c

86

timersub(&end, &start, &diff);

tools/perf/bench/find-bit-bench.c

87

runtime_us = diff.tv_sec * USEC_PER_SEC + diff.tv_usec;

tools/perf/bench/inject-buildid.c

409

struct timeval start, end, diff;

tools/perf/bench/inject-buildid.c

426

timersub(&end, &start, &diff);

tools/perf/bench/inject-buildid.c

427

runtime_us = diff.tv_sec * USEC_PER_SEC + diff.tv_usec;

tools/perf/bench/kallsyms-parse.c

37

struct timeval start, end, diff;

tools/perf/bench/kallsyms-parse.c

54

timersub(&end, &start, &diff);

tools/perf/bench/kallsyms-parse.c

55

runtime_us = diff.tv_sec * USEC_PER_SEC + diff.tv_usec;

tools/perf/bench/mem-functions.c

501

union bench_clock start, end, diff;

tools/perf/bench/mem-functions.c

516

diff = clock_diff(&start, &end);

tools/perf/bench/mem-functions.c

517

clock_accum(accum, &diff);

tools/perf/bench/numa.c

1209

struct timeval start0, start, stop, diff;

tools/perf/bench/numa.c

1314

timersub(&stop, &start0, &diff);

tools/perf/bench/numa.c

1315

if ((u32)diff.tv_sec >= g->p.nr_secs) {

tools/perf/bench/numa.c

1358

timersub(&stop, &start, &diff);

tools/perf/bench/numa.c

1359

runtime_ns_max = diff.tv_sec * NSEC_PER_SEC;

tools/perf/bench/numa.c

1360

runtime_ns_max += diff.tv_usec * NSEC_PER_USEC;

tools/perf/bench/numa.c

1371

timersub(&stop, &start0, &diff);

tools/perf/bench/numa.c

1372

runtime_ns_max = diff.tv_sec * NSEC_PER_SEC;

tools/perf/bench/numa.c

1373

runtime_ns_max += diff.tv_usec * NSEC_PER_USEC;

tools/perf/bench/numa.c

1379

timersub(&stop, &start0, &diff);

tools/perf/bench/numa.c

1380

td->runtime_ns = diff.tv_sec * NSEC_PER_SEC;

tools/perf/bench/numa.c

1381

td->runtime_ns += diff.tv_usec * NSEC_PER_USEC;

tools/perf/bench/numa.c

1618

struct timeval start, stop, diff;

tools/perf/bench/numa.c

1682

timersub(&stop, &start, &diff);

tools/perf/bench/numa.c

1684

startup_sec = diff.tv_sec * NSEC_PER_SEC;

tools/perf/bench/numa.c

1685

startup_sec += diff.tv_usec * NSEC_PER_USEC;

tools/perf/bench/numa.c

1722

timersub(&stop, &start, &diff);

tools/perf/bench/numa.c

1729

runtime_sec_max = diff.tv_sec * NSEC_PER_SEC;

tools/perf/bench/numa.c

1730

runtime_sec_max += diff.tv_usec * NSEC_PER_USEC;

tools/perf/bench/pmu-scan.c

132

struct timeval start, end, diff;

tools/perf/bench/pmu-scan.c

156

timersub(&end, &start, &diff);

tools/perf/bench/pmu-scan.c

157

runtime_us = diff.tv_sec * USEC_PER_SEC + diff.tv_usec;

tools/perf/bench/sched-messaging.c

295

struct timeval start, stop, diff;

tools/perf/bench/sched-messaging.c

337

timersub(&stop, &start, &diff);

tools/perf/bench/sched-messaging.c

347

(unsigned long) diff.tv_sec,

tools/perf/bench/sched-messaging.c

348

(unsigned long) (diff.tv_usec / USEC_PER_MSEC));

tools/perf/bench/sched-messaging.c

351

printf("%lu.%03lu\n", (unsigned long) diff.tv_sec,

tools/perf/bench/sched-messaging.c

352

(unsigned long) (diff.tv_usec / USEC_PER_MSEC));

tools/perf/bench/sched-pipe.c

221

struct timeval start, stop, diff;

tools/perf/bench/sched-pipe.c

288

timersub(&stop, &start, &diff);

tools/perf/bench/sched-pipe.c

301

result_usec = diff.tv_sec * USEC_PER_SEC;

tools/perf/bench/sched-pipe.c

302

result_usec += diff.tv_usec;

tools/perf/bench/sched-pipe.c

305

(unsigned long) diff.tv_sec,

tools/perf/bench/sched-pipe.c

306

(unsigned long) (diff.tv_usec / USEC_PER_MSEC));

tools/perf/bench/sched-pipe.c

317

(unsigned long) diff.tv_sec,

tools/perf/bench/sched-pipe.c

318

(unsigned long) (diff.tv_usec / USEC_PER_MSEC));

tools/perf/bench/sched-seccomp-notify.c

143

timersub(&stop, &start, &diff);

tools/perf/bench/sched-seccomp-notify.c

150

result_usec = diff.tv_sec * USEC_PER_SEC;

tools/perf/bench/sched-seccomp-notify.c

151

result_usec += diff.tv_usec;

tools/perf/bench/sched-seccomp-notify.c

154

(unsigned long) diff.tv_sec,

tools/perf/bench/sched-seccomp-notify.c

155

(unsigned long) (diff.tv_usec / USEC_PER_MSEC));

tools/perf/bench/sched-seccomp-notify.c

166

(unsigned long) diff.tv_sec,

tools/perf/bench/sched-seccomp-notify.c

167

(unsigned long) (diff.tv_usec / USEC_PER_MSEC));

tools/perf/bench/sched-seccomp-notify.c

97

struct timeval start, stop, diff;

tools/perf/bench/synthesize.c

159

struct timeval start, end, diff;

tools/perf/bench/synthesize.c

192

timersub(&end, &start, &diff);

tools/perf/bench/synthesize.c

193

runtime_us = diff.tv_sec * USEC_PER_SEC + diff.tv_usec;

tools/perf/bench/synthesize.c

67

struct timeval start, end, diff;

tools/perf/bench/synthesize.c

90

timersub(&end, &start, &diff);

tools/perf/bench/synthesize.c

91

runtime_us = diff.tv_sec * USEC_PER_SEC + diff.tv_usec;

tools/perf/bench/syscall.c

117

timersub(&stop, &start, &diff);

tools/perf/bench/syscall.c

140

result_usec = diff.tv_sec * 1000000;

tools/perf/bench/syscall.c

141

result_usec += diff.tv_usec;

tools/perf/bench/syscall.c

144

(unsigned long) diff.tv_sec,

tools/perf/bench/syscall.c

145

(unsigned long) (diff.tv_usec/1000));

tools/perf/bench/syscall.c

156

(unsigned long) diff.tv_sec,

tools/perf/bench/syscall.c

157

(unsigned long) (diff.tv_usec / 1000));

tools/perf/bench/syscall.c

77

struct timeval start, stop, diff;

tools/perf/bench/uprobe.c

112

static int bench_uprobe_format__default_fprintf(const char *name, const char *unit, u64 diff, FILE *fp)

tools/perf/bench/uprobe.c

115

s64 diff_to_baseline = diff - baseline,

tools/perf/bench/uprobe.c

116

diff_to_previous = diff - previous;

tools/perf/bench/uprobe.c

119

printed += fprintf(fp, " %14s: %'" PRIu64 " %ss", "Total time", diff, unit);

tools/perf/bench/uprobe.c

128

printed += fprintf(fp, "\n\n %'.3f %ss/op", (double)diff / (double)loops, unit);

tools/perf/bench/uprobe.c

136

baseline = diff;

tools/perf/bench/uprobe.c

141

previous = diff;

tools/perf/bench/uprobe.c

150

u64 diff;

tools/perf/bench/uprobe.c

166

diff = end.tv_sec * NSEC_PER_SEC + end.tv_nsec - (start.tv_sec * NSEC_PER_SEC + start.tv_nsec);

tools/perf/bench/uprobe.c

167

diff /= NSEC_PER_USEC;

tools/perf/bench/uprobe.c

171

bench_uprobe_format__default_fprintf(name, unit, diff, stdout);

tools/perf/bench/uprobe.c

175

printf("%" PRIu64 "\n", diff);

tools/perf/builtin-diff.c

1369

start_line, end_line, block_he->diff.cycles);

tools/perf/builtin-diff.c

1372

bi->start, bi->end, block_he->diff.cycles);

tools/perf/builtin-diff.c

1388

double diff;

tools/perf/builtin-diff.c

1406

if (pair->diff.computed)

tools/perf/builtin-diff.c

1407

diff = pair->diff.period_ratio_delta;

tools/perf/builtin-diff.c

1409

diff = compute_delta(he, pair);

tools/perf/builtin-diff.c

1413

pfmt, diff);

tools/perf/builtin-diff.c

1417

if (pair->diff.computed)

tools/perf/builtin-diff.c

1418

diff = pair->diff.period_ratio;

tools/perf/builtin-diff.c

1420

diff = compute_ratio(he, pair);

tools/perf/builtin-diff.c

1424

pfmt, diff);

tools/perf/builtin-diff.c

1428

if (pair->diff.computed)

tools/perf/builtin-diff.c

1429

wdiff = pair->diff.wdiff;

tools/perf/builtin-diff.c

1529

ret = print_cycles_spark(spark, sizeof(spark), block_he->diff.svals,

tools/perf/builtin-diff.c

1530

block_he->diff.stats.n);

tools/perf/builtin-diff.c

1532

r = rel_stddev_stats(stddev_stats(&block_he->diff.stats),

tools/perf/builtin-diff.c

1533

avg_stats(&block_he->diff.stats));

tools/perf/builtin-diff.c

1575

double diff;

tools/perf/builtin-diff.c

1582

if (pair->diff.computed)

tools/perf/builtin-diff.c

1583

diff = pair->diff.period_ratio_delta;

tools/perf/builtin-diff.c

1585

diff = compute_delta(he, pair);

tools/perf/builtin-diff.c

1587

scnprintf(buf, size, "%+4.2F%%", diff);

tools/perf/builtin-diff.c

1597

if (pair->diff.computed)

tools/perf/builtin-diff.c

1598

ratio = pair->diff.period_ratio;

tools/perf/builtin-diff.c

1613

if (pair->diff.computed)

tools/perf/builtin-diff.c

1614

wdiff = pair->diff.wdiff;

tools/perf/builtin-diff.c

283

pair->diff.period_ratio_delta = new_percent - old_percent;

tools/perf/builtin-diff.c

284

pair->diff.computed = true;

tools/perf/builtin-diff.c

285

return pair->diff.period_ratio_delta;

tools/perf/builtin-diff.c

293

pair->diff.computed = true;

tools/perf/builtin-diff.c

294

pair->diff.period_ratio = new_period / old_period;

tools/perf/builtin-diff.c

295

return pair->diff.period_ratio;

tools/perf/builtin-diff.c

303

pair->diff.computed = true;

tools/perf/builtin-diff.c

304

pair->diff.wdiff = new_period * compute_wdiff_w2 -

tools/perf/builtin-diff.c

307

return pair->diff.wdiff;

tools/perf/builtin-diff.c

558

l = llabs(left->diff.cycles);

tools/perf/builtin-diff.c

559

r = llabs(right->diff.cycles);

tools/perf/builtin-diff.c

622

pair->diff.computed = true;

tools/perf/builtin-diff.c

624

pair->diff.cycles =

tools/perf/builtin-diff.c

631

init_stats(&pair->diff.stats);

tools/perf/builtin-diff.c

632

init_spark_values(pair->diff.svals, NUM_SPARKS);

tools/perf/builtin-diff.c

643

update_spark_value(pair->diff.svals, NUM_SPARKS,

tools/perf/builtin-diff.c

644

&pair->diff.stats, val);

tools/perf/builtin-diff.c

645

update_stats(&pair->diff.stats, val);

tools/perf/builtin-diff.c

751

double l = left->diff.period_ratio_delta;

tools/perf/builtin-diff.c

752

double r = right->diff.period_ratio_delta;

tools/perf/builtin-diff.c

758

double l = fabs(left->diff.period_ratio_delta);

tools/perf/builtin-diff.c

759

double r = fabs(right->diff.period_ratio_delta);

tools/perf/builtin-diff.c

765

double l = left->diff.period_ratio;

tools/perf/builtin-diff.c

766

double r = right->diff.period_ratio;

tools/perf/builtin-diff.c

772

s64 l = left->diff.wdiff;

tools/perf/builtin-diff.c

773

s64 r = right->diff.wdiff;

tools/perf/tests/switch-tracking.c

27

struct timeval start, now, diff, maxtime;

tools/perf/tests/switch-tracking.c

47

timersub(&now, &start, &diff);

tools/perf/tests/switch-tracking.c

48

if (timercmp(&diff, &maxtime, > /* For checkpatch */))

tools/perf/ui/browser.c

772

unsigned int row, int diff, bool arrow_down)

tools/perf/ui/browser.c

776

if (diff <= 0)

tools/perf/ui/browser.c

782

if (row + diff <= browser->top_idx)

tools/perf/ui/browser.c

785

end_row = row + diff - browser->top_idx;

tools/perf/ui/browser.h

54

unsigned int row, int diff, bool arrow_down);

tools/perf/ui/browsers/annotate.c

159

int diff = 1;

tools/perf/ui/browsers/annotate.c

164

diff++;

tools/perf/ui/browsers/annotate.c

179

return diff;

tools/perf/ui/browsers/annotate.c

195

int diff = 0;

tools/perf/ui/browsers/annotate.c

246

diff = is_fused(ab, cursor);

tools/perf/ui/browsers/annotate.c

247

if (diff > 0) {

tools/perf/ui/browsers/annotate.c

250

from - diff, diff, to > from);

tools/perf/util/bpf_skel/bpf_prog_profiler.bpf.c

55

struct bpf_perf_event_value *before, diff;

tools/perf/util/bpf_skel/bpf_prog_profiler.bpf.c

63

diff.counter = after->counter - before->counter;

tools/perf/util/bpf_skel/bpf_prog_profiler.bpf.c

64

diff.enabled = after->enabled - before->enabled;

tools/perf/util/bpf_skel/bpf_prog_profiler.bpf.c

65

diff.running = after->running - before->running;

tools/perf/util/bpf_skel/bpf_prog_profiler.bpf.c

69

accum->counter += diff.counter;

tools/perf/util/bpf_skel/bpf_prog_profiler.bpf.c

70

accum->enabled += diff.enabled;

tools/perf/util/bpf_skel/bpf_prog_profiler.bpf.c

71

accum->running += diff.running;

tools/perf/util/hist.h

282

struct hist_entry_diff diff;

tools/perf/util/metricgroup.c

1016

int diff = strcmp(right->default_metricgroup_name, left->default_metricgroup_name);

tools/perf/util/metricgroup.c

1018

if (diff)

tools/perf/util/metricgroup.c

1019

return diff;

tools/perf/util/powerpc-vpadtl.c

138

unsigned long long diff;

tools/perf/util/powerpc-vpadtl.c

149

diff = be64_to_cpu(record->timebase) - boot_tb;

tools/perf/util/powerpc-vpadtl.c

150

div = diff / boot_freq;

tools/perf/util/probe-finder.c

644

int diff;

tools/perf/util/probe-finder.c

671

if (lno < fsp->line && fsp->diff > fsp->line - lno) {

tools/perf/util/probe-finder.c

673

fsp->diff = fsp->line - lno;

tools/perf/util/probe-finder.c

698

.diff = INT_MAX,

tools/power/cpupower/debug/kernel/cpufreq-test_tsc.c

56

u32 now, then, diff;

tools/power/cpupower/debug/kernel/cpufreq-test_tsc.c

90

diff = (now - then) & 0xFFFFFF;

tools/power/cpupower/debug/kernel/cpufreq-test_tsc.c

92

printk(KERN_DEBUG "t1: %08u t2: %08u diff_pmtmr: %08u diff_tsc: %016llu\n", then, now, diff, diff_tsc);

tools/power/cpupower/utils/idle_monitor/amd_fam14h_idle.c

210

unsigned long diff;

tools/power/cpupower/utils/idle_monitor/amd_fam14h_idle.c

215

diff = current_count[id][cpu] - previous_count[id][cpu];

tools/power/cpupower/utils/idle_monitor/amd_fam14h_idle.c

220

*percent = 100.0 * diff / timediff / 12.5;

tools/power/cpupower/utils/idle_monitor/amd_fam14h_idle.c

223

timediff, diff * 10 / 125, *percent);

tools/testing/selftests/alsa/pcm-test.c

69

timestamp_t now, diff;

tools/testing/selftests/alsa/pcm-test.c

72

diff.tv_sec = now.tv_sec - tstamp->tv_sec - 1;

tools/testing/selftests/alsa/pcm-test.c

73

diff.tv_nsec = (now.tv_nsec + 1000000000L) - tstamp->tv_nsec;

tools/testing/selftests/alsa/pcm-test.c

75

diff.tv_sec = now.tv_sec - tstamp->tv_sec;

tools/testing/selftests/alsa/pcm-test.c

76

diff.tv_nsec = now.tv_nsec - tstamp->tv_nsec;

tools/testing/selftests/alsa/pcm-test.c

78

return (diff.tv_sec * 1000) + ((diff.tv_nsec + 500000L) / 1000000L);

tools/testing/selftests/bpf/prog_tests/xdp_bonding.c

289

int diff = abs(veth1_rx - veth2_rx);

tools/testing/selftests/bpf/prog_tests/xdp_bonding.c

295

ASSERT_GE(diff, NPACKETS,

tools/testing/selftests/bpf/prog_tests/xdp_bonding.c

300

ASSERT_LT(diff, NPACKETS/2,

tools/testing/selftests/bpf/prog_tests/xdp_bonding.c

312

int diff = abs(veth1_rx - veth2_rx);

tools/testing/selftests/bpf/prog_tests/xdp_bonding.c

314

ASSERT_GE(diff, NPACKETS,

tools/testing/selftests/cgroup/lib/include/cgroup_util.h

36

long diff = labs(a - b);

tools/testing/selftests/cgroup/lib/include/cgroup_util.h

38

double actual_err = (a + b) ? (100.0 * diff / (a + b)) : 0.0;

tools/testing/selftests/cgroup/lib/include/cgroup_util.h

39

int close = diff <= limit;

tools/testing/selftests/cgroup/lib/include/cgroup_util.h

45

a, b, diff, limit, err, actual_err);

tools/testing/selftests/kvm/s390/memop.c

184

int diff = memcmp(desc->old_value, desc->old, desc->size);

tools/testing/selftests/kvm/s390/memop.c

185

*desc->cmpxchg_success = !diff;

tools/testing/selftests/net/tcp_ao/lib/sock.c

78

test_cnt diff;

tools/testing/selftests/net/tcp_ao/lib/sock.c

83

diff = test_cmp_counters(c, &c2);

tools/testing/selftests/net/tcp_ao/lib/sock.c

85

return (diff & condition) == condition;

tools/testing/selftests/resctrl/resctrl_val.c

446

unsigned long diff = fabs(bw_imc - bw_resc);

tools/testing/selftests/resctrl/resctrl_val.c

451

printf("Mem_BW_resc: %lu \t Difference: %lu\n", bw_resc, diff);

tools/testing/selftests/resctrl/resctrl_val.c

460

(int)bm_pid, bw_imc, bw_resc, diff) <= 0) {

tools/testing/selftests/timers/adjtick.c

68

long long diff = 0, tmp;

tools/testing/selftests/timers/adjtick.c

83

if (diff == 0 || newdiff < diff) {

tools/testing/selftests/timers/adjtick.c

84

diff = newdiff;

tools/testing/selftests/timers/posix_timers.c

450

int64_t diff;

tools/testing/selftests/timers/posix_timers.c

452

diff = NSEC_PER_SEC * (int64_t)((int) t1.tv_sec - (int) t2.tv_sec);

tools/testing/selftests/timers/posix_timers.c

453

diff += ((int) t1.tv_nsec - (int) t2.tv_nsec);

tools/testing/selftests/timers/posix_timers.c

454

return diff;

tools/testing/selftests/timers/posix_timers.c

87

long long diff;

tools/testing/selftests/timers/posix_timers.c

89

diff = end.tv_usec - start.tv_usec;

tools/testing/selftests/timers/posix_timers.c

90

diff += (end.tv_sec - start.tv_sec) * USEC_PER_SEC;

tools/testing/selftests/timers/posix_timers.c

92

if (llabs(diff - DELAY * USEC_PER_SEC) > USEC_PER_SEC / 2) {

tools/testing/selftests/timers/posix_timers.c

93

printf("Diff too high: %lld..", diff);

tools/testing/selftests/timers/raw_skew.c

70

long long diff = 0, tmp;

tools/testing/selftests/timers/raw_skew.c

81

if (diff == 0 || newdiff < diff) {

tools/testing/selftests/timers/raw_skew.c

82

diff = newdiff;

tools/testing/selftests/timers/rtcpie.c

111

timersub(&end, &start, &diff);

tools/testing/selftests/timers/rtcpie.c

112

if (diff.tv_sec > 0 ||

tools/testing/selftests/timers/rtcpie.c

113

diff.tv_usec > ((1000000L / tmp) * 1.10)) {

tools/testing/selftests/timers/rtcpie.c

115

diff.tv_sec, diff.tv_usec,

tools/testing/selftests/timers/rtcpie.c

35

struct timeval start, end, diff;

tools/testing/selftests/vDSO/vdso_test_getrandom.c

178

struct timespec start, end, diff;

tools/testing/selftests/vDSO/vdso_test_getrandom.c

183

timespecsub(&end, &start, &diff);

tools/testing/selftests/vDSO/vdso_test_getrandom.c

184

printf(" vdso: %u times in %lu.%09lu seconds\n", TRIALS, diff.tv_sec, diff.tv_nsec);

tools/testing/selftests/vDSO/vdso_test_getrandom.c

189

timespecsub(&end, &start, &diff);

tools/testing/selftests/vDSO/vdso_test_getrandom.c

190

printf(" libc: %u times in %lu.%09lu seconds\n", TRIALS, diff.tv_sec, diff.tv_nsec);

tools/testing/selftests/vDSO/vdso_test_getrandom.c

195

timespecsub(&end, &start, &diff);

tools/testing/selftests/vDSO/vdso_test_getrandom.c

196

printf("syscall: %u times in %lu.%09lu seconds\n", TRIALS, diff.tv_sec, diff.tv_nsec);

tools/testing/selftests/vDSO/vdso_test_getrandom.c

201

struct timespec start, end, diff;

tools/testing/selftests/vDSO/vdso_test_getrandom.c

210

timespecsub(&end, &start, &diff);

tools/testing/selftests/vDSO/vdso_test_getrandom.c

211

printf(" vdso: %u x %u times in %lu.%09lu seconds\n", TRIALS, THREADS, diff.tv_sec, diff.tv_nsec);

tools/testing/selftests/vDSO/vdso_test_getrandom.c

219

timespecsub(&end, &start, &diff);

tools/testing/selftests/vDSO/vdso_test_getrandom.c

220

printf(" libc: %u x %u times in %lu.%09lu seconds\n", TRIALS, THREADS, diff.tv_sec, diff.tv_nsec);

tools/testing/selftests/vDSO/vdso_test_getrandom.c

228

timespecsub(&end, &start, &diff);

tools/testing/selftests/vDSO/vdso_test_getrandom.c

229

printf(" syscall: %u x %u times in %lu.%09lu seconds\n", TRIALS, THREADS, diff.tv_sec, diff.tv_nsec);

tools/tracing/latency/latency-collector.c

764

int diff = req->ticket - req->ticket_completed_ref;

tools/tracing/latency/latency-collector.c

768

diff--;

tools/tracing/latency/latency-collector.c

770

if (unlikely(diff < 0)) {

tools/tracing/latency/latency-collector.c

776

if (diff >= (sleeptable.size - 1)) {

tools/tracing/latency/latency-collector.c

781

rval = sleeptable.table[diff];