arch/arm/mach-omap2/control.c

328

sdrc_block_contents.block_size = 0x0;

arch/arm/mach-omap2/control.c

83

u32 block_size;

arch/arm/mm/cache-l2x0.c

952

u32 block_size = 0;

arch/arm/mm/cache-l2x0.c

957

of_property_read_u32(np, "cache-block-size", &block_size);

arch/arm/mm/cache-l2x0.c

965

if (block_size) {

arch/arm/mm/cache-l2x0.c

967

line_size = block_size;

arch/arm64/include/asm/kvm_nested.h

105

return trans->block_size;

arch/arm64/include/asm/kvm_nested.h

90

unsigned long block_size;

arch/arm64/kvm/hyp/nvhe/mem_protect.c

943

size_t block_size;

arch/arm64/kvm/hyp/nvhe/mem_protect.c

951

block_size = kvm_granule_size(KVM_PGTABLE_LAST_LEVEL - 1);

arch/arm64/kvm/hyp/nvhe/mem_protect.c

953

if (nr_pages != block_size >> PAGE_SHIFT)

arch/arm64/kvm/hyp/nvhe/mem_protect.c

956

if (!IS_ALIGNED(phys | ipa, block_size))

arch/arm64/kvm/hyp/nvhe/mem_protect.c

959

*size = block_size;

arch/arm64/kvm/nested.c

373

out->block_size = 1UL << ((3 - level) * stride + wi->pgshift);

arch/openrisc/include/asm/cpuinfo.h

24

u32 block_size;

arch/openrisc/kernel/cacheinfo.c

22

this_leaf->coherency_line_size = cache->block_size;

arch/openrisc/kernel/cacheinfo.c

47

cpuinfo->dcache.block_size = 16 << ((dccfgr & SPR_DCCFGR_CBS) >> 7);

arch/openrisc/kernel/cacheinfo.c

49

cpuinfo->dcache.sets * cpuinfo->dcache.ways * cpuinfo->dcache.block_size;

arch/openrisc/kernel/cacheinfo.c

53

cpuinfo->dcache.size, cpuinfo->dcache.block_size,

arch/openrisc/kernel/cacheinfo.c

62

cpuinfo->icache.block_size = 16 << ((iccfgr & SPR_ICCFGR_CBS) >> 7);

arch/openrisc/kernel/cacheinfo.c

64

cpuinfo->icache.sets * cpuinfo->icache.ways * cpuinfo->icache.block_size;

arch/openrisc/kernel/cacheinfo.c

68

cpuinfo->icache.size, cpuinfo->icache.block_size,

arch/powerpc/include/asm/cache.h

46

u32 block_size; /* L1 only */

arch/powerpc/include/asm/cache.h

69

return ppc64_caches.l1d.block_size;

arch/powerpc/include/asm/cache.h

79

return ppc64_caches.l1i.block_size;

arch/powerpc/include/asm/page_64.h

55

onex = ppc64_caches.l1d.block_size;

arch/powerpc/kernel/asm-offsets.c

178

OFFSET(DCACHEL1BLOCKSIZE, ppc64_caches, l1d.block_size);

arch/powerpc/kernel/rtas_flash.c

167

unsigned long block_size, image_size;

arch/powerpc/kernel/rtas_flash.c

176

block_size = f->blocks[i].length;

arch/powerpc/kernel/rtas_flash.c

177

if (block_size <= 0 || block_size > RTAS_BLK_SIZE) {

arch/powerpc/kernel/rtas_flash.c

180

image_size += block_size;

arch/powerpc/kernel/setup_64.c

553

info->block_size = bsize;

arch/powerpc/kernel/setup_64.c

676

dcache_bsize = ppc64_caches.l1d.block_size;

arch/powerpc/kernel/setup_64.c

677

icache_bsize = ppc64_caches.l1i.block_size;

arch/powerpc/kernel/setup_64.c

80

.block_size = 0x40,

arch/powerpc/kernel/setup_64.c

84

.block_size = 0x40,

arch/powerpc/kernel/vdso.c

261

vdso_k_arch_data->dcache_block_size = ppc64_caches.l1d.block_size;

arch/powerpc/kernel/vdso.c

262

vdso_k_arch_data->icache_block_size = ppc64_caches.l1i.block_size;

arch/powerpc/mm/book3s64/hash_utils.c

937

long unsigned int block_size;

arch/powerpc/mm/book3s64/hash_utils.c

955

block_size = be64_to_cpu(addr_prop[1]);

arch/powerpc/mm/book3s64/hash_utils.c

956

if (block_size != (16 * GB))

arch/powerpc/mm/book3s64/hash_utils.c

960

phys_addr, block_size, expected_pages);

arch/powerpc/mm/book3s64/hash_utils.c

961

if (phys_addr + block_size * expected_pages <= memblock_end_of_DRAM()) {

arch/powerpc/mm/book3s64/hash_utils.c

962

memblock_reserve(phys_addr, block_size * expected_pages);

arch/powerpc/mm/book3s64/hash_utils.c

963

pseries_add_gpage(phys_addr, block_size, expected_pages);

arch/powerpc/mm/init_64.c

513

static void update_memory_block_size(unsigned long *block_size, unsigned long mem_size)

arch/powerpc/mm/init_64.c

517

for (; *block_size > min_memory_block_size; *block_size >>= 2) {

arch/powerpc/mm/init_64.c

518

if ((mem_size & *block_size) == 0)

arch/powerpc/mm/init_64.c

527

unsigned long *block_size = (unsigned long *)data;

arch/powerpc/mm/init_64.c

547

*block_size = DEFAULT_MEMORY_BLOCK_SIZE;

arch/powerpc/mm/init_64.c

549

*block_size = of_read_number(prop, dt_root_size_cells);

arch/powerpc/mm/init_64.c

586

update_memory_block_size(block_size, size);

arch/powerpc/mm/init_64.c

598

if (*block_size > SZ_256M)

arch/powerpc/mm/init_64.c

599

*block_size = SZ_256M;

arch/powerpc/platforms/pseries/lpar.c

1433

unsigned int block_size)

arch/powerpc/platforms/pseries/lpar.c

1435

if (block_size > hblkrm_size[bpsize][psize])

arch/powerpc/platforms/pseries/lpar.c

1436

hblkrm_size[bpsize][psize] = block_size;

arch/powerpc/platforms/pseries/lpar.c

1450

unsigned int block_size)

arch/powerpc/platforms/pseries/lpar.c

1456

set_hblkrm_bloc_size(MMU_PAGE_4K, MMU_PAGE_4K, block_size);

arch/powerpc/platforms/pseries/lpar.c

1466

set_hblkrm_bloc_size(bpsize, psize, block_size);

arch/powerpc/platforms/pseries/lpar.c

1501

u32 block_size;

arch/powerpc/platforms/pseries/lpar.c

1507

block_size = 1 << block_shift;

arch/powerpc/platforms/pseries/lpar.c

1512

block_size);

arch/powerpc/platforms/pseries/papr_scm.c

1253

mapping.size = p->blocks * p->block_size; // XXX: potential overflow?

arch/powerpc/platforms/pseries/papr_scm.c

1364

u64 blocks, block_size;

arch/powerpc/platforms/pseries/papr_scm.c

1378

if (of_property_read_u64(dn, "ibm,block-size", &block_size)) {

arch/powerpc/platforms/pseries/papr_scm.c

1413

p->block_size = block_size;

arch/powerpc/platforms/pseries/papr_scm.c

1460

p->res.end = p->bound_addr + p->blocks * p->block_size - 1;

arch/powerpc/platforms/pseries/papr_scm.c

215

if ((end_addr - start_addr) != ((p->blocks - 1) * p->block_size))

arch/powerpc/platforms/pseries/papr_scm.c

57

uint64_t block_size;

arch/riscv/mm/cacheflush.c

121

const char *name, u32 *block_size,

arch/riscv/mm/cacheflush.c

133

if (!*block_size) {

arch/riscv/mm/cacheflush.c

134

*block_size = val;

arch/riscv/mm/cacheflush.c

136

} else if (*block_size != val) {

arch/s390/include/uapi/asm/vtoc.h

194

__u32 block_size; /* Disk block size */

block/bdev.c

1373

EXPORT_SYMBOL_GPL(block_size);

block/bdev.c

165

int bdev_validate_blocksize(struct block_device *bdev, int block_size)

block/bdev.c

167

if (blk_validate_block_size(block_size))

block/bdev.c

171

if (block_size < bdev_logical_block_size(bdev))

block/ioctl.c

784

return put_int(argp, block_size(bdev));

block/partitions/ibm.c

291

blocksize = label->cms.block_size;

block/partitions/mac.c

54

secsize = be16_to_cpu(md->block_size);

block/partitions/mac.h

40

__be16 block_size;

drivers/accel/habanalabs/common/debugfs.c

293

lnode->vaddr, lnode->block_size, lnode->mapped_size,

drivers/accel/habanalabs/common/habanalabs.h

1751

u32 *block_size, u32 *block_id);

drivers/accel/habanalabs/common/habanalabs.h

1753

u32 block_id, u32 block_size);

drivers/accel/habanalabs/common/habanalabs.h

2212

u32 block_size;

drivers/accel/habanalabs/common/memory.c

1465

u32 block_id, block_size;

drivers/accel/habanalabs/common/memory.c

1475

block_size = vma->vm_end - vma->vm_start;

drivers/accel/habanalabs/common/memory.c

1477

if (!access_ok((void __user *) (uintptr_t) vma->vm_start, block_size)) {

drivers/accel/habanalabs/common/memory.c

1489

rc = hdev->asic_funcs->hw_block_mmap(hdev, vma, block_id, block_size);

drivers/accel/habanalabs/common/memory.c

1499

lnode->block_size = block_size;

drivers/accel/habanalabs/common/memory.c

1500

lnode->mapped_size = lnode->block_size;

drivers/accel/habanalabs/common/memory.c

2202

u32 handle = 0, block_size;

drivers/accel/habanalabs/common/memory.c

2286

&block_handle, &block_size);

drivers/accel/habanalabs/common/memory.c

2288

args->out.block_size = block_size;

drivers/accel/habanalabs/gaudi/gaudi.c

8784

u32 *block_size, u32 *block_id)

drivers/accel/habanalabs/gaudi/gaudi.c

8791

u32 block_id, u32 block_size)

drivers/accel/habanalabs/gaudi2/gaudi2.c

11586

u32 *block_size, u32 *block_id)

drivers/accel/habanalabs/gaudi2/gaudi2.c

11594

if (block_size)

drivers/accel/habanalabs/gaudi2/gaudi2.c

11595

*block_size = gaudi2->mapped_blocks[i].size;

drivers/accel/habanalabs/gaudi2/gaudi2.c

11606

u32 block_id, u32 block_size)

drivers/accel/habanalabs/gaudi2/gaudi2.c

11619

if (block_size != gaudi2->mapped_blocks[block_id].size) {

drivers/accel/habanalabs/gaudi2/gaudi2.c

11620

dev_err(hdev->dev, "Invalid block size %u", block_size);

drivers/accel/habanalabs/gaudi2/gaudi2.c

11632

block_size, vma->vm_page_prot);

drivers/accel/habanalabs/gaudi2/gaudi2.c

3727

u32 block_size, umr_start_idx, num_umr_blocks;

drivers/accel/habanalabs/gaudi2/gaudi2.c

3732

block_size = ARC_DCCM_BLOCK_SIZE * 2;

drivers/accel/habanalabs/gaudi2/gaudi2.c

3734

block_size = ARC_DCCM_BLOCK_SIZE;

drivers/accel/habanalabs/gaudi2/gaudi2.c

3737

blocks[i].size = block_size;

drivers/accel/habanalabs/gaudi2/gaudi2_security.c

47

u32 block_size;

drivers/accel/habanalabs/goya/goya.c

5310

u32 *block_size, u32 *block_id)

drivers/accel/habanalabs/goya/goya.c

5316

u32 block_id, u32 block_size)

drivers/block/floppy.c

4150

__bio_add_page(&bio, page, block_size(bdev), 0);

drivers/block/loop.c

1062

loop_update_limits(lo, &lim, config->block_size);

drivers/block/zloop.c

1087

lim.physical_block_size = zlo->block_size;

drivers/block/zloop.c

1088

lim.logical_block_size = zlo->block_size;

drivers/block/zloop.c

1134

zlo->block_size);

drivers/block/zloop.c

131

unsigned int block_size;

drivers/block/zloop.c

181

if (file_sectors & ((zlo->block_size >> SECTOR_SHIFT) - 1)) {

drivers/block/zloop.c

183

zone_no, zlo->block_size);

drivers/block/zloop.c

864

zlo->block_size = file_inode(zone->file)->i_sb->s_blocksize;

drivers/block/zloop.c

867

zlo->block_size = st.dio_offset_align;

drivers/block/zloop.c

869

zlo->block_size = bdev_physical_block_size(sb_bdev);

drivers/block/zloop.c

871

zlo->block_size = SECTOR_SIZE;

drivers/block/zloop.c

873

if (zlo->zone_capacity & ((zlo->block_size >> SECTOR_SHIFT) - 1)) {

drivers/block/zloop.c

875

zlo->block_size);

drivers/block/zloop.c

916

if (!zlo->block_size) {

drivers/block/zloop.c

956

if (!zlo->block_size) {

drivers/cache/starfive_starlink_cache.c

105

u32 block_size;

drivers/cache/starfive_starlink_cache.c

113

ret = of_property_read_u32(np, "cache-block-size", &block_size);

drivers/cache/starfive_starlink_cache.c

117

if (block_size % STARLINK_CACHE_ALIGN)

drivers/cache/starfive_starlink_cache.c

124

riscv_cbom_block_size = block_size;

drivers/comedi/comedi_buf.c

346

unsigned int block_size =

drivers/comedi/comedi_buf.c

350

block_size, async->munge_chan);

drivers/comedi/comedi_buf.c

358

async->munge_chan += block_size / num_sample_bytes;

drivers/comedi/comedi_buf.c

360

async->munge_count += block_size;

drivers/comedi/comedi_buf.c

361

async->munge_ptr += block_size;

drivers/comedi/comedi_buf.c

364

count += block_size;

drivers/comedi/comedi_buf.c

583

unsigned int block_size = min(num_bytes, PAGE_SIZE - offset);

drivers/comedi/comedi_buf.c

586

data, block_size);

drivers/comedi/comedi_buf.c

588

data += block_size;

drivers/comedi/comedi_buf.c

589

num_bytes -= block_size;

drivers/comedi/comedi_buf.c

590

write_ptr += block_size;

drivers/comedi/comedi_buf.c

610

unsigned int block_size = min(nbytes, PAGE_SIZE - offset);

drivers/comedi/comedi_buf.c

613

block_size);

drivers/comedi/comedi_buf.c

614

nbytes -= block_size;

drivers/comedi/comedi_buf.c

615

dest += block_size;

drivers/comedi/comedi_buf.c

616

read_ptr += block_size;

drivers/comedi/drivers/cb_pcidas64.c

1896

unsigned int block_size, requested_block_size;

drivers/comedi/drivers/cb_pcidas64.c

1910

block_size = ai_fifo_size(dev) / fifo->num_segments * bytes_in_sample;

drivers/comedi/drivers/cb_pcidas64.c

1912

data[1] = block_size;

drivers/comedi/drivers/gsc_hpdi.c

137

unsigned int block_size;

drivers/comedi/drivers/gsc_hpdi.c

156

for (desc = 0; (next < start || next >= start + devpriv->block_size) &&

drivers/comedi/drivers/gsc_hpdi.c

159

size = devpriv->block_size / sizeof(u32);

drivers/comedi/drivers/gsc_hpdi.c

448

devpriv->block_size = len;

drivers/crypto/aspeed/aspeed-hace-hash.c

171

remain = length - round_down(length, rctx->block_size);

drivers/crypto/aspeed/aspeed-hace-hash.c

178

if (round_up(length, rctx->block_size) + rctx->block_size >

drivers/crypto/aspeed/aspeed-hace-hash.c

180

length = round_down(length - 1, rctx->block_size);

drivers/crypto/aspeed/aspeed-hace-hash.c

225

remain = final ? 0 : length - round_down(length, rctx->block_size);

drivers/crypto/aspeed/aspeed-hace-hash.c

280

total = round_down(total, rctx->block_size);

drivers/crypto/aspeed/aspeed-hace-hash.c

333

if (rctx->total - rctx->offset >= rctx->block_size ||

drivers/crypto/aspeed/aspeed-hace-hash.c

552

rctx->block_size = SHA1_BLOCK_SIZE;

drivers/crypto/aspeed/aspeed-hace-hash.c

560

rctx->block_size = SHA224_BLOCK_SIZE;

drivers/crypto/aspeed/aspeed-hace-hash.c

568

rctx->block_size = SHA256_BLOCK_SIZE;

drivers/crypto/aspeed/aspeed-hace-hash.c

577

rctx->block_size = SHA384_BLOCK_SIZE;

drivers/crypto/aspeed/aspeed-hace-hash.c

586

rctx->block_size = SHA512_BLOCK_SIZE;

drivers/crypto/aspeed/aspeed-hace.h

184

size_t block_size;

drivers/crypto/atmel-aes.c

1088

ctx->block_size = AES_BLOCK_SIZE;

drivers/crypto/atmel-aes.c

1534

ctx->block_size = AES_BLOCK_SIZE;

drivers/crypto/atmel-aes.c

2016

ctx->block_size = AES_BLOCK_SIZE;

drivers/crypto/atmel-aes.c

405

static inline size_t atmel_aes_padlen(size_t len, size_t block_size)

drivers/crypto/atmel-aes.c

407

len &= block_size - 1;

drivers/crypto/atmel-aes.c

408

return len ? block_size - len : 0;

drivers/crypto/atmel-aes.c

654

if (!IS_ALIGNED(len, dd->ctx->block_size))

drivers/crypto/atmel-aes.c

662

if (!IS_ALIGNED(len, dd->ctx->block_size))

drivers/crypto/atmel-aes.c

671

if (!IS_ALIGNED(sg->length, dd->ctx->block_size))

drivers/crypto/atmel-aes.c

716

padlen = atmel_aes_padlen(len, dd->ctx->block_size);

drivers/crypto/atmel-aes.c

850

switch (dd->ctx->block_size) {

drivers/crypto/atmel-aes.c

951

dd->ctx->block_size != AES_BLOCK_SIZE);

drivers/crypto/atmel-aes.c

96

u16 block_size;

drivers/crypto/atmel-sha.c

105

size_t block_size;

drivers/crypto/atmel-sha.c

1395

size_t bs = ctx->block_size;

drivers/crypto/atmel-sha.c

1529

ctx->bufcnt = min_t(size_t, ctx->block_size, ctx->total);

drivers/crypto/atmel-sha.c

1575

ctx->bufcnt = min_t(size_t, ctx->block_size, ctx->total);

drivers/crypto/atmel-sha.c

1593

if (!(IS_ALIGNED(datalen, ctx->block_size) || auto_padding))

drivers/crypto/atmel-sha.c

1697

ctx->block_size = SHA1_BLOCK_SIZE;

drivers/crypto/atmel-sha.c

1702

ctx->block_size = SHA224_BLOCK_SIZE;

drivers/crypto/atmel-sha.c

1707

ctx->block_size = SHA256_BLOCK_SIZE;

drivers/crypto/atmel-sha.c

1712

ctx->block_size = SHA384_BLOCK_SIZE;

drivers/crypto/atmel-sha.c

1717

ctx->block_size = SHA512_BLOCK_SIZE;

drivers/crypto/atmel-sha.c

1724

bs = ctx->block_size;

drivers/crypto/atmel-sha.c

1753

size_t bs = ctx->block_size;

drivers/crypto/atmel-sha.c

1769

size_t bs = ctx->block_size;

drivers/crypto/atmel-sha.c

1789

size_t bs = ctx->block_size;

drivers/crypto/atmel-sha.c

1875

size_t bs = ctx->block_size;

drivers/crypto/atmel-sha.c

1894

size_t bs = ctx->block_size;

drivers/crypto/atmel-sha.c

443

ctx->block_size = SHA1_BLOCK_SIZE;

drivers/crypto/atmel-sha.c

447

ctx->block_size = SHA224_BLOCK_SIZE;

drivers/crypto/atmel-sha.c

451

ctx->block_size = SHA256_BLOCK_SIZE;

drivers/crypto/atmel-sha.c

455

ctx->block_size = SHA384_BLOCK_SIZE;

drivers/crypto/atmel-sha.c

459

ctx->block_size = SHA512_BLOCK_SIZE;

drivers/crypto/atmel-sha.c

721

ctx->buflen + ctx->block_size, DMA_TO_DEVICE);

drivers/crypto/atmel-sha.c

724

ctx->block_size);

drivers/crypto/atmel-sha.c

780

if (!sg_is_last(sg) && !IS_ALIGNED(sg->length, ctx->block_size))

drivers/crypto/atmel-sha.c

789

tail = length & (ctx->block_size - 1);

drivers/crypto/atmel-sha.c

801

tail = length & (ctx->block_size - 1);

drivers/crypto/atmel-sha.c

812

ctx->buflen + ctx->block_size, DMA_TO_DEVICE);

drivers/crypto/atmel-sha.c

815

ctx->buflen + ctx->block_size);

drivers/crypto/atmel-sha.c

867

ctx->buflen + ctx->block_size, DMA_TO_DEVICE);

drivers/crypto/atmel-sha.c

871

ctx->block_size, DMA_TO_DEVICE);

drivers/crypto/atmel-tdes.c

461

IS_ALIGNED(dd->in_sg->length, dd->ctx->block_size);

drivers/crypto/atmel-tdes.c

463

IS_ALIGNED(dd->out_sg->length, dd->ctx->block_size);

drivers/crypto/atmel-tdes.c

651

ctx->block_size = DES_BLOCK_SIZE;

drivers/crypto/atmel-tdes.c

71

u16 block_size;

drivers/crypto/ccp/ccp-crypto-aes-cmac.c

133

int pad_length = block_size - (len & (block_size - 1));

drivers/crypto/ccp/ccp-crypto-aes-cmac.c

62

unsigned int block_size =

drivers/crypto/ccp/ccp-crypto-aes-cmac.c

77

