BITS_PER_BYTE

arch/arm/mm/dma-mapping.c

1524

mapping->bits = BITS_PER_BYTE * bitmap_size;

arch/arm64/kvm/vgic/vgic-its.c

402

byte_offset = intid / BITS_PER_BYTE;

arch/arm64/kvm/vgic/vgic-its.c

403

bit_nr = intid % BITS_PER_BYTE;

arch/arm64/kvm/vgic/vgic-v3.c

529

byte_offset = irq->intid / BITS_PER_BYTE;

arch/arm64/kvm/vgic/vgic-v3.c

530

bit_nr = irq->intid % BITS_PER_BYTE;

arch/arm64/kvm/vgic/vgic-v3.c

620

byte_offset = irq->intid / BITS_PER_BYTE;

arch/arm64/kvm/vgic/vgic-v3.c

621

bit_nr = irq->intid % BITS_PER_BYTE;

arch/arm64/kvm/vgic/vgic-v4.c

219

int mask = BIT(irq->intid % BITS_PER_BYTE);

arch/arm64/kvm/vgic/vgic-v4.c

224

ptr = va + irq->intid / BITS_PER_BYTE;

arch/loongarch/include/asm/cmpxchg.h

149

mask = GENMASK((size * BITS_PER_BYTE) - 1, 0);

arch/loongarch/include/asm/cmpxchg.h

159

shift *= BITS_PER_BYTE;

arch/loongarch/include/asm/cmpxchg.h

50

mask = GENMASK((size * BITS_PER_BYTE) - 1, 0);

arch/loongarch/include/asm/cmpxchg.h

59

shift *= BITS_PER_BYTE;

arch/mips/kernel/cmpxchg.c

20

mask = GENMASK((size * BITS_PER_BYTE) - 1, 0);

arch/mips/kernel/cmpxchg.c

31

shift *= BITS_PER_BYTE;

arch/mips/kernel/cmpxchg.c

61

mask = GENMASK((size * BITS_PER_BYTE) - 1, 0);

arch/mips/kernel/cmpxchg.c

73

shift *= BITS_PER_BYTE;

arch/mips/net/bpf_jit_comp.c

131

for (reg = 0; reg < BITS_PER_BYTE * sizeof(mask); reg++)

arch/mips/net/bpf_jit_comp.c

154

for (reg = 0; reg < BITS_PER_BYTE * sizeof(mask); reg++)

arch/openrisc/include/asm/cmpxchg.h

101

u32 bitmask = ((0x1 << size * BITS_PER_BYTE) - 1) << bitoff;

arch/openrisc/include/asm/cmpxchg.h

65

int bitoff = (sizeof(u32) - size - off) * BITS_PER_BYTE;

arch/openrisc/include/asm/cmpxchg.h

67

int bitoff = off * BITS_PER_BYTE;

arch/openrisc/include/asm/cmpxchg.h

69

u32 bitmask = ((0x1 << size * BITS_PER_BYTE) - 1) << bitoff;

arch/openrisc/include/asm/cmpxchg.h

97

int bitoff = (sizeof(u32) - size - off) * BITS_PER_BYTE;

arch/openrisc/include/asm/cmpxchg.h

99

int bitoff = off * BITS_PER_BYTE;

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

668

#define LOW_SLICE_ARRAY_SZ (BITS_PER_LONG / BITS_PER_BYTE)

arch/powerpc/include/asm/cmpxchg.h

11

#define BITOFF_CAL(size, off) ((sizeof(u32) - size - off) * BITS_PER_BYTE)

arch/powerpc/include/asm/cmpxchg.h

13

#define BITOFF_CAL(size, off) (off * BITS_PER_BYTE)

arch/powerpc/include/asm/paca.h

155

unsigned char mm_ctx_low_slices_psize[BITS_PER_LONG / BITS_PER_BYTE];

arch/powerpc/kvm/book3s.c

413

BITS_PER_BYTE * sizeof(*pending),

arch/powerpc/kvm/booke.c

701

BITS_PER_BYTE * sizeof(*pending),

arch/powerpc/mm/book3s64/pkeys.c

128

!= (sizeof(u64) * BITS_PER_BYTE));

arch/riscv/include/asm/cmpxchg.h

151

ulong __s = ((ulong)(p) & (0x4 - sizeof(*p))) * BITS_PER_BYTE; \

arch/riscv/include/asm/cmpxchg.h

152

ulong __mask = GENMASK(((sizeof(*p)) * BITS_PER_BYTE) - 1, 0) \

arch/riscv/include/asm/cmpxchg.h

33

ulong __s = ((ulong)(p) & (0x4 - sizeof(*p))) * BITS_PER_BYTE; \

arch/riscv/include/asm/cmpxchg.h

34

ulong __mask = GENMASK(((sizeof(*p)) * BITS_PER_BYTE) - 1, 0) \

arch/riscv/include/asm/cmpxchg.h

384

__s = ((ulong)(ptr) & 0x3) * BITS_PER_BYTE;

arch/riscv/include/asm/cmpxchg.h

401

__s = ((ulong)(ptr) & 0x2) * BITS_PER_BYTE;

arch/riscv/kernel/sbi-ipi.c

60

virq = ipi_mux_create(BITS_PER_BYTE, sbi_send_ipi);

arch/riscv/kernel/sbi-ipi.c

78

riscv_ipi_set_virq_range(virq, BITS_PER_BYTE);

arch/s390/crypto/hmac_s390.c

90

*(u64 *)imbl = buflen_lo * BITS_PER_BYTE;

arch/s390/crypto/phmac_s390.c

397

*(u64 *)imbl = buflen_lo * BITS_PER_BYTE;

arch/s390/include/asm/bitops.h

62

addr += (nr ^ (BITS_PER_LONG - BITS_PER_BYTE)) / BITS_PER_BYTE;

arch/s390/include/asm/bitops.h

63

mask = 1UL << (nr & (BITS_PER_BYTE - 1));

arch/s390/include/asm/machine.h

30

#define MAX_MFEATURE_BIT (sizeof(machine_features) * BITS_PER_BYTE)

arch/s390/kvm/interrupt.c

177

#define IPM_BIT_OFFSET (offsetof(struct kvm_s390_gisa, ipm) * BITS_PER_BYTE)

arch/s390/kvm/interrupt.c

2728

WARN_ON_ONCE(bit > (PAGE_SIZE * BITS_PER_BYTE - 1));

arch/s390/kvm/vsie.c

200

BITS_PER_BYTE * sizeof(struct kvm_s390_apcb0));

arch/s390/kvm/vsie.c

227

BITS_PER_BYTE * sizeof(struct kvm_s390_apcb1));

arch/s390/kvm/vsie.c

374

bitmap_xor(b1, b1, b2, BITS_PER_BYTE * 56);

arch/s390/mm/extable.c

63

data <<= BITS_PER_BYTE * offset;

arch/s390/pci/pci_irq.c

575

zpci_ibv[cpu] = airq_iv_create(cache_line_size() * BITS_PER_BYTE,

arch/sh/include/asm/bitops-op32.h

14

#define BYTE_NUMBER(nr) ((nr ^ BITOP_LE_SWIZZLE) / BITS_PER_BYTE)

arch/sh/include/asm/bitops-op32.h

15

#define BYTE_OFFSET(nr) ((nr ^ BITOP_LE_SWIZZLE) % BITS_PER_BYTE)

arch/sh/include/asm/bitops-op32.h

17

#define BYTE_NUMBER(nr) ((nr) / BITS_PER_BYTE)

arch/sh/include/asm/bitops-op32.h

18

#define BYTE_OFFSET(nr) ((nr) % BITS_PER_BYTE)

arch/sh/include/asm/cmpxchg-xchg.h

23

int bitoff = (sizeof(u32) - size - off) * BITS_PER_BYTE;

arch/sh/include/asm/cmpxchg-xchg.h

25

int bitoff = off * BITS_PER_BYTE;

arch/sh/include/asm/cmpxchg-xchg.h

27

u32 bitmask = ((0x1 << size * BITS_PER_BYTE) - 1) << bitoff;

arch/x86/coco/tdx/tdx.c

696

u64 mask = GENMASK(BITS_PER_BYTE * size, 0);

arch/x86/coco/tdx/tdx.c

716

u64 mask = GENMASK(BITS_PER_BYTE * size, 0);

arch/x86/include/asm/processor.h

334

#define IO_BITMAP_BYTES (IO_BITMAP_BITS / BITS_PER_BYTE)

arch/x86/kernel/cpu/mce/internal.h

96

#define NUM_HISTORY_BITS (sizeof(u64) * BITS_PER_BYTE)

arch/x86/kvm/kvm_emulate.h

561

BUILD_BUG_ON(sizeof(ctxt->regs_dirty) * BITS_PER_BYTE < NR_EMULATOR_GPRS);

arch/x86/kvm/kvm_emulate.h

562

BUILD_BUG_ON(sizeof(ctxt->regs_valid) * BITS_PER_BYTE < NR_EMULATOR_GPRS);

arch/x86/kvm/pmu.c

1110

BUILD_BUG_ON(sizeof(pmu->global_ctrl) * BITS_PER_BYTE != X86_PMC_IDX_MAX);

arch/x86/kvm/svm/nested.c

1446

if (kvm_vcpu_read_guest(&svm->vcpu, base + bit_nr / BITS_PER_BYTE,

arch/x86/kvm/svm/nested.c

1450

mask = BIT(write) << (bit_nr & (BITS_PER_BYTE - 1));

arch/x86/kvm/svm/nested.c

254

offset = bit_nr / BITS_PER_BYTE / sizeof(nsvm_msrpm_merge_t);

arch/x86/kvm/svm/svm.h

656

#define SVM_MSRS_PER_BYTE (BITS_PER_BYTE / SVM_BITS_PER_MSR)

arch/x86/kvm/svm/svm.h

679

return range_nr * SVM_MSRPM_BYTES_PER_RANGE * BITS_PER_BYTE +

arch/x86/kvm/x86.c

12903

BUILD_BUG_ON(sizeof(xfeatures_mask) * BITS_PER_BYTE <= XFEATURE_MAX);

arch/xtensa/include/asm/cmpxchg.h

182

int bitoff = (sizeof(u32) - size - off) * BITS_PER_BYTE;

arch/xtensa/include/asm/cmpxchg.h

184

int bitoff = off * BITS_PER_BYTE;

arch/xtensa/include/asm/cmpxchg.h

186

u32 bitmask = ((0x1 << size * BITS_PER_BYTE) - 1) << bitoff;

block/blk-mq-debugfs.c

59

for (i = 0; i < sizeof(flags) * BITS_PER_BYTE; i++) {

crypto/asymmetric_keys/public_key.c

227

info->max_enc_size = len / BITS_PER_BYTE;

crypto/asymmetric_keys/public_key.c

228

info->max_dec_size = len / BITS_PER_BYTE;

crypto/asymmetric_keys/public_key.c

254

info->key_size = len * BITS_PER_BYTE;

crypto/ecdsa-p1363.c

25

BITS_PER_BYTE);

crypto/ecdsa-p1363.c

50

BITS_PER_BYTE);

crypto/ecdsa-x962.c

107

BITS_PER_BYTE);

crypto/ecdsa-x962.c

85

sizeof(u64) * BITS_PER_BYTE);

crypto/ecrdsa.c

252

return ctx->pub_key.ndigits * sizeof(u64) * BITS_PER_BYTE;

crypto/lrw.c

63

BITS_PER_BYTE

crypto/rsassa-pkcs1.c

304

return ctx->key_size * BITS_PER_BYTE;

crypto/sig.c

108

return DIV_ROUND_UP_POW2(crypto_sig_keysize(tfm), BITS_PER_BYTE);

drivers/accel/habanalabs/common/command_submission.c

196

for (i = BITS_PER_BYTE - 1 ; i >= 0 ; i--)

drivers/accel/habanalabs/common/state_dump.c

39

for (i = 0; i < sizeof(n) * BITS_PER_BYTE && buf_len; ++i, n <<= 1) {

drivers/accel/habanalabs/common/state_dump.c

43

bit = n & (1 << (sizeof(n) * BITS_PER_BYTE - 1));

drivers/base/regmap/regmap-i2c.c

354

(config->reg_bits + config->pad_bits) / BITS_PER_BYTE;

drivers/base/regmap/regmap-sdw-mbq.c

132

int shift = BITS_PER_BYTE;

drivers/base/regmap/regmap-sdw-mbq.c

151

shift += BITS_PER_BYTE;

drivers/base/regmap/regmap-sdw-mbq.c

196

if (config->val_bits > (sizeof(unsigned int) * BITS_PER_BYTE))

drivers/base/regmap/regmap-sdw-mbq.c

227

ctx->val_size = config->val_bits / BITS_PER_BYTE;

drivers/base/regmap/regmap-sdw-mbq.c

79

int shift = mbq_size * BITS_PER_BYTE;

drivers/base/regmap/regmap-sdw-mbq.c

83

shift -= BITS_PER_BYTE;

drivers/base/regmap/regmap-spi.c

125

reg_reserve_size = (config->reg_bits + config->pad_bits) / BITS_PER_BYTE;

drivers/block/rbd.c

1641

#define OBJS_PER_BYTE (BITS_PER_BYTE / BITS_PER_OBJ)

drivers/block/rbd.c

1843

BITS_PER_BYTE);

drivers/block/ublk_drv.c

4477

if (header->len * BITS_PER_BYTE < nr_cpu_ids)

drivers/bus/brcmstb_gisb.c

148

const char *master_names[sizeof(u32) * BITS_PER_BYTE];

drivers/char/hw_random/arm_smccc_trng.c

70

size_t bits = min_t(size_t, (max - copied) * BITS_PER_BYTE,

drivers/char/hw_random/arm_smccc_trng.c

78

bits / BITS_PER_BYTE);

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

174

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

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

194

u32 limit = BITS_PER_BYTE * sizeof(u32);

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

377

limit = BITS_PER_BYTE * sizeof(u32);

drivers/clk/clk-eyeq.c

157

shift = __fls(biggest) - (BITS_PER_BYTE * sizeof(unsigned int)) + 1;

drivers/clk/clk-stm32f4.c

1003

if (WARN_ON(secondary >= BITS_PER_BYTE * sizeof(table) ||

drivers/clk/stm32/reset-stm32.c

39

int bank = id / (reg_width * BITS_PER_BYTE);

drivers/clk/stm32/reset-stm32.c

40

int offset = id % (reg_width * BITS_PER_BYTE);

drivers/clocksource/timer-clint.c

246

rc = ipi_mux_create(BITS_PER_BYTE, clint_send_ipi);

drivers/clocksource/timer-clint.c

254

riscv_ipi_set_virq_range(rc, BITS_PER_BYTE);

drivers/crypto/allwinner/sun4i-ss/sun4i-ss-core.c

229

.seedsize = SS_SEED_LEN / BITS_PER_BYTE,

drivers/crypto/allwinner/sun4i-ss/sun4i-ss-prng.c

51

len = min_t(size_t, SS_DATA_LEN / BITS_PER_BYTE, todo);

drivers/crypto/ccp/ccp-ops.c

1019

op.u.aes.size = AES_BLOCK_SIZE * BITS_PER_BYTE - 1;

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

8

#define BITS_PER_REG(_n_) (sizeof(_n_) * BITS_PER_BYTE)

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

50

rp_mask_size = sizeof(sla_in->rp_mask) * BITS_PER_BYTE;

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

218

u16 bw_hw_2_bits = tl_data->bw_units_to_bytes * BITS_PER_BYTE;

drivers/crypto/marvell/octeontx/otx_cptpf_ucode.h

42

#define OTX_CPT_ENGS_BITMASK_LEN (OTX_CPT_MAX_ENGINES/(BITS_PER_BYTE * \

drivers/cxl/core/pci.c

665

bw /= BITS_PER_BYTE;

drivers/cxl/core/pci.c

708

speed /= BITS_PER_BYTE;

drivers/cxl/core/port.c

2425

bw /= BITS_PER_BYTE;

drivers/firmware/cirrus/cs_dsp.c

3443

for (i = 0; i < sizeof(ch->cache); i++, ch->cache <<= BITS_PER_BYTE)

drivers/firmware/cirrus/cs_dsp.c

3498

for (i = 0; i < sizeof(ch->cache); i++, ch->cache <<= BITS_PER_BYTE)

drivers/firmware/cirrus/cs_dsp.c

3507

result = ch->cache >> ((sizeof(ch->cache) * BITS_PER_BYTE) - nread);

drivers/firmware/efi/libstub/unaccepted_memory.c

161

if (end > bitmap_size * unit_size * BITS_PER_BYTE) {

drivers/firmware/efi/libstub/unaccepted_memory.c

164

phys_start = bitmap_size * unit_size * BITS_PER_BYTE +

drivers/firmware/efi/libstub/unaccepted_memory.c

169

end = bitmap_size * unit_size * BITS_PER_BYTE;

drivers/firmware/efi/libstub/unaccepted_memory.c

206

if (end > unaccepted_table->size * unit_size * BITS_PER_BYTE)

drivers/firmware/efi/libstub/unaccepted_memory.c

207

end = unaccepted_table->size * unit_size * BITS_PER_BYTE;

drivers/firmware/efi/libstub/unaccepted_memory.c

63

EFI_UNACCEPTED_UNIT_SIZE * BITS_PER_BYTE);

drivers/firmware/efi/sysfb_efi.c

244

si->lfb_linelength = bpp * si->lfb_width / BITS_PER_BYTE;

drivers/firmware/efi/unaccepted_memory.c

201

if (end > unaccepted->size * unit_size * BITS_PER_BYTE)

drivers/firmware/efi/unaccepted_memory.c

202

end = unaccepted->size * unit_size * BITS_PER_BYTE;

drivers/firmware/efi/unaccepted_memory.c

93

if (end > unaccepted->size * unit_size * BITS_PER_BYTE)

drivers/firmware/efi/unaccepted_memory.c

94

end = unaccepted->size * unit_size * BITS_PER_BYTE;

drivers/fpga/microchip-spi.c

182

(i * MPF_BITS_PER_COMPONENT_SIZE) / BITS_PER_BYTE;

drivers/fpga/microchip-spi.c

184

(i * MPF_BITS_PER_COMPONENT_SIZE) % BITS_PER_BYTE;

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

644

return (num_lanes_factor * gen_speed_mbits_factor)/BITS_PER_BYTE;

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

917

int per_link_bw = (speed * num_lanes * unit_scale)/BITS_PER_BYTE;

drivers/gpu/drm/arm/malidp_drv.c

335

/ BITS_PER_BYTE;

drivers/gpu/drm/arm/malidp_drv.c

340

if ((mode_cmd->width * bpp) != (mode_cmd->pitches[0] * BITS_PER_BYTE)) {

drivers/gpu/drm/arm/malidp_drv.c

343

(mode_cmd->pitches[0] * BITS_PER_BYTE),

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

2641

return 1 & (addr[bit / BITS_PER_BYTE] >> (bit % BITS_PER_BYTE));

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

53

#define BIT_OFFSET(x) (((x) - INT_STATUS_01) * BITS_PER_BYTE)

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

201

return DIV_ROUND_UP(ui, BITS_PER_BYTE);

drivers/gpu/drm/bridge/sil-sii8620.c

2007

return 1 & (addr[nr / BITS_PER_BYTE] >> (nr % BITS_PER_BYTE));

drivers/gpu/drm/drm_panic.c

116

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

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

1640

return sizeof(((struct intel_display_platforms *)0)->bitmap) * BITS_PER_BYTE;

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

583

BITS_PER_BYTE * (i % 4));

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

113

(mask >> (BITS_PER_BYTE * i)) & 0xff;

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

140

i = s * ss_stride * BITS_PER_BYTE + ss;

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

145

ss_mask[i / BITS_PER_BYTE] |= BIT(i % BITS_PER_BYTE);

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

48

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

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

99

u32 smp_entries_per_blk = smp->blk_size / (128 / BITS_PER_BYTE);

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

260

*sdm_din = (rem >> BITS_PER_BYTE) & MASK(GPCPLL_CFG2_SDM_DIN_WIDTH);

drivers/gpu/drm/stm/dw_mipi_dsi-stm.c

548

dsi_short_packet_size_px = DIV_ROUND_UP(4 * BITS_PER_BYTE, bpp);

drivers/gpu/drm/stm/dw_mipi_dsi-stm.c

578

lanes * BITS_PER_BYTE, bpp);

drivers/gpu/drm/xe/xe_pmu.c

169

return id < sizeof(pmu->supported_events) * BITS_PER_BYTE &&

drivers/hv/mshv_synic.c

218

bank_mask_size = sizeof(vpset->valid_bank_mask) * BITS_PER_BYTE;

drivers/hv/mshv_synic.c

222

int vp_bank_size = sizeof(*bank_contents) * BITS_PER_BYTE;

drivers/i2c/busses/i2c-brcmstb.c

364

word >>= BITS_PER_BYTE;

drivers/i2c/busses/i2c-brcmstb.c

367

(BITS_PER_BYTE * (data_regsz - 1));

drivers/i2c/busses/i2c-brcmstb.c

389

data >>= BITS_PER_BYTE;

drivers/i2c/busses/i2c-cadence.c

961

msg_timeout = msecs_to_jiffies((1000 * msg->len * BITS_PER_BYTE) / id->i2c_clk);

drivers/i2c/busses/i2c-cgbc.c

173

algo_data->read_maxtime_us = (BITS_PER_BYTE + 1) * CGBC_I2C_READ_MAX_LEN

drivers/i2c/busses/i2c-qcom-geni.c

1115

geni_se_config_packing(&gi2c->se, BITS_PER_BYTE,

drivers/iio/adc/ad4130.c

419

return ad4130_data_reg_size(st) * BITS_PER_BYTE;

drivers/iio/adc/meson_saradc.c

834

priv->temperature_sensor_adc_val |= upper_adc_val << BITS_PER_BYTE;

drivers/iio/adc/stm32-dfsdm-adc.c

346

for_each_set_bit(bit, &adc->smask, sizeof(adc->smask) * BITS_PER_BYTE) {

drivers/iio/adc/stm32-dfsdm-adc.c

365

for_each_set_bit(bit, &adc->smask, sizeof(adc->smask) * BITS_PER_BYTE) {

drivers/iio/adc/stm32-dfsdm-adc.c

487

sizeof(adc->smask) * BITS_PER_BYTE) {

drivers/iio/adc/stm32-dfsdm-adc.c

575

sizeof(adc->smask) * BITS_PER_BYTE) {

drivers/iio/imu/adis.c

320

diag_stat_bits = BITS_PER_BYTE * (adis->data->diag_stat_size ?

drivers/infiniband/hw/hfi1/chip.h

13

#define BITS_PER_REGISTER (BITS_PER_BYTE * sizeof(u64))

drivers/infiniband/hw/hfi1/fault.c

113

unsigned long bound = 1U << BITS_PER_BYTE;

drivers/infiniband/hw/hfi1/fault.c

136

BITS_PER_BYTE);

drivers/infiniband/hw/hfi1/fault.c

167

size_t bitsize = sizeof(fault->opcodes) * BITS_PER_BYTE;

drivers/infiniband/hw/hfi1/fault.c

228

sizeof(ibd->fault->opcodes) * BITS_PER_BYTE);

drivers/infiniband/hw/hfi1/fault.c

276

BITS_PER_BYTE)))

drivers/infiniband/hw/hfi1/fault.h

23

u64 n_rxfaults[(1U << BITS_PER_BYTE)];

drivers/infiniband/hw/hfi1/fault.h

24

u64 n_txfaults[(1U << BITS_PER_BYTE)];

drivers/infiniband/hw/hfi1/fault.h

29

unsigned long opcodes[(1U << BITS_PER_BYTE) / BITS_PER_LONG];

drivers/infiniband/hw/hfi1/tid_rdma.c

728

(sizeof(rcd->flow_mask) * BITS_PER_BYTE));

drivers/infiniband/hw/hns/hns_roce_mr.c

972

for_each_set_bit_from(pg_shift, &cap, sizeof(cap) * BITS_PER_BYTE) {

drivers/infiniband/hw/mlx5/qp.c

454

if (ucmd->rq_wqe_shift > BITS_PER_BYTE * sizeof(ucmd->rq_wqe_shift))

drivers/infiniband/sw/rdmavt/qp.c

1976

BUILD_BUG_ON(IB_QPT_MAX >= (sizeof(u32) * BITS_PER_BYTE));

drivers/input/keyboard/omap4-keypad.c

126

for_each_set_bit(bit, mask, keypad_data->rows * BITS_PER_BYTE) {

drivers/input/keyboard/omap4-keypad.c

127

row = bit / BITS_PER_BYTE;

drivers/input/keyboard/omap4-keypad.c

128

col = bit % BITS_PER_BYTE;

drivers/input/rmi4/rmi_driver.h

49

#define RMI_REG_DESC_PRESENSE_BITS (32 * BITS_PER_BYTE)

drivers/input/rmi4/rmi_driver.h

50

#define RMI_REG_DESC_SUBPACKET_BITS (37 * BITS_PER_BYTE)

drivers/iommu/iommufd/driver.c

202

BITS_PER_BYTE * sizeof_field(struct iommufd_sw_msi_maps, bitmap))

drivers/iommu/iommufd/iova_bitmap.c

11

#define BITS_PER_PAGE (PAGE_SIZE * BITS_PER_BYTE)

drivers/iommu/iommufd/iova_bitmap.c

420

mapped->pgshift) + mapped->pgoff * BITS_PER_BYTE;

drivers/iommu/iommufd/iova_bitmap.c

422

mapped->pgshift) + mapped->pgoff * BITS_PER_BYTE;

drivers/iommu/iommufd/selftest.c

1747

if (copy_from_user(tmp, uptr, DIV_ROUND_UP(max, BITS_PER_BYTE))) {

drivers/irqchip/irq-aclint-sswi.c

141

virq = ipi_mux_create(BITS_PER_BYTE, aclint_sswi_ipi_send);

drivers/irqchip/irq-aclint-sswi.c

155

riscv_ipi_set_virq_range(virq, BITS_PER_BYTE);

drivers/mailbox/mtk-cmdq-mailbox.c

719

DMA_BIT_MASK(sizeof(u32) * BITS_PER_BYTE + cmdq->pdata->shift));

drivers/md/bcache/super.c

72

max = sizeof(unsigned int) * BITS_PER_BYTE - 1;

drivers/md/dm-vdo/indexer/delta-index.c

101

#define COLLISION_BITS (COLLISION_BYTES * BITS_PER_BYTE)

drivers/md/dm-vdo/indexer/delta-index.c

1010

if ((save_info.bit_offset >= BITS_PER_BYTE) ||

drivers/md/dm-vdo/indexer/delta-index.c

1098

buffer[1] = delta_list->start % BITS_PER_BYTE;

drivers/md/dm-vdo/indexer/delta-index.c

1282

uds_prefetch_range(&delta_zone->memory[delta_list->start / BITS_PER_BYTE],

drivers/md/dm-vdo/indexer/delta-index.c

1283

delta_list->size / BITS_PER_BYTE, false);

drivers/md/dm-vdo/indexer/delta-index.c

1315

const u8 *addr = memory + delta_offset / BITS_PER_BYTE;

drivers/md/dm-vdo/indexer/delta-index.c

1316

int offset = delta_offset % BITS_PER_BYTE;

drivers/md/dm-vdo/indexer/delta-index.c

1325

key_bits = sizeof(u32) * BITS_PER_BYTE - offset;

drivers/md/dm-vdo/indexer/delta-index.c

1328

key_bits += sizeof(u32) * BITS_PER_BYTE;

drivers/md/dm-vdo/indexer/delta-index.c

1416

const u8 *addr = entry->delta_zone->memory + offset / BITS_PER_BYTE;

drivers/md/dm-vdo/indexer/delta-index.c

1418

int shift = offset % BITS_PER_BYTE;

drivers/md/dm-vdo/indexer/delta-index.c

1427

u8 *addr = entry->delta_zone->memory + offset / BITS_PER_BYTE;

drivers/md/dm-vdo/indexer/delta-index.c

1429

int shift = offset % BITS_PER_BYTE;

drivers/md/dm-vdo/indexer/delta-index.c

144

return delta_list->start / BITS_PER_BYTE;

drivers/md/dm-vdo/indexer/delta-index.c

149

unsigned int bit_offset = delta_list->start % BITS_PER_BYTE;

drivers/md/dm-vdo/indexer/delta-index.c

1950

bits_per_page = ((bytes_per_page - sizeof(struct delta_page_header)) * BITS_PER_BYTE);

drivers/md/dm-vdo/indexer/delta-index.c

230

list_bits = (u64) zone->size * BITS_PER_BYTE - GUARD_BITS;

drivers/md/dm-vdo/indexer/delta-index.c

233

memset(zone->memory + (list_bits / BITS_PER_BYTE), ~0,

drivers/md/dm-vdo/indexer/delta-index.c

406

const void *addr = memory + offset / BITS_PER_BYTE;

drivers/md/dm-vdo/indexer/delta-index.c

408

return (get_unaligned_le32(addr) >> (offset % BITS_PER_BYTE)) & ((1 << size) - 1);

drivers/md/dm-vdo/indexer/delta-index.c

414

void *addr = memory + offset / BITS_PER_BYTE;

drivers/md/dm-vdo/indexer/delta-index.c

415

int shift = offset % BITS_PER_BYTE;

drivers/md/dm-vdo/indexer/delta-index.c

426

return sizeof(struct delta_page_header) * BITS_PER_BYTE +

drivers/md/dm-vdo/indexer/delta-index.c

458

BITS_PER_BYTE / IMMUTABLE_HEADER_SIZE))

drivers/md/dm-vdo/indexer/delta-index.c

479

(memory_size - POST_FIELD_GUARD_BYTES) * BITS_PER_BYTE)

drivers/md/dm-vdo/indexer/delta-index.c

564

const void *addr = memory + offset / BITS_PER_BYTE;

drivers/md/dm-vdo/indexer/delta-index.c

566

return (get_unaligned_le64(addr) >> (offset % BITS_PER_BYTE)) & ((1UL << size) - 1);

drivers/md/dm-vdo/indexer/delta-index.c

572

void *addr = memory + offset / BITS_PER_BYTE;

drivers/md/dm-vdo/indexer/delta-index.c

573

u8 shift = offset % BITS_PER_BYTE;

drivers/md/dm-vdo/indexer/delta-index.c

585

u8 *addr = memory + offset / BITS_PER_BYTE;

drivers/md/dm-vdo/indexer/delta-index.c

586

u8 shift = offset % BITS_PER_BYTE;

drivers/md/dm-vdo/indexer/delta-index.c

587

u32 count = size + shift > BITS_PER_BYTE ? (u32) BITS_PER_BYTE - shift : size;

drivers/md/dm-vdo/indexer/delta-index.c

590

for (size -= count; size > BITS_PER_BYTE; size -= BITS_PER_BYTE)

drivers/md/dm-vdo/indexer/delta-index.c

620

source = from + (from_offset - offset) / BITS_PER_BYTE;

drivers/md/dm-vdo/indexer/delta-index.c

621

destination = to + to_offset / BITS_PER_BYTE;

drivers/md/dm-vdo/indexer/delta-index.c

660

source = from + (from_offset + size - offset) / BITS_PER_BYTE;

drivers/md/dm-vdo/indexer/delta-index.c

661

destination = to + (to_offset + size) / BITS_PER_BYTE;

drivers/md/dm-vdo/indexer/delta-index.c

73

#define MAX_FIELD_BITS ((sizeof(u32) - 1) * BITS_PER_BYTE + 1)

drivers/md/dm-vdo/indexer/delta-index.c

730

free_bits = memory_size * BITS_PER_BYTE;

drivers/md/dm-vdo/indexer/delta-index.c

79

#define MAX_BIG_FIELD_BITS ((sizeof(u64) - 1) * BITS_PER_BYTE + 1)

drivers/md/dm-vdo/indexer/delta-index.c

794

delta_zone->new_offsets[i] *= BITS_PER_BYTE;

drivers/md/dm-vdo/indexer/delta-index.c

795

delta_zone->new_offsets[i] += delta_lists[i].start % BITS_PER_BYTE;

drivers/md/dm-vdo/indexer/delta-index.c

803

(delta_zone->size * BITS_PER_BYTE - delta_lists[tail_guard_index].size);

drivers/md/dm-vdo/indexer/delta-index.c

90

#define GUARD_BITS (POST_FIELD_GUARD_BYTES * BITS_PER_BYTE)

drivers/md/dm-vdo/indexer/delta-index.c

97

((U16_MAX + BITS_PER_BYTE) / BITS_PER_BYTE + POST_FIELD_GUARD_BYTES)

drivers/md/dm-vdo/indexer/volume-index.c

1207

sub_index->max_zone_bits = (available_bytes * BITS_PER_BYTE) / zone_count;

drivers/md/dm-vdo/indexer/volume-index.c

273

expected_index_size = index_size_in_bits / BITS_PER_BYTE;

drivers/md/md-bitmap.c

2420

(BITS_PER_BYTE * sizeof(((bitmap_super_t *)0)->chunksize) - 1));

drivers/md/md-bitmap.c

2849

if (BITS_PER_LONG > 32 && csize >= (1ULL << (BITS_PER_BYTE *

drivers/md/raid5-ppl.c

1348

BITS_PER_BYTE;

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

254

*bytesperline = *width * DIV_ROUND_UP(pfmt->bpp, BITS_PER_BYTE);

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

256

*bytesperline = DIV_ROUND_UP(*width * pfmt->bpp, BITS_PER_BYTE);

drivers/media/platform/allegro-dvt/allegro-core.c

1218

cpb_size_kbit = cpb_size * BITS_PER_BYTE;

drivers/media/platform/amphion/vpu_helpers.c

185

bytesperline = DIV_ROUND_UP(width * bitdepth, BITS_PER_BYTE);

drivers/media/v4l2-core/v4l2-subdev.c

2329

if (pad >= sizeof(sd->enabled_pads) * BITS_PER_BYTE)

drivers/media/v4l2-core/v4l2-subdev.c

2430

if (pad >= sizeof(sd->enabled_pads) * BITS_PER_BYTE)

drivers/mfd/hi6421-spmi-pmic.c

24

.val_bits = BITS_PER_BYTE,

drivers/misc/hi6421v600-irq.c

127

for_each_set_bit(offset, &pending, BITS_PER_BYTE) {

drivers/misc/hi6421v600-irq.c

128

generic_handle_irq_safe(priv->irqs[offset + i * BITS_PER_BYTE]);

drivers/misc/hi6421v600-irq.c

94

(irqd_to_hwirq(irq_data) / BITS_PER_BYTE))

drivers/misc/hi6421v600-irq.c

95

#define HISI_IRQ_MASK_BIT(irq_data) BIT(irqd_to_hwirq(irq_data) & (BITS_PER_BYTE - 1))

drivers/misc/sgi-xp/xpc_partition.c

173

BITS_PER_BYTE);

drivers/mmc/host/meson-mx-sdio.c

184

pack_size = cmd->data->blksz * BITS_PER_BYTE;

drivers/mmc/host/meson-mx-sdio.c

551

mmc->max_blk_size /= BITS_PER_BYTE;

drivers/mmc/host/renesas_sdhi_core.c

711

if (priv->tap_num * 2 >= sizeof(priv->taps) * BITS_PER_BYTE) {

drivers/mtd/maps/physmap-bt1-rom.c

44

ret.x[0] = data >> (shift * BITS_PER_BYTE);

drivers/mtd/maps/physmap-bt1-rom.c

52

ret.x[0] |= data << (shift * BITS_PER_BYTE);

drivers/mtd/nand/core.c

43

bitflips += BITS_PER_BYTE - weight;

drivers/mtd/nand/core.c

61

bitflips += BITS_PER_BYTE - weight;

drivers/mtd/nand/raw/loongson-nand-controller.c

278

shift = i * BITS_PER_BYTE;

drivers/mtd/nand/raw/loongson-nand-controller.c

284

shift = op->row_start + (i - LOONGSON_NAND_COL_ADDR_CYC) * BITS_PER_BYTE;

drivers/mtd/nand/raw/loongson-nand-controller.c

306

shift = i * BITS_PER_BYTE;

drivers/mtd/nand/raw/loongson-nand-controller.c

311

shift = (i - LOONGSON_NAND_COL_ADDR_CYC) * BITS_PER_BYTE;

drivers/mtd/nand/raw/loongson-nand-controller.c

348

col = op->addrs[1] << BITS_PER_BYTE | op->addrs[0];

drivers/mtd/nand/raw/loongson-nand-controller.c

75

#define BITS_PER_WORD (4 * BITS_PER_BYTE)

drivers/mtd/nand/raw/tegra_nand.c

1027

chip->ecc.bytes = DIV_ROUND_UP(bits_per_step, BITS_PER_BYTE);

drivers/mtd/nand/raw/tegra_nand.c

208

BITS_PER_BYTE);

drivers/mtd/nand/raw/tegra_nand.c

235

BITS_PER_BYTE);

drivers/mtd/nand/raw/tegra_nand.c

389

addr1 |= *addrs++ << (BITS_PER_BYTE * i);

drivers/mtd/nand/raw/tegra_nand.c

392

addr2 |= *addrs++ << (BITS_PER_BYTE * i);

drivers/mtd/nand/raw/tegra_nand.c

869

BITS_PER_BYTE);

drivers/mtd/spi-nor/core.c

2443

for (cap = 0; cap < sizeof(*hwcaps) * BITS_PER_BYTE; cap++) {

drivers/mtd/spi-nor/debugfs.c

190

for (i = 0; i < sizeof(hwcaps) * BITS_PER_BYTE; i++) {

drivers/mtd/spi-nor/debugfs.c

203

for (i = 0; i < sizeof(hwcaps) * BITS_PER_BYTE; i++) {

drivers/mtd/spi-nor/debugfs.c

63

for (i = 0; i < sizeof(flags) * BITS_PER_BYTE; i++) {

drivers/mtd/tests/mtd_nandecctest.c

50

unsigned int offset = get_random_u32_below(size * BITS_PER_BYTE);

drivers/mtd/tests/mtd_nandecctest.c

61

offset[0] = get_random_u32_below(size * BITS_PER_BYTE);

drivers/mtd/tests/mtd_nandecctest.c

63

offset[1] = get_random_u32_below(size * BITS_PER_BYTE);

drivers/mtd/tests/mtd_nandecctest.c

74

unsigned int offset = get_random_u32_below(3 * BITS_PER_BYTE);

drivers/mtd/tests/mtd_nandecctest.c

82

offset = get_random_u32_below(3 * BITS_PER_BYTE);

drivers/net/can/spi/mcp251xfd/mcp251xfd-regmap.c

177

mask_le32 = cpu_to_le32(mask >> BITS_PER_BYTE * first_byte);

drivers/net/can/spi/mcp251xfd/mcp251xfd-regmap.c

178

val_le32 = cpu_to_le32(val >> BITS_PER_BYTE * first_byte);

drivers/net/can/spi/mcp251xfd/mcp251xfd-regmap.c

260

mcp251xfd_regmap_crc.pad_bits / BITS_PER_BYTE)

drivers/net/can/spi/mcp251xfd/mcp251xfd-regmap.c

315

mcp251xfd_regmap_crc.pad_bits / BITS_PER_BYTE;

drivers/net/can/spi/mcp251xfd/mcp251xfd-regmap.c

378

mcp251xfd_regmap_crc.pad_bits / BITS_PER_BYTE)

drivers/net/can/spi/mcp251xfd/mcp251xfd-ring.c

34

val_le32 = cpu_to_le32(val >> BITS_PER_BYTE * first_byte);

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_rss.c

270

j * HCLGE_COMM_RSS_CFG_TBL_BW_H / BITS_PER_BYTE;

drivers/net/ethernet/hisilicon/hns3/hns3_common/hclge_comm_rss.c

272

(j * HCLGE_COMM_RSS_CFG_TBL_BW_H % BITS_PER_BYTE);

drivers/net/ethernet/ibm/emac/core.h

389

((crc) >> ((sizeof (u32) * BITS_PER_BYTE) - \

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

1625

for (i = 0; i < BITS_PER_BYTE * sizeof(mask_bm); i++)

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

1703

for (i = 0; i < BITS_PER_BYTE * sizeof(ena_mask); i++)

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

2901

raw_swap |= used[idx] << (k * BITS_PER_BYTE);

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

2903

raw_in |= ICE_INSET_DFLT << (k * BITS_PER_BYTE);

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

3005

raw_swap |= (swap_val++) << (j * BITS_PER_BYTE);

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

3006

raw_in |= ICE_INSET_DFLT << (j * BITS_PER_BYTE);

drivers/net/ethernet/intel/ice/ice_flex_type.h

373

BITS_PER_BYTE))

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

1147

ese_bits = ICE_FLOW_FV_EXTRACT_SZ * BITS_PER_BYTE;

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

1238

BITS_PER_BYTE;

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

1245

(raw->info.src.last * BITS_PER_BYTE),

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

1246

(ICE_FLOW_FV_EXTRACT_SZ * BITS_PER_BYTE));

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

1680

params->mask[idx] = (((prof->fv[i].msk) << BITS_PER_BYTE) &

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

1682

(((prof->fv[i].msk) >> BITS_PER_BYTE) &

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

50

.off = (_offset_bytes) * BITS_PER_BYTE, \

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

51

.size = (_size_bytes) * BITS_PER_BYTE, \

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

58

.off = (_offset_bytes) * BITS_PER_BYTE, \

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

59

.size = (_size_bytes) * BITS_PER_BYTE, \

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

1062

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

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

1234

idd = (ICE_BST_ALU_BA_S + off) / BITS_PER_BYTE;

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

1235

off = (ICE_BST_ALU_BA_S + off) % BITS_PER_BYTE;

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

1292

#define ICE_BT_KEY_IDD (ICE_BT_KEY_S / BITS_PER_BYTE)

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

1294

#define ICE_BT_KIV_IDD (ICE_BT_KIV_S / BITS_PER_BYTE)

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

1296

#define ICE_BT_HIG_IDD (ICE_BT_HIG_S / BITS_PER_BYTE)

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

1298

#define ICE_BT_PGP_IDD (ICE_BT_PGP_S / BITS_PER_BYTE)

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

1301

#define ICE_BT_NPKB_IDD (ICE_BT_NPKB_S / BITS_PER_BYTE)

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

1302

#define ICE_BT_NPKB_OFF (ICE_BT_NPKB_S % BITS_PER_BYTE)

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

1304

#define ICE_BT_PGKB_IDD (ICE_BT_PGKB_S / BITS_PER_BYTE)

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

1305

#define ICE_BT_PGKB_OFF (ICE_BT_PGKB_S % BITS_PER_BYTE)

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

1307

#define ICE_BT_ALU0_IDD (ICE_BT_ALU0_S / BITS_PER_BYTE)

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

1308

#define ICE_BT_ALU0_OFF (ICE_BT_ALU0_S % BITS_PER_BYTE)

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

1310

#define ICE_BT_ALU1_IDD (ICE_BT_ALU1_S / BITS_PER_BYTE)

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

1311

#define ICE_BT_ALU1_OFF (ICE_BT_ALU1_S % BITS_PER_BYTE)

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

1313

#define ICE_BT_ALU2_IDD (ICE_BT_ALU2_S / BITS_PER_BYTE)

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

1314

#define ICE_BT_ALU2_OFF (ICE_BT_ALU2_S % BITS_PER_BYTE)

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

1623

idd = (ICE_PROTO_GRP_ITEM_SIZE * i) / BITS_PER_BYTE;

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

1624

off = (ICE_PROTO_GRP_ITEM_SIZE * i) % BITS_PER_BYTE;

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

1761

(u32)(kb->flag15 >> (sizeof(u32) * BITS_PER_BYTE)));

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

1768

#define ICE_XLT_KB_X1AS_IDD (ICE_XLT_KB_X1AS_S / BITS_PER_BYTE)

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

1769

#define ICE_XLT_KB_X1AS_OFF (ICE_XLT_KB_X1AS_S % BITS_PER_BYTE)

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

1787

#define ICE_XLT_KB_FL06_IDD (ICE_XLT_KB_FL06_S / BITS_PER_BYTE)

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

1788

#define ICE_XLT_KB_FL06_OFF (ICE_XLT_KB_FL06_S % BITS_PER_BYTE)

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

1802

#define ICE_XLT_KB_FL12_IDD (ICE_XLT_KB_FL12_S / BITS_PER_BYTE)

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

1803

#define ICE_XLT_KB_FL12_OFF (ICE_XLT_KB_FL12_S % BITS_PER_BYTE)

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

352

idd = (ICE_IM_ALU_BA_S + off) / BITS_PER_BYTE;

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

353

off = (ICE_IM_ALU_BA_S + off) % BITS_PER_BYTE;

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

367

#define ICE_IMEM_BKB_IDD (ICE_IMEM_BKB_S / BITS_PER_BYTE)

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

368

#define ICE_IMEM_BKB_OFF (ICE_IMEM_BKB_S % BITS_PER_BYTE)

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

371

#define ICE_IMEM_NPKB_IDD (ICE_IMEM_NPKB_S / BITS_PER_BYTE)

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

372

#define ICE_IMEM_NPKB_OFF (ICE_IMEM_NPKB_S % BITS_PER_BYTE)

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

374

#define ICE_IMEM_PGKB_IDD (ICE_IMEM_PGKB_S / BITS_PER_BYTE)

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

375

#define ICE_IMEM_PGKB_OFF (ICE_IMEM_PGKB_S % BITS_PER_BYTE)

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

377

#define ICE_IMEM_ALU0_IDD (ICE_IMEM_ALU0_S / BITS_PER_BYTE)

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

378

#define ICE_IMEM_ALU0_OFF (ICE_IMEM_ALU0_S % BITS_PER_BYTE)

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

380

#define ICE_IMEM_ALU1_IDD (ICE_IMEM_ALU1_S / BITS_PER_BYTE)

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

381

#define ICE_IMEM_ALU1_OFF (ICE_IMEM_ALU1_S % BITS_PER_BYTE)

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

383

#define ICE_IMEM_ALU2_IDD (ICE_IMEM_ALU2_S / BITS_PER_BYTE)

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

384

#define ICE_IMEM_ALU2_OFF (ICE_IMEM_ALU2_S % BITS_PER_BYTE)

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

501

#define ICE_MI_GBDM_IDD (ICE_MI_GBDM_S / BITS_PER_BYTE)

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

502

#define ICE_MI_GBDM_OFF (ICE_MI_GBDM_S % BITS_PER_BYTE)

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

521

#define ICE_MI_FLAG_IDD (ICE_MI_FLAG_S / BITS_PER_BYTE)

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

522

#define ICE_MI_FLAG_OFF (ICE_MI_FLAG_S % BITS_PER_BYTE)

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

773

#define ICE_PGCK_NPK_IDD (ICE_PGCK_NPK_S / BITS_PER_BYTE)

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

774

#define ICE_PGCK_NPK_OFF (ICE_PGCK_NPK_S % BITS_PER_BYTE)

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

807

#define ICE_PG_CAM_ACT_IDD (ICE_PG_CAM_ACT_S / BITS_PER_BYTE)

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

808

#define ICE_PG_CAM_ACT_OFF (ICE_PG_CAM_ACT_S % BITS_PER_BYTE)

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

837

#define ICE_PG_SP_CAM_KEY_IDD (ICE_PG_SP_CAM_KEY_S / BITS_PER_BYTE)

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

866

#define ICE_PG_NM_CAM_ACT_IDD (ICE_PG_NM_CAM_ACT_S / BITS_PER_BYTE)

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

867

#define ICE_PG_NM_CAM_ACT_OFF (ICE_PG_NM_CAM_ACT_S % BITS_PER_BYTE)

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

897

#define ICE_PG_NM_SP_CAM_ACT_IDD (ICE_PG_NM_SP_CAM_ACT_S / BITS_PER_BYTE)

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

898

#define ICE_PG_NM_SP_CAM_ACT_OFF (ICE_PG_NM_SP_CAM_ACT_S % BITS_PER_BYTE)

drivers/net/ethernet/intel/ice/ice_parser.h

405

(ICE_MARKER_ID_SIZE * BITS_PER_BYTE - 1)

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

665

unsigned int byte = idx / BITS_PER_BYTE;

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

666

unsigned int bit = idx % BITS_PER_BYTE;

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

3200

bytes_per_sec = div64_long(((s64)bw * 1000), BITS_PER_BYTE);

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

3252

bytes_per_sec = div64_long(((s64)bw * 1000), BITS_PER_BYTE);

drivers/net/ethernet/marvell/mvpp2/mvpp2_prs.c

155

int pos = MVPP2_PRS_BYTE_IN_WORD(offs) * BITS_PER_BYTE;

drivers/net/ethernet/marvell/mvpp2/mvpp2_prs.c

168

int pos = MVPP2_PRS_BYTE_IN_WORD(offs) * BITS_PER_BYTE;

drivers/net/ethernet/marvell/octeon_ep/octep_ctrl_net.c

48

GENMASK(sizeof(msg->hdr.s.msg_id) * BITS_PER_BYTE, 0);

drivers/net/ethernet/mellanox/mlx4/mlx4_en.h

517

#define MLX4_EN_MAC_HASH_SIZE (1 << BITS_PER_BYTE)

drivers/net/ethernet/mellanox/mlx5/core/en/fs.h

36

#define MLX5E_L2_ADDR_HASH_SIZE BIT(BITS_PER_BYTE)

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ipsec_offload.c

215

aes_gcm->key_len / BITS_PER_BYTE,

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

40

#define ARFS_HASH_SHIFT BITS_PER_BYTE

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

41

#define ARFS_HASH_SIZE BIT(BITS_PER_BYTE)

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

1022

bitn = find_first_bit(&active_fec_long, sizeof(active_fec_long) * BITS_PER_BYTE);

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

1961

sizeof(unsigned long) * BITS_PER_BYTE);

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

1967

sizeof(unsigned long) * BITS_PER_BYTE);

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

1982

bitmap_from_arr32(&fec_bitmap, &fecparam->fec, sizeof(fecparam->fec) * BITS_PER_BYTE);

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

1413

return find_first_bit(&fec_active_long, sizeof(unsigned long) * BITS_PER_BYTE);

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

5037

rate = (rate * BITS_PER_BYTE) + 500000;

drivers/net/ethernet/mellanox/mlx5/core/esw/bridge.c

935

return vport_num | (unsigned long)esw_owner_vhca_id << sizeof(vport_num) * BITS_PER_BYTE;

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

162

int num_bits = sizeof(bit_set) * BITS_PER_BYTE;

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

197

sizeof(value_lsb) * BITS_PER_BYTE);

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

93

u32 sz_bits = sz_bytes * BITS_PER_BYTE;

drivers/net/ethernet/mellanox/mlx5/core/lib/mpfs.h

40

#define MLX5_L2_ADDR_HASH_SIZE (BIT(BITS_PER_BYTE))

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_rule.c

700

if (dr_get_bits_per_mask(htbl->byte_mask) * BITS_PER_BYTE <= htbl->chunk->size)

drivers/net/ethernet/mellanox/mlxsw/item.h

214

BITS_PER_BYTE % item->element_size != 0) {

drivers/net/ethernet/mellanox/mlxsw/item.h

227

in_byte_index = index % (BITS_PER_BYTE / item->element_size);

drivers/net/ethernet/mellanox/mlxsw/reg.h

10713

int offset = bit % (MLXSW_REG_BYTES_PER_DWORD * BITS_PER_BYTE);

drivers/net/ethernet/mellanox/mlxsw/reg.h

10714

int dword = bit / (MLXSW_REG_BYTES_PER_DWORD * BITS_PER_BYTE);

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.h

72

(MLXSW_REG_PTCEX_FLEX_KEY_BLOCKS_LEN * BITS_PER_BYTE)

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

550

hdroom.delay_bytes = DIV_ROUND_UP(pfc->delay, BITS_PER_BYTE);

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

174

u64 rate_bps = params->rate * BITS_PER_BYTE;

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

56

return div_u64(rate_bytes_ps, 1000) * BITS_PER_BYTE;

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

173

WARN_ON(max > BITS_PER_BYTE * sizeof(u16));

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

400

#define MLXSW_SP_PREFIX_COUNT (sizeof(struct in6_addr) * BITS_PER_BYTE + 1)

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

1036

int byidx = port->portno / BITS_PER_BYTE;

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

1037

int biidx = port->portno % BITS_PER_BYTE;

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

318

range = port->portno / BITS_PER_BYTE;

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

319

port_mask.mask[range] = ~BIT(port->portno % BITS_PER_BYTE);

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

176

int bytes = DIV_ROUND_UP(width, BITS_PER_BYTE);

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

181

for (idx = 0; idx < bytes; ++idx, rwidth -= BITS_PER_BYTE) {

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

182

if (rwidth && rwidth < BITS_PER_BYTE)

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

105

bytes = DIV_ROUND_UP(keyfield[key].width, BITS_PER_BYTE);

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

150

bytes = DIV_ROUND_UP(actionfield[action].width, BITS_PER_BYTE);

drivers/net/ethernet/netronome/nfp/abm/cls.c

129

prios_per_word = sizeof(u32) * BITS_PER_BYTE / bits_per_prio;

drivers/net/ethernet/netronome/nfp/abm/ctrl.c

320

size = DIV_ROUND_UP(size * abm->num_prios, BITS_PER_BYTE);

drivers/net/ethernet/netronome/nfp/crypto/ipsec.c

368

key_len = DIV_ROUND_UP(x->aalg->alg_key_len, BITS_PER_BYTE);

drivers/net/ethernet/netronome/nfp/crypto/ipsec.c

461

key_len = DIV_ROUND_UP(x->aead->alg_key_len, BITS_PER_BYTE);

drivers/net/ethernet/netronome/nfp/crypto/ipsec.c

488

key_len = DIV_ROUND_UP(x->ealg->alg_key_len, BITS_PER_BYTE);

drivers/net/ethernet/netronome/nfp/nfp_net_debugdump.c

470

reg_sz = be32_to_cpu(spec_csr->register_width) / BITS_PER_BYTE;

drivers/net/ethernet/netronome/nfp/nfp_net_debugdump.c

574

reg_sz = be32_to_cpu(spec_csr->register_width) / BITS_PER_BYTE;

drivers/net/ethernet/qlogic/qed/qed_dev.c

1687

sizeof(pq_flags) * BITS_PER_BYTE) > 1) {

drivers/net/ethernet/qlogic/qed/qed_iwarp.c

1842

fpdu->fpdu_length = *mpa_data << BITS_PER_BYTE;

drivers/net/ethernet/qlogic/qed/qed_l2.c

1514

nbits = sizeof(u32) * BITS_PER_BYTE;

drivers/net/ethernet/realtek/r8169_main.c

2241

return DIV_ROUND_CLOSEST(timer * BITS_PER_BYTE, speed);

drivers/net/ethernet/stmicro/stmmac/dwmac-ingenic.c

144

if (phy_intf_sel >= BITS_PER_BYTE ||

drivers/net/ipa/ipa_cmd.c

269

bit_count = BITS_PER_BYTE * sizeof(payload->offset);

drivers/net/ipvlan/ipvlan.h

33

#define IPVLAN_HASH_SIZE (1 << BITS_PER_BYTE)

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

927

minlen = (nsymbols * nsymbits) / BITS_PER_BYTE;

drivers/net/wireless/ath/carl9170/carl9170.h

115

#define CARL9170_BAW_LEN (DIV_ROUND_UP(CARL9170_BAW_BITS, BITS_PER_BYTE))

drivers/net/wireless/intel/iwlwifi/dvm/main.c

1347

WARN_ON(sizeof(priv->transport_queue_stop) * BITS_PER_BYTE <

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

2706

BUILD_BUG_ON((sizeof(trigger->regions_mask) * BITS_PER_BYTE) <

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

3211

BUILD_BUG_ON((sizeof(mvmsta->agg_tids) * BITS_PER_BYTE)

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/tx-gen2.c

1410

BUILD_BUG_ON(IWL_TFH_NUM_TBS > sizeof(out_meta->tbs) * BITS_PER_BYTE);

drivers/net/wireless/intel/iwlwifi/pcie/gen1_2/tx.c

1584

BUILD_BUG_ON(IWL_TFH_NUM_TBS > sizeof(out_meta->tbs) * BITS_PER_BYTE);

drivers/net/wireless/quantenna/qtnfmac/core.h

120

u8 hw_capab[QLINK_HW_CAPAB_NUM / BITS_PER_BYTE + 1];

drivers/net/wireless/quantenna/qtnfmac/qlink_util.c

161

unsigned int idx = bit / BITS_PER_BYTE;

drivers/net/wireless/quantenna/qtnfmac/qlink_util.c

162

u8 mask = 1 << (bit - (idx * BITS_PER_BYTE));

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

5145

int tids_nbit = BITS_PER_BYTE;

drivers/nvmem/core.c

1609

bytes_offset = bit_offset / BITS_PER_BYTE;

drivers/nvmem/core.c

1611

bit_offset %= BITS_PER_BYTE;

drivers/nvmem/core.c

1613

if (bit_offset % BITS_PER_BYTE) {

drivers/nvmem/core.c

1620

*p++ |= *b << (BITS_PER_BYTE - bit_offset);

drivers/nvmem/core.c

1633

extra = cell->bytes - DIV_ROUND_UP(cell->nbits, BITS_PER_BYTE);

drivers/nvmem/core.c

1638

if (cell->nbits % BITS_PER_BYTE)

drivers/nvmem/core.c

1639

*p &= GENMASK((cell->nbits % BITS_PER_BYTE) - 1, 0);

drivers/nvmem/core.c

1732

pbits = pbyte >> (BITS_PER_BYTE - 1 - bit_offset);

drivers/nvmem/core.c

1741

if ((nbits + bit_offset) % BITS_PER_BYTE) {

drivers/nvmem/core.c

1747

*p |= GENMASK(7, (nbits + bit_offset) % BITS_PER_BYTE) & v;

drivers/nvmem/core.c

596

BITS_PER_BYTE);

drivers/nvmem/core.c

814

if (info.bit_offset >= BITS_PER_BYTE * info.bytes ||

drivers/nvmem/core.c

816

info.bit_offset + info.nbits > BITS_PER_BYTE * info.bytes) {

drivers/nvmem/qfprom.c

344

cell->bit_offset += byte_offset * BITS_PER_BYTE;

drivers/nvmem/qfprom.c

347

cell->nbits = cell->bytes * BITS_PER_BYTE;

drivers/nvmem/sc27xx-efuse.c

128

u32 blk_offset = (offset % SC27XX_EFUSE_BLOCK_WIDTH) * BITS_PER_BYTE;

drivers/nvmem/sprd-efuse.c

299

u32 blk_offset = (offset % SPRD_EFUSE_BLOCK_WIDTH) * BITS_PER_BYTE;

drivers/pci/controller/dwc/pcie-bt1.c

180

*val = readl(addr - ofs) >> ofs * BITS_PER_BYTE;

drivers/pci/controller/dwc/pcie-bt1.c

206

mask = GENMASK(size * BITS_PER_BYTE - 1, 0);

drivers/pci/controller/dwc/pcie-bt1.c

207

tmp = readl(addr - ofs) & ~(mask << ofs * BITS_PER_BYTE);

drivers/pci/controller/dwc/pcie-bt1.c

208

tmp |= (val & mask) << ofs * BITS_PER_BYTE;

drivers/pci/controller/pcie-rcar-host.c

241

*val = (*val >> (BITS_PER_BYTE * (where & 3))) & 0xff;

drivers/pci/controller/pcie-rcar-host.c

243

*val = (*val >> (BITS_PER_BYTE * (where & 2))) & 0xffff;

drivers/pci/controller/pcie-rcar-host.c

269

shift = BITS_PER_BYTE * (where & 3);

drivers/pci/controller/pcie-rcar-host.c

273

shift = BITS_PER_BYTE * (where & 2);

drivers/pci/controller/pcie-rcar-host.c

94

unsigned int shift = BITS_PER_BYTE * (where & 3);

drivers/pci/controller/pcie-rcar.c

26

unsigned int shift = BITS_PER_BYTE * (where & 3);

drivers/pci/controller/pcie-rzg3s-host.c

415

shift = BITS_PER_BYTE * (where & 3);

drivers/pci/controller/pcie-rzg3s-host.c

419

shift = BITS_PER_BYTE * (where & 2);

drivers/phy/amlogic/phy-meson-axg-mipi-dphy.c

254

DIV_ROUND_UP(priv->config.clk_pre, BITS_PER_BYTE));

drivers/phy/mediatek/phy-mtk-tphy.c

1246

offset = instance->type_sw_index * BITS_PER_BYTE;

drivers/phy/mediatek/phy-mtk-xsphy.c

373

offset = instance->type_sw_index * BITS_PER_BYTE;

drivers/phy/rockchip/phy-rockchip-inno-dsidphy.c

493

clk_pre = DIV_ROUND_UP(cfg->clk_pre, BITS_PER_BYTE);

drivers/pinctrl/pinctrl-lpc18xx.c

744

reg_val >>= BITS_PER_BYTE;

drivers/pinctrl/pinctrl-single.c

1644

mux_bytes = pcs->width / BITS_PER_BYTE;

drivers/pinctrl/pinctrl-single.c

1680

mux_bytes = pcs->width / BITS_PER_BYTE;

drivers/pinctrl/pinctrl-single.c

271

unsigned int mux_bytes = pcs->width / BITS_PER_BYTE;

drivers/pinctrl/pinctrl-single.c

276

pin_offset_bytes = (pcs->bits_per_pin * pin) / BITS_PER_BYTE;

drivers/pinctrl/pinctrl-single.c

508

offset = pin * (pcs->width / BITS_PER_BYTE);

drivers/pinctrl/pinctrl-single.c

576

offset = pin * (pcs->width / BITS_PER_BYTE);

drivers/pinctrl/pinctrl-single.c

736

mux_bytes = pcs->width / BITS_PER_BYTE;

drivers/pinctrl/pinctrl-single.c

740

nr_pins = (pcs->size * BITS_PER_BYTE) / pcs->bits_per_pin;

drivers/pinctrl/pinctrl-single.c

832

index = (offset * BITS_PER_BYTE) / pcs->bits_per_pin;

drivers/pinctrl/pinctrl-single.c

834

index = offset / (pcs->width / BITS_PER_BYTE);

drivers/platform/x86/intel/speed_select_if/isst_tpmi_core.c

882

for_each_set_bit(level, &level_mask, BITS_PER_BYTE) {

drivers/platform/x86/intel/speed_select_if/isst_tpmi_core.c

896

for_each_set_bit(level, &level_mask, BITS_PER_BYTE) {

drivers/platform/x86/intel/telemetry/pltdrv.c

252

write_buf <<= BITS_PER_BYTE;

drivers/platform/x86/lg-laptop.c

744

if (bits % BITS_PER_BYTE)

drivers/platform/x86/lg-laptop.c

747

size = bits / BITS_PER_BYTE;

drivers/power/supply/max77705_charger.c

86

REGMAP_IRQ_REG_LINE(MAX77705_BYP_I, BITS_PER_BYTE),

drivers/power/supply/max77705_charger.c

87

REGMAP_IRQ_REG_LINE(MAX77705_INP_LIMIT_I, BITS_PER_BYTE),

drivers/power/supply/max77705_charger.c

88

REGMAP_IRQ_REG_LINE(MAX77705_BATP_I, BITS_PER_BYTE),

drivers/power/supply/max77705_charger.c

89

REGMAP_IRQ_REG_LINE(MAX77705_BAT_I, BITS_PER_BYTE),

drivers/power/supply/max77705_charger.c

90

REGMAP_IRQ_REG_LINE(MAX77705_CHG_I, BITS_PER_BYTE),

drivers/power/supply/max77705_charger.c

91

REGMAP_IRQ_REG_LINE(MAX77705_WCIN_I, BITS_PER_BYTE),

drivers/power/supply/max77705_charger.c

92

REGMAP_IRQ_REG_LINE(MAX77705_CHGIN_I, BITS_PER_BYTE),

drivers/power/supply/max77705_charger.c

93

REGMAP_IRQ_REG_LINE(MAX77705_AICL_I, BITS_PER_BYTE),

drivers/ptp/ptp_chardev.c

159

DIV_ROUND_UP(PTP_MAX_CHANNELS, BITS_PER_BYTE * sizeof(u32));

drivers/pwm/pwm-stm32-lp.c

50

if (bitmap_weight(&ccmr, sizeof(u32) * BITS_PER_BYTE) > 1)

drivers/reset/amlogic/reset-meson-common.c

30

*offset = (id / (stride * BITS_PER_BYTE)) * stride;

drivers/reset/amlogic/reset-meson-common.c

31

*bit = id % (stride * BITS_PER_BYTE);

drivers/reset/reset-simple.c

183

data->rcdev.nr_resets = resource_size(res) * BITS_PER_BYTE;

drivers/reset/reset-simple.c

35

int bank = id / (reg_width * BITS_PER_BYTE);

drivers/reset/reset-simple.c

36

int offset = id % (reg_width * BITS_PER_BYTE);

drivers/reset/reset-simple.c

89

int bank = id / (reg_width * BITS_PER_BYTE);

drivers/reset/reset-simple.c

90

int offset = id % (reg_width * BITS_PER_BYTE);

drivers/reset/reset-uniphier-glue.c

82

priv->rdata.rcdev.nr_resets = resource_size(res) * BITS_PER_BYTE;

drivers/s390/char/sclp.h

24

#define SCLP_EVTYP_MASK(T) (1UL << (sizeof(sccb_mask_t) * BITS_PER_BYTE - (T)))

drivers/s390/cio/airq.c

141

if ((cache_line_size() * BITS_PER_BYTE) < bits

drivers/s390/net/ism_drv.c

505

end = sizeof(ism->sba->dmb_bits) * BITS_PER_BYTE - ISM_DMB_BIT_OFFSET;

drivers/s390/net/qeth_l2_main.c

2239

chars_len = sizeof(card->options.vnicc.sup_chars) * BITS_PER_BYTE;

drivers/s390/net/qeth_l2_main.c

2263

chars_len = sizeof(card->options.vnicc.wanted_chars) * BITS_PER_BYTE;

drivers/s390/virtio/virtio_ccw.c

1215

sizeof(*indicators(vcdev)) * BITS_PER_BYTE) {

drivers/scsi/scsi_sysfs.c

1069

for (i = 0; i < sizeof(sdev->sdev_bflags) * BITS_PER_BYTE; i++) {

drivers/scsi/smartpqi/smartpqi_init.c

7827

byte_index = bit_position / BITS_PER_BYTE;

drivers/scsi/smartpqi/smartpqi_init.c

7833

(1 << (bit_position % BITS_PER_BYTE)) ? true : false;

drivers/scsi/smartpqi/smartpqi_init.c

7844

byte_index = (bit_position / BITS_PER_BYTE) +

drivers/scsi/smartpqi/smartpqi_init.c

7852

(1 << (bit_position % BITS_PER_BYTE)) ? true : false;

drivers/scsi/smartpqi/smartpqi_init.c

7861

byte_index = (bit_position / BITS_PER_BYTE) +

drivers/scsi/smartpqi/smartpqi_init.c

7865

(1 << (bit_position % BITS_PER_BYTE));

drivers/soc/qcom/qcom-geni-se.c

532

int idx_delta = msb_to_lsb ? -BITS_PER_BYTE : BITS_PER_BYTE;

drivers/soc/qcom/qcom-geni-se.c

533

int ceil_bpw = ALIGN(bpw, BITS_PER_BYTE);

drivers/soc/qcom/qcom-geni-se.c

534

int iter = (ceil_bpw * pack_words) / BITS_PER_BYTE;

drivers/soc/qcom/qcom-geni-se.c

541

len = min_t(int, temp_bpw, BITS_PER_BYTE) - 1;

drivers/soc/qcom/qcom-geni-se.c

546

if (temp_bpw <= BITS_PER_BYTE) {

drivers/soc/qcom/qcom-geni-se.c

547

idx = ((i + 1) * BITS_PER_BYTE) + idx_start;

drivers/soc/qcom/qcom-geni-se.c

551

temp_bpw = temp_bpw - BITS_PER_BYTE;

drivers/soc/qcom/rpmh-rsc.c

1018

st + tcs->num_tcs >= BITS_PER_BYTE * sizeof(tcs->mask))

drivers/spi/spi-airoha-snfi.c

497

if (op->dummy.nbytes * BITS_PER_BYTE / op->dummy.buswidth > 0xf)

drivers/spi/spi-cs42l43.c

117

val >>= BITS_PER_BYTE;

drivers/spi/spi-cs42l43.c

69

val >>= BITS_PER_BYTE;

drivers/spi/spi-cs42l43.c

75

val >>= pad * BITS_PER_BYTE;

drivers/spi/spi-dw-core.c

398

nbits = dws->n_bytes * BITS_PER_BYTE;

drivers/spi/spi-dw-core.c

639

ns *= dws->n_bytes * BITS_PER_BYTE;

drivers/spi/spi-dw-dma.c

263

ms = len * MSEC_PER_SEC * BITS_PER_BYTE;

drivers/spi/spi-dw-dma.c

296

delay.value = nents * dws->n_bytes * BITS_PER_BYTE;

drivers/spi/spi-dw.h

130

((_val) >> (BITS_PER_BYTE * (_idx)) & 0xff)

drivers/spi/spi-fsl-lpspi.c

201

return DIV_ROUND_UP(bpw, BITS_PER_BYTE);

drivers/spi/spi-geni-qcom.c

423

int bytes_per_word = (mas->cur_bits_per_word / BITS_PER_BYTE) + 1;

drivers/spi/spi-geni-qcom.c

490

len = xfer->len * BITS_PER_BYTE / xfer->bits_per_word;

drivers/spi/spi-geni-qcom.c

492

len = xfer->len / (xfer->bits_per_word / BITS_PER_BYTE + 1);

drivers/spi/spi-geni-qcom.c

696

BITS_PER_BYTE));

drivers/spi/spi-geni-qcom.c

698

return mas->fifo_width_bits / BITS_PER_BYTE;

drivers/spi/spi-imx.c

1659

pre_bl = transfer->len * BITS_PER_BYTE - 1;

drivers/spi/spi-imx.c

1662

pre_bl = MX51_ECSPI_CTRL_MAX_BURST * BITS_PER_BYTE - 1;

drivers/spi/spi-imx.c

1665

pre_bl = MX51_ECSPI_CTRL_MAX_BURST * BITS_PER_BYTE - 1;

drivers/spi/spi-imx.c

1666

tail_bl = (transfer->len % MX51_ECSPI_CTRL_MAX_BURST) * BITS_PER_BYTE - 1;

drivers/spi/spi-imx.c

2114

result = DIV_U64_ROUND_CLOSEST((u64)USEC_PER_SEC * transfer->len * BITS_PER_BYTE,

drivers/spi/spi-imx.c

2120

words = DIV_ROUND_UP(transfer->len * BITS_PER_BYTE, transfer->bits_per_word);

drivers/spi/spi-loopback-test.c

581

unsigned long long nbits = (unsigned long long)BITS_PER_BYTE *

drivers/spi/spi-mpfs.c

497

spi->n_bytes = roundup_pow_of_two(DIV_ROUND_UP(xfer->bits_per_word, BITS_PER_BYTE));

drivers/spi/spi-mtk-nor.c

190

dummy = op->dummy.nbytes * BITS_PER_BYTE / op->dummy.buswidth;

drivers/spi/spi-mtk-nor.c

391

delay = CLK_TO_US(sp, (length + 5) * BITS_PER_BYTE);

drivers/spi/spi-mtk-nor.c

454

ret = mtk_nor_cmd_exec(sp, MTK_NOR_CMD_READ, 6 * BITS_PER_BYTE);

drivers/spi/spi-mtk-nor.c

501

(op->data.nbytes + 5) * BITS_PER_BYTE);

drivers/spi/spi-mtk-nor.c

514

return mtk_nor_cmd_exec(sp, MTK_NOR_CMD_WRITE, 6 * BITS_PER_BYTE);

drivers/spi/spi-mtk-nor.c

548

bufbyte = (op->cmd.opcode >> ((i - 1) * BITS_PER_BYTE)) & 0xff;

drivers/spi/spi-mtk-nor.c

554

bufbyte = (op->addr.val >> ((i - 1) * BITS_PER_BYTE)) & 0xff;

drivers/spi/spi-mtk-nor.c

577

writel(prg_len * BITS_PER_BYTE + sp->caps->extra_dummy_bit,

drivers/spi/spi-mtk-nor.c

580

writel(prg_len * BITS_PER_BYTE, sp->base + MTK_NOR_REG_PRG_CNT);

drivers/spi/spi-mtk-nor.c

583

prg_len * BITS_PER_BYTE);

drivers/spi/spi-mtk-nor.c

679

writel(trx_len * BITS_PER_BYTE, sp->base + MTK_NOR_REG_PRG_CNT);

drivers/spi/spi-mtk-nor.c

682

trx_len * BITS_PER_BYTE);

drivers/spi/spi-mtk-snfi.c

1211

if (op->dummy.nbytes * BITS_PER_BYTE / op->dummy.buswidth >

drivers/spi/spi-mtk-snfi.c

870

u32 dummy_clk = (op->dummy.nbytes * BITS_PER_BYTE / op->dummy.buswidth);

drivers/spi/spi-qcom-qspi.c

560

*byte_buf++ = rd_fifo >> (i * BITS_PER_BYTE);

drivers/spi/spi-qup.c

279

shift = BITS_PER_BYTE;

drivers/spi/spi-qup.c

356

word |= data << (BITS_PER_BYTE * (3 - i));

drivers/spi/spi-uniphier.c

549

USEC_PER_SEC * BITS_PER_BYTE);

drivers/staging/media/ipu7/ipu7-isys-video.c

190

*bytesperline = *width * DIV_ROUND_UP(pfmt->bpp, BITS_PER_BYTE);

drivers/staging/media/ipu7/ipu7-isys-video.c

192

*bytesperline = DIV_ROUND_UP(*width * pfmt->bpp, BITS_PER_BYTE);

drivers/staging/media/ipu7/ipu7-isys-video.c

383

if (pfmt->bpp == pfmt->bpp_packed && pfmt->bpp % BITS_PER_BYTE)

drivers/tty/serial/qcom_geni_serial.c

1142

(port->tx_fifo_depth * port->tx_fifo_width) / BITS_PER_BYTE;

drivers/tty/serial/qcom_geni_serial.c

1225

geni_se_config_packing(&port->se, BITS_PER_BYTE, BYTES_PER_FIFO_WORD,

drivers/tty/serial/qcom_geni_serial.c

1540

bits_per_char = BITS_PER_BYTE;

drivers/tty/serial/qcom_geni_serial.c

1548

geni_se_config_packing(&se, BITS_PER_BYTE, BYTES_PER_FIFO_WORD,

drivers/tty/serial/qcom_geni_serial.c

520

private_data->write_cached_bytes >>= BITS_PER_BYTE *

drivers/usb/cdns3/cdns3-gadget.c

1997

sizeof(u32) * BITS_PER_BYTE) {

drivers/usb/gadget/udc/cdns2/cdns2-gadget.c

1317

for_each_set_bit(bit, &dma_ep_ists, sizeof(u32) * BITS_PER_BYTE) {

drivers/vfio/pci/pds/dirty.c

205

page_count / BITS_PER_BYTE);

drivers/vfio/pci/pds/dirty.c

224

dev_bmp_offset_byte += page_count / BITS_PER_BYTE;

drivers/vfio/pci/pds/dirty.c

225

if (dev_bmp_offset_byte % BITS_PER_BYTE) {

drivers/vfio/pci/pds/dirty.c

549

round_up(pages, sizeof(u64) * BITS_PER_BYTE) / BITS_PER_BYTE;

drivers/vfio/vfio_iommu_type1.c

142

#define DIRTY_BITMAP_BYTES(n) (ALIGN(n, BITS_PER_TYPE(u64)) / BITS_PER_BYTE)

drivers/video/fbdev/core/cfbmem.h

20

ptr.address = PTR_ALIGN_DOWN(base, BITS_PER_LONG / BITS_PER_BYTE);

drivers/video/fbdev/core/cfbmem.h

21

ptr.bits = (base - ptr.address) * BITS_PER_BYTE;

drivers/video/fbdev/core/cfbmem.h

29

fb_writel(val, dst->address + offset * (BITS_PER_LONG / BITS_PER_BYTE));

drivers/video/fbdev/core/cfbmem.h

31

fb_writeq(val, dst->address + offset * (BITS_PER_LONG / BITS_PER_BYTE));

drivers/video/fbdev/core/cfbmem.h

39

return fb_readl(src->address + offset * (BITS_PER_LONG / BITS_PER_BYTE));

drivers/video/fbdev/core/cfbmem.h

41

return fb_readq(src->address + offset * (BITS_PER_LONG / BITS_PER_BYTE));

drivers/video/fbdev/core/fb_copyarea.h

399

!((src.bits ^ dst.bits) & (BITS_PER_BYTE-1)))) {

drivers/video/fbdev/core/fb_draw.h

155

reverse.pixel = info->var.bits_per_pixel < BITS_PER_BYTE

drivers/video/fbdev/core/fb_draw.h

18

adr->address += offset * (BITS_PER_LONG / BITS_PER_BYTE);

drivers/video/fbdev/core/fb_draw.h

27

adr->address += (bits & ~(BITS_PER_LONG - 1u)) / BITS_PER_BYTE;

drivers/video/fbdev/core/fb_draw.h

37

adr->address -= (adr->bits - bits) / BITS_PER_BYTE;

drivers/video/fbdev/core/fb_draw.h

39

adr->address += (bits - adr->bits) / BITS_PER_BYTE;

drivers/video/fbdev/core/fb_imageblit.h

100

data = *iter->data++ >> BITS_PER_BYTE/2;

drivers/video/fbdev/core/fb_imageblit.h

102

data = iter->data[-1] & ((1 << BITS_PER_BYTE/2)-1);

drivers/video/fbdev/core/fb_imageblit.h

106

data = iter->data[-1] & ((1 << BITS_PER_BYTE/2)-1);

drivers/video/fbdev/core/fb_imageblit.h

108

data = *iter->data++ >> BITS_PER_BYTE/2;

drivers/video/fbdev/core/fb_imageblit.h

110

data >>= BITS_PER_BYTE/2 - iter->i;

drivers/video/fbdev/core/fb_imageblit.h

114

*bits = iter->bpp * BITS_PER_BYTE/2;

drivers/video/fbdev/core/fb_imageblit.h

180

iter.shift = BITS_PER_BYTE - bpp;

drivers/video/fbdev/core/fb_imageblit.h

185

iter.shift = BITS_PER_LONG - BITS_PER_BYTE;

drivers/video/fbdev/core/fb_imageblit.h

219

static const u32 mul[BITS_PER_BYTE] = {

drivers/video/fbdev/core/fb_imageblit.h

222

static const u32 expand[BITS_PER_BYTE][1 << 4] = {

drivers/video/fbdev/core/fb_imageblit.h

237

fgcolor = fb_reverse_bits_long(fgcolor << (BITS_PER_BYTE - bpp));

drivers/video/fbdev/core/fb_imageblit.h

238

bgcolor = fb_reverse_bits_long(bgcolor << (BITS_PER_BYTE - bpp));

drivers/video/fbdev/core/fb_imageblit.h

250

fb_bitblit(fb_bitmap4x_image, &iter, bpp * BITS_PER_BYTE/2, dst, reverse);

drivers/video/fbdev/core/fb_imageblit.h

416

if (BITS_PER_LONG/4 > BITS_PER_BYTE && reverse.byte) {

drivers/video/fbdev/core/fb_imageblit.h

42

int bit = ~iter->i & (BITS_PER_BYTE-1);

drivers/video/fbdev/core/fb_imageblit.h

43

int byte = iter->i++ / BITS_PER_BYTE;

drivers/video/fbdev/core/fb_imageblit.h

473

if (bpp > 0 && bpp <= BITS_PER_BYTE)

drivers/video/fbdev/core/fb_imageblit.h

476

else if (bpp > BITS_PER_BYTE && bpp <= BITS_PER_LONG)

drivers/video/fbdev/core/fb_imageblit.h

96

if (iter->i >= BITS_PER_BYTE/2) {

drivers/video/fbdev/core/fb_imageblit.h

97

iter->i -= BITS_PER_BYTE/2;

drivers/video/fbdev/core/sysmem.h

20

ptr.address = PTR_ALIGN_DOWN(base, BITS_PER_LONG / BITS_PER_BYTE);

drivers/video/fbdev/core/sysmem.h

21

ptr.bits = (base - ptr.address) * BITS_PER_BYTE;

drivers/w1/masters/w1-uart.c

133

bit_ns * BITS_PER_BYTE < low_ns + to_ns(limits->sample_us))

drivers/w1/masters/w1-uart.c

25

#define W1_UART_BITS_PER_PACKET (BITS_PER_BYTE + 2)

drivers/xen/sys-hypervisor.c

408

#define FLAG_COUNT (sizeof(xen_start_flags) * BITS_PER_BYTE)

fs/btrfs/extent_io.c

4301

return 1U & (kaddr[offset] >> (nr & (BITS_PER_BYTE - 1)));

fs/btrfs/extent_io.h

74

#define BIT_BYTE(nr) ((nr) / BITS_PER_BYTE)

fs/btrfs/extent_io.h

75

#define BYTE_MASK ((1U << BITS_PER_BYTE) - 1)

fs/btrfs/extent_io.h

77

((BYTE_MASK << ((start) & (BITS_PER_BYTE - 1))) & BYTE_MASK)

fs/btrfs/extent_io.h

79

(BYTE_MASK >> (-(nbits) & (BITS_PER_BYTE - 1)))

fs/btrfs/free-space-tree.c

155

return DIV_ROUND_UP(size >> fs_info->sectorsize_bits, BITS_PER_BYTE);

fs/btrfs/free-space-tree.c

180

int bits_to_set = BITS_PER_BYTE - (start % BITS_PER_BYTE);

fs/btrfs/free-space-tree.c

186

bits_to_set = BITS_PER_BYTE;

fs/btrfs/free-space-tree.c

396

BITS_PER_BYTE);

fs/btrfs/free-space-tree.h

23

#define BTRFS_FREE_SPACE_BITMAP_BITS (BTRFS_FREE_SPACE_BITMAP_SIZE * BITS_PER_BYTE)

fs/btrfs/relocation.c

4520

data_size * BITS_PER_BYTE,

fs/btrfs/tests/extent-io-tests.c

345

for (i = 0; i < eb->len * BITS_PER_BYTE; i++) {

fs/btrfs/tests/extent-io-tests.c

354

read_extent_buffer(eb, &has, i / BITS_PER_BYTE, 1);

fs/btrfs/tests/extent-io-tests.c

355

expect = bitmap_get_value8(bitmap, ALIGN(i, BITS_PER_BYTE));

fs/btrfs/tests/extent-io-tests.c

359

i, i / BITS_PER_BYTE, has, expect);

fs/btrfs/tests/extent-io-tests.c

363

bit1_set = extent_buffer_test_bit(eb, i / BITS_PER_BYTE,

fs/btrfs/tests/extent-io-tests.c

364

i % BITS_PER_BYTE);

fs/btrfs/tests/extent-io-tests.c

369

read_extent_buffer(eb, &has, i / BITS_PER_BYTE, 1);

fs/btrfs/tests/extent-io-tests.c

370

expect = bitmap_get_value8(bitmap, ALIGN(i, BITS_PER_BYTE));

fs/btrfs/tests/extent-io-tests.c

374

i / BITS_PER_BYTE, i % BITS_PER_BYTE,

fs/btrfs/tests/extent-io-tests.c

375

i / BITS_PER_BYTE, has, expect);

fs/btrfs/tests/extent-io-tests.c

389

bitmap_set(bitmap, byte_start * BITS_PER_BYTE + bit_start, bit_len);

fs/btrfs/tests/extent-io-tests.c

404

bitmap_clear(bitmap, byte_start * BITS_PER_BYTE + bit_start, bit_len);

fs/btrfs/tests/extent-io-tests.c

419

byte_len * BITS_PER_BYTE);

fs/btrfs/tests/extent-io-tests.c

423

ret = test_bitmap_set("set all", bitmap, eb, 0, 0, byte_len * BITS_PER_BYTE);

fs/btrfs/tests/extent-io-tests.c

428

byte_len * BITS_PER_BYTE);

fs/btrfs/tests/extent-io-tests.c

460

sizeof(long) * BITS_PER_BYTE);

fs/btrfs/tests/extent-io-tests.c

465

byte_len * BITS_PER_BYTE);

fs/btrfs/tests/extent-io-tests.c

471

sizeof(long) * BITS_PER_BYTE);

fs/btrfs/tests/extent-io-tests.c

482

byte_len * BITS_PER_BYTE);

fs/btrfs/tests/extent-io-tests.c

486

for (i = 0; i < byte_len * BITS_PER_BYTE / 32; i++) {

fs/ceph/mds_client.c

3327

old_max_retry = 1 << (old_max_retry * BITS_PER_BYTE);

fs/exfat/balloc.c

85

need_map_size = ((EXFAT_DATA_CLUSTER_COUNT(sbi) - 1) / BITS_PER_BYTE)

fs/exfat/exfat_fs.h

129

#define BITS_PER_SECTOR(sb) ((sb)->s_blocksize * BITS_PER_BYTE)

fs/exfat/exfat_fs.h

132

((ent / BITS_PER_BYTE) >> (sb)->s_blocksize_bits)

fs/exfat/exfat_fs.h

135

((ent / BITS_PER_BYTE) & ((sb)->s_blocksize - 1))

fs/ext2/balloc.c

1440

return numchars * BITS_PER_BYTE - memweight(map->b_data, numchars);

fs/ext4/bitmap.c

16

return numchars * BITS_PER_BYTE - memweight(bitmap, numchars);

fs/f2fs/f2fs.h

597

#define NR_INLINE_DENTRY(inode) (MAX_INLINE_DATA(inode) * BITS_PER_BYTE / \

fs/f2fs/f2fs.h

599

BITS_PER_BYTE + 1))

fs/f2fs/f2fs.h

601

DIV_ROUND_UP(NR_INLINE_DENTRY(inode), BITS_PER_BYTE)

fs/f2fs/node.c

3251

unsigned int nat_bits_bytes = nm_i->nat_blocks / BITS_PER_BYTE;

fs/f2fs/segment.c

45

shift -= BITS_PER_BYTE;

fs/f2fs/super.c

4285

nat_bits_bytes = nat_blocks / BITS_PER_BYTE;

fs/f2fs/super.c

4593

if (sbi->stop_reason[reason] < GENMASK(BITS_PER_BYTE - 1, 0))

fs/file.c

225

2 * nr / BITS_PER_BYTE + BITBIT_SIZE(nr), L1_CACHE_BYTES),

fs/file.c

230

data += nr / BITS_PER_BYTE;

fs/file.c

232

data += nr / BITS_PER_BYTE;

fs/hpfs/super.c

144

count = bitmap_weight(bits, 2048 * BITS_PER_BYTE);

fs/qnx4/bitmap.c

37

total_free += bytes * BITS_PER_BYTE -

include/linux/bitmap.h

232

#define bitmap_size(nbits) (ALIGN(nbits, BITS_PER_LONG) / BITS_PER_BYTE)

include/linux/bitmap.h

845

bitmap_read(map, start, BITS_PER_BYTE)

include/linux/bitmap.h

847

bitmap_write(map, value, start, BITS_PER_BYTE)

include/linux/bitops.h

16

#define BYTES_TO_BITS(nb) ((nb) * BITS_PER_BYTE)

include/linux/bits.h

13

#define BITS_PER_TYPE(type) (sizeof(type) * BITS_PER_BYTE)

include/linux/can/length.h

187

(data_len) * BITS_PER_BYTE + \

include/linux/can/length.h

199

(data_len) * BITS_PER_BYTE) + \

include/linux/can/length.h

243

BITS_PER_BYTE)