if (!final && (len <= block_size)) {

drivers/crypto/ccp/ccp-crypto-aes-cmac.c

89

rctx->hash_rem = final ? 0 : len & (block_size - 1);

drivers/crypto/ccp/ccp-crypto-aes-cmac.c

93

rctx->hash_cnt -= block_size;

drivers/crypto/ccp/ccp-crypto-aes-cmac.c

94

rctx->hash_rem = block_size;

drivers/crypto/ccp/ccp-crypto-aes-cmac.c

97

if (final && (rctx->null_msg || (len & (block_size - 1))))

drivers/crypto/ccp/ccp-crypto-sha.c

189

unsigned int block_size =

drivers/crypto/ccp/ccp-crypto-sha.c

199

memcpy(rctx->buf, ctx->u.sha.ipad, block_size);

drivers/crypto/ccp/ccp-crypto-sha.c

200

rctx->buf_count = block_size;

drivers/crypto/ccp/ccp-crypto-sha.c

277

unsigned int block_size = crypto_shash_blocksize(shash);

drivers/crypto/ccp/ccp-crypto-sha.c

289

if (key_len > block_size) {

drivers/crypto/ccp/ccp-crypto-sha.c

301

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

drivers/crypto/ccp/ccp-crypto-sha.c

306

sg_init_one(&ctx->u.sha.opad_sg, ctx->u.sha.opad, block_size);

drivers/crypto/ccp/ccp-crypto-sha.c

307

ctx->u.sha.opad_count = block_size;

drivers/crypto/ccp/ccp-crypto-sha.c

365

u32 block_size;

drivers/crypto/ccp/ccp-crypto-sha.c

375

.block_size = SHA1_BLOCK_SIZE,

drivers/crypto/ccp/ccp-crypto-sha.c

383

.block_size = SHA224_BLOCK_SIZE,

drivers/crypto/ccp/ccp-crypto-sha.c

391

.block_size = SHA256_BLOCK_SIZE,

drivers/crypto/ccp/ccp-crypto-sha.c

399

.block_size = SHA384_BLOCK_SIZE,

drivers/crypto/ccp/ccp-crypto-sha.c

407

.block_size = SHA512_BLOCK_SIZE,

drivers/crypto/ccp/ccp-crypto-sha.c

494

base->cra_blocksize = def->block_size;

drivers/crypto/ccp/ccp-crypto-sha.c

65

unsigned int block_size =

drivers/crypto/ccp/ccp-crypto-sha.c

74

if (!final && (len <= block_size)) {

drivers/crypto/ccp/ccp-crypto-sha.c

86

rctx->hash_rem = final ? 0 : len & (block_size - 1);

drivers/crypto/ccp/ccp-crypto-sha.c

90

rctx->hash_cnt -= block_size;

drivers/crypto/ccp/ccp-crypto-sha.c

91

rctx->hash_rem = block_size;

drivers/crypto/ccp/ccp-ops.c

1509

u64 block_size;

drivers/crypto/ccp/ccp-ops.c

1517

block_size = SHA1_BLOCK_SIZE;

drivers/crypto/ccp/ccp-ops.c

1522

block_size = SHA224_BLOCK_SIZE;

drivers/crypto/ccp/ccp-ops.c

1527

block_size = SHA256_BLOCK_SIZE;

drivers/crypto/ccp/ccp-ops.c

1533

block_size = SHA384_BLOCK_SIZE;

drivers/crypto/ccp/ccp-ops.c

1539

block_size = SHA512_BLOCK_SIZE;

drivers/crypto/ccp/ccp-ops.c

1548

if (!sha->final && (sha->src_len & (block_size - 1)))

drivers/crypto/ccp/ccp-ops.c

1706

block_size, DMA_TO_DEVICE);

drivers/crypto/ccp/ccp-ops.c

1711

ccp_prepare_data(&src, NULL, &op, block_size, false);

drivers/crypto/ccp/ccp-ops.c

1777

if (sha->opad_len != block_size) {

drivers/crypto/ccp/ccp-ops.c

1782

hmac_buf = kmalloc(block_size + digest_size, GFP_KERNEL);

drivers/crypto/ccp/ccp-ops.c

1787

sg_init_one(&sg, hmac_buf, block_size + digest_size);

drivers/crypto/ccp/ccp-ops.c

1789

scatterwalk_map_and_copy(hmac_buf, sha->opad, 0, block_size, 0);

drivers/crypto/ccp/ccp-ops.c

1794

memcpy(hmac_buf + block_size,

drivers/crypto/ccp/ccp-ops.c

1800

memcpy(hmac_buf + block_size,

drivers/crypto/ccp/ccp-ops.c

1803

memcpy(hmac_buf + block_size +

drivers/crypto/ccp/ccp-ops.c

1820

hmac_cmd.u.sha.src_len = block_size + digest_size;

drivers/crypto/ccp/ccp-ops.c

1825

hmac_cmd.u.sha.msg_bits = (block_size + digest_size) << 3;

drivers/crypto/ccp/ccp-ops.c

344

struct ccp_op *op, unsigned int block_size,

drivers/crypto/ccp/ccp-ops.c

369

op_len = max(op_len, block_size);

drivers/crypto/ccp/ccp-ops.c

374

if (sg_src_len < block_size) {

drivers/crypto/ccp/ccp-ops.c

383

op->src.u.dma.length = (blocksize_op) ? block_size : cp_len;

drivers/crypto/ccp/ccp-ops.c

390

op->src.u.dma.length = op_len & ~(block_size - 1);

drivers/crypto/ccp/ccp-ops.c

396

if (sg_dst_len < block_size) {

drivers/crypto/ccree/cc_buffer_mgr.c

1222

unsigned int block_size, gfp_t flags)

drivers/crypto/ccree/cc_buffer_mgr.c

1249

if (total_in_len < block_size) {

drivers/crypto/ccree/cc_buffer_mgr.c

1263

*next_buff_cnt = total_in_len & (block_size - 1);

drivers/crypto/ccree/cc_buffer_mgr.h

62

unsigned int block_size, gfp_t flags);

drivers/crypto/ccree/cc_hash.c

1156

unsigned int block_size = crypto_tfm_alg_blocksize(&tfm->base);

drivers/crypto/ccree/cc_hash.c

1171

req->nbytes, block_size, flags);

drivers/crypto/ccree/cc_hash.c

561

unsigned int block_size = crypto_tfm_alg_blocksize(&tfm->base);

drivers/crypto/ccree/cc_hash.c

580

block_size, flags);

drivers/crypto/hisilicon/sgl.c

100

block[i].size = block_size;

drivers/crypto/hisilicon/sgl.c

125

dma_free_coherent(dev, block_size, block[j].sgl,

drivers/crypto/hisilicon/sgl.c

60

u32 sgl_size, block_size, sgl_num_per_block, block_num, remain_sgl;

drivers/crypto/hisilicon/sgl.c

76

block_size = 1 << (PAGE_SHIFT + MAX_PAGE_ORDER < 32 ?

drivers/crypto/hisilicon/sgl.c

78

sgl_num_per_block = block_size / sgl_size;

drivers/crypto/hisilicon/sgl.c

92

block[i].sgl = dma_alloc_coherent(dev, block_size,

drivers/crypto/hisilicon/trng/trng.c

183

unsigned int block_size;

drivers/crypto/hisilicon/trng/trng.c

192

block_size = min_t(unsigned int, dlen - currsize, SW_MAX_RANDOM_BYTES);

drivers/crypto/hisilicon/trng/trng.c

194

ret = hisi_trng_get_bytes(trng, dstn + currsize, block_size);

drivers/crypto/hisilicon/trng/trng.c

198

currsize += block_size;

drivers/crypto/sa2ul.c

439

int block_size = crypto_shash_blocksize(data->ctx->shash);

drivers/crypto/sa2ul.c

452

crypto_shash_update(shash, sha.k_pad, block_size);

drivers/crypto/sa2ul.c

458

crypto_shash_update(shash, sha.k_pad, block_size);

drivers/crypto/sahara.c

876

unsigned int block_size;

drivers/crypto/sahara.c

879

block_size = crypto_tfm_alg_blocksize(crypto_ahash_tfm(tfm));

drivers/crypto/sahara.c

885

if (!rctx->last && (len < block_size)) {

drivers/crypto/sahara.c

899

hash_later = rctx->last ? 0 : len & (block_size - 1);

drivers/crypto/stm32/stm32-cryp.c

1424

size_t block_size)

drivers/crypto/stm32/stm32-cryp.c

1433

if (!IS_ALIGNED(sg->length, block_size) && !sg_is_last(sg))

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

1414

chip->dw->hdata->block_size[tmp] = carr[tmp];

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

662

axi_block_ts = chan->chip->dw->hdata->block_size[chan->id];

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

741

axi_block_ts = chan->chip->dw->hdata->block_size[chan->id];

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

933

max_block_ts = chan->chip->dw->hdata->block_size[chan->id];

drivers/dma/dw-axi-dmac/dw-axi-dmac.h

29

u32 block_size[DMAC_MAX_CHANNELS];

drivers/dma/dw/core.c

1188

pdata->block_size = dma_readl(dw, MAX_BLK_SIZE);

drivers/dma/dw/core.c

1278

dwc->block_size =

drivers/dma/dw/core.c

1279

(4 << ((pdata->block_size >> 4 * i) & 0xf)) - 1;

drivers/dma/dw/core.c

1294

dwc->block_size = pdata->block_size;

drivers/dma/dw/core.c

1342

dma_set_max_seg_size(dw->dma.dev, dw->chan[0].block_size);

drivers/dma/dw/dw.c

51

if ((bytes >> width) > dwc->block_size) {

drivers/dma/dw/dw.c

52

block = dwc->block_size;

drivers/dma/dw/dw.c

53

*len = dwc->block_size << width;

drivers/dma/dw/idma32.c

186

if (bytes > dwc->block_size) {

drivers/dma/dw/idma32.c

187

block = dwc->block_size;

drivers/dma/dw/idma32.c

188

*len = dwc->block_size;

drivers/dma/dw/internal.h

69

.block_size = 131071,

drivers/dma/dw/internal.h

87

.block_size = 131071,

drivers/dma/dw/of.c

77

of_property_read_u32(np, "block_size", &pdata->block_size);

drivers/dma/dw/regs.h

286

unsigned int block_size;

drivers/dpll/zl3073x/flash.c

337

size_t max_block_size, block_size, sector_size;

drivers/dpll/zl3073x/flash.c

351

for (ptr = data, end = data + size; ptr < end; ptr += block_size) {

drivers/dpll/zl3073x/flash.c

354

block_size = min_t(size_t, max_block_size, end - ptr);

drivers/dpll/zl3073x/flash.c

368

ptr, block_size, extack);

drivers/dpll/zl3073x/flash.c

373

page += block_size / ZL_FLASH_PAGE_SIZE;

drivers/fpga/altera-cvp.c

451

len = min(conf->priv->block_size, remaining);

drivers/fpga/altera-cvp.c

523

.block_size = ALTERA_CVP_V1_SIZE,

drivers/fpga/altera-cvp.c

531

.block_size = ALTERA_CVP_V2_SIZE,

drivers/fpga/altera-cvp.c

87

size_t block_size;

drivers/gpib/agilent_82350b/agilent_82350b.c

160

int block_size = 0;

drivers/gpib/agilent_82350b/agilent_82350b.c

196

block_size = min(fifotransferlength - i, agilent_82350b_fifo_size);

drivers/gpib/agilent_82350b/agilent_82350b.c

197

set_transfer_counter(a_priv, block_size);

drivers/gpib/agilent_82350b/agilent_82350b.c

198

for (j = 0; j < block_size; ++j, ++i) {

drivers/gpib/agilent_82350b/agilent_82350b.c

214

num_bytes = block_size - read_transfer_counter(a_priv);

drivers/gpib/agilent_82350b/agilent_82350b.c

73

int block_size;

drivers/gpib/agilent_82350b/agilent_82350b.c

77

block_size = min(num_fifo_bytes - i, agilent_82350b_fifo_size);

drivers/gpib/agilent_82350b/agilent_82350b.c

78

set_transfer_counter(a_priv, block_size);

drivers/gpib/agilent_82350b/agilent_82350b.c

97

count = block_size - read_transfer_counter(a_priv);

drivers/gpib/hp_82341/hp_82341.c

104

count = block_size - read_transfer_counter(hp_priv);

drivers/gpib/hp_82341/hp_82341.c

193

int block_size;

drivers/gpib/hp_82341/hp_82341.c

195

block_size = min(fifo_xfer_len - i, hp_82341_fifo_size);

drivers/gpib/hp_82341/hp_82341.c

196

set_transfer_counter(hp_priv, block_size);

drivers/gpib/hp_82341/hp_82341.c

198

for (j = 0; j < block_size;) {

drivers/gpib/hp_82341/hp_82341.c

201

if (j < block_size) {

drivers/gpib/hp_82341/hp_82341.c

221

*bytes_written += block_size - read_transfer_counter(hp_priv);

drivers/gpib/hp_82341/hp_82341.c

78

int block_size;

drivers/gpib/hp_82341/hp_82341.c

82

block_size = min(num_fifo_bytes - i, hp_82341_fifo_size);

drivers/gpib/hp_82341/hp_82341.c

83

set_transfer_counter(hp_priv, block_size);

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

2137

seq_printf(m, "block_size: 0x%x\n", adev->vm_manager.block_size);

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

1018

unsigned int block_size = 1 << block_size_log2;

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

1035

if (rfb->base.offsets[plane] % block_size) {

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

1038

rfb->base.offsets[plane], plane, block_size);

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

1044

block_size * DIV_ROUND_UP(height, block_height);

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

2431

adev->vm_manager.block_size =

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

2436

adev->vm_manager.block_size = 9;

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

2438

adev->vm_manager.block_size = amdgpu_vm_get_block_size(tmp);

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

2449

adev->vm_manager.block_size, adev->vm_manager.fragment_size);

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

463

uint32_t block_size;

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

55

#define AMDGPU_VM_PTE_COUNT(adev) (1 << (adev)->vm_manager.block_size)

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

59

adev->vm_manager.block_size;

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

320

adev->vm_manager.block_size - 9);

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

325

adev->vm_manager.block_size - 9);

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

398

unsigned int num_level, block_size;

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

403

block_size = adev->vm_manager.block_size;

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

404

block_size -= 9;

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

431

PAGE_TABLE_BLOCK_SIZE, block_size);

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

253

unsigned int num_level, block_size;

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

258

block_size = adev->vm_manager.block_size;

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

262

block_size -= 9;

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

286

block_size);

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

332

unsigned int num_level, block_size;

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

337

block_size = adev->vm_manager.block_size;

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

341

block_size -= 9;

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

368

block_size);

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

310

adev->vm_manager.block_size - 9);

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

322

adev->vm_manager.block_size - 9);

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

317

adev->vm_manager.block_size - 9);

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

322

adev->vm_manager.block_size - 9);

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

550

((adev->vm_manager.block_size - 9)

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

694

adev->vm_manager.block_size - 9);

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

934

adev->vm_manager.block_size - 9);

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

281

unsigned num_level, block_size;

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

286

block_size = adev->vm_manager.block_size;

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

290

block_size -= 9;

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

314

block_size);

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

289

unsigned num_level, block_size;

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

294

block_size = adev->vm_manager.block_size;

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

298

block_size -= 9;

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

322

block_size);

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

380

unsigned int num_level, block_size;

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

385

block_size = adev->vm_manager.block_size;

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

389

block_size -= 9;

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

417

block_size);

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

394

adev->vm_manager.block_size - 9);

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

310

adev->vm_manager.block_size - 9);

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

348

adev->vm_manager.block_size - 9);

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

342

adev->vm_manager.block_size - 9);

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

340

adev->vm_manager.block_size - 9);

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

469

adev->vm_manager.block_size - 9);

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

341

adev->vm_manager.block_size - 9);

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

477

adev->vm_manager.block_size - 9);

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

328

unsigned int num_level, block_size;

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

333

block_size = adev->vm_manager.block_size;

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

337

block_size -= 9;

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

364

block_size);

drivers/gpu/drm/amd/display/dc/dcn20/dcn20_vmid.c

90

VM_CONTEXT0_PAGE_TABLE_BLOCK_SIZE, config->block_size);

drivers/gpu/drm/amd/display/dc/hubbub/dcn20/dcn20_hubbub.c

336

enum dcn_hubbub_page_table_block_size block_size = 0;

drivers/gpu/drm/amd/display/dc/hubbub/dcn20/dcn20_hubbub.c

340

block_size = DCN_PAGE_TABLE_BLOCK_SIZE_4KB;

drivers/gpu/drm/amd/display/dc/hubbub/dcn20/dcn20_hubbub.c

343

block_size = DCN_PAGE_TABLE_BLOCK_SIZE_8KB;

drivers/gpu/drm/amd/display/dc/hubbub/dcn20/dcn20_hubbub.c

346

block_size = DCN_PAGE_TABLE_BLOCK_SIZE_16KB;

drivers/gpu/drm/amd/display/dc/hubbub/dcn20/dcn20_hubbub.c

349

block_size = DCN_PAGE_TABLE_BLOCK_SIZE_32KB;

drivers/gpu/drm/amd/display/dc/hubbub/dcn20/dcn20_hubbub.c

352

block_size = DCN_PAGE_TABLE_BLOCK_SIZE_64KB;

drivers/gpu/drm/amd/display/dc/hubbub/dcn20/dcn20_hubbub.c

355

block_size = DCN_PAGE_TABLE_BLOCK_SIZE_128KB;

drivers/gpu/drm/amd/display/dc/hubbub/dcn20/dcn20_hubbub.c

358

block_size = DCN_PAGE_TABLE_BLOCK_SIZE_256KB;

drivers/gpu/drm/amd/display/dc/hubbub/dcn20/dcn20_hubbub.c

361

block_size = DCN_PAGE_TABLE_BLOCK_SIZE_512KB;

drivers/gpu/drm/amd/display/dc/hubbub/dcn20/dcn20_hubbub.c

364

block_size = DCN_PAGE_TABLE_BLOCK_SIZE_1024KB;

drivers/gpu/drm/amd/display/dc/hubbub/dcn20/dcn20_hubbub.c

367

block_size = DCN_PAGE_TABLE_BLOCK_SIZE_2048KB;

drivers/gpu/drm/amd/display/dc/hubbub/dcn20/dcn20_hubbub.c

371

block_size = DCN_PAGE_TABLE_BLOCK_SIZE_4KB;

drivers/gpu/drm/amd/display/dc/hubbub/dcn20/dcn20_hubbub.c

375

return block_size;

drivers/gpu/drm/amd/display/dc/hubbub/dcn20/dcn20_hubbub.c

388

virt_config.block_size = page_table_block_size_to_hw(va_config->page_table_block_size);

drivers/gpu/drm/amd/display/dc/hubbub/dcn20/dcn20_hubbub.c

423

phys_config.block_size = 0;

drivers/gpu/drm/amd/display/dc/hubbub/dcn21/dcn21_hubbub.c

131

phys_config.block_size = 0;

drivers/gpu/drm/amd/display/dc/hubbub/dcn30/dcn30_hubbub.c

88

phys_config.block_size = 0;

drivers/gpu/drm/amd/display/dc/hubbub/dcn31/dcn31_hubbub.c

930

phys_config.block_size = 0;

drivers/gpu/drm/amd/display/dc/inc/hw/vmid.h

46

enum dcn_hubbub_page_table_block_size block_size;

drivers/gpu/drm/display/drm_dp_helper.c

3038

int block_size = dpcd[DP_DPCD_REV] < 0x14 ? 1 : buf_size;

drivers/gpu/drm/display/drm_dp_helper.c

3042

for (offset = 0; offset < buf_size; offset += block_size) {

drivers/gpu/drm/display/drm_dp_helper.c

3045

&buf[offset], block_size);

drivers/gpu/drm/drm_fb_dma_helper.c

105

dma_addr += block_size * num_hblocks;

drivers/gpu/drm/drm_fb_dma_helper.c

82

u32 block_size = fb->format->char_per_block[plane];

drivers/gpu/drm/drm_framebuffer.c

174

unsigned int block_size = info->char_per_block[i];

drivers/gpu/drm/drm_framebuffer.c

177