include/linux/context_tracking_state.h

56

#define CT_SIZE (sizeof(((struct context_tracking *)0)->state) * BITS_PER_BYTE)

include/linux/f2fs_fs.h

595

#define NR_DENTRY_IN_BLOCK ((BITS_PER_BYTE * F2FS_BLKSIZE) / \

include/linux/f2fs_fs.h

596

((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * BITS_PER_BYTE + 1))

include/linux/f2fs_fs.h

598

#define SIZE_OF_DENTRY_BITMAP ((NR_DENTRY_IN_BLOCK + BITS_PER_BYTE - 1) / \

include/linux/f2fs_fs.h

599

BITS_PER_BYTE)

include/linux/firmware/cirrus/cs_dsp.h

38

#define CS_DSP_DATA_WORD_BITS (3 * BITS_PER_BYTE)

include/linux/mm_types.h

344

#define MM_ID_BITS ((sizeof(mm_id_t) * BITS_PER_BYTE) - 1)

include/linux/packing.h

67

BUILD_BUG_ON_MSG(__f.startbit - __f.endbit >= BITS_PER_BYTE * __f.size, \

include/linux/packing.h

86

BUILD_BUG_ON_MSG(_f[0].startbit >= BITS_PER_BYTE * _len, \

include/linux/packing.h

88

BUILD_BUG_ON_MSG(_f[num_fields - 1].startbit >= BITS_PER_BYTE * _len, \

include/linux/units.h

60

#define BYTES_PER_KBIT (KILO / BITS_PER_BYTE)

include/linux/units.h

61

#define BYTES_PER_MBIT (MEGA / BITS_PER_BYTE)

include/linux/units.h

62

#define BYTES_PER_GBIT (GIGA / BITS_PER_BYTE)

include/net/ip_tunnels.h

104

options_len) * BITS_PER_BYTE) - 1, 0)

include/net/netfilter/nf_conntrack_labels.h

14

#define NF_CT_LABELS_MAX_SIZE ((XT_CONNLABEL_MAXBIT + 1) / BITS_PER_BYTE)

include/net/netfilter/nf_tables.h

1632

#define NFT_SET_ELEM_DEAD_BIT (BITS_PER_LONG - BITS_PER_BYTE + 2)

include/net/pie.h

11

#define MAX_PROB (U64_MAX >> BITS_PER_BYTE)

include/rdma/rdmavt_qp.h

471

#define RVT_QPNMAP_ENTRIES (RVT_QPN_MAX / PAGE_SIZE / BITS_PER_BYTE)

include/rdma/rdmavt_qp.h

472

#define RVT_BITS_PER_PAGE (PAGE_SIZE * BITS_PER_BYTE)

kernel/bpf/btf.c

178

#define BITS_PER_U128 (sizeof(u64) * BITS_PER_BYTE * 2)

kernel/bpf/btf.c

179

#define BITS_PER_BYTE_MASK (BITS_PER_BYTE - 1)

kernel/bpf/btf.c

4408

u32 int_bitsize = sizeof(int) * BITS_PER_BYTE;

kernel/bpf/btf.c

5041

align_bits = align_bytes * BITS_PER_BYTE;

kernel/bpf/btf.c

5049

start_offset_bytes = member->offset / BITS_PER_BYTE;

kernel/bpf/verifier.c

5310

reg_value_fits = get_reg_width(reg) <= BITS_PER_BYTE * size;

kernel/bpf/verifier.c

5608

if (get_reg_width(reg) > size * BITS_PER_BYTE)

kernel/compat.c

150

if ((len * BITS_PER_BYTE) < nr_cpu_ids)

kernel/events/core.c

7741

for_each_set_bit(bit, _mask, sizeof(mask) * BITS_PER_BYTE) {

kernel/kcsan/core.c

1176

check_access(ptr, bits / BITS_PER_BYTE, KCSAN_ACCESS_ATOMIC, _RET_IP_); \

kernel/kcsan/core.c

1186

check_access(ptr, bits / BITS_PER_BYTE, \

kernel/kcsan/core.c

1199

check_access(ptr, bits / BITS_PER_BYTE, \

kernel/kcsan/core.c

1232

check_access(ptr, bits / BITS_PER_BYTE, \

kernel/kcsan/core.c

1248

check_access(ptr, bits / BITS_PER_BYTE, \

kernel/power/snapshot.c

374

#define BM_BITS_PER_BLOCK (PAGE_SIZE * BITS_PER_BYTE)

kernel/sched/syscalls.c

1307

if ((len * BITS_PER_BYTE) < nr_cpu_ids)

kernel/trace/fgraph.c

1301

sizeof(fgraph_array_bitmask) * BITS_PER_BYTE) {

kernel/trace/fgraph.c

686

sizeof(fgraph_array_bitmask) * BITS_PER_BYTE) {

kernel/trace/fgraph.c

856

for_each_set_bit(i, &bitmap, sizeof(bitmap) * BITS_PER_BYTE) {

kernel/trace/trace_events_user.c

2433

if (kreg->enable_bit > (kreg->enable_size * BITS_PER_BYTE) - 1)

lib/packing.c

118

box_start_bit = startbit % BITS_PER_BYTE;

lib/packing.c

122

box_end_bit = endbit % BITS_PER_BYTE;

lib/packing.c

133

proj_start_bit = ((box * BITS_PER_BYTE) + box_start_bit) - endbit;

lib/packing.c

134

proj_end_bit = ((box * BITS_PER_BYTE) + box_end_bit) - endbit;

lib/packing.c

185

if (unlikely(startbit < endbit || startbit >= BITS_PER_BYTE * pbuflen))

lib/packing.c

204

int plogical_first_u8 = startbit / BITS_PER_BYTE;

lib/packing.c

205

int plogical_last_u8 = endbit / BITS_PER_BYTE;

lib/packing.c

229

box_start_bit = startbit % BITS_PER_BYTE;

lib/packing.c

233

box_end_bit = endbit % BITS_PER_BYTE;

lib/packing.c

244

proj_start_bit = ((box * BITS_PER_BYTE) + box_start_bit) - endbit;

lib/packing.c

245

proj_end_bit = ((box * BITS_PER_BYTE) + box_end_bit) - endbit;

lib/packing.c

299

if (startbit < endbit || startbit >= BITS_PER_BYTE * pbuflen)

lib/packing.c

87

int plogical_first_u8 = startbit / BITS_PER_BYTE;

lib/packing.c

88

int plogical_last_u8 = endbit / BITS_PER_BYTE;

lib/random32.c

89

rem >>= BITS_PER_BYTE;

lib/test_bitmap.c

1168

{ small_bitmap, sizeof(small_bitmap) * BITS_PER_BYTE, small_mask, small_list },

lib/test_bitmap.c

1169

{ large_bitmap, sizeof(large_bitmap) * BITS_PER_BYTE, large_mask, large_list },

mm/cma_debug.c

188

BITS_PER_BYTE * sizeof(u32));

mm/hugetlb.c

4134

BUILD_BUG_ON(sizeof_field(struct page, private) * BITS_PER_BYTE <

mm/kasan/kasan_test_c.c

1782

kasan_bitops_test_and_modify(test, BITS_PER_LONG + BITS_PER_BYTE, bits);

mm/kasan/kasan_test_c.c

1800

kasan_bitops_test_and_modify(test, BITS_PER_LONG + BITS_PER_BYTE, (void *)bits + 48);

mm/mempolicy.c

1665

if (maxnode > PAGE_SIZE*BITS_PER_BYTE)

mm/mm_init.c

1486

return usemapsize / BITS_PER_BYTE;

mm/page_idle.c

130

pfn = pos * BITS_PER_BYTE;

mm/page_idle.c

134

end_pfn = pfn + count * BITS_PER_BYTE;

mm/page_idle.c

175

pfn = pos * BITS_PER_BYTE;

mm/page_idle.c

179

end_pfn = pfn + count * BITS_PER_BYTE;

mm/page_idle.c

19

#define BITMAP_CHUNK_BITS (BITMAP_CHUNK_SIZE * BITS_PER_BYTE)

mm/swap_table.h

43

BITS_PER_BYTE * sizeof(unsigned long));

mm/swapfile.c

539

BUILD_BUG_ON(1 << sizeof(ci->flags) * BITS_PER_BYTE < CLUSTER_FLAG_MAX);

mm/vmalloc.c

1011

return (node_id + 1) << BITS_PER_BYTE;

mm/vmalloc.c

1026

unsigned int node_id = (val >> BITS_PER_BYTE) - 1;

net/core/dev.c

11332

BUILD_BUG_ON(sizeof(netdev_features_t) * BITS_PER_BYTE <

net/core/dev.c

12901

BITS_PER_BYTE * sizeof_field(struct gro_node, bitmask));

net/core/neighbour.c

2051

BUILD_BUG_ON(sizeof(neigh->flags) * BITS_PER_BYTE <

net/core/neighbour.c

2052

(sizeof(ndm->ndm_flags) * BITS_PER_BYTE +

net/ethtool/features.c

147

const unsigned int nft_bits = sizeof(netdev_features_t) * BITS_PER_BYTE;

net/ethtool/strset.c

159

BUILD_BUG_ON(ETH_SS_COUNT >= BITS_PER_BYTE * sizeof(info->req_ids));

net/ipv4/udp_tunnel_nic.c

795

BUILD_BUG_ON(sizeof(utn->missed) * BITS_PER_BYTE <

net/mac80211/mesh.c

1171

for_each_set_bit(bit, bits, sizeof(changed) * BITS_PER_BYTE)

net/mac80211/mesh.c

1732

sizeof(changed) * BITS_PER_BYTE) {

net/netfilter/nf_conntrack_h323_asn1.c

168

bytes += bits / BITS_PER_BYTE;

net/netfilter/nf_conntrack_h323_asn1.c

169

if (bits % BITS_PER_BYTE > 0)

net/netfilter/nf_tables_api.c

4780

if (tmp < min || tmp >= min + BITS_PER_BYTE * PAGE_SIZE)

net/netfilter/nf_tables_api.c

4786

n = find_first_zero_bit(inuse, BITS_PER_BYTE * PAGE_SIZE);

net/netfilter/nf_tables_api.c

4787

if (n >= BITS_PER_BYTE * PAGE_SIZE) {

net/netfilter/nf_tables_api.c

4788

min += BITS_PER_BYTE * PAGE_SIZE;

net/netfilter/nft_cmp.c

204

data) * BITS_PER_BYTE - len));

net/netfilter/nft_cmp.c

229

desc.len *= BITS_PER_BYTE;

net/netfilter/nft_cmp.c

250

.len = priv->len / BITS_PER_BYTE,

net/netfilter/nft_cmp.c

271

NFT_DATA_VALUE, priv->len / BITS_PER_BYTE) < 0)

net/netfilter/nft_cmp.c

291

return (__force u32)cpu_to_le32(~0U >> (sizeof(u32) * BITS_PER_BYTE - bitlen));

net/netfilter/nft_cmp.c

296

int len = bitlen / BITS_PER_BYTE;

net/netfilter/nft_cmp.c

301

bitlen -= sizeof(u32) * BITS_PER_BYTE;

net/netfilter/nft_cmp.c

330

nft_cmp16_fast_mask(&priv->mask, desc.len * BITS_PER_BYTE);

net/netfilter/nft_ct.c

427

err = nf_connlabels_get(ctx->net, (len * BITS_PER_BYTE) - 1);

net/netfilter/nft_ct.c

582

err = nf_connlabels_get(ctx->net, (len * BITS_PER_BYTE) - 1);

net/netfilter/nft_payload.c

297

remainder_mask = htonl(~((1 << (delta * BITS_PER_BYTE)) - 1));

net/netfilter/nft_set_bitmap.c

249

return ((2 << ((klen * BITS_PER_BYTE) - 1)) / BITS_PER_BYTE) << 1;

net/netfilter/nft_set_bitmap.c

64

*idx = k / BITS_PER_BYTE;

net/netfilter/nft_set_bitmap.c

65

*off = k % BITS_PER_BYTE;

net/netfilter/nft_set_pipapo.c

1005

v = k[group / (BITS_PER_BYTE / f->bb)];

net/netfilter/nft_set_pipapo.c

1006

v &= GENMASK(BITS_PER_BYTE - bit_offset - 1, 0);

net/netfilter/nft_set_pipapo.c

1007

v >>= (BITS_PER_BYTE - bit_offset) - f->bb;

net/netfilter/nft_set_pipapo.c

1010

bit_offset %= BITS_PER_BYTE;

net/netfilter/nft_set_pipapo.c

1049

return !(BIT(step % BITS_PER_BYTE) & base[step / BITS_PER_BYTE]);

net/netfilter/nft_set_pipapo.c

1051

return !(BIT(step % BITS_PER_BYTE) &

net/netfilter/nft_set_pipapo.c

1052

base[len - 1 - step / BITS_PER_BYTE]);

net/netfilter/nft_set_pipapo.c

1078

tmp[i / BITS_PER_BYTE] |= BIT(i % BITS_PER_BYTE);

net/netfilter/nft_set_pipapo.c

1080

tmp[len - 1 - i / BITS_PER_BYTE] |= BIT(i % BITS_PER_BYTE);

net/netfilter/nft_set_pipapo.c

1099

for (i = step / BITS_PER_BYTE; i < len; i++) {

net/netfilter/nft_set_pipapo.c

1101

for (i = len - 1 - step / BITS_PER_BYTE; i >= 0; i--) {

net/netfilter/nft_set_pipapo.c

1106

base[i] += 1 << (step % BITS_PER_BYTE);

net/netfilter/nft_set_pipapo.c

1130

int step, masks = 0, bytes = DIV_ROUND_UP(len, BITS_PER_BYTE);

net/netfilter/nft_set_pipapo.c

2009

*l |= x0 << (BITS_PER_BYTE - f->bb - bit_offset);

net/netfilter/nft_set_pipapo.c

2010

*r |= x1 << (BITS_PER_BYTE - f->bb - bit_offset);

net/netfilter/nft_set_pipapo.c

2013

if (bit_offset >= BITS_PER_BYTE) {

net/netfilter/nft_set_pipapo.c

2014

bit_offset %= BITS_PER_BYTE;

net/netfilter/nft_set_pipapo.c

2301

BITS_PER_BYTE / NFT_PIPAPO_GROUP_BITS_LARGE_SET) >= 256);

net/netfilter/nft_set_pipapo.h

16

#define NFT_PIPAPO_MAX_BITS (NFT_PIPAPO_MAX_BYTES * BITS_PER_BYTE)

net/netfilter/nft_set_pipapo.h

198

for (group = 0; group < f->groups; group += BITS_PER_BYTE / 4, data++) {

net/netfilter/nft_set_pipapo.h

25

#define NFT_PIPAPO_GROUPS_PER_BYTE(f) (BITS_PER_BYTE / (f)->bb)

net/netfilter/nft_set_pipapo.h

264

rules = ilog2(desc->field_len[i] * BITS_PER_BYTE) * 2;

net/netfilter/nft_set_pipapo.h

267

BITS_PER_BYTE;

net/netfilter/nft_set_pipapo_avx2.c

128

memset(data, 0xff, len / BITS_PER_BYTE);

net/netfilter/nft_set_pipapo_avx2.h

6

#define NFT_PIPAPO_ALIGN (XSAVE_YMM_SIZE / BITS_PER_BYTE)

net/openvswitch/conntrack.c

2001

unsigned int n_bits = sizeof(struct ovs_key_ct_labels) * BITS_PER_BYTE;

net/sched/act_ct.c

1141

.len = 128 / BITS_PER_BYTE },

net/sched/act_ct.c

1143

.len = 128 / BITS_PER_BYTE },

net/sched/cls_flower.c

733

.len = 128 / BITS_PER_BYTE },

net/sched/cls_flower.c

735

.len = 128 / BITS_PER_BYTE },

net/sched/sch_hhf.c

636

BITS_PER_BYTE, GFP_KERNEL);

net/sched/sch_pie.c

504

.prob = q->vars.prob << BITS_PER_BYTE,

net/sched/sch_pie.c

76

if ((rnd >> BITS_PER_BYTE) < local_prob) {

samples/trace_events/trace-events-sample.h

582

BITS_PER_BYTE * sizeof(unsigned long) )

samples/trace_events/trace-events-sample.h

590

BITS_PER_BYTE * sizeof(unsigned long));

sound/soc/sdca/sdca_asoc.c

1325

static_assert(sizeof(channel_mask) * BITS_PER_BYTE >= SDCA_MAX_CHANNEL_COUNT);

sound/soc/sdca/sdca_interrupts.c

119

for_each_set_bit(mask, &status, BITS_PER_BYTE) {

sound/soc/sdca/sdca_interrupts.c

30

#define IRQ_SDCA(number) REGMAP_IRQ_REG(number, ((number) / BITS_PER_BYTE), \

sound/soc/sdca/sdca_regmap.c

194

return clamp_val(control->nbits / BITS_PER_BYTE, sizeof(u8), sizeof(u32));

sound/soc/soc-ops.c

717

unsigned int regwshift = component->val_bytes * BITS_PER_BYTE;

sound/soc/soc-ops.c

761

unsigned int regwshift = component->val_bytes * BITS_PER_BYTE;

tools/bpf/bpftool/btf_dumper.c

18

#define BITS_PER_BYTE_MASK (BITS_PER_BYTE - 1)

tools/include/linux/bitmap.h

35

#define bitmap_size(nbits) (ALIGN(nbits, BITS_PER_LONG) / BITS_PER_BYTE)

tools/include/linux/bitops.h

17

#define BITS_PER_TYPE(type) (sizeof(type) * BITS_PER_BYTE)

tools/include/linux/bitops.h

23

#define BYTES_TO_BITS(nb) ((nb) * BITS_PER_BYTE)

tools/include/linux/bits.h

13

#define BITS_PER_TYPE(type) (sizeof(type) * BITS_PER_BYTE)

tools/perf/util/cpumap.c

109

int cpus_per_i = (i * data->mask32_data.long_size * BITS_PER_BYTE);

tools/testing/selftests/iommu/iommufd.c

2154

size = DIV_ROUND_UP(self->bitmap_size, BITS_PER_BYTE);

tools/testing/selftests/iommu/iommufd_utils.h

469

unsigned long bitmap_size = DIV_ROUND_UP(nbits, BITS_PER_BYTE);

tools/testing/selftests/kvm/include/x86/processor.h

129

kvm_static_assert(idx < BIT(sizeof(feature.index) * BITS_PER_BYTE)); \

tools/testing/selftests/kvm/include/x86/processor.h

262

kvm_static_assert(idx < BIT(sizeof(property.index) * BITS_PER_BYTE)); \