if (!block_size && (r->modifier[i] == DRM_FORMAT_MOD_LINEAR)) {

drivers/gpu/drm/drm_framebuffer.c

193

if (block_size && r->pitches[i] < min_pitch) {

drivers/gpu/drm/gma500/intel_bios.c

141

u16 *block_ptr, block_size;

drivers/gpu/drm/gma500/intel_bios.c

144

block_size = *block_ptr;

drivers/gpu/drm/gma500/intel_bios.c

145

return block_size;

drivers/gpu/drm/gma500/intel_bios.c

331

u16 block_size;

drivers/gpu/drm/gma500/intel_bios.c

349

block_size = get_blocksize(p_defs);

drivers/gpu/drm/gma500/intel_bios.c

351

child_device_num = (block_size - sizeof(*p_defs)) /

drivers/gpu/drm/gma500/intel_bios.c

444

u16 block_size;

drivers/gpu/drm/gma500/intel_bios.c

462

block_size = get_blocksize(p_defs);

drivers/gpu/drm/gma500/intel_bios.c

464

child_device_num = (block_size - sizeof(*p_defs)) /

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

2133

u16 block_size;

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

2148

block_size = get_blocksize(params);

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

2149

if (block_size < sizeof(*params)) {

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

2893

u16 block_size;

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

2903

block_size = get_blocksize(defs);

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

2904

if (block_size < sizeof(*defs)) {

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

2907

block_size);

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

2920

child_device_num = (block_size - sizeof(*defs)) / defs->child_dev_size;

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

369

int i, size, table_size, block_size, offset, fp_timing_size;

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

391

block_size = get_blocksize(block);

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

395

if (size * 16 > block_size)

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

437

if (16 * (size + table_size) <= block_size) {

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

464

size_t block_size;

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

480

block_size = get_blocksize(block);

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

487

block_size += 5;

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

489

entry = kzalloc_flex(*entry, data, max(min_size, block_size) + 3);

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

496

memcpy(entry->data, block - 3, block_size + 3);

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

502

section_id, block_size, min_size);

drivers/gpu/drm/i915/i915_scatterlist.c

115

block_size = node->size << PAGE_SHIFT;

drivers/gpu/drm/i915/i915_scatterlist.c

118

while (block_size) {

drivers/gpu/drm/i915/i915_scatterlist.c

133

len = min_t(u64, block_size, max_segment - sg->length);

drivers/gpu/drm/i915/i915_scatterlist.c

138

block_size -= len;

drivers/gpu/drm/i915/i915_scatterlist.c

203

u64 block_size, offset;

drivers/gpu/drm/i915/i915_scatterlist.c

205

block_size = min_t(u64, size, drm_buddy_block_size(mm, block));

drivers/gpu/drm/i915/i915_scatterlist.c

208

while (block_size) {

drivers/gpu/drm/i915/i915_scatterlist.c

223

len = min_t(u64, block_size, max_segment - sg->length);

drivers/gpu/drm/i915/i915_scatterlist.c

228

block_size -= len;

drivers/gpu/drm/i915/i915_scatterlist.c

86

u64 block_size, offset, prev_end;

drivers/gpu/drm/meson/meson_overlay.c

701

unsigned long block_size = 4096;

drivers/gpu/drm/meson/meson_overlay.c

706

block_size = 3072;

drivers/gpu/drm/meson/meson_overlay.c

710

block_size;

drivers/gpu/drm/nouveau/include/nvkm/core/mm.h

24

u32 block_size;

drivers/gpu/drm/nouveau/nouveau_abi16.c

198

if (chan->heap.block_size)

drivers/gpu/drm/nouveau/nvkm/core/mm.c

131

s = roundup(s, mm->block_size);

drivers/gpu/drm/nouveau/nvkm/core/mm.c

135

e = rounddown(e, mm->block_size);

drivers/gpu/drm/nouveau/nvkm/core/mm.c

205

s = roundup(s, mm->block_size);

drivers/gpu/drm/nouveau/nvkm/core/mm.c

209

e = rounddown(e, mm->block_size);

drivers/gpu/drm/nouveau/nvkm/core/mm.c

257

BUG_ON(block != mm->block_size);

drivers/gpu/drm/nouveau/nvkm/core/mm.c

261

mm->block_size = block;

drivers/gpu/drm/nouveau/nvkm/core/mm.c

270

node->offset = roundup(offset, mm->block_size);

drivers/gpu/drm/nouveau/nvkm/core/mm.c

271

node->length = rounddown(offset + length, mm->block_size);

drivers/gpu/drm/omapdrm/dss/hdmi.h

195

u8 block_size;

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

782

audio_dma.block_size = 0xC0;

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

824

audio_dma.block_size = 0xC0;

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

255

r = FLD_MOD(r, aud_dma->block_size, 7, 0);

drivers/gpu/drm/tiny/gm12u320.c

169

int i, block_size;

drivers/gpu/drm/tiny/gm12u320.c

178

block_size = DATA_LAST_BLOCK_SIZE;

drivers/gpu/drm/tiny/gm12u320.c

181

block_size = DATA_BLOCK_SIZE;

drivers/gpu/drm/tiny/gm12u320.c

186

block_size, GFP_KERNEL);

drivers/gpu/drm/tiny/gm12u320.c

192

(block_size - DATA_BLOCK_FOOTER_SIZE),

drivers/gpu/drm/tiny/gm12u320.c

327

int block, block_size, len;

drivers/gpu/drm/tiny/gm12u320.c

334

block_size = DATA_LAST_BLOCK_SIZE;

drivers/gpu/drm/tiny/gm12u320.c

336

block_size = DATA_BLOCK_SIZE;

drivers/gpu/drm/tiny/gm12u320.c

340

gm12u320->cmd_buf[8] = block_size & 0xff;

drivers/gpu/drm/tiny/gm12u320.c

341

gm12u320->cmd_buf[9] = block_size >> 8;

drivers/gpu/drm/tiny/gm12u320.c

356

gm12u320->data_buf[block], block_size,

drivers/gpu/drm/tiny/gm12u320.c

358

if (ret || len != block_size)

drivers/gpu/drm/vmwgfx/vmw_surface_cache.h

78

SVGA3dSize *block_size)

drivers/gpu/drm/vmwgfx/vmw_surface_cache.h

80

block_size->width = __KERNEL_DIV_ROUND_UP(pixel_size->width,

drivers/gpu/drm/vmwgfx/vmw_surface_cache.h

82

block_size->height = __KERNEL_DIV_ROUND_UP(pixel_size->height,

drivers/gpu/drm/vmwgfx/vmw_surface_cache.h

84

block_size->depth = __KERNEL_DIV_ROUND_UP(pixel_size->depth,

drivers/iio/buffer/industrialio-buffer-dma.c

344

if (PAGE_ALIGN(queue->fileio.block_size) == PAGE_ALIGN(size))

drivers/iio/buffer/industrialio-buffer-dma.c

347

queue->fileio.block_size = size;

drivers/infiniband/hw/mlx5/wr.c

317

static u8 bs_selector(int block_size)

drivers/infiniband/hw/mlx5/wr.c

319

switch (block_size) {

drivers/infiniband/hw/mlx5/wr.c

480

u16 block_size = sig_attrs->mem.sig.dif.pi_interval;

drivers/infiniband/hw/mlx5/wr.c

489

pr_err("Bad block size given: %u\n", block_size);

drivers/infiniband/hw/mlx5/wr.c

492

sblock_ctrl->bcount_per_cycle = cpu_to_be32(block_size +

drivers/infiniband/hw/mlx5/wr.c

495

sblock_ctrl->repeat_count = cpu_to_be32(data_len / block_size);

drivers/infiniband/hw/mlx5/wr.c

498

data_sentry->bcount = cpu_to_be16(block_size);

drivers/infiniband/hw/mlx5/wr.c

501

data_sentry->stride = cpu_to_be16(block_size);

drivers/infiniband/ulp/isert/ib_isert.c

1540

u32 block_size = se_cmd->se_dev->dev_attrib.block_size + 8;

drivers/infiniband/ulp/isert/ib_isert.c

1554

do_div(sec_offset_err, block_size);

drivers/infiniband/ulp/isert/ib_isert.c

1982

domain->sig.dif.pi_interval = se_cmd->se_dev->dev_attrib.block_size;

drivers/input/rmi4/rmi_f34.c

150

data, f34->v5.block_size);

drivers/input/rmi4/rmi_f34.c

168

data += f34->v5.block_size;

drivers/input/rmi4/rmi_f34.c

169

f34->update_progress += f34->v5.block_size;

drivers/input/rmi4/rmi_f34.c

266

if (image_size && image_size != f34->v5.fw_blocks * f34->v5.block_size) {

drivers/input/rmi4/rmi_f34.c

269

image_size, f34->v5.fw_blocks * f34->v5.block_size);

drivers/input/rmi4/rmi_f34.c

274

config_size != f34->v5.config_blocks * f34->v5.block_size) {

drivers/input/rmi4/rmi_f34.c

278

f34->v5.config_blocks * f34->v5.block_size);

drivers/input/rmi4/rmi_f34.c

541

f34->v5.block_size = get_unaligned_le16(&f34_queries[3]);

drivers/input/rmi4/rmi_f34.c

545

f34->v5.block_size;

drivers/input/rmi4/rmi_f34.c

551

f34->v5.block_size);

drivers/input/rmi4/rmi_f34.h

124

__le16 block_size;

drivers/input/rmi4/rmi_f34.h

238

u16 block_size;

drivers/input/rmi4/rmi_f34.h

256

u16 block_size;

drivers/input/rmi4/rmi_f34v7.c

521

f34->v7.block_size = le16_to_cpu(query_1_7.block_size);

drivers/input/rmi4/rmi_f34v7.c

527

__func__, f34->v7.block_size);

drivers/input/rmi4/rmi_f34v7.c

593

block_count = f34->v7.img.bl_config.size / f34->v7.block_size;

drivers/input/rmi4/rmi_f34v7.c

651

(u16)(PAGE_SIZE / f34->v7.block_size));

drivers/input/rmi4/rmi_f34v7.c

680

transfer * f34->v7.block_size);

drivers/input/rmi4/rmi_f34v7.c

688

index += (transfer * f34->v7.block_size);

drivers/input/rmi4/rmi_f34v7.c

722

if (f34->v7.payload_length > (PAGE_SIZE / f34->v7.block_size))

drivers/input/rmi4/rmi_f34v7.c

723

max_transfer = PAGE_SIZE / f34->v7.block_size;

drivers/input/rmi4/rmi_f34v7.c

749

block_ptr, transfer * f34->v7.block_size);

drivers/input/rmi4/rmi_f34v7.c

761

block_ptr += (transfer * f34->v7.block_size);

drivers/input/rmi4/rmi_f34v7.c

783

f34->v7.config_block_count = f34->v7.config_size / f34->v7.block_size;

drivers/input/rmi4/rmi_f34v7.c

793

f34->v7.config_block_count = f34->v7.config_size / f34->v7.block_size;

drivers/input/rmi4/rmi_f34v7.c

802

f34->v7.block_size,

drivers/input/rmi4/rmi_f34v7.c

813

f34->v7.config_block_count = f34->v7.config_size / f34->v7.block_size;

drivers/input/rmi4/rmi_f34v7.c

837

f34->v7.config_size = f34->v7.block_size * block_count;

drivers/input/rmi4/rmi_f34v7.c

859

f34->v7.config_block_count = f34->v7.config_size / f34->v7.block_size;

drivers/input/rmi4/rmi_f34v7.c

872

blk_count = f34->v7.img.ui_firmware.size / f34->v7.block_size;

drivers/iommu/io-pgtable-arm.c

428

size_t block_size = ARM_LPAE_BLOCK_SIZE(lvl, data);

drivers/iommu/io-pgtable-arm.c

438

if (size == block_size) {

drivers/md/bcache/alloc.c

663

if (b->sectors_free < c->cache->sb.block_size)

drivers/md/bcache/bcache.h

776

#define block_bytes(ca) ((ca)->sb.block_size << 9)

drivers/md/bcache/bcache_ondisk.h

191

__le16 block_size; /* sectors */

drivers/md/bcache/bcache_ondisk.h

251

__u16 block_size; /* sectors */

drivers/md/bcache/btree.c

160

iter->size = b->c->cache->sb.bucket_size / b->c->cache->sb.block_size;

drivers/md/bcache/btree.c

428

atomic_long_add(set_blocks(i, block_bytes(b->c->cache)) * b->c->cache->sb.block_size,

drivers/md/bcache/journal.c

161

offset += blocks * ca->sb.block_size;

drivers/md/bcache/journal.c

162

len -= blocks * ca->sb.block_size;

drivers/md/bcache/journal.c

679

ca->sb.block_size;

drivers/md/bcache/journal.c

790

block_bytes(ca)) * ca->sb.block_size;

drivers/md/bcache/journal.c

793

c->journal.blocks_free * ca->sb.block_size,

drivers/md/bcache/request.c

411

if (bio->bi_iter.bi_sector & (c->cache->sb.block_size - 1) ||

drivers/md/bcache/request.c

412

bio_sectors(bio) & (c->cache->sb.block_size - 1)) {

drivers/md/bcache/super.c

117

if (!is_power_of_2(sb->block_size))

drivers/md/bcache/super.c

121

if (sb->block_size > PAGE_SECTORS)

drivers/md/bcache/super.c

1218

if (dc->sb.block_size < c->cache->sb.block_size) {

drivers/md/bcache/super.c

1402

static int cached_dev_init(struct cached_dev *dc, unsigned int block_size)

drivers/md/bcache/super.c

1430

ret = bcache_device_init(&dc->disk, block_size,

drivers/md/bcache/super.c

1462

if (cached_dev_init(dc, sb->block_size << 9))

drivers/md/bcache/super.c

1892

c->block_bits = ilog2(sb->block_size);

drivers/md/bcache/super.c

1923

((meta_bucket_pages(sb) * PAGE_SECTORS) / sb->block_size) *

drivers/md/bcache/super.c

215

sb->block_size = le16_to_cpu(s->block_size);

drivers/md/bcache/super.c

218

if (sb->block_size << 9 < bdev_logical_block_size(bdev))

drivers/md/bcache/super.c

897

static int bcache_device_init(struct bcache_device *d, unsigned int block_size,

drivers/md/bcache/super.c

909

.io_min = block_size,

drivers/md/bcache/super.c

910

.logical_block_size = block_size,

drivers/md/bcache/super.c

911

.physical_block_size = block_size,

drivers/md/bcache/super.c

919

lim.io_opt = umax(block_size, bdev_io_opt(cached_bdev));

drivers/md/bcache/sysfs.c

1036

sysfs_hprint(block_size, block_bytes(ca));

drivers/md/bcache/sysfs.c

67

read_attribute(block_size);

drivers/md/bcache/sysfs.c

731

sysfs_hprint(block_size, block_bytes(c->cache));

drivers/md/dm-bufio.c

1109

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

drivers/md/dm-bufio.c

1181

if (unlikely(c->block_size < PAGE_SIZE)) {

drivers/md/dm-bufio.c

1183

return kmalloc(c->block_size, gfp_mask | __GFP_RECLAIMABLE);

drivers/md/dm-bufio.c

1186

if (c->block_size <= KMALLOC_MAX_SIZE &&

drivers/md/dm-bufio.c

1195

return __vmalloc(c->block_size, gfp_mask);

drivers/md/dm-bufio.c

1371

sector = block * (c->block_size >> SECTOR_SHIFT);

drivers/md/dm-bufio.c

1389

n_sectors = b->c->block_size >> SECTOR_SHIFT;

drivers/md/dm-bufio.c

1401

if (unlikely(end > b->c->block_size))

drivers/md/dm-bufio.c

1402

end = b->c->block_size;

drivers/md/dm-bufio.c

2091

BUG_ON(end > b->c->block_size);

drivers/md/dm-bufio.c

2115

dm_bufio_mark_partial_buffer_dirty(b, 0, b->c->block_size);

drivers/md/dm-bufio.c

2304

return c->block_size;

drivers/md/dm-bufio.c

2319

sector_div(s, c->block_size >> SECTOR_SHIFT);

drivers/md/dm-bufio.c

2412

retain_bytes /= c->block_size;

drivers/md/dm-bufio.c

2495

struct dm_bufio_client *dm_bufio_client_create(struct block_device *bdev, unsigned int block_size,

drivers/md/dm-bufio.c

2507

if (!block_size || block_size & ((1 << SECTOR_SHIFT) - 1)) {

drivers/md/dm-bufio.c

2522

c->block_size = block_size;

drivers/md/dm-bufio.c

2523

if (is_power_of_2(block_size))

drivers/md/dm-bufio.c

2524

c->sectors_per_block_bits = __ffs(block_size) - SECTOR_SHIFT;

drivers/md/dm-bufio.c

2552

if (block_size <= KMALLOC_MAX_SIZE && !is_power_of_2(block_size)) {

drivers/md/dm-bufio.c

2553

unsigned int align = min(1U << __ffs(block_size), (unsigned int)PAGE_SIZE);

drivers/md/dm-bufio.c

2556

block_size, atomic_inc_return(&seqno));

drivers/md/dm-bufio.c

2557

c->slab_cache = kmem_cache_create(slab_name, block_size, align,

drivers/md/dm-bufio.c

977

unsigned int block_size;

drivers/md/dm-cache-policy-internal.h

147

sector_t origin_size, sector_t block_size);

drivers/md/dm-cache-policy.h

179

sector_t block_size);

drivers/md/dm-cache-target.c

2023

uint32_t block_size;

drivers/md/dm-cache-target.c

2120

unsigned long block_size;

drivers/md/dm-cache-target.c

2125

if (kstrtoul(dm_shift_arg(as), 10, &block_size) || !block_size ||

drivers/md/dm-cache-target.c

2126

block_size < DATA_DEV_BLOCK_SIZE_MIN_SECTORS ||

drivers/md/dm-cache-target.c

2127

block_size > DATA_DEV_BLOCK_SIZE_MAX_SECTORS ||

drivers/md/dm-cache-target.c

2128

block_size & (DATA_DEV_BLOCK_SIZE_MIN_SECTORS - 1)) {

drivers/md/dm-cache-target.c

2133

if (block_size > ca->cache_sectors) {

drivers/md/dm-cache-target.c

2138

ca->block_size = block_size;

drivers/md/dm-cache-target.c

2420

origin_blocks = block_div(origin_blocks, ca->block_size);

drivers/md/dm-cache-target.c

2423

cache->sectors_per_block = ca->block_size;

drivers/md/dm-cache-target.c

2429

if (ca->block_size & (ca->block_size - 1)) {

drivers/md/dm-cache-target.c

2433

cache_size = block_div(cache_size, ca->block_size);

drivers/md/dm-cache-target.c

2436

cache->sectors_per_block_shift = __ffs(ca->block_size);

drivers/md/dm-cache-target.c

2454

ca->block_size, may_format,

drivers/md/dm-cache-target.c

2852

dm_block_t block_size;

drivers/md/dm-cache-target.c

2873

b = li->discard_begin * li->block_size;

drivers/md/dm-cache-target.c

2874

e = li->discard_end * li->block_size;

drivers/md/dm-cache-target.c

2898

li->block_size = discard_block_size;

drivers/md/dm-era-target.c

1453

static bool valid_block_size(dm_block_t block_size)

drivers/md/dm-era-target.c

1455

bool greater_than_zero = block_size > 0;

drivers/md/dm-era-target.c

1456

bool multiple_of_min_block_size = (block_size & (MIN_BLOCK_SIZE - 1)) == 0;

drivers/md/dm-era-target.c

277

dm_block_t block_size;

drivers/md/dm-era-target.c

516

disk->data_block_size = cpu_to_le32(md->block_size);

drivers/md/dm-era-target.c

585

if (le32_to_cpu(disk->data_block_size) != md->block_size) {

drivers/md/dm-era-target.c

587

le32_to_cpu(disk->data_block_size), md->block_size);

drivers/md/dm-era-target.c

807

sector_t block_size,

drivers/md/dm-era-target.c

817

md->block_size = block_size;

drivers/md/dm-thin-metadata.c

254

size_t block_size)

drivers/md/dm-thin-metadata.c

260

block_size - sizeof(__le32),

drivers/md/dm-thin-metadata.c

266

size_t block_size)

drivers/md/dm-thin-metadata.c

286

block_size - sizeof(__le32),

drivers/md/dm-thin-metadata.c

460

unsigned int block_size = dm_bm_block_size(bm) / sizeof(__le64);

drivers/md/dm-thin-metadata.c

471

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

drivers/md/dm-thin.c

2830

static bool is_factor(sector_t block_size, uint32_t n)

drivers/md/dm-thin.c

2832

return !sector_div(block_size, n);

drivers/md/dm-thin.c

2937

unsigned long block_size,

drivers/md/dm-thin.c

2946

pmd = dm_pool_metadata_open(metadata_dev, block_size, format_device);

drivers/md/dm-thin.c

2960

pool->sectors_per_block = block_size;

drivers/md/dm-thin.c

2961

if (block_size & (block_size - 1))

drivers/md/dm-thin.c

2964

pool->sectors_per_block_shift = __ffs(block_size);

drivers/md/dm-thin.c

3087

unsigned long block_size, int read_only,

drivers/md/dm-thin.c

3113

pool = pool_create(pool_md, metadata_dev, data_dev, block_size, read_only, error);

drivers/md/dm-thin.c

3291

unsigned long block_size;

drivers/md/dm-thin.c

3342

if (kstrtoul(argv[2], 10, &block_size) || !block_size ||

drivers/md/dm-thin.c

3343

block_size < DATA_DEV_BLOCK_SIZE_MIN_SECTORS ||

drivers/md/dm-thin.c

3344

block_size > DATA_DEV_BLOCK_SIZE_MAX_SECTORS ||

drivers/md/dm-thin.c

3345

block_size & (DATA_DEV_BLOCK_SIZE_MIN_SECTORS - 1)) {

drivers/md/dm-thin.c

3364

block_size, pf.mode == PM_READ_ONLY, &ti->error, &pool_created);

drivers/md/dm-vdo/dm-vdo-target.c

1453

u64 block_size = VDO_BLOCK_SIZE;

drivers/md/dm-vdo/dm-vdo-target.c

1455

block_count_t logical_blocks = logical_size / block_size;

drivers/md/dm-vdo/dm-vdo-target.c

1460

vdo_log_debug("Physical block size = %llu", (u64) block_size);

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

1196

decode_u32_le(buffer, &offset, &super->block_size);

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

1353

static int __must_check load_super_block(struct index_layout *layout, size_t block_size,

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

1376

if (super->block_size != block_size) {

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

1380

super->block_size, block_size);

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

1725

int uds_open_volume_bufio(struct index_layout *layout, size_t block_size,

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

1733

return uds_make_bufio(layout->factory, offset, block_size, reserved_buffers,

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

180

u32 block_size;

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

205

size_t block_size;

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

229

sls->block_size = UDS_BLOCK_SIZE;

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

230

sls->volume_blocks = geometry->bytes_per_volume / sls->block_size;

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

232

result = uds_compute_volume_index_save_blocks(config, sls->block_size,

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

239

sls->block_size);

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

242

sls->block_size);

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

247

sls->total_size = sls->total_blocks * sls->block_size;

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

336

super->block_size = sls->block_size;

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

404

u64 next_block = layout->offset / sls->block_size;

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

704

encode_u32_le(buffer, &offset, layout->super.block_size);

drivers/md/dm-vdo/indexer/index-layout.h

39

int __must_check uds_open_volume_bufio(struct index_layout *layout, size_t block_size,

drivers/md/dm-vdo/indexer/io-factory.c

102

client = dm_bufio_client_create(factory->bdev, block_size, reserved_buffers, 0,

drivers/md/dm-vdo/indexer/io-factory.c

97

int uds_make_bufio(struct io_factory *factory, off_t block_offset, size_t block_size,

drivers/md/dm-vdo/indexer/io-factory.h

38

size_t block_size, unsigned int reserved_buffers,

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

372

size_t block_size, u64 *block_count)

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

382

*block_count = DIV_ROUND_UP(bytes, block_size) + MAX_ZONES;

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

147

size_t block_size,

drivers/md/dm-vdo/message-stats.c

337

write_u64("blockSize : ", stats->block_size, ", ", buf, maxlen);

drivers/md/dm-vdo/statistics.h

214

u64 block_size;

drivers/md/dm-vdo/vdo.c

1526

stats->block_size = VDO_BLOCK_SIZE;

drivers/md/dm-verity-target.c

468

const unsigned int block_size = 1 << v->data_dev_block_bits;

drivers/md/dm-verity-target.c

475

io->pending_blocks[1].data, block_size,

drivers/md/dm-verity-target.c

481

block_size,

drivers/md/dm-verity-target.c

511

const unsigned int block_size = 1 << v->data_dev_block_bits;

drivers/md/dm-verity-target.c

532

b++, bio_advance_iter_single(bio, iter, block_size)) {

drivers/md/dm-verity-target.c

551

if (unlikely(bv.bv_len < block_size)) {

drivers/md/dm-verity-target.c

570

memset(data, 0, block_size);

drivers/md/dm-writecache.c

1251

unsigned int remaining_size = wc->block_size;

drivers/md/dm-writecache.c

1365

dm_accept_partial_bio(bio, wc->block_size >> SECTOR_SHIFT);

drivers/md/dm-writecache.c

1374

wc->stats.reads += (bio->bi_iter.bi_size - wc->block_size) >> wc->block_size_bits;

drivers/md/dm-writecache.c

1384

unsigned int bio_size = wc->block_size;

drivers/md/dm-writecache.c

1408

read_original_sector(wc, e) + (wc->block_size >> SECTOR_SHIFT))

drivers/md/dm-writecache.c

1416

bio_size += wc->block_size;

drivers/md/dm-writecache.c

1417

current_cache_sec += wc->block_size >> SECTOR_SHIFT;

drivers/md/dm-writecache.c

1425

wc->stats.writes_allocate += (bio->bi_iter.bi_size - wc->block_size) >> wc->block_size_bits;

drivers/md/dm-writecache.c

154

unsigned int block_size;

drivers/md/dm-writecache.c

1557

(wc->block_size / 512 - 1)) != 0)) {

drivers/md/dm-writecache.c

1560

bio->bi_iter.bi_size, wc->block_size);

drivers/md/dm-writecache.c

1643

if (limits->logical_block_size < wc->block_size)

drivers/md/dm-writecache.c

1644

limits->logical_block_size = wc->block_size;

drivers/md/dm-writecache.c

1646

if (limits->physical_block_size < wc->block_size)

drivers/md/dm-writecache.c

1647

limits->physical_block_size = wc->block_size;

drivers/md/dm-writecache.c

1649

if (limits->io_min < wc->block_size)

drivers/md/dm-writecache.c

1650

limits->io_min = wc->block_size;

drivers/md/dm-writecache.c

1799

unsigned int block_size = wc->block_size;

drivers/md/dm-writecache.c

1802

persistent_memory_flush_cache(address, block_size);

drivers/md/dm-writecache.c

1808

block_size, persistent_memory_page_offset(address)) != 0;

drivers/md/dm-writecache.c

1867

read_original_sector(wc, e) + (wc->block_size >> SECTOR_SHIFT))

drivers/md/dm-writecache.c

1919

while ((n_sectors -= wc->block_size >> SECTOR_SHIFT)) {

drivers/md/dm-writecache.c

2048

read_original_sector(wc, f) + (wc->block_size >> SECTOR_SHIFT))

drivers/md/dm-writecache.c

2112

static int calculate_memory_size(uint64_t device_size, unsigned int block_size,

drivers/md/dm-writecache.c

2119

do_div(n_blocks, block_size + sizeof(struct wc_memory_entry));

drivers/md/dm-writecache.c

2129

offset = (offset + block_size - 1) & ~(uint64_t)(block_size - 1);

drivers/md/dm-writecache.c

2130

if (offset + n_blocks * block_size <= device_size)

drivers/md/dm-writecache.c

2143

*n_metadata_blocks_p = offset >> __ffs(block_size);

drivers/md/dm-writecache.c

2152

r = calculate_memory_size(wc->memory_map_size, wc->block_size, &wc->n_blocks, NULL);

drivers/md/dm-writecache.c

2163

pmem_assign(sb(wc)->block_size, cpu_to_le32(wc->block_size));

drivers/md/dm-writecache.c

2375

if (sscanf(string, "%u%c", &wc->block_size, &dummy) != 1 ||

drivers/md/dm-writecache.c

2376

wc->block_size < 512 || wc->block_size > PAGE_SIZE ||

drivers/md/dm-writecache.c

2377

(wc->block_size & (wc->block_size - 1))) {

drivers/md/dm-writecache.c

2382

if (wc->block_size < bdev_logical_block_size(wc->dev->bdev) ||

drivers/md/dm-writecache.c

2383

wc->block_size < bdev_logical_block_size(wc->ssd_dev->bdev)) {

drivers/md/dm-writecache.c

2388

wc->block_size_bits = __ffs(wc->block_size);

drivers/md/dm-writecache.c

2533

r = calculate_memory_size(wc->memory_map_size, wc->block_size,

drivers/md/dm-writecache.c

2574

r = writecache_read_metadata(wc, wc->block_size >> SECTOR_SHIFT);

drivers/md/dm-writecache.c

2612

if (le32_to_cpu(s.block_size) != wc->block_size) {

drivers/md/dm-writecache.c

2630

offset = (offset + wc->block_size - 1) & ~(size_t)(wc->block_size - 1);

drivers/md/dm-writecache.c

2631

data_size = wc->n_blocks * (size_t)wc->block_size;

drivers/md/dm-writecache.c

2632

if (!offset || (data_size / wc->block_size != wc->n_blocks) ||

drivers/md/dm-writecache.c

2705

wc->dev->name, wc->ssd_dev->name, wc->block_size);

drivers/md/dm-writecache.c

556

region.count = max(4096U, wc->block_size) >> SECTOR_SHIFT;

drivers/md/dm-writecache.c

71

__le32 block_size;

drivers/md/dm-writecache.c

785

writecache_flush_region(wc, memory_data(wc, e), wc->block_size);

drivers/md/persistent-data/dm-block-manager.c

385

unsigned int block_size,

drivers/md/persistent-data/dm-block-manager.c

397

bm->bufio = dm_bufio_client_create(bdev, block_size, max_held_per_thread,

drivers/md/persistent-data/dm-block-manager.h

36

struct block_device *bdev, unsigned int block_size,

drivers/md/persistent-data/dm-block-manager.h

55

struct dm_block *b, size_t block_size);

drivers/md/persistent-data/dm-block-manager.h

61

struct dm_block *b, size_t block_size);

drivers/md/persistent-data/dm-btree-spine.c

21

size_t block_size)

drivers/md/persistent-data/dm-btree-spine.c

28

block_size - sizeof(__le32),

drivers/md/persistent-data/dm-btree-spine.c

34

size_t block_size)

drivers/md/persistent-data/dm-btree-spine.c

49

block_size - sizeof(__le32),

drivers/md/persistent-data/dm-btree-spine.c

62

(sizeof(__le64) + value_size) * max_entries > block_size) {

drivers/md/persistent-data/dm-btree.c

117

static uint32_t calc_max_entries(size_t value_size, size_t block_size)

drivers/md/persistent-data/dm-btree.c

122

block_size -= sizeof(struct node_header);

drivers/md/persistent-data/dm-btree.c

123

total = block_size / elt_size;

drivers/md/persistent-data/dm-btree.c

134

size_t block_size;

drivers/md/persistent-data/dm-btree.c

141

block_size = dm_bm_block_size(dm_tm_get_bm(info->tm));

drivers/md/persistent-data/dm-btree.c

142

max_entries = calc_max_entries(info->value_type.size, block_size);

drivers/md/persistent-data/dm-btree.c

145

memset(n, 0, block_size);

drivers/md/persistent-data/dm-space-map-common.c

101

block_size - sizeof(__le32),

drivers/md/persistent-data/dm-space-map-common.c

220

ll->block_size = dm_bm_block_size(dm_tm_get_bm(tm));

drivers/md/persistent-data/dm-space-map-common.c

222

if (ll->block_size > (1 << 30)) {

drivers/md/persistent-data/dm-space-map-common.c

227

ll->entries_per_block = (ll->block_size - sizeof(struct disk_bitmap_header)) *

drivers/md/persistent-data/dm-space-map-common.c

27

size_t block_size)

drivers/md/persistent-data/dm-space-map-common.c

33

block_size - sizeof(__le32),

drivers/md/persistent-data/dm-space-map-common.c

39

size_t block_size)

drivers/md/persistent-data/dm-space-map-common.c

51

block_size - sizeof(__le32),

drivers/md/persistent-data/dm-space-map-common.c

77

size_t block_size)

drivers/md/persistent-data/dm-space-map-common.c

83

block_size - sizeof(__le32),

drivers/md/persistent-data/dm-space-map-common.c

89

size_t block_size)

drivers/md/persistent-data/dm-space-map-common.h

77

uint32_t block_size;

drivers/md/raid5-ppl.c

1393

ppl_conf->block_size = 512;

drivers/md/raid5-ppl.c

1395

ppl_conf->block_size =

drivers/md/raid5-ppl.c

452

ilog2(ppl_conf->block_size >> 9));

drivers/md/raid5-ppl.c

790

int block_size = ppl_conf->block_size;

drivers/md/raid5-ppl.c

810

r_sector_first = le64_to_cpu(e->data_sector) * (block_size >> 9);

drivers/md/raid5-ppl.c

834

if (block_size == 512 &&

drivers/md/raid5-ppl.c

837

block_size = RAID5_STRIPE_SIZE(conf);

drivers/md/raid5-ppl.c

840

for (i = 0; i < strip_sectors; i += (block_size >> 9)) {

drivers/md/raid5-ppl.c

895

if (!sync_page_io(rdev, sector, block_size, page2,

drivers/md/raid5-ppl.c

904

ppl_xor(block_size, page1, page2);

drivers/md/raid5-ppl.c

918

block_size, page2, REQ_OP_READ,

drivers/md/raid5-ppl.c

927

ppl_xor(block_size, page1, page2);

drivers/md/raid5-ppl.c

94

int block_size; /* the logical block size used for data_sector

drivers/md/raid5-ppl.c

942

if (!sync_page_io(parity_rdev, parity_sector, block_size,

drivers/media/dvb-frontends/drx39xyj/drxj.c

1593

u16 block_size = 0;

drivers/media/dvb-frontends/drx39xyj/drxj.c

1616

block_size = ((DRXDAP_MAX_WCHUNKSIZE) - overhead_size) & ~1;

drivers/media/dvb-frontends/drx39xyj/drxj.c

1655

todo = min(block_size, datasize);

drivers/media/dvb-frontends/drxk_hard.c

1280

u16 block_size;

drivers/media/dvb-frontends/drxk_hard.c

1304

block_size = ((p_src[0] << 8) | p_src[1]) * sizeof(u16);

drivers/media/dvb-frontends/drxk_hard.c

1322

if (offset + block_size > length) {

drivers/media/dvb-frontends/drxk_hard.c

1327

status = write_block(state, address, block_size, p_src);

drivers/media/dvb-frontends/drxk_hard.c

1332

p_src += block_size;

drivers/media/dvb-frontends/drxk_hard.c

1333

offset += block_size;

drivers/media/dvb-frontends/drxk_hard.c

399

const int block_size, const u8 p_block[])

drivers/media/dvb-frontends/drxk_hard.c

401

int status = 0, blk_size = block_size;

drivers/media/dvb-frontends/mxl5xx.c

849

u32 block_size = ((MXL_HYDRA_OEM_MAX_BLOCK_WRITE_LENGTH -

drivers/media/dvb-frontends/mxl5xx.c

856

size = orig_size = (((u32)(data_count + block_size)) > total_size) ?

drivers/media/dvb-frontends/mxl5xx.c

857

(total_size - data_count) : block_size;

drivers/media/usb/gspca/jl2005bcd.c

351

bytes_left = buffer[0x07] * dev->block_size - act_len;

drivers/media/usb/gspca/jl2005bcd.c

36

int block_size; /* block size of camera */

drivers/media/usb/gspca/jl2005bcd.c

422

sd->block_size = 0x80;

drivers/media/usb/gspca/jl2005bcd.c

426

sd->block_size = 0x200;

drivers/memstick/core/ms_block.c

1178

p->attr.block_size = be16_to_cpu(p->attr.block_size);

drivers/memstick/core/ms_block.c

1524

msb->cache = kzalloc(msb->block_size, GFP_KERNEL);

drivers/memstick/core/ms_block.c

1551

sg_init_one(&sg, msb->cache , msb->block_size);

drivers/memstick/core/ms_block.c

1735

msb->pages_in_block = boot_block->attr.block_size * 2;

drivers/memstick/core/ms_block.c

1736

msb->block_size = msb->page_size * msb->pages_in_block;

drivers/memstick/core/ms_block.c

1744

msb->block_buffer = kzalloc(msb->block_size, GFP_KERNEL);

drivers/memstick/core/ms_block.c

1748

raw_size_in_megs = (msb->block_size * msb->block_count) >> 20;

drivers/memstick/core/ms_block.c

1818

if (page == 0 && len - offset >= msb->block_size) {

drivers/memstick/core/ms_block.c

1828

offset += msb->block_size;

drivers/memstick/core/ms_block.c

1829

*sucessfuly_written += msb->block_size;

drivers/memstick/core/ms_block.c

2239

if (msb->block_size != new_msb->block_size)

drivers/memstick/core/ms_block.c

982

sg_init_one(&sg, msb->block_buffer, msb->block_size);

drivers/memstick/core/ms_block.c

994

msb->block_buffer, msb->block_size))

drivers/memstick/core/ms_block.h

170

int block_size;

drivers/memstick/core/ms_block.h

76

unsigned short block_size;

drivers/memstick/core/mspro_block.c

1158

capacity *= be16_to_cpu(sys_info->block_size);

drivers/memstick/core/mspro_block.c

294

rc += sysfs_emit_at(buffer, rc, "block size: %x\n", be16_to_cpu(x_sys->block_size));

drivers/memstick/core/mspro_block.c

71

__be16 block_size;

drivers/misc/c2port/c2port-duramar2150.c

102

.block_size = 512, /* bytes */

drivers/misc/c2port/core.c

328

return sprintf(buf, "%d\n", ops->block_size);

drivers/misc/c2port/core.c

338

return sprintf(buf, "%d\n", ops->blocks_num * ops->block_size);

drivers/misc/c2port/core.c

634

if (offset >= ops->block_size * ops->blocks_num)

drivers/misc/c2port/core.c

637

if (ops->block_size * ops->blocks_num - offset < nread)

drivers/misc/c2port/core.c

638

nread = ops->block_size * ops->blocks_num - offset;

drivers/misc/c2port/core.c

746

if (ops->block_size * ops->blocks_num - offset < nwrite)

drivers/misc/c2port/core.c

747

nwrite = ops->block_size * ops->blocks_num - offset;

drivers/misc/c2port/core.c

750

if (offset >= ops->block_size * ops->blocks_num)

drivers/misc/c2port/core.c

884

return c2dev->ops->blocks_num * c2dev->ops->block_size;

drivers/misc/c2port/core.c

948

name, ops->blocks_num, ops->block_size,

drivers/misc/c2port/core.c

949

ops->blocks_num * ops->block_size);

drivers/mmc/host/omap.c

1065

host->total_bytes_left = data->blocks * block_size;

drivers/mmc/host/omap.c

954

int i, use_dma = 1, block_size;

drivers/mmc/host/omap.c

968

block_size = data->blksz;

drivers/mmc/host/omap.c

971

OMAP_MMC_WRITE(host, BLEN, block_size - 1);

drivers/mmc/host/omap.c

981

if ((sg->length % block_size) != 0) {

drivers/mmc/host/ushc.c

279

ushc->cbw->block_size = cpu_to_le16(req->data->blksz);

drivers/mmc/host/ushc.c

281

ushc->cbw->block_size = 0;

drivers/mmc/host/ushc.c

66

__le16 block_size;

drivers/mmc/host/vub300.c

1078

vub300->cmnd.head.block_size[0] = (vub300->fbs[fn] >> 8) & 0xFF;

drivers/mmc/host/vub300.c

1079

vub300->cmnd.head.block_size[1] = (vub300->fbs[fn] >> 0) & 0xFF;

drivers/mmc/host/vub300.c

1088

vub300->cmnd.head.block_size[0] = (vub300->fbs[0] >> 8) & 0xFF;

drivers/mmc/host/vub300.c

1089

vub300->cmnd.head.block_size[1] = (vub300->fbs[0] >> 0) & 0xFF;

drivers/mmc/host/vub300.c

1102

vub300->cmnd.head.block_size[0] =

drivers/mmc/host/vub300.c

1104

vub300->cmnd.head.block_size[1] =

drivers/mmc/host/vub300.c

1109

vub300->cmnd.head.block_size[0] =

drivers/mmc/host/vub300.c

1111

vub300->cmnd.head.block_size[1] =

drivers/mmc/host/vub300.c

1131

vub300->cmnd.head.block_size[0] = (data->blksz >> 8) & 0xFF;

drivers/mmc/host/vub300.c

1132

vub300->cmnd.head.block_size[1] = (data->blksz >> 0) & 0xFF;

drivers/mmc/host/vub300.c

1148

if (vub300->cmnd.head.block_size[0] || vub300->cmnd.head.block_size[1]) {

drivers/mmc/host/vub300.c

1149

u16 block_size = vub300->cmnd.head.block_size[1] |

drivers/mmc/host/vub300.c

1150

(vub300->cmnd.head.block_size[0] << 8);

drivers/mmc/host/vub300.c

1152

(FIRMWARE_BLOCK_BOUNDARY % block_size);

drivers/mmc/host/vub300.c

2175

vub300->cmnd.head.block_size[0] = 0x00;

drivers/mmc/host/vub300.c

2176

vub300->cmnd.head.block_size[1] = 0x00;

drivers/mmc/host/vub300.c

70

u8 block_size[2];

drivers/mtd/nand/onenand/onenand_base.c

2136

unsigned int block_size = (1 << this->erase_shift);

drivers/mtd/nand/onenand/onenand_base.c

2140

this->command(mtd, ONENAND_CMD_ERASE_VERIFY, addr, block_size);

drivers/mtd/nand/onenand/onenand_base.c

2148

len -= block_size;

drivers/mtd/nand/onenand/onenand_base.c

2149

addr += block_size;

drivers/mtd/nand/onenand/onenand_base.c

2164

unsigned int block_size)

drivers/mtd/nand/onenand/onenand_base.c

2188

len -= block_size;

drivers/mtd/nand/onenand/onenand_base.c

2189

addr += block_size;

drivers/mtd/nand/onenand/onenand_base.c

2215

while (len > block_size && eb_count < (max_eb_count - 1)) {

drivers/mtd/nand/onenand/onenand_base.c

2217

addr, block_size);

drivers/mtd/nand/onenand/onenand_base.c

2218

onenand_invalidate_bufferram(mtd, addr, block_size);

drivers/mtd/nand/onenand/onenand_base.c

2229

len -= block_size;

drivers/mtd/nand/onenand/onenand_base.c

2230

addr += block_size;

drivers/mtd/nand/onenand/onenand_base.c

2236

this->command(mtd, ONENAND_CMD_ERASE, addr, block_size);

drivers/mtd/nand/onenand/onenand_base.c

2237

onenand_invalidate_bufferram(mtd, addr, block_size);

drivers/mtd/nand/onenand/onenand_base.c

2248

len -= block_size;

drivers/mtd/nand/onenand/onenand_base.c

2249

addr += block_size;

drivers/mtd/nand/onenand/onenand_base.c

2253

verify_instr.len = eb_count * block_size;

drivers/mtd/nand/onenand/onenand_base.c

2276

unsigned int block_size)

drivers/mtd/nand/onenand/onenand_base.c

2301

this->command(mtd, ONENAND_CMD_ERASE, addr, block_size);

drivers/mtd/nand/onenand/onenand_base.c

2303

onenand_invalidate_bufferram(mtd, addr, block_size);

drivers/mtd/nand/onenand/onenand_base.c

2314

len -= block_size;

drivers/mtd/nand/onenand/onenand_base.c

2315

addr += block_size;

drivers/mtd/nand/onenand/onenand_base.c

2322

block_size = region->erasesize;

drivers/mtd/nand/onenand/onenand_base.c

2325

if (len & (block_size - 1)) {

drivers/mtd/nand/onenand/onenand_base.c

2346

unsigned int block_size;

drivers/mtd/nand/onenand/onenand_base.c

2362

block_size = region->erasesize;

drivers/mtd/nand/onenand/onenand_base.c

2369

block_size = 1 << this->erase_shift;

drivers/mtd/nand/onenand/onenand_base.c

2372

if (unlikely((addr - region_offset) & (block_size - 1))) {

drivers/mtd/nand/onenand/onenand_base.c

2378

if (unlikely(len & (block_size - 1))) {

drivers/mtd/nand/onenand/onenand_base.c

2387

instr->len < MB_ERASE_MIN_BLK_COUNT * block_size) {

drivers/mtd/nand/onenand/onenand_base.c

2390

region, block_size);

drivers/mtd/nand/onenand/onenand_base.c

2392

ret = onenand_multiblock_erase(mtd, instr, block_size);

drivers/mtd/nand/raw/brcmnand/brcmnand.c

2763

u8 block_size = 0, page_size = 0, device_size = 0;

drivers/mtd/nand/raw/brcmnand/brcmnand.c

2770

if (ctrl->block_sizes[i] * 1024 == cfg->block_size) {

drivers/mtd/nand/raw/brcmnand/brcmnand.c

2771

block_size = i;

drivers/mtd/nand/raw/brcmnand/brcmnand.c

2776

cfg->block_size);

drivers/mtd/nand/raw/brcmnand/brcmnand.c

2780

block_size = ffs(cfg->block_size) - ffs(BRCMNAND_MIN_BLOCKSIZE);

drivers/mtd/nand/raw/brcmnand/brcmnand.c

2783

if (cfg->block_size < BRCMNAND_MIN_BLOCKSIZE || (ctrl->max_block_size &&

drivers/mtd/nand/raw/brcmnand/brcmnand.c

2784

cfg->block_size > ctrl->max_block_size)) {

drivers/mtd/nand/raw/brcmnand/brcmnand.c

2786

cfg->block_size);

drivers/mtd/nand/raw/brcmnand/brcmnand.c

2787

block_size = 0;

drivers/mtd/nand/raw/brcmnand/brcmnand.c

2827

(block_size << CFG_BLK_SIZE_SHIFT);

drivers/mtd/nand/raw/brcmnand/brcmnand.c

2832

(block_size << CFG_EXT_BLK_SIZE_SHIFT);

drivers/mtd/nand/raw/brcmnand/brcmnand.c

2859

cfg->block_size >> 10,

drivers/mtd/nand/raw/brcmnand/brcmnand.c

2939

cfg->block_size = mtd->erasesize;

drivers/mtd/nand/raw/brcmnand/brcmnand.c

321

unsigned int block_size;

drivers/mtd/rfd_ftl.c

158

sectors_per_block = part->block_size / SECTOR_SIZE;

drivers/mtd/rfd_ftl.c

159

part->total_blocks = (u32)part->mbd.mtd->size / part->block_size;

drivers/mtd/rfd_ftl.c

201

rc = mtd_read(part->mbd.mtd, i * part->block_size,

drivers/mtd/rfd_ftl.c

26

static int block_size = 0;

drivers/mtd/rfd_ftl.c

27

module_param(block_size, int, 0);

drivers/mtd/rfd_ftl.c

277

erase->len = part->block_size;

drivers/mtd/rfd_ftl.c

28

MODULE_PARM_DESC(block_size, "Block size to use by RFD, defaults to erase unit size");

drivers/mtd/rfd_ftl.c

417

old_sector_block = *old_sector / part->block_size;

drivers/mtd/rfd_ftl.c

551

block = old_addr / part->block_size;

drivers/mtd/rfd_ftl.c

552

offset = (old_addr % part->block_size) / SECTOR_SIZE -

drivers/mtd/rfd_ftl.c

74

u_int block_size; /* size of erase unit */

drivers/mtd/rfd_ftl.c

760

if (block_size)

drivers/mtd/rfd_ftl.c

761

part->block_size = block_size;

drivers/mtd/rfd_ftl.c

767

part->block_size = mtd->erasesize;

drivers/mtd/rfd_ftl.c

98

block->offset = part->block_size * block_no;

drivers/mtd/sm_ftl.c

1163

ftl->cache_data = kzalloc(ftl->block_size, GFP_KERNEL);

drivers/mtd/sm_ftl.c

1182

trans->size = (ftl->block_size * ftl->max_lba * ftl->zone_count) >> 9;

drivers/mtd/sm_ftl.c

1203

ftl->block_size);

drivers/mtd/sm_ftl.c

195

WARN_ON(boffset >= ftl->block_size);

drivers/mtd/sm_ftl.c

200

return (zone * SM_MAX_ZONE_SIZE + block) * ftl->block_size + boffset;

drivers/mtd/sm_ftl.c

208

*boffset = do_div(offset, ftl->block_size);

drivers/mtd/sm_ftl.c

383

for (boffset = 0; boffset < ftl->block_size;

drivers/mtd/sm_ftl.c

454

for (boffset = 0; boffset < ftl->block_size; boffset += SM_SECTOR_SIZE)

drivers/mtd/sm_ftl.c

470

erase.len = ftl->block_size;

drivers/mtd/sm_ftl.c

512

for (boffset = 0; boffset < ftl->block_size;

drivers/mtd/sm_ftl.c

578

ftl->block_size = 8 * SM_SECTOR_SIZE;

drivers/mtd/sm_ftl.c

587

ftl->block_size = 8 * SM_SECTOR_SIZE;

drivers/mtd/sm_ftl.c

597

ftl->block_size = 16 * SM_SECTOR_SIZE;

drivers/mtd/sm_ftl.c

604

ftl->block_size = 16 * SM_SECTOR_SIZE;

drivers/mtd/sm_ftl.c

610

ftl->block_size = 16 * SM_SECTOR_SIZE;

drivers/mtd/sm_ftl.c

620

ftl->block_size = 32 * SM_SECTOR_SIZE;

drivers/mtd/sm_ftl.c

624

if (mtd->erasesize > ftl->block_size)

drivers/mtd/sm_ftl.c

701

for (boffset = 0 ; boffset < ftl->block_size;

drivers/mtd/sm_ftl.c

712

if (boffset == ftl->block_size)

drivers/mtd/sm_ftl.c

728

block * ftl->block_size +

drivers/mtd/sm_ftl.c

950

ftl->block_size / SM_SECTOR_SIZE) {

drivers/mtd/sm_ftl.h

32

int block_size; /* block size in bytes */

drivers/net/dsa/microchip/ksz9477_acl.c

618

int block_size;

drivers/net/dsa/microchip/ksz9477_acl.c

621

block_size = ksz9477_acl_get_cont_entr(dev, port, i);

drivers/net/dsa/microchip/ksz9477_acl.c

622

if (block_size < 0 && block_size != -ENOTEMPTY)

drivers/net/dsa/microchip/ksz9477_acl.c

623

return block_size;

drivers/net/dsa/microchip/ksz9477_acl.c

625

if (block_size > 0)

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

295

u16 block_size, u8 *block, bool last_cmd,

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

308

block_size, module, offset);

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

312

err = ice_aq_update_nvm(hw, module, offset, block_size, block,

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

316

module, block_size, offset, err,

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

331

module, block_size, offset, err);

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

360

module, block_size, offset,

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

429

u32 block_size;

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

431

block_size = min_t(u32, ICE_AQ_MAX_BUF_LEN, length - offset);

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

432

last_cmd = !(offset + block_size < length);

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

438

memcpy(block, image + offset, block_size);

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

440

err = ice_write_one_nvm_block(pf, module, offset, block_size,

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

446

offset += block_size;

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

13

u16 block_size, u8 *block, bool last_cmd,

drivers/net/ethernet/intel/ixgbe/ixgbe_fw_update.c

241

u16 block_size, u8 *block, bool last_cmd,

drivers/net/ethernet/intel/ixgbe/ixgbe_fw_update.c

246

return ixgbe_aci_update_nvm(hw, module, offset, block_size, block,

drivers/net/ethernet/intel/ixgbe/ixgbe_fw_update.c

286

u32 block_size;

drivers/net/ethernet/intel/ixgbe/ixgbe_fw_update.c

288

block_size = min_t(u32, IXGBE_ACI_MAX_BUFFER_SIZE,

drivers/net/ethernet/intel/ixgbe/ixgbe_fw_update.c

290

last_cmd = !(offset + block_size < length);

drivers/net/ethernet/intel/ixgbe/ixgbe_fw_update.c

292

memcpy(block, image + offset, block_size);

drivers/net/ethernet/intel/ixgbe/ixgbe_fw_update.c

295

block_size, block, last_cmd,

drivers/net/ethernet/intel/ixgbe/ixgbe_fw_update.c

300

offset += block_size;

drivers/net/ethernet/mellanox/mlxfw/mlxfw_fsm.c

216

u16 block_size;

drivers/net/ethernet/mellanox/mlxfw/mlxfw_fsm.c

268

block_size = (u16) min_t(u32, comp->data_size - offset,

drivers/net/ethernet/mellanox/mlxfw/mlxfw_fsm.c

271

block_ptr, block_size,

drivers/net/ethernet/mellanox/mlxfw/mlxfw_fsm.c

279

comp_name, offset + block_size,

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

344

tran_buf = kmalloc(mlxsw_i2c->block_size + MLXSW_I2C_ADDR_BUF_SIZE,

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

351

chunk_size = (in_mbox_size > mlxsw_i2c->block_size) ?

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

352

mlxsw_i2c->block_size : in_mbox_size;

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

356

mlxsw_i2c->block_size * i, chunk_size);

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

427

num = DIV_ROUND_UP(reg_size, mlxsw_i2c->block_size);

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

446

num = DIV_ROUND_UP(reg_size, mlxsw_i2c->block_size);

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

462

chunk_size = (reg_size > mlxsw_i2c->block_size) ?

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

463

mlxsw_i2c->block_size : reg_size;

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

655

mlxsw_i2c->block_size = min_t(u16, MLXSW_I2C_BLK_MAX,

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

659

mlxsw_i2c->block_size = MLXSW_I2C_BLK_DEF;

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

92

u16 block_size;

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

3195

u32 block_size, ram_size, offset = 0, reg_val, i;

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

3204

block_size = reg_val &

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

3218

block_size * 8,

drivers/net/ethernet/qlogic/qlcnic/qlcnic.h

278

u32 block_size;

drivers/net/ethernet/sfc/falcon/falcon.c

2168

spi_device->block_size =

drivers/net/ethernet/sfc/falcon/falcon.c

661

(spi->block_size - (start & (spi->block_size - 1))));

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

205

unsigned int block_size;

drivers/net/phy/sfp.c

2237

size_t i, block_size = sfp->i2c_block_size;

drivers/net/phy/sfp.c

2240

if (block_size == 1)

drivers/net/phy/sfp.c

2243

for (i = 1; i < len; i += block_size) {

drivers/net/phy/sfp.c

2244

if (memchr_inv(buf + i, '\0', min(block_size - 1, len - i)))

drivers/net/phy/sfp.c

679

size_t block_size = sfp->i2c_block_size;

drivers/net/phy/sfp.c

694

if (this_len > block_size)

drivers/net/phy/sfp.c

695

this_len = block_size;

drivers/net/wireless/ath/ath10k/sdio.c

1086

mbox_info->block_size = ATH10K_HIF_MBOX_BLOCK_SIZE;

drivers/net/wireless/ath/ath10k/sdio.c

206

ret = sdio_set_block_size(func, ar_sdio->mbox_info.block_size);

drivers/net/wireless/ath/ath10k/sdio.c

209

ar_sdio->mbox_info.block_size, ret);

drivers/net/wireless/ath/ath10k/sdio.c

359

len = round_down(len, ar_sdio->mbox_info.block_size);

drivers/net/wireless/ath/ath10k/sdio.h

178

u32 block_size;

drivers/net/wireless/ath/ath6kl/core.h

522

u32 block_size;

drivers/net/wireless/ath/ath6kl/hif.c

680

dev->htc_cnxt->block_sz = dev->ar->mbox_info.block_size;

drivers/net/wireless/ath/ath6kl/htc_mbox.c

2782

u32 block_size, ctrl_bufsz;

drivers/net/wireless/ath/ath6kl/htc_mbox.c

2788

block_size = target->dev->ar->mbox_info.block_size;

drivers/net/wireless/ath/ath6kl/htc_mbox.c

2790

ctrl_bufsz = (block_size > HTC_MAX_CTRL_MSG_LEN) ?

drivers/net/wireless/ath/ath6kl/htc_mbox.c

2791

(block_size + HTC_HDR_LENGTH) :

drivers/net/wireless/ath/ath6kl/init.c

422

blk_size = ar->mbox_info.block_size;

drivers/net/wireless/ath/ath6kl/sdio.c

104

mbox_info->block_size = HIF_MBOX_BLOCK_SIZE;

drivers/net/wireless/ath/ath6kl/usb.c

1162

ar->mbox_info.block_size = 16;

drivers/net/wireless/intel/iwlwifi/fw/api/paging.h

24

__le32 block_size;

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

242

.block_size = cpu_to_le32(BLOCK_2_EXP_SIZE),

drivers/net/wireless/intersil/p54/p54usb.c

504

unsigned int left, remains, block_size;

drivers/net/wireless/intersil/p54/p54usb.c

516

left = block_size = min_t(size_t, P54U_FW_BLOCK, priv->fw->size);

drivers/net/wireless/intersil/p54/p54usb.c

558

err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_size);

drivers/net/wireless/intersil/p54/p54usb.c

566

left = block_size = min((unsigned int)P54U_FW_BLOCK, remains);

drivers/net/wireless/marvell/mwifiex/fw.h

1507

__le16 block_size;

drivers/net/wireless/marvell/mwifiex/sta_cmdresp.c

1013

adapter->sdio_rx_block_size = le16_to_cpu(cfg->block_size);

drivers/net/wireless/marvell/mwl8k.c

667

int block_size = length > 256 ? 256 : length;

drivers/net/wireless/marvell/mwl8k.c

669

memcpy(cmd->payload, data + done, block_size);

drivers/net/wireless/marvell/mwl8k.c

670

cmd->length = cpu_to_le16(block_size);

drivers/net/wireless/marvell/mwl8k.c

673

sizeof(*cmd) + block_size);

drivers/net/wireless/marvell/mwl8k.c

677

done += block_size;

drivers/net/wireless/marvell/mwl8k.c

678

length -= block_size;

drivers/net/wireless/marvell/mwl8k.c

706

u32 block_size;

drivers/net/wireless/marvell/mwl8k.c

708

block_size = ioread32(priv->regs + MWL8K_HIU_SCRATCH);

drivers/net/wireless/marvell/mwl8k.c

709

if (block_size & 1) {

drivers/net/wireless/marvell/mwl8k.c

710

block_size &= ~1;

drivers/net/wireless/marvell/mwl8k.c

717

if (block_size > 1024 || block_size > length) {

drivers/net/wireless/marvell/mwl8k.c

727

if (block_size == 0) {

drivers/net/wireless/marvell/mwl8k.c

734

prev_block_size = block_size;

drivers/net/wireless/marvell/mwl8k.c

735

memcpy(buffer, data + done, block_size);

drivers/net/wireless/marvell/mwl8k.c

737

rc = mwl8k_send_fw_load_cmd(priv, buffer, block_size);

drivers/net/wireless/mediatek/mt76/mt7615/mcu.c

46

__le32 block_size;

drivers/net/wireless/microchip/wilc1000/sdio.c

105

func->cur_blksize = cmd->block_size;

drivers/net/wireless/microchip/wilc1000/sdio.c

107

size = cmd->count * cmd->block_size;

drivers/net/wireless/microchip/wilc1000/sdio.c

32

u32 block_size;

drivers/net/wireless/microchip/wilc1000/sdio.c

338

u32 block_size)

drivers/net/wireless/microchip/wilc1000/sdio.c

348

cmd.data = (u8)block_size;

drivers/net/wireless/microchip/wilc1000/sdio.c

357

cmd.data = (u8)(block_size >> 8);

drivers/net/wireless/microchip/wilc1000/sdio.c

411

cmd.block_size = sdio_priv->block_size;

drivers/net/wireless/microchip/wilc1000/sdio.c

425

u32 block_size = sdio_priv->block_size;

drivers/net/wireless/microchip/wilc1000/sdio.c

445

nblk = size / block_size;

drivers/net/wireless/microchip/wilc1000/sdio.c

446

nleft = size % block_size;

drivers/net/wireless/microchip/wilc1000/sdio.c

454

cmd.block_size = block_size;

drivers/net/wireless/microchip/wilc1000/sdio.c

467

addr += nblk * block_size;

drivers/net/wireless/microchip/wilc1000/sdio.c

468

buf += nblk * block_size;

drivers/net/wireless/microchip/wilc1000/sdio.c

477

cmd.block_size = block_size;

drivers/net/wireless/microchip/wilc1000/sdio.c

53

u32 block_size;

drivers/net/wireless/microchip/wilc1000/sdio.c

531

cmd.block_size = sdio_priv->block_size;

drivers/net/wireless/microchip/wilc1000/sdio.c

548

u32 block_size = sdio_priv->block_size;

drivers/net/wireless/microchip/wilc1000/sdio.c

568

nblk = size / block_size;

drivers/net/wireless/microchip/wilc1000/sdio.c

569

nleft = size % block_size;

drivers/net/wireless/microchip/wilc1000/sdio.c

577

cmd.block_size = block_size;

drivers/net/wireless/microchip/wilc1000/sdio.c

590

addr += nblk * block_size;

drivers/net/wireless/microchip/wilc1000/sdio.c

591

buf += nblk * block_size;

drivers/net/wireless/microchip/wilc1000/sdio.c

600

cmd.block_size = block_size;

drivers/net/wireless/microchip/wilc1000/sdio.c

706

sdio_priv->block_size = WILC_SDIO_BLOCK_SIZE;

drivers/net/wireless/realtek/rtw88/usb.c

175

u32 n, block_size;

drivers/net/wireless/realtek/rtw88/usb.c

180

block_size = 254;

drivers/net/wireless/realtek/rtw88/usb.c

183

block_size = 196;

drivers/net/wireless/realtek/rtw88/usb.c

196

if (size >= block_size)

drivers/net/wireless/realtek/rtw88/usb.c

197

n = block_size;

drivers/net/wireless/rsi/rsi_91x_hal.c

1012

u16 block_size = adapter->block_size;

drivers/net/wireless/rsi/rsi_91x_hal.c

1082

block_size,

drivers/net/wireless/rsi/rsi_91x_hal.c

1100

block_size,

drivers/net/wireless/rsi/rsi_91x_hal.c

718

u32 block_size = adapter->block_size;

drivers/net/wireless/rsi/rsi_91x_hal.c

737

block_size, addr);

drivers/net/wireless/rsi/rsi_91x_sdio.c

365

adapter->block_size = dev->pfunction->max_blksize;

drivers/net/wireless/rsi/rsi_91x_sdio.c

559

u16 block_size,

drivers/net/wireless/rsi/rsi_91x_sdio.c

567

num_blocks = instructions_sz / block_size;

drivers/net/wireless/rsi/rsi_91x_sdio.c

573

temp_buf = kmalloc(block_size, GFP_KERNEL);

drivers/net/wireless/rsi/rsi_91x_sdio.c

584

for (offset = 0, i = 0; i < num_blocks; i++, offset += block_size) {

drivers/net/wireless/rsi/rsi_91x_sdio.c

585

memcpy(temp_buf, ta_firmware + offset, block_size);

drivers/net/wireless/rsi/rsi_91x_sdio.c

590

temp_buf, block_size);

drivers/net/wireless/rsi/rsi_91x_sdio.c

596

base_address += block_size;

drivers/net/wireless/rsi/rsi_91x_sdio.c

613

if (instructions_sz % block_size) {

drivers/net/wireless/rsi/rsi_91x_sdio.c

614

memset(temp_buf, 0, block_size);

drivers/net/wireless/rsi/rsi_91x_sdio.c

616

instructions_sz % block_size);

drivers/net/wireless/rsi/rsi_91x_sdio.c

622

instructions_sz % block_size);

drivers/net/wireless/rsi/rsi_91x_sdio.c

758

u32 block_size = dev->tx_blk_size;

drivers/net/wireless/rsi/rsi_91x_sdio.c

767

num_blocks = len / block_size;

drivers/net/wireless/rsi/rsi_91x_sdio.c

769

if (len % block_size)

drivers/net/wireless/rsi/rsi_91x_sdio.c

772

address = (num_blocks * block_size | (queueno << 12));

drivers/net/wireless/rsi/rsi_91x_sdio.c

773

length = num_blocks * block_size;

drivers/net/wireless/rsi/rsi_91x_usb.c

505

u32 instructions_sz, u16 block_size,

drivers/net/wireless/rsi/rsi_91x_usb.c

513

num_blocks = instructions_sz / block_size;

drivers/net/wireless/rsi/rsi_91x_usb.c

516

for (cur_indx = 0, i = 0; i < num_blocks; i++, cur_indx += block_size) {

drivers/net/wireless/rsi/rsi_91x_usb.c

517

memcpy(temp_buf, ta_firmware + cur_indx, block_size);

drivers/net/wireless/rsi/rsi_91x_usb.c

520

block_size);

drivers/net/wireless/rsi/rsi_91x_usb.c

525

base_address += block_size;

drivers/net/wireless/rsi/rsi_91x_usb.c

528

if (instructions_sz % block_size) {

drivers/net/wireless/rsi/rsi_91x_usb.c

529

memset(temp_buf, 0, block_size);

drivers/net/wireless/rsi/rsi_91x_usb.c

531

instructions_sz % block_size);

drivers/net/wireless/rsi/rsi_91x_usb.c

535

instructions_sz % block_size);

drivers/net/wireless/rsi/rsi_91x_usb.c

652

adapter->block_size = rsi_dev->tx_blk_size;

drivers/net/wireless/rsi/rsi_main.h

365

u16 block_size;

drivers/net/wireless/rsi/rsi_main.h

404

u32 instructions_size, u16 block_size,

drivers/net/wireless/st/cw1200/fwio.c

182

size_t block_size;

drivers/net/wireless/st/cw1200/fwio.c

208

tx_size = block_size = min_t(size_t, firmware->size - put,

drivers/net/wireless/st/cw1200/fwio.c

211

memcpy(buf, &firmware->data[put], block_size);

drivers/net/wireless/st/cw1200/fwio.c

212

if (block_size < DOWNLOAD_BLOCK_SIZE) {

drivers/net/wireless/st/cw1200/fwio.c

213

memset(&buf[block_size], 0,

drivers/net/wireless/st/cw1200/fwio.c

214

DOWNLOAD_BLOCK_SIZE - block_size);

drivers/net/wireless/st/cw1200/fwio.c

230

put += block_size;

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

116

u64 block_size :8;

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

344

pd_info->pp_block_size = pd_info->pp_header.block_size;

drivers/s390/block/dasd_diag.c

114

iib->block_size = blocksize;

drivers/s390/block/dasd_diag.c

443

bsize = (unsigned int) label->block_size;

drivers/s390/block/dasd_diag.h

60

u32 block_size;

drivers/s390/char/sclp_mem.c

192

unsigned long addr, block_size;

drivers/s390/char/sclp_mem.c

203

block_size = memory_block_size_bytes();

drivers/s390/char/sclp_mem.c

204

addr = sclp_mem->id * block_size;

drivers/s390/char/sclp_mem.c

218

rc = sclp_mem_change_state(addr, block_size, 1);

drivers/s390/char/sclp_mem.c

226

__arch_set_page_nodat((void *)__va(addr), block_size >> PAGE_SHIFT);

drivers/s390/char/sclp_mem.c

227

rc = __add_memory(0, addr, block_size,

drivers/s390/char/sclp_mem.c

231

sclp_mem_change_state(addr, block_size, 0);

drivers/s390/char/sclp_mem.c

248

sclp_mem_change_state(addr, block_size, 0);

drivers/s390/char/sclp_mem.c

249

__remove_memory(addr, block_size);

drivers/s390/char/sclp_mem.c

255

end = start + (block_size >> KASAN_SHADOW_SCALE_SHIFT);

drivers/s390/char/sclp_mem.c

282

unsigned long block_size;

drivers/s390/char/sclp_mem.c

295

block_size = memory_block_size_bytes();

drivers/s390/char/sclp_mem.c

297

mem = find_memory_block(pfn_to_section_nr(PFN_DOWN(sclp_mem->id * block_size)));

drivers/s390/char/sclp_mem.c

375

unsigned long start, size, addr, block_size;

drivers/s390/char/sclp_mem.c

392

block_size = memory_block_size_bytes();

drivers/s390/char/sclp_mem.c

393

align_to_block_size(&start, &size, block_size);

drivers/s390/char/sclp_mem.c

396

for (addr = start; addr < start + size; addr += block_size) {

drivers/s390/char/sclp_mem.c

397

id = addr / block_size;

drivers/s390/char/sclp_mem.c

425

const unsigned long block_size = memory_block_size_bytes();

drivers/s390/char/sclp_mem.c

432

max_sclp_mems = roundup(sclp.rnmax * sclp.rzm, block_size) / block_size;

drivers/s390/char/tape.h

171

int block_size; /* of size block_size. */

drivers/s390/char/tape_char.c

116

if (device->char_data.block_size != 0) {

drivers/s390/char/tape_char.c

117

if (count < device->char_data.block_size) {

drivers/s390/char/tape_char.c

122

block_size = device->char_data.block_size;

drivers/s390/char/tape_char.c

124

block_size = count;

drivers/s390/char/tape_char.c

127

rc = tape_check_idalbuffer(device, block_size);

drivers/s390/char/tape_char.c

131

DBF_EVENT(6, "TCHAR:nbytes: %lx\n", block_size);

drivers/s390/char/tape_char.c

174

size_t block_size;

drivers/s390/char/tape_char.c

181

if (device->char_data.block_size != 0) {

drivers/s390/char/tape_char.c

182

if (count < device->char_data.block_size) {

drivers/s390/char/tape_char.c

187

block_size = device->char_data.block_size;

drivers/s390/char/tape_char.c

188

nblocks = count / block_size;

drivers/s390/char/tape_char.c

190

block_size = count;

drivers/s390/char/tape_char.c

194

rc = tape_check_idalbuffer(device, block_size);

drivers/s390/char/tape_char.c

198

DBF_EVENT(6, "TCHAR:nbytes: %lx\n", block_size);

drivers/s390/char/tape_char.c

393

((device->char_data.block_size << MT_ST_BLKSIZE_SHIFT)

drivers/s390/char/tape_char.c

99

size_t block_size;

drivers/s390/char/tape_core.c

163

return sysfs_emit(buf, "%i\n", tdev->char_data.block_size);

drivers/s390/char/tape_proc.c

60

if (device->char_data.block_size == 0)

drivers/s390/char/tape_proc.c

63

seq_printf(m, "%i\t", device->char_data.block_size);

drivers/s390/char/tape_std.c

192

device->char_data.block_size = 0;

drivers/s390/char/tape_std.c

200

device->char_data.block_size = count;

drivers/s390/char/tape_std.c

201

DBF_LH(6, "new blocksize is %d\n", device->char_data.block_size);

drivers/s390/char/tape_std.c

213

device->char_data.block_size = 0;

drivers/scsi/aacraid/aachba.c

1244

dev->fsa_dev[scmd_id(cmd)].block_size);

drivers/scsi/aacraid/aachba.c

1260

dev->fsa_dev[scmd_id(cmd)].block_size);

drivers/scsi/aacraid/aachba.c

1334

dev->fsa_dev[scmd_id(cmd)].block_size);

drivers/scsi/aacraid/aachba.c

1372

dev->fsa_dev[scmd_id(cmd)].block_size);

drivers/scsi/aacraid/aachba.c

1391

dev->fsa_dev[scmd_id(cmd)].block_size);

drivers/scsi/aacraid/aachba.c

1468

dev->fsa_dev[scmd_id(cmd)].block_size);

drivers/scsi/aacraid/aachba.c

2985

cp[8] = (fsa_dev_ptr[cid].block_size >> 24) & 0xff;

drivers/scsi/aacraid/aachba.c

2986

cp[9] = (fsa_dev_ptr[cid].block_size >> 16) & 0xff;

drivers/scsi/aacraid/aachba.c

2987

cp[10] = (fsa_dev_ptr[cid].block_size >> 8) & 0xff;

drivers/scsi/aacraid/aachba.c

2988

cp[11] = (fsa_dev_ptr[cid].block_size) & 0xff;

drivers/scsi/aacraid/aachba.c

3023

cp[4] = (fsa_dev_ptr[cid].block_size >> 24) & 0xff;

drivers/scsi/aacraid/aachba.c

3024

cp[5] = (fsa_dev_ptr[cid].block_size >> 16) & 0xff;

drivers/scsi/aacraid/aachba.c

3025

cp[6] = (fsa_dev_ptr[cid].block_size >> 8) & 0xff;

drivers/scsi/aacraid/aachba.c

3026

cp[7] = (fsa_dev_ptr[cid].block_size) & 0xff;

drivers/scsi/aacraid/aachba.c

3065

(fsa_dev_ptr[cid].block_size >> 16) & 0xff;

drivers/scsi/aacraid/aachba.c

3067

(fsa_dev_ptr[cid].block_size >> 8) & 0xff;

drivers/scsi/aacraid/aachba.c

3069

fsa_dev_ptr[cid].block_size & 0xff;

drivers/scsi/aacraid/aachba.c

3152

(fsa_dev_ptr[cid].block_size >> 16) & 0xff;

drivers/scsi/aacraid/aachba.c

3154

(fsa_dev_ptr[cid].block_size >> 8) & 0xff;

drivers/scsi/aacraid/aachba.c

3156

fsa_dev_ptr[cid].block_size & 0xff;

drivers/scsi/aacraid/aachba.c

659

dresp->mnt[0].fileinfo.bdevinfo.block_size = 0x200;

drivers/scsi/aacraid/aachba.c

660

fsa_dev_ptr->block_size = 0x200;

drivers/scsi/aacraid/aachba.c

662

fsa_dev_ptr->block_size =

drivers/scsi/aacraid/aachba.c

663

le32_to_cpu(dresp->mnt[0].fileinfo.bdevinfo.block_size);

drivers/scsi/aacraid/aacraid.h

1284

u32 block_size;

drivers/scsi/aacraid/aacraid.h

2148

__le32 block_size;

drivers/scsi/aacraid/aacraid.h

335

u16 block_size; /* sector size in bytes */

drivers/scsi/elx/libefc_sli/sli4.h

2781

__le16 block_size;

drivers/scsi/esas2r/atvda.h

195

u32 block_size;

drivers/scsi/esas2r/atvda.h

292

u32 block_size;

drivers/scsi/esas2r/atvda.h

355

u32 block_size;

drivers/scsi/esas2r/atvda.h

469

u32 block_size;

drivers/scsi/esas2r/esas2r.h

637

u32 block_size;

drivers/scsi/esas2r/esas2r.h

733

u32 block_size;

drivers/scsi/esas2r/esas2r_disc.c

1110

dc->block_size = luevt->id.tgtlun_raid.dwblock_size;

drivers/scsi/esas2r/esas2r_disc.c

1113

dc->block_size = 0;

drivers/scsi/esas2r/esas2r_disc.c

656

dc->block_size = le32_to_cpu(grpinfo->block_size);

drivers/scsi/esas2r/esas2r_io.c

596

sgc->length = startlba * t->block_size;

drivers/scsi/esas2r/esas2r_main.c

1353

d->block_size = le32_to_cpu(d->block_size);

drivers/scsi/esas2r/esas2r_main.c

1381

g->block_size = le32_to_cpu(g->block_size);

drivers/scsi/esas2r/esas2r_main.c

1401

p->block_size = le32_to_cpu(p->block_size);

drivers/scsi/esas2r/esas2r_targdb.c

146

|| dc->block_size == 0) {

drivers/scsi/esas2r/esas2r_targdb.c

156

t->block_size = dc->block_size;

drivers/scsi/esas2r/esas2r_targdb.c

158

t->inter_block = dc->interleave / dc->block_size;

drivers/scsi/esas2r/esas2r_targdb.c

205

t->block_size = 0;

drivers/scsi/hpsa_cmd.h

724

__le16 block_size; /* sector size in bytes */

drivers/scsi/ps3rom.c

44

u32 block_size;

drivers/scsi/ps3rom.c

99

atapi_cmnd.block_size = 1; /* transfer size is block_size * blocks */

drivers/scsi/qla2xxx/qla_fw.h

1620

__le32 block_size;

drivers/scsi/qla2xxx/qla_sup.c

1004

ha->fdt_block_size = le32_to_cpu(fdt->block_size);

drivers/scsi/qla2xxx/tcm_qla2xxx.c

422

cmd->blk_sz = se_cmd->se_dev->dev_attrib.block_size;

drivers/scsi/qla2xxx/tcm_qla2xxx.c

687

cmd->blk_sz = se_cmd->se_dev->dev_attrib.block_size;

drivers/scsi/qla4xxx/ql4_fw.h

311

uint32_t block_size;

drivers/scsi/qla4xxx/ql4_nx.c

3847

hw->fdt_block_size = le32_to_cpu(fdt->block_size);

drivers/scsi/smartpqi/smartpqi.h

1522

__le16 block_size; /* sector size in bytes */

drivers/scsi/st.c

1127

STp->block_size = 0;

drivers/scsi/st.c

1178

STp->block_size = ST_DEFAULT_BLOCK; /* Educated guess (?) */

drivers/scsi/st.c

1192

STp->block_size = (STp->buffer)->b_data[9] * 65536 +

drivers/scsi/st.c

1214

if (STp->block_size > 0)

drivers/scsi/st.c

1216

(STp->buffer)->buffer_size / STp->block_size;

drivers/scsi/st.c

1222

STp->block_size, (STp->buffer)->buffer_size,

drivers/scsi/st.c

1557

if (STp->block_size == 0 && STp->max_block > 0 &&

drivers/scsi/st.c

1605

if (STp->block_size)

drivers/scsi/st.c

1606

bufsize = STp->block_size > st_fixed_buffer_size ?

drivers/scsi/st.c

1607

STp->block_size : st_fixed_buffer_size;

drivers/scsi/st.c

1624

if (STp->block_size)

drivers/scsi/st.c

1625

STbp->buffer_blocks = bufsize / STp->block_size;

drivers/scsi/st.c

1672

if (STp->block_size != 0 && (count % STp->block_size) != 0) {

drivers/scsi/st.c

1731

if (STp->block_size != 0 &&

drivers/scsi/st.c

1747

cmd[1] = (STp->block_size != 0);

drivers/scsi/st.c

1758

if (STp->block_size == 0)

drivers/scsi/st.c

1761

do_count = STbp->buffer_blocks * STp->block_size -

drivers/scsi/st.c

1776

async_write = STp->block_size == 0 && !STbp->do_dio &&

drivers/scsi/st.c

1779

if (STp->block_size != 0 && STm->do_buffer_writes &&

drivers/scsi/st.c

1789

if (STp->block_size == 0)

drivers/scsi/st.c

1796

blks /= STp->block_size;

drivers/scsi/st.c

1797

transfer = blks * STp->block_size;

drivers/scsi/st.c

1827

else if (STp->block_size == 0 &&

drivers/scsi/st.c

1832

if (STp->block_size != 0)

drivers/scsi/st.c

1833

undone *= STp->block_size;

drivers/scsi/st.c

1839

if (STp->block_size)

drivers/scsi/st.c

1840

blks = (transfer - undone) / STp->block_size;

drivers/scsi/st.c

1846

if (STp->block_size == 0 ||

drivers/scsi/st.c

1861

STp->block_size;

drivers/scsi/st.c

1891

if (STp->block_size == 0)

drivers/scsi/st.c

1948

if (STp->block_size == 0)

drivers/scsi/st.c

1953

bytes = blks * STp->block_size;

drivers/scsi/st.c

1958

blks = bytes / STp->block_size;

drivers/scsi/st.c

1959

bytes = blks * STp->block_size;

drivers/scsi/st.c

1965

cmd[1] = (STp->block_size != 0);

drivers/scsi/st.c

2007

if (STp->block_size == 0)

drivers/scsi/st.c

2014

if (STp->block_size == 0 &&

drivers/scsi/st.c

2026

} else if (STp->block_size == 0) {

drivers/scsi/st.c

2042

STp->block_size;

drivers/scsi/st.c

2058

if (STp->block_size == 0)

drivers/scsi/st.c

2062

bytes - transfer * STp->block_size;

drivers/scsi/st.c

2071

if (STp->block_size == 0)

drivers/scsi/st.c

2075

bytes - transfer * STp->block_size;

drivers/scsi/st.c

2113

if (STp->block_size == 0)

drivers/scsi/st.c

2116

STps->drv_block += STbp->buffer_bytes / STp->block_size;

drivers/scsi/st.c

2144

if (STp->block_size != 0 && (count % STp->block_size) != 0) {

drivers/scsi/st.c

2231

if (STp->block_size == 0)

drivers/scsi/st.c

2963

ltmp = STp->block_size;

drivers/scsi/st.c

3009

STp->block_size = arg & MT_ST_BLKSIZE_MASK;

drivers/scsi/st.c

3010

if (STp->block_size != 0) {

drivers/scsi/st.c

3012

(STp->buffer)->buffer_size / STp->block_size;

drivers/scsi/st.c

3878

((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) |

drivers/scsi/st.c

3882

if (STp->block_size != 0 && mt_status.mt_blkno >= 0) {

drivers/scsi/st.c

3885

(STp->buffer)->buffer_bytes / STp->block_size;

drivers/scsi/st.c

3889

STp->block_size - 1) / STp->block_size;

drivers/scsi/st.c

3920

(STm->do_buffer_writes && STp->block_size != 0) ||

drivers/scsi/st.c

707

if (STp->block_size == 0)

drivers/scsi/st.c

710

STps->drv_block += STbuffer->writing / STp->block_size;

drivers/scsi/st.c

798

blks = transfer / STp->block_size;

drivers/scsi/st.c

863

if (STp->block_size == 0)

drivers/scsi/st.c

867

(STp->buffer)->read_pointer) / STp->block_size -

drivers/scsi/st.c

868

((STp->buffer)->read_pointer + STp->block_size - 1) /

drivers/scsi/st.c

869

STp->block_size;

drivers/scsi/st.c

912

STm->default_blksize != STp->block_size) {

drivers/scsi/st.c

916

arg |= STp->block_size;

drivers/scsi/st.h

175

int block_size;

drivers/spi/spi-amlogic-spisg.c

253

int block_size, blocks;

drivers/spi/spi-amlogic-spisg.c

269

block_size = xfer->bits_per_word >> 3;

drivers/spi/spi-amlogic-spisg.c

270

blocks = xfer->len / block_size;

drivers/spi/spi-amlogic-spisg.c

290

desc->cfg_start |= FIELD_PREP(CFG_BLOCK_SIZE, block_size & 0x7) |

drivers/spi/spi-intel.c

556

size_t block_size, nbytes = op->data.nbytes;

drivers/spi/spi-intel.c

569

block_size = min_t(size_t, nbytes, INTEL_SPI_FIFO_SZ);

drivers/spi/spi-intel.c

572

block_size = min_t(loff_t, addr + block_size,

drivers/spi/spi-intel.c

580

val |= (block_size - 1) << HSFSTS_CTL_FDBC_SHIFT;

drivers/spi/spi-intel.c

600

ret = intel_spi_read_block(ispi, read_buf, block_size);

drivers/spi/spi-intel.c

604

nbytes -= block_size;

drivers/spi/spi-intel.c

605

addr += block_size;

drivers/spi/spi-intel.c

606

read_buf += block_size;

drivers/spi/spi-intel.c

617

size_t block_size, nbytes = op->data.nbytes;

drivers/spi/spi-intel.c

626

block_size = min_t(size_t, nbytes, INTEL_SPI_FIFO_SZ);

drivers/spi/spi-intel.c

629

block_size = min_t(loff_t, addr + block_size,

drivers/spi/spi-intel.c

637

val |= (block_size - 1) << HSFSTS_CTL_FDBC_SHIFT;

drivers/spi/spi-intel.c

640

ret = intel_spi_write_block(ispi, write_buf, block_size);

drivers/spi/spi-intel.c

667

nbytes -= block_size;

drivers/spi/spi-intel.c

668

addr += block_size;

drivers/spi/spi-intel.c

669

write_buf += block_size;

drivers/staging/media/atomisp/pci/isp/kernels/bnlm/ia_css_bnlm.host.c

40

const u32 block_size = 16;

drivers/staging/media/atomisp/pci/isp/kernels/bnlm/ia_css_bnlm.host.c

41

const u32 total_blocks = ISP_VEC_NELEMS / block_size;

drivers/staging/media/atomisp/pci/isp/kernels/bnlm/ia_css_bnlm.host.c

53

assert((lut_size >= 2) && (lut_size <= block_size));

drivers/staging/media/atomisp/pci/isp/kernels/bnlm/ia_css_bnlm.host.c

61

for (i = 0; i < total_blocks * block_size; i++) {

drivers/staging/media/atomisp/pci/isp/kernels/bnlm/ia_css_bnlm.host.c

75

u32 blk_offset = blk * block_size;

drivers/target/target_core_alua.c

462

sectors = cmd->data_length / dev->dev_attrib.block_size;

drivers/target/target_core_configfs.c

1149

da->block_size = val;

drivers/target/target_core_configfs.c

1291

CONFIGFS_ATTR(, block_size);

drivers/target/target_core_configfs.c

565

DEF_CONFIGFS_ATTRIB_SHOW(block_size);

drivers/target/target_core_device.c

510

static u32 se_dev_align_max_sectors(u32 max_sectors, u32 block_size)

drivers/target/target_core_device.c

518

alignment = max(1ul, PAGE_SIZE / block_size);

drivers/target/target_core_device.c

848

int block_size = bdev_logical_block_size(bdev);

drivers/target/target_core_device.c

853

attrib->atomic_max_len = queue_atomic_write_max_bytes(q) / block_size;

drivers/target/target_core_device.c

855

queue_atomic_write_unit_min_bytes(q) / block_size;

drivers/target/target_core_device.c

868

int block_size = bdev_logical_block_size(bdev);

drivers/target/target_core_device.c

874

bdev_max_discard_sectors(bdev) >> (ilog2(block_size) - 9);

drivers/target/target_core_device.c

879

attrib->unmap_granularity = bdev_discard_granularity(bdev) / block_size;

drivers/target/target_core_device.c

881

bdev_discard_alignment(bdev) / block_size;

drivers/target/target_core_device.c

892

switch (dev->dev_attrib.block_size) {

drivers/target/target_core_device.c

999

dev->dev_attrib.block_size = dev->dev_attrib.hw_block_size;

drivers/target/target_core_file.c

293

aio_cmd->iocb.ki_pos = cmd->t_task_lba * dev->dev_attrib.block_size;

drivers/target/target_core_file.c

313

u32 block_size, struct scatterlist *sgl,

drivers/target/target_core_file.c

320

loff_t pos = (cmd->t_task_lba * block_size);

drivers/target/target_core_file.c

405

start = cmd->t_task_lba * dev->dev_attrib.block_size;

drivers/target/target_core_file.c

432

loff_t pos = cmd->t_task_lba * se_dev->dev_attrib.block_size;

drivers/target/target_core_file.c

449

cmd->t_data_sg[0].length != cmd->se_dev->dev_attrib.block_size) {

drivers/target/target_core_file.c

454

cmd->se_dev->dev_attrib.block_size);

drivers/target/target_core_file.c

466

len += se_dev->dev_attrib.block_size;

drivers/target/target_core_file.c

566

loff_t pos = lba * se_dev->dev_attrib.block_size;

drivers/target/target_core_file.c

567

unsigned int len = nolb * se_dev->dev_attrib.block_size;

drivers/target/target_core_file.c

606

ret = fd_do_rw(cmd, file, dev->dev_attrib.block_size,

drivers/target/target_core_file.c

612

ilog2(dev->dev_attrib.block_size);

drivers/target/target_core_file.c

623

ilog2(dev->dev_attrib.block_size);

drivers/target/target_core_file.c

631

ret = fd_do_rw(cmd, file, dev->dev_attrib.block_size,

drivers/target/target_core_file.c

640

dev->dev_attrib.block_size;

drivers/target/target_core_file.c

820

return div_u64(dev_size - dev->dev_attrib.block_size,

drivers/target/target_core_file.c

821

dev->dev_attrib.block_size);

drivers/target/target_core_file.c

864

int unit_size = FDBD_FORMAT_UNIT_SIZE * dev->dev_attrib.block_size;

drivers/target/target_core_iblock.c

240

u32 block_size = bdev_logical_block_size(ib_dev->ibd_bd);

drivers/target/target_core_iblock.c

242

div_u64(bdev_nr_bytes(ib_dev->ibd_bd), block_size) - 1;

drivers/target/target_core_iblock.c

244

if (block_size == dev->dev_attrib.block_size)

drivers/target/target_core_iblock.c

247

switch (block_size) {

drivers/target/target_core_iblock.c

249

switch (dev->dev_attrib.block_size) {

drivers/target/target_core_iblock.c

264

switch (dev->dev_attrib.block_size) {

drivers/target/target_core_iblock.c

279

switch (dev->dev_attrib.block_size) {

drivers/target/target_core_iblock.c

294

switch (dev->dev_attrib.block_size) {

drivers/target/target_core_iblock.c

513

sg->length != cmd->se_dev->dev_attrib.block_size) {

drivers/target/target_core_iblock.c

516

cmd->se_dev->dev_attrib.block_size);

drivers/target/target_core_rd.c

232

static int rd_build_prot_space(struct rd_dev *rd_dev, int prot_length, int block_size)

drivers/target/target_core_rd.c

248

total_sg_needed = (rd_dev->rd_page_count * prot_length / block_size) + 1;

drivers/target/target_core_rd.c

384

u32 sectors = cmd->data_length / se_dev->dev_attrib.block_size;

drivers/target/target_core_rd.c

436

tmp = cmd->t_task_lba * se_dev->dev_attrib.block_size;

drivers/target/target_core_rd.c

622

dev->dev_attrib.block_size) - 1;

drivers/target/target_core_rd.c

635

dev->dev_attrib.block_size);

drivers/target/target_core_sbc.c

1221

unsigned int block_size = dev->dev_attrib.block_size;

drivers/target/target_core_sbc.c

1244

avail = min(block_size, dsg->length - offset);

drivers/target/target_core_sbc.c

1246

if (avail < block_size) {

drivers/target/target_core_sbc.c

1254

offset = block_size - avail;

drivers/target/target_core_sbc.c

1257

offset += block_size;

drivers/target/target_core_sbc.c

1378

unsigned int block_size = dev->dev_attrib.block_size;

drivers/target/target_core_sbc.c

1409

dsg_off += block_size;

drivers/target/target_core_sbc.c

1413

avail = min(block_size, dsg->length - dsg_off);

drivers/target/target_core_sbc.c

1415

if (avail < block_size) {

drivers/target/target_core_sbc.c

1423

dsg_off = block_size - avail;

drivers/target/target_core_sbc.c

1426

dsg_off += block_size;

drivers/target/target_core_sbc.c

218

return cmd->se_dev->dev_attrib.block_size * sectors;

drivers/target/target_core_sbc.c

444

unsigned int block_size = dev->dev_attrib.block_size;

drivers/target/target_core_sbc.c

445

unsigned int compare_len = (cmd->t_task_nolb * block_size);

drivers/target/target_core_sbc.c

518

if (block_size < PAGE_SIZE) {

drivers/target/target_core_sbc.c

519

sg_set_page(&write_sg[i], m.page, block_size,

drivers/target/target_core_sbc.c

520

m.piter.sg->offset + block_size);

drivers/target/target_core_sbc.c

523

sg_set_page(&write_sg[i], m.page, block_size,

drivers/target/target_core_sbc.c

526

len -= block_size;

drivers/target/target_core_sbc.c

588

cmd->data_length = cmd->t_task_nolb * dev->dev_attrib.block_size;

drivers/target/target_core_sbc.c

62

put_unaligned_be32(dev->dev_attrib.block_size, &buf[4]);

drivers/target/target_core_sbc.c

734

cmd->data_length = sectors * dev->dev_attrib.block_size;

drivers/target/target_core_sbc.c

87

put_unaligned_be32(dev->dev_attrib.block_size, &buf[8]);

drivers/target/target_core_spc.c

1015

static int spc_modesense_blockdesc(unsigned char *buf, u64 blocks, u32 block_size)

drivers/target/target_core_spc.c

1020

put_unaligned_be32(block_size, buf);

drivers/target/target_core_spc.c

1024

static int spc_modesense_long_blockdesc(unsigned char *buf, u64 blocks, u32 block_size)

drivers/target/target_core_spc.c

1027

return spc_modesense_blockdesc(buf + 3, blocks, block_size) + 3;

drivers/target/target_core_spc.c

1034

put_unaligned_be32(block_size, buf);

drivers/target/target_core_spc.c

1085

u32 block_size = dev->dev_attrib.block_size;

drivers/target/target_core_spc.c

1090

blocks, block_size);

drivers/target/target_core_spc.c

1094

blocks, block_size);

drivers/target/target_core_spc.c

1098

block_size);

drivers/target/target_core_spc.c

540

put_unaligned_be16(min / dev->dev_attrib.block_size, &buf[6]);

drivers/target/target_core_spc.c

552

dev->dev_attrib.block_size;

drivers/target/target_core_spc.c

556

dev->dev_attrib.block_size);

drivers/target/target_core_spc.c

563

put_unaligned_be32(opt / dev->dev_attrib.block_size, &buf[12]);

drivers/target/target_core_transport.c

1062

dev->dev_attrib.block_size,

drivers/target/target_core_transport.c

1365

u32 sectors = (mtl / dev->dev_attrib.block_size);

drivers/target/target_core_transport.c

2201

sectors = cmd->data_length >> ilog2(cmd->se_dev->dev_attrib.block_size);

drivers/target/target_core_transport.c

2499

ilog2(cmd->se_dev->dev_attrib.block_size);

drivers/target/target_core_transport.c

2820

cmd->se_dev->dev_attrib.block_size;

drivers/target/target_core_transport.c

2842

cmd->se_dev->dev_attrib.block_size;

drivers/target/target_core_user.c

2663

return div_u64(udev->dev_size - dev->dev_attrib.block_size,

drivers/target/target_core_user.c

2664

dev->dev_attrib.block_size);

drivers/target/target_core_xcopy.c

579

u32 transfer_length_block = src_bytes / src_dev->dev_attrib.block_size;

drivers/target/target_core_xcopy.c

624

u32 transfer_length_block = dst_bytes / dst_dev->dev_attrib.block_size;

drivers/target/target_core_xcopy.c

700

max_blocks = max_bytes >> ilog2(src_dev->dev_attrib.block_size);

drivers/target/target_core_xcopy.c

708

u32 cur_bytes = min_t(u64, max_bytes, nolb * src_dev->dev_attrib.block_size);

drivers/target/target_core_xcopy.c

709

unsigned short cur_nolb = cur_bytes / src_dev->dev_attrib.block_size;

drivers/target/target_core_xcopy.c

733

src_lba += cur_bytes / src_dev->dev_attrib.block_size;

drivers/target/target_core_xcopy.c

745

dst_lba += cur_bytes / dst_dev->dev_attrib.block_size;

drivers/target/target_core_xcopy.c

750

nolb -= cur_bytes / src_dev->dev_attrib.block_size;

drivers/target/target_core_xcopy.c

760

copied_bytes / dst_dev->dev_attrib.block_size, copied_bytes);

drivers/target/target_core_xcopy.c

852

if (xop->src_dev->dev_attrib.block_size !=

drivers/target/target_core_xcopy.c

853

xop->dst_dev->dev_attrib.block_size) {

drivers/target/target_core_xcopy.c

856

xop->src_dev->dev_attrib.block_size,

drivers/target/target_core_xcopy.c

857

xop->dst_dev->dev_attrib.block_size);

drivers/tty/serial/8250/8250_lpss.c

196

.block_size = 4095,

drivers/usb/host/xhci.c

2453

unsigned int block_size;

drivers/usb/host/xhci.c

2477

block_size = xhci_get_block_size(virt_dev->udev);

drivers/usb/host/xhci.c

2504

bw_used = DIV_ROUND_UP(bw_table->interval0_esit_payload, block_size) +

drivers/usb/host/xhci.c

2536

block_size);

drivers/video/fbdev/omap2/omapfb/dss/hdmi.h

191

u8 block_size;

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

826

audio_dma.block_size = 0xC0;

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

837

audio_dma.block_size = 0xC0;

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

235

r = FLD_MOD(r, aud_dma->block_size, 7, 0);

drivers/virtio/virtio_mem.c

2848

virtio_cread_le(vm->vdev, struct virtio_mem_config, block_size,

fs/befs/befs.h

145

return BEFS_SB(sb)->block_size / sizeof(befs_disk_inode_addr);

fs/befs/befs.h

34

u32 block_size;

fs/befs/befs_fs_types.h

118

fs32 block_size;

fs/befs/datastream.c

148

plen = ((bytes_read + BEFS_SB(sb)->block_size) < len) ?

fs/befs/datastream.c

149

BEFS_SB(sb)->block_size : len - bytes_read;

fs/befs/datastream.c

182

if (ds->size & (befs_sb->block_size - 1))

fs/befs/datastream.c

208

dbl_bytes / (befs_sb->block_size * BEFS_DBLINDIR_BRUN_LEN);

fs/befs/debug.c

169

befs_debug(sb, " block_size %u", fs32_to_cpu(sb, sup->block_size));

fs/befs/linuxvfs.c

378

inode->i_blocks = befs_sb->block_size / VFS_BLOCK_SIZE;

fs/befs/linuxvfs.c

389

num_blks * (befs_sb->block_size / VFS_BLOCK_SIZE);

fs/befs/linuxvfs.c

863

sb_set_blocksize(sb, (ulong) befs_sb->block_size);

fs/befs/super.c

34

befs_sb->block_size = fs32_to_cpu(sb, disk_sb->block_size);

fs/befs/super.c

76

if ((befs_sb->block_size != 1024)

fs/befs/super.c

77

&& (befs_sb->block_size != 2048)

fs/befs/super.c

78

&& (befs_sb->block_size != 4096)

fs/befs/super.c

79

&& (befs_sb->block_size != 8192)) {

fs/befs/super.c

80

befs_error(sb, "invalid blocksize: %u", befs_sb->block_size);

fs/befs/super.c

84

if (befs_sb->block_size > PAGE_SIZE) {

fs/befs/super.c

86

"than system pagesize(%lu)", befs_sb->block_size,

fs/befs/super.c

96

if ((1 << befs_sb->block_shift) != befs_sb->block_size) {

fs/btrfs/reflink.c

140

if (datal < block_size)

fs/btrfs/reflink.c

141

folio_zero_range(folio, datal, block_size - datal);

fs/btrfs/reflink.c

143

btrfs_folio_set_uptodate(fs_info, folio, file_offset, block_size);

fs/btrfs/reflink.c

144

btrfs_folio_clear_checked(fs_info, folio, file_offset, block_size);

fs/btrfs/reflink.c

145

btrfs_folio_set_dirty(fs_info, folio, file_offset, block_size);

fs/btrfs/reflink.c

153

block_size, true);

fs/btrfs/reflink.c

154

btrfs_delalloc_release_extents(inode, block_size);

fs/btrfs/reflink.c

63

const u32 block_size = fs_info->sectorsize;

fs/btrfs/reflink.c

64

const u64 range_end = file_offset + block_size - 1;

fs/btrfs/reflink.c

72

ASSERT(IS_ALIGNED(file_offset, block_size));

fs/btrfs/reflink.c

81

block_size);

fs/btrfs/relocation.c

3904

static void parse_bitmap(u64 block_size, const unsigned long *bitmap,

fs/btrfs/relocation.c

3918

run_start = address + (pos * block_size);

fs/btrfs/relocation.c

3919

run_length = (end - pos) * block_size;

fs/ceph/crypto.h

48

__le32 block_size;

fs/ceph/inode.c

2466

header.block_size = cpu_to_le32(CEPH_FSCRYPT_BLOCK_SIZE);

fs/ceph/inode.c

2507

if (header.block_size) {

fs/ceph/ioctl.c

203

dl.block_size = ci->i_layout.stripe_unit;

fs/ceph/ioctl.c

207

dl.block_offset = do_div(tmp, dl.block_size);

fs/ceph/ioctl.h

63

__u64 block_size; /* out: block length */

fs/ecryptfs/keystore.c

591

size_t block_size;

fs/ecryptfs/keystore.c

651

s->block_size = crypto_skcipher_blocksize(s->skcipher_tfm);

fs/ecryptfs/keystore.c

656

if ((s->block_aligned_filename_size % s->block_size) != 0) {

fs/ecryptfs/keystore.c

657

s->num_rand_bytes += (s->block_size

fs/ecryptfs/keystore.c

659

% s->block_size));

fs/ecryptfs/keystore.c

821

size_t block_size;

fs/hfsplus/btree.c

75

u32 hfsplus_calc_btree_clump_size(u32 block_size, u32 node_size,

fs/hfsplus/btree.c

78

u32 mod = max(node_size, block_size);

fs/hfsplus/hfsplus_fs.h

357

u32 hfsplus_calc_btree_clump_size(u32 block_size, u32 node_size, u64 sectors,

fs/iomap/buffered-io.c

275

unsigned block_size = 1 << block_bits;

fs/iomap/buffered-io.c

276

unsigned block_offset = end_pos & (block_size - 1);

fs/iomap/buffered-io.c

294

unsigned block_size = (1 << block_bits);

fs/iomap/buffered-io.c

313

unsigned long block_offset = *pos & (block_size - 1);

fs/iomap/buffered-io.c

795

loff_t block_size = i_blocksize(iter->inode);

fs/iomap/buffered-io.c

796

loff_t block_start = round_down(pos, block_size);

fs/iomap/buffered-io.c

797

loff_t block_end = round_up(pos + len, block_size);

fs/isofs/compress.c

141

block_size);

fs/isofs/compress.c

142

block_size -= stream.avail_in;

fs/isofs/compress.c

49

int i, block_size = block_end - block_start;

fs/isofs/compress.c

54

int needblocks = (block_size + (block_start & bufmask) + bufmask)

fs/isofs/compress.c

61

if (block_size > deflateBound(1UL << zisofs_block_shift)) {

fs/isofs/compress.c

66

if (block_size == 0) {

fs/nfsd/blocklayout.c

102

if (seg->offset & (block_size - 1)) {

fs/nfsd/blocklayout.c

95

u32 i, nr_extents_max, block_size = i_blocksize(inode);

fs/nfsd/blocklayoutxdr.c

153

int *nr_iomapsp, u32 block_size)

fs/nfsd/blocklayoutxdr.c

183

if (bex.foff & (block_size - 1)) {

fs/nfsd/blocklayoutxdr.c

192

if (bex.len & (block_size - 1)) {

fs/nfsd/blocklayoutxdr.c

201

if (bex.soff & (block_size - 1)) {

fs/nfsd/blocklayoutxdr.c

247

int *nr_iomapsp, u32 block_size)

fs/nfsd/blocklayoutxdr.c

272

if (val & (block_size - 1)) {

fs/nfsd/blocklayoutxdr.c

282

if (val & (block_size - 1)) {

fs/nfsd/blocklayoutxdr.h

72

struct iomap **iomapp, int *nr_iomapsp, u32 block_size);

fs/nfsd/blocklayoutxdr.h

74

struct iomap **iomapp, int *nr_iomapsp, u32 block_size);

fs/ntfs3/fsntfs.c

1437

u32 block_size = sb->s_blocksize;

fs/ntfs3/fsntfs.c

1452

u32 op = block_size - off;

fs/ntfs3/lib/lzx_decompress.c

352

u32 block_size;

fs/ntfs3/lib/lzx_decompress.c

364

block_size = LZX_DEFAULT_BLOCK_SIZE;

fs/ntfs3/lib/lzx_decompress.c

366

block_size = 0;

fs/ntfs3/lib/lzx_decompress.c

367

block_size |= bitstream_read_bits(is, 8);

fs/ntfs3/lib/lzx_decompress.c

368

block_size <<= 8;

fs/ntfs3/lib/lzx_decompress.c

369

block_size |= bitstream_read_bits(is, 8);

fs/ntfs3/lib/lzx_decompress.c

466

*block_size_ret = block_size;

fs/ntfs3/lib/lzx_decompress.c

473

int block_type, u32 block_size,

fs/ntfs3/lib/lzx_decompress.c

477

u8 * const block_end = out_next + block_size;

fs/ntfs3/lib/lzx_decompress.c

611

u32 block_size;

fs/ntfs3/lib/lzx_decompress.c

613

if (lzx_read_block_header(d, &is, &block_type, &block_size,

fs/ntfs3/lib/lzx_decompress.c

617

if (block_size < 1 || block_size > (size_t)(out_end - out_next))

fs/ntfs3/lib/lzx_decompress.c

627

block_size,

fs/ntfs3/lib/lzx_decompress.c

634

out_next += block_size;

fs/ntfs3/lib/lzx_decompress.c

639

block_size);

fs/ntfs3/lib/lzx_decompress.c

643

if (block_size & 1)

fs/ntfs3/super.c

1226

u32 block_size = min_t(u32, sector_size, PAGE_SIZE);

fs/ntfs3/super.c

1229

boot_block = lbo >> blksize_bits(block_size);

fs/ntfs3/super.c

1230

boot_off = lbo & (block_size - 1);

fs/ntfs3/super.c

1231

if (boot_block && block_size >= boot_off + sizeof(*boot)) {

fs/ntfs3/super.c

1235

sb_set_blocksize(sb, block_size);

fs/orangefs/downcall.h

45

__s64 block_size;

fs/orangefs/super.c

178

(long)new_op->downcall.resp.statfs.block_size,

fs/orangefs/super.c

185

buf->f_bsize = new_op->downcall.resp.statfs.block_size;

fs/pstore/ram_core.c

129

int ecc_block_size = prz->ecc_info.block_size;

fs/pstore/ram_core.c

172

int size = prz->ecc_info.block_size;

fs/pstore/ram_core.c

183

block += prz->ecc_info.block_size;

fs/pstore/ram_core.c

199

prz->ecc_info.block_size = ecc_info->block_size ?: 128;

fs/pstore/ram_core.c

205

prz->ecc_info.block_size +

fs/pstore/ram_core.c

633

prz->ecc_info.ecc_size, prz->ecc_info.block_size);

fs/squashfs/cache.c

224

int block_size)

fs/squashfs/cache.c

248

cache->block_size = block_size;

fs/squashfs/cache.c

249

cache->pages = block_size >> PAGE_SHIFT;

fs/squashfs/file.c

469

(i_size_read(inode) & (msblk->block_size - 1)) :

fs/squashfs/file.c

470

msblk->block_size;

fs/squashfs/file.c

602

(i_size_read(inode) & (msblk->block_size - 1)) :

fs/squashfs/file.c

603

msblk->block_size;

fs/squashfs/file.c

676

u64 file_end = (i_size_read(inode) + msblk->block_size - 1) >> msblk->block_log;

fs/squashfs/inode.c

154

if ((inode->i_size & (msblk->block_size - 1)) == 0) {

fs/squashfs/inode.c

210

if ((inode->i_size & (msblk->block_size - 1)) == 0) {

fs/squashfs/lz4_wrapper.c

54

int block_size = max_t(int, msblk->block_size, SQUASHFS_METADATA_SIZE);

fs/squashfs/lz4_wrapper.c

60

stream->input = vmalloc(block_size);

fs/squashfs/lz4_wrapper.c

63

stream->output = vmalloc(block_size);

fs/squashfs/lzo_wrapper.c

30

int block_size = max_t(int, msblk->block_size, SQUASHFS_METADATA_SIZE);

fs/squashfs/lzo_wrapper.c

35

stream->input = vmalloc(block_size);

fs/squashfs/lzo_wrapper.c

38

stream->output = vmalloc(block_size);

fs/squashfs/squashfs_fs.h

245

__le32 block_size;

fs/squashfs/squashfs_fs_sb.h

22

int block_size;

fs/squashfs/squashfs_fs_sb.h

62

unsigned int block_size;

fs/squashfs/super.c

264

msblk->block_size = le32_to_cpu(sblk->block_size);

fs/squashfs/super.c

265

if (msblk->block_size > SQUASHFS_FILE_MAX_SIZE)

fs/squashfs/super.c

272

if (PAGE_SIZE > msblk->block_size) {

fs/squashfs/super.c

274

"currently not supported!", msblk->block_size);

fs/squashfs/super.c

284

if (msblk->block_size != (1 << msblk->block_log))

fs/squashfs/super.c

305

TRACE("Block size %d\n", msblk->block_size);

fs/squashfs/super.c

331

SQUASHFS_READ_PAGES, msblk->block_size);

fs/squashfs/super.c

416

min(SQUASHFS_CACHED_FRAGMENTS, fragments), msblk->block_size);

fs/squashfs/super.c

579

buf->f_bsize = msblk->block_size;

fs/squashfs/xz_wrapper.c

69

opts->dict_size = max_t(int, msblk->block_size,

fs/squashfs/zstd_wrapper.c

36

msblk->block_size, SQUASHFS_METADATA_SIZE);

fs/super.c

1651

sb_set_blocksize(sb, block_size(bdev));

fs/ufs/super.c

1036

if (uspi->s_fsize != block_size || uspi->s_sbsize != super_block_size) {

fs/ufs/super.c

1039

block_size = uspi->s_fsize;

fs/ufs/super.c

1041

UFSD("another value of block_size or super_block_size %u, %u\n", block_size, super_block_size);

fs/ufs/super.c

727

unsigned block_size, super_block_size;

fs/ufs/super.c

787

uspi->s_fsize = block_size = 512;

fs/ufs/super.c

797

uspi->s_fsize = block_size = 512;

fs/ufs/super.c

810

uspi->s_fsize = block_size = 1024;

fs/ufs/super.c

821

uspi->s_fsize = block_size = 1024;

fs/ufs/super.c

833

uspi->s_fsize = block_size = 1024;

fs/ufs/super.c

844

uspi->s_fsize = block_size = 1024;

fs/ufs/super.c

859

uspi->s_fsize = block_size = 1024;

fs/ufs/super.c

875

uspi->s_fsize = block_size = 2048;

fs/ufs/super.c

891

uspi->s_fsize = block_size = 1024;

fs/ufs/super.c

907

uspi->s_fsize = block_size = 1024;

fs/ufs/super.c

926

if (!sb_set_blocksize(sb, block_size)) {

fs/ufs/super.c

935

ubh = ubh_bread_uspi(uspi, sb, uspi->s_sbbase + super_block_offset/block_size, super_block_size);

fs/verity/enable.c

107

for (offset = 0; offset < data_size; offset += params->block_size) {

fs/verity/enable.c

111

buffers[-1].filled = min_t(u64, params->block_size,

fs/verity/enable.c

130

params->block_size) {

fs/verity/enable.c

196

desc->log_blocksize = ilog2(arg->block_size);

fs/verity/enable.c

342

if (!is_power_of_2(arg.block_size))

fs/verity/enable.c

36

memset(&cur->data[cur->filled], 0, params->block_size - cur->filled);

fs/verity/enable.c

53

params->block_size);

fs/verity/enable.c

94

buffers[level].data = kzalloc(params->block_size, GFP_KERNEL);

fs/verity/fsverity_private.h

26

unsigned int block_size; /* block size in bytes, e.g. 64 for SHA-256 */

fs/verity/fsverity_private.h

45

unsigned int block_size; /* size of data and tree blocks */

fs/verity/hash_algs.c

109

fsverity_hash_buffer(params->hash_alg, data, params->block_size,

fs/verity/hash_algs.c

117

sha256_update(&ctx.sha256, data, params->block_size);

fs/verity/hash_algs.c

122

sha512_update(&ctx.sha512, data, params->block_size);

fs/verity/hash_algs.c

15

.block_size = SHA256_BLOCK_SIZE,

fs/verity/hash_algs.c

182

BUG_ON(!is_power_of_2(alg->block_size));

fs/verity/hash_algs.c

21

.block_size = SHA512_BLOCK_SIZE,

fs/verity/hash_algs.c

70

padded_salt_size = round_up(salt_size, alg->block_size);

fs/verity/open.c

102

params->block_size, hash_alg->name);

fs/verity/open.c

118

blocks = ((u64)inode->i_size + params->block_size - 1) >> log_blocksize;

fs/verity/open.c

149

if ((params->block_size != PAGE_SIZE && offset > 1 << 23) ||

fs/verity/open.c

217

if (vi->tree_params.block_size != PAGE_SIZE) {

fs/verity/open.c

91

params->block_size = 1 << log_blocksize;

fs/verity/open.c

99

if (params->block_size < 2 * params->digest_size) {

fs/verity/verify.c

205

if (memchr_inv(dblock->data, 0, params->block_size)) {

fs/verity/verify.c

245

(params->block_size - 1);

fs/verity/verify.c

360

ctx->pending_blocks[1].data, params->block_size,

fs/verity/verify.c

383

const unsigned int block_size = params->block_size;

fs/verity/verify.c

386

if (WARN_ON_ONCE(len <= 0 || !IS_ALIGNED(len | offset, block_size)))

fs/verity/verify.c

398

offset += block_size;

fs/verity/verify.c

399

len -= block_size;

fs/xfs/libxfs/xfs_rtrefcount_btree.h

120

unsigned int block_size)

fs/xfs/libxfs/xfs_rtrefcount_btree.h

123

xfs_rtrefcountbt_maxrecs(mp, block_size, false));

fs/xfs/libxfs/xfs_rtrmap_btree.h

131

unsigned int block_size)

fs/xfs/libxfs/xfs_rtrmap_btree.h

134

xfs_rtrmapbt_maxrecs(mp, block_size, false));

include/crypto/sha3.h

120

.ctx.block_size = SHA3_224_BLOCK_SIZE,

include/crypto/sha3.h

136

.ctx.block_size = SHA3_256_BLOCK_SIZE,

include/crypto/sha3.h

152

.ctx.block_size = SHA3_384_BLOCK_SIZE,

include/crypto/sha3.h

168

.ctx.block_size = SHA3_512_BLOCK_SIZE,

include/crypto/sha3.h

213

.ctx.block_size = SHAKE128_BLOCK_SIZE,

include/crypto/sha3.h

228

.ctx.block_size = SHAKE256_BLOCK_SIZE,

include/crypto/sha3.h

62

u8 block_size; /* Block size in bytes */

include/linux/blkdev.h

1723

int bdev_validate_blocksize(struct block_device *bdev, int block_size);

include/linux/blkdev.h

1783

unsigned int block_size(struct block_device *bdev);

include/linux/c2port.h

36

unsigned short block_size; /* flash block size in bytes */

include/linux/dm-bufio.h

30

dm_bufio_client_create(struct block_device *bdev, unsigned int block_size,

include/linux/iio/buffer-dma.h

95

size_t block_size;

include/linux/platform_data/cros_ec_commands.h

5857

uint32_t block_size;

include/linux/platform_data/dma-dw.h

66

u32 block_size;

include/linux/pstore_ram.h

14

int block_size;

include/sound/tas2781-dsp.h

187

unsigned int block_size;

include/target/target_core_base.h

729

u32 block_size;

include/trace/events/fsverity.h

29

__entry->merkle_block = params->block_size;

include/trace/events/fsverity.h

57

__entry->merkle_block = params->block_size;

include/trace/events/fsverity.h

85

__entry->merkle_block = params->block_size;

include/uapi/drm/habanalabs_accel.h

2054

__u32 block_size;

include/uapi/linux/cdrom.h

820

__u32 block_size;

include/uapi/linux/fsverity.h

22

__u32 block_size;

include/uapi/linux/loop.h

79

__u32 block_size;

include/uapi/linux/virtio_mem.h

193

__le64 block_size;

lib/crypto/arm64/sha3.h

16

size_t nblocks, size_t block_size);

lib/crypto/arm64/sha3.h

19

size_t nblocks, size_t block_size)

lib/crypto/arm64/sha3.h

27

block_size);

lib/crypto/arm64/sha3.h

28

data += (nblocks - rem) * block_size;

lib/crypto/arm64/sha3.h

32

sha3_absorb_blocks_generic(state, data, nblocks, block_size);

lib/crypto/s390/sha3.h

14

size_t nblocks, size_t block_size)

lib/crypto/s390/sha3.h

22

switch (block_size) {

lib/crypto/s390/sha3.h

25

data, nblocks * block_size);

lib/crypto/s390/sha3.h

33

data, nblocks * block_size);

lib/crypto/s390/sha3.h

37

data, nblocks * block_size);

lib/crypto/s390/sha3.h

41

data, nblocks * block_size);

lib/crypto/s390/sha3.h

45

sha3_absorb_blocks_generic(state, data, nblocks, block_size);

lib/crypto/sha3.c

183

size_t nblocks, size_t block_size)

lib/crypto/sha3.c

186

for (size_t i = 0; i < block_size; i += 8)

lib/crypto/sha3.c

189

data += block_size;

lib/crypto/sha3.c

202

const size_t block_size = ctx->block_size;

lib/crypto/sha3.c

206

WARN_ON_ONCE(absorb_offset >= block_size);

lib/crypto/sha3.c

208

if (absorb_offset && absorb_offset + in_len >= block_size) {

lib/crypto/sha3.c

210

block_size - absorb_offset);

lib/crypto/sha3.c

211

in += block_size - absorb_offset;

lib/crypto/sha3.c

212

in_len -= block_size - absorb_offset;

lib/crypto/sha3.c

217

if (in_len >= block_size) {

lib/crypto/sha3.c

218

size_t nblocks = in_len / block_size;

lib/crypto/sha3.c

220

sha3_absorb_blocks(&ctx->state, in, nblocks, block_size);

lib/crypto/sha3.c

221

in += nblocks * block_size;

lib/crypto/sha3.c

222

in_len -= nblocks * block_size;

lib/crypto/sha3.c

238

ctx->state.bytes[ctx->block_size - 1] ^= 0x80;

lib/crypto/sha3.c

248

const size_t block_size = ctx->block_size;

lib/crypto/sha3.c

251

if (ctx->absorb_offset < block_size) {

lib/crypto/sha3.c

256

ctx->state.bytes[block_size - 1] ^= 0x80;

lib/crypto/sha3.c

259

ctx->absorb_offset = block_size;

lib/crypto/sha3.c

265

squeeze_offset = block_size;

lib/crypto/sha3.c

268

if (squeeze_offset == block_size) {

lib/crypto/sha3.c

272

size_t copy = min(out_len, block_size - squeeze_offset);

lib/zlib_dfltcc/dfltcc.h

106

uLong block_size; /* New block each X bytes */

lib/zlib_dfltcc/dfltcc_deflate.c

191

strm->total_in + dfltcc_state->block_size;

lib/zlib_dfltcc/dfltcc_deflate.c

208

if (no_flush && strm->avail_in > dfltcc_state->block_size) {

lib/zlib_dfltcc/dfltcc_deflate.c

209

masked_avail_in += (strm->avail_in - dfltcc_state->block_size);

lib/zlib_dfltcc/dfltcc_deflate.c

210

strm->avail_in = dfltcc_state->block_size;

lib/zlib_dfltcc/dfltcc_deflate.c

289

strm->total_in + dfltcc_state->block_size;

lib/zlib_dfltcc/dfltcc_deflate.c

53

dfltcc_state->block_size = DFLTCC_BLOCK_SIZE;

net/ethtool/cmis_fw_update.c

180

u32 block_size, lpl_len;

net/ethtool/cmis_fw_update.c

186

block_size = min_t(u32, max_block_size, image_size - offset);

net/ethtool/cmis_fw_update.c

187

memcpy(pl.fw_block, &fw_update->fw->data[offset], block_size);

net/ethtool/cmis_fw_update.c

188

lpl_len = block_size +

sound/atmel/ac97c.c

184

int block_size = frames_to_bytes(runtime, runtime->period_size);

sound/atmel/ac97c.c

255

writel(block_size / 2, chip->regs + ATMEL_PDC_TCR);

sound/atmel/ac97c.c

256

writel(runtime->dma_addr + block_size, chip->regs + ATMEL_PDC_TNPR);

sound/atmel/ac97c.c

257

writel(block_size / 2, chip->regs + ATMEL_PDC_TNCR);

sound/atmel/ac97c.c

266

int block_size = frames_to_bytes(runtime, runtime->period_size);

sound/atmel/ac97c.c

337

writel(block_size / 2, chip->regs + ATMEL_PDC_RCR);

sound/atmel/ac97c.c

338

writel(runtime->dma_addr + block_size, chip->regs + ATMEL_PDC_RNPR);

sound/atmel/ac97c.c

339

writel(block_size / 2, chip->regs + ATMEL_PDC_RNCR);

sound/atmel/ac97c.c

470

int offset, next_period, block_size;

sound/atmel/ac97c.c

480

block_size = frames_to_bytes(runtime, runtime->period_size);

sound/atmel/ac97c.c

489

offset = block_size * next_period;

sound/atmel/ac97c.c

492

writel(block_size / 2, chip->regs + ATMEL_PDC_TNCR);

sound/atmel/ac97c.c

498

block_size = frames_to_bytes(runtime, runtime->period_size);

sound/atmel/ac97c.c

507

offset = block_size * next_period;

sound/atmel/ac97c.c

510

writel(block_size / 2, chip->regs + ATMEL_PDC_RNCR);

sound/isa/gus/gus_pcm.c

116

curr = begin + (pcmp->bpos * pcmp->block_size) / runtime->channels;

sound/isa/gus/gus_pcm.c

117

end = curr + (pcmp->block_size / runtime->channels);

sound/isa/gus/gus_pcm.c

201

end = pcmp->memory + (((pcmp->bpos + 1) * pcmp->block_size) / runtime->channels);

sound/isa/gus/gus_pcm.c

232

end = pcmp->bpos * pcmp->block_size;

sound/isa/gus/gus_pcm.c

234

snd_gf1_pcm_block_change(pcmp->substream, end, pcmp->memory + (end / 2), pcmp->block_size / 2);

sound/isa/gus/gus_pcm.c

235

snd_gf1_pcm_block_change(pcmp->substream, end + (pcmp->block_size / 2), pcmp->memory + (pcmp->dma_size / 2) + (end / 2), pcmp->block_size / 2);

sound/isa/gus/gus_pcm.c

237

snd_gf1_pcm_block_change(pcmp->substream, end, pcmp->memory + end, pcmp->block_size);

sound/isa/gus/gus_pcm.c

42

unsigned int block_size;

sound/isa/gus/gus_pcm.c

459

pcmp->block_size = snd_pcm_lib_period_bytes(substream);

sound/isa/gus/gus_pcm.c

460

pcmp->blocks = pcmp->dma_size / pcmp->block_size;

sound/oss/dmasound/dmasound.h

217

int block_size; /* internal block size in bytes */

sound/oss/dmasound/dmasound_atari.c

1178

: write_sq.block_size);

sound/oss/dmasound/dmasound_atari.c

1218

write_sq.rear_size < write_sq.block_size &&

sound/oss/dmasound/dmasound_atari.c

1233

write_sq.rear_size < write_sq.block_size &&

sound/oss/dmasound/dmasound_atari.c

1248

write_sq.rear_size < write_sq.block_size &&

sound/oss/dmasound/dmasound_core.c

1306

"write", write_sq.max_count, write_sq.block_size,

sound/oss/dmasound/dmasound_core.c

479

sq->block_size = sq->bufSize;

sound/oss/dmasound/dmasound_core.c

489

sq->block_size = sq->user_frag_size ;

sound/oss/dmasound/dmasound_core.c

490

sq->block_size *=

sound/oss/dmasound/dmasound_core.c

492

sq->block_size /=

sound/oss/dmasound/dmasound_core.c

495

sq->block_size *= dmasound.hard.speed ;

sound/oss/dmasound/dmasound_core.c

496

sq->block_size /= dmasound.soft.speed ;

sound/oss/dmasound/dmasound_core.c

500

sq->block_size += (hard_frame - 1) ;

sound/oss/dmasound/dmasound_core.c

501

sq->block_size &= ~(hard_frame - 1) ; /* make sure we are aligned */

sound/oss/dmasound/dmasound_core.c

503

if ( sq->block_size <= 0 || sq->block_size > sq->bufSize) {

sound/oss/dmasound/dmasound_core.c

507

sq->block_size = sq->bufSize ;

sound/oss/dmasound/dmasound_core.c

602

(bLeft = write_sq.block_size-write_sq.rear_size) > 0) {

sound/oss/dmasound/dmasound_core.c

646

bLeft = write_sq.block_size;

sound/oss/dmasound/dmasound_core.c

679

if (write_sq.count < write_sq.max_active || write_sq.block_size - write_sq.rear_size > 0)

sound/oss/dmasound/dmasound_paula.c

472

: write_sq.block_size)>>1;

sound/oss/dmasound/dmasound_paula.c

543

write_sq.rear_size < write_sq.block_size && !write_sq.syncing) {

sound/oss/dmasound/dmasound_paula.c

648

write_sq_block_size_half = write_sq.block_size>>1;

sound/oss/dmasound/dmasound_q40.c

412

size = (write_sq.count == index ? write_sq.rear_size : write_sq.block_size);

sound/oss/dmasound/dmasound_q40.c

448

if (write_sq.count <= 1 && write_sq.rear_size < write_sq.block_size && !write_sq.syncing) {

sound/soc/codecs/pcm6240.c

1302

bk_da[i]->block_size =

sound/soc/codecs/pcm6240.c

1311

if (config_offset + bk_da[i]->block_size > config_size) {

sound/soc/codecs/pcm6240.c

1320

bk_da[i]->block_size, GFP_KERNEL);

sound/soc/codecs/pcm6240.c

1325

config_offset += bk_da[i]->block_size;

sound/soc/codecs/pcm6240.c

1864

blk_data[j]->block_size - length);

sound/soc/codecs/pcm6240.c

1866

if (blk_data[j]->block_size < length) {

sound/soc/codecs/pcm6240.c

1870

blk_data[j]->block_size);

sound/soc/codecs/pcm6240.c

1874

if (length != blk_data[j]->block_size)

sound/soc/codecs/pcm6240.c

1876

__func__, length, blk_data[j]->block_size);

sound/soc/codecs/pcm6240.h

192

unsigned int block_size;

sound/soc/codecs/tas2781-fmwlib.c

1058

blk_data[j]->block_size - length);

sound/soc/codecs/tas2781-fmwlib.c

1060

if (blk_data[j]->block_size < length) {

sound/soc/codecs/tas2781-fmwlib.c

1064

blk_data[j]->block_size);

sound/soc/codecs/tas2781-fmwlib.c

1068

if (length != blk_data[j]->block_size)

sound/soc/codecs/tas2781-fmwlib.c

1070

__func__, length, blk_data[j]->block_size);

sound/soc/codecs/tas2781-fmwlib.c

269

bk_da[i]->block_size =

sound/soc/codecs/tas2781-fmwlib.c

278

if (config_offset + bk_da[i]->block_size > config_size) {

sound/soc/codecs/tas2781-fmwlib.c

287

bk_da[i]->block_size, GFP_KERNEL);

sound/soc/codecs/tas2781-fmwlib.c

293

config_offset += bk_da[i]->block_size;

sound/soc/intel/avs/topology.c

1006

u32 block_size)

sound/soc/intel/avs/topology.c

1019

block_size -= le32_to_cpu(tuples->size);

sound/soc/intel/avs/topology.c

102

u32 block_size, u32 entry_id_token, u32 *size)

sound/soc/intel/avs/topology.c

1027

ret = avs_tplg_vendor_entry_size(tuples, block_size,

sound/soc/intel/avs/topology.c

1036

block_size -= esize;

sound/soc/intel/avs/topology.c

106

ret = avs_tplg_vendor_array_lookup_next(tuples, block_size, entry_id_token, size);

sound/soc/intel/avs/topology.c

1078

u32 block_size)

sound/soc/intel/avs/topology.c

108

*size = block_size;

sound/soc/intel/avs/topology.c

1083

return parse_dictionary(comp, tuples, block_size, (void **)&tplg->pplcfgs,

sound/soc/intel/avs/topology.c

1143

u32 block_size)

sound/soc/intel/avs/topology.c

1148

return parse_dictionary(comp, tuples, block_size, (void **)&tplg->bindings,

sound/soc/intel/avs/topology.c

1223

struct snd_soc_tplg_vendor_array *tuples, u32 block_size)

sound/soc/intel/avs/topology.c

1230

ret = avs_tplg_vendor_entry_size(tuples, block_size,

sound/soc/intel/avs/topology.c

1244

block_size -= esize;

sound/soc/intel/avs/topology.c

1246

if (block_size) {

sound/soc/intel/avs/topology.c

1259

ret = parse_dictionary_entries(comp, tuples, block_size,

sound/soc/intel/avs/topology.c

1308

struct snd_soc_tplg_vendor_array *tuples, u32 block_size)

sound/soc/intel/avs/topology.c

1322

ret = avs_tplg_vendor_array_lookup(tuples, block_size,

sound/soc/intel/avs/topology.c

1335

block_size -= offset;

sound/soc/intel/avs/topology.c

1339

ret = avs_tplg_vendor_array_lookup_next(tuples, block_size,

sound/soc/intel/avs/topology.c

1349

modblk_size = block_size;

sound/soc/intel/avs/topology.c

1359

block_size -= modblk_size;

sound/soc/intel/avs/topology.c

1382

ret = parse_dictionary_entries(comp, tuples, block_size, pipeline->bindings,

sound/soc/intel/avs/topology.c

1436

struct snd_soc_tplg_vendor_array *tuples, u32 block_size,

sound/soc/intel/avs/topology.c

1453

ret = avs_tplg_vendor_array_lookup(tuples, block_size,

sound/soc/intel/avs/topology.c

1456

offset = block_size;

sound/soc/intel/avs/topology.c

1467

block_size -= offset;

sound/soc/intel/avs/topology.c

1469

while (block_size > 0) {

sound/soc/intel/avs/topology.c

1472

ret = avs_tplg_vendor_entry_size(tuples, block_size,

sound/soc/intel/avs/topology.c

1485

block_size -= esize;

sound/soc/intel/avs/topology.c

1535

struct snd_soc_tplg_vendor_array *tuples, u32 block_size,

sound/soc/intel/avs/topology.c

1545

ret = avs_tplg_vendor_array_lookup(tuples, block_size,

sound/soc/intel/avs/topology.c

1555

block_size -= offset;

sound/soc/intel/avs/topology.c

1560

ret = avs_tplg_vendor_entry_size(tuples, block_size,

sound/soc/intel/avs/topology.c

1573

block_size -= esize;

sound/soc/intel/avs/topology.c

1575

} while (block_size > 0);

sound/soc/intel/avs/topology.c

1582

struct snd_soc_tplg_vendor_array *tuples, u32 block_size)

sound/soc/intel/avs/topology.c

1595

ret = parse_path_template(comp, tuples, block_size, template, path_tmpl_parsers,

sound/soc/intel/avs/topology.c

1606

u32 block_size)

sound/soc/intel/avs/topology.c

1619

block_size -= le32_to_cpu(tuples->size);

sound/soc/intel/avs/topology.c

1632

ret = avs_tplg_vendor_entry_size(tuples, block_size,

sound/soc/intel/avs/topology.c

1647

block_size -= esize;

sound/soc/intel/avs/topology.c

1677

u32 block_size, u32 *offset)

sound/soc/intel/avs/topology.c

1693

block_size -= le32_to_cpu(tuples->size);

sound/soc/intel/avs/topology.c

1698

for (i = 0; i < tplg->num_init_configs && block_size > 0; i++) {

sound/soc/intel/avs/topology.c

1717

block_size -= esize;

sound/soc/intel/avs/topology.c

1729

block_size -= esize;

sound/soc/intel/avs/topology.c

1752

u32 block_size)

sound/soc/intel/avs/topology.c

1766

block_size -= le32_to_cpu(tuples->size);

sound/soc/intel/avs/topology.c

1770

for (i = 0; i < tplg->num_nhlt_configs && block_size > 0; i++) {

sound/soc/intel/avs/topology.c

1792

block_size -= esize;

sound/soc/intel/avs/topology.c

2162

size_t block_size;

sound/soc/intel/avs/topology.c

2175

block_size = le32_to_cpu(tmc->priv.size);

sound/soc/intel/avs/topology.c

2181

ret = parse_dictionary_entries(comp, tuples, block_size, ctl_data, 1, sizeof(*ctl_data),

sound/soc/intel/avs/topology.c

37

u32 block_size, u32 token, u32 *offset)

sound/soc/intel/avs/topology.c

41

while (block_size > 0) {

sound/soc/intel/avs/topology.c

45

if (tuples_size > block_size)

sound/soc/intel/avs/topology.c

466

struct snd_soc_tplg_vendor_array *tuples, u32 block_size,

sound/soc/intel/avs/topology.c

478

ret = avs_tplg_vendor_entry_size(tuples, block_size,

sound/soc/intel/avs/topology.c

491

block_size -= esize;

sound/soc/intel/avs/topology.c

499

struct snd_soc_tplg_vendor_array *tuples, u32 block_size,

sound/soc/intel/avs/topology.c

511

block_size -= le32_to_cpu(tuples->size);

sound/soc/intel/avs/topology.c

515

return parse_dictionary_entries(comp, tuples, block_size, *dict,

sound/soc/intel/avs/topology.c

530

struct snd_soc_tplg_vendor_array *tuples, u32 block_size)

sound/soc/intel/avs/topology.c

535

return parse_dictionary(comp, tuples, block_size, (void **)&tplg->libs,

sound/soc/intel/avs/topology.c

54

block_size -= tuples_size;

sound/soc/intel/avs/topology.c

595

u32 block_size)

sound/soc/intel/avs/topology.c

600

return parse_dictionary(comp, tuples, block_size, (void **)&tplg->fmts,

sound/soc/intel/avs/topology.c

636

u32 block_size)

sound/soc/intel/avs/topology.c

641

return parse_dictionary(comp, tuples, block_size, (void **)&tplg->modcfgs_base,

sound/soc/intel/avs/topology.c

73

u32 block_size, u32 token, u32 *offset)

sound/soc/intel/avs/topology.c

78

if (tuples_size > block_size)

sound/soc/intel/avs/topology.c

82

block_size -= tuples_size;

sound/soc/intel/avs/topology.c

84

ret = avs_tplg_vendor_array_lookup(tuples, block_size, token, offset);

sound/soc/intel/avs/topology.c

957

u32 block_size)

sound/soc/intel/avs/topology.c

963

ret = avs_tplg_vendor_entry_size(tuples, block_size,

sound/soc/intel/avs/topology.c

976

block_size -= esize;

sound/soc/intel/avs/topology.c

978

if (block_size) {

sound/soc/intel/avs/topology.c

991

ret = parse_dictionary_entries(comp, tuples, block_size,

sound/spi/at73c213.c

254

int block_size;

sound/spi/at73c213.c

256

block_size = frames_to_bytes(runtime, runtime->period_size);

sound/spi/at73c213.c

265

(long)runtime->dma_addr + block_size);

sound/spi/at73c213.c

354

int block_size;

sound/spi/at73c213.c

359

block_size = frames_to_bytes(runtime, runtime->period_size);

sound/spi/at73c213.c

370

offset = block_size * next_period;

sound/usb/mixer_scarlett2.c

9267

const size_t block_size = SCARLETT2_DEVMAP_BLOCK_SIZE;

sound/usb/mixer_scarlett2.c

9277

kmalloc(block_size, GFP_KERNEL);

sound/usb/mixer_scarlett2.c

9291

size_t offset = pos % block_size;

sound/usb/mixer_scarlett2.c

9296

block_size,

sound/usb/mixer_scarlett2.c

9303

req = cpu_to_le32(pos / block_size);

tools/bpf/bpftool/prog.c

1176

size_t block_size = 256;

tools/bpf/bpftool/prog.c

1177

size_t buf_size = block_size;

tools/bpf/bpftool/prog.c

1197

*data_ptr = malloc(block_size);

tools/bpf/bpftool/prog.c

1204

while ((nb_read += fread(*data_ptr + nb_read, 1, block_size, f))) {

tools/bpf/bpftool/prog.c

1212

if (nb_read > buf_size - block_size) {

tools/testing/selftests/bpf/prog_tests/fs_kfuncs.c

230

arg.block_size = 4096;

tools/testing/selftests/riscv/hwprobe/cbo.c

120

__u64 block_size;

tools/testing/selftests/riscv/hwprobe/cbo.c

129

block_size = pair.value;

tools/testing/selftests/riscv/hwprobe/cbo.c

131

is_power_of_2(block_size), "Zicbop block size\n");

tools/testing/selftests/riscv/hwprobe/cbo.c

132

ksft_print_msg("Zicbop block size: %llu\n", block_size);

tools/testing/selftests/riscv/hwprobe/cbo.c

158

__u64 block_size;

tools/testing/selftests/riscv/hwprobe/cbo.c

162

block_size = pair.value;

tools/testing/selftests/riscv/hwprobe/cbo.c

164

is_power_of_2(block_size), "Zicbom block size\n");

tools/testing/selftests/riscv/hwprobe/cbo.c

165

ksft_print_msg("Zicbom block size: %llu\n", block_size);

tools/testing/selftests/riscv/hwprobe/cbo.c

168

cbo_clean(&mem[block_size]);

tools/testing/selftests/riscv/hwprobe/cbo.c

172

cbo_flush(&mem[block_size]);

tools/testing/selftests/riscv/hwprobe/cbo.c

182

__u64 block_size;

tools/testing/selftests/riscv/hwprobe/cbo.c

187

block_size = pair.value;

tools/testing/selftests/riscv/hwprobe/cbo.c

189

is_power_of_2(block_size), "Zicboz block size\n");

tools/testing/selftests/riscv/hwprobe/cbo.c

190

ksft_print_msg("Zicboz block size: %llu\n", block_size);

tools/testing/selftests/riscv/hwprobe/cbo.c

193

cbo_zero(&mem[block_size]);

tools/testing/selftests/riscv/hwprobe/cbo.c

196

if (got_fault || !is_power_of_2(block_size)) {

tools/testing/selftests/riscv/hwprobe/cbo.c

201

assert(block_size <= 1024);

tools/testing/selftests/riscv/hwprobe/cbo.c

203

for (i = 0; i < 4096 / block_size; ++i) {

tools/testing/selftests/riscv/hwprobe/cbo.c

205

cbo_zero(&mem[i * block_size]);

tools/testing/selftests/riscv/hwprobe/cbo.c

208

for (i = 0; i < 4096 / block_size; ++i) {

tools/testing/selftests/riscv/hwprobe/cbo.c

211

for (j = 0; j < block_size; ++j) {

tools/testing/selftests/riscv/hwprobe/cbo.c

212

if (mem[i * block_size + j] != expected) {

tools/testing/selftests/riscv/hwprobe/cbo.c

215

i * block_size + j, expected